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