Standard MIDI file: C++/STL parsing library

File extension

["mid", "smf"]

KS implementation details

License: CC0-1.0

This page hosts a formal specification of Standard MIDI file using Kaitai Struct. This specification can be automatically translated into a variety of programming languages to get a parsing library.

Usage

Using Kaitai Struct in C++/STL usually consists of 3 steps.

  1. We need to create an STL input stream (std::istream).
    • One can open a stream for reading from a local file:
      #include <fstream>
      
      std::ifstream is("path/to/local/file.["mid", "smf"]", std::ifstream::binary);
    • Or one can prepare a stream for reading from existing std::string str:
      #include <sstream>
      
      std::istringstream is(str);
    • Or one can parse arbitrary char* buffer in memory, given that we know its size:
      #include <sstream>
      
      const char buf[] = { ... };
      std::string str(buf, sizeof buf);
      std::istringstream is(str);
  2. We need to wrap our input stream into Kaitai stream:
    #include <kaitai/kaitaistream.h>
    
    kaitai::kstream ks(&is);
  3. And finally, we can invoke the parsing:
    standard_midi_file_t data(&ks);

After that, one can get various attributes from the structure by invoking getter methods like:

data.hdr() // => get hdr

C++/STL source code to parse Standard MIDI file

standard_midi_file.h

#ifndef STANDARD_MIDI_FILE_H_
#define STANDARD_MIDI_FILE_H_

// This is a generated file! Please edit source .ksy file and use kaitai-struct-compiler to rebuild

#include "kaitai/kaitaistruct.h"

#include <stdint.h>
#include <vector>

#if KAITAI_STRUCT_VERSION < 7000L
#error "Incompatible Kaitai Struct C++/STL API: version 0.7 or later is required"
#endif
class vlq_base128_be_t;

class standard_midi_file_t : public kaitai::kstruct {

public:
    class track_events_t;
    class track_event_t;
    class pitch_bend_event_t;
    class program_change_event_t;
    class note_on_event_t;
    class polyphonic_pressure_event_t;
    class track_t;
    class meta_event_body_t;
    class controller_event_t;
    class header_t;
    class sysex_event_body_t;
    class note_off_event_t;
    class channel_pressure_event_t;

    standard_midi_file_t(kaitai::kstream* p__io, kaitai::kstruct* p__parent = 0, standard_midi_file_t* p__root = 0);

private:
    void _read();

public:
    ~standard_midi_file_t();

    class track_events_t : public kaitai::kstruct {

    public:

        track_events_t(kaitai::kstream* p__io, standard_midi_file_t::track_t* p__parent = 0, standard_midi_file_t* p__root = 0);

    private:
        void _read();

    public:
        ~track_events_t();

    private:
        std::vector<track_event_t*>* m_event;
        standard_midi_file_t* m__root;
        standard_midi_file_t::track_t* m__parent;

    public:
        std::vector<track_event_t*>* event() const { return m_event; }
        standard_midi_file_t* _root() const { return m__root; }
        standard_midi_file_t::track_t* _parent() const { return m__parent; }
    };

    class track_event_t : public kaitai::kstruct {

    public:

        track_event_t(kaitai::kstream* p__io, standard_midi_file_t::track_events_t* p__parent = 0, standard_midi_file_t* p__root = 0);

    private:
        void _read();

    public:
        ~track_event_t();

    private:
        bool f_event_type;
        int32_t m_event_type;

    public:
        int32_t event_type();

    private:
        bool f_channel;
        int32_t m_channel;
        bool n_channel;

    public:
        bool _is_null_channel() { channel(); return n_channel; };

    private:

    public:
        int32_t channel();

    private:
        vlq_base128_be_t* m_v_time;
        uint8_t m_event_header;
        meta_event_body_t* m_meta_event_body;
        bool n_meta_event_body;

    public:
        bool _is_null_meta_event_body() { meta_event_body(); return n_meta_event_body; };

    private:
        sysex_event_body_t* m_sysex_body;
        bool n_sysex_body;

    public:
        bool _is_null_sysex_body() { sysex_body(); return n_sysex_body; };

    private:
        kaitai::kstruct* m_event_body;
        bool n_event_body;

    public:
        bool _is_null_event_body() { event_body(); return n_event_body; };

    private:
        standard_midi_file_t* m__root;
        standard_midi_file_t::track_events_t* m__parent;

    public:
        vlq_base128_be_t* v_time() const { return m_v_time; }
        uint8_t event_header() const { return m_event_header; }
        meta_event_body_t* meta_event_body() const { return m_meta_event_body; }
        sysex_event_body_t* sysex_body() const { return m_sysex_body; }
        kaitai::kstruct* event_body() const { return m_event_body; }
        standard_midi_file_t* _root() const { return m__root; }
        standard_midi_file_t::track_events_t* _parent() const { return m__parent; }
    };

    class pitch_bend_event_t : public kaitai::kstruct {

    public:

        pitch_bend_event_t(kaitai::kstream* p__io, standard_midi_file_t::track_event_t* p__parent = 0, standard_midi_file_t* p__root = 0);

    private:
        void _read();

    public:
        ~pitch_bend_event_t();

    private:
        bool f_bend_value;
        int32_t m_bend_value;

    public:
        int32_t bend_value();

    private:
        bool f_adj_bend_value;
        int32_t m_adj_bend_value;

    public:
        int32_t adj_bend_value();

    private:
        uint8_t m_b1;
        uint8_t m_b2;
        standard_midi_file_t* m__root;
        standard_midi_file_t::track_event_t* m__parent;

    public:
        uint8_t b1() const { return m_b1; }
        uint8_t b2() const { return m_b2; }
        standard_midi_file_t* _root() const { return m__root; }
        standard_midi_file_t::track_event_t* _parent() const { return m__parent; }
    };

    class program_change_event_t : public kaitai::kstruct {

    public:

        program_change_event_t(kaitai::kstream* p__io, standard_midi_file_t::track_event_t* p__parent = 0, standard_midi_file_t* p__root = 0);

    private:
        void _read();

    public:
        ~program_change_event_t();

    private:
        uint8_t m_program;
        standard_midi_file_t* m__root;
        standard_midi_file_t::track_event_t* m__parent;

    public:
        uint8_t program() const { return m_program; }
        standard_midi_file_t* _root() const { return m__root; }
        standard_midi_file_t::track_event_t* _parent() const { return m__parent; }
    };

    class note_on_event_t : public kaitai::kstruct {

    public:

        note_on_event_t(kaitai::kstream* p__io, standard_midi_file_t::track_event_t* p__parent = 0, standard_midi_file_t* p__root = 0);

    private:
        void _read();

    public:
        ~note_on_event_t();

    private:
        uint8_t m_note;
        uint8_t m_velocity;
        standard_midi_file_t* m__root;
        standard_midi_file_t::track_event_t* m__parent;

    public:
        uint8_t note() const { return m_note; }
        uint8_t velocity() const { return m_velocity; }
        standard_midi_file_t* _root() const { return m__root; }
        standard_midi_file_t::track_event_t* _parent() const { return m__parent; }
    };

    class polyphonic_pressure_event_t : public kaitai::kstruct {

    public:

        polyphonic_pressure_event_t(kaitai::kstream* p__io, standard_midi_file_t::track_event_t* p__parent = 0, standard_midi_file_t* p__root = 0);

    private:
        void _read();

    public:
        ~polyphonic_pressure_event_t();

    private:
        uint8_t m_note;
        uint8_t m_pressure;
        standard_midi_file_t* m__root;
        standard_midi_file_t::track_event_t* m__parent;

    public:
        uint8_t note() const { return m_note; }
        uint8_t pressure() const { return m_pressure; }
        standard_midi_file_t* _root() const { return m__root; }
        standard_midi_file_t::track_event_t* _parent() const { return m__parent; }
    };

    class track_t : public kaitai::kstruct {

    public:

        track_t(kaitai::kstream* p__io, standard_midi_file_t* p__parent = 0, standard_midi_file_t* p__root = 0);

    private:
        void _read();

    public:
        ~track_t();

    private:
        std::string m_magic;
        uint32_t m_track_length;
        track_events_t* m_events;
        standard_midi_file_t* m__root;
        standard_midi_file_t* m__parent;
        std::string m__raw_events;
        kaitai::kstream* m__io__raw_events;

    public:
        std::string magic() const { return m_magic; }
        uint32_t track_length() const { return m_track_length; }
        track_events_t* events() const { return m_events; }
        standard_midi_file_t* _root() const { return m__root; }
        standard_midi_file_t* _parent() const { return m__parent; }
        std::string _raw_events() const { return m__raw_events; }
        kaitai::kstream* _io__raw_events() const { return m__io__raw_events; }
    };

    class meta_event_body_t : public kaitai::kstruct {

    public:

        enum meta_type_enum_t {
            META_TYPE_ENUM_SEQUENCE_NUMBER = 0,
            META_TYPE_ENUM_TEXT_EVENT = 1,
            META_TYPE_ENUM_COPYRIGHT = 2,
            META_TYPE_ENUM_SEQUENCE_TRACK_NAME = 3,
            META_TYPE_ENUM_INSTRUMENT_NAME = 4,
            META_TYPE_ENUM_LYRIC_TEXT = 5,
            META_TYPE_ENUM_MARKER_TEXT = 6,
            META_TYPE_ENUM_CUE_POINT = 7,
            META_TYPE_ENUM_MIDI_CHANNEL_PREFIX_ASSIGNMENT = 32,
            META_TYPE_ENUM_END_OF_TRACK = 47,
            META_TYPE_ENUM_TEMPO = 81,
            META_TYPE_ENUM_SMPTE_OFFSET = 84,
            META_TYPE_ENUM_TIME_SIGNATURE = 88,
            META_TYPE_ENUM_KEY_SIGNATURE = 89,
            META_TYPE_ENUM_SEQUENCER_SPECIFIC_EVENT = 127
        };

        meta_event_body_t(kaitai::kstream* p__io, standard_midi_file_t::track_event_t* p__parent = 0, standard_midi_file_t* p__root = 0);

    private:
        void _read();

    public:
        ~meta_event_body_t();

    private:
        meta_type_enum_t m_meta_type;
        vlq_base128_be_t* m_len;
        std::string m_body;
        standard_midi_file_t* m__root;
        standard_midi_file_t::track_event_t* m__parent;

    public:
        meta_type_enum_t meta_type() const { return m_meta_type; }
        vlq_base128_be_t* len() const { return m_len; }
        std::string body() const { return m_body; }
        standard_midi_file_t* _root() const { return m__root; }
        standard_midi_file_t::track_event_t* _parent() const { return m__parent; }
    };

    class controller_event_t : public kaitai::kstruct {

    public:

        controller_event_t(kaitai::kstream* p__io, standard_midi_file_t::track_event_t* p__parent = 0, standard_midi_file_t* p__root = 0);

    private:
        void _read();

    public:
        ~controller_event_t();

    private:
        uint8_t m_controller;
        uint8_t m_value;
        standard_midi_file_t* m__root;
        standard_midi_file_t::track_event_t* m__parent;

    public:
        uint8_t controller() const { return m_controller; }
        uint8_t value() const { return m_value; }
        standard_midi_file_t* _root() const { return m__root; }
        standard_midi_file_t::track_event_t* _parent() const { return m__parent; }
    };

    class header_t : public kaitai::kstruct {

    public:

        header_t(kaitai::kstream* p__io, standard_midi_file_t* p__parent = 0, standard_midi_file_t* p__root = 0);

    private:
        void _read();

    public:
        ~header_t();

    private:
        std::string m_magic;
        uint32_t m_header_length;
        uint16_t m_format;
        uint16_t m_qty_tracks;
        int16_t m_division;
        standard_midi_file_t* m__root;
        standard_midi_file_t* m__parent;

    public:
        std::string magic() const { return m_magic; }
        uint32_t header_length() const { return m_header_length; }
        uint16_t format() const { return m_format; }
        uint16_t qty_tracks() const { return m_qty_tracks; }
        int16_t division() const { return m_division; }
        standard_midi_file_t* _root() const { return m__root; }
        standard_midi_file_t* _parent() const { return m__parent; }
    };

    class sysex_event_body_t : public kaitai::kstruct {

    public:

        sysex_event_body_t(kaitai::kstream* p__io, standard_midi_file_t::track_event_t* p__parent = 0, standard_midi_file_t* p__root = 0);

    private:
        void _read();

    public:
        ~sysex_event_body_t();

    private:
        vlq_base128_be_t* m_len;
        std::string m_data;
        standard_midi_file_t* m__root;
        standard_midi_file_t::track_event_t* m__parent;

    public:
        vlq_base128_be_t* len() const { return m_len; }
        std::string data() const { return m_data; }
        standard_midi_file_t* _root() const { return m__root; }
        standard_midi_file_t::track_event_t* _parent() const { return m__parent; }
    };

    class note_off_event_t : public kaitai::kstruct {

    public:

        note_off_event_t(kaitai::kstream* p__io, standard_midi_file_t::track_event_t* p__parent = 0, standard_midi_file_t* p__root = 0);

    private:
        void _read();

    public:
        ~note_off_event_t();

    private:
        uint8_t m_note;
        uint8_t m_velocity;
        standard_midi_file_t* m__root;
        standard_midi_file_t::track_event_t* m__parent;

    public:
        uint8_t note() const { return m_note; }
        uint8_t velocity() const { return m_velocity; }
        standard_midi_file_t* _root() const { return m__root; }
        standard_midi_file_t::track_event_t* _parent() const { return m__parent; }
    };

    class channel_pressure_event_t : public kaitai::kstruct {

    public:

        channel_pressure_event_t(kaitai::kstream* p__io, standard_midi_file_t::track_event_t* p__parent = 0, standard_midi_file_t* p__root = 0);

    private:
        void _read();

    public:
        ~channel_pressure_event_t();

    private:
        uint8_t m_pressure;
        standard_midi_file_t* m__root;
        standard_midi_file_t::track_event_t* m__parent;

    public:
        uint8_t pressure() const { return m_pressure; }
        standard_midi_file_t* _root() const { return m__root; }
        standard_midi_file_t::track_event_t* _parent() const { return m__parent; }
    };

private:
    header_t* m_hdr;
    std::vector<track_t*>* m_tracks;
    standard_midi_file_t* m__root;
    kaitai::kstruct* m__parent;

public:
    header_t* hdr() const { return m_hdr; }
    std::vector<track_t*>* tracks() const { return m_tracks; }
    standard_midi_file_t* _root() const { return m__root; }
    kaitai::kstruct* _parent() const { return m__parent; }
};

#endif  // STANDARD_MIDI_FILE_H_

standard_midi_file.cpp

// This is a generated file! Please edit source .ksy file and use kaitai-struct-compiler to rebuild

#include "standard_midi_file.h"


#include "vlq_base128_be.h"

standard_midi_file_t::standard_midi_file_t(kaitai::kstream* p__io, kaitai::kstruct* p__parent, standard_midi_file_t* p__root) : kaitai::kstruct(p__io) {
    m__parent = p__parent;
    m__root = this;
    _read();
}

void standard_midi_file_t::_read() {
    m_hdr = new header_t(m__io, this, m__root);
    int l_tracks = hdr()->qty_tracks();
    m_tracks = new std::vector<track_t*>();
    m_tracks->reserve(l_tracks);
    for (int i = 0; i < l_tracks; i++) {
        m_tracks->push_back(new track_t(m__io, this, m__root));
    }
}

standard_midi_file_t::~standard_midi_file_t() {
    delete m_hdr;
    for (std::vector<track_t*>::iterator it = m_tracks->begin(); it != m_tracks->end(); ++it) {
        delete *it;
    }
    delete m_tracks;
}

standard_midi_file_t::track_events_t::track_events_t(kaitai::kstream* p__io, standard_midi_file_t::track_t* p__parent, standard_midi_file_t* p__root) : kaitai::kstruct(p__io) {
    m__parent = p__parent;
    m__root = p__root;
    _read();
}

void standard_midi_file_t::track_events_t::_read() {
    m_event = new std::vector<track_event_t*>();
    {
        int i = 0;
        while (!m__io->is_eof()) {
            m_event->push_back(new track_event_t(m__io, this, m__root));
            i++;
        }
    }
}

standard_midi_file_t::track_events_t::~track_events_t() {
    for (std::vector<track_event_t*>::iterator it = m_event->begin(); it != m_event->end(); ++it) {
        delete *it;
    }
    delete m_event;
}

standard_midi_file_t::track_event_t::track_event_t(kaitai::kstream* p__io, standard_midi_file_t::track_events_t* p__parent, standard_midi_file_t* p__root) : kaitai::kstruct(p__io) {
    m__parent = p__parent;
    m__root = p__root;
    f_event_type = false;
    f_channel = false;
    _read();
}

void standard_midi_file_t::track_event_t::_read() {
    m_v_time = new vlq_base128_be_t(m__io);
    m_event_header = m__io->read_u1();
    n_meta_event_body = true;
    if (event_header() == 255) {
        n_meta_event_body = false;
        m_meta_event_body = new meta_event_body_t(m__io, this, m__root);
    }
    n_sysex_body = true;
    if (event_header() == 240) {
        n_sysex_body = false;
        m_sysex_body = new sysex_event_body_t(m__io, this, m__root);
    }
    n_event_body = true;
    switch (event_type()) {
    case 224: {
        n_event_body = false;
        m_event_body = new pitch_bend_event_t(m__io, this, m__root);
        break;
    }
    case 144: {
        n_event_body = false;
        m_event_body = new note_on_event_t(m__io, this, m__root);
        break;
    }
    case 208: {
        n_event_body = false;
        m_event_body = new channel_pressure_event_t(m__io, this, m__root);
        break;
    }
    case 192: {
        n_event_body = false;
        m_event_body = new program_change_event_t(m__io, this, m__root);
        break;
    }
    case 160: {
        n_event_body = false;
        m_event_body = new polyphonic_pressure_event_t(m__io, this, m__root);
        break;
    }
    case 176: {
        n_event_body = false;
        m_event_body = new controller_event_t(m__io, this, m__root);
        break;
    }
    case 128: {
        n_event_body = false;
        m_event_body = new note_off_event_t(m__io, this, m__root);
        break;
    }
    }
}

standard_midi_file_t::track_event_t::~track_event_t() {
    delete m_v_time;
    if (!n_meta_event_body) {
        delete m_meta_event_body;
    }
    if (!n_sysex_body) {
        delete m_sysex_body;
    }
    if (!n_event_body) {
        delete m_event_body;
    }
}

int32_t standard_midi_file_t::track_event_t::event_type() {
    if (f_event_type)
        return m_event_type;
    m_event_type = (event_header() & 240);
    f_event_type = true;
    return m_event_type;
}

int32_t standard_midi_file_t::track_event_t::channel() {
    if (f_channel)
        return m_channel;
    n_channel = true;
    if (event_type() != 240) {
        n_channel = false;
        m_channel = (event_header() & 15);
    }
    f_channel = true;
    return m_channel;
}

standard_midi_file_t::pitch_bend_event_t::pitch_bend_event_t(kaitai::kstream* p__io, standard_midi_file_t::track_event_t* p__parent, standard_midi_file_t* p__root) : kaitai::kstruct(p__io) {
    m__parent = p__parent;
    m__root = p__root;
    f_bend_value = false;
    f_adj_bend_value = false;
    _read();
}

void standard_midi_file_t::pitch_bend_event_t::_read() {
    m_b1 = m__io->read_u1();
    m_b2 = m__io->read_u1();
}

standard_midi_file_t::pitch_bend_event_t::~pitch_bend_event_t() {
}

int32_t standard_midi_file_t::pitch_bend_event_t::bend_value() {
    if (f_bend_value)
        return m_bend_value;
    m_bend_value = (((b2() << 7) + b1()) - 16384);
    f_bend_value = true;
    return m_bend_value;
}

int32_t standard_midi_file_t::pitch_bend_event_t::adj_bend_value() {
    if (f_adj_bend_value)
        return m_adj_bend_value;
    m_adj_bend_value = (bend_value() - 16384);
    f_adj_bend_value = true;
    return m_adj_bend_value;
}

standard_midi_file_t::program_change_event_t::program_change_event_t(kaitai::kstream* p__io, standard_midi_file_t::track_event_t* p__parent, standard_midi_file_t* p__root) : kaitai::kstruct(p__io) {
    m__parent = p__parent;
    m__root = p__root;
    _read();
}

void standard_midi_file_t::program_change_event_t::_read() {
    m_program = m__io->read_u1();
}

standard_midi_file_t::program_change_event_t::~program_change_event_t() {
}

standard_midi_file_t::note_on_event_t::note_on_event_t(kaitai::kstream* p__io, standard_midi_file_t::track_event_t* p__parent, standard_midi_file_t* p__root) : kaitai::kstruct(p__io) {
    m__parent = p__parent;
    m__root = p__root;
    _read();
}

void standard_midi_file_t::note_on_event_t::_read() {
    m_note = m__io->read_u1();
    m_velocity = m__io->read_u1();
}

standard_midi_file_t::note_on_event_t::~note_on_event_t() {
}

standard_midi_file_t::polyphonic_pressure_event_t::polyphonic_pressure_event_t(kaitai::kstream* p__io, standard_midi_file_t::track_event_t* p__parent, standard_midi_file_t* p__root) : kaitai::kstruct(p__io) {
    m__parent = p__parent;
    m__root = p__root;
    _read();
}

void standard_midi_file_t::polyphonic_pressure_event_t::_read() {
    m_note = m__io->read_u1();
    m_pressure = m__io->read_u1();
}

standard_midi_file_t::polyphonic_pressure_event_t::~polyphonic_pressure_event_t() {
}

standard_midi_file_t::track_t::track_t(kaitai::kstream* p__io, standard_midi_file_t* p__parent, standard_midi_file_t* p__root) : kaitai::kstruct(p__io) {
    m__parent = p__parent;
    m__root = p__root;
    _read();
}

void standard_midi_file_t::track_t::_read() {
    m_magic = m__io->ensure_fixed_contents(std::string("\x4D\x54\x72\x6B", 4));
    m_track_length = m__io->read_u4be();
    m__raw_events = m__io->read_bytes(track_length());
    m__io__raw_events = new kaitai::kstream(m__raw_events);
    m_events = new track_events_t(m__io__raw_events, this, m__root);
}

standard_midi_file_t::track_t::~track_t() {
    delete m__io__raw_events;
    delete m_events;
}

standard_midi_file_t::meta_event_body_t::meta_event_body_t(kaitai::kstream* p__io, standard_midi_file_t::track_event_t* p__parent, standard_midi_file_t* p__root) : kaitai::kstruct(p__io) {
    m__parent = p__parent;
    m__root = p__root;
    _read();
}

void standard_midi_file_t::meta_event_body_t::_read() {
    m_meta_type = static_cast<standard_midi_file_t::meta_event_body_t::meta_type_enum_t>(m__io->read_u1());
    m_len = new vlq_base128_be_t(m__io);
    m_body = m__io->read_bytes(len()->value());
}

standard_midi_file_t::meta_event_body_t::~meta_event_body_t() {
    delete m_len;
}

standard_midi_file_t::controller_event_t::controller_event_t(kaitai::kstream* p__io, standard_midi_file_t::track_event_t* p__parent, standard_midi_file_t* p__root) : kaitai::kstruct(p__io) {
    m__parent = p__parent;
    m__root = p__root;
    _read();
}

void standard_midi_file_t::controller_event_t::_read() {
    m_controller = m__io->read_u1();
    m_value = m__io->read_u1();
}

standard_midi_file_t::controller_event_t::~controller_event_t() {
}

standard_midi_file_t::header_t::header_t(kaitai::kstream* p__io, standard_midi_file_t* p__parent, standard_midi_file_t* p__root) : kaitai::kstruct(p__io) {
    m__parent = p__parent;
    m__root = p__root;
    _read();
}

void standard_midi_file_t::header_t::_read() {
    m_magic = m__io->ensure_fixed_contents(std::string("\x4D\x54\x68\x64", 4));
    m_header_length = m__io->read_u4be();
    m_format = m__io->read_u2be();
    m_qty_tracks = m__io->read_u2be();
    m_division = m__io->read_s2be();
}

standard_midi_file_t::header_t::~header_t() {
}

standard_midi_file_t::sysex_event_body_t::sysex_event_body_t(kaitai::kstream* p__io, standard_midi_file_t::track_event_t* p__parent, standard_midi_file_t* p__root) : kaitai::kstruct(p__io) {
    m__parent = p__parent;
    m__root = p__root;
    _read();
}

void standard_midi_file_t::sysex_event_body_t::_read() {
    m_len = new vlq_base128_be_t(m__io);
    m_data = m__io->read_bytes(len()->value());
}

standard_midi_file_t::sysex_event_body_t::~sysex_event_body_t() {
    delete m_len;
}

standard_midi_file_t::note_off_event_t::note_off_event_t(kaitai::kstream* p__io, standard_midi_file_t::track_event_t* p__parent, standard_midi_file_t* p__root) : kaitai::kstruct(p__io) {
    m__parent = p__parent;
    m__root = p__root;
    _read();
}

void standard_midi_file_t::note_off_event_t::_read() {
    m_note = m__io->read_u1();
    m_velocity = m__io->read_u1();
}

standard_midi_file_t::note_off_event_t::~note_off_event_t() {
}

standard_midi_file_t::channel_pressure_event_t::channel_pressure_event_t(kaitai::kstream* p__io, standard_midi_file_t::track_event_t* p__parent, standard_midi_file_t* p__root) : kaitai::kstruct(p__io) {
    m__parent = p__parent;
    m__root = p__root;
    _read();
}

void standard_midi_file_t::channel_pressure_event_t::_read() {
    m_pressure = m__io->read_u1();
}

standard_midi_file_t::channel_pressure_event_t::~channel_pressure_event_t() {
}