aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
-rw-r--r--src/engine/SMFReader.cpp311
-rw-r--r--src/engine/SMFReader.hpp81
-rw-r--r--src/engine/SMFWriter.cpp235
-rw-r--r--src/engine/SMFWriter.hpp71
-rw-r--r--src/engine/smf_test.cpp80
5 files changed, 778 insertions, 0 deletions
diff --git a/src/engine/SMFReader.cpp b/src/engine/SMFReader.cpp
new file mode 100644
index 0000000..0474f88
--- /dev/null
+++ b/src/engine/SMFReader.cpp
@@ -0,0 +1,311 @@
+/*
+ This file is part of Raul.
+ Copyright 2007-2012 David Robillard <http://drobilla.net>
+
+ Raul is free software: you can redistribute it and/or modify it under the
+ terms of the GNU General Public License as published by the Free Software
+ Foundation, either version 3 of the License, or any later version.
+
+ Raul is distributed in the hope that it will be useful, but WITHOUT ANY
+ WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with Raul. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <glib.h>
+
+#include <cassert>
+#include <cstdio>
+#include <cstring>
+#include <string>
+
+#include "raul/log.hpp"
+#include "raul/SMFReader.hpp"
+#include "raul/midi_events.h"
+
+using std::endl;
+
+namespace Raul {
+
+/** Return the size of the given event NOT including the status byte,
+ * or -1 if unknown (eg sysex)
+ */
+static int
+midi_event_size(unsigned char status)
+{
+ if (status >= 0x80 && status <= 0xE0) {
+ status &= 0xF0; // mask off the channel
+ }
+
+ switch (status) {
+ case MIDI_CMD_NOTE_OFF:
+ case MIDI_CMD_NOTE_ON:
+ case MIDI_CMD_NOTE_PRESSURE:
+ case MIDI_CMD_CONTROL:
+ case MIDI_CMD_BENDER:
+ case MIDI_CMD_COMMON_SONG_POS:
+ return 2;
+
+ case MIDI_CMD_PGM_CHANGE:
+ case MIDI_CMD_CHANNEL_PRESSURE:
+ case MIDI_CMD_COMMON_MTC_QUARTER:
+ case MIDI_CMD_COMMON_SONG_SELECT:
+ return 1;
+
+ case MIDI_CMD_COMMON_TUNE_REQUEST:
+ case MIDI_CMD_COMMON_SYSEX_END:
+ case MIDI_CMD_COMMON_CLOCK:
+ case MIDI_CMD_COMMON_START:
+ case MIDI_CMD_COMMON_CONTINUE:
+ case MIDI_CMD_COMMON_STOP:
+ case MIDI_CMD_COMMON_SENSING:
+ case MIDI_CMD_COMMON_RESET:
+ return 0;
+
+ case MIDI_CMD_COMMON_SYSEX:
+ return -1;
+ }
+
+ return -1;
+}
+
+SMFReader::SMFReader(const std::string filename)
+ : _fd(NULL)
+ , _ppqn(0)
+ , _track(0)
+ , _track_size(0)
+{
+ if (filename.length() > 0)
+ open(filename);
+}
+
+SMFReader::~SMFReader()
+{
+ if (_fd)
+ close();
+}
+
+bool
+SMFReader::open(const std::string& filename) throw (std::logic_error, UnsupportedTime)
+{
+ if (_fd)
+ throw std::logic_error("Attempt to start new read while write in progress.");
+
+ info << "Opening SMF file " << filename << " for reading." << endl;
+
+ _fd = fopen(filename.c_str(), "r+");
+
+ if (_fd) {
+ // Read type (bytes 8..9)
+ fseek(_fd, 0, SEEK_SET);
+ char mthd[5];
+ mthd[4] = '\0';
+ fread(mthd, 1, 4, _fd);
+ if (strcmp(mthd, "MThd")) {
+ error << filename << " is not an SMF file, aborting." << endl;
+ fclose(_fd);
+ _fd = NULL;
+ return false;
+ }
+
+ // Read type (bytes 8..9)
+ fseek(_fd, 8, SEEK_SET);
+ uint16_t type_be = 0;
+ fread(&type_be, 2, 1, _fd);
+ _type = GUINT16_FROM_BE(type_be);
+
+ // Read number of tracks (bytes 10..11)
+ uint16_t num_tracks_be = 0;
+ fread(&num_tracks_be, 2, 1, _fd);
+ _num_tracks = GUINT16_FROM_BE(num_tracks_be);
+
+ // Read PPQN (bytes 12..13)
+ uint16_t ppqn_be = 0;
+ fread(&ppqn_be, 2, 1, _fd);
+ _ppqn = GUINT16_FROM_BE(ppqn_be);
+
+ // TODO: Absolute (SMPTE seconds) time support
+ if ((_ppqn & 0x8000) != 0)
+ throw UnsupportedTime();
+
+ seek_to_track(1);
+
+ return true;
+ } else {
+ return false;
+ }
+}
+
+/** Seek to the start of a given track, starting from 1.
+ * Returns true if specified track was found.
+ */
+bool
+SMFReader::seek_to_track(unsigned track) throw (std::logic_error)
+{
+ if (track == 0)
+ throw std::logic_error("Seek to track 0 out of range (must be >= 1)");
+
+ if (!_fd)
+ throw std::logic_error("Attempt to seek to track on unopened SMF file.");
+
+ unsigned track_pos = 0;
+
+ fseek(_fd, 14, SEEK_SET);
+ char id[5];
+ id[4] = '\0';
+ uint32_t chunk_size = 0;
+
+ while (!feof(_fd)) {
+ fread(id, 1, 4, _fd);
+
+ if (!strcmp(id, "MTrk")) {
+ ++track_pos;
+ } else {
+ error << "Unknown chunk ID " << id << endl;
+ }
+
+ uint32_t chunk_size_be;
+ fread(&chunk_size_be, 4, 1, _fd);
+ chunk_size = GUINT32_FROM_BE(chunk_size_be);
+
+ if (track_pos == track)
+ break;
+
+ fseek(_fd, chunk_size, SEEK_CUR);
+ }
+
+ if (!feof(_fd) && track_pos == track) {
+ _track = track;
+ _track_size = chunk_size;
+ return true;
+ } else {
+ return false;
+ }
+}
+
+/** Read an event from the current position in file.
+ *
+ * File position MUST be at the beginning of a delta time, or this will die very messily.
+ * ev.buffer must be of size ev.size, and large enough for the event. The returned event
+ * will have it's time field set to it's delta time (so it's the caller's responsibility
+ * to keep track of delta time, even for ignored events).
+ *
+ * Returns event length (including status byte) on success, 0 if event was
+ * skipped (eg a meta event), or -1 on EOF (or end of track).
+ *
+ * If @a buf is not large enough to hold the event, 0 will be returned, but ev_size
+ * set to the actual size of the event.
+ */
+int
+SMFReader::read_event(size_t buf_len,
+ uint8_t* buf,
+ uint32_t* ev_size,
+ uint32_t* delta_time)
+ throw (std::logic_error, PrematureEOF, CorruptFile)
+{
+ if (_track == 0)
+ throw std::logic_error("Attempt to read from unopened SMF file");
+
+ if (!_fd || feof(_fd)) {
+ return -1;
+ }
+
+ assert(buf_len > 0);
+ assert(buf);
+ assert(ev_size);
+ assert(delta_time);
+
+ // Running status state
+ static uint8_t last_status = 0;
+ static uint32_t last_size = 0;
+
+ *delta_time = read_var_len(_fd);
+ int status = fgetc(_fd);
+ if (status == EOF)
+ throw PrematureEOF();
+ else if (status > 0xFF)
+ throw CorruptFile();
+
+ if (status < 0x80) {
+ if (last_status == 0)
+ throw CorruptFile();
+ status = last_status;
+ *ev_size = last_size;
+ fseek(_fd, -1, SEEK_CUR);
+ } else {
+ last_status = status;
+ *ev_size = midi_event_size(status) + 1;
+ last_size = *ev_size;
+ }
+
+ buf[0] = static_cast<uint8_t>(status);
+
+ if (status == 0xFF) {
+ *ev_size = 0;
+ if (feof(_fd))
+ throw PrematureEOF();
+ uint8_t type = fgetc(_fd);
+ const uint32_t size = read_var_len(_fd);
+
+ if (type == 0x2F) {
+ return -1; // we hit the logical EOF anyway...
+ } else {
+ fseek(_fd, size, SEEK_CUR);
+ return 0;
+ }
+ }
+
+ if (*ev_size > buf_len || *ev_size == 0 || feof(_fd)) {
+ // Skip event, return 0
+ fseek(_fd, *ev_size - 1, SEEK_CUR);
+ return 0;
+ } else {
+ // Read event, return size
+ if (ferror(_fd))
+ throw CorruptFile();
+
+ fread(buf+1, 1, *ev_size - 1, _fd);
+
+ if ((buf[0] & 0xF0) == 0x90 && buf[2] == 0) {
+ buf[0] = (0x80 | (buf[0] & 0x0F));
+ buf[2] = 0x40;
+ }
+
+ return *ev_size;
+ }
+}
+
+void
+SMFReader::close()
+{
+ if (_fd)
+ fclose(_fd);
+
+ _fd = NULL;
+}
+
+uint32_t
+SMFReader::read_var_len(FILE* fd) throw (PrematureEOF)
+{
+ if (feof(fd))
+ throw PrematureEOF();
+
+ uint32_t value;
+ uint8_t c;
+
+ if ( (value = getc(fd)) & 0x80 ) {
+ value &= 0x7F;
+ do {
+ if (feof(fd))
+ throw PrematureEOF();
+ value = (value << 7) + ((c = getc(fd)) & 0x7F);
+ } while (c & 0x80);
+ }
+
+ return value;
+}
+
+} // namespace Raul
+
diff --git a/src/engine/SMFReader.hpp b/src/engine/SMFReader.hpp
new file mode 100644
index 0000000..dbca289
--- /dev/null
+++ b/src/engine/SMFReader.hpp
@@ -0,0 +1,81 @@
+/*
+ This file is part of Raul.
+ Copyright 2007-2012 David Robillard <http://drobilla.net>
+
+ Raul is free software: you can redistribute it and/or modify it under the
+ terms of the GNU General Public License as published by the Free Software
+ Foundation, either version 3 of the License, or any later version.
+
+ Raul is distributed in the hope that it will be useful, but WITHOUT ANY
+ WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with Raul. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef RAUL_SMF_READER_HPP
+#define RAUL_SMF_READER_HPP
+
+#include <stdexcept>
+#include <string>
+#include <inttypes.h>
+#include "raul/TimeStamp.hpp"
+
+namespace Raul {
+
+/** Standard Midi File (Type 0) Reader
+ *
+ * Currently this only reads SMF files with tempo-based timing.
+ * \ingroup raul
+ */
+class SMFReader {
+public:
+ class PrematureEOF : public std::exception {
+ const char* what() const throw() { return "Unexpected end of file"; }
+ };
+ class CorruptFile : public std::exception {
+ const char* what() const throw() { return "Corrupted file"; }
+ };
+ class UnsupportedTime : public std::exception {
+ const char* what() const throw() { return "Unsupported time stamp type (SMPTE)"; }
+ };
+
+ explicit SMFReader(const std::string filename="");
+ ~SMFReader();
+
+ bool open(const std::string& filename) throw (std::logic_error, UnsupportedTime);
+
+ bool seek_to_track(unsigned track) throw (std::logic_error);
+
+ uint16_t type() const { return _type; }
+ uint16_t ppqn() const { return _ppqn; }
+ size_t num_tracks() { return _num_tracks; }
+
+ int read_event(size_t buf_len,
+ uint8_t* buf,
+ uint32_t* ev_size,
+ uint32_t* ev_delta_time)
+ throw (std::logic_error, PrematureEOF, CorruptFile);
+
+ void close();
+
+ static uint32_t read_var_len(FILE* fd) throw (PrematureEOF);
+
+protected:
+ /** size of SMF header, including MTrk chunk header */
+ static const uint32_t HEADER_SIZE = 22;
+
+ std::string _filename;
+ FILE* _fd;
+ uint16_t _type;
+ uint16_t _ppqn;
+ uint16_t _num_tracks;
+ uint32_t _track;
+ uint32_t _track_size;
+};
+
+} // namespace Raul
+
+#endif // RAUL_SMF_READER_HPP
+
diff --git a/src/engine/SMFWriter.cpp b/src/engine/SMFWriter.cpp
new file mode 100644
index 0000000..f3a9043
--- /dev/null
+++ b/src/engine/SMFWriter.cpp
@@ -0,0 +1,235 @@
+/*
+ This file is part of Raul.
+ Copyright 2007-2012 David Robillard <http://drobilla.net>
+
+ Raul is free software: you can redistribute it and/or modify it under the
+ terms of the GNU General Public License as published by the Free Software
+ Foundation, either version 3 of the License, or any later version.
+
+ Raul is distributed in the hope that it will be useful, but WITHOUT ANY
+ WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with Raul. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <glib.h>
+#include <stdint.h>
+#include <stdio.h>
+
+#include <cassert>
+#include <cstdio>
+#include <cstring>
+#include <limits>
+#include <string>
+
+#include "raul/log.hpp"
+#include "raul/SMFWriter.hpp"
+
+using std::endl;
+
+namespace Raul {
+
+/** Create a new SMF writer.
+ *
+ * @a unit must match the time stamp of ALL events passed to write, or
+ * terrible things will happen.
+ *
+ * *** NOTE: Only beat time is implemented currently.
+ */
+SMFWriter::SMFWriter(TimeUnit unit)
+ : _fd(NULL)
+ , _unit(unit)
+ , _start_time(unit, 0, 0)
+ , _last_ev_time(unit, 0, 0)
+ , _track_size(0)
+ , _header_size(0)
+{
+ if (unit.type() == TimeUnit::BEATS)
+ assert(unit.ppt() < std::numeric_limits<uint16_t>::max());
+}
+
+SMFWriter::~SMFWriter()
+{
+ if (_fd)
+ finish();
+}
+
+/** Start a write to an SMF file.
+ *
+ * @a filename Filename to write to.
+ * @a start_time Beat time corresponding to t=0 in the file (timestamps passed
+ * to write_event will have this value subtracted before writing).
+ */
+bool
+SMFWriter::start(const std::string& filename,
+ Raul::TimeStamp start_time) throw (std::logic_error)
+{
+ if (_fd)
+ throw std::logic_error("Attempt to start new write while write in progress.");
+
+ info << "Opening SMF file " << filename << " for writing." << endl;
+
+ _fd = fopen(filename.c_str(), "w+");
+
+ if (_fd) {
+ _track_size = 0;
+ _filename = filename;
+ _start_time = start_time;
+ _last_ev_time = 0;
+ // write a tentative header to pad file out so writing starts at the right offset
+ write_header();
+ }
+
+ return (_fd == 0) ? -1 : 0;
+}
+
+/** Write an event at the end of the file.
+ *
+ * @a time is the absolute time of the event, relative to the start of the file
+ * (the start_time parameter to start). Must be monotonically increasing on
+ * successive calls to this method.
+ */
+void
+SMFWriter::write_event(Raul::TimeStamp time,
+ size_t ev_size,
+ const unsigned char* ev) throw (std::logic_error)
+{
+ if (time < _start_time)
+ throw std::logic_error("Event time is before file start time");
+ else if (time < _last_ev_time)
+ throw std::logic_error("Event time not monotonically increasing");
+ else if (time.unit() != _unit)
+ throw std::logic_error("Event has unexpected time unit");
+
+ Raul::TimeStamp delta_time = time;
+ delta_time -= _start_time;
+
+ fseek(_fd, 0, SEEK_END);
+
+ uint64_t delta_ticks = delta_time.ticks() * _unit.ppt() + delta_time.subticks();
+ size_t stamp_size = 0;
+
+ /* If delta time is too long (i.e. overflows), write out empty
+ * "proprietary" events to reach the desired time.
+ * Any SMF reading application should interpret this correctly
+ * (by accumulating the delta time and ignoring the event) */
+ while (delta_ticks > VAR_LEN_MAX) {
+ static unsigned char null_event[] = { 0xFF, 0x7F, 0x0 };
+ stamp_size = write_var_len(VAR_LEN_MAX);
+ fwrite(null_event, 1, 3, _fd);
+ _track_size += stamp_size + 3;
+ delta_ticks -= VAR_LEN_MAX;
+ }
+
+ assert(delta_ticks <= VAR_LEN_MAX);
+ stamp_size = write_var_len(static_cast<uint32_t>(delta_ticks));
+ fwrite(ev, 1, ev_size, _fd);
+
+ _last_ev_time = time;
+ _track_size += stamp_size + ev_size;
+}
+
+void
+SMFWriter::flush()
+{
+ if (_fd)
+ fflush(_fd);
+}
+
+void
+SMFWriter::finish() throw (std::logic_error)
+{
+ if (!_fd)
+ throw std::logic_error("Attempt to finish write with no write in progress.");
+
+ write_footer();
+ fclose(_fd);
+ _fd = NULL;
+}
+
+void
+SMFWriter::write_header()
+{
+ info << "SMF Flushing header\n";
+
+ assert(_fd);
+
+ const uint16_t type = GUINT16_TO_BE(0); // SMF Type 0 (single track)
+ const uint16_t ntracks = GUINT16_TO_BE(1); // Number of tracks (always 1 for Type 0)
+ const uint16_t division = GUINT16_TO_BE(_unit.ppt()); // PPQN
+
+ char data[6];
+ memcpy(data, &type, 2);
+ memcpy(data+2, &ntracks, 2);
+ memcpy(data+4, &division, 2);
+ //data[4] = _ppqn & 0xF0;
+ //data[5] = _ppqn & 0x0F;
+
+ _fd = freopen(_filename.c_str(), "r+", _fd);
+ assert(_fd);
+ fseek(_fd, 0, 0);
+ write_chunk("MThd", 6, data);
+ write_chunk_header("MTrk", _track_size);
+}
+
+void
+SMFWriter::write_footer()
+{
+ info << "Writing EOT\n";
+
+ fseek(_fd, 0, SEEK_END);
+ write_var_len(1); // whatever...
+ static const unsigned char eot[4] = { 0xFF, 0x2F, 0x00 }; // end-of-track meta-event
+ fwrite(eot, 1, 4, _fd);
+}
+
+void
+SMFWriter::write_chunk_header(const char id[4], uint32_t length)
+{
+ const uint32_t length_be = GUINT32_TO_BE(length);
+
+ fwrite(id, 1, 4, _fd);
+ fwrite(&length_be, 4, 1, _fd);
+}
+
+void
+SMFWriter::write_chunk(const char id[4], uint32_t length, void* data)
+{
+ write_chunk_header(id, length);
+
+ fwrite(data, 1, length, _fd);
+}
+
+/** Write an SMF variable length value.
+ *
+ * @return size (in bytes) of the value written.
+ */
+size_t
+SMFWriter::write_var_len(uint32_t value)
+{
+ size_t ret = 0;
+
+ uint32_t buffer = value & 0x7F;
+
+ while ( (value >>= 7) ) {
+ buffer <<= 8;
+ buffer |= ((value & 0x7F) | 0x80);
+ }
+
+ while (true) {
+ //printf("Writing var len byte %X\n", (unsigned char)buffer);
+ ++ret;
+ fputc(buffer, _fd);
+ if (buffer & 0x80)
+ buffer >>= 8;
+ else
+ break;
+ }
+
+ return ret;
+}
+
+} // namespace Raul
+
diff --git a/src/engine/SMFWriter.hpp b/src/engine/SMFWriter.hpp
new file mode 100644
index 0000000..4c52b12
--- /dev/null
+++ b/src/engine/SMFWriter.hpp
@@ -0,0 +1,71 @@
+/*
+ This file is part of Raul.
+ Copyright 2007-2012 David Robillard <http://drobilla.net>
+
+ Raul is free software: you can redistribute it and/or modify it under the
+ terms of the GNU General Public License as published by the Free Software
+ Foundation, either version 3 of the License, or any later version.
+
+ Raul is distributed in the hope that it will be useful, but WITHOUT ANY
+ WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with Raul. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef RAUL_SMF_WRITER_HPP
+#define RAUL_SMF_WRITER_HPP
+
+#include <stdexcept>
+#include <string>
+
+#include "raul/MIDISink.hpp"
+#include "raul/TimeStamp.hpp"
+
+namespace Raul {
+
+/** Standard Midi File (Type 0) Writer
+ * \ingroup raul
+ */
+class SMFWriter : public Raul::MIDISink {
+public:
+ explicit SMFWriter(TimeUnit unit);
+ ~SMFWriter();
+
+ bool start(const std::string& filename,
+ TimeStamp start_time) throw (std::logic_error);
+
+ TimeUnit unit() const { return _unit; }
+
+ void write_event(TimeStamp time,
+ size_t ev_size,
+ const unsigned char* ev) throw (std::logic_error);
+
+ void flush();
+
+ void finish() throw (std::logic_error);
+
+protected:
+ static const uint32_t VAR_LEN_MAX = 0x0FFFFFFF;
+
+ void write_header();
+ void write_footer();
+
+ void write_chunk_header(const char id[4], uint32_t length);
+ void write_chunk(const char id[4], uint32_t length, void* data);
+ size_t write_var_len(uint32_t val);
+
+ std::string _filename;
+ FILE* _fd;
+ TimeUnit _unit;
+ Raul::TimeStamp _start_time;
+ Raul::TimeStamp _last_ev_time; ///< Time last event was written relative to _start_time
+ uint32_t _track_size;
+ uint32_t _header_size; ///< size of SMF header, including MTrk chunk header
+};
+
+} // namespace Raul
+
+#endif // RAUL_SMF_WRITER_HPP
+
diff --git a/src/engine/smf_test.cpp b/src/engine/smf_test.cpp
new file mode 100644
index 0000000..680f66b
--- /dev/null
+++ b/src/engine/smf_test.cpp
@@ -0,0 +1,80 @@
+/*
+ This file is part of Raul.
+ Copyright 2007-2012 David Robillard <http://drobilla.net>
+
+ Raul is free software: you can redistribute it and/or modify it under the
+ terms of the GNU General Public License as published by the Free Software
+ Foundation, either version 3 of the License, or any later version.
+
+ Raul is distributed in the hope that it will be useful, but WITHOUT ANY
+ WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with Raul. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <iostream>
+#include <string>
+#include "raul/log.hpp"
+#include "raul/SMFReader.hpp"
+#include "raul/SMFWriter.hpp"
+
+using namespace std;
+using namespace Raul;
+
+int
+main(int argc, char** argv)
+{
+#define CHECK(cond) \
+ do { if (!(cond)) { \
+ error << "Test at " << __FILE__ << ":" << __LINE__ << " failed: " << __STRING(cond) << endl; \
+ return 1; \
+ } } while (0)
+
+ static const uint16_t ppqn = 19200;
+
+ const char* filename = NULL;
+
+ if (argc < 2) {
+ filename = "./test.mid";
+ SMFWriter writer(TimeUnit(TimeUnit::BEATS, ppqn));
+ writer.start(string(filename), TimeStamp(writer.unit(), 0, 0));
+ writer.finish();
+ } else {
+ filename = argv[1];
+ }
+
+ SMFReader reader;
+ bool opened = reader.open(filename);
+
+ if (!opened) {
+ cerr << "Unable to open SMF file " << filename << endl;
+ return -1;
+ }
+
+ CHECK(reader.type() == 0);
+ CHECK(reader.num_tracks() == 1);
+ CHECK(reader.ppqn() == ppqn);
+
+ for (unsigned t=1; t <= reader.num_tracks(); ++t) {
+ reader.seek_to_track(t);
+
+ unsigned char buf[4];
+ uint32_t ev_size;
+ uint32_t ev_delta_time;
+ while (reader.read_event(4, buf, &ev_size, &ev_delta_time) >= 0) {
+
+ cout << t << ": Event, size = " << ev_size << ", time = " << ev_delta_time;
+ cout << ":\t";
+ cout.flags(ios::hex);
+ for (uint32_t i=0; i < ev_size; ++i) {
+ cout << "0x" << static_cast<int>(buf[i]) << " ";
+ }
+ cout.flags(ios::dec);
+ cout << endl;
+ }
+ }
+
+ return 0;
+}