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).trunc() 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 {
336 info: Rc<NACodecInfo>,
338 codes: [[Codebook<u8>; 4]; 4],
339 ch_data: [IMCChannel; 2],
343 cycle1: [usize; BANDS],
344 cycle2: [usize; BANDS],
345 weights1: [f32; BANDS-1],
346 weights2: [f32; BANDS-1],
349 fn calc_maxcoef(coef: f32) -> (f32, f32) {
350 let c1 = 20000.0 / 2.0f32.powf(coef * 0.18945);
355 fn new(is_imc: bool) -> Self {
356 let mut codes: [[Codebook<u8>; 4]; 4];
357 let mut cycle1: [usize; BANDS] = [0; BANDS];
358 let mut cycle2: [usize; BANDS] = [0; BANDS];
359 let mut weights1: [f32; BANDS-1] = [0.0; BANDS-1];
360 let mut weights2: [f32; BANDS-1] = [0.0; BANDS-1];
362 cycle1.copy_from_slice(&IMC_CYCLE1);
363 cycle2.copy_from_slice(&IMC_CYCLE2);
364 weights1.copy_from_slice(&IMC_WEIGHTS1);
365 weights2.copy_from_slice(&IMC_WEIGHTS2);
368 codes = mem::uninitialized();
371 let mut cr = IMCCodeReader::new(i, j);
372 ptr::write(&mut codes[i][j], Codebook::new(&mut cr, CodebookMode::MSB).unwrap());
378 chmap: NAChannelMap::new(),
379 ainfo: NAAudioInfo::new(0, 0, SND_F32P_FORMAT, 0),
380 info: NACodecInfo::new_dummy(),
383 ch_data: [IMCChannel::new(), IMCChannel::new()],
385 imdct: IMDCTContext::new(),
394 fn generate_iac_tables(&mut self, sample_rate: f32) {
395 let scale = sample_rate / 1024.0;
396 let nyq_freq = sample_rate / 2.0;
397 let mut last_bark = 0.0;
398 let mut freq_max: [f32; BANDS] = [0.0; BANDS];
399 let mut freq_mid: [f32; BANDS] = [0.0; BANDS];
400 let mut freq_min: [f32; BANDS] = [0.0; BANDS];
401 for band in 0..BANDS {
402 let freq = ((IMC_BANDS[band] + IMC_BANDS[band + 1] - 1) as f32) * scale;
403 let bark = freq2bark(freq);
405 let bark_diff = bark - last_bark;
406 self.weights1[band - 1] = 10.0f32.powf(-1.0 * bark_diff);
407 self.weights1[band - 1] = 10.0f32.powf(-2.7 * bark_diff);
410 freq_mid[band] = freq;
412 let mut tmp_freq = freq;
413 while tmp_freq < nyq_freq {
415 if freq2bark(tmp_freq) > bark + 0.5 { break; }
417 freq_max[band] = tmp_freq;
419 let mut tmp_freq = freq;
420 while tmp_freq > 0.0 {
422 if freq2bark(tmp_freq) < bark - 0.5 { break; }
424 freq_min[band] = tmp_freq;
427 for band in 0..BANDS {
428 let mut s_band = BANDS - 1;
429 while s_band > 0 && freq_max[band] <= freq_mid[s_band] { s_band -= 1; }
430 self.cycle1[band] = s_band + 1;
434 for band in 1..BANDS {
436 while s_band < BANDS-1 && freq_min[band] >= freq_mid[s_band] { s_band += 1; }
437 self.cycle2[band] = s_band - 1;
441 fn read_level_coeffs_raw(&mut self, br: &mut BitReader, ch: usize) -> DecoderResult<()> {
442 let mut ch_data = &mut self.ch_data[ch];
443 let maxc_pos = br.read(5)? as usize;
444 let max_coef = br.read(7)? as u8;
446 let (c1, c2) = calc_maxcoef(max_coef as f32);
449 let level = br.read(4)? as f32;
450 ch_data.coeffs1[i] = c1 * 10.0f32.powf(-level * 0.4375); // almost exp(-lev)
451 ch_data.coeffs2[i] = c2 - 1.4533435415 * level;
453 ch_data.coeffs1[i] = c1;
454 ch_data.coeffs2[i] = c2;
456 self.ba.band_width[i] = IMC_BANDS[i + 1] - IMC_BANDS[i];
457 //self.ba.band_flag[i] = false;
459 ch_data.coeffs3[i] = ch_data.coeffs2[i] * 2.0;
460 ch_data.coeffs5[i] = 1.0;
466 fn calculate_channel_values(&mut self, ch: usize) {
467 let mut ch_data = &mut self.ch_data[ch];
468 let mut tmp2: [f32; BANDS] = [0.0; BANDS];
469 let mut tmp3: [f32; BANDS] = [0.0; BANDS];
471 for band in 0..BANDS {
472 ch_data.coeffs5[band] = 0.0;
474 if self.ba.band_width[band] > 0 {
475 val = ch_data.coeffs1[band] * ch_data.coeffs1[band];
476 ch_data.coeffs3[band] = 2.0 * ch_data.coeffs2[band];
479 ch_data.coeffs3[band] = -30000.0;
481 tmp3[band] = val * (self.ba.band_width[band] as f32) * 0.01;
482 if tmp3[band] <= 1.0e-6 { tmp3[band] = 0.0; }
485 for band in 0..BANDS {
486 let next_band = self.cycle1[band];
487 for band2 in band..next_band {
488 ch_data.coeffs5[band2] += tmp3[band];
490 tmp2[next_band - 1] += tmp3[band];
494 for band in 0..BANDS-1 {
495 accum = (tmp2[band] + accum) * self.weights1[band];
496 ch_data.coeffs5[band + 1] += accum;
499 let mut tmp2: [f32; BANDS] = [0.0; BANDS];
501 for band in 1..BANDS {
502 let prev_band = self.cycle2[band];
503 for band2 in prev_band+1..band {
504 ch_data.coeffs5[band2] += tmp3[band];
506 tmp2[prev_band + 1] += tmp3[band];
510 for i in 0..BANDS-1 {
511 let band = BANDS - 2 - i;
512 accum = (tmp2[band + 1] + accum) * self.weights2[band];
513 ch_data.coeffs5[band] += accum;
517 fn read_level_coeffs(&mut self, br: &mut BitReader, reset: bool, sel_idx: usize, ch: usize) -> DecoderResult<()> {
518 let mut level: [i8; BANDS] = [0; BANDS];
522 level[0] = br.read(7)? as i8;
526 for i in start..BANDS {
527 level[i] = br.read_cb(&self.codes[sel_idx][IMC_CB_SELECTOR[sel_idx][i]])? as i8;
529 level[i] += br.read(4)? as i8;
531 self.ba.keep_flag[i] = level[i] == 16;
534 let mut ch_data = &mut self.ch_data[ch];
535 let (mut c1, mut c2) = calc_maxcoef(level[0] as f32);
536 ch_data.coeffs1[0] = c1;
537 ch_data.coeffs2[0] = c2;
540 ch_data.coeffs1[i] = 1.0;
541 ch_data.coeffs2[i] = 0.0;
545 lval = (level[i] - 7) as f32;
546 } else if level[i] < 25 {
547 lval = (level[i] - 32) as f32;
549 lval = (level[i] - 16) as f32;
551 c1 *= 10.0f32.powf(lval * 0.25);
552 c2 += 0.83048 * lval;
553 ch_data.coeffs1[i] = c1;
554 ch_data.coeffs2[i] = c2;
558 let mut ch_data = &mut self.ch_data[ch];
561 let lval = (level[i] - 7) as f32;
562 ch_data.coeffs1[i] = 10.0f32.powf(lval * 0.25) * ch_data.old_floor[i];
563 ch_data.coeffs2[i] += lval * 0.83048;
565 ch_data.coeffs1[i] = ch_data.old_floor[i];
572 self.ba.band_width[i] = IMC_BANDS[i + 1] - IMC_BANDS[i];
574 self.ba.band_width[i] = 0;
576 //self.ba.band_flag[i] = false;
579 for i in 0..BANDS-1 {
580 if self.ba.band_width[i] > 0 {
581 self.ba.band_flag[i] = br.read_bool()?;
584 self.calculate_channel_values(ch);
589 fn read_skip_flags(&mut self, br: &mut BitReader) -> DecoderResult<()> {
590 let mut ba = &mut self.ba;
591 for band in 0..BANDS {
592 if !ba.band_flag[band] || ba.band_width[band] == 0 { continue; }
594 if !ba.band_skip[band] {
595 ba.skip_flag_bits[band] = (IMC_BANDS[band + 1] - IMC_BANDS[band]) as u8;
596 for i in IMC_BANDS[band]..IMC_BANDS[band + 1] {
597 ba.skip_flag[i] = br.read_bool()?;
599 ba.skips_per_band[band] += 1;
603 let mut i = IMC_BANDS[band];
604 while i < IMC_BANDS[band + 1] - 1 {
605 if !br.read_bool()? {
606 ba.skip_flag_bits[band] += 1;
607 ba.skip_flag[i] = true;
608 ba.skip_flag[i + 1] = true;
609 ba.skips_per_band[band] += 2;
612 ba.skip_flag_bits[band] += 2;
613 ba.skip_flag[i] = false;
614 ba.skip_flag[i + 1] = true;
615 ba.skips_per_band[band] += 1;
617 ba.skip_flag_bits[band] += 3;
618 if !br.read_bool()? {
619 ba.skip_flag[i] = true;
620 ba.skips_per_band[band] += 1;
622 ba.skip_flag[i] = false;
624 ba.skip_flag[i + 1] = false;
629 if i != IMC_BANDS[band + 1] {
630 ba.skip_flag_bits[band] += 1;
631 ba.skip_flag[i] = br.read_bool()?;
633 ba.skips_per_band[band] += 1;
641 fn read_bitalloc_delta(&mut self, br: &mut BitReader, ch: usize) -> DecoderResult<()> {
642 for band in 0..BANDS {
643 self.ba.band_bitsum[band] = 0;
644 self.ba.band_skip[band] = false;
645 for i in IMC_BANDS[band]..IMC_BANDS[band + 1] {
646 self.ba.band_bitsum[band] += self.ba.cw_len[i] as usize;
648 if self.ba.band_flag[band] {
649 let band_w = IMC_BANDS[band + 1] - IMC_BANDS[band];
650 let bitsum = self.ba.band_bitsum[band] as usize;
651 if (bitsum > 0) && (band_w * 3 > bitsum * 2) {
652 self.ba.band_skip[band] = true;
657 self.read_skip_flags(br)?;
659 let mut ch_data = &mut self.ch_data[ch];
660 for band in 0..BANDS {
661 ch_data.coeffs6[band] = ch_data.coeffs1[band];
662 let band_w = IMC_BANDS[band + 1] - IMC_BANDS[band];
663 let nonskip = band_w - self.ba.skips_per_band[band];
664 if self.ba.band_flag[band] && nonskip > 0 {
665 ch_data.coeffs6[band] *= (band_w as f32).sqrt() / (nonskip as f32).sqrt();
669 let mut bits_freed: i32 = 0;
670 for band in 0..BANDS {
671 if !self.ba.band_flag[band] { continue; }
672 for i in IMC_BANDS[band]..IMC_BANDS[band + 1] {
673 if self.ba.skip_flag[i] {
674 bits_freed += self.ba.cw_len[i] as i32;
675 self.ba.cw_len[i] = 0;
678 bits_freed -= self.ba.skip_flag_bits[band] as i32;
681 self.ba.adjust_bit_allocation(&mut ch_data, bits_freed);
686 fn read_coeffs(&mut self, br: &mut BitReader) -> DecoderResult<()> {
687 for band in 0..BANDS {
688 if self.ba.band_bitsum[band] == 0 { continue; }
689 if !self.ba.band_flag[band] && (self.ba.band_width[band] == 0) { continue; }
690 for i in IMC_BANDS[band]..IMC_BANDS[band + 1] {
691 let len = self.ba.cw_len[i];
692 if len > 0 && (!self.ba.band_flag[band] || !self.ba.skip_flag[i]) {
693 self.ba.coeff[i] = br.read(len)? as u8;
695 self.ba.coeff[i] = 0;
702 fn inv_quant(&mut self, ch: usize, raw_coeffs: bool) {
703 let qidx: usize = if raw_coeffs { 1 } else { 0 };
704 let mut ch_data = &mut self.ch_data[ch];
705 for band in 0..BANDS {
706 for i in IMC_BANDS[band]..IMC_BANDS[band + 1] {
708 let cw_len = self.ba.cw_len[i];
709 if cw_len == 0 || self.ba.skip_flag[i] { continue; }
711 let val = self.ba.coeff[i] as usize;
712 let mid = 1 << (cw_len - 1);
713 let max = (1 << cw_len) - 1;
715 let quant = &IMC_QUANT_LARGE[qidx];
717 ch_data.cw[i] = quant[val - 8] * ch_data.coeffs6[band];
719 ch_data.cw[i] = -quant[max - val - 8] * ch_data.coeffs6[band];
722 let idx = qidx + (if self.ba.band_flag[band] { 2 } else { 0 });
723 let quant = &IMC_QUANT_SMALL[idx];
725 ch_data.cw[i] = quant[val - 1] * ch_data.coeffs6[band];
727 ch_data.cw[i] = -quant[max - val - 1] * ch_data.coeffs6[band];
734 fn decode_block(&mut self, data: &[u8], ch: usize, dst: &mut [f32]) -> DecoderResult<()> {
735 let mut br = BitReader::new(&data[BLOCK_SIZE*ch..], BLOCK_SIZE, BitReaderMode::LE16MSB);
736 let hdr = br.read(9)?;
737 validate!((hdr & 0x18) == 0);
739 let reset = br.read_bool()?;
740 let fixed_head = br.read_bool()?;
741 let raw_coeffs = br.read_bool()?;
742 let weight_idx = br.read(1)? as usize;
745 self.ch_data[ch].reset();
751 self.read_level_coeffs_raw(&mut br, ch)?;
753 let cb_idx = (if reset { 2 } else { 0 }) + (if fixed_head { 1 } else { 0 });
754 self.read_level_coeffs(&mut br, reset, cb_idx, ch)?;
757 self.ch_data[ch].old_floor.copy_from_slice(&self.ch_data[ch].coeffs1);
759 let mut bitcount: usize = 0;
762 self.ba.band_bits[0] = 5;
764 self.ba.cw_len[i] = 5;
768 if raw_coeffs || !self.ba.keep_flag[band]{
773 self.ba.band_bits[band] = bits;
774 for i in IMC_BANDS[band]..IMC_BANDS[band + 1] {
775 self.ba.cw_len[i] = bits;
776 bitcount += bits as usize;
782 if self.ba.band_width[BANDS - 1] != 0 {
790 validate!(br.tell() + bitcount < BLOCK_SIZE * 8);
791 self.ba.calculate_bit_allocation(&mut self.ch_data[ch], 512 - bitcount - br.tell(), fixed_head, weight_idx)?;
794 self.read_bitalloc_delta(&mut br, ch)?;
797 for band in 0..BANDS {
798 self.ba.band_bitsum[band] = 0;
799 for i in IMC_BANDS[band]..IMC_BANDS[band + 1] {
800 if !self.ba.skip_flag[i] {
801 self.ba.band_bitsum[band] += self.ba.cw_len[i] as usize;
806 self.read_coeffs(&mut br)?;
807 self.inv_quant(ch, raw_coeffs);
808 self.imdct.imdct(&self.ch_data[ch].cw, dst, &mut self.ch_data[ch].last_im);
816 let mut window: [f32; COEFFS] = [0.0; COEFFS];
817 generate_window(WindowType::Sine, 1.0, COEFFS, true, &mut window);
818 let mut pretwiddle1: [f32; COEFFS/2] = [0.0; COEFFS/2];
819 let mut pretwiddle2: [f32; COEFFS/2] = [0.0; COEFFS/2];
820 let mut posttwiddle: [FFTComplex; COEFFS/2] = [FFTC_ZERO; COEFFS/2];
821 for i in 0..COEFFS/2 {
823 let base = (n * 4.0 + 1.0) / 1024.0 * consts::PI;
827 pretwiddle1[i] = -(r1 + r2) * consts::SQRT_2;
828 pretwiddle2[i] = (r1 - r2) * consts::SQRT_2;
830 pretwiddle1[i] = (r1 + r2) * consts::SQRT_2;
831 pretwiddle2[i] = -(r1 - r2) * consts::SQRT_2;
833 posttwiddle[i] = FFTComplex::exp(consts::PI / 256.0 * n).scale(1.0/32768.0);
836 pretwiddle1: pretwiddle1,
837 pretwiddle2: pretwiddle2,
838 posttwiddle: posttwiddle,
839 tmp: [FFTC_ZERO; COEFFS/2],
840 fft: FFTBuilder::new_fft(FFTMode::SplitRadix, COEFFS/2),
844 fn imdct(&mut self, coeffs: &[f32; COEFFS], dst: &mut [f32], last_im: &mut [f32; COEFFS/2]) {
845 for i in 0..COEFFS/2 {
846 let in2 = coeffs[i * 2];
847 let in1 = coeffs[COEFFS - 1 - i * 2];
848 let c2 = self.pretwiddle1[i];
849 let c1 = self.pretwiddle2[i];
850 self.tmp[i].re = -(c2 * in1 + c1 * in2);
851 self.tmp[i].im = c1 * in1 - c2 * in2;
853 self.fft.do_fft_inplace(&mut self.tmp, false);
854 for i in 0..COEFFS/2 {
855 let tmp = !(self.tmp[i] * self.posttwiddle[i]);
856 let c1 = self.window[i * 2];
857 let c2 = self.window[COEFFS - 1 - i * 2];
859 dst[i * 2] = c2 * im + c1 * tmp.re;
860 dst[COEFFS - 1 - i * 2] = c1 * im - c2 * tmp.re;
866 const CHMAP_MONO: [NAChannelType; 1] = [NAChannelType::C];
867 const CHMAP_STEREO: [NAChannelType; 2] = [NAChannelType::L, NAChannelType::R];
869 impl NADecoder for IMCDecoder {
870 fn init(&mut self, info: Rc<NACodecInfo>) -> DecoderResult<()> {
871 if let NACodecTypeInfo::Audio(ainfo) = info.get_properties() {
872 self.chmap = NAChannelMap::new();
873 match ainfo.get_channels() {
874 1 => { self.chmap.add_channels(&CHMAP_MONO); },
875 2 => { self.chmap.add_channels(&CHMAP_STEREO); },
876 _ => { return Err(DecoderError::InvalidData); },
878 self.ainfo = NAAudioInfo::new(ainfo.get_sample_rate(),
879 ainfo.get_channels(),
881 self.info = info.replace_info(NACodecTypeInfo::Audio(self.ainfo.clone()));
884 self.generate_iac_tables(ainfo.get_sample_rate() as f32);
888 Err(DecoderError::InvalidData)
891 fn decode(&mut self, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
892 let info = pkt.get_stream().get_info();
893 validate!(info.get_properties().is_audio());
894 let pktbuf = pkt.get_buffer();
896 let nblocks = pktbuf.len() / BLOCK_SIZE / (self.ainfo.get_channels() as usize);
897 let duration = COEFFS * nblocks;
899 let mut abuf = alloc_audio_buffer(self.ainfo, duration, self.chmap.clone())?;
900 let mut adata = abuf.get_abuf_f32().unwrap();
901 let mut dst = adata.get_data_mut();
903 let mut start: usize = 0;
904 for chunk in pktbuf.chunks(BLOCK_SIZE * (self.ainfo.get_channels() as usize)) {
905 for ch in 0..self.ainfo.get_channels() {
906 let off = abuf.get_offset(ch as usize) + start;
907 self.decode_block(chunk, ch as usize, &mut dst[off..off+COEFFS])?;
912 let mut frm = NAFrame::new_from_pkt(pkt, self.info.clone(), abuf);
913 frm.set_keyframe(true);
914 Ok(Rc::new(RefCell::new(frm)))
918 pub fn get_decoder_imc() -> Box<NADecoder> {
919 Box::new(IMCDecoder::new(true))
922 pub fn get_decoder_iac() -> Box<NADecoder> {
923 Box::new(IMCDecoder::new(false))
926 struct IMCCodeReader { sel1: usize, sel2: usize }
929 fn new(sel1: usize, sel2: usize) -> Self { IMCCodeReader { sel1: sel1, sel2: sel2 } }
932 impl CodebookDescReader<u8> for IMCCodeReader {
933 fn bits(&mut self, idx: usize) -> u8 { IMC_CODE_LENGTHS[self.sel1][self.sel2][idx] }
934 fn code(&mut self, idx: usize) -> u32 { IMC_CODE_CODES[self.sel1][self.sel2][idx] as u32 }
935 fn sym (&mut self, idx: usize) -> u8 { idx as u8 }
936 fn len(&mut self) -> usize { IMC_CODE_LENGTHS[0][0].len() }
939 static IMC_BANDS: [usize; 33] = [
940 0, 3, 6, 9, 12, 16, 20, 24, 29, 34, 40, 46, 53, 60, 68, 76,
941 84, 93, 102, 111, 121, 131, 141, 151, 162, 173, 184, 195, 207, 219, 231, 243,
945 const IMC_QUANT_SMALL: &[[f32; 8]; 4] = &[
946 [ 8.4431201e-1, 4.7358301e-1, 1.448354, 2.7073899e-1,
947 7.4449003e-1, 1.241991, 1.845484, 0.0 ],
948 [ 8.6876702e-1, 4.7659001e-1, 1.478224, 2.5672799e-1,
949 7.55777e-1, 1.3229851, 2.03438, 0.0 ],
950 [ 7.5891501e-1, 6.2272799e-1, 1.271322, 3.47904e-1,
951 7.5317699e-1, 1.150767, 1.628476, 0.0 ],
952 [ 7.65257e-1, 6.44647e-1, 1.263824, 3.4548101e-1,
953 7.6384902e-1, 1.214466, 1.7638789, 0.0 ]
956 const IMC_QUANT_LARGE: &[[f32; 56]; 2] = &[
957 [ 1.39236e-1, 3.50548e-1, 5.9547901e-1, 8.5772401e-1,
958 1.121545, 1.3882281, 1.695882, 2.1270809,
959 7.2221003e-2, 1.85177e-1, 2.9521701e-1, 4.12568e-1,
960 5.4068601e-1, 6.7679501e-1, 8.1196898e-1, 9.4765198e-1,
961 1.0779999, 1.203415, 1.337265, 1.481871,
962 1.639982, 1.814766, 2.0701399, 2.449862,
963 3.7533998e-2, 1.02722e-1, 1.6021401e-1, 2.16043e-1,
964 2.7231601e-1, 3.3025399e-1, 3.9022601e-1, 4.52849e-1,
965 5.1794899e-1, 5.8529502e-1, 6.53956e-1, 7.2312802e-1,
966 7.9150802e-1, 8.5891002e-1, 9.28141e-1, 9.9706203e-1,
967 1.062153, 1.12564, 1.189834, 1.256122,
968 1.324469, 1.3955311, 1.468906, 1.545084,
969 1.6264729, 1.711524, 1.802705, 1.91023,
970 2.0533991, 2.22333, 2.4830019, 3.253329 ],
971 [ 1.11654e-1, 3.54469e-1, 6.4232099e-1, 9.6128798e-1,
972 1.295053, 1.61777, 1.989839, 2.51107,
973 5.7721999e-2, 1.69879e-1, 2.97589e-1, 4.3858799e-1,
974 5.9039903e-1, 7.4934798e-1, 9.1628098e-1, 1.087297,
975 1.262751, 1.4288321, 1.6040879, 1.79067,
976 2.000668, 2.2394669, 2.649332, 5.2760072,
977 2.9722e-2, 8.7316997e-2, 1.4445201e-1, 2.04247e-1,
978 2.6879501e-1, 3.3716801e-1, 4.08811e-1, 4.8306999e-1,
979 5.6049401e-1, 6.3955498e-1, 7.2044599e-1, 8.0427998e-1,
980 8.8933599e-1, 9.7537601e-1, 1.062461, 1.1510431,
981 1.240236, 1.326715, 1.412513, 1.500502,
982 1.591749, 1.686413, 1.785239, 1.891233,
983 2.0051291, 2.127681, 2.2709141, 2.475826,
984 2.7219379, 3.101985, 4.686213, 6.2287788 ]
987 static IMC_CYCLE1: [usize; BANDS] = [
988 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
989 17, 18, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 32,
992 static IMC_CYCLE2: [usize; BANDS] = [
993 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
994 15, 16, 17, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29
997 static IMC_WEIGHTS1: [f32; BANDS-1] = [
998 0.119595, 0.123124, 0.129192, 9.97377e-2,
999 8.1923e-2, 9.61153e-2, 8.77885e-2, 8.61174e-2,
1000 9.00882e-2, 9.91658e-2, 0.112991, 0.131126,
1001 0.152886, 0.177292, 0.221782, 0.244917,
1002 0.267386, 0.306816, 0.323046, 0.33729,
1003 0.366773, 0.392557, 0.398076, 0.403302,
1004 0.42451, 0.444777, 0.449188, 0.455445,
1005 0.477853, 0.500669, 0.510395
1008 static IMC_WEIGHTS2: [f32; BANDS-1] = [
1009 3.23466e-3, 3.49886e-3, 3.98413e-3, 1.98116e-3,
1010 1.16465e-3, 1.79283e-3, 1.40372e-3, 1.33274e-3,
1011 1.50523e-3, 1.95064e-3, 2.77472e-3, 4.14725e-3,
1012 6.2776e-3, 9.36401e-3, 1.71397e-2, 2.24052e-2,
1013 2.83971e-2, 4.11689e-2, 4.73165e-2, 5.31631e-2,
1014 6.66614e-2, 8.00824e-2, 8.31588e-2, 8.61397e-2,
1015 9.89229e-2, 0.112197, 0.115227, 0.119613,
1016 0.136174, 0.15445, 0.162685
1019 static IMC_BITALLOC_ADJ: [[f32; 7]; 2] = [
1020 [ 7.6, 4.4, 6.1, 2.3, 6.2, 1.8, 0.0 ],
1021 [ 3.6, 3.7, 5.1, 1.6, 1.5, 1.2, 0.0 ]
1024 static IMC_CODE_LENGTHS: &[[[u8; 18]; 4]; 4] = &[
1026 [ 16, 15, 13, 11, 8, 5, 3, 1, 2, 4, 6, 9, 10, 12, 14, 16, 7, 0 ],
1027 [ 10, 8, 7, 6, 4, 4, 3, 2, 2, 3, 4, 6, 7, 9, 11, 11, 7, 0 ],
1028 [ 15, 15, 14, 11, 8, 6, 4, 2, 1, 4, 5, 7, 9, 10, 12, 13, 4, 0 ],
1029 [ 13, 11, 10, 8, 6, 4, 2, 2, 2, 3, 5, 7, 9, 12, 15, 15, 14, 0 ],
1031 [ 14, 12, 10, 8, 7, 4, 2, 2, 2, 3, 5, 7, 9, 11, 13, 14, 7, 0 ],
1032 [ 14, 13, 11, 8, 6, 4, 3, 2, 2, 3, 5, 7, 9, 10, 12, 14, 3, 0 ],
1033 [ 13, 12, 10, 7, 5, 4, 3, 2, 2, 3, 4, 6, 8, 9, 11, 13, 4, 0 ],
1034 [ 13, 12, 10, 7, 5, 4, 3, 2, 2, 3, 4, 6, 8, 9, 11, 13, 4, 0 ],
1036 [ 16, 14, 12, 10, 8, 5, 3, 1, 2, 4, 7, 9, 11, 13, 15, 17, 6, 17 ],
1037 [ 15, 13, 11, 8, 6, 4, 2, 2, 2, 3, 5, 7, 10, 12, 14, 16, 9, 16 ],
1038 [ 14, 12, 11, 9, 8, 6, 3, 1, 2, 5, 7, 10, 13, 15, 16, 17, 4, 17 ],
1039 [ 16, 14, 12, 9, 7, 5, 2, 2, 2, 3, 4, 6, 8, 11, 13, 15, 10, 16 ],
1041 [ 13, 11, 10, 8, 7, 5, 2, 2, 2, 4, 6, 9, 12, 14, 15, 16, 3, 16 ],
1042 [ 11, 11, 10, 9, 8, 7, 5, 4, 3, 3, 3, 3, 3, 3, 4, 5, 6, 5 ],
1043 [ 9, 9, 7, 6, 5, 4, 3, 3, 2, 3, 4, 5, 4, 5, 5, 6, 8, 6 ],
1044 [ 13, 12, 10, 8, 5, 3, 3, 2, 2, 3, 4, 7, 9, 11, 14, 15, 6, 15 ]
1048 static IMC_CODE_CODES: &[[[u16; 18]; 4]; 4] = &[
1050 [ 0xCC32, 0x6618, 0x1987, 0x0660, 0x00CD, 0x0018, 0x0007, 0x0000, 0x0002,
1051 0x000D, 0x0032, 0x0199, 0x0331, 0x0CC2, 0x330D, 0xCC33, 0x0067, 0x0000 ],
1052 [ 0x02FE, 0x00BE, 0x005E, 0x002D, 0x000A, 0x0009, 0x0003, 0x0003, 0x0000,
1053 0x0002, 0x0008, 0x002C, 0x005D, 0x017E, 0x05FE, 0x05FF, 0x005C, 0x0000 ],
1054 [ 0x5169, 0x5168, 0x28B5, 0x0517, 0x00A3, 0x0029, 0x0008, 0x0003, 0x0000,
1055 0x0009, 0x0015, 0x0050, 0x0144, 0x028A, 0x0A2C, 0x145B, 0x000B, 0x0000 ],
1056 [ 0x1231, 0x048D, 0x0247, 0x0090, 0x0025, 0x0008, 0x0001, 0x0003, 0x0000,
1057 0x0005, 0x0013, 0x0049, 0x0122, 0x0919, 0x48C3, 0x48C2, 0x2460, 0x0000 ]
1059 [ 0x2D1D, 0x0B46, 0x02D0, 0x00B5, 0x0059, 0x000A, 0x0003, 0x0001, 0x0000,
1060 0x0004, 0x0017, 0x005B, 0x0169, 0x05A2, 0x168F, 0x2D1C, 0x0058, 0x0000 ],
1061 [ 0x1800, 0x0C01, 0x0301, 0x0061, 0x0019, 0x0007, 0x0004, 0x0003, 0x0000,
1062 0x0005, 0x000D, 0x0031, 0x00C1, 0x0181, 0x0601, 0x1801, 0x0002, 0x0000 ],
1063 [ 0x1556, 0x0AAA, 0x02AB, 0x0054, 0x0014, 0x000B, 0x0002, 0x0003, 0x0000,
1064 0x0003, 0x0008, 0x002B, 0x00AB, 0x0154, 0x0554, 0x1557, 0x0009, 0x0000 ],
1065 [ 0x1556, 0x0AAA, 0x02AB, 0x0054, 0x0014, 0x000B, 0x0002, 0x0003, 0x0000,
1066 0x0003, 0x0008, 0x002B, 0x00AB, 0x0154, 0x0554, 0x1557, 0x0009, 0x0000 ]
1068 [ 0x2993, 0x0A65, 0x0298, 0x00A7, 0x0028, 0x0004, 0x0000, 0x0001, 0x0001,
1069 0x0003, 0x0015, 0x0052, 0x014D, 0x0533, 0x14C8, 0x5324, 0x000B, 0x5325 ],
1070 [ 0x09B8, 0x026F, 0x009A, 0x0012, 0x0005, 0x0000, 0x0001, 0x0002, 0x0003,
1071 0x0001, 0x0003, 0x0008, 0x004C, 0x0136, 0x04DD, 0x1373, 0x0027, 0x1372 ],
1072 [ 0x0787, 0x01E0, 0x00F1, 0x003D, 0x001F, 0x0006, 0x0001, 0x0001, 0x0001,
1073 0x0002, 0x000E, 0x0079, 0x03C2, 0x0F0D, 0x1E19, 0x3C30, 0x0000, 0x3C31 ],
1074 [ 0x4B06, 0x12C0, 0x04B1, 0x0097, 0x0024, 0x0008, 0x0002, 0x0003, 0x0000,
1075 0x0003, 0x0005, 0x0013, 0x004A, 0x0259, 0x0961, 0x2582, 0x012D, 0x4B07 ]
1077 [ 0x0A5A, 0x0297, 0x014A, 0x0053, 0x0028, 0x000B, 0x0003, 0x0000, 0x0002,
1078 0x0004, 0x0015, 0x00A4, 0x052C, 0x14B7, 0x296C, 0x52DB, 0x0003, 0x52DA ],
1079 [ 0x0193, 0x0192, 0x00C8, 0x0065, 0x0033, 0x0018, 0x0007, 0x0004, 0x0000,
1080 0x0004, 0x0005, 0x0007, 0x0006, 0x0003, 0x0005, 0x0005, 0x000D, 0x0004 ],
1081 [ 0x0012, 0x0013, 0x0005, 0x0003, 0x0000, 0x0003, 0x0005, 0x0004, 0x0003,
1082 0x0003, 0x0005, 0x0005, 0x0004, 0x0004, 0x0003, 0x0005, 0x0008, 0x0004 ],
1083 [ 0x0D66, 0x06B2, 0x01AD, 0x006A, 0x000C, 0x0005, 0x0004, 0x0000, 0x0003,
1084 0x0002, 0x0007, 0x0034, 0x00D7, 0x0358, 0x1ACF, 0x359C, 0x001B, 0x359D ]
1088 const IMC_CB_SELECTOR: [[usize; BANDS]; 4] = [
1089 [ 1, 1, 1, 1, 1, 1, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0,
1090 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2 ],
1091 [ 0, 2, 0, 3, 2, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1092 0, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ],
1093 [ 1, 1, 1, 1, 1, 1, 1, 3, 3, 3, 3, 3, 3, 3, 3, 3,
1094 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2 ],
1095 [ 0, 1, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
1096 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]
1104 use test::wavwriter::WavWriter;
1108 let avi_dmx = find_demuxer("avi").unwrap();
1109 let mut file = File::open("assets/neal73_saber.avi").unwrap();
1110 let mut fr = FileReader::new_read(&mut file);
1111 let mut br = ByteReader::new(&mut fr);
1112 let mut dmx = avi_dmx.new_demuxer(&mut br);
1113 dmx.open().unwrap();
1115 let mut file = File::create("assets/imc-out.wav").unwrap();
1116 let mut fw = FileWriter::new_write(&mut file);
1117 let mut wr = ByteWriter::new(&mut fw);
1118 let mut wwr = WavWriter::new(&mut wr);
1119 let mut wrote_header = false;
1121 let mut decs: Vec<Option<Box<NADecoder>>> = Vec::new();
1122 for i in 0..dmx.get_num_streams() {
1123 let s = dmx.get_stream(i).unwrap();
1124 let info = s.get_info();
1125 let decfunc = find_decoder(info.get_name());
1126 if let Some(df) = decfunc {
1127 if info.is_audio() {
1128 let mut dec = (df)();
1129 dec.init(info).unwrap();
1130 decs.push(Some(dec));
1140 let pktres = dmx.get_frame();
1141 if let Err(e) = pktres {
1142 if e == DemuxerError::EOF { break; }
1145 let pkt = pktres.unwrap();
1146 //if pkt.get_pts().unwrap() > 10 { break; }
1147 let streamno = pkt.get_stream().get_id() as usize;
1148 if let Some(ref mut dec) = decs[streamno] {
1149 let frm_ = dec.decode(&pkt).unwrap();
1150 let frm = frm_.borrow();
1151 if frm.get_info().is_audio() {
1153 wwr.write_header(frm.get_info().as_ref().get_properties().get_audio_info().unwrap()).unwrap();
1154 wrote_header = true;
1156 wwr.write_frame(frm.get_buffer()).unwrap();