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] = [96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050, 16000, 12000, 11025, 8000, 7350];
45
46/// The parts of an `AudioSpecificConfig` the decoder uses.
47#[derive(Debug, Clone, PartialEq, Eq)]
48pub struct AudioSpecificConfig {
49    /// The core object type (2, AAC-LC; an explicit SBR/PS type 5/29 is
50    /// recorded in `sbr`/`ps`).
51    pub object_type: u32,
52    /// `samplingFrequencyIndex`.
53    pub sampling_index: usize,
54    /// The core sampling rate.
55    pub sample_rate: u32,
56    /// `channelConfiguration`.
57    pub chan_config: u32,
58    /// Output channels.
59    pub channels: usize,
60    /// `-1` unknown (implicit SBR possible), `0` absent, `1` present.
61    pub sbr: i32,
62    /// Parametric stereo: `-1` unknown, `0` absent, `1` present.
63    pub ps: i32,
64    /// The SBR output rate when signalled (0 when not).
65    pub ext_sample_rate: u32,
66    /// The element instance tag of the single SCE/CPE (from a PCE; 0 for
67    /// the indexed configurations).
68    pub elem_tag: u32,
69}
70
71impl AudioSpecificConfig {
72    /// `ff_mpeg4audio_get_config_gb` with `sync_extension = 1`, then
73    /// `decode_ga_specific_config`.
74    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            // Sync extension scan from the start of the specific config.
114            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); // coreCoderDelay
154        }
155        let _extension_flag = br.bit();
156        let (mut channels, mut elem_tag) = (channels, 0);
157        if chan_config == 0 {
158            // element_instance_tag, then decode_pce.
159            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        // decode_ga_specific_config's channel-count rule.
181        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/// How often each coding tool was used (frames, or bands for the
252/// band-level tools) — a coverage record for parity tests.
253#[derive(Debug, Clone, Default)]
254pub struct ToolStats {
255    /// Raw data blocks decoded.
256    pub frames: u64,
257    /// Frames with an `EIGHT_SHORT_SEQUENCE` window.
258    pub short_windows: u64,
259    /// Frames with a start or stop window.
260    pub start_stop_windows: u64,
261    /// Frames with the Kaiser-Bessel-derived window shape.
262    pub kbd_windows: u64,
263    /// Bands coded mid/side.
264    pub ms_bands: u64,
265    /// Bands coded with intensity stereo.
266    pub intensity_bands: u64,
267    /// Bands coded with perceptual noise substitution.
268    pub noise_bands: u64,
269    /// Bands using the escape codebook.
270    pub escape_bands: u64,
271    /// Pulse data blocks.
272    pub pulses: u64,
273    /// Temporal noise shaping filters.
274    pub tns_filters: u64,
275    /// Dynamic range control payloads.
276    pub drc: u64,
277    /// Fill and data stream elements.
278    pub fill_or_dse: u64,
279    /// Frames with SBR active (a header received), and of those coupled
280    /// stereo SBR / downsampled (single-rate) SBR.
281    pub sbr_frames: u64,
282    /// Frames with coupled-stereo SBR.
283    pub sbr_coupled: u64,
284    /// Frames with downsampled (single-rate) SBR.
285    pub sbr_downsampled: u64,
286    /// Frames with parametric stereo active, in 34-band mode, with IPD/OPD.
287    pub ps_frames: u64,
288    /// Frames with 34-band parametric stereo.
289    pub ps_34_bands: u64,
290    /// Frames with IPD/OPD parametric stereo.
291    pub ps_ipdopd: u64,
292}
293
294struct Pulse {
295    num_pulse: usize,
296    pos: [usize; 4],
297    amp: [i32; 4],
298}
299
300/// An AAC decoder, as ffmpeg n7.1 decodes AAC-LC and HE-AAC (v1 and v2).
301pub struct AacDecoder {
302    /// The parsed `AudioSpecificConfig`.
303    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    /// Set when a FIL element names libfaac: ffmpeg then skips 1024 samples.
311    pub libfaac_skip: bool,
312    /// Which coding tools the stream has used so far.
313    pub stats: ToolStats,
314    /// The element's SBR context (`ExtChannelElement`), allocated with it.
315    sbr: Box<super::sbr::Sbr>,
316    /// `oc[1].status == OC_LOCKED`: a frame with audio was decoded.
317    locked: bool,
318    /// Right-channel output of a mono element with parametric stereo.
319    ps_right: Vec<f32>,
320}
321
322impl AacDecoder {
323    /// A decoder for the `AudioSpecificConfig` `asc` (from `esds`, or
324    /// [`AacTrack::asc`](super::AacTrack::asc)).
325    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    /// Output channels (a mono stream with parametric stereo decodes to 2).
345    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    /// `multiplier`: 1 when SBR doubles the output rate.
354    fn multiplier(&self) -> u32 {
355        (self.config.sbr == 1 && self.config.ext_sample_rate > self.config.sample_rate) as u32
356    }
357
358    /// Samples per channel per frame (1024, or 2048 with SBR).
359    pub fn frame_len(&self) -> usize {
360        1024 << self.multiplier()
361    }
362
363    /// The output sampling rate.
364    pub fn sample_rate(&self) -> u32 {
365        self.config.sample_rate << self.multiplier()
366    }
367
368    /// Decode one raw_data_block into 1024 planar samples per channel
369    /// (`AV_SAMPLE_FMT_FLTP`), appended to `out[c]`.
370    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                    // SCE / LFE
384                    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                    // DSE
414                    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            // ff_aac_sbr_apply on che->ch[0].output / ch[1].output (2048 each).
483            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                // decode_extension_payload's EXT_SBR_DATA(_CRC) cases.
523                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                // EXT_FILL: decode_fill.
549                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); // reserved
619        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                                    // VMUL4S
756                                    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                                    // VMUL2S
784                                    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
1091/// `compute_lpc_coefs(coef, order, lpc, 0, 0, 0)` in float: the in-place
1092/// step-up recursion. The reference build does not contract C arithmetic
1093/// (measured on av_tx's `CMUL`), so every product rounds on its own.
1094fn 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
1148/// `decode_dynamic_range`: parsed for its length only (the float decoder
1149/// does not apply DRC).
1150fn 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