auto import from //depot/cupcake/@135843

2 files changed, 0 insertions, 787 deletions

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

- *

- * 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;

-}