rk3588-game
/
android13
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
android13/external/sonivox/arm-wt-22k/jetcreator_lib_src/darwin-x86/EASLibVst.c

1505 lines
41 KiB
C
Raw Blame History

/*
* 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;
}
Reference in New Issue View Git Blame Copy Permalink