reverb.c File Reference

Go to the source code of this file.

Macros
#define	SWAP16(in, out)
#define	CONVERT   173123.404906676
#define	SCALE   16384
#define	INPUT_PARAM   0
#define	OUTPUT_PARAM   1
#define	FBCOEF_PARAM   2
#define	FFCOEF_PARAM   3
#define	GAIN_PARAM   4
#define	CHORUSRATE_PARAM   5
#define	CHORUSDEPTH_PARAM   6
#define	LPFILT_PARAM   7

Functions
void	func_80058E84 (AuFX *fx, u8 effectType, ALHeap *heap)
void	func_80058F88 (AlUnkKappa *kappa, ALHeap *heap)
void	func_80059008 (AlUnkKappa *kappa, s16 arg1, s16 arg2, s16 fc)
void	func_8005904C (AuFX *fx, u8 effectType)
Acmd *	au_pull_fx (AuFX *fx, Acmd *ptr, s16 outputBuf, s16 arg3)
s32	au_fx_param_hdl (AuFX *fx, s16 index, s16 paramID, s32 value)

Variables
s32	SMALL_ROOM_PARAMS []
s32	BIG_ROOM_PARAMS []
s32	D_8007F0C0 []
s32	ECHO_PARAMS []
s32	CHORUS_PARAMS []
s32	FLANGE_PARAMS []
s32	NULL_PARAMS []
s32 *	AU_FX_CUSTOM_PARAMS []

Macro Definition Documentation

SWAP16

#define SWAP16	(		in,
			out )

Value:

{ \
    s16 t = out; \
    out = in; \
    in = t; \
}

Definition at line 4 of file reverb.c.

#define SWAP16(in, out) \
{ \
    s16 t = out; \
    out = in; \
    in = t; \
}

Referenced by au_pull_fx().

CONVERT

#define CONVERT   173123.404906676

Definition at line 27 of file reverb.c.

Referenced by au_fx_param_hdl(), and func_8005904C().

SCALE

#define SCALE   16384

Definition at line 33 of file reverb.c.

INPUT_PARAM

#define INPUT_PARAM   0

Definition at line 374 of file reverb.c.

Referenced by au_fx_param_hdl().

OUTPUT_PARAM

#define OUTPUT_PARAM   1

Definition at line 375 of file reverb.c.

Referenced by au_fx_param_hdl().

FBCOEF_PARAM

#define FBCOEF_PARAM   2

Definition at line 376 of file reverb.c.

Referenced by au_fx_param_hdl().

FFCOEF_PARAM

#define FFCOEF_PARAM   3

Definition at line 377 of file reverb.c.

Referenced by au_fx_param_hdl().

GAIN_PARAM

#define GAIN_PARAM   4

Definition at line 378 of file reverb.c.

Referenced by au_fx_param_hdl().

CHORUSRATE_PARAM

#define CHORUSRATE_PARAM   5

Definition at line 379 of file reverb.c.

Referenced by au_fx_param_hdl().

CHORUSDEPTH_PARAM

#define CHORUSDEPTH_PARAM   6

Definition at line 380 of file reverb.c.

Referenced by au_fx_param_hdl().

LPFILT_PARAM

#define LPFILT_PARAM   7

Definition at line 381 of file reverb.c.

Referenced by au_fx_param_hdl().

Function Documentation

func_80058E84()

void func_80058E84	(	AuFX *	fx,
		u8	effectType,
		ALHeap *	heap )

Parameters

effectType

from enum AuEffectType

Definition at line 137 of file reverb.c.

                                                          {
    AuDelay* delay;
    u16 i;
 
    // allocate space for 4 AuDelay
    fx->delays = alHeapAlloc(heap, AU_FX_DELAY_COUNT, sizeof(AuDelay));
    fx->base = alHeapAlloc(heap, AU_FX_LENGTH, sizeof(s16));
 
    for (i = 0; i < AU_FX_DELAY_COUNT; i++) {
        delay = &fx->delays[i];
        delay->resampler_2C = alHeapAlloc(heap, 1, sizeof(AuResampler));
        delay->resampler_2C->state = alHeapAlloc(heap, 1, sizeof(RESAMPLE_STATE));
        delay->lowpass_24 = alHeapAlloc(heap, 1, sizeof(AuLowPass));
        delay->lowpass_24->fstate = alHeapAlloc(heap, 1, sizeof(POLEF_STATE));
    }
 
    func_8005904C(fx, effectType);
}

Referenced by au_driver_init().

func_80058F88()

void func_80058F88	(	AlUnkKappa *	kappa,
		ALHeap *	heap )

Definition at line 157 of file reverb.c.

                                                    {
    kappa->unk_00 = alHeapAlloc(heap, 0x1420, sizeof(s16));
    kappa->lowpass_10 = alHeapAlloc(heap, 1, sizeof(AuLowPass));
    kappa->lowpass_10->fstate = alHeapAlloc(heap, 1, sizeof(POLEF_STATE));
    func_80059008(kappa, 0, 0, 0x5000);
}

func_80059008()

void func_80059008	(	AlUnkKappa *	kappa,
		s16	arg1,
		s16	arg2,
		s16	fc )

Definition at line 165 of file reverb.c.

                                                                  {
    kappa->unk_06 = arg1;
    kappa->unk_08 = arg2;
 
    if (fc != 0) {
        kappa->lowpass_0C = kappa->lowpass_10;
        kappa->lowpass_0C->fc = fc;
        _init_lpfilter(kappa->lowpass_0C);
        return;
    }
 
    kappa->lowpass_0C = NULL;
}

Referenced by func_80058F88().

func_8005904C()

void func_8005904C	(	AuFX *	fx,
		u8	effectType )

Definition at line 180 of file reverb.c.

                                            {
    s32* params;
    s32* clr;
    s32 i, j;
    clr = (s32*)fx->base;
 
    switch (effectType) {
        case AU_FX_SMALLROOM:
            params = SMALL_ROOM_PARAMS;
            break;
        case AU_FX_BIGROOM:
            params = BIG_ROOM_PARAMS;
            break;
        case AU_FX_ECHO:
            params = ECHO_PARAMS;
            break;
        case AU_FX_CHORUS:
            params = CHORUS_PARAMS;
            break;
        case AU_FX_FLANGE:
            params = FLANGE_PARAMS;
            break;
        case AU_FX_CUSTOM_0:
            params = AU_FX_CUSTOM_PARAMS[0];
            break;
        case AU_FX_CUSTOM_1:
            params = AU_FX_CUSTOM_PARAMS[1];
            break;
        case AU_FX_CUSTOM_2:
            params = AU_FX_CUSTOM_PARAMS[2];
            break;
        case AU_FX_CUSTOM_3:
            params = AU_FX_CUSTOM_PARAMS[3];
            break;
        case AU_FX_OTHER_BIGROOM:
            params = BIG_ROOM_PARAMS;
            break;
        default:
            params = NULL_PARAMS;
            break;
    }
 
    j = 0;
    fx->delayCount = params[j++];
    fx->length = params[j++] * AUDIO_SAMPLES;
    fx->input = fx->base;
 
    for (i = 0; i < AU_FX_LENGTH/2; i++) {
        *clr++ = 0;
    }
 
    for (i = 0; i < fx->delayCount; i++) {
        AuDelay* delay = &fx->delays[i];
        delay->input  = params[j++] * AUDIO_SAMPLES;
        delay->output = params[j++] * AUDIO_SAMPLES;
        delay->fbcoef = (u16) params[j++];
        delay->ffcoef = (u16) params[j++];
        delay->gain   = (u16) params[j++];
 
        if (params[j]) {
            delay->rsinc = (2.0 * (params[j++] / 1000.0f)) / gActiveSynDriverPtr->outputRate;
            delay->rsgain = ((f32)params[j++] / CONVERT) * (delay->output - delay->input);
            delay->rsval = 1.0f;
            delay->rsdelta = 0.0f;
            delay->resampler_28 = delay->resampler_2C;
            delay->resampler_2C->delta = 0.0;
            delay->resampler_28->first = 1;
        } else {
            delay->resampler_28 = NULL;
            j++;
            j++;
        }
 
        if (params[j]) {
            delay->lowpass_20 = delay->lowpass_24;
            delay->lowpass_20->fc = params[j++];
            _init_lpfilter(delay->lowpass_20);
        } else {
            delay->lowpass_20 = NULL;
            j++;
        }
    }
}

Referenced by au_bus_set_effect(), and func_80058E84().

au_pull_fx()

Acmd * au_pull_fx	(	AuFX *	fx,
		Acmd *	ptr,
		s16	outputBuf,
		s16	arg3 )

Definition at line 267 of file reverb.c.

                                                               {
    Acmd* cmdBufPos = ptr;
    s16 delayIdx;
 
    s16* inPtr;
    s16* outPtr;
 
    s16 buff1 = arg3 + N_AL_TEMP_0;
    s16 buff2 = arg3 + N_AL_TEMP_1;
    s16 rbuff = arg3 + N_AL_TEMP_2;
    s16* prevOutPtr = 0;
    s16 outputBufCopy = outputBuf;
 
    n_aSaveBuffer(cmdBufPos++, FIXED_SAMPLE<<1, outputBuf, osVirtualToPhysical(fx->input));
    aClearBuffer(cmdBufPos++, outputBuf, FIXED_SAMPLE<<1);
 
    for (delayIdx = 0; delayIdx < fx->delayCount; delayIdx++) {
        AuDelay* delay = &fx->delays[delayIdx];
        f32 fUnityPitch = UNITY_PITCH;
 
        inPtr = &fx->input[-delay->input];
        if (inPtr < fx->base) {
            inPtr += fx->length;
        }
        outPtr = &fx->input[-delay->output];
        if (outPtr < fx->base) {
            outPtr += fx->length;
        }
        if (inPtr == prevOutPtr) {
            SWAP16(buff1, buff2);
        } else {
            n_aLoadBuffer(cmdBufPos++, FIXED_SAMPLE<<1, buff1, osVirtualToPhysical(inPtr));
        }
        if (delay->resampler_28) {
            // modified _n_loadOutputBuffer
            s32 ratio;
            s32 length, count;
            f32 delta, fratio, fincount;
            s32 ramAlign;
            s16 tmp;
            s16* rsOutPtr;
 
            length = delay->output - delay->input;
            delta = func_80059BD4(delay, AUDIO_SAMPLES);
            delta /= length;
            delta = (s32)(delta * fUnityPitch);
            delta = delta / UNITY_PITCH;
            fratio = 1.0 - delta;
            fincount = delay->resampler_28->delta + (fratio * AUDIO_SAMPLES);
            count = (s32) fincount;
            delay->resampler_28->delta = fincount - count;
 
            rsOutPtr = &fx->input[-(delay->output - delay->rsdelta)];
            ramAlign = ((s32) rsOutPtr & 7) >> 1;
 
            rsOutPtr -= ramAlign;
            if (rsOutPtr < fx->base) {
                rsOutPtr += fx->length;
            }
 
            cmdBufPos = _saveBuffer(fx, rsOutPtr, rbuff, count + ramAlign, cmdBufPos);
            ratio = fratio * fUnityPitch;
 
            tmp = buff2 >> 8;
            n_aResample(cmdBufPos++, osVirtualToPhysical(delay->resampler_28->state),
                delay->resampler_28->first, ratio, rbuff + (ramAlign<<1), tmp);
 
            delay->resampler_28->first = 0;
            delay->rsdelta += count - AUDIO_SAMPLES;
        } else {
            n_aLoadBuffer(cmdBufPos++, FIXED_SAMPLE<<1, buff2, osVirtualToPhysical(outPtr));
        }
        if (delay->ffcoef) {
            aMix(cmdBufPos++, 0, (u16)delay->ffcoef, buff1, buff2);
 
            if (delay->resampler_28 == NULL && delay->lowpass_20 == NULL) {
                n_aSaveBuffer(cmdBufPos++, FIXED_SAMPLE<<1, buff2, osVirtualToPhysical(outPtr));
            }
        }
        if (delay->fbcoef) {
            aMix(cmdBufPos++, 0, (u16)delay->fbcoef, buff2, buff1);
            n_aSaveBuffer(cmdBufPos++, FIXED_SAMPLE<<1, buff1, osVirtualToPhysical(inPtr));
        }
        if (delay->lowpass_20 != NULL) {
            // modified _n_filterBuffer
            s16 tmp = buff2 >> 8;
            n_aLoadADPCM(cmdBufPos++, 32, osVirtualToPhysical(delay->lowpass_20->fccoef));
            n_aPoleFilter(cmdBufPos++, delay->lowpass_20->first, delay->lowpass_20->fgain, tmp, osVirtualToPhysical(delay->lowpass_20->fstate));
            delay->lowpass_20->first = 0;
        }
        if (!delay->resampler_28) {
            n_aSaveBuffer(cmdBufPos++, FIXED_SAMPLE<<1, buff2, osVirtualToPhysical(outPtr));
        }
        if (delay->gain) {
            aMix(cmdBufPos++, 0, (u16)delay->gain, buff2, outputBufCopy);
        }
        prevOutPtr = &fx->input[delay->output];
    }
 
    fx->input += AUDIO_SAMPLES;
    if (fx->input >= &fx->base[fx->length]) {
        fx->input = fx->base;
    }
    return cmdBufPos;
}

Referenced by alAudioFrame().

au_fx_param_hdl()

s32 au_fx_param_hdl	(	AuFX *	fx,
		s16	index,
		s16	paramID,
		s32	value )

Definition at line 384 of file reverb.c.

                                                                 {
    switch (paramID) {
    case INPUT_PARAM:
        fx->delays[index].input = value & 0xFFFFFFF8;
        break;
    case OUTPUT_PARAM:
        fx->delays[index].output = value & 0xFFFFFFF8;
        break;
    case FFCOEF_PARAM:
        fx->delays[index].ffcoef = value;
        break;
    case FBCOEF_PARAM:
        fx->delays[index].fbcoef = value;
        break;
    case GAIN_PARAM:
        fx->delays[index].gain = value;
        break;
    case CHORUSRATE_PARAM:
        fx->delays[index].rsinc = (2.0 * (value / 1000.0f)) / gActiveSynDriverPtr->outputRate;
        break;
    case CHORUSDEPTH_PARAM:
        fx->delays[index].rsgain = ((f32)value / CONVERT) * (fx->delays[index].output - fx->delays[index].input);
        break;
    case LPFILT_PARAM:
        if (fx->delays[index].lowpass_20) {
            fx->delays[index].lowpass_20->fc = value;
            _init_lpfilter(fx->delays[index].lowpass_20);
        }
        break;
    }
    return 0;
}

Referenced by au_bus_set_fx_params().

Variable Documentation

SMALL_ROOM_PARAMS

s32 SMALL_ROOM_PARAMS[]

Initial value:

= {
    
        3,             11,
    
        0,       9,  9830,  -9830,      0,      0,      0,      0,
        3,       7,  3276,  -3276, 0x3FFF,      0,      0,      0,
        0,      10,  5000,      0,      0,      0,      0, 0x5000
}

Definition at line 37 of file reverb.c.

                          {
    /* sections    length */
        3,             11,
    /*                                      chorus  chorus   filter
    input  output  fbcoef  ffcoef   gain     rate   depth     coef  */
        0,       9,  9830,  -9830,      0,      0,      0,      0,
        3,       7,  3276,  -3276, 0x3FFF,      0,      0,      0,
        0,      10,  5000,      0,      0,      0,      0, 0x5000
};

Referenced by func_8005904C().

BIG_ROOM_PARAMS

s32 BIG_ROOM_PARAMS[]

Initial value:

= {
    
        4,             14,
    
        0,       9,  9830,  -9830,      0,      0,      0,      0,
        2,       6,  3276,  -3276, 0x3FFF,      0,      0,      0,
        9,      12,  3276,  -3276, 0x3FFF,      0,      0,      0,
        0,      13,  6000,      0,      0,      0,      0,  0x5000
}

Definition at line 47 of file reverb.c.

                        {
    /* sections    length */
        4,             14,
    /*                                      chorus  chorus   filter
    input  output  fbcoef  ffcoef   gain     rate   depth     coef  */
        0,       9,  9830,  -9830,      0,      0,      0,      0,
        2,       6,  3276,  -3276, 0x3FFF,      0,      0,      0,
        9,      12,  3276,  -3276, 0x3FFF,      0,      0,      0,
        0,      13,  6000,      0,      0,      0,      0,  0x5000
};

Referenced by func_8005904C().

D_8007F0C0

s32 D_8007F0C0[]

Initial value:

= {
    
        4,             17,
    
        0,     11,   9830,  -9830,      0,      0,      0,      0,
        4,      9,   3276,  -3276, 0x3FFF,      0,      0,      0,
       11,     15,   3276,  -3276, 0x3FFF,      0,      0,      0,
        0,     16,   8000,      0,      0,      0,      0, 0x5000
}

Definition at line 59 of file reverb.c.

                   {
    /* sections    length */
        4,             17,
    /*                                      chorus  chorus   filter
    input  output  fbcoef  ffcoef   gain     rate   depth     coef  */
        0,     11,   9830,  -9830,      0,      0,      0,      0,
        4,      9,   3276,  -3276, 0x3FFF,      0,      0,      0,
       11,     15,   3276,  -3276, 0x3FFF,      0,      0,      0,
        0,     16,   8000,      0,      0,      0,      0, 0x5000
};

ECHO_PARAMS

s32 ECHO_PARAMS[]

Initial value:

= {
    
        1,             14,
    
        0,     13,  20000,      0, 0x7FFF,      0,      0, 0x7FFF
}

Definition at line 70 of file reverb.c.

                    {
    /* sections    length */
        1,             14,
    /*                                      chorus  chorus   filter
    input  output  fbcoef  ffcoef   gain     rate   depth     coef  */
        0,     13,  20000,      0, 0x7FFF,      0,      0, 0x7FFF
};

Referenced by func_8005904C().

CHORUS_PARAMS

s32 CHORUS_PARAMS[]

Initial value:

= {
    
        1,              3,
    
        0,      1,  16384,      0, 0x7FFF,   7600,    700,      0
}

Definition at line 78 of file reverb.c.

                      {
    /* sections    length */
        1,              3,
    /*                                      chorus  chorus   filter
    input  output  fbcoef  ffcoef   gain     rate   depth     coef  */
        0,      1,  16384,      0, 0x7FFF,   7600,    700,      0
};

Referenced by func_8005904C().

FLANGE_PARAMS

s32 FLANGE_PARAMS[]

Initial value:

= {
    
        1,              3,
    
        0,      1,      0, 0x5FFF, 0x7FFF,    380,    500,      0
}

Definition at line 86 of file reverb.c.

                      {
    /* sections    length */
        1,              3,
    /*                                      chorus  chorus   filter
    input  output  fbcoef  ffcoef   gain     rate   depth     coef  */
        0,      1,      0, 0x5FFF, 0x7FFF,    380,    500,      0
};

Referenced by func_8005904C().

NULL_PARAMS

s32 NULL_PARAMS[]

Initial value:

= {
    
        0,              0,
    
        0,      0,      0,      0,      0,      0,      0,      0
}

Definition at line 94 of file reverb.c.

                    {
    /* sections    length */
        0,              0,
    /*                                      chorus  chorus   filter
    input  output  fbcoef  ffcoef   gain     rate   depth     coef  */
        0,      0,      0,      0,      0,      0,      0,      0
};

Referenced by func_8005904C().

AU_FX_CUSTOM_PARAMS

s32* AU_FX_CUSTOM_PARAMS[]

Initial value:

= {
    NULL_PARAMS, NULL_PARAMS, NULL_PARAMS, NULL_PARAMS
}

Definition at line 103 of file reverb.c.

                             {
    NULL_PARAMS, NULL_PARAMS, NULL_PARAMS, NULL_PARAMS
};

Referenced by au_sfx_set_reverb_type(), and func_8005904C().