nihav-mpeg/src/codecs/mpegaudio/mp3code.rs

   1 use nihav_core::codecs::*;
   2 use nihav_core::io::bitreader::*;
   3 use nihav_core::io::codebook::*;
   4
   5 use super::SAMPLES;
   6 use super::mp3data::*;
   7
   8 const MP3_MAX_BANDS: usize = MP3_BANDS_SHORT * 3 + 4;
   9 const IS_MODE: u8 = 1;
  10 const MS_MODE: u8 = 2;
  11
  12 #[derive(Clone,Copy)]
  13 struct Granule {
  14     part2_3_length:     usize,
  15     big_values:         usize,
  16     global_gain:        u8,
  17     scalefac_compress:  usize,
  18     blocksplit:         bool,
  19     block_type:         u8,
  20     switch_point:       bool,
  21     table_select:       [u8; 3],
  22     subblock_gain:      [u8; 3],
  23     region_address1:    u8,
  24     region_address2:    u8,
  25     preflag:            bool,
  26     scalefac_scale:     bool,
  27     count1table_select: bool,
  28     scalefac:           [u8; MP3_MAX_BANDS],
  29     istereo:            [u8; MP3_MAX_BANDS],
  30
  31     lastcoded:          usize,
  32     zero_part:          usize,
  33 }
  34
  35 impl Default for Granule {
  36     fn default() -> Self { unsafe { std::mem::MaybeUninit::zeroed().assume_init() } }
  37 }
  38
  39 impl Granule {
  40     fn get_mpeg2_params(&self, bits: &mut [u8; 4], independent: bool) -> usize {
  41         if independent {
  42             match self.scalefac_compress {
  43                 0..=399 => {
  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;
  48                     0
  49                 },
  50                 400..=499 => {
  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;
  55                     bits[3] = 0;
  56                     1
  57                 },
  58                 _ => {
  59                     let idx = self.scalefac_compress - 500;
  60                     bits[0] = MP3_SCF_BITS3[idx * 2];
  61                     bits[1] = MP3_SCF_BITS3[idx * 2 + 1];
  62                     bits[2] = 0;
  63                     bits[3] = 0;
  64                     2
  65                 },
  66             }
  67         } else {
  68             bits[3] = 0;
  69             let idx = self.scalefac_compress >> 1;
  70             match idx {
  71                 0..=179 => {
  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];
  75                     3
  76                 },
  77                 180..=243 => {
  78                     let val = (idx - 180) as u8;
  79                     bits[0] =  val >> 4;
  80                     bits[1] = (val >> 2) & 3;
  81                     bits[2] =  val       & 3;
  82                     4
  83                 },
  84                 _ => {
  85                     let idx = idx - 244;
  86                     bits[0] = MP3_SCF_BITS6[idx * 2];
  87                     bits[1] = MP3_SCF_BITS6[idx * 2 + 1];
  88                     bits[2] = 0;
  89                     5
  90                 },
  91             }
  92         }
  93     }
  94 }
  95
  96 struct MDCTContext {
  97     win36:      [f32; 36],
  98     win36f:     [f32; 36],
  99     win12:      [f32; 12],
 100     win12f:     [f32; 12],
 101     tmp:        [f32; 36],
 102 }
 103
 104 impl MDCTContext {
 105     fn new() -> Self {
 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];
 110
 111         for i in 0..36 {
 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] };
 114         }
 115         for i in 0..12 {
 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] };
 118         }
 119
 120         Self {
 121             tmp: [0.0; 36],
 122             win36, win36f, win12, win12f
 123         }
 124     }
 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);
 130             match block_type {
 131                 0 | 2 => {
 132                     for j in 0..9 {
 133                         dst[i + j] = delay[i + j] - self.tmp[8 - j] * win36[j];
 134                         delay[i + j] = self.tmp[j + 9] * win36[j + 18];
 135                     }
 136                     for j in 9..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];
 139                     }
 140                 },
 141                 1 => {
 142                     for j in 0..9 {
 143                         dst[i + j] = delay[i + j] - self.tmp[8 - j] * win36[j];
 144                     }
 145                     for j in 9..18 {
 146                         dst[i + j] = delay[i + j] + self.tmp[j - 9] * win36[j];
 147                     }
 148                     delay[i..][..6].copy_from_slice(&self.tmp[9..][..6]);
 149                     if flip {
 150                         for j in (1..6).step_by(2) {
 151                             delay[i + j] = -delay[i + j];
 152                         }
 153                     }
 154                     for j in 6..9 {
 155                         delay[i + j] = self.tmp[j + 9] * win12[j];
 156                     }
 157                     for j in 9..12 {
 158                         delay[i + j] = self.tmp[26 - j] * win12[j];
 159                     }
 160                     for j in 12..18 {
 161                         delay[i + j] = 0.0;
 162                     }
 163                 },
 164                 _ => {
 165                     dst[i..][..6].copy_from_slice(&delay[i..][..6]);
 166                     for j in 6..9 {
 167                         dst[i + j] = delay[i + j] - self.tmp[8 - j] * win12[j - 6];
 168                     }
 169                     for j in 9..12 {
 170                         dst[i + j] = delay[i + j] + self.tmp[j - 9] * win12[j - 6];
 171                     }
 172                     if !flip {
 173                         for j in 12..18 {
 174                             dst[i + j] = delay[i + j] + self.tmp[j - 9];
 175                         }
 176                     } else {
 177                         for j in 12..18 {
 178                             dst[i + j] = delay[i + j] + if (j & 1) == 0 { self.tmp[j - 9] } else { -self.tmp[j - 9] };
 179                         }
 180                     }
 181                     for j in 0..9 {
 182                         delay[i + j] = self.tmp[j + 9] * win36[j + 18];
 183                     }
 184                     for j in 9..18 {
 185                         delay[i + j] = self.tmp[26 - j] * win36[j + 18];
 186                     }
 187                 },
 188             };
 189
 190             flip = !flip;
 191         }
 192     }
 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 };
 197             for j in 0..3 {
 198                 let tmp = &mut self.tmp[j * 12..];
 199                 dct12(&src[i + j..], tmp);
 200                 for (el, &w) in tmp.iter_mut().zip(window.iter()) {
 201                     *el *= w;
 202                 }
 203             }
 204
 205             for j in 0..6 {
 206                 dst[i + j] = delay[i + j];
 207                 delay[i + j] = self.tmp[j + 18] + self.tmp[j + 18 + 6];
 208             }
 209             for j in 6..12 {
 210                 dst[i + j] = delay[i + j] + self.tmp[j - 6];
 211                 delay[i + j] = self.tmp[j + 18 + 6];
 212             }
 213             for j in 12..18 {
 214                 dst[i + j] = delay[i + j] + self.tmp[j - 6] + self.tmp[j];
 215                 delay[i + j] = 0.0;
 216             }
 217
 218             flip = !flip;
 219         }
 220     }
 221 }
 222
 223 pub struct MP3Data {
 224         cb:             MP3Codebooks,
 225         mdct:           MDCTContext,
 226         granule:        [[Granule; 2]; 2],
 227         scfsi:          [[bool; 4]; 2],
 228     pub main_data_end:  usize,
 229         is_mode:        [i8; SAMPLES],
 230     pub mpeg1:          bool,
 231     pub sf_idx:         usize,
 232
 233         delay:          [[f32; SAMPLES / 2]; 2],
 234         tmp:            [f32; SAMPLES / 2],
 235 }
 236
 237 #[allow(clippy::needless_range_loop)]
 238 impl MP3Data {
 239     pub fn new() -> Self {
 240         Self {
 241             cb:             MP3Codebooks::new(),
 242             mdct:           MDCTContext::new(),
 243             granule:        [[Granule::default(); 2]; 2],
 244             scfsi:          [[false; 4]; 2],
 245             main_data_end:  0,
 246             is_mode:        [0; SAMPLES],
 247             mpeg1:          false,
 248             sf_idx:         0,
 249
 250             delay:          [[0.0; SAMPLES / 2]; 2],
 251             tmp:            [0.0; SAMPLES / 2],
 252         }
 253     }
 254     pub fn reset(&mut self) {
 255         for dly in self.delay.iter_mut() {
 256             for el in dly.iter_mut() {
 257                 *el = 0.0;
 258             }
 259         }
 260     }
 261     fn calc_scale(gr: &Granule, sb: usize, ssb: usize, sblk_gain: u8) -> i8 {
 262         (i32::from(gr.global_gain) - 64 - 146
 263             - 8 * i32::from(sblk_gain)
 264             - if gr.scalefac_scale { 4 } else { 2 } * (i32::from(gr.scalefac[ssb])
 265                 + if gr.preflag { i32::from(MP3_PREEMP_SCALES[sb]) } else { 0 })
 266         ).min(127).max(-124) as i8
 267     }
 268     fn read_mp3_coeffs(&mut self, br: &mut BitReader, end: usize, gr_no: usize, ch: usize, coeffs: &mut [f32]) -> DecoderResult<()> {
 269         let mut scales = [0; SAMPLES / 2];
 270         let gr = &mut self.granule[gr_no][ch];
 271
 272         // calculate scales first
 273         if gr.block_type != 2 {
 274             let mut off = 0;
 275             let mut sb = 0;
 276             while off < SAMPLES / 2 {
 277                 let end = MP3_SFB_LONG_OFFS[self.sf_idx][sb + 1];
 278                 let scale = Self::calc_scale(gr, sb, sb, 0);
 279                 for el in scales[off..end].iter_mut() {
 280                     *el = scale;
 281                 }
 282
 283                 if ch == 1 {
 284                     let scf = gr.scalefac[sb.min(MP3_BANDS - 1)];
 285                     if scf != gr.istereo[sb] {
 286                         for el in self.is_mode[gr_no * SAMPLES/2..][off..end].iter_mut() {
 287                             *el = scf as i8;
 288                         }
 289                     }
 290                 }
 291
 292                 sb += 1;
 293                 off = end;
 294             }
 295         } else {
 296             let end_band = if self.mpeg1 { 8 } else { 6 };
 297
 298             let mut off = 0;
 299             let mut sb = 0;
 300             if gr.switch_point {
 301                 while sb < end_band {
 302                     let end = MP3_SFB_LONG_OFFS[self.sf_idx][sb + 1];
 303                     let scale = Self::calc_scale(gr, sb, sb, 0);
 304                     for el in scales[off..end].iter_mut() {
 305                         *el = scale;
 306                     }
 307
 308                     if ch == 1 {
 309                         let scf = gr.scalefac[sb.min(MP3_BANDS - 1)];
 310                         if scf != gr.istereo[sb] {
 311                             for el in self.is_mode[gr_no * SAMPLES/2..][off..end].iter_mut() {
 312                                 *el = scf as i8;
 313                             }
 314                         }
 315                     }
 316                     sb += 1;
 317                     off = end;
 318                 }
 319             }
 320             let mut ssb = if gr.switch_point { 8 } else { 0 };
 321             let mut sb = if gr.switch_point { 3 } else { 0 };
 322             while sb <= MP3_BANDS_SHORT {
 323                 let band_size = MP3_SFB_SHORT_SIZE[self.sf_idx][sb];
 324                 for win in 0..3 {
 325                     let scale = Self::calc_scale(gr, sb, ssb, gr.subblock_gain[win]);
 326                     for el in scales[off..][..band_size].iter_mut() {
 327                         *el = scale;
 328                     }
 329
 330                     if ch == 1 {
 331                         if sb == MP3_BANDS_SHORT {
 332                             gr.scalefac[ssb] = gr.scalefac[ssb - 3];
 333                             gr.istereo[ssb]  = gr.istereo[ssb - 3];
 334                         }
 335                         let scf = gr.scalefac[ssb];
 336                         if scf != gr.istereo[ssb] {
 337                             for el in self.is_mode[gr_no * SAMPLES/2 + off..][..band_size].iter_mut() {
 338                                 *el = scf as i8;
 339                             }
 340                         }
 341                     }
 342                     off += band_size;
 343                     ssb += 1;
 344                 }
 345                 sb += 1;
 346             }
 347         }
 348
 349         // prepare for coefficients decoding
 350         let region1_start = if gr.block_type != 2 {
 351                 MP3_SFB_LONG_OFFS[self.sf_idx][gr.region_address1 as usize + 1]
 352             } else if gr.switch_point {
 353                 36
 354             } else {
 355                 MP3_SFB_SHORT_OFFS[self.sf_idx][3] * 3
 356             }.min(gr.big_values);
 357         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
 359         for el in coeffs[..SAMPLES/2].iter_mut() {
 360             *el = 0.0;
 361         }
 362
 363         // read coefficients
 364         gr.lastcoded = 0;
 365         if let Some((cb, esc_bits)) = self.cb.get_cb(gr.table_select[0]) {
 366             let lc = read_region(br, end, coeffs, &scales, 0, region1_start, cb, esc_bits)?;
 367             gr.lastcoded = gr.lastcoded.max(lc);
 368         }
 369         if let Some((cb, esc_bits)) = self.cb.get_cb(gr.table_select[1]) {
 370             let lc = read_region(br, end, coeffs, &scales, region1_start, region2_start, cb, esc_bits)?;
 371             gr.lastcoded = gr.lastcoded.max(lc);
 372         }
 373         if let Some((cb, esc_bits)) = self.cb.get_cb(gr.table_select[2]) {
 374             let lc = read_region(br, end, coeffs, &scales, region2_start, gr.big_values, cb, esc_bits)?;
 375             gr.lastcoded = gr.lastcoded.max(lc);
 376         }
 377         let (lc, zp) = read_region_quad(br, end, coeffs, &scales, gr.big_values, if !gr.count1table_select { Some(&self.cb.quad_cb) } else { None })?;
 378         gr.lastcoded = gr.lastcoded.max(lc);
 379         gr.zero_part = if zp > 0 { zp } else { gr.lastcoded };
 380
 381         Ok(())
 382     }
 383     pub fn read_mp3_side_data(&mut self, br: &mut BitReader, channels: usize) -> DecoderResult<()> {
 384         if self.mpeg1 {
 385             self.main_data_end          = br.read(9)? as usize;
 386             let _private_bits           = br.read(if channels == 1 { 5 } else { 3 })?;
 387             for scfsis in self.scfsi[..channels].iter_mut() {
 388                 for scfsi in scfsis.iter_mut() {
 389                     *scfsi              = br.read_bool()?;
 390                 }
 391             }
 392         } else {
 393             self.main_data_end          = br.read(8)? as usize;
 394             let _private_bits           = br.read(channels as u8)?;
 395         }
 396         let granules = if self.mpeg1 { 2 } else { 1 };
 397         for grans in self.granule[..granules].iter_mut() {
 398             for gr in grans[..channels].iter_mut() {
 399                 gr.part2_3_length       = br.read(12)? as usize;
 400                 gr.big_values           = (br.read(9)? as usize) * 2;
 401                 gr.global_gain          = br.read(8)? as u8;
 402                 gr.scalefac_compress    = br.read(if self.mpeg1 { 4 } else { 9 })? as usize;
 403                 gr.blocksplit           = br.read_bool()?;
 404                 if gr.blocksplit {
 405                     gr.block_type       = br.read(2)? as u8;
 406                     gr.switch_point     = br.read_bool()?;
 407                     for tsel in gr.table_select[..2].iter_mut() {
 408                         *tsel           = br.read(5)? as u8;
 409                         match *tsel {
 410                             4 | 14 => return Err(DecoderError::InvalidData),
 411                             _ => {},
 412                         };
 413                     }
 414                     for gain in gr.subblock_gain.iter_mut() {
 415                         *gain           = br.read(3)? as u8;
 416                     }
 417                     gr.region_address1 = 7;
 418                     gr.region_address2 = 13;
 419                 } else {
 420                     gr.block_type = 0;
 421                     gr.switch_point = false;
 422                     for tsel in gr.table_select.iter_mut() {
 423                         *tsel           = br.read(5)? as u8;
 424                         match *tsel {
 425                             4 | 14 => return Err(DecoderError::InvalidData),
 426                             _ => {},
 427                         };
 428                     }
 429                     gr.region_address1  = br.read(4)? as u8;
 430                     gr.region_address2  = br.read(3)? as u8;
 431                 }
 432                 if self.mpeg1 {
 433                     gr.preflag          = br.read_bool()?;
 434                 } else {
 435                     gr.preflag = false;
 436                 }
 437                 gr.scalefac_scale       = br.read_bool()?;
 438                 gr.count1table_select   = br.read_bool()?
 439             }
 440         }
 441         Ok(())
 442     }
 443     pub fn decode_mpeg1_layer3(&mut self, br: &mut BitReader, coeffs: &mut [[f32; SAMPLES]; 2], channels: usize) -> DecoderResult<()> {
 444         let mut data_end = 0;
 445         for gr_no in 0..2 {
 446             for ch in 0..channels {
 447                 data_end += self.granule[gr_no][ch].part2_3_length;
 448
 449                 if self.granule[gr_no][ch].block_type != 2 {
 450                     if gr_no != 0 {
 451                         self.granule[1][ch].scalefac = self.granule[0][ch].scalefac;
 452                     } else {
 453                         for scf in self.granule[gr_no][ch].scalefac.iter_mut() {
 454                             *scf = 0;
 455                         }
 456                     }
 457
 458                     let gr = &mut self.granule[gr_no][ch];
 459                     let bits1 = MP3_SCALEFAC_BITS1[gr.scalefac_compress];
 460                     let bits2 = MP3_SCALEFAC_BITS2[gr.scalefac_compress];
 461                     for cb in 0..11 {
 462                         if !self.scfsi[ch][SCFSI_FROM_BAND[cb]] || (gr_no == 0) {
 463                             gr.scalefac[cb]     = br.read(bits1)? as u8;
 464                         }
 465                     }
 466                     for cb in 11..MP3_BANDS {
 467                         if !self.scfsi[ch][SCFSI_FROM_BAND[cb]] || (gr_no == 0) {
 468                             gr.scalefac[cb]     = br.read(bits2)? as u8;
 469                         }
 470                     }
 471                     for scf in gr.scalefac[MP3_BANDS..].iter_mut() {
 472                         *scf = 0;
 473                     }
 474                     for is in gr.istereo.iter_mut() {
 475                         *is = 7;
 476                     }
 477                 } else {
 478                     let gr = &mut self.granule[gr_no][ch];
 479                     let bits1 = MP3_SCALEFAC_BITS1[gr.scalefac_compress];
 480                     let bits2 = MP3_SCALEFAC_BITS2[gr.scalefac_compress];
 481                     let pivot = if gr.blocksplit && gr.switch_point { 17 } else { 18 };
 482
 483                     for scf in gr.scalefac[..pivot].iter_mut() {
 484                         *scf        = br.read(bits1)? as u8;
 485                     }
 486                     for scf in gr.scalefac[pivot..][..18].iter_mut() {
 487                         *scf        = br.read(bits2)? as u8;
 488                     }
 489                     for scf in gr.scalefac[pivot + 18..].iter_mut() {
 490                         *scf = 0;
 491                     }
 492                     for is in gr.istereo.iter_mut() {
 493                         *is = 7;
 494                     }
 495                 }
 496                 self.read_mp3_coeffs(br, data_end, gr_no, ch, &mut coeffs[ch][gr_no * SAMPLES/2..])?;
 497                 validate!(br.tell() <= data_end);
 498                 br.seek(data_end as u32)?;
 499             }
 500         }
 501         Ok(())
 502     }
 503     pub fn decode_mpeg2_layer3(&mut self, br: &mut BitReader, coeffs: &mut [[f32; SAMPLES]; 2], channels: usize, mode_ext: u8) -> DecoderResult<()> {
 504         let mut data_end = 0;
 505         for ch in 0..channels {
 506             let gr = &mut self.granule[0][ch];
 507             data_end += gr.part2_3_length;
 508
 509             let mut bits = [0; 4];
 510             let idx = gr.get_mpeg2_params(&mut bits, (ch == 0) || ((mode_ext & IS_MODE) == 0));
 511             let idx2 = if gr.block_type != 2 { 0 } else if !gr.switch_point { 1 } else { 2 };
 512
 513             gr.preflag = idx == 2;
 514             let ends = &MP3_SCF_ENDS[idx][idx2];
 515
 516             for (scf, is) in gr.scalefac[0..ends[0]].iter_mut().zip(gr.istereo[0..ends[0]].iter_mut()) {
 517                 *scf                    = br.read(bits[0])? as u8;
 518                 *is = (1 << bits[0]) - 1;
 519             }
 520             for (scf, is) in gr.scalefac[ends[0]..ends[1]].iter_mut().zip(gr.istereo[ends[0]..ends[1]].iter_mut()) {
 521                 *scf                    = br.read(bits[1])? as u8;
 522                 *is = (1 << bits[1]) - 1;
 523             }
 524             for (scf, is) in gr.scalefac[ends[1]..ends[2]].iter_mut().zip(gr.istereo[ends[1]..ends[2]].iter_mut()) {
 525                 *scf                    = br.read(bits[2])? as u8;
 526                 *is = (1 << bits[2]) - 1;
 527             }
 528             for (scf, is) in gr.scalefac[ends[2]..ends[3]].iter_mut().zip(gr.istereo[ends[2]..ends[3]].iter_mut()) {
 529                 *scf                    = br.read(bits[3])? as u8;
 530                 *is = (1 << bits[3]) - 1;
 531             }
 532             self.read_mp3_coeffs(br, data_end, 0, ch, &mut coeffs[ch])?;
 533             validate!(br.tell() <= data_end);
 534             br.seek(data_end as u32)?;
 535         }
 536         Ok(())
 537     }
 538     #[allow(clippy::manual_range_contains)]
 539     pub fn synth(&mut self, coeffs: &mut [[f32; SAMPLES]; 2], output: &mut [[[f32; 32]; 36]; 2], mode: u8, mode_ext: u8) {
 540         let channels = if mode == 3 { 1 } else { 2 };
 541         let granules = if self.mpeg1 { 2 } else { 1 };
 542
 543         let mut end_freq = [[0; 2]; 2];
 544         for gr_no in 0..granules {
 545             for ch in 0..channels {
 546                 end_freq[gr_no][ch] = self.granule[gr_no][ch].lastcoded;
 547             }
 548         }
 549
 550         let mut band_flags = [[0; MP3_MAX_BANDS + 3]; 2];
 551         let mut band_start = [[0; MP3_MAX_BANDS + 3]; 2];
 552         let mut band_end   = [[0; MP3_MAX_BANDS + 3]; 2];
 553
 554         if mode == 1 { // joint stereo
 555             let mut bound_band = [0; 2];
 556             let mut num_bands = [MP3_BANDS + 1; 2];
 557
 558             for (gr_no, grans) in self.granule[..granules].iter_mut().enumerate() {
 559                 if grans[1].block_type != 2 {
 560                     for band in 0..=MP3_BANDS {
 561                         band_flags[gr_no][band] = mode_ext;
 562                         band_start[gr_no][band] = MP3_SFB_LONG_OFFS[self.sf_idx][band];
 563                         band_end  [gr_no][band] = MP3_SFB_LONG_OFFS[self.sf_idx][band + 1];
 564                         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)]) {
 565                             band_flags[gr_no][band] &= !IS_MODE;
 566                         }
 567                         if band_start[gr_no][band] < end_freq[gr_no][1] {
 568                             bound_band[gr_no] = band;
 569                         }
 570                         if (band_flags[gr_no][band] & IS_MODE) == 0 {
 571                             for el in self.is_mode[gr_no * SAMPLES/2..][band_start[gr_no][band]..band_end[gr_no][band]].iter_mut() {
 572                                 *el = -1;
 573                             }
 574                         }
 575                     }
 576                 } else {
 577                     let switch_off = if grans[1].switch_point { 3 } else { 0 };
 578                     let mut start = 0;
 579                     let mut band = 0;
 580                     if grans[1].switch_point {
 581                         let long_bands = if self.mpeg1 { 8 } else { 6 };
 582                         for _ in 0..long_bands {
 583                             band_flags[gr_no][band] = mode_ext;
 584                             band_start[gr_no][band] = MP3_SFB_LONG_OFFS[self.sf_idx][band];
 585                             band_end  [gr_no][band] = MP3_SFB_LONG_OFFS[self.sf_idx][band + 1];
 586                             if end_freq[gr_no][1] >= band_end[gr_no][band] {
 587                                 band_flags[gr_no][band] &= !IS_MODE;
 588                             }
 589                             start = band_end[gr_no][band];
 590                             band += 1;
 591                         }
 592                     }
 593                     for sb in switch_off..=MP3_BANDS_SHORT {
 594                         let band_size = MP3_SFB_SHORT_SIZE[self.sf_idx][sb];
 595                         for _win in 0..3 {
 596                             band_flags[gr_no][band] = mode_ext;
 597                             band_start[gr_no][band] = start;
 598                             band_end  [gr_no][band] = start + band_size;
 599                             if end_freq[gr_no][1] >= band_end[gr_no][band] {
 600                                 band_flags[gr_no][band] &= !IS_MODE;
 601                             }
 602                             start += band_size;
 603                             band += 1;
 604                         }
 605                     }
 606                     num_bands[gr_no] = band;
 607                 }
 608             }
 609             if (mode_ext & IS_MODE) != 0 {
 610                 for (gr_no, grans) in self.granule[..granules].iter_mut().enumerate() {
 611                     let (coef0, coef1) = coeffs.split_at_mut(1);
 612                     let coef0 = &mut coef0[0][gr_no * SAMPLES/2..];
 613                     let coef1 = &mut coef1[0][gr_no * SAMPLES/2..];
 614                     let is_mode = &self.is_mode[gr_no * SAMPLES/2..];
 615                     let start = band_end[gr_no][bound_band[gr_no]];
 616                     let end = grans[0].zero_part.max(start);
 617
 618                     if self.mpeg1 {
 619                         let coef0 = &mut coef0[start..end];
 620                         let coef1 = &mut coef1[start..end];
 621                         let is_mode = &self.is_mode[gr_no * SAMPLES/2..][start..end];
 622                         for ((l, r), &is) in coef0.iter_mut().zip(coef1.iter_mut()).zip(is_mode.iter()) {
 623                             if is >= 0 && is < 7 {
 624                                 let t = *l * MP3_ISTEREO_COEFFS[is as usize];
 625                                 *l -= t;
 626                                 *r  = t;
 627                             }
 628                         }
 629                     } else {
 630                         let iscale = (grans[1].scalefac_compress & 1) as u8;
 631                         for band in 0..num_bands[gr_no] {
 632                             if (band_flags[gr_no][band] & IS_MODE) != 0 {
 633                                 let start = band_start[gr_no][band];
 634                                 let end   = band_end[gr_no][band];
 635                                 apply_istereo(&mut coef0[start..end], &mut coef1[start..end], is_mode[start], iscale, (band_flags[gr_no][band] & MS_MODE) != 0);
 636                             }
 637                         }
 638                     }
 639                     end_freq[gr_no][1] = end_freq[gr_no][1].max(end);
 640                 }
 641             }
 642             if (mode_ext & MS_MODE) != 0 {
 643                 for (gr_no, grans) in self.granule[..granules].iter_mut().enumerate() {
 644                     let end = grans[0].zero_part.max(grans[1].zero_part);
 645                     let (coef0, coef1) = coeffs.split_at_mut(1);
 646                     let coef0 = &mut coef0[0][gr_no * SAMPLES/2..];
 647                     let coef1 = &mut coef1[0][gr_no * SAMPLES/2..];
 648                     for band in 0..num_bands[gr_no] {
 649                         if band_start[gr_no][band] >= end {
 650                             break;
 651                         }
 652                         if band_flags[gr_no][band] == MS_MODE {
 653                             let start = band_start[gr_no][band];
 654                             let end   = band_end[gr_no][band];
 655                             super::apply_ms(&mut coef0[start..end], &mut coef1[start..end]);
 656                         }
 657                     }
 658                     end_freq[gr_no][0] = end;
 659                     end_freq[gr_no][1] = end;
 660                 }
 661             }
 662         }
 663         for (gr_no, grans) in self.granule[..granules].iter_mut().enumerate() {
 664             for (ch, gr) in grans[..channels].iter_mut().enumerate() {
 665                 let src = &mut coeffs[ch][gr_no * SAMPLES/2..][..SAMPLES/2];
 666                 if gr.block_type != 2 {
 667                     dealias(src, SAMPLES/2);
 668                     self.mdct.mdct36(src, &mut self.tmp, &mut self.delay[ch], end_freq[gr_no][ch], gr.block_type);
 669                 } else {
 670                     let switch_off = if gr.switch_point { MP3_SFB_LONG_OFFS[self.sf_idx][if self.mpeg1 { 8 } else { 6 }] } else { 0 };
 671                     let mut band_buf = [0.0; 66 * 3];
 672                     let mut sb = if gr.switch_point { 3 } else { 0 };
 673                     let mut off = switch_off;
 674
 675                     while sb <= MP3_BANDS_SHORT {
 676                         let band_size = MP3_SFB_SHORT_SIZE[self.sf_idx][sb];
 677                         for win in 0..3 {
 678                             for i in 0..band_size {
 679                                 band_buf[win + i * 3] = src[off + win * band_size + i];
 680                             }
 681                         }
 682                         src[off..][..band_size * 3].copy_from_slice(&band_buf[..band_size * 3]);
 683                         off += band_size * 3;
 684                         sb += 1;
 685                     }
 686                     if gr.switch_point {
 687                         dealias(src, switch_off);
 688                         self.mdct.mdct36(src, &mut self.tmp, &mut self.delay[ch], switch_off, gr.block_type);
 689                     }
 690                     self.mdct.mdct12(&src[switch_off..], &mut self.tmp[switch_off..], &mut self.delay[ch][switch_off..], end_freq[gr_no][ch] - switch_off);
 691                 }
 692
 693                 let dst = &mut output[ch][gr_no * 18..];
 694                 let end = (end_freq[gr_no][ch] + 17) / 18;
 695                 for i in 0..end {
 696                     for j in 0..18 {
 697                         dst[j][i] = self.tmp[i * 18 + j];
 698                     }
 699                 }
 700                 for i in end..32 {
 701                     for j in 0..18 {
 702                         dst[j][i] = self.delay[ch][i * 18 + j];
 703                     }
 704                     for el in self.delay[ch][i * 18..][..18].iter_mut() {
 705                         *el = 0.0;
 706                     }
 707                 }
 708             }
 709         }
 710     }
 711 }
 712
 713 fn mp3_unquant(val: u32, scale: i8) -> f32 {
 714     (val as f32) * (val as f32).cbrt() * 2.0f32.powf((scale as f32) * 0.25)
 715 }
 716
 717 #[allow(clippy::too_many_arguments)]
 718 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> {
 719     let mut lastcoded = 0;
 720     for (i, (cpair, scpair)) in coeffs[start..end].chunks_exact_mut(2).zip(scales[start..end].chunks_exact(2)).enumerate() {
 721         if br.tell() >= br_end { break; }
 722         let val                         = br.read_cb(cb)?;
 723         if val == 0 {
 724             continue;
 725         }
 726         let a = if (val >> 4) != 0xF || esc_bits == 0 {
 727                 u32::from(val >> 4)
 728             } else {
 729                                           br.read(esc_bits)? + 15
 730             };
 731         if a != 0 {
 732             let a = mp3_unquant(a, scpair[0]);
 733             cpair[0] = if br.read_bool()? { -a } else { a };
 734         }
 735         let b = if (val & 0xF) != 0xF || esc_bits == 0 {
 736                 u32::from(val & 0xF)
 737             } else {
 738                                           br.read(esc_bits)? + 15
 739             };
 740         if b != 0 {
 741             let b = mp3_unquant(b, scpair[1]);
 742             cpair[1] = if br.read_bool()? { -b } else { b };
 743         }
 744         lastcoded = start + (i + 1) * 2;
 745     }
 746     Ok(lastcoded)
 747 }
 748
 749 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)> {
 750     let mut lastcoded = 0;
 751     let mut zero_part = 0;
 752     if br.tell() >= br_end {
 753         return Ok((0, 0));
 754     }
 755     for (i, (cquad, scquad)) in coeffs[start..SAMPLES/2].chunks_exact_mut(4).zip(scales[start..].chunks_exact(4)).enumerate() {
 756         zero_part = start + i * 4 + 4;
 757         if br.tell() >= br_end || (br.tell() + 3 >= br_end && cb.is_none()) {
 758             break;
 759         }
 760         let val = if let Some(cbook) = cb { br.read_cb(cbook)? } else { (br.read(4)? as u8) ^ 0xF };
 761         if val == 0 {
 762             continue;
 763         }
 764         for j in 0..4 {
 765             if ((val >> (3 - j)) & 1) != 0 {
 766                 cquad[j] = mp3_unquant(1, scquad[j]);
 767                 if br.read_bool()? {
 768                     cquad[j] = -cquad[j];
 769                 }
 770                 lastcoded = start + i * 4 + j + 1;
 771             }
 772         }
 773     }
 774     Ok((lastcoded, zero_part))
 775 }
 776
 777 const DCT12_0: f32 = -0.92387953251128675613;
 778 const DCT12_1: f32 = -0.38268343236508977174;
 779
 780 const DCT12_2: f32 = -0.1305261922200516;
 781 const DCT12_3: f32 = -0.6087614290087205;
 782 const DCT12_4: f32 =  0.7933533402912348;
 783 const DCT12_5: f32 =  0.9914448613738103;
 784
 785 fn dct12(src: &[f32], dst: &mut [f32]) {
 786     let t0 = src[0] - src[9] - src[12];
 787     let t1 = src[3] - src[6] - src[15];
 788
 789     dst[ 4] = t0 * DCT12_1 - t1 * DCT12_0;
 790     dst[ 7] = t0 * DCT12_0 + t1 * DCT12_1;
 791     dst[ 1] = -dst[4];
 792     dst[10] =  dst[7];
 793
 794     let t0 = src[3] * DCT12_1 - src[12] * DCT12_0;
 795     let t1 = src[3] * DCT12_0 + src[12] * DCT12_1;
 796
 797     dst[ 3] =  src[0] * DCT12_2 + src[6] * DCT12_3 + src[9] * DCT12_4 + src[15] * DCT12_5 - t0;
 798     dst[ 5] =  src[0] * DCT12_3 - src[6] * DCT12_2 - src[9] * DCT12_5 + src[15] * DCT12_4 - t1;
 799     dst[ 6] = -src[0] * DCT12_4 + src[6] * DCT12_5 - src[9] * DCT12_2 + src[15] * DCT12_3 - t0;
 800     dst[ 8] = -src[0] * DCT12_5 - src[6] * DCT12_4 + src[9] * DCT12_3 + src[15] * DCT12_2 + t1;
 801     dst[ 2] = -dst[3];
 802     dst[ 0] = -dst[5];
 803     dst[11] =  dst[6];
 804     dst[ 9] =  dst[8];
 805 }
 806
 807 const DCT36_PRESCALE: [f32; 18] = [
 808     0.99904822158185776240, 0.99144486137381041114, 0.97629600711993336597,
 809     0.95371695074822692114, 0.92387953251128675613, 0.88701083317822170105,
 810     0.84339144581288570127, 0.79335334029123516458, 0.73727733681012404139,
 811     0.67559020761566024435, 0.60876142900872063942, 0.53729960834682383185,
 812     0.46174861323503393057, 0.38268343236508977174, 0.30070579950427312163,
 813     0.21643961393810287977, 0.13052619222005159156, 0.04361938736533599979
 814 ];
 815 const DCT36_TWIDDLE: [f32; 9] = [
 816     0.99619469809174553229, 0.96592582628906828675, 0.90630778703664996324,
 817     0.81915204428899178969, 0.70710678118654752440, 0.57357643635104609611,
 818     0.42261826174069943619, 0.25881904510252076236, 0.08715574274765817357
 819 ];
 820 const SDCT2_TWIDDLE: [f32; 7] = [
 821     -2.0 * 0.98480775301220805936, -2.0 * 0.86602540378443864676,
 822     -2.0 * 0.76604444311897803520, -2.0 * 0.64278760968653932633,
 823     -2.0 * 0.34202014332566873305, -2.0 * 0.17364817766693034887,
 824      2.0 * 0.93969262078590838404
 825 ];
 826
 827 fn sdct_ii(buf: &mut [f32]) {
 828     let t0 = buf[ 6] + buf[10];
 829     let t1 = buf[ 6] - buf[10];
 830     let t2 = buf[12] + buf[ 4];
 831     let t3 = buf[12] - buf[ 4];
 832     let t4 = buf[16] + buf[ 0];
 833     let t5 = buf[16] - buf[ 0];
 834
 835     let t6 =  t0 + t2;
 836     let t7 = (t0 - t2) * SDCT2_TWIDDLE[2];
 837     let t8 = (t1 + t3) * SDCT2_TWIDDLE[3];
 838     let t9 =  t1 - t3;
 839     let t0 = (t0 - t4) * SDCT2_TWIDDLE[5];
 840     let t1 = (t1 - t5) * SDCT2_TWIDDLE[0];
 841     let t2 = (t2 - t4) * SDCT2_TWIDDLE[6];
 842     let t3 = (t3 + t5) * SDCT2_TWIDDLE[4];
 843
 844     let ta =  t6 + t4;
 845     let tb = (t9 + t5) * SDCT2_TWIDDLE[1];
 846
 847     let tc =  buf[2] + buf[14];
 848     let td = (buf[2] - buf[14]) * SDCT2_TWIDDLE[1];
 849
 850     let t6 = buf[8]       + tc;
 851     let t9 = buf[8] * 2.0 - tc;
 852     let te = t9 + t2;
 853     let tf = t9 - t2;
 854     let t9 = t9 + t0;
 855
 856     buf[ 0] = ta + t6;
 857     buf[ 2] = t8 - td - t1;
 858     buf[ 4] = t7 - te;
 859     buf[ 6] = tb;
 860     buf[ 8] = tf - t0;
 861     buf[10] = td - t3 - t1;
 862     buf[12] = ta - t6 * 2.0;
 863     buf[14] = t8 + t3 + td;
 864     buf[16] = t9 + t7;
 865 }
 866
 867 fn dct36(src: &mut [f32], dst: &mut [f32]) {
 868     for (el, &w) in src.iter_mut().zip(DCT36_PRESCALE.iter()) {
 869         *el *= w;
 870     }
 871
 872     let mut tmp = [0.0; 18];
 873     for i in 0..9 {
 874         tmp[i * 2]     =  src[i] + src[17 - i];
 875         tmp[i * 2 + 1] = (src[i] - src[17 - i]) * DCT36_TWIDDLE[i] * 2.0;
 876     }
 877     sdct_ii(&mut tmp);
 878     sdct_ii(&mut tmp[1..]);
 879
 880     for i in (3..18).step_by(2) {
 881         tmp[i] -= tmp[i - 2];
 882     }
 883     tmp[0] *= 0.5;
 884     for i in 1..18 {
 885         tmp[i] = tmp[i] * 0.5 - tmp[i - 1];
 886     }
 887     for i in 0..18 {
 888         dst[i] = -tmp[17 - i] * 2.0;
 889     }
 890 }
 891
 892 const ALIAS_COEFFS_S: [f32; 8] = [
 893     0.85749292571254418689, 0.88174199731770518178,
 894     0.94962864910273289205, 0.98331459249179014599,
 895     0.99551781606758576429, 0.99916055817814750453,
 896     0.99989919524444704627, 0.99999315507028023572
 897 ];
 898 const ALIAS_COEFFS_A: [f32; 8] = [
 899     -0.51449575542752651213, -0.47173196856497227225,
 900     -0.31337745420390185437, -0.18191319961098117700,
 901     -0.09457419252642064760, -0.04096558288530404768,
 902     -0.01419856857247114805, -0.00369997467376003687
 903 ];
 904 fn dealias(buf: &mut [f32], len: usize) {
 905     for i in (18..len).step_by(18) {
 906         for (j, (&cs, &ca)) in ALIAS_COEFFS_S.iter().zip(ALIAS_COEFFS_A.iter()).enumerate() {
 907             let a = buf[i - j - 1];
 908             let b = buf[i + j];
 909             let c0 = a * cs - b * ca;
 910             let c1 = a * ca + b * cs;
 911             buf[i - j - 1] = c0;
 912             buf[i + j]     = c1;
 913         }
 914     }
 915 }
 916
 917 fn apply_istereo(ch0: &mut [f32], ch1: &mut [f32], is_mode: i8, iscale: u8, ms_mode: bool) {
 918     match (is_mode, ms_mode) {
 919         (-1, true) => {
 920             for (c0, c1) in ch0.iter_mut().zip(ch1.iter_mut()) {
 921                 let a = (*c0 + *c1) * std::f32::consts::FRAC_1_SQRT_2;
 922                 let b = (*c0 - *c1) * std::f32::consts::FRAC_1_SQRT_2;
 923                 *c0 = a;
 924                 *c1 = b;
 925             }
 926         },
 927         (-1, false) => {},
 928         (0, _) => {
 929             ch1.copy_from_slice(ch0);
 930         },
 931         _ => {
 932             let scale = mp3_unquant(1, -((is_mode + 1) >> 1) << iscale);
 933             if (is_mode & 1) == 0 {
 934                 for (&c0, c1) in ch0.iter().zip(ch1.iter_mut()) {
 935                     *c1 = c0 * scale;
 936                 }
 937             } else {
 938                 for (c0, c1) in ch0.iter_mut().zip(ch1.iter_mut()) {
 939                     *c1 = *c0;
 940                     *c0 *= scale;
 941                 }
 942             }
 943         },
 944     };
 945 }