/*
 * midiFile.c - A general purpose midi file handling library. This code
 *				can read and write MIDI files in formats 0 and 1.
 * Version 1.4
 *
 *  AUTHOR: Steven Goodwin (StevenGoodwin@gmail.com)
 *          Copyright 1998-2010, Steven Goodwin
 *
 *  This program 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 2 of
 *  the License,or (at your option) any later version.
 *
 *  This program 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 this program; if not, write to the Free Software
 *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#ifndef  __APPLE__
#include <malloc.h>
#endif
#include "midifile.h"

/*
** Internal Data Structures
*/
typedef struct
{
    BYTE note, chn;
    BYTE valid, p2;
    DWORD end_pos;
} MIDI_LAST_NOTE;

typedef struct
{
    BYTE *ptr;
    BYTE *pBase;
    BYTE *pEnd;

    DWORD pos;
    DWORD dt;
    /* For Reading MIDI Files */
    DWORD sz;                   /* size of whole iTrack */
    /* For Writing MIDI Files */
    DWORD iBlockSize;           /* max size of track */
    BYTE iDefaultChannel;       /* use for write only */
    BYTE last_status;           /* used for running status */

    MIDI_LAST_NOTE LastNote[MAX_TRACK_POLYPHONY];
} MIDI_FILE_TRACK;

typedef struct
{
    DWORD iHeaderSize;
      /**/ WORD iVersion;       /* 0, 1 or 2 */
    WORD iNumTracks;            /* number of tracks... (will be 1 for MIDI type 0) */
    WORD PPQN;                  /* pulses per quarter note */
} MIDI_HEADER;

typedef struct
{
    FILE *pFile;
    BOOL bOpenForWriting;

    MIDI_HEADER Header;
    BYTE *ptr;                  /* to whole data block */
    DWORD file_sz;

    MIDI_FILE_TRACK Track[MAX_MIDI_TRACKS];
} _MIDI_FILE;


/*
** Internal Functions
*/
#define DT_DEF				32      /* assume maximum delta-time + msg is no more than 32 bytes */
#define SWAP_WORD(w)		(WORD)(((w)>>8)|((w)<<8))
#define SWAP_DWORD(d)		(DWORD)((d)>>24)|(((d)>>8)&0xff00)|(((d)<<8)&0xff0000)|(((d)<<24))

#define _VAR_CAST				_MIDI_FILE *pMF = (_MIDI_FILE *)_pMF
#define IsFilePtrValid(pMF)		(pMF)
#define IsTrackValid(_x)		(_midiValidateTrack(pMF, _x))
#define IsChannelValid(_x)		((_x)>=1 && (_x)<=16)
#define IsNoteValid(_x)			((_x)>=0 && (_x)<128)
#define IsMessageValid(_x)		((_x)>=msgNoteOff && (_x)<=msgMetaEvent)


static BOOL _midiValidateTrack(const _MIDI_FILE *pMF, int iTrack)
{
    if (!IsFilePtrValid(pMF))
        return FALSE;

    if (pMF->bOpenForWriting)
    {
        if (iTrack < 0 || iTrack >= MAX_MIDI_TRACKS)
            return FALSE;
    }
    else                        /* open for reading */
    {
        if (!pMF->ptr)
            return FALSE;

        if (iTrack < 0 || iTrack >= pMF->Header.iNumTracks)
            return FALSE;
    }

    return TRUE;
}

static BYTE *_midiWriteVarLen(BYTE * ptr, int n)
{
    register long buffer;
    register long value = n;

    buffer = value & 0x7f;
    while ((value >>= 7) > 0)
    {
        buffer <<= 8;
        buffer |= 0x80;
        buffer += (value & 0x7f);
    }

    while (TRUE)
    {
        *ptr++ = (BYTE) buffer;
        if (buffer & 0x80)
            buffer >>= 8;
        else
            break;
    }

    return (ptr);
}

/* Return a ptr to valid block of memory to store a message
** of up to sz_reqd bytes
*/
static BYTE *_midiGetPtr(_MIDI_FILE *pMF, int iTrack, int sz_reqd)
{
    const DWORD mem_sz_inc = 8092;      /* arbitary */
    BYTE *ptr;
    int curr_offset;
    MIDI_FILE_TRACK *pTrack = &pMF->Track[iTrack];

    ptr = pTrack->ptr;
    if (ptr == NULL || ptr + sz_reqd > pTrack->pEnd)    /* need more RAM! */
    {
        curr_offset = ptr - pTrack->pBase;
        if ((ptr =
             (BYTE *) realloc(pTrack->pBase,
                              mem_sz_inc + pTrack->iBlockSize)))
        {
            pTrack->pBase = ptr;
            pTrack->iBlockSize += mem_sz_inc;
            pTrack->pEnd = ptr + pTrack->iBlockSize;
            /* Move new ptr to continue data entry: */
            pTrack->ptr = ptr + curr_offset;
            ptr += curr_offset;
        }
        else
        {
            /* NO MEMORY LEFT */
            return NULL;
        }
    }

    return ptr;
}


static int _midiGetLength(int ppqn, int iNoteLen, BOOL bOverride)
{
    int length = ppqn;

    if (bOverride)
    {
        length = iNoteLen;
    }
    else
    {
        switch (iNoteLen)
        {
        case MIDI_NOTE_DOTTED_MINIM:
            length *= 3;
            break;

        case MIDI_NOTE_DOTTED_CROCHET:
            length *= 3;
            length /= 2;
            break;

        case MIDI_NOTE_DOTTED_QUAVER:
            length *= 3;
            length /= 4;
            break;

        case MIDI_NOTE_DOTTED_SEMIQUAVER:
            length *= 3;
            length /= 8;
            break;

        case MIDI_NOTE_DOTTED_SEMIDEMIQUAVER:
            length *= 3;
            length /= 16;
            break;

        case MIDI_NOTE_BREVE:
            length *= 4;
            break;

        case MIDI_NOTE_MINIM:
            length *= 2;
            break;

        case MIDI_NOTE_QUAVER:
            length /= 2;
            break;

        case MIDI_NOTE_SEMIQUAVER:
            length /= 4;
            break;

        case MIDI_NOTE_SEMIDEMIQUAVER:
            length /= 8;
            break;

        case MIDI_NOTE_TRIPLE_CROCHET:
            length *= 2;
            length /= 3;
            break;
        }
    }

    return length;
}

/*
** midiFile* Functions
*/
MIDI_FILE *midiFileCreate(const char *pFilename, BOOL bOverwriteIfExists)
{
    _MIDI_FILE *pMF = (_MIDI_FILE *) malloc(sizeof(_MIDI_FILE));
    int i;

    if (!pMF)
        return NULL;

    if (!bOverwriteIfExists)
    {
        if ((pMF->pFile = fopen(pFilename, "r")))
        {
            fclose(pMF->pFile);
            free(pMF);
            return NULL;
        }
    }

    if ((pMF->pFile = fopen(pFilename, "wb+")))
    {                           /*empty */
    }
    else
    {
        free((void *) pMF);
        return NULL;
    }

    pMF->bOpenForWriting = TRUE;
    pMF->Header.PPQN = MIDI_PPQN_DEFAULT;
    pMF->Header.iVersion = MIDI_VERSION_DEFAULT;

    for (i = 0; i < MAX_MIDI_TRACKS; ++i)
    {
        pMF->Track[i].pos = 0;
        pMF->Track[i].ptr = NULL;
        pMF->Track[i].pBase = NULL;
        pMF->Track[i].pEnd = NULL;
        pMF->Track[i].iBlockSize = 0;
        pMF->Track[i].dt = 0;
        pMF->Track[i].iDefaultChannel = (BYTE) (i & 0xf);

        memset(pMF->Track[i].LastNote, '\0', sizeof(pMF->Track[i].LastNote));
    }

    return (MIDI_FILE *) pMF;
}

int midiFileSetTracksDefaultChannel(MIDI_FILE *_pMF, int iTrack,
                                    int iChannel)
{
    int prev;

    _VAR_CAST;
    if (!IsFilePtrValid(pMF))
        return 0;
    if (!IsTrackValid(iTrack))
        return 0;
    if (!IsChannelValid(iChannel))
        return 0;

    /* For programmer each, iChannel is between 1 & 16 - but MIDI uses
     ** 0-15. Thus, the fudge factor of 1 :)
     */
    prev = pMF->Track[iTrack].iDefaultChannel + 1;
    pMF->Track[iTrack].iDefaultChannel = (BYTE) (iChannel - 1);
    return prev;
}

int midiFileGetTracksDefaultChannel(const MIDI_FILE *_pMF, int iTrack)
{
    _VAR_CAST;
    if (!IsFilePtrValid(pMF))
        return 0;
    if (!IsTrackValid(iTrack))
        return 0;

    return pMF->Track[iTrack].iDefaultChannel + 1;
}

int midiFileSetPPQN(MIDI_FILE *_pMF, int PPQN)
{
    int prev;

    _VAR_CAST;
    if (!IsFilePtrValid(pMF))
        return MIDI_PPQN_DEFAULT;
    prev = pMF->Header.PPQN;
    pMF->Header.PPQN = (WORD) PPQN;
    return prev;
}

int midiFileGetPPQN(const MIDI_FILE *_pMF)
{
    _VAR_CAST;
    if (!IsFilePtrValid(pMF))
        return MIDI_PPQN_DEFAULT;
    return (int) pMF->Header.PPQN;
}

int midiFileSetVersion(MIDI_FILE *_pMF, int iVersion)
{
    int prev;

    _VAR_CAST;
    if (!IsFilePtrValid(pMF))
        return MIDI_VERSION_DEFAULT;
    if (iVersion < 0 || iVersion > 2)
        return MIDI_VERSION_DEFAULT;
    prev = pMF->Header.iVersion;
    pMF->Header.iVersion = (WORD) iVersion;
    return prev;
}

int midiFileGetVersion(const MIDI_FILE *_pMF)
{
    _VAR_CAST;
    if (!IsFilePtrValid(pMF))
        return MIDI_VERSION_DEFAULT;
    return pMF->Header.iVersion;
}

MIDI_FILE *midiFileOpen(const char *pFilename)
{
    FILE *fp = fopen(pFilename, "rb");
    _MIDI_FILE *pMF = NULL;
    BYTE *ptr;
    BOOL bValidFile = FALSE;
    long size;

    if (fp)
    {
        if ((pMF = (_MIDI_FILE *) malloc(sizeof(_MIDI_FILE))))
        {
            fseek(fp, 0L, SEEK_END);
            size = ftell(fp);
            if ((pMF->ptr = (BYTE *) malloc(size)))
            {
                fseek(fp, 0L, SEEK_SET);
                fread(pMF->ptr, sizeof(BYTE), size, fp);
                /* Is this a valid MIDI file ? */
                ptr = pMF->ptr;
                if (*(ptr + 0) == 'M' && *(ptr + 1) == 'T' &&
                    *(ptr + 2) == 'h' && *(ptr + 3) == 'd')
                {
                    DWORD dwData;
                    WORD wData;
                    int i;

                    dwData = *((DWORD *) (ptr + 4));
                    pMF->Header.iHeaderSize = SWAP_DWORD(dwData);

                    wData = *((WORD *) (ptr + 8));
                    pMF->Header.iVersion = (WORD) SWAP_WORD(wData);

                    wData = *((WORD *) (ptr + 10));
                    pMF->Header.iNumTracks = (WORD) SWAP_WORD(wData);

                    wData = *((WORD *) (ptr + 12));
                    pMF->Header.PPQN = (WORD) SWAP_WORD(wData);

                    ptr += pMF->Header.iHeaderSize + 8;
                    /*
                     **      Get all tracks
                     */
                    for (i = 0; i < MAX_MIDI_TRACKS; ++i)
                    {
                        pMF->Track[i].pos = 0;
                        pMF->Track[i].last_status = 0;
                    }

                    for (i = 0; i < pMF->Header.iNumTracks; ++i)
                    {
                        pMF->Track[i].pBase = ptr;
                        pMF->Track[i].ptr = ptr + 8;
                        dwData = *((DWORD *) (ptr + 4));
                        pMF->Track[i].sz = SWAP_DWORD(dwData);
                        pMF->Track[i].pEnd = ptr + pMF->Track[i].sz + 8;
                        ptr += pMF->Track[i].sz + 8;
                    }

                    pMF->bOpenForWriting = FALSE;
                    pMF->pFile = NULL;
                    bValidFile = TRUE;
                }
            }
        }

        fclose(fp);
    }

    if (!bValidFile)
    {
        if (pMF)
            free((void *) pMF);
        return NULL;
    }

    return (MIDI_FILE *) pMF;
}

typedef struct
{
    int iIdx;
    int iEndPos;
} MIDI_END_POINT;

static int qs_cmp_pEndPoints(const void *e1, const void *e2)
{
    MIDI_END_POINT *p1 = (MIDI_END_POINT *) e1;
    MIDI_END_POINT *p2 = (MIDI_END_POINT *) e2;

    return p1->iEndPos - p2->iEndPos;
}

BOOL midiFileFlushTrack(MIDI_FILE *_pMF, int iTrack, BOOL bFlushToEnd,
                        DWORD dwEndTimePos)
{
    int sz;
    BYTE *ptr;
    MIDI_END_POINT *pEndPoints;
    int num, i, mx_pts;
    BOOL bNoChanges = TRUE;

    _VAR_CAST;
    if (!IsFilePtrValid(pMF))
        return FALSE;
    if (!_midiValidateTrack(pMF, iTrack))
        return FALSE;
    sz = sizeof(pMF->Track[0].LastNote) / sizeof(pMF->Track[0].LastNote[0]);

    /*
     ** Flush all
     */
    pEndPoints = (MIDI_END_POINT *) malloc(sz * sizeof(MIDI_END_POINT));
    mx_pts = 0;
    for (i = 0; i < sz; ++i)
        if (pMF->Track[iTrack].LastNote[i].valid)
        {
            pEndPoints[mx_pts].iIdx = i;
            pEndPoints[mx_pts].iEndPos =
                pMF->Track[iTrack].LastNote[i].end_pos;
            mx_pts++;
        }

    if (bFlushToEnd)
    {
        if (mx_pts)
            dwEndTimePos = pEndPoints[mx_pts - 1].iEndPos;
        else
            dwEndTimePos = pMF->Track[iTrack].pos;
    }

    if (mx_pts)
    {
        /* Sort, smallest first, and add the note off msgs */
        qsort(pEndPoints, mx_pts, sizeof(MIDI_END_POINT), qs_cmp_pEndPoints);

        i = 0;
        while ((dwEndTimePos >= (DWORD) pEndPoints[i].iEndPos || bFlushToEnd)
               && i < mx_pts)
        {
            ptr = _midiGetPtr(pMF, iTrack, DT_DEF);
            if (!ptr)
                return FALSE;

            num = pEndPoints[i].iIdx;   /* get 'LastNote' index */

            ptr =
                _midiWriteVarLen(ptr,
                                 pMF->Track[iTrack].LastNote[num].end_pos -
                                 pMF->Track[iTrack].pos);
            /* msgNoteOn  msgNoteOff */
            *ptr++ =
                (BYTE) (msgNoteOff | pMF->Track[iTrack].LastNote[num].chn);
            *ptr++ = pMF->Track[iTrack].LastNote[num].note;
            *ptr++ = 0;

            pMF->Track[iTrack].LastNote[num].valid = FALSE;
            pMF->Track[iTrack].pos = pMF->Track[iTrack].LastNote[num].end_pos;

            pMF->Track[iTrack].ptr = ptr;

            ++i;
            bNoChanges = FALSE;
        }
    }

    free((void *) pEndPoints);
    /*
     ** Re-calc current position
     */
    pMF->Track[iTrack].dt = dwEndTimePos - pMF->Track[iTrack].pos;

    return TRUE;
}

BOOL midiFileSyncTracks(MIDI_FILE *_pMF, int iTrack1, int iTrack2)
{
    int p1, p2;

    _VAR_CAST;
    if (!IsFilePtrValid(pMF))
        return FALSE;
    if (!IsTrackValid(iTrack1))
        return FALSE;
    if (!IsTrackValid(iTrack2))
        return FALSE;

    p1 = pMF->Track[iTrack1].pos + pMF->Track[iTrack1].dt;
    p2 = pMF->Track[iTrack2].pos + pMF->Track[iTrack2].dt;

    if (p1 < p2)
        midiTrackIncTime(pMF, iTrack1, p2 - p1, TRUE);
    else if (p2 < p1)
        midiTrackIncTime(pMF, iTrack2, p1 - p2, TRUE);

    return TRUE;
}


BOOL midiFileClose(MIDI_FILE *_pMF)
{
    _VAR_CAST;
    if (!IsFilePtrValid(pMF))
        return FALSE;

    if (pMF->bOpenForWriting)
    {
        WORD iNumTracks = 0;
        WORD wTest = 256;
        BOOL bSwap = FALSE;
        int i;

        /* Intel processor style-endians need byte swap :( */
        if (*((BYTE *) & wTest) == 0)
            bSwap = TRUE;

        /* Flush our buffers  */
        for (i = 0; i < MAX_MIDI_TRACKS; ++i)
        {
            if (pMF->Track[i].ptr)
            {
                midiSongAddEndSequence(pMF, i);
                midiFileFlushTrack(pMF, i, TRUE, 0);
                iNumTracks++;
            }
        }
        /*
         ** Header
         */
        {
            const BYTE mthd[4] = { 'M', 'T', 'h', 'd' };
            DWORD dwData;
            WORD wData;
            WORD version, PPQN;

            fwrite(mthd, sizeof(BYTE), 4, pMF->pFile);
            dwData = 6;
            if (bSwap)
                dwData = SWAP_DWORD(dwData);
            fwrite(&dwData, sizeof(DWORD), 1, pMF->pFile);

            wData = (WORD) (iNumTracks == 1 ? pMF->Header.iVersion : 1);
            if (bSwap)
                version = SWAP_WORD(wData);
            else
                version = (WORD) wData;
            if (bSwap)
                iNumTracks = SWAP_WORD(iNumTracks);
            wData = pMF->Header.PPQN;
            if (bSwap)
                PPQN = SWAP_WORD(wData);
            else
                PPQN = wData;
            fwrite(&version, sizeof(WORD), 1, pMF->pFile);
            fwrite(&iNumTracks, sizeof(WORD), 1, pMF->pFile);
            fwrite(&PPQN, sizeof(WORD), 1, pMF->pFile);
        }
        /*
         ** Track data
         */
        for (i = 0; i < MAX_MIDI_TRACKS; ++i)
            if (pMF->Track[i].ptr)
            {
                const BYTE mtrk[4] = { 'M', 'T', 'r', 'k' };
                DWORD sz, dwData;

                /* Write track header */
                fwrite(&mtrk, sizeof(BYTE), 4, pMF->pFile);

                /* Write data size */
                sz = dwData = (int) (pMF->Track[i].ptr - pMF->Track[i].pBase);
                if (bSwap)
                    sz = SWAP_DWORD(sz);
                fwrite(&sz, sizeof(DWORD), 1, pMF->pFile);

                /* Write data */
                fwrite(pMF->Track[i].pBase, sizeof(BYTE), dwData, pMF->pFile);

                /* Free memory */
                free((void *) pMF->Track[i].pBase);
            }

    }

    if (pMF->pFile)
        return fclose(pMF->pFile) ? FALSE : TRUE;
    free((void *) pMF);
    return TRUE;
}


/*
** midiSong* Functions
*/
BOOL midiSongAddSMPTEOffset(MIDI_FILE *_pMF, int iTrack, int iHours,
                            int iMins, int iSecs, int iFrames, int iFFrames)
{
    static BYTE tmp[] =
        { msgMetaEvent, metaSMPTEOffset, 0x05, 0, 0, 0, 0, 0 };

    _VAR_CAST;
    if (!IsFilePtrValid(pMF))
        return FALSE;
    if (!IsTrackValid(iTrack))
        return FALSE;

    if (iMins < 0 || iMins > 59)
        iMins = 0;
    if (iSecs < 0 || iSecs > 59)
        iSecs = 0;
    if (iFrames < 0 || iFrames > 24)
        iFrames = 0;

    tmp[3] = (BYTE) iHours;
    tmp[4] = (BYTE) iMins;
    tmp[5] = (BYTE) iSecs;
    tmp[6] = (BYTE) iFrames;
    tmp[7] = (BYTE) iFFrames;
    return midiTrackAddRaw(pMF, iTrack, sizeof(tmp), tmp, FALSE, 0);
}


BOOL midiSongAddSimpleTimeSig(MIDI_FILE *_pMF, int iTrack, int iNom,
                              int iDenom)
{
    return midiSongAddTimeSig(_pMF, iTrack, iNom, iDenom, 24, 8);
}

BOOL midiSongAddTimeSig(MIDI_FILE *_pMF, int iTrack, int iNom, int iDenom,
                        int iClockInMetroTick, int iNotated32nds)
{
    static BYTE tmp[] = { msgMetaEvent, metaTimeSig, 0x04, 0, 0, 0, 0 };

    _VAR_CAST;
    if (!IsFilePtrValid(pMF))
        return FALSE;
    if (!IsTrackValid(iTrack))
        return FALSE;

    tmp[3] = (BYTE) iNom;
    tmp[4] = (BYTE) (MIDI_NOTE_MINIM / iDenom);
    tmp[5] = (BYTE) iClockInMetroTick;
    tmp[6] = (BYTE) iNotated32nds;
    return midiTrackAddRaw(pMF, iTrack, sizeof(tmp), tmp, FALSE, 0);
}

BOOL midiSongAddKeySig(MIDI_FILE *_pMF, int iTrack, tMIDI_KEYSIG iKey)
{
    static BYTE tmp[] = { msgMetaEvent, metaKeySig, 0x02, 0, 0 };

    _VAR_CAST;
    if (!IsFilePtrValid(pMF))
        return FALSE;
    if (!IsTrackValid(iTrack))
        return FALSE;

    tmp[3] = (BYTE) ((iKey & keyMaskKey) * ((iKey & keyMaskNeg) ? -1 : 1));
    tmp[4] = (BYTE) ((iKey & keyMaskMin) ? 1 : 0);
    return midiTrackAddRaw(pMF, iTrack, sizeof(tmp), tmp, FALSE, 0);
}

BOOL midiSongAddTempo(MIDI_FILE *_pMF, int iTrack, int iTempo)
{
    static BYTE tmp[] = { msgMetaEvent, metaSetTempo, 0x03, 0, 0, 0 };
    int us;                     /* micro-seconds per qn */

    _VAR_CAST;
    if (!IsFilePtrValid(pMF))
        return FALSE;
    if (!IsTrackValid(iTrack))
        return FALSE;

    us = 60000000L / iTempo;
    tmp[3] = (BYTE) ((us >> 16) & 0xff);
    tmp[4] = (BYTE) ((us >> 8) & 0xff);
    tmp[5] = (BYTE) ((us >> 0) & 0xff);
    return midiTrackAddRaw(pMF, iTrack, sizeof(tmp), tmp, FALSE, 0);
}

BOOL midiSongAddMIDIPort(MIDI_FILE *_pMF, int iTrack, int iPort)
{
    static BYTE tmp[] = { msgMetaEvent, metaMIDIPort, 1, 0 };

    _VAR_CAST;
    if (!IsFilePtrValid(pMF))
        return FALSE;
    if (!IsTrackValid(iTrack))
        return FALSE;
    tmp[3] = (BYTE) iPort;
    return midiTrackAddRaw(pMF, iTrack, sizeof(tmp), tmp, FALSE, 0);
}

BOOL midiSongAddEndSequence(MIDI_FILE *_pMF, int iTrack)
{
    static BYTE tmp[] = { msgMetaEvent, metaEndSequence, 0 };

    _VAR_CAST;
    if (!IsFilePtrValid(pMF))
        return FALSE;
    if (!IsTrackValid(iTrack))
        return FALSE;

    return midiTrackAddRaw(pMF, iTrack, sizeof(tmp), tmp, FALSE, 0);
}


/*
** midiTrack* Functions
*/
BOOL midiTrackAddRaw(MIDI_FILE *_pMF, int iTrack, int data_sz,
                     const BYTE * pData, BOOL bMovePtr, int dt)
{
    MIDI_FILE_TRACK *pTrk;
    BYTE *ptr;
    int dtime;

    _VAR_CAST;
    if (!IsFilePtrValid(pMF))
        return FALSE;
    if (!IsTrackValid(iTrack))
        return FALSE;

    pTrk = &pMF->Track[iTrack];
    ptr = _midiGetPtr(pMF, iTrack, data_sz + DT_DEF);
    if (!ptr)
        return FALSE;

    dtime = pTrk->dt;
    if (bMovePtr)
        dtime += dt;

    ptr = _midiWriteVarLen(ptr, dtime);
    memcpy(ptr, pData, data_sz);

    pTrk->pos += dtime;
    pTrk->dt = 0;
    pTrk->ptr = ptr + data_sz;

    return TRUE;
}


BOOL midiTrackIncTime(MIDI_FILE *_pMF, int iTrack, int iDeltaTime,
                      BOOL bOverridePPQN)
{
    DWORD will_end_at;

    _VAR_CAST;
    if (!IsFilePtrValid(pMF))
        return FALSE;
    if (!IsTrackValid(iTrack))
        return FALSE;

    will_end_at = _midiGetLength(pMF->Header.PPQN, iDeltaTime, bOverridePPQN);
    will_end_at += pMF->Track[iTrack].pos + pMF->Track[iTrack].dt;

    midiFileFlushTrack(pMF, iTrack, FALSE, will_end_at);

    return TRUE;
}

BOOL midiTrackAddText(MIDI_FILE *_pMF, int iTrack, tMIDI_TEXT iType,
                      const char *pTxt)
{
    BYTE *ptr;
    int sz;

    _VAR_CAST;
    if (!IsFilePtrValid(pMF))
        return FALSE;
    if (!IsTrackValid(iTrack))
        return FALSE;

    sz = strlen(pTxt);
    if ((ptr = _midiGetPtr(pMF, iTrack, sz + DT_DEF)))
    {
        *ptr++ = 0;             /* delta-time=0 */
        *ptr++ = msgMetaEvent;
        *ptr++ = (BYTE) iType;
        ptr = _midiWriteVarLen((BYTE *) ptr, sz);
        strcpy((char *) ptr, pTxt);
        pMF->Track[iTrack].ptr = ptr + sz;
        return TRUE;
    }
    else
    {
        return FALSE;
    }
}

BOOL midiTrackSetKeyPressure(MIDI_FILE *pMF, int iTrack, int iNote,
                             int iAftertouch)
{
    return midiTrackAddMsg(pMF, iTrack, msgNoteKeyPressure, iNote,
                           iAftertouch);
}

BOOL midiTrackAddControlChange(MIDI_FILE *pMF, int iTrack, tMIDI_CC iCCType,
                               int iParam)
{
    return midiTrackAddMsg(pMF, iTrack, msgControlChange, iCCType, iParam);
}

BOOL midiTrackAddProgramChange(MIDI_FILE *pMF, int iTrack, int iInstrPatch)
{
    return midiTrackAddMsg(pMF, iTrack, msgSetProgram, iInstrPatch, 0);
}

BOOL midiTrackChangeKeyPressure(MIDI_FILE *pMF, int iTrack,
                                int iDeltaPressure)
{
    return midiTrackAddMsg(pMF, iTrack, msgChangePressure,
                           iDeltaPressure & 0x7f, 0);
}

BOOL midiTrackSetPitchWheel(MIDI_FILE *pMF, int iTrack, int iWheelPos)
{
    WORD wheel = (WORD) iWheelPos;

    /* bitshift 7 instead of eight because we're dealing with 7 bit numbers */
    wheel += MIDI_WHEEL_CENTRE;
    return midiTrackAddMsg(pMF, iTrack, msgSetPitchWheel, wheel & 0x7f,
                           (wheel >> 7) & 0x7f);
}

BOOL midiTrackAddMsg(MIDI_FILE *_pMF, int iTrack, tMIDI_MSG iMsg,
                     int iParam1, int iParam2)
{
    BYTE *ptr;
    BYTE data[3];
    int sz;

    _VAR_CAST;
    if (!IsFilePtrValid(pMF))
        return FALSE;
    if (!IsTrackValid(iTrack))
        return FALSE;
    if (!IsMessageValid(iMsg))
        return FALSE;

    ptr = _midiGetPtr(pMF, iTrack, DT_DEF);
    if (!ptr)
        return FALSE;

    data[0] = (BYTE) (iMsg | pMF->Track[iTrack].iDefaultChannel);
    data[1] = (BYTE) (iParam1 & 0x7f);
    data[2] = (BYTE) (iParam2 & 0x7f);
    /*
     ** Is this msg a single, or double BYTE, prm?
     */
    switch (iMsg)
    {
    case msgSetProgram:        /* only one byte required for these msgs */
    case msgChangePressure:
        sz = 2;
        break;

    default:                   /* double byte messages */
        sz = 3;
        break;
    }

    return midiTrackAddRaw(pMF, iTrack, sz, data, FALSE, 0);

}

BOOL midiTrackAddNote(MIDI_FILE *_pMF, int iTrack, int iNote, int iLength,
                      int iVol, BOOL bAutoInc, BOOL bOverrideLength)
{
    MIDI_FILE_TRACK *pTrk;
    BYTE *ptr;
    BOOL bSuccess = FALSE;
    int i, chn;

    _VAR_CAST;
    if (!IsFilePtrValid(pMF))
        return FALSE;
    if (!IsTrackValid(iTrack))
        return FALSE;
    if (!IsNoteValid(iNote))
        return FALSE;

    pTrk = &pMF->Track[iTrack];
    ptr = _midiGetPtr(pMF, iTrack, DT_DEF);
    if (!ptr)
        return FALSE;

    chn = pTrk->iDefaultChannel;
    iLength = _midiGetLength(pMF->Header.PPQN, iLength, bOverrideLength);

    for (i = 0; i < sizeof(pTrk->LastNote) / sizeof(pTrk->LastNote[0]); ++i)
        if (pTrk->LastNote[i].valid == FALSE)
        {
            pTrk->LastNote[i].note = (BYTE) iNote;
            pTrk->LastNote[i].chn = (BYTE) chn;
            pTrk->LastNote[i].end_pos = pTrk->pos + pTrk->dt + iLength;
            pTrk->LastNote[i].valid = TRUE;
            bSuccess = TRUE;

            ptr = _midiWriteVarLen(ptr, pTrk->dt);      /* delta-time */
            *ptr++ = (BYTE) (msgNoteOn | chn);
            *ptr++ = (BYTE) iNote;
            *ptr++ = (BYTE) iVol;
            break;
        }

    if (!bSuccess)
        return FALSE;

    pTrk->ptr = ptr;

    pTrk->pos += pTrk->dt;
    pTrk->dt = 0;

    if (bAutoInc)
        return midiTrackIncTime(pMF, iTrack, iLength, bOverrideLength);

    return TRUE;
}

BOOL midiTrackAddRest(MIDI_FILE *_pMF, int iTrack, int iLength,
                      BOOL bOverridePPQN)
{
    _VAR_CAST;
    if (!IsFilePtrValid(pMF))
        return FALSE;
    if (!IsTrackValid(iTrack))
        return FALSE;

    iLength = _midiGetLength(pMF->Header.PPQN, iLength, bOverridePPQN);
    return midiTrackIncTime(pMF, iTrack, iLength, bOverridePPQN);
}

int midiTrackGetEndPos(MIDI_FILE *_pMF, int iTrack)
{
    _VAR_CAST;
    if (!IsFilePtrValid(pMF))
        return FALSE;
    if (!IsTrackValid(iTrack))
        return FALSE;

    return pMF->Track[iTrack].pos;
}

/*
** midiRead* Functions
*/
static BYTE *_midiReadVarLen(BYTE * ptr, DWORD * num)
{
    register DWORD value;
    register BYTE c;

    if ((value = *ptr++) & 0x80)
    {
        value &= 0x7f;
        do
        {
            value = (value << 7) + ((c = *ptr++) & 0x7f);
        }
        while (c & 0x80);
    }
    *num = value;
    return (ptr);
}


static BOOL _midiReadTrackCopyData(MIDI_MSG * pMsg, BYTE * ptr, DWORD sz,
                                   BOOL bCopyPtrData)
{
    if (sz > pMsg->data_sz)
    {
        pMsg->data = (BYTE *) realloc(pMsg->data, sz);
        pMsg->data_sz = sz;
    }

    if (!pMsg->data)
        return FALSE;

    if (bCopyPtrData && ptr)
        memcpy(pMsg->data, ptr, sz);

    return TRUE;
}

int midiReadGetNumTracks(const MIDI_FILE *_pMF)
{
    _VAR_CAST;
    return pMF->Header.iNumTracks;
}

BOOL midiReadGetNextMessage(const MIDI_FILE *_pMF, int iTrack,
                            MIDI_MSG * pMsg)
{
    MIDI_FILE_TRACK *pTrack;
    BYTE *bptr, *pMsgDataPtr;
    int sz;

    _VAR_CAST;
    if (!IsTrackValid(iTrack))
        return FALSE;

    pTrack = &pMF->Track[iTrack];
    /* FIXME: Check if there is data on this track first!!! */
    if (pTrack->ptr >= pTrack->pEnd)
        return FALSE;

    pTrack->ptr = _midiReadVarLen(pTrack->ptr, &pMsg->dt);
    pTrack->pos += pMsg->dt;

    pMsg->dwAbsPos = pTrack->pos;

    if (*pTrack->ptr & 0x80)    /* Is this is sys message */
    {
        pMsg->iType = (tMIDI_MSG) ((*pTrack->ptr) & 0xf0);
        pMsgDataPtr = pTrack->ptr + 1;

        /* SysEx & Meta events don't carry channel info, but something
         ** important in their lower bits that we must keep */
        if (pMsg->iType == 0xf0)
            pMsg->iType = (tMIDI_MSG) (*pTrack->ptr);
    }
    else                        /* just data - so use the last msg type */
    {
        pMsg->iType = pMsg->iLastMsgType;
        pMsgDataPtr = pTrack->ptr;
    }

    pMsg->iLastMsgType = (tMIDI_MSG) pMsg->iType;
    pMsg->iLastMsgChnl = (BYTE) ((*pTrack->ptr) & 0x0f) + 1;

    switch (pMsg->iType)
    {
    case msgNoteOn:
        pMsg->MsgData.NoteOn.iChannel = pMsg->iLastMsgChnl;
        pMsg->MsgData.NoteOn.iNote = *(pMsgDataPtr);
        pMsg->MsgData.NoteOn.iVolume = *(pMsgDataPtr + 1);
        pMsg->iMsgSize = 3;
        break;

    case msgNoteOff:
        pMsg->MsgData.NoteOff.iChannel = pMsg->iLastMsgChnl;
        pMsg->MsgData.NoteOff.iNote = *(pMsgDataPtr);
        pMsg->iMsgSize = 3;
        break;

    case msgNoteKeyPressure:
        pMsg->MsgData.NoteKeyPressure.iChannel = pMsg->iLastMsgChnl;
        pMsg->MsgData.NoteKeyPressure.iNote = *(pMsgDataPtr);
        pMsg->MsgData.NoteKeyPressure.iPressure = *(pMsgDataPtr + 1);
        pMsg->iMsgSize = 3;
        break;

    case msgSetParameter:
        pMsg->MsgData.NoteParameter.iChannel = pMsg->iLastMsgChnl;
        pMsg->MsgData.NoteParameter.iControl = (tMIDI_CC) * (pMsgDataPtr);
        pMsg->MsgData.NoteParameter.iParam = *(pMsgDataPtr + 1);
        pMsg->iMsgSize = 3;
        break;

    case msgSetProgram:
        pMsg->MsgData.ChangeProgram.iChannel = pMsg->iLastMsgChnl;
        pMsg->MsgData.ChangeProgram.iProgram = *(pMsgDataPtr);
        pMsg->iMsgSize = 2;
        break;

    case msgChangePressure:
        pMsg->MsgData.ChangePressure.iChannel = pMsg->iLastMsgChnl;
        pMsg->MsgData.ChangePressure.iPressure = *(pMsgDataPtr);
        pMsg->iMsgSize = 2;
        break;

    case msgSetPitchWheel:
        pMsg->MsgData.PitchWheel.iChannel = pMsg->iLastMsgChnl;
        pMsg->MsgData.PitchWheel.iPitch =
            *(pMsgDataPtr) | (*(pMsgDataPtr + 1) << 7);
        pMsg->MsgData.PitchWheel.iPitch -= MIDI_WHEEL_CENTRE;
        pMsg->iMsgSize = 3;
        break;

    case msgMetaEvent:
        /* We can use 'pTrack->ptr' from now on, since meta events
         ** always have bit 7 set */
        bptr = pTrack->ptr;
        pMsg->MsgData.MetaEvent.iType = (tMIDI_META) * (pTrack->ptr + 1);
        pTrack->ptr = _midiReadVarLen(pTrack->ptr + 2, &pMsg->iMsgSize);
        sz = (pTrack->ptr - bptr) + pMsg->iMsgSize;

        if (_midiReadTrackCopyData(pMsg, pTrack->ptr, sz, FALSE) == FALSE)
            return FALSE;

        /* Now copy the data... */
        memcpy(pMsg->data, bptr, sz);

        /* Now place it in a neat structure */
        switch (pMsg->MsgData.MetaEvent.iType)
        {
        case metaMIDIPort:
            pMsg->MsgData.MetaEvent.Data.iMIDIPort = *(pTrack->ptr + 0);
            break;
        case metaSequenceNumber:
            pMsg->MsgData.MetaEvent.Data.iSequenceNumber = *(pTrack->ptr + 0);
            break;
        case metaTextEvent:
        case metaCopyright:
        case metaTrackName:
        case metaInstrument:
        case metaLyric:
        case metaMarker:
        case metaCuePoint:
            /* TODO - Add NULL terminator ??? */
            pMsg->MsgData.MetaEvent.Data.Text.pData = pTrack->ptr;
            break;
        case metaEndSequence:
            /* NO DATA */
            break;
        case metaSetTempo:
            {
                DWORD us =
                    ((*(pTrack->ptr + 0)) << 16) | ((*(pTrack->ptr + 1)) << 8)
                    | (*(pTrack->ptr + 2));
                pMsg->MsgData.MetaEvent.Data.Tempo.iBPM = 60000000L / us;
            }
            break;
        case metaSMPTEOffset:
            pMsg->MsgData.MetaEvent.Data.SMPTE.iHours = *(pTrack->ptr + 0);
            pMsg->MsgData.MetaEvent.Data.SMPTE.iMins = *(pTrack->ptr + 1);
            pMsg->MsgData.MetaEvent.Data.SMPTE.iSecs = *(pTrack->ptr + 2);
            pMsg->MsgData.MetaEvent.Data.SMPTE.iFrames = *(pTrack->ptr + 3);
            pMsg->MsgData.MetaEvent.Data.SMPTE.iFF = *(pTrack->ptr + 4);
            break;
        case metaTimeSig:
            pMsg->MsgData.MetaEvent.Data.TimeSig.iNom = *(pTrack->ptr + 0);
            pMsg->MsgData.MetaEvent.Data.TimeSig.iDenom =
                *(pTrack->ptr + 1) * MIDI_NOTE_MINIM;
            /* TODO: Variations without 24 & 8 */
            break;
        case metaKeySig:
            if (*pTrack->ptr & 0x80)
            {
                /* Do some trendy sign extending in reverse :) */
                pMsg->MsgData.MetaEvent.Data.KeySig.iKey =
                    ((256 - *pTrack->ptr) & keyMaskKey);
                pMsg->MsgData.MetaEvent.Data.KeySig.iKey |= keyMaskNeg;
            }
            else
            {
                pMsg->MsgData.MetaEvent.Data.KeySig.iKey =
                    (tMIDI_KEYSIG) (*pTrack->ptr & keyMaskKey);
            }
            if (*(pTrack->ptr + 1))
                pMsg->MsgData.MetaEvent.Data.KeySig.iKey |= keyMaskMin;
            break;
        case metaSequencerSpecific:
            pMsg->MsgData.MetaEvent.Data.Sequencer.iSize = pMsg->iMsgSize;
            pMsg->MsgData.MetaEvent.Data.Sequencer.pData = pTrack->ptr;
            break;
        }

        pTrack->ptr += pMsg->iMsgSize;
        pMsg->iMsgSize = sz;
        break;

    case msgSysEx1:
    case msgSysEx2:
        bptr = pTrack->ptr;
        pTrack->ptr = _midiReadVarLen(pTrack->ptr + 1, &pMsg->iMsgSize);
        sz = (pTrack->ptr - bptr) + pMsg->iMsgSize;

        if (_midiReadTrackCopyData(pMsg, pTrack->ptr, sz, FALSE) == FALSE)
            return FALSE;

        /* Now copy the data... */
        memcpy(pMsg->data, bptr, sz);
        pTrack->ptr += pMsg->iMsgSize;
        pMsg->iMsgSize = sz;
        pMsg->MsgData.SysEx.pData = pMsg->data;
        pMsg->MsgData.SysEx.iSize = sz;
        break;
    }
    /*
     ** Standard MIDI messages use a common copy routine
     */
    pMsg->bImpliedMsg = FALSE;
    if ((pMsg->iType & 0xf0) != 0xf0)
    {
        if (*pTrack->ptr & 0x80)
        {
        }
        else
        {
            pMsg->bImpliedMsg = TRUE;
            pMsg->iImpliedMsg = pMsg->iLastMsgType;
            pMsg->iMsgSize--;
        }
        _midiReadTrackCopyData(pMsg, pTrack->ptr, pMsg->iMsgSize, TRUE);
        pTrack->ptr += pMsg->iMsgSize;
    }
    return TRUE;
}

void midiReadInitMessage(MIDI_MSG * pMsg)
{
    pMsg->data = NULL;
    pMsg->data_sz = 0;
    pMsg->bImpliedMsg = FALSE;
}

void midiReadFreeMessage(MIDI_MSG * pMsg)
{
    if (pMsg->data)
        free((void *) pMsg->data);
    pMsg->data = NULL;
}