SymphoniaDecoder::new() panics on SeekError during initialization with M4A files

[Cloud370]

Summary

SymphoniaDecoder::new() panics via unreachable!() when symphonia's FormatReader::next_packet() returns Error::SeekError during initialization. This consistently occurs with M4A (AAC in ISO MP4 container) files.

Affected code — src/decoder/symphonia.rs line 40 (master):

Error::SeekError(_) => {
    unreachable!("Seek errors should not occur during initialization")
}

Steps to Reproduce

1. Obtain an M4A audio file (AAC in ISO MP4 container, e.g. NetEase Cloud Music "exhigh" quality)
2. Load the file bytes into memory
3. Attempt to decode with any rodio decoder method:

use rodio::Decoder;
use std::io::Cursor;

let audio_bytes: Vec<u8> = std::fs::read("song.m4a").unwrap();
// This panics:
let decoder = Decoder::new(Cursor::new(audio_bytes));

The M4A file has a standard ftyp box header: 00 00 00 1c 66 74 79 70 4d 34 41 20 (ftyp + brand M4A ).

Observed Behavior

The program panics with:

thread 'audio' panicked at 'internal error: entered unreachable code: Seek errors should not occur during initialization'

All decoder methods are affected (Decoder::new, Decoder::new_mp3, Decoder::new_flac, Decoder::new_aac, Decoder::new_wav, Decoder::new_vorbis) — they all go through SymphoniaDecoder::init() which calls format.next_packet(), and symphonia's ISO MP4 format reader returns Error::SeekError for these files.

Expected Behavior

Decoder::new() should return Err(DecoderError::...) instead of panicking. A library should never panic on valid user input.

Root Cause

SymphoniaDecoder::init() reads packets in a loop via format.next_packet(). The error handling at the call site (SymphoniaDecoder::new()) assumes SeekError can never be returned during initialization, but symphonia's ISO MP4 FormatReader can return Error::SeekError from next_packet() for certain M4A files.

Suggested Fix

Replace the unreachable!() with a proper error return:

// Before:
Error::SeekError(_) => {
    unreachable!("Seek errors should not occur during initialization")
}

// After:
Error::SeekError(e) => Err(DecoderError::IoError(format!("seek error during init: {}", e))),

This is a one-line fix. A new DecoderError variant (e.g. SeekError) would be even cleaner but would be a breaking change.

Versions

• rodio: 0.20.1 (also verified on master — the unreachable!() is still present at line 40)
• symphonia: 0.5.5
• OS: Windows 11
• Rust: stable

[roderickvd]

Thanks for the report. We can do that. At the same time, it sounds like this is a bug that should be reported with Symphonia upstream. Does it help when you load the file with Decoder::TryFrom? That should correctly set byte length and seekable metadata.

[Cloud370]

Thanks for the reply. Decoder::TryFrom doesn't exist in 0.20.1 (it was added in 0.21). And even in 0.21.1, TryFrom<Cursor<T>> just calls Self::new(data) without setting byte_len (source) — so it won't fix this for in-memory data. Only TryFrom<File> correctly sets byte_len via file.metadata().len().

I did some further investigation and found the root cause: ReadSeekSource::byte_len() returns None (hardcoded in 0.20.1, default in 0.21.1). Symphonia's ISO MP4 format reader depends on this value — when it gets None, it fails.

I tested the same M4A file three ways to confirm:

Approach	byte_len()	Result
rodio::Decoder::new(Cursor)	None (via ReadSeekSource)	PANIC — unreachable!()
symphonia directly, byte_len() = None	None	Probe fails: seek error: stream is not seekable
symphonia directly, byte_len() = Some(len)	Correct length	Decodes successfully (44100 Hz, stereo, first packet)

So this doesn't need a symphonia upstream report — symphonia behaves correctly when given proper metadata.

Suggestions for rodio:

1. Replace the unreachable!() with Err(...) — a library should never panic on user input regardless of root cause (this is still present in 0.21.1)
2. TryFrom<Cursor<T>> should set byte_len — the underlying T: AsRef<[u8]> has a known length via data.get_ref().as_ref().len(), so there's no reason not to

My current workaround is bypassing rodio and calling symphonia directly with a correct byte_len() implementation.

Minimal reproduction code

use std::io::{Cursor, Read, Seek, SeekFrom};
use symphonia::core::io::MediaSource;

// Reproducing rodio's wrapper (byte_len = None)
struct BrokenSource<T: Read + Seek + Send + Sync> {
    inner: T,
}

impl<T: Read + Seek + Send + Sync> MediaSource for BrokenSource<T> {
    fn is_seekable(&self) -> bool { true }
    fn byte_len(&self) -> Option<u64> { None } // rodio's ReadSeekSource does this
}
impl<T: Read + Seek + Send + Sync> Read for BrokenSource<T> {
    fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> { self.inner.read(buf) }
}
impl<T: Read + Seek + Send + Sync> Seek for BrokenSource<T> {
    fn seek(&mut self, pos: SeekFrom) -> std::io::Result<u64> { self.inner.seek(pos) }
}

// Fixed wrapper (byte_len = actual length)
struct FixedSource {
    inner: Cursor<Vec<u8>>,
    len: u64,
}

impl MediaSource for FixedSource {
    fn is_seekable(&self) -> bool { true }
    fn byte_len(&self) -> Option<u64> { Some(self.len) }
}
impl Read for FixedSource {
    fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> { self.inner.read(buf) }
}
impl Seek for FixedSource {
    fn seek(&mut self, pos: SeekFrom) -> std::io::Result<u64> { self.inner.seek(pos) }
}

fn main() {
    let data = std::fs::read(std::env::args().nth(1).unwrap()).unwrap();

    // Test 1: rodio Decoder::new — panics
    let r = std::panic::catch_unwind(|| rodio::Decoder::new(Cursor::new(data.clone())));
    println!("rodio Decoder::new: {r:?}");

    // Test 2: symphonia with byte_len=None — probe fails
    let mss = symphonia::core::io::MediaSourceStream::new(
        Box::new(BrokenSource { inner: Cursor::new(data.clone()) }), Default::default());
    println!("symphonia byte_len=None: {:?}", decode(mss));

    // Test 3: symphonia with byte_len=Some(len) — works
    let len = data.len() as u64;
    let mss = symphonia::core::io::MediaSourceStream::new(
        Box::new(FixedSource { inner: Cursor::new(data), len }), Default::default());
    println!("symphonia byte_len=Some: {:?}", decode(mss));
}

fn decode(mss: symphonia::core::io::MediaSourceStream) -> Result<String, String> {
    use symphonia::core::{codecs::*, errors::Error, formats::*, meta::*, probe::*};
    let probed = symphonia::default::get_probe()
        .format(&Hint::new(), mss, &FormatOptions { enable_gapless: true, ..Default::default() },
                &MetadataOptions::default())
        .map_err(|e| format!("probe: {e}"))?;
    let mut fmt = probed.format;
    let t = fmt.tracks().iter().find(|t| t.codec_params.codec != CODEC_TYPE_NULL)
        .ok_or("no track")?;
    let tid = t.id;
    let mut dec = symphonia::default::get_codecs()
        .make(&t.codec_params, &DecoderOptions::default()).map_err(|e| format!("{e}"))?;
    loop {
        match fmt.next_packet() {
            Ok(p) if p.track_id() == tid => match dec.decode(&p) {
                Ok(d) => return Ok(format!("rate={}, ch={}", d.spec().rate, d.spec().channels.count())),
                Err(Error::DecodeError(_)) => continue,
                Err(e) => return Err(format!("{e}")),
            },
            Ok(_) => continue,
            Err(e) => return Err(format!("{e}")),
        }
    }
}

Cargo.toml:

[dependencies]
rodio = { version = "0.20", default-features = false, features = [
    "symphonia-aac", "symphonia-isomp4",
] }
symphonia = "0.5"

Any M4A file will reproduce the issue.

[roderickvd]

It was fixed in #786.