midi_file.cpp

Go to the documentation of this file.

/*
 * midi_file.cpp
 *
 * Copyright (c) 2003 Thomas A. Vaughan
 * All rights reserved.
 *
 * Implements the midi file object.
 */

// includes --------------------------------------------------------------------
#include "midi_file.h"  // always include our own header first

#ifdef WIN32
#include <winsock2.h>
#else   // WIN32
#include <netinet/in.h> // host <--> network byte order translations
#endif  // WIN32


// namespace
namespace media {



// typedefs and statics --------------------------------------------------------

static const int s_MaxTracks            = 16;   // maximum # of midi tracks
static const long s_usec_per_minute     = 60 * 1000 * 1000;
        
        
////////////////////////////////////////////////////////////////////////////////
//
//      static helper methods
//
////////////////////////////////////////////////////////////////////////////////

void
WriteByte
(
IN FILE * file,
IN byte_t byte
)
throw()
{
        ASSERT(file, "Invalid file");
        ASSERT(1 == fwrite(&byte, sizeof(byte_t), 1, file),
            "Failed to write byte to midi file");
}



void
WriteWord
(
IN FILE * file,
IN word_t word
)
throw()
{
        word_t big_endian;

        ASSERT(file, "Invalid file");

        // convert to big-endian
        big_endian = htons(word);

        // write
        ASSERT(1 == fwrite(&big_endian, sizeof(word_t), 1, file),
            "Failed to write word to midi file");
}



void
WriteDword
(
IN FILE * file,
IN dword_t dword
)
throw()
{
        dword_t big_endian;

        ASSERT(file, "Invalid file");

        // convert to big-endian
        big_endian = htonl(dword);

        // write
        ASSERT(4 == sizeof(dword_t), "Bad size???");
        ASSERT(1 == fwrite(&big_endian, sizeof(dword_t), 1, file),
            "Failed to write dword to midi file");
}



int
WriteVariable
(
IN FILE * file,
IN dword_t value
)
throw()
{
        byte_t out[4];
        int count, retval;

        ASSERT(file, "NULL file");
        // ASSERT(written) -- can be null

        // keep going until value is zero
        count = 0;
        for (;;) {
                out[count] = (value & 0x7f);
                if (count)
                        out[count] |= 0x80;
                count++;
                value >>= 7;
                if (!value)
                        break;
        }

        // tell caller the byte count written if they want to know
        retval = count;

        // now keep writing the packed bytes
        while (count > 0) {
                count--;
                WriteByte(file, out[count]);
                // DPRINTF("  packed variable byte: %x", out[count]);
        }

        return retval;
}



void
WriteChunkHeader
(
IN FILE * file,
IN const char * name,
IN dword_t length
)
throw()
{
        ASSERT(file, "invalid file");
        ASSERT(name, "Null name");
        ASSERT(4 == strlen(name), "Bad name length");

        // write chunk name
        ASSERT(4 == fwrite(name, sizeof(char), 4, file),
            "Failed to write chunk name to midi file");

        // write chunk length
        WriteDword(file, length);
}



/*
 * class: MidiFileImpl
 *
 * Class that implements the MidiFile interface.
 */
class MidiFileImpl : public MidiFile {
public:
        // constructor, destructor ---------------------------------------------
        MidiFileImpl(void) throw();
        ~MidiFileImpl(void) throw();

        // public class methods ------------------------------------------------
        void initialize() throw();
        void readFile(IN const char * filename);

        // media::MidiFile class interface methods -----------------------------
        virtual const MidiEventMap& getEvents(void) const throw();
        void setPpqn(IN int ppqn) throw();
        void setTempo(IN float bpm) throw();
        virtual void addEvent(IN unsigned long tick,
                                IN const MidiEvent& event);
        virtual void write(IN const char * filename) const;

private:
        // private typedefs ----------------------------------------------------
        typedef std::vector<int> VecTracks;     // vector of track numbers

        // private helper methods ----------------------------------------------
        void getTracks(OUT VecTracks& tracks) const throw();
        void writeTrackEvents(IN FILE * outfile, IN int track_index,
                OUT dword_t& count) const;

        // private data members ------------------------------------------------
        int             m_ppqn;         // pulses per quarter note
        float           m_bpm;
        MidiEventMap    m_events;       // all events in midi file
};



////////////////////////////////////////////////////////////////////////////////
//
//      MidiFileImpl -- public class methods
//
////////////////////////////////////////////////////////////////////////////////

MidiFileImpl::MidiFileImpl(void) throw() :
m_ppqn(96),
m_bpm(120)
{
        // DPRINTF("MidiFileImpl constructor...");
}



MidiFileImpl::~MidiFileImpl(void) throw()
{
        // DPRINTF("MidiFileImpl destructor...");
}



////////////////////////////////////////////////////////////////////////////////
//
//      MidiFileImpl -- public class methods
//
////////////////////////////////////////////////////////////////////////////////

void
MidiFileImpl::initialize
(
void
)
throw()
{
        // nothing to do!
}



void
MidiFileImpl::setPpqn
(
IN int ppqn
)
throw()
{
        ASSERT(ppqn > 0, "Bad ppqn");
        m_ppqn = ppqn;
}



void
MidiFileImpl::setTempo
(
IN float bpm
)
throw()
{
        ASSERT(bpm > 0, "Bad bpm: %f", bpm);

        m_bpm = bpm;
}



void
MidiFileImpl::readFile
(
IN const char * filename
)
{
        ASSERT(filename, "NULL filename");

        ASSERT(false, "ReadFile() is not yet implemented");
}



////////////////////////////////////////////////////////////////////////////////
//
//      MidiFileImpl -- media::MidiFile class interface methods
//
////////////////////////////////////////////////////////////////////////////////

const MidiEventMap&
MidiFileImpl::getEvents(void)
const
throw()
{
        return m_events;
}



void
MidiFileImpl::addEvent
(
IN unsigned long tick,
IN const MidiEvent& event
)
{
        m_events.insert(MidiEventMap::value_type(tick, event));
}



void
MidiFileImpl::write
(
IN const char * filename
)
const
{
        VecTracks tracks;
        FILE * outfile = NULL;
        byte_t byte;

        ASSERT(filename && *filename, "NULL filename");

        // get tracks
        this->getTracks(tracks);
        ASSERT((int) tracks.size() <= s_MaxTracks, "Bad track count");

        // open file
        outfile = fopen(filename, "w");
        ASSERT(outfile, "Failed to open file for writing: '%s'", filename);

        // write MThd chunk
        WriteChunkHeader(outfile, "MThd", 6);

        // midi file format is 1
        WriteWord(outfile, (word_t) 1);

        // # of tracks
        WriteWord(outfile, (word_t) (tracks.size() + 1));

        // no midi player understands SMPTE--use ppqn 
        byte = (byte_t) (m_ppqn / 256);
        WriteByte(outfile, byte);
        // DPRINTF("  1st time byte: %x", byte);

        byte = (byte_t) (m_ppqn % 256);
        WriteByte(outfile, byte);
        // DPRINTF("  2nd time byte: %x", byte);

        // write tracks
        for (int i = -1; i < (int) tracks.size(); i++) {
                int track_idx = -1;
                if (i >= 0) {
                        track_idx = tracks[i];
                }
                dword_t count = 0;
                long position;

                // DPRINTF("Writing track %d (idx = %d)", i, track_idx);

                // remember location
                position = ftell(outfile);
                // DPRINTF("  position = %ld", position);

                // write chunk header (+ buffer size)
                WriteChunkHeader(outfile, "MTrk", 0);

                // write all events for this track
                this->writeTrackEvents(outfile, track_idx, count);

                // back up to chunk header location
                ASSERT(-1 != fseek(outfile, position, SEEK_SET),
                    "Failed to set file position");

                // write chunk again (with correct length now)
                WriteChunkHeader(outfile, "MTrk", count);

                // move forward to end
                ASSERT(-1 != fseek(outfile, 0, SEEK_END),
                    "Failed to move to end of file");
                ASSERT((long) (count + position + 8) == ftell(outfile),
                       "Should be '%lu' bytes ahead", count);
        }

        // write an empty header
        WriteChunkHeader(outfile, "MTrk", 0);
}



////////////////////////////////////////////////////////////////////////////////
//
//      MidiFileImpl -- private helper methods
//
////////////////////////////////////////////////////////////////////////////////

void
MidiFileImpl::getTracks
(
OUT VecTracks& tracks
)
const
throw()
{
        MidiEventMap::const_iterator iter;
        bool used[s_MaxTracks];

        tracks.clear();
        for (int i = 0; i < s_MaxTracks; i++) {
                used[i] = false;
        }

        // loop through, accumulate track indices
        for (iter = m_events.begin(); iter != m_events.end(); ++iter) {

                // is this a new index?
                int channel = iter->second.GetChannel();
                ASSERT(channel >=0 && channel < s_MaxTracks,
                    "Bad channel/track number for event");

                if (!used[iter->second.GetChannel()]) {
                        used[iter->second.GetChannel()] = true;
                        tracks.push_back(iter->second.GetChannel());
                }
        }
}



void
MidiFileImpl::writeTrackEvents
(
IN FILE * outfile,
IN int track_index,
OUT dword_t& count
)
const
{
        MidiEventMap::const_iterator iter;

        ASSERT(outfile, "NULL output file");
        ASSERT(track_index >= -1 && track_index < s_MaxTracks,
            "Invalid track index");
        count = 0;              // no bytes written

        // index is -1?  Special initial track
        if (-1 == track_index) {
                // write tempo
                count += WriteVariable(outfile, 0);     // time = 0
                WriteByte(outfile, 255);                // meta event
                WriteByte(outfile, 81);                 // set tempo
                WriteByte(outfile, 3);                  // writing 3 bytes
                long upqn = (int) (s_usec_per_minute / m_bpm); // microseconds per quarter note
                // DPRINTF("bpm=%3.1lf  -->  upqn=%ld", m_bpm, upqn);
                const byte_t * pb = (const byte_t *) &upqn;
/*              for (int i = 0; i < 4; ++i) {
                        DPRINTF("  byte[%d] = %d", i, pb[i]);
                } */
                WriteByte(outfile, pb[2]);
                WriteByte(outfile, pb[1]);
                WriteByte(outfile, pb[0]);
                count += 6;     // meta + event type + length byte + 3 bytes for tempo

                return;
        }

        // loop through all events and write those for this track
        long current_tick = 0;  // start at zero tick
        for (iter = m_events.begin(); iter != m_events.end(); ++iter) {
        
                int track = iter->second.GetChannel();
                ASSERT(track >= 0 && track < s_MaxTracks,
                    "Invalid track index");
                // DPRINTF("Track index = %d", track);
                if (track == track_index) {
                        // write this event
                        byte_t status;

                        // first write the delta time (ticks)
                        long delta = iter->first - current_tick;
                        int bytes = WriteVariable(outfile, delta);
                        ASSERT(bytes > 0, "Invalid byte count");
                        current_tick = iter->first;
                        count += bytes;

                        // DPRINTF("  Wrote delta: %lu (%d bytes)", delta, bytes);

                        // write the status byte
                        status = (iter->second.GetStatus() << 4) |
                            iter->second.GetChannel();
                        WriteByte(outfile, status);
                        count += 1;
                        // DPRINTF("  Wrote status byte: %x", status);

                        // write the data bytes
                        bytes = MidiEvent::GetDataByteCount(
                            iter->second.GetStatus());
                        ASSERT(bytes > 0, "Invalid byte count");
                        ASSERT(bytes < 3, "Invalid byte count");

                        if (bytes > 0) {
                                WriteByte(outfile, iter->second.GetByte0());
                                //DPRINTF("  byte0 = %x",
                                //    iter->second.GetByte0());
                        }
                        if (bytes > 1) {
                                WriteByte(outfile, iter->second.GetByte1());
                                //DPRINTF("  byte1 = %x",
                                //    iter->second.GetByte1());
                        }

                        count += bytes;
                }
        }
}



////////////////////////////////////////////////////////////////////////////////
//
//      MidiFile -- public static methods (factory methods)
//
////////////////////////////////////////////////////////////////////////////////

/*
 * Function:  MidiFile::New
 */
smart_ptr<MidiFile>
MidiFile::create
(
void
)
{
        // create new object
        smart_ptr<MidiFileImpl> local = new MidiFileImpl;
        ASSERT(local, "out of memory");
        local->initialize();

        // return to caller
        return local;
}



/*
 * Function: MidiFile::Load
 */
smart_ptr<MidiFile>
MidiFile::load
(
IN const char * filename
)
{
        // new object
        smart_ptr<MidiFileImpl> local = new MidiFileImpl;
        local->readFile(filename);

        // return
        return local;
}



////////////////////////////////////////////////////////////////////////////////
//
//      Helper Methods for Midi File
//
////////////////////////////////////////////////////////////////////////////////

static void
AddNote
(
IN MidiFile * file,
IN dword_t tick,
IN int channel,
IN int note,
IN int velocity,
IN bool note_on
)
throw()
{
        MidiEvent event;

        ASSERT(file, "NULL midi file");
        ASSERT(channel >= 0, "Bad midi channel");
        ASSERT(channel < 16, "Bad midi channel");
        ASSERT(note >= 0, "Bad note value");
        ASSERT(note < 128, "Bad note value");
        ASSERT(velocity >= 0, "Bad velocity");
        ASSERT(velocity < 128, "Bad velocity");

        // DPRINTF("Note event on channel %d", channel);

        event.SetStatus(note_on ? MidiEvent::eNoteOn : MidiEvent::eNoteOff);
        event.SetChannel(channel);
        event.SetByte0(note);
        event.SetByte1(velocity);

        file->addEvent(tick, event);
}



void
AddNoteOn
(
IN MidiFile * file,
dword_t tick,
int channel,
int note,
int velocity
)
throw()
{
        AddNote(file, tick, channel, note, velocity, true); 
}



void
AddNoteOff
(
IN MidiFile * file,
dword_t tick,
int channel,
int note,
int velocity
)
throw()
{
        AddNote(file, tick, channel, note, velocity, false);
}



};      // media namespace