Skip to main content

threers_codec/aac/
decoder.rs

1//! AAC-LC raw_data_block decoding, after ffmpeg n7.1 `libavcodec/aac/aacdec.c`,
2//! `aacdec_proc_template.c` and `aacdec_dsp_template.c` (float decoder).
3//!
4//! Supported: AAC-LC cores (object type 2, alone or under SBR/PS), 1024-
5//! sample frames, one SCE or CPE (channel configuration 1 or 2, or a PCE
6//! naming just that element); SBR and PS run through [`super::sbr`]. Main/LTP
7//! prediction, coupling (CCE), larger layouts and 960-sample frames are
8//! refused with [`AacError::Unsupported`].
9
10use super::bits::BitReader;
11use super::dsp::{scalarproduct, tables, vector_fmul_window};
12use super::tables as t;
13use super::vlc;
14
15/// Why an AAC stream could not be decoded.
16#[derive(Debug, Clone, PartialEq, Eq)]
17pub enum AacError {
18    /// Valid AAC using something this decoder does not implement.
19    Unsupported(String),
20    /// A malformed stream.
21    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
43/// Sampling rates by `samplingFrequencyIndex` (ISO/IEC 14496-3).
44pub const SAMPLE_RATES: [u32; 13] = [
45    96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050, 16000, 12000, 11025, 8000, 7350,
46];
47
48/// The parts of an `AudioSpecificConfig` the decoder uses.
49#[derive(Debug, Clone, PartialEq, Eq)]
50pub struct AudioSpecificConfig {
51    /// The core object type (2, AAC-LC; an explicit SBR/PS type 5/29 is
52    /// recorded in `sbr`/`ps`).
53    pub object_type: u32,
54    /// `samplingFrequencyIndex`.
55    pub sampling_index: usize,
56    /// The core sampling rate.
57    pub sample_rate: u32,
58    /// `channelConfiguration`.
59    pub chan_config: u32,
60    /// Output channels.
61    pub channels: usize,
62    /// `-1` unknown (implicit SBR possible), `0` absent, `1` present.
63    pub sbr: i32,
64    /// Parametric stereo: `-1` unknown, `0` absent, `1` present.
65    pub ps: i32,
66    /// The SBR output rate when signalled (0 when not).
67    pub ext_sample_rate: u32,
68    /// The element instance tag of the single SCE/CPE (from a PCE; 0 for
69    /// the indexed configurations).
70    pub elem_tag: u32,
71}
72
73impl AudioSpecificConfig {
74    /// `ff_mpeg4audio_get_config_gb` with `sync_extension = 1`, then
75    /// `decode_ga_specific_config`.
76    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            // Sync extension scan from the start of the specific config.
118            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); // coreCoderDelay
160        }
161        let _extension_flag = br.bit();
162        let (mut channels, mut elem_tag) = (channels, 0);
163        if chan_config == 0 {
164            // element_instance_tag, then decode_pce.
165            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        // decode_ga_specific_config's channel-count rule.
194        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/// How often each coding tool was used (frames, or bands for the
275/// band-level tools) — a coverage record for parity tests.
276#[derive(Debug, Clone, Default)]
277pub struct ToolStats {
278    /// Raw data blocks decoded.
279    pub frames: u64,
280    /// Frames with an `EIGHT_SHORT_SEQUENCE` window.
281    pub short_windows: u64,
282    /// Frames with a start or stop window.
283    pub start_stop_windows: u64,
284    /// Frames with the Kaiser-Bessel-derived window shape.
285    pub kbd_windows: u64,
286    /// Bands coded mid/side.
287    pub ms_bands: u64,
288    /// Bands coded with intensity stereo.
289    pub intensity_bands: u64,
290    /// Bands coded with perceptual noise substitution.
291    pub noise_bands: u64,
292    /// Bands using the escape codebook.
293    pub escape_bands: u64,
294    /// Pulse data blocks.
295    pub pulses: u64,
296    /// Temporal noise shaping filters.
297    pub tns_filters: u64,
298    /// Dynamic range control payloads.
299    pub drc: u64,
300    /// Fill and data stream elements.
301    pub fill_or_dse: u64,
302    /// Frames with SBR active (a header received), and of those coupled
303    /// stereo SBR / downsampled (single-rate) SBR.
304    pub sbr_frames: u64,
305    /// Frames with coupled-stereo SBR.
306    pub sbr_coupled: u64,
307    /// Frames with downsampled (single-rate) SBR.
308    pub sbr_downsampled: u64,
309    /// Frames with parametric stereo active, in 34-band mode, with IPD/OPD.
310    pub ps_frames: u64,
311    /// Frames with 34-band parametric stereo.
312    pub ps_34_bands: u64,
313    /// Frames with IPD/OPD parametric stereo.
314    pub ps_ipdopd: u64,
315}
316
317struct Pulse {
318    num_pulse: usize,
319    pos: [usize; 4],
320    amp: [i32; 4],
321}
322
323/// An AAC decoder, as ffmpeg n7.1 decodes AAC-LC and HE-AAC (v1 and v2).
324pub struct AacDecoder {
325    /// The parsed `AudioSpecificConfig`.
326    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    /// Set when a FIL element names libfaac: ffmpeg then skips 1024 samples.
334    pub libfaac_skip: bool,
335    /// Which coding tools the stream has used so far.
336    pub stats: ToolStats,
337    /// The element's SBR context (`ExtChannelElement`), allocated with it.
338    sbr: Box<super::sbr::Sbr>,
339    /// `oc[1].status == OC_LOCKED`: a frame with audio was decoded.
340    locked: bool,
341    /// Right-channel output of a mono element with parametric stereo.
342    ps_right: Vec<f32>,
343}
344
345impl AacDecoder {
346    /// A decoder for the `AudioSpecificConfig` `asc` (from `esds`, or
347    /// [`AacTrack::asc`](super::AacTrack::asc)).
348    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    /// Output channels (a mono stream with parametric stereo decodes to 2).
372    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    /// `multiplier`: 1 when SBR doubles the output rate.
381    fn multiplier(&self) -> u32 {
382        (self.config.sbr == 1 && self.config.ext_sample_rate > self.config.sample_rate) as u32
383    }
384
385    /// Samples per channel per frame (1024, or 2048 with SBR).
386    pub fn frame_len(&self) -> usize {
387        1024 << self.multiplier()
388    }
389
390    /// The output sampling rate.
391    pub fn sample_rate(&self) -> u32 {
392        self.config.sample_rate << self.multiplier()
393    }
394
395    /// Decode one raw_data_block into 1024 planar samples per channel
396    /// (`AV_SAMPLE_FMT_FLTP`), appended to `out[c]`.
397    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                    // SCE / LFE
411                    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                    // DSE
444                    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            // ff_aac_sbr_apply on che->ch[0].output / ch[1].output (2048 each).
514            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                // decode_extension_payload's EXT_SBR_DATA(_CRC) cases.
564                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                // EXT_FILL: decode_fill.
591                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); // reserved
670        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                                    // VMUL4S
830                                    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                                    // VMUL2S
862                                    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
1229/// `compute_lpc_coefs(coef, order, lpc, 0, 0, 0)` in float: the in-place
1230/// step-up recursion. The reference build does not contract C arithmetic
1231/// (measured on av_tx's `CMUL`), so every product rounds on its own.
1232fn 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
1286/// `decode_dynamic_range`: parsed for its length only (the float decoder
1287/// does not apply DRC).
1288fn 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}