/*----------------------------------------------------------------------------
 *
 * File: 
 * eas_mixer.c
 *
 * Contents and purpose:
 * This file contains the critical components of the mix engine that
 * must be optimized for best performance.
 *			
 * Copyright Sonic Network Inc. 2005

 * 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: 706 $
 *   $Date: 2007-05-31 17:22:51 -0700 (Thu, 31 May 2007) $
 *----------------------------------------------------------------------------
*/

//3 dls: This module is in the midst of being converted from a synth
//3 specific module to a general purpose mix engine

/*------------------------------------
 * includes
 *------------------------------------
*/
#include "eas_data.h"
#include "eas_host.h"
#include "eas_math.h"
#include "eas_mixer.h"
#include "eas_config.h"
#include "eas_report.h"

#ifdef _MAXIMIZER_ENABLED
EAS_I32 MaximizerProcess (EAS_VOID_PTR pInstData, EAS_I32 *pSrc, EAS_I32 *pDst, EAS_I32 numSamples);
#endif

/*------------------------------------
 * defines
 *------------------------------------
*/

/* need to boost stereo by ~3dB to compensate for the panner */
#define STEREO_3DB_GAIN_BOOST		512

/*----------------------------------------------------------------------------
 * EAS_MixEngineInit()
 *----------------------------------------------------------------------------
 * Purpose:
 * Prepares the mix engine for work, allocates buffers, locates effects modules, etc.
 *
 * Inputs:
 * pEASData		 	- instance data
 * pInstData		- pointer to variable to receive instance data handle
 *
 * Outputs:
 *
 * Side Effects:
 *
 *----------------------------------------------------------------------------
*/
EAS_RESULT EAS_MixEngineInit (S_EAS_DATA *pEASData)
{
	
	/* check Configuration Module for mix buffer allocation */
	if (pEASData->staticMemoryModel)
		pEASData->pMixBuffer = EAS_CMEnumData(EAS_CM_MIX_BUFFER);
	else
		pEASData->pMixBuffer = EAS_HWMalloc(pEASData->hwInstData, BUFFER_SIZE_IN_MONO_SAMPLES * NUM_OUTPUT_CHANNELS * sizeof(EAS_I32));
	if (pEASData->pMixBuffer == NULL)
	{
		{ /* dpp: EAS_ReportEx(_EAS_SEVERITY_FATAL, "Failed to allocate mix buffer memory\n"); */ }
		return EAS_ERROR_MALLOC_FAILED;
	}
	EAS_HWMemSet((void *)(pEASData->pMixBuffer), 0, BUFFER_SIZE_IN_MONO_SAMPLES * NUM_OUTPUT_CHANNELS * sizeof(EAS_I32));

	return EAS_SUCCESS;
}

/*----------------------------------------------------------------------------
 * EAS_MixEnginePrep()
 *----------------------------------------------------------------------------
 * Purpose:
 * Performs prep before synthesize a buffer of audio, such as clearing
 * audio buffers, etc.
 *
 * Inputs:
 * psEASData - pointer to overall EAS data structure
 *
 * Outputs:
 *
 * Side Effects:
 *
 *----------------------------------------------------------------------------
*/
void EAS_MixEnginePrep (S_EAS_DATA *pEASData, EAS_I32 numSamples)
{

	/* clear the mix buffer */
#if (NUM_OUTPUT_CHANNELS == 2)
	EAS_HWMemSet(pEASData->pMixBuffer, 0, numSamples * (EAS_I32) sizeof(long) * 2);
#else
	EAS_HWMemSet(pEASData->pMixBuffer, 0, (EAS_I32) numSamples * (EAS_I32) sizeof(long));
#endif

	/* need to clear other side-chain effect buffers (chorus & reverb) */
}

/*----------------------------------------------------------------------------
 * EAS_MixEnginePost
 *----------------------------------------------------------------------------
 * Purpose: 
 * This routine does the post-processing after all voices have been
 * synthesized. It calls any sweeteners and does the final mixdown to
 * the output buffer.
 * 
 * Inputs: 
 *			
 * Outputs:
 *
 * Notes:
 *----------------------------------------------------------------------------
*/
void EAS_MixEnginePost (S_EAS_DATA *pEASData, EAS_I32 numSamples)
{
	EAS_U16 gain;

//3 dls: Need to restore the mix engine metrics

	/* calculate the gain multiplier */
#ifdef _MAXIMIZER_ENABLED
	if (pEASData->effectsModules[EAS_MODULE_MAXIMIZER].effect)
	{
		EAS_I32 temp;
		temp = MaximizerProcess(pEASData->effectsModules[EAS_MODULE_MAXIMIZER].effectData, pEASData->pMixBuffer, pEASData->pMixBuffer, numSamples);
		temp = (temp * pEASData->masterGain) >> 15;
		if (temp > 32767)
			gain = 32767;
		else
			gain = (EAS_U16) temp;
	}
	else
		gain = (EAS_U16) pEASData->masterGain;
#else
	gain = (EAS_U16) pEASData->masterGain;
#endif

	/* Not using all the gain bits for now
	 * Reduce the input to the compressor by 6dB to prevent saturation
	 */
#ifdef _COMPRESSOR_ENABLED
	if (pEASData->effectsModules[EAS_MODULE_COMPRESSOR].effectData)
		gain = gain >> 5;
	else
		gain = gain >> 4;
#else
	gain = gain >> 4;
#endif

	/* convert 32-bit mix buffer to 16-bit output format */
#if (NUM_OUTPUT_CHANNELS == 2)	
	SynthMasterGain(pEASData->pMixBuffer, pEASData->pOutputAudioBuffer, gain, (EAS_U16) ((EAS_U16) numSamples * 2));
#else	
	SynthMasterGain(pEASData->pMixBuffer, pEASData->pOutputAudioBuffer, gain, (EAS_U16) numSamples);
#endif

#ifdef _ENHANCER_ENABLED
	/* enhancer effect */
	if (pEASData->effectsModules[EAS_MODULE_ENHANCER].effectData)
		(*pEASData->effectsModules[EAS_MODULE_ENHANCER].effect->pfProcess)
			(pEASData->effectsModules[EAS_MODULE_ENHANCER].effectData,
			pEASData->pOutputAudioBuffer,
			pEASData->pOutputAudioBuffer,
			numSamples);
#endif	
	
#ifdef _GRAPHIC_EQ_ENABLED	
	/* graphic EQ effect */
	if (pEASData->effectsModules[EAS_MODULE_GRAPHIC_EQ].effectData)
		(*pEASData->effectsModules[EAS_MODULE_GRAPHIC_EQ].effect->pfProcess)
			(pEASData->effectsModules[EAS_MODULE_GRAPHIC_EQ].effectData,
			pEASData->pOutputAudioBuffer,
			pEASData->pOutputAudioBuffer,
			numSamples);
#endif	
	
#ifdef _COMPRESSOR_ENABLED	
	/* compressor effect */
	if (pEASData->effectsModules[EAS_MODULE_COMPRESSOR].effectData)
		(*pEASData->effectsModules[EAS_MODULE_COMPRESSOR].effect->pfProcess)
			(pEASData->effectsModules[EAS_MODULE_COMPRESSOR].effectData,
			pEASData->pOutputAudioBuffer,
			pEASData->pOutputAudioBuffer,
			numSamples);
#endif	

#ifdef _WOW_ENABLED	
	/* WOW requires a 32-bit buffer, borrow the mix buffer and
	 * pass it as the destination buffer
	 */
	/*lint -e{740} temporarily passing a parameter through an existing I/F */
	if (pEASData->effectsModules[EAS_MODULE_WOW].effectData)
		(*pEASData->effectsModules[EAS_MODULE_WOW].effect->pfProcess)
			(pEASData->effectsModules[EAS_MODULE_WOW].effectData,
			pEASData->pOutputAudioBuffer,
			(EAS_PCM*) pEASData->pMixBuffer,
			numSamples);
#endif	

#ifdef _TONECONTROLEQ_ENABLED
	/* ToneControlEQ effect */
	if (pEASData->effectsModules[EAS_MODULE_TONECONTROLEQ].effectData)
		(*pEASData->effectsModules[EAS_MODULE_TONECONTROLEQ].effect->pfProcess)
			(pEASData->effectsModules[EAS_MODULE_TONECONTROLEQ].effectData,
			pEASData->pOutputAudioBuffer,
			pEASData->pOutputAudioBuffer,
			numSamples);
#endif	

#ifdef _REVERB_ENABLED
	/* Reverb effect */
	if (pEASData->effectsModules[EAS_MODULE_REVERB].effectData)
		(*pEASData->effectsModules[EAS_MODULE_REVERB].effect->pfProcess)
			(pEASData->effectsModules[EAS_MODULE_REVERB].effectData,
			pEASData->pOutputAudioBuffer,
			pEASData->pOutputAudioBuffer,
			numSamples);
#endif	

#ifdef _CHORUS_ENABLED
	/* Chorus effect */
	if (pEASData->effectsModules[EAS_MODULE_CHORUS].effectData)
		(*pEASData->effectsModules[EAS_MODULE_CHORUS].effect->pfProcess)
			(pEASData->effectsModules[EAS_MODULE_CHORUS].effectData,
			pEASData->pOutputAudioBuffer,
			pEASData->pOutputAudioBuffer,
			numSamples);
#endif	

}

#ifndef NATIVE_EAS_KERNEL
/*----------------------------------------------------------------------------
 * SynthMasterGain
 *----------------------------------------------------------------------------
 * Purpose:
 * Mixes down audio from 32-bit to 16-bit target buffer
 *
 * Inputs: 
 *			
 * Outputs:
 *
 *----------------------------------------------------------------------------
*/
void SynthMasterGain (long *pInputBuffer, EAS_PCM *pOutputBuffer, EAS_U16 nGain, EAS_U16 numSamples) {

	/* loop through the buffer */
	while (numSamples--) {
		long s;
		
		/* read a sample from the input buffer and add some guard bits */
		s = *pInputBuffer++;
		
		/* add some guard bits */
		/*lint -e{704} <avoid divide for performance>*/
		s = s >> 7;
		
		/* apply master gain */
		s *= (long) nGain;

		/* shift to lower 16-bits */
		/*lint -e{704} <avoid divide for performance>*/
		s = s >> 9;
		
		/* saturate */
		s = SATURATE(s);

		*pOutputBuffer++ = (EAS_PCM)s;
	}
}
#endif

/*----------------------------------------------------------------------------
 * EAS_MixEngineShutdown()
 *----------------------------------------------------------------------------
 * Purpose:
 * Shuts down effects modules and deallocates memory
 *
 * Inputs:
 * pEASData		 	- instance data
 * pInstData		- instance data handle
 *
 * Outputs:
 *
 * Side Effects:
 *
 *----------------------------------------------------------------------------
*/
EAS_RESULT EAS_MixEngineShutdown (S_EAS_DATA *pEASData)
{

	/* check Configuration Module for static memory allocation */
	if (!pEASData->staticMemoryModel && (pEASData->pMixBuffer != NULL))
		EAS_HWFree(pEASData->hwInstData, pEASData->pMixBuffer);

	return EAS_SUCCESS;
}

#ifdef UNIFIED_MIXER
#ifndef NATIVE_MIX_STREAM
/*----------------------------------------------------------------------------
 * EAS_MixStream
 *----------------------------------------------------------------------------
 * Mix a 16-bit stream into a 32-bit buffer
 *
 * pInputBuffer	16-bit input buffer
 * pMixBuffer	32-bit mix buffer
 * numSamples	number of samples to mix
 * gainLeft		initial gain left or mono
 * gainRight	initial gain right
 * gainLeft		left gain increment per sample
 * gainRight	right gain increment per sample
 * flags		bit 0 = stereo source
 * 				bit 1 = stereo output
 *----------------------------------------------------------------------------
*/
void EAS_MixStream (EAS_PCM *pInputBuffer, EAS_I32 *pMixBuffer, EAS_I32 numSamples, EAS_I32 gainLeft, EAS_I32 gainRight, EAS_I32 gainIncLeft, EAS_I32 gainIncRight, EAS_I32 flags)
{
	EAS_I32 temp;
	EAS_INT src, dest;

	/* NOTE: There are a lot of optimizations that can be done 
	 * in the native implementations based on register
	 * availability, etc. For example, it may make sense to
	 * break this down into 8 separate routines:
	 *
	 * 1. Mono source to mono output
	 * 2. Mono source to stereo output
	 * 3. Stereo source to mono output
	 * 4. Stereo source to stereo output
	 * 5. Mono source to mono output - no gain change
	 * 6. Mono source to stereo output - no gain change
	 * 7. Stereo source to mono output - no gain change
	 * 8. Stereo source to stereo output - no gain change
	 *
	 * Other possibilities include loop unrolling, skipping
	 * a gain calculation every 2 or 4 samples, etc.
	 */

	/* no gain change, use fast loops */	
	if ((gainIncLeft == 0) && (gainIncRight == 0))
	{
		switch (flags & (MIX_FLAGS_STEREO_SOURCE | MIX_FLAGS_STEREO_OUTPUT))
		{
			/* mono to mono */
			case 0:
				gainLeft >>= 15;
				for (src = dest = 0; src < numSamples; src++, dest++)
				{
					
					pMixBuffer[dest] += (pInputBuffer[src] * gainLeft) >> NUM_MIXER_GUARD_BITS;
				}
				break;
				
			/* mono to stereo */
			case MIX_FLAGS_STEREO_OUTPUT:
				gainLeft >>= 15;
				gainRight >>= 15;
				for (src = dest = 0; src < numSamples; src++, dest+=2)
				{
					pMixBuffer[dest] += (pInputBuffer[src] * gainLeft) >> NUM_MIXER_GUARD_BITS;
					pMixBuffer[dest+1] += (pInputBuffer[src] * gainRight) >> NUM_MIXER_GUARD_BITS;
				}
				break;

			/* stereo to mono */
			case MIX_FLAGS_STEREO_SOURCE:
				gainLeft >>= 15;
				gainRight >>= 15;
				for (src = dest = 0; src < numSamples; src+=2, dest++)
				{
					temp = (pInputBuffer[src] * gainLeft) >> NUM_MIXER_GUARD_BITS;
					temp += ((pInputBuffer[src+1] * gainRight) >> NUM_MIXER_GUARD_BITS);
					pMixBuffer[dest] += temp;
				}
				break;
				
			/* stereo to stereo */
			case MIX_FLAGS_STEREO_SOURCE | MIX_FLAGS_STEREO_OUTPUT:
				gainLeft >>= 15;
				gainRight >>= 15;
				for (src = dest = 0; src < numSamples; src+=2, dest+=2)
				{
					pMixBuffer[dest] += (pInputBuffer[src] * gainLeft) >> NUM_MIXER_GUARD_BITS;
					pMixBuffer[dest+1] += (pInputBuffer[src+1] * gainRight) >> NUM_MIXER_GUARD_BITS;
				}
				break;
		}
	}

	/* gain change - do gain increment */
	else
	{
		switch (flags & (MIX_FLAGS_STEREO_SOURCE | MIX_FLAGS_STEREO_OUTPUT))
		{
			/* mono to mono */
			case 0:
				for (src = dest = 0; src < numSamples; src++, dest++)
				{
					gainLeft += gainIncLeft;
					pMixBuffer[dest] += (pInputBuffer[src] * (gainLeft >> 15)) >> NUM_MIXER_GUARD_BITS;
				}
				break;
				
			/* mono to stereo */
			case MIX_FLAGS_STEREO_OUTPUT:
				for (src = dest = 0; src < numSamples; src++, dest+=2)
				{
					gainLeft += gainIncLeft;
					gainRight += gainIncRight;
					pMixBuffer[dest] += (pInputBuffer[src] * (gainLeft >> 15)) >> NUM_MIXER_GUARD_BITS;
					pMixBuffer[dest+1] += (pInputBuffer[src] * (gainRight >> 15)) >> NUM_MIXER_GUARD_BITS;
				}
				break;

			/* stereo to mono */
			case MIX_FLAGS_STEREO_SOURCE:
				for (src = dest = 0; src < numSamples; src+=2, dest++)
				{
					gainLeft += gainIncLeft;
					gainRight += gainIncRight;
					temp = (pInputBuffer[src] * (gainLeft >> 15)) >> NUM_MIXER_GUARD_BITS;
					temp += ((pInputBuffer[src+1] * (gainRight >> 15)) >> NUM_MIXER_GUARD_BITS);
					pMixBuffer[dest] += temp;
				}
				break;
				
			/* stereo to stereo */
			case MIX_FLAGS_STEREO_SOURCE | MIX_FLAGS_STEREO_OUTPUT:
				for (src = dest = 0; src < numSamples; src+=2, dest+=2)
				{
					gainLeft += gainIncLeft;
					gainRight += gainIncRight;
					pMixBuffer[dest] += (pInputBuffer[src] * (gainLeft >> 15)) >> NUM_MIXER_GUARD_BITS;
					pMixBuffer[dest+1] += (pInputBuffer[src+1] * (gainRight >> 15)) >> NUM_MIXER_GUARD_BITS;
				}
				break;
		}
	}
}
#endif
#endif