/*----------------------------------------------------------------------------
 *
 * 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;
	
	/* 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;
				
#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 invalid repeats */
				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;
}