nihav-commonfmt/src/codecs/aac.rs

   1 use nihav_core::formats::*;
   2 use nihav_core::frame::*;
   3 use nihav_core::codecs::*;
   4 use nihav_core::dsp::fft::FFTMode;
   5 use nihav_core::dsp::mdct::IMDCT;
   6 use nihav_core::dsp::window::*;
   7 use nihav_core::io::bitreader::*;
   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, 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 output = adata.get_data_mut().unwrap();
 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:       NACodecInfoRef,
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: NACodecInfoRef) -> 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 nihav_core::codecs::RegisteredDecoders;
1265     use nihav_core::demuxers::RegisteredDemuxers;
1266     use nihav_core::test::dec_video::test_decode_audio;
1267     use crate::codecs::generic_register_all_codecs;
1268     use nihav_realmedia::demuxers::realmedia_register_all_demuxers;
1269     #[test]
1270     fn test_aac() {
1271         let mut dmx_reg = RegisteredDemuxers::new();
1272         realmedia_register_all_demuxers(&mut dmx_reg);
1273         let mut dec_reg = RegisteredDecoders::new();
1274         generic_register_all_codecs(&mut dec_reg);
1275
1276 //        let file = "assets/RV/rv40_weighted_mc.rmvb";
1277         let file = "assets/RV/rv40_weighted_mc_2.rmvb";
1278         test_decode_audio("realmedia", file, Some(12000), "aac", &dmx_reg, &dec_reg);
1279     }
1280 }
1281
1282 const AAC_SCF_CODEBOOK_BITS: &[u8] = &[
1283     18, 18, 18, 18, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
1284     19, 19, 19, 18, 19, 18, 17, 17, 16, 17, 16, 16, 16, 16, 15, 15,
1285     14, 14, 14, 14, 14, 14, 13, 13, 12, 12, 12, 11, 12, 11, 10, 10,
1286     10,  9,  9,  8,  8,  8,  7,  6,  6,  5,  4,  3,  1,  4,  4,  5,
1287      6,  6,  7,  7,  8,  8,  9,  9, 10, 10, 10, 11, 11, 11, 11, 12,
1288     12, 13, 13, 13, 14, 14, 16, 15, 16, 15, 18, 19, 19, 19, 19, 19,
1289     19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
1290     19, 19, 19, 19, 19, 19, 19, 19, 19
1291 ];
1292
1293 const AAC_SCF_CODEBOOK_CODES: &[u32] = &[
1294     0x3FFE8, 0x3FFE6, 0x3FFE7, 0x3FFE5, 0x7FFF5, 0x7FFF1, 0x7FFED, 0x7FFF6,
1295     0x7FFEE, 0x7FFEF, 0x7FFF0, 0x7FFFC, 0x7FFFD, 0x7FFFF, 0x7FFFE, 0x7FFF7,
1296     0x7FFF8, 0x7FFFB, 0x7FFF9, 0x3FFE4, 0x7FFFA, 0x3FFE3, 0x1FFEF, 0x1FFF0,
1297     0x0FFF5, 0x1FFEE, 0x0FFF2, 0x0FFF3, 0x0FFF4, 0x0FFF1, 0x07FF6, 0x07FF7,
1298     0x03FF9, 0x03FF5, 0x03FF7, 0x03FF3, 0x03FF6, 0x03FF2, 0x01FF7, 0x01FF5,
1299     0x00FF9, 0x00FF7, 0x00FF6, 0x007F9, 0x00FF4, 0x007F8, 0x003F9, 0x003F7,
1300     0x003F5, 0x001F8, 0x001F7, 0x000FA, 0x000F8, 0x000F6, 0x00079, 0x0003A,
1301     0x00038, 0x0001A, 0x0000B, 0x00004, 0x00000, 0x0000A, 0x0000C, 0x0001B,
1302     0x00039, 0x0003B, 0x00078, 0x0007A, 0x000F7, 0x000F9, 0x001F6, 0x001F9,
1303     0x003F4, 0x003F6, 0x003F8, 0x007F5, 0x007F4, 0x007F6, 0x007F7, 0x00FF5,
1304     0x00FF8, 0x01FF4, 0x01FF6, 0x01FF8, 0x03FF8, 0x03FF4, 0x0FFF0, 0x07FF4,
1305     0x0FFF6, 0x07FF5, 0x3FFE2, 0x7FFD9, 0x7FFDA, 0x7FFDB, 0x7FFDC, 0x7FFDD,
1306     0x7FFDE, 0x7FFD8, 0x7FFD2, 0x7FFD3, 0x7FFD4, 0x7FFD5, 0x7FFD6, 0x7FFF2,
1307     0x7FFDF, 0x7FFE7, 0x7FFE8, 0x7FFE9, 0x7FFEA, 0x7FFEB, 0x7FFE6, 0x7FFE0,
1308     0x7FFE1, 0x7FFE2, 0x7FFE3, 0x7FFE4, 0x7FFE5, 0x7FFD7, 0x7FFEC, 0x7FFF4,
1309     0x7FFF3
1310 ];
1311
1312 const AAC_SPEC_CB1_BITS: &[u8] = &[
1313     11,  9, 11, 10,  7, 10, 11,  9, 11, 10,  7, 10,  7,  5,  7,  9,
1314      7, 10, 11,  9, 11,  9,  7,  9, 11,  9, 11,  9,  7,  9,  7,  5,
1315      7,  9,  7,  9,  7,  5,  7,  5,  1,  5,  7,  5,  7,  9,  7,  9,
1316      7,  5,  7,  9,  7,  9, 11,  9, 11,  9,  7,  9, 11,  9, 11, 10,
1317      7,  9,  7,  5,  7,  9,  7, 10, 11,  9, 11, 10,  7,  9, 11,  9,
1318     11
1319 ];
1320 const AAC_SPEC_CB1_CODES: &[u16] = &[
1321     0x7f8, 0x1f1, 0x7fd, 0x3f5, 0x068, 0x3f0, 0x7f7, 0x1ec,
1322     0x7f5, 0x3f1, 0x072, 0x3f4, 0x074, 0x011, 0x076, 0x1eb,
1323     0x06c, 0x3f6, 0x7fc, 0x1e1, 0x7f1, 0x1f0, 0x061, 0x1f6,
1324     0x7f2, 0x1ea, 0x7fb, 0x1f2, 0x069, 0x1ed, 0x077, 0x017,
1325     0x06f, 0x1e6, 0x064, 0x1e5, 0x067, 0x015, 0x062, 0x012,
1326     0x000, 0x014, 0x065, 0x016, 0x06d, 0x1e9, 0x063, 0x1e4,
1327     0x06b, 0x013, 0x071, 0x1e3, 0x070, 0x1f3, 0x7fe, 0x1e7,
1328     0x7f3, 0x1ef, 0x060, 0x1ee, 0x7f0, 0x1e2, 0x7fa, 0x3f3,
1329     0x06a, 0x1e8, 0x075, 0x010, 0x073, 0x1f4, 0x06e, 0x3f7,
1330     0x7f6, 0x1e0, 0x7f9, 0x3f2, 0x066, 0x1f5, 0x7ff, 0x1f7,
1331     0x7f4
1332 ];
1333 const AAC_SPEC_CB2_BITS: &[u8] = &[
1334     9, 7, 9, 8, 6, 8, 9, 8, 9, 8, 6, 7, 6, 5, 6, 7,
1335     6, 8, 9, 7, 8, 8, 6, 8, 9, 7, 9, 8, 6, 7, 6, 5,
1336     6, 7, 6, 8, 6, 5, 6, 5, 3, 5, 6, 5, 6, 8, 6, 7,
1337     6, 5, 6, 8, 6, 8, 9, 7, 9, 8, 6, 8, 8, 7, 9, 8,
1338     6, 7, 6, 4, 6, 8, 6, 7, 9, 7, 9, 7, 6, 8, 9, 7,
1339     9
1340 ];
1341 const AAC_SPEC_CB2_CODES: &[u16] = &[
1342     0x1f3, 0x06f, 0x1fd, 0x0eb, 0x023, 0x0ea, 0x1f7, 0x0e8,
1343     0x1fa, 0x0f2, 0x02d, 0x070, 0x020, 0x006, 0x02b, 0x06e,
1344     0x028, 0x0e9, 0x1f9, 0x066, 0x0f8, 0x0e7, 0x01b, 0x0f1,
1345     0x1f4, 0x06b, 0x1f5, 0x0ec, 0x02a, 0x06c, 0x02c, 0x00a,
1346     0x027, 0x067, 0x01a, 0x0f5, 0x024, 0x008, 0x01f, 0x009,
1347     0x000, 0x007, 0x01d, 0x00b, 0x030, 0x0ef, 0x01c, 0x064,
1348     0x01e, 0x00c, 0x029, 0x0f3, 0x02f, 0x0f0, 0x1fc, 0x071,
1349     0x1f2, 0x0f4, 0x021, 0x0e6, 0x0f7, 0x068, 0x1f8, 0x0ee,
1350     0x022, 0x065, 0x031, 0x002, 0x026, 0x0ed, 0x025, 0x06a,
1351     0x1fb, 0x072, 0x1fe, 0x069, 0x02e, 0x0f6, 0x1ff, 0x06d,
1352     0x1f6
1353 ];
1354 const AAC_SPEC_CB3_BITS: &[u8] = &[
1355      1,  4,  8,  4,  5,  8,  9,  9, 10,  4,  6,  9,  6,  6,  9,  9,
1356      9, 10,  9, 10, 13,  9,  9, 11, 11, 10, 12,  4,  6, 10,  6,  7,
1357     10, 10, 10, 12,  5,  7, 11,  6,  7, 10,  9,  9, 11,  9, 10, 13,
1358      8,  9, 12, 10, 11, 12,  8, 10, 15,  9, 11, 15, 13, 14, 16,  8,
1359     10, 14,  9, 10, 14, 12, 12, 15, 11, 12, 16, 10, 11, 15, 12, 12,
1360     15
1361 ];
1362 const AAC_SPEC_CB3_CODES: &[u16] = &[
1363     0x0000, 0x0009, 0x00ef, 0x000b, 0x0019, 0x00f0, 0x01eb, 0x01e6,
1364     0x03f2, 0x000a, 0x0035, 0x01ef, 0x0034, 0x0037, 0x01e9, 0x01ed,
1365     0x01e7, 0x03f3, 0x01ee, 0x03ed, 0x1ffa, 0x01ec, 0x01f2, 0x07f9,
1366     0x07f8, 0x03f8, 0x0ff8, 0x0008, 0x0038, 0x03f6, 0x0036, 0x0075,
1367     0x03f1, 0x03eb, 0x03ec, 0x0ff4, 0x0018, 0x0076, 0x07f4, 0x0039,
1368     0x0074, 0x03ef, 0x01f3, 0x01f4, 0x07f6, 0x01e8, 0x03ea, 0x1ffc,
1369     0x00f2, 0x01f1, 0x0ffb, 0x03f5, 0x07f3, 0x0ffc, 0x00ee, 0x03f7,
1370     0x7ffe, 0x01f0, 0x07f5, 0x7ffd, 0x1ffb, 0x3ffa, 0xffff, 0x00f1,
1371     0x03f0, 0x3ffc, 0x01ea, 0x03ee, 0x3ffb, 0x0ff6, 0x0ffa, 0x7ffc,
1372     0x07f2, 0x0ff5, 0xfffe, 0x03f4, 0x07f7, 0x7ffb, 0x0ff7, 0x0ff9,
1373     0x7ffa
1374 ];
1375 const AAC_SPEC_CB4_BITS: &[u8] = &[
1376      4,  5,  8,  5,  4,  8,  9,  8, 11,  5,  5,  8,  5,  4,  8,  8,
1377      7, 10,  9,  8, 11,  8,  8, 10, 11, 10, 11,  4,  5,  8,  4,  4,
1378      8,  8,  8, 10,  4,  4,  8,  4,  4,  7,  8,  7,  9,  8,  8, 10,
1379      7,  7,  9, 10,  9, 10,  8,  8, 11,  8,  7, 10, 11, 10, 12,  8,
1380      7, 10,  7,  7,  9, 10,  9, 11, 11, 10, 12, 10,  9, 11, 11, 10,
1381     11
1382 ];
1383 const AAC_SPEC_CB4_CODES: &[u16] = &[
1384     0x007, 0x016, 0x0f6, 0x018, 0x008, 0x0ef, 0x1ef, 0x0f3,
1385     0x7f8, 0x019, 0x017, 0x0ed, 0x015, 0x001, 0x0e2, 0x0f0,
1386     0x070, 0x3f0, 0x1ee, 0x0f1, 0x7fa, 0x0ee, 0x0e4, 0x3f2,
1387     0x7f6, 0x3ef, 0x7fd, 0x005, 0x014, 0x0f2, 0x009, 0x004,
1388     0x0e5, 0x0f4, 0x0e8, 0x3f4, 0x006, 0x002, 0x0e7, 0x003,
1389     0x000, 0x06b, 0x0e3, 0x069, 0x1f3, 0x0eb, 0x0e6, 0x3f6,
1390     0x06e, 0x06a, 0x1f4, 0x3ec, 0x1f0, 0x3f9, 0x0f5, 0x0ec,
1391     0x7fb, 0x0ea, 0x06f, 0x3f7, 0x7f9, 0x3f3, 0xfff, 0x0e9,
1392     0x06d, 0x3f8, 0x06c, 0x068, 0x1f5, 0x3ee, 0x1f2, 0x7f4,
1393     0x7f7, 0x3f1, 0xffe, 0x3ed, 0x1f1, 0x7f5, 0x7fe, 0x3f5,
1394     0x7fc
1395 ];
1396 const AAC_SPEC_CB5_BITS: &[u8] = &[
1397     13, 12, 11, 11, 10, 11, 11, 12, 13, 12, 11, 10,  9,  8,  9, 10,
1398     11, 12, 12, 10,  9,  8,  7,  8,  9, 10, 11, 11,  9,  8,  5,  4,
1399      5,  8,  9, 11, 10,  8,  7,  4,  1,  4,  7,  8, 11, 11,  9,  8,
1400      5,  4,  5,  8,  9, 11, 11, 10,  9,  8,  7,  8,  9, 10, 11, 12,
1401     11, 10,  9,  8,  9, 10, 11, 12, 13, 12, 12, 11, 10, 10, 11, 12,
1402     13
1403 ];
1404 const AAC_SPEC_CB5_CODES: &[u16] = &[
1405     0x1fff, 0x0ff7, 0x07f4, 0x07e8, 0x03f1, 0x07ee, 0x07f9, 0x0ff8,
1406     0x1ffd, 0x0ffd, 0x07f1, 0x03e8, 0x01e8, 0x00f0, 0x01ec, 0x03ee,
1407     0x07f2, 0x0ffa, 0x0ff4, 0x03ef, 0x01f2, 0x00e8, 0x0070, 0x00ec,
1408     0x01f0, 0x03ea, 0x07f3, 0x07eb, 0x01eb, 0x00ea, 0x001a, 0x0008,
1409     0x0019, 0x00ee, 0x01ef, 0x07ed, 0x03f0, 0x00f2, 0x0073, 0x000b,
1410     0x0000, 0x000a, 0x0071, 0x00f3, 0x07e9, 0x07ef, 0x01ee, 0x00ef,
1411     0x0018, 0x0009, 0x001b, 0x00eb, 0x01e9, 0x07ec, 0x07f6, 0x03eb,
1412     0x01f3, 0x00ed, 0x0072, 0x00e9, 0x01f1, 0x03ed, 0x07f7, 0x0ff6,
1413     0x07f0, 0x03e9, 0x01ed, 0x00f1, 0x01ea, 0x03ec, 0x07f8, 0x0ff9,
1414     0x1ffc, 0x0ffc, 0x0ff5, 0x07ea, 0x03f3, 0x03f2, 0x07f5, 0x0ffb,
1415     0x1ffe
1416 ];
1417 const AAC_SPEC_CB6_BITS: &[u8] = &[
1418     11, 10,  9,  9,  9,  9,  9, 10, 11, 10,  9,  8,  7,  7,  7,  8,
1419      9, 10,  9,  8,  6,  6,  6,  6,  6,  8,  9,  9,  7,  6,  4,  4,
1420      4,  6,  7,  9,  9,  7,  6,  4,  4,  4,  6,  7,  9,  9,  7,  6,
1421      4,  4,  4,  6,  7,  9,  9,  8,  6,  6,  6,  6,  6,  8,  9, 10,
1422      9,  8,  7,  7,  7,  7,  8, 10, 11, 10,  9,  9,  9,  9,  9, 10,
1423     11
1424 ];
1425 const AAC_SPEC_CB6_CODES: &[u16] = &[
1426     0x7fe, 0x3fd, 0x1f1, 0x1eb, 0x1f4, 0x1ea, 0x1f0, 0x3fc,
1427     0x7fd, 0x3f6, 0x1e5, 0x0ea, 0x06c, 0x071, 0x068, 0x0f0,
1428     0x1e6, 0x3f7, 0x1f3, 0x0ef, 0x032, 0x027, 0x028, 0x026,
1429     0x031, 0x0eb, 0x1f7, 0x1e8, 0x06f, 0x02e, 0x008, 0x004,
1430     0x006, 0x029, 0x06b, 0x1ee, 0x1ef, 0x072, 0x02d, 0x002,
1431     0x000, 0x003, 0x02f, 0x073, 0x1fa, 0x1e7, 0x06e, 0x02b,
1432     0x007, 0x001, 0x005, 0x02c, 0x06d, 0x1ec, 0x1f9, 0x0ee,
1433     0x030, 0x024, 0x02a, 0x025, 0x033, 0x0ec, 0x1f2, 0x3f8,
1434     0x1e4, 0x0ed, 0x06a, 0x070, 0x069, 0x074, 0x0f1, 0x3fa,
1435     0x7ff, 0x3f9, 0x1f6, 0x1ed, 0x1f8, 0x1e9, 0x1f5, 0x3fb,
1436     0x7fc
1437 ];
1438 const AAC_SPEC_CB7_BITS: &[u8] = &[
1439      1,  3,  6,  7,  8,  9, 10, 11,  3,  4,  6,  7,  8,  8,  9,  9,
1440      6,  6,  7,  8,  8,  9,  9, 10,  7,  7,  8,  8,  9,  9, 10, 10,
1441      8,  8,  9,  9, 10, 10, 10, 11,  9,  8,  9,  9, 10, 10, 11, 11,
1442     10,  9,  9, 10, 10, 11, 12, 12, 11, 10, 10, 10, 11, 11, 12, 12
1443 ];
1444 const AAC_SPEC_CB7_CODES: &[u16] = &[
1445     0x000, 0x005, 0x037, 0x074, 0x0f2, 0x1eb, 0x3ed, 0x7f7,
1446     0x004, 0x00c, 0x035, 0x071, 0x0ec, 0x0ee, 0x1ee, 0x1f5,
1447     0x036, 0x034, 0x072, 0x0ea, 0x0f1, 0x1e9, 0x1f3, 0x3f5,
1448     0x073, 0x070, 0x0eb, 0x0f0, 0x1f1, 0x1f0, 0x3ec, 0x3fa,
1449     0x0f3, 0x0ed, 0x1e8, 0x1ef, 0x3ef, 0x3f1, 0x3f9, 0x7fb,
1450     0x1ed, 0x0ef, 0x1ea, 0x1f2, 0x3f3, 0x3f8, 0x7f9, 0x7fc,
1451     0x3ee, 0x1ec, 0x1f4, 0x3f4, 0x3f7, 0x7f8, 0xffd, 0xffe,
1452     0x7f6, 0x3f0, 0x3f2, 0x3f6, 0x7fa, 0x7fd, 0xffc, 0xfff
1453 ];
1454 const AAC_SPEC_CB8_BITS: &[u8] = &[
1455      5,  4,  5,  6,  7,  8,  9, 10,  4,  3,  4,  5,  6,  7,  7,  8,
1456      5,  4,  4,  5,  6,  7,  7,  8,  6,  5,  5,  6,  6,  7,  8,  8,
1457      7,  6,  6,  6,  7,  7,  8,  9,  8,  7,  6,  7,  7,  8,  8, 10,
1458      9,  7,  7,  8,  8,  8,  9,  9, 10,  8,  8,  8,  9,  9,  9, 10
1459 ];
1460 const AAC_SPEC_CB8_CODES: &[u16] = &[
1461     0x00e, 0x005, 0x010, 0x030, 0x06f, 0x0f1, 0x1fa, 0x3fe,
1462     0x003, 0x000, 0x004, 0x012, 0x02c, 0x06a, 0x075, 0x0f8,
1463     0x00f, 0x002, 0x006, 0x014, 0x02e, 0x069, 0x072, 0x0f5,
1464     0x02f, 0x011, 0x013, 0x02a, 0x032, 0x06c, 0x0ec, 0x0fa,
1465     0x071, 0x02b, 0x02d, 0x031, 0x06d, 0x070, 0x0f2, 0x1f9,
1466     0x0ef, 0x068, 0x033, 0x06b, 0x06e, 0x0ee, 0x0f9, 0x3fc,
1467     0x1f8, 0x074, 0x073, 0x0ed, 0x0f0, 0x0f6, 0x1f6, 0x1fd,
1468     0x3fd, 0x0f3, 0x0f4, 0x0f7, 0x1f7, 0x1fb, 0x1fc, 0x3ff
1469 ];
1470 const AAC_SPEC_CB9_BITS: &[u8] = &[
1471      1,  3,  6,  8,  9, 10, 10, 11, 11, 12, 12, 13, 13,  3,  4,  6,
1472      7,  8,  8,  9, 10, 10, 10, 11, 12, 12,  6,  6,  7,  8,  8,  9,
1473     10, 10, 10, 11, 12, 12, 12,  8,  7,  8,  9,  9, 10, 10, 11, 11,
1474     11, 12, 12, 13,  9,  8,  9,  9, 10, 10, 11, 11, 11, 12, 12, 12,
1475     13, 10,  9,  9, 10, 11, 11, 11, 12, 11, 12, 12, 13, 13, 11,  9,
1476     10, 11, 11, 11, 12, 12, 12, 12, 13, 13, 13, 11, 10, 10, 11, 11,
1477     12, 12, 13, 13, 13, 13, 13, 13, 11, 10, 10, 11, 11, 11, 12, 12,
1478     13, 13, 14, 13, 14, 11, 10, 11, 11, 12, 12, 12, 12, 13, 13, 14,
1479     14, 14, 12, 11, 11, 12, 12, 12, 13, 13, 13, 14, 14, 14, 15, 12,
1480     11, 12, 12, 12, 13, 13, 13, 13, 14, 14, 15, 15, 13, 12, 12, 12,
1481     13, 13, 13, 13, 14, 14, 14, 14, 15
1482 ];
1483 const AAC_SPEC_CB9_CODES: &[u16] = &[
1484     0x0000, 0x0005, 0x0037, 0x00e7, 0x01de, 0x03ce, 0x03d9, 0x07c8,
1485     0x07cd, 0x0fc8, 0x0fdd, 0x1fe4, 0x1fec, 0x0004, 0x000c, 0x0035,
1486     0x0072, 0x00ea, 0x00ed, 0x01e2, 0x03d1, 0x03d3, 0x03e0, 0x07d8,
1487     0x0fcf, 0x0fd5, 0x0036, 0x0034, 0x0071, 0x00e8, 0x00ec, 0x01e1,
1488     0x03cf, 0x03dd, 0x03db, 0x07d0, 0x0fc7, 0x0fd4, 0x0fe4, 0x00e6,
1489     0x0070, 0x00e9, 0x01dd, 0x01e3, 0x03d2, 0x03dc, 0x07cc, 0x07ca,
1490     0x07de, 0x0fd8, 0x0fea, 0x1fdb, 0x01df, 0x00eb, 0x01dc, 0x01e6,
1491     0x03d5, 0x03de, 0x07cb, 0x07dd, 0x07dc, 0x0fcd, 0x0fe2, 0x0fe7,
1492     0x1fe1, 0x03d0, 0x01e0, 0x01e4, 0x03d6, 0x07c5, 0x07d1, 0x07db,
1493     0x0fd2, 0x07e0, 0x0fd9, 0x0feb, 0x1fe3, 0x1fe9, 0x07c4, 0x01e5,
1494     0x03d7, 0x07c6, 0x07cf, 0x07da, 0x0fcb, 0x0fda, 0x0fe3, 0x0fe9,
1495     0x1fe6, 0x1ff3, 0x1ff7, 0x07d3, 0x03d8, 0x03e1, 0x07d4, 0x07d9,
1496     0x0fd3, 0x0fde, 0x1fdd, 0x1fd9, 0x1fe2, 0x1fea, 0x1ff1, 0x1ff6,
1497     0x07d2, 0x03d4, 0x03da, 0x07c7, 0x07d7, 0x07e2, 0x0fce, 0x0fdb,
1498     0x1fd8, 0x1fee, 0x3ff0, 0x1ff4, 0x3ff2, 0x07e1, 0x03df, 0x07c9,
1499     0x07d6, 0x0fca, 0x0fd0, 0x0fe5, 0x0fe6, 0x1feb, 0x1fef, 0x3ff3,
1500     0x3ff4, 0x3ff5, 0x0fe0, 0x07ce, 0x07d5, 0x0fc6, 0x0fd1, 0x0fe1,
1501     0x1fe0, 0x1fe8, 0x1ff0, 0x3ff1, 0x3ff8, 0x3ff6, 0x7ffc, 0x0fe8,
1502     0x07df, 0x0fc9, 0x0fd7, 0x0fdc, 0x1fdc, 0x1fdf, 0x1fed, 0x1ff5,
1503     0x3ff9, 0x3ffb, 0x7ffd, 0x7ffe, 0x1fe7, 0x0fcc, 0x0fd6, 0x0fdf,
1504     0x1fde, 0x1fda, 0x1fe5, 0x1ff2, 0x3ffa, 0x3ff7, 0x3ffc, 0x3ffd,
1505     0x7fff
1506 ];
1507 const AAC_SPEC_CB10_BITS: &[u8] = &[
1508      6,  5,  6,  6,  7,  8,  9, 10, 10, 10, 11, 11, 12,  5,  4,  4,
1509      5,  6,  7,  7,  8,  8,  9, 10, 10, 11,  6,  4,  5,  5,  6,  6,
1510      7,  8,  8,  9,  9, 10, 10,  6,  5,  5,  5,  6,  7,  7,  8,  8,
1511      9,  9, 10, 10,  7,  6,  6,  6,  6,  7,  7,  8,  8,  9,  9, 10,
1512     10,  8,  7,  6,  7,  7,  7,  8,  8,  8,  9, 10, 10, 11,  9,  7,
1513      7,  7,  7,  8,  8,  9,  9,  9, 10, 10, 11,  9,  8,  8,  8,  8,
1514      8,  9,  9,  9, 10, 10, 11, 11,  9,  8,  8,  8,  8,  8,  9,  9,
1515     10, 10, 10, 11, 11, 10,  9,  9,  9,  9,  9,  9, 10, 10, 10, 11,
1516     11, 12, 10,  9,  9,  9,  9, 10, 10, 10, 10, 11, 11, 11, 12, 11,
1517     10,  9, 10, 10, 10, 10, 10, 11, 11, 11, 11, 12, 11, 10, 10, 10,
1518     10, 10, 10, 11, 11, 12, 12, 12, 12
1519 ];
1520 const AAC_SPEC_CB10_CODES: &[u16] = &[
1521     0x022, 0x008, 0x01d, 0x026, 0x05f, 0x0d3, 0x1cf, 0x3d0,
1522     0x3d7, 0x3ed, 0x7f0, 0x7f6, 0xffd, 0x007, 0x000, 0x001,
1523     0x009, 0x020, 0x054, 0x060, 0x0d5, 0x0dc, 0x1d4, 0x3cd,
1524     0x3de, 0x7e7, 0x01c, 0x002, 0x006, 0x00c, 0x01e, 0x028,
1525     0x05b, 0x0cd, 0x0d9, 0x1ce, 0x1dc, 0x3d9, 0x3f1, 0x025,
1526     0x00b, 0x00a, 0x00d, 0x024, 0x057, 0x061, 0x0cc, 0x0dd,
1527     0x1cc, 0x1de, 0x3d3, 0x3e7, 0x05d, 0x021, 0x01f, 0x023,
1528     0x027, 0x059, 0x064, 0x0d8, 0x0df, 0x1d2, 0x1e2, 0x3dd,
1529     0x3ee, 0x0d1, 0x055, 0x029, 0x056, 0x058, 0x062, 0x0ce,
1530     0x0e0, 0x0e2, 0x1da, 0x3d4, 0x3e3, 0x7eb, 0x1c9, 0x05e,
1531     0x05a, 0x05c, 0x063, 0x0ca, 0x0da, 0x1c7, 0x1ca, 0x1e0,
1532     0x3db, 0x3e8, 0x7ec, 0x1e3, 0x0d2, 0x0cb, 0x0d0, 0x0d7,
1533     0x0db, 0x1c6, 0x1d5, 0x1d8, 0x3ca, 0x3da, 0x7ea, 0x7f1,
1534     0x1e1, 0x0d4, 0x0cf, 0x0d6, 0x0de, 0x0e1, 0x1d0, 0x1d6,
1535     0x3d1, 0x3d5, 0x3f2, 0x7ee, 0x7fb, 0x3e9, 0x1cd, 0x1c8,
1536     0x1cb, 0x1d1, 0x1d7, 0x1df, 0x3cf, 0x3e0, 0x3ef, 0x7e6,
1537     0x7f8, 0xffa, 0x3eb, 0x1dd, 0x1d3, 0x1d9, 0x1db, 0x3d2,
1538     0x3cc, 0x3dc, 0x3ea, 0x7ed, 0x7f3, 0x7f9, 0xff9, 0x7f2,
1539     0x3ce, 0x1e4, 0x3cb, 0x3d8, 0x3d6, 0x3e2, 0x3e5, 0x7e8,
1540     0x7f4, 0x7f5, 0x7f7, 0xffb, 0x7fa, 0x3ec, 0x3df, 0x3e1,
1541     0x3e4, 0x3e6, 0x3f0, 0x7e9, 0x7ef, 0xff8, 0xffe, 0xffc,
1542     0xfff
1543 ];
1544 const AAC_SPEC_CB11_BITS: &[u8] = &[
1545      4,  5,  6,  7,  8,  8,  9, 10, 10, 10, 11, 11, 12, 11, 12, 12,
1546     10,  5,  4,  5,  6,  7,  7,  8,  8,  9,  9,  9, 10, 10, 10, 10,
1547     11,  8,  6,  5,  5,  6,  7,  7,  8,  8,  8,  9,  9,  9, 10, 10,
1548     10, 10,  8,  7,  6,  6,  6,  7,  7,  8,  8,  8,  9,  9,  9, 10,
1549     10, 10, 10,  8,  8,  7,  7,  7,  7,  8,  8,  8,  8,  9,  9,  9,
1550     10, 10, 10, 10,  8,  8,  7,  7,  7,  7,  8,  8,  8,  9,  9,  9,
1551      9, 10, 10, 10, 10,  8,  9,  8,  8,  8,  8,  8,  8,  8,  9,  9,
1552      9, 10, 10, 10, 10, 10,  8,  9,  8,  8,  8,  8,  8,  8,  9,  9,
1553      9, 10, 10, 10, 10, 10, 10,  8, 10,  9,  8,  8,  9,  9,  9,  9,
1554      9, 10, 10, 10, 10, 10, 10, 11,  8, 10,  9,  9,  9,  9,  9,  9,
1555      9, 10, 10, 10, 10, 10, 10, 11, 11,  8, 11,  9,  9,  9,  9,  9,
1556      9, 10, 10, 10, 10, 10, 11, 10, 11, 11,  8, 11, 10,  9,  9, 10,
1557      9, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11,  8, 11, 10, 10, 10,
1558     10, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11,  9, 11, 10,  9,
1559      9, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11,  9, 11, 10,
1560     10, 10, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11,  9, 12,
1561     10, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11, 12, 12,  9,
1562      9,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  9,
1563      5
1564 ];
1565 const AAC_SPEC_CB11_CODES: &[u16] = &[
1566     0x000, 0x006, 0x019, 0x03d, 0x09c, 0x0c6, 0x1a7, 0x390,
1567     0x3c2, 0x3df, 0x7e6, 0x7f3, 0xffb, 0x7ec, 0xffa, 0xffe,
1568     0x38e, 0x005, 0x001, 0x008, 0x014, 0x037, 0x042, 0x092,
1569     0x0af, 0x191, 0x1a5, 0x1b5, 0x39e, 0x3c0, 0x3a2, 0x3cd,
1570     0x7d6, 0x0ae, 0x017, 0x007, 0x009, 0x018, 0x039, 0x040,
1571     0x08e, 0x0a3, 0x0b8, 0x199, 0x1ac, 0x1c1, 0x3b1, 0x396,
1572     0x3be, 0x3ca, 0x09d, 0x03c, 0x015, 0x016, 0x01a, 0x03b,
1573     0x044, 0x091, 0x0a5, 0x0be, 0x196, 0x1ae, 0x1b9, 0x3a1,
1574     0x391, 0x3a5, 0x3d5, 0x094, 0x09a, 0x036, 0x038, 0x03a,
1575     0x041, 0x08c, 0x09b, 0x0b0, 0x0c3, 0x19e, 0x1ab, 0x1bc,
1576     0x39f, 0x38f, 0x3a9, 0x3cf, 0x093, 0x0bf, 0x03e, 0x03f,
1577     0x043, 0x045, 0x09e, 0x0a7, 0x0b9, 0x194, 0x1a2, 0x1ba,
1578     0x1c3, 0x3a6, 0x3a7, 0x3bb, 0x3d4, 0x09f, 0x1a0, 0x08f,
1579     0x08d, 0x090, 0x098, 0x0a6, 0x0b6, 0x0c4, 0x19f, 0x1af,
1580     0x1bf, 0x399, 0x3bf, 0x3b4, 0x3c9, 0x3e7, 0x0a8, 0x1b6,
1581     0x0ab, 0x0a4, 0x0aa, 0x0b2, 0x0c2, 0x0c5, 0x198, 0x1a4,
1582     0x1b8, 0x38c, 0x3a4, 0x3c4, 0x3c6, 0x3dd, 0x3e8, 0x0ad,
1583     0x3af, 0x192, 0x0bd, 0x0bc, 0x18e, 0x197, 0x19a, 0x1a3,
1584     0x1b1, 0x38d, 0x398, 0x3b7, 0x3d3, 0x3d1, 0x3db, 0x7dd,
1585     0x0b4, 0x3de, 0x1a9, 0x19b, 0x19c, 0x1a1, 0x1aa, 0x1ad,
1586     0x1b3, 0x38b, 0x3b2, 0x3b8, 0x3ce, 0x3e1, 0x3e0, 0x7d2,
1587     0x7e5, 0x0b7, 0x7e3, 0x1bb, 0x1a8, 0x1a6, 0x1b0, 0x1b2,
1588     0x1b7, 0x39b, 0x39a, 0x3ba, 0x3b5, 0x3d6, 0x7d7, 0x3e4,
1589     0x7d8, 0x7ea, 0x0ba, 0x7e8, 0x3a0, 0x1bd, 0x1b4, 0x38a,
1590     0x1c4, 0x392, 0x3aa, 0x3b0, 0x3bc, 0x3d7, 0x7d4, 0x7dc,
1591     0x7db, 0x7d5, 0x7f0, 0x0c1, 0x7fb, 0x3c8, 0x3a3, 0x395,
1592     0x39d, 0x3ac, 0x3ae, 0x3c5, 0x3d8, 0x3e2, 0x3e6, 0x7e4,
1593     0x7e7, 0x7e0, 0x7e9, 0x7f7, 0x190, 0x7f2, 0x393, 0x1be,
1594     0x1c0, 0x394, 0x397, 0x3ad, 0x3c3, 0x3c1, 0x3d2, 0x7da,
1595     0x7d9, 0x7df, 0x7eb, 0x7f4, 0x7fa, 0x195, 0x7f8, 0x3bd,
1596     0x39c, 0x3ab, 0x3a8, 0x3b3, 0x3b9, 0x3d0, 0x3e3, 0x3e5,
1597     0x7e2, 0x7de, 0x7ed, 0x7f1, 0x7f9, 0x7fc, 0x193, 0xffd,
1598     0x3dc, 0x3b6, 0x3c7, 0x3cc, 0x3cb, 0x3d9, 0x3da, 0x7d3,
1599     0x7e1, 0x7ee, 0x7ef, 0x7f5, 0x7f6, 0xffc, 0xfff, 0x19d,
1600     0x1c2, 0x0b5, 0x0a1, 0x096, 0x097, 0x095, 0x099, 0x0a0,
1601     0x0a2, 0x0ac, 0x0a9, 0x0b1, 0x0b3, 0x0bb, 0x0c0, 0x18f,
1602     0x004
1603 ];
1604
1605 const AAC_SPEC_BITS: [&[u8]; 11] = [
1606     AAC_SPEC_CB1_BITS, AAC_SPEC_CB2_BITS, AAC_SPEC_CB3_BITS, AAC_SPEC_CB4_BITS,
1607     AAC_SPEC_CB5_BITS, AAC_SPEC_CB6_BITS, AAC_SPEC_CB7_BITS, AAC_SPEC_CB8_BITS,
1608     AAC_SPEC_CB9_BITS, AAC_SPEC_CB10_BITS, AAC_SPEC_CB11_BITS
1609 ];
1610 const AAC_SPEC_CODES: [&[u16]; 11] = [
1611     AAC_SPEC_CB1_CODES, AAC_SPEC_CB2_CODES, AAC_SPEC_CB3_CODES, AAC_SPEC_CB4_CODES,
1612     AAC_SPEC_CB5_CODES, AAC_SPEC_CB6_CODES, AAC_SPEC_CB7_CODES, AAC_SPEC_CB8_CODES,
1613     AAC_SPEC_CB9_CODES, AAC_SPEC_CB10_CODES, AAC_SPEC_CB11_CODES
1614 ];
1615 const AAC_UNSIGNED_CODEBOOK: [bool; 11] = [
1616     false, false, true, true, false, false, true, true, true, true, true
1617 ];
1618 const AAC_CODEBOOK_MODULO: [u16; 7] = [
1619     9, 9, 8, 8, 13, 13, 17
1620 ];
1621
1622 const AAC_QUADS: [[i8; 4]; 81] = [
1623     [ 0, 0, 0, 0 ], [ 0, 0, 0, 1 ], [ 0, 0, 0, 2 ],
1624     [ 0, 0, 1, 0 ], [ 0, 0, 1, 1 ], [ 0, 0, 1, 2 ],
1625     [ 0, 0, 2, 0 ], [ 0, 0, 2, 1 ], [ 0, 0, 2, 2 ],
1626     [ 0, 1, 0, 0 ], [ 0, 1, 0, 1 ], [ 0, 1, 0, 2 ],
1627     [ 0, 1, 1, 0 ], [ 0, 1, 1, 1 ], [ 0, 1, 1, 2 ],
1628     [ 0, 1, 2, 0 ], [ 0, 1, 2, 1 ], [ 0, 1, 2, 2 ],
1629     [ 0, 2, 0, 0 ], [ 0, 2, 0, 1 ], [ 0, 2, 0, 2 ],
1630     [ 0, 2, 1, 0 ], [ 0, 2, 1, 1 ], [ 0, 2, 1, 2 ],
1631     [ 0, 2, 2, 0 ], [ 0, 2, 2, 1 ], [ 0, 2, 2, 2 ],
1632     [ 1, 0, 0, 0 ], [ 1, 0, 0, 1 ], [ 1, 0, 0, 2 ],
1633     [ 1, 0, 1, 0 ], [ 1, 0, 1, 1 ], [ 1, 0, 1, 2 ],
1634     [ 1, 0, 2, 0 ], [ 1, 0, 2, 1 ], [ 1, 0, 2, 2 ],
1635     [ 1, 1, 0, 0 ], [ 1, 1, 0, 1 ], [ 1, 1, 0, 2 ],
1636     [ 1, 1, 1, 0 ], [ 1, 1, 1, 1 ], [ 1, 1, 1, 2 ],
1637     [ 1, 1, 2, 0 ], [ 1, 1, 2, 1 ], [ 1, 1, 2, 2 ],
1638     [ 1, 2, 0, 0 ], [ 1, 2, 0, 1 ], [ 1, 2, 0, 2 ],
1639     [ 1, 2, 1, 0 ], [ 1, 2, 1, 1 ], [ 1, 2, 1, 2 ],
1640     [ 1, 2, 2, 0 ], [ 1, 2, 2, 1 ], [ 1, 2, 2, 2 ],
1641     [ 2, 0, 0, 0 ], [ 2, 0, 0, 1 ], [ 2, 0, 0, 2 ],
1642     [ 2, 0, 1, 0 ], [ 2, 0, 1, 1 ], [ 2, 0, 1, 2 ],
1643     [ 2, 0, 2, 0 ], [ 2, 0, 2, 1 ], [ 2, 0, 2, 2 ],
1644     [ 2, 1, 0, 0 ], [ 2, 1, 0, 1 ], [ 2, 1, 0, 2 ],
1645     [ 2, 1, 1, 0 ], [ 2, 1, 1, 1 ], [ 2, 1, 1, 2 ],
1646     [ 2, 1, 2, 0 ], [ 2, 1, 2, 1 ], [ 2, 1, 2, 2 ],
1647     [ 2, 2, 0, 0 ], [ 2, 2, 0, 1 ], [ 2, 2, 0, 2 ],
1648     [ 2, 2, 1, 0 ], [ 2, 2, 1, 1 ], [ 2, 2, 1, 2 ],
1649     [ 2, 2, 2, 0 ], [ 2, 2, 2, 1 ], [ 2, 2, 2, 2 ],
1650 ];
1651
1652 const DEFAULT_CHANNEL_MAP: [&str; 9] = [
1653     "",
1654     "C",
1655     "L,R",
1656     "C,L,R",
1657     "C,L,R,Cs",
1658     "C,L,R,Ls,Rs",
1659     "C,L,R,Ls,Rs,LFE",
1660     "",
1661     "C,L,R,Ls,Rs,Lss,Rss,LFE",
1662 ];
1663
1664 const SWB_OFFSET_48K_LONG: [usize; 49+1] = [
1665       0,   4,   8,  12,  16,  20,  24,  28,
1666      32,  36,  40,  48,  56,  64,  72,  80,
1667      88,  96, 108, 120, 132, 144, 160, 176,
1668     196, 216, 240, 264, 292, 320, 352, 384,
1669     416, 448, 480, 512, 544, 576, 608, 640,
1670     672, 704, 736, 768, 800, 832, 864, 896,
1671     928, 1024
1672 ];
1673 const SWB_OFFSET_48K_SHORT: [usize; 14+1] = [
1674     0, 4, 8, 12, 16, 20, 28, 36, 44, 56, 68, 80, 96, 112, 128
1675 ];
1676 const SWB_OFFSET_32K_LONG: [usize; 51+1] = [
1677       0,   4,   8,  12,  16,  20,  24,  28,
1678      32,  36,  40,  48,  56,  64,  72,  80,
1679      88,  96, 108, 120, 132, 144, 160, 176,
1680     196, 216, 240, 264, 292, 320, 352, 384,
1681     416, 448, 480, 512, 544, 576, 608, 640,
1682     672, 704, 736, 768, 800, 832, 864, 896,
1683     928, 960, 992, 1024
1684 ];
1685 const SWB_OFFSET_8K_LONG: [usize; 40+1] = [
1686       0,  12,  24,  36,  48,  60,  72,  84,
1687      96, 108, 120, 132, 144, 156, 172, 188,
1688     204, 220, 236, 252, 268, 288, 308, 328,
1689     348, 372, 396, 420, 448, 476, 508, 544,
1690     580, 620, 664, 712, 764, 820, 880, 944,
1691     1024
1692 ];
1693 const SWB_OFFSET_8K_SHORT: [usize; 15+1] = [
1694     0, 4, 8, 12, 16, 20, 24, 28, 36, 44, 52, 60, 72, 88, 108, 128
1695 ];
1696 const SWB_OFFSET_16K_LONG: [usize; 43+1] = [
1697       0,   8,  16,  24,  32,  40,  48,  56,
1698      64,  72,  80,  88, 100, 112, 124, 136,
1699     148, 160, 172, 184, 196, 212, 228, 244,
1700     260, 280, 300, 320, 344, 368, 396, 424,
1701     456, 492, 532, 572, 616, 664, 716, 772,
1702     832, 896, 960, 1024
1703 ];
1704 const SWB_OFFSET_16K_SHORT: [usize; 15+1] = [
1705     0, 4, 8, 12, 16, 20, 24, 28, 32, 40, 48, 60, 72, 88, 108, 128
1706 ];
1707 const SWB_OFFSET_24K_LONG: [usize; 47+1] = [
1708       0,   4,   8,  12,  16,  20,  24,  28,
1709      32,  36,  40,  44,  52,  60,  68,  76,
1710      84,  92, 100, 108, 116, 124, 136, 148,
1711     160, 172, 188, 204, 220, 240, 260, 284,
1712     308, 336, 364, 396, 432, 468, 508, 552,
1713     600, 652, 704, 768, 832, 896, 960, 1024
1714 ];
1715 const SWB_OFFSET_24K_SHORT: [usize; 15+1] = [
1716     0, 4, 8, 12, 16, 20, 24, 28, 36, 44, 52, 64, 76, 92, 108, 128
1717 ];
1718 const SWB_OFFSET_64K_LONG: [usize; 47+1] = [
1719       0,   4,   8,  12,  16,  20,  24,  28,
1720      32,  36,  40,  44,  48,  52,  56,  64,
1721      72,  80,  88, 100, 112, 124, 140, 156,
1722     172, 192, 216, 240, 268, 304, 344, 384,
1723     424, 464, 504, 544, 584, 624, 664, 704,
1724     744, 784, 824, 864, 904, 944, 984, 1024
1725 ];
1726 const SWB_OFFSET_64K_SHORT: [usize; 12+1] = [
1727     0, 4, 8, 12, 16, 20, 24, 32, 40, 48, 64, 92, 128
1728 ];
1729 const SWB_OFFSET_96K_LONG: [usize; 41+1] = [
1730       0,   4,   8,  12,  16,  20,  24,  28,
1731      32,  36,  40,  44,  48,  52,  56,  64,
1732      72,  80,  88,  96, 108, 120, 132, 144,
1733     156, 172, 188, 212, 240, 276, 320, 384,
1734     448, 512, 576, 640, 704, 768, 832, 896,
1735     960, 1024
1736 ];
1737
1738 #[derive(Clone,Copy)]
1739 struct GASubbandInfo {
1740     min_srate:     u32,
1741     long_bands:    &'static [usize],
1742     short_bands:   &'static [usize],
1743 }
1744
1745 impl GASubbandInfo {
1746     fn find(srate: u32) -> GASubbandInfo {
1747         for i in 0..AAC_SUBBAND_INFO.len() {
1748             if srate >= AAC_SUBBAND_INFO[i].min_srate {
1749                 return AAC_SUBBAND_INFO[i];
1750             }
1751         }
1752         unreachable!("")
1753     }
1754     fn find_idx(srate: u32) -> usize {
1755         for i in 0..AAC_SUBBAND_INFO.len() {
1756             if srate >= AAC_SUBBAND_INFO[i].min_srate {
1757                 return i;
1758             }
1759         }
1760         unreachable!("")
1761     }
1762 }
1763
1764 const AAC_SUBBAND_INFO: [GASubbandInfo; 12] = [
1765     GASubbandInfo { min_srate: 92017, long_bands: &SWB_OFFSET_96K_LONG, short_bands: &SWB_OFFSET_64K_SHORT }, //96K
1766     GASubbandInfo { min_srate: 75132, long_bands: &SWB_OFFSET_96K_LONG, short_bands: &SWB_OFFSET_64K_SHORT }, //88.2K
1767     GASubbandInfo { min_srate: 55426, long_bands: &SWB_OFFSET_64K_LONG, short_bands: &SWB_OFFSET_64K_SHORT }, //64K
1768     GASubbandInfo { min_srate: 46009, long_bands: &SWB_OFFSET_48K_LONG, short_bands: &SWB_OFFSET_48K_SHORT }, //48K
1769     GASubbandInfo { min_srate: 37566, long_bands: &SWB_OFFSET_48K_LONG, short_bands: &SWB_OFFSET_48K_SHORT }, //44.1K
1770     GASubbandInfo { min_srate: 27713, long_bands: &SWB_OFFSET_32K_LONG, short_bands: &SWB_OFFSET_48K_SHORT }, //32K
1771     GASubbandInfo { min_srate: 23004, long_bands: &SWB_OFFSET_24K_LONG, short_bands: &SWB_OFFSET_24K_SHORT }, //24K
1772     GASubbandInfo { min_srate: 18783, long_bands: &SWB_OFFSET_24K_LONG, short_bands: &SWB_OFFSET_24K_SHORT }, //22.05K
1773     GASubbandInfo { min_srate: 13856, long_bands: &SWB_OFFSET_16K_LONG, short_bands: &SWB_OFFSET_16K_SHORT }, //16K
1774     GASubbandInfo { min_srate: 11502, long_bands: &SWB_OFFSET_16K_LONG, short_bands: &SWB_OFFSET_16K_SHORT }, //12K
1775     GASubbandInfo { min_srate:  9391, long_bands: &SWB_OFFSET_16K_LONG, short_bands: &SWB_OFFSET_16K_SHORT }, //11.025K
1776     GASubbandInfo { min_srate:     0, long_bands: &SWB_OFFSET_8K_LONG,  short_bands: &SWB_OFFSET_8K_SHORT  }, //8K
1777 ];