/*---------------------------------------------------------------------------- * * 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 #include #include #include #include #include #include #include #include #include #include #define LOG_TAG "Sonivox" #include #include #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; }