oximedia-mir 0.1.8

Music Information Retrieval (MIR) system for OxiMedia
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

//! Rhythm feature extraction.

pub mod complexity;
pub mod pattern;
pub mod polyrhythm;

pub use complexity::RhythmComplexity;
pub use pattern::RhythmPattern;
pub use polyrhythm::{
    ExtendedRhythmResult, PolyrhythmAnalyzer, PolyrhythmPattern, SyncopationMetrics,
};

use crate::beat::onset::OnsetDetector;
use crate::types::RhythmResult;
use crate::utils::stft;
use crate::MirResult;

/// Rhythm analyzer.
pub struct RhythmAnalyzer {
    sample_rate: f32,
    hop_size: usize,
}

impl RhythmAnalyzer {
    /// Create a new rhythm analyzer.
    #[must_use]
    pub fn new(sample_rate: f32, hop_size: usize) -> Self {
        Self {
            sample_rate,
            hop_size,
        }
    }

    /// Analyze rhythm features.
    ///
    /// # Errors
    ///
    /// Returns error if rhythm analysis fails.
    #[allow(clippy::cast_precision_loss)]
    pub fn analyze(&self, signal: &[f32]) -> MirResult<RhythmResult> {
        // Detect onsets
        let onset_detector = OnsetDetector::new(self.sample_rate, 2048, self.hop_size);
        let onset_times = onset_detector.detect(signal)?;

        // Compute onset strength envelope
        let onset_strength = self.compute_onset_strength(signal)?;

        // Extract rhythm patterns
        let pattern_extractor = RhythmPattern::new();
        let patterns = pattern_extractor.extract(&onset_times);

        // Compute rhythm complexity
        let complexity_analyzer = RhythmComplexity::new();
        let complexity = complexity_analyzer.compute(&onset_times);

        // Compute syncopation
        let syncopation = self.compute_syncopation(&onset_times);

        Ok(RhythmResult {
            onset_strength,
            onset_times,
            patterns,
            complexity,
            syncopation,
        })
    }

    /// Compute onset strength envelope.
    fn compute_onset_strength(&self, signal: &[f32]) -> MirResult<Vec<f32>> {
        let window_size = 2048;
        let frames = stft(signal, window_size, self.hop_size)?;

        let mut onset_strength = Vec::with_capacity(frames.len());
        let mut prev_mag = vec![0.0; window_size / 2 + 1];

        for frame in &frames {
            let mag = crate::utils::magnitude_spectrum(frame);

            // Spectral flux
            let flux: f32 = mag
                .iter()
                .zip(&prev_mag)
                .map(|(m, p)| (m - p).max(0.0))
                .sum();

            onset_strength.push(flux);
            prev_mag = mag;
        }

        Ok(onset_strength)
    }

    /// Compute syncopation measure.
    fn compute_syncopation(&self, onset_times: &[f32]) -> f32 {
        if onset_times.len() < 2 {
            return 0.0;
        }

        // Compute inter-onset intervals
        let mut intervals = Vec::new();
        for i in 1..onset_times.len() {
            intervals.push(onset_times[i] - onset_times[i - 1]);
        }

        // Syncopation based on interval irregularity
        let mean_interval = crate::utils::mean(&intervals);
        if mean_interval == 0.0 {
            return 0.0;
        }

        let variance: f32 = intervals
            .iter()
            .map(|i| (i - mean_interval).powi(2))
            .sum::<f32>()
            / intervals.len() as f32;

        let cv = variance.sqrt() / mean_interval;
        cv.min(1.0)
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_rhythm_analyzer_creation() {
        let analyzer = RhythmAnalyzer::new(44100.0, 512);
        assert_eq!(analyzer.sample_rate, 44100.0);
    }
}