9 const BLOCK_LEN: usize = 256;
10 const NBLOCKS: usize = 6;
11 const MAX_CHANNELS: usize = 5;
12 const MAX_CPLBANDS: usize = 18;
13 const MAX_BANDS: usize = 50;
15 const MAGIC_BYTE0: u8 = 0x0B;
16 const MAGIC_BYTE1: u8 = 0x77;
18 const STRATEGY_REUSE: u8 = 0;
20 const LFE_CHANNEL: usize = MAX_CHANNELS;
21 const CPL_CHANNEL: usize = MAX_CHANNELS + 1;
24 xsincos: [FFTComplex; BLOCK_LEN/2],
29 struct IMDCTWorkspace {
30 z: [FFTComplex; BLOCK_LEN / 2],
31 y: [FFTComplex; BLOCK_LEN / 2],
32 out: [f32; BLOCK_LEN * 2],
36 fn new(bits: usize) -> Self {
38 let size4 = 1 << (bits - 2);
39 let mut xsincos: [FFTComplex; 512/4] = [FFTC_ZERO; 512/4];
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();
45 let fft = FFTBuilder::new_fft(FFTMode::SplitRadix, size/4);
46 IMDCTContext { xsincos: xsincos, size: size, fft: fft }
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;
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];
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;
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];
93 #[allow(non_snake_case)]
94 fn do_imdct_core(fft: &mut FFT, xsc: &[FFTComplex; BLOCK_LEN/2], size: usize, ilace: bool, coeffs: &[i32], z: &mut [FFTComplex], y: &mut [FFTComplex]) {
98 let scale = 1.0 / ((1 << 24) as f32);
100 let (c0, c1) = if !ilace {
101 ((coeffs[N2 - 2 * k - 1] as f32) * scale,
102 (coeffs[ 2 * k] as f32) * scale)
104 ((coeffs[N - 4 * k - 2] as f32) * scale,
105 (coeffs[ 4 * k] as f32) * scale)
107 let c = FFTComplex { re: c0, im: c1 };
110 fft.do_fft_inplace(z, false);
112 y[k] = z[k] * xsc[k];
116 struct AudioDecoder {
117 info: Rc<NACodecInfo>,
119 imdct512: IMDCTContext,
120 imdct256: IMDCTContext,
122 delay: [[f32; BLOCK_LEN]; MAX_CHANNELS + 1],
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],
137 delay: [[0.0; BLOCK_LEN]; MAX_CHANNELS + 1],
142 const SAMPLE_RATES: [u32; 4] = [ 48000, 44100, 32000, 0 ];
144 const FRAME_SIZES: [[usize; 64]; 4] = [
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,
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,
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,
172 #[derive(Debug,Clone,Copy)]
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 })
191 fn is_valid(&self) -> bool {
192 (self.samplerate != 0) && (self.frame_size != 0)
197 fn read_optional8(&mut self) -> BitReaderResult<Option<u8>>;
198 fn read_optional16(&mut self, bits: u8) -> BitReaderResult<Option<u16>>;
201 impl<'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))
209 fn read_optional16(&mut self, bits: u8) -> BitReaderResult<Option<u16>> {
210 if self.read_bool()? {
211 Ok(Some(self.read(bits)? as u16))
218 #[derive(Debug,Clone,Copy,PartialEq)]
231 fn get_num_channels(&self) -> usize {
233 ACMode::DualMono => 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,
243 fn get_channel_map_str(&self) -> &'static str {
245 ACMode::DualMono => "C,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",
255 fn get_channel_map(&self, has_lfe: bool) -> NAChannelMap {
256 let mut chmap = NAChannelMap::from_str(self.get_channel_map_str()).unwrap();
258 chmap.add_channel(NAChannelType::LFE);
262 fn is_3_x(&self) -> bool {
266 ACMode::Mode3_2 => true,
270 fn is_surround(&self) -> bool {
275 ACMode::Mode3_2 => true,
281 const 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,
288 #[derive(Debug,Clone,Copy)]
293 mixlevel: Option<u8>,
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;
306 (Some(mlev), Some(rt))
310 Ok(Mixinfo { dialnorm, compr, langcod, mixlevel, roomtyp })
314 #[derive(Debug,Clone,Copy)]
321 surmixlev: Option<u8>,
325 mixinfo2: Option<Mixinfo>,
328 timecod1: Option<u16>,
329 timecod2: Option<u16>,
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;
347 let surmixlev = if acmod.is_surround() {
348 let sml = br.read(2)? as u8;
352 let dsurmod = if acmod == ACMode::Stereo {
353 let dsm = br.read(2)? as u8;
357 let lfeon = br.read_bool()?;
358 let mixinfo = Mixinfo::read(br)?;
359 let mixinfo2 = if acmod == ACMode::DualMono {
360 Some(Mixinfo::read(br)?)
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()?;
370 bsid, shift, bsmod, acmod, lfeon,
371 cmixlev, surmixlev, dsurmod,
372 mixinfo: mixinfo, mixinfo2: mixinfo2,
373 copysmth, origbs, timecod1, timecod2, has_addb,
378 #[derive(Clone, Copy)]
385 cplcoexp: [u8; MAX_CPLBANDS],
386 cplcomant: [u8; MAX_CPLBANDS],
415 const GROUPS: [usize; 4] = [ 0, 3, 6, 12 ];
416 const GROUP_BIAS: [usize; 4] = [ 0, 0, 3, 9 ];
418 fn decode_exps(br: &mut BitReader, dst: &mut [u8], mut prev: u8, grplen: usize) -> DecoderResult<()> {
419 let repeat = grplen / 3;
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);
438 macro_rules! read_bap {
439 ($br: expr, $tab:ident, $nbits:expr) => ({
440 let val = $br.read($nbits)? as usize;
441 validate!(val < $tab.len());
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]]
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];
454 $bap_buf_fill[$bufidx] = $tab[0].len() - 1;
468 cplcoexp: [0; MAX_CPLBANDS],
469 cplcomant: [0; MAX_CPLBANDS],
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];
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];
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)?;
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;
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)?;
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;
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;
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;
559 for bin in start..end {
560 psd[bin] = 3072 - ((exps[bin] as i16) << 7);
564 let mut band = TS102366_BIN_TO_BAND[bin] as usize;
567 lastbin = ((TS102366_BAND_START[band] as usize) + (TS102366_BAND_SIZE[band] as usize)).min(end);
568 bndpsd[band] = psd[bin] as i32;
570 while bin < lastbin {
571 bndpsd[band] = logadd(bndpsd[band], psd[bin] as i32);
575 if lastbin >= end { break; }
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;
582 let bndstart = TS102366_BIN_TO_BAND[self.startmant] as usize;
583 let bndend = (TS102366_BIN_TO_BAND[self.endmant - 1] as usize) + 1;
585 let mut excite: [i32; MAX_BANDS] = [0; MAX_BANDS];
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;
596 let mut lowcomp = lowcomp1;
600 let not_lfe_case = (bndend != 7) || (band != 6);
602 lowcomp = calc_lowcomp(lowcomp, self.bndpsd[band], self.bndpsd[band + 1], band);
604 fast_leak = self.bndpsd[band] - fgain;
605 slow_leak = self.bndpsd[band] - (sgain as i32);
606 excite[band] = fast_leak - lowcomp;
608 if self.bndpsd[band] <= self.bndpsd[band + 1] {
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);
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);
625 fast_leak = cplfleak as i32;
626 slow_leak = cplsleak as i32;
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);
633 for band in bndstart..bndend {
634 if self.bndpsd[band] < (dbknee as i32) {
635 excite[band] += ((dbknee as i32) - self.bndpsd[band]) >> 2;
637 mask[band] = excite[band].max(TS102366_HTH[fscod][band >> shift] as i32);
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
648 ((self.deltba[seg] as i32) - 4) << 7
650 if band + self.deltlen[seg] > MAX_BANDS { break; }
651 for _ in 0..self.deltlen[seg] {
658 fn calc_snr_offset(&mut self, csnroffst: u8) {
659 self.snroffset = ((((csnroffst as i32) - 15) << 4) + (self.fsnroffst as i32)) << 2;
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;
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];
675 if lastbin == end { break; }
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] {
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) },
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
702 self.mant[bin] >>= self.exps[bin];
707 fn synth(&mut self, imdct512: &mut IMDCTContext, imdct256: &mut IMDCTContext, tmp: &mut IMDCTWorkspace, delay: &mut [f32; BLOCK_LEN], dst: &mut [f32]) {
709 imdct512.do_imdct(&self.mant, tmp);
711 imdct256.do_imdct_ileave(&self.mant, tmp);
713 overlap(delay, &tmp.out, dst);
717 fn logadd(acc: i32, add: i32) -> i32 {
719 let addr = (c.abs() >> 1).min(255);
721 acc + (TS102366_LATAB[addr as usize] as i32)
723 add + (TS102366_LATAB[addr as usize] as i32)
727 fn calc_lowcomp(a: i32, b0: i32, b1: i32, band: usize) -> i32 {
729 if (b0 + 256) == b1 {
736 } else if band < 20 {
737 if (b0 + 256) == b1 {
749 fn overlap(delay: &mut [f32; BLOCK_LEN], src: &[f32; BLOCK_LEN * 2], out: &mut [f32]) {
752 for ((d, s), o) in dly.into_iter().zip(src.into_iter()).zip(out.iter_mut()) {
753 *o = (*d + *s) * 2.0;
756 delay.copy_from_slice(&src[BLOCK_LEN..]);
771 cplbndstrc: [bool; MAX_CPLBANDS],
773 phsflg: [bool; MAX_CPLBANDS],
777 chdata: [ChannelData; MAX_CHANNELS + 2],
793 bap_buf: [[i32; 2]; 3],
794 bap_buf_fill: [usize; 3],
800 chdata: [ChannelData::new(); MAX_CHANNELS + 2],
812 cplbndstrc: [false; MAX_CPLBANDS],
814 phsflg: [false; MAX_CPLBANDS],
816 rematflg: [false; 4],
832 bap_buf: [[0; 2]; 3],
833 bap_buf_fill: [0; 3],
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;
840 for ch in 0..channels {
841 self.chdata[ch].blksw = br.read_bool()?;
843 // dynamic range information
844 for ch in 0..channels {
845 self.chdata[ch].dithflag = br.read_bool()?;
847 self.dynrng = br.read_optional8()?;
848 if bsi.acmod == ACMode::DualMono {
849 self.dynrng2 = br.read_optional8()?;
851 // coupling strategy information
852 self.cplstre = br.read_bool()?;
853 validate!((blk_no != 0) || self.cplstre);
855 self.cplinu = br.read_bool()?;
857 for ch in 0..channels {
858 self.chdata[ch].chincpl = br.read_bool()?;
861 self.phsflginu = br.read_bool()?;
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] {
878 // coupling coordinates
880 for c in 0..channels {
881 let ch = &mut self.chdata[c];
883 ch.cplcoe = br.read_bool()?;
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;
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()?;
899 for ch in 0..channels {
900 self.chdata[ch].chincpl = false;
903 // stereo rematrixing
905 self.rematstr = br.read_bool()?;
907 if self.cplbegf > 2 || !self.cplinu {
909 self.rematflg[rbnd] = br.read_bool()?;
912 if self.cplbegf > 0 && self.cplbegf <= 2 && self.cplinu {
914 self.rematflg[rbnd] = br.read_bool()?;
917 if self.cplbegf == 0 && self.cplinu {
919 self.rematflg[rbnd] = br.read_bool()?;
926 self.chdata[CPL_CHANNEL].read_strategy(br, blk_no)?;
928 for ch in 0..channels {
929 self.chdata[ch].read_strategy(br, blk_no)?;
932 self.chdata[LFE_CHANNEL].expstr = br.read(1)? as u8;
933 validate!(blk_no != 0 || self.chdata[LFE_CHANNEL].expstr != STRATEGY_REUSE);
934 self.chdata[LFE_CHANNEL].groups = 2;
935 self.chdata[LFE_CHANNEL].startmant = 0;
936 self.chdata[LFE_CHANNEL].endmant = 7;
938 let cpl_startmant = self.chdata[CPL_CHANNEL].startmant;
939 for c in 0..channels {
940 let ch = &mut self.chdata[c];
941 if ch.expstr != STRATEGY_REUSE && !ch.chincpl {
942 ch.chbwcod = br.read(6)? as u8;
946 ch.endmant = ((ch.chbwcod as usize) + 12) * 3 + 37;
949 ch.endmant = cpl_startmant;
952 // set number of mantissas
954 self.chdata[CPL_CHANNEL].read_exps(br, true, false)?;
956 for ch in 0..channels {
957 self.chdata[ch].read_exps(br, false, false)?;
960 self.chdata[LFE_CHANNEL].read_exps(br, false, true)?;
962 // bit allocation parameters
963 self.baie = br.read_bool()?;
965 self.sdcycod = br.read(2)? as usize;
966 self.fdcycod = br.read(2)? as usize;
967 self.sgaincod = br.read(2)? as usize;
968 self.dbpbcod = br.read(2)? as usize;
969 self.floorcod = br.read(3)? as usize;
971 self.snroffste = br.read_bool()?;
973 self.csnroffst = br.read(6)? as u8;
975 self.chdata[CPL_CHANNEL].read_snr(br)?;
977 for ch in 0..channels {
978 self.chdata[ch].read_snr(br)?;
981 self.chdata[LFE_CHANNEL].read_snr(br)?;
985 self.cplleake = br.read_bool()?;
987 self.cplfleak = br.read(3)? as u8;
988 self.cplsleak = br.read(3)? as u8;
991 // delta bit allocation information
992 self.deltbaie = br.read_bool()?;
995 self.chdata[CPL_CHANNEL].deltbae = br.read(2)? as u8;
996 validate!(blk_no != 0 || self.chdata[CPL_CHANNEL].deltbae != 0);
997 validate!(self.chdata[CPL_CHANNEL].deltbae != 3);
999 for ch in 0..channels {
1000 self.chdata[ch].deltbae = br.read(2)? as u8;
1001 validate!(blk_no != 0 || self.chdata[ch].deltbae != 0);
1002 validate!(self.chdata[ch].deltbae != 3);
1005 self.chdata[CPL_CHANNEL].read_deltbai(br)?;
1007 for ch in 0..channels {
1008 self.chdata[ch].read_deltbai(br)?;
1012 if br.read_bool()? {
1013 let skipl = br.read(9)?;
1014 br.skip(skipl * 8)?;
1017 let all_zero = self.calc_bitalloc(bsi, channels, fscod);
1018 if all_zero { return Ok(true); }
1020 // quantised mantissa values
1021 let mut got_cplchan = false;
1022 for i in 0..self.bap_buf_fill.len() { self.bap_buf_fill[i] = 0; }
1023 for c in 0..channels {
1025 let ch = &mut self.chdata[c];
1026 ch.read_mant(br, &mut self.bap_buf, &mut self.bap_buf_fill)?;
1028 if self.cplinu && self.chdata[c].chincpl && !got_cplchan {
1029 let cplch = &mut self.chdata[CPL_CHANNEL];
1030 cplch.read_mant(br, &mut self.bap_buf, &mut self.bap_buf_fill)?;
1035 let lfech = &mut self.chdata[LFE_CHANNEL];
1036 lfech.read_mant(br, &mut self.bap_buf, &mut self.bap_buf_fill)?;
1040 fn calc_bitalloc(&mut self, bsi: &BSI, channels: usize, fscod: usize) -> bool {
1041 let sdecay1 = TS102366_SLOW_DECAY[self.sdcycod];
1042 let fdecay1 = TS102366_FAST_DECAY[self.fdcycod];
1044 let sdecay = sdecay1 >> bsi.shift;
1045 let fdecay = fdecay1 >> bsi.shift;
1046 let sgain = TS102366_SLOW_GAIN[self.sgaincod];
1047 let dbknee = TS102366_DBP_TAB[self.dbpbcod];
1048 let floor = TS102366_FLOOR_TAB[self.floorcod];
1050 let mut all_zero = self.csnroffst == 0;
1051 if !all_zero && self.chdata[LFE_CHANNEL].fsnroffst == 0 {
1052 for ch in 0..channels {
1053 if self.chdata[ch].fsnroffst != 0 {
1059 if all_zero { return true; }
1061 let mut mask: [i32; MAX_BANDS] = [0; MAX_BANDS];
1064 self.chdata[CPL_CHANNEL].compute_bndpsd();
1065 self.chdata[CPL_CHANNEL].compute_mask(&mut mask, fscod, sgain, fdecay, sdecay, dbknee,
1066 ((self.cplfleak as u16) << 8) + 768, ((self.cplsleak as u16) << 8) + 768, bsi.shift);
1067 self.chdata[CPL_CHANNEL].apply_delta_info(&mut mask);
1068 self.chdata[CPL_CHANNEL].calc_snr_offset(self.csnroffst);
1069 self.chdata[CPL_CHANNEL].compute_bap(&mut mask, floor);
1071 for ch in 0..channels {
1072 self.chdata[ch].compute_bndpsd();
1073 self.chdata[ch].compute_mask(&mut mask, fscod, sgain, fdecay, sdecay, dbknee, 0, 0, bsi.shift);
1074 self.chdata[ch].apply_delta_info(&mut mask);
1075 self.chdata[ch].calc_snr_offset(self.csnroffst);
1076 self.chdata[ch].compute_bap(&mut mask, floor);
1079 self.chdata[LFE_CHANNEL].compute_bndpsd();
1080 self.chdata[LFE_CHANNEL].compute_mask(&mut mask, fscod, sgain, fdecay, sdecay, dbknee,
1082 self.chdata[LFE_CHANNEL].calc_snr_offset(self.csnroffst);
1083 self.chdata[LFE_CHANNEL].compute_bap(&mut mask, floor);
1088 fn couple_channels(&mut self, acmod: ACMode) {
1089 if !self.cplinu { return; }
1090 for ch in 0..acmod.get_num_channels() {
1091 if !self.chdata[ch].chincpl { continue; }
1093 for band in self.cplbegf..self.cplendf {
1094 let cband = band - self.cplbegf;
1095 let comant = self.chdata[ch].cplcomant[cband];
1096 let mut cotemp = (if self.chdata[ch].cplcoexp[cband] == 15 { comant << 1 } else { comant + 16 }) as i32;
1097 if (acmod == ACMode::Stereo) && (ch == 1) && self.phsflginu && self.phsflg[pband] {
1100 if !self.cplbndstrc[cband] {
1103 let exp = self.chdata[ch].cplcoexp[cband] + 3 * self.chdata[ch].mstrcplco + 5 - 3;
1104 let start = band * 12 + 37;
1106 self.chdata[ch].mant[start + bin] = self.chdata[CPL_CHANNEL].mant[start + bin] * cotemp >> exp;
1112 fn rematrix(&mut self) {
1113 let maxbin = self.chdata[0].endmant.min(self.chdata[1].endmant);
1114 if self.rematflg[0] {
1115 let end = maxbin.min(25);
1116 for bin in 13..end {
1117 let s = self.chdata[0].mant[bin] + self.chdata[1].mant[bin];
1118 let d = self.chdata[0].mant[bin] - self.chdata[1].mant[bin];
1119 self.chdata[0].mant[bin] = d;
1120 self.chdata[1].mant[bin] = s;
1122 if maxbin <= 25 { return; }
1124 if self.rematflg[1] {
1125 let end = maxbin.min(37);
1126 for bin in 25..end {
1127 let s = self.chdata[0].mant[bin] + self.chdata[1].mant[bin];
1128 let d = self.chdata[0].mant[bin] - self.chdata[1].mant[bin];
1129 self.chdata[0].mant[bin] = d;
1130 self.chdata[1].mant[bin] = s;
1132 if maxbin <= 37 { return; }
1134 if self.rematflg[2] {
1135 let end = maxbin.min(61);
1136 for bin in 37..end {
1137 let s = self.chdata[0].mant[bin] + self.chdata[1].mant[bin];
1138 let d = self.chdata[0].mant[bin] - self.chdata[1].mant[bin];
1139 self.chdata[0].mant[bin] = d;
1140 self.chdata[1].mant[bin] = s;
1142 if maxbin <= 61 { return; }
1144 if self.rematflg[3] {
1146 for bin in 61..end {
1147 let s = self.chdata[0].mant[bin] + self.chdata[1].mant[bin];
1148 let d = self.chdata[0].mant[bin] - self.chdata[1].mant[bin];
1149 self.chdata[0].mant[bin] = d;
1150 self.chdata[1].mant[bin] = s;
1154 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]) {
1155 self.chdata[channel].synth(imdct512, imdct256, tmp, delay, dst);
1159 impl NADecoder for AudioDecoder {
1160 fn init(&mut self, info: Rc<NACodecInfo>) -> DecoderResult<()> {
1161 if let NACodecTypeInfo::Audio(_) = info.get_properties() {
1162 self.info = info.clone();
1165 Err(DecoderError::InvalidData)
1168 fn decode(&mut self, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
1169 let info = pkt.get_stream().get_info();
1170 validate!(info.get_properties().is_audio());
1171 let pktbuf = pkt.get_buffer();
1172 validate!(pktbuf.len() > 5);
1175 if (pktbuf[0] == MAGIC_BYTE0) && (pktbuf[1] == MAGIC_BYTE1) {
1176 br = BitReader::new(pktbuf.as_slice(), pktbuf.len(), BitReaderMode::BE);
1177 } else if (pktbuf[0] == MAGIC_BYTE1) && (pktbuf[1] == MAGIC_BYTE0) {
1178 br = BitReader::new(pktbuf.as_slice(), pktbuf.len(), BitReaderMode::LE16MSB);
1180 return Err(DecoderError::InvalidData);
1183 let sinfo = Syncinfo::read(&mut br)?;
1184 validate!(sinfo.is_valid());
1186 let bsi = BSI::read(&mut br)?;
1188 let len = br.read(6)? as u32;
1189 br.skip((len + 1) * 8)?;
1192 let duration = BLOCK_LEN * NBLOCKS;
1194 let core_channels = bsi.acmod.get_num_channels();
1195 let channels = core_channels + if bsi.lfeon { 1 } else { 0 };
1197 let ainfo = NAAudioInfo::new(sinfo.samplerate >> bsi.shift, channels as u8,
1198 SND_F32P_FORMAT, BLOCK_LEN);
1200 let mut abuf = alloc_audio_buffer(ainfo, duration, bsi.acmod.get_channel_map(bsi.lfeon))?;
1201 let mut adata = abuf.get_abuf_f32().unwrap();
1202 let mut output = adata.get_data_mut();
1204 self.ablk = AudioBlock::new();
1205 for blk in 0..NBLOCKS {
1206 let all_zero = self.ablk.read(&mut br, &bsi, sinfo.fscod as usize, blk)?;
1207 let off = blk * BLOCK_LEN;
1208 self.ablk.couple_channels(bsi.acmod);
1209 if bsi.acmod == ACMode::Stereo {
1210 self.ablk.rematrix();
1212 for ch in 0..core_channels {
1213 let dpos = abuf.get_offset(ch) + off;
1214 let dst = &mut output[dpos..][..BLOCK_LEN];
1216 self.ablk.synth_audio_block(&mut self.imdct512, &mut self.imdct256, &mut self.tmp, ch, &mut self.delay[ch], dst);
1218 self.delay[ch] = [0.0; BLOCK_LEN];
1219 for i in 0..BLOCK_LEN { dst[i] = 0.0; }
1223 let dpos = abuf.get_offset(core_channels) + off;
1224 let dst = &mut output[dpos..][..BLOCK_LEN];
1226 self.ablk.synth_audio_block(&mut self.imdct512, &mut self.imdct256, &mut self.tmp, LFE_CHANNEL, &mut self.delay[LFE_CHANNEL], dst);
1228 self.delay[LFE_CHANNEL] = [0.0; BLOCK_LEN];
1229 for i in 0..BLOCK_LEN { dst[i] = 0.0; }
1234 //todo do errorcheck
1236 let mut frm = NAFrame::new_from_pkt(pkt, self.info.replace_info(NACodecTypeInfo::Audio(ainfo)), abuf);
1237 frm.set_keyframe(true);
1238 Ok(Rc::new(RefCell::new(frm)))
1242 pub fn get_decoder() -> Box<NADecoder> {
1243 Box::new(AudioDecoder::new())
1248 use test::dec_video::*;
1250 fn test_ts102366() {
1251 let file = "assets/RV/sp_sample1.rm";
1252 test_decode_audio("realmedia", file, Some(12000), "ac3");
1256 const TS102366_SLOW_DECAY: [u8; 4] = [ 0x0F, 0x11, 0x13, 0x15 ];
1257 const TS102366_FAST_DECAY: [u8; 4] = [ 0x3F, 0x53, 0x67, 0x7B ];
1258 const TS102366_SLOW_GAIN: [u16; 4] = [ 0x540, 0x4D8, 0x478, 0x410 ];
1259 const TS102366_FAST_GAIN: [u16; 8] = [ 0x080, 0x100, 0x180, 0x200, 0x280, 0x300, 0x380, 0x400 ];
1260 const TS102366_DBP_TAB: [u16; 4] = [ 0x000, 0x700, 0x900, 0xB00 ];
1261 const TS102366_FLOOR_TAB: [u16; 8] = [ 0x02F0, 0x02B0, 0x0270, 0x0230, 0x01F0, 0x0170, 0x00F0, 0xF800 ];
1263 const TS102366_BIN_TO_BAND: [u8; 256] = [
1264 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
1265 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
1266 20, 21, 22, 23, 24, 25, 26, 27, 28, 28,
1267 28, 29, 29, 29, 30, 30, 30, 31, 31, 31,
1268 32, 32, 32, 33, 33, 33, 34, 34, 34, 35,
1269 35, 35, 35, 35, 35, 36, 36, 36, 36, 36,
1270 36, 37, 37, 37, 37, 37, 37, 38, 38, 38,
1271 38, 38, 38, 39, 39, 39, 39, 39, 39, 40,
1272 40, 40, 40, 40, 40, 41, 41, 41, 41, 41,
1273 41, 41, 41, 41, 41, 41, 41, 42, 42, 42,
1274 42, 42, 42, 42, 42, 42, 42, 42, 42, 43,
1275 43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
1276 43, 44, 44, 44, 44, 44, 44, 44, 44, 44,
1277 44, 44, 44, 45, 45, 45, 45, 45, 45, 45,
1278 45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
1279 45, 45, 45, 45, 45, 45, 45, 46, 46, 46,
1280 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
1281 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
1282 46, 47, 47, 47, 47, 47, 47, 47, 47, 47,
1283 47, 47, 47, 47, 47, 47, 47, 47, 47, 47,
1284 47, 47, 47, 47, 47, 48, 48, 48, 48, 48,
1285 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
1286 48, 48, 48, 48, 48, 48, 48, 48, 48, 49,
1287 49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
1288 49, 49, 49, 49, 49, 49, 49, 49, 49, 49,
1291 const TS102366_BAND_SIZE: [u8; MAX_BANDS] = [
1292 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1293 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1294 1, 1, 1, 1, 1, 1, 1, 1, 3, 3,
1295 3, 3, 3, 3, 3, 6, 6, 6, 6, 6,
1296 6, 12, 12, 12, 12, 24, 24, 24, 24, 24
1298 const TS102366_BAND_START: [u8; MAX_BANDS] = [
1299 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
1300 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
1301 20, 21, 22, 23, 24, 25, 26, 27, 28, 31,
1302 34, 37, 40, 43, 46, 49, 55, 61, 67, 73,
1303 79, 85, 97, 109, 121, 133, 157, 181, 205, 229
1306 const TS102366_LATAB: [u16; 256] = [
1307 0x0040, 0x003f, 0x003e, 0x003d, 0x003c, 0x003b, 0x003a, 0x0039,
1308 0x0038, 0x0037, 0x0036, 0x0035, 0x0034, 0x0034, 0x0033, 0x0032,
1309 0x0031, 0x0030, 0x002f, 0x002f, 0x002e, 0x002d, 0x002c, 0x002c,
1310 0x002b, 0x002a, 0x0029, 0x0029, 0x0028, 0x0027, 0x0026, 0x0026,
1311 0x0025, 0x0024, 0x0024, 0x0023, 0x0023, 0x0022, 0x0021, 0x0021,
1312 0x0020, 0x0020, 0x001f, 0x001e, 0x001e, 0x001d, 0x001d, 0x001c,
1313 0x001c, 0x001b, 0x001b, 0x001a, 0x001a, 0x0019, 0x0019, 0x0018,
1314 0x0018, 0x0017, 0x0017, 0x0016, 0x0016, 0x0015, 0x0015, 0x0015,
1315 0x0014, 0x0014, 0x0013, 0x0013, 0x0013, 0x0012, 0x0012, 0x0012,
1316 0x0011, 0x0011, 0x0011, 0x0010, 0x0010, 0x0010, 0x000f, 0x000f,
1317 0x000f, 0x000e, 0x000e, 0x000e, 0x000d, 0x000d, 0x000d, 0x000d,
1318 0x000c, 0x000c, 0x000c, 0x000c, 0x000b, 0x000b, 0x000b, 0x000b,
1319 0x000a, 0x000a, 0x000a, 0x000a, 0x000a, 0x0009, 0x0009, 0x0009,
1320 0x0009, 0x0009, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008,
1321 0x0007, 0x0007, 0x0007, 0x0007, 0x0007, 0x0007, 0x0006, 0x0006,
1322 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0006, 0x0005, 0x0005,
1323 0x0005, 0x0005, 0x0005, 0x0005, 0x0005, 0x0005, 0x0004, 0x0004,
1324 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004,
1325 0x0004, 0x0003, 0x0003, 0x0003, 0x0003, 0x0003, 0x0003, 0x0003,
1326 0x0003, 0x0003, 0x0003, 0x0003, 0x0003, 0x0003, 0x0003, 0x0002,
1327 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002,
1328 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002, 0x0002,
1329 0x0002, 0x0002, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001,
1330 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001,
1331 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001,
1332 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001, 0x0001,
1333 0x0001, 0x0001, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
1334 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
1335 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
1336 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
1337 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
1338 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000
1340 const TS102366_HTH: [[u16; MAX_BANDS]; 3] = [
1342 0x04D0, 0x04D0, 0x0440, 0x0400, 0x03E0, 0x03C0, 0x03B0, 0x03B0, 0x03A0, 0x03A0,
1343 0x03A0, 0x03A0, 0x03A0, 0x0390, 0x0390, 0x0390, 0x0380, 0x0380, 0x0370, 0x0370,
1344 0x0360, 0x0360, 0x0350, 0x0350, 0x0340, 0x0340, 0x0330, 0x0320, 0x0310, 0x0300,
1345 0x02F0, 0x02F0, 0x02F0, 0x02F0, 0x0300, 0x0310, 0x0340, 0x0390, 0x03E0, 0x0420,
1346 0x0460, 0x0490, 0x04A0, 0x0460, 0x0440, 0x0440, 0x0520, 0x0800, 0x0840, 0x0840,
1348 0x04F0, 0x04F0, 0x0460, 0x0410, 0x03E0, 0x03D0, 0x03C0, 0x03B0, 0x03B0, 0x03A0,
1349 0x03A0, 0x03A0, 0x03A0, 0x03A0, 0x0390, 0x0390, 0x0390, 0x0380, 0x0380, 0x0380,
1350 0x0370, 0x0370, 0x0360, 0x0360, 0x0350, 0x0350, 0x0340, 0x0340, 0x0320, 0x0310,
1351 0x0300, 0x02F0, 0x02F0, 0x02F0, 0x02F0, 0x0300, 0x0320, 0x0350, 0x0390, 0x03E0,
1352 0x0420, 0x0450, 0x04A0, 0x0490, 0x0460, 0x0440, 0x0480, 0x0630, 0x0840, 0x0840,
1354 0x0580, 0x0580, 0x04B0, 0x0450, 0x0420, 0x03F0, 0x03E0, 0x03D0, 0x03C0, 0x03B0,
1355 0x03B0, 0x03B0, 0x03A0, 0x03A0, 0x03A0, 0x03A0, 0x03A0, 0x03A0, 0x03A0, 0x03A0,
1356 0x0390, 0x0390, 0x0390, 0x0390, 0x0380, 0x0380, 0x0380, 0x0370, 0x0360, 0x0350,
1357 0x0340, 0x0330, 0x0320, 0x0310, 0x0300, 0x02F0, 0x02F0, 0x02F0, 0x0300, 0x0310,
1358 0x0330, 0x0350, 0x03C0, 0x0410, 0x0470, 0x04A0, 0x0460, 0x0440, 0x0450, 0x04E0,
1361 const TS102366_BAPTAB: [u8; 64] = [
1362 0, 1, 1, 1, 1, 1, 2, 2, 3, 3, 3, 4, 4, 5, 5, 6,
1363 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 8, 9, 9, 9, 9, 10,
1364 10, 10, 10, 11, 11, 11, 11, 12, 12, 12, 12, 13, 13, 13, 13, 14,
1365 14, 14, 14, 14, 14, 14, 14, 15, 15, 15, 15, 15, 15, 15, 15, 15
1368 const TS102366_QUANT3_MAP: [[i32; 3]; 27] = [
1369 [ -0x0AAAAAA, -0x0AAAAAA, -0x0AAAAAA ],
1370 [ -0x0AAAAAA, -0x0AAAAAA, 0x00000000 ],
1371 [ -0x0AAAAAA, -0x0AAAAAA, 0x00AAAAAA ],
1372 [ -0x0AAAAAA, 0x00000000, -0x0AAAAAA ],
1373 [ -0x0AAAAAA, 0x00000000, 0x00000000 ],
1374 [ -0x0AAAAAA, 0x00000000, 0x00AAAAAA ],
1375 [ -0x0AAAAAA, 0x00AAAAAA, -0x0AAAAAA ],
1376 [ -0x0AAAAAA, 0x00AAAAAA, 0x00000000 ],
1377 [ -0x0AAAAAA, 0x00AAAAAA, 0x00AAAAAA ],
1378 [ 0x00000000, -0x0AAAAAA, -0x0AAAAAA ],
1379 [ 0x00000000, -0x0AAAAAA, 0x00000000 ],
1380 [ 0x00000000, -0x0AAAAAA, 0x00AAAAAA ],
1381 [ 0x00000000, 0x00000000, -0x0AAAAAA ],
1382 [ 0x00000000, 0x00000000, 0x00000000 ],
1383 [ 0x00000000, 0x00000000, 0x00AAAAAA ],
1384 [ 0x00000000, 0x00AAAAAA, -0x0AAAAAA ],
1385 [ 0x00000000, 0x00AAAAAA, 0x00000000 ],
1386 [ 0x00000000, 0x00AAAAAA, 0x00AAAAAA ],
1387 [ 0x00AAAAAA, -0x0AAAAAA, -0x0AAAAAA ],
1388 [ 0x00AAAAAA, -0x0AAAAAA, 0x00000000 ],
1389 [ 0x00AAAAAA, -0x0AAAAAA, 0x00AAAAAA ],
1390 [ 0x00AAAAAA, 0x00000000, -0x0AAAAAA ],
1391 [ 0x00AAAAAA, 0x00000000, 0x00000000 ],
1392 [ 0x00AAAAAA, 0x00000000, 0x00AAAAAA ],
1393 [ 0x00AAAAAA, 0x00AAAAAA, -0x0AAAAAA ],
1394 [ 0x00AAAAAA, 0x00AAAAAA, 0x00000000 ],
1395 [ 0x00AAAAAA, 0x00AAAAAA, 0x00AAAAAA ]
1397 const TS102366_QUANT5_MAP: [[i32; 3]; 125] = [
1398 [ -0x0CCCCCC, -0x0CCCCCC, -0x0CCCCCC ], [ -0x0CCCCCC, -0x0CCCCCC, -0x0666666 ], [ -0x0CCCCCC, -0x0CCCCCC, 0x00000000 ],
1399 [ -0x0CCCCCC, -0x0CCCCCC, 0x00666666 ], [ -0x0CCCCCC, -0x0CCCCCC, 0x00CCCCCC ],
1400 [ -0x0CCCCCC, -0x0666666, -0x0CCCCCC ], [ -0x0CCCCCC, -0x0666666, -0x0666666 ], [ -0x0CCCCCC, -0x0666666, 0x00000000 ],
1401 [ -0x0CCCCCC, -0x0666666, 0x00666666 ], [ -0x0CCCCCC, -0x0666666, 0x00CCCCCC ],
1402 [ -0x0CCCCCC, 0x00000000, -0x0CCCCCC ], [ -0x0CCCCCC, 0x00000000, -0x0666666 ], [ -0x0CCCCCC, 0x00000000, 0x00000000 ],
1403 [ -0x0CCCCCC, 0x00000000, 0x00666666 ], [ -0x0CCCCCC, 0x00000000, 0x00CCCCCC ],
1404 [ -0x0CCCCCC, 0x00666666, -0x0CCCCCC ], [ -0x0CCCCCC, 0x00666666, -0x0666666 ], [ -0x0CCCCCC, 0x00666666, 0x00000000 ],
1405 [ -0x0CCCCCC, 0x00666666, 0x00666666 ], [ -0x0CCCCCC, 0x00666666, 0x00CCCCCC ],
1406 [ -0x0CCCCCC, 0x00CCCCCC, -0x0CCCCCC ], [ -0x0CCCCCC, 0x00CCCCCC, -0x0666666 ], [ -0x0CCCCCC, 0x00CCCCCC, 0x00000000 ],
1407 [ -0x0CCCCCC, 0x00CCCCCC, 0x00666666 ], [ -0x0CCCCCC, 0x00CCCCCC, 0x00CCCCCC ],
1408 [ -0x0666666, -0x0CCCCCC, -0x0CCCCCC ], [ -0x0666666, -0x0CCCCCC, -0x0666666 ], [ -0x0666666, -0x0CCCCCC, 0x00000000 ],
1409 [ -0x0666666, -0x0CCCCCC, 0x00666666 ], [ -0x0666666, -0x0CCCCCC, 0x00CCCCCC ],
1410 [ -0x0666666, -0x0666666, -0x0CCCCCC ], [ -0x0666666, -0x0666666, -0x0666666 ], [ -0x0666666, -0x0666666, 0x00000000 ],
1411 [ -0x0666666, -0x0666666, 0x00666666 ], [ -0x0666666, -0x0666666, 0x00CCCCCC ],
1412 [ -0x0666666, 0x00000000, -0x0CCCCCC ], [ -0x0666666, 0x00000000, -0x0666666 ], [ -0x0666666, 0x00000000, 0x00000000 ],
1413 [ -0x0666666, 0x00000000, 0x00666666 ], [ -0x0666666, 0x00000000, 0x00CCCCCC ],
1414 [ -0x0666666, 0x00666666, -0x0CCCCCC ], [ -0x0666666, 0x00666666, -0x0666666 ], [ -0x0666666, 0x00666666, 0x00000000 ],
1415 [ -0x0666666, 0x00666666, 0x00666666 ], [ -0x0666666, 0x00666666, 0x00CCCCCC ],
1416 [ -0x0666666, 0x00CCCCCC, -0x0CCCCCC ], [ -0x0666666, 0x00CCCCCC, -0x0666666 ], [ -0x0666666, 0x00CCCCCC, 0x00000000 ],
1417 [ -0x0666666, 0x00CCCCCC, 0x00666666 ], [ -0x0666666, 0x00CCCCCC, 0x00CCCCCC ],
1418 [ 0x00000000, -0x0CCCCCC, -0x0CCCCCC ], [ 0x00000000, -0x0CCCCCC, -0x0666666 ], [ 0x00000000, -0x0CCCCCC, 0x00000000 ],
1419 [ 0x00000000, -0x0CCCCCC, 0x00666666 ], [ 0x00000000, -0x0CCCCCC, 0x00CCCCCC ],
1420 [ 0x00000000, -0x0666666, -0x0CCCCCC ], [ 0x00000000, -0x0666666, -0x0666666 ], [ 0x00000000, -0x0666666, 0x00000000 ],
1421 [ 0x00000000, -0x0666666, 0x00666666 ], [ 0x00000000, -0x0666666, 0x00CCCCCC ],
1422 [ 0x00000000, 0x00000000, -0x0CCCCCC ], [ 0x00000000, 0x00000000, -0x0666666 ], [ 0x00000000, 0x00000000, 0x00000000 ],
1423 [ 0x00000000, 0x00000000, 0x00666666 ], [ 0x00000000, 0x00000000, 0x00CCCCCC ],
1424 [ 0x00000000, 0x00666666, -0x0CCCCCC ], [ 0x00000000, 0x00666666, -0x0666666 ], [ 0x00000000, 0x00666666, 0x00000000 ],
1425 [ 0x00000000, 0x00666666, 0x00666666 ], [ 0x00000000, 0x00666666, 0x00CCCCCC ],
1426 [ 0x00000000, 0x00CCCCCC, -0x0CCCCCC ], [ 0x00000000, 0x00CCCCCC, -0x0666666 ], [ 0x00000000, 0x00CCCCCC, 0x00000000 ],
1427 [ 0x00000000, 0x00CCCCCC, 0x00666666 ], [ 0x00000000, 0x00CCCCCC, 0x00CCCCCC ],
1428 [ 0x00666666, -0x0CCCCCC, -0x0CCCCCC ], [ 0x00666666, -0x0CCCCCC, -0x0666666 ], [ 0x00666666, -0x0CCCCCC, 0x00000000 ],
1429 [ 0x00666666, -0x0CCCCCC, 0x00666666 ], [ 0x00666666, -0x0CCCCCC, 0x00CCCCCC ],
1430 [ 0x00666666, -0x0666666, -0x0CCCCCC ], [ 0x00666666, -0x0666666, -0x0666666 ], [ 0x00666666, -0x0666666, 0x00000000 ],
1431 [ 0x00666666, -0x0666666, 0x00666666 ], [ 0x00666666, -0x0666666, 0x00CCCCCC ],
1432 [ 0x00666666, 0x00000000, -0x0CCCCCC ], [ 0x00666666, 0x00000000, -0x0666666 ], [ 0x00666666, 0x00000000, 0x00000000 ],
1433 [ 0x00666666, 0x00000000, 0x00666666 ], [ 0x00666666, 0x00000000, 0x00CCCCCC ],
1434 [ 0x00666666, 0x00666666, -0x0CCCCCC ], [ 0x00666666, 0x00666666, -0x0666666 ], [ 0x00666666, 0x00666666, 0x00000000 ],
1435 [ 0x00666666, 0x00666666, 0x00666666 ], [ 0x00666666, 0x00666666, 0x00CCCCCC ],
1436 [ 0x00666666, 0x00CCCCCC, -0x0CCCCCC ], [ 0x00666666, 0x00CCCCCC, -0x0666666 ], [ 0x00666666, 0x00CCCCCC, 0x00000000 ],
1437 [ 0x00666666, 0x00CCCCCC, 0x00666666 ], [ 0x00666666, 0x00CCCCCC, 0x00CCCCCC ],
1438 [ 0x00CCCCCC, -0x0CCCCCC, -0x0CCCCCC ], [ 0x00CCCCCC, -0x0CCCCCC, -0x0666666 ], [ 0x00CCCCCC, -0x0CCCCCC, 0x00000000 ],
1439 [ 0x00CCCCCC, -0x0CCCCCC, 0x00666666 ], [ 0x00CCCCCC, -0x0CCCCCC, 0x00CCCCCC ],
1440 [ 0x00CCCCCC, -0x0666666, -0x0CCCCCC ], [ 0x00CCCCCC, -0x0666666, -0x0666666 ], [ 0x00CCCCCC, -0x0666666, 0x00000000 ],
1441 [ 0x00CCCCCC, -0x0666666, 0x00666666 ], [ 0x00CCCCCC, -0x0666666, 0x00CCCCCC ],
1442 [ 0x00CCCCCC, 0x00000000, -0x0CCCCCC ], [ 0x00CCCCCC, 0x00000000, -0x0666666 ], [ 0x00CCCCCC, 0x00000000, 0x00000000 ],
1443 [ 0x00CCCCCC, 0x00000000, 0x00666666 ], [ 0x00CCCCCC, 0x00000000, 0x00CCCCCC ],
1444 [ 0x00CCCCCC, 0x00666666, -0x0CCCCCC ], [ 0x00CCCCCC, 0x00666666, -0x0666666 ], [ 0x00CCCCCC, 0x00666666, 0x00000000 ],
1445 [ 0x00CCCCCC, 0x00666666, 0x00666666 ], [ 0x00CCCCCC, 0x00666666, 0x00CCCCCC ],
1446 [ 0x00CCCCCC, 0x00CCCCCC, -0x0CCCCCC ], [ 0x00CCCCCC, 0x00CCCCCC, -0x0666666 ], [ 0x00CCCCCC, 0x00CCCCCC, 0x00000000 ],
1447 [ 0x00CCCCCC, 0x00CCCCCC, 0x00666666 ], [ 0x00CCCCCC, 0x00CCCCCC, 0x00CCCCCC ],
1449 const TS102366_QUANT7_MAP: [i32; 7] = [
1450 -0xDB6DB6, -0x924924, -0x492492, 0x000000, 0x492492, 0x924924, 0xDB6DB6
1452 const TS102366_QUANT11_MAP: [[i32; 2]; 121] = [
1453 [ -0x0E8BA2E, -0x0E8BA2E ], [ -0x0E8BA2E, -0x0BA2E8B ], [ -0x0E8BA2E, -0x08BA2E8 ],
1454 [ -0x0E8BA2E, -0x05D1745 ], [ -0x0E8BA2E, -0x02E8BA2 ], [ -0x0E8BA2E, 0x00000000 ],
1455 [ -0x0E8BA2E, 0x002E8BA2 ], [ -0x0E8BA2E, 0x005D1745 ], [ -0x0E8BA2E, 0x008BA2E8 ],
1456 [ -0x0E8BA2E, 0x00BA2E8B ], [ -0x0E8BA2E, 0x00E8BA2E ], [ -0x0BA2E8B, -0x0E8BA2E ],
1457 [ -0x0BA2E8B, -0x0BA2E8B ], [ -0x0BA2E8B, -0x08BA2E8 ], [ -0x0BA2E8B, -0x05D1745 ],
1458 [ -0x0BA2E8B, -0x02E8BA2 ], [ -0x0BA2E8B, 0x00000000 ], [ -0x0BA2E8B, 0x002E8BA2 ],
1459 [ -0x0BA2E8B, 0x005D1745 ], [ -0x0BA2E8B, 0x008BA2E8 ], [ -0x0BA2E8B, 0x00BA2E8B ],
1460 [ -0x0BA2E8B, 0x00E8BA2E ], [ -0x08BA2E8, -0x0E8BA2E ], [ -0x08BA2E8, -0x0BA2E8B ],
1461 [ -0x08BA2E8, -0x08BA2E8 ], [ -0x08BA2E8, -0x05D1745 ], [ -0x08BA2E8, -0x02E8BA2 ],
1462 [ -0x08BA2E8, 0x00000000 ], [ -0x08BA2E8, 0x002E8BA2 ], [ -0x08BA2E8, 0x005D1745 ],
1463 [ -0x08BA2E8, 0x008BA2E8 ], [ -0x08BA2E8, 0x00BA2E8B ], [ -0x08BA2E8, 0x00E8BA2E ],
1464 [ -0x05D1745, -0x0E8BA2E ], [ -0x05D1745, -0x0BA2E8B ], [ -0x05D1745, -0x08BA2E8 ],
1465 [ -0x05D1745, -0x05D1745 ], [ -0x05D1745, -0x02E8BA2 ], [ -0x05D1745, 0x00000000 ],
1466 [ -0x05D1745, 0x002E8BA2 ], [ -0x05D1745, 0x005D1745 ], [ -0x05D1745, 0x008BA2E8 ],
1467 [ -0x05D1745, 0x00BA2E8B ], [ -0x05D1745, 0x00E8BA2E ], [ -0x02E8BA2, -0x0E8BA2E ],
1468 [ -0x02E8BA2, -0x0BA2E8B ], [ -0x02E8BA2, -0x08BA2E8 ], [ -0x02E8BA2, -0x05D1745 ],
1469 [ -0x02E8BA2, -0x02E8BA2 ], [ -0x02E8BA2, 0x00000000 ], [ -0x02E8BA2, 0x002E8BA2 ],
1470 [ -0x02E8BA2, 0x005D1745 ], [ -0x02E8BA2, 0x008BA2E8 ], [ -0x02E8BA2, 0x00BA2E8B ],
1471 [ -0x02E8BA2, 0x00E8BA2E ], [ 0x00000000, -0x0E8BA2E ], [ 0x00000000, -0x0BA2E8B ],
1472 [ 0x00000000, -0x08BA2E8 ], [ 0x00000000, -0x05D1745 ], [ 0x00000000, -0x02E8BA2 ],
1473 [ 0x00000000, 0x00000000 ], [ 0x00000000, 0x002E8BA2 ], [ 0x00000000, 0x005D1745 ],
1474 [ 0x00000000, 0x008BA2E8 ], [ 0x00000000, 0x00BA2E8B ], [ 0x00000000, 0x00E8BA2E ],
1475 [ 0x002E8BA2, -0x0E8BA2E ], [ 0x002E8BA2, -0x0BA2E8B ], [ 0x002E8BA2, -0x08BA2E8 ],
1476 [ 0x002E8BA2, -0x05D1745 ], [ 0x002E8BA2, -0x02E8BA2 ], [ 0x002E8BA2, 0x00000000 ],
1477 [ 0x002E8BA2, 0x002E8BA2 ], [ 0x002E8BA2, 0x005D1745 ], [ 0x002E8BA2, 0x008BA2E8 ],
1478 [ 0x002E8BA2, 0x00BA2E8B ], [ 0x002E8BA2, 0x00E8BA2E ], [ 0x005D1745, -0x0E8BA2E ],
1479 [ 0x005D1745, -0x0BA2E8B ], [ 0x005D1745, -0x08BA2E8 ], [ 0x005D1745, -0x05D1745 ],
1480 [ 0x005D1745, -0x02E8BA2 ], [ 0x005D1745, 0x00000000 ], [ 0x005D1745, 0x002E8BA2 ],
1481 [ 0x005D1745, 0x005D1745 ], [ 0x005D1745, 0x008BA2E8 ], [ 0x005D1745, 0x00BA2E8B ],
1482 [ 0x005D1745, 0x00E8BA2E ], [ 0x008BA2E8, -0x0E8BA2E ], [ 0x008BA2E8, -0x0BA2E8B ],
1483 [ 0x008BA2E8, -0x08BA2E8 ], [ 0x008BA2E8, -0x05D1745 ], [ 0x008BA2E8, -0x02E8BA2 ],
1484 [ 0x008BA2E8, 0x00000000 ], [ 0x008BA2E8, 0x002E8BA2 ], [ 0x008BA2E8, 0x005D1745 ],
1485 [ 0x008BA2E8, 0x008BA2E8 ], [ 0x008BA2E8, 0x00BA2E8B ], [ 0x008BA2E8, 0x00E8BA2E ],
1486 [ 0x00BA2E8B, -0x0E8BA2E ], [ 0x00BA2E8B, -0x0BA2E8B ], [ 0x00BA2E8B, -0x08BA2E8 ],
1487 [ 0x00BA2E8B, -0x05D1745 ], [ 0x00BA2E8B, -0x02E8BA2 ], [ 0x00BA2E8B, 0x00000000 ],
1488 [ 0x00BA2E8B, 0x002E8BA2 ], [ 0x00BA2E8B, 0x005D1745 ], [ 0x00BA2E8B, 0x008BA2E8 ],
1489 [ 0x00BA2E8B, 0x00BA2E8B ], [ 0x00BA2E8B, 0x00E8BA2E ], [ 0x00E8BA2E, -0x0E8BA2E ],
1490 [ 0x00E8BA2E, -0x0BA2E8B ], [ 0x00E8BA2E, -0x08BA2E8 ], [ 0x00E8BA2E, -0x05D1745 ],
1491 [ 0x00E8BA2E, -0x02E8BA2 ], [ 0x00E8BA2E, 0x00000000 ], [ 0x00E8BA2E, 0x002E8BA2 ],
1492 [ 0x00E8BA2E, 0x005D1745 ], [ 0x00E8BA2E, 0x008BA2E8 ], [ 0x00E8BA2E, 0x00BA2E8B ],
1493 [ 0x00E8BA2E, 0x00E8BA2E ],
1495 const TS102366_QUANT15_MAP: [i32; 15] = [
1496 -0x0EEEEEE, -0x0CCCCCC, -0x0AAAAAA, -0x0888888, -0x0666666, -0x0444444, -0x0222222, 0x00000000,
1497 0x00222222, 0x00444444, 0x00666666, 0x00888888, 0x00AAAAAA, 0x00CCCCCC, 0x00EEEEEE,
1499 const TS102366_BAP_BITS: [u8; 10] = [ 5, 6, 7, 8, 9, 10, 11, 12, 14, 16 ];
1501 const TS102366_WINDOW: [f32; 256] = [
1502 0.00014, 0.00024, 0.00037, 0.00051, 0.00067, 0.00086, 0.00107, 0.00130,
1503 0.00157, 0.00187, 0.00220, 0.00256, 0.00297, 0.00341, 0.00390, 0.00443,
1504 0.00501, 0.00564, 0.00632, 0.00706, 0.00785, 0.00871, 0.00962, 0.01061,
1505 0.01166, 0.01279, 0.01399, 0.01526, 0.01662, 0.01806, 0.01959, 0.02121,
1506 0.02292, 0.02472, 0.02662, 0.02863, 0.03073, 0.03294, 0.03527, 0.03770,
1507 0.04025, 0.04292, 0.04571, 0.04862, 0.05165, 0.05481, 0.05810, 0.06153,
1508 0.06508, 0.06878, 0.07261, 0.07658, 0.08069, 0.08495, 0.08935, 0.09389,
1509 0.09859, 0.10343, 0.10842, 0.11356, 0.11885, 0.12429, 0.12988, 0.13563,
1510 0.14152, 0.14757, 0.15376, 0.16011, 0.16661, 0.17325, 0.18005, 0.18699,
1511 0.19407, 0.20130, 0.20867, 0.21618, 0.22382, 0.23161, 0.23952, 0.24757,
1512 0.25574, 0.26404, 0.27246, 0.28100, 0.28965, 0.29841, 0.30729, 0.31626,
1513 0.32533, 0.33450, 0.34376, 0.35311, 0.36253, 0.37204, 0.38161, 0.39126,
1514 0.40096, 0.41072, 0.42054, 0.43040, 0.44030, 0.45023, 0.46020, 0.47019,
1515 0.48020, 0.49022, 0.50025, 0.51028, 0.52031, 0.53033, 0.54033, 0.55031,
1516 0.56026, 0.57019, 0.58007, 0.58991, 0.59970, 0.60944, 0.61912, 0.62873,
1517 0.63827, 0.64774, 0.65713, 0.66643, 0.67564, 0.68476, 0.69377, 0.70269,
1518 0.71150, 0.72019, 0.72877, 0.73723, 0.74557, 0.75378, 0.76186, 0.76981,
1519 0.77762, 0.78530, 0.79283, 0.80022, 0.80747, 0.81457, 0.82151, 0.82831,
1520 0.83496, 0.84145, 0.84779, 0.85398, 0.86001, 0.86588, 0.87160, 0.87716,
1521 0.88257, 0.88782, 0.89291, 0.89785, 0.90264, 0.90728, 0.91176, 0.91610,
1522 0.92028, 0.92432, 0.92822, 0.93197, 0.93558, 0.93906, 0.94240, 0.94560,
1523 0.94867, 0.95162, 0.95444, 0.95713, 0.95971, 0.96217, 0.96451, 0.96674,
1524 0.96887, 0.97089, 0.97281, 0.97463, 0.97635, 0.97799, 0.97953, 0.98099,
1525 0.98236, 0.98366, 0.98488, 0.98602, 0.98710, 0.98811, 0.98905, 0.98994,
1526 0.99076, 0.99153, 0.99225, 0.99291, 0.99353, 0.99411, 0.99464, 0.99513,
1527 0.99558, 0.99600, 0.99639, 0.99674, 0.99706, 0.99736, 0.99763, 0.99788,
1528 0.99811, 0.99831, 0.99850, 0.99867, 0.99882, 0.99895, 0.99908, 0.99919,
1529 0.99929, 0.99938, 0.99946, 0.99953, 0.99959, 0.99965, 0.99969, 0.99974,
1530 0.99978, 0.99981, 0.99984, 0.99986, 0.99988, 0.99990, 0.99992, 0.99993,
1531 0.99994, 0.99995, 0.99996, 0.99997, 0.99998, 0.99998, 0.99998, 0.99999,
1532 0.99999, 0.99999, 0.99999, 1.00000, 1.00000, 1.00000, 1.00000, 1.00000,
1533 1.00000, 1.00000, 1.00000, 1.00000, 1.00000, 1.00000, 1.00000, 1.00000,