Struct WaveformAnalyzer 

pub struct WaveformAnalyzer { /* private fields */ }

Computes peak and RMS amplitude per time interval for an audio file.

Decodes audio via AudioDecoder (requesting packed f32 output so that per-sample arithmetic needs no format dispatch) and computes, for each configurable interval, the peak and RMS amplitudes in dBFS. The resulting Vec<WaveformSample> is designed for waveform display rendering.

Examples

use ff_analysis::WaveformAnalyzer;
use std::time::Duration;

let samples = WaveformAnalyzer::new("audio.mp3")
    .interval(Duration::from_millis(50))
    .run()?;

for s in &samples {
    println!("{:?}: peak={:.1} dBFS  rms={:.1} dBFS",
             s.timestamp, s.peak_db, s.rms_db);
}

Implementations

impl WaveformAnalyzer

pub fn new(input: impl AsRef<Path>) -> Self

Creates a new analyzer for the given audio file.

The default sampling interval is 100 ms. Call interval to override it.

Examples found in repository

examples/waveform.rs (line 58)

fn main() {
    let mut args = std::env::args().skip(1);
    let mut input = None::<String>;
    let mut interval_ms = 100u64;

    while let Some(flag) = args.next() {
        match flag.as_str() {
            "--input" | "-i" => input = Some(args.next().unwrap_or_default()),
            "--interval-ms" => {
                let raw = args.next().unwrap_or_default();
                interval_ms = raw.parse().unwrap_or_else(|_| {
                    eprintln!("Invalid interval-ms: {raw}");
                    process::exit(1);
                });
            }
            other => {
                eprintln!("Unknown flag: {other}");
                process::exit(1);
            }
        }
    }

    let input = input.unwrap_or_else(|| {
        eprintln!("Usage: waveform --input <audio> [--interval-ms <ms>]");
        process::exit(1);
    });

    println!("Analyzing waveform: {input}");
    println!("Interval: {interval_ms} ms");
    println!();

    let samples: Vec<WaveformSample> = WaveformAnalyzer::new(&input)
        .interval(Duration::from_millis(interval_ms))
        .run()
        .unwrap_or_else(|e| {
            eprintln!("Error: {e}");
            process::exit(1);
        });

    println!("{} interval(s) analyzed.", samples.len());
    println!();

    // Print first 20 samples to avoid flooding the terminal.
    let display_count = samples.len().min(20);
    println!(
        "{:<12}  {:>10}  {:>10}",
        "Time (s)", "Peak dBFS", "RMS dBFS"
    );
    println!("{}", "-".repeat(38));
    for s in samples.iter().take(display_count) {
        let secs = s.timestamp.as_secs_f64();
        println!(
            "{secs:<12.3}  {:>10}  {:>10}",
            fmt_db(s.peak_db),
            fmt_db(s.rms_db)
        );
    }
    if samples.len() > display_count {
        println!("  … ({} more intervals)", samples.len() - display_count);
    }
}

pub fn interval(self, d: Duration) -> Self

Sets the sampling interval.

Peak and RMS are computed independently for each interval of this length. Passing Duration::ZERO causes run to return AnalysisError::Failed.

Default: 100 ms.

Examples found in repository

examples/waveform.rs (line 59)

fn main() {
    let mut args = std::env::args().skip(1);
    let mut input = None::<String>;
    let mut interval_ms = 100u64;

    while let Some(flag) = args.next() {
        match flag.as_str() {
            "--input" | "-i" => input = Some(args.next().unwrap_or_default()),
            "--interval-ms" => {
                let raw = args.next().unwrap_or_default();
                interval_ms = raw.parse().unwrap_or_else(|_| {
                    eprintln!("Invalid interval-ms: {raw}");
                    process::exit(1);
                });
            }
            other => {
                eprintln!("Unknown flag: {other}");
                process::exit(1);
            }
        }
    }

    let input = input.unwrap_or_else(|| {
        eprintln!("Usage: waveform --input <audio> [--interval-ms <ms>]");
        process::exit(1);
    });

    println!("Analyzing waveform: {input}");
    println!("Interval: {interval_ms} ms");
    println!();

    let samples: Vec<WaveformSample> = WaveformAnalyzer::new(&input)
        .interval(Duration::from_millis(interval_ms))
        .run()
        .unwrap_or_else(|e| {
            eprintln!("Error: {e}");
            process::exit(1);
        });

    println!("{} interval(s) analyzed.", samples.len());
    println!();

    // Print first 20 samples to avoid flooding the terminal.
    let display_count = samples.len().min(20);
    println!(
        "{:<12}  {:>10}  {:>10}",
        "Time (s)", "Peak dBFS", "RMS dBFS"
    );
    println!("{}", "-".repeat(38));
    for s in samples.iter().take(display_count) {
        let secs = s.timestamp.as_secs_f64();
        println!(
            "{secs:<12.3}  {:>10}  {:>10}",
            fmt_db(s.peak_db),
            fmt_db(s.rms_db)
        );
    }
    if samples.len() > display_count {
        println!("  … ({} more intervals)", samples.len() - display_count);
    }
}

pub fn run(self) -> Result<Vec<WaveformSample>, AnalysisError>

Runs the waveform analysis and returns one WaveformSample per interval.

The timestamp of each sample is the start of its interval. Audio is decoded as packed f32 samples; the decoder performs any necessary format conversion automatically.

Errors

• AnalysisError::Failed — interval is Duration::ZERO.
• ff_decode::DecodeError::FileNotFound — input path does not exist.
• Any other ff_decode::DecodeError propagated from AudioDecoder, wrapped in AnalysisError::Decode.

Examples found in repository

examples/waveform.rs (line 60)

fn main() {
    let mut args = std::env::args().skip(1);
    let mut input = None::<String>;
    let mut interval_ms = 100u64;

    while let Some(flag) = args.next() {
        match flag.as_str() {
            "--input" | "-i" => input = Some(args.next().unwrap_or_default()),
            "--interval-ms" => {
                let raw = args.next().unwrap_or_default();
                interval_ms = raw.parse().unwrap_or_else(|_| {
                    eprintln!("Invalid interval-ms: {raw}");
                    process::exit(1);
                });
            }
            other => {
                eprintln!("Unknown flag: {other}");
                process::exit(1);
            }
        }
    }

    let input = input.unwrap_or_else(|| {
        eprintln!("Usage: waveform --input <audio> [--interval-ms <ms>]");
        process::exit(1);
    });

    println!("Analyzing waveform: {input}");
    println!("Interval: {interval_ms} ms");
    println!();

    let samples: Vec<WaveformSample> = WaveformAnalyzer::new(&input)
        .interval(Duration::from_millis(interval_ms))
        .run()
        .unwrap_or_else(|e| {
            eprintln!("Error: {e}");
            process::exit(1);
        });

    println!("{} interval(s) analyzed.", samples.len());
    println!();

    // Print first 20 samples to avoid flooding the terminal.
    let display_count = samples.len().min(20);
    println!(
        "{:<12}  {:>10}  {:>10}",
        "Time (s)", "Peak dBFS", "RMS dBFS"
    );
    println!("{}", "-".repeat(38));
    for s in samples.iter().take(display_count) {
        let secs = s.timestamp.as_secs_f64();
        println!(
            "{secs:<12.3}  {:>10}  {:>10}",
            fmt_db(s.peak_db),
            fmt_db(s.rms_db)
        );
    }
    if samples.len() > display_count {
        println!("  … ({} more intervals)", samples.len() - display_count);
    }
}