1 use nihav_core::codecs::*;
2 use nihav_core::io::byteio::read_u32be;
3 use nihav_core::io::bitreader::*;
4 use nihav_codec_support::dsp::qmf::QMF;
13 const SAMPLES: usize = 1152;
14 const BYTEBUF_SIZE: usize = 2048;
16 #[allow(clippy::large_enum_variant)]
24 fn layer_id(&self) -> u8 {
27 LayerData::MP2(_) => 1,
28 LayerData::MP3(_) => 2,
34 LayerData::MP2(ref mut data) => data.reset(),
35 LayerData::MP3(ref mut data) => data.reset(),
50 coeffs: [[f32; SAMPLES]; 2],
51 out: [[[f32; 32]; 36]; 2],
56 fn new(layer: u8) -> Self {
57 let ctx = match layer {
59 1 => LayerData::MP2(MP2Data::new()),
60 2 => LayerData::MP3(MP3Data::new()),
64 info: NACodecInfo::new_dummy(),
65 smap: NAChannelMap::from_ms_mapping(3),
66 mmap: NAChannelMap::from_ms_mapping(4),
67 qmf: [QMF::new(), QMF::new()],
73 bytebuf: Vec::with_capacity(BYTEBUF_SIZE),
74 coeffs: [[0.0; SAMPLES]; 2],
75 out: [[[0.0; 32]; 36]; 2],
78 fn read_mp3_side_data(&mut self, br: &mut BitReader, src: &[u8], mono: bool) -> DecoderResult<()> {
79 if let LayerData::MP3(ref mut ctx) = self.ctx {
80 let channels = if mono { 1 } else { 2 };
81 ctx.mpeg1 = self.sf_idx < 3;
82 ctx.sf_idx = self.sf_idx;
83 ctx.read_mp3_side_data(br, channels)?;
84 let hdr_size = br.tell() / 8;
85 let add_len = src.len() - hdr_size;
86 if self.bytebuf.len() + add_len > BYTEBUF_SIZE {
87 self.bytebuf.drain(..self.bytebuf.len() + add_len - BYTEBUF_SIZE);
89 let underrun = self.bytebuf.len() < ctx.main_data_end;
90 let del_len = if !underrun { self.bytebuf.len() - ctx.main_data_end } else { 0 };
91 self.bytebuf.extend_from_slice(&src[hdr_size..]);
92 self.bytebuf.drain(..del_len);
94 return Err(DecoderError::MissingReference);
99 Err(DecoderError::Bug)
102 fn decode_layer3(&mut self, channels: usize, mode_ext: u8) -> DecoderResult<bool> {
103 if let LayerData::MP3(ref mut ctx) = self.ctx {
104 let mut br = BitReader::new(&self.bytebuf, BitReaderMode::BE);
106 ctx.decode_mpeg1_layer3(&mut br, &mut self.coeffs, channels)?;
108 ctx.decode_mpeg2_layer3(&mut br, &mut self.coeffs, channels, mode_ext)?;
110 let used_data = (br.tell() + 7) / 8;
111 self.bytebuf.drain(..used_data);
115 Err(DecoderError::Bug)
118 fn synth_layer3(&mut self, mode: u8, mode_ext: u8) {
119 if let LayerData::MP3(ref mut ctx) = self.ctx {
120 ctx.synth(&mut self.coeffs, &mut self.out, mode, mode_ext);
125 fn apply_ms(ch0: &mut [f32], ch1: &mut [f32]) {
126 for (l, r) in ch0.iter_mut().zip(ch1) {
127 let ll = (*l + *r) * std::f32::consts::FRAC_1_SQRT_2;
128 let rr = (*l - *r) * std::f32::consts::FRAC_1_SQRT_2;
134 impl NADecoder for MPADecoder {
135 fn init(&mut self, _supp: &mut NADecoderSupport, info: NACodecInfoRef) -> DecoderResult<()> {
136 if let NACodecTypeInfo::Audio(_ainfo) = info.get_properties() {
137 self.info = info.clone();
140 Err(DecoderError::InvalidData)
143 fn decode(&mut self, _supp: &mut NADecoderSupport, pkt: &NAPacket) -> DecoderResult<NAFrameRef> {
144 let info = pkt.get_stream().get_info();
145 if let NACodecTypeInfo::Audio(_) = info.get_properties() {
146 let src = pkt.get_buffer();
148 let mut br = BitReader::new(src.as_slice(), BitReaderMode::BE);
150 let syncword = br.read(11)?;
151 validate!(syncword == 0x7FF);
152 let id = br.read(2)?;
154 let layer = (br.read(2)? ^ 3) as u8;
155 validate!(layer != 3);
156 let protection = br.read_bool()?;
157 let bitrate_index = br.read(4)? as usize;
158 validate!(bitrate_index < 15);
159 if bitrate_index == 0 {
160 //todo freeform eventually
163 let mut sf_idx = br.read(2)? as usize;
164 validate!(sf_idx != 3);
165 let padding = br.read_bool()?;
166 let _private = br.read_bool()?;
167 let mode = br.read(2)? as u8;
168 let mode_extension = br.read(2)? as u8;
169 let _copyright = br.read_bool()?;
170 let _original = br.read_bool()?;
171 let _emphasis = br.read(2)?;
173 let _crc_check = br.read(16)?;
175 validate!(layer == self.ctx.layer_id());
182 let srate = SAMPLING_RATE[sf_idx];
186 validate!(srate == self.srate);
187 let channels = if mode == 3 { 1 } else { 2 };
188 if self.channels == 0 {
189 self.channels = channels;
191 if channels != self.channels {
194 let bitrate = BITRATE[if mpeg1 { 0 } else { 1 }][layer as usize][bitrate_index];
195 let frame_size = match layer {
197 ((SAMPLES / 3 / 8 * 1000 * (bitrate as usize) / (srate as usize)) & !3) + if padding { 4 } else { 0 }
200 SAMPLES / 2 / 8 * 1000 * (bitrate as usize) / (srate as usize) + if padding { 1 } else { 0 }
203 SAMPLES / 8 * 1000 * (bitrate as usize) / (srate as usize) + if padding { 1 } else { 0 }
206 validate!(src.len() >= frame_size);
207 self.sf_idx = sf_idx;
209 let nsamples = if mpeg1 { SAMPLES } else { SAMPLES / 2 };
211 let ainfo = NAAudioInfo::new(srate, channels, SND_F32P_FORMAT, nsamples);
212 let chmap = if channels == 1 { self.mmap.clone() } else { self.smap.clone() };
214 let mut abuf = alloc_audio_buffer(ainfo, nsamples, chmap)?;
215 let mut adata = abuf.get_abuf_f32().unwrap();
216 let off = if channels == 1 { adata.get_length() } else { adata.get_stride() };
217 let buf = adata.get_data_mut().unwrap();
218 let (ch0, ch1) = buf.split_at_mut(off);
221 0 => unimplemented!(),
223 if let LayerData::MP2(ref mut ctx) = self.ctx {
224 ctx.mpeg1 = self.sf_idx < 3;
225 ctx.sf_idx = self.sf_idx;
226 ctx.br_idx = bitrate_index;
227 ctx.read_layer2(&mut br, channels as usize, &mut self.out, mode, mode_extension)?;
229 return Err(DecoderError::Bug);
231 for (dst, src) in ch0.chunks_exact_mut(32).zip(self.out[0].iter_mut()) {
232 self.qmf[0].synth(src, dst);
235 for (dst, src) in ch1.chunks_mut(32).zip(self.out[1].iter_mut()) {
236 self.qmf[1].synth(src, dst);
241 let ret = self.read_mp3_side_data(&mut br, &src[..frame_size], channels == 1);
243 Err(DecoderError::MissingReference) => {
244 abuf.truncate_audio(0);
245 let mut frm = NAFrame::new_from_pkt(pkt, self.info.clone(), abuf);
246 frm.set_duration(Some(0));
247 return Ok(frm.into_ref());
249 Err(err) => return Err(err),
252 let has_data = self.decode_layer3(channels as usize, mode_extension)?;
254 let frm = NAFrame::new_from_pkt(pkt, self.info.clone(), NABufferType::None);
255 return Ok(frm.into_ref());
257 self.synth_layer3(mode, mode_extension);
258 for (dst, src) in ch0.chunks_exact_mut(32).zip(self.out[0].iter_mut()) {
259 self.qmf[0].synth(src, dst);
262 for (dst, src) in ch1.chunks_mut(32).zip(self.out[1].iter_mut()) {
263 self.qmf[1].synth(src, dst);
269 let mut frm = NAFrame::new_from_pkt(pkt, self.info.clone(), abuf);
270 frm.set_duration(Some(nsamples as u64));
271 frm.set_keyframe(true);
274 Err(DecoderError::Bug)
277 fn flush(&mut self) {
278 for qmf in self.qmf.iter_mut() {
281 self.bytebuf.clear();
286 impl NAOptionHandler for MPADecoder {
287 fn get_supported_options(&self) -> &[NAOptionDefinition] { &[] }
288 fn set_options(&mut self, _options: &[NAOption]) { }
289 fn query_option_value(&self, _name: &str) -> Option<NAValue> { None }
292 pub fn get_decoder_mp2() -> Box<dyn NADecoder + Send> {
293 Box::new(MPADecoder::new(1))
296 pub fn get_decoder_mp3() -> Box<dyn NADecoder + Send> {
297 Box::new(MPADecoder::new(2))
300 #[derive(Clone,Copy,Debug)]
309 impl PartialEq for MPAHeader {
310 fn eq(&self, other: &Self) -> bool {
311 self.layer == other.layer &&
312 self.srate == other.srate &&
313 self.channels == other.channels
318 struct MPAPacketiser {
320 hdr: Option<MPAHeader>,
324 fn new() -> Self { Self::default() }
325 fn parse_header(&self, off: usize) -> DecoderResult<MPAHeader> {
326 if self.buf.len() < off + 4 { return Err(DecoderError::ShortData); }
328 let mut br = BitReader::new(&self.buf[off..], BitReaderMode::BE);
330 let syncword = br.read(11)?;
331 if syncword != 0x7FF { return Err(DecoderError::InvalidData); }
332 let id = br.read(2)?;
333 if id == 1 { return Err(DecoderError::InvalidData); }
334 let layer = (br.read(2)? ^ 3) as u8;
335 if layer == 3 { return Err(DecoderError::InvalidData); }
336 let _protection = br.read_bool()?;
337 let bitrate_index = br.read(4)? as usize;
338 if bitrate_index == 15 { return Err(DecoderError::InvalidData); }
339 if bitrate_index == 0 {
340 //todo freeform eventually
343 let mut sf_idx = br.read(2)? as usize;
344 if sf_idx == 3 { return Err(DecoderError::InvalidData); }
345 let padding = br.read_bool()?;
346 let _private = br.read_bool()?;
347 let mode = br.read(2)? as u8;
355 let srate = SAMPLING_RATE[sf_idx];
356 let channels = if mode == 3 { 1 } else { 2 };
357 let bitrate = BITRATE[if mpeg1 { 0 } else { 1 }][layer as usize][bitrate_index];
358 let frame_size = match layer {
360 ((SAMPLES / 3 / 8 * 1000 * (bitrate as usize) / (srate as usize)) & !3) + if padding { 4 } else { 0 }
363 SAMPLES / 2 / 8 * 1000 * (bitrate as usize) / (srate as usize) + if padding { 1 } else { 0 }
366 SAMPLES / 8 * 1000 * (bitrate as usize) / (srate as usize) + if padding { 1 } else { 0 }
369 let nsamples = if mpeg1 { SAMPLES } else { SAMPLES / 2 };
371 Ok(MPAHeader{ layer, srate, channels, frame_size, nsamples })
375 impl NAPacketiser for MPAPacketiser {
376 fn attach_stream(&mut self, _stream: NAStreamRef) {}
377 fn add_data(&mut self, src: &[u8]) -> bool {
378 self.buf.extend_from_slice(src);
379 self.buf.len() < 4096
381 fn parse_stream(&mut self, id: u32) -> DecoderResult<NAStreamRef> {
382 if self.hdr.is_none() {
383 if self.buf.len() < 4 {
384 return Err(DecoderError::ShortData);
386 let hdr = self.parse_header(0)?;
387 self.hdr = Some(hdr);
389 let hdr = self.hdr.unwrap();
390 let mut duration = 0;
391 if hdr.layer == 2 { // check for Xing/LAME info
392 let mpeg1 = hdr.srate >= 32000;
393 let offset = match (mpeg1, hdr.channels) {
399 if self.buf.len() >= offset + 12 && (&self.buf[offset..][..4] == b"Xing" || &self.buf[offset..][..4] == b"Info") {
400 let flags = read_u32be(&self.buf[offset + 4..]).unwrap_or(0);
401 if (flags & 1) != 0 {
402 duration = u64::from(read_u32be(&self.buf[offset + 8..]).unwrap_or(0));
404 } else if self.buf.len() >= offset + 18 && &self.buf[offset..][..6] == b"VBRI\x00\x01" {
405 duration = u64::from(read_u32be(&self.buf[offset + 14..]).unwrap_or(0));
408 let ainfo = NAAudioInfo::new(hdr.srate, hdr.channels, SND_F32P_FORMAT, hdr.nsamples);
409 let cname = match hdr.layer {
414 let info = NACodecInfo::new(cname, NACodecTypeInfo::Audio(ainfo), None);
415 Ok(NAStream::new(StreamType::Audio, id, info, hdr.nsamples as u32, hdr.srate, duration).into_ref())
417 fn skip_junk(&mut self) -> DecoderResult<usize> {
418 if self.buf.len() <= 2 {
422 let mut hdr = u16::from(self.buf[0]) * 256 + u16::from(self.buf[1]);
423 let mut iter = self.buf[2..].iter();
425 if (hdr & 0xFFE0) != 0xFFE0 {
426 let ret = self.parse_header(off);
429 if self.hdr.is_none() {
430 self.hdr = Some(hdr);
432 if self.hdr.unwrap() != hdr { // header is valid but mismatches
433 self.buf.drain(..off + 1);
434 return Err(DecoderError::InvalidData);
439 self.buf.drain(..off + 1);
445 if let Some(&b) = iter.next() {
446 hdr = (hdr << 8) | u16::from(b);
451 self.buf.drain(..off);
454 fn get_packet(&mut self, stream: NAStreamRef) -> DecoderResult<Option<NAPacket>> {
455 if self.buf.len() < 4 {
456 return Err(DecoderError::ShortData);
458 let hdr = self.parse_header(0)?;
459 if self.hdr.is_none() {
460 self.hdr = Some(hdr);
462 if self.hdr.unwrap() != hdr {
463 return Err(DecoderError::InvalidData);
465 if hdr.frame_size <= self.buf.len() {
466 let mut data = Vec::with_capacity(hdr.frame_size);
467 data.extend_from_slice(&self.buf[..hdr.frame_size]);
468 self.buf.drain(..hdr.frame_size);
469 let ts = NATimeInfo::new(None, None, Some(1), hdr.nsamples as u32, hdr.srate);
470 Ok(Some(NAPacket::new(stream, ts, true, data)))
475 fn reset(&mut self) {
478 fn bytes_left(&self) -> usize { self.buf.len() }
481 pub fn get_packetiser() -> Box<dyn NAPacketiser + Send> {
482 Box::new(MPAPacketiser::new())
487 use nihav_core::codecs::RegisteredDecoders;
488 use nihav_core::demuxers::RegisteredDemuxers;
489 use nihav_codec_support::test::dec_video::test_decode_audio;
490 use crate::mpeg_register_all_decoders;
491 use nihav_flash::flash_register_all_demuxers;
493 use nihav_core::codecs::NAPacketiser;
496 fn test_mpeg1_layer3_mono() {
497 let mut dmx_reg = RegisteredDemuxers::new();
498 flash_register_all_demuxers(&mut dmx_reg);
499 let mut dec_reg = RegisteredDecoders::new();
500 mpeg_register_all_decoders(&mut dec_reg);
502 // sample: https://samples.mplayerhq.hu/FLV/flash_video_5/i_004.flv
503 let file = "assets/Flash/i_004.flv";
504 test_decode_audio("flv", file, Some(6000), None/*Some("mp3_1")*/, &dmx_reg, &dec_reg);
507 fn test_mpeg1_layer3_stereo() {
508 let mut dmx_reg = RegisteredDemuxers::new();
509 flash_register_all_demuxers(&mut dmx_reg);
510 let mut dec_reg = RegisteredDecoders::new();
511 mpeg_register_all_decoders(&mut dec_reg);
513 // sample: https://samples.mplayerhq.hu/FLV/venture_030_ivcp_001_8bit.flv
514 let file = "assets/Flash/venture_030_ivcp_001_8bit.flv";
515 test_decode_audio("flv", file, Some(7200), None/*Some("mp3_2")*/, &dmx_reg, &dec_reg);
518 fn test_mpeg2_layer3() {
519 let mut dmx_reg = RegisteredDemuxers::new();
520 flash_register_all_demuxers(&mut dmx_reg);
521 let mut dec_reg = RegisteredDecoders::new();
522 mpeg_register_all_decoders(&mut dec_reg);
524 // sample: https://samples.mplayerhq.hu/FLV/flash_with_alpha/lection2-2.flv
525 let file = "assets/Flash/lection2-2.flv";
526 test_decode_audio("flv", file, Some(6000), None/*Some("mp3_3")*/, &dmx_reg, &dec_reg);
529 fn test_mpa_packetiser() {
530 let mut buf = [0; 16384];
531 // sample from a private collection
532 let mut file = std::fs::File::open("assets/MPEG/1.mp3").unwrap();
534 let mut pkts = super::MPAPacketiser::new();
535 file.read_exact(&mut buf).unwrap();
537 let stream = pkts.parse_stream(0).unwrap();
538 let mut frame_sizes = Vec::with_capacity(15);
539 while let Some(pkt) = pkts.get_packet(stream.clone()).unwrap() {
540 let frame_size = pkt.get_buffer().len();
541 println!("pkt size {}", frame_size);
542 frame_sizes.push(frame_size);
544 assert_eq!(&frame_sizes, &[1044, 1044, 1045, 1045, 1045, 1045, 1045, 1045, 1045, 1045, 1045, 1044, 1045, 1045, 1045]);
548 const BITRATE: [[[u32; 15]; 3]; 2] = [
550 [ 0, 32, 64, 96, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416, 448 ],
551 [ 0, 32, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384 ],
552 [ 0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320 ]
554 [ 0, 32, 48, 56, 64, 80, 96, 112, 128, 144, 160, 176, 192, 224, 256 ],
555 [ 0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160 ],
556 [ 0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160 ]
560 const SAMPLING_RATE: [u32; 9] = [ 44100, 48000, 32000, 22050, 24000, 16000, 11025, 12000, 8000 ];