nihav-commonfmt/src/codecs/aac.rs

   1 use nihav_core::formats::*;
   2 use nihav_core::frame::*;
   3 use nihav_core::codecs::*;
   4 use nihav_codec_support::dsp::mdct::IMDCT;
   5 use nihav_codec_support::dsp::window::*;
   6 use nihav_core::io::bitreader::*;
   7 use nihav_core::io::byteio::*;
   8 use nihav_core::io::codebook::*;
   9 use std::fmt;
  10 use nihav_core::io::intcode::*;
  11 use std::mem;
  12 use std::ptr;
  13 use std::str::FromStr;
  14 use std::f32::consts;
  15
  16 #[allow(non_camel_case_types)]
  17 #[derive(Clone,Copy,PartialEq)]
  18 enum M4AType {
  19     None,
  20     Main,
  21     LC,
  22     SSR,
  23     LTP,
  24     SBR,
  25     Scalable,
  26     TwinVQ,
  27     CELP,
  28     HVXC,
  29     TTSI,
  30     MainSynth,
  31     WavetableSynth,
  32     GeneralMIDI,
  33     Algorithmic,
  34     ER_AAC_LC,
  35     ER_AAC_LTP,
  36     ER_AAC_Scalable,
  37     ER_TwinVQ,
  38     ER_BSAC,
  39     ER_AAC_LD,
  40     ER_CELP,
  41     ER_HVXC,
  42     ER_HILN,
  43     ER_Parametric,
  44     SSC,
  45     PS,
  46     MPEGSurround,
  47     Layer1,
  48     Layer2,
  49     Layer3,
  50     DST,
  51     ALS,
  52     SLS,
  53     SLSNonCore,
  54     ER_AAC_ELD,
  55     SMRSimple,
  56     SMRMain,
  57     Reserved,
  58     Unknown,
  59 }
  60
  61 const M4A_TYPES: &[M4AType] = &[
  62     M4AType::None,              M4AType::Main,      M4AType::LC,            M4AType::SSR,
  63     M4AType::LTP,               M4AType::SBR,       M4AType::Scalable,      M4AType::TwinVQ,
  64     M4AType::CELP,              M4AType::HVXC,      M4AType::Reserved,      M4AType::Reserved,
  65     M4AType::TTSI,              M4AType::MainSynth, M4AType::WavetableSynth, M4AType::GeneralMIDI,
  66     M4AType::Algorithmic,       M4AType::ER_AAC_LC, M4AType::Reserved,      M4AType::ER_AAC_LTP,
  67     M4AType::ER_AAC_Scalable,   M4AType::ER_TwinVQ, M4AType::ER_BSAC,       M4AType::ER_AAC_LD,
  68     M4AType::ER_CELP,           M4AType::ER_HVXC,   M4AType::ER_HILN,       M4AType::ER_Parametric,
  69     M4AType::SSC,               M4AType::PS,        M4AType::MPEGSurround,  M4AType::Reserved /*escape*/,
  70     M4AType::Layer1,            M4AType::Layer2,    M4AType::Layer3,        M4AType::DST,
  71     M4AType::ALS,               M4AType::SLS,       M4AType::SLSNonCore,    M4AType::ER_AAC_ELD,
  72     M4AType::SMRSimple,         M4AType::SMRMain,
  73 ];
  74 const M4A_TYPE_NAMES: &[&str] = &[
  75     "None", "AAC Main", "AAC LC", "AAC SSR", "AAC LTP", "SBR", "AAC Scalable", "TwinVQ", "CELP", "HVXC",
  76     /*"(reserved10)", "(reserved11)", */ "TTSI",
  77     "Main synthetic", "Wavetable synthesis", "General MIDI", "Algorithmic Synthesis and Audio FX",
  78     "ER AAC LC", /*"(reserved18)",*/ "ER AAC LTP", "ER AAC Scalable", "ER TwinVQ", "ER BSAC", "ER AAC LD",
  79     "ER CELP", "ER HVXC", "ER HILN", "ER Parametric", "SSC", "PS", "MPEG Surround", /*"(escape)",*/
  80     "Layer-1", "Layer-2", "Layer-3", "DST", "ALS", "SLS", "SLS non-core", "ER AAC ELD", "SMR Simple", "SMR Main",
  81     "(reserved)", "(unknown)",
  82 ];
  83
  84 impl fmt::Display for M4AType {
  85     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  86         write!(f, "{}", M4A_TYPE_NAMES[*self as usize])
  87     }
  88 }
  89
  90 const AAC_SAMPLE_RATES: [u32; 16] = [
  91     96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050,
  92     16000, 12000, 11025,  8000,  7350, 0, 0, 0
  93 ];
  94
  95 const AAC_CHANNELS: [usize; 8] = [ 0, 1, 2, 3, 4, 5, 6, 8 ];
  96
  97 struct M4AInfo {
  98     otype:          M4AType,
  99     srate:          u32,
 100     channels:       usize,
 101     samples:        usize,
 102     sbr_ps_info:    Option<(u32, usize)>,
 103     sbr_present:    bool,
 104     ps_present:     bool,
 105 }
 106
 107 impl M4AInfo {
 108     fn new() -> Self {
 109         Self {
 110             otype:          M4AType::None,
 111             srate:          0,
 112             channels:       0,
 113             samples:        0,
 114             sbr_ps_info:    Option::None,
 115             sbr_present:    false,
 116             ps_present:     false,
 117         }
 118     }
 119     fn read_object_type(br: &mut BitReader) -> DecoderResult<M4AType> {
 120         let otypeidx;
 121         if br.peek(5) == 31 {
 122                                                           br.skip(5)?;
 123             otypeidx                                    = (br.read(6)? as usize) + 32;
 124         } else {
 125             otypeidx                                    = br.read(5)? as usize;
 126         }
 127         if otypeidx >= M4A_TYPES.len() {
 128             Ok(M4AType::Unknown)
 129         } else {
 130             Ok(M4A_TYPES[otypeidx])
 131         }
 132     }
 133     fn read_sampling_frequency(br: &mut BitReader) -> DecoderResult<u32> {
 134         if br.peek(4) == 15 {
 135             let srate                                   = br.read(24)?;
 136             Ok(srate)
 137         } else {
 138             let srate_idx                               = br.read(4)? as usize;
 139             Ok(AAC_SAMPLE_RATES[srate_idx])
 140         }
 141     }
 142     fn read_channel_config(br: &mut BitReader) -> DecoderResult<usize> {
 143         let chidx                                       = br.read(4)? as usize;
 144         if chidx < AAC_CHANNELS.len() {
 145             Ok(AAC_CHANNELS[chidx])
 146         } else {
 147             Ok(chidx)
 148         }
 149     }
 150     fn read(&mut self, src: &[u8]) -> DecoderResult<()> {
 151         let mut br = BitReader::new(src, BitReaderMode::BE);
 152         self.otype = Self::read_object_type(&mut br)?;
 153         self.srate = Self::read_sampling_frequency(&mut br)?;
 154         validate!(self.srate > 0);
 155         self.channels = Self::read_channel_config(&mut br)?;
 156
 157         if (self.otype == M4AType::SBR) || (self.otype == M4AType::PS) {
 158             let ext_srate = Self::read_sampling_frequency(&mut br)?;
 159             self.otype = Self::read_object_type(&mut br)?;
 160             let ext_chans;
 161             if self.otype == M4AType::ER_BSAC {
 162                 ext_chans = Self::read_channel_config(&mut br)?;
 163             } else {
 164                 ext_chans = 0;
 165             }
 166             self.sbr_ps_info = Some((ext_srate, ext_chans));
 167         }
 168
 169         match self.otype {
 170             M4AType::Main | M4AType::LC | M4AType::SSR | M4AType::Scalable | M4AType::TwinVQ |
 171             M4AType::ER_AAC_LC | M4AType::ER_AAC_LTP | M4AType::ER_AAC_Scalable | M4AType::ER_TwinVQ |
 172             M4AType::ER_BSAC | M4AType::ER_AAC_LD => {
 173                 // GASpecificConfig
 174                     let short_frame                     = br.read_bool()?;
 175                     self.samples = if short_frame { 960 } else { 1024 };
 176                     let depends_on_core                 = br.read_bool()?;
 177                     if depends_on_core {
 178                         let _delay                      = br.read(14)?;
 179                     }
 180                     let extension_flag                  = br.read_bool()?;
 181                     if self.channels == 0 {
 182                         unimplemented!("program config element");
 183                     }
 184                     if (self.otype == M4AType::Scalable) || (self.otype == M4AType::ER_AAC_Scalable) {
 185                         let _layer                      = br.read(3)?;
 186                     }
 187                     if extension_flag {
 188                         if self.otype == M4AType::ER_BSAC {
 189                             let _num_subframes          = br.read(5)? as usize;
 190                             let _layer_length           = br.read(11)?;
 191                         }
 192                         if (self.otype == M4AType::ER_AAC_LC) ||
 193                            (self.otype == M4AType::ER_AAC_LTP) ||
 194                            (self.otype == M4AType::ER_AAC_Scalable) ||
 195                            (self.otype == M4AType::ER_AAC_LD) {
 196                             let _section_data_resilience    = br.read_bool()?;
 197                             let _scalefactors_resilience    = br.read_bool()?;
 198                             let _spectral_data_resilience   = br.read_bool()?;
 199                         }
 200                         let extension_flag3             = br.read_bool()?;
 201                         if extension_flag3 {
 202                             unimplemented!("version3 extensions");
 203                         }
 204                     }
 205                 },
 206             M4AType::CELP => { unimplemented!("CELP config"); },
 207             M4AType::HVXC => { unimplemented!("HVXC config"); },
 208             M4AType::TTSI => { unimplemented!("TTS config"); },
 209             M4AType::MainSynth | M4AType::WavetableSynth | M4AType::GeneralMIDI | M4AType::Algorithmic => { unimplemented!("structured audio config"); },
 210             M4AType::ER_CELP => { unimplemented!("ER CELP config"); },
 211             M4AType::ER_HVXC => { unimplemented!("ER HVXC config"); },
 212             M4AType::ER_HILN | M4AType::ER_Parametric => { unimplemented!("parametric config"); },
 213             M4AType::SSC => { unimplemented!("SSC config"); },
 214             M4AType::MPEGSurround => {
 215                                                         br.skip(1)?; // sacPayloadEmbedding
 216                     unimplemented!("MPEG Surround config");
 217                 },
 218             M4AType::Layer1 | M4AType::Layer2 | M4AType::Layer3 => { unimplemented!("MPEG Layer 1/2/3 config"); },
 219             M4AType::DST => { unimplemented!("DST config"); },
 220             M4AType::ALS => {
 221                                                         br.skip(5)?; // fillBits
 222                     unimplemented!("ALS config");
 223                 },
 224             M4AType::SLS | M4AType::SLSNonCore => { unimplemented!("SLS config"); },
 225             M4AType::ER_AAC_ELD => { unimplemented!("ELD config"); },
 226             M4AType::SMRSimple | M4AType::SMRMain => { unimplemented!("symbolic music config"); },
 227             _ => {},
 228         };
 229         match self.otype {
 230             M4AType::ER_AAC_LC | M4AType::ER_AAC_LTP | M4AType::ER_AAC_Scalable | M4AType::ER_TwinVQ |
 231             M4AType::ER_BSAC | M4AType::ER_AAC_LD | M4AType::ER_CELP | M4AType::ER_HVXC |
 232             M4AType::ER_HILN | M4AType::ER_Parametric | M4AType::ER_AAC_ELD => {
 233                     let ep_config                       = br.read(2)?;
 234                     if (ep_config == 2) || (ep_config == 3) {
 235                         unimplemented!("error protection config");
 236                     }
 237                     if ep_config == 3 {
 238                         let direct_mapping              = br.read_bool()?;
 239                         validate!(direct_mapping);
 240                     }
 241                 },
 242             _ => {},
 243         };
 244         if self.sbr_ps_info.is_some() && (br.left() >= 16) {
 245             let sync                                    = br.read(11)?;
 246             if sync == 0x2B7 {
 247                 let ext_otype = Self::read_object_type(&mut br)?;
 248                 if ext_otype == M4AType::SBR {
 249                     self.sbr_present                    = br.read_bool()?;
 250                     if self.sbr_present {
 251                         let _ext_srate = Self::read_sampling_frequency(&mut br)?;
 252                         if br.left() >= 12 {
 253                             let sync                    = br.read(11)?;
 254                             if sync == 0x548 {
 255                                 self.ps_present         = br.read_bool()?;
 256                             }
 257                         }
 258                     }
 259                 }
 260                 if ext_otype == M4AType::PS {
 261                     self.sbr_present                    = br.read_bool()?;
 262                     if self.sbr_present {
 263                         let _ext_srate = Self::read_sampling_frequency(&mut br)?;
 264                     }
 265                     let _ext_channels = br.read(4)?;
 266                 }
 267             }
 268         }
 269
 270         Ok(())
 271     }
 272 }
 273
 274 impl fmt::Display for M4AInfo {
 275     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 276         write!(f, "MPEG 4 Audio {}, {} Hz, {} channels, {} samples per frame",
 277                self.otype, self.srate, self.channels, self.samples)
 278     }
 279 }
 280
 281 const MAX_WINDOWS:  usize = 8;
 282 const MAX_SFBS:     usize = 64;
 283
 284 #[derive(Clone,Copy)]
 285 struct ICSInfo {
 286     window_sequence:        u8,
 287     prev_window_sequence:   u8,
 288     window_shape:           bool,
 289     prev_window_shape:      bool,
 290     scale_factor_grouping:  [bool; MAX_WINDOWS],
 291     group_start:            [usize; MAX_WINDOWS],
 292     window_groups:          usize,
 293     num_windows:            usize,
 294     max_sfb:                usize,
 295     predictor_data:         Option<LTPData>,
 296     long_win:               bool,
 297 }
 298
 299 const ONLY_LONG_SEQUENCE:   u8 = 0;
 300 const LONG_START_SEQUENCE:  u8 = 1;
 301 const EIGHT_SHORT_SEQUENCE: u8 = 2;
 302 const LONG_STOP_SEQUENCE:   u8 = 3;
 303
 304 impl ICSInfo {
 305     fn new() -> Self {
 306         Self {
 307             window_sequence:        0,
 308             prev_window_sequence:   0,
 309             window_shape:           false,
 310             prev_window_shape:      false,
 311             scale_factor_grouping:  [false; MAX_WINDOWS],
 312             group_start:            [0; MAX_WINDOWS],
 313             num_windows:            0,
 314             window_groups:          0,
 315             max_sfb:                0,
 316             predictor_data:         None,
 317             long_win:               true,
 318         }
 319     }
 320     fn decode_ics_info(&mut self, br: &mut BitReader) -> DecoderResult<()> {
 321         self.prev_window_sequence = self.window_sequence;
 322         self.prev_window_shape    = self.window_shape;
 323         let ics_reserved_bit                            = br.read(1)?;
 324         validate!(ics_reserved_bit == 0);
 325         self.window_sequence                            = br.read(2)? as u8;
 326         match self.prev_window_sequence {
 327             ONLY_LONG_SEQUENCE | LONG_STOP_SEQUENCE => {
 328                     validate!((self.window_sequence == ONLY_LONG_SEQUENCE) ||
 329                               (self.window_sequence == LONG_START_SEQUENCE));
 330                 },
 331             LONG_START_SEQUENCE | EIGHT_SHORT_SEQUENCE => {
 332                     validate!((self.window_sequence == EIGHT_SHORT_SEQUENCE) ||
 333                               (self.window_sequence == LONG_STOP_SEQUENCE));
 334                 },
 335             _ => {},
 336         };
 337         self.window_shape                               = br.read_bool()?;
 338         self.window_groups = 1;
 339         if self.window_sequence == EIGHT_SHORT_SEQUENCE {
 340             self.long_win = false;
 341             self.num_windows = 8;
 342             self.max_sfb                                = br.read(4)? as usize;
 343             for i in 0..MAX_WINDOWS-1 {
 344                 self.scale_factor_grouping[i]           = br.read_bool()?;
 345                 if !self.scale_factor_grouping[i] {
 346                     self.group_start[self.window_groups] = i + 1;
 347                     self.window_groups += 1;
 348                 }
 349             }
 350         } else {
 351             self.long_win = true;
 352             self.num_windows = 1;
 353             self.max_sfb                                = br.read(6)? as usize;
 354             self.predictor_data = LTPData::read(br)?;
 355         }
 356         Ok(())
 357     }
 358     fn get_group_start(&self, g: usize) -> usize {
 359         if g == 0 {
 360             0
 361         } else if g >= self.window_groups {
 362             if self.long_win { 1 } else { 8 }
 363         } else {
 364             self.group_start[g]
 365         }
 366     }
 367 }
 368
 369 #[derive(Clone,Copy)]
 370 struct LTPData {
 371 }
 372
 373 impl LTPData {
 374     fn read(br: &mut BitReader) -> DecoderResult<Option<Self>> {
 375         let predictor_data_present                      = br.read_bool()?;
 376         if !predictor_data_present { return Ok(None); }
 377 unimplemented!("predictor data");
 378 /*
 379         if is_main {
 380             let predictor_reset                         = br.read_bool()?;
 381             if predictor_reset {
 382                 let predictor_reset_group_number        = br.read(5)?;
 383             }
 384             for sfb in 0..max_sfb.min(PRED_SFB_MAX) {
 385                 prediction_used[sfb]                    = br.read_bool()?;
 386             }
 387         } else {
 388             let ltp_data_present                        = br.read_bool()?;
 389             if ltp_data_present {
 390                 //ltp data
 391             }
 392             if common_window {
 393                 let ltp_data_present                    = br.read_bool()?;
 394                 if ltp_data_present {
 395                     //ltp data
 396                 }
 397             }
 398         }
 399         Ok(Some(Self { }))
 400 */
 401     }
 402 }
 403
 404 #[derive(Clone,Copy)]
 405 #[allow(dead_code)]
 406 struct PulseData {
 407     number_pulse:       usize,
 408     pulse_start_sfb:    usize,
 409     pulse_offset:       [u8; 4],
 410     pulse_amp:          [u8; 4],
 411 }
 412
 413 impl PulseData {
 414     fn read(br: &mut BitReader) -> DecoderResult<Option<Self>> {
 415         let pulse_data_present                          = br.read_bool()?;
 416         if !pulse_data_present { return Ok(None); }
 417
 418         let number_pulse                                = (br.read(2)? as usize) + 1;
 419         let pulse_start_sfb                             = br.read(6)? as usize;
 420         let mut pulse_offset: [u8; 4] = [0; 4];
 421         let mut pulse_amp: [u8; 4] = [0; 4];
 422         for i in 0..number_pulse {
 423             pulse_offset[i]                             = br.read(5)? as u8;
 424             pulse_amp[i]                                = br.read(4)? as u8;
 425         }
 426         Ok(Some(Self{ number_pulse, pulse_start_sfb, pulse_offset, pulse_amp }))
 427     }
 428 }
 429
 430 const TNS_MAX_ORDER: usize = 20;
 431 const TNS_MAX_LONG_BANDS: [usize; 12] = [ 31, 31, 34, 40, 42, 51, 46, 46, 42, 42, 42, 39 ];
 432 const TNS_MAX_SHORT_BANDS: [usize; 12] = [ 9, 9, 10, 14, 14, 14, 14, 14, 14, 14, 14, 14 ];
 433
 434 #[derive(Clone,Copy)]
 435 struct TNSCoeffs {
 436     length:     usize,
 437     order:      usize,
 438     direction:  bool,
 439     compress:   bool,
 440     coef:       [f32; TNS_MAX_ORDER + 1],
 441 }
 442
 443 impl TNSCoeffs {
 444     fn new() -> Self {
 445         Self {
 446             length: 0, order: 0, direction: false, compress: false, coef: [0.0; TNS_MAX_ORDER + 1],
 447         }
 448     }
 449     fn read(&mut self, br: &mut BitReader, long_win: bool, coef_res: bool, max_order: usize) -> DecoderResult<()> {
 450         self.length                                     = br.read(if long_win { 6 } else { 4 })? as usize;
 451         self.order                                      = br.read(if long_win { 5 } else { 3 })? as usize;
 452         validate!(self.order <= max_order);
 453         if self.order > 0 {
 454             self.direction                              = br.read_bool()?;
 455             self.compress                               = br.read_bool()?;
 456             let mut coef_bits = 3;
 457             if coef_res      { coef_bits += 1; }
 458             if self.compress { coef_bits -= 1; }
 459             let sign_mask = 1 << (coef_bits - 1);
 460             let neg_mask  = !(sign_mask * 2 - 1);
 461
 462             let fac_base = if coef_res { 1 << 3 } else { 1 << 2 } as f32;
 463             let iqfac   = (fac_base - 0.5) / (consts::PI / 2.0);
 464             let iqfac_m = (fac_base + 0.5) / (consts::PI / 2.0);
 465             let mut tmp: [f32; TNS_MAX_ORDER] = [0.0; TNS_MAX_ORDER];
 466             for el in tmp.iter_mut().take(self.order) {
 467                 let val                                 = br.read(coef_bits)? as i8;
 468                 let c = f32::from(if (val & sign_mask) != 0 { val | neg_mask } else { val });
 469                 *el = (if c >= 0.0 { c / iqfac } else { c / iqfac_m }).sin();
 470             }
 471             // convert to LPC coefficients
 472             let mut b: [f32; TNS_MAX_ORDER + 1] = [0.0; TNS_MAX_ORDER + 1];
 473             for m in 1..=self.order {
 474                 for i in 1..m {
 475                     b[i] = self.coef[i - 1] + tmp[m - 1] * self.coef[m - i - 1];
 476                 }
 477                 for i in 1..m {
 478                     self.coef[i - 1] = b[i];
 479                 }
 480                 self.coef[m - 1] = tmp[m - 1];
 481             }
 482         }
 483         Ok(())
 484     }
 485 }
 486
 487 #[derive(Clone,Copy)]
 488 #[allow(dead_code)]
 489 struct TNSData {
 490     n_filt:     [usize; MAX_WINDOWS],
 491     coef_res:   [bool; MAX_WINDOWS],
 492     coeffs:     [[TNSCoeffs; 4]; MAX_WINDOWS],
 493 }
 494
 495 impl TNSData {
 496     fn read(br: &mut BitReader, long_win: bool, num_windows: usize, max_order: usize) -> DecoderResult<Option<Self>> {
 497         let tns_data_present                            = br.read_bool()?;
 498         if !tns_data_present { return Ok(None); }
 499         let mut n_filt: [usize; MAX_WINDOWS] = [0; MAX_WINDOWS];
 500         let mut coef_res: [bool; MAX_WINDOWS] = [false; MAX_WINDOWS];
 501         let mut coeffs: [[TNSCoeffs; 4]; MAX_WINDOWS] = [[TNSCoeffs::new(); 4]; MAX_WINDOWS];
 502         for w in 0..num_windows {
 503             n_filt[w]                                   = br.read(if long_win { 2 } else { 1 })? as usize;
 504             if n_filt[w] != 0 {
 505                 coef_res[w]                             = br.read_bool()?;
 506             }
 507             for filt in 0..n_filt[w] {
 508                 coeffs[w][filt].read(br, long_win, coef_res[w], max_order)?;
 509             }
 510         }
 511         Ok(Some(Self { n_filt, coef_res, coeffs }))
 512     }
 513 }
 514
 515 #[derive(Clone,Copy)]
 516 #[allow(dead_code)]
 517 struct GainControlData {
 518     max_band:       u8,
 519 }
 520
 521 impl GainControlData {
 522     fn read(br: &mut BitReader) -> DecoderResult<Option<Self>> {
 523         let gain_control_data_present                   = br.read_bool()?;
 524         if !gain_control_data_present { return Ok(None); }
 525 unimplemented!("gain control data");
 526 /*        self.max_band                                   = br.read(2)? as u8;
 527         if window_sequence == ONLY_LONG_SEQUENCE {
 528             for bd in 0..max_band
 529 ...
 530         }
 531         Ok(Some(Self { }))*/
 532     }
 533 }
 534
 535 const ZERO_HCB:         u8 = 0;
 536 const FIRST_PAIR_HCB:   u8 = 5;
 537 const ESC_HCB:          u8 = 11;
 538 const RESERVED_HCB:     u8 = 12;
 539 const NOISE_HCB:        u8 = 13;
 540 const INTENSITY_HCB2:   u8 = 14;
 541 const INTENSITY_HCB:    u8 = 15;
 542
 543 struct Codebooks {
 544     scale_cb:       Codebook<i8>,
 545     spec_cb:        [Codebook<u16>; 11],
 546 }
 547
 548 fn scale_map(idx: usize) -> i8 { (idx as i8) - 60 }
 549 fn cb_map(idx: usize) -> u16 { idx as u16 }
 550
 551 impl Codebooks {
 552     fn new() -> Self {
 553         let mut coderead = TableCodebookDescReader::new(AAC_SCF_CODEBOOK_CODES, AAC_SCF_CODEBOOK_BITS, scale_map);
 554         let scale_cb = Codebook::new(&mut coderead, CodebookMode::MSB).unwrap();
 555         let mut spec_cb: [Codebook<u16>; 11];
 556         unsafe {
 557             spec_cb = mem::uninitialized();
 558             for i in 0..AAC_SPEC_CODES.len() {
 559                 let mut coderead = TableCodebookDescReader::new(AAC_SPEC_CODES[i], AAC_SPEC_BITS[i], cb_map);
 560                 ptr::write(&mut spec_cb[i], Codebook::new(&mut coderead, CodebookMode::MSB).unwrap());
 561             }
 562         }
 563         Self { scale_cb, spec_cb }
 564     }
 565 }
 566
 567 #[derive(Clone)]
 568 struct ICS {
 569     global_gain:    u8,
 570     info:           ICSInfo,
 571     pulse_data:     Option<PulseData>,
 572     tns_data:       Option<TNSData>,
 573     gain_control:   Option<GainControlData>,
 574     sect_cb:        [[u8; MAX_SFBS]; MAX_WINDOWS],
 575     sect_len:       [[usize; MAX_SFBS]; MAX_WINDOWS],
 576     sfb_cb:         [[u8; MAX_SFBS]; MAX_WINDOWS],
 577     num_sec:        [usize; MAX_WINDOWS],
 578     scales:         [[u8; MAX_SFBS]; MAX_WINDOWS],
 579     sbinfo:         GASubbandInfo,
 580     coeffs:         [f32; 1024],
 581     delay:          [f32; 1024],
 582 }
 583
 584 const INTENSITY_SCALE_MIN:  i16 = -155;
 585 const NOISE_SCALE_MIN:      i16 = -100;
 586 impl ICS {
 587     fn new(sbinfo: GASubbandInfo) -> Self {
 588         Self {
 589             global_gain:    0,
 590             info:           ICSInfo::new(),
 591             pulse_data:     None,
 592             tns_data:       None,
 593             gain_control:   None,
 594             sect_cb:        [[0; MAX_SFBS]; MAX_WINDOWS],
 595             sect_len:       [[0; MAX_SFBS]; MAX_WINDOWS],
 596             sfb_cb:         [[0; MAX_SFBS]; MAX_WINDOWS],
 597             scales:         [[0; MAX_SFBS]; MAX_WINDOWS],
 598             num_sec:        [0; MAX_WINDOWS],
 599             sbinfo,
 600             coeffs:         [0.0; 1024],
 601             delay:          [0.0; 1024],
 602         }
 603     }
 604     fn decode_section_data(&mut self, br: &mut BitReader, may_have_intensity: bool) -> DecoderResult<()> {
 605         let sect_bits = if self.info.long_win { 5 } else { 3 };
 606         let sect_esc_val = (1 << sect_bits) - 1;
 607
 608         for g in 0..self.info.window_groups {
 609             let mut k = 0;
 610             let mut l = 0;
 611             while k < self.info.max_sfb {
 612                 self.sect_cb[g][l]                      = br.read(4)? as u8;
 613                 self.sect_len[g][l] = 0;
 614                 validate!(self.sect_cb[g][l] != RESERVED_HCB);
 615                 if ((self.sect_cb[g][l] == INTENSITY_HCB) || (self.sect_cb[g][l] == INTENSITY_HCB2)) && !may_have_intensity {
 616                     return Err(DecoderError::InvalidData);
 617                 }
 618                 loop {
 619                     let sect_len_incr                   = br.read(sect_bits)? as usize;
 620                     self.sect_len[g][l] += sect_len_incr;
 621                     if sect_len_incr < sect_esc_val { break; }
 622                 }
 623                 validate!(k + self.sect_len[g][l] <= self.info.max_sfb);
 624                 for _ in 0..self.sect_len[g][l] {
 625                     self.sfb_cb[g][k] = self.sect_cb[g][l];
 626                     k += 1;
 627                 }
 628                 l += 1;
 629             }
 630             self.num_sec[g] = l;
 631         }
 632         Ok(())
 633     }
 634     fn is_intensity(&self, g: usize, sfb: usize) -> bool {
 635         (self.sfb_cb[g][sfb] == INTENSITY_HCB) || (self.sfb_cb[g][sfb] == INTENSITY_HCB2)
 636     }
 637     fn get_intensity_dir(&self, g: usize, sfb: usize) -> bool {
 638         self.sfb_cb[g][sfb] == INTENSITY_HCB
 639     }
 640     fn decode_scale_factor_data(&mut self, br: &mut BitReader, codebooks: &Codebooks) -> DecoderResult<()> {
 641         let mut noise_pcm_flag = true;
 642         let mut scf_normal = i16::from(self.global_gain);
 643         let mut scf_intensity = 0i16;
 644         let mut scf_noise  = 0i16;
 645         for g in 0..self.info.window_groups {
 646             for sfb in 0..self.info.max_sfb {
 647                 if self.sfb_cb[g][sfb] != ZERO_HCB {
 648                     if self.is_intensity(g, sfb) {
 649                         let diff                        = i16::from(br.read_cb(&codebooks.scale_cb)?);
 650                         scf_intensity += diff;
 651                         validate!((scf_intensity >= INTENSITY_SCALE_MIN) && (scf_intensity < INTENSITY_SCALE_MIN + 256));
 652                         self.scales[g][sfb] = (scf_intensity - INTENSITY_SCALE_MIN) as u8;
 653                     } else if self.sfb_cb[g][sfb] == NOISE_HCB {
 654                         if noise_pcm_flag {
 655                             noise_pcm_flag = false;
 656                             scf_noise                   = (br.read(9)? as i16) - 256 + i16::from(self.global_gain) - 90;
 657                         } else {
 658                             scf_noise                  += i16::from(br.read_cb(&codebooks.scale_cb)?);
 659                         }
 660                         validate!((scf_noise >= NOISE_SCALE_MIN) && (scf_noise < NOISE_SCALE_MIN + 256));
 661                         self.scales[g][sfb] = (scf_noise - NOISE_SCALE_MIN) as u8;
 662                     } else {
 663                         scf_normal                     += i16::from(br.read_cb(&codebooks.scale_cb)?);
 664                         validate!((scf_normal >= 0) && (scf_normal < 255));
 665                         self.scales[g][sfb] = scf_normal as u8;
 666                     }
 667                 }
 668             }
 669         }
 670         Ok(())
 671     }
 672     fn get_band_start(&self, swb: usize) -> usize {
 673         if self.info.long_win {
 674             self.sbinfo.long_bands[swb]
 675         } else {
 676             self.sbinfo.short_bands[swb]
 677         }
 678     }
 679     fn get_num_bands(&self) -> usize {
 680         if self.info.long_win {
 681             self.sbinfo.long_bands.len() - 1
 682         } else {
 683             self.sbinfo.short_bands.len() - 1
 684         }
 685     }
 686     fn decode_spectrum(&mut self, br: &mut BitReader, codebooks: &Codebooks) -> DecoderResult<()> {
 687         self.coeffs = [0.0; 1024];
 688         for g in 0..self.info.window_groups {
 689             let cur_w   = self.info.get_group_start(g);
 690             let next_w  = self.info.get_group_start(g + 1);
 691             for sfb in 0..self.info.max_sfb {
 692                 let start = self.get_band_start(sfb);
 693                 let end   = self.get_band_start(sfb + 1);
 694                 let cb_idx = self.sfb_cb[g][sfb];
 695                 for w in cur_w..next_w {
 696                     let dst = &mut self.coeffs[start + w*128..end + w*128];
 697                     match cb_idx {
 698                         ZERO_HCB => { /* zeroes */ },
 699                         NOISE_HCB => { /* noise */ },
 700                         INTENSITY_HCB | INTENSITY_HCB2 => { /* intensity */ },
 701                         _ => {
 702                                 let unsigned = AAC_UNSIGNED_CODEBOOK[(cb_idx - 1) as usize];
 703                                 let scale = get_scale(self.scales[g][sfb]);
 704                                 let cb = &codebooks.spec_cb[(cb_idx - 1) as usize];
 705                                 if cb_idx < FIRST_PAIR_HCB {
 706                                     decode_quads(br, cb, unsigned, scale, dst)?;
 707                                 } else {
 708                                     decode_pairs(br, cb, unsigned, cb_idx == ESC_HCB,
 709                                                  AAC_CODEBOOK_MODULO[(cb_idx - FIRST_PAIR_HCB) as usize], scale, dst)?;
 710                                 }
 711                             },
 712                     };
 713                 }
 714             }
 715         }
 716         Ok(())
 717     }
 718     fn place_pulses(&mut self) {
 719         if let Some(ref pdata) = self.pulse_data {
 720             if pdata.pulse_start_sfb >= self.sbinfo.long_bands.len() - 1 { return; }
 721             let mut k = self.get_band_start(pdata.pulse_start_sfb);
 722             let mut band = pdata.pulse_start_sfb;
 723             for pno in 0..pdata.number_pulse {
 724                 k += pdata.pulse_offset[pno] as usize;
 725                 if k >= 1024 { return; }
 726                 while self.get_band_start(band + 1) <= k { band += 1; }
 727                 let scale = get_scale(self.scales[0][band]);
 728                 let mut base = self.coeffs[k];
 729                 if base != 0.0 {
 730                     base = requant(self.coeffs[k], scale);
 731                 }
 732                 if base > 0.0 {
 733                     base += f32::from(pdata.pulse_amp[pno]);
 734                 } else {
 735                     base -= f32::from(pdata.pulse_amp[pno]);
 736                 }
 737                 self.coeffs[k] = iquant(base) * scale;
 738             }
 739         }
 740     }
 741     fn decode_ics(&mut self, br: &mut BitReader, codebooks: &Codebooks, m4atype: M4AType, common_window: bool, may_have_intensity: bool) -> DecoderResult<()> {
 742         self.global_gain                                = br.read(8)? as u8;
 743         if !common_window {
 744             self.info.decode_ics_info(br)?;
 745         }
 746         self.decode_section_data(br, may_have_intensity)?;
 747         self.decode_scale_factor_data(br, codebooks)?;
 748         self.pulse_data = PulseData::read(br)?;
 749         validate!(self.pulse_data.is_none() || self.info.long_win);
 750         let tns_max_order;
 751         if !self.info.long_win {
 752             tns_max_order = 7;
 753         } else if m4atype == M4AType::LC {
 754             tns_max_order = 12;
 755         } else {
 756             tns_max_order = TNS_MAX_ORDER;
 757         }
 758         self.tns_data = TNSData::read(br, self.info.long_win, self.info.num_windows, tns_max_order)?;
 759         if m4atype == M4AType::SSR {
 760             self.gain_control = GainControlData::read(br)?;
 761         } else {
 762             let gain_control_data_present               = br.read_bool()?;
 763             validate!(!gain_control_data_present);
 764         }
 765         self.decode_spectrum(br, codebooks)?;
 766         Ok(())
 767     }
 768     fn synth_channel(&mut self, dsp: &mut DSP, dst: &mut [f32], srate_idx: usize) {
 769         self.place_pulses();
 770         if let Some(ref tns_data) = self.tns_data {
 771             let tns_max_bands = (if self.info.long_win {
 772                     TNS_MAX_LONG_BANDS[srate_idx]
 773                 } else {
 774                     TNS_MAX_SHORT_BANDS[srate_idx]
 775                 }).min(self.info.max_sfb);
 776             for w in 0..self.info.num_windows {
 777                 let mut bottom = self.get_num_bands();
 778                 for f in 0..tns_data.n_filt[w] {
 779                     let top = bottom;
 780                     bottom = if top >= tns_data.coeffs[w][f].length { top - tns_data.coeffs[w][f].length } else { 0 };
 781                     let order = tns_data.coeffs[w][f].order;
 782                     if order == 0 { continue; }
 783                     let start = w * 128 + self.get_band_start(tns_max_bands.min(bottom));
 784                     let end   = w * 128 + self.get_band_start(tns_max_bands.min(top));
 785                     let lpc = &tns_data.coeffs[w][f].coef;
 786                     let mut state = [0.0f32; 64];
 787                     let mut sidx = 32;
 788                     if !tns_data.coeffs[w][f].direction {
 789                         for m in start..end {
 790                             for i in 0..order {
 791                                 self.coeffs[m] -= state[(sidx + i) & 63] * lpc[i];
 792                             }
 793                             sidx = (sidx + 63) & 63;
 794                             state[sidx] = self.coeffs[m];
 795                         }
 796                     } else {
 797                         for m in (start..end).rev() {
 798                             for i in 0..order {
 799                                 self.coeffs[m] -= state[(sidx + i) & 63] * lpc[i];
 800                             }
 801                             sidx = (sidx + 63) & 63;
 802                             state[sidx] = self.coeffs[m];
 803                         }
 804                     }
 805                 }
 806             }
 807         }
 808         dsp.synth(&self.coeffs, &mut self.delay, self.info.window_sequence, self.info.window_shape, self.info.prev_window_shape, dst);
 809     }
 810 }
 811
 812 fn get_scale(scale: u8) -> f32 {
 813     2.0f32.powf(0.25 * (f32::from(scale) - 100.0 - 56.0))
 814 }
 815 fn iquant(val: f32) -> f32 {
 816     if val < 0.0 {
 817         -((-val).powf(4.0 / 3.0))
 818     } else {
 819         val.powf(4.0 / 3.0)
 820     }
 821 }
 822 fn requant(val: f32, scale: f32) -> f32 {
 823     if scale == 0.0 { return 0.0; }
 824     let bval = val / scale;
 825     if bval >= 0.0 {
 826         val.powf(3.0 / 4.0)
 827     } else {
 828         -((-val).powf(3.0 / 4.0))
 829     }
 830 }
 831 fn decode_quads(br: &mut BitReader, cb: &Codebook<u16>, unsigned: bool, scale: f32, dst: &mut [f32]) -> DecoderResult<()> {
 832     for out in dst.chunks_mut(4) {
 833         let cw                                          = br.read_cb(cb)? as usize;
 834         if unsigned {
 835             for i in 0..4 {
 836                 let val = AAC_QUADS[cw][i];
 837                 if val != 0 {
 838                     if br.read_bool()? {
 839                         out[i] = iquant(-f32::from(val)) * scale;
 840                     } else {
 841                         out[i] = iquant( f32::from(val)) * scale;
 842                     }
 843                 }
 844             }
 845         } else {
 846             for i in 0..4 {
 847                 out[i] = iquant(f32::from(AAC_QUADS[cw][i] - 1)) * scale;
 848             }
 849         }
 850     }
 851     Ok(())
 852 }
 853 fn decode_pairs(br: &mut BitReader, cb: &Codebook<u16>, unsigned: bool, escape: bool, modulo: u16, scale: f32, dst: &mut [f32]) -> DecoderResult<()> {
 854     for out in dst.chunks_mut(2) {
 855         let cw                                          = br.read_cb(cb)?;
 856         let mut x = (cw / modulo) as i16;
 857         let mut y = (cw % modulo) as i16;
 858         if unsigned {
 859             if x != 0 && br.read_bool()? {
 860                 x = -x;
 861             }
 862             if y != 0 && br.read_bool()? {
 863                 y = -y;
 864             }
 865         } else {
 866             x -= (modulo >> 1) as i16;
 867             y -= (modulo >> 1) as i16;
 868         }
 869         if escape {
 870             if (x == 16) || (x == -16) {
 871                 x += read_escape(br, x > 0)?;
 872             }
 873             if (y == 16) || (y == -16) {
 874                 y += read_escape(br, y > 0)?;
 875             }
 876         }
 877         out[0] = iquant(f32::from(x)) * scale;
 878         out[1] = iquant(f32::from(y)) * scale;
 879     }
 880     Ok(())
 881 }
 882 fn read_escape(br: &mut BitReader, sign: bool) -> DecoderResult<i16> {
 883     let prefix                                          = br.read_code(UintCodeType::UnaryOnes)? as u8;
 884     validate!(prefix < 9);
 885     let bits                                            = br.read(prefix + 4)? as i16;
 886     let bits = bits | (1 << (prefix + 4));
 887     if sign {
 888         Ok(bits)
 889     } else {
 890         Ok(-bits)
 891     }
 892 }
 893
 894 #[derive(Clone)]
 895 struct ChannelPair {
 896     pair:               bool,
 897     channel:            usize,
 898     common_window:      bool,
 899     ms_mask_present:    u8,
 900     ms_used:            [[bool; MAX_SFBS]; MAX_WINDOWS],
 901     ics:                [ICS; 2],
 902 }
 903
 904 impl ChannelPair {
 905     fn new(pair: bool, channel: usize, sbinfo: GASubbandInfo) -> Self {
 906         Self {
 907             pair, channel,
 908             common_window:      false,
 909             ms_mask_present:    0,
 910             ms_used:            [[false; MAX_SFBS]; MAX_WINDOWS],
 911             ics:                [ICS::new(sbinfo), ICS::new(sbinfo)],
 912         }
 913     }
 914     fn decode_ga_sce(&mut self, br: &mut BitReader, codebooks: &Codebooks, m4atype: M4AType) -> DecoderResult<()> {
 915         self.ics[0].decode_ics(br, codebooks, m4atype, false, false)?;
 916         Ok(())
 917     }
 918     fn decode_ga_cpe(&mut self, br: &mut BitReader, codebooks: &Codebooks, m4atype: M4AType) -> DecoderResult<()> {
 919         let common_window                               = br.read_bool()?;
 920         self.common_window = common_window;
 921         if common_window {
 922             self.ics[0].info.decode_ics_info(br)?;
 923             self.ms_mask_present                        = br.read(2)? as u8;
 924             validate!(self.ms_mask_present != 3);
 925             if self.ms_mask_present == 1 {
 926                 for g in 0..self.ics[0].info.window_groups {
 927                     for sfb in 0..self.ics[0].info.max_sfb {
 928                         self.ms_used[g][sfb]            = br.read_bool()?;
 929                     }
 930                 }
 931             }
 932             self.ics[1].info = self.ics[0].info;
 933         }
 934         self.ics[0].decode_ics(br, codebooks, m4atype, common_window, true)?;
 935         self.ics[1].decode_ics(br, codebooks, m4atype, common_window, true)?;
 936         if common_window && self.ms_mask_present != 0 {
 937             let mut g = 0;
 938             for w in 0..self.ics[0].info.num_windows {
 939                 if w > 0 && !self.ics[0].info.scale_factor_grouping[w - 1] {
 940                     g += 1;
 941                 }
 942                 for sfb in 0..self.ics[0].info.max_sfb {
 943                     let start = w * 128 + self.ics[0].get_band_start(sfb);
 944                     let end   = w * 128 + self.ics[0].get_band_start(sfb + 1);
 945                     if self.ics[0].is_intensity(g, sfb) {
 946                         let invert = (self.ms_mask_present == 1) && self.ms_used[g][sfb];
 947                         let dir = self.ics[0].get_intensity_dir(g, sfb) ^ invert;
 948                         let scale = 0.5f32.powf(0.25 * (f32::from(self.ics[0].scales[g][sfb]) + f32::from(INTENSITY_SCALE_MIN)));
 949                         if !dir {
 950                             for i in start..end {
 951                                 self.ics[1].coeffs[i] = scale * self.ics[0].coeffs[i];
 952                             }
 953                         } else {
 954                             for i in start..end {
 955                                 self.ics[1].coeffs[i] = -scale * self.ics[0].coeffs[i];
 956                             }
 957                         }
 958                     } else if (self.ms_mask_present == 2) || self.ms_used[g][sfb] {
 959                         for i in start..end {
 960                             let tmp = self.ics[0].coeffs[i] - self.ics[1].coeffs[i];
 961                             self.ics[0].coeffs[i] += self.ics[1].coeffs[i];
 962                             self.ics[1].coeffs[i] = tmp;
 963                         }
 964                     }
 965                 }
 966             }
 967         }
 968         Ok(())
 969     }
 970     fn synth_audio(&mut self, dsp: &mut DSP, abuf: &mut NABufferType, srate_idx: usize) {
 971         let mut adata = abuf.get_abuf_f32().unwrap();
 972         let output = adata.get_data_mut().unwrap();
 973         let off0 = abuf.get_offset(self.channel);
 974         let off1 = abuf.get_offset(self.channel + 1);
 975         self.ics[0].synth_channel(dsp, &mut output[off0..], srate_idx);
 976         if self.pair {
 977             self.ics[1].synth_channel(dsp, &mut output[off1..], srate_idx);
 978         }
 979     }
 980 }
 981
 982 struct DSP {
 983     kbd_long_win:   [f32; 1024],
 984     kbd_short_win:  [f32; 128],
 985     sine_long_win:  [f32; 1024],
 986     sine_short_win: [f32; 128],
 987     imdct_long:     IMDCT,
 988     imdct_short:    IMDCT,
 989     tmp:            [f32; 2048],
 990     ew_buf:         [f32; 1152],
 991 }
 992
 993 const SHORT_WIN_POINT0: usize = 512 - 64;
 994 const SHORT_WIN_POINT1: usize = 512 + 64;
 995
 996 impl DSP {
 997     fn new() -> Self {
 998         let mut kbd_long_win: [f32; 1024] = [0.0; 1024];
 999         let mut kbd_short_win: [f32; 128] = [0.0; 128];
1000         generate_window(WindowType::KaiserBessel(4.0), 1.0, 1024, true, &mut kbd_long_win);
1001         generate_window(WindowType::KaiserBessel(6.0), 1.0,  128, true, &mut kbd_short_win);
1002         let mut sine_long_win: [f32; 1024] = [0.0; 1024];
1003         let mut sine_short_win: [f32; 128] = [0.0; 128];
1004         generate_window(WindowType::Sine, 1.0, 1024, true, &mut sine_long_win);
1005         generate_window(WindowType::Sine, 1.0,  128, true, &mut sine_short_win);
1006         Self {
1007             kbd_long_win, kbd_short_win,
1008             sine_long_win, sine_short_win,
1009             imdct_long: IMDCT::new(1024 * 2, true),
1010             imdct_short: IMDCT::new(128 * 2, true),
1011             tmp: [0.0; 2048], ew_buf: [0.0; 1152],
1012         }
1013     }
1014     #[allow(clippy::cyclomatic_complexity)]
1015     fn synth(&mut self, coeffs: &[f32; 1024], delay: &mut [f32; 1024], seq: u8, window_shape: bool, prev_window_shape: bool, dst: &mut [f32]) {
1016         let long_win  = if window_shape { &self.kbd_long_win  } else { &self.sine_long_win };
1017         let short_win = if window_shape { &self.kbd_short_win } else { &self.sine_short_win };
1018         let left_long_win  = if prev_window_shape { &self.kbd_long_win  } else { &self.sine_long_win };
1019         let left_short_win = if prev_window_shape { &self.kbd_short_win } else { &self.sine_short_win };
1020         if seq != EIGHT_SHORT_SEQUENCE {
1021             self.imdct_long.imdct(coeffs, &mut self.tmp);
1022         } else {
1023             for (ain, aout) in coeffs.chunks(128).zip(self.tmp.chunks_mut(256)) {
1024                 self.imdct_short.imdct(ain, aout);
1025             }
1026             self.ew_buf = [0.0; 1152];
1027             for (w, src) in self.tmp.chunks(256).enumerate() {
1028                 if w > 0 {
1029                     for i in 0..128 {
1030                         self.ew_buf[w * 128 + i] += src[i] * short_win[i];
1031                     }
1032                 } else { // to be left-windowed
1033                     for i in 0..128 {
1034                         self.ew_buf[i] = src[i];
1035                     }
1036                 }
1037                 for i in 0..128 {
1038                     self.ew_buf[w * 128 + i + 128] += src[i + 128] * short_win[127 - i];
1039                 }
1040             }
1041         }
1042         if seq == ONLY_LONG_SEQUENCE { // should be the most common case
1043             for i in 0..1024 {
1044                 dst[i] = delay[i] + self.tmp[i] * left_long_win[i];
1045                 delay[i] = self.tmp[i + 1024] * long_win[1023 - i];
1046             }
1047             return;
1048         }
1049         // output new data
1050         match seq {
1051             ONLY_LONG_SEQUENCE | LONG_START_SEQUENCE => {
1052                     for i in 0..1024 {
1053                         dst[i] = self.tmp[i] * left_long_win[i] + delay[i];
1054                     }
1055                 },
1056             EIGHT_SHORT_SEQUENCE => {
1057                     for i in 0..SHORT_WIN_POINT0 {
1058                         dst[i] = delay[i];
1059                     }
1060                     for i in SHORT_WIN_POINT0..SHORT_WIN_POINT1 {
1061                         let j = i - SHORT_WIN_POINT0;
1062                         dst[i] = delay[i] + self.ew_buf[j] * left_short_win[j];
1063                     }
1064                     for i in SHORT_WIN_POINT1..1024 {
1065                         let j = i - SHORT_WIN_POINT0;
1066                         dst[i] = self.ew_buf[j];
1067                     }
1068                 },
1069             LONG_STOP_SEQUENCE => {
1070                     for i in 0..SHORT_WIN_POINT0 {
1071                         dst[i] = delay[i];
1072                     }
1073                     for i in SHORT_WIN_POINT0..SHORT_WIN_POINT1 {
1074                         dst[i] = delay[i] + self.tmp[i] * left_short_win[i - SHORT_WIN_POINT0];
1075                     }
1076                     for i in SHORT_WIN_POINT1..1024 {
1077                         dst[i] = self.tmp[i];
1078                     }
1079                 },
1080             _ => unreachable!(""),
1081         };
1082         // save delay
1083         match seq {
1084             ONLY_LONG_SEQUENCE | LONG_STOP_SEQUENCE => {
1085                     for i in 0..1024 {
1086                         delay[i] = self.tmp[i + 1024] * long_win[1023 - i];
1087                     }
1088                 },
1089             EIGHT_SHORT_SEQUENCE => {
1090                     for i in 0..SHORT_WIN_POINT1 { // last part is already windowed
1091                         delay[i] = self.ew_buf[i + 512+64];
1092                     }
1093                     for i in SHORT_WIN_POINT1..1024 {
1094                         delay[i] = 0.0;
1095                     }
1096                 },
1097             LONG_START_SEQUENCE   => {
1098                     for i in 0..SHORT_WIN_POINT0 {
1099                         delay[i] = self.tmp[i + 1024];
1100                     }
1101                     for i in SHORT_WIN_POINT0..SHORT_WIN_POINT1 {
1102                         delay[i] = self.tmp[i + 1024] * short_win[127 - (i - SHORT_WIN_POINT0)];
1103                     }
1104                     for i in SHORT_WIN_POINT1..1024 {
1105                         delay[i] = 0.0;
1106                     }
1107                 },
1108             _ => unreachable!(""),
1109         };
1110     }
1111 }
1112
1113 struct AACDecoder {
1114     info:       NACodecInfoRef,
1115     chmap:      NAChannelMap,
1116     m4ainfo:    M4AInfo,
1117     pairs:      Vec<ChannelPair>,
1118     codebooks:  Codebooks,
1119     dsp:        DSP,
1120     sbinfo:     GASubbandInfo,
1121 }
1122
1123 impl AACDecoder {
1124     fn new() -> Self {
1125         AACDecoder {
1126             info:       NACodecInfo::new_dummy(),
1127             chmap:      NAChannelMap::new(),
1128             m4ainfo:    M4AInfo::new(),
1129             pairs:      Vec::new(),
1130             codebooks:  Codebooks::new(),
1131             dsp:        DSP::new(),
1132             sbinfo:     AAC_SUBBAND_INFO[0],
1133         }
1134     }
1135     fn set_pair(&mut self, pair_no: usize, channel: usize, pair: bool) -> DecoderResult<()> {
1136         if self.pairs.len() <= pair_no {
1137             self.pairs.push(ChannelPair::new(pair, channel, self.sbinfo));
1138         } else {
1139             validate!(self.pairs[pair_no].channel == channel);
1140             validate!(self.pairs[pair_no].pair    == pair);
1141         }
1142         validate!(if pair { channel + 1 } else { channel } < self.m4ainfo.channels);
1143         Ok(())
1144     }
1145     fn decode_ga(&mut self, br: &mut BitReader, abuf: &mut NABufferType) -> DecoderResult<()> {
1146         let mut cur_pair = 0;
1147         let mut cur_ch   = 0;
1148         while br.left() > 3 {
1149             let id                                      = br.read(3)?;
1150             match id {
1151                 0 => { // ID_SCE
1152                         let _tag                        = br.read(4)?;
1153                         self.set_pair(cur_pair, cur_ch, false)?;
1154                         self.pairs[cur_pair].decode_ga_sce(br, &self.codebooks, self.m4ainfo.otype)?;
1155                         cur_pair += 1;
1156                         cur_ch   += 1;
1157                     },
1158                 1 => { // ID_CPE
1159                         let _tag                        = br.read(4)?;
1160                         self.set_pair(cur_pair, cur_ch, true)?;
1161                         self.pairs[cur_pair].decode_ga_cpe(br, &self.codebooks, self.m4ainfo.otype)?;
1162                         cur_pair += 1;
1163                         cur_ch   += 2;
1164                     },
1165                 2 => { // ID_CCE
1166                         unimplemented!("coupling channel element");
1167                     },
1168                 3 => { // ID_LFE
1169                         let _tag                        = br.read(4)?;
1170                         self.set_pair(cur_pair, cur_ch, false)?;
1171                         self.pairs[cur_pair].decode_ga_sce(br, &self.codebooks, self.m4ainfo.otype)?;
1172                         cur_pair += 1;
1173                         cur_ch   += 1;
1174                     },
1175                 4 => { // ID_DSE
1176                         let _id                         = br.read(4)?;
1177                         let align                       = br.read_bool()?;
1178                         let mut count                   = br.read(8)? as u32;
1179                         if count == 255 { count        += br.read(8)? as u32; }
1180                         if align {                        br.align(); }
1181                                                           br.skip(count * 8)?; // no SBR payload or such
1182                     },
1183                 5 => { // ID_PCE
1184                         unimplemented!("program config");
1185                     },
1186                 6 => { // ID_FIL
1187                         let mut count                   = br.read(4)? as usize;
1188                         if count == 15 {
1189                             count                      += br.read(8)? as usize;
1190                             count -= 1;
1191                         }
1192                         for _ in 0..count {
1193                             // ext payload
1194                                                           br.skip(8)?;
1195                         }
1196                     },
1197                 7 => { // ID_TERM
1198                         break;
1199                     },
1200                 _ => { unreachable!(); },
1201             };
1202         }
1203         let srate_idx = GASubbandInfo::find_idx(self.m4ainfo.srate);
1204         for pair in 0..cur_pair {
1205             self.pairs[pair].synth_audio(&mut self.dsp, abuf, srate_idx);
1206         }
1207         Ok(())
1208     }
1209 }
1210
1211 impl NADecoder for AACDecoder {
1212     fn init(&mut self, _supp: &mut NADecoderSupport, info: NACodecInfoRef) -> DecoderResult<()> {
1213         if let NACodecTypeInfo::Audio(_) = info.get_properties() {
1214             let edata = info.get_extradata().unwrap();
1215             validate!(edata.len() >= 2);
1216
1217 //print!("edata:"); for s in edata.iter() { print!(" {:02X}", *s);}println!("");
1218             if (edata.len() > 12) && (&edata[4..8] == b"esds") {
1219                 let mut mr = MemoryReader::new_read(edata.as_slice());
1220                 let mut br = ByteReader::new(&mut mr);
1221                 let esds_size           = br.read_u32be()? as usize;
1222                 validate!(esds_size <= edata.len());
1223                                           br.read_skip(8)?;
1224                 let mut info_start = 0;
1225                 let mut info_size = 0;
1226                 while br.tell() < (esds_size as u64) {
1227                     let tag             = br.read_byte()?;
1228                     let mut size = 0;
1229                     loop {
1230                         let b           = br.read_byte()?;
1231                         size = (size << 7) | u64::from(b & 0x7F);
1232                         validate!(br.tell() + size <= (esds_size as u64));
1233                         if (b & 0x80) == 0 {
1234                             break;
1235                         }
1236                     }
1237                     match tag {
1238                         3 => {
1239                                           br.read_u16be()?;
1240                             let flags   = br.read_byte()?;
1241                             if (flags & 0x80) != 0 {
1242                                           br.read_u16be()?;
1243                             }
1244                             if (flags & 0x40) != 0 {
1245                                 let len = br.read_byte()?;
1246                                           br.read_skip(len as usize)?;
1247                             }
1248                             if (flags & 0x20) != 0 {
1249                                           br.read_u16be()?;
1250                             }
1251                         },
1252                         4 => {
1253                             let _otype  = br.read_byte()?;
1254                             let _stype  = br.read_byte()?;
1255                             let _flags  = br.read_u24be()?;
1256                             let _max_br = br.read_u32be()?;
1257                             let _min_br = br.read_u32be()?;
1258                         },
1259                         5 => {
1260                             info_start = br.tell() as usize;
1261                             info_size = size as usize;
1262                             break;
1263                         },
1264                         _ => br.read_skip(size as usize)?,
1265                     }
1266                 }
1267                 validate!(info_start > 0 && info_size > 0);
1268                 self.m4ainfo.read(&edata[info_start..][..info_size])?;
1269             } else {
1270                 self.m4ainfo.read(&edata)?;
1271             }
1272
1273             //println!("{}", self.m4ainfo);
1274             if (self.m4ainfo.otype != M4AType::LC) || (self.m4ainfo.channels > 2) || (self.m4ainfo.samples != 1024) {
1275                 return Err(DecoderError::NotImplemented);
1276             }
1277             self.sbinfo = GASubbandInfo::find(self.m4ainfo.srate);
1278
1279             let ainfo = NAAudioInfo::new(self.m4ainfo.srate, self.m4ainfo.channels as u8,
1280                                          SND_F32P_FORMAT, self.m4ainfo.samples);
1281             self.info = info.replace_info(NACodecTypeInfo::Audio(ainfo));
1282
1283             if self.m4ainfo.channels >= DEFAULT_CHANNEL_MAP.len() {
1284                 return Err(DecoderError::NotImplemented);
1285             }
1286             let chmap_str = DEFAULT_CHANNEL_MAP[self.m4ainfo.channels];
1287             if chmap_str.is_empty() { return Err(DecoderError::NotImplemented); }
1288             self.chmap = NAChannelMap::from_str(chmap_str).unwrap();
1289
1290             Ok(())
1291         } else {
1292             Err(DecoderError::InvalidData)
1293         }
1294     }
1295     fn decode(&mut self, _supp: &mut NADecoderSupport, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
1296         let info = pkt.get_stream().get_info();
1297         validate!(info.get_properties().is_audio());
1298         let pktbuf = pkt.get_buffer();
1299
1300         let ainfo = self.info.get_properties().get_audio_info().unwrap();
1301         let mut abuf = alloc_audio_buffer(ainfo, self.m4ainfo.samples, self.chmap.clone())?;
1302
1303         let mut br = BitReader::new(&pktbuf, BitReaderMode::BE);
1304         match self.m4ainfo.otype {
1305             M4AType::LC => {
1306                     self.decode_ga(&mut br, &mut abuf)?;
1307                 },
1308             _ => { unimplemented!(""); }
1309         }
1310
1311         let mut frm = NAFrame::new_from_pkt(pkt, self.info.replace_info(NACodecTypeInfo::Audio(ainfo)), abuf);
1312         frm.set_keyframe(true);
1313         Ok(frm.into_ref())
1314     }
1315     fn flush(&mut self) {
1316         for pair in self.pairs.iter_mut() {
1317             pair.ics[0].delay = [0.0; 1024];
1318             pair.ics[1].delay = [0.0; 1024];
1319         }
1320     }
1321 }
1322
1323 impl NAOptionHandler for AACDecoder {
1324     fn get_supported_options(&self) -> &[NAOptionDefinition] { &[] }
1325     fn set_options(&mut self, _options: &[NAOption]) { }
1326     fn query_option_value(&self, _name: &str) -> Option<NAValue> { None }
1327 }
1328
1329 pub fn get_decoder() -> Box<dyn NADecoder + Send> {
1330     Box::new(AACDecoder::new())
1331 }
1332
1333 #[cfg(test)]
1334 mod test {
1335     use nihav_core::codecs::RegisteredDecoders;
1336     use nihav_core::demuxers::RegisteredDemuxers;
1337     use nihav_codec_support::test::dec_video::test_decode_audio;
1338     use crate::generic_register_all_decoders;
1339     use nihav_realmedia::realmedia_register_all_demuxers;
1340     #[test]
1341     fn test_aac() {
1342         let mut dmx_reg = RegisteredDemuxers::new();
1343         realmedia_register_all_demuxers(&mut dmx_reg);
1344         let mut dec_reg = RegisteredDecoders::new();
1345         generic_register_all_decoders(&mut dec_reg);
1346
1347 //        let file = "assets/RV/rv40_weighted_mc.rmvb";
1348         let file = "assets/RV/rv40_weighted_mc_2.rmvb";
1349         test_decode_audio("realmedia", file, Some(12000), None/*Some("aac")*/, &dmx_reg, &dec_reg);
1350     }
1351 }
1352
1353 const AAC_SCF_CODEBOOK_BITS: &[u8] = &[
1354     18, 18, 18, 18, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
1355     19, 19, 19, 18, 19, 18, 17, 17, 16, 17, 16, 16, 16, 16, 15, 15,
1356     14, 14, 14, 14, 14, 14, 13, 13, 12, 12, 12, 11, 12, 11, 10, 10,
1357     10,  9,  9,  8,  8,  8,  7,  6,  6,  5,  4,  3,  1,  4,  4,  5,
1358      6,  6,  7,  7,  8,  8,  9,  9, 10, 10, 10, 11, 11, 11, 11, 12,
1359     12, 13, 13, 13, 14, 14, 16, 15, 16, 15, 18, 19, 19, 19, 19, 19,
1360     19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
1361     19, 19, 19, 19, 19, 19, 19, 19, 19
1362 ];
1363
1364 const AAC_SCF_CODEBOOK_CODES: &[u32] = &[
1365     0x3FFE8, 0x3FFE6, 0x3FFE7, 0x3FFE5, 0x7FFF5, 0x7FFF1, 0x7FFED, 0x7FFF6,
1366     0x7FFEE, 0x7FFEF, 0x7FFF0, 0x7FFFC, 0x7FFFD, 0x7FFFF, 0x7FFFE, 0x7FFF7,
1367     0x7FFF8, 0x7FFFB, 0x7FFF9, 0x3FFE4, 0x7FFFA, 0x3FFE3, 0x1FFEF, 0x1FFF0,
1368     0x0FFF5, 0x1FFEE, 0x0FFF2, 0x0FFF3, 0x0FFF4, 0x0FFF1, 0x07FF6, 0x07FF7,
1369     0x03FF9, 0x03FF5, 0x03FF7, 0x03FF3, 0x03FF6, 0x03FF2, 0x01FF7, 0x01FF5,
1370     0x00FF9, 0x00FF7, 0x00FF6, 0x007F9, 0x00FF4, 0x007F8, 0x003F9, 0x003F7,
1371     0x003F5, 0x001F8, 0x001F7, 0x000FA, 0x000F8, 0x000F6, 0x00079, 0x0003A,
1372     0x00038, 0x0001A, 0x0000B, 0x00004, 0x00000, 0x0000A, 0x0000C, 0x0001B,
1373     0x00039, 0x0003B, 0x00078, 0x0007A, 0x000F7, 0x000F9, 0x001F6, 0x001F9,
1374     0x003F4, 0x003F6, 0x003F8, 0x007F5, 0x007F4, 0x007F6, 0x007F7, 0x00FF5,
1375     0x00FF8, 0x01FF4, 0x01FF6, 0x01FF8, 0x03FF8, 0x03FF4, 0x0FFF0, 0x07FF4,
1376     0x0FFF6, 0x07FF5, 0x3FFE2, 0x7FFD9, 0x7FFDA, 0x7FFDB, 0x7FFDC, 0x7FFDD,
1377     0x7FFDE, 0x7FFD8, 0x7FFD2, 0x7FFD3, 0x7FFD4, 0x7FFD5, 0x7FFD6, 0x7FFF2,
1378     0x7FFDF, 0x7FFE7, 0x7FFE8, 0x7FFE9, 0x7FFEA, 0x7FFEB, 0x7FFE6, 0x7FFE0,
1379     0x7FFE1, 0x7FFE2, 0x7FFE3, 0x7FFE4, 0x7FFE5, 0x7FFD7, 0x7FFEC, 0x7FFF4,
1380     0x7FFF3
1381 ];
1382
1383 const AAC_SPEC_CB1_BITS: &[u8] = &[
1384     11,  9, 11, 10,  7, 10, 11,  9, 11, 10,  7, 10,  7,  5,  7,  9,
1385      7, 10, 11,  9, 11,  9,  7,  9, 11,  9, 11,  9,  7,  9,  7,  5,
1386      7,  9,  7,  9,  7,  5,  7,  5,  1,  5,  7,  5,  7,  9,  7,  9,
1387      7,  5,  7,  9,  7,  9, 11,  9, 11,  9,  7,  9, 11,  9, 11, 10,
1388      7,  9,  7,  5,  7,  9,  7, 10, 11,  9, 11, 10,  7,  9, 11,  9,
1389     11
1390 ];
1391 const AAC_SPEC_CB1_CODES: &[u16] = &[
1392     0x7f8, 0x1f1, 0x7fd, 0x3f5, 0x068, 0x3f0, 0x7f7, 0x1ec,
1393     0x7f5, 0x3f1, 0x072, 0x3f4, 0x074, 0x011, 0x076, 0x1eb,
1394     0x06c, 0x3f6, 0x7fc, 0x1e1, 0x7f1, 0x1f0, 0x061, 0x1f6,
1395     0x7f2, 0x1ea, 0x7fb, 0x1f2, 0x069, 0x1ed, 0x077, 0x017,
1396     0x06f, 0x1e6, 0x064, 0x1e5, 0x067, 0x015, 0x062, 0x012,
1397     0x000, 0x014, 0x065, 0x016, 0x06d, 0x1e9, 0x063, 0x1e4,
1398     0x06b, 0x013, 0x071, 0x1e3, 0x070, 0x1f3, 0x7fe, 0x1e7,
1399     0x7f3, 0x1ef, 0x060, 0x1ee, 0x7f0, 0x1e2, 0x7fa, 0x3f3,
1400     0x06a, 0x1e8, 0x075, 0x010, 0x073, 0x1f4, 0x06e, 0x3f7,
1401     0x7f6, 0x1e0, 0x7f9, 0x3f2, 0x066, 0x1f5, 0x7ff, 0x1f7,
1402     0x7f4
1403 ];
1404 const AAC_SPEC_CB2_BITS: &[u8] = &[
1405     9, 7, 9, 8, 6, 8, 9, 8, 9, 8, 6, 7, 6, 5, 6, 7,
1406     6, 8, 9, 7, 8, 8, 6, 8, 9, 7, 9, 8, 6, 7, 6, 5,
1407     6, 7, 6, 8, 6, 5, 6, 5, 3, 5, 6, 5, 6, 8, 6, 7,
1408     6, 5, 6, 8, 6, 8, 9, 7, 9, 8, 6, 8, 8, 7, 9, 8,
1409     6, 7, 6, 4, 6, 8, 6, 7, 9, 7, 9, 7, 6, 8, 9, 7,
1410     9
1411 ];
1412 const AAC_SPEC_CB2_CODES: &[u16] = &[
1413     0x1f3, 0x06f, 0x1fd, 0x0eb, 0x023, 0x0ea, 0x1f7, 0x0e8,
1414     0x1fa, 0x0f2, 0x02d, 0x070, 0x020, 0x006, 0x02b, 0x06e,
1415     0x028, 0x0e9, 0x1f9, 0x066, 0x0f8, 0x0e7, 0x01b, 0x0f1,
1416     0x1f4, 0x06b, 0x1f5, 0x0ec, 0x02a, 0x06c, 0x02c, 0x00a,
1417     0x027, 0x067, 0x01a, 0x0f5, 0x024, 0x008, 0x01f, 0x009,
1418     0x000, 0x007, 0x01d, 0x00b, 0x030, 0x0ef, 0x01c, 0x064,
1419     0x01e, 0x00c, 0x029, 0x0f3, 0x02f, 0x0f0, 0x1fc, 0x071,
1420     0x1f2, 0x0f4, 0x021, 0x0e6, 0x0f7, 0x068, 0x1f8, 0x0ee,
1421     0x022, 0x065, 0x031, 0x002, 0x026, 0x0ed, 0x025, 0x06a,
1422     0x1fb, 0x072, 0x1fe, 0x069, 0x02e, 0x0f6, 0x1ff, 0x06d,
1423     0x1f6
1424 ];
1425 const AAC_SPEC_CB3_BITS: &[u8] = &[
1426      1,  4,  8,  4,  5,  8,  9,  9, 10,  4,  6,  9,  6,  6,  9,  9,
1427      9, 10,  9, 10, 13,  9,  9, 11, 11, 10, 12,  4,  6, 10,  6,  7,
1428     10, 10, 10, 12,  5,  7, 11,  6,  7, 10,  9,  9, 11,  9, 10, 13,
1429      8,  9, 12, 10, 11, 12,  8, 10, 15,  9, 11, 15, 13, 14, 16,  8,
1430     10, 14,  9, 10, 14, 12, 12, 15, 11, 12, 16, 10, 11, 15, 12, 12,
1431     15
1432 ];
1433 const AAC_SPEC_CB3_CODES: &[u16] = &[
1434     0x0000, 0x0009, 0x00ef, 0x000b, 0x0019, 0x00f0, 0x01eb, 0x01e6,
1435     0x03f2, 0x000a, 0x0035, 0x01ef, 0x0034, 0x0037, 0x01e9, 0x01ed,
1436     0x01e7, 0x03f3, 0x01ee, 0x03ed, 0x1ffa, 0x01ec, 0x01f2, 0x07f9,
1437     0x07f8, 0x03f8, 0x0ff8, 0x0008, 0x0038, 0x03f6, 0x0036, 0x0075,
1438     0x03f1, 0x03eb, 0x03ec, 0x0ff4, 0x0018, 0x0076, 0x07f4, 0x0039,
1439     0x0074, 0x03ef, 0x01f3, 0x01f4, 0x07f6, 0x01e8, 0x03ea, 0x1ffc,
1440     0x00f2, 0x01f1, 0x0ffb, 0x03f5, 0x07f3, 0x0ffc, 0x00ee, 0x03f7,
1441     0x7ffe, 0x01f0, 0x07f5, 0x7ffd, 0x1ffb, 0x3ffa, 0xffff, 0x00f1,
1442     0x03f0, 0x3ffc, 0x01ea, 0x03ee, 0x3ffb, 0x0ff6, 0x0ffa, 0x7ffc,
1443     0x07f2, 0x0ff5, 0xfffe, 0x03f4, 0x07f7, 0x7ffb, 0x0ff7, 0x0ff9,
1444     0x7ffa
1445 ];
1446 const AAC_SPEC_CB4_BITS: &[u8] = &[
1447      4,  5,  8,  5,  4,  8,  9,  8, 11,  5,  5,  8,  5,  4,  8,  8,
1448      7, 10,  9,  8, 11,  8,  8, 10, 11, 10, 11,  4,  5,  8,  4,  4,
1449      8,  8,  8, 10,  4,  4,  8,  4,  4,  7,  8,  7,  9,  8,  8, 10,
1450      7,  7,  9, 10,  9, 10,  8,  8, 11,  8,  7, 10, 11, 10, 12,  8,
1451      7, 10,  7,  7,  9, 10,  9, 11, 11, 10, 12, 10,  9, 11, 11, 10,
1452     11
1453 ];
1454 const AAC_SPEC_CB4_CODES: &[u16] = &[
1455     0x007, 0x016, 0x0f6, 0x018, 0x008, 0x0ef, 0x1ef, 0x0f3,
1456     0x7f8, 0x019, 0x017, 0x0ed, 0x015, 0x001, 0x0e2, 0x0f0,
1457     0x070, 0x3f0, 0x1ee, 0x0f1, 0x7fa, 0x0ee, 0x0e4, 0x3f2,
1458     0x7f6, 0x3ef, 0x7fd, 0x005, 0x014, 0x0f2, 0x009, 0x004,
1459     0x0e5, 0x0f4, 0x0e8, 0x3f4, 0x006, 0x002, 0x0e7, 0x003,
1460     0x000, 0x06b, 0x0e3, 0x069, 0x1f3, 0x0eb, 0x0e6, 0x3f6,
1461     0x06e, 0x06a, 0x1f4, 0x3ec, 0x1f0, 0x3f9, 0x0f5, 0x0ec,
1462     0x7fb, 0x0ea, 0x06f, 0x3f7, 0x7f9, 0x3f3, 0xfff, 0x0e9,
1463     0x06d, 0x3f8, 0x06c, 0x068, 0x1f5, 0x3ee, 0x1f2, 0x7f4,
1464     0x7f7, 0x3f1, 0xffe, 0x3ed, 0x1f1, 0x7f5, 0x7fe, 0x3f5,
1465     0x7fc
1466 ];
1467 const AAC_SPEC_CB5_BITS: &[u8] = &[
1468     13, 12, 11, 11, 10, 11, 11, 12, 13, 12, 11, 10,  9,  8,  9, 10,
1469     11, 12, 12, 10,  9,  8,  7,  8,  9, 10, 11, 11,  9,  8,  5,  4,
1470      5,  8,  9, 11, 10,  8,  7,  4,  1,  4,  7,  8, 11, 11,  9,  8,
1471      5,  4,  5,  8,  9, 11, 11, 10,  9,  8,  7,  8,  9, 10, 11, 12,
1472     11, 10,  9,  8,  9, 10, 11, 12, 13, 12, 12, 11, 10, 10, 11, 12,
1473     13
1474 ];
1475 const AAC_SPEC_CB5_CODES: &[u16] = &[
1476     0x1fff, 0x0ff7, 0x07f4, 0x07e8, 0x03f1, 0x07ee, 0x07f9, 0x0ff8,
1477     0x1ffd, 0x0ffd, 0x07f1, 0x03e8, 0x01e8, 0x00f0, 0x01ec, 0x03ee,
1478     0x07f2, 0x0ffa, 0x0ff4, 0x03ef, 0x01f2, 0x00e8, 0x0070, 0x00ec,
1479     0x01f0, 0x03ea, 0x07f3, 0x07eb, 0x01eb, 0x00ea, 0x001a, 0x0008,
1480     0x0019, 0x00ee, 0x01ef, 0x07ed, 0x03f0, 0x00f2, 0x0073, 0x000b,
1481     0x0000, 0x000a, 0x0071, 0x00f3, 0x07e9, 0x07ef, 0x01ee, 0x00ef,
1482     0x0018, 0x0009, 0x001b, 0x00eb, 0x01e9, 0x07ec, 0x07f6, 0x03eb,
1483     0x01f3, 0x00ed, 0x0072, 0x00e9, 0x01f1, 0x03ed, 0x07f7, 0x0ff6,
1484     0x07f0, 0x03e9, 0x01ed, 0x00f1, 0x01ea, 0x03ec, 0x07f8, 0x0ff9,
1485     0x1ffc, 0x0ffc, 0x0ff5, 0x07ea, 0x03f3, 0x03f2, 0x07f5, 0x0ffb,
1486     0x1ffe
1487 ];
1488 const AAC_SPEC_CB6_BITS: &[u8] = &[
1489     11, 10,  9,  9,  9,  9,  9, 10, 11, 10,  9,  8,  7,  7,  7,  8,
1490      9, 10,  9,  8,  6,  6,  6,  6,  6,  8,  9,  9,  7,  6,  4,  4,
1491      4,  6,  7,  9,  9,  7,  6,  4,  4,  4,  6,  7,  9,  9,  7,  6,
1492      4,  4,  4,  6,  7,  9,  9,  8,  6,  6,  6,  6,  6,  8,  9, 10,
1493      9,  8,  7,  7,  7,  7,  8, 10, 11, 10,  9,  9,  9,  9,  9, 10,
1494     11
1495 ];
1496 const AAC_SPEC_CB6_CODES: &[u16] = &[
1497     0x7fe, 0x3fd, 0x1f1, 0x1eb, 0x1f4, 0x1ea, 0x1f0, 0x3fc,
1498     0x7fd, 0x3f6, 0x1e5, 0x0ea, 0x06c, 0x071, 0x068, 0x0f0,
1499     0x1e6, 0x3f7, 0x1f3, 0x0ef, 0x032, 0x027, 0x028, 0x026,
1500     0x031, 0x0eb, 0x1f7, 0x1e8, 0x06f, 0x02e, 0x008, 0x004,
1501     0x006, 0x029, 0x06b, 0x1ee, 0x1ef, 0x072, 0x02d, 0x002,
1502     0x000, 0x003, 0x02f, 0x073, 0x1fa, 0x1e7, 0x06e, 0x02b,
1503     0x007, 0x001, 0x005, 0x02c, 0x06d, 0x1ec, 0x1f9, 0x0ee,
1504     0x030, 0x024, 0x02a, 0x025, 0x033, 0x0ec, 0x1f2, 0x3f8,
1505     0x1e4, 0x0ed, 0x06a, 0x070, 0x069, 0x074, 0x0f1, 0x3fa,
1506     0x7ff, 0x3f9, 0x1f6, 0x1ed, 0x1f8, 0x1e9, 0x1f5, 0x3fb,
1507     0x7fc
1508 ];
1509 const AAC_SPEC_CB7_BITS: &[u8] = &[
1510      1,  3,  6,  7,  8,  9, 10, 11,  3,  4,  6,  7,  8,  8,  9,  9,
1511      6,  6,  7,  8,  8,  9,  9, 10,  7,  7,  8,  8,  9,  9, 10, 10,
1512      8,  8,  9,  9, 10, 10, 10, 11,  9,  8,  9,  9, 10, 10, 11, 11,
1513     10,  9,  9, 10, 10, 11, 12, 12, 11, 10, 10, 10, 11, 11, 12, 12
1514 ];
1515 const AAC_SPEC_CB7_CODES: &[u16] = &[
1516     0x000, 0x005, 0x037, 0x074, 0x0f2, 0x1eb, 0x3ed, 0x7f7,
1517     0x004, 0x00c, 0x035, 0x071, 0x0ec, 0x0ee, 0x1ee, 0x1f5,
1518     0x036, 0x034, 0x072, 0x0ea, 0x0f1, 0x1e9, 0x1f3, 0x3f5,
1519     0x073, 0x070, 0x0eb, 0x0f0, 0x1f1, 0x1f0, 0x3ec, 0x3fa,
1520     0x0f3, 0x0ed, 0x1e8, 0x1ef, 0x3ef, 0x3f1, 0x3f9, 0x7fb,
1521     0x1ed, 0x0ef, 0x1ea, 0x1f2, 0x3f3, 0x3f8, 0x7f9, 0x7fc,
1522     0x3ee, 0x1ec, 0x1f4, 0x3f4, 0x3f7, 0x7f8, 0xffd, 0xffe,
1523     0x7f6, 0x3f0, 0x3f2, 0x3f6, 0x7fa, 0x7fd, 0xffc, 0xfff
1524 ];
1525 const AAC_SPEC_CB8_BITS: &[u8] = &[
1526      5,  4,  5,  6,  7,  8,  9, 10,  4,  3,  4,  5,  6,  7,  7,  8,
1527      5,  4,  4,  5,  6,  7,  7,  8,  6,  5,  5,  6,  6,  7,  8,  8,
1528      7,  6,  6,  6,  7,  7,  8,  9,  8,  7,  6,  7,  7,  8,  8, 10,
1529      9,  7,  7,  8,  8,  8,  9,  9, 10,  8,  8,  8,  9,  9,  9, 10
1530 ];
1531 const AAC_SPEC_CB8_CODES: &[u16] = &[
1532     0x00e, 0x005, 0x010, 0x030, 0x06f, 0x0f1, 0x1fa, 0x3fe,
1533     0x003, 0x000, 0x004, 0x012, 0x02c, 0x06a, 0x075, 0x0f8,
1534     0x00f, 0x002, 0x006, 0x014, 0x02e, 0x069, 0x072, 0x0f5,
1535     0x02f, 0x011, 0x013, 0x02a, 0x032, 0x06c, 0x0ec, 0x0fa,
1536     0x071, 0x02b, 0x02d, 0x031, 0x06d, 0x070, 0x0f2, 0x1f9,
1537     0x0ef, 0x068, 0x033, 0x06b, 0x06e, 0x0ee, 0x0f9, 0x3fc,
1538     0x1f8, 0x074, 0x073, 0x0ed, 0x0f0, 0x0f6, 0x1f6, 0x1fd,
1539     0x3fd, 0x0f3, 0x0f4, 0x0f7, 0x1f7, 0x1fb, 0x1fc, 0x3ff
1540 ];
1541 const AAC_SPEC_CB9_BITS: &[u8] = &[
1542      1,  3,  6,  8,  9, 10, 10, 11, 11, 12, 12, 13, 13,  3,  4,  6,
1543      7,  8,  8,  9, 10, 10, 10, 11, 12, 12,  6,  6,  7,  8,  8,  9,
1544     10, 10, 10, 11, 12, 12, 12,  8,  7,  8,  9,  9, 10, 10, 11, 11,
1545     11, 12, 12, 13,  9,  8,  9,  9, 10, 10, 11, 11, 11, 12, 12, 12,
1546     13, 10,  9,  9, 10, 11, 11, 11, 12, 11, 12, 12, 13, 13, 11,  9,
1547     10, 11, 11, 11, 12, 12, 12, 12, 13, 13, 13, 11, 10, 10, 11, 11,
1548     12, 12, 13, 13, 13, 13, 13, 13, 11, 10, 10, 11, 11, 11, 12, 12,
1549     13, 13, 14, 13, 14, 11, 10, 11, 11, 12, 12, 12, 12, 13, 13, 14,
1550     14, 14, 12, 11, 11, 12, 12, 12, 13, 13, 13, 14, 14, 14, 15, 12,
1551     11, 12, 12, 12, 13, 13, 13, 13, 14, 14, 15, 15, 13, 12, 12, 12,
1552     13, 13, 13, 13, 14, 14, 14, 14, 15
1553 ];
1554 const AAC_SPEC_CB9_CODES: &[u16] = &[
1555     0x0000, 0x0005, 0x0037, 0x00e7, 0x01de, 0x03ce, 0x03d9, 0x07c8,
1556     0x07cd, 0x0fc8, 0x0fdd, 0x1fe4, 0x1fec, 0x0004, 0x000c, 0x0035,
1557     0x0072, 0x00ea, 0x00ed, 0x01e2, 0x03d1, 0x03d3, 0x03e0, 0x07d8,
1558     0x0fcf, 0x0fd5, 0x0036, 0x0034, 0x0071, 0x00e8, 0x00ec, 0x01e1,
1559     0x03cf, 0x03dd, 0x03db, 0x07d0, 0x0fc7, 0x0fd4, 0x0fe4, 0x00e6,
1560     0x0070, 0x00e9, 0x01dd, 0x01e3, 0x03d2, 0x03dc, 0x07cc, 0x07ca,
1561     0x07de, 0x0fd8, 0x0fea, 0x1fdb, 0x01df, 0x00eb, 0x01dc, 0x01e6,
1562     0x03d5, 0x03de, 0x07cb, 0x07dd, 0x07dc, 0x0fcd, 0x0fe2, 0x0fe7,
1563     0x1fe1, 0x03d0, 0x01e0, 0x01e4, 0x03d6, 0x07c5, 0x07d1, 0x07db,
1564     0x0fd2, 0x07e0, 0x0fd9, 0x0feb, 0x1fe3, 0x1fe9, 0x07c4, 0x01e5,
1565     0x03d7, 0x07c6, 0x07cf, 0x07da, 0x0fcb, 0x0fda, 0x0fe3, 0x0fe9,
1566     0x1fe6, 0x1ff3, 0x1ff7, 0x07d3, 0x03d8, 0x03e1, 0x07d4, 0x07d9,
1567     0x0fd3, 0x0fde, 0x1fdd, 0x1fd9, 0x1fe2, 0x1fea, 0x1ff1, 0x1ff6,
1568     0x07d2, 0x03d4, 0x03da, 0x07c7, 0x07d7, 0x07e2, 0x0fce, 0x0fdb,
1569     0x1fd8, 0x1fee, 0x3ff0, 0x1ff4, 0x3ff2, 0x07e1, 0x03df, 0x07c9,
1570     0x07d6, 0x0fca, 0x0fd0, 0x0fe5, 0x0fe6, 0x1feb, 0x1fef, 0x3ff3,
1571     0x3ff4, 0x3ff5, 0x0fe0, 0x07ce, 0x07d5, 0x0fc6, 0x0fd1, 0x0fe1,
1572     0x1fe0, 0x1fe8, 0x1ff0, 0x3ff1, 0x3ff8, 0x3ff6, 0x7ffc, 0x0fe8,
1573     0x07df, 0x0fc9, 0x0fd7, 0x0fdc, 0x1fdc, 0x1fdf, 0x1fed, 0x1ff5,
1574     0x3ff9, 0x3ffb, 0x7ffd, 0x7ffe, 0x1fe7, 0x0fcc, 0x0fd6, 0x0fdf,
1575     0x1fde, 0x1fda, 0x1fe5, 0x1ff2, 0x3ffa, 0x3ff7, 0x3ffc, 0x3ffd,
1576     0x7fff
1577 ];
1578 const AAC_SPEC_CB10_BITS: &[u8] = &[
1579      6,  5,  6,  6,  7,  8,  9, 10, 10, 10, 11, 11, 12,  5,  4,  4,
1580      5,  6,  7,  7,  8,  8,  9, 10, 10, 11,  6,  4,  5,  5,  6,  6,
1581      7,  8,  8,  9,  9, 10, 10,  6,  5,  5,  5,  6,  7,  7,  8,  8,
1582      9,  9, 10, 10,  7,  6,  6,  6,  6,  7,  7,  8,  8,  9,  9, 10,
1583     10,  8,  7,  6,  7,  7,  7,  8,  8,  8,  9, 10, 10, 11,  9,  7,
1584      7,  7,  7,  8,  8,  9,  9,  9, 10, 10, 11,  9,  8,  8,  8,  8,
1585      8,  9,  9,  9, 10, 10, 11, 11,  9,  8,  8,  8,  8,  8,  9,  9,
1586     10, 10, 10, 11, 11, 10,  9,  9,  9,  9,  9,  9, 10, 10, 10, 11,
1587     11, 12, 10,  9,  9,  9,  9, 10, 10, 10, 10, 11, 11, 11, 12, 11,
1588     10,  9, 10, 10, 10, 10, 10, 11, 11, 11, 11, 12, 11, 10, 10, 10,
1589     10, 10, 10, 11, 11, 12, 12, 12, 12
1590 ];
1591 const AAC_SPEC_CB10_CODES: &[u16] = &[
1592     0x022, 0x008, 0x01d, 0x026, 0x05f, 0x0d3, 0x1cf, 0x3d0,
1593     0x3d7, 0x3ed, 0x7f0, 0x7f6, 0xffd, 0x007, 0x000, 0x001,
1594     0x009, 0x020, 0x054, 0x060, 0x0d5, 0x0dc, 0x1d4, 0x3cd,
1595     0x3de, 0x7e7, 0x01c, 0x002, 0x006, 0x00c, 0x01e, 0x028,
1596     0x05b, 0x0cd, 0x0d9, 0x1ce, 0x1dc, 0x3d9, 0x3f1, 0x025,
1597     0x00b, 0x00a, 0x00d, 0x024, 0x057, 0x061, 0x0cc, 0x0dd,
1598     0x1cc, 0x1de, 0x3d3, 0x3e7, 0x05d, 0x021, 0x01f, 0x023,
1599     0x027, 0x059, 0x064, 0x0d8, 0x0df, 0x1d2, 0x1e2, 0x3dd,
1600     0x3ee, 0x0d1, 0x055, 0x029, 0x056, 0x058, 0x062, 0x0ce,
1601     0x0e0, 0x0e2, 0x1da, 0x3d4, 0x3e3, 0x7eb, 0x1c9, 0x05e,
1602     0x05a, 0x05c, 0x063, 0x0ca, 0x0da, 0x1c7, 0x1ca, 0x1e0,
1603     0x3db, 0x3e8, 0x7ec, 0x1e3, 0x0d2, 0x0cb, 0x0d0, 0x0d7,
1604     0x0db, 0x1c6, 0x1d5, 0x1d8, 0x3ca, 0x3da, 0x7ea, 0x7f1,
1605     0x1e1, 0x0d4, 0x0cf, 0x0d6, 0x0de, 0x0e1, 0x1d0, 0x1d6,
1606     0x3d1, 0x3d5, 0x3f2, 0x7ee, 0x7fb, 0x3e9, 0x1cd, 0x1c8,
1607     0x1cb, 0x1d1, 0x1d7, 0x1df, 0x3cf, 0x3e0, 0x3ef, 0x7e6,
1608     0x7f8, 0xffa, 0x3eb, 0x1dd, 0x1d3, 0x1d9, 0x1db, 0x3d2,
1609     0x3cc, 0x3dc, 0x3ea, 0x7ed, 0x7f3, 0x7f9, 0xff9, 0x7f2,
1610     0x3ce, 0x1e4, 0x3cb, 0x3d8, 0x3d6, 0x3e2, 0x3e5, 0x7e8,
1611     0x7f4, 0x7f5, 0x7f7, 0xffb, 0x7fa, 0x3ec, 0x3df, 0x3e1,
1612     0x3e4, 0x3e6, 0x3f0, 0x7e9, 0x7ef, 0xff8, 0xffe, 0xffc,
1613     0xfff
1614 ];
1615 const AAC_SPEC_CB11_BITS: &[u8] = &[
1616      4,  5,  6,  7,  8,  8,  9, 10, 10, 10, 11, 11, 12, 11, 12, 12,
1617     10,  5,  4,  5,  6,  7,  7,  8,  8,  9,  9,  9, 10, 10, 10, 10,
1618     11,  8,  6,  5,  5,  6,  7,  7,  8,  8,  8,  9,  9,  9, 10, 10,
1619     10, 10,  8,  7,  6,  6,  6,  7,  7,  8,  8,  8,  9,  9,  9, 10,
1620     10, 10, 10,  8,  8,  7,  7,  7,  7,  8,  8,  8,  8,  9,  9,  9,
1621     10, 10, 10, 10,  8,  8,  7,  7,  7,  7,  8,  8,  8,  9,  9,  9,
1622      9, 10, 10, 10, 10,  8,  9,  8,  8,  8,  8,  8,  8,  8,  9,  9,
1623      9, 10, 10, 10, 10, 10,  8,  9,  8,  8,  8,  8,  8,  8,  9,  9,
1624      9, 10, 10, 10, 10, 10, 10,  8, 10,  9,  8,  8,  9,  9,  9,  9,
1625      9, 10, 10, 10, 10, 10, 10, 11,  8, 10,  9,  9,  9,  9,  9,  9,
1626      9, 10, 10, 10, 10, 10, 10, 11, 11,  8, 11,  9,  9,  9,  9,  9,
1627      9, 10, 10, 10, 10, 10, 11, 10, 11, 11,  8, 11, 10,  9,  9, 10,
1628      9, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11,  8, 11, 10, 10, 10,
1629     10, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11,  9, 11, 10,  9,
1630      9, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11,  9, 11, 10,
1631     10, 10, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11,  9, 12,
1632     10, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11, 12, 12,  9,
1633      9,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  9,
1634      5
1635 ];
1636 const AAC_SPEC_CB11_CODES: &[u16] = &[
1637     0x000, 0x006, 0x019, 0x03d, 0x09c, 0x0c6, 0x1a7, 0x390,
1638     0x3c2, 0x3df, 0x7e6, 0x7f3, 0xffb, 0x7ec, 0xffa, 0xffe,
1639     0x38e, 0x005, 0x001, 0x008, 0x014, 0x037, 0x042, 0x092,
1640     0x0af, 0x191, 0x1a5, 0x1b5, 0x39e, 0x3c0, 0x3a2, 0x3cd,
1641     0x7d6, 0x0ae, 0x017, 0x007, 0x009, 0x018, 0x039, 0x040,
1642     0x08e, 0x0a3, 0x0b8, 0x199, 0x1ac, 0x1c1, 0x3b1, 0x396,
1643     0x3be, 0x3ca, 0x09d, 0x03c, 0x015, 0x016, 0x01a, 0x03b,
1644     0x044, 0x091, 0x0a5, 0x0be, 0x196, 0x1ae, 0x1b9, 0x3a1,
1645     0x391, 0x3a5, 0x3d5, 0x094, 0x09a, 0x036, 0x038, 0x03a,
1646     0x041, 0x08c, 0x09b, 0x0b0, 0x0c3, 0x19e, 0x1ab, 0x1bc,
1647     0x39f, 0x38f, 0x3a9, 0x3cf, 0x093, 0x0bf, 0x03e, 0x03f,
1648     0x043, 0x045, 0x09e, 0x0a7, 0x0b9, 0x194, 0x1a2, 0x1ba,
1649     0x1c3, 0x3a6, 0x3a7, 0x3bb, 0x3d4, 0x09f, 0x1a0, 0x08f,
1650     0x08d, 0x090, 0x098, 0x0a6, 0x0b6, 0x0c4, 0x19f, 0x1af,
1651     0x1bf, 0x399, 0x3bf, 0x3b4, 0x3c9, 0x3e7, 0x0a8, 0x1b6,
1652     0x0ab, 0x0a4, 0x0aa, 0x0b2, 0x0c2, 0x0c5, 0x198, 0x1a4,
1653     0x1b8, 0x38c, 0x3a4, 0x3c4, 0x3c6, 0x3dd, 0x3e8, 0x0ad,
1654     0x3af, 0x192, 0x0bd, 0x0bc, 0x18e, 0x197, 0x19a, 0x1a3,
1655     0x1b1, 0x38d, 0x398, 0x3b7, 0x3d3, 0x3d1, 0x3db, 0x7dd,
1656     0x0b4, 0x3de, 0x1a9, 0x19b, 0x19c, 0x1a1, 0x1aa, 0x1ad,
1657     0x1b3, 0x38b, 0x3b2, 0x3b8, 0x3ce, 0x3e1, 0x3e0, 0x7d2,
1658     0x7e5, 0x0b7, 0x7e3, 0x1bb, 0x1a8, 0x1a6, 0x1b0, 0x1b2,
1659     0x1b7, 0x39b, 0x39a, 0x3ba, 0x3b5, 0x3d6, 0x7d7, 0x3e4,
1660     0x7d8, 0x7ea, 0x0ba, 0x7e8, 0x3a0, 0x1bd, 0x1b4, 0x38a,
1661     0x1c4, 0x392, 0x3aa, 0x3b0, 0x3bc, 0x3d7, 0x7d4, 0x7dc,
1662     0x7db, 0x7d5, 0x7f0, 0x0c1, 0x7fb, 0x3c8, 0x3a3, 0x395,
1663     0x39d, 0x3ac, 0x3ae, 0x3c5, 0x3d8, 0x3e2, 0x3e6, 0x7e4,
1664     0x7e7, 0x7e0, 0x7e9, 0x7f7, 0x190, 0x7f2, 0x393, 0x1be,
1665     0x1c0, 0x394, 0x397, 0x3ad, 0x3c3, 0x3c1, 0x3d2, 0x7da,
1666     0x7d9, 0x7df, 0x7eb, 0x7f4, 0x7fa, 0x195, 0x7f8, 0x3bd,
1667     0x39c, 0x3ab, 0x3a8, 0x3b3, 0x3b9, 0x3d0, 0x3e3, 0x3e5,
1668     0x7e2, 0x7de, 0x7ed, 0x7f1, 0x7f9, 0x7fc, 0x193, 0xffd,
1669     0x3dc, 0x3b6, 0x3c7, 0x3cc, 0x3cb, 0x3d9, 0x3da, 0x7d3,
1670     0x7e1, 0x7ee, 0x7ef, 0x7f5, 0x7f6, 0xffc, 0xfff, 0x19d,
1671     0x1c2, 0x0b5, 0x0a1, 0x096, 0x097, 0x095, 0x099, 0x0a0,
1672     0x0a2, 0x0ac, 0x0a9, 0x0b1, 0x0b3, 0x0bb, 0x0c0, 0x18f,
1673     0x004
1674 ];
1675
1676 const AAC_SPEC_BITS: [&[u8]; 11] = [
1677     AAC_SPEC_CB1_BITS, AAC_SPEC_CB2_BITS, AAC_SPEC_CB3_BITS, AAC_SPEC_CB4_BITS,
1678     AAC_SPEC_CB5_BITS, AAC_SPEC_CB6_BITS, AAC_SPEC_CB7_BITS, AAC_SPEC_CB8_BITS,
1679     AAC_SPEC_CB9_BITS, AAC_SPEC_CB10_BITS, AAC_SPEC_CB11_BITS
1680 ];
1681 const AAC_SPEC_CODES: [&[u16]; 11] = [
1682     AAC_SPEC_CB1_CODES, AAC_SPEC_CB2_CODES, AAC_SPEC_CB3_CODES, AAC_SPEC_CB4_CODES,
1683     AAC_SPEC_CB5_CODES, AAC_SPEC_CB6_CODES, AAC_SPEC_CB7_CODES, AAC_SPEC_CB8_CODES,
1684     AAC_SPEC_CB9_CODES, AAC_SPEC_CB10_CODES, AAC_SPEC_CB11_CODES
1685 ];
1686 const AAC_UNSIGNED_CODEBOOK: [bool; 11] = [
1687     false, false, true, true, false, false, true, true, true, true, true
1688 ];
1689 const AAC_CODEBOOK_MODULO: [u16; 7] = [
1690     9, 9, 8, 8, 13, 13, 17
1691 ];
1692
1693 const AAC_QUADS: [[i8; 4]; 81] = [
1694     [ 0, 0, 0, 0 ], [ 0, 0, 0, 1 ], [ 0, 0, 0, 2 ],
1695     [ 0, 0, 1, 0 ], [ 0, 0, 1, 1 ], [ 0, 0, 1, 2 ],
1696     [ 0, 0, 2, 0 ], [ 0, 0, 2, 1 ], [ 0, 0, 2, 2 ],
1697     [ 0, 1, 0, 0 ], [ 0, 1, 0, 1 ], [ 0, 1, 0, 2 ],
1698     [ 0, 1, 1, 0 ], [ 0, 1, 1, 1 ], [ 0, 1, 1, 2 ],
1699     [ 0, 1, 2, 0 ], [ 0, 1, 2, 1 ], [ 0, 1, 2, 2 ],
1700     [ 0, 2, 0, 0 ], [ 0, 2, 0, 1 ], [ 0, 2, 0, 2 ],
1701     [ 0, 2, 1, 0 ], [ 0, 2, 1, 1 ], [ 0, 2, 1, 2 ],
1702     [ 0, 2, 2, 0 ], [ 0, 2, 2, 1 ], [ 0, 2, 2, 2 ],
1703     [ 1, 0, 0, 0 ], [ 1, 0, 0, 1 ], [ 1, 0, 0, 2 ],
1704     [ 1, 0, 1, 0 ], [ 1, 0, 1, 1 ], [ 1, 0, 1, 2 ],
1705     [ 1, 0, 2, 0 ], [ 1, 0, 2, 1 ], [ 1, 0, 2, 2 ],
1706     [ 1, 1, 0, 0 ], [ 1, 1, 0, 1 ], [ 1, 1, 0, 2 ],
1707     [ 1, 1, 1, 0 ], [ 1, 1, 1, 1 ], [ 1, 1, 1, 2 ],
1708     [ 1, 1, 2, 0 ], [ 1, 1, 2, 1 ], [ 1, 1, 2, 2 ],
1709     [ 1, 2, 0, 0 ], [ 1, 2, 0, 1 ], [ 1, 2, 0, 2 ],
1710     [ 1, 2, 1, 0 ], [ 1, 2, 1, 1 ], [ 1, 2, 1, 2 ],
1711     [ 1, 2, 2, 0 ], [ 1, 2, 2, 1 ], [ 1, 2, 2, 2 ],
1712     [ 2, 0, 0, 0 ], [ 2, 0, 0, 1 ], [ 2, 0, 0, 2 ],
1713     [ 2, 0, 1, 0 ], [ 2, 0, 1, 1 ], [ 2, 0, 1, 2 ],
1714     [ 2, 0, 2, 0 ], [ 2, 0, 2, 1 ], [ 2, 0, 2, 2 ],
1715     [ 2, 1, 0, 0 ], [ 2, 1, 0, 1 ], [ 2, 1, 0, 2 ],
1716     [ 2, 1, 1, 0 ], [ 2, 1, 1, 1 ], [ 2, 1, 1, 2 ],
1717     [ 2, 1, 2, 0 ], [ 2, 1, 2, 1 ], [ 2, 1, 2, 2 ],
1718     [ 2, 2, 0, 0 ], [ 2, 2, 0, 1 ], [ 2, 2, 0, 2 ],
1719     [ 2, 2, 1, 0 ], [ 2, 2, 1, 1 ], [ 2, 2, 1, 2 ],
1720     [ 2, 2, 2, 0 ], [ 2, 2, 2, 1 ], [ 2, 2, 2, 2 ],
1721 ];
1722
1723 const DEFAULT_CHANNEL_MAP: [&str; 9] = [
1724     "",
1725     "C",
1726     "L,R",
1727     "C,L,R",
1728     "C,L,R,Cs",
1729     "C,L,R,Ls,Rs",
1730     "C,L,R,Ls,Rs,LFE",
1731     "",
1732     "C,L,R,Ls,Rs,Lss,Rss,LFE",
1733 ];
1734
1735 const SWB_OFFSET_48K_LONG: [usize; 49+1] = [
1736       0,   4,   8,  12,  16,  20,  24,  28,
1737      32,  36,  40,  48,  56,  64,  72,  80,
1738      88,  96, 108, 120, 132, 144, 160, 176,
1739     196, 216, 240, 264, 292, 320, 352, 384,
1740     416, 448, 480, 512, 544, 576, 608, 640,
1741     672, 704, 736, 768, 800, 832, 864, 896,
1742     928, 1024
1743 ];
1744 const SWB_OFFSET_48K_SHORT: [usize; 14+1] = [
1745     0, 4, 8, 12, 16, 20, 28, 36, 44, 56, 68, 80, 96, 112, 128
1746 ];
1747 const SWB_OFFSET_32K_LONG: [usize; 51+1] = [
1748       0,   4,   8,  12,  16,  20,  24,  28,
1749      32,  36,  40,  48,  56,  64,  72,  80,
1750      88,  96, 108, 120, 132, 144, 160, 176,
1751     196, 216, 240, 264, 292, 320, 352, 384,
1752     416, 448, 480, 512, 544, 576, 608, 640,
1753     672, 704, 736, 768, 800, 832, 864, 896,
1754     928, 960, 992, 1024
1755 ];
1756 const SWB_OFFSET_8K_LONG: [usize; 40+1] = [
1757       0,  12,  24,  36,  48,  60,  72,  84,
1758      96, 108, 120, 132, 144, 156, 172, 188,
1759     204, 220, 236, 252, 268, 288, 308, 328,
1760     348, 372, 396, 420, 448, 476, 508, 544,
1761     580, 620, 664, 712, 764, 820, 880, 944,
1762     1024
1763 ];
1764 const SWB_OFFSET_8K_SHORT: [usize; 15+1] = [
1765     0, 4, 8, 12, 16, 20, 24, 28, 36, 44, 52, 60, 72, 88, 108, 128
1766 ];
1767 const SWB_OFFSET_16K_LONG: [usize; 43+1] = [
1768       0,   8,  16,  24,  32,  40,  48,  56,
1769      64,  72,  80,  88, 100, 112, 124, 136,
1770     148, 160, 172, 184, 196, 212, 228, 244,
1771     260, 280, 300, 320, 344, 368, 396, 424,
1772     456, 492, 532, 572, 616, 664, 716, 772,
1773     832, 896, 960, 1024
1774 ];
1775 const SWB_OFFSET_16K_SHORT: [usize; 15+1] = [
1776     0, 4, 8, 12, 16, 20, 24, 28, 32, 40, 48, 60, 72, 88, 108, 128
1777 ];
1778 const SWB_OFFSET_24K_LONG: [usize; 47+1] = [
1779       0,   4,   8,  12,  16,  20,  24,  28,
1780      32,  36,  40,  44,  52,  60,  68,  76,
1781      84,  92, 100, 108, 116, 124, 136, 148,
1782     160, 172, 188, 204, 220, 240, 260, 284,
1783     308, 336, 364, 396, 432, 468, 508, 552,
1784     600, 652, 704, 768, 832, 896, 960, 1024
1785 ];
1786 const SWB_OFFSET_24K_SHORT: [usize; 15+1] = [
1787     0, 4, 8, 12, 16, 20, 24, 28, 36, 44, 52, 64, 76, 92, 108, 128
1788 ];
1789 const SWB_OFFSET_64K_LONG: [usize; 47+1] = [
1790       0,   4,   8,  12,  16,  20,  24,  28,
1791      32,  36,  40,  44,  48,  52,  56,  64,
1792      72,  80,  88, 100, 112, 124, 140, 156,
1793     172, 192, 216, 240, 268, 304, 344, 384,
1794     424, 464, 504, 544, 584, 624, 664, 704,
1795     744, 784, 824, 864, 904, 944, 984, 1024
1796 ];
1797 const SWB_OFFSET_64K_SHORT: [usize; 12+1] = [
1798     0, 4, 8, 12, 16, 20, 24, 32, 40, 48, 64, 92, 128
1799 ];
1800 const SWB_OFFSET_96K_LONG: [usize; 41+1] = [
1801       0,   4,   8,  12,  16,  20,  24,  28,
1802      32,  36,  40,  44,  48,  52,  56,  64,
1803      72,  80,  88,  96, 108, 120, 132, 144,
1804     156, 172, 188, 212, 240, 276, 320, 384,
1805     448, 512, 576, 640, 704, 768, 832, 896,
1806     960, 1024
1807 ];
1808
1809 #[derive(Clone,Copy)]
1810 struct GASubbandInfo {
1811     min_srate:     u32,
1812     long_bands:    &'static [usize],
1813     short_bands:   &'static [usize],
1814 }
1815
1816 impl GASubbandInfo {
1817     fn find(srate: u32) -> GASubbandInfo {
1818         for sbi in AAC_SUBBAND_INFO.iter() {
1819             if srate >= sbi.min_srate {
1820                 return *sbi;
1821             }
1822         }
1823         unreachable!("")
1824     }
1825     fn find_idx(srate: u32) -> usize {
1826         for (i, sbi) in AAC_SUBBAND_INFO.iter().enumerate() {
1827             if srate >= sbi.min_srate {
1828                 return i;
1829             }
1830         }
1831         unreachable!("")
1832     }
1833 }
1834
1835 const AAC_SUBBAND_INFO: [GASubbandInfo; 12] = [
1836     GASubbandInfo { min_srate: 92017, long_bands: &SWB_OFFSET_96K_LONG, short_bands: &SWB_OFFSET_64K_SHORT }, //96K
1837     GASubbandInfo { min_srate: 75132, long_bands: &SWB_OFFSET_96K_LONG, short_bands: &SWB_OFFSET_64K_SHORT }, //88.2K
1838     GASubbandInfo { min_srate: 55426, long_bands: &SWB_OFFSET_64K_LONG, short_bands: &SWB_OFFSET_64K_SHORT }, //64K
1839     GASubbandInfo { min_srate: 46009, long_bands: &SWB_OFFSET_48K_LONG, short_bands: &SWB_OFFSET_48K_SHORT }, //48K
1840     GASubbandInfo { min_srate: 37566, long_bands: &SWB_OFFSET_48K_LONG, short_bands: &SWB_OFFSET_48K_SHORT }, //44.1K
1841     GASubbandInfo { min_srate: 27713, long_bands: &SWB_OFFSET_32K_LONG, short_bands: &SWB_OFFSET_48K_SHORT }, //32K
1842     GASubbandInfo { min_srate: 23004, long_bands: &SWB_OFFSET_24K_LONG, short_bands: &SWB_OFFSET_24K_SHORT }, //24K
1843     GASubbandInfo { min_srate: 18783, long_bands: &SWB_OFFSET_24K_LONG, short_bands: &SWB_OFFSET_24K_SHORT }, //22.05K
1844     GASubbandInfo { min_srate: 13856, long_bands: &SWB_OFFSET_16K_LONG, short_bands: &SWB_OFFSET_16K_SHORT }, //16K
1845     GASubbandInfo { min_srate: 11502, long_bands: &SWB_OFFSET_16K_LONG, short_bands: &SWB_OFFSET_16K_SHORT }, //12K
1846     GASubbandInfo { min_srate:  9391, long_bands: &SWB_OFFSET_16K_LONG, short_bands: &SWB_OFFSET_16K_SHORT }, //11.025K
1847     GASubbandInfo { min_srate:     0, long_bands: &SWB_OFFSET_8K_LONG,  short_bands: &SWB_OFFSET_8K_SHORT  }, //8K
1848 ];