nihav-commonfmt/src/codecs/ts102366.rs

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