/*----------------------------------------------------------------------------
 *
 * File: 
 * eas_public.c
 *
 * Contents and purpose:
 * Contains EAS library public interface
 *			
 * Copyright Sonic Network Inc. 2004

 * 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: 842 $
 *   $Date: 2007-08-23 14:32:31 -0700 (Thu, 23 Aug 2007) $
 *----------------------------------------------------------------------------
*/

#include "eas_synthcfg.h"
#include "eas.h"
#include "eas_config.h"
#include "eas_host.h"
#include "eas_report.h"
#include "eas_data.h"
#include "eas_parser.h"
#include "eas_pcm.h"
#include "eas_midi.h"
#include "eas_mixer.h"
#include "eas_build.h"
#include "eas_vm_protos.h"
#include "eas_math.h"

#ifdef JET_INTERFACE
#include "jet_data.h"
#endif

#ifdef DLS_SYNTHESIZER
#include "eas_mdls.h"
#endif

/* number of events to parse before calling EAS_HWYield function */
#define YIELD_EVENT_COUNT		10

/*----------------------------------------------------------------------------
 * easLibConfig
 *
 * This structure is available through the EAS public interface to allow
 * the user to check the configuration of the library.
 *----------------------------------------------------------------------------
*/
static const S_EAS_LIB_CONFIG easLibConfig =
{
	LIB_VERSION,
#ifdef _CHECKED_BUILD
	EAS_TRUE,
#else
	EAS_FALSE,
#endif
	MAX_SYNTH_VOICES,
	NUM_OUTPUT_CHANNELS,
	_OUTPUT_SAMPLE_RATE,
	BUFFER_SIZE_IN_MONO_SAMPLES,
#ifdef _FILTER_ENABLED
	EAS_TRUE,
#else
	EAS_FALSE,
#endif
	_BUILD_TIME_,
	_BUILD_VERSION_
};

/* local prototypes */
static EAS_RESULT EAS_ParseEvents (S_EAS_DATA *pEASData, S_EAS_STREAM *pStream, EAS_U32 endTime, EAS_INT parseMode);

/*----------------------------------------------------------------------------
 * EAS_SetStreamParameter
 *----------------------------------------------------------------------------
 * Sets the specified parameter in the stream. Allows access to
 * customizable settings within the individual file parsers.
 *----------------------------------------------------------------------------
 * pEASData			- pointer to EAS persistent data object
 * pStream			- stream handle
 * param			- enumerated parameter (see eas_parser.h)
 * value			- new value
 *----------------------------------------------------------------------------
*/
EAS_RESULT EAS_SetStreamParameter (S_EAS_DATA *pEASData, EAS_HANDLE pStream, EAS_I32 param, EAS_I32 value)
{
	S_FILE_PARSER_INTERFACE *pParserModule;

	pParserModule = (S_FILE_PARSER_INTERFACE*) pStream->pParserModule;
	if (pParserModule->pfSetData)
		return (*pParserModule->pfSetData)(pEASData, pStream->handle, param, value);
	return EAS_ERROR_FEATURE_NOT_AVAILABLE;
}

/*----------------------------------------------------------------------------
 * EAS_GetStreamParameter
 *----------------------------------------------------------------------------
 * Sets the specified parameter in the stream. Allows access to
 * customizable settings within the individual file parsers.
 *----------------------------------------------------------------------------
 * pEASData			- pointer to EAS persistent data object
 * pStream			- stream handle
 * param			- enumerated parameter (see eas_parser.h)
 * pValue			- pointer to variable to receive current setting
 *----------------------------------------------------------------------------
*/
EAS_RESULT EAS_GetStreamParameter (S_EAS_DATA *pEASData, EAS_HANDLE pStream, EAS_I32 param, EAS_I32 *pValue)
{
	S_FILE_PARSER_INTERFACE *pParserModule;

	pParserModule = (S_FILE_PARSER_INTERFACE*) pStream->pParserModule;
	if (pParserModule->pfGetData)
		return (*pParserModule->pfGetData)(pEASData, pStream->handle, param, pValue);
	return EAS_ERROR_FEATURE_NOT_AVAILABLE;
}

/*----------------------------------------------------------------------------
 * EAS_StreamReady()
 *----------------------------------------------------------------------------
 * This routine sets common parameters like transpose, volume, etc.
 * First, it attempts to use the parser EAS_SetStreamParameter interface. If that
 * fails, it attempts to get the synth handle from the parser and
 * set the parameter directly on the synth. This eliminates duplicate
 * code in the parser.
 *----------------------------------------------------------------------------
*/
EAS_BOOL EAS_StreamReady (S_EAS_DATA *pEASData, EAS_HANDLE pStream)
{
	S_FILE_PARSER_INTERFACE *pParserModule;
	EAS_STATE state;

	pParserModule = (S_FILE_PARSER_INTERFACE*) pStream->pParserModule;
	if (pParserModule->pfState(pEASData, pStream->handle, &state) != EAS_SUCCESS)
		return EAS_FALSE;
	return (state < EAS_STATE_OPEN);
}

/*----------------------------------------------------------------------------
 * EAS_IntSetStrmParam()
 *----------------------------------------------------------------------------
 * This routine sets common parameters like transpose, volume, etc.
 * First, it attempts to use the parser EAS_SetStreamParameter interface. If that
 * fails, it attempts to get the synth handle from the parser and
 * set the parameter directly on the synth. This eliminates duplicate
 * code in the parser.
 *----------------------------------------------------------------------------
*/
EAS_RESULT EAS_IntSetStrmParam (S_EAS_DATA *pEASData, EAS_HANDLE pStream, EAS_INT param, EAS_I32 value)
{
	S_SYNTH *pSynth;
	
	/* try to set the parameter using stream interface */
	if (EAS_SetStreamParameter(pEASData, pStream, param, value) == EAS_SUCCESS)
		return EAS_SUCCESS;

	/* get a pointer to the synth object and set it directly */
	/*lint -e{740} we are cheating by passing a pointer through this interface */
	if (EAS_GetStreamParameter(pEASData, pStream, PARSER_DATA_SYNTH_HANDLE, (EAS_I32*) &pSynth) != EAS_SUCCESS)
		return EAS_ERROR_INVALID_PARAMETER;

	if (pSynth == NULL)
		return EAS_ERROR_INVALID_PARAMETER;

	switch (param)
	{

#ifdef DLS_SYNTHESIZER		
		case PARSER_DATA_DLS_COLLECTION:
			{
				EAS_RESULT result = VMSetDLSLib(pSynth, (EAS_DLSLIB_HANDLE) value);
				if (result == EAS_SUCCESS)
				{
					DLSAddRef((S_DLS*) value);
					VMInitializeAllChannels(pEASData->pVoiceMgr, pSynth);
				}
				return result;
			}
#endif

		case PARSER_DATA_EAS_LIBRARY:
			return VMSetEASLib(pSynth, (EAS_SNDLIB_HANDLE) value);
			
		case PARSER_DATA_POLYPHONY:
			return VMSetPolyphony(pEASData->pVoiceMgr, pSynth, value);
				
		case PARSER_DATA_PRIORITY:
			return VMSetPriority(pEASData->pVoiceMgr, pSynth, value);
			
		case PARSER_DATA_TRANSPOSITION:
			VMSetTranposition(pSynth, value);
			break;
			
		case PARSER_DATA_VOLUME:
			VMSetVolume(pSynth, (EAS_U16) value);
			break;
			
		default:
			{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "Invalid paramter %d in call to EAS_IntSetStrmParam", param); */ }
			return EAS_ERROR_INVALID_PARAMETER;
	}
	
	return EAS_SUCCESS;
}

/*----------------------------------------------------------------------------
 * EAS_IntGetStrmParam()
 *----------------------------------------------------------------------------
 * This routine gets common parameters like transpose, volume, etc.
 * First, it attempts to use the parser EAS_GetStreamParameter interface. If that
 * fails, it attempts to get the synth handle from the parser and
 * get the parameter directly on the synth.
 *----------------------------------------------------------------------------
*/
EAS_RESULT EAS_IntGetStrmParam (S_EAS_DATA *pEASData, EAS_HANDLE pStream, EAS_INT param, EAS_I32 *pValue)
{
	S_SYNTH *pSynth;

	/* try to set the parameter */
	if (EAS_GetStreamParameter(pEASData, pStream, param, pValue) == EAS_SUCCESS)
		return EAS_SUCCESS;
	
	/* get a pointer to the synth object and retrieve data directly */
	/*lint -e{740} we are cheating by passing a pointer through this interface */
	if (EAS_GetStreamParameter(pEASData, pStream, PARSER_DATA_SYNTH_HANDLE, (EAS_I32*) &pSynth) != EAS_SUCCESS)
		return EAS_ERROR_INVALID_PARAMETER;

	if (pSynth == NULL)
		return EAS_ERROR_INVALID_PARAMETER;

	switch (param)
	{
		case PARSER_DATA_POLYPHONY:
			return VMGetPolyphony(pEASData->pVoiceMgr, pSynth, pValue);
				
		case PARSER_DATA_PRIORITY:
			return VMGetPriority(pEASData->pVoiceMgr, pSynth, pValue);
			
		case PARSER_DATA_TRANSPOSITION:
			VMGetTranposition(pSynth, pValue);
			break;

		case PARSER_DATA_NOTE_COUNT:
			*pValue = VMGetNoteCount(pSynth);
			break;
			
		default:
			{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "Invalid paramter %d in call to EAS_IntSetStrmParam", param); */ }
			return EAS_ERROR_INVALID_PARAMETER;
	}
	
	return EAS_SUCCESS;
}

/*----------------------------------------------------------------------------
 * EAS_AllocateStream()
 *----------------------------------------------------------------------------
 * Purpose:
 * Allocates a stream handle
 *
 * Inputs:
 *
 * Outputs:
 *
 *----------------------------------------------------------------------------
*/
static EAS_INT EAS_AllocateStream (EAS_DATA_HANDLE pEASData)
{
	EAS_INT streamNum;
	
	/* check for static allocation, only one stream allowed */
	if (pEASData->staticMemoryModel)
	{
		if (pEASData->streams[0].handle != NULL)
		{
			{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "Attempt to open multiple streams in static model\n"); */ }
			return -1;
		}
		return 0;
	}

	/* dynamic model */
	for (streamNum = 0; streamNum < MAX_NUMBER_STREAMS; streamNum++)
		if (pEASData->streams[streamNum].handle == NULL)
			break;
	if (streamNum == MAX_NUMBER_STREAMS)
	{
		{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "Exceeded maximum number of open streams\n"); */ }
		return -1;
	}
	return streamNum;
}

/*----------------------------------------------------------------------------
 * EAS_InitStream()
 *----------------------------------------------------------------------------
 * Purpose:
 * Initialize a stream
 *
 * Inputs:
 *
 * Outputs:
 *
 *----------------------------------------------------------------------------
*/
static void EAS_InitStream (S_EAS_STREAM *pStream, EAS_VOID_PTR pParserModule, EAS_VOID_PTR streamHandle)
{
	pStream->pParserModule = pParserModule;
	pStream->handle = streamHandle;
	pStream->time = 0;
	pStream->frameLength = AUDIO_FRAME_LENGTH;
	pStream->repeatCount = 0;
	pStream->volume = DEFAULT_STREAM_VOLUME;
}

/*----------------------------------------------------------------------------
 * EAS_Config()
 *----------------------------------------------------------------------------
 * Purpose:
 * Returns a pointer to a structure containing the configuration options
 * in this library build.
 *
 * Inputs:
 *
 * Outputs:
 *
 *----------------------------------------------------------------------------
*/
EAS_PUBLIC const S_EAS_LIB_CONFIG *EAS_Config (void)
{
	return &easLibConfig;
}

/*----------------------------------------------------------------------------
 * EAS_Init()
 *----------------------------------------------------------------------------
 * Purpose:
 * Initialize the synthesizer library
 *
 * Inputs:
 *	ppEASData		- pointer to data handle variable for this instance
 *
 * Outputs:
 *
 *----------------------------------------------------------------------------
*/
EAS_PUBLIC EAS_RESULT EAS_Init (EAS_DATA_HANDLE *ppEASData)
{
	EAS_HW_DATA_HANDLE pHWInstData;
	EAS_RESULT result;
	S_EAS_DATA *pEASData;
	EAS_INT module;
	EAS_BOOL staticMemoryModel;

	/* get the memory model */
	staticMemoryModel = EAS_CMStaticMemoryModel();

	/* initialize the host wrapper interface */
	*ppEASData = NULL;
	if ((result = EAS_HWInit(&pHWInstData)) != EAS_SUCCESS)
		return result;

	/* check Configuration Module for S_EAS_DATA allocation */
	if (staticMemoryModel)
		pEASData = EAS_CMEnumData(EAS_CM_EAS_DATA);
	else
		pEASData = EAS_HWMalloc(pHWInstData, sizeof(S_EAS_DATA));
	if (!pEASData)
	{
		{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_FATAL, "Failed to allocate EAS library memory\n"); */ }
		return EAS_ERROR_MALLOC_FAILED;
	}

	/* initialize some data */
	EAS_HWMemSet(pEASData, 0, sizeof(S_EAS_DATA));
	pEASData->staticMemoryModel = (EAS_BOOL8) staticMemoryModel;
	pEASData->hwInstData = pHWInstData;
	pEASData->renderTime = 0;

	/* set header search flag */
#ifdef FILE_HEADER_SEARCH	
	pEASData->searchHeaderFlag = EAS_TRUE;
#endif

	/* initalize parameters */
	EAS_SetVolume(pEASData, NULL, DEFAULT_VOLUME);

#ifdef _METRICS_ENABLED
	/* initalize the metrics module */
	pEASData->pMetricsModule = EAS_CMEnumOptModules(EAS_MODULE_METRICS);
	if (pEASData->pMetricsModule != NULL)
	{
		if ((result = (*pEASData->pMetricsModule->pfInit)(pEASData, &pEASData->pMetricsData)) != EAS_SUCCESS)
		{
			{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "Error %ld initializing metrics module\n", result); */ }
			return result;
		}
	}
#endif	

	/* initailize the voice manager & synthesizer */
	if ((result = VMInitialize(pEASData)) != EAS_SUCCESS)
		return result;

	/* initialize mix engine */
	if ((result = EAS_MixEngineInit(pEASData)) != EAS_SUCCESS)
	{
		{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "Error %ld starting up mix engine\n", result); */ }
		return result;
	}
	
	/* initialize effects modules */
	for (module = 0; module < NUM_EFFECTS_MODULES; module++)
	{
		pEASData->effectsModules[module].effect = EAS_CMEnumFXModules(module);
		if (pEASData->effectsModules[module].effect != NULL)
		{
			if ((result = (*pEASData->effectsModules[module].effect->pfInit)(pEASData, &pEASData->effectsModules[module].effectData)) != EAS_SUCCESS)
			{
				{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_FATAL, "Initialization of effects module %d returned %d\n", module, result); */ }
				return result;
			}
		}
	}

	/* initialize PCM engine */
	if ((result = EAS_PEInit(pEASData)) != EAS_SUCCESS)
	{
		{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_FATAL, "EAS_PEInit failed with error code %ld\n", result); */ }
		return result;
	}

	/* return instance data pointer to host */
	*ppEASData = pEASData;

	return EAS_SUCCESS;
} 

/*----------------------------------------------------------------------------
 * EAS_Shutdown()
 *----------------------------------------------------------------------------
 * Purpose:
 * Shuts down the library. Deallocates any memory associated with the
 * synthesizer (dynamic memory model only)
 *
 * Inputs:
 *	pEASData		- handle to data for this instance
 *
 * Outputs:
 *
 *----------------------------------------------------------------------------
*/
EAS_PUBLIC EAS_RESULT EAS_Shutdown (EAS_DATA_HANDLE pEASData)
{
	EAS_HW_DATA_HANDLE hwInstData;
	EAS_RESULT result, reportResult;
	EAS_INT i;

	/* establish pointers */
	hwInstData = pEASData->hwInstData;

	/* check for NULL handle */
	if (!pEASData)
		return EAS_ERROR_HANDLE_INTEGRITY;

	/* if there are streams open, close them */
	reportResult = EAS_SUCCESS;
	for (i = 0; i < MAX_NUMBER_STREAMS; i++)
	{
		if (pEASData->streams[i].pParserModule && pEASData->streams[i].handle)
		{
		 	if ((result = (*((S_FILE_PARSER_INTERFACE*)(pEASData->streams[i].pParserModule))->pfClose)(pEASData, pEASData->streams[i].handle)) != EAS_SUCCESS)
		 	{
				{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "Error %ld shutting down parser module\n", result); */ }
				reportResult = result;
		 	}
		}
	}
	
	/* shutdown PCM engine */
	if ((result = EAS_PEShutdown(pEASData)) != EAS_SUCCESS)
	{
		{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "Error %ld shutting down PCM engine\n", result); */ }
		if (reportResult == EAS_SUCCESS)
			reportResult = result;
	}

	/* shutdown mix engine */
	if ((result = EAS_MixEngineShutdown(pEASData)) != EAS_SUCCESS)
	{
		{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "Error %ld shutting down mix engine\n", result); */ }
		if (reportResult == EAS_SUCCESS)
			reportResult = result;
	}

	/* shutdown effects modules */
	for (i = 0; i < NUM_EFFECTS_MODULES; i++)
	{
		if (pEASData->effectsModules[i].effect)
		{
			if ((result = (*pEASData->effectsModules[i].effect->pfShutdown)(pEASData, pEASData->effectsModules[i].effectData)) != EAS_SUCCESS)
			{
				{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_FATAL, "Shutdown of effects module %d returned %d\n", i, result); */ }
				if (reportResult == EAS_SUCCESS)
					reportResult = result;
			}
		}
	}

	/* shutdown the voice manager & synthesizer */
	VMShutdown(pEASData);

#ifdef _METRICS_ENABLED	
	/* shutdown the metrics module */
	if (pEASData->pMetricsModule != NULL)
	{
		if ((result = (*pEASData->pMetricsModule->pfShutdown)(pEASData, pEASData->pMetricsData)) != EAS_SUCCESS)
		{
			{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "Error %ld shutting down metrics module\n", result); */ }
			if (reportResult == EAS_SUCCESS)
				reportResult = result;
		}
	}
#endif	

	/* release allocated memory */
	if (!pEASData->staticMemoryModel)
		EAS_HWFree(hwInstData, pEASData);

	/* shutdown host wrappers */
	if (hwInstData)
	{
		if ((result = EAS_HWShutdown(hwInstData)) != EAS_SUCCESS)
		{
			{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "Error %ld shutting down host wrappers\n", result); */ }
			if (reportResult == EAS_SUCCESS)
				reportResult = result;
		}
	}
	
	return reportResult;
}

#ifdef JET_INTERFACE
/*----------------------------------------------------------------------------
 * EAS_OpenJETStream()
 *----------------------------------------------------------------------------
 * Private interface for JET to open an SMF stream with an offset
 *----------------------------------------------------------------------------
*/
EAS_RESULT EAS_OpenJETStream (EAS_DATA_HANDLE pEASData, EAS_FILE_HANDLE fileHandle, EAS_I32 offset, EAS_HANDLE *ppStream)
{
	EAS_RESULT result;
	EAS_VOID_PTR streamHandle;
	S_FILE_PARSER_INTERFACE *pParserModule;
	EAS_INT streamNum;

	/* allocate a stream */
	if ((streamNum = EAS_AllocateStream(pEASData)) < 0)
		return EAS_ERROR_MAX_STREAMS_OPEN;
	
	/* check Configuration Module for SMF parser */
	*ppStream = NULL;
	streamHandle = NULL;
	pParserModule = (S_FILE_PARSER_INTERFACE *) EAS_CMEnumModules(0);
	if (pParserModule == NULL)
		return EAS_ERROR_UNRECOGNIZED_FORMAT;

	/* see if SMF parser recognizes the file */
	if ((result = (*pParserModule->pfCheckFileType)(pEASData, fileHandle, &streamHandle, offset)) != EAS_SUCCESS)
	{
		{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "CheckFileType returned error %ld\n", result); */ }
		return result;
	}

	/* parser recognized the file, return the handle */
	if (streamHandle)
	{
		EAS_InitStream(&pEASData->streams[streamNum], pParserModule, streamHandle);
		*ppStream = &pEASData->streams[streamNum];
		return EAS_SUCCESS;
	}

	return EAS_ERROR_UNRECOGNIZED_FORMAT;
}
#endif

/*----------------------------------------------------------------------------
 * EAS_OpenFile()
 *----------------------------------------------------------------------------
 * Purpose: 
 * Opens a file for audio playback.
 *
 * Inputs:
 * pEASData			- pointer to overall EAS data structure
 * pHandle			- pointer to file handle
 *		
 * Outputs:
 * 
 *
 * Side Effects:
 *
 *----------------------------------------------------------------------------
*/
EAS_PUBLIC EAS_RESULT EAS_OpenFile (EAS_DATA_HANDLE pEASData, EAS_FILE_LOCATOR locator, EAS_HANDLE *ppStream)
{
	EAS_RESULT result;
	EAS_FILE_HANDLE fileHandle;
	EAS_VOID_PTR streamHandle;
	S_FILE_PARSER_INTERFACE *pParserModule;
	EAS_INT streamNum;
	EAS_INT moduleNum;

	/* open the file */
	if ((result = EAS_HWOpenFile(pEASData->hwInstData, locator, &fileHandle, EAS_FILE_READ)) != EAS_SUCCESS)
		return result;

	/* allocate a stream */
	if ((streamNum = EAS_AllocateStream(pEASData)) < 0)
		return EAS_ERROR_MAX_STREAMS_OPEN;
	
	/* check Configuration Module for file parsers */
	pParserModule = NULL;
	*ppStream = NULL;
	streamHandle = NULL;
	for (moduleNum = 0; ; moduleNum++)
	{
		pParserModule = (S_FILE_PARSER_INTERFACE *) EAS_CMEnumModules(moduleNum);
		if (pParserModule == NULL)
			break;

		/* see if this parser recognizes it */
		if ((result = (*pParserModule->pfCheckFileType)(pEASData, fileHandle, &streamHandle, 0L)) != EAS_SUCCESS)
		{
			{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "CheckFileType returned error %ld\n", result); */ }
			return result;
		}

		/* parser recognized the file, return the handle */
		if (streamHandle)
		{
			
			/* save the parser pointer and file handle */
			EAS_InitStream(&pEASData->streams[streamNum], pParserModule, streamHandle);
			*ppStream = &pEASData->streams[streamNum];
			return EAS_SUCCESS;
		}

		/* rewind the file for the next parser */
		if ((result = EAS_HWFileSeek(pEASData->hwInstData, fileHandle, 0L)) != EAS_SUCCESS)
			return result;
	}

	/* no parser was able to recognize the file, close it and return an error */
	EAS_HWCloseFile(pEASData->hwInstData, fileHandle);
	{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_WARNING, "No parser recognized the requested file\n"); */ }
	return EAS_ERROR_UNRECOGNIZED_FORMAT;
}

#ifdef MMAPI_SUPPORT
/*----------------------------------------------------------------------------
 * EAS_MMAPIToneControl()
 *----------------------------------------------------------------------------
 * Purpose: 
 * Opens a ToneControl file for audio playback.
 *
 * Inputs:
 * pEASData			- pointer to overall EAS data structure
 * pHandle			- pointer to file handle
 *		
 * Outputs:
 * 
 *
 * Side Effects:
 *
 *----------------------------------------------------------------------------
*/
EAS_PUBLIC EAS_RESULT EAS_MMAPIToneControl (EAS_DATA_HANDLE pEASData, EAS_FILE_LOCATOR locator, EAS_HANDLE *ppStream)
{
	EAS_RESULT result;
	EAS_FILE_HANDLE fileHandle;
	EAS_VOID_PTR streamHandle;
	S_FILE_PARSER_INTERFACE *pParserModule;
	EAS_INT streamNum;

	/* check if the tone control parser is available */
	*ppStream = NULL;
	streamHandle = NULL;
	pParserModule = EAS_CMEnumOptModules(EAS_MODULE_MMAPI_TONE_CONTROL);
	if (pParserModule == NULL)
	{
		{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "EAS_MMAPIToneControl: ToneControl parser not available\n"); */ }
		return EAS_ERROR_FEATURE_NOT_AVAILABLE;
	}

	/* open the file */
	if ((result = EAS_HWOpenFile(pEASData->hwInstData, locator, &fileHandle, EAS_FILE_READ)) != EAS_SUCCESS)
		return result;

	/* allocate a stream */
	if ((streamNum = EAS_AllocateStream(pEASData)) < 0)
		return EAS_ERROR_MAX_STREAMS_OPEN;

	/* see if ToneControl parser recognizes it */
	if ((result = (*pParserModule->pfCheckFileType)(pEASData, fileHandle, &streamHandle, 0L)) != EAS_SUCCESS)
	{
		{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "CheckFileType returned error %ld\n", result); */ }
		return result;
	}

	/* parser accepted the file, return the handle */
	if (streamHandle)
	{
		
		/* save the parser pointer and file handle */
		EAS_InitStream(&pEASData->streams[streamNum], pParserModule, streamHandle);
		*ppStream = &pEASData->streams[streamNum];
		return EAS_SUCCESS;
	}

	/* parser did not recognize the file, close it and return an error */
	EAS_HWCloseFile(pEASData->hwInstData, fileHandle);
	{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_WARNING, "No parser recognized the requested file\n"); */ }
	return EAS_ERROR_UNRECOGNIZED_FORMAT;
}

/*----------------------------------------------------------------------------
 * EAS_GetWaveFmtChunk
 *----------------------------------------------------------------------------
 * Helper function to retrieve WAVE file fmt chunk for MMAPI
 *----------------------------------------------------------------------------
 * pEASData			- pointer to EAS persistent data object
 * pStream			- stream handle
 * pFmtChunk		- pointer to variable to receive current setting
 *----------------------------------------------------------------------------
*/
EAS_PUBLIC EAS_RESULT EAS_GetWaveFmtChunk (S_EAS_DATA *pEASData, EAS_HANDLE pStream, EAS_VOID_PTR *ppFmtChunk)
{
	EAS_RESULT result;
	EAS_I32 value;

	if ((result = EAS_GetStreamParameter(pEASData, pStream, PARSER_DATA_FORMAT, &value)) != EAS_SUCCESS)
		return result;
	*ppFmtChunk = (EAS_VOID_PTR) value;
	return EAS_SUCCESS;
}
#endif

/*----------------------------------------------------------------------------
 * EAS_GetFileType
 *----------------------------------------------------------------------------
 * Returns the file type (see eas_types.h for enumerations)
 *----------------------------------------------------------------------------
 * pEASData			- pointer to EAS persistent data object
 * pStream			- stream handle
 * pFileType		- pointer to variable to receive file type
 *----------------------------------------------------------------------------
*/
EAS_PUBLIC EAS_RESULT EAS_GetFileType (S_EAS_DATA *pEASData, EAS_HANDLE pStream, EAS_I32 *pFileType)
{
	if (!EAS_StreamReady (pEASData, pStream))
		return EAS_ERROR_NOT_VALID_IN_THIS_STATE;
	return EAS_GetStreamParameter(pEASData, pStream, PARSER_DATA_FILE_TYPE, pFileType);
}

/*----------------------------------------------------------------------------
 * EAS_Prepare()
 *----------------------------------------------------------------------------
 * Purpose: 
 * Prepares the synthesizer to play the file or stream. Parses the first
 * frame of data from the file and arms the synthesizer.
 *
 * Inputs:
 * pEASData			- pointer to overall EAS data structure
 * handle			- file or stream handle
 *		
 * Outputs:
 * 
 *
 * Side Effects:
 *
 *----------------------------------------------------------------------------
*/
EAS_PUBLIC EAS_RESULT EAS_Prepare (EAS_DATA_HANDLE pEASData, EAS_HANDLE pStream)
{
	S_FILE_PARSER_INTERFACE *pParserModule;
	EAS_STATE state;
	EAS_RESULT result;

	pParserModule = (S_FILE_PARSER_INTERFACE*) pStream->pParserModule;
	if (pParserModule == NULL)
		return EAS_ERROR_FEATURE_NOT_AVAILABLE;

	/* check for valid state */
	result = pParserModule->pfState(pEASData, pStream->handle, &state);
	if (result == EAS_SUCCESS)
	{
		/* prepare the stream */	
		if (state == EAS_STATE_OPEN)
		{
			pParserModule = (S_FILE_PARSER_INTERFACE*) pStream->pParserModule;
			result = (*pParserModule->pfPrepare)(pEASData, pStream->handle);
			
			/* set volume */
			if (result == EAS_SUCCESS)
				result = EAS_SetVolume(pEASData, pStream, pStream->volume);
		}
		else
			result = EAS_ERROR_NOT_VALID_IN_THIS_STATE;
		
	}
	
	return result;
} 

/*----------------------------------------------------------------------------
 * EAS_Render()
 *----------------------------------------------------------------------------
 * Purpose:
 * Parse the Midi data and render PCM audio data.
 *
 * Inputs:
 *  pEASData        - buffer for internal EAS data
 *	pOut			- output buffer pointer
 *	nNumRequested	- requested num samples to generate
 *	pnNumGenerated	- actual number of samples generated
 *
 * Outputs:
 *	EAS_SUCCESS if PCM data was successfully rendered
 *
 *----------------------------------------------------------------------------
*/
EAS_PUBLIC EAS_RESULT EAS_Render (EAS_DATA_HANDLE pEASData, EAS_PCM *pOut, EAS_I32 numRequested, EAS_I32 *pNumGenerated)
{
	S_FILE_PARSER_INTERFACE *pParserModule;
	EAS_RESULT result;
	EAS_I32 voicesRendered;
	EAS_STATE parserState;
	EAS_INT streamNum;

	/* assume no samples generated and reset workload */
	*pNumGenerated = 0;
	VMInitWorkload(pEASData->pVoiceMgr);
		
	/* no support for other buffer sizes yet */
	if (numRequested != BUFFER_SIZE_IN_MONO_SAMPLES)
	{
		{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "This library supports only %ld samples in buffer, host requested %ld samples\n", 
			(EAS_I32) BUFFER_SIZE_IN_MONO_SAMPLES, numRequested); */ }
		return EAS_BUFFER_SIZE_MISMATCH;
	}

#ifdef _METRICS_ENABLED	
	/* start performance counter */
	if (pEASData->pMetricsData)
		(*pEASData->pMetricsModule->pfStartTimer)(pEASData->pMetricsData, EAS_PM_TOTAL_TIME);
#endif

	/* prep the frame buffer, do mix engine prep only if TRUE */
#ifdef _SPLIT_ARCHITECTURE
	if (VMStartFrame(pEASData))
		EAS_MixEnginePrep(pEASData, numRequested);
#else	
	/* prep the mix engine */
	EAS_MixEnginePrep(pEASData, numRequested);
#endif

	/* save the output buffer pointer */
	pEASData->pOutputAudioBuffer = pOut;


#ifdef _METRICS_ENABLED	
		/* start performance counter */
		if (pEASData->pMetricsData)
			(*pEASData->pMetricsModule->pfStartTimer)(pEASData->pMetricsData, EAS_PM_PARSE_TIME);
#endif	

	/* if we haven't finished parsing from last time, do it now */
	/* need to parse another frame of events before we render again */
	for (streamNum = 0; streamNum < MAX_NUMBER_STREAMS; streamNum++)
	{
		/* clear the locate flag */
		pEASData->streams[streamNum].streamFlags &= ~STREAM_FLAGS_LOCATE;
		
		if (pEASData->streams[streamNum].pParserModule)
		{
			
			/* establish pointer to parser module */
			pParserModule = pEASData->streams[streamNum].pParserModule;

			/* handle pause */
			if (pEASData->streams[streamNum].streamFlags & STREAM_FLAGS_PAUSE)
			{
				if (pParserModule->pfPause)
					result = pParserModule->pfPause(pEASData, pEASData->streams[streamNum].handle);
				pEASData->streams[streamNum].streamFlags &= ~STREAM_FLAGS_PAUSE;
			}

			/* get current state */
			if ((result = (*pParserModule->pfState)(pEASData, pEASData->streams[streamNum].handle, &parserState)) != EAS_SUCCESS)
				return result;

			/* handle resume */
			if (parserState == EAS_STATE_PAUSED)
			{
				if (pEASData->streams[streamNum].streamFlags & STREAM_FLAGS_RESUME)
				{
					if (pParserModule->pfResume)
						result = pParserModule->pfResume(pEASData, pEASData->streams[streamNum].handle);
					pEASData->streams[streamNum].streamFlags &= ~STREAM_FLAGS_RESUME;
				}
			}

			/* if necessary, parse stream */
			if ((pEASData->streams[streamNum].streamFlags & STREAM_FLAGS_PARSED) == 0)
				if ((result = EAS_ParseEvents(pEASData, &pEASData->streams[streamNum], pEASData->streams[streamNum].time + pEASData->streams[streamNum].frameLength, eParserModePlay)) != EAS_SUCCESS)
					return result;

			/* check for an early abort */
			if ((pEASData->streams[streamNum].streamFlags) == 0)
			{
				
#ifdef _METRICS_ENABLED	
				/* stop performance counter */
				if (pEASData->pMetricsData)
					(*pEASData->pMetricsModule->pfStartTimer)(pEASData->pMetricsData, EAS_PM_TOTAL_TIME);
#endif

				return EAS_SUCCESS;
			}
			
			/* check for repeat */
			if (pEASData->streams[streamNum].repeatCount)
			{
				
				/* check for stopped state */
				if ((result = (*pParserModule->pfState)(pEASData, pEASData->streams[streamNum].handle, &parserState)) != EAS_SUCCESS)
					return result;
				if (parserState == EAS_STATE_STOPPED)
				{

					/* decrement repeat count, unless it is negative */
					if (pEASData->streams[streamNum].repeatCount > 0)
						pEASData->streams[streamNum].repeatCount--;
					
					/* reset the parser */
					if ((result = (*pParserModule->pfReset)(pEASData, pEASData->streams[streamNum].handle)) != EAS_SUCCESS)
						return result;
					pEASData->streams[streamNum].time = 0;
				}
			}
		}
	}

#ifdef _METRICS_ENABLED	
	/* stop performance counter */
	if (pEASData->pMetricsData)
		(void)(*pEASData->pMetricsModule->pfStopTimer)(pEASData->pMetricsData, EAS_PM_PARSE_TIME);
#endif
	
#ifdef _METRICS_ENABLED	
	/* start the render timer */
	if (pEASData->pMetricsData)
		(*pEASData->pMetricsModule->pfStartTimer)(pEASData->pMetricsData, EAS_PM_RENDER_TIME);
#endif

	/* render audio */
	if ((result = VMRender(pEASData->pVoiceMgr, BUFFER_SIZE_IN_MONO_SAMPLES, pEASData->pMixBuffer, &voicesRendered)) != EAS_SUCCESS)
	{
		{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "pfRender function returned error %ld\n", result); */ } 
		return result;
	}

#ifdef _METRICS_ENABLED	
	/* stop the render timer */
	if (pEASData->pMetricsData) {
		(*pEASData->pMetricsModule->pfIncrementCounter)(pEASData->pMetricsData, EAS_PM_FRAME_COUNT, 1);
		(void)(*pEASData->pMetricsModule->pfStopTimer)(pEASData->pMetricsData, EAS_PM_RENDER_TIME);
		(*pEASData->pMetricsModule->pfIncrementCounter)(pEASData->pMetricsData, EAS_PM_TOTAL_VOICE_COUNT, (EAS_U32) voicesRendered);
		(void)(*pEASData->pMetricsModule->pfRecordMaxValue)(pEASData->pMetricsData, EAS_PM_MAX_VOICES, (EAS_U32) voicesRendered);
	}
#endif

	//2 Do we really need frameParsed?
	/* need to parse another frame of events before we render again */
	for (streamNum = 0; streamNum < MAX_NUMBER_STREAMS; streamNum++)
		if (pEASData->streams[streamNum].pParserModule != NULL)
			pEASData->streams[streamNum].streamFlags &= ~STREAM_FLAGS_PARSED;

#ifdef _METRICS_ENABLED	
	/* start performance counter */
	if (pEASData->pMetricsData)
		(*pEASData->pMetricsModule->pfStartTimer)(pEASData->pMetricsData, EAS_PM_STREAM_TIME);
#endif

	/* render PCM audio */
	if ((result = EAS_PERender(pEASData, numRequested)) != EAS_SUCCESS)
	{
		{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "EAS_PERender returned error %ld\n", result); */ } 
		return result;
	}
	
#ifdef _METRICS_ENABLED	
	/* stop the stream timer */
	if (pEASData->pMetricsData)
		(void)(*pEASData->pMetricsModule->pfStopTimer)(pEASData->pMetricsData, EAS_PM_STREAM_TIME);
#endif

#ifdef _METRICS_ENABLED	
	/* start the post timer */
	if (pEASData->pMetricsData)
		(*pEASData->pMetricsModule->pfStartTimer)(pEASData->pMetricsData, EAS_PM_POST_TIME);
#endif

	/* for split architecture, send DSP vectors.  Do post only if return is TRUE */
#ifdef _SPLIT_ARCHITECTURE
	if (VMEndFrame(pEASData))
	{
		/* now do post-processing */
		EAS_MixEnginePost(pEASData, numRequested);
		*pNumGenerated = numRequested;
	}
#else	
	/* now do post-processing */
	EAS_MixEnginePost(pEASData, numRequested);
	*pNumGenerated = numRequested;
#endif

#ifdef _METRICS_ENABLED	
	/* stop the post timer */
	if (pEASData->pMetricsData)
		(void)(*pEASData->pMetricsModule->pfStopTimer)(pEASData->pMetricsData, EAS_PM_POST_TIME);
#endif

	/* advance render time */
	pEASData->renderTime += AUDIO_FRAME_LENGTH;

#if 0
	/* dump workload for debug */
	if (pEASData->pVoiceMgr->workload)
		{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_DETAIL, "Workload = %d\n", pEASData->pVoiceMgr->workload); */ }
#endif	

#ifdef _METRICS_ENABLED	
	/* stop performance counter */
	if (pEASData->pMetricsData)
	{
		PERF_TIMER temp;
		temp = (*pEASData->pMetricsModule->pfStopTimer)(pEASData->pMetricsData, EAS_PM_TOTAL_TIME);
		
		/* if max render time, record the number of voices and time */
		if ((*pEASData->pMetricsModule->pfRecordMaxValue)
			(pEASData->pMetricsData, EAS_PM_MAX_CYCLES, (EAS_U32) temp))
		{
			(*pEASData->pMetricsModule->pfRecordValue)(pEASData->pMetricsData, EAS_PM_MAX_CYCLES_VOICES, (EAS_U32) voicesRendered);
			(*pEASData->pMetricsModule->pfRecordValue)(pEASData->pMetricsData, EAS_PM_MAX_CYCLES_TIME, (EAS_I32) (pEASData->renderTime >> 8));
		}	
	}
#endif

#ifdef JET_INTERFACE
	/* let JET to do its thing */
	if (pEASData->jetHandle != NULL)
	{
		result = JET_Process(pEASData);
		if (result != EAS_SUCCESS)
			return result;
	}
#endif

	return EAS_SUCCESS;
}

/*----------------------------------------------------------------------------
 * EAS_SetRepeat()
 *----------------------------------------------------------------------------
 * Purpose: 
 * Set the selected stream to repeat.
 *
 * Inputs:
 *	pEASData		- handle to data for this instance
 *	handle			- handle to stream
 *	repeatCount		- repeat count
 *		
 * Outputs:
 *
 * Side Effects:
 *
 * Notes:
 *	0 = no repeat
 *	1 = repeat once, i.e. play through twice
 *  -1 = repeat forever
 *----------------------------------------------------------------------------
*/
/*lint -esym(715, pEASData) reserved for future use */
EAS_PUBLIC EAS_RESULT EAS_SetRepeat (EAS_DATA_HANDLE pEASData, EAS_HANDLE pStream, EAS_I32 repeatCount)
{
	pStream->repeatCount = repeatCount;
	return EAS_SUCCESS;
}

/*----------------------------------------------------------------------------
 * EAS_GetRepeat()
 *----------------------------------------------------------------------------
 * Purpose: 
 * Gets the current repeat count for the selected stream.
 *
 * Inputs:
 *	pEASData		- handle to data for this instance
 *	handle			- handle to stream
 *	pRrepeatCount	- pointer to variable to hold repeat count
 *		
 * Outputs:
 *
 * Side Effects:
 *
 * Notes:
 *	0 = no repeat
 *	1 = repeat once, i.e. play through twice
 *  -1 = repeat forever
 *----------------------------------------------------------------------------
*/
/*lint -esym(715, pEASData) reserved for future use */
EAS_PUBLIC EAS_RESULT EAS_GetRepeat (EAS_DATA_HANDLE pEASData, EAS_HANDLE pStream, EAS_I32 *pRepeatCount)
{
	*pRepeatCount = pStream->repeatCount;
	return EAS_SUCCESS;
}

/*----------------------------------------------------------------------------
 * EAS_SetPlaybackRate()
 *----------------------------------------------------------------------------
 * Purpose: 
 * Sets the playback rate.
 *
 * Inputs:
 *	pEASData		- handle to data for this instance
 *	handle			- handle to stream
 *	rate			- rate (28-bit fractional amount)
 *		
 * Outputs:
 *
 * Side Effects:
 *
 *----------------------------------------------------------------------------
*/
/*lint -esym(715, pEASData) reserved for future use */
EAS_PUBLIC EAS_RESULT EAS_SetPlaybackRate (EAS_DATA_HANDLE pEASData, EAS_HANDLE pStream, EAS_U32 rate)
{

	/* check range */
	if ((rate < (1 << 27)) || (rate > (1 << 29)))
		return EAS_ERROR_INVALID_PARAMETER;

	/* calculate new frame length
	 *
	 * NOTE: The maximum frame length we can accomodate based on a 
	 * maximum rate of 2.0 (2^28) is 2047 (2^13-1). To accomodate a
	 * longer frame length or a higher maximum rate, the fixed point
	 * divide below will need to be adjusted
	 */
	pStream->frameLength = (AUDIO_FRAME_LENGTH * (rate >> 8)) >> 20;

	/* notify stream of new playback rate */
	EAS_SetStreamParameter(pEASData, pStream, PARSER_DATA_PLAYBACK_RATE, (EAS_I32) rate);
	return EAS_SUCCESS;
}

/*----------------------------------------------------------------------------
 * EAS_SetTransposition)
 *----------------------------------------------------------------------------
 * Purpose: 
 * Sets the key tranposition for the synthesizer. Transposes all
 * melodic instruments by the specified amount. Range is limited
 * to +/-12 semitones.
 *
 * Inputs:
 *	pEASData		- handle to data for this instance
 *	handle			- handle to stream
 *	transposition	- +/-12 semitones
 *		
 * Outputs:
 *
 * Side Effects:
 *
 *----------------------------------------------------------------------------
*/
EAS_PUBLIC EAS_RESULT EAS_SetTransposition (EAS_DATA_HANDLE pEASData, EAS_HANDLE pStream, EAS_I32 transposition)
{

	/* check range */
	if ((transposition < -12) || (transposition > 12))
		return EAS_ERROR_INVALID_PARAMETER;

	if (!EAS_StreamReady(pEASData, pStream))
		return EAS_ERROR_NOT_VALID_IN_THIS_STATE;
	return EAS_IntSetStrmParam(pEASData, pStream, PARSER_DATA_TRANSPOSITION, transposition);
}
	
/*----------------------------------------------------------------------------
 * EAS_ParseEvents()
 *----------------------------------------------------------------------------
 * Purpose:
 * Parse events in the current streams until the desired time is reached.
 *
 * Inputs:
 *  pEASData        - buffer for internal EAS data
 *	endTime			- stop parsing if this time is reached 
 *	parseMode		- play, locate, or metadata
 *
 * Outputs:
 *	EAS_SUCCESS if PCM data was successfully rendered
 *
 *----------------------------------------------------------------------------
*/
static EAS_RESULT EAS_ParseEvents (S_EAS_DATA *pEASData, EAS_HANDLE pStream, EAS_U32 endTime, EAS_INT parseMode)
{
	S_FILE_PARSER_INTERFACE *pParserModule;
	EAS_RESULT result;
	EAS_I32 parserState;
	EAS_BOOL done;
	EAS_INT yieldCount = YIELD_EVENT_COUNT;
	EAS_U32 time = 0;

	/* does this parser have a time function? */
	pParserModule = pStream->pParserModule;
	if (pParserModule->pfTime == NULL)
	{
		/* check state */
		if ((result = (*pParserModule->pfState)(pEASData, pStream->handle, &parserState)) != EAS_SUCCESS)
			return result;
		/* if play state, advance time */
		if ((parserState >= EAS_STATE_READY) && (parserState <= EAS_STATE_PAUSING))
			pStream->time += pStream->frameLength;
		done = EAS_TRUE;
	}

	/* assume we're not done, in case we abort out */ 
	else
	{
		pStream->streamFlags &= ~STREAM_FLAGS_PARSED;
		done = EAS_FALSE;
	}
	
	while (!done)
	{
		
		/* check for stopped state */
		if ((result = (*pParserModule->pfState)(pEASData, pStream->handle, &parserState)) != EAS_SUCCESS)
			return result;
		if (parserState > EAS_STATE_PLAY)
		{
			/* save current time if we're not in play mode */
			if (parseMode != eParserModePlay)
				pStream->time = time << 8;
			done = EAS_TRUE;
			break;
		}

		/* get the next event time */
		if (pParserModule->pfTime)
		{
			if ((result = (*pParserModule->pfTime)(pEASData, pStream->handle, &time)) != EAS_SUCCESS)
				return result;

			/* if next event is within this frame, parse it */
			if (time < (endTime >> 8))
			{

				/* parse the next event */
				if (pParserModule->pfEvent)
					if ((result = (*pParserModule->pfEvent)(pEASData, pStream->handle, parseMode)) != EAS_SUCCESS)
						return result;
			}

			/* no more events in this frame, advance time */
			else
			{
				pStream->time = endTime;
				done = EAS_TRUE;
			}
		}

		/* check for max workload exceeded */
		if (VMCheckWorkload(pEASData->pVoiceMgr))
		{
			/* stop even though we may not have parsed
			 * all the events in this frame. The parser will try to
			 * catch up on the next frame.
			 */
			break;
		}

		/* give host a chance for an early abort */
		if (--yieldCount == 0)
		{
			if (EAS_HWYield(pEASData->hwInstData))
				break;
			yieldCount = YIELD_EVENT_COUNT;
		}
	}

	/* if no early abort, parsing is complete for this frame */
	if (done)
		pStream->streamFlags |= STREAM_FLAGS_PARSED;
	
	return EAS_SUCCESS;
}

/*----------------------------------------------------------------------------
 * EAS_ParseMetaData()
 *----------------------------------------------------------------------------
 * Purpose: 
 * 
 *
 * Inputs:
 * pEASData			- pointer to overall EAS data structure
 * handle			- file or stream handle
 * playLength		- pointer to variable to store the play length (in msecs)
 *		
 * Outputs:
 * 
 *
 * Side Effects:
 *					- resets the parser to the start of the file
 *----------------------------------------------------------------------------
*/
EAS_PUBLIC EAS_RESULT EAS_ParseMetaData (EAS_DATA_HANDLE pEASData, EAS_HANDLE pStream, EAS_I32 *playLength)
{
	S_FILE_PARSER_INTERFACE *pParserModule;
	EAS_RESULT result;
	EAS_STATE state;

	pParserModule = (S_FILE_PARSER_INTERFACE*) pStream->pParserModule;
	if (pParserModule == NULL)
		return EAS_ERROR_FEATURE_NOT_AVAILABLE;

	/* check parser state */
	if ((result = (*pParserModule->pfState)(pEASData, pStream->handle, &state)) != EAS_SUCCESS)
		return result;
	if (state >= EAS_STATE_OPEN)
		return EAS_ERROR_NOT_VALID_IN_THIS_STATE;

	/* if parser has metadata function, use that */
	if (pParserModule->pfGetMetaData != NULL)
		return pParserModule->pfGetMetaData(pEASData, pStream->handle, playLength);

	/* reset the parser to the beginning */
	if ((result = (*pParserModule->pfReset)(pEASData, pStream->handle)) != EAS_SUCCESS)
		return result;

	/* parse the file to end */
	pStream->time = 0;
	VMInitWorkload(pEASData->pVoiceMgr);
	if ((result = EAS_ParseEvents(pEASData, pStream, 0x7fffffff, eParserModeMetaData)) != EAS_SUCCESS)
		return result;

	/* get the parser time */
	if ((result = EAS_GetLocation(pEASData, pStream, playLength)) != EAS_SUCCESS)
		return result;

	/* reset the parser to the beginning */
	pStream->time = 0;
	return (*pParserModule->pfReset)(pEASData, pStream->handle);
}

/*----------------------------------------------------------------------------
 * EAS_RegisterMetaDataCallback()
 *----------------------------------------------------------------------------
 * Purpose: 
 * Registers a metadata callback function for parsed metadata. 
 *
 * Inputs:
 * pEASData			- pointer to overall EAS data structure
 * handle			- file or stream handle
 * cbFunc			- pointer to host callback function
 * metaDataBuffer	- pointer to metadata buffer
 * metaDataBufSize	- maximum size of the metadata buffer
 *		
 * Outputs:
 * 
 *
 * Side Effects:
 *
 *----------------------------------------------------------------------------
*/
EAS_PUBLIC EAS_RESULT EAS_RegisterMetaDataCallback (
	EAS_DATA_HANDLE pEASData, 
	EAS_HANDLE pStream, 
	EAS_METADATA_CBFUNC cbFunc, 
	char *metaDataBuffer, 
	EAS_I32 metaDataBufSize,
	EAS_VOID_PTR pUserData)
{
	S_METADATA_CB metadata;

	if (!EAS_StreamReady(pEASData, pStream))
		return EAS_ERROR_NOT_VALID_IN_THIS_STATE;
	
	/* register callback function */
	metadata.callback = cbFunc;
	metadata.buffer = metaDataBuffer;
	metadata.bufferSize = metaDataBufSize;
	metadata.pUserData = pUserData;
	return EAS_SetStreamParameter(pEASData, pStream, PARSER_DATA_METADATA_CB, (EAS_I32) &metadata);
}

/*----------------------------------------------------------------------------
 * EAS_GetNoteCount ()
 *----------------------------------------------------------------------------
 * Returns the total number of notes played in this stream
 *----------------------------------------------------------------------------
*/
EAS_PUBLIC EAS_RESULT EAS_GetNoteCount (EAS_DATA_HANDLE pEASData, EAS_HANDLE pStream, EAS_I32 *pNoteCount)
{
	if (!EAS_StreamReady(pEASData, pStream))
		return EAS_ERROR_NOT_VALID_IN_THIS_STATE;
	return EAS_IntGetStrmParam(pEASData, pStream, PARSER_DATA_NOTE_COUNT, pNoteCount);
}

/*----------------------------------------------------------------------------
 * EAS_CloseFile()
 *----------------------------------------------------------------------------
 * Purpose: 
 * Closes an audio file or stream. Playback should have either paused or
 * completed (EAS_State returns EAS_PAUSED or EAS_STOPPED).
 *
 * Inputs:
 * pEASData			- pointer to overall EAS data structure
 * handle			- file or stream handle
 *		
 * Outputs:
 * 
 *
 * Side Effects:
 *
 *----------------------------------------------------------------------------
*/
EAS_PUBLIC EAS_RESULT EAS_CloseFile (EAS_DATA_HANDLE pEASData, EAS_HANDLE pStream)
{
	S_FILE_PARSER_INTERFACE *pParserModule;
	EAS_RESULT result;

	/* call the close function */
	pParserModule = (S_FILE_PARSER_INTERFACE*) pStream->pParserModule;
	if (pParserModule == NULL)
		return EAS_ERROR_FEATURE_NOT_AVAILABLE;

 	result = (*pParserModule->pfClose)(pEASData, pStream->handle);

	/* clear the handle and parser interface pointer */
	pStream->handle = NULL;
	pStream->pParserModule = NULL;
	return result;
} 

/*----------------------------------------------------------------------------
 * EAS_OpenMIDIStream()
 *----------------------------------------------------------------------------
 * Purpose: 
 * Opens a raw MIDI stream allowing the host to route MIDI cable data directly to the synthesizer
 *
 * Inputs:
 * pEASData			- pointer to overall EAS data structure
 * pHandle			- pointer to variable to hold file or stream handle
 *		
 * Outputs:
 * 
 *
 * Side Effects:
 *
 *----------------------------------------------------------------------------
*/
EAS_PUBLIC EAS_RESULT EAS_OpenMIDIStream (EAS_DATA_HANDLE pEASData, EAS_HANDLE *ppStream, EAS_HANDLE streamHandle)
{
	EAS_RESULT result;
	S_INTERACTIVE_MIDI *pMIDIStream;
	EAS_INT streamNum;

	/* initialize some pointers */
	*ppStream = NULL;

	/* allocate a stream */
	if ((streamNum = EAS_AllocateStream(pEASData)) < 0)
		return EAS_ERROR_MAX_STREAMS_OPEN;

	/* check Configuration Module for S_EAS_DATA allocation */
	if (pEASData->staticMemoryModel)
		pMIDIStream = EAS_CMEnumData(EAS_CM_MIDI_STREAM_DATA);
	else
		pMIDIStream = EAS_HWMalloc(pEASData->hwInstData, sizeof(S_INTERACTIVE_MIDI));
	
	/* allocate dynamic memory */
	if (!pMIDIStream)
	{
		{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_FATAL, "Failed to allocate MIDI stream data\n"); */ }
		return EAS_ERROR_MALLOC_FAILED;
	}

	/* zero the memory to insure complete initialization */
	EAS_HWMemSet(pMIDIStream, 0, sizeof(S_INTERACTIVE_MIDI));
	EAS_InitStream(&pEASData->streams[streamNum], NULL, pMIDIStream);

	/* instantiate a new synthesizer */
	if (streamHandle == NULL)
	{
		result = VMInitMIDI(pEASData, &pMIDIStream->pSynth);
	}

	/* use an existing synthesizer */
	else
	{
		EAS_I32 value;
		result = EAS_GetStreamParameter(pEASData, streamHandle, PARSER_DATA_SYNTH_HANDLE, &value);
		pMIDIStream->pSynth = (S_SYNTH*) value;
		VMIncRefCount(pMIDIStream->pSynth);
	}
	if (result != EAS_SUCCESS)
	{
		EAS_CloseMIDIStream(pEASData, &pEASData->streams[streamNum]);
		return result;
	}

	/* initialize the MIDI stream data */
	EAS_InitMIDIStream(&pMIDIStream->stream);

	*ppStream = (EAS_HANDLE) &pEASData->streams[streamNum];
	return EAS_SUCCESS;
} 

/*----------------------------------------------------------------------------
 * EAS_WriteMIDIStream()
 *----------------------------------------------------------------------------
 * Purpose: 
 * Send data to the MIDI stream device
 *
 * Inputs:
 * pEASData			- pointer to overall EAS data structure
 * handle			- stream handle
 * pBuffer			- pointer to buffer
 * count			- number of bytes to write
 *		
 * Outputs:
 * 
 *
 * Side Effects:
 *
 *----------------------------------------------------------------------------
*/
EAS_PUBLIC EAS_RESULT EAS_WriteMIDIStream (EAS_DATA_HANDLE pEASData, EAS_HANDLE pStream, EAS_U8 *pBuffer, EAS_I32 count)
{
	S_INTERACTIVE_MIDI *pMIDIStream;
	EAS_RESULT result;

	pMIDIStream = (S_INTERACTIVE_MIDI*) pStream->handle;

	/* send the entire buffer */
	while (count--)
	{
		if ((result = EAS_ParseMIDIStream(pEASData, pMIDIStream->pSynth, &pMIDIStream->stream, *pBuffer++, eParserModePlay)) != EAS_SUCCESS)
			return result;
	}
	return EAS_SUCCESS;
}

/*----------------------------------------------------------------------------
 * EAS_CloseMIDIStream()
 *----------------------------------------------------------------------------
 * Purpose: 
 * Closes a raw MIDI stream
 *
 * Inputs:
 * pEASData			- pointer to overall EAS data structure
 * handle			- stream handle
 *		
 * Outputs:
 * 
 *
 * Side Effects:
 *
 *----------------------------------------------------------------------------
*/
EAS_PUBLIC EAS_RESULT EAS_CloseMIDIStream (EAS_DATA_HANDLE pEASData, EAS_HANDLE pStream)
{
	S_INTERACTIVE_MIDI *pMIDIStream;

	pMIDIStream = (S_INTERACTIVE_MIDI*) pStream->handle;

	/* close synth */
	if (pMIDIStream->pSynth != NULL)
	{
		VMMIDIShutdown(pEASData, pMIDIStream->pSynth);
		pMIDIStream->pSynth = NULL;
	}

	/* release allocated memory */
	if (!pEASData->staticMemoryModel)
		EAS_HWFree(((S_EAS_DATA*) pEASData)->hwInstData, pMIDIStream);

	pStream->handle = NULL;
	return EAS_SUCCESS;
}

/*----------------------------------------------------------------------------
 * EAS_State()
 *----------------------------------------------------------------------------
 * Purpose: 
 * Returns the state of an audio file or stream. 
 *
 * Inputs:
 * pEASData			- pointer to overall EAS data structure
 * handle			- file or stream handle
 *		
 * Outputs:
 * 
 *
 * Side Effects:
 *
 *----------------------------------------------------------------------------
*/
EAS_PUBLIC EAS_RESULT EAS_State (EAS_DATA_HANDLE pEASData, EAS_HANDLE pStream, EAS_STATE *pState)
{
	S_FILE_PARSER_INTERFACE *pParserModule;
	EAS_RESULT result;

	/* call the parser to return state */
	pParserModule = (S_FILE_PARSER_INTERFACE*) pStream->pParserModule;
	if (pParserModule == NULL)
		return EAS_ERROR_FEATURE_NOT_AVAILABLE;

 	if ((result = (*pParserModule->pfState)(pEASData, pStream->handle, pState)) != EAS_SUCCESS)
		return result;

	/* if repeat count is set for this parser, mask the stopped state from the application */
	if (pStream->repeatCount && (*pState == EAS_STATE_STOPPED))
		*pState = EAS_STATE_PLAY;

	/* if we're not ready or playing, we don't need to hide state from host */
	if (*pState > EAS_STATE_PLAY)
		return EAS_SUCCESS;

	/* if stream is about to be paused, report it as paused */
	if (pStream->streamFlags & STREAM_FLAGS_PAUSE)
	{
		if (pStream->streamFlags & STREAM_FLAGS_LOCATE)
			*pState = EAS_STATE_PAUSED;
		else
			*pState = EAS_STATE_PAUSING;
	}
	
	/* if stream is about to resume, report it as playing */
	if (pStream->streamFlags & STREAM_FLAGS_RESUME)
		*pState = EAS_STATE_PLAY;
		
	return EAS_SUCCESS;
}

/*----------------------------------------------------------------------------
 * EAS_SetPolyphony()
 *----------------------------------------------------------------------------
 * Purpose: 
 * Set the polyphony of the stream. A value of 0 allows the stream
 * to use all voices (set by EAS_SetSynthPolyphony).
 *
 * Inputs:
 * pEASData			- pointer to overall EAS data structure
 * streamHandle		- handle returned by EAS_OpenFile
 * polyphonyCount	- the desired polyphony count
 *		
 * Outputs:
 *
 * Side Effects:
 *
 *----------------------------------------------------------------------------
*/
EAS_PUBLIC EAS_RESULT EAS_SetPolyphony (EAS_DATA_HANDLE pEASData, EAS_HANDLE pStream, EAS_I32 polyphonyCount)
{
	if (!EAS_StreamReady(pEASData, pStream))
		return EAS_ERROR_NOT_VALID_IN_THIS_STATE;
	return EAS_IntSetStrmParam(pEASData, pStream, PARSER_DATA_POLYPHONY, polyphonyCount);
}

/*----------------------------------------------------------------------------
 * EAS_GetPolyphony()
 *----------------------------------------------------------------------------
 * Purpose: 
 * Returns the current polyphony setting of the stream
 *
 * Inputs:
 * pEASData			- pointer to overall EAS data structure
 * streamHandle		- handle returned by EAS_OpenFile
 * pPolyphonyCount	- pointer to variable to receive polyphony count
 *		
 * Outputs:
 *
 * Side Effects:
 *
 *----------------------------------------------------------------------------
*/
EAS_PUBLIC EAS_RESULT EAS_GetPolyphony (EAS_DATA_HANDLE pEASData, EAS_HANDLE pStream, EAS_I32 *pPolyphonyCount)
{
	if (!EAS_StreamReady(pEASData, pStream))
		return EAS_ERROR_NOT_VALID_IN_THIS_STATE;
	return EAS_IntGetStrmParam(pEASData, pStream, PARSER_DATA_POLYPHONY, pPolyphonyCount);
}

/*----------------------------------------------------------------------------
 * EAS_SetSynthPolyphony()
 *----------------------------------------------------------------------------
 * Purpose: 
 * Set the polyphony of the synth . Value must be >= 1 and <= the
 * maximum number of voices. This function will pin the polyphony
 * at those limits
 *
 * Inputs:
 * pEASData			- pointer to overall EAS data structure
 * synthNum			- synthesizer number (0 = onboard, 1 = DSP)
 * polyphonyCount	- the desired polyphony count
 *		
 * Outputs:
 *
 * Side Effects:
 *
 *----------------------------------------------------------------------------
*/
EAS_PUBLIC EAS_RESULT EAS_SetSynthPolyphony (EAS_DATA_HANDLE pEASData, EAS_I32 synthNum, EAS_I32 polyphonyCount)
{
	return VMSetSynthPolyphony(pEASData->pVoiceMgr, synthNum, polyphonyCount);
}

/*----------------------------------------------------------------------------
 * EAS_GetSynthPolyphony()
 *----------------------------------------------------------------------------
 * Purpose: 
 * Returns the current polyphony setting of the synth
 *
 * Inputs:
 * pEASData			- pointer to overall EAS data structure
 * synthNum			- synthesizer number (0 = onboard, 1 = DSP)
 * pPolyphonyCount	- pointer to variable to receive polyphony count
 *		
 * Outputs:
 *
 * Side Effects:
 *
 *----------------------------------------------------------------------------
*/
EAS_PUBLIC EAS_RESULT EAS_GetSynthPolyphony (EAS_DATA_HANDLE pEASData, EAS_I32 synthNum, EAS_I32 *pPolyphonyCount)
{
	return VMGetSynthPolyphony(pEASData->pVoiceMgr, synthNum, pPolyphonyCount);
}

/*----------------------------------------------------------------------------
 * EAS_SetPriority()
 *----------------------------------------------------------------------------
 * Purpose: 
 * Set the priority of the stream. Determines which stream's voices
 * are stolen when there are insufficient voices for all notes.
 * Value must be in the range of 1-15, lower values are higher
 * priority.
 *
 * Inputs:
 * pEASData			- pointer to overall EAS data structure
 * streamHandle		- handle returned by EAS_OpenFile
 * polyphonyCount	- the desired polyphony count
 *		
 * Outputs:
 *
 * Side Effects:
 *
 *----------------------------------------------------------------------------
*/
EAS_PUBLIC EAS_RESULT EAS_SetPriority (EAS_DATA_HANDLE pEASData, EAS_HANDLE pStream, EAS_I32 priority)
{
	if (!EAS_StreamReady(pEASData, pStream))
		return EAS_ERROR_NOT_VALID_IN_THIS_STATE;
	return EAS_IntSetStrmParam(pEASData, pStream, PARSER_DATA_PRIORITY, priority);
}

/*----------------------------------------------------------------------------
 * EAS_GetPriority()
 *----------------------------------------------------------------------------
 * Purpose: 
 * Returns the current priority setting of the stream
 *
 * Inputs:
 * pEASData			- pointer to overall EAS data structure
 * streamHandle		- handle returned by EAS_OpenFile
 * pPriority		- pointer to variable to receive priority
 *		
 * Outputs:
 *
 * Side Effects:
 *
 *----------------------------------------------------------------------------
*/
EAS_PUBLIC EAS_RESULT EAS_GetPriority (EAS_DATA_HANDLE pEASData, EAS_HANDLE pStream, EAS_I32 *pPriority)
{
	if (!EAS_StreamReady(pEASData, pStream))
		return EAS_ERROR_NOT_VALID_IN_THIS_STATE;
	return EAS_IntGetStrmParam(pEASData, pStream, PARSER_DATA_PRIORITY, pPriority);
}

/*----------------------------------------------------------------------------
 * EAS_SetVolume()
 *----------------------------------------------------------------------------
 * Purpose: 
 * Set the master gain for the mix engine in 1dB increments
 *
 * Inputs:
 * pEASData			- pointer to overall EAS data structure
 * volume			- the desired master gain (100 is max)
 * handle			- file or stream handle
 *		
 * Outputs:
 *
 *
 * Side Effects:
 * overrides any previously set master volume from sysex
 *
 *----------------------------------------------------------------------------
*/
EAS_PUBLIC EAS_RESULT EAS_SetVolume (EAS_DATA_HANDLE pEASData, EAS_HANDLE pStream, EAS_I32 volume)
{
	EAS_I16 gain;

	/* check range */
	if ((volume < 0) || (volume > EAS_MAX_VOLUME))
		return EAS_ERROR_PARAMETER_RANGE;

	/* stream volume */
	if (pStream != NULL)
	{
		EAS_I32 gainOffset;
		EAS_RESULT result;
		
		if (!EAS_StreamReady(pEASData, pStream))
			return EAS_ERROR_NOT_VALID_IN_THIS_STATE;

		/* get gain offset */
		pStream->volume = (EAS_U8) volume;
		result = EAS_GetStreamParameter(pEASData, pStream, PARSER_DATA_GAIN_OFFSET, &gainOffset);
		if (result == EAS_SUCCESS)
			volume += gainOffset;

		/* set stream volume */
		gain = EAS_VolumeToGain(volume - STREAM_VOLUME_HEADROOM);	
		
		/* convert to linear scalar */
		return EAS_IntSetStrmParam(pEASData, pStream, PARSER_DATA_VOLUME, gain);
	}

	/* master volume */
	pEASData->masterVolume = (EAS_U8) volume;
#if (NUM_OUTPUT_CHANNELS == 1)
	/* leave 3dB headroom for mono output */		
	volume -= 3;
#endif

	gain = EAS_VolumeToGain(volume - STREAM_VOLUME_HEADROOM);	
	pEASData->masterGain = gain;
	return EAS_SUCCESS;
}

/*----------------------------------------------------------------------------
 * EAS_GetVolume()
 *----------------------------------------------------------------------------
 * Purpose: 
 * Returns the master volume for the synthesizer. The default volume setting is
 * 50. The volume range is 0 to 100;
 *
 * Inputs:
 * pEASData			- pointer to overall EAS data structure
 * volume			- the desired master volume
 * handle			- file or stream handle
 *		
 * Outputs:
 *
 *
 * Side Effects:
 * overrides any previously set master volume from sysex
 *
 *----------------------------------------------------------------------------
*/
EAS_PUBLIC EAS_I32 EAS_GetVolume (EAS_DATA_HANDLE pEASData, EAS_HANDLE pStream)
{
	if (pStream == NULL)
		return pEASData->masterVolume;
	
	if (!EAS_StreamReady(pEASData, pStream))
		return EAS_ERROR_NOT_VALID_IN_THIS_STATE;
	return pStream->volume;
}

/*----------------------------------------------------------------------------
 * EAS_SetMaxLoad()
 *----------------------------------------------------------------------------
 * Purpose: 
 * Sets the maximum workload the parsers will do in a single call to
 * EAS_Render. The units are currently arbitrary, but should correlate
 * well to the actual CPU cycles consumed. The primary effect is to
 * reduce the occasional peaks in CPU cycles consumed when parsing
 * dense parts of a MIDI score. 
 *
 * Inputs:
 *	pEASData		- handle to data for this instance
 *	maxLoad			- the desired maximum workload
 *		
 * Outputs:
 *
 * Side Effects:
 *
 *----------------------------------------------------------------------------
*/
EAS_PUBLIC EAS_RESULT EAS_SetMaxLoad (EAS_DATA_HANDLE pEASData, EAS_I32 maxLoad)
{
	VMSetWorkload(pEASData->pVoiceMgr, maxLoad);
	return EAS_SUCCESS;
}

/*----------------------------------------------------------------------------
 * EAS_SetMaxPCMStreams()
 *----------------------------------------------------------------------------
 * Sets the maximum number of PCM streams allowed in parsers that
 * use PCM streaming.
 *
 * Inputs:
 * pEASData			- pointer to overall EAS data structure
 * streamHandle		- handle returned by EAS_OpenFile
 * maxNumStreams	- maximum number of PCM streams
 *----------------------------------------------------------------------------
*/
EAS_PUBLIC EAS_RESULT EAS_SetMaxPCMStreams (EAS_DATA_HANDLE pEASData, EAS_HANDLE pStream, EAS_I32 maxNumStreams)
{
	if (!EAS_StreamReady(pEASData, pStream))
		return EAS_ERROR_NOT_VALID_IN_THIS_STATE;
	return EAS_IntSetStrmParam(pEASData, pStream, PARSER_DATA_MAX_PCM_STREAMS, maxNumStreams);
}

/*----------------------------------------------------------------------------
 * EAS_Locate()
 *----------------------------------------------------------------------------
 * Purpose: 
 * Locate into the file associated with the handle.
 *
 * Inputs:
 * pEASData - pointer to overall EAS data structure
 * handle			- file handle
 * milliseconds		- playback offset from start of file in milliseconds
 *		
 * Outputs:
 * 
 *
 * Side Effects:
 * the actual offset will be quantized to the closest update period, typically
 * a resolution of 5.9ms. Notes that are started prior to this time will not
 * sound. Any notes currently playing will be shut off.
 *
 *----------------------------------------------------------------------------
*/
EAS_PUBLIC EAS_RESULT EAS_Locate (EAS_DATA_HANDLE pEASData, EAS_HANDLE pStream, EAS_I32 milliseconds, EAS_BOOL offset)
{
	S_FILE_PARSER_INTERFACE *pParserModule;
	EAS_RESULT result;
	EAS_U32 requestedTime;
	EAS_STATE state;

	/* get pointer to parser function table */
	pParserModule = (S_FILE_PARSER_INTERFACE*) pStream->pParserModule;
	if (pParserModule == NULL)
		return EAS_ERROR_FEATURE_NOT_AVAILABLE;
	
	if ((result = (*pParserModule->pfState)(pEASData, pStream->handle, &state)) != EAS_SUCCESS)
		return result;
	if (state >= EAS_STATE_OPEN)
		return EAS_ERROR_NOT_VALID_IN_THIS_STATE;

	/* handle offset and limit to start of file */
	/*lint -e{704} use shift for performance*/
	if (offset)
		milliseconds += (EAS_I32) pStream->time >> 8;
	if (milliseconds < 0)
		milliseconds = 0;
	
	/* check to see if the request is different from the current time */
	requestedTime = (EAS_U32) milliseconds;
	if (requestedTime == (pStream->time >> 8))
		return EAS_SUCCESS;

	/* set the locate flag */
	pStream->streamFlags |= STREAM_FLAGS_LOCATE;

	/* use the parser locate function, if available */
	if (pParserModule->pfLocate != NULL)
	{
		EAS_BOOL parserLocate = EAS_FALSE;
		result = pParserModule->pfLocate(pEASData, pStream->handle, (EAS_I32) requestedTime, &parserLocate);
		if (!parserLocate)
		{
			if (result == EAS_SUCCESS)
				pStream->time = requestedTime << 8;
			return result;
		}
	}

	/* if we were paused and not going to resume, set pause request flag */
	if (((state == EAS_STATE_PAUSING) || (state == EAS_STATE_PAUSED)) && ((pStream->streamFlags & STREAM_FLAGS_RESUME) == 0))
		pStream->streamFlags |= STREAM_FLAGS_PAUSE;

	/* reset the synth and parser */
	if ((result = (*pParserModule->pfReset)(pEASData, pStream->handle)) != EAS_SUCCESS)
		return result;
	pStream->time = 0;

	/* locating forward, clear parsed flag and parse data until we get to the requested location */
	if ((result = EAS_ParseEvents(pEASData, pStream, requestedTime << 8, eParserModeLocate)) != EAS_SUCCESS)
		return result;

	return EAS_SUCCESS;
}

/*----------------------------------------------------------------------------
 * EAS_GetLocation()
 *----------------------------------------------------------------------------
 * Purpose: 
 * Returns the current playback offset 
 *
 * Inputs:
 * pEASData			- pointer to overall EAS data structure
 * handle			- file handle
 *		
 * Outputs:
 * The offset in milliseconds from the start of the current sequence, quantized
 * to the nearest update period. Actual resolution is typically 5.9 ms.
 *
 * Side Effects:
 *
 *----------------------------------------------------------------------------
*/
/*lint -esym(715, pEASData) reserved for future use */
EAS_PUBLIC EAS_RESULT EAS_GetLocation (EAS_DATA_HANDLE pEASData, EAS_HANDLE pStream, EAS_I32 *pTime)
{
	if (!EAS_StreamReady(pEASData, pStream))
		return EAS_ERROR_NOT_VALID_IN_THIS_STATE;

	*pTime = pStream->time >> 8;
	return EAS_SUCCESS;
}

/*----------------------------------------------------------------------------
 * EAS_GetRenderTime()
 *----------------------------------------------------------------------------
 * Purpose: 
 * Returns the current playback offset 
 *
 * Inputs:
 * pEASData			- pointer to overall EAS data structure
 *		
 * Outputs:
 * Gets the render time clock in msecs.
 *
 * Side Effects:
 *
 *----------------------------------------------------------------------------
*/
EAS_PUBLIC EAS_RESULT EAS_GetRenderTime (EAS_DATA_HANDLE pEASData, EAS_I32 *pTime)
{
	*pTime = pEASData->renderTime >> 8;
	return EAS_SUCCESS;
}

/*----------------------------------------------------------------------------
 * EAS_Pause()
 *----------------------------------------------------------------------------
 * Purpose: 
 * Pauses the playback of the data associated with this handle. The audio
 * is gracefully ramped down to prevent clicks and pops. It may take several
 * buffers of audio before the audio is muted.
 *
 * Inputs:
 * psEASData		- pointer to overall EAS data structure
 * handle			- file or stream handle
 *		
 * Outputs:
 * 
 *
 * Side Effects:
 *
 *
 *----------------------------------------------------------------------------
*/
EAS_PUBLIC EAS_RESULT EAS_Pause (EAS_DATA_HANDLE pEASData, EAS_HANDLE pStream)
{
	S_FILE_PARSER_INTERFACE *pParserModule;
	EAS_STATE state;
	EAS_RESULT result;

	pParserModule = (S_FILE_PARSER_INTERFACE*) pStream->pParserModule;
	if (pParserModule == NULL)
		return EAS_ERROR_FEATURE_NOT_AVAILABLE;

	/* check for valid state */
	result = pParserModule->pfState(pEASData, pStream->handle, &state);
	if (result == EAS_SUCCESS)
	{
		if ((state != EAS_STATE_PLAY) && (state != EAS_STATE_READY) && ((pStream->streamFlags & STREAM_FLAGS_RESUME) == 0))
			return EAS_ERROR_NOT_VALID_IN_THIS_STATE;

		/* make sure parser implements pause */
		if (pParserModule->pfPause == NULL)
			result = EAS_ERROR_NOT_IMPLEMENTED;

		/* clear resume flag */
		pStream->streamFlags &= ~STREAM_FLAGS_RESUME;

		/* set pause flag */
		pStream->streamFlags |= STREAM_FLAGS_PAUSE;

#if 0		
		/* pause the stream */
		if (pParserModule->pfPause)
			result = pParserModule->pfPause(pEASData, pStream->handle);
		else
			result = EAS_ERROR_NOT_IMPLEMENTED;
#endif		
	}

	return result;
}

/*----------------------------------------------------------------------------
 * EAS_Resume()
 *----------------------------------------------------------------------------
 * Purpose: 
 * Resumes the playback of the data associated with this handle. The audio
 * is gracefully ramped up to prevent clicks and pops.
 *
 * Inputs:
 * psEASData		- pointer to overall EAS data structure
 * handle			- file or stream handle
 *		
 * Outputs:
 * 
 *
 * Side Effects:
 *
 *
 *----------------------------------------------------------------------------
*/
EAS_PUBLIC EAS_RESULT EAS_Resume (EAS_DATA_HANDLE pEASData, EAS_HANDLE pStream)
{
	S_FILE_PARSER_INTERFACE *pParserModule;
	EAS_STATE state;
	EAS_RESULT result;

	pParserModule = (S_FILE_PARSER_INTERFACE*) pStream->pParserModule;
	if (pParserModule == NULL)
		return EAS_ERROR_FEATURE_NOT_AVAILABLE;

	/* check for valid state */
	result = pParserModule->pfState(pEASData, pStream->handle, &state);
	if (result == EAS_SUCCESS)
	{
		if ((state != EAS_STATE_PAUSED) && (state != EAS_STATE_PAUSING) && ((pStream->streamFlags & STREAM_FLAGS_PAUSE) == 0))
			return EAS_ERROR_NOT_VALID_IN_THIS_STATE;

		/* make sure parser implements this function */
		if (pParserModule->pfResume == NULL)
			result = EAS_ERROR_NOT_IMPLEMENTED;

		/* clear pause flag */
		pStream->streamFlags &= ~STREAM_FLAGS_PAUSE;

		/* set resume flag */
		pStream->streamFlags |= STREAM_FLAGS_RESUME;

#if 0		
		/* resume the stream */
		if (pParserModule->pfResume)
			result = pParserModule->pfResume(pEASData, pStream->handle);
		else
			result = EAS_ERROR_NOT_IMPLEMENTED;
#endif		
	}

	return result;
}

/*----------------------------------------------------------------------------
 * EAS_GetParameter()
 *----------------------------------------------------------------------------
 * Purpose: 
 * Set the parameter of a module. See E_MODULES for a list of modules
 * and the header files of the modules for a list of parameters.
 *
 * Inputs:
 * psEASData		- pointer to overall EAS data structure
 * handle			- file or stream handle
 * module			- enumerated module number
 * param			- enumerated parameter number
 * pValue			- pointer to variable to receive parameter value
 *		
 * Outputs:
 * 
 *
 * Side Effects:
 *
 *
 *----------------------------------------------------------------------------
*/
EAS_PUBLIC EAS_RESULT EAS_GetParameter (EAS_DATA_HANDLE pEASData, EAS_I32 module, EAS_I32 param, EAS_I32 *pValue)
{

	if (module >= NUM_EFFECTS_MODULES)
		return EAS_ERROR_INVALID_MODULE;
	
	if (pEASData->effectsModules[module].effectData == NULL)
		return EAS_ERROR_INVALID_MODULE;
	
	return (*pEASData->effectsModules[module].effect->pFGetParam)
		(pEASData->effectsModules[module].effectData, param, pValue);
}

/*----------------------------------------------------------------------------
 * EAS_SetParameter()
 *----------------------------------------------------------------------------
 * Purpose: 
 * Set the parameter of a module. See E_MODULES for a list of modules
 * and the header files of the modules for a list of parameters.
 *
 * Inputs:
 * psEASData		- pointer to overall EAS data structure
 * handle			- file or stream handle
 * module			- enumerated module number
 * param			- enumerated parameter number
 * value			- new parameter value
 *		
 * Outputs:
 * 
 *
 * Side Effects:
 *
 *
 *----------------------------------------------------------------------------
*/
EAS_PUBLIC EAS_RESULT EAS_SetParameter (EAS_DATA_HANDLE pEASData, EAS_I32 module, EAS_I32 param, EAS_I32 value)
{

	if (module >= NUM_EFFECTS_MODULES)
		return EAS_ERROR_INVALID_MODULE;
	
	if (pEASData->effectsModules[module].effectData == NULL)
		return EAS_ERROR_INVALID_MODULE;

	return (*pEASData->effectsModules[module].effect->pFSetParam)
		(pEASData->effectsModules[module].effectData, param, value);
}

#ifdef _METRICS_ENABLED	
/*----------------------------------------------------------------------------
 * EAS_MetricsReport()
 *----------------------------------------------------------------------------
 * Purpose: 
 * Displays the current metrics through the metrics interface.
 *
 * Inputs:
 * p				- instance data handle
 *		
 * Outputs:
 * 
 *
 * Side Effects:
 *
 *----------------------------------------------------------------------------
*/
EAS_PUBLIC EAS_RESULT EAS_MetricsReport (EAS_DATA_HANDLE pEASData)
{
	if (!pEASData->pMetricsModule)
		return EAS_ERROR_INVALID_MODULE;

	return (*pEASData->pMetricsModule->pfReport)(pEASData->pMetricsData);
}

/*----------------------------------------------------------------------------
 * EAS_MetricsReset()
 *----------------------------------------------------------------------------
 * Purpose: 
 * Resets the metrics.
 *
 * Inputs:
 * p				- instance data handle
 *		
 * Outputs:
 * 
 *
 * Side Effects:
 *
 *----------------------------------------------------------------------------
*/
EAS_PUBLIC EAS_RESULT EAS_MetricsReset (EAS_DATA_HANDLE pEASData)
{

	if (!pEASData->pMetricsModule)
		return EAS_ERROR_INVALID_MODULE;

	return (*pEASData->pMetricsModule->pfReset)(pEASData->pMetricsData);
}
#endif

/*----------------------------------------------------------------------------
 * EAS_SetSoundLibrary()
 *----------------------------------------------------------------------------
 * Purpose: 
 * Sets the location of the sound library.
 *
 * Inputs:
 * pEASData				- instance data handle
 * pSoundLib			- pointer to sound library
 *		
 * Outputs:
 * 
 *
 * Side Effects:
 *
 *----------------------------------------------------------------------------
*/
EAS_PUBLIC EAS_RESULT EAS_SetSoundLibrary (EAS_DATA_HANDLE pEASData, EAS_HANDLE pStream, EAS_SNDLIB_HANDLE pSndLib)
{
	if (pStream)
	{
		if (!EAS_StreamReady(pEASData, pStream))
			return EAS_ERROR_NOT_VALID_IN_THIS_STATE;
		return EAS_IntSetStrmParam(pEASData, pStream, PARSER_DATA_EAS_LIBRARY, (EAS_I32) pSndLib);
	}

	return VMSetGlobalEASLib(pEASData->pVoiceMgr, pSndLib);
}

/*----------------------------------------------------------------------------
 * EAS_SetHeaderSearchFlag()
 *----------------------------------------------------------------------------
 * By default, when EAS_OpenFile is called, the parsers check the
 * first few bytes of the file looking for a specific header. Some
 * mobile devices may add a header to the start of a file, which
 * will prevent the parser from recognizing the file. If the
 * searchFlag is set to EAS_TRUE, the parser will search the entire
 * file looking for the header. This may enable EAS to recognize
 * some files that it would ordinarily reject. The negative is that
 * it make take slightly longer to process the EAS_OpenFile request.
 *
 * Inputs:
 * pEASData				- instance data handle
 * searchFlag			- search flag (EAS_TRUE or EAS_FALSE)
 *----------------------------------------------------------------------------
*/
EAS_PUBLIC EAS_RESULT EAS_SetHeaderSearchFlag (EAS_DATA_HANDLE pEASData, EAS_BOOL searchFlag)
{
	pEASData->searchHeaderFlag = (EAS_BOOL8) searchFlag;
	return EAS_SUCCESS;
}

/*----------------------------------------------------------------------------
 * EAS_SetPlayMode()
 *----------------------------------------------------------------------------
 * Some file formats support special play modes, such as iMode partial
 * play mode. This call can be used to change the play mode. The
 * default play mode (usually straight playback) is always zero.
 *
 * Inputs:
 * pEASData				- instance data handle
 * handle				- file or stream handle
 * playMode				- play mode (see file parser for specifics)
 *----------------------------------------------------------------------------
*/
EAS_PUBLIC EAS_RESULT EAS_SetPlayMode (EAS_DATA_HANDLE pEASData, EAS_HANDLE pStream, EAS_I32 playMode)
{
	return EAS_IntSetStrmParam(pEASData, pStream, PARSER_DATA_PLAY_MODE, playMode);
}

#ifdef DLS_SYNTHESIZER
/*----------------------------------------------------------------------------
 * EAS_LoadDLSCollection()
 *----------------------------------------------------------------------------
 * Purpose: 
 * Sets the location of the sound library.
 *
 * Inputs:
 * pEASData				- instance data handle
 * pSoundLib			- pointer to sound library
 *		
 * Outputs:
 * 
 *
 * Side Effects:
 *
 *----------------------------------------------------------------------------
*/
EAS_PUBLIC EAS_RESULT EAS_LoadDLSCollection (EAS_DATA_HANDLE pEASData, EAS_HANDLE pStream, EAS_FILE_LOCATOR locator)
{
	EAS_FILE_HANDLE fileHandle;
	EAS_RESULT result;
	EAS_DLSLIB_HANDLE pDLS;

	if (pStream != NULL)
	{
		if (!EAS_StreamReady(pEASData, pStream))
			return EAS_ERROR_NOT_VALID_IN_THIS_STATE;
	}

	/* open the file */
	if ((result = EAS_HWOpenFile(pEASData->hwInstData, locator, &fileHandle, EAS_FILE_READ)) != EAS_SUCCESS)
		return result;

	/* parse the file */
	result = DLSParser(pEASData->hwInstData, fileHandle, 0, &pDLS);
	EAS_HWCloseFile(pEASData->hwInstData, fileHandle);

	if (result == EAS_SUCCESS)
	{
		
		/* if a stream pStream is specified, point it to the DLS collection */
		if (pStream)
			result = EAS_IntSetStrmParam(pEASData, pStream, PARSER_DATA_DLS_COLLECTION, (EAS_I32) pDLS);

		/* global DLS load */
		else
			result = VMSetGlobalDLSLib(pEASData, pDLS);
	}		

	return result;
}
#endif

#ifdef EXTERNAL_AUDIO
/*----------------------------------------------------------------------------
 * EAS_RegExtAudioCallback()
 *----------------------------------------------------------------------------
 * Purpose: 
 * Registers callback functions for audio events.
 *
 * Inputs:
 * pEASData			- pointer to overall EAS data structure
 * handle			- file or stream handle
 * cbProgChgFunc	- pointer to host callback function for program change
 * cbEventFunc		- pointer to host callback functio for note events
 *		
 * Outputs:
 * 
 *
 * Side Effects:
 *
 *----------------------------------------------------------------------------
*/
EAS_PUBLIC EAS_RESULT EAS_RegExtAudioCallback (EAS_DATA_HANDLE pEASData,
	EAS_HANDLE pStream,
	EAS_VOID_PTR pInstData,
	EAS_EXT_PRG_CHG_FUNC cbProgChgFunc,
	EAS_EXT_EVENT_FUNC cbEventFunc)
{
	S_SYNTH *pSynth;
	
	if (!EAS_StreamReady(pEASData, pStream))
		return EAS_ERROR_NOT_VALID_IN_THIS_STATE;
	
	if (EAS_GetStreamParameter(pEASData, pStream, PARSER_DATA_SYNTH_HANDLE, (EAS_I32*) &pSynth) != EAS_SUCCESS)
		return EAS_ERROR_INVALID_PARAMETER;

	if (pSynth == NULL)
		return EAS_ERROR_INVALID_PARAMETER;

	VMRegExtAudioCallback(pSynth, pInstData, cbProgChgFunc, cbEventFunc);
	return EAS_SUCCESS;
}

/*----------------------------------------------------------------------------
 * EAS_GetMIDIControllers()
 *----------------------------------------------------------------------------
 * Purpose: 
 * Returns the current state of MIDI controllers on the requested channel.
 *
 * Inputs:
 * pEASData			- pointer to overall EAS data structure
 * handle			- file or stream handle
 * pControl			- pointer to structure to receive data
 *		
 * Outputs:
 * 
 *
 * Side Effects:
 *
 *----------------------------------------------------------------------------
*/
EAS_PUBLIC EAS_RESULT EAS_GetMIDIControllers (EAS_DATA_HANDLE pEASData, EAS_HANDLE pStream, EAS_U8 channel, S_MIDI_CONTROLLERS *pControl)
{
	S_SYNTH *pSynth;
	
	if (!EAS_StreamReady(pEASData, pStream))
		return EAS_ERROR_NOT_VALID_IN_THIS_STATE;
	
	if (EAS_GetStreamParameter(pEASData, pStream, PARSER_DATA_SYNTH_HANDLE, (EAS_I32*) &pSynth) != EAS_SUCCESS)
		return EAS_ERROR_INVALID_PARAMETER;

	if (pSynth == NULL)
		return EAS_ERROR_INVALID_PARAMETER;

	VMGetMIDIControllers(pSynth, channel, pControl);
	return EAS_SUCCESS;
}
#endif

#ifdef _SPLIT_ARCHITECTURE
/*----------------------------------------------------------------------------
 * EAS_SetFrameBuffer()
 *----------------------------------------------------------------------------
 * Purpose: 
 * Sets the frame buffer pointer passed to the IPC communications functions
 *
 * Inputs:
 * pEASData				- instance data handle
 * locator				- file locator
 *		
 * Outputs:
 * 
 *
 * Side Effects:
 * May overlay instruments in the GM sound set
 *
 *----------------------------------------------------------------------------
*/
EAS_PUBLIC EAS_RESULT EAS_SetFrameBuffer (EAS_DATA_HANDLE pEASData, EAS_FRAME_BUFFER_HANDLE pFrameBuffer)
{
	if (pEASData->pVoiceMgr)
		pEASData->pVoiceMgr->pFrameBuffer = pFrameBuffer;
	return EAS_SUCCESS;
}
#endif

/*----------------------------------------------------------------------------
 * EAS_SearchFile
 *----------------------------------------------------------------------------
 * Search file for specific sequence starting at current file
 * position. Returns offset to start of sequence.
 *
 * Inputs:
 * pEASData			- pointer to EAS persistent data object
 * fileHandle		- file handle
 * searchString		- pointer to search sequence
 * len				- length of search sequence
 * pOffset			- pointer to variable to store offset to sequence
 *
 * Returns EAS_EOF if end-of-file is reached
 *----------------------------------------------------------------------------
*/
EAS_RESULT EAS_SearchFile (S_EAS_DATA *pEASData, EAS_FILE_HANDLE fileHandle, const EAS_U8 *searchString, EAS_I32 len, EAS_I32 *pOffset)
{
	EAS_RESULT result;
	EAS_INT index;
	EAS_U8 c;

	*pOffset = -1;
	index = 0;
	for (;;)
	{
		result = EAS_HWGetByte(pEASData->hwInstData, fileHandle, &c);
		if (result != EAS_SUCCESS)
			return result;
		if (c == searchString[index])
		{
			index++;
			if (index == 4)
			{
				result = EAS_HWFilePos(pEASData->hwInstData, fileHandle, pOffset);
				if (result != EAS_SUCCESS)
					return result;
				*pOffset -= len;
				break;
			}
		}
		else
			index = 0;
	}
	return EAS_SUCCESS;
}