Struct libatm::MIDIFile

pub struct MIDIFile {
    pub sequence: MIDINoteSequence,
    pub format: MIDIFormat,
    pub tracks: u16,
    pub division: u16,
}

MIDI file representation

MIDI files can be complex, allowing for any number of tracks with different notes and instruments playing simultaneously. This library was created for the express purpose of brute-forcing melodies, and thus only supports a subset of the official MIDI standard. More specifically, this class is optimized for creating the smallest possible single track MIDI files.

Fields

sequence: MIDINoteSequence

Sequence of notes (MIDINoteSequence) from which the track chunk is generated

format: MIDIFormat

Format specification (should always be MIDIFormat::0)

tracks: u16

Number of tracks in MIDI file (should always be 1)

division: u16

Number of ticks to represent a quarter-note (recommended to use 1)

Methods

impl MIDIFile

pub fn new(
    sequence: MIDINoteSequence,
    format: MIDIFormat,
    tracks: u16,
    division: u16
) -> MIDIFile

Create new MIDIFile

Arguments

See field comments above.

Examples

let mfile = libatm::MIDIFile::new(
    libatm::MIDINoteSequence::new(vec![
        libatm::MIDINote::new(libatm::MIDINoteType::C, 4),
        libatm::MIDINote::new(libatm::MIDINoteType::D, 5),
        libatm::MIDINote::new(libatm::MIDINoteType::CSharp, 8),
        libatm::MIDINote::new(libatm::MIDINoteType::DSharp, 3),
    ]),
    libatm::MIDIFormat::Format0,
    1,
    1,
);
assert_eq!("607410951", mfile.gen_hash());

pub fn gen_track_size_static(num_notes: u32) -> u32

Generate the size in bytes of the track chunk for a MIDI file with a sequence of length num_notes once written to disk

pub fn gen_size_static(num_notes: u32) -> u32

Generate the size in bytes of a MIDI file with a sequence of length num_notes once written to disk

pub fn gen_hash(&self) -> String

Generate unique hash for this file's MIDINoteSequence

This hash function simply concatenates the sequential integer representation of the file's MIDINotesequence. By this definition, no two non-identical sequences can have the same hash. The primary intended purpose of this function is to allow for O(1) lookups by note sequence once a file has been written to disk, and thus there is no requirement to mitigate collisions for identical sequences.

pub fn gen_header(&self) -> MIDIHeader

Generate header chunk (see: MIDIHeader)

pub fn gen_track_size(&self) -> u32

Generate the size in bytes of the track chunk once written to disk

pub fn gen_track_header(&self) -> MIDITrackHeader

Generate track chunk header (see: MIDITrackHeader)

pub fn gen_track(&self) -> Vec<MIDIChannelVoiceMessage>

Generate track data (see: MIDIChannelVoiceMessage)

pub fn gen_size(&self) -> u32

Generate the size in bytes of this MIDI file once written to disk

pub fn write_buffer<T>(&self, target: &mut T) -> Result<()> where
    T: WriteBytesExt, 

Write MIDI file to buffer

pub fn gen_buffer(&self) -> Result<Vec<u8>>

Generate buffer containing entire MIDI file

pub fn write_file(&self, path: &str) -> Result<()>

Write MIDI file to path on disk

Trait Implementations

impl Clone for MIDIFile

fn clone(&self) -> MIDIFile

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for MIDIFile

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

Formats the value using the given formatter.