1use super::bits::BitReader;
11use super::dsp::{scalarproduct, tables, vector_fmul_window};
12use super::tables as t;
13use super::vlc;
14
15#[derive(Debug, Clone, PartialEq, Eq)]
17pub enum AacError {
18 Unsupported(String),
20 Invalid(String),
22}
23
24impl std::fmt::Display for AacError {
25 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
26 match self {
27 AacError::Unsupported(s) => write!(f, "unsupported AAC: {s}"),
28 AacError::Invalid(s) => write!(f, "invalid AAC: {s}"),
29 }
30 }
31}
32
33impl std::error::Error for AacError {}
34
35fn invalid<T>(s: &str) -> Result<T, AacError> {
36 Err(AacError::Invalid(s.into()))
37}
38
39fn unsupported<T>(s: impl Into<String>) -> Result<T, AacError> {
40 Err(AacError::Unsupported(s.into()))
41}
42
43pub const SAMPLE_RATES: [u32; 13] = [96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050, 16000, 12000, 11025, 8000, 7350];
45
46#[derive(Debug, Clone, PartialEq, Eq)]
48pub struct AudioSpecificConfig {
49 pub object_type: u32,
52 pub sampling_index: usize,
54 pub sample_rate: u32,
56 pub chan_config: u32,
58 pub channels: usize,
60 pub sbr: i32,
62 pub ps: i32,
64 pub ext_sample_rate: u32,
66 pub elem_tag: u32,
69}
70
71impl AudioSpecificConfig {
72 pub fn parse(asc: &[u8]) -> Result<Self, AacError> {
75 let mut br = BitReader::new(asc);
76 let get_ot = |br: &mut BitReader| {
77 let o = br.bits(5);
78 if o == 31 {
79 32 + br.bits(6)
80 } else {
81 o
82 }
83 };
84 let get_sr = |br: &mut BitReader| -> (usize, u32) {
85 let i = br.bits(4) as usize;
86 if i == 15 {
87 (i, br.bits(24))
88 } else {
89 (i, SAMPLE_RATES.get(i).copied().unwrap_or(0))
90 }
91 };
92 let mut object_type = get_ot(&mut br);
93 let (sampling_index, sample_rate) = get_sr(&mut br);
94 let chan_config = br.bits(4);
95 let channels = [0, 1, 2, 3, 4, 5, 6, 8, 0, 0, 0, 7, 8, 24, 8]
96 .get(chan_config as usize)
97 .copied()
98 .ok_or_else(|| AacError::Invalid(format!("chan_config {chan_config}")))?;
99 let (mut sbr, mut ps) = (-1i32, -1i32);
100 let mut ext_sample_rate = 0;
101 let mut explicit_sbr = false;
102 if object_type == 5 || (object_type == 29 && !(br.show(3) & 3 != 0 && br.show(9) & 0x3f == 0)) {
103 if object_type == 29 {
104 ps = 1;
105 }
106 explicit_sbr = true;
107 sbr = 1;
108 ext_sample_rate = get_sr(&mut br).1;
109 object_type = get_ot(&mut br);
110 }
111 let specific = br.pos();
112 if !explicit_sbr {
113 let mut scan = BitReader::new(asc);
115 scan.skip(specific as u32);
116 while scan.left() > 15 {
117 if scan.show(11) == 0x2b7 {
118 scan.skip(11);
119 let ext = get_ot(&mut scan);
120 if ext == 5 {
121 sbr = scan.bits(1) as i32;
122 if sbr == 1 {
123 ext_sample_rate = get_sr(&mut scan).1;
124 if ext_sample_rate == sample_rate {
125 sbr = -1;
126 }
127 }
128 }
129 if scan.left() > 11 && scan.bits(11) == 0x548 {
130 ps = scan.bits(1) as i32;
131 }
132 break;
133 }
134 scan.skip(1);
135 }
136 }
137 if sbr == 0 {
138 ps = 0;
139 }
140 if (ps == -1 && object_type != 2) || channels & !1 != 0 {
141 ps = 0;
142 }
143 if object_type != 2 {
144 return unsupported(format!("audio object type {object_type} (only AAC-LC cores)"));
145 }
146 if sampling_index >= 12 {
147 return unsupported(format!("sampling index {sampling_index}"));
148 }
149 if br.bit() {
150 return unsupported("960-sample frames");
151 }
152 if br.bit() {
153 br.skip(14); }
155 let _extension_flag = br.bit();
156 let (mut channels, mut elem_tag) = (channels, 0);
157 if chan_config == 0 {
158 br.skip(4);
160 br.skip(2 + 4);
161 let (front, side, back, lfe, assoc, cc) = (br.bits(4), br.bits(4), br.bits(4), br.bits(2), br.bits(3), br.bits(4));
162 for skip in [4, 4] {
163 if br.bit() {
164 br.skip(skip);
165 }
166 }
167 if br.bit() {
168 br.skip(3);
169 }
170 if front != 1 || side + back + lfe + cc != 0 {
171 return unsupported("program config element layouts beyond one front SCE/CPE");
172 }
173 let is_cpe = br.bit();
174 elem_tag = br.bits(4);
175 br.skip(4 * assoc);
176 channels = if is_cpe { 2 } else { 1 };
177 } else if !(1..=2).contains(&chan_config) {
178 return unsupported(format!("channel configuration {chan_config}"));
179 }
180 if channels > 1 {
182 ps = 0;
183 } else if sbr == 1 && ps == -1 {
184 ps = 1;
185 }
186 Ok(Self { object_type, sampling_index, sample_rate, chan_config, channels, sbr, ps, ext_sample_rate, elem_tag })
187 }
188}
189
190const ONLY_LONG: u8 = 0;
191const LONG_START: u8 = 1;
192const EIGHT_SHORT: u8 = 2;
193const LONG_STOP: u8 = 3;
194
195const ZERO_BT: u8 = 0;
196const NOISE_BT: u8 = 13;
197const INTENSITY_BT2: u8 = 14;
198const INTENSITY_BT: u8 = 15;
199
200#[derive(Clone, Default)]
201struct Ics {
202 max_sfb: usize,
203 window_sequence: [u8; 2],
204 use_kb_window: [bool; 2],
205 num_window_groups: usize,
206 group_len: [usize; 8],
207 num_windows: usize,
208 swb_offset: &'static [u16],
209 num_swb: usize,
210 tns_max_bands: usize,
211 predictor_present: bool,
212}
213
214#[derive(Clone, Default)]
215struct Tns {
216 present: bool,
217 n_filt: [usize; 8],
218 length: [[usize; 4]; 8],
219 order: [[usize; 4]; 8],
220 direction: [[bool; 4]; 8],
221 coef: [[[f32; 20]; 4]; 8],
222}
223
224#[derive(Clone)]
225struct Sce {
226 ics: Ics,
227 tns: Tns,
228 band_type: [u8; 128],
229 sfo: [i32; 128],
230 sf: [f32; 128],
231 coeffs: [f32; 1024],
232 saved: [f32; 1536],
233 output: [f32; 1024],
234}
235
236impl Default for Sce {
237 fn default() -> Self {
238 Self {
239 ics: Ics::default(),
240 tns: Tns::default(),
241 band_type: [0; 128],
242 sfo: [0; 128],
243 sf: [0.0; 128],
244 coeffs: [0.0; 1024],
245 saved: [0.0; 1536],
246 output: [0.0; 1024],
247 }
248 }
249}
250
251#[derive(Debug, Clone, Default)]
254pub struct ToolStats {
255 pub frames: u64,
257 pub short_windows: u64,
259 pub start_stop_windows: u64,
261 pub kbd_windows: u64,
263 pub ms_bands: u64,
265 pub intensity_bands: u64,
267 pub noise_bands: u64,
269 pub escape_bands: u64,
271 pub pulses: u64,
273 pub tns_filters: u64,
275 pub drc: u64,
277 pub fill_or_dse: u64,
279 pub sbr_frames: u64,
282 pub sbr_coupled: u64,
284 pub sbr_downsampled: u64,
286 pub ps_frames: u64,
288 pub ps_34_bands: u64,
290 pub ps_ipdopd: u64,
292}
293
294struct Pulse {
295 num_pulse: usize,
296 pos: [usize; 4],
297 amp: [i32; 4],
298}
299
300pub struct AacDecoder {
302 pub config: AudioSpecificConfig,
304 ch: Vec<Sce>,
305 ms_mask: [bool; 128],
306 random_state: u32,
307 frames: u64,
308 buf: [f32; 1024],
309 temp: [f32; 128],
310 pub libfaac_skip: bool,
312 pub stats: ToolStats,
314 sbr: Box<super::sbr::Sbr>,
316 locked: bool,
318 ps_right: Vec<f32>,
320}
321
322impl AacDecoder {
323 pub fn new(asc: &[u8]) -> Result<Self, AacError> {
326 let config = AudioSpecificConfig::parse(asc)?;
327 let n = config.channels;
328 Ok(Self {
329 config,
330 ch: vec![Sce::default(); n],
331 ms_mask: [false; 128],
332 random_state: 0x1f2e3d4c,
333 frames: 0,
334 buf: [0.0; 1024],
335 temp: [0.0; 128],
336 libfaac_skip: false,
337 stats: ToolStats::default(),
338 sbr: Box::new(super::sbr::Sbr::new(if n == 1 { super::sbr::TYPE_SCE } else { super::sbr::TYPE_CPE })),
339 locked: false,
340 ps_right: vec![0.0; 2048],
341 })
342 }
343
344 pub fn channels(&self) -> usize {
346 if self.config.ps == 1 && self.config.channels == 1 {
347 2
348 } else {
349 self.config.channels
350 }
351 }
352
353 fn multiplier(&self) -> u32 {
355 (self.config.sbr == 1 && self.config.ext_sample_rate > self.config.sample_rate) as u32
356 }
357
358 pub fn frame_len(&self) -> usize {
360 1024 << self.multiplier()
361 }
362
363 pub fn sample_rate(&self) -> u32 {
365 self.config.sample_rate << self.multiplier()
366 }
367
368 pub fn decode_frame(&mut self, packet: &[u8], out: &mut Vec<Vec<f32>>) -> Result<(), AacError> {
371 let mut br = BitReader::new(packet);
372 let mut present = [false; 2];
373 let mut have_prev = false;
374 let mut prev_type = 0u32;
375 loop {
376 let elem_type = br.bits(3);
377 if elem_type == 7 {
378 break;
379 }
380 let elem_id = br.bits(4) as usize;
381 match elem_type {
382 0 | 3 => {
383 if self.config.channels != 1 || elem_id as u32 != self.config.elem_tag || elem_type == 3 {
385 return unsupported("element layout beyond mono SCE / stereo CPE");
386 }
387 if present[0] {
388 return invalid("duplicate channel element");
389 }
390 present[0] = true;
391 let mut ch = std::mem::take(&mut self.ch[0]);
392 let r = self.decode_ics(&mut br, &mut ch, false);
393 self.ch[0] = ch;
394 r?;
395 have_prev = true;
396 prev_type = super::sbr::TYPE_SCE;
397 }
398 1 => {
399 if self.config.channels != 2 || elem_id as u32 != self.config.elem_tag {
400 return unsupported("element layout beyond mono SCE / stereo CPE");
401 }
402 if present[1] {
403 return invalid("duplicate channel element");
404 }
405 present[1] = true;
406 self.decode_cpe(&mut br)?;
407 have_prev = true;
408 prev_type = super::sbr::TYPE_CPE;
409 }
410 2 => return unsupported("coupling channel element"),
411 4 => {
412 self.stats.fill_or_dse += 1;
413 let byte_align = br.bit();
415 let mut count = br.bits(8) as isize;
416 if count == 255 {
417 count += br.bits(8) as isize;
418 }
419 if byte_align {
420 br.align();
421 }
422 if br.left() < 8 * count {
423 return invalid("DSE overread");
424 }
425 br.skip_long(8 * count);
426 }
427 5 => return unsupported("program config element in the stream"),
428 6 => {
429 self.stats.fill_or_dse += 1;
430 let mut cnt = elem_id as isize;
431 if cnt == 15 {
432 cnt += br.bits(8) as isize - 1;
433 }
434 if br.left() < 8 * cnt {
435 return invalid("FIL overread");
436 }
437 while cnt > 0 {
438 cnt -= self.extension_payload(&mut br, cnt, have_prev.then_some(prev_type))?;
439 }
440 }
441 _ => unreachable!(),
442 }
443 if br.left() < 3 {
444 return invalid("overread");
445 }
446 }
447 if !present[0] && !present[1] {
448 return invalid("frame without audio");
449 }
450 let nout = self.channels();
451 if out.len() < nout {
452 out.resize(nout, Vec::new());
453 }
454 let mut outputs: Vec<Vec<f32>> = Vec::with_capacity(self.ch.len());
455 for c in 0..self.ch.len() {
456 let mut ch = std::mem::take(&mut self.ch[c]);
457 let st = &mut self.stats;
458 match ch.ics.window_sequence[0] {
459 EIGHT_SHORT => st.short_windows += 1,
460 LONG_START | LONG_STOP => st.start_stop_windows += 1,
461 _ => {}
462 }
463 st.kbd_windows += ch.ics.use_kb_window[0] as u64;
464 let nb = ch.ics.num_window_groups * ch.ics.max_sfb;
465 for &bt in &ch.band_type[..nb] {
466 match bt {
467 NOISE_BT => st.noise_bands += 1,
468 INTENSITY_BT | INTENSITY_BT2 => st.intensity_bands += 1,
469 11 => st.escape_bands += 1,
470 _ => {}
471 }
472 }
473 if ch.tns.present {
474 st.tns_filters += ch.tns.n_filt[..ch.ics.num_windows].iter().sum::<usize>() as u64;
475 apply_tns(&mut ch.coeffs, &ch.tns, &ch.ics);
476 }
477 self.imdct_and_windowing(&mut ch);
478 outputs.push(ch.output.to_vec());
479 self.ch[c] = ch;
480 }
481 if self.config.sbr > 0 {
482 let id = if self.ch.len() == 2 { super::sbr::TYPE_CPE } else { super::sbr::TYPE_SCE };
484 let downsampled = self.config.ext_sample_rate < self.sbr.sample_rate as u32;
485 let mut l = vec![0f32; 2048];
486 l[..1024].copy_from_slice(&outputs[0]);
487 let mut r = std::mem::take(&mut self.ps_right);
488 if outputs.len() > 1 {
489 r[..1024].copy_from_slice(&outputs[1]);
490 }
491 self.sbr.apply(id, &mut l, &mut r, downsampled, self.config.ps == 1);
492 let (sbr_on, coupled, ps_on, ps34, ipd) = self.sbr.coverage();
493 let st = &mut self.stats;
494 st.sbr_frames += sbr_on as u64;
495 st.sbr_coupled += (sbr_on && coupled) as u64;
496 st.sbr_downsampled += (sbr_on && downsampled) as u64;
497 let ps_on = ps_on && self.config.ps == 1;
498 st.ps_frames += ps_on as u64;
499 st.ps_34_bands += (ps_on && ps34) as u64;
500 st.ps_ipdopd += (ps_on && ipd) as u64;
501 let n = self.frame_len();
502 outputs.clear();
503 outputs.push(l[..n].to_vec());
504 if nout == 2 {
505 outputs.push(r[..n].to_vec());
506 }
507 self.ps_right = r;
508 }
509 for (plane, o) in out.iter_mut().zip(&outputs) {
510 plane.extend_from_slice(o);
511 }
512 self.locked = true;
513 self.frames += 1;
514 self.stats.frames += 1;
515 Ok(())
516 }
517
518 fn extension_payload(&mut self, br: &mut BitReader, cnt: isize, prev: Option<u32>) -> Result<isize, AacError> {
519 let ty = br.bits(4);
520 match ty {
521 0xd | 0xe => {
522 let Some(id) = prev else {
524 return Ok(cnt);
525 };
526 if self.config.sbr == 0 || (self.config.sbr == -1 && self.locked) {
527 br.skip_long(8 * cnt - 4);
528 return Ok(cnt);
529 }
530 if self.config.ps == -1 && !self.locked && self.config.channels == 1 {
531 self.config.sbr = 1;
532 self.config.ps = 1;
533 } else {
534 self.config.sbr = 1;
535 }
536 let core = self.config.sample_rate;
537 let ps_allowed = self.config.ps;
538 let mut ext = self.config.ext_sample_rate;
539 self.sbr.decode_extension(br, ty == 0xe, cnt, id, core, &mut ext, ps_allowed);
540 self.config.ext_sample_rate = ext;
541 Ok(cnt)
542 }
543 0xb => {
544 self.stats.drc += 1;
545 Ok(decode_dynamic_range(br))
546 }
547 0x1 => {
548 let mut len = 8 * cnt - 4;
550 if len >= 13 + 7 * 8 {
551 br.skip(13);
552 len -= 13;
553 let mut s = Vec::new();
554 while s.len() + 1 < 256 && len >= 8 {
555 s.push(br.bits(8) as u8);
556 len -= 8;
557 }
558 if let Some(rest) = s.strip_prefix(b"libfaac ") {
559 let txt = String::from_utf8_lossy(rest);
560 let mut it = txt.splitn(2, '.');
561 let ok = |x: Option<&str>| {
562 x.map(|v| v.trim_start().chars().take_while(|c| c.is_ascii_digit() || *c == '-').count() > 0)
563 .unwrap_or(false)
564 };
565 if ok(it.next()) && ok(it.next()) {
566 self.libfaac_skip = true;
567 }
568 }
569 }
570 br.skip_long(len);
571 Ok(cnt)
572 }
573 _ => {
574 br.skip_long(8 * cnt - 4);
575 Ok(cnt)
576 }
577 }
578 }
579
580 fn decode_cpe(&mut self, br: &mut BitReader) -> Result<(), AacError> {
581 let common_window = br.bit();
582 let mut ms_present = 0;
583 let (mut c0, mut c1) = (std::mem::take(&mut self.ch[0]), std::mem::take(&mut self.ch[1]));
584 let r = (|| {
585 if common_window {
586 self.decode_ics_info(br, &mut c0.ics)?;
587 let kb = c1.ics.use_kb_window[0];
588 c1.ics = c0.ics.clone();
589 c1.ics.use_kb_window[1] = kb;
590 ms_present = br.bits(2);
591 if ms_present == 3 {
592 return invalid("ms_present = 3");
593 }
594 let max_idx = c0.ics.num_window_groups * c0.ics.max_sfb;
595 if ms_present == 1 {
596 for i in 0..max_idx {
597 self.ms_mask[i] = br.bit();
598 }
599 } else if ms_present == 2 {
600 self.ms_mask[..max_idx].fill(true);
601 }
602 }
603 self.decode_ics(br, &mut c0, common_window)?;
604 self.decode_ics(br, &mut c1, common_window)?;
605 if common_window && ms_present != 0 {
606 self.apply_mid_side(&mut c0, &mut c1);
607 }
608 self.apply_intensity(&c0, &mut c1, ms_present != 0);
609 Ok(())
610 })();
611 self.ch[0] = c0;
612 self.ch[1] = c1;
613 r
614 }
615
616 fn decode_ics_info(&self, br: &mut BitReader, ics: &mut Ics) -> Result<(), AacError> {
617 let si = self.config.sampling_index;
618 br.skip(1); ics.window_sequence[1] = ics.window_sequence[0];
620 ics.window_sequence[0] = br.bits(2) as u8;
621 ics.use_kb_window[1] = ics.use_kb_window[0];
622 ics.use_kb_window[0] = br.bit();
623 ics.num_window_groups = 1;
624 ics.group_len[0] = 1;
625 if ics.window_sequence[0] == EIGHT_SHORT {
626 ics.max_sfb = br.bits(4) as usize;
627 for _ in 0..7 {
628 if br.bit() {
629 ics.group_len[ics.num_window_groups - 1] += 1;
630 } else {
631 ics.num_window_groups += 1;
632 ics.group_len[ics.num_window_groups - 1] = 1;
633 }
634 }
635 ics.num_windows = 8;
636 ics.swb_offset = t::SWB_OFFSET_128[si];
637 ics.num_swb = t::NUM_SWB_128[si] as usize;
638 ics.tns_max_bands = t::TNS_MAX_BANDS_128[si] as usize;
639 ics.predictor_present = false;
640 } else {
641 ics.max_sfb = br.bits(6) as usize;
642 ics.num_windows = 1;
643 ics.swb_offset = t::SWB_OFFSET_1024[si];
644 ics.num_swb = t::NUM_SWB_1024[si] as usize;
645 ics.tns_max_bands = t::TNS_MAX_BANDS_1024[si] as usize;
646 ics.predictor_present = br.bit();
647 if ics.predictor_present {
648 ics.max_sfb = 0;
649 return invalid("Prediction is not allowed in AAC-LC");
650 }
651 }
652 if ics.max_sfb > ics.num_swb {
653 ics.max_sfb = 0;
654 return invalid("max_sfb exceeds num_swb");
655 }
656 Ok(())
657 }
658
659 fn decode_ics(&mut self, br: &mut BitReader, sce: &mut Sce, common_window: bool) -> Result<(), AacError> {
660 let r = self.decode_ics_inner(br, sce, common_window);
661 if r.is_err() {
662 sce.tns.present = false;
663 }
664 r
665 }
666
667 fn decode_ics_inner(&mut self, br: &mut BitReader, sce: &mut Sce, common_window: bool) -> Result<(), AacError> {
668 let global_gain = br.bits(8) as i32;
669 if !common_window {
670 self.decode_ics_info(br, &mut sce.ics)?;
671 }
672 decode_band_types(br, sce)?;
673 decode_scalefactors(br, sce, global_gain)?;
674 dequant_scalefactors(sce);
675 let mut pulse = None;
676 if br.bit() {
677 if sce.ics.window_sequence[0] == EIGHT_SHORT {
678 return invalid("Pulse tool not allowed in eight short sequence");
679 }
680 pulse = Some(decode_pulses(br, sce.ics.swb_offset, sce.ics.num_swb).ok_or(AacError::Invalid("pulse".into()))?);
681 self.stats.pulses += 1;
682 }
683 sce.tns.present = br.bit();
684 if sce.tns.present {
685 decode_tns(br, &mut sce.tns, &sce.ics)?;
686 }
687 if br.bit() {
688 return unsupported("SSR gain control");
689 }
690 self.decode_spectrum_and_dequant(br, pulse.as_ref(), sce)
691 }
692
693 fn decode_spectrum_and_dequant(&mut self, br: &mut BitReader, pulse: Option<&Pulse>, sce: &mut Sce) -> Result<(), AacError> {
694 let tb = tables();
695 let ics = &sce.ics;
696 let c = 1024 / ics.num_windows;
697 let offsets = ics.swb_offset;
698 let coef = &mut sce.coeffs;
699 for g in 0..ics.num_windows {
700 let from = g * 128 + offsets[ics.max_sfb] as usize;
701 coef[from..g * 128 + c].fill(0.0);
702 }
703 let mut idx = 0;
704 let mut base = 0usize;
705 for g in 0..ics.num_window_groups {
706 let g_len = ics.group_len[g];
707 for i in 0..ics.max_sfb {
708 let bt = sce.band_type[idx];
709 let off = offsets[i] as usize;
710 let off_len = offsets[i + 1] as usize - off;
711 let sfv = sce.sf[idx];
712 if bt == ZERO_BT || bt >= INTENSITY_BT2 {
713 for grp in 0..g_len {
714 let s = base + grp * 128 + off;
715 coef[s..s + off_len].fill(0.0);
716 }
717 } else if bt == NOISE_BT {
718 for grp in 0..g_len {
719 let s = base + grp * 128 + off;
720 let cf = &mut coef[s..s + off_len];
721 for v in cf.iter_mut() {
722 self.random_state = self.random_state.wrapping_mul(1664525).wrapping_add(1013904223);
723 *v = self.random_state as i32 as f32;
724 }
725 let band_energy = scalarproduct(cf);
726 let scale = sfv / band_energy.sqrt();
727 for v in cf.iter_mut() {
728 *v *= scale;
729 }
730 }
731 } else {
732 let cbt_m1 = (bt - 1) as usize;
733 let vq = t::VEC_VALS[cbt_m1];
734 let vl = vlc::spectral(cbt_m1);
735 for grp in 0..g_len {
736 let s = base + grp * 128 + off;
737 let cf = &mut coef[s..s + off_len];
738 let read = |br: &mut BitReader| vl.read(br).ok_or(AacError::Invalid("spectral VLC".into()));
739 match cbt_m1 >> 1 {
740 0 => {
741 for q in cf.chunks_exact_mut(4) {
742 let ix = read(br)? as usize;
743 q[0] = vq[ix & 3] * sfv;
744 q[1] = vq[ix >> 2 & 3] * sfv;
745 q[2] = vq[ix >> 4 & 3] * sfv;
746 q[3] = vq[ix >> 6 & 3] * sfv;
747 }
748 }
749 1 => {
750 for q in cf.chunks_exact_mut(4) {
751 let ix = read(br)?;
752 let nnz = ix >> 8 & 15;
753 let mut sign = if nnz != 0 { br.peek32() } else { 0 };
754 br.skip(nnz);
755 let mut nz = ix >> 12;
757 let sb = sfv.to_bits();
758 let ix = ix as usize;
759 q[0] = vq[ix & 3] * f32::from_bits(sb ^ (sign & 1 << 31));
760 sign <<= nz & 1;
761 nz >>= 1;
762 q[1] = vq[ix >> 2 & 3] * f32::from_bits(sb ^ (sign & 1 << 31));
763 sign <<= nz & 1;
764 nz >>= 1;
765 q[2] = vq[ix >> 4 & 3] * f32::from_bits(sb ^ (sign & 1 << 31));
766 sign <<= nz & 1;
767 q[3] = vq[ix >> 6 & 3] * f32::from_bits(sb ^ (sign & 1 << 31));
768 }
769 }
770 2 => {
771 for q in cf.chunks_exact_mut(2) {
772 let ix = read(br)? as usize;
773 q[0] = vq[ix & 15] * sfv;
774 q[1] = vq[ix >> 4 & 15] * sfv;
775 }
776 }
777 3 | 4 => {
778 for q in cf.chunks_exact_mut(2) {
779 let ix = read(br)?;
780 let nnz = ix >> 8 & 15;
781 let sign = if nnz != 0 { br.show(nnz) << (ix >> 12) } else { 0 };
782 br.skip(nnz);
783 let sb = sfv.to_bits();
785 let ix = ix as usize;
786 q[0] = vq[ix & 15] * f32::from_bits(sb ^ ((sign >> 1) << 31));
787 q[1] = vq[ix >> 4 & 15] * f32::from_bits(sb ^ (sign << 31));
788 }
789 }
790 _ => {
791 for q in cf.chunks_exact_mut(2) {
792 let mut ix = read(br)?;
793 if ix == 0 {
794 q[0] = 0.0;
795 q[1] = 0.0;
796 continue;
797 }
798 let nnz = ix >> 12;
799 let nzt = ix >> 8;
800 let mut bits = if nnz != 0 { br.show(nnz) << (32 - nnz) } else { 0 };
801 br.skip(nnz);
802 for (j, slot) in q.iter_mut().enumerate() {
803 if nzt & (1 << j) != 0 {
804 let b = br.peek32();
805 let b = (!b).leading_zeros();
806 if b > 8 {
807 return invalid("ESC overflow");
808 }
809 br.skip(b + 1);
810 let b = b + 4;
811 let n = (1u32 << b) + br.bits(b);
812 *slot = f32::from_bits(tb.cbrt[n as usize] | (bits & 1 << 31));
813 bits <<= 1;
814 } else {
815 let v = vq[(ix & 15) as usize].to_bits();
816 *slot = f32::from_bits((bits & 1 << 31) | v);
817 bits <<= (v != 0) as u32;
818 }
819 ix >>= 4;
820 }
821 }
822 for v in cf.iter_mut() {
823 *v *= sfv;
824 }
825 }
826 }
827 }
828 }
829 idx += 1;
830 }
831 base += g_len << 7;
832 }
833 if let Some(p) = pulse {
834 let mut idx = 0;
835 for i in 0..p.num_pulse {
836 let pos = p.pos[i];
837 let co = coef[pos];
838 while offsets[idx + 1] as usize <= pos {
839 idx += 1;
840 }
841 if sce.band_type[idx] != NOISE_BT && sce.sf[idx] != 0.0 {
842 let mut ico = -(p.amp[i] as f32);
843 if co != 0.0 {
844 let co = co / sce.sf[idx];
845 ico = co / co.abs().sqrt().sqrt() + if co > 0.0 { -ico } else { ico };
846 }
847 coef[pos] = ico.abs().cbrt() * ico * sce.sf[idx];
848 }
849 }
850 }
851 Ok(())
852 }
853
854 fn apply_mid_side(&mut self, c0: &mut Sce, c1: &mut Sce) {
855 let mut ms_bands = 0;
856 let ics = &c0.ics;
857 let offsets = ics.swb_offset;
858 let max_sfb = ics.max_sfb;
859 let mut base = 0;
860 for g in 0..ics.num_window_groups {
861 for sfb in 0..max_sfb {
862 let idx = g * max_sfb + sfb;
863 if self.ms_mask[idx] && c0.band_type[idx] < NOISE_BT && c1.band_type[idx] < NOISE_BT {
864 ms_bands += 1;
865 for grp in 0..ics.group_len[g] {
866 let s = base + grp * 128 + offsets[sfb] as usize;
867 for k in s..base + grp * 128 + offsets[sfb + 1] as usize {
868 let (a, b) = (c0.coeffs[k], c1.coeffs[k]);
869 c0.coeffs[k] = a + b;
870 c1.coeffs[k] = a - b;
871 }
872 }
873 }
874 }
875 base += ics.group_len[g] * 128;
876 }
877 self.stats.ms_bands += ms_bands;
878 }
879
880 fn apply_intensity(&self, c0: &Sce, c1: &mut Sce, ms_present: bool) {
881 let ics = c1.ics.clone();
882 let offsets = ics.swb_offset;
883 let mut base = 0;
884 for g in 0..ics.num_window_groups {
885 for sfb in 0..ics.max_sfb {
886 let idx = g * ics.max_sfb + sfb;
887 let bt = c1.band_type[idx];
888 if bt == INTENSITY_BT || bt == INTENSITY_BT2 {
889 let mut c = -1 + 2 * (bt as i32 - 14);
890 if ms_present {
891 c *= 1 - 2 * self.ms_mask[idx] as i32;
892 }
893 let scale = c as f32 * c1.sf[idx];
894 for grp in 0..ics.group_len[g] {
895 let s = base + grp * 128;
896 for k in s + offsets[sfb] as usize..s + offsets[sfb + 1] as usize {
897 c1.coeffs[k] = c0.coeffs[k] * scale;
898 }
899 }
900 }
901 }
902 base += ics.group_len[g] * 128;
903 }
904 }
905
906 fn imdct_and_windowing(&mut self, sce: &mut Sce) {
907 let tb = tables();
908 let ics = &sce.ics;
909 let swindow: &[f32] = if ics.use_kb_window[0] { &tb.kbd_short } else { &tb.sine_short };
910 let lwindow_prev: &[f32] = if ics.use_kb_window[1] { &tb.kbd_long } else { &tb.sine_long };
911 let swindow_prev: &[f32] = if ics.use_kb_window[1] { &tb.kbd_short } else { &tb.sine_short };
912 let buf = &mut self.buf;
913 let temp = &mut self.temp;
914 let (ws0, ws1) = (ics.window_sequence[0], ics.window_sequence[1]);
915 if ws0 == EIGHT_SHORT {
916 for i in (0..1024).step_by(128) {
917 tb.imdct_short.run(&sce.coeffs[i..i + 128], &mut buf[i..i + 128]);
918 }
919 } else {
920 tb.imdct_long.run(&sce.coeffs, buf);
921 }
922 let out = &mut sce.output;
923 let saved = &mut sce.saved;
924 if (ws1 == ONLY_LONG || ws1 == LONG_STOP) && (ws0 == ONLY_LONG || ws0 == LONG_START) {
925 vector_fmul_window(out, saved, buf, lwindow_prev, 512);
926 } else {
927 out[..448].copy_from_slice(&saved[..448]);
928 if ws0 == EIGHT_SHORT {
929 vector_fmul_window(&mut out[448..], &saved[448..], &buf[0..], swindow_prev, 64);
930 vector_fmul_window(&mut out[448 + 128..], &buf[64..], &buf[128..], swindow, 64);
931 vector_fmul_window(&mut out[448 + 256..], &buf[128 + 64..], &buf[256..], swindow, 64);
932 vector_fmul_window(&mut out[448 + 384..], &buf[256 + 64..], &buf[384..], swindow, 64);
933 vector_fmul_window(temp, &buf[384 + 64..], &buf[512..], swindow, 64);
934 out[448 + 512..1024].copy_from_slice(&temp[..64]);
935 } else {
936 vector_fmul_window(&mut out[448..], &saved[448..], buf, swindow_prev, 64);
937 out[576..1024].copy_from_slice(&buf[64..512]);
938 }
939 }
940 if ws0 == EIGHT_SHORT {
941 saved[..64].copy_from_slice(&temp[64..128]);
942 vector_fmul_window(&mut saved[64..], &buf[512 + 64..], &buf[640..], swindow, 64);
943 vector_fmul_window(&mut saved[192..], &buf[640 + 64..], &buf[768..], swindow, 64);
944 vector_fmul_window(&mut saved[320..], &buf[768 + 64..], &buf[896..], swindow, 64);
945 saved[448..512].copy_from_slice(&buf[896 + 64..1024]);
946 } else if ws0 == LONG_START {
947 saved[..448].copy_from_slice(&buf[512..960]);
948 saved[448..512].copy_from_slice(&buf[896 + 64..1024]);
949 } else {
950 saved[..512].copy_from_slice(&buf[512..1024]);
951 }
952 }
953}
954
955fn decode_band_types(br: &mut BitReader, sce: &mut Sce) -> Result<(), AacError> {
956 let ics = &sce.ics;
957 let bits = if ics.window_sequence[0] == EIGHT_SHORT { 3 } else { 5 };
958 for g in 0..ics.num_window_groups {
959 let mut k = 0;
960 while k < ics.max_sfb {
961 let mut sect_end = k;
962 let bt = br.bits(4) as u8;
963 if bt == 12 {
964 return invalid("invalid band type");
965 }
966 loop {
967 let inc = br.bits(bits) as usize;
968 sect_end += inc;
969 if br.left() < 0 {
970 return invalid("band types overread");
971 }
972 if sect_end > ics.max_sfb {
973 return invalid("band count exceeds max_sfb");
974 }
975 if inc != (1 << bits) - 1 {
976 break;
977 }
978 }
979 while k < sect_end {
980 sce.band_type[g * ics.max_sfb + k] = bt;
981 k += 1;
982 }
983 }
984 }
985 Ok(())
986}
987
988fn decode_scalefactors(br: &mut BitReader, sce: &mut Sce, global_gain: i32) -> Result<(), AacError> {
989 let ics = &sce.ics;
990 let mut offset = [global_gain, global_gain - 90, 0];
991 let mut noise_flag = 1;
992 let vl = vlc::scalefactor();
993 let read = |br: &mut BitReader| vl.read(br).map(|v| v as i32 - 60).ok_or(AacError::Invalid("scalefactor VLC".into()));
994 for g in 0..ics.num_window_groups {
995 for sfb in 0..ics.max_sfb {
996 let i = g * ics.max_sfb + sfb;
997 match sce.band_type[i] {
998 ZERO_BT => sce.sfo[i] = 0,
999 INTENSITY_BT | INTENSITY_BT2 => {
1000 offset[2] += read(br)?;
1001 sce.sfo[i] = offset[2].clamp(-155, 100) - 100;
1002 }
1003 NOISE_BT => {
1004 let first = noise_flag > 0;
1005 noise_flag -= 1;
1006 if first {
1007 offset[1] += br.bits(9) as i32 - 256;
1008 } else {
1009 offset[1] += read(br)?;
1010 }
1011 sce.sfo[i] = offset[1].clamp(-100, 155);
1012 }
1013 _ => {
1014 offset[0] += read(br)?;
1015 if offset[0] as u32 > 255 {
1016 return invalid("scalefactor out of range");
1017 }
1018 sce.sfo[i] = offset[0] - 100;
1019 }
1020 }
1021 }
1022 }
1023 Ok(())
1024}
1025
1026fn dequant_scalefactors(sce: &mut Sce) {
1027 let p = &tables().pow2sf;
1028 let ics = &sce.ics;
1029 for i in 0..ics.num_window_groups * ics.max_sfb {
1030 let sfo = sce.sfo[i];
1031 sce.sf[i] = match sce.band_type[i] {
1032 ZERO_BT => 0.0,
1033 INTENSITY_BT | INTENSITY_BT2 => p[(-sfo - 100 + 200) as usize],
1034 _ => -p[(sfo + 200) as usize],
1035 };
1036 }
1037}
1038
1039fn decode_pulses(br: &mut BitReader, swb_offset: &[u16], num_swb: usize) -> Option<Pulse> {
1040 let mut p = Pulse { num_pulse: br.bits(2) as usize + 1, pos: [0; 4], amp: [0; 4] };
1041 let swb = br.bits(6) as usize;
1042 if swb >= num_swb {
1043 return None;
1044 }
1045 let end = swb_offset[num_swb] as usize;
1046 p.pos[0] = swb_offset[swb] as usize + br.bits(5) as usize;
1047 if p.pos[0] >= end {
1048 return None;
1049 }
1050 p.amp[0] = br.bits(4) as i32;
1051 for i in 1..p.num_pulse {
1052 p.pos[i] = br.bits(5) as usize + p.pos[i - 1];
1053 if p.pos[i] >= end {
1054 return None;
1055 }
1056 p.amp[i] = br.bits(4) as i32;
1057 }
1058 Some(p)
1059}
1060
1061fn decode_tns(br: &mut BitReader, tns: &mut Tns, ics: &Ics) -> Result<(), AacError> {
1062 let is8 = (ics.window_sequence[0] == EIGHT_SHORT) as u32;
1063 let max_order = if is8 == 1 { 7 } else { 12 };
1064 for w in 0..ics.num_windows {
1065 tns.n_filt[w] = br.bits(2 - is8) as usize;
1066 if tns.n_filt[w] == 0 {
1067 continue;
1068 }
1069 let coef_res = br.bits(1);
1070 for f in 0..tns.n_filt[w] {
1071 tns.length[w][f] = br.bits(6 - 2 * is8) as usize;
1072 tns.order[w][f] = br.bits(5 - 2 * is8) as usize;
1073 if tns.order[w][f] > max_order {
1074 tns.order[w][f] = 0;
1075 return invalid("TNS filter order");
1076 }
1077 if tns.order[w][f] != 0 {
1078 tns.direction[w][f] = br.bit();
1079 let compress = br.bits(1);
1080 let coef_len = coef_res + 3 - compress;
1081 let map = t::TNS_TMP2_MAP[(2 * compress + coef_res) as usize];
1082 for i in 0..tns.order[w][f] {
1083 tns.coef[w][f][i] = map[br.bits(coef_len) as usize];
1084 }
1085 }
1086 }
1087 }
1088 Ok(())
1089}
1090
1091fn compute_lpc(coef: &[f32], order: usize, lpc: &mut [f32; 20]) {
1095 for i in 0..order {
1096 let r = -coef[i];
1097 lpc[i] = r;
1098 for j in 0..(i + 1) >> 1 {
1099 let f = lpc[j];
1100 let b = lpc[i - 1 - j];
1101 lpc[j] = f + r * b;
1102 lpc[i - 1 - j] = b + r * f;
1103 }
1104 }
1105}
1106
1107fn apply_tns(coef: &mut [f32; 1024], tns: &Tns, ics: &Ics) {
1108 let mmm = ics.tns_max_bands.min(ics.max_sfb);
1109 if mmm == 0 {
1110 return;
1111 }
1112 let mut lpc = [0f32; 20];
1113 for w in 0..ics.num_windows {
1114 let mut bottom = ics.num_swb;
1115 for f in 0..tns.n_filt[w] {
1116 let top = bottom;
1117 bottom = top.saturating_sub(tns.length[w][f]);
1118 let order = tns.order[w][f];
1119 if order == 0 {
1120 continue;
1121 }
1122 compute_lpc(&tns.coef[w][f], order, &mut lpc);
1123 let mut start = ics.swb_offset[bottom.min(mmm)] as isize;
1124 let end = ics.swb_offset[top.min(mmm)] as isize;
1125 let size = end - start;
1126 if size <= 0 {
1127 continue;
1128 }
1129 let inc: isize = if tns.direction[w][f] {
1130 start = end - 1;
1131 -1
1132 } else {
1133 1
1134 };
1135 start += (w * 128) as isize;
1136 for m in 0..size as usize {
1137 let s = start as usize;
1138 for i in 1..=m.min(order) {
1139 let prev = coef[(start - i as isize * inc) as usize];
1140 coef[s] -= prev * lpc[i - 1];
1141 }
1142 start += inc;
1143 }
1144 }
1145 }
1146}
1147
1148fn decode_dynamic_range(br: &mut BitReader) -> isize {
1151 let mut n = 1;
1152 let mut num_bands = 1;
1153 if br.bit() {
1154 br.skip(8);
1155 n += 1;
1156 }
1157 if br.bit() {
1158 let mut num_excl = 0;
1159 loop {
1160 br.skip(7);
1161 num_excl += 7;
1162 if !(num_excl < 64 - 7 && br.bit()) {
1163 break;
1164 }
1165 }
1166 n += num_excl / 7;
1167 }
1168 if br.bit() {
1169 let band_incr = br.bits(4) as isize;
1170 br.skip(4);
1171 n += 1;
1172 num_bands += band_incr;
1173 for _ in 0..num_bands {
1174 br.skip(8);
1175 n += 1;
1176 }
1177 }
1178 if br.bit() {
1179 br.skip(8);
1180 n += 1;
1181 }
1182 for _ in 0..num_bands {
1183 br.skip(8);
1184 n += 1;
1185 }
1186 n
1187}
1188