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