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