Frequently Asked Questions

[dependencies]
symphonia = { version = "0.5", features = ["all"] }

use symphonia::core::codecs::DecoderOptions;
use symphonia::core::formats::FormatOptions;
use symphonia::core::io::MediaSourceStream;
use symphonia::core::meta::MetadataOptions;
use symphonia::core::probe::Hint;
use std::fs::File;

let file = Box::new(File::open("audio.mp3")?);
let mss = MediaSourceStream::new(file, Default::default());
let mut hint = Hint::new();
hint.with_extension("mp3");

let probed = symphonia::default::get_probe()
    .format(&hint, mss, &FormatOptions::default(), &MetadataOptions::default())?;

let mut format = probed.format;
let track = format.default_track()?;
let mut decoder = symphonia::default::get_codecs()
    .make(&track.codec_params, &DecoderOptions::default())?;

# Enable specific codecs
symphonia = { version = "0.5", features = ["mp3", "aac", "flac"] }

# Enable all codecs
symphonia = { version = "0.5", features = ["all-codecs"] }

# Enable all formats
symphonia = { version = "0.5", features = ["all-formats"] }

# Enable everything
symphonia = { version = "0.5", features = ["all"] }

use symphonia::core::audio::SampleBuffer;
use cpal::traits::{DeviceTrait, HostTrait, StreamTrait};

// Decode audio with Symphonia
let decoded = decoder.decode(&packet)?;

// Convert to interleaved samples
let mut sample_buf = SampleBuffer::<f32>::new(
    decoded.capacity() as u64,
    *decoded.spec()
);
sample_buf.copy_interleaved_ref(decoded);

// Send to CPAL audio output
// (See CPAL documentation for stream setup)

use symphonia::core::formats::{SeekMode, SeekTo};
use symphonia::core::units::Time;

// Seek to 30 seconds
let seek_to = SeekTo::Time {
    time: Time::from(30.0),
    track_id: Some(track_id),
};
format.seek(SeekMode::Accurate, seek_to)?;

// Get current metadata revision
if let Some(metadata_rev) = format.metadata().current() {
    // Iterate over all tags
    for tag in metadata_rev.tags() {
        println!("{}: {}", tag.std_key.map(|k| k.to_string()).unwrap_or_else(|| tag.key.clone()), tag.value);
    }

    // Get visual (cover art)
    for visual in metadata_rev.visuals() {
        println!("Found cover art: {} ({})", visual.media_type, visual.data.len());
    }
}

// Check for updated metadata during decoding
while !format.metadata().is_latest() {
    format.metadata().pop();
    // Process new metadata
}

use tokio::task;

let decoded_samples = task::spawn_blocking(move || {
    // Perform decoding in blocking task
    decoder.decode(&packet)
}).await??;

symphonia = { version = "0.5", features = ["opt-simd"] }

RUSTFLAGS="-C target-cpu=native" cargo build --release

// Convert to f32
let mut sample_buf = SampleBuffer::<f32>::new(
    decoded.capacity() as u64,
    *decoded.spec()
);
sample_buf.copy_interleaved_ref(decoded);

let f32_samples: &[f32] = sample_buf.samples();

use symphonia::core::io::MediaSourceStream;
use std::io::Cursor;

// From a byte buffer
let audio_data: Vec<u8> = /* ... */;
let cursor = Cursor::new(audio_data);
let mss = MediaSourceStream::new(Box::new(cursor), Default::default());

// Probe and decode as usual
let probed = symphonia::default::get_probe()
    .format(&hint, mss, &fmt_opts, &meta_opts)?;