summaryrefslogtreecommitdiffstats
path: root/arm-wt-22k/jetcreator_lib_src/darwin-x86/EASLibVst.c
diff options
context:
space:
mode:
Diffstat (limited to 'arm-wt-22k/jetcreator_lib_src/darwin-x86/EASLibVst.c')
-rwxr-xr-xarm-wt-22k/jetcreator_lib_src/darwin-x86/EASLibVst.c1504
1 files changed, 1504 insertions, 0 deletions
diff --git a/arm-wt-22k/jetcreator_lib_src/darwin-x86/EASLibVst.c b/arm-wt-22k/jetcreator_lib_src/darwin-x86/EASLibVst.c
new file mode 100755
index 0000000..58c8770
--- /dev/null
+++ b/arm-wt-22k/jetcreator_lib_src/darwin-x86/EASLibVst.c
@@ -0,0 +1,1504 @@
+/*
+ * EASLib.c
+ * EASLIb
+ *
+ * Copyright (C) 2008 The Android Open Source Project
+ *
+ * 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.
+ *
+ *
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <string.h>
+
+#include "eas.h"
+#include "eas_report.h"
+#include "eas_host.h"
+
+#ifdef JET_INTERFACE
+#include "jet.h"
+#endif
+
+
+#define EAS_EXPORT __attribute__((visibility("default")))
+
+// #define DEBUG_FILE_IO
+
+/* include debug interface */
+#include "eas_host_debug.h"
+
+#ifdef AUX_MIXER
+#include "eas_auxmix.h"
+#endif
+
+/* this module requires dynamic memory support */
+#ifdef _STATIC_MEMORY
+#error "eas_hostmm.c requires the dynamic memory model!\n"
+#endif
+
+#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 it in memory. If your system uses
+ * in-memory resources, you can eliminate the calls
+ * to malloc and free, the dup flag, and simply track
+ * the file size and read position.
+ */
+ #ifdef BUFFERED_FILE_ACCESS
+typedef struct eas_hw_file_tag
+{
+ FILE *pFile;
+ EAS_I32 bytesInBuffer;
+ EAS_I32 readIndex;
+ EAS_I32 filePos;
+ EAS_I32 fileSize;
+ EAS_BOOL dup;
+ EAS_U8 buffer[EAS_FILE_BUFFER_SIZE];
+} EAS_HW_FILE;
+#else
+typedef struct eas_hw_file_tag
+{
+ EAS_I32 fileSize;
+ EAS_I32 filePos;
+ EAS_BOOL dup;
+ EAS_U8 *buffer;
+} EAS_HW_FILE;
+#endif
+
+typedef struct eas_hw_inst_data_tag
+{
+ EAS_HW_FILE files[EAS_MAX_FILE_HANDLES];
+} EAS_HW_INST_DATA;
+
+EAS_BOOL errorConditions[eNumErrorConditions];
+EAS_BOOL ledState;
+EAS_BOOL vibState;
+EAS_BOOL backlightState;
+
+#define MAX_DEBUG_MSG_LEN 1024
+
+typedef void (*EAS_LOG_FUNC)(EAS_INT severity, char *msg);
+
+static EAS_LOG_FUNC logCallback = NULL;
+static char messageBuffer[MAX_DEBUG_MSG_LEN];
+
+/* error counts */
+static EAS_INT eas_fatalErrors;
+static EAS_INT eas_errors;
+static EAS_INT eas_warnings;
+static int severityLevel = 9999;
+
+/* wave out device */
+#ifndef MAX_WAVE_OUT_BUFFERS
+#define MAX_WAVE_OUT_BUFFERS 8
+#endif
+
+#ifndef EAS_BUFFERS_PER_WAVE_BUFFER
+#define EAS_BUFFERS_PER_WAVE_BUFFER 8
+#endif
+
+/*----------------------------------------------------------------------------
+ * ResetErrorCounters()
+ *----------------------------------------------------------------------------
+*/
+EAS_EXPORT void ResetErrorCounters()
+{
+ eas_fatalErrors = 0;
+ eas_errors = 0;
+ eas_warnings = 0;
+}
+
+/*----------------------------------------------------------------------------
+ * SetLogCallback()
+ *----------------------------------------------------------------------------
+*/
+EAS_EXPORT void SetLogCallback (EAS_LOG_FUNC callback)
+{
+ logCallback = callback;
+}
+
+#ifndef _NO_DEBUG_PREPROCESSOR
+static S_DEBUG_MESSAGES debugMessages[] =
+{
+#ifdef UNIFIED_DEBUG_MESSAGES
+#include "eas_debugmsgs.h"
+#endif
+ { 0,0,0 }
+};
+
+/*----------------------------------------------------------------------------
+ * EAS_ReportEx()
+ *----------------------------------------------------------------------------
+*/
+void EAS_ReportEx (int severity, unsigned long hashCode, int serialNum, ...)
+{
+ va_list vargs;
+ int i;
+
+ switch (severity)
+ {
+ case _EAS_SEVERITY_FATAL:
+ eas_fatalErrors++;
+ break;
+
+ case _EAS_SEVERITY_ERROR:
+ eas_errors++;
+ break;
+
+ case _EAS_SEVERITY_WARNING:
+ eas_warnings++;
+ break;
+
+ default:
+ break;
+ }
+
+ /* check severity level */
+ if (severity > severityLevel)
+ return;
+
+ /* check for callback */
+ if (logCallback == NULL)
+ return;
+
+ /* find the error message and output to stdout */
+ for (i = 0; debugMessages[i].m_pDebugMsg; i++)
+ {
+ if ((debugMessages[i].m_nHashCode == hashCode) &&
+ (debugMessages[i].m_nSerialNum == serialNum))
+ {
+ va_start(vargs, serialNum);
+#ifdef WIN32
+ vsprintf_s(messageBuffer, sizeof(messageBuffer), fmt, vargs);
+#else
+ vsprintf(messageBuffer, debugMessages[i].m_pDebugMsg, vargs);
+#endif
+ logCallback(severity, messageBuffer);
+ va_end(vargs);
+ return;
+ }
+ }
+ printf("Unrecognized error: Severity=%d; HashCode=%lu; SerialNum=%d\n", severity, hashCode, serialNum);
+} /* end EAS_ReportEx */
+
+#else
+/*----------------------------------------------------------------------------
+ * EAS_Report()
+ *----------------------------------------------------------------------------
+*/
+void EAS_Report (int severity, const char *fmt, ...)
+{
+ va_list vargs;
+
+ switch (severity)
+ {
+ case _EAS_SEVERITY_FATAL:
+ eas_fatalErrors++;
+ break;
+
+ case _EAS_SEVERITY_ERROR:
+ eas_errors++;
+ break;
+
+ case _EAS_SEVERITY_WARNING:
+ eas_warnings++;
+ break;
+
+ default:
+ break;
+ }
+
+ /* check severity level */
+ if (severity > severityLevel)
+ return;
+
+ /* check for callback */
+ if (logCallback == NULL)
+ return;
+
+ va_start(vargs, fmt);
+#ifdef _WIN32
+ vsprintf_s(messageBuffer, sizeof(messageBuffer), fmt, vargs);
+#else
+ vsprintf(messageBuffer, fmt, vargs);
+#endif
+ logCallback(severity, messageBuffer);
+ va_end(vargs);
+} /* end EAS_Report */
+
+/*----------------------------------------------------------------------------
+ * EAS_ReportX()
+ *----------------------------------------------------------------------------
+*/
+void EAS_ReportX (int severity, const char *fmt, ...)
+{
+ va_list vargs;
+
+ switch (severity)
+ {
+ case _EAS_SEVERITY_FATAL:
+ eas_fatalErrors++;
+ break;
+
+ case _EAS_SEVERITY_ERROR:
+ eas_errors++;
+ break;
+
+ case _EAS_SEVERITY_WARNING:
+ eas_warnings++;
+ break;
+
+ default:
+ break;
+ }
+
+ /* check severity level */
+ if (severity > severityLevel)
+ return;
+
+ /* check for callback */
+ if (logCallback == NULL)
+ return;
+
+ va_start(vargs, fmt);
+#ifdef _WIN32
+ vsprintf_s(messageBuffer, sizeof(messageBuffer), fmt, vargs);
+#else
+ vsprintf(messageBuffer, fmt, vargs);
+#endif
+ logCallback(severity, messageBuffer);
+ va_end(vargs);
+}
+#endif
+
+/*----------------------------------------------------------------------------
+ * EAS_DLLSetDebugLevel()
+ *----------------------------------------------------------------------------
+*/
+EAS_EXPORT void EAS_DLLSetDebugLevel (int severity)
+{
+ severityLevel = severity;
+}
+
+/*----------------------------------------------------------------------------
+ * EAS_ExSetDebugLevel()
+ *----------------------------------------------------------------------------
+*/
+void EAS_SetDebugLevel (int severity)
+{
+ severityLevel = severity;
+}
+
+/*----------------------------------------------------------------------------
+ * EAS_SelectLibrary()
+ *----------------------------------------------------------------------------
+*/
+EAS_EXPORT EAS_RESULT EAS_SelectLib (EAS_DATA_HANDLE pEASData, EAS_HANDLE streamHandle, EAS_BOOL testLib)
+{
+ extern EAS_SNDLIB_HANDLE VMGetLibHandle(EAS_INT libNum);
+ return EAS_SetSoundLibrary(pEASData, streamHandle, VMGetLibHandle(testLib ? 1 : 0));
+}
+
+
+#if defined(_DEBUG) && !defined(MSC)
+#include <crtdbg.h>
+/*----------------------------------------------------------------------------
+ * EnableHeapDebug()
+ *----------------------------------------------------------------------------
+*/
+static void EnableHeapDebug (void)
+{
+ int temp;
+ temp = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG);
+ temp |= _CRTDBG_ALLOC_MEM_DF;
+ temp |= _CRTDBG_CHECK_ALWAYS_DF;
+ temp |= _CRTDBG_LEAK_CHECK_DF;
+// temp |= _CRTDBG_DELAY_FREE_MEM_DF;
+ _CrtSetDbgFlag(temp);
+}
+
+/*----------------------------------------------------------------------------
+ * HeapCheck()
+ *----------------------------------------------------------------------------
+ * Check heap status
+ *----------------------------------------------------------------------------
+*/
+void HeapCheck (void)
+{
+ int heapStatus;
+
+ /* Check heap status */
+ heapStatus = _heapchk();
+ if ((heapStatus == _HEAPOK) || (heapStatus == _HEAPEMPTY))
+ return;
+
+ EAS_ReportX(_EAS_SEVERITY_FATAL, "Heap corrupt\n" );
+}
+#endif
+
+
+/*----------------------------------------------------------------------------
+ * EAS_HWInit
+ *
+ * Initialize host wrapper interface
+ *
+ *----------------------------------------------------------------------------
+*/
+EAS_RESULT EAS_HWInit (EAS_HW_DATA_HANDLE *pHWInstData)
+{
+
+#if defined(_DEBUG) && !defined(MSC)
+ EnableHeapDebug();
+#endif
+
+ #ifdef BUFFERED_FILE_ACCESS
+ EAS_ReportX(_EAS_SEVERITY_INFO, "EAS_HWInit: Buffered file access\n");
+ #else
+ EAS_ReportX(_EAS_SEVERITY_INFO, "EAS_HWInit: Memory mapped file access\n");
+ #endif
+
+ /* simulate failure */
+ if (errorConditions[eInitError])
+ return EAS_FAILURE;
+
+ /* need to track file opens for duplicate handles */
+ *pHWInstData = malloc(sizeof(EAS_HW_INST_DATA));
+ if (!(*pHWInstData))
+ return EAS_ERROR_MALLOC_FAILED;
+
+ EAS_HWMemSet(*pHWInstData, 0, sizeof(EAS_HW_INST_DATA));
+ return EAS_SUCCESS;
+}
+
+/*----------------------------------------------------------------------------
+ * EAS_HWShutdown
+ *
+ * Shut down host wrapper interface
+ *
+ *----------------------------------------------------------------------------
+*/
+EAS_RESULT EAS_HWShutdown (EAS_HW_DATA_HANDLE hwInstData)
+{
+
+ /* simulate failure */
+ if (errorConditions[eShutdownError])
+ return EAS_FAILURE;
+
+ free(hwInstData);
+
+#if defined(_DEBUG) && !defined(MSC)
+ HeapCheck();
+#endif
+
+ return EAS_SUCCESS;
+}
+
+/*----------------------------------------------------------------------------
+ *
+ * EAS_HWMalloc
+ *
+ * Allocates dynamic memory
+ *
+ *----------------------------------------------------------------------------
+*/
+/*lint -esym(715, hwInstData) available for customer use */
+void *EAS_HWMalloc (EAS_HW_DATA_HANDLE hwInstData, EAS_I32 size)
+{
+ /* simulate failure */
+ if (errorConditions[eMallocError])
+ return NULL;
+
+ return malloc((size_t) size);
+}
+
+/*----------------------------------------------------------------------------
+ *
+ * EAS_HWFree
+ *
+ * Frees dynamic memory
+ *
+ *----------------------------------------------------------------------------
+*/
+/*lint -esym(715, hwInstData) available for customer use */
+void EAS_HWFree (EAS_HW_DATA_HANDLE hwInstData, void *p)
+{
+ free(p);
+}
+
+/*----------------------------------------------------------------------------
+ *
+ * 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);
+}
+
+#ifdef BUFFERED_FILE_ACCESS
+/*----------------------------------------------------------------------------
+ *
+ * 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)
+ {
+ EAS_RESULT result;
+
+ /* open the file */
+ file->pFile = fopen((const char*) locator, "rb");
+ if (file->pFile == NULL)
+ return EAS_ERROR_FILE_OPEN_FAILED;
+
+ /* get file length */
+ if ((result = EAS_HWFileLength(hwInstData, file, &file->fileSize)) != EAS_SUCCESS)
+ {
+ EAS_HWCloseFile(hwInstData, file);
+ return result;
+ }
+
+#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;
+ p += temp;
+ bytesLeft -= 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 */
+ 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;
+
+ /* check for seek past end */
+ if ((position < 0) || (position > file->fileSize))
+ return EAS_ERROR_FILE_SEEK;
+
+#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;
+
+ /* check for seek past end */
+ temp = file->filePos + position;
+ if ((temp < 0) || (temp > file->fileSize))
+ return EAS_ERROR_FILE_SEEK;
+
+ /* 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;
+ dupfile->fileSize = file->fileSize;
+
+ /* 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;
+}
+#else
+/*----------------------------------------------------------------------------
+ *
+ * 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;
+ FILE *ioFile;
+ int i, temp;
+
+ /* set return value to NULL */
+ *pFile = NULL;
+
+ /* simulate failure */
+ if (errorConditions[eOpenError])
+ return EAS_FAILURE;
+
+ /* 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->buffer == NULL)
+ {
+ /* open the file */
+ if ((ioFile = fopen(locator,"rb")) == NULL)
+ return EAS_ERROR_FILE_OPEN_FAILED;
+
+ /* determine the file size */
+ if (fseek(ioFile, 0L, SEEK_END) != 0)
+ return EAS_ERROR_FILE_LENGTH;
+ if ((file->fileSize = ftell(ioFile)) == -1L)
+ return EAS_ERROR_FILE_LENGTH;
+ if (fseek(ioFile, 0L, SEEK_SET) != 0)
+ return EAS_ERROR_FILE_LENGTH;
+
+ /* allocate a buffer */
+ file->buffer = EAS_HWMalloc(hwInstData, file->fileSize);
+ if (file->buffer == NULL)
+ {
+ fclose(ioFile);
+ return EAS_ERROR_MALLOC_FAILED;
+ }
+
+ /* read the file into memory */
+ temp = (int) fread(file->buffer, (size_t) file->fileSize, 1, ioFile);
+
+ /* close the file - don't need it any more */
+ fclose(ioFile);
+
+ /* check for error reading file */
+ if (temp != 1)
+ return EAS_ERROR_FILE_READ_FAILED;
+
+ /* initialize some values */
+ file->filePos = 0;
+ file->dup = EAS_FALSE;
+
+ *pFile = file;
+ return EAS_SUCCESS;
+ }
+ file++;
+ }
+
+ /* too many open files */
+ return EAS_ERROR_MAX_FILES_OPEN;
+}
+
+/*----------------------------------------------------------------------------
+ *
+ * EAS_HWReadFile
+ *
+ * Read data from a file
+ *
+ *----------------------------------------------------------------------------
+*/
+/*lint -esym(715, 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_I32 count;
+
+ /* simulate failure */
+ if (errorConditions[eReadError])
+ return EAS_FAILURE;
+
+ /* make sure we have a valid handle */
+ if (file->buffer == NULL)
+ return EAS_ERROR_INVALID_HANDLE;
+
+ /* calculate the bytes to read */
+ count = file->fileSize - file->filePos;
+ if (n < count)
+ count = n;
+
+ /* copy the data to the requested location, and advance the pointer */
+ if (count)
+ EAS_HWMemCpy(pBuffer, &file->buffer[file->filePos], count);
+ file->filePos += count;
+ *pBytesRead = count;
+
+ /* were n bytes read? */
+ if (count!= n)
+ return EAS_EOF;
+ return EAS_SUCCESS;
+}
+
+/*----------------------------------------------------------------------------
+ *
+ * EAS_HWGetByte
+ *
+ * Read a byte from a file
+ *
+ *----------------------------------------------------------------------------
+*/
+/*lint -e{715} hwInstData available for customer use */
+EAS_RESULT EAS_HWGetByte (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE file, void *p)
+{
+
+ /* simulate failure */
+ if (errorConditions[eReadError])
+ return EAS_FAILURE;
+
+ /* make sure we have a valid handle */
+ if (file->buffer == NULL)
+ return EAS_ERROR_INVALID_HANDLE;
+
+ /* check for end of file */
+ if (file->filePos >= file->fileSize)
+ {
+ *((EAS_U8*) p) = 0;
+ return EAS_EOF;
+ }
+
+ /* get a character from the buffer */
+ *((EAS_U8*) p) = file->buffer[file->filePos++];
+ return EAS_SUCCESS;
+}
+
+/*----------------------------------------------------------------------------
+ *
+ * EAS_HWGetWord
+ *
+ * Returns the current location in the file
+ *
+ *----------------------------------------------------------------------------
+*/
+/*lint -esym(715, hwInstData) available for customer use */
+EAS_RESULT EAS_HWGetWord (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE file, void *p, EAS_BOOL msbFirst)
+{
+ EAS_RESULT result;
+ EAS_U8 c1, c2;
+
+ /* read 2 bytes from the file */
+ if ((result = EAS_HWGetByte(hwInstData, file, &c1)) != EAS_SUCCESS)
+ return result;
+ if ((result = EAS_HWGetByte(hwInstData, file, &c2)) != EAS_SUCCESS)
+ return result;
+
+ /* order them as requested */
+ if (msbFirst)
+ *((EAS_U16*) p) = ((EAS_U16) c1 << 8) | c2;
+ else
+ *((EAS_U16*) p) = ((EAS_U16) c2 << 8) | c1;
+
+ return EAS_SUCCESS;
+}
+
+/*----------------------------------------------------------------------------
+ *
+ * EAS_HWGetDWord
+ *
+ * Returns the current location in the file
+ *
+ *----------------------------------------------------------------------------
+*/
+/*lint -esym(715, hwInstData) available for customer use */
+EAS_RESULT EAS_HWGetDWord (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE file, void *p, EAS_BOOL msbFirst)
+{
+ EAS_RESULT result;
+ EAS_U8 c1, c2,c3,c4;
+
+ /* read 4 bytes from the file */
+ if ((result = EAS_HWGetByte(hwInstData, file, &c1)) != EAS_SUCCESS)
+ return result;
+ if ((result = EAS_HWGetByte(hwInstData, file, &c2)) != EAS_SUCCESS)
+ return result;
+ if ((result = EAS_HWGetByte(hwInstData, file, &c3)) != EAS_SUCCESS)
+ return result;
+ if ((result = EAS_HWGetByte(hwInstData, file, &c4)) != EAS_SUCCESS)
+ return result;
+
+ /* order them as requested */
+ if (msbFirst)
+ *((EAS_U32*) p) = ((EAS_U32) c1 << 24) | ((EAS_U32) c2 << 16) | ((EAS_U32) c3 << 8) | c4;
+ else
+ *((EAS_U32*) p)= ((EAS_U32) c4 << 24) | ((EAS_U32) c3 << 16) | ((EAS_U32) c2 << 8) | c1;
+
+ return EAS_SUCCESS;
+}
+
+/*----------------------------------------------------------------------------
+ *
+ * EAS_HWFilePos
+ *
+ * Returns the current location in the file
+ *
+ *----------------------------------------------------------------------------
+*/
+/*lint -esym(715, hwInstData) available for customer use */
+EAS_RESULT EAS_HWFilePos (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE file, EAS_I32 *pPosition)
+{
+
+ /* simulate failure */
+ if (errorConditions[ePosError])
+ return EAS_FAILURE;
+
+ /* make sure we have a valid handle */
+ if (file->buffer == NULL)
+ return EAS_ERROR_INVALID_HANDLE;
+
+ *pPosition = file->filePos;
+ return EAS_SUCCESS;
+} /* end EAS_HWFilePos */
+
+/*----------------------------------------------------------------------------
+ *
+ * EAS_HWFileSeek
+ *
+ * Seek to a specific location in the file
+ *
+ *----------------------------------------------------------------------------
+*/
+/*lint -esym(715, hwInstData) available for customer use */
+EAS_RESULT EAS_HWFileSeek (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE file, EAS_I32 position)
+{
+
+ /* simulate failure */
+ if (errorConditions[eSeekError])
+ return EAS_FAILURE;
+
+ /* make sure we have a valid handle */
+ if (file->buffer == NULL)
+ return EAS_ERROR_INVALID_HANDLE;
+
+ /* validate new position */
+ if ((position < 0) || (position > file->fileSize))
+ return EAS_ERROR_FILE_SEEK;
+
+ /* save new position */
+ file->filePos = position;
+ return EAS_SUCCESS;
+}
+
+/*----------------------------------------------------------------------------
+ *
+ * EAS_HWFileSeekOfs
+ *
+ * Seek forward or back relative to the current position
+ *
+ *----------------------------------------------------------------------------
+*/
+/*lint -esym(715, hwInstData) available for customer use */
+EAS_RESULT EAS_HWFileSeekOfs (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE file, EAS_I32 position)
+{
+
+ /* simulate failure */
+ if (errorConditions[eSeekError])
+ return EAS_FAILURE;
+
+ /* make sure we have a valid handle */
+ if (file->buffer == NULL)
+ return EAS_ERROR_INVALID_HANDLE;
+
+ /* determine the file position */
+ position += file->filePos;
+ if ((position < 0) || (position > file->fileSize))
+ return EAS_ERROR_FILE_SEEK;
+
+ /* save new position */
+ file->filePos = position;
+ return EAS_SUCCESS;
+}
+
+/*----------------------------------------------------------------------------
+ *
+ * EAS_HWFileLength
+ *
+ * Return the file length
+ *
+ *----------------------------------------------------------------------------
+*/
+/*lint -esym(715, hwInstData) available for customer use */
+EAS_RESULT EAS_HWFileLength (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE file, EAS_I32 *pLength)
+{
+
+ /* simulate failure */
+ if (errorConditions[eLengthError])
+ return EAS_FAILURE;
+
+ /* make sure we have a valid handle */
+ if (file->buffer == NULL)
+ return EAS_ERROR_INVALID_HANDLE;
+
+ *pLength = file->fileSize;
+ 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;
+
+ /* simulate failure */
+ if (errorConditions[eDupError])
+ return EAS_FAILURE;
+
+ /* make sure we have a valid handle */
+ if (file->buffer == 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->buffer == NULL)
+ {
+
+ /* copy info from the handle to be duplicated */
+ dupFile->filePos = file->filePos;
+ dupFile->fileSize = file->fileSize;
+ dupFile->buffer = file->buffer;
+
+ /* set the duplicate handle flag */
+ dupFile->dup = file->dup = EAS_TRUE;
+
+ *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;
+
+ /* simulate failure */
+ if (errorConditions[eCloseError])
+ return EAS_FAILURE;
+
+ /* make sure we have a valid handle */
+ if (file1->buffer == 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->buffer == file1->buffer))
+ {
+ /* is there more than one duplicate? */
+ if (dupFile != NULL)
+ {
+ /* clear this entry and return */
+ file1->buffer = NULL;
+ return EAS_SUCCESS;
+ }
+
+ /* this is the first duplicate found */
+ else
+ 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->buffer = NULL;
+ return EAS_SUCCESS;
+ }
+
+ /* no duplicates -free the buffer */
+ EAS_HWFree(hwInstData, file1->buffer);
+
+ /* clear this entry and return */
+ file1->buffer = NULL;
+ return EAS_SUCCESS;
+}
+#endif
+
+/*----------------------------------------------------------------------------
+ *
+ * EAS_HWVibrate
+ *
+ * Turn on/off vibrate function
+ *
+ *----------------------------------------------------------------------------
+*/
+/*lint -esym(715, hwInstData) available for customer use */
+EAS_RESULT EAS_HWVibrate (EAS_HW_DATA_HANDLE hwInstData, EAS_BOOL state)
+{
+ vibState = state;
+// EAS_ReportX(_EAS_SEVERITY_NOFILTER, "Vibrate state: %d\n", state);
+ return EAS_SUCCESS;
+} /* end EAS_HWVibrate */
+
+/*----------------------------------------------------------------------------
+ *
+ * EAS_HWLED
+ *
+ * Turn on/off LED
+ *
+ *----------------------------------------------------------------------------
+*/
+/*lint -esym(715, hwInstData) available for customer use */
+EAS_RESULT EAS_HWLED (EAS_HW_DATA_HANDLE hwInstData, EAS_BOOL state)
+{
+ ledState = state;
+// EAS_ReportX(_EAS_SEVERITY_NOFILTER, "LED state: %d\n", state);
+ return EAS_SUCCESS;
+}
+
+/*----------------------------------------------------------------------------
+ *
+ * EAS_HWBackLight
+ *
+ * Turn on/off backlight
+ *
+ *----------------------------------------------------------------------------
+*/
+/*lint -esym(715, hwInstData) available for customer use */
+EAS_RESULT EAS_HWBackLight (EAS_HW_DATA_HANDLE hwInstData, EAS_BOOL state)
+{
+ backlightState = 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) available for customer use */
+EAS_BOOL EAS_HWYield (EAS_HW_DATA_HANDLE hwInstData)
+{
+ /* put your code here */
+ return EAS_FALSE;
+}
+
+