1/*----------------------------------------------------------------------------
2 *
3 * File:
4 * eas_reverb.c
5 *
6 * Contents and purpose:
7 * Contains the implementation of the Reverb effect.
8 *
9 *
10 * Copyright Sonic Network Inc. 2006
11
12 * Licensed under the Apache License, Version 2.0 (the "License");
13 * you may not use this file except in compliance with the License.
14 * You may obtain a copy of the License at
15 *
16 *      http://www.apache.org/licenses/LICENSE-2.0
17 *
18 * Unless required by applicable law or agreed to in writing, software
19 * distributed under the License is distributed on an "AS IS" BASIS,
20 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
21 * See the License for the specific language governing permissions and
22 * limitations under the License.
23 *
24 *----------------------------------------------------------------------------
25 * Revision Control:
26 *   $Revision: 510 $
27 *   $Date: 2006-12-19 01:47:33 -0800 (Tue, 19 Dec 2006) $
28 *----------------------------------------------------------------------------
29*/
30
31/*------------------------------------
32 * includes
33 *------------------------------------
34*/
35
36#include "eas_data.h"
37#include "eas_effects.h"
38#include "eas_math.h"
39#include "eas_reverbdata.h"
40#include "eas_reverb.h"
41#include "eas_config.h"
42#include "eas_host.h"
43#include "eas_report.h"
44
45/* prototypes for effects interface */
46static EAS_RESULT ReverbInit (EAS_DATA_HANDLE pEASData, EAS_VOID_PTR *pInstData);
47static void ReverbProcess (EAS_VOID_PTR pInstData, EAS_PCM *pSrc, EAS_PCM *pDst, EAS_I32 numSamples);
48static EAS_RESULT ReverbShutdown (EAS_DATA_HANDLE pEASData, EAS_VOID_PTR pInstData);
49static EAS_RESULT ReverbGetParam (EAS_VOID_PTR pInstData, EAS_I32 param, EAS_I32 *pValue);
50static EAS_RESULT ReverbSetParam (EAS_VOID_PTR pInstData, EAS_I32 param, EAS_I32 value);
51
52/* common effects interface for configuration module */
53const S_EFFECTS_INTERFACE EAS_Reverb =
54{
55    ReverbInit,
56    ReverbProcess,
57    ReverbShutdown,
58    ReverbGetParam,
59    ReverbSetParam
60};
61
62
63
64/*----------------------------------------------------------------------------
65 * InitializeReverb()
66 *----------------------------------------------------------------------------
67 * Purpose:
68 *
69 * Inputs:
70 *
71 * Outputs:
72 *
73 *----------------------------------------------------------------------------
74*/
75static EAS_RESULT ReverbInit(EAS_DATA_HANDLE pEASData, EAS_VOID_PTR *pInstData)
76{
77    EAS_I32 i;
78    EAS_U16 nOffset;
79    EAS_INT temp;
80
81    S_REVERB_OBJECT *pReverbData;
82    S_REVERB_PRESET *pPreset;
83
84    /* check Configuration Module for data allocation */
85    if (pEASData->staticMemoryModel)
86        pReverbData = EAS_CMEnumFXData(EAS_MODULE_REVERB);
87
88    /* allocate dynamic memory */
89    else
90        pReverbData = EAS_HWMalloc(pEASData->hwInstData, sizeof(S_REVERB_OBJECT));
91
92    if (pReverbData == NULL)
93    {
94        { /* dpp: EAS_ReportEx(_EAS_SEVERITY_FATAL, "Failed to allocate Reverb memory\n"); */ }
95        return EAS_ERROR_MALLOC_FAILED;
96    }
97
98    /* clear the structure */
99    EAS_HWMemSet(pReverbData, 0, sizeof(S_REVERB_OBJECT));
100
101    ReverbReadInPresets(pReverbData);
102
103    pReverbData->m_nMinSamplesToAdd = REVERB_UPDATE_PERIOD_IN_SAMPLES;
104
105    pReverbData->m_nRevOutFbkR = 0;
106    pReverbData->m_nRevOutFbkL = 0;
107
108    pReverbData->m_sAp0.m_zApIn  = AP0_IN;
109    pReverbData->m_sAp0.m_zApOut = AP0_IN + DEFAULT_AP0_LENGTH;
110    pReverbData->m_sAp0.m_nApGain = DEFAULT_AP0_GAIN;
111
112    pReverbData->m_zD0In = DELAY0_IN;
113
114    pReverbData->m_sAp1.m_zApIn  = AP1_IN;
115    pReverbData->m_sAp1.m_zApOut = AP1_IN + DEFAULT_AP1_LENGTH;
116    pReverbData->m_sAp1.m_nApGain = DEFAULT_AP1_GAIN;
117
118    pReverbData->m_zD1In = DELAY1_IN;
119
120    pReverbData->m_zLpf0    = 0;
121    pReverbData->m_zLpf1    = 0;
122    pReverbData->m_nLpfFwd  = 8837;
123    pReverbData->m_nLpfFbk  = 6494;
124
125    pReverbData->m_nSin     = 0;
126    pReverbData->m_nCos     = 0;
127    pReverbData->m_nSinIncrement    = 0;
128    pReverbData->m_nCosIncrement    = 0;
129
130    // set xfade parameters
131    pReverbData->m_nXfadeInterval = (EAS_U16)REVERB_XFADE_PERIOD_IN_SAMPLES;
132    pReverbData->m_nXfadeCounter = pReverbData->m_nXfadeInterval + 1;   // force update on first iteration
133    pReverbData->m_nPhase = -32768;
134    pReverbData->m_nPhaseIncrement = REVERB_XFADE_PHASE_INCREMENT;
135
136    pReverbData->m_nNoise = (EAS_I16)0xABCD;
137
138    pReverbData->m_nMaxExcursion = 0x007F;
139
140    // set delay tap lengths
141    nOffset = ReverbCalculateNoise( pReverbData->m_nMaxExcursion,
142                                    &pReverbData->m_nNoise );
143
144    pReverbData->m_zD1Cross =
145        DELAY1_OUT - pReverbData->m_nMaxExcursion + nOffset;
146
147    nOffset = ReverbCalculateNoise( pReverbData->m_nMaxExcursion,
148                                    &pReverbData->m_nNoise );
149
150    pReverbData->m_zD0Cross =
151        DELAY1_OUT - pReverbData->m_nMaxExcursion - nOffset;
152
153    nOffset = ReverbCalculateNoise( pReverbData->m_nMaxExcursion,
154                                    &pReverbData->m_nNoise );
155
156    pReverbData->m_zD0Self  =
157        DELAY0_OUT - pReverbData->m_nMaxExcursion - nOffset;
158
159    nOffset = ReverbCalculateNoise( pReverbData->m_nMaxExcursion,
160                                    &pReverbData->m_nNoise );
161
162    pReverbData->m_zD1Self  =
163        DELAY1_OUT - pReverbData->m_nMaxExcursion + nOffset;
164
165    // for debugging purposes, allow noise generator
166    pReverbData->m_bUseNoise = EAS_FALSE;
167
168    // for debugging purposes, allow bypass
169    pReverbData->m_bBypass = EAS_TRUE;  //EAS_FALSE;
170
171    pReverbData->m_nNextRoom = 1;
172
173    pReverbData->m_nCurrentRoom = pReverbData->m_nNextRoom + 1; // force update on first iteration
174
175    pReverbData->m_nWet = REVERB_DEFAULT_WET;
176
177    pReverbData->m_nDry = REVERB_DEFAULT_DRY;
178
179    // set base index into circular buffer
180    pReverbData->m_nBaseIndex = 0;
181
182    // set the early reflections, L
183    pReverbData->m_sEarlyL.m_nLpfFbk = 4915;
184    pReverbData->m_sEarlyL.m_nLpfFwd = 27852;
185    pReverbData->m_sEarlyL.m_zLpf = 0;
186
187    for (i=0; i < REVERB_MAX_NUM_REFLECTIONS; i++)
188    {
189        pReverbData->m_sEarlyL.m_nGain[i] = 0;
190        pReverbData->m_sEarlyL.m_zDelay[i] = 0;
191    }
192
193    // set the early reflections, R
194    pReverbData->m_sEarlyR.m_nLpfFbk = 4915;
195    pReverbData->m_sEarlyR.m_nLpfFwd = 27852;
196    pReverbData->m_sEarlyR.m_zLpf = 0;
197
198    for (i=0; i < REVERB_MAX_NUM_REFLECTIONS; i++)
199    {
200        pReverbData->m_sEarlyR.m_nGain[i] = 0;
201        pReverbData->m_sEarlyR.m_zDelay[i] = 0;
202    }
203
204    // clear the reverb delay line
205    for (i=0; i < REVERB_BUFFER_SIZE_IN_SAMPLES; i++)
206    {
207        pReverbData->m_nDelayLine[i] = 0;
208    }
209
210    ////////////////////////////////
211    ///code from the EAS DEMO Reverb
212    //now copy from the new preset into the reverb
213    pPreset = &pReverbData->m_sPreset.m_sPreset[pReverbData->m_nNextRoom];
214
215    pReverbData->m_nLpfFbk = pPreset->m_nLpfFbk;
216    pReverbData->m_nLpfFwd = pPreset->m_nLpfFwd;
217
218    pReverbData->m_nEarly = pPreset->m_nEarly;
219    pReverbData->m_nWet = pPreset->m_nWet;
220    pReverbData->m_nDry = pPreset->m_nDry;
221
222    pReverbData->m_nMaxExcursion = pPreset->m_nMaxExcursion;
223    //stored as time based, convert to sample based
224    temp = pPreset->m_nXfadeInterval;
225    /*lint -e{702} shift for performance */
226    temp = (temp * _OUTPUT_SAMPLE_RATE) >> 16;
227    pReverbData->m_nXfadeInterval = (EAS_U16) temp;
228    //gsReverbObject.m_nXfadeInterval = pPreset->m_nXfadeInterval;
229
230    pReverbData->m_sAp0.m_nApGain = pPreset->m_nAp0_ApGain;
231    //stored as time based, convert to absolute sample value
232    temp = pPreset->m_nAp0_ApOut;
233    /*lint -e{702} shift for performance */
234    temp = (temp * _OUTPUT_SAMPLE_RATE) >> 16;
235    pReverbData->m_sAp0.m_zApOut = (EAS_U16) (pReverbData->m_sAp0.m_zApIn + temp);
236    //gsReverbObject.m_sAp0.m_zApOut = pPreset->m_nAp0_ApOut;
237
238    pReverbData->m_sAp1.m_nApGain = pPreset->m_nAp1_ApGain;
239    //stored as time based, convert to absolute sample value
240    temp = pPreset->m_nAp1_ApOut;
241    /*lint -e{702} shift for performance */
242    temp = (temp * _OUTPUT_SAMPLE_RATE) >> 16;
243    pReverbData->m_sAp1.m_zApOut = (EAS_U16) (pReverbData->m_sAp1.m_zApIn + temp);
244    //gsReverbObject.m_sAp1.m_zApOut = pPreset->m_nAp1_ApOut;
245    ///code from the EAS DEMO Reverb
246    ////////////////////////////////
247
248    *pInstData = pReverbData;
249
250    return EAS_SUCCESS;
251
252}   /* end InitializeReverb */
253
254
255
256/*----------------------------------------------------------------------------
257 * ReverbProcess()
258 *----------------------------------------------------------------------------
259 * Purpose:
260 * Reverberate the requested number of samples (block based processing)
261 *
262 * Inputs:
263 * pInputBuffer - src buffer
264 * pOutputBuffer - dst buffer
265 * nNumSamplesToAdd - number of samples to write to buffer
266 *
267 * Outputs:
268 * number of samples actually written to buffer
269 *
270 * Side Effects:
271 * - samples are added to the presently free buffer
272 *
273 *----------------------------------------------------------------------------
274*/
275static void ReverbProcess(EAS_VOID_PTR pInstData, EAS_PCM *pSrc, EAS_PCM *pDst, EAS_I32 numSamples)
276{
277    S_REVERB_OBJECT *pReverbData;
278
279    pReverbData = (S_REVERB_OBJECT*) pInstData;
280
281    //if bypassed or the preset forces the signal to be completely dry
282    if (pReverbData->m_bBypass ||
283        (pReverbData->m_nWet == 0 && pReverbData->m_nDry == 32767))
284    {
285        if (pSrc != pDst)
286            EAS_HWMemCpy(pSrc, pDst, numSamples * NUM_OUTPUT_CHANNELS * (EAS_I32) sizeof(EAS_PCM));
287        return;
288    }
289
290    if (pReverbData->m_nNextRoom != pReverbData->m_nCurrentRoom)
291    {
292        ReverbUpdateRoom(pReverbData);
293    }
294
295    ReverbUpdateXfade(pReverbData, numSamples);
296
297    Reverb(pReverbData, numSamples, pDst, pSrc);
298
299    /* check if update counter needs to be reset */
300    if (pReverbData->m_nUpdateCounter >= REVERB_MODULO_UPDATE_PERIOD_IN_SAMPLES)
301    {
302        /* update interval has elapsed, so reset counter */
303        pReverbData->m_nUpdateCounter = 0;
304    }   /* end if m_nUpdateCounter >= update interval */
305
306    /* increment update counter */
307    pReverbData->m_nUpdateCounter += (EAS_I16)numSamples;
308
309}   /* end ComputeReverb */
310
311/*----------------------------------------------------------------------------
312 * ReverbUpdateXfade
313 *----------------------------------------------------------------------------
314 * Purpose:
315 * Update the xfade parameters as required
316 *
317 * Inputs:
318 * nNumSamplesToAdd - number of samples to write to buffer
319 *
320 * Outputs:
321 *
322 *
323 * Side Effects:
324 * - xfade parameters will be changed
325 *
326 *----------------------------------------------------------------------------
327*/
328static EAS_RESULT ReverbUpdateXfade(S_REVERB_OBJECT *pReverbData, EAS_INT nNumSamplesToAdd)
329{
330    EAS_U16 nOffset;
331    EAS_I16 tempCos;
332    EAS_I16 tempSin;
333
334    if (pReverbData->m_nXfadeCounter >= pReverbData->m_nXfadeInterval)
335    {
336        /* update interval has elapsed, so reset counter */
337        pReverbData->m_nXfadeCounter = 0;
338
339        // Pin the sin,cos values to min / max values to ensure that the
340        // modulated taps' coefs are zero (thus no clicks)
341        if (pReverbData->m_nPhaseIncrement > 0)
342        {
343            // if phase increment > 0, then sin -> 1, cos -> 0
344            pReverbData->m_nSin = 32767;
345            pReverbData->m_nCos = 0;
346
347            // reset the phase to match the sin, cos values
348            pReverbData->m_nPhase = 32767;
349
350            // modulate the cross taps because their tap coefs are zero
351            nOffset = ReverbCalculateNoise( pReverbData->m_nMaxExcursion, &pReverbData->m_nNoise );
352
353            pReverbData->m_zD1Cross =
354                DELAY1_OUT - pReverbData->m_nMaxExcursion + nOffset;
355
356            nOffset = ReverbCalculateNoise( pReverbData->m_nMaxExcursion, &pReverbData->m_nNoise );
357
358            pReverbData->m_zD0Cross =
359                DELAY0_OUT - pReverbData->m_nMaxExcursion - nOffset;
360        }
361        else
362        {
363            // if phase increment < 0, then sin -> 0, cos -> 1
364            pReverbData->m_nSin = 0;
365            pReverbData->m_nCos = 32767;
366
367            // reset the phase to match the sin, cos values
368            pReverbData->m_nPhase = -32768;
369
370            // modulate the self taps because their tap coefs are zero
371            nOffset = ReverbCalculateNoise( pReverbData->m_nMaxExcursion, &pReverbData->m_nNoise );
372
373            pReverbData->m_zD0Self  =
374                DELAY0_OUT - pReverbData->m_nMaxExcursion - nOffset;
375
376            nOffset = ReverbCalculateNoise( pReverbData->m_nMaxExcursion, &pReverbData->m_nNoise );
377
378            pReverbData->m_zD1Self  =
379                DELAY1_OUT - pReverbData->m_nMaxExcursion + nOffset;
380
381        }   // end if-else (pReverbData->m_nPhaseIncrement > 0)
382
383        // Reverse the direction of the sin,cos so that the
384        // tap whose coef was previously increasing now decreases
385        // and vice versa
386        pReverbData->m_nPhaseIncrement = -pReverbData->m_nPhaseIncrement;
387
388    }   // end if counter >= update interval
389
390    //compute what phase will be next time
391    pReverbData->m_nPhase += pReverbData->m_nPhaseIncrement;
392
393    //calculate what the new sin and cos need to reach by the next update
394    ReverbCalculateSinCos(pReverbData->m_nPhase, &tempSin, &tempCos);
395
396    //calculate the per-sample increment required to get there by the next update
397    /*lint -e{702} shift for performance */
398    pReverbData->m_nSinIncrement =
399            (tempSin - pReverbData->m_nSin) >> REVERB_UPDATE_PERIOD_IN_BITS;
400
401    /*lint -e{702} shift for performance */
402    pReverbData->m_nCosIncrement =
403            (tempCos - pReverbData->m_nCos) >> REVERB_UPDATE_PERIOD_IN_BITS;
404
405
406    /* increment update counter */
407    pReverbData->m_nXfadeCounter += (EAS_U16) nNumSamplesToAdd;
408
409    return EAS_SUCCESS;
410
411}   /* end ReverbUpdateXfade */
412
413
414/*----------------------------------------------------------------------------
415 * ReverbCalculateNoise
416 *----------------------------------------------------------------------------
417 * Purpose:
418 * Calculate a noise sample and limit its value
419 *
420 * Inputs:
421 * nMaxExcursion - noise value is limited to this value
422 * pnNoise - return new noise sample in this (not limited)
423 *
424 * Outputs:
425 * new limited noise value
426 *
427 * Side Effects:
428 * - *pnNoise noise value is updated
429 *
430 *----------------------------------------------------------------------------
431*/
432static EAS_U16 ReverbCalculateNoise(EAS_U16 nMaxExcursion, EAS_I16 *pnNoise)
433{
434    // calculate new noise value
435    *pnNoise = (EAS_I16) (*pnNoise * 5 + 1);
436
437#if 0   // 1xxx, test
438    *pnNoise = 0;
439#endif  // 1xxx, test
440
441    // return the limited noise value
442    return (nMaxExcursion & (*pnNoise));
443
444}   /* end ReverbCalculateNoise */
445
446/*----------------------------------------------------------------------------
447 * ReverbCalculateSinCos
448 *----------------------------------------------------------------------------
449 * Purpose:
450 * Calculate a new sin and cosine value based on the given phase
451 *
452 * Inputs:
453 * nPhase   - phase angle
454 * pnSin    - input old value, output new value
455 * pnCos    - input old value, output new value
456 *
457 * Outputs:
458 *
459 * Side Effects:
460 * - *pnSin, *pnCos are updated
461 *
462 *----------------------------------------------------------------------------
463*/
464static EAS_RESULT ReverbCalculateSinCos(EAS_I16 nPhase, EAS_I16 *pnSin, EAS_I16 *pnCos)
465{
466    EAS_I32 nTemp;
467    EAS_I32 nNetAngle;
468
469    //  -1 <=  nPhase  < 1
470    // However, for the calculation, we need a value
471    // that ranges from -1/2 to +1/2, so divide the phase by 2
472    /*lint -e{702} shift for performance */
473    nNetAngle = nPhase >> 1;
474
475    /*
476    Implement the following
477    sin(x) = (2-4*c)*x^2 + c + x
478    cos(x) = (2-4*c)*x^2 + c - x
479
480      where  c = 1/sqrt(2)
481    using the a0 + x*(a1 + x*a2) approach
482    */
483
484    /* limit the input "angle" to be between -0.5 and +0.5 */
485    if (nNetAngle > EG1_HALF)
486    {
487        nNetAngle = EG1_HALF;
488    }
489    else if (nNetAngle < EG1_MINUS_HALF)
490    {
491        nNetAngle = EG1_MINUS_HALF;
492    }
493
494    /* calculate sin */
495    nTemp = EG1_ONE + MULT_EG1_EG1(REVERB_PAN_G2, nNetAngle);
496    nTemp = REVERB_PAN_G0 + MULT_EG1_EG1(nTemp, nNetAngle);
497    *pnSin = (EAS_I16) SATURATE_EG1(nTemp);
498
499    /* calculate cos */
500    nTemp = -EG1_ONE + MULT_EG1_EG1(REVERB_PAN_G2, nNetAngle);
501    nTemp = REVERB_PAN_G0 + MULT_EG1_EG1(nTemp, nNetAngle);
502    *pnCos = (EAS_I16) SATURATE_EG1(nTemp);
503
504    return EAS_SUCCESS;
505}   /* end ReverbCalculateSinCos */
506
507/*----------------------------------------------------------------------------
508 * Reverb
509 *----------------------------------------------------------------------------
510 * Purpose:
511 * apply reverb to the given signal
512 *
513 * Inputs:
514 * nNu
515 * pnSin    - input old value, output new value
516 * pnCos    - input old value, output new value
517 *
518 * Outputs:
519 * number of samples actually reverberated
520 *
521 * Side Effects:
522 *
523 *----------------------------------------------------------------------------
524*/
525static EAS_RESULT Reverb(S_REVERB_OBJECT *pReverbData, EAS_INT nNumSamplesToAdd, EAS_PCM *pOutputBuffer, EAS_PCM *pInputBuffer)
526{
527    EAS_I32 i;
528    EAS_I32 nDelayOut;
529    EAS_U16 nBase;
530
531    EAS_U32 nAddr;
532    EAS_I32 nTemp1;
533    EAS_I32 nTemp2;
534    EAS_I32 nApIn;
535    EAS_I32 nApOut;
536
537    EAS_I32 j;
538    EAS_I32 nEarlyOut;
539
540    EAS_I32 tempValue;
541
542
543    // get the base address
544    nBase = pReverbData->m_nBaseIndex;
545
546    for (i=0; i < nNumSamplesToAdd; i++)
547    {
548        // ********** Left Allpass - start
549        // left input = (left dry/4) + right feedback from previous period
550        /*lint -e{702} use shift for performance */
551        nApIn = ((*pInputBuffer++)>>2) + pReverbData->m_nRevOutFbkR;
552//      nApIn = *pInputBuffer++;    // 1xxx test and debug ap
553
554        // fetch allpass delay line out
555        //nAddr = CIRCULAR(nBase, psAp0->m_zApOut, REVERB_BUFFER_MASK);
556        nAddr = CIRCULAR(nBase, pReverbData->m_sAp0.m_zApOut, REVERB_BUFFER_MASK);
557        nDelayOut = pReverbData->m_nDelayLine[nAddr];
558
559        // calculate allpass feedforward; subtract the feedforward result
560        nTemp1 = MULT_EG1_EG1(nApIn, pReverbData->m_sAp0.m_nApGain);
561        nApOut = SATURATE(nDelayOut - nTemp1);          // allpass output
562
563        // calculate allpass feedback; add the feedback result
564        nTemp1 = MULT_EG1_EG1(nApOut, pReverbData->m_sAp0.m_nApGain);
565        nTemp1 = SATURATE(nApIn + nTemp1);
566
567        // inject into allpass delay
568        nAddr = CIRCULAR(nBase, pReverbData->m_sAp0.m_zApIn, REVERB_BUFFER_MASK);
569        pReverbData->m_nDelayLine[nAddr] = (EAS_PCM) nTemp1;
570
571        // inject allpass output into delay line
572        nAddr = CIRCULAR(nBase, pReverbData->m_zD0In, REVERB_BUFFER_MASK);
573        pReverbData->m_nDelayLine[nAddr] = (EAS_PCM) nApOut;
574
575        // ********** Left Allpass - end
576
577        // ********** Right Allpass - start
578        // right input = (right dry/4) + left feedback from previous period
579        /*lint -e{702} use shift for performance */
580        nApIn = ((*pInputBuffer++)>>2) + pReverbData->m_nRevOutFbkL;
581//      nApIn = *pInputBuffer++;    // 1xxx test and debug ap
582
583        // fetch allpass delay line out
584        nAddr = CIRCULAR(nBase, pReverbData->m_sAp1.m_zApOut, REVERB_BUFFER_MASK);
585        nDelayOut = pReverbData->m_nDelayLine[nAddr];
586
587        // calculate allpass feedforward; subtract the feedforward result
588        nTemp1 = MULT_EG1_EG1(nApIn, pReverbData->m_sAp1.m_nApGain);
589        nApOut = SATURATE(nDelayOut - nTemp1);          // allpass output
590
591        // calculate allpass feedback; add the feedback result
592        nTemp1 = MULT_EG1_EG1(nApOut, pReverbData->m_sAp1.m_nApGain);
593        nTemp1 = SATURATE(nApIn + nTemp1);
594
595        // inject into allpass delay
596        nAddr = CIRCULAR(nBase, pReverbData->m_sAp1.m_zApIn, REVERB_BUFFER_MASK);
597        pReverbData->m_nDelayLine[nAddr] = (EAS_PCM) nTemp1;
598
599        // inject allpass output into delay line
600        nAddr = CIRCULAR(nBase, pReverbData->m_zD1In, REVERB_BUFFER_MASK);
601        pReverbData->m_nDelayLine[nAddr] = (EAS_PCM) nApOut;
602
603        // ********** Right Allpass - end
604
605        // ********** D0 output - start
606        // fetch delay line self out
607        nAddr = CIRCULAR(nBase, pReverbData->m_zD0Self, REVERB_BUFFER_MASK);
608        nDelayOut = pReverbData->m_nDelayLine[nAddr];
609
610        // calculate delay line self out
611        nTemp1 = MULT_EG1_EG1(nDelayOut, pReverbData->m_nSin);
612
613        // fetch delay line cross out
614        nAddr = CIRCULAR(nBase, pReverbData->m_zD1Cross, REVERB_BUFFER_MASK);
615        nDelayOut = pReverbData->m_nDelayLine[nAddr];
616
617        // calculate delay line self out
618        nTemp2 = MULT_EG1_EG1(nDelayOut, pReverbData->m_nCos);
619
620        // calculate unfiltered delay out
621        nDelayOut = SATURATE(nTemp1 + nTemp2);
622
623        // calculate lowpass filter (mixer scale factor included in LPF feedforward)
624        nTemp1 = MULT_EG1_EG1(nDelayOut, pReverbData->m_nLpfFwd);
625
626        nTemp2 = MULT_EG1_EG1(pReverbData->m_zLpf0, pReverbData->m_nLpfFbk);
627
628        // calculate filtered delay out and simultaneously update LPF state variable
629        // filtered delay output is stored in m_zLpf0
630        pReverbData->m_zLpf0 = (EAS_PCM) SATURATE(nTemp1 + nTemp2);
631
632        // ********** D0 output - end
633
634        // ********** D1 output - start
635        // fetch delay line self out
636        nAddr = CIRCULAR(nBase, pReverbData->m_zD1Self, REVERB_BUFFER_MASK);
637        nDelayOut = pReverbData->m_nDelayLine[nAddr];
638
639        // calculate delay line self out
640        nTemp1 = MULT_EG1_EG1(nDelayOut, pReverbData->m_nSin);
641
642        // fetch delay line cross out
643        nAddr = CIRCULAR(nBase, pReverbData->m_zD0Cross, REVERB_BUFFER_MASK);
644        nDelayOut = pReverbData->m_nDelayLine[nAddr];
645
646        // calculate delay line self out
647        nTemp2 = MULT_EG1_EG1(nDelayOut, pReverbData->m_nCos);
648
649        // calculate unfiltered delay out
650        nDelayOut = SATURATE(nTemp1 + nTemp2);
651
652        // calculate lowpass filter (mixer scale factor included in LPF feedforward)
653        nTemp1 = MULT_EG1_EG1(nDelayOut, pReverbData->m_nLpfFwd);
654
655        nTemp2 = MULT_EG1_EG1(pReverbData->m_zLpf1, pReverbData->m_nLpfFbk);
656
657        // calculate filtered delay out and simultaneously update LPF state variable
658        // filtered delay output is stored in m_zLpf1
659        pReverbData->m_zLpf1 = (EAS_PCM)SATURATE(nTemp1 + nTemp2);
660
661        // ********** D1 output - end
662
663        // ********** mixer and feedback - start
664        // sum is fedback to right input (R + L)
665        pReverbData->m_nRevOutFbkL =
666            (EAS_PCM)SATURATE((EAS_I32)pReverbData->m_zLpf1 + (EAS_I32)pReverbData->m_zLpf0);
667
668        // difference is feedback to left input (R - L)
669        /*lint -e{685} lint complains that it can't saturate negative */
670        pReverbData->m_nRevOutFbkR =
671            (EAS_PCM)SATURATE((EAS_I32)pReverbData->m_zLpf1 - (EAS_I32)pReverbData->m_zLpf0);
672
673        // ********** mixer and feedback - end
674
675        // ********** start early reflection generator, left
676        //psEarly = &(pReverbData->m_sEarlyL);
677
678        nEarlyOut = 0;
679
680        for (j=0; j < REVERB_MAX_NUM_REFLECTIONS; j++)
681        {
682            // fetch delay line out
683            //nAddr = CIRCULAR(nBase, psEarly->m_zDelay[j], REVERB_BUFFER_MASK);
684            nAddr = CIRCULAR(nBase, pReverbData->m_sEarlyL.m_zDelay[j], REVERB_BUFFER_MASK);
685
686            nDelayOut = pReverbData->m_nDelayLine[nAddr];
687
688            // calculate reflection
689            //nTemp1 = MULT_EG1_EG1(nDelayOut, psEarly->m_nGain[j]);
690            nTemp1 = MULT_EG1_EG1(nDelayOut, pReverbData->m_sEarlyL.m_nGain[j]);
691
692            nEarlyOut = SATURATE(nEarlyOut + nTemp1);
693
694        }   // end for (j=0; j < REVERB_MAX_NUM_REFLECTIONS; j++)
695
696        // apply lowpass to early reflections
697        //nTemp1 = MULT_EG1_EG1(nEarlyOut, psEarly->m_nLpfFwd);
698        nTemp1 = MULT_EG1_EG1(nEarlyOut, pReverbData->m_sEarlyL.m_nLpfFwd);
699
700        //nTemp2 = MULT_EG1_EG1(psEarly->m_zLpf, psEarly->m_nLpfFbk);
701        nTemp2 = MULT_EG1_EG1(pReverbData->m_sEarlyL.m_zLpf, pReverbData->m_sEarlyL.m_nLpfFbk);
702
703
704        // calculate filtered out and simultaneously update LPF state variable
705        // filtered output is stored in m_zLpf1
706        //psEarly->m_zLpf = SATURATE(nTemp1 + nTemp2);
707        pReverbData->m_sEarlyL.m_zLpf = (EAS_PCM) SATURATE(nTemp1 + nTemp2);
708
709        // combine filtered early and late reflections for output
710        //*pOutputBuffer++ = inL;
711        //tempValue = SATURATE(psEarly->m_zLpf + pReverbData->m_nRevOutFbkL);
712        tempValue = SATURATE((EAS_I32)pReverbData->m_sEarlyL.m_zLpf + (EAS_I32)pReverbData->m_nRevOutFbkL);
713        //scale reverb output by wet level
714        /*lint -e{701} use shift for performance */
715        tempValue = MULT_EG1_EG1(tempValue, (pReverbData->m_nWet<<1));
716        //sum with output buffer
717        tempValue += *pOutputBuffer;
718        *pOutputBuffer++ = (EAS_PCM)SATURATE(tempValue);
719
720        // ********** end early reflection generator, left
721
722        // ********** start early reflection generator, right
723        //psEarly = &(pReverbData->m_sEarlyR);
724
725        nEarlyOut = 0;
726
727        for (j=0; j < REVERB_MAX_NUM_REFLECTIONS; j++)
728        {
729            // fetch delay line out
730            nAddr = CIRCULAR(nBase, pReverbData->m_sEarlyR.m_zDelay[j], REVERB_BUFFER_MASK);
731            nDelayOut = pReverbData->m_nDelayLine[nAddr];
732
733            // calculate reflection
734            nTemp1 = MULT_EG1_EG1(nDelayOut, pReverbData->m_sEarlyR.m_nGain[j]);
735
736            nEarlyOut = SATURATE(nEarlyOut + nTemp1);
737
738        }   // end for (j=0; j < REVERB_MAX_NUM_REFLECTIONS; j++)
739
740        // apply lowpass to early reflections
741        nTemp1 = MULT_EG1_EG1(nEarlyOut, pReverbData->m_sEarlyR.m_nLpfFwd);
742
743        nTemp2 = MULT_EG1_EG1(pReverbData->m_sEarlyR.m_zLpf, pReverbData->m_sEarlyR.m_nLpfFbk);
744
745        // calculate filtered out and simultaneously update LPF state variable
746        // filtered output is stored in m_zLpf1
747        pReverbData->m_sEarlyR.m_zLpf = (EAS_PCM)SATURATE(nTemp1 + nTemp2);
748
749        // combine filtered early and late reflections for output
750        //*pOutputBuffer++ = inR;
751        tempValue = SATURATE((EAS_I32)pReverbData->m_sEarlyR.m_zLpf + (EAS_I32)pReverbData->m_nRevOutFbkR);
752        //scale reverb output by wet level
753        /*lint -e{701} use shift for performance */
754        tempValue = MULT_EG1_EG1(tempValue, (pReverbData->m_nWet << 1));
755        //sum with output buffer
756        tempValue = tempValue + *pOutputBuffer;
757        *pOutputBuffer++ = (EAS_PCM)SATURATE(tempValue);
758
759        // ********** end early reflection generator, right
760
761        // decrement base addr for next sample period
762        nBase--;
763
764        pReverbData->m_nSin += pReverbData->m_nSinIncrement;
765        pReverbData->m_nCos += pReverbData->m_nCosIncrement;
766
767    }   // end for (i=0; i < nNumSamplesToAdd; i++)
768
769    // store the most up to date version
770    pReverbData->m_nBaseIndex = nBase;
771
772    return EAS_SUCCESS;
773}   /* end Reverb */
774
775
776
777/*----------------------------------------------------------------------------
778 * ReverbShutdown()
779 *----------------------------------------------------------------------------
780 * Purpose:
781 * Initializes the Reverb effect.
782 *
783 * Inputs:
784 * pInstData        - handle to instance data
785 *
786 * Outputs:
787 *
788 *
789 * Side Effects:
790 *
791 *----------------------------------------------------------------------------
792*/
793static EAS_RESULT ReverbShutdown (EAS_DATA_HANDLE pEASData, EAS_VOID_PTR pInstData)
794{
795    /* check Configuration Module for static memory allocation */
796    if (!pEASData->staticMemoryModel)
797        EAS_HWFree(pEASData->hwInstData, pInstData);
798    return EAS_SUCCESS;
799} /* end ReverbShutdown */
800
801/*----------------------------------------------------------------------------
802 * ReverbGetParam()
803 *----------------------------------------------------------------------------
804 * Purpose:
805 * Get a Reverb parameter
806 *
807 * Inputs:
808 * pInstData        - handle to instance data
809 * param            - parameter index
810 * *pValue          - pointer to variable to hold retrieved value
811 *
812 * Outputs:
813 *
814 *
815 * Side Effects:
816 *
817 *----------------------------------------------------------------------------
818*/
819static EAS_RESULT ReverbGetParam (EAS_VOID_PTR pInstData, EAS_I32 param, EAS_I32 *pValue)
820{
821    S_REVERB_OBJECT *p;
822
823    p = (S_REVERB_OBJECT*) pInstData;
824
825    switch (param)
826    {
827        case EAS_PARAM_REVERB_BYPASS:
828            *pValue = (EAS_I32) p->m_bBypass;
829            break;
830        case EAS_PARAM_REVERB_PRESET:
831            *pValue = (EAS_I8) p->m_nCurrentRoom;
832            break;
833        case EAS_PARAM_REVERB_WET:
834            *pValue = p->m_nWet;
835            break;
836        case EAS_PARAM_REVERB_DRY:
837            *pValue = p->m_nDry;
838            break;
839        default:
840            return EAS_ERROR_INVALID_PARAMETER;
841    }
842    return EAS_SUCCESS;
843} /* end ReverbGetParam */
844
845
846/*----------------------------------------------------------------------------
847 * ReverbSetParam()
848 *----------------------------------------------------------------------------
849 * Purpose:
850 * Set a Reverb parameter
851 *
852 * Inputs:
853 * pInstData        - handle to instance data
854 * param            - parameter index
855 * *pValue          - new paramter value
856 *
857 * Outputs:
858 *
859 *
860 * Side Effects:
861 *
862 *----------------------------------------------------------------------------
863*/
864static EAS_RESULT ReverbSetParam (EAS_VOID_PTR pInstData, EAS_I32 param, EAS_I32 value)
865{
866    S_REVERB_OBJECT *p;
867
868    p = (S_REVERB_OBJECT*) pInstData;
869
870    switch (param)
871    {
872        case EAS_PARAM_REVERB_BYPASS:
873            p->m_bBypass = (EAS_BOOL) value;
874            break;
875        case EAS_PARAM_REVERB_PRESET:
876            if(value!=EAS_PARAM_REVERB_LARGE_HALL && value!=EAS_PARAM_REVERB_HALL &&
877                value!=EAS_PARAM_REVERB_CHAMBER && value!=EAS_PARAM_REVERB_ROOM)
878                return EAS_ERROR_INVALID_PARAMETER;
879            p->m_nNextRoom = (EAS_I16)value;
880            break;
881        case EAS_PARAM_REVERB_WET:
882            if(value>EAS_REVERB_WET_MAX || value<EAS_REVERB_WET_MIN)
883                return EAS_ERROR_INVALID_PARAMETER;
884            p->m_nWet = (EAS_I16)value;
885            break;
886        case EAS_PARAM_REVERB_DRY:
887            if(value>EAS_REVERB_DRY_MAX || value<EAS_REVERB_DRY_MIN)
888                return EAS_ERROR_INVALID_PARAMETER;
889            p->m_nDry = (EAS_I16)value;
890            break;
891        default:
892            return EAS_ERROR_INVALID_PARAMETER;
893    }
894    return EAS_SUCCESS;
895} /* end ReverbSetParam */
896
897
898/*----------------------------------------------------------------------------
899 * ReverbUpdateRoom
900 *----------------------------------------------------------------------------
901 * Purpose:
902 * Update the room's preset parameters as required
903 *
904 * Inputs:
905 *
906 * Outputs:
907 *
908 *
909 * Side Effects:
910 * - reverb paramters (fbk, fwd, etc) will be changed
911 * - m_nCurrentRoom := m_nNextRoom
912 *----------------------------------------------------------------------------
913*/
914static EAS_RESULT ReverbUpdateRoom(S_REVERB_OBJECT *pReverbData)
915{
916    EAS_INT temp;
917
918    S_REVERB_PRESET *pPreset = &pReverbData->m_sPreset.m_sPreset[pReverbData->m_nNextRoom];
919
920    pReverbData->m_nLpfFwd = pPreset->m_nLpfFwd;
921    pReverbData->m_nLpfFbk = pPreset->m_nLpfFbk;
922
923    pReverbData->m_nEarly = pPreset->m_nEarly;
924    pReverbData->m_nWet = pPreset->m_nWet;
925    pReverbData->m_nDry = pPreset->m_nDry;
926
927
928    pReverbData->m_nMaxExcursion = pPreset->m_nMaxExcursion;
929    //stored as time based, convert to sample based
930    temp = pPreset->m_nXfadeInterval;
931    /*lint -e{702} shift for performance */
932    temp = (temp * _OUTPUT_SAMPLE_RATE) >> 16;
933    pReverbData->m_nXfadeInterval = (EAS_U16) temp;
934    //gpsReverbObject->m_nXfadeInterval = pPreset->m_nXfadeInterval;
935    pReverbData->m_sAp0.m_nApGain = pPreset->m_nAp0_ApGain;
936    //stored as time based, convert to absolute sample value
937    temp = pPreset->m_nAp0_ApOut;
938    /*lint -e{702} shift for performance */
939    temp = (temp * _OUTPUT_SAMPLE_RATE) >> 16;
940    pReverbData->m_sAp0.m_zApOut = (EAS_U16) (pReverbData->m_sAp0.m_zApIn + temp);
941    //gpsReverbObject->m_sAp0.m_zApOut = pPreset->m_nAp0_ApOut;
942    pReverbData->m_sAp1.m_nApGain = pPreset->m_nAp1_ApGain;
943    //stored as time based, convert to absolute sample value
944    temp = pPreset->m_nAp1_ApOut;
945    /*lint -e{702} shift for performance */
946    temp = (temp * _OUTPUT_SAMPLE_RATE) >> 16;
947    pReverbData->m_sAp1.m_zApOut = (EAS_U16) (pReverbData->m_sAp1.m_zApIn + temp);
948    //gpsReverbObject->m_sAp1.m_zApOut = pPreset->m_nAp1_ApOut;
949
950    pReverbData->m_nCurrentRoom = pReverbData->m_nNextRoom;
951
952    return EAS_SUCCESS;
953
954}   /* end ReverbUpdateRoom */
955
956
957/*----------------------------------------------------------------------------
958 * ReverbReadInPresets()
959 *----------------------------------------------------------------------------
960 * Purpose: sets global reverb preset bank to defaults
961 *
962 * Inputs:
963 *
964 * Outputs:
965 *
966 *----------------------------------------------------------------------------
967*/
968static EAS_RESULT ReverbReadInPresets(S_REVERB_OBJECT *pReverbData)
969{
970
971    int preset = 0;
972    int defaultPreset = 0;
973
974    //now init any remaining presets to defaults
975    for (defaultPreset = preset; defaultPreset < REVERB_MAX_ROOM_TYPE; defaultPreset++)
976    {
977        S_REVERB_PRESET *pPreset = &pReverbData->m_sPreset.m_sPreset[defaultPreset];
978        if (defaultPreset == 0 || defaultPreset > REVERB_MAX_ROOM_TYPE-1)
979        {
980            pPreset->m_nLpfFbk = 8307;
981            pPreset->m_nLpfFwd = 14768;
982            pPreset->m_nEarly = 0;
983            pPreset->m_nWet = 27690;
984            pPreset->m_nDry = 32767;
985            pPreset->m_nEarlyL_LpfFbk = 3692;
986            pPreset->m_nEarlyL_LpfFwd = 29075;
987            pPreset->m_nEarlyL_Delay0 = 922;
988            pPreset->m_nEarlyL_Gain0 = 22152;
989            pPreset->m_nEarlyL_Delay1 = 1462;
990            pPreset->m_nEarlyL_Gain1 = 17537;
991            pPreset->m_nEarlyL_Delay2 = 0;
992            pPreset->m_nEarlyL_Gain2 = 14768;
993            pPreset->m_nEarlyL_Delay3 = 1221;
994            pPreset->m_nEarlyL_Gain3 = 14307;
995            pPreset->m_nEarlyL_Delay4 = 0;
996            pPreset->m_nEarlyL_Gain4 = 13384;
997            pPreset->m_nEarlyR_Delay0 = 502;
998            pPreset->m_nEarlyR_Gain0 = 20306;
999            pPreset->m_nEarlyR_Delay1 = 1762;
1000            pPreset->m_nEarlyR_Gain1 = 17537;
1001            pPreset->m_nEarlyR_Delay2 = 0;
1002            pPreset->m_nEarlyR_Gain2 = 14768;
1003            pPreset->m_nEarlyR_Delay3 = 0;
1004            pPreset->m_nEarlyR_Gain3 = 16153;
1005            pPreset->m_nEarlyR_Delay4 = 0;
1006            pPreset->m_nEarlyR_Gain4 = 13384;
1007            pPreset->m_nMaxExcursion = 127;
1008            pPreset->m_nXfadeInterval = 6388;
1009            pPreset->m_nAp0_ApGain = 15691;
1010            pPreset->m_nAp0_ApOut = 711;
1011            pPreset->m_nAp1_ApGain = 17999;
1012            pPreset->m_nAp1_ApOut = 1113;
1013            pPreset->m_rfu4 = 0;
1014            pPreset->m_rfu5 = 0;
1015            pPreset->m_rfu6 = 0;
1016            pPreset->m_rfu7 = 0;
1017            pPreset->m_rfu8 = 0;
1018            pPreset->m_rfu9 = 0;
1019            pPreset->m_rfu10 = 0;
1020        }
1021        else if (defaultPreset == 1)
1022        {
1023            pPreset->m_nLpfFbk = 6461;
1024            pPreset->m_nLpfFwd = 14307;
1025            pPreset->m_nEarly = 0;
1026            pPreset->m_nWet = 27690;
1027            pPreset->m_nDry = 32767;
1028            pPreset->m_nEarlyL_LpfFbk = 3692;
1029            pPreset->m_nEarlyL_LpfFwd = 29075;
1030            pPreset->m_nEarlyL_Delay0 = 922;
1031            pPreset->m_nEarlyL_Gain0 = 22152;
1032            pPreset->m_nEarlyL_Delay1 = 1462;
1033            pPreset->m_nEarlyL_Gain1 = 17537;
1034            pPreset->m_nEarlyL_Delay2 = 0;
1035            pPreset->m_nEarlyL_Gain2 = 14768;
1036            pPreset->m_nEarlyL_Delay3 = 1221;
1037            pPreset->m_nEarlyL_Gain3 = 14307;
1038            pPreset->m_nEarlyL_Delay4 = 0;
1039            pPreset->m_nEarlyL_Gain4 = 13384;
1040            pPreset->m_nEarlyR_Delay0 = 502;
1041            pPreset->m_nEarlyR_Gain0 = 20306;
1042            pPreset->m_nEarlyR_Delay1 = 1762;
1043            pPreset->m_nEarlyR_Gain1 = 17537;
1044            pPreset->m_nEarlyR_Delay2 = 0;
1045            pPreset->m_nEarlyR_Gain2 = 14768;
1046            pPreset->m_nEarlyR_Delay3 = 0;
1047            pPreset->m_nEarlyR_Gain3 = 16153;
1048            pPreset->m_nEarlyR_Delay4 = 0;
1049            pPreset->m_nEarlyR_Gain4 = 13384;
1050            pPreset->m_nMaxExcursion = 127;
1051            pPreset->m_nXfadeInterval = 6391;
1052            pPreset->m_nAp0_ApGain = 15230;
1053            pPreset->m_nAp0_ApOut = 708;
1054            pPreset->m_nAp1_ApGain = 9692;
1055            pPreset->m_nAp1_ApOut = 1113;
1056            pPreset->m_rfu4 = 0;
1057            pPreset->m_rfu5 = 0;
1058            pPreset->m_rfu6 = 0;
1059            pPreset->m_rfu7 = 0;
1060            pPreset->m_rfu8 = 0;
1061            pPreset->m_rfu9 = 0;
1062            pPreset->m_rfu10 = 0;
1063        }
1064        else if (defaultPreset == 2)
1065        {
1066            pPreset->m_nLpfFbk = 5077;
1067            pPreset->m_nLpfFwd = 12922;
1068            pPreset->m_nEarly = 0;
1069            pPreset->m_nWet = 24460;
1070            pPreset->m_nDry = 32767;
1071            pPreset->m_nEarlyL_LpfFbk = 3692;
1072            pPreset->m_nEarlyL_LpfFwd = 29075;
1073            pPreset->m_nEarlyL_Delay0 = 922;
1074            pPreset->m_nEarlyL_Gain0 = 22152;
1075            pPreset->m_nEarlyL_Delay1 = 1462;
1076            pPreset->m_nEarlyL_Gain1 = 17537;
1077            pPreset->m_nEarlyL_Delay2 = 0;
1078            pPreset->m_nEarlyL_Gain2 = 14768;
1079            pPreset->m_nEarlyL_Delay3 = 1221;
1080            pPreset->m_nEarlyL_Gain3 = 14307;
1081            pPreset->m_nEarlyL_Delay4 = 0;
1082            pPreset->m_nEarlyL_Gain4 = 13384;
1083            pPreset->m_nEarlyR_Delay0 = 502;
1084            pPreset->m_nEarlyR_Gain0 = 20306;
1085            pPreset->m_nEarlyR_Delay1 = 1762;
1086            pPreset->m_nEarlyR_Gain1 = 17537;
1087            pPreset->m_nEarlyR_Delay2 = 0;
1088            pPreset->m_nEarlyR_Gain2 = 14768;
1089            pPreset->m_nEarlyR_Delay3 = 0;
1090            pPreset->m_nEarlyR_Gain3 = 16153;
1091            pPreset->m_nEarlyR_Delay4 = 0;
1092            pPreset->m_nEarlyR_Gain4 = 13384;
1093            pPreset->m_nMaxExcursion = 127;
1094            pPreset->m_nXfadeInterval = 6449;
1095            pPreset->m_nAp0_ApGain = 15691;
1096            pPreset->m_nAp0_ApOut = 774;
1097            pPreset->m_nAp1_ApGain = 15691;
1098            pPreset->m_nAp1_ApOut = 1113;
1099            pPreset->m_rfu4 = 0;
1100            pPreset->m_rfu5 = 0;
1101            pPreset->m_rfu6 = 0;
1102            pPreset->m_rfu7 = 0;
1103            pPreset->m_rfu8 = 0;
1104            pPreset->m_rfu9 = 0;
1105            pPreset->m_rfu10 = 0;
1106        }
1107        else if (defaultPreset == 3)
1108        {
1109            pPreset->m_nLpfFbk = 5077;
1110            pPreset->m_nLpfFwd = 11076;
1111            pPreset->m_nEarly = 0;
1112            pPreset->m_nWet = 23075;
1113            pPreset->m_nDry = 32767;
1114            pPreset->m_nEarlyL_LpfFbk = 3692;
1115            pPreset->m_nEarlyL_LpfFwd = 29075;
1116            pPreset->m_nEarlyL_Delay0 = 922;
1117            pPreset->m_nEarlyL_Gain0 = 22152;
1118            pPreset->m_nEarlyL_Delay1 = 1462;
1119            pPreset->m_nEarlyL_Gain1 = 17537;
1120            pPreset->m_nEarlyL_Delay2 = 0;
1121            pPreset->m_nEarlyL_Gain2 = 14768;
1122            pPreset->m_nEarlyL_Delay3 = 1221;
1123            pPreset->m_nEarlyL_Gain3 = 14307;
1124            pPreset->m_nEarlyL_Delay4 = 0;
1125            pPreset->m_nEarlyL_Gain4 = 13384;
1126            pPreset->m_nEarlyR_Delay0 = 502;
1127            pPreset->m_nEarlyR_Gain0 = 20306;
1128            pPreset->m_nEarlyR_Delay1 = 1762;
1129            pPreset->m_nEarlyR_Gain1 = 17537;
1130            pPreset->m_nEarlyR_Delay2 = 0;
1131            pPreset->m_nEarlyR_Gain2 = 14768;
1132            pPreset->m_nEarlyR_Delay3 = 0;
1133            pPreset->m_nEarlyR_Gain3 = 16153;
1134            pPreset->m_nEarlyR_Delay4 = 0;
1135            pPreset->m_nEarlyR_Gain4 = 13384;
1136            pPreset->m_nMaxExcursion = 127;
1137            pPreset->m_nXfadeInterval = 6470;   //6483;
1138            pPreset->m_nAp0_ApGain = 14768;
1139            pPreset->m_nAp0_ApOut = 792;
1140            pPreset->m_nAp1_ApGain = 15783;
1141            pPreset->m_nAp1_ApOut = 1113;
1142            pPreset->m_rfu4 = 0;
1143            pPreset->m_rfu5 = 0;
1144            pPreset->m_rfu6 = 0;
1145            pPreset->m_rfu7 = 0;
1146            pPreset->m_rfu8 = 0;
1147            pPreset->m_rfu9 = 0;
1148            pPreset->m_rfu10 = 0;
1149
1150        }
1151    }
1152
1153    return EAS_SUCCESS;
1154}
1155