pub trait EventSequenceCollectionExt<D: MIDINum, T, Err, I>: Iterator<Item = I> + Sized{
// Provided methods
fn merge_all(self) -> impl Iterator<Item = Result<T, Err>> { ... }
fn channel_statistics(self) -> Result<ChannelGroupStatistics<D>, Err>
where T: MIDIEventEnum + MIDIDelta<D>,
Err: Send,
I: Send { ... }
}Provided Methods§
Sourcefn merge_all(self) -> impl Iterator<Item = Result<T, Err>>
fn merge_all(self) -> impl Iterator<Item = Result<T, Err>>
Examples found in repository?
examples/polyphony.rs (line 11)
5pub fn main() {
6 println!("Opening midi...");
7 let file = MIDIFile::open_in_ram("D:/Midis/tau2.5.9.mid", None).unwrap();
8 println!("Parsing midi...");
9 let now = Instant::now();
10 let mut poly: u64 = 0;
11 let merged = file.iter_all_tracks().merge_all().unwrap_items();
12
13 let mut max_poly: u64 = 0;
14
15 for e in merged {
16 match *e {
17 Event::NoteOn(_) => {
18 poly += 1;
19 if poly > max_poly {
20 max_poly = poly;
21 }
22 }
23 Event::NoteOff(_) => poly -= 1,
24 _ => {}
25 }
26 }
27
28 println!("Finished parsing midi, found {max_poly} polyphony");
29 println!("Elapsed {:?}", now.elapsed());
30}More examples
examples/statistics.rs (line 21)
13fn main() {
14 println!("Opening midi...");
15 let file = MIDIFile::open_in_ram("D:/Midis/tau2.5.9.mid", None).unwrap();
16 println!("Parsing midi...");
17
18 let now = Instant::now();
19 let stats1 = file
20 .iter_all_tracks()
21 .merge_all()
22 .channel_statistics()
23 .unwrap();
24
25 println!("Calculated merged stats in {:?}", now.elapsed());
26 println!(
27 "MIDI length: {}",
28 duration_to_minutes_seconds(stats1.calculate_total_duration(file.ppq()))
29 );
30 println!("Other stats: {stats1:#?}\n\n");
31
32 let now = Instant::now();
33 let stats2 = file.iter_all_tracks().channel_statistics().unwrap();
34 println!("Calculated multithreaded stats in {:?}", now.elapsed());
35 println!(
36 "MIDI length: {}",
37 duration_to_minutes_seconds(stats2.calculate_total_duration(file.ppq()))
38 );
39 println!("Other stats: {stats2:#?}");
40}examples/write.rs (line 22)
9pub fn main() {
10 println!("Opening midi...");
11 let file = MIDIFile::open_in_ram("D:/Midis/tau2.5.9.mid", None).unwrap();
12 let writer = MIDIWriter::new("./out.mid", file.ppq()).unwrap();
13 println!("Parsing midi...");
14 let now = Instant::now();
15
16 let mut nc: u64 = 0;
17 {
18 let mut track_writer = writer.try_open_next_track().unwrap();
19 // let merged = pipe!(file.iter_all_tracks()|>to_vec()|>merge_events_array()|>unwrap_items());
20 let converted = file.iter_all_tracks();
21 // .map(|track| pipe!(track|>events_to_notes()|>notes_to_events()));
22 let merged = converted.merge_all().unwrap_items();
23 for e in merged {
24 if let Event::NoteOn(_) = *e {
25 nc += 1
26 }
27 track_writer.write_event(e).unwrap();
28 }
29 }
30
31 println!("Finished parsing midi, found {nc} notes");
32 println!("Elapsed {:?}", now.elapsed());
33 println!(
34 "Notes/second {}",
35 (nc as f64 / now.elapsed().as_secs_f64()).round()
36 );
37}examples/events_notes.rs (line 22)
5pub fn main() {
6 println!("Opening midi...");
7 let file = MIDIFile::open("D:/Midis/tau2.5.9.mid", None).unwrap();
8 println!("Parsing midi...");
9 let now = Instant::now();
10 let mut nc: u64 = 0;
11 // for track in file.iter_all_tracks(true) {
12 // // let track = TimeCaster::<f64>::cast_event_delta(track);
13 // for e in pipe!(track|>unwrap_items())
14 // // for e in pipe!(track|>TimeCaster::<f64>::cast_event_delta()|>scale_event_time(10.0)|>unwrap_items())
15 // {
16 // match e {
17 // Event::NoteOn(_) => nc += 1,
18 // _ => {}
19 // }
20 // }
21 // }
22 let merged = file.iter_all_tracks().merge_all().unwrap_items();
23
24 for e in merged {
25 if let Event::NoteOn(_) = *e {
26 nc += 1
27 }
28 let delta = e.delta;
29 if delta > 184467440737 {
30 dbg!(e);
31 }
32 }
33
34 println!("Finished parsing midi, found {nc} notes");
35 println!("Elapsed {:?}", now.elapsed());
36 println!(
37 "Notes/second {}",
38 (nc as f64 / now.elapsed().as_secs_f64()).round()
39 );
40}examples/benchmark.rs (line 62)
32fn main() {
33 let filename = "D:/Midis/Ra Ra Rasputin Ultimate Black MIDI Final.mid";
34 let repeats = 4;
35
36 println!("Opening midi...");
37 let file = MIDIFile::open(filename, None).unwrap();
38
39 println!("Tracks: {}", file.track_count());
40
41 let loaded_tracks = file
42 .iter_all_tracks()
43 .map(|t| t.collect_vec_result().unwrap())
44 .collect::<Vec<_>>();
45
46 let mut nc: u64 = 0;
47 for track in loaded_tracks.iter() {
48 for e in track {
49 if let Event::NoteOn(_) = **e {
50 nc += 1
51 }
52 }
53 }
54 println!("Note count: {nc}");
55
56 do_run("Parse all tracks individually", repeats, || {
57 for track in file.iter_all_tracks() {
58 for _ in track {}
59 }
60 });
61 do_run("Merge all tracks together while parsing", repeats, || {
62 let merged = file.iter_all_tracks().merge_all();
63 for _ in merged {}
64 });
65 do_run("Clone all events", repeats, || {
66 let iters = loaded_tracks.iter().map(|t| t.iter().cloned());
67 for track in iters {
68 for _ in track {}
69 }
70 });
71 do_run(
72 "Clone all events, then wrap and unwrap them in Result",
73 repeats,
74 || {
75 let iters = loaded_tracks
76 .iter()
77 .map(|t| t.iter().cloned().into_ok().unwrap_items());
78 for track in iters {
79 for _ in track {}
80 }
81 },
82 );
83 do_run("Merge all tracks together while cloning", repeats, || {
84 let iters = loaded_tracks
85 .iter()
86 .map(|t| t.iter().cloned().into_ok())
87 .collect::<Vec<_>>();
88 let merged = iters.into_iter().merge_all();
89 for _ in merged {}
90 });
91 do_run("Write each track while cloning", repeats, || {
92 let output = Cursor::new(Vec::<u8>::new());
93 let writer = MIDIWriter::new_from_stream(Box::new(output), file.ppq()).unwrap();
94
95 let iters = loaded_tracks.iter().map(|t| t.iter().cloned());
96 for track in iters {
97 let mut track_writer = writer.try_open_next_track().unwrap();
98 for e in track {
99 track_writer.write_event(e).unwrap();
100 }
101 }
102 });
103 do_run("Merge each track while cloning then write", repeats, || {
104 let output = Cursor::new(Vec::<u8>::new());
105 let writer = MIDIWriter::new_from_stream(Box::new(output), file.ppq()).unwrap();
106
107 let iters = loaded_tracks
108 .iter()
109 .map(|t| t.iter().cloned().into_ok())
110 .collect::<Vec<_>>();
111 let merged = iters.into_iter().merge_all().unwrap_items();
112 let mut track_writer = writer.try_open_next_track().unwrap();
113 for e in merged {
114 track_writer.write_event(e).unwrap();
115 }
116 });
117}Sourcefn channel_statistics(self) -> Result<ChannelGroupStatistics<D>, Err>
fn channel_statistics(self) -> Result<ChannelGroupStatistics<D>, Err>
Examples found in repository?
examples/statistics.rs (line 33)
13fn main() {
14 println!("Opening midi...");
15 let file = MIDIFile::open_in_ram("D:/Midis/tau2.5.9.mid", None).unwrap();
16 println!("Parsing midi...");
17
18 let now = Instant::now();
19 let stats1 = file
20 .iter_all_tracks()
21 .merge_all()
22 .channel_statistics()
23 .unwrap();
24
25 println!("Calculated merged stats in {:?}", now.elapsed());
26 println!(
27 "MIDI length: {}",
28 duration_to_minutes_seconds(stats1.calculate_total_duration(file.ppq()))
29 );
30 println!("Other stats: {stats1:#?}\n\n");
31
32 let now = Instant::now();
33 let stats2 = file.iter_all_tracks().channel_statistics().unwrap();
34 println!("Calculated multithreaded stats in {:?}", now.elapsed());
35 println!(
36 "MIDI length: {}",
37 duration_to_minutes_seconds(stats2.calculate_total_duration(file.ppq()))
38 );
39 println!("Other stats: {stats2:#?}");
40}More examples
examples/parse_benchmark.rs (line 41)
31fn main() {
32 let filename = "D:/Midis/toilet story 3 2020 ver 3840 black with tempo.mid";
33 let repeats = 4;
34
35 println!("Opening midi...");
36 let file = MIDIFile::open(filename, None).unwrap();
37
38 println!("Tracks: {}", file.track_count());
39
40 // Make windows cache stuff
41 let stats = file.iter_all_tracks().channel_statistics().unwrap();
42
43 println!("Note count: {}", stats.note_count());
44
45 do_run("Parse tracks in parallel", repeats, || {
46 let stats = file.iter_all_tracks().channel_statistics().unwrap();
47 stats.note_count()
48 });
49
50 do_run("Iter event batches merged", repeats, || {
51 let ppq = file.ppq();
52 let merged = file
53 .iter_all_track_events_merged_batches()
54 .cast_event_delta::<f64>()
55 .cancel_tempo_events(250000)
56 .scale_event_time(1.0 / ppq as f64)
57 .unwrap_items();
58
59 let mut note_count = 0;
60 for batch in merged {
61 for e in batch.into_iter() {
62 if let Event::NoteOn(_) = e.as_event() {
63 note_count += 1
64 }
65 }
66 }
67
68 note_count
69 });
70
71 // do_run("Merge all tracks together while parsing", repeats, || {
72 // let merged = pipe!(file.iter_all_tracks()|>to_vec()|>merge_events_array());
73 // for _ in merged {}
74 // });
75 // do_run("Clone all events", repeats, || {
76 // let iters = pipe!(loaded_tracks.iter().map(|t| pipe!(t.iter().cloned())));
77 // for track in iters {
78 // for _ in track {}
79 // }
80 // });
81 // do_run(
82 // "Clone all events, then wrap and unwrap them in Result",
83 // repeats,
84 // || {
85 // let iters = pipe!(loaded_tracks
86 // .iter()
87 // .map(|t| pipe!(t.iter().cloned()|>wrap_ok()|>unwrap_items())));
88 // for track in iters {
89 // for _ in track {}
90 // }
91 // },
92 // );
93 // do_run("Merge all tracks together while cloning", repeats, || {
94 // let iters =
95 // pipe!(loaded_tracks.iter().map(|t| pipe!(t.iter().cloned()|>wrap_ok()))|>to_vec());
96 // let merged = pipe!(iters|>merge_events_array());
97 // for _ in merged {}
98 // });
99 // do_run("Write each track while cloning", repeats, || {
100 // let output = Cursor::new(Vec::<u8>::new());
101 // let writer = MIDIWriter::new_from_stream(Box::new(output), file.ppq()).unwrap();
102
103 // let iters = pipe!(loaded_tracks.iter().map(|t| pipe!(t.iter().cloned())));
104 // for track in iters {
105 // let mut track_writer = writer.open_next_track();
106 // for e in track {
107 // track_writer.write_event(e).unwrap();
108 // }
109 // }
110 // });
111 // do_run("Merge each track while cloning then write", repeats, || {
112 // let output = Cursor::new(Vec::<u8>::new());
113 // let writer = MIDIWriter::new_from_stream(Box::new(output), file.ppq()).unwrap();
114
115 // let iters =
116 // pipe!(loaded_tracks.iter().map(|t| pipe!(t.iter().cloned()|>wrap_ok()))|>to_vec());
117 // let merged = pipe!(iters|>merge_events_array()|>unwrap_items());
118 // let mut track_writer = writer.open_next_track();
119 // for e in merged {
120 // track_writer.write_event(e).unwrap();
121 // }
122 // });
123}Dyn Compatibility§
This trait is not dyn compatible.
In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.