PCM Codec

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

[dependencies]
symphonia-codec-pcm = "0.5"

use symphonia_codec_pcm::PcmDecoder;
use symphonia::core::codecs::{Decoder, DecoderOptions};

// Create decoder from codec parameters
let mut decoder = PcmDecoder::try_new(&codec_params, &DecoderOptions::default())?;

// Decode a packet
let decoded = decoder.decode(&packet)?;

use symphonia::core::codecs::*;

// Signed integer formats
CODEC_TYPE_PCM_S8
CODEC_TYPE_PCM_S16LE
CODEC_TYPE_PCM_S16BE
CODEC_TYPE_PCM_S24LE
CODEC_TYPE_PCM_S24BE
CODEC_TYPE_PCM_S32LE
CODEC_TYPE_PCM_S32BE

// Unsigned integer formats
CODEC_TYPE_PCM_U8
CODEC_TYPE_PCM_U16LE
CODEC_TYPE_PCM_U16BE
CODEC_TYPE_PCM_U24LE
CODEC_TYPE_PCM_U24BE
CODEC_TYPE_PCM_U32LE
CODEC_TYPE_PCM_U32BE

// Floating-point formats
CODEC_TYPE_PCM_F32LE
CODEC_TYPE_PCM_F32BE
CODEC_TYPE_PCM_F64LE
CODEC_TYPE_PCM_F64BE

// Log-PCM formats
CODEC_TYPE_PCM_ALAW
CODEC_TYPE_PCM_MULAW

[dependencies]
# For WAV files
symphonia = { version = "0.5", features = ["pcm", "wav"] }

# For AIFF files
symphonia = { version = "0.5", features = ["pcm", "aiff"] }

// Required parameters:
// - codec: The specific PCM codec type
// - sample_rate: Sample rate in Hz
// - channels or channel_layout: Channel configuration
// - max_frames_per_packet: Maximum frames per packet

// Optional but recommended:
// - bits_per_sample: Actual bit depth
// - bits_per_coded_sample: Coded bit depth (may differ)

// Example: 20-bit audio in 24-bit format
// bits_per_sample = 20
// bits_per_coded_sample = 24
// The decoder automatically shifts samples appropriately

use symphonia::core::codecs::{CODEC_TYPE_PCM_S16LE, 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;

fn decode_wav_file(path: &str) -> Result<(), Box<dyn std::error::Error>> {
    // Open the media source
    let file = Box::new(File::open(path)?);
    let mss = MediaSourceStream::new(file, Default::default());

    // Create a hint
    let mut hint = Hint::new();
    hint.with_extension("wav");

    // Probe the media source
    let probed = symphonia::default::get_probe()
        .format(&hint, mss, &FormatOptions::default(), &MetadataOptions::default())?;

    let mut format = probed.format;
    let track = &format.tracks()[0];

    println!("Codec: {:?}", track.codec_params.codec);
    println!("Sample Rate: {:?}", track.codec_params.sample_rate);
    println!("Channels: {:?}", track.codec_params.channels);
    println!("Bit Depth: {:?}", track.codec_params.bits_per_sample);

    // Create the decoder
    let mut decoder = symphonia::default::get_codecs()
        .make(&track.codec_params, &DecoderOptions::default())?;

    // Decode packets
    loop {
        let packet = match format.next_packet() {
            Ok(packet) => packet,
            Err(_) => break,
        };

        let decoded = decoder.decode(&packet)?;
        // Process decoded audio...
    }

    Ok(())
}

use symphonia::core::audio::AudioBufferRef;
use symphonia::core::conv::{FromSample, IntoSample};

let decoded = decoder.decode(&packet)?;

match decoded {
    AudioBufferRef::U8(buf) => {
        // 8-bit unsigned samples
    }
    AudioBufferRef::S16(buf) => {
        // 16-bit signed samples (most common)
        for channel in 0..buf.spec().channels.count() {
            let samples = buf.chan(channel);
            // Process i16 samples...
        }
    }
    AudioBufferRef::S24(buf) => {
        // 24-bit signed samples
    }
    AudioBufferRef::S32(buf) => {
        // 32-bit signed samples
    }
    AudioBufferRef::F32(buf) => {
        // 32-bit float samples
    }
    AudioBufferRef::F64(buf) => {
        // 64-bit float samples
    }
    _ => {}
}

use symphonia::core::codecs::{CODEC_TYPE_PCM_ALAW, CODEC_TYPE_PCM_MULAW};

// A-law and μ-law are decoded to S16
// 8-bit companded → 16-bit linear PCM

let decoded = decoder.decode(&packet)?;
match decoded {
    AudioBufferRef::S16(buf) => {
        // Linear 16-bit samples from A-law/μ-law
    }
    _ => unreachable!(),
}

use symphonia::core::conv::{FromSample, IntoSample};

// Convert any sample type to f32
let float_sample: f32 = sample.into_sample();

// Convert from f32 to any sample type  
let int_sample: i16 = f32::from_sample(0.5);

// 16-bit signed, 44.1 kHz, stereo, little-endian
CODEC_TYPE_PCM_S16LE

// 24-bit signed, 96 kHz or 192 kHz
CODEC_TYPE_PCM_S24LE

// 8-bit A-law or μ-law, 8 kHz, mono
CODEC_TYPE_PCM_ALAW
CODEC_TYPE_PCM_MULAW

// 32-bit float, 192 kHz
CODEC_TYPE_PCM_F32LE