nihav-commonfmt/src/codecs/ts102366.rs

   1 use std::rc::Rc;
   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::*;
   8 use std::str::FromStr;
   9 use std::f32::consts;
  10
  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;
  16
  17 const MAGIC_BYTE0: u8 = 0x0B;
  18 const MAGIC_BYTE1: u8 = 0x77;
  19
  20 const STRATEGY_REUSE: u8 = 0;
  21
  22 const LFE_CHANNEL:  usize = MAX_CHANNELS;
  23 const CPL_CHANNEL:  usize = MAX_CHANNELS + 1;
  24
  25 struct IMDCTContext {
  26     xsincos:    [FFTComplex; BLOCK_LEN/2],
  27     fft:        FFT,
  28     size:       usize,
  29 }
  30
  31 struct IMDCTWorkspace {
  32     z:      [FFTComplex; BLOCK_LEN / 2],
  33     y:      [FFTComplex; BLOCK_LEN / 2],
  34     out:    [f32; BLOCK_LEN * 2],
  35 }
  36
  37 impl IMDCTContext {
  38     fn new(bits: usize) -> Self {
  39         let size = 1 << bits;
  40         let size4 = 1 << (bits - 2);
  41         let mut xsincos: [FFTComplex; 512/4] = [FFTC_ZERO; 512/4];
  42         for k in 0..size4 {
  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();
  46         }
  47         let fft = FFTBuilder::new_fft(FFTMode::SplitRadix, size/4);
  48         IMDCTContext { xsincos: xsincos, size: size, fft: fft }
  49     }
  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;
  57         for n in 0..N8 {
  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];
  66         }
  67     }
  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;
  82         for n in 0..N8 {
  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];
  91         }
  92     }
  93 }
  94
  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]) {
  97     let N  = size;
  98     let N2 = size / 2;
  99     let N4 = size / 4;
 100     let scale = 1.0 / ((1 << 24) as f32);
 101     for k in 0..N4 {
 102         let (c0, c1) = if !ilace {
 103                 ((coeffs[N2 - 2 * k - 1] as f32) * scale,
 104                  (coeffs[     2 * k]     as f32) * scale)
 105             } else {
 106                 ((coeffs[N - 4 * k - 2] as f32) * scale,
 107                  (coeffs[    4 * k]     as f32) * scale)
 108             };
 109         let c = FFTComplex { re: c0, im: c1 };
 110         z[k] = c * xsc[k];
 111     }
 112     fft.do_fft_inplace(z, false);
 113     for k in 0..N4 {
 114         y[k] = z[k] * xsc[k];
 115     }
 116 }
 117
 118 struct AudioDecoder {
 119     info:       Rc<NACodecInfo>,
 120     ablk:       AudioBlock,
 121     imdct512:   IMDCTContext,
 122     imdct256:   IMDCTContext,
 123     tmp:        IMDCTWorkspace,
 124     delay:      [[f32; BLOCK_LEN]; MAX_CHANNELS + 1],
 125 }
 126
 127 impl AudioDecoder {
 128     fn new() -> Self {
 129         AudioDecoder {
 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],
 138                         },
 139             delay:      [[0.0; BLOCK_LEN]; MAX_CHANNELS + 1],
 140         }
 141     }
 142 }
 143
 144 const SAMPLE_RATES: [u32; 4] = [ 48000, 44100, 32000, 0 ];
 145
 146 const FRAME_SIZES: [[usize; 64]; 4] = [
 147     [
 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,
 155     ], [
 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,
 163     ], [
 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,
 171     ], [ 0; 64 ],
 172 ];
 173
 174 #[derive(Debug,Clone,Copy)]
 175 struct Syncinfo {
 176     crc1:       u16,
 177     fscod:      u8,
 178     frmsizecod: u8,
 179     samplerate: u32,
 180     frame_size: usize,
 181 }
 182
 183 impl Syncinfo {
 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 })
 192     }
 193     fn is_valid(&self) -> bool {
 194         (self.samplerate != 0) && (self.frame_size != 0)
 195     }
 196 }
 197
 198 trait ReadOptional {
 199     fn read_optional8(&mut self) -> BitReaderResult<Option<u8>>;
 200     fn read_optional16(&mut self, bits: u8) -> BitReaderResult<Option<u16>>;
 201 }
 202
 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))
 207         } else {
 208             Ok(None)
 209         }
 210     }
 211     fn read_optional16(&mut self, bits: u8) -> BitReaderResult<Option<u16>> {
 212         if self.read_bool()? {
 213             Ok(Some(self.read(bits)? as u16))
 214         } else {
 215             Ok(None)
 216         }
 217     }
 218 }
 219
 220 #[derive(Debug,Clone,Copy,PartialEq)]
 221 enum ACMode {
 222     DualMono,
 223     Mono,
 224     Stereo,
 225     Mode3_0,
 226     Mode2_1,
 227     Mode3_1,
 228     Mode2_2,
 229     Mode3_2,
 230 }
 231
 232 impl ACMode {
 233     fn get_num_channels(&self) -> usize {
 234         match *self {
 235             ACMode::DualMono    => 2,
 236             ACMode::Mono        => 1,
 237             ACMode::Stereo      => 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,
 243         }
 244     }
 245     fn get_channel_map_str(&self) -> &'static str {
 246         match *self {
 247             ACMode::DualMono    => "C,C",
 248             ACMode::Mono        => "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",
 255         }
 256     }
 257     fn get_channel_map(&self, has_lfe: bool) -> NAChannelMap {
 258         let mut chmap = NAChannelMap::from_str(self.get_channel_map_str()).unwrap();
 259         if has_lfe {
 260             chmap.add_channel(NAChannelType::LFE);
 261         }
 262         chmap
 263     }
 264     fn is_3_x(&self) -> bool {
 265         match *self {
 266             ACMode::Mode3_0 |
 267             ACMode::Mode3_1 |
 268             ACMode::Mode3_2     => true,
 269             _                   => false,
 270         }
 271     }
 272     fn is_surround(&self) -> bool {
 273         match *self {
 274             ACMode::Mode2_1 |
 275             ACMode::Mode3_1 |
 276             ACMode::Mode2_2 |
 277             ACMode::Mode3_2     => true,
 278             _                   => false,
 279         }
 280     }
 281 }
 282
 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,
 287     ACMode::Mode3_2
 288 ];
 289
 290 #[derive(Debug,Clone,Copy)]
 291 struct Mixinfo {
 292     dialnorm:   u8,
 293     compr:      Option<u8>,
 294     langcod:    Option<u8>,
 295     mixlevel:   Option<u8>,
 296     roomtyp:    Option<u8>,
 297 }
 298
 299 impl Mixinfo {
 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;
 307                 validate!(rt < 3);
 308                 (Some(mlev), Some(rt))
 309             } else {
 310                 (None, None)
 311             };
 312         Ok(Mixinfo { dialnorm, compr, langcod, mixlevel, roomtyp })
 313     }
 314 }
 315
 316 #[derive(Debug,Clone,Copy)]
 317 struct BSI {
 318     bsid:       u8,
 319     shift:      u8,
 320     bsmod:      u8,
 321     acmod:      ACMode,
 322     cmixlev:    Option<u8>,
 323     surmixlev:  Option<u8>,
 324     dsurmod:    Option<u8>,
 325     lfeon:      bool,
 326     mixinfo:    Mixinfo,
 327     mixinfo2:   Option<Mixinfo>,
 328     copysmth:   bool,
 329     origbs:     bool,
 330     timecod1:   Option<u16>,
 331     timecod2:   Option<u16>,
 332     has_addb:   bool,
 333 }
 334
 335 impl BSI {
 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;
 346                 validate!(cl < 3);
 347                 Some(cl)
 348             } else { None };
 349         let surmixlev = if acmod.is_surround() {
 350                 let sml             = br.read(2)? as u8;
 351                 validate!(sml < 3);
 352                 Some(sml)
 353             } else { None };
 354         let dsurmod = if acmod == ACMode::Stereo {
 355                 let dsm             = br.read(2)? as u8;
 356                 validate!(dsm < 3);
 357                 Some(dsm)
 358             } else { None };
 359         let lfeon                   = br.read_bool()?;
 360         let mixinfo                 = Mixinfo::read(br)?;
 361         let mixinfo2 = if acmod == ACMode::DualMono {
 362                 Some(Mixinfo::read(br)?)
 363             } else {
 364                 None
 365             };
 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()?;
 371         Ok(BSI{
 372             bsid, shift, bsmod, acmod, lfeon,
 373             cmixlev, surmixlev, dsurmod,
 374             mixinfo: mixinfo, mixinfo2: mixinfo2,
 375             copysmth, origbs, timecod1, timecod2, has_addb,
 376             })
 377     }
 378 }
 379
 380 #[derive(Clone, Copy)]
 381 struct ChannelData {
 382     blksw:      bool,
 383     dithflag:   bool,
 384
 385     chincpl:    bool,
 386     cplcoe:     bool,
 387     cplcoexp:   [u8; MAX_CPLBANDS],
 388     cplcomant:  [u8; MAX_CPLBANDS],
 389     mstrcplco:  u8,
 390
 391     chbwcod:    u8,
 392
 393     expstr:     u8,
 394     gainrng:    u8,
 395     startmant:  usize,
 396     endmant:    usize,
 397     groups:     usize,
 398
 399     fsnroffst:  u8,
 400     fgaincod:   usize,
 401     snroffset:  i32,
 402
 403     deltbae:    u8,
 404     deltnseg:   usize,
 405     deltoffst:  [u8; 8],
 406     deltlen:    [usize; 8],
 407     deltba:     [u8; 8],
 408
 409     bap:        [u8; 256],
 410     exps:       [u8; 256],
 411     mant:       [i32; 256],
 412
 413     psd:        [i16; 256],
 414     bndpsd:     [i32; 64],
 415 }
 416
 417 const GROUPS: [usize; 4] = [ 0, 3, 6, 12 ];
 418 const GROUP_BIAS: [usize; 4] = [ 0, 0, 3, 9 ];
 419
 420 fn decode_exps(br: &mut BitReader, dst: &mut [u8], mut prev: u8, grplen: usize) -> DecoderResult<()> {
 421     let repeat = grplen / 3;
 422
 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);
 430             for j in 1..repeat {
 431                 exps[j] = exps[0];
 432             }
 433             prev = exps[0];
 434         }
 435     }
 436
 437     Ok(())
 438 }
 439
 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());
 444             $tab[val]
 445         });
 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]]
 450             } else {
 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];
 455                 }
 456                 $bap_buf_fill[$bufidx] = $tab[0].len() - 1;
 457                 $tab[val][0]
 458             }
 459         );
 460 }
 461
 462 impl ChannelData {
 463     fn new() -> Self {
 464         ChannelData {
 465             blksw:      false,
 466             dithflag:   false,
 467
 468             chincpl:    false,
 469             cplcoe:     false,
 470             cplcoexp:   [0; MAX_CPLBANDS],
 471             cplcomant:  [0; MAX_CPLBANDS],
 472             mstrcplco:  0,
 473
 474             chbwcod:    0,
 475
 476             expstr:     0,
 477             gainrng:    0,
 478             startmant:  0,
 479             endmant:    0,
 480             groups:     0,
 481
 482             fsnroffst:  0,
 483             fgaincod:   0,
 484             snroffset:  0,
 485
 486             deltbae:    0,
 487             deltnseg:   0,
 488             deltoffst:  [0; 8],
 489             deltlen:    [0; 8],
 490             deltba:     [0; 8],
 491
 492             bap:        [0; 256],
 493             exps:       [0; 256],
 494             mant:       [0; 256],
 495
 496             psd:        [0; 256],
 497             bndpsd:     [0; 64],
 498         }
 499     }
 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];
 509             } else {
 510                 self.groups = 0;
 511             }
 512         }
 513         Ok(())
 514     }
 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];
 519         if is_cpl {
 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)?;
 523         } else if !is_lfe {
 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;
 529         } else {
 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)?;
 534         }
 535         Ok(())
 536     }
 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;
 540         Ok(())
 541     }
 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;
 549             }
 550         }
 551         Ok(())
 552     }
 553
 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;
 560
 561         for bin in start..end {
 562             psd[bin] = 3072 - ((exps[bin] as i16) << 7);
 563         }
 564
 565         let mut bin = start;
 566         let mut band = TS102366_BIN_TO_BAND[bin] as usize;
 567         let mut lastbin;
 568         loop {
 569             lastbin = ((TS102366_BAND_START[band] as usize) + (TS102366_BAND_SIZE[band] as usize)).min(end);
 570             bndpsd[band] = psd[bin] as i32;
 571             bin += 1;
 572             while bin < lastbin {
 573                 bndpsd[band] = logadd(bndpsd[band], psd[bin] as i32);
 574                 bin += 1;
 575             }
 576             band += 1;
 577             if lastbin >= end { break; }
 578         }
 579     }
 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;
 583
 584         let bndstart = TS102366_BIN_TO_BAND[self.startmant] as usize;
 585         let bndend   = (TS102366_BIN_TO_BAND[self.endmant - 1] as usize) + 1;
 586
 587         let mut excite: [i32; MAX_BANDS] = [0; MAX_BANDS];
 588
 589         let begin;
 590         let mut fast_leak;
 591         let mut slow_leak;
 592         if bndstart == 0 {
 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;
 597             let mut sband = 7;
 598             let mut lowcomp = lowcomp1;
 599             fast_leak = 0;
 600             slow_leak = 0;
 601             for band in 2..7 {
 602                 let not_lfe_case = (bndend != 7) || (band != 6);
 603                 if not_lfe_case {
 604                     lowcomp = calc_lowcomp(lowcomp, self.bndpsd[band], self.bndpsd[band + 1], band);
 605                 }
 606                 fast_leak = self.bndpsd[band] - fgain;
 607                 slow_leak = self.bndpsd[band] - (sgain as i32);
 608                 excite[band] = fast_leak - lowcomp;
 609                 if not_lfe_case {
 610                     if self.bndpsd[band] <= self.bndpsd[band + 1] {
 611                         sband = band + 1;
 612                         break;
 613                     }
 614                 }
 615             }
 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);
 619                 }
 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);
 623             }
 624             begin = 22;
 625         } else {
 626             begin = bndstart;
 627             fast_leak = cplfleak as i32;
 628             slow_leak = cplsleak as i32;
 629         }
 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);
 634         }
 635         for band in bndstart..bndend {
 636             if self.bndpsd[band] < (dbknee as i32) {
 637                 excite[band] += ((dbknee as i32) - self.bndpsd[band]) >> 2;
 638             }
 639             mask[band] = excite[band].max(TS102366_HTH[fscod][band >> shift] as i32);
 640         }
 641     }
 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
 649                     } else {
 650                         ((self.deltba[seg] as i32) - 4) << 7
 651                     };
 652                 if band + self.deltlen[seg] > MAX_BANDS { break; }
 653                 for _ in 0..self.deltlen[seg] {
 654                     mask[band] += delta;
 655                     band += 1;
 656                 }
 657             }
 658         }
 659     }
 660     fn calc_snr_offset(&mut self, csnroffst: u8) {
 661         self.snroffset = ((((csnroffst as i32) - 15) << 4) + (self.fsnroffst as i32)) << 2;
 662     }
 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;
 667         let mut lastbin;
 668         loop {
 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];
 675                 bin += 1;
 676             }
 677             if lastbin == end { break; }
 678             band += 1;
 679         }
 680     }
 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] {
 685                     0 => {
 686                             if self.dithflag {
 687                                 42 // todo dither
 688                             } else {
 689                                 0
 690                             }
 691                         },
 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) },
 697                     _ => {
 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
 702                         },
 703                 };
 704             self.mant[bin] >>= self.exps[bin];
 705         }
 706         Ok(())
 707     }
 708
 709     fn synth(&mut self, imdct512: &mut IMDCTContext, imdct256: &mut IMDCTContext, tmp: &mut IMDCTWorkspace, delay: &mut [f32; BLOCK_LEN], dst: &mut [f32]) {
 710         if !self.blksw {
 711             imdct512.do_imdct(&self.mant, tmp);
 712         } else {
 713             imdct256.do_imdct_ileave(&self.mant, tmp);
 714         }
 715         overlap(delay, &tmp.out, dst);
 716     }
 717 }
 718
 719 fn logadd(acc: i32, add: i32) -> i32 {
 720     let c = acc - add;
 721     let addr = (c.abs() >> 1).min(255);
 722     if c >= 0 {
 723         acc + (TS102366_LATAB[addr as usize] as i32)
 724     } else {
 725         add + (TS102366_LATAB[addr as usize] as i32)
 726     }
 727 }
 728
 729 fn calc_lowcomp(a: i32, b0: i32, b1: i32, band: usize) -> i32 {
 730     if band < 7 {
 731         if (b0 + 256) == b1 {
 732             384
 733         } else if b0 > b1 {
 734             0.max(a - 64)
 735         } else {
 736             a
 737         }
 738     } else if band < 20 {
 739         if (b0 + 256) == b1 {
 740             320
 741         } else if b0 > b1 {
 742             0.max(a - 64)
 743         } else {
 744             a
 745         }
 746     } else {
 747         0.max(a - 128)
 748     }
 749 }
 750
 751 fn overlap(delay: &mut [f32; BLOCK_LEN], src: &[f32; BLOCK_LEN * 2], out: &mut [f32]) {
 752     {
 753         let dly = &delay;
 754         for ((d, s), o) in dly.into_iter().zip(src.into_iter()).zip(out.iter_mut()) {
 755             *o = (*d + *s) * 2.0;
 756         }
 757     }
 758     delay.copy_from_slice(&src[BLOCK_LEN..]);
 759 }
 760
 761 #[derive(Clone)]
 762 struct AudioBlock {
 763     dynrng:     Option<u8>,
 764     dynrng2:    Option<u8>,
 765
 766     cplstre:    bool,
 767     cplinu:     bool,
 768     phsflginu:  bool,
 769     cplbegf:    usize,
 770     cplendf:    usize,
 771     ncplsubnd:  usize,
 772     ncplbnd:    usize,
 773     cplbndstrc: [bool; MAX_CPLBANDS],
 774
 775     phsflg:     [bool; MAX_CPLBANDS],
 776     rematstr:   bool,
 777     rematflg:   [bool; 4],
 778
 779     chdata:     [ChannelData; MAX_CHANNELS + 2],
 780
 781     baie:       bool,
 782     fdcycod:    usize,
 783     sdcycod:    usize,
 784     sgaincod:   usize,
 785     dbpbcod:    usize,
 786     floorcod:   usize,
 787     snroffste:  bool,
 788     csnroffst:  u8,
 789     cplleake:   bool,
 790     cplfleak:   u8,
 791     cplsleak:   u8,
 792
 793     deltbaie:   bool,
 794
 795     bap_buf:        [[i32; 2]; 3],
 796     bap_buf_fill:   [usize; 3],
 797 }
 798
 799 impl AudioBlock {
 800     fn new() -> Self {
 801         AudioBlock {
 802             chdata:     [ChannelData::new(); MAX_CHANNELS + 2],
 803
 804             dynrng:     None,
 805             dynrng2:    None,
 806
 807             cplstre:    false,
 808             cplinu:     false,
 809             phsflginu:  false,
 810             cplbegf:    0,
 811             cplendf:    0,
 812             ncplsubnd:  0,
 813             ncplbnd:    0,
 814             cplbndstrc: [false; MAX_CPLBANDS],
 815
 816             phsflg:     [false; MAX_CPLBANDS],
 817             rematstr:   false,
 818             rematflg:   [false; 4],
 819
 820             baie:       false,
 821             sdcycod:    0,
 822             fdcycod:    0,
 823             sgaincod:   0,
 824             dbpbcod:    0,
 825             floorcod:   0,
 826             snroffste:  false,
 827             csnroffst:  0,
 828             cplleake:   false,
 829             cplfleak:   0,
 830             cplsleak:   0,
 831
 832             deltbaie:   false,
 833
 834             bap_buf:        [[0; 2]; 3],
 835             bap_buf_fill:   [0; 3],
 836         }
 837     }
 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;
 841
 842         for ch in 0..channels {
 843             self.chdata[ch].blksw                   = br.read_bool()?;
 844         }
 845         // dynamic range information
 846         for ch in 0..channels {
 847             self.chdata[ch].dithflag                = br.read_bool()?;
 848         }
 849         self.dynrng                                 = br.read_optional8()?;
 850         if bsi.acmod == ACMode::DualMono {
 851             self.dynrng2                            = br.read_optional8()?;
 852         }
 853         // coupling strategy information
 854         self.cplstre                                = br.read_bool()?;
 855         validate!((blk_no != 0) || self.cplstre);
 856         if self.cplstre {
 857             self.cplinu                             = br.read_bool()?;
 858             if self.cplinu {
 859                 for ch in 0..channels {
 860                     self.chdata[ch].chincpl         = br.read_bool()?;
 861                 }
 862                 if is_stereo {
 863                     self.phsflginu                  = br.read_bool()?;
 864                 }
 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] {
 875                         self.ncplbnd -= 1;
 876                     }
 877                 }
 878             }
 879         }
 880         // coupling coordinates
 881         if self.cplinu {
 882             for c in 0..channels {
 883                 let ch = &mut self.chdata[c];
 884                 if ch.chincpl {
 885                     ch.cplcoe                       = br.read_bool()?;
 886                     if ch.cplcoe {
 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;
 891                         }
 892                     }
 893                 }
 894             }
 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()?;
 898                 }
 899             }
 900         } else {
 901             for ch in 0..channels {
 902                 self.chdata[ch].chincpl = false;
 903             }
 904         }
 905         // stereo rematrixing
 906         if is_stereo {
 907             self.rematstr                           = br.read_bool()?;
 908             if self.rematstr {
 909                 if self.cplbegf > 2 || !self.cplinu {
 910                     for rbnd in 0..4 {
 911                         self.rematflg[rbnd]         = br.read_bool()?;
 912                     }
 913                 }
 914                 if self.cplbegf > 0 && self.cplbegf <= 2 && self.cplinu {
 915                     for rbnd in 0..3 {
 916                         self.rematflg[rbnd]         = br.read_bool()?;
 917                     }
 918                 }
 919                 if self.cplbegf == 0 && self.cplinu {
 920                     for rbnd in 0..2 {
 921                         self.rematflg[rbnd]         = br.read_bool()?;
 922                     }
 923                 }
 924             }
 925         }
 926         // exponent strategy
 927         if self.cplinu {
 928             self.chdata[CPL_CHANNEL].read_strategy(br, blk_no)?;
 929         }
 930         for ch in 0..channels {
 931             self.chdata[ch].read_strategy(br, blk_no)?;
 932         }
 933         if bsi.lfeon {
 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;
 939         }
 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;
 945             }
 946             if !ch.chincpl {
 947                 ch.startmant = 0;
 948                 ch.endmant   = ((ch.chbwcod as usize) + 12) * 3 + 37;
 949             } else {
 950                 ch.startmant = 0;
 951                 ch.endmant   = cpl_startmant;
 952             }
 953         }
 954         // set number of mantissas
 955         if self.cplinu {
 956             self.chdata[CPL_CHANNEL].read_exps(br, true, false)?;
 957         }
 958         for ch in 0..channels {
 959             self.chdata[ch].read_exps(br, false, false)?;
 960         }
 961         if bsi.lfeon {
 962             self.chdata[LFE_CHANNEL].read_exps(br, false, true)?;
 963         }
 964         // bit allocation parameters
 965         self.baie                                   = br.read_bool()?;
 966         if self.baie {
 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;
 972         }
 973         self.snroffste                              = br.read_bool()?;
 974         if self.snroffste {
 975             self.csnroffst                          = br.read(6)? as u8;
 976             if self.cplinu {
 977                 self.chdata[CPL_CHANNEL].read_snr(br)?;
 978             }
 979             for ch in 0..channels {
 980                 self.chdata[ch].read_snr(br)?;
 981             }
 982             if bsi.lfeon {
 983                 self.chdata[LFE_CHANNEL].read_snr(br)?;
 984             }
 985         }
 986         if self.cplinu {
 987             self.cplleake                           = br.read_bool()?;
 988             if self.cplleake {
 989                 self.cplfleak                       = br.read(3)? as u8;
 990                 self.cplsleak                       = br.read(3)? as u8;
 991             }
 992         }
 993         // delta bit allocation information
 994         self.deltbaie                               = br.read_bool()?;
 995         if self.deltbaie {
 996             if self.cplinu {
 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);
1000             }
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);
1005             }
1006             if self.cplinu {
1007                 self.chdata[CPL_CHANNEL].read_deltbai(br)?;
1008             }
1009             for ch in 0..channels {
1010                 self.chdata[ch].read_deltbai(br)?;
1011             }
1012         }
1013         // dummy data
1014         if br.read_bool()? {
1015             let skipl                               = br.read(9)?;
1016             br.skip(skipl * 8)?;
1017         }
1018
1019         let all_zero = self.calc_bitalloc(bsi, channels, fscod);
1020         if all_zero { return Ok(true); }
1021
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 {
1026             {
1027                 let ch = &mut self.chdata[c];
1028                 ch.read_mant(br, &mut self.bap_buf, &mut self.bap_buf_fill)?;
1029             }
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)?;
1033                 got_cplchan = true;
1034             }
1035         }
1036         if bsi.lfeon {
1037             let lfech = &mut self.chdata[LFE_CHANNEL];
1038             lfech.read_mant(br, &mut self.bap_buf, &mut self.bap_buf_fill)?;
1039         }
1040         Ok(false)
1041     }
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];
1045
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];
1051
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 {
1056                     all_zero = false;
1057                     break;
1058                 }
1059             }
1060         }
1061         if all_zero { return true; }
1062
1063         let mut mask: [i32; MAX_BANDS] = [0; MAX_BANDS];
1064
1065         if self.cplinu {
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);
1072         }
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);
1079         }
1080         if bsi.lfeon {
1081             self.chdata[LFE_CHANNEL].compute_bndpsd();
1082             self.chdata[LFE_CHANNEL].compute_mask(&mut mask, fscod, sgain, fdecay, sdecay, dbknee,
1083                                                   0, 0, bsi.shift);
1084             self.chdata[LFE_CHANNEL].calc_snr_offset(self.csnroffst);
1085             self.chdata[LFE_CHANNEL].compute_bap(&mut mask, floor);
1086         }
1087
1088         false
1089     }
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; }
1094             let mut pband = 0;
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] {
1100                     cotemp = -cotemp;
1101                 }
1102                 if !self.cplbndstrc[cband] {
1103                     pband += 1;
1104                 }
1105                 let exp = self.chdata[ch].cplcoexp[cband] + 3 * self.chdata[ch].mstrcplco + 5 - 3;
1106                 let start = band * 12 + 37;
1107                 for bin in 0..12 {
1108                     self.chdata[ch].mant[start + bin] = self.chdata[CPL_CHANNEL].mant[start + bin] * cotemp >> exp;
1109                 }
1110 //todo dither
1111             }
1112         }
1113     }
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;
1123             }
1124             if maxbin <= 25 { return; }
1125         }
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;
1133             }
1134             if maxbin <= 37 { return; }
1135         }
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;
1143             }
1144             if maxbin <= 61 { return; }
1145         }
1146         if self.rematflg[3] {
1147             let end = maxbin;
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;
1153             }
1154         }
1155     }
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);
1158     }
1159 }
1160
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();
1165             Ok(())
1166         } else {
1167             Err(DecoderError::InvalidData)
1168         }
1169     }
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);
1175
1176         let mut br;
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);
1181         } else {
1182             return Err(DecoderError::InvalidData);
1183         }
1184
1185         let sinfo = Syncinfo::read(&mut br)?;
1186         validate!(sinfo.is_valid());
1187
1188         let bsi = BSI::read(&mut br)?;
1189         if bsi.has_addb {
1190             let len                 = br.read(6)? as u32;
1191             br.skip((len + 1) * 8)?;
1192         }
1193
1194         let duration = BLOCK_LEN * NBLOCKS;
1195
1196         let core_channels = bsi.acmod.get_num_channels();
1197         let channels = core_channels + if bsi.lfeon { 1 } else { 0 };
1198
1199         let ainfo = NAAudioInfo::new(sinfo.samplerate >> bsi.shift, channels as u8,
1200                                      SND_F32P_FORMAT, BLOCK_LEN);
1201
1202         let abuf = alloc_audio_buffer(ainfo, duration, bsi.acmod.get_channel_map(bsi.lfeon))?;
1203         let mut adata = abuf.get_abuf_f32().unwrap();
1204         let output = adata.get_data_mut().unwrap();
1205
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();
1213             }
1214             for ch in 0..core_channels {
1215                 let dpos = abuf.get_offset(ch) + off;
1216                 let dst = &mut output[dpos..][..BLOCK_LEN];
1217                 if !all_zero {
1218                     self.ablk.synth_audio_block(&mut self.imdct512, &mut self.imdct256, &mut self.tmp, ch, &mut self.delay[ch], dst);
1219                 } else {
1220                     self.delay[ch] = [0.0; BLOCK_LEN];
1221                     for i in 0..BLOCK_LEN { dst[i] = 0.0; }
1222                 }
1223             }
1224             if bsi.lfeon {
1225                 let dpos = abuf.get_offset(core_channels) + off;
1226                 let dst = &mut output[dpos..][..BLOCK_LEN];
1227                 if !all_zero {
1228                     self.ablk.synth_audio_block(&mut self.imdct512, &mut self.imdct256, &mut self.tmp, LFE_CHANNEL, &mut self.delay[LFE_CHANNEL], dst);
1229                 } else {
1230                     self.delay[LFE_CHANNEL] = [0.0; BLOCK_LEN];
1231                     for i in 0..BLOCK_LEN { dst[i] = 0.0; }
1232                 }
1233             }
1234         }
1235 //todo skip auxdata
1236 //todo do errorcheck
1237
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)))
1241     }
1242 }
1243
1244 pub fn get_decoder() -> Box<NADecoder> {
1245     Box::new(AudioDecoder::new())
1246 }
1247
1248 #[cfg(test)]
1249 mod test {
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;
1255     #[test]
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);
1261
1262         let file = "assets/RV/sp_sample1.rm";
1263         test_decode_audio("realmedia", file, Some(12000), "ac3", &dmx_reg, &dec_reg);
1264     }
1265 }
1266
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 ];
1273
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,
1300     49, 49, 49, 0, 0, 0
1301 ];
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
1308 ];
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
1315 ];
1316
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
1350 ];
1351 const TS102366_HTH: [[u16; MAX_BANDS]; 3] = [
1352   [
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,
1358   ], [
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,
1364   ], [
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,
1370   ]
1371 ];
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
1377 ];
1378
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 ]
1407 ];
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 ],
1459 ];
1460 const TS102366_QUANT7_MAP: [i32; 7] = [
1461     -0xDB6DB6, -0x924924, -0x492492, 0x000000, 0x492492, 0x924924, 0xDB6DB6
1462 ];
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 ],
1505 ];
1506 const TS102366_QUANT15_MAP: [i32; 15] = [
1507  -0x0EEEEEE, -0x0CCCCCC, -0x0AAAAAA, -0x0888888, -0x0666666, -0x0444444, -0x0222222, 0x00000000,
1508              0x00222222, 0x00444444, 0x00666666, 0x00888888, 0x00AAAAAA, 0x00CCCCCC, 0x00EEEEEE,
1509 ];
1510 const TS102366_BAP_BITS: [u8; 10] = [ 5, 6, 7, 8, 9, 10, 11, 12, 14, 16 ];
1511
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,
1545 ];