projects / nihav.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
move AAC decoder to nihav-mpeg crate
[nihav.git] / nihav-mpeg / src / codecs / aac.rs
CommitLineData
38953fb5
KS		 1use nihav_core::formats::*;
2use nihav_core::frame::*;
3use nihav_core::codecs::*;
b4d5b851
KS		 4use nihav_codec_support::dsp::mdct::IMDCT;
5use nihav_codec_support::dsp::window::*;
38953fb5 6use nihav_core::io::bitreader::*;
009c5158 7use nihav_core::io::byteio::*;
38953fb5 8use nihav_core::io::codebook::*;
5a932f64 9use std::fmt;
38953fb5 10use nihav_core::io::intcode::*;
5a932f64
KS		 11use std::mem;
12use std::ptr;
13use std::str::FromStr;
14use std::f32::consts;
15
16#[allow(non_camel_case_types)]
17#[derive(Clone,Copy,PartialEq)]
18enum M4AType {
19 None,
20 Main,
21 LC,
22 SSR,
23 LTP,
24 SBR,
25 Scalable,
26 TwinVQ,
27 CELP,
28 HVXC,
29 TTSI,
30 MainSynth,
31 WavetableSynth,
32 GeneralMIDI,
33 Algorithmic,
34 ER_AAC_LC,
35 ER_AAC_LTP,
36 ER_AAC_Scalable,
37 ER_TwinVQ,
38 ER_BSAC,
39 ER_AAC_LD,
40 ER_CELP,
41 ER_HVXC,
42 ER_HILN,
43 ER_Parametric,
44 SSC,
45 PS,
46 MPEGSurround,
47 Layer1,
48 Layer2,
49 Layer3,
50 DST,
51 ALS,
52 SLS,
53 SLSNonCore,
54 ER_AAC_ELD,
55 SMRSimple,
56 SMRMain,
57 Reserved,
58 Unknown,
59}
60
61const M4A_TYPES: &[M4AType] = &[
62 M4AType::None, M4AType::Main, M4AType::LC, M4AType::SSR,
63 M4AType::LTP, M4AType::SBR, M4AType::Scalable, M4AType::TwinVQ,
64 M4AType::CELP, M4AType::HVXC, M4AType::Reserved, M4AType::Reserved,
65 M4AType::TTSI, M4AType::MainSynth, M4AType::WavetableSynth, M4AType::GeneralMIDI,
66 M4AType::Algorithmic, M4AType::ER_AAC_LC, M4AType::Reserved, M4AType::ER_AAC_LTP,
67 M4AType::ER_AAC_Scalable, M4AType::ER_TwinVQ, M4AType::ER_BSAC, M4AType::ER_AAC_LD,
68 M4AType::ER_CELP, M4AType::ER_HVXC, M4AType::ER_HILN, M4AType::ER_Parametric,
69 M4AType::SSC, M4AType::PS, M4AType::MPEGSurround, M4AType::Reserved /*escape*/,
70 M4AType::Layer1, M4AType::Layer2, M4AType::Layer3, M4AType::DST,
71 M4AType::ALS, M4AType::SLS, M4AType::SLSNonCore, M4AType::ER_AAC_ELD,
72 M4AType::SMRSimple, M4AType::SMRMain,
73];
74const M4A_TYPE_NAMES: &[&str] = &[
75 "None", "AAC Main", "AAC LC", "AAC SSR", "AAC LTP", "SBR", "AAC Scalable", "TwinVQ", "CELP", "HVXC",
76 /*"(reserved10)", "(reserved11)", */ "TTSI",
77 "Main synthetic", "Wavetable synthesis", "General MIDI", "Algorithmic Synthesis and Audio FX",
78 "ER AAC LC", /*"(reserved18)",*/ "ER AAC LTP", "ER AAC Scalable", "ER TwinVQ", "ER BSAC", "ER AAC LD",
79 "ER CELP", "ER HVXC", "ER HILN", "ER Parametric", "SSC", "PS", "MPEG Surround", /*"(escape)",*/
80 "Layer-1", "Layer-2", "Layer-3", "DST", "ALS", "SLS", "SLS non-core", "ER AAC ELD", "SMR Simple", "SMR Main",
81 "(reserved)", "(unknown)",
82];
83
84impl fmt::Display for M4AType {
85 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
86 write!(f, "{}", M4A_TYPE_NAMES[*self as usize])
87 }
88}
89
90const AAC_SAMPLE_RATES: [u32; 16] = [
91 96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050,
92 16000, 12000, 11025, 8000, 7350, 0, 0, 0
93];
94
95const AAC_CHANNELS: [usize; 8] = [ 0, 1, 2, 3, 4, 5, 6, 8 ];
96
97struct M4AInfo {
98 otype: M4AType,
99 srate: u32,
100 channels: usize,
101 samples: usize,
102 sbr_ps_info: Option<(u32, usize)>,
103 sbr_present: bool,
104 ps_present: bool,
105}
106
107impl M4AInfo {
108 fn new() -> Self {
109 Self {
110 otype: M4AType::None,
111 srate: 0,
112 channels: 0,
113 samples: 0,
114 sbr_ps_info: Option::None,
115 sbr_present: false,
116 ps_present: false,
117 }
118 }
119 fn read_object_type(br: &mut BitReader) -> DecoderResult<M4AType> {
120 let otypeidx;
121 if br.peek(5) == 31 {
122 br.skip(5)?;
123 otypeidx = (br.read(6)? as usize) + 32;
124 } else {
125 otypeidx = br.read(5)? as usize;
126 }
127 if otypeidx >= M4A_TYPES.len() {
128 Ok(M4AType::Unknown)
129 } else {
130 Ok(M4A_TYPES[otypeidx])
131 }
132 }
133 fn read_sampling_frequency(br: &mut BitReader) -> DecoderResult<u32> {
134 if br.peek(4) == 15 {
135 let srate = br.read(24)?;
136 Ok(srate)
137 } else {
138 let srate_idx = br.read(4)? as usize;
139 Ok(AAC_SAMPLE_RATES[srate_idx])
140 }
141 }
142 fn read_channel_config(br: &mut BitReader) -> DecoderResult<usize> {
143 let chidx = br.read(4)? as usize;
144 if chidx < AAC_CHANNELS.len() {
145 Ok(AAC_CHANNELS[chidx])
146 } else {
147 Ok(chidx)
148 }
149 }
150 fn read(&mut self, src: &[u8]) -> DecoderResult<()> {
fa90ccfb 151 let mut br = BitReader::new(src, BitReaderMode::BE);
5a932f64
KS		 152 self.otype = Self::read_object_type(&mut br)?;
153 self.srate = Self::read_sampling_frequency(&mut br)?;
154 validate!(self.srate > 0);
155 self.channels = Self::read_channel_config(&mut br)?;
156
157 if (self.otype == M4AType::SBR) || (self.otype == M4AType::PS) {
158 let ext_srate = Self::read_sampling_frequency(&mut br)?;
159 self.otype = Self::read_object_type(&mut br)?;
160 let ext_chans;
161 if self.otype == M4AType::ER_BSAC {
162 ext_chans = Self::read_channel_config(&mut br)?;
163 } else {
164 ext_chans = 0;
165 }
166 self.sbr_ps_info = Some((ext_srate, ext_chans));
167 }
168
169 match self.otype {
170 M4AType::Main | M4AType::LC | M4AType::SSR | M4AType::Scalable | M4AType::TwinVQ |
171 M4AType::ER_AAC_LC | M4AType::ER_AAC_LTP | M4AType::ER_AAC_Scalable | M4AType::ER_TwinVQ |
172 M4AType::ER_BSAC | M4AType::ER_AAC_LD => {
173 // GASpecificConfig
174 let short_frame = br.read_bool()?;
175 self.samples = if short_frame { 960 } else { 1024 };
176 let depends_on_core = br.read_bool()?;
177 if depends_on_core {
178 let _delay = br.read(14)?;
179 }
180 let extension_flag = br.read_bool()?;
181 if self.channels == 0 {
182 unimplemented!("program config element");
183 }
184 if (self.otype == M4AType::Scalable) || (self.otype == M4AType::ER_AAC_Scalable) {
185 let _layer = br.read(3)?;
186 }
187 if extension_flag {
188 if self.otype == M4AType::ER_BSAC {
189 let _num_subframes = br.read(5)? as usize;
190 let _layer_length = br.read(11)?;
191 }
192 if (self.otype == M4AType::ER_AAC_LC) ||
193 (self.otype == M4AType::ER_AAC_LTP) ||
194 (self.otype == M4AType::ER_AAC_Scalable) ||
195 (self.otype == M4AType::ER_AAC_LD) {
196 let _section_data_resilience = br.read_bool()?;
197 let _scalefactors_resilience = br.read_bool()?;
198 let _spectral_data_resilience = br.read_bool()?;
199 }
200 let extension_flag3 = br.read_bool()?;
201 if extension_flag3 {
202 unimplemented!("version3 extensions");
203 }
204 }
205 },
206 M4AType::CELP => { unimplemented!("CELP config"); },
207 M4AType::HVXC => { unimplemented!("HVXC config"); },
208 M4AType::TTSI => { unimplemented!("TTS config"); },
209 M4AType::MainSynth | M4AType::WavetableSynth | M4AType::GeneralMIDI | M4AType::Algorithmic => { unimplemented!("structured audio config"); },
210 M4AType::ER_CELP => { unimplemented!("ER CELP config"); },
211 M4AType::ER_HVXC => { unimplemented!("ER HVXC config"); },
212 M4AType::ER_HILN | M4AType::ER_Parametric => { unimplemented!("parametric config"); },
213 M4AType::SSC => { unimplemented!("SSC config"); },
214 M4AType::MPEGSurround => {
215 br.skip(1)?; // sacPayloadEmbedding
216 unimplemented!("MPEG Surround config");
217 },
218 M4AType::Layer1 | M4AType::Layer2 | M4AType::Layer3 => { unimplemented!("MPEG Layer 1/2/3 config"); },
219 M4AType::DST => { unimplemented!("DST config"); },
220 M4AType::ALS => {
221 br.skip(5)?; // fillBits
222 unimplemented!("ALS config");
223 },
224 M4AType::SLS | M4AType::SLSNonCore => { unimplemented!("SLS config"); },
225 M4AType::ER_AAC_ELD => { unimplemented!("ELD config"); },
226 M4AType::SMRSimple | M4AType::SMRMain => { unimplemented!("symbolic music config"); },
227 _ => {},
228 };
229 match self.otype {
230 M4AType::ER_AAC_LC | M4AType::ER_AAC_LTP | M4AType::ER_AAC_Scalable | M4AType::ER_TwinVQ |
231 M4AType::ER_BSAC | M4AType::ER_AAC_LD | M4AType::ER_CELP | M4AType::ER_HVXC |
232 M4AType::ER_HILN | M4AType::ER_Parametric | M4AType::ER_AAC_ELD => {
233 let ep_config = br.read(2)?;
234 if (ep_config == 2) || (ep_config == 3) {
235 unimplemented!("error protection config");
236 }
237 if ep_config == 3 {
238 let direct_mapping = br.read_bool()?;
239 validate!(direct_mapping);
240 }
241 },
242 _ => {},
243 };
244 if self.sbr_ps_info.is_some() && (br.left() >= 16) {
245 let sync = br.read(11)?;
246 if sync == 0x2B7 {
247 let ext_otype = Self::read_object_type(&mut br)?;
248 if ext_otype == M4AType::SBR {
249 self.sbr_present = br.read_bool()?;
250 if self.sbr_present {
251 let _ext_srate = Self::read_sampling_frequency(&mut br)?;
252 if br.left() >= 12 {
253 let sync = br.read(11)?;
254 if sync == 0x548 {
255 self.ps_present = br.read_bool()?;
256 }
257 }
258 }
259 }
260 if ext_otype == M4AType::PS {
261 self.sbr_present = br.read_bool()?;
262 if self.sbr_present {
263 let _ext_srate = Self::read_sampling_frequency(&mut br)?;
264 }
265 let _ext_channels = br.read(4)?;
266 }
267 }
268 }
269
270 Ok(())
271 }
272}
273
274impl fmt::Display for M4AInfo {
275 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
276 write!(f, "MPEG 4 Audio {}, {} Hz, {} channels, {} samples per frame",
277 self.otype, self.srate, self.channels, self.samples)
278 }
279}
280
281const MAX_WINDOWS: usize = 8;
282const MAX_SFBS: usize = 64;
283
284#[derive(Clone,Copy)]
285struct ICSInfo {
286 window_sequence: u8,
287 prev_window_sequence: u8,
288 window_shape: bool,
289 prev_window_shape: bool,
290 scale_factor_grouping: [bool; MAX_WINDOWS],
291 group_start: [usize; MAX_WINDOWS],
292 window_groups: usize,
293 num_windows: usize,
294 max_sfb: usize,
295 predictor_data: Option<LTPData>,
296 long_win: bool,
297}
298
299const ONLY_LONG_SEQUENCE: u8 = 0;
300const LONG_START_SEQUENCE: u8 = 1;
301const EIGHT_SHORT_SEQUENCE: u8 = 2;
302const LONG_STOP_SEQUENCE: u8 = 3;
303
304impl ICSInfo {
305 fn new() -> Self {
306 Self {
307 window_sequence: 0,
308 prev_window_sequence: 0,
309 window_shape: false,
310 prev_window_shape: false,
311 scale_factor_grouping: [false; MAX_WINDOWS],
312 group_start: [0; MAX_WINDOWS],
313 num_windows: 0,
314 window_groups: 0,
315 max_sfb: 0,
316 predictor_data: None,
317 long_win: true,
318 }
319 }
320 fn decode_ics_info(&mut self, br: &mut BitReader) -> DecoderResult<()> {
321 self.prev_window_sequence = self.window_sequence;
322 self.prev_window_shape = self.window_shape;
323 let ics_reserved_bit = br.read(1)?;
324 validate!(ics_reserved_bit == 0);
325 self.window_sequence = br.read(2)? as u8;
326 match self.prev_window_sequence {
327 ONLY_LONG_SEQUENCE | LONG_STOP_SEQUENCE => {
d4547e6a
KS		 328 if (self.window_sequence != ONLY_LONG_SEQUENCE) &&
329 (self.window_sequence != LONG_START_SEQUENCE) {
330 println!("incorrect previous window");
331 }
5a932f64
KS		 332 },
333 LONG_START_SEQUENCE | EIGHT_SHORT_SEQUENCE => {
d4547e6a
KS		 334 if (self.window_sequence != EIGHT_SHORT_SEQUENCE) &&
335 (self.window_sequence != LONG_STOP_SEQUENCE) {
336 println!("incorrect previous window");
337 }
5a932f64
KS		 338 },
339 _ => {},
340 };
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;
352 }
353 }
354 } else {
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)?;
359 }
360 Ok(())
361 }
362 fn get_group_start(&self, g: usize) -> usize {
363 if g == 0 {
364 0
365 } else if g >= self.window_groups {
366 if self.long_win { 1 } else { 8 }
367 } else {
368 self.group_start[g]
369 }
370 }
371}
372
373#[derive(Clone,Copy)]
374struct LTPData {
375}
376
377impl LTPData {
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); }
381unimplemented!("predictor data");
382/*
383 if is_main {
384 let predictor_reset = br.read_bool()?;
385 if predictor_reset {
386 let predictor_reset_group_number = br.read(5)?;
387 }
388 for sfb in 0..max_sfb.min(PRED_SFB_MAX) {
389 prediction_used[sfb] = br.read_bool()?;
390 }
391 } else {
392 let ltp_data_present = br.read_bool()?;
393 if ltp_data_present {
394 //ltp data
395 }
396 if common_window {
397 let ltp_data_present = br.read_bool()?;
398 if ltp_data_present {
399 //ltp data
400 }
190f8cf0 401 }
5a932f64
KS		 402 }
403 Ok(Some(Self { }))
404*/
405 }
406}
407
408#[derive(Clone,Copy)]
409#[allow(dead_code)]
410struct PulseData {
411 number_pulse: usize,
412 pulse_start_sfb: usize,
413 pulse_offset: [u8; 4],
414 pulse_amp: [u8; 4],
415}
416
417impl PulseData {
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); }
421
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;
429 }
430 Ok(Some(Self{ number_pulse, pulse_start_sfb, pulse_offset, pulse_amp }))
431 }
432}
433
434const TNS_MAX_ORDER: usize = 20;
435const TNS_MAX_LONG_BANDS: [usize; 12] = [ 31, 31, 34, 40, 42, 51, 46, 46, 42, 42, 42, 39 ];
436const TNS_MAX_SHORT_BANDS: [usize; 12] = [ 9, 9, 10, 14, 14, 14, 14, 14, 14, 14, 14, 14 ];
437
438#[derive(Clone,Copy)]
439struct TNSCoeffs {
440 length: usize,
441 order: usize,
442 direction: bool,
443 compress: bool,
444 coef: [f32; TNS_MAX_ORDER + 1],
445}
446
447impl TNSCoeffs {
448 fn new() -> Self {
449 Self {
450 length: 0, order: 0, direction: false, compress: false, coef: [0.0; TNS_MAX_ORDER + 1],
451 }
452 }
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);
457 if self.order > 0 {
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);
465
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];
c83013a1 470 for el in tmp.iter_mut().take(self.order) {
5a932f64 471 let val = br.read(coef_bits)? as i8;
c83013a1
KS		 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();
5a932f64
KS		 474 }
475 // convert to LPC coefficients
476 let mut b: [f32; TNS_MAX_ORDER + 1] = [0.0; TNS_MAX_ORDER + 1];
c83013a1 477 for m in 1..=self.order {
5a932f64
KS		 478 for i in 1..m {
479 b[i] = self.coef[i - 1] + tmp[m - 1] * self.coef[m - i - 1];
480 }
481 for i in 1..m {
482 self.coef[i - 1] = b[i];
483 }
484 self.coef[m - 1] = tmp[m - 1];
485 }
486 }
487 Ok(())
488 }
489}
490
491#[derive(Clone,Copy)]
492#[allow(dead_code)]
493struct TNSData {
494 n_filt: [usize; MAX_WINDOWS],
495 coef_res: [bool; MAX_WINDOWS],
496 coeffs: [[TNSCoeffs; 4]; MAX_WINDOWS],
497}
498
499impl TNSData {
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;
508 if n_filt[w] != 0 {
509 coef_res[w] = br.read_bool()?;
510 }
511 for filt in 0..n_filt[w] {
512 coeffs[w][filt].read(br, long_win, coef_res[w], max_order)?;
513 }
514 }
515 Ok(Some(Self { n_filt, coef_res, coeffs }))
516 }
517}
518
519#[derive(Clone,Copy)]
520#[allow(dead_code)]
521struct GainControlData {
522 max_band: u8,
523}
524
525impl 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); }
529unimplemented!("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
533...
534 }
535 Ok(Some(Self { }))*/
536 }
537}
538
539const ZERO_HCB: u8 = 0;
540const FIRST_PAIR_HCB: u8 = 5;
541const ESC_HCB: u8 = 11;
542const RESERVED_HCB: u8 = 12;
543const NOISE_HCB: u8 = 13;
544const INTENSITY_HCB2: u8 = 14;
545const INTENSITY_HCB: u8 = 15;
546
547struct Codebooks {
548 scale_cb: Codebook<i8>,
549 spec_cb: [Codebook<u16>; 11],
550}
551
552fn scale_map(idx: usize) -> i8 { (idx as i8) - 60 }
553fn cb_map(idx: usize) -> u16 { idx as u16 }
554
555impl Codebooks {
556 fn new() -> Self {
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();
fd8666bc
KS		 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());
564 }
565 uspec_cb.assume_init()
566 };
5a932f64
KS		 567 Self { scale_cb, spec_cb }
568 }
569}
570
571#[derive(Clone)]
572struct ICS {
573 global_gain: u8,
574 info: ICSInfo,
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,
584 coeffs: [f32; 1024],
585 delay: [f32; 1024],
586}
587
588const INTENSITY_SCALE_MIN: i16 = -155;
589const NOISE_SCALE_MIN: i16 = -100;
590impl ICS {
591 fn new(sbinfo: GASubbandInfo) -> Self {
592 Self {
593 global_gain: 0,
594 info: ICSInfo::new(),
595 pulse_data: None,
596 tns_data: None,
597 gain_control: None,
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],
603 sbinfo,
604 coeffs: [0.0; 1024],
605 delay: [0.0; 1024],
606 }
607 }
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;
611
612 for g in 0..self.info.window_groups {
613 let mut k = 0;
614 let mut l = 0;
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);
621 }
622 loop {
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; }
626 }
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];
630 k += 1;
631 }
632 l += 1;
633 }
634 self.num_sec[g] = l;
635 }
636 Ok(())
637 }
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)
640 }
641 fn get_intensity_dir(&self, g: usize, sfb: usize) -> bool {
642 self.sfb_cb[g][sfb] == INTENSITY_HCB
643 }
644 fn decode_scale_factor_data(&mut self, br: &mut BitReader, codebooks: &Codebooks) -> DecoderResult<()> {
645 let mut noise_pcm_flag = true;
c83013a1 646 let mut scf_normal = i16::from(self.global_gain);
5a932f64
KS		 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) {
c83013a1 653 let diff = i16::from(br.read_cb(&codebooks.scale_cb)?);
5a932f64
KS		 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;
c83013a1
KS		 657 } else if self.sfb_cb[g][sfb] == NOISE_HCB {
658 if noise_pcm_flag {
659 noise_pcm_flag = false;
660 scf_noise = (br.read(9)? as i16) - 256 + i16::from(self.global_gain) - 90;
5a932f64 661 } else {
c83013a1 662 scf_noise += i16::from(br.read_cb(&codebooks.scale_cb)?);
5a932f64 663 }
c83013a1
KS		 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;
666 } else {
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;
5a932f64
KS		 670 }
671 }
672 }
673 }
674 Ok(())
675 }
676 fn get_band_start(&self, swb: usize) -> usize {
677 if self.info.long_win {
678 self.sbinfo.long_bands[swb]
679 } else {
680 self.sbinfo.short_bands[swb]
681 }
682 }
683 fn get_num_bands(&self) -> usize {
684 if self.info.long_win {
685 self.sbinfo.long_bands.len() - 1
686 } else {
687 self.sbinfo.short_bands.len() - 1
688 }
689 }
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];
701 match cb_idx {
702 ZERO_HCB => { /* zeroes */ },
703 NOISE_HCB => { /* noise */ },
704 INTENSITY_HCB | INTENSITY_HCB2 => { /* intensity */ },
705 _ => {
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)?;
711 } else {
712 decode_pairs(br, cb, unsigned, cb_idx == ESC_HCB,
713 AAC_CODEBOOK_MODULO[(cb_idx - FIRST_PAIR_HCB) as usize], scale, dst)?;
714 }
715 },
716 };
717 }
718 }
719 }
720 Ok(())
721 }
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];
733 if base != 0.0 {
734 base = requant(self.coeffs[k], scale);
735 }
736 if base > 0.0 {
c83013a1 737 base += f32::from(pdata.pulse_amp[pno]);
5a932f64 738 } else {
c83013a1 739 base -= f32::from(pdata.pulse_amp[pno]);
5a932f64
KS		 740 }
741 self.coeffs[k] = iquant(base) * scale;
742 }
743 }
744 }
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;
747 if !common_window {
748 self.info.decode_ics_info(br)?;
749 }
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);
754 let tns_max_order;
755 if !self.info.long_win {
756 tns_max_order = 7;
757 } else if m4atype == M4AType::LC {
758 tns_max_order = 12;
759 } else {
760 tns_max_order = TNS_MAX_ORDER;
761 }
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)?;
765 } else {
766 let gain_control_data_present = br.read_bool()?;
767 validate!(!gain_control_data_present);
768 }
769 self.decode_spectrum(br, codebooks)?;
770 Ok(())
771 }
772 fn synth_channel(&mut self, dsp: &mut DSP, dst: &mut [f32], srate_idx: usize) {
773 self.place_pulses();
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]
777 } else {
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] {
783 let top = bottom;
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;
b103b7b2
KS		 790 let mut state = [0.0f32; 64];
791 let mut sidx = 32;
5a932f64
KS		 792 if !tns_data.coeffs[w][f].direction {
793 for m in start..end {
b103b7b2
KS		 794 for i in 0..order {
795 self.coeffs[m] -= state[(sidx + i) & 63] * lpc[i];
5a932f64 796 }
b103b7b2
KS		 797 sidx = (sidx + 63) & 63;
798 state[sidx] = self.coeffs[m];
5a932f64
KS		 799 }
800 } else {
801 for m in (start..end).rev() {
b103b7b2
KS		 802 for i in 0..order {
803 self.coeffs[m] -= state[(sidx + i) & 63] * lpc[i];
5a932f64 804 }
b103b7b2
KS		 805 sidx = (sidx + 63) & 63;
806 state[sidx] = self.coeffs[m];
5a932f64
KS		 807 }
808 }
809 }
810 }
811 }
812 dsp.synth(&self.coeffs, &mut self.delay, self.info.window_sequence, self.info.window_shape, self.info.prev_window_shape, dst);
813 }
814}
815
816fn get_scale(scale: u8) -> f32 {
c83013a1 817 2.0f32.powf(0.25 * (f32::from(scale) - 100.0 - 56.0))
5a932f64
KS		 818}
819fn iquant(val: f32) -> f32 {
820 if val < 0.0 {
821 -((-val).powf(4.0 / 3.0))
822 } else {
823 val.powf(4.0 / 3.0)
824 }
825}
826fn requant(val: f32, scale: f32) -> f32 {
827 if scale == 0.0 { return 0.0; }
828 let bval = val / scale;
829 if bval >= 0.0 {
830 val.powf(3.0 / 4.0)
831 } else {
832 -((-val).powf(3.0 / 4.0))
833 }
834}
835fn 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;
838 if unsigned {
839 for i in 0..4 {
840 let val = AAC_QUADS[cw][i];
841 if val != 0 {
842 if br.read_bool()? {
c83013a1 843 out[i] = iquant(-f32::from(val)) * scale;
5a932f64 844 } else {
c83013a1 845 out[i] = iquant( f32::from(val)) * scale;
5a932f64
KS		 846 }
847 }
848 }
849 } else {
850 for i in 0..4 {
c83013a1 851 out[i] = iquant(f32::from(AAC_QUADS[cw][i] - 1)) * scale;
5a932f64
KS		 852 }
853 }
854 }
855 Ok(())
856}
857fn 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;
862 if unsigned {
863 if x != 0 && br.read_bool()? {
864 x = -x;
865 }
866 if y != 0 && br.read_bool()? {
867 y = -y;
868 }
869 } else {
870 x -= (modulo >> 1) as i16;
871 y -= (modulo >> 1) as i16;
872 }
873 if escape {
874 if (x == 16) || (x == -16) {
875 x += read_escape(br, x > 0)?;
876 }
877 if (y == 16) || (y == -16) {
878 y += read_escape(br, y > 0)?;
879 }
880 }
c83013a1
KS		 881 out[0] = iquant(f32::from(x)) * scale;
882 out[1] = iquant(f32::from(y)) * scale;
5a932f64
KS		 883 }
884 Ok(())
885}
886fn 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;
f5324ff9 890 let bits = bits | (1 << (prefix + 4));
5a932f64
KS		 891 if sign {
892 Ok(bits)
893 } else {
894 Ok(-bits)
895 }
896}
897
898#[derive(Clone)]
899struct ChannelPair {
900 pair: bool,
901 channel: usize,
902 common_window: bool,
903 ms_mask_present: u8,
904 ms_used: [[bool; MAX_SFBS]; MAX_WINDOWS],
905 ics: [ICS; 2],
906}
907
908impl ChannelPair {
909 fn new(pair: bool, channel: usize, sbinfo: GASubbandInfo) -> Self {
910 Self {
911 pair, channel,
912 common_window: false,
913 ms_mask_present: 0,
914 ms_used: [[false; MAX_SFBS]; MAX_WINDOWS],
915 ics: [ICS::new(sbinfo), ICS::new(sbinfo)],
916 }
917 }
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)?;
920 Ok(())
921 }
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;
925 if 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()?;
933 }
934 }
935 }
936 self.ics[1].info = self.ics[0].info;
937 }
938 self.ics[0].decode_ics(br, codebooks, m4atype, common_window, true)?;
ea185f9d 939 self.ics[1].decode_ics(br, codebooks, m4atype, common_window, true)?;
5a932f64
KS		 940 if common_window && self.ms_mask_present != 0 {
941 let mut g = 0;
942 for w in 0..self.ics[0].info.num_windows {
bb5ba87c 943 if w > 0 && !self.ics[0].info.scale_factor_grouping[w - 1] {
5a932f64
KS		 944 g += 1;
945 }
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;
c83013a1 952 let scale = 0.5f32.powf(0.25 * (f32::from(self.ics[0].scales[g][sfb]) + f32::from(INTENSITY_SCALE_MIN)));
5a932f64
KS		 953 if !dir {
954 for i in start..end {
955 self.ics[1].coeffs[i] = scale * self.ics[0].coeffs[i];
956 }
957 } else {
958 for i in start..end {
959 self.ics[1].coeffs[i] = -scale * self.ics[0].coeffs[i];
960 }
961 }
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;
967 }
968 }
969 }
970 }
971 }
972 Ok(())
973 }
974 fn synth_audio(&mut self, dsp: &mut DSP, abuf: &mut NABufferType, srate_idx: usize) {
975 let mut adata = abuf.get_abuf_f32().unwrap();
1a967e6b 976 let output = adata.get_data_mut().unwrap();
5a932f64
KS		 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);
980 if self.pair {
981 self.ics[1].synth_channel(dsp, &mut output[off1..], srate_idx);
982 }
983 }
984}
985
986struct DSP {
987 kbd_long_win: [f32; 1024],
988 kbd_short_win: [f32; 128],
989 sine_long_win: [f32; 1024],
990 sine_short_win: [f32; 128],
991 imdct_long: IMDCT,
992 imdct_short: IMDCT,
993 tmp: [f32; 2048],
994 ew_buf: [f32; 1152],
995}
996
997const SHORT_WIN_POINT0: usize = 512 - 64;
998const SHORT_WIN_POINT1: usize = 512 + 64;
999
1000impl DSP {
1001 fn new() -> Self {
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);
1010 Self {
1011 kbd_long_win, kbd_short_win,
1012 sine_long_win, sine_short_win,
9e78289c
KS		 1013 imdct_long: IMDCT::new(1024 * 2, true),
1014 imdct_short: IMDCT::new(128 * 2, true),
5a932f64
KS		 1015 tmp: [0.0; 2048], ew_buf: [0.0; 1152],
1016 }
1017 }
b7c882c1 1018 #[allow(clippy::cognitive_complexity)]
5a932f64
KS		 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);
1026 } else {
1027 for (ain, aout) in coeffs.chunks(128).zip(self.tmp.chunks_mut(256)) {
1028 self.imdct_short.imdct(ain, aout);
1029 }
1030 self.ew_buf = [0.0; 1152];
1031 for (w, src) in self.tmp.chunks(256).enumerate() {
1032 if w > 0 {
1033 for i in 0..128 {
1034 self.ew_buf[w * 128 + i] += src[i] * short_win[i];
1035 }
1036 } else { // to be left-windowed
1037 for i in 0..128 {
1038 self.ew_buf[i] = src[i];
1039 }
1040 }
1041 for i in 0..128 {
1042 self.ew_buf[w * 128 + i + 128] += src[i + 128] * short_win[127 - i];
1043 }
1044 }
1045 }
1046 if seq == ONLY_LONG_SEQUENCE { // should be the most common case
1047 for i in 0..1024 {
1048 dst[i] = delay[i] + self.tmp[i] * left_long_win[i];
1049 delay[i] = self.tmp[i + 1024] * long_win[1023 - i];
1050 }
1051 return;
1052 }
1053 // output new data
1054 match seq {
1055 ONLY_LONG_SEQUENCE | LONG_START_SEQUENCE => {
1056 for i in 0..1024 {
1057 dst[i] = self.tmp[i] * left_long_win[i] + delay[i];
1058 }
1059 },
1060 EIGHT_SHORT_SEQUENCE => {
1061 for i in 0..SHORT_WIN_POINT0 {
1062 dst[i] = delay[i];
1063 }
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];
1067 }
1068 for i in SHORT_WIN_POINT1..1024 {
1069 let j = i - SHORT_WIN_POINT0;
1070 dst[i] = self.ew_buf[j];
1071 }
1072 },
1073 LONG_STOP_SEQUENCE => {
1074 for i in 0..SHORT_WIN_POINT0 {
1075 dst[i] = delay[i];
1076 }
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];
1079 }
1080 for i in SHORT_WIN_POINT1..1024 {
1081 dst[i] = self.tmp[i];
1082 }
1083 },
1084 _ => unreachable!(""),
1085 };
1086 // save delay
1087 match seq {
1088 ONLY_LONG_SEQUENCE | LONG_STOP_SEQUENCE => {
1089 for i in 0..1024 {
1090 delay[i] = self.tmp[i + 1024] * long_win[1023 - i];
1091 }
1092 },
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];
1096 }
1097 for i in SHORT_WIN_POINT1..1024 {
1098 delay[i] = 0.0;
1099 }
1100 },
1101 LONG_START_SEQUENCE => {
1102 for i in 0..SHORT_WIN_POINT0 {
1103 delay[i] = self.tmp[i + 1024];
1104 }
1105 for i in SHORT_WIN_POINT0..SHORT_WIN_POINT1 {
1106 delay[i] = self.tmp[i + 1024] * short_win[127 - (i - SHORT_WIN_POINT0)];
1107 }
1108 for i in SHORT_WIN_POINT1..1024 {
1109 delay[i] = 0.0;
1110 }
1111 },
1112 _ => unreachable!(""),
1113 };
1114 }
1115}
1116
1117struct AACDecoder {
2422d969 1118 info: NACodecInfoRef,
5a932f64
KS		 1119 chmap: NAChannelMap,
1120 m4ainfo: M4AInfo,
1121 pairs: Vec<ChannelPair>,
1122 codebooks: Codebooks,
1123 dsp: DSP,
1124 sbinfo: GASubbandInfo,
1125}
1126
1127impl AACDecoder {
1128 fn new() -> Self {
1129 AACDecoder {
1130 info: NACodecInfo::new_dummy(),
1131 chmap: NAChannelMap::new(),
1132 m4ainfo: M4AInfo::new(),
1133 pairs: Vec::new(),
1134 codebooks: Codebooks::new(),
1135 dsp: DSP::new(),
1136 sbinfo: AAC_SUBBAND_INFO[0],
1137 }
1138 }
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));
1142 } else {
1143 validate!(self.pairs[pair_no].channel == channel);
1144 validate!(self.pairs[pair_no].pair == pair);
1145 }
1146 validate!(if pair { channel + 1 } else { channel } < self.m4ainfo.channels);
1147 Ok(())
1148 }
1149 fn decode_ga(&mut self, br: &mut BitReader, abuf: &mut NABufferType) -> DecoderResult<()> {
1150 let mut cur_pair = 0;
1151 let mut cur_ch = 0;
1152 while br.left() > 3 {
1153 let id = br.read(3)?;
1154 match id {
1155 0 => { // ID_SCE
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)?;
1159 cur_pair += 1;
1160 cur_ch += 1;
1161 },
1162 1 => { // ID_CPE
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)?;
1166 cur_pair += 1;
1167 cur_ch += 2;
1168 },
1169 2 => { // ID_CCE
1170 unimplemented!("coupling channel element");
1171 },
1172 3 => { // ID_LFE
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)?;
1176 cur_pair += 1;
1177 cur_ch += 1;
1178 },
1179 4 => { // ID_DSE
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
1186 },
1187 5 => { // ID_PCE
1188 unimplemented!("program config");
1189 },
1190 6 => { // ID_FIL
1191 let mut count = br.read(4)? as usize;
1192 if count == 15 {
1193 count += br.read(8)? as usize;
1194 count -= 1;
1195 }
1196 for _ in 0..count {
1197 // ext payload
1198 br.skip(8)?;
1199 }
1200 },
1201 7 => { // ID_TERM
1202 break;
1203 },
1204 _ => { unreachable!(); },
1205 };
1206 }
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);
1210 }
1211 Ok(())
1212 }
1213}
1214
1215impl NADecoder for AACDecoder {
01613464 1216 fn init(&mut self, _supp: &mut NADecoderSupport, info: NACodecInfoRef) -> DecoderResult<()> {
5a932f64
KS		 1217 if let NACodecTypeInfo::Audio(_) = info.get_properties() {
1218 let edata = info.get_extradata().unwrap();
1219 validate!(edata.len() >= 2);
1220
1221//print!("edata:"); for s in edata.iter() { print!(" {:02X}", *s);}println!("");
009c5158
KS		 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());
1227 br.read_skip(8)?;
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()?;
1232 let mut size = 0;
1233 loop {
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 {
1238 break;
1239 }
1240 }
1241 match tag {
1242 3 => {
1243 br.read_u16be()?;
1244 let flags = br.read_byte()?;
1245 if (flags & 0x80) != 0 {
1246 br.read_u16be()?;
1247 }
1248 if (flags & 0x40) != 0 {
1249 let len = br.read_byte()?;
1250 br.read_skip(len as usize)?;
1251 }
1252 if (flags & 0x20) != 0 {
1253 br.read_u16be()?;
1254 }
1255 },
1256 4 => {
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()?;
1262 },
1263 5 => {
1264 info_start = br.tell() as usize;
1265 info_size = size as usize;
1266 break;
1267 },
1268 _ => br.read_skip(size as usize)?,
1269 }
1270 }
1271 validate!(info_start > 0 && info_size > 0);
1272 self.m4ainfo.read(&edata[info_start..][..info_size])?;
1273 } else {
1274 self.m4ainfo.read(&edata)?;
1275 }
5a932f64
KS		 1276
1277 //println!("{}", self.m4ainfo);
1278 if (self.m4ainfo.otype != M4AType::LC) || (self.m4ainfo.channels > 2) || (self.m4ainfo.samples != 1024) {
1279 return Err(DecoderError::NotImplemented);
1280 }
1281 self.sbinfo = GASubbandInfo::find(self.m4ainfo.srate);
1282
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));
1286
1287 if self.m4ainfo.channels >= DEFAULT_CHANNEL_MAP.len() {
1288 return Err(DecoderError::NotImplemented);
1289 }
1290 let chmap_str = DEFAULT_CHANNEL_MAP[self.m4ainfo.channels];
c83013a1 1291 if chmap_str.is_empty() { return Err(DecoderError::NotImplemented); }
5a932f64
KS		 1292 self.chmap = NAChannelMap::from_str(chmap_str).unwrap();
1293
1294 Ok(())
1295 } else {
1296 Err(DecoderError::InvalidData)
1297 }
1298 }
01613464 1299 fn decode(&mut self, _supp: &mut NADecoderSupport, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
5a932f64
KS		 1300 let info = pkt.get_stream().get_info();
1301 validate!(info.get_properties().is_audio());
1302 let pktbuf = pkt.get_buffer();
1303
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())?;
1306
fa90ccfb 1307 let mut br = BitReader::new(&pktbuf, BitReaderMode::BE);
5a932f64
KS		 1308 match self.m4ainfo.otype {
1309 M4AType::LC => {
1310 self.decode_ga(&mut br, &mut abuf)?;
1311 },
1312 _ => { unimplemented!(""); }
1313 }
1314
1315 let mut frm = NAFrame::new_from_pkt(pkt, self.info.replace_info(NACodecTypeInfo::Audio(ainfo)), abuf);
1316 frm.set_keyframe(true);
171860fc 1317 Ok(frm.into_ref())
5a932f64 1318 }
f9be4e75
KS		 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];
1323 }
1324 }
5a932f64
KS		 1325}
1326
7d57ae2f
KS		 1327impl 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 }
1331}
1332
08a1fab7 1333pub fn get_decoder() -> Box<dyn NADecoder + Send> {
5a932f64
KS		 1334 Box::new(AACDecoder::new())
1335}
1336
1337#[cfg(test)]
1338mod test {
4f6124ac
KS		 1339 use nihav_core::codecs::RegisteredDecoders;
1340 use nihav_core::demuxers::RegisteredDemuxers;
ce742854 1341 use nihav_codec_support::test::dec_video::test_decode_audio;
ef0b99e6 1342 use crate::mpeg_register_all_decoders;
e64739f8 1343 use nihav_realmedia::realmedia_register_all_demuxers;
5a932f64
KS		 1344 #[test]
1345 fn test_aac() {
4f6124ac
KS		 1346 let mut dmx_reg = RegisteredDemuxers::new();
1347 realmedia_register_all_demuxers(&mut dmx_reg);
1348 let mut dec_reg = RegisteredDecoders::new();
ef0b99e6 1349 mpeg_register_all_decoders(&mut dec_reg);
4f6124ac 1350
5a932f64
KS		 1351// let file = "assets/RV/rv40_weighted_mc.rmvb";
1352 let file = "assets/RV/rv40_weighted_mc_2.rmvb";
5580b11b 1353 test_decode_audio("realmedia", file, Some(12000), None/*Some("aac")*/, &dmx_reg, &dec_reg);
5a932f64
KS		 1354 }
1355}
1356
1357const 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
1366];
1367
1368const 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,
1384 0x7FFF3
1385];
1386
1387const 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,
1393 11
1394];
1395const 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,
1406 0x7f4
1407];
1408const 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,
1414 9
1415];
1416const 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,
1427 0x1f6
1428];
1429const 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,
1435 15
1436];
1437const 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,
1448 0x7ffa
1449];
1450const 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,
1456 11
1457];
1458const 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,
1469 0x7fc
1470];
1471const 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,
1477 13
1478];
1479const 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,
1490 0x1ffe
1491];
1492const 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,
1498 11
1499];
1500const 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,
1511 0x7fc
1512];
1513const 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
1518];
1519const 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
1528];
1529const 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
1534];
1535const 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
1544];
1545const 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
1557];
1558const 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,
1580 0x7fff
1581];
1582const 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
1594];
1595const 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,
1617 0xfff
1618];
1619const 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,
1638 5
1639];
1640const 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,
1677 0x004
1678];
1679
1680const 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
1684];
1685const 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
1689];
1690const AAC_UNSIGNED_CODEBOOK: [bool; 11] = [
1691 false, false, true, true, false, false, true, true, true, true, true
1692];
1693const AAC_CODEBOOK_MODULO: [u16; 7] = [
1694 9, 9, 8, 8, 13, 13, 17
1695];
1696
1697const 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 ],
1725];
1726
1727const DEFAULT_CHANNEL_MAP: [&str; 9] = [
1728 "",
1729 "C",
1730 "L,R",
1731 "C,L,R",
1732 "C,L,R,Cs",
1733 "C,L,R,Ls,Rs",
1734 "C,L,R,Ls,Rs,LFE",
1735 "",
1736 "C,L,R,Ls,Rs,Lss,Rss,LFE",
1737];
1738
1739const 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,
1746 928, 1024
1747];
1748const SWB_OFFSET_48K_SHORT: [usize; 14+1] = [
1749 0, 4, 8, 12, 16, 20, 28, 36, 44, 56, 68, 80, 96, 112, 128
1750];
1751const 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,
1758 928, 960, 992, 1024
1759];
1760const 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,
1766 1024
1767];
1768const SWB_OFFSET_8K_SHORT: [usize; 15+1] = [
1769 0, 4, 8, 12, 16, 20, 24, 28, 36, 44, 52, 60, 72, 88, 108, 128
1770];
1771const 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,
1777 832, 896, 960, 1024
1778];
1779const SWB_OFFSET_16K_SHORT: [usize; 15+1] = [
1780 0, 4, 8, 12, 16, 20, 24, 28, 32, 40, 48, 60, 72, 88, 108, 128
1781];
1782const 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
1789];
1790const SWB_OFFSET_24K_SHORT: [usize; 15+1] = [
1791 0, 4, 8, 12, 16, 20, 24, 28, 36, 44, 52, 64, 76, 92, 108, 128
1792];
1793const 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
1800];
1801const SWB_OFFSET_64K_SHORT: [usize; 12+1] = [
1802 0, 4, 8, 12, 16, 20, 24, 32, 40, 48, 64, 92, 128
1803];
1804const 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,
1810 960, 1024
1811];
1812
1813#[derive(Clone,Copy)]
1814struct GASubbandInfo {
1815 min_srate: u32,
1816 long_bands: &'static [usize],
1817 short_bands: &'static [usize],
1818}
1819
1820impl GASubbandInfo {
1821 fn find(srate: u32) -> GASubbandInfo {
c83013a1
KS		 1822 for sbi in AAC_SUBBAND_INFO.iter() {
1823 if srate >= sbi.min_srate {
1824 return *sbi;
5a932f64
KS		 1825 }
1826 }
1827 unreachable!("")
1828 }
1829 fn find_idx(srate: u32) -> usize {
c83013a1
KS		 1830 for (i, sbi) in AAC_SUBBAND_INFO.iter().enumerate() {
1831 if srate >= sbi.min_srate {
5a932f64
KS		 1832 return i;
1833 }
1834 }
1835 unreachable!("")
1836 }
1837}
1838
1839const 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
1852];
NihAV is a research multimedia framework