Skip to main content

SilenceDetector

ff_analysis::analysis

Struct SilenceDetector

pub struct SilenceDetector { /* private fields */ }

Expand description

Detects silent intervals in an audio file and returns their time ranges.

Uses FFmpeg’s silencedetect filter to identify audio segments whose amplitude stays below threshold_db for at least min_duration. Only complete intervals (silence start and end detected) are reported; a trailing silence that runs to end-of-file without an explicit end marker is not included.

§Examples

use ff_analysis::SilenceDetector;
use std::time::Duration;

let ranges = SilenceDetector::new("audio.mp3")
    .threshold_db(-40.0)
    .min_duration(Duration::from_millis(500))
    .run()?;

for r in &ranges {
    println!("Silence {:?}–{:?}", r.start, r.end);
}

Implementations§

impl SilenceDetector

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

Creates a new detector for the given audio file.

Defaults: threshold_db = -40.0, min_duration = 500 ms.

Examples found in repository ?

examples/silence_detection.rs (line 67)

24fn main() {
25    let mut args = std::env::args().skip(1);
26    let mut input = None::<String>;
27    let mut threshold_db = -40.0_f32;
28    let mut min_duration_ms = 500u64;
29
30    while let Some(flag) = args.next() {
31        match flag.as_str() {
32            "--input" | "-i" => input = Some(args.next().unwrap_or_default()),
33            "--threshold-db" => {
34                let raw = args.next().unwrap_or_default();
35                threshold_db = raw.parse().unwrap_or_else(|_| {
36                    eprintln!("Invalid threshold-db: {raw}");
37                    process::exit(1);
38                });
39            }
40            "--min-duration-ms" => {
41                let raw = args.next().unwrap_or_default();
42                min_duration_ms = raw.parse().unwrap_or_else(|_| {
43                    eprintln!("Invalid min-duration-ms: {raw}");
44                    process::exit(1);
45                });
46            }
47            other => {
48                eprintln!("Unknown flag: {other}");
49                process::exit(1);
50            }
51        }
52    }
53
54    let input = input.unwrap_or_else(|| {
55        eprintln!(
56            "Usage: silence_detection --input <audio> \
57             [--threshold-db <dB>] [--min-duration-ms <ms>]"
58        );
59        process::exit(1);
60    });
61
62    println!("Detecting silence in: {input}");
63    println!("Threshold: {threshold_db:.1} dBFS");
64    println!("Minimum duration: {min_duration_ms} ms");
65    println!();
66
67    let ranges: Vec<SilenceRange> = SilenceDetector::new(&input)
68        .threshold_db(threshold_db)
69        .min_duration(Duration::from_millis(min_duration_ms))
70        .run()
71        .unwrap_or_else(|e| {
72            eprintln!("Error: {e}");
73            process::exit(1);
74        });
75
76    if ranges.is_empty() {
77        println!("No silence detected.");
78    } else {
79        println!("Detected {} silent interval(s):", ranges.len());
80        println!("{:<14}  {:<14}  {:<12}", "Start", "End", "Duration");
81        println!("{}", "-".repeat(44));
82        for r in &ranges {
83            let duration = r.end.saturating_sub(r.start);
84            println!(
85                "{:<14}  {:<14}  {:<12}",
86                fmt_duration(r.start),
87                fmt_duration(r.end),
88                fmt_duration(duration)
89            );
90        }
91    }
92}

pub fn threshold_db(self, db: f32) -> Self

Sets the amplitude threshold in dBFS.

Audio samples below this level are considered silent. The value should be negative (e.g. -40.0 for −40 dBFS).

Default: -40.0 dB.

Examples found in repository ?

examples/silence_detection.rs (line 68)

24fn main() {
25    let mut args = std::env::args().skip(1);
26    let mut input = None::<String>;
27    let mut threshold_db = -40.0_f32;
28    let mut min_duration_ms = 500u64;
29
30    while let Some(flag) = args.next() {
31        match flag.as_str() {
32            "--input" | "-i" => input = Some(args.next().unwrap_or_default()),
33            "--threshold-db" => {
34                let raw = args.next().unwrap_or_default();
35                threshold_db = raw.parse().unwrap_or_else(|_| {
36                    eprintln!("Invalid threshold-db: {raw}");
37                    process::exit(1);
38                });
39            }
40            "--min-duration-ms" => {
41                let raw = args.next().unwrap_or_default();
42                min_duration_ms = raw.parse().unwrap_or_else(|_| {
43                    eprintln!("Invalid min-duration-ms: {raw}");
44                    process::exit(1);
45                });
46            }
47            other => {
48                eprintln!("Unknown flag: {other}");
49                process::exit(1);
50            }
51        }
52    }
53
54    let input = input.unwrap_or_else(|| {
55        eprintln!(
56            "Usage: silence_detection --input <audio> \
57             [--threshold-db <dB>] [--min-duration-ms <ms>]"
58        );
59        process::exit(1);
60    });
61
62    println!("Detecting silence in: {input}");
63    println!("Threshold: {threshold_db:.1} dBFS");
64    println!("Minimum duration: {min_duration_ms} ms");
65    println!();
66
67    let ranges: Vec<SilenceRange> = SilenceDetector::new(&input)
68        .threshold_db(threshold_db)
69        .min_duration(Duration::from_millis(min_duration_ms))
70        .run()
71        .unwrap_or_else(|e| {
72            eprintln!("Error: {e}");
73            process::exit(1);
74        });
75
76    if ranges.is_empty() {
77        println!("No silence detected.");
78    } else {
79        println!("Detected {} silent interval(s):", ranges.len());
80        println!("{:<14}  {:<14}  {:<12}", "Start", "End", "Duration");
81        println!("{}", "-".repeat(44));
82        for r in &ranges {
83            let duration = r.end.saturating_sub(r.start);
84            println!(
85                "{:<14}  {:<14}  {:<12}",
86                fmt_duration(r.start),
87                fmt_duration(r.end),
88                fmt_duration(duration)
89            );
90        }
91    }
92}

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

Sets the minimum duration a silent segment must last to be reported.

Silence shorter than this value is ignored.

Default: 500 ms.

Examples found in repository ?

examples/silence_detection.rs (line 69)

24fn main() {
25    let mut args = std::env::args().skip(1);
26    let mut input = None::<String>;
27    let mut threshold_db = -40.0_f32;
28    let mut min_duration_ms = 500u64;
29
30    while let Some(flag) = args.next() {
31        match flag.as_str() {
32            "--input" | "-i" => input = Some(args.next().unwrap_or_default()),
33            "--threshold-db" => {
34                let raw = args.next().unwrap_or_default();
35                threshold_db = raw.parse().unwrap_or_else(|_| {
36                    eprintln!("Invalid threshold-db: {raw}");
37                    process::exit(1);
38                });
39            }
40            "--min-duration-ms" => {
41                let raw = args.next().unwrap_or_default();
42                min_duration_ms = raw.parse().unwrap_or_else(|_| {
43                    eprintln!("Invalid min-duration-ms: {raw}");
44                    process::exit(1);
45                });
46            }
47            other => {
48                eprintln!("Unknown flag: {other}");
49                process::exit(1);
50            }
51        }
52    }
53
54    let input = input.unwrap_or_else(|| {
55        eprintln!(
56            "Usage: silence_detection --input <audio> \
57             [--threshold-db <dB>] [--min-duration-ms <ms>]"
58        );
59        process::exit(1);
60    });
61
62    println!("Detecting silence in: {input}");
63    println!("Threshold: {threshold_db:.1} dBFS");
64    println!("Minimum duration: {min_duration_ms} ms");
65    println!();
66
67    let ranges: Vec<SilenceRange> = SilenceDetector::new(&input)
68        .threshold_db(threshold_db)
69        .min_duration(Duration::from_millis(min_duration_ms))
70        .run()
71        .unwrap_or_else(|e| {
72            eprintln!("Error: {e}");
73            process::exit(1);
74        });
75
76    if ranges.is_empty() {
77        println!("No silence detected.");
78    } else {
79        println!("Detected {} silent interval(s):", ranges.len());
80        println!("{:<14}  {:<14}  {:<12}", "Start", "End", "Duration");
81        println!("{}", "-".repeat(44));
82        for r in &ranges {
83            let duration = r.end.saturating_sub(r.start);
84            println!(
85                "{:<14}  {:<14}  {:<12}",
86                fmt_duration(r.start),
87                fmt_duration(r.end),
88                fmt_duration(duration)
89            );
90        }
91    }
92}

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

Runs silence detection and returns all detected SilenceRange values.

§Errors

AnalysisError::Failed — input file not found or an internal filter-graph error occurs.

Examples found in repository ?

examples/silence_detection.rs (line 70)

24fn main() {
25    let mut args = std::env::args().skip(1);
26    let mut input = None::<String>;
27    let mut threshold_db = -40.0_f32;
28    let mut min_duration_ms = 500u64;
29
30    while let Some(flag) = args.next() {
31        match flag.as_str() {
32            "--input" | "-i" => input = Some(args.next().unwrap_or_default()),
33            "--threshold-db" => {
34                let raw = args.next().unwrap_or_default();
35                threshold_db = raw.parse().unwrap_or_else(|_| {
36                    eprintln!("Invalid threshold-db: {raw}");
37                    process::exit(1);
38                });
39            }
40            "--min-duration-ms" => {
41                let raw = args.next().unwrap_or_default();
42                min_duration_ms = raw.parse().unwrap_or_else(|_| {
43                    eprintln!("Invalid min-duration-ms: {raw}");
44                    process::exit(1);
45                });
46            }
47            other => {
48                eprintln!("Unknown flag: {other}");
49                process::exit(1);
50            }
51        }
52    }
53
54    let input = input.unwrap_or_else(|| {
55        eprintln!(
56            "Usage: silence_detection --input <audio> \
57             [--threshold-db <dB>] [--min-duration-ms <ms>]"
58        );
59        process::exit(1);
60    });
61
62    println!("Detecting silence in: {input}");
63    println!("Threshold: {threshold_db:.1} dBFS");
64    println!("Minimum duration: {min_duration_ms} ms");
65    println!();
66
67    let ranges: Vec<SilenceRange> = SilenceDetector::new(&input)
68        .threshold_db(threshold_db)
69        .min_duration(Duration::from_millis(min_duration_ms))
70        .run()
71        .unwrap_or_else(|e| {
72            eprintln!("Error: {e}");
73            process::exit(1);
74        });
75
76    if ranges.is_empty() {
77        println!("No silence detected.");
78    } else {
79        println!("Detected {} silent interval(s):", ranges.len());
80        println!("{:<14}  {:<14}  {:<12}", "Start", "End", "Duration");
81        println!("{}", "-".repeat(44));
82        for r in &ranges {
83            let duration = r.end.saturating_sub(r.start);
84            println!(
85                "{:<14}  {:<14}  {:<12}",
86                fmt_duration(r.start),
87                fmt_duration(r.end),
88                fmt_duration(duration)
89            );
90        }
91    }
92}

Auto Trait Implementations§

impl Freeze for SilenceDetector

impl RefUnwindSafe for SilenceDetector

impl Send for SilenceDetector

impl Sync for SilenceDetector

impl Unpin for SilenceDetector

impl UnsafeUnpin for SilenceDetector

impl UnwindSafe for SilenceDetector

Blanket Implementations§

impl<T> Any for T
where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

impl<T> Borrow<T> for T
where T: ?Sized,

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

impl<T> BorrowMut<T> for T
where T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

impl<T> From<T> for T

fn from(t: T) -> T

Returns the argument unchanged.

impl<T, U> Into<U> for T
where U: From<T>,

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

impl<T, U> TryFrom<U> for T
where U: Into<T>,

type Error = !

The type returned in the event of a conversion error.

fn try_from(value: U) -> Result<T, !>

Performs the conversion.

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.