DOOM-IOS2/common/embeddedaudiosynthesis/arm-fm-22k/lib_src/eas_reverb.c

/*----------------------------------------------------------------------------
 *
 * File:
 * eas_reverb.c
 *
 * Contents and purpose:
 * Contains the implementation of the Reverb effect.
 *
 *
 * Copyright Sonic Network Inc. 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: 510 $
 *   $Date: 2006-12-19 01:47:33 -0800 (Tue, 19 Dec 2006) $
 *----------------------------------------------------------------------------
*/

/*------------------------------------
 * includes
 *------------------------------------
*/

#include "eas_data.h"
#include "eas_effects.h"
#include "eas_math.h"
#include "eas_reverbdata.h"
#include "eas_reverb.h"
#include "eas_config.h"
#include "eas_host.h"
#include "eas_report.h"

/* prototypes for effects interface */
static EAS_RESULT ReverbInit (EAS_DATA_HANDLE pEASData, EAS_VOID_PTR *pInstData);
static void ReverbProcess (EAS_VOID_PTR pInstData, EAS_PCM *pSrc, EAS_PCM *pDst, EAS_I32 numSamples);
static EAS_RESULT ReverbShutdown (EAS_DATA_HANDLE pEASData, EAS_VOID_PTR pInstData);
static EAS_RESULT ReverbGetParam (EAS_VOID_PTR pInstData, EAS_I32 param, EAS_I32 *pValue);
static EAS_RESULT ReverbSetParam (EAS_VOID_PTR pInstData, EAS_I32 param, EAS_I32 value);

/* common effects interface for configuration module */
const S_EFFECTS_INTERFACE EAS_Reverb =
{
    ReverbInit,
    ReverbProcess,
    ReverbShutdown,
    ReverbGetParam,
    ReverbSetParam
};



/*----------------------------------------------------------------------------
 * InitializeReverb()
 *----------------------------------------------------------------------------
 * Purpose:
 *
 * Inputs:
 *
 * Outputs:
 *
 *----------------------------------------------------------------------------
*/
static EAS_RESULT ReverbInit(EAS_DATA_HANDLE pEASData, EAS_VOID_PTR *pInstData)
{
    EAS_I32 i;
    EAS_U16 nOffset;
    EAS_INT temp;

    S_REVERB_OBJECT *pReverbData;
    S_REVERB_PRESET *pPreset;

    /* check Configuration Module for data allocation */
    if (pEASData->staticMemoryModel)
        pReverbData = EAS_CMEnumFXData(EAS_MODULE_REVERB);

    /* allocate dynamic memory */
    else
        pReverbData = EAS_HWMalloc(pEASData->hwInstData, sizeof(S_REVERB_OBJECT));

    if (pReverbData == NULL)
    {
        { /* dpp: EAS_ReportEx(_EAS_SEVERITY_FATAL, "Failed to allocate Reverb memory\n"); */ }
        return EAS_ERROR_MALLOC_FAILED;
    }

    /* clear the structure */
    EAS_HWMemSet(pReverbData, 0, sizeof(S_REVERB_OBJECT));

    ReverbReadInPresets(pReverbData);

    pReverbData->m_nMinSamplesToAdd = REVERB_UPDATE_PERIOD_IN_SAMPLES;

    pReverbData->m_nRevOutFbkR = 0;
    pReverbData->m_nRevOutFbkL = 0;

    pReverbData->m_sAp0.m_zApIn  = AP0_IN;
    pReverbData->m_sAp0.m_zApOut = AP0_IN + DEFAULT_AP0_LENGTH;
    pReverbData->m_sAp0.m_nApGain = DEFAULT_AP0_GAIN;

    pReverbData->m_zD0In = DELAY0_IN;

    pReverbData->m_sAp1.m_zApIn  = AP1_IN;
    pReverbData->m_sAp1.m_zApOut = AP1_IN + DEFAULT_AP1_LENGTH;
    pReverbData->m_sAp1.m_nApGain = DEFAULT_AP1_GAIN;

    pReverbData->m_zD1In = DELAY1_IN;

    pReverbData->m_zLpf0    = 0;
    pReverbData->m_zLpf1    = 0;
    pReverbData->m_nLpfFwd  = 8837;
    pReverbData->m_nLpfFbk  = 6494;

    pReverbData->m_nSin     = 0;
    pReverbData->m_nCos     = 0;
    pReverbData->m_nSinIncrement    = 0;
    pReverbData->m_nCosIncrement    = 0;

    // set xfade parameters
    pReverbData->m_nXfadeInterval = (EAS_U16)REVERB_XFADE_PERIOD_IN_SAMPLES;
    pReverbData->m_nXfadeCounter = pReverbData->m_nXfadeInterval + 1;   // force update on first iteration
    pReverbData->m_nPhase = -32768;
    pReverbData->m_nPhaseIncrement = REVERB_XFADE_PHASE_INCREMENT;

    pReverbData->m_nNoise = (EAS_I16)0xABCD;

    pReverbData->m_nMaxExcursion = 0x007F;

    // set delay tap lengths
    nOffset = ReverbCalculateNoise( pReverbData->m_nMaxExcursion,
                                    &pReverbData->m_nNoise );

    pReverbData->m_zD1Cross =
        DELAY1_OUT - pReverbData->m_nMaxExcursion + nOffset;

    nOffset = ReverbCalculateNoise( pReverbData->m_nMaxExcursion,
                                    &pReverbData->m_nNoise );

    pReverbData->m_zD0Cross =
        DELAY1_OUT - pReverbData->m_nMaxExcursion - nOffset;

    nOffset = ReverbCalculateNoise( pReverbData->m_nMaxExcursion,
                                    &pReverbData->m_nNoise );

    pReverbData->m_zD0Self  =
        DELAY0_OUT - pReverbData->m_nMaxExcursion - nOffset;

    nOffset = ReverbCalculateNoise( pReverbData->m_nMaxExcursion,
                                    &pReverbData->m_nNoise );

    pReverbData->m_zD1Self  =
        DELAY1_OUT - pReverbData->m_nMaxExcursion + nOffset;

    // for debugging purposes, allow noise generator
    pReverbData->m_bUseNoise = EAS_FALSE;

    // for debugging purposes, allow bypass
    pReverbData->m_bBypass = EAS_TRUE;  //EAS_FALSE;

    pReverbData->m_nNextRoom = 1;

    pReverbData->m_nCurrentRoom = pReverbData->m_nNextRoom + 1; // force update on first iteration

    pReverbData->m_nWet = REVERB_DEFAULT_WET;

    pReverbData->m_nDry = REVERB_DEFAULT_DRY;

    // set base index into circular buffer
    pReverbData->m_nBaseIndex = 0;

    // set the early reflections, L
    pReverbData->m_sEarlyL.m_nLpfFbk = 4915;
    pReverbData->m_sEarlyL.m_nLpfFwd = 27852;
    pReverbData->m_sEarlyL.m_zLpf = 0;

    for (i=0; i < REVERB_MAX_NUM_REFLECTIONS; i++)
    {
        pReverbData->m_sEarlyL.m_nGain[i] = 0;
        pReverbData->m_sEarlyL.m_zDelay[i] = 0;
    }

    // set the early reflections, R
    pReverbData->m_sEarlyR.m_nLpfFbk = 4915;
    pReverbData->m_sEarlyR.m_nLpfFwd = 27852;
    pReverbData->m_sEarlyR.m_zLpf = 0;

    for (i=0; i < REVERB_MAX_NUM_REFLECTIONS; i++)
    {
        pReverbData->m_sEarlyR.m_nGain[i] = 0;
        pReverbData->m_sEarlyR.m_zDelay[i] = 0;
    }

    // clear the reverb delay line
    for (i=0; i < REVERB_BUFFER_SIZE_IN_SAMPLES; i++)
    {
        pReverbData->m_nDelayLine[i] = 0;
    }

    ////////////////////////////////
    ///code from the EAS DEMO Reverb
    //now copy from the new preset into the reverb
    pPreset = &pReverbData->m_sPreset.m_sPreset[pReverbData->m_nNextRoom];

    pReverbData->m_nLpfFbk = pPreset->m_nLpfFbk;
    pReverbData->m_nLpfFwd = pPreset->m_nLpfFwd;

    pReverbData->m_nEarly = pPreset->m_nEarly;
    pReverbData->m_nWet = pPreset->m_nWet;
    pReverbData->m_nDry = pPreset->m_nDry;

    pReverbData->m_nMaxExcursion = pPreset->m_nMaxExcursion;
    //stored as time based, convert to sample based
    temp = pPreset->m_nXfadeInterval;
    /*lint -e{702} shift for performance */
    temp = (temp * _OUTPUT_SAMPLE_RATE) >> 16;
    pReverbData->m_nXfadeInterval = (EAS_U16) temp;
    //gsReverbObject.m_nXfadeInterval = pPreset->m_nXfadeInterval;

    pReverbData->m_sAp0.m_nApGain = pPreset->m_nAp0_ApGain;
    //stored as time based, convert to absolute sample value
    temp = pPreset->m_nAp0_ApOut;
    /*lint -e{702} shift for performance */
    temp = (temp * _OUTPUT_SAMPLE_RATE) >> 16;
    pReverbData->m_sAp0.m_zApOut = (EAS_U16) (pReverbData->m_sAp0.m_zApIn + temp);
    //gsReverbObject.m_sAp0.m_zApOut = pPreset->m_nAp0_ApOut;

    pReverbData->m_sAp1.m_nApGain = pPreset->m_nAp1_ApGain;
    //stored as time based, convert to absolute sample value
    temp = pPreset->m_nAp1_ApOut;
    /*lint -e{702} shift for performance */
    temp = (temp * _OUTPUT_SAMPLE_RATE) >> 16;
    pReverbData->m_sAp1.m_zApOut = (EAS_U16) (pReverbData->m_sAp1.m_zApIn + temp);
    //gsReverbObject.m_sAp1.m_zApOut = pPreset->m_nAp1_ApOut;
    ///code from the EAS DEMO Reverb
    ////////////////////////////////

    *pInstData = pReverbData;

    return EAS_SUCCESS;

}   /* end InitializeReverb */



/*----------------------------------------------------------------------------
 * ReverbProcess()
 *----------------------------------------------------------------------------
 * Purpose:
 * Reverberate the requested number of samples (block based processing)
 *
 * Inputs:
 * pInputBuffer - src buffer
 * pOutputBuffer - dst buffer
 * nNumSamplesToAdd - number of samples to write to buffer
 *
 * Outputs:
 * number of samples actually written to buffer
 *
 * Side Effects:
 * - samples are added to the presently free buffer
 *
 *----------------------------------------------------------------------------
*/
static void ReverbProcess(EAS_VOID_PTR pInstData, EAS_PCM *pSrc, EAS_PCM *pDst, EAS_I32 numSamples)
{
    S_REVERB_OBJECT *pReverbData;

    pReverbData = (S_REVERB_OBJECT*) pInstData;

    //if bypassed or the preset forces the signal to be completely dry
    if (pReverbData->m_bBypass ||
        (pReverbData->m_nWet == 0 && pReverbData->m_nDry == 32767))
    {
        if (pSrc != pDst)
            EAS_HWMemCpy(pSrc, pDst, numSamples * NUM_OUTPUT_CHANNELS * (EAS_I32) sizeof(EAS_PCM));
        return;
    }

    if (pReverbData->m_nNextRoom != pReverbData->m_nCurrentRoom)
    {
        ReverbUpdateRoom(pReverbData);
    }

    ReverbUpdateXfade(pReverbData, numSamples);

    Reverb(pReverbData, numSamples, pDst, pSrc);

    /* check if update counter needs to be reset */
    if (pReverbData->m_nUpdateCounter >= REVERB_MODULO_UPDATE_PERIOD_IN_SAMPLES)
    {
        /* update interval has elapsed, so reset counter */
        pReverbData->m_nUpdateCounter = 0;
    }   /* end if m_nUpdateCounter >= update interval */

    /* increment update counter */
    pReverbData->m_nUpdateCounter += (EAS_I16)numSamples;

}   /* end ComputeReverb */

/*----------------------------------------------------------------------------
 * ReverbUpdateXfade
 *----------------------------------------------------------------------------
 * Purpose:
 * Update the xfade parameters as required
 *
 * Inputs:
 * nNumSamplesToAdd - number of samples to write to buffer
 *
 * Outputs:
 *
 *
 * Side Effects:
 * - xfade parameters will be changed
 *
 *----------------------------------------------------------------------------
*/
static EAS_RESULT ReverbUpdateXfade(S_REVERB_OBJECT *pReverbData, EAS_INT nNumSamplesToAdd)
{
    EAS_U16 nOffset;
    EAS_I16 tempCos;
    EAS_I16 tempSin;

    if (pReverbData->m_nXfadeCounter >= pReverbData->m_nXfadeInterval)
    {
        /* update interval has elapsed, so reset counter */
        pReverbData->m_nXfadeCounter = 0;

        // Pin the sin,cos values to min / max values to ensure that the
        // modulated taps' coefs are zero (thus no clicks)
        if (pReverbData->m_nPhaseIncrement > 0)
        {
            // if phase increment > 0, then sin -> 1, cos -> 0
            pReverbData->m_nSin = 32767;
            pReverbData->m_nCos = 0;

            // reset the phase to match the sin, cos values
            pReverbData->m_nPhase = 32767;

            // modulate the cross taps because their tap coefs are zero
            nOffset = ReverbCalculateNoise( pReverbData->m_nMaxExcursion, &pReverbData->m_nNoise );

            pReverbData->m_zD1Cross =
                DELAY1_OUT - pReverbData->m_nMaxExcursion + nOffset;

            nOffset = ReverbCalculateNoise( pReverbData->m_nMaxExcursion, &pReverbData->m_nNoise );

            pReverbData->m_zD0Cross =
                DELAY0_OUT - pReverbData->m_nMaxExcursion - nOffset;
        }
        else
        {
            // if phase increment < 0, then sin -> 0, cos -> 1
            pReverbData->m_nSin = 0;
            pReverbData->m_nCos = 32767;

            // reset the phase to match the sin, cos values
            pReverbData->m_nPhase = -32768;

            // modulate the self taps because their tap coefs are zero
            nOffset = ReverbCalculateNoise( pReverbData->m_nMaxExcursion, &pReverbData->m_nNoise );

            pReverbData->m_zD0Self  =
                DELAY0_OUT - pReverbData->m_nMaxExcursion - nOffset;

            nOffset = ReverbCalculateNoise( pReverbData->m_nMaxExcursion, &pReverbData->m_nNoise );

            pReverbData->m_zD1Self  =
                DELAY1_OUT - pReverbData->m_nMaxExcursion + nOffset;

        }   // end if-else (pReverbData->m_nPhaseIncrement > 0)

        // Reverse the direction of the sin,cos so that the
        // tap whose coef was previously increasing now decreases
        // and vice versa
        pReverbData->m_nPhaseIncrement = -pReverbData->m_nPhaseIncrement;

    }   // end if counter >= update interval

    //compute what phase will be next time
    pReverbData->m_nPhase += pReverbData->m_nPhaseIncrement;

    //calculate what the new sin and cos need to reach by the next update
    ReverbCalculateSinCos(pReverbData->m_nPhase, &tempSin, &tempCos);

    //calculate the per-sample increment required to get there by the next update
    /*lint -e{702} shift for performance */
    pReverbData->m_nSinIncrement =
            (tempSin - pReverbData->m_nSin) >> REVERB_UPDATE_PERIOD_IN_BITS;

    /*lint -e{702} shift for performance */
    pReverbData->m_nCosIncrement =
            (tempCos - pReverbData->m_nCos) >> REVERB_UPDATE_PERIOD_IN_BITS;


    /* increment update counter */
    pReverbData->m_nXfadeCounter += (EAS_U16) nNumSamplesToAdd;

    return EAS_SUCCESS;

}   /* end ReverbUpdateXfade */


/*----------------------------------------------------------------------------
 * ReverbCalculateNoise
 *----------------------------------------------------------------------------
 * Purpose:
 * Calculate a noise sample and limit its value
 *
 * Inputs:
 * nMaxExcursion - noise value is limited to this value
 * pnNoise - return new noise sample in this (not limited)
 *
 * Outputs:
 * new limited noise value
 *
 * Side Effects:
 * - *pnNoise noise value is updated
 *
 *----------------------------------------------------------------------------
*/
static EAS_U16 ReverbCalculateNoise(EAS_U16 nMaxExcursion, EAS_I16 *pnNoise)
{
    // calculate new noise value
    *pnNoise = (EAS_I16) (*pnNoise * 5 + 1);

#if 0   // 1xxx, test
    *pnNoise = 0;
#endif  // 1xxx, test

    // return the limited noise value
    return (nMaxExcursion & (*pnNoise));

}   /* end ReverbCalculateNoise */

/*----------------------------------------------------------------------------
 * ReverbCalculateSinCos
 *----------------------------------------------------------------------------
 * Purpose:
 * Calculate a new sin and cosine value based on the given phase
 *
 * Inputs:
 * nPhase   - phase angle
 * pnSin    - input old value, output new value
 * pnCos    - input old value, output new value
 *
 * Outputs:
 *
 * Side Effects:
 * - *pnSin, *pnCos are updated
 *
 *----------------------------------------------------------------------------
*/
static EAS_RESULT ReverbCalculateSinCos(EAS_I16 nPhase, EAS_I16 *pnSin, EAS_I16 *pnCos)
{
    EAS_I32 nTemp;
    EAS_I32 nNetAngle;

    //  -1 <=  nPhase  < 1
    // However, for the calculation, we need a value
    // that ranges from -1/2 to +1/2, so divide the phase by 2
    /*lint -e{702} shift for performance */
    nNetAngle = nPhase >> 1;

    /*
    Implement the following
    sin(x) = (2-4*c)*x^2 + c + x
    cos(x) = (2-4*c)*x^2 + c - x

      where  c = 1/sqrt(2)
    using the a0 + x*(a1 + x*a2) approach
    */

    /* limit the input "angle" to be between -0.5 and +0.5 */
    if (nNetAngle > EG1_HALF)
    {
        nNetAngle = EG1_HALF;
    }
    else if (nNetAngle < EG1_MINUS_HALF)
    {
        nNetAngle = EG1_MINUS_HALF;
    }

    /* calculate sin */
    nTemp = EG1_ONE + MULT_EG1_EG1(REVERB_PAN_G2, nNetAngle);
    nTemp = REVERB_PAN_G0 + MULT_EG1_EG1(nTemp, nNetAngle);
    *pnSin = (EAS_I16) SATURATE_EG1(nTemp);

    /* calculate cos */
    nTemp = -EG1_ONE + MULT_EG1_EG1(REVERB_PAN_G2, nNetAngle);
    nTemp = REVERB_PAN_G0 + MULT_EG1_EG1(nTemp, nNetAngle);
    *pnCos = (EAS_I16) SATURATE_EG1(nTemp);

    return EAS_SUCCESS;
}   /* end ReverbCalculateSinCos */

/*----------------------------------------------------------------------------
 * Reverb
 *----------------------------------------------------------------------------
 * Purpose:
 * apply reverb to the given signal
 *
 * Inputs:
 * nNu
 * pnSin    - input old value, output new value
 * pnCos    - input old value, output new value
 *
 * Outputs:
 * number of samples actually reverberated
 *
 * Side Effects:
 *
 *----------------------------------------------------------------------------
*/
static EAS_RESULT Reverb(S_REVERB_OBJECT *pReverbData, EAS_INT nNumSamplesToAdd, EAS_PCM *pOutputBuffer, EAS_PCM *pInputBuffer)
{
    EAS_I32 i;
    EAS_I32 nDelayOut;
    EAS_U16 nBase;

    EAS_U32 nAddr;
    EAS_I32 nTemp1;
    EAS_I32 nTemp2;
    EAS_I32 nApIn;
    EAS_I32 nApOut;

    EAS_I32 j;
    EAS_I32 nEarlyOut;

    EAS_I32 tempValue;


    // get the base address
    nBase = pReverbData->m_nBaseIndex;

    for (i=0; i < nNumSamplesToAdd; i++)
    {
        // ********** Left Allpass - start
        // left input = (left dry/4) + right feedback from previous period
        /*lint -e{702} use shift for performance */
        nApIn = ((*pInputBuffer++)>>2) + pReverbData->m_nRevOutFbkR;
//      nApIn = *pInputBuffer++;    // 1xxx test and debug ap

        // fetch allpass delay line out
        //nAddr = CIRCULAR(nBase, psAp0->m_zApOut, REVERB_BUFFER_MASK);
        nAddr = CIRCULAR(nBase, pReverbData->m_sAp0.m_zApOut, REVERB_BUFFER_MASK);
        nDelayOut = pReverbData->m_nDelayLine[nAddr];

        // calculate allpass feedforward; subtract the feedforward result
        nTemp1 = MULT_EG1_EG1(nApIn, pReverbData->m_sAp0.m_nApGain);
        nApOut = SATURATE(nDelayOut - nTemp1);          // allpass output

        // calculate allpass feedback; add the feedback result
        nTemp1 = MULT_EG1_EG1(nApOut, pReverbData->m_sAp0.m_nApGain);
        nTemp1 = SATURATE(nApIn + nTemp1);

        // inject into allpass delay
        nAddr = CIRCULAR(nBase, pReverbData->m_sAp0.m_zApIn, REVERB_BUFFER_MASK);
        pReverbData->m_nDelayLine[nAddr] = (EAS_PCM) nTemp1;

        // inject allpass output into delay line
        nAddr = CIRCULAR(nBase, pReverbData->m_zD0In, REVERB_BUFFER_MASK);
        pReverbData->m_nDelayLine[nAddr] = (EAS_PCM) nApOut;

        // ********** Left Allpass - end

        // ********** Right Allpass - start
        // right input = (right dry/4) + left feedback from previous period
        /*lint -e{702} use shift for performance */
        nApIn = ((*pInputBuffer++)>>2) + pReverbData->m_nRevOutFbkL;
//      nApIn = *pInputBuffer++;    // 1xxx test and debug ap

        // fetch allpass delay line out
        nAddr = CIRCULAR(nBase, pReverbData->m_sAp1.m_zApOut, REVERB_BUFFER_MASK);
        nDelayOut = pReverbData->m_nDelayLine[nAddr];

        // calculate allpass feedforward; subtract the feedforward result
        nTemp1 = MULT_EG1_EG1(nApIn, pReverbData->m_sAp1.m_nApGain);
        nApOut = SATURATE(nDelayOut - nTemp1);          // allpass output

        // calculate allpass feedback; add the feedback result
        nTemp1 = MULT_EG1_EG1(nApOut, pReverbData->m_sAp1.m_nApGain);
        nTemp1 = SATURATE(nApIn + nTemp1);

        // inject into allpass delay
        nAddr = CIRCULAR(nBase, pReverbData->m_sAp1.m_zApIn, REVERB_BUFFER_MASK);
        pReverbData->m_nDelayLine[nAddr] = (EAS_PCM) nTemp1;

        // inject allpass output into delay line
        nAddr = CIRCULAR(nBase, pReverbData->m_zD1In, REVERB_BUFFER_MASK);
        pReverbData->m_nDelayLine[nAddr] = (EAS_PCM) nApOut;

        // ********** Right Allpass - end

        // ********** D0 output - start
        // fetch delay line self out
        nAddr = CIRCULAR(nBase, pReverbData->m_zD0Self, REVERB_BUFFER_MASK);
        nDelayOut = pReverbData->m_nDelayLine[nAddr];

        // calculate delay line self out
        nTemp1 = MULT_EG1_EG1(nDelayOut, pReverbData->m_nSin);

        // fetch delay line cross out
        nAddr = CIRCULAR(nBase, pReverbData->m_zD1Cross, REVERB_BUFFER_MASK);
        nDelayOut = pReverbData->m_nDelayLine[nAddr];

        // calculate delay line self out
        nTemp2 = MULT_EG1_EG1(nDelayOut, pReverbData->m_nCos);

        // calculate unfiltered delay out
        nDelayOut = SATURATE(nTemp1 + nTemp2);

        // calculate lowpass filter (mixer scale factor included in LPF feedforward)
        nTemp1 = MULT_EG1_EG1(nDelayOut, pReverbData->m_nLpfFwd);

        nTemp2 = MULT_EG1_EG1(pReverbData->m_zLpf0, pReverbData->m_nLpfFbk);

        // calculate filtered delay out and simultaneously update LPF state variable
        // filtered delay output is stored in m_zLpf0
        pReverbData->m_zLpf0 = (EAS_PCM) SATURATE(nTemp1 + nTemp2);

        // ********** D0 output - end

        // ********** D1 output - start
        // fetch delay line self out
        nAddr = CIRCULAR(nBase, pReverbData->m_zD1Self, REVERB_BUFFER_MASK);
        nDelayOut = pReverbData->m_nDelayLine[nAddr];

        // calculate delay line self out
        nTemp1 = MULT_EG1_EG1(nDelayOut, pReverbData->m_nSin);

        // fetch delay line cross out
        nAddr = CIRCULAR(nBase, pReverbData->m_zD0Cross, REVERB_BUFFER_MASK);
        nDelayOut = pReverbData->m_nDelayLine[nAddr];

        // calculate delay line self out
        nTemp2 = MULT_EG1_EG1(nDelayOut, pReverbData->m_nCos);

        // calculate unfiltered delay out
        nDelayOut = SATURATE(nTemp1 + nTemp2);

        // calculate lowpass filter (mixer scale factor included in LPF feedforward)
        nTemp1 = MULT_EG1_EG1(nDelayOut, pReverbData->m_nLpfFwd);

        nTemp2 = MULT_EG1_EG1(pReverbData->m_zLpf1, pReverbData->m_nLpfFbk);

        // calculate filtered delay out and simultaneously update LPF state variable
        // filtered delay output is stored in m_zLpf1
        pReverbData->m_zLpf1 = (EAS_PCM)SATURATE(nTemp1 + nTemp2);

        // ********** D1 output - end

        // ********** mixer and feedback - start
        // sum is fedback to right input (R + L)
        pReverbData->m_nRevOutFbkL =
            (EAS_PCM)SATURATE((EAS_I32)pReverbData->m_zLpf1 + (EAS_I32)pReverbData->m_zLpf0);

        // difference is feedback to left input (R - L)
        /*lint -e{685} lint complains that it can't saturate negative */
        pReverbData->m_nRevOutFbkR =
            (EAS_PCM)SATURATE((EAS_I32)pReverbData->m_zLpf1 - (EAS_I32)pReverbData->m_zLpf0);

        // ********** mixer and feedback - end

        // ********** start early reflection generator, left
        //psEarly = &(pReverbData->m_sEarlyL);

        nEarlyOut = 0;

        for (j=0; j < REVERB_MAX_NUM_REFLECTIONS; j++)
        {
            // fetch delay line out
            //nAddr = CIRCULAR(nBase, psEarly->m_zDelay[j], REVERB_BUFFER_MASK);
            nAddr = CIRCULAR(nBase, pReverbData->m_sEarlyL.m_zDelay[j], REVERB_BUFFER_MASK);

            nDelayOut = pReverbData->m_nDelayLine[nAddr];

            // calculate reflection
            //nTemp1 = MULT_EG1_EG1(nDelayOut, psEarly->m_nGain[j]);
            nTemp1 = MULT_EG1_EG1(nDelayOut, pReverbData->m_sEarlyL.m_nGain[j]);

            nEarlyOut = SATURATE(nEarlyOut + nTemp1);

        }   // end for (j=0; j < REVERB_MAX_NUM_REFLECTIONS; j++)

        // apply lowpass to early reflections
        //nTemp1 = MULT_EG1_EG1(nEarlyOut, psEarly->m_nLpfFwd);
        nTemp1 = MULT_EG1_EG1(nEarlyOut, pReverbData->m_sEarlyL.m_nLpfFwd);

        //nTemp2 = MULT_EG1_EG1(psEarly->m_zLpf, psEarly->m_nLpfFbk);
        nTemp2 = MULT_EG1_EG1(pReverbData->m_sEarlyL.m_zLpf, pReverbData->m_sEarlyL.m_nLpfFbk);


        // calculate filtered out and simultaneously update LPF state variable
        // filtered output is stored in m_zLpf1
        //psEarly->m_zLpf = SATURATE(nTemp1 + nTemp2);
        pReverbData->m_sEarlyL.m_zLpf = (EAS_PCM) SATURATE(nTemp1 + nTemp2);

        // combine filtered early and late reflections for output
        //*pOutputBuffer++ = inL;
        //tempValue = SATURATE(psEarly->m_zLpf + pReverbData->m_nRevOutFbkL);
        tempValue = SATURATE((EAS_I32)pReverbData->m_sEarlyL.m_zLpf + (EAS_I32)pReverbData->m_nRevOutFbkL);
        //scale reverb output by wet level
        /*lint -e{701} use shift for performance */
        tempValue = MULT_EG1_EG1(tempValue, (pReverbData->m_nWet<<1));
        //sum with output buffer
        tempValue += *pOutputBuffer;
        *pOutputBuffer++ = (EAS_PCM)SATURATE(tempValue);

        // ********** end early reflection generator, left

        // ********** start early reflection generator, right
        //psEarly = &(pReverbData->m_sEarlyR);

        nEarlyOut = 0;

        for (j=0; j < REVERB_MAX_NUM_REFLECTIONS; j++)
        {
            // fetch delay line out
            nAddr = CIRCULAR(nBase, pReverbData->m_sEarlyR.m_zDelay[j], REVERB_BUFFER_MASK);
            nDelayOut = pReverbData->m_nDelayLine[nAddr];

            // calculate reflection
            nTemp1 = MULT_EG1_EG1(nDelayOut, pReverbData->m_sEarlyR.m_nGain[j]);

            nEarlyOut = SATURATE(nEarlyOut + nTemp1);

        }   // end for (j=0; j < REVERB_MAX_NUM_REFLECTIONS; j++)

        // apply lowpass to early reflections
        nTemp1 = MULT_EG1_EG1(nEarlyOut, pReverbData->m_sEarlyR.m_nLpfFwd);

        nTemp2 = MULT_EG1_EG1(pReverbData->m_sEarlyR.m_zLpf, pReverbData->m_sEarlyR.m_nLpfFbk);

        // calculate filtered out and simultaneously update LPF state variable
        // filtered output is stored in m_zLpf1
        pReverbData->m_sEarlyR.m_zLpf = (EAS_PCM)SATURATE(nTemp1 + nTemp2);

        // combine filtered early and late reflections for output
        //*pOutputBuffer++ = inR;
        tempValue = SATURATE((EAS_I32)pReverbData->m_sEarlyR.m_zLpf + (EAS_I32)pReverbData->m_nRevOutFbkR);
        //scale reverb output by wet level
        /*lint -e{701} use shift for performance */
        tempValue = MULT_EG1_EG1(tempValue, (pReverbData->m_nWet << 1));
        //sum with output buffer
        tempValue = tempValue + *pOutputBuffer;
        *pOutputBuffer++ = (EAS_PCM)SATURATE(tempValue);

        // ********** end early reflection generator, right

        // decrement base addr for next sample period
        nBase--;

        pReverbData->m_nSin += pReverbData->m_nSinIncrement;
        pReverbData->m_nCos += pReverbData->m_nCosIncrement;

    }   // end for (i=0; i < nNumSamplesToAdd; i++)

    // store the most up to date version
    pReverbData->m_nBaseIndex = nBase;

    return EAS_SUCCESS;
}   /* end Reverb */



/*----------------------------------------------------------------------------
 * ReverbShutdown()
 *----------------------------------------------------------------------------
 * Purpose:
 * Initializes the Reverb effect.
 *
 * Inputs:
 * pInstData        - handle to instance data
 *
 * Outputs:
 *
 *
 * Side Effects:
 *
 *----------------------------------------------------------------------------
*/
static EAS_RESULT ReverbShutdown (EAS_DATA_HANDLE pEASData, EAS_VOID_PTR pInstData)
{
    /* check Configuration Module for static memory allocation */
    if (!pEASData->staticMemoryModel)
        EAS_HWFree(pEASData->hwInstData, pInstData);
    return EAS_SUCCESS;
} /* end ReverbShutdown */

/*----------------------------------------------------------------------------
 * ReverbGetParam()
 *----------------------------------------------------------------------------
 * Purpose:
 * Get a Reverb parameter
 *
 * Inputs:
 * pInstData        - handle to instance data
 * param            - parameter index
 * *pValue          - pointer to variable to hold retrieved value
 *
 * Outputs:
 *
 *
 * Side Effects:
 *
 *----------------------------------------------------------------------------
*/
static EAS_RESULT ReverbGetParam (EAS_VOID_PTR pInstData, EAS_I32 param, EAS_I32 *pValue)
{
    S_REVERB_OBJECT *p;

    p = (S_REVERB_OBJECT*) pInstData;

    switch (param)
    {
        case EAS_PARAM_REVERB_BYPASS:
            *pValue = (EAS_I32) p->m_bBypass;
            break;
        case EAS_PARAM_REVERB_PRESET:
            *pValue = (EAS_I8) p->m_nCurrentRoom;
            break;
        case EAS_PARAM_REVERB_WET:
            *pValue = p->m_nWet;
            break;
        case EAS_PARAM_REVERB_DRY:
            *pValue = p->m_nDry;
            break;
        default:
            return EAS_ERROR_INVALID_PARAMETER;
    }
    return EAS_SUCCESS;
} /* end ReverbGetParam */


/*----------------------------------------------------------------------------
 * ReverbSetParam()
 *----------------------------------------------------------------------------
 * Purpose:
 * Set a Reverb parameter
 *
 * Inputs:
 * pInstData        - handle to instance data
 * param            - parameter index
 * *pValue          - new paramter value
 *
 * Outputs:
 *
 *
 * Side Effects:
 *
 *----------------------------------------------------------------------------
*/
static EAS_RESULT ReverbSetParam (EAS_VOID_PTR pInstData, EAS_I32 param, EAS_I32 value)
{
    S_REVERB_OBJECT *p;

    p = (S_REVERB_OBJECT*) pInstData;

    switch (param)
    {
        case EAS_PARAM_REVERB_BYPASS:
            p->m_bBypass = (EAS_BOOL) value;
            break;
        case EAS_PARAM_REVERB_PRESET:
            if(value!=EAS_PARAM_REVERB_LARGE_HALL && value!=EAS_PARAM_REVERB_HALL &&
                value!=EAS_PARAM_REVERB_CHAMBER && value!=EAS_PARAM_REVERB_ROOM)
                return EAS_ERROR_INVALID_PARAMETER;
            p->m_nNextRoom = (EAS_I16)value;
            break;
        case EAS_PARAM_REVERB_WET:
            if(value>EAS_REVERB_WET_MAX || value<EAS_REVERB_WET_MIN)
                return EAS_ERROR_INVALID_PARAMETER;
            p->m_nWet = (EAS_I16)value;
            break;
        case EAS_PARAM_REVERB_DRY:
            if(value>EAS_REVERB_DRY_MAX || value<EAS_REVERB_DRY_MIN)
                return EAS_ERROR_INVALID_PARAMETER;
            p->m_nDry = (EAS_I16)value;
            break;
        default:
            return EAS_ERROR_INVALID_PARAMETER;
    }
    return EAS_SUCCESS;
} /* end ReverbSetParam */


/*----------------------------------------------------------------------------
 * ReverbUpdateRoom
 *----------------------------------------------------------------------------
 * Purpose:
 * Update the room's preset parameters as required
 *
 * Inputs:
 *
 * Outputs:
 *
 *
 * Side Effects:
 * - reverb paramters (fbk, fwd, etc) will be changed
 * - m_nCurrentRoom := m_nNextRoom
 *----------------------------------------------------------------------------
*/
static EAS_RESULT ReverbUpdateRoom(S_REVERB_OBJECT *pReverbData)
{
    EAS_INT temp;

    S_REVERB_PRESET *pPreset = &pReverbData->m_sPreset.m_sPreset[pReverbData->m_nNextRoom];

    pReverbData->m_nLpfFwd = pPreset->m_nLpfFwd;
    pReverbData->m_nLpfFbk = pPreset->m_nLpfFbk;

    pReverbData->m_nEarly = pPreset->m_nEarly;
    pReverbData->m_nWet = pPreset->m_nWet;
    pReverbData->m_nDry = pPreset->m_nDry;


    pReverbData->m_nMaxExcursion = pPreset->m_nMaxExcursion;
    //stored as time based, convert to sample based
    temp = pPreset->m_nXfadeInterval;
    /*lint -e{702} shift for performance */
    temp = (temp * _OUTPUT_SAMPLE_RATE) >> 16;
    pReverbData->m_nXfadeInterval = (EAS_U16) temp;
    //gpsReverbObject->m_nXfadeInterval = pPreset->m_nXfadeInterval;
    pReverbData->m_sAp0.m_nApGain = pPreset->m_nAp0_ApGain;
    //stored as time based, convert to absolute sample value
    temp = pPreset->m_nAp0_ApOut;
    /*lint -e{702} shift for performance */
    temp = (temp * _OUTPUT_SAMPLE_RATE) >> 16;
    pReverbData->m_sAp0.m_zApOut = (EAS_U16) (pReverbData->m_sAp0.m_zApIn + temp);
    //gpsReverbObject->m_sAp0.m_zApOut = pPreset->m_nAp0_ApOut;
    pReverbData->m_sAp1.m_nApGain = pPreset->m_nAp1_ApGain;
    //stored as time based, convert to absolute sample value
    temp = pPreset->m_nAp1_ApOut;
    /*lint -e{702} shift for performance */
    temp = (temp * _OUTPUT_SAMPLE_RATE) >> 16;
    pReverbData->m_sAp1.m_zApOut = (EAS_U16) (pReverbData->m_sAp1.m_zApIn + temp);
    //gpsReverbObject->m_sAp1.m_zApOut = pPreset->m_nAp1_ApOut;

    pReverbData->m_nCurrentRoom = pReverbData->m_nNextRoom;

    return EAS_SUCCESS;

}   /* end ReverbUpdateRoom */


/*----------------------------------------------------------------------------
 * ReverbReadInPresets()
 *----------------------------------------------------------------------------
 * Purpose: sets global reverb preset bank to defaults
 *
 * Inputs:
 *
 * Outputs:
 *
 *----------------------------------------------------------------------------
*/
static EAS_RESULT ReverbReadInPresets(S_REVERB_OBJECT *pReverbData)
{

    int preset = 0;
    int defaultPreset = 0;

    //now init any remaining presets to defaults
    for (defaultPreset = preset; defaultPreset < REVERB_MAX_ROOM_TYPE; defaultPreset++)
    {
        S_REVERB_PRESET *pPreset = &pReverbData->m_sPreset.m_sPreset[defaultPreset];
        if (defaultPreset == 0 || defaultPreset > REVERB_MAX_ROOM_TYPE-1)
        {
            pPreset->m_nLpfFbk = 8307;
            pPreset->m_nLpfFwd = 14768;
            pPreset->m_nEarly = 0;
            pPreset->m_nWet = 27690;
            pPreset->m_nDry = 32767;
            pPreset->m_nEarlyL_LpfFbk = 3692;
            pPreset->m_nEarlyL_LpfFwd = 29075;
            pPreset->m_nEarlyL_Delay0 = 922;
            pPreset->m_nEarlyL_Gain0 = 22152;
            pPreset->m_nEarlyL_Delay1 = 1462;
            pPreset->m_nEarlyL_Gain1 = 17537;
            pPreset->m_nEarlyL_Delay2 = 0;
            pPreset->m_nEarlyL_Gain2 = 14768;
            pPreset->m_nEarlyL_Delay3 = 1221;
            pPreset->m_nEarlyL_Gain3 = 14307;
            pPreset->m_nEarlyL_Delay4 = 0;
            pPreset->m_nEarlyL_Gain4 = 13384;
            pPreset->m_nEarlyR_Delay0 = 502;
            pPreset->m_nEarlyR_Gain0 = 20306;
            pPreset->m_nEarlyR_Delay1 = 1762;
            pPreset->m_nEarlyR_Gain1 = 17537;
            pPreset->m_nEarlyR_Delay2 = 0;
            pPreset->m_nEarlyR_Gain2 = 14768;
            pPreset->m_nEarlyR_Delay3 = 0;
            pPreset->m_nEarlyR_Gain3 = 16153;
            pPreset->m_nEarlyR_Delay4 = 0;
            pPreset->m_nEarlyR_Gain4 = 13384;
            pPreset->m_nMaxExcursion = 127;
            pPreset->m_nXfadeInterval = 6388;
            pPreset->m_nAp0_ApGain = 15691;
            pPreset->m_nAp0_ApOut = 711;
            pPreset->m_nAp1_ApGain = 17999;
            pPreset->m_nAp1_ApOut = 1113;
            pPreset->m_rfu4 = 0;
            pPreset->m_rfu5 = 0;
            pPreset->m_rfu6 = 0;
            pPreset->m_rfu7 = 0;
            pPreset->m_rfu8 = 0;
            pPreset->m_rfu9 = 0;
            pPreset->m_rfu10 = 0;
        }
        else if (defaultPreset == 1)
        {
            pPreset->m_nLpfFbk = 6461;
            pPreset->m_nLpfFwd = 14307;
            pPreset->m_nEarly = 0;
            pPreset->m_nWet = 27690;
            pPreset->m_nDry = 32767;
            pPreset->m_nEarlyL_LpfFbk = 3692;
            pPreset->m_nEarlyL_LpfFwd = 29075;
            pPreset->m_nEarlyL_Delay0 = 922;
            pPreset->m_nEarlyL_Gain0 = 22152;
            pPreset->m_nEarlyL_Delay1 = 1462;
            pPreset->m_nEarlyL_Gain1 = 17537;
            pPreset->m_nEarlyL_Delay2 = 0;
            pPreset->m_nEarlyL_Gain2 = 14768;
            pPreset->m_nEarlyL_Delay3 = 1221;
            pPreset->m_nEarlyL_Gain3 = 14307;
            pPreset->m_nEarlyL_Delay4 = 0;
            pPreset->m_nEarlyL_Gain4 = 13384;
            pPreset->m_nEarlyR_Delay0 = 502;
            pPreset->m_nEarlyR_Gain0 = 20306;
            pPreset->m_nEarlyR_Delay1 = 1762;
            pPreset->m_nEarlyR_Gain1 = 17537;
            pPreset->m_nEarlyR_Delay2 = 0;
            pPreset->m_nEarlyR_Gain2 = 14768;
            pPreset->m_nEarlyR_Delay3 = 0;
            pPreset->m_nEarlyR_Gain3 = 16153;
            pPreset->m_nEarlyR_Delay4 = 0;
            pPreset->m_nEarlyR_Gain4 = 13384;
            pPreset->m_nMaxExcursion = 127;
            pPreset->m_nXfadeInterval = 6391;
            pPreset->m_nAp0_ApGain = 15230;
            pPreset->m_nAp0_ApOut = 708;
            pPreset->m_nAp1_ApGain = 9692;
            pPreset->m_nAp1_ApOut = 1113;
            pPreset->m_rfu4 = 0;
            pPreset->m_rfu5 = 0;
            pPreset->m_rfu6 = 0;
            pPreset->m_rfu7 = 0;
            pPreset->m_rfu8 = 0;
            pPreset->m_rfu9 = 0;
            pPreset->m_rfu10 = 0;
        }
        else if (defaultPreset == 2)
        {
            pPreset->m_nLpfFbk = 5077;
            pPreset->m_nLpfFwd = 12922;
            pPreset->m_nEarly = 0;
            pPreset->m_nWet = 24460;
            pPreset->m_nDry = 32767;
            pPreset->m_nEarlyL_LpfFbk = 3692;
            pPreset->m_nEarlyL_LpfFwd = 29075;
            pPreset->m_nEarlyL_Delay0 = 922;
            pPreset->m_nEarlyL_Gain0 = 22152;
            pPreset->m_nEarlyL_Delay1 = 1462;
            pPreset->m_nEarlyL_Gain1 = 17537;
            pPreset->m_nEarlyL_Delay2 = 0;
            pPreset->m_nEarlyL_Gain2 = 14768;
            pPreset->m_nEarlyL_Delay3 = 1221;
            pPreset->m_nEarlyL_Gain3 = 14307;
            pPreset->m_nEarlyL_Delay4 = 0;
            pPreset->m_nEarlyL_Gain4 = 13384;
            pPreset->m_nEarlyR_Delay0 = 502;
            pPreset->m_nEarlyR_Gain0 = 20306;
            pPreset->m_nEarlyR_Delay1 = 1762;
            pPreset->m_nEarlyR_Gain1 = 17537;
            pPreset->m_nEarlyR_Delay2 = 0;
            pPreset->m_nEarlyR_Gain2 = 14768;
            pPreset->m_nEarlyR_Delay3 = 0;
            pPreset->m_nEarlyR_Gain3 = 16153;
            pPreset->m_nEarlyR_Delay4 = 0;
            pPreset->m_nEarlyR_Gain4 = 13384;
            pPreset->m_nMaxExcursion = 127;
            pPreset->m_nXfadeInterval = 6449;
            pPreset->m_nAp0_ApGain = 15691;
            pPreset->m_nAp0_ApOut = 774;
            pPreset->m_nAp1_ApGain = 15691;
            pPreset->m_nAp1_ApOut = 1113;
            pPreset->m_rfu4 = 0;
            pPreset->m_rfu5 = 0;
            pPreset->m_rfu6 = 0;
            pPreset->m_rfu7 = 0;
            pPreset->m_rfu8 = 0;
            pPreset->m_rfu9 = 0;
            pPreset->m_rfu10 = 0;
        }
        else if (defaultPreset == 3)
        {
            pPreset->m_nLpfFbk = 5077;
            pPreset->m_nLpfFwd = 11076;
            pPreset->m_nEarly = 0;
            pPreset->m_nWet = 23075;
            pPreset->m_nDry = 32767;
            pPreset->m_nEarlyL_LpfFbk = 3692;
            pPreset->m_nEarlyL_LpfFwd = 29075;
            pPreset->m_nEarlyL_Delay0 = 922;
            pPreset->m_nEarlyL_Gain0 = 22152;
            pPreset->m_nEarlyL_Delay1 = 1462;
            pPreset->m_nEarlyL_Gain1 = 17537;
            pPreset->m_nEarlyL_Delay2 = 0;
            pPreset->m_nEarlyL_Gain2 = 14768;
            pPreset->m_nEarlyL_Delay3 = 1221;
            pPreset->m_nEarlyL_Gain3 = 14307;
            pPreset->m_nEarlyL_Delay4 = 0;
            pPreset->m_nEarlyL_Gain4 = 13384;
            pPreset->m_nEarlyR_Delay0 = 502;
            pPreset->m_nEarlyR_Gain0 = 20306;
            pPreset->m_nEarlyR_Delay1 = 1762;
            pPreset->m_nEarlyR_Gain1 = 17537;
            pPreset->m_nEarlyR_Delay2 = 0;
            pPreset->m_nEarlyR_Gain2 = 14768;
            pPreset->m_nEarlyR_Delay3 = 0;
            pPreset->m_nEarlyR_Gain3 = 16153;
            pPreset->m_nEarlyR_Delay4 = 0;
            pPreset->m_nEarlyR_Gain4 = 13384;
            pPreset->m_nMaxExcursion = 127;
            pPreset->m_nXfadeInterval = 6470;   //6483;
            pPreset->m_nAp0_ApGain = 14768;
            pPreset->m_nAp0_ApOut = 792;
            pPreset->m_nAp1_ApGain = 15783;
            pPreset->m_nAp1_ApOut = 1113;
            pPreset->m_rfu4 = 0;
            pPreset->m_rfu5 = 0;
            pPreset->m_rfu6 = 0;
            pPreset->m_rfu7 = 0;
            pPreset->m_rfu8 = 0;
            pPreset->m_rfu9 = 0;
            pPreset->m_rfu10 = 0;

        }
    }

    return EAS_SUCCESS;
}