midly 0.2.2

A pure-rust fast and flexible MIDI parser library, designed for multi-MB files
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

use crate::Smf;
use failure::Fail;
use std::{fs, time::Instant};

/// Open and read the content of a file.
macro_rules! open {
    {$name:ident : $file:expr} => {
        let $name = fs::read(concat!("test-asset/", $file)).unwrap();
    };
}

/// Macro for parsing a MIDI file.
macro_rules! test {
    {($name:expr , $file:expr) => {$method_parse:ident,$method_len:ident}} => {{
        let counts = time($name, ||->Vec<_> {
            open!{smf: $file};
            let smf = match Smf::$method_parse(&smf) {
                Ok(smf) => smf,
                Err(err) => {
                    eprintln!("failed to parse test file:");
                    for cause in (&err as &dyn Fail).iter_chain() {
                        eprintln!("  {}", cause);
                    }
                    panic!()
                },
            };
            smf.tracks.into_iter().map(|track| track.$method_len()).collect()
        });
        for (i,count) in counts.iter().enumerate() {
            println!("track {} has {} events", i, count);
        }
    }};
}

/// Take note of how long it takes to parse.
fn time<F: FnOnce() -> R, R>(activity: &str, op: F) -> R {
    let start = Instant::now();
    let result = op();
    let took = Instant::now() - start;
    println!("{}: {}ms", activity, (took * 1000).as_secs());
    result
}

/// Test the MIDI parser on several files.
mod parse {
    use super::*;

    #[test]
    fn clementi_defer() {
        test!(("parse_clementi_iter","Clementi.mid") => {parse_lazy,count});
    }
    #[test]
    fn clementi_collect() {
        test!(("parse_clementi_vec","Clementi.mid") => {parse,len});
    }

    #[test]
    fn pi_defer() {
        test!(("parse_pi_iter","Pi.mid") => {parse_lazy,count});
    }
    #[test]
    fn pi_collect() {
        test!(("parse_pi_vec","Pi.mid") => {parse,len});
    }

    #[test]
    #[cfg_attr(not(feature = "lenient"), should_panic)]
    fn pidamaged_defer() {
        test!(("parse_pidamaged_iter","PiDamaged.mid") => {parse_lazy,count});
    }
    #[test]
    #[cfg_attr(not(feature = "lenient"), should_panic)]
    fn pidamaged_collect() {
        test!(("parse_pidamaged_vec","PiDamaged.mid") => {parse,len});
    }

    #[test]
    fn levels_defer() {
        test!(("parse_levels_iter","LevelsAvicii.mid") => {parse_lazy,count});
    }
    #[test]
    #[cfg_attr(feature = "strict", should_panic)]
    fn levels_collect() {
        test!(("parse_levels_vec","LevelsAvicii.mid") => {parse,len});
    }
}