]>
Commit | Line | Data |
---|---|---|
38953fb5 KS |
1 | use nihav_core::formats::*; |
2 | use nihav_core::frame::*; | |
3 | use nihav_core::codecs::*; | |
b4d5b851 KS |
4 | use nihav_codec_support::dsp::mdct::IMDCT; |
5 | use nihav_codec_support::dsp::window::*; | |
38953fb5 | 6 | use nihav_core::io::bitreader::*; |
009c5158 | 7 | use nihav_core::io::byteio::*; |
38953fb5 | 8 | use nihav_core::io::codebook::*; |
5a932f64 | 9 | use std::fmt; |
38953fb5 | 10 | use nihav_core::io::intcode::*; |
5a932f64 KS |
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<()> { | |
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 | ||
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 => { | |
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)] | |
374 | struct LTPData { | |
375 | } | |
376 | ||
377 | impl 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); } | |
381 | unimplemented!("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)] | |
410 | struct PulseData { | |
411 | number_pulse: usize, | |
412 | pulse_start_sfb: usize, | |
413 | pulse_offset: [u8; 4], | |
414 | pulse_amp: [u8; 4], | |
415 | } | |
416 | ||
417 | impl 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 | ||
434 | const TNS_MAX_ORDER: usize = 20; | |
435 | const TNS_MAX_LONG_BANDS: [usize; 12] = [ 31, 31, 34, 40, 42, 51, 46, 46, 42, 42, 42, 39 ]; | |
436 | const TNS_MAX_SHORT_BANDS: [usize; 12] = [ 9, 9, 10, 14, 14, 14, 14, 14, 14, 14, 14, 14 ]; | |
437 | ||
438 | #[derive(Clone,Copy)] | |
439 | struct TNSCoeffs { | |
440 | length: usize, | |
441 | order: usize, | |
442 | direction: bool, | |
443 | compress: bool, | |
444 | coef: [f32; TNS_MAX_ORDER + 1], | |
445 | } | |
446 | ||
447 | impl 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)] | |
493 | struct TNSData { | |
494 | n_filt: [usize; MAX_WINDOWS], | |
495 | coef_res: [bool; MAX_WINDOWS], | |
496 | coeffs: [[TNSCoeffs; 4]; MAX_WINDOWS], | |
497 | } | |
498 | ||
499 | impl 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)] | |
521 | struct GainControlData { | |
522 | max_band: u8, | |
523 | } | |
524 | ||
525 | impl GainControlData { | |
526 | fn read(br: &mut BitReader) -> DecoderResult<Option<Self>> { | |
527 | let gain_control_data_present = br.read_bool()?; | |
528 | if !gain_control_data_present { return Ok(None); } | |
529 | unimplemented!("gain control data"); | |
530 | /* self.max_band = br.read(2)? as u8; | |
531 | if window_sequence == ONLY_LONG_SEQUENCE { | |
532 | for bd in 0..max_band | |
533 | ... | |
534 | } | |
535 | Ok(Some(Self { }))*/ | |
536 | } | |
537 | } | |
538 | ||
539 | const ZERO_HCB: u8 = 0; | |
540 | const FIRST_PAIR_HCB: u8 = 5; | |
541 | const ESC_HCB: u8 = 11; | |
542 | const RESERVED_HCB: u8 = 12; | |
543 | const NOISE_HCB: u8 = 13; | |
544 | const INTENSITY_HCB2: u8 = 14; | |
545 | const INTENSITY_HCB: u8 = 15; | |
546 | ||
547 | struct Codebooks { | |
548 | scale_cb: Codebook<i8>, | |
549 | spec_cb: [Codebook<u16>; 11], | |
550 | } | |
551 | ||
552 | fn scale_map(idx: usize) -> i8 { (idx as i8) - 60 } | |
553 | fn cb_map(idx: usize) -> u16 { idx as u16 } | |
554 | ||
555 | impl 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(); | |
559 | let mut spec_cb: [Codebook<u16>; 11]; | |
560 | unsafe { | |
561 | spec_cb = mem::uninitialized(); | |
562 | for i in 0..AAC_SPEC_CODES.len() { | |
563 | let mut coderead = TableCodebookDescReader::new(AAC_SPEC_CODES[i], AAC_SPEC_BITS[i], cb_map); | |
564 | ptr::write(&mut spec_cb[i], Codebook::new(&mut coderead, CodebookMode::MSB).unwrap()); | |
565 | } | |
566 | } | |
567 | Self { scale_cb, spec_cb } | |
568 | } | |
569 | } | |
570 | ||
571 | #[derive(Clone)] | |
572 | struct 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 | ||
588 | const INTENSITY_SCALE_MIN: i16 = -155; | |
589 | const NOISE_SCALE_MIN: i16 = -100; | |
590 | impl 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 | ||
816 | fn get_scale(scale: u8) -> f32 { | |
c83013a1 | 817 | 2.0f32.powf(0.25 * (f32::from(scale) - 100.0 - 56.0)) |
5a932f64 KS |
818 | } |
819 | fn 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 | } | |
826 | fn 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 | } | |
835 | fn decode_quads(br: &mut BitReader, cb: &Codebook<u16>, unsigned: bool, scale: f32, dst: &mut [f32]) -> DecoderResult<()> { | |
836 | for out in dst.chunks_mut(4) { | |
837 | let cw = br.read_cb(cb)? as usize; | |
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 | } | |
857 | fn decode_pairs(br: &mut BitReader, cb: &Codebook<u16>, unsigned: bool, escape: bool, modulo: u16, scale: f32, dst: &mut [f32]) -> DecoderResult<()> { | |
858 | for out in dst.chunks_mut(2) { | |
859 | let cw = br.read_cb(cb)?; | |
860 | let mut x = (cw / modulo) as i16; | |
861 | let mut y = (cw % modulo) as i16; | |
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 | } | |
886 | fn read_escape(br: &mut BitReader, sign: bool) -> DecoderResult<i16> { | |
887 | let prefix = br.read_code(UintCodeType::UnaryOnes)? as u8; | |
888 | validate!(prefix < 9); | |
889 | let bits = br.read(prefix + 4)? as i16; | |
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)] | |
899 | struct 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 | ||
908 | impl 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 | ||
986 | struct 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 | ||
997 | const SHORT_WIN_POINT0: usize = 512 - 64; | |
998 | const SHORT_WIN_POINT1: usize = 512 + 64; | |
999 | ||
1000 | impl 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 | } | |
61cab15b | 1018 | #[allow(clippy::cyclomatic_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 | ||
1117 | struct 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 | ||
1127 | impl 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 | ||
1215 | impl 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 |
1327 | impl NAOptionHandler for AACDecoder { |
1328 | fn get_supported_options(&self) -> &[NAOptionDefinition] { &[] } | |
1329 | fn set_options(&mut self, _options: &[NAOption]) { } | |
1330 | fn query_option_value(&self, _name: &str) -> Option<NAValue> { None } | |
1331 | } | |
1332 | ||
08a1fab7 | 1333 | pub fn get_decoder() -> Box<dyn NADecoder + Send> { |
5a932f64 KS |
1334 | Box::new(AACDecoder::new()) |
1335 | } | |
1336 | ||
1337 | #[cfg(test)] | |
1338 | mod 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; |
78fb6560 | 1342 | use crate::generic_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(); | |
78fb6560 | 1349 | generic_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 | ||
1357 | const AAC_SCF_CODEBOOK_BITS: &[u8] = &[ | |
1358 | 18, 18, 18, 18, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, | |
1359 | 19, 19, 19, 18, 19, 18, 17, 17, 16, 17, 16, 16, 16, 16, 15, 15, | |
1360 | 14, 14, 14, 14, 14, 14, 13, 13, 12, 12, 12, 11, 12, 11, 10, 10, | |
1361 | 10, 9, 9, 8, 8, 8, 7, 6, 6, 5, 4, 3, 1, 4, 4, 5, | |
1362 | 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 10, 11, 11, 11, 11, 12, | |
1363 | 12, 13, 13, 13, 14, 14, 16, 15, 16, 15, 18, 19, 19, 19, 19, 19, | |
1364 | 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, | |
1365 | 19, 19, 19, 19, 19, 19, 19, 19, 19 | |
1366 | ]; | |
1367 | ||
1368 | const AAC_SCF_CODEBOOK_CODES: &[u32] = &[ | |
1369 | 0x3FFE8, 0x3FFE6, 0x3FFE7, 0x3FFE5, 0x7FFF5, 0x7FFF1, 0x7FFED, 0x7FFF6, | |
1370 | 0x7FFEE, 0x7FFEF, 0x7FFF0, 0x7FFFC, 0x7FFFD, 0x7FFFF, 0x7FFFE, 0x7FFF7, | |
1371 | 0x7FFF8, 0x7FFFB, 0x7FFF9, 0x3FFE4, 0x7FFFA, 0x3FFE3, 0x1FFEF, 0x1FFF0, | |
1372 | 0x0FFF5, 0x1FFEE, 0x0FFF2, 0x0FFF3, 0x0FFF4, 0x0FFF1, 0x07FF6, 0x07FF7, | |
1373 | 0x03FF9, 0x03FF5, 0x03FF7, 0x03FF3, 0x03FF6, 0x03FF2, 0x01FF7, 0x01FF5, | |
1374 | 0x00FF9, 0x00FF7, 0x00FF6, 0x007F9, 0x00FF4, 0x007F8, 0x003F9, 0x003F7, | |
1375 | 0x003F5, 0x001F8, 0x001F7, 0x000FA, 0x000F8, 0x000F6, 0x00079, 0x0003A, | |
1376 | 0x00038, 0x0001A, 0x0000B, 0x00004, 0x00000, 0x0000A, 0x0000C, 0x0001B, | |
1377 | 0x00039, 0x0003B, 0x00078, 0x0007A, 0x000F7, 0x000F9, 0x001F6, 0x001F9, | |
1378 | 0x003F4, 0x003F6, 0x003F8, 0x007F5, 0x007F4, 0x007F6, 0x007F7, 0x00FF5, | |
1379 | 0x00FF8, 0x01FF4, 0x01FF6, 0x01FF8, 0x03FF8, 0x03FF4, 0x0FFF0, 0x07FF4, | |
1380 | 0x0FFF6, 0x07FF5, 0x3FFE2, 0x7FFD9, 0x7FFDA, 0x7FFDB, 0x7FFDC, 0x7FFDD, | |
1381 | 0x7FFDE, 0x7FFD8, 0x7FFD2, 0x7FFD3, 0x7FFD4, 0x7FFD5, 0x7FFD6, 0x7FFF2, | |
1382 | 0x7FFDF, 0x7FFE7, 0x7FFE8, 0x7FFE9, 0x7FFEA, 0x7FFEB, 0x7FFE6, 0x7FFE0, | |
1383 | 0x7FFE1, 0x7FFE2, 0x7FFE3, 0x7FFE4, 0x7FFE5, 0x7FFD7, 0x7FFEC, 0x7FFF4, | |
1384 | 0x7FFF3 | |
1385 | ]; | |
1386 | ||
1387 | const AAC_SPEC_CB1_BITS: &[u8] = &[ | |
1388 | 11, 9, 11, 10, 7, 10, 11, 9, 11, 10, 7, 10, 7, 5, 7, 9, | |
1389 | 7, 10, 11, 9, 11, 9, 7, 9, 11, 9, 11, 9, 7, 9, 7, 5, | |
1390 | 7, 9, 7, 9, 7, 5, 7, 5, 1, 5, 7, 5, 7, 9, 7, 9, | |
1391 | 7, 5, 7, 9, 7, 9, 11, 9, 11, 9, 7, 9, 11, 9, 11, 10, | |
1392 | 7, 9, 7, 5, 7, 9, 7, 10, 11, 9, 11, 10, 7, 9, 11, 9, | |
1393 | 11 | |
1394 | ]; | |
1395 | const AAC_SPEC_CB1_CODES: &[u16] = &[ | |
1396 | 0x7f8, 0x1f1, 0x7fd, 0x3f5, 0x068, 0x3f0, 0x7f7, 0x1ec, | |
1397 | 0x7f5, 0x3f1, 0x072, 0x3f4, 0x074, 0x011, 0x076, 0x1eb, | |
1398 | 0x06c, 0x3f6, 0x7fc, 0x1e1, 0x7f1, 0x1f0, 0x061, 0x1f6, | |
1399 | 0x7f2, 0x1ea, 0x7fb, 0x1f2, 0x069, 0x1ed, 0x077, 0x017, | |
1400 | 0x06f, 0x1e6, 0x064, 0x1e5, 0x067, 0x015, 0x062, 0x012, | |
1401 | 0x000, 0x014, 0x065, 0x016, 0x06d, 0x1e9, 0x063, 0x1e4, | |
1402 | 0x06b, 0x013, 0x071, 0x1e3, 0x070, 0x1f3, 0x7fe, 0x1e7, | |
1403 | 0x7f3, 0x1ef, 0x060, 0x1ee, 0x7f0, 0x1e2, 0x7fa, 0x3f3, | |
1404 | 0x06a, 0x1e8, 0x075, 0x010, 0x073, 0x1f4, 0x06e, 0x3f7, | |
1405 | 0x7f6, 0x1e0, 0x7f9, 0x3f2, 0x066, 0x1f5, 0x7ff, 0x1f7, | |
1406 | 0x7f4 | |
1407 | ]; | |
1408 | const AAC_SPEC_CB2_BITS: &[u8] = &[ | |
1409 | 9, 7, 9, 8, 6, 8, 9, 8, 9, 8, 6, 7, 6, 5, 6, 7, | |
1410 | 6, 8, 9, 7, 8, 8, 6, 8, 9, 7, 9, 8, 6, 7, 6, 5, | |
1411 | 6, 7, 6, 8, 6, 5, 6, 5, 3, 5, 6, 5, 6, 8, 6, 7, | |
1412 | 6, 5, 6, 8, 6, 8, 9, 7, 9, 8, 6, 8, 8, 7, 9, 8, | |
1413 | 6, 7, 6, 4, 6, 8, 6, 7, 9, 7, 9, 7, 6, 8, 9, 7, | |
1414 | 9 | |
1415 | ]; | |
1416 | const AAC_SPEC_CB2_CODES: &[u16] = &[ | |
1417 | 0x1f3, 0x06f, 0x1fd, 0x0eb, 0x023, 0x0ea, 0x1f7, 0x0e8, | |
1418 | 0x1fa, 0x0f2, 0x02d, 0x070, 0x020, 0x006, 0x02b, 0x06e, | |
1419 | 0x028, 0x0e9, 0x1f9, 0x066, 0x0f8, 0x0e7, 0x01b, 0x0f1, | |
1420 | 0x1f4, 0x06b, 0x1f5, 0x0ec, 0x02a, 0x06c, 0x02c, 0x00a, | |
1421 | 0x027, 0x067, 0x01a, 0x0f5, 0x024, 0x008, 0x01f, 0x009, | |
1422 | 0x000, 0x007, 0x01d, 0x00b, 0x030, 0x0ef, 0x01c, 0x064, | |
1423 | 0x01e, 0x00c, 0x029, 0x0f3, 0x02f, 0x0f0, 0x1fc, 0x071, | |
1424 | 0x1f2, 0x0f4, 0x021, 0x0e6, 0x0f7, 0x068, 0x1f8, 0x0ee, | |
1425 | 0x022, 0x065, 0x031, 0x002, 0x026, 0x0ed, 0x025, 0x06a, | |
1426 | 0x1fb, 0x072, 0x1fe, 0x069, 0x02e, 0x0f6, 0x1ff, 0x06d, | |
1427 | 0x1f6 | |
1428 | ]; | |
1429 | const AAC_SPEC_CB3_BITS: &[u8] = &[ | |
1430 | 1, 4, 8, 4, 5, 8, 9, 9, 10, 4, 6, 9, 6, 6, 9, 9, | |
1431 | 9, 10, 9, 10, 13, 9, 9, 11, 11, 10, 12, 4, 6, 10, 6, 7, | |
1432 | 10, 10, 10, 12, 5, 7, 11, 6, 7, 10, 9, 9, 11, 9, 10, 13, | |
1433 | 8, 9, 12, 10, 11, 12, 8, 10, 15, 9, 11, 15, 13, 14, 16, 8, | |
1434 | 10, 14, 9, 10, 14, 12, 12, 15, 11, 12, 16, 10, 11, 15, 12, 12, | |
1435 | 15 | |
1436 | ]; | |
1437 | const AAC_SPEC_CB3_CODES: &[u16] = &[ | |
1438 | 0x0000, 0x0009, 0x00ef, 0x000b, 0x0019, 0x00f0, 0x01eb, 0x01e6, | |
1439 | 0x03f2, 0x000a, 0x0035, 0x01ef, 0x0034, 0x0037, 0x01e9, 0x01ed, | |
1440 | 0x01e7, 0x03f3, 0x01ee, 0x03ed, 0x1ffa, 0x01ec, 0x01f2, 0x07f9, | |
1441 | 0x07f8, 0x03f8, 0x0ff8, 0x0008, 0x0038, 0x03f6, 0x0036, 0x0075, | |
1442 | 0x03f1, 0x03eb, 0x03ec, 0x0ff4, 0x0018, 0x0076, 0x07f4, 0x0039, | |
1443 | 0x0074, 0x03ef, 0x01f3, 0x01f4, 0x07f6, 0x01e8, 0x03ea, 0x1ffc, | |
1444 | 0x00f2, 0x01f1, 0x0ffb, 0x03f5, 0x07f3, 0x0ffc, 0x00ee, 0x03f7, | |
1445 | 0x7ffe, 0x01f0, 0x07f5, 0x7ffd, 0x1ffb, 0x3ffa, 0xffff, 0x00f1, | |
1446 | 0x03f0, 0x3ffc, 0x01ea, 0x03ee, 0x3ffb, 0x0ff6, 0x0ffa, 0x7ffc, | |
1447 | 0x07f2, 0x0ff5, 0xfffe, 0x03f4, 0x07f7, 0x7ffb, 0x0ff7, 0x0ff9, | |
1448 | 0x7ffa | |
1449 | ]; | |
1450 | const AAC_SPEC_CB4_BITS: &[u8] = &[ | |
1451 | 4, 5, 8, 5, 4, 8, 9, 8, 11, 5, 5, 8, 5, 4, 8, 8, | |
1452 | 7, 10, 9, 8, 11, 8, 8, 10, 11, 10, 11, 4, 5, 8, 4, 4, | |
1453 | 8, 8, 8, 10, 4, 4, 8, 4, 4, 7, 8, 7, 9, 8, 8, 10, | |
1454 | 7, 7, 9, 10, 9, 10, 8, 8, 11, 8, 7, 10, 11, 10, 12, 8, | |
1455 | 7, 10, 7, 7, 9, 10, 9, 11, 11, 10, 12, 10, 9, 11, 11, 10, | |
1456 | 11 | |
1457 | ]; | |
1458 | const AAC_SPEC_CB4_CODES: &[u16] = &[ | |
1459 | 0x007, 0x016, 0x0f6, 0x018, 0x008, 0x0ef, 0x1ef, 0x0f3, | |
1460 | 0x7f8, 0x019, 0x017, 0x0ed, 0x015, 0x001, 0x0e2, 0x0f0, | |
1461 | 0x070, 0x3f0, 0x1ee, 0x0f1, 0x7fa, 0x0ee, 0x0e4, 0x3f2, | |
1462 | 0x7f6, 0x3ef, 0x7fd, 0x005, 0x014, 0x0f2, 0x009, 0x004, | |
1463 | 0x0e5, 0x0f4, 0x0e8, 0x3f4, 0x006, 0x002, 0x0e7, 0x003, | |
1464 | 0x000, 0x06b, 0x0e3, 0x069, 0x1f3, 0x0eb, 0x0e6, 0x3f6, | |
1465 | 0x06e, 0x06a, 0x1f4, 0x3ec, 0x1f0, 0x3f9, 0x0f5, 0x0ec, | |
1466 | 0x7fb, 0x0ea, 0x06f, 0x3f7, 0x7f9, 0x3f3, 0xfff, 0x0e9, | |
1467 | 0x06d, 0x3f8, 0x06c, 0x068, 0x1f5, 0x3ee, 0x1f2, 0x7f4, | |
1468 | 0x7f7, 0x3f1, 0xffe, 0x3ed, 0x1f1, 0x7f5, 0x7fe, 0x3f5, | |
1469 | 0x7fc | |
1470 | ]; | |
1471 | const AAC_SPEC_CB5_BITS: &[u8] = &[ | |
1472 | 13, 12, 11, 11, 10, 11, 11, 12, 13, 12, 11, 10, 9, 8, 9, 10, | |
1473 | 11, 12, 12, 10, 9, 8, 7, 8, 9, 10, 11, 11, 9, 8, 5, 4, | |
1474 | 5, 8, 9, 11, 10, 8, 7, 4, 1, 4, 7, 8, 11, 11, 9, 8, | |
1475 | 5, 4, 5, 8, 9, 11, 11, 10, 9, 8, 7, 8, 9, 10, 11, 12, | |
1476 | 11, 10, 9, 8, 9, 10, 11, 12, 13, 12, 12, 11, 10, 10, 11, 12, | |
1477 | 13 | |
1478 | ]; | |
1479 | const AAC_SPEC_CB5_CODES: &[u16] = &[ | |
1480 | 0x1fff, 0x0ff7, 0x07f4, 0x07e8, 0x03f1, 0x07ee, 0x07f9, 0x0ff8, | |
1481 | 0x1ffd, 0x0ffd, 0x07f1, 0x03e8, 0x01e8, 0x00f0, 0x01ec, 0x03ee, | |
1482 | 0x07f2, 0x0ffa, 0x0ff4, 0x03ef, 0x01f2, 0x00e8, 0x0070, 0x00ec, | |
1483 | 0x01f0, 0x03ea, 0x07f3, 0x07eb, 0x01eb, 0x00ea, 0x001a, 0x0008, | |
1484 | 0x0019, 0x00ee, 0x01ef, 0x07ed, 0x03f0, 0x00f2, 0x0073, 0x000b, | |
1485 | 0x0000, 0x000a, 0x0071, 0x00f3, 0x07e9, 0x07ef, 0x01ee, 0x00ef, | |
1486 | 0x0018, 0x0009, 0x001b, 0x00eb, 0x01e9, 0x07ec, 0x07f6, 0x03eb, | |
1487 | 0x01f3, 0x00ed, 0x0072, 0x00e9, 0x01f1, 0x03ed, 0x07f7, 0x0ff6, | |
1488 | 0x07f0, 0x03e9, 0x01ed, 0x00f1, 0x01ea, 0x03ec, 0x07f8, 0x0ff9, | |
1489 | 0x1ffc, 0x0ffc, 0x0ff5, 0x07ea, 0x03f3, 0x03f2, 0x07f5, 0x0ffb, | |
1490 | 0x1ffe | |
1491 | ]; | |
1492 | const AAC_SPEC_CB6_BITS: &[u8] = &[ | |
1493 | 11, 10, 9, 9, 9, 9, 9, 10, 11, 10, 9, 8, 7, 7, 7, 8, | |
1494 | 9, 10, 9, 8, 6, 6, 6, 6, 6, 8, 9, 9, 7, 6, 4, 4, | |
1495 | 4, 6, 7, 9, 9, 7, 6, 4, 4, 4, 6, 7, 9, 9, 7, 6, | |
1496 | 4, 4, 4, 6, 7, 9, 9, 8, 6, 6, 6, 6, 6, 8, 9, 10, | |
1497 | 9, 8, 7, 7, 7, 7, 8, 10, 11, 10, 9, 9, 9, 9, 9, 10, | |
1498 | 11 | |
1499 | ]; | |
1500 | const AAC_SPEC_CB6_CODES: &[u16] = &[ | |
1501 | 0x7fe, 0x3fd, 0x1f1, 0x1eb, 0x1f4, 0x1ea, 0x1f0, 0x3fc, | |
1502 | 0x7fd, 0x3f6, 0x1e5, 0x0ea, 0x06c, 0x071, 0x068, 0x0f0, | |
1503 | 0x1e6, 0x3f7, 0x1f3, 0x0ef, 0x032, 0x027, 0x028, 0x026, | |
1504 | 0x031, 0x0eb, 0x1f7, 0x1e8, 0x06f, 0x02e, 0x008, 0x004, | |
1505 | 0x006, 0x029, 0x06b, 0x1ee, 0x1ef, 0x072, 0x02d, 0x002, | |
1506 | 0x000, 0x003, 0x02f, 0x073, 0x1fa, 0x1e7, 0x06e, 0x02b, | |
1507 | 0x007, 0x001, 0x005, 0x02c, 0x06d, 0x1ec, 0x1f9, 0x0ee, | |
1508 | 0x030, 0x024, 0x02a, 0x025, 0x033, 0x0ec, 0x1f2, 0x3f8, | |
1509 | 0x1e4, 0x0ed, 0x06a, 0x070, 0x069, 0x074, 0x0f1, 0x3fa, | |
1510 | 0x7ff, 0x3f9, 0x1f6, 0x1ed, 0x1f8, 0x1e9, 0x1f5, 0x3fb, | |
1511 | 0x7fc | |
1512 | ]; | |
1513 | const AAC_SPEC_CB7_BITS: &[u8] = &[ | |
1514 | 1, 3, 6, 7, 8, 9, 10, 11, 3, 4, 6, 7, 8, 8, 9, 9, | |
1515 | 6, 6, 7, 8, 8, 9, 9, 10, 7, 7, 8, 8, 9, 9, 10, 10, | |
1516 | 8, 8, 9, 9, 10, 10, 10, 11, 9, 8, 9, 9, 10, 10, 11, 11, | |
1517 | 10, 9, 9, 10, 10, 11, 12, 12, 11, 10, 10, 10, 11, 11, 12, 12 | |
1518 | ]; | |
1519 | const AAC_SPEC_CB7_CODES: &[u16] = &[ | |
1520 | 0x000, 0x005, 0x037, 0x074, 0x0f2, 0x1eb, 0x3ed, 0x7f7, | |
1521 | 0x004, 0x00c, 0x035, 0x071, 0x0ec, 0x0ee, 0x1ee, 0x1f5, | |
1522 | 0x036, 0x034, 0x072, 0x0ea, 0x0f1, 0x1e9, 0x1f3, 0x3f5, | |
1523 | 0x073, 0x070, 0x0eb, 0x0f0, 0x1f1, 0x1f0, 0x3ec, 0x3fa, | |
1524 | 0x0f3, 0x0ed, 0x1e8, 0x1ef, 0x3ef, 0x3f1, 0x3f9, 0x7fb, | |
1525 | 0x1ed, 0x0ef, 0x1ea, 0x1f2, 0x3f3, 0x3f8, 0x7f9, 0x7fc, | |
1526 | 0x3ee, 0x1ec, 0x1f4, 0x3f4, 0x3f7, 0x7f8, 0xffd, 0xffe, | |
1527 | 0x7f6, 0x3f0, 0x3f2, 0x3f6, 0x7fa, 0x7fd, 0xffc, 0xfff | |
1528 | ]; | |
1529 | const AAC_SPEC_CB8_BITS: &[u8] = &[ | |
1530 | 5, 4, 5, 6, 7, 8, 9, 10, 4, 3, 4, 5, 6, 7, 7, 8, | |
1531 | 5, 4, 4, 5, 6, 7, 7, 8, 6, 5, 5, 6, 6, 7, 8, 8, | |
1532 | 7, 6, 6, 6, 7, 7, 8, 9, 8, 7, 6, 7, 7, 8, 8, 10, | |
1533 | 9, 7, 7, 8, 8, 8, 9, 9, 10, 8, 8, 8, 9, 9, 9, 10 | |
1534 | ]; | |
1535 | const AAC_SPEC_CB8_CODES: &[u16] = &[ | |
1536 | 0x00e, 0x005, 0x010, 0x030, 0x06f, 0x0f1, 0x1fa, 0x3fe, | |
1537 | 0x003, 0x000, 0x004, 0x012, 0x02c, 0x06a, 0x075, 0x0f8, | |
1538 | 0x00f, 0x002, 0x006, 0x014, 0x02e, 0x069, 0x072, 0x0f5, | |
1539 | 0x02f, 0x011, 0x013, 0x02a, 0x032, 0x06c, 0x0ec, 0x0fa, | |
1540 | 0x071, 0x02b, 0x02d, 0x031, 0x06d, 0x070, 0x0f2, 0x1f9, | |
1541 | 0x0ef, 0x068, 0x033, 0x06b, 0x06e, 0x0ee, 0x0f9, 0x3fc, | |
1542 | 0x1f8, 0x074, 0x073, 0x0ed, 0x0f0, 0x0f6, 0x1f6, 0x1fd, | |
1543 | 0x3fd, 0x0f3, 0x0f4, 0x0f7, 0x1f7, 0x1fb, 0x1fc, 0x3ff | |
1544 | ]; | |
1545 | const AAC_SPEC_CB9_BITS: &[u8] = &[ | |
1546 | 1, 3, 6, 8, 9, 10, 10, 11, 11, 12, 12, 13, 13, 3, 4, 6, | |
1547 | 7, 8, 8, 9, 10, 10, 10, 11, 12, 12, 6, 6, 7, 8, 8, 9, | |
1548 | 10, 10, 10, 11, 12, 12, 12, 8, 7, 8, 9, 9, 10, 10, 11, 11, | |
1549 | 11, 12, 12, 13, 9, 8, 9, 9, 10, 10, 11, 11, 11, 12, 12, 12, | |
1550 | 13, 10, 9, 9, 10, 11, 11, 11, 12, 11, 12, 12, 13, 13, 11, 9, | |
1551 | 10, 11, 11, 11, 12, 12, 12, 12, 13, 13, 13, 11, 10, 10, 11, 11, | |
1552 | 12, 12, 13, 13, 13, 13, 13, 13, 11, 10, 10, 11, 11, 11, 12, 12, | |
1553 | 13, 13, 14, 13, 14, 11, 10, 11, 11, 12, 12, 12, 12, 13, 13, 14, | |
1554 | 14, 14, 12, 11, 11, 12, 12, 12, 13, 13, 13, 14, 14, 14, 15, 12, | |
1555 | 11, 12, 12, 12, 13, 13, 13, 13, 14, 14, 15, 15, 13, 12, 12, 12, | |
1556 | 13, 13, 13, 13, 14, 14, 14, 14, 15 | |
1557 | ]; | |
1558 | const AAC_SPEC_CB9_CODES: &[u16] = &[ | |
1559 | 0x0000, 0x0005, 0x0037, 0x00e7, 0x01de, 0x03ce, 0x03d9, 0x07c8, | |
1560 | 0x07cd, 0x0fc8, 0x0fdd, 0x1fe4, 0x1fec, 0x0004, 0x000c, 0x0035, | |
1561 | 0x0072, 0x00ea, 0x00ed, 0x01e2, 0x03d1, 0x03d3, 0x03e0, 0x07d8, | |
1562 | 0x0fcf, 0x0fd5, 0x0036, 0x0034, 0x0071, 0x00e8, 0x00ec, 0x01e1, | |
1563 | 0x03cf, 0x03dd, 0x03db, 0x07d0, 0x0fc7, 0x0fd4, 0x0fe4, 0x00e6, | |
1564 | 0x0070, 0x00e9, 0x01dd, 0x01e3, 0x03d2, 0x03dc, 0x07cc, 0x07ca, | |
1565 | 0x07de, 0x0fd8, 0x0fea, 0x1fdb, 0x01df, 0x00eb, 0x01dc, 0x01e6, | |
1566 | 0x03d5, 0x03de, 0x07cb, 0x07dd, 0x07dc, 0x0fcd, 0x0fe2, 0x0fe7, | |
1567 | 0x1fe1, 0x03d0, 0x01e0, 0x01e4, 0x03d6, 0x07c5, 0x07d1, 0x07db, | |
1568 | 0x0fd2, 0x07e0, 0x0fd9, 0x0feb, 0x1fe3, 0x1fe9, 0x07c4, 0x01e5, | |
1569 | 0x03d7, 0x07c6, 0x07cf, 0x07da, 0x0fcb, 0x0fda, 0x0fe3, 0x0fe9, | |
1570 | 0x1fe6, 0x1ff3, 0x1ff7, 0x07d3, 0x03d8, 0x03e1, 0x07d4, 0x07d9, | |
1571 | 0x0fd3, 0x0fde, 0x1fdd, 0x1fd9, 0x1fe2, 0x1fea, 0x1ff1, 0x1ff6, | |
1572 | 0x07d2, 0x03d4, 0x03da, 0x07c7, 0x07d7, 0x07e2, 0x0fce, 0x0fdb, | |
1573 | 0x1fd8, 0x1fee, 0x3ff0, 0x1ff4, 0x3ff2, 0x07e1, 0x03df, 0x07c9, | |
1574 | 0x07d6, 0x0fca, 0x0fd0, 0x0fe5, 0x0fe6, 0x1feb, 0x1fef, 0x3ff3, | |
1575 | 0x3ff4, 0x3ff5, 0x0fe0, 0x07ce, 0x07d5, 0x0fc6, 0x0fd1, 0x0fe1, | |
1576 | 0x1fe0, 0x1fe8, 0x1ff0, 0x3ff1, 0x3ff8, 0x3ff6, 0x7ffc, 0x0fe8, | |
1577 | 0x07df, 0x0fc9, 0x0fd7, 0x0fdc, 0x1fdc, 0x1fdf, 0x1fed, 0x1ff5, | |
1578 | 0x3ff9, 0x3ffb, 0x7ffd, 0x7ffe, 0x1fe7, 0x0fcc, 0x0fd6, 0x0fdf, | |
1579 | 0x1fde, 0x1fda, 0x1fe5, 0x1ff2, 0x3ffa, 0x3ff7, 0x3ffc, 0x3ffd, | |
1580 | 0x7fff | |
1581 | ]; | |
1582 | const AAC_SPEC_CB10_BITS: &[u8] = &[ | |
1583 | 6, 5, 6, 6, 7, 8, 9, 10, 10, 10, 11, 11, 12, 5, 4, 4, | |
1584 | 5, 6, 7, 7, 8, 8, 9, 10, 10, 11, 6, 4, 5, 5, 6, 6, | |
1585 | 7, 8, 8, 9, 9, 10, 10, 6, 5, 5, 5, 6, 7, 7, 8, 8, | |
1586 | 9, 9, 10, 10, 7, 6, 6, 6, 6, 7, 7, 8, 8, 9, 9, 10, | |
1587 | 10, 8, 7, 6, 7, 7, 7, 8, 8, 8, 9, 10, 10, 11, 9, 7, | |
1588 | 7, 7, 7, 8, 8, 9, 9, 9, 10, 10, 11, 9, 8, 8, 8, 8, | |
1589 | 8, 9, 9, 9, 10, 10, 11, 11, 9, 8, 8, 8, 8, 8, 9, 9, | |
1590 | 10, 10, 10, 11, 11, 10, 9, 9, 9, 9, 9, 9, 10, 10, 10, 11, | |
1591 | 11, 12, 10, 9, 9, 9, 9, 10, 10, 10, 10, 11, 11, 11, 12, 11, | |
1592 | 10, 9, 10, 10, 10, 10, 10, 11, 11, 11, 11, 12, 11, 10, 10, 10, | |
1593 | 10, 10, 10, 11, 11, 12, 12, 12, 12 | |
1594 | ]; | |
1595 | const AAC_SPEC_CB10_CODES: &[u16] = &[ | |
1596 | 0x022, 0x008, 0x01d, 0x026, 0x05f, 0x0d3, 0x1cf, 0x3d0, | |
1597 | 0x3d7, 0x3ed, 0x7f0, 0x7f6, 0xffd, 0x007, 0x000, 0x001, | |
1598 | 0x009, 0x020, 0x054, 0x060, 0x0d5, 0x0dc, 0x1d4, 0x3cd, | |
1599 | 0x3de, 0x7e7, 0x01c, 0x002, 0x006, 0x00c, 0x01e, 0x028, | |
1600 | 0x05b, 0x0cd, 0x0d9, 0x1ce, 0x1dc, 0x3d9, 0x3f1, 0x025, | |
1601 | 0x00b, 0x00a, 0x00d, 0x024, 0x057, 0x061, 0x0cc, 0x0dd, | |
1602 | 0x1cc, 0x1de, 0x3d3, 0x3e7, 0x05d, 0x021, 0x01f, 0x023, | |
1603 | 0x027, 0x059, 0x064, 0x0d8, 0x0df, 0x1d2, 0x1e2, 0x3dd, | |
1604 | 0x3ee, 0x0d1, 0x055, 0x029, 0x056, 0x058, 0x062, 0x0ce, | |
1605 | 0x0e0, 0x0e2, 0x1da, 0x3d4, 0x3e3, 0x7eb, 0x1c9, 0x05e, | |
1606 | 0x05a, 0x05c, 0x063, 0x0ca, 0x0da, 0x1c7, 0x1ca, 0x1e0, | |
1607 | 0x3db, 0x3e8, 0x7ec, 0x1e3, 0x0d2, 0x0cb, 0x0d0, 0x0d7, | |
1608 | 0x0db, 0x1c6, 0x1d5, 0x1d8, 0x3ca, 0x3da, 0x7ea, 0x7f1, | |
1609 | 0x1e1, 0x0d4, 0x0cf, 0x0d6, 0x0de, 0x0e1, 0x1d0, 0x1d6, | |
1610 | 0x3d1, 0x3d5, 0x3f2, 0x7ee, 0x7fb, 0x3e9, 0x1cd, 0x1c8, | |
1611 | 0x1cb, 0x1d1, 0x1d7, 0x1df, 0x3cf, 0x3e0, 0x3ef, 0x7e6, | |
1612 | 0x7f8, 0xffa, 0x3eb, 0x1dd, 0x1d3, 0x1d9, 0x1db, 0x3d2, | |
1613 | 0x3cc, 0x3dc, 0x3ea, 0x7ed, 0x7f3, 0x7f9, 0xff9, 0x7f2, | |
1614 | 0x3ce, 0x1e4, 0x3cb, 0x3d8, 0x3d6, 0x3e2, 0x3e5, 0x7e8, | |
1615 | 0x7f4, 0x7f5, 0x7f7, 0xffb, 0x7fa, 0x3ec, 0x3df, 0x3e1, | |
1616 | 0x3e4, 0x3e6, 0x3f0, 0x7e9, 0x7ef, 0xff8, 0xffe, 0xffc, | |
1617 | 0xfff | |
1618 | ]; | |
1619 | const AAC_SPEC_CB11_BITS: &[u8] = &[ | |
1620 | 4, 5, 6, 7, 8, 8, 9, 10, 10, 10, 11, 11, 12, 11, 12, 12, | |
1621 | 10, 5, 4, 5, 6, 7, 7, 8, 8, 9, 9, 9, 10, 10, 10, 10, | |
1622 | 11, 8, 6, 5, 5, 6, 7, 7, 8, 8, 8, 9, 9, 9, 10, 10, | |
1623 | 10, 10, 8, 7, 6, 6, 6, 7, 7, 8, 8, 8, 9, 9, 9, 10, | |
1624 | 10, 10, 10, 8, 8, 7, 7, 7, 7, 8, 8, 8, 8, 9, 9, 9, | |
1625 | 10, 10, 10, 10, 8, 8, 7, 7, 7, 7, 8, 8, 8, 9, 9, 9, | |
1626 | 9, 10, 10, 10, 10, 8, 9, 8, 8, 8, 8, 8, 8, 8, 9, 9, | |
1627 | 9, 10, 10, 10, 10, 10, 8, 9, 8, 8, 8, 8, 8, 8, 9, 9, | |
1628 | 9, 10, 10, 10, 10, 10, 10, 8, 10, 9, 8, 8, 9, 9, 9, 9, | |
1629 | 9, 10, 10, 10, 10, 10, 10, 11, 8, 10, 9, 9, 9, 9, 9, 9, | |
1630 | 9, 10, 10, 10, 10, 10, 10, 11, 11, 8, 11, 9, 9, 9, 9, 9, | |
1631 | 9, 10, 10, 10, 10, 10, 11, 10, 11, 11, 8, 11, 10, 9, 9, 10, | |
1632 | 9, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 8, 11, 10, 10, 10, | |
1633 | 10, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 9, 11, 10, 9, | |
1634 | 9, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11, 9, 11, 10, | |
1635 | 10, 10, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11, 9, 12, | |
1636 | 10, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11, 12, 12, 9, | |
1637 | 9, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 9, | |
1638 | 5 | |
1639 | ]; | |
1640 | const AAC_SPEC_CB11_CODES: &[u16] = &[ | |
1641 | 0x000, 0x006, 0x019, 0x03d, 0x09c, 0x0c6, 0x1a7, 0x390, | |
1642 | 0x3c2, 0x3df, 0x7e6, 0x7f3, 0xffb, 0x7ec, 0xffa, 0xffe, | |
1643 | 0x38e, 0x005, 0x001, 0x008, 0x014, 0x037, 0x042, 0x092, | |
1644 | 0x0af, 0x191, 0x1a5, 0x1b5, 0x39e, 0x3c0, 0x3a2, 0x3cd, | |
1645 | 0x7d6, 0x0ae, 0x017, 0x007, 0x009, 0x018, 0x039, 0x040, | |
1646 | 0x08e, 0x0a3, 0x0b8, 0x199, 0x1ac, 0x1c1, 0x3b1, 0x396, | |
1647 | 0x3be, 0x3ca, 0x09d, 0x03c, 0x015, 0x016, 0x01a, 0x03b, | |
1648 | 0x044, 0x091, 0x0a5, 0x0be, 0x196, 0x1ae, 0x1b9, 0x3a1, | |
1649 | 0x391, 0x3a5, 0x3d5, 0x094, 0x09a, 0x036, 0x038, 0x03a, | |
1650 | 0x041, 0x08c, 0x09b, 0x0b0, 0x0c3, 0x19e, 0x1ab, 0x1bc, | |
1651 | 0x39f, 0x38f, 0x3a9, 0x3cf, 0x093, 0x0bf, 0x03e, 0x03f, | |
1652 | 0x043, 0x045, 0x09e, 0x0a7, 0x0b9, 0x194, 0x1a2, 0x1ba, | |
1653 | 0x1c3, 0x3a6, 0x3a7, 0x3bb, 0x3d4, 0x09f, 0x1a0, 0x08f, | |
1654 | 0x08d, 0x090, 0x098, 0x0a6, 0x0b6, 0x0c4, 0x19f, 0x1af, | |
1655 | 0x1bf, 0x399, 0x3bf, 0x3b4, 0x3c9, 0x3e7, 0x0a8, 0x1b6, | |
1656 | 0x0ab, 0x0a4, 0x0aa, 0x0b2, 0x0c2, 0x0c5, 0x198, 0x1a4, | |
1657 | 0x1b8, 0x38c, 0x3a4, 0x3c4, 0x3c6, 0x3dd, 0x3e8, 0x0ad, | |
1658 | 0x3af, 0x192, 0x0bd, 0x0bc, 0x18e, 0x197, 0x19a, 0x1a3, | |
1659 | 0x1b1, 0x38d, 0x398, 0x3b7, 0x3d3, 0x3d1, 0x3db, 0x7dd, | |
1660 | 0x0b4, 0x3de, 0x1a9, 0x19b, 0x19c, 0x1a1, 0x1aa, 0x1ad, | |
1661 | 0x1b3, 0x38b, 0x3b2, 0x3b8, 0x3ce, 0x3e1, 0x3e0, 0x7d2, | |
1662 | 0x7e5, 0x0b7, 0x7e3, 0x1bb, 0x1a8, 0x1a6, 0x1b0, 0x1b2, | |
1663 | 0x1b7, 0x39b, 0x39a, 0x3ba, 0x3b5, 0x3d6, 0x7d7, 0x3e4, | |
1664 | 0x7d8, 0x7ea, 0x0ba, 0x7e8, 0x3a0, 0x1bd, 0x1b4, 0x38a, | |
1665 | 0x1c4, 0x392, 0x3aa, 0x3b0, 0x3bc, 0x3d7, 0x7d4, 0x7dc, | |
1666 | 0x7db, 0x7d5, 0x7f0, 0x0c1, 0x7fb, 0x3c8, 0x3a3, 0x395, | |
1667 | 0x39d, 0x3ac, 0x3ae, 0x3c5, 0x3d8, 0x3e2, 0x3e6, 0x7e4, | |
1668 | 0x7e7, 0x7e0, 0x7e9, 0x7f7, 0x190, 0x7f2, 0x393, 0x1be, | |
1669 | 0x1c0, 0x394, 0x397, 0x3ad, 0x3c3, 0x3c1, 0x3d2, 0x7da, | |
1670 | 0x7d9, 0x7df, 0x7eb, 0x7f4, 0x7fa, 0x195, 0x7f8, 0x3bd, | |
1671 | 0x39c, 0x3ab, 0x3a8, 0x3b3, 0x3b9, 0x3d0, 0x3e3, 0x3e5, | |
1672 | 0x7e2, 0x7de, 0x7ed, 0x7f1, 0x7f9, 0x7fc, 0x193, 0xffd, | |
1673 | 0x3dc, 0x3b6, 0x3c7, 0x3cc, 0x3cb, 0x3d9, 0x3da, 0x7d3, | |
1674 | 0x7e1, 0x7ee, 0x7ef, 0x7f5, 0x7f6, 0xffc, 0xfff, 0x19d, | |
1675 | 0x1c2, 0x0b5, 0x0a1, 0x096, 0x097, 0x095, 0x099, 0x0a0, | |
1676 | 0x0a2, 0x0ac, 0x0a9, 0x0b1, 0x0b3, 0x0bb, 0x0c0, 0x18f, | |
1677 | 0x004 | |
1678 | ]; | |
1679 | ||
1680 | const AAC_SPEC_BITS: [&[u8]; 11] = [ | |
1681 | AAC_SPEC_CB1_BITS, AAC_SPEC_CB2_BITS, AAC_SPEC_CB3_BITS, AAC_SPEC_CB4_BITS, | |
1682 | AAC_SPEC_CB5_BITS, AAC_SPEC_CB6_BITS, AAC_SPEC_CB7_BITS, AAC_SPEC_CB8_BITS, | |
1683 | AAC_SPEC_CB9_BITS, AAC_SPEC_CB10_BITS, AAC_SPEC_CB11_BITS | |
1684 | ]; | |
1685 | const AAC_SPEC_CODES: [&[u16]; 11] = [ | |
1686 | AAC_SPEC_CB1_CODES, AAC_SPEC_CB2_CODES, AAC_SPEC_CB3_CODES, AAC_SPEC_CB4_CODES, | |
1687 | AAC_SPEC_CB5_CODES, AAC_SPEC_CB6_CODES, AAC_SPEC_CB7_CODES, AAC_SPEC_CB8_CODES, | |
1688 | AAC_SPEC_CB9_CODES, AAC_SPEC_CB10_CODES, AAC_SPEC_CB11_CODES | |
1689 | ]; | |
1690 | const AAC_UNSIGNED_CODEBOOK: [bool; 11] = [ | |
1691 | false, false, true, true, false, false, true, true, true, true, true | |
1692 | ]; | |
1693 | const AAC_CODEBOOK_MODULO: [u16; 7] = [ | |
1694 | 9, 9, 8, 8, 13, 13, 17 | |
1695 | ]; | |
1696 | ||
1697 | const AAC_QUADS: [[i8; 4]; 81] = [ | |
1698 | [ 0, 0, 0, 0 ], [ 0, 0, 0, 1 ], [ 0, 0, 0, 2 ], | |
1699 | [ 0, 0, 1, 0 ], [ 0, 0, 1, 1 ], [ 0, 0, 1, 2 ], | |
1700 | [ 0, 0, 2, 0 ], [ 0, 0, 2, 1 ], [ 0, 0, 2, 2 ], | |
1701 | [ 0, 1, 0, 0 ], [ 0, 1, 0, 1 ], [ 0, 1, 0, 2 ], | |
1702 | [ 0, 1, 1, 0 ], [ 0, 1, 1, 1 ], [ 0, 1, 1, 2 ], | |
1703 | [ 0, 1, 2, 0 ], [ 0, 1, 2, 1 ], [ 0, 1, 2, 2 ], | |
1704 | [ 0, 2, 0, 0 ], [ 0, 2, 0, 1 ], [ 0, 2, 0, 2 ], | |
1705 | [ 0, 2, 1, 0 ], [ 0, 2, 1, 1 ], [ 0, 2, 1, 2 ], | |
1706 | [ 0, 2, 2, 0 ], [ 0, 2, 2, 1 ], [ 0, 2, 2, 2 ], | |
1707 | [ 1, 0, 0, 0 ], [ 1, 0, 0, 1 ], [ 1, 0, 0, 2 ], | |
1708 | [ 1, 0, 1, 0 ], [ 1, 0, 1, 1 ], [ 1, 0, 1, 2 ], | |
1709 | [ 1, 0, 2, 0 ], [ 1, 0, 2, 1 ], [ 1, 0, 2, 2 ], | |
1710 | [ 1, 1, 0, 0 ], [ 1, 1, 0, 1 ], [ 1, 1, 0, 2 ], | |
1711 | [ 1, 1, 1, 0 ], [ 1, 1, 1, 1 ], [ 1, 1, 1, 2 ], | |
1712 | [ 1, 1, 2, 0 ], [ 1, 1, 2, 1 ], [ 1, 1, 2, 2 ], | |
1713 | [ 1, 2, 0, 0 ], [ 1, 2, 0, 1 ], [ 1, 2, 0, 2 ], | |
1714 | [ 1, 2, 1, 0 ], [ 1, 2, 1, 1 ], [ 1, 2, 1, 2 ], | |
1715 | [ 1, 2, 2, 0 ], [ 1, 2, 2, 1 ], [ 1, 2, 2, 2 ], | |
1716 | [ 2, 0, 0, 0 ], [ 2, 0, 0, 1 ], [ 2, 0, 0, 2 ], | |
1717 | [ 2, 0, 1, 0 ], [ 2, 0, 1, 1 ], [ 2, 0, 1, 2 ], | |
1718 | [ 2, 0, 2, 0 ], [ 2, 0, 2, 1 ], [ 2, 0, 2, 2 ], | |
1719 | [ 2, 1, 0, 0 ], [ 2, 1, 0, 1 ], [ 2, 1, 0, 2 ], | |
1720 | [ 2, 1, 1, 0 ], [ 2, 1, 1, 1 ], [ 2, 1, 1, 2 ], | |
1721 | [ 2, 1, 2, 0 ], [ 2, 1, 2, 1 ], [ 2, 1, 2, 2 ], | |
1722 | [ 2, 2, 0, 0 ], [ 2, 2, 0, 1 ], [ 2, 2, 0, 2 ], | |
1723 | [ 2, 2, 1, 0 ], [ 2, 2, 1, 1 ], [ 2, 2, 1, 2 ], | |
1724 | [ 2, 2, 2, 0 ], [ 2, 2, 2, 1 ], [ 2, 2, 2, 2 ], | |
1725 | ]; | |
1726 | ||
1727 | const 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 | ||
1739 | const SWB_OFFSET_48K_LONG: [usize; 49+1] = [ | |
1740 | 0, 4, 8, 12, 16, 20, 24, 28, | |
1741 | 32, 36, 40, 48, 56, 64, 72, 80, | |
1742 | 88, 96, 108, 120, 132, 144, 160, 176, | |
1743 | 196, 216, 240, 264, 292, 320, 352, 384, | |
1744 | 416, 448, 480, 512, 544, 576, 608, 640, | |
1745 | 672, 704, 736, 768, 800, 832, 864, 896, | |
1746 | 928, 1024 | |
1747 | ]; | |
1748 | const SWB_OFFSET_48K_SHORT: [usize; 14+1] = [ | |
1749 | 0, 4, 8, 12, 16, 20, 28, 36, 44, 56, 68, 80, 96, 112, 128 | |
1750 | ]; | |
1751 | const SWB_OFFSET_32K_LONG: [usize; 51+1] = [ | |
1752 | 0, 4, 8, 12, 16, 20, 24, 28, | |
1753 | 32, 36, 40, 48, 56, 64, 72, 80, | |
1754 | 88, 96, 108, 120, 132, 144, 160, 176, | |
1755 | 196, 216, 240, 264, 292, 320, 352, 384, | |
1756 | 416, 448, 480, 512, 544, 576, 608, 640, | |
1757 | 672, 704, 736, 768, 800, 832, 864, 896, | |
1758 | 928, 960, 992, 1024 | |
1759 | ]; | |
1760 | const SWB_OFFSET_8K_LONG: [usize; 40+1] = [ | |
1761 | 0, 12, 24, 36, 48, 60, 72, 84, | |
1762 | 96, 108, 120, 132, 144, 156, 172, 188, | |
1763 | 204, 220, 236, 252, 268, 288, 308, 328, | |
1764 | 348, 372, 396, 420, 448, 476, 508, 544, | |
1765 | 580, 620, 664, 712, 764, 820, 880, 944, | |
1766 | 1024 | |
1767 | ]; | |
1768 | const SWB_OFFSET_8K_SHORT: [usize; 15+1] = [ | |
1769 | 0, 4, 8, 12, 16, 20, 24, 28, 36, 44, 52, 60, 72, 88, 108, 128 | |
1770 | ]; | |
1771 | const SWB_OFFSET_16K_LONG: [usize; 43+1] = [ | |
1772 | 0, 8, 16, 24, 32, 40, 48, 56, | |
1773 | 64, 72, 80, 88, 100, 112, 124, 136, | |
1774 | 148, 160, 172, 184, 196, 212, 228, 244, | |
1775 | 260, 280, 300, 320, 344, 368, 396, 424, | |
1776 | 456, 492, 532, 572, 616, 664, 716, 772, | |
1777 | 832, 896, 960, 1024 | |
1778 | ]; | |
1779 | const SWB_OFFSET_16K_SHORT: [usize; 15+1] = [ | |
1780 | 0, 4, 8, 12, 16, 20, 24, 28, 32, 40, 48, 60, 72, 88, 108, 128 | |
1781 | ]; | |
1782 | const SWB_OFFSET_24K_LONG: [usize; 47+1] = [ | |
1783 | 0, 4, 8, 12, 16, 20, 24, 28, | |
1784 | 32, 36, 40, 44, 52, 60, 68, 76, | |
1785 | 84, 92, 100, 108, 116, 124, 136, 148, | |
1786 | 160, 172, 188, 204, 220, 240, 260, 284, | |
1787 | 308, 336, 364, 396, 432, 468, 508, 552, | |
1788 | 600, 652, 704, 768, 832, 896, 960, 1024 | |
1789 | ]; | |
1790 | const SWB_OFFSET_24K_SHORT: [usize; 15+1] = [ | |
1791 | 0, 4, 8, 12, 16, 20, 24, 28, 36, 44, 52, 64, 76, 92, 108, 128 | |
1792 | ]; | |
1793 | const SWB_OFFSET_64K_LONG: [usize; 47+1] = [ | |
1794 | 0, 4, 8, 12, 16, 20, 24, 28, | |
1795 | 32, 36, 40, 44, 48, 52, 56, 64, | |
1796 | 72, 80, 88, 100, 112, 124, 140, 156, | |
1797 | 172, 192, 216, 240, 268, 304, 344, 384, | |
1798 | 424, 464, 504, 544, 584, 624, 664, 704, | |
1799 | 744, 784, 824, 864, 904, 944, 984, 1024 | |
1800 | ]; | |
1801 | const SWB_OFFSET_64K_SHORT: [usize; 12+1] = [ | |
1802 | 0, 4, 8, 12, 16, 20, 24, 32, 40, 48, 64, 92, 128 | |
1803 | ]; | |
1804 | const SWB_OFFSET_96K_LONG: [usize; 41+1] = [ | |
1805 | 0, 4, 8, 12, 16, 20, 24, 28, | |
1806 | 32, 36, 40, 44, 48, 52, 56, 64, | |
1807 | 72, 80, 88, 96, 108, 120, 132, 144, | |
1808 | 156, 172, 188, 212, 240, 276, 320, 384, | |
1809 | 448, 512, 576, 640, 704, 768, 832, 896, | |
1810 | 960, 1024 | |
1811 | ]; | |
1812 | ||
1813 | #[derive(Clone,Copy)] | |
1814 | struct GASubbandInfo { | |
1815 | min_srate: u32, | |
1816 | long_bands: &'static [usize], | |
1817 | short_bands: &'static [usize], | |
1818 | } | |
1819 | ||
1820 | impl 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 | ||
1839 | const AAC_SUBBAND_INFO: [GASubbandInfo; 12] = [ | |
1840 | GASubbandInfo { min_srate: 92017, long_bands: &SWB_OFFSET_96K_LONG, short_bands: &SWB_OFFSET_64K_SHORT }, //96K | |
1841 | GASubbandInfo { min_srate: 75132, long_bands: &SWB_OFFSET_96K_LONG, short_bands: &SWB_OFFSET_64K_SHORT }, //88.2K | |
1842 | GASubbandInfo { min_srate: 55426, long_bands: &SWB_OFFSET_64K_LONG, short_bands: &SWB_OFFSET_64K_SHORT }, //64K | |
1843 | GASubbandInfo { min_srate: 46009, long_bands: &SWB_OFFSET_48K_LONG, short_bands: &SWB_OFFSET_48K_SHORT }, //48K | |
1844 | GASubbandInfo { min_srate: 37566, long_bands: &SWB_OFFSET_48K_LONG, short_bands: &SWB_OFFSET_48K_SHORT }, //44.1K | |
1845 | GASubbandInfo { min_srate: 27713, long_bands: &SWB_OFFSET_32K_LONG, short_bands: &SWB_OFFSET_48K_SHORT }, //32K | |
1846 | GASubbandInfo { min_srate: 23004, long_bands: &SWB_OFFSET_24K_LONG, short_bands: &SWB_OFFSET_24K_SHORT }, //24K | |
1847 | GASubbandInfo { min_srate: 18783, long_bands: &SWB_OFFSET_24K_LONG, short_bands: &SWB_OFFSET_24K_SHORT }, //22.05K | |
1848 | GASubbandInfo { min_srate: 13856, long_bands: &SWB_OFFSET_16K_LONG, short_bands: &SWB_OFFSET_16K_SHORT }, //16K | |
1849 | GASubbandInfo { min_srate: 11502, long_bands: &SWB_OFFSET_16K_LONG, short_bands: &SWB_OFFSET_16K_SHORT }, //12K | |
1850 | GASubbandInfo { min_srate: 9391, long_bands: &SWB_OFFSET_16K_LONG, short_bands: &SWB_OFFSET_16K_SHORT }, //11.025K | |
1851 | GASubbandInfo { min_srate: 0, long_bands: &SWB_OFFSET_8K_LONG, short_bands: &SWB_OFFSET_8K_SHORT }, //8K | |
1852 | ]; |