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 69typedef 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 80typedef 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 89typedef struct eas_hw_inst_data_tag 90{ 91 EAS_HW_FILE files[EAS_MAX_FILE_HANDLES]; 92} EAS_HW_INST_DATA; 93 94EAS_BOOL errorConditions[eNumErrorConditions]; 95EAS_BOOL ledState; 96EAS_BOOL vibState; 97EAS_BOOL backlightState; 98 99#define MAX_DEBUG_MSG_LEN 1024 100 101typedef void (*EAS_LOG_FUNC)(EAS_INT severity, char *msg); 102 103static EAS_LOG_FUNC logCallback = NULL; 104static char messageBuffer[MAX_DEBUG_MSG_LEN]; 105 106/* error counts */ 107static EAS_INT eas_fatalErrors; 108static EAS_INT eas_errors; 109static EAS_INT eas_warnings; 110static 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*/ 125EAS_EXPORT void ResetErrorCounters() 126{ 127 eas_fatalErrors = 0; 128 eas_errors = 0; 129 eas_warnings = 0; 130} 131 132/*---------------------------------------------------------------------------- 133 * SetLogCallback() 134 *---------------------------------------------------------------------------- 135*/ 136EAS_EXPORT void SetLogCallback (EAS_LOG_FUNC callback) 137{ 138 logCallback = callback; 139} 140 141#ifndef _NO_DEBUG_PREPROCESSOR 142static 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*/ 154void 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*/ 210void 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*/ 254void 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*/ 299EAS_EXPORT void EAS_DLLSetDebugLevel (int severity) 300{ 301 severityLevel = severity; 302} 303 304/*---------------------------------------------------------------------------- 305 * EAS_ExSetDebugLevel() 306 *---------------------------------------------------------------------------- 307*/ 308void EAS_SetDebugLevel (int severity) 309{ 310 severityLevel = severity; 311} 312 313/*---------------------------------------------------------------------------- 314 * EAS_SelectLibrary() 315 *---------------------------------------------------------------------------- 316*/ 317EAS_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*/ 330static 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*/ 347void 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*/ 368EAS_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*/ 401EAS_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 */ 426void *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 */ 444void 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*/ 457void *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*/ 470void *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*/ 483EAS_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*/ 497EAS_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 */ 558EAS_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 */ 580EAS_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 */ 667EAS_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*/ 704EAS_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*/ 734EAS_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 */ 766EAS_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 */ 786EAS_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 */ 827EAS_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 */ 869EAS_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*/ 896EAS_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*/ 944EAS_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*/ 1006EAS_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 */ 1083EAS_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 */ 1121EAS_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 */ 1153EAS_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 */ 1182EAS_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 */ 1215EAS_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 */ 1239EAS_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 */ 1268EAS_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 */ 1298EAS_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*/ 1321EAS_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*/ 1368EAS_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 */ 1436EAS_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 */ 1452EAS_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 */ 1468EAS_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 */ 1498EAS_BOOL EAS_HWYield (EAS_HW_DATA_HANDLE hwInstData) 1499{ 1500 /* put your code here */ 1501 return EAS_FALSE; 1502} 1503 1504 1505