king
/
v811_spc009
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'main'
${ noResults }
v811_spc009/external/sonivox/arm-wt-22k/lib_src/eas_reverb.c

1155 lines
39 KiB
Raw Permalink Blame History

/*----------------------------------------------------------------------------
*
* 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;
}
Reference in new issue View Git Blame Copy Permalink