1 /*
2 * EASLib.c
3 * EASLIb
4 *
5 * Copyright (C) 2008 The Android Open Source Project
6 *
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
18 *
19 *
20 */
21
22 #include <stdlib.h>
23 #include <stdio.h>
24 #include <stdarg.h>
25 #include <string.h>
26
27 #include "eas.h"
28 #include "eas_report.h"
29 #include "eas_host.h"
30
31 #ifdef JET_INTERFACE
32 #include "jet.h"
33 #endif
34
35
36 #define EAS_EXPORT __attribute__((visibility("default")))
37
38 // #define DEBUG_FILE_IO
39
40 /* include debug interface */
41 #include "eas_host_debug.h"
42
43 #ifdef AUX_MIXER
44 #include "eas_auxmix.h"
45 #endif
46
47 /* this module requires dynamic memory support */
48 #ifdef _STATIC_MEMORY
49 #error "eas_hostmm.c requires the dynamic memory model!\n"
50 #endif
51
52 #ifndef EAS_MAX_FILE_HANDLES
53 #define EAS_MAX_FILE_HANDLES 32
54 #endif
55
56 #ifndef EAS_FILE_BUFFER_SIZE
57 #define EAS_FILE_BUFFER_SIZE 32
58 #endif
59
60 /*
61 * this structure and the related function are here
62 * to support the ability to create duplicate handles
63 * and buffering it in memory. If your system uses
64 * in-memory resources, you can eliminate the calls
65 * to malloc and free, the dup flag, and simply track
66 * the file size and read position.
67 */
68 #ifdef BUFFERED_FILE_ACCESS
69 typedef struct eas_hw_file_tag
70 {
71 FILE *pFile;
72 EAS_I32 bytesInBuffer;
73 EAS_I32 readIndex;
74 EAS_I32 filePos;
75 EAS_I32 fileSize;
76 EAS_BOOL dup;
77 EAS_U8 buffer[EAS_FILE_BUFFER_SIZE];
78 } EAS_HW_FILE;
79 #else
80 typedef struct eas_hw_file_tag
81 {
82 EAS_I32 fileSize;
83 EAS_I32 filePos;
84 EAS_BOOL dup;
85 EAS_U8 *buffer;
86 } EAS_HW_FILE;
87 #endif
88
89 typedef struct eas_hw_inst_data_tag
90 {
91 EAS_HW_FILE files[EAS_MAX_FILE_HANDLES];
92 } EAS_HW_INST_DATA;
93
94 EAS_BOOL errorConditions[eNumErrorConditions];
95 EAS_BOOL ledState;
96 EAS_BOOL vibState;
97 EAS_BOOL backlightState;
98
99 #define MAX_DEBUG_MSG_LEN 1024
100
101 typedef void (*EAS_LOG_FUNC)(EAS_INT severity, char *msg);
102
103 static EAS_LOG_FUNC logCallback = NULL;
104 static char messageBuffer[MAX_DEBUG_MSG_LEN];
105
106 /* error counts */
107 static EAS_INT eas_fatalErrors;
108 static EAS_INT eas_errors;
109 static EAS_INT eas_warnings;
110 static int severityLevel = 9999;
111
112 /* wave out device */
113 #ifndef MAX_WAVE_OUT_BUFFERS
114 #define MAX_WAVE_OUT_BUFFERS 8
115 #endif
116
117 #ifndef EAS_BUFFERS_PER_WAVE_BUFFER
118 #define EAS_BUFFERS_PER_WAVE_BUFFER 8
119 #endif
120
121 /*----------------------------------------------------------------------------
122 * ResetErrorCounters()
123 *----------------------------------------------------------------------------
124 */
ResetErrorCounters()125 EAS_EXPORT void ResetErrorCounters()
126 {
127 eas_fatalErrors = 0;
128 eas_errors = 0;
129 eas_warnings = 0;
130 }
131
132 /*----------------------------------------------------------------------------
133 * SetLogCallback()
134 *----------------------------------------------------------------------------
135 */
SetLogCallback(EAS_LOG_FUNC callback)136 EAS_EXPORT void SetLogCallback (EAS_LOG_FUNC callback)
137 {
138 logCallback = callback;
139 }
140
141 #ifndef _NO_DEBUG_PREPROCESSOR
142 static S_DEBUG_MESSAGES debugMessages[] =
143 {
144 #ifdef UNIFIED_DEBUG_MESSAGES
145 #include "eas_debugmsgs.h"
146 #endif
147 { 0,0,0 }
148 };
149
150 /*----------------------------------------------------------------------------
151 * EAS_ReportEx()
152 *----------------------------------------------------------------------------
153 */
EAS_ReportEx(int severity,unsigned long hashCode,int serialNum,...)154 void EAS_ReportEx (int severity, unsigned long hashCode, int serialNum, ...)
155 {
156 va_list vargs;
157 int i;
158
159 switch (severity)
160 {
161 case _EAS_SEVERITY_FATAL:
162 eas_fatalErrors++;
163 break;
164
165 case _EAS_SEVERITY_ERROR:
166 eas_errors++;
167 break;
168
169 case _EAS_SEVERITY_WARNING:
170 eas_warnings++;
171 break;
172
173 default:
174 break;
175 }
176
177 /* check severity level */
178 if (severity > severityLevel)
179 return;
180
181 /* check for callback */
182 if (logCallback == NULL)
183 return;
184
185 /* find the error message and output to stdout */
186 for (i = 0; debugMessages[i].m_pDebugMsg; i++)
187 {
188 if ((debugMessages[i].m_nHashCode == hashCode) &&
189 (debugMessages[i].m_nSerialNum == serialNum))
190 {
191 va_start(vargs, serialNum);
192 #ifdef WIN32
193 vsprintf_s(messageBuffer, sizeof(messageBuffer), fmt, vargs);
194 #else
195 vsprintf(messageBuffer, debugMessages[i].m_pDebugMsg, vargs);
196 #endif
197 logCallback(severity, messageBuffer);
198 va_end(vargs);
199 return;
200 }
201 }
202 printf("Unrecognized error: Severity=%d; HashCode=%lu; SerialNum=%d\n", severity, hashCode, serialNum);
203 } /* end EAS_ReportEx */
204
205 #else
206 /*----------------------------------------------------------------------------
207 * EAS_Report()
208 *----------------------------------------------------------------------------
209 */
EAS_Report(int severity,const char * fmt,...)210 void EAS_Report (int severity, const char *fmt, ...)
211 {
212 va_list vargs;
213
214 switch (severity)
215 {
216 case _EAS_SEVERITY_FATAL:
217 eas_fatalErrors++;
218 break;
219
220 case _EAS_SEVERITY_ERROR:
221 eas_errors++;
222 break;
223
224 case _EAS_SEVERITY_WARNING:
225 eas_warnings++;
226 break;
227
228 default:
229 break;
230 }
231
232 /* check severity level */
233 if (severity > severityLevel)
234 return;
235
236 /* check for callback */
237 if (logCallback == NULL)
238 return;
239
240 va_start(vargs, fmt);
241 #ifdef _WIN32
242 vsprintf_s(messageBuffer, sizeof(messageBuffer), fmt, vargs);
243 #else
244 vsprintf(messageBuffer, fmt, vargs);
245 #endif
246 logCallback(severity, messageBuffer);
247 va_end(vargs);
248 } /* end EAS_Report */
249
250 /*----------------------------------------------------------------------------
251 * EAS_ReportX()
252 *----------------------------------------------------------------------------
253 */
EAS_ReportX(int severity,const char * fmt,...)254 void EAS_ReportX (int severity, const char *fmt, ...)
255 {
256 va_list vargs;
257
258 switch (severity)
259 {
260 case _EAS_SEVERITY_FATAL:
261 eas_fatalErrors++;
262 break;
263
264 case _EAS_SEVERITY_ERROR:
265 eas_errors++;
266 break;
267
268 case _EAS_SEVERITY_WARNING:
269 eas_warnings++;
270 break;
271
272 default:
273 break;
274 }
275
276 /* check severity level */
277 if (severity > severityLevel)
278 return;
279
280 /* check for callback */
281 if (logCallback == NULL)
282 return;
283
284 va_start(vargs, fmt);
285 #ifdef _WIN32
286 vsprintf_s(messageBuffer, sizeof(messageBuffer), fmt, vargs);
287 #else
288 vsprintf(messageBuffer, fmt, vargs);
289 #endif
290 logCallback(severity, messageBuffer);
291 va_end(vargs);
292 }
293 #endif
294
295 /*----------------------------------------------------------------------------
296 * EAS_DLLSetDebugLevel()
297 *----------------------------------------------------------------------------
298 */
EAS_DLLSetDebugLevel(int severity)299 EAS_EXPORT void EAS_DLLSetDebugLevel (int severity)
300 {
301 severityLevel = severity;
302 }
303
304 /*----------------------------------------------------------------------------
305 * EAS_ExSetDebugLevel()
306 *----------------------------------------------------------------------------
307 */
EAS_SetDebugLevel(int severity)308 void EAS_SetDebugLevel (int severity)
309 {
310 severityLevel = severity;
311 }
312
313 /*----------------------------------------------------------------------------
314 * EAS_SelectLibrary()
315 *----------------------------------------------------------------------------
316 */
EAS_SelectLib(EAS_DATA_HANDLE pEASData,EAS_HANDLE streamHandle,EAS_BOOL testLib)317 EAS_EXPORT EAS_RESULT EAS_SelectLib (EAS_DATA_HANDLE pEASData, EAS_HANDLE streamHandle, EAS_BOOL testLib)
318 {
319 extern EAS_SNDLIB_HANDLE VMGetLibHandle(EAS_INT libNum);
320 return EAS_SetSoundLibrary(pEASData, streamHandle, VMGetLibHandle(testLib ? 1 : 0));
321 }
322
323
324 #if defined(_DEBUG) && !defined(MSC)
325 #include <crtdbg.h>
326 /*----------------------------------------------------------------------------
327 * EnableHeapDebug()
328 *----------------------------------------------------------------------------
329 */
EnableHeapDebug(void)330 static void EnableHeapDebug (void)
331 {
332 int temp;
333 temp = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG);
334 temp |= _CRTDBG_ALLOC_MEM_DF;
335 temp |= _CRTDBG_CHECK_ALWAYS_DF;
336 temp |= _CRTDBG_LEAK_CHECK_DF;
337 // temp |= _CRTDBG_DELAY_FREE_MEM_DF;
338 _CrtSetDbgFlag(temp);
339 }
340
341 /*----------------------------------------------------------------------------
342 * HeapCheck()
343 *----------------------------------------------------------------------------
344 * Check heap status
345 *----------------------------------------------------------------------------
346 */
HeapCheck(void)347 void HeapCheck (void)
348 {
349 int heapStatus;
350
351 /* Check heap status */
352 heapStatus = _heapchk();
353 if ((heapStatus == _HEAPOK) || (heapStatus == _HEAPEMPTY))
354 return;
355
356 EAS_ReportX(_EAS_SEVERITY_FATAL, "Heap corrupt\n" );
357 }
358 #endif
359
360
361 /*----------------------------------------------------------------------------
362 * EAS_HWInit
363 *
364 * Initialize host wrapper interface
365 *
366 *----------------------------------------------------------------------------
367 */
EAS_HWInit(EAS_HW_DATA_HANDLE * pHWInstData)368 EAS_RESULT EAS_HWInit (EAS_HW_DATA_HANDLE *pHWInstData)
369 {
370
371 #if defined(_DEBUG) && !defined(MSC)
372 EnableHeapDebug();
373 #endif
374
375 #ifdef BUFFERED_FILE_ACCESS
376 EAS_ReportX(_EAS_SEVERITY_INFO, "EAS_HWInit: Buffered file access\n");
377 #else
378 EAS_ReportX(_EAS_SEVERITY_INFO, "EAS_HWInit: Memory mapped file access\n");
379 #endif
380
381 /* simulate failure */
382 if (errorConditions[eInitError])
383 return EAS_FAILURE;
384
385 /* need to track file opens for duplicate handles */
386 *pHWInstData = malloc(sizeof(EAS_HW_INST_DATA));
387 if (!(*pHWInstData))
388 return EAS_ERROR_MALLOC_FAILED;
389
390 EAS_HWMemSet(*pHWInstData, 0, sizeof(EAS_HW_INST_DATA));
391 return EAS_SUCCESS;
392 }
393
394 /*----------------------------------------------------------------------------
395 * EAS_HWShutdown
396 *
397 * Shut down host wrapper interface
398 *
399 *----------------------------------------------------------------------------
400 */
EAS_HWShutdown(EAS_HW_DATA_HANDLE hwInstData)401 EAS_RESULT EAS_HWShutdown (EAS_HW_DATA_HANDLE hwInstData)
402 {
403
404 /* simulate failure */
405 if (errorConditions[eShutdownError])
406 return EAS_FAILURE;
407
408 free(hwInstData);
409
410 #if defined(_DEBUG) && !defined(MSC)
411 HeapCheck();
412 #endif
413
414 return EAS_SUCCESS;
415 }
416
417 /*----------------------------------------------------------------------------
418 *
419 * EAS_HWMalloc
420 *
421 * Allocates dynamic memory
422 *
423 *----------------------------------------------------------------------------
424 */
425 /*lint -esym(715, hwInstData) available for customer use */
EAS_HWMalloc(EAS_HW_DATA_HANDLE hwInstData,EAS_I32 size)426 void *EAS_HWMalloc (EAS_HW_DATA_HANDLE hwInstData, EAS_I32 size)
427 {
428 /* simulate failure */
429 if (errorConditions[eMallocError])
430 return NULL;
431
432 return malloc((size_t) size);
433 }
434
435 /*----------------------------------------------------------------------------
436 *
437 * EAS_HWFree
438 *
439 * Frees dynamic memory
440 *
441 *----------------------------------------------------------------------------
442 */
443 /*lint -esym(715, hwInstData) available for customer use */
EAS_HWFree(EAS_HW_DATA_HANDLE hwInstData,void * p)444 void EAS_HWFree (EAS_HW_DATA_HANDLE hwInstData, void *p)
445 {
446 free(p);
447 }
448
449 /*----------------------------------------------------------------------------
450 *
451 * EAS_HWMemCpy
452 *
453 * Copy memory wrapper
454 *
455 *----------------------------------------------------------------------------
456 */
EAS_HWMemCpy(void * dest,const void * src,EAS_I32 amount)457 void *EAS_HWMemCpy (void *dest, const void *src, EAS_I32 amount)
458 {
459 return memcpy(dest, src, (size_t) amount);
460 }
461
462 /*----------------------------------------------------------------------------
463 *
464 * EAS_HWMemSet
465 *
466 * Set memory wrapper
467 *
468 *----------------------------------------------------------------------------
469 */
EAS_HWMemSet(void * dest,int val,EAS_I32 amount)470 void *EAS_HWMemSet (void *dest, int val, EAS_I32 amount)
471 {
472 return memset(dest, val, (size_t) amount);
473 }
474
475 /*----------------------------------------------------------------------------
476 *
477 * EAS_HWMemCmp
478 *
479 * Compare memory wrapper
480 *
481 *----------------------------------------------------------------------------
482 */
EAS_HWMemCmp(const void * s1,const void * s2,EAS_I32 amount)483 EAS_I32 EAS_HWMemCmp (const void *s1, const void *s2, EAS_I32 amount)
484 {
485 return (EAS_I32) memcmp(s1, s2, (size_t) amount);
486 }
487
488 #ifdef BUFFERED_FILE_ACCESS
489 /*----------------------------------------------------------------------------
490 *
491 * EAS_HWOpenFile
492 *
493 * Open a file for read or write
494 *
495 *----------------------------------------------------------------------------
496 */
EAS_HWOpenFile(EAS_HW_DATA_HANDLE hwInstData,EAS_FILE_LOCATOR locator,EAS_FILE_HANDLE * pFile,EAS_FILE_MODE mode)497 EAS_RESULT EAS_HWOpenFile (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_LOCATOR locator, EAS_FILE_HANDLE *pFile, EAS_FILE_MODE mode)
498 {
499 EAS_HW_FILE *file;
500 int i;
501
502 /* set return value to NULL */
503 *pFile = NULL;
504
505 /* only support read mode at this time */
506 if (mode != EAS_FILE_READ)
507 return EAS_ERROR_INVALID_FILE_MODE;
508
509 /* find an empty entry in the file table */
510 file = hwInstData->files;
511 for (i = 0; i < EAS_MAX_FILE_HANDLES; i++)
512 {
513 /* is this slot being used? */
514 if (file->pFile == NULL)
515 {
516 EAS_RESULT result;
517
518 /* open the file */
519 file->pFile = fopen((const char*) locator, "rb");
520 if (file->pFile == NULL)
521 return EAS_ERROR_FILE_OPEN_FAILED;
522
523 /* get file length */
524 if ((result = EAS_HWFileLength(hwInstData, file, &file->fileSize)) != EAS_SUCCESS)
525 {
526 EAS_HWCloseFile(hwInstData, file);
527 return result;
528 }
529
530 #ifdef DEBUG_FILE_IO
531 EAS_ReportX(_EAS_SEVERITY_NOFILTER, "EAS_HWOpenFile: Open file %d\n", i);
532 #endif
533
534 /* initialize some values */
535 file->bytesInBuffer = 0;
536 file->readIndex = 0;
537 file->filePos = 0;
538 file->dup = EAS_FALSE;
539
540 *pFile = file;
541 return EAS_SUCCESS;
542 }
543 file++;
544 }
545
546 /* too many open files */
547 return EAS_ERROR_MAX_FILES_OPEN;
548 }
549
550 /*----------------------------------------------------------------------------
551 *
552 * EAS_HWFillBuffer
553 *
554 * Fill buffer from file
555 *----------------------------------------------------------------------------
556 */
557 /*lint -esym(715, hwInstData) hwInstData available for customer use */
EAS_HWFillBuffer(EAS_HW_DATA_HANDLE hwInstData,EAS_FILE_HANDLE file)558 EAS_RESULT EAS_HWFillBuffer (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE file)
559 {
560 /* reposition the file pointer */
561 if (fseek(file->pFile, file->filePos, SEEK_SET) != 0)
562 return EAS_ERROR_FILE_SEEK;
563
564 /* read some data from the file */
565 file->bytesInBuffer = (EAS_I32) fread(file->buffer, 1, EAS_FILE_BUFFER_SIZE, file->pFile);
566 file->readIndex = 0;
567 if (file->bytesInBuffer == 0)
568 return EAS_EOF;
569 return EAS_SUCCESS;
570 }
571
572 /*----------------------------------------------------------------------------
573 *
574 * EAS_HWReadFile
575 *
576 * Read data from a file
577 *----------------------------------------------------------------------------
578 */
579 /*lint -esym(715, hwInstData) hwInstData available for customer use */
EAS_HWReadFile(EAS_HW_DATA_HANDLE hwInstData,EAS_FILE_HANDLE file,void * pBuffer,EAS_I32 n,EAS_I32 * pBytesRead)580 EAS_RESULT EAS_HWReadFile (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE file, void *pBuffer, EAS_I32 n, EAS_I32 *pBytesRead)
581 {
582 EAS_RESULT result;
583 EAS_I32 temp;
584 EAS_U8 *p = pBuffer;
585 EAS_I32 bytesLeft = n;
586
587 *pBytesRead = 0;
588
589 /* check handle integrity */
590 if (file->pFile == NULL)
591 return EAS_ERROR_INVALID_HANDLE;
592
593 #ifdef DEBUG_FILE_IO
594 EAS_ReportX(_EAS_SEVERITY_NOFILTER, "EAS_HWReadFile: Reading %d bytes from position %d\n", n, file->filePos);
595 #endif
596
597 /* try to fulfill request from buffer */
598 for (;bytesLeft > 0;)
599 {
600 /* how many bytes can we get from buffer? */
601 temp = file->bytesInBuffer - file->readIndex;
602 if (temp > bytesLeft)
603 temp = bytesLeft;
604
605 /* copy data from buffer */
606 EAS_HWMemCpy(p, &file->buffer[file->readIndex], temp);
607 *pBytesRead += temp;
608 file->readIndex += temp;
609 file->filePos += temp;
610 p += temp;
611 bytesLeft -= temp;
612
613 /* don't refill buffer if request is bigger than buffer */
614 if ((bytesLeft == 0) || (bytesLeft >= EAS_FILE_BUFFER_SIZE))
615 break;
616
617 /* refill buffer */
618 if ((result = EAS_HWFillBuffer(hwInstData, file)) != EAS_SUCCESS)
619 return result;
620 }
621
622 /* more to read? do unbuffered read directly to target memory */
623 if (bytesLeft)
624 {
625
626 /* position the file pointer */
627 if (fseek(file->pFile, file->filePos, SEEK_SET) != 0)
628 return EAS_ERROR_FILE_SEEK;
629
630 /* read data in the buffer */
631 temp = (EAS_I32) fread(p, 1, (size_t) bytesLeft, file->pFile);
632 *pBytesRead += temp;
633 file->filePos += temp;
634
635 /* reset buffer info */
636 file->bytesInBuffer = 0;
637 file->readIndex = 0;
638 }
639
640 #ifdef DEBUG_FILE_IO
641 {
642 #define BYTES_PER_LINE 16
643 char str[BYTES_PER_LINE * 3 + 1];
644 EAS_INT i;
645 for (i = 0; i < (n > BYTES_PER_LINE ? BYTES_PER_LINE : n) ; i ++)
646 sprintf(&str[i*3], "%02x ", ((EAS_U8*)pBuffer)[i]);
647 if (i)
648 EAS_ReportX(_EAS_SEVERITY_NOFILTER, "%s\n", str);
649 }
650 #endif
651
652 /* were n bytes read? */
653 if (*pBytesRead != n)
654 return EAS_EOF;
655
656 return EAS_SUCCESS;
657 }
658
659 /*----------------------------------------------------------------------------
660 *
661 * EAS_HWGetByte
662 *
663 * Read a byte from a file
664 *----------------------------------------------------------------------------
665 */
666 /*lint -esym(715, hwInstData) hwInstData available for customer use */
EAS_HWGetByte(EAS_HW_DATA_HANDLE hwInstData,EAS_FILE_HANDLE file,void * p)667 EAS_RESULT EAS_HWGetByte (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE file, void *p)
668 {
669 EAS_RESULT result;
670
671 /* check handle integrity */
672 if (file->pFile == NULL)
673 return EAS_ERROR_INVALID_HANDLE;
674
675 /* use local buffer - do we have any data? */
676 if (file->readIndex >= file->bytesInBuffer)
677 {
678 if ((result = EAS_HWFillBuffer(hwInstData, file)) != EAS_SUCCESS)
679 return result;
680
681 /* if nothing to read, return EOF */
682 if (file->bytesInBuffer == 0)
683 return EAS_EOF;
684 }
685
686 /* get a character from the buffer */
687 *((EAS_U8*) p) = file->buffer[file->readIndex++];
688
689 #ifdef DEBUG_FILE_IO
690 EAS_ReportX(_EAS_SEVERITY_NOFILTER, "EAS_HWGetByte: Reading from position %d, byte = 0x%02x\n", file->filePos, *(EAS_U8*)p);
691 #endif
692
693 file->filePos++;
694 return EAS_SUCCESS;
695 }
696
697 /*----------------------------------------------------------------------------
698 *
699 * EAS_HWGetWord
700 *
701 * Read a 16-bit value from the file
702 *----------------------------------------------------------------------------
703 */
EAS_HWGetWord(EAS_HW_DATA_HANDLE hwInstData,EAS_FILE_HANDLE file,void * p,EAS_BOOL msbFirst)704 EAS_RESULT EAS_HWGetWord (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE file, void *p, EAS_BOOL msbFirst)
705 {
706 EAS_RESULT result;
707 EAS_I32 count;
708 EAS_U8 c[2];
709
710 #ifdef DEBUG_FILE_IO
711 EAS_ReportX(_EAS_SEVERITY_NOFILTER, "EAS_HWGetWord: Reading 2 bytes from position %d\n", file->filePos);
712 #endif
713
714 /* read 2 bytes from the file */
715 if ((result = EAS_HWReadFile(hwInstData, file, c, 2, &count)) != EAS_SUCCESS)
716 return result;
717
718 /* order them as requested */
719 if (msbFirst)
720 *((EAS_U16*) p) = ((EAS_U16) c[0] << 8) | c[1];
721 else
722 *((EAS_U16*) p) = ((EAS_U16) c[1] << 8) | c[0];
723
724 return EAS_SUCCESS;
725 }
726
727 /*----------------------------------------------------------------------------
728 *
729 * EAS_HWGetDWord
730 *
731 * Read a 16-bit value from the file
732 *----------------------------------------------------------------------------
733 */
EAS_HWGetDWord(EAS_HW_DATA_HANDLE hwInstData,EAS_FILE_HANDLE file,void * p,EAS_BOOL msbFirst)734 EAS_RESULT EAS_HWGetDWord (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE file, void *p, EAS_BOOL msbFirst)
735 {
736 EAS_RESULT result;
737 EAS_I32 count;
738 EAS_U8 c[4];
739
740 #ifdef DEBUG_FILE_IO
741 EAS_ReportX(_EAS_SEVERITY_NOFILTER, "EAS_HWGetDWord: Reading 4 bytes from position %d\n", file->filePos);
742 #endif
743
744 /* read 4 bytes from the file */
745 if ((result = EAS_HWReadFile(hwInstData, file, c, 4, &count)) != EAS_SUCCESS)
746 return result;
747
748 /* order them as requested */
749 if (msbFirst)
750 *((EAS_U32*) p) = ((EAS_U32) c[0] << 24) | ((EAS_U32) c[1] << 16) | ((EAS_U32) c[2] << 8) | c[3];
751 else
752 *((EAS_U32*) p) = ((EAS_U32) c[3] << 24) | ((EAS_U32) c[2] << 16) | ((EAS_U32) c[1] << 8) | c[0];
753
754 return EAS_SUCCESS;
755 }
756
757 /*----------------------------------------------------------------------------
758 *
759 * EAS_HWFilePos
760 *
761 * Returns the current location in the file
762 *
763 *----------------------------------------------------------------------------
764 */
765 /*lint -esym(715, hwInstData) hwInstData available for customer use */
EAS_HWFilePos(EAS_HW_DATA_HANDLE hwInstData,EAS_FILE_HANDLE file,EAS_I32 * pPosition)766 EAS_RESULT EAS_HWFilePos (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE file, EAS_I32 *pPosition)
767 {
768
769 /* check handle integrity */
770 if (file->pFile == NULL)
771 return EAS_ERROR_INVALID_HANDLE;
772
773 *pPosition = file->filePos;
774 return EAS_SUCCESS;
775 }
776
777 /*----------------------------------------------------------------------------
778 *
779 * EAS_HWFileSeek
780 *
781 * Seek to a specific location in the file
782 *
783 *----------------------------------------------------------------------------
784 */
785 /*lint -esym(715, hwInstData) hwInstData available for customer use */
EAS_HWFileSeek(EAS_HW_DATA_HANDLE hwInstData,EAS_FILE_HANDLE file,EAS_I32 position)786 EAS_RESULT EAS_HWFileSeek (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE file, EAS_I32 position)
787 {
788 EAS_I32 newIndex;
789
790 /* check handle integrity */
791 if (file->pFile == NULL)
792 return EAS_ERROR_INVALID_HANDLE;
793
794 /* check for seek past end */
795 if ((position < 0) || (position > file->fileSize))
796 return EAS_ERROR_FILE_SEEK;
797
798 #ifdef DEBUG_FILE_IO
799 EAS_ReportX(_EAS_SEVERITY_NOFILTER, "EAS_HWFileSeek: Seeking to new position %d\n", file->filePos);
800 #endif
801
802 /* is new position in current buffer? */
803 newIndex = position - file->filePos + file->readIndex;
804 if ((newIndex >= 0) && (newIndex < file->bytesInBuffer))
805 {
806 file->readIndex = newIndex;
807 file->filePos = position;
808 return EAS_SUCCESS;
809 }
810
811 /* save new position and reset buffer info so EAS_HWGetByte doesn't fail */
812 file->filePos = position;
813 file->bytesInBuffer = 0;
814 file->readIndex = 0;
815 return EAS_SUCCESS;
816 }
817
818 /*----------------------------------------------------------------------------
819 *
820 * EAS_HWFileSeekOfs
821 *
822 * Seek forward or back relative to the current position
823 *
824 *----------------------------------------------------------------------------
825 */
826 /*lint -esym(715, hwInstData) hwInstData available for customer use */
EAS_HWFileSeekOfs(EAS_HW_DATA_HANDLE hwInstData,EAS_FILE_HANDLE file,EAS_I32 position)827 EAS_RESULT EAS_HWFileSeekOfs (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE file, EAS_I32 position)
828 {
829 EAS_I32 temp;
830
831 #ifdef DEBUG_FILE_IO
832 EAS_ReportX(_EAS_SEVERITY_NOFILTER, "EAS_HWFileSeekOfs: Seeking to new position %d\n", file->filePos + position);
833 #endif
834
835 /* check handle integrity */
836 if (file->pFile == NULL)
837 return EAS_ERROR_INVALID_HANDLE;
838
839 /* check for seek past end */
840 temp = file->filePos + position;
841 if ((temp < 0) || (temp > file->fileSize))
842 return EAS_ERROR_FILE_SEEK;
843
844 /* is new position in current buffer? */
845 temp = position + file->readIndex;
846 if ((temp >= 0) && (temp < file->bytesInBuffer))
847 {
848 file->readIndex = temp;
849 file->filePos += position;
850 return EAS_SUCCESS;
851 }
852
853 /* save new position and reset buffer info so EAS_HWGetByte doesn't fail */
854 file->filePos += position;
855 file->bytesInBuffer = 0;
856 file->readIndex = 0;
857 return EAS_SUCCESS;
858 }
859
860 /*----------------------------------------------------------------------------
861 *
862 * EAS_HWFileLength
863 *
864 * Return the file length
865 *
866 *----------------------------------------------------------------------------
867 */
868 /*lint -esym(715, hwInstData) hwInstData available for customer use */
EAS_HWFileLength(EAS_HW_DATA_HANDLE hwInstData,EAS_FILE_HANDLE file,EAS_I32 * pLength)869 EAS_RESULT EAS_HWFileLength (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE file, EAS_I32 *pLength)
870 {
871 long pos;
872
873 /* check handle integrity */
874 if (file->pFile == NULL)
875 return EAS_ERROR_INVALID_HANDLE;
876
877 if ((pos = ftell(file->pFile)) == -1L)
878 return EAS_ERROR_FILE_LENGTH;
879 if (fseek(file->pFile, 0L, SEEK_END) != 0)
880 return EAS_ERROR_FILE_LENGTH;
881 if ((*pLength = ftell(file->pFile)) == -1L)
882 return EAS_ERROR_FILE_LENGTH;
883 if (fseek(file->pFile, pos, SEEK_SET) != 0)
884 return EAS_ERROR_FILE_LENGTH;
885 return EAS_SUCCESS;
886 }
887
888 /*----------------------------------------------------------------------------
889 *
890 * EAS_HWDupHandle
891 *
892 * Duplicate a file handle
893 *
894 *----------------------------------------------------------------------------
895 */
EAS_HWDupHandle(EAS_HW_DATA_HANDLE hwInstData,EAS_FILE_HANDLE file,EAS_FILE_HANDLE * pDupFile)896 EAS_RESULT EAS_HWDupHandle (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE file, EAS_FILE_HANDLE* pDupFile)
897 {
898 EAS_HW_FILE *dupfile;
899 int i;
900
901 /* check handle integrity */
902 *pDupFile = NULL;
903 if (file->pFile == NULL)
904 return EAS_ERROR_INVALID_HANDLE;
905
906 /* find an empty entry in the file table */
907 dupfile = hwInstData->files;
908 for (i = 0; i < EAS_MAX_FILE_HANDLES; i++)
909 {
910 /* is this slot being used? */
911 if (dupfile->pFile == NULL)
912 {
913
914 /* copy info from the handle to be duplicated */
915 dupfile->filePos = file->filePos;
916 dupfile->pFile = file->pFile;
917 dupfile->fileSize = file->fileSize;
918
919 /* set the duplicate handle flag */
920 dupfile->dup = file->dup = EAS_TRUE;
921
922 /* initialize some values */
923 dupfile->bytesInBuffer = 0;
924 dupfile->readIndex = 0;
925
926 *pDupFile = dupfile;
927 return EAS_SUCCESS;
928 }
929 dupfile++;
930 }
931
932 /* too many open files */
933 return EAS_ERROR_MAX_FILES_OPEN;
934 }
935
936 /*----------------------------------------------------------------------------
937 *
938 * EAS_HWClose
939 *
940 * Wrapper for fclose function
941 *
942 *----------------------------------------------------------------------------
943 */
EAS_HWCloseFile(EAS_HW_DATA_HANDLE hwInstData,EAS_FILE_HANDLE file1)944 EAS_RESULT EAS_HWCloseFile (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE file1)
945 {
946 EAS_HW_FILE *file2,*dupFile;
947 int i;
948
949 /* check handle integrity */
950 if (file1->pFile == NULL)
951 return EAS_ERROR_INVALID_HANDLE;
952
953 /* check for duplicate handle */
954 if (file1->dup)
955 {
956 dupFile = NULL;
957 file2 = hwInstData->files;
958 for (i = 0; i < EAS_MAX_FILE_HANDLES; i++)
959 {
960 /* check for duplicate */
961 if ((file1 != file2) && (file2->pFile == file1->pFile))
962 {
963 /* is there more than one duplicate? */
964 if (dupFile != NULL)
965 {
966 /* clear this entry and return */
967 file1->pFile = NULL;
968 return EAS_SUCCESS;
969 }
970
971 /* this is the first duplicate found */
972 dupFile = file2;
973 }
974 file2++;
975 }
976
977 /* there is only one duplicate, clear the dup flag */
978 if (dupFile)
979 dupFile->dup = EAS_FALSE;
980 else
981 /* if we get here, there's a serious problem */
982 return EAS_ERROR_HANDLE_INTEGRITY;
983
984 /* clear this entry and return */
985 file1->pFile = NULL;
986 return EAS_SUCCESS;
987 }
988
989 /* no duplicates - close the file */
990 if (fclose(file1->pFile) != 0)
991 return EAS_ERROR_CLOSE_FAILED;
992
993 /* clear this entry and return */
994 file1->pFile = NULL;
995 return EAS_SUCCESS;
996 }
997 #else
998 /*----------------------------------------------------------------------------
999 *
1000 * EAS_HWOpenFile
1001 *
1002 * Open a file for read or write
1003 *
1004 *----------------------------------------------------------------------------
1005 */
EAS_HWOpenFile(EAS_HW_DATA_HANDLE hwInstData,EAS_FILE_LOCATOR locator,EAS_FILE_HANDLE * pFile,EAS_FILE_MODE mode)1006 EAS_RESULT EAS_HWOpenFile (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_LOCATOR locator, EAS_FILE_HANDLE *pFile, EAS_FILE_MODE mode)
1007 {
1008 EAS_HW_FILE *file;
1009 FILE *ioFile;
1010 int i, temp;
1011
1012 /* set return value to NULL */
1013 *pFile = NULL;
1014
1015 /* simulate failure */
1016 if (errorConditions[eOpenError])
1017 return EAS_FAILURE;
1018
1019 /* only support read mode at this time */
1020 if (mode != EAS_FILE_READ)
1021 return EAS_ERROR_INVALID_FILE_MODE;
1022
1023 /* find an empty entry in the file table */
1024 file = hwInstData->files;
1025 for (i = 0; i < EAS_MAX_FILE_HANDLES; i++)
1026 {
1027 /* is this slot being used? */
1028 if (file->buffer == NULL)
1029 {
1030 /* open the file */
1031 if ((ioFile = fopen(locator,"rb")) == NULL)
1032 return EAS_ERROR_FILE_OPEN_FAILED;
1033
1034 /* determine the file size */
1035 if (fseek(ioFile, 0L, SEEK_END) != 0)
1036 return EAS_ERROR_FILE_LENGTH;
1037 if ((file->fileSize = ftell(ioFile)) == -1L)
1038 return EAS_ERROR_FILE_LENGTH;
1039 if (fseek(ioFile, 0L, SEEK_SET) != 0)
1040 return EAS_ERROR_FILE_LENGTH;
1041
1042 /* allocate a buffer */
1043 file->buffer = EAS_HWMalloc(hwInstData, file->fileSize);
1044 if (file->buffer == NULL)
1045 {
1046 fclose(ioFile);
1047 return EAS_ERROR_MALLOC_FAILED;
1048 }
1049
1050 /* read the file into memory */
1051 temp = (int) fread(file->buffer, (size_t) file->fileSize, 1, ioFile);
1052
1053 /* close the file - don't need it any more */
1054 fclose(ioFile);
1055
1056 /* check for error reading file */
1057 if (temp != 1)
1058 return EAS_ERROR_FILE_READ_FAILED;
1059
1060 /* initialize some values */
1061 file->filePos = 0;
1062 file->dup = EAS_FALSE;
1063
1064 *pFile = file;
1065 return EAS_SUCCESS;
1066 }
1067 file++;
1068 }
1069
1070 /* too many open files */
1071 return EAS_ERROR_MAX_FILES_OPEN;
1072 }
1073
1074 /*----------------------------------------------------------------------------
1075 *
1076 * EAS_HWReadFile
1077 *
1078 * Read data from a file
1079 *
1080 *----------------------------------------------------------------------------
1081 */
1082 /*lint -esym(715, hwInstData) available for customer use */
EAS_HWReadFile(EAS_HW_DATA_HANDLE hwInstData,EAS_FILE_HANDLE file,void * pBuffer,EAS_I32 n,EAS_I32 * pBytesRead)1083 EAS_RESULT EAS_HWReadFile (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE file, void *pBuffer, EAS_I32 n, EAS_I32 *pBytesRead)
1084 {
1085 EAS_I32 count;
1086
1087 /* simulate failure */
1088 if (errorConditions[eReadError])
1089 return EAS_FAILURE;
1090
1091 /* make sure we have a valid handle */
1092 if (file->buffer == NULL)
1093 return EAS_ERROR_INVALID_HANDLE;
1094
1095 /* calculate the bytes to read */
1096 count = file->fileSize - file->filePos;
1097 if (n < count)
1098 count = n;
1099
1100 /* copy the data to the requested location, and advance the pointer */
1101 if (count)
1102 EAS_HWMemCpy(pBuffer, &file->buffer[file->filePos], count);
1103 file->filePos += count;
1104 *pBytesRead = count;
1105
1106 /* were n bytes read? */
1107 if (count!= n)
1108 return EAS_EOF;
1109 return EAS_SUCCESS;
1110 }
1111
1112 /*----------------------------------------------------------------------------
1113 *
1114 * EAS_HWGetByte
1115 *
1116 * Read a byte from a file
1117 *
1118 *----------------------------------------------------------------------------
1119 */
1120 /*lint -e{715} hwInstData available for customer use */
EAS_HWGetByte(EAS_HW_DATA_HANDLE hwInstData,EAS_FILE_HANDLE file,void * p)1121 EAS_RESULT EAS_HWGetByte (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE file, void *p)
1122 {
1123
1124 /* simulate failure */
1125 if (errorConditions[eReadError])
1126 return EAS_FAILURE;
1127
1128 /* make sure we have a valid handle */
1129 if (file->buffer == NULL)
1130 return EAS_ERROR_INVALID_HANDLE;
1131
1132 /* check for end of file */
1133 if (file->filePos >= file->fileSize)
1134 {
1135 *((EAS_U8*) p) = 0;
1136 return EAS_EOF;
1137 }
1138
1139 /* get a character from the buffer */
1140 *((EAS_U8*) p) = file->buffer[file->filePos++];
1141 return EAS_SUCCESS;
1142 }
1143
1144 /*----------------------------------------------------------------------------
1145 *
1146 * EAS_HWGetWord
1147 *
1148 * Returns the current location in the file
1149 *
1150 *----------------------------------------------------------------------------
1151 */
1152 /*lint -esym(715, hwInstData) available for customer use */
EAS_HWGetWord(EAS_HW_DATA_HANDLE hwInstData,EAS_FILE_HANDLE file,void * p,EAS_BOOL msbFirst)1153 EAS_RESULT EAS_HWGetWord (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE file, void *p, EAS_BOOL msbFirst)
1154 {
1155 EAS_RESULT result;
1156 EAS_U8 c1, c2;
1157
1158 /* read 2 bytes from the file */
1159 if ((result = EAS_HWGetByte(hwInstData, file, &c1)) != EAS_SUCCESS)
1160 return result;
1161 if ((result = EAS_HWGetByte(hwInstData, file, &c2)) != EAS_SUCCESS)
1162 return result;
1163
1164 /* order them as requested */
1165 if (msbFirst)
1166 *((EAS_U16*) p) = ((EAS_U16) c1 << 8) | c2;
1167 else
1168 *((EAS_U16*) p) = ((EAS_U16) c2 << 8) | c1;
1169
1170 return EAS_SUCCESS;
1171 }
1172
1173 /*----------------------------------------------------------------------------
1174 *
1175 * EAS_HWGetDWord
1176 *
1177 * Returns the current location in the file
1178 *
1179 *----------------------------------------------------------------------------
1180 */
1181 /*lint -esym(715, hwInstData) available for customer use */
EAS_HWGetDWord(EAS_HW_DATA_HANDLE hwInstData,EAS_FILE_HANDLE file,void * p,EAS_BOOL msbFirst)1182 EAS_RESULT EAS_HWGetDWord (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE file, void *p, EAS_BOOL msbFirst)
1183 {
1184 EAS_RESULT result;
1185 EAS_U8 c1, c2,c3,c4;
1186
1187 /* read 4 bytes from the file */
1188 if ((result = EAS_HWGetByte(hwInstData, file, &c1)) != EAS_SUCCESS)
1189 return result;
1190 if ((result = EAS_HWGetByte(hwInstData, file, &c2)) != EAS_SUCCESS)
1191 return result;
1192 if ((result = EAS_HWGetByte(hwInstData, file, &c3)) != EAS_SUCCESS)
1193 return result;
1194 if ((result = EAS_HWGetByte(hwInstData, file, &c4)) != EAS_SUCCESS)
1195 return result;
1196
1197 /* order them as requested */
1198 if (msbFirst)
1199 *((EAS_U32*) p) = ((EAS_U32) c1 << 24) | ((EAS_U32) c2 << 16) | ((EAS_U32) c3 << 8) | c4;
1200 else
1201 *((EAS_U32*) p)= ((EAS_U32) c4 << 24) | ((EAS_U32) c3 << 16) | ((EAS_U32) c2 << 8) | c1;
1202
1203 return EAS_SUCCESS;
1204 }
1205
1206 /*----------------------------------------------------------------------------
1207 *
1208 * EAS_HWFilePos
1209 *
1210 * Returns the current location in the file
1211 *
1212 *----------------------------------------------------------------------------
1213 */
1214 /*lint -esym(715, hwInstData) available for customer use */
EAS_HWFilePos(EAS_HW_DATA_HANDLE hwInstData,EAS_FILE_HANDLE file,EAS_I32 * pPosition)1215 EAS_RESULT EAS_HWFilePos (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE file, EAS_I32 *pPosition)
1216 {
1217
1218 /* simulate failure */
1219 if (errorConditions[ePosError])
1220 return EAS_FAILURE;
1221
1222 /* make sure we have a valid handle */
1223 if (file->buffer == NULL)
1224 return EAS_ERROR_INVALID_HANDLE;
1225
1226 *pPosition = file->filePos;
1227 return EAS_SUCCESS;
1228 } /* end EAS_HWFilePos */
1229
1230 /*----------------------------------------------------------------------------
1231 *
1232 * EAS_HWFileSeek
1233 *
1234 * Seek to a specific location in the file
1235 *
1236 *----------------------------------------------------------------------------
1237 */
1238 /*lint -esym(715, hwInstData) available for customer use */
EAS_HWFileSeek(EAS_HW_DATA_HANDLE hwInstData,EAS_FILE_HANDLE file,EAS_I32 position)1239 EAS_RESULT EAS_HWFileSeek (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE file, EAS_I32 position)
1240 {
1241
1242 /* simulate failure */
1243 if (errorConditions[eSeekError])
1244 return EAS_FAILURE;
1245
1246 /* make sure we have a valid handle */
1247 if (file->buffer == NULL)
1248 return EAS_ERROR_INVALID_HANDLE;
1249
1250 /* validate new position */
1251 if ((position < 0) || (position > file->fileSize))
1252 return EAS_ERROR_FILE_SEEK;
1253
1254 /* save new position */
1255 file->filePos = position;
1256 return EAS_SUCCESS;
1257 }
1258
1259 /*----------------------------------------------------------------------------
1260 *
1261 * EAS_HWFileSeekOfs
1262 *
1263 * Seek forward or back relative to the current position
1264 *
1265 *----------------------------------------------------------------------------
1266 */
1267 /*lint -esym(715, hwInstData) available for customer use */
EAS_HWFileSeekOfs(EAS_HW_DATA_HANDLE hwInstData,EAS_FILE_HANDLE file,EAS_I32 position)1268 EAS_RESULT EAS_HWFileSeekOfs (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE file, EAS_I32 position)
1269 {
1270
1271 /* simulate failure */
1272 if (errorConditions[eSeekError])
1273 return EAS_FAILURE;
1274
1275 /* make sure we have a valid handle */
1276 if (file->buffer == NULL)
1277 return EAS_ERROR_INVALID_HANDLE;
1278
1279 /* determine the file position */
1280 position += file->filePos;
1281 if ((position < 0) || (position > file->fileSize))
1282 return EAS_ERROR_FILE_SEEK;
1283
1284 /* save new position */
1285 file->filePos = position;
1286 return EAS_SUCCESS;
1287 }
1288
1289 /*----------------------------------------------------------------------------
1290 *
1291 * EAS_HWFileLength
1292 *
1293 * Return the file length
1294 *
1295 *----------------------------------------------------------------------------
1296 */
1297 /*lint -esym(715, hwInstData) available for customer use */
EAS_HWFileLength(EAS_HW_DATA_HANDLE hwInstData,EAS_FILE_HANDLE file,EAS_I32 * pLength)1298 EAS_RESULT EAS_HWFileLength (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE file, EAS_I32 *pLength)
1299 {
1300
1301 /* simulate failure */
1302 if (errorConditions[eLengthError])
1303 return EAS_FAILURE;
1304
1305 /* make sure we have a valid handle */
1306 if (file->buffer == NULL)
1307 return EAS_ERROR_INVALID_HANDLE;
1308
1309 *pLength = file->fileSize;
1310 return EAS_SUCCESS;
1311 }
1312
1313 /*----------------------------------------------------------------------------
1314 *
1315 * EAS_HWDupHandle
1316 *
1317 * Duplicate a file handle
1318 *
1319 *----------------------------------------------------------------------------
1320 */
EAS_HWDupHandle(EAS_HW_DATA_HANDLE hwInstData,EAS_FILE_HANDLE file,EAS_FILE_HANDLE * pDupFile)1321 EAS_RESULT EAS_HWDupHandle (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE file, EAS_FILE_HANDLE *pDupFile)
1322 {
1323 EAS_HW_FILE *dupFile;
1324 int i;
1325
1326 /* simulate failure */
1327 if (errorConditions[eDupError])
1328 return EAS_FAILURE;
1329
1330 /* make sure we have a valid handle */
1331 if (file->buffer == NULL)
1332 return EAS_ERROR_INVALID_HANDLE;
1333
1334 /* find an empty entry in the file table */
1335 dupFile = hwInstData->files;
1336 for (i = 0; i < EAS_MAX_FILE_HANDLES; i++)
1337 {
1338 /* is this slot being used? */
1339 if (dupFile->buffer == NULL)
1340 {
1341
1342 /* copy info from the handle to be duplicated */
1343 dupFile->filePos = file->filePos;
1344 dupFile->fileSize = file->fileSize;
1345 dupFile->buffer = file->buffer;
1346
1347 /* set the duplicate handle flag */
1348 dupFile->dup = file->dup = EAS_TRUE;
1349
1350 *pDupFile = dupFile;
1351 return EAS_SUCCESS;
1352 }
1353 dupFile++;
1354 }
1355
1356 /* too many open files */
1357 return EAS_ERROR_MAX_FILES_OPEN;
1358 }
1359
1360 /*----------------------------------------------------------------------------
1361 *
1362 * EAS_HWClose
1363 *
1364 * Wrapper for fclose function
1365 *
1366 *----------------------------------------------------------------------------
1367 */
EAS_HWCloseFile(EAS_HW_DATA_HANDLE hwInstData,EAS_FILE_HANDLE file1)1368 EAS_RESULT EAS_HWCloseFile (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE file1)
1369 {
1370 EAS_HW_FILE *file2,*dupFile;
1371 int i;
1372
1373 /* simulate failure */
1374 if (errorConditions[eCloseError])
1375 return EAS_FAILURE;
1376
1377 /* make sure we have a valid handle */
1378 if (file1->buffer == NULL)
1379 return EAS_ERROR_INVALID_HANDLE;
1380
1381 /* check for duplicate handle */
1382 if (file1->dup)
1383 {
1384 dupFile = NULL;
1385 file2 = hwInstData->files;
1386 for (i = 0; i < EAS_MAX_FILE_HANDLES; i++)
1387 {
1388 /* check for duplicate */
1389 if ((file1 != file2) && (file2->buffer == file1->buffer))
1390 {
1391 /* is there more than one duplicate? */
1392 if (dupFile != NULL)
1393 {
1394 /* clear this entry and return */
1395 file1->buffer = NULL;
1396 return EAS_SUCCESS;
1397 }
1398
1399 /* this is the first duplicate found */
1400 else
1401 dupFile = file2;
1402 }
1403 file2++;
1404 }
1405
1406 /* there is only one duplicate, clear the dup flag */
1407 if (dupFile)
1408 dupFile->dup = EAS_FALSE;
1409 else
1410 /* if we get here, there's a serious problem */
1411 return EAS_ERROR_HANDLE_INTEGRITY;
1412
1413 /* clear this entry and return */
1414 file1->buffer = NULL;
1415 return EAS_SUCCESS;
1416 }
1417
1418 /* no duplicates -free the buffer */
1419 EAS_HWFree(hwInstData, file1->buffer);
1420
1421 /* clear this entry and return */
1422 file1->buffer = NULL;
1423 return EAS_SUCCESS;
1424 }
1425 #endif
1426
1427 /*----------------------------------------------------------------------------
1428 *
1429 * EAS_HWVibrate
1430 *
1431 * Turn on/off vibrate function
1432 *
1433 *----------------------------------------------------------------------------
1434 */
1435 /*lint -esym(715, hwInstData) available for customer use */
EAS_HWVibrate(EAS_HW_DATA_HANDLE hwInstData,EAS_BOOL state)1436 EAS_RESULT EAS_HWVibrate (EAS_HW_DATA_HANDLE hwInstData, EAS_BOOL state)
1437 {
1438 vibState = state;
1439 // EAS_ReportX(_EAS_SEVERITY_NOFILTER, "Vibrate state: %d\n", state);
1440 return EAS_SUCCESS;
1441 } /* end EAS_HWVibrate */
1442
1443 /*----------------------------------------------------------------------------
1444 *
1445 * EAS_HWLED
1446 *
1447 * Turn on/off LED
1448 *
1449 *----------------------------------------------------------------------------
1450 */
1451 /*lint -esym(715, hwInstData) available for customer use */
EAS_HWLED(EAS_HW_DATA_HANDLE hwInstData,EAS_BOOL state)1452 EAS_RESULT EAS_HWLED (EAS_HW_DATA_HANDLE hwInstData, EAS_BOOL state)
1453 {
1454 ledState = state;
1455 // EAS_ReportX(_EAS_SEVERITY_NOFILTER, "LED state: %d\n", state);
1456 return EAS_SUCCESS;
1457 }
1458
1459 /*----------------------------------------------------------------------------
1460 *
1461 * EAS_HWBackLight
1462 *
1463 * Turn on/off backlight
1464 *
1465 *----------------------------------------------------------------------------
1466 */
1467 /*lint -esym(715, hwInstData) available for customer use */
EAS_HWBackLight(EAS_HW_DATA_HANDLE hwInstData,EAS_BOOL state)1468 EAS_RESULT EAS_HWBackLight (EAS_HW_DATA_HANDLE hwInstData, EAS_BOOL state)
1469 {
1470 backlightState = state;
1471 // EAS_ReportX(_EAS_SEVERITY_NOFILTER, "Backlight state: %d\n", state);
1472 return EAS_SUCCESS;
1473 }
1474
1475 /*----------------------------------------------------------------------------
1476 *
1477 * EAS_HWYield
1478 *
1479 * This function is called periodically by the EAS library to give the
1480 * host an opportunity to allow other tasks to run. There are two ways to
1481 * use this call:
1482 *
1483 * If you have a multi-tasking OS, you can call the yield function in the
1484 * OS to allow other tasks to run. In this case, return EAS_FALSE to tell
1485 * the EAS library to continue processing when control returns from this
1486 * function.
1487 *
1488 * If tasks run in a single thread by sequential function calls (sometimes
1489 * call a "commutator loop"), return EAS_TRUE to cause the EAS Library to
1490 * return to the caller. Be sure to check the number of bytes rendered
1491 * before passing the audio buffer to the codec - it may not be filled.
1492 * The next call to EAS_Render will continue processing until the buffer
1493 * has been filled.
1494 *
1495 *----------------------------------------------------------------------------
1496 */
1497 /*lint -esym(715, hwInstData) available for customer use */
EAS_HWYield(EAS_HW_DATA_HANDLE hwInstData)1498 EAS_BOOL EAS_HWYield (EAS_HW_DATA_HANDLE hwInstData)
1499 {
1500 /* put your code here */
1501 return EAS_FALSE;
1502 }
1503
1504
1505