Struct SceneDetector 

pub struct SceneDetector { /* private fields */ }

Detects scene changes in a video file and returns their timestamps.

Uses FFmpeg’s select=gt(scene\,threshold) filter to identify frames where the scene changes. The threshold controls detection sensitivity: lower values detect more cuts (including subtle ones); higher values detect only hard cuts.

Examples

use ff_analysis::SceneDetector;

let cuts = SceneDetector::new("video.mp4")
    .threshold(0.3)
    .run()?;

for ts in &cuts {
    println!("Scene change at {:?}", ts);
}

Implementations

impl SceneDetector

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

Creates a new detector for the given video file.

The default detection threshold is 0.4. Call threshold to override it.

Examples found in repository

examples/scene_detection.rs (line 49)

fn main() {
    let mut args = std::env::args().skip(1);
    let mut input = None::<String>;
    let mut threshold = 0.4_f64;

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

    let input = input.unwrap_or_else(|| {
        eprintln!("Usage: scene_detection --input <video> [--threshold <0.0–1.0>]");
        process::exit(1);
    });

    println!("Detecting scene changes in: {input}");
    println!("Threshold: {threshold:.2}");
    println!();

    let cuts = SceneDetector::new(&input)
        .threshold(threshold)
        .run()
        .unwrap_or_else(|e| {
            eprintln!("Error: {e}");
            process::exit(1);
        });

    if cuts.is_empty() {
        println!("No scene changes detected.");
    } else {
        println!("Detected {} scene change(s):", cuts.len());
        for (i, ts) in cuts.iter().enumerate() {
            let secs = ts.as_secs_f64();
            let h = ts.as_secs() / 3600;
            let m = (ts.as_secs() % 3600) / 60;
            let s = ts.as_secs() % 60;
            let ms = ts.subsec_millis();
            println!("  [{i:3}] {h:02}:{m:02}:{s:02}.{ms:03}  ({secs:.3}s)");
        }
    }
}

pub fn threshold(self, t: f64) -> Self

Sets the scene-change detection threshold.

Must be in the range [0.0, 1.0]. Lower values make the detector more sensitive (more cuts reported); higher values require a larger visual difference. Passing a value outside this range causes run to return AnalysisError::Failed.

Default: 0.4.

Examples found in repository

examples/scene_detection.rs (line 50)

fn main() {
    let mut args = std::env::args().skip(1);
    let mut input = None::<String>;
    let mut threshold = 0.4_f64;

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

    let input = input.unwrap_or_else(|| {
        eprintln!("Usage: scene_detection --input <video> [--threshold <0.0–1.0>]");
        process::exit(1);
    });

    println!("Detecting scene changes in: {input}");
    println!("Threshold: {threshold:.2}");
    println!();

    let cuts = SceneDetector::new(&input)
        .threshold(threshold)
        .run()
        .unwrap_or_else(|e| {
            eprintln!("Error: {e}");
            process::exit(1);
        });

    if cuts.is_empty() {
        println!("No scene changes detected.");
    } else {
        println!("Detected {} scene change(s):", cuts.len());
        for (i, ts) in cuts.iter().enumerate() {
            let secs = ts.as_secs_f64();
            let h = ts.as_secs() / 3600;
            let m = (ts.as_secs() % 3600) / 60;
            let s = ts.as_secs() % 60;
            let ms = ts.subsec_millis();
            println!("  [{i:3}] {h:02}:{m:02}:{s:02}.{ms:03}  ({secs:.3}s)");
        }
    }
}

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

Runs scene-change detection and returns one Duration per detected cut.

Timestamps are sorted in ascending order and represent the PTS of the first frame of each new scene.

Errors

• AnalysisError::Failed — threshold outside [0.0, 1.0], input file not found, or an internal filter-graph error.

Examples found in repository

examples/scene_detection.rs (line 51)

fn main() {
    let mut args = std::env::args().skip(1);
    let mut input = None::<String>;
    let mut threshold = 0.4_f64;

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

    let input = input.unwrap_or_else(|| {
        eprintln!("Usage: scene_detection --input <video> [--threshold <0.0–1.0>]");
        process::exit(1);
    });

    println!("Detecting scene changes in: {input}");
    println!("Threshold: {threshold:.2}");
    println!();

    let cuts = SceneDetector::new(&input)
        .threshold(threshold)
        .run()
        .unwrap_or_else(|e| {
            eprintln!("Error: {e}");
            process::exit(1);
        });

    if cuts.is_empty() {
        println!("No scene changes detected.");
    } else {
        println!("Detected {} scene change(s):", cuts.len());
        for (i, ts) in cuts.iter().enumerate() {
            let secs = ts.as_secs_f64();
            let h = ts.as_secs() / 3600;
            let m = (ts.as_secs() % 3600) / 60;
            let s = ts.as_secs() % 60;
            let ms = ts.subsec_millis();
            println!("  [{i:3}] {h:02}:{m:02}:{s:02}.{ms:03}  ({secs:.3}s)");
        }
    }
}