Trait EventSequenceExt 

pub trait EventSequenceExt<D: MIDINum, E, Err>: Iterator<Item = Result<Delta<D, E>, Err>> + Sized {
    // Provided methods
    fn cast_event_delta<ND: MIDINum>(
        self,
    ) -> impl Iterator<Item = Result<<Delta<D, E> as CastEventDelta<ND>>::Output, Err>>
       where Delta<D, E>: CastEventDelta<ND> { ... }
    fn scale_event_time(
        self,
        multiplier: D,
    ) -> impl Iterator<Item = Result<Delta<D, E>, Err>>
       where Delta<D, E>: MIDIDelta<D> { ... }
    fn scale_event_ppq(
        self,
        from: D,
        to: D,
    ) -> impl Iterator<Item = Result<Delta<D, E>, Err>>
       where Delta<D, E>: MIDIEvent + MIDIDelta<D> { ... }
    fn filter_events(
        self,
        predicate: impl Fn(&Delta<D, E>) -> bool,
    ) -> impl Iterator<Item = Result<Delta<D, E>, Err>>
       where Delta<D, E>: MIDIEventEnum + MIDIDelta<D> { ... }
    fn filter_map_events<NE>(
        self,
        mapper: impl FnMut(E) -> Option<NE>,
    ) -> impl Iterator<Item = Result<Delta<D, NE>, Err>> { ... }
    fn filter_note_events(
        self,
    ) -> impl Iterator<Item = Result<Delta<D, E>, Err>>
       where Delta<D, E>: MIDIEventEnum + MIDIDelta<D> { ... }
    fn filter_non_note_events(
        self,
    ) -> impl Iterator<Item = Result<Delta<D, E>, Err>>
       where Delta<D, E>: MIDIEventEnum + MIDIDelta<D> { ... }
    fn cancel_tempo_events(
        self,
        new_tempo: u32,
    ) -> impl Iterator<Item = Result<Delta<D, E>, Err>>
       where Delta<D, E>: BatchTempo + MIDIDelta<D> { ... }
    fn event_batches(
        self,
    ) -> impl Iterator<Item = Result<Delta<D, EventBatch<E>>, Err>>
       where Delta<D, E>: MIDIDelta<D> { ... }
    fn into_track_events(
        self,
        track: u32,
    ) -> impl Iterator<Item = Result<Delta<D, Track<E>>, Err>> { ... }
    fn events_to_notes(self) -> impl Iterator<Item = Result<Note<D>, Err>>
       where E: MIDIEventEnum { ... }
    fn channel_statistics(self) -> Result<ChannelStatistics<D>, Err>
       where Delta<D, E>: MIDIEventEnum + MIDIDelta<D> { ... }
}

Provided Methods

fn cast_event_delta<ND: MIDINum>( self, ) -> impl Iterator<Item = Result<<Delta<D, E> as CastEventDelta<ND>>::Output, Err>>

where Delta<D, E>: CastEventDelta<ND>,

Examples found in repository

examples/nps_bench.rs (line 20)

pub fn main() {
    println!("Opening midi...");
    let midi = MIDIFile::open_in_ram(
        "/mnt/fat/Midis/Ra Ra Rasputin Ultimate Black MIDI Final.mid",
        None,
    )
    .unwrap();

    let ppq = midi.ppq();
    let merged = midi
        .iter_all_track_events_merged_batches()
        .cast_event_delta::<f64>()
        .cancel_tempo_events(250000)
        .scale_event_time(1.0 / ppq as f64)
        .unwrap_items();

    println!("Tracks: {}", midi.track_count());

    let start = Instant::now();
    let mut note_count = 0;
    for batch in merged {
        for e in batch.iter_events() {
            if let Event::NoteOn(_) = e.as_event() {
                note_count += 1;
            }
        }
    }

    println!("Note count: {}   \tTime: {:?}", note_count, start.elapsed());
    println!(
        "Notes per second: {}",
        note_count as f64 / start.elapsed().as_secs_f64()
    );
}

examples/parse_benchmark.rs (line 54)

fn main() {
    let filename = "D:/Midis/toilet story 3 2020 ver 3840 black with tempo.mid";
    let repeats = 4;

    println!("Opening midi...");
    let file = MIDIFile::open(filename, None).unwrap();

    println!("Tracks: {}", file.track_count());

    // Make windows cache stuff
    let stats = file.iter_all_tracks().channel_statistics().unwrap();

    println!("Note count: {}", stats.note_count());

    do_run("Parse tracks in parallel", repeats, || {
        let stats = file.iter_all_tracks().channel_statistics().unwrap();
        stats.note_count()
    });

    do_run("Iter event batches merged", repeats, || {
        let ppq = file.ppq();
        let merged = file
            .iter_all_track_events_merged_batches()
            .cast_event_delta::<f64>()
            .cancel_tempo_events(250000)
            .scale_event_time(1.0 / ppq as f64)
            .unwrap_items();

        let mut note_count = 0;
        for batch in merged {
            for e in batch.into_iter() {
                if let Event::NoteOn(_) = e.as_event() {
                    note_count += 1
                }
            }
        }

        note_count
    });

    // do_run("Merge all tracks together while parsing", repeats, || {
    //     let merged = pipe!(file.iter_all_tracks()|>to_vec()|>merge_events_array());
    //     for _ in merged {}
    // });
    // do_run("Clone all events", repeats, || {
    //     let iters = pipe!(loaded_tracks.iter().map(|t| pipe!(t.iter().cloned())));
    //     for track in iters {
    //         for _ in track {}
    //     }
    // });
    // do_run(
    //     "Clone all events, then wrap and unwrap them in Result",
    //     repeats,
    //     || {
    //         let iters = pipe!(loaded_tracks
    //             .iter()
    //             .map(|t| pipe!(t.iter().cloned()|>wrap_ok()|>unwrap_items())));
    //         for track in iters {
    //             for _ in track {}
    //         }
    //     },
    // );
    // do_run("Merge all tracks together while cloning", repeats, || {
    //     let iters =
    //         pipe!(loaded_tracks.iter().map(|t| pipe!(t.iter().cloned()|>wrap_ok()))|>to_vec());
    //     let merged = pipe!(iters|>merge_events_array());
    //     for _ in merged {}
    // });
    // do_run("Write each track while cloning", repeats, || {
    //     let output = Cursor::new(Vec::<u8>::new());
    //     let writer = MIDIWriter::new_from_stream(Box::new(output), file.ppq()).unwrap();

    //     let iters = pipe!(loaded_tracks.iter().map(|t| pipe!(t.iter().cloned())));
    //     for track in iters {
    //         let mut track_writer = writer.open_next_track();
    //         for e in track {
    //             track_writer.write_event(e).unwrap();
    //         }
    //     }
    // });
    // do_run("Merge each track while cloning then write", repeats, || {
    //     let output = Cursor::new(Vec::<u8>::new());
    //     let writer = MIDIWriter::new_from_stream(Box::new(output), file.ppq()).unwrap();

    //     let iters =
    //         pipe!(loaded_tracks.iter().map(|t| pipe!(t.iter().cloned()|>wrap_ok()))|>to_vec());
    //     let merged = pipe!(iters|>merge_events_array()|>unwrap_items());
    //     let mut track_writer = writer.open_next_track();
    //     for e in merged {
    //         track_writer.write_event(e).unwrap();
    //     }
    // });
}

fn scale_event_time( self, multiplier: D, ) -> impl Iterator<Item = Result<Delta<D, E>, Err>>

where Delta<D, E>: MIDIDelta<D>,

Examples found in repository

examples/nps_bench.rs (line 22)

pub fn main() {
    println!("Opening midi...");
    let midi = MIDIFile::open_in_ram(
        "/mnt/fat/Midis/Ra Ra Rasputin Ultimate Black MIDI Final.mid",
        None,
    )
    .unwrap();

    let ppq = midi.ppq();
    let merged = midi
        .iter_all_track_events_merged_batches()
        .cast_event_delta::<f64>()
        .cancel_tempo_events(250000)
        .scale_event_time(1.0 / ppq as f64)
        .unwrap_items();

    println!("Tracks: {}", midi.track_count());

    let start = Instant::now();
    let mut note_count = 0;
    for batch in merged {
        for e in batch.iter_events() {
            if let Event::NoteOn(_) = e.as_event() {
                note_count += 1;
            }
        }
    }

    println!("Note count: {}   \tTime: {:?}", note_count, start.elapsed());
    println!(
        "Notes per second: {}",
        note_count as f64 / start.elapsed().as_secs_f64()
    );
}

examples/parse_benchmark.rs (line 56)

fn main() {
    let filename = "D:/Midis/toilet story 3 2020 ver 3840 black with tempo.mid";
    let repeats = 4;

    println!("Opening midi...");
    let file = MIDIFile::open(filename, None).unwrap();

    println!("Tracks: {}", file.track_count());

    // Make windows cache stuff
    let stats = file.iter_all_tracks().channel_statistics().unwrap();

    println!("Note count: {}", stats.note_count());

    do_run("Parse tracks in parallel", repeats, || {
        let stats = file.iter_all_tracks().channel_statistics().unwrap();
        stats.note_count()
    });

    do_run("Iter event batches merged", repeats, || {
        let ppq = file.ppq();
        let merged = file
            .iter_all_track_events_merged_batches()
            .cast_event_delta::<f64>()
            .cancel_tempo_events(250000)
            .scale_event_time(1.0 / ppq as f64)
            .unwrap_items();

        let mut note_count = 0;
        for batch in merged {
            for e in batch.into_iter() {
                if let Event::NoteOn(_) = e.as_event() {
                    note_count += 1
                }
            }
        }

        note_count
    });

    // do_run("Merge all tracks together while parsing", repeats, || {
    //     let merged = pipe!(file.iter_all_tracks()|>to_vec()|>merge_events_array());
    //     for _ in merged {}
    // });
    // do_run("Clone all events", repeats, || {
    //     let iters = pipe!(loaded_tracks.iter().map(|t| pipe!(t.iter().cloned())));
    //     for track in iters {
    //         for _ in track {}
    //     }
    // });
    // do_run(
    //     "Clone all events, then wrap and unwrap them in Result",
    //     repeats,
    //     || {
    //         let iters = pipe!(loaded_tracks
    //             .iter()
    //             .map(|t| pipe!(t.iter().cloned()|>wrap_ok()|>unwrap_items())));
    //         for track in iters {
    //             for _ in track {}
    //         }
    //     },
    // );
    // do_run("Merge all tracks together while cloning", repeats, || {
    //     let iters =
    //         pipe!(loaded_tracks.iter().map(|t| pipe!(t.iter().cloned()|>wrap_ok()))|>to_vec());
    //     let merged = pipe!(iters|>merge_events_array());
    //     for _ in merged {}
    // });
    // do_run("Write each track while cloning", repeats, || {
    //     let output = Cursor::new(Vec::<u8>::new());
    //     let writer = MIDIWriter::new_from_stream(Box::new(output), file.ppq()).unwrap();

    //     let iters = pipe!(loaded_tracks.iter().map(|t| pipe!(t.iter().cloned())));
    //     for track in iters {
    //         let mut track_writer = writer.open_next_track();
    //         for e in track {
    //             track_writer.write_event(e).unwrap();
    //         }
    //     }
    // });
    // do_run("Merge each track while cloning then write", repeats, || {
    //     let output = Cursor::new(Vec::<u8>::new());
    //     let writer = MIDIWriter::new_from_stream(Box::new(output), file.ppq()).unwrap();

    //     let iters =
    //         pipe!(loaded_tracks.iter().map(|t| pipe!(t.iter().cloned()|>wrap_ok()))|>to_vec());
    //     let merged = pipe!(iters|>merge_events_array()|>unwrap_items());
    //     let mut track_writer = writer.open_next_track();
    //     for e in merged {
    //         track_writer.write_event(e).unwrap();
    //     }
    // });
}

fn scale_event_ppq( self, from: D, to: D, ) -> impl Iterator<Item = Result<Delta<D, E>, Err>>

where Delta<D, E>: MIDIEvent + MIDIDelta<D>,

fn filter_events( self, predicate: impl Fn(&Delta<D, E>) -> bool, ) -> impl Iterator<Item = Result<Delta<D, E>, Err>>

where Delta<D, E>: MIDIEventEnum + MIDIDelta<D>,

fn filter_map_events<NE>( self, mapper: impl FnMut(E) -> Option<NE>, ) -> impl Iterator<Item = Result<Delta<D, NE>, Err>>

fn filter_note_events(self) -> impl Iterator<Item = Result<Delta<D, E>, Err>>

where Delta<D, E>: MIDIEventEnum + MIDIDelta<D>,

fn filter_non_note_events( self, ) -> impl Iterator<Item = Result<Delta<D, E>, Err>>

where Delta<D, E>: MIDIEventEnum + MIDIDelta<D>,

Examples found in repository

examples/note_chopper.rs (line 41)

fn main() {
    let file = MIDIFile::open("D:/Midis/tau2.5.9.mid", None).unwrap();

    let chop_size = file.ppq() as u64 / 16;

    let writer = MIDIWriter::new("./out.mid", file.ppq()).unwrap();

    for (i, track) in file.iter_all_tracks().enumerate() {
        println!("Chopping track {} of {}", i, file.track_count());

        let cached = track.collect_vec_result().unwrap();

        let non_note_events = cached.iter().cloned().into_ok().filter_non_note_events();

        let notes = cached
            .iter()
            .cloned()
            .into_ok()
            .events_to_notes()
            .unwrap_items();
        let chopped = notes.map(|n| chop_note(n, chop_size).into_ok());
        let flattened = chopped.merge_all().notes_to_events();

        // let notes = pipe!(cached.iter().cloned()|>wrap_ok()|>events_to_notes()|>unwrap_items());
        // let flattened = pipe!(notes|>wrap_ok()|>notes_to_events());

        let merged = merge_events(flattened, non_note_events);

        writer
            .try_open_next_track()
            .unwrap()
            .write_events_iter(merged.unwrap_items())
            .unwrap();
    }
}

fn cancel_tempo_events( self, new_tempo: u32, ) -> impl Iterator<Item = Result<Delta<D, E>, Err>>

where Delta<D, E>: BatchTempo + MIDIDelta<D>,

Examples found in repository

examples/nps_bench.rs (line 21)

pub fn main() {
    println!("Opening midi...");
    let midi = MIDIFile::open_in_ram(
        "/mnt/fat/Midis/Ra Ra Rasputin Ultimate Black MIDI Final.mid",
        None,
    )
    .unwrap();

    let ppq = midi.ppq();
    let merged = midi
        .iter_all_track_events_merged_batches()
        .cast_event_delta::<f64>()
        .cancel_tempo_events(250000)
        .scale_event_time(1.0 / ppq as f64)
        .unwrap_items();

    println!("Tracks: {}", midi.track_count());

    let start = Instant::now();
    let mut note_count = 0;
    for batch in merged {
        for e in batch.iter_events() {
            if let Event::NoteOn(_) = e.as_event() {
                note_count += 1;
            }
        }
    }

    println!("Note count: {}   \tTime: {:?}", note_count, start.elapsed());
    println!(
        "Notes per second: {}",
        note_count as f64 / start.elapsed().as_secs_f64()
    );
}

examples/parse_benchmark.rs (line 55)

fn main() {
    let filename = "D:/Midis/toilet story 3 2020 ver 3840 black with tempo.mid";
    let repeats = 4;

    println!("Opening midi...");
    let file = MIDIFile::open(filename, None).unwrap();

    println!("Tracks: {}", file.track_count());

    // Make windows cache stuff
    let stats = file.iter_all_tracks().channel_statistics().unwrap();

    println!("Note count: {}", stats.note_count());

    do_run("Parse tracks in parallel", repeats, || {
        let stats = file.iter_all_tracks().channel_statistics().unwrap();
        stats.note_count()
    });

    do_run("Iter event batches merged", repeats, || {
        let ppq = file.ppq();
        let merged = file
            .iter_all_track_events_merged_batches()
            .cast_event_delta::<f64>()
            .cancel_tempo_events(250000)
            .scale_event_time(1.0 / ppq as f64)
            .unwrap_items();

        let mut note_count = 0;
        for batch in merged {
            for e in batch.into_iter() {
                if let Event::NoteOn(_) = e.as_event() {
                    note_count += 1
                }
            }
        }

        note_count
    });

    // do_run("Merge all tracks together while parsing", repeats, || {
    //     let merged = pipe!(file.iter_all_tracks()|>to_vec()|>merge_events_array());
    //     for _ in merged {}
    // });
    // do_run("Clone all events", repeats, || {
    //     let iters = pipe!(loaded_tracks.iter().map(|t| pipe!(t.iter().cloned())));
    //     for track in iters {
    //         for _ in track {}
    //     }
    // });
    // do_run(
    //     "Clone all events, then wrap and unwrap them in Result",
    //     repeats,
    //     || {
    //         let iters = pipe!(loaded_tracks
    //             .iter()
    //             .map(|t| pipe!(t.iter().cloned()|>wrap_ok()|>unwrap_items())));
    //         for track in iters {
    //             for _ in track {}
    //         }
    //     },
    // );
    // do_run("Merge all tracks together while cloning", repeats, || {
    //     let iters =
    //         pipe!(loaded_tracks.iter().map(|t| pipe!(t.iter().cloned()|>wrap_ok()))|>to_vec());
    //     let merged = pipe!(iters|>merge_events_array());
    //     for _ in merged {}
    // });
    // do_run("Write each track while cloning", repeats, || {
    //     let output = Cursor::new(Vec::<u8>::new());
    //     let writer = MIDIWriter::new_from_stream(Box::new(output), file.ppq()).unwrap();

    //     let iters = pipe!(loaded_tracks.iter().map(|t| pipe!(t.iter().cloned())));
    //     for track in iters {
    //         let mut track_writer = writer.open_next_track();
    //         for e in track {
    //             track_writer.write_event(e).unwrap();
    //         }
    //     }
    // });
    // do_run("Merge each track while cloning then write", repeats, || {
    //     let output = Cursor::new(Vec::<u8>::new());
    //     let writer = MIDIWriter::new_from_stream(Box::new(output), file.ppq()).unwrap();

    //     let iters =
    //         pipe!(loaded_tracks.iter().map(|t| pipe!(t.iter().cloned()|>wrap_ok()))|>to_vec());
    //     let merged = pipe!(iters|>merge_events_array()|>unwrap_items());
    //     let mut track_writer = writer.open_next_track();
    //     for e in merged {
    //         track_writer.write_event(e).unwrap();
    //     }
    // });
}

fn event_batches( self, ) -> impl Iterator<Item = Result<Delta<D, EventBatch<E>>, Err>>

where Delta<D, E>: MIDIDelta<D>,

fn into_track_events( self, track: u32, ) -> impl Iterator<Item = Result<Delta<D, Track<E>>, Err>>

fn events_to_notes(self) -> impl Iterator<Item = Result<Note<D>, Err>>

where E: MIDIEventEnum,

Examples found in repository

examples/note_chopper.rs (line 47)

fn main() {
    let file = MIDIFile::open("D:/Midis/tau2.5.9.mid", None).unwrap();

    let chop_size = file.ppq() as u64 / 16;

    let writer = MIDIWriter::new("./out.mid", file.ppq()).unwrap();

    for (i, track) in file.iter_all_tracks().enumerate() {
        println!("Chopping track {} of {}", i, file.track_count());

        let cached = track.collect_vec_result().unwrap();

        let non_note_events = cached.iter().cloned().into_ok().filter_non_note_events();

        let notes = cached
            .iter()
            .cloned()
            .into_ok()
            .events_to_notes()
            .unwrap_items();
        let chopped = notes.map(|n| chop_note(n, chop_size).into_ok());
        let flattened = chopped.merge_all().notes_to_events();

        // let notes = pipe!(cached.iter().cloned()|>wrap_ok()|>events_to_notes()|>unwrap_items());
        // let flattened = pipe!(notes|>wrap_ok()|>notes_to_events());

        let merged = merge_events(flattened, non_note_events);

        writer
            .try_open_next_track()
            .unwrap()
            .write_events_iter(merged.unwrap_items())
            .unwrap();
    }
}

fn channel_statistics(self) -> Result<ChannelStatistics<D>, Err>

where Delta<D, E>: MIDIEventEnum + MIDIDelta<D>,

Examples found in repository

examples/statistics.rs (line 22)

fn main() {
    println!("Opening midi...");
    let file = MIDIFile::open_in_ram("D:/Midis/tau2.5.9.mid", None).unwrap();
    println!("Parsing midi...");

    let now = Instant::now();
    let stats1 = file
        .iter_all_tracks()
        .merge_all()
        .channel_statistics()
        .unwrap();

    println!("Calculated merged stats in {:?}", now.elapsed());
    println!(
        "MIDI length: {}",
        duration_to_minutes_seconds(stats1.calculate_total_duration(file.ppq()))
    );
    println!("Other stats: {stats1:#?}\n\n");

    let now = Instant::now();
    let stats2 = file.iter_all_tracks().channel_statistics().unwrap();
    println!("Calculated multithreaded stats in {:?}", now.elapsed());
    println!(
        "MIDI length: {}",
        duration_to_minutes_seconds(stats2.calculate_total_duration(file.ppq()))
    );
    println!("Other stats: {stats2:#?}");
}

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.

Implementors

impl<D: MIDINum, E, Err, I> EventSequenceExt<D, E, Err> for I

where I: Iterator<Item = Result<Delta<D, E>, Err>> + Sized,