path: root/arm-hybrid-22k/lib_src/eas_wavefile.c

/*----------------------------------------------------------------------------
 *
 * File: 
 * eas_wavefile.c
 *
 * Contents and purpose:
 * This file implements the wave file parser.
 *
 * Copyright Sonic Network Inc. 2005

 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 *----------------------------------------------------------------------------
 * Revision Control:
 *   $Revision: 852 $
 *   $Date: 2007-09-04 11:43:49 -0700 (Tue, 04 Sep 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_wavefile.h"

/* lint is choking on the ARM math.h file, so we declare the log10 function here */
extern double log10(double x);

/* increase gain to compensate for loss in mixer */
#define WAVE_GAIN_OFFSET			6

/* constant for 1200 / log10(2.0) */
#define PITCH_CENTS_CONVERSION		3986.313714

/*----------------------------------------------------------------------------
 * WAVE file defines
 *----------------------------------------------------------------------------
*/
/* RIFF chunks */
#define	CHUNK_TYPE(a,b,c,d)	(	\
		( ((EAS_U32)(a) & 0xFF) << 24 ) \
	+	( ((EAS_U32)(b) & 0xFF) << 16 ) \
	+	( ((EAS_U32)(c) & 0xFF) <<  8 ) \
	+	( ((EAS_U32)(d) & 0xFF)       ) )

#define CHUNK_RIFF					CHUNK_TYPE('R','I','F','F')
#define CHUNK_WAVE					CHUNK_TYPE('W','A','V','E')
#define CHUNK_FMT 					CHUNK_TYPE('f','m','t',' ')
#define CHUNK_DATA					CHUNK_TYPE('d','a','t','a')
#define CHUNK_LIST					CHUNK_TYPE('L','I','S','T')
#define CHUNK_INFO					CHUNK_TYPE('I','N','F','O')
#define CHUNK_INAM					CHUNK_TYPE('I','N','A','M')
#define CHUNK_ICOP					CHUNK_TYPE('I','C','O','P')
#define CHUNK_IART					CHUNK_TYPE('I','A','R','T')

/* wave file format identifiers */
#define WAVE_FORMAT_PCM				0x0001
#define WAVE_FORMAT_IMA_ADPCM		0x0011

/* file size for streamed file */
#define FILE_SIZE_STREAMING			0x80000000

/*----------------------------------------------------------------------------
 * prototypes
 *----------------------------------------------------------------------------
*/
static EAS_RESULT WaveCheckFileType (S_EAS_DATA *pEASData, EAS_FILE_HANDLE fileHandle, EAS_VOID_PTR *pHandle, EAS_I32 offset);
static EAS_RESULT WavePrepare (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData);
static EAS_RESULT WaveState (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData, EAS_STATE *pState);
static EAS_RESULT WaveClose (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData);
static EAS_RESULT WaveReset (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData);
static EAS_RESULT WaveLocate (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData, EAS_I32 time, EAS_BOOL *pParserLocate);
static EAS_RESULT WavePause (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData);
static EAS_RESULT WaveResume (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData);
static EAS_RESULT WaveSetData (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData, EAS_I32 param, EAS_I32 value);
static EAS_RESULT WaveGetData (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData, EAS_I32 param, EAS_I32 *pValue);
static EAS_RESULT WaveParseHeader (S_EAS_DATA *pEASData, EAS_FILE_HANDLE fileHandle, S_WAVE_STATE *pWaveData);
static EAS_RESULT WaveGetMetaData (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData, EAS_I32 *pMediaLength);

#ifdef MMAPI_SUPPORT
static EAS_RESULT SaveFmtChunk (S_EAS_DATA *pEASData, EAS_FILE_HANDLE fileHandle, S_WAVE_STATE *pWaveData, EAS_I32 size);
#endif

/*----------------------------------------------------------------------------
 *
 * EAS_Wave_Parser
 *
 * This structure contains the functional interface for the Wave file parser 
 *----------------------------------------------------------------------------
*/
const S_FILE_PARSER_INTERFACE EAS_Wave_Parser =
{
	WaveCheckFileType,
	WavePrepare,
	NULL,
	NULL,
	WaveState,
	WaveClose,
	WaveReset,
	WavePause,
	WaveResume,
	WaveLocate,
	WaveSetData,
	WaveGetData,
	WaveGetMetaData
};

/*----------------------------------------------------------------------------
 * WaveCheckFileType()
 *----------------------------------------------------------------------------
 * Purpose: 
 * Check the file type to see if we can parse it
 *
 * Inputs:
 * pEASData			- pointer to overall EAS data structure
 * handle			- pointer to file handle
 *		
 * Outputs:
 * 
 *
 * Side Effects:
 *
 *----------------------------------------------------------------------------
*/
static EAS_RESULT WaveCheckFileType (S_EAS_DATA *pEASData, EAS_FILE_HANDLE fileHandle, EAS_VOID_PTR *pHandle, EAS_I32 offset)
{
	S_WAVE_STATE *pWaveData;

	/* zero the memory to insure complete initialization */
	*pHandle = NULL;

	/* read the file header */
	if (WaveParseHeader(pEASData, fileHandle, NULL) == EAS_SUCCESS)
	{
	
		/* check for static memory allocation */
		if (pEASData->staticMemoryModel)
			pWaveData = EAS_CMEnumData(EAS_CM_WAVE_DATA);
		else
			pWaveData = EAS_HWMalloc(pEASData->hwInstData, sizeof(S_WAVE_STATE));
		if (!pWaveData)
			return EAS_ERROR_MALLOC_FAILED;
		EAS_HWMemSet(pWaveData, 0, sizeof(S_WAVE_STATE));
		
		/* return a pointer to the instance data */
		pWaveData->fileHandle = fileHandle;
		pWaveData->fileOffset = offset;
		*pHandle = pWaveData;
	}

	return EAS_SUCCESS;
}

/*----------------------------------------------------------------------------
 * WavePrepare()
 *----------------------------------------------------------------------------
 * Purpose: 
 * Prepare to parse the file. 
 *
 * Inputs:
 * pEASData			- pointer to overall EAS data structure
 * handle			- pointer to file handle
 *		
 * Outputs:
 * 
 *
 * Side Effects:
 *
 *----------------------------------------------------------------------------
*/
static EAS_RESULT WavePrepare (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData)
{
	S_WAVE_STATE *pWaveData;
	EAS_RESULT result;

	/* validate parser state */
	pWaveData = (S_WAVE_STATE*) pInstData;
	if (pWaveData->streamHandle != NULL)
		return EAS_ERROR_NOT_VALID_IN_THIS_STATE;
	
	/* back to start of file */
	pWaveData->time = 0;
	if ((result = EAS_HWFileSeek(pEASData->hwInstData, pWaveData->fileHandle, pWaveData->fileOffset)) != EAS_SUCCESS)
		return result;

	/* parse the file header */
	if ((result = WaveParseHeader(pEASData, pWaveData->fileHandle, pWaveData)) != EAS_SUCCESS)
		return result;

	return EAS_SUCCESS;
}

/*----------------------------------------------------------------------------
 * WaveState()
 *----------------------------------------------------------------------------
 * 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.
 *----------------------------------------------------------------------------
*/
static EAS_RESULT WaveState (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData, EAS_STATE *pState)
{
	S_WAVE_STATE *pWaveData;
	
	/* return current state */
	pWaveData = (S_WAVE_STATE*) pInstData;
	if (pWaveData->streamHandle)
		return EAS_PEState(pEASData, pWaveData->streamHandle, pState);

	/* if no stream handle, and time is not zero, we are done */
	if (pWaveData->time > 0)
		*pState = EAS_STATE_STOPPED;
	else
		*pState = EAS_STATE_OPEN;
	return EAS_SUCCESS;
}

/*----------------------------------------------------------------------------
 * WaveClose()
 *----------------------------------------------------------------------------
 * Purpose: 
 * Close the file and clean up
 *
 * Inputs:
 * pEASData			- pointer to overall EAS data structure
 * handle			- pointer to file handle
 *		
 * Outputs:
 * 
 *
 * Side Effects:
 *
 *----------------------------------------------------------------------------
*/
static EAS_RESULT WaveClose (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData)
{
	S_WAVE_STATE *pWaveData;
	EAS_RESULT result;

	pWaveData = (S_WAVE_STATE*) pInstData;

	/* close the stream */
	if (pWaveData->streamHandle)
	{
		if ((result = EAS_PEClose(pEASData, pWaveData->streamHandle)) != EAS_SUCCESS)
			return result;
		pWaveData->streamHandle = NULL;
	}
	
	/* if using dynamic memory, free it */
	if (!pEASData->staticMemoryModel)
	{

#ifdef MMAPI_SUPPORT
		/* need to free the fmt chunk */
		if (pWaveData->fmtChunk != NULL)
			EAS_HWFree(pEASData->hwInstData, pWaveData->fmtChunk);
#endif

		/* free the instance data */			
		EAS_HWFree(pEASData->hwInstData, pWaveData);

	}
	return EAS_SUCCESS;
}

/*----------------------------------------------------------------------------
 * WaveReset()
 *----------------------------------------------------------------------------
 * Purpose: 
 * Reset the sequencer. Used for locating backwards in the file.
 *
 * Inputs:
 * pEASData			- pointer to overall EAS data structure
 * handle			- pointer to file handle
 *		
 * Outputs:
 * 
 *
 * Side Effects:
 *
 *----------------------------------------------------------------------------
*/
static EAS_RESULT WaveReset (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData)
{
	EAS_PCM_HANDLE streamHandle;

	/* reset to first byte of data in the stream */
	streamHandle = ((S_WAVE_STATE*)pInstData)->streamHandle;
	if (streamHandle)
		return EAS_PEReset(pEASData, streamHandle);
	return EAS_ERROR_NOT_VALID_IN_THIS_STATE;
}

/*----------------------------------------------------------------------------
 * WaveLocate()
 *----------------------------------------------------------------------------
 * Purpose: 
 * Rewind/fast-forward in file.
 *
 * Inputs:
 * pEASData			- pointer to overall EAS data structure
 * handle			- pointer to file handle
 * time				- time (in msecs)
 *		
 * Outputs:
 * 
 *
 * Side Effects:
 *
 *----------------------------------------------------------------------------
*/
/*lint -esym(715, pParserLocate) reserved for future use */
static EAS_RESULT WaveLocate (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData, EAS_I32 time, EAS_BOOL *pParserLocate)
{
	EAS_PCM_HANDLE streamHandle;

	/* reset to first byte of data in the stream */
	streamHandle = ((S_WAVE_STATE*)pInstData)->streamHandle;
	if (streamHandle)
		return EAS_PELocate(pEASData, streamHandle, time);
	return EAS_ERROR_NOT_VALID_IN_THIS_STATE;
}

/*----------------------------------------------------------------------------
 * WavePause()
 *----------------------------------------------------------------------------
 * 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_WAVE_STATE for this stream
 *		
 * Outputs:
 * 
 *
 * Side Effects:
 *
 *----------------------------------------------------------------------------
*/
/*lint -esym(715, pEASData) reserved for future use */
static EAS_RESULT WavePause (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData)
{
	EAS_PCM_HANDLE streamHandle;

	/* pause the stream */
	streamHandle = ((S_WAVE_STATE*)pInstData)->streamHandle;
	if (streamHandle)
		return EAS_PEPause(pEASData, streamHandle);
	return EAS_ERROR_NOT_VALID_IN_THIS_STATE;
}

/*----------------------------------------------------------------------------
 * WaveResume()
 *----------------------------------------------------------------------------
 * 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_WAVE_STATE for this stream
 *		
 * Outputs:
 * 
 *
 * Side Effects:
 *
 *----------------------------------------------------------------------------
*/
/*lint -esym(715, pEASData) reserved for future use */
static EAS_RESULT WaveResume (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData)
{
	EAS_PCM_HANDLE streamHandle;

	/* resume the stream */
	streamHandle = ((S_WAVE_STATE*)pInstData)->streamHandle;
	if (streamHandle)
		return EAS_PEResume(pEASData, streamHandle);
	return EAS_ERROR_NOT_VALID_IN_THIS_STATE;
}

/*----------------------------------------------------------------------------
 * WaveSetData()
 *----------------------------------------------------------------------------
 * Purpose: 
 *
 * Inputs:
 * pEASData			- pointer to EAS library instance data
 * handle			- pointer to S_WAVE_STATE for this stream
 *		
 * Outputs:
 * 
 *
 * Side Effects:
 *
 *----------------------------------------------------------------------------
*/
static EAS_RESULT WaveSetData (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData, EAS_I32 param, EAS_I32 value)
{
	S_WAVE_STATE *pWaveData = (S_WAVE_STATE*) pInstData;

	switch (param)
	{
		/* set metadata callback */
		case PARSER_DATA_METADATA_CB:
			EAS_HWMemCpy(&pWaveData->metadata, (void*) value, sizeof(S_METADATA_CB));
			return EAS_SUCCESS;

		case PARSER_DATA_PLAYBACK_RATE:
			value = (EAS_I32) (PITCH_CENTS_CONVERSION * log10((double) value / (double) (1 << 28)));
			return EAS_PEUpdatePitch(pEASData, pWaveData->streamHandle, (EAS_I16) value);

		case PARSER_DATA_VOLUME:
			return EAS_PEUpdateVolume(pEASData, pWaveData->streamHandle, (EAS_I16) value);
			
		default:
			return EAS_ERROR_INVALID_PARAMETER;
	}
}

/*----------------------------------------------------------------------------
 * WaveGetData()
 *----------------------------------------------------------------------------
 * Purpose: 
 *
 * Inputs:
 * pEASData			- pointer to EAS library instance data
 * handle			- pointer to S_WAVE_STATE for this stream
 *		
 * Outputs:
 * 
 *
 * Side Effects:
 *
 *----------------------------------------------------------------------------
*/
/*lint -esym(715, pEASData) reserved for future use */
static EAS_RESULT WaveGetData (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData, EAS_I32 param, EAS_I32 *pValue)
{
	S_WAVE_STATE *pWaveData;

	pWaveData = (S_WAVE_STATE*) pInstData;
	switch (param)
	{
		/* return file type as WAVE */
		case PARSER_DATA_FILE_TYPE:
			*pValue = pWaveData->fileType;
			break;

#ifdef MMAPI_SUPPORT
		/* return pointer to 'fmt' chunk */
		case PARSER_DATA_FORMAT:
			*pValue = (EAS_I32) pWaveData->fmtChunk;
			break;
#endif

		case PARSER_DATA_GAIN_OFFSET:
			*pValue = WAVE_GAIN_OFFSET;
			break;
			
		default:
			return EAS_ERROR_INVALID_PARAMETER;
	}
	
	return EAS_SUCCESS;
}

/*----------------------------------------------------------------------------
 * WaveParseHeader()
 *----------------------------------------------------------------------------
 * Purpose: 
 * Parse the WAVE file header.
 *
 * Inputs:
 * pEASData			- pointer to EAS library instance data
 * handle			- pointer to S_WAVE_STATE for this stream
 *		
 * Outputs:
 * 
 *
 * Side Effects:
 *
 *----------------------------------------------------------------------------
*/
static EAS_RESULT WaveParseHeader (S_EAS_DATA *pEASData, EAS_FILE_HANDLE fileHandle, S_WAVE_STATE *pWaveData)
{
	S_PCM_OPEN_PARAMS params;
	EAS_RESULT result;
	EAS_U32 tag;
	EAS_U32 fileSize;
	EAS_U32 size;
	EAS_I32 pos;
	EAS_I32 audioOffset;
	EAS_U16 usTemp;
	EAS_BOOL parseDone;
	EAS_U32 avgBytesPerSec;

	/* init some data (and keep lint happy) */
	params.sampleRate = 0;
	params.size = 0;
	audioOffset = 0;
	params.decoder = 0;
	params.blockSize = 0;
	params.pCallbackFunc = NULL;
	params.cbInstData = NULL;
	params.loopSamples = 0;
	params.fileHandle = fileHandle;
	params.volume = 0x7fff;
	params.envData = 0;
	avgBytesPerSec = 8000;

	/* check for 'RIFF' tag */
	if ((result = EAS_HWGetDWord(pEASData->hwInstData, fileHandle, &tag, EAS_TRUE)) != EAS_FALSE)
		return result;
	if (tag != CHUNK_RIFF)
		return EAS_ERROR_UNRECOGNIZED_FORMAT;

	/* get size */
	if ((result = EAS_HWGetDWord(pEASData->hwInstData, fileHandle, &fileSize, EAS_FALSE)) != EAS_FALSE)
		return result;

	/* check for 'WAVE' tag */
	if ((result = EAS_HWGetDWord(pEASData->hwInstData, fileHandle, &tag, EAS_TRUE)) != EAS_FALSE)
		return result;
	if (tag != CHUNK_WAVE)
		return EAS_ERROR_UNRECOGNIZED_FORMAT;

	/* this is enough to say we recognize the file */
	if (pWaveData == NULL)
		return EAS_SUCCESS;

	/* check for streaming mode */
	pWaveData->flags = 0;
	pWaveData->mediaLength = -1;
	pWaveData->infoChunkPos = -1;
	pWaveData->infoChunkSize = -1;
	if (fileSize== FILE_SIZE_STREAMING)
	{
		pWaveData->flags |= PCM_FLAGS_STREAMING;
		fileSize = 0x7fffffff;
	}

	/* find out where we're at */
	if ((result = EAS_HWFilePos(pEASData->hwInstData, fileHandle, &pos)) != EAS_SUCCESS)
		return result;
	fileSize -= 4;

	parseDone = EAS_FALSE;
	for (;;)
	{
		/* get tag and size for next chunk */
		if ((result = EAS_HWGetDWord(pEASData->hwInstData, fileHandle, &tag, EAS_TRUE)) != EAS_FALSE)
			return result;
		if ((result = EAS_HWGetDWord(pEASData->hwInstData, fileHandle, &size, EAS_FALSE)) != EAS_FALSE)
			return result;

		/* process chunk */
		pos += 8;
		switch (tag)
		{
			case CHUNK_FMT:

#ifdef MMAPI_SUPPORT
				if ((result = SaveFmtChunk(pEASData, fileHandle, pWaveData, (EAS_I32) size)) != EAS_SUCCESS)
					return result;
#endif
				
				/* get audio format */
				if ((result = EAS_HWGetWord(pEASData->hwInstData, fileHandle, &usTemp, EAS_FALSE)) != EAS_FALSE)
					return result;
				if (usTemp == WAVE_FORMAT_PCM)
				{
					params.decoder = EAS_DECODER_PCM;
					pWaveData->fileType = EAS_FILE_WAVE_PCM;
				}
				else if (usTemp == WAVE_FORMAT_IMA_ADPCM)
				{
					params.decoder = EAS_DECODER_IMA_ADPCM;
					pWaveData->fileType = EAS_FILE_WAVE_IMA_ADPCM;
				}
				else
					return EAS_ERROR_UNRECOGNIZED_FORMAT;
				
				/* get number of channels */
				if ((result = EAS_HWGetWord(pEASData->hwInstData, fileHandle, &usTemp, EAS_FALSE)) != EAS_FALSE)
					return result;
				if (usTemp == 2)
					pWaveData->flags |= PCM_FLAGS_STEREO;
				else if (usTemp != 1)
					return EAS_ERROR_UNRECOGNIZED_FORMAT;

				/* get sample rate */
				if ((result = EAS_HWGetDWord(pEASData->hwInstData, fileHandle, &params.sampleRate, EAS_FALSE)) != EAS_FALSE)
					return result;

				/* get stream rate */
				if ((result = EAS_HWGetDWord(pEASData->hwInstData, fileHandle, &avgBytesPerSec, EAS_FALSE)) != EAS_FALSE)
					return result;

				/* get block alignment */				
				if ((result = EAS_HWGetWord(pEASData->hwInstData, fileHandle, &usTemp, EAS_FALSE)) != EAS_FALSE)
					return result;
				params.blockSize = usTemp;
				
				/* get bits per sample */				
				if ((result = EAS_HWGetWord(pEASData->hwInstData, fileHandle, &usTemp, EAS_FALSE)) != EAS_FALSE)
					return result;
				
				/* PCM, must be 8 or 16 bit samples */
				if (params.decoder == EAS_DECODER_PCM)
				{
					if (usTemp == 8)
						pWaveData->flags |= PCM_FLAGS_8_BIT | PCM_FLAGS_UNSIGNED;
					else if (usTemp != 16)
						return EAS_ERROR_UNRECOGNIZED_FORMAT;
				}

				/* for IMA ADPCM, we only support mono 4-bit ADPCM */
				else
				{
					if ((usTemp != 4) || (pWaveData->flags & PCM_FLAGS_STEREO))
						return EAS_ERROR_UNRECOGNIZED_FORMAT;
				}

				break;

			case CHUNK_DATA:
				audioOffset = pos;
				if (pWaveData->flags & PCM_FLAGS_STREAMING)
				{
					params.size = 0x7fffffff;
					parseDone = EAS_TRUE;
				}
				else
				{
					params.size = (EAS_I32) size;
					params.loopStart = size;
					/* use more accurate method if possible */
					if (size <= (0x7fffffff / 1000))
						pWaveData->mediaLength = (EAS_I32) ((size * 1000) / avgBytesPerSec);
					else
						pWaveData->mediaLength = (EAS_I32) (size / (avgBytesPerSec / 1000));
				}
				break;

			case CHUNK_LIST:
				/* get the list type */
				if ((result = EAS_HWGetDWord(pEASData->hwInstData, fileHandle, &tag, EAS_TRUE)) != EAS_FALSE)
					return result;
				if (tag == CHUNK_INFO)
				{
					pWaveData->infoChunkPos = pos + 4;
					pWaveData->infoChunkSize = (EAS_I32) size - 4;
				}
				break;

			default:
				{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_INFO, "WaveParseHeader: %c%c%c%c chunk - %d byte(s) ignored\n",
					(char) (tag >> 24), (char) (tag >> 16), (char) (tag >> 8), (char) tag, size); */ }
				break;
		}

		if (parseDone)
			break;

		/* subtract header size */
		fileSize -= 8;

		/* account for zero-padding on odd length chunks */
		if (size & 1)
			size++;

		/* this check works for files with odd length last chunk and no zero-pad */
		if (size >= fileSize)
		{
			if (size > fileSize)
				{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_INFO, "WaveParseHeader: '%c%c%c%c' chunk size exceeds length of file or is not zero-padded\n",
					(char) (tag >> 24), (char) (tag >> 16), (char) (tag >> 8), (char) tag, size); */ }
			break;
		}

		/* subtract size of data chunk (including any zero-pad) */
		fileSize -= size;

		/* seek to next chunk */
		pos += (EAS_I32) size;
		if ((result = EAS_HWFileSeek(pEASData->hwInstData, fileHandle, pos)) != EAS_SUCCESS)
			return result;
	}

	/* check for valid header */
	if ((params.sampleRate == 0) || (params.size == 0))
		return EAS_ERROR_UNRECOGNIZED_FORMAT;

	/* save the pertinent information */
	pWaveData->audioOffset = audioOffset;
	params.flags = pWaveData->flags;

	/* seek to data */
	if ((result = EAS_HWFileSeek(pEASData->hwInstData, fileHandle, audioOffset)) != EAS_SUCCESS)
		return result;

	/* open a stream in the PCM engine */
	return EAS_PEOpenStream(pEASData, &params, &pWaveData->streamHandle);
}

/*----------------------------------------------------------------------------
 * WaveGetMetaData()
 *----------------------------------------------------------------------------
 * Purpose: 
 * Process the INFO chunk and return metadata to host
 *----------------------------------------------------------------------------
*/
static EAS_RESULT WaveGetMetaData (S_EAS_DATA *pEASData, EAS_VOID_PTR pInstData, EAS_I32 *pMediaLength)
{
	S_WAVE_STATE *pWaveData;
	EAS_RESULT result;
	EAS_I32 pos;
	EAS_U32 size;
	EAS_I32 infoSize;
	EAS_U32 tag;
	EAS_I32 restorePos;
	E_EAS_METADATA_TYPE metaType;
	EAS_I32 metaLen;

	/* get current position so we can restore it */
	pWaveData = (S_WAVE_STATE*) pInstData;

	/* return media length */
	*pMediaLength = pWaveData->mediaLength;

	/* did we encounter an INFO chunk? */
	if (pWaveData->infoChunkPos < 0)
		return EAS_SUCCESS;
	
	if ((result = EAS_HWFilePos(pEASData->hwInstData, pWaveData->fileHandle, &restorePos)) != EAS_SUCCESS)
		return result;
	
	/* offset to start of first chunk in INFO chunk */
	pos = pWaveData->infoChunkPos;
	infoSize = pWaveData->infoChunkSize;

	/* read all the chunks in the INFO chunk */
	for (;;)
	{
		
		/* seek to next chunk */
		if ((result = EAS_HWFileSeek(pEASData->hwInstData, pWaveData->fileHandle, pos)) != EAS_SUCCESS)
			return result;
		
		/* get tag and size for next chunk */
		if ((result = EAS_HWGetDWord(pEASData->hwInstData, pWaveData->fileHandle, &tag, EAS_TRUE)) != EAS_FALSE)
			return result;
		if ((result = EAS_HWGetDWord(pEASData->hwInstData, pWaveData->fileHandle, &size, EAS_FALSE)) != EAS_FALSE)
			return result;

		/* process chunk */
		pos += 8;
		metaType = EAS_METADATA_UNKNOWN;
		switch (tag)
		{
			case CHUNK_INAM:
				metaType = EAS_METADATA_TITLE;
				break;

			case CHUNK_IART:
				metaType = EAS_METADATA_AUTHOR;
				break;

			case CHUNK_ICOP:
				metaType = EAS_METADATA_COPYRIGHT;
				break;

			default:
				{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_INFO, "WaveParseHeader: %c%c%c%c chunk - %d byte(s) ignored\n",
					(char) (tag >> 24), (char) (tag >> 16), (char) (tag >> 8), (char) tag, size); */ }
				break;
		}

		/* process known metadata */
		if (metaType != EAS_METADATA_UNKNOWN)
		{
			metaLen = pWaveData->metadata.bufferSize - 1;
			if (metaLen > (EAS_I32) size)
				metaLen = (EAS_I32) size;
			if ((result = EAS_HWReadFile(pEASData->hwInstData, pWaveData->fileHandle, pWaveData->metadata.buffer, metaLen, &metaLen)) != EAS_SUCCESS)
				return result;
			pWaveData->metadata.buffer[metaLen] = 0;
			pWaveData->metadata.callback(metaType, pWaveData->metadata.buffer, pWaveData->metadata.pUserData);
		}
		
		/* subtract this block */
		if (size & 1)
			size++;
		infoSize -= (EAS_I32) size + 8;
		if (infoSize == 0)
			break;
		pos += (EAS_I32) size;
	}


	/* restore original position */	
	return EAS_HWFileSeek(pEASData->hwInstData, pWaveData->fileHandle, restorePos);
}

#ifdef MMAPI_SUPPORT
/*----------------------------------------------------------------------------
 * SaveFmtChunk()
 *----------------------------------------------------------------------------
 * Purpose: 
 * Save the fmt chunk for the MMAPI library
 *----------------------------------------------------------------------------
*/
static EAS_RESULT SaveFmtChunk (S_EAS_DATA *pEASData, EAS_FILE_HANDLE fileHandle, S_WAVE_STATE *pWaveData, EAS_I32 fmtSize)
{
	EAS_RESULT result;
	EAS_I32 pos;
	EAS_I32 count;

	/* save current file position */
	if ((result = EAS_HWFilePos(pEASData->hwInstData, fileHandle, &pos)) != EAS_SUCCESS)
		return result;

	/* allocate a chunk of memory */
	pWaveData->fmtChunk = EAS_HWMalloc(pEASData->hwInstData, fmtSize);
	if (!pWaveData->fmtChunk)
		return EAS_ERROR_MALLOC_FAILED;

	/* read the fmt chunk into memory */
	if ((result = EAS_HWReadFile(pEASData->hwInstData, fileHandle, pWaveData->fmtChunk, fmtSize, &count)) != EAS_SUCCESS)
		return result;
	if (count != fmtSize)
		return EAS_ERROR_FILE_READ_FAILED;

	/* restore file position */
	return EAS_HWFileSeek(pEASData->hwInstData, fileHandle, pos);
}
#endif