projects / nihav.git / blob
? search:


2d65a7c954c15752804834c5558dd2a2769d2703
[nihav.git] / nihav-indeo / src / codecs / imc.rs
1 use std::mem;
2 use std::ptr;
3 use std::f32::consts;
4 use std::rc::Rc;
5 use std::cell::RefCell;
6
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::*;
14
15 const BANDS: usize = 32;
16 const COEFFS: usize = 256;
17 const BLOCK_SIZE: usize = 64;
18
19 struct IMDCTContext {
20 pretwiddle1: [f32; COEFFS/2],
21 pretwiddle2: [f32; COEFFS/2],
22 posttwiddle: [FFTComplex; COEFFS/2],
23 tmp: [FFTComplex; COEFFS/2],
24 fft: FFT,
25 window: [f32; COEFFS],
26 }
27
28 struct IMCChannel {
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],
36 cw: [f32; COEFFS],
37 last_im: [f32; COEFFS/2],
38 }
39
40 struct BitAlloc {
41 band_width: [usize; BANDS],
42 band_present: [bool; BANDS],
43 band_skip: [bool; BANDS],
44 band_bits: [u8; BANDS],
45 cw_len: [u8; COEFFS],
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],
51 coeff: [u8; COEFFS],
52 }
53
54 impl IMCChannel {
55 fn new() -> Self {
56 IMCChannel {
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],
64 cw: [0.0; COEFFS],
65 last_im: [0.0; COEFFS/2],
66 }
67 }
68 fn reset(&mut self) {
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; }
71 }
72 }
73
74 const BITALLOC_LIMIT: f32 = -1.0e20;
75 const BITALLOC_TOP_LIMIT: f32 = 1.0e20;
76 impl BitAlloc {
77 fn new() -> Self {
78 BitAlloc {
79 band_width: [0; BANDS],
80 band_present: [false; BANDS],
81 band_skip: [false; BANDS],
82 band_bits: [0; BANDS],
83 cw_len: [0; COEFFS],
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],
89 coeff: [0; COEFFS],
90 }
91 }
92 fn reset(&mut self) {
93 for i in 0..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;
102 }
103 for i in 0..COEFFS {
104 self.cw_len[i] = 0;
105 self.skip_flag[i] = false;
106 }
107 }
108 fn calculate_bit_allocation(&mut self, ch_data: &mut IMCChannel, bits: usize, fixed_head: bool, adj_idx: usize) -> DecoderResult<()> {
109
110 let mut peak = 0.0;
111 for coef in ch_data.new_floor.iter() { if *coef > peak { peak = *coef; } }
112 peak *= 0.25;
113
114 for band in 0..BANDS-1 {
115 ch_data.bit_est[band] = ch_data.log_floor2[band] - ch_data.mask_wght[band].log2();
116 }
117 ch_data.bit_est[BANDS - 1] = BITALLOC_LIMIT;
118
119 for band in 0..BANDS {
120 let mut idx = 42;
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; }
125 validate!(idx <= 2);
126 idx *= 2;
127 if ch_data.new_floor[band] < peak { idx += 1; }
128 ch_data.bit_est[band] += IMC_BITALLOC_ADJ[adj_idx][idx];
129 }
130
131 if fixed_head {
132 for i in 0..4 {
133 ch_data.bit_est[i] = BITALLOC_LIMIT;
134 }
135 }
136
137 let start = if fixed_head { 4 } else { 0 };
138
139 let mut a_width = 0;
140 let mut pool = 0.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];
144 }
145 validate!(a_width > 0);
146
147 self.band_width[BANDS - 1] = 0;
148 pool = (pool * 0.5 - (bits as f32)) / (a_width as f32);
149
150 let free_bits = bits as i32;
151 let mut cur_bits: i32 = 0;
152 let mut flag = 1;
153 let mut mmcount = 0;
154 for i in 0..BANDS/2 {
155 let diff = cur_bits - free_bits;
156 if diff.abs() <= 8 { break; }
157
158 cur_bits = 0;
159 let mut acc = 0;
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);
166 if len > 0 {
167 acc += self.band_width[band] as i32;
168 }
169 }
170
171 let mut lflag = flag;
172 flag = 1;
173 if free_bits < cur_bits { flag = -1; }
174 if i == 0 { lflag = flag; }
175 if flag != lflag {
176 mmcount += 1;
177 }
178 pool += ((cur_bits - free_bits) as f32) / (((mmcount + 1) * acc) as f32);
179 }
180
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];
184 }
185 }
186
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;
192 }
193 }
194 let mut peak = 0.0;
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 {
200 peak = tmp[band];
201 idx = Some(band);
202 }
203 }
204 if let Some(band) = idx {
205 tmp[band] -= 2.0;
206 self.band_bits[band] += 1;
207 if self.band_bits[band] == 6 {
208 tmp[band] = BITALLOC_LIMIT;
209 }
210 for i in IMC_BANDS[band]..IMC_BANDS[band + 1] {
211 self.cw_len[i] += 1;
212 cur_bits += 1;
213 if cur_bits >= free_bits {
214 break;
215 }
216 }
217 }
218 }
219 }
220
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;
226 }
227 }
228 while free_bits < cur_bits {
229 let mut low = BITALLOC_TOP_LIMIT;
230 let mut idx = 0;
231 for band in 0..BANDS {
232 if tmp[band] < low {
233 low = tmp[band];
234 idx = band;
235 }
236 }
237 tmp[idx] += 2.0;
238 self.band_bits[idx] -= 1;
239 if self.band_bits[idx] == 0 {
240 tmp[idx] = BITALLOC_TOP_LIMIT;
241 }
242 for i in IMC_BANDS[idx]..IMC_BANDS[idx + 1] {
243 if self.cw_len[i] > 0 {
244 self.cw_len[i] -= 1;
245 cur_bits -= 1;
246 if cur_bits <= free_bits {
247 break;
248 }
249 }
250 }
251 }
252 }
253
254 Ok(())
255 }
256
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;
262 }
263 }
264 let mut used_bits: i32 = 0;
265 let mut peak = 0.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 {
271 peak = tmp[band];
272 idx = Some(band);
273 }
274 }
275 if let Some(band) = idx {
276 tmp[band] -= 2.0;
277 self.band_bits[band] += 1;
278 if self.band_bits[band] == 6 {
279 tmp[band] = BITALLOC_LIMIT;
280 }
281 for i in IMC_BANDS[band]..IMC_BANDS[band + 1] {
282 if self.cw_len[i] >= 6 { continue; }
283 self.cw_len[i] += 1;
284 used_bits += 1;
285 if used_bits >= free_bits {
286 break;
287 }
288 }
289 }
290 }
291 }
292 }
293
294 struct LUTs {
295 exp_lev: [f32; 16],
296 exp_10: [f32; 32],
297 sqrt_tab: [f32; 32],
298 }
299
300 impl LUTs {
301 fn new() -> Self {
302 let mut exp_lev: [f32; 16] = [0.0; 16];
303 for lev in 0..16 {
304 exp_lev[lev] = 10.0f32.powf(-(lev as f32) * 0.4375);
305 }
306
307 let mut exp_10: [f32; 32] = [0.0; 32];
308 for i in 0..32 {
309 exp_10[i] = 10.0f32.powf(((i as f32) - 16.0) * 0.25);
310 }
311
312 let mut sqrt_tab: [f32; 32] = [0.0; 32];
313 for i in 0..32 {
314 sqrt_tab[i] = (i as f32).sqrt();
315 }
316
317 LUTs { exp_lev: exp_lev, exp_10: exp_10, sqrt_tab: sqrt_tab }
318 }
319 }
320
321 struct IMCDecoder {
322 is_imc: bool,
323
324 chmap: NAChannelMap,
325 ainfo: NAAudioInfo,
326 info: Rc<NACodecInfo>,
327
328 codes: [[Codebook<u8>; 4]; 4],
329 ch_data: [IMCChannel; 2],
330 ba: BitAlloc,
331 imdct: IMDCTContext,
332
333 cycle1: [usize; BANDS],
334 cycle2: [usize; BANDS],
335 weights1: [f32; BANDS-1],
336 weights2: [f32; BANDS-1],
337
338 luts: LUTs,
339 }
340
341 fn freq2bark(freq: f32) -> f32 {
342 3.5 * ((freq / 7500.0) * (freq / 7500.0)).atan() + 13.0 * (freq * 0.00076).atan()
343 }
344
345 fn calc_maxcoef(coef: f32) -> (f32, f32) {
346 let c1 = 20000.0 / 10.0f32.powf(coef * 0.057031251);
347 (c1, c1.log2())
348 }
349
350 impl IMCDecoder {
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];
357 if is_imc {
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);
362 }
363 unsafe {
364 codes = mem::uninitialized();
365 for i in 0..4 {
366 for j in 0..4 {
367 let mut cr = IMCCodeReader::new(i, j);
368 ptr::write(&mut codes[i][j], Codebook::new(&mut cr, CodebookMode::MSB).unwrap());
369 }
370 }
371 }
372 IMCDecoder {
373 is_imc: is_imc,
374 chmap: NAChannelMap::new(),
375 ainfo: NAAudioInfo::new(0, 0, SND_F32P_FORMAT, 0),
376 info: NACodecInfo::new_dummy(),
377
378 codes: codes,
379 ch_data: [IMCChannel::new(), IMCChannel::new()],
380 ba: BitAlloc::new(),
381 imdct: IMDCTContext::new(),
382 luts: LUTs::new(),
383
384 cycle1: cycle1,
385 cycle2: cycle2,
386 weights1: weights1,
387 weights2: weights2,
388 }
389 }
390
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);
401 if band > 0 {
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);
405 }
406 last_bark = bark;
407 freq_mid[band] = freq;
408
409 let mut tmp_freq = freq;
410 while tmp_freq < nyq_freq {
411 tmp_freq += 0.5;
412 if freq2bark(tmp_freq) > bark + 0.5 { break; }
413 }
414 freq_max[band] = tmp_freq;
415
416 let mut tmp_freq = freq;
417 while tmp_freq > 0.0 {
418 tmp_freq -= 0.5;
419 if freq2bark(tmp_freq) < bark - 0.5 { break; }
420 }
421 freq_min[band] = tmp_freq;
422 }
423
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;
428 }
429
430 self.cycle2[0] = 0;
431 for band in 1..BANDS {
432 let mut s_band = 0;
433 while s_band < BANDS-1 && freq_min[band] >= freq_mid[s_band] { s_band += 1; }
434 self.cycle2[band] = s_band - 1;
435 }
436 }
437
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;
442
443 let (c1, c2) = calc_maxcoef(max_coef as f32);
444 for i in 0..BANDS {
445 if i != maxc_pos {
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);
449 } else {
450 ch_data.new_floor[i] = c1;
451 ch_data.log_floor[i] = c2;
452 }
453 self.ba.band_width[i] = IMC_BANDS[i + 1] - IMC_BANDS[i];
454
455 ch_data.log_floor2[i] = ch_data.log_floor[i] * 2.0;
456 ch_data.mask_wght[i] = 1.0;
457 }
458
459 Ok(())
460 }
461
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];
466
467 for band in 0..BANDS {
468 ch_data.mask_wght[band] = 0.0;
469 let val;
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];
473 } else {
474 val = 0.0;
475 ch_data.log_floor2[band] = -30000.0;
476 }
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; }
480 }
481
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];
486 }
487 tmp2[next_band] += tmp3[band];
488 }
489
490 let mut accum = 0.0;
491 for band in 1..BANDS {
492 accum = (tmp2[band] + accum) * self.weights1[band - 1];
493 ch_data.mask_wght[band] += accum;
494 }
495
496 let mut tmp2: [f32; BANDS] = [0.0; BANDS];
497 tmp2[0] = tmp3[0];
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];
502 }
503 tmp2[prev_band + 1] += tmp3[band];
504 }
505
506 let mut accum = 0.0;
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;
511 }
512 }
513
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];
516 let start;
517 if reset {
518 start = 1;
519 level[0] = br.read(7)? as i8;
520 } else {
521 start = 0;
522 }
523 for i in start..BANDS {
524 level[i] = br.read_cb(&self.codes[sel_idx][IMC_CB_SELECTOR[sel_idx][i]])? as i8;
525 if level[i] == 17 {
526 level[i] += br.read(4)? as i8;
527 }
528 self.ba.keep_flag[i] = level[i] == 16;
529 }
530 if reset {
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;
535 for i in 1..BANDS {
536 if level[i] == 16 {
537 ch_data.new_floor[i] = 1.0;
538 ch_data.log_floor[i] = 0.0;
539 } else {
540 let lval;
541 if level[i] < 17 {
542 lval = level[i] - 7;
543 } else if level[i] < 25 {
544 lval = level[i] - 32;
545 } else {
546 lval = level[i] - 16;
547 }
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;
552 }
553 }
554 } else {
555 let ch_data = &mut self.ch_data[ch];
556 for i in 0..BANDS {
557 if level[i] < 16 {
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;
561 } else {
562 ch_data.new_floor[i] = ch_data.old_floor[i];
563 }
564 }
565 }
566
567 self.ba.band_width[0] = IMC_BANDS[1] - IMC_BANDS[0];
568 for i in 1..BANDS {
569 if level[i] != 16 {
570 self.ba.band_width[i] = IMC_BANDS[i + 1] - IMC_BANDS[i];
571 } else {
572 self.ba.band_width[i] = 0;
573 }
574 }
575
576 for i in 0..BANDS-1 {
577 if self.ba.band_width[i] > 0 {
578 self.ba.band_present[i] = br.read_bool()?;
579 }
580 }
581 self.calculate_channel_values(ch);
582
583 Ok(())
584 }
585
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; }
590
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()?;
595 if ba.skip_flag[i] {
596 ba.skips_per_band[band] += 1;
597 }
598 }
599 } else {
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;
607 } else {
608 if br.read_bool()? {
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;
613 } else {
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;
618 } else {
619 ba.skip_flag[i] = false;
620 }
621 ba.skip_flag[i + 1] = false;
622 }
623 }
624 i += 2;
625 }
626 if i != IMC_BANDS[band + 1] {
627 ba.skip_flag_bits[band] += 1;
628 ba.skip_flag[i] = br.read_bool()?;
629 if ba.skip_flag[i] {
630 ba.skips_per_band[band] += 1;
631 }
632 }
633 }
634 }
635 Ok(())
636 }
637
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;
644 }
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;
650 }
651 }
652 }
653
654 self.read_skip_flags(br)?;
655
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];
663 }
664 }
665
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;
673 }
674 }
675 bits_freed -= self.ba.skip_flag_bits[band] as i32;
676 }
677
678 if bits_freed < 0 { return Err(DecoderError::Bug); }
679 self.ba.adjust_bit_allocation(&mut ch_data, bits_freed);
680
681 Ok(())
682 }
683
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;
692 } else {
693 self.ba.coeff[i] = 0;
694 }
695 }
696 }
697 Ok(())
698 }
699
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] {
705 ch_data.cw[i] = 0.0;
706 let cw_len = self.ba.cw_len[i];
707 if cw_len == 0 || self.ba.skip_flag[i] { continue; }
708
709 let val = self.ba.coeff[i] as usize;
710 let mid = 1 << (cw_len - 1);
711 let max = (1 << cw_len) - 1;
712 if cw_len >= 4 {
713 let quant = &IMC_QUANT_LARGE[qidx];
714 if val >= mid {
715 ch_data.cw[i] = quant[val - 8] * ch_data.adj_floor[band];
716 } else {
717 ch_data.cw[i] = -quant[max - val - 8] * ch_data.adj_floor[band];
718 }
719 } else {
720 let idx = qidx + (if self.ba.band_present[band] { 2 } else { 0 });
721 let quant = &IMC_QUANT_SMALL[idx];
722 if val >= mid {
723 ch_data.cw[i] = quant[val - 1] * ch_data.adj_floor[band];
724 } else {
725 ch_data.cw[i] = -quant[max - val - 1] * ch_data.adj_floor[band];
726 }
727 }
728 }
729 }
730 }
731
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);
736
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;
741
742 if reset {
743 self.ch_data[ch].reset();
744 }
745
746 self.ba.reset();
747
748 if raw_coeffs {
749 self.read_level_coeffs_raw(&mut br, ch)?;
750 } else {
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)?;
753 }
754
755 self.ch_data[ch].old_floor.copy_from_slice(&self.ch_data[ch].new_floor);
756
757 let mut bitcount: usize = 0;
758 if fixed_head {
759 bitcount += 15;
760 self.ba.band_bits[0] = 5;
761 for i in 0..3 {
762 self.ba.cw_len[i] = 5;
763 }
764 for band in 1..4 {
765 let bits: u8;
766 if raw_coeffs || !self.ba.keep_flag[band]{
767 bits = 5;
768 } else {
769 bits = 0;
770 }
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;
775 }
776 }
777 }
778
779 if !self.is_imc {
780 if self.ba.band_width[BANDS - 1] != 0 {
781 bitcount += 1;
782 }
783 bitcount += 16;
784 } else {
785 if self.ba.band_width[BANDS - 1] != 0 {
786 bitcount += 1;
787 }
788 }
789
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)?;
792
793 if !raw_coeffs {
794 self.read_bitalloc_delta(&mut br, ch)?;
795 }
796
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;
802 }
803 }
804 }
805
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);
809
810 Ok(())
811 }
812 }
813
814 impl IMDCTContext {
815 fn new() -> Self {
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 {
822 let n = i as f32;
823 let base = (n * 4.0 + 1.0) / 1024.0 * consts::PI;
824 let r1 = base.sin();
825 let r2 = base.cos();
826 if (i & 1) == 0 {
827 pretwiddle1[i] = -(r1 + r2) * consts::SQRT_2;
828 pretwiddle2[i] = (r1 - r2) * consts::SQRT_2;
829 } else {
830 pretwiddle1[i] = (r1 + r2) * consts::SQRT_2;
831 pretwiddle2[i] = -(r1 - r2) * consts::SQRT_2;
832 }
833 posttwiddle[i] = FFTComplex::exp(consts::PI / 256.0 * n).scale(1.0/32768.0);
834 }
835 IMDCTContext {
836 pretwiddle1: pretwiddle1,
837 pretwiddle2: pretwiddle2,
838 posttwiddle: posttwiddle,
839 tmp: [FFTC_ZERO; COEFFS/2],
840 fft: FFTBuilder::new_fft(FFTMode::SplitRadix, COEFFS/2),
841 window: window,
842 }
843 }
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;
852 }
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];
858 let im = last_im[i];
859 dst[i * 2] = c2 * im + c1 * tmp.re;
860 dst[COEFFS - 1 - i * 2] = c1 * im - c2 * tmp.re;
861 last_im[i] = tmp.im;
862 }
863 }
864 }
865
866 const CHMAP_MONO: [NAChannelType; 1] = [NAChannelType::C];
867 const CHMAP_STEREO: [NAChannelType; 2] = [NAChannelType::L, NAChannelType::R];
868
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); },
877 };
878 self.ainfo = NAAudioInfo::new(ainfo.get_sample_rate(),
879 ainfo.get_channels(),
880 SND_F32P_FORMAT, 0);
881 self.info = info.replace_info(NACodecTypeInfo::Audio(self.ainfo.clone()));
882
883 if !self.is_imc {
884 self.generate_iac_tables(ainfo.get_sample_rate() as f32);
885 }
886 Ok(())
887 } else {
888 Err(DecoderError::InvalidData)
889 }
890 }
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();
895
896 let nblocks = pktbuf.len() / BLOCK_SIZE / (self.ainfo.get_channels() as usize);
897 let duration = COEFFS * nblocks;
898
899 let abuf = alloc_audio_buffer(self.ainfo, duration, self.chmap.clone())?;
900 let mut adata = abuf.get_abuf_f32().unwrap();
901 let dst = adata.get_data_mut().unwrap();
902
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])?;
909 }
910 if (channels == 2) && ((chunk[1] & 0x20) != 0) {
911 let off1 = abuf.get_offset(0) + start;
912 let off2 = abuf.get_offset(1) + start;
913 for i in 0..COEFFS {
914 let l = dst[off1 + i];
915 let r = dst[off2 + i];
916 dst[off1 + i] = l + r;
917 dst[off2 + i] = l - r;
918 }
919 }
920 start += COEFFS;
921 }
922
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)))
926 }
927 }
928
929 pub fn get_decoder_imc() -> Box<NADecoder> {
930 Box::new(IMCDecoder::new(true))
931 }
932
933 pub fn get_decoder_iac() -> Box<NADecoder> {
934 Box::new(IMCDecoder::new(false))
935 }
936
937 struct IMCCodeReader { sel1: usize, sel2: usize }
938
939 impl IMCCodeReader {
940 fn new(sel1: usize, sel2: usize) -> Self { IMCCodeReader { sel1: sel1, sel2: sel2 } }
941 }
942
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() }
948 }
949
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,
953 256,
954 ];
955
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 ]
965 ];
966
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 ]
996 ];
997
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,
1001 ];
1002
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
1006 ];
1007
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
1017 ];
1018
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
1028 ];
1029
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 ]
1033 ];
1034
1035 static IMC_CODE_LENGTHS: &[[[u8; 18]; 4]; 4] = &[
1036 [
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 ],
1041 ], [
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 ],
1046 ], [
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 ],
1051 ], [
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 ]
1056 ]
1057 ];
1058
1059 static IMC_CODE_CODES: &[[[u16; 18]; 4]; 4] = &[
1060 [
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 ]
1069 ], [
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 ]
1078 ], [
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 ]
1087 ], [
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 ]
1096 ]
1097 ];
1098
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 ]
1108 ];
1109
1110 #[cfg(test)]
1111 mod test {
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;
1117 #[test]
1118 fn test_imc() {
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);
1123
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);
1131 }
1132 }
NihAV is a research multimedia framework