Enum Track 

pub enum Track {
    Midi(MidiTrack),
    Audio(AudioTrack),
}

Wrapper type allowing processors to operate on MIDI or audio data.

Variants

Midi(MidiTrack)

Audio(AudioTrack)

Implementations

impl Track

pub fn from_midi<P: AsRef<Path>>(path: P) -> Result<Self>

Load a MIDI track from a lightweight text representation where each line contains note velocity.

pub fn from_audio(samples: Vec<f32>, sample_rate: u32) -> Self

Construct an audio track from samples and a sample rate.

Examples found in repository

examples/audio_gain.rs (line 5)

fn main() -> humster::Result<()> {
    use humster::prelude::*;

    let mut track = Track::from_audio(vec![0.1, -0.3, 0.5], 48_000);

    struct Gain(f32);

    impl Processor for Gain {
        fn process_audio(&self, track: &mut AudioTrack) {
            for sample in track.samples.iter_mut() {
                *sample *= self.0;
            }
        }
    }

    let gain = Gain(1.5);
    track.apply(&gain);

    if let Some(audio) = track.as_audio() {
        println!("Sample rate: {}", audio.sample_rate);
        for (idx, sample) in audio.samples.iter().enumerate() {
            println!("Sample #{idx}: {sample:.3}");
        }
    }

    Ok(())
}

pub fn apply<P: Processor>(&mut self, processor: &P)

Apply a processor to the underlying track representation.

Examples found in repository

examples/audio_gain.rs (line 18)

fn main() -> humster::Result<()> {
    use humster::prelude::*;

    let mut track = Track::from_audio(vec![0.1, -0.3, 0.5], 48_000);

    struct Gain(f32);

    impl Processor for Gain {
        fn process_audio(&self, track: &mut AudioTrack) {
            for sample in track.samples.iter_mut() {
                *sample *= self.0;
            }
        }
    }

    let gain = Gain(1.5);
    track.apply(&gain);

    if let Some(audio) = track.as_audio() {
        println!("Sample rate: {}", audio.sample_rate);
        for (idx, sample) in audio.samples.iter().enumerate() {
            println!("Sample #{idx}: {sample:.3}");
        }
    }

    Ok(())
}

examples/midi_input.rs (line 22)

fn main() -> humster::Result<()> {
    use humster::prelude::*;

    let mut track = Track::Midi(MidiTrack::new(vec![
        MidiEvent::new(60, 80),
        MidiEvent::new(64, 90),
    ]));

    struct VelocityBoost(f32);

    impl Processor for VelocityBoost {
        fn process_midi(&self, track: &mut MidiTrack) {
            for event in track.events.iter_mut() {
                let boosted = (event.velocity as f32 * self.0).round() as u32;
                event.velocity = boosted.min(127) as u8;
            }
        }
    }

    let boost = VelocityBoost(1.25);
    track.apply(&boost);

    if let Some(midi) = track.as_midi() {
        for (idx, event) in midi.events().iter().enumerate() {
            println!("Event #{idx}: note {}, velocity {}", event.note, event.velocity);
        }
    }

    Ok(())
}

pub fn export<P: AsRef<Path>>(&self, path: P) -> Result<()>

Export a track to the lightweight text formats understood by from_midi and from_audio.

pub fn as_midi(&self) -> Option<&MidiTrack>

Returns the contained MIDI track if present.

Examples found in repository

examples/midi_input.rs (line 24)

fn main() -> humster::Result<()> {
    use humster::prelude::*;

    let mut track = Track::Midi(MidiTrack::new(vec![
        MidiEvent::new(60, 80),
        MidiEvent::new(64, 90),
    ]));

    struct VelocityBoost(f32);

    impl Processor for VelocityBoost {
        fn process_midi(&self, track: &mut MidiTrack) {
            for event in track.events.iter_mut() {
                let boosted = (event.velocity as f32 * self.0).round() as u32;
                event.velocity = boosted.min(127) as u8;
            }
        }
    }

    let boost = VelocityBoost(1.25);
    track.apply(&boost);

    if let Some(midi) = track.as_midi() {
        for (idx, event) in midi.events().iter().enumerate() {
            println!("Event #{idx}: note {}, velocity {}", event.note, event.velocity);
        }
    }

    Ok(())
}

pub fn as_midi_mut(&mut self) -> Option<&mut MidiTrack>

Returns the contained MIDI track mutably if present.

pub fn as_audio(&self) -> Option<&AudioTrack>

Returns the contained audio track if present.

Examples found in repository

examples/audio_gain.rs (line 20)

fn main() -> humster::Result<()> {
    use humster::prelude::*;

    let mut track = Track::from_audio(vec![0.1, -0.3, 0.5], 48_000);

    struct Gain(f32);

    impl Processor for Gain {
        fn process_audio(&self, track: &mut AudioTrack) {
            for sample in track.samples.iter_mut() {
                *sample *= self.0;
            }
        }
    }

    let gain = Gain(1.5);
    track.apply(&gain);

    if let Some(audio) = track.as_audio() {
        println!("Sample rate: {}", audio.sample_rate);
        for (idx, sample) in audio.samples.iter().enumerate() {
            println!("Sample #{idx}: {sample:.3}");
        }
    }

    Ok(())
}

pub fn as_audio_mut(&mut self) -> Option<&mut AudioTrack>

Returns the contained audio track mutably if present.

Trait Implementations

impl Clone for Track

fn clone(&self) -> Track

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Track

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

Formats the value using the given formatter.

impl PartialEq for Track

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Track