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 #[allow(clippy::cognitive_complexity)]
107 fn calculate_bit_allocation(&mut self, ch_data: &mut IMCChannel, bits: usize, fixed_head: bool, adj_idx: usize) -> DecoderResult<()> {
110 for coef in ch_data.new_floor.iter() { if *coef > peak { peak = *coef; } }
113 for band in 0..BANDS-1 {
114 ch_data.bit_est[band] = ch_data.log_floor2[band] - ch_data.mask_wght[band].log2();
116 ch_data.bit_est[BANDS - 1] = BITALLOC_LIMIT;
118 for band in 0..BANDS {
120 let band_w = IMC_BANDS[band + 1] - IMC_BANDS[band];
121 if band_w == self.band_width[band] { idx = 0; }
122 if band_w > self.band_width[band] { idx = 1; }
123 if band_w/2 >= self.band_width[band] { idx = 2; }
126 if ch_data.new_floor[band] < peak { idx += 1; }
127 ch_data.bit_est[band] += IMC_BITALLOC_ADJ[adj_idx][idx];
132 ch_data.bit_est[i] = BITALLOC_LIMIT;
136 let start = if fixed_head { 4 } else { 0 };
140 for band in start..BANDS-1 {
141 a_width += self.band_width[band];
142 pool += (self.band_width[band] as f32) * ch_data.bit_est[band];
144 validate!(a_width > 0);
146 self.band_width[BANDS - 1] = 0;
147 pool = (pool * 0.5 - (bits as f32)) / (a_width as f32);
149 let free_bits = bits as i32;
150 let mut cur_bits: i32 = 0;
153 for i in 0..BANDS/2 {
154 let diff = cur_bits - free_bits;
155 if diff.abs() <= 8 { break; }
159 for band in start..BANDS {
160 let mut len = (ch_data.bit_est[band] * 0.5 - pool + 0.5) as i32;
161 if len < 0 { len = 0; }
162 if len > 6 { len = 6; }
163 self.band_bits[band] = len as u8;
164 cur_bits += (self.band_width[band] as i32) * len;
166 acc += self.band_width[band] as i32;
170 let mut lflag = flag;
172 if free_bits < cur_bits { flag = -1; }
173 if i == 0 { lflag = flag; }
177 pool += ((cur_bits - free_bits) as f32) / (((mmcount + 1) * acc) as f32);
180 for band in start..BANDS {
181 for i in IMC_BANDS[band]..IMC_BANDS[band + 1] {
182 self.cw_len[i] = self.band_bits[band];
186 if free_bits > cur_bits {
187 let mut tmp: [f32; BANDS] = [BITALLOC_LIMIT; BANDS];
188 for band in 0..BANDS {
189 if self.band_bits[band] != 6 {
190 tmp[band] = f32::from(self.band_bits[band]) * -2.0 + ch_data.bit_est[band] - 0.415;
194 while (peak > BITALLOC_LIMIT) && (cur_bits < free_bits) {
195 peak = BITALLOC_LIMIT;
196 let mut idx: Option<usize> = None;
197 for band in 0..BANDS {
198 if tmp[band] > peak {
203 if let Some(band) = idx {
205 self.band_bits[band] += 1;
206 if self.band_bits[band] == 6 {
207 tmp[band] = BITALLOC_LIMIT;
209 for i in IMC_BANDS[band]..IMC_BANDS[band + 1] {
212 if cur_bits >= free_bits {
220 if cur_bits > free_bits {
221 let mut tmp: [f32; BANDS] = [BITALLOC_TOP_LIMIT; BANDS];
222 for band in start..BANDS {
223 if self.band_bits[band] != 0 {
224 tmp[band] = f32::from(self.band_bits[band]) * -2.0 + ch_data.bit_est[band] - 0.415 + 2.0;
227 while free_bits < cur_bits {
228 let mut low = BITALLOC_TOP_LIMIT;
230 for band in 0..BANDS {
237 self.band_bits[idx] -= 1;
238 if self.band_bits[idx] == 0 {
239 tmp[idx] = BITALLOC_TOP_LIMIT;
241 for i in IMC_BANDS[idx]..IMC_BANDS[idx + 1] {
242 if self.cw_len[i] > 0 {
245 if cur_bits <= free_bits {
256 fn adjust_bit_allocation(&mut self, ch_data: &mut IMCChannel, free_bits: i32) {
257 let mut tmp: [f32; BANDS] = [BITALLOC_LIMIT; BANDS];
258 for band in 0..BANDS {
259 if self.band_bits[band] != 6 {
260 tmp[band] = f32::from(self.band_bits[band]) * -2.0 + ch_data.bit_est[band] - 0.415;
263 let mut used_bits: i32 = 0;
265 while (peak > BITALLOC_LIMIT) && (used_bits < free_bits) {
266 peak = BITALLOC_LIMIT;
267 let mut idx: Option<usize> = None;
268 for band in 0..BANDS {
269 if tmp[band] > peak {
274 if let Some(band) = idx {
276 self.band_bits[band] += 1;
277 if self.band_bits[band] == 6 {
278 tmp[band] = BITALLOC_LIMIT;
280 for i in IMC_BANDS[band]..IMC_BANDS[band + 1] {
281 if self.cw_len[i] >= 6 { continue; }
284 if used_bits >= free_bits {
301 let mut exp_lev: [f32; 16] = [0.0; 16];
303 exp_lev[lev] = 10.0f32.powf(-(lev as f32) * 0.4375);
306 let mut exp_10: [f32; 32] = [0.0; 32];
308 exp_10[i] = 10.0f32.powf(((i as f32) - 16.0) * 0.25);
311 let mut sqrt_tab: [f32; 32] = [0.0; 32];
313 sqrt_tab[i] = (i as f32).sqrt();
316 LUTs { exp_lev, exp_10, sqrt_tab }
325 info: NACodecInfoRef,
327 codes: [[Codebook<u8>; 4]; 4],
328 ch_data: [IMCChannel; 2],
332 cycle1: [usize; BANDS],
333 cycle2: [usize; BANDS],
334 weights1: [f32; BANDS-1],
335 weights2: [f32; BANDS-1],
340 fn freq2bark(freq: f32) -> f32 {
341 3.5 * ((freq / 7500.0) * (freq / 7500.0)).atan() + 13.0 * (freq * 0.00076).atan()
344 fn calc_maxcoef(coef: f32) -> (f32, f32) {
345 let c1 = 20000.0 / 10.0f32.powf(coef * 0.057031251);
350 fn new(is_imc: bool) -> Self {
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 let mut ucodes: mem::MaybeUninit::<[[Codebook<u8>; 4]; 4]> = mem::MaybeUninit::uninit();
365 let mut cr = IMCCodeReader::new(i, j);
366 ptr::write(&mut (*ucodes.as_mut_ptr())[i][j], Codebook::new(&mut cr, CodebookMode::MSB).unwrap());
373 chmap: NAChannelMap::new(),
374 ainfo: NAAudioInfo::new(0, 0, SND_F32P_FORMAT, 0),
375 info: NACodecInfo::new_dummy(),
378 ch_data: [IMCChannel::new(), IMCChannel::new()],
380 imdct: IMDCTContext::new(),
390 fn generate_iac_tables(&mut self, sample_rate: f32) {
391 let scale = sample_rate / 256.0 / 2.0 * 0.5;
392 let nyq_freq = sample_rate / 2.0;
393 let mut last_bark = 0.0;
394 let mut freq_max: [f32; BANDS] = [0.0; BANDS];
395 let mut freq_mid: [f32; BANDS] = [0.0; BANDS];
396 let mut freq_min: [f32; BANDS] = [0.0; BANDS];
397 for band in 0..BANDS {
398 let freq = ((IMC_BANDS[band] + IMC_BANDS[band + 1] - 1) as f32) * scale;
399 let bark = freq2bark(freq);
401 let bark_diff = bark - last_bark;
402 self.weights1[band - 1] = 10.0f32.powf(-1.0 * bark_diff);
403 self.weights2[band - 1] = 10.0f32.powf(-2.7 * bark_diff);
406 freq_mid[band] = freq;
408 let mut tmp_freq = freq;
409 while tmp_freq < nyq_freq {
411 if freq2bark(tmp_freq) > bark + 0.5 { break; }
413 freq_max[band] = tmp_freq;
415 let mut tmp_freq = freq;
416 while tmp_freq > 0.0 {
418 if freq2bark(tmp_freq) < bark - 0.5 { break; }
420 freq_min[band] = tmp_freq;
423 for band in 0..BANDS {
424 let mut s_band = BANDS - 1;
425 while s_band > 0 && freq_max[band] <= freq_mid[s_band] { s_band -= 1; }
426 self.cycle1[band] = s_band + 1;
430 for band in 1..BANDS {
432 while s_band < BANDS-1 && freq_min[band] >= freq_mid[s_band] { s_band += 1; }
433 self.cycle2[band] = s_band - 1;
437 fn read_level_coeffs_raw(&mut self, br: &mut BitReader, ch: usize) -> DecoderResult<()> {
438 let ch_data = &mut self.ch_data[ch];
439 let maxc_pos = br.read(5)? as usize;
440 let max_coef = br.read(7)? as u8;
442 let (c1, c2) = calc_maxcoef(f32::from(max_coef));
445 let level = br.read(4)?;
446 ch_data.new_floor[i] = c1 * self.luts.exp_lev[level as usize];
447 ch_data.log_floor[i] = c2 - 1.4533435415 * (level as f32);
449 ch_data.new_floor[i] = c1;
450 ch_data.log_floor[i] = c2;
452 self.ba.band_width[i] = IMC_BANDS[i + 1] - IMC_BANDS[i];
454 ch_data.log_floor2[i] = ch_data.log_floor[i] * 2.0;
455 ch_data.mask_wght[i] = 1.0;
461 fn calculate_channel_values(&mut self, ch: usize) {
462 let 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.mask_wght[band] = 0.0;
469 if self.ba.band_width[band] > 0 {
470 val = f64::from(ch_data.new_floor[band]).powi(2);
471 ch_data.log_floor2[band] = 2.0 * ch_data.log_floor[band];
474 ch_data.log_floor2[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.mask_wght[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.mask_wght[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.mask_wght[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.mask_wght[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 ch_data = &mut self.ch_data[ch];
531 let (mut c1, mut c2) = calc_maxcoef(f32::from(level[0]));
532 ch_data.new_floor[0] = c1;
533 ch_data.log_floor[0] = c2;
536 ch_data.new_floor[i] = 1.0;
537 ch_data.log_floor[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 * f32::from(lval);
549 ch_data.new_floor[i] = c1;
550 ch_data.log_floor[i] = c2;
554 let ch_data = &mut self.ch_data[ch];
557 let lval = level[i] - 7;
558 ch_data.new_floor[i] = self.luts.exp_10[(lval + 16) as usize] * ch_data.old_floor[i];
559 ch_data.log_floor[i] += f32::from(lval) * 0.83048;
561 ch_data.new_floor[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;
575 for i in 0..BANDS-1 {
576 if self.ba.band_width[i] > 0 {
577 self.ba.band_present[i] = br.read_bool()?;
580 self.calculate_channel_values(ch);
585 fn read_skip_flags(&mut self, br: &mut BitReader) -> DecoderResult<()> {
586 let ba = &mut self.ba;
587 for band in 0..BANDS {
588 if !ba.band_present[band] || ba.band_width[band] == 0 { continue; }
590 if !ba.band_skip[band] {
591 ba.skip_flag_bits[band] = (IMC_BANDS[band + 1] - IMC_BANDS[band]) as u8;
592 for i in IMC_BANDS[band]..IMC_BANDS[band + 1] {
593 ba.skip_flag[i] = br.read_bool()?;
595 ba.skips_per_band[band] += 1;
599 let mut i = IMC_BANDS[band];
600 while i < IMC_BANDS[band + 1] - 1 {
601 if !br.read_bool()? {
602 ba.skip_flag_bits[band] += 1;
603 ba.skip_flag[i] = true;
604 ba.skip_flag[i + 1] = true;
605 ba.skips_per_band[band] += 2;
608 ba.skip_flag_bits[band] += 2;
609 ba.skip_flag[i] = false;
610 ba.skip_flag[i + 1] = true;
611 ba.skips_per_band[band] += 1;
613 ba.skip_flag_bits[band] += 3;
614 if !br.read_bool()? {
615 ba.skip_flag[i] = true;
616 ba.skips_per_band[band] += 1;
618 ba.skip_flag[i] = false;
620 ba.skip_flag[i + 1] = false;
625 if i != IMC_BANDS[band + 1] {
626 ba.skip_flag_bits[band] += 1;
627 ba.skip_flag[i] = br.read_bool()?;
629 ba.skips_per_band[band] += 1;
637 fn read_bitalloc_delta(&mut self, br: &mut BitReader, ch: usize) -> DecoderResult<()> {
638 for band in 0..BANDS {
639 self.ba.band_bitsum[band] = 0;
640 self.ba.band_skip[band] = false;
641 for i in IMC_BANDS[band]..IMC_BANDS[band + 1] {
642 self.ba.band_bitsum[band] += self.ba.cw_len[i] as usize;
644 if self.ba.band_present[band] {
645 let band_w = IMC_BANDS[band + 1] - IMC_BANDS[band];
646 let bitsum = self.ba.band_bitsum[band];
647 if (bitsum > 0) && (((band_w * 3) >> 1) > bitsum) {
648 self.ba.band_skip[band] = true;
653 self.read_skip_flags(br)?;
655 let ch_data = &mut self.ch_data[ch];
656 for band in 0..BANDS {
657 ch_data.adj_floor[band] = ch_data.new_floor[band];
658 let band_w = IMC_BANDS[band + 1] - IMC_BANDS[band];
659 let nonskip = band_w - self.ba.skips_per_band[band];
660 if self.ba.band_present[band] && nonskip > 0 {
661 ch_data.adj_floor[band] *= self.luts.sqrt_tab[band_w] / self.luts.sqrt_tab[nonskip];
665 let mut bits_freed: i32 = 0;
666 for band in 0..BANDS {
667 if !self.ba.band_present[band] { continue; }
668 for i in IMC_BANDS[band]..IMC_BANDS[band + 1] {
669 if self.ba.skip_flag[i] {
670 bits_freed += i32::from(self.ba.cw_len[i]);
671 self.ba.cw_len[i] = 0;
674 bits_freed -= i32::from(self.ba.skip_flag_bits[band]);
677 if bits_freed < 0 { return Err(DecoderError::Bug); }
678 self.ba.adjust_bit_allocation(ch_data, bits_freed);
683 fn read_coeffs(&mut self, br: &mut BitReader) -> DecoderResult<()> {
684 for band in 0..BANDS {
685 if self.ba.band_bitsum[band] == 0 { continue; }
686 if !self.ba.band_present[band] && (self.ba.band_width[band] == 0) { continue; }
687 for i in IMC_BANDS[band]..IMC_BANDS[band + 1] {
688 let len = self.ba.cw_len[i];
689 if len > 0 && (!self.ba.band_present[band] || !self.ba.skip_flag[i]) {
690 self.ba.coeff[i] = br.read(len)? as u8;
692 self.ba.coeff[i] = 0;
699 fn inv_quant(&mut self, ch: usize, raw_coeffs: bool) {
700 let qidx: usize = if raw_coeffs { 1 } else { 0 };
701 let ch_data = &mut self.ch_data[ch];
702 for band in 0..BANDS {
703 for i in IMC_BANDS[band]..IMC_BANDS[band + 1] {
705 let cw_len = self.ba.cw_len[i];
706 if cw_len == 0 || self.ba.skip_flag[i] { continue; }
708 let val = self.ba.coeff[i] as usize;
709 let mid = 1 << (cw_len - 1);
710 let max = (1 << cw_len) - 1;
712 let quant = &IMC_QUANT_LARGE[qidx];
714 ch_data.cw[i] = quant[val - 8] * ch_data.adj_floor[band];
716 ch_data.cw[i] = -quant[max - val - 8] * ch_data.adj_floor[band];
719 let idx = qidx + (if self.ba.band_present[band] { 2 } else { 0 });
720 let quant = &IMC_QUANT_SMALL[idx];
722 ch_data.cw[i] = quant[val - 1] * ch_data.adj_floor[band];
724 ch_data.cw[i] = -quant[max - val - 1] * ch_data.adj_floor[band];
731 fn decode_block(&mut self, data: &[u8], ch: usize, dst: &mut [f32]) -> DecoderResult<()> {
732 let mut br = BitReader::new(&data[BLOCK_SIZE*ch..][..BLOCK_SIZE], BitReaderMode::LE16MSB);
733 let hdr = br.read(9)?;
734 validate!((hdr & 0x18) == 0);
736 let reset = br.read_bool()?;
737 let fixed_head = br.read_bool()?;
738 let raw_coeffs = br.read_bool()?;
739 let weight_idx = br.read(1)? as usize;
742 self.ch_data[ch].reset();
748 self.read_level_coeffs_raw(&mut br, ch)?;
750 let cb_idx = (if reset { 2 } else { 0 }) + (if fixed_head { 1 } else { 0 });
751 self.read_level_coeffs(&mut br, reset, cb_idx, ch)?;
754 self.ch_data[ch].old_floor.copy_from_slice(&self.ch_data[ch].new_floor);
756 let mut bitcount: usize = 0;
759 self.ba.band_bits[0] = 5;
761 self.ba.cw_len[i] = 5;
765 if raw_coeffs || !self.ba.keep_flag[band]{
770 self.ba.band_bits[band] = bits;
771 for i in IMC_BANDS[band]..IMC_BANDS[band + 1] {
772 self.ba.cw_len[i] = bits;
773 bitcount += bits as usize;
779 if self.ba.band_width[BANDS - 1] != 0 {
784 if self.ba.band_width[BANDS - 1] != 0 {
789 validate!(br.tell() + bitcount < BLOCK_SIZE * 8);
790 self.ba.calculate_bit_allocation(&mut self.ch_data[ch], 512 - bitcount - br.tell(), fixed_head, weight_idx)?;
793 self.read_bitalloc_delta(&mut br, ch)?;
796 for band in 0..BANDS {
797 self.ba.band_bitsum[band] = 0;
798 for i in IMC_BANDS[band]..IMC_BANDS[band + 1] {
799 if !self.ba.skip_flag[i] {
800 self.ba.band_bitsum[band] += self.ba.cw_len[i] as usize;
805 self.read_coeffs(&mut br)?;
806 self.inv_quant(ch, raw_coeffs);
807 self.imdct.imdct(&self.ch_data[ch].cw, dst, &mut self.ch_data[ch].last_im);
815 let mut window: [f32; COEFFS] = [0.0; COEFFS];
816 generate_window(WindowType::Sine, 1.0, COEFFS, true, &mut window);
817 let mut pretwiddle1: [f32; COEFFS/2] = [0.0; COEFFS/2];
818 let mut pretwiddle2: [f32; COEFFS/2] = [0.0; COEFFS/2];
819 let mut posttwiddle: [FFTComplex; COEFFS/2] = [FFTC_ZERO; COEFFS/2];
820 for i in 0..COEFFS/2 {
822 let base = (n * 4.0 + 1.0) / 1024.0 * consts::PI;
826 pretwiddle1[i] = -(r1 + r2) * consts::SQRT_2;
827 pretwiddle2[i] = (r1 - r2) * consts::SQRT_2;
829 pretwiddle1[i] = (r1 + r2) * consts::SQRT_2;
830 pretwiddle2[i] = -(r1 - r2) * consts::SQRT_2;
832 posttwiddle[i] = FFTComplex::exp(consts::PI / 256.0 * n).scale(1.0/32768.0);
838 tmp: [FFTC_ZERO; COEFFS/2],
839 fft: FFTBuilder::new_fft(COEFFS/2, false),
843 fn imdct(&mut self, coeffs: &[f32; COEFFS], dst: &mut [f32], last_im: &mut [f32; COEFFS/2]) {
844 for i in 0..COEFFS/2 {
845 let in2 = coeffs[i * 2];
846 let in1 = coeffs[COEFFS - 1 - i * 2];
847 let c2 = self.pretwiddle1[i];
848 let c1 = self.pretwiddle2[i];
849 self.tmp[i].re = -(c2 * in1 + c1 * in2);
850 self.tmp[i].im = c1 * in1 - c2 * in2;
852 self.fft.do_ifft_inplace(&mut self.tmp);
853 for i in 0..COEFFS/2 {
854 let tmp = !(self.tmp[i] * self.posttwiddle[i]);
855 let c1 = self.window[i * 2];
856 let c2 = self.window[COEFFS - 1 - i * 2];
858 dst[i * 2] = c2 * im + c1 * tmp.re;
859 dst[COEFFS - 1 - i * 2] = c1 * im - c2 * tmp.re;
865 const CHMAP_MONO: [NAChannelType; 1] = [NAChannelType::C];
866 const CHMAP_STEREO: [NAChannelType; 2] = [NAChannelType::L, NAChannelType::R];
868 impl NADecoder for IMCDecoder {
869 fn init(&mut self, _supp: &mut NADecoderSupport, info: NACodecInfoRef) -> DecoderResult<()> {
870 if let NACodecTypeInfo::Audio(ainfo) = info.get_properties() {
871 self.chmap = NAChannelMap::new();
872 match ainfo.get_channels() {
873 1 => { self.chmap.add_channels(&CHMAP_MONO); },
874 2 => { self.chmap.add_channels(&CHMAP_STEREO); },
875 _ => { return Err(DecoderError::InvalidData); },
877 self.ainfo = NAAudioInfo::new(ainfo.get_sample_rate(),
878 ainfo.get_channels(),
880 self.info = info.replace_info(NACodecTypeInfo::Audio(self.ainfo));
883 self.generate_iac_tables(ainfo.get_sample_rate() as f32);
887 Err(DecoderError::InvalidData)
890 fn decode(&mut self, _supp: &mut NADecoderSupport, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
891 let info = pkt.get_stream().get_info();
892 validate!(info.get_properties().is_audio());
893 let pktbuf = pkt.get_buffer();
895 let nblocks = pktbuf.len() / BLOCK_SIZE / (self.ainfo.get_channels() as usize);
896 let duration = COEFFS * nblocks;
898 let abuf = alloc_audio_buffer(self.ainfo, duration, self.chmap.clone())?;
899 let mut adata = abuf.get_abuf_f32().unwrap();
900 let dst = adata.get_data_mut().unwrap();
902 let mut start: usize = 0;
903 let channels = self.ainfo.get_channels() as usize;
904 for chunk in pktbuf.chunks(BLOCK_SIZE * channels) {
905 for ch in 0..channels {
906 let off = abuf.get_offset(ch) + start;
907 self.decode_block(chunk, ch, &mut dst[off..off+COEFFS])?;
909 if (channels == 2) && ((chunk[1] & 0x20) != 0) {
910 let off1 = abuf.get_offset(0) + start;
911 let off2 = abuf.get_offset(1) + start;
913 let l = dst[off1 + i];
914 let r = dst[off2 + i];
915 dst[off1 + i] = l + r;
916 dst[off2 + i] = l - r;
922 let mut frm = NAFrame::new_from_pkt(pkt, self.info.clone(), abuf);
923 frm.set_keyframe(true);
926 fn flush(&mut self) {
930 impl NAOptionHandler for IMCDecoder {
931 fn get_supported_options(&self) -> &[NAOptionDefinition] { &[] }
932 fn set_options(&mut self, _options: &[NAOption]) { }
933 fn query_option_value(&self, _name: &str) -> Option<NAValue> { None }
936 pub fn get_decoder_imc() -> Box<dyn NADecoder + Send> {
937 Box::new(IMCDecoder::new(true))
940 pub fn get_decoder_iac() -> Box<dyn NADecoder + Send> {
941 Box::new(IMCDecoder::new(false))
944 struct IMCCodeReader { sel1: usize, sel2: usize }
947 fn new(sel1: usize, sel2: usize) -> Self { IMCCodeReader { sel1, sel2 } }
950 impl CodebookDescReader<u8> for IMCCodeReader {
951 fn bits(&mut self, idx: usize) -> u8 { IMC_CODE_LENGTHS[self.sel1][self.sel2][idx] }
952 fn code(&mut self, idx: usize) -> u32 { u32::from(IMC_CODE_CODES[self.sel1][self.sel2][idx]) }
953 fn sym (&mut self, idx: usize) -> u8 { idx as u8 }
954 fn len(&mut self) -> usize { IMC_CODE_LENGTHS[0][0].len() }
957 static IMC_BANDS: [usize; 33] = [
958 0, 3, 6, 9, 12, 16, 20, 24, 29, 34, 40, 46, 53, 60, 68, 76,
959 84, 93, 102, 111, 121, 131, 141, 151, 162, 173, 184, 195, 207, 219, 231, 243,
963 const IMC_QUANT_SMALL: &[[f32; 8]; 4] = &[
964 [ 8.4431201e-1, 4.7358301e-1, 1.448354, 2.7073899e-1,
965 7.4449003e-1, 1.241991, 1.845484, 0.0 ],
966 [ 8.6876702e-1, 4.7659001e-1, 1.478224, 2.5672799e-1,
967 7.55777e-1, 1.3229851, 2.03438, 0.0 ],
968 [ 7.5891501e-1, 6.2272799e-1, 1.271322, 3.47904e-1,
969 7.5317699e-1, 1.150767, 1.628476, 0.0 ],
970 [ 7.65257e-1, 6.44647e-1, 1.263824, 3.4548101e-1,
971 7.6384902e-1, 1.214466, 1.7638789, 0.0 ]
974 const IMC_QUANT_LARGE: &[[f32; 56]; 2] = &[
975 [ 1.39236e-1, 3.50548e-1, 5.9547901e-1, 8.5772401e-1,
976 1.121545, 1.3882281, 1.695882, 2.1270809,
977 7.2221003e-2, 1.85177e-1, 2.9521701e-1, 4.12568e-1,
978 5.4068601e-1, 6.7679501e-1, 8.1196898e-1, 9.4765198e-1,
979 1.0779999, 1.203415, 1.337265, 1.481871,
980 1.639982, 1.814766, 2.0701399, 2.449862,
981 3.7533998e-2, 1.02722e-1, 1.6021401e-1, 2.16043e-1,
982 2.7231601e-1, 3.3025399e-1, 3.9022601e-1, 4.52849e-1,
983 5.1794899e-1, 5.8529502e-1, 6.53956e-1, 7.2312802e-1,
984 7.9150802e-1, 8.5891002e-1, 9.28141e-1, 9.9706203e-1,
985 1.062153, 1.12564, 1.189834, 1.256122,
986 1.324469, 1.3955311, 1.468906, 1.545084,
987 1.6264729, 1.711524, 1.802705, 1.91023,
988 2.0533991, 2.22333, 2.4830019, 3.253329 ],
989 [ 1.11654e-1, 3.54469e-1, 6.4232099e-1, 9.6128798e-1,
990 1.295053, 1.61777, 1.989839, 2.51107,
991 5.7721999e-2, 1.69879e-1, 2.97589e-1, 4.3858799e-1,
992 5.9039903e-1, 7.4934798e-1, 9.1628098e-1, 1.087297,
993 1.262751, 1.4288321, 1.6040879, 1.79067,
994 2.000668, 2.2394669, 2.649332, 5.2760072,
995 2.9722e-2, 8.7316997e-2, 1.4445201e-1, 2.04247e-1,
996 2.6879501e-1, 3.3716801e-1, 4.08811e-1, 4.8306999e-1,
997 5.6049401e-1, 6.3955498e-1, 7.2044599e-1, 8.0427998e-1,
998 8.8933599e-1, 9.7537601e-1, 1.062461, 1.1510431,
999 1.240236, 1.326715, 1.412513, 1.500502,
1000 1.591749, 1.686413, 1.785239, 1.891233,
1001 2.0051291, 2.127681, 2.2709141, 2.475826,
1002 2.7219379, 3.101985, 4.686213, 6.2287788 ]
1005 static IMC_CYCLE1: [usize; BANDS] = [
1006 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
1007 17, 18, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 32,
1010 static IMC_CYCLE2: [usize; BANDS] = [
1011 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
1012 15, 16, 17, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29
1015 static IMC_WEIGHTS1: [f32; BANDS-1] = [
1016 0.119595, 0.123124, 0.129192, 9.97377e-2,
1017 8.1923e-2, 9.61153e-2, 8.77885e-2, 8.61174e-2,
1018 9.00882e-2, 9.91658e-2, 0.112991, 0.131126,
1019 0.152886, 0.177292, 0.221782, 0.244917,
1020 0.267386, 0.306816, 0.323046, 0.33729,
1021 0.366773, 0.392557, 0.398076, 0.403302,
1022 0.42451, 0.444777, 0.449188, 0.455445,
1023 0.477853, 0.500669, 0.510395
1026 static IMC_WEIGHTS2: [f32; BANDS-1] = [
1027 3.23466e-3, 3.49886e-3, 3.98413e-3, 1.98116e-3,
1028 1.16465e-3, 1.79283e-3, 1.40372e-3, 1.33274e-3,
1029 1.50523e-3, 1.95064e-3, 2.77472e-3, 4.14725e-3,
1030 6.2776e-3, 9.36401e-3, 1.71397e-2, 2.24052e-2,
1031 2.83971e-2, 4.11689e-2, 4.73165e-2, 5.31631e-2,
1032 6.66614e-2, 8.00824e-2, 8.31588e-2, 8.61397e-2,
1033 9.89229e-2, 0.112197, 0.115227, 0.119613,
1034 0.136174, 0.15445, 0.162685
1037 static IMC_BITALLOC_ADJ: [[f32; 7]; 2] = [
1038 [ 7.6, 4.4, 6.1, 2.3, 6.2, 1.8, 0.0 ],
1039 [ 3.6, 3.7, 5.1, 1.6, 1.5, 1.2, 0.0 ]
1042 static IMC_CODE_LENGTHS: &[[[u8; 18]; 4]; 4] = &[
1044 [ 16, 15, 13, 11, 8, 5, 3, 1, 2, 4, 6, 9, 10, 12, 14, 16, 7, 0 ],
1045 [ 10, 8, 7, 6, 4, 4, 3, 2, 2, 3, 4, 6, 7, 9, 11, 11, 7, 0 ],
1046 [ 15, 15, 14, 11, 8, 6, 4, 2, 1, 4, 5, 7, 9, 10, 12, 13, 4, 0 ],
1047 [ 13, 11, 10, 8, 6, 4, 2, 2, 2, 3, 5, 7, 9, 12, 15, 15, 14, 0 ],
1049 [ 14, 12, 10, 8, 7, 4, 2, 2, 2, 3, 5, 7, 9, 11, 13, 14, 7, 0 ],
1050 [ 14, 13, 11, 8, 6, 4, 3, 2, 2, 3, 5, 7, 9, 10, 12, 14, 3, 0 ],
1051 [ 13, 12, 10, 7, 5, 4, 3, 2, 2, 3, 4, 6, 8, 9, 11, 13, 4, 0 ],
1052 [ 13, 12, 10, 7, 5, 4, 3, 2, 2, 3, 4, 6, 8, 9, 11, 13, 4, 0 ],
1054 [ 16, 14, 12, 10, 8, 5, 3, 1, 2, 4, 7, 9, 11, 13, 15, 17, 6, 17 ],
1055 [ 15, 13, 11, 8, 6, 4, 2, 2, 2, 3, 5, 7, 10, 12, 14, 16, 9, 16 ],
1056 [ 14, 12, 11, 9, 8, 6, 3, 1, 2, 5, 7, 10, 13, 15, 16, 17, 4, 17 ],
1057 [ 16, 14, 12, 9, 7, 5, 2, 2, 2, 3, 4, 6, 8, 11, 13, 15, 10, 16 ],
1059 [ 13, 11, 10, 8, 7, 5, 2, 2, 2, 4, 6, 9, 12, 14, 15, 16, 3, 16 ],
1060 [ 11, 11, 10, 9, 8, 7, 5, 4, 3, 3, 3, 3, 3, 3, 4, 5, 6, 5 ],
1061 [ 9, 9, 7, 6, 5, 4, 3, 3, 2, 3, 4, 5, 4, 5, 5, 6, 8, 6 ],
1062 [ 13, 12, 10, 8, 5, 3, 3, 2, 2, 3, 4, 7, 9, 11, 14, 15, 6, 15 ]
1066 static IMC_CODE_CODES: &[[[u16; 18]; 4]; 4] = &[
1068 [ 0xCC32, 0x6618, 0x1987, 0x0660, 0x00CD, 0x0018, 0x0007, 0x0000, 0x0002,
1069 0x000D, 0x0032, 0x0199, 0x0331, 0x0CC2, 0x330D, 0xCC33, 0x0067, 0x0000 ],
1070 [ 0x02FE, 0x00BE, 0x005E, 0x002D, 0x000A, 0x0009, 0x0003, 0x0003, 0x0000,
1071 0x0002, 0x0008, 0x002C, 0x005D, 0x017E, 0x05FE, 0x05FF, 0x005C, 0x0000 ],
1072 [ 0x5169, 0x5168, 0x28B5, 0x0517, 0x00A3, 0x0029, 0x0008, 0x0003, 0x0000,
1073 0x0009, 0x0015, 0x0050, 0x0144, 0x028A, 0x0A2C, 0x145B, 0x000B, 0x0000 ],
1074 [ 0x1231, 0x048D, 0x0247, 0x0090, 0x0025, 0x0008, 0x0001, 0x0003, 0x0000,
1075 0x0005, 0x0013, 0x0049, 0x0122, 0x0919, 0x48C3, 0x48C2, 0x2460, 0x0000 ]
1077 [ 0x2D1D, 0x0B46, 0x02D0, 0x00B5, 0x0059, 0x000A, 0x0003, 0x0001, 0x0000,
1078 0x0004, 0x0017, 0x005B, 0x0169, 0x05A2, 0x168F, 0x2D1C, 0x0058, 0x0000 ],
1079 [ 0x1800, 0x0C01, 0x0301, 0x0061, 0x0019, 0x0007, 0x0004, 0x0003, 0x0000,
1080 0x0005, 0x000D, 0x0031, 0x00C1, 0x0181, 0x0601, 0x1801, 0x0002, 0x0000 ],
1081 [ 0x1556, 0x0AAA, 0x02AB, 0x0054, 0x0014, 0x000B, 0x0002, 0x0003, 0x0000,
1082 0x0003, 0x0008, 0x002B, 0x00AB, 0x0154, 0x0554, 0x1557, 0x0009, 0x0000 ],
1083 [ 0x1556, 0x0AAA, 0x02AB, 0x0054, 0x0014, 0x000B, 0x0002, 0x0003, 0x0000,
1084 0x0003, 0x0008, 0x002B, 0x00AB, 0x0154, 0x0554, 0x1557, 0x0009, 0x0000 ]
1086 [ 0x2993, 0x0A65, 0x0298, 0x00A7, 0x0028, 0x0004, 0x0000, 0x0001, 0x0001,
1087 0x0003, 0x0015, 0x0052, 0x014D, 0x0533, 0x14C8, 0x5324, 0x000B, 0x5325 ],
1088 [ 0x09B8, 0x026F, 0x009A, 0x0012, 0x0005, 0x0000, 0x0001, 0x0002, 0x0003,
1089 0x0001, 0x0003, 0x0008, 0x004C, 0x0136, 0x04DD, 0x1373, 0x0027, 0x1372 ],
1090 [ 0x0787, 0x01E0, 0x00F1, 0x003D, 0x001F, 0x0006, 0x0001, 0x0001, 0x0001,
1091 0x0002, 0x000E, 0x0079, 0x03C2, 0x0F0D, 0x1E19, 0x3C30, 0x0000, 0x3C31 ],
1092 [ 0x4B06, 0x12C0, 0x04B1, 0x0097, 0x0024, 0x0008, 0x0002, 0x0003, 0x0000,
1093 0x0003, 0x0005, 0x0013, 0x004A, 0x0259, 0x0961, 0x2582, 0x012D, 0x4B07 ]
1095 [ 0x0A5A, 0x0297, 0x014A, 0x0053, 0x0028, 0x000B, 0x0003, 0x0000, 0x0002,
1096 0x0004, 0x0015, 0x00A4, 0x052C, 0x14B7, 0x296C, 0x52DB, 0x0003, 0x52DA ],
1097 [ 0x0193, 0x0192, 0x00C8, 0x0065, 0x0033, 0x0018, 0x0007, 0x0004, 0x0000,
1098 0x0004, 0x0005, 0x0007, 0x0006, 0x0003, 0x0005, 0x0005, 0x000D, 0x0004 ],
1099 [ 0x0012, 0x0013, 0x0005, 0x0003, 0x0000, 0x0003, 0x0005, 0x0004, 0x0003,
1100 0x0003, 0x0005, 0x0005, 0x0004, 0x0004, 0x0003, 0x0005, 0x0008, 0x0004 ],
1101 [ 0x0D66, 0x06B2, 0x01AD, 0x006A, 0x000C, 0x0005, 0x0004, 0x0000, 0x0003,
1102 0x0002, 0x0007, 0x0034, 0x00D7, 0x0358, 0x1ACF, 0x359C, 0x001B, 0x359D ]
1106 const IMC_CB_SELECTOR: [[usize; BANDS]; 4] = [
1107 [ 1, 1, 1, 1, 1, 1, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0,
1108 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2 ],
1109 [ 0, 2, 0, 3, 2, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1110 0, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ],
1111 [ 1, 1, 1, 1, 1, 1, 1, 3, 3, 3, 3, 3, 3, 3, 3, 3,
1112 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2 ],
1113 [ 0, 1, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
1114 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]
1119 use nihav_core::codecs::RegisteredDecoders;
1120 use nihav_core::demuxers::RegisteredDemuxers;
1121 use nihav_codec_support::test::dec_video::*;
1122 use crate::indeo_register_all_decoders;
1123 use nihav_commonfmt::generic_register_all_demuxers;
1126 let mut dmx_reg = RegisteredDemuxers::new();
1127 generic_register_all_demuxers(&mut dmx_reg);
1128 let mut dec_reg = RegisteredDecoders::new();
1129 indeo_register_all_decoders(&mut dec_reg);
1131 // let file = "assets/Indeo/neal73_saber.avi";
1132 // let file = "assets/Indeo/IMC/hvalen.avi";
1133 // sample from a private collection
1134 let file = "assets/Indeo/IMC/8khz.avi";
1135 // let file = "assets/Indeo/STsKlassFist-1a.avi";
1136 // let file = "assets/Indeo/IMC/Angel Bday.avi";
1137 test_decode_audio("avi", file, None, None/*Some("imc")*/, &dmx_reg, &dec_reg);
1138 //test_file_decoding("avi", file, None, false, true, None);