2 use std::cell::RefCell;
3 use nihav_core::formats::*;
4 use nihav_core::frame::*;
5 use nihav_core::codecs::*;
6 use nihav_core::dsp::fft::FFTMode;
7 use nihav_core::dsp::mdct::IMDCT;
8 use nihav_core::dsp::window::*;
9 use nihav_core::io::bitreader::*;
10 use nihav_core::io::codebook::*;
12 use nihav_core::io::intcode::*;
15 use std::str::FromStr;
18 #[allow(non_camel_case_types)]
19 #[derive(Clone,Copy,PartialEq)]
63 const M4A_TYPES: &[M4AType] = &[
64 M4AType::None, M4AType::Main, M4AType::LC, M4AType::SSR,
65 M4AType::LTP, M4AType::SBR, M4AType::Scalable, M4AType::TwinVQ,
66 M4AType::CELP, M4AType::HVXC, M4AType::Reserved, M4AType::Reserved,
67 M4AType::TTSI, M4AType::MainSynth, M4AType::WavetableSynth, M4AType::GeneralMIDI,
68 M4AType::Algorithmic, M4AType::ER_AAC_LC, M4AType::Reserved, M4AType::ER_AAC_LTP,
69 M4AType::ER_AAC_Scalable, M4AType::ER_TwinVQ, M4AType::ER_BSAC, M4AType::ER_AAC_LD,
70 M4AType::ER_CELP, M4AType::ER_HVXC, M4AType::ER_HILN, M4AType::ER_Parametric,
71 M4AType::SSC, M4AType::PS, M4AType::MPEGSurround, M4AType::Reserved /*escape*/,
72 M4AType::Layer1, M4AType::Layer2, M4AType::Layer3, M4AType::DST,
73 M4AType::ALS, M4AType::SLS, M4AType::SLSNonCore, M4AType::ER_AAC_ELD,
74 M4AType::SMRSimple, M4AType::SMRMain,
76 const M4A_TYPE_NAMES: &[&str] = &[
77 "None", "AAC Main", "AAC LC", "AAC SSR", "AAC LTP", "SBR", "AAC Scalable", "TwinVQ", "CELP", "HVXC",
78 /*"(reserved10)", "(reserved11)", */ "TTSI",
79 "Main synthetic", "Wavetable synthesis", "General MIDI", "Algorithmic Synthesis and Audio FX",
80 "ER AAC LC", /*"(reserved18)",*/ "ER AAC LTP", "ER AAC Scalable", "ER TwinVQ", "ER BSAC", "ER AAC LD",
81 "ER CELP", "ER HVXC", "ER HILN", "ER Parametric", "SSC", "PS", "MPEG Surround", /*"(escape)",*/
82 "Layer-1", "Layer-2", "Layer-3", "DST", "ALS", "SLS", "SLS non-core", "ER AAC ELD", "SMR Simple", "SMR Main",
83 "(reserved)", "(unknown)",
86 impl fmt::Display for M4AType {
87 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
88 write!(f, "{}", M4A_TYPE_NAMES[*self as usize])
92 const AAC_SAMPLE_RATES: [u32; 16] = [
93 96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050,
94 16000, 12000, 11025, 8000, 7350, 0, 0, 0
97 const AAC_CHANNELS: [usize; 8] = [ 0, 1, 2, 3, 4, 5, 6, 8 ];
104 sbr_ps_info: Option<(u32, usize)>,
112 otype: M4AType::None,
116 sbr_ps_info: Option::None,
121 fn read_object_type(br: &mut BitReader) -> DecoderResult<M4AType> {
123 if br.peek(5) == 31 {
125 otypeidx = (br.read(6)? as usize) + 32;
127 otypeidx = br.read(5)? as usize;
129 if otypeidx >= M4A_TYPES.len() {
132 Ok(M4A_TYPES[otypeidx])
135 fn read_sampling_frequency(br: &mut BitReader) -> DecoderResult<u32> {
136 if br.peek(4) == 15 {
137 let srate = br.read(24)?;
140 let srate_idx = br.read(4)? as usize;
141 Ok(AAC_SAMPLE_RATES[srate_idx])
144 fn read_channel_config(br: &mut BitReader) -> DecoderResult<usize> {
145 let chidx = br.read(4)? as usize;
146 if chidx < AAC_CHANNELS.len() {
147 Ok(AAC_CHANNELS[chidx])
152 fn read(&mut self, src: &[u8]) -> DecoderResult<()> {
153 let mut br = BitReader::new(src, src.len(), BitReaderMode::BE);
154 self.otype = Self::read_object_type(&mut br)?;
155 self.srate = Self::read_sampling_frequency(&mut br)?;
156 validate!(self.srate > 0);
157 self.channels = Self::read_channel_config(&mut br)?;
159 if (self.otype == M4AType::SBR) || (self.otype == M4AType::PS) {
160 let ext_srate = Self::read_sampling_frequency(&mut br)?;
161 self.otype = Self::read_object_type(&mut br)?;
163 if self.otype == M4AType::ER_BSAC {
164 ext_chans = Self::read_channel_config(&mut br)?;
168 self.sbr_ps_info = Some((ext_srate, ext_chans));
172 M4AType::Main | M4AType::LC | M4AType::SSR | M4AType::Scalable | M4AType::TwinVQ |
173 M4AType::ER_AAC_LC | M4AType::ER_AAC_LTP | M4AType::ER_AAC_Scalable | M4AType::ER_TwinVQ |
174 M4AType::ER_BSAC | M4AType::ER_AAC_LD => {
176 let short_frame = br.read_bool()?;
177 self.samples = if short_frame { 960 } else { 1024 };
178 let depends_on_core = br.read_bool()?;
180 let _delay = br.read(14)?;
182 let extension_flag = br.read_bool()?;
183 if self.channels == 0 {
184 unimplemented!("program config element");
186 if (self.otype == M4AType::Scalable) || (self.otype == M4AType::ER_AAC_Scalable) {
187 let _layer = br.read(3)?;
190 if self.otype == M4AType::ER_BSAC {
191 let _num_subframes = br.read(5)? as usize;
192 let _layer_length = br.read(11)?;
194 if (self.otype == M4AType::ER_AAC_LC) ||
195 (self.otype == M4AType::ER_AAC_LTP) ||
196 (self.otype == M4AType::ER_AAC_Scalable) ||
197 (self.otype == M4AType::ER_AAC_LD) {
198 let _section_data_resilience = br.read_bool()?;
199 let _scalefactors_resilience = br.read_bool()?;
200 let _spectral_data_resilience = br.read_bool()?;
202 let extension_flag3 = br.read_bool()?;
204 unimplemented!("version3 extensions");
208 M4AType::CELP => { unimplemented!("CELP config"); },
209 M4AType::HVXC => { unimplemented!("HVXC config"); },
210 M4AType::TTSI => { unimplemented!("TTS config"); },
211 M4AType::MainSynth | M4AType::WavetableSynth | M4AType::GeneralMIDI | M4AType::Algorithmic => { unimplemented!("structured audio config"); },
212 M4AType::ER_CELP => { unimplemented!("ER CELP config"); },
213 M4AType::ER_HVXC => { unimplemented!("ER HVXC config"); },
214 M4AType::ER_HILN | M4AType::ER_Parametric => { unimplemented!("parametric config"); },
215 M4AType::SSC => { unimplemented!("SSC config"); },
216 M4AType::MPEGSurround => {
217 br.skip(1)?; // sacPayloadEmbedding
218 unimplemented!("MPEG Surround config");
220 M4AType::Layer1 | M4AType::Layer2 | M4AType::Layer3 => { unimplemented!("MPEG Layer 1/2/3 config"); },
221 M4AType::DST => { unimplemented!("DST config"); },
223 br.skip(5)?; // fillBits
224 unimplemented!("ALS config");
226 M4AType::SLS | M4AType::SLSNonCore => { unimplemented!("SLS config"); },
227 M4AType::ER_AAC_ELD => { unimplemented!("ELD config"); },
228 M4AType::SMRSimple | M4AType::SMRMain => { unimplemented!("symbolic music config"); },
232 M4AType::ER_AAC_LC | M4AType::ER_AAC_LTP | M4AType::ER_AAC_Scalable | M4AType::ER_TwinVQ |
233 M4AType::ER_BSAC | M4AType::ER_AAC_LD | M4AType::ER_CELP | M4AType::ER_HVXC |
234 M4AType::ER_HILN | M4AType::ER_Parametric | M4AType::ER_AAC_ELD => {
235 let ep_config = br.read(2)?;
236 if (ep_config == 2) || (ep_config == 3) {
237 unimplemented!("error protection config");
240 let direct_mapping = br.read_bool()?;
241 validate!(direct_mapping);
246 if self.sbr_ps_info.is_some() && (br.left() >= 16) {
247 let sync = br.read(11)?;
249 let ext_otype = Self::read_object_type(&mut br)?;
250 if ext_otype == M4AType::SBR {
251 self.sbr_present = br.read_bool()?;
252 if self.sbr_present {
253 let _ext_srate = Self::read_sampling_frequency(&mut br)?;
255 let sync = br.read(11)?;
257 self.ps_present = br.read_bool()?;
262 if ext_otype == M4AType::PS {
263 self.sbr_present = br.read_bool()?;
264 if self.sbr_present {
265 let _ext_srate = Self::read_sampling_frequency(&mut br)?;
267 let _ext_channels = br.read(4)?;
276 impl fmt::Display for M4AInfo {
277 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
278 write!(f, "MPEG 4 Audio {}, {} Hz, {} channels, {} samples per frame",
279 self.otype, self.srate, self.channels, self.samples)
283 const MAX_WINDOWS: usize = 8;
284 const MAX_SFBS: usize = 64;
286 #[derive(Clone,Copy)]
289 prev_window_sequence: u8,
291 prev_window_shape: bool,
292 scale_factor_grouping: [bool; MAX_WINDOWS],
293 group_start: [usize; MAX_WINDOWS],
294 window_groups: usize,
297 predictor_data: Option<LTPData>,
301 const ONLY_LONG_SEQUENCE: u8 = 0;
302 const LONG_START_SEQUENCE: u8 = 1;
303 const EIGHT_SHORT_SEQUENCE: u8 = 2;
304 const LONG_STOP_SEQUENCE: u8 = 3;
310 prev_window_sequence: 0,
312 prev_window_shape: false,
313 scale_factor_grouping: [false; MAX_WINDOWS],
314 group_start: [0; MAX_WINDOWS],
318 predictor_data: None,
322 fn decode_ics_info(&mut self, br: &mut BitReader) -> DecoderResult<()> {
323 self.prev_window_sequence = self.window_sequence;
324 self.prev_window_shape = self.window_shape;
325 let ics_reserved_bit = br.read(1)?;
326 validate!(ics_reserved_bit == 0);
327 self.window_sequence = br.read(2)? as u8;
328 match self.prev_window_sequence {
329 ONLY_LONG_SEQUENCE | LONG_STOP_SEQUENCE => {
330 validate!((self.window_sequence == ONLY_LONG_SEQUENCE) ||
331 (self.window_sequence == LONG_START_SEQUENCE));
333 LONG_START_SEQUENCE | EIGHT_SHORT_SEQUENCE => {
334 validate!((self.window_sequence == EIGHT_SHORT_SEQUENCE) ||
335 (self.window_sequence == LONG_STOP_SEQUENCE));
339 self.window_shape = br.read_bool()?;
340 self.window_groups = 1;
341 if self.window_sequence == EIGHT_SHORT_SEQUENCE {
342 self.long_win = false;
343 self.num_windows = 8;
344 self.max_sfb = br.read(4)? as usize;
345 for i in 0..MAX_WINDOWS-1 {
346 self.scale_factor_grouping[i] = br.read_bool()?;
347 if !self.scale_factor_grouping[i] {
348 self.group_start[self.window_groups] = i + 1;
349 self.window_groups += 1;
353 self.long_win = true;
354 self.num_windows = 1;
355 self.max_sfb = br.read(6)? as usize;
356 self.predictor_data = LTPData::read(br)?;
360 fn get_group_start(&self, g: usize) -> usize {
363 } else if g >= self.window_groups {
364 if self.long_win { 1 } else { 8 }
371 #[derive(Clone,Copy)]
376 fn read(br: &mut BitReader) -> DecoderResult<Option<Self>> {
377 let predictor_data_present = br.read_bool()?;
378 if !predictor_data_present { return Ok(None); }
379 unimplemented!("predictor data");
382 let predictor_reset = br.read_bool()?;
384 let predictor_reset_group_number = br.read(5)?;
386 for sfb in 0..max_sfb.min(PRED_SFB_MAX) {
387 prediction_used[sfb] = br.read_bool()?;
390 let ltp_data_present = br.read_bool()?;
391 if ltp_data_present {
395 let ltp_data_present = br.read_bool()?;
396 if ltp_data_present {
406 #[derive(Clone,Copy)]
410 pulse_start_sfb: usize,
411 pulse_offset: [u8; 4],
416 fn read(br: &mut BitReader) -> DecoderResult<Option<Self>> {
417 let pulse_data_present = br.read_bool()?;
418 if !pulse_data_present { return Ok(None); }
420 let number_pulse = (br.read(2)? as usize) + 1;
421 let pulse_start_sfb = br.read(6)? as usize;
422 let mut pulse_offset: [u8; 4] = [0; 4];
423 let mut pulse_amp: [u8; 4] = [0; 4];
424 for i in 0..number_pulse {
425 pulse_offset[i] = br.read(5)? as u8;
426 pulse_amp[i] = br.read(4)? as u8;
428 Ok(Some(Self{ number_pulse, pulse_start_sfb, pulse_offset, pulse_amp }))
432 const TNS_MAX_ORDER: usize = 20;
433 const TNS_MAX_LONG_BANDS: [usize; 12] = [ 31, 31, 34, 40, 42, 51, 46, 46, 42, 42, 42, 39 ];
434 const TNS_MAX_SHORT_BANDS: [usize; 12] = [ 9, 9, 10, 14, 14, 14, 14, 14, 14, 14, 14, 14 ];
436 #[derive(Clone,Copy)]
442 coef: [f32; TNS_MAX_ORDER + 1],
448 length: 0, order: 0, direction: false, compress: false, coef: [0.0; TNS_MAX_ORDER + 1],
451 fn read(&mut self, br: &mut BitReader, long_win: bool, coef_res: bool, max_order: usize) -> DecoderResult<()> {
452 self.length = br.read(if long_win { 6 } else { 4 })? as usize;
453 self.order = br.read(if long_win { 5 } else { 3 })? as usize;
454 validate!(self.order <= max_order);
456 self.direction = br.read_bool()?;
457 self.compress = br.read_bool()?;
458 let mut coef_bits = 3;
459 if coef_res { coef_bits += 1; }
460 if self.compress { coef_bits -= 1; }
461 let sign_mask = 1 << (coef_bits - 1);
462 let neg_mask = !(sign_mask * 2 - 1);
464 let fac_base = if coef_res { 1 << 3 } else { 1 << 2 } as f32;
465 let iqfac = (fac_base - 0.5) / (consts::PI / 2.0);
466 let iqfac_m = (fac_base + 0.5) / (consts::PI / 2.0);
467 let mut tmp: [f32; TNS_MAX_ORDER] = [0.0; TNS_MAX_ORDER];
468 for i in 0..self.order {
469 let val = br.read(coef_bits)? as i8;
470 let c = if (val & sign_mask) != 0 { val | neg_mask } else { val } as f32;
471 tmp[i] = (if c >= 0.0 { c / iqfac } else { c / iqfac_m }).sin();
473 // convert to LPC coefficients
474 let mut b: [f32; TNS_MAX_ORDER + 1] = [0.0; TNS_MAX_ORDER + 1];
475 for m in 1..(self.order + 1) {
477 b[i] = self.coef[i - 1] + tmp[m - 1] * self.coef[m - i - 1];
480 self.coef[i - 1] = b[i];
482 self.coef[m - 1] = tmp[m - 1];
489 #[derive(Clone,Copy)]
492 n_filt: [usize; MAX_WINDOWS],
493 coef_res: [bool; MAX_WINDOWS],
494 coeffs: [[TNSCoeffs; 4]; MAX_WINDOWS],
498 fn read(br: &mut BitReader, long_win: bool, num_windows: usize, max_order: usize) -> DecoderResult<Option<Self>> {
499 let tns_data_present = br.read_bool()?;
500 if !tns_data_present { return Ok(None); }
501 let mut n_filt: [usize; MAX_WINDOWS] = [0; MAX_WINDOWS];
502 let mut coef_res: [bool; MAX_WINDOWS] = [false; MAX_WINDOWS];
503 let mut coeffs: [[TNSCoeffs; 4]; MAX_WINDOWS] = [[TNSCoeffs::new(); 4]; MAX_WINDOWS];
504 for w in 0..num_windows {
505 n_filt[w] = br.read(if long_win { 2 } else { 1 })? as usize;
507 coef_res[w] = br.read_bool()?;
509 for filt in 0..n_filt[w] {
510 coeffs[w][filt].read(br, long_win, coef_res[w], max_order)?;
513 Ok(Some(Self { n_filt, coef_res, coeffs }))
517 #[derive(Clone,Copy)]
519 struct GainControlData {
523 impl GainControlData {
524 fn read(br: &mut BitReader) -> DecoderResult<Option<Self>> {
525 let gain_control_data_present = br.read_bool()?;
526 if !gain_control_data_present { return Ok(None); }
527 unimplemented!("gain control data");
528 /* self.max_band = br.read(2)? as u8;
529 if window_sequence == ONLY_LONG_SEQUENCE {
530 for bd in 0..max_band
537 const ZERO_HCB: u8 = 0;
538 const FIRST_PAIR_HCB: u8 = 5;
539 const ESC_HCB: u8 = 11;
540 const RESERVED_HCB: u8 = 12;
541 const NOISE_HCB: u8 = 13;
542 const INTENSITY_HCB2: u8 = 14;
543 const INTENSITY_HCB: u8 = 15;
546 scale_cb: Codebook<i8>,
547 spec_cb: [Codebook<u16>; 11],
550 fn scale_map(idx: usize) -> i8 { (idx as i8) - 60 }
551 fn cb_map(idx: usize) -> u16 { idx as u16 }
555 let mut coderead = TableCodebookDescReader::new(AAC_SCF_CODEBOOK_CODES, AAC_SCF_CODEBOOK_BITS, scale_map);
556 let scale_cb = Codebook::new(&mut coderead, CodebookMode::MSB).unwrap();
557 let mut spec_cb: [Codebook<u16>; 11];
559 spec_cb = mem::uninitialized();
560 for i in 0..AAC_SPEC_CODES.len() {
561 let mut coderead = TableCodebookDescReader::new(AAC_SPEC_CODES[i], AAC_SPEC_BITS[i], cb_map);
562 ptr::write(&mut spec_cb[i], Codebook::new(&mut coderead, CodebookMode::MSB).unwrap());
565 Self { scale_cb, spec_cb }
573 pulse_data: Option<PulseData>,
574 tns_data: Option<TNSData>,
575 gain_control: Option<GainControlData>,
576 sect_cb: [[u8; MAX_SFBS]; MAX_WINDOWS],
577 sect_len: [[usize; MAX_SFBS]; MAX_WINDOWS],
578 sfb_cb: [[u8; MAX_SFBS]; MAX_WINDOWS],
579 num_sec: [usize; MAX_WINDOWS],
580 scales: [[u8; MAX_SFBS]; MAX_WINDOWS],
581 sbinfo: GASubbandInfo,
586 const INTENSITY_SCALE_MIN: i16 = -155;
587 const NOISE_SCALE_MIN: i16 = -100;
589 fn new(sbinfo: GASubbandInfo) -> Self {
592 info: ICSInfo::new(),
596 sect_cb: [[0; MAX_SFBS]; MAX_WINDOWS],
597 sect_len: [[0; MAX_SFBS]; MAX_WINDOWS],
598 sfb_cb: [[0; MAX_SFBS]; MAX_WINDOWS],
599 scales: [[0; MAX_SFBS]; MAX_WINDOWS],
600 num_sec: [0; MAX_WINDOWS],
606 fn decode_section_data(&mut self, br: &mut BitReader, may_have_intensity: bool) -> DecoderResult<()> {
607 let sect_bits = if self.info.long_win { 5 } else { 3 };
608 let sect_esc_val = (1 << sect_bits) - 1;
610 for g in 0..self.info.window_groups {
613 while k < self.info.max_sfb {
614 self.sect_cb[g][l] = br.read(4)? as u8;
615 self.sect_len[g][l] = 0;
616 validate!(self.sect_cb[g][l] != RESERVED_HCB);
617 if ((self.sect_cb[g][l] == INTENSITY_HCB) || (self.sect_cb[g][l] == INTENSITY_HCB2)) && !may_have_intensity {
618 return Err(DecoderError::InvalidData);
621 let sect_len_incr = br.read(sect_bits)? as usize;
622 self.sect_len[g][l] += sect_len_incr;
623 if sect_len_incr < sect_esc_val { break; }
625 validate!(k + self.sect_len[g][l] <= self.info.max_sfb);
626 for _ in 0..self.sect_len[g][l] {
627 self.sfb_cb[g][k] = self.sect_cb[g][l];
636 fn is_intensity(&self, g: usize, sfb: usize) -> bool {
637 (self.sfb_cb[g][sfb] == INTENSITY_HCB) || (self.sfb_cb[g][sfb] == INTENSITY_HCB2)
639 fn get_intensity_dir(&self, g: usize, sfb: usize) -> bool {
640 self.sfb_cb[g][sfb] == INTENSITY_HCB
642 fn decode_scale_factor_data(&mut self, br: &mut BitReader, codebooks: &Codebooks) -> DecoderResult<()> {
643 let mut noise_pcm_flag = true;
644 let mut scf_normal = self.global_gain as i16;
645 let mut scf_intensity = 0i16;
646 let mut scf_noise = 0i16;
647 for g in 0..self.info.window_groups {
648 for sfb in 0..self.info.max_sfb {
649 if self.sfb_cb[g][sfb] != ZERO_HCB {
650 if self.is_intensity(g, sfb) {
651 let diff = br.read_cb(&codebooks.scale_cb)? as i16;
652 scf_intensity += diff;
653 validate!((scf_intensity >= INTENSITY_SCALE_MIN) && (scf_intensity < INTENSITY_SCALE_MIN + 256));
654 self.scales[g][sfb] = (scf_intensity - INTENSITY_SCALE_MIN) as u8;
656 if self.sfb_cb[g][sfb] == NOISE_HCB {
658 noise_pcm_flag = false;
659 scf_noise = (br.read(9)? as i16) - 256 + (self.global_gain as i16) - 90;
661 scf_noise += br.read_cb(&codebooks.scale_cb)? as i16;
663 validate!((scf_noise >= NOISE_SCALE_MIN) && (scf_noise < NOISE_SCALE_MIN + 256));
664 self.scales[g][sfb] = (scf_noise - NOISE_SCALE_MIN) as u8;
666 scf_normal += br.read_cb(&codebooks.scale_cb)? as i16;
667 validate!((scf_normal >= 0) && (scf_normal < 255));
668 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 += pdata.pulse_amp[pno] as f32;
739 base -= pdata.pulse_amp[pno] as f32;
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 if !tns_data.coeffs[w][f].direction {
791 for m in start..end {
792 for i in 0..order.min(m) {
793 self.coeffs[m] -= self.coeffs[m - i - 1] * lpc[i];
797 for m in (start..end).rev() {
798 for i in 0..order.min(m) {
799 self.coeffs[m] -= self.coeffs[m + i - 1] * lpc[i];
806 dsp.synth(&self.coeffs, &mut self.delay, self.info.window_sequence, self.info.window_shape, self.info.prev_window_shape, dst);
810 fn get_scale(scale: u8) -> f32 {
811 2.0f32.powf(0.25 * ((scale as f32) - 100.0 - 56.0))
813 fn iquant(val: f32) -> f32 {
815 -((-val).powf(4.0 / 3.0))
820 fn requant(val: f32, scale: f32) -> f32 {
821 if scale == 0.0 { return 0.0; }
822 let bval = val / scale;
826 -((-val).powf(3.0 / 4.0))
829 fn decode_quads(br: &mut BitReader, cb: &Codebook<u16>, unsigned: bool, scale: f32, dst: &mut [f32]) -> DecoderResult<()> {
830 for out in dst.chunks_mut(4) {
831 let cw = br.read_cb(cb)? as usize;
834 let val = AAC_QUADS[cw][i];
837 out[i] = iquant(-val as f32) * scale;
839 out[i] = iquant( val as f32) * scale;
845 out[i] = iquant((AAC_QUADS[cw][i] - 1) as f32) * scale;
851 fn decode_pairs(br: &mut BitReader, cb: &Codebook<u16>, unsigned: bool, escape: bool, modulo: u16, scale: f32, dst: &mut [f32]) -> DecoderResult<()> {
852 for out in dst.chunks_mut(2) {
853 let cw = br.read_cb(cb)?;
854 let mut x = (cw / modulo) as i16;
855 let mut y = (cw % modulo) as i16;
857 if x != 0 && br.read_bool()? {
860 if y != 0 && br.read_bool()? {
864 x -= (modulo >> 1) as i16;
865 y -= (modulo >> 1) as i16;
868 if (x == 16) || (x == -16) {
869 x += read_escape(br, x > 0)?;
871 if (y == 16) || (y == -16) {
872 y += read_escape(br, y > 0)?;
875 out[0] = iquant(x as f32) * scale;
876 out[1] = iquant(y as f32) * scale;
880 fn read_escape(br: &mut BitReader, sign: bool) -> DecoderResult<i16> {
881 let prefix = br.read_code(UintCodeType::UnaryOnes)? as u8;
882 validate!(prefix < 9);
883 let bits = br.read(prefix + 4)? as i16;
897 ms_used: [[bool; MAX_SFBS]; MAX_WINDOWS],
902 fn new(pair: bool, channel: usize, sbinfo: GASubbandInfo) -> Self {
905 common_window: false,
907 ms_used: [[false; MAX_SFBS]; MAX_WINDOWS],
908 ics: [ICS::new(sbinfo), ICS::new(sbinfo)],
911 fn decode_ga_sce(&mut self, br: &mut BitReader, codebooks: &Codebooks, m4atype: M4AType) -> DecoderResult<()> {
912 self.ics[0].decode_ics(br, codebooks, m4atype, false, false)?;
915 fn decode_ga_cpe(&mut self, br: &mut BitReader, codebooks: &Codebooks, m4atype: M4AType) -> DecoderResult<()> {
916 let common_window = br.read_bool()?;
917 self.common_window = common_window;
919 self.ics[0].info.decode_ics_info(br)?;
920 self.ms_mask_present = br.read(2)? as u8;
921 validate!(self.ms_mask_present != 3);
922 if self.ms_mask_present == 1 {
923 for g in 0..self.ics[0].info.window_groups {
924 for sfb in 0..self.ics[0].info.max_sfb {
925 self.ms_used[g][sfb] = br.read_bool()?;
929 self.ics[1].info = self.ics[0].info;
931 self.ics[0].decode_ics(br, codebooks, m4atype, common_window, true)?;
932 self.ics[1].decode_ics(br, codebooks, m4atype, common_window, false)?;
933 if common_window && self.ms_mask_present != 0 {
935 for w in 0..self.ics[0].info.num_windows {
936 if w > 0 && self.ics[0].info.scale_factor_grouping[w - 1] {
939 for sfb in 0..self.ics[0].info.max_sfb {
940 let start = w * 128 + self.ics[0].get_band_start(sfb);
941 let end = w * 128 + self.ics[0].get_band_start(sfb + 1);
942 if self.ics[0].is_intensity(g, sfb) {
943 let invert = (self.ms_mask_present == 1) && self.ms_used[g][sfb];
944 let dir = self.ics[0].get_intensity_dir(g, sfb) ^ invert;
945 let scale = 0.5f32.powf(0.25 * ((self.ics[0].scales[g][sfb] as f32) + (INTENSITY_SCALE_MIN as f32)));
947 for i in start..end {
948 self.ics[1].coeffs[i] = scale * self.ics[0].coeffs[i];
951 for i in start..end {
952 self.ics[1].coeffs[i] = -scale * self.ics[0].coeffs[i];
955 } else if (self.ms_mask_present == 2) || self.ms_used[g][sfb] {
956 for i in start..end {
957 let tmp = self.ics[0].coeffs[i] - self.ics[1].coeffs[i];
958 self.ics[0].coeffs[i] += self.ics[1].coeffs[i];
959 self.ics[1].coeffs[i] = tmp;
967 fn synth_audio(&mut self, dsp: &mut DSP, abuf: &mut NABufferType, srate_idx: usize) {
968 let mut adata = abuf.get_abuf_f32().unwrap();
969 let mut output = adata.get_data_mut();
970 let off0 = abuf.get_offset(self.channel);
971 let off1 = abuf.get_offset(self.channel + 1);
972 self.ics[0].synth_channel(dsp, &mut output[off0..], srate_idx);
974 self.ics[1].synth_channel(dsp, &mut output[off1..], srate_idx);
980 kbd_long_win: [f32; 1024],
981 kbd_short_win: [f32; 128],
982 sine_long_win: [f32; 1024],
983 sine_short_win: [f32; 128],
990 const SHORT_WIN_POINT0: usize = 512 - 64;
991 const SHORT_WIN_POINT1: usize = 512 + 64;
995 let mut kbd_long_win: [f32; 1024] = [0.0; 1024];
996 let mut kbd_short_win: [f32; 128] = [0.0; 128];
997 generate_window(WindowType::KaiserBessel(4.0), 1.0, 1024, true, &mut kbd_long_win);
998 generate_window(WindowType::KaiserBessel(6.0), 1.0, 128, true, &mut kbd_short_win);
999 let mut sine_long_win: [f32; 1024] = [0.0; 1024];
1000 let mut sine_short_win: [f32; 128] = [0.0; 128];
1001 generate_window(WindowType::Sine, 1.0, 1024, true, &mut sine_long_win);
1002 generate_window(WindowType::Sine, 1.0, 128, true, &mut sine_short_win);
1004 kbd_long_win, kbd_short_win,
1005 sine_long_win, sine_short_win,
1006 imdct_long: IMDCT::new(FFTMode::SplitRadix, 1024 * 2, true),
1007 imdct_short: IMDCT::new(FFTMode::SplitRadix, 128 * 2, true),
1008 tmp: [0.0; 2048], ew_buf: [0.0; 1152],
1011 fn synth(&mut self, coeffs: &[f32; 1024], delay: &mut [f32; 1024], seq: u8, window_shape: bool, prev_window_shape: bool, dst: &mut [f32]) {
1012 let long_win = if window_shape { &self.kbd_long_win } else { &self.sine_long_win };
1013 let short_win = if window_shape { &self.kbd_short_win } else { &self.sine_short_win };
1014 let left_long_win = if prev_window_shape { &self.kbd_long_win } else { &self.sine_long_win };
1015 let left_short_win = if prev_window_shape { &self.kbd_short_win } else { &self.sine_short_win };
1016 if seq != EIGHT_SHORT_SEQUENCE {
1017 self.imdct_long.imdct(coeffs, &mut self.tmp);
1019 for (ain, aout) in coeffs.chunks(128).zip(self.tmp.chunks_mut(256)) {
1020 self.imdct_short.imdct(ain, aout);
1022 self.ew_buf = [0.0; 1152];
1023 for (w, src) in self.tmp.chunks(256).enumerate() {
1026 self.ew_buf[w * 128 + i] += src[i] * short_win[i];
1028 } else { // to be left-windowed
1030 self.ew_buf[i] = src[i];
1034 self.ew_buf[w * 128 + i + 128] += src[i + 128] * short_win[127 - i];
1038 if seq == ONLY_LONG_SEQUENCE { // should be the most common case
1040 dst[i] = delay[i] + self.tmp[i] * left_long_win[i];
1041 delay[i] = self.tmp[i + 1024] * long_win[1023 - i];
1047 ONLY_LONG_SEQUENCE | LONG_START_SEQUENCE => {
1049 dst[i] = self.tmp[i] * left_long_win[i] + delay[i];
1052 EIGHT_SHORT_SEQUENCE => {
1053 for i in 0..SHORT_WIN_POINT0 {
1056 for i in SHORT_WIN_POINT0..SHORT_WIN_POINT1 {
1057 let j = i - SHORT_WIN_POINT0;
1058 dst[i] = delay[i] + self.ew_buf[j] * left_short_win[j];
1060 for i in SHORT_WIN_POINT1..1024 {
1061 let j = i - SHORT_WIN_POINT0;
1062 dst[i] = self.ew_buf[j];
1065 LONG_STOP_SEQUENCE => {
1066 for i in 0..SHORT_WIN_POINT0 {
1069 for i in SHORT_WIN_POINT0..SHORT_WIN_POINT1 {
1070 dst[i] = delay[i] + self.tmp[i] * left_short_win[i - SHORT_WIN_POINT0];
1072 for i in SHORT_WIN_POINT1..1024 {
1073 dst[i] = self.tmp[i];
1076 _ => unreachable!(""),
1080 ONLY_LONG_SEQUENCE | LONG_STOP_SEQUENCE => {
1082 delay[i] = self.tmp[i + 1024] * long_win[1023 - i];
1085 EIGHT_SHORT_SEQUENCE => {
1086 for i in 0..SHORT_WIN_POINT1 { // last part is already windowed
1087 delay[i] = self.ew_buf[i + 512+64];
1089 for i in SHORT_WIN_POINT1..1024 {
1093 LONG_START_SEQUENCE => {
1094 for i in 0..SHORT_WIN_POINT0 {
1095 delay[i] = self.tmp[i + 1024];
1097 for i in SHORT_WIN_POINT0..SHORT_WIN_POINT1 {
1098 delay[i] = self.tmp[i + 1024] * short_win[127 - (i - SHORT_WIN_POINT0)];
1100 for i in SHORT_WIN_POINT1..1024 {
1104 _ => unreachable!(""),
1110 info: Rc<NACodecInfo>,
1111 chmap: NAChannelMap,
1113 pairs: Vec<ChannelPair>,
1114 codebooks: Codebooks,
1116 sbinfo: GASubbandInfo,
1122 info: NACodecInfo::new_dummy(),
1123 chmap: NAChannelMap::new(),
1124 m4ainfo: M4AInfo::new(),
1126 codebooks: Codebooks::new(),
1128 sbinfo: AAC_SUBBAND_INFO[0],
1131 fn set_pair(&mut self, pair_no: usize, channel: usize, pair: bool) -> DecoderResult<()> {
1132 if self.pairs.len() <= pair_no {
1133 self.pairs.push(ChannelPair::new(pair, channel, self.sbinfo));
1135 validate!(self.pairs[pair_no].channel == channel);
1136 validate!(self.pairs[pair_no].pair == pair);
1138 validate!(if pair { channel + 1 } else { channel } < self.m4ainfo.channels);
1141 fn decode_ga(&mut self, br: &mut BitReader, abuf: &mut NABufferType) -> DecoderResult<()> {
1142 let mut cur_pair = 0;
1144 while br.left() > 3 {
1145 let id = br.read(3)?;
1148 let _tag = br.read(4)?;
1149 self.set_pair(cur_pair, cur_ch, false)?;
1150 self.pairs[cur_pair].decode_ga_sce(br, &self.codebooks, self.m4ainfo.otype)?;
1155 let _tag = br.read(4)?;
1156 self.set_pair(cur_pair, cur_ch, true)?;
1157 self.pairs[cur_pair].decode_ga_cpe(br, &self.codebooks, self.m4ainfo.otype)?;
1162 unimplemented!("coupling channel element");
1165 let _tag = br.read(4)?;
1166 self.set_pair(cur_pair, cur_ch, false)?;
1167 self.pairs[cur_pair].decode_ga_sce(br, &self.codebooks, self.m4ainfo.otype)?;
1172 let _id = br.read(4)?;
1173 let align = br.read_bool()?;
1174 let mut count = br.read(8)? as u32;
1175 if count == 255 { count += br.read(8)? as u32; }
1176 if align { br.align(); }
1177 br.skip(count * 8)?; // no SBR payload or such
1180 unimplemented!("program config");
1183 let mut count = br.read(4)? as usize;
1185 count += br.read(8)? as usize;
1196 _ => { unreachable!(); },
1199 let srate_idx = GASubbandInfo::find_idx(self.m4ainfo.srate);
1200 for pair in 0..cur_pair {
1201 self.pairs[pair].synth_audio(&mut self.dsp, abuf, srate_idx);
1207 impl NADecoder for AACDecoder {
1208 fn init(&mut self, info: Rc<NACodecInfo>) -> DecoderResult<()> {
1209 if let NACodecTypeInfo::Audio(_) = info.get_properties() {
1210 let edata = info.get_extradata().unwrap();
1211 validate!(edata.len() >= 2);
1213 //print!("edata:"); for s in edata.iter() { print!(" {:02X}", *s);}println!("");
1214 self.m4ainfo.read(&edata)?;
1216 //println!("{}", self.m4ainfo);
1217 if (self.m4ainfo.otype != M4AType::LC) || (self.m4ainfo.channels > 2) || (self.m4ainfo.samples != 1024) {
1218 return Err(DecoderError::NotImplemented);
1220 self.sbinfo = GASubbandInfo::find(self.m4ainfo.srate);
1222 let ainfo = NAAudioInfo::new(self.m4ainfo.srate, self.m4ainfo.channels as u8,
1223 SND_F32P_FORMAT, self.m4ainfo.samples);
1224 self.info = info.replace_info(NACodecTypeInfo::Audio(ainfo));
1226 if self.m4ainfo.channels >= DEFAULT_CHANNEL_MAP.len() {
1227 return Err(DecoderError::NotImplemented);
1229 let chmap_str = DEFAULT_CHANNEL_MAP[self.m4ainfo.channels];
1230 if chmap_str.len() == 0 { return Err(DecoderError::NotImplemented); }
1231 self.chmap = NAChannelMap::from_str(chmap_str).unwrap();
1235 Err(DecoderError::InvalidData)
1238 fn decode(&mut self, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
1239 let info = pkt.get_stream().get_info();
1240 validate!(info.get_properties().is_audio());
1241 let pktbuf = pkt.get_buffer();
1243 let ainfo = self.info.get_properties().get_audio_info().unwrap();
1244 let mut abuf = alloc_audio_buffer(ainfo, self.m4ainfo.samples, self.chmap.clone())?;
1246 let mut br = BitReader::new(&pktbuf, pktbuf.len(), BitReaderMode::BE);
1247 match self.m4ainfo.otype {
1249 self.decode_ga(&mut br, &mut abuf)?;
1251 _ => { unimplemented!(""); }
1254 let mut frm = NAFrame::new_from_pkt(pkt, self.info.replace_info(NACodecTypeInfo::Audio(ainfo)), abuf);
1255 frm.set_keyframe(true);
1256 Ok(Rc::new(RefCell::new(frm)))
1260 pub fn get_decoder() -> Box<NADecoder> {
1261 Box::new(AACDecoder::new())
1266 use nihav_core::codecs::RegisteredDecoders;
1267 use nihav_core::demuxers::RegisteredDemuxers;
1268 use nihav_core::test::dec_video::test_decode_audio;
1269 use crate::codecs::generic_register_all_codecs;
1270 use nihav_realmedia::demuxers::realmedia_register_all_demuxers;
1273 let mut dmx_reg = RegisteredDemuxers::new();
1274 realmedia_register_all_demuxers(&mut dmx_reg);
1275 let mut dec_reg = RegisteredDecoders::new();
1276 generic_register_all_codecs(&mut dec_reg);
1278 // let file = "assets/RV/rv40_weighted_mc.rmvb";
1279 let file = "assets/RV/rv40_weighted_mc_2.rmvb";
1280 test_decode_audio("realmedia", file, Some(12000), "aac", &dmx_reg, &dec_reg);
1284 const AAC_SCF_CODEBOOK_BITS: &[u8] = &[
1285 18, 18, 18, 18, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
1286 19, 19, 19, 18, 19, 18, 17, 17, 16, 17, 16, 16, 16, 16, 15, 15,
1287 14, 14, 14, 14, 14, 14, 13, 13, 12, 12, 12, 11, 12, 11, 10, 10,
1288 10, 9, 9, 8, 8, 8, 7, 6, 6, 5, 4, 3, 1, 4, 4, 5,
1289 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 10, 11, 11, 11, 11, 12,
1290 12, 13, 13, 13, 14, 14, 16, 15, 16, 15, 18, 19, 19, 19, 19, 19,
1291 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
1292 19, 19, 19, 19, 19, 19, 19, 19, 19
1295 const AAC_SCF_CODEBOOK_CODES: &[u32] = &[
1296 0x3FFE8, 0x3FFE6, 0x3FFE7, 0x3FFE5, 0x7FFF5, 0x7FFF1, 0x7FFED, 0x7FFF6,
1297 0x7FFEE, 0x7FFEF, 0x7FFF0, 0x7FFFC, 0x7FFFD, 0x7FFFF, 0x7FFFE, 0x7FFF7,
1298 0x7FFF8, 0x7FFFB, 0x7FFF9, 0x3FFE4, 0x7FFFA, 0x3FFE3, 0x1FFEF, 0x1FFF0,
1299 0x0FFF5, 0x1FFEE, 0x0FFF2, 0x0FFF3, 0x0FFF4, 0x0FFF1, 0x07FF6, 0x07FF7,
1300 0x03FF9, 0x03FF5, 0x03FF7, 0x03FF3, 0x03FF6, 0x03FF2, 0x01FF7, 0x01FF5,
1301 0x00FF9, 0x00FF7, 0x00FF6, 0x007F9, 0x00FF4, 0x007F8, 0x003F9, 0x003F7,
1302 0x003F5, 0x001F8, 0x001F7, 0x000FA, 0x000F8, 0x000F6, 0x00079, 0x0003A,
1303 0x00038, 0x0001A, 0x0000B, 0x00004, 0x00000, 0x0000A, 0x0000C, 0x0001B,
1304 0x00039, 0x0003B, 0x00078, 0x0007A, 0x000F7, 0x000F9, 0x001F6, 0x001F9,
1305 0x003F4, 0x003F6, 0x003F8, 0x007F5, 0x007F4, 0x007F6, 0x007F7, 0x00FF5,
1306 0x00FF8, 0x01FF4, 0x01FF6, 0x01FF8, 0x03FF8, 0x03FF4, 0x0FFF0, 0x07FF4,
1307 0x0FFF6, 0x07FF5, 0x3FFE2, 0x7FFD9, 0x7FFDA, 0x7FFDB, 0x7FFDC, 0x7FFDD,
1308 0x7FFDE, 0x7FFD8, 0x7FFD2, 0x7FFD3, 0x7FFD4, 0x7FFD5, 0x7FFD6, 0x7FFF2,
1309 0x7FFDF, 0x7FFE7, 0x7FFE8, 0x7FFE9, 0x7FFEA, 0x7FFEB, 0x7FFE6, 0x7FFE0,
1310 0x7FFE1, 0x7FFE2, 0x7FFE3, 0x7FFE4, 0x7FFE5, 0x7FFD7, 0x7FFEC, 0x7FFF4,
1314 const AAC_SPEC_CB1_BITS: &[u8] = &[
1315 11, 9, 11, 10, 7, 10, 11, 9, 11, 10, 7, 10, 7, 5, 7, 9,
1316 7, 10, 11, 9, 11, 9, 7, 9, 11, 9, 11, 9, 7, 9, 7, 5,
1317 7, 9, 7, 9, 7, 5, 7, 5, 1, 5, 7, 5, 7, 9, 7, 9,
1318 7, 5, 7, 9, 7, 9, 11, 9, 11, 9, 7, 9, 11, 9, 11, 10,
1319 7, 9, 7, 5, 7, 9, 7, 10, 11, 9, 11, 10, 7, 9, 11, 9,
1322 const AAC_SPEC_CB1_CODES: &[u16] = &[
1323 0x7f8, 0x1f1, 0x7fd, 0x3f5, 0x068, 0x3f0, 0x7f7, 0x1ec,
1324 0x7f5, 0x3f1, 0x072, 0x3f4, 0x074, 0x011, 0x076, 0x1eb,
1325 0x06c, 0x3f6, 0x7fc, 0x1e1, 0x7f1, 0x1f0, 0x061, 0x1f6,
1326 0x7f2, 0x1ea, 0x7fb, 0x1f2, 0x069, 0x1ed, 0x077, 0x017,
1327 0x06f, 0x1e6, 0x064, 0x1e5, 0x067, 0x015, 0x062, 0x012,
1328 0x000, 0x014, 0x065, 0x016, 0x06d, 0x1e9, 0x063, 0x1e4,
1329 0x06b, 0x013, 0x071, 0x1e3, 0x070, 0x1f3, 0x7fe, 0x1e7,
1330 0x7f3, 0x1ef, 0x060, 0x1ee, 0x7f0, 0x1e2, 0x7fa, 0x3f3,
1331 0x06a, 0x1e8, 0x075, 0x010, 0x073, 0x1f4, 0x06e, 0x3f7,
1332 0x7f6, 0x1e0, 0x7f9, 0x3f2, 0x066, 0x1f5, 0x7ff, 0x1f7,
1335 const AAC_SPEC_CB2_BITS: &[u8] = &[
1336 9, 7, 9, 8, 6, 8, 9, 8, 9, 8, 6, 7, 6, 5, 6, 7,
1337 6, 8, 9, 7, 8, 8, 6, 8, 9, 7, 9, 8, 6, 7, 6, 5,
1338 6, 7, 6, 8, 6, 5, 6, 5, 3, 5, 6, 5, 6, 8, 6, 7,
1339 6, 5, 6, 8, 6, 8, 9, 7, 9, 8, 6, 8, 8, 7, 9, 8,
1340 6, 7, 6, 4, 6, 8, 6, 7, 9, 7, 9, 7, 6, 8, 9, 7,
1343 const AAC_SPEC_CB2_CODES: &[u16] = &[
1344 0x1f3, 0x06f, 0x1fd, 0x0eb, 0x023, 0x0ea, 0x1f7, 0x0e8,
1345 0x1fa, 0x0f2, 0x02d, 0x070, 0x020, 0x006, 0x02b, 0x06e,
1346 0x028, 0x0e9, 0x1f9, 0x066, 0x0f8, 0x0e7, 0x01b, 0x0f1,
1347 0x1f4, 0x06b, 0x1f5, 0x0ec, 0x02a, 0x06c, 0x02c, 0x00a,
1348 0x027, 0x067, 0x01a, 0x0f5, 0x024, 0x008, 0x01f, 0x009,
1349 0x000, 0x007, 0x01d, 0x00b, 0x030, 0x0ef, 0x01c, 0x064,
1350 0x01e, 0x00c, 0x029, 0x0f3, 0x02f, 0x0f0, 0x1fc, 0x071,
1351 0x1f2, 0x0f4, 0x021, 0x0e6, 0x0f7, 0x068, 0x1f8, 0x0ee,
1352 0x022, 0x065, 0x031, 0x002, 0x026, 0x0ed, 0x025, 0x06a,
1353 0x1fb, 0x072, 0x1fe, 0x069, 0x02e, 0x0f6, 0x1ff, 0x06d,
1356 const AAC_SPEC_CB3_BITS: &[u8] = &[
1357 1, 4, 8, 4, 5, 8, 9, 9, 10, 4, 6, 9, 6, 6, 9, 9,
1358 9, 10, 9, 10, 13, 9, 9, 11, 11, 10, 12, 4, 6, 10, 6, 7,
1359 10, 10, 10, 12, 5, 7, 11, 6, 7, 10, 9, 9, 11, 9, 10, 13,
1360 8, 9, 12, 10, 11, 12, 8, 10, 15, 9, 11, 15, 13, 14, 16, 8,
1361 10, 14, 9, 10, 14, 12, 12, 15, 11, 12, 16, 10, 11, 15, 12, 12,
1364 const AAC_SPEC_CB3_CODES: &[u16] = &[
1365 0x0000, 0x0009, 0x00ef, 0x000b, 0x0019, 0x00f0, 0x01eb, 0x01e6,
1366 0x03f2, 0x000a, 0x0035, 0x01ef, 0x0034, 0x0037, 0x01e9, 0x01ed,
1367 0x01e7, 0x03f3, 0x01ee, 0x03ed, 0x1ffa, 0x01ec, 0x01f2, 0x07f9,
1368 0x07f8, 0x03f8, 0x0ff8, 0x0008, 0x0038, 0x03f6, 0x0036, 0x0075,
1369 0x03f1, 0x03eb, 0x03ec, 0x0ff4, 0x0018, 0x0076, 0x07f4, 0x0039,
1370 0x0074, 0x03ef, 0x01f3, 0x01f4, 0x07f6, 0x01e8, 0x03ea, 0x1ffc,
1371 0x00f2, 0x01f1, 0x0ffb, 0x03f5, 0x07f3, 0x0ffc, 0x00ee, 0x03f7,
1372 0x7ffe, 0x01f0, 0x07f5, 0x7ffd, 0x1ffb, 0x3ffa, 0xffff, 0x00f1,
1373 0x03f0, 0x3ffc, 0x01ea, 0x03ee, 0x3ffb, 0x0ff6, 0x0ffa, 0x7ffc,
1374 0x07f2, 0x0ff5, 0xfffe, 0x03f4, 0x07f7, 0x7ffb, 0x0ff7, 0x0ff9,
1377 const AAC_SPEC_CB4_BITS: &[u8] = &[
1378 4, 5, 8, 5, 4, 8, 9, 8, 11, 5, 5, 8, 5, 4, 8, 8,
1379 7, 10, 9, 8, 11, 8, 8, 10, 11, 10, 11, 4, 5, 8, 4, 4,
1380 8, 8, 8, 10, 4, 4, 8, 4, 4, 7, 8, 7, 9, 8, 8, 10,
1381 7, 7, 9, 10, 9, 10, 8, 8, 11, 8, 7, 10, 11, 10, 12, 8,
1382 7, 10, 7, 7, 9, 10, 9, 11, 11, 10, 12, 10, 9, 11, 11, 10,
1385 const AAC_SPEC_CB4_CODES: &[u16] = &[
1386 0x007, 0x016, 0x0f6, 0x018, 0x008, 0x0ef, 0x1ef, 0x0f3,
1387 0x7f8, 0x019, 0x017, 0x0ed, 0x015, 0x001, 0x0e2, 0x0f0,
1388 0x070, 0x3f0, 0x1ee, 0x0f1, 0x7fa, 0x0ee, 0x0e4, 0x3f2,
1389 0x7f6, 0x3ef, 0x7fd, 0x005, 0x014, 0x0f2, 0x009, 0x004,
1390 0x0e5, 0x0f4, 0x0e8, 0x3f4, 0x006, 0x002, 0x0e7, 0x003,
1391 0x000, 0x06b, 0x0e3, 0x069, 0x1f3, 0x0eb, 0x0e6, 0x3f6,
1392 0x06e, 0x06a, 0x1f4, 0x3ec, 0x1f0, 0x3f9, 0x0f5, 0x0ec,
1393 0x7fb, 0x0ea, 0x06f, 0x3f7, 0x7f9, 0x3f3, 0xfff, 0x0e9,
1394 0x06d, 0x3f8, 0x06c, 0x068, 0x1f5, 0x3ee, 0x1f2, 0x7f4,
1395 0x7f7, 0x3f1, 0xffe, 0x3ed, 0x1f1, 0x7f5, 0x7fe, 0x3f5,
1398 const AAC_SPEC_CB5_BITS: &[u8] = &[
1399 13, 12, 11, 11, 10, 11, 11, 12, 13, 12, 11, 10, 9, 8, 9, 10,
1400 11, 12, 12, 10, 9, 8, 7, 8, 9, 10, 11, 11, 9, 8, 5, 4,
1401 5, 8, 9, 11, 10, 8, 7, 4, 1, 4, 7, 8, 11, 11, 9, 8,
1402 5, 4, 5, 8, 9, 11, 11, 10, 9, 8, 7, 8, 9, 10, 11, 12,
1403 11, 10, 9, 8, 9, 10, 11, 12, 13, 12, 12, 11, 10, 10, 11, 12,
1406 const AAC_SPEC_CB5_CODES: &[u16] = &[
1407 0x1fff, 0x0ff7, 0x07f4, 0x07e8, 0x03f1, 0x07ee, 0x07f9, 0x0ff8,
1408 0x1ffd, 0x0ffd, 0x07f1, 0x03e8, 0x01e8, 0x00f0, 0x01ec, 0x03ee,
1409 0x07f2, 0x0ffa, 0x0ff4, 0x03ef, 0x01f2, 0x00e8, 0x0070, 0x00ec,
1410 0x01f0, 0x03ea, 0x07f3, 0x07eb, 0x01eb, 0x00ea, 0x001a, 0x0008,
1411 0x0019, 0x00ee, 0x01ef, 0x07ed, 0x03f0, 0x00f2, 0x0073, 0x000b,
1412 0x0000, 0x000a, 0x0071, 0x00f3, 0x07e9, 0x07ef, 0x01ee, 0x00ef,
1413 0x0018, 0x0009, 0x001b, 0x00eb, 0x01e9, 0x07ec, 0x07f6, 0x03eb,
1414 0x01f3, 0x00ed, 0x0072, 0x00e9, 0x01f1, 0x03ed, 0x07f7, 0x0ff6,
1415 0x07f0, 0x03e9, 0x01ed, 0x00f1, 0x01ea, 0x03ec, 0x07f8, 0x0ff9,
1416 0x1ffc, 0x0ffc, 0x0ff5, 0x07ea, 0x03f3, 0x03f2, 0x07f5, 0x0ffb,
1419 const AAC_SPEC_CB6_BITS: &[u8] = &[
1420 11, 10, 9, 9, 9, 9, 9, 10, 11, 10, 9, 8, 7, 7, 7, 8,
1421 9, 10, 9, 8, 6, 6, 6, 6, 6, 8, 9, 9, 7, 6, 4, 4,
1422 4, 6, 7, 9, 9, 7, 6, 4, 4, 4, 6, 7, 9, 9, 7, 6,
1423 4, 4, 4, 6, 7, 9, 9, 8, 6, 6, 6, 6, 6, 8, 9, 10,
1424 9, 8, 7, 7, 7, 7, 8, 10, 11, 10, 9, 9, 9, 9, 9, 10,
1427 const AAC_SPEC_CB6_CODES: &[u16] = &[
1428 0x7fe, 0x3fd, 0x1f1, 0x1eb, 0x1f4, 0x1ea, 0x1f0, 0x3fc,
1429 0x7fd, 0x3f6, 0x1e5, 0x0ea, 0x06c, 0x071, 0x068, 0x0f0,
1430 0x1e6, 0x3f7, 0x1f3, 0x0ef, 0x032, 0x027, 0x028, 0x026,
1431 0x031, 0x0eb, 0x1f7, 0x1e8, 0x06f, 0x02e, 0x008, 0x004,
1432 0x006, 0x029, 0x06b, 0x1ee, 0x1ef, 0x072, 0x02d, 0x002,
1433 0x000, 0x003, 0x02f, 0x073, 0x1fa, 0x1e7, 0x06e, 0x02b,
1434 0x007, 0x001, 0x005, 0x02c, 0x06d, 0x1ec, 0x1f9, 0x0ee,
1435 0x030, 0x024, 0x02a, 0x025, 0x033, 0x0ec, 0x1f2, 0x3f8,
1436 0x1e4, 0x0ed, 0x06a, 0x070, 0x069, 0x074, 0x0f1, 0x3fa,
1437 0x7ff, 0x3f9, 0x1f6, 0x1ed, 0x1f8, 0x1e9, 0x1f5, 0x3fb,
1440 const AAC_SPEC_CB7_BITS: &[u8] = &[
1441 1, 3, 6, 7, 8, 9, 10, 11, 3, 4, 6, 7, 8, 8, 9, 9,
1442 6, 6, 7, 8, 8, 9, 9, 10, 7, 7, 8, 8, 9, 9, 10, 10,
1443 8, 8, 9, 9, 10, 10, 10, 11, 9, 8, 9, 9, 10, 10, 11, 11,
1444 10, 9, 9, 10, 10, 11, 12, 12, 11, 10, 10, 10, 11, 11, 12, 12
1446 const AAC_SPEC_CB7_CODES: &[u16] = &[
1447 0x000, 0x005, 0x037, 0x074, 0x0f2, 0x1eb, 0x3ed, 0x7f7,
1448 0x004, 0x00c, 0x035, 0x071, 0x0ec, 0x0ee, 0x1ee, 0x1f5,
1449 0x036, 0x034, 0x072, 0x0ea, 0x0f1, 0x1e9, 0x1f3, 0x3f5,
1450 0x073, 0x070, 0x0eb, 0x0f0, 0x1f1, 0x1f0, 0x3ec, 0x3fa,
1451 0x0f3, 0x0ed, 0x1e8, 0x1ef, 0x3ef, 0x3f1, 0x3f9, 0x7fb,
1452 0x1ed, 0x0ef, 0x1ea, 0x1f2, 0x3f3, 0x3f8, 0x7f9, 0x7fc,
1453 0x3ee, 0x1ec, 0x1f4, 0x3f4, 0x3f7, 0x7f8, 0xffd, 0xffe,
1454 0x7f6, 0x3f0, 0x3f2, 0x3f6, 0x7fa, 0x7fd, 0xffc, 0xfff
1456 const AAC_SPEC_CB8_BITS: &[u8] = &[
1457 5, 4, 5, 6, 7, 8, 9, 10, 4, 3, 4, 5, 6, 7, 7, 8,
1458 5, 4, 4, 5, 6, 7, 7, 8, 6, 5, 5, 6, 6, 7, 8, 8,
1459 7, 6, 6, 6, 7, 7, 8, 9, 8, 7, 6, 7, 7, 8, 8, 10,
1460 9, 7, 7, 8, 8, 8, 9, 9, 10, 8, 8, 8, 9, 9, 9, 10
1462 const AAC_SPEC_CB8_CODES: &[u16] = &[
1463 0x00e, 0x005, 0x010, 0x030, 0x06f, 0x0f1, 0x1fa, 0x3fe,
1464 0x003, 0x000, 0x004, 0x012, 0x02c, 0x06a, 0x075, 0x0f8,
1465 0x00f, 0x002, 0x006, 0x014, 0x02e, 0x069, 0x072, 0x0f5,
1466 0x02f, 0x011, 0x013, 0x02a, 0x032, 0x06c, 0x0ec, 0x0fa,
1467 0x071, 0x02b, 0x02d, 0x031, 0x06d, 0x070, 0x0f2, 0x1f9,
1468 0x0ef, 0x068, 0x033, 0x06b, 0x06e, 0x0ee, 0x0f9, 0x3fc,
1469 0x1f8, 0x074, 0x073, 0x0ed, 0x0f0, 0x0f6, 0x1f6, 0x1fd,
1470 0x3fd, 0x0f3, 0x0f4, 0x0f7, 0x1f7, 0x1fb, 0x1fc, 0x3ff
1472 const AAC_SPEC_CB9_BITS: &[u8] = &[
1473 1, 3, 6, 8, 9, 10, 10, 11, 11, 12, 12, 13, 13, 3, 4, 6,
1474 7, 8, 8, 9, 10, 10, 10, 11, 12, 12, 6, 6, 7, 8, 8, 9,
1475 10, 10, 10, 11, 12, 12, 12, 8, 7, 8, 9, 9, 10, 10, 11, 11,
1476 11, 12, 12, 13, 9, 8, 9, 9, 10, 10, 11, 11, 11, 12, 12, 12,
1477 13, 10, 9, 9, 10, 11, 11, 11, 12, 11, 12, 12, 13, 13, 11, 9,
1478 10, 11, 11, 11, 12, 12, 12, 12, 13, 13, 13, 11, 10, 10, 11, 11,
1479 12, 12, 13, 13, 13, 13, 13, 13, 11, 10, 10, 11, 11, 11, 12, 12,
1480 13, 13, 14, 13, 14, 11, 10, 11, 11, 12, 12, 12, 12, 13, 13, 14,
1481 14, 14, 12, 11, 11, 12, 12, 12, 13, 13, 13, 14, 14, 14, 15, 12,
1482 11, 12, 12, 12, 13, 13, 13, 13, 14, 14, 15, 15, 13, 12, 12, 12,
1483 13, 13, 13, 13, 14, 14, 14, 14, 15
1485 const AAC_SPEC_CB9_CODES: &[u16] = &[
1486 0x0000, 0x0005, 0x0037, 0x00e7, 0x01de, 0x03ce, 0x03d9, 0x07c8,
1487 0x07cd, 0x0fc8, 0x0fdd, 0x1fe4, 0x1fec, 0x0004, 0x000c, 0x0035,
1488 0x0072, 0x00ea, 0x00ed, 0x01e2, 0x03d1, 0x03d3, 0x03e0, 0x07d8,
1489 0x0fcf, 0x0fd5, 0x0036, 0x0034, 0x0071, 0x00e8, 0x00ec, 0x01e1,
1490 0x03cf, 0x03dd, 0x03db, 0x07d0, 0x0fc7, 0x0fd4, 0x0fe4, 0x00e6,
1491 0x0070, 0x00e9, 0x01dd, 0x01e3, 0x03d2, 0x03dc, 0x07cc, 0x07ca,
1492 0x07de, 0x0fd8, 0x0fea, 0x1fdb, 0x01df, 0x00eb, 0x01dc, 0x01e6,
1493 0x03d5, 0x03de, 0x07cb, 0x07dd, 0x07dc, 0x0fcd, 0x0fe2, 0x0fe7,
1494 0x1fe1, 0x03d0, 0x01e0, 0x01e4, 0x03d6, 0x07c5, 0x07d1, 0x07db,
1495 0x0fd2, 0x07e0, 0x0fd9, 0x0feb, 0x1fe3, 0x1fe9, 0x07c4, 0x01e5,
1496 0x03d7, 0x07c6, 0x07cf, 0x07da, 0x0fcb, 0x0fda, 0x0fe3, 0x0fe9,
1497 0x1fe6, 0x1ff3, 0x1ff7, 0x07d3, 0x03d8, 0x03e1, 0x07d4, 0x07d9,
1498 0x0fd3, 0x0fde, 0x1fdd, 0x1fd9, 0x1fe2, 0x1fea, 0x1ff1, 0x1ff6,
1499 0x07d2, 0x03d4, 0x03da, 0x07c7, 0x07d7, 0x07e2, 0x0fce, 0x0fdb,
1500 0x1fd8, 0x1fee, 0x3ff0, 0x1ff4, 0x3ff2, 0x07e1, 0x03df, 0x07c9,
1501 0x07d6, 0x0fca, 0x0fd0, 0x0fe5, 0x0fe6, 0x1feb, 0x1fef, 0x3ff3,
1502 0x3ff4, 0x3ff5, 0x0fe0, 0x07ce, 0x07d5, 0x0fc6, 0x0fd1, 0x0fe1,
1503 0x1fe0, 0x1fe8, 0x1ff0, 0x3ff1, 0x3ff8, 0x3ff6, 0x7ffc, 0x0fe8,
1504 0x07df, 0x0fc9, 0x0fd7, 0x0fdc, 0x1fdc, 0x1fdf, 0x1fed, 0x1ff5,
1505 0x3ff9, 0x3ffb, 0x7ffd, 0x7ffe, 0x1fe7, 0x0fcc, 0x0fd6, 0x0fdf,
1506 0x1fde, 0x1fda, 0x1fe5, 0x1ff2, 0x3ffa, 0x3ff7, 0x3ffc, 0x3ffd,
1509 const AAC_SPEC_CB10_BITS: &[u8] = &[
1510 6, 5, 6, 6, 7, 8, 9, 10, 10, 10, 11, 11, 12, 5, 4, 4,
1511 5, 6, 7, 7, 8, 8, 9, 10, 10, 11, 6, 4, 5, 5, 6, 6,
1512 7, 8, 8, 9, 9, 10, 10, 6, 5, 5, 5, 6, 7, 7, 8, 8,
1513 9, 9, 10, 10, 7, 6, 6, 6, 6, 7, 7, 8, 8, 9, 9, 10,
1514 10, 8, 7, 6, 7, 7, 7, 8, 8, 8, 9, 10, 10, 11, 9, 7,
1515 7, 7, 7, 8, 8, 9, 9, 9, 10, 10, 11, 9, 8, 8, 8, 8,
1516 8, 9, 9, 9, 10, 10, 11, 11, 9, 8, 8, 8, 8, 8, 9, 9,
1517 10, 10, 10, 11, 11, 10, 9, 9, 9, 9, 9, 9, 10, 10, 10, 11,
1518 11, 12, 10, 9, 9, 9, 9, 10, 10, 10, 10, 11, 11, 11, 12, 11,
1519 10, 9, 10, 10, 10, 10, 10, 11, 11, 11, 11, 12, 11, 10, 10, 10,
1520 10, 10, 10, 11, 11, 12, 12, 12, 12
1522 const AAC_SPEC_CB10_CODES: &[u16] = &[
1523 0x022, 0x008, 0x01d, 0x026, 0x05f, 0x0d3, 0x1cf, 0x3d0,
1524 0x3d7, 0x3ed, 0x7f0, 0x7f6, 0xffd, 0x007, 0x000, 0x001,
1525 0x009, 0x020, 0x054, 0x060, 0x0d5, 0x0dc, 0x1d4, 0x3cd,
1526 0x3de, 0x7e7, 0x01c, 0x002, 0x006, 0x00c, 0x01e, 0x028,
1527 0x05b, 0x0cd, 0x0d9, 0x1ce, 0x1dc, 0x3d9, 0x3f1, 0x025,
1528 0x00b, 0x00a, 0x00d, 0x024, 0x057, 0x061, 0x0cc, 0x0dd,
1529 0x1cc, 0x1de, 0x3d3, 0x3e7, 0x05d, 0x021, 0x01f, 0x023,
1530 0x027, 0x059, 0x064, 0x0d8, 0x0df, 0x1d2, 0x1e2, 0x3dd,
1531 0x3ee, 0x0d1, 0x055, 0x029, 0x056, 0x058, 0x062, 0x0ce,
1532 0x0e0, 0x0e2, 0x1da, 0x3d4, 0x3e3, 0x7eb, 0x1c9, 0x05e,
1533 0x05a, 0x05c, 0x063, 0x0ca, 0x0da, 0x1c7, 0x1ca, 0x1e0,
1534 0x3db, 0x3e8, 0x7ec, 0x1e3, 0x0d2, 0x0cb, 0x0d0, 0x0d7,
1535 0x0db, 0x1c6, 0x1d5, 0x1d8, 0x3ca, 0x3da, 0x7ea, 0x7f1,
1536 0x1e1, 0x0d4, 0x0cf, 0x0d6, 0x0de, 0x0e1, 0x1d0, 0x1d6,
1537 0x3d1, 0x3d5, 0x3f2, 0x7ee, 0x7fb, 0x3e9, 0x1cd, 0x1c8,
1538 0x1cb, 0x1d1, 0x1d7, 0x1df, 0x3cf, 0x3e0, 0x3ef, 0x7e6,
1539 0x7f8, 0xffa, 0x3eb, 0x1dd, 0x1d3, 0x1d9, 0x1db, 0x3d2,
1540 0x3cc, 0x3dc, 0x3ea, 0x7ed, 0x7f3, 0x7f9, 0xff9, 0x7f2,
1541 0x3ce, 0x1e4, 0x3cb, 0x3d8, 0x3d6, 0x3e2, 0x3e5, 0x7e8,
1542 0x7f4, 0x7f5, 0x7f7, 0xffb, 0x7fa, 0x3ec, 0x3df, 0x3e1,
1543 0x3e4, 0x3e6, 0x3f0, 0x7e9, 0x7ef, 0xff8, 0xffe, 0xffc,
1546 const AAC_SPEC_CB11_BITS: &[u8] = &[
1547 4, 5, 6, 7, 8, 8, 9, 10, 10, 10, 11, 11, 12, 11, 12, 12,
1548 10, 5, 4, 5, 6, 7, 7, 8, 8, 9, 9, 9, 10, 10, 10, 10,
1549 11, 8, 6, 5, 5, 6, 7, 7, 8, 8, 8, 9, 9, 9, 10, 10,
1550 10, 10, 8, 7, 6, 6, 6, 7, 7, 8, 8, 8, 9, 9, 9, 10,
1551 10, 10, 10, 8, 8, 7, 7, 7, 7, 8, 8, 8, 8, 9, 9, 9,
1552 10, 10, 10, 10, 8, 8, 7, 7, 7, 7, 8, 8, 8, 9, 9, 9,
1553 9, 10, 10, 10, 10, 8, 9, 8, 8, 8, 8, 8, 8, 8, 9, 9,
1554 9, 10, 10, 10, 10, 10, 8, 9, 8, 8, 8, 8, 8, 8, 9, 9,
1555 9, 10, 10, 10, 10, 10, 10, 8, 10, 9, 8, 8, 9, 9, 9, 9,
1556 9, 10, 10, 10, 10, 10, 10, 11, 8, 10, 9, 9, 9, 9, 9, 9,
1557 9, 10, 10, 10, 10, 10, 10, 11, 11, 8, 11, 9, 9, 9, 9, 9,
1558 9, 10, 10, 10, 10, 10, 11, 10, 11, 11, 8, 11, 10, 9, 9, 10,
1559 9, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 8, 11, 10, 10, 10,
1560 10, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 9, 11, 10, 9,
1561 9, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11, 9, 11, 10,
1562 10, 10, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11, 9, 12,
1563 10, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11, 12, 12, 9,
1564 9, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 9,
1567 const AAC_SPEC_CB11_CODES: &[u16] = &[
1568 0x000, 0x006, 0x019, 0x03d, 0x09c, 0x0c6, 0x1a7, 0x390,
1569 0x3c2, 0x3df, 0x7e6, 0x7f3, 0xffb, 0x7ec, 0xffa, 0xffe,
1570 0x38e, 0x005, 0x001, 0x008, 0x014, 0x037, 0x042, 0x092,
1571 0x0af, 0x191, 0x1a5, 0x1b5, 0x39e, 0x3c0, 0x3a2, 0x3cd,
1572 0x7d6, 0x0ae, 0x017, 0x007, 0x009, 0x018, 0x039, 0x040,
1573 0x08e, 0x0a3, 0x0b8, 0x199, 0x1ac, 0x1c1, 0x3b1, 0x396,
1574 0x3be, 0x3ca, 0x09d, 0x03c, 0x015, 0x016, 0x01a, 0x03b,
1575 0x044, 0x091, 0x0a5, 0x0be, 0x196, 0x1ae, 0x1b9, 0x3a1,
1576 0x391, 0x3a5, 0x3d5, 0x094, 0x09a, 0x036, 0x038, 0x03a,
1577 0x041, 0x08c, 0x09b, 0x0b0, 0x0c3, 0x19e, 0x1ab, 0x1bc,
1578 0x39f, 0x38f, 0x3a9, 0x3cf, 0x093, 0x0bf, 0x03e, 0x03f,
1579 0x043, 0x045, 0x09e, 0x0a7, 0x0b9, 0x194, 0x1a2, 0x1ba,
1580 0x1c3, 0x3a6, 0x3a7, 0x3bb, 0x3d4, 0x09f, 0x1a0, 0x08f,
1581 0x08d, 0x090, 0x098, 0x0a6, 0x0b6, 0x0c4, 0x19f, 0x1af,
1582 0x1bf, 0x399, 0x3bf, 0x3b4, 0x3c9, 0x3e7, 0x0a8, 0x1b6,
1583 0x0ab, 0x0a4, 0x0aa, 0x0b2, 0x0c2, 0x0c5, 0x198, 0x1a4,
1584 0x1b8, 0x38c, 0x3a4, 0x3c4, 0x3c6, 0x3dd, 0x3e8, 0x0ad,
1585 0x3af, 0x192, 0x0bd, 0x0bc, 0x18e, 0x197, 0x19a, 0x1a3,
1586 0x1b1, 0x38d, 0x398, 0x3b7, 0x3d3, 0x3d1, 0x3db, 0x7dd,
1587 0x0b4, 0x3de, 0x1a9, 0x19b, 0x19c, 0x1a1, 0x1aa, 0x1ad,
1588 0x1b3, 0x38b, 0x3b2, 0x3b8, 0x3ce, 0x3e1, 0x3e0, 0x7d2,
1589 0x7e5, 0x0b7, 0x7e3, 0x1bb, 0x1a8, 0x1a6, 0x1b0, 0x1b2,
1590 0x1b7, 0x39b, 0x39a, 0x3ba, 0x3b5, 0x3d6, 0x7d7, 0x3e4,
1591 0x7d8, 0x7ea, 0x0ba, 0x7e8, 0x3a0, 0x1bd, 0x1b4, 0x38a,
1592 0x1c4, 0x392, 0x3aa, 0x3b0, 0x3bc, 0x3d7, 0x7d4, 0x7dc,
1593 0x7db, 0x7d5, 0x7f0, 0x0c1, 0x7fb, 0x3c8, 0x3a3, 0x395,
1594 0x39d, 0x3ac, 0x3ae, 0x3c5, 0x3d8, 0x3e2, 0x3e6, 0x7e4,
1595 0x7e7, 0x7e0, 0x7e9, 0x7f7, 0x190, 0x7f2, 0x393, 0x1be,
1596 0x1c0, 0x394, 0x397, 0x3ad, 0x3c3, 0x3c1, 0x3d2, 0x7da,
1597 0x7d9, 0x7df, 0x7eb, 0x7f4, 0x7fa, 0x195, 0x7f8, 0x3bd,
1598 0x39c, 0x3ab, 0x3a8, 0x3b3, 0x3b9, 0x3d0, 0x3e3, 0x3e5,
1599 0x7e2, 0x7de, 0x7ed, 0x7f1, 0x7f9, 0x7fc, 0x193, 0xffd,
1600 0x3dc, 0x3b6, 0x3c7, 0x3cc, 0x3cb, 0x3d9, 0x3da, 0x7d3,
1601 0x7e1, 0x7ee, 0x7ef, 0x7f5, 0x7f6, 0xffc, 0xfff, 0x19d,
1602 0x1c2, 0x0b5, 0x0a1, 0x096, 0x097, 0x095, 0x099, 0x0a0,
1603 0x0a2, 0x0ac, 0x0a9, 0x0b1, 0x0b3, 0x0bb, 0x0c0, 0x18f,
1607 const AAC_SPEC_BITS: [&[u8]; 11] = [
1608 AAC_SPEC_CB1_BITS, AAC_SPEC_CB2_BITS, AAC_SPEC_CB3_BITS, AAC_SPEC_CB4_BITS,
1609 AAC_SPEC_CB5_BITS, AAC_SPEC_CB6_BITS, AAC_SPEC_CB7_BITS, AAC_SPEC_CB8_BITS,
1610 AAC_SPEC_CB9_BITS, AAC_SPEC_CB10_BITS, AAC_SPEC_CB11_BITS
1612 const AAC_SPEC_CODES: [&[u16]; 11] = [
1613 AAC_SPEC_CB1_CODES, AAC_SPEC_CB2_CODES, AAC_SPEC_CB3_CODES, AAC_SPEC_CB4_CODES,
1614 AAC_SPEC_CB5_CODES, AAC_SPEC_CB6_CODES, AAC_SPEC_CB7_CODES, AAC_SPEC_CB8_CODES,
1615 AAC_SPEC_CB9_CODES, AAC_SPEC_CB10_CODES, AAC_SPEC_CB11_CODES
1617 const AAC_UNSIGNED_CODEBOOK: [bool; 11] = [
1618 false, false, true, true, false, false, true, true, true, true, true
1620 const AAC_CODEBOOK_MODULO: [u16; 7] = [
1621 9, 9, 8, 8, 13, 13, 17
1624 const AAC_QUADS: [[i8; 4]; 81] = [
1625 [ 0, 0, 0, 0 ], [ 0, 0, 0, 1 ], [ 0, 0, 0, 2 ],
1626 [ 0, 0, 1, 0 ], [ 0, 0, 1, 1 ], [ 0, 0, 1, 2 ],
1627 [ 0, 0, 2, 0 ], [ 0, 0, 2, 1 ], [ 0, 0, 2, 2 ],
1628 [ 0, 1, 0, 0 ], [ 0, 1, 0, 1 ], [ 0, 1, 0, 2 ],
1629 [ 0, 1, 1, 0 ], [ 0, 1, 1, 1 ], [ 0, 1, 1, 2 ],
1630 [ 0, 1, 2, 0 ], [ 0, 1, 2, 1 ], [ 0, 1, 2, 2 ],
1631 [ 0, 2, 0, 0 ], [ 0, 2, 0, 1 ], [ 0, 2, 0, 2 ],
1632 [ 0, 2, 1, 0 ], [ 0, 2, 1, 1 ], [ 0, 2, 1, 2 ],
1633 [ 0, 2, 2, 0 ], [ 0, 2, 2, 1 ], [ 0, 2, 2, 2 ],
1634 [ 1, 0, 0, 0 ], [ 1, 0, 0, 1 ], [ 1, 0, 0, 2 ],
1635 [ 1, 0, 1, 0 ], [ 1, 0, 1, 1 ], [ 1, 0, 1, 2 ],
1636 [ 1, 0, 2, 0 ], [ 1, 0, 2, 1 ], [ 1, 0, 2, 2 ],
1637 [ 1, 1, 0, 0 ], [ 1, 1, 0, 1 ], [ 1, 1, 0, 2 ],
1638 [ 1, 1, 1, 0 ], [ 1, 1, 1, 1 ], [ 1, 1, 1, 2 ],
1639 [ 1, 1, 2, 0 ], [ 1, 1, 2, 1 ], [ 1, 1, 2, 2 ],
1640 [ 1, 2, 0, 0 ], [ 1, 2, 0, 1 ], [ 1, 2, 0, 2 ],
1641 [ 1, 2, 1, 0 ], [ 1, 2, 1, 1 ], [ 1, 2, 1, 2 ],
1642 [ 1, 2, 2, 0 ], [ 1, 2, 2, 1 ], [ 1, 2, 2, 2 ],
1643 [ 2, 0, 0, 0 ], [ 2, 0, 0, 1 ], [ 2, 0, 0, 2 ],
1644 [ 2, 0, 1, 0 ], [ 2, 0, 1, 1 ], [ 2, 0, 1, 2 ],
1645 [ 2, 0, 2, 0 ], [ 2, 0, 2, 1 ], [ 2, 0, 2, 2 ],
1646 [ 2, 1, 0, 0 ], [ 2, 1, 0, 1 ], [ 2, 1, 0, 2 ],
1647 [ 2, 1, 1, 0 ], [ 2, 1, 1, 1 ], [ 2, 1, 1, 2 ],
1648 [ 2, 1, 2, 0 ], [ 2, 1, 2, 1 ], [ 2, 1, 2, 2 ],
1649 [ 2, 2, 0, 0 ], [ 2, 2, 0, 1 ], [ 2, 2, 0, 2 ],
1650 [ 2, 2, 1, 0 ], [ 2, 2, 1, 1 ], [ 2, 2, 1, 2 ],
1651 [ 2, 2, 2, 0 ], [ 2, 2, 2, 1 ], [ 2, 2, 2, 2 ],
1654 const DEFAULT_CHANNEL_MAP: [&str; 9] = [
1663 "C,L,R,Ls,Rs,Lss,Rss,LFE",
1666 const SWB_OFFSET_48K_LONG: [usize; 49+1] = [
1667 0, 4, 8, 12, 16, 20, 24, 28,
1668 32, 36, 40, 48, 56, 64, 72, 80,
1669 88, 96, 108, 120, 132, 144, 160, 176,
1670 196, 216, 240, 264, 292, 320, 352, 384,
1671 416, 448, 480, 512, 544, 576, 608, 640,
1672 672, 704, 736, 768, 800, 832, 864, 896,
1675 const SWB_OFFSET_48K_SHORT: [usize; 14+1] = [
1676 0, 4, 8, 12, 16, 20, 28, 36, 44, 56, 68, 80, 96, 112, 128
1678 const SWB_OFFSET_32K_LONG: [usize; 51+1] = [
1679 0, 4, 8, 12, 16, 20, 24, 28,
1680 32, 36, 40, 48, 56, 64, 72, 80,
1681 88, 96, 108, 120, 132, 144, 160, 176,
1682 196, 216, 240, 264, 292, 320, 352, 384,
1683 416, 448, 480, 512, 544, 576, 608, 640,
1684 672, 704, 736, 768, 800, 832, 864, 896,
1687 const SWB_OFFSET_8K_LONG: [usize; 40+1] = [
1688 0, 12, 24, 36, 48, 60, 72, 84,
1689 96, 108, 120, 132, 144, 156, 172, 188,
1690 204, 220, 236, 252, 268, 288, 308, 328,
1691 348, 372, 396, 420, 448, 476, 508, 544,
1692 580, 620, 664, 712, 764, 820, 880, 944,
1695 const SWB_OFFSET_8K_SHORT: [usize; 15+1] = [
1696 0, 4, 8, 12, 16, 20, 24, 28, 36, 44, 52, 60, 72, 88, 108, 128
1698 const SWB_OFFSET_16K_LONG: [usize; 43+1] = [
1699 0, 8, 16, 24, 32, 40, 48, 56,
1700 64, 72, 80, 88, 100, 112, 124, 136,
1701 148, 160, 172, 184, 196, 212, 228, 244,
1702 260, 280, 300, 320, 344, 368, 396, 424,
1703 456, 492, 532, 572, 616, 664, 716, 772,
1706 const SWB_OFFSET_16K_SHORT: [usize; 15+1] = [
1707 0, 4, 8, 12, 16, 20, 24, 28, 32, 40, 48, 60, 72, 88, 108, 128
1709 const SWB_OFFSET_24K_LONG: [usize; 47+1] = [
1710 0, 4, 8, 12, 16, 20, 24, 28,
1711 32, 36, 40, 44, 52, 60, 68, 76,
1712 84, 92, 100, 108, 116, 124, 136, 148,
1713 160, 172, 188, 204, 220, 240, 260, 284,
1714 308, 336, 364, 396, 432, 468, 508, 552,
1715 600, 652, 704, 768, 832, 896, 960, 1024
1717 const SWB_OFFSET_24K_SHORT: [usize; 15+1] = [
1718 0, 4, 8, 12, 16, 20, 24, 28, 36, 44, 52, 64, 76, 92, 108, 128
1720 const SWB_OFFSET_64K_LONG: [usize; 47+1] = [
1721 0, 4, 8, 12, 16, 20, 24, 28,
1722 32, 36, 40, 44, 48, 52, 56, 64,
1723 72, 80, 88, 100, 112, 124, 140, 156,
1724 172, 192, 216, 240, 268, 304, 344, 384,
1725 424, 464, 504, 544, 584, 624, 664, 704,
1726 744, 784, 824, 864, 904, 944, 984, 1024
1728 const SWB_OFFSET_64K_SHORT: [usize; 12+1] = [
1729 0, 4, 8, 12, 16, 20, 24, 32, 40, 48, 64, 92, 128
1731 const SWB_OFFSET_96K_LONG: [usize; 41+1] = [
1732 0, 4, 8, 12, 16, 20, 24, 28,
1733 32, 36, 40, 44, 48, 52, 56, 64,
1734 72, 80, 88, 96, 108, 120, 132, 144,
1735 156, 172, 188, 212, 240, 276, 320, 384,
1736 448, 512, 576, 640, 704, 768, 832, 896,
1740 #[derive(Clone,Copy)]
1741 struct GASubbandInfo {
1743 long_bands: &'static [usize],
1744 short_bands: &'static [usize],
1747 impl GASubbandInfo {
1748 fn find(srate: u32) -> GASubbandInfo {
1749 for i in 0..AAC_SUBBAND_INFO.len() {
1750 if srate >= AAC_SUBBAND_INFO[i].min_srate {
1751 return AAC_SUBBAND_INFO[i];
1756 fn find_idx(srate: u32) -> usize {
1757 for i in 0..AAC_SUBBAND_INFO.len() {
1758 if srate >= AAC_SUBBAND_INFO[i].min_srate {
1766 const AAC_SUBBAND_INFO: [GASubbandInfo; 12] = [
1767 GASubbandInfo { min_srate: 92017, long_bands: &SWB_OFFSET_96K_LONG, short_bands: &SWB_OFFSET_64K_SHORT }, //96K
1768 GASubbandInfo { min_srate: 75132, long_bands: &SWB_OFFSET_96K_LONG, short_bands: &SWB_OFFSET_64K_SHORT }, //88.2K
1769 GASubbandInfo { min_srate: 55426, long_bands: &SWB_OFFSET_64K_LONG, short_bands: &SWB_OFFSET_64K_SHORT }, //64K
1770 GASubbandInfo { min_srate: 46009, long_bands: &SWB_OFFSET_48K_LONG, short_bands: &SWB_OFFSET_48K_SHORT }, //48K
1771 GASubbandInfo { min_srate: 37566, long_bands: &SWB_OFFSET_48K_LONG, short_bands: &SWB_OFFSET_48K_SHORT }, //44.1K
1772 GASubbandInfo { min_srate: 27713, long_bands: &SWB_OFFSET_32K_LONG, short_bands: &SWB_OFFSET_48K_SHORT }, //32K
1773 GASubbandInfo { min_srate: 23004, long_bands: &SWB_OFFSET_24K_LONG, short_bands: &SWB_OFFSET_24K_SHORT }, //24K
1774 GASubbandInfo { min_srate: 18783, long_bands: &SWB_OFFSET_24K_LONG, short_bands: &SWB_OFFSET_24K_SHORT }, //22.05K
1775 GASubbandInfo { min_srate: 13856, long_bands: &SWB_OFFSET_16K_LONG, short_bands: &SWB_OFFSET_16K_SHORT }, //16K
1776 GASubbandInfo { min_srate: 11502, long_bands: &SWB_OFFSET_16K_LONG, short_bands: &SWB_OFFSET_16K_SHORT }, //12K
1777 GASubbandInfo { min_srate: 9391, long_bands: &SWB_OFFSET_16K_LONG, short_bands: &SWB_OFFSET_16K_SHORT }, //11.025K
1778 GASubbandInfo { min_srate: 0, long_bands: &SWB_OFFSET_8K_LONG, short_bands: &SWB_OFFSET_8K_SHORT }, //8K