Struct BpmDetection 

pub struct BpmDetection { /* private fields */ }

Result from BPM detection containing up to 5 candidates sorted by confidence.

Implementations

impl BpmDetection

pub fn from_array(arr: [(f32, f32); 5]) -> Self

Creates a new detection result from an array of candidates.

pub fn with_beats(arr: [(f32, f32); 5], beat_timings: Vec<BeatTiming>) -> Self

Creates a new detection result with beat timings.

pub fn top_candidate(&self) -> Option<&BpmCandidate>

Returns the top BPM candidate (highest confidence).

pub fn candidates(&self) -> &[BpmCandidate]

Returns all candidates.

pub fn bpm(&self) -> Option<f32>

Returns the most likely BPM value.

Examples found in repository

examples/beat_timing.rs (line 21)

fn main() -> Result<(), bpm_analyzer::Error> {
    // Configure the analyzer for electronic music
    let config = AnalyzerConfig::electronic();

    println!("Starting BPM analyzer...");
    println!("Listening for beats and tempo...\n");

    // Start the analyzer
    let receiver = begin(config)?;

    // Process detections
    for detection in receiver.iter() {
        // Print BPM if detected
        if let Some(bpm) = detection.bpm() {
            println!("🎵 Detected BPM: {:.1}", bpm);
        }

        // Print beat timings
        if let Some(last_beat) = detection.last_beat() {
            print!(
                "🥁 Beat at {:.2}s (strength: {:.2})",
                last_beat.time_seconds, last_beat.strength
            );

            // Show beat interval if we have at least 2 beats
            if let Some(interval) = detection.last_beat_interval() {
                let instant_bpm = 60.0 / interval;
                print!(" | Interval: {:.3}s ({:.1} BPM)", interval, instant_bpm);
            }
            println!();
        }

        // Print all recent beat timings
        let beats = detection.beat_timings();
        if beats.len() >= 4 {
            println!("📊 Recent beats: {} detected", beats.len());
            for (i, beat) in beats.iter().rev().take(4).enumerate() {
                println!(
                    "   {} {:.2}s ago (strength: {:.2})",
                    if i == 0 { "•" } else { " " },
                    beats.last().unwrap().time_seconds - beat.time_seconds,
                    beat.strength
                );
            }
        }

        println!();
    }

    Ok(())
}

pub fn in_range(&self, min: f32, max: f32) -> Vec<BpmCandidate>

Returns candidates within a specific BPM range.

pub fn beat_timings(&self) -> &[BeatTiming]

Returns the detected beat timings.

Examples found in repository

examples/beat_timing.rs (line 41)

fn main() -> Result<(), bpm_analyzer::Error> {
    // Configure the analyzer for electronic music
    let config = AnalyzerConfig::electronic();

    println!("Starting BPM analyzer...");
    println!("Listening for beats and tempo...\n");

    // Start the analyzer
    let receiver = begin(config)?;

    // Process detections
    for detection in receiver.iter() {
        // Print BPM if detected
        if let Some(bpm) = detection.bpm() {
            println!("🎵 Detected BPM: {:.1}", bpm);
        }

        // Print beat timings
        if let Some(last_beat) = detection.last_beat() {
            print!(
                "🥁 Beat at {:.2}s (strength: {:.2})",
                last_beat.time_seconds, last_beat.strength
            );

            // Show beat interval if we have at least 2 beats
            if let Some(interval) = detection.last_beat_interval() {
                let instant_bpm = 60.0 / interval;
                print!(" | Interval: {:.3}s ({:.1} BPM)", interval, instant_bpm);
            }
            println!();
        }

        // Print all recent beat timings
        let beats = detection.beat_timings();
        if beats.len() >= 4 {
            println!("📊 Recent beats: {} detected", beats.len());
            for (i, beat) in beats.iter().rev().take(4).enumerate() {
                println!(
                    "   {} {:.2}s ago (strength: {:.2})",
                    if i == 0 { "•" } else { " " },
                    beats.last().unwrap().time_seconds - beat.time_seconds,
                    beat.strength
                );
            }
        }

        println!();
    }

    Ok(())
}

pub fn last_beat(&self) -> Option<&BeatTiming>

Returns the most recent beat timing, if available.

Examples found in repository

examples/beat_timing.rs (line 26)

fn main() -> Result<(), bpm_analyzer::Error> {
    // Configure the analyzer for electronic music
    let config = AnalyzerConfig::electronic();

    println!("Starting BPM analyzer...");
    println!("Listening for beats and tempo...\n");

    // Start the analyzer
    let receiver = begin(config)?;

    // Process detections
    for detection in receiver.iter() {
        // Print BPM if detected
        if let Some(bpm) = detection.bpm() {
            println!("🎵 Detected BPM: {:.1}", bpm);
        }

        // Print beat timings
        if let Some(last_beat) = detection.last_beat() {
            print!(
                "🥁 Beat at {:.2}s (strength: {:.2})",
                last_beat.time_seconds, last_beat.strength
            );

            // Show beat interval if we have at least 2 beats
            if let Some(interval) = detection.last_beat_interval() {
                let instant_bpm = 60.0 / interval;
                print!(" | Interval: {:.3}s ({:.1} BPM)", interval, instant_bpm);
            }
            println!();
        }

        // Print all recent beat timings
        let beats = detection.beat_timings();
        if beats.len() >= 4 {
            println!("📊 Recent beats: {} detected", beats.len());
            for (i, beat) in beats.iter().rev().take(4).enumerate() {
                println!(
                    "   {} {:.2}s ago (strength: {:.2})",
                    if i == 0 { "•" } else { " " },
                    beats.last().unwrap().time_seconds - beat.time_seconds,
                    beat.strength
                );
            }
        }

        println!();
    }

    Ok(())
}

pub fn last_beat_interval(&self) -> Option<f64>

Returns the time interval between the last two beats, if available.

Examples found in repository

examples/beat_timing.rs (line 33)

fn main() -> Result<(), bpm_analyzer::Error> {
    // Configure the analyzer for electronic music
    let config = AnalyzerConfig::electronic();

    println!("Starting BPM analyzer...");
    println!("Listening for beats and tempo...\n");

    // Start the analyzer
    let receiver = begin(config)?;

    // Process detections
    for detection in receiver.iter() {
        // Print BPM if detected
        if let Some(bpm) = detection.bpm() {
            println!("🎵 Detected BPM: {:.1}", bpm);
        }

        // Print beat timings
        if let Some(last_beat) = detection.last_beat() {
            print!(
                "🥁 Beat at {:.2}s (strength: {:.2})",
                last_beat.time_seconds, last_beat.strength
            );

            // Show beat interval if we have at least 2 beats
            if let Some(interval) = detection.last_beat_interval() {
                let instant_bpm = 60.0 / interval;
                print!(" | Interval: {:.3}s ({:.1} BPM)", interval, instant_bpm);
            }
            println!();
        }

        // Print all recent beat timings
        let beats = detection.beat_timings();
        if beats.len() >= 4 {
            println!("📊 Recent beats: {} detected", beats.len());
            for (i, beat) in beats.iter().rev().take(4).enumerate() {
                println!(
                    "   {} {:.2}s ago (strength: {:.2})",
                    if i == 0 { "•" } else { " " },
                    beats.last().unwrap().time_seconds - beat.time_seconds,
                    beat.strength
                );
            }
        }

        println!();
    }

    Ok(())
}

Trait Implementations

impl Clone for BpmDetection

fn clone(&self) -> BpmDetection

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for BpmDetection

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.