path: root/servers/audio/reverb_sw.cpp

/*************************************************************************/
/*  reverb_sw.cpp                                                        */
/*************************************************************************/
/*                       This file is part of:                           */
/*                           GODOT ENGINE                                */
/*                    http://www.godotengine.org                         */
/*************************************************************************/
/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur.                 */
/*                                                                       */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the       */
/* "Software"), to deal in the Software without restriction, including   */
/* without limitation the rights to use, copy, modify, merge, publish,   */
/* distribute, sublicense, and/or sell copies of the Software, and to    */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions:                                             */
/*                                                                       */
/* The above copyright notice and this permission notice shall be        */
/* included in all copies or substantial portions of the Software.       */
/*                                                                       */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
/*************************************************************************/
#include "reverb_sw.h"
#include "stdlib.h"
#include "print_string.h"
#define SETMIN( x, y ) (x) = MIN ( (x), (y) )
#define rangeloop( c, min, max )       \
	for ( (c) = (min) ; (c) < (max) ; (c)++ )

#define ABSDIFF(x, y)\
	( ((x) < (y)) ? ((y) - (x)) : ((x) - (y)) )


#ifdef bleh_MSC_VER

#if _MSC_VER >= 1400
	_FORCE_INLINE_ int32_tMULSHIFT_S32 (
		int32_t Factor1,
		int32_t Factor2,
		uint8_t Bits
					) {

			return __ll_rshift (
					__emul ( Factor1, Factor2 ),
			Bits
						);
					}
#endif

#else
#define MULSHIFT_S32( Factor1, Factor2, Bits )\
			( (int) (( (int64_t)(Factor1) * (Factor2) ) >> (Bits)) )
#endif



struct ReverbParamsSW {
	unsigned int BufferSize;		// Required buffer size
	int gLPF;			// Coefficient
	int gEcho0;			// Coefficient
	int gEcho1;			// Coefficient
	int gEcho2;			// Coefficient
	int gEcho3;			// Coefficient
	int gWall;			// Coefficient
	int gReva;			// Coefficient
	int gRevb;			// Coefficient
	int gInputL;		// Coefficient
	int gInputR;		// Coefficient
	unsigned int nRevaOldL;		// Offset
	unsigned int nRevaOldR;		// Offset
	unsigned int nRevbOldL;		// Offset
	unsigned int nRevbOldR;		// Offset
	unsigned int nLwlNew;		// Offset
	unsigned int nRwrNew;		// Offset
	unsigned int nEcho0L;		// Offset
	unsigned int nEcho0R;		// Offset
	unsigned int nEcho1L;		// Offset
	unsigned int nEcho1R;		// Offset
	unsigned int nLwlOld;		// Offset
	unsigned int nRwrOld;		// Offset
	unsigned int nLwrNew;		// Offset
	unsigned int nRwlNew;		// Offset
	unsigned int nEcho2L;		// Offset
	unsigned int nEcho2R;		// Offset
	unsigned int nEcho3L;		// Offset
	unsigned int nEcho3R;		// Offset
	unsigned int nLwrOld;		// Offset
	unsigned int nRwlOld;		// Offset
	unsigned int nRevaNewL;		// Offset
	unsigned int nRevaNewR;		// Offset
	unsigned int nRevbNewL;		// Offset
	unsigned int nRevbNewR;		// Offset
};

static ReverbParamsSW reverb_params_Room = {
	0x26C0/2,
//	gLPF		gEcho0		gEcho1		gEcho2		gEcho3		gWall
	0x6D80,		0x54B8,		-0x4130,	0x0000,		0x0000,		-0x4580,
//	gReva		gRevb		gInputL		gInputR
	0x5800,		0x5300,		-0x8000,	-0x8000,
//	nRevaOldL			nRevaOldR			nRevbOldL			nRevbOldR
	0x01B4 - 0x007D,	0x0136 - 0x007D,	0x00B8 - 0x005B,	0x005C - 0x005B,
//	nLwlNew		nRwrNew		nEcho0L		nEcho0R		nEcho1L		nEcho1R
	0x04D6,		0x0333,		0x03F0,		0x0227,		0x0374,		0x01EF,
//	nLwlOld		nRwrOld		nLwrNew		nRwlNew		nEcho2L		nEcho2R		nEcho3L		nEcho3R
	0x0334,		0x01B5,		0x0000,		0x0000,		0x0000,		0x0000,		0x0000,		0x0000,
//	nLwrOld		nRwlOld		nRevaNewL	nRevaNewR	nRevbNewL	nRevbNewR
	0x0000,		0x0000,		0x01B4,		0x0136,		0x00B8,		0x005C
};

static ReverbParamsSW reverb_params_StudioSmall = {
	0x1F40/2,
//	gLPF		gEcho0		gEcho1		gEcho2		gEcho3		gWall
	0x70F0,		0x4FA8,		-0x4320,	0x4410,		-0x3F10,	-0x6400,
//	gReva		gRevb		gInputL		gInputR
	0x5280,		0x4EC0,		-0x8000,	-0x8000,
//	nRevaOldL			nRevaOldR			nRevbOldL			nRevbOldR
	0x00B4 - 0x0033,	0x0080 - 0x0033,	0x004C - 0x0025,	0x0026 - 0x0025,
//	nLwlNew		nRwrNew		nEcho0L		nEcho0R		nEcho1L		nEcho1R
	0x03E4,		0x031B,		0x03A4,		0x02AF,		0x0372,		0x0266,
//	nLwlOld		nRwrOld		nLwrNew		nRwlNew		nEcho2L		nEcho2R		nEcho3L		nEcho3R
	0x031C,		0x025D,		0x025C,		0x018E,		0x022F,		0x0135,		0x01D2,		0x00B7,
//	nLwrOld		nRwlOld		nRevaNewL	nRevaNewR	nRevbNewL	nRevbNewR
	0x018F,		0x00B5,		0x00B4,		0x0080,		0x004C,		0x0026
};

static ReverbParamsSW reverb_params_StudioMedium = {
	0x4840/2,
//	gLPF		gEcho0		gEcho1		gEcho2		gEcho3		gWall
	0x70F0,		0x4FA8,		-0x4320,	0x4510,		-0x4110,	-0x4B40,
//	gReva		gRevb		gInputL		gInputR
	0x5280,		0x4EC0,		-0x8000,	-0x8000,
//	nRevaOldL			nRevaOldR			nRevbOldL			nRevbOldR
	0x0264 - 0x00B1,	0x01B2 - 0x00B1,	0x0100 - 0x007F,	0x0080 - 0x007F,
//	nLwlNew		nRwrNew		nEcho0L		nEcho0R		nEcho1L		nEcho1R
	0x0904,		0x076B,		0x0824,		0x065F,		0x07A2,		0x0616,
//	nLwlOld		nRwrOld		nLwrNew		nRwlNew		nEcho2L		nEcho2R		nEcho3L		nEcho3R
	0x076C,		0x05ED,		0x05EC,		0x042E,		0x050F,		0x0305,		0x0462,		0x02B7,
//	nLwrOld		nRwlOld		nRevaNewL	nRevaNewR	nRevbNewL	nRevbNewR
	0x042F,		0x0265,		0x0264,		0x01B2,		0x0100,		0x0080
};

static ReverbParamsSW reverb_params_StudioLarge = {
	0x6FE0/2,
//	gLPF		gEcho0		gEcho1		gEcho2		gEcho3		gWall
	0x6F60,		0x4FA8,		-0x4320,	0x4510,		-0x4110,	-0x5980,
//	gReva		gRevb		gInputL		gInputR
	0x5680,		0x52C0,		-0x8000,	-0x8000,
//	nRevaOldL			nRevaOldR			nRevbOldL			nRevbOldR
	0x031C - 0x00E3,	0x0238 - 0x00E3,	0x0154 -  0x00A9,	0x00AA - 0x00A9,
//	nLwlNew		nRwrNew		nEcho0L		nEcho0R		nEcho1L		nEcho1R
	0x0DFB,		0x0B58,		0x0D09,		0x0A3C,		0x0BD9,		0x0973,
//	nLwlOld		nRwrOld		nLwrNew		nRwlNew		nEcho2L		nEcho2R		nEcho3L		nEcho3R
	0x0B59,		0x08DA,		0x08D9,		0x05E9,		0x07EC,		0x04B0,		0x06EF,		0x03D2,
//	nLwrOld		nRwlOld		nRevaNewL	nRevaNewR	nRevbNewL	nRevbNewR
	0x05EA,		0x031D,		0x031C,		0x0238,		0x0154,		0x00AA
};

static ReverbParamsSW reverb_params_Hall = {
	0xADE0/2,
//	gLPF		gEcho0		gEcho1		gEcho2		gEcho3		gWall
	0x6000,		0x5000,		0x4C00,		-0x4800,	-0x4400,	-0x4000,
//	gReva		gRevb		gInputL		gInputR
	0x6000,		0x5C00,		-0x8000,	-0x8000,
//	nRevaOldL			nRevaOldR			nRevbOldL			nRevbOldR
	0x05C0 - 0x01A5,	0x041A - 0x01A5,	0x0274 - 0x0139,	0x013A -  0x0139,
//	nLwlNew		nRwrNew		nEcho0L		nEcho0R		nEcho1L		nEcho1R
	0x15BA,		0x11BB,		0x14C2,		0x10BD,		0x11BC,		0x0DC1,
//	nLwlOld		nRwrOld		nLwrNew		nRwlNew		nEcho2L		nEcho2R		nEcho3L		nEcho3R
	0x11C0,		0x0DC3,		0x0DC0,		0x09C1,		0x0BC4,		0x07C1,		0x0A00,		0x06CD,
//	nLwrOld		nRwlOld		nRevaNewL	nRevaNewR	nRevbNewL	nRevbNewR
	0x09C2,		0x05C1,		0x05C0,		0x041A,		0x0274,		0x013A
};

static ReverbParamsSW reverb_params_SpaceEcho = {
	0xF6C0/2,
//	gLPF		gEcho0		gEcho1		gEcho2		gEcho3		gWall
	0x7E00,		0x5000,		-0x4C00,	-0x5000,	0x4C00,		-0x5000,
//	gReva		gRevb		gInputL		gInputR
	0x6000,		0x5400,		-0x8000,	-0x8000,
//	nRevaOldL			nRevaOldR			nRevbOldL			nRevbOldR
	0x0AE0 - 0x033D,	0x07A2 - 0x033D,	0x0464 - 0x0231,	0x0232 - 0x0231,
//	nLwlNew		nRwrNew		nEcho0L		nEcho0R		nEcho1L		nEcho1R
	0x1ED6,		0x1A31,		0x1D14,		0x183B,		0x1BC2,		0x16B2,
//	nLwlOld		nRwrOld		nLwrNew		nRwlNew		nEcho2L		nEcho2R		nEcho3L		nEcho3R
	0x1A32,		0x15EF,		0x15EE,		0x1055,		0x1334,		0x0F2D,		0x11F6,		0x0C5D,
//	nLwrOld		nRwlOld		nRevaNewL	nRevaNewR	nRevbNewL	nRevbNewR
	0x1056,		0x0AE1,		0x0AE0,		0x07A2,		0x0464,		0x0232
};

static ReverbParamsSW reverb_params_Echo = {
	0x18040/2,
//	gLPF		gEcho0		gEcho1		gEcho2		gEcho3		gWall
	0x7FFF,		0x7FFF,		0x0000,		0x0000,		0x0000,		-0x7F00,
//	gReva		gRevb		gInputL		gInputR
	0x0000,		0x0000,		-0x8000,	-0x8000,
//	nRevaOldL			nRevaOldR			nRevbOldL			nRevbOldR
	0x1004 - 0x0001,	0x1002 - 0x0001,	0x0004 - 0x0001,	0x0002 - 0x0001,
//	nLwlNew		nRwrNew		nEcho0L		nEcho0R		nEcho1L		nEcho1R
	0x1FFF,		0x0FFF,		0x1005,		0x0005,		0x0000,		0x0000,
//	nLwlOld		nRwrOld		nLwrNew		nRwlNew		nEcho2L		nEcho2R		nEcho3L		nEcho3R
	0x1005,		0x0005,		0x0000,		0x0000,		0x0000,		0x0000,		0x0000,		0x0000,
//	nLwrOld		nRwlOld		nRevaNewL	nRevaNewR	nRevbNewL	nRevbNewR
	0x0000,		0x0000,		0x1004,		0x1002,		0x0004,		0x0002
};

static ReverbParamsSW reverb_params_Delay = {
	0x18040/2,
//	gLPF		gEcho0		gEcho1		gEcho2		gEcho3		gWall
	0x7FFF,		0x7FFF,		0x0000,		0x0000,		0x0000,		0x0000,
//	gReva		gRevb		gInputL		gInputR
	0x0000,		0x0000,		-0x8000,	-0x8000,
//	nRevaOldL			nRevaOldR			nRevbOldL			nRevbOldR
	0x1004 - 0x0001,	0x1002 - 0x0001,	0x0004 - 0x0001,	0x0002 - 0x0001,
//	nLwlNew		nRwrNew		nEcho0L		nEcho0R		nEcho1L		nEcho1R
	0x1FFF,		0x0FFF,		0x1005,		0x0005,		0x0000,		0x0000,
//	nLwlOld		nRwrOld		nLwrNew		nRwlNew		nEcho2L		nEcho2R		nEcho3L		nEcho3R
	0x1005,		0x0005,		0x0000,		0x0000,		0x0000,		0x0000,		0x0000,		0x0000,
//	nLwrOld		nRwlOld		nRevaNewL	nRevaNewR	nRevbNewL	nRevbNewR
	0x0000,		0x0000,		0x1004,		0x1002,		0x0004,		0x0002
};

static ReverbParamsSW reverb_params_HalfEcho = {
	0x3C00/2,
//	gLPF		gEcho0		gEcho1		gEcho2		gEcho3		gWall
	0x70F0,		0x4FA8,		-0x4320,	0x4510,		-0x4110,	-0x7B00,
//	gReva		gRevb		gInputL		gInputR
	0x5F80,		0x54C0,		-0x8000,	-0x8000,
//	nRevaOldL			nRevaOldR			nRevbOldL			nRevbOldR
	0x0058 - 0x0017,	0x0040 - 0x0017,	0x0028 - 0x0013,	0x0014 - 0x0013,
//	nLwlNew		nRwrNew		nEcho0L		nEcho0R		nEcho1L		nEcho1R
	0x0371,		0x02AF,		0x02E5,		0x01DF,		0x02B0,		0x01D7,
//	nLwlOld		nRwrOld		nLwrNew		nRwlNew		nEcho2L		nEcho2R		nEcho3L		nEcho3R
	0x0358,		0x026A,		0x01D6,		0x011E,		0x012D,		0x00B1,		0x011F,		0x0059,
//	nLwrOld		nRwlOld		nRevaNewL	nRevaNewR	nRevbNewL	nRevbNewR
	0x01A0,		0x00E3,		0x0058,		0x0040,		0x0028,		0x0014
};


static ReverbParamsSW * reverb_param_modes[] = {
	&reverb_params_Room,
	&reverb_params_StudioSmall,
	&reverb_params_StudioMedium,
	&reverb_params_StudioLarge,
	&reverb_params_Hall,
	&reverb_params_SpaceEcho,
	&reverb_params_Echo,
	&reverb_params_Delay,
	&reverb_params_HalfEcho,
};

bool ReverbSW::process(int *p_input,int *p_output,int p_frames,int p_stereo_stride) {

	if (!reverb_buffer)
		return false;


		//
	// p_input must point to a non-looping buffer.
	// BOTH p_input and p_output must be touched (use ClearModuleBuffer).

	// �������LOCAL MACROS ������۲

#undef LM_SETSRCOFFSET
#define LM_SETSRCOFFSET(x)								\
			(x) = current_params->x + Offset;									\
			if ( (x) >= reverb_buffer_size ) {						\
				(x) -= reverb_buffer_size;							\
	}												\
			SETMIN ( aSample, reverb_buffer_size - (x) );

/*
#undef LM_SETSRCOFFSET2
#define LM_SETSRCOFFSET2(x,y)							\
			(x) = ((y) << 3) >> HZShift;					\
			(x) += Offset;									\
			if ( (x) >= reverb_buffer_size ) {						\
				(x) -= reverb_buffer_size;							\
	}												\
			SETMIN ( aSample, reverb_buffer_size - (x) );
*/
#undef LM_SRCADVANCE
#define LM_SRCADVANCE(x)								\
			(x) += aSample;

#undef LM_MUL
#define LM_MUL(x,y)										\
MULSHIFT_S32 ( x, current_params->y, 15 )

#undef LM_REVERB
#define LM_REVERB(x) reverb_buffer[ (x) + cSample ]

	// �������LOCAL VARIABLES ������۲

	unsigned int Offset;

	int lwl, lwr, rwl, rwr;
//	unsigned char HZShift;

	// �������CODE ������۲


	lwl = state.lwl;
	lwr = state.lwr;
	rwl = state.rwl;
	rwr = state.rwr;
	Offset = state.Offset;

	int max=0;

	while ( p_frames ) {

		// Offsets

		unsigned int nLwlOld;
		unsigned int nRwrOld;
		unsigned int nLwlNew;
		unsigned int nRwrNew;

		unsigned int nLwrOld;
		unsigned int nRwlOld;
		unsigned int nLwrNew;
		unsigned int nRwlNew;

		unsigned int nEcho0L;
		unsigned int nEcho1L;
		unsigned int nEcho2L;
		unsigned int nEcho3L;

		unsigned int nEcho0R;
		unsigned int nEcho1R;
		unsigned int nEcho2R;
		unsigned int nEcho3R;

		unsigned int nRevaOldL;
		unsigned int nRevaOldR;
		unsigned int nRevbOldL;
		unsigned int nRevbOldR;

		unsigned int nRevaNewL;
		unsigned int nRevaNewR;
		unsigned int nRevbNewL;
		unsigned int nRevbNewR;

		// Other variables

		unsigned int aSample = p_frames;

		// Set initial offsets

		LM_SETSRCOFFSET ( nLwlOld );
		LM_SETSRCOFFSET ( nRwrOld );
		LM_SETSRCOFFSET ( nLwlNew );
		LM_SETSRCOFFSET ( nRwrNew );
		LM_SETSRCOFFSET ( nLwrOld );
		LM_SETSRCOFFSET ( nRwlOld );
		LM_SETSRCOFFSET ( nLwrNew );
		LM_SETSRCOFFSET ( nRwlNew );
		LM_SETSRCOFFSET ( nEcho0L );
		LM_SETSRCOFFSET ( nEcho1L );
		LM_SETSRCOFFSET ( nEcho2L );
		LM_SETSRCOFFSET ( nEcho3L );
		LM_SETSRCOFFSET ( nEcho0R );
		LM_SETSRCOFFSET ( nEcho1R );
		LM_SETSRCOFFSET ( nEcho2R );
		LM_SETSRCOFFSET ( nEcho3R );
		LM_SETSRCOFFSET ( nRevaOldL );
		LM_SETSRCOFFSET ( nRevaOldR );
		LM_SETSRCOFFSET ( nRevbOldL );
		LM_SETSRCOFFSET ( nRevbOldR );
		LM_SETSRCOFFSET ( nRevaNewL );
		LM_SETSRCOFFSET ( nRevaNewR );
		LM_SETSRCOFFSET ( nRevbNewL );
		LM_SETSRCOFFSET ( nRevbNewR );

		//SETMIN ( aSample, p_output.Size - p_output.Offset );

		for (unsigned int cSample=0;cSample<aSample;cSample++) {

			int tempL0, tempL1, tempR0, tempR1;

			tempL1 = p_input[(cSample<<p_stereo_stride)]>>8;
			tempR1 = p_input[(cSample<<p_stereo_stride) + 1]>>8;

			tempL0 = LM_MUL ( tempL1, gInputL );
			tempR0 = LM_MUL ( tempR1, gInputR );

			/*
			Left -> Wall -> Left Reflection
			*/
			tempL1 = tempL0 + LM_MUL ( LM_REVERB( nLwlOld ), gWall );
			tempR1 = tempR0 + LM_MUL ( LM_REVERB( nRwrOld ), gWall );
			lwl += LM_MUL ( tempL1 - lwl, gLPF );
			rwr += LM_MUL ( tempR1 - rwr, gLPF );
			LM_REVERB( nLwlNew ) = lwl;
			LM_REVERB( nRwrNew ) = rwr;
			/*
			Left -> Wall -> Right Reflection
			*/
			tempL1 = tempL0 + LM_MUL ( LM_REVERB( nRwlOld ), gWall );
			tempR1 = tempR0 + LM_MUL ( LM_REVERB( nLwrOld ), gWall );
			lwr += LM_MUL ( tempL1 - lwr, gLPF );
			rwl += LM_MUL ( tempR1 - rwl, gLPF );
			LM_REVERB( nLwrNew ) = lwr;
			LM_REVERB( nRwlNew ) = rwl;
			/*
			Early Echo(Early Reflection)
			*/
			tempL0 =
					LM_MUL ( LM_REVERB( nEcho0L ), gEcho0 ) +
					LM_MUL ( LM_REVERB( nEcho1L ), gEcho1 ) +
					LM_MUL ( LM_REVERB( nEcho2L ), gEcho2 ) +
					LM_MUL ( LM_REVERB( nEcho3L ), gEcho3 );
			tempR0 =
					LM_MUL ( LM_REVERB( nEcho0R ), gEcho0 ) +
					LM_MUL ( LM_REVERB( nEcho1R ), gEcho1 ) +
					LM_MUL ( LM_REVERB( nEcho2R ), gEcho2 ) +
					LM_MUL ( LM_REVERB( nEcho3R ), gEcho3 );
			/*
			Late Reverb
			*/
			tempL1 = LM_REVERB( nRevaOldL );
			tempR1 = LM_REVERB( nRevaOldR );
			tempL0 -= LM_MUL ( tempL1, gReva );
			tempR0 -= LM_MUL ( tempR1, gReva );
			LM_REVERB( nRevaNewL ) = tempL0;
			LM_REVERB( nRevaNewR ) = tempR0;
			tempL0 = LM_MUL ( tempL0, gReva ) + tempL1;
			tempR0 = LM_MUL ( tempR0, gReva ) + tempR1;
			tempL1 = LM_REVERB( nRevbOldL );
			tempR1 = LM_REVERB( nRevbOldR );
			tempL0 -= LM_MUL ( tempL1, gRevb );
			tempR0 -= LM_MUL ( tempR1, gRevb );
			LM_REVERB( nRevbNewL ) = tempL0;
			LM_REVERB( nRevbNewR ) = tempR0;
			tempL0 = LM_MUL ( tempL0, gRevb ) + tempL1;
			tempR0 = LM_MUL ( tempR0, gRevb ) + tempR1;
			/*
			Output
			*/

			max|=abs(tempL0);
			max|=abs(tempR0);

			p_output[(cSample<<p_stereo_stride)] += tempL0<<8;
			p_output[(cSample<<p_stereo_stride) + 1] += tempR0<<8;

		}

		// Advance offsets

		Offset += aSample;
		if ( Offset >= reverb_buffer_size ) { Offset -= reverb_buffer_size; }

		p_input += aSample << p_stereo_stride;
		p_output += aSample << p_stereo_stride;

		p_frames -= aSample;
	}

	state.lwl = lwl;
	state.lwr = lwr;
	state.rwl = rwl;
	state.rwr = rwr;
	state.Offset = Offset;

	return (max&0x7FFFFF00)!=0; // audio was mixed?
}

void ReverbSW::adjust_current_params() {

	*current_params=*reverb_param_modes[mode];

	uint32_t maxofs=0;

#define LM_CONFIG_PARAM( x )\
	current_params->x=(int)( ( (int64_t)current_params->x*(int64_t)mix_rate*8L)/(int64_t)44100);\
	if (current_params->x>maxofs)\
		maxofs=current_params->x;


	LM_CONFIG_PARAM ( nLwlOld );
	LM_CONFIG_PARAM ( nRwrOld );
	LM_CONFIG_PARAM ( nLwlNew );
	LM_CONFIG_PARAM ( nRwrNew );
	LM_CONFIG_PARAM ( nLwrOld );
	LM_CONFIG_PARAM ( nRwlOld );
	LM_CONFIG_PARAM ( nLwrNew );
	LM_CONFIG_PARAM ( nRwlNew );
	LM_CONFIG_PARAM ( nEcho0L );
	LM_CONFIG_PARAM ( nEcho1L );
	LM_CONFIG_PARAM ( nEcho2L );
	LM_CONFIG_PARAM ( nEcho3L );
	LM_CONFIG_PARAM ( nEcho0R );
	LM_CONFIG_PARAM ( nEcho1R );
	LM_CONFIG_PARAM ( nEcho2R );
	LM_CONFIG_PARAM ( nEcho3R );
	LM_CONFIG_PARAM ( nRevaOldL );
	LM_CONFIG_PARAM ( nRevaOldR );
	LM_CONFIG_PARAM ( nRevbOldL );
	LM_CONFIG_PARAM ( nRevbOldR );
	LM_CONFIG_PARAM ( nRevaNewL );
	LM_CONFIG_PARAM ( nRevaNewR );
	LM_CONFIG_PARAM ( nRevbNewL );
	LM_CONFIG_PARAM ( nRevbNewR );

	int needed_buffer_size=maxofs+1;
	if (reverb_buffer)
		memdelete_arr(reverb_buffer);

	reverb_buffer = memnew_arr(int,needed_buffer_size);
	reverb_buffer_size=needed_buffer_size;

	for (uint32_t i=0;i<reverb_buffer_size;i++)
		reverb_buffer[i]=0;

	state.reset();


}

void ReverbSW::set_mode(ReverbMode p_mode) {

	if (mode==p_mode)
		return;

	mode=p_mode;

	adjust_current_params();
}

void ReverbSW::set_mix_rate(int p_mix_rate) {

	if (p_mix_rate==mix_rate)
		return;

	mix_rate=p_mix_rate;

	adjust_current_params();

}


ReverbSW::ReverbSW() {

	reverb_buffer=0;
	reverb_buffer_size=0;
	mode=REVERB_MODE_ROOM;
	mix_rate=1;
	current_params = memnew(ReverbParamsSW);
}


ReverbSW::~ReverbSW() {


	if (reverb_buffer)
		memdelete_arr(reverb_buffer);

	memdelete(current_params);

}