5 use std::cell::RefCell;
7 use nihav_core::formats::*;
8 use nihav_core::frame::*;
9 use nihav_core::codecs::*;
10 use nihav_core::io::bitreader::*;
11 use nihav_core::io::codebook::*;
12 use nihav_core::dsp::fft::*;
13 use nihav_core::dsp::window::*;
15 const BANDS: usize = 32;
16 const COEFFS: usize = 256;
17 const BLOCK_SIZE: usize = 64;
20 pretwiddle1: [f32; COEFFS/2],
21 pretwiddle2: [f32; COEFFS/2],
22 posttwiddle: [FFTComplex; COEFFS/2],
23 tmp: [FFTComplex; COEFFS/2],
25 window: [f32; COEFFS],
29 old_floor: [f32; BANDS],
30 new_floor: [f32; BANDS],
31 log_floor: [f32; BANDS],
32 log_floor2: [f32; BANDS],
33 bit_est: [f32; BANDS],
34 mask_wght: [f32; BANDS],
35 adj_floor: [f32; BANDS],
37 last_im: [f32; COEFFS/2],
41 band_width: [usize; BANDS],
42 band_present: [bool; BANDS],
43 band_skip: [bool; BANDS],
44 band_bits: [u8; BANDS],
46 band_bitsum: [usize; BANDS],
47 skip_flag: [bool; COEFFS],
48 skip_flag_bits: [u8; BANDS],
49 skips_per_band: [usize; BANDS],
50 keep_flag: [bool; BANDS],
57 old_floor: [0.0; BANDS],
58 new_floor: [0.0; BANDS],
59 log_floor: [0.0; BANDS],
60 log_floor2: [0.0; BANDS],
61 bit_est: [0.0; BANDS],
62 mask_wght: [0.0; BANDS],
63 adj_floor: [0.0; BANDS],
65 last_im: [0.0; COEFFS/2],
69 for i in 0..self.old_floor.len() { self.old_floor[i] = 1.0; }
70 for i in 0..self.cw.len() { self.cw[i] = 0.0; }
74 const BITALLOC_LIMIT: f32 = -1.0e20;
75 const BITALLOC_TOP_LIMIT: f32 = 1.0e20;
79 band_width: [0; BANDS],
80 band_present: [false; BANDS],
81 band_skip: [false; BANDS],
82 band_bits: [0; BANDS],
84 band_bitsum: [0; BANDS],
85 skip_flag: [false; COEFFS],
86 skip_flag_bits: [0; BANDS],
87 skips_per_band: [0; BANDS],
88 keep_flag: [false; BANDS],
94 self.band_width[i] = 0;
95 self.band_present[i] = false;
96 self.band_skip[i] = false;
97 self.band_bits[i] = 0;
98 self.keep_flag[i] = false;
99 self.band_bitsum[i] = 0;
100 self.skips_per_band[i] = 0;
101 self.skip_flag_bits[i] = 0;
105 self.skip_flag[i] = false;
108 fn calculate_bit_allocation(&mut self, ch_data: &mut IMCChannel, bits: usize, fixed_head: bool, adj_idx: usize) -> DecoderResult<()> {
111 for coef in ch_data.new_floor.iter() { if *coef > peak { peak = *coef; } }
114 for band in 0..BANDS-1 {
115 ch_data.bit_est[band] = ch_data.log_floor2[band] - ch_data.mask_wght[band].log2();
117 ch_data.bit_est[BANDS - 1] = BITALLOC_LIMIT;
119 for band in 0..BANDS {
121 let band_w = IMC_BANDS[band + 1] - IMC_BANDS[band];
122 if band_w == self.band_width[band] { idx = 0; }
123 if band_w > self.band_width[band] { idx = 1; }
124 if band_w/2 >= self.band_width[band] { idx = 2; }
127 if ch_data.new_floor[band] < peak { idx += 1; }
128 ch_data.bit_est[band] += IMC_BITALLOC_ADJ[adj_idx][idx];
133 ch_data.bit_est[i] = BITALLOC_LIMIT;
137 let start = if fixed_head { 4 } else { 0 };
141 for band in start..BANDS-1 {
142 a_width += self.band_width[band];
143 pool += (self.band_width[band] as f32) * ch_data.bit_est[band];
145 validate!(a_width > 0);
147 self.band_width[BANDS - 1] = 0;
148 pool = (pool * 0.5 - (bits as f32)) / (a_width as f32);
150 let free_bits = bits as i32;
151 let mut cur_bits: i32 = 0;
154 for i in 0..BANDS/2 {
155 let diff = cur_bits - free_bits;
156 if diff.abs() <= 8 { break; }
160 for band in start..BANDS {
161 let mut len = (ch_data.bit_est[band] * 0.5 - pool + 0.5) as i32;
162 if len < 0 { len = 0; }
163 if len > 6 { len = 6; }
164 self.band_bits[band] = len as u8;
165 cur_bits += (self.band_width[band] as i32) * (len as i32);
167 acc += self.band_width[band] as i32;
171 let mut lflag = flag;
173 if free_bits < cur_bits { flag = -1; }
174 if i == 0 { lflag = flag; }
178 pool += ((cur_bits - free_bits) as f32) / (((mmcount + 1) * acc) as f32);
181 for band in start..BANDS {
182 for i in IMC_BANDS[band]..IMC_BANDS[band + 1] {
183 self.cw_len[i] = self.band_bits[band];
187 if free_bits > cur_bits {
188 let mut tmp: [f32; BANDS] = [BITALLOC_LIMIT; BANDS];
189 for band in 0..BANDS {
190 if self.band_bits[band] != 6 {
191 tmp[band] = (self.band_bits[band] as f32) * -2.0 + ch_data.bit_est[band] - 0.415;
195 while (peak > BITALLOC_LIMIT) && (cur_bits < free_bits) {
196 peak = BITALLOC_LIMIT;
197 let mut idx: Option<usize> = None;
198 for band in 0..BANDS {
199 if tmp[band] > peak {
204 if let Some(band) = idx {
206 self.band_bits[band] += 1;
207 if self.band_bits[band] == 6 {
208 tmp[band] = BITALLOC_LIMIT;
210 for i in IMC_BANDS[band]..IMC_BANDS[band + 1] {
213 if cur_bits >= free_bits {
221 if cur_bits > free_bits {
222 let mut tmp: [f32; BANDS] = [BITALLOC_TOP_LIMIT; BANDS];
223 for band in start..BANDS {
224 if self.band_bits[band] != 0 {
225 tmp[band] = (self.band_bits[band] as f32) * -2.0 + ch_data.bit_est[band] - 0.415 + 2.0;
228 while free_bits < cur_bits {
229 let mut low = BITALLOC_TOP_LIMIT;
231 for band in 0..BANDS {
238 self.band_bits[idx] -= 1;
239 if self.band_bits[idx] == 0 {
240 tmp[idx] = BITALLOC_TOP_LIMIT;
242 for i in IMC_BANDS[idx]..IMC_BANDS[idx + 1] {
243 if self.cw_len[i] > 0 {
246 if cur_bits <= free_bits {
257 fn adjust_bit_allocation(&mut self, ch_data: &mut IMCChannel, free_bits: i32) {
258 let mut tmp: [f32; BANDS] = [BITALLOC_LIMIT; BANDS];
259 for band in 0..BANDS {
260 if self.band_bits[band] != 6 {
261 tmp[band] = (self.band_bits[band] as f32) * -2.0 + ch_data.bit_est[band] - 0.415;
264 let mut used_bits: i32 = 0;
266 while (peak > BITALLOC_LIMIT) && (used_bits < free_bits) {
267 peak = BITALLOC_LIMIT;
268 let mut idx: Option<usize> = None;
269 for band in 0..BANDS {
270 if tmp[band] > peak {
275 if let Some(band) = idx {
277 self.band_bits[band] += 1;
278 if self.band_bits[band] == 6 {
279 tmp[band] = BITALLOC_LIMIT;
281 for i in IMC_BANDS[band]..IMC_BANDS[band + 1] {
282 if self.cw_len[i] >= 6 { continue; }
285 if used_bits >= free_bits {
302 let mut exp_lev: [f32; 16] = [0.0; 16];
304 exp_lev[lev] = 10.0f32.powf(-(lev as f32) * 0.4375);
307 let mut exp_10: [f32; 32] = [0.0; 32];
309 exp_10[i] = 10.0f32.powf(((i as f32) - 16.0) * 0.25);
312 let mut sqrt_tab: [f32; 32] = [0.0; 32];
314 sqrt_tab[i] = (i as f32).sqrt();
317 LUTs { exp_lev: exp_lev, exp_10: exp_10, sqrt_tab: sqrt_tab }
326 info: Rc<NACodecInfo>,
328 codes: [[Codebook<u8>; 4]; 4],
329 ch_data: [IMCChannel; 2],
333 cycle1: [usize; BANDS],
334 cycle2: [usize; BANDS],
335 weights1: [f32; BANDS-1],
336 weights2: [f32; BANDS-1],
341 fn freq2bark(freq: f32) -> f32 {
342 3.5 * ((freq / 7500.0) * (freq / 7500.0)).atan() + 13.0 * (freq * 0.00076).atan()
345 fn calc_maxcoef(coef: f32) -> (f32, f32) {
346 let c1 = 20000.0 / 10.0f32.powf(coef * 0.057031251);
351 fn new(is_imc: bool) -> Self {
352 let mut codes: [[Codebook<u8>; 4]; 4];
353 let mut cycle1: [usize; BANDS] = [0; BANDS];
354 let mut cycle2: [usize; BANDS] = [0; BANDS];
355 let mut weights1: [f32; BANDS-1] = [0.0; BANDS-1];
356 let mut weights2: [f32; BANDS-1] = [0.0; BANDS-1];
358 cycle1.copy_from_slice(&IMC_CYCLE1);
359 cycle2.copy_from_slice(&IMC_CYCLE2);
360 weights1.copy_from_slice(&IMC_WEIGHTS1);
361 weights2.copy_from_slice(&IMC_WEIGHTS2);
364 codes = mem::uninitialized();
367 let mut cr = IMCCodeReader::new(i, j);
368 ptr::write(&mut codes[i][j], Codebook::new(&mut cr, CodebookMode::MSB).unwrap());
374 chmap: NAChannelMap::new(),
375 ainfo: NAAudioInfo::new(0, 0, SND_F32P_FORMAT, 0),
376 info: NACodecInfo::new_dummy(),
379 ch_data: [IMCChannel::new(), IMCChannel::new()],
381 imdct: IMDCTContext::new(),
391 fn generate_iac_tables(&mut self, sample_rate: f32) {
392 let scale = sample_rate / 256.0 / 2.0 * 0.5;
393 let nyq_freq = sample_rate / 2.0;
394 let mut last_bark = 0.0;
395 let mut freq_max: [f32; BANDS] = [0.0; BANDS];
396 let mut freq_mid: [f32; BANDS] = [0.0; BANDS];
397 let mut freq_min: [f32; BANDS] = [0.0; BANDS];
398 for band in 0..BANDS {
399 let freq = ((IMC_BANDS[band] + IMC_BANDS[band + 1] - 1) as f32) * scale;
400 let bark = freq2bark(freq);
402 let bark_diff = bark - last_bark;
403 self.weights1[band - 1] = 10.0f32.powf(-1.0 * bark_diff);
404 self.weights2[band - 1] = 10.0f32.powf(-2.7 * bark_diff);
407 freq_mid[band] = freq;
409 let mut tmp_freq = freq;
410 while tmp_freq < nyq_freq {
412 if freq2bark(tmp_freq) > bark + 0.5 { break; }
414 freq_max[band] = tmp_freq;
416 let mut tmp_freq = freq;
417 while tmp_freq > 0.0 {
419 if freq2bark(tmp_freq) < bark - 0.5 { break; }
421 freq_min[band] = tmp_freq;
424 for band in 0..BANDS {
425 let mut s_band = BANDS - 1;
426 while s_band > 0 && freq_max[band] <= freq_mid[s_band] { s_band -= 1; }
427 self.cycle1[band] = s_band + 1;
431 for band in 1..BANDS {
433 while s_band < BANDS-1 && freq_min[band] >= freq_mid[s_band] { s_band += 1; }
434 self.cycle2[band] = s_band - 1;
438 fn read_level_coeffs_raw(&mut self, br: &mut BitReader, ch: usize) -> DecoderResult<()> {
439 let ch_data = &mut self.ch_data[ch];
440 let maxc_pos = br.read(5)? as usize;
441 let max_coef = br.read(7)? as u8;
443 let (c1, c2) = calc_maxcoef(max_coef as f32);
446 let level = br.read(4)?;
447 ch_data.new_floor[i] = c1 * self.luts.exp_lev[level as usize];
448 ch_data.log_floor[i] = c2 - 1.4533435415 * (level as f32);
450 ch_data.new_floor[i] = c1;
451 ch_data.log_floor[i] = c2;
453 self.ba.band_width[i] = IMC_BANDS[i + 1] - IMC_BANDS[i];
455 ch_data.log_floor2[i] = ch_data.log_floor[i] * 2.0;
456 ch_data.mask_wght[i] = 1.0;
462 fn calculate_channel_values(&mut self, ch: usize) {
463 let ch_data = &mut self.ch_data[ch];
464 let mut tmp2: [f32; BANDS+1] = [0.0; BANDS+1];
465 let mut tmp3: [f32; BANDS] = [0.0; BANDS];
467 for band in 0..BANDS {
468 ch_data.mask_wght[band] = 0.0;
470 if self.ba.band_width[band] > 0 {
471 val = (ch_data.new_floor[band] as f64).powi(2);
472 ch_data.log_floor2[band] = 2.0 * ch_data.log_floor[band];
475 ch_data.log_floor2[band] = -30000.0;
477 let tmp = val * (self.ba.band_width[band] as f64) * 0.01;
478 if val <= 1.0e-30 { tmp3[band] = 0.0; }
479 else { tmp3[band] = tmp as f32; }
482 for band in 0..BANDS {
483 let next_band = self.cycle1[band];
484 for band2 in band..next_band {
485 ch_data.mask_wght[band2] += tmp3[band];
487 tmp2[next_band] += tmp3[band];
491 for band in 1..BANDS {
492 accum = (tmp2[band] + accum) * self.weights1[band - 1];
493 ch_data.mask_wght[band] += accum;
496 let mut tmp2: [f32; BANDS] = [0.0; BANDS];
498 for band in 1..BANDS {
499 let prev_band = self.cycle2[band];
500 for band2 in prev_band+1..band {
501 ch_data.mask_wght[band2] += tmp3[band];
503 tmp2[prev_band + 1] += tmp3[band];
507 for i in 0..BANDS-1 {
508 let band = BANDS - 2 - i;
509 accum = (tmp2[band + 1] + accum) * self.weights2[band];
510 ch_data.mask_wght[band] += accum;
514 fn read_level_coeffs(&mut self, br: &mut BitReader, reset: bool, sel_idx: usize, ch: usize) -> DecoderResult<()> {
515 let mut level: [i8; BANDS] = [0; BANDS];
519 level[0] = br.read(7)? as i8;
523 for i in start..BANDS {
524 level[i] = br.read_cb(&self.codes[sel_idx][IMC_CB_SELECTOR[sel_idx][i]])? as i8;
526 level[i] += br.read(4)? as i8;
528 self.ba.keep_flag[i] = level[i] == 16;
531 let ch_data = &mut self.ch_data[ch];
532 let (mut c1, mut c2) = calc_maxcoef(level[0] as f32);
533 ch_data.new_floor[0] = c1;
534 ch_data.log_floor[0] = c2;
537 ch_data.new_floor[i] = 1.0;
538 ch_data.log_floor[i] = 0.0;
543 } else if level[i] < 25 {
544 lval = level[i] - 32;
546 lval = level[i] - 16;
548 c1 *= self.luts.exp_10[(lval + 16) as usize];
549 c2 += 0.83048 * (lval as f32);
550 ch_data.new_floor[i] = c1;
551 ch_data.log_floor[i] = c2;
555 let ch_data = &mut self.ch_data[ch];
558 let lval = level[i] - 7;
559 ch_data.new_floor[i] = self.luts.exp_10[(lval + 16) as usize] * ch_data.old_floor[i];
560 ch_data.log_floor[i] += (lval as f32) * 0.83048;
562 ch_data.new_floor[i] = ch_data.old_floor[i];
567 self.ba.band_width[0] = IMC_BANDS[1] - IMC_BANDS[0];
570 self.ba.band_width[i] = IMC_BANDS[i + 1] - IMC_BANDS[i];
572 self.ba.band_width[i] = 0;
576 for i in 0..BANDS-1 {
577 if self.ba.band_width[i] > 0 {
578 self.ba.band_present[i] = br.read_bool()?;
581 self.calculate_channel_values(ch);
586 fn read_skip_flags(&mut self, br: &mut BitReader) -> DecoderResult<()> {
587 let ba = &mut self.ba;
588 for band in 0..BANDS {
589 if !ba.band_present[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_present[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.adj_floor[band] = ch_data.new_floor[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_present[band] && nonskip > 0 {
662 ch_data.adj_floor[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_present[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_present[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_present[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 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.adj_floor[band];
717 ch_data.cw[i] = -quant[max - val - 8] * ch_data.adj_floor[band];
720 let idx = qidx + (if self.ba.band_present[band] { 2 } else { 0 });
721 let quant = &IMC_QUANT_SMALL[idx];
723 ch_data.cw[i] = quant[val - 1] * ch_data.adj_floor[band];
725 ch_data.cw[i] = -quant[max - val - 1] * ch_data.adj_floor[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].new_floor);
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 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 ]
1112 use nihav_core::codecs::RegisteredDecoders;
1113 use nihav_core::demuxers::RegisteredDemuxers;
1114 use nihav_core::test::dec_video::*;
1115 use crate::codecs::indeo_register_all_codecs;
1116 use nihav_commonfmt::demuxers::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, "imc", &dmx_reg, &dec_reg);
1130 //test_file_decoding("avi", file, None, false, true, None);