From 16cca4d3a7a7505ae31a7469b3547c52650fd194 Mon Sep 17 00:00:00 2001 From: Kostya Shishkov Date: Tue, 9 Nov 2021 18:30:05 +0100 Subject: [PATCH 1/1] add nihav-mpeg crate --- nihav-allstuff/Cargo.toml | 1 + nihav-allstuff/src/lib.rs | 2 + nihav-mpeg/Cargo.toml | 27 + nihav-mpeg/src/codecs/mod.rs | 21 + nihav-mpeg/src/codecs/mpegaudio/mod.rs | 326 +++++++ nihav-mpeg/src/codecs/mpegaudio/mp3code.rs | 935 +++++++++++++++++++++ nihav-mpeg/src/codecs/mpegaudio/mp3data.rs | 535 ++++++++++++ nihav-mpeg/src/lib.rs | 10 + 8 files changed, 1857 insertions(+) create mode 100644 nihav-mpeg/Cargo.toml create mode 100644 nihav-mpeg/src/codecs/mod.rs create mode 100644 nihav-mpeg/src/codecs/mpegaudio/mod.rs create mode 100644 nihav-mpeg/src/codecs/mpegaudio/mp3code.rs create mode 100644 nihav-mpeg/src/codecs/mpegaudio/mp3data.rs create mode 100644 nihav-mpeg/src/lib.rs diff --git a/nihav-allstuff/Cargo.toml b/nihav-allstuff/Cargo.toml index 6e97f02..9fc23f7 100644 --- a/nihav-allstuff/Cargo.toml +++ b/nihav-allstuff/Cargo.toml @@ -13,6 +13,7 @@ nihav_game = { path = "../nihav-game" } nihav_indeo = { path = "../nihav-indeo" } nihav_itu = { path = "../nihav-itu" } nihav_llaudio = { path = "../nihav-llaudio" } +nihav_mpeg = { path = "../nihav-mpeg" } nihav_ms = { path = "../nihav-ms" } nihav_qt = { path = "../nihav-qt" } nihav_rad = { path = "../nihav-rad" } diff --git a/nihav-allstuff/src/lib.rs b/nihav-allstuff/src/lib.rs index 8e9eed1..0225579 100644 --- a/nihav-allstuff/src/lib.rs +++ b/nihav-allstuff/src/lib.rs @@ -24,6 +24,7 @@ use nihav_game::*; use nihav_indeo::indeo_register_all_decoders; use nihav_itu::itu_register_all_decoders; use nihav_llaudio::*; +use nihav_mpeg::*; use nihav_ms::*; use nihav_qt::qt_register_all_decoders; use nihav_rad::*; @@ -39,6 +40,7 @@ pub fn nihav_register_all_decoders(rd: &mut RegisteredDecoders) { indeo_register_all_decoders(rd); itu_register_all_decoders(rd); llaudio_register_all_decoders(rd); + mpeg_register_all_decoders(rd); ms_register_all_decoders(rd); qt_register_all_decoders(rd); rad_register_all_decoders(rd); diff --git a/nihav-mpeg/Cargo.toml b/nihav-mpeg/Cargo.toml new file mode 100644 index 0000000..0b21444 --- /dev/null +++ b/nihav-mpeg/Cargo.toml @@ -0,0 +1,27 @@ +[package] +name = "nihav_mpeg" +version = "0.1.0" +authors = ["Kostya Shishkov "] +edition = "2018" + +[dependencies.nihav_core] +path = "../nihav-core" + +[dependencies.nihav_codec_support] +path = "../nihav-codec-support" +features = ["qmf"] + +[dev-dependencies] +nihav_flash = { path = "../nihav-flash", default-features=false, features = ["all_demuxers"] } +nihav_realmedia = { path = "../nihav-realmedia", default-features=false, features = ["all_demuxers"] } + +[features] +default = ["all_decoders"] +decoders = [] + +all_decoders = ["all_video_decoders", "all_audio_decoders"] + +all_video_decoders = [] + +all_audio_decoders = ["decoder_mpa"] +decoder_mpa = ["decoders"] diff --git a/nihav-mpeg/src/codecs/mod.rs b/nihav-mpeg/src/codecs/mod.rs new file mode 100644 index 0000000..eb58553 --- /dev/null +++ b/nihav-mpeg/src/codecs/mod.rs @@ -0,0 +1,21 @@ +use nihav_core::codecs::*; + +macro_rules! validate { + ($a:expr) => { if !$a { println!("check failed at {}:{}", file!(), line!()); return Err(DecoderError::InvalidData); } }; +} + +#[cfg(feature="decoder_mpa")] +#[allow(clippy::excessive_precision)] +mod mpegaudio; + +const DECODERS: &[DecoderInfo] = &[ +#[cfg(feature="decoder_mpa")] + DecoderInfo { name: "mp3", get_decoder: mpegaudio::get_decoder_mp3 }, +]; + +/// Registers all available codecs provided by this crate. +pub fn mpeg_register_all_decoders(rd: &mut RegisteredDecoders) { + for decoder in DECODERS.iter() { + rd.add_decoder(*decoder); + } +} diff --git a/nihav-mpeg/src/codecs/mpegaudio/mod.rs b/nihav-mpeg/src/codecs/mpegaudio/mod.rs new file mode 100644 index 0000000..f61b0a1 --- /dev/null +++ b/nihav-mpeg/src/codecs/mpegaudio/mod.rs @@ -0,0 +1,326 @@ +use nihav_core::codecs::*; +use nihav_core::io::bitreader::*; +use nihav_codec_support::dsp::qmf::QMF; + +mod mp3data; +mod mp3code; +use mp3code::*; + +const SAMPLES: usize = 1152; +const BYTEBUF_SIZE: usize = 1024; + +#[allow(clippy::large_enum_variant)] +enum LayerData { + MP1, + MP2, + MP3(MP3Data), +} + +impl LayerData { + fn layer_id(&self) -> u8 { + match *self { + LayerData::MP1 => 0, + LayerData::MP2 => 1, + LayerData::MP3(_) => 2, + } + } + fn reset(&mut self) { + match self { + LayerData::MP1 => {}, + LayerData::MP2 => {}, + LayerData::MP3(ref mut data) => data.reset(), + }; + } +} + +struct MPADecoder { + info: NACodecInfoRef, + smap: NAChannelMap, + mmap: NAChannelMap, + qmf: [QMF; 2], + srate: u32, + channels: u8, + sf_idx: usize, + + bytebuf: Vec, + coeffs: [[f32; SAMPLES]; 2], + out: [[[f32; 32]; 36]; 2], + ctx: LayerData, +} + +impl MPADecoder { + fn new(layer: u8) -> Self { + let ctx = match layer { + 0 => LayerData::MP1, + 1 => LayerData::MP2, + 2 => LayerData::MP3(MP3Data::new()), + _ => unreachable!(), + }; + Self { + info: NACodecInfo::new_dummy(), + smap: NAChannelMap::from_ms_mapping(3), + mmap: NAChannelMap::from_ms_mapping(4), + qmf: [QMF::new(), QMF::new()], + srate: 0, + channels: 0, + sf_idx: 0, + ctx, + + bytebuf: Vec::with_capacity(BYTEBUF_SIZE), + coeffs: [[0.0; SAMPLES]; 2], + out: [[[0.0; 32]; 36]; 2], + } + } + fn read_mp3_side_data(&mut self, br: &mut BitReader, src: &[u8], mono: bool) -> DecoderResult<()> { + if let LayerData::MP3(ref mut ctx) = self.ctx { + let channels = if mono { 1 } else { 2 }; + ctx.mpeg1 = self.sf_idx < 3; + ctx.sf_idx = self.sf_idx; + ctx.read_mp3_side_data(br, channels)?; + let hdr_size = (br.tell() / 8) as usize; + let add_len = src.len() - hdr_size; + if self.bytebuf.len() + add_len > BYTEBUF_SIZE { + self.bytebuf.drain(..self.bytebuf.len() + add_len - BYTEBUF_SIZE); + } + let underrun = self.bytebuf.len() < ctx.main_data_end; + let del_len = if !underrun { self.bytebuf.len() - ctx.main_data_end } else { 0 }; + self.bytebuf.extend_from_slice(&src[hdr_size..]); + self.bytebuf.drain(..del_len); + if underrun { + return Err(DecoderError::MissingReference); + } + + Ok(()) + } else { + Err(DecoderError::Bug) + } + } + fn decode_layer3(&mut self, channels: usize, mode_ext: u8) -> DecoderResult { + if let LayerData::MP3(ref mut ctx) = self.ctx { + let mut br = BitReader::new(&self.bytebuf, BitReaderMode::BE); + if ctx.mpeg1 { + ctx.decode_mpeg1_layer3(&mut br, &mut self.coeffs, channels)?; + } else { + ctx.decode_mpeg2_layer3(&mut br, &mut self.coeffs, channels, mode_ext)?; + } + let used_data = (br.tell() + 7) / 8; + self.bytebuf.drain(..used_data); + + Ok(true) + } else { + Err(DecoderError::Bug) + } + } + fn synth_layer3(&mut self, mode: u8, mode_ext: u8) { + if let LayerData::MP3(ref mut ctx) = self.ctx { + ctx.synth(&mut self.coeffs, &mut self.out, mode, mode_ext); + } + } +} + +fn apply_ms(ch0: &mut [f32], ch1: &mut [f32]) { + for (l, r) in ch0.iter_mut().zip(ch1) { + let ll = (*l + *r) * std::f32::consts::FRAC_1_SQRT_2; + let rr = (*l - *r) * std::f32::consts::FRAC_1_SQRT_2; + *l = ll; + *r = rr; + } +} + +impl NADecoder for MPADecoder { + fn init(&mut self, _supp: &mut NADecoderSupport, info: NACodecInfoRef) -> DecoderResult<()> { + if let NACodecTypeInfo::Audio(_ainfo) = info.get_properties() { + self.info = info.clone(); + Ok(()) + } else { + Err(DecoderError::InvalidData) + } + } + fn decode(&mut self, _supp: &mut NADecoderSupport, pkt: &NAPacket) -> DecoderResult { + let info = pkt.get_stream().get_info(); + if let NACodecTypeInfo::Audio(_) = info.get_properties() { + let src = pkt.get_buffer(); + + let mut br = BitReader::new(src.as_slice(), BitReaderMode::BE); + + let syncword = br.read(11)?; + validate!(syncword == 0x7FF); + let id = br.read(2)?; + validate!(id != 1); + let layer = (br.read(2)? ^ 3) as u8; + validate!(layer != 3); + let protection = br.read_bool()?; + let bitrate_index = br.read(4)? as usize; + validate!(bitrate_index < 15); + if bitrate_index == 0 { + //todo freeform eventually + unimplemented!(); + } + let mut sf_idx = br.read(2)? as usize; + validate!(sf_idx != 3); + let padding = br.read_bool()?; + let _private = br.read_bool()?; + let mode = br.read(2)? as u8; + let mode_extension = br.read(2)? as u8; + let _copyright = br.read_bool()?; + let _original = br.read_bool()?; + let _emphasis = br.read(2)?; + if !protection { + let _crc_check = br.read(16)?; + } + validate!(layer == self.ctx.layer_id()); + match id { + 0 => sf_idx += 6, + 2 => sf_idx += 3, + _ => {}, + }; + let mpeg1 = id == 3; + let srate = SAMPLING_RATE[sf_idx]; + if self.srate == 0 { + self.srate = srate; + } + validate!(srate == self.srate); + let channels = if mode == 3 { 1 } else { 2 }; + if self.channels == 0 { + self.channels = channels; + } + if channels != self.channels { + self.flush(); + } + let bitrate = BITRATE[if mpeg1 { 0 } else { 1 }][layer as usize][bitrate_index]; + let frame_size = match layer { + 0 => { + ((SAMPLES / 3 / 8 * 1000 * (bitrate as usize) / (srate as usize)) & !3) + if padding { 4 } else { 0 } + }, + 2 if !mpeg1 => { + SAMPLES / 2 / 8 * 1000 * (bitrate as usize) / (srate as usize) + if padding { 1 } else { 0 } + }, + _ => { + SAMPLES / 8 * 1000 * (bitrate as usize) / (srate as usize) + if padding { 1 } else { 0 } + }, + }; + validate!(src.len() >= frame_size); + self.sf_idx = sf_idx; + + let nsamples = if mpeg1 { SAMPLES } else { SAMPLES / 2 }; + + let ainfo = NAAudioInfo::new(srate, channels, SND_F32P_FORMAT, nsamples); + let chmap = if channels == 1 { self.mmap.clone() } else { self.smap.clone() }; + + let mut abuf = alloc_audio_buffer(ainfo, nsamples, chmap)?; + let mut adata = abuf.get_abuf_f32().unwrap(); + let off = if channels == 1 { adata.get_length() } else { adata.get_stride() }; + let buf = adata.get_data_mut().unwrap(); + let (ch0, ch1) = buf.split_at_mut(off); + + match layer { + 0 => unimplemented!(), + 1 => unimplemented!(), + _ => { + let ret = self.read_mp3_side_data(&mut br, &src[..frame_size], channels == 1); + match ret { + Err(DecoderError::MissingReference) => { + abuf.truncate_audio(0); + let mut frm = NAFrame::new_from_pkt(pkt, self.info.clone(), abuf); + frm.set_duration(Some(0)); + return Ok(frm.into_ref()); + }, + Err(err) => return Err(err), + Ok(()) => {}, + }; + let has_data = self.decode_layer3(channels as usize, mode_extension)?; + if !has_data { + let frm = NAFrame::new_from_pkt(pkt, self.info.clone(), NABufferType::None); + return Ok(frm.into_ref()); + } + self.synth_layer3(mode, mode_extension); + for (dst, src) in ch0.chunks_exact_mut(32).zip(self.out[0].iter_mut()) { + self.qmf[0].synth(src, dst); + } + if channels == 2 { + for (dst, src) in ch1.chunks_mut(32).zip(self.out[1].iter_mut()) { + self.qmf[1].synth(src, dst); + } + } + }, + }; + + let mut frm = NAFrame::new_from_pkt(pkt, self.info.clone(), abuf); + frm.set_duration(Some(nsamples as u64)); + frm.set_keyframe(true); + Ok(frm.into_ref()) + } else { + Err(DecoderError::Bug) + } + } + fn flush(&mut self) { + for qmf in self.qmf.iter_mut() { + *qmf = QMF::new(); + } + self.bytebuf.clear(); + self.ctx.reset(); + } +} + +impl NAOptionHandler for MPADecoder { + fn get_supported_options(&self) -> &[NAOptionDefinition] { &[] } + fn set_options(&mut self, _options: &[NAOption]) { } + fn query_option_value(&self, _name: &str) -> Option { None } +} + +pub fn get_decoder_mp3() -> Box { + Box::new(MPADecoder::new(2)) +} + +#[cfg(test)] +mod test { + use nihav_core::codecs::RegisteredDecoders; + use nihav_core::demuxers::RegisteredDemuxers; + use nihav_codec_support::test::dec_video::test_decode_audio; + use crate::mpeg_register_all_decoders; + use nihav_flash::flash_register_all_demuxers; + #[test] + fn test_mpeg1_layer3_mono() { + let mut dmx_reg = RegisteredDemuxers::new(); + flash_register_all_demuxers(&mut dmx_reg); + let mut dec_reg = RegisteredDecoders::new(); + mpeg_register_all_decoders(&mut dec_reg); + + let file = "assets/Flash/i_004.flv"; + test_decode_audio("flv", file, Some(6000), None/*Some("mp3_1")*/, &dmx_reg, &dec_reg); + } + #[test] + fn test_mpeg1_layer3_stereo() { + let mut dmx_reg = RegisteredDemuxers::new(); + flash_register_all_demuxers(&mut dmx_reg); + let mut dec_reg = RegisteredDecoders::new(); + mpeg_register_all_decoders(&mut dec_reg); + + let file = "assets/Flash/venture_030_ivcp_001_8bit.flv"; + test_decode_audio("flv", file, Some(7200), None/*Some("mp3_2")*/, &dmx_reg, &dec_reg); + } + #[test] + fn test_mpeg2_layer3() { + let mut dmx_reg = RegisteredDemuxers::new(); + flash_register_all_demuxers(&mut dmx_reg); + let mut dec_reg = RegisteredDecoders::new(); + mpeg_register_all_decoders(&mut dec_reg); + + let file = "assets/Flash/lection2-2.flv"; + test_decode_audio("flv", file, Some(6000), None/*Some("mp3_3")*/, &dmx_reg, &dec_reg); + } +} + +const BITRATE: [[[u32; 15]; 3]; 2] = [ + [ + [ 0, 32, 64, 96, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416, 448 ], + [ 0, 32, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384 ], + [ 0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320 ] + ], [ + [ 0, 32, 48, 56, 64, 80, 96, 112, 128, 144, 160, 176, 192, 224, 256 ], + [ 0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160 ], + [ 0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160 ] + ] +]; + +const SAMPLING_RATE: [u32; 9] = [ 44100, 48000, 32000, 22050, 24000, 16000, 11025, 12000, 8000 ]; diff --git a/nihav-mpeg/src/codecs/mpegaudio/mp3code.rs b/nihav-mpeg/src/codecs/mpegaudio/mp3code.rs new file mode 100644 index 0000000..84be76a --- /dev/null +++ b/nihav-mpeg/src/codecs/mpegaudio/mp3code.rs @@ -0,0 +1,935 @@ +use nihav_core::codecs::*; +use nihav_core::io::bitreader::*; +use nihav_core::io::codebook::*; + +use super::SAMPLES; +use super::mp3data::*; + +const MP3_MAX_BANDS: usize = MP3_BANDS_SHORT * 3 + 4; +const IS_MODE: u8 = 1; +const MS_MODE: u8 = 2; + +#[derive(Clone,Copy)] +struct Granule { + part2_3_length: usize, + big_values: usize, + global_gain: u8, + scalefac_compress: usize, + blocksplit: bool, + block_type: u8, + switch_point: bool, + table_select: [u8; 3], + subblock_gain: [u8; 3], + region_address1: u8, + region_address2: u8, + preflag: bool, + scalefac_scale: bool, + count1table_select: bool, + scalefac: [u8; MP3_MAX_BANDS], + istereo: [u8; MP3_MAX_BANDS], + + lastcoded: usize, + zero_part: usize, +} + +impl Default for Granule { + fn default() -> Self { unsafe { std::mem::MaybeUninit::zeroed().assume_init() } } +} + +impl Granule { + fn get_mpeg2_params(&self, bits: &mut [u8; 4], independent: bool) -> usize { + if independent { + match self.scalefac_compress { + 0..=399 => { + bits[0] = MP3_SCF_BITS5[(self.scalefac_compress >> 4) * 2]; + bits[1] = MP3_SCF_BITS5[(self.scalefac_compress >> 4) * 2 + 1]; + bits[2] = ((self.scalefac_compress >> 2) & 3) as u8; + bits[3] = (self.scalefac_compress & 3) as u8; + 0 + }, + 400..=499 => { + let idx = self.scalefac_compress - 400; + bits[0] = MP3_SCF_BITS5[(idx >> 2) * 2]; + bits[1] = MP3_SCF_BITS5[(idx >> 2) * 2 + 1]; + bits[2] = (idx & 3) as u8; + bits[3] = 0; + 1 + }, + _ => { + let idx = self.scalefac_compress - 500; + bits[0] = MP3_SCF_BITS3[idx * 2]; + bits[1] = MP3_SCF_BITS3[idx * 2 + 1]; + bits[2] = 0; + bits[3] = 0; + 2 + }, + } + } else { + bits[3] = 0; + let idx = self.scalefac_compress >> 1; + match idx { + 0..=179 => { + bits[0] = MP3_SCF_BITS6[idx * 3]; + bits[1] = MP3_SCF_BITS6[idx * 3 + 1]; + bits[2] = MP3_SCF_BITS6[idx * 3 + 2]; + 3 + }, + 180..=243 => { + let val = (idx - 180) as u8; + bits[0] = val >> 4; + bits[1] = (val >> 2) & 3; + bits[2] = val & 3; + 4 + }, + _ => { + let idx = idx - 244; + bits[0] = MP3_SCF_BITS6[idx * 2]; + bits[1] = MP3_SCF_BITS6[idx * 2 + 1]; + bits[2] = 0; + 5 + }, + } + } + } +} + +struct MDCTContext { + win36: [f32; 36], + win36f: [f32; 36], + win12: [f32; 12], + win12f: [f32; 12], + tmp: [f32; 36], +} + +impl MDCTContext { + fn new() -> Self { + let mut win36 = [0.0; 36]; + let mut win36f = [0.0; 36]; + let mut win12 = [0.0; 12]; + let mut win12f = [0.0; 12]; + + for i in 0..36 { + win36 [i] = ((i as f32 + 0.5) * std::f32::consts::PI / 36.0).sin(); + win36f[i] = if (i & 1) == 0 { win36[i] } else { -win36[i] }; + } + for i in 0..12 { + win12 [i] = ((i as f32 + 0.5) * std::f32::consts::PI / 12.0).sin(); + win12f[i] = if (i & 1) == 0 { win12[i] } else { -win12[i] }; + } + + Self { + tmp: [0.0; 36], + win36, win36f, win12, win12f + } + } + fn mdct36(&mut self, src: &mut [f32], dst: &mut[f32], delay: &mut [f32], len: usize, block_type: u8) { + let mut flip = false; + for i in (0..len).step_by(18) { + let (win36, win12) = if flip { (&self.win36f, &self.win12f) } else { (&self.win36, &self.win12) }; + dct36(&mut src[i..], &mut self.tmp); + match block_type { + 0 | 2 => { + for j in 0..9 { + dst[i + j] = delay[i + j] - self.tmp[8 - j] * win36[j]; + delay[i + j] = self.tmp[j + 9] * win36[j + 18]; + } + for j in 9..18 { + dst[i + j] = delay[i + j] + self.tmp[j - 9] * win36[j]; + delay[i + j] = self.tmp[26 - j] * win36[j + 18]; + } + }, + 1 => { + for j in 0..9 { + dst[i + j] = delay[i + j] - self.tmp[8 - j] * win36[j]; + } + for j in 9..18 { + dst[i + j] = delay[i + j] + self.tmp[j - 9] * win36[j]; + } + delay[i..][..6].copy_from_slice(&self.tmp[9..][..6]); + if flip { + for j in (1..6).step_by(2) { + delay[i + j] = -delay[i + j]; + } + } + for j in 6..9 { + delay[i + j] = self.tmp[j + 9] * win12[j]; + } + for j in 9..12 { + delay[i + j] = self.tmp[26 - j] * win12[j]; + } + for j in 12..18 { + delay[i + j] = 0.0; + } + }, + _ => { + dst[i..][..6].copy_from_slice(&delay[i..][..6]); + for j in 6..9 { + dst[i + j] = delay[i + j] - self.tmp[8 - j] * win12[j - 6]; + } + for j in 9..12 { + dst[i + j] = delay[i + j] + self.tmp[j - 9] * win12[j - 6]; + } + if !flip { + for j in 12..18 { + dst[i + j] = delay[i + j] + self.tmp[j - 9]; + } + } else { + for j in 12..18 { + dst[i + j] = delay[i + j] + if (j & 1) == 0 { self.tmp[j - 9] } else { -self.tmp[j - 9] }; + } + } + for j in 0..9 { + delay[i + j] = self.tmp[j + 9] * win36[j + 18]; + } + for j in 9..18 { + delay[i + j] = self.tmp[26 - j] * win36[j + 18]; + } + }, + }; + + flip = !flip; + } + } + fn mdct12(&mut self, src: &[f32], dst: &mut[f32], delay: &mut [f32], len: usize) { + let mut flip = false; + for i in (0..len).step_by(18) { + let window = if flip { &self.win12f } else { &self.win12 }; + for j in 0..3 { + let tmp = &mut self.tmp[j * 12..]; + dct12(&src[i + j * 6..], tmp); + for (el, &w) in tmp.iter_mut().zip(window.iter()) { + *el *= w; + } + } + + for j in 0..6 { + dst[i + j] = delay[i + j]; + delay[i + j] = self.tmp[j + 18] + self.tmp[j + 18 + 6]; + } + for j in 6..12 { + dst[i + j] = delay[i + j] + self.tmp[j - 6]; + delay[i + j] = self.tmp[j + 18 + 6]; + } + for j in 12..18 { + dst[i + j] = delay[i + j] + self.tmp[j - 6] + self.tmp[j]; + delay[i + j] = 0.0; + } + + flip = !flip; + } + } +} + +pub struct MP3Data { + cb: MP3Codebooks, + mdct: MDCTContext, + granule: [[Granule; 2]; 2], + scfsi: [[bool; 4]; 2], + pub main_data_end: usize, + is_mode: [i8; SAMPLES], + pub mpeg1: bool, + pub sf_idx: usize, + + delay: [[f32; SAMPLES / 2]; 2], + tmp: [f32; SAMPLES / 2], +} + +impl MP3Data { + pub fn new() -> Self { + Self { + cb: MP3Codebooks::new(), + mdct: MDCTContext::new(), + granule: [[Granule::default(); 2]; 2], + scfsi: [[false; 4]; 2], + main_data_end: 0, + is_mode: [0; SAMPLES], + mpeg1: false, + sf_idx: 0, + + delay: [[0.0; SAMPLES / 2]; 2], + tmp: [0.0; SAMPLES / 2], + } + } + pub fn reset(&mut self) { + for dly in self.delay.iter_mut() { + for el in dly.iter_mut() { + *el = 0.0; + } + } + } + fn calc_scale(gr: &Granule, sb: usize, ssb: usize, sblk_gain: u8) -> i8 { + (i32::from(gr.global_gain) - 64 - 146 + - 8 * i32::from(sblk_gain) + - if gr.scalefac_scale { 4 } else { 2 } * (i32::from(gr.scalefac[ssb]) + + if gr.preflag { i32::from(MP3_PREEMP_SCALES[sb]) } else { 0 }) + ).min(127).max(-124) as i8 + } + fn read_mp3_coeffs(&mut self, br: &mut BitReader, end: usize, gr_no: usize, ch: usize, coeffs: &mut [f32]) -> DecoderResult<()> { + let mut scales = [0; SAMPLES / 2]; + let gr = &mut self.granule[gr_no][ch]; + + // calculate scales first + if gr.block_type != 2 { + let mut off = 0; + let mut sb = 0; + while off < SAMPLES / 2 { + let end = MP3_SFB_LONG_OFFS[self.sf_idx][sb + 1]; + let scale = Self::calc_scale(gr, sb, sb, 0); + for el in scales[off..end].iter_mut() { + *el = scale; + } + + if ch == 1 { + let scf = gr.scalefac[sb.min(MP3_BANDS - 1)]; + if scf != gr.istereo[sb] { + for el in self.is_mode[gr_no * SAMPLES/2..][off..end].iter_mut() { + *el = scf as i8; + } + } + } + + sb += 1; + off = end; + } + } else { + let end_band = if self.mpeg1 { 8 } else { 6 }; + + let mut off = 0; + let mut sb = 0; + if gr.switch_point { + while sb < end_band { + let end = MP3_SFB_LONG_OFFS[self.sf_idx][sb + 1]; + let scale = Self::calc_scale(gr, sb, sb, 0); + for el in scales[off..end].iter_mut() { + *el = scale; + } + + if ch == 1 { + let scf = gr.scalefac[sb.min(MP3_BANDS - 1)]; + if scf != gr.istereo[sb] { + for el in self.is_mode[gr_no * SAMPLES/2..][off..end].iter_mut() { + *el = scf as i8; + } + } + } + sb += 1; + off = end; + } + } + let mut ssb = if gr.switch_point { 8 } else { 0 }; + let mut sb = if gr.switch_point { 3 } else { 0 }; + while sb <= MP3_BANDS_SHORT { + let band_size = MP3_SFB_SHORT_SIZE[self.sf_idx][sb]; + for win in 0..3 { + let scale = Self::calc_scale(gr, sb, ssb, gr.subblock_gain[win]); + for el in scales[off..][..band_size].iter_mut() { + *el = scale; + } + + if ch == 1 { + if sb == MP3_BANDS_SHORT { + gr.scalefac[ssb] = gr.scalefac[ssb - 3]; + gr.istereo[ssb] = gr.istereo[ssb - 3]; + } + let scf = gr.scalefac[ssb]; + if scf != gr.istereo[ssb] { + for el in self.is_mode[gr_no * SAMPLES/2 + off..][..band_size].iter_mut() { + *el = scf as i8; + } + } + } + off += band_size; + ssb += 1; + } + sb += 1; + } + } + + // prepare for coefficients decoding + let region1_start = if gr.block_type != 2 { + MP3_SFB_LONG_OFFS[self.sf_idx][gr.region_address1 as usize + 1] + } else if gr.switch_point { + 36 + } else { + MP3_SFB_SHORT_OFFS[self.sf_idx][3] * 3 + }.min(gr.big_values); + 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); + + for el in coeffs[..SAMPLES/2].iter_mut() { + *el = 0.0; + } + + // read coefficients + gr.lastcoded = 0; + if let Some((cb, esc_bits)) = self.cb.get_cb(gr.table_select[0]) { + let lc = read_region(br, end, coeffs, &scales, 0, region1_start, cb, esc_bits)?; + gr.lastcoded = gr.lastcoded.max(lc); + } + if let Some((cb, esc_bits)) = self.cb.get_cb(gr.table_select[1]) { + let lc = read_region(br, end, coeffs, &scales, region1_start, region2_start, cb, esc_bits)?; + gr.lastcoded = gr.lastcoded.max(lc); + } + if let Some((cb, esc_bits)) = self.cb.get_cb(gr.table_select[2]) { + let lc = read_region(br, end, coeffs, &scales, region2_start, gr.big_values, cb, esc_bits)?; + gr.lastcoded = gr.lastcoded.max(lc); + } + let (lc, zp) = read_region_quad(br, end, coeffs, &scales, gr.big_values, if !gr.count1table_select { Some(&self.cb.quad_cb) } else { None })?; + gr.lastcoded = gr.lastcoded.max(lc); + gr.zero_part = if zp > 0 { zp } else { gr.lastcoded }; + + Ok(()) + } + pub fn read_mp3_side_data(&mut self, br: &mut BitReader, channels: usize) -> DecoderResult<()> { + if self.mpeg1 { + self.main_data_end = br.read(9)? as usize; + let _private_bits = br.read(if channels == 1 { 5 } else { 3 })?; + for scfsis in self.scfsi[..channels].iter_mut() { + for scfsi in scfsis.iter_mut() { + *scfsi = br.read_bool()?; + } + } + } else { + self.main_data_end = br.read(8)? as usize; + let _private_bits = br.read(channels as u8)?; + } + let granules = if self.mpeg1 { 2 } else { 1 }; + for grans in self.granule[..granules].iter_mut() { + for gr in grans[..channels].iter_mut() { + gr.part2_3_length = br.read(12)? as usize; + gr.big_values = (br.read(9)? as usize) * 2; + gr.global_gain = br.read(8)? as u8; + gr.scalefac_compress = br.read(if self.mpeg1 { 4 } else { 9 })? as usize; + gr.blocksplit = br.read_bool()?; + if gr.blocksplit { + gr.block_type = br.read(2)? as u8; + gr.switch_point = br.read_bool()?; + for tsel in gr.table_select[..2].iter_mut() { + *tsel = br.read(5)? as u8; + match *tsel { + 4 | 14 => return Err(DecoderError::InvalidData), + _ => {}, + }; + } + for gain in gr.subblock_gain.iter_mut() { + *gain = br.read(3)? as u8; + } + gr.region_address1 = 7; + gr.region_address2 = 13; + } else { + gr.block_type = 0; + gr.switch_point = false; + for tsel in gr.table_select.iter_mut() { + *tsel = br.read(5)? as u8; + match *tsel { + 4 | 14 => return Err(DecoderError::InvalidData), + _ => {}, + }; + } + gr.region_address1 = br.read(4)? as u8; + gr.region_address2 = br.read(3)? as u8; + } + if self.mpeg1 { + gr.preflag = br.read_bool()?; + } else { + gr.preflag = false; + } + gr.scalefac_scale = br.read_bool()?; + gr.count1table_select = br.read_bool()? + } + } + Ok(()) + } + pub fn decode_mpeg1_layer3(&mut self, br: &mut BitReader, coeffs: &mut [[f32; SAMPLES]; 2], channels: usize) -> DecoderResult<()> { + let mut data_end = 0; + for gr_no in 0..2 { + for ch in 0..channels { + data_end += self.granule[gr_no][ch].part2_3_length; + + if self.granule[gr_no][ch].block_type != 2 { + if gr_no != 0 { + self.granule[1][ch].scalefac = self.granule[0][ch].scalefac; + } else { + for scf in self.granule[gr_no][ch].scalefac.iter_mut() { + *scf = 0; + } + } + + let gr = &mut self.granule[gr_no][ch]; + let bits1 = MP3_SCALEFAC_BITS1[gr.scalefac_compress]; + let bits2 = MP3_SCALEFAC_BITS2[gr.scalefac_compress]; + for cb in 0..11 { + if !self.scfsi[ch][SCFSI_FROM_BAND[cb]] || (gr_no == 0) { + gr.scalefac[cb] = br.read(bits1)? as u8; + } + } + for cb in 11..MP3_BANDS { + if !self.scfsi[ch][SCFSI_FROM_BAND[cb]] || (gr_no == 0) { + gr.scalefac[cb] = br.read(bits2)? as u8; + } + } + for is in gr.istereo.iter_mut() { + *is = 7; + } + } else { + let gr = &mut self.granule[gr_no][ch]; + let bits1 = MP3_SCALEFAC_BITS1[gr.scalefac_compress]; + let bits2 = MP3_SCALEFAC_BITS2[gr.scalefac_compress]; + let pivot = if gr.blocksplit && gr.switch_point { 17 } else { 18 }; + + for scf in gr.scalefac[..pivot].iter_mut() { + *scf = br.read(bits1)? as u8; + } + for scf in gr.scalefac[pivot..][..18].iter_mut() { + *scf = br.read(bits2)? as u8; + } + for is in gr.istereo.iter_mut() { + *is = 7; + } + } + self.read_mp3_coeffs(br, data_end, gr_no, ch, &mut coeffs[ch][gr_no * SAMPLES/2..])?; + validate!(br.tell() <= data_end); + br.seek(data_end as u32)?; + } + } + Ok(()) + } + pub fn decode_mpeg2_layer3(&mut self, br: &mut BitReader, coeffs: &mut [[f32; SAMPLES]; 2], channels: usize, mode_ext: u8) -> DecoderResult<()> { + let mut data_end = 0; + for ch in 0..channels { + let gr = &mut self.granule[0][ch]; + data_end += gr.part2_3_length; + + let mut bits = [0; 4]; + let idx = gr.get_mpeg2_params(&mut bits, (ch == 0) || ((mode_ext & IS_MODE) == 0)); + let idx2 = if gr.block_type != 2 { 0 } else if !gr.switch_point { 1 } else { 2 }; + + gr.preflag = idx == 2; + let ends = &MP3_SCF_ENDS[idx][idx2]; + + for (scf, is) in gr.scalefac[0..ends[0]].iter_mut().zip(gr.istereo[0..ends[0]].iter_mut()) { + *scf = br.read(bits[0])? as u8; + *is = (1 << bits[0]) - 1; + } + for (scf, is) in gr.scalefac[ends[0]..ends[1]].iter_mut().zip(gr.istereo[ends[0]..ends[1]].iter_mut()) { + *scf = br.read(bits[1])? as u8; + *is = (1 << bits[1]) - 1; + } + for (scf, is) in gr.scalefac[ends[1]..ends[2]].iter_mut().zip(gr.istereo[ends[1]..ends[2]].iter_mut()) { + *scf = br.read(bits[2])? as u8; + *is = (1 << bits[2]) - 1; + } + for (scf, is) in gr.scalefac[ends[2]..ends[3]].iter_mut().zip(gr.istereo[ends[2]..ends[3]].iter_mut()) { + *scf = br.read(bits[3])? as u8; + *is = (1 << bits[3]) - 1; + } + self.read_mp3_coeffs(br, data_end, 0, ch, &mut coeffs[ch])?; + validate!(br.tell() <= data_end); + br.seek(data_end as u32)?; + } + Ok(()) + } + pub fn synth(&mut self, coeffs: &mut [[f32; SAMPLES]; 2], output: &mut [[[f32; 32]; 36]; 2], mode: u8, mode_ext: u8) { + let channels = if mode == 3 { 1 } else { 2 }; + let granules = if self.mpeg1 { 2 } else { 1 }; + + let mut end_freq = [[0; 2]; 2]; + for gr_no in 0..granules { + for ch in 0..channels { + end_freq[gr_no][ch] = self.granule[gr_no][ch].lastcoded; + } + } + + let mut band_flags = [[0; MP3_MAX_BANDS + 3]; 2]; + let mut band_start = [[0; MP3_MAX_BANDS + 3]; 2]; + let mut band_end = [[0; MP3_MAX_BANDS + 3]; 2]; + + if mode == 1 { // joint stereo + let mut bound_band = [0; 2]; + let mut num_bands = [MP3_BANDS + 1; 2]; + + for (gr_no, grans) in self.granule[..granules].iter_mut().enumerate() { + if grans[1].block_type != 2 { + for band in 0..=MP3_BANDS { + band_flags[gr_no][band] = mode_ext; + band_start[gr_no][band] = MP3_SFB_LONG_OFFS[self.sf_idx][band]; + band_end [gr_no][band] = MP3_SFB_LONG_OFFS[self.sf_idx][band + 1]; + 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)]) { + band_flags[gr_no][band] &= !IS_MODE; + } + if band_start[gr_no][band] < end_freq[gr_no][1] { + bound_band[gr_no] = band; + } + if (band_flags[gr_no][band] & IS_MODE) == 0 { + for el in self.is_mode[gr_no * SAMPLES/2..][band_start[gr_no][band]..band_end[gr_no][band]].iter_mut() { + *el = -1; + } + } + } + } else { + let switch_off = if grans[1].switch_point { 3 } else { 0 }; + let mut start = 0; + let mut band = 0; + if grans[1].switch_point { + let long_bands = if self.mpeg1 { 8 } else { 6 }; + for _ in 0..long_bands { + band_flags[gr_no][band] = mode_ext; + band_start[gr_no][band] = MP3_SFB_LONG_OFFS[self.sf_idx][band]; + band_end [gr_no][band] = MP3_SFB_LONG_OFFS[self.sf_idx][band + 1]; + if end_freq[gr_no][1] >= band_end[gr_no][band] { + band_flags[gr_no][band] &= !IS_MODE; + } + start = band_end[gr_no][band]; + band += 1; + } + } + for sb in switch_off..=MP3_BANDS_SHORT { + let band_size = MP3_SFB_SHORT_SIZE[self.sf_idx][sb]; + for _win in 0..3 { + band_flags[gr_no][band] = mode_ext; + band_start[gr_no][band] = start; + band_end [gr_no][band] = start + band_size; + if end_freq[gr_no][1] >= band_end[gr_no][band] { + band_flags[gr_no][band] &= !IS_MODE; + } + start += band_size; + band += 1; + } + } + num_bands[gr_no] = band; + } + } + if (mode_ext & IS_MODE) != 0 { + for (gr_no, grans) in self.granule[..granules].iter_mut().enumerate() { + let (coef0, coef1) = coeffs.split_at_mut(1); + let coef0 = &mut coef0[0][gr_no * SAMPLES/2..]; + let coef1 = &mut coef1[0][gr_no * SAMPLES/2..]; + let is_mode = &self.is_mode[gr_no * SAMPLES/2..]; + let start = band_end[gr_no][bound_band[gr_no]]; + let end = grans[0].zero_part; + + if self.mpeg1 { + let coef0 = &mut coef0[start..end]; + let coef1 = &mut coef1[start..end]; + let is_mode = &self.is_mode[gr_no * SAMPLES/2..][start..end]; + for ((l, r), &is) in coef0.iter_mut().zip(coef1.iter_mut()).zip(is_mode.iter()) { + if is >= 0 && is < 7 { + let t = *l * MP3_ISTEREO_COEFFS[is as usize]; + *l -= t; + *r = t; + } + } + } else { + let iscale = (grans[1].scalefac_compress & 1) as u8; + for band in 0..num_bands[gr_no] { + if (band_flags[gr_no][band] & IS_MODE) != 0 { + apply_istereo(&mut coef0[start..end], &mut coef1[start..end], is_mode[start], iscale, (band_flags[gr_no][band] & MS_MODE) != 0); + } + } + } + end_freq[gr_no][1] = end_freq[gr_no][1].min(end); + } + } + if (mode_ext & MS_MODE) != 0 { + for (gr_no, grans) in self.granule[..granules].iter_mut().enumerate() { + let end = grans[0].zero_part.max(grans[1].zero_part); + let (coef0, coef1) = coeffs.split_at_mut(1); + let coef0 = &mut coef0[0][gr_no * SAMPLES/2..]; + let coef1 = &mut coef1[0][gr_no * SAMPLES/2..]; + for band in 0..num_bands[gr_no] { + if band_start[gr_no][band] >= end { + break; + } + if (band_flags[gr_no][band] & MS_MODE) != 0 { + let start = band_start[gr_no][band]; + let end = band_end[gr_no][band]; + super::apply_ms(&mut coef0[start..end], &mut coef1[start..end]); + } + } + end_freq[gr_no][0] = end; + end_freq[gr_no][1] = end; + } + } + } + for (gr_no, grans) in self.granule[..granules].iter_mut().enumerate() { + for (ch, gr) in grans[..channels].iter_mut().enumerate() { + let src = &mut coeffs[ch][gr_no * SAMPLES/2..][..SAMPLES/2]; + if gr.block_type != 2 { + dealias(src, SAMPLES/2); + self.mdct.mdct36(src, &mut self.tmp, &mut self.delay[ch], end_freq[gr_no][ch], gr.block_type); + } else { + let switch_off = if gr.switch_point { MP3_SFB_LONG_OFFS[self.sf_idx][if self.mpeg1 { 8 } else { 6 }] } else { 0 }; + let mut band_buf = [0.0; 66 * 3]; + let mut sb = if gr.switch_point { 3 } else { 0 }; + let mut off = switch_off; + + while sb < MP3_BANDS_SHORT { + let band_size = MP3_SFB_SHORT_SIZE[self.sf_idx][sb]; + for win in 0..3 { + for i in 0..band_size { + band_buf[win + i * 3] = src[off + win * band_size + i]; + } + } + src[off..][..band_size * 3].copy_from_slice(&band_buf[..band_size * 3]); + off += band_size * 3; + sb += 1; + } + if gr.switch_point { + dealias(src, switch_off); + self.mdct.mdct36(src, &mut self.tmp, &mut self.delay[ch], switch_off, gr.block_type); + } + self.mdct.mdct12(&src[switch_off..], &mut self.tmp[switch_off..], &mut self.delay[ch][switch_off..], end_freq[gr_no][ch] - switch_off); + } + + let dst = &mut output[ch][gr_no * 18..]; + let end = (end_freq[gr_no][ch] + 17) / 18; + for i in 0..end { + for j in 0..18 { + dst[j][i] = self.tmp[i * 18 + j]; + } + } + for i in end..32 { + for j in 0..18 { + dst[j][i] = self.delay[ch][i * 18 + j]; + } + for el in self.delay[ch][i * 18..][..18].iter_mut() { + *el = 0.0; + } + } + } + } + } +} + +fn mp3_unquant(val: u32, scale: i8) -> f32 { + (val as f32) * (val as f32).cbrt() * 2.0f32.powf((scale as f32) * 0.25) +} + +#[allow(clippy::too_many_arguments)] +fn read_region(br: &mut BitReader, br_end: usize, coeffs: &mut [f32], scales: &[i8; SAMPLES/2], start: usize, end: usize, cb: &Codebook, esc_bits: u8) -> DecoderResult { + let mut lastcoded = 0; + for (i, (cpair, scpair)) in coeffs[start..end].chunks_exact_mut(2).zip(scales[start..end].chunks_exact(2)).enumerate() { + if br.tell() >= br_end { break; } + let val = br.read_cb(cb)?; + if val == 0 { + continue; + } + let a = if (val >> 4) != 0xF || esc_bits == 0 { + u32::from(val >> 4) + } else { + br.read(esc_bits)? + 15 + }; + if a != 0 { + let a = mp3_unquant(a, scpair[0]); + cpair[0] = if br.read_bool()? { -a } else { a }; + } + let b = if (val & 0xF) != 0xF || esc_bits == 0 { + u32::from(val & 0xF) + } else { + br.read(esc_bits)? + 15 + }; + if b != 0 { + let b = mp3_unquant(b, scpair[1]); + cpair[1] = if br.read_bool()? { -b } else { b }; + } + lastcoded = start + (i + 1) * 2; + } + Ok(lastcoded) +} + +fn read_region_quad(br: &mut BitReader, br_end: usize, coeffs: &mut [f32], scales: &[i8; SAMPLES/2], start: usize, cb: Option<&Codebook>) -> DecoderResult<(usize, usize)> { + let mut lastcoded = 0; + let mut zero_part = 0; + if br.tell() >= br_end { + return Ok((0, 0)); + } + for (i, (cquad, scquad)) in coeffs[start..SAMPLES/2].chunks_exact_mut(4).zip(scales[start..].chunks_exact(4)).enumerate() { + zero_part = start + i * 4 + 4; + if br.tell() >= br_end { + break; + } + let val = if let Some(cbook) = cb { br.read_cb(cbook)? } else { (br.read(4)? as u8) ^ 0xF }; + if val == 0 { + continue; + } + for j in 0..4 { + if ((val >> (3 - j)) & 1) != 0 { + cquad[j] = mp3_unquant(1, scquad[j]); + if br.read_bool()? { + cquad[j] = -cquad[j]; + } + lastcoded = start + i * 4 + j + 1; + } + } + } + Ok((lastcoded, zero_part)) +} + +const DCT12_0: f32 = -0.92387953251128675613; +const DCT12_1: f32 = -0.38268343236508977174; + +const DCT12_2: f32 = -0.1305261922200516; +const DCT12_3: f32 = -0.6087614290087205; +const DCT12_4: f32 = 0.7933533402912348; +const DCT12_5: f32 = 0.9914448613738103; + +fn dct12(src: &[f32], dst: &mut [f32]) { + let t0 = src[0] - src[3] - src[4]; + let t1 = src[1] - src[2] - src[5]; + + dst[ 4] = t0 * DCT12_1 - t1 * DCT12_0; + dst[ 7] = t0 * DCT12_0 + t1 * DCT12_1; + dst[ 1] = -dst[4]; + dst[10] = -dst[7]; + + let t0 = src[1] * DCT12_1 - src[4] * DCT12_0; + let t1 = src[1] * DCT12_0 + src[4] * DCT12_1; + + dst[ 3] = src[0] * DCT12_2 + src[2] * DCT12_3 + src[3] * DCT12_4 + src[5] * DCT12_5 - t0; + dst[ 5] = src[0] * DCT12_3 - src[2] * DCT12_2 - src[3] * DCT12_5 + src[5] * DCT12_4 - t1; + dst[ 6] = -src[0] * DCT12_4 + src[2] * DCT12_5 - src[3] * DCT12_2 + src[5] * DCT12_3 - t0; + dst[ 8] = -src[0] * DCT12_5 - src[2] * DCT12_4 + src[3] * DCT12_3 + src[5] * DCT12_2 + t1; + dst[ 2] = -dst[3]; + dst[ 0] = -dst[5]; + dst[11] = dst[6]; + dst[ 9] = dst[8]; +} + +const DCT36_PRESCALE: [f32; 18] = [ + 0.99904822158185776240, 0.99144486137381041114, 0.97629600711993336597, + 0.95371695074822692114, 0.92387953251128675613, 0.88701083317822170105, + 0.84339144581288570127, 0.79335334029123516458, 0.73727733681012404139, + 0.67559020761566024435, 0.60876142900872063942, 0.53729960834682383185, + 0.46174861323503393057, 0.38268343236508977174, 0.30070579950427312163, + 0.21643961393810287977, 0.13052619222005159156, 0.04361938736533599979 +]; +const DCT36_TWIDDLE: [f32; 9] = [ + 0.99619469809174553229, 0.96592582628906828675, 0.90630778703664996324, + 0.81915204428899178969, 0.70710678118654752440, 0.57357643635104609611, + 0.42261826174069943619, 0.25881904510252076236, 0.08715574274765817357 +]; +const SDCT2_TWIDDLE: [f32; 7] = [ + -2.0 * 0.98480775301220805936, -2.0 * 0.86602540378443864676, + -2.0 * 0.76604444311897803520, -2.0 * 0.64278760968653932633, + -2.0 * 0.34202014332566873305, -2.0 * 0.17364817766693034887, + 2.0 * 0.93969262078590838404 +]; + +fn sdct_ii(buf: &mut [f32]) { + let t0 = buf[ 6] + buf[10]; + let t1 = buf[ 6] - buf[10]; + let t2 = buf[12] + buf[ 4]; + let t3 = buf[12] - buf[ 4]; + let t4 = buf[16] + buf[ 0]; + let t5 = buf[16] - buf[ 0]; + + let t6 = t0 + t2; + let t7 = (t0 - t2) * SDCT2_TWIDDLE[2]; + let t8 = (t1 + t3) * SDCT2_TWIDDLE[3]; + let t9 = t1 - t3; + let t0 = (t0 - t4) * SDCT2_TWIDDLE[5]; + let t1 = (t1 - t5) * SDCT2_TWIDDLE[0]; + let t2 = (t2 - t4) * SDCT2_TWIDDLE[6]; + let t3 = (t3 + t5) * SDCT2_TWIDDLE[4]; + + let ta = t6 + t4; + let tb = (t9 + t5) * SDCT2_TWIDDLE[1]; + + let tc = buf[2] + buf[14]; + let td = (buf[2] - buf[14]) * SDCT2_TWIDDLE[1]; + + let t6 = buf[8] + tc; + let t9 = buf[8] * 2.0 - tc; + let te = t9 + t2; + let tf = t9 - t2; + let t9 = t9 + t0; + + buf[ 0] = ta + t6; + buf[ 2] = t8 - td - t1; + buf[ 4] = t7 - te; + buf[ 6] = tb; + buf[ 8] = tf - t0; + buf[10] = td - t3 - t1; + buf[12] = ta - t6 * 2.0; + buf[14] = t8 + t3 + td; + buf[16] = t9 + t7; +} + +fn dct36(src: &mut [f32], dst: &mut [f32]) { + for (el, &w) in src.iter_mut().zip(DCT36_PRESCALE.iter()) { + *el *= w; + } + + let mut tmp = [0.0; 18]; + for i in 0..9 { + tmp[i * 2] = src[i] + src[17 - i]; + tmp[i * 2 + 1] = (src[i] - src[17 - i]) * DCT36_TWIDDLE[i] * 2.0; + } + sdct_ii(&mut tmp); + sdct_ii(&mut tmp[1..]); + + for i in (3..18).step_by(2) { + tmp[i] -= tmp[i - 2]; + } + tmp[0] *= 0.5; + for i in 1..18 { + tmp[i] = tmp[i] * 0.5 - tmp[i - 1]; + } + for i in 0..18 { + dst[i] = -tmp[17 - i] * 2.0; + } +} + +const ALIAS_COEFFS_S: [f32; 8] = [ + 0.85749292571254418689, 0.88174199731770518178, + 0.94962864910273289205, 0.98331459249179014599, + 0.99551781606758576429, 0.99916055817814750453, + 0.99989919524444704627, 0.99999315507028023572 +]; +const ALIAS_COEFFS_A: [f32; 8] = [ + -0.51449575542752651213, -0.47173196856497227225, + -0.31337745420390185437, -0.18191319961098117700, + -0.09457419252642064760, -0.04096558288530404768, + -0.01419856857247114805, -0.00369997467376003687 +]; +fn dealias(buf: &mut [f32], len: usize) { + for i in (18..len).step_by(18) { + for (j, (&cs, &ca)) in ALIAS_COEFFS_S.iter().zip(ALIAS_COEFFS_A.iter()).enumerate() { + let a = buf[i - j - 1]; + let b = buf[i + j]; + let c0 = a * cs - b * ca; + let c1 = a * ca + b * cs; + buf[i - j - 1] = c0; + buf[i + j] = c1; + } + } +} + +fn apply_istereo(ch0: &mut [f32], ch1: &mut [f32], is_mode: i8, iscale: u8, ms_mode: bool) { + match (is_mode, ms_mode) { + (-1, true) => { + for (c0, c1) in ch0.iter_mut().zip(ch1.iter_mut()) { + let a = (*c0 + *c1) * std::f32::consts::FRAC_1_SQRT_2; + let b = (*c0 - *c1) * std::f32::consts::FRAC_1_SQRT_2; + *c0 = a; + *c1 = b; + } + }, + (-1, false) => {}, + (0, _) => { + ch1.copy_from_slice(ch0); + }, + _ => { + let scale = mp3_unquant(1, -((is_mode + 1) >> 1) << iscale); + if (is_mode & 1) == 0 { + for (&c0, c1) in ch0.iter().zip(ch1.iter_mut()) { + *c1 = c0 * scale; + } + } else { + for (c0, c1) in ch0.iter_mut().zip(ch1.iter_mut()) { + *c1 = *c0; + *c0 *= scale; + } + } + }, + }; +} diff --git a/nihav-mpeg/src/codecs/mpegaudio/mp3data.rs b/nihav-mpeg/src/codecs/mpegaudio/mp3data.rs new file mode 100644 index 0000000..e7603e0 --- /dev/null +++ b/nihav-mpeg/src/codecs/mpegaudio/mp3data.rs @@ -0,0 +1,535 @@ +use nihav_core::io::codebook::*; + +pub const MP3_BANDS: usize = 21; +pub const MP3_BANDS_SHORT: usize = 12; + +pub const MP3_PREEMP_SCALES: [i8; MP3_BANDS + 1] = [ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 3, 3, 3, 2, 0 +]; + +pub const MP3_ISTEREO_COEFFS: [f32; 7] = [ + 1.0, 0.78867513459481288226, 0.63397459621556135323, 0.5, + 0.36602540378443864677, 0.21132486540518711774, 0.0 +]; + +pub const SCFSI_FROM_BAND: [usize; MP3_BANDS] = [ + 0, 0, 0, 0, 0, 0, + 1, 1, 1, 1, 1, + 2, 2, 2, 2, 2, + 3, 3, 3, 3, 3 +]; + +pub const MP3_SCALEFAC_BITS1: [u8; 16] = [ 0, 0, 0, 0, 3, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4 ]; +pub const MP3_SCALEFAC_BITS2: [u8; 16] = [ 0, 1, 2, 3, 0, 1, 2, 3, 1, 2, 3, 1, 2, 3, 2, 3 ]; + +pub const MP3_SFB_LONG_OFFS: [[usize; MP3_BANDS + 2]; 9] = [ + [ // 44.1 + 0, 4, 8, 12, 16, 20, 24, 30, 36, 44, 52, 62, 74, 90, 110, 134, 162, 196, 238, 288, 342, 418, 576 + ], [ // 48 + 0, 4, 8, 12, 16, 20, 24, 30, 36, 42, 50, 60, 72, 88, 106, 128, 156, 190, 230, 276, 330, 384, 576 + ], [ // 32 + 0, 4, 8, 12, 16, 20, 24, 30, 36, 44, 54, 66, 82, 102, 126, 156, 194, 240, 296, 364, 448, 550, 576 + ], [ // 22.05 + 0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 116, 140, 168, 200, 238, 284, 336, 396, 464, 522, 576 + ], [ // 24 + 0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 114, 136, 162, 194, 232, 278, 332, 394, 464, 540, 576 + ], [ // 16 + 0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 116, 140, 168, 200, 238, 284, 336, 396, 464, 522, 576 + ], [ // 11.025 + 0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 116, 140, 168, 200, 238, 284, 336, 396, 464, 522, 576 + ], [ // 12 + 0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 116, 140, 168, 200, 238, 284, 336, 396, 464, 522, 576 + ], [ // 8 + 0, 12, 24, 36, 48, 60, 72, 88, 108, 132, 160, 192, 232, 280, 336, 400, 476, 566, 568, 570, 572, 574, 576 + ] +]; + +pub const MP3_SFB_SHORT_OFFS: [[usize; MP3_BANDS_SHORT + 2]; 9] = [ + [ 0, 4, 8, 12, 16, 22, 30, 40, 52, 66, 84, 106, 136, 192 ], // 44.1 + [ 0, 4, 8, 12, 16, 22, 28, 38, 50, 64, 80, 100, 126, 192 ], // 48 + [ 0, 4, 8, 12, 16, 22, 30, 42, 58, 78, 104, 138, 180, 192 ], // 32 + [ 0, 4, 8, 12, 18, 24, 32, 42, 56, 74, 100, 132, 174, 192 ], // 22.05 + [ 0, 4, 8, 12, 18, 26, 36, 48, 62, 80, 104, 136, 180, 192 ], // 24 + [ 0, 4, 8, 12, 18, 26, 36, 48, 62, 80, 104, 134, 174, 192 ], // 16 + [ 0, 4, 8, 12, 18, 26, 36, 48, 62, 80, 104, 134, 174, 192 ], // 11.025 + [ 0, 4, 8, 12, 18, 26, 36, 48, 62, 80, 104, 134, 174, 192 ], // 12 + [ 0, 8, 16, 24, 36, 52, 72, 96, 124, 160, 162, 164, 166, 192 ], // 8 +]; +pub const MP3_SFB_SHORT_SIZE: [[usize; MP3_BANDS_SHORT + 1]; 9] = [ + [ 4, 4, 4, 4, 6, 8, 10, 12, 14, 18, 22, 30, 56 ], // 44.1 + [ 4, 4, 4, 4, 6, 6, 10, 12, 14, 16, 20, 26, 66 ], // 48 + [ 4, 4, 4, 4, 6, 8, 12, 16, 20, 26, 34, 42, 12 ], // 32 + [ 4, 4, 4, 6, 6, 8, 10, 14, 18, 26, 32, 42, 18 ], // 22.05 + [ 4, 4, 4, 6, 8, 10, 12, 14, 18, 24, 32, 44, 12 ], // 24 + [ 4, 4, 4, 6, 8, 10, 12, 14, 18, 24, 30, 40, 18 ], // 16 + [ 4, 4, 4, 6, 8, 10, 12, 14, 18, 24, 30, 40, 18 ], // 11.025 + [ 4, 4, 4, 6, 8, 10, 12, 14, 18, 24, 30, 40, 18 ], // 12 + [ 8, 8, 8, 12, 16, 20, 24, 28, 36, 2, 2, 2, 26 ], // 8 +]; + +pub const MP3_SCF_BITS3: [u8; 12 * 2] = [ + 0, 0, 0, 1, 0, 2, + 1, 0, 1, 1, 1, 2, + 2, 0, 2, 1, 2, 2, + 3, 0, 3, 1, 3, 2 +]; +pub const MP3_SCF_BITS5: [u8; 25 * 2] = [ + 0, 0, 0, 1, 0, 2, 0, 3, 0, 4, + 1, 0, 1, 1, 1, 2, 1, 3, 1, 4, + 2, 0, 2, 1, 2, 2, 2, 3, 2, 4, + 3, 0, 3, 1, 3, 2, 3, 3, 3, 4, + 4, 0, 4, 1, 4, 2, 4, 3, 4, 4 +]; +pub const MP3_SCF_BITS6: [u8; 180 * 3] = [ + 0, 0, 0, 0, 0, 1, 0, 0, 2, 0, 0, 3, 0, 0, 4, 0, 0, 5, + 0, 1, 0, 0, 1, 1, 0, 1, 2, 0, 1, 3, 0, 1, 4, 0, 1, 5, + 0, 2, 0, 0, 2, 1, 0, 2, 2, 0, 2, 3, 0, 2, 4, 0, 2, 5, + 0, 3, 0, 0, 3, 1, 0, 3, 2, 0, 3, 3, 0, 3, 4, 0, 3, 5, + 0, 4, 0, 0, 4, 1, 0, 4, 2, 0, 4, 3, 0, 4, 4, 0, 4, 5, + 0, 5, 0, 0, 5, 1, 0, 5, 2, 0, 5, 3, 0, 5, 4, 0, 5, 5, + 1, 0, 0, 1, 0, 1, 1, 0, 2, 1, 0, 3, 1, 0, 4, 1, 0, 5, + 1, 1, 0, 1, 1, 1, 1, 1, 2, 1, 1, 3, 1, 1, 4, 1, 1, 5, + 1, 2, 0, 1, 2, 1, 1, 2, 2, 1, 2, 3, 1, 2, 4, 1, 2, 5, + 1, 3, 0, 1, 3, 1, 1, 3, 2, 1, 3, 3, 1, 3, 4, 1, 3, 5, + 1, 4, 0, 1, 4, 1, 1, 4, 2, 1, 4, 3, 1, 4, 4, 1, 4, 5, + 1, 5, 0, 1, 5, 1, 1, 5, 2, 1, 5, 3, 1, 5, 4, 1, 5, 5, + 2, 0, 0, 2, 0, 1, 2, 0, 2, 2, 0, 3, 2, 0, 4, 2, 0, 5, + 2, 1, 0, 2, 1, 1, 2, 1, 2, 2, 1, 3, 2, 1, 4, 2, 1, 5, + 2, 2, 0, 2, 2, 1, 2, 2, 2, 2, 2, 3, 2, 2, 4, 2, 2, 5, + 2, 3, 0, 2, 3, 1, 2, 3, 2, 2, 3, 3, 2, 3, 4, 2, 3, 5, + 2, 4, 0, 2, 4, 1, 2, 4, 2, 2, 4, 3, 2, 4, 4, 2, 4, 5, + 2, 5, 0, 2, 5, 1, 2, 5, 2, 2, 5, 3, 2, 5, 4, 2, 5, 5, + 3, 0, 0, 3, 0, 1, 3, 0, 2, 3, 0, 3, 3, 0, 4, 3, 0, 5, + 3, 1, 0, 3, 1, 1, 3, 1, 2, 3, 1, 3, 3, 1, 4, 3, 1, 5, + 3, 2, 0, 3, 2, 1, 3, 2, 2, 3, 2, 3, 3, 2, 4, 3, 2, 5, + 3, 3, 0, 3, 3, 1, 3, 3, 2, 3, 3, 3, 3, 3, 4, 3, 3, 5, + 3, 4, 0, 3, 4, 1, 3, 4, 2, 3, 4, 3, 3, 4, 4, 3, 4, 5, + 3, 5, 0, 3, 5, 1, 3, 5, 2, 3, 5, 3, 3, 5, 4, 3, 5, 5, + 4, 0, 0, 4, 0, 1, 4, 0, 2, 4, 0, 3, 4, 0, 4, 4, 0, 5, + 4, 1, 0, 4, 1, 1, 4, 1, 2, 4, 1, 3, 4, 1, 4, 4, 1, 5, + 4, 2, 0, 4, 2, 1, 4, 2, 2, 4, 2, 3, 4, 2, 4, 4, 2, 5, + 4, 3, 0, 4, 3, 1, 4, 3, 2, 4, 3, 3, 4, 3, 4, 4, 3, 5, + 4, 4, 0, 4, 4, 1, 4, 4, 2, 4, 4, 3, 4, 4, 4, 4, 4, 5, + 4, 5, 0, 4, 5, 1, 4, 5, 2, 4, 5, 3, 4, 5, 4, 4, 5, 5 +]; + +pub const MP3_SCF_ENDS: [[[usize; 4]; 3]; 6] = [ + [ [ 6, 11, 16, 21 ], [ 9, 18, 27, 36 ], [ 6, 15, 27, 33 ] ], + [ [ 6, 11, 18, 21 ], [ 9, 18, 30, 36 ], [ 6, 15, 27, 33 ] ], + [ [ 11, 21, 21, 21 ], [ 18, 36, 36, 36 ], [ 15, 33, 33, 33 ] ], + [ [ 7, 14, 21, 21 ], [ 12, 24, 36, 36 ], [ 6, 21, 33, 33 ] ], + [ [ 6, 12, 18, 21 ], [ 12, 21, 30, 36 ], [ 6, 18, 27, 33 ] ], + [ [ 8, 16, 21, 21 ], [ 15, 27, 36, 36 ], [ 6, 24, 33, 33 ] ] +]; + +const MP3_HUFF_QUAD_A_BITS: [u8; 16] = [ 1, 5, 4, 5, 6, 5, 4, 4, 7, 3, 6, 0, 7, 2, 3, 1 ]; +const MP3_HUFF_QUAD_A_LENS: [u8; 16] = [ 1, 4, 4, 5, 4, 6, 5, 6, 4, 5, 5, 6, 5, 6, 6, 6 ]; + +const MP3_HUFF1_BITS: [u8; 4] = [ 1, 1, 1, 0 ]; +const MP3_HUFF1_LENS: [u8; 4] = [ 1, 3, 2, 3 ]; +const MP3_HUFF2_BITS: [u8; 9] = [ 1, 2, 1, 3, 1, 1, 3, 2, 0 ]; +const MP3_HUFF2_LENS: [u8; 9] = [ 1, 3, 6, 3, 3, 5, 5, 5, 6 ]; +const MP3_HUFF3_BITS: [u8; 9] = [ 3, 2, 1, 1, 1, 1, 3, 2, 0 ]; +const MP3_HUFF3_LENS: [u8; 9] = [ 2, 2, 6, 3, 2, 5, 5, 5, 6 ]; +const MP3_HUFF5_BITS: [u8; 16] = [ 1, 2, 6, 5, 3, 1, 4, 4, 7, 5, 7, 1, 6, 1, 1, 0 ]; +const MP3_HUFF5_LENS: [u8; 16] = [ 1, 3, 6, 7, 3, 3, 6, 7, 6, 6, 7, 8, 7, 6, 7, 8 ]; +const MP3_HUFF6_BITS: [u8; 16] = [ 7, 3, 5, 1, 6, 2, 3, 2, 5, 4, 4, 1, 3, 3, 2, 0 ]; +const MP3_HUFF6_LENS: [u8; 16] = [ 3, 3, 5, 7, 3, 2, 4, 5, 4, 4, 5, 6, 6, 5, 6, 7 ]; +const MP3_HUFF7_BITS: [u8; 36] = [ + 0x01, 0x02, 0x0A, 0x13, 0x10, 0x0A, 0x03, 0x03, + 0x07, 0x0A, 0x05, 0x03, 0x0B, 0x04, 0x0D, 0x11, + 0x08, 0x04, 0x0C, 0x0B, 0x12, 0x0F, 0x0B, 0x02, + 0x07, 0x06, 0x09, 0x0E, 0x03, 0x01, 0x06, 0x04, + 0x05, 0x03, 0x02, 0x00 +]; +const MP3_HUFF7_LENS: [u8; 36] = [ + 1, 3, 6, 8, 8, 9, 3, 4, 6, 7, 7, 8, 6, 5, 7, 8, + 8, 9, 7, 7, 8, 9, 9, 9, 7, 7, 8, 9, 9, 10, 8, 8, + 9, 10, 10, 10 +]; +const MP3_HUFF8_BITS: [u8; 36] = [ + 0x03, 0x04, 0x06, 0x12, 0x0C, 0x05, 0x05, 0x01, + 0x02, 0x10, 0x09, 0x03, 0x07, 0x03, 0x05, 0x0E, + 0x07, 0x03, 0x13, 0x11, 0x0F, 0x0D, 0x0A, 0x04, + 0x0D, 0x05, 0x08, 0x0B, 0x05, 0x01, 0x0C, 0x04, + 0x04, 0x01, 0x01, 0x00 +]; +const MP3_HUFF8_LENS: [u8; 36] = [ + 2, 3, 6, 8, 8, 9, 3, 2, 4, 8, 8, 8, 6, 4, 6, 8, + 8, 9, 8, 8, 8, 9, 9, 10, 8, 7, 8, 9, 10, 10, 9, 8, + 9, 9, 11, 11 +]; +const MP3_HUFF9_BITS: [u8; 36] = [ + 0x07, 0x05, 0x09, 0x0E, 0x0F, 0x07, 0x06, 0x04, + 0x05, 0x05, 0x06, 0x07, 0x07, 0x06, 0x08, 0x08, + 0x08, 0x05, 0x0F, 0x06, 0x09, 0x0A, 0x05, 0x01, + 0x0B, 0x07, 0x09, 0x06, 0x04, 0x01, 0x0E, 0x04, + 0x06, 0x02, 0x06, 0x00 +]; +const MP3_HUFF9_LENS: [u8; 36] = [ + 3, 3, 5, 6, 8, 9, 3, 3, 4, 5, 6, 8, 4, 4, 5, 6, + 7, 8, 6, 5, 6, 7, 7, 8, 7, 6, 7, 7, 8, 9, 8, 7, + 8, 8, 9, 9 +]; +const MP3_HUFF10_BITS: [u8; 64] = [ + 0x01, 0x02, 0x0A, 0x17, 0x23, 0x1E, 0x0C, 0x11, + 0x03, 0x03, 0x08, 0x0C, 0x12, 0x15, 0x0C, 0x07, + 0x0B, 0x09, 0x0F, 0x15, 0x20, 0x28, 0x13, 0x06, + 0x0E, 0x0D, 0x16, 0x22, 0x2E, 0x17, 0x12, 0x07, + 0x14, 0x13, 0x21, 0x2F, 0x1B, 0x16, 0x09, 0x03, + 0x1F, 0x16, 0x29, 0x1A, 0x15, 0x14, 0x05, 0x03, + 0x0E, 0x0D, 0x0A, 0x0B, 0x10, 0x06, 0x05, 0x01, + 0x09, 0x08, 0x07, 0x08, 0x04, 0x04, 0x02, 0x00 +]; +const MP3_HUFF10_LENS: [u8; 64] = [ + 1, 3, 6, 8, 9, 9, 9, 10, 3, 4, 6, 7, 8, 9, 8, 8, + 6, 6, 7, 8, 9, 10, 9, 9, 7, 7, 8, 9, 10, 10, 9, 10, + 8, 8, 9, 10, 10, 10, 10, 10, 9, 9, 10, 10, 11, 11, 10, 11, + 8, 8, 9, 10, 10, 10, 11, 11, 9, 8, 9, 10, 10, 11, 11, 11 +]; +const MP3_HUFF11_BITS: [u8; 64] = [ + 0x03, 0x04, 0x0A, 0x18, 0x22, 0x21, 0x15, 0x0F, + 0x05, 0x03, 0x04, 0x0A, 0x20, 0x11, 0x0B, 0x0A, + 0x0B, 0x07, 0x0D, 0x12, 0x1E, 0x1F, 0x14, 0x05, + 0x19, 0x0B, 0x13, 0x3B, 0x1B, 0x12, 0x0C, 0x05, + 0x23, 0x21, 0x1F, 0x3A, 0x1E, 0x10, 0x07, 0x05, + 0x1C, 0x1A, 0x20, 0x13, 0x11, 0x0F, 0x08, 0x0E, + 0x0E, 0x0C, 0x09, 0x0D, 0x0E, 0x09, 0x04, 0x01, + 0x0B, 0x04, 0x06, 0x06, 0x06, 0x03, 0x02, 0x00 +]; +const MP3_HUFF11_LENS: [u8; 64] = [ + 2, 3, 5, 7, 8, 9, 8, 9, 3, 3, 4, 6, 8, 8, 7, 8, + 5, 5, 6, 7, 8, 9, 8, 8, 7, 6, 7, 9, 8, 10, 8, 9, + 8, 8, 8, 9, 9, 10, 9, 10, 8, 8, 9, 10, 10, 11, 10, 11, + 8, 7, 7, 8, 9, 10, 10, 10, 8, 7, 8, 9, 10, 10, 10, 10 +]; +const MP3_HUFF12_BITS: [u8; 64] = [ + 0x09, 0x06, 0x10, 0x21, 0x29, 0x27, 0x26, 0x1A, + 0x07, 0x05, 0x06, 0x09, 0x17, 0x10, 0x1A, 0x0B, + 0x11, 0x07, 0x0B, 0x0E, 0x15, 0x1E, 0x0A, 0x07, + 0x11, 0x0A, 0x0F, 0x0C, 0x12, 0x1C, 0x0E, 0x05, + 0x20, 0x0D, 0x16, 0x13, 0x12, 0x10, 0x09, 0x05, + 0x28, 0x11, 0x1F, 0x1D, 0x11, 0x0D, 0x04, 0x02, + 0x1B, 0x0C, 0x0B, 0x0F, 0x0A, 0x07, 0x04, 0x01, + 0x1B, 0x0C, 0x08, 0x0C, 0x06, 0x03, 0x01, 0x00 +]; +const MP3_HUFF12_LENS: [u8; 64] = [ + 4, 3, 5, 7, 8, 9, 9, 9, 3, 3, 4, 5, 7, 7, 8, 8, + 5, 4, 5, 6, 7, 8, 7, 8, 6, 5, 6, 6, 7, 8, 8, 8, + 7, 6, 7, 7, 8, 8, 8, 9, 8, 7, 8, 8, 8, 9, 8, 9, + 8, 7, 7, 8, 8, 9, 9, 10, 9, 8, 8, 9, 9, 9, 9, 10 +]; +const MP3_HUFF13_BITS: [u8; 256] = [ + 0x01, 0x05, 0x0E, 0x15, 0x22, 0x33, 0x2E, 0x47, + 0x2A, 0x34, 0x44, 0x34, 0x43, 0x2C, 0x2B, 0x13, + 0x03, 0x04, 0x0C, 0x13, 0x1F, 0x1A, 0x2C, 0x21, + 0x1F, 0x18, 0x20, 0x18, 0x1F, 0x23, 0x16, 0x0E, + 0x0F, 0x0D, 0x17, 0x24, 0x3B, 0x31, 0x4D, 0x41, + 0x1D, 0x28, 0x1E, 0x28, 0x1B, 0x21, 0x2A, 0x10, + 0x16, 0x14, 0x25, 0x3D, 0x38, 0x4F, 0x49, 0x40, + 0x2B, 0x4C, 0x38, 0x25, 0x1A, 0x1F, 0x19, 0x0E, + 0x23, 0x10, 0x3C, 0x39, 0x61, 0x4B, 0x72, 0x5B, + 0x36, 0x49, 0x37, 0x29, 0x30, 0x35, 0x17, 0x18, + 0x3A, 0x1B, 0x32, 0x60, 0x4C, 0x46, 0x5D, 0x54, + 0x4D, 0x3A, 0x4F, 0x1D, 0x4A, 0x31, 0x29, 0x11, + 0x2F, 0x2D, 0x4E, 0x4A, 0x73, 0x5E, 0x5A, 0x4F, + 0x45, 0x53, 0x47, 0x32, 0x3B, 0x26, 0x24, 0x0F, + 0x48, 0x22, 0x38, 0x5F, 0x5C, 0x55, 0x5B, 0x5A, + 0x56, 0x49, 0x4D, 0x41, 0x33, 0x2C, 0x2B, 0x2A, + 0x2B, 0x14, 0x1E, 0x2C, 0x37, 0x4E, 0x48, 0x57, + 0x4E, 0x3D, 0x2E, 0x36, 0x25, 0x1E, 0x14, 0x10, + 0x35, 0x19, 0x29, 0x25, 0x2C, 0x3B, 0x36, 0x51, + 0x42, 0x4C, 0x39, 0x36, 0x25, 0x12, 0x27, 0x0B, + 0x23, 0x21, 0x1F, 0x39, 0x2A, 0x52, 0x48, 0x50, + 0x2F, 0x3A, 0x37, 0x15, 0x16, 0x1A, 0x26, 0x16, + 0x35, 0x19, 0x17, 0x26, 0x46, 0x3C, 0x33, 0x24, + 0x37, 0x1A, 0x22, 0x17, 0x1B, 0x0E, 0x09, 0x07, + 0x22, 0x20, 0x1C, 0x27, 0x31, 0x4B, 0x1E, 0x34, + 0x30, 0x28, 0x34, 0x1C, 0x12, 0x11, 0x09, 0x05, + 0x2D, 0x15, 0x22, 0x40, 0x38, 0x32, 0x31, 0x2D, + 0x1F, 0x13, 0x0C, 0x0F, 0x0A, 0x07, 0x06, 0x03, + 0x30, 0x17, 0x14, 0x27, 0x24, 0x23, 0x35, 0x15, + 0x10, 0x17, 0x0D, 0x0A, 0x06, 0x01, 0x04, 0x02, + 0x10, 0x0F, 0x11, 0x1B, 0x19, 0x14, 0x1D, 0x0B, + 0x11, 0x0C, 0x10, 0x08, 0x01, 0x01, 0x00, 0x01 +]; +const MP3_HUFF13_LENS: [u8; 256] = [ + 1, 4, 6, 7, 8, 9, 9, 10, 9, 10, 11, 11, 12, 12, 13, 13, + 3, 4, 6, 7, 8, 8, 9, 9, 9, 9, 10, 10, 11, 12, 12, 12, + 6, 6, 7, 8, 9, 9, 10, 10, 9, 10, 10, 11, 11, 12, 13, 13, + 7, 7, 8, 9, 9, 10, 10, 10, 10, 11, 11, 11, 11, 12, 13, 13, + 8, 7, 9, 9, 10, 10, 11, 11, 10, 11, 11, 12, 12, 13, 13, 14, + 9, 8, 9, 10, 10, 10, 11, 11, 11, 11, 12, 11, 13, 13, 14, 14, + 9, 9, 10, 10, 11, 11, 11, 11, 11, 12, 12, 12, 13, 13, 14, 14, + 10, 9, 10, 11, 11, 11, 12, 12, 12, 12, 13, 13, 13, 14, 16, 16, + 9, 8, 9, 10, 10, 11, 11, 12, 12, 12, 12, 13, 13, 14, 15, 15, + 10, 9, 10, 10, 11, 11, 11, 13, 12, 13, 13, 14, 14, 14, 16, 15, + 10, 10, 10, 11, 11, 12, 12, 13, 12, 13, 14, 13, 14, 15, 16, 17, + 11, 10, 10, 11, 12, 12, 12, 12, 13, 13, 13, 14, 15, 15, 15, 16, + 11, 11, 11, 12, 12, 13, 12, 13, 14, 14, 15, 15, 15, 16, 16, 16, + 12, 11, 12, 13, 13, 13, 14, 14, 14, 14, 14, 15, 16, 15, 16, 16, + 13, 12, 12, 13, 13, 13, 15, 14, 14, 17, 15, 15, 15, 17, 16, 16, + 12, 12, 13, 14, 14, 14, 15, 14, 15, 15, 16, 16, 19, 18, 19, 16 +]; +const MP3_HUFF15_BITS: [u8; 256] = [ + 0x07, 0x0C, 0x12, 0x35, 0x2F, 0x4C, 0x7C, 0x6C, + 0x59, 0x7B, 0x6C, 0x77, 0x6B, 0x51, 0x7A, 0x3F, + 0x0D, 0x05, 0x10, 0x1B, 0x2E, 0x24, 0x3D, 0x33, + 0x2A, 0x46, 0x34, 0x53, 0x41, 0x29, 0x3B, 0x24, + 0x13, 0x11, 0x0F, 0x18, 0x29, 0x22, 0x3B, 0x30, + 0x28, 0x40, 0x32, 0x4E, 0x3E, 0x50, 0x38, 0x21, + 0x1D, 0x1C, 0x19, 0x2B, 0x27, 0x3F, 0x37, 0x5D, + 0x4C, 0x3B, 0x5D, 0x48, 0x36, 0x4B, 0x32, 0x1D, + 0x34, 0x16, 0x2A, 0x28, 0x43, 0x39, 0x5F, 0x4F, + 0x48, 0x39, 0x59, 0x45, 0x31, 0x42, 0x2E, 0x1B, + 0x4D, 0x25, 0x23, 0x42, 0x3A, 0x34, 0x5B, 0x4A, + 0x3E, 0x30, 0x4F, 0x3F, 0x5A, 0x3E, 0x28, 0x26, + 0x7D, 0x20, 0x3C, 0x38, 0x32, 0x5C, 0x4E, 0x41, + 0x37, 0x57, 0x47, 0x33, 0x49, 0x33, 0x46, 0x1E, + 0x6D, 0x35, 0x31, 0x5E, 0x58, 0x4B, 0x42, 0x7A, + 0x5B, 0x49, 0x38, 0x2A, 0x40, 0x2C, 0x15, 0x19, + 0x5A, 0x2B, 0x29, 0x4D, 0x49, 0x3F, 0x38, 0x5C, + 0x4D, 0x42, 0x2F, 0x43, 0x30, 0x35, 0x24, 0x14, + 0x47, 0x22, 0x43, 0x3C, 0x3A, 0x31, 0x58, 0x4C, + 0x43, 0x6A, 0x47, 0x36, 0x26, 0x27, 0x17, 0x0F, + 0x6D, 0x35, 0x33, 0x2F, 0x5A, 0x52, 0x3A, 0x39, + 0x30, 0x48, 0x39, 0x29, 0x17, 0x1B, 0x3E, 0x09, + 0x56, 0x2A, 0x28, 0x25, 0x46, 0x40, 0x34, 0x2B, + 0x46, 0x37, 0x2A, 0x19, 0x1D, 0x12, 0x0B, 0x0B, + 0x76, 0x44, 0x1E, 0x37, 0x32, 0x2E, 0x4A, 0x41, + 0x31, 0x27, 0x18, 0x10, 0x16, 0x0D, 0x0E, 0x07, + 0x5B, 0x2C, 0x27, 0x26, 0x22, 0x3F, 0x34, 0x2D, + 0x1F, 0x34, 0x1C, 0x13, 0x0E, 0x08, 0x09, 0x03, + 0x7B, 0x3C, 0x3A, 0x35, 0x2F, 0x2B, 0x20, 0x16, + 0x25, 0x18, 0x11, 0x0C, 0x0F, 0x0A, 0x02, 0x01, + 0x47, 0x25, 0x22, 0x1E, 0x1C, 0x14, 0x11, 0x1A, + 0x15, 0x10, 0x0A, 0x06, 0x08, 0x06, 0x02, 0x00 +]; +const MP3_HUFF15_LENS: [u8; 256] = [ + 3, 4, 5, 7, 7, 8, 9, 9, 9, 10, 10, 11, 11, 11, 12, 13, + 4, 3, 5, 6, 7, 7, 8, 8, 8, 9, 9, 10, 10, 10, 11, 11, + 5, 5, 5, 6, 7, 7, 8, 8, 8, 9, 9, 10, 10, 11, 11, 11, + 6, 6, 6, 7, 7, 8, 8, 9, 9, 9, 10, 10, 10, 11, 11, 11, + 7, 6, 7, 7, 8, 8, 9, 9, 9, 9, 10, 10, 10, 11, 11, 11, + 8, 7, 7, 8, 8, 8, 9, 9, 9, 9, 10, 10, 11, 11, 11, 12, + 9, 7, 8, 8, 8, 9, 9, 9, 9, 10, 10, 10, 11, 11, 12, 12, + 9, 8, 8, 9, 9, 9, 9, 10, 10, 10, 10, 10, 11, 11, 11, 12, + 9, 8, 8, 9, 9, 9, 9, 10, 10, 10, 10, 11, 11, 12, 12, 12, + 9, 8, 9, 9, 9, 9, 10, 10, 10, 11, 11, 11, 11, 12, 12, 12, + 10, 9, 9, 9, 10, 10, 10, 10, 10, 11, 11, 11, 11, 12, 13, 12, + 10, 9, 9, 9, 10, 10, 10, 10, 11, 11, 11, 11, 12, 12, 12, 13, + 11, 10, 9, 10, 10, 10, 11, 11, 11, 11, 11, 11, 12, 12, 13, 13, + 11, 10, 10, 10, 10, 11, 11, 11, 11, 12, 12, 12, 12, 12, 13, 13, + 12, 11, 11, 11, 11, 11, 11, 11, 12, 12, 12, 12, 13, 13, 12, 13, + 12, 11, 11, 11, 11, 11, 11, 12, 12, 12, 12, 12, 13, 13, 13, 13 +]; +const MP3_HUFF16_BITS: [u16; 256] = [ + 0x001, 0x005, 0x00E, 0x02C, 0x04A, 0x03F, 0x06E, 0x05D, + 0x0AC, 0x095, 0x08A, 0x0F2, 0x0E1, 0x0C3, 0x178, 0x011, + 0x003, 0x004, 0x00C, 0x014, 0x023, 0x03E, 0x035, 0x02F, + 0x053, 0x04B, 0x044, 0x077, 0x0C9, 0x06B, 0x0CF, 0x009, + 0x00F, 0x00D, 0x017, 0x026, 0x043, 0x03A, 0x067, 0x05A, + 0x0A1, 0x048, 0x07F, 0x075, 0x06E, 0x0D1, 0x0CE, 0x010, + 0x02D, 0x015, 0x027, 0x045, 0x040, 0x072, 0x063, 0x057, + 0x09E, 0x08C, 0x0FC, 0x0D4, 0x0C7, 0x183, 0x16D, 0x01A, + 0x04B, 0x024, 0x044, 0x041, 0x073, 0x065, 0x0B3, 0x0A4, + 0x09B, 0x108, 0x0F6, 0x0E2, 0x18B, 0x17E, 0x16A, 0x009, + 0x042, 0x01E, 0x03B, 0x038, 0x066, 0x0B9, 0x0AD, 0x109, + 0x08E, 0x0FD, 0x0E8, 0x190, 0x184, 0x17A, 0x1BD, 0x010, + 0x06F, 0x036, 0x034, 0x064, 0x0B8, 0x0B2, 0x0A0, 0x085, + 0x101, 0x0F4, 0x0E4, 0x0D9, 0x181, 0x16E, 0x2CB, 0x00A, + 0x062, 0x030, 0x05B, 0x058, 0x0A5, 0x09D, 0x094, 0x105, + 0x0F8, 0x197, 0x18D, 0x174, 0x17C, 0x379, 0x374, 0x008, + 0x055, 0x054, 0x051, 0x09F, 0x09C, 0x08F, 0x104, 0x0F9, + 0x1AB, 0x191, 0x188, 0x17F, 0x2D7, 0x2C9, 0x2C4, 0x007, + 0x09A, 0x04C, 0x049, 0x08D, 0x083, 0x100, 0x0F5, 0x1AA, + 0x196, 0x18A, 0x180, 0x2DF, 0x167, 0x2C6, 0x160, 0x00B, + 0x08B, 0x081, 0x043, 0x07D, 0x0F7, 0x0E9, 0x0E5, 0x0DB, + 0x189, 0x2E7, 0x2E1, 0x2D0, 0x375, 0x372, 0x1B7, 0x004, + 0x0F3, 0x078, 0x076, 0x073, 0x0E3, 0x0DF, 0x18C, 0x2EA, + 0x2E6, 0x2E0, 0x2D1, 0x2C8, 0x2C2, 0x0DF, 0x1B4, 0x006, + 0x0CA, 0x0E0, 0x0DE, 0x0DA, 0x0D8, 0x185, 0x182, 0x17D, + 0x16C, 0x378, 0x1BB, 0x2C3, 0x1B8, 0x1B5, 0x6C0, 0x004, + 0x2EB, 0x0D3, 0x0D2, 0x0D0, 0x172, 0x17B, 0x2DE, 0x2D3, + 0x2CA, 0x6C7, 0x373, 0x36D, 0x36C, 0xD83, 0x361, 0x002, + 0x179, 0x171, 0x066, 0x0BB, 0x2D6, 0x2D2, 0x166, 0x2C7, + 0x2C5, 0x362, 0x6C6, 0x367, 0xD82, 0x366, 0x1B2, 0x000, + 0x00C, 0x00A, 0x007, 0x00B, 0x00A, 0x011, 0x00B, 0x009, + 0x00D, 0x00C, 0x00A, 0x007, 0x005, 0x003, 0x001, 0x003 +]; +const MP3_HUFF16_LENS: [u8; 256] = [ + 1, 4, 6, 8, 9, 9, 10, 10, 11, 11, 11, 12, 12, 12, 13, 9, + 3, 4, 6, 7, 8, 9, 9, 9, 10, 10, 10, 11, 12, 11, 12, 8, + 6, 6, 7, 8, 9, 9, 10, 10, 11, 10, 11, 11, 11, 12, 12, 9, + 8, 7, 8, 9, 9, 10, 10, 10, 11, 11, 12, 12, 12, 13, 13, 10, + 9, 8, 9, 9, 10, 10, 11, 11, 11, 12, 12, 12, 13, 13, 13, 9, + 9, 8, 9, 9, 10, 11, 11, 12, 11, 12, 12, 13, 13, 13, 14, 10, + 10, 9, 9, 10, 11, 11, 11, 11, 12, 12, 12, 12, 13, 13, 14, 10, + 10, 9, 10, 10, 11, 11, 11, 12, 12, 13, 13, 13, 13, 15, 15, 10, + 10, 10, 10, 11, 11, 11, 12, 12, 13, 13, 13, 13, 14, 14, 14, 10, + 11, 10, 10, 11, 11, 12, 12, 13, 13, 13, 13, 14, 13, 14, 13, 11, + 11, 11, 10, 11, 12, 12, 12, 12, 13, 14, 14, 14, 15, 15, 14, 10, + 12, 11, 11, 11, 12, 12, 13, 14, 14, 14, 14, 14, 14, 13, 14, 11, + 12, 12, 12, 12, 12, 13, 13, 13, 13, 15, 14, 14, 14, 14, 16, 11, + 14, 12, 12, 12, 13, 13, 14, 14, 14, 16, 15, 15, 15, 17, 15, 11, + 13, 13, 11, 12, 14, 14, 13, 14, 14, 15, 16, 15, 17, 15, 14, 11, + 9, 8, 8, 9, 9, 10, 10, 10, 11, 11, 11, 11, 11, 11, 11, 8 +]; +const MP3_HUFF24_BITS: [u16; 256] = [ + 0x00F, 0x00D, 0x02E, 0x050, 0x092, 0x106, 0x0F8, 0x1B2, + 0x1AA, 0x29D, 0x28D, 0x289, 0x26D, 0x205, 0x408, 0x058, + 0x00E, 0x00C, 0x015, 0x026, 0x047, 0x082, 0x07A, 0x0D8, + 0x0D1, 0x0C6, 0x147, 0x159, 0x13F, 0x129, 0x117, 0x02A, + 0x02F, 0x016, 0x029, 0x04A, 0x044, 0x080, 0x078, 0x0DD, + 0x0CF, 0x0C2, 0x0B6, 0x154, 0x13B, 0x127, 0x21D, 0x012, + 0x051, 0x027, 0x04B, 0x046, 0x086, 0x07D, 0x074, 0x0DC, + 0x0CC, 0x0BE, 0x0B2, 0x145, 0x137, 0x125, 0x10F, 0x010, + 0x093, 0x048, 0x045, 0x087, 0x07F, 0x076, 0x070, 0x0D2, + 0x0C8, 0x0BC, 0x160, 0x143, 0x132, 0x11D, 0x21C, 0x00E, + 0x107, 0x042, 0x081, 0x07E, 0x077, 0x072, 0x0D6, 0x0CA, + 0x0C0, 0x0B4, 0x155, 0x13D, 0x12D, 0x119, 0x106, 0x00C, + 0x0F9, 0x07B, 0x079, 0x075, 0x071, 0x0D7, 0x0CE, 0x0C3, + 0x0B9, 0x15B, 0x14A, 0x134, 0x123, 0x110, 0x208, 0x00A, + 0x1B3, 0x073, 0x06F, 0x06D, 0x0D3, 0x0CB, 0x0C4, 0x0BB, + 0x161, 0x14C, 0x139, 0x12A, 0x11B, 0x213, 0x17D, 0x011, + 0x1AB, 0x0D4, 0x0D0, 0x0CD, 0x0C9, 0x0C1, 0x0BA, 0x0B1, + 0x0A9, 0x140, 0x12F, 0x11E, 0x10C, 0x202, 0x179, 0x010, + 0x14F, 0x0C7, 0x0C5, 0x0BF, 0x0BD, 0x0B5, 0x0AE, 0x14D, + 0x141, 0x131, 0x121, 0x113, 0x209, 0x17B, 0x173, 0x00B, + 0x29C, 0x0B8, 0x0B7, 0x0B3, 0x0AF, 0x158, 0x14B, 0x13A, + 0x130, 0x122, 0x115, 0x212, 0x17F, 0x175, 0x16E, 0x00A, + 0x28C, 0x15A, 0x0AB, 0x0A8, 0x0A4, 0x13E, 0x135, 0x12B, + 0x11F, 0x114, 0x107, 0x201, 0x177, 0x170, 0x16A, 0x006, + 0x288, 0x142, 0x13C, 0x138, 0x133, 0x12E, 0x124, 0x11C, + 0x10D, 0x105, 0x200, 0x178, 0x172, 0x16C, 0x167, 0x004, + 0x26C, 0x12C, 0x128, 0x126, 0x120, 0x11A, 0x111, 0x10A, + 0x203, 0x17C, 0x176, 0x171, 0x16D, 0x169, 0x165, 0x002, + 0x409, 0x118, 0x116, 0x112, 0x10B, 0x108, 0x103, 0x17E, + 0x17A, 0x174, 0x16F, 0x16B, 0x168, 0x166, 0x164, 0x000, + 0x02B, 0x014, 0x013, 0x011, 0x00F, 0x00D, 0x00B, 0x009, + 0x007, 0x006, 0x004, 0x007, 0x005, 0x003, 0x001, 0x003 +]; +const MP3_HUFF24_LENS: [u8; 256] = [ + 4, 4, 6, 7, 8, 9, 9, 10, 10, 11, 11, 11, 11, 11, 12, 9, + 4, 4, 5, 6, 7, 8, 8, 9, 9, 9, 10, 10, 10, 10, 10, 8, + 6, 5, 6, 7, 7, 8, 8, 9, 9, 9, 9, 10, 10, 10, 11, 7, + 7, 6, 7, 7, 8, 8, 8, 9, 9, 9, 9, 10, 10, 10, 10, 7, + 8, 7, 7, 8, 8, 8, 8, 9, 9, 9, 10, 10, 10, 10, 11, 7, + 9, 7, 8, 8, 8, 8, 9, 9, 9, 9, 10, 10, 10, 10, 10, 7, + 9, 8, 8, 8, 8, 9, 9, 9, 9, 10, 10, 10, 10, 10, 11, 7, + 10, 8, 8, 8, 9, 9, 9, 9, 10, 10, 10, 10, 10, 11, 11, 8, + 10, 9, 9, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10, 11, 11, 8, + 10, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10, 10, 11, 11, 11, 8, + 11, 9, 9, 9, 9, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 8, + 11, 10, 9, 9, 9, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 8, + 11, 10, 10, 10, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 8, + 11, 10, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11, 11, 8, + 12, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11, 11, 11, 8, + 8, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 4 +]; + +const MP3_HUFF_SYMS2: [u8; 4] = [ 0x00, 0x01, 0x10, 0x11 ]; +const MP3_HUFF_SYMS3: [u8; 9] = [ 0x00, 0x01, 0x02, 0x10, 0x11, 0x12, 0x20, 0x21, 0x22 ]; +const MP3_HUFF_SYMS4: [u8; 16] = [ + 0x00, 0x01, 0x02, 0x03, + 0x10, 0x11, 0x12, 0x13, + 0x20, 0x21, 0x22, 0x23, + 0x30, 0x31, 0x32, 0x33 +]; +const MP3_HUFF_SYMS6: [u8; 36] = [ + 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, + 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, + 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, + 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, + 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, + 0x50, 0x51, 0x52, 0x53, 0x54, 0x55 +]; +const MP3_HUFF_SYMS8: [u8; 64] = [ + 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, + 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, + 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, + 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, + 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, + 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, + 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, + 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77 +]; + +pub struct MP3Codebooks { + pub quad_cb: Codebook, + pub cb: [Codebook; 15], +} + +fn map_cb2(idx: usize) -> u8 { MP3_HUFF_SYMS2[idx] } +fn map_cb3(idx: usize) -> u8 { MP3_HUFF_SYMS3[idx] } +fn map_cb4(idx: usize) -> u8 { MP3_HUFF_SYMS4[idx] } +fn map_cb6(idx: usize) -> u8 { MP3_HUFF_SYMS6[idx] } +fn map_cb8(idx: usize) -> u8 { MP3_HUFF_SYMS8[idx] } +fn map_cb16(idx: usize) -> u8 { idx as u8 } + +macro_rules! init_cb { + ($bits: ident, $lens: ident, $map_cb: ident) => ({ + let mut cbr = TableCodebookDescReader::new(&$bits, &$lens, $map_cb); + Codebook::new(&mut cbr, CodebookMode::MSB).unwrap() + }) +} + +impl MP3Codebooks { + pub fn new() -> Self { + let quad_cb = init_cb!(MP3_HUFF_QUAD_A_BITS, MP3_HUFF_QUAD_A_LENS, map_cb16); + let cb = [ + init_cb!(MP3_HUFF1_BITS, MP3_HUFF1_LENS, map_cb2), + init_cb!(MP3_HUFF2_BITS, MP3_HUFF2_LENS, map_cb3), + init_cb!(MP3_HUFF3_BITS, MP3_HUFF3_LENS, map_cb3), + init_cb!(MP3_HUFF5_BITS, MP3_HUFF5_LENS, map_cb4), + init_cb!(MP3_HUFF6_BITS, MP3_HUFF6_LENS, map_cb4), + init_cb!(MP3_HUFF7_BITS, MP3_HUFF7_LENS, map_cb6), + init_cb!(MP3_HUFF8_BITS, MP3_HUFF8_LENS, map_cb6), + init_cb!(MP3_HUFF9_BITS, MP3_HUFF9_LENS, map_cb6), + init_cb!(MP3_HUFF10_BITS, MP3_HUFF10_LENS, map_cb8), + init_cb!(MP3_HUFF11_BITS, MP3_HUFF11_LENS, map_cb8), + init_cb!(MP3_HUFF12_BITS, MP3_HUFF12_LENS, map_cb8), + init_cb!(MP3_HUFF13_BITS, MP3_HUFF13_LENS, map_cb16), + init_cb!(MP3_HUFF15_BITS, MP3_HUFF15_LENS, map_cb16), + init_cb!(MP3_HUFF16_BITS, MP3_HUFF16_LENS, map_cb16), + init_cb!(MP3_HUFF24_BITS, MP3_HUFF24_LENS, map_cb16) + ]; + + Self { quad_cb, cb } + } + pub fn get_cb(&self, cb_id: u8) -> Option<(&Codebook, u8)> { + match cb_id { + 0 => None, + 1 => Some((&self.cb[0], 0)), + 2 => Some((&self.cb[1], 0)), + 3 => Some((&self.cb[2], 0)), + 5 => Some((&self.cb[3], 0)), + 6 => Some((&self.cb[4], 0)), + 7 => Some((&self.cb[5], 0)), + 8 => Some((&self.cb[6], 0)), + 9 => Some((&self.cb[7], 0)), + 10 => Some((&self.cb[8], 0)), + 11 => Some((&self.cb[9], 0)), + 12 => Some((&self.cb[10], 0)), + 13 => Some((&self.cb[11], 0)), + 15 => Some((&self.cb[12], 0)), + 16 => Some((&self.cb[13], 1)), + 17 => Some((&self.cb[13], 2)), + 18 => Some((&self.cb[13], 3)), + 19 => Some((&self.cb[13], 4)), + 20 => Some((&self.cb[13], 6)), + 21 => Some((&self.cb[13], 8)), + 22 => Some((&self.cb[13], 10)), + 23 => Some((&self.cb[13], 13)), + 24 => Some((&self.cb[14], 4)), + 25 => Some((&self.cb[14], 5)), + 26 => Some((&self.cb[14], 6)), + 27 => Some((&self.cb[14], 7)), + 28 => Some((&self.cb[14], 8)), + 29 => Some((&self.cb[14], 9)), + 30 => Some((&self.cb[14], 11)), + 31 => Some((&self.cb[14], 13)), + _ => unreachable!(), + } + } +} diff --git a/nihav-mpeg/src/lib.rs b/nihav-mpeg/src/lib.rs new file mode 100644 index 0000000..52700b3 --- /dev/null +++ b/nihav-mpeg/src/lib.rs @@ -0,0 +1,10 @@ +//! Crate for providing support for various MPEG formats. +extern crate nihav_core; +extern crate nihav_codec_support; + +#[cfg(feature="decoders")] +#[allow(clippy::needless_range_loop)] +mod codecs; + +#[cfg(feature="decoders")] +pub use crate::codecs::mpeg_register_all_decoders; -- 2.30.2