blob: 1419d6d35890788e82ee5f29b9c63a89f0975d54 [file] [log] [blame]
/*----------------------------------------------------------------------------
*
* 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,
#ifdef JET_INTERFACE
RTTTL_Pause,
RTTTL_Resume,
#else
NULL,
NULL,
#endif
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 (pData->notePlayedSinceRepeat == 0) {
return EAS_ERROR_FILE_FORMAT;
}
if ((result = EAS_HWFileSeek(pEASData->hwInstData, pData->fileHandle, pData->repeatOffset)) != EAS_SUCCESS)
return result;
pData->notePlayedSinceRepeat = 0;
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 == '.')
{
/* Number of ticks must not be greater than 32-bits */
if ((ticks >> 1) > (INT32_MAX - ticks))
{
return EAS_ERROR_FILE_FORMAT;
}
/*lint -e{704} shift for performance */
ticks += ticks >> 1;
}
/* accidental */
else if (c == '#')
{
if (note)
note++;
}
/* end of event */
else if ((c == ',') && note)
{
pData->notePlayedSinceRepeat = 1;
/* 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 */
if ((ticks - pData->restTicks) > (INT32_MAX - pData->time))
{
return EAS_ERROR_FILE_FORMAT;
}
pData->time += ticks - pData->restTicks;
}
/* rest */
else
{
if (ticks > (INT32_MAX - pData->time))
{
return EAS_ERROR_FILE_FORMAT;
}
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;
}
#ifdef JET_INTERFACE
/*----------------------------------------------------------------------------
* 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;
}
#endif
/*----------------------------------------------------------------------------
* 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;
if (temp > 100) {
// This is just to prevent overflows in case of a really large number
// in the file, but rather than allowing the number to grow up to INT_MAX,
// we limit it to a much smaller number since the numbers in an RTTTL file
// are supposed to be at most in the hundreds, not millions or billions.
// There are more specific checks in the callers of this function to enforce
// the various limits for notes, octaves, tempo, etc.
return EAS_FAILURE;
}
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;
pData->notePlayedSinceRepeat = 0;
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;
}
}