Struct TrackWriter 

pub struct TrackWriter<'a> { /* private fields */ }

Implementations

impl<'a> TrackWriter<'a>

pub fn end(&mut self) -> Result<(), MIDIWriteError>

pub fn is_ended(&self) -> bool

pub fn get_writer_mut(&mut self) -> &mut impl Write

pub fn write_event<T: SerializeEventWithDelta>( &mut self, event: T, ) -> Result<usize, MIDIWriteError>

Examples found in repository

examples/write.rs (line 27)

pub fn main() {
    println!("Opening midi...");
    let file = MIDIFile::open_in_ram("D:/Midis/tau2.5.9.mid", None).unwrap();
    let writer = MIDIWriter::new("./out.mid", file.ppq()).unwrap();
    println!("Parsing midi...");
    let now = Instant::now();

    let mut nc: u64 = 0;
    {
        let mut track_writer = writer.try_open_next_track().unwrap();
        // let merged = pipe!(file.iter_all_tracks()|>to_vec()|>merge_events_array()|>unwrap_items());
        let converted = file.iter_all_tracks();
        // .map(|track| pipe!(track|>events_to_notes()|>notes_to_events()));
        let merged = converted.merge_all().unwrap_items();
        for e in merged {
            if let Event::NoteOn(_) = *e {
                nc += 1
            }
            track_writer.write_event(e).unwrap();
        }
    }

    println!("Finished parsing midi, found {nc} notes");
    println!("Elapsed {:?}", now.elapsed());
    println!(
        "Notes/second {}",
        (nc as f64 / now.elapsed().as_secs_f64()).round()
    );
}

examples/benchmark.rs (line 99)

fn main() {
    let filename = "D:/Midis/Ra Ra Rasputin Ultimate Black MIDI Final.mid";
    let repeats = 4;

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

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

    let loaded_tracks = file
        .iter_all_tracks()
        .map(|t| t.collect_vec_result().unwrap())
        .collect::<Vec<_>>();

    let mut nc: u64 = 0;
    for track in loaded_tracks.iter() {
        for e in track {
            if let Event::NoteOn(_) = **e {
                nc += 1
            }
        }
    }
    println!("Note count: {nc}");

    do_run("Parse all tracks individually", repeats, || {
        for track in file.iter_all_tracks() {
            for _ in track {}
        }
    });
    do_run("Merge all tracks together while parsing", repeats, || {
        let merged = file.iter_all_tracks().merge_all();
        for _ in merged {}
    });
    do_run("Clone all events", repeats, || {
        let iters = loaded_tracks.iter().map(|t| 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 = loaded_tracks
                .iter()
                .map(|t| t.iter().cloned().into_ok().unwrap_items());
            for track in iters {
                for _ in track {}
            }
        },
    );
    do_run("Merge all tracks together while cloning", repeats, || {
        let iters = loaded_tracks
            .iter()
            .map(|t| t.iter().cloned().into_ok())
            .collect::<Vec<_>>();
        let merged = iters.into_iter().merge_all();
        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 = loaded_tracks.iter().map(|t| t.iter().cloned());
        for track in iters {
            let mut track_writer = writer.try_open_next_track().unwrap();
            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 = loaded_tracks
            .iter()
            .map(|t| t.iter().cloned().into_ok())
            .collect::<Vec<_>>();
        let merged = iters.into_iter().merge_all().unwrap_items();
        let mut track_writer = writer.try_open_next_track().unwrap();
        for e in merged {
            track_writer.write_event(e).unwrap();
        }
    });
}

pub fn write_events_iter<T: SerializeEventWithDelta>( &mut self, events: impl Iterator<Item = T>, ) -> Result<usize, MIDIWriteError>

Examples found in repository

examples/note_chopper.rs (line 60)

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

pub fn write_bytes(&mut self, bytes: &[u8]) -> Result<usize, MIDIWriteError>

Trait Implementations

impl<'a> Debug for TrackWriter<'a>

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

Formats the value using the given formatter.

impl<'a> Drop for TrackWriter<'a>

fn drop(&mut self)

Executes the destructor for this type.