1 use nihav_core::codecs::*;
2 use nihav_core::io::bitreader::*;
3 use nihav_core::io::codebook::*;
8 const MP3_MAX_BANDS: usize = MP3_BANDS_SHORT * 3 + 4;
10 const MS_MODE: u8 = 2;
14 part2_3_length: usize,
17 scalefac_compress: usize,
21 table_select: [u8; 3],
22 subblock_gain: [u8; 3],
27 count1table_select: bool,
28 scalefac: [u8; MP3_MAX_BANDS],
29 istereo: [u8; MP3_MAX_BANDS],
35 impl Default for Granule {
36 fn default() -> Self { unsafe { std::mem::MaybeUninit::zeroed().assume_init() } }
40 fn get_mpeg2_params(&self, bits: &mut [u8; 4], independent: bool) -> usize {
42 match self.scalefac_compress {
44 bits[0] = MP3_SCF_BITS5[(self.scalefac_compress >> 4) * 2];
45 bits[1] = MP3_SCF_BITS5[(self.scalefac_compress >> 4) * 2 + 1];
46 bits[2] = ((self.scalefac_compress >> 2) & 3) as u8;
47 bits[3] = (self.scalefac_compress & 3) as u8;
51 let idx = self.scalefac_compress - 400;
52 bits[0] = MP3_SCF_BITS5[(idx >> 2) * 2];
53 bits[1] = MP3_SCF_BITS5[(idx >> 2) * 2 + 1];
54 bits[2] = (idx & 3) as u8;
59 let idx = self.scalefac_compress - 500;
60 bits[0] = MP3_SCF_BITS3[idx * 2];
61 bits[1] = MP3_SCF_BITS3[idx * 2 + 1];
69 let idx = self.scalefac_compress >> 1;
72 bits[0] = MP3_SCF_BITS6[idx * 3];
73 bits[1] = MP3_SCF_BITS6[idx * 3 + 1];
74 bits[2] = MP3_SCF_BITS6[idx * 3 + 2];
78 let val = (idx - 180) as u8;
80 bits[1] = (val >> 2) & 3;
86 bits[0] = MP3_SCF_BITS6[idx * 2];
87 bits[1] = MP3_SCF_BITS6[idx * 2 + 1];
106 let mut win36 = [0.0; 36];
107 let mut win36f = [0.0; 36];
108 let mut win12 = [0.0; 12];
109 let mut win12f = [0.0; 12];
112 win36 [i] = ((i as f32 + 0.5) * std::f32::consts::PI / 36.0).sin();
113 win36f[i] = if (i & 1) == 0 { win36[i] } else { -win36[i] };
116 win12 [i] = ((i as f32 + 0.5) * std::f32::consts::PI / 12.0).sin();
117 win12f[i] = if (i & 1) == 0 { win12[i] } else { -win12[i] };
122 win36, win36f, win12, win12f
125 fn mdct36(&mut self, src: &mut [f32], dst: &mut[f32], delay: &mut [f32], len: usize, block_type: u8) {
126 let mut flip = false;
127 for i in (0..len).step_by(18) {
128 let (win36, win12) = if flip { (&self.win36f, &self.win12f) } else { (&self.win36, &self.win12) };
129 dct36(&mut src[i..], &mut self.tmp);
133 dst[i + j] = delay[i + j] - self.tmp[8 - j] * win36[j];
134 delay[i + j] = self.tmp[j + 9] * win36[j + 18];
137 dst[i + j] = delay[i + j] + self.tmp[j - 9] * win36[j];
138 delay[i + j] = self.tmp[26 - j] * win36[j + 18];
143 dst[i + j] = delay[i + j] - self.tmp[8 - j] * win36[j];
146 dst[i + j] = delay[i + j] + self.tmp[j - 9] * win36[j];
148 delay[i..][..6].copy_from_slice(&self.tmp[9..][..6]);
150 for j in (1..6).step_by(2) {
151 delay[i + j] = -delay[i + j];
155 delay[i + j] = self.tmp[j + 9] * win12[j];
158 delay[i + j] = self.tmp[26 - j] * win12[j];
165 dst[i..][..6].copy_from_slice(&delay[i..][..6]);
167 dst[i + j] = delay[i + j] - self.tmp[8 - j] * win12[j - 6];
170 dst[i + j] = delay[i + j] + self.tmp[j - 9] * win12[j - 6];
174 dst[i + j] = delay[i + j] + self.tmp[j - 9];
178 dst[i + j] = delay[i + j] + if (j & 1) == 0 { self.tmp[j - 9] } else { -self.tmp[j - 9] };
182 delay[i + j] = self.tmp[j + 9] * win36[j + 18];
185 delay[i + j] = self.tmp[26 - j] * win36[j + 18];
193 fn mdct12(&mut self, src: &[f32], dst: &mut[f32], delay: &mut [f32], len: usize) {
194 let mut flip = false;
195 for i in (0..len).step_by(18) {
196 let window = if flip { &self.win12f } else { &self.win12 };
198 let tmp = &mut self.tmp[j * 12..];
199 dct12(&src[i + j * 6..], tmp);
200 for (el, &w) in tmp.iter_mut().zip(window.iter()) {
206 dst[i + j] = delay[i + j];
207 delay[i + j] = self.tmp[j + 18] + self.tmp[j + 18 + 6];
210 dst[i + j] = delay[i + j] + self.tmp[j - 6];
211 delay[i + j] = self.tmp[j + 18 + 6];
214 dst[i + j] = delay[i + j] + self.tmp[j - 6] + self.tmp[j];
226 granule: [[Granule; 2]; 2],
227 scfsi: [[bool; 4]; 2],
228 pub main_data_end: usize,
229 is_mode: [i8; SAMPLES],
233 delay: [[f32; SAMPLES / 2]; 2],
234 tmp: [f32; SAMPLES / 2],
238 pub fn new() -> Self {
240 cb: MP3Codebooks::new(),
241 mdct: MDCTContext::new(),
242 granule: [[Granule::default(); 2]; 2],
243 scfsi: [[false; 4]; 2],
245 is_mode: [0; SAMPLES],
249 delay: [[0.0; SAMPLES / 2]; 2],
250 tmp: [0.0; SAMPLES / 2],
253 pub fn reset(&mut self) {
254 for dly in self.delay.iter_mut() {
255 for el in dly.iter_mut() {
260 fn calc_scale(gr: &Granule, sb: usize, ssb: usize, sblk_gain: u8) -> i8 {
261 (i32::from(gr.global_gain) - 64 - 146
262 - 8 * i32::from(sblk_gain)
263 - if gr.scalefac_scale { 4 } else { 2 } * (i32::from(gr.scalefac[ssb])
264 + if gr.preflag { i32::from(MP3_PREEMP_SCALES[sb]) } else { 0 })
265 ).min(127).max(-124) as i8
267 fn read_mp3_coeffs(&mut self, br: &mut BitReader, end: usize, gr_no: usize, ch: usize, coeffs: &mut [f32]) -> DecoderResult<()> {
268 let mut scales = [0; SAMPLES / 2];
269 let gr = &mut self.granule[gr_no][ch];
271 // calculate scales first
272 if gr.block_type != 2 {
275 while off < SAMPLES / 2 {
276 let end = MP3_SFB_LONG_OFFS[self.sf_idx][sb + 1];
277 let scale = Self::calc_scale(gr, sb, sb, 0);
278 for el in scales[off..end].iter_mut() {
283 let scf = gr.scalefac[sb.min(MP3_BANDS - 1)];
284 if scf != gr.istereo[sb] {
285 for el in self.is_mode[gr_no * SAMPLES/2..][off..end].iter_mut() {
295 let end_band = if self.mpeg1 { 8 } else { 6 };
300 while sb < end_band {
301 let end = MP3_SFB_LONG_OFFS[self.sf_idx][sb + 1];
302 let scale = Self::calc_scale(gr, sb, sb, 0);
303 for el in scales[off..end].iter_mut() {
308 let scf = gr.scalefac[sb.min(MP3_BANDS - 1)];
309 if scf != gr.istereo[sb] {
310 for el in self.is_mode[gr_no * SAMPLES/2..][off..end].iter_mut() {
319 let mut ssb = if gr.switch_point { 8 } else { 0 };
320 let mut sb = if gr.switch_point { 3 } else { 0 };
321 while sb <= MP3_BANDS_SHORT {
322 let band_size = MP3_SFB_SHORT_SIZE[self.sf_idx][sb];
324 let scale = Self::calc_scale(gr, sb, ssb, gr.subblock_gain[win]);
325 for el in scales[off..][..band_size].iter_mut() {
330 if sb == MP3_BANDS_SHORT {
331 gr.scalefac[ssb] = gr.scalefac[ssb - 3];
332 gr.istereo[ssb] = gr.istereo[ssb - 3];
334 let scf = gr.scalefac[ssb];
335 if scf != gr.istereo[ssb] {
336 for el in self.is_mode[gr_no * SAMPLES/2 + off..][..band_size].iter_mut() {
348 // prepare for coefficients decoding
349 let region1_start = if gr.block_type != 2 {
350 MP3_SFB_LONG_OFFS[self.sf_idx][gr.region_address1 as usize + 1]
351 } else if gr.switch_point {
354 MP3_SFB_SHORT_OFFS[self.sf_idx][3] * 3
355 }.min(gr.big_values);
356 let region2_start = MP3_SFB_LONG_OFFS[self.sf_idx][((gr.region_address1 + gr.region_address2 + 2) as usize).min(MP3_BANDS + 1)].min(gr.big_values);
358 for el in coeffs[..SAMPLES/2].iter_mut() {
364 if let Some((cb, esc_bits)) = self.cb.get_cb(gr.table_select[0]) {
365 let lc = read_region(br, end, coeffs, &scales, 0, region1_start, cb, esc_bits)?;
366 gr.lastcoded = gr.lastcoded.max(lc);
368 if let Some((cb, esc_bits)) = self.cb.get_cb(gr.table_select[1]) {
369 let lc = read_region(br, end, coeffs, &scales, region1_start, region2_start, cb, esc_bits)?;
370 gr.lastcoded = gr.lastcoded.max(lc);
372 if let Some((cb, esc_bits)) = self.cb.get_cb(gr.table_select[2]) {
373 let lc = read_region(br, end, coeffs, &scales, region2_start, gr.big_values, cb, esc_bits)?;
374 gr.lastcoded = gr.lastcoded.max(lc);
376 let (lc, zp) = read_region_quad(br, end, coeffs, &scales, gr.big_values, if !gr.count1table_select { Some(&self.cb.quad_cb) } else { None })?;
377 gr.lastcoded = gr.lastcoded.max(lc);
378 gr.zero_part = if zp > 0 { zp } else { gr.lastcoded };
382 pub fn read_mp3_side_data(&mut self, br: &mut BitReader, channels: usize) -> DecoderResult<()> {
384 self.main_data_end = br.read(9)? as usize;
385 let _private_bits = br.read(if channels == 1 { 5 } else { 3 })?;
386 for scfsis in self.scfsi[..channels].iter_mut() {
387 for scfsi in scfsis.iter_mut() {
388 *scfsi = br.read_bool()?;
392 self.main_data_end = br.read(8)? as usize;
393 let _private_bits = br.read(channels as u8)?;
395 let granules = if self.mpeg1 { 2 } else { 1 };
396 for grans in self.granule[..granules].iter_mut() {
397 for gr in grans[..channels].iter_mut() {
398 gr.part2_3_length = br.read(12)? as usize;
399 gr.big_values = (br.read(9)? as usize) * 2;
400 gr.global_gain = br.read(8)? as u8;
401 gr.scalefac_compress = br.read(if self.mpeg1 { 4 } else { 9 })? as usize;
402 gr.blocksplit = br.read_bool()?;
404 gr.block_type = br.read(2)? as u8;
405 gr.switch_point = br.read_bool()?;
406 for tsel in gr.table_select[..2].iter_mut() {
407 *tsel = br.read(5)? as u8;
409 4 | 14 => return Err(DecoderError::InvalidData),
413 for gain in gr.subblock_gain.iter_mut() {
414 *gain = br.read(3)? as u8;
416 gr.region_address1 = 7;
417 gr.region_address2 = 13;
420 gr.switch_point = false;
421 for tsel in gr.table_select.iter_mut() {
422 *tsel = br.read(5)? as u8;
424 4 | 14 => return Err(DecoderError::InvalidData),
428 gr.region_address1 = br.read(4)? as u8;
429 gr.region_address2 = br.read(3)? as u8;
432 gr.preflag = br.read_bool()?;
436 gr.scalefac_scale = br.read_bool()?;
437 gr.count1table_select = br.read_bool()?
442 pub fn decode_mpeg1_layer3(&mut self, br: &mut BitReader, coeffs: &mut [[f32; SAMPLES]; 2], channels: usize) -> DecoderResult<()> {
443 let mut data_end = 0;
445 for ch in 0..channels {
446 data_end += self.granule[gr_no][ch].part2_3_length;
448 if self.granule[gr_no][ch].block_type != 2 {
450 self.granule[1][ch].scalefac = self.granule[0][ch].scalefac;
452 for scf in self.granule[gr_no][ch].scalefac.iter_mut() {
457 let gr = &mut self.granule[gr_no][ch];
458 let bits1 = MP3_SCALEFAC_BITS1[gr.scalefac_compress];
459 let bits2 = MP3_SCALEFAC_BITS2[gr.scalefac_compress];
461 if !self.scfsi[ch][SCFSI_FROM_BAND[cb]] || (gr_no == 0) {
462 gr.scalefac[cb] = br.read(bits1)? as u8;
465 for cb in 11..MP3_BANDS {
466 if !self.scfsi[ch][SCFSI_FROM_BAND[cb]] || (gr_no == 0) {
467 gr.scalefac[cb] = br.read(bits2)? as u8;
470 for is in gr.istereo.iter_mut() {
474 let gr = &mut self.granule[gr_no][ch];
475 let bits1 = MP3_SCALEFAC_BITS1[gr.scalefac_compress];
476 let bits2 = MP3_SCALEFAC_BITS2[gr.scalefac_compress];
477 let pivot = if gr.blocksplit && gr.switch_point { 17 } else { 18 };
479 for scf in gr.scalefac[..pivot].iter_mut() {
480 *scf = br.read(bits1)? as u8;
482 for scf in gr.scalefac[pivot..][..18].iter_mut() {
483 *scf = br.read(bits2)? as u8;
485 for is in gr.istereo.iter_mut() {
489 self.read_mp3_coeffs(br, data_end, gr_no, ch, &mut coeffs[ch][gr_no * SAMPLES/2..])?;
490 validate!(br.tell() <= data_end);
491 br.seek(data_end as u32)?;
496 pub fn decode_mpeg2_layer3(&mut self, br: &mut BitReader, coeffs: &mut [[f32; SAMPLES]; 2], channels: usize, mode_ext: u8) -> DecoderResult<()> {
497 let mut data_end = 0;
498 for ch in 0..channels {
499 let gr = &mut self.granule[0][ch];
500 data_end += gr.part2_3_length;
502 let mut bits = [0; 4];
503 let idx = gr.get_mpeg2_params(&mut bits, (ch == 0) || ((mode_ext & IS_MODE) == 0));
504 let idx2 = if gr.block_type != 2 { 0 } else if !gr.switch_point { 1 } else { 2 };
506 gr.preflag = idx == 2;
507 let ends = &MP3_SCF_ENDS[idx][idx2];
509 for (scf, is) in gr.scalefac[0..ends[0]].iter_mut().zip(gr.istereo[0..ends[0]].iter_mut()) {
510 *scf = br.read(bits[0])? as u8;
511 *is = (1 << bits[0]) - 1;
513 for (scf, is) in gr.scalefac[ends[0]..ends[1]].iter_mut().zip(gr.istereo[ends[0]..ends[1]].iter_mut()) {
514 *scf = br.read(bits[1])? as u8;
515 *is = (1 << bits[1]) - 1;
517 for (scf, is) in gr.scalefac[ends[1]..ends[2]].iter_mut().zip(gr.istereo[ends[1]..ends[2]].iter_mut()) {
518 *scf = br.read(bits[2])? as u8;
519 *is = (1 << bits[2]) - 1;
521 for (scf, is) in gr.scalefac[ends[2]..ends[3]].iter_mut().zip(gr.istereo[ends[2]..ends[3]].iter_mut()) {
522 *scf = br.read(bits[3])? as u8;
523 *is = (1 << bits[3]) - 1;
525 self.read_mp3_coeffs(br, data_end, 0, ch, &mut coeffs[ch])?;
526 validate!(br.tell() <= data_end);
527 br.seek(data_end as u32)?;
531 pub fn synth(&mut self, coeffs: &mut [[f32; SAMPLES]; 2], output: &mut [[[f32; 32]; 36]; 2], mode: u8, mode_ext: u8) {
532 let channels = if mode == 3 { 1 } else { 2 };
533 let granules = if self.mpeg1 { 2 } else { 1 };
535 let mut end_freq = [[0; 2]; 2];
536 for gr_no in 0..granules {
537 for ch in 0..channels {
538 end_freq[gr_no][ch] = self.granule[gr_no][ch].lastcoded;
542 let mut band_flags = [[0; MP3_MAX_BANDS + 3]; 2];
543 let mut band_start = [[0; MP3_MAX_BANDS + 3]; 2];
544 let mut band_end = [[0; MP3_MAX_BANDS + 3]; 2];
546 if mode == 1 { // joint stereo
547 let mut bound_band = [0; 2];
548 let mut num_bands = [MP3_BANDS + 1; 2];
550 for (gr_no, grans) in self.granule[..granules].iter_mut().enumerate() {
551 if grans[1].block_type != 2 {
552 for band in 0..=MP3_BANDS {
553 band_flags[gr_no][band] = mode_ext;
554 band_start[gr_no][band] = MP3_SFB_LONG_OFFS[self.sf_idx][band];
555 band_end [gr_no][band] = MP3_SFB_LONG_OFFS[self.sf_idx][band + 1];
556 if (end_freq[gr_no][1] >= band_end[gr_no][band]) || (grans[1].scalefac[band.min(MP3_BANDS - 1)] == grans[1].istereo[band.min(MP3_BANDS - 1)]) {
557 band_flags[gr_no][band] &= !IS_MODE;
559 if band_start[gr_no][band] < end_freq[gr_no][1] {
560 bound_band[gr_no] = band;
562 if (band_flags[gr_no][band] & IS_MODE) == 0 {
563 for el in self.is_mode[gr_no * SAMPLES/2..][band_start[gr_no][band]..band_end[gr_no][band]].iter_mut() {
569 let switch_off = if grans[1].switch_point { 3 } else { 0 };
572 if grans[1].switch_point {
573 let long_bands = if self.mpeg1 { 8 } else { 6 };
574 for _ in 0..long_bands {
575 band_flags[gr_no][band] = mode_ext;
576 band_start[gr_no][band] = MP3_SFB_LONG_OFFS[self.sf_idx][band];
577 band_end [gr_no][band] = MP3_SFB_LONG_OFFS[self.sf_idx][band + 1];
578 if end_freq[gr_no][1] >= band_end[gr_no][band] {
579 band_flags[gr_no][band] &= !IS_MODE;
581 start = band_end[gr_no][band];
585 for sb in switch_off..=MP3_BANDS_SHORT {
586 let band_size = MP3_SFB_SHORT_SIZE[self.sf_idx][sb];
588 band_flags[gr_no][band] = mode_ext;
589 band_start[gr_no][band] = start;
590 band_end [gr_no][band] = start + band_size;
591 if end_freq[gr_no][1] >= band_end[gr_no][band] {
592 band_flags[gr_no][band] &= !IS_MODE;
598 num_bands[gr_no] = band;
601 if (mode_ext & IS_MODE) != 0 {
602 for (gr_no, grans) in self.granule[..granules].iter_mut().enumerate() {
603 let (coef0, coef1) = coeffs.split_at_mut(1);
604 let coef0 = &mut coef0[0][gr_no * SAMPLES/2..];
605 let coef1 = &mut coef1[0][gr_no * SAMPLES/2..];
606 let is_mode = &self.is_mode[gr_no * SAMPLES/2..];
607 let start = band_end[gr_no][bound_band[gr_no]];
608 let end = grans[0].zero_part;
611 let coef0 = &mut coef0[start..end];
612 let coef1 = &mut coef1[start..end];
613 let is_mode = &self.is_mode[gr_no * SAMPLES/2..][start..end];
614 for ((l, r), &is) in coef0.iter_mut().zip(coef1.iter_mut()).zip(is_mode.iter()) {
615 if is >= 0 && is < 7 {
616 let t = *l * MP3_ISTEREO_COEFFS[is as usize];
622 let iscale = (grans[1].scalefac_compress & 1) as u8;
623 for band in 0..num_bands[gr_no] {
624 if (band_flags[gr_no][band] & IS_MODE) != 0 {
625 apply_istereo(&mut coef0[start..end], &mut coef1[start..end], is_mode[start], iscale, (band_flags[gr_no][band] & MS_MODE) != 0);
629 end_freq[gr_no][1] = end_freq[gr_no][1].min(end);
632 if (mode_ext & MS_MODE) != 0 {
633 for (gr_no, grans) in self.granule[..granules].iter_mut().enumerate() {
634 let end = grans[0].zero_part.max(grans[1].zero_part);
635 let (coef0, coef1) = coeffs.split_at_mut(1);
636 let coef0 = &mut coef0[0][gr_no * SAMPLES/2..];
637 let coef1 = &mut coef1[0][gr_no * SAMPLES/2..];
638 for band in 0..num_bands[gr_no] {
639 if band_start[gr_no][band] >= end {
642 if (band_flags[gr_no][band] & MS_MODE) != 0 {
643 let start = band_start[gr_no][band];
644 let end = band_end[gr_no][band];
645 super::apply_ms(&mut coef0[start..end], &mut coef1[start..end]);
648 end_freq[gr_no][0] = end;
649 end_freq[gr_no][1] = end;
653 for (gr_no, grans) in self.granule[..granules].iter_mut().enumerate() {
654 for (ch, gr) in grans[..channels].iter_mut().enumerate() {
655 let src = &mut coeffs[ch][gr_no * SAMPLES/2..][..SAMPLES/2];
656 if gr.block_type != 2 {
657 dealias(src, SAMPLES/2);
658 self.mdct.mdct36(src, &mut self.tmp, &mut self.delay[ch], end_freq[gr_no][ch], gr.block_type);
660 let switch_off = if gr.switch_point { MP3_SFB_LONG_OFFS[self.sf_idx][if self.mpeg1 { 8 } else { 6 }] } else { 0 };
661 let mut band_buf = [0.0; 66 * 3];
662 let mut sb = if gr.switch_point { 3 } else { 0 };
663 let mut off = switch_off;
665 while sb < MP3_BANDS_SHORT {
666 let band_size = MP3_SFB_SHORT_SIZE[self.sf_idx][sb];
668 for i in 0..band_size {
669 band_buf[win + i * 3] = src[off + win * band_size + i];
672 src[off..][..band_size * 3].copy_from_slice(&band_buf[..band_size * 3]);
673 off += band_size * 3;
677 dealias(src, switch_off);
678 self.mdct.mdct36(src, &mut self.tmp, &mut self.delay[ch], switch_off, gr.block_type);
680 self.mdct.mdct12(&src[switch_off..], &mut self.tmp[switch_off..], &mut self.delay[ch][switch_off..], end_freq[gr_no][ch] - switch_off);
683 let dst = &mut output[ch][gr_no * 18..];
684 let end = (end_freq[gr_no][ch] + 17) / 18;
687 dst[j][i] = self.tmp[i * 18 + j];
692 dst[j][i] = self.delay[ch][i * 18 + j];
694 for el in self.delay[ch][i * 18..][..18].iter_mut() {
703 fn mp3_unquant(val: u32, scale: i8) -> f32 {
704 (val as f32) * (val as f32).cbrt() * 2.0f32.powf((scale as f32) * 0.25)
707 #[allow(clippy::too_many_arguments)]
708 fn read_region(br: &mut BitReader, br_end: usize, coeffs: &mut [f32], scales: &[i8; SAMPLES/2], start: usize, end: usize, cb: &Codebook<u8>, esc_bits: u8) -> DecoderResult<usize> {
709 let mut lastcoded = 0;
710 for (i, (cpair, scpair)) in coeffs[start..end].chunks_exact_mut(2).zip(scales[start..end].chunks_exact(2)).enumerate() {
711 if br.tell() >= br_end { break; }
712 let val = br.read_cb(cb)?;
716 let a = if (val >> 4) != 0xF || esc_bits == 0 {
719 br.read(esc_bits)? + 15
722 let a = mp3_unquant(a, scpair[0]);
723 cpair[0] = if br.read_bool()? { -a } else { a };
725 let b = if (val & 0xF) != 0xF || esc_bits == 0 {
728 br.read(esc_bits)? + 15
731 let b = mp3_unquant(b, scpair[1]);
732 cpair[1] = if br.read_bool()? { -b } else { b };
734 lastcoded = start + (i + 1) * 2;
739 fn read_region_quad(br: &mut BitReader, br_end: usize, coeffs: &mut [f32], scales: &[i8; SAMPLES/2], start: usize, cb: Option<&Codebook<u8>>) -> DecoderResult<(usize, usize)> {
740 let mut lastcoded = 0;
741 let mut zero_part = 0;
742 if br.tell() >= br_end {
745 for (i, (cquad, scquad)) in coeffs[start..SAMPLES/2].chunks_exact_mut(4).zip(scales[start..].chunks_exact(4)).enumerate() {
746 zero_part = start + i * 4 + 4;
747 if br.tell() >= br_end {
750 let val = if let Some(cbook) = cb { br.read_cb(cbook)? } else { (br.read(4)? as u8) ^ 0xF };
755 if ((val >> (3 - j)) & 1) != 0 {
756 cquad[j] = mp3_unquant(1, scquad[j]);
758 cquad[j] = -cquad[j];
760 lastcoded = start + i * 4 + j + 1;
764 Ok((lastcoded, zero_part))
767 const DCT12_0: f32 = -0.92387953251128675613;
768 const DCT12_1: f32 = -0.38268343236508977174;
770 const DCT12_2: f32 = -0.1305261922200516;
771 const DCT12_3: f32 = -0.6087614290087205;
772 const DCT12_4: f32 = 0.7933533402912348;
773 const DCT12_5: f32 = 0.9914448613738103;
775 fn dct12(src: &[f32], dst: &mut [f32]) {
776 let t0 = src[0] - src[3] - src[4];
777 let t1 = src[1] - src[2] - src[5];
779 dst[ 4] = t0 * DCT12_1 - t1 * DCT12_0;
780 dst[ 7] = t0 * DCT12_0 + t1 * DCT12_1;
784 let t0 = src[1] * DCT12_1 - src[4] * DCT12_0;
785 let t1 = src[1] * DCT12_0 + src[4] * DCT12_1;
787 dst[ 3] = src[0] * DCT12_2 + src[2] * DCT12_3 + src[3] * DCT12_4 + src[5] * DCT12_5 - t0;
788 dst[ 5] = src[0] * DCT12_3 - src[2] * DCT12_2 - src[3] * DCT12_5 + src[5] * DCT12_4 - t1;
789 dst[ 6] = -src[0] * DCT12_4 + src[2] * DCT12_5 - src[3] * DCT12_2 + src[5] * DCT12_3 - t0;
790 dst[ 8] = -src[0] * DCT12_5 - src[2] * DCT12_4 + src[3] * DCT12_3 + src[5] * DCT12_2 + t1;
797 const DCT36_PRESCALE: [f32; 18] = [
798 0.99904822158185776240, 0.99144486137381041114, 0.97629600711993336597,
799 0.95371695074822692114, 0.92387953251128675613, 0.88701083317822170105,
800 0.84339144581288570127, 0.79335334029123516458, 0.73727733681012404139,
801 0.67559020761566024435, 0.60876142900872063942, 0.53729960834682383185,
802 0.46174861323503393057, 0.38268343236508977174, 0.30070579950427312163,
803 0.21643961393810287977, 0.13052619222005159156, 0.04361938736533599979
805 const DCT36_TWIDDLE: [f32; 9] = [
806 0.99619469809174553229, 0.96592582628906828675, 0.90630778703664996324,
807 0.81915204428899178969, 0.70710678118654752440, 0.57357643635104609611,
808 0.42261826174069943619, 0.25881904510252076236, 0.08715574274765817357
810 const SDCT2_TWIDDLE: [f32; 7] = [
811 -2.0 * 0.98480775301220805936, -2.0 * 0.86602540378443864676,
812 -2.0 * 0.76604444311897803520, -2.0 * 0.64278760968653932633,
813 -2.0 * 0.34202014332566873305, -2.0 * 0.17364817766693034887,
814 2.0 * 0.93969262078590838404
817 fn sdct_ii(buf: &mut [f32]) {
818 let t0 = buf[ 6] + buf[10];
819 let t1 = buf[ 6] - buf[10];
820 let t2 = buf[12] + buf[ 4];
821 let t3 = buf[12] - buf[ 4];
822 let t4 = buf[16] + buf[ 0];
823 let t5 = buf[16] - buf[ 0];
826 let t7 = (t0 - t2) * SDCT2_TWIDDLE[2];
827 let t8 = (t1 + t3) * SDCT2_TWIDDLE[3];
829 let t0 = (t0 - t4) * SDCT2_TWIDDLE[5];
830 let t1 = (t1 - t5) * SDCT2_TWIDDLE[0];
831 let t2 = (t2 - t4) * SDCT2_TWIDDLE[6];
832 let t3 = (t3 + t5) * SDCT2_TWIDDLE[4];
835 let tb = (t9 + t5) * SDCT2_TWIDDLE[1];
837 let tc = buf[2] + buf[14];
838 let td = (buf[2] - buf[14]) * SDCT2_TWIDDLE[1];
840 let t6 = buf[8] + tc;
841 let t9 = buf[8] * 2.0 - tc;
847 buf[ 2] = t8 - td - t1;
851 buf[10] = td - t3 - t1;
852 buf[12] = ta - t6 * 2.0;
853 buf[14] = t8 + t3 + td;
857 fn dct36(src: &mut [f32], dst: &mut [f32]) {
858 for (el, &w) in src.iter_mut().zip(DCT36_PRESCALE.iter()) {
862 let mut tmp = [0.0; 18];
864 tmp[i * 2] = src[i] + src[17 - i];
865 tmp[i * 2 + 1] = (src[i] - src[17 - i]) * DCT36_TWIDDLE[i] * 2.0;
868 sdct_ii(&mut tmp[1..]);
870 for i in (3..18).step_by(2) {
871 tmp[i] -= tmp[i - 2];
875 tmp[i] = tmp[i] * 0.5 - tmp[i - 1];
878 dst[i] = -tmp[17 - i] * 2.0;
882 const ALIAS_COEFFS_S: [f32; 8] = [
883 0.85749292571254418689, 0.88174199731770518178,
884 0.94962864910273289205, 0.98331459249179014599,
885 0.99551781606758576429, 0.99916055817814750453,
886 0.99989919524444704627, 0.99999315507028023572
888 const ALIAS_COEFFS_A: [f32; 8] = [
889 -0.51449575542752651213, -0.47173196856497227225,
890 -0.31337745420390185437, -0.18191319961098117700,
891 -0.09457419252642064760, -0.04096558288530404768,
892 -0.01419856857247114805, -0.00369997467376003687
894 fn dealias(buf: &mut [f32], len: usize) {
895 for i in (18..len).step_by(18) {
896 for (j, (&cs, &ca)) in ALIAS_COEFFS_S.iter().zip(ALIAS_COEFFS_A.iter()).enumerate() {
897 let a = buf[i - j - 1];
899 let c0 = a * cs - b * ca;
900 let c1 = a * ca + b * cs;
907 fn apply_istereo(ch0: &mut [f32], ch1: &mut [f32], is_mode: i8, iscale: u8, ms_mode: bool) {
908 match (is_mode, ms_mode) {
910 for (c0, c1) in ch0.iter_mut().zip(ch1.iter_mut()) {
911 let a = (*c0 + *c1) * std::f32::consts::FRAC_1_SQRT_2;
912 let b = (*c0 - *c1) * std::f32::consts::FRAC_1_SQRT_2;
919 ch1.copy_from_slice(ch0);
922 let scale = mp3_unquant(1, -((is_mode + 1) >> 1) << iscale);
923 if (is_mode & 1) == 0 {
924 for (&c0, c1) in ch0.iter().zip(ch1.iter_mut()) {
928 for (c0, c1) in ch0.iter_mut().zip(ch1.iter_mut()) {