/*----------------------------------------------------------------------------
*
* 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)
{
/* Closing the opened file as stream allocation failed */
EAS_HWCloseFile(pEASData->hwInstData, fileHandle);
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)
{
/* Closing the opened file as file type check failed */
EAS_HWCloseFile(pEASData->hwInstData, fileHandle);
{ /* 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)
{
/* Closing the opened file as file seek failed */
EAS_HWCloseFile(pEASData->hwInstData, fileHandle);
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 paused or pausing, we don't need to hide state from host */
if (*pState != EAS_STATE_PAUSED && *pState != EAS_STATE_PAUSING)
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;
}