use std::fs::File;
use std::io::Cursor;
use std::path::Path;
use symphonia::core::codecs::audio::AudioDecoderOptions;
use symphonia::core::errors::Error as SymphoniaError;
use symphonia::core::formats::probe::Hint;
use symphonia::core::formats::FormatOptions;
use symphonia::core::formats::TrackType;
use symphonia::core::io::MediaSourceStream;
use symphonia::core::meta::MetadataOptions;
use crate::{AsrError, AudioBuffer, AudioSpec, ErrorKind};
const SUPPORTED: &str = "WAV/PCM incl. float, FLAC, MP3, M4A/AAC, Ogg Vorbis, MKV/WebM";
fn decode_error(message: impl Into<String>) -> AsrError {
AsrError::new(ErrorKind::InvalidInput, "decode", message)
}
pub fn read_audio(path: impl AsRef<Path>) -> Result<AudioBuffer, AsrError> {
let file =
File::open(path).map_err(|e| AsrError::new(ErrorKind::Io, "decode", e.to_string()))?;
decode_stream(MediaSourceStream::new(Box::new(file), Default::default()))
}
pub fn decode_audio(bytes: &[u8]) -> Result<AudioBuffer, AsrError> {
decode_stream(MediaSourceStream::new(
Box::new(Cursor::new(bytes)),
Default::default(),
))
}
fn decode_stream(mss: MediaSourceStream) -> Result<AudioBuffer, AsrError> {
let mut format = symphonia::default::get_probe()
.probe(
&Hint::new(),
mss,
FormatOptions::default(),
MetadataOptions::default(),
)
.map_err(|e| {
decode_error(format!(
"unsupported or corrupt audio: {e} (supported: {SUPPORTED})"
))
})?;
let track = format
.default_track(TrackType::Audio)
.ok_or_else(|| decode_error("no audio track"))?;
let params = track
.codec_params
.as_ref()
.and_then(|params| params.audio())
.ok_or_else(|| decode_error("audio track has no codec parameters"))?;
let sample_rate = params
.sample_rate
.ok_or_else(|| decode_error("audio track has no sample rate"))?;
let channels = params
.channels
.as_ref()
.map(|channels| channels.count())
.filter(|count| *count > 0)
.ok_or_else(|| decode_error("audio track has no channels"))?;
let mut decoder = symphonia::default::get_codecs()
.make_audio_decoder(params, &AudioDecoderOptions::default())
.map_err(|e| {
decode_error(format!(
"unsupported audio codec: {e} (supported: {SUPPORTED}; \
Opus has no decoder in symphonia)"
))
})?;
let track_id = track.id;
AudioSpec::mono(sample_rate)?;
let mut samples = Vec::new();
let mut interleaved = Vec::new();
let mut saw_packet = false;
const MAX_UNPRODUCTIVE_PACKETS: usize = 5;
let mut unproductive = 0usize;
loop {
let packet = match format.next_packet() {
Ok(Some(packet)) => packet,
Ok(None) => break,
Err(SymphoniaError::IoError(e)) if e.kind() == std::io::ErrorKind::UnexpectedEof => {
break
}
Err(SymphoniaError::ResetRequired) => {
return Err(decode_error(
"audio stream reconfigures mid-file (e.g. a chained OGG); \
split the segments first",
))
}
Err(e) => return Err(decode_error(format!("failed to read packet: {e}"))),
};
if packet.track_id != track_id {
continue;
}
saw_packet = true;
let decoded = match decoder.decode(&packet) {
Ok(decoded) => decoded,
Err(SymphoniaError::DecodeError(_) | SymphoniaError::IoError(_)) => {
unproductive += 1;
if unproductive >= MAX_UNPRODUCTIVE_PACKETS {
return Err(decode_error(format!(
"audio stream broke mid-file: {MAX_UNPRODUCTIVE_PACKETS} consecutive \
packets failed to decode; chained or reconfigured streams must be \
split first"
)));
}
continue;
}
Err(SymphoniaError::ResetRequired) => {
return Err(decode_error("audio codec reconfigured mid-file"))
}
Err(e) => return Err(decode_error(format!("audio decoding failed: {e}"))),
};
let spec = decoded.spec();
if spec.rate() != sample_rate || spec.channels().count() != channels {
return Err(decode_error(
"audio stream changed sample rate or channels mid-file",
));
}
if decoded.frames() == 0 {
unproductive += 1;
if unproductive >= MAX_UNPRODUCTIVE_PACKETS {
return Err(decode_error(format!(
"audio stream broke mid-file: {MAX_UNPRODUCTIVE_PACKETS} consecutive \
packets decoded to no audio; a concatenated second segment must be \
split first"
)));
}
continue;
}
unproductive = 0;
interleaved.clear();
interleaved.resize(decoded.samples_interleaved(), 0.0);
decoded.copy_to_slice_interleaved(&mut interleaved);
samples.extend(
interleaved
.chunks_exact(channels)
.map(|frame| frame.iter().sum::<f32>() / channels as f32),
);
}
if samples.is_empty() && saw_packet {
return Err(decode_error(
"no audio could be decoded from the input (every packet failed)",
));
}
AudioBuffer::mono(samples, sample_rate)
}
#[cfg(test)]
mod tests;