| /*---------------------------------------------------------------------------- | |
| * | |
| * File: | |
| * eas_rtttl.c | |
| * | |
| * Contents and purpose: | |
| * RTTTL 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: 795 $ | |
| * $Date: 2007-08-01 00:14:45 -0700 (Wed, 01 Aug 2007) $ | |
| *---------------------------------------------------------------------------- | |
| */ | |
| #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_rtttldata.h" | |
| #include "eas_ctype.h" | |
| /* increase gain for mono ringtones */ | |
| #define RTTTL_GAIN_OFFSET 8 | |
| /* maximum title length including colon separator */ | |
| #define RTTTL_MAX_TITLE_LEN 32 | |
| #define RTTTL_INFINITE_LOOP 15 | |
| /* length of 32nd note in 1/256ths of a msec for 63 BPM tempo */ | |
| #define DEFAULT_TICK_CONV 30476 | |
| #define TICK_CONVERT 1920000 | |
| /* default channel and program for RTTTL playback */ | |
| #define RTTTL_CHANNEL 0 | |
| #define RTTTL_PROGRAM 80 | |
| #define RTTTL_VELOCITY 127 | |
| /* note used for rest */ | |
| #define RTTTL_REST 1 | |
| /* multiplier for fixed point triplet conversion */ | |
| #define TRIPLET_MULTIPLIER 683 | |
| #define TRIPLET_SHIFT 10 | |
| /* local prototypes */ | |
| static EAS_RESULT RTTTL_CheckFileType (S_EAS_DATA *pEASData, EAS_FILE_HANDLE fileHandle, EAS_VOID_PTR *ppHandle, EAS_I32 offset); | |
| static EAS_RESULT RTTTL_Prepare (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData); | |
| static EAS_RESULT RTTTL_Time (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData, EAS_U32 *pTime); | |
| static EAS_RESULT RTTTL_Event (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData, EAS_INT parserMode); | |
| static EAS_RESULT RTTTL_State (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData, EAS_STATE *pState); | |
| static EAS_RESULT RTTTL_Close (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData); | |
| static EAS_RESULT RTTTL_Reset (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData); | |
| static EAS_RESULT RTTTL_Pause (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData); | |
| static EAS_RESULT RTTTL_Resume (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData); | |
| static EAS_RESULT RTTTL_SetData (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData, EAS_I32 param, EAS_I32 value); | |
| static EAS_RESULT RTTTL_GetData (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData, EAS_I32 param, EAS_I32 *pValue); | |
| static EAS_RESULT RTTTL_GetStyle (EAS_HW_DATA_HANDLE hwInstData, S_RTTTL_DATA *pData); | |
| static EAS_RESULT RTTTL_GetDuration (EAS_HW_DATA_HANDLE hwInstData, S_RTTTL_DATA *pData, EAS_I8 *pDuration); | |
| static EAS_RESULT RTTTL_GetOctave (EAS_HW_DATA_HANDLE hwInstData, S_RTTTL_DATA *pData, EAS_U8 *pOctave); | |
| static EAS_RESULT RTTTL_GetTempo (EAS_HW_DATA_HANDLE hwInstData, S_RTTTL_DATA *pData); | |
| static EAS_RESULT RTTTL_GetNumber (EAS_HW_DATA_HANDLE hwInstData, S_RTTTL_DATA *pData, EAS_I32 *pValue); | |
| static EAS_RESULT RTTTL_ParseHeader (S_EAS_DATA *pEASData, S_RTTTL_DATA* pData, EAS_BOOL metaData); | |
| static EAS_RESULT RTTTL_GetNextChar (EAS_HW_DATA_HANDLE hwInstData, S_RTTTL_DATA *pData, EAS_I8 *pValue); | |
| static EAS_RESULT RTTTL_PeekNextChar (EAS_HW_DATA_HANDLE hwInstData, S_RTTTL_DATA *pData, EAS_I8 *pValue); | |
| /* inline functions */ | |
| EAS_INLINE void RTTTL_PutBackChar (S_RTTTL_DATA *pData, EAS_I8 value) { pData->dataByte = value; } | |
| /* lookup table for note values */ | |
| static const EAS_U8 noteTable[] = { 21, 23, 12, 14, 16, 17, 19, 23 }; | |
| /*---------------------------------------------------------------------------- | |
| * | |
| * EAS_RTTTL_Parser | |
| * | |
| * This structure contains the functional interface for the iMelody parser | |
| *---------------------------------------------------------------------------- | |
| */ | |
| const S_FILE_PARSER_INTERFACE EAS_RTTTL_Parser = | |
| { | |
| RTTTL_CheckFileType, | |
| RTTTL_Prepare, | |
| RTTTL_Time, | |
| RTTTL_Event, | |
| RTTTL_State, | |
| RTTTL_Close, | |
| RTTTL_Reset, | |
| RTTTL_Pause, | |
| RTTTL_Resume, | |
| NULL, | |
| RTTTL_SetData, | |
| RTTTL_GetData, | |
| NULL | |
| }; | |
| /*---------------------------------------------------------------------------- | |
| * RTTTL_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 RTTTL_CheckFileType (S_EAS_DATA *pEASData, EAS_FILE_HANDLE fileHandle, EAS_VOID_PTR *ppHandle, EAS_I32 offset) | |
| { | |
| S_RTTTL_DATA data; | |
| S_RTTTL_DATA *pData; | |
| /* see if we can parse the header */ | |
| data.fileHandle = fileHandle; | |
| data.fileOffset = offset; | |
| *ppHandle= NULL; | |
| if (RTTTL_ParseHeader (pEASData, &data, EAS_FALSE) == EAS_SUCCESS) | |
| { | |
| /* check for static memory allocation */ | |
| if (pEASData->staticMemoryModel) | |
| pData = EAS_CMEnumData(EAS_CM_RTTTL_DATA); | |
| else | |
| pData = EAS_HWMalloc(pEASData->hwInstData, sizeof(S_RTTTL_DATA)); | |
| if (!pData) | |
| return EAS_ERROR_MALLOC_FAILED; | |
| EAS_HWMemSet(pData, 0, sizeof(S_RTTTL_DATA)); | |
| /* return a pointer to the instance data */ | |
| pData->fileHandle = fileHandle; | |
| pData->fileOffset = offset; | |
| pData->state = EAS_STATE_OPEN; | |
| *ppHandle = pData; | |
| } | |
| return EAS_SUCCESS; | |
| } | |
| /*---------------------------------------------------------------------------- | |
| * RTTTL_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 RTTTL_Prepare (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData) | |
| { | |
| S_RTTTL_DATA* pData; | |
| EAS_RESULT result; | |
| /* check for valid state */ | |
| pData = (S_RTTTL_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; | |
| } | |
| pData->state = EAS_STATE_ERROR; | |
| if ((result = RTTTL_ParseHeader (pEASData, pData, (EAS_BOOL) (pData->metadata.callback != NULL))) != EAS_SUCCESS) | |
| { | |
| /* if using dynamic memory, free it */ | |
| if (!pEASData->staticMemoryModel) | |
| EAS_HWFree(pEASData->hwInstData, pData); | |
| return result; | |
| } | |
| pData->state = EAS_STATE_READY; | |
| return EAS_SUCCESS; | |
| } | |
| /*---------------------------------------------------------------------------- | |
| * RTTTL_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) reserved for future use */ | |
| static EAS_RESULT RTTTL_Time (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData, EAS_U32 *pTime) | |
| { | |
| S_RTTTL_DATA *pData; | |
| pData = (S_RTTTL_DATA*) pInstData; | |
| /* return time in milliseconds */ | |
| /*lint -e{704} use shift instead of division */ | |
| *pTime = pData->time >> 8; | |
| return EAS_SUCCESS; | |
| } | |
| /*---------------------------------------------------------------------------- | |
| * RTTTL_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 RTTTL_Event (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData, EAS_INT parserMode) | |
| { | |
| S_RTTTL_DATA* pData; | |
| EAS_RESULT result; | |
| EAS_I32 ticks; | |
| EAS_I32 temp; | |
| EAS_I8 c; | |
| EAS_U8 note; | |
| EAS_U8 octave; | |
| pData = (S_RTTTL_DATA*) pInstData; | |
| if (pData->state >= EAS_STATE_OPEN) | |
| return EAS_SUCCESS; | |
| /* initialize MIDI channel when the track starts playing */ | |
| if (pData->time == 0) | |
| { | |
| /* set program to square lead */ | |
| VMProgramChange(pEASData->pVoiceMgr, pData->pSynth, RTTTL_CHANNEL, RTTTL_PROGRAM); | |
| /* set channel volume to max */ | |
| VMControlChange(pEASData->pVoiceMgr, pData->pSynth, RTTTL_CHANNEL, 7, 127); | |
| } | |
| /* check for end of note */ | |
| if (pData->note) | |
| { | |
| /* stop the note */ | |
| VMStopNote(pEASData->pVoiceMgr, pData->pSynth, RTTTL_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 */ | |
| octave = pData->octave; | |
| note = 0; | |
| ticks = pData->duration * pData->tick; | |
| for (;;) | |
| { | |
| /* get next character */ | |
| if ((result = RTTTL_GetNextChar(pEASData->hwInstData, pData, &c)) != EAS_SUCCESS) | |
| { | |
| if (result != EAS_EOF) | |
| return result; | |
| /* end of file, if no notes to process, check for looping */ | |
| if (!note) | |
| { | |
| /* if no loop set state to stopping */ | |
| if (pData->repeatCount == 0) | |
| { | |
| pData->state = EAS_STATE_STOPPING; | |
| VMReleaseAllVoices(pEASData->pVoiceMgr, pData->pSynth); | |
| return EAS_SUCCESS; | |
| } | |
| /* decrement loop count */ | |
| if (pData->repeatCount != RTTTL_INFINITE_LOOP) | |
| pData->repeatCount--; | |
| /* if locating, ignore infinite loops */ | |
| else if (parserMode != eParserModePlay) | |
| { | |
| pData->state = EAS_STATE_STOPPING; | |
| VMReleaseAllVoices(pEASData->pVoiceMgr, pData->pSynth); | |
| return EAS_SUCCESS; | |
| } | |
| /* loop back to start of notes */ | |
| if ((result = EAS_HWFileSeek(pEASData->hwInstData, pData->fileHandle, pData->repeatOffset)) != EAS_SUCCESS) | |
| return result; | |
| continue; | |
| } | |
| /* still have a note to process */ | |
| else | |
| c = ','; | |
| } | |
| /* bpm */ | |
| if (c == 'b') | |
| { | |
| /* peek at next character */ | |
| if ((result = RTTTL_PeekNextChar(pEASData->hwInstData, pData, &c)) != EAS_SUCCESS) | |
| return result; | |
| /* if a number, must be octave or tempo */ | |
| if (IsDigit(c)) | |
| { | |
| if ((result = RTTTL_GetNumber(pEASData->hwInstData, pData, &temp)) != EAS_SUCCESS) | |
| return result; | |
| /* check for octave first */ | |
| if ((temp >= 4) && (temp <= 7)) | |
| { | |
| octave = (EAS_U8) temp; | |
| } | |
| /* check for tempo */ | |
| else if ((temp >= 25) && (temp <= 900)) | |
| { | |
| pData->tick = TICK_CONVERT / (EAS_U32) temp; | |
| } | |
| /* don't know what it was */ | |
| else | |
| return EAS_ERROR_FILE_FORMAT; | |
| } | |
| /* must be a note */ | |
| else | |
| { | |
| note = noteTable[1]; | |
| } | |
| } | |
| /* octave */ | |
| else if (c == 'o') | |
| { | |
| if ((result = RTTTL_GetOctave(pEASData->hwInstData, pData, &pData->octave)) != EAS_SUCCESS) | |
| return result; | |
| } | |
| /* style */ | |
| else if (c == 's') | |
| { | |
| if ((result = RTTTL_GetStyle(pEASData->hwInstData, pData)) != EAS_SUCCESS) | |
| return result; | |
| } | |
| /* duration or octave */ | |
| else if (IsDigit(c)) | |
| { | |
| RTTTL_PutBackChar(pData, c); | |
| /* duration comes before note */ | |
| if (!note) | |
| { | |
| if ((result = RTTTL_GetDuration(pEASData->hwInstData, pData, &c)) != EAS_SUCCESS) | |
| return result; | |
| ticks = c * pData->tick; | |
| } | |
| /* octave comes after note */ | |
| else | |
| { | |
| if ((result = RTTTL_GetOctave(pEASData->hwInstData, pData, &octave)) != EAS_SUCCESS) | |
| return result; | |
| } | |
| } | |
| /* note or rest */ | |
| else if ((c >= 'a') && (c <= 'h')) | |
| { | |
| note = noteTable[c - 'a']; | |
| } | |
| else if (c == 'p') | |
| { | |
| note = RTTTL_REST; | |
| } | |
| /* dotted note */ | |
| else if (c == '.') | |
| { | |
| /*lint -e{704} shift for performance */ | |
| ticks += ticks >> 1; | |
| } | |
| /* accidental */ | |
| else if (c == '#') | |
| { | |
| if (note) | |
| note++; | |
| } | |
| /* end of event */ | |
| else if ((c == ',') && note) | |
| { | |
| /* handle note events */ | |
| if (note != RTTTL_REST) | |
| { | |
| /* save note and start it */ | |
| pData->note = note + octave; | |
| if (parserMode == eParserModePlay) | |
| VMStartNote(pEASData->pVoiceMgr, pData->pSynth, RTTTL_CHANNEL, pData->note, RTTTL_VELOCITY); | |
| /* determine note length */ | |
| switch (pData->style) | |
| { | |
| /* natural */ | |
| case 'n': | |
| /*lint -e{704} shift for performance */ | |
| pData->restTicks = ticks >> 4; | |
| break; | |
| /* continuous */ | |
| case 'c': | |
| pData->restTicks = 0; | |
| break; | |
| /* staccato */ | |
| case 's': | |
| /*lint -e{704} shift for performance */ | |
| pData->restTicks = ticks >> 1; | |
| break; | |
| default: | |
| { /* dpp: EAS_ReportEx(_EAS_SEVERITY_WARNING, "RTTTL_Event: Unexpected style type %c\n", pData->style); */ } | |
| break; | |
| } | |
| /* next event is at end of this note */ | |
| pData->time += ticks - pData->restTicks; | |
| } | |
| /* rest */ | |
| else | |
| pData->time += ticks; | |
| /* event found, return to caller */ | |
| break; | |
| } | |
| } | |
| pData->state = EAS_STATE_PLAY; | |
| return EAS_SUCCESS; | |
| } | |
| /*---------------------------------------------------------------------------- | |
| * RTTTL_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) reserved for future use */ | |
| static EAS_RESULT RTTTL_State (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData, EAS_I32 *pState) | |
| { | |
| S_RTTTL_DATA* pData; | |
| /* establish pointer to instance data */ | |
| pData = (S_RTTTL_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; | |
| } | |
| if (pData->state == EAS_STATE_PAUSING) | |
| { | |
| if (VMActiveVoices(pData->pSynth) == 0) | |
| pData->state = EAS_STATE_PAUSED; | |
| } | |
| /* return current state */ | |
| *pState = pData->state; | |
| return EAS_SUCCESS; | |
| } | |
| /*---------------------------------------------------------------------------- | |
| * RTTTL_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 RTTTL_Close (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData) | |
| { | |
| S_RTTTL_DATA* pData; | |
| EAS_RESULT result; | |
| pData = (S_RTTTL_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; | |
| } | |
| /*---------------------------------------------------------------------------- | |
| * RTTTL_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 RTTTL_Reset (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData) | |
| { | |
| S_RTTTL_DATA* pData; | |
| EAS_RESULT result; | |
| pData = (S_RTTTL_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 = RTTTL_ParseHeader (pEASData, pData, EAS_TRUE)) != EAS_SUCCESS) | |
| return result; | |
| pData->state = EAS_STATE_READY; | |
| return EAS_SUCCESS; | |
| } | |
| /*---------------------------------------------------------------------------- | |
| * RTTTL_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 RTTTL_Pause (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData) | |
| { | |
| S_RTTTL_DATA *pData; | |
| /* can't pause a stopped stream */ | |
| pData = (S_RTTTL_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; | |
| } | |
| /*---------------------------------------------------------------------------- | |
| * RTTTL_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) reserved for future use */ | |
| static EAS_RESULT RTTTL_Resume (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData) | |
| { | |
| S_RTTTL_DATA *pData; | |
| /* can't resume a stopped stream */ | |
| pData = (S_RTTTL_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; | |
| } | |
| /*---------------------------------------------------------------------------- | |
| * RTTTL_SetData() | |
| *---------------------------------------------------------------------------- | |
| * Purpose: | |
| * Return file type | |
| * | |
| * Inputs: | |
| * pEASData - pointer to overall EAS data structure | |
| * handle - pointer to file handle | |
| * | |
| * Outputs: | |
| * | |
| * | |
| * Side Effects: | |
| * | |
| *---------------------------------------------------------------------------- | |
| */ | |
| /*lint -esym(715, pEASData) reserved for future use */ | |
| static EAS_RESULT RTTTL_SetData (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData, EAS_I32 param, EAS_I32 value) | |
| { | |
| S_RTTTL_DATA *pData; | |
| pData = (S_RTTTL_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; | |
| } | |
| /*---------------------------------------------------------------------------- | |
| * RTTTL_GetData() | |
| *---------------------------------------------------------------------------- | |
| * Purpose: | |
| * Return file type | |
| * | |
| * Inputs: | |
| * pEASData - pointer to overall EAS data structure | |
| * handle - pointer to file handle | |
| * | |
| * Outputs: | |
| * | |
| * | |
| * Side Effects: | |
| * | |
| *---------------------------------------------------------------------------- | |
| */ | |
| /*lint -esym(715, pEASData) reserved for future use */ | |
| static EAS_RESULT RTTTL_GetData (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData, EAS_I32 param, EAS_I32 *pValue) | |
| { | |
| S_RTTTL_DATA *pData; | |
| pData = (S_RTTTL_DATA *) pInstData; | |
| switch (param) | |
| { | |
| /* return file type as RTTTL */ | |
| case PARSER_DATA_FILE_TYPE: | |
| *pValue = EAS_FILE_RTTTL; | |
| break; | |
| #if 0 | |
| /* set transposition */ | |
| case PARSER_DATA_TRANSPOSITION: | |
| *pValue = pData->transposition; | |
| break; | |
| #endif | |
| case PARSER_DATA_SYNTH_HANDLE: | |
| *pValue = (EAS_I32) pData->pSynth; | |
| break; | |
| case PARSER_DATA_GAIN_OFFSET: | |
| *pValue = RTTTL_GAIN_OFFSET; | |
| break; | |
| default: | |
| return EAS_ERROR_INVALID_PARAMETER; | |
| } | |
| return EAS_SUCCESS; | |
| } | |
| /*---------------------------------------------------------------------------- | |
| * RTTTL_GetStyle() | |
| *---------------------------------------------------------------------------- | |
| * Purpose: | |
| * | |
| * | |
| * Inputs: | |
| * | |
| * | |
| * Outputs: | |
| * | |
| * | |
| * Side Effects: | |
| * | |
| *---------------------------------------------------------------------------- | |
| */ | |
| static EAS_RESULT RTTTL_GetStyle (EAS_HW_DATA_HANDLE hwInstData, S_RTTTL_DATA *pData) | |
| { | |
| EAS_RESULT result; | |
| EAS_I8 style; | |
| /* get style */ | |
| if ((result = RTTTL_GetNextChar(hwInstData, pData, &style)) != EAS_SUCCESS) | |
| return result; | |
| if ((style != 's') && (style != 'n') && (style != 'c')) | |
| return EAS_ERROR_FILE_FORMAT; | |
| pData->style = style; | |
| return EAS_SUCCESS; | |
| } | |
| /*---------------------------------------------------------------------------- | |
| * RTTTL_GetDuration() | |
| *---------------------------------------------------------------------------- | |
| * Purpose: | |
| * | |
| * | |
| * Inputs: | |
| * | |
| * | |
| * Outputs: | |
| * | |
| * | |
| * Side Effects: | |
| * | |
| *---------------------------------------------------------------------------- | |
| */ | |
| static EAS_RESULT RTTTL_GetDuration (EAS_HW_DATA_HANDLE hwInstData, S_RTTTL_DATA *pData, EAS_I8 *pDuration) | |
| { | |
| EAS_RESULT result; | |
| EAS_I32 duration; | |
| EAS_I8 temp; | |
| /* get the duration */ | |
| if ((result = RTTTL_GetNumber(hwInstData, pData, &duration)) != EAS_SUCCESS) | |
| return result; | |
| if ((duration != 1) && (duration != 2) && (duration != 4) && (duration != 8) && (duration != 16) && (duration != 32)) | |
| return EAS_ERROR_FILE_FORMAT; | |
| temp = 64; | |
| while (duration) | |
| { | |
| /*lint -e{704} shift for performance */ | |
| duration = duration >> 1; | |
| /*lint -e{702} use shift for performance */ | |
| temp = temp >> 1; | |
| } | |
| *pDuration = temp; | |
| return EAS_SUCCESS; | |
| } | |
| /*---------------------------------------------------------------------------- | |
| * RTTTL_GetOctave() | |
| *---------------------------------------------------------------------------- | |
| * Purpose: | |
| * | |
| * | |
| * Inputs: | |
| * | |
| * | |
| * Outputs: | |
| * | |
| * | |
| * Side Effects: | |
| * | |
| *---------------------------------------------------------------------------- | |
| */ | |
| static EAS_RESULT RTTTL_GetOctave (EAS_HW_DATA_HANDLE hwInstData, S_RTTTL_DATA *pData, EAS_U8 *pOctave) | |
| { | |
| EAS_RESULT result; | |
| EAS_I32 octave; | |
| /* get the tempo */ | |
| if ((result = RTTTL_GetNumber(hwInstData, pData, &octave)) != EAS_SUCCESS) | |
| return result; | |
| if ((octave < 4) || (octave > 7)) | |
| return EAS_ERROR_FILE_FORMAT; | |
| *pOctave = (EAS_U8) (octave * 12); | |
| return EAS_SUCCESS; | |
| } | |
| /*---------------------------------------------------------------------------- | |
| * RTTTL_GetTempo() | |
| *---------------------------------------------------------------------------- | |
| * Purpose: | |
| * | |
| * | |
| * Inputs: | |
| * | |
| * | |
| * Outputs: | |
| * | |
| * | |
| * Side Effects: | |
| * | |
| *---------------------------------------------------------------------------- | |
| */ | |
| static EAS_RESULT RTTTL_GetTempo (EAS_HW_DATA_HANDLE hwInstData, S_RTTTL_DATA *pData) | |
| { | |
| EAS_RESULT result; | |
| EAS_I32 tempo; | |
| /* get the tempo */ | |
| if ((result = RTTTL_GetNumber(hwInstData, pData, &tempo)) != EAS_SUCCESS) | |
| return result; | |
| if ((tempo < 25) || (tempo > 900)) | |
| return EAS_ERROR_FILE_FORMAT; | |
| pData->tick = TICK_CONVERT / (EAS_U32) tempo; | |
| return EAS_SUCCESS; | |
| } | |
| /*---------------------------------------------------------------------------- | |
| * RTTTL_GetNumber() | |
| *---------------------------------------------------------------------------- | |
| * Purpose: | |
| * | |
| * | |
| * Inputs: | |
| * | |
| * | |
| * Outputs: | |
| * | |
| * | |
| * Side Effects: | |
| * | |
| *---------------------------------------------------------------------------- | |
| */ | |
| static EAS_RESULT RTTTL_GetNumber (EAS_HW_DATA_HANDLE hwInstData, S_RTTTL_DATA *pData, EAS_I32 *pValue) | |
| { | |
| EAS_RESULT result; | |
| EAS_INT temp; | |
| EAS_I8 c; | |
| *pValue = -1; | |
| temp = 0; | |
| for (;;) | |
| { | |
| if ((result = RTTTL_PeekNextChar(hwInstData, pData, &c)) != EAS_SUCCESS) | |
| { | |
| if ((result == EAS_EOF) && (*pValue != -1)) | |
| return EAS_SUCCESS; | |
| return result; | |
| } | |
| if (IsDigit(c)) | |
| { | |
| pData->dataByte = 0; | |
| temp = temp * 10 + c - '0'; | |
| *pValue = temp; | |
| } | |
| else | |
| return EAS_SUCCESS; | |
| } | |
| } | |
| /*---------------------------------------------------------------------------- | |
| * RTTTL_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 RTTTL_ParseHeader (S_EAS_DATA *pEASData, S_RTTTL_DATA* pData, EAS_BOOL metaData) | |
| { | |
| EAS_RESULT result; | |
| EAS_I32 i; | |
| EAS_I8 temp; | |
| EAS_I8 control; | |
| /* initialize some defaults */ | |
| pData->time = 0; | |
| pData->tick = DEFAULT_TICK_CONV; | |
| pData->note = 0; | |
| pData->duration = 4; | |
| pData ->restTicks = 0; | |
| pData->octave = 60; | |
| pData->repeatOffset = -1; | |
| pData->repeatCount = 0; | |
| pData->style = 'n'; | |
| pData->dataByte = 0; | |
| metaData = metaData && (pData->metadata.buffer != NULL) && (pData->metadata.callback != NULL); | |
| /* seek to start of data */ | |
| if ((result = EAS_HWFileSeek(pEASData->hwInstData, pData->fileHandle, pData->fileOffset)) != EAS_SUCCESS) | |
| return result; | |
| /* zero the metadata buffer */ | |
| if (metaData) | |
| EAS_HWMemSet(pData->metadata.buffer, 0, pData->metadata.bufferSize); | |
| /* read the title */ | |
| for (i = 0; i < RTTTL_MAX_TITLE_LEN; i++) | |
| { | |
| if ((result = EAS_HWGetByte(pEASData->hwInstData, pData->fileHandle, &temp)) != EAS_SUCCESS) | |
| return result; | |
| if (temp == ':') | |
| break; | |
| /* pass along metadata */ | |
| if (metaData) | |
| { | |
| if (i < (pData->metadata.bufferSize- 1)) | |
| pData->metadata.buffer[i] = (char) temp; | |
| } | |
| } | |
| /* check for error in title */ | |
| if (i == RTTTL_MAX_TITLE_LEN) | |
| return EAS_ERROR_FILE_FORMAT; | |
| /* pass along metadata */ | |
| if (metaData) | |
| (*pData->metadata.callback)(EAS_METADATA_TITLE, pData->metadata.buffer, pData->metadata.pUserData); | |
| /* control fields */ | |
| for (;;) | |
| { | |
| /* get control type */ | |
| if ((result = RTTTL_GetNextChar(pEASData->hwInstData, pData, &control)) != EAS_SUCCESS) | |
| return result; | |
| /* next char should be equal sign */ | |
| if ((result = RTTTL_GetNextChar(pEASData->hwInstData, pData, &temp)) != EAS_SUCCESS) | |
| return result; | |
| if (temp != '=') | |
| return EAS_ERROR_FILE_FORMAT; | |
| /* get the control value */ | |
| switch (control) | |
| { | |
| /* bpm */ | |
| case 'b': | |
| if ((result = RTTTL_GetTempo(pEASData->hwInstData, pData)) != EAS_SUCCESS) | |
| return result; | |
| break; | |
| /* duration */ | |
| case 'd': | |
| if ((result = RTTTL_GetDuration(pEASData->hwInstData, pData, &temp)) != EAS_SUCCESS) | |
| return result; | |
| pData->duration = temp; | |
| break; | |
| /* loop */ | |
| case 'l': | |
| if ((result = RTTTL_GetNumber(pEASData->hwInstData, pData, &i)) != EAS_SUCCESS) | |
| return result; | |
| if ((i < 0) || (i > 15)) | |
| return EAS_ERROR_FILE_FORMAT; | |
| pData->repeatCount = (EAS_U8) i; | |
| break; | |
| /* octave */ | |
| case 'o': | |
| if ((result = RTTTL_GetOctave(pEASData->hwInstData, pData, &pData->octave)) != EAS_SUCCESS) | |
| return result; | |
| break; | |
| /* get style */ | |
| case 's': | |
| if ((result = RTTTL_GetStyle(pEASData->hwInstData, pData)) != EAS_SUCCESS) | |
| return result; | |
| break; | |
| /* unrecognized control */ | |
| default: | |
| return EAS_ERROR_FILE_FORMAT; | |
| } | |
| /* next character should be comma or colon */ | |
| if ((result = RTTTL_GetNextChar(pEASData->hwInstData, pData, &temp)) != EAS_SUCCESS) | |
| return result; | |
| /* check for end of control field */ | |
| if (temp == ':') | |
| break; | |
| /* must be a comma */ | |
| if (temp != ',') | |
| return EAS_ERROR_FILE_FORMAT; | |
| } | |
| /* should be at the start of the music block */ | |
| if ((result = EAS_HWFilePos(pEASData->hwInstData, pData->fileHandle, &pData->repeatOffset)) != EAS_SUCCESS) | |
| return result; | |
| return EAS_SUCCESS; | |
| } | |
| /*---------------------------------------------------------------------------- | |
| * RTTTL_GetNextChar() | |
| *---------------------------------------------------------------------------- | |
| * Purpose: | |
| * | |
| * | |
| * Inputs: | |
| * | |
| * | |
| * Outputs: | |
| * | |
| * | |
| * Side Effects: | |
| * | |
| *---------------------------------------------------------------------------- | |
| */ | |
| static EAS_RESULT RTTTL_GetNextChar (EAS_HW_DATA_HANDLE hwInstData, S_RTTTL_DATA *pData, EAS_I8 *pValue) | |
| { | |
| EAS_RESULT result; | |
| EAS_I8 temp; | |
| *pValue = 0; | |
| for(;;) | |
| { | |
| /* check for character that has been put back */ | |
| if (pData->dataByte) | |
| { | |
| temp = pData->dataByte; | |
| pData->dataByte = 0; | |
| } | |
| else | |
| { | |
| if ((result = EAS_HWGetByte(hwInstData, pData->fileHandle, &temp)) != EAS_SUCCESS) | |
| return result; | |
| } | |
| /* ignore white space */ | |
| if (!IsSpace(temp)) | |
| { | |
| *pValue = ToLower(temp); | |
| return EAS_SUCCESS; | |
| } | |
| } | |
| } | |
| /*---------------------------------------------------------------------------- | |
| * RTTTL_PeekNextChar() | |
| *---------------------------------------------------------------------------- | |
| * Purpose: | |
| * | |
| * | |
| * Inputs: | |
| * | |
| * | |
| * Outputs: | |
| * | |
| * | |
| * Side Effects: | |
| * | |
| *---------------------------------------------------------------------------- | |
| */ | |
| static EAS_RESULT RTTTL_PeekNextChar (EAS_HW_DATA_HANDLE hwInstData, S_RTTTL_DATA *pData, EAS_I8 *pValue) | |
| { | |
| EAS_RESULT result; | |
| EAS_I8 temp; | |
| *pValue = 0; | |
| for(;;) | |
| { | |
| /* read a character from the file, if necessary */ | |
| if (!pData->dataByte) | |
| { | |
| if ((result = EAS_HWGetByte(hwInstData, pData->fileHandle, &pData->dataByte)) != EAS_SUCCESS) | |
| return result; | |
| } | |
| temp = pData->dataByte; | |
| /* ignore white space */ | |
| if (!IsSpace(temp)) | |
| { | |
| *pValue = ToLower(temp); | |
| return EAS_SUCCESS; | |
| } | |
| pData->dataByte = 0; | |
| } | |
| } | |