diff options
author | The Android Open Source Project <initial-contribution@android.com> | 2009-03-03 18:28:36 -0800 |
---|---|---|
committer | The Android Open Source Project <initial-contribution@android.com> | 2009-03-03 18:28:36 -0800 |
commit | 1b52a76815aa068a3477bfdfaf58718d41d7f9b4 (patch) | |
tree | 4b825dc642cb6eb9a060e54bf8d69288fbee4904 /arm-wt-22k/lib_src/eas_public.c | |
parent | 251d5a6afb8ebdccc8df9d438acc2761001d8bec (diff) | |
download | android_external_sonivox-1b52a76815aa068a3477bfdfaf58718d41d7f9b4.tar.gz android_external_sonivox-1b52a76815aa068a3477bfdfaf58718d41d7f9b4.tar.bz2 android_external_sonivox-1b52a76815aa068a3477bfdfaf58718d41d7f9b4.zip |
auto import from //depot/cupcake/@135843
Diffstat (limited to 'arm-wt-22k/lib_src/eas_public.c')
-rw-r--r-- | arm-wt-22k/lib_src/eas_public.c | 2601 |
1 files changed, 0 insertions, 2601 deletions
diff --git a/arm-wt-22k/lib_src/eas_public.c b/arm-wt-22k/lib_src/eas_public.c deleted file mode 100644 index d67ef7e..0000000 --- a/arm-wt-22k/lib_src/eas_public.c +++ /dev/null @@ -1,2601 +0,0 @@ -/*---------------------------------------------------------------------------- - * - * File: - * eas_public.c - * - * Contents and purpose: - * Contains EAS library public interface - * - * Copyright Sonic Network Inc. 2004 - - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * - *---------------------------------------------------------------------------- - * Revision Control: - * $Revision: 842 $ - * $Date: 2007-08-23 14:32:31 -0700 (Thu, 23 Aug 2007) $ - *---------------------------------------------------------------------------- -*/ - -#include "eas_synthcfg.h" -#include "eas.h" -#include "eas_config.h" -#include "eas_host.h" -#include "eas_report.h" -#include "eas_data.h" -#include "eas_parser.h" -#include "eas_pcm.h" -#include "eas_midi.h" -#include "eas_mixer.h" -#include "eas_build.h" -#include "eas_vm_protos.h" -#include "eas_math.h" - -#ifdef JET_INTERFACE -#include "jet_data.h" -#endif - -#ifdef DLS_SYNTHESIZER -#include "eas_mdls.h" -#endif - -/* number of events to parse before calling EAS_HWYield function */ -#define YIELD_EVENT_COUNT 10 - -/*---------------------------------------------------------------------------- - * easLibConfig - * - * This structure is available through the EAS public interface to allow - * the user to check the configuration of the library. - *---------------------------------------------------------------------------- -*/ -static const S_EAS_LIB_CONFIG easLibConfig = -{ - LIB_VERSION, -#ifdef _CHECKED_BUILD - EAS_TRUE, -#else - EAS_FALSE, -#endif - MAX_SYNTH_VOICES, - NUM_OUTPUT_CHANNELS, - _OUTPUT_SAMPLE_RATE, - BUFFER_SIZE_IN_MONO_SAMPLES, -#ifdef _FILTER_ENABLED - EAS_TRUE, -#else - EAS_FALSE, -#endif - _BUILD_TIME_, - _BUILD_VERSION_ -}; - -/* local prototypes */ -static EAS_RESULT EAS_ParseEvents (S_EAS_DATA *pEASData, S_EAS_STREAM *pStream, EAS_U32 endTime, EAS_INT parseMode); - -/*---------------------------------------------------------------------------- - * EAS_SetStreamParameter - *---------------------------------------------------------------------------- - * Sets the specified parameter in the stream. Allows access to - * customizable settings within the individual file parsers. - *---------------------------------------------------------------------------- - * pEASData - pointer to EAS persistent data object - * pStream - stream handle - * param - enumerated parameter (see eas_parser.h) - * value - new value - *---------------------------------------------------------------------------- -*/ -EAS_RESULT EAS_SetStreamParameter (S_EAS_DATA *pEASData, EAS_HANDLE pStream, EAS_I32 param, EAS_I32 value) -{ - S_FILE_PARSER_INTERFACE *pParserModule; - - pParserModule = (S_FILE_PARSER_INTERFACE*) pStream->pParserModule; - if (pParserModule->pfSetData) - return (*pParserModule->pfSetData)(pEASData, pStream->handle, param, value); - return EAS_ERROR_FEATURE_NOT_AVAILABLE; -} - -/*---------------------------------------------------------------------------- - * EAS_GetStreamParameter - *---------------------------------------------------------------------------- - * Sets the specified parameter in the stream. Allows access to - * customizable settings within the individual file parsers. - *---------------------------------------------------------------------------- - * pEASData - pointer to EAS persistent data object - * pStream - stream handle - * param - enumerated parameter (see eas_parser.h) - * pValue - pointer to variable to receive current setting - *---------------------------------------------------------------------------- -*/ -EAS_RESULT EAS_GetStreamParameter (S_EAS_DATA *pEASData, EAS_HANDLE pStream, EAS_I32 param, EAS_I32 *pValue) -{ - S_FILE_PARSER_INTERFACE *pParserModule; - - pParserModule = (S_FILE_PARSER_INTERFACE*) pStream->pParserModule; - if (pParserModule->pfGetData) - return (*pParserModule->pfGetData)(pEASData, pStream->handle, param, pValue); - return EAS_ERROR_FEATURE_NOT_AVAILABLE; -} - -/*---------------------------------------------------------------------------- - * EAS_StreamReady() - *---------------------------------------------------------------------------- - * This routine sets common parameters like transpose, volume, etc. - * First, it attempts to use the parser EAS_SetStreamParameter interface. If that - * fails, it attempts to get the synth handle from the parser and - * set the parameter directly on the synth. This eliminates duplicate - * code in the parser. - *---------------------------------------------------------------------------- -*/ -EAS_BOOL EAS_StreamReady (S_EAS_DATA *pEASData, EAS_HANDLE pStream) -{ - S_FILE_PARSER_INTERFACE *pParserModule; - EAS_STATE state; - - pParserModule = (S_FILE_PARSER_INTERFACE*) pStream->pParserModule; - if (pParserModule->pfState(pEASData, pStream->handle, &state) != EAS_SUCCESS) - return EAS_FALSE; - return (state < EAS_STATE_OPEN); -} - -/*---------------------------------------------------------------------------- - * EAS_IntSetStrmParam() - *---------------------------------------------------------------------------- - * This routine sets common parameters like transpose, volume, etc. - * First, it attempts to use the parser EAS_SetStreamParameter interface. If that - * fails, it attempts to get the synth handle from the parser and - * set the parameter directly on the synth. This eliminates duplicate - * code in the parser. - *---------------------------------------------------------------------------- -*/ -EAS_RESULT EAS_IntSetStrmParam (S_EAS_DATA *pEASData, EAS_HANDLE pStream, EAS_INT param, EAS_I32 value) -{ - S_SYNTH *pSynth; - - /* try to set the parameter using stream interface */ - if (EAS_SetStreamParameter(pEASData, pStream, param, value) == EAS_SUCCESS) - return EAS_SUCCESS; - - /* get a pointer to the synth object and set it directly */ - /*lint -e{740} we are cheating by passing a pointer through this interface */ - if (EAS_GetStreamParameter(pEASData, pStream, PARSER_DATA_SYNTH_HANDLE, (EAS_I32*) &pSynth) != EAS_SUCCESS) - return EAS_ERROR_INVALID_PARAMETER; - - if (pSynth == NULL) - return EAS_ERROR_INVALID_PARAMETER; - - switch (param) - { - -#ifdef DLS_SYNTHESIZER - case PARSER_DATA_DLS_COLLECTION: - { - EAS_RESULT result = VMSetDLSLib(pSynth, (EAS_DLSLIB_HANDLE) value); - if (result == EAS_SUCCESS) - { - DLSAddRef((S_DLS*) value); - VMInitializeAllChannels(pEASData->pVoiceMgr, pSynth); - } - return result; - } -#endif - - case PARSER_DATA_EAS_LIBRARY: - return VMSetEASLib(pSynth, (EAS_SNDLIB_HANDLE) value); - - case PARSER_DATA_POLYPHONY: - return VMSetPolyphony(pEASData->pVoiceMgr, pSynth, value); - - case PARSER_DATA_PRIORITY: - return VMSetPriority(pEASData->pVoiceMgr, pSynth, value); - - case PARSER_DATA_TRANSPOSITION: - VMSetTranposition(pSynth, value); - break; - - case PARSER_DATA_VOLUME: - VMSetVolume(pSynth, (EAS_U16) value); - break; - - default: - { /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "Invalid paramter %d in call to EAS_IntSetStrmParam", param); */ } - return EAS_ERROR_INVALID_PARAMETER; - } - - return EAS_SUCCESS; -} - -/*---------------------------------------------------------------------------- - * EAS_IntGetStrmParam() - *---------------------------------------------------------------------------- - * This routine gets common parameters like transpose, volume, etc. - * First, it attempts to use the parser EAS_GetStreamParameter interface. If that - * fails, it attempts to get the synth handle from the parser and - * get the parameter directly on the synth. - *---------------------------------------------------------------------------- -*/ -EAS_RESULT EAS_IntGetStrmParam (S_EAS_DATA *pEASData, EAS_HANDLE pStream, EAS_INT param, EAS_I32 *pValue) -{ - S_SYNTH *pSynth; - - /* try to set the parameter */ - if (EAS_GetStreamParameter(pEASData, pStream, param, pValue) == EAS_SUCCESS) - return EAS_SUCCESS; - - /* get a pointer to the synth object and retrieve data directly */ - /*lint -e{740} we are cheating by passing a pointer through this interface */ - if (EAS_GetStreamParameter(pEASData, pStream, PARSER_DATA_SYNTH_HANDLE, (EAS_I32*) &pSynth) != EAS_SUCCESS) - return EAS_ERROR_INVALID_PARAMETER; - - if (pSynth == NULL) - return EAS_ERROR_INVALID_PARAMETER; - - switch (param) - { - case PARSER_DATA_POLYPHONY: - return VMGetPolyphony(pEASData->pVoiceMgr, pSynth, pValue); - - case PARSER_DATA_PRIORITY: - return VMGetPriority(pEASData->pVoiceMgr, pSynth, pValue); - - case PARSER_DATA_TRANSPOSITION: - VMGetTranposition(pSynth, pValue); - break; - - case PARSER_DATA_NOTE_COUNT: - *pValue = VMGetNoteCount(pSynth); - break; - - default: - { /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "Invalid paramter %d in call to EAS_IntSetStrmParam", param); */ } - return EAS_ERROR_INVALID_PARAMETER; - } - - return EAS_SUCCESS; -} - -/*---------------------------------------------------------------------------- - * EAS_AllocateStream() - *---------------------------------------------------------------------------- - * Purpose: - * Allocates a stream handle - * - * Inputs: - * - * Outputs: - * - *---------------------------------------------------------------------------- -*/ -static EAS_INT EAS_AllocateStream (EAS_DATA_HANDLE pEASData) -{ - EAS_INT streamNum; - - /* check for static allocation, only one stream allowed */ - if (pEASData->staticMemoryModel) - { - if (pEASData->streams[0].handle != NULL) - { - { /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "Attempt to open multiple streams in static model\n"); */ } - return -1; - } - return 0; - } - - /* dynamic model */ - for (streamNum = 0; streamNum < MAX_NUMBER_STREAMS; streamNum++) - if (pEASData->streams[streamNum].handle == NULL) - break; - if (streamNum == MAX_NUMBER_STREAMS) - { - { /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "Exceeded maximum number of open streams\n"); */ } - return -1; - } - return streamNum; -} - -/*---------------------------------------------------------------------------- - * EAS_InitStream() - *---------------------------------------------------------------------------- - * Purpose: - * Initialize a stream - * - * Inputs: - * - * Outputs: - * - *---------------------------------------------------------------------------- -*/ -static void EAS_InitStream (S_EAS_STREAM *pStream, EAS_VOID_PTR pParserModule, EAS_VOID_PTR streamHandle) -{ - pStream->pParserModule = pParserModule; - pStream->handle = streamHandle; - pStream->time = 0; - pStream->frameLength = AUDIO_FRAME_LENGTH; - pStream->repeatCount = 0; - pStream->volume = DEFAULT_STREAM_VOLUME; - pStream->streamFlags = 0; -} - -/*---------------------------------------------------------------------------- - * EAS_Config() - *---------------------------------------------------------------------------- - * Purpose: - * Returns a pointer to a structure containing the configuration options - * in this library build. - * - * Inputs: - * - * Outputs: - * - *---------------------------------------------------------------------------- -*/ -EAS_PUBLIC const S_EAS_LIB_CONFIG *EAS_Config (void) -{ - return &easLibConfig; -} - -/*---------------------------------------------------------------------------- - * EAS_Init() - *---------------------------------------------------------------------------- - * Purpose: - * Initialize the synthesizer library - * - * Inputs: - * ppEASData - pointer to data handle variable for this instance - * - * Outputs: - * - *---------------------------------------------------------------------------- -*/ -EAS_PUBLIC EAS_RESULT EAS_Init (EAS_DATA_HANDLE *ppEASData) -{ - EAS_HW_DATA_HANDLE pHWInstData; - EAS_RESULT result; - S_EAS_DATA *pEASData; - EAS_INT module; - EAS_BOOL staticMemoryModel; - - /* get the memory model */ - staticMemoryModel = EAS_CMStaticMemoryModel(); - - /* initialize the host wrapper interface */ - *ppEASData = NULL; - if ((result = EAS_HWInit(&pHWInstData)) != EAS_SUCCESS) - return result; - - /* check Configuration Module for S_EAS_DATA allocation */ - if (staticMemoryModel) - pEASData = EAS_CMEnumData(EAS_CM_EAS_DATA); - else - pEASData = EAS_HWMalloc(pHWInstData, sizeof(S_EAS_DATA)); - if (!pEASData) - { - { /* dpp: EAS_ReportEx(_EAS_SEVERITY_FATAL, "Failed to allocate EAS library memory\n"); */ } - return EAS_ERROR_MALLOC_FAILED; - } - - /* initialize some data */ - EAS_HWMemSet(pEASData, 0, sizeof(S_EAS_DATA)); - pEASData->staticMemoryModel = (EAS_BOOL8) staticMemoryModel; - pEASData->hwInstData = pHWInstData; - pEASData->renderTime = 0; - - /* set header search flag */ -#ifdef FILE_HEADER_SEARCH - pEASData->searchHeaderFlag = EAS_TRUE; -#endif - - /* initalize parameters */ - EAS_SetVolume(pEASData, NULL, DEFAULT_VOLUME); - -#ifdef _METRICS_ENABLED - /* initalize the metrics module */ - pEASData->pMetricsModule = EAS_CMEnumOptModules(EAS_MODULE_METRICS); - if (pEASData->pMetricsModule != NULL) - { - if ((result = (*pEASData->pMetricsModule->pfInit)(pEASData, &pEASData->pMetricsData)) != EAS_SUCCESS) - { - { /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "Error %ld initializing metrics module\n", result); */ } - return result; - } - } -#endif - - /* initailize the voice manager & synthesizer */ - if ((result = VMInitialize(pEASData)) != EAS_SUCCESS) - return result; - - /* initialize mix engine */ - if ((result = EAS_MixEngineInit(pEASData)) != EAS_SUCCESS) - { - { /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "Error %ld starting up mix engine\n", result); */ } - return result; - } - - /* initialize effects modules */ - for (module = 0; module < NUM_EFFECTS_MODULES; module++) - { - pEASData->effectsModules[module].effect = EAS_CMEnumFXModules(module); - if (pEASData->effectsModules[module].effect != NULL) - { - if ((result = (*pEASData->effectsModules[module].effect->pfInit)(pEASData, &pEASData->effectsModules[module].effectData)) != EAS_SUCCESS) - { - { /* dpp: EAS_ReportEx(_EAS_SEVERITY_FATAL, "Initialization of effects module %d returned %d\n", module, result); */ } - return result; - } - } - } - - /* initialize PCM engine */ - if ((result = EAS_PEInit(pEASData)) != EAS_SUCCESS) - { - { /* dpp: EAS_ReportEx(_EAS_SEVERITY_FATAL, "EAS_PEInit failed with error code %ld\n", result); */ } - return result; - } - - /* return instance data pointer to host */ - *ppEASData = pEASData; - - return EAS_SUCCESS; -} - -/*---------------------------------------------------------------------------- - * EAS_Shutdown() - *---------------------------------------------------------------------------- - * Purpose: - * Shuts down the library. Deallocates any memory associated with the - * synthesizer (dynamic memory model only) - * - * Inputs: - * pEASData - handle to data for this instance - * - * Outputs: - * - *---------------------------------------------------------------------------- -*/ -EAS_PUBLIC EAS_RESULT EAS_Shutdown (EAS_DATA_HANDLE pEASData) -{ - EAS_HW_DATA_HANDLE hwInstData; - EAS_RESULT result, reportResult; - EAS_INT i; - - /* establish pointers */ - hwInstData = pEASData->hwInstData; - - /* check for NULL handle */ - if (!pEASData) - return EAS_ERROR_HANDLE_INTEGRITY; - - /* if there are streams open, close them */ - reportResult = EAS_SUCCESS; - for (i = 0; i < MAX_NUMBER_STREAMS; i++) - { - if (pEASData->streams[i].pParserModule && pEASData->streams[i].handle) - { - if ((result = (*((S_FILE_PARSER_INTERFACE*)(pEASData->streams[i].pParserModule))->pfClose)(pEASData, pEASData->streams[i].handle)) != EAS_SUCCESS) - { - { /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "Error %ld shutting down parser module\n", result); */ } - reportResult = result; - } - } - } - - /* shutdown PCM engine */ - if ((result = EAS_PEShutdown(pEASData)) != EAS_SUCCESS) - { - { /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "Error %ld shutting down PCM engine\n", result); */ } - if (reportResult == EAS_SUCCESS) - reportResult = result; - } - - /* shutdown mix engine */ - if ((result = EAS_MixEngineShutdown(pEASData)) != EAS_SUCCESS) - { - { /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "Error %ld shutting down mix engine\n", result); */ } - if (reportResult == EAS_SUCCESS) - reportResult = result; - } - - /* shutdown effects modules */ - for (i = 0; i < NUM_EFFECTS_MODULES; i++) - { - if (pEASData->effectsModules[i].effect) - { - if ((result = (*pEASData->effectsModules[i].effect->pfShutdown)(pEASData, pEASData->effectsModules[i].effectData)) != EAS_SUCCESS) - { - { /* dpp: EAS_ReportEx(_EAS_SEVERITY_FATAL, "Shutdown of effects module %d returned %d\n", i, result); */ } - if (reportResult == EAS_SUCCESS) - reportResult = result; - } - } - } - - /* shutdown the voice manager & synthesizer */ - VMShutdown(pEASData); - -#ifdef _METRICS_ENABLED - /* shutdown the metrics module */ - if (pEASData->pMetricsModule != NULL) - { - if ((result = (*pEASData->pMetricsModule->pfShutdown)(pEASData, pEASData->pMetricsData)) != EAS_SUCCESS) - { - { /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "Error %ld shutting down metrics module\n", result); */ } - if (reportResult == EAS_SUCCESS) - reportResult = result; - } - } -#endif - - /* release allocated memory */ - if (!pEASData->staticMemoryModel) - EAS_HWFree(hwInstData, pEASData); - - /* shutdown host wrappers */ - if (hwInstData) - { - if ((result = EAS_HWShutdown(hwInstData)) != EAS_SUCCESS) - { - { /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "Error %ld shutting down host wrappers\n", result); */ } - if (reportResult == EAS_SUCCESS) - reportResult = result; - } - } - - return reportResult; -} - -#ifdef JET_INTERFACE -/*---------------------------------------------------------------------------- - * EAS_OpenJETStream() - *---------------------------------------------------------------------------- - * Private interface for JET to open an SMF stream with an offset - *---------------------------------------------------------------------------- -*/ -EAS_RESULT EAS_OpenJETStream (EAS_DATA_HANDLE pEASData, EAS_FILE_HANDLE fileHandle, EAS_I32 offset, EAS_HANDLE *ppStream) -{ - EAS_RESULT result; - EAS_VOID_PTR streamHandle; - S_FILE_PARSER_INTERFACE *pParserModule; - EAS_INT streamNum; - - /* allocate a stream */ - if ((streamNum = EAS_AllocateStream(pEASData)) < 0) - return EAS_ERROR_MAX_STREAMS_OPEN; - - /* check Configuration Module for SMF parser */ - *ppStream = NULL; - streamHandle = NULL; - pParserModule = (S_FILE_PARSER_INTERFACE *) EAS_CMEnumModules(0); - if (pParserModule == NULL) - return EAS_ERROR_UNRECOGNIZED_FORMAT; - - /* see if SMF parser recognizes the file */ - if ((result = (*pParserModule->pfCheckFileType)(pEASData, fileHandle, &streamHandle, offset)) != EAS_SUCCESS) - { - { /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "CheckFileType returned error %ld\n", result); */ } - return result; - } - - /* parser recognized the file, return the handle */ - if (streamHandle) - { - EAS_InitStream(&pEASData->streams[streamNum], pParserModule, streamHandle); - *ppStream = &pEASData->streams[streamNum]; - return EAS_SUCCESS; - } - - return EAS_ERROR_UNRECOGNIZED_FORMAT; -} -#endif - -/*---------------------------------------------------------------------------- - * EAS_OpenFile() - *---------------------------------------------------------------------------- - * Purpose: - * Opens a file for audio playback. - * - * Inputs: - * pEASData - pointer to overall EAS data structure - * pHandle - pointer to file handle - * - * Outputs: - * - * - * Side Effects: - * - *---------------------------------------------------------------------------- -*/ -EAS_PUBLIC EAS_RESULT EAS_OpenFile (EAS_DATA_HANDLE pEASData, EAS_FILE_LOCATOR locator, EAS_HANDLE *ppStream) -{ - EAS_RESULT result; - EAS_FILE_HANDLE fileHandle; - EAS_VOID_PTR streamHandle; - S_FILE_PARSER_INTERFACE *pParserModule; - EAS_INT streamNum; - EAS_INT moduleNum; - - /* open the file */ - if ((result = EAS_HWOpenFile(pEASData->hwInstData, locator, &fileHandle, EAS_FILE_READ)) != EAS_SUCCESS) - return result; - - /* allocate a stream */ - if ((streamNum = EAS_AllocateStream(pEASData)) < 0) - return EAS_ERROR_MAX_STREAMS_OPEN; - - /* check Configuration Module for file parsers */ - pParserModule = NULL; - *ppStream = NULL; - streamHandle = NULL; - for (moduleNum = 0; ; moduleNum++) - { - pParserModule = (S_FILE_PARSER_INTERFACE *) EAS_CMEnumModules(moduleNum); - if (pParserModule == NULL) - break; - - /* see if this parser recognizes it */ - if ((result = (*pParserModule->pfCheckFileType)(pEASData, fileHandle, &streamHandle, 0L)) != EAS_SUCCESS) - { - { /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "CheckFileType returned error %ld\n", result); */ } - return result; - } - - /* parser recognized the file, return the handle */ - if (streamHandle) - { - - /* save the parser pointer and file handle */ - EAS_InitStream(&pEASData->streams[streamNum], pParserModule, streamHandle); - *ppStream = &pEASData->streams[streamNum]; - return EAS_SUCCESS; - } - - /* rewind the file for the next parser */ - if ((result = EAS_HWFileSeek(pEASData->hwInstData, fileHandle, 0L)) != EAS_SUCCESS) - return result; - } - - /* no parser was able to recognize the file, close it and return an error */ - EAS_HWCloseFile(pEASData->hwInstData, fileHandle); - { /* dpp: EAS_ReportEx(_EAS_SEVERITY_WARNING, "No parser recognized the requested file\n"); */ } - return EAS_ERROR_UNRECOGNIZED_FORMAT; -} - -#ifdef MMAPI_SUPPORT -/*---------------------------------------------------------------------------- - * EAS_MMAPIToneControl() - *---------------------------------------------------------------------------- - * Purpose: - * Opens a ToneControl file for audio playback. - * - * Inputs: - * pEASData - pointer to overall EAS data structure - * pHandle - pointer to file handle - * - * Outputs: - * - * - * Side Effects: - * - *---------------------------------------------------------------------------- -*/ -EAS_PUBLIC EAS_RESULT EAS_MMAPIToneControl (EAS_DATA_HANDLE pEASData, EAS_FILE_LOCATOR locator, EAS_HANDLE *ppStream) -{ - EAS_RESULT result; - EAS_FILE_HANDLE fileHandle; - EAS_VOID_PTR streamHandle; - S_FILE_PARSER_INTERFACE *pParserModule; - EAS_INT streamNum; - - /* check if the tone control parser is available */ - *ppStream = NULL; - streamHandle = NULL; - pParserModule = EAS_CMEnumOptModules(EAS_MODULE_MMAPI_TONE_CONTROL); - if (pParserModule == NULL) - { - { /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "EAS_MMAPIToneControl: ToneControl parser not available\n"); */ } - return EAS_ERROR_FEATURE_NOT_AVAILABLE; - } - - /* open the file */ - if ((result = EAS_HWOpenFile(pEASData->hwInstData, locator, &fileHandle, EAS_FILE_READ)) != EAS_SUCCESS) - return result; - - /* allocate a stream */ - if ((streamNum = EAS_AllocateStream(pEASData)) < 0) - return EAS_ERROR_MAX_STREAMS_OPEN; - - /* see if ToneControl parser recognizes it */ - if ((result = (*pParserModule->pfCheckFileType)(pEASData, fileHandle, &streamHandle, 0L)) != EAS_SUCCESS) - { - { /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "CheckFileType returned error %ld\n", result); */ } - return result; - } - - /* parser accepted the file, return the handle */ - if (streamHandle) - { - - /* save the parser pointer and file handle */ - EAS_InitStream(&pEASData->streams[streamNum], pParserModule, streamHandle); - *ppStream = &pEASData->streams[streamNum]; - return EAS_SUCCESS; - } - - /* parser did not recognize the file, close it and return an error */ - EAS_HWCloseFile(pEASData->hwInstData, fileHandle); - { /* dpp: EAS_ReportEx(_EAS_SEVERITY_WARNING, "No parser recognized the requested file\n"); */ } - return EAS_ERROR_UNRECOGNIZED_FORMAT; -} - -/*---------------------------------------------------------------------------- - * EAS_GetWaveFmtChunk - *---------------------------------------------------------------------------- - * Helper function to retrieve WAVE file fmt chunk for MMAPI - *---------------------------------------------------------------------------- - * pEASData - pointer to EAS persistent data object - * pStream - stream handle - * pFmtChunk - pointer to variable to receive current setting - *---------------------------------------------------------------------------- -*/ -EAS_PUBLIC EAS_RESULT EAS_GetWaveFmtChunk (S_EAS_DATA *pEASData, EAS_HANDLE pStream, EAS_VOID_PTR *ppFmtChunk) -{ - EAS_RESULT result; - EAS_I32 value; - - if ((result = EAS_GetStreamParameter(pEASData, pStream, PARSER_DATA_FORMAT, &value)) != EAS_SUCCESS) - return result; - *ppFmtChunk = (EAS_VOID_PTR) value; - return EAS_SUCCESS; -} -#endif - -/*---------------------------------------------------------------------------- - * EAS_GetFileType - *---------------------------------------------------------------------------- - * Returns the file type (see eas_types.h for enumerations) - *---------------------------------------------------------------------------- - * pEASData - pointer to EAS persistent data object - * pStream - stream handle - * pFileType - pointer to variable to receive file type - *---------------------------------------------------------------------------- -*/ -EAS_PUBLIC EAS_RESULT EAS_GetFileType (S_EAS_DATA *pEASData, EAS_HANDLE pStream, EAS_I32 *pFileType) -{ - if (!EAS_StreamReady (pEASData, pStream)) - return EAS_ERROR_NOT_VALID_IN_THIS_STATE; - return EAS_GetStreamParameter(pEASData, pStream, PARSER_DATA_FILE_TYPE, pFileType); -} - -/*---------------------------------------------------------------------------- - * EAS_Prepare() - *---------------------------------------------------------------------------- - * Purpose: - * Prepares the synthesizer to play the file or stream. Parses the first - * frame of data from the file and arms the synthesizer. - * - * Inputs: - * pEASData - pointer to overall EAS data structure - * handle - file or stream handle - * - * Outputs: - * - * - * Side Effects: - * - *---------------------------------------------------------------------------- -*/ -EAS_PUBLIC EAS_RESULT EAS_Prepare (EAS_DATA_HANDLE pEASData, EAS_HANDLE pStream) -{ - S_FILE_PARSER_INTERFACE *pParserModule; - EAS_STATE state; - EAS_RESULT result; - - pParserModule = (S_FILE_PARSER_INTERFACE*) pStream->pParserModule; - if (pParserModule == NULL) - return EAS_ERROR_FEATURE_NOT_AVAILABLE; - - /* check for valid state */ - result = pParserModule->pfState(pEASData, pStream->handle, &state); - if (result == EAS_SUCCESS) - { - /* prepare the stream */ - if (state == EAS_STATE_OPEN) - { - pParserModule = (S_FILE_PARSER_INTERFACE*) pStream->pParserModule; - result = (*pParserModule->pfPrepare)(pEASData, pStream->handle); - - /* set volume */ - if (result == EAS_SUCCESS) - result = EAS_SetVolume(pEASData, pStream, pStream->volume); - } - else - result = EAS_ERROR_NOT_VALID_IN_THIS_STATE; - - } - - return result; -} - -/*---------------------------------------------------------------------------- - * EAS_Render() - *---------------------------------------------------------------------------- - * Purpose: - * Parse the Midi data and render PCM audio data. - * - * Inputs: - * pEASData - buffer for internal EAS data - * pOut - output buffer pointer - * nNumRequested - requested num samples to generate - * pnNumGenerated - actual number of samples generated - * - * Outputs: - * EAS_SUCCESS if PCM data was successfully rendered - * - *---------------------------------------------------------------------------- -*/ -EAS_PUBLIC EAS_RESULT EAS_Render (EAS_DATA_HANDLE pEASData, EAS_PCM *pOut, EAS_I32 numRequested, EAS_I32 *pNumGenerated) -{ - S_FILE_PARSER_INTERFACE *pParserModule; - EAS_RESULT result; - EAS_I32 voicesRendered; - EAS_STATE parserState; - EAS_INT streamNum; - - /* assume no samples generated and reset workload */ - *pNumGenerated = 0; - VMInitWorkload(pEASData->pVoiceMgr); - - /* no support for other buffer sizes yet */ - if (numRequested != BUFFER_SIZE_IN_MONO_SAMPLES) - { - { /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "This library supports only %ld samples in buffer, host requested %ld samples\n", - (EAS_I32) BUFFER_SIZE_IN_MONO_SAMPLES, numRequested); */ } - return EAS_BUFFER_SIZE_MISMATCH; - } - -#ifdef _METRICS_ENABLED - /* start performance counter */ - if (pEASData->pMetricsData) - (*pEASData->pMetricsModule->pfStartTimer)(pEASData->pMetricsData, EAS_PM_TOTAL_TIME); -#endif - - /* prep the frame buffer, do mix engine prep only if TRUE */ -#ifdef _SPLIT_ARCHITECTURE - if (VMStartFrame(pEASData)) - EAS_MixEnginePrep(pEASData, numRequested); -#else - /* prep the mix engine */ - EAS_MixEnginePrep(pEASData, numRequested); -#endif - - /* save the output buffer pointer */ - pEASData->pOutputAudioBuffer = pOut; - - -#ifdef _METRICS_ENABLED - /* start performance counter */ - if (pEASData->pMetricsData) - (*pEASData->pMetricsModule->pfStartTimer)(pEASData->pMetricsData, EAS_PM_PARSE_TIME); -#endif - - /* if we haven't finished parsing from last time, do it now */ - /* need to parse another frame of events before we render again */ - for (streamNum = 0; streamNum < MAX_NUMBER_STREAMS; streamNum++) - { - /* clear the locate flag */ - pEASData->streams[streamNum].streamFlags &= ~STREAM_FLAGS_LOCATE; - - if (pEASData->streams[streamNum].pParserModule) - { - - /* establish pointer to parser module */ - pParserModule = pEASData->streams[streamNum].pParserModule; - - /* handle pause */ - if (pEASData->streams[streamNum].streamFlags & STREAM_FLAGS_PAUSE) - { - if (pParserModule->pfPause) - result = pParserModule->pfPause(pEASData, pEASData->streams[streamNum].handle); - pEASData->streams[streamNum].streamFlags &= ~STREAM_FLAGS_PAUSE; - } - - /* get current state */ - if ((result = (*pParserModule->pfState)(pEASData, pEASData->streams[streamNum].handle, &parserState)) != EAS_SUCCESS) - return result; - - /* handle resume */ - if (parserState == EAS_STATE_PAUSED) - { - if (pEASData->streams[streamNum].streamFlags & STREAM_FLAGS_RESUME) - { - if (pParserModule->pfResume) - result = pParserModule->pfResume(pEASData, pEASData->streams[streamNum].handle); - pEASData->streams[streamNum].streamFlags &= ~STREAM_FLAGS_RESUME; - } - } - - /* if necessary, parse stream */ - if ((pEASData->streams[streamNum].streamFlags & STREAM_FLAGS_PARSED) == 0) - if ((result = EAS_ParseEvents(pEASData, &pEASData->streams[streamNum], pEASData->streams[streamNum].time + pEASData->streams[streamNum].frameLength, eParserModePlay)) != EAS_SUCCESS) - return result; - - /* check for an early abort */ - if ((pEASData->streams[streamNum].streamFlags) == 0) - { - -#ifdef _METRICS_ENABLED - /* stop performance counter */ - if (pEASData->pMetricsData) - (*pEASData->pMetricsModule->pfStartTimer)(pEASData->pMetricsData, EAS_PM_TOTAL_TIME); -#endif - - return EAS_SUCCESS; - } - - /* check for repeat */ - if (pEASData->streams[streamNum].repeatCount) - { - - /* check for stopped state */ - if ((result = (*pParserModule->pfState)(pEASData, pEASData->streams[streamNum].handle, &parserState)) != EAS_SUCCESS) - return result; - if (parserState == EAS_STATE_STOPPED) - { - - /* decrement repeat count, unless it is negative */ - if (pEASData->streams[streamNum].repeatCount > 0) - pEASData->streams[streamNum].repeatCount--; - - /* reset the parser */ - if ((result = (*pParserModule->pfReset)(pEASData, pEASData->streams[streamNum].handle)) != EAS_SUCCESS) - return result; - pEASData->streams[streamNum].time = 0; - } - } - } - } - -#ifdef _METRICS_ENABLED - /* stop performance counter */ - if (pEASData->pMetricsData) - (void)(*pEASData->pMetricsModule->pfStopTimer)(pEASData->pMetricsData, EAS_PM_PARSE_TIME); -#endif - -#ifdef _METRICS_ENABLED - /* start the render timer */ - if (pEASData->pMetricsData) - (*pEASData->pMetricsModule->pfStartTimer)(pEASData->pMetricsData, EAS_PM_RENDER_TIME); -#endif - - /* render audio */ - if ((result = VMRender(pEASData->pVoiceMgr, BUFFER_SIZE_IN_MONO_SAMPLES, pEASData->pMixBuffer, &voicesRendered)) != EAS_SUCCESS) - { - { /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "pfRender function returned error %ld\n", result); */ } - return result; - } - -#ifdef _METRICS_ENABLED - /* stop the render timer */ - if (pEASData->pMetricsData) { - (*pEASData->pMetricsModule->pfIncrementCounter)(pEASData->pMetricsData, EAS_PM_FRAME_COUNT, 1); - (void)(*pEASData->pMetricsModule->pfStopTimer)(pEASData->pMetricsData, EAS_PM_RENDER_TIME); - (*pEASData->pMetricsModule->pfIncrementCounter)(pEASData->pMetricsData, EAS_PM_TOTAL_VOICE_COUNT, (EAS_U32) voicesRendered); - (void)(*pEASData->pMetricsModule->pfRecordMaxValue)(pEASData->pMetricsData, EAS_PM_MAX_VOICES, (EAS_U32) voicesRendered); - } -#endif - - //2 Do we really need frameParsed? - /* need to parse another frame of events before we render again */ - for (streamNum = 0; streamNum < MAX_NUMBER_STREAMS; streamNum++) - if (pEASData->streams[streamNum].pParserModule != NULL) - pEASData->streams[streamNum].streamFlags &= ~STREAM_FLAGS_PARSED; - -#ifdef _METRICS_ENABLED - /* start performance counter */ - if (pEASData->pMetricsData) - (*pEASData->pMetricsModule->pfStartTimer)(pEASData->pMetricsData, EAS_PM_STREAM_TIME); -#endif - - /* render PCM audio */ - if ((result = EAS_PERender(pEASData, numRequested)) != EAS_SUCCESS) - { - { /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "EAS_PERender returned error %ld\n", result); */ } - return result; - } - -#ifdef _METRICS_ENABLED - /* stop the stream timer */ - if (pEASData->pMetricsData) - (void)(*pEASData->pMetricsModule->pfStopTimer)(pEASData->pMetricsData, EAS_PM_STREAM_TIME); -#endif - -#ifdef _METRICS_ENABLED - /* start the post timer */ - if (pEASData->pMetricsData) - (*pEASData->pMetricsModule->pfStartTimer)(pEASData->pMetricsData, EAS_PM_POST_TIME); -#endif - - /* for split architecture, send DSP vectors. Do post only if return is TRUE */ -#ifdef _SPLIT_ARCHITECTURE - if (VMEndFrame(pEASData)) - { - /* now do post-processing */ - EAS_MixEnginePost(pEASData, numRequested); - *pNumGenerated = numRequested; - } -#else - /* now do post-processing */ - EAS_MixEnginePost(pEASData, numRequested); - *pNumGenerated = numRequested; -#endif - -#ifdef _METRICS_ENABLED - /* stop the post timer */ - if (pEASData->pMetricsData) - (void)(*pEASData->pMetricsModule->pfStopTimer)(pEASData->pMetricsData, EAS_PM_POST_TIME); -#endif - - /* advance render time */ - pEASData->renderTime += AUDIO_FRAME_LENGTH; - -#if 0 - /* dump workload for debug */ - if (pEASData->pVoiceMgr->workload) - { /* dpp: EAS_ReportEx(_EAS_SEVERITY_DETAIL, "Workload = %d\n", pEASData->pVoiceMgr->workload); */ } -#endif - -#ifdef _METRICS_ENABLED - /* stop performance counter */ - if (pEASData->pMetricsData) - { - PERF_TIMER temp; - temp = (*pEASData->pMetricsModule->pfStopTimer)(pEASData->pMetricsData, EAS_PM_TOTAL_TIME); - - /* if max render time, record the number of voices and time */ - if ((*pEASData->pMetricsModule->pfRecordMaxValue) - (pEASData->pMetricsData, EAS_PM_MAX_CYCLES, (EAS_U32) temp)) - { - (*pEASData->pMetricsModule->pfRecordValue)(pEASData->pMetricsData, EAS_PM_MAX_CYCLES_VOICES, (EAS_U32) voicesRendered); - (*pEASData->pMetricsModule->pfRecordValue)(pEASData->pMetricsData, EAS_PM_MAX_CYCLES_TIME, (EAS_I32) (pEASData->renderTime >> 8)); - } - } -#endif - -#ifdef JET_INTERFACE - /* let JET to do its thing */ - if (pEASData->jetHandle != NULL) - { - result = JET_Process(pEASData); - if (result != EAS_SUCCESS) - return result; - } -#endif - - return EAS_SUCCESS; -} - -/*---------------------------------------------------------------------------- - * EAS_SetRepeat() - *---------------------------------------------------------------------------- - * Purpose: - * Set the selected stream to repeat. - * - * Inputs: - * pEASData - handle to data for this instance - * handle - handle to stream - * repeatCount - repeat count - * - * Outputs: - * - * Side Effects: - * - * Notes: - * 0 = no repeat - * 1 = repeat once, i.e. play through twice - * -1 = repeat forever - *---------------------------------------------------------------------------- -*/ -/*lint -esym(715, pEASData) reserved for future use */ -EAS_PUBLIC EAS_RESULT EAS_SetRepeat (EAS_DATA_HANDLE pEASData, EAS_HANDLE pStream, EAS_I32 repeatCount) -{ - pStream->repeatCount = repeatCount; - return EAS_SUCCESS; -} - -/*---------------------------------------------------------------------------- - * EAS_GetRepeat() - *---------------------------------------------------------------------------- - * Purpose: - * Gets the current repeat count for the selected stream. - * - * Inputs: - * pEASData - handle to data for this instance - * handle - handle to stream - * pRrepeatCount - pointer to variable to hold repeat count - * - * Outputs: - * - * Side Effects: - * - * Notes: - * 0 = no repeat - * 1 = repeat once, i.e. play through twice - * -1 = repeat forever - *---------------------------------------------------------------------------- -*/ -/*lint -esym(715, pEASData) reserved for future use */ -EAS_PUBLIC EAS_RESULT EAS_GetRepeat (EAS_DATA_HANDLE pEASData, EAS_HANDLE pStream, EAS_I32 *pRepeatCount) -{ - *pRepeatCount = pStream->repeatCount; - return EAS_SUCCESS; -} - -/*---------------------------------------------------------------------------- - * EAS_SetPlaybackRate() - *---------------------------------------------------------------------------- - * Purpose: - * Sets the playback rate. - * - * Inputs: - * pEASData - handle to data for this instance - * handle - handle to stream - * rate - rate (28-bit fractional amount) - * - * Outputs: - * - * Side Effects: - * - *---------------------------------------------------------------------------- -*/ -/*lint -esym(715, pEASData) reserved for future use */ -EAS_PUBLIC EAS_RESULT EAS_SetPlaybackRate (EAS_DATA_HANDLE pEASData, EAS_HANDLE pStream, EAS_U32 rate) -{ - - /* check range */ - if ((rate < (1 << 27)) || (rate > (1 << 29))) - return EAS_ERROR_INVALID_PARAMETER; - - /* calculate new frame length - * - * NOTE: The maximum frame length we can accomodate based on a - * maximum rate of 2.0 (2^28) is 2047 (2^13-1). To accomodate a - * longer frame length or a higher maximum rate, the fixed point - * divide below will need to be adjusted - */ - pStream->frameLength = (AUDIO_FRAME_LENGTH * (rate >> 8)) >> 20; - - /* notify stream of new playback rate */ - EAS_SetStreamParameter(pEASData, pStream, PARSER_DATA_PLAYBACK_RATE, (EAS_I32) rate); - return EAS_SUCCESS; -} - -/*---------------------------------------------------------------------------- - * EAS_SetTransposition) - *---------------------------------------------------------------------------- - * Purpose: - * Sets the key tranposition for the synthesizer. Transposes all - * melodic instruments by the specified amount. Range is limited - * to +/-12 semitones. - * - * Inputs: - * pEASData - handle to data for this instance - * handle - handle to stream - * transposition - +/-12 semitones - * - * Outputs: - * - * Side Effects: - * - *---------------------------------------------------------------------------- -*/ -EAS_PUBLIC EAS_RESULT EAS_SetTransposition (EAS_DATA_HANDLE pEASData, EAS_HANDLE pStream, EAS_I32 transposition) -{ - - /* check range */ - if ((transposition < -12) || (transposition > 12)) - return EAS_ERROR_INVALID_PARAMETER; - - if (!EAS_StreamReady(pEASData, pStream)) - return EAS_ERROR_NOT_VALID_IN_THIS_STATE; - return EAS_IntSetStrmParam(pEASData, pStream, PARSER_DATA_TRANSPOSITION, transposition); -} - -/*---------------------------------------------------------------------------- - * EAS_ParseEvents() - *---------------------------------------------------------------------------- - * Purpose: - * Parse events in the current streams until the desired time is reached. - * - * Inputs: - * pEASData - buffer for internal EAS data - * endTime - stop parsing if this time is reached - * parseMode - play, locate, or metadata - * - * Outputs: - * EAS_SUCCESS if PCM data was successfully rendered - * - *---------------------------------------------------------------------------- -*/ -static EAS_RESULT EAS_ParseEvents (S_EAS_DATA *pEASData, EAS_HANDLE pStream, EAS_U32 endTime, EAS_INT parseMode) -{ - S_FILE_PARSER_INTERFACE *pParserModule; - EAS_RESULT result; - EAS_I32 parserState; - EAS_BOOL done; - EAS_INT yieldCount = YIELD_EVENT_COUNT; - EAS_U32 time = 0; - - /* does this parser have a time function? */ - pParserModule = pStream->pParserModule; - if (pParserModule->pfTime == NULL) - { - /* check state */ - if ((result = (*pParserModule->pfState)(pEASData, pStream->handle, &parserState)) != EAS_SUCCESS) - return result; - /* if play state, advance time */ - if ((parserState >= EAS_STATE_READY) && (parserState <= EAS_STATE_PAUSING)) - pStream->time += pStream->frameLength; - done = EAS_TRUE; - } - - /* assume we're not done, in case we abort out */ - else - { - pStream->streamFlags &= ~STREAM_FLAGS_PARSED; - done = EAS_FALSE; - } - - while (!done) - { - - /* check for stopped state */ - if ((result = (*pParserModule->pfState)(pEASData, pStream->handle, &parserState)) != EAS_SUCCESS) - return result; - if (parserState > EAS_STATE_PLAY) - { - /* save current time if we're not in play mode */ - if (parseMode != eParserModePlay) - pStream->time = time << 8; - done = EAS_TRUE; - break; - } - - /* get the next event time */ - if (pParserModule->pfTime) - { - if ((result = (*pParserModule->pfTime)(pEASData, pStream->handle, &time)) != EAS_SUCCESS) - return result; - - /* if next event is within this frame, parse it */ - if (time < (endTime >> 8)) - { - - /* parse the next event */ - if (pParserModule->pfEvent) - if ((result = (*pParserModule->pfEvent)(pEASData, pStream->handle, parseMode)) != EAS_SUCCESS) - return result; - } - - /* no more events in this frame, advance time */ - else - { - pStream->time = endTime; - done = EAS_TRUE; - } - } - - /* check for max workload exceeded */ - if (VMCheckWorkload(pEASData->pVoiceMgr)) - { - /* stop even though we may not have parsed - * all the events in this frame. The parser will try to - * catch up on the next frame. - */ - break; - } - - /* give host a chance for an early abort */ - if (--yieldCount == 0) - { - if (EAS_HWYield(pEASData->hwInstData)) - break; - yieldCount = YIELD_EVENT_COUNT; - } - } - - /* if no early abort, parsing is complete for this frame */ - if (done) - pStream->streamFlags |= STREAM_FLAGS_PARSED; - - return EAS_SUCCESS; -} - -/*---------------------------------------------------------------------------- - * EAS_ParseMetaData() - *---------------------------------------------------------------------------- - * Purpose: - * - * - * Inputs: - * pEASData - pointer to overall EAS data structure - * handle - file or stream handle - * playLength - pointer to variable to store the play length (in msecs) - * - * Outputs: - * - * - * Side Effects: - * - resets the parser to the start of the file - *---------------------------------------------------------------------------- -*/ -EAS_PUBLIC EAS_RESULT EAS_ParseMetaData (EAS_DATA_HANDLE pEASData, EAS_HANDLE pStream, EAS_I32 *playLength) -{ - S_FILE_PARSER_INTERFACE *pParserModule; - EAS_RESULT result; - EAS_STATE state; - - pParserModule = (S_FILE_PARSER_INTERFACE*) pStream->pParserModule; - if (pParserModule == NULL) - return EAS_ERROR_FEATURE_NOT_AVAILABLE; - - /* check parser state */ - if ((result = (*pParserModule->pfState)(pEASData, pStream->handle, &state)) != EAS_SUCCESS) - return result; - if (state >= EAS_STATE_OPEN) - return EAS_ERROR_NOT_VALID_IN_THIS_STATE; - - /* if parser has metadata function, use that */ - if (pParserModule->pfGetMetaData != NULL) - return pParserModule->pfGetMetaData(pEASData, pStream->handle, playLength); - - /* reset the parser to the beginning */ - if ((result = (*pParserModule->pfReset)(pEASData, pStream->handle)) != EAS_SUCCESS) - return result; - - /* parse the file to end */ - pStream->time = 0; - VMInitWorkload(pEASData->pVoiceMgr); - if ((result = EAS_ParseEvents(pEASData, pStream, 0x7fffffff, eParserModeMetaData)) != EAS_SUCCESS) - return result; - - /* get the parser time */ - if ((result = EAS_GetLocation(pEASData, pStream, playLength)) != EAS_SUCCESS) - return result; - - /* reset the parser to the beginning */ - pStream->time = 0; - return (*pParserModule->pfReset)(pEASData, pStream->handle); -} - -/*---------------------------------------------------------------------------- - * EAS_RegisterMetaDataCallback() - *---------------------------------------------------------------------------- - * Purpose: - * Registers a metadata callback function for parsed metadata. - * - * Inputs: - * pEASData - pointer to overall EAS data structure - * handle - file or stream handle - * cbFunc - pointer to host callback function - * metaDataBuffer - pointer to metadata buffer - * metaDataBufSize - maximum size of the metadata buffer - * - * Outputs: - * - * - * Side Effects: - * - *---------------------------------------------------------------------------- -*/ -EAS_PUBLIC EAS_RESULT EAS_RegisterMetaDataCallback ( - EAS_DATA_HANDLE pEASData, - EAS_HANDLE pStream, - EAS_METADATA_CBFUNC cbFunc, - char *metaDataBuffer, - EAS_I32 metaDataBufSize, - EAS_VOID_PTR pUserData) -{ - S_METADATA_CB metadata; - - if (!EAS_StreamReady(pEASData, pStream)) - return EAS_ERROR_NOT_VALID_IN_THIS_STATE; - - /* register callback function */ - metadata.callback = cbFunc; - metadata.buffer = metaDataBuffer; - metadata.bufferSize = metaDataBufSize; - metadata.pUserData = pUserData; - return EAS_SetStreamParameter(pEASData, pStream, PARSER_DATA_METADATA_CB, (EAS_I32) &metadata); -} - -/*---------------------------------------------------------------------------- - * EAS_GetNoteCount () - *---------------------------------------------------------------------------- - * Returns the total number of notes played in this stream - *---------------------------------------------------------------------------- -*/ -EAS_PUBLIC EAS_RESULT EAS_GetNoteCount (EAS_DATA_HANDLE pEASData, EAS_HANDLE pStream, EAS_I32 *pNoteCount) -{ - if (!EAS_StreamReady(pEASData, pStream)) - return EAS_ERROR_NOT_VALID_IN_THIS_STATE; - return EAS_IntGetStrmParam(pEASData, pStream, PARSER_DATA_NOTE_COUNT, pNoteCount); -} - -/*---------------------------------------------------------------------------- - * EAS_CloseFile() - *---------------------------------------------------------------------------- - * Purpose: - * Closes an audio file or stream. Playback should have either paused or - * completed (EAS_State returns EAS_PAUSED or EAS_STOPPED). - * - * Inputs: - * pEASData - pointer to overall EAS data structure - * handle - file or stream handle - * - * Outputs: - * - * - * Side Effects: - * - *---------------------------------------------------------------------------- -*/ -EAS_PUBLIC EAS_RESULT EAS_CloseFile (EAS_DATA_HANDLE pEASData, EAS_HANDLE pStream) -{ - S_FILE_PARSER_INTERFACE *pParserModule; - EAS_RESULT result; - - /* call the close function */ - pParserModule = (S_FILE_PARSER_INTERFACE*) pStream->pParserModule; - if (pParserModule == NULL) - return EAS_ERROR_FEATURE_NOT_AVAILABLE; - - result = (*pParserModule->pfClose)(pEASData, pStream->handle); - - /* clear the handle and parser interface pointer */ - pStream->handle = NULL; - pStream->pParserModule = NULL; - return result; -} - -/*---------------------------------------------------------------------------- - * EAS_OpenMIDIStream() - *---------------------------------------------------------------------------- - * Purpose: - * Opens a raw MIDI stream allowing the host to route MIDI cable data directly to the synthesizer - * - * Inputs: - * pEASData - pointer to overall EAS data structure - * pHandle - pointer to variable to hold file or stream handle - * - * Outputs: - * - * - * Side Effects: - * - *---------------------------------------------------------------------------- -*/ -EAS_PUBLIC EAS_RESULT EAS_OpenMIDIStream (EAS_DATA_HANDLE pEASData, EAS_HANDLE *ppStream, EAS_HANDLE streamHandle) -{ - EAS_RESULT result; - S_INTERACTIVE_MIDI *pMIDIStream; - EAS_INT streamNum; - - /* initialize some pointers */ - *ppStream = NULL; - - /* allocate a stream */ - if ((streamNum = EAS_AllocateStream(pEASData)) < 0) - return EAS_ERROR_MAX_STREAMS_OPEN; - - /* check Configuration Module for S_EAS_DATA allocation */ - if (pEASData->staticMemoryModel) - pMIDIStream = EAS_CMEnumData(EAS_CM_MIDI_STREAM_DATA); - else - pMIDIStream = EAS_HWMalloc(pEASData->hwInstData, sizeof(S_INTERACTIVE_MIDI)); - - /* allocate dynamic memory */ - if (!pMIDIStream) - { - { /* dpp: EAS_ReportEx(_EAS_SEVERITY_FATAL, "Failed to allocate MIDI stream data\n"); */ } - return EAS_ERROR_MALLOC_FAILED; - } - - /* zero the memory to insure complete initialization */ - EAS_HWMemSet(pMIDIStream, 0, sizeof(S_INTERACTIVE_MIDI)); - EAS_InitStream(&pEASData->streams[streamNum], NULL, pMIDIStream); - - /* instantiate a new synthesizer */ - if (streamHandle == NULL) - { - result = VMInitMIDI(pEASData, &pMIDIStream->pSynth); - } - - /* use an existing synthesizer */ - else - { - EAS_I32 value; - result = EAS_GetStreamParameter(pEASData, streamHandle, PARSER_DATA_SYNTH_HANDLE, &value); - pMIDIStream->pSynth = (S_SYNTH*) value; - VMIncRefCount(pMIDIStream->pSynth); - } - if (result != EAS_SUCCESS) - { - EAS_CloseMIDIStream(pEASData, &pEASData->streams[streamNum]); - return result; - } - - /* initialize the MIDI stream data */ - EAS_InitMIDIStream(&pMIDIStream->stream); - - *ppStream = (EAS_HANDLE) &pEASData->streams[streamNum]; - return EAS_SUCCESS; -} - -/*---------------------------------------------------------------------------- - * EAS_WriteMIDIStream() - *---------------------------------------------------------------------------- - * Purpose: - * Send data to the MIDI stream device - * - * Inputs: - * pEASData - pointer to overall EAS data structure - * handle - stream handle - * pBuffer - pointer to buffer - * count - number of bytes to write - * - * Outputs: - * - * - * Side Effects: - * - *---------------------------------------------------------------------------- -*/ -EAS_PUBLIC EAS_RESULT EAS_WriteMIDIStream (EAS_DATA_HANDLE pEASData, EAS_HANDLE pStream, EAS_U8 *pBuffer, EAS_I32 count) -{ - S_INTERACTIVE_MIDI *pMIDIStream; - EAS_RESULT result; - - pMIDIStream = (S_INTERACTIVE_MIDI*) pStream->handle; - - if (count <= 0) - return EAS_ERROR_PARAMETER_RANGE; - - /* send the entire buffer */ - while (count--) - { - if ((result = EAS_ParseMIDIStream(pEASData, pMIDIStream->pSynth, &pMIDIStream->stream, *pBuffer++, eParserModePlay)) != EAS_SUCCESS) - return result; - } - return EAS_SUCCESS; -} - -/*---------------------------------------------------------------------------- - * EAS_CloseMIDIStream() - *---------------------------------------------------------------------------- - * Purpose: - * Closes a raw MIDI stream - * - * Inputs: - * pEASData - pointer to overall EAS data structure - * handle - stream handle - * - * Outputs: - * - * - * Side Effects: - * - *---------------------------------------------------------------------------- -*/ -EAS_PUBLIC EAS_RESULT EAS_CloseMIDIStream (EAS_DATA_HANDLE pEASData, EAS_HANDLE pStream) -{ - S_INTERACTIVE_MIDI *pMIDIStream; - - pMIDIStream = (S_INTERACTIVE_MIDI*) pStream->handle; - - /* close synth */ - if (pMIDIStream->pSynth != NULL) - { - VMMIDIShutdown(pEASData, pMIDIStream->pSynth); - pMIDIStream->pSynth = NULL; - } - - /* release allocated memory */ - if (!pEASData->staticMemoryModel) - EAS_HWFree(((S_EAS_DATA*) pEASData)->hwInstData, pMIDIStream); - - pStream->handle = NULL; - return EAS_SUCCESS; -} - -/*---------------------------------------------------------------------------- - * EAS_State() - *---------------------------------------------------------------------------- - * Purpose: - * Returns the state of an audio file or stream. - * - * Inputs: - * pEASData - pointer to overall EAS data structure - * handle - file or stream handle - * - * Outputs: - * - * - * Side Effects: - * - *---------------------------------------------------------------------------- -*/ -EAS_PUBLIC EAS_RESULT EAS_State (EAS_DATA_HANDLE pEASData, EAS_HANDLE pStream, EAS_STATE *pState) -{ - S_FILE_PARSER_INTERFACE *pParserModule; - EAS_RESULT result; - - /* call the parser to return state */ - pParserModule = (S_FILE_PARSER_INTERFACE*) pStream->pParserModule; - if (pParserModule == NULL) - return EAS_ERROR_FEATURE_NOT_AVAILABLE; - - if ((result = (*pParserModule->pfState)(pEASData, pStream->handle, pState)) != EAS_SUCCESS) - return result; - - /* if repeat count is set for this parser, mask the stopped state from the application */ - if (pStream->repeatCount && (*pState == EAS_STATE_STOPPED)) - *pState = EAS_STATE_PLAY; - - /* if we're not ready or playing, we don't need to hide state from host */ - if (*pState > EAS_STATE_PLAY) - return EAS_SUCCESS; - - /* if stream is about to be paused, report it as paused */ - if (pStream->streamFlags & STREAM_FLAGS_PAUSE) - { - if (pStream->streamFlags & STREAM_FLAGS_LOCATE) - *pState = EAS_STATE_PAUSED; - else - *pState = EAS_STATE_PAUSING; - } - - /* if stream is about to resume, report it as playing */ - if (pStream->streamFlags & STREAM_FLAGS_RESUME) - *pState = EAS_STATE_PLAY; - - return EAS_SUCCESS; -} - -/*---------------------------------------------------------------------------- - * EAS_SetPolyphony() - *---------------------------------------------------------------------------- - * Purpose: - * Set the polyphony of the stream. A value of 0 allows the stream - * to use all voices (set by EAS_SetSynthPolyphony). - * - * Inputs: - * pEASData - pointer to overall EAS data structure - * streamHandle - handle returned by EAS_OpenFile - * polyphonyCount - the desired polyphony count - * - * Outputs: - * - * Side Effects: - * - *---------------------------------------------------------------------------- -*/ -EAS_PUBLIC EAS_RESULT EAS_SetPolyphony (EAS_DATA_HANDLE pEASData, EAS_HANDLE pStream, EAS_I32 polyphonyCount) -{ - if (!EAS_StreamReady(pEASData, pStream)) - return EAS_ERROR_NOT_VALID_IN_THIS_STATE; - return EAS_IntSetStrmParam(pEASData, pStream, PARSER_DATA_POLYPHONY, polyphonyCount); -} - -/*---------------------------------------------------------------------------- - * EAS_GetPolyphony() - *---------------------------------------------------------------------------- - * Purpose: - * Returns the current polyphony setting of the stream - * - * Inputs: - * pEASData - pointer to overall EAS data structure - * streamHandle - handle returned by EAS_OpenFile - * pPolyphonyCount - pointer to variable to receive polyphony count - * - * Outputs: - * - * Side Effects: - * - *---------------------------------------------------------------------------- -*/ -EAS_PUBLIC EAS_RESULT EAS_GetPolyphony (EAS_DATA_HANDLE pEASData, EAS_HANDLE pStream, EAS_I32 *pPolyphonyCount) -{ - if (!EAS_StreamReady(pEASData, pStream)) - return EAS_ERROR_NOT_VALID_IN_THIS_STATE; - return EAS_IntGetStrmParam(pEASData, pStream, PARSER_DATA_POLYPHONY, pPolyphonyCount); -} - -/*---------------------------------------------------------------------------- - * EAS_SetSynthPolyphony() - *---------------------------------------------------------------------------- - * Purpose: - * Set the polyphony of the synth . Value must be >= 1 and <= the - * maximum number of voices. This function will pin the polyphony - * at those limits - * - * Inputs: - * pEASData - pointer to overall EAS data structure - * synthNum - synthesizer number (0 = onboard, 1 = DSP) - * polyphonyCount - the desired polyphony count - * - * Outputs: - * - * Side Effects: - * - *---------------------------------------------------------------------------- -*/ -EAS_PUBLIC EAS_RESULT EAS_SetSynthPolyphony (EAS_DATA_HANDLE pEASData, EAS_I32 synthNum, EAS_I32 polyphonyCount) -{ - return VMSetSynthPolyphony(pEASData->pVoiceMgr, synthNum, polyphonyCount); -} - -/*---------------------------------------------------------------------------- - * EAS_GetSynthPolyphony() - *---------------------------------------------------------------------------- - * Purpose: - * Returns the current polyphony setting of the synth - * - * Inputs: - * pEASData - pointer to overall EAS data structure - * synthNum - synthesizer number (0 = onboard, 1 = DSP) - * pPolyphonyCount - pointer to variable to receive polyphony count - * - * Outputs: - * - * Side Effects: - * - *---------------------------------------------------------------------------- -*/ -EAS_PUBLIC EAS_RESULT EAS_GetSynthPolyphony (EAS_DATA_HANDLE pEASData, EAS_I32 synthNum, EAS_I32 *pPolyphonyCount) -{ - return VMGetSynthPolyphony(pEASData->pVoiceMgr, synthNum, pPolyphonyCount); -} - -/*---------------------------------------------------------------------------- - * EAS_SetPriority() - *---------------------------------------------------------------------------- - * Purpose: - * Set the priority of the stream. Determines which stream's voices - * are stolen when there are insufficient voices for all notes. - * Value must be in the range of 1-15, lower values are higher - * priority. - * - * Inputs: - * pEASData - pointer to overall EAS data structure - * streamHandle - handle returned by EAS_OpenFile - * polyphonyCount - the desired polyphony count - * - * Outputs: - * - * Side Effects: - * - *---------------------------------------------------------------------------- -*/ -EAS_PUBLIC EAS_RESULT EAS_SetPriority (EAS_DATA_HANDLE pEASData, EAS_HANDLE pStream, EAS_I32 priority) -{ - if (!EAS_StreamReady(pEASData, pStream)) - return EAS_ERROR_NOT_VALID_IN_THIS_STATE; - return EAS_IntSetStrmParam(pEASData, pStream, PARSER_DATA_PRIORITY, priority); -} - -/*---------------------------------------------------------------------------- - * EAS_GetPriority() - *---------------------------------------------------------------------------- - * Purpose: - * Returns the current priority setting of the stream - * - * Inputs: - * pEASData - pointer to overall EAS data structure - * streamHandle - handle returned by EAS_OpenFile - * pPriority - pointer to variable to receive priority - * - * Outputs: - * - * Side Effects: - * - *---------------------------------------------------------------------------- -*/ -EAS_PUBLIC EAS_RESULT EAS_GetPriority (EAS_DATA_HANDLE pEASData, EAS_HANDLE pStream, EAS_I32 *pPriority) -{ - if (!EAS_StreamReady(pEASData, pStream)) - return EAS_ERROR_NOT_VALID_IN_THIS_STATE; - return EAS_IntGetStrmParam(pEASData, pStream, PARSER_DATA_PRIORITY, pPriority); -} - -/*---------------------------------------------------------------------------- - * EAS_SetVolume() - *---------------------------------------------------------------------------- - * Purpose: - * Set the master gain for the mix engine in 1dB increments - * - * Inputs: - * pEASData - pointer to overall EAS data structure - * volume - the desired master gain (100 is max) - * handle - file or stream handle - * - * Outputs: - * - * - * Side Effects: - * overrides any previously set master volume from sysex - * - *---------------------------------------------------------------------------- -*/ -EAS_PUBLIC EAS_RESULT EAS_SetVolume (EAS_DATA_HANDLE pEASData, EAS_HANDLE pStream, EAS_I32 volume) -{ - EAS_I16 gain; - - /* check range */ - if ((volume < 0) || (volume > EAS_MAX_VOLUME)) - return EAS_ERROR_PARAMETER_RANGE; - - /* stream volume */ - if (pStream != NULL) - { - EAS_I32 gainOffset; - EAS_RESULT result; - - if (!EAS_StreamReady(pEASData, pStream)) - return EAS_ERROR_NOT_VALID_IN_THIS_STATE; - - /* get gain offset */ - pStream->volume = (EAS_U8) volume; - result = EAS_GetStreamParameter(pEASData, pStream, PARSER_DATA_GAIN_OFFSET, &gainOffset); - if (result == EAS_SUCCESS) - volume += gainOffset; - - /* set stream volume */ - gain = EAS_VolumeToGain(volume - STREAM_VOLUME_HEADROOM); - - /* convert to linear scalar */ - return EAS_IntSetStrmParam(pEASData, pStream, PARSER_DATA_VOLUME, gain); - } - - /* master volume */ - pEASData->masterVolume = (EAS_U8) volume; -#if (NUM_OUTPUT_CHANNELS == 1) - /* leave 3dB headroom for mono output */ - volume -= 3; -#endif - - gain = EAS_VolumeToGain(volume - STREAM_VOLUME_HEADROOM); - pEASData->masterGain = gain; - return EAS_SUCCESS; -} - -/*---------------------------------------------------------------------------- - * EAS_GetVolume() - *---------------------------------------------------------------------------- - * Purpose: - * Returns the master volume for the synthesizer. The default volume setting is - * 50. The volume range is 0 to 100; - * - * Inputs: - * pEASData - pointer to overall EAS data structure - * volume - the desired master volume - * handle - file or stream handle - * - * Outputs: - * - * - * Side Effects: - * overrides any previously set master volume from sysex - * - *---------------------------------------------------------------------------- -*/ -EAS_PUBLIC EAS_I32 EAS_GetVolume (EAS_DATA_HANDLE pEASData, EAS_HANDLE pStream) -{ - if (pStream == NULL) - return pEASData->masterVolume; - - if (!EAS_StreamReady(pEASData, pStream)) - return EAS_ERROR_NOT_VALID_IN_THIS_STATE; - return pStream->volume; -} - -/*---------------------------------------------------------------------------- - * EAS_SetMaxLoad() - *---------------------------------------------------------------------------- - * Purpose: - * Sets the maximum workload the parsers will do in a single call to - * EAS_Render. The units are currently arbitrary, but should correlate - * well to the actual CPU cycles consumed. The primary effect is to - * reduce the occasional peaks in CPU cycles consumed when parsing - * dense parts of a MIDI score. - * - * Inputs: - * pEASData - handle to data for this instance - * maxLoad - the desired maximum workload - * - * Outputs: - * - * Side Effects: - * - *---------------------------------------------------------------------------- -*/ -EAS_PUBLIC EAS_RESULT EAS_SetMaxLoad (EAS_DATA_HANDLE pEASData, EAS_I32 maxLoad) -{ - VMSetWorkload(pEASData->pVoiceMgr, maxLoad); - return EAS_SUCCESS; -} - -/*---------------------------------------------------------------------------- - * EAS_SetMaxPCMStreams() - *---------------------------------------------------------------------------- - * Sets the maximum number of PCM streams allowed in parsers that - * use PCM streaming. - * - * Inputs: - * pEASData - pointer to overall EAS data structure - * streamHandle - handle returned by EAS_OpenFile - * maxNumStreams - maximum number of PCM streams - *---------------------------------------------------------------------------- -*/ -EAS_PUBLIC EAS_RESULT EAS_SetMaxPCMStreams (EAS_DATA_HANDLE pEASData, EAS_HANDLE pStream, EAS_I32 maxNumStreams) -{ - if (!EAS_StreamReady(pEASData, pStream)) - return EAS_ERROR_NOT_VALID_IN_THIS_STATE; - return EAS_IntSetStrmParam(pEASData, pStream, PARSER_DATA_MAX_PCM_STREAMS, maxNumStreams); -} - -/*---------------------------------------------------------------------------- - * EAS_Locate() - *---------------------------------------------------------------------------- - * Purpose: - * Locate into the file associated with the handle. - * - * Inputs: - * pEASData - pointer to overall EAS data structure - * handle - file handle - * milliseconds - playback offset from start of file in milliseconds - * - * Outputs: - * - * - * Side Effects: - * the actual offset will be quantized to the closest update period, typically - * a resolution of 5.9ms. Notes that are started prior to this time will not - * sound. Any notes currently playing will be shut off. - * - *---------------------------------------------------------------------------- -*/ -EAS_PUBLIC EAS_RESULT EAS_Locate (EAS_DATA_HANDLE pEASData, EAS_HANDLE pStream, EAS_I32 milliseconds, EAS_BOOL offset) -{ - S_FILE_PARSER_INTERFACE *pParserModule; - EAS_RESULT result; - EAS_U32 requestedTime; - EAS_STATE state; - - /* get pointer to parser function table */ - pParserModule = (S_FILE_PARSER_INTERFACE*) pStream->pParserModule; - if (pParserModule == NULL) - return EAS_ERROR_FEATURE_NOT_AVAILABLE; - - if ((result = (*pParserModule->pfState)(pEASData, pStream->handle, &state)) != EAS_SUCCESS) - return result; - if (state >= EAS_STATE_OPEN) - return EAS_ERROR_NOT_VALID_IN_THIS_STATE; - - /* handle offset and limit to start of file */ - /*lint -e{704} use shift for performance*/ - if (offset) - milliseconds += (EAS_I32) pStream->time >> 8; - if (milliseconds < 0) - milliseconds = 0; - - /* check to see if the request is different from the current time */ - requestedTime = (EAS_U32) milliseconds; - if (requestedTime == (pStream->time >> 8)) - return EAS_SUCCESS; - - /* set the locate flag */ - pStream->streamFlags |= STREAM_FLAGS_LOCATE; - - /* use the parser locate function, if available */ - if (pParserModule->pfLocate != NULL) - { - EAS_BOOL parserLocate = EAS_FALSE; - result = pParserModule->pfLocate(pEASData, pStream->handle, (EAS_I32) requestedTime, &parserLocate); - if (!parserLocate) - { - if (result == EAS_SUCCESS) - pStream->time = requestedTime << 8; - return result; - } - } - - /* if we were paused and not going to resume, set pause request flag */ - if (((state == EAS_STATE_PAUSING) || (state == EAS_STATE_PAUSED)) && ((pStream->streamFlags & STREAM_FLAGS_RESUME) == 0)) - pStream->streamFlags |= STREAM_FLAGS_PAUSE; - - /* reset the synth and parser */ - if ((result = (*pParserModule->pfReset)(pEASData, pStream->handle)) != EAS_SUCCESS) - return result; - pStream->time = 0; - - /* locating forward, clear parsed flag and parse data until we get to the requested location */ - if ((result = EAS_ParseEvents(pEASData, pStream, requestedTime << 8, eParserModeLocate)) != EAS_SUCCESS) - return result; - - return EAS_SUCCESS; -} - -/*---------------------------------------------------------------------------- - * EAS_GetLocation() - *---------------------------------------------------------------------------- - * Purpose: - * Returns the current playback offset - * - * Inputs: - * pEASData - pointer to overall EAS data structure - * handle - file handle - * - * Outputs: - * The offset in milliseconds from the start of the current sequence, quantized - * to the nearest update period. Actual resolution is typically 5.9 ms. - * - * Side Effects: - * - *---------------------------------------------------------------------------- -*/ -/*lint -esym(715, pEASData) reserved for future use */ -EAS_PUBLIC EAS_RESULT EAS_GetLocation (EAS_DATA_HANDLE pEASData, EAS_HANDLE pStream, EAS_I32 *pTime) -{ - if (!EAS_StreamReady(pEASData, pStream)) - return EAS_ERROR_NOT_VALID_IN_THIS_STATE; - - *pTime = pStream->time >> 8; - return EAS_SUCCESS; -} - -/*---------------------------------------------------------------------------- - * EAS_GetRenderTime() - *---------------------------------------------------------------------------- - * Purpose: - * Returns the current playback offset - * - * Inputs: - * pEASData - pointer to overall EAS data structure - * - * Outputs: - * Gets the render time clock in msecs. - * - * Side Effects: - * - *---------------------------------------------------------------------------- -*/ -EAS_PUBLIC EAS_RESULT EAS_GetRenderTime (EAS_DATA_HANDLE pEASData, EAS_I32 *pTime) -{ - *pTime = pEASData->renderTime >> 8; - return EAS_SUCCESS; -} - -/*---------------------------------------------------------------------------- - * EAS_Pause() - *---------------------------------------------------------------------------- - * Purpose: - * Pauses the playback of the data associated with this handle. The audio - * is gracefully ramped down to prevent clicks and pops. It may take several - * buffers of audio before the audio is muted. - * - * Inputs: - * psEASData - pointer to overall EAS data structure - * handle - file or stream handle - * - * Outputs: - * - * - * Side Effects: - * - * - *---------------------------------------------------------------------------- -*/ -EAS_PUBLIC EAS_RESULT EAS_Pause (EAS_DATA_HANDLE pEASData, EAS_HANDLE pStream) -{ - S_FILE_PARSER_INTERFACE *pParserModule; - EAS_STATE state; - EAS_RESULT result; - - pParserModule = (S_FILE_PARSER_INTERFACE*) pStream->pParserModule; - if (pParserModule == NULL) - return EAS_ERROR_FEATURE_NOT_AVAILABLE; - - /* check for valid state */ - result = pParserModule->pfState(pEASData, pStream->handle, &state); - if (result == EAS_SUCCESS) - { - if ((state != EAS_STATE_PLAY) && (state != EAS_STATE_READY) && ((pStream->streamFlags & STREAM_FLAGS_RESUME) == 0)) - return EAS_ERROR_NOT_VALID_IN_THIS_STATE; - - /* make sure parser implements pause */ - if (pParserModule->pfPause == NULL) - result = EAS_ERROR_NOT_IMPLEMENTED; - - /* clear resume flag */ - pStream->streamFlags &= ~STREAM_FLAGS_RESUME; - - /* set pause flag */ - pStream->streamFlags |= STREAM_FLAGS_PAUSE; - -#if 0 - /* pause the stream */ - if (pParserModule->pfPause) - result = pParserModule->pfPause(pEASData, pStream->handle); - else - result = EAS_ERROR_NOT_IMPLEMENTED; -#endif - } - - return result; -} - -/*---------------------------------------------------------------------------- - * EAS_Resume() - *---------------------------------------------------------------------------- - * Purpose: - * Resumes the playback of the data associated with this handle. The audio - * is gracefully ramped up to prevent clicks and pops. - * - * Inputs: - * psEASData - pointer to overall EAS data structure - * handle - file or stream handle - * - * Outputs: - * - * - * Side Effects: - * - * - *---------------------------------------------------------------------------- -*/ -EAS_PUBLIC EAS_RESULT EAS_Resume (EAS_DATA_HANDLE pEASData, EAS_HANDLE pStream) -{ - S_FILE_PARSER_INTERFACE *pParserModule; - EAS_STATE state; - EAS_RESULT result; - - pParserModule = (S_FILE_PARSER_INTERFACE*) pStream->pParserModule; - if (pParserModule == NULL) - return EAS_ERROR_FEATURE_NOT_AVAILABLE; - - /* check for valid state */ - result = pParserModule->pfState(pEASData, pStream->handle, &state); - if (result == EAS_SUCCESS) - { - if ((state != EAS_STATE_PAUSED) && (state != EAS_STATE_PAUSING) && ((pStream->streamFlags & STREAM_FLAGS_PAUSE) == 0)) - return EAS_ERROR_NOT_VALID_IN_THIS_STATE; - - /* make sure parser implements this function */ - if (pParserModule->pfResume == NULL) - result = EAS_ERROR_NOT_IMPLEMENTED; - - /* clear pause flag */ - pStream->streamFlags &= ~STREAM_FLAGS_PAUSE; - - /* set resume flag */ - pStream->streamFlags |= STREAM_FLAGS_RESUME; - -#if 0 - /* resume the stream */ - if (pParserModule->pfResume) - result = pParserModule->pfResume(pEASData, pStream->handle); - else - result = EAS_ERROR_NOT_IMPLEMENTED; -#endif - } - - return result; -} - -/*---------------------------------------------------------------------------- - * EAS_GetParameter() - *---------------------------------------------------------------------------- - * Purpose: - * Set the parameter of a module. See E_MODULES for a list of modules - * and the header files of the modules for a list of parameters. - * - * Inputs: - * psEASData - pointer to overall EAS data structure - * handle - file or stream handle - * module - enumerated module number - * param - enumerated parameter number - * pValue - pointer to variable to receive parameter value - * - * Outputs: - * - * - * Side Effects: - * - * - *---------------------------------------------------------------------------- -*/ -EAS_PUBLIC EAS_RESULT EAS_GetParameter (EAS_DATA_HANDLE pEASData, EAS_I32 module, EAS_I32 param, EAS_I32 *pValue) -{ - - if (module >= NUM_EFFECTS_MODULES) - return EAS_ERROR_INVALID_MODULE; - - if (pEASData->effectsModules[module].effectData == NULL) - return EAS_ERROR_INVALID_MODULE; - - return (*pEASData->effectsModules[module].effect->pFGetParam) - (pEASData->effectsModules[module].effectData, param, pValue); -} - -/*---------------------------------------------------------------------------- - * EAS_SetParameter() - *---------------------------------------------------------------------------- - * Purpose: - * Set the parameter of a module. See E_MODULES for a list of modules - * and the header files of the modules for a list of parameters. - * - * Inputs: - * psEASData - pointer to overall EAS data structure - * handle - file or stream handle - * module - enumerated module number - * param - enumerated parameter number - * value - new parameter value - * - * Outputs: - * - * - * Side Effects: - * - * - *---------------------------------------------------------------------------- -*/ -EAS_PUBLIC EAS_RESULT EAS_SetParameter (EAS_DATA_HANDLE pEASData, EAS_I32 module, EAS_I32 param, EAS_I32 value) -{ - - if (module >= NUM_EFFECTS_MODULES) - return EAS_ERROR_INVALID_MODULE; - - if (pEASData->effectsModules[module].effectData == NULL) - return EAS_ERROR_INVALID_MODULE; - - return (*pEASData->effectsModules[module].effect->pFSetParam) - (pEASData->effectsModules[module].effectData, param, value); -} - -#ifdef _METRICS_ENABLED -/*---------------------------------------------------------------------------- - * EAS_MetricsReport() - *---------------------------------------------------------------------------- - * Purpose: - * Displays the current metrics through the metrics interface. - * - * Inputs: - * p - instance data handle - * - * Outputs: - * - * - * Side Effects: - * - *---------------------------------------------------------------------------- -*/ -EAS_PUBLIC EAS_RESULT EAS_MetricsReport (EAS_DATA_HANDLE pEASData) -{ - if (!pEASData->pMetricsModule) - return EAS_ERROR_INVALID_MODULE; - - return (*pEASData->pMetricsModule->pfReport)(pEASData->pMetricsData); -} - -/*---------------------------------------------------------------------------- - * EAS_MetricsReset() - *---------------------------------------------------------------------------- - * Purpose: - * Resets the metrics. - * - * Inputs: - * p - instance data handle - * - * Outputs: - * - * - * Side Effects: - * - *---------------------------------------------------------------------------- -*/ -EAS_PUBLIC EAS_RESULT EAS_MetricsReset (EAS_DATA_HANDLE pEASData) -{ - - if (!pEASData->pMetricsModule) - return EAS_ERROR_INVALID_MODULE; - - return (*pEASData->pMetricsModule->pfReset)(pEASData->pMetricsData); -} -#endif - -/*---------------------------------------------------------------------------- - * EAS_SetSoundLibrary() - *---------------------------------------------------------------------------- - * Purpose: - * Sets the location of the sound library. - * - * Inputs: - * pEASData - instance data handle - * pSoundLib - pointer to sound library - * - * Outputs: - * - * - * Side Effects: - * - *---------------------------------------------------------------------------- -*/ -EAS_PUBLIC EAS_RESULT EAS_SetSoundLibrary (EAS_DATA_HANDLE pEASData, EAS_HANDLE pStream, EAS_SNDLIB_HANDLE pSndLib) -{ - if (pStream) - { - if (!EAS_StreamReady(pEASData, pStream)) - return EAS_ERROR_NOT_VALID_IN_THIS_STATE; - return EAS_IntSetStrmParam(pEASData, pStream, PARSER_DATA_EAS_LIBRARY, (EAS_I32) pSndLib); - } - - return VMSetGlobalEASLib(pEASData->pVoiceMgr, pSndLib); -} - -/*---------------------------------------------------------------------------- - * EAS_SetHeaderSearchFlag() - *---------------------------------------------------------------------------- - * By default, when EAS_OpenFile is called, the parsers check the - * first few bytes of the file looking for a specific header. Some - * mobile devices may add a header to the start of a file, which - * will prevent the parser from recognizing the file. If the - * searchFlag is set to EAS_TRUE, the parser will search the entire - * file looking for the header. This may enable EAS to recognize - * some files that it would ordinarily reject. The negative is that - * it make take slightly longer to process the EAS_OpenFile request. - * - * Inputs: - * pEASData - instance data handle - * searchFlag - search flag (EAS_TRUE or EAS_FALSE) - *---------------------------------------------------------------------------- -*/ -EAS_PUBLIC EAS_RESULT EAS_SetHeaderSearchFlag (EAS_DATA_HANDLE pEASData, EAS_BOOL searchFlag) -{ - pEASData->searchHeaderFlag = (EAS_BOOL8) searchFlag; - return EAS_SUCCESS; -} - -/*---------------------------------------------------------------------------- - * EAS_SetPlayMode() - *---------------------------------------------------------------------------- - * Some file formats support special play modes, such as iMode partial - * play mode. This call can be used to change the play mode. The - * default play mode (usually straight playback) is always zero. - * - * Inputs: - * pEASData - instance data handle - * handle - file or stream handle - * playMode - play mode (see file parser for specifics) - *---------------------------------------------------------------------------- -*/ -EAS_PUBLIC EAS_RESULT EAS_SetPlayMode (EAS_DATA_HANDLE pEASData, EAS_HANDLE pStream, EAS_I32 playMode) -{ - return EAS_IntSetStrmParam(pEASData, pStream, PARSER_DATA_PLAY_MODE, playMode); -} - -#ifdef DLS_SYNTHESIZER -/*---------------------------------------------------------------------------- - * EAS_LoadDLSCollection() - *---------------------------------------------------------------------------- - * Purpose: - * Sets the location of the sound library. - * - * Inputs: - * pEASData - instance data handle - * pSoundLib - pointer to sound library - * - * Outputs: - * - * - * Side Effects: - * - *---------------------------------------------------------------------------- -*/ -EAS_PUBLIC EAS_RESULT EAS_LoadDLSCollection (EAS_DATA_HANDLE pEASData, EAS_HANDLE pStream, EAS_FILE_LOCATOR locator) -{ - EAS_FILE_HANDLE fileHandle; - EAS_RESULT result; - EAS_DLSLIB_HANDLE pDLS; - - if (pStream != NULL) - { - if (!EAS_StreamReady(pEASData, pStream)) - return EAS_ERROR_NOT_VALID_IN_THIS_STATE; - } - - /* open the file */ - if ((result = EAS_HWOpenFile(pEASData->hwInstData, locator, &fileHandle, EAS_FILE_READ)) != EAS_SUCCESS) - return result; - - /* parse the file */ - result = DLSParser(pEASData->hwInstData, fileHandle, 0, &pDLS); - EAS_HWCloseFile(pEASData->hwInstData, fileHandle); - - if (result == EAS_SUCCESS) - { - - /* if a stream pStream is specified, point it to the DLS collection */ - if (pStream) - result = EAS_IntSetStrmParam(pEASData, pStream, PARSER_DATA_DLS_COLLECTION, (EAS_I32) pDLS); - - /* global DLS load */ - else - result = VMSetGlobalDLSLib(pEASData, pDLS); - } - - return result; -} -#endif - -#ifdef EXTERNAL_AUDIO -/*---------------------------------------------------------------------------- - * EAS_RegExtAudioCallback() - *---------------------------------------------------------------------------- - * Purpose: - * Registers callback functions for audio events. - * - * Inputs: - * pEASData - pointer to overall EAS data structure - * handle - file or stream handle - * cbProgChgFunc - pointer to host callback function for program change - * cbEventFunc - pointer to host callback functio for note events - * - * Outputs: - * - * - * Side Effects: - * - *---------------------------------------------------------------------------- -*/ -EAS_PUBLIC EAS_RESULT EAS_RegExtAudioCallback (EAS_DATA_HANDLE pEASData, - EAS_HANDLE pStream, - EAS_VOID_PTR pInstData, - EAS_EXT_PRG_CHG_FUNC cbProgChgFunc, - EAS_EXT_EVENT_FUNC cbEventFunc) -{ - S_SYNTH *pSynth; - - if (!EAS_StreamReady(pEASData, pStream)) - return EAS_ERROR_NOT_VALID_IN_THIS_STATE; - - if (EAS_GetStreamParameter(pEASData, pStream, PARSER_DATA_SYNTH_HANDLE, (EAS_I32*) &pSynth) != EAS_SUCCESS) - return EAS_ERROR_INVALID_PARAMETER; - - if (pSynth == NULL) - return EAS_ERROR_INVALID_PARAMETER; - - VMRegExtAudioCallback(pSynth, pInstData, cbProgChgFunc, cbEventFunc); - return EAS_SUCCESS; -} - -/*---------------------------------------------------------------------------- - * EAS_GetMIDIControllers() - *---------------------------------------------------------------------------- - * Purpose: - * Returns the current state of MIDI controllers on the requested channel. - * - * Inputs: - * pEASData - pointer to overall EAS data structure - * handle - file or stream handle - * pControl - pointer to structure to receive data - * - * Outputs: - * - * - * Side Effects: - * - *---------------------------------------------------------------------------- -*/ -EAS_PUBLIC EAS_RESULT EAS_GetMIDIControllers (EAS_DATA_HANDLE pEASData, EAS_HANDLE pStream, EAS_U8 channel, S_MIDI_CONTROLLERS *pControl) -{ - S_SYNTH *pSynth; - - if (!EAS_StreamReady(pEASData, pStream)) - return EAS_ERROR_NOT_VALID_IN_THIS_STATE; - - if (EAS_GetStreamParameter(pEASData, pStream, PARSER_DATA_SYNTH_HANDLE, (EAS_I32*) &pSynth) != EAS_SUCCESS) - return EAS_ERROR_INVALID_PARAMETER; - - if (pSynth == NULL) - return EAS_ERROR_INVALID_PARAMETER; - - VMGetMIDIControllers(pSynth, channel, pControl); - return EAS_SUCCESS; -} -#endif - -#ifdef _SPLIT_ARCHITECTURE -/*---------------------------------------------------------------------------- - * EAS_SetFrameBuffer() - *---------------------------------------------------------------------------- - * Purpose: - * Sets the frame buffer pointer passed to the IPC communications functions - * - * Inputs: - * pEASData - instance data handle - * locator - file locator - * - * Outputs: - * - * - * Side Effects: - * May overlay instruments in the GM sound set - * - *---------------------------------------------------------------------------- -*/ -EAS_PUBLIC EAS_RESULT EAS_SetFrameBuffer (EAS_DATA_HANDLE pEASData, EAS_FRAME_BUFFER_HANDLE pFrameBuffer) -{ - if (pEASData->pVoiceMgr) - pEASData->pVoiceMgr->pFrameBuffer = pFrameBuffer; - return EAS_SUCCESS; -} -#endif - -/*---------------------------------------------------------------------------- - * EAS_SearchFile - *---------------------------------------------------------------------------- - * Search file for specific sequence starting at current file - * position. Returns offset to start of sequence. - * - * Inputs: - * pEASData - pointer to EAS persistent data object - * fileHandle - file handle - * searchString - pointer to search sequence - * len - length of search sequence - * pOffset - pointer to variable to store offset to sequence - * - * Returns EAS_EOF if end-of-file is reached - *---------------------------------------------------------------------------- -*/ -EAS_RESULT EAS_SearchFile (S_EAS_DATA *pEASData, EAS_FILE_HANDLE fileHandle, const EAS_U8 *searchString, EAS_I32 len, EAS_I32 *pOffset) -{ - EAS_RESULT result; - EAS_INT index; - EAS_U8 c; - - *pOffset = -1; - index = 0; - for (;;) - { - result = EAS_HWGetByte(pEASData->hwInstData, fileHandle, &c); - if (result != EAS_SUCCESS) - return result; - if (c == searchString[index]) - { - index++; - if (index == 4) - { - result = EAS_HWFilePos(pEASData->hwInstData, fileHandle, pOffset); - if (result != EAS_SUCCESS) - return result; - *pOffset -= len; - break; - } - } - else - index = 0; - } - return EAS_SUCCESS; -} - - |