/*---------------------------------------------------------------------------- * * File: * eas_config.c * * Contents and purpose: * This file contains the Configuration Module interface (CM). The CM * is a module compiled external to the library that sets the configuration * for this build. It allows the library to find optional components and * links to static memory allocations (when used in a static configuration). * * DO NOT MODIFY THIS FILE! * * NOTE: This module is not intended to be modified by the customer. It * needs to be included in the build process with the correct configuration * defines (see the library documentation for information on how to configure * the library). * * Copyright Sonic Network Inc. 2004-2006 * 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: 796 $ * $Date: 2007-08-01 00:15:25 -0700 (Wed, 01 Aug 2007) $ *---------------------------------------------------------------------------- */ #include "eas.h" #include "eas_config.h" #ifdef _MFI_PARSER /*---------------------------------------------------------------------------- * Vendor/Device ID for MFi Extensions * * Define the preprocessor symbols to establish the vendor ID and * device ID for the MFi PCM/ADPCM extensions. *---------------------------------------------------------------------------- */ const EAS_U8 eas_MFIVendorIDMSB = (MFI_VENDOR_ID >> 8) & 0xff; const EAS_U8 eas_MFIVendorIDLSB = MFI_VENDOR_ID & 0xff; const EAS_U8 eas_MFIDeviceID = MFI_DEVICE_ID; #endif /*---------------------------------------------------------------------------- * * parserModules * * This structure is used by the EAS library to locate file parsing * modules. *---------------------------------------------------------------------------- */ /* define the external file parsers */ extern EAS_VOID_PTR EAS_SMF_Parser; #ifdef _XMF_PARSER extern EAS_VOID_PTR EAS_XMF_Parser; #endif #ifdef _SMAF_PARSER extern EAS_VOID_PTR EAS_SMAF_Parser; #endif #ifdef _WAVE_PARSER extern EAS_VOID_PTR EAS_Wave_Parser; #endif #ifdef _OTA_PARSER extern EAS_VOID_PTR EAS_OTA_Parser; #endif #ifdef _IMELODY_PARSER extern EAS_VOID_PTR EAS_iMelody_Parser; #endif #ifdef _RTTTL_PARSER extern EAS_VOID_PTR EAS_RTTTL_Parser; #endif #if defined (_CMX_PARSER) || defined(_MFI_PARSER) extern EAS_VOID_PTR EAS_CMF_Parser; #endif /* initalize pointers to parser interfaces */ /*lint -e{605} not pretty, but it works */ EAS_VOID_PTR const parserModules[] = { &EAS_SMF_Parser, #ifdef _XMF_PARSER &EAS_XMF_Parser, #endif #ifdef _WAVE_PARSER &EAS_Wave_Parser, #endif #ifdef _SMAF_PARSER &EAS_SMAF_Parser, #endif #ifdef _OTA_PARSER &EAS_OTA_Parser, #endif #ifdef _IMELODY_PARSER &EAS_iMelody_Parser, #endif #ifdef _RTTTL_PARSER &EAS_RTTTL_Parser, #endif #if defined (_CMX_PARSER) || defined(_MFI_PARSER) &EAS_CMF_Parser #endif }; #define NUM_PARSER_MODULES (sizeof(parserModules) / sizeof(EAS_VOID_PTR)) /*---------------------------------------------------------------------------- * Data Modules *---------------------------------------------------------------------------- */ #ifdef _STATIC_MEMORY extern EAS_VOID_PTR eas_SMFData; extern EAS_VOID_PTR eas_Data; extern EAS_VOID_PTR eas_MixBuffer; extern EAS_VOID_PTR eas_Synth; extern EAS_VOID_PTR eas_MIDI; extern EAS_VOID_PTR eas_PCMData; extern EAS_VOID_PTR eas_MIDIData; #ifdef _XMF_PARSER extern EAS_VOID_PTR eas_XMFData; #endif #ifdef _SMAF_PARSER extern EAS_VOID_PTR eas_SMAFData; #endif #ifdef _OTA_PARSER extern EAS_VOID_PTR eas_OTAData; #endif #ifdef _IMELODY_PARSER extern EAS_VOID_PTR eas_iMelodyData; #endif #ifdef _RTTTL_PARSER extern EAS_VOID_PTR eas_RTTTLData; #endif #ifdef _WAVE_PARSER extern EAS_VOID_PTR eas_WaveData; #endif #if defined (_CMX_PARSER) || defined(_MFI_PARSER) extern EAS_VOID_PTR eas_CMFData; #endif #endif /*---------------------------------------------------------------------------- * * Effects Modules * * These declarations are used by the EAS library to locate * effects modules. *---------------------------------------------------------------------------- */ #ifdef _ENHANCER_ENABLED extern EAS_VOID_PTR EAS_Enhancer; #define EAS_ENHANCER_INTERFACE &EAS_Enhancer #ifdef _STATIC_MEMORY extern EAS_VOID_PTR eas_EnhancerData; #define EAS_ENHANCER_DATA &eas_EnhancerData #else #define EAS_ENHANCER_DATA NULL #endif #else #define EAS_ENHANCER_INTERFACE NULL #define EAS_ENHANCER_DATA NULL #endif #ifdef _COMPRESSOR_ENABLED extern EAS_VOID_PTR EAS_Compressor; #define EAS_COMPRESSOR_INTERFACE &EAS_Compressor #ifdef _STATIC_MEMORY extern EAS_VOID_PTR eas_CompressorData; #define EAS_COMPRESSOR_DATA &eas_CompressorData #else #define EAS_COMPRESSOR_DATA NULL #endif #else #define EAS_COMPRESSOR_INTERFACE NULL #define EAS_COMPRESSOR_DATA NULL #endif #ifdef _MAXIMIZER_ENABLED extern EAS_VOID_PTR EAS_Maximizer; #define EAS_MAXIMIZER_INTERFACE &EAS_Maximizer #ifdef _STATIC_MEMORY extern EAS_VOID_PTR eas_MaximizerData; #define EAS_MAXIMIZER_DATA &eas_MaximizerData #else #define EAS_MAXIMIZER_DATA NULL #endif #else #define EAS_MAXIMIZER_INTERFACE NULL #define EAS_MAXIMIZER_DATA NULL #endif #ifdef _REVERB_ENABLED extern EAS_VOID_PTR EAS_Reverb; #define EAS_REVERB_INTERFACE &EAS_Reverb #ifdef _STATIC_MEMORY extern EAS_VOID_PTR eas_ReverbData; #define EAS_REVERB_DATA &eas_ReverbData #else #define EAS_REVERB_DATA NULL #endif #else #define EAS_REVERB_INTERFACE NULL #define EAS_REVERB_DATA NULL #endif #ifdef _CHORUS_ENABLED extern EAS_VOID_PTR EAS_Chorus; #define EAS_CHORUS_INTERFACE &EAS_Chorus #ifdef _STATIC_MEMORY extern EAS_VOID_PTR eas_ChorusData; #define EAS_CHORUS_DATA &eas_ChorusData #else #define EAS_CHORUS_DATA NULL #endif #else #define EAS_CHORUS_INTERFACE NULL #define EAS_CHORUS_DATA NULL #endif #ifdef _WIDENER_ENABLED extern EAS_VOID_PTR EAS_Widener; #define EAS_WIDENER_INTERFACE &EAS_Widener #ifdef _STATIC_MEMORY extern EAS_VOID_PTR eas_WidenerData; #define EAS_WIDENER_DATA &eas_WidenerData #else #define EAS_WIDENER_DATA NULL #endif #else #define EAS_WIDENER_INTERFACE NULL #define EAS_WIDENER_DATA NULL #endif #ifdef _GRAPHIC_EQ_ENABLED extern EAS_VOID_PTR EAS_GraphicEQ; #define EAS_GRAPHIC_EQ_INTERFACE &EAS_GraphicEQ #ifdef _STATIC_MEMORY extern EAS_VOID_PTR eas_GraphicEQData; #define EAS_GRAPHIC_EQ_DATA &eas_GraphicEQData #else #define EAS_GRAPHIC_EQ_DATA NULL #endif #else #define EAS_GRAPHIC_EQ_INTERFACE NULL #define EAS_GRAPHIC_EQ_DATA NULL #endif #ifdef _WOW_ENABLED extern EAS_VOID_PTR EAS_Wow; #define EAS_WOW_INTERFACE &EAS_Wow #ifdef _STATIC_MEMORY #error "WOW module requires dynamic memory model" #else #define EAS_WOW_DATA NULL #endif #else #define EAS_WOW_INTERFACE NULL #define EAS_WOW_DATA NULL #endif #ifdef _TONECONTROLEQ_ENABLED extern EAS_VOID_PTR EAS_ToneControlEQ; #define EAS_TONECONTROLEQ_INTERFACE &EAS_ToneControlEQ #ifdef _STATIC_MEMORY extern EAS_VOID_PTR eas_ToneControlEQData; #define EAS_TONECONTROLEQ_DATA &eas_ToneControlEQData #else #define EAS_TONECONTROLEQ_DATA NULL #endif #else #define EAS_TONECONTROLEQ_INTERFACE NULL #define EAS_TONECONTROLEQ_DATA NULL #endif /*lint -e{605} not pretty, but it works */ EAS_VOID_PTR const effectsModules[] = { EAS_ENHANCER_INTERFACE, EAS_COMPRESSOR_INTERFACE, EAS_REVERB_INTERFACE, EAS_CHORUS_INTERFACE, EAS_WIDENER_INTERFACE, EAS_GRAPHIC_EQ_INTERFACE, EAS_WOW_INTERFACE, EAS_MAXIMIZER_INTERFACE, EAS_TONECONTROLEQ_INTERFACE }; EAS_VOID_PTR const effectsData[] = { EAS_ENHANCER_DATA, EAS_COMPRESSOR_DATA, EAS_REVERB_DATA, EAS_CHORUS_DATA, EAS_WIDENER_DATA, EAS_GRAPHIC_EQ_DATA, EAS_WOW_DATA, EAS_MAXIMIZER_DATA, EAS_TONECONTROLEQ_DATA }; /*---------------------------------------------------------------------------- * * Optional Modules * * These declarations are used by the EAS library to locate * effects modules. *---------------------------------------------------------------------------- */ #ifdef _METRICS_ENABLED extern EAS_VOID_PTR EAS_Metrics; #define EAS_METRICS_INTERFACE &EAS_Metrics #ifdef _STATIC_MEMORY extern EAS_VOID_PTR eas_MetricsData; #define EAS_METRICS_DATA &eas_MetricsData #else #define EAS_METRICS_DATA NULL #endif #else #define EAS_METRICS_INTERFACE NULL #define EAS_METRICS_DATA NULL #endif #ifdef MMAPI_SUPPORT extern EAS_VOID_PTR EAS_TC_Parser; #define EAS_TONE_CONTROL_PARSER &EAS_TC_Parser #ifdef _STATIC_MEMORY extern EAS_VOID_PTR eas_TCData; #define EAS_TONE_CONTROL_DATA &eas_TCData #else #define EAS_TONE_CONTROL_DATA NULL #endif #else #define EAS_TONE_CONTROL_PARSER NULL #define EAS_TONE_CONTROL_DATA NULL #endif /*lint -e{605} not pretty, but it works */ EAS_VOID_PTR const optionalModules[] = { EAS_TONE_CONTROL_PARSER, EAS_METRICS_INTERFACE }; EAS_VOID_PTR const optionalData[] = { EAS_TONE_CONTROL_DATA, EAS_METRICS_DATA }; /*---------------------------------------------------------------------------- * EAS_CMStaticMemoryModel() *---------------------------------------------------------------------------- * Purpose: * This function returns true if EAS has been configured for * a static memory model. There are some limitations in the * static memory model, see the documentation for more * information. * * Outputs: * returns EAS_TRUE if a module is found *---------------------------------------------------------------------------- */ EAS_BOOL EAS_CMStaticMemoryModel (void) { #ifdef _STATIC_MEMORY return EAS_TRUE; #else return EAS_FALSE; #endif } /*---------------------------------------------------------------------------- * EAS_CMEnumModules() *---------------------------------------------------------------------------- * Purpose: * This function is used to find pointers to optional modules. * * Inputs: * module - module number * * Outputs: * returns a pointer to the module function table or NULL if no module *---------------------------------------------------------------------------- */ EAS_VOID_PTR EAS_CMEnumModules (EAS_INT module) { if (module >= (EAS_INT) NUM_PARSER_MODULES) return NULL; return parserModules[module]; } /*---------------------------------------------------------------------------- * EAS_CMEnumData() *---------------------------------------------------------------------------- * Purpose: * This function is used to find pointers to static memory allocations. * * Inputs: * dataModule - enumerated module number * * Outputs: * Returns handle to data or NULL if not found *---------------------------------------------------------------------------- */ /*lint -esym(715, dataModule) used only when _STATIC_MEMORY is defined */ EAS_VOID_PTR EAS_CMEnumData (EAS_INT dataModule) { #ifdef _STATIC_MEMORY switch (dataModule) { /* main instance data for synthesizer */ case EAS_CM_EAS_DATA: return &eas_Data; /* mix buffer for mix engine */ case EAS_CM_MIX_BUFFER: /*lint -e{545} lint doesn't like this because it sees the underlying type */ return &eas_MixBuffer; /* instance data for synth */ case EAS_CM_SYNTH_DATA: return &eas_Synth; /* instance data for MIDI parser */ case EAS_CM_MIDI_DATA: return &eas_MIDI; /* instance data for SMF parser */ case EAS_CM_SMF_DATA: return &eas_SMFData; #ifdef _XMF_PARSER /* instance data for XMF parser */ case EAS_CM_XMF_DATA: return &eas_XMFData; #endif #ifdef _SMAF_PARSER /* instance data for SMAF parser */ case EAS_CM_SMAF_DATA: return &eas_SMAFData; #endif /* instance data for the PCM engine */ case EAS_CM_PCM_DATA: /*lint -e{545} lint doesn't like this because it sees the underlying type */ return &eas_PCMData; case EAS_CM_MIDI_STREAM_DATA: return &eas_MIDIData; #ifdef _OTA_PARSER /* instance data for OTA parser */ case EAS_CM_OTA_DATA: return &eas_OTAData; #endif #ifdef _IMELODY_PARSER /* instance data for iMelody parser */ case EAS_CM_IMELODY_DATA: return &eas_iMelodyData; #endif #ifdef _RTTTL_PARSER /* instance data for RTTTL parser */ case EAS_CM_RTTTL_DATA: return &eas_RTTTLData; #endif #ifdef _WAVE_PARSER /* instance data for WAVE parser */ case EAS_CM_WAVE_DATA: return &eas_WaveData; #endif #if defined (_CMX_PARSER) || defined(_MFI_PARSER) /* instance data for CMF parser */ case EAS_CM_CMF_DATA: return &eas_CMFData; #endif default: return NULL; } #else return NULL; #endif } /*---------------------------------------------------------------------------- * EAS_CMEnumFXModules() *---------------------------------------------------------------------------- * Purpose: * This function is used to find pointers to optional effects modules. * * Inputs: * module - enumerated module number * pModule - pointer to module interface * * Outputs: * Returns pointer to function table or NULL if not found *---------------------------------------------------------------------------- */ EAS_VOID_PTR EAS_CMEnumFXModules (EAS_INT module) { if (module >= NUM_EFFECTS_MODULES) return NULL; return effectsModules[module]; } /*---------------------------------------------------------------------------- * EAS_CMEnumFXData() *---------------------------------------------------------------------------- * Purpose: * This function is used to find pointers to static memory allocations. * * Inputs: * dataModule - enumerated module number * pData - pointer to handle variable * * Outputs: * Returns handle to data or NULL if not found *---------------------------------------------------------------------------- */ EAS_VOID_PTR EAS_CMEnumFXData (EAS_INT dataModule) { if (dataModule >= NUM_EFFECTS_MODULES) return NULL; return effectsData[dataModule]; } /*---------------------------------------------------------------------------- * EAS_CMEnumOptModules() *---------------------------------------------------------------------------- * Purpose: * This function is used to find pointers to optional modules. * * Inputs: * module - enumerated module number * * Outputs: * returns pointer to function table or NULL if no module *---------------------------------------------------------------------------- */ EAS_VOID_PTR EAS_CMEnumOptModules (EAS_INT module) { /* sanity check */ if (module >= NUM_OPTIONAL_MODULES) return EAS_FALSE; return optionalModules[module]; } /*---------------------------------------------------------------------------- * EAS_CMEnumOptData() *---------------------------------------------------------------------------- * Purpose: * This function is used to find pointers to static memory allocations. * * Inputs: * dataModule - enumerated module number * * Outputs: * Returns handle to data or NULL if not found *---------------------------------------------------------------------------- */ EAS_VOID_PTR EAS_CMEnumOptData (EAS_INT dataModule) { if (dataModule >= NUM_OPTIONAL_MODULES) return NULL; return optionalData[dataModule]; }