midi-writer.cpp

Go to the documentation of this file.

/*
 * midi-writer.cpp
 *
 * Copyright (C) 2006  Thomas A. Vaughan
 * All rights reserved.
 *
 * Given a midi event stream on STDIN, writes out a midi file
 */

// includes --------------------------------------------------------------------
#include <iostream>

#include "wave-midi/midi_file.h"


// statics
typedef const char * cc_ptr_t;

struct stat_entry_t {
        const char                     *name;
        media::MidiEvent::eStatus       status;
};


#define STAT_ENTRY(name,status) { #name , media::MidiEvent::status } ,

static const stat_entry_t s_statusTable[] = {

        // order by expected occurance
        STAT_ENTRY(note-on,     eNoteOn)
        STAT_ENTRY(note-off,    eNoteOff)
        STAT_ENTRY(program,     eProgram)

        // must be last!
        { 0, media::MidiEvent::eInvalid }
};


////////////////////////////////////////////////////////////////////////////////
//
//      helper methods
//
////////////////////////////////////////////////////////////////////////////////

static const char *
getNextToken
(
IO cc_ptr_t& p
)
{
        ASSERT(p, "null");

        static const int s_max = 1024;
        static char s_buffer[s_max];
        const char * max = s_buffer + s_max;

        char * q = s_buffer;            // points to current point in buffer

        // skip leading whitespace
        while (isspace(*p)) {
                // keep going
                ++p;
        }

        // copy characters until end, or whitespace, or comment
        while (0 != *p && !isspace(*p) && '#' != *p) {
                ASSERT(q < max, "Ran out of room in buffer");

                // not whitespace or comment--copy over!
                *q = *p;

                // increment both strings
                ++q;
                ++p;
        }

        // null-terminate and return
        *q = 0;
        return s_buffer;
}



static void
addMeta
(
IN media::MidiFile * mf,
IN const char * p
)
{
        ASSERT(mf, "null");
        ASSERT(p, "null");

        const char * key = getNextToken(p);
        if (!strcmp("ppqn", key)) {
                int ppqn = atoi(getNextToken(p));
                mf->setPpqn(ppqn);
        } else if (!strcmp("bpm", key)) {
                float bpm = atof(getNextToken(p));
                mf->setTempo(bpm);
        } else {
                ASSERT(false, "unknown meta key: '%s'", key);
        }
}



static media::MidiEvent::eStatus
getStatus
(
IN const char * type
)
{
        ASSERT(type, "null");

        const stat_entry_t * p = s_statusTable;
        while (p->name) {
                if (!strcmp(type, p->name)) {
                        return p->status;
                }
                ++p;
        }

        ASSERT(false, "unrecognized event type: '%s'", type);
        return p->status;
}



static void
addEvent
(
IN media::MidiFile * mf,
IN const char * p
)
{
        ASSERT(mf, "null");
        ASSERT(p, "null");

        // extract raw data
        long tick = atol(getNextToken(p));
        ASSERT(tick >= 0, "Bad tick value: %ld", tick);

        const char * type = getNextToken(p);

        // determine status
        media::MidiEvent me;
        me.SetStatus(getStatus(type));

        int channel = atoi(getNextToken(p));
        ASSERT(channel >= 0 && channel < 16, "bad channel: %d", channel);
        int p1 = atoi(getNextToken(p));
        ASSERT(p1 >= 0 && p1 < 128, "bad parameter 1: %d", p1);
        int p2 = atoi(getNextToken(p));
        ASSERT(p2 >= 0 && p2 < 128, "bad parameter 2: %d", p2);

        me.SetChannel(channel);
        me.SetByte0((byte_t) p1);
        me.SetByte1((byte_t) p2);

        mf->addEvent(tick, me);
}



static void
addEvents
(
IN media::MidiFile * mf,
IO std::istream& stream
)
{
        ASSERT(mf, "null");

        // keep reading until end of stream
        std::string line;
        while (stream.good()) {
                std::getline(stream, line);
                const char * p = line.c_str();

                // get first token (meta or event)
                const char * token = getNextToken(p);
                if (!*token) {
                        continue;       // skip line
                }

                // what sort of line is this?
                if (!strcmp("meta", token)) {
                        addMeta(mf, p);
                } else if (!strcmp("event", token)) {
                        addEvent(mf, p);
                } else {
                        ASSERT(false, "unknown token: '%s'", token);
                }
        }
}



////////////////////////////////////////////////////////////////////////////////
//
//      entry point
//
////////////////////////////////////////////////////////////////////////////////

int
main
(
IN int argc,
IN const char * argv[]
)
{
        ASSERT(2 == argc,
            "usage: midi-writer <filename>");
        const char * filename = argv[1];

        // create new midi file
        smart_ptr<media::MidiFile> mf = media::MidiFile::create();
        ASSERT(mf, "could not create midi file object?");

        // add events
        addEvents(mf, std::cin);

        // write output
        mf->write(filename);

        return 0;
}