midi_toolkit::io

Struct MIDIFile

Source 
pub struct MIDIFile<T: MIDIReader> { /* private fields */ }

Implementations§

Source§

impl<T: 'static + MIDIReader> MIDIFile<T>

Source

pub fn open_track_reader(&self, track: u32) -> T::ByteReader

Source

pub fn iter_all_tracks( &self, ) -> impl Iterator<Item = impl Iterator<Item = Result<Delta<u64, Event>, MIDIParseError>>>

Examples found in repository?
examples/write.rs (line 21)
10pub fn main() {
11    println!("Opening midi...");
12    let file = MIDIFile::open_in_ram("D:/Midis/tau2.5.9.mid", None).unwrap();
13    let writer = MIDIWriter::new("./out.mid", file.ppq()).unwrap();
14    println!("Parsing midi...");
15    let now = Instant::now();
16
17    let mut nc: u64 = 0;
18    {
19        let mut track_writer = writer.open_next_track();
20        // let merged = pipe!(file.iter_all_tracks()|>to_vec()|>merge_events_array()|>unwrap_items());
21        let converted = file.iter_all_tracks();
22        // .map(|track| pipe!(track|>events_to_notes()|>notes_to_events()));
23        let merged = pipe!(converted|>to_vec()|>merge_events_array()|>unwrap_items());
24        for e in merged {
25            if let Event::NoteOn(_) = *e {
26                nc += 1
27            }
28            track_writer.write_event(e).unwrap();
29        }
30    }
31
32    println!("Finished parsing midi, found {nc} notes");
33    println!("Elapsed {:?}", now.elapsed());
34    println!(
35        "Notes/second {}",
36        (nc as f64 / now.elapsed().as_secs_f64()).round()
37    );
38}
More examples
Hide additional examples
examples/benchmark.rs (line 42)
33fn main() {
34    let filename = "D:/Midis/Ra Ra Rasputin Ultimate Black MIDI Final.mid";
35    let repeats = 4;
36
37    println!("Opening midi...");
38    let file = MIDIFile::open(filename, None).unwrap();
39
40    println!("Tracks: {}", file.track_count());
41
42    let loaded_tracks = to_vec(file.iter_all_tracks().map(|t| to_vec_result(t).unwrap()));
43
44    let mut nc: u64 = 0;
45    for track in loaded_tracks.iter() {
46        for e in track {
47            if let Event::NoteOn(_) = **e {
48                nc += 1
49            }
50        }
51    }
52    println!("Note count: {nc}");
53
54    do_run("Parse all tracks individually", repeats, || {
55        for track in file.iter_all_tracks() {
56            for _ in pipe!(track) {}
57        }
58    });
59    do_run("Merge all tracks together while parsing", repeats, || {
60        let merged = pipe!(file.iter_all_tracks()|>to_vec()|>merge_events_array());
61        for _ in merged {}
62    });
63    do_run("Clone all events", repeats, || {
64        let iters = pipe!(loaded_tracks.iter().map(|t| pipe!(t.iter().cloned())));
65        for track in iters {
66            for _ in track {}
67        }
68    });
69    do_run(
70        "Clone all events, then wrap and unwrap them in Result",
71        repeats,
72        || {
73            let iters = pipe!(loaded_tracks
74                .iter()
75                .map(|t| pipe!(t.iter().cloned()|>wrap_ok()|>unwrap_items())));
76            for track in iters {
77                for _ in track {}
78            }
79        },
80    );
81    do_run("Merge all tracks together while cloning", repeats, || {
82        let iters =
83            pipe!(loaded_tracks.iter().map(|t| pipe!(t.iter().cloned()|>wrap_ok()))|>to_vec());
84        let merged = pipe!(iters|>merge_events_array());
85        for _ in merged {}
86    });
87    do_run("Write each track while cloning", repeats, || {
88        let output = Cursor::new(Vec::<u8>::new());
89        let writer = MIDIWriter::new_from_stram(Box::new(output), file.ppq()).unwrap();
90
91        let iters = pipe!(loaded_tracks.iter().map(|t| pipe!(t.iter().cloned())));
92        for track in iters {
93            let mut track_writer = writer.open_next_track();
94            for e in track {
95                track_writer.write_event(e).unwrap();
96            }
97        }
98    });
99    do_run("Merge each track while cloning then write", repeats, || {
100        let output = Cursor::new(Vec::<u8>::new());
101        let writer = MIDIWriter::new_from_stram(Box::new(output), file.ppq()).unwrap();
102
103        let iters =
104            pipe!(loaded_tracks.iter().map(|t| pipe!(t.iter().cloned()|>wrap_ok()))|>to_vec());
105        let merged = pipe!(iters|>merge_events_array()|>unwrap_items());
106        let mut track_writer = writer.open_next_track();
107        for e in merged {
108            track_writer.write_event(e).unwrap();
109        }
110    });
111}
examples/parse_benchmark.rs (line 45)
35fn main() {
36    let filename = "D:/Midis/toilet story 3 2020 ver 3840 black with tempo.mid";
37    let repeats = 4;
38
39    println!("Opening midi...");
40    let file = MIDIFile::open(filename, None).unwrap();
41
42    println!("Tracks: {}", file.track_count());
43
44    // Make windows cache stuff
45    let tracks = file.iter_all_tracks().collect();
46    let stats = get_channels_array_statistics(tracks).unwrap();
47
48    println!("Note count: {}", stats.note_count());
49
50    do_run("Parse tracks in parallel", repeats, || {
51        let tracks = file.iter_all_tracks().collect();
52        let stats = get_channels_array_statistics(tracks).unwrap();
53        stats.note_count()
54    });
55
56    do_run("Iter event batches merged", repeats, || {
57        let ppq = file.ppq();
58        let merged = pipe!(
59            file.iter_all_track_events_merged_batches()
60            |>TimeCaster::<f64>::cast_event_delta()
61            |>cancel_tempo_events(250000)
62            |>scale_event_time(1.0 / ppq as f64)
63            |>unwrap_items()
64        );
65
66        let mut note_count = 0;
67        for batch in merged {
68            for e in batch.into_iter() {
69                if let Event::NoteOn(_) = e.as_event() {
70                    note_count += 1
71                }
72            }
73        }
74
75        note_count
76    });
77
78    // do_run("Merge all tracks together while parsing", repeats, || {
79    //     let merged = pipe!(file.iter_all_tracks()|>to_vec()|>merge_events_array());
80    //     for _ in merged {}
81    // });
82    // do_run("Clone all events", repeats, || {
83    //     let iters = pipe!(loaded_tracks.iter().map(|t| pipe!(t.iter().cloned())));
84    //     for track in iters {
85    //         for _ in track {}
86    //     }
87    // });
88    // do_run(
89    //     "Clone all events, then wrap and unwrap them in Result",
90    //     repeats,
91    //     || {
92    //         let iters = pipe!(loaded_tracks
93    //             .iter()
94    //             .map(|t| pipe!(t.iter().cloned()|>wrap_ok()|>unwrap_items())));
95    //         for track in iters {
96    //             for _ in track {}
97    //         }
98    //     },
99    // );
100    // do_run("Merge all tracks together while cloning", repeats, || {
101    //     let iters =
102    //         pipe!(loaded_tracks.iter().map(|t| pipe!(t.iter().cloned()|>wrap_ok()))|>to_vec());
103    //     let merged = pipe!(iters|>merge_events_array());
104    //     for _ in merged {}
105    // });
106    // do_run("Write each track while cloning", repeats, || {
107    //     let output = Cursor::new(Vec::<u8>::new());
108    //     let writer = MIDIWriter::new_from_stram(Box::new(output), file.ppq()).unwrap();
109
110    //     let iters = pipe!(loaded_tracks.iter().map(|t| pipe!(t.iter().cloned())));
111    //     for track in iters {
112    //         let mut track_writer = writer.open_next_track();
113    //         for e in track {
114    //             track_writer.write_event(e).unwrap();
115    //         }
116    //     }
117    // });
118    // do_run("Merge each track while cloning then write", repeats, || {
119    //     let output = Cursor::new(Vec::<u8>::new());
120    //     let writer = MIDIWriter::new_from_stram(Box::new(output), file.ppq()).unwrap();
121
122    //     let iters =
123    //         pipe!(loaded_tracks.iter().map(|t| pipe!(t.iter().cloned()|>wrap_ok()))|>to_vec());
124    //     let merged = pipe!(iters|>merge_events_array()|>unwrap_items());
125    //     let mut track_writer = writer.open_next_track();
126    //     for e in merged {
127    //         track_writer.write_event(e).unwrap();
128    //     }
129    // });
130}
Source

pub fn iter_all_events_merged( &self, ) -> impl Iterator<Item = Result<Delta<u64, Event>, MIDIParseError>>

Source

pub fn iter_all_track_events_merged( &self, ) -> impl Iterator<Item = Result<Delta<u64, Track<Event>>, MIDIParseError>>

Source

pub fn iter_all_events_merged_batches( &self, ) -> impl Iterator<Item = Result<Delta<u64, EventBatch<Event>>, MIDIParseError>>

Source

pub fn iter_all_track_events_merged_batches( &self, ) -> impl Iterator<Item = Result<Delta<u64, Track<EventBatch<Event>>>, MIDIParseError>>

Source

pub fn iter_track( &self, track: u32, ) -> impl Iterator<Item = Result<Delta<u64, Event>, MIDIParseError>>

Source

pub fn ppq(&self) -> u16

Examples found in repository?
examples/nps_bench.rs (line 21)
13pub fn main() {
14    println!("Opening midi...");
15    let midi = MIDIFile::open_in_ram(
16        "/mnt/fat/Midis/Ra Ra Rasputin Ultimate Black MIDI Final.mid",
17        None,
18    )
19    .unwrap();
20
21    let ppq = midi.ppq();
22    let merged = pipe!(
23        midi.iter_all_track_events_merged_batches()
24        |>TimeCaster::<f64>::cast_event_delta()
25        |>cancel_tempo_events(250000)
26        |>scale_event_time(1.0 / ppq as f64)
27        |>unwrap_items()
28    );
29
30    println!("Tracks: {}", midi.track_count());
31
32    let start = Instant::now();
33    let mut note_count = 0;
34    for batch in merged {
35        for e in batch.iter_events() {
36            if let Event::NoteOn(_) = e.as_event() {
37                note_count += 1;
38            }
39        }
40    }
41
42    println!("Note count: {}   \tTime: {:?}", note_count, start.elapsed());
43    println!(
44        "Notes per second: {}",
45        note_count as f64 / start.elapsed().as_secs_f64()
46    );
47}
More examples
Hide additional examples
examples/statistics.rs (line 36)
20fn main() {
21    println!("Opening midi...");
22    let file = MIDIFile::open_in_ram("D:/Midis/tau2.5.9.mid", None).unwrap();
23    println!("Parsing midi...");
24
25    let now = Instant::now();
26    let stats1 = pipe!(
27        file.iter_all_tracks()
28        |>to_vec()
29        |>merge_events_array()
30        |>get_channel_statistics().unwrap()
31    );
32
33    println!("Calculated merged stats in {:?}", now.elapsed());
34    println!(
35        "MIDI length: {}",
36        duration_to_minutes_seconds(stats1.calculate_total_duration(file.ppq()))
37    );
38    println!("Other stats: {stats1:#?}\n\n");
39
40    let now = Instant::now();
41    let stats2 = pipe!(
42        file.iter_all_tracks()|>to_vec()|>get_channels_array_statistics().unwrap()
43    );
44    println!("Calculated multithreaded stats in {:?}", now.elapsed());
45    println!(
46        "MIDI length: {}",
47        duration_to_minutes_seconds(stats2.calculate_total_duration(file.ppq()))
48    );
49    println!("Other stats: {stats2:#?}");
50}
examples/write.rs (line 13)
10pub fn main() {
11    println!("Opening midi...");
12    let file = MIDIFile::open_in_ram("D:/Midis/tau2.5.9.mid", None).unwrap();
13    let writer = MIDIWriter::new("./out.mid", file.ppq()).unwrap();
14    println!("Parsing midi...");
15    let now = Instant::now();
16
17    let mut nc: u64 = 0;
18    {
19        let mut track_writer = writer.open_next_track();
20        // let merged = pipe!(file.iter_all_tracks()|>to_vec()|>merge_events_array()|>unwrap_items());
21        let converted = file.iter_all_tracks();
22        // .map(|track| pipe!(track|>events_to_notes()|>notes_to_events()));
23        let merged = pipe!(converted|>to_vec()|>merge_events_array()|>unwrap_items());
24        for e in merged {
25            if let Event::NoteOn(_) = *e {
26                nc += 1
27            }
28            track_writer.write_event(e).unwrap();
29        }
30    }
31
32    println!("Finished parsing midi, found {nc} notes");
33    println!("Elapsed {:?}", now.elapsed());
34    println!(
35        "Notes/second {}",
36        (nc as f64 / now.elapsed().as_secs_f64()).round()
37    );
38}
examples/benchmark.rs (line 89)
33fn main() {
34    let filename = "D:/Midis/Ra Ra Rasputin Ultimate Black MIDI Final.mid";
35    let repeats = 4;
36
37    println!("Opening midi...");
38    let file = MIDIFile::open(filename, None).unwrap();
39
40    println!("Tracks: {}", file.track_count());
41
42    let loaded_tracks = to_vec(file.iter_all_tracks().map(|t| to_vec_result(t).unwrap()));
43
44    let mut nc: u64 = 0;
45    for track in loaded_tracks.iter() {
46        for e in track {
47            if let Event::NoteOn(_) = **e {
48                nc += 1
49            }
50        }
51    }
52    println!("Note count: {nc}");
53
54    do_run("Parse all tracks individually", repeats, || {
55        for track in file.iter_all_tracks() {
56            for _ in pipe!(track) {}
57        }
58    });
59    do_run("Merge all tracks together while parsing", repeats, || {
60        let merged = pipe!(file.iter_all_tracks()|>to_vec()|>merge_events_array());
61        for _ in merged {}
62    });
63    do_run("Clone all events", repeats, || {
64        let iters = pipe!(loaded_tracks.iter().map(|t| pipe!(t.iter().cloned())));
65        for track in iters {
66            for _ in track {}
67        }
68    });
69    do_run(
70        "Clone all events, then wrap and unwrap them in Result",
71        repeats,
72        || {
73            let iters = pipe!(loaded_tracks
74                .iter()
75                .map(|t| pipe!(t.iter().cloned()|>wrap_ok()|>unwrap_items())));
76            for track in iters {
77                for _ in track {}
78            }
79        },
80    );
81    do_run("Merge all tracks together while cloning", repeats, || {
82        let iters =
83            pipe!(loaded_tracks.iter().map(|t| pipe!(t.iter().cloned()|>wrap_ok()))|>to_vec());
84        let merged = pipe!(iters|>merge_events_array());
85        for _ in merged {}
86    });
87    do_run("Write each track while cloning", repeats, || {
88        let output = Cursor::new(Vec::<u8>::new());
89        let writer = MIDIWriter::new_from_stram(Box::new(output), file.ppq()).unwrap();
90
91        let iters = pipe!(loaded_tracks.iter().map(|t| pipe!(t.iter().cloned())));
92        for track in iters {
93            let mut track_writer = writer.open_next_track();
94            for e in track {
95                track_writer.write_event(e).unwrap();
96            }
97        }
98    });
99    do_run("Merge each track while cloning then write", repeats, || {
100        let output = Cursor::new(Vec::<u8>::new());
101        let writer = MIDIWriter::new_from_stram(Box::new(output), file.ppq()).unwrap();
102
103        let iters =
104            pipe!(loaded_tracks.iter().map(|t| pipe!(t.iter().cloned()|>wrap_ok()))|>to_vec());
105        let merged = pipe!(iters|>merge_events_array()|>unwrap_items());
106        let mut track_writer = writer.open_next_track();
107        for e in merged {
108            track_writer.write_event(e).unwrap();
109        }
110    });
111}
examples/parse_benchmark.rs (line 57)
35fn main() {
36    let filename = "D:/Midis/toilet story 3 2020 ver 3840 black with tempo.mid";
37    let repeats = 4;
38
39    println!("Opening midi...");
40    let file = MIDIFile::open(filename, None).unwrap();
41
42    println!("Tracks: {}", file.track_count());
43
44    // Make windows cache stuff
45    let tracks = file.iter_all_tracks().collect();
46    let stats = get_channels_array_statistics(tracks).unwrap();
47
48    println!("Note count: {}", stats.note_count());
49
50    do_run("Parse tracks in parallel", repeats, || {
51        let tracks = file.iter_all_tracks().collect();
52        let stats = get_channels_array_statistics(tracks).unwrap();
53        stats.note_count()
54    });
55
56    do_run("Iter event batches merged", repeats, || {
57        let ppq = file.ppq();
58        let merged = pipe!(
59            file.iter_all_track_events_merged_batches()
60            |>TimeCaster::<f64>::cast_event_delta()
61            |>cancel_tempo_events(250000)
62            |>scale_event_time(1.0 / ppq as f64)
63            |>unwrap_items()
64        );
65
66        let mut note_count = 0;
67        for batch in merged {
68            for e in batch.into_iter() {
69                if let Event::NoteOn(_) = e.as_event() {
70                    note_count += 1
71                }
72            }
73        }
74
75        note_count
76    });
77
78    // do_run("Merge all tracks together while parsing", repeats, || {
79    //     let merged = pipe!(file.iter_all_tracks()|>to_vec()|>merge_events_array());
80    //     for _ in merged {}
81    // });
82    // do_run("Clone all events", repeats, || {
83    //     let iters = pipe!(loaded_tracks.iter().map(|t| pipe!(t.iter().cloned())));
84    //     for track in iters {
85    //         for _ in track {}
86    //     }
87    // });
88    // do_run(
89    //     "Clone all events, then wrap and unwrap them in Result",
90    //     repeats,
91    //     || {
92    //         let iters = pipe!(loaded_tracks
93    //             .iter()
94    //             .map(|t| pipe!(t.iter().cloned()|>wrap_ok()|>unwrap_items())));
95    //         for track in iters {
96    //             for _ in track {}
97    //         }
98    //     },
99    // );
100    // do_run("Merge all tracks together while cloning", repeats, || {
101    //     let iters =
102    //         pipe!(loaded_tracks.iter().map(|t| pipe!(t.iter().cloned()|>wrap_ok()))|>to_vec());
103    //     let merged = pipe!(iters|>merge_events_array());
104    //     for _ in merged {}
105    // });
106    // do_run("Write each track while cloning", repeats, || {
107    //     let output = Cursor::new(Vec::<u8>::new());
108    //     let writer = MIDIWriter::new_from_stram(Box::new(output), file.ppq()).unwrap();
109
110    //     let iters = pipe!(loaded_tracks.iter().map(|t| pipe!(t.iter().cloned())));
111    //     for track in iters {
112    //         let mut track_writer = writer.open_next_track();
113    //         for e in track {
114    //             track_writer.write_event(e).unwrap();
115    //         }
116    //     }
117    // });
118    // do_run("Merge each track while cloning then write", repeats, || {
119    //     let output = Cursor::new(Vec::<u8>::new());
120    //     let writer = MIDIWriter::new_from_stram(Box::new(output), file.ppq()).unwrap();
121
122    //     let iters =
123    //         pipe!(loaded_tracks.iter().map(|t| pipe!(t.iter().cloned()|>wrap_ok()))|>to_vec());
124    //     let merged = pipe!(iters|>merge_events_array()|>unwrap_items());
125    //     let mut track_writer = writer.open_next_track();
126    //     for e in merged {
127    //         track_writer.write_event(e).unwrap();
128    //     }
129    // });
130}
Source

pub fn format(&self) -> u16

Source

pub fn track_count(&self) -> usize

Examples found in repository?
examples/nps_bench.rs (line 30)
13pub fn main() {
14    println!("Opening midi...");
15    let midi = MIDIFile::open_in_ram(
16        "/mnt/fat/Midis/Ra Ra Rasputin Ultimate Black MIDI Final.mid",
17        None,
18    )
19    .unwrap();
20
21    let ppq = midi.ppq();
22    let merged = pipe!(
23        midi.iter_all_track_events_merged_batches()
24        |>TimeCaster::<f64>::cast_event_delta()
25        |>cancel_tempo_events(250000)
26        |>scale_event_time(1.0 / ppq as f64)
27        |>unwrap_items()
28    );
29
30    println!("Tracks: {}", midi.track_count());
31
32    let start = Instant::now();
33    let mut note_count = 0;
34    for batch in merged {
35        for e in batch.iter_events() {
36            if let Event::NoteOn(_) = e.as_event() {
37                note_count += 1;
38            }
39        }
40    }
41
42    println!("Note count: {}   \tTime: {:?}", note_count, start.elapsed());
43    println!(
44        "Notes per second: {}",
45        note_count as f64 / start.elapsed().as_secs_f64()
46    );
47}
More examples
Hide additional examples
examples/benchmark.rs (line 40)
33fn main() {
34    let filename = "D:/Midis/Ra Ra Rasputin Ultimate Black MIDI Final.mid";
35    let repeats = 4;
36
37    println!("Opening midi...");
38    let file = MIDIFile::open(filename, None).unwrap();
39
40    println!("Tracks: {}", file.track_count());
41
42    let loaded_tracks = to_vec(file.iter_all_tracks().map(|t| to_vec_result(t).unwrap()));
43
44    let mut nc: u64 = 0;
45    for track in loaded_tracks.iter() {
46        for e in track {
47            if let Event::NoteOn(_) = **e {
48                nc += 1
49            }
50        }
51    }
52    println!("Note count: {nc}");
53
54    do_run("Parse all tracks individually", repeats, || {
55        for track in file.iter_all_tracks() {
56            for _ in pipe!(track) {}
57        }
58    });
59    do_run("Merge all tracks together while parsing", repeats, || {
60        let merged = pipe!(file.iter_all_tracks()|>to_vec()|>merge_events_array());
61        for _ in merged {}
62    });
63    do_run("Clone all events", repeats, || {
64        let iters = pipe!(loaded_tracks.iter().map(|t| pipe!(t.iter().cloned())));
65        for track in iters {
66            for _ in track {}
67        }
68    });
69    do_run(
70        "Clone all events, then wrap and unwrap them in Result",
71        repeats,
72        || {
73            let iters = pipe!(loaded_tracks
74                .iter()
75                .map(|t| pipe!(t.iter().cloned()|>wrap_ok()|>unwrap_items())));
76            for track in iters {
77                for _ in track {}
78            }
79        },
80    );
81    do_run("Merge all tracks together while cloning", repeats, || {
82        let iters =
83            pipe!(loaded_tracks.iter().map(|t| pipe!(t.iter().cloned()|>wrap_ok()))|>to_vec());
84        let merged = pipe!(iters|>merge_events_array());
85        for _ in merged {}
86    });
87    do_run("Write each track while cloning", repeats, || {
88        let output = Cursor::new(Vec::<u8>::new());
89        let writer = MIDIWriter::new_from_stram(Box::new(output), file.ppq()).unwrap();
90
91        let iters = pipe!(loaded_tracks.iter().map(|t| pipe!(t.iter().cloned())));
92        for track in iters {
93            let mut track_writer = writer.open_next_track();
94            for e in track {
95                track_writer.write_event(e).unwrap();
96            }
97        }
98    });
99    do_run("Merge each track while cloning then write", repeats, || {
100        let output = Cursor::new(Vec::<u8>::new());
101        let writer = MIDIWriter::new_from_stram(Box::new(output), file.ppq()).unwrap();
102
103        let iters =
104            pipe!(loaded_tracks.iter().map(|t| pipe!(t.iter().cloned()|>wrap_ok()))|>to_vec());
105        let merged = pipe!(iters|>merge_events_array()|>unwrap_items());
106        let mut track_writer = writer.open_next_track();
107        for e in merged {
108            track_writer.write_event(e).unwrap();
109        }
110    });
111}
examples/parse_benchmark.rs (line 42)
35fn main() {
36    let filename = "D:/Midis/toilet story 3 2020 ver 3840 black with tempo.mid";
37    let repeats = 4;
38
39    println!("Opening midi...");
40    let file = MIDIFile::open(filename, None).unwrap();
41
42    println!("Tracks: {}", file.track_count());
43
44    // Make windows cache stuff
45    let tracks = file.iter_all_tracks().collect();
46    let stats = get_channels_array_statistics(tracks).unwrap();
47
48    println!("Note count: {}", stats.note_count());
49
50    do_run("Parse tracks in parallel", repeats, || {
51        let tracks = file.iter_all_tracks().collect();
52        let stats = get_channels_array_statistics(tracks).unwrap();
53        stats.note_count()
54    });
55
56    do_run("Iter event batches merged", repeats, || {
57        let ppq = file.ppq();
58        let merged = pipe!(
59            file.iter_all_track_events_merged_batches()
60            |>TimeCaster::<f64>::cast_event_delta()
61            |>cancel_tempo_events(250000)
62            |>scale_event_time(1.0 / ppq as f64)
63            |>unwrap_items()
64        );
65
66        let mut note_count = 0;
67        for batch in merged {
68            for e in batch.into_iter() {
69                if let Event::NoteOn(_) = e.as_event() {
70                    note_count += 1
71                }
72            }
73        }
74
75        note_count
76    });
77
78    // do_run("Merge all tracks together while parsing", repeats, || {
79    //     let merged = pipe!(file.iter_all_tracks()|>to_vec()|>merge_events_array());
80    //     for _ in merged {}
81    // });
82    // do_run("Clone all events", repeats, || {
83    //     let iters = pipe!(loaded_tracks.iter().map(|t| pipe!(t.iter().cloned())));
84    //     for track in iters {
85    //         for _ in track {}
86    //     }
87    // });
88    // do_run(
89    //     "Clone all events, then wrap and unwrap them in Result",
90    //     repeats,
91    //     || {
92    //         let iters = pipe!(loaded_tracks
93    //             .iter()
94    //             .map(|t| pipe!(t.iter().cloned()|>wrap_ok()|>unwrap_items())));
95    //         for track in iters {
96    //             for _ in track {}
97    //         }
98    //     },
99    // );
100    // do_run("Merge all tracks together while cloning", repeats, || {
101    //     let iters =
102    //         pipe!(loaded_tracks.iter().map(|t| pipe!(t.iter().cloned()|>wrap_ok()))|>to_vec());
103    //     let merged = pipe!(iters|>merge_events_array());
104    //     for _ in merged {}
105    // });
106    // do_run("Write each track while cloning", repeats, || {
107    //     let output = Cursor::new(Vec::<u8>::new());
108    //     let writer = MIDIWriter::new_from_stram(Box::new(output), file.ppq()).unwrap();
109
110    //     let iters = pipe!(loaded_tracks.iter().map(|t| pipe!(t.iter().cloned())));
111    //     for track in iters {
112    //         let mut track_writer = writer.open_next_track();
113    //         for e in track {
114    //             track_writer.write_event(e).unwrap();
115    //         }
116    //     }
117    // });
118    // do_run("Merge each track while cloning then write", repeats, || {
119    //     let output = Cursor::new(Vec::<u8>::new());
120    //     let writer = MIDIWriter::new_from_stram(Box::new(output), file.ppq()).unwrap();
121
122    //     let iters =
123    //         pipe!(loaded_tracks.iter().map(|t| pipe!(t.iter().cloned()|>wrap_ok()))|>to_vec());
124    //     let merged = pipe!(iters|>merge_events_array()|>unwrap_items());
125    //     let mut track_writer = writer.open_next_track();
126    //     for e in merged {
127    //         track_writer.write_event(e).unwrap();
128    //     }
129    // });
130}
Source§

impl MIDIFile<DiskReader>

Source

pub fn open( filename: impl AsRef<Path>, read_progress: Option<&mut dyn FnMut(u32)>, ) -> Result<Self, MIDILoadError>

Examples found in repository?
examples/test.rs (line 12)
10pub fn main() {
11    println!("Opening midi...");
12    let file = MIDIFile::open("/run/media/d/Midis/The Quarantine Project.mid", None).unwrap();
13    let now = Instant::now();
14    let mut nc: u64 = 0;
15
16    println!("Creating parsers...");
17    let merged = pipe!(file.iter_all_track_events_merged()|>unwrap_items());
18    println!("Parsing midi...");
19
20    for e in merged {
21        if let Event::NoteOn(_) = e.as_event() {
22            nc += 1;
23        }
24    }
25
26    println!("Finished parsing midi, found {nc} notes");
27    println!("Elapsed {:?}", now.elapsed());
28    println!(
29        "Notes/second {}",
30        (nc as f64 / now.elapsed().as_secs_f64()).round()
31    );
32}
More examples
Hide additional examples
examples/events_notes.rs (line 12)
10pub fn main() {
11    println!("Opening midi...");
12    let file = MIDIFile::open("D:/Midis/tau2.5.9.mid", None).unwrap();
13    println!("Parsing midi...");
14    let now = Instant::now();
15    let mut nc: u64 = 0;
16    // for track in file.iter_all_tracks(true) {
17    //     // let track = TimeCaster::<f64>::cast_event_delta(track);
18    //     for e in pipe!(track|>unwrap_items())
19    //     // for e in pipe!(track|>TimeCaster::<f64>::cast_event_delta()|>scale_event_time(10.0)|>unwrap_items())
20    //     {
21    //         match e {
22    //             Event::NoteOn(_) => nc += 1,
23    //             _ => {}
24    //         }
25    //     }
26    // }
27    let merged = pipe!(file.iter_all_tracks()|>to_vec()|>merge_events_array()|>unwrap_items());
28
29    for e in merged {
30        if let Event::NoteOn(_) = *e {
31            nc += 1
32        }
33        let delta = e.delta;
34        if delta > 184467440737 {
35            dbg!(e);
36        }
37    }
38
39    println!("Finished parsing midi, found {nc} notes");
40    println!("Elapsed {:?}", now.elapsed());
41    println!(
42        "Notes/second {}",
43        (nc as f64 / now.elapsed().as_secs_f64()).round()
44    );
45}
examples/benchmark.rs (line 38)
33fn main() {
34    let filename = "D:/Midis/Ra Ra Rasputin Ultimate Black MIDI Final.mid";
35    let repeats = 4;
36
37    println!("Opening midi...");
38    let file = MIDIFile::open(filename, None).unwrap();
39
40    println!("Tracks: {}", file.track_count());
41
42    let loaded_tracks = to_vec(file.iter_all_tracks().map(|t| to_vec_result(t).unwrap()));
43
44    let mut nc: u64 = 0;
45    for track in loaded_tracks.iter() {
46        for e in track {
47            if let Event::NoteOn(_) = **e {
48                nc += 1
49            }
50        }
51    }
52    println!("Note count: {nc}");
53
54    do_run("Parse all tracks individually", repeats, || {
55        for track in file.iter_all_tracks() {
56            for _ in pipe!(track) {}
57        }
58    });
59    do_run("Merge all tracks together while parsing", repeats, || {
60        let merged = pipe!(file.iter_all_tracks()|>to_vec()|>merge_events_array());
61        for _ in merged {}
62    });
63    do_run("Clone all events", repeats, || {
64        let iters = pipe!(loaded_tracks.iter().map(|t| pipe!(t.iter().cloned())));
65        for track in iters {
66            for _ in track {}
67        }
68    });
69    do_run(
70        "Clone all events, then wrap and unwrap them in Result",
71        repeats,
72        || {
73            let iters = pipe!(loaded_tracks
74                .iter()
75                .map(|t| pipe!(t.iter().cloned()|>wrap_ok()|>unwrap_items())));
76            for track in iters {
77                for _ in track {}
78            }
79        },
80    );
81    do_run("Merge all tracks together while cloning", repeats, || {
82        let iters =
83            pipe!(loaded_tracks.iter().map(|t| pipe!(t.iter().cloned()|>wrap_ok()))|>to_vec());
84        let merged = pipe!(iters|>merge_events_array());
85        for _ in merged {}
86    });
87    do_run("Write each track while cloning", repeats, || {
88        let output = Cursor::new(Vec::<u8>::new());
89        let writer = MIDIWriter::new_from_stram(Box::new(output), file.ppq()).unwrap();
90
91        let iters = pipe!(loaded_tracks.iter().map(|t| pipe!(t.iter().cloned())));
92        for track in iters {
93            let mut track_writer = writer.open_next_track();
94            for e in track {
95                track_writer.write_event(e).unwrap();
96            }
97        }
98    });
99    do_run("Merge each track while cloning then write", repeats, || {
100        let output = Cursor::new(Vec::<u8>::new());
101        let writer = MIDIWriter::new_from_stram(Box::new(output), file.ppq()).unwrap();
102
103        let iters =
104            pipe!(loaded_tracks.iter().map(|t| pipe!(t.iter().cloned()|>wrap_ok()))|>to_vec());
105        let merged = pipe!(iters|>merge_events_array()|>unwrap_items());
106        let mut track_writer = writer.open_next_track();
107        for e in merged {
108            track_writer.write_event(e).unwrap();
109        }
110    });
111}
examples/parse_benchmark.rs (line 40)
35fn main() {
36    let filename = "D:/Midis/toilet story 3 2020 ver 3840 black with tempo.mid";
37    let repeats = 4;
38
39    println!("Opening midi...");
40    let file = MIDIFile::open(filename, None).unwrap();
41
42    println!("Tracks: {}", file.track_count());
43
44    // Make windows cache stuff
45    let tracks = file.iter_all_tracks().collect();
46    let stats = get_channels_array_statistics(tracks).unwrap();
47
48    println!("Note count: {}", stats.note_count());
49
50    do_run("Parse tracks in parallel", repeats, || {
51        let tracks = file.iter_all_tracks().collect();
52        let stats = get_channels_array_statistics(tracks).unwrap();
53        stats.note_count()
54    });
55
56    do_run("Iter event batches merged", repeats, || {
57        let ppq = file.ppq();
58        let merged = pipe!(
59            file.iter_all_track_events_merged_batches()
60            |>TimeCaster::<f64>::cast_event_delta()
61            |>cancel_tempo_events(250000)
62            |>scale_event_time(1.0 / ppq as f64)
63            |>unwrap_items()
64        );
65
66        let mut note_count = 0;
67        for batch in merged {
68            for e in batch.into_iter() {
69                if let Event::NoteOn(_) = e.as_event() {
70                    note_count += 1
71                }
72            }
73        }
74
75        note_count
76    });
77
78    // do_run("Merge all tracks together while parsing", repeats, || {
79    //     let merged = pipe!(file.iter_all_tracks()|>to_vec()|>merge_events_array());
80    //     for _ in merged {}
81    // });
82    // do_run("Clone all events", repeats, || {
83    //     let iters = pipe!(loaded_tracks.iter().map(|t| pipe!(t.iter().cloned())));
84    //     for track in iters {
85    //         for _ in track {}
86    //     }
87    // });
88    // do_run(
89    //     "Clone all events, then wrap and unwrap them in Result",
90    //     repeats,
91    //     || {
92    //         let iters = pipe!(loaded_tracks
93    //             .iter()
94    //             .map(|t| pipe!(t.iter().cloned()|>wrap_ok()|>unwrap_items())));
95    //         for track in iters {
96    //             for _ in track {}
97    //         }
98    //     },
99    // );
100    // do_run("Merge all tracks together while cloning", repeats, || {
101    //     let iters =
102    //         pipe!(loaded_tracks.iter().map(|t| pipe!(t.iter().cloned()|>wrap_ok()))|>to_vec());
103    //     let merged = pipe!(iters|>merge_events_array());
104    //     for _ in merged {}
105    // });
106    // do_run("Write each track while cloning", repeats, || {
107    //     let output = Cursor::new(Vec::<u8>::new());
108    //     let writer = MIDIWriter::new_from_stram(Box::new(output), file.ppq()).unwrap();
109
110    //     let iters = pipe!(loaded_tracks.iter().map(|t| pipe!(t.iter().cloned())));
111    //     for track in iters {
112    //         let mut track_writer = writer.open_next_track();
113    //         for e in track {
114    //             track_writer.write_event(e).unwrap();
115    //         }
116    //     }
117    // });
118    // do_run("Merge each track while cloning then write", repeats, || {
119    //     let output = Cursor::new(Vec::<u8>::new());
120    //     let writer = MIDIWriter::new_from_stram(Box::new(output), file.ppq()).unwrap();
121
122    //     let iters =
123    //         pipe!(loaded_tracks.iter().map(|t| pipe!(t.iter().cloned()|>wrap_ok()))|>to_vec());
124    //     let merged = pipe!(iters|>merge_events_array()|>unwrap_items());
125    //     let mut track_writer = writer.open_next_track();
126    //     for e in merged {
127    //         track_writer.write_event(e).unwrap();
128    //     }
129    // });
130}
Source

pub fn open_from_stream<T: 'static + Read + Seek + Send>( stream: T, read_progress: Option<&mut dyn FnMut(u32)>, ) -> Result<Self, MIDILoadError>

Source§

impl MIDIFile<RAMReader>

Source

pub fn open_in_ram( filename: impl AsRef<Path>, read_progress: Option<&mut dyn FnMut(u32)>, ) -> Result<Self, MIDILoadError>

Examples found in repository?
examples/polyphony.rs (line 12)
10pub fn main() {
11    println!("Opening midi...");
12    let file = MIDIFile::open_in_ram("D:/Midis/tau2.5.9.mid", None).unwrap();
13    println!("Parsing midi...");
14    let now = Instant::now();
15    let mut poly: u64 = 0;
16    let merged = pipe!(file.iter_all_tracks()|>to_vec()|>merge_events_array()|>unwrap_items());
17
18    let mut max_poly: u64 = 0;
19
20    for e in merged {
21        match *e {
22            Event::NoteOn(_) => {
23                poly += 1;
24                if poly > max_poly {
25                    max_poly = poly;
26                }
27            }
28            Event::NoteOff(_) => poly -= 1,
29            _ => {}
30        }
31    }
32
33    println!("Finished parsing midi, found {max_poly} polyphony");
34    println!("Elapsed {:?}", now.elapsed());
35}
More examples
Hide additional examples
examples/nps_bench.rs (lines 15-18)
13pub fn main() {
14    println!("Opening midi...");
15    let midi = MIDIFile::open_in_ram(
16        "/mnt/fat/Midis/Ra Ra Rasputin Ultimate Black MIDI Final.mid",
17        None,
18    )
19    .unwrap();
20
21    let ppq = midi.ppq();
22    let merged = pipe!(
23        midi.iter_all_track_events_merged_batches()
24        |>TimeCaster::<f64>::cast_event_delta()
25        |>cancel_tempo_events(250000)
26        |>scale_event_time(1.0 / ppq as f64)
27        |>unwrap_items()
28    );
29
30    println!("Tracks: {}", midi.track_count());
31
32    let start = Instant::now();
33    let mut note_count = 0;
34    for batch in merged {
35        for e in batch.iter_events() {
36            if let Event::NoteOn(_) = e.as_event() {
37                note_count += 1;
38            }
39        }
40    }
41
42    println!("Note count: {}   \tTime: {:?}", note_count, start.elapsed());
43    println!(
44        "Notes per second: {}",
45        note_count as f64 / start.elapsed().as_secs_f64()
46    );
47}
examples/statistics.rs (line 22)
20fn main() {
21    println!("Opening midi...");
22    let file = MIDIFile::open_in_ram("D:/Midis/tau2.5.9.mid", None).unwrap();
23    println!("Parsing midi...");
24
25    let now = Instant::now();
26    let stats1 = pipe!(
27        file.iter_all_tracks()
28        |>to_vec()
29        |>merge_events_array()
30        |>get_channel_statistics().unwrap()
31    );
32
33    println!("Calculated merged stats in {:?}", now.elapsed());
34    println!(
35        "MIDI length: {}",
36        duration_to_minutes_seconds(stats1.calculate_total_duration(file.ppq()))
37    );
38    println!("Other stats: {stats1:#?}\n\n");
39
40    let now = Instant::now();
41    let stats2 = pipe!(
42        file.iter_all_tracks()|>to_vec()|>get_channels_array_statistics().unwrap()
43    );
44    println!("Calculated multithreaded stats in {:?}", now.elapsed());
45    println!(
46        "MIDI length: {}",
47        duration_to_minutes_seconds(stats2.calculate_total_duration(file.ppq()))
48    );
49    println!("Other stats: {stats2:#?}");
50}
examples/write.rs (line 12)
10pub fn main() {
11    println!("Opening midi...");
12    let file = MIDIFile::open_in_ram("D:/Midis/tau2.5.9.mid", None).unwrap();
13    let writer = MIDIWriter::new("./out.mid", file.ppq()).unwrap();
14    println!("Parsing midi...");
15    let now = Instant::now();
16
17    let mut nc: u64 = 0;
18    {
19        let mut track_writer = writer.open_next_track();
20        // let merged = pipe!(file.iter_all_tracks()|>to_vec()|>merge_events_array()|>unwrap_items());
21        let converted = file.iter_all_tracks();
22        // .map(|track| pipe!(track|>events_to_notes()|>notes_to_events()));
23        let merged = pipe!(converted|>to_vec()|>merge_events_array()|>unwrap_items());
24        for e in merged {
25            if let Event::NoteOn(_) = *e {
26                nc += 1
27            }
28            track_writer.write_event(e).unwrap();
29        }
30    }
31
32    println!("Finished parsing midi, found {nc} notes");
33    println!("Elapsed {:?}", now.elapsed());
34    println!(
35        "Notes/second {}",
36        (nc as f64 / now.elapsed().as_secs_f64()).round()
37    );
38}
Source

pub fn open_from_stream_in_ram<T: 'static + Read + Seek + Send>( stream: T, read_progress: Option<&mut dyn FnMut(u32)>, ) -> Result<Self, MIDILoadError>

Trait Implementations§

Source§

impl<T: Debug + MIDIReader> Debug for MIDIFile<T>

Source§

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

Formats the value using the given formatter. Read more

Auto Trait Implementations§

§

impl<T> Freeze for MIDIFile<T>
where T: Freeze,

§

impl<T> RefUnwindSafe for MIDIFile<T>
where T: RefUnwindSafe,

§

impl<T> Send for MIDIFile<T>
where T: Send,

§

impl<T> Sync for MIDIFile<T>
where T: Sync,

§

impl<T> Unpin for MIDIFile<T>
where T: Unpin,

§

impl<T> UnwindSafe for MIDIFile<T>
where T: UnwindSafe,

Blanket Implementations§

Source§

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

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

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

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

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

Source§

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

Mutably borrows from an owned value. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

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

Source§

fn into(self) -> U

Calls U::from(self).

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

Source§

impl<T> Pointable for T

Source§

const ALIGN: usize

The alignment of pointer.
Source§

type Init = T

The type for initializers.
Source§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
Source§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
Source§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
Source§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
Source§

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

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

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

Source§

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

The type returned in the event of a conversion error.
Source§

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

Performs the conversion.