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