| /*---------------------------------------------------------------------------- |
| * |
| * 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 |
| |
