13 const BANDS: usize = 32;
14 const COEFFS: usize = 256;
15 const BLOCK_SIZE: usize = 64;
17 fn freq2bark(freq: f32) -> f32 {
18 3.5 * ((freq / 7500.0) * (freq / 7500.0)).atan() + 13.0 * (freq * 0.00076).atan()
22 pretwiddle1: [f32; COEFFS/2],
23 pretwiddle2: [f32; COEFFS/2],
24 posttwiddle: [FFTComplex; COEFFS/2],
25 tmp: [FFTComplex; COEFFS/2],
27 window: [f32; COEFFS],
31 old_floor: [f32; BANDS],
32 coeffs1: [f32; BANDS], // new floor?
33 coeffs2: [f32; BANDS], // log2 of coeffs1
34 coeffs3: [f32; BANDS],
35 coeffs4: [f32; BANDS],
36 coeffs5: [f32; BANDS],
37 coeffs6: [f32; BANDS],
39 last_im: [f32; COEFFS/2],
43 band_width: [usize; BANDS],
44 band_flag: [bool; BANDS],
45 band_skip: [bool; BANDS],
46 band_bits: [u8; BANDS],
48 band_bitsum: [usize; BANDS],
49 skip_flag: [bool; COEFFS],
50 skip_flag_bits: [u8; BANDS],
51 skips_per_band: [usize; BANDS],
52 keep_flag: [bool; BANDS],
59 old_floor: [0.0; BANDS],
60 coeffs1: [0.0; BANDS],
61 coeffs2: [0.0; BANDS],
62 coeffs3: [0.0; BANDS],
63 coeffs4: [0.0; BANDS],
64 coeffs5: [0.0; BANDS],
65 coeffs6: [0.0; BANDS],
67 last_im: [0.0; COEFFS/2],
71 for i in 0..self.old_floor.len() { self.old_floor[i] = 1.0; }
72 for i in 0..self.cw.len() { self.cw[i] = 0.0; }
76 const BITALLOC_LIMIT: f32 = -1.0e20;
77 const BITALLOC_TOP_LIMIT: f32 = 1.0e20;
81 band_width: [0; BANDS],
82 band_flag: [false; BANDS],
83 band_skip: [false; BANDS],
84 band_bits: [0; BANDS],
86 band_bitsum: [0; BANDS],
87 skip_flag: [false; COEFFS],
88 skip_flag_bits: [0; BANDS],
89 skips_per_band: [0; BANDS],
90 keep_flag: [false; BANDS],
96 self.band_width[i] = 0;
97 self.band_flag[i] = false;
98 self.band_skip[i] = false;
99 self.band_bits[i] = 0;
100 self.keep_flag[i] = false;
101 //self.band_bitsum[i] = 0;
102 self.skips_per_band[i] = 0;
103 self.skip_flag_bits[i] = 0;
106 //self.cw_len[i] = 0;
107 self.skip_flag[i] = false;
110 fn calculate_bit_allocation(&mut self, ch_data: &mut IMCChannel, bits: usize, fixed_head: bool, adj_idx: usize) -> DecoderResult<()> {
113 for coef in ch_data.coeffs1.iter() { if *coef > peak { peak = *coef; } }
116 for band in 0..BANDS-1 {
117 ch_data.coeffs4[band] = ch_data.coeffs3[band] - ch_data.coeffs5[band].log2();
119 ch_data.coeffs4[BANDS - 1] = BITALLOC_LIMIT;
121 for band in 0..BANDS {
123 let band_w = IMC_BANDS[band + 1] - IMC_BANDS[band];
124 if band_w == self.band_width[band] { idx = 0; }
125 if band_w > self.band_width[band] { idx = 1; }
126 if band_w/2 >= self.band_width[band] { idx = 2; }
129 if ch_data.coeffs1[band] < peak { idx += 1; }
130 ch_data.coeffs4[band] += IMC_BITALLOC_ADJ[adj_idx][idx];
135 ch_data.coeffs4[i] = BITALLOC_LIMIT;
139 let start = if fixed_head { 4 } else { 0 };
143 for band in start..BANDS-1 {
144 a_width += self.band_width[band];
145 pool += (self.band_width[band] as f32) * ch_data.coeffs4[band];
147 validate!(a_width > 0);
149 self.band_width[BANDS - 1] = 0;
150 pool = (pool * 0.5 - (bits as f32)) / (a_width as f32);
152 let free_bits = bits as i32;
153 let mut cur_bits: i32 = 0;
156 for i in 0..BANDS/2 {
157 let diff = cur_bits - free_bits;
158 if diff.abs() <= 8 { break; }
162 for band in start..BANDS {
163 let mut len = (ch_data.coeffs4[band] * 0.5 - pool + 0.5) as i32;
164 if len < 0 { len = 0; }
165 if len > 6 { len = 6; }
166 self.band_bits[band] = len as u8;
167 cur_bits += (self.band_width[band] as i32) * (len as i32);
169 acc += self.band_width[band] as i32;
173 let mut lflag = flag;
175 if free_bits < cur_bits { flag = -1; }
176 if i == 0 { lflag = flag; }
180 pool += ((cur_bits - free_bits) as f32) / (((mmcount + 1) * acc) as f32);
183 for band in start..BANDS {
184 for i in IMC_BANDS[band]..IMC_BANDS[band + 1] {
185 self.cw_len[i] = self.band_bits[band];
189 if free_bits > cur_bits {
190 let mut tmp: [f32; BANDS] = [BITALLOC_LIMIT; BANDS];
191 for band in 0..BANDS {
192 if self.band_bits[band] != 6 {
193 tmp[band] = (self.band_bits[band] as f32) * -2.0 + ch_data.coeffs4[band] - 0.415;
197 while (peak > BITALLOC_LIMIT) && (cur_bits < free_bits) {
198 peak = BITALLOC_LIMIT;
199 let mut idx: Option<usize> = None;
200 for band in 0..BANDS {
201 if tmp[band] > peak {
206 if let Some(band) = idx {
208 self.band_bits[band] += 1;
209 if self.band_bits[band] == 6 {
210 tmp[band] = BITALLOC_LIMIT;
212 for i in IMC_BANDS[band]..IMC_BANDS[band + 1] {
215 if cur_bits >= free_bits {
223 if cur_bits > free_bits {
224 let mut tmp: [f32; BANDS] = [BITALLOC_TOP_LIMIT; BANDS];
225 for band in start..BANDS {
226 if self.band_bits[band] != 0 {
227 tmp[band] = (self.band_bits[band] as f32) * -2.0 + ch_data.coeffs4[band] - 0.415 + 2.0;
230 while free_bits < cur_bits {
231 let mut low = BITALLOC_TOP_LIMIT;
233 for band in 0..BANDS {
240 self.band_bits[idx] -= 1;
241 if self.band_bits[idx] == 0 {
242 tmp[idx] = BITALLOC_TOP_LIMIT;
244 for i in IMC_BANDS[idx]..IMC_BANDS[idx + 1] {
245 if self.cw_len[i] > 0 {
248 if cur_bits <= free_bits {
259 fn adjust_bit_allocation(&mut self, ch_data: &mut IMCChannel, free_bits: i32) {
260 let mut tmp: [f32; BANDS] = [BITALLOC_LIMIT; BANDS];
262 for band in 0..BANDS {
263 if self.band_bits[band] != 6 {
264 tmp[band] = (self.band_bits[band] as f32) * -2.0 + ch_data.coeffs4[band] - 0.415;
267 let mut used_bits: i32 = 0;
269 while (peak > BITALLOC_LIMIT) && (used_bits < free_bits) {
270 peak = BITALLOC_LIMIT;
271 let mut idx: Option<usize> = None;
272 for band in 0..BANDS {
273 if tmp[band] > peak {
278 if let Some(band) = idx {
280 self.band_bits[band] += 1;
281 if self.band_bits[band] == 6 {
282 tmp[band] = BITALLOC_LIMIT;
284 for i in IMC_BANDS[band]..IMC_BANDS[band + 1] {
287 if used_bits >= free_bits {
294 let mut used_bits: i32 = 0;
296 let mut tmp: [f32; BANDS] = [BITALLOC_TOP_LIMIT; BANDS];
297 for band in 0..BANDS {
298 if self.band_bits[band] != 0 {
299 tmp[band] = (self.band_bits[band] as f32) * -2.0 + ch_data.coeffs4[band] - 0.415 + 2.0;
302 while free_bits < used_bits {
303 let mut low = BITALLOC_TOP_LIMIT;
305 for band in 0..BANDS {
312 self.band_bits[idx] -= 1;
313 if self.band_bits[idx] == 0 {
314 tmp[idx] = BITALLOC_TOP_LIMIT;
316 for i in IMC_BANDS[idx]..IMC_BANDS[idx + 1] {
317 if self.cw_len[i] > 0 {
320 if used_bits <= free_bits {
339 let mut exp_lev: [f32; 16] = [0.0; 16];
341 exp_lev[lev] = 10.0f32.powf(-(lev as f32) * 0.4375); // almost exp(-lev)
344 let mut exp_10: [f32; 32] = [0.0; 32];
346 exp_10[i] = 10.0f32.powf(((i as f32) - 16.0) * 0.25);
349 let mut sqrt_tab: [f32; 32] = [0.0; 32];
351 sqrt_tab[i] = (i as f32).sqrt();
354 LUTs { exp_lev: exp_lev, exp_10: exp_10, sqrt_tab: sqrt_tab }
363 info: Rc<NACodecInfo>,
365 codes: [[Codebook<u8>; 4]; 4],
366 ch_data: [IMCChannel; 2],
370 cycle1: [usize; BANDS],
371 cycle2: [usize; BANDS],
372 weights1: [f32; BANDS-1],
373 weights2: [f32; BANDS-1],
378 fn calc_maxcoef(coef: f32) -> (f32, f32) {
379 let c1 = 20000.0 / 2.0f32.powf(coef * 0.18945);
384 fn new(is_imc: bool) -> Self {
385 let mut codes: [[Codebook<u8>; 4]; 4];
386 let mut cycle1: [usize; BANDS] = [0; BANDS];
387 let mut cycle2: [usize; BANDS] = [0; BANDS];
388 let mut weights1: [f32; BANDS-1] = [0.0; BANDS-1];
389 let mut weights2: [f32; BANDS-1] = [0.0; BANDS-1];
391 cycle1.copy_from_slice(&IMC_CYCLE1);
392 cycle2.copy_from_slice(&IMC_CYCLE2);
393 weights1.copy_from_slice(&IMC_WEIGHTS1);
394 weights2.copy_from_slice(&IMC_WEIGHTS2);
397 codes = mem::uninitialized();
400 let mut cr = IMCCodeReader::new(i, j);
401 ptr::write(&mut codes[i][j], Codebook::new(&mut cr, CodebookMode::MSB).unwrap());
407 chmap: NAChannelMap::new(),
408 ainfo: NAAudioInfo::new(0, 0, SND_F32P_FORMAT, 0),
409 info: NACodecInfo::new_dummy(),
412 ch_data: [IMCChannel::new(), IMCChannel::new()],
414 imdct: IMDCTContext::new(),
424 fn generate_iac_tables(&mut self, sample_rate: f32) {
425 let scale = sample_rate / 1024.0;
426 let nyq_freq = sample_rate / 2.0;
427 let mut last_bark = 0.0;
428 let mut freq_max: [f32; BANDS] = [0.0; BANDS];
429 let mut freq_mid: [f32; BANDS] = [0.0; BANDS];
430 let mut freq_min: [f32; BANDS] = [0.0; BANDS];
431 for band in 0..BANDS {
432 let freq = ((IMC_BANDS[band] + IMC_BANDS[band + 1] - 1) as f32) * scale;
433 let bark = freq2bark(freq);
435 let bark_diff = bark - last_bark;
436 self.weights1[band - 1] = 10.0f32.powf(-1.0 * bark_diff);
437 self.weights1[band - 1] = 10.0f32.powf(-2.7 * bark_diff);
440 freq_mid[band] = freq;
442 let mut tmp_freq = freq;
443 while tmp_freq < nyq_freq {
445 if freq2bark(tmp_freq) > bark + 0.5 { break; }
447 freq_max[band] = tmp_freq;
449 let mut tmp_freq = freq;
450 while tmp_freq > 0.0 {
452 if freq2bark(tmp_freq) < bark - 0.5 { break; }
454 freq_min[band] = tmp_freq;
457 for band in 0..BANDS {
458 let mut s_band = BANDS - 1;
459 while s_band > 0 && freq_max[band] <= freq_mid[s_band] { s_band -= 1; }
460 self.cycle1[band] = s_band + 1;
464 for band in 1..BANDS {
466 while s_band < BANDS-1 && freq_min[band] >= freq_mid[s_band] { s_band += 1; }
467 self.cycle2[band] = s_band - 1;
471 fn read_level_coeffs_raw(&mut self, br: &mut BitReader, ch: usize) -> DecoderResult<()> {
472 let mut ch_data = &mut self.ch_data[ch];
473 let maxc_pos = br.read(5)? as usize;
474 let max_coef = br.read(7)? as u8;
476 let (c1, c2) = calc_maxcoef(max_coef as f32);
479 let level = br.read(4)?;
480 ch_data.coeffs1[i] = c1 * self.luts.exp_lev[level as usize];
481 ch_data.coeffs2[i] = c2 - 1.4533435415 * (level as f32);
483 ch_data.coeffs1[i] = c1;
484 ch_data.coeffs2[i] = c2;
486 self.ba.band_width[i] = IMC_BANDS[i + 1] - IMC_BANDS[i];
487 //self.ba.band_flag[i] = false;
489 ch_data.coeffs3[i] = ch_data.coeffs2[i] * 2.0;
490 ch_data.coeffs5[i] = 1.0;
496 fn calculate_channel_values(&mut self, ch: usize) {
497 let mut ch_data = &mut self.ch_data[ch];
498 let mut tmp2: [f32; BANDS] = [0.0; BANDS];
499 let mut tmp3: [f32; BANDS] = [0.0; BANDS];
501 for band in 0..BANDS {
502 ch_data.coeffs5[band] = 0.0;
504 if self.ba.band_width[band] > 0 {
505 val = ch_data.coeffs1[band] * ch_data.coeffs1[band];
506 ch_data.coeffs3[band] = 2.0 * ch_data.coeffs2[band];
509 ch_data.coeffs3[band] = -30000.0;
511 tmp3[band] = val * (self.ba.band_width[band] as f32) * 0.01;
512 if tmp3[band] <= 1.0e-6 { tmp3[band] = 0.0; }
515 for band in 0..BANDS {
516 let next_band = self.cycle1[band];
517 for band2 in band..next_band {
518 ch_data.coeffs5[band2] += tmp3[band];
520 tmp2[next_band - 1] += tmp3[band];
524 for band in 0..BANDS-1 {
525 accum = (tmp2[band] + accum) * self.weights1[band];
526 ch_data.coeffs5[band + 1] += accum;
529 let mut tmp2: [f32; BANDS] = [0.0; BANDS];
531 for band in 1..BANDS {
532 let prev_band = self.cycle2[band];
533 for band2 in prev_band+1..band {
534 ch_data.coeffs5[band2] += tmp3[band];
536 tmp2[prev_band + 1] += tmp3[band];
540 for i in 0..BANDS-1 {
541 let band = BANDS - 2 - i;
542 accum = (tmp2[band + 1] + accum) * self.weights2[band];
543 ch_data.coeffs5[band] += accum;
547 fn read_level_coeffs(&mut self, br: &mut BitReader, reset: bool, sel_idx: usize, ch: usize) -> DecoderResult<()> {
548 let mut level: [i8; BANDS] = [0; BANDS];
552 level[0] = br.read(7)? as i8;
556 for i in start..BANDS {
557 level[i] = br.read_cb(&self.codes[sel_idx][IMC_CB_SELECTOR[sel_idx][i]])? as i8;
559 level[i] += br.read(4)? as i8;
561 self.ba.keep_flag[i] = level[i] == 16;
564 let mut ch_data = &mut self.ch_data[ch];
565 let (mut c1, mut c2) = calc_maxcoef(level[0] as f32);
566 ch_data.coeffs1[0] = c1;
567 ch_data.coeffs2[0] = c2;
570 ch_data.coeffs1[i] = 1.0;
571 ch_data.coeffs2[i] = 0.0;
576 } else if level[i] < 25 {
577 lval = level[i] - 32;
579 lval = level[i] - 16;
581 c1 *= self.luts.exp_10[(lval + 16) as usize];
582 c2 += 0.83048 * (lval as f32);
583 ch_data.coeffs1[i] = c1;
584 ch_data.coeffs2[i] = c2;
588 let mut ch_data = &mut self.ch_data[ch];
591 let lval = level[i] - 7;
592 ch_data.coeffs1[i] = self.luts.exp_10[(lval + 16) as usize] * ch_data.old_floor[i];
593 ch_data.coeffs2[i] += (lval as f32) * 0.83048;
595 ch_data.coeffs1[i] = ch_data.old_floor[i];
602 self.ba.band_width[i] = IMC_BANDS[i + 1] - IMC_BANDS[i];
604 self.ba.band_width[i] = 0;
606 //self.ba.band_flag[i] = false;
609 for i in 0..BANDS-1 {
610 if self.ba.band_width[i] > 0 {
611 self.ba.band_flag[i] = br.read_bool()?;
614 self.calculate_channel_values(ch);
619 fn read_skip_flags(&mut self, br: &mut BitReader) -> DecoderResult<()> {
620 let mut ba = &mut self.ba;
621 for band in 0..BANDS {
622 if !ba.band_flag[band] || ba.band_width[band] == 0 { continue; }
624 if !ba.band_skip[band] {
625 ba.skip_flag_bits[band] = (IMC_BANDS[band + 1] - IMC_BANDS[band]) as u8;
626 for i in IMC_BANDS[band]..IMC_BANDS[band + 1] {
627 ba.skip_flag[i] = br.read_bool()?;
629 ba.skips_per_band[band] += 1;
633 let mut i = IMC_BANDS[band];
634 while i < IMC_BANDS[band + 1] - 1 {
635 if !br.read_bool()? {
636 ba.skip_flag_bits[band] += 1;
637 ba.skip_flag[i] = true;
638 ba.skip_flag[i + 1] = true;
639 ba.skips_per_band[band] += 2;
642 ba.skip_flag_bits[band] += 2;
643 ba.skip_flag[i] = false;
644 ba.skip_flag[i + 1] = true;
645 ba.skips_per_band[band] += 1;
647 ba.skip_flag_bits[band] += 3;
648 if !br.read_bool()? {
649 ba.skip_flag[i] = true;
650 ba.skips_per_band[band] += 1;
652 ba.skip_flag[i] = false;
654 ba.skip_flag[i + 1] = false;
659 if i != IMC_BANDS[band + 1] {
660 ba.skip_flag_bits[band] += 1;
661 ba.skip_flag[i] = br.read_bool()?;
663 ba.skips_per_band[band] += 1;
671 fn read_bitalloc_delta(&mut self, br: &mut BitReader, ch: usize) -> DecoderResult<()> {
672 for band in 0..BANDS {
673 self.ba.band_bitsum[band] = 0;
674 self.ba.band_skip[band] = false;
675 for i in IMC_BANDS[band]..IMC_BANDS[band + 1] {
676 self.ba.band_bitsum[band] += self.ba.cw_len[i] as usize;
678 if self.ba.band_flag[band] {
679 let band_w = IMC_BANDS[band + 1] - IMC_BANDS[band];
680 let bitsum = self.ba.band_bitsum[band] as usize;
681 if (bitsum > 0) && (band_w * 3 > bitsum * 2) {
682 self.ba.band_skip[band] = true;
687 self.read_skip_flags(br)?;
689 let mut ch_data = &mut self.ch_data[ch];
690 for band in 0..BANDS {
691 ch_data.coeffs6[band] = ch_data.coeffs1[band];
692 let band_w = IMC_BANDS[band + 1] - IMC_BANDS[band];
693 let nonskip = band_w - self.ba.skips_per_band[band];
694 if self.ba.band_flag[band] && nonskip > 0 {
695 ch_data.coeffs6[band] *= self.luts.sqrt_tab[band_w] / self.luts.sqrt_tab[nonskip];//
699 let mut bits_freed: i32 = 0;
700 for band in 0..BANDS {
701 if !self.ba.band_flag[band] { continue; }
702 for i in IMC_BANDS[band]..IMC_BANDS[band + 1] {
703 if self.ba.skip_flag[i] {
704 bits_freed += self.ba.cw_len[i] as i32;
705 self.ba.cw_len[i] = 0;
708 bits_freed -= self.ba.skip_flag_bits[band] as i32;
711 self.ba.adjust_bit_allocation(&mut ch_data, bits_freed);
716 fn read_coeffs(&mut self, br: &mut BitReader) -> DecoderResult<()> {
717 for band in 0..BANDS {
718 if self.ba.band_bitsum[band] == 0 { continue; }
719 if !self.ba.band_flag[band] && (self.ba.band_width[band] == 0) { continue; }
720 for i in IMC_BANDS[band]..IMC_BANDS[band + 1] {
721 let len = self.ba.cw_len[i];
722 if len > 0 && (!self.ba.band_flag[band] || !self.ba.skip_flag[i]) {
723 self.ba.coeff[i] = br.read(len)? as u8;
725 self.ba.coeff[i] = 0;
732 fn inv_quant(&mut self, ch: usize, raw_coeffs: bool) {
733 let qidx: usize = if raw_coeffs { 1 } else { 0 };
734 let mut ch_data = &mut self.ch_data[ch];
735 for band in 0..BANDS {
736 for i in IMC_BANDS[band]..IMC_BANDS[band + 1] {
738 let cw_len = self.ba.cw_len[i];
739 if cw_len == 0 || self.ba.skip_flag[i] { continue; }
741 let val = self.ba.coeff[i] as usize;
742 let mid = 1 << (cw_len - 1);
743 let max = (1 << cw_len) - 1;
745 let quant = &IMC_QUANT_LARGE[qidx];
747 ch_data.cw[i] = quant[val - 8] * ch_data.coeffs6[band];
749 ch_data.cw[i] = -quant[max - val - 8] * ch_data.coeffs6[band];
752 let idx = qidx + (if self.ba.band_flag[band] { 2 } else { 0 });
753 let quant = &IMC_QUANT_SMALL[idx];
755 ch_data.cw[i] = quant[val - 1] * ch_data.coeffs6[band];
757 ch_data.cw[i] = -quant[max - val - 1] * ch_data.coeffs6[band];
764 fn decode_block(&mut self, data: &[u8], ch: usize, dst: &mut [f32]) -> DecoderResult<()> {
765 let mut br = BitReader::new(&data[BLOCK_SIZE*ch..], BLOCK_SIZE, BitReaderMode::LE16MSB);
766 let hdr = br.read(9)?;
767 validate!((hdr & 0x18) == 0);
769 let reset = br.read_bool()?;
770 let fixed_head = br.read_bool()?;
771 let raw_coeffs = br.read_bool()?;
772 let weight_idx = br.read(1)? as usize;
775 self.ch_data[ch].reset();
781 self.read_level_coeffs_raw(&mut br, ch)?;
783 let cb_idx = (if reset { 2 } else { 0 }) + (if fixed_head { 1 } else { 0 });
784 self.read_level_coeffs(&mut br, reset, cb_idx, ch)?;
787 self.ch_data[ch].old_floor.copy_from_slice(&self.ch_data[ch].coeffs1);
789 let mut bitcount: usize = 0;
792 self.ba.band_bits[0] = 5;
794 self.ba.cw_len[i] = 5;
798 if raw_coeffs || !self.ba.keep_flag[band]{
803 self.ba.band_bits[band] = bits;
804 for i in IMC_BANDS[band]..IMC_BANDS[band + 1] {
805 self.ba.cw_len[i] = bits;
806 bitcount += bits as usize;
812 if self.ba.band_width[BANDS - 1] != 0 {
820 validate!(br.tell() + bitcount < BLOCK_SIZE * 8);
821 self.ba.calculate_bit_allocation(&mut self.ch_data[ch], 512 - bitcount - br.tell(), fixed_head, weight_idx)?;
824 self.read_bitalloc_delta(&mut br, ch)?;
827 for band in 0..BANDS {
828 self.ba.band_bitsum[band] = 0;
829 for i in IMC_BANDS[band]..IMC_BANDS[band + 1] {
830 if !self.ba.skip_flag[i] {
831 self.ba.band_bitsum[band] += self.ba.cw_len[i] as usize;
836 self.read_coeffs(&mut br)?;
837 self.inv_quant(ch, raw_coeffs);
838 self.imdct.imdct(&self.ch_data[ch].cw, dst, &mut self.ch_data[ch].last_im);
846 let mut window: [f32; COEFFS] = [0.0; COEFFS];
847 generate_window(WindowType::Sine, 1.0, COEFFS, true, &mut window);
848 let mut pretwiddle1: [f32; COEFFS/2] = [0.0; COEFFS/2];
849 let mut pretwiddle2: [f32; COEFFS/2] = [0.0; COEFFS/2];
850 let mut posttwiddle: [FFTComplex; COEFFS/2] = [FFTC_ZERO; COEFFS/2];
851 for i in 0..COEFFS/2 {
853 let base = (n * 4.0 + 1.0) / 1024.0 * consts::PI;
857 pretwiddle1[i] = -(r1 + r2) * consts::SQRT_2;
858 pretwiddle2[i] = (r1 - r2) * consts::SQRT_2;
860 pretwiddle1[i] = (r1 + r2) * consts::SQRT_2;
861 pretwiddle2[i] = -(r1 - r2) * consts::SQRT_2;
863 posttwiddle[i] = FFTComplex::exp(consts::PI / 256.0 * n).scale(1.0/32768.0);
866 pretwiddle1: pretwiddle1,
867 pretwiddle2: pretwiddle2,
868 posttwiddle: posttwiddle,
869 tmp: [FFTC_ZERO; COEFFS/2],
870 fft: FFTBuilder::new_fft(FFTMode::SplitRadix, COEFFS/2),
874 fn imdct(&mut self, coeffs: &[f32; COEFFS], dst: &mut [f32], last_im: &mut [f32; COEFFS/2]) {
875 for i in 0..COEFFS/2 {
876 let in2 = coeffs[i * 2];
877 let in1 = coeffs[COEFFS - 1 - i * 2];
878 let c2 = self.pretwiddle1[i];
879 let c1 = self.pretwiddle2[i];
880 self.tmp[i].re = -(c2 * in1 + c1 * in2);
881 self.tmp[i].im = c1 * in1 - c2 * in2;
883 self.fft.do_fft_inplace(&mut self.tmp, false);
884 for i in 0..COEFFS/2 {
885 let tmp = !(self.tmp[i] * self.posttwiddle[i]);
886 let c1 = self.window[i * 2];
887 let c2 = self.window[COEFFS - 1 - i * 2];
889 dst[i * 2] = c2 * im + c1 * tmp.re;
890 dst[COEFFS - 1 - i * 2] = c1 * im - c2 * tmp.re;
896 const CHMAP_MONO: [NAChannelType; 1] = [NAChannelType::C];
897 const CHMAP_STEREO: [NAChannelType; 2] = [NAChannelType::L, NAChannelType::R];
899 impl NADecoder for IMCDecoder {
900 fn init(&mut self, info: Rc<NACodecInfo>) -> DecoderResult<()> {
901 if let NACodecTypeInfo::Audio(ainfo) = info.get_properties() {
902 self.chmap = NAChannelMap::new();
903 match ainfo.get_channels() {
904 1 => { self.chmap.add_channels(&CHMAP_MONO); },
905 2 => { self.chmap.add_channels(&CHMAP_STEREO); },
906 _ => { return Err(DecoderError::InvalidData); },
908 self.ainfo = NAAudioInfo::new(ainfo.get_sample_rate(),
909 ainfo.get_channels(),
911 self.info = info.replace_info(NACodecTypeInfo::Audio(self.ainfo.clone()));
914 self.generate_iac_tables(ainfo.get_sample_rate() as f32);
918 Err(DecoderError::InvalidData)
921 fn decode(&mut self, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
922 let info = pkt.get_stream().get_info();
923 validate!(info.get_properties().is_audio());
924 let pktbuf = pkt.get_buffer();
926 let nblocks = pktbuf.len() / BLOCK_SIZE / (self.ainfo.get_channels() as usize);
927 let duration = COEFFS * nblocks;
929 let mut abuf = alloc_audio_buffer(self.ainfo, duration, self.chmap.clone())?;
930 let mut adata = abuf.get_abuf_f32().unwrap();
931 let mut dst = adata.get_data_mut();
933 let mut start: usize = 0;
934 for chunk in pktbuf.chunks(BLOCK_SIZE * (self.ainfo.get_channels() as usize)) {
935 for ch in 0..self.ainfo.get_channels() {
936 let off = abuf.get_offset(ch as usize) + start;
937 self.decode_block(chunk, ch as usize, &mut dst[off..off+COEFFS])?;
942 let mut frm = NAFrame::new_from_pkt(pkt, self.info.clone(), abuf);
943 frm.set_keyframe(true);
944 Ok(Rc::new(RefCell::new(frm)))
948 pub fn get_decoder_imc() -> Box<NADecoder> {
949 Box::new(IMCDecoder::new(true))
952 pub fn get_decoder_iac() -> Box<NADecoder> {
953 Box::new(IMCDecoder::new(false))
956 struct IMCCodeReader { sel1: usize, sel2: usize }
959 fn new(sel1: usize, sel2: usize) -> Self { IMCCodeReader { sel1: sel1, sel2: sel2 } }
962 impl CodebookDescReader<u8> for IMCCodeReader {
963 fn bits(&mut self, idx: usize) -> u8 { IMC_CODE_LENGTHS[self.sel1][self.sel2][idx] }
964 fn code(&mut self, idx: usize) -> u32 { IMC_CODE_CODES[self.sel1][self.sel2][idx] as u32 }
965 fn sym (&mut self, idx: usize) -> u8 { idx as u8 }
966 fn len(&mut self) -> usize { IMC_CODE_LENGTHS[0][0].len() }
969 static IMC_BANDS: [usize; 33] = [
970 0, 3, 6, 9, 12, 16, 20, 24, 29, 34, 40, 46, 53, 60, 68, 76,
971 84, 93, 102, 111, 121, 131, 141, 151, 162, 173, 184, 195, 207, 219, 231, 243,
975 const IMC_QUANT_SMALL: &[[f32; 8]; 4] = &[
976 [ 8.4431201e-1, 4.7358301e-1, 1.448354, 2.7073899e-1,
977 7.4449003e-1, 1.241991, 1.845484, 0.0 ],
978 [ 8.6876702e-1, 4.7659001e-1, 1.478224, 2.5672799e-1,
979 7.55777e-1, 1.3229851, 2.03438, 0.0 ],
980 [ 7.5891501e-1, 6.2272799e-1, 1.271322, 3.47904e-1,
981 7.5317699e-1, 1.150767, 1.628476, 0.0 ],
982 [ 7.65257e-1, 6.44647e-1, 1.263824, 3.4548101e-1,
983 7.6384902e-1, 1.214466, 1.7638789, 0.0 ]
986 const IMC_QUANT_LARGE: &[[f32; 56]; 2] = &[
987 [ 1.39236e-1, 3.50548e-1, 5.9547901e-1, 8.5772401e-1,
988 1.121545, 1.3882281, 1.695882, 2.1270809,
989 7.2221003e-2, 1.85177e-1, 2.9521701e-1, 4.12568e-1,
990 5.4068601e-1, 6.7679501e-1, 8.1196898e-1, 9.4765198e-1,
991 1.0779999, 1.203415, 1.337265, 1.481871,
992 1.639982, 1.814766, 2.0701399, 2.449862,
993 3.7533998e-2, 1.02722e-1, 1.6021401e-1, 2.16043e-1,
994 2.7231601e-1, 3.3025399e-1, 3.9022601e-1, 4.52849e-1,
995 5.1794899e-1, 5.8529502e-1, 6.53956e-1, 7.2312802e-1,
996 7.9150802e-1, 8.5891002e-1, 9.28141e-1, 9.9706203e-1,
997 1.062153, 1.12564, 1.189834, 1.256122,
998 1.324469, 1.3955311, 1.468906, 1.545084,
999 1.6264729, 1.711524, 1.802705, 1.91023,
1000 2.0533991, 2.22333, 2.4830019, 3.253329 ],
1001 [ 1.11654e-1, 3.54469e-1, 6.4232099e-1, 9.6128798e-1,
1002 1.295053, 1.61777, 1.989839, 2.51107,
1003 5.7721999e-2, 1.69879e-1, 2.97589e-1, 4.3858799e-1,
1004 5.9039903e-1, 7.4934798e-1, 9.1628098e-1, 1.087297,
1005 1.262751, 1.4288321, 1.6040879, 1.79067,
1006 2.000668, 2.2394669, 2.649332, 5.2760072,
1007 2.9722e-2, 8.7316997e-2, 1.4445201e-1, 2.04247e-1,
1008 2.6879501e-1, 3.3716801e-1, 4.08811e-1, 4.8306999e-1,
1009 5.6049401e-1, 6.3955498e-1, 7.2044599e-1, 8.0427998e-1,
1010 8.8933599e-1, 9.7537601e-1, 1.062461, 1.1510431,
1011 1.240236, 1.326715, 1.412513, 1.500502,
1012 1.591749, 1.686413, 1.785239, 1.891233,
1013 2.0051291, 2.127681, 2.2709141, 2.475826,
1014 2.7219379, 3.101985, 4.686213, 6.2287788 ]
1017 static IMC_CYCLE1: [usize; BANDS] = [
1018 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
1019 17, 18, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 32,
1022 static IMC_CYCLE2: [usize; BANDS] = [
1023 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
1024 15, 16, 17, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29
1027 static IMC_WEIGHTS1: [f32; BANDS-1] = [
1028 0.119595, 0.123124, 0.129192, 9.97377e-2,
1029 8.1923e-2, 9.61153e-2, 8.77885e-2, 8.61174e-2,
1030 9.00882e-2, 9.91658e-2, 0.112991, 0.131126,
1031 0.152886, 0.177292, 0.221782, 0.244917,
1032 0.267386, 0.306816, 0.323046, 0.33729,
1033 0.366773, 0.392557, 0.398076, 0.403302,
1034 0.42451, 0.444777, 0.449188, 0.455445,
1035 0.477853, 0.500669, 0.510395
1038 static IMC_WEIGHTS2: [f32; BANDS-1] = [
1039 3.23466e-3, 3.49886e-3, 3.98413e-3, 1.98116e-3,
1040 1.16465e-3, 1.79283e-3, 1.40372e-3, 1.33274e-3,
1041 1.50523e-3, 1.95064e-3, 2.77472e-3, 4.14725e-3,
1042 6.2776e-3, 9.36401e-3, 1.71397e-2, 2.24052e-2,
1043 2.83971e-2, 4.11689e-2, 4.73165e-2, 5.31631e-2,
1044 6.66614e-2, 8.00824e-2, 8.31588e-2, 8.61397e-2,
1045 9.89229e-2, 0.112197, 0.115227, 0.119613,
1046 0.136174, 0.15445, 0.162685
1049 static IMC_BITALLOC_ADJ: [[f32; 7]; 2] = [
1050 [ 7.6, 4.4, 6.1, 2.3, 6.2, 1.8, 0.0 ],
1051 [ 3.6, 3.7, 5.1, 1.6, 1.5, 1.2, 0.0 ]
1054 static IMC_CODE_LENGTHS: &[[[u8; 18]; 4]; 4] = &[
1056 [ 16, 15, 13, 11, 8, 5, 3, 1, 2, 4, 6, 9, 10, 12, 14, 16, 7, 0 ],
1057 [ 10, 8, 7, 6, 4, 4, 3, 2, 2, 3, 4, 6, 7, 9, 11, 11, 7, 0 ],
1058 [ 15, 15, 14, 11, 8, 6, 4, 2, 1, 4, 5, 7, 9, 10, 12, 13, 4, 0 ],
1059 [ 13, 11, 10, 8, 6, 4, 2, 2, 2, 3, 5, 7, 9, 12, 15, 15, 14, 0 ],
1061 [ 14, 12, 10, 8, 7, 4, 2, 2, 2, 3, 5, 7, 9, 11, 13, 14, 7, 0 ],
1062 [ 14, 13, 11, 8, 6, 4, 3, 2, 2, 3, 5, 7, 9, 10, 12, 14, 3, 0 ],
1063 [ 13, 12, 10, 7, 5, 4, 3, 2, 2, 3, 4, 6, 8, 9, 11, 13, 4, 0 ],
1064 [ 13, 12, 10, 7, 5, 4, 3, 2, 2, 3, 4, 6, 8, 9, 11, 13, 4, 0 ],
1066 [ 16, 14, 12, 10, 8, 5, 3, 1, 2, 4, 7, 9, 11, 13, 15, 17, 6, 17 ],
1067 [ 15, 13, 11, 8, 6, 4, 2, 2, 2, 3, 5, 7, 10, 12, 14, 16, 9, 16 ],
1068 [ 14, 12, 11, 9, 8, 6, 3, 1, 2, 5, 7, 10, 13, 15, 16, 17, 4, 17 ],
1069 [ 16, 14, 12, 9, 7, 5, 2, 2, 2, 3, 4, 6, 8, 11, 13, 15, 10, 16 ],
1071 [ 13, 11, 10, 8, 7, 5, 2, 2, 2, 4, 6, 9, 12, 14, 15, 16, 3, 16 ],
1072 [ 11, 11, 10, 9, 8, 7, 5, 4, 3, 3, 3, 3, 3, 3, 4, 5, 6, 5 ],
1073 [ 9, 9, 7, 6, 5, 4, 3, 3, 2, 3, 4, 5, 4, 5, 5, 6, 8, 6 ],
1074 [ 13, 12, 10, 8, 5, 3, 3, 2, 2, 3, 4, 7, 9, 11, 14, 15, 6, 15 ]
1078 static IMC_CODE_CODES: &[[[u16; 18]; 4]; 4] = &[
1080 [ 0xCC32, 0x6618, 0x1987, 0x0660, 0x00CD, 0x0018, 0x0007, 0x0000, 0x0002,
1081 0x000D, 0x0032, 0x0199, 0x0331, 0x0CC2, 0x330D, 0xCC33, 0x0067, 0x0000 ],
1082 [ 0x02FE, 0x00BE, 0x005E, 0x002D, 0x000A, 0x0009, 0x0003, 0x0003, 0x0000,
1083 0x0002, 0x0008, 0x002C, 0x005D, 0x017E, 0x05FE, 0x05FF, 0x005C, 0x0000 ],
1084 [ 0x5169, 0x5168, 0x28B5, 0x0517, 0x00A3, 0x0029, 0x0008, 0x0003, 0x0000,
1085 0x0009, 0x0015, 0x0050, 0x0144, 0x028A, 0x0A2C, 0x145B, 0x000B, 0x0000 ],
1086 [ 0x1231, 0x048D, 0x0247, 0x0090, 0x0025, 0x0008, 0x0001, 0x0003, 0x0000,
1087 0x0005, 0x0013, 0x0049, 0x0122, 0x0919, 0x48C3, 0x48C2, 0x2460, 0x0000 ]
1089 [ 0x2D1D, 0x0B46, 0x02D0, 0x00B5, 0x0059, 0x000A, 0x0003, 0x0001, 0x0000,
1090 0x0004, 0x0017, 0x005B, 0x0169, 0x05A2, 0x168F, 0x2D1C, 0x0058, 0x0000 ],
1091 [ 0x1800, 0x0C01, 0x0301, 0x0061, 0x0019, 0x0007, 0x0004, 0x0003, 0x0000,
1092 0x0005, 0x000D, 0x0031, 0x00C1, 0x0181, 0x0601, 0x1801, 0x0002, 0x0000 ],
1093 [ 0x1556, 0x0AAA, 0x02AB, 0x0054, 0x0014, 0x000B, 0x0002, 0x0003, 0x0000,
1094 0x0003, 0x0008, 0x002B, 0x00AB, 0x0154, 0x0554, 0x1557, 0x0009, 0x0000 ],
1095 [ 0x1556, 0x0AAA, 0x02AB, 0x0054, 0x0014, 0x000B, 0x0002, 0x0003, 0x0000,
1096 0x0003, 0x0008, 0x002B, 0x00AB, 0x0154, 0x0554, 0x1557, 0x0009, 0x0000 ]
1098 [ 0x2993, 0x0A65, 0x0298, 0x00A7, 0x0028, 0x0004, 0x0000, 0x0001, 0x0001,
1099 0x0003, 0x0015, 0x0052, 0x014D, 0x0533, 0x14C8, 0x5324, 0x000B, 0x5325 ],
1100 [ 0x09B8, 0x026F, 0x009A, 0x0012, 0x0005, 0x0000, 0x0001, 0x0002, 0x0003,
1101 0x0001, 0x0003, 0x0008, 0x004C, 0x0136, 0x04DD, 0x1373, 0x0027, 0x1372 ],
1102 [ 0x0787, 0x01E0, 0x00F1, 0x003D, 0x001F, 0x0006, 0x0001, 0x0001, 0x0001,
1103 0x0002, 0x000E, 0x0079, 0x03C2, 0x0F0D, 0x1E19, 0x3C30, 0x0000, 0x3C31 ],
1104 [ 0x4B06, 0x12C0, 0x04B1, 0x0097, 0x0024, 0x0008, 0x0002, 0x0003, 0x0000,
1105 0x0003, 0x0005, 0x0013, 0x004A, 0x0259, 0x0961, 0x2582, 0x012D, 0x4B07 ]
1107 [ 0x0A5A, 0x0297, 0x014A, 0x0053, 0x0028, 0x000B, 0x0003, 0x0000, 0x0002,
1108 0x0004, 0x0015, 0x00A4, 0x052C, 0x14B7, 0x296C, 0x52DB, 0x0003, 0x52DA ],
1109 [ 0x0193, 0x0192, 0x00C8, 0x0065, 0x0033, 0x0018, 0x0007, 0x0004, 0x0000,
1110 0x0004, 0x0005, 0x0007, 0x0006, 0x0003, 0x0005, 0x0005, 0x000D, 0x0004 ],
1111 [ 0x0012, 0x0013, 0x0005, 0x0003, 0x0000, 0x0003, 0x0005, 0x0004, 0x0003,
1112 0x0003, 0x0005, 0x0005, 0x0004, 0x0004, 0x0003, 0x0005, 0x0008, 0x0004 ],
1113 [ 0x0D66, 0x06B2, 0x01AD, 0x006A, 0x000C, 0x0005, 0x0004, 0x0000, 0x0003,
1114 0x0002, 0x0007, 0x0034, 0x00D7, 0x0358, 0x1ACF, 0x359C, 0x001B, 0x359D ]
1118 const IMC_CB_SELECTOR: [[usize; BANDS]; 4] = [
1119 [ 1, 1, 1, 1, 1, 1, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0,
1120 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2 ],
1121 [ 0, 2, 0, 3, 2, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1122 0, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ],
1123 [ 1, 1, 1, 1, 1, 1, 1, 3, 3, 3, 3, 3, 3, 3, 3, 3,
1124 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2 ],
1125 [ 0, 1, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
1126 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]
1134 use test::wavwriter::WavWriter;
1138 let avi_dmx = find_demuxer("avi").unwrap();
1139 let mut file = File::open("assets/neal73_saber.avi").unwrap();
1140 let mut fr = FileReader::new_read(&mut file);
1141 let mut br = ByteReader::new(&mut fr);
1142 let mut dmx = avi_dmx.new_demuxer(&mut br);
1143 dmx.open().unwrap();
1145 let mut file = File::create("assets/imc-out.wav").unwrap();
1146 let mut fw = FileWriter::new_write(&mut file);
1147 let mut wr = ByteWriter::new(&mut fw);
1148 let mut wwr = WavWriter::new(&mut wr);
1149 let mut wrote_header = false;
1151 let mut decs: Vec<Option<Box<NADecoder>>> = Vec::new();
1152 for i in 0..dmx.get_num_streams() {
1153 let s = dmx.get_stream(i).unwrap();
1154 let info = s.get_info();
1155 let decfunc = find_decoder(info.get_name());
1156 if let Some(df) = decfunc {
1157 if info.is_audio() {
1158 let mut dec = (df)();
1159 dec.init(info).unwrap();
1160 decs.push(Some(dec));
1170 let pktres = dmx.get_frame();
1171 if let Err(e) = pktres {
1172 if e == DemuxerError::EOF { break; }
1175 let pkt = pktres.unwrap();
1176 //if pkt.get_pts().unwrap() > 10 { break; }
1177 let streamno = pkt.get_stream().get_id() as usize;
1178 if let Some(ref mut dec) = decs[streamno] {
1179 let frm_ = dec.decode(&pkt).unwrap();
1180 let frm = frm_.borrow();
1181 if frm.get_info().is_audio() {
1183 wwr.write_header(frm.get_info().as_ref().get_properties().get_audio_info().unwrap()).unwrap();
1184 wrote_header = true;
1186 wwr.write_frame(frm.get_buffer()).unwrap();