#include <libaudio.h> 
#include <stdio.h>
#include <stdlib.h>
#include <bstring.h>
#include <string.h>
#include <u64gio.h>
#include <unistd.h>
#include "midiApp.h"
#include "midiDmon.h"
#include "midiGlobals.h"

#ifdef SYSEX_IMPL

#include <sysex.h>
#include <synthcommon.h>



#define IFF_ID_FORM             'FORM'
#define IFF_ID_AIFC             'AIFC'
#define IFF_ID_AIFF             'AIFF'
#define IFF_ID_COMM             'COMM'
#define IFF_ID_SSND             'SSND'
#define IFF_ID_INST             'INST'
#define IFF_ID_APPL             'APPL'
#define IFF_ID_MARK             'MARK'
#define CODE_NAME               "VADPCMCODES"
#define LOOP_NAME               "VADPCMLOOPS"
#define VERSION                 1

#define NoLooping               0
#define ForwardLooping          1
#define ForwardBackwardLooping  2

typedef struct {
    unsigned long       ckID;
    long                ckSize;
} ChunkHeader;

typedef struct {
    unsigned long       ckID;
    long                ckSize;
    unsigned long       formType;
} Chunk;

typedef struct {
    unsigned long       offset;
    unsigned long       blockSize;
} SoundDataChunk;

typedef struct {
    short               numChannels;
    unsigned short      numFramesH;
    unsigned short      numFramesL;
    short               sampleSize;
    char                sampleRate[10];
    unsigned short      compressionTypeH;        /* Separated into HL to prevent alignment */
    unsigned short      compressionTypeL;        /* note: string follows */
} CommonChunk;

typedef short MarkerID;

typedef struct {
    MarkerID            id;
    unsigned short      positionH;              /* Separated into HL to prevent alignment */
    unsigned short      positionL;              /* note: pstring follows */
} Marker;

int lookupMarker(long *sample, MarkerID loopPoint, Marker *markers, int nmarkers);

typedef struct {
    short               playMode;
    MarkerID            beginLoop;
    MarkerID            endLoop;
} Loop;

typedef struct {
    char                baseNote;
    char                detune;
    char                lowNote;
    char                highNote;
    char                lowVelocity;
    char                highVelocity;
    short               gain;
    Loop                sustainLoop;
    Loop                releaseLoop;
} InstrumentChunk;

extern int  errno;

int     gLoopCt,gBookCt;

char *ReadPString(FILE *ifile);

int ReadAIFCFile(char *fname,ALWaveTable *wvTblPtr)
{
    int         i,num,mirrorSize,done=0,retVal;
    long        waveLen,offset,readLen;
    long        skip,applSig;
    ChunkHeader Header;
    Chunk       FormChunk;
    CommonChunk comm;
    char        *ChunkName;
    FILE        *sourceFile;
    u8          *smpBuf;
    ALADPCMloop *loopPtr;
    ALRawLoop   *rawLoopPtr;
    ALADPCMBook *bookPtr;
    short       order;
    short       npredictors;
    short       version;
    short       nloops;
    short       nMarkers;
    long        start;
    long        end;
    int         bookSize;                            
    ALSymObj    *symObjPtr;
    Marker              *markers;
    SoundDataChunk      ssndData;
    InstrumentChunk     inst;
    char                loopName[16];
    char                bookName[16];
    u32                 numBytes,smpOffset;
    unsigned long       compressionType;

    sourceFile = fopen(fname, "r");
    if(!sourceFile)
    {
        fprintf(stderr,"%s: Unable to open sound file %s\n",gAppName,fname);
        fprintf(stderr,"%s: errno = %d\n",gAppName,errno);
        return -1;
    }

    fread(&FormChunk, sizeof(FormChunk), 1, sourceFile);
    
    if ((FormChunk.ckID != IFF_ID_FORM) ||
        ((FormChunk.formType != IFF_ID_AIFC) && (FormChunk.formType != IFF_ID_AIFF)))
    {
        fprintf(stderr,"%s: %s is not an AIFF-C File\n",gAppName,fname);
        fclose(sourceFile);
        return -1;
    }

    while (!done)
    {
        num = fread(&Header, sizeof(ChunkHeader), 1, sourceFile);
        if (num < 1)
        {
            fclose(sourceFile);
            done = 1;
        }
        
        if(!done)
        {
            skip = (Header.ckSize + 1) & ~1; /* account for pad byte */
        
            switch (Header.ckID)
            {
                case (IFF_ID_COMM):
                    offset = ftell(sourceFile);
                    num = fread (&comm, sizeof(CommonChunk), 1, sourceFile);
                    if (num < 1)
                    {
                        fprintf(stderr,"%s: error reading common chunk\n",gAppName);
                        done = 1;
                    }
                    if (FormChunk.formType != IFF_ID_AIFF)
                        compressionType = comm.compressionTypeH<<16 | comm.compressionTypeL;
                    else
                        compressionType = 'NONE';
                    
                    fseek(sourceFile, offset + skip, SEEK_SET);
                    break;                
                case (IFF_ID_MARK):
                    offset = ftell(sourceFile);
                    fread(&nMarkers, sizeof(short), 1, sourceFile);
                    markers = (Marker *) calloc(nMarkers, sizeof(Marker));
                    for (i=0; i<nMarkers; i++)
                    {
                        fread(&markers[i], sizeof(Marker), 1, sourceFile);
                        ChunkName = ReadPString(sourceFile);        
                        free(ChunkName);            /* Junk the marker name */
                    }
                    fseek(sourceFile, offset + skip, SEEK_SET);
                    break;
                case (IFF_ID_INST):
                    offset = ftell(sourceFile);
                    fread(&inst, sizeof(InstrumentChunk), 1, sourceFile);
                    fseek(sourceFile, offset + skip, SEEK_SET);
                    break;
                case (IFF_ID_SSND):
                    offset = ftell(sourceFile);
                    fread(&ssndData, sizeof (SoundDataChunk), 1, sourceFile);
                    if(ssndData.offset != 0 || ssndData.blockSize !=0)
                    {
                        fprintf(stderr,"%s: AIFC SSND hdr data values != 0",gAppName);
                        fclose(sourceFile);
                        return -1;
                    }
                    readLen = skip - sizeof(SoundDataChunk); /* waveLen must be even */
                    waveLen = (readLen + 7) &~0x00000007;  /* now make it 8 byte aligned */
                
                    if(CheckMemory(0,0,waveLen) != MEMORY_OK)
                    {
                        fprintf(stderr,"%s: Not enough memory for samples\n",gAppName);
                        fprintf(stderr,"%s: needed 0x%x bytes, gSamplesCur = 0x%x, waveLen = 0x%x\n",
                                gAppName,gSamplesCur+waveLen,gSamplesCur,waveLen);
                        fclose(sourceFile);
                        return -1;
                    }
                    smpOffset = gSamplesCur;
                    smpBuf = &gSamples[smpOffset];

                    retVal = fread(smpBuf,readLen,1,sourceFile);
                    
                    wvTblPtr->len = readLen;
                    wvTblPtr->base = (u8*)smpOffset;

                    WriteRamRom(smpOffset + SAMPLES_RAMROM_ADDR,smpBuf,waveLen);
                    gSamplesCur += waveLen;
                    fseek(sourceFile, offset + skip, SEEK_SET);
                    break;
                case (IFF_ID_APPL):
                /* make sure only one of each type of chunk */
                    offset = ftell(sourceFile);
                    fread(&applSig, sizeof(applSig), 1, sourceFile);
                    if (applSig == 'stoc')
                    {
                        ChunkName = ReadPString(sourceFile);
                        if (!strcmp(LOOP_NAME, ChunkName))
                        {
                            fread(&version, sizeof(short), 1, sourceFile);
                            if (version != VERSION)
                            {
                                fprintf(stderr,"%s: Non-identical loop chunk versions\n",gAppName);
                                fclose(sourceFile);
                                return -1;
                            }
                            fread(&nloops, sizeof(short), 1, sourceFile);
                            if (nloops > 1)
                            {
                                fprintf(stderr,"%s: Found %d loops, only 1 supported\n",gAppName);
                                nloops = 1;
                            }

                            mirrorSize = sizeof(ALADPCMloop); 
                            if(mirrorSize & 0x00000007)
                                mirrorSize = (mirrorSize+8) & 0xFFFFFFF8;

                            if(CheckMemory(mirrorSize,0,0)!=MEMORY_OK)
                            {
                                fprintf(stderr,"%s: Not enough memory for a LOOP object\n",gAppName);
                                fclose(sourceFile);
                                return -1;
                            }
                            symObjPtr = &gSymObj[gObjCt];
                            gObjCt++;
                            sprintf(loopName,"_Loop%d",gLoopCt++);
                            symObjPtr->SFObj.objectClass = AL_LOOP_CLASS;
                            symObjPtr->SFObj.bankFileOffset = gMirrorCur;
                            symObjPtr->SFObj.stringOffset = AddName(loopName);
                            symObjPtr->SFObj.refCount = 1;
                            symObjPtr->deleteFlag = 0;

                            AddHashName(loopName,symObjPtr);

                            loopPtr = (ALADPCMloop*)&gMirror[gMirrorCur];

                            fread(loopPtr, sizeof(ALADPCMloop),1, sourceFile);

                            WriteBlock(BANK_RDRAM_ADDR + gMirrorCur,(char*)loopPtr,mirrorSize);

                            wvTblPtr->waveInfo.adpcmWave.loop = (ALADPCMloop*)gMirrorCur;

                            gMirrorCur += mirrorSize;
                        }
                        else if (!strcmp(CODE_NAME, ChunkName))
                        {
                            fread(&version, sizeof(short), 1, sourceFile);
                            if (version != VERSION)
                            {
                                fprintf(stderr, "%s: Bad codebook chunk version\n",gAppName);
                                fclose(sourceFile);
                                return -1;
                            }
                        
                            fread(&order, sizeof(short), 1, sourceFile);
                            fread(&npredictors, sizeof(short), 1, sourceFile);
                        
                            bookSize = npredictors*order*ADPCMVSIZE*sizeof(short);

                            mirrorSize = sizeof(ALADPCMBook) + bookSize; 
                            if(mirrorSize & 0x00000007)
                                mirrorSize = (mirrorSize+8) & 0xFFFFFFF8;

                            if(CheckMemory(mirrorSize,0,0)!=MEMORY_OK)
                            {
                                fprintf(stderr,"%s: Not enough memory for a BOOK object\n",gAppName);
                                fclose(sourceFile);
                                return -1;
                            }
                            symObjPtr = &gSymObj[gObjCt];
                            gObjCt++;
                            sprintf(bookName,"_Book%d",gBookCt++);
                            symObjPtr->SFObj.objectClass = AL_BOOK_CLASS;
                            symObjPtr->SFObj.bankFileOffset = gMirrorCur;
                            symObjPtr->SFObj.stringOffset = AddName(bookName);
                            symObjPtr->SFObj.refCount = 1;
                            symObjPtr->deleteFlag = 0;

                            AddHashName(bookName,symObjPtr);

                            bookPtr = (ALADPCMBook*)&gMirror[gMirrorCur];
                            bookPtr->order = order;
                            bookPtr->npredictors = npredictors;
                        
                            fread(&bookPtr->book[0],sizeof(short), bookSize, sourceFile);

                            WriteBlock(BANK_RDRAM_ADDR + gMirrorCur,(char*)bookPtr,mirrorSize); 

                            wvTblPtr->waveInfo.adpcmWave.book = (ALADPCMBook*)gMirrorCur;
                            gMirrorCur += mirrorSize;
                        }
                        free(ChunkName);
                    }
                    fseek(sourceFile, offset + skip, SEEK_SET); /* probably not needed */
                    break;
                default:      /* skip chunks we don't know about */
                    fseek(sourceFile, skip, SEEK_CUR);                
                    break;
            }         /* end of switch */   
        }  /* end of if(!done)  */            
    }   /* end of while(!done)  */
        
    if (compressionType == 'NONE')
    {
        if(comm.sampleSize == 16)
            wvTblPtr->type = AL_RAW16_WAVE;
        else
        {
            fprintf(stderr,"%s: Raw Sample Size is not 16 bit\n",gAppName);
            return(-1);
        }
        if (inst.sustainLoop.playMode == ForwardLooping)
        {
            if (lookupMarker(&start, inst.sustainLoop.beginLoop, markers, nMarkers))
                fprintf(stderr,"%s: Begin loop marker not found\n",gAppName);
            if (lookupMarker(&end, inst.sustainLoop.endLoop, markers, nMarkers))
                fprintf(stderr,"%s: End loop marker not found\n",gAppName);
            
            /* Make and init a loop object */
            mirrorSize = sizeof(ALADPCMloop); 
            if(mirrorSize & 0x00000007)
                mirrorSize = (mirrorSize+8) & 0xFFFFFFF8;
            
            if(CheckMemory(mirrorSize,0,0)!=MEMORY_OK)
            {
                fprintf(stderr,"%s: Not enough memory for a Raw Loop Object\n",gAppName);
                return(-1);
            }
            
            symObjPtr = &gSymObj[gObjCt];
            gObjCt++;
            sprintf(loopName,"_Loop%d",gLoopCt++);
            symObjPtr->SFObj.objectClass = AL_LOOP_CLASS;
            symObjPtr->SFObj.bankFileOffset = gMirrorCur;
            symObjPtr->SFObj.stringOffset = AddName(loopName);
            symObjPtr->SFObj.refCount = 1;
            symObjPtr->deleteFlag = 0;
            
            AddHashName(loopName,symObjPtr);
            
            rawLoopPtr = (ALRawLoop*)&gMirror[gMirrorCur];
            rawLoopPtr->start = start;
            rawLoopPtr->end = end;
            rawLoopPtr->count = -1;
            
            WriteBlock(BANK_RDRAM_ADDR + gMirrorCur,(char*)rawLoopPtr,mirrorSize);

            wvTblPtr->waveInfo.rawWave.loop = (ALRawLoop*)gMirrorCur;
            
            gMirrorCur += mirrorSize;
        }  /* end of if(forward loop)  */
    }  /* end of if(compressionType == 'NONE')  */

    return(0);
}

char *ReadPString(FILE *ifile)
{
    unsigned char c;
    char        *st;

    fread(&c, 1, 1, ifile);
    st = (char *) malloc(c+1);
    fread(st, c, 1, ifile);
    *(st+c) = 0;
    
    /*
     * Read the pad byte if necessary
     */
    if (!(c & 1))
        fread(&c, 1, 1, ifile);
    return st;
}

int lookupMarker(long *sample, MarkerID loopPoint, Marker *markers, int nmarkers)
{
    int     i;
    
    for (i=0; i<nmarkers; i++)
    {
        if (loopPoint == markers[i].id)
        {
            *sample = (markers[i].positionH<<16) + markers[i].positionL;
            return 0;
        }
    }
    return 1;
}

#endif /* SYSEX_IMPL */