Struct ScopeAnalyzer 

pub struct ScopeAnalyzer;

Scope analysis utilities for decoded video frames.

All methods are associated functions (no instance state).

Implementations

impl ScopeAnalyzer

pub fn waveform(frame: &VideoFrame) -> Vec<Vec<f32>>

Compute waveform monitor data for frame.

Returns a Vec of length frame.width(). Each inner Vec contains the normalised Y (luma) values [0.0, 1.0] of every pixel in that column, ordered top-to-bottom.

Only yuv420p, yuv422p, and yuv444p pixel formats are supported. Returns an empty Vec for unsupported formats or if Y-plane data is unavailable.

pub fn vectorscope(frame: &VideoFrame) -> Vec<(f32, f32)>

Compute vectorscope data for frame.

Returns a Vec of (cb, cr) pairs, one per chroma sample, with both values normalised to [-0.5, 0.5].

Chroma dimensions vary by format:

• yuv420p — (width/2) × (height/2) samples
• yuv422p — (width/2) × height samples
• yuv444p — width × height samples

Returns an empty Vec for unsupported formats or if chroma plane data is unavailable.

Examples found in repository

examples/scope_analyzer.rs (line 122)

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

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

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

    let mut decoder = match VideoDecoder::open(&input).build() {
        Ok(d) => d,
        Err(e) => {
            eprintln!("Error opening video: {e}");
            process::exit(1);
        }
    };

    println!("Scope analysis: {input}");
    println!("Sampling every {interval_frames} frame(s)");
    println!();

    let mut frame_count: u64 = 0;
    let mut sample_count: u64 = 0;

    loop {
        let frame = match decoder.decode_one() {
            Ok(Some(f)) => f,
            Ok(None) => break,
            Err(e) => {
                eprintln!("Decode error: {e}");
                process::exit(1);
            }
        };

        if frame_count.is_multiple_of(interval_frames) {
            let scatter = ScopeAnalyzer::vectorscope(&frame);
            let parade = ScopeAnalyzer::rgb_parade(&frame);
            print_vectorscope_summary(frame_count, &scatter);
            print_rgb_parade_summary(frame_count, &parade);
            sample_count += 1;
        }

        frame_count += 1;
    }

    println!();
    println!("Decoded {frame_count} frame(s), sampled {sample_count}.");
}

pub fn rgb_parade(frame: &VideoFrame) -> RgbParade

Compute RGB parade data for frame.

Each pixel is converted from YUV to RGB using the BT.601 full-range matrix before sampling. Returns an RgbParade whose r, g, and b fields each have the same column-major shape as ScopeAnalyzer::waveform.

Only yuv420p, yuv422p, and yuv444p pixel formats are supported. Returns RgbParade { r: vec![], g: vec![], b: vec![] } for unsupported formats or if plane data is unavailable.

Examples found in repository

examples/scope_analyzer.rs (line 123)

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

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

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

    let mut decoder = match VideoDecoder::open(&input).build() {
        Ok(d) => d,
        Err(e) => {
            eprintln!("Error opening video: {e}");
            process::exit(1);
        }
    };

    println!("Scope analysis: {input}");
    println!("Sampling every {interval_frames} frame(s)");
    println!();

    let mut frame_count: u64 = 0;
    let mut sample_count: u64 = 0;

    loop {
        let frame = match decoder.decode_one() {
            Ok(Some(f)) => f,
            Ok(None) => break,
            Err(e) => {
                eprintln!("Decode error: {e}");
                process::exit(1);
            }
        };

        if frame_count.is_multiple_of(interval_frames) {
            let scatter = ScopeAnalyzer::vectorscope(&frame);
            let parade = ScopeAnalyzer::rgb_parade(&frame);
            print_vectorscope_summary(frame_count, &scatter);
            print_rgb_parade_summary(frame_count, &parade);
            sample_count += 1;
        }

        frame_count += 1;
    }

    println!();
    println!("Decoded {frame_count} frame(s), sampled {sample_count}.");
}

pub fn histogram(frame: &VideoFrame) -> Histogram

Compute a 256-bin histogram for each channel and for luminance.

For YUV frames luma is read directly from the Y plane; R, G, and B are computed via BT.601 full-range conversion. Bins are indexed by the raw 8-bit value [0, 255].

Only yuv420p, yuv422p, and yuv444p pixel formats are supported. Returns a zeroed Histogram for unsupported formats or if plane data is unavailable.