arm-wt-22k/host_src/eas_hostmm.c - platform/external/sonivox - Git at Google

 /*----------------------------------------------------------------------------
  *
  * File:
  * eas_hostmm.c
  *
  * Contents and purpose:
  * This file contains the host wrapper functions for stdio, stdlib, etc.
  * This is a sample version that reads from a filedescriptor.
  * The file locator (EAS_FILE_LOCATOR) handle passed to
  * HWOpenFile is the same one that is passed to EAS_OpenFile.
  *
  * 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.
  *
  * EAS_HW_FILE is a structure to support the file I/O functions. It
  * comprises the file descriptor, the file read pointer, and
  * the dup flag, which when set, indicates that the file handle has
  * been duplicated, and offset and length within the file.
  *
  * 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: 795 $
  *   $Date: 2007-08-01 00:14:45 -0700 (Wed, 01 Aug 2007) $
  *----------------------------------------------------------------------------
 */

 #ifdef _lint
 #include "lint_stdlib.h"
 #else
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
 #include <limits.h>
 #include <sys/mman.h>
 #include <errno.h>
 #include <signal.h>
 #define LOG_TAG "Sonivox"
 #include <utils/Log.h>
 #include <media/MediaPlayerInterface.h>
 #endif

 #include "eas_host.h"

 /* Only for debugging LED, vibrate, and backlight functions */
 #include "eas_report.h"

 /* 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
 // 100 max file handles == 3 * (nb tracks(32) + 1 for the segment) + 1 for jet file
 //                         3 == 1(playing segment) + 1(prepared segment)
 //                              + 1(after end of playing segment, before files closed)
 #define EAS_MAX_FILE_HANDLES    100
 #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.
  */
 typedef struct eas_hw_file_tag
 {
     EAS_I32 fileSize;
     EAS_I32 filePos;
     EAS_BOOL dup;
     int fd;
     EAS_I32 offset;
 } EAS_HW_FILE;

 typedef struct eas_hw_inst_data_tag
 {
     EAS_HW_FILE files[EAS_MAX_FILE_HANDLES];
 } EAS_HW_INST_DATA;

 pthread_key_t EAS_sigbuskey;

 /*----------------------------------------------------------------------------
  * EAS_HWInit
  *
  * Initialize host wrapper interface
  *
  *----------------------------------------------------------------------------
 */
 EAS_RESULT EAS_HWInit (EAS_HW_DATA_HANDLE *pHWInstData)
 {
     EAS_HW_FILE *file;
     int i;

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

     file = (*pHWInstData)->files;
     for (i = 0; i < EAS_MAX_FILE_HANDLES; i++)
     {
         file->fd = -1;
         file++;
     }


     return EAS_SUCCESS;
 }

 /*----------------------------------------------------------------------------
  * EAS_HWShutdown
  *
  * Shut down host wrapper interface
  *
  *----------------------------------------------------------------------------
 */
 EAS_RESULT EAS_HWShutdown (EAS_HW_DATA_HANDLE hwInstData)
 {

     free(hwInstData);
     return EAS_SUCCESS;
 }

 /*----------------------------------------------------------------------------
  *
  * EAS_HWMalloc
  *
  * Allocates dynamic memory
  *
  *----------------------------------------------------------------------------
 */
 /*lint -esym(715, hwInstData) hwInstData available for customer use */
 void *EAS_HWMalloc (EAS_HW_DATA_HANDLE hwInstData, EAS_I32 size)
 {
     /* Since this whole library loves signed sizes, let's not let
      * negative or 0 values through */
     if (size <= 0)
       return NULL;
     return malloc((size_t) size);
 }

 /*----------------------------------------------------------------------------
  *
  * EAS_HWFree
  *
  * Frees dynamic memory
  *
  *----------------------------------------------------------------------------
 */
 /*lint -esym(715, hwInstData) 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)
 {
     if (amount < 0)  {
       EAS_ReportEx(_EAS_SEVERITY_NOFILTER, 0x1a54b6e8, 0x00000004 , amount);
       exit(255);
     }
     return memcpy(dest, src, (size_t) amount);
 }

 /*----------------------------------------------------------------------------
  *
  * EAS_HWMemSet
  *
  * Set memory wrapper
  *
  *----------------------------------------------------------------------------
 */
 void *EAS_HWMemSet (void *dest, int val, EAS_I32 amount)
 {
     if (amount < 0)  {
       EAS_ReportEx(_EAS_SEVERITY_NOFILTER, 0x1a54b6e8, 0x00000005 , amount);
       exit(255);
     }
     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)
 {
     if (amount < 0) {
       EAS_ReportEx(_EAS_SEVERITY_NOFILTER, 0x1a54b6e8, 0x00000006 , amount);
       exit(255);
     }
     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 fd;
     int i, temp;

     /* 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->fd < 0)
         {
             if (locator->path) {
                 /* open the file */
                 if ((fd = open(locator->path, O_RDONLY)) < 0) {
                     return EAS_ERROR_FILE_OPEN_FAILED;
                 }
             } else {
                 /* else file is already open */
                 fd = dup(locator->fd);
             }

             /* determine the file size */
             if (locator->length == 0) {
                 if (lseek(fd, 0, SEEK_END) < 0) {
                     close(fd);
                     return EAS_ERROR_FILE_LENGTH;
                 }
                 if ((file->fileSize = lseek(fd, 0, SEEK_CUR)) == -1L) {
                     close(fd);
                     return EAS_ERROR_FILE_LENGTH;
                 }
             }

             // file size was passed in
             else {
                 file->fileSize = (EAS_I32) locator->length;
             }

             file->fd = fd;
             file->offset = locator->offset;

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

     /* make sure we have a valid handle */
     if (file->fd < 0)
         return EAS_ERROR_INVALID_HANDLE;

     if (n < 0)
       return EAS_EOF;

     /* calculate the bytes to read */
     count = file->fileSize - file->filePos;
     if (n < count)
         count = n;
     if (count < 0)
       return EAS_EOF;

     /* copy the data to the requested location, and advance the pointer */
     if (count) {
         lseek(file->fd, file->filePos + file->offset, SEEK_SET);
         count = read(file->fd, pBuffer, 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 -esym(715, hwInstData) hwInstData available for customer use */
 EAS_RESULT EAS_HWGetByte (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE file, void *p)
 {
     EAS_I32 numread;
     return EAS_HWReadFile(hwInstData, file, p, 1, &numread);
 }

 /*----------------------------------------------------------------------------
  *
  * EAS_HWGetWord
  *
  * Read a 16 bit word from a file
  *
  *----------------------------------------------------------------------------
 */
 /*lint -esym(715, hwInstData) 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) 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) hwInstData available for customer use */
 EAS_RESULT EAS_HWFilePos (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE file, EAS_I32 *pPosition)
 {

     /* make sure we have a valid handle */
     if (file->fd < 0)
         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) hwInstData available for customer use */
 EAS_RESULT EAS_HWFileSeek (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE file, EAS_I32 position)
 {

     /* make sure we have a valid handle */
     if (file->fd < 0)
         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) hwInstData available for customer use */
 EAS_RESULT EAS_HWFileSeekOfs (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE file, EAS_I32 position)
 {

     /* make sure we have a valid handle */
     if (file->fd < 0)
         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) hwInstData available for customer use */
 EAS_RESULT EAS_HWFileLength (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE file, EAS_I32 *pLength)
 {

     /* make sure we have a valid handle */
     if (file->fd < 0)
         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;

     /* make sure we have a valid handle */
     if (file->fd < 0)
         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->fd < 0)
         {
             /* copy info from the handle to be duplicated */
             dupFile->filePos = file->filePos;
             dupFile->fileSize = file->fileSize;
             dupFile->fd = file->fd;
             dupFile->offset = file->offset;

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


     /* make sure we have a valid handle */
     if (file1->fd < 0)
         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->fd == file1->fd))
             {
                 /* is there more than one duplicate? */
                 if (dupFile != NULL)
                 {
                     /* clear this entry and return */
                     file1->fd = -1;
                     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->fd = -1;
         return EAS_SUCCESS;
     }

     /* no duplicates - close the file */
     close(file1->fd);
     /* clear this entry and return */
     file1->fd = -1;
     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_ReportEx(_EAS_SEVERITY_NOFILTER, 0x1a54b6e8, 0x00000001 , state);
     return EAS_SUCCESS;
 } /* end EAS_HWVibrate */

 /*----------------------------------------------------------------------------
  *
  * 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_ReportEx(_EAS_SEVERITY_NOFILTER, 0x1a54b6e8, 0x00000002 , 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_ReportEx(_EAS_SEVERITY_NOFILTER, 0x1a54b6e8, 0x00000003 , 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;
 }
	/*----------------------------------------------------------------------------
	*
	* File:
	* eas_hostmm.c
	*
	* Contents and purpose:
	* This file contains the host wrapper functions for stdio, stdlib, etc.
	* This is a sample version that reads from a filedescriptor.
	* The file locator (EAS_FILE_LOCATOR) handle passed to
	* HWOpenFile is the same one that is passed to EAS_OpenFile.
	*
	* 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.
	*
	* EAS_HW_FILE is a structure to support the file I/O functions. It
	* comprises the file descriptor, the file read pointer, and
	* the dup flag, which when set, indicates that the file handle has
	* been duplicated, and offset and length within the file.
	*
	* 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: 795 $
	* $Date: 2007-08-01 00:14:45 -0700 (Wed, 01 Aug 2007) $
	*----------------------------------------------------------------------------
	*/

	#ifdef _lint
	#include "lint_stdlib.h"
	#else
	#include <stdio.h>
	#include <stdlib.h>
	#include <string.h>
	#include <unistd.h>
	#include <sys/types.h>
	#include <sys/stat.h>
	#include <fcntl.h>
	#include <limits.h>
	#include <sys/mman.h>
	#include <errno.h>
	#include <signal.h>
	#define LOG_TAG "Sonivox"
	#include <utils/Log.h>
	#include <media/MediaPlayerInterface.h>
	#endif

	#include "eas_host.h"

	/* Only for debugging LED, vibrate, and backlight functions */
	#include "eas_report.h"

	/* 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
	// 100 max file handles == 3 * (nb tracks(32) + 1 for the segment) + 1 for jet file
	// 3 == 1(playing segment) + 1(prepared segment)
	// + 1(after end of playing segment, before files closed)
	#define EAS_MAX_FILE_HANDLES 100
	#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.
	*/
	typedef struct eas_hw_file_tag
	{
	EAS_I32 fileSize;
	EAS_I32 filePos;
	EAS_BOOL dup;
	int fd;
	EAS_I32 offset;
	} EAS_HW_FILE;

	typedef struct eas_hw_inst_data_tag
	{
	EAS_HW_FILE files[EAS_MAX_FILE_HANDLES];
	} EAS_HW_INST_DATA;

	pthread_key_t EAS_sigbuskey;

	/*----------------------------------------------------------------------------
	* EAS_HWInit
	*
	* Initialize host wrapper interface
	*
	*----------------------------------------------------------------------------
	*/
	EAS_RESULT EAS_HWInit (EAS_HW_DATA_HANDLE *pHWInstData)
	{
	EAS_HW_FILE *file;
	int i;

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

	file = (*pHWInstData)->files;
	for (i = 0; i < EAS_MAX_FILE_HANDLES; i++)
	{
	file->fd = -1;
	file++;
	}


	return EAS_SUCCESS;
	}

	/*----------------------------------------------------------------------------
	* EAS_HWShutdown
	*
	* Shut down host wrapper interface
	*
	*----------------------------------------------------------------------------
	*/
	EAS_RESULT EAS_HWShutdown (EAS_HW_DATA_HANDLE hwInstData)
	{

	free(hwInstData);
	return EAS_SUCCESS;
	}

	/*----------------------------------------------------------------------------
	*
	* EAS_HWMalloc
	*
	* Allocates dynamic memory
	*
	*----------------------------------------------------------------------------
	*/
	/lint -esym(715, hwInstData) hwInstData available for customer use /
	void *EAS_HWMalloc (EAS_HW_DATA_HANDLE hwInstData, EAS_I32 size)
	{
	/* Since this whole library loves signed sizes, let's not let
	* negative or 0 values through */
	if (size <= 0)
	return NULL;
	return malloc((size_t) size);
	}

	/*----------------------------------------------------------------------------
	*
	* EAS_HWFree
	*
	* Frees dynamic memory
	*
	*----------------------------------------------------------------------------
	*/
	/lint -esym(715, hwInstData) 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)
	{
	if (amount < 0) {
	EAS_ReportEx(_EAS_SEVERITY_NOFILTER, 0x1a54b6e8, 0x00000004 , amount);
	exit(255);
	}
	return memcpy(dest, src, (size_t) amount);
	}

	/*----------------------------------------------------------------------------
	*
	* EAS_HWMemSet
	*
	* Set memory wrapper
	*
	*----------------------------------------------------------------------------
	*/
	void EAS_HWMemSet (void dest, int val, EAS_I32 amount)
	{
	if (amount < 0) {
	EAS_ReportEx(_EAS_SEVERITY_NOFILTER, 0x1a54b6e8, 0x00000005 , amount);
	exit(255);
	}
	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)
	{
	if (amount < 0) {
	EAS_ReportEx(_EAS_SEVERITY_NOFILTER, 0x1a54b6e8, 0x00000006 , amount);
	exit(255);
	}
	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 fd;
	int i, temp;

	/* 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->fd < 0)
	{
	if (locator->path) {
	/* open the file */
	if ((fd = open(locator->path, O_RDONLY)) < 0) {
	return EAS_ERROR_FILE_OPEN_FAILED;
	}
	} else {
	/* else file is already open */
	fd = dup(locator->fd);
	}

	/* determine the file size */
	if (locator->length == 0) {
	if (lseek(fd, 0, SEEK_END) < 0) {
	close(fd);
	return EAS_ERROR_FILE_LENGTH;
	}
	if ((file->fileSize = lseek(fd, 0, SEEK_CUR)) == -1L) {
	close(fd);
	return EAS_ERROR_FILE_LENGTH;
	}
	}

	// file size was passed in
	else {
	file->fileSize = (EAS_I32) locator->length;
	}

	file->fd = fd;
	file->offset = locator->offset;

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

	/* make sure we have a valid handle */
	if (file->fd < 0)
	return EAS_ERROR_INVALID_HANDLE;

	if (n < 0)
	return EAS_EOF;

	/* calculate the bytes to read */
	count = file->fileSize - file->filePos;
	if (n < count)
	count = n;
	if (count < 0)
	return EAS_EOF;

	/* copy the data to the requested location, and advance the pointer */
	if (count) {
	lseek(file->fd, file->filePos + file->offset, SEEK_SET);
	count = read(file->fd, pBuffer, 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 -esym(715, hwInstData) hwInstData available for customer use /
	EAS_RESULT EAS_HWGetByte (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE file, void *p)
	{
	EAS_I32 numread;
	return EAS_HWReadFile(hwInstData, file, p, 1, &numread);
	}

	/*----------------------------------------------------------------------------
	*
	* EAS_HWGetWord
	*
	* Read a 16 bit word from a file
	*
	*----------------------------------------------------------------------------
	*/
	/lint -esym(715, hwInstData) 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) 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) hwInstData available for customer use /
	EAS_RESULT EAS_HWFilePos (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE file, EAS_I32 *pPosition)
	{

	/* make sure we have a valid handle */
	if (file->fd < 0)
	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) hwInstData available for customer use /
	EAS_RESULT EAS_HWFileSeek (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE file, EAS_I32 position)
	{

	/* make sure we have a valid handle */
	if (file->fd < 0)
	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) hwInstData available for customer use /
	EAS_RESULT EAS_HWFileSeekOfs (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE file, EAS_I32 position)
	{

	/* make sure we have a valid handle */
	if (file->fd < 0)
	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) hwInstData available for customer use /
	EAS_RESULT EAS_HWFileLength (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE file, EAS_I32 *pLength)
	{

	/* make sure we have a valid handle */
	if (file->fd < 0)
	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;

	/* make sure we have a valid handle */
	if (file->fd < 0)
	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->fd < 0)
	{
	/* copy info from the handle to be duplicated */
	dupFile->filePos = file->filePos;
	dupFile->fileSize = file->fileSize;
	dupFile->fd = file->fd;
	dupFile->offset = file->offset;

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


	/* make sure we have a valid handle */
	if (file1->fd < 0)
	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->fd == file1->fd))
	{
	/* is there more than one duplicate? */
	if (dupFile != NULL)
	{
	/* clear this entry and return */
	file1->fd = -1;
	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->fd = -1;
	return EAS_SUCCESS;
	}

	/* no duplicates - close the file */
	close(file1->fd);
	/* clear this entry and return */
	file1->fd = -1;
	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_ReportEx(_EAS_SEVERITY_NOFILTER, 0x1a54b6e8, 0x00000001 , state);
	return EAS_SUCCESS;
	} /* end EAS_HWVibrate */

	/*----------------------------------------------------------------------------
	*
	* 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_ReportEx(_EAS_SEVERITY_NOFILTER, 0x1a54b6e8, 0x00000002 , 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_ReportEx(_EAS_SEVERITY_NOFILTER, 0x1a54b6e8, 0x00000003 , 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;
	}