Home | History | Annotate | Download | only in host_src 
      1 /*----------------------------------------------------------------------------
      2  *
      3  * File:
      4  * eas_config.c
      5  *
      6  * Contents and purpose:
      7  * This file contains the Configuration Module interface (CM). The CM
      8  * is a module compiled external to the library that sets the configuration
      9  * for this build. It allows the library to find optional components and
     10  * links to static memory allocations (when used in a static configuration).
     11  *
     12  * DO NOT MODIFY THIS FILE!
     13  *
     14  * NOTE: This module is not intended to be modified by the customer. It
     15  * needs to be included in the build process with the correct configuration
     16  * defines (see the library documentation for information on how to configure
     17  * the library).
     18  *
     19  * Copyright Sonic Network Inc. 2004-2006
     20 
     21  * Licensed under the Apache License, Version 2.0 (the "License");
     22  * you may not use this file except in compliance with the License.
     23  * You may obtain a copy of the License at
     24  *
     25  *      http://www.apache.org/licenses/LICENSE-2.0
     26  *
     27  * Unless required by applicable law or agreed to in writing, software
     28  * distributed under the License is distributed on an "AS IS" BASIS,
     29  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     30  * See the License for the specific language governing permissions and
     31  * limitations under the License.
     32  *
     33  *----------------------------------------------------------------------------
     34  * Revision Control:
     35  *   $Revision: 796 $
     36  *   $Date: 2007-08-01 00:15:25 -0700 (Wed, 01 Aug 2007) $
     37  *----------------------------------------------------------------------------
     38 */
     39 
     40 #include "eas.h"
     41 #include "eas_config.h"
     42 
     43 
     44 #ifdef _MFI_PARSER
     45 /*----------------------------------------------------------------------------
     46  * Vendor/Device ID for MFi Extensions
     47  *
     48  * Define the preprocessor symbols to establish the vendor ID and
     49  * device ID for the MFi PCM/ADPCM extensions.
     50  *----------------------------------------------------------------------------
     51 */
     52 const EAS_U8 eas_MFIVendorIDMSB = (MFI_VENDOR_ID >> 8) & 0xff;
     53 const EAS_U8 eas_MFIVendorIDLSB = MFI_VENDOR_ID & 0xff;
     54 const EAS_U8 eas_MFIDeviceID = MFI_DEVICE_ID;
     55 #endif
     56 
     57 /*----------------------------------------------------------------------------
     58  *
     59  * parserModules
     60  *
     61  * This structure is used by the EAS library to locate file parsing
     62  * modules.
     63  *----------------------------------------------------------------------------
     64 */
     65 
     66 /* define the external file parsers */
     67 extern EAS_VOID_PTR EAS_SMF_Parser;
     68 
     69 #ifdef _XMF_PARSER
     70 extern EAS_VOID_PTR EAS_XMF_Parser;
     71 #endif
     72 
     73 #ifdef _SMAF_PARSER
     74 extern EAS_VOID_PTR EAS_SMAF_Parser;
     75 #endif
     76 
     77 #ifdef _WAVE_PARSER
     78 extern EAS_VOID_PTR EAS_Wave_Parser;
     79 #endif
     80 
     81 #ifdef _OTA_PARSER
     82 extern EAS_VOID_PTR EAS_OTA_Parser;
     83 #endif
     84 
     85 #ifdef _IMELODY_PARSER
     86 extern EAS_VOID_PTR EAS_iMelody_Parser;
     87 #endif
     88 
     89 #ifdef _RTTTL_PARSER
     90 extern EAS_VOID_PTR EAS_RTTTL_Parser;
     91 #endif
     92 
     93 #if defined (_CMX_PARSER) || defined(_MFI_PARSER)
     94 extern EAS_VOID_PTR EAS_CMF_Parser;
     95 #endif
     96 
     97 /* initalize pointers to parser interfaces */
     98 /*lint -e{605} not pretty, but it works */
     99 EAS_VOID_PTR const parserModules[] =
    100 {
    101     &EAS_SMF_Parser,
    102 
    103 #ifdef _XMF_PARSER
    104     &EAS_XMF_Parser,
    105 #endif
    106 
    107 #ifdef _WAVE_PARSER
    108     &EAS_Wave_Parser,
    109 #endif
    110 
    111 #ifdef _SMAF_PARSER
    112     &EAS_SMAF_Parser,
    113 #endif
    114 
    115 #ifdef _OTA_PARSER
    116     &EAS_OTA_Parser,
    117 #endif
    118 
    119 #ifdef _IMELODY_PARSER
    120     &EAS_iMelody_Parser,
    121 #endif
    122 
    123 #ifdef _RTTTL_PARSER
    124     &EAS_RTTTL_Parser,
    125 #endif
    126 
    127 #if defined (_CMX_PARSER) || defined(_MFI_PARSER)
    128     &EAS_CMF_Parser
    129 #endif
    130 };
    131 #define NUM_PARSER_MODULES (sizeof(parserModules) / sizeof(EAS_VOID_PTR))
    132 
    133 /*----------------------------------------------------------------------------
    134  * Data Modules
    135  *----------------------------------------------------------------------------
    136 */
    137 
    138 #ifdef _STATIC_MEMORY
    139 extern EAS_VOID_PTR eas_SMFData;
    140 extern EAS_VOID_PTR eas_Data;
    141 extern EAS_VOID_PTR eas_MixBuffer;
    142 extern EAS_VOID_PTR eas_Synth;
    143 extern EAS_VOID_PTR eas_MIDI;
    144 extern EAS_VOID_PTR eas_PCMData;
    145 extern EAS_VOID_PTR eas_MIDIData;
    146 
    147 #ifdef _XMF_PARSER
    148 extern EAS_VOID_PTR eas_XMFData;
    149 #endif
    150 
    151 #ifdef _SMAF_PARSER
    152 extern EAS_VOID_PTR eas_SMAFData;
    153 #endif
    154 
    155 #ifdef _OTA_PARSER
    156 extern EAS_VOID_PTR eas_OTAData;
    157 #endif
    158 
    159 #ifdef _IMELODY_PARSER
    160 extern EAS_VOID_PTR eas_iMelodyData;
    161 #endif
    162 
    163 #ifdef _RTTTL_PARSER
    164 extern EAS_VOID_PTR eas_RTTTLData;
    165 #endif
    166 
    167 #ifdef _WAVE_PARSER
    168 extern EAS_VOID_PTR eas_WaveData;
    169 #endif
    170 
    171 #if defined (_CMX_PARSER) || defined(_MFI_PARSER)
    172 extern EAS_VOID_PTR eas_CMFData;
    173 #endif
    174 #endif
    175 
    176 /*----------------------------------------------------------------------------
    177  *
    178  * Effects Modules
    179  *
    180  * These declarations are used by the EAS library to locate
    181  * effects modules.
    182  *----------------------------------------------------------------------------
    183 */
    184 
    185 #ifdef _ENHANCER_ENABLED
    186 extern EAS_VOID_PTR                 EAS_Enhancer;
    187 #define EAS_ENHANCER_INTERFACE      &EAS_Enhancer
    188 #ifdef _STATIC_MEMORY
    189 extern EAS_VOID_PTR                 eas_EnhancerData;
    190 #define EAS_ENHANCER_DATA           &eas_EnhancerData
    191 #else
    192 #define EAS_ENHANCER_DATA           NULL
    193 #endif
    194 #else
    195 #define EAS_ENHANCER_INTERFACE      NULL
    196 #define EAS_ENHANCER_DATA           NULL
    197 #endif
    198 
    199 #ifdef _COMPRESSOR_ENABLED
    200 extern EAS_VOID_PTR                 EAS_Compressor;
    201 #define EAS_COMPRESSOR_INTERFACE    &EAS_Compressor
    202 #ifdef _STATIC_MEMORY
    203 extern EAS_VOID_PTR                 eas_CompressorData;
    204 #define EAS_COMPRESSOR_DATA         &eas_CompressorData
    205 #else
    206 #define EAS_COMPRESSOR_DATA         NULL
    207 #endif
    208 #else
    209 #define EAS_COMPRESSOR_INTERFACE    NULL
    210 #define EAS_COMPRESSOR_DATA         NULL
    211 #endif
    212 
    213 #ifdef _MAXIMIZER_ENABLED
    214 extern EAS_VOID_PTR                 EAS_Maximizer;
    215 #define EAS_MAXIMIZER_INTERFACE     &EAS_Maximizer
    216 #ifdef _STATIC_MEMORY
    217 extern EAS_VOID_PTR                 eas_MaximizerData;
    218 #define EAS_MAXIMIZER_DATA          &eas_MaximizerData
    219 #else
    220 #define EAS_MAXIMIZER_DATA          NULL
    221 #endif
    222 #else
    223 #define EAS_MAXIMIZER_INTERFACE NULL
    224 #define EAS_MAXIMIZER_DATA          NULL
    225 #endif
    226 
    227 
    228 #ifdef _REVERB_ENABLED
    229 extern EAS_VOID_PTR                 EAS_Reverb;
    230 #define EAS_REVERB_INTERFACE        &EAS_Reverb
    231 #ifdef _STATIC_MEMORY
    232 extern EAS_VOID_PTR                 eas_ReverbData;
    233 #define EAS_REVERB_DATA             &eas_ReverbData
    234 #else
    235 #define EAS_REVERB_DATA             NULL
    236 #endif
    237 #else
    238 #define EAS_REVERB_INTERFACE        NULL
    239 #define EAS_REVERB_DATA             NULL
    240 #endif
    241 
    242 #ifdef _CHORUS_ENABLED
    243 extern EAS_VOID_PTR                 EAS_Chorus;
    244 #define EAS_CHORUS_INTERFACE        &EAS_Chorus
    245 #ifdef _STATIC_MEMORY
    246 extern EAS_VOID_PTR                 eas_ChorusData;
    247 #define EAS_CHORUS_DATA             &eas_ChorusData
    248 #else
    249 #define EAS_CHORUS_DATA             NULL
    250 #endif
    251 #else
    252 #define EAS_CHORUS_INTERFACE        NULL
    253 #define EAS_CHORUS_DATA             NULL
    254 #endif
    255 
    256 #ifdef _WIDENER_ENABLED
    257 extern EAS_VOID_PTR                 EAS_Widener;
    258 #define EAS_WIDENER_INTERFACE       &EAS_Widener
    259 #ifdef _STATIC_MEMORY
    260 extern EAS_VOID_PTR                 eas_WidenerData;
    261 #define EAS_WIDENER_DATA            &eas_WidenerData
    262 #else
    263 #define EAS_WIDENER_DATA            NULL
    264 #endif
    265 #else
    266 #define EAS_WIDENER_INTERFACE       NULL
    267 #define EAS_WIDENER_DATA            NULL
    268 #endif
    269 
    270 #ifdef _GRAPHIC_EQ_ENABLED
    271 extern EAS_VOID_PTR                 EAS_GraphicEQ;
    272 #define EAS_GRAPHIC_EQ_INTERFACE    &EAS_GraphicEQ
    273 #ifdef _STATIC_MEMORY
    274 extern EAS_VOID_PTR                 eas_GraphicEQData;
    275 #define EAS_GRAPHIC_EQ_DATA         &eas_GraphicEQData
    276 #else
    277 #define EAS_GRAPHIC_EQ_DATA         NULL
    278 #endif
    279 #else
    280 #define EAS_GRAPHIC_EQ_INTERFACE    NULL
    281 #define EAS_GRAPHIC_EQ_DATA         NULL
    282 #endif
    283 
    284 #ifdef _WOW_ENABLED
    285 extern EAS_VOID_PTR                 EAS_Wow;
    286 #define EAS_WOW_INTERFACE           &EAS_Wow
    287 #ifdef _STATIC_MEMORY
    288 #error "WOW module requires dynamic memory model"
    289 #else
    290 #define EAS_WOW_DATA                NULL
    291 #endif
    292 #else
    293 #define EAS_WOW_INTERFACE           NULL
    294 #define EAS_WOW_DATA                NULL
    295 #endif
    296 
    297 #ifdef _TONECONTROLEQ_ENABLED
    298 extern EAS_VOID_PTR                 EAS_ToneControlEQ;
    299 #define EAS_TONECONTROLEQ_INTERFACE &EAS_ToneControlEQ
    300 #ifdef _STATIC_MEMORY
    301 extern EAS_VOID_PTR                 eas_ToneControlEQData;
    302 #define EAS_TONECONTROLEQ_DATA      &eas_ToneControlEQData
    303 #else
    304 #define EAS_TONECONTROLEQ_DATA      NULL
    305 #endif
    306 #else
    307 #define EAS_TONECONTROLEQ_INTERFACE NULL
    308 #define EAS_TONECONTROLEQ_DATA      NULL
    309 #endif
    310 
    311 /*lint -e{605} not pretty, but it works */
    312 EAS_VOID_PTR const effectsModules[] =
    313 {
    314     EAS_ENHANCER_INTERFACE,
    315     EAS_COMPRESSOR_INTERFACE,
    316     EAS_REVERB_INTERFACE,
    317     EAS_CHORUS_INTERFACE,
    318     EAS_WIDENER_INTERFACE,
    319     EAS_GRAPHIC_EQ_INTERFACE,
    320     EAS_WOW_INTERFACE,
    321     EAS_MAXIMIZER_INTERFACE,
    322     EAS_TONECONTROLEQ_INTERFACE
    323 };
    324 
    325 EAS_VOID_PTR const effectsData[] =
    326 {
    327     EAS_ENHANCER_DATA,
    328     EAS_COMPRESSOR_DATA,
    329     EAS_REVERB_DATA,
    330     EAS_CHORUS_DATA,
    331     EAS_WIDENER_DATA,
    332     EAS_GRAPHIC_EQ_DATA,
    333     EAS_WOW_DATA,
    334     EAS_MAXIMIZER_DATA,
    335     EAS_TONECONTROLEQ_DATA
    336 };
    337 
    338 /*----------------------------------------------------------------------------
    339  *
    340  * Optional Modules
    341  *
    342  * These declarations are used by the EAS library to locate
    343  * effects modules.
    344  *----------------------------------------------------------------------------
    345 */
    346 
    347 #ifdef _METRICS_ENABLED
    348 extern EAS_VOID_PTR                 EAS_Metrics;
    349 #define EAS_METRICS_INTERFACE       &EAS_Metrics
    350 #ifdef _STATIC_MEMORY
    351 extern EAS_VOID_PTR                 eas_MetricsData;
    352 #define EAS_METRICS_DATA            &eas_MetricsData
    353 #else
    354 #define EAS_METRICS_DATA            NULL
    355 #endif
    356 #else
    357 #define EAS_METRICS_INTERFACE       NULL
    358 #define EAS_METRICS_DATA            NULL
    359 #endif
    360 
    361 #ifdef MMAPI_SUPPORT
    362 extern EAS_VOID_PTR                 EAS_TC_Parser;
    363 #define EAS_TONE_CONTROL_PARSER     &EAS_TC_Parser
    364 #ifdef _STATIC_MEMORY
    365 extern EAS_VOID_PTR                 eas_TCData;
    366 #define EAS_TONE_CONTROL_DATA       &eas_TCData
    367 #else
    368 #define EAS_TONE_CONTROL_DATA       NULL
    369 #endif
    370 #else
    371 #define EAS_TONE_CONTROL_PARSER     NULL
    372 #define EAS_TONE_CONTROL_DATA       NULL
    373 #endif
    374 
    375 /*lint -e{605} not pretty, but it works */
    376 EAS_VOID_PTR const optionalModules[] =
    377 {
    378     EAS_TONE_CONTROL_PARSER,
    379     EAS_METRICS_INTERFACE
    380 };
    381 
    382 EAS_VOID_PTR const optionalData[] =
    383 {
    384     EAS_TONE_CONTROL_DATA,
    385     EAS_METRICS_DATA
    386 };
    387 
    388 /*----------------------------------------------------------------------------
    389  * EAS_CMStaticMemoryModel()
    390  *----------------------------------------------------------------------------
    391  * Purpose:
    392  * This function returns true if EAS has been configured for
    393  * a static memory model. There are some limitations in the
    394  * static memory model, see the documentation for more
    395  * information.
    396  *
    397  * Outputs:
    398  *  returns EAS_TRUE if a module is found
    399  *----------------------------------------------------------------------------
    400 */
    401 EAS_BOOL EAS_CMStaticMemoryModel (void)
    402 {
    403 #ifdef _STATIC_MEMORY
    404     return EAS_TRUE;
    405 #else
    406     return EAS_FALSE;
    407 #endif
    408 }
    409 
    410 /*----------------------------------------------------------------------------
    411  * EAS_CMEnumModules()
    412  *----------------------------------------------------------------------------
    413  * Purpose:
    414  * This function is used to find pointers to optional modules.
    415  *
    416  * Inputs:
    417  *  module          - module number
    418  *
    419  * Outputs:
    420  *  returns a pointer to the module function table or NULL if no module
    421  *----------------------------------------------------------------------------
    422 */
    423 EAS_VOID_PTR EAS_CMEnumModules (EAS_INT module)
    424 {
    425 
    426     if (module >= (EAS_INT) NUM_PARSER_MODULES)
    427         return NULL;
    428     return parserModules[module];
    429 }
    430 
    431 /*----------------------------------------------------------------------------
    432  * EAS_CMEnumData()
    433  *----------------------------------------------------------------------------
    434  * Purpose:
    435  * This function is used to find pointers to static memory allocations.
    436  *
    437  * Inputs:
    438  *  dataModule          - enumerated module number
    439  *
    440  * Outputs:
    441  * Returns handle to data or NULL if not found
    442  *----------------------------------------------------------------------------
    443 */
    444 /*lint -esym(715, dataModule) used only when _STATIC_MEMORY is defined */
    445 EAS_VOID_PTR EAS_CMEnumData (EAS_INT dataModule)
    446 {
    447 
    448 #ifdef _STATIC_MEMORY
    449     switch (dataModule)
    450     {
    451 
    452     /* main instance data for synthesizer */
    453     case EAS_CM_EAS_DATA:
    454         return &eas_Data;
    455 
    456     /* mix buffer for mix engine */
    457     case EAS_CM_MIX_BUFFER:
    458         /*lint -e{545} lint doesn't like this because it sees the underlying type */
    459         return &eas_MixBuffer;
    460 
    461     /* instance data for synth */
    462     case EAS_CM_SYNTH_DATA:
    463         return &eas_Synth;
    464 
    465     /* instance data for MIDI parser */
    466     case EAS_CM_MIDI_DATA:
    467         return &eas_MIDI;
    468 
    469     /* instance data for SMF parser */
    470     case EAS_CM_SMF_DATA:
    471         return &eas_SMFData;
    472 
    473 #ifdef _XMF_PARSER
    474     /* instance data for XMF parser */
    475     case EAS_CM_XMF_DATA:
    476         return &eas_XMFData;
    477 #endif
    478 
    479 #ifdef _SMAF_PARSER
    480     /* instance data for SMAF parser */
    481     case EAS_CM_SMAF_DATA:
    482         return &eas_SMAFData;
    483 #endif
    484 
    485     /* instance data for the PCM engine */
    486     case EAS_CM_PCM_DATA:
    487         /*lint -e{545} lint doesn't like this because it sees the underlying type */
    488         return &eas_PCMData;
    489 
    490     case EAS_CM_MIDI_STREAM_DATA:
    491         return &eas_MIDIData;
    492 
    493 #ifdef _OTA_PARSER
    494     /* instance data for OTA parser */
    495     case EAS_CM_OTA_DATA:
    496         return &eas_OTAData;
    497 #endif
    498 
    499 #ifdef _IMELODY_PARSER
    500     /* instance data for iMelody parser */
    501     case EAS_CM_IMELODY_DATA:
    502         return &eas_iMelodyData;
    503 #endif
    504 
    505 #ifdef _RTTTL_PARSER
    506     /* instance data for RTTTL parser */
    507     case EAS_CM_RTTTL_DATA:
    508         return &eas_RTTTLData;
    509 #endif
    510 
    511 #ifdef _WAVE_PARSER
    512     /* instance data for WAVE parser */
    513     case EAS_CM_WAVE_DATA:
    514         return &eas_WaveData;
    515 #endif
    516 
    517 #if defined (_CMX_PARSER) || defined(_MFI_PARSER)
    518     /* instance data for CMF parser */
    519     case EAS_CM_CMF_DATA:
    520         return &eas_CMFData;
    521 #endif
    522 
    523     default:
    524         return NULL;
    525     }
    526 
    527 #else
    528     return NULL;
    529 #endif
    530 }
    531 
    532 /*----------------------------------------------------------------------------
    533  * EAS_CMEnumFXModules()
    534  *----------------------------------------------------------------------------
    535  * Purpose:
    536  * This function is used to find pointers to optional effects modules.
    537  *
    538  * Inputs:
    539  *  module          - enumerated module number
    540  *  pModule         - pointer to module interface
    541  *
    542  * Outputs:
    543  *  Returns pointer to function table or NULL if not found
    544  *----------------------------------------------------------------------------
    545 */
    546 EAS_VOID_PTR EAS_CMEnumFXModules (EAS_INT module)
    547 {
    548 
    549     if (module >= NUM_EFFECTS_MODULES)
    550         return NULL;
    551     return effectsModules[module];
    552 }
    553 
    554 /*----------------------------------------------------------------------------
    555  * EAS_CMEnumFXData()
    556  *----------------------------------------------------------------------------
    557  * Purpose:
    558  * This function is used to find pointers to static memory allocations.
    559  *
    560  * Inputs:
    561  *  dataModule          - enumerated module number
    562  *  pData               - pointer to handle variable
    563  *
    564  * Outputs:
    565  * Returns handle to data or NULL if not found
    566  *----------------------------------------------------------------------------
    567 */
    568 EAS_VOID_PTR EAS_CMEnumFXData (EAS_INT dataModule)
    569 {
    570 
    571     if (dataModule >= NUM_EFFECTS_MODULES)
    572         return NULL;
    573     return effectsData[dataModule];
    574 }
    575 
    576 /*----------------------------------------------------------------------------
    577  * EAS_CMEnumOptModules()
    578  *----------------------------------------------------------------------------
    579  * Purpose:
    580  * This function is used to find pointers to optional modules.
    581  *
    582  * Inputs:
    583  *  module          - enumerated module number
    584  *
    585  * Outputs:
    586  *  returns pointer to function table or NULL if no module
    587  *----------------------------------------------------------------------------
    588 */
    589 EAS_VOID_PTR EAS_CMEnumOptModules (EAS_INT module)
    590 {
    591 
    592     /* sanity check */
    593     if (module >= NUM_OPTIONAL_MODULES)
    594         return EAS_FALSE;
    595     return optionalModules[module];
    596 }
    597 
    598 /*----------------------------------------------------------------------------
    599  * EAS_CMEnumOptData()
    600  *----------------------------------------------------------------------------
    601  * Purpose:
    602  * This function is used to find pointers to static memory allocations.
    603  *
    604  * Inputs:
    605  *  dataModule          - enumerated module number
    606  *
    607  * Outputs:
    608  * Returns handle to data or NULL if not found
    609  *----------------------------------------------------------------------------
    610 */
    611 EAS_VOID_PTR EAS_CMEnumOptData (EAS_INT dataModule)
    612 {
    613 
    614     if (dataModule >= NUM_OPTIONAL_MODULES)
    615         return NULL;
    616     return optionalData[dataModule];
    617 }
    618 
    619 
    620