Struct StagedMIDIWriter 

pub struct StagedMIDIWriter { /* private fields */ }

Implementations

impl StagedMIDIWriter

pub fn new( destination: impl AsRef<Path>, ppq: u16, ) -> Result<Self, MIDIWriteError>

Examples found in repository

examples/staged_write.rs (line 6)

fn main() {
    let writer = StagedMIDIWriter::new("./staged-output.mid", 480).unwrap();
    println!(
        "Temporary parts file: {}",
        writer.temporary_parts_path().display()
    );

    let mut handles = Vec::new();
    for track_id in 0..3 {
        let mut track = writer.try_open_track(track_id).unwrap();
        handles.push(thread::spawn(move || {
            for step in 0..8 {
                let pitch = 60 + step as u8;
                track
                    .write_all(&[0x00, 0x90 | track_id as u8, pitch, 0x40])
                    .unwrap();
                track
                    .write_all(&[0x10, 0x80 | track_id as u8, pitch, 0x00])
                    .unwrap();
            }
            track.end().unwrap();
        }));
    }

    for handle in handles {
        handle.join().unwrap();
    }

    writer.end().unwrap();
    println!(
        "Final MIDI written to {}",
        writer.destination_path().display()
    );
}

pub fn destination_path(&self) -> &Path

Examples found in repository

examples/staged_write.rs (line 36)

fn main() {
    let writer = StagedMIDIWriter::new("./staged-output.mid", 480).unwrap();
    println!(
        "Temporary parts file: {}",
        writer.temporary_parts_path().display()
    );

    let mut handles = Vec::new();
    for track_id in 0..3 {
        let mut track = writer.try_open_track(track_id).unwrap();
        handles.push(thread::spawn(move || {
            for step in 0..8 {
                let pitch = 60 + step as u8;
                track
                    .write_all(&[0x00, 0x90 | track_id as u8, pitch, 0x40])
                    .unwrap();
                track
                    .write_all(&[0x10, 0x80 | track_id as u8, pitch, 0x00])
                    .unwrap();
            }
            track.end().unwrap();
        }));
    }

    for handle in handles {
        handle.join().unwrap();
    }

    writer.end().unwrap();
    println!(
        "Final MIDI written to {}",
        writer.destination_path().display()
    );
}

pub fn temporary_parts_path(&self) -> &Path

Examples found in repository

examples/staged_write.rs (line 9)

fn main() {
    let writer = StagedMIDIWriter::new("./staged-output.mid", 480).unwrap();
    println!(
        "Temporary parts file: {}",
        writer.temporary_parts_path().display()
    );

    let mut handles = Vec::new();
    for track_id in 0..3 {
        let mut track = writer.try_open_track(track_id).unwrap();
        handles.push(thread::spawn(move || {
            for step in 0..8 {
                let pitch = 60 + step as u8;
                track
                    .write_all(&[0x00, 0x90 | track_id as u8, pitch, 0x40])
                    .unwrap();
                track
                    .write_all(&[0x10, 0x80 | track_id as u8, pitch, 0x00])
                    .unwrap();
            }
            track.end().unwrap();
        }));
    }

    for handle in handles {
        handle.join().unwrap();
    }

    writer.end().unwrap();
    println!(
        "Final MIDI written to {}",
        writer.destination_path().display()
    );
}

pub fn write_ppq(&self, ppq: u16) -> Result<(), MIDIWriteError>

pub fn write_format(&self, format: u16) -> Result<(), MIDIWriteError>

pub fn try_open_next_track(&self) -> Result<StagedTrackWriter, MIDIWriteError>

pub fn try_open_track( &self, track_id: i32, ) -> Result<StagedTrackWriter, MIDIWriteError>

Examples found in repository

examples/staged_write.rs (line 14)

fn main() {
    let writer = StagedMIDIWriter::new("./staged-output.mid", 480).unwrap();
    println!(
        "Temporary parts file: {}",
        writer.temporary_parts_path().display()
    );

    let mut handles = Vec::new();
    for track_id in 0..3 {
        let mut track = writer.try_open_track(track_id).unwrap();
        handles.push(thread::spawn(move || {
            for step in 0..8 {
                let pitch = 60 + step as u8;
                track
                    .write_all(&[0x00, 0x90 | track_id as u8, pitch, 0x40])
                    .unwrap();
                track
                    .write_all(&[0x10, 0x80 | track_id as u8, pitch, 0x00])
                    .unwrap();
            }
            track.end().unwrap();
        }));
    }

    for handle in handles {
        handle.join().unwrap();
    }

    writer.end().unwrap();
    println!(
        "Final MIDI written to {}",
        writer.destination_path().display()
    );
}

pub fn is_ended(&self) -> bool

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

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

Examples found in repository

examples/staged_write.rs (line 33)

fn main() {
    let writer = StagedMIDIWriter::new("./staged-output.mid", 480).unwrap();
    println!(
        "Temporary parts file: {}",
        writer.temporary_parts_path().display()
    );

    let mut handles = Vec::new();
    for track_id in 0..3 {
        let mut track = writer.try_open_track(track_id).unwrap();
        handles.push(thread::spawn(move || {
            for step in 0..8 {
                let pitch = 60 + step as u8;
                track
                    .write_all(&[0x00, 0x90 | track_id as u8, pitch, 0x40])
                    .unwrap();
                track
                    .write_all(&[0x10, 0x80 | track_id as u8, pitch, 0x00])
                    .unwrap();
            }
            track.end().unwrap();
        }));
    }

    for handle in handles {
        handle.join().unwrap();
    }

    writer.end().unwrap();
    println!(
        "Final MIDI written to {}",
        writer.destination_path().display()
    );
}

Trait Implementations

impl Drop for StagedMIDIWriter

fn drop(&mut self)

Executes the destructor for this type.