13 const BANDS: usize = 32;
14 const COEFFS: usize = 256;
15 const BLOCK_SIZE: usize = 64;
18 pretwiddle1: [f32; COEFFS/2],
19 pretwiddle2: [f32; COEFFS/2],
20 posttwiddle: [FFTComplex; COEFFS/2],
21 tmp: [FFTComplex; COEFFS/2],
23 window: [f32; COEFFS],
27 old_floor: [f32; BANDS],
28 coeffs1: [f32; BANDS], // new floor?
29 coeffs2: [f32; BANDS], // log2 of coeffs1
30 coeffs3: [f32; BANDS],
31 coeffs4: [f32; BANDS],
32 coeffs5: [f32; BANDS],
33 coeffs6: [f32; BANDS],
35 last_im: [f32; COEFFS/2],
39 band_width: [usize; BANDS],
40 band_flag: [bool; BANDS],
41 band_skip: [bool; BANDS],
42 band_bits: [u8; BANDS],
44 band_bitsum: [usize; BANDS],
45 skip_flag: [bool; COEFFS],
46 skip_flag_bits: [u8; BANDS],
47 skips_per_band: [usize; BANDS],
48 keep_flag: [bool; BANDS],
55 old_floor: [0.0; BANDS],
56 coeffs1: [0.0; BANDS],
57 coeffs2: [0.0; BANDS],
58 coeffs3: [0.0; BANDS],
59 coeffs4: [0.0; BANDS],
60 coeffs5: [0.0; BANDS],
61 coeffs6: [0.0; BANDS],
63 last_im: [0.0; COEFFS/2],
67 for i in 0..self.old_floor.len() { self.old_floor[i] = 1.0; }
68 for i in 0..self.cw.len() { self.cw[i] = 0.0; }
72 const BITALLOC_LIMIT: f32 = -1.0e20;
73 const BITALLOC_TOP_LIMIT: f32 = 1.0e20;
77 band_width: [0; BANDS],
78 band_flag: [false; BANDS],
79 band_skip: [false; BANDS],
80 band_bits: [0; BANDS],
82 band_bitsum: [0; BANDS],
83 skip_flag: [false; COEFFS],
84 skip_flag_bits: [0; BANDS],
85 skips_per_band: [0; BANDS],
86 keep_flag: [false; BANDS],
92 self.band_width[i] = 0;
93 self.band_flag[i] = false;
94 self.band_skip[i] = false;
95 self.band_bits[i] = 0;
96 self.keep_flag[i] = false;
97 //self.band_bitsum[i] = 0;
98 self.skips_per_band[i] = 0;
99 self.skip_flag_bits[i] = 0;
102 //self.cw_len[i] = 0;
103 self.skip_flag[i] = false;
106 fn calculate_bit_allocation(&mut self, ch_data: &mut IMCChannel, bits: usize, fixed_head: bool, adj_idx: usize) -> DecoderResult<()> {
109 for coef in ch_data.coeffs1.iter() { if *coef > peak { peak = *coef; } }
112 for band in 0..BANDS-1 {
113 ch_data.coeffs4[band] = ch_data.coeffs3[band] - ch_data.coeffs5[band].log2();
115 ch_data.coeffs4[BANDS - 1] = BITALLOC_LIMIT;
117 for band in 0..BANDS {
119 let band_w = IMC_BANDS[band + 1] - IMC_BANDS[band];
120 if band_w == self.band_width[band] { idx = 0; }
121 if band_w > self.band_width[band] { idx = 1; }
122 if band_w/2 >= self.band_width[band] { idx = 2; }
125 if ch_data.coeffs1[band] < peak { idx += 1; }
126 ch_data.coeffs4[band] += IMC_BITALLOC_ADJ[adj_idx][idx];
131 ch_data.coeffs4[i] = BITALLOC_LIMIT;
135 let start = if fixed_head { 4 } else { 0 };
139 for band in start..BANDS-1 {
140 a_width += self.band_width[band];
141 pool += (self.band_width[band] as f32) * ch_data.coeffs4[band];
143 validate!(a_width > 0);
145 self.band_width[BANDS - 1] = 0;
146 pool = (pool * 0.5 - (bits as f32)) / (a_width as f32);
148 let free_bits = bits as i32;
149 let mut cur_bits: i32 = 0;
152 for i in 0..BANDS/2 {
153 let diff = cur_bits - free_bits;
154 if diff.abs() <= 8 { break; }
158 for band in start..BANDS {
159 let mut len = (ch_data.coeffs4[band] * 0.5 - pool + 0.5) as i32;
160 if len < 0 { len = 0; }
161 if len > 6 { len = 6; }
162 self.band_bits[band] = len as u8;
163 cur_bits += (self.band_width[band] as i32) * (len as i32);
165 acc += self.band_width[band] as i32;
169 let mut lflag = flag;
171 if free_bits < cur_bits { flag = -1; }
172 if i == 0 { lflag = flag; }
176 pool += ((cur_bits - free_bits) as f32) / (((mmcount + 1) * acc) as f32);
179 for band in start..BANDS {
180 for i in IMC_BANDS[band]..IMC_BANDS[band + 1] {
181 self.cw_len[i] = self.band_bits[band];
185 if free_bits > cur_bits {
186 let mut tmp: [f32; BANDS] = [BITALLOC_LIMIT; BANDS];
187 for band in 0..BANDS {
188 if self.band_bits[band] != 6 {
189 tmp[band] = (self.band_bits[band] as f32) * -2.0 + ch_data.coeffs4[band] - 0.415;
193 while (peak > BITALLOC_LIMIT) && (cur_bits < free_bits) {
194 peak = BITALLOC_LIMIT;
195 let mut idx: Option<usize> = None;
196 for band in 0..BANDS {
197 if tmp[band] > peak {
202 if let Some(band) = idx {
204 self.band_bits[band] += 1;
205 if self.band_bits[band] == 6 {
206 tmp[band] = BITALLOC_LIMIT;
208 for i in IMC_BANDS[band]..IMC_BANDS[band + 1] {
211 if cur_bits >= free_bits {
219 if cur_bits > free_bits {
220 let mut tmp: [f32; BANDS] = [BITALLOC_TOP_LIMIT; BANDS];
221 for band in start..BANDS {
222 if self.band_bits[band] != 0 {
223 tmp[band] = (self.band_bits[band] as f32) * -2.0 + ch_data.coeffs4[band] - 0.415 + 2.0;
226 while free_bits < cur_bits {
227 let mut low = BITALLOC_TOP_LIMIT;
229 for band in 0..BANDS {
236 self.band_bits[idx] -= 1;
237 if self.band_bits[idx] == 0 {
238 tmp[idx] = BITALLOC_TOP_LIMIT;
240 for i in IMC_BANDS[idx]..IMC_BANDS[idx + 1] {
241 if self.cw_len[i] > 0 {
244 if cur_bits <= free_bits {
255 fn adjust_bit_allocation(&mut self, ch_data: &mut IMCChannel, free_bits: i32) {
256 let mut tmp: [f32; BANDS] = [BITALLOC_LIMIT; BANDS];
257 for band in 0..BANDS {
258 if self.band_bits[band] != 6 {
259 tmp[band] = (self.band_bits[band] as f32) * -2.0 + ch_data.coeffs4[band] - 0.415;
262 let mut used_bits: i32 = 0;
264 while (peak > BITALLOC_LIMIT) && (used_bits < free_bits) {
265 peak = BITALLOC_LIMIT;
266 let mut idx: Option<usize> = None;
267 for band in 0..BANDS {
268 if tmp[band] > peak {
273 if let Some(band) = idx {
275 self.band_bits[band] += 1;
276 if self.band_bits[band] == 6 {
277 tmp[band] = BITALLOC_LIMIT;
279 for i in IMC_BANDS[band]..IMC_BANDS[band + 1] {
280 if self.cw_len[i] >= 6 { continue; }
283 if used_bits >= free_bits {
300 let mut exp_lev: [f32; 16] = [0.0; 16];
302 exp_lev[lev] = 10.0f32.powf(-(lev as f32) * 0.4375); // almost exp(-lev)
305 let mut exp_10: [f32; 32] = [0.0; 32];
307 exp_10[i] = 10.0f32.powf(((i as f32) - 16.0) * 0.25);
310 let mut sqrt_tab: [f32; 32] = [0.0; 32];
312 sqrt_tab[i] = (i as f32).sqrt();
315 LUTs { exp_lev: exp_lev, exp_10: exp_10, sqrt_tab: sqrt_tab }
324 info: Rc<NACodecInfo>,
326 codes: [[Codebook<u8>; 4]; 4],
327 ch_data: [IMCChannel; 2],
331 cycle1: [usize; BANDS],
332 cycle2: [usize; BANDS],
333 weights1: [f32; BANDS-1],
334 weights2: [f32; BANDS-1],
339 fn freq2bark(freq: f32) -> f32 {
340 3.5 * ((freq / 7500.0) * (freq / 7500.0)).atan() + 13.0 * (freq * 0.00076).atan()
343 fn calc_maxcoef(coef: f32) -> (f32, f32) {
344 let c1 = 20000.0 / 10.0f32.powf(coef * 0.057031251); //2.0f32.powf(coef * 0.18945);
349 fn new(is_imc: bool) -> Self {
350 let mut codes: [[Codebook<u8>; 4]; 4];
351 let mut cycle1: [usize; BANDS] = [0; BANDS];
352 let mut cycle2: [usize; BANDS] = [0; BANDS];
353 let mut weights1: [f32; BANDS-1] = [0.0; BANDS-1];
354 let mut weights2: [f32; BANDS-1] = [0.0; BANDS-1];
356 cycle1.copy_from_slice(&IMC_CYCLE1);
357 cycle2.copy_from_slice(&IMC_CYCLE2);
358 weights1.copy_from_slice(&IMC_WEIGHTS1);
359 weights2.copy_from_slice(&IMC_WEIGHTS2);
362 codes = mem::uninitialized();
365 let mut cr = IMCCodeReader::new(i, j);
366 ptr::write(&mut codes[i][j], Codebook::new(&mut cr, CodebookMode::MSB).unwrap());
372 chmap: NAChannelMap::new(),
373 ainfo: NAAudioInfo::new(0, 0, SND_F32P_FORMAT, 0),
374 info: NACodecInfo::new_dummy(),
377 ch_data: [IMCChannel::new(), IMCChannel::new()],
379 imdct: IMDCTContext::new(),
389 fn generate_iac_tables(&mut self, sample_rate: f32) {
390 let scale = sample_rate / 256.0 / 2.0 * 0.5;
391 let nyq_freq = sample_rate / 2.0;
392 let mut last_bark = 0.0;
393 let mut freq_max: [f32; BANDS] = [0.0; BANDS];
394 let mut freq_mid: [f32; BANDS] = [0.0; BANDS];
395 let mut freq_min: [f32; BANDS] = [0.0; BANDS];
396 for band in 0..BANDS {
397 let freq = ((IMC_BANDS[band] + IMC_BANDS[band + 1] - 1) as f32) * scale;
398 let bark = freq2bark(freq);
400 let bark_diff = bark - last_bark;
401 self.weights1[band - 1] = 10.0f32.powf(-1.0 * bark_diff);
402 self.weights2[band - 1] = 10.0f32.powf(-2.7 * bark_diff);
405 freq_mid[band] = freq;
407 let mut tmp_freq = freq;
408 while tmp_freq < nyq_freq {
410 if freq2bark(tmp_freq) > bark + 0.5 { break; }
412 freq_max[band] = tmp_freq;
414 let mut tmp_freq = freq;
415 while tmp_freq > 0.0 {
417 if freq2bark(tmp_freq) < bark - 0.5 { break; }
419 freq_min[band] = tmp_freq;
422 for band in 0..BANDS {
423 let mut s_band = BANDS - 1;
424 while s_band > 0 && freq_max[band] <= freq_mid[s_band] { s_band -= 1; }
425 self.cycle1[band] = s_band + 1;
429 for band in 1..BANDS {
431 while s_band < BANDS-1 && freq_min[band] >= freq_mid[s_band] { s_band += 1; }
432 self.cycle2[band] = s_band - 1;
436 fn read_level_coeffs_raw(&mut self, br: &mut BitReader, ch: usize) -> DecoderResult<()> {
437 let mut ch_data = &mut self.ch_data[ch];
438 let maxc_pos = br.read(5)? as usize;
439 let max_coef = br.read(7)? as u8;
441 let (c1, c2) = calc_maxcoef(max_coef as f32);
444 let level = br.read(4)?;
445 ch_data.coeffs1[i] = c1 * self.luts.exp_lev[level as usize];
446 ch_data.coeffs2[i] = c2 - 1.4533435415 * (level as f32);
448 ch_data.coeffs1[i] = c1;
449 ch_data.coeffs2[i] = c2;
451 self.ba.band_width[i] = IMC_BANDS[i + 1] - IMC_BANDS[i];
452 //self.ba.band_flag[i] = false;
454 ch_data.coeffs3[i] = ch_data.coeffs2[i] * 2.0;
455 ch_data.coeffs5[i] = 1.0;
461 fn calculate_channel_values(&mut self, ch: usize) {
462 let mut ch_data = &mut self.ch_data[ch];
463 let mut tmp2: [f32; BANDS+1] = [0.0; BANDS+1];
464 let mut tmp3: [f32; BANDS] = [0.0; BANDS];
466 for band in 0..BANDS {
467 ch_data.coeffs5[band] = 0.0;
469 if self.ba.band_width[band] > 0 {
470 val = (ch_data.coeffs1[band] as f64).powi(2);
471 ch_data.coeffs3[band] = 2.0 * ch_data.coeffs2[band];
474 ch_data.coeffs3[band] = -30000.0;
476 let tmp = val * (self.ba.band_width[band] as f64) * 0.01;
477 if val <= 1.0e-30 { tmp3[band] = 0.0; }
478 else { tmp3[band] = tmp as f32; }
481 for band in 0..BANDS {
482 let next_band = self.cycle1[band];
483 for band2 in band..next_band {
484 ch_data.coeffs5[band2] += tmp3[band];
486 tmp2[next_band] += tmp3[band];
490 for band in 1..BANDS {
491 accum = (tmp2[band] + accum) * self.weights1[band - 1];
492 ch_data.coeffs5[band] += accum;
495 let mut tmp2: [f32; BANDS] = [0.0; BANDS];
497 for band in 1..BANDS {
498 let prev_band = self.cycle2[band];
499 for band2 in prev_band+1..band {
500 ch_data.coeffs5[band2] += tmp3[band];
502 tmp2[prev_band + 1] += tmp3[band];
506 for i in 0..BANDS-1 {
507 let band = BANDS - 2 - i;
508 accum = (tmp2[band + 1] + accum) * self.weights2[band];
509 ch_data.coeffs5[band] += accum;
513 fn read_level_coeffs(&mut self, br: &mut BitReader, reset: bool, sel_idx: usize, ch: usize) -> DecoderResult<()> {
514 let mut level: [i8; BANDS] = [0; BANDS];
518 level[0] = br.read(7)? as i8;
522 for i in start..BANDS {
523 level[i] = br.read_cb(&self.codes[sel_idx][IMC_CB_SELECTOR[sel_idx][i]])? as i8;
525 level[i] += br.read(4)? as i8;
527 self.ba.keep_flag[i] = level[i] == 16;
530 let mut ch_data = &mut self.ch_data[ch];
531 let (mut c1, mut c2) = calc_maxcoef(level[0] as f32);
532 ch_data.coeffs1[0] = c1;
533 ch_data.coeffs2[0] = c2;
536 ch_data.coeffs1[i] = 1.0;
537 ch_data.coeffs2[i] = 0.0;
542 } else if level[i] < 25 {
543 lval = level[i] - 32;
545 lval = level[i] - 16;
547 c1 *= self.luts.exp_10[(lval + 16) as usize];
548 c2 += 0.83048 * (lval as f32);
549 ch_data.coeffs1[i] = c1;
550 ch_data.coeffs2[i] = c2;
554 let mut ch_data = &mut self.ch_data[ch];
557 let lval = level[i] - 7;
558 ch_data.coeffs1[i] = self.luts.exp_10[(lval + 16) as usize] * ch_data.old_floor[i];
559 ch_data.coeffs2[i] += (lval as f32) * 0.83048;
561 ch_data.coeffs1[i] = ch_data.old_floor[i];
566 self.ba.band_width[0] = IMC_BANDS[1] - IMC_BANDS[0];
569 self.ba.band_width[i] = IMC_BANDS[i + 1] - IMC_BANDS[i];
571 self.ba.band_width[i] = 0;
573 //self.ba.band_flag[i] = false;
576 for i in 0..BANDS-1 {
577 if self.ba.band_width[i] > 0 {
578 self.ba.band_flag[i] = br.read_bool()?;
581 self.calculate_channel_values(ch);
586 fn read_skip_flags(&mut self, br: &mut BitReader) -> DecoderResult<()> {
587 let mut ba = &mut self.ba;
588 for band in 0..BANDS {
589 if !ba.band_flag[band] || ba.band_width[band] == 0 { continue; }
591 if !ba.band_skip[band] {
592 ba.skip_flag_bits[band] = (IMC_BANDS[band + 1] - IMC_BANDS[band]) as u8;
593 for i in IMC_BANDS[band]..IMC_BANDS[band + 1] {
594 ba.skip_flag[i] = br.read_bool()?;
596 ba.skips_per_band[band] += 1;
600 let mut i = IMC_BANDS[band];
601 while i < IMC_BANDS[band + 1] - 1 {
602 if !br.read_bool()? {
603 ba.skip_flag_bits[band] += 1;
604 ba.skip_flag[i] = true;
605 ba.skip_flag[i + 1] = true;
606 ba.skips_per_band[band] += 2;
609 ba.skip_flag_bits[band] += 2;
610 ba.skip_flag[i] = false;
611 ba.skip_flag[i + 1] = true;
612 ba.skips_per_band[band] += 1;
614 ba.skip_flag_bits[band] += 3;
615 if !br.read_bool()? {
616 ba.skip_flag[i] = true;
617 ba.skips_per_band[band] += 1;
619 ba.skip_flag[i] = false;
621 ba.skip_flag[i + 1] = false;
626 if i != IMC_BANDS[band + 1] {
627 ba.skip_flag_bits[band] += 1;
628 ba.skip_flag[i] = br.read_bool()?;
630 ba.skips_per_band[band] += 1;
638 fn read_bitalloc_delta(&mut self, br: &mut BitReader, ch: usize) -> DecoderResult<()> {
639 for band in 0..BANDS {
640 self.ba.band_bitsum[band] = 0;
641 self.ba.band_skip[band] = false;
642 for i in IMC_BANDS[band]..IMC_BANDS[band + 1] {
643 self.ba.band_bitsum[band] += self.ba.cw_len[i] as usize;
645 if self.ba.band_flag[band] {
646 let band_w = IMC_BANDS[band + 1] - IMC_BANDS[band];
647 let bitsum = self.ba.band_bitsum[band] as usize;
648 if (bitsum > 0) && (((band_w * 3) >> 1) > bitsum) {
649 self.ba.band_skip[band] = true;
654 self.read_skip_flags(br)?;
656 let mut ch_data = &mut self.ch_data[ch];
657 for band in 0..BANDS {
658 ch_data.coeffs6[band] = ch_data.coeffs1[band];
659 let band_w = IMC_BANDS[band + 1] - IMC_BANDS[band];
660 let nonskip = band_w - self.ba.skips_per_band[band];
661 if self.ba.band_flag[band] && nonskip > 0 {
662 ch_data.coeffs6[band] *= self.luts.sqrt_tab[band_w] / self.luts.sqrt_tab[nonskip];
666 let mut bits_freed: i32 = 0;
667 for band in 0..BANDS {
668 if !self.ba.band_flag[band] { continue; }
669 for i in IMC_BANDS[band]..IMC_BANDS[band + 1] {
670 if self.ba.skip_flag[i] {
671 bits_freed += self.ba.cw_len[i] as i32;
672 self.ba.cw_len[i] = 0;
675 bits_freed -= self.ba.skip_flag_bits[band] as i32;
678 if bits_freed < 0 { return Err(DecoderError::Bug); }
679 self.ba.adjust_bit_allocation(&mut ch_data, bits_freed);
684 fn read_coeffs(&mut self, br: &mut BitReader) -> DecoderResult<()> {
685 for band in 0..BANDS {
686 if self.ba.band_bitsum[band] == 0 { continue; }
687 if !self.ba.band_flag[band] && (self.ba.band_width[band] == 0) { continue; }
688 for i in IMC_BANDS[band]..IMC_BANDS[band + 1] {
689 let len = self.ba.cw_len[i];
690 if len > 0 && (!self.ba.band_flag[band] || !self.ba.skip_flag[i]) {
691 self.ba.coeff[i] = br.read(len)? as u8;
693 self.ba.coeff[i] = 0;
700 fn inv_quant(&mut self, ch: usize, raw_coeffs: bool) {
701 let qidx: usize = if raw_coeffs { 1 } else { 0 };
702 let mut ch_data = &mut self.ch_data[ch];
703 for band in 0..BANDS {
704 for i in IMC_BANDS[band]..IMC_BANDS[band + 1] {
706 let cw_len = self.ba.cw_len[i];
707 if cw_len == 0 || self.ba.skip_flag[i] { continue; }
709 let val = self.ba.coeff[i] as usize;
710 let mid = 1 << (cw_len - 1);
711 let max = (1 << cw_len) - 1;
713 let quant = &IMC_QUANT_LARGE[qidx];
715 ch_data.cw[i] = quant[val - 8] * ch_data.coeffs6[band];
717 ch_data.cw[i] = -quant[max - val - 8] * ch_data.coeffs6[band];
720 let idx = qidx + (if self.ba.band_flag[band] { 2 } else { 0 });
721 let quant = &IMC_QUANT_SMALL[idx];
723 ch_data.cw[i] = quant[val - 1] * ch_data.coeffs6[band];
725 ch_data.cw[i] = -quant[max - val - 1] * ch_data.coeffs6[band];
732 fn decode_block(&mut self, data: &[u8], ch: usize, dst: &mut [f32]) -> DecoderResult<()> {
733 let mut br = BitReader::new(&data[BLOCK_SIZE*ch..], BLOCK_SIZE, BitReaderMode::LE16MSB);
734 let hdr = br.read(9)?;
735 validate!((hdr & 0x18) == 0);
737 let reset = br.read_bool()?;
738 let fixed_head = br.read_bool()?;
739 let raw_coeffs = br.read_bool()?;
740 let weight_idx = br.read(1)? as usize;
743 self.ch_data[ch].reset();
749 self.read_level_coeffs_raw(&mut br, ch)?;
751 let cb_idx = (if reset { 2 } else { 0 }) + (if fixed_head { 1 } else { 0 });
752 self.read_level_coeffs(&mut br, reset, cb_idx, ch)?;
755 self.ch_data[ch].old_floor.copy_from_slice(&self.ch_data[ch].coeffs1);
757 let mut bitcount: usize = 0;
760 self.ba.band_bits[0] = 5;
762 self.ba.cw_len[i] = 5;
766 if raw_coeffs || !self.ba.keep_flag[band]{
771 self.ba.band_bits[band] = bits;
772 for i in IMC_BANDS[band]..IMC_BANDS[band + 1] {
773 self.ba.cw_len[i] = bits;
774 bitcount += bits as usize;
780 if self.ba.band_width[BANDS - 1] != 0 {
785 if self.ba.band_width[BANDS - 1] != 0 {
790 validate!(br.tell() + bitcount < BLOCK_SIZE * 8);
791 self.ba.calculate_bit_allocation(&mut self.ch_data[ch], 512 - bitcount - br.tell(), fixed_head, weight_idx)?;
794 self.read_bitalloc_delta(&mut br, ch)?;
797 for band in 0..BANDS {
798 self.ba.band_bitsum[band] = 0;
799 for i in IMC_BANDS[band]..IMC_BANDS[band + 1] {
800 if !self.ba.skip_flag[i] {
801 self.ba.band_bitsum[band] += self.ba.cw_len[i] as usize;
806 self.read_coeffs(&mut br)?;
807 self.inv_quant(ch, raw_coeffs);
808 self.imdct.imdct(&self.ch_data[ch].cw, dst, &mut self.ch_data[ch].last_im);
816 let mut window: [f32; COEFFS] = [0.0; COEFFS];
817 generate_window(WindowType::Sine, 1.0, COEFFS, true, &mut window);
818 let mut pretwiddle1: [f32; COEFFS/2] = [0.0; COEFFS/2];
819 let mut pretwiddle2: [f32; COEFFS/2] = [0.0; COEFFS/2];
820 let mut posttwiddle: [FFTComplex; COEFFS/2] = [FFTC_ZERO; COEFFS/2];
821 for i in 0..COEFFS/2 {
823 let base = (n * 4.0 + 1.0) / 1024.0 * consts::PI;
827 pretwiddle1[i] = -(r1 + r2) * consts::SQRT_2;
828 pretwiddle2[i] = (r1 - r2) * consts::SQRT_2;
830 pretwiddle1[i] = (r1 + r2) * consts::SQRT_2;
831 pretwiddle2[i] = -(r1 - r2) * consts::SQRT_2;
833 posttwiddle[i] = FFTComplex::exp(consts::PI / 256.0 * n).scale(1.0/32768.0);
836 pretwiddle1: pretwiddle1,
837 pretwiddle2: pretwiddle2,
838 posttwiddle: posttwiddle,
839 tmp: [FFTC_ZERO; COEFFS/2],
840 fft: FFTBuilder::new_fft(FFTMode::SplitRadix, COEFFS/2),
844 fn imdct(&mut self, coeffs: &[f32; COEFFS], dst: &mut [f32], last_im: &mut [f32; COEFFS/2]) {
845 for i in 0..COEFFS/2 {
846 let in2 = coeffs[i * 2];
847 let in1 = coeffs[COEFFS - 1 - i * 2];
848 let c2 = self.pretwiddle1[i];
849 let c1 = self.pretwiddle2[i];
850 self.tmp[i].re = -(c2 * in1 + c1 * in2);
851 self.tmp[i].im = c1 * in1 - c2 * in2;
853 self.fft.do_fft_inplace(&mut self.tmp, false);
854 for i in 0..COEFFS/2 {
855 let tmp = !(self.tmp[i] * self.posttwiddle[i]);
856 let c1 = self.window[i * 2];
857 let c2 = self.window[COEFFS - 1 - i * 2];
859 dst[i * 2] = c2 * im + c1 * tmp.re;
860 dst[COEFFS - 1 - i * 2] = c1 * im - c2 * tmp.re;
866 const CHMAP_MONO: [NAChannelType; 1] = [NAChannelType::C];
867 const CHMAP_STEREO: [NAChannelType; 2] = [NAChannelType::L, NAChannelType::R];
869 impl NADecoder for IMCDecoder {
870 fn init(&mut self, info: Rc<NACodecInfo>) -> DecoderResult<()> {
871 if let NACodecTypeInfo::Audio(ainfo) = info.get_properties() {
872 self.chmap = NAChannelMap::new();
873 match ainfo.get_channels() {
874 1 => { self.chmap.add_channels(&CHMAP_MONO); },
875 2 => { self.chmap.add_channels(&CHMAP_STEREO); },
876 _ => { return Err(DecoderError::InvalidData); },
878 self.ainfo = NAAudioInfo::new(ainfo.get_sample_rate(),
879 ainfo.get_channels(),
881 self.info = info.replace_info(NACodecTypeInfo::Audio(self.ainfo.clone()));
884 self.generate_iac_tables(ainfo.get_sample_rate() as f32);
888 Err(DecoderError::InvalidData)
891 fn decode(&mut self, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
892 let info = pkt.get_stream().get_info();
893 validate!(info.get_properties().is_audio());
894 let pktbuf = pkt.get_buffer();
896 let nblocks = pktbuf.len() / BLOCK_SIZE / (self.ainfo.get_channels() as usize);
897 let duration = COEFFS * nblocks;
899 let mut abuf = alloc_audio_buffer(self.ainfo, duration, self.chmap.clone())?;
900 let mut adata = abuf.get_abuf_f32().unwrap();
901 let mut dst = adata.get_data_mut();
903 let mut start: usize = 0;
904 let channels = self.ainfo.get_channels() as usize;
905 for chunk in pktbuf.chunks(BLOCK_SIZE * channels) {
906 for ch in 0..channels {
907 let off = abuf.get_offset(ch as usize) + start;
908 self.decode_block(chunk, ch as usize, &mut dst[off..off+COEFFS])?;
910 if (channels == 2) && ((chunk[1] & 0x20) != 0) {
911 let off1 = abuf.get_offset(0) + start;
912 let off2 = abuf.get_offset(1) + start;
914 let l = dst[off1 + i];
915 let r = dst[off2 + i];
916 dst[off1 + i] = l + r;
917 dst[off2 + i] = l - r;
923 let mut frm = NAFrame::new_from_pkt(pkt, self.info.clone(), abuf);
924 frm.set_keyframe(true);
925 Ok(Rc::new(RefCell::new(frm)))
929 pub fn get_decoder_imc() -> Box<NADecoder> {
930 Box::new(IMCDecoder::new(true))
933 pub fn get_decoder_iac() -> Box<NADecoder> {
934 Box::new(IMCDecoder::new(false))
937 struct IMCCodeReader { sel1: usize, sel2: usize }
940 fn new(sel1: usize, sel2: usize) -> Self { IMCCodeReader { sel1: sel1, sel2: sel2 } }
943 impl CodebookDescReader<u8> for IMCCodeReader {
944 fn bits(&mut self, idx: usize) -> u8 { IMC_CODE_LENGTHS[self.sel1][self.sel2][idx] }
945 fn code(&mut self, idx: usize) -> u32 { IMC_CODE_CODES[self.sel1][self.sel2][idx] as u32 }
946 fn sym (&mut self, idx: usize) -> u8 { idx as u8 }
947 fn len(&mut self) -> usize { IMC_CODE_LENGTHS[0][0].len() }
950 static IMC_BANDS: [usize; 33] = [
951 0, 3, 6, 9, 12, 16, 20, 24, 29, 34, 40, 46, 53, 60, 68, 76,
952 84, 93, 102, 111, 121, 131, 141, 151, 162, 173, 184, 195, 207, 219, 231, 243,
956 const IMC_QUANT_SMALL: &[[f32; 8]; 4] = &[
957 [ 8.4431201e-1, 4.7358301e-1, 1.448354, 2.7073899e-1,
958 7.4449003e-1, 1.241991, 1.845484, 0.0 ],
959 [ 8.6876702e-1, 4.7659001e-1, 1.478224, 2.5672799e-1,
960 7.55777e-1, 1.3229851, 2.03438, 0.0 ],
961 [ 7.5891501e-1, 6.2272799e-1, 1.271322, 3.47904e-1,
962 7.5317699e-1, 1.150767, 1.628476, 0.0 ],
963 [ 7.65257e-1, 6.44647e-1, 1.263824, 3.4548101e-1,
964 7.6384902e-1, 1.214466, 1.7638789, 0.0 ]
967 const IMC_QUANT_LARGE: &[[f32; 56]; 2] = &[
968 [ 1.39236e-1, 3.50548e-1, 5.9547901e-1, 8.5772401e-1,
969 1.121545, 1.3882281, 1.695882, 2.1270809,
970 7.2221003e-2, 1.85177e-1, 2.9521701e-1, 4.12568e-1,
971 5.4068601e-1, 6.7679501e-1, 8.1196898e-1, 9.4765198e-1,
972 1.0779999, 1.203415, 1.337265, 1.481871,
973 1.639982, 1.814766, 2.0701399, 2.449862,
974 3.7533998e-2, 1.02722e-1, 1.6021401e-1, 2.16043e-1,
975 2.7231601e-1, 3.3025399e-1, 3.9022601e-1, 4.52849e-1,
976 5.1794899e-1, 5.8529502e-1, 6.53956e-1, 7.2312802e-1,
977 7.9150802e-1, 8.5891002e-1, 9.28141e-1, 9.9706203e-1,
978 1.062153, 1.12564, 1.189834, 1.256122,
979 1.324469, 1.3955311, 1.468906, 1.545084,
980 1.6264729, 1.711524, 1.802705, 1.91023,
981 2.0533991, 2.22333, 2.4830019, 3.253329 ],
982 [ 1.11654e-1, 3.54469e-1, 6.4232099e-1, 9.6128798e-1,
983 1.295053, 1.61777, 1.989839, 2.51107,
984 5.7721999e-2, 1.69879e-1, 2.97589e-1, 4.3858799e-1,
985 5.9039903e-1, 7.4934798e-1, 9.1628098e-1, 1.087297,
986 1.262751, 1.4288321, 1.6040879, 1.79067,
987 2.000668, 2.2394669, 2.649332, 5.2760072,
988 2.9722e-2, 8.7316997e-2, 1.4445201e-1, 2.04247e-1,
989 2.6879501e-1, 3.3716801e-1, 4.08811e-1, 4.8306999e-1,
990 5.6049401e-1, 6.3955498e-1, 7.2044599e-1, 8.0427998e-1,
991 8.8933599e-1, 9.7537601e-1, 1.062461, 1.1510431,
992 1.240236, 1.326715, 1.412513, 1.500502,
993 1.591749, 1.686413, 1.785239, 1.891233,
994 2.0051291, 2.127681, 2.2709141, 2.475826,
995 2.7219379, 3.101985, 4.686213, 6.2287788 ]
998 static IMC_CYCLE1: [usize; BANDS] = [
999 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
1000 17, 18, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 32,
1003 static IMC_CYCLE2: [usize; BANDS] = [
1004 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
1005 15, 16, 17, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29
1008 static IMC_WEIGHTS1: [f32; BANDS-1] = [
1009 0.119595, 0.123124, 0.129192, 9.97377e-2,
1010 8.1923e-2, 9.61153e-2, 8.77885e-2, 8.61174e-2,
1011 9.00882e-2, 9.91658e-2, 0.112991, 0.131126,
1012 0.152886, 0.177292, 0.221782, 0.244917,
1013 0.267386, 0.306816, 0.323046, 0.33729,
1014 0.366773, 0.392557, 0.398076, 0.403302,
1015 0.42451, 0.444777, 0.449188, 0.455445,
1016 0.477853, 0.500669, 0.510395
1019 static IMC_WEIGHTS2: [f32; BANDS-1] = [
1020 3.23466e-3, 3.49886e-3, 3.98413e-3, 1.98116e-3,
1021 1.16465e-3, 1.79283e-3, 1.40372e-3, 1.33274e-3,
1022 1.50523e-3, 1.95064e-3, 2.77472e-3, 4.14725e-3,
1023 6.2776e-3, 9.36401e-3, 1.71397e-2, 2.24052e-2,
1024 2.83971e-2, 4.11689e-2, 4.73165e-2, 5.31631e-2,
1025 6.66614e-2, 8.00824e-2, 8.31588e-2, 8.61397e-2,
1026 9.89229e-2, 0.112197, 0.115227, 0.119613,
1027 0.136174, 0.15445, 0.162685
1030 static IMC_BITALLOC_ADJ: [[f32; 7]; 2] = [
1031 [ 7.6, 4.4, 6.1, 2.3, 6.2, 1.8, 0.0 ],
1032 [ 3.6, 3.7, 5.1, 1.6, 1.5, 1.2, 0.0 ]
1035 static IMC_CODE_LENGTHS: &[[[u8; 18]; 4]; 4] = &[
1037 [ 16, 15, 13, 11, 8, 5, 3, 1, 2, 4, 6, 9, 10, 12, 14, 16, 7, 0 ],
1038 [ 10, 8, 7, 6, 4, 4, 3, 2, 2, 3, 4, 6, 7, 9, 11, 11, 7, 0 ],
1039 [ 15, 15, 14, 11, 8, 6, 4, 2, 1, 4, 5, 7, 9, 10, 12, 13, 4, 0 ],
1040 [ 13, 11, 10, 8, 6, 4, 2, 2, 2, 3, 5, 7, 9, 12, 15, 15, 14, 0 ],
1042 [ 14, 12, 10, 8, 7, 4, 2, 2, 2, 3, 5, 7, 9, 11, 13, 14, 7, 0 ],
1043 [ 14, 13, 11, 8, 6, 4, 3, 2, 2, 3, 5, 7, 9, 10, 12, 14, 3, 0 ],
1044 [ 13, 12, 10, 7, 5, 4, 3, 2, 2, 3, 4, 6, 8, 9, 11, 13, 4, 0 ],
1045 [ 13, 12, 10, 7, 5, 4, 3, 2, 2, 3, 4, 6, 8, 9, 11, 13, 4, 0 ],
1047 [ 16, 14, 12, 10, 8, 5, 3, 1, 2, 4, 7, 9, 11, 13, 15, 17, 6, 17 ],
1048 [ 15, 13, 11, 8, 6, 4, 2, 2, 2, 3, 5, 7, 10, 12, 14, 16, 9, 16 ],
1049 [ 14, 12, 11, 9, 8, 6, 3, 1, 2, 5, 7, 10, 13, 15, 16, 17, 4, 17 ],
1050 [ 16, 14, 12, 9, 7, 5, 2, 2, 2, 3, 4, 6, 8, 11, 13, 15, 10, 16 ],
1052 [ 13, 11, 10, 8, 7, 5, 2, 2, 2, 4, 6, 9, 12, 14, 15, 16, 3, 16 ],
1053 [ 11, 11, 10, 9, 8, 7, 5, 4, 3, 3, 3, 3, 3, 3, 4, 5, 6, 5 ],
1054 [ 9, 9, 7, 6, 5, 4, 3, 3, 2, 3, 4, 5, 4, 5, 5, 6, 8, 6 ],
1055 [ 13, 12, 10, 8, 5, 3, 3, 2, 2, 3, 4, 7, 9, 11, 14, 15, 6, 15 ]
1059 static IMC_CODE_CODES: &[[[u16; 18]; 4]; 4] = &[
1061 [ 0xCC32, 0x6618, 0x1987, 0x0660, 0x00CD, 0x0018, 0x0007, 0x0000, 0x0002,
1062 0x000D, 0x0032, 0x0199, 0x0331, 0x0CC2, 0x330D, 0xCC33, 0x0067, 0x0000 ],
1063 [ 0x02FE, 0x00BE, 0x005E, 0x002D, 0x000A, 0x0009, 0x0003, 0x0003, 0x0000,
1064 0x0002, 0x0008, 0x002C, 0x005D, 0x017E, 0x05FE, 0x05FF, 0x005C, 0x0000 ],
1065 [ 0x5169, 0x5168, 0x28B5, 0x0517, 0x00A3, 0x0029, 0x0008, 0x0003, 0x0000,
1066 0x0009, 0x0015, 0x0050, 0x0144, 0x028A, 0x0A2C, 0x145B, 0x000B, 0x0000 ],
1067 [ 0x1231, 0x048D, 0x0247, 0x0090, 0x0025, 0x0008, 0x0001, 0x0003, 0x0000,
1068 0x0005, 0x0013, 0x0049, 0x0122, 0x0919, 0x48C3, 0x48C2, 0x2460, 0x0000 ]
1070 [ 0x2D1D, 0x0B46, 0x02D0, 0x00B5, 0x0059, 0x000A, 0x0003, 0x0001, 0x0000,
1071 0x0004, 0x0017, 0x005B, 0x0169, 0x05A2, 0x168F, 0x2D1C, 0x0058, 0x0000 ],
1072 [ 0x1800, 0x0C01, 0x0301, 0x0061, 0x0019, 0x0007, 0x0004, 0x0003, 0x0000,
1073 0x0005, 0x000D, 0x0031, 0x00C1, 0x0181, 0x0601, 0x1801, 0x0002, 0x0000 ],
1074 [ 0x1556, 0x0AAA, 0x02AB, 0x0054, 0x0014, 0x000B, 0x0002, 0x0003, 0x0000,
1075 0x0003, 0x0008, 0x002B, 0x00AB, 0x0154, 0x0554, 0x1557, 0x0009, 0x0000 ],
1076 [ 0x1556, 0x0AAA, 0x02AB, 0x0054, 0x0014, 0x000B, 0x0002, 0x0003, 0x0000,
1077 0x0003, 0x0008, 0x002B, 0x00AB, 0x0154, 0x0554, 0x1557, 0x0009, 0x0000 ]
1079 [ 0x2993, 0x0A65, 0x0298, 0x00A7, 0x0028, 0x0004, 0x0000, 0x0001, 0x0001,
1080 0x0003, 0x0015, 0x0052, 0x014D, 0x0533, 0x14C8, 0x5324, 0x000B, 0x5325 ],
1081 [ 0x09B8, 0x026F, 0x009A, 0x0012, 0x0005, 0x0000, 0x0001, 0x0002, 0x0003,
1082 0x0001, 0x0003, 0x0008, 0x004C, 0x0136, 0x04DD, 0x1373, 0x0027, 0x1372 ],
1083 [ 0x0787, 0x01E0, 0x00F1, 0x003D, 0x001F, 0x0006, 0x0001, 0x0001, 0x0001,
1084 0x0002, 0x000E, 0x0079, 0x03C2, 0x0F0D, 0x1E19, 0x3C30, 0x0000, 0x3C31 ],
1085 [ 0x4B06, 0x12C0, 0x04B1, 0x0097, 0x0024, 0x0008, 0x0002, 0x0003, 0x0000,
1086 0x0003, 0x0005, 0x0013, 0x004A, 0x0259, 0x0961, 0x2582, 0x012D, 0x4B07 ]
1088 [ 0x0A5A, 0x0297, 0x014A, 0x0053, 0x0028, 0x000B, 0x0003, 0x0000, 0x0002,
1089 0x0004, 0x0015, 0x00A4, 0x052C, 0x14B7, 0x296C, 0x52DB, 0x0003, 0x52DA ],
1090 [ 0x0193, 0x0192, 0x00C8, 0x0065, 0x0033, 0x0018, 0x0007, 0x0004, 0x0000,
1091 0x0004, 0x0005, 0x0007, 0x0006, 0x0003, 0x0005, 0x0005, 0x000D, 0x0004 ],
1092 [ 0x0012, 0x0013, 0x0005, 0x0003, 0x0000, 0x0003, 0x0005, 0x0004, 0x0003,
1093 0x0003, 0x0005, 0x0005, 0x0004, 0x0004, 0x0003, 0x0005, 0x0008, 0x0004 ],
1094 [ 0x0D66, 0x06B2, 0x01AD, 0x006A, 0x000C, 0x0005, 0x0004, 0x0000, 0x0003,
1095 0x0002, 0x0007, 0x0034, 0x00D7, 0x0358, 0x1ACF, 0x359C, 0x001B, 0x359D ]
1099 const IMC_CB_SELECTOR: [[usize; BANDS]; 4] = [
1100 [ 1, 1, 1, 1, 1, 1, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0,
1101 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2 ],
1102 [ 0, 2, 0, 3, 2, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1103 0, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ],
1104 [ 1, 1, 1, 1, 1, 1, 1, 3, 3, 3, 3, 3, 3, 3, 3, 3,
1105 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2 ],
1106 [ 0, 1, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
1107 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]
1115 use test::wavwriter::WavWriter;
1119 let avi_dmx = find_demuxer("avi").unwrap();
1120 // let mut file = File::open("assets/neal73_saber.avi").unwrap();
1121 // let mut file = File::open("assets/IMC/hvalen.avi").unwrap();
1122 // let mut file = File::open("assets/IMC/8khz.avi").unwrap();
1123 // let mut file = File::open("assets/STsKlassFist-1a.avi").unwrap();
1124 let mut file = File::open("assets/IMC/Angel Bday.avi").unwrap();
1125 let mut fr = FileReader::new_read(&mut file);
1126 let mut br = ByteReader::new(&mut fr);
1127 let mut dmx = avi_dmx.new_demuxer(&mut br);
1128 dmx.open().unwrap();
1130 let mut file = File::create("assets/imc-out.wav").unwrap();
1131 let mut fw = FileWriter::new_write(&mut file);
1132 let mut wr = ByteWriter::new(&mut fw);
1133 let mut wwr = WavWriter::new(&mut wr);
1134 let mut wrote_header = false;
1136 let mut decs: Vec<Option<Box<NADecoder>>> = Vec::new();
1137 for i in 0..dmx.get_num_streams() {
1138 let s = dmx.get_stream(i).unwrap();
1139 let info = s.get_info();
1140 let decfunc = find_decoder(info.get_name());
1141 if let Some(df) = decfunc {
1142 if info.is_audio() {
1143 let mut dec = (df)();
1144 dec.init(info).unwrap();
1145 decs.push(Some(dec));
1155 let pktres = dmx.get_frame();
1156 if let Err(e) = pktres {
1157 if e == DemuxerError::EOF { break; }
1160 let pkt = pktres.unwrap();
1161 //if pkt.get_pts().unwrap() > 10 { break; }
1162 let streamno = pkt.get_stream().get_id() as usize;
1163 if let Some(ref mut dec) = decs[streamno] {
1164 let frm_ = dec.decode(&pkt).unwrap();
1165 let frm = frm_.borrow();
1166 if frm.get_info().is_audio() {
1168 wwr.write_header(frm.get_info().as_ref().get_properties().get_audio_info().unwrap()).unwrap();
1169 wrote_header = true;
1171 wwr.write_frame(frm.get_buffer()).unwrap();