Skip to main content

threers_codec/mp3/
decoder.rs

1//! mpg123 1.32.3's layer III decoder (`layer3.c`, `parse.c`, `frame.c`,
2//! `synth_real.c`, `synth_mono.h`) as libsndfile drives it: float output,
3//! `MPG123_GAPLESS | MPG123_NO_FRANKENSTEIN`, NEON64 synth.
4//!
5//! Integer work (headers, side info, scalefactors, Huffman, the bit
6//! reservoir) is ported from the C. Float arrays live in the [`Cpu`] arena so
7//! the kernels generated from the reference's machine code (`dct12`,
8//! `dct36_neon64`, `dct64_real_neon64`, the synths, the vectorised antialias
9//! loop) run on them directly.
10
11#![allow(
12    clippy::needless_range_loop,
13    clippy::collapsible_if,
14    clippy::explicit_counter_loop
15)]
16
17use super::built;
18use super::cpu::Cpu;
19use super::tables as t;
20
21// ---- arena layout (byte addresses) -----------------------------------------
22const REAL_BUFFS: u64 = 0x1000; // [ch][2][0x110] f32
23const DECWIN: u64 = 0x3000; // 512 + 32 + 512 f32 (+ slack)
24const SAMPLES: u64 = 0x5000; // one frame of output, interleaved, 1152 * 2 f32
25const MONO_TMP: u64 = 0x7800; // 64 f32
26const HYBRID_IN: u64 = 0x8000; // [2][576] f32
27const HYBRID_OUT: u64 = 0xA000; // [2][576] f32 ([ss][sb])
28const HYBRID_BLOCK: u64 = 0xC000; // [2][2][576] f32
29const WIN: u64 = 0xF000; // [4][36]
30const WIN1: u64 = 0xF400; // [4][36]
31
32const FREQS: [u32; 9] = [44100, 48000, 32000, 22050, 24000, 16000, 11025, 12000, 8000];
33const TABSEL: [[[u32; 16]; 3]; 2] = [
34    [
35        [
36            0, 32, 64, 96, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416, 448, 0,
37        ],
38        [
39            0, 32, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384, 0,
40        ],
41        [
42            0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 0,
43        ],
44    ],
45    [
46        [
47            0, 32, 48, 56, 64, 80, 96, 112, 128, 144, 160, 176, 192, 224, 256, 0,
48        ],
49        [
50            0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, 0,
51        ],
52        [
53            0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, 0,
54        ],
55    ],
56];
57
58/// mpg123's `head_check` (layer III only here).
59fn head_check(h: u32) -> bool {
60    (h & 0xffe0_0000) == 0xffe0_0000
61        && (h >> 17) & 3 != 0
62        && (h >> 12) & 0xf != 0xf
63        && (h >> 10) & 3 != 3
64}
65
66#[derive(Clone, Copy, Debug, PartialEq, Eq)]
67struct Header {
68    lay: u32,
69    lsf: usize,
70    mpeg25: bool,
71    sfreq: usize,
72    error_protection: bool,
73    bitrate_index: usize,
74    padding: usize,
75    mode: u32,
76    mode_ext: u32,
77    stereo: usize,
78    framesize: usize,
79    ssize: usize,
80    spf: usize,
81}
82
83/// `decode_header` for layer III; `free` is the known free-format frame
84/// size (without padding), if any.
85fn decode_header(h: u32, free: Option<usize>) -> Result<Header, String> {
86    let lay = 4 - ((h >> 17) & 3);
87    let ver = (h >> 19) & 3;
88    let (lsf, mpeg25, sfreq) = if ver & 2 != 0 {
89        let lsf = if ver & 1 != 0 { 0 } else { 1 };
90        (lsf, false, ((h >> 10) & 3) as usize + lsf * 3)
91    } else {
92        (1, true, 6 + ((h >> 10) & 3) as usize)
93    };
94    let bitrate_index = ((h >> 12) & 0xf) as usize;
95    if lay != 3 {
96        return Err(format!(
97            "MPEG audio layer {lay} is not supported (layer III only)"
98        ));
99    }
100    let padding = ((h >> 9) & 1) as usize;
101    let mode = (h >> 6) & 3;
102    let stereo = if mode == 3 { 1 } else { 2 };
103    let error_protection = (h >> 16) & 1 == 0;
104    let mut ssize = if lsf == 1 {
105        if stereo == 1 {
106            9
107        } else {
108            17
109        }
110    } else if stereo == 1 {
111        17
112    } else {
113        32
114    };
115    if error_protection {
116        ssize += 2;
117    }
118    let framesize = if bitrate_index == 0 {
119        free.ok_or("free-format frame size unknown")? + padding
120    } else {
121        let mut fs = TABSEL[lsf][2][bitrate_index] as i64 * 144000;
122        fs /= (FREQS[sfreq] as i64) << lsf;
123        fs += padding as i64 - 4;
124        fs as usize
125    };
126    if framesize < ssize || framesize > MAXFRAMESIZE {
127        return Err("bad MP3 frame size".into());
128    }
129    Ok(Header {
130        lay,
131        lsf,
132        mpeg25,
133        sfreq,
134        error_protection,
135        bitrate_index,
136        padding,
137        mode,
138        mode_ext: (h >> 4) & 3,
139        stereo,
140        framesize,
141        ssize,
142        spf: if lsf == 1 { 576 } else { 1152 },
143    })
144}
145
146/// mpg123's `head_compatible`: same sync/version/layer/sampling rate
147/// (`HDR_CMPMASK`) and the same mono-ness.
148fn head_compatible(a: u32, b: u32) -> bool {
149    (a & 0xfffe_0c00) == (b & 0xfffe_0c00) && ((a >> 6) & 3 == 3) == ((b >> 6) & 3 == 3)
150}
151
152const MAXFRAMESIZE: usize = 3456;
153const BSSPACE: usize = MAXFRAMESIZE + 512 + 4;
154const GAPLESS_DELAY: i64 = 529;
155const PREFRAMES: i64 = 4;
156
157/// The parts of `mpg123_handle` the layer III path touches.
158struct Dec<'a> {
159    data: &'a [u8],
160    filepos: usize,
161    filelen: i64,
162    cpu: Cpu,
163    gainpow2: [f32; 378],
164    long_limit: [[i32; 23]; 9],
165    short_limit: [[i32; 14]; 9],
166    // frame
167    h: Header,
168    /// `fr->freeformat_framesize`, once guessed.
169    freeformat_framesize: Option<usize>,
170    firsthead: u32,
171    oldhead: u32,
172    fsizeold: usize,
173    bsspace: [Vec<u8>; 2],
174    bsnum: usize,
175    /// (buffer, offset) of `bsbuf` / `bsbufold`.
176    bsbuf: (usize, usize),
177    bsbufold: (usize, usize),
178    wp: usize,
179    bitindex: u32,
180    bits_avail: i64,
181    bitreservoir: u32,
182    hybrid_blc: [usize; 2],
183    bo: u32,
184    // track
185    num: i64,
186    track_frames: i64,
187    gapless_frames: i64,
188    begin_s: i64,
189    end_s: i64,
190    begin_os: i64,
191    end_os: i64,
192    fullend_os: i64,
193    firstframe: i64,
194    firstoff: i64,
195    lastframe: i64,
196    lastoff: i64,
197    ignoreframe: i64,
198    mean_frames: i64,
199    mean_framesize: f64,
200    to_decode: bool,
201    to_ignore: bool,
202    fresh: bool,
203    header_change: u32,
204    /// The current frame's output (interleaved f32).
205    out: Vec<f32>,
206    /// `fr->index`: the header position of every frame read (step 1).
207    index: Vec<usize>,
208}
209
210#[derive(Clone, Copy, Default)]
211struct GrInfo {
212    scfsi: i32,
213    part2_3_length: u32,
214    big_values: u32,
215    scalefac_compress: u32,
216    block_type: u32,
217    mixed_block_flag: u32,
218    table_select: [u32; 3],
219    maxband: [i32; 3],
220    maxbandl: i32,
221    maxb: u32,
222    region1start: u32,
223    region2start: u32,
224    preflag: u32,
225    scalefac_scale: u32,
226    count1table_select: u32,
227    /// Offsets into `gainpow2` of `full_gain[3]` and `pow2gain`.
228    full_gain: [i32; 3],
229    pow2gain: i32,
230}
231
232#[derive(Default)]
233struct SideInfo {
234    main_data_begin: u32,
235    ch: [[GrInfo; 2]; 2],
236}
237
238fn f(bits: u32) -> f32 {
239    f32::from_bits(bits)
240}
241
242impl<'a> Dec<'a> {
243    fn new(data: &'a [u8]) -> Self {
244        // `INT123_init_layer3_gainpow2`: pow(2, -0.25 * (i + 210)), exact in
245        // the binary exponent, so split it into 2^-k * 2^(-j/4).
246        let quarter = [
247            1.0f64,
248            0.840_896_415_253_714_5,
249            std::f64::consts::FRAC_1_SQRT_2,
250            0.594_603_557_501_360_5,
251        ];
252        let mut gainpow2 = [0f32; 378];
253        for (k, g) in gainpow2.iter_mut().enumerate() {
254            let e = k as i64 - 256 + 210; // 2^(-e/4)
255            let (q, r) = (e.div_euclid(4), e.rem_euclid(4));
256            *g = (quarter[r as usize] * 2f64.powi(-q as i32)) as f32;
257        }
258        let mut long_limit = [[0i32; 23]; 9];
259        let mut short_limit = [[0i32; 14]; 9];
260        for j in 0..9 {
261            for i in 0..23 {
262                long_limit[j][i] = ((t::BAND_INFO[j].long_idx[i] as i32 - 1 + 8) / 18 + 1).min(32);
263            }
264            for i in 0..14 {
265                short_limit[j][i] = ((t::BAND_INFO[j].short_idx[i] as i32 - 1) / 18 + 1).min(32);
266            }
267        }
268        let mut cpu = Cpu::default();
269        for (i, w) in t::WIN.iter().enumerate() {
270            cpu.st32(WIN + 4 * i as u64, *w);
271        }
272        for (i, w) in t::WIN1.iter().enumerate() {
273            cpu.st32(WIN1 + 4 * i as u64, *w);
274        }
275        // `INT123_make_decode_tables` with outscale 1, then the NEON layout.
276        let mut decwin = [0f32; 512 + 32 + 512];
277        let mut scaleval = -0.5f64;
278        let (mut idx, mut j) = (0i64, 0i64);
279        for i in 0..512i64 {
280            if idx < 512 + 16 {
281                let v = (t::INTWINBASE[j as usize] as f64 * scaleval) as f32;
282                decwin[idx as usize + 16] = v;
283                decwin[idx as usize] = v;
284            }
285            if i % 32 == 31 {
286                idx -= 1023;
287            }
288            if i % 64 == 63 {
289                scaleval = -scaleval;
290            }
291            idx += 32;
292            j += if i < 256 { 1 } else { -1 };
293        }
294        for i in 512..544 {
295            if i & 1 == 0 {
296                decwin[i] = 0.0;
297            }
298        }
299        for i in 0..512 {
300            decwin[544 + i] = -decwin[511 - i];
301        }
302        for i in (0..512).step_by(2) {
303            decwin[i] = -decwin[i];
304        }
305        cpu.put(DECWIN, &decwin);
306        let mut d = Dec {
307            data,
308            filepos: 0,
309            filelen: 0,
310            cpu,
311            gainpow2,
312            long_limit,
313            short_limit,
314            h: decode_header(0xfffb_9000, None).unwrap(),
315            freeformat_framesize: None,
316            firsthead: 0,
317            oldhead: 0,
318            fsizeold: 0,
319            bsspace: [vec![0; BSSPACE], vec![0; BSSPACE]],
320            bsnum: 0,
321            bsbuf: (1, 0),
322            bsbufold: (1, 0),
323            wp: 0,
324            bitindex: 0,
325            bits_avail: 0,
326            bitreservoir: 0,
327            hybrid_blc: [0, 0],
328            bo: 1,
329            num: -1,
330            track_frames: 0,
331            gapless_frames: -1,
332            begin_s: 0,
333            end_s: 0,
334            begin_os: 0,
335            end_os: 0,
336            fullend_os: 0,
337            firstframe: 0,
338            firstoff: 0,
339            lastframe: -1,
340            lastoff: 0,
341            ignoreframe: -PREFRAMES,
342            mean_frames: 0,
343            mean_framesize: 0.0,
344            to_decode: false,
345            to_ignore: false,
346            fresh: true,
347            header_change: 0,
348            out: Vec::new(),
349            index: Vec::new(),
350        };
351        d.h.framesize = 0;
352        // `get_fileinfo`: the length without a trailing ID3v1 tag.
353        let mut len = data.len() as i64;
354        if data.len() >= 128 && &data[data.len() - 128..data.len() - 125] == b"TAG" {
355            len -= 128;
356        }
357        d.filelen = len;
358        d
359    }
360
361    // ---- getbits.h, on `wordpointer` inside the current `bsbuf` ------------
362
363    fn byte(&self, i: usize) -> u32 {
364        *self.bsspace[self.bsbuf.0].get(i).unwrap_or(&0) as u32
365    }
366    fn getbits(&mut self, n: u32) -> u32 {
367        self.bits_avail -= n as i64;
368        if self.bits_avail < 0 {
369            return 0;
370        }
371        let mut r =
372            (self.byte(self.wp) << 16) | (self.byte(self.wp + 1) << 8) | self.byte(self.wp + 2);
373        r <<= self.bitindex;
374        r &= 0xffffff;
375        self.bitindex += n;
376        r >>= 24 - n;
377        self.wp += (self.bitindex >> 3) as usize;
378        self.bitindex &= 7;
379        r
380    }
381    fn skipbits(&mut self, n: u32) {
382        self.bitindex += n;
383        self.bits_avail -= n as i64;
384        self.wp += (self.bitindex >> 3) as usize;
385        self.bitindex &= 7;
386    }
387    fn getbits_fast(&mut self, n: u32) -> u32 {
388        let mut u = (self.byte(self.wp) << self.bitindex) & 0xff;
389        u |= (self.byte(self.wp + 1) << self.bitindex) >> 8 & 0xff;
390        u <<= n;
391        u >>= 8;
392        self.bitindex += n;
393        self.bits_avail -= n as i64;
394        self.wp += (self.bitindex >> 3) as usize;
395        self.bitindex &= 7;
396        u
397    }
398    fn get1bit(&mut self) -> u32 {
399        let u = (self.byte(self.wp) << self.bitindex) & 0xff;
400        self.bitindex += 1;
401        self.bits_avail -= 1;
402        self.wp += (self.bitindex >> 3) as usize;
403        self.bitindex &= 7;
404        u >> 7
405    }
406    fn getbyte(&mut self) -> u32 {
407        self.bits_avail -= 8;
408        if self.bits_avail >= 0 {
409            let b = self.byte(self.wp);
410            self.wp += 1;
411            b
412        } else {
413            0
414        }
415    }
416    fn backbits(&mut self, n: i64) {
417        self.bits_avail += n;
418        let bi = self.bitindex as i64 - n;
419        self.wp = (self.wp as i64 + (bi >> 3)) as usize;
420        self.bitindex = (bi & 7) as u32;
421    }
422    fn getbitoffset(&self) -> u32 {
423        self.bitindex.wrapping_neg() & 7
424    }
425
426    fn set_pointer(&mut self, part2: bool, backstep: usize) {
427        self.bitindex = 0;
428        let (b, off) = self.bsbuf;
429        if part2 {
430            self.wp = off + self.h.ssize - backstep;
431            if backstep > 0 {
432                let (ob, ooff) = self.bsbufold;
433                let src = ooff + self.fsizeold - backstep;
434                let tmp: Vec<u8> = self.bsspace[ob][src..src + backstep].to_vec();
435                self.bsspace[b][self.wp..self.wp + backstep].copy_from_slice(&tmp);
436            }
437            self.bits_avail = (self.h.framesize as i64 - self.h.ssize as i64 + backstep as i64) * 8;
438        } else {
439            self.wp = off;
440            self.bits_avail = self.h.ssize as i64 * 8;
441        }
442    }
443}
444
445const SINGLE_STEREO: i32 = -1;
446
447impl Dec<'_> {
448    /// `III_get_side_info`; `Err` is mpg123's "bad frame".
449    fn get_side_info(
450        &mut self,
451        si: &mut SideInfo,
452        stereo: usize,
453        ms_stereo: bool,
454        sfreq: usize,
455    ) -> Result<(), ()> {
456        let powdiff = 0; // single != SINGLE_MIX
457        let lsf = self.h.lsf;
458        let tab: [u32; 5] = if lsf == 0 {
459            [2, 9, 5, 3, 4]
460        } else {
461            [1, 8, 1, 2, 9]
462        };
463        let mut needbits = tab[1] + if stereo == 1 { tab[2] } else { tab[3] };
464        if lsf == 0 {
465            needbits += stereo as u32 * 4;
466        }
467        needbits +=
468            tab[0] * stereo as u32 * (29 + tab[4] + 1 + 22 + if lsf == 0 { 1 } else { 0 } + 2);
469        if self.bits_avail < needbits as i64 {
470            return Err(());
471        }
472        si.main_data_begin = self.getbits(tab[1]);
473        if si.main_data_begin > self.bitreservoir {
474            self.backbits(tab[1] as i64);
475            let b = self.bsbuf.0;
476            let wp = self.wp;
477            if lsf == 0 {
478                self.bsspace[b][wp] = (self.bitreservoir >> 1) as u8;
479                self.bsspace[b][wp + 1] = ((self.bitreservoir & 1) << 7) as u8;
480            } else {
481                self.bsspace[b][wp] = self.bitreservoir as u8;
482            }
483            for k in 2..self.h.ssize {
484                self.bsspace[b][wp + k] = 0;
485            }
486            si.main_data_begin = self.getbits(tab[1]);
487        }
488        self.bitreservoir = self.bitreservoir + self.h.framesize as u32 - self.h.ssize as u32;
489        let cap = if lsf == 0 { 511 } else { 255 };
490        if self.bitreservoir > cap {
491            self.bitreservoir = cap;
492        }
493        let _private_bits = self.getbits(if stereo == 1 { tab[2] } else { tab[3] });
494        if lsf == 0 {
495            for ch in 0..stereo {
496                si.ch[ch][0].scfsi = -1;
497                si.ch[ch][1].scfsi = self.getbits(4) as i32;
498            }
499        }
500        let bi = &t::BAND_INFO[sfreq];
501        for gr in 0..tab[0] as usize {
502            for ch in 0..stereo {
503                let mut g = si.ch[ch][gr];
504                g.part2_3_length = self.getbits(12);
505                g.big_values = self.getbits(9).min(288);
506                let qss = self.getbits_fast(8) as i32;
507                g.pow2gain = 256 - qss + powdiff + if ms_stereo { 2 } else { 0 };
508                g.scalefac_compress = self.getbits(tab[4]);
509                if g.part2_3_length == 0 {
510                    g.scalefac_compress = 0;
511                }
512                if self.getbits(1) != 0 {
513                    g.block_type = self.getbits_fast(2);
514                    g.mixed_block_flag = self.get1bit();
515                    g.table_select[0] = self.getbits_fast(5);
516                    g.table_select[1] = self.getbits_fast(5);
517                    g.table_select[2] = 0;
518                    for i in 0..3 {
519                        let sbg = (self.getbits_fast(3) << 3) as i32;
520                        g.full_gain[i] = g.pow2gain + sbg;
521                    }
522                    if g.block_type == 0 {
523                        return Err(());
524                    }
525                    if (lsf == 0 || g.block_type == 2) && !self.h.mpeg25 {
526                        g.region1start = 36 >> 1;
527                        g.region2start = 576 >> 1;
528                    } else if self.h.mpeg25 {
529                        let r0c = if g.block_type == 2 && g.mixed_block_flag == 0 {
530                            5
531                        } else {
532                            7
533                        };
534                        let r1c = 20 - r0c;
535                        g.region1start = bi.long_idx[r0c + 1] as u32 >> 1;
536                        g.region2start = bi.long_idx[r0c + 1 + r1c + 1] as u32 >> 1;
537                    } else {
538                        g.region1start = 54 >> 1;
539                        g.region2start = 576 >> 1;
540                    }
541                } else {
542                    for i in 0..3 {
543                        g.table_select[i] = self.getbits_fast(5);
544                    }
545                    let r0c = self.getbits_fast(4) as usize;
546                    let r1c = self.getbits_fast(3) as usize;
547                    g.region1start = bi.long_idx[r0c + 1] as u32 >> 1;
548                    g.region2start = if r0c + 1 + r1c + 1 > 22 {
549                        576 >> 1
550                    } else {
551                        bi.long_idx[r0c + 1 + r1c + 1] as u32 >> 1
552                    };
553                    g.block_type = 0;
554                    g.mixed_block_flag = 0;
555                }
556                if lsf == 0 {
557                    g.preflag = self.get1bit();
558                }
559                g.scalefac_scale = self.get1bit();
560                g.count1table_select = self.get1bit();
561                si.ch[ch][gr] = g;
562            }
563        }
564        Ok(())
565    }
566
567    /// `III_get_scale_factors_1`; `None` for "not enough bits".
568    fn scale_factors_1(&mut self, scf: &mut [i32; 39], g: &GrInfo) -> Option<i32> {
569        const SLEN: [[u32; 16]; 2] = [
570            [0, 0, 0, 0, 3, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4],
571            [0, 1, 2, 3, 0, 1, 2, 3, 1, 2, 3, 1, 2, 3, 2, 3],
572        ];
573        let num0 = SLEN[0][g.scalefac_compress as usize];
574        let num1 = SLEN[1][g.scalefac_compress as usize];
575        let mut p = 0;
576        let numbits;
577        if g.block_type == 2 {
578            numbits = ((num0 + num1) * 18 - if g.mixed_block_flag != 0 { num0 } else { 0 }) as i32;
579            if self.bits_avail < numbits as i64 {
580                return None;
581            }
582            let mut i = 18;
583            if g.mixed_block_flag != 0 {
584                for _ in 0..8 {
585                    scf[p] = self.getbits_fast(num0) as i32;
586                    p += 1;
587                }
588                i = 9;
589            }
590            for _ in 0..i {
591                scf[p] = self.getbits_fast(num0) as i32;
592                p += 1;
593            }
594            for _ in 0..18 {
595                scf[p] = self.getbits_fast(num1) as i32;
596                p += 1;
597            }
598            scf[p] = 0;
599            scf[p + 1] = 0;
600            scf[p + 2] = 0;
601        } else {
602            let scfsi = g.scfsi;
603            if scfsi < 0 {
604                numbits = ((num0 + num1) * 10 + num0) as i32;
605                if self.bits_avail < numbits as i64 {
606                    return None;
607                }
608                for _ in 0..11 {
609                    scf[p] = self.getbits_fast(num0) as i32;
610                    p += 1;
611                }
612                for _ in 0..10 {
613                    scf[p] = self.getbits_fast(num1) as i32;
614                    p += 1;
615                }
616                scf[p] = 0;
617            } else {
618                let nb = |bit: i32, n: u32, k: u32| if scfsi & bit == 0 { n * k } else { 0 };
619                numbits =
620                    (nb(8, num0, 6) + nb(4, num0, 5) + nb(2, num1, 5) + nb(1, num1, 5)) as i32;
621                if self.bits_avail < numbits as i64 {
622                    return None;
623                }
624                for (bit, n, k) in [(8, num0, 6), (4, num0, 5), (2, num1, 5), (1, num1, 5)] {
625                    if scfsi & bit == 0 {
626                        for _ in 0..k {
627                            scf[p] = self.getbits_fast(n) as i32;
628                            p += 1;
629                        }
630                    } else {
631                        p += k;
632                    }
633                }
634                scf[p] = 0;
635            }
636        }
637        Some(numbits)
638    }
639
640    /// `III_get_scale_factors_2`.
641    fn scale_factors_2(
642        &mut self,
643        scf: &mut [i32; 39],
644        g: &mut GrInfo,
645        i_stereo: bool,
646    ) -> Option<i32> {
647        const STAB: [[[u32; 4]; 6]; 3] = [
648            [
649                [6, 5, 5, 5],
650                [6, 5, 7, 3],
651                [11, 10, 0, 0],
652                [7, 7, 7, 0],
653                [6, 6, 6, 3],
654                [8, 8, 5, 0],
655            ],
656            [
657                [9, 9, 9, 9],
658                [9, 9, 12, 6],
659                [18, 18, 0, 0],
660                [12, 12, 12, 0],
661                [12, 9, 9, 6],
662                [15, 12, 9, 0],
663            ],
664            [
665                [6, 9, 9, 9],
666                [6, 9, 12, 6],
667                [15, 18, 0, 0],
668                [6, 15, 12, 0],
669                [6, 12, 9, 6],
670                [6, 18, 9, 0],
671            ],
672        ];
673        let mut slen = if i_stereo {
674            t::I_SLEN2[(g.scalefac_compress >> 1) as usize] as u32
675        } else {
676            t::N_SLEN2[g.scalefac_compress as usize] as u32
677        };
678        g.preflag = (slen >> 15) & 1;
679        let mut n = 0;
680        if g.block_type == 2 {
681            n += 1;
682            if g.mixed_block_flag != 0 {
683                n += 1;
684            }
685        }
686        let pnt = &STAB[n][((slen >> 12) & 7) as usize];
687        let mut numbits = 0u32;
688        let mut slen2 = slen;
689        for &pi in pnt {
690            let num = slen2 & 7;
691            slen2 >>= 3;
692            if num != 0 {
693                numbits += pi * num;
694            }
695        }
696        if numbits > g.part2_3_length {
697            return None;
698        }
699        let mut p = 0;
700        for &pi in pnt {
701            let num = slen & 7;
702            slen >>= 3;
703            for _ in 0..pi {
704                scf[p] = if num != 0 {
705                    self.getbits_fast(num) as i32
706                } else {
707                    0
708                };
709                p += 1;
710            }
711        }
712        for _ in 0..(n << 1) + 1 {
713            scf[p] = 0;
714            p += 1;
715        }
716        Some(numbits as i32)
717    }
718}
719
720/// The `REFRESH_MASK` / `MSB_MASK` state of `III_dequantize_sample`.
721struct Mask {
722    mask: u32,
723    num: i32,
724    part2remain: i32,
725}
726
727impl Dec<'_> {
728    #[inline]
729    fn refresh(&mut self, m: &mut Mask) {
730        while m.num < 24 {
731            m.mask |= self.getbyte().wrapping_shl((24 - m.num) as u32);
732            m.num += 8;
733            m.part2remain -= 8;
734        }
735    }
736
737    /// `III_dequantize_sample` (USE_NEW_HUFFTABLE, no CUT_SFB21); `Err` is
738    /// mpg123's dequantisation failure.
739    fn dequantize(
740        &mut self,
741        xr: &mut [f32; 576],
742        scf: &[i32; 39],
743        g: &mut GrInfo,
744        sfreq: usize,
745        part2bits: i32,
746    ) -> Result<(), ()> {
747        let shift = 1 + g.scalefac_scale;
748        let mut xi: usize = 0; // xrpnt
749        let mut m = Mask {
750            mask: 0,
751            num: 0,
752            part2remain: g.part2_3_length as i32 - part2bits,
753        };
754        let ispow = |x: i32| f(t::ISPOW[x as usize]);
755        let mut sp = 0usize; // scf pointer
756        if g.part2_3_length > 0 {
757            let num = self.getbitoffset();
758            m.mask = self.getbits(num) << 24;
759            m.mask <<= 8 - num;
760            m.num = num as i32;
761            m.part2remain -= num as i32;
762            let bv = g.big_values as i32;
763            let region1 = g.region1start as i32;
764            let region2 = g.region2start as i32;
765            let mut l3 = ((576 >> 1) - bv) >> 1;
766            let l: [i32; 3] = if bv <= region1 {
767                [bv, 0, 0]
768            } else if bv <= region2 {
769                [region1, bv - region1, 0]
770            } else {
771                [region1, region2 - region1, bv - region2]
772            };
773            let msb = |mask: u32| mask & 0x8000_0000 != 0;
774
775            if g.block_type == 2 {
776                let mut max = [-1i32; 4];
777                let (mut step, mut lwin, mut cb) = (0usize, 3usize, 0i32);
778                let mut v = 0f32;
779                let (map, base, end): (&[i16], usize, usize) = if g.mixed_block_flag != 0 {
780                    max = [2, 2, 2, -1];
781                    (
782                        &t::MAPBUF0,
783                        sfreq * 152,
784                        sfreq * 152 + if sfreq < 3 { 152 } else { 144 },
785                    )
786                } else {
787                    (&t::MAPBUF1, sfreq * 156, sfreq * 156 + 156)
788                };
789                let mut mi = base;
790                let mut mc = 0i32;
791                macro_rules! next_band {
792                    () => {{
793                        mc = map[mi] as i32;
794                        xi = map[mi + 1] as usize;
795                        lwin = map[mi + 2] as usize;
796                        cb = map[mi + 3] as i32;
797                        mi += 4;
798                        if lwin == 3 {
799                            v = self.gainpow2[(g.pow2gain + (scf[sp] << shift)) as usize];
800                            step = 1;
801                        } else {
802                            v = self.gainpow2[(g.full_gain[lwin] + (scf[sp] << shift)) as usize];
803                            step = 3;
804                        }
805                        sp += 1;
806                    }};
807                }
808                for i in 0..2 {
809                    let mut lp = l[i];
810                    let (linbits, table) = t::HT[g.table_select[i] as usize];
811                    while lp > 0 {
812                        if mc == 0 {
813                            next_band!();
814                        }
815                        let (mut x, mut y) = self.huff_pair(&mut m, table);
816                        for val in [&mut x, &mut y] {
817                            if xi >= 576 {
818                                return Err(());
819                            }
820                            if *val == 15 && linbits != 0 {
821                                max[lwin] = cb;
822                                self.refresh(&mut m);
823                                *val += (m.mask >> (32 - linbits)) as i32;
824                                m.num -= linbits as i32 + 1;
825                                m.mask <<= linbits;
826                                xr[xi] = if msb(m.mask) {
827                                    -ispow(*val) * v
828                                } else {
829                                    ispow(*val) * v
830                                };
831                                m.mask <<= 1;
832                            } else if *val != 0 {
833                                max[lwin] = cb;
834                                xr[xi] = if msb(m.mask) {
835                                    -ispow(*val) * v
836                                } else {
837                                    ispow(*val) * v
838                                };
839                                m.num -= 1;
840                                m.mask <<= 1;
841                            } else {
842                                xr[xi] = 0.0;
843                            }
844                            xi += step;
845                        }
846                        lp -= 1;
847                        mc -= 1;
848                    }
849                }
850                while l3 > 0 && m.part2remain + m.num > 0 {
851                    let a = self.huff_count1(&mut m, t::HTC[g.count1table_select as usize].1);
852                    if m.part2remain + m.num <= 0 {
853                        m.num -= m.part2remain + m.num;
854                        break;
855                    }
856                    for i in 0..4 {
857                        if i & 1 == 0 {
858                            if mc == 0 {
859                                next_band!();
860                            }
861                            mc -= 1;
862                        }
863                        if xi >= 576 {
864                            return Err(());
865                        }
866                        if a & (0x8 >> i) != 0 {
867                            max[lwin] = cb;
868                            if m.part2remain + m.num <= 0 {
869                                break;
870                            }
871                            xr[xi] = if msb(m.mask) { -v } else { v };
872                            m.num -= 1;
873                            m.mask <<= 1;
874                        } else {
875                            xr[xi] = 0.0;
876                        }
877                        xi += step;
878                    }
879                    l3 -= 1;
880                }
881                if lwin < 3 {
882                    loop {
883                        while mc > 0 {
884                            if xi >= 576 {
885                                return Err(());
886                            }
887                            xr[xi] = 0.0;
888                            xi += 3;
889                            if xi < 576 {
890                                xr[xi] = 0.0;
891                            }
892                            xi += 3;
893                            mc -= 1;
894                        }
895                        if mi >= end {
896                            break;
897                        }
898                        mc = map[mi] as i32;
899                        xi = map[mi + 1] as usize;
900                        let lw = map[mi + 2];
901                        mi += 3;
902                        if lw == 0 {
903                            break;
904                        }
905                        mi += 1;
906                    }
907                }
908                g.maxband = [max[0] + 1, max[1] + 1, max[2] + 1];
909                g.maxbandl = max[3] + 1;
910                let rmax = max[0].max(max[1]).max(max[2]) + 1;
911                g.maxb = if rmax != 0 {
912                    self.short_limit[sfreq][rmax as usize]
913                } else {
914                    self.long_limit[sfreq][(max[3] + 1) as usize]
915                } as u32;
916            } else {
917                let pretab: &[u8] = if g.preflag != 0 {
918                    &t::PRETAB[22..]
919                } else {
920                    &t::PRETAB[..22]
921                };
922                let mut pp = 0usize;
923                let mut max = -1i32;
924                let mut cb = 0i32;
925                let map = &t::MAPBUF2;
926                let mut mi = sfreq * 44;
927                let mut v = 0f32;
928                let mut mc = 0i32;
929                macro_rules! next_band {
930                    () => {{
931                        mc = map[mi] as i32;
932                        cb = map[mi + 1] as i32;
933                        mi += 2;
934                        v = self.gainpow2
935                            [(g.pow2gain + ((scf[sp] + pretab[pp] as i32) << shift)) as usize];
936                        sp += 1;
937                        pp += 1;
938                    }};
939                }
940                for i in 0..3 {
941                    let mut lp = l[i];
942                    let (linbits, table) = t::HT[g.table_select[i] as usize];
943                    while lp > 0 {
944                        if mc == 0 {
945                            next_band!();
946                        }
947                        let (mut x, mut y) = self.huff_pair(&mut m, table);
948                        for val in [&mut x, &mut y] {
949                            if xi >= 576 {
950                                return Err(());
951                            }
952                            if *val == 15 && linbits != 0 {
953                                max = cb;
954                                self.refresh(&mut m);
955                                *val += (m.mask >> (32 - linbits)) as i32;
956                                m.num -= linbits as i32 + 1;
957                                m.mask <<= linbits;
958                                xr[xi] = if msb(m.mask) {
959                                    -ispow(*val) * v
960                                } else {
961                                    ispow(*val) * v
962                                };
963                                m.mask <<= 1;
964                            } else if *val != 0 {
965                                max = cb;
966                                xr[xi] = if msb(m.mask) {
967                                    -ispow(*val) * v
968                                } else {
969                                    ispow(*val) * v
970                                };
971                                m.num -= 1;
972                                m.mask <<= 1;
973                            } else {
974                                xr[xi] = 0.0;
975                            }
976                            xi += 1;
977                        }
978                        lp -= 1;
979                        mc -= 1;
980                    }
981                }
982                while l3 > 0 && m.part2remain + m.num > 0 {
983                    let a = self.huff_count1(&mut m, t::HTC[g.count1table_select as usize].1);
984                    if m.part2remain + m.num <= 0 {
985                        m.num -= m.part2remain + m.num;
986                        break;
987                    }
988                    for i in 0..4 {
989                        if i & 1 == 0 {
990                            if mc == 0 {
991                                next_band!();
992                            }
993                            mc -= 1;
994                        }
995                        if xi >= 576 {
996                            return Err(());
997                        }
998                        if a & (0x8 >> i) != 0 {
999                            max = cb;
1000                            if m.part2remain + m.num <= 0 {
1001                                break;
1002                            }
1003                            xr[xi] = if msb(m.mask) { -v } else { v };
1004                            m.num -= 1;
1005                            m.mask <<= 1;
1006                        } else {
1007                            xr[xi] = 0.0;
1008                        }
1009                        xi += 1;
1010                    }
1011                    l3 -= 1;
1012                }
1013                g.maxbandl = max + 1;
1014                g.maxb = self.long_limit[sfreq][g.maxbandl as usize] as u32;
1015            }
1016            m.part2remain += m.num;
1017            self.backbits(m.num as i64);
1018        } else {
1019            m.part2remain = 0;
1020            g.maxband = [1, 1, 1];
1021            g.maxbandl = 1;
1022            g.maxb = 1;
1023        }
1024        while xi < 576 {
1025            xr[xi] = 0.0;
1026            xi += 1;
1027        }
1028        while m.part2remain > 16 {
1029            self.skipbits(16);
1030            m.part2remain -= 16;
1031        }
1032        if m.part2remain > 0 {
1033            self.skipbits(m.part2remain as u32);
1034        } else if m.part2remain < 0 {
1035            return Err(());
1036        }
1037        Ok(())
1038    }
1039
1040    /// One big-value pair from a radix-4 `newhuff` table.
1041    #[inline]
1042    fn huff_pair(&mut self, m: &mut Mask, table: &[i16]) -> (i32, i32) {
1043        self.refresh(m);
1044        let mut vi = 0usize;
1045        let mut y;
1046        loop {
1047            y = table[vi + (m.mask >> 28) as usize] as i32;
1048            if y >= 0 {
1049                break;
1050            }
1051            vi = (vi as i32 - y) as usize;
1052            m.num -= 4;
1053            m.mask <<= 4;
1054        }
1055        m.num -= y >> 8;
1056        m.mask = m.mask.wrapping_shl((y >> 8) as u32);
1057        ((y >> 4) & 0xf, y & 0xf)
1058    }
1059
1060    /// A count1 quadruple from a bit-serial table.
1061    #[inline]
1062    fn huff_count1(&mut self, m: &mut Mask, table: &[i16]) -> i32 {
1063        self.refresh(m);
1064        let mut vi = 0usize;
1065        loop {
1066            let a = table[vi] as i32;
1067            vi += 1;
1068            if a >= 0 {
1069                return a;
1070            }
1071            if m.mask & 0x8000_0000 != 0 {
1072                vi = (vi as i32 - a) as usize;
1073            }
1074            m.num -= 1;
1075            m.mask <<= 1;
1076        }
1077    }
1078}
1079
1080impl Dec<'_> {
1081    /// `III_i_stereo`.
1082    fn i_stereo(
1083        xr: &mut [[f32; 576]; 2],
1084        scalefac: &[i32; 39],
1085        g: &GrInfo,
1086        sfreq: usize,
1087        ms_stereo: bool,
1088        lsf: usize,
1089    ) {
1090        let bi = &t::BAND_INFO[sfreq];
1091        let tab = lsf + (g.scalefac_compress as usize & lsf);
1092        let ms = ms_stereo as usize;
1093        let (tab1, tab2): (&[u32], &[u32]) = match (tab, ms) {
1094            (0, 0) => (&t::TAN1_1, &t::TAN2_1),
1095            (0, _) => (&t::TAN1_2, &t::TAN2_2),
1096            (1, 0) => (&t::POW1_1[..32], &t::POW2_1[..32]),
1097            (1, _) => (&t::POW1_2[..32], &t::POW2_2[..32]),
1098            (_, 0) => (&t::POW1_1[32..], &t::POW2_1[32..]),
1099            (_, _) => (&t::POW1_2[32..], &t::POW2_2[32..]),
1100        };
1101        let mut apply = |idx: &mut usize, sb: usize, step: usize, is_p: i32| {
1102            let (t1, t2) = (f(tab1[is_p as usize]), f(tab2[is_p as usize]));
1103            for _ in 0..sb {
1104                let v = xr[0][*idx];
1105                xr[0][*idx] = v * t1;
1106                xr[1][*idx] = v * t2;
1107                *idx += step;
1108            }
1109        };
1110        let mixed = g.mixed_block_flag as i32;
1111        if g.block_type == 2 {
1112            let mut do_l = g.mixed_block_flag != 0;
1113            for lwin in 0..3 {
1114                let mut sfb = g.maxband[lwin];
1115                if sfb > 3 {
1116                    do_l = false;
1117                }
1118                while sfb < 12 {
1119                    let is_p = scalefac[(sfb * 3 + lwin as i32 - mixed) as usize];
1120                    if is_p != 7 {
1121                        let mut idx = bi.short_idx[sfb as usize] as usize + lwin;
1122                        apply(&mut idx, bi.short_diff[sfb as usize] as usize, 3, is_p);
1123                    }
1124                    sfb += 1;
1125                }
1126                let is_p = scalefac[(11 * 3 + lwin as i32 - mixed) as usize];
1127                if is_p != 7 {
1128                    let mut idx = bi.short_idx[12] as usize + lwin;
1129                    apply(&mut idx, bi.short_diff[12] as usize, 3, is_p);
1130                }
1131            }
1132            if do_l {
1133                let mut sfb = g.maxbandl;
1134                if sfb > 21 {
1135                    return;
1136                }
1137                let mut idx = bi.long_idx[sfb as usize] as usize;
1138                while sfb < 8 {
1139                    let sb = bi.long_diff[sfb as usize] as usize;
1140                    let is_p = scalefac[sfb as usize];
1141                    if is_p != 7 {
1142                        apply(&mut idx, sb, 1, is_p);
1143                    } else {
1144                        idx += sb;
1145                    }
1146                    sfb += 1;
1147                }
1148            }
1149        } else {
1150            let mut sfb = g.maxbandl;
1151            if sfb > 21 {
1152                return;
1153            }
1154            let mut idx = bi.long_idx[sfb as usize] as usize;
1155            while sfb < 21 {
1156                let sb = bi.long_diff[sfb as usize] as usize;
1157                let is_p = scalefac[sfb as usize];
1158                if is_p != 7 {
1159                    apply(&mut idx, sb, 1, is_p);
1160                } else {
1161                    idx += sb;
1162                }
1163                sfb += 1;
1164            }
1165            let is_p = scalefac[20];
1166            if is_p != 7 {
1167                apply(&mut idx, bi.long_diff[21] as usize, 1, is_p);
1168            }
1169        }
1170    }
1171
1172    /// `III_antialias` through the vectorised loop of the reference's
1173    /// `INT123_do_layer3`.
1174    fn antialias(&mut self, ch: usize, g: &GrInfo) {
1175        let sblim = if g.block_type == 2 {
1176            if g.mixed_block_flag == 0 {
1177                return;
1178            }
1179            1
1180        } else {
1181            g.maxb as i64 - 1
1182        };
1183        if sblim <= 0 {
1184            return;
1185        }
1186        self.cpu.x[8] = sblim as u64;
1187        self.cpu.x[9] = HYBRID_IN + (ch * 576 * 4) as u64 + 22 * 4;
1188        built::antialias_loop(&mut self.cpu);
1189    }
1190
1191    /// `III_hybrid` with `dct36_neon64` and the C `dct12`.
1192    fn hybrid(&mut self, ch: usize, g: &GrInfo) {
1193        let b = self.hybrid_blc[ch];
1194        let block = |b: usize| HYBRID_BLOCK + ((b * 2 + ch) * 576 * 4) as u64;
1195        let mut raw1 = block(b);
1196        let mut raw2 = block(1 - b);
1197        self.hybrid_blc[ch] = 1 - b;
1198        let fs_in = HYBRID_IN + (ch * 576 * 4) as u64;
1199        let mut ts = HYBRID_OUT + (ch * 576 * 4) as u64;
1200        let mut sb = 0u32;
1201        let c = &mut self.cpu;
1202        let call = |c: &mut Cpu, k: fn(&mut Cpu), inp: u64, o1: u64, o2: u64, w: u64, ts: u64| {
1203            c.x[0] = inp;
1204            c.x[1] = o1;
1205            c.x[2] = o2;
1206            c.x[3] = w;
1207            c.x[4] = ts;
1208            k(c);
1209        };
1210        let row = |sb: u32| fs_in + (sb as u64) * 18 * 4;
1211        if g.mixed_block_flag != 0 {
1212            sb = 2;
1213            call(c, built::INT123_dct36_neon64, row(0), raw1, raw2, WIN, ts);
1214            call(
1215                c,
1216                built::INT123_dct36_neon64,
1217                row(1),
1218                raw1 + 72,
1219                raw2 + 72,
1220                WIN1,
1221                ts + 4,
1222            );
1223            raw1 += 144;
1224            raw2 += 144;
1225            ts += 8;
1226        }
1227        let bt = g.block_type as u64;
1228        while sb < g.maxb {
1229            if bt == 2 {
1230                call(c, built::dct12, row(sb), raw1, raw2, WIN + 2 * 144, ts);
1231                call(
1232                    c,
1233                    built::dct12,
1234                    row(sb + 1),
1235                    raw1 + 72,
1236                    raw2 + 72,
1237                    WIN1 + 2 * 144,
1238                    ts + 4,
1239                );
1240            } else {
1241                call(
1242                    c,
1243                    built::INT123_dct36_neon64,
1244                    row(sb),
1245                    raw1,
1246                    raw2,
1247                    WIN + bt * 144,
1248                    ts,
1249                );
1250                call(
1251                    c,
1252                    built::INT123_dct36_neon64,
1253                    row(sb + 1),
1254                    raw1 + 72,
1255                    raw2 + 72,
1256                    WIN1 + bt * 144,
1257                    ts + 4,
1258                );
1259            }
1260            sb += 2;
1261            ts += 8;
1262            raw1 += 144;
1263            raw2 += 144;
1264        }
1265        while sb < 32 {
1266            for i in 0..18u64 {
1267                let v = c.ld32(raw1);
1268                c.st32(ts + i * 32 * 4, v);
1269                c.st32(raw2, 0);
1270                raw1 += 4;
1271                raw2 += 4;
1272            }
1273            sb += 1;
1274            ts += 4;
1275        }
1276    }
1277
1278    /// `INT123_synth_1to1_real_neon64` through the `synth_mono` wrapper:
1279    /// 32 samples into `out`.
1280    fn synth_mono(&mut self, band: u64) {
1281        self.bo = self.bo.wrapping_sub(1) & 0xf;
1282        let buf = |j: u64| REAL_BUFFS + j * 0x110 * 4;
1283        let c = &mut self.cpu;
1284        let bo = self.bo as u64;
1285        let (b0, bo1) = if bo & 1 != 0 {
1286            c.x[0] = buf(1) + ((bo + 1) & 0xf) * 4;
1287            c.x[1] = buf(0) + bo * 4;
1288            (buf(0), bo)
1289        } else {
1290            c.x[0] = buf(0) + bo * 4;
1291            c.x[1] = buf(1) + (bo + 1) * 4;
1292            (buf(1), bo + 1)
1293        };
1294        c.x[2] = band;
1295        built::INT123_dct64_real_neon64(c);
1296        c.x[0] = DECWIN;
1297        c.x[1] = b0;
1298        c.x[2] = MONO_TMP;
1299        c.x[3] = bo1;
1300        built::INT123_synth_1to1_real_neon64_asm(c);
1301        for i in 0..32 {
1302            self.out.push(f(self.cpu.ld32(MONO_TMP + 8 * i)));
1303        }
1304    }
1305
1306    /// `INT123_synth_1to1_fltst_neon64`: 32 interleaved stereo samples.
1307    fn synth_stereo(&mut self, band_l: u64, band_r: u64) {
1308        self.bo = self.bo.wrapping_sub(1) & 0xf;
1309        let buf = |ch: u64, j: u64| REAL_BUFFS + (ch * 2 + j) * 0x110 * 4;
1310        let c = &mut self.cpu;
1311        let bo = self.bo as u64;
1312        let (j0, j1, bo1, a, b) = if bo & 1 != 0 {
1313            (0, 1, bo, (bo + 1) & 0xf, bo)
1314        } else {
1315            (1, 0, bo + 1, bo, bo + 1)
1316        };
1317        for (ch, band) in [(0, band_l), (1, band_r)] {
1318            if bo & 1 != 0 {
1319                c.x[0] = buf(ch, 1) + a * 4;
1320                c.x[1] = buf(ch, 0) + b * 4;
1321            } else {
1322                c.x[0] = buf(ch, 0) + a * 4;
1323                c.x[1] = buf(ch, 1) + b * 4;
1324            }
1325            c.x[2] = band;
1326            built::INT123_dct64_real_neon64(c);
1327        }
1328        let _ = j1;
1329        c.x[0] = DECWIN;
1330        c.x[1] = buf(0, j0);
1331        c.x[2] = buf(1, j0);
1332        c.x[3] = SAMPLES;
1333        c.x[4] = bo1;
1334        built::INT123_synth_1to1_real_s_neon64_asm(c);
1335        for i in 0..64 {
1336            self.out.push(f(self.cpu.ld32(SAMPLES + 4 * i)));
1337        }
1338    }
1339}
1340
1341impl Dec<'_> {
1342    /// `INT123_do_layer3` for libsndfile's setup (no forced mono); appends
1343    /// to `out` whatever the frame produced before any error.
1344    fn do_layer3(&mut self) {
1345        let stereo = self.h.stereo;
1346        let single = SINGLE_STEREO;
1347        let sfreq = self.h.sfreq;
1348        let (ms_stereo, i_stereo) = if self.h.mode == 1 {
1349            (self.h.mode_ext & 2 != 0, self.h.mode_ext & 1 != 0)
1350        } else {
1351            (false, false)
1352        };
1353        let granules = if self.h.lsf != 0 { 1 } else { 2 };
1354        let mut si = SideInfo::default();
1355        if self
1356            .get_side_info(&mut si, stereo, ms_stereo, sfreq)
1357            .is_err()
1358        {
1359            return;
1360        }
1361        self.set_pointer(true, si.main_data_begin as usize);
1362        let mut scalefacs = [[0i32; 39]; 2];
1363        let mut xr = Box::new([[0f32; 576]; 2]);
1364        for gr in 0..granules {
1365            {
1366                let mut g = si.ch[0][gr];
1367                if g.part2_3_length as i64 > self.bits_avail {
1368                    return;
1369                }
1370                let part2bits = if self.h.lsf != 0 {
1371                    self.scale_factors_2(&mut scalefacs[0], &mut g, false)
1372                } else {
1373                    self.scale_factors_1(&mut scalefacs[0], &g)
1374                };
1375                let Some(part2bits) = part2bits else { return };
1376                let r = self.dequantize(&mut xr[0], &scalefacs[0], &mut g, sfreq, part2bits);
1377                si.ch[0][gr] = g;
1378                if r.is_err() || self.bits_avail < 0 {
1379                    return;
1380                }
1381            }
1382            if stereo == 2 {
1383                let mut g = si.ch[1][gr];
1384                let part2bits = if self.h.lsf != 0 {
1385                    self.scale_factors_2(&mut scalefacs[1], &mut g, i_stereo)
1386                } else {
1387                    self.scale_factors_1(&mut scalefacs[1], &g)
1388                };
1389                let Some(part2bits) = part2bits else { return };
1390                let r = self.dequantize(&mut xr[1], &scalefacs[1], &mut g, sfreq, part2bits);
1391                si.ch[1][gr] = g;
1392                if r.is_err() || self.bits_avail < 0 {
1393                    return;
1394                }
1395                if ms_stereo {
1396                    let maxb = si.ch[0][gr].maxb.max(si.ch[1][gr].maxb) as usize;
1397                    for i in 0..18 * maxb {
1398                        let (a, b) = (xr[0][i], xr[1][i]);
1399                        xr[0][i] = a + b;
1400                        xr[1][i] = a - b;
1401                    }
1402                }
1403                if i_stereo {
1404                    let g1 = si.ch[1][gr];
1405                    Self::i_stereo(&mut xr, &scalefacs[1], &g1, sfreq, ms_stereo, self.h.lsf);
1406                }
1407                if ms_stereo || i_stereo {
1408                    if si.ch[1][gr].maxb > si.ch[0][gr].maxb {
1409                        si.ch[0][gr].maxb = si.ch[1][gr].maxb;
1410                    } else {
1411                        si.ch[1][gr].maxb = si.ch[0][gr].maxb;
1412                    }
1413                }
1414            }
1415            let stereo1 = if stereo == 1 || single != SINGLE_STEREO {
1416                1
1417            } else {
1418                2
1419            };
1420            for ch in 0..stereo1 {
1421                self.cpu.put(HYBRID_IN + (ch * 576 * 4) as u64, &xr[ch]);
1422                let g = si.ch[ch][gr];
1423                self.antialias(ch, &g);
1424                self.hybrid(ch, &g);
1425            }
1426            for ss in 0..18u64 {
1427                let a = HYBRID_OUT + ss * 32 * 4;
1428                if stereo1 == 1 {
1429                    self.synth_mono(a);
1430                } else {
1431                    self.synth_stereo(a, a + 576 * 4);
1432                }
1433            }
1434        }
1435    }
1436
1437    // ---- parse.c ------------------------------------------------------------
1438
1439    fn head_at(&self, pos: usize) -> Option<u32> {
1440        let b = self.data.get(pos..pos + 4)?;
1441        Some(u32::from_be_bytes(b.try_into().unwrap()))
1442    }
1443
1444    /// `decode_header` at `pos`, guessing a free-format frame size from the
1445    /// next matching header (`guess_freeformat_framesize`).
1446    fn header(&mut self, pos: usize, h: u32) -> Option<Header> {
1447        if !head_check(h) {
1448            return None;
1449        }
1450        if (h >> 12) & 0xf == 0 && self.freeformat_framesize.is_none() {
1451            const SAMEMASK: u32 = 0xfffe_fcc0;
1452            let i = (4..MAXFRAMESIZE + 4).find(|&i| {
1453                self.head_at(pos + i + 1)
1454                    .is_some_and(|n| n & SAMEMASK == h & SAMEMASK)
1455            })?;
1456            self.freeformat_framesize = Some(i - 3 - ((h >> 9) & 1) as usize);
1457        }
1458        decode_header(h, self.freeformat_framesize).ok()
1459    }
1460
1461    /// The first header: skip ID3v2 tags and junk, accept a header whose
1462    /// successor (if any) is compatible (`skip_junk` + `do_readahead`).
1463    fn sync_first(&mut self) -> Option<(u32, Header)> {
1464        let mut pos = self.filepos;
1465        let mut junk = 0;
1466        loop {
1467            let d = self.data.get(pos..)?;
1468            if d.len() >= 10
1469                && &d[..3] == b"ID3"
1470                && d[3] != 0xff
1471                && d[4] != 0xff
1472                && d[6..10].iter().all(|b| b & 0x80 == 0)
1473            {
1474                let size = d[6..10].iter().fold(0usize, |a, &b| (a << 7) | b as usize);
1475                pos += 10 + size + if d[5] & 0x10 != 0 { 10 } else { 0 };
1476                continue;
1477            }
1478            let h = self.head_at(pos)?;
1479            if head_check(h) {
1480                if let Some(hd) = self.header(pos, h) {
1481                    let next = pos + 4 + hd.framesize;
1482                    match self.head_at(next) {
1483                        Some(nh) if !(head_check(nh) && head_compatible(h, nh)) => {}
1484                        _ => {
1485                            self.filepos = pos + 4;
1486                            return Some((h, hd));
1487                        }
1488                    }
1489                }
1490            }
1491            pos += 1;
1492            junk += 1;
1493            if junk >= 65536 {
1494                return None;
1495            }
1496        }
1497    }
1498
1499    /// A later header: resync forward to a compatible one.
1500    fn sync_next(&mut self) -> Option<(u32, Header)> {
1501        let mut pos = self.filepos;
1502        for _ in 0..=1024 {
1503            let h = self.head_at(pos)?;
1504            if head_check(h) {
1505                if let Some(hd) = self.header(pos, h) {
1506                    if pos == self.filepos || head_compatible(self.firsthead, h) {
1507                        self.filepos = pos + 4;
1508                        return Some((h, hd));
1509                    }
1510                }
1511            }
1512            pos += 1;
1513        }
1514        None
1515    }
1516
1517    /// `INT123_read_frame`; false at the end of the stream.
1518    fn read_frame(&mut self) -> bool {
1519        self.fsizeold = self.h.framesize;
1520        self.to_decode = false;
1521        self.to_ignore = false;
1522        if (self.track_frames > 0 && self.num >= self.track_frames - 1)
1523            || (self.gapless_frames > 0 && self.num >= self.gapless_frames - 1)
1524        {
1525            return false;
1526        }
1527        let mut framepos;
1528        loop {
1529            let found = if self.firsthead == 0 {
1530                self.sync_first()
1531            } else {
1532                self.sync_next()
1533            };
1534            let Some((newhead, hd)) = found else {
1535                return false;
1536            };
1537            if self.firsthead != 0 && !head_compatible(self.firsthead, newhead) {
1538                return false;
1539            }
1540            framepos = self.filepos - 4;
1541            let Some(body) = self.data.get(self.filepos..self.filepos + hd.framesize) else {
1542                return false;
1543            };
1544            self.h = hd;
1545            let n = self.bsnum;
1546            self.bsspace[n][512..512 + hd.framesize].copy_from_slice(body);
1547            self.filepos += hd.framesize;
1548            self.bsbufold = self.bsbuf;
1549            self.bsbuf = (n, 512);
1550            self.bsnum = (self.bsnum + 1) & 1;
1551            if self.firsthead == 0 {
1552                self.firsthead = newhead;
1553                if self.num < 0 {
1554                    if self.check_lame_tag() {
1555                        self.oldhead = 0;
1556                        continue;
1557                    }
1558                }
1559            }
1560            break;
1561        }
1562        self.set_pointer(false, 0);
1563        self.mean_frames += 1;
1564        self.mean_framesize = ((self.mean_frames - 1) as f64 * self.mean_framesize
1565            + (self.h.framesize as f64 + 4.0))
1566            / self.mean_frames as f64;
1567        self.num += 1;
1568        if self.num as usize == self.index.len() {
1569            self.index.push(framepos);
1570        }
1571        self.to_decode = true;
1572        self.to_ignore = true;
1573        if self.h.error_protection {
1574            let _crc = self.getbits(16);
1575        }
1576        if self.header_change < 2 {
1577            self.header_change = 2;
1578        }
1579        true
1580    }
1581
1582    /// `check_lame_tag`: Xing/Info frame count and LAME delay/padding.
1583    fn check_lame_tag(&mut self) -> bool {
1584        let h = self.h;
1585        let mut lo = if h.stereo == 2 {
1586            if h.lsf != 0 {
1587                17
1588            } else {
1589                32
1590            }
1591        } else if h.lsf != 0 {
1592            9
1593        } else {
1594            17
1595        };
1596        if h.framesize < lo + 8 {
1597            return false;
1598        }
1599        let (b, off) = self.bsbuf;
1600        let buf = self.bsspace[b][off..off + h.framesize].to_vec();
1601        if buf[2..lo].iter().any(|&x| x != 0) {
1602            return false;
1603        }
1604        if &buf[lo..lo + 4] != b"Info" && &buf[lo..lo + 4] != b"Xing" {
1605            return false;
1606        }
1607        let rd = |o: &mut usize| {
1608            let v = u32::from_be_bytes(buf[*o..*o + 4].try_into().unwrap());
1609            *o += 4;
1610            v
1611        };
1612        lo += 4;
1613        let flags = rd(&mut lo);
1614        'tag: {
1615            let left = |o: usize, n: usize| h.framesize >= o + n;
1616            if flags & 1 != 0 {
1617                if !left(lo, 4) {
1618                    break 'tag;
1619                }
1620                let frames = rd(&mut lo) as i64;
1621                self.track_frames = if frames > (u32::MAX as i64) / 4 / 1152 {
1622                    0
1623                } else {
1624                    frames
1625                };
1626                self.gapless_init(self.track_frames, 0, 0);
1627            }
1628            if flags & 2 != 0 {
1629                if !left(lo, 4) {
1630                    break 'tag;
1631                }
1632                lo += 4;
1633            }
1634            if flags & 4 != 0 {
1635                if !left(lo, 100) {
1636                    break 'tag;
1637                }
1638                lo += 100;
1639            }
1640            if flags & 8 != 0 {
1641                if !left(lo, 4) {
1642                    break 'tag;
1643                }
1644                lo += 4;
1645            }
1646            if !left(lo, 24) {
1647                break 'tag;
1648            }
1649            if buf[lo] != 0 {
1650                let o = lo + 21;
1651                let pad_in = ((buf[o] as i64) << 4) | (buf[o + 1] as i64 >> 4);
1652                let pad_out = (((buf[o + 1] as i64) << 8) | buf[o + 2] as i64) & 0xfff;
1653                self.gapless_init(self.track_frames, pad_in, pad_out);
1654            }
1655        }
1656        self.bsbuf = (self.bsnum, 512);
1657        self.bsnum = (self.bsnum + 1) & 1;
1658        true
1659    }
1660
1661    // ---- frame.c gapless ------------------------------------------------------
1662
1663    fn gapless_init(&mut self, framecount: i64, bskip: i64, eskip: i64) {
1664        self.gapless_frames = framecount;
1665        if framecount > 0 && bskip >= 0 && eskip >= 0 {
1666            self.begin_s = bskip + GAPLESS_DELAY;
1667            self.end_s = framecount * self.h.spf as i64 - eskip + GAPLESS_DELAY;
1668        } else {
1669            self.begin_s = 0;
1670            self.end_s = 0;
1671        }
1672        self.begin_os = 0;
1673        self.end_os = 0;
1674        self.fullend_os = 0;
1675    }
1676
1677    fn gapless_realinit(&mut self) {
1678        self.begin_os = self.begin_s;
1679        self.end_os = self.end_s;
1680        self.fullend_os = if self.gapless_frames > 0 {
1681            self.gapless_frames * self.h.spf as i64
1682        } else {
1683            0
1684        };
1685    }
1686
1687    fn set_frameseek(&mut self, fe: i64) {
1688        let spf = self.h.spf as i64;
1689        self.firstframe = fe;
1690        if self.gapless_frames > 0 {
1691            let beg_f = self.begin_os / spf;
1692            if fe <= beg_f {
1693                self.firstframe = beg_f;
1694                self.firstoff = self.begin_os - beg_f * spf;
1695            } else {
1696                self.firstoff = 0;
1697            }
1698            if self.end_os > 0 {
1699                self.lastframe = self.end_os / spf;
1700                self.lastoff = self.end_os - self.lastframe * spf;
1701            } else {
1702                self.lastframe = -1;
1703                self.lastoff = 0;
1704            }
1705        } else {
1706            self.firstoff = 0;
1707            self.lastoff = 0;
1708            self.lastframe = -1;
1709        }
1710        self.ignoreframe = self.firstframe - PREFRAMES;
1711    }
1712
1713    /// Decode a frame and throw its output away (an ignored frame).
1714    fn decode_discard(&mut self) {
1715        let keep = std::mem::take(&mut self.out);
1716        self.do_layer3();
1717        self.out = keep;
1718    }
1719
1720    /// `get_next_frame`; false at the end.
1721    fn get_next_frame(&mut self) -> bool {
1722        let mut change = false;
1723        if self.header_change > 1 && self.num >= 0 {
1724            change = true;
1725            self.header_change = 0;
1726        }
1727        loop {
1728            if self.to_ignore && self.num < self.firstframe && self.num >= self.ignoreframe {
1729                self.decode_discard();
1730                self.to_ignore = false;
1731                self.to_decode = false;
1732            }
1733            self.to_decode = false;
1734            if !self.read_frame() {
1735                self.track_frames = self.num + 1;
1736                return false;
1737            }
1738            if self.header_change > 1 {
1739                change = true;
1740                self.header_change = 0;
1741            }
1742            if self.num < self.firstframe {
1743                if !(self.to_ignore && self.num < self.firstframe && self.num >= self.ignoreframe) {
1744                    // `INT123_frame_skip`
1745                    self.set_pointer(true, 512);
1746                }
1747            } else {
1748                break;
1749            }
1750        }
1751        if change && self.fresh {
1752            self.gapless_realinit();
1753            self.set_frameseek(self.num);
1754            self.fresh = false;
1755            if self.num < self.firstframe {
1756                return self.get_next_frame();
1757            }
1758        }
1759        true
1760    }
1761
1762    /// `mpg123_seek(0, SEEK_SET)`, which `soundfile.read` issues (via
1763    /// `sf_seek`) before reading: `INT123_frame_set_seek` + `do_the_seek`.
1764    fn seek_start(&mut self) {
1765        let spf = self.h.spf as i64;
1766        let mut sp = self.begin_os;
1767        if sp >= self.end_os {
1768            sp += self.fullend_os - self.end_os;
1769        }
1770        self.firstframe = sp / spf;
1771        self.ignoreframe = self.firstframe - PREFRAMES;
1772        self.firstoff = sp - self.firstframe * spf;
1773        let fnum = self.ignoreframe.max(0);
1774        if self.num < self.firstframe {
1775            self.to_decode = false;
1776            if self.num > fnum {
1777                return;
1778            }
1779        }
1780        if self.num == fnum && (self.to_decode || fnum < self.firstframe) {
1781            return;
1782        }
1783        if self.num == fnum - 1 {
1784            self.to_decode = false;
1785            return;
1786        }
1787        // `INT123_frame_buffers_reset` (`bo` is kept).
1788        self.bsnum = 0;
1789        self.bsbuf = (1, 0);
1790        self.bsbufold = (1, 0);
1791        self.bitreservoir = 0;
1792        self.cpu.put(REAL_BUFFS, &[0.0; 4 * 0x110]);
1793        for b in &mut self.bsspace {
1794            b[..MAXFRAMESIZE + 512].fill(0);
1795        }
1796        self.hybrid_blc = [0, 0];
1797        self.cpu.put(HYBRID_BLOCK, &[0.0; 4 * 576]);
1798        // `stream_seek_frame` from the frame index.
1799        let Some(&pos) = self.index.get(fnum as usize) else {
1800            return;
1801        };
1802        // (`num >= newframe || num < preframe` always holds with step 1.)
1803        self.filepos = pos;
1804        self.num = fnum - 1;
1805        while self.num < fnum {
1806            if !self.read_frame() {
1807                break;
1808            }
1809        }
1810        if self.num < self.firstframe {
1811            self.to_decode = false;
1812        }
1813    }
1814
1815    /// `decode_the_frame` + `frame_buffercheck`: the frame's kept samples.
1816    fn decode_the_frame(&mut self) -> Vec<f32> {
1817        let ch = self.h.stereo;
1818        let needed = self.h.spf * ch;
1819        self.out.clear();
1820        self.do_layer3();
1821        self.out.resize(needed, 0.0);
1822        let mut fill = needed;
1823        let mut start = 0;
1824        if !(self.gapless_frames > 0 && self.num >= self.gapless_frames) {
1825            if self.lastframe > -1 && self.num >= self.lastframe {
1826                let byteoff = if self.num == self.lastframe {
1827                    self.lastoff as usize * ch
1828                } else {
1829                    0
1830                };
1831                fill = fill.min(byteoff);
1832            }
1833            if self.firstoff != 0 && self.num == self.firstframe {
1834                let off = self.firstoff as usize * ch;
1835                if fill > off {
1836                    fill -= off;
1837                    start = off;
1838                } else {
1839                    fill = 0;
1840                }
1841                self.firstoff = 0;
1842            }
1843        }
1844        self.out[start..start + fill].to_vec()
1845    }
1846}
1847
1848/// An MP3 stream decoded as `soundfile` (libsndfile 1.2.2 + mpg123 1.32.3,
1849/// arm64) returns it.
1850pub struct Mp3 {
1851    /// Samples per second.
1852    pub sample_rate: u32,
1853    /// Channel count.
1854    pub channels: usize,
1855    /// Interleaved samples.
1856    pub samples: Vec<f32>,
1857}
1858
1859/// Whether `data` holds MPEG layer III frames: two consecutive compatible
1860/// headers within mpg123's 64 KiB junk window (after any ID3v2 tag).
1861pub fn probe(data: &[u8]) -> bool {
1862    let mut d = Dec::new(data);
1863    let Some((h0, h)) = d.sync_first() else {
1864        return false;
1865    };
1866    d.head_at(d.filepos + h.framesize)
1867        .is_some_and(|n| head_check(n) && head_compatible(h0, n))
1868}
1869
1870/// Decode a whole MP3 (layer III) file.
1871pub fn decode(data: &[u8]) -> Result<Mp3, String> {
1872    let mut d = Dec::new(data);
1873    // `init_track` via `mpg123_length`.
1874    if !d.get_next_frame() {
1875        return Err("no MPEG audio frame found".into());
1876    }
1877    let spf = d.h.spf as i64;
1878    let x = if d.track_frames > 0 {
1879        d.track_frames * spf
1880    } else if d.filelen > 0 {
1881        let bpf = if d.mean_framesize != 0.0 {
1882            d.mean_framesize
1883        } else {
1884            d.h.framesize as f64 + 4.0
1885        };
1886        (d.filelen as f64 / bpf * spf as f64) as i64
1887    } else {
1888        return Err("MP3 length unknown".into());
1889    };
1890    // `sample_adjust`
1891    let length = if x > d.end_os {
1892        if x < d.fullend_os {
1893            d.end_os - d.begin_os
1894        } else {
1895            x - (d.fullend_os - d.end_os + d.begin_os)
1896        }
1897    } else {
1898        x - d.begin_os
1899    };
1900    d.seek_start();
1901    let channels = d.h.stereo;
1902    let sample_rate = FREQS[d.h.sfreq];
1903    let want = length.max(0) as usize * channels;
1904    let mut samples = Vec::with_capacity(want);
1905    loop {
1906        if d.to_decode {
1907            let frame = d.decode_the_frame();
1908            d.to_decode = false;
1909            d.to_ignore = false;
1910            samples.extend_from_slice(&frame);
1911            if samples.len() >= want {
1912                break;
1913            }
1914        }
1915        if !d.get_next_frame() {
1916            break;
1917        }
1918    }
1919    samples.truncate(want);
1920    Ok(Mp3 {
1921        sample_rate,
1922        channels,
1923        samples,
1924    })
1925}