| /*---------------------------------------------------------------------------- |
| * |
| * 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 <string.h> |
| #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, |
| IMY_Pause, |
| IMY_Resume, |
| 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; |
| } |
| |
| /*---------------------------------------------------------------------------- |
| * 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; |
| } |
| |
| /*---------------------------------------------------------------------------- |
| * 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; |
| } |
| |
