/*---------------------------------------------------------------------------- * * File: * eas_imelody.c * * Contents and purpose: * iMelody parser * * Copyright Sonic Network Inc. 2005 * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. * *---------------------------------------------------------------------------- * Revision Control: * $Revision: 797 $ * $Date: 2007-08-01 00:15:56 -0700 (Wed, 01 Aug 2007) $ *---------------------------------------------------------------------------- */ /* lint doesn't like the way some string.h files look */ #ifdef _lint #include "lint_stdlib.h" #else #include #endif #include "eas_data.h" #include "eas_miditypes.h" #include "eas_parser.h" #include "eas_report.h" #include "eas_host.h" #include "eas_midi.h" #include "eas_config.h" #include "eas_vm_protos.h" #include "eas_imelodydata.h" #include "eas_ctype.h" // #define _DEBUG_IMELODY /* increase gain for mono ringtones */ #define IMELODY_GAIN_OFFSET 8 /* length of 32nd note in 1/256ths of a msec for 120 BPM tempo */ #define DEFAULT_TICK_CONV 16000 #define TICK_CONVERT 1920000 /* default channel and program for iMelody playback */ #define IMELODY_CHANNEL 0 #define IMELODY_PROGRAM 80 #define IMELODY_VEL_MUL 4 #define IMELODY_VEL_OFS 67 /* multiplier for fixed point triplet conversion */ #define TRIPLET_MULTIPLIER 683 #define TRIPLET_SHIFT 10 static const char* const tokens[] = { "BEGIN:IMELODY", "VERSION:", "FORMAT:CLASS", "NAME:", "COMPOSER:", "BEAT:", "STYLE:", "VOLUME:", "MELODY:", "END:IMELODY" }; /* ledon or ledoff */ static const char ledStr[] = "edo"; /* vibeon or vibeoff */ static const char vibeStr[] = "ibeo"; /* backon or backoff */ static const char backStr[] = "cko"; typedef enum { TOKEN_BEGIN, TOKEN_VERSION, TOKEN_FORMAT, TOKEN_NAME, TOKEN_COMPOSER, TOKEN_BEAT, TOKEN_STYLE, TOKEN_VOLUME, TOKEN_MELODY, TOKEN_END, TOKEN_INVALID } ENUM_IMELODY_TOKENS; /* lookup table for note values */ static const EAS_I8 noteTable[] = { 9, 11, 0, 2, 4, 5, 7 }; /* inline functions */ #ifdef _DEBUG_IMELODY static void PutBackChar (S_IMELODY_DATA *pData) { if (pData->index) pData->index--; { /* dpp: EAS_ReportEx(_EAS_SEVERITY_DETAIL, "PutBackChar '%c'\n", pData->buffer[pData->index]); */ } } #else EAS_INLINE void PutBackChar (S_IMELODY_DATA *pData) { if (pData->index) pData->index--; } #endif /* local prototypes */ static EAS_RESULT IMY_CheckFileType (S_EAS_DATA *pEASData, EAS_FILE_HANDLE fileHandle, EAS_VOID_PTR *ppHandle, EAS_I32 offset); static EAS_RESULT IMY_Prepare (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData); static EAS_RESULT IMY_Time (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData, EAS_U32 *pTime); static EAS_RESULT IMY_Event (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData, EAS_INT parserMode); static EAS_RESULT IMY_State (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData, EAS_STATE *pState); static EAS_RESULT IMY_Close (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData); static EAS_RESULT IMY_Reset (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData); static EAS_RESULT IMY_Pause (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData); static EAS_RESULT IMY_Resume (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData); static EAS_RESULT IMY_SetData (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData, EAS_I32 param, EAS_I32 value); static EAS_RESULT IMY_GetData (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData, EAS_I32 param, EAS_I32 *pValue); static EAS_BOOL IMY_PlayNote (S_EAS_DATA *pEASData, S_IMELODY_DATA *pData, EAS_I8 note, EAS_INT parserMode); static EAS_BOOL IMY_PlayRest (S_EAS_DATA *pEASData, S_IMELODY_DATA *pData); static EAS_BOOL IMY_GetDuration (EAS_HW_DATA_HANDLE hwInstData, S_IMELODY_DATA *pData, EAS_I32 *pDuration); static EAS_BOOL IMY_GetLEDState (S_EAS_DATA *pEASData, S_IMELODY_DATA *pData); static EAS_BOOL IMY_GetVibeState (S_EAS_DATA *pEASData, S_IMELODY_DATA *pData); static EAS_BOOL IMY_GetBackState (S_EAS_DATA *pEASData, S_IMELODY_DATA *pData); static EAS_BOOL IMY_GetVolume (EAS_HW_DATA_HANDLE hwInstData, S_IMELODY_DATA *pData, EAS_BOOL inHeader); static EAS_BOOL IMY_GetNumber (EAS_HW_DATA_HANDLE hwInstData, S_IMELODY_DATA *pData, EAS_INT *temp, EAS_BOOL inHeader); static EAS_RESULT IMY_ParseHeader (S_EAS_DATA *pEASData, S_IMELODY_DATA* pData); static EAS_I8 IMY_GetNextChar (EAS_HW_DATA_HANDLE hwInstData, S_IMELODY_DATA *pData, EAS_BOOL inHeader); static EAS_RESULT IMY_ReadLine (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE fileHandle, EAS_I8 *buffer, EAS_I32 *pStartLine); static EAS_INT IMY_ParseLine (EAS_I8 *buffer, EAS_U8 *pIndex); /*---------------------------------------------------------------------------- * * EAS_iMelody_Parser * * This structure contains the functional interface for the iMelody parser *---------------------------------------------------------------------------- */ const S_FILE_PARSER_INTERFACE EAS_iMelody_Parser = { IMY_CheckFileType, IMY_Prepare, IMY_Time, IMY_Event, IMY_State, IMY_Close, IMY_Reset, #ifdef JET_INTERFACE IMY_Pause, IMY_Resume, #else NULL, NULL, #endif NULL, IMY_SetData, IMY_GetData, NULL }; /*---------------------------------------------------------------------------- * IMY_CheckFileType() *---------------------------------------------------------------------------- * Purpose: * Check the file type to see if we can parse it * * Inputs: * pEASData - pointer to overall EAS data structure * handle - pointer to file handle * * Outputs: * * * Side Effects: * *---------------------------------------------------------------------------- */ static EAS_RESULT IMY_CheckFileType (S_EAS_DATA *pEASData, EAS_FILE_HANDLE fileHandle, EAS_VOID_PTR *ppHandle, EAS_I32 offset) { S_IMELODY_DATA* pData; EAS_I8 buffer[MAX_LINE_SIZE+1]; EAS_U8 index; #ifdef _DEBUG_IMELODY { /* dpp: EAS_ReportEx(_EAS_SEVERITY_DETAIL, "Enter IMY_CheckFileType\n"); */ } #endif /* read the first line of the file */ *ppHandle = NULL; if (IMY_ReadLine(pEASData->hwInstData, fileHandle, buffer, NULL) != EAS_SUCCESS) return EAS_SUCCESS; /* check for header string */ if (IMY_ParseLine(buffer, &index) == TOKEN_BEGIN) { /* check for static memory allocation */ if (pEASData->staticMemoryModel) pData = EAS_CMEnumData(EAS_CM_IMELODY_DATA); else pData = EAS_HWMalloc(pEASData->hwInstData, sizeof(S_IMELODY_DATA)); if (!pData) return EAS_ERROR_MALLOC_FAILED; EAS_HWMemSet(pData, 0, sizeof(S_IMELODY_DATA)); /* initialize */ pData->fileHandle = fileHandle; pData->fileOffset = offset; pData->state = EAS_STATE_ERROR; pData->state = EAS_STATE_OPEN; /* return a pointer to the instance data */ *ppHandle = pData; } return EAS_SUCCESS; } /*---------------------------------------------------------------------------- * IMY_Prepare() *---------------------------------------------------------------------------- * Purpose: * Prepare to parse the file. Allocates instance data (or uses static allocation for * static memory model). * * Inputs: * pEASData - pointer to overall EAS data structure * handle - pointer to file handle * * Outputs: * * * Side Effects: * *---------------------------------------------------------------------------- */ static EAS_RESULT IMY_Prepare (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData) { S_IMELODY_DATA* pData; EAS_RESULT result; #ifdef _DEBUG_IMELODY { /* dpp: EAS_ReportEx(_EAS_SEVERITY_DETAIL, "Enter IMY_Prepare\n"); */ } #endif /* check for valid state */ pData = (S_IMELODY_DATA*) pInstData; if (pData->state != EAS_STATE_OPEN) return EAS_ERROR_NOT_VALID_IN_THIS_STATE; /* instantiate a synthesizer */ if ((result = VMInitMIDI(pEASData, &pData->pSynth)) != EAS_SUCCESS) { { /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "VMInitMIDI returned %d\n", result); */ } return result; } /* parse the header */ if ((result = IMY_ParseHeader(pEASData, pData)) != EAS_SUCCESS) return result; #ifdef _DEBUG_IMELODY { /* dpp: EAS_ReportEx(_EAS_SEVERITY_DETAIL, "IMY_Prepare: state set to EAS_STATE_READY\n"); */ } #endif pData ->state = EAS_STATE_READY; return EAS_SUCCESS; } /*---------------------------------------------------------------------------- * IMY_Time() *---------------------------------------------------------------------------- * Purpose: * Returns the time of the next event in msecs * * Inputs: * pEASData - pointer to overall EAS data structure * handle - pointer to file handle * pTime - pointer to variable to hold time of next event (in msecs) * * Outputs: * * * Side Effects: * *---------------------------------------------------------------------------- */ /*lint -esym(715, pEASData) common decoder interface - pEASData not used */ static EAS_RESULT IMY_Time (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData, EAS_U32 *pTime) { S_IMELODY_DATA *pData; pData = (S_IMELODY_DATA*) pInstData; /* return time in milliseconds */ /*lint -e{704} use shift instead of division */ *pTime = pData->time >> 8; return EAS_SUCCESS; } /*---------------------------------------------------------------------------- * IMY_Event() *---------------------------------------------------------------------------- * Purpose: * Parse the next event in the file * * Inputs: * pEASData - pointer to overall EAS data structure * handle - pointer to file handle * * Outputs: * * * Side Effects: * *---------------------------------------------------------------------------- */ static EAS_RESULT IMY_Event (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData, EAS_INT parserMode) { S_IMELODY_DATA* pData; EAS_RESULT result; EAS_I8 c; EAS_BOOL eof; EAS_INT temp; pData = (S_IMELODY_DATA*) pInstData; if (pData->state >= EAS_STATE_OPEN) return EAS_SUCCESS; if (pData->state == EAS_STATE_READY) { pData->state = EAS_STATE_PLAY; } /* initialize MIDI channel when the track starts playing */ if (pData->time == 0) { #ifdef _DEBUG_IMELODY { /* dpp: EAS_ReportEx(_EAS_SEVERITY_DETAIL, "IMY_Event: Reset\n"); */ } #endif /* set program to square lead */ VMProgramChange(pEASData->pVoiceMgr, pData->pSynth, IMELODY_CHANNEL, IMELODY_PROGRAM); /* set channel volume to max */ VMControlChange(pEASData->pVoiceMgr, pData->pSynth, IMELODY_CHANNEL, 7, 127); } /* check for end of note */ if (pData->note) { #ifdef _DEBUG_IMELODY { /* dpp: EAS_ReportEx(_EAS_SEVERITY_DETAIL, "Stopping note %d\n", pData->note); */ } #endif /* stop the note */ VMStopNote(pEASData->pVoiceMgr, pData->pSynth, IMELODY_CHANNEL, pData->note, 0); pData->note = 0; /* check for rest between notes */ if (pData->restTicks) { pData->time += pData->restTicks; pData->restTicks = 0; return EAS_SUCCESS; } } /* parse the next event */ eof = EAS_FALSE; while (!eof) { /* get next character */ c = IMY_GetNextChar(pEASData->hwInstData, pData, EAS_FALSE); switch (c) { /* start repeat */ case '(': #ifdef _DEBUG_IMELODY { /* dpp: EAS_ReportEx(_EAS_SEVERITY_DETAIL, "Enter repeat section\n", c); */ } #endif if (pData->repeatOffset < 0) { pData->repeatOffset = pData->startLine + (EAS_I32) pData->index; /* save current time and check it later to make sure the loop isn't zero length */ pData->repeatTime = pData->time; #ifdef _DEBUG_IMELODY { /* dpp: EAS_ReportEx(_EAS_SEVERITY_DETAIL, "Repeat offset = %d\n", pData->repeatOffset); */ } #endif } else { /* dpp: EAS_ReportEx(_EAS_SEVERITY_WARNING, "Ignoring nested repeat section\n"); */ } break; /* end repeat */ case ')': #ifdef _DEBUG_IMELODY { /* dpp: EAS_ReportEx(_EAS_SEVERITY_DETAIL, "End repeat section, repeat offset = %d\n", pData->repeatOffset); */ } #endif /* ignore zero-length loops */ if (pData->repeatTime == pData->time) { pData->repeatCount = -1; pData->repeatOffset = -1; } else if (pData->repeatCount >= 0) { /* decrement repeat count (repeatCount == 0 means infinite loop) */ if (pData->repeatCount > 0) { if (--pData->repeatCount == 0) { pData->repeatCount = -1; #ifdef _DEBUG_IMELODY { /* dpp: EAS_ReportEx(_EAS_SEVERITY_DETAIL, "Repeat loop complete\n"); */ } #endif } } //2 TEMPORARY FIX: If locating, don't do infinite loops. //3 We need a different mode for metadata parsing where we don't loop at all if ((parserMode == eParserModePlay) || (pData->repeatCount != 0)) { #ifdef _DEBUG_IMELODY { /* dpp: EAS_ReportEx(_EAS_SEVERITY_DETAIL, "Rewinding file for repeat\n"); */ } #endif /* rewind to start of loop */ if ((result = EAS_HWFileSeek(pEASData->hwInstData, pData->fileHandle, pData->repeatOffset)) != EAS_SUCCESS) return result; IMY_ReadLine(pEASData->hwInstData, pData->fileHandle, pData->buffer, &pData->startLine); pData->index = 0; /* if last loop, prevent future loops */ if (pData->repeatCount == -1) pData->repeatOffset = -1; } } break; /* repeat count */ case '@': if (!IMY_GetNumber(pEASData->hwInstData, pData, &temp, EAS_FALSE)) eof = EAS_TRUE; else if (pData->repeatOffset > 0) { #ifdef _DEBUG_IMELODY { /* dpp: EAS_ReportEx(_EAS_SEVERITY_DETAIL, "Repeat count = %dt", pData->repeatCount); */ } #endif if (pData->repeatCount < 0) pData->repeatCount = (EAS_I16) temp; } break; /* volume */ case 'V': if (!IMY_GetVolume(pEASData->hwInstData, pData, EAS_FALSE)) eof = EAS_TRUE; break; /* flat */ case '&': pData->noteModifier = -1; break; /* sharp */ case '#': pData->noteModifier = +1; break; /* octave */ case '*': c = IMY_GetNextChar(pEASData->hwInstData, pData, EAS_FALSE); if (IsDigit(c)) pData->octave = (EAS_U8) ((c - '0' + 1) * 12); else if (!c) eof = EAS_TRUE; break; /* ledon or ledoff */ case 'l': if (!IMY_GetLEDState(pEASData, pData)) eof = EAS_TRUE; break; /* vibeon or vibeoff */ case 'v': if (!IMY_GetVibeState(pEASData, pData)) eof = EAS_TRUE; break; /* either a B note or backon or backoff */ case 'b': if (IMY_GetNextChar(pEASData->hwInstData, pData, EAS_FALSE) == 'a') { if (!IMY_GetBackState(pEASData, pData)) eof = EAS_TRUE; } else { PutBackChar(pData); if (IMY_PlayNote(pEASData, pData, c, parserMode)) return EAS_SUCCESS; eof = EAS_TRUE; } break; /* rest */ case 'r': case 'R': if (IMY_PlayRest(pEASData, pData)) return EAS_SUCCESS; eof = EAS_TRUE; break; /* EOF */ case 0: #ifdef _DEBUG_IMELODY { /* dpp: EAS_ReportEx(_EAS_SEVERITY_DETAIL, "IMY_Event: end of iMelody file detected\n"); */ } #endif eof = EAS_TRUE; break; /* must be a note */ default: c = ToLower(c); if ((c >= 'a') && (c <= 'g')) { if (IMY_PlayNote(pEASData, pData, c, parserMode)) return EAS_SUCCESS; eof = EAS_TRUE; } else { /* dpp: EAS_ReportEx(_EAS_SEVERITY_WARNING, "Ignoring unexpected character '%c' [0x%02x]\n", c, c); */ } break; } } /* handle EOF */ #ifdef _DEBUG_IMELODY { /* dpp: EAS_ReportEx(_EAS_SEVERITY_DETAIL, "IMY_Event: state set to EAS_STATE_STOPPING\n"); */ } #endif pData->state = EAS_STATE_STOPPING; VMReleaseAllVoices(pEASData->pVoiceMgr, pData->pSynth); return EAS_SUCCESS; } /*---------------------------------------------------------------------------- * IMY_State() *---------------------------------------------------------------------------- * Purpose: * Returns the current state of the stream * * Inputs: * pEASData - pointer to overall EAS data structure * handle - pointer to file handle * pState - pointer to variable to store state * * Outputs: * * * Side Effects: * *---------------------------------------------------------------------------- */ /*lint -esym(715, pEASData) common decoder interface - pEASData not used */ static EAS_RESULT IMY_State (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData, EAS_I32 *pState) { S_IMELODY_DATA* pData; /* establish pointer to instance data */ pData = (S_IMELODY_DATA*) pInstData; /* if stopping, check to see if synth voices are active */ if (pData->state == EAS_STATE_STOPPING) { if (VMActiveVoices(pData->pSynth) == 0) { pData->state = EAS_STATE_STOPPED; #ifdef _DEBUG_IMELODY { /* dpp: EAS_ReportEx(_EAS_SEVERITY_DETAIL, "IMY_State: state set to EAS_STATE_STOPPED\n"); */ } #endif } } if (pData->state == EAS_STATE_PAUSING) { if (VMActiveVoices(pData->pSynth) == 0) { #ifdef _DEBUG_IMELODY { /* dpp: EAS_ReportEx(_EAS_SEVERITY_DETAIL, "IMY_State: state set to EAS_STATE_PAUSED\n"); */ } #endif pData->state = EAS_STATE_PAUSED; } } /* return current state */ *pState = pData->state; return EAS_SUCCESS; } /*---------------------------------------------------------------------------- * IMY_Close() *---------------------------------------------------------------------------- * Purpose: * Close the file and clean up * * Inputs: * pEASData - pointer to overall EAS data structure * handle - pointer to file handle * * Outputs: * * * Side Effects: * *---------------------------------------------------------------------------- */ static EAS_RESULT IMY_Close (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData) { S_IMELODY_DATA* pData; EAS_RESULT result; #ifdef _DEBUG_IMELODY { /* dpp: EAS_ReportEx(_EAS_SEVERITY_DETAIL, "IMY_Close: close file\n"); */ } #endif pData = (S_IMELODY_DATA*) pInstData; /* close the file */ if ((result = EAS_HWCloseFile(pEASData->hwInstData, pData->fileHandle)) != EAS_SUCCESS) return result; /* free the synth */ if (pData->pSynth != NULL) VMMIDIShutdown(pEASData, pData->pSynth); /* if using dynamic memory, free it */ if (!pEASData->staticMemoryModel) EAS_HWFree(pEASData->hwInstData, pData); return EAS_SUCCESS; } /*---------------------------------------------------------------------------- * IMY_Reset() *---------------------------------------------------------------------------- * Purpose: * Reset the sequencer. Used for locating backwards in the file. * * Inputs: * pEASData - pointer to overall EAS data structure * handle - pointer to file handle * * Outputs: * * * Side Effects: * *---------------------------------------------------------------------------- */ static EAS_RESULT IMY_Reset (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData) { S_IMELODY_DATA* pData; EAS_RESULT result; #ifdef _DEBUG_IMELODY { /* dpp: EAS_ReportEx(_EAS_SEVERITY_DETAIL, "IMY_Reset: reset file\n"); */ } #endif pData = (S_IMELODY_DATA*) pInstData; /* reset the synth */ VMReset(pEASData->pVoiceMgr, pData->pSynth, EAS_TRUE); /* reset time to zero */ pData->time = 0; pData->note = 0; /* reset file position and re-parse header */ pData->state = EAS_STATE_ERROR; if ((result = EAS_HWFileSeek(pEASData->hwInstData, pData->fileHandle, pData->fileOffset)) != EAS_SUCCESS) return result; if ((result = IMY_ParseHeader (pEASData, pData)) != EAS_SUCCESS) return result; #ifdef _DEBUG_IMELODY { /* dpp: EAS_ReportEx(_EAS_SEVERITY_DETAIL, "IMY_Reset: state set to EAS_STATE_ERROR\n"); */ } #endif pData->state = EAS_STATE_READY; return EAS_SUCCESS; } #ifdef JET_INTERFACE /*---------------------------------------------------------------------------- * IMY_Pause() *---------------------------------------------------------------------------- * Purpose: * Pauses the sequencer. Mutes all voices and sets state to pause. * * Inputs: * pEASData - pointer to overall EAS data structure * handle - pointer to file handle * * Outputs: * * * Side Effects: * *---------------------------------------------------------------------------- */ static EAS_RESULT IMY_Pause (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData) { S_IMELODY_DATA *pData; #ifdef _DEBUG_IMELODY { /* dpp: EAS_ReportEx(_EAS_SEVERITY_DETAIL, "IMY_Pause: pause file\n"); */ } #endif /* can't pause a stopped stream */ pData = (S_IMELODY_DATA*) pInstData; if (pData->state == EAS_STATE_STOPPED) return EAS_ERROR_ALREADY_STOPPED; /* mute the synthesizer */ VMMuteAllVoices(pEASData->pVoiceMgr, pData->pSynth); pData->state = EAS_STATE_PAUSING; return EAS_SUCCESS; } /*---------------------------------------------------------------------------- * IMY_Resume() *---------------------------------------------------------------------------- * Purpose: * Resume playing after a pause, sets state back to playing. * * Inputs: * pEASData - pointer to overall EAS data structure * handle - pointer to file handle * * Outputs: * * * Side Effects: * *---------------------------------------------------------------------------- */ /*lint -esym(715, pEASData) common decoder interface - pEASData not used */ static EAS_RESULT IMY_Resume (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData) { S_IMELODY_DATA *pData; #ifdef _DEBUG_IMELODY { /* dpp: EAS_ReportEx(_EAS_SEVERITY_DETAIL, "IMY_Resume: resume file\n"); */ } #endif /* can't resume a stopped stream */ pData = (S_IMELODY_DATA*) pInstData; if (pData->state == EAS_STATE_STOPPED) return EAS_ERROR_ALREADY_STOPPED; /* nothing to do but resume playback */ pData->state = EAS_STATE_PLAY; return EAS_SUCCESS; } #endif /*---------------------------------------------------------------------------- * IMY_SetData() *---------------------------------------------------------------------------- * Purpose: * Adjust tempo relative to song tempo * * Inputs: * pEASData - pointer to overall EAS data structure * pInstData - pointer to iMelody instance data * rate - rate (28-bit fractional amount) * * Outputs: * * * Side Effects: * *---------------------------------------------------------------------------- */ /*lint -esym(715, pEASData) common decoder interface - pEASData not used */ static EAS_RESULT IMY_SetData (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData, EAS_I32 param, EAS_I32 value) { S_IMELODY_DATA *pData; pData = (S_IMELODY_DATA*) pInstData; switch (param) { /* set metadata callback */ case PARSER_DATA_METADATA_CB: EAS_HWMemCpy(&pData->metadata, (void*) value, sizeof(S_METADATA_CB)); break; default: return EAS_ERROR_INVALID_PARAMETER; } return EAS_SUCCESS; } /*---------------------------------------------------------------------------- * IMY_GetData() *---------------------------------------------------------------------------- * Purpose: * Return the file type * * Inputs: * pEASData - pointer to overall EAS data structure * pInstData - pointer to iMelody instance data * * Outputs: * * * Side Effects: * *---------------------------------------------------------------------------- */ /*lint -esym(715, pEASData) common decoder interface - pEASData not used */ static EAS_RESULT IMY_GetData (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData, EAS_I32 param, EAS_I32 *pValue) { S_IMELODY_DATA *pData; pData = (S_IMELODY_DATA*) pInstData; switch (param) { /* return file type as iMelody */ case PARSER_DATA_FILE_TYPE: *pValue = EAS_FILE_IMELODY; break; case PARSER_DATA_SYNTH_HANDLE: *pValue = (EAS_I32) pData->pSynth; break; case PARSER_DATA_GAIN_OFFSET: *pValue = IMELODY_GAIN_OFFSET; break; default: return EAS_ERROR_INVALID_PARAMETER; } return EAS_SUCCESS; } /*---------------------------------------------------------------------------- * IMY_PlayNote() *---------------------------------------------------------------------------- * Purpose: * * * Inputs: * * * Outputs: * * * Side Effects: * *---------------------------------------------------------------------------- */ static EAS_BOOL IMY_PlayNote (S_EAS_DATA *pEASData, S_IMELODY_DATA *pData, EAS_I8 note, EAS_INT parserMode) { EAS_I32 duration; EAS_U8 velocity; #ifdef _DEBUG_IMELODY { /* dpp: EAS_ReportEx(_EAS_SEVERITY_DETAIL, "IMY_PlayNote: start note %d\n", note); */ } #endif /* get the duration */ if (!IMY_GetDuration(pEASData->hwInstData, pData, &duration)) return EAS_FALSE; /* save note value */ pData->note = (EAS_U8) (pData->octave + noteTable[note - 'a'] + pData->noteModifier); velocity = (EAS_U8) (pData->volume ? pData->volume * IMELODY_VEL_MUL + IMELODY_VEL_OFS : 0); /* start note only if in play mode */ if (parserMode == eParserModePlay) VMStartNote(pEASData->pVoiceMgr, pData->pSynth, IMELODY_CHANNEL, pData->note, velocity); #ifdef _DEBUG_IMELODY { /* dpp: EAS_ReportEx(_EAS_SEVERITY_DETAIL, "IMY_PlayNote: Start note %d, duration %d\n", pData->note, duration); */ } #endif /* determine note length */ switch (pData->style) { case 0: /*lint -e{704} shift for performance */ pData->restTicks = duration >> 4; break; case 1: pData->restTicks = 0; break; case 2: /*lint -e{704} shift for performance */ pData->restTicks = duration >> 1; break; default: { /* dpp: EAS_ReportEx(_EAS_SEVERITY_WARNING, "IMY_PlayNote: Note style out of range: %d\n", pData->style); */ } /*lint -e{704} shift for performance */ pData->restTicks = duration >> 4; break; } /* next event is at end of this note */ pData->time += duration - pData->restTicks; /* reset the flat/sharp modifier */ pData->noteModifier = 0; return EAS_TRUE; } /*---------------------------------------------------------------------------- * IMY_PlayRest() *---------------------------------------------------------------------------- * Purpose: * * * Inputs: * * * Outputs: * * * Side Effects: * *---------------------------------------------------------------------------- */ static EAS_BOOL IMY_PlayRest (S_EAS_DATA *pEASData, S_IMELODY_DATA *pData) { EAS_I32 duration; #ifdef _DEBUG_IMELODY { /* dpp: EAS_ReportEx(_EAS_SEVERITY_DETAIL, "Enter IMY_PlayRest]n"); */ } #endif /* get the duration */ if (!IMY_GetDuration(pEASData->hwInstData, pData, &duration)) return EAS_FALSE; #ifdef _DEBUG_IMELODY { /* dpp: EAS_ReportEx(_EAS_SEVERITY_DETAIL, "IMY_PlayRest: note duration %d\n", duration); */ } #endif /* next event is at end of this note */ pData->time += duration; return EAS_TRUE; } /*---------------------------------------------------------------------------- * IMY_GetDuration() *---------------------------------------------------------------------------- * Purpose: * * * Inputs: * * * Outputs: * * * Side Effects: * *---------------------------------------------------------------------------- */ static EAS_BOOL IMY_GetDuration (EAS_HW_DATA_HANDLE hwInstData, S_IMELODY_DATA *pData, EAS_I32 *pDuration) { EAS_I32 duration; EAS_I8 c; /* get the duration */ *pDuration = 0; c = IMY_GetNextChar(hwInstData, pData, EAS_FALSE); if (!c) return EAS_FALSE; if ((c < '0') || (c > '5')) { #ifdef _DEBUG_IMELODY { /* dpp: EAS_ReportEx(_EAS_SEVERITY_DETAIL, "IMY_GetDuration: error in duration '%c'\n", c); */ } #endif return EAS_FALSE; } /* calculate total length of note */ duration = pData->tick * (1 << ('5' - c)); /* check for duration modifier */ c = IMY_GetNextChar(hwInstData, pData, EAS_FALSE); if (c) { if (c == '.') /*lint -e{704} shift for performance */ duration += duration >> 1; else if (c == ':') /*lint -e{704} shift for performance */ duration += (duration >> 1) + (duration >> 2); else if (c == ';') /*lint -e{704} shift for performance */ duration = (duration * TRIPLET_MULTIPLIER) >> TRIPLET_SHIFT; else PutBackChar(pData); } *pDuration = duration; return EAS_TRUE; } /*---------------------------------------------------------------------------- * IMY_GetLEDState() *---------------------------------------------------------------------------- * Purpose: * * * Inputs: * * * Outputs: * * * Side Effects: * *---------------------------------------------------------------------------- */ static EAS_BOOL IMY_GetLEDState (S_EAS_DATA *pEASData, S_IMELODY_DATA *pData) { EAS_I8 c; EAS_INT i; #ifdef _DEBUG_IMELODY { /* dpp: EAS_ReportEx(_EAS_SEVERITY_DETAIL, "Enter IMY_GetLEDState\n"); */ } #endif for (i = 0; i < 5; i++) { c = IMY_GetNextChar(pEASData->hwInstData, pData, EAS_FALSE); if (!c) return EAS_FALSE; switch (i) { case 3: if (c == 'n') { #ifdef _DEBUG_IMELODY { /* dpp: EAS_ReportEx(_EAS_SEVERITY_DETAIL, "IMY_GetLEDState: LED on\n"); */ } #endif EAS_HWLED(pEASData->hwInstData, EAS_TRUE); return EAS_TRUE; } else if (c != 'f') return EAS_FALSE; break; case 4: if (c == 'f') { #ifdef _DEBUG_IMELODY { /* dpp: EAS_ReportEx(_EAS_SEVERITY_DETAIL, "IMY_GetLEDState: LED off\n"); */ } #endif EAS_HWLED(pEASData->hwInstData, EAS_FALSE); return EAS_TRUE; } return EAS_FALSE; default: if (c != ledStr[i]) return EAS_FALSE; break; } } return EAS_FALSE; } /*---------------------------------------------------------------------------- * IMY_GetVibeState() *---------------------------------------------------------------------------- * Purpose: * * * Inputs: * * * Outputs: * * * Side Effects: * *---------------------------------------------------------------------------- */ static EAS_BOOL IMY_GetVibeState (S_EAS_DATA *pEASData, S_IMELODY_DATA *pData) { EAS_I8 c; EAS_INT i; #ifdef _DEBUG_IMELODY { /* dpp: EAS_ReportEx(_EAS_SEVERITY_DETAIL, "Enter IMY_GetVibeState\n"); */ } #endif for (i = 0; i < 6; i++) { c = IMY_GetNextChar(pEASData->hwInstData, pData, EAS_FALSE); if (!c) return EAS_FALSE; switch (i) { case 4: if (c == 'n') { #ifdef _DEBUG_IMELODY { /* dpp: EAS_ReportEx(_EAS_SEVERITY_DETAIL, "IMY_GetVibeState: vibrate on\n"); */ } #endif EAS_HWVibrate(pEASData->hwInstData, EAS_TRUE); return EAS_TRUE; } else if (c != 'f') return EAS_FALSE; break; case 5: if (c == 'f') { #ifdef _DEBUG_IMELODY { /* dpp: EAS_ReportEx(_EAS_SEVERITY_DETAIL, "IMY_GetVibeState: vibrate off\n"); */ } #endif EAS_HWVibrate(pEASData->hwInstData, EAS_FALSE); return EAS_TRUE; } return EAS_FALSE; default: if (c != vibeStr[i]) return EAS_FALSE; break; } } return EAS_FALSE; } /*---------------------------------------------------------------------------- * IMY_GetBackState() *---------------------------------------------------------------------------- * Purpose: * * * Inputs: * * * Outputs: * * * Side Effects: * *---------------------------------------------------------------------------- */ static EAS_BOOL IMY_GetBackState (S_EAS_DATA *pEASData, S_IMELODY_DATA *pData) { EAS_I8 c; EAS_INT i; #ifdef _DEBUG_IMELODY { /* dpp: EAS_ReportEx(_EAS_SEVERITY_DETAIL, "Enter IMY_GetBackState\n"); */ } #endif for (i = 0; i < 5; i++) { c = IMY_GetNextChar(pEASData->hwInstData, pData, EAS_FALSE); if (!c) return EAS_FALSE; switch (i) { case 3: if (c == 'n') { #ifdef _DEBUG_IMELODY { /* dpp: EAS_ReportEx(_EAS_SEVERITY_DETAIL, "IMY_GetBackState: backlight on\n"); */ } #endif EAS_HWBackLight(pEASData->hwInstData, EAS_TRUE); return EAS_TRUE; } else if (c != 'f') return EAS_FALSE; break; case 4: if (c == 'f') { #ifdef _DEBUG_IMELODY { /* dpp: EAS_ReportEx(_EAS_SEVERITY_DETAIL, "IMY_GetBackState: backlight off\n"); */ } #endif EAS_HWBackLight(pEASData->hwInstData, EAS_FALSE); return EAS_TRUE; } return EAS_FALSE; default: if (c != backStr[i]) return EAS_FALSE; break; } } return EAS_FALSE; } /*---------------------------------------------------------------------------- * IMY_GetVolume() *---------------------------------------------------------------------------- * Purpose: * * * Inputs: * * * Outputs: * * * Side Effects: * *---------------------------------------------------------------------------- */ static EAS_BOOL IMY_GetVolume (EAS_HW_DATA_HANDLE hwInstData, S_IMELODY_DATA *pData, EAS_BOOL inHeader) { EAS_INT temp; EAS_I8 c; #ifdef _DEBUG_IMELODY { /* dpp: EAS_ReportEx(_EAS_SEVERITY_DETAIL, "Enter IMY_GetVolume\n"); */ } #endif c = IMY_GetNextChar(hwInstData, pData, inHeader); if (c == '+') { if (pData->volume < 15) pData->volume++; return EAS_TRUE; } else if (c == '-') { if (pData->volume > 0) pData->volume--; return EAS_TRUE; } else if (IsDigit(c)) temp = c - '0'; else return EAS_FALSE; c = IMY_GetNextChar(hwInstData, pData, inHeader); if (IsDigit(c)) temp = temp * 10 + c - '0'; else if (c) PutBackChar(pData); if ((temp >= 0) && (temp <= 15)) { if (inHeader && (temp == 0)) { /* dpp: EAS_ReportEx(_EAS_SEVERITY_WARNING, "Ignoring V0 encountered in header\n"); */ } else pData->volume = (EAS_U8) temp; } return EAS_TRUE; } /*---------------------------------------------------------------------------- * IMY_GetNumber() *---------------------------------------------------------------------------- * Purpose: * * * Inputs: * * * Outputs: * * * Side Effects: * *---------------------------------------------------------------------------- */ static EAS_BOOL IMY_GetNumber (EAS_HW_DATA_HANDLE hwInstData, S_IMELODY_DATA *pData, EAS_INT *temp, EAS_BOOL inHeader) { EAS_BOOL ok; EAS_I8 c; #ifdef _DEBUG_IMELODY { /* dpp: EAS_ReportEx(_EAS_SEVERITY_DETAIL, "Enter IMY_GetNumber\n"); */ } #endif *temp = 0; ok = EAS_FALSE; for (;;) { c = IMY_GetNextChar(hwInstData, pData, inHeader); if (IsDigit(c)) { *temp = *temp * 10 + c - '0'; ok = EAS_TRUE; } else { if (c) PutBackChar(pData); #ifdef _DEBUG_IMELODY { /* dpp: EAS_ReportEx(_EAS_SEVERITY_DETAIL, "IMY_GetNumber: value %d\n", *temp); */ } #endif return ok; } } } /*---------------------------------------------------------------------------- * IMY_GetVersion() *---------------------------------------------------------------------------- * Purpose: * * * Inputs: * * * Outputs: * * * Side Effects: * *---------------------------------------------------------------------------- */ static EAS_BOOL IMY_GetVersion (S_IMELODY_DATA *pData, EAS_INT *pVersion) { EAS_I8 c; EAS_INT temp; EAS_INT version; version = temp = 0; for (;;) { c = pData->buffer[pData->index++]; if ((c == 0) || (c == '.')) { /*lint -e{701} use shift for performance */ version = (version << 8) + temp; if (c == 0) { #ifdef _DEBUG_IMELODY { /* dpp: EAS_ReportEx(_EAS_SEVERITY_DETAIL, "IMY_GetVersion: version 0x%04x\n", version); */ } #endif *pVersion = version; return EAS_TRUE; } temp = 0; } else if (IsDigit(c)) temp = (temp * 10) + c - '0'; } } /*---------------------------------------------------------------------------- * IMY_MetaData() *---------------------------------------------------------------------------- * Purpose: * Prepare to parse the file. Allocates instance data (or uses static allocation for * static memory model). * * Inputs: * pEASData - pointer to overall EAS data structure * handle - pointer to file handle * * Outputs: * * * Side Effects: * *---------------------------------------------------------------------------- */ static void IMY_MetaData (S_IMELODY_DATA *pData, E_EAS_METADATA_TYPE metaType, EAS_I8 *buffer) { EAS_I32 len; /* check for callback */ if (!pData->metadata.callback) return; /* copy data to host buffer */ len = (EAS_I32) strlen((char*) buffer); if (len >pData->metadata.bufferSize) len = pData->metadata.bufferSize; strncpy((char*) pData->metadata.buffer, (char*) buffer, (size_t) len); pData->metadata.buffer[len] = 0; /* callback to host */ pData->metadata.callback(metaType, pData->metadata.buffer, pData->metadata.pUserData); } /*---------------------------------------------------------------------------- * IMY_ParseHeader() *---------------------------------------------------------------------------- * Purpose: * Prepare to parse the file. Allocates instance data (or uses static allocation for * static memory model). * * Inputs: * pEASData - pointer to overall EAS data structure * handle - pointer to file handle * * Outputs: * * * Side Effects: * *---------------------------------------------------------------------------- */ static EAS_RESULT IMY_ParseHeader (S_EAS_DATA *pEASData, S_IMELODY_DATA* pData) { EAS_RESULT result; EAS_INT token; EAS_INT temp; EAS_I8 c; #ifdef _DEBUG_IMELODY { /* dpp: EAS_ReportEx(_EAS_SEVERITY_DETAIL, "Enter IMY_ParseHeader\n"); */ } #endif /* initialize some defaults */ pData->time = 0; pData->tick = DEFAULT_TICK_CONV; pData->note = 0; pData->noteModifier = 0; pData ->restTicks = 0; pData->volume = 7; pData->octave = 60; pData->repeatOffset = -1; pData->repeatCount = -1; pData->style = 0; /* force the read of the first line */ pData->index = 1; /* read data until we get to melody */ for (;;) { /* read a line from the file and parse the token */ if (pData->index != 0) { if ((result = IMY_ReadLine(pEASData->hwInstData, pData->fileHandle, pData->buffer, &pData->startLine)) != EAS_SUCCESS) { #ifdef _DEBUG_IMELODY { /* dpp: EAS_ReportEx(_EAS_SEVERITY_DETAIL, "IMY_ParseHeader: IMY_ReadLine returned %d\n", result); */ } #endif return result; } } token = IMY_ParseLine(pData->buffer, &pData->index); switch (token) { /* ignore these valid tokens */ case TOKEN_BEGIN: break; case TOKEN_FORMAT: if (!IMY_GetVersion(pData, &temp)) { { /* dpp: EAS_ReportEx(_EAS_SEVERITY_WARNING, "Invalid FORMAT field '%s'\n", pData->buffer); */ } return EAS_ERROR_FILE_FORMAT; } if ((temp != 0x0100) && (temp != 0x0200)) { { /* dpp: EAS_ReportEx(_EAS_SEVERITY_WARNING, "Unsupported FORMAT %02x\n", temp); */ } return EAS_ERROR_UNRECOGNIZED_FORMAT; } break; case TOKEN_VERSION: if (!IMY_GetVersion(pData, &temp)) { { /* dpp: EAS_ReportEx(_EAS_SEVERITY_WARNING, "Invalid VERSION field '%s'\n", pData->buffer); */ } return EAS_ERROR_FILE_FORMAT; } if ((temp != 0x0100) && (temp != 0x0102)) { { /* dpp: EAS_ReportEx(_EAS_SEVERITY_WARNING, "Unsupported VERSION %02x\n", temp); */ } return EAS_ERROR_UNRECOGNIZED_FORMAT; } break; case TOKEN_NAME: IMY_MetaData(pData, EAS_METADATA_TITLE, pData->buffer + pData->index); break; case TOKEN_COMPOSER: IMY_MetaData(pData, EAS_METADATA_AUTHOR, pData->buffer + pData->index); break; /* handle beat */ case TOKEN_BEAT: IMY_GetNumber(pEASData->hwInstData, pData, &temp, EAS_TRUE); if ((temp >= 25) && (temp <= 900)) pData->tick = TICK_CONVERT / temp; break; /* handle style */ case TOKEN_STYLE: c = IMY_GetNextChar(pEASData->hwInstData, pData, EAS_TRUE); if (c == 'S') c = IMY_GetNextChar(pEASData->hwInstData, pData, EAS_TRUE); if ((c >= '0') && (c <= '2')) pData->style = (EAS_U8) (c - '0'); else { PutBackChar(pData); { /* dpp: EAS_ReportEx(_EAS_SEVERITY_WARNING, "Error in style command: %s\n", pData->buffer); */ } } break; /* handle volume */ case TOKEN_VOLUME: c = IMY_GetNextChar(pEASData->hwInstData, pData, EAS_TRUE); if (c != 'V') { PutBackChar(pData); if (!IsDigit(c)) { { /* dpp: EAS_ReportEx(_EAS_SEVERITY_WARNING, "Error in volume command: %s\n", pData->buffer); */ } break; } } IMY_GetVolume(pEASData->hwInstData, pData, EAS_TRUE); break; case TOKEN_MELODY: #ifdef _DEBUG_IMELODY { /* dpp: EAS_ReportEx(_EAS_SEVERITY_DETAIL, "Header successfully parsed\n"); */ } #endif return EAS_SUCCESS; case TOKEN_END: { /* dpp: EAS_ReportEx(_EAS_SEVERITY_WARNING, "Unexpected END:IMELODY encountered\n"); */ } return EAS_ERROR_FILE_FORMAT; default: /* force a read of the next line */ pData->index = 1; { /* dpp: EAS_ReportEx(_EAS_SEVERITY_WARNING, "Ignoring unrecognized token in iMelody file: %s\n", pData->buffer); */ } break; } } } /*---------------------------------------------------------------------------- * IMY_GetNextChar() *---------------------------------------------------------------------------- * Purpose: * * * Inputs: * * * Outputs: * * * Side Effects: * *---------------------------------------------------------------------------- */ static EAS_I8 IMY_GetNextChar (EAS_HW_DATA_HANDLE hwInstData, S_IMELODY_DATA *pData, EAS_BOOL inHeader) { EAS_I8 c; EAS_U8 index; for (;;) { /* get next character */ c = pData->buffer[pData->index++]; /* buffer empty, read more */ if (!c) { /* don't read the next line in the header */ if (inHeader) return 0; pData->index = 0; pData->buffer[0] = 0; if (IMY_ReadLine(hwInstData, pData->fileHandle, pData->buffer, &pData->startLine) != EAS_SUCCESS) { #ifdef _DEBUG_IMELODY { /* dpp: EAS_ReportEx(_EAS_SEVERITY_DETAIL, "IMY_GetNextChar: EOF\n"); */ } #endif return 0; } /* check for END:IMELODY token */ if (IMY_ParseLine(pData->buffer, &index) == TOKEN_END) { #ifdef _DEBUG_IMELODY { /* dpp: EAS_ReportEx(_EAS_SEVERITY_DETAIL, "IMY_GetNextChar: found END:IMELODY\n"); */ } #endif pData->buffer[0] = 0; return 0; } continue; } /* ignore white space */ if (!IsSpace(c)) { #ifdef _DEBUG_IMELODY { /* dpp: EAS_ReportEx(_EAS_SEVERITY_DETAIL, "IMY_GetNextChar returned '%c'\n", c); */ } #endif return c; } } } /*---------------------------------------------------------------------------- * IMY_ReadLine() *---------------------------------------------------------------------------- * Purpose: * Reads a line of input from the file, discarding the CR/LF * * Inputs: * * * Outputs: * * * Side Effects: * *---------------------------------------------------------------------------- */ static EAS_RESULT IMY_ReadLine (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE fileHandle, EAS_I8 *buffer, EAS_I32 *pStartLine) { EAS_RESULT result; EAS_INT i; EAS_I8 c; /* fetch current file position and save it */ if (pStartLine != NULL) { if ((result = EAS_HWFilePos(hwInstData, fileHandle, pStartLine)) != EAS_SUCCESS) { #ifdef _DEBUG_IMELODY { /* dpp: EAS_ReportEx(_EAS_SEVERITY_DETAIL, "IMY_ParseHeader: EAS_HWFilePos returned %d\n", result); */ } #endif return result; } } buffer[0] = 0; for (i = 0; i < MAX_LINE_SIZE; ) { if ((result = EAS_HWGetByte(hwInstData, fileHandle, &c)) != EAS_SUCCESS) { if ((result == EAS_EOF) && (i > 0)) break; return result; } /* return on LF or end of data */ if (c == '\n') break; /* store characters in buffer */ if (c != '\r') buffer[i++] = c; } buffer[i] = 0; #ifdef _DEBUG_IMELODY { /* dpp: EAS_ReportEx(_EAS_SEVERITY_DETAIL, "IMY_ReadLine read %s\n", buffer); */ } #endif return EAS_SUCCESS; } /*---------------------------------------------------------------------------- * IMY_ParseLine() *---------------------------------------------------------------------------- * Purpose: * * * Inputs: * * * Outputs: * * * Side Effects: * *---------------------------------------------------------------------------- */ static EAS_INT IMY_ParseLine (EAS_I8 *buffer, EAS_U8 *pIndex) { EAS_INT i; EAS_INT j; /* there's no strnicmp() in stdlib, so we have to roll our own */ for (i = 0; i < TOKEN_INVALID; i++) { for (j = 0; ; j++) { /* end of token, must be a match */ if (tokens[i][j] == 0) { #ifdef _DEBUG_IMELODY { /* dpp: EAS_ReportEx(_EAS_SEVERITY_DETAIL, "IMY_ParseLine found token %d\n", i); */ } #endif *pIndex = (EAS_U8) j; return i; } if (tokens[i][j] != ToUpper(buffer[j])) break; } } #ifdef _DEBUG_IMELODY { /* dpp: EAS_ReportEx(_EAS_SEVERITY_DETAIL, "IMY_ParseLine: no token found\n"); */ } #endif return TOKEN_INVALID; }