src/codecs/aac.rs

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