5 use nihav_core::formats::*;
6 use nihav_core::frame::*;
7 use nihav_core::codecs::*;
8 use nihav_core::io::bitreader::*;
9 use nihav_core::io::codebook::*;
10 use nihav_codec_support::dsp::fft::*;
11 use nihav_codec_support::dsp::window::*;
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 new_floor: [f32; BANDS],
29 log_floor: [f32; BANDS],
30 log_floor2: [f32; BANDS],
31 bit_est: [f32; BANDS],
32 mask_wght: [f32; BANDS],
33 adj_floor: [f32; BANDS],
35 last_im: [f32; COEFFS/2],
39 band_width: [usize; BANDS],
40 band_present: [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 new_floor: [0.0; BANDS],
57 log_floor: [0.0; BANDS],
58 log_floor2: [0.0; BANDS],
59 bit_est: [0.0; BANDS],
60 mask_wght: [0.0; BANDS],
61 adj_floor: [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_present: [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_present[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;
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.new_floor.iter() { if *coef > peak { peak = *coef; } }
112 for band in 0..BANDS-1 {
113 ch_data.bit_est[band] = ch_data.log_floor2[band] - ch_data.mask_wght[band].log2();
115 ch_data.bit_est[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.new_floor[band] < peak { idx += 1; }
126 ch_data.bit_est[band] += IMC_BITALLOC_ADJ[adj_idx][idx];
131 ch_data.bit_est[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.bit_est[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.bit_est[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] = f32::from(self.band_bits[band]) * -2.0 + ch_data.bit_est[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] = f32::from(self.band_bits[band]) * -2.0 + ch_data.bit_est[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] = f32::from(self.band_bits[band]) * -2.0 + ch_data.bit_est[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);
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_10, sqrt_tab }
324 info: NACodecInfoRef,
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);
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 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(f32::from(max_coef));
444 let level = br.read(4)?;
445 ch_data.new_floor[i] = c1 * self.luts.exp_lev[level as usize];
446 ch_data.log_floor[i] = c2 - 1.4533435415 * (level as f32);
448 ch_data.new_floor[i] = c1;
449 ch_data.log_floor[i] = c2;
451 self.ba.band_width[i] = IMC_BANDS[i + 1] - IMC_BANDS[i];
453 ch_data.log_floor2[i] = ch_data.log_floor[i] * 2.0;
454 ch_data.mask_wght[i] = 1.0;
460 fn calculate_channel_values(&mut self, ch: usize) {
461 let ch_data = &mut self.ch_data[ch];
462 let mut tmp2: [f32; BANDS+1] = [0.0; BANDS+1];
463 let mut tmp3: [f32; BANDS] = [0.0; BANDS];
465 for band in 0..BANDS {
466 ch_data.mask_wght[band] = 0.0;
468 if self.ba.band_width[band] > 0 {
469 val = f64::from(ch_data.new_floor[band]).powi(2);
470 ch_data.log_floor2[band] = 2.0 * ch_data.log_floor[band];
473 ch_data.log_floor2[band] = -30000.0;
475 let tmp = val * (self.ba.band_width[band] as f64) * 0.01;
476 if val <= 1.0e-30 { tmp3[band] = 0.0; }
477 else { tmp3[band] = tmp as f32; }
480 for band in 0..BANDS {
481 let next_band = self.cycle1[band];
482 for band2 in band..next_band {
483 ch_data.mask_wght[band2] += tmp3[band];
485 tmp2[next_band] += tmp3[band];
489 for band in 1..BANDS {
490 accum = (tmp2[band] + accum) * self.weights1[band - 1];
491 ch_data.mask_wght[band] += accum;
494 let mut tmp2: [f32; BANDS] = [0.0; BANDS];
496 for band in 1..BANDS {
497 let prev_band = self.cycle2[band];
498 for band2 in prev_band+1..band {
499 ch_data.mask_wght[band2] += tmp3[band];
501 tmp2[prev_band + 1] += tmp3[band];
505 for i in 0..BANDS-1 {
506 let band = BANDS - 2 - i;
507 accum = (tmp2[band + 1] + accum) * self.weights2[band];
508 ch_data.mask_wght[band] += accum;
512 fn read_level_coeffs(&mut self, br: &mut BitReader, reset: bool, sel_idx: usize, ch: usize) -> DecoderResult<()> {
513 let mut level: [i8; BANDS] = [0; BANDS];
517 level[0] = br.read(7)? as i8;
521 for i in start..BANDS {
522 level[i] = br.read_cb(&self.codes[sel_idx][IMC_CB_SELECTOR[sel_idx][i]])? as i8;
524 level[i] += br.read(4)? as i8;
526 self.ba.keep_flag[i] = level[i] == 16;
529 let ch_data = &mut self.ch_data[ch];
530 let (mut c1, mut c2) = calc_maxcoef(f32::from(level[0]));
531 ch_data.new_floor[0] = c1;
532 ch_data.log_floor[0] = c2;
535 ch_data.new_floor[i] = 1.0;
536 ch_data.log_floor[i] = 0.0;
541 } else if level[i] < 25 {
542 lval = level[i] - 32;
544 lval = level[i] - 16;
546 c1 *= self.luts.exp_10[(lval + 16) as usize];
547 c2 += 0.83048 * f32::from(lval);
548 ch_data.new_floor[i] = c1;
549 ch_data.log_floor[i] = c2;
553 let ch_data = &mut self.ch_data[ch];
556 let lval = level[i] - 7;
557 ch_data.new_floor[i] = self.luts.exp_10[(lval + 16) as usize] * ch_data.old_floor[i];
558 ch_data.log_floor[i] += f32::from(lval) * 0.83048;
560 ch_data.new_floor[i] = ch_data.old_floor[i];
565 self.ba.band_width[0] = IMC_BANDS[1] - IMC_BANDS[0];
568 self.ba.band_width[i] = IMC_BANDS[i + 1] - IMC_BANDS[i];
570 self.ba.band_width[i] = 0;
574 for i in 0..BANDS-1 {
575 if self.ba.band_width[i] > 0 {
576 self.ba.band_present[i] = br.read_bool()?;
579 self.calculate_channel_values(ch);
584 fn read_skip_flags(&mut self, br: &mut BitReader) -> DecoderResult<()> {
585 let ba = &mut self.ba;
586 for band in 0..BANDS {
587 if !ba.band_present[band] || ba.band_width[band] == 0 { continue; }
589 if !ba.band_skip[band] {
590 ba.skip_flag_bits[band] = (IMC_BANDS[band + 1] - IMC_BANDS[band]) as u8;
591 for i in IMC_BANDS[band]..IMC_BANDS[band + 1] {
592 ba.skip_flag[i] = br.read_bool()?;
594 ba.skips_per_band[band] += 1;
598 let mut i = IMC_BANDS[band];
599 while i < IMC_BANDS[band + 1] - 1 {
600 if !br.read_bool()? {
601 ba.skip_flag_bits[band] += 1;
602 ba.skip_flag[i] = true;
603 ba.skip_flag[i + 1] = true;
604 ba.skips_per_band[band] += 2;
607 ba.skip_flag_bits[band] += 2;
608 ba.skip_flag[i] = false;
609 ba.skip_flag[i + 1] = true;
610 ba.skips_per_band[band] += 1;
612 ba.skip_flag_bits[band] += 3;
613 if !br.read_bool()? {
614 ba.skip_flag[i] = true;
615 ba.skips_per_band[band] += 1;
617 ba.skip_flag[i] = false;
619 ba.skip_flag[i + 1] = false;
624 if i != IMC_BANDS[band + 1] {
625 ba.skip_flag_bits[band] += 1;
626 ba.skip_flag[i] = br.read_bool()?;
628 ba.skips_per_band[band] += 1;
636 fn read_bitalloc_delta(&mut self, br: &mut BitReader, ch: usize) -> DecoderResult<()> {
637 for band in 0..BANDS {
638 self.ba.band_bitsum[band] = 0;
639 self.ba.band_skip[band] = false;
640 for i in IMC_BANDS[band]..IMC_BANDS[band + 1] {
641 self.ba.band_bitsum[band] += self.ba.cw_len[i] as usize;
643 if self.ba.band_present[band] {
644 let band_w = IMC_BANDS[band + 1] - IMC_BANDS[band];
645 let bitsum = self.ba.band_bitsum[band] as usize;
646 if (bitsum > 0) && (((band_w * 3) >> 1) > bitsum) {
647 self.ba.band_skip[band] = true;
652 self.read_skip_flags(br)?;
654 let mut ch_data = &mut self.ch_data[ch];
655 for band in 0..BANDS {
656 ch_data.adj_floor[band] = ch_data.new_floor[band];
657 let band_w = IMC_BANDS[band + 1] - IMC_BANDS[band];
658 let nonskip = band_w - self.ba.skips_per_band[band];
659 if self.ba.band_present[band] && nonskip > 0 {
660 ch_data.adj_floor[band] *= self.luts.sqrt_tab[band_w] / self.luts.sqrt_tab[nonskip];
664 let mut bits_freed: i32 = 0;
665 for band in 0..BANDS {
666 if !self.ba.band_present[band] { continue; }
667 for i in IMC_BANDS[band]..IMC_BANDS[band + 1] {
668 if self.ba.skip_flag[i] {
669 bits_freed += i32::from(self.ba.cw_len[i]);
670 self.ba.cw_len[i] = 0;
673 bits_freed -= i32::from(self.ba.skip_flag_bits[band]);
676 if bits_freed < 0 { return Err(DecoderError::Bug); }
677 self.ba.adjust_bit_allocation(&mut ch_data, bits_freed);
682 fn read_coeffs(&mut self, br: &mut BitReader) -> DecoderResult<()> {
683 for band in 0..BANDS {
684 if self.ba.band_bitsum[band] == 0 { continue; }
685 if !self.ba.band_present[band] && (self.ba.band_width[band] == 0) { continue; }
686 for i in IMC_BANDS[band]..IMC_BANDS[band + 1] {
687 let len = self.ba.cw_len[i];
688 if len > 0 && (!self.ba.band_present[band] || !self.ba.skip_flag[i]) {
689 self.ba.coeff[i] = br.read(len)? as u8;
691 self.ba.coeff[i] = 0;
698 fn inv_quant(&mut self, ch: usize, raw_coeffs: bool) {
699 let qidx: usize = if raw_coeffs { 1 } else { 0 };
700 let ch_data = &mut self.ch_data[ch];
701 for band in 0..BANDS {
702 for i in IMC_BANDS[band]..IMC_BANDS[band + 1] {
704 let cw_len = self.ba.cw_len[i];
705 if cw_len == 0 || self.ba.skip_flag[i] { continue; }
707 let val = self.ba.coeff[i] as usize;
708 let mid = 1 << (cw_len - 1);
709 let max = (1 << cw_len) - 1;
711 let quant = &IMC_QUANT_LARGE[qidx];
713 ch_data.cw[i] = quant[val - 8] * ch_data.adj_floor[band];
715 ch_data.cw[i] = -quant[max - val - 8] * ch_data.adj_floor[band];
718 let idx = qidx + (if self.ba.band_present[band] { 2 } else { 0 });
719 let quant = &IMC_QUANT_SMALL[idx];
721 ch_data.cw[i] = quant[val - 1] * ch_data.adj_floor[band];
723 ch_data.cw[i] = -quant[max - val - 1] * ch_data.adj_floor[band];
730 fn decode_block(&mut self, data: &[u8], ch: usize, dst: &mut [f32]) -> DecoderResult<()> {
731 let mut br = BitReader::new(&data[BLOCK_SIZE*ch..][..BLOCK_SIZE], BitReaderMode::LE16MSB);
732 let hdr = br.read(9)?;
733 validate!((hdr & 0x18) == 0);
735 let reset = br.read_bool()?;
736 let fixed_head = br.read_bool()?;
737 let raw_coeffs = br.read_bool()?;
738 let weight_idx = br.read(1)? as usize;
741 self.ch_data[ch].reset();
747 self.read_level_coeffs_raw(&mut br, ch)?;
749 let cb_idx = (if reset { 2 } else { 0 }) + (if fixed_head { 1 } else { 0 });
750 self.read_level_coeffs(&mut br, reset, cb_idx, ch)?;
753 self.ch_data[ch].old_floor.copy_from_slice(&self.ch_data[ch].new_floor);
755 let mut bitcount: usize = 0;
758 self.ba.band_bits[0] = 5;
760 self.ba.cw_len[i] = 5;
764 if raw_coeffs || !self.ba.keep_flag[band]{
769 self.ba.band_bits[band] = bits;
770 for i in IMC_BANDS[band]..IMC_BANDS[band + 1] {
771 self.ba.cw_len[i] = bits;
772 bitcount += bits as usize;
778 if self.ba.band_width[BANDS - 1] != 0 {
783 if self.ba.band_width[BANDS - 1] != 0 {
788 validate!(br.tell() + bitcount < BLOCK_SIZE * 8);
789 self.ba.calculate_bit_allocation(&mut self.ch_data[ch], 512 - bitcount - br.tell(), fixed_head, weight_idx)?;
792 self.read_bitalloc_delta(&mut br, ch)?;
795 for band in 0..BANDS {
796 self.ba.band_bitsum[band] = 0;
797 for i in IMC_BANDS[band]..IMC_BANDS[band + 1] {
798 if !self.ba.skip_flag[i] {
799 self.ba.band_bitsum[band] += self.ba.cw_len[i] as usize;
804 self.read_coeffs(&mut br)?;
805 self.inv_quant(ch, raw_coeffs);
806 self.imdct.imdct(&self.ch_data[ch].cw, dst, &mut self.ch_data[ch].last_im);
814 let mut window: [f32; COEFFS] = [0.0; COEFFS];
815 generate_window(WindowType::Sine, 1.0, COEFFS, true, &mut window);
816 let mut pretwiddle1: [f32; COEFFS/2] = [0.0; COEFFS/2];
817 let mut pretwiddle2: [f32; COEFFS/2] = [0.0; COEFFS/2];
818 let mut posttwiddle: [FFTComplex; COEFFS/2] = [FFTC_ZERO; COEFFS/2];
819 for i in 0..COEFFS/2 {
821 let base = (n * 4.0 + 1.0) / 1024.0 * consts::PI;
825 pretwiddle1[i] = -(r1 + r2) * consts::SQRT_2;
826 pretwiddle2[i] = (r1 - r2) * consts::SQRT_2;
828 pretwiddle1[i] = (r1 + r2) * consts::SQRT_2;
829 pretwiddle2[i] = -(r1 - r2) * consts::SQRT_2;
831 posttwiddle[i] = FFTComplex::exp(consts::PI / 256.0 * n).scale(1.0/32768.0);
837 tmp: [FFTC_ZERO; COEFFS/2],
838 fft: FFTBuilder::new_fft(COEFFS/2, false),
842 fn imdct(&mut self, coeffs: &[f32; COEFFS], dst: &mut [f32], last_im: &mut [f32; COEFFS/2]) {
843 for i in 0..COEFFS/2 {
844 let in2 = coeffs[i * 2];
845 let in1 = coeffs[COEFFS - 1 - i * 2];
846 let c2 = self.pretwiddle1[i];
847 let c1 = self.pretwiddle2[i];
848 self.tmp[i].re = -(c2 * in1 + c1 * in2);
849 self.tmp[i].im = c1 * in1 - c2 * in2;
851 self.fft.do_ifft_inplace(&mut self.tmp);
852 for i in 0..COEFFS/2 {
853 let tmp = !(self.tmp[i] * self.posttwiddle[i]);
854 let c1 = self.window[i * 2];
855 let c2 = self.window[COEFFS - 1 - i * 2];
857 dst[i * 2] = c2 * im + c1 * tmp.re;
858 dst[COEFFS - 1 - i * 2] = c1 * im - c2 * tmp.re;
864 const CHMAP_MONO: [NAChannelType; 1] = [NAChannelType::C];
865 const CHMAP_STEREO: [NAChannelType; 2] = [NAChannelType::L, NAChannelType::R];
867 impl NADecoder for IMCDecoder {
868 fn init(&mut self, _supp: &mut NADecoderSupport, info: NACodecInfoRef) -> DecoderResult<()> {
869 if let NACodecTypeInfo::Audio(ainfo) = info.get_properties() {
870 self.chmap = NAChannelMap::new();
871 match ainfo.get_channels() {
872 1 => { self.chmap.add_channels(&CHMAP_MONO); },
873 2 => { self.chmap.add_channels(&CHMAP_STEREO); },
874 _ => { return Err(DecoderError::InvalidData); },
876 self.ainfo = NAAudioInfo::new(ainfo.get_sample_rate(),
877 ainfo.get_channels(),
879 self.info = info.replace_info(NACodecTypeInfo::Audio(self.ainfo));
882 self.generate_iac_tables(ainfo.get_sample_rate() as f32);
886 Err(DecoderError::InvalidData)
889 fn decode(&mut self, _supp: &mut NADecoderSupport, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
890 let info = pkt.get_stream().get_info();
891 validate!(info.get_properties().is_audio());
892 let pktbuf = pkt.get_buffer();
894 let nblocks = pktbuf.len() / BLOCK_SIZE / (self.ainfo.get_channels() as usize);
895 let duration = COEFFS * nblocks;
897 let abuf = alloc_audio_buffer(self.ainfo, duration, self.chmap.clone())?;
898 let mut adata = abuf.get_abuf_f32().unwrap();
899 let dst = adata.get_data_mut().unwrap();
901 let mut start: usize = 0;
902 let channels = self.ainfo.get_channels() as usize;
903 for chunk in pktbuf.chunks(BLOCK_SIZE * channels) {
904 for ch in 0..channels {
905 let off = abuf.get_offset(ch as usize) + start;
906 self.decode_block(chunk, ch as usize, &mut dst[off..off+COEFFS])?;
908 if (channels == 2) && ((chunk[1] & 0x20) != 0) {
909 let off1 = abuf.get_offset(0) + start;
910 let off2 = abuf.get_offset(1) + start;
912 let l = dst[off1 + i];
913 let r = dst[off2 + i];
914 dst[off1 + i] = l + r;
915 dst[off2 + i] = l - r;
921 let mut frm = NAFrame::new_from_pkt(pkt, self.info.clone(), abuf);
922 frm.set_keyframe(true);
925 fn flush(&mut self) {
929 pub fn get_decoder_imc() -> Box<dyn NADecoder + Send> {
930 Box::new(IMCDecoder::new(true))
933 pub fn get_decoder_iac() -> Box<dyn NADecoder + Send> {
934 Box::new(IMCDecoder::new(false))
937 struct IMCCodeReader { sel1: usize, sel2: usize }
940 fn new(sel1: usize, sel2: usize) -> Self { IMCCodeReader { sel1, 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 { u32::from(IMC_CODE_CODES[self.sel1][self.sel2][idx]) }
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 ]
1112 use nihav_core::codecs::RegisteredDecoders;
1113 use nihav_core::demuxers::RegisteredDemuxers;
1114 use nihav_codec_support::test::dec_video::*;
1115 use crate::indeo_register_all_codecs;
1116 use nihav_commonfmt::generic_register_all_demuxers;
1119 let mut dmx_reg = RegisteredDemuxers::new();
1120 generic_register_all_demuxers(&mut dmx_reg);
1121 let mut dec_reg = RegisteredDecoders::new();
1122 indeo_register_all_codecs(&mut dec_reg);
1124 // let file = "assets/Indeo/neal73_saber.avi";
1125 // let file = "assets/Indeo/IMC/hvalen.avi";
1126 let file = "assets/Indeo/IMC/8khz.avi";
1127 // let file = "assets/Indeo/STsKlassFist-1a.avi";
1128 // let file = "assets/Indeo/IMC/Angel Bday.avi";
1129 test_decode_audio("avi", file, None, None/*Some("imc")*/, &dmx_reg, &dec_reg);
1130 //test_file_decoding("avi", file, None, false, true, None);