path: root/arm-fm-22k/lib_src/eas_pcm.c

/*----------------------------------------------------------------------------
 *
 * File: 
 * eas_pcm.c
 *
 * Contents and purpose:
 * Implements the PCM engine including ADPCM decode for SMAF and CMX audio playback.
 *
 * 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: 849 $
 *   $Date: 2007-08-28 08:59:11 -0700 (Tue, 28 Aug 2007) $
 *----------------------------------------------------------------------------
*/

#include "eas_data.h"
#include "eas_report.h"
#include "eas_host.h"
#include "eas_config.h"
#include "eas_parser.h"
#include "eas_pcm.h"
#include "eas_math.h"
#include "eas_mixer.h"

#define PCM_MIXER_GUARD_BITS (NUM_MIXER_GUARD_BITS + 1)

/*----------------------------------------------------------------------------
 * Decoder interfaces
 *----------------------------------------------------------------------------
*/

static EAS_RESULT LinearPCMDecode (EAS_DATA_HANDLE pEASData, S_PCM_STATE *pState);
static EAS_RESULT LinearPCMLocate (EAS_DATA_HANDLE pEASData, S_PCM_STATE *pState, EAS_I32 time);

static const S_DECODER_INTERFACE PCMDecoder = 
{
	NULL,
	LinearPCMDecode,
	LinearPCMLocate,
};

/* SMAF ADPCM decoder */
#ifdef _SMAF_PARSER
extern S_DECODER_INTERFACE SmafDecoder;
#define SMAF_DECODER &SmafDecoder
extern S_DECODER_INTERFACE Smaf7BitDecoder;
#define SMAF_7BIT_DECODER &Smaf7BitDecoder
#else
#define SMAF_DECODER NULL
#define SMAF_7BIT_DECODER NULL
#endif

/* IMA ADPCM decoder */
#ifdef _IMA_DECODER
extern S_DECODER_INTERFACE IMADecoder;
#define IMA_DECODER &IMADecoder
#else
#define IMA_DECODER NULL
#endif

static const S_DECODER_INTERFACE * const decoders[] =
{
	&PCMDecoder,
	SMAF_DECODER,
	IMA_DECODER,
	SMAF_7BIT_DECODER
};

/*----------------------------------------------------------------------------
 * Sample rate conversion
 *----------------------------------------------------------------------------
*/

#define SRC_RATE_MULTIPLER (0x40000000 / _OUTPUT_SAMPLE_RATE)

#ifdef _LOOKUP_SAMPLE_RATE	
static const EAS_U32 srcConvRate[][2] =
{
	4000L, (4000L << 15) / _OUTPUT_SAMPLE_RATE,
	8000L, (8000L << 15) / _OUTPUT_SAMPLE_RATE,
	11025L, (11025L << 15) / _OUTPUT_SAMPLE_RATE,
	12000L, (12000L << 15) / _OUTPUT_SAMPLE_RATE,
	16000L, (16000L << 15) / _OUTPUT_SAMPLE_RATE,
	22050L, (22050L << 15) / _OUTPUT_SAMPLE_RATE,
	24000L, (24000L << 15) / _OUTPUT_SAMPLE_RATE,
	32000L, (32000L << 15) / _OUTPUT_SAMPLE_RATE
};
static EAS_U32 CalcBaseFreq (EAS_U32 sampleRate);
#define SRC_CONV_RATE_ENTRIES (sizeof(srcConvRate)/sizeof(EAS_U32)/2)
#endif


/* interface prototypes */
static EAS_RESULT RenderPCMStream (S_EAS_DATA *pEASData, S_PCM_STATE *pState, EAS_I32 numSamples);


/* local prototypes */
static S_PCM_STATE *FindSlot (S_EAS_DATA *pEASData, EAS_FILE_HANDLE fileHandle, EAS_PCM_CALLBACK pCallbackFunc, EAS_VOID_PTR cbInstData);
static EAS_RESULT InitPCMStream (S_EAS_DATA *pEASData, S_PCM_STATE *pState);

/*----------------------------------------------------------------------------
 * EAS_PEInit()
 *----------------------------------------------------------------------------
 * Purpose: 
 * Initializes the PCM engine
 *
 * Inputs:
 * 
 *		
 * Outputs:
 * 
 *
 * Side Effects:
 *
 *----------------------------------------------------------------------------
*/
EAS_RESULT EAS_PEInit (S_EAS_DATA *pEASData)
{
	S_PCM_STATE *pState;
	EAS_INT i;

	/* check for static memory allocation */
	if (pEASData->staticMemoryModel)
		pEASData->pPCMStreams = EAS_CMEnumData(EAS_CM_PCM_DATA);
	/* allocate dynamic memory */
	else
		pEASData->pPCMStreams = EAS_HWMalloc(pEASData->hwInstData, sizeof(S_PCM_STATE) * MAX_PCM_STREAMS);

	if (!pEASData->pPCMStreams)
	{
		{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_FATAL, "Failed to allocate memory for PCM streams\n"); */ }
		return EAS_ERROR_MALLOC_FAILED;
	}
	
	//zero the memory to insure complete initialization
	EAS_HWMemSet((void *)(pEASData->pPCMStreams),0, sizeof(S_PCM_STATE) * MAX_PCM_STREAMS);

	/* initialize the state data */
	for (i = 0, pState = pEASData->pPCMStreams; i < MAX_PCM_STREAMS; i++, pState++)
		pState->fileHandle = NULL;
	
	return EAS_SUCCESS;
}

/*----------------------------------------------------------------------------
 * EAS_PEShutdown()
 *----------------------------------------------------------------------------
 * Purpose: 
 * Shuts down the PCM engine
 *
 * Inputs:
 * 
 *		
 * Outputs:
 * 
 *
 * Side Effects:
 *
 *----------------------------------------------------------------------------
*/
EAS_RESULT EAS_PEShutdown (S_EAS_DATA *pEASData)
{

	/* free any dynamic memory */
	if (!pEASData->staticMemoryModel)
	{
		if (pEASData->pPCMStreams)
		{
			EAS_HWFree(pEASData->hwInstData, pEASData->pPCMStreams);
			pEASData->pPCMStreams = NULL;
		}
	}	
	return EAS_SUCCESS;
}

/*----------------------------------------------------------------------------
 * EAS_PERender()
 *----------------------------------------------------------------------------
 * Purpose: 
 * Render a buffer of PCM audio
 *
 * Inputs:
 * 
 *		
 * Outputs:
 * 
 *
 * Side Effects:
 *
 *----------------------------------------------------------------------------
*/
EAS_RESULT EAS_PERender (S_EAS_DATA* pEASData, EAS_I32 numSamples)
{
	S_PCM_STATE *pState;
	EAS_RESULT result;
	EAS_INT i;

	/* render all the active streams */	
	for (i = 0, pState = pEASData->pPCMStreams; i < MAX_PCM_STREAMS; i++, pState++)
	{
		if ((pState->fileHandle) && (pState->state != EAS_STATE_STOPPED) && (pState->state != EAS_STATE_PAUSED))
			if ((result = RenderPCMStream(pEASData, pState, numSamples)) != EAS_SUCCESS)
				return result;
	}
	return EAS_SUCCESS;
}


/*----------------------------------------------------------------------------
 * EAS_PEState()
 *----------------------------------------------------------------------------
 * 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:
 *
 * Notes:
 * This interface is also exposed in the internal library for use by the other modules.
 *----------------------------------------------------------------------------
*/
/*lint -esym(715, pEASData) reserved for future use */
EAS_RESULT EAS_PEState (S_EAS_DATA *pEASData, EAS_PCM_HANDLE pInstData, EAS_STATE *pState)
{
	/* return current state */
	*pState = pInstData->state;
	return EAS_SUCCESS;
}

/*----------------------------------------------------------------------------
 * EAS_PEClose()
 *----------------------------------------------------------------------------
 * Purpose: 
 * Close the file and clean up
 *
 * Inputs:
 * pEASData			- pointer to overall EAS data structure
 * handle			- pointer to file handle
 *		
 * Outputs:
 * 
 *
 * Side Effects:
 *
 *----------------------------------------------------------------------------
*/
EAS_RESULT EAS_PEClose (S_EAS_DATA *pEASData, EAS_PCM_HANDLE pState)
{
	EAS_RESULT result;

	if ((result = EAS_HWCloseFile(pEASData->hwInstData, pState->fileHandle)) != EAS_SUCCESS)
		return result;

	pState->fileHandle = NULL;
	return EAS_SUCCESS;
}

/*----------------------------------------------------------------------------
 * PCM_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:
 *
 *----------------------------------------------------------------------------
*/
EAS_RESULT EAS_PEReset (S_EAS_DATA *pEASData, EAS_PCM_HANDLE pState)
{
	EAS_RESULT result;

	/* reset file position to first byte of data in the stream */
	if ((result = EAS_HWFileSeek(pEASData->hwInstData, pState->fileHandle, pState->startPos)) != EAS_SUCCESS)
	{
		{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "Error %d seeking to start of PCM file\n", result); */ }
		return result;
	}

	/* re-initialize stream */
	return InitPCMStream(pEASData, pState);
}

/*----------------------------------------------------------------------------
 * EAS_PEOpenStream()
 *----------------------------------------------------------------------------
 * Purpose: 
 * Starts up a PCM playback
 *
 * Inputs:
 * 
 *		
 * Outputs:
 * 
 *
 * Side Effects:
 *
 *----------------------------------------------------------------------------
*/
EAS_RESULT EAS_PEOpenStream (S_EAS_DATA *pEASData, S_PCM_OPEN_PARAMS *pParams, EAS_PCM_HANDLE *pHandle)
{
	EAS_RESULT result;
	S_PCM_STATE *pState;
	EAS_I32 filePos;

	/* make sure we support this decoder */
	if (pParams->decoder >= NUM_DECODER_MODULES)
	{
		{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "Decoder selector out of range\n"); */ }
		return EAS_ERROR_PARAMETER_RANGE;
	}
	if (decoders[pParams->decoder] == NULL)
	{
		{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "Decoder module not available\n"); */ }
		return EAS_ERROR_FEATURE_NOT_AVAILABLE;
	}
	
	/* find a slot for the new stream */
	if ((pState = FindSlot(pEASData, pParams->fileHandle, pParams->pCallbackFunc, pParams->cbInstData)) == NULL)
	{
		{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "Unable to open ADPCM stream, too many streams open\n"); */ }
		return EAS_ERROR_MAX_PCM_STREAMS;
	}

	/* get the current file position */
	if ((result = EAS_HWFilePos(pEASData->hwInstData, pState->fileHandle, &filePos)) != EAS_SUCCESS)
	{
		{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "EAS_HWFilePos returned %ld\n",result); */ }
		pState->fileHandle = NULL;
		return result;
	}
	
	pState->pDecoder = decoders[pParams->decoder];
	pState->startPos = filePos;
	pState->bytesLeftLoop = pState->byteCount = pParams->size;
	pState->loopStart = pParams->loopStart;
	pState->samplesTilLoop = (EAS_I32) pState->loopStart;
	pState->loopSamples = pParams->loopSamples;
	pState->samplesInLoop = 0;
	pState->blockSize = (EAS_U16) pParams->blockSize;
	pState->flags = pParams->flags;
	pState->envData = pParams->envData;
	pState->volume = pParams->volume;
	pState->sampleRate = (EAS_U16) pParams->sampleRate;

	/* set the base frequency */
	pState->basefreq = (SRC_RATE_MULTIPLER * (EAS_U32) pParams->sampleRate) >> 15;

	/* calculate shift for frequencies > 1.0 */
	pState->rateShift = 0;
	while (pState->basefreq > 32767)
	{
		pState->basefreq = pState->basefreq >> 1;
		pState->rateShift++;
	}

	/* initialize */
	if ((result = InitPCMStream(pEASData, pState)) != EAS_SUCCESS)
		return result;
	
	*pHandle = pState;
	
	{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_DETAIL, "EAS_PEOpenStream: StartPos=%d, byteCount = %d, loopSamples=%d\n", 
		pState->startPos, pState->byteCount, pState->loopSamples); */ }
	return EAS_SUCCESS;
}

/*----------------------------------------------------------------------------
 * EAS_PEContinueStream()
 *----------------------------------------------------------------------------
 * Purpose: 
 * Continues a PCM stream
 *
 * Inputs:
 * 
 *		
 * Outputs:
 * 
 *
 * Side Effects:
 *
 *----------------------------------------------------------------------------
*/
/*lint -e{715} reserved for future use */
EAS_RESULT EAS_PEContinueStream (S_EAS_DATA *pEASData, EAS_PCM_HANDLE pState, EAS_I32 size)
{

	/* add new samples to count */
	pState->bytesLeft += size;
	if (pState->bytesLeft > 0)
		pState->flags &= ~PCM_FLAGS_EMPTY;
	return EAS_SUCCESS;
}

/*----------------------------------------------------------------------------
 * EAS_PEGetFileHandle()
 *----------------------------------------------------------------------------
 * Purpose: 
 * Returns the file handle of a stream
 *
 * Inputs:
 * 
 *		
 * Outputs:
 * 
 *
 * Side Effects:
 *
 *----------------------------------------------------------------------------
*/
/*lint -esym(715, pEASData) reserved for future use */
EAS_RESULT EAS_PEGetFileHandle (S_EAS_DATA *pEASData, EAS_PCM_HANDLE pState, EAS_FILE_HANDLE *pFileHandle)
{
	*pFileHandle = pState->fileHandle;
	return EAS_SUCCESS;
}

/*----------------------------------------------------------------------------
 * EAS_PEUpdateParams()
 *----------------------------------------------------------------------------
 * Purpose: 
 * Update the pitch and volume parameters for a PCM stream
 *
 * Inputs:
 * pEASData			- pointer to EAS library instance data
 * handle			- pointer to S_PCM_STATE for this stream
 * gainLeft			- linear gain multipler in 1.15 fraction format
 * gainRight		- linear gain multipler in 1.15 fraction format
 * pitch			- pitch shift in cents
 * initial			- initial settings, set current gain
 *
 * Outputs:
 * 
 *
 * Side Effects:
 *
 * Notes
 * In mono mode, leftGain controls the output gain and rightGain is ignored
 *----------------------------------------------------------------------------
*/
/*lint -esym(715, pEASData) reserved for future use */
/*lint -esym(715, gainRight) used only in 2-channel version */
EAS_RESULT EAS_PEUpdateParams (S_EAS_DATA* pEASData, EAS_PCM_HANDLE pState, EAS_I16 pitch, EAS_I16 gainLeft, EAS_I16 gainRight)
{

	pState->gainLeft = gainLeft;
	
#if (NUM_OUTPUT_CHANNELS == 2)
	pState->gainRight = gainRight;
#endif

	pState->pitch = pitch;
	return EAS_SUCCESS;
}

/*----------------------------------------------------------------------------
 * EAS_PELocate()
 *----------------------------------------------------------------------------
 * Purpose: 
 * This function seeks to the requested place in the file. Accuracy
 * is dependent on the sample rate and block size.
 *
 * Inputs:
 * pEASData			- pointer to overall EAS data structure
 * pState			- stream handle
 * time				- media time in milliseconds
 *----------------------------------------------------------------------------
*/
EAS_RESULT EAS_PELocate (S_EAS_DATA *pEASData, EAS_PCM_HANDLE pState, EAS_I32 time)
{
	if (pState->pDecoder->pfLocate == NULL)
		return EAS_ERROR_FEATURE_NOT_AVAILABLE;

	return pState->pDecoder->pfLocate(pEASData, pState, time);
}

/*----------------------------------------------------------------------------
 * EAS_PEUpdateVolume()
 *----------------------------------------------------------------------------
 * Purpose: 
 * Update the volume parameters for a PCM stream
 *
 * Inputs:
 * pEASData			- pointer to EAS library instance data
 * handle			- pointer to S_PCM_STATE for this stream
 * gainLeft			- linear gain multipler in 1.15 fraction format
 * gainRight		- linear gain multipler in 1.15 fraction format
 * initial			- initial settings, set current gain
 *
 * Outputs:
 * 
 *
 * Side Effects:
 *
 * Notes
 * In mono mode, leftGain controls the output gain and rightGain is ignored
 *----------------------------------------------------------------------------
*/
/*lint -esym(715, pEASData) reserved for future use */
EAS_RESULT EAS_PEUpdateVolume (S_EAS_DATA* pEASData, EAS_PCM_HANDLE pState, EAS_I16 volume)
{
	pState->volume = volume;
	return EAS_SUCCESS;
}

/*----------------------------------------------------------------------------
 * EAS_PEUpdatePitch()
 *----------------------------------------------------------------------------
 * Purpose: 
 * Update the pitch parameter for a PCM stream
 *
 * Inputs:
 * pEASData			- pointer to EAS library instance data
 * pState			- pointer to S_PCM_STATE for this stream
 * pitch			- new pitch value in pitch cents
 *----------------------------------------------------------------------------
*/
/*lint -esym(715, pEASData) reserved for future use */
EAS_RESULT EAS_PEUpdatePitch (S_EAS_DATA* pEASData, EAS_PCM_HANDLE pState, EAS_I16 pitch)
{
	pState->pitch = pitch;
	return EAS_SUCCESS;
}

/*----------------------------------------------------------------------------
 * EAS_PEPause()
 *----------------------------------------------------------------------------
 * Purpose: 
 * Mute and stop rendering a PCM stream. Sets the gain target to zero and stops the playback
 * at the end of the next audio frame.
 *
 * Inputs:
 * pEASData			- pointer to EAS library instance data
 * handle			- pointer to S_PCM_STATE for this stream
 *		
 * Outputs:
 * 
 *
 * Side Effects:
 *
 *----------------------------------------------------------------------------
*/
/*lint -esym(715, pEASData) reserved for future use */
EAS_RESULT EAS_PEPause (S_EAS_DATA *pEASData, EAS_PCM_HANDLE pState)
{
	/* set state to stopping */
	pState->state = EAS_STATE_PAUSING;
	return EAS_SUCCESS;
}

/*----------------------------------------------------------------------------
 * EAS_PEResume()
 *----------------------------------------------------------------------------
 * Purpose: 
 * Resume rendering a PCM stream. Sets the gain target back to its
 * previous setting and restarts playback at the end of the next audio
 * frame.
 *
 * Inputs:
 * pEASData			- pointer to EAS library instance data
 * handle			- pointer to S_PCM_STATE for this stream
 *		
 * Outputs:
 * 
 *
 * Side Effects:
 *
 *----------------------------------------------------------------------------
*/
/*lint -esym(715, pEASData) reserved for future use */
EAS_RESULT EAS_PEResume (S_EAS_DATA *pEASData, EAS_PCM_HANDLE pState)
{
	/* set state to stopping */
	pState->state = EAS_STATE_PLAY;
	return EAS_SUCCESS;
}

EAS_U32 getDecayScale(EAS_U32 index)
{
	EAS_U32 utemp;

	//envelope decay segment
	switch (index)
	{
	case 0:	//no decay
		utemp = 512;//32768;
		break;
	case 1: //.0156 dB per update
		utemp = 511;//32709;
		break;
	case 2: //.03125
		utemp = 510;//32649;
		break;
	case 3: //.0625
		utemp = 508;//32532;
		break;
	case 4: //.125
		utemp = 505;//32298;
		break;
	case 5: //.25
		utemp = 497;//31835;
		break;
	case 6: //.5
		utemp = 483;//30929;
		break;
	case 7: //1.0
		utemp = 456;//29193;
		break;
	case 8:	//2.0
		utemp = 406;//26008;
		break;
	case 9:	//4.0
		utemp = 323;//20642;
		break;
	case 10: //8.0
		utemp = 203;//13004;
		break;
	case 11: //16.0
		utemp = 81;//5160;
		break;
	case 12: //32.0
		utemp = 13;//813;
		break;
	case 13: //64.0
		utemp = 0;//20;
		break;
	case 14: //128.0
		utemp = 0;
		break;
	case 15: //256.0
	default:
		utemp = 0;
		break;
	}
	//printf("getdecayscale returned %d\n",utemp);
	return utemp;
}

EAS_U32 getAttackIncrement(EAS_U32 index)
{
	EAS_U32 utemp;

	//envelope decay segment
	switch (index)
	{
	case 0:	
		utemp = 32;
		break;
	case 1: 
		utemp = 64;
		break;
	case 2: 
		utemp = 128;
		break;
	case 3: 
		utemp = 256;
		break;
	case 4: 
		utemp = 512;
		break;
	case 5: 
		utemp = 1024;
		break;
	case 6: 
		utemp = 2048;
		break;
	case 7: 
		utemp = 4096;
		break;
	case 8:	
		utemp = 8192;
		break;
	case 9:	
		utemp = 16384;
		break;
	case 10: 
		utemp = 32768;
		break;
	case 11: 
		utemp = 65536;
		break;
	case 12: 
		utemp = 65536;
		break;
	case 13: 
		utemp = 65536;
		break;
	case 14: 
		utemp = 65535;
		break;
	case 15: 
	default:
		utemp = 0;
		break;
	}
	//printf("getattackincrement returned %d\n",utemp);
	return utemp;
}

/*----------------------------------------------------------------------------
 * EAS_PERelease()
 *----------------------------------------------------------------------------
 * Purpose: 
 * Put the PCM stream envelope into release. 
 *
 * Inputs:
 * pEASData			- pointer to EAS library instance data
 * handle			- pointer to S_PCM_STATE for this stream
 *		
 * Outputs:
 * 
 *
 * Side Effects:
 *
 *----------------------------------------------------------------------------
*/
/*lint -esym(715, pEASData) reserved for future use */
EAS_RESULT EAS_PERelease (S_EAS_DATA *pEASData, EAS_PCM_HANDLE pState)
{
	EAS_U32 utemp;

	//printf("handling note-off part of envelope\n");
	/*if the note is not ignore release or sustained*/
	if (((pState->envData >> 24) & 0x0F)==0)
	{
		/* set envelope state to release */
		pState->envState = PCM_ENV_RELEASE;
		utemp = ((pState->envData >> 20) & 0x0F);
		pState->envScale = getDecayScale(utemp); //getReleaseScale(utemp);
	}
	else
	{
		/*else change envelope state to sustain */
		pState->envState = PCM_ENV_SUSTAIN;
		utemp = ((pState->envData >> 28) & 0x0F);
		pState->envScale = getDecayScale(utemp); //getSustainScale(utemp);
	}
	//since we are in release, don't let anything hang around too long
	//printf("checking env scale, val = %d\n",((S_PCM_STATE*) handle)->envScale);
	if (pState->envScale > 505)
		pState->envScale = 505;
	return EAS_SUCCESS;
}

/*----------------------------------------------------------------------------
 * FindSlot()
 *----------------------------------------------------------------------------
 * Purpose: 
 * Locates an empty stream slot and assigns the file handle
 *
 * Inputs:
 * pEASData			- pointer to EAS library instance data
 * fileHandle		- file handle
 * pCallbackFunc	- function to be called back upon EAS_STATE_STOPPED
 *		
 * Outputs:
 * returns handle to slot or NULL if all slots are used
 *
 * Side Effects:
 *
 *----------------------------------------------------------------------------
*/
static S_PCM_STATE *FindSlot (S_EAS_DATA *pEASData, EAS_FILE_HANDLE fileHandle, EAS_PCM_CALLBACK pCallbackFunc, EAS_VOID_PTR cbInstData)
{
	EAS_INT i;
	S_PCM_STATE *pState;

#ifndef NO_PCM_STEAL	
	S_PCM_STATE *foundState = NULL;
	EAS_INT count = 0;
	EAS_U32 startOrder = 0xFFFFFFFF;
	S_PCM_STATE *stealState = NULL;
	EAS_U32 youngest = 0;

	/* find an empty slot, count total in use, and find oldest in use (lowest start order) */
	for (i = 0, pState = pEASData->pPCMStreams; i < MAX_PCM_STREAMS; i++, pState++)
	{
		/* if this one is available */
		if (pState->fileHandle == NULL)
		{
			foundState = pState;
		}
		/* else this one is in use, so see if it is the oldest, and count total in use */
		/* also find youngest */
		else
		{
			/*one more voice in use*/
			count++;
			/* is this the oldest? (lowest start order) */
			if ((pState->state != EAS_STATE_STOPPING) && (pState->startOrder < startOrder))
			{
				/* remember this one */
				stealState = pState;
				/* remember the oldest so far */
				startOrder = pState->startOrder;
			}
			/* is this the youngest? (highest start order) */
			if (pState->startOrder >= youngest)
			{
				youngest = pState->startOrder;
			}
		}
	}

	/* if there are too many voices active, stop the oldest one */
	if (count > PCM_STREAM_THRESHOLD)
	{
		//printf("stealing!!!\n");
		/* make sure we got one, although we should always have one at this point */
		if (stealState != NULL)
		{
			//flag this as stopping, so it will get shut off
			stealState->state = EAS_STATE_STOPPING;
		}
	}

	/* if there are no available open streams (we won't likely see this, due to stealing) */
	if (foundState == NULL)
		return NULL;

	/* save info */
	foundState->startOrder = youngest + 1;
	foundState->fileHandle = fileHandle;
	foundState->pCallback = pCallbackFunc;
	foundState->cbInstData = cbInstData;
	return foundState;
#else
	/* find an empty slot*/
	for (i = 0; i < MAX_PCM_STREAMS; i++)
	{
		pState = &pEASData->pPCMStreams[i];
		if (pState->fileHandle != NULL)
			continue;
		
		pState->fileHandle = fileHandle;
		pState->pCallback = pCallbackFunc;
		pState->cbInstData = cbInstData;
		return pState;
	}
	return NULL;
#endif
}

#ifdef _LOOKUP_SAMPLE_RATE	
/*----------------------------------------------------------------------------
 * CalcBaseFreq()
 *----------------------------------------------------------------------------
 * Purpose: 
 * Calculates the fractional phase increment for the sample rate converter
 *
 * Inputs:
 * sampleRate		- sample rate in samples/sec
 *		
 * Outputs:
 * Returns fractional sample rate with a 15-bit fraction
 *
 * Side Effects:
 *
 *----------------------------------------------------------------------------
*/
static EAS_U32 CalcBaseFreq (EAS_U32 sampleRate)
{
	EAS_INT i;

	/* look up the conversion rate */
	for (i = 0; i < (EAS_INT)(SRC_CONV_RATE_ENTRIES); i ++)
	{
		if (srcConvRate[i][0] == sampleRate)
			return srcConvRate[i][1];
	}

	/* if not found in table, do it the long way */
	{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_WARNING, "Sample rate %u not in table, calculating by division\n", sampleRate); */ }

	return (SRC_RATE_MULTIPLER * (EAS_U32) sampleRate) >> 15;
}
#endif

/*----------------------------------------------------------------------------
 * InitPCMStream()
 *----------------------------------------------------------------------------
 * Purpose: 
 * Start an ADPCM stream playback. Decodes the header, preps the engine.
 *
 * Inputs:
 * 
 *		
 * Outputs:
 * 
 *
 * Side Effects:
 *
 *----------------------------------------------------------------------------
*/
static EAS_RESULT InitPCMStream (S_EAS_DATA *pEASData, S_PCM_STATE *pState)
{

	/* initialize the data structure */
	pState->bytesLeft = pState->byteCount;
	pState->phase = 0;
	pState->srcByte = 0;
	pState->decoderL.acc = 0;
	pState->decoderL.output = 0;
	pState->decoderL.x0 = pState->decoderL.x1 = 0;
	pState->decoderL.step = 0;
	pState->decoderR.acc = 0;
	pState->decoderR.output = 0;
	pState->decoderR.x0 = pState->decoderR.x1 = 0;
	pState->decoderR.step = 0;
	pState->hiNibble = EAS_FALSE;
	pState->pitch = 0;
	pState->blockCount = 0;
	pState->gainLeft = PCM_DEFAULT_GAIN_SETTING;
//	pState->currentGainLeft = PCM_DEFAULT_GAIN_SETTING;
	pState->envValue = 0;
	pState->envState = PCM_ENV_START;
	
#if (NUM_OUTPUT_CHANNELS == 2)
	pState->gainRight = PCM_DEFAULT_GAIN_SETTING;
//	pState->currentGainRight = PCM_DEFAULT_GAIN_SETTING;
#endif
	pState->state = EAS_STATE_READY;

	/* initialize the decoder */
	if (pState->pDecoder->pfInit)
		return (*pState->pDecoder->pfInit)(pEASData, pState);
	return EAS_SUCCESS;
}

/*----------------------------------------------------------------------------
 * RenderPCMStream()
 *----------------------------------------------------------------------------
 * Purpose: 
 * Decodes a buffer of ADPCM data.
 *
 * Inputs:
 * 
 *		
 * Outputs:
 * 
 *
 * Side Effects:
 *
 *----------------------------------------------------------------------------
*/
static EAS_RESULT RenderPCMStream (S_EAS_DATA *pEASData, S_PCM_STATE *pState, EAS_I32 numSamples)
{
	EAS_RESULT result;
	EAS_U32 phaseInc;
	EAS_I32 gainLeft, gainIncLeft;
	EAS_I32 *pOut;
	EAS_I32 temp;
	EAS_U32 utemp;
	
#if (NUM_OUTPUT_CHANNELS == 2)
	EAS_I32 gainRight, gainIncRight;
#endif

#if 0
	printf("env data: AR = %d, DR = %d, SL = %d, SR = %d, RR = %d\n",
		((pState->envData >> 12) & 0x0F),
		((pState->envData >> 16) & 0x0F),
		((pState->envData >> 8) & 0x0F),
		((pState->envData >> 28) & 0x0F),
		((pState->envData >> 20) & 0x0F));
#endif

	if (pState->envState == PCM_ENV_START)
	{
		//printf("env start\n");
		utemp = ((pState->envData >> 12) & 0x0F);
		//if fastest rate, attack is already completed
		//do the same for slowest rate, since that allows zero to be passed for default envelope
		if (utemp == 0x0F || utemp == 0x00)
		{
			//start envelope at full
			pState->envValue = (32768<<7);
			//jump right into decay
			utemp = ((pState->envData >> 16) & 0x0F);
			pState->envScale = getDecayScale(utemp);
			pState->envState = PCM_ENV_DECAY;
			pState->currentGainLeft = (EAS_I16) FMUL_15x15(pState->gainLeft, pState->volume);
			pState->currentGainRight = (EAS_I16) FMUL_15x15(pState->gainRight, pState->volume);
		}
		//else attack has a ramp
		else
		{
			//start the envelope very low
			pState->envValue = (2<<7);
			pState->currentGainLeft = 0;
			pState->currentGainRight = 0;
			//get envelope attack scaling value
			pState->envScale = getAttackIncrement(utemp);
			//go to attack state
			pState->envState = PCM_ENV_ATTACK;
		}
	}
	if (pState->envState == PCM_ENV_ATTACK)
	{
		//printf("env attack, env value = %d, env scale = %d\n",pState->envValue>>7,pState->envScale);
		//update envelope value
		pState->envValue = pState->envValue + (pState->envScale << 7);
		//check envelope level and update state if needed
		if (pState->envValue >= (32768<<7))
		{
			pState->envValue = (32768<<7);
			utemp = ((pState->envData >> 16) & 0x0F);
			pState->envScale = getDecayScale(utemp);
			pState->envState = PCM_ENV_DECAY;
		}
	}
	else if (pState->envState == PCM_ENV_DECAY)
	{
		//printf("env decay, env value = %d, env scale = %d\n",pState->envValue>>7,pState->envScale);
		//update envelope value
		pState->envValue = (pState->envValue * pState->envScale)>>9;
		//check envelope level against sustain level and update state if needed
		utemp = ((pState->envData >> 8) & 0x0F);
		if (utemp == (EAS_U32)0x0F)
			utemp = (2<<7);
		else
		{
			utemp = ((32769<<7) >> (utemp>>1));
		}
		if (pState->envValue <= utemp)
		{
			utemp = ((pState->envData >> 28) & 0x0F);
			pState->envScale = getDecayScale(utemp); //getSustainScale(utemp);
			pState->envState = PCM_ENV_SUSTAIN;
		}
	}
	else if (pState->envState == PCM_ENV_SUSTAIN)
	{
		//printf("env sustain, env value = %d, env scale = %d\n",pState->envValue>>7,pState->envScale);
		//update envelope value
		pState->envValue = (pState->envValue * pState->envScale)>>9;
		//check envelope level against bottom level and update state if needed
		if (pState->envValue <= (2<<7))
		{
			//no more decay
			pState->envScale = 512;
			pState->envState = PCM_ENV_END;
		}
	}
	else if (pState->envState == PCM_ENV_RELEASE)
	{
		//printf("env release, env value = %d, env scale = %d\n",pState->envValue>>7,pState->envScale);
		//update envelope value
		pState->envValue = (pState->envValue * pState->envScale)>>9;
		//check envelope level against bottom level and update state if needed
		if (pState->envValue <= (2<<7))
		{
			//no more decay
			pState->envScale = 512;
			pState->envState = PCM_ENV_END;
		}
	}
	else if (pState->envState == PCM_ENV_END)
	{
		//printf("env end\n");
		/* set state to stopping, already ramped down */
		pState->state = EAS_STATE_STOPPING;
	}

	//pState->gainLeft = (EAS_U16)((pState->gainLeft * (pState->envValue>>7))>>15);
	//pState->gainRight = (EAS_U16)((pState->gainRight * (pState->envValue>>7))>>15);

	/* gain to 32-bits to increase resolution on anti-zipper filter */
	/*lint -e{703} use shift for performance */
	gainLeft = (EAS_I32) pState->currentGainLeft << SYNTH_UPDATE_PERIOD_IN_BITS;
#if (NUM_OUTPUT_CHANNELS == 2)
	/*lint -e{703} use shift for performance */
	gainRight = (EAS_I32) pState->currentGainRight << SYNTH_UPDATE_PERIOD_IN_BITS;
#endif

	/* calculate a new gain increment, gain target is zero if pausing */
	if ((pState->state == EAS_STATE_PAUSING) || (pState->state == EAS_STATE_PAUSED))
	{
		gainIncLeft = -pState->currentGainLeft;
#if (NUM_OUTPUT_CHANNELS == 2)
		gainIncRight= -pState->currentGainRight;
#endif
	}
	else
	{
		EAS_I32 gain = FMUL_15x15(pState->envValue >> 7, pState->volume);
		gainIncLeft = FMUL_15x15(pState->gainLeft, gain) - pState->currentGainLeft;
#if (NUM_OUTPUT_CHANNELS == 2)
		gainIncRight = FMUL_15x15(pState->gainRight, gain) - pState->currentGainRight;
#endif
	}

	/* calculate phase increment */
	phaseInc = pState->basefreq;

	/* convert pitch cents to linear multiplier */
	if (pState->pitch)
	{
		temp = EAS_Calculate2toX(pState->pitch);
		phaseInc = FMUL_15x15(phaseInc, temp);
	}
	phaseInc = phaseInc << pState->rateShift;

	/* pointer to mix buffer */
	pOut = pEASData->pMixBuffer;
	
	/* render a buffer of samples */
	while (numSamples--)
	{

		/* interpolate an output sample */
		pState->decoderL.output = pState->decoderL.x0 + FMUL_15x15((pState->decoderL.x1 - pState->decoderL.x0), pState->phase & PHASE_FRAC_MASK);

		/* stereo output */
#if (NUM_OUTPUT_CHANNELS == 2)

		/* stereo stream? */
		if (pState->flags & PCM_FLAGS_STEREO)
			pState->decoderR.output = pState->decoderR.x0 + FMUL_15x15((pState->decoderR.x1 - pState->decoderR.x0), pState->phase & PHASE_FRAC_MASK);

		/* gain scale and mix */
		/*lint -e{704} use shift instead of division */
		*pOut++ += (pState->decoderL.output * (gainLeft >> SYNTH_UPDATE_PERIOD_IN_BITS)) >> PCM_MIXER_GUARD_BITS;
		gainLeft += gainIncLeft;
		
		/*lint -e{704} use shift instead of division */
		if (pState->flags & PCM_FLAGS_STEREO)
			*pOut++ += (pState->decoderR.output * (gainRight >> SYNTH_UPDATE_PERIOD_IN_BITS)) >> PCM_MIXER_GUARD_BITS;
		else
			*pOut++ += (pState->decoderL.output * (gainRight >> SYNTH_UPDATE_PERIOD_IN_BITS)) >> PCM_MIXER_GUARD_BITS;
		
		gainRight += gainIncRight;

		/* mono output */
#else
		/* if stereo stream, decode right channel and mix to mono */
		if (pState->flags & PCM_FLAGS_STEREO)
		{
			pState->decoderR.output= pState->decoderR.x0 + FMUL_15x15((pState->decoderR.x1 - pState->decoderR.x0), pState->phase & PHASE_FRAC_MASK);

			/* for mono, sum stereo ADPCM to mono */
			/*lint -e{704} use shift instead of division */
			*pOut++ += ((pState->decoderL.output + pState->decoderR.output) * (gainLeft >> SYNTH_UPDATE_PERIOD_IN_BITS)) >> PCM_MIXER_GUARD_BITS;
		}
		else
			/*lint -e{704} use shift instead of division */
			*pOut++ += (pState->decoderL.output * (gainLeft >> SYNTH_UPDATE_PERIOD_IN_BITS)) >> PCM_MIXER_GUARD_BITS;
		
		gainLeft += gainIncLeft;
#endif		

		/* advance phase accumulator */
		pState->phase += phaseInc;

		/* if integer part of phase accumulator is non-zero, advance to next sample */
		while (pState->phase & ~PHASE_FRAC_MASK)
		{
			pState->decoderL.x0 = pState->decoderL.x1;
			pState->decoderR.x0 = pState->decoderR.x1;

			/* give the source a chance to continue the stream */
			if (!pState->bytesLeft && pState->pCallback && ((pState->flags & PCM_FLAGS_EMPTY) == 0))
			{
				pState->flags |= PCM_FLAGS_EMPTY;
				(*pState->pCallback)(pEASData, pState->cbInstData, pState, EAS_STATE_EMPTY);
				{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_DETAIL, "RenderPCMStream: After empty callback, bytesLeft = %d\n", pState->bytesLeft); */ }
			}
			
			/* decode the next sample */
			if ((result = (*pState->pDecoder->pfDecodeSample)(pEASData, pState)) != EAS_SUCCESS)
				return result;

			/* adjust phase by one sample */
			pState->phase -= (1L << NUM_PHASE_FRAC_BITS);
		}
			
	}

	/* save new gain */
	/*lint -e{704} use shift instead of division */
	pState->currentGainLeft = (EAS_I16) (gainLeft >> SYNTH_UPDATE_PERIOD_IN_BITS);
	
#if (NUM_OUTPUT_CHANNELS == 2)
	/*lint -e{704} use shift instead of division */
	pState->currentGainRight = (EAS_I16) (gainRight >> SYNTH_UPDATE_PERIOD_IN_BITS);
#endif

	/* if pausing, set new state and notify */
	if (pState->state == EAS_STATE_PAUSING)
	{
		pState->state = EAS_STATE_PAUSED;
		if (pState->pCallback)
			(*pState->pCallback)(pEASData, pState->cbInstData, pState, pState->state);
	}

	/* if out of data, set stopped state and notify */
	if (pState->bytesLeft == 0 || pState->state == EAS_STATE_STOPPING)
	{
		pState->state = EAS_STATE_STOPPED;

		/* do callback unless the file has already been closed */
		if (pState->pCallback && pState->fileHandle)
			(*pState->pCallback)(pEASData, pState->cbInstData, pState, pState->state);
	}

	if (pState->state == EAS_STATE_READY)
		pState->state = EAS_STATE_PLAY;

	return EAS_SUCCESS;
}

/*----------------------------------------------------------------------------
 * LinearPCMDecode()
 *----------------------------------------------------------------------------
 * Purpose: 
 * Decodes a PCM sample
 *
 * Inputs:
 * 
 *		
 * Outputs:
 * 
 *
 * Side Effects:
 *
 *----------------------------------------------------------------------------
*/
static EAS_RESULT LinearPCMDecode (EAS_DATA_HANDLE pEASData, S_PCM_STATE *pState)
{
	EAS_RESULT result;
	EAS_HW_DATA_HANDLE hwInstData;

	hwInstData = ((S_EAS_DATA*) pEASData)->hwInstData;

	/* if out of data, check for loop */
	if ((pState->bytesLeft == 0) && (pState->loopSamples != 0))
	{
		if ((result = EAS_HWFileSeek(pEASData->hwInstData, pState->fileHandle, (EAS_I32) (pState->startPos + pState->loopLocation))) != EAS_SUCCESS)
			return result;
		pState->bytesLeft = pState->byteCount = (EAS_I32) pState->bytesLeftLoop;
		pState->flags &= ~PCM_FLAGS_EMPTY;
		{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_DETAIL, "LinearPCMDecode: Rewind file to %d, bytesLeft = %d\n", pState->startPos, pState->bytesLeft); */ }
	}

	if (pState->bytesLeft)
	{

		/* check format byte for 8-bit samples */
		if (pState->flags & PCM_FLAGS_8_BIT)
		{
			/* fetch left or mono sample */
			if ((result = EAS_HWGetByte(hwInstData, pState->fileHandle, &pState->srcByte)) != EAS_SUCCESS)
				return result;

			/* if unsigned */
			if (pState->flags & PCM_FLAGS_UNSIGNED)
			{
				/*lint -e{734} converting unsigned 8-bit to signed 16-bit */
				pState->decoderL.x1 = (EAS_PCM)(((EAS_PCM) pState->srcByte << 8) ^ 0x8000);
			}
			else
			{
				/*lint -e{734} converting signed 8-bit to signed 16-bit */
				pState->decoderL.x1 = (EAS_PCM)((EAS_PCM) pState->srcByte << 8);
			}
			pState->bytesLeft--;
			
			/* fetch right sample */
			if(pState->flags & PCM_FLAGS_STEREO)
			{
				if ((result = EAS_HWGetByte(hwInstData, pState->fileHandle, &pState->srcByte)) != EAS_SUCCESS)
					return result;

				/* if unsigned */
				if (pState->flags & PCM_FLAGS_UNSIGNED)
				{
					/*lint -e{734} converting unsigned 8-bit to signed 16-bit */
					pState->decoderR.x1 = (EAS_PCM)(((EAS_PCM) pState->srcByte << 8) ^ 0x8000);
				}
				else
				{
					/*lint -e{734} converting signed 8-bit to signed 16-bit */
					pState->decoderR.x1 = (EAS_PCM)((EAS_PCM) pState->srcByte << 8);
				}
				pState->bytesLeft--;
			}
		}

		/* must be 16-bit samples */
		else
		{
			//unsigned 16 bit currently not supported
			if (pState->flags & PCM_FLAGS_UNSIGNED)
			{
				return EAS_ERROR_INVALID_PCM_TYPE;
			}

			/* fetch left or mono sample */
			if ((result = EAS_HWGetWord(hwInstData, pState->fileHandle, &pState->decoderL.x1, EAS_FALSE)) != EAS_SUCCESS)
				return result;
			pState->bytesLeft -= 2;
			
			/* fetch right sample */
			if(pState->flags & PCM_FLAGS_STEREO)
			{
				if ((result = EAS_HWGetWord(hwInstData, pState->fileHandle, &pState->decoderR.x1, EAS_FALSE)) != EAS_SUCCESS)
					return result;
				pState->bytesLeft -= 2;
			}
		}
	}

	/* no more data, force zero samples */
	else
		pState->decoderL.x1 = pState->decoderR.x1 = 0;

	return EAS_SUCCESS;
}

/*----------------------------------------------------------------------------
 * LinearPCMLocate()
 *----------------------------------------------------------------------------
 * Purpose: 
 * Locate in a linear PCM stream
 *----------------------------------------------------------------------------
*/
static EAS_RESULT LinearPCMLocate (EAS_DATA_HANDLE pEASData, S_PCM_STATE *pState, EAS_I32 time)
{
	EAS_RESULT result;
	EAS_I32 temp;
	EAS_I32 secs, msecs;
	EAS_INT shift;

	/* calculate size of sample frame */
	if (pState->flags & PCM_FLAGS_8_BIT)
		shift = 0;
	else
		shift = 1;
	if (pState->flags & PCM_FLAGS_STEREO)
		shift++;

	/* break down into secs and msecs */
	secs = time / 1000;
	msecs = time - (secs * 1000);

	/* calculate sample number fraction from msecs */
	temp = (msecs * pState->sampleRate);
	temp = (temp >> 10) + ((temp * 49) >> 21);

	/* add integer sample count */
	temp += secs * pState->sampleRate;

	/* calculate the position based on sample frame size */
	/*lint -e{703} use shift for performance */
	temp <<= shift;

	/* past end of sample? */
	if (temp > (EAS_I32) pState->loopStart)
	{
		/* if not looped, flag error */
		if (pState->loopSamples == 0)
		{
			pState->bytesLeft = 0;
			pState->flags |= PCM_FLAGS_EMPTY;
			return EAS_ERROR_LOCATE_BEYOND_END;
		}

		/* looped sample - calculate position in loop */
		while (temp > (EAS_I32) pState->loopStart)
			temp -= (EAS_I32) pState->loopStart;
	}

	/* seek to new position */
	if ((result = EAS_PESeek(pEASData, pState, &temp)) != EAS_SUCCESS)
		return result;

	/* reset state */
	if ((pState->state != EAS_STATE_PAUSING) && (pState->state != EAS_STATE_PAUSED))
		pState->state = EAS_STATE_READY;

	return EAS_SUCCESS;	
}

/*----------------------------------------------------------------------------
 * EAS_PESeek
 *----------------------------------------------------------------------------
 * Purpose: 
 * Locate to a particular byte in a PCM stream
 *----------------------------------------------------------------------------
 * This bit is tricky because the chunks may not be contiguous,
 * so we have to rely on the parser to position in the file. We
 * do this by seeking to the end of each chunk and simulating an
 * empty buffer condition until we get to where we want to go.
 *
 * A better solution would be a parser API for re-positioning,
 * but there isn't time at the moment to re-factor all the
 * parsers to support a new API.
 *----------------------------------------------------------------------------
*/
EAS_RESULT EAS_PESeek (S_EAS_DATA *pEASData, S_PCM_STATE *pState, EAS_I32 *pLocation)
{
	EAS_RESULT result;

	/* seek to start of audio */
	if ((result = EAS_HWFileSeek(pEASData->hwInstData, pState->fileHandle, pState->startPos)) != EAS_SUCCESS)
	{
		pState->state = EAS_STATE_ERROR;
		return result;
	}
	pState->bytesLeft = pState->bytesLeftLoop;

	/* skip through chunks until we find the right chunk */	
	while (*pLocation > (EAS_I32) pState->bytesLeft)
	{
		/* seek to end of audio chunk */
		{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_DETAIL, "EAS_PESeek: Seek to offset = %d\n", pState->bytesLeft); */ }
		if ((result = EAS_HWFileSeekOfs(pEASData->hwInstData, pState->fileHandle, pState->bytesLeft)) != EAS_SUCCESS)
		{
			pState->state = EAS_STATE_ERROR;
			return result;
		}
		*pLocation -= pState->bytesLeft;
		pState->bytesLeft = 0;
		pState->flags |= PCM_FLAGS_EMPTY;
		
		/* retrieve more data */
		if (pState->pCallback)
			(*pState->pCallback)(pEASData, pState->cbInstData, pState, EAS_STATE_EMPTY);

		{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_DETAIL, "EAS_PESeek: bytesLeft=%d, byte location = %d\n", pState->bytesLeft, *pLocation); */ }

		/* no more samples */
		if (pState->bytesLeft == 0)
			return EAS_ERROR_LOCATE_BEYOND_END;
	}

	/* seek to new offset in current chunk */
	if (*pLocation > 0)
	{
		{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_DETAIL, "EAS_PESeek: Seek to offset = %d\n", *pLocation); */ }
		if ((result = EAS_HWFileSeekOfs(pEASData->hwInstData, pState->fileHandle, *pLocation)) != EAS_SUCCESS)
		{
			pState->state = EAS_STATE_ERROR;
			return result;
		}
		
		/* if not streamed, calculate number of bytes left */
		if (pState->flags & PCM_FLAGS_STREAMING)
			pState->bytesLeft = 0x7fffffff;
		else
			pState->bytesLeft -= *pLocation;
	}
	return EAS_SUCCESS;
}