A few samples
to get started.

cargo add audiobox

use audiobox::{EncodeOptions, NormalizeOptions,
    read_audio_file, write_audio_file};

fn main() -> audiobox::Result<()> {
    let original = read_audio_file("recording.wav")?;
    let ready = original
        .cut(0.0, 10.0)?
        .to_mono()
        .normalize(NormalizeOptions::default())?;

    write_audio_file("ready.flac", &ready,
        &EncodeOptions::default())?;
    Ok(())
}

use audiobox::Audio;

fn main() -> audiobox::Result<()> {
    let audio = Audio::new(vec![vec![0.0; 48_000]], 48_000)?;
    assert_eq!(audio.channels(), 1);
    assert_eq!(audio.frames(), 48_000);
    assert_eq!(audio.duration(), 1.0);

    let channel: &[f32] = audio.channel_data(0)?;
    let interleaved: Vec<f32> = audio.to_interleaved();
    let restored = Audio::from_interleaved(&interleaved, 1, 48_000)?;
    assert_eq!(channel.len(), restored.frames());
    Ok(())
}

use audiobox::{Audio, AudioFormat, EncodeOptions, SampleFormat,
    decode, encode, encode_with_options, sniff};

fn main() -> audiobox::Result<()> {
    let audio = Audio::new(vec![vec![0.0; 4_800]], 48_000)?;
    let wav = encode(&audio, AudioFormat::Wav)?;
    assert_eq!(sniff(&wav), Some(AudioFormat::Wav));
    let restored = decode(&wav)?;

    let flac = encode_with_options(&restored, AudioFormat::Flac,
        &EncodeOptions {
            sample_format: SampleFormat::S24,
            compression_level: 5,
            ..EncodeOptions::default()
        })?;
    assert!(!flac.is_empty());
    Ok(())
}

use audiobox::{Audio, TimePosition};

fn main() -> audiobox::Result<()> {
    let audio = Audio::silence(3.0, 2, 48_000)?;
    let first_second = audio.cut(
        TimePosition::Frames(0),
        TimePosition::Frames(48_000),
    )?;
    let last_second = audio.cut(-1.0, audio.duration())?;
    let joined = first_second.concat(&last_second)?;
    let reversed = joined.reverse().to_mono();
    assert_eq!(reversed.channels(), 1);
    Ok(())
}

use audiobox::{Audio, FadeCurve, FilterOptions, FilterType,
    LimiterOptions, NormalizeOptions, NormalizeUnit};

fn main() -> audiobox::Result<()> {
    let audio = Audio::silence(2.0, 2, 44_100)?;
    let processed = audio
        .remove_dc_offset()
        .filter(FilterOptions::new(FilterType::Highpass, 80.0))?
        .gain_db(-3.0)?
        .fade(0.1, 0.3, FadeCurve::EqualPower)?
        .resample(48_000)?;

    let normalized = processed.normalize(NormalizeOptions {
        to: -16.0,
        unit: NormalizeUnit::Lufs,
        peak_ceiling_db: -1.0,
    })?;
    let limited = normalized.limit(LimiterOptions::default())?;
    assert_eq!(limited.sample_rate(), 48_000);
    Ok(())
}

use audiobox::{Audio, analyze};

fn main() -> audiobox::Result<()> {
    let audio = Audio::silence(1.0, 1, 48_000)?;
    let waveform = audio.waveform(256)?;
    let spectrum = analyze::spectrum(audio.channel_data(0)?,
        audio.sample_rate(), 2048)?;
    let loudness = audio.loudness();

    println!("Peak: {} dBFS", audio.peak_db());
    println!("RMS: {} dBFS", audio.rms_db());
    println!("Integrated: {} LUFS", loudness.integrated);
    println!("Buckets: {}, bins: {}",
        waveform.min.len(), spectrum.frequencies.len());
    Ok(())
}

use audiobox::stream::Decoder;

fn main() -> audiobox::Result<()> {
    let bytes = std::fs::read("music.mp3")?;
    let mut music = Decoder::new(bytes)?;
    println!("{} Hz, {} channels", music.sample_rate(), music.channels());

    let mut buffer = vec![0.0f32; 1024 * music.channels()];
    loop {
        let frames = music.read(&mut buffer)?; // Interleaved frames; 0 at the end.
        if frames == 0 {
            break;
        }
    }
    music.rewind()?; // Loop without decoding anything again.
    music.seek(44_100)?; // Or move to any frame.
    Ok(())
}

use audiobox::{Endian, Limits, SampleFormat};
use audiobox::stream::{PcmDecoder, Resampler};

fn main() -> audiobox::Result<()> {
    let mut decoder = PcmDecoder::new(SampleFormat::S16,
        Endian::Little, 2, 48_000, Limits::default())?;
    let mut resampler = Resampler::new(48_000, 16_000,
        2, Limits::default())?;
    let pcm = vec![0_u8; 48_000 * 2 * 2];

    for chunk in pcm.chunks(1023) {
        let decoded = decoder.push(chunk)?;
        let output = resampler.push(&decoded)?;
        println!("{} output frames", output.frames());
    }
    decoder.finish()?;          // Reject an incomplete final frame.
    let tail = resampler.finish()?; // Drain the final filter tail.
    println!("{} final frames", tail.frames());
    Ok(())
}

use audiobox::mixer::{Fade, Loop, Mixer, MixerConfig, Play};
use audiobox::stream::Decoder;
use std::sync::Arc;

fn main() -> audiobox::Result<()> {
    let (mut mixer, mut handle) = Mixer::new(MixerConfig {
        buses: vec!["music".into(), "effects".into()],
        ..MixerConfig::default() // 48 kHz stereo, 32 voices.
    })?;
    let music = handle.bus("music").unwrap();
    let effects = handle.bus("effects").unwrap();

    // Game thread: stream music, share decoded effects.
    let song = Decoder::new(std::fs::read("music.flac")?)?;
    let looping = Play { bus: music, looping: Loop::Whole, priority: 255, ..Play::default() };
    handle.play(song, &looping)?;
    let jump = Arc::new(audiobox::read_audio_file("jump.wav")?);
    handle.play(jump, &Play { bus: effects, pan: -0.4, ..Play::default() })?;
    handle.set_bus_gain(music, 0.5, Fade::linear(0.5))?;

    // Audio thread: once per device buffer.
    let mut buffer = vec![0.0f32; 2 * 512];
    mixer.render(&mut buffer);

    // Game thread, once per frame: events, and freeing finished voices.
    while let Some(event) = handle.poll_event() {
        println!("{event:?}");
    }
    Ok(())
}

use audiobox::synth::Score;

fn main() -> audiobox::Result<()> {
    let score: Score = "
        tempo 150
        instrument lead wave=pulse duty=25 adsr=5,60,70,40 vibrato=12,160,200
        instrument bass wave=triangle
        channel melody = @lead o5 l8 L [c e g >c< g e]2 c2
        channel bass   = @bass o3 l2 c g c1
    ".parse()?;
    let audio = score.render(44_100)?;
    audiobox::write_audio_file("song.wav", &audio, &Default::default())?;
    Ok(())
}

use audiobox::sfx::{Effect, Preset};

fn main() -> audiobox::Result<()> {
    // Draw an effect from a seed; the same seed gives the same sound everywhere.
    let jump = Effect::preset(Preset::Jump, 7);
    println!("{jump}"); // Its text form, to keep in your repository.

    let coin: Effect = "wave=pulse frequency=987.8 sustain=0.05 punch=0.5 decay=0.3
                        arpeggio=5 arpeggio-time=0.07".parse()?;
    audiobox::write_audio_file("coin.wav", &coin.render(44_100)?, &Default::default())?;
    Ok(())
}

use audiobox::{DecodeOptions, ErrorCode, Limits,
    decode_with_options};

fn main() {
    let options = DecodeOptions {
        limits: Limits {
            max_duration_seconds: 60.0,
            max_channels: 2,
            max_decoded_bytes: 32 * 1024 * 1024,
            ..Limits::default()
        },
        ..DecodeOptions::default()
    };

    match decode_with_options(b"not an audio file", &options) {
        Ok(audio) => println!("{} frames", audio.frames()),
        Err(error) => match error.code {
            ErrorCode::LimitExceeded => eprintln!("Choose a smaller clip"),
            _ => eprintln!("Could not decode: {error}"),
        },
    }
}