/*----------------------------------------------------------------------------
 *
 * 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];
}