#![no_std]
#![forbid(unsafe_code)]
mod minimp3;
pub use minimp3::Sample;
#[doc(hidden)]
pub mod __private {
pub use crate::minimp3::{l3_side_info, mp3d_find_frame as find_frame, FrameInfo, Header};
use crate::{minimp3, Decoder, Sample};
pub fn decode_frame<S: Sample>(
dec: &mut Decoder,
mp3: &[u8],
pcm: Option<&mut [S]>,
info: &mut FrameInfo,
) -> usize {
minimp3::mp3dec_decode_frame(&mut dec.dec, mp3, pcm, info, dec.minimp3_compat)
}
pub fn init(dec: &mut Decoder) {
minimp3::mp3dec_init(&mut dec.dec);
}
}
#[cfg(test)]
mod tests;
pub const MAX_SAMPLES_PER_FRAME: usize = 1152*2;
#[derive(Clone)]
pub struct Decoder {
dec: minimp3::Mp3Dec,
minimp3_compat: bool,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
pub enum Channels {
Mono = 1,
Stereo
}
impl Channels {
pub fn num(self) -> u8 {
self as u8
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[non_exhaustive]
pub struct FrameInfo {
pub samples_produced: usize,
pub channels: Channels,
pub sample_rate: u32,
pub bitrate: u32,
pub layer: u8,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[non_exhaustive]
pub enum DecodeError {
NoFrame,
ReservoirUnavailable(FrameInfo),
Corrupt(FrameInfo),
UnsupportedLayer(FrameInfo),
}
impl DecodeError {
pub fn frame_info(&self) -> Option<&FrameInfo> {
match self {
DecodeError::NoFrame => None,
DecodeError::ReservoirUnavailable(info)
| DecodeError::Corrupt(info)
| DecodeError::UnsupportedLayer(info) => Some(info),
}
}
}
impl core::fmt::Display for DecodeError {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
f.write_str(match self {
DecodeError::NoFrame => "no complete MPEG audio frame in the input",
DecodeError::ReservoirUnavailable(_) => "frame depends on bit reservoir data that wasn't decoded",
DecodeError::Corrupt(_) => "corrupt frame",
DecodeError::UnsupportedLayer(_) => "Layer I/II frame (the layer12 feature is disabled)",
})
}
}
impl core::error::Error for DecodeError {}
impl Decoder {
pub const fn new() -> Self {
Self { dec: minimp3::Mp3Dec::new(), minimp3_compat: false }
}
pub const fn new_minimp3_compat() -> Self {
Self { dec: minimp3::Mp3Dec::new(), minimp3_compat: true }
}
pub fn decode<S: Sample>(&mut self, mp3: &[u8], pcm: &mut [S]) -> (usize, Result<FrameInfo, DecodeError>) {
assert!(pcm.len() >= MAX_SAMPLES_PER_FRAME, "pcm buffer too small");
let mut info = minimp3::FrameInfo::default();
let samples = minimp3::mp3dec_decode_frame(&mut self.dec, mp3, Some(pcm), &mut info, self.minimp3_compat);
let frame = FrameInfo {
samples_produced: samples,
channels: if info.channels == 1 { Channels::Mono } else { Channels::Stereo },
sample_rate: info.hz,
bitrate: info.bitrate_kbps,
layer: info.layer,
};
let result = match info.status {
minimp3::Status::Decoded => Ok(frame),
minimp3::Status::NoFrame | minimp3::Status::HeaderOnly => Err(DecodeError::NoFrame),
minimp3::Status::Corrupt => Err(DecodeError::Corrupt(frame)),
minimp3::Status::ReservoirUnavailable => Err(DecodeError::ReservoirUnavailable(frame)),
minimp3::Status::UnsupportedLayer => Err(DecodeError::UnsupportedLayer(frame)),
};
(info.frame_bytes, result)
}
}
impl Default for Decoder {
fn default() -> Self {
Self::new()
}
}