Enum TrackEventKind 

pub enum TrackEventKind<'a> {
    Midi {
        channel: u4,
        message: MidiMessage,
    },
    SysEx(&'a [u8]),
    Escape(&'a [u8]),
    Meta(MetaMessage<'a>),
}

Represents the different kinds of SMF events and their associated data.

It notably does not include the timing of the event; the TrackEvent struct is responsible for this.

Variants

Midi

A message associated to a MIDI channel carrying musical data.

Usually, the bulk of MIDI data is these kind of messages.

Fields

channel: u4

The MIDI channel that this event is associated with.

message: MidiMessage

The MIDI message type and associated data.

SysEx(&'a [u8])

A System Exclusive message, carrying arbitrary data.

The data bytes included here do not include the implicit 0xF0 prefix.

Usually SysEx events end with an 0xF7 byte, but SysEx events that are split into several small packets may only contain the 0xF7 byte in the last packet fragment.

Escape(&'a [u8])

An escape sequence, intended to send arbitrary data to the MIDI synthesizer.

Meta(MetaMessage<'a>)

A meta-message, giving extra information for correct playback, like tempo, song name, lyrics, etc…

Implementations

impl<'a> TrackEventKind<'a>

pub fn as_live_event(&self) -> Option<LiveEvent<'a>>

Lossy conversion from a track event to a live event.

Only channel MIDI messages and not-split SysEx messages can be converted. Meta messages and arbitrary escapes yield None when converted.

pub fn to_static(&self) -> TrackEventKind<'static>

Remove any lifetimed data from this event to create a TrackEventKind with 'static lifetime that can be stored and moved everywhere, solving borrow checker issues.

WARNING: Any bytestrings in the input will be replaced by empty bytestrings.

Trait Implementations

impl<'a> Clone for TrackEventKind<'a>

fn clone(&self) -> TrackEventKind<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for TrackEventKind<'a>

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

Formats the value using the given formatter.

impl<'a> Hash for TrackEventKind<'a>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'a> PartialEq for TrackEventKind<'a>

fn eq(&self, other: &TrackEventKind<'a>) -> 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<'a> Copy for TrackEventKind<'a>

impl<'a> Eq for TrackEventKind<'a>

impl<'a> StructuralPartialEq for TrackEventKind<'a>