1#![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
21const REAL_BUFFS: u64 = 0x1000; const DECWIN: u64 = 0x3000; const SAMPLES: u64 = 0x5000; const MONO_TMP: u64 = 0x7800; const HYBRID_IN: u64 = 0x8000; const HYBRID_OUT: u64 = 0xA000; const HYBRID_BLOCK: u64 = 0xC000; const WIN: u64 = 0xF000; const WIN1: u64 = 0xF400; const 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
58fn 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
83fn 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
146fn 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
157struct 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 h: Header,
168 freeformat_framesize: Option<usize>,
170 firsthead: u32,
171 oldhead: u32,
172 fsizeold: usize,
173 bsspace: [Vec<u8>; 2],
174 bsnum: usize,
175 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 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 out: Vec<f32>,
206 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 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 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; 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 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 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 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 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; 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 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 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
720struct 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 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; 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; 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 #[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 #[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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 let Some(&pos) = self.index.get(fnum as usize) else {
1800 return;
1801 };
1802 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 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
1848pub struct Mp3 {
1851 pub sample_rate: u32,
1853 pub channels: usize,
1855 pub samples: Vec<f32>,
1857}
1858
1859pub 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
1870pub fn decode(data: &[u8]) -> Result<Mp3, String> {
1872 let mut d = Dec::new(data);
1873 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 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}