/*----------------------------------------------------------------------------
*
* File:
* eas_tonecontrol.c
*
* Contents and purpose:
* MMAPI ToneControl parser
*
* Copyright Sonic Network Inc. 2006
* 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_tcdata.h"
/* default channel and program for TC playback */
#define TC_CHANNEL 0
#define TC_PROGRAM 80
#define TC_VELOCITY 127
#define TC_FIELD_SILENCE -1
#define TC_FIELD_VERSION -2
#define TC_FIELD_TEMPO -3
#define TC_FIELD_RESOLUTION -4
#define TC_FIELD_BLOCK_START -5
#define TC_FIELD_BLOCK_END -6
#define TC_FIELD_PLAY_BLOCK -7
#define TC_FIELD_SET_VOLUME -8
#define TC_FIELD_REPEAT -9
#define TC_FIELD_INVALID -10
/* convert 0-100 volume to 0-127 velocity using fixed point */
#define TC_VOLUME_CONV 21307064
#define TC_VOLUME_SHIFT 24
/* local prototypes */
static EAS_RESULT TC_CheckFileType (S_EAS_DATA *pEASData, EAS_FILE_HANDLE fileHandle, EAS_VOID_PTR *ppHandle, EAS_I32 offset);
static EAS_RESULT TC_Prepare (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData);
static EAS_RESULT TC_Time (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData, EAS_U32 *pTime);
static EAS_RESULT TC_Event (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData, EAS_INT parserMode);
static EAS_RESULT TC_State (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData, EAS_STATE *pState);
static EAS_RESULT TC_Close (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData);
static EAS_RESULT TC_Reset (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData);
static EAS_RESULT TC_Pause (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData);
static EAS_RESULT TC_Resume (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData);
static EAS_RESULT TC_SetData (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData, EAS_I32 param, EAS_I32 value);
static EAS_RESULT TC_GetData (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData, EAS_I32 param, EAS_I32 *pValue);
static EAS_RESULT TC_ParseHeader (S_EAS_DATA *pEASData, S_TC_DATA* pData);
static EAS_RESULT TC_StartNote (S_EAS_DATA *pEASData, S_TC_DATA* pData, EAS_INT parserMode, EAS_I8 note);
static EAS_RESULT TC_GetRepeat (S_EAS_DATA *pEASData, S_TC_DATA* pData, EAS_INT parserMode);
static EAS_RESULT TC_PlayBlock (S_EAS_DATA *pEASData, S_TC_DATA* pData);
static EAS_RESULT TC_BlockEnd (S_EAS_DATA *pEASData, S_TC_DATA* pData);
static EAS_RESULT TC_GetVolume (S_EAS_DATA *pEASData, S_TC_DATA* pData);
static EAS_RESULT TC_GetTempo (S_EAS_DATA *pEASData, S_TC_DATA* pData);
static EAS_RESULT TC_GetResolution (S_EAS_DATA *pEASData, S_TC_DATA* pData);
static EAS_RESULT TC_GetNextChar (EAS_HW_DATA_HANDLE hwInstData, S_TC_DATA *pData, EAS_I8 *pValue);
static void TC_PutBackChar (S_TC_DATA *pData, EAS_I8 value);
/* calculate a new tick time based on resolution & tempo */
EAS_INLINE void TC_CalcTimeBase (S_TC_DATA *pData)
{
/* ticks in 256ths of a millisecond */
pData->tick = ((60 * 1000) << 8) / (pData->tempo * pData->resolution);
}
/*----------------------------------------------------------------------------
*
* EAS_TC_Parser
*
* This structure contains the functional interface for the iMelody parser
*----------------------------------------------------------------------------
*/
const S_FILE_PARSER_INTERFACE EAS_TC_Parser =
{
TC_CheckFileType,
TC_Prepare,
TC_Time,
TC_Event,
TC_State,
TC_Close,
TC_Reset,
TC_Pause,
TC_Resume,
NULL,
TC_SetData,
TC_GetData,
NULL
};
/*----------------------------------------------------------------------------
* TC_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 TC_CheckFileType (S_EAS_DATA *pEASData, EAS_FILE_HANDLE fileHandle, EAS_VOID_PTR *ppHandle, EAS_I32 offset)
{
S_TC_DATA data;
S_TC_DATA *pData;
/* init data */
EAS_HWMemSet(&data, 0, sizeof(S_TC_DATA));
data.fileHandle = fileHandle;
data.fileOffset = offset;
*ppHandle= NULL;
/* see if we can parse the header */
if (TC_ParseHeader(pEASData, &data) == EAS_SUCCESS)
{
/* check for static memory allocation */
if (pEASData->staticMemoryModel)
pData = EAS_CMEnumOptData(EAS_MODULE_MMAPI_TONE_CONTROL);
else
pData = EAS_HWMalloc(pEASData->hwInstData, sizeof(S_TC_DATA));
if (!pData)
return EAS_ERROR_MALLOC_FAILED;
/* copy data to persistent storage */
EAS_HWMemCpy(pData, &data, sizeof(S_TC_DATA));
/* return a pointer to the instance data */
pData->state = EAS_STATE_OPEN;
*ppHandle = pData;
}
return EAS_SUCCESS;
}
/*----------------------------------------------------------------------------
* TC_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 TC_Prepare (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData)
{
S_TC_DATA* pData;
EAS_RESULT result;
/* check for valid state */
pData = (S_TC_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;
}
/* set to ready state */
pData->state = EAS_STATE_READY;
return EAS_SUCCESS;
}
/*----------------------------------------------------------------------------
* TC_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 TC_Time (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData, EAS_U32 *pTime)
{
S_TC_DATA *pData;
pData = (S_TC_DATA*) pInstData;
/* return time in milliseconds */
/*lint -e{704} use shift instead of division */
*pTime = pData->time >> 8;
return EAS_SUCCESS;
}
/*----------------------------------------------------------------------------
* TC_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 TC_Event (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData, EAS_INT parserMode)
{
S_TC_DATA* pData;
EAS_RESULT result;
EAS_I8 temp;
pData = (S_TC_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, TC_CHANNEL, TC_PROGRAM);
/* set channel volume to max */
VMControlChange(pEASData->pVoiceMgr, pData->pSynth, TC_CHANNEL, 7, 127);
}
/* check for end of note */
if (pData->note >= 0)
{
/* stop the note */
VMStopNote(pEASData->pVoiceMgr, pData->pSynth, TC_CHANNEL, (EAS_U8) pData->note, 0);
/* check for repeat note */
if (pData->repeatCount)
{
pData->repeatCount--;
pData->time += pData->length;
if ((pData->note >= 0) && (parserMode == eParserModePlay))
VMStartNote(pEASData->pVoiceMgr, pData->pSynth, TC_CHANNEL, (EAS_U8) pData->note, pData->volume);
return EAS_SUCCESS;
}
pData->note = TC_FIELD_SILENCE;
}
/* parse stream until we get a note or rest */
for (;;)
{
/* get next byte from stream */
if ((result = TC_GetNextChar(pEASData->hwInstData, pData, &temp)) != EAS_SUCCESS)
{
if (result == EAS_EOF)
{
pData->state = EAS_STATE_STOPPING;
return EAS_SUCCESS;
}
break;
}
/* check for musical events */
if (temp >= TC_FIELD_SILENCE)
{
result = TC_StartNote(pEASData, pData, parserMode, temp);
break;
}
/* must be a control field */
switch (temp)
{
case TC_FIELD_TEMPO:
result = TC_GetTempo(pEASData, pData);
break;
case TC_FIELD_RESOLUTION:
result = TC_GetResolution(pEASData, pData);
break;
case TC_FIELD_SET_VOLUME:
result = TC_GetVolume(pEASData, pData);
break;
case TC_FIELD_REPEAT:
result = TC_GetRepeat(pEASData, pData, parserMode);
break;
case TC_FIELD_PLAY_BLOCK:
result = TC_PlayBlock(pEASData, pData);
break;
case TC_FIELD_BLOCK_START:
result = TC_GetNextChar(pEASData->hwInstData, pData, &temp);
break;
case TC_FIELD_BLOCK_END:
result = TC_BlockEnd(pEASData, pData);
break;
default:
{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "Unexpected byte 0x%02x in ToneControl stream\n", temp); */ }
result = EAS_ERROR_FILE_FORMAT;
}
/* check for error */
if (result != EAS_SUCCESS)
break;
}
/* check for error */
if (result != EAS_SUCCESS)
{
if (result == EAS_EOF)
result = EAS_ERROR_FILE_FORMAT;
pData->state = EAS_STATE_ERROR;
}
else
pData->state = EAS_STATE_PLAY;
return result;
}
/*----------------------------------------------------------------------------
* TC_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 TC_State (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData, EAS_I32 *pState)
{
S_TC_DATA* pData;
/* establish pointer to instance data */
pData = (S_TC_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;
}
/*----------------------------------------------------------------------------
* TC_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 TC_Close (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData)
{
S_TC_DATA* pData;
EAS_RESULT result;
pData = (S_TC_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;
}
/*----------------------------------------------------------------------------
* TC_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 TC_Reset (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData)
{
S_TC_DATA* pData;
EAS_RESULT result;
pData = (S_TC_DATA*) pInstData;
/* reset the synth */
VMReset(pEASData->pVoiceMgr, pData->pSynth, EAS_TRUE);
/* reset time to zero */
pData->time = 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 = TC_ParseHeader (pEASData, pData)) != EAS_SUCCESS)
return result;
pData->state = EAS_STATE_READY;
return EAS_SUCCESS;
}
/*----------------------------------------------------------------------------
* TC_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 TC_Pause (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData)
{
S_TC_DATA *pData;
/* can't pause a stopped stream */
pData = (S_TC_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;
}
/*----------------------------------------------------------------------------
* TC_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 TC_Resume (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData)
{
S_TC_DATA *pData;
/* can't resume a stopped stream */
pData = (S_TC_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;
}
/*----------------------------------------------------------------------------
* TC_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, pInstData, value) reserved for future use */
static EAS_RESULT TC_SetData (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData, EAS_I32 param, EAS_I32 value)
{
/* we don't parse any metadata, but we need to return success here */
if (param == PARSER_DATA_METADATA_CB)
return EAS_SUCCESS;
return EAS_ERROR_INVALID_PARAMETER;
}
/*----------------------------------------------------------------------------
* TC_GetData()
*----------------------------------------------------------------------------
* Purpose:
* Return file type
*
* Inputs:
* pEASData - pointer to overall EAS data structure
* handle - pointer to file handle
*
* Outputs:
*
*
* Side Effects:
*
*----------------------------------------------------------------------------
*/
/*lint -e{715} common with other parsers */
static EAS_RESULT TC_GetData (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData, EAS_I32 param, EAS_I32 *pValue)
{
S_TC_DATA *pData;
pData = (S_TC_DATA *) pInstData;
switch (param)
{
/* return file type as TC */
case PARSER_DATA_FILE_TYPE:
*pValue = EAS_FILE_MMAPI_TONE_CONTROL;
break;
case PARSER_DATA_SYNTH_HANDLE:
*pValue = (EAS_I32) pData->pSynth;
break;
default:
return EAS_ERROR_INVALID_PARAMETER;
}
return EAS_SUCCESS;
}
/*----------------------------------------------------------------------------
* TC_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 TC_ParseHeader (S_EAS_DATA *pEASData, S_TC_DATA* pData)
{
EAS_RESULT result;
EAS_I8 temp;
/* initialize some defaults */
pData->time = 0;
pData->tempo = 120;
pData->resolution = 64;
pData->volume = 127;
pData->repeatCount = 0;
pData->note = TC_FIELD_SILENCE;
pData->byteAvail = EAS_FALSE;
/* set default timebase */
TC_CalcTimeBase(pData);
/* seek to start of data */
if ((result = EAS_HWFileSeek(pEASData->hwInstData, pData->fileHandle, pData->fileOffset)) != EAS_SUCCESS)
return result;
/* get version */
if ((result = TC_GetNextChar(pEASData->hwInstData, pData, &temp)) != EAS_SUCCESS)
return result;
/* check for version number */
if (temp == TC_FIELD_VERSION)
{
TC_GetNextChar(pEASData->hwInstData, pData, &temp);
// { /* dpp: EAS_ReportEx(_EAS_SEVERITY_INFO, "ToneControl sequence version %d\n", temp); */ }
}
else
return EAS_ERROR_FILE_FORMAT;
/* parse the header data until we find the first note or block */
for (;;)
{
/* get next byte from stream */
if ((result = TC_GetNextChar(pEASData->hwInstData, pData, &temp)) != EAS_SUCCESS)
return result;
/* check for tempo */
if (temp == TC_FIELD_TEMPO)
{
if ((result = TC_GetTempo(pEASData, pData)) != EAS_SUCCESS)
return result;
}
/* or resolution */
else if (temp == TC_FIELD_TEMPO)
{
if ((result = TC_GetResolution(pEASData, pData)) != EAS_SUCCESS)
return result;
}
/* must be music data */
else if (temp > TC_FIELD_INVALID)
{
TC_PutBackChar(pData, temp);
return EAS_SUCCESS;
}
/* unknown codes */
else
{
{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "Unexpected byte 0x%02x in ToneControl stream\n", temp); */ }
return EAS_ERROR_FILE_FORMAT;
}
}
}
/*----------------------------------------------------------------------------
* TC_StartNote()
*----------------------------------------------------------------------------
* Process a note or silence event
*----------------------------------------------------------------------------
*/
static EAS_RESULT TC_StartNote (S_EAS_DATA *pEASData, S_TC_DATA* pData, EAS_INT parserMode, EAS_I8 note)
{
EAS_I8 duration;
/* get the duration */
if (TC_GetNextChar(pEASData->hwInstData, pData, &duration) != EAS_SUCCESS)
return EAS_ERROR_FILE_FORMAT;
/* calculate time of next event */
pData->length = (EAS_I32) duration * pData->tick;
pData->time += pData->length;
/* start the note */
if ((note >= 0) && (parserMode == eParserModePlay))
{
VMStartNote(pEASData->pVoiceMgr, pData->pSynth, TC_CHANNEL, (EAS_U8) note, pData->volume);
pData->note = note;
}
return EAS_SUCCESS;
}
/*----------------------------------------------------------------------------
* TC_GetRepeat()
*----------------------------------------------------------------------------
* Process a repeat code
*----------------------------------------------------------------------------
*/
static EAS_RESULT TC_GetRepeat (S_EAS_DATA *pEASData, S_TC_DATA* pData, EAS_INT parserMode)
{
EAS_I8 count;
/* get the repeat count */
if (TC_GetNextChar(pEASData->hwInstData, pData, &count) != EAS_SUCCESS)
return EAS_ERROR_FILE_FORMAT;
/* validiate it */
if (count < 2)
return EAS_ERROR_FILE_FORMAT;
/* calculate time of next event */
pData->time += pData->length;
pData->repeatCount = count - 2;
/* start the note */
if ((pData->note >= 0) && (parserMode == eParserModePlay))
VMStartNote(pEASData->pVoiceMgr, pData->pSynth, TC_CHANNEL, (EAS_U8) pData->note, pData->volume);
return EAS_SUCCESS;
}
/*----------------------------------------------------------------------------
* TC_PlayBlock()
*----------------------------------------------------------------------------
* Play a block of notes
*----------------------------------------------------------------------------
*/
static EAS_RESULT TC_PlayBlock (S_EAS_DATA *pEASData, S_TC_DATA* pData)
{
EAS_RESULT result;
EAS_I8 blockNum;
EAS_I8 temp;
EAS_I8 temp2;
/* get the block number */
if (TC_GetNextChar(pEASData->hwInstData, pData, &blockNum) != EAS_SUCCESS)
return EAS_ERROR_FILE_FORMAT;
/* validiate it */
if (blockNum < 0)
return EAS_ERROR_FILE_FORMAT;
/* save the current position */
if ((result = EAS_HWFilePos(pEASData->hwInstData, pData->fileHandle, &pData->restorePos)) != EAS_SUCCESS)
return result;
/* return to start of file */
pData->byteAvail = EAS_FALSE;
if ((result = EAS_HWFileSeek(pEASData->hwInstData, pData->fileHandle, pData->fileOffset)) != EAS_SUCCESS)
return result;
/* find the block */
for (;;)
{
if (TC_GetNextChar(pEASData->hwInstData, pData, &temp) != EAS_SUCCESS)
return EAS_ERROR_FILE_FORMAT;
if (TC_GetNextChar(pEASData->hwInstData, pData, &temp2) != EAS_SUCCESS)
return EAS_ERROR_FILE_FORMAT;
if ((temp == TC_FIELD_BLOCK_START) && (temp2 == blockNum))
return EAS_SUCCESS;
}
}
/*----------------------------------------------------------------------------
* TC_BlockEnd()
*----------------------------------------------------------------------------
* Handle end of block
*----------------------------------------------------------------------------
*/
static EAS_RESULT TC_BlockEnd (S_EAS_DATA *pEASData, S_TC_DATA* pData)
{
EAS_I8 blockNum;
/* get the block number */
if (TC_GetNextChar(pEASData->hwInstData, pData, &blockNum) != EAS_SUCCESS)
return EAS_ERROR_FILE_FORMAT;
/* validiate it */
if (blockNum < 0)
return EAS_ERROR_FILE_FORMAT;
/* if we were playing this block, restore to previous position */
pData->byteAvail = EAS_FALSE;
return EAS_HWFileSeek(pEASData->hwInstData, pData->fileHandle, pData->restorePos);
}
/*----------------------------------------------------------------------------
* TC_GetVolume()
*----------------------------------------------------------------------------
* Get the volume field and process it
*----------------------------------------------------------------------------
*/
static EAS_RESULT TC_GetVolume (S_EAS_DATA *pEASData, S_TC_DATA* pData)
{
EAS_I8 volume;
/* get volume */
if (TC_GetNextChar(pEASData->hwInstData, pData, &volume) != EAS_SUCCESS)
return EAS_ERROR_FILE_FORMAT;
if ((volume < 0) || (volume > 100))
return EAS_ERROR_FILE_FORMAT;
/* save volume */
pData->volume = (EAS_U8) ((EAS_I32) (volume * TC_VOLUME_CONV + 1) >> TC_VOLUME_SHIFT);
return EAS_SUCCESS;
}
/*----------------------------------------------------------------------------
* TC_GetTempo()
*----------------------------------------------------------------------------
* Get the tempo field and process it
*----------------------------------------------------------------------------
*/
static EAS_RESULT TC_GetTempo (S_EAS_DATA *pEASData, S_TC_DATA* pData)
{
EAS_I8 tempo;
/* get tempo */
if (TC_GetNextChar(pEASData->hwInstData, pData, &tempo) != EAS_SUCCESS)
return EAS_ERROR_FILE_FORMAT;
if (tempo < 5)
return EAS_ERROR_FILE_FORMAT;
/* save tempo */
pData->tempo = tempo;
/* calculate new timebase */
TC_CalcTimeBase(pData);
return EAS_SUCCESS;
}
/*----------------------------------------------------------------------------
* TC_GetResolution()
*----------------------------------------------------------------------------
* Get the resolution field and process it
*----------------------------------------------------------------------------
*/
static EAS_RESULT TC_GetResolution (S_EAS_DATA *pEASData, S_TC_DATA* pData)
{
EAS_I8 resolution;
/* get resolution */
if (TC_GetNextChar(pEASData->hwInstData, pData, &resolution) != EAS_SUCCESS)
return EAS_ERROR_FILE_FORMAT;
if (resolution < 0)
return EAS_ERROR_FILE_FORMAT;
/* save tempo */
pData->resolution = resolution;
/* calculate new timebase */
TC_CalcTimeBase(pData);
return EAS_SUCCESS;
}
/*----------------------------------------------------------------------------
* TC_GetNextChar()
*----------------------------------------------------------------------------
* Fetch the next character from the stream
*----------------------------------------------------------------------------
*/
static EAS_RESULT TC_GetNextChar (EAS_HW_DATA_HANDLE hwInstData, S_TC_DATA *pData, EAS_I8 *pValue)
{
/* get character from "put back" buffer */
if (pData->byteAvail)
{
pData->byteAvail = EAS_FALSE;
*pValue = pData->dataByte;
return EAS_SUCCESS;
}
/* get character from file */
return EAS_HWGetByte(hwInstData, pData->fileHandle, pValue);
}
/*----------------------------------------------------------------------------
* TC_PutBackChar()
*----------------------------------------------------------------------------
* Put back the character
*----------------------------------------------------------------------------
*/
static void TC_PutBackChar (S_TC_DATA *pData, EAS_I8 value)
{
pData->dataByte = value;
pData->byteAvail = EAS_TRUE;
}