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::*;
10 use nihav_core::io::intcode::*;
13 use std::str::FromStr;
16 #[allow(non_camel_case_types)]
17 #[derive(Clone,Copy,PartialEq)]
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,
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)",
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])
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
95 const AAC_CHANNELS: [usize; 8] = [ 0, 1, 2, 3, 4, 5, 6, 8 ];
102 sbr_ps_info: Option<(u32, usize)>,
110 otype: M4AType::None,
114 sbr_ps_info: Option::None,
119 fn read_object_type(br: &mut BitReader) -> DecoderResult<M4AType> {
121 if br.peek(5) == 31 {
123 otypeidx = (br.read(6)? as usize) + 32;
125 otypeidx = br.read(5)? as usize;
127 if otypeidx >= M4A_TYPES.len() {
130 Ok(M4A_TYPES[otypeidx])
133 fn read_sampling_frequency(br: &mut BitReader) -> DecoderResult<u32> {
134 if br.peek(4) == 15 {
135 let srate = br.read(24)?;
138 let srate_idx = br.read(4)? as usize;
139 Ok(AAC_SAMPLE_RATES[srate_idx])
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])
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)?;
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)?;
161 if self.otype == M4AType::ER_BSAC {
162 ext_chans = Self::read_channel_config(&mut br)?;
166 self.sbr_ps_info = Some((ext_srate, ext_chans));
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 => {
174 let short_frame = br.read_bool()?;
175 self.samples = if short_frame { 960 } else { 1024 };
176 let depends_on_core = br.read_bool()?;
178 let _delay = br.read(14)?;
180 let extension_flag = br.read_bool()?;
181 if self.channels == 0 {
182 unimplemented!("program config element");
184 if (self.otype == M4AType::Scalable) || (self.otype == M4AType::ER_AAC_Scalable) {
185 let _layer = br.read(3)?;
188 if self.otype == M4AType::ER_BSAC {
189 let _num_subframes = br.read(5)? as usize;
190 let _layer_length = br.read(11)?;
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()?;
200 let extension_flag3 = br.read_bool()?;
202 unimplemented!("version3 extensions");
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");
218 M4AType::Layer1 | M4AType::Layer2 | M4AType::Layer3 => { unimplemented!("MPEG Layer 1/2/3 config"); },
219 M4AType::DST => { unimplemented!("DST config"); },
221 br.skip(5)?; // fillBits
222 unimplemented!("ALS config");
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"); },
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");
238 let direct_mapping = br.read_bool()?;
239 validate!(direct_mapping);
244 if self.sbr_ps_info.is_some() && (br.left() >= 16) {
245 let sync = br.read(11)?;
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)?;
253 let sync = br.read(11)?;
255 self.ps_present = br.read_bool()?;
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)?;
265 let _ext_channels = br.read(4)?;
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)
281 const MAX_WINDOWS: usize = 8;
282 const MAX_SFBS: usize = 64;
284 #[derive(Clone,Copy)]
287 prev_window_sequence: u8,
289 prev_window_shape: bool,
290 scale_factor_grouping: [bool; MAX_WINDOWS],
291 group_start: [usize; MAX_WINDOWS],
292 window_groups: usize,
295 predictor_data: Option<LTPData>,
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;
308 prev_window_sequence: 0,
310 prev_window_shape: false,
311 scale_factor_grouping: [false; MAX_WINDOWS],
312 group_start: [0; MAX_WINDOWS],
316 predictor_data: None,
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));
331 LONG_START_SEQUENCE | EIGHT_SHORT_SEQUENCE => {
332 validate!((self.window_sequence == EIGHT_SHORT_SEQUENCE) ||
333 (self.window_sequence == LONG_STOP_SEQUENCE));
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;
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)?;
358 fn get_group_start(&self, g: usize) -> usize {
361 } else if g >= self.window_groups {
362 if self.long_win { 1 } else { 8 }
369 #[derive(Clone,Copy)]
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");
380 let predictor_reset = br.read_bool()?;
382 let predictor_reset_group_number = br.read(5)?;
384 for sfb in 0..max_sfb.min(PRED_SFB_MAX) {
385 prediction_used[sfb] = br.read_bool()?;
388 let ltp_data_present = br.read_bool()?;
389 if ltp_data_present {
393 let ltp_data_present = br.read_bool()?;
394 if ltp_data_present {
404 #[derive(Clone,Copy)]
408 pulse_start_sfb: usize,
409 pulse_offset: [u8; 4],
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); }
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;
426 Ok(Some(Self{ number_pulse, pulse_start_sfb, pulse_offset, pulse_amp }))
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 ];
434 #[derive(Clone,Copy)]
440 coef: [f32; TNS_MAX_ORDER + 1],
446 length: 0, order: 0, direction: false, compress: false, coef: [0.0; TNS_MAX_ORDER + 1],
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);
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);
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();
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) {
475 b[i] = self.coef[i - 1] + tmp[m - 1] * self.coef[m - i - 1];
478 self.coef[i - 1] = b[i];
480 self.coef[m - 1] = tmp[m - 1];
487 #[derive(Clone,Copy)]
490 n_filt: [usize; MAX_WINDOWS],
491 coef_res: [bool; MAX_WINDOWS],
492 coeffs: [[TNSCoeffs; 4]; MAX_WINDOWS],
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;
505 coef_res[w] = br.read_bool()?;
507 for filt in 0..n_filt[w] {
508 coeffs[w][filt].read(br, long_win, coef_res[w], max_order)?;
511 Ok(Some(Self { n_filt, coef_res, coeffs }))
515 #[derive(Clone,Copy)]
517 struct GainControlData {
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
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;
544 scale_cb: Codebook<i8>,
545 spec_cb: [Codebook<u16>; 11],
548 fn scale_map(idx: usize) -> i8 { (idx as i8) - 60 }
549 fn cb_map(idx: usize) -> u16 { idx as u16 }
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];
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());
563 Self { scale_cb, spec_cb }
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,
584 const INTENSITY_SCALE_MIN: i16 = -155;
585 const NOISE_SCALE_MIN: i16 = -100;
587 fn new(sbinfo: GASubbandInfo) -> Self {
590 info: ICSInfo::new(),
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],
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;
608 for g in 0..self.info.window_groups {
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);
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; }
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];
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)
637 fn get_intensity_dir(&self, g: usize, sfb: usize) -> bool {
638 self.sfb_cb[g][sfb] == INTENSITY_HCB
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;
654 if self.sfb_cb[g][sfb] == NOISE_HCB {
656 noise_pcm_flag = false;
657 scf_noise = (br.read(9)? as i16) - 256 + (self.global_gain as i16) - 90;
659 scf_noise += br.read_cb(&codebooks.scale_cb)? as i16;
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;
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;
674 fn get_band_start(&self, swb: usize) -> usize {
675 if self.info.long_win {
676 self.sbinfo.long_bands[swb]
678 self.sbinfo.short_bands[swb]
681 fn get_num_bands(&self) -> usize {
682 if self.info.long_win {
683 self.sbinfo.long_bands.len() - 1
685 self.sbinfo.short_bands.len() - 1
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];
700 ZERO_HCB => { /* zeroes */ },
701 NOISE_HCB => { /* noise */ },
702 INTENSITY_HCB | INTENSITY_HCB2 => { /* intensity */ },
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)?;
710 decode_pairs(br, cb, unsigned, cb_idx == ESC_HCB,
711 AAC_CODEBOOK_MODULO[(cb_idx - FIRST_PAIR_HCB) as usize], scale, dst)?;
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];
732 base = requant(self.coeffs[k], scale);
735 base += pdata.pulse_amp[pno] as f32;
737 base -= pdata.pulse_amp[pno] as f32;
739 self.coeffs[k] = iquant(base) * scale;
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;
746 self.info.decode_ics_info(br)?;
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);
753 if !self.info.long_win {
755 } else if m4atype == M4AType::LC {
758 tns_max_order = TNS_MAX_ORDER;
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)?;
764 let gain_control_data_present = br.read_bool()?;
765 validate!(!gain_control_data_present);
767 self.decode_spectrum(br, codebooks)?;
770 fn synth_channel(&mut self, dsp: &mut DSP, dst: &mut [f32], srate_idx: usize) {
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]
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] {
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];
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];
804 dsp.synth(&self.coeffs, &mut self.delay, self.info.window_sequence, self.info.window_shape, self.info.prev_window_shape, dst);
808 fn get_scale(scale: u8) -> f32 {
809 2.0f32.powf(0.25 * ((scale as f32) - 100.0 - 56.0))
811 fn iquant(val: f32) -> f32 {
813 -((-val).powf(4.0 / 3.0))
818 fn requant(val: f32, scale: f32) -> f32 {
819 if scale == 0.0 { return 0.0; }
820 let bval = val / scale;
824 -((-val).powf(3.0 / 4.0))
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;
832 let val = AAC_QUADS[cw][i];
835 out[i] = iquant(-val as f32) * scale;
837 out[i] = iquant( val as f32) * scale;
843 out[i] = iquant((AAC_QUADS[cw][i] - 1) as f32) * scale;
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;
855 if x != 0 && br.read_bool()? {
858 if y != 0 && br.read_bool()? {
862 x -= (modulo >> 1) as i16;
863 y -= (modulo >> 1) as i16;
866 if (x == 16) || (x == -16) {
867 x += read_escape(br, x > 0)?;
869 if (y == 16) || (y == -16) {
870 y += read_escape(br, y > 0)?;
873 out[0] = iquant(x as f32) * scale;
874 out[1] = iquant(y as f32) * scale;
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;
895 ms_used: [[bool; MAX_SFBS]; MAX_WINDOWS],
900 fn new(pair: bool, channel: usize, sbinfo: GASubbandInfo) -> Self {
903 common_window: false,
905 ms_used: [[false; MAX_SFBS]; MAX_WINDOWS],
906 ics: [ICS::new(sbinfo), ICS::new(sbinfo)],
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)?;
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;
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()?;
927 self.ics[1].info = self.ics[0].info;
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 {
933 for w in 0..self.ics[0].info.num_windows {
934 if w > 0 && self.ics[0].info.scale_factor_grouping[w - 1] {
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)));
945 for i in start..end {
946 self.ics[1].coeffs[i] = scale * self.ics[0].coeffs[i];
949 for i in start..end {
950 self.ics[1].coeffs[i] = -scale * self.ics[0].coeffs[i];
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;
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);
972 self.ics[1].synth_channel(dsp, &mut output[off1..], srate_idx);
978 kbd_long_win: [f32; 1024],
979 kbd_short_win: [f32; 128],
980 sine_long_win: [f32; 1024],
981 sine_short_win: [f32; 128],
988 const SHORT_WIN_POINT0: usize = 512 - 64;
989 const SHORT_WIN_POINT1: usize = 512 + 64;
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);
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],
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);
1017 for (ain, aout) in coeffs.chunks(128).zip(self.tmp.chunks_mut(256)) {
1018 self.imdct_short.imdct(ain, aout);
1020 self.ew_buf = [0.0; 1152];
1021 for (w, src) in self.tmp.chunks(256).enumerate() {
1024 self.ew_buf[w * 128 + i] += src[i] * short_win[i];
1026 } else { // to be left-windowed
1028 self.ew_buf[i] = src[i];
1032 self.ew_buf[w * 128 + i + 128] += src[i + 128] * short_win[127 - i];
1036 if seq == ONLY_LONG_SEQUENCE { // should be the most common case
1038 dst[i] = delay[i] + self.tmp[i] * left_long_win[i];
1039 delay[i] = self.tmp[i + 1024] * long_win[1023 - i];
1045 ONLY_LONG_SEQUENCE | LONG_START_SEQUENCE => {
1047 dst[i] = self.tmp[i] * left_long_win[i] + delay[i];
1050 EIGHT_SHORT_SEQUENCE => {
1051 for i in 0..SHORT_WIN_POINT0 {
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];
1058 for i in SHORT_WIN_POINT1..1024 {
1059 let j = i - SHORT_WIN_POINT0;
1060 dst[i] = self.ew_buf[j];
1063 LONG_STOP_SEQUENCE => {
1064 for i in 0..SHORT_WIN_POINT0 {
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];
1070 for i in SHORT_WIN_POINT1..1024 {
1071 dst[i] = self.tmp[i];
1074 _ => unreachable!(""),
1078 ONLY_LONG_SEQUENCE | LONG_STOP_SEQUENCE => {
1080 delay[i] = self.tmp[i + 1024] * long_win[1023 - i];
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];
1087 for i in SHORT_WIN_POINT1..1024 {
1091 LONG_START_SEQUENCE => {
1092 for i in 0..SHORT_WIN_POINT0 {
1093 delay[i] = self.tmp[i + 1024];
1095 for i in SHORT_WIN_POINT0..SHORT_WIN_POINT1 {
1096 delay[i] = self.tmp[i + 1024] * short_win[127 - (i - SHORT_WIN_POINT0)];
1098 for i in SHORT_WIN_POINT1..1024 {
1102 _ => unreachable!(""),
1108 info: NACodecInfoRef,
1109 chmap: NAChannelMap,
1111 pairs: Vec<ChannelPair>,
1112 codebooks: Codebooks,
1114 sbinfo: GASubbandInfo,
1120 info: NACodecInfo::new_dummy(),
1121 chmap: NAChannelMap::new(),
1122 m4ainfo: M4AInfo::new(),
1124 codebooks: Codebooks::new(),
1126 sbinfo: AAC_SUBBAND_INFO[0],
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));
1133 validate!(self.pairs[pair_no].channel == channel);
1134 validate!(self.pairs[pair_no].pair == pair);
1136 validate!(if pair { channel + 1 } else { channel } < self.m4ainfo.channels);
1139 fn decode_ga(&mut self, br: &mut BitReader, abuf: &mut NABufferType) -> DecoderResult<()> {
1140 let mut cur_pair = 0;
1142 while br.left() > 3 {
1143 let id = br.read(3)?;
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)?;
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)?;
1160 unimplemented!("coupling channel element");
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)?;
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
1178 unimplemented!("program config");
1181 let mut count = br.read(4)? as usize;
1183 count += br.read(8)? as usize;
1194 _ => { unreachable!(); },
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);
1205 impl NADecoder for AACDecoder {
1206 fn init(&mut self, _supp: &mut NADecoderSupport, info: NACodecInfoRef) -> DecoderResult<()> {
1207 if let NACodecTypeInfo::Audio(_) = info.get_properties() {
1208 let edata = info.get_extradata().unwrap();
1209 validate!(edata.len() >= 2);
1211 //print!("edata:"); for s in edata.iter() { print!(" {:02X}", *s);}println!("");
1212 self.m4ainfo.read(&edata)?;
1214 //println!("{}", self.m4ainfo);
1215 if (self.m4ainfo.otype != M4AType::LC) || (self.m4ainfo.channels > 2) || (self.m4ainfo.samples != 1024) {
1216 return Err(DecoderError::NotImplemented);
1218 self.sbinfo = GASubbandInfo::find(self.m4ainfo.srate);
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));
1224 if self.m4ainfo.channels >= DEFAULT_CHANNEL_MAP.len() {
1225 return Err(DecoderError::NotImplemented);
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();
1233 Err(DecoderError::InvalidData)
1236 fn decode(&mut self, _supp: &mut NADecoderSupport, 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();
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())?;
1244 let mut br = BitReader::new(&pktbuf, pktbuf.len(), BitReaderMode::BE);
1245 match self.m4ainfo.otype {
1247 self.decode_ga(&mut br, &mut abuf)?;
1249 _ => { unimplemented!(""); }
1252 let mut frm = NAFrame::new_from_pkt(pkt, self.info.replace_info(NACodecTypeInfo::Audio(ainfo)), abuf);
1253 frm.set_keyframe(true);
1258 pub fn get_decoder() -> Box<NADecoder> {
1259 Box::new(AACDecoder::new())
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;
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);
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);
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
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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
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
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
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
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
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,
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
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,
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,
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,
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
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
1615 const AAC_UNSIGNED_CODEBOOK: [bool; 11] = [
1616 false, false, true, true, false, false, true, true, true, true, true
1618 const AAC_CODEBOOK_MODULO: [u16; 7] = [
1619 9, 9, 8, 8, 13, 13, 17
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 ],
1652 const DEFAULT_CHANNEL_MAP: [&str; 9] = [
1661 "C,L,R,Ls,Rs,Lss,Rss,LFE",
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,
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
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,
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,
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
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,
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
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
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
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
1726 const SWB_OFFSET_64K_SHORT: [usize; 12+1] = [
1727 0, 4, 8, 12, 16, 20, 24, 32, 40, 48, 64, 92, 128
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,
1738 #[derive(Clone,Copy)]
1739 struct GASubbandInfo {
1741 long_bands: &'static [usize],
1742 short_bands: &'static [usize],
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];
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 {
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