//====================================================================
// midifile.c++
//
// Copyright 1993, Silicon Graphics, Inc.
// All Rights Reserved.
//
// This is UNPUBLISHED PROPRIETARY SOURCE CODE of Silicon Graphics, Inc.;
// the contents of this file may not be disclosed to third parties, copied or
// duplicated in any form, in whole or in part, without the prior written
// permission of Silicon Graphics, Inc.
//
// RESTRICTED RIGHTS LEGEND:
// Use, duplication or disclosure by the Government is subject to restrictions
// as set forth in subdivision (c)(1)(ii) of the Rights in Technical Data
// and Computer Software clause at DFARS 252.227-7013, and/or in similar or
// successor clauses in the FAR, DOD or NASA FAR Supplement. Unpublished -
// rights reserved under the Copyright Laws of the United States.
//====================================================================

#include <malloc.h>
#include <stdlib.h>
#include <string.h>
#include "midifile.h"

MIDIFile::MIDIFile()
{
}

int MIDIFile::Open(const char *fileName, const char *rw)
{
    file = fopen(fileName, rw);
    if (!file) {
        printf("couldn't open file %s\n", name);
        exit(1);
    }

       
    fseek(file, 0, SEEK_END);
    fileSize = ftell(file);
    rewind(file);

    name = (char *) malloc(strlen(fileName)+1);
    strcpy(name, fileName);
    
    return 0;
}

int MIDIFile::Close()
{
    return fclose(file);
}

void MIDIFile::Parse() 
{
    parseHeader();

    int i;
    for (i = 0; i < hdr.ntrks; i++) {
        parseTrack();
    }   
}

void MIDIFile::Write(short format, short ntracks, short division)
{
    writeHeader(format, ntracks, division);
    
    if (format == 1)
        midiWriteTempoTrack();

    int i;
    for (i = 0; i < ntracks; i++)
        writeTrack(i);
    
}

void MIDIFile::parseHeader()
{
    ChunkHdr chdr;
    int rv;
    
    rv = fread (&chdr, sizeof(ChunkHdr), 1, file);

    if (rv != 1)
        midiError("could not read file");
    
    if (chdr.ckID != IFF_ID_MTHD)
        midiError("this is not a Standard MIDI file");

    rv = fread(&hdr, sizeof(TrackHdr), 1, file);
    if (rv != 1)
        midiError("could not read file");
    
    midiHeader(&hdr);
}

void MIDIFile::writeHeader(short format, short tracks, short division)
{
    write32bit(IFF_ID_MTHD);
    write32bit(6);
    write16bit(format);
    write16bit(tracks);
    write16bit(division);    
}

static int msgBytes[] = {
    0, 0, 0, 0, 0, 0, 0, 0,		// 0x00 - 0x70
    2, 2, 2, 2, 1, 1, 2, 0		// 0x80 - 0xf0
};

void MIDIFile::parseTrack()
{
    ChunkHdr    chdr;
    int         rv;
    char        c;
    char        c1;
    int         running = 0;
    int         status = 0;
    
    rv = fread(&chdr, sizeof(ChunkHdr), 1, file);

    if (chdr.ckID != IFF_ID_MTRK)
        midiError("bad track header");

    long offset = ftell(file);
    
    midiTrackStart();

    long bytesToRead = chdr.ckSize;

    curTime = 0;
    
    endOfTrack = 0;
    
    while ( !endOfTrack > 0 ) {

        curTime += readVarLen();	/* delta time */

        c = getc(file);

        switch ( c ) {

            case 0xff:			/* meta event */
                {
                    int type = getc(file);
                    long len = readVarLen();
                    char *buf;
                    if (len) {
                        buf = (char *)malloc((int)len);
                        fread(buf, sizeof(char), (int)len, file);
                    }                    
                    metaEvent(type, buf, len);
                    running = 0;
                    status = 0;
                }
                break;

            case 0xf0: /* start of multi packet system exclusive */
                {
                    long len = readVarLen();
                    char *buf = (char *)malloc((int)len);
                    fread(buf, sizeof(char), (int)len, file);
                    midiSysExStart(buf, (int)len);
                    running = 0;
                    status = 0;
                }
                break;

            case 0xf7:	/* system exclusive  */
                {
                    long len = readVarLen();
                    char *buf = (char *)malloc((int)len);
                    fread(buf, sizeof(char), (int)len, file);
                    midiSysEx(buf, (int)len);
                    running = 0;
                    status = 0;
                }                
                break;

            default:
                {                    
                    if ( (c & 0x80) == 0 ) {	 /* running status? */
                        if ( status == 0 ) {
                            midiError("unexpected running status");
                        }
                        running = 1;
                    } else {
                        status = c;
                        running = 0;
                    }

                    int bytes = msgBytes[ (status>>4) & 0xf ];

                    if ( bytes ) {

                        if ( running ) {
                            c1 = c;
                        } else {
                            c1 = getc(file);
                        }

                        channelEvent( status, c1, (bytes>1) ? getc(file) : 0 );

                    }
                }                
                break;
        }
    }
    
    midiTrackEnd();
    fseek(file, offset + chdr.ckSize, SEEK_SET); // forget any garbage    
}

void MIDIFile::writeTrack(int track) 
{
    long offset = ftell(file);

    write32bit(IFF_ID_MTRK);
    write32bit(0);              // don't know how long the track is yet

    midiWriteTrack(track);

    write8bit(1);              // write the end of track marker
    write8bit(0xff);           // one tick after last midi event
    write8bit(0x2f);           // this extra tick is needed so 
    write8bit(0);              // looping works correctly.
    
    long eot = ftell(file);

    fseek(file, offset, SEEK_SET);
    
    write32bit(IFF_ID_MTRK);
    write32bit(eot - offset - sizeof(ChunkHdr));

    fseek(file, eot, SEEK_SET);
    
}

void MIDIFile::writeMidiEvent(long deltaTime, char status, char b1, char b2) 
{
    writeVarLen(deltaTime);

    if (status != lastStatus)   // running status
        write8bit(status);

    write8bit(b1);

    int bytes = msgBytes[ (status>>4) & 0xf ];

    if (bytes == 2)
        write8bit(b2);
    
    lastStatus = status;
}

void MIDIFile::writeMetaEvent(long deltaTime, char type, char *msg, int len)
{
    lastStatus = 0;

    writeVarLen(deltaTime);

    write8bit(0xff);
    write8bit(type);

    writeVarLen(len); 

    int i;
    for(i = 0; i < len; i++) {
        write8bit(msg[i]);
        
    }
}

void MIDIFile::channelEvent(int status, char byte1, char byte2)
{
    int chan = status & 0xf;

    switch ( status & 0xf0 ) {
	case 0x80:
            midiNoteOff(chan, byte1, byte2);
            break;
            
	case 0x90:
            midiNoteOn(chan, byte1, byte2);
            break;
            
	case 0xa0:
            midiKeyPressure(chan, byte1, byte2);
            break;
            
	case 0xb0:
            midiControlChange(chan, byte1, byte2);
            break;
            
	case 0xe0:
            midiPitchBend(chan, byte1, byte2);
            break;
            
	case 0xc0:
            midiProgramChange(chan, byte1);
            break;
    
	case 0xd0:
            midiChannelPressure(chan, byte1);
            break;
    }
}

void MIDIFile::metaEvent(int type, char *m, long len)
{
    switch  ( type ) {
	case 0x00:
            midiSeqNum(to16bit(m[0],m[1]));
            break;

	case 0x01:	/* Text event */
	case 0x02:	/* Copyright notice */
	case 0x03:	/* Sequence/Track name */
	case 0x04:	/* Instrument name */
	case 0x05:	/* Lyric */
	case 0x06:	/* Marker */
	case 0x07:	/* Cue point */
	case 0x08:
	case 0x09:
	case 0x0a:
	case 0x0b:
	case 0x0c:
	case 0x0d:
	case 0x0e:
	case 0x0f:
            midiText(type, m , (int)len);
            break;
            
	case 0x2f:	/* End of Track */
            midiEndOfTrack();
            endOfTrack = 1;
            break;
            
	case 0x51:	/* Set tempo */
            midiTempo(to32bit(0,m[0],m[1],m[2]));
            break;
            
	case 0x54:      /* SMPTE time */
            midiSMPTE(m[0],m[1],m[2],m[3],m[4]);
            break;

	case 0x58:
            midiTimeSig(m[0],m[1],m[2],m[3]);
            break;
    
	case 0x59:
            midiKeySig(m[0],m[1]);
            break;
    
	case 0x7f:
            midiSeqSpecific(m, len);
            break;
    
	default:
            midiMetaMisc(type, m, len);
            break;
    }
}

long MIDIFile::to32bit(char c1, char c2, char c3, char c4)
{
	long value = 0L;

	value = (c1 & 0xff);
	value = (value<<8) + (c2 & 0xff);
	value = (value<<8) + (c3 & 0xff);
	value = (value<<8) + (c4 & 0xff);
	return (value);
}

short MIDIFile::to16bit(int c1, int c2)
{
	return ((c1 & 0xff ) << 8) + (c2 & 0xff);
}

long MIDIFile::readVarLen()
{
    long value;
    int c;

    c = getc(file);
    value = c;
    if ( c & 0x80 ) {
        value &= 0x7f;
        do {
            c = getc(file);
            value = (value << 7) + (c & 0x7f);
        } while (c & 0x80);
    }
    return (value);
}

void MIDIFile::writeVarLen(long value)
{
    unsigned long buffer;

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

    while(1){
        write8bit((int)buffer & 0xff);
       
	if(buffer & 0x80)
            buffer >>= 8;
	else
            break;
    }
}

/*
 * MIDI File event handlers do nothing in the base class
 */
void MIDIFile::midiHeader(TrackHdr *)
{
}

void MIDIFile::midiTrackStart()
{}

void MIDIFile::midiTrackEnd()
{}

void MIDIFile::midiSeqNum(short )
{}

void MIDIFile::midiMetaMisc(int, char *, long)
{}

void MIDIFile::midiText(int , char * , int )
{}

void MIDIFile::midiEndOfTrack()
{}

void MIDIFile::midiTempo(long /* tempo */)
{}

void MIDIFile::midiSMPTE(char , char , char , char , char )
{}

void MIDIFile::midiTimeSig(char, char, char, char)
{}

void MIDIFile::midiKeySig(char, char)
{}

void MIDIFile::midiNoteOn(char, char, char)
{}

void MIDIFile::midiNoteOff(char, char, char)
{}

void MIDIFile::midiKeyPressure(char, char, char)
{}

void MIDIFile::midiControlChange(char, char, char)
{}

void MIDIFile::midiPitchBend(char, char, char)
{}

void MIDIFile::midiProgramChange(char, char)
{}

void MIDIFile::midiChannelPressure(char , char )
{}

void MIDIFile::midiSeqSpecific(char *, long)
{}

void MIDIFile::midiSysExStart(char *, int)
{}

void MIDIFile::midiSysEx(char *, int)
{}

void MIDIFile::midiError(char *msg) 
{
    printf("error: %s\n", msg);
    exit(1);
}

void MIDIFile::midiWriteTempoTrack() 
{}

void MIDIFile::midiWriteTrack(int )
{}

void MIDIFile::write8bit(int val)
{
    putc(val &0xff, file);
}

void MIDIFile::write16bit(int val)
{
    short tmp = val & 0xffff;

    fwrite(&tmp, sizeof(short), 1, file);
}

void MIDIFile::write32bit(long val)
{
    fwrite(&val, sizeof(long), 1, file);
}