Initial Contribution

2 files changed, 787 insertions, 0 deletions

diff --git a/arm-wt-22k/misc/MMAPI.zip b/arm-wt-22k/misc/MMAPI.zip
new file mode 100644
index 0000000..c185dbd
--- /dev/null
+++ b/arm-wt-22k/misc/MMAPI.zip
diff --git a/arm-wt-22k/misc/eas_host.c b/arm-wt-22k/misc/eas_host.c
new file mode 100644
index 0000000..89eb87a
--- /dev/null
+++ b/arm-wt-22k/misc/eas_host.c
@@ -0,0 +1,787 @@
+/*----------------------------------------------------------------------------

+ *

+ * File: 

+ * eas_host.c

+ *

+ * Contents and purpose:

+ * This file contains the host wrapper functions for stdio, stdlib, etc.

+ * This is a sample version that wraps the standard library functions.

+ * Modify this file to suit the needs of your particular system.

+ *

+ * EAS_MAX_FILE_HANDLES sets the maximum number of MIDI streams within

+ * a MIDI type 1 file that can be played. To maintain efficiency, data

+ * is buffered locally when byte access is used (EAS_HWGetByte). The

+ * size of the buffer is set by EAS_FILE_BUFFER_SIZE.

+ *

+ * EAS_HW_FILE is a structure to support local file buffering. It

+ * comprises the OS File handle, some data related to the local file

+ * buffer, the position of the next byte of data to be read, the dup

+ * flag which when set, indicates that the handle has been duplicated,

+ * and the data buffer. Since the data buffer is only used for byte

+ * access, it does not need to be large.

+ *

+ * If the file system supports duplicate file handles and buffering,

+ * this entire subsystem can be replaced with direct calls to the

+ * native file I/O routines.

+ *

+ * If the system has enough memory to support reading the entire file

+ * into memory, it will be much more efficient to do so on the call to

+ * EAS_HWOpenFile and then close the file. Simply substitute a memory

+ * pointer for the FILE* pointer. Calls to EAS_HW_DupHandle will work

+ * as they do in this version. In the call to EAS_HWCloseFile, instead

+ * of calling fclose, free the memory containing the file data.

+ *

+ * Copyright 2005 Sonic Network Inc.

+
+ * 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: 853 $

+ *   $Date: 2007-09-05 09:54:17 -0700 (Wed, 05 Sep 2007) $

+ *----------------------------------------------------------------------------

+*/

+

+#ifdef _lint

+#include "lint_stdlib.h"

+#else

+#include <stdio.h>

+#include <stdlib.h>

+#include <string.h>

+#endif

+

+#include "eas_host.h"

+

+// #define DEBUG_FILE_IO

+

+/* Only for debugging LED, vibrate, and backlight functions */

+#include "eas_report.h"

+

+#ifndef EAS_MAX_FILE_HANDLES

+#define EAS_MAX_FILE_HANDLES	32

+#endif

+

+#ifndef EAS_FILE_BUFFER_SIZE

+#define EAS_FILE_BUFFER_SIZE	32

+#endif

+

+/* 

+ * this structure and the related function are here

+ * to support the ability to create duplicate handles

+ * and buffering into a single file. If the OS supports

+ * duplicate file handles natively, this code can be

+ * stripped to eliminate double-buffering.

+ */

+typedef struct eas_hw_file_tag

+{

+	FILE *pFile;

+	EAS_I32 bytesInBuffer;

+	EAS_I32 readIndex;

+	EAS_I32 filePos;

+	EAS_BOOL dup;

+	EAS_U8 buffer[EAS_FILE_BUFFER_SIZE];

+} EAS_HW_FILE;

+

+typedef struct eas_hw_inst_data_tag

+{

+	EAS_HW_FILE files[EAS_MAX_FILE_HANDLES];

+} EAS_HW_INST_DATA;

+

+/* local memory for files and streams */

+#ifdef _STATIC_MEMORY

+EAS_HW_INST_DATA fileData;

+#endif

+

+/*----------------------------------------------------------------------------

+ * EAS_HWInit

+ *

+ * Initialize host wrapper interface

+ *

+ *----------------------------------------------------------------------------

+*/

+EAS_RESULT EAS_HWInit (EAS_HW_DATA_HANDLE *pHWInstData)

+{

+

+	/* need to track file opens for duplicate handles */

+#ifndef _STATIC_MEMORY

+	*pHWInstData = malloc(sizeof(EAS_HW_INST_DATA));

+	if (!(*pHWInstData))

+		return EAS_ERROR_MALLOC_FAILED;

+#else

+	*pHWInstData = &fileData;

+#endif

+	EAS_HWMemSet(*pHWInstData, 0, sizeof(EAS_HW_INST_DATA));

+	return EAS_SUCCESS;

+}

+

+/*----------------------------------------------------------------------------

+ * EAS_HWShutdown

+ *

+ * Shut down host wrapper interface

+ *

+ *----------------------------------------------------------------------------

+*/

+/*lint -esym(715, hwInstData) hwInstData available for customer use */

+EAS_RESULT EAS_HWShutdown (EAS_HW_DATA_HANDLE hwInstData)

+{

+

+#ifndef _STATIC_MEMORY

+	free(hwInstData);

+#endif

+	return EAS_SUCCESS;

+}

+

+/*----------------------------------------------------------------------------

+ *

+ * EAS_HWMalloc

+ *

+ * Allocates dynamic memory

+ *

+ *----------------------------------------------------------------------------

+*/

+/*lint -esym(715, hwInstData) hwInstData available for customer use */

+#ifdef _STATIC_MEMORY

+/*lint -esym(715, size) not used in static memory model */

+#endif

+void *EAS_HWMalloc (EAS_HW_DATA_HANDLE hwInstData, EAS_I32 size)

+{

+#ifdef _STATIC_MEMORY

+	return NULL;

+#else

+	return malloc((EAS_U32)size);

+#endif

+}

+

+/*----------------------------------------------------------------------------

+ *

+ * EAS_HWFree

+ *

+ * Frees dynamic memory

+ *

+ *----------------------------------------------------------------------------

+*/

+/*lint -esym(715, hwInstData) hwInstData available for customer use */

+#ifdef _STATIC_MEMORY

+/*lint -esym(715, p) not used in static memory model */

+#endif

+void EAS_HWFree(EAS_HW_DATA_HANDLE hwInstData, void *p)

+{

+#ifndef _STATIC_MEMORY

+	free(p);

+#endif

+}

+

+/*----------------------------------------------------------------------------

+ *

+ * EAS_HWMemCpy

+ *

+ * Copy memory wrapper

+ *

+ *----------------------------------------------------------------------------

+*/

+void *EAS_HWMemCpy (void *dest, const void *src, EAS_I32 amount) 

+{

+	return memcpy(dest,src,(size_t) amount);

+}

+

+/*----------------------------------------------------------------------------

+ *

+ * EAS_HWMemSet

+ *

+ * Set memory wrapper

+ *

+ *----------------------------------------------------------------------------

+*/

+void *EAS_HWMemSet (void *dest, int val, EAS_I32 amount) 

+{

+	return memset(dest,val,(size_t) amount);

+}

+

+/*----------------------------------------------------------------------------

+ *

+ * EAS_HWMemCmp

+ *

+ * Compare memory wrapper

+ *

+ *----------------------------------------------------------------------------

+*/

+EAS_I32 EAS_HWMemCmp (const void *s1, const void *s2, EAS_I32 amount) 

+{

+	return (EAS_I32) memcmp(s1, s2, (size_t) amount);

+}

+

+/*----------------------------------------------------------------------------

+ *

+ * EAS_HWOpenFile

+ *

+ * Open a file for read or write

+ *

+ *----------------------------------------------------------------------------

+*/

+EAS_RESULT EAS_HWOpenFile (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_LOCATOR locator, EAS_FILE_HANDLE *pFile, EAS_FILE_MODE mode)

+{

+	EAS_HW_FILE *file;

+	int i;

+

+	/* set return value to NULL */

+	*pFile = NULL;

+

+	/* only support read mode at this time */

+	if (mode != EAS_FILE_READ)

+		return EAS_ERROR_INVALID_FILE_MODE;

+

+	/* find an empty entry in the file table */

+	file = hwInstData->files;

+	for (i = 0; i < EAS_MAX_FILE_HANDLES; i++)

+	{

+		/* is this slot being used? */

+		if (file->pFile == NULL)

+		{

+			/* open the file */

+			if (locator->path)

+				file->pFile = fopen((const char*) locator->path, "rb");

+			if (file->pFile == NULL)

+				return EAS_ERROR_FILE_OPEN_FAILED;

+

+#ifdef DEBUG_FILE_IO			

+		 	EAS_ReportX(_EAS_SEVERITY_NOFILTER, "EAS_HWOpenFile: Open file %d\n", i);

+#endif

+

+			/* initialize some values */

+			file->bytesInBuffer = 0;

+			file->readIndex = 0;

+			file->filePos = 0;

+			file->dup = EAS_FALSE;

+

+			*pFile = file;

+			return EAS_SUCCESS;

+		}

+		file++;

+	}

+

+	/* too many open files */

+	return EAS_ERROR_MAX_FILES_OPEN;

+}

+

+/*----------------------------------------------------------------------------

+ *

+ * EAS_HWFillBuffer

+ *

+ * Fill buffer from file

+ *----------------------------------------------------------------------------

+*/

+/*lint -esym(715, hwInstData) hwInstData available for customer use */

+EAS_RESULT EAS_HWFillBuffer (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE file)

+{

+	/* reposition the file pointer */

+	if (fseek(file->pFile, file->filePos, SEEK_SET) != 0)

+		return EAS_ERROR_FILE_SEEK;

+

+	/* read some data from the file */

+	file->bytesInBuffer = (EAS_I32) fread(file->buffer, 1, EAS_FILE_BUFFER_SIZE, file->pFile);

+	file->readIndex = 0;

+	if (file->bytesInBuffer == 0)

+		return EAS_EOF;

+	return EAS_SUCCESS;

+}

+

+/*----------------------------------------------------------------------------

+ *

+ * EAS_HWReadFile

+ *

+ * Read data from a file

+ *----------------------------------------------------------------------------

+*/

+/*lint -esym(715, hwInstData) hwInstData available for customer use */

+EAS_RESULT EAS_HWReadFile (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE file, void *pBuffer, EAS_I32 n, EAS_I32 *pBytesRead)

+{

+	EAS_RESULT result;

+	EAS_I32 temp;

+	EAS_U8 *p = pBuffer;

+	EAS_I32 bytesLeft = n;

+

+	*pBytesRead = 0;

+

+	/* check handle integrity */	

+	if (file->pFile == NULL)

+		return EAS_ERROR_INVALID_HANDLE;

+

+#ifdef DEBUG_FILE_IO

+	EAS_ReportX(_EAS_SEVERITY_NOFILTER, "EAS_HWReadFile: Reading %d bytes from position %d\n", n, file->filePos);

+#endif

+

+	/* try to fulfill request from buffer */

+	for (;bytesLeft > 0;)

+	{

+		/* how many bytes can we get from buffer? */

+		temp = file->bytesInBuffer - file->readIndex;

+		if (temp > bytesLeft)

+			temp = bytesLeft;

+		

+		/* copy data from buffer */

+		EAS_HWMemCpy(p, &file->buffer[file->readIndex], temp);

+		*pBytesRead += temp;

+		file->readIndex += temp;

+		file->filePos += temp;

+		bytesLeft -= temp;

+		p += temp;

+

+		/* don't refill buffer if request is bigger than buffer */

+		if ((bytesLeft == 0) || (bytesLeft >= EAS_FILE_BUFFER_SIZE))

+			break;

+

+		/* refill buffer */

+		if ((result = EAS_HWFillBuffer(hwInstData, file)) != EAS_SUCCESS)

+			return result;

+	}

+

+	/* more to read? do unbuffered read directly to target memory */

+	if (bytesLeft)

+	{

+

+		/* position the file pointer */

+		if (fseek(file->pFile, file->filePos, SEEK_SET) != 0)

+			return EAS_ERROR_FILE_SEEK;

+

+		/* read data in the buffer */

+		/*lint -e{826} lint doesn't like this with STATIC_MEMORY defined for some reason */

+		temp = (EAS_I32) fread(p, 1, (size_t) bytesLeft, file->pFile);

+		*pBytesRead += temp;

+		file->filePos += temp;

+

+		/* reset buffer info */

+		file->bytesInBuffer = 0;

+		file->readIndex = 0;

+	}

+

+#ifdef DEBUG_FILE_IO

+	{

+#define BYTES_PER_LINE 16

+		char str[BYTES_PER_LINE * 3 + 1];

+		EAS_INT i;

+		for (i = 0; i < (n > BYTES_PER_LINE ? BYTES_PER_LINE : n) ; i ++)

+			sprintf(&str[i*3], "%02x ", ((EAS_U8*)pBuffer)[i]);

+		if (i)

+			EAS_ReportX(_EAS_SEVERITY_NOFILTER, "%s\n", str);

+	}

+#endif

+

+	/* were n bytes read? */

+	if (*pBytesRead != n)

+		return EAS_EOF;

+

+	return EAS_SUCCESS;

+}

+

+/*----------------------------------------------------------------------------

+ *

+ * EAS_HWGetByte

+ *

+ * Read a byte from a file

+ *----------------------------------------------------------------------------

+*/

+/*lint -esym(715, hwInstData) hwInstData available for customer use */

+EAS_RESULT EAS_HWGetByte (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE file, void *p)

+{

+	EAS_RESULT result;

+

+	/* check handle integrity */	

+	if (file->pFile == NULL)

+		return EAS_ERROR_INVALID_HANDLE;

+

+	/* use local buffer - do we have any data? */

+	if (file->readIndex >= file->bytesInBuffer)

+	{

+		if ((result = EAS_HWFillBuffer(hwInstData, file)) != EAS_SUCCESS)

+			return result;

+

+		/* if nothing to read, return EOF */

+		if (file->bytesInBuffer == 0)

+			return EAS_EOF;

+	}

+

+	/* get a character from the buffer */

+	*((EAS_U8*) p) = file->buffer[file->readIndex++];

+

+#ifdef DEBUG_FILE_IO

+	EAS_ReportX(_EAS_SEVERITY_NOFILTER, "EAS_HWGetByte: Reading from position %d, byte = 0x%02x\n", file->filePos, *(EAS_U8*)p);

+#endif

+

+	file->filePos++;

+	return EAS_SUCCESS;

+}

+

+/*----------------------------------------------------------------------------

+ *

+ * EAS_HWGetWord

+ *

+ * Read a 16-bit value from the file

+ *----------------------------------------------------------------------------

+*/

+EAS_RESULT EAS_HWGetWord (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE file, void *p, EAS_BOOL msbFirst)

+{

+	EAS_RESULT result;

+	EAS_I32 count;

+	EAS_U8 c[2];

+

+#ifdef DEBUG_FILE_IO

+	EAS_ReportX(_EAS_SEVERITY_NOFILTER, "EAS_HWGetWord: Reading 2 bytes from position %d\n", file->filePos);

+#endif

+

+	/* read 2 bytes from the file */

+	if ((result = EAS_HWReadFile(hwInstData, file, c, 2, &count)) != EAS_SUCCESS)

+		return result;

+

+	/* order them as requested */

+	if (msbFirst)

+		*((EAS_U16*) p) = ((EAS_U16) c[0] << 8) | c[1];

+	else

+		*((EAS_U16*) p) = ((EAS_U16) c[1] << 8) | c[0];

+

+	return EAS_SUCCESS;

+}

+

+/*----------------------------------------------------------------------------

+ *

+ * EAS_HWGetDWord

+ *

+ * Read a 16-bit value from the file

+ *----------------------------------------------------------------------------

+*/

+EAS_RESULT EAS_HWGetDWord (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE file, void *p, EAS_BOOL msbFirst)

+{

+	EAS_RESULT result;

+	EAS_I32 count;

+	EAS_U8 c[4];

+

+#ifdef DEBUG_FILE_IO

+	EAS_ReportX(_EAS_SEVERITY_NOFILTER, "EAS_HWGetDWord: Reading 4 bytes from position %d\n", file->filePos);

+#endif

+

+	/* read 4 bytes from the file */

+	if ((result = EAS_HWReadFile(hwInstData, file, c, 4, &count)) != EAS_SUCCESS)

+		return result;

+

+	/* order them as requested */

+	if (msbFirst)

+		*((EAS_U32*) p) = ((EAS_U32) c[0] << 24) | ((EAS_U32) c[1] << 16) | ((EAS_U32) c[2] << 8) | c[3];

+	else

+		*((EAS_U32*) p) = ((EAS_U32) c[3] << 24) | ((EAS_U32) c[2] << 16) | ((EAS_U32) c[1] << 8) | c[0];

+	

+	return EAS_SUCCESS;

+}

+

+/*----------------------------------------------------------------------------

+ *

+ * EAS_HWFilePos

+ *

+ * Returns the current location in the file 

+ *

+ *----------------------------------------------------------------------------

+*/

+/*lint -esym(715, hwInstData) hwInstData available for customer use */

+EAS_RESULT EAS_HWFilePos (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE file, EAS_I32 *pPosition)

+{

+

+	/* check handle integrity */	

+	if (file->pFile == NULL)

+		return EAS_ERROR_INVALID_HANDLE;

+	

+	*pPosition = file->filePos;

+	return EAS_SUCCESS;

+}

+

+/*----------------------------------------------------------------------------

+ *

+ * EAS_HWFileSeek

+ *

+ * Seek to a specific location in the file

+ *

+ *----------------------------------------------------------------------------

+*/

+/*lint -esym(715, hwInstData) hwInstData available for customer use */

+EAS_RESULT EAS_HWFileSeek (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE file, EAS_I32 position)

+{

+	EAS_I32 newIndex;

+

+	/* check handle integrity */	

+	if (file->pFile == NULL)

+		return EAS_ERROR_INVALID_HANDLE;

+

+#ifdef DEBUG_FILE_IO

+	EAS_ReportX(_EAS_SEVERITY_NOFILTER, "EAS_HWFileSeek: Seeking to new position %d\n", file->filePos);

+#endif

+

+	/* is new position in current buffer? */

+	newIndex = position - file->filePos + file->readIndex;

+	if ((newIndex >= 0) && (newIndex < file->bytesInBuffer))

+	{

+		file->readIndex = newIndex;

+		file->filePos = position;

+		return EAS_SUCCESS;

+	}

+

+	/* save new position and reset buffer info so EAS_HWGetByte doesn't fail */

+	file->filePos = position;

+	file->bytesInBuffer = 0;

+	file->readIndex = 0;

+	return EAS_SUCCESS;

+}

+

+/*----------------------------------------------------------------------------

+ *

+ * EAS_HWFileSeekOfs

+ *

+ * Seek forward or back relative to the current position

+ *

+ *----------------------------------------------------------------------------

+*/

+/*lint -esym(715, hwInstData) hwInstData available for customer use */

+EAS_RESULT EAS_HWFileSeekOfs (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE file, EAS_I32 position)

+{

+	EAS_I32 temp;

+

+#ifdef DEBUG_FILE_IO

+	EAS_ReportX(_EAS_SEVERITY_NOFILTER, "EAS_HWFileSeekOfs: Seeking to new position %d\n", file->filePos + position);

+#endif

+

+	/* check handle integrity */	

+	if (file->pFile == NULL)

+		return EAS_ERROR_INVALID_HANDLE;

+

+	/* is new position in current buffer? */

+	temp = position + file->readIndex;

+	if ((temp >= 0) && (temp < file->bytesInBuffer))

+	{

+		file->readIndex = temp;

+		file->filePos += position;

+		return EAS_SUCCESS;

+	}

+

+	/* save new position and reset buffer info so EAS_HWGetByte doesn't fail */

+	file->filePos += position;

+	file->bytesInBuffer = 0;

+	file->readIndex = 0;

+	return EAS_SUCCESS;

+}

+

+/*----------------------------------------------------------------------------

+ *

+ * EAS_HWFileLength

+ *

+ * Return the file length

+ *

+ *----------------------------------------------------------------------------

+*/

+/*lint -esym(715, hwInstData) hwInstData available for customer use */

+EAS_RESULT EAS_HWFileLength (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE file, EAS_I32 *pLength)

+{

+	long pos;

+

+	/* check handle integrity */	

+	if (file->pFile == NULL)

+		return EAS_ERROR_INVALID_HANDLE;

+

+	if ((pos = ftell(file->pFile)) == -1L)

+		return EAS_ERROR_FILE_LENGTH;

+	if (fseek(file->pFile, 0L, SEEK_END) != 0)

+		return EAS_ERROR_FILE_LENGTH;

+	if ((*pLength = ftell(file->pFile)) == -1L)

+		return EAS_ERROR_FILE_LENGTH;

+	if (fseek(file->pFile, pos, SEEK_SET) != 0)

+		return EAS_ERROR_FILE_LENGTH;

+	return EAS_SUCCESS;

+}

+

+/*----------------------------------------------------------------------------

+ *

+ * EAS_HWDupHandle

+ *

+ * Duplicate a file handle

+ *

+ *----------------------------------------------------------------------------

+*/

+EAS_RESULT EAS_HWDupHandle (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE file, EAS_FILE_HANDLE* pDupFile)

+{

+	EAS_HW_FILE *dupfile;

+	int i;

+

+	/* check handle integrity */

+	*pDupFile = NULL;

+	if (file->pFile == NULL)

+		return EAS_ERROR_INVALID_HANDLE;

+

+	/* find an empty entry in the file table */

+	dupfile = hwInstData->files;

+	for (i = 0; i < EAS_MAX_FILE_HANDLES; i++)

+	{

+		/* is this slot being used? */

+		if (dupfile->pFile == NULL)

+		{

+

+			/* copy info from the handle to be duplicated */

+			dupfile->filePos = file->filePos;

+			dupfile->pFile = file->pFile;

+

+			/* set the duplicate handle flag */

+			dupfile->dup = file->dup = EAS_TRUE;

+

+			/* initialize some values */

+			dupfile->bytesInBuffer = 0;

+			dupfile->readIndex = 0;

+

+			*pDupFile = dupfile;

+			return EAS_SUCCESS;

+		}

+		dupfile++;

+	}

+

+	/* too many open files */

+	return EAS_ERROR_MAX_FILES_OPEN;

+}

+

+/*----------------------------------------------------------------------------

+ *

+ * EAS_HWClose

+ *

+ * Wrapper for fclose function

+ *

+ *----------------------------------------------------------------------------

+*/

+EAS_RESULT EAS_HWCloseFile (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE file1)

+{

+	EAS_HW_FILE *file2,*dupFile;

+	int i;

+

+	/* check handle integrity */	

+	if (file1->pFile == NULL)

+		return EAS_ERROR_INVALID_HANDLE;

+

+	/* check for duplicate handle */

+	if (file1->dup)

+	{

+		dupFile = NULL;

+		file2 = hwInstData->files;

+		for (i = 0; i < EAS_MAX_FILE_HANDLES; i++)

+		{

+			/* check for duplicate */

+			if ((file1 != file2) && (file2->pFile == file1->pFile))

+			{

+				/* is there more than one duplicate? */

+				if (dupFile != NULL)

+				{

+					/* clear this entry and return */

+					file1->pFile = NULL;

+					return EAS_SUCCESS;

+				}

+

+				/* this is the first duplicate found */

+				dupFile = file2;

+			}

+			file2++;

+		}

+

+		/* there is only one duplicate, clear the dup flag */

+		if (dupFile)

+			dupFile->dup = EAS_FALSE;

+		else

+			/* if we get here, there's a serious problem */

+			return EAS_ERROR_HANDLE_INTEGRITY;

+

+		/* clear this entry and return */

+		file1->pFile = NULL;

+		return EAS_SUCCESS;

+	}

+

+	/* no duplicates - close the file */

+	if (fclose(file1->pFile) != 0)

+		return EAS_ERROR_CLOSE_FAILED;

+

+	/* clear this entry and return */

+	file1->pFile = NULL;

+	return EAS_SUCCESS;

+}

+

+/*----------------------------------------------------------------------------

+ *

+ * EAS_HWVibrate

+ *

+ * Turn on/off vibrate function

+ *

+ *----------------------------------------------------------------------------

+*/

+/*lint -esym(715, hwInstData) hwInstData available for customer use */

+EAS_RESULT EAS_HWVibrate (EAS_HW_DATA_HANDLE hwInstData, EAS_BOOL state)

+{

+	EAS_ReportX(_EAS_SEVERITY_NOFILTER, "Vibrate state: %d\n", state);

+	return EAS_SUCCESS;

+}

+

+/*----------------------------------------------------------------------------

+ *

+ * EAS_HWLED

+ *

+ * Turn on/off LED

+ *

+ *----------------------------------------------------------------------------

+*/

+/*lint -esym(715, hwInstData) hwInstData available for customer use */

+EAS_RESULT EAS_HWLED (EAS_HW_DATA_HANDLE hwInstData, EAS_BOOL state)

+{

+	EAS_ReportX(_EAS_SEVERITY_NOFILTER, "LED state: %d\n", state);

+	return EAS_SUCCESS;

+}

+

+/*----------------------------------------------------------------------------

+ *

+ * EAS_HWBackLight

+ *

+ * Turn on/off backlight

+ *

+ *----------------------------------------------------------------------------

+*/

+/*lint -esym(715, hwInstData) hwInstData available for customer use */

+EAS_RESULT EAS_HWBackLight (EAS_HW_DATA_HANDLE hwInstData, EAS_BOOL state)

+{

+	EAS_ReportX(_EAS_SEVERITY_NOFILTER, "Backlight state: %d\n", state);

+	return EAS_SUCCESS;

+}

+

+/*----------------------------------------------------------------------------

+ *

+ * EAS_HWYield

+ *

+ * This function is called periodically by the EAS library to give the

+ * host an opportunity to allow other tasks to run. There are two ways to

+ * use this call:

+ *

+ * If you have a multi-tasking OS, you can call the yield function in the

+ * OS to allow other tasks to run. In this case, return EAS_FALSE to tell

+ * the EAS library to continue processing when control returns from this

+ * function.

+ *

+ * If tasks run in a single thread by sequential function calls (sometimes

+ * call a "commutator loop"), return EAS_TRUE to cause the EAS Library to

+ * return to the caller. Be sure to check the number of bytes rendered

+ * before passing the audio buffer to the codec - it may not be filled.

+ * The next call to EAS_Render will continue processing until the buffer

+ * has been filled.

+ *

+ *----------------------------------------------------------------------------

+*/

+/*lint -esym(715, hwInstData) hwInstData available for customer use */

+EAS_BOOL EAS_HWYield (EAS_HW_DATA_HANDLE hwInstData)

+{

+	/* put your code here */

+	return EAS_FALSE;

+}