/*----------------------------------------------------------------------------
 *
 * File: 
 * eas_ota.c
 *
 * Contents and purpose:
 * OTA 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_otadata.h"

/* increase gain for mono ringtones */
#define OTA_GAIN_OFFSET				8

/* file definitions */
#define OTA_RINGTONE 				0x25
#define OTA_SOUND 					0x1d
#define OTA_UNICODE					0x22

/* song type definitions */
#define OTA_BASIC_SONG_TYPE			0x01
#define OTA_TEMPORARY_SONG_TYPE		0x02

/* instruction ID coding */
#define OTA_PATTERN_HEADER_ID		0x00
#define OTA_NOTE_INST_ID			0x01
#define OTA_SCALE_INST_ID			0x02
#define OTA_STYLE_INST_ID			0x03
#define OTA_TEMPO_INST_ID			0x04
#define OTA_VOLUME_INST_ID			0x05

/* note durations */
#define OTA_NORMAL_DURATION			0x00
#define OTA_DOTTED_NOTE				0x01
#define OTA_DOUBLE_DOTTED_NOTE		0x02
#define OTA_TRIPLET_NOTE			0x03

/* loop count value for infinite loop */
#define OTA_INFINITE_LOOP			0x0f

/* length of 32nd note in 1/256ths of a msec for 63 BPM tempo */
#define DEFAULT_TICK_CONV			30476

/* default channel and program for OTA playback */
#define OTA_CHANNEL					0
#define OTA_PROGRAM					80
#define OTA_VEL_MUL					4
#define OTA_VEL_OFS					67
#define OTA_VEL_DEFAULT				95

/* multiplier for fixed point triplet conversion */
#define TRIPLET_MULTIPLIER			683
#define TRIPLET_SHIFT				10

/* local prototypes */
static EAS_RESULT OTA_CheckFileType (S_EAS_DATA *pEASData, EAS_FILE_HANDLE fileHandle, EAS_VOID_PTR *ppHandle, EAS_I32 offset);
static EAS_RESULT OTA_Prepare (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData);
static EAS_RESULT OTA_Time (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData, EAS_U32 *pTime);
static EAS_RESULT OTA_Event (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData, EAS_INT parserMode);
static EAS_RESULT OTA_State (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData, EAS_STATE *pState);
static EAS_RESULT OTA_Close (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData);
static EAS_RESULT OTA_Reset (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData);
static EAS_RESULT OTA_Pause (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData);
static EAS_RESULT OTA_Resume (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData);
static EAS_RESULT OTA_SetData (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData, EAS_I32 param, EAS_I32 value);
static EAS_RESULT OTA_GetData (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData, EAS_I32 param, EAS_I32 *pValue);
static EAS_RESULT OTA_ParseHeader (S_EAS_DATA *pEASData, S_OTA_DATA* pData);
static EAS_RESULT OTA_FetchBitField (EAS_HW_DATA_HANDLE hwInstData, S_OTA_DATA *pData, EAS_I32 numBits, EAS_U8 *pValue);
static EAS_RESULT OTA_SavePosition (EAS_HW_DATA_HANDLE hwInstData, S_OTA_DATA *pData, S_OTA_LOC *pLoc);
static EAS_RESULT OTA_RestorePosition (EAS_HW_DATA_HANDLE hwInstData, S_OTA_DATA *pData, S_OTA_LOC *pLoc);


/*----------------------------------------------------------------------------
 *
 * EAS_OTA_Parser
 *
 * This structure contains the functional interface for the OTA parser 
 *----------------------------------------------------------------------------
*/
const S_FILE_PARSER_INTERFACE EAS_OTA_Parser =
{
	OTA_CheckFileType,
	OTA_Prepare,
	OTA_Time,
	OTA_Event,
	OTA_State,
	OTA_Close,
	OTA_Reset,
	OTA_Pause,
	OTA_Resume,
	NULL,
	OTA_SetData,
	OTA_GetData,
	NULL
};

/*----------------------------------------------------------------------------
 *
 * bpmTable
 *
 * BPM conversion table. Converts bpm values to 256ths of a millisecond for a 32nd note 
 *----------------------------------------------------------------------------
*/
static const EAS_U32 bpmTable[32] =
{
	76800, 68571, 61935, 54857, 
	48000, 42667, 38400, 34286,
	30476, 27429, 24000, 21333,
	19200, 17143, 15360, 13714,
	12000, 10667, 9600, 8533,
	7680, 6737, 6000, 5408,
	4800, 4267, 3840, 3398,
	3024, 2685, 2400, 2133
};

/*----------------------------------------------------------------------------
 * OTA_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 OTA_CheckFileType (S_EAS_DATA *pEASData, EAS_FILE_HANDLE fileHandle, EAS_VOID_PTR *ppHandle, EAS_I32 offset)
{
	S_OTA_DATA* pData;
	EAS_RESULT result;
	EAS_INT cmdLen;
	EAS_INT state;
	EAS_U8 temp;
	
	/* read the first byte, should be command length */
	*ppHandle = NULL;
	if ((result = EAS_HWGetByte(pEASData->hwInstData, fileHandle, &temp)) != EAS_SUCCESS)
		return result;

	/* read all the commands */
	cmdLen = temp;
	state = 0;
	while (cmdLen--)
	{
	
		/* read the command, upper 7 bits */	
		if ((result = EAS_HWGetByte(pEASData->hwInstData, fileHandle, &temp)) != EAS_SUCCESS)
			return result;
		temp = temp >> 1;

		if (state == 0)
		{
			if (temp != OTA_RINGTONE)
				break;
			state++;
		}
		else
		{
	
			if (temp == OTA_SOUND)
			{
				
				/* check for static memory allocation */
				if (pEASData->staticMemoryModel)
					pData = EAS_CMEnumData(EAS_CM_OTA_DATA);
				else
					pData = EAS_HWMalloc(pEASData->hwInstData, sizeof(S_OTA_DATA));
				if (!pData)
				{
					{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "Malloc failed in OTA_Prepare\n"); */ }
					return EAS_ERROR_MALLOC_FAILED;
				}
				EAS_HWMemSet(pData, 0, sizeof(S_OTA_DATA));

				/* return a pointer to the instance data */
				pData->fileHandle = fileHandle;
				pData->fileOffset = offset;
				pData->state = EAS_STATE_OPEN;
				*ppHandle = pData;
				break;
			}

			if (temp != OTA_UNICODE)
				break;
		}
	}

	/* not recognized */
	return EAS_SUCCESS;
}

/*----------------------------------------------------------------------------
 * OTA_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 OTA_Prepare (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData)
{
	S_OTA_DATA* pData;
	EAS_RESULT result;

	/* check for valid state */
	pData = (S_OTA_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 = OTA_ParseHeader(pEASData, pData)) != EAS_SUCCESS)
		return result;

	pData->state = EAS_STATE_READY;
	return EAS_SUCCESS;
}

/*----------------------------------------------------------------------------
 * OTA_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 OTA_Time (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData, EAS_U32 *pTime)
{
	S_OTA_DATA *pData;
	
	pData = (S_OTA_DATA*) pInstData;

	/* return time in milliseconds */
	/*lint -e{704} use shift instead of division */
	*pTime = pData->time >> 8;
	return EAS_SUCCESS;
}

/*----------------------------------------------------------------------------
 * OTA_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 OTA_Event (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData, EAS_INT parserMode)
{
	S_OTA_DATA* pData;
	EAS_RESULT result;
	EAS_U32 duration;
	EAS_U8 temp;

	pData = (S_OTA_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 */
		if (parserMode != eParserModeMetaData)
			VMProgramChange(pEASData->pVoiceMgr, pData->pSynth, OTA_CHANNEL, OTA_PROGRAM);

		/* set channel volume to max */
		if (parserMode != eParserModeMetaData)
			VMControlChange(pEASData->pVoiceMgr, pData->pSynth, OTA_CHANNEL, 7, 127);
	}

	/* check for end of note */
	if (pData->note)
	{
		/* stop the note */
		VMStopNote(pEASData->pVoiceMgr, pData->pSynth, OTA_CHANNEL, pData->note, 0);
		pData->note = 0;

		/* check for rest between notes */
		if (pData->restTicks)
		{
			pData->time += (EAS_I32) pData->restTicks;
			pData->restTicks = 0;
			return EAS_SUCCESS;
		}
	}

	/* if not in a pattern, read the pattern header */
	while (pData->current.patternLen == 0)
	{

		/* check for loop - don't do infinite loops when locating */
		if (pData->loopCount && ((parserMode == eParserModePlay) || (pData->loopCount != OTA_INFINITE_LOOP)))
		{
			/* if not infinite loop, decrement loop count */
			if (pData->loopCount != OTA_INFINITE_LOOP)
				pData->loopCount--;
			
			/* back to start of pattern*/
			if ((result = OTA_RestorePosition(pEASData->hwInstData, pData, &pData->patterns[pData->currentPattern])) != EAS_SUCCESS)
				return result;
		}

		/* if no previous position to restore, continue forward */
		else if (pData->restore.fileOffset < 0)
		{
		
			/* check for end of song */
			if (pData->numPatterns == 0)
			{
				pData->state = EAS_STATE_STOPPING;
				VMReleaseAllVoices(pEASData->pVoiceMgr, pData->pSynth);
				return EAS_SUCCESS;
			}

			/* read the next pattern header */
			if ((result = OTA_FetchBitField(pEASData->hwInstData, pData, 3, &temp)) != EAS_SUCCESS)
				return result;
			if (temp != OTA_PATTERN_HEADER_ID)
			{
				{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "Expected OTA pattern header\n"); */ }
				return EAS_ERROR_FILE_FORMAT;
			}

			/* get the pattern ID */
			if ((result = OTA_FetchBitField(pEASData->hwInstData, pData, 2, &pData->currentPattern)) != EAS_SUCCESS)
				return result;

			/* get the loop count */
			if ((result = OTA_FetchBitField(pEASData->hwInstData, pData, 4, &pData->loopCount)) != EAS_SUCCESS)
				return result;

			/* get the pattern length */
			if ((result = OTA_FetchBitField(pEASData->hwInstData, pData, 8, &pData->current.patternLen)) != EAS_SUCCESS)
				return result;

			/* if pattern definition, save the current position */
			if (pData->current.patternLen)
			{
				if ((result = OTA_SavePosition(pEASData->hwInstData, pData, &pData->patterns[pData->currentPattern])) != EAS_SUCCESS)
					return result;
			}
				
			/* if pattern length is zero, repeat a previous pattern */
			else
			{
				/* make sure it's a valid pattern */
				if (pData->patterns[pData->currentPattern].fileOffset < 0)
				{
					{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "OTA pattern error, invalid pattern specified\n"); */ }
					return EAS_ERROR_FILE_FORMAT;
				}

				/* save current position and data */
				if ((result = OTA_SavePosition(pEASData->hwInstData, pData, &pData->restore)) != EAS_SUCCESS)
					return result;

				/* seek to the pattern in the file */
				if ((result = OTA_RestorePosition(pEASData->hwInstData, pData, &pData->patterns[pData->currentPattern])) != EAS_SUCCESS)
					return result;
			}

			/* decrement pattern count */
			pData->numPatterns--;
		}

		/* restore previous position */
		else
		{
			if ((result = OTA_RestorePosition(pEASData->hwInstData, pData, &pData->restore)) != EAS_SUCCESS)
				return result;
		}
	}

	/* get the next event */
	if ((result = OTA_FetchBitField(pEASData->hwInstData, pData, 3, &temp)) != EAS_SUCCESS)
		return result;

	switch (temp)
	{
		case OTA_NOTE_INST_ID:
			/* fetch note value */
			if ((result = OTA_FetchBitField(pEASData->hwInstData, pData, 4, &pData->note)) != EAS_SUCCESS)
				return result;
			
			/* fetch note duration */
			if ((result = OTA_FetchBitField(pEASData->hwInstData, pData, 3, &temp)) != EAS_SUCCESS)
				return result;
			duration = pData->tick * (0x20 >> temp); 
			
			/* fetch note duration modifier */
			if ((result = OTA_FetchBitField(pEASData->hwInstData, pData, 2, &temp)) != EAS_SUCCESS)
				return result;
			switch (temp)
			{
				case OTA_NORMAL_DURATION:
					break;
					
				case OTA_DOTTED_NOTE:
					duration += duration >> 1;
					break;

				case OTA_DOUBLE_DOTTED_NOTE:
					duration += (duration >> 1) + (duration >> 2);
					break;

				case OTA_TRIPLET_NOTE:
					duration = (duration * TRIPLET_MULTIPLIER) >> TRIPLET_SHIFT;
					break;

				default:
					{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_WARNING, "Unrecognized note duration ignored\n"); */ }
					break;
			}

			/* check for note */
			if (pData->note)
			{
				
				/* determine note length based on style */
				switch (pData->style)
				{
					case 0:
						pData->restTicks = duration >> 4;
						break;
					case 1:
						pData->restTicks = 0;
						break;
					case 2:
						pData->restTicks = duration >> 1;
						break;
					default:
						{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_WARNING, "Unrecognized note style ignored\n"); */ }
				}

				/* add octave */
				pData->note += pData->octave;
				if (parserMode == eParserModePlay)
					VMStartNote(pEASData->pVoiceMgr, pData->pSynth, OTA_CHANNEL, pData->note, pData->velocity);
				pData->time += (EAS_I32) duration - (EAS_I32) pData->restTicks;
			}
			
			/* this is a rest */
			else
				pData->time += (EAS_I32) duration;
			break;
			
		case OTA_SCALE_INST_ID:
			/* fetch octave */
			if ((result = OTA_FetchBitField(pEASData->hwInstData, pData, 2, &temp)) != EAS_SUCCESS)
				return result;
			pData->octave = (EAS_U8) (temp * 12 + 59);
			break;

		case OTA_STYLE_INST_ID:
			/* fetch note style */
			if ((result = OTA_FetchBitField(pEASData->hwInstData, pData, 2, &pData->style)) != EAS_SUCCESS)
				return result;
			break;

		case OTA_TEMPO_INST_ID:
			/* fetch tempo */
			if ((result = OTA_FetchBitField(pEASData->hwInstData, pData, 5, &temp)) != EAS_SUCCESS)
				return result;
			pData->tick = bpmTable[temp];
			break;

		case OTA_VOLUME_INST_ID:
			/* fetch volume */
			if ((result = OTA_FetchBitField(pEASData->hwInstData, pData, 4, &temp)) != EAS_SUCCESS)
				return result;
			pData->velocity = temp ? (EAS_U8) (temp * OTA_VEL_MUL + OTA_VEL_OFS) : 0;
			break;

		default:
			{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "Unexpected instruction ID in OTA stream\n"); */ }
			return EAS_ERROR_FILE_FORMAT;
	}

	/* decrement pattern length */
	pData->current.patternLen--;
	return EAS_SUCCESS;
}
		
/*----------------------------------------------------------------------------
 * OTA_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 OTA_State (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData, EAS_I32 *pState)
{
	S_OTA_DATA* pData;

	/* establish pointer to instance data */
	pData = (S_OTA_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;
}

/*----------------------------------------------------------------------------
 * OTA_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 OTA_Close (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData)
{
	S_OTA_DATA* pData;
	EAS_RESULT result;

	pData = (S_OTA_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;
}

/*----------------------------------------------------------------------------
 * OTA_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 OTA_Reset (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData)
{
	S_OTA_DATA* pData;
	EAS_RESULT result;

	pData = (S_OTA_DATA*) pInstData;

	/* reset the synth */
	VMReset(pEASData->pVoiceMgr, pData->pSynth, EAS_TRUE);
	pData->note = 0;

	/* reset file position and re-parse header */
	pData->state = EAS_STATE_ERROR;
	if ((result = OTA_ParseHeader (pEASData,  pData)) != EAS_SUCCESS)
		return result;

	pData->state = EAS_STATE_READY;
	return EAS_SUCCESS;
}

/*----------------------------------------------------------------------------
 * OTA_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 OTA_Pause (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData)
{
	S_OTA_DATA *pData;

	/* can't pause a stopped stream */
	pData = (S_OTA_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;
}

/*----------------------------------------------------------------------------
 * OTA_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 OTA_Resume (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData)
{
	S_OTA_DATA *pData;

	/* can't resume a stopped stream */
	pData = (S_OTA_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;
}

/*----------------------------------------------------------------------------
 * OTA_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) common decoder interface - pEASData not used */
static EAS_RESULT OTA_SetData (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData, EAS_I32 param, EAS_I32 value)
{
	S_OTA_DATA *pData;

	pData = (S_OTA_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;
}

/*----------------------------------------------------------------------------
 * OTA_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) common decoder interface - pEASData not used */
static EAS_RESULT OTA_GetData (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData, EAS_I32 param, EAS_I32 *pValue)
{
	S_OTA_DATA *pData;

	pData = (S_OTA_DATA*) pInstData;
	switch (param)
	{
		/* return file type as OTA */
		case PARSER_DATA_FILE_TYPE:
			*pValue = EAS_FILE_OTA;
			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 = OTA_GAIN_OFFSET;
			break;
			
		default:
			return EAS_ERROR_INVALID_PARAMETER;
	}			
	return EAS_SUCCESS;
}

/*----------------------------------------------------------------------------
 * OTA_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 OTA_ParseHeader (S_EAS_DATA *pEASData, S_OTA_DATA* pData)
{
	EAS_RESULT result;
	EAS_INT i;
	EAS_INT state;
	EAS_U8 temp;
	EAS_U8 titleLen;

	/* initialize some data */
	pData->flags = 0;
	pData->time = 0;
	pData->tick = DEFAULT_TICK_CONV;
	pData->patterns[0].fileOffset = pData->patterns[1].fileOffset =
		pData->patterns[2].fileOffset = pData->patterns[3].fileOffset = -1;
	pData->current.bitCount = 0;
	pData->current.patternLen = 0;
	pData->loopCount = 0;
	pData->restore.fileOffset = -1;
	pData->note = 0;
	pData->restTicks = 0;
	pData->velocity = OTA_VEL_DEFAULT;
	pData->style = 0;
	pData->octave = 59;

	/* seek to start of data */
	if ((result = EAS_HWFileSeek(pEASData->hwInstData, pData->fileHandle, pData->fileOffset)) != EAS_SUCCESS)
		return result;

	/* read the first byte, should be command length */
	if ((result = EAS_HWGetByte(pEASData->hwInstData, pData->fileHandle, &temp)) != EAS_SUCCESS)
		return result;

	/* read all the commands */
	i = temp;
	state = 0;
	while (i--)
	{

		/* fetch command, always starts on byte boundary */
		pData->current.bitCount = 0;
		if ((result = OTA_FetchBitField(pEASData->hwInstData, pData, 7, &temp)) != EAS_SUCCESS)
			return result;

		if (state == 0)
		{
			if (temp != OTA_RINGTONE)
			{
				{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "Expected OTA Ring Tone Programming type\n"); */ }
				return EAS_ERROR_FILE_FORMAT;
			}
			state++;
		}
		else
		{
	
			if (temp == OTA_SOUND)
				break;

			if (temp == OTA_UNICODE)
				pData->flags |= OTA_FLAGS_UNICODE;
			else
			{
				{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "Expected OTA Sound or Unicode type\n"); */ }
				return EAS_ERROR_FILE_FORMAT;
			}
		}
	}

	/* get song type */
	if ((result = OTA_FetchBitField(pEASData->hwInstData, pData, 3, &temp)) != EAS_SUCCESS)
		return result;

	/* check for basic song type */
	if (temp == OTA_BASIC_SONG_TYPE)
	{
		/* fetch title length */
		if ((result = OTA_FetchBitField(pEASData->hwInstData, pData, 4, &titleLen)) != EAS_SUCCESS)
			return result;

		/* if unicode, double the length */
		if (pData->flags & OTA_FLAGS_UNICODE)
			titleLen = (EAS_U8) (titleLen << 1);

		/* zero the metadata buffer */
		if (pData->metadata.buffer)
			EAS_HWMemSet(pData->metadata.buffer, 0, pData->metadata.bufferSize);
	
		/* read the song title */
		for (i = 0; i < titleLen; i++)
		{
			/* fetch character */
			if ((result = OTA_FetchBitField(pEASData->hwInstData, pData, 8, &temp)) != EAS_SUCCESS)
				return result;
			
			/* check for metadata callback */
			if (pData->metadata.callback)
			{
				if (i < (pData->metadata.bufferSize - 1))
					pData->metadata.buffer[i] = (char) temp;
			}
		}

		/* if host has registered callback, call it now */
		if (pData->metadata.callback)
			(*pData->metadata.callback)(EAS_METADATA_TITLE, pData->metadata.buffer, pData->metadata.pUserData);
	}

	/* must be temporary song */
	else if (temp != OTA_TEMPORARY_SONG_TYPE)
	{
		{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "Expected OTA basic or temporary song type\n"); */ }
		return EAS_ERROR_FILE_FORMAT;
	}

	/* get the song length */
	if ((result = OTA_FetchBitField(pEASData->hwInstData, pData, 8, &pData->numPatterns)) != EAS_SUCCESS)
		return result;

	/* sanity check */
	if (pData->numPatterns == 0)
	{
		{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "OTA number of patterns is zero\n"); */ }
		return EAS_ERROR_FILE_FORMAT;
	}

	/* at start of first pattern */
	return EAS_SUCCESS;
}

/*----------------------------------------------------------------------------
 * OTA_FetchBitField()
 *----------------------------------------------------------------------------
 * Purpose: 
 * Fetch a specified number of bits from the input stream
 *
 * Inputs:
 * 
 *		
 * Outputs:
 * 
 *
 * Side Effects:
 *
 *----------------------------------------------------------------------------
*/
static EAS_RESULT OTA_FetchBitField (EAS_HW_DATA_HANDLE hwInstData, S_OTA_DATA *pData, EAS_I32 numBits, EAS_U8 *pValue)
{
	EAS_RESULT result;
	EAS_I32 bitsLeft;
	EAS_U8 value;

	value = 0;
	
	/* do we have enough bits? */
	bitsLeft = pData->current.bitCount - numBits;

	/* not enough bits, assemble them from 2 characters */
	if (bitsLeft < 0)
	{
		/* grab the remaining bits from the previous byte */
		if (pData->current.bitCount)
			/*lint -e{504,734} this is a legitimate shift operation */
			value = pData->current.dataByte << -bitsLeft;

		/* read the next byte */
		if ((result = EAS_HWGetByte(hwInstData, pData->fileHandle, &pData->current.dataByte)) != EAS_SUCCESS)
			return result;
		bitsLeft += 8;
	}

	/* more bits than needed? */
	if (bitsLeft > 0)
	{
		value |= pData->current.dataByte >> bitsLeft;
		pData->current.bitCount = (EAS_U8) bitsLeft;
		pData->current.dataByte = pData->current.dataByte & (0xff >> (8 - bitsLeft));
	}

	/* exactly the right number of bits */
	else
	{
		value |= pData->current.dataByte;
		pData->current.bitCount = 0;
	}

	*pValue = value;
	return EAS_SUCCESS;
}

/*----------------------------------------------------------------------------
 * OTA_SavePosition()
 *----------------------------------------------------------------------------
 * Purpose: 
 * 
 *
 * Inputs:
 * 
 *		
 * Outputs:
 * 
 *
 * Side Effects:
 *
 *----------------------------------------------------------------------------
*/
static EAS_RESULT OTA_SavePosition (EAS_HW_DATA_HANDLE hwInstData, S_OTA_DATA *pData, S_OTA_LOC *pLoc)
{
	EAS_HWMemCpy(pLoc, &pData->current, sizeof(S_OTA_LOC));
	return EAS_HWFilePos(hwInstData, pData->fileHandle, &pLoc->fileOffset);
}

/*----------------------------------------------------------------------------
 * OTA_RestorePosition()
 *----------------------------------------------------------------------------
 * Purpose: 
 * 
 *
 * Inputs:
 * 
 *		
 * Outputs:
 * 
 *
 * Side Effects:
 *
 *----------------------------------------------------------------------------
*/
static EAS_RESULT OTA_RestorePosition (EAS_HW_DATA_HANDLE hwInstData, S_OTA_DATA *pData, S_OTA_LOC *pLoc)
{
	EAS_HWMemCpy(&pData->current, pLoc, sizeof(S_OTA_LOC));
	pData->restore.fileOffset = -1;
	return EAS_HWFileSeek(hwInstData, pData->fileHandle, pLoc->fileOffset);
}