Struct ChannelStatistics 

pub struct ChannelStatistics<D: MIDINum> { /* private fields */ }

A struct to hold the statistics of a sequence.

Implementations

impl<T: MIDINum> ChannelStatistics<T>

pub fn note_on_count(&self) -> u64

The number of note on events

pub fn note_count(&self) -> u64

Alias for note_on_count

Examples found in repository

examples/parse_benchmark.rs (line 43)

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();
    //     }
    // });
}

pub fn note_off_count(&self) -> u64

The number of note off events

pub fn other_event_count(&self) -> u64

The number of events that are not note on and note off.

Alias for (total_event_count() - note_on_count() - note_off_count())

pub fn total_event_count(&self) -> u64

The total number of events

pub fn total_length_ticks(&self) -> T

The sum of all delta times in each event

pub fn calculate_total_duration(&self, ppq: u16) -> Duration

Calculate the length in seconds based on the tick length and the tempo events, as well as the ppq

Examples found in repository

examples/statistics.rs (line 28)

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:#?}");
}

Trait Implementations

impl<D: Clone + MIDINum> Clone for ChannelStatistics<D>

fn clone(&self) -> ChannelStatistics<D>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: MIDINum> Debug for ChannelStatistics<T>

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

Formats the value using the given formatter.