Struct MidiEvent 

pub struct MidiEvent {
    pub frame: u64,
    pub kind: MidiEventKind,
}

One MIDI event at an absolute sample frame of the render.

Fields

frame: u64

kind: MidiEventKind

Implementations

impl MidiEvent

pub fn note_on(frame: u64, channel: u8, key: u8, velocity: f32) -> MidiEvent

Examples found in repository

examples/render_note.rs (line 24)

fn main() {
    let args: Vec<String> = std::env::args().skip(1).collect();
    if args.len() < 2 {
        eprintln!("usage: render_note <plugin> <out.wav> [midi key] [param=value ...]");
        std::process::exit(2);
    }
    let plugin = PluginRef::resolve(&args[0], &[]).unwrap_or_else(|e| {
        eprintln!("{e}");
        std::process::exit(e.exit_code)
    });
    let key: u8 = args.get(2).and_then(|k| k.parse().ok()).unwrap_or(60);
    let params =
        args.iter().skip(3).filter_map(|kv| kv.split_once('=').map(|(k, v)| (k.to_string(), v.to_string()))).collect();
    let sr = 48000u32;
    let events = [MidiEvent::note_on(sr as u64 / 10, 0, key, 0.8), MidiEvent::note_off(sr as u64, 0, key)];
    let opts = PluginOptions { params, ..Default::default() };
    match render_instrument_with(&plugin, &events, sr, 2.0, &opts) {
        Ok(run) => {
            let a = &run.audio;
            let onset = a.data[0].iter().position(|v| v.abs() > 1e-4);
            println!(
                "{} ({}): {} frames, peak {:.3}, first sound at frame {:?} (note at {}), latency {}",
                plugin.name,
                plugin.format,
                a.frames(),
                a.peak(),
                onset,
                sr / 10,
                run.latency
            );
            std::fs::write(&args[1], ferraus_core::wav::encode(a, 32, true).expect("encode")).expect("write");
        }
        Err(e) => {
            eprintln!("{e}");
            std::process::exit(e.exit_code);
        }
    }
}

pub fn note_off(frame: u64, channel: u8, key: u8) -> MidiEvent

Examples found in repository

examples/render_note.rs (line 24)

fn main() {
    let args: Vec<String> = std::env::args().skip(1).collect();
    if args.len() < 2 {
        eprintln!("usage: render_note <plugin> <out.wav> [midi key] [param=value ...]");
        std::process::exit(2);
    }
    let plugin = PluginRef::resolve(&args[0], &[]).unwrap_or_else(|e| {
        eprintln!("{e}");
        std::process::exit(e.exit_code)
    });
    let key: u8 = args.get(2).and_then(|k| k.parse().ok()).unwrap_or(60);
    let params =
        args.iter().skip(3).filter_map(|kv| kv.split_once('=').map(|(k, v)| (k.to_string(), v.to_string()))).collect();
    let sr = 48000u32;
    let events = [MidiEvent::note_on(sr as u64 / 10, 0, key, 0.8), MidiEvent::note_off(sr as u64, 0, key)];
    let opts = PluginOptions { params, ..Default::default() };
    match render_instrument_with(&plugin, &events, sr, 2.0, &opts) {
        Ok(run) => {
            let a = &run.audio;
            let onset = a.data[0].iter().position(|v| v.abs() > 1e-4);
            println!(
                "{} ({}): {} frames, peak {:.3}, first sound at frame {:?} (note at {}), latency {}",
                plugin.name,
                plugin.format,
                a.frames(),
                a.peak(),
                onset,
                sr / 10,
                run.latency
            );
            std::fs::write(&args[1], ferraus_core::wav::encode(a, 32, true).expect("encode")).expect("write");
        }
        Err(e) => {
            eprintln!("{e}");
            std::process::exit(e.exit_code);
        }
    }
}

Trait Implementations

impl Clone for MidiEvent

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for MidiEvent

impl Debug for MidiEvent

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

Formats the value using the given formatter.

impl PartialEq for MidiEvent

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for MidiEvent