#include <dmedia/midi.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <libaudio.h> 
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include "midiApp.h"
#include "midiDmon.h"
#include "midiGlobals.h"

#ifdef SYSEX_IMPL

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


void CreateInstrumentFile(char *instName);
void CreateSoundFile(char *soundName);
void CreateKeymapFile(char *keyMapName);
void CreateEnvelopeFile(char *envlpName);
void CreateObjectFiles(void);
void DumpInstFromOffset(u32 offset);

#define  MAX_CHECK_STRS   31

array32 gCmmdStrList[MAX_CHECK_STRS]= {
    "bank",
    "preset",                  /* "Instrument:", */
    "oscillator",              /* "Sound:",      */
    "envelope",
    "keymap",
    "synthesizer present",
    "ListAllBanks",
    "ListAllInstruments", 
    "ListAllSounds",
    "ListAllEnvelopes",
    "ListAllKeymaps",
    "ListAllWavetables",
    "ListInstruments:",
    "ListSounds:",
    "CreateBank:",
    "CreateInstrument:",
    "CreateSound:",
    "CreateKeymap:",
    "CreateEnvelope:",
    "CreateWavetable:",
    "DeleteBank:",
    "DeleteInstrument:",
    "DeleteSound:",
    "DeleteKeymap:",
    "DeleteEnvelope:",
    "DeleteWavetable:",
    "CleanMemory",
    "CompactMemory",
    "SelectBank",
    "SaveBanks",
    "dump preset units"};

#define  BANK_CMD           1
#define  INST_CMD           2
#define  SOUND_CMD          3
#define  ENVLP_CMD          4
#define  KMAP_CMD           5
#define  PRESENT_STR        6
#define  LIST_ALL_BANK      7
#define  LIST_ALL_INST      8
#define  LIST_ALL_SNDS      9
#define  LIST_ALL_ENV       10
#define  LIST_ALL_KMAP      11
#define  LIST_ALL_WAVETBL   12
#define  LIST_INSTS         13
#define  LIST_SNDS          14
#define  CREATE_BANK_CMD    15
#define  CREATE_INST_CMD    16
#define  CREATE_SND_CMD     17
#define  CREATE_KMAP_CMD    18
#define  CREATE_ENVLP_CMD   19
#define  CREATE_WAVETBL_CMD 20
#define  DELETE_BANK_CMD    21
#define  DELETE_INST_CMD    22
#define  DELETE_SND_CMD     23
#define  DELETE_KMAP_CMD    24
#define  DELETE_ENVLP_CMD   25
#define  DELETE_WAVETBL_CMD 26
#define  CLEAN_MEMORY_CMD   27
#define  COMPACT_MEMORY_CMD 28
#define  SELECT_BANK_CMD    29
#define  SAVE_BANKS_CMD     30
#define  DUMP_PRESETS_CMD   31

#define  BANK_STR_LEN        4
#define  INST_STR_LEN        6
#define  SOUND_STR_LEN       10
#define  KMAP_STR_LEN        6
#define  ENVLP_STR_LEN       8



array32 gBankStrList[MAX_BANK_STRS] = {
    "default",
    "percussion",
    "instCount",
    "sampleRate",
    "instrument" };

array32 gInstStrList[MAX_INST_STRS] = {
    "volume",
    "pan",
    "priority",
    "soundCount",
    "sound" };

array32 gSoundStrList[MAX_SOUND_STRS] = {
    "wavetable",
    "keymap",
    "envelope",
    "pan",
    "gain" };
    
array32 gEnvlpStrList[MAX_ENVLP_STRS] = {
    "attackTime",
    "attackLevel",
    "decayTime",
    "decayLevel",
    "releaseTime" };

array32 gKmapStrList[MAX_KMAP_STRS] = {
    "velocityMin",
    "velocityMax",
    "keyMin",
    "keyMax",
    "keyBase",
    "detune" };


/******************************************************************
 * ProcessSysEx  Check to see if the sysex is SGI format, and that
 * this isn't one we sent out. Parse by commandID, and call subroutines
 * Check to make sure symbolfile is true. 
 *******************************************************************/

void ProcessSysEx(MDevent *mdv)
{
    double  dvalue;
    char    commandID;
    char    *data;
    char    *parameter,*ptr;
    int     strType;
    char    isSGI;
    int     sgiID;

    isSGI = suIsSGISynthSystemExclusive(mdv);
    if(!isSGI)
    {
        mdFree(mdv->sysexmsg);
        return;
    }
    
    sgiID = suGetOriginID(mdv); 

    if(sgiID!=_SYNTH_NINTENDO_ID)
    {  
        commandID = suGetCommandID(mdv);
        parameter = suGetParameter(mdv);
        ptr = parameter;
        strType = CheckString(&ptr,gCmmdStrList,MAX_CHECK_STRS);
        if(verbose)
        {
            int c;
            fprintf(stderr,"%s: SGI SysEx msg, origin %d, command %d type %d\n",gAppName,
                    sgiID,commandID,strType);
            for(c = 0; c < mdv->msglen; c++)
                printf("%c ",mdv->sysexmsg[c]);
            printf("\n");
        }

        switch (commandID)
        {
            case _AP_GET_BOOLEAN:
                if(strType == PRESENT_STR)
                {
                    AckPresent(parameter);
                    CreateObjectFiles();
                }
                break;
            case _AP_GET_STRING:
                HandleGetString(parameter,strType);
                break;
            case _AP_GET_NUMBER:
                HandleGetNumber(parameter,strType);
                break;
            case _AP_SET_NUMBER:
                data = suGetData(mdv);
                dvalue = suNibblesToDouble(data);
                HandleSetNumber(ptr,strType,dvalue);
                break;
            case _AP_SET_STRING:
                data = suGetData(mdv);
                HandleSetString(ptr,strType,data);
            case _AP_TELL:
                HandleTell(parameter,strType);
            break;
        } 
    }

    mdFree(mdv->sysexmsg);
}

void HandleTell(char *param,int strType)
{
    ALBankFile      *myBankFile;
    ALBank          *defBank;
    ALInstrument    *defInst;
    u32              defBankOffset,defInstOffset;
    ALSymObj        *instSymObj;
    char            *instName;
    
    switch(strType)
    {
        case DUMP_PRESETS_CMD:
            printf("Found a dump presets command\n");
            myBankFile = (ALBankFile*)gMirror;
            defBankOffset = (u32)myBankFile->bankArray[0];
            defBank = (ALBank*)&gMirror[defBankOffset];
            defInstOffset = (u32)defBank->instArray[0];
            DumpInstFromOffset(defInstOffset);
            break;
    }

}

void DumpInstFromOffset(u32 offset)
{
    char        *instName,*sndName,*tmpPtr;
    char        tmpStr[256];
    int         c = 0;

    instName = GetStrFromOffset(offset);
    ReplyString("preset(default) path",instName);     /* AP_SET_STRING  "preset(default) path" "Piano44K" */
    sprintf(tmpStr,"preset%s oscillators",instName);
    sndName = BuildSoundList(instName);
    ReplyString(tmpStr,sndName);                     /* AP_SET_STRING  "presetPiano44K oscillators"
                                                       "Piano44K00 Piano44K01 Piano44K02 Piano44K03
                                                       Piano44K04 Piano44K05 Piano44K06 Piano44K07" */
    while(sndName[c] != ' ')
        c++;
    sndName[c] = 0;
    ReplyString("oscillator(default) path",tmpStr);  /* AP_SET_STRING 'oscillator(default) path' 'Piano44K00' */
    
    
    sprintf(tmpStr,"oscillator%s gain",sndName);
    HandleGetSnd(tmpStr);                           /* AP_SET_NUMBER 'oscillatorPiano44K00 gain' '1.000000' */
    free(sndName);
}
void HandleGetNumber(char *param,int strType)
{
    switch(strType)
    {
        case  BANK_CMD:
            HandleGetBank(param);
            break;
        case  INST_CMD:
            HandleGetInst(param);
            break;
        case  SOUND_CMD:
            HandleGetSnd(param);
            break;
        case  ENVLP_CMD:
            HandleGetEnvlp(param);
            break;
        case  KMAP_CMD:
            HandleGetKmap(param);
            break;
    }
}

void HandleSetNumber(char *param,int strType,double dvalue)
{
    switch(strType)
    {
        case  BANK_CMD:
            HandleSetBank(param,(char *)NULL,dvalue);
            break;
        case  INST_CMD:
            HandleSetInst(param,(char *)NULL,dvalue);
            break;
        case  SOUND_CMD:
            HandleSetSnd(param,(char *)NULL,dvalue);
            break;
        case  ENVLP_CMD:
            HandleSetEnvlp(param,dvalue);
            break;
        case  KMAP_CMD:
            HandleSetKmap(param,dvalue);
            break;
    }
}

void HandleGetString(char *param,int strType)
{
    switch(strType)
    {
        case  BANK_CMD:
            HandleGetBank(param);
            break;
        case  INST_CMD:
            HandleGetInst(param);
            break;
        case  SOUND_CMD:
            HandleGetSnd(param);
            break;
        case  LIST_ALL_BANK:
            SendClassList(AL_BANK_CLASS,param);
            break;
        case  LIST_ALL_INST:
            SendClassList(AL_INST_CLASS,param);
            break;
        case  LIST_ALL_SNDS:
            SendClassList(AL_SOUND_CLASS,param);
            break;          
        case  LIST_ALL_ENV:          
            SendClassList(AL_ENVLP_CLASS,param);
            break;        
        case  LIST_ALL_KMAP: 
            SendClassList(AL_KEYMAP_CLASS,param);
            break; 
        case  LIST_ALL_WAVETBL: 
            SendClassList(AL_WAVETBL_CLASS,param);
            break;
        case LIST_INSTS:
            SendInstList(param);
            break;
        case LIST_SNDS:
            SendSoundList(param);
            break;
    }
}

void HandleSetString(char *param,int strType,char *data)
{
    switch(strType)
    {
        case  BANK_CMD:
            HandleSetBank(param,data,(double)0);
            break;
        case  INST_CMD:
            HandleSetInst(param,data,(double)0);
            break;
        case SOUND_CMD:
            HandleSetSnd(param,data,(double)0);
            break;
        case CREATE_BANK_CMD:
            CreateBankObj(param,data);
            break;
        case CREATE_INST_CMD:
            CreateInstObj(param,data);
            break;
        case CREATE_SND_CMD:
            CreateSndObj(param,data);
            break;
        case CREATE_KMAP_CMD:
            CreateKmapObj(param,data);
            break;
        case CREATE_ENVLP_CMD:
            CreateEnvlpObj(param,data);
            break;
        case CREATE_WAVETBL_CMD:
            CreateWavetblObj(param,data);
            break;
        case DELETE_BANK_CMD:
        case DELETE_INST_CMD:
        case DELETE_SND_CMD:
        case DELETE_KMAP_CMD:
        case DELETE_ENVLP_CMD:
        case DELETE_WAVETBL_CMD:
            DeleteObject(param);
            break;
        case CLEAN_MEMORY_CMD:
            CleanMemory(0,0);
            sleep(2);       /* precautionary */
            break;
        case COMPACT_MEMORY_CMD:
            CompactMemory();
            sleep(2);      /* precautionary */
            break;
        case SELECT_BANK_CMD:
            SelectBank(data);
            break;
        case SAVE_BANKS_CMD:
            SaveBanks(data);
            break;
    }
}

void HandleGetBank(char *param)
{
    char            *ptr = param + BANK_STR_LEN;
    char            hashName[MAX_HASH_NAME_SIZE];
    ALSymObj        *entry;
    int             paramValue,count;
    u32             value;
    ALBank          *bankPtr;
    
    ptr = parsename(ptr,hashName);
    entry = MatchHashName(hashName);
    if(!entry)
    {
        fprintf(stderr,"%s: Unknown object name %s\n",gAppName,hashName);
        return;
    }
    paramValue = CheckString(&ptr,gBankStrList,MAX_BANK_STRS);  
    bankPtr = (ALBank*) &gMirror[entry->SFObj.bankFileOffset];

    switch(paramValue)
    {
        case BANK_PERC_PARAM:
            value = (u32) bankPtr->percussion;
            ptr = GetStrFromOffset(value);
            ReplyString(param,ptr);
            break;
        case BANK_INST_CT_PARAM:
            value = (u32) bankPtr->instCount;
            ReplyValue(param,value);
            break;
        case BANK_RATE_PARAM:
            value = (u32) bankPtr->sampleRate;
            ReplyValue(param,value);
            break;
        case BANK_INST_PARAM:
            count = GetNumber(&ptr);
            value = (u32) bankPtr->instArray[count];
            ptr = GetStrFromOffset(value);
            ReplyString(param,ptr);
            break;
    }
}

void HandleSetBank(char *param,char *data,double dvalue)
{
    char            hashName[MAX_HASH_NAME_SIZE];
    ALSymObj        *entry,*target;
    int             paramValue,count;
    u32             offset,value,newOffset,oldObjOffset, blkVal;
    ALBank          *bankPtr;

    value = (u32) dvalue;
    param = parsename(param,hashName);
    entry = MatchHashName(hashName);
    if(!entry)
    {
        fprintf(stderr,"%s: Unable to match object name %s\n",gAppName,hashName);
        return;
    }
    paramValue = CheckString(&param,gBankStrList,MAX_BANK_STRS);  
    bankPtr = (ALBank*)&gMirror[entry->SFObj.bankFileOffset];
    offset = entry->SFObj.bankFileOffset + BANK_RDRAM_ADDR;
    
    switch(paramValue)
    {
        case BANK_PERC_PARAM:
            oldObjOffset = (u32)bankPtr->percussion;
            DecRefCtFromOffset(oldObjOffset);
            target = MatchHashName(data);
            if(!target)
            {
                fprintf(stderr,"%s: Unknown target name %s\n",gAppName,data);
                break;
            }
            target->SFObj.refCount++;
            newOffset = target->SFObj.bankFileOffset;
            bankPtr->percussion = (ALInstrument*)newOffset;
            offset = (u32) &((ALBank*)offset)->percussion;            
            SetValue(offset,SET_32,newOffset+BANK_RDRAM_ADDR);
            break;
        case BANK_INST_CT_PARAM:
            bankPtr->instCount = (s16)value;
            offset = (u32) &((ALBank*)offset)->instCount;
            SetValue(offset,SET_16,value);
            break;
        case BANK_RATE_PARAM:
            bankPtr->sampleRate = (s32)value;
            offset = (u32) &((ALBank*)offset)->sampleRate;
            SetValue(offset,SET_32,value);
            break;
        case BANK_INST_PARAM:
           
            count = GetNumber(&param);
            oldObjOffset = (u32)bankPtr->instArray[count];
            DecRefCtFromOffset(oldObjOffset);
            target = MatchHashName(data);
            if(!target)
            {
                fprintf(stderr,"%s: Unknown target name %s\n",gAppName,data);
                break;
            }
            target->SFObj.refCount++;
            newOffset = target->SFObj.bankFileOffset;
            bankPtr->instArray[count] = (ALInstrument*)newOffset;
            offset = (u32) &((ALBank*)offset)->instArray[count];
            SetValue(offset,SET_32,newOffset+BANK_RDRAM_ADDR);
            FakeProgChnge(count); 
            break;
    }
}

void HandleGetInst(char *param)
{
    char            *ptr = param + INST_STR_LEN;
    char            hashName[MAX_HASH_NAME_SIZE];
    ALSymObj        *entry;
    int             paramValue,count;
    u32             value;
    ALInstrument    *instPtr;


    ptr = parsename(ptr,hashName);
    entry = MatchHashName(hashName);
    if(!entry)
    {
        fprintf(stderr,"%s: Unknown object name %s\n",gAppName,hashName);
        return;
    }
    paramValue = CheckString(&ptr,gInstStrList,MAX_INST_STRS);  
    instPtr = (ALInstrument*) &gMirror[entry->SFObj.bankFileOffset];

    switch(paramValue)
    {
        case INST_VOLUME_PARAM:
            value = (u32)instPtr->volume;
            ReplyValue(param,value);
            break;
        case INST_PAN_PARAM:
            value = (u32)instPtr->pan;
            ReplyValue(param,value);
            break;
        case INST_PRIOR_PARAM:
            value = (u32)instPtr->priority;
            ReplyValue(param,value);
            break;
        case INST_SNDCOUNT_PARAM:
            value = (u32)instPtr->soundCount;
            ReplyValue(param,value);
            break;
        case INST_SNDARRAY_PARAM:
            count = GetNumber(&ptr);
            value = (u32)instPtr->soundArray[count];
            ptr = GetStrFromOffset(value);
            ReplyString(param,ptr);
            break;
    }
}

void HandleSetInst(char *param,char *data,double dvalue)
{
    char            hashName[MAX_HASH_NAME_SIZE];
    ALSymObj        *entry,*target;
    int             paramValue,count;
    u32             offset,value,newOffset,oldObjOffset;
    ALInstrument    *instPtr;
    
    value = (u32) dvalue;
    param = parsename(param,hashName);
    entry = MatchHashName(hashName);
    if(!entry)
    {
        fprintf(stderr,"%s: Unknown object name %s\n",gAppName,hashName);
        return;
    }
    paramValue = CheckString(&param,gInstStrList,MAX_INST_STRS);  
    instPtr = (ALInstrument*)&gMirror[entry->SFObj.bankFileOffset];
    offset = entry->SFObj.bankFileOffset + BANK_RDRAM_ADDR;
    
    switch(paramValue)
    {
        case INST_VOLUME_PARAM:
            instPtr->volume = (u8)value;
            offset = (u32) &((ALInstrument*)offset)->volume;
            SetValue(offset,SET_8,value);
            break;
        case INST_PAN_PARAM:
            instPtr->pan = (u8)value;
            offset = (u32) &((ALInstrument*)offset)->pan;
            SetValue(offset,SET_8,value);
            break;
        case INST_PRIOR_PARAM:
            instPtr->priority = (u8)value;
            offset = (u32) &((ALInstrument*)offset)->priority;
            SetValue(offset,SET_8,value);
            break;
        case INST_SNDCOUNT_PARAM:
            instPtr->soundCount = (u32)value;
            offset = (u32) &((ALInstrument*)offset)->soundCount;
            SetValue(offset,SET_32,value);
            break;
        case INST_SNDARRAY_PARAM:
            count = GetNumber(&param);
            oldObjOffset = (u32)instPtr->soundArray[count];
            DecRefCtFromOffset(oldObjOffset);
            target = MatchHashName(data);
            if(!target)
            {
                fprintf(stderr,"%s: Unknown target name %s\n",gAppName,data);
                break;
            }
            target->SFObj.refCount++;
            newOffset = target->SFObj.bankFileOffset;
            instPtr->soundArray[count] = (ALSound*)newOffset;
            offset = (u32) &((ALInstrument*)offset)->soundArray[count];            
            SetValue(offset,SET_32,newOffset+BANK_RDRAM_ADDR);
            break;
    }
}

void HandleGetSnd(char *param)
{
    char            *ptr = param + SOUND_STR_LEN;
    char            hashName[MAX_HASH_NAME_SIZE];
    ALSymObj        *entry;
    int             paramValue;
    u32             value;
    ALSound         *sndPtr;
    

    ptr = parsename(ptr,hashName);
    entry = MatchHashName(hashName);
    if(!entry)
    {
        fprintf(stderr,"%s: Unknown object name %s\n",gAppName,hashName);
        return;
    }

    paramValue = CheckString(&ptr,gSoundStrList,MAX_SOUND_STRS);  
    sndPtr = (ALSound*) &gMirror[entry->SFObj.bankFileOffset];
    switch(paramValue)
    {
        case SND_SAMPLE_PARAM:
            value = (u32)sndPtr->wavetable;
            ptr = GetStrFromOffset(value);
            ReplyString(param,ptr);
            break;
        case SND_KEYMAP_PARAM:
            value = (u32)sndPtr->keyMap;
            ptr = GetStrFromOffset(value);
            ReplyString(param,ptr);
            break;
        case SND_ENVLP_PARAM:
            value = (u32)sndPtr->envelope;
            ptr = GetStrFromOffset(value);
            ReplyString(param,ptr);
            break;
        case SND_PAN_PARAM:
            value = (u32)sndPtr->samplePan;
            ReplyValue(param,value);
            break;
        case SND_VOLUME_PARAM:
            value = (u32)sndPtr->sampleVolume;
            ReplyValue(param,value);
            break;
    }
    printf("Done HandleGetSnd\n");
}

void HandleSetSnd(char *param,char *data,double dvalue)
{
    char            hashName[MAX_HASH_NAME_SIZE];
    ALSymObj        *entry,*target;
    int             paramValue;
    u32             offset,value,newOffset,oldObjOffset;
    ALSound         *sndPtr;

    printf("HandleSetSnd\n");
    value = (u32) dvalue;
    param = parsename(param,hashName);
    entry = MatchHashName(hashName);
    if(!entry)
    {
        fprintf(stderr,"%s: Unknown object name %s\n",gAppName,hashName);
        return;
    }
    paramValue = CheckString(&param,gSoundStrList,MAX_SOUND_STRS);
    sndPtr = (ALSound*)&gMirror[entry->SFObj.bankFileOffset];
    offset = entry->SFObj.bankFileOffset + BANK_RDRAM_ADDR;
    
    switch(paramValue)
    {
        case SND_SAMPLE_PARAM:
            oldObjOffset = (u32)sndPtr->wavetable;
            DecRefCtFromOffset(oldObjOffset);
            target = MatchHashName(data);
            if(!target)
            {
                fprintf(stderr,"%s: Unknown target name %s\n",gAppName,data);
                break;
            }
            target->SFObj.refCount++;
            newOffset = target->SFObj.bankFileOffset;
            sndPtr->wavetable = (ALWaveTable*)newOffset;
            offset = (u32) &((ALSound*)offset)->wavetable;
            newOffset+=BANK_RDRAM_ADDR;
            SetValue(offset,SET_32,newOffset);
            break;
        case SND_KEYMAP_PARAM:
            oldObjOffset = (u32)sndPtr->keyMap;
            DecRefCtFromOffset(oldObjOffset);
            target = MatchHashName(data);
            if(!target)
            {
                fprintf(stderr,"%s: Unknown target name %s\n",gAppName,data);
                break;
            }
            target->SFObj.refCount++;
            newOffset = target->SFObj.bankFileOffset;
            sndPtr->keyMap = (ALKeyMap*)newOffset;
            offset = (u32) &((ALSound*)offset)->keyMap;
            SetValue(offset,SET_32,newOffset+BANK_RDRAM_ADDR);
            break;
        case SND_ENVLP_PARAM:
            oldObjOffset = (u32)sndPtr->envelope;
            DecRefCtFromOffset(oldObjOffset);
            target = MatchHashName(data);
            if(!target)
            {
                fprintf(stderr,"%s: Unknown target name %s\n",gAppName,data);
                break;
            }
            target->SFObj.refCount++;
            newOffset = target->SFObj.bankFileOffset;
            sndPtr->envelope = (ALEnvelope*)newOffset;
            offset = (u32) &((ALSound*)offset)->envelope;
            SetValue(offset,SET_32,newOffset+BANK_RDRAM_ADDR);
            break;
        case SND_PAN_PARAM:
            sndPtr->samplePan = (u8)value;
            offset = (u32) &((ALSound*)offset)->samplePan;
            SetValue(offset,SET_8,value);
            break;
        case SND_VOLUME_PARAM:
            sndPtr->sampleVolume = (u8)value;
            offset = (u32) &((ALSound*)offset)->sampleVolume;
            SetValue(offset,SET_8,value);
            break;
    }
}

void HandleGetEnvlp(char *param)
{
    char            *ptr = param + ENVLP_STR_LEN;
    char            hashName[MAX_HASH_NAME_SIZE];
    ALSymObj        *entry;
    int             paramValue;
    u32             value;
    ALEnvelope      *envlpPtr;
    
    ptr = parsename(ptr,hashName);
    entry = MatchHashName(hashName);
    if(!entry)
    {
        fprintf(stderr,"%s: Unknown object name %s\n",gAppName,hashName);
        return;
    }
    paramValue = CheckString(&ptr,gEnvlpStrList,MAX_ENVLP_STRS);  
    envlpPtr = (ALEnvelope*) &gMirror[entry->SFObj.bankFileOffset];
    
    switch(paramValue)
    {
        case ENVLP_ATTCK_TIME:
            value = (u32)envlpPtr->attackTime;
            break;
        case ENVLP_ATTCK_LVL:
            value = (u32)envlpPtr->attackVolume;
            break;
        case ENVLP_DECAY_TIME:
            value = (u32)envlpPtr->decayTime;
            break;
        case ENVLP_DECAY_LVL:
            value = (u32)envlpPtr->decayVolume;
            break;
        case ENVLP_REL_TIME:
            value = (u32)envlpPtr->releaseTime;
            break;
    }
    ReplyValue(param,value);    
}

void HandleSetEnvlp(char *param,double dvalue)
{
    char            hashName[MAX_HASH_NAME_SIZE];
    ALSymObj        *entry;
    int             paramValue;
    u32             offset,value;
    ALEnvelope      *envlpPtr;
    
    printf("HandleSetEnvlp\n");
    value = (u32)dvalue;
    param = parsename(param,hashName);
    entry = MatchHashName(hashName);
    if(!entry)
    {
        fprintf(stderr,"%s: Unknown object name %s\n",gAppName,hashName);
        return;
    }
    paramValue = CheckString(&param,gEnvlpStrList,MAX_ENVLP_STRS);  
    envlpPtr = (ALEnvelope*)&gMirror[entry->SFObj.bankFileOffset];
    offset = entry->SFObj.bankFileOffset + BANK_RDRAM_ADDR;

    switch(paramValue)
    {
        case ENVLP_ATTCK_TIME:
            envlpPtr->attackTime = value;
            offset =  (u32) &((ALEnvelope*)offset)->attackTime;
            SetValue(offset,SET_32,value);
            break;
        case ENVLP_ATTCK_LVL:
            envlpPtr->attackVolume = (u8)value;
            offset =  (u32) &((ALEnvelope*)offset)->attackVolume;
            SetValue(offset,SET_8,value);            
            break;
        case ENVLP_DECAY_TIME:
            envlpPtr->decayTime = value;
            offset =  (u32) &((ALEnvelope*)offset)->decayTime;
            SetValue(offset,SET_32,value);            
            break;
        case ENVLP_DECAY_LVL:
            envlpPtr->decayVolume = (u8)value;
            offset =  (u32) &((ALEnvelope*)offset)->decayVolume;
            SetValue(offset,SET_8,value);                 
            break;
        case ENVLP_REL_TIME:
            envlpPtr->releaseTime = value;
            offset =  (u32) &((ALEnvelope*)offset)->releaseTime;
            SetValue(offset,SET_32,value);           
            break;
    }
}

void HandleGetKmap(char *param)
{
    char            *ptr = param + KMAP_STR_LEN;
    char            hashName[MAX_HASH_NAME_SIZE];
    ALSymObj        *entry;
    int             paramValue;
    u32             value;
    ALKeyMap        *kmapPtr;
    
    ptr = parsename(ptr,hashName);
    entry = MatchHashName(hashName);
    if(!entry)
    {
        fprintf(stderr,"%s: Unknown object name %s\n",gAppName,hashName);
        return;
    }
    paramValue = CheckString(&ptr,gKmapStrList,MAX_KMAP_STRS);  
    kmapPtr = (ALKeyMap*) &gMirror[entry->SFObj.bankFileOffset];
    
    switch(paramValue)
    {
        case KMAP_VEL_MIN:
            value = (u32)kmapPtr->velocityMin;
            break;
        case KMAP_VEL_MAX:
            value = (u32)kmapPtr->velocityMax;
            break;
        case KMAP_KEY_MIN:
            value = (u32)kmapPtr->keyMin;
            break;
        case KMAP_KEY_MAX:
            value = (u32)kmapPtr->keyMax;
            break;
        case KMAP_KEYBASE:
            value = (u32)kmapPtr->keyBase;
            break;
        case KMAP_DETUNE:
            value = (u32)kmapPtr->detune;
            break;
    }
    ReplyValue(param,value);
}

void HandleSetKmap(char *param,double dvalue)
{
    char            hashName[MAX_HASH_NAME_SIZE];
    ALSymObj        *entry;
    int             paramValue;
    u32             offset,value;
    ALKeyMap        *kmapPtr;
    
    value = (u32)dvalue;
    param = parsename(param,hashName);
    entry = MatchHashName(hashName);
    if(!entry)
    {
        fprintf(stderr,"%s: Unknown object name %s\n",gAppName,hashName);
        return;
    }
    paramValue = CheckString(&param,gKmapStrList,MAX_KMAP_STRS);  
    kmapPtr = (ALKeyMap*)&gMirror[entry->SFObj.bankFileOffset];
    offset = entry->SFObj.bankFileOffset + BANK_RDRAM_ADDR;
    
    switch(paramValue)
    {
        case KMAP_VEL_MIN:
            kmapPtr->velocityMin = (u8)value;
            offset = (u32) &((ALKeyMap*)offset)->velocityMin;
            break;
        case KMAP_VEL_MAX:
            kmapPtr->velocityMax = (u8)value;
            offset = (u32) &((ALKeyMap*)offset)->velocityMax;
            break;
        case KMAP_KEY_MIN:
            kmapPtr->keyMin = (u8)value;
            offset = (u32) &((ALKeyMap*)offset)->keyMin;
            break;
        case KMAP_KEY_MAX:
            kmapPtr->keyMax = (u8)value;
            offset = (u32) &((ALKeyMap*)offset)->keyMax;
            break;
        case KMAP_KEYBASE:
            kmapPtr->keyBase = (u8)value;
            offset = (u32) &((ALKeyMap*)offset)->keyBase;
            break;
        case KMAP_DETUNE:
            kmapPtr->detune = (u8)value;           
            offset = (u32) &((ALKeyMap*)offset)->detune;
            break;
    }
    SetValue(offset,SET_8,value);
}

void SelectBank(char *data)
{
    ALSymObj        *target;
    ALBankFile      *bnkfPtr;
    u32             i,offset;
    int             found = FALSE;
    
    target = MatchHashName(data);
    if(!target)
    {
        fprintf(stderr,"%s: Unknown bank name %s\n",gAppName,data);
        return;
    }

    offset = target->SFObj.bankFileOffset;

    bnkfPtr = (ALBankFile*)gMirror;
    for(i=0;i<bnkfPtr->bankCount;i++)
    {
        if((u32)bnkfPtr->bankArray[i] == offset)
        {
            gCurBank = i;
            found = TRUE;
            break;
        }
    }
    if(found == TRUE)
    {
        offset += BANK_RDRAM_ADDR;
        SendSetBank(offset);
    }
    else
        fprintf(stderr,"%s: Unable to identify bank in bankfile\n",gAppName);

    sleep(3);  /* safety precaution.  if you do some stuff immediately following this, can cause crash */
    
}

void CreateObjectFiles(void)
{
    int     i;
    mode_t  myMode = 0xFFF;
    mode_t  oldMask;
    
    oldMask = umask(0); 
    
    mkdir("/var/tmp/midiDmon",myMode);
    mkdir("/var/tmp/midiDmon/instruments",myMode);
    mkdir("/var/tmp/midiDmon/sounds",myMode);
    mkdir("/var/tmp/midiDmon/keymaps",myMode);
    mkdir("/var/tmp/midiDmon/envelopes",myMode);

    for(i=0; i<gObjCt; i++)
    {
        switch(gSymObj[i].SFObj.objectClass)
        {
            case AL_INST_CLASS:
                CreateInstrumentFile(&gNameBuffer[gSymObj[i].SFObj.stringOffset]);
                break;
            case AL_SOUND_CLASS:
                CreateSoundFile(&gNameBuffer[gSymObj[i].SFObj.stringOffset]);
                break;
            case AL_KEYMAP_CLASS:
                CreateKeymapFile(&gNameBuffer[gSymObj[i].SFObj.stringOffset]);
                break;
            case AL_ENVLP_CLASS:
                CreateEnvelopeFile(&gNameBuffer[gSymObj[i].SFObj.stringOffset]);
                break;
        }
    }

    umask(oldMask);
    printf("Done writing names\n");
}


void CreateInstrumentFile(char *instName)
{
    char    fName[256];
    char    dName[] = {"/var/tmp/midiDmon/instruments/"};
    FILE    *fHandle;
    
    sprintf(fName,"%s%s",dName,instName);
    fHandle = fopen(fName, "w");
    if(!fHandle)
        fprintf(stderr,"Instrument:Failed to open %s for writing preset\n",instName);
    else
    {
        fprintf(fHandle, "#Synth Preset v1.0\n\n");
        fprintf(fHandle, "PRESET\n");
        fprintf(fHandle, "# INFORMATION\n");
        fprintf(fHandle, "Information\n");
        fprintf(fHandle, "\tPresetName:\t\"%s\"\n", instName);
        fclose(fHandle);
    }
}
    
void CreateSoundFile(char *soundName)
{
    char    fName[256];
    char    dName[] = {"/var/tmp/midiDmon/sounds/"};
    FILE    *fHandle;
    
    sprintf(fName,"%s%s",dName,soundName);
    fHandle = fopen(fName, "w");
    if(!fHandle)
        fprintf(stderr,"Sound:Failed to open %s for writing sound\n",soundName);
    else
    {
        fprintf(fHandle, "#Synth Preset v1.0\n\n");
        fprintf(fHandle, "PRESET\n");
        fprintf(fHandle, "# INFORMATION\n");
        fprintf(fHandle, "Information\n");
        fprintf(fHandle, "\tPresetName:\t\"%s\"\n", soundName);
        fclose(fHandle);
    }
}
     
void CreateKeymapFile(char *keyMapName)
{
    char    fName[256];
    char    dName[] = {"/var/tmp/midiDmon/keymaps/"};
    FILE    *fHandle;
    
    sprintf(fName,"%s%s",dName,keyMapName);
    fHandle = fopen(fName, "w");
    if(!fHandle)
        fprintf(stderr,"Keymap:Failed to open %s for writing keymap\n",keyMapName);
    else
    {
        fprintf(fHandle, "#Synth Preset v1.0\n\n");
        fprintf(fHandle, "PRESET\n");
        fprintf(fHandle, "# INFORMATION\n");
        fprintf(fHandle, "Information\n");
        fprintf(fHandle, "\tPresetName:\t\"%s\"\n", keyMapName);
        fclose(fHandle);
    }
}

void CreateEnvelopeFile(char *envlpName)
{
    char    fName[256];
    char    dName[] = {"/var/tmp/midiDmon/envelopes/"};
    FILE    *fHandle;
    
    sprintf(fName,"%s%s",dName,envlpName);
    fHandle = fopen(fName, "w");
    if(!fHandle)
        fprintf(stderr,"Envelope:Failed to open %s for writing envelope\n",envlpName);
    else
    {
        fprintf(fHandle, "#Synth Preset v1.0\n\n");
        fprintf(fHandle, "PRESET\n");
        fprintf(fHandle, "# INFORMATION\n");
        fprintf(fHandle, "Information\n");
        fprintf(fHandle, "\tPresetName:\t\"%s\"\n", envlpName);
        fclose(fHandle);
    }
}
    
#endif /* SYSEX_IMPL */