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