projects / nihav.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
RealAudio DNET decoder
[nihav.git] / src / codecs / ts102366.rs
CommitLineData
16dd4f44
KS		 1use formats::*;
2use frame::*;
3use super::*;
4use io::bitreader::*;
5use dsp::fft::*;
6use std::str::FromStr;
7use std::f32::consts;
8
9const BLOCK_LEN: usize = 256;
10const NBLOCKS: usize = 6;
11const MAX_CHANNELS: usize = 5;
12const MAX_CPLBANDS: usize = 18;
13const MAX_BANDS: usize = 50;
14
15const MAGIC_BYTE0: u8 = 0x0B;
16const MAGIC_BYTE1: u8 = 0x77;
17
18const STRATEGY_REUSE: u8 = 0;
19
20const LFE_CHANNEL: usize = MAX_CHANNELS;
21const CPL_CHANNEL: usize = MAX_CHANNELS + 1;
22
23struct IMDCTContext {
24 xsincos: [FFTComplex; BLOCK_LEN/2],
25 fft: FFT,
26 size: usize,
27}
28
29struct IMDCTWorkspace {
30 z: [FFTComplex; BLOCK_LEN / 2],
31 y: [FFTComplex; BLOCK_LEN / 2],
32 out: [f32; BLOCK_LEN * 2],
33}
34
35impl IMDCTContext {
36 fn new(bits: usize) -> Self {
37 let size = 1 << bits;
38 let size4 = 1 << (bits - 2);
39 let mut xsincos: [FFTComplex; 512/4] = [FFTC_ZERO; 512/4];
40 for k in 0..size4 {
41 let factor = 2.0 * consts::PI * ((8 * k + 1) as f32) / ((8 * size) as f32);
42 xsincos[k].re = -factor.cos();
43 xsincos[k].im = -factor.sin();
44 }
45 let fft = FFTBuilder::new_fft(FFTMode::SplitRadix, size/4);
46 IMDCTContext { xsincos: xsincos, size: size, fft: fft }
47 }
48 #[allow(non_snake_case)]
49 fn do_imdct(&mut self, coeffs: &[i32; BLOCK_LEN], tmp: &mut IMDCTWorkspace) {
50 do_imdct_core(&mut self.fft, &self.xsincos, self.size, false, coeffs, &mut tmp.z, &mut tmp.y);
51 let w = &TS102366_WINDOW;
52 let N2 = self.size / 2;
53 let N4 = self.size / 4;
54 let N8 = self.size / 8;
55 for n in 0..N8 {
56 tmp.out[ 2 * n] = -tmp.y[N8 + n] .im * w[ 2 * n];
57 tmp.out[ 2 * n + 1] = tmp.y[N8 - n - 1].re * w[ 2 * n + 1];
58 tmp.out[ N4 + 2 * n] = -tmp.y[ n] .re * w[N4 + 2 * n];
59 tmp.out[ N4 + 2 * n + 1] = tmp.y[N4 - n - 1].im * w[N4 + 2 * n + 1];
60 tmp.out[ N2 + 2 * n] = -tmp.y[N8 + n] .re * w[N2 - 2 * n - 1];
61 tmp.out[ N2 + 2 * n + 1] = tmp.y[N8 - n - 1].im * w[N2 - 2 * n - 2];
62 tmp.out[3 * N4 + 2 * n] = tmp.y[ n] .im * w[N4 - 2 * n - 1];
63 tmp.out[3 * N4 + 2 * n + 1] = -tmp.y[N4 - n - 1].re * w[N4 - 2 * n - 2];
64 }
65 }
66 #[allow(non_snake_case)]
67 fn do_imdct_ileave(&mut self, coeffs: &[i32; BLOCK_LEN], tmp: &mut IMDCTWorkspace) {
68 let mut ziter = tmp.z.chunks_mut(self.size / 4);
69 let z1 = ziter.next().unwrap();
70 let z2 = ziter.next().unwrap();
71 let mut yiter = tmp.y.chunks_mut(self.size / 4);
72 let y1 = yiter.next().unwrap();
73 let y2 = yiter.next().unwrap();
74 do_imdct_core(&mut self.fft, &self.xsincos, self.size, true, coeffs, z1, y1);
75 do_imdct_core(&mut self.fft, &self.xsincos, self.size, true, &coeffs[1..], z2, y2);
76 let w = &TS102366_WINDOW;
77 let N2 = self.size / 2;
78 let N4 = self.size / 4;
79 let N8 = self.size / 8;
80 for n in 0..N8 {
81 tmp.out[ 2 * n] = -y1[ n] .im * w[ 2 * n];
82 tmp.out[ 2 * n + 1] = y1[N8 - n - 1].re * w[ 2 * n + 1];
83 tmp.out[ N4 + 2 * n] = -y1[ n] .re * w[N4 + 2 * n];
84 tmp.out[ N4 + 2 * n + 1] = y1[N8 - n - 1].im * w[N4 + 2 * n + 1];
85 tmp.out[ N2 + 2 * n] = -y2[ n] .re * w[N2 - 2 * n - 1];
86 tmp.out[ N2 + 2 * n + 1] = y2[N8 - n - 1].im * w[N2 - 2 * n - 2];
87 tmp.out[3 * N4 + 2 * n] = y2[ n] .im * w[N4 - 2 * n - 1];
88 tmp.out[3 * N4 + 2 * n + 1] = -y2[N8 - n - 1].re * w[N4 - 2 * n - 2];
89 }
90 }
91}
92
93#[allow(non_snake_case)]
94fn do_imdct_core(fft: &mut FFT, xsc: &[FFTComplex; BLOCK_LEN/2], size: usize, ilace: bool, coeffs: &[i32], z: &mut [FFTComplex], y: &mut [FFTComplex]) {
95 let N = size;
96 let N2 = size / 2;
97 let N4 = size / 4;
98 let scale = 1.0 / ((1 << 24) as f32);
99 for k in 0..N4 {
100 let (c0, c1) = if !ilace {
101 ((coeffs[N2 - 2 * k - 1] as f32) * scale ,
102 (coeffs[ 2 * k] as f32) * scale)
103 } else {
104 ((coeffs[N - 4 * k - 2] as f32) * scale,
105 (coeffs[ 4 * k] as f32) * scale)
106 };
107 z[k].re = c0 * xsc[k].re - c1 * xsc[k].im;
108 z[k].im = c0 * xsc[k].im + c1 * xsc[k].re;
109 }
110 fft.do_fft_inplace(z, false);
111 for k in 0..N4 {
112 y[k] = z[k] * xsc[k];
113 }
114}
115
116struct AudioDecoder {
117 info: Rc<NACodecInfo>,
118 ablk: AudioBlock,
119 imdct512: IMDCTContext,
120 imdct256: IMDCTContext,
121 tmp: IMDCTWorkspace,
122 delay: [[f32; BLOCK_LEN]; MAX_CHANNELS + 1],
123}
124
125impl AudioDecoder {
126 fn new() -> Self {
127 AudioDecoder {
128 info: NACodecInfo::new_dummy(),
129 ablk: AudioBlock::new(),
130 imdct512: IMDCTContext::new(9),
131 imdct256: IMDCTContext::new(8),
132 tmp: IMDCTWorkspace {
133 z: [FFTC_ZERO; BLOCK_LEN / 2],
134 y: [FFTC_ZERO; BLOCK_LEN / 2],
135 out: [0.0; BLOCK_LEN * 2],
136 },
137 delay: [[0.0; BLOCK_LEN]; MAX_CHANNELS + 1],
138 }
139 }
140}
141
142const SAMPLE_RATES: [u32; 4] = [ 48000, 44100, 32000, 0 ];
143
144const FRAME_SIZES: [[usize; 64]; 4] = [
145 [
146 64, 64, 80, 80, 96, 96, 112, 112,
147 128, 128, 160, 160, 192, 192, 224, 224,
148 256, 256, 320, 320, 384, 384, 448, 448,
149 512, 512, 640, 640, 768, 768, 896, 896,
150 1024, 1024, 1152, 1152, 1280, 1280,
151 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
152 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
153 ], [
154 69, 70, 87, 88, 104, 105, 121, 122,
155 139, 140, 174, 175, 208, 209, 243, 244,
156 278, 279, 348, 349, 417, 418, 487, 488,
157 557, 558, 696, 697, 835, 836, 975, 976,
158 1114, 1115, 1253, 1254, 1393, 1394,
159 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
160 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
161 ], [
162 96, 96, 120, 120, 144, 144, 168, 168,
163 192, 192, 240, 240, 288, 288, 336, 336,
164 384, 384, 480, 480, 576, 576, 672, 672,
165 768, 768, 960, 960, 1152, 1152, 1344, 1344,
166 1536, 1536, 1728, 1728, 1920, 1920,
167 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
168 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
169 ], [ 0; 64 ],
170];
171
172#[derive(Debug,Clone,Copy)]
173struct Syncinfo {
174 crc1: u16,
175 fscod: u8,
176 frmsizecod: u8,
177 samplerate: u32,
178 frame_size: usize,
179}
180
181impl Syncinfo {
182 fn read(br: &mut BitReader) -> DecoderResult<Self> {
183 let syncword = br.read(16)?;
184 validate!(syncword == ((MAGIC_BYTE0 as u32) * 256) + (MAGIC_BYTE1 as u32));
185 let crc1 = br.read(16)? as u16;
186 let fscod = br.read(2)? as usize;
187 let frmsizecod = br.read(6)? as usize;
188 Ok(Syncinfo { crc1: crc1, fscod: fscod as u8, frmsizecod: frmsizecod as u8,
189 samplerate: SAMPLE_RATES[fscod], frame_size: FRAME_SIZES[fscod][frmsizecod] * 2 })
190 }
191 fn is_valid(&self) -> bool {
192 (self.samplerate != 0) && (self.frame_size != 0)
193 }
194}
195
196trait ReadOptional {
197 fn read_optional8(&mut self) -> BitReaderResult<Option<u8>>;
198 fn read_optional16(&mut self, bits: u8) -> BitReaderResult<Option<u16>>;
199}
200
201impl<'a> ReadOptional for BitReader<'a> {
202 fn read_optional8(&mut self) -> BitReaderResult<Option<u8>> {
203 if self.read_bool()? {
204 Ok(Some(self.read(8)? as u8))
205 } else {
206 Ok(None)
207 }
208 }
209 fn read_optional16(&mut self, bits: u8) -> BitReaderResult<Option<u16>> {
210 if self.read_bool()? {
211 Ok(Some(self.read(bits)? as u16))
212 } else {
213 Ok(None)
214 }
215 }
216}
217
218#[derive(Debug,Clone,Copy,PartialEq)]
219enum ACMode {
220 DualMono,
221 Mono,
222 Stereo,
223 Mode3_0,
224 Mode2_1,
225 Mode3_1,
226 Mode2_2,
227 Mode3_2,
228}
229
230impl ACMode {
231 fn get_num_channels(&self) -> usize {
232 match *self {
233 ACMode::DualMono => 2,
234 ACMode::Mono => 1,
235 ACMode::Stereo => 2,
236 ACMode::Mode3_0 => 3,
237 ACMode::Mode2_1 => 3,
238 ACMode::Mode3_1 => 4,
239 ACMode::Mode2_2 => 4,
240 ACMode::Mode3_2 => 5,
241 }
242 }
243 fn get_channel_map_str(&self) -> &'static str {
244 match *self {
245 ACMode::DualMono => "C,C",
246 ACMode::Mono => "C",
247 ACMode::Stereo => "L,R",
248 ACMode::Mode3_0 => "L,C,R",
249 ACMode::Mode2_1 => "L,R,Cs",
250 ACMode::Mode3_1 => "L,C,R,Cs",
251 ACMode::Mode2_2 => "L,R,Ls,Rs",
252 ACMode::Mode3_2 => "L,C,R,Ls,Rs",
253 }
254 }
255 fn get_channel_map(&self, has_lfe: bool) -> NAChannelMap {
256 let mut chmap = NAChannelMap::from_str(self.get_channel_map_str()).unwrap();
257 if has_lfe {
258 chmap.add_channel(NAChannelType::LFE);
259 }
260 chmap
261 }
262 fn is_3_x(&self) -> bool {
263 match *self {
264 ACMode::Mode3_0 |
265 ACMode::Mode3_1 |
266 ACMode::Mode3_2 => true,
267 _ => false,
268 }
269 }
270 fn is_surround(&self) -> bool {
271 match *self {
272 ACMode::Mode2_1 |
273 ACMode::Mode3_1 |
274 ACMode::Mode2_2 |
275 ACMode::Mode3_2 => true,
276 _ => false,
277 }
278 }
279}
280
281const AC_MODES: [ACMode; 8] = [
282 ACMode::DualMono, ACMode::Mono, ACMode::Stereo,
283 ACMode::Mode3_0, ACMode::Mode2_1,
284 ACMode::Mode3_1, ACMode::Mode2_2,
285 ACMode::Mode3_2
286];
287
288#[derive(Debug,Clone,Copy)]
289struct Mixinfo {
290 dialnorm: u8,
291 compr: Option<u8>,
292 langcod: Option<u8>,
293 mixlevel: Option<u8>,
294 roomtyp: Option<u8>,
295}
296
297impl Mixinfo {
298 fn read(br: &mut BitReader) -> DecoderResult<Self> {
299 let dialnorm = br.read(5)? as u8;
300 let compr = br.read_optional8()?;
301 let langcod = br.read_optional8()?;
302 let (mixlevel, roomtyp) = if br.read_bool()? {
303 let mlev = br.read(5)? as u8;
304 let rt = br.read(2)? as u8;
305 validate!(rt < 3);
306 (Some(mlev), Some(rt))
307 } else {
308 (None, None)
309 };
310 Ok(Mixinfo { dialnorm, compr, langcod, mixlevel, roomtyp })
311 }
312}
313
314#[derive(Debug,Clone,Copy)]
315struct BSI {
316 bsid: u8,
317 shift: u8,
318 bsmod: u8,
319 acmod: ACMode,
320 cmixlev: Option<u8>,
321 surmixlev: Option<u8>,
322 dsurmod: Option<u8>,
323 lfeon: bool,
324 mixinfo: Mixinfo,
325 mixinfo2: Option<Mixinfo>,
326 copysmth: bool,
327 origbs: bool,
328 timecod1: Option<u16>,
329 timecod2: Option<u16>,
330 has_addb: bool,
331}
332
333impl BSI {
334 fn read(br: &mut BitReader) -> DecoderResult<BSI> {
335 let bsid = br.read(5)? as u8;
336 validate!(bsid <= 10);
337 let shift = if bsid < 9 { 0 } else { bsid - 9 + 1 };
338 let bsmod = br.read(3)? as u8;
339 let acmod_id = br.read(3)? as usize;
340 validate!(acmod_id < AC_MODES.len());
341 let acmod = AC_MODES[acmod_id];
342 let cmixlev = if acmod.is_3_x() {
343 let cl = br.read(2)? as u8;
344 validate!(cl < 3);
345 Some(cl)
346 } else { None };
347 let surmixlev = if acmod.is_surround() {
348 let sml = br.read(2)? as u8;
349 validate!(sml < 3);
350 Some(sml)
351 } else { None };
352 let dsurmod = if acmod == ACMode::Stereo {
353 let dsm = br.read(2)? as u8;
354 validate!(dsm < 3);
355 Some(dsm)
356 } else { None };
357 let lfeon = br.read_bool()?;
358 let mixinfo = Mixinfo::read(br)?;
359 let mixinfo2 = if acmod == ACMode::DualMono {
360 Some(Mixinfo::read(br)?)
361 } else {
362 None
363 };
364 let copysmth = br.read_bool()?;
365 let origbs = br.read_bool()?;
366 let timecod1 = br.read_optional16(14)?;
367 let timecod2 = br.read_optional16(14)?;
368 let has_addb = br.read_bool()?;
369 Ok(BSI{
370 bsid, shift, bsmod, acmod, lfeon,
371 cmixlev, surmixlev, dsurmod,
372 mixinfo: mixinfo, mixinfo2: mixinfo2,
373 copysmth, origbs, timecod1, timecod2, has_addb,
374 })
375 }
376}
377
378#[derive(Clone, Copy)]
379struct ChannelData {
380 blksw: bool,
381 dithflag: bool,
382
383 chincpl: bool,
384 cplcoe: bool,
385 cplcoexp: [u8; MAX_CPLBANDS],
386 cplcomant: [u8; MAX_CPLBANDS],
387 mstrcplco: u8,
388
389 chbwcod: u8,
390
391 expstr: u8,
392 gainrng: u8,
393 startmant: usize,
394 endmant: usize,
395 groups: usize,
396
397 fsnroffst: u8,
398 fgaincod: usize,
399 snroffset: i32,
400
401 deltbae: u8,
402 deltnseg: usize,
403 deltoffst: [u8; 8],
404 deltlen: [usize; 8],
405 deltba: [u8; 8],
406
407 bap: [u8; 256],
408 exps: [u8; 256],
409 mant: [i32; 256],
410
411 psd: [i16; 256],
412 bndpsd: [i32; 64],
413}
414
415const GROUPS: [usize; 4] = [ 0, 3, 6, 12 ];
416const GROUP_BIAS: [usize; 4] = [ 0, 0, 3, 9 ];
417
418fn decode_exps(br: &mut BitReader, dst: &mut [u8], mut prev: u8, grplen: usize) -> DecoderResult<()> {
419 let repeat = grplen / 3;
420
421 for out in dst.chunks_mut(grplen) {
422 let val = br.read(7)? as u8;
423 validate!(val < 125);
424 let diff: [u8; 3] = [ val / 25, (val / 5) % 5, val % 5 ];
425 for (i, exps) in out.chunks_mut(repeat).enumerate() {
426 exps[0] = (prev + diff[i]).wrapping_sub(2);
427 validate!(exps[0] <= 24);
428 for j in 1..repeat {
429 exps[j] = exps[0];
430 }
431 prev = exps[0];
432 }
433 }
434
435 Ok(())
436}
437
438macro_rules! read_bap {
439 ($br: expr, $tab:ident, $nbits:expr) => ({
440 let val = $br.read($nbits)? as usize;
441 validate!(val < $tab.len());
442 $tab[val]
443 });
444 ($br:expr, $tab:ident, $nbits:expr, $bufidx:expr, $bap_buf:expr, $bap_buf_fill:expr) => (
445 if $bap_buf_fill[$bufidx] > 0 {
446 $bap_buf_fill[$bufidx] -= 1;
447 $bap_buf[$bufidx][$bap_buf_fill[$bufidx]]
448 } else {
449 let val = $br.read($nbits)? as usize;
450 validate!(val < $tab.len());
451 for i in 1..$tab[0].len() {
452 $bap_buf[$bufidx][i - 1] = $tab[val][i];
453 }
454 $bap_buf_fill[$bufidx] = $tab[0].len() - 1;
455 $tab[val][0]
456 }
457 );
458}
459
460impl ChannelData {
461 fn new() -> Self {
462 ChannelData {
463 blksw: false,
464 dithflag: false,
465
466 chincpl: false,
467 cplcoe: false,
468 cplcoexp: [0; MAX_CPLBANDS],
469 cplcomant: [0; MAX_CPLBANDS],
470 mstrcplco: 0,
471
472 chbwcod: 0,
473
474 expstr: 0,
475 gainrng: 0,
476 startmant: 0,
477 endmant: 0,
478 groups: 0,
479
480 fsnroffst: 0,
481 fgaincod: 0,
482 snroffset: 0,
483
484 deltbae: 0,
485 deltnseg: 0,
486 deltoffst: [0; 8],
487 deltlen: [0; 8],
488 deltba: [0; 8],
489
490 bap: [0; 256],
491 exps: [0; 256],
492 mant: [0; 256],
493
494 psd: [0; 256],
495 bndpsd: [0; 64],
496 }
497 }
498 fn read_strategy(&mut self, br: &mut BitReader, blk_no: usize) -> DecoderResult<()> {
499 self.expstr = br.read(2)? as u8;
500 validate!(blk_no != 0 || self.expstr != STRATEGY_REUSE);
501 if self.expstr != STRATEGY_REUSE {
502 if self.startmant > 0 {
503 self.groups = (self.endmant - self.startmant) / GROUPS[self.expstr as usize];
504 } else if self.endmant != 0{
505 let idx = self.expstr as usize;
506 self.groups = (self.endmant + GROUP_BIAS[idx] - 1) / GROUPS[idx];
507 } else {
508 self.groups = 0;
509 }
510 }
511 Ok(())
512 }
513 fn read_exps(&mut self, br: &mut BitReader, is_cpl: bool, is_lfe: bool) -> DecoderResult<()> {
514 if self.expstr == STRATEGY_REUSE { return Ok(()); }
515 let grpsize = GROUPS[self.expstr as usize];
516 self.exps = [0; 256];
517 if is_cpl {
518 let first = (br.read(4)? as u8) << 1;
519 let out = &mut self.exps[self.startmant..self.endmant];
520 decode_exps(br, out, first, grpsize)?;
521 } else if !is_lfe {
522 self.exps[0] = br.read(4)? as u8;
523 let first = self.exps[0];
524 let out = &mut self.exps[1..self.endmant];
525 decode_exps(br, out, first, grpsize)?;
526 self.gainrng = br.read(2)? as u8;
527 } else {
528 self.exps[0] = br.read(4)? as u8;
529 let first = self.exps[0];
530 let out = &mut self.exps[1..7];
531 decode_exps(br, out, first, grpsize)?;
532 }
533 Ok(())
534 }
535 fn read_snr(&mut self, br: &mut BitReader) -> DecoderResult<()> {
536 self.fsnroffst = br.read(4)? as u8;
537 self.fgaincod = br.read(3)? as usize;
538 Ok(())
539 }
540 fn read_deltbai(&mut self, br: &mut BitReader) -> DecoderResult<()> {
541 if self.deltbae == 1 {
542 self.deltnseg = (br.read(3)? as usize) + 1;
543 for seg in 0..self.deltnseg {
544 self.deltoffst[seg] = br.read(5)? as u8;
545 self.deltlen[seg] = br.read(4)? as usize;
546 self.deltba[seg] = br.read(3)? as u8;
547 }
548 }
549 Ok(())
550 }
551
552 fn compute_bndpsd(&mut self) {
553 let start = self.startmant;
554 let end = self.endmant;
555 let exps = &mut self.exps;
556 let psd = &mut self.psd;
557 let bndpsd = &mut self.bndpsd;
558
559 for bin in start..end {
560 psd[bin] = 3072 - ((exps[bin] as i16) << 7);
561 }
562
563 let mut bin = start;
564 let mut band = TS102366_BIN_TO_BAND[bin] as usize;
565 let mut lastbin;
566 loop {
567 lastbin = ((TS102366_BAND_START[band] as usize) + (TS102366_BAND_SIZE[band] as usize)).min(end);
568 bndpsd[band] = psd[bin] as i32;
569 bin += 1;
570 while bin < lastbin {
571 bndpsd[band] = logadd(bndpsd[band], psd[bin] as i32);
572 bin += 1;
573 }
574 band += 1;
575 if lastbin >= end { break; }
576 }
577 }
578 fn compute_mask(&mut self, mask: &mut [i32; MAX_BANDS], fscod: usize, sgain: u16, fdecay: u8, sdecay: u8,
579 dbknee: u16, cplfleak: u16, cplsleak: u16, shift: u8) {
580 let fgain = TS102366_FAST_GAIN[self.fgaincod] as i32;
581
582 let bndstart = TS102366_BIN_TO_BAND[self.startmant] as usize;
583 let bndend = (TS102366_BIN_TO_BAND[self.endmant - 1] as usize) + 1;
584
585 let mut excite: [i32; MAX_BANDS] = [0; MAX_BANDS];
586
587 let begin;
588 let mut fast_leak;
589 let mut slow_leak;
590 if bndstart == 0 {
591 let lowcomp0 = calc_lowcomp(0, self.bndpsd[0], self.bndpsd[1], 0);
592 excite[0] = self.bndpsd[0] - fgain - lowcomp0;
593 let lowcomp1 = calc_lowcomp(lowcomp0, self.bndpsd[1], self.bndpsd[2], 1);
594 excite[1] = self.bndpsd[1] - fgain - lowcomp1;
595 let mut sband = 7;
596 let mut lowcomp = lowcomp1;
597 fast_leak = 0;
598 slow_leak = 0;
599 for band in 2..7 {
600 let not_lfe_case = (bndend != 7) || (band != 6);
601 if not_lfe_case {
602 lowcomp = calc_lowcomp(lowcomp, self.bndpsd[band], self.bndpsd[band + 1], band);
603 }
604 fast_leak = self.bndpsd[band] - fgain;
605 slow_leak = self.bndpsd[band] - (sgain as i32);
606 excite[band] = fast_leak - lowcomp;
607 if not_lfe_case {
608 if self.bndpsd[band] <= self.bndpsd[band + 1] {
609 sband = band + 1;
610 break;
611 }
612 }
613 }
614 for band in sband..bndend.min(22) {
615 if (bndend != 7) || (band != 6) {
616 lowcomp = calc_lowcomp(lowcomp, self.bndpsd[band], self.bndpsd[band + 1], band);
617 }
618 fast_leak = (fast_leak - (fdecay as i32)).max(self.bndpsd[band] - (fgain as i32));
619 slow_leak = (slow_leak - (sdecay as i32)).max(self.bndpsd[band] - (sgain as i32));
620 excite[band] = slow_leak.max(fast_leak - lowcomp);
621 }
622 begin = 22;
623 } else {
624 begin = bndstart;
625 fast_leak = cplfleak as i32;
626 slow_leak = cplsleak as i32;
627 }
628 for band in begin..bndend {
629 fast_leak = (fast_leak - (fdecay as i32)).max(self.bndpsd[band] - (fgain as i32));
630 slow_leak = (slow_leak - (sdecay as i32)).max(self.bndpsd[band] - (sgain as i32));
631 excite[band] = fast_leak.max(slow_leak);
632 }
633 for band in bndstart..bndend {
634 if self.bndpsd[band] < (dbknee as i32) {
635 excite[band] += ((dbknee as i32) - self.bndpsd[band]) >> 2;
636 }
637 mask[band] = excite[band].max(TS102366_HTH[fscod][band >> shift] as i32);
638 }
639 }
640 fn apply_delta_info(&mut self, mask: &mut [i32; MAX_BANDS]) {
641 if self.deltbae == 0 || self.deltbae == 1 {
642 let mut band = TS102366_BIN_TO_BAND[self.startmant] as usize;
643 for seg in 0..self.deltnseg {
644 band += self.deltoffst[seg] as usize;
645 let delta = if self.deltba[seg] >= 4 {
646 ((self.deltba[seg] as i32) - 3) << 7
647 } else {
648 ((self.deltba[seg] as i32) - 4) << 7
649 };
650 if band + self.deltlen[seg] > MAX_BANDS { break; }
651 for _ in 0..self.deltlen[seg] {
652 mask[band] += delta;
653 band += 1;
654 }
655 }
656 }
657 }
658 fn calc_snr_offset(&mut self, csnroffst: u8) {
659 self.snroffset = ((((csnroffst as i32) - 15) << 4) + (self.fsnroffst as i32)) << 2;
660 }
661 fn compute_bap(&mut self, mask: &mut [i32; MAX_BANDS], floor: u16) {
662 let end = self.endmant;
663 let mut band = TS102366_BIN_TO_BAND[self.startmant] as usize;
664 let mut bin = self.startmant;
665 let mut lastbin;
666 loop {
667 lastbin = ((TS102366_BAND_START[band] as usize) + (TS102366_BAND_SIZE[band] as usize)).min(end);
668 mask[band] = (mask[band] - self.snroffset - (floor as i32)).max(0) & 0x1FE0;
669 mask[band] += floor as i32;
670 while bin < lastbin {
671 let addr = (((self.psd[bin] as i32) - mask[band]) >> 5).min(63).max(0) as usize;
672 self.bap[bin] = TS102366_BAPTAB[addr];
673 bin += 1;
674 }
675 if lastbin == end { break; }
676 band += 1;
677 }
678 }
679 fn read_mant(&mut self, br: &mut BitReader, bap_buf: &mut [[i32; 2]; 3], bap_buf_fill: &mut [usize; 3]) -> DecoderResult<()> {
680 self.mant = [0; BLOCK_LEN];
681 for bin in self.startmant..self.endmant {
682 self.mant[bin] = match self.bap[bin] {
683 0 => {
684 if self.dithflag {
685 42 // todo dither
686 } else {
687 0
688 }
689 },
690 1 => { read_bap!(br, TS102366_QUANT3_MAP, 5, 0, bap_buf, bap_buf_fill) },
691 2 => { read_bap!(br, TS102366_QUANT5_MAP, 7, 1, bap_buf, bap_buf_fill) },
692 3 => { read_bap!(br, TS102366_QUANT7_MAP, 3) },
693 4 => { read_bap!(br, TS102366_QUANT11_MAP, 7, 2, bap_buf, bap_buf_fill) },
694 5 => { read_bap!(br, TS102366_QUANT15_MAP, 4) },
695 _ => {
696 validate!(self.bap[bin] < 15);
697 let nbits = TS102366_BAP_BITS[(self.bap[bin] as usize) - 6];
698 let val = br.read(nbits)? as i16;
699 ((val << (16 - nbits)) as i32) << 9
700 },
701 };
702 self.mant[bin] >>= self.exps[bin];
703 }
704 Ok(())
705 }
706
707 fn synth(&mut self, imdct512: &mut IMDCTContext, imdct256: &mut IMDCTContext, tmp: &mut IMDCTWorkspace, delay: &mut [f32; BLOCK_LEN], dst: &mut [f32]) {
708 if !self.blksw {
709 imdct512.do_imdct(&self.mant, tmp);
710 } else {
711 imdct256.do_imdct_ileave(&self.mant, tmp);
712 }
713 overlap(delay, &tmp.out, dst);
714 }
715}
716
717fn logadd(acc: i32, add: i32) -> i32 {
718 let c = acc - add;
719 let addr = (c.abs() >> 1).min(255);
720 if c >= 0 {
721 acc + (TS102366_LATAB[addr as usize] as i32)
722 } else {
723 add + (TS102366_LATAB[addr as usize] as i32)
724 }
725}
726
727fn calc_lowcomp(a: i32, b0: i32, b1: i32, band: usize) -> i32 {
728 if band < 7 {
729 if (b0 + 256) == b1 {
730 384
731 } else if b0 > b1 {
732 0.max(a - 64)
733 } else {
734 a
735 }
736 } else if band < 20 {
737 if (b0 + 256) == b1 {
738 320
739 } else if b0 > b1 {
740 0.max(a - 64)
741 } else {
742 a
743 }
744 } else {
745 0.max(a - 128)
746 }
747}
748
749fn overlap(delay: &mut [f32; BLOCK_LEN], src: &[f32; BLOCK_LEN * 2], out: &mut [f32]) {
750 {
751 let dly = &delay;
752 for ((d, s), o) in dly.into_iter().zip(src.into_iter()).zip(out.iter_mut()) {
753 *o = (*d + *s) * 2.0;
754 }
755 }
756 delay.copy_from_slice(&src[BLOCK_LEN..]);
757}
758
759#[derive(Clone)]
760struct AudioBlock {
761 dynrng: Option<u8>,
762 dynrng2: Option<u8>,
763
764 cplstre: bool,
765 cplinu: bool,
766 phsflginu: bool,
767 cplbegf: usize,
768 cplendf: usize,
769 ncplsubnd: usize,
770 ncplbnd: usize,
771 cplbndstrc: [bool; MAX_CPLBANDS],
772
773 phsflg: [bool; MAX_CPLBANDS],
774 rematstr: bool,
775 rematflg: [bool; 4],
776
777 chdata: [ChannelData; MAX_CHANNELS + 2],
778
779 baie: bool,
780 fdcycod: usize,
781 sdcycod: usize,
782 sgaincod: usize,
783 dbpbcod: usize,
784 floorcod: usize,
785 snroffste: bool,
786 csnroffst: u8,
787 cplleake: bool,
788 cplfleak: u8,
789 cplsleak: u8,
790
791 deltbaie: bool,
792
793 bap_buf: [[i32; 2]; 3],
794 bap_buf_fill: [usize; 3],
795}
796
797impl AudioBlock {
798 fn new() -> Self {
799 AudioBlock {
800 chdata: [ChannelData::new(); MAX_CHANNELS + 2],
801
802 dynrng: None,
803 dynrng2: None,
804
805 cplstre: false,
806 cplinu: false,
807 phsflginu: false,
808 cplbegf: 0,
809 cplendf: 0,
810 ncplsubnd: 0,
811 ncplbnd: 0,
812 cplbndstrc: [false; MAX_CPLBANDS],
813
814 phsflg: [false; MAX_CPLBANDS],
815 rematstr: false,
816 rematflg: [false; 4],
817
818 baie: false,
819 sdcycod: 0,
820 fdcycod: 0,
821 sgaincod: 0,
822 dbpbcod: 0,
823 floorcod: 0,
824 snroffste: false,
825 csnroffst: 0,
826 cplleake: false,
827 cplfleak: 0,
828 cplsleak: 0,
829
830 deltbaie: false,
831
832 bap_buf: [[0; 2]; 3],
833 bap_buf_fill: [0; 3],
834 }
835 }
836 fn read(&mut self, br: &mut BitReader, bsi: &BSI, fscod: usize, blk_no: usize) -> DecoderResult<bool> {
837 let channels = bsi.acmod.get_num_channels();
838 let is_stereo = bsi.acmod == ACMode::Stereo;
839
840 for ch in 0..channels {
841 self.chdata[ch].blksw = br.read_bool()?;
842 }
843 // dynamic range information
844 for ch in 0..channels {
845 self.chdata[ch].dithflag = br.read_bool()?;
846 }
847 self.dynrng = br.read_optional8()?;
848 if bsi.acmod == ACMode::DualMono {
849 self.dynrng2 = br.read_optional8()?;
850 }
851 // coupling strategy information
852 self.cplstre = br.read_bool()?;
853 validate!((blk_no != 0) || self.cplstre);
854 if self.cplstre {
855 self.cplinu = br.read_bool()?;
856 if self.cplinu {
857 for ch in 0..channels {
858 self.chdata[ch].chincpl = br.read_bool()?;
859 }
860 if is_stereo {
861 self.phsflginu = br.read_bool()?;
862 }
863 self.cplbegf = br.read(4)? as usize;
864 self.cplendf = (br.read(4)? as usize) + 3;
865 validate!(self.cplendf >= self.cplbegf);
866 self.ncplsubnd = self.cplendf - self.cplbegf;
867 self.ncplbnd = self.ncplsubnd;
868 self.chdata[CPL_CHANNEL].startmant = self.cplbegf * 12 + 37;
869 self.chdata[CPL_CHANNEL].endmant = self.cplendf * 12 + 37;
870 for bnd in 1..self.ncplsubnd {
871 self.cplbndstrc[bnd] = br.read_bool()?;
872 if self.cplbndstrc[bnd] {
873 self.ncplbnd -= 1;
874 }
875 }
876 }
877 }
878 // coupling coordinates
879 if self.cplinu {
880 for c in 0..channels {
881 let ch = &mut self.chdata[c];
882 if ch.chincpl {
883 ch.cplcoe = br.read_bool()?;
884 if ch.cplcoe {
885 ch.mstrcplco = br.read(2)? as u8;
886 for bnd in 0..self.ncplbnd {
887 ch.cplcoexp [bnd] = br.read(4)? as u8;
888 ch.cplcomant[bnd] = br.read(4)? as u8;
889 }
890 }
891 }
892 }
893 if is_stereo && self.phsflginu && (self.chdata[0].cplcoe || self.chdata[1].cplcoe) {
894 for bnd in 0..self.ncplbnd {
895 self.phsflg[bnd] = br.read_bool()?;
896 }
897 }
898 }
899 // stereo rematrixing
900 if is_stereo {
901 self.rematstr = br.read_bool()?;
902 if self.rematstr {
903 if self.cplbegf > 2 || !self.cplinu {
904 for rbnd in 0..4 {
905 self.rematflg[rbnd] = br.read_bool()?;
906 }
907 }
908 if self.cplbegf > 0 && self.cplbegf <= 2 && self.cplinu {
909 for rbnd in 0..3 {
910 self.rematflg[rbnd] = br.read_bool()?;
911 }
912 }
913 if self.cplbegf == 0 && self.cplinu {
914 for rbnd in 0..2 {
915 self.rematflg[rbnd] = br.read_bool()?;
916 }
917 }
918 }
919 }
920 // exponent strategy
921 if self.cplinu {
922 self.chdata[CPL_CHANNEL].read_strategy(br, blk_no)?;
923 }
924 for ch in 0..channels {
925 self.chdata[ch].read_strategy(br, blk_no)?;
926 }
927 if bsi.lfeon {
928 self.chdata[LFE_CHANNEL].expstr = br.read(1)? as u8;
929 validate!(blk_no != 0 || self.chdata[LFE_CHANNEL].expstr != STRATEGY_REUSE);
930 self.chdata[LFE_CHANNEL].groups = 2;
931 self.chdata[LFE_CHANNEL].startmant = 0;
932 self.chdata[LFE_CHANNEL].endmant = 7;
933 }
934 let cpl_startmant = self.chdata[CPL_CHANNEL].startmant;
935 for c in 0..channels {
936 let ch = &mut self.chdata[c];
937 if ch.expstr != STRATEGY_REUSE && !ch.chincpl {
938 ch.chbwcod = br.read(6)? as u8;
939 }
940 if !ch.chincpl {
941 ch.startmant = 0;
942 ch.endmant = ((ch.chbwcod as usize) + 12) * 3 + 37;
943 } else {
944 ch.startmant = 0;
945 ch.endmant = cpl_startmant;
946 }
947 }
948 // set number of mantissas
949 if self.cplinu {
950 self.chdata[CPL_CHANNEL].read_exps(br, true, false)?;
951 }
952 for ch in 0..channels {
953 self.chdata[ch].read_exps(br, false, false)?;
954 }
955 if bsi.lfeon {
956 self.chdata[LFE_CHANNEL].read_exps(br, false, true)?;
957 }
958 // bit allocation parameters
959 self.baie = br.read_bool()?;
960 if self.baie {
961 self.sdcycod = br.read(2)? as usize;
962 self.fdcycod = br.read(2)? as usize;
963 self.sgaincod = br.read(2)? as usize;
964 self.dbpbcod = br.read(2)? as usize;
965 self.floorcod = br.read(3)? as usize;
966 }
967 self.snroffste = br.read_bool()?;
968 if self.snroffste {
969 self.csnroffst = br.read(6)? as u8;
970 if self.cplinu {
971 self.chdata[CPL_CHANNEL].read_snr(br)?;
972 }
973 for ch in 0..channels {
974 self.chdata[ch].read_snr(br)?;
975 }
976 if bsi.lfeon {
977 self.chdata[LFE_CHANNEL].read_snr(br)?;
978 }
979 }
980 if self.cplinu {
981 self.cplleake = br.read_bool()?;
982 if self.cplleake {
983 self.cplfleak = br.read(3)? as u8;
984 self.cplsleak = br.read(3)? as u8;
985 }
986 }
987 // delta bit allocation information
988 self.deltbaie = br.read_bool()?;
989 if self.deltbaie {
990 if self.cplinu {
991 self.chdata[CPL_CHANNEL].deltbae = br.read(2)? as u8;
992 validate!(blk_no != 0 || self.chdata[CPL_CHANNEL].deltbae != 0);
993 validate!(self.chdata[CPL_CHANNEL].deltbae != 3);
994 }
995 for ch in 0..channels {
996 self.chdata[ch].deltbae = br.read(2)? as u8;
997 validate!(blk_no != 0 || self.chdata[ch].deltbae != 0);
998 validate!(self.chdata[ch].deltbae != 3);
999 }
1000 if self.cplinu {
1001 self.chdata[CPL_CHANNEL].read_deltbai(br)?;
1002 }
1003 for ch in 0..channels {
1004 self.chdata[ch].read_deltbai(br)?;
1005 }
1006 }
1007 // dummy data
1008 if br.read_bool()? {
1009 let skipl = br.read(9)?;
1010 br.skip(skipl * 8)?;
1011 }
1012
1013 let all_zero = self.calc_bitalloc(bsi, channels, fscod);
1014 if all_zero { return Ok(true); }
1015
1016 // quantised mantissa values
1017 let mut got_cplchan = false;
1018 for i in 0..self.bap_buf_fill.len() { self.bap_buf_fill[i] = 0; }
1019 for c in 0..channels {
1020 {
1021 let ch = &mut self.chdata[c];
1022 ch.read_mant(br, &mut self.bap_buf, &mut self.bap_buf_fill)?;
1023 }
1024 if self.cplinu && self.chdata[c].chincpl && !got_cplchan {
1025 let cplch = &mut self.chdata[CPL_CHANNEL];
1026 cplch.read_mant(br, &mut self.bap_buf, &mut self.bap_buf_fill)?;
1027 got_cplchan = true;
1028 }
1029 }
1030 if bsi.lfeon {
1031 let lfech = &mut self.chdata[LFE_CHANNEL];
1032 lfech.read_mant(br, &mut self.bap_buf, &mut self.bap_buf_fill)?;
1033 }
1034 Ok(false)
1035 }
1036 fn calc_bitalloc(&mut self, bsi: &BSI, channels: usize, fscod: usize) -> bool {
1037 let sdecay1 = TS102366_SLOW_DECAY[self.sdcycod];
1038 let fdecay1 = TS102366_FAST_DECAY[self.fdcycod];
1039
1040 let sdecay = sdecay1 >> bsi.shift;
1041 let fdecay = fdecay1 >> bsi.shift;
1042 let sgain = TS102366_SLOW_GAIN[self.sgaincod];
1043 let dbknee = TS102366_DBP_TAB[self.dbpbcod];
1044 let floor = TS102366_FLOOR_TAB[self.floorcod];
1045
1046 let mut all_zero = self.csnroffst == 0;
1047 if !all_zero && self.chdata[LFE_CHANNEL].fsnroffst == 0 {
1048 for ch in 0..channels {
1049 if self.chdata[ch].fsnroffst != 0 {
1050 all_zero = false;
1051 break;
1052 }
1053 }
1054 }
1055 if all_zero { return true; }
1056
1057 let mut mask: [i32; MAX_BANDS] = [0; MAX_BANDS];
1058
1059 if self.cplinu {
1060 self.chdata[CPL_CHANNEL].compute_bndpsd();
1061 self.chdata[CPL_CHANNEL].compute_mask(&mut mask, fscod, sgain, fdecay, sdecay, dbknee,
1062 ((self.cplfleak as u16) << 8) + 768, ((self.cplsleak as u16) << 8) + 768, bsi.shift);
1063 self.chdata[CPL_CHANNEL].apply_delta_info(&mut mask);
1064 self.chdata[CPL_CHANNEL].calc_snr_offset(self.csnroffst);
1065 self.chdata[CPL_CHANNEL].compute_bap(&mut mask, floor);
1066 }
1067 for ch in 0..channels {
1068 self.chdata[ch].compute_bndpsd();
1069 self.chdata[ch].compute_mask(&mut mask, fscod, sgain, fdecay, sdecay, dbknee, 0, 0, bsi.shift);
1070 self.chdata[ch].apply_delta_info(&mut mask);
1071 self.chdata[ch].calc_snr_offset(self.csnroffst);
1072 self.chdata[ch].compute_bap(&mut mask, floor);
1073 }
1074 if bsi.lfeon {
1075 self.chdata[LFE_CHANNEL].compute_bndpsd();
1076 self.chdata[LFE_CHANNEL].compute_mask(&mut mask, fscod, sgain, fdecay, sdecay, dbknee,
1077 0, 0, bsi.shift);
1078 self.chdata[LFE_CHANNEL].calc_snr_offset(self.csnroffst);
1079 self.chdata[LFE_CHANNEL].compute_bap(&mut mask, floor);
1080 }
1081
1082 false
1083 }
1084 fn couple_channels(&mut self, acmod: ACMode) {
1085 if !self.cplinu { return; }
1086 for ch in 0..acmod.get_num_channels() {
1087 if !self.chdata[ch].chincpl { continue; }
1088 let mut pband = 0;
1089 for band in self.cplbegf..self.cplendf {
1090 let cband = band - self.cplbegf;
1091 let comant = self.chdata[ch].cplcomant[cband];
1092 let mut cotemp = (if self.chdata[ch].cplcoexp[cband] == 15 { comant << 1 } else { comant + 16 }) as i32;
1093 if (acmod == ACMode::Stereo) && (ch == 1) && self.phsflginu && self.phsflg[pband] {
1094 cotemp = -cotemp;
1095 }
1096 if !self.cplbndstrc[cband] {
1097 pband += 1;
1098 }
1099 let exp = self.chdata[ch].cplcoexp[cband] + 3 * self.chdata[ch].mstrcplco + 5 - 3;
1100 let start = band * 12 + 37;
1101 for bin in 0..12 {
1102 self.chdata[ch].mant[start + bin] = self.chdata[CPL_CHANNEL].mant[start + bin] * cotemp >> exp;
1103 }
1104//todo dither
1105 }
1106 }
1107 }
1108 fn synth_audio_block(&mut self, imdct512: &mut IMDCTContext, imdct256: &mut IMDCTContext, tmp: &mut IMDCTWorkspace, channel: usize, delay: &mut [f32; BLOCK_LEN], dst: &mut [f32]) {
1109 self.chdata[channel].synth(imdct512, imdct256, tmp, delay, dst);
1110 }
1111}
1112
1113impl NADecoder for AudioDecoder {
1114 fn init(&mut self, info: Rc<NACodecInfo>) -> DecoderResult<()> {
1115 if let NACodecTypeInfo::Audio(_) = info.get_properties() {
1116 self.info = info.clone();
1117 Ok(())
1118 } else {
1119 Err(DecoderError::InvalidData)
1120 }
1121 }
1122 fn decode(&mut self, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
1123 let info = pkt.get_stream().get_info();
1124 validate!(info.get_properties().is_audio());
1125 let pktbuf = pkt.get_buffer();
1126 validate!(pktbuf.len() > 5);
1127
1128 let mut br;
1129 if (pktbuf[0] == MAGIC_BYTE0) && (pktbuf[1] == MAGIC_BYTE1) {
1130 br = BitReader::new(pktbuf.as_slice(), pktbuf.len(), BitReaderMode::BE);
1131 } else if (pktbuf[0] == MAGIC_BYTE1) && (pktbuf[1] == MAGIC_BYTE0) {
1132 br = BitReader::new(pktbuf.as_slice(), pktbuf.len(), BitReaderMode::LE16MSB);
1133 } else {
1134 return Err(DecoderError::InvalidData);
1135 }
1136
1137 let sinfo = Syncinfo::read(&mut br)?;
1138 validate!(sinfo.is_valid());
1139
1140 let bsi = BSI::read(&mut br)?;
1141 if bsi.has_addb {
1142 let len = br.read(6)? as u32;
1143 br.skip((len + 1) * 8)?;
1144 }
1145
1146 let duration = BLOCK_LEN * NBLOCKS;
1147
1148 let core_channels = bsi.acmod.get_num_channels();
1149 let channels = core_channels + if bsi.lfeon { 1 } else { 0 };
1150
1151 let ainfo = NAAudioInfo::new(sinfo.samplerate >> bsi.shift, channels as u8,
1152 SND_F32P_FORMAT, BLOCK_LEN);
1153
1154 let mut abuf = alloc_audio_buffer(ainfo, duration, bsi.acmod.get_channel_map(bsi.lfeon))?;
1155 let mut adata = abuf.get_abuf_f32().unwrap();
1156 let mut output = adata.get_data_mut();
1157
1158 self.ablk = AudioBlock::new();
1159 for blk in 0..NBLOCKS {
1160 let all_zero = self.ablk.read(&mut br, &bsi, sinfo.fscod as usize, blk)?;
1161 let off = blk * BLOCK_LEN;
1162 self.ablk.couple_channels(bsi.acmod);
1163 for ch in 0..core_channels {
1164 let dpos = abuf.get_offset(ch) + off;
1165 let dst = &mut output[dpos..][..BLOCK_LEN];
1166 if !all_zero {
1167 self.ablk.synth_audio_block(&mut self.imdct512, &mut self.imdct256, &mut self.tmp, ch, &mut self.delay[ch], dst);
1168 } else {
1169 self.delay[ch] = [0.0; BLOCK_LEN];
1170 for i in 0..BLOCK_LEN { dst[i] = 0.0; }
1171 }
1172 }
1173 if bsi.lfeon {
1174 let dpos = abuf.get_offset(core_channels) + off;
1175 let dst = &mut output[dpos..][..BLOCK_LEN];
1176 if !all_zero {
1177 self.ablk.synth_audio_block(&mut self.imdct512, &mut self.imdct256, &mut self.tmp, LFE_CHANNEL, &mut self.delay[LFE_CHANNEL], dst);
1178 } else {
1179 self.delay[LFE_CHANNEL] = [0.0; BLOCK_LEN];
1180 for i in 0..BLOCK_LEN { dst[i] = 0.0; }
1181 }
1182 }
1183 }
1184//todo skip auxdata
1185//todo do errorcheck
1186
1187 let mut frm = NAFrame::new_from_pkt(pkt, self.info.replace_info(NACodecTypeInfo::Audio(ainfo)), abuf);
1188 frm.set_keyframe(true);
1189 Ok(Rc::new(RefCell::new(frm)))
1190 }
1191}
1192
1193pub fn get_decoder() -> Box<NADecoder> {
1194 Box::new(AudioDecoder::new())
1195}
1196
1197#[cfg(test)]
1198mod test {
1199 use test::dec_video::*;
1200 #[test]
1201 fn test_ts102366() {
1202 let file = "assets/RV/sp_sample1.rm";
1203 test_decode_audio("realmedia", file, Some(12000), "ac3");
1204 }
1205}
1206
1207const TS102366_SLOW_DECAY: [u8; 4] = [ 0x0F, 0x11, 0x13, 0x15 ];
1208const TS102366_FAST_DECAY: [u8; 4] = [ 0x3F, 0x53, 0x67, 0x7B ];
1209const TS102366_SLOW_GAIN: [u16; 4] = [ 0x540, 0x4D8, 0x478, 0x410 ];
1210const TS102366_FAST_GAIN: [u16; 8] = [ 0x080, 0x100, 0x180, 0x200, 0x280, 0x300, 0x380, 0x400 ];
1211const TS102366_DBP_TAB: [u16; 4] = [ 0x000, 0x700, 0x900, 0xB00 ];
1212const TS102366_FLOOR_TAB: [u16; 8] = [ 0x02F0, 0x02B0, 0x0270, 0x0230, 0x01F0, 0x0170, 0x00F0, 0xF800 ];
1213
1214const TS102366_BIN_TO_BAND: [u8; 256] = [
1215 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
1216 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
1217 20, 21, 22, 23, 24, 25, 26, 27, 28, 28,
1218 28, 29, 29, 29, 30, 30, 30, 31, 31, 31,
1219 32, 32, 32, 33, 33, 33, 34, 34, 34, 35,
1220 35, 35, 35, 35, 35, 36, 36, 36, 36, 36,
1221 36, 37, 37, 37, 37, 37, 37, 38, 38, 38,
1222 38, 38, 38, 39, 39, 39, 39, 39, 39, 40,
1223 40, 40, 40, 40, 40, 41, 41, 41, 41, 41,
1224 41, 41, 41, 41, 41, 41, 41, 42, 42, 42,
1225 42, 42, 42, 42, 42, 42, 42, 42, 42, 43,
1226 43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
1227 43, 44, 44, 44, 44, 44, 44, 44, 44, 44,
1228 44, 44, 44, 45, 45, 45, 45, 45, 45, 45,
1229 45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
1230 45, 45, 45, 45, 45, 45, 45, 46, 46, 46,
1231 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
1232 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
1233 46, 47, 47, 47, 47, 47, 47, 47, 47, 47,
1234 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
1235 47, 47, 47, 47, 47, 48, 48, 48, 48, 48,
1236 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
1237 48, 48, 48, 48, 48, 48, 48, 48, 48, 49,
1238 49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
1239 49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
1240 49, 49, 49, 0, 0, 0
1241];
1242const TS102366_BAND_SIZE: [u8; MAX_BANDS] = [
1243 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1244 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1245 1, 1, 1, 1, 1, 1, 1, 1, 3, 3,
1246 3, 3, 3, 3, 3, 6, 6, 6, 6, 6,
1247 6, 12, 12, 12, 12, 24, 24, 24, 24, 24
1248];
1249const TS102366_BAND_START: [u8; MAX_BANDS] = [
1250 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
1251 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
1252 20, 21, 22, 23, 24, 25, 26, 27, 28, 31,
1253 34, 37, 40, 43, 46, 49, 55, 61, 67, 73,
1254 79, 85, 97, 109, 121, 133, 157, 181, 205, 229
1255];
1256
1257const TS102366_LATAB: [u16; 256] = [
1258 0x0040, 0x003f, 0x003e, 0x003d, 0x003c, 0x003b, 0x003a, 0x0039,
1259 0x0038, 0x0037, 0x0036, 0x0035, 0x0034, 0x0034, 0x0033, 0x0032,
1260 0x0031, 0x0030, 0x002f, 0x002f, 0x002e, 0x002d, 0x002c, 0x002c,
1261 0x002b, 0x002a, 0x0029, 0x0029, 0x0028, 0x0027, 0x0026, 0x0026,
1262 0x0025, 0x0024, 0x0024, 0x0023, 0x0023, 0x0022, 0x0021, 0x0021,
1263 0x0020, 0x0020, 0x001f, 0x001e, 0x001e, 0x001d, 0x001d, 0x001c,
1264 0x001c, 0x001b, 0x001b, 0x001a, 0x001a, 0x0019, 0x0019, 0x0018,
1265 0x0018, 0x0017, 0x0017, 0x0016, 0x0016, 0x0015, 0x0015, 0x0015,
1266 0x0014, 0x0014, 0x0013, 0x0013, 0x0013, 0x0012, 0x0012, 0x0012,
1267 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0010, 0x000f, 0x000f,
1268 0x000f, 0x000e, 0x000e, 0x000e, 0x000d, 0x000d, 0x000d, 0x000d,
1269 0x000c, 0x000c, 0x000c, 0x000c, 0x000b, 0x000b, 0x000b, 0x000b,
1270 0x000a, 0x000a, 0x000a, 0x000a, 0x000a, 0x0009, 0x0009, 0x0009,
1271 0x0009, 0x0009, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008,
1272 0x0007, 0x0007, 0x0007, 0x0007, 0x0007, 0x0007, 0x0006, 0x0006,
1273 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0005, 0x0005,
1274 0x0005, 0x0005, 0x0005, 0x0005, 0x0005, 0x0005, 0x0004, 0x0004,
1275 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004,
1276 0x0004, 0x0003, 0x0003, 0x0003, 0x0003, 0x0003, 0x0003, 0x0003,
1277 0x0003, 0x0003, 0x0003, 0x0003, 0x0003, 0x0003, 0x0003, 0x0002,
1278 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002,
1279 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002,
1280 0x0002, 0x0002, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001,
1281 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001,
1282 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001,
1283 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001,
1284 0x0001, 0x0001, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
1285 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
1286 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
1287 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
1288 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
1289 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000
1290];
1291const TS102366_HTH: [[u16; MAX_BANDS]; 3] = [
1292 [
1293 0x04D0, 0x04D0, 0x0440, 0x0400, 0x03E0, 0x03C0, 0x03B0, 0x03B0, 0x03A0, 0x03A0,
1294 0x03A0, 0x03A0, 0x03A0, 0x0390, 0x0390, 0x0390, 0x0380, 0x0380, 0x0370, 0x0370,
1295 0x0360, 0x0360, 0x0350, 0x0350, 0x0340, 0x0340, 0x0330, 0x0320, 0x0310, 0x0300,
1296 0x02F0, 0x02F0, 0x02F0, 0x02F0, 0x0300, 0x0310, 0x0340, 0x0390, 0x03E0, 0x0420,
1297 0x0460, 0x0490, 0x04A0, 0x0460, 0x0440, 0x0440, 0x0520, 0x0800, 0x0840, 0x0840,
1298 ], [
1299 0x04F0, 0x04F0, 0x0460, 0x0410, 0x03E0, 0x03D0, 0x03C0, 0x03B0, 0x03B0, 0x03A0,
1300 0x03A0, 0x03A0, 0x03A0, 0x03A0, 0x0390, 0x0390, 0x0390, 0x0380, 0x0380, 0x0380,
1301 0x0370, 0x0370, 0x0360, 0x0360, 0x0350, 0x0350, 0x0340, 0x0340, 0x0320, 0x0310,
1302 0x0300, 0x02F0, 0x02F0, 0x02F0, 0x02F0, 0x0300, 0x0320, 0x0350, 0x0390, 0x03E0,
1303 0x0420, 0x0450, 0x04A0, 0x0490, 0x0460, 0x0440, 0x0480, 0x0630, 0x0840, 0x0840,
1304 ], [
1305 0x0580, 0x0580, 0x04B0, 0x0450, 0x0420, 0x03F0, 0x03E0, 0x03D0, 0x03C0, 0x03B0,
1306 0x03B0, 0x03B0, 0x03A0, 0x03A0, 0x03A0, 0x03A0, 0x03A0, 0x03A0, 0x03A0, 0x03A0,
1307 0x0390, 0x0390, 0x0390, 0x0390, 0x0380, 0x0380, 0x0380, 0x0370, 0x0360, 0x0350,
1308 0x0340, 0x0330, 0x0320, 0x0310, 0x0300, 0x02F0, 0x02F0, 0x02F0, 0x0300, 0x0310,
1309 0x0330, 0x0350, 0x03C0, 0x0410, 0x0470, 0x04A0, 0x0460, 0x0440, 0x0450, 0x04E0,
1310 ]
1311];
1312const TS102366_BAPTAB: [u8; 64] = [
1313 0, 1, 1, 1, 1, 1, 2, 2, 3, 3, 3, 4, 4, 5, 5, 6,
1314 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 8, 9, 9, 9, 9, 10,
1315 10, 10, 10, 11, 11, 11, 11, 12, 12, 12, 12, 13, 13, 13, 13, 14,
1316 14, 14, 14, 14, 14, 14, 14, 15, 15, 15, 15, 15, 15, 15, 15, 15
1317];
1318
1319const TS102366_QUANT3_MAP: [[i32; 3]; 27] = [
1320 [ -0x0AAAAAA, -0x0AAAAAA, -0x0AAAAAA ],
1321 [ -0x0AAAAAA, -0x0AAAAAA, 0x00000000 ],
1322 [ -0x0AAAAAA, -0x0AAAAAA, 0x00AAAAAA ],
1323 [ -0x0AAAAAA, 0x00000000, -0x0AAAAAA ],
1324 [ -0x0AAAAAA, 0x00000000, 0x00000000 ],
1325 [ -0x0AAAAAA, 0x00000000, 0x00AAAAAA ],
1326 [ -0x0AAAAAA, 0x00AAAAAA, -0x0AAAAAA ],
1327 [ -0x0AAAAAA, 0x00AAAAAA, 0x00000000 ],
1328 [ -0x0AAAAAA, 0x00AAAAAA, 0x00AAAAAA ],
1329 [ 0x00000000, -0x0AAAAAA, -0x0AAAAAA ],
1330 [ 0x00000000, -0x0AAAAAA, 0x00000000 ],
1331 [ 0x00000000, -0x0AAAAAA, 0x00AAAAAA ],
1332 [ 0x00000000, 0x00000000, -0x0AAAAAA ],
1333 [ 0x00000000, 0x00000000, 0x00000000 ],
1334 [ 0x00000000, 0x00000000, 0x00AAAAAA ],
1335 [ 0x00000000, 0x00AAAAAA, -0x0AAAAAA ],
1336 [ 0x00000000, 0x00AAAAAA, 0x00000000 ],
1337 [ 0x00000000, 0x00AAAAAA, 0x00AAAAAA ],
1338 [ 0x00AAAAAA, -0x0AAAAAA, -0x0AAAAAA ],
1339 [ 0x00AAAAAA, -0x0AAAAAA, 0x00000000 ],
1340 [ 0x00AAAAAA, -0x0AAAAAA, 0x00AAAAAA ],
1341 [ 0x00AAAAAA, 0x00000000, -0x0AAAAAA ],
1342 [ 0x00AAAAAA, 0x00000000, 0x00000000 ],
1343 [ 0x00AAAAAA, 0x00000000, 0x00AAAAAA ],
1344 [ 0x00AAAAAA, 0x00AAAAAA, -0x0AAAAAA ],
1345 [ 0x00AAAAAA, 0x00AAAAAA, 0x00000000 ],
1346 [ 0x00AAAAAA, 0x00AAAAAA, 0x00AAAAAA ]
1347];
1348const TS102366_QUANT5_MAP: [[i32; 3]; 125] = [
1349 [ -0x0CCCCCC, -0x0CCCCCC, -0x0CCCCCC ], [ -0x0CCCCCC, -0x0CCCCCC, -0x0666666 ], [ -0x0CCCCCC, -0x0CCCCCC, 0x00000000 ],
1350 [ -0x0CCCCCC, -0x0CCCCCC, 0x00666666 ], [ -0x0CCCCCC, -0x0CCCCCC, 0x00CCCCCC ],
1351 [ -0x0CCCCCC, -0x0666666, -0x0CCCCCC ], [ -0x0CCCCCC, -0x0666666, -0x0666666 ], [ -0x0CCCCCC, -0x0666666, 0x00000000 ],
1352 [ -0x0CCCCCC, -0x0666666, 0x00666666 ], [ -0x0CCCCCC, -0x0666666, 0x00CCCCCC ],
1353 [ -0x0CCCCCC, 0x00000000, -0x0CCCCCC ], [ -0x0CCCCCC, 0x00000000, -0x0666666 ], [ -0x0CCCCCC, 0x00000000, 0x00000000 ],
1354 [ -0x0CCCCCC, 0x00000000, 0x00666666 ], [ -0x0CCCCCC, 0x00000000, 0x00CCCCCC ],
1355 [ -0x0CCCCCC, 0x00666666, -0x0CCCCCC ], [ -0x0CCCCCC, 0x00666666, -0x0666666 ], [ -0x0CCCCCC, 0x00666666, 0x00000000 ],
1356 [ -0x0CCCCCC, 0x00666666, 0x00666666 ], [ -0x0CCCCCC, 0x00666666, 0x00CCCCCC ],
1357 [ -0x0CCCCCC, 0x00CCCCCC, -0x0CCCCCC ], [ -0x0CCCCCC, 0x00CCCCCC, -0x0666666 ], [ -0x0CCCCCC, 0x00CCCCCC, 0x00000000 ],
1358 [ -0x0CCCCCC, 0x00CCCCCC, 0x00666666 ], [ -0x0CCCCCC, 0x00CCCCCC, 0x00CCCCCC ],
1359 [ -0x0666666, -0x0CCCCCC, -0x0CCCCCC ], [ -0x0666666, -0x0CCCCCC, -0x0666666 ], [ -0x0666666, -0x0CCCCCC, 0x00000000 ],
1360 [ -0x0666666, -0x0CCCCCC, 0x00666666 ], [ -0x0666666, -0x0CCCCCC, 0x00CCCCCC ],
1361 [ -0x0666666, -0x0666666, -0x0CCCCCC ], [ -0x0666666, -0x0666666, -0x0666666 ], [ -0x0666666, -0x0666666, 0x00000000 ],
1362 [ -0x0666666, -0x0666666, 0x00666666 ], [ -0x0666666, -0x0666666, 0x00CCCCCC ],
1363 [ -0x0666666, 0x00000000, -0x0CCCCCC ], [ -0x0666666, 0x00000000, -0x0666666 ], [ -0x0666666, 0x00000000, 0x00000000 ],
1364 [ -0x0666666, 0x00000000, 0x00666666 ], [ -0x0666666, 0x00000000, 0x00CCCCCC ],
1365 [ -0x0666666, 0x00666666, -0x0CCCCCC ], [ -0x0666666, 0x00666666, -0x0666666 ], [ -0x0666666, 0x00666666, 0x00000000 ],
1366 [ -0x0666666, 0x00666666, 0x00666666 ], [ -0x0666666, 0x00666666, 0x00CCCCCC ],
1367 [ -0x0666666, 0x00CCCCCC, -0x0CCCCCC ], [ -0x0666666, 0x00CCCCCC, -0x0666666 ], [ -0x0666666, 0x00CCCCCC, 0x00000000 ],
1368 [ -0x0666666, 0x00CCCCCC, 0x00666666 ], [ -0x0666666, 0x00CCCCCC, 0x00CCCCCC ],
1369 [ 0x00000000, -0x0CCCCCC, -0x0CCCCCC ], [ 0x00000000, -0x0CCCCCC, -0x0666666 ], [ 0x00000000, -0x0CCCCCC, 0x00000000 ],
1370 [ 0x00000000, -0x0CCCCCC, 0x00666666 ], [ 0x00000000, -0x0CCCCCC, 0x00CCCCCC ],
1371 [ 0x00000000, -0x0666666, -0x0CCCCCC ], [ 0x00000000, -0x0666666, -0x0666666 ], [ 0x00000000, -0x0666666, 0x00000000 ],
1372 [ 0x00000000, -0x0666666, 0x00666666 ], [ 0x00000000, -0x0666666, 0x00CCCCCC ],
1373 [ 0x00000000, 0x00000000, -0x0CCCCCC ], [ 0x00000000, 0x00000000, -0x0666666 ], [ 0x00000000, 0x00000000, 0x00000000 ],
1374 [ 0x00000000, 0x00000000, 0x00666666 ], [ 0x00000000, 0x00000000, 0x00CCCCCC ],
1375 [ 0x00000000, 0x00666666, -0x0CCCCCC ], [ 0x00000000, 0x00666666, -0x0666666 ], [ 0x00000000, 0x00666666, 0x00000000 ],
1376 [ 0x00000000, 0x00666666, 0x00666666 ], [ 0x00000000, 0x00666666, 0x00CCCCCC ],
1377 [ 0x00000000, 0x00CCCCCC, -0x0CCCCCC ], [ 0x00000000, 0x00CCCCCC, -0x0666666 ], [ 0x00000000, 0x00CCCCCC, 0x00000000 ],
1378 [ 0x00000000, 0x00CCCCCC, 0x00666666 ], [ 0x00000000, 0x00CCCCCC, 0x00CCCCCC ],
1379 [ 0x00666666, -0x0CCCCCC, -0x0CCCCCC ], [ 0x00666666, -0x0CCCCCC, -0x0666666 ], [ 0x00666666, -0x0CCCCCC, 0x00000000 ],
1380 [ 0x00666666, -0x0CCCCCC, 0x00666666 ], [ 0x00666666, -0x0CCCCCC, 0x00CCCCCC ],
1381 [ 0x00666666, -0x0666666, -0x0CCCCCC ], [ 0x00666666, -0x0666666, -0x0666666 ], [ 0x00666666, -0x0666666, 0x00000000 ],
1382 [ 0x00666666, -0x0666666, 0x00666666 ], [ 0x00666666, -0x0666666, 0x00CCCCCC ],
1383 [ 0x00666666, 0x00000000, -0x0CCCCCC ], [ 0x00666666, 0x00000000, -0x0666666 ], [ 0x00666666, 0x00000000, 0x00000000 ],
1384 [ 0x00666666, 0x00000000, 0x00666666 ], [ 0x00666666, 0x00000000, 0x00CCCCCC ],
1385 [ 0x00666666, 0x00666666, -0x0CCCCCC ], [ 0x00666666, 0x00666666, -0x0666666 ], [ 0x00666666, 0x00666666, 0x00000000 ],
1386 [ 0x00666666, 0x00666666, 0x00666666 ], [ 0x00666666, 0x00666666, 0x00CCCCCC ],
1387 [ 0x00666666, 0x00CCCCCC, -0x0CCCCCC ], [ 0x00666666, 0x00CCCCCC, -0x0666666 ], [ 0x00666666, 0x00CCCCCC, 0x00000000 ],
1388 [ 0x00666666, 0x00CCCCCC, 0x00666666 ], [ 0x00666666, 0x00CCCCCC, 0x00CCCCCC ],
1389 [ 0x00CCCCCC, -0x0CCCCCC, -0x0CCCCCC ], [ 0x00CCCCCC, -0x0CCCCCC, -0x0666666 ], [ 0x00CCCCCC, -0x0CCCCCC, 0x00000000 ],
1390 [ 0x00CCCCCC, -0x0CCCCCC, 0x00666666 ], [ 0x00CCCCCC, -0x0CCCCCC, 0x00CCCCCC ],
1391 [ 0x00CCCCCC, -0x0666666, -0x0CCCCCC ], [ 0x00CCCCCC, -0x0666666, -0x0666666 ], [ 0x00CCCCCC, -0x0666666, 0x00000000 ],
1392 [ 0x00CCCCCC, -0x0666666, 0x00666666 ], [ 0x00CCCCCC, -0x0666666, 0x00CCCCCC ],
1393 [ 0x00CCCCCC, 0x00000000, -0x0CCCCCC ], [ 0x00CCCCCC, 0x00000000, -0x0666666 ], [ 0x00CCCCCC, 0x00000000, 0x00000000 ],
1394 [ 0x00CCCCCC, 0x00000000, 0x00666666 ], [ 0x00CCCCCC, 0x00000000, 0x00CCCCCC ],
1395 [ 0x00CCCCCC, 0x00666666, -0x0CCCCCC ], [ 0x00CCCCCC, 0x00666666, -0x0666666 ], [ 0x00CCCCCC, 0x00666666, 0x00000000 ],
1396 [ 0x00CCCCCC, 0x00666666, 0x00666666 ], [ 0x00CCCCCC, 0x00666666, 0x00CCCCCC ],
1397 [ 0x00CCCCCC, 0x00CCCCCC, -0x0CCCCCC ], [ 0x00CCCCCC, 0x00CCCCCC, -0x0666666 ], [ 0x00CCCCCC, 0x00CCCCCC, 0x00000000 ],
1398 [ 0x00CCCCCC, 0x00CCCCCC, 0x00666666 ], [ 0x00CCCCCC, 0x00CCCCCC, 0x00CCCCCC ],
1399];
1400const TS102366_QUANT7_MAP: [i32; 7] = [
1401 -0xDB6DB6, -0x924924, -0x492492, 0x000000, 0x492492, 0x924924, 0xDB6DB6
1402];
1403const TS102366_QUANT11_MAP: [[i32; 2]; 121] = [
1404 [ -0x0E8BA2E, -0x0E8BA2E ], [ -0x0E8BA2E, -0x0BA2E8B ], [ -0x0E8BA2E, -0x08BA2E8 ],
1405 [ -0x0E8BA2E, -0x05D1745 ], [ -0x0E8BA2E, -0x02E8BA2 ], [ -0x0E8BA2E, 0x00000000 ],
1406 [ -0x0E8BA2E, 0x002E8BA2 ], [ -0x0E8BA2E, 0x005D1745 ], [ -0x0E8BA2E, 0x008BA2E8 ],
1407 [ -0x0E8BA2E, 0x00BA2E8B ], [ -0x0E8BA2E, 0x00E8BA2E ], [ -0x0BA2E8B, -0x0E8BA2E ],
1408 [ -0x0BA2E8B, -0x0BA2E8B ], [ -0x0BA2E8B, -0x08BA2E8 ], [ -0x0BA2E8B, -0x05D1745 ],
1409 [ -0x0BA2E8B, -0x02E8BA2 ], [ -0x0BA2E8B, 0x00000000 ], [ -0x0BA2E8B, 0x002E8BA2 ],
1410 [ -0x0BA2E8B, 0x005D1745 ], [ -0x0BA2E8B, 0x008BA2E8 ], [ -0x0BA2E8B, 0x00BA2E8B ],
1411 [ -0x0BA2E8B, 0x00E8BA2E ], [ -0x08BA2E8, -0x0E8BA2E ], [ -0x08BA2E8, -0x0BA2E8B ],
1412 [ -0x08BA2E8, -0x08BA2E8 ], [ -0x08BA2E8, -0x05D1745 ], [ -0x08BA2E8, -0x02E8BA2 ],
1413 [ -0x08BA2E8, 0x00000000 ], [ -0x08BA2E8, 0x002E8BA2 ], [ -0x08BA2E8, 0x005D1745 ],
1414 [ -0x08BA2E8, 0x008BA2E8 ], [ -0x08BA2E8, 0x00BA2E8B ], [ -0x08BA2E8, 0x00E8BA2E ],
1415 [ -0x05D1745, -0x0E8BA2E ], [ -0x05D1745, -0x0BA2E8B ], [ -0x05D1745, -0x08BA2E8 ],
1416 [ -0x05D1745, -0x05D1745 ], [ -0x05D1745, -0x02E8BA2 ], [ -0x05D1745, 0x00000000 ],
1417 [ -0x05D1745, 0x002E8BA2 ], [ -0x05D1745, 0x005D1745 ], [ -0x05D1745, 0x008BA2E8 ],
1418 [ -0x05D1745, 0x00BA2E8B ], [ -0x05D1745, 0x00E8BA2E ], [ -0x02E8BA2, -0x0E8BA2E ],
1419 [ -0x02E8BA2, -0x0BA2E8B ], [ -0x02E8BA2, -0x08BA2E8 ], [ -0x02E8BA2, -0x05D1745 ],
1420 [ -0x02E8BA2, -0x02E8BA2 ], [ -0x02E8BA2, 0x00000000 ], [ -0x02E8BA2, 0x002E8BA2 ],
1421 [ -0x02E8BA2, 0x005D1745 ], [ -0x02E8BA2, 0x008BA2E8 ], [ -0x02E8BA2, 0x00BA2E8B ],
1422 [ -0x02E8BA2, 0x00E8BA2E ], [ 0x00000000, -0x0E8BA2E ], [ 0x00000000, -0x0BA2E8B ],
1423 [ 0x00000000, -0x08BA2E8 ], [ 0x00000000, -0x05D1745 ], [ 0x00000000, -0x02E8BA2 ],
1424 [ 0x00000000, 0x00000000 ], [ 0x00000000, 0x002E8BA2 ], [ 0x00000000, 0x005D1745 ],
1425 [ 0x00000000, 0x008BA2E8 ], [ 0x00000000, 0x00BA2E8B ], [ 0x00000000, 0x00E8BA2E ],
1426 [ 0x002E8BA2, -0x0E8BA2E ], [ 0x002E8BA2, -0x0BA2E8B ], [ 0x002E8BA2, -0x08BA2E8 ],
1427 [ 0x002E8BA2, -0x05D1745 ], [ 0x002E8BA2, -0x02E8BA2 ], [ 0x002E8BA2, 0x00000000 ],
1428 [ 0x002E8BA2, 0x002E8BA2 ], [ 0x002E8BA2, 0x005D1745 ], [ 0x002E8BA2, 0x008BA2E8 ],
1429 [ 0x002E8BA2, 0x00BA2E8B ], [ 0x002E8BA2, 0x00E8BA2E ], [ 0x005D1745, -0x0E8BA2E ],
1430 [ 0x005D1745, -0x0BA2E8B ], [ 0x005D1745, -0x08BA2E8 ], [ 0x005D1745, -0x05D1745 ],
1431 [ 0x005D1745, -0x02E8BA2 ], [ 0x005D1745, 0x00000000 ], [ 0x005D1745, 0x002E8BA2 ],
1432 [ 0x005D1745, 0x005D1745 ], [ 0x005D1745, 0x008BA2E8 ], [ 0x005D1745, 0x00BA2E8B ],
1433 [ 0x005D1745, 0x00E8BA2E ], [ 0x008BA2E8, -0x0E8BA2E ], [ 0x008BA2E8, -0x0BA2E8B ],
1434 [ 0x008BA2E8, -0x08BA2E8 ], [ 0x008BA2E8, -0x05D1745 ], [ 0x008BA2E8, -0x02E8BA2 ],
1435 [ 0x008BA2E8, 0x00000000 ], [ 0x008BA2E8, 0x002E8BA2 ], [ 0x008BA2E8, 0x005D1745 ],
1436 [ 0x008BA2E8, 0x008BA2E8 ], [ 0x008BA2E8, 0x00BA2E8B ], [ 0x008BA2E8, 0x00E8BA2E ],
1437 [ 0x00BA2E8B, -0x0E8BA2E ], [ 0x00BA2E8B, -0x0BA2E8B ], [ 0x00BA2E8B, -0x08BA2E8 ],
1438 [ 0x00BA2E8B, -0x05D1745 ], [ 0x00BA2E8B, -0x02E8BA2 ], [ 0x00BA2E8B, 0x00000000 ],
1439 [ 0x00BA2E8B, 0x002E8BA2 ], [ 0x00BA2E8B, 0x005D1745 ], [ 0x00BA2E8B, 0x008BA2E8 ],
1440 [ 0x00BA2E8B, 0x00BA2E8B ], [ 0x00BA2E8B, 0x00E8BA2E ], [ 0x00E8BA2E, -0x0E8BA2E ],
1441 [ 0x00E8BA2E, -0x0BA2E8B ], [ 0x00E8BA2E, -0x08BA2E8 ], [ 0x00E8BA2E, -0x05D1745 ],
1442 [ 0x00E8BA2E, -0x02E8BA2 ], [ 0x00E8BA2E, 0x00000000 ], [ 0x00E8BA2E, 0x002E8BA2 ],
1443 [ 0x00E8BA2E, 0x005D1745 ], [ 0x00E8BA2E, 0x008BA2E8 ], [ 0x00E8BA2E, 0x00BA2E8B ],
1444 [ 0x00E8BA2E, 0x00E8BA2E ],
1445];
1446const TS102366_QUANT15_MAP: [i32; 15] = [
1447 -0x0EEEEEE, -0x0CCCCCC, -0x0AAAAAA, -0x0888888, -0x0666666, -0x0444444, -0x0222222, 0x00000000,
1448 0x00222222, 0x00444444, 0x00666666, 0x00888888, 0x00AAAAAA, 0x00CCCCCC, 0x00EEEEEE,
1449];
1450const TS102366_BAP_BITS: [u8; 10] = [ 5, 6, 7, 8, 9, 10, 11, 12, 14, 16 ];
1451
1452const TS102366_WINDOW: [f32; 256] = [
1453 0.00014, 0.00024, 0.00037, 0.00051, 0.00067, 0.00086, 0.00107, 0.00130,
1454 0.00157, 0.00187, 0.00220, 0.00256, 0.00297, 0.00341, 0.00390, 0.00443,
1455 0.00501, 0.00564, 0.00632, 0.00706, 0.00785, 0.00871, 0.00962, 0.01061,
1456 0.01166, 0.01279, 0.01399, 0.01526, 0.01662, 0.01806, 0.01959, 0.02121,
1457 0.02292, 0.02472, 0.02662, 0.02863, 0.03073, 0.03294, 0.03527, 0.03770,
1458 0.04025, 0.04292, 0.04571, 0.04862, 0.05165, 0.05481, 0.05810, 0.06153,
1459 0.06508, 0.06878, 0.07261, 0.07658, 0.08069, 0.08495, 0.08935, 0.09389,
1460 0.09859, 0.10343, 0.10842, 0.11356, 0.11885, 0.12429, 0.12988, 0.13563,
1461 0.14152, 0.14757, 0.15376, 0.16011, 0.16661, 0.17325, 0.18005, 0.18699,
1462 0.19407, 0.20130, 0.20867, 0.21618, 0.22382, 0.23161, 0.23952, 0.24757,
1463 0.25574, 0.26404, 0.27246, 0.28100, 0.28965, 0.29841, 0.30729, 0.31626,
1464 0.32533, 0.33450, 0.34376, 0.35311, 0.36253, 0.37204, 0.38161, 0.39126,
1465 0.40096, 0.41072, 0.42054, 0.43040, 0.44030, 0.45023, 0.46020, 0.47019,
1466 0.48020, 0.49022, 0.50025, 0.51028, 0.52031, 0.53033, 0.54033, 0.55031,
1467 0.56026, 0.57019, 0.58007, 0.58991, 0.59970, 0.60944, 0.61912, 0.62873,
1468 0.63827, 0.64774, 0.65713, 0.66643, 0.67564, 0.68476, 0.69377, 0.70269,
1469 0.71150, 0.72019, 0.72877, 0.73723, 0.74557, 0.75378, 0.76186, 0.76981,
1470 0.77762, 0.78530, 0.79283, 0.80022, 0.80747, 0.81457, 0.82151, 0.82831,
1471 0.83496, 0.84145, 0.84779, 0.85398, 0.86001, 0.86588, 0.87160, 0.87716,
1472 0.88257, 0.88782, 0.89291, 0.89785, 0.90264, 0.90728, 0.91176, 0.91610,
1473 0.92028, 0.92432, 0.92822, 0.93197, 0.93558, 0.93906, 0.94240, 0.94560,
1474 0.94867, 0.95162, 0.95444, 0.95713, 0.95971, 0.96217, 0.96451, 0.96674,
1475 0.96887, 0.97089, 0.97281, 0.97463, 0.97635, 0.97799, 0.97953, 0.98099,
1476 0.98236, 0.98366, 0.98488, 0.98602, 0.98710, 0.98811, 0.98905, 0.98994,
1477 0.99076, 0.99153, 0.99225, 0.99291, 0.99353, 0.99411, 0.99464, 0.99513,
1478 0.99558, 0.99600, 0.99639, 0.99674, 0.99706, 0.99736, 0.99763, 0.99788,
1479 0.99811, 0.99831, 0.99850, 0.99867, 0.99882, 0.99895, 0.99908, 0.99919,
1480 0.99929, 0.99938, 0.99946, 0.99953, 0.99959, 0.99965, 0.99969, 0.99974,
1481 0.99978, 0.99981, 0.99984, 0.99986, 0.99988, 0.99990, 0.99992, 0.99993,
1482 0.99994, 0.99995, 0.99996, 0.99997, 0.99998, 0.99998, 0.99998, 0.99999,
1483 0.99999, 0.99999, 0.99999, 1.00000, 1.00000, 1.00000, 1.00000, 1.00000,
1484 1.00000, 1.00000, 1.00000, 1.00000, 1.00000, 1.00000, 1.00000, 1.00000,
1485];
NihAV is a research multimedia framework