2 use std::cell::RefCell;
3 use nihav_core::formats::*;
4 use nihav_core::frame::*;
5 use nihav_core::codecs::*;
6 use nihav_core::io::bitreader::*;
7 use nihav_core::dsp::fft::*;
11 const BLOCK_LEN: usize = 256;
12 const NBLOCKS: usize = 6;
13 const MAX_CHANNELS: usize = 5;
14 const MAX_CPLBANDS: usize = 18;
15 const MAX_BANDS: usize = 50;
17 const MAGIC_BYTE0: u8 = 0x0B;
18 const MAGIC_BYTE1: u8 = 0x77;
20 const STRATEGY_REUSE: u8 = 0;
22 const LFE_CHANNEL: usize = MAX_CHANNELS;
23 const CPL_CHANNEL: usize = MAX_CHANNELS + 1;
26 xsincos: [FFTComplex; BLOCK_LEN/2],
31 struct IMDCTWorkspace {
32 z: [FFTComplex; BLOCK_LEN / 2],
33 y: [FFTComplex; BLOCK_LEN / 2],
34 out: [f32; BLOCK_LEN * 2],
38 fn new(bits: usize) -> Self {
40 let size4 = 1 << (bits - 2);
41 let mut xsincos: [FFTComplex; 512/4] = [FFTC_ZERO; 512/4];
43 let factor = 2.0 * consts::PI * ((8 * k + 1) as f32) / ((8 * size) as f32);
44 xsincos[k].re = -factor.cos();
45 xsincos[k].im = -factor.sin();
47 let fft = FFTBuilder::new_fft(FFTMode::SplitRadix, size/4);
48 IMDCTContext { xsincos: xsincos, size: size, fft: fft }
50 #[allow(non_snake_case)]
51 fn do_imdct(&mut self, coeffs: &[i32; BLOCK_LEN], tmp: &mut IMDCTWorkspace) {
52 do_imdct_core(&mut self.fft, &self.xsincos, self.size, false, coeffs, &mut tmp.z, &mut tmp.y);
53 let w = &TS102366_WINDOW;
54 let N2 = self.size / 2;
55 let N4 = self.size / 4;
56 let N8 = self.size / 8;
58 tmp.out[ 2 * n] = -tmp.y[N8 + n] .im * w[ 2 * n];
59 tmp.out[ 2 * n + 1] = tmp.y[N8 - n - 1].re * w[ 2 * n + 1];
60 tmp.out[ N4 + 2 * n] = -tmp.y[ n] .re * w[N4 + 2 * n];
61 tmp.out[ N4 + 2 * n + 1] = tmp.y[N4 - n - 1].im * w[N4 + 2 * n + 1];
62 tmp.out[ N2 + 2 * n] = -tmp.y[N8 + n] .re * w[N2 - 2 * n - 1];
63 tmp.out[ N2 + 2 * n + 1] = tmp.y[N8 - n - 1].im * w[N2 - 2 * n - 2];
64 tmp.out[3 * N4 + 2 * n] = tmp.y[ n] .im * w[N4 - 2 * n - 1];
65 tmp.out[3 * N4 + 2 * n + 1] = -tmp.y[N4 - n - 1].re * w[N4 - 2 * n - 2];
68 #[allow(non_snake_case)]
69 fn do_imdct_ileave(&mut self, coeffs: &[i32; BLOCK_LEN], tmp: &mut IMDCTWorkspace) {
70 let mut ziter = tmp.z.chunks_mut(self.size / 4);
71 let z1 = ziter.next().unwrap();
72 let z2 = ziter.next().unwrap();
73 let mut yiter = tmp.y.chunks_mut(self.size / 4);
74 let y1 = yiter.next().unwrap();
75 let y2 = yiter.next().unwrap();
76 do_imdct_core(&mut self.fft, &self.xsincos, self.size, true, coeffs, z1, y1);
77 do_imdct_core(&mut self.fft, &self.xsincos, self.size, true, &coeffs[1..], z2, y2);
78 let w = &TS102366_WINDOW;
79 let N2 = self.size / 2;
80 let N4 = self.size / 4;
81 let N8 = self.size / 8;
83 tmp.out[ 2 * n] = -y1[ n] .im * w[ 2 * n];
84 tmp.out[ 2 * n + 1] = y1[N8 - n - 1].re * w[ 2 * n + 1];
85 tmp.out[ N4 + 2 * n] = -y1[ n] .re * w[N4 + 2 * n];
86 tmp.out[ N4 + 2 * n + 1] = y1[N8 - n - 1].im * w[N4 + 2 * n + 1];
87 tmp.out[ N2 + 2 * n] = -y2[ n] .re * w[N2 - 2 * n - 1];
88 tmp.out[ N2 + 2 * n + 1] = y2[N8 - n - 1].im * w[N2 - 2 * n - 2];
89 tmp.out[3 * N4 + 2 * n] = y2[ n] .im * w[N4 - 2 * n - 1];
90 tmp.out[3 * N4 + 2 * n + 1] = -y2[N8 - n - 1].re * w[N4 - 2 * n - 2];
95 #[allow(non_snake_case)]
96 fn do_imdct_core(fft: &mut FFT, xsc: &[FFTComplex; BLOCK_LEN/2], size: usize, ilace: bool, coeffs: &[i32], z: &mut [FFTComplex], y: &mut [FFTComplex]) {
100 let scale = 1.0 / ((1 << 24) as f32);
102 let (c0, c1) = if !ilace {
103 ((coeffs[N2 - 2 * k - 1] as f32) * scale,
104 (coeffs[ 2 * k] as f32) * scale)
106 ((coeffs[N - 4 * k - 2] as f32) * scale,
107 (coeffs[ 4 * k] as f32) * scale)
109 let c = FFTComplex { re: c0, im: c1 };
112 fft.do_fft_inplace(z, false);
114 y[k] = z[k] * xsc[k];
118 struct AudioDecoder {
119 info: Rc<NACodecInfo>,
121 imdct512: IMDCTContext,
122 imdct256: IMDCTContext,
124 delay: [[f32; BLOCK_LEN]; MAX_CHANNELS + 1],
130 info: NACodecInfo::new_dummy(),
131 ablk: AudioBlock::new(),
132 imdct512: IMDCTContext::new(9),
133 imdct256: IMDCTContext::new(8),
134 tmp: IMDCTWorkspace {
135 z: [FFTC_ZERO; BLOCK_LEN / 2],
136 y: [FFTC_ZERO; BLOCK_LEN / 2],
137 out: [0.0; BLOCK_LEN * 2],
139 delay: [[0.0; BLOCK_LEN]; MAX_CHANNELS + 1],
144 const SAMPLE_RATES: [u32; 4] = [ 48000, 44100, 32000, 0 ];
146 const FRAME_SIZES: [[usize; 64]; 4] = [
148 64, 64, 80, 80, 96, 96, 112, 112,
149 128, 128, 160, 160, 192, 192, 224, 224,
150 256, 256, 320, 320, 384, 384, 448, 448,
151 512, 512, 640, 640, 768, 768, 896, 896,
152 1024, 1024, 1152, 1152, 1280, 1280,
153 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
154 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
156 69, 70, 87, 88, 104, 105, 121, 122,
157 139, 140, 174, 175, 208, 209, 243, 244,
158 278, 279, 348, 349, 417, 418, 487, 488,
159 557, 558, 696, 697, 835, 836, 975, 976,
160 1114, 1115, 1253, 1254, 1393, 1394,
161 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
162 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
164 96, 96, 120, 120, 144, 144, 168, 168,
165 192, 192, 240, 240, 288, 288, 336, 336,
166 384, 384, 480, 480, 576, 576, 672, 672,
167 768, 768, 960, 960, 1152, 1152, 1344, 1344,
168 1536, 1536, 1728, 1728, 1920, 1920,
169 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
170 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
174 #[derive(Debug,Clone,Copy)]
184 fn read(br: &mut BitReader) -> DecoderResult<Self> {
185 let syncword = br.read(16)?;
186 validate!(syncword == ((MAGIC_BYTE0 as u32) * 256) + (MAGIC_BYTE1 as u32));
187 let crc1 = br.read(16)? as u16;
188 let fscod = br.read(2)? as usize;
189 let frmsizecod = br.read(6)? as usize;
190 Ok(Syncinfo { crc1: crc1, fscod: fscod as u8, frmsizecod: frmsizecod as u8,
191 samplerate: SAMPLE_RATES[fscod], frame_size: FRAME_SIZES[fscod][frmsizecod] * 2 })
193 fn is_valid(&self) -> bool {
194 (self.samplerate != 0) && (self.frame_size != 0)
199 fn read_optional8(&mut self) -> BitReaderResult<Option<u8>>;
200 fn read_optional16(&mut self, bits: u8) -> BitReaderResult<Option<u16>>;
203 impl<'a> ReadOptional for BitReader<'a> {
204 fn read_optional8(&mut self) -> BitReaderResult<Option<u8>> {
205 if self.read_bool()? {
206 Ok(Some(self.read(8)? as u8))
211 fn read_optional16(&mut self, bits: u8) -> BitReaderResult<Option<u16>> {
212 if self.read_bool()? {
213 Ok(Some(self.read(bits)? as u16))
220 #[derive(Debug,Clone,Copy,PartialEq)]
233 fn get_num_channels(&self) -> usize {
235 ACMode::DualMono => 2,
238 ACMode::Mode3_0 => 3,
239 ACMode::Mode2_1 => 3,
240 ACMode::Mode3_1 => 4,
241 ACMode::Mode2_2 => 4,
242 ACMode::Mode3_2 => 5,
245 fn get_channel_map_str(&self) -> &'static str {
247 ACMode::DualMono => "C,C",
249 ACMode::Stereo => "L,R",
250 ACMode::Mode3_0 => "L,C,R",
251 ACMode::Mode2_1 => "L,R,Cs",
252 ACMode::Mode3_1 => "L,C,R,Cs",
253 ACMode::Mode2_2 => "L,R,Ls,Rs",
254 ACMode::Mode3_2 => "L,C,R,Ls,Rs",
257 fn get_channel_map(&self, has_lfe: bool) -> NAChannelMap {
258 let mut chmap = NAChannelMap::from_str(self.get_channel_map_str()).unwrap();
260 chmap.add_channel(NAChannelType::LFE);
264 fn is_3_x(&self) -> bool {
268 ACMode::Mode3_2 => true,
272 fn is_surround(&self) -> bool {
277 ACMode::Mode3_2 => true,
283 const AC_MODES: [ACMode; 8] = [
284 ACMode::DualMono, ACMode::Mono, ACMode::Stereo,
285 ACMode::Mode3_0, ACMode::Mode2_1,
286 ACMode::Mode3_1, ACMode::Mode2_2,
290 #[derive(Debug,Clone,Copy)]
295 mixlevel: Option<u8>,
300 fn read(br: &mut BitReader) -> DecoderResult<Self> {
301 let dialnorm = br.read(5)? as u8;
302 let compr = br.read_optional8()?;
303 let langcod = br.read_optional8()?;
304 let (mixlevel, roomtyp) = if br.read_bool()? {
305 let mlev = br.read(5)? as u8;
306 let rt = br.read(2)? as u8;
308 (Some(mlev), Some(rt))
312 Ok(Mixinfo { dialnorm, compr, langcod, mixlevel, roomtyp })
316 #[derive(Debug,Clone,Copy)]
323 surmixlev: Option<u8>,
327 mixinfo2: Option<Mixinfo>,
330 timecod1: Option<u16>,
331 timecod2: Option<u16>,
336 fn read(br: &mut BitReader) -> DecoderResult<BSI> {
337 let bsid = br.read(5)? as u8;
338 validate!(bsid <= 10);
339 let shift = if bsid < 9 { 0 } else { bsid - 9 + 1 };
340 let bsmod = br.read(3)? as u8;
341 let acmod_id = br.read(3)? as usize;
342 validate!(acmod_id < AC_MODES.len());
343 let acmod = AC_MODES[acmod_id];
344 let cmixlev = if acmod.is_3_x() {
345 let cl = br.read(2)? as u8;
349 let surmixlev = if acmod.is_surround() {
350 let sml = br.read(2)? as u8;
354 let dsurmod = if acmod == ACMode::Stereo {
355 let dsm = br.read(2)? as u8;
359 let lfeon = br.read_bool()?;
360 let mixinfo = Mixinfo::read(br)?;
361 let mixinfo2 = if acmod == ACMode::DualMono {
362 Some(Mixinfo::read(br)?)
366 let copysmth = br.read_bool()?;
367 let origbs = br.read_bool()?;
368 let timecod1 = br.read_optional16(14)?;
369 let timecod2 = br.read_optional16(14)?;
370 let has_addb = br.read_bool()?;
372 bsid, shift, bsmod, acmod, lfeon,
373 cmixlev, surmixlev, dsurmod,
374 mixinfo: mixinfo, mixinfo2: mixinfo2,
375 copysmth, origbs, timecod1, timecod2, has_addb,
380 #[derive(Clone, Copy)]
387 cplcoexp: [u8; MAX_CPLBANDS],
388 cplcomant: [u8; MAX_CPLBANDS],
417 const GROUPS: [usize; 4] = [ 0, 3, 6, 12 ];
418 const GROUP_BIAS: [usize; 4] = [ 0, 0, 3, 9 ];
420 fn decode_exps(br: &mut BitReader, dst: &mut [u8], mut prev: u8, grplen: usize) -> DecoderResult<()> {
421 let repeat = grplen / 3;
423 for out in dst.chunks_mut(grplen) {
424 let val = br.read(7)? as u8;
425 validate!(val < 125);
426 let diff: [u8; 3] = [ val / 25, (val / 5) % 5, val % 5 ];
427 for (i, exps) in out.chunks_mut(repeat).enumerate() {
428 exps[0] = (prev + diff[i]).wrapping_sub(2);
429 validate!(exps[0] <= 24);
440 macro_rules! read_bap {
441 ($br: expr, $tab:ident, $nbits:expr) => ({
442 let val = $br.read($nbits)? as usize;
443 validate!(val < $tab.len());
446 ($br:expr, $tab:ident, $nbits:expr, $bufidx:expr, $bap_buf:expr, $bap_buf_fill:expr) => (
447 if $bap_buf_fill[$bufidx] > 0 {
448 $bap_buf_fill[$bufidx] -= 1;
449 $bap_buf[$bufidx][$bap_buf_fill[$bufidx]]
451 let val = $br.read($nbits)? as usize;
452 validate!(val < $tab.len());
453 for i in 1..$tab[0].len() {
454 $bap_buf[$bufidx][i - 1] = $tab[val][i];
456 $bap_buf_fill[$bufidx] = $tab[0].len() - 1;
470 cplcoexp: [0; MAX_CPLBANDS],
471 cplcomant: [0; MAX_CPLBANDS],
500 fn read_strategy(&mut self, br: &mut BitReader, blk_no: usize) -> DecoderResult<()> {
501 self.expstr = br.read(2)? as u8;
502 validate!(blk_no != 0 || self.expstr != STRATEGY_REUSE);
503 if self.expstr != STRATEGY_REUSE {
504 if self.startmant > 0 {
505 self.groups = (self.endmant - self.startmant) / GROUPS[self.expstr as usize];
506 } else if self.endmant != 0{
507 let idx = self.expstr as usize;
508 self.groups = (self.endmant + GROUP_BIAS[idx] - 1) / GROUPS[idx];
515 fn read_exps(&mut self, br: &mut BitReader, is_cpl: bool, is_lfe: bool) -> DecoderResult<()> {
516 if self.expstr == STRATEGY_REUSE { return Ok(()); }
517 let grpsize = GROUPS[self.expstr as usize];
518 self.exps = [0; 256];
520 let first = (br.read(4)? as u8) << 1;
521 let out = &mut self.exps[self.startmant..self.endmant];
522 decode_exps(br, out, first, grpsize)?;
524 self.exps[0] = br.read(4)? as u8;
525 let first = self.exps[0];
526 let out = &mut self.exps[1..self.endmant];
527 decode_exps(br, out, first, grpsize)?;
528 self.gainrng = br.read(2)? as u8;
530 self.exps[0] = br.read(4)? as u8;
531 let first = self.exps[0];
532 let out = &mut self.exps[1..7];
533 decode_exps(br, out, first, grpsize)?;
537 fn read_snr(&mut self, br: &mut BitReader) -> DecoderResult<()> {
538 self.fsnroffst = br.read(4)? as u8;
539 self.fgaincod = br.read(3)? as usize;
542 fn read_deltbai(&mut self, br: &mut BitReader) -> DecoderResult<()> {
543 if self.deltbae == 1 {
544 self.deltnseg = (br.read(3)? as usize) + 1;
545 for seg in 0..self.deltnseg {
546 self.deltoffst[seg] = br.read(5)? as u8;
547 self.deltlen[seg] = br.read(4)? as usize;
548 self.deltba[seg] = br.read(3)? as u8;
554 fn compute_bndpsd(&mut self) {
555 let start = self.startmant;
556 let end = self.endmant;
557 let exps = &mut self.exps;
558 let psd = &mut self.psd;
559 let bndpsd = &mut self.bndpsd;
561 for bin in start..end {
562 psd[bin] = 3072 - ((exps[bin] as i16) << 7);
566 let mut band = TS102366_BIN_TO_BAND[bin] as usize;
569 lastbin = ((TS102366_BAND_START[band] as usize) + (TS102366_BAND_SIZE[band] as usize)).min(end);
570 bndpsd[band] = psd[bin] as i32;
572 while bin < lastbin {
573 bndpsd[band] = logadd(bndpsd[band], psd[bin] as i32);
577 if lastbin >= end { break; }
580 fn compute_mask(&mut self, mask: &mut [i32; MAX_BANDS], fscod: usize, sgain: u16, fdecay: u8, sdecay: u8,
581 dbknee: u16, cplfleak: u16, cplsleak: u16, shift: u8) {
582 let fgain = TS102366_FAST_GAIN[self.fgaincod] as i32;
584 let bndstart = TS102366_BIN_TO_BAND[self.startmant] as usize;
585 let bndend = (TS102366_BIN_TO_BAND[self.endmant - 1] as usize) + 1;
587 let mut excite: [i32; MAX_BANDS] = [0; MAX_BANDS];
593 let lowcomp0 = calc_lowcomp(0, self.bndpsd[0], self.bndpsd[1], 0);
594 excite[0] = self.bndpsd[0] - fgain - lowcomp0;
595 let lowcomp1 = calc_lowcomp(lowcomp0, self.bndpsd[1], self.bndpsd[2], 1);
596 excite[1] = self.bndpsd[1] - fgain - lowcomp1;
598 let mut lowcomp = lowcomp1;
602 let not_lfe_case = (bndend != 7) || (band != 6);
604 lowcomp = calc_lowcomp(lowcomp, self.bndpsd[band], self.bndpsd[band + 1], band);
606 fast_leak = self.bndpsd[band] - fgain;
607 slow_leak = self.bndpsd[band] - (sgain as i32);
608 excite[band] = fast_leak - lowcomp;
610 if self.bndpsd[band] <= self.bndpsd[band + 1] {
616 for band in sband..bndend.min(22) {
617 if (bndend != 7) || (band != 6) {
618 lowcomp = calc_lowcomp(lowcomp, self.bndpsd[band], self.bndpsd[band + 1], band);
620 fast_leak = (fast_leak - (fdecay as i32)).max(self.bndpsd[band] - (fgain as i32));
621 slow_leak = (slow_leak - (sdecay as i32)).max(self.bndpsd[band] - (sgain as i32));
622 excite[band] = slow_leak.max(fast_leak - lowcomp);
627 fast_leak = cplfleak as i32;
628 slow_leak = cplsleak as i32;
630 for band in begin..bndend {
631 fast_leak = (fast_leak - (fdecay as i32)).max(self.bndpsd[band] - (fgain as i32));
632 slow_leak = (slow_leak - (sdecay as i32)).max(self.bndpsd[band] - (sgain as i32));
633 excite[band] = fast_leak.max(slow_leak);
635 for band in bndstart..bndend {
636 if self.bndpsd[band] < (dbknee as i32) {
637 excite[band] += ((dbknee as i32) - self.bndpsd[band]) >> 2;
639 mask[band] = excite[band].max(TS102366_HTH[fscod][band >> shift] as i32);
642 fn apply_delta_info(&mut self, mask: &mut [i32; MAX_BANDS]) {
643 if self.deltbae == 0 || self.deltbae == 1 {
644 let mut band = TS102366_BIN_TO_BAND[self.startmant] as usize;
645 for seg in 0..self.deltnseg {
646 band += self.deltoffst[seg] as usize;
647 let delta = if self.deltba[seg] >= 4 {
648 ((self.deltba[seg] as i32) - 3) << 7
650 ((self.deltba[seg] as i32) - 4) << 7
652 if band + self.deltlen[seg] > MAX_BANDS { break; }
653 for _ in 0..self.deltlen[seg] {
660 fn calc_snr_offset(&mut self, csnroffst: u8) {
661 self.snroffset = ((((csnroffst as i32) - 15) << 4) + (self.fsnroffst as i32)) << 2;
663 fn compute_bap(&mut self, mask: &mut [i32; MAX_BANDS], floor: u16) {
664 let end = self.endmant;
665 let mut band = TS102366_BIN_TO_BAND[self.startmant] as usize;
666 let mut bin = self.startmant;
669 lastbin = ((TS102366_BAND_START[band] as usize) + (TS102366_BAND_SIZE[band] as usize)).min(end);
670 mask[band] = (mask[band] - self.snroffset - (floor as i32)).max(0) & 0x1FE0;
671 mask[band] += floor as i32;
672 while bin < lastbin {
673 let addr = (((self.psd[bin] as i32) - mask[band]) >> 5).min(63).max(0) as usize;
674 self.bap[bin] = TS102366_BAPTAB[addr];
677 if lastbin == end { break; }
681 fn read_mant(&mut self, br: &mut BitReader, bap_buf: &mut [[i32; 2]; 3], bap_buf_fill: &mut [usize; 3]) -> DecoderResult<()> {
682 self.mant = [0; BLOCK_LEN];
683 for bin in self.startmant..self.endmant {
684 self.mant[bin] = match self.bap[bin] {
692 1 => { read_bap!(br, TS102366_QUANT3_MAP, 5, 0, bap_buf, bap_buf_fill) },
693 2 => { read_bap!(br, TS102366_QUANT5_MAP, 7, 1, bap_buf, bap_buf_fill) },
694 3 => { read_bap!(br, TS102366_QUANT7_MAP, 3) },
695 4 => { read_bap!(br, TS102366_QUANT11_MAP, 7, 2, bap_buf, bap_buf_fill) },
696 5 => { read_bap!(br, TS102366_QUANT15_MAP, 4) },
698 validate!(self.bap[bin] < 15);
699 let nbits = TS102366_BAP_BITS[(self.bap[bin] as usize) - 6];
700 let val = br.read(nbits)? as i16;
701 ((val << (16 - nbits)) as i32) << 9
704 self.mant[bin] >>= self.exps[bin];
709 fn synth(&mut self, imdct512: &mut IMDCTContext, imdct256: &mut IMDCTContext, tmp: &mut IMDCTWorkspace, delay: &mut [f32; BLOCK_LEN], dst: &mut [f32]) {
711 imdct512.do_imdct(&self.mant, tmp);
713 imdct256.do_imdct_ileave(&self.mant, tmp);
715 overlap(delay, &tmp.out, dst);
719 fn logadd(acc: i32, add: i32) -> i32 {
721 let addr = (c.abs() >> 1).min(255);
723 acc + (TS102366_LATAB[addr as usize] as i32)
725 add + (TS102366_LATAB[addr as usize] as i32)
729 fn calc_lowcomp(a: i32, b0: i32, b1: i32, band: usize) -> i32 {
731 if (b0 + 256) == b1 {
738 } else if band < 20 {
739 if (b0 + 256) == b1 {
751 fn overlap(delay: &mut [f32; BLOCK_LEN], src: &[f32; BLOCK_LEN * 2], out: &mut [f32]) {
754 for ((d, s), o) in dly.into_iter().zip(src.into_iter()).zip(out.iter_mut()) {
755 *o = (*d + *s) * 2.0;
758 delay.copy_from_slice(&src[BLOCK_LEN..]);
773 cplbndstrc: [bool; MAX_CPLBANDS],
775 phsflg: [bool; MAX_CPLBANDS],
779 chdata: [ChannelData; MAX_CHANNELS + 2],
795 bap_buf: [[i32; 2]; 3],
796 bap_buf_fill: [usize; 3],
802 chdata: [ChannelData::new(); MAX_CHANNELS + 2],
814 cplbndstrc: [false; MAX_CPLBANDS],
816 phsflg: [false; MAX_CPLBANDS],
818 rematflg: [false; 4],
834 bap_buf: [[0; 2]; 3],
835 bap_buf_fill: [0; 3],
838 fn read(&mut self, br: &mut BitReader, bsi: &BSI, fscod: usize, blk_no: usize) -> DecoderResult<bool> {
839 let channels = bsi.acmod.get_num_channels();
840 let is_stereo = bsi.acmod == ACMode::Stereo;
842 for ch in 0..channels {
843 self.chdata[ch].blksw = br.read_bool()?;
845 // dynamic range information
846 for ch in 0..channels {
847 self.chdata[ch].dithflag = br.read_bool()?;
849 self.dynrng = br.read_optional8()?;
850 if bsi.acmod == ACMode::DualMono {
851 self.dynrng2 = br.read_optional8()?;
853 // coupling strategy information
854 self.cplstre = br.read_bool()?;
855 validate!((blk_no != 0) || self.cplstre);
857 self.cplinu = br.read_bool()?;
859 for ch in 0..channels {
860 self.chdata[ch].chincpl = br.read_bool()?;
863 self.phsflginu = br.read_bool()?;
865 self.cplbegf = br.read(4)? as usize;
866 self.cplendf = (br.read(4)? as usize) + 3;
867 validate!(self.cplendf >= self.cplbegf);
868 self.ncplsubnd = self.cplendf - self.cplbegf;
869 self.ncplbnd = self.ncplsubnd;
870 self.chdata[CPL_CHANNEL].startmant = self.cplbegf * 12 + 37;
871 self.chdata[CPL_CHANNEL].endmant = self.cplendf * 12 + 37;
872 for bnd in 1..self.ncplsubnd {
873 self.cplbndstrc[bnd] = br.read_bool()?;
874 if self.cplbndstrc[bnd] {
880 // coupling coordinates
882 for c in 0..channels {
883 let ch = &mut self.chdata[c];
885 ch.cplcoe = br.read_bool()?;
887 ch.mstrcplco = br.read(2)? as u8;
888 for bnd in 0..self.ncplbnd {
889 ch.cplcoexp [bnd] = br.read(4)? as u8;
890 ch.cplcomant[bnd] = br.read(4)? as u8;
895 if is_stereo && self.phsflginu && (self.chdata[0].cplcoe || self.chdata[1].cplcoe) {
896 for bnd in 0..self.ncplbnd {
897 self.phsflg[bnd] = br.read_bool()?;
901 for ch in 0..channels {
902 self.chdata[ch].chincpl = false;
905 // stereo rematrixing
907 self.rematstr = br.read_bool()?;
909 if self.cplbegf > 2 || !self.cplinu {
911 self.rematflg[rbnd] = br.read_bool()?;
914 if self.cplbegf > 0 && self.cplbegf <= 2 && self.cplinu {
916 self.rematflg[rbnd] = br.read_bool()?;
919 if self.cplbegf == 0 && self.cplinu {
921 self.rematflg[rbnd] = br.read_bool()?;
928 self.chdata[CPL_CHANNEL].read_strategy(br, blk_no)?;
930 for ch in 0..channels {
931 self.chdata[ch].read_strategy(br, blk_no)?;
934 self.chdata[LFE_CHANNEL].expstr = br.read(1)? as u8;
935 validate!(blk_no != 0 || self.chdata[LFE_CHANNEL].expstr != STRATEGY_REUSE);
936 self.chdata[LFE_CHANNEL].groups = 2;
937 self.chdata[LFE_CHANNEL].startmant = 0;
938 self.chdata[LFE_CHANNEL].endmant = 7;
940 let cpl_startmant = self.chdata[CPL_CHANNEL].startmant;
941 for c in 0..channels {
942 let ch = &mut self.chdata[c];
943 if ch.expstr != STRATEGY_REUSE && !ch.chincpl {
944 ch.chbwcod = br.read(6)? as u8;
948 ch.endmant = ((ch.chbwcod as usize) + 12) * 3 + 37;
951 ch.endmant = cpl_startmant;
954 // set number of mantissas
956 self.chdata[CPL_CHANNEL].read_exps(br, true, false)?;
958 for ch in 0..channels {
959 self.chdata[ch].read_exps(br, false, false)?;
962 self.chdata[LFE_CHANNEL].read_exps(br, false, true)?;
964 // bit allocation parameters
965 self.baie = br.read_bool()?;
967 self.sdcycod = br.read(2)? as usize;
968 self.fdcycod = br.read(2)? as usize;
969 self.sgaincod = br.read(2)? as usize;
970 self.dbpbcod = br.read(2)? as usize;
971 self.floorcod = br.read(3)? as usize;
973 self.snroffste = br.read_bool()?;
975 self.csnroffst = br.read(6)? as u8;
977 self.chdata[CPL_CHANNEL].read_snr(br)?;
979 for ch in 0..channels {
980 self.chdata[ch].read_snr(br)?;
983 self.chdata[LFE_CHANNEL].read_snr(br)?;
987 self.cplleake = br.read_bool()?;
989 self.cplfleak = br.read(3)? as u8;
990 self.cplsleak = br.read(3)? as u8;
993 // delta bit allocation information
994 self.deltbaie = br.read_bool()?;
997 self.chdata[CPL_CHANNEL].deltbae = br.read(2)? as u8;
998 validate!(blk_no != 0 || self.chdata[CPL_CHANNEL].deltbae != 0);
999 validate!(self.chdata[CPL_CHANNEL].deltbae != 3);
1001 for ch in 0..channels {
1002 self.chdata[ch].deltbae = br.read(2)? as u8;
1003 validate!(blk_no != 0 || self.chdata[ch].deltbae != 0);
1004 validate!(self.chdata[ch].deltbae != 3);
1007 self.chdata[CPL_CHANNEL].read_deltbai(br)?;
1009 for ch in 0..channels {
1010 self.chdata[ch].read_deltbai(br)?;
1014 if br.read_bool()? {
1015 let skipl = br.read(9)?;
1016 br.skip(skipl * 8)?;
1019 let all_zero = self.calc_bitalloc(bsi, channels, fscod);
1020 if all_zero { return Ok(true); }
1022 // quantised mantissa values
1023 let mut got_cplchan = false;
1024 for i in 0..self.bap_buf_fill.len() { self.bap_buf_fill[i] = 0; }
1025 for c in 0..channels {
1027 let ch = &mut self.chdata[c];
1028 ch.read_mant(br, &mut self.bap_buf, &mut self.bap_buf_fill)?;
1030 if self.cplinu && self.chdata[c].chincpl && !got_cplchan {
1031 let cplch = &mut self.chdata[CPL_CHANNEL];
1032 cplch.read_mant(br, &mut self.bap_buf, &mut self.bap_buf_fill)?;
1037 let lfech = &mut self.chdata[LFE_CHANNEL];
1038 lfech.read_mant(br, &mut self.bap_buf, &mut self.bap_buf_fill)?;
1042 fn calc_bitalloc(&mut self, bsi: &BSI, channels: usize, fscod: usize) -> bool {
1043 let sdecay1 = TS102366_SLOW_DECAY[self.sdcycod];
1044 let fdecay1 = TS102366_FAST_DECAY[self.fdcycod];
1046 let sdecay = sdecay1 >> bsi.shift;
1047 let fdecay = fdecay1 >> bsi.shift;
1048 let sgain = TS102366_SLOW_GAIN[self.sgaincod];
1049 let dbknee = TS102366_DBP_TAB[self.dbpbcod];
1050 let floor = TS102366_FLOOR_TAB[self.floorcod];
1052 let mut all_zero = self.csnroffst == 0;
1053 if !all_zero && self.chdata[LFE_CHANNEL].fsnroffst == 0 {
1054 for ch in 0..channels {
1055 if self.chdata[ch].fsnroffst != 0 {
1061 if all_zero { return true; }
1063 let mut mask: [i32; MAX_BANDS] = [0; MAX_BANDS];
1066 self.chdata[CPL_CHANNEL].compute_bndpsd();
1067 self.chdata[CPL_CHANNEL].compute_mask(&mut mask, fscod, sgain, fdecay, sdecay, dbknee,
1068 ((self.cplfleak as u16) << 8) + 768, ((self.cplsleak as u16) << 8) + 768, bsi.shift);
1069 self.chdata[CPL_CHANNEL].apply_delta_info(&mut mask);
1070 self.chdata[CPL_CHANNEL].calc_snr_offset(self.csnroffst);
1071 self.chdata[CPL_CHANNEL].compute_bap(&mut mask, floor);
1073 for ch in 0..channels {
1074 self.chdata[ch].compute_bndpsd();
1075 self.chdata[ch].compute_mask(&mut mask, fscod, sgain, fdecay, sdecay, dbknee, 0, 0, bsi.shift);
1076 self.chdata[ch].apply_delta_info(&mut mask);
1077 self.chdata[ch].calc_snr_offset(self.csnroffst);
1078 self.chdata[ch].compute_bap(&mut mask, floor);
1081 self.chdata[LFE_CHANNEL].compute_bndpsd();
1082 self.chdata[LFE_CHANNEL].compute_mask(&mut mask, fscod, sgain, fdecay, sdecay, dbknee,
1084 self.chdata[LFE_CHANNEL].calc_snr_offset(self.csnroffst);
1085 self.chdata[LFE_CHANNEL].compute_bap(&mut mask, floor);
1090 fn couple_channels(&mut self, acmod: ACMode) {
1091 if !self.cplinu { return; }
1092 for ch in 0..acmod.get_num_channels() {
1093 if !self.chdata[ch].chincpl { continue; }
1095 for band in self.cplbegf..self.cplendf {
1096 let cband = band - self.cplbegf;
1097 let comant = self.chdata[ch].cplcomant[cband];
1098 let mut cotemp = (if self.chdata[ch].cplcoexp[cband] == 15 { comant << 1 } else { comant + 16 }) as i32;
1099 if (acmod == ACMode::Stereo) && (ch == 1) && self.phsflginu && self.phsflg[pband] {
1102 if !self.cplbndstrc[cband] {
1105 let exp = self.chdata[ch].cplcoexp[cband] + 3 * self.chdata[ch].mstrcplco + 5 - 3;
1106 let start = band * 12 + 37;
1108 self.chdata[ch].mant[start + bin] = self.chdata[CPL_CHANNEL].mant[start + bin] * cotemp >> exp;
1114 fn rematrix(&mut self) {
1115 let maxbin = self.chdata[0].endmant.min(self.chdata[1].endmant);
1116 if self.rematflg[0] {
1117 let end = maxbin.min(25);
1118 for bin in 13..end {
1119 let s = self.chdata[0].mant[bin] + self.chdata[1].mant[bin];
1120 let d = self.chdata[0].mant[bin] - self.chdata[1].mant[bin];
1121 self.chdata[0].mant[bin] = d;
1122 self.chdata[1].mant[bin] = s;
1124 if maxbin <= 25 { return; }
1126 if self.rematflg[1] {
1127 let end = maxbin.min(37);
1128 for bin in 25..end {
1129 let s = self.chdata[0].mant[bin] + self.chdata[1].mant[bin];
1130 let d = self.chdata[0].mant[bin] - self.chdata[1].mant[bin];
1131 self.chdata[0].mant[bin] = d;
1132 self.chdata[1].mant[bin] = s;
1134 if maxbin <= 37 { return; }
1136 if self.rematflg[2] {
1137 let end = maxbin.min(61);
1138 for bin in 37..end {
1139 let s = self.chdata[0].mant[bin] + self.chdata[1].mant[bin];
1140 let d = self.chdata[0].mant[bin] - self.chdata[1].mant[bin];
1141 self.chdata[0].mant[bin] = d;
1142 self.chdata[1].mant[bin] = s;
1144 if maxbin <= 61 { return; }
1146 if self.rematflg[3] {
1148 for bin in 61..end {
1149 let s = self.chdata[0].mant[bin] + self.chdata[1].mant[bin];
1150 let d = self.chdata[0].mant[bin] - self.chdata[1].mant[bin];
1151 self.chdata[0].mant[bin] = d;
1152 self.chdata[1].mant[bin] = s;
1156 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]) {
1157 self.chdata[channel].synth(imdct512, imdct256, tmp, delay, dst);
1161 impl NADecoder for AudioDecoder {
1162 fn init(&mut self, info: Rc<NACodecInfo>) -> DecoderResult<()> {
1163 if let NACodecTypeInfo::Audio(_) = info.get_properties() {
1164 self.info = info.clone();
1167 Err(DecoderError::InvalidData)
1170 fn decode(&mut self, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
1171 let info = pkt.get_stream().get_info();
1172 validate!(info.get_properties().is_audio());
1173 let pktbuf = pkt.get_buffer();
1174 validate!(pktbuf.len() > 5);
1177 if (pktbuf[0] == MAGIC_BYTE0) && (pktbuf[1] == MAGIC_BYTE1) {
1178 br = BitReader::new(pktbuf.as_slice(), pktbuf.len(), BitReaderMode::BE);
1179 } else if (pktbuf[0] == MAGIC_BYTE1) && (pktbuf[1] == MAGIC_BYTE0) {
1180 br = BitReader::new(pktbuf.as_slice(), pktbuf.len(), BitReaderMode::LE16MSB);
1182 return Err(DecoderError::InvalidData);
1185 let sinfo = Syncinfo::read(&mut br)?;
1186 validate!(sinfo.is_valid());
1188 let bsi = BSI::read(&mut br)?;
1190 let len = br.read(6)? as u32;
1191 br.skip((len + 1) * 8)?;
1194 let duration = BLOCK_LEN * NBLOCKS;
1196 let core_channels = bsi.acmod.get_num_channels();
1197 let channels = core_channels + if bsi.lfeon { 1 } else { 0 };
1199 let ainfo = NAAudioInfo::new(sinfo.samplerate >> bsi.shift, channels as u8,
1200 SND_F32P_FORMAT, BLOCK_LEN);
1202 let mut abuf = alloc_audio_buffer(ainfo, duration, bsi.acmod.get_channel_map(bsi.lfeon))?;
1203 let mut adata = abuf.get_abuf_f32().unwrap();
1204 let mut output = adata.get_data_mut();
1206 self.ablk = AudioBlock::new();
1207 for blk in 0..NBLOCKS {
1208 let all_zero = self.ablk.read(&mut br, &bsi, sinfo.fscod as usize, blk)?;
1209 let off = blk * BLOCK_LEN;
1210 self.ablk.couple_channels(bsi.acmod);
1211 if bsi.acmod == ACMode::Stereo {
1212 self.ablk.rematrix();
1214 for ch in 0..core_channels {
1215 let dpos = abuf.get_offset(ch) + off;
1216 let dst = &mut output[dpos..][..BLOCK_LEN];
1218 self.ablk.synth_audio_block(&mut self.imdct512, &mut self.imdct256, &mut self.tmp, ch, &mut self.delay[ch], dst);
1220 self.delay[ch] = [0.0; BLOCK_LEN];
1221 for i in 0..BLOCK_LEN { dst[i] = 0.0; }
1225 let dpos = abuf.get_offset(core_channels) + off;
1226 let dst = &mut output[dpos..][..BLOCK_LEN];
1228 self.ablk.synth_audio_block(&mut self.imdct512, &mut self.imdct256, &mut self.tmp, LFE_CHANNEL, &mut self.delay[LFE_CHANNEL], dst);
1230 self.delay[LFE_CHANNEL] = [0.0; BLOCK_LEN];
1231 for i in 0..BLOCK_LEN { dst[i] = 0.0; }
1236 //todo do errorcheck
1238 let mut frm = NAFrame::new_from_pkt(pkt, self.info.replace_info(NACodecTypeInfo::Audio(ainfo)), abuf);
1239 frm.set_keyframe(true);
1240 Ok(Rc::new(RefCell::new(frm)))
1244 pub fn get_decoder() -> Box<NADecoder> {
1245 Box::new(AudioDecoder::new())
1250 use nihav_core::codecs::RegisteredDecoders;
1251 use nihav_core::demuxers::RegisteredDemuxers;
1252 use nihav_core::test::dec_video::test_decode_audio;
1253 use crate::codecs::generic_register_all_codecs;
1254 use nihav_realmedia::demuxers::realmedia_register_all_demuxers;
1256 fn test_ts102366() {
1257 let mut dmx_reg = RegisteredDemuxers::new();
1258 realmedia_register_all_demuxers(&mut dmx_reg);
1259 let mut dec_reg = RegisteredDecoders::new();
1260 generic_register_all_codecs(&mut dec_reg);
1262 let file = "assets/RV/sp_sample1.rm";
1263 test_decode_audio("realmedia", file, Some(12000), "ac3", &dmx_reg, &dec_reg);
1267 const TS102366_SLOW_DECAY: [u8; 4] = [ 0x0F, 0x11, 0x13, 0x15 ];
1268 const TS102366_FAST_DECAY: [u8; 4] = [ 0x3F, 0x53, 0x67, 0x7B ];
1269 const TS102366_SLOW_GAIN: [u16; 4] = [ 0x540, 0x4D8, 0x478, 0x410 ];
1270 const TS102366_FAST_GAIN: [u16; 8] = [ 0x080, 0x100, 0x180, 0x200, 0x280, 0x300, 0x380, 0x400 ];
1271 const TS102366_DBP_TAB: [u16; 4] = [ 0x000, 0x700, 0x900, 0xB00 ];
1272 const TS102366_FLOOR_TAB: [u16; 8] = [ 0x02F0, 0x02B0, 0x0270, 0x0230, 0x01F0, 0x0170, 0x00F0, 0xF800 ];
1274 const TS102366_BIN_TO_BAND: [u8; 256] = [
1275 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
1276 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
1277 20, 21, 22, 23, 24, 25, 26, 27, 28, 28,
1278 28, 29, 29, 29, 30, 30, 30, 31, 31, 31,
1279 32, 32, 32, 33, 33, 33, 34, 34, 34, 35,
1280 35, 35, 35, 35, 35, 36, 36, 36, 36, 36,
1281 36, 37, 37, 37, 37, 37, 37, 38, 38, 38,
1282 38, 38, 38, 39, 39, 39, 39, 39, 39, 40,
1283 40, 40, 40, 40, 40, 41, 41, 41, 41, 41,
1284 41, 41, 41, 41, 41, 41, 41, 42, 42, 42,
1285 42, 42, 42, 42, 42, 42, 42, 42, 42, 43,
1286 43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
1287 43, 44, 44, 44, 44, 44, 44, 44, 44, 44,
1288 44, 44, 44, 45, 45, 45, 45, 45, 45, 45,
1289 45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
1290 45, 45, 45, 45, 45, 45, 45, 46, 46, 46,
1291 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
1292 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
1293 46, 47, 47, 47, 47, 47, 47, 47, 47, 47,
1294 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
1295 47, 47, 47, 47, 47, 48, 48, 48, 48, 48,
1296 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
1297 48, 48, 48, 48, 48, 48, 48, 48, 48, 49,
1298 49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
1299 49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
1302 const TS102366_BAND_SIZE: [u8; MAX_BANDS] = [
1303 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1304 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1305 1, 1, 1, 1, 1, 1, 1, 1, 3, 3,
1306 3, 3, 3, 3, 3, 6, 6, 6, 6, 6,
1307 6, 12, 12, 12, 12, 24, 24, 24, 24, 24
1309 const TS102366_BAND_START: [u8; MAX_BANDS] = [
1310 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
1311 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
1312 20, 21, 22, 23, 24, 25, 26, 27, 28, 31,
1313 34, 37, 40, 43, 46, 49, 55, 61, 67, 73,
1314 79, 85, 97, 109, 121, 133, 157, 181, 205, 229
1317 const TS102366_LATAB: [u16; 256] = [
1318 0x0040, 0x003f, 0x003e, 0x003d, 0x003c, 0x003b, 0x003a, 0x0039,
1319 0x0038, 0x0037, 0x0036, 0x0035, 0x0034, 0x0034, 0x0033, 0x0032,
1320 0x0031, 0x0030, 0x002f, 0x002f, 0x002e, 0x002d, 0x002c, 0x002c,
1321 0x002b, 0x002a, 0x0029, 0x0029, 0x0028, 0x0027, 0x0026, 0x0026,
1322 0x0025, 0x0024, 0x0024, 0x0023, 0x0023, 0x0022, 0x0021, 0x0021,
1323 0x0020, 0x0020, 0x001f, 0x001e, 0x001e, 0x001d, 0x001d, 0x001c,
1324 0x001c, 0x001b, 0x001b, 0x001a, 0x001a, 0x0019, 0x0019, 0x0018,
1325 0x0018, 0x0017, 0x0017, 0x0016, 0x0016, 0x0015, 0x0015, 0x0015,
1326 0x0014, 0x0014, 0x0013, 0x0013, 0x0013, 0x0012, 0x0012, 0x0012,
1327 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0010, 0x000f, 0x000f,
1328 0x000f, 0x000e, 0x000e, 0x000e, 0x000d, 0x000d, 0x000d, 0x000d,
1329 0x000c, 0x000c, 0x000c, 0x000c, 0x000b, 0x000b, 0x000b, 0x000b,
1330 0x000a, 0x000a, 0x000a, 0x000a, 0x000a, 0x0009, 0x0009, 0x0009,
1331 0x0009, 0x0009, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008,
1332 0x0007, 0x0007, 0x0007, 0x0007, 0x0007, 0x0007, 0x0006, 0x0006,
1333 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0005, 0x0005,
1334 0x0005, 0x0005, 0x0005, 0x0005, 0x0005, 0x0005, 0x0004, 0x0004,
1335 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004,
1336 0x0004, 0x0003, 0x0003, 0x0003, 0x0003, 0x0003, 0x0003, 0x0003,
1337 0x0003, 0x0003, 0x0003, 0x0003, 0x0003, 0x0003, 0x0003, 0x0002,
1338 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002,
1339 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002,
1340 0x0002, 0x0002, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001,
1341 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001,
1342 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001,
1343 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001,
1344 0x0001, 0x0001, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
1345 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
1346 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
1347 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
1348 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
1349 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000
1351 const TS102366_HTH: [[u16; MAX_BANDS]; 3] = [
1353 0x04D0, 0x04D0, 0x0440, 0x0400, 0x03E0, 0x03C0, 0x03B0, 0x03B0, 0x03A0, 0x03A0,
1354 0x03A0, 0x03A0, 0x03A0, 0x0390, 0x0390, 0x0390, 0x0380, 0x0380, 0x0370, 0x0370,
1355 0x0360, 0x0360, 0x0350, 0x0350, 0x0340, 0x0340, 0x0330, 0x0320, 0x0310, 0x0300,
1356 0x02F0, 0x02F0, 0x02F0, 0x02F0, 0x0300, 0x0310, 0x0340, 0x0390, 0x03E0, 0x0420,
1357 0x0460, 0x0490, 0x04A0, 0x0460, 0x0440, 0x0440, 0x0520, 0x0800, 0x0840, 0x0840,
1359 0x04F0, 0x04F0, 0x0460, 0x0410, 0x03E0, 0x03D0, 0x03C0, 0x03B0, 0x03B0, 0x03A0,
1360 0x03A0, 0x03A0, 0x03A0, 0x03A0, 0x0390, 0x0390, 0x0390, 0x0380, 0x0380, 0x0380,
1361 0x0370, 0x0370, 0x0360, 0x0360, 0x0350, 0x0350, 0x0340, 0x0340, 0x0320, 0x0310,
1362 0x0300, 0x02F0, 0x02F0, 0x02F0, 0x02F0, 0x0300, 0x0320, 0x0350, 0x0390, 0x03E0,
1363 0x0420, 0x0450, 0x04A0, 0x0490, 0x0460, 0x0440, 0x0480, 0x0630, 0x0840, 0x0840,
1365 0x0580, 0x0580, 0x04B0, 0x0450, 0x0420, 0x03F0, 0x03E0, 0x03D0, 0x03C0, 0x03B0,
1366 0x03B0, 0x03B0, 0x03A0, 0x03A0, 0x03A0, 0x03A0, 0x03A0, 0x03A0, 0x03A0, 0x03A0,
1367 0x0390, 0x0390, 0x0390, 0x0390, 0x0380, 0x0380, 0x0380, 0x0370, 0x0360, 0x0350,
1368 0x0340, 0x0330, 0x0320, 0x0310, 0x0300, 0x02F0, 0x02F0, 0x02F0, 0x0300, 0x0310,
1369 0x0330, 0x0350, 0x03C0, 0x0410, 0x0470, 0x04A0, 0x0460, 0x0440, 0x0450, 0x04E0,
1372 const TS102366_BAPTAB: [u8; 64] = [
1373 0, 1, 1, 1, 1, 1, 2, 2, 3, 3, 3, 4, 4, 5, 5, 6,
1374 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 8, 9, 9, 9, 9, 10,
1375 10, 10, 10, 11, 11, 11, 11, 12, 12, 12, 12, 13, 13, 13, 13, 14,
1376 14, 14, 14, 14, 14, 14, 14, 15, 15, 15, 15, 15, 15, 15, 15, 15
1379 const TS102366_QUANT3_MAP: [[i32; 3]; 27] = [
1380 [ -0x0AAAAAA, -0x0AAAAAA, -0x0AAAAAA ],
1381 [ -0x0AAAAAA, -0x0AAAAAA, 0x00000000 ],
1382 [ -0x0AAAAAA, -0x0AAAAAA, 0x00AAAAAA ],
1383 [ -0x0AAAAAA, 0x00000000, -0x0AAAAAA ],
1384 [ -0x0AAAAAA, 0x00000000, 0x00000000 ],
1385 [ -0x0AAAAAA, 0x00000000, 0x00AAAAAA ],
1386 [ -0x0AAAAAA, 0x00AAAAAA, -0x0AAAAAA ],
1387 [ -0x0AAAAAA, 0x00AAAAAA, 0x00000000 ],
1388 [ -0x0AAAAAA, 0x00AAAAAA, 0x00AAAAAA ],
1389 [ 0x00000000, -0x0AAAAAA, -0x0AAAAAA ],
1390 [ 0x00000000, -0x0AAAAAA, 0x00000000 ],
1391 [ 0x00000000, -0x0AAAAAA, 0x00AAAAAA ],
1392 [ 0x00000000, 0x00000000, -0x0AAAAAA ],
1393 [ 0x00000000, 0x00000000, 0x00000000 ],
1394 [ 0x00000000, 0x00000000, 0x00AAAAAA ],
1395 [ 0x00000000, 0x00AAAAAA, -0x0AAAAAA ],
1396 [ 0x00000000, 0x00AAAAAA, 0x00000000 ],
1397 [ 0x00000000, 0x00AAAAAA, 0x00AAAAAA ],
1398 [ 0x00AAAAAA, -0x0AAAAAA, -0x0AAAAAA ],
1399 [ 0x00AAAAAA, -0x0AAAAAA, 0x00000000 ],
1400 [ 0x00AAAAAA, -0x0AAAAAA, 0x00AAAAAA ],
1401 [ 0x00AAAAAA, 0x00000000, -0x0AAAAAA ],
1402 [ 0x00AAAAAA, 0x00000000, 0x00000000 ],
1403 [ 0x00AAAAAA, 0x00000000, 0x00AAAAAA ],
1404 [ 0x00AAAAAA, 0x00AAAAAA, -0x0AAAAAA ],
1405 [ 0x00AAAAAA, 0x00AAAAAA, 0x00000000 ],
1406 [ 0x00AAAAAA, 0x00AAAAAA, 0x00AAAAAA ]
1408 const TS102366_QUANT5_MAP: [[i32; 3]; 125] = [
1409 [ -0x0CCCCCC, -0x0CCCCCC, -0x0CCCCCC ], [ -0x0CCCCCC, -0x0CCCCCC, -0x0666666 ], [ -0x0CCCCCC, -0x0CCCCCC, 0x00000000 ],
1410 [ -0x0CCCCCC, -0x0CCCCCC, 0x00666666 ], [ -0x0CCCCCC, -0x0CCCCCC, 0x00CCCCCC ],
1411 [ -0x0CCCCCC, -0x0666666, -0x0CCCCCC ], [ -0x0CCCCCC, -0x0666666, -0x0666666 ], [ -0x0CCCCCC, -0x0666666, 0x00000000 ],
1412 [ -0x0CCCCCC, -0x0666666, 0x00666666 ], [ -0x0CCCCCC, -0x0666666, 0x00CCCCCC ],
1413 [ -0x0CCCCCC, 0x00000000, -0x0CCCCCC ], [ -0x0CCCCCC, 0x00000000, -0x0666666 ], [ -0x0CCCCCC, 0x00000000, 0x00000000 ],
1414 [ -0x0CCCCCC, 0x00000000, 0x00666666 ], [ -0x0CCCCCC, 0x00000000, 0x00CCCCCC ],
1415 [ -0x0CCCCCC, 0x00666666, -0x0CCCCCC ], [ -0x0CCCCCC, 0x00666666, -0x0666666 ], [ -0x0CCCCCC, 0x00666666, 0x00000000 ],
1416 [ -0x0CCCCCC, 0x00666666, 0x00666666 ], [ -0x0CCCCCC, 0x00666666, 0x00CCCCCC ],
1417 [ -0x0CCCCCC, 0x00CCCCCC, -0x0CCCCCC ], [ -0x0CCCCCC, 0x00CCCCCC, -0x0666666 ], [ -0x0CCCCCC, 0x00CCCCCC, 0x00000000 ],
1418 [ -0x0CCCCCC, 0x00CCCCCC, 0x00666666 ], [ -0x0CCCCCC, 0x00CCCCCC, 0x00CCCCCC ],
1419 [ -0x0666666, -0x0CCCCCC, -0x0CCCCCC ], [ -0x0666666, -0x0CCCCCC, -0x0666666 ], [ -0x0666666, -0x0CCCCCC, 0x00000000 ],
1420 [ -0x0666666, -0x0CCCCCC, 0x00666666 ], [ -0x0666666, -0x0CCCCCC, 0x00CCCCCC ],
1421 [ -0x0666666, -0x0666666, -0x0CCCCCC ], [ -0x0666666, -0x0666666, -0x0666666 ], [ -0x0666666, -0x0666666, 0x00000000 ],
1422 [ -0x0666666, -0x0666666, 0x00666666 ], [ -0x0666666, -0x0666666, 0x00CCCCCC ],
1423 [ -0x0666666, 0x00000000, -0x0CCCCCC ], [ -0x0666666, 0x00000000, -0x0666666 ], [ -0x0666666, 0x00000000, 0x00000000 ],
1424 [ -0x0666666, 0x00000000, 0x00666666 ], [ -0x0666666, 0x00000000, 0x00CCCCCC ],
1425 [ -0x0666666, 0x00666666, -0x0CCCCCC ], [ -0x0666666, 0x00666666, -0x0666666 ], [ -0x0666666, 0x00666666, 0x00000000 ],
1426 [ -0x0666666, 0x00666666, 0x00666666 ], [ -0x0666666, 0x00666666, 0x00CCCCCC ],
1427 [ -0x0666666, 0x00CCCCCC, -0x0CCCCCC ], [ -0x0666666, 0x00CCCCCC, -0x0666666 ], [ -0x0666666, 0x00CCCCCC, 0x00000000 ],
1428 [ -0x0666666, 0x00CCCCCC, 0x00666666 ], [ -0x0666666, 0x00CCCCCC, 0x00CCCCCC ],
1429 [ 0x00000000, -0x0CCCCCC, -0x0CCCCCC ], [ 0x00000000, -0x0CCCCCC, -0x0666666 ], [ 0x00000000, -0x0CCCCCC, 0x00000000 ],
1430 [ 0x00000000, -0x0CCCCCC, 0x00666666 ], [ 0x00000000, -0x0CCCCCC, 0x00CCCCCC ],
1431 [ 0x00000000, -0x0666666, -0x0CCCCCC ], [ 0x00000000, -0x0666666, -0x0666666 ], [ 0x00000000, -0x0666666, 0x00000000 ],
1432 [ 0x00000000, -0x0666666, 0x00666666 ], [ 0x00000000, -0x0666666, 0x00CCCCCC ],
1433 [ 0x00000000, 0x00000000, -0x0CCCCCC ], [ 0x00000000, 0x00000000, -0x0666666 ], [ 0x00000000, 0x00000000, 0x00000000 ],
1434 [ 0x00000000, 0x00000000, 0x00666666 ], [ 0x00000000, 0x00000000, 0x00CCCCCC ],
1435 [ 0x00000000, 0x00666666, -0x0CCCCCC ], [ 0x00000000, 0x00666666, -0x0666666 ], [ 0x00000000, 0x00666666, 0x00000000 ],
1436 [ 0x00000000, 0x00666666, 0x00666666 ], [ 0x00000000, 0x00666666, 0x00CCCCCC ],
1437 [ 0x00000000, 0x00CCCCCC, -0x0CCCCCC ], [ 0x00000000, 0x00CCCCCC, -0x0666666 ], [ 0x00000000, 0x00CCCCCC, 0x00000000 ],
1438 [ 0x00000000, 0x00CCCCCC, 0x00666666 ], [ 0x00000000, 0x00CCCCCC, 0x00CCCCCC ],
1439 [ 0x00666666, -0x0CCCCCC, -0x0CCCCCC ], [ 0x00666666, -0x0CCCCCC, -0x0666666 ], [ 0x00666666, -0x0CCCCCC, 0x00000000 ],
1440 [ 0x00666666, -0x0CCCCCC, 0x00666666 ], [ 0x00666666, -0x0CCCCCC, 0x00CCCCCC ],
1441 [ 0x00666666, -0x0666666, -0x0CCCCCC ], [ 0x00666666, -0x0666666, -0x0666666 ], [ 0x00666666, -0x0666666, 0x00000000 ],
1442 [ 0x00666666, -0x0666666, 0x00666666 ], [ 0x00666666, -0x0666666, 0x00CCCCCC ],
1443 [ 0x00666666, 0x00000000, -0x0CCCCCC ], [ 0x00666666, 0x00000000, -0x0666666 ], [ 0x00666666, 0x00000000, 0x00000000 ],
1444 [ 0x00666666, 0x00000000, 0x00666666 ], [ 0x00666666, 0x00000000, 0x00CCCCCC ],
1445 [ 0x00666666, 0x00666666, -0x0CCCCCC ], [ 0x00666666, 0x00666666, -0x0666666 ], [ 0x00666666, 0x00666666, 0x00000000 ],
1446 [ 0x00666666, 0x00666666, 0x00666666 ], [ 0x00666666, 0x00666666, 0x00CCCCCC ],
1447 [ 0x00666666, 0x00CCCCCC, -0x0CCCCCC ], [ 0x00666666, 0x00CCCCCC, -0x0666666 ], [ 0x00666666, 0x00CCCCCC, 0x00000000 ],
1448 [ 0x00666666, 0x00CCCCCC, 0x00666666 ], [ 0x00666666, 0x00CCCCCC, 0x00CCCCCC ],
1449 [ 0x00CCCCCC, -0x0CCCCCC, -0x0CCCCCC ], [ 0x00CCCCCC, -0x0CCCCCC, -0x0666666 ], [ 0x00CCCCCC, -0x0CCCCCC, 0x00000000 ],
1450 [ 0x00CCCCCC, -0x0CCCCCC, 0x00666666 ], [ 0x00CCCCCC, -0x0CCCCCC, 0x00CCCCCC ],
1451 [ 0x00CCCCCC, -0x0666666, -0x0CCCCCC ], [ 0x00CCCCCC, -0x0666666, -0x0666666 ], [ 0x00CCCCCC, -0x0666666, 0x00000000 ],
1452 [ 0x00CCCCCC, -0x0666666, 0x00666666 ], [ 0x00CCCCCC, -0x0666666, 0x00CCCCCC ],
1453 [ 0x00CCCCCC, 0x00000000, -0x0CCCCCC ], [ 0x00CCCCCC, 0x00000000, -0x0666666 ], [ 0x00CCCCCC, 0x00000000, 0x00000000 ],
1454 [ 0x00CCCCCC, 0x00000000, 0x00666666 ], [ 0x00CCCCCC, 0x00000000, 0x00CCCCCC ],
1455 [ 0x00CCCCCC, 0x00666666, -0x0CCCCCC ], [ 0x00CCCCCC, 0x00666666, -0x0666666 ], [ 0x00CCCCCC, 0x00666666, 0x00000000 ],
1456 [ 0x00CCCCCC, 0x00666666, 0x00666666 ], [ 0x00CCCCCC, 0x00666666, 0x00CCCCCC ],
1457 [ 0x00CCCCCC, 0x00CCCCCC, -0x0CCCCCC ], [ 0x00CCCCCC, 0x00CCCCCC, -0x0666666 ], [ 0x00CCCCCC, 0x00CCCCCC, 0x00000000 ],
1458 [ 0x00CCCCCC, 0x00CCCCCC, 0x00666666 ], [ 0x00CCCCCC, 0x00CCCCCC, 0x00CCCCCC ],
1460 const TS102366_QUANT7_MAP: [i32; 7] = [
1461 -0xDB6DB6, -0x924924, -0x492492, 0x000000, 0x492492, 0x924924, 0xDB6DB6
1463 const TS102366_QUANT11_MAP: [[i32; 2]; 121] = [
1464 [ -0x0E8BA2E, -0x0E8BA2E ], [ -0x0E8BA2E, -0x0BA2E8B ], [ -0x0E8BA2E, -0x08BA2E8 ],
1465 [ -0x0E8BA2E, -0x05D1745 ], [ -0x0E8BA2E, -0x02E8BA2 ], [ -0x0E8BA2E, 0x00000000 ],
1466 [ -0x0E8BA2E, 0x002E8BA2 ], [ -0x0E8BA2E, 0x005D1745 ], [ -0x0E8BA2E, 0x008BA2E8 ],
1467 [ -0x0E8BA2E, 0x00BA2E8B ], [ -0x0E8BA2E, 0x00E8BA2E ], [ -0x0BA2E8B, -0x0E8BA2E ],
1468 [ -0x0BA2E8B, -0x0BA2E8B ], [ -0x0BA2E8B, -0x08BA2E8 ], [ -0x0BA2E8B, -0x05D1745 ],
1469 [ -0x0BA2E8B, -0x02E8BA2 ], [ -0x0BA2E8B, 0x00000000 ], [ -0x0BA2E8B, 0x002E8BA2 ],
1470 [ -0x0BA2E8B, 0x005D1745 ], [ -0x0BA2E8B, 0x008BA2E8 ], [ -0x0BA2E8B, 0x00BA2E8B ],
1471 [ -0x0BA2E8B, 0x00E8BA2E ], [ -0x08BA2E8, -0x0E8BA2E ], [ -0x08BA2E8, -0x0BA2E8B ],
1472 [ -0x08BA2E8, -0x08BA2E8 ], [ -0x08BA2E8, -0x05D1745 ], [ -0x08BA2E8, -0x02E8BA2 ],
1473 [ -0x08BA2E8, 0x00000000 ], [ -0x08BA2E8, 0x002E8BA2 ], [ -0x08BA2E8, 0x005D1745 ],
1474 [ -0x08BA2E8, 0x008BA2E8 ], [ -0x08BA2E8, 0x00BA2E8B ], [ -0x08BA2E8, 0x00E8BA2E ],
1475 [ -0x05D1745, -0x0E8BA2E ], [ -0x05D1745, -0x0BA2E8B ], [ -0x05D1745, -0x08BA2E8 ],
1476 [ -0x05D1745, -0x05D1745 ], [ -0x05D1745, -0x02E8BA2 ], [ -0x05D1745, 0x00000000 ],
1477 [ -0x05D1745, 0x002E8BA2 ], [ -0x05D1745, 0x005D1745 ], [ -0x05D1745, 0x008BA2E8 ],
1478 [ -0x05D1745, 0x00BA2E8B ], [ -0x05D1745, 0x00E8BA2E ], [ -0x02E8BA2, -0x0E8BA2E ],
1479 [ -0x02E8BA2, -0x0BA2E8B ], [ -0x02E8BA2, -0x08BA2E8 ], [ -0x02E8BA2, -0x05D1745 ],
1480 [ -0x02E8BA2, -0x02E8BA2 ], [ -0x02E8BA2, 0x00000000 ], [ -0x02E8BA2, 0x002E8BA2 ],
1481 [ -0x02E8BA2, 0x005D1745 ], [ -0x02E8BA2, 0x008BA2E8 ], [ -0x02E8BA2, 0x00BA2E8B ],
1482 [ -0x02E8BA2, 0x00E8BA2E ], [ 0x00000000, -0x0E8BA2E ], [ 0x00000000, -0x0BA2E8B ],
1483 [ 0x00000000, -0x08BA2E8 ], [ 0x00000000, -0x05D1745 ], [ 0x00000000, -0x02E8BA2 ],
1484 [ 0x00000000, 0x00000000 ], [ 0x00000000, 0x002E8BA2 ], [ 0x00000000, 0x005D1745 ],
1485 [ 0x00000000, 0x008BA2E8 ], [ 0x00000000, 0x00BA2E8B ], [ 0x00000000, 0x00E8BA2E ],
1486 [ 0x002E8BA2, -0x0E8BA2E ], [ 0x002E8BA2, -0x0BA2E8B ], [ 0x002E8BA2, -0x08BA2E8 ],
1487 [ 0x002E8BA2, -0x05D1745 ], [ 0x002E8BA2, -0x02E8BA2 ], [ 0x002E8BA2, 0x00000000 ],
1488 [ 0x002E8BA2, 0x002E8BA2 ], [ 0x002E8BA2, 0x005D1745 ], [ 0x002E8BA2, 0x008BA2E8 ],
1489 [ 0x002E8BA2, 0x00BA2E8B ], [ 0x002E8BA2, 0x00E8BA2E ], [ 0x005D1745, -0x0E8BA2E ],
1490 [ 0x005D1745, -0x0BA2E8B ], [ 0x005D1745, -0x08BA2E8 ], [ 0x005D1745, -0x05D1745 ],
1491 [ 0x005D1745, -0x02E8BA2 ], [ 0x005D1745, 0x00000000 ], [ 0x005D1745, 0x002E8BA2 ],
1492 [ 0x005D1745, 0x005D1745 ], [ 0x005D1745, 0x008BA2E8 ], [ 0x005D1745, 0x00BA2E8B ],
1493 [ 0x005D1745, 0x00E8BA2E ], [ 0x008BA2E8, -0x0E8BA2E ], [ 0x008BA2E8, -0x0BA2E8B ],
1494 [ 0x008BA2E8, -0x08BA2E8 ], [ 0x008BA2E8, -0x05D1745 ], [ 0x008BA2E8, -0x02E8BA2 ],
1495 [ 0x008BA2E8, 0x00000000 ], [ 0x008BA2E8, 0x002E8BA2 ], [ 0x008BA2E8, 0x005D1745 ],
1496 [ 0x008BA2E8, 0x008BA2E8 ], [ 0x008BA2E8, 0x00BA2E8B ], [ 0x008BA2E8, 0x00E8BA2E ],
1497 [ 0x00BA2E8B, -0x0E8BA2E ], [ 0x00BA2E8B, -0x0BA2E8B ], [ 0x00BA2E8B, -0x08BA2E8 ],
1498 [ 0x00BA2E8B, -0x05D1745 ], [ 0x00BA2E8B, -0x02E8BA2 ], [ 0x00BA2E8B, 0x00000000 ],
1499 [ 0x00BA2E8B, 0x002E8BA2 ], [ 0x00BA2E8B, 0x005D1745 ], [ 0x00BA2E8B, 0x008BA2E8 ],
1500 [ 0x00BA2E8B, 0x00BA2E8B ], [ 0x00BA2E8B, 0x00E8BA2E ], [ 0x00E8BA2E, -0x0E8BA2E ],
1501 [ 0x00E8BA2E, -0x0BA2E8B ], [ 0x00E8BA2E, -0x08BA2E8 ], [ 0x00E8BA2E, -0x05D1745 ],
1502 [ 0x00E8BA2E, -0x02E8BA2 ], [ 0x00E8BA2E, 0x00000000 ], [ 0x00E8BA2E, 0x002E8BA2 ],
1503 [ 0x00E8BA2E, 0x005D1745 ], [ 0x00E8BA2E, 0x008BA2E8 ], [ 0x00E8BA2E, 0x00BA2E8B ],
1504 [ 0x00E8BA2E, 0x00E8BA2E ],
1506 const TS102366_QUANT15_MAP: [i32; 15] = [
1507 -0x0EEEEEE, -0x0CCCCCC, -0x0AAAAAA, -0x0888888, -0x0666666, -0x0444444, -0x0222222, 0x00000000,
1508 0x00222222, 0x00444444, 0x00666666, 0x00888888, 0x00AAAAAA, 0x00CCCCCC, 0x00EEEEEE,
1510 const TS102366_BAP_BITS: [u8; 10] = [ 5, 6, 7, 8, 9, 10, 11, 12, 14, 16 ];
1512 const TS102366_WINDOW: [f32; 256] = [
1513 0.00014, 0.00024, 0.00037, 0.00051, 0.00067, 0.00086, 0.00107, 0.00130,
1514 0.00157, 0.00187, 0.00220, 0.00256, 0.00297, 0.00341, 0.00390, 0.00443,
1515 0.00501, 0.00564, 0.00632, 0.00706, 0.00785, 0.00871, 0.00962, 0.01061,
1516 0.01166, 0.01279, 0.01399, 0.01526, 0.01662, 0.01806, 0.01959, 0.02121,
1517 0.02292, 0.02472, 0.02662, 0.02863, 0.03073, 0.03294, 0.03527, 0.03770,
1518 0.04025, 0.04292, 0.04571, 0.04862, 0.05165, 0.05481, 0.05810, 0.06153,
1519 0.06508, 0.06878, 0.07261, 0.07658, 0.08069, 0.08495, 0.08935, 0.09389,
1520 0.09859, 0.10343, 0.10842, 0.11356, 0.11885, 0.12429, 0.12988, 0.13563,
1521 0.14152, 0.14757, 0.15376, 0.16011, 0.16661, 0.17325, 0.18005, 0.18699,
1522 0.19407, 0.20130, 0.20867, 0.21618, 0.22382, 0.23161, 0.23952, 0.24757,
1523 0.25574, 0.26404, 0.27246, 0.28100, 0.28965, 0.29841, 0.30729, 0.31626,
1524 0.32533, 0.33450, 0.34376, 0.35311, 0.36253, 0.37204, 0.38161, 0.39126,
1525 0.40096, 0.41072, 0.42054, 0.43040, 0.44030, 0.45023, 0.46020, 0.47019,
1526 0.48020, 0.49022, 0.50025, 0.51028, 0.52031, 0.53033, 0.54033, 0.55031,
1527 0.56026, 0.57019, 0.58007, 0.58991, 0.59970, 0.60944, 0.61912, 0.62873,
1528 0.63827, 0.64774, 0.65713, 0.66643, 0.67564, 0.68476, 0.69377, 0.70269,
1529 0.71150, 0.72019, 0.72877, 0.73723, 0.74557, 0.75378, 0.76186, 0.76981,
1530 0.77762, 0.78530, 0.79283, 0.80022, 0.80747, 0.81457, 0.82151, 0.82831,
1531 0.83496, 0.84145, 0.84779, 0.85398, 0.86001, 0.86588, 0.87160, 0.87716,
1532 0.88257, 0.88782, 0.89291, 0.89785, 0.90264, 0.90728, 0.91176, 0.91610,
1533 0.92028, 0.92432, 0.92822, 0.93197, 0.93558, 0.93906, 0.94240, 0.94560,
1534 0.94867, 0.95162, 0.95444, 0.95713, 0.95971, 0.96217, 0.96451, 0.96674,
1535 0.96887, 0.97089, 0.97281, 0.97463, 0.97635, 0.97799, 0.97953, 0.98099,
1536 0.98236, 0.98366, 0.98488, 0.98602, 0.98710, 0.98811, 0.98905, 0.98994,
1537 0.99076, 0.99153, 0.99225, 0.99291, 0.99353, 0.99411, 0.99464, 0.99513,
1538 0.99558, 0.99600, 0.99639, 0.99674, 0.99706, 0.99736, 0.99763, 0.99788,
1539 0.99811, 0.99831, 0.99850, 0.99867, 0.99882, 0.99895, 0.99908, 0.99919,
1540 0.99929, 0.99938, 0.99946, 0.99953, 0.99959, 0.99965, 0.99969, 0.99974,
1541 0.99978, 0.99981, 0.99984, 0.99986, 0.99988, 0.99990, 0.99992, 0.99993,
1542 0.99994, 0.99995, 0.99996, 0.99997, 0.99998, 0.99998, 0.99998, 0.99999,
1543 0.99999, 0.99999, 0.99999, 1.00000, 1.00000, 1.00000, 1.00000, 1.00000,
1544 1.00000, 1.00000, 1.00000, 1.00000, 1.00000, 1.00000, 1.00000, 1.00000,