[pcsx_rearmed.git] / plugins / dfsound / reverb.c

/***************************************************************************\r
                          reverb.c  -  description\r
                             -------------------\r
    begin                : Wed May 15 2002\r
    copyright            : (C) 2002 by Pete Bernert\r
    email                : BlackDove@addcom.de\r
\r
 Portions (C) Gražvydas "notaz" Ignotas, 2010-2011\r
 Portions (C) SPU2-X, gigaherz, Pcsx2 Development Team\r
\r
 ***************************************************************************/\r
/***************************************************************************\r
 *                                                                         *\r
 *   This program is free software; you can redistribute it and/or modify  *\r
 *   it under the terms of the GNU General Public License as published by  *\r
 *   the Free Software Foundation; either version 2 of the License, or     *\r
 *   (at your option) any later version. See also the license.txt file for *\r
 *   additional informations.                                              *\r
 *                                                                         *\r
 ***************************************************************************/\r
\r
#include "stdafx.h"\r
#include "spu.h"\r
#include <assert.h>\r
\r
#define _IN_REVERB\r
\r
// will be included from spu.c\r
#ifdef _IN_SPU\r
\r
////////////////////////////////////////////////////////////////////////\r
// START REVERB\r
////////////////////////////////////////////////////////////////////////\r
\r
INLINE void StartREVERB(int ch)\r
{\r
 if(spu.s_chan[ch].bReverb && (spu.spuCtrl&0x80))      // reverb possible?\r
  {\r
   spu.s_chan[ch].bRVBActive=!!spu_config.iUseReverb;\r
  }\r
 else spu.s_chan[ch].bRVBActive=0;                     // else -> no reverb\r
}\r
\r
////////////////////////////////////////////////////////////////////////\r
\r
INLINE int rvb_wrap(int ofs, int space)\r
{\r
#if 0\r
 int mask = (0x3ffff - ofs) >> 31;\r
 ofs = ofs - (space & mask);\r
#else\r
 if (ofs >= 0x40000)\r
  ofs -= space;\r
#endif\r
 //assert(ofs >= 0x40000 - space);\r
 //assert(ofs < 0x40000);\r
 return ofs;\r
}\r
\r
INLINE int rvb2ram_offs(int curr, int space, int ofs)\r
{\r
 ofs += curr;\r
 return rvb_wrap(ofs, space);\r
}\r
\r
// get_buffer content helper: takes care about wraps\r
#define g_buffer(var) \\r
 ((int)(signed short)LE16TOH(spuMem[rvb2ram_offs(curr_addr, space, var)]))\r
\r
// saturate iVal and store it as var\r
#define s_buffer_w(var, iVal) \\r
 ssat32_to_16(iVal); \\r
 spuMem[rvb2ram_offs(curr_addr, space, var)] = HTOLE16(iVal)\r
\r
////////////////////////////////////////////////////////////////////////\r
\r
static void reverb_interpolate(sample_buf *sb, int curr_addr,\r
  int out0[2], int out1[2])\r
{\r
 int spos = (curr_addr - 3) & 3;\r
 int dpos = curr_addr & 3;\r
 int i;\r
\r
 for (i = 0; i < 2; i++)\r
  sb->SB_rvb[i][dpos] = sb->SB_rvb[i][4 | dpos] = out0[i];\r
\r
 // mednafen uses some 20 coefs here, we just reuse gauss [0] and [128]\r
 for (i = 0; i < 2; i++)\r
 {\r
  const int *s;\r
  s = &sb->SB_rvb[i][spos];\r
  out0[i] = (s[0] * 0x12c7 + s[1] * 0x59b3 + s[2] * 0x1307) >> 15;\r
  out1[i] = (s[0] * 0x019c + s[1] * 0x3def + s[2] * 0x3e4c + s[3] * 0x01a8) >> 15;\r
 }\r
}\r
\r
static void MixREVERB(int *SSumLR, int *RVB, int ns_to, int curr_addr,\r
  int do_filter)\r
{\r
 unsigned short *spuMem = spu.spuMem;\r
 const REVERBInfo *rvb = spu.rvb;\r
 sample_buf *sb = &spu.sb[MAXCHAN];\r
 int space = 0x40000 - rvb->StartAddr;\r
 int mlsame_m2o = rvb->mLSAME + space - 1;\r
 int mrsame_m2o = rvb->mRSAME + space - 1;\r
 int mldiff_m2o = rvb->mLDIFF + space - 1;\r
 int mrdiff_m2o = rvb->mRDIFF + space - 1;\r
 int vCOMB1 = rvb->vCOMB1 >> 1, vCOMB2 = rvb->vCOMB2 >> 1;\r
 int vCOMB3 = rvb->vCOMB3 >> 1, vCOMB4 = rvb->vCOMB4 >> 1;\r
 int vAPF1 = rvb->vAPF1 >> 1, vAPF2 = rvb->vAPF2 >> 1;\r
 int vLIN = rvb->vLIN >> 1, vRIN = rvb->vRIN >> 1;\r
 int vWALL = rvb->vWALL >> 1;\r
 int vIIR = rvb->vIIR;\r
 int ns;\r
\r
#if P_HAVE_PTHREAD || defined(WANT_THREAD_CODE)\r
 sb = &spu.sb_thread[MAXCHAN];\r
#endif\r
 if (mlsame_m2o >= space) mlsame_m2o -= space;\r
 if (mrsame_m2o >= space) mrsame_m2o -= space;\r
 if (mldiff_m2o >= space) mldiff_m2o -= space;\r
 if (mrdiff_m2o >= space) mrdiff_m2o -= space;\r
\r
 for (ns = 0; ns < ns_to * 2; )\r
  {\r
   int Lin = RVB[ns];\r
   int Rin = RVB[ns+1];\r
   int mlsame_m2 = g_buffer(mlsame_m2o) << (15-1);\r
   int mrsame_m2 = g_buffer(mrsame_m2o) << (15-1);\r
   int mldiff_m2 = g_buffer(mldiff_m2o) << (15-1);\r
   int mrdiff_m2 = g_buffer(mrdiff_m2o) << (15-1);\r
   int Lout, Rout, out0[2], out1[2];\r
\r
   ssat32_to_16(Lin); Lin *= vLIN;\r
   ssat32_to_16(Rin); Rin *= vRIN;\r
\r
   // from nocash psx-spx\r
   mlsame_m2 += ((Lin + g_buffer(rvb->dLSAME) * vWALL - mlsame_m2) >> 15) * vIIR;\r
   mrsame_m2 += ((Rin + g_buffer(rvb->dRSAME) * vWALL - mrsame_m2) >> 15) * vIIR;\r
   mldiff_m2 += ((Lin + g_buffer(rvb->dLDIFF) * vWALL - mldiff_m2) >> 15) * vIIR;\r
   mrdiff_m2 += ((Rin + g_buffer(rvb->dRDIFF) * vWALL - mrdiff_m2) >> 15) * vIIR;\r
   mlsame_m2 >>= (15-1); s_buffer_w(rvb->mLSAME, mlsame_m2);\r
   mrsame_m2 >>= (15-1); s_buffer_w(rvb->mRSAME, mrsame_m2);\r
   mldiff_m2 >>= (15-1); s_buffer_w(rvb->mLDIFF, mldiff_m2);\r
   mrdiff_m2 >>= (15-1); s_buffer_w(rvb->mRDIFF, mrdiff_m2);\r
\r
   Lout = vCOMB1 * g_buffer(rvb->mLCOMB1) + vCOMB2 * g_buffer(rvb->mLCOMB2)\r
        + vCOMB3 * g_buffer(rvb->mLCOMB3) + vCOMB4 * g_buffer(rvb->mLCOMB4);\r
   Rout = vCOMB1 * g_buffer(rvb->mRCOMB1) + vCOMB2 * g_buffer(rvb->mRCOMB2)\r
        + vCOMB3 * g_buffer(rvb->mRCOMB3) + vCOMB4 * g_buffer(rvb->mRCOMB4);\r
\r
   preload(SSumLR + ns + 64*2/4 - 4);\r
\r
   Lout -= vAPF1 * g_buffer(rvb->mLAPF1_dAPF1); Lout >>= (15-1);\r
   Rout -= vAPF1 * g_buffer(rvb->mRAPF1_dAPF1); Rout >>= (15-1);\r
   s_buffer_w(rvb->mLAPF1, Lout);\r
   s_buffer_w(rvb->mRAPF1, Rout);\r
   Lout = Lout * vAPF1 + (g_buffer(rvb->mLAPF1_dAPF1) << (15-1));\r
   Rout = Rout * vAPF1 + (g_buffer(rvb->mRAPF1_dAPF1) << (15-1));\r
\r
   preload(RVB + ns + 64*2/4 - 4);\r
\r
   Lout -= vAPF2 * g_buffer(rvb->mLAPF2_dAPF2); Lout >>= (15-1);\r
   Rout -= vAPF2 * g_buffer(rvb->mRAPF2_dAPF2); Rout >>= (15-1);\r
   s_buffer_w(rvb->mLAPF2, Lout);\r
   s_buffer_w(rvb->mRAPF2, Rout);\r
   Lout = Lout * vAPF2 + (g_buffer(rvb->mLAPF2_dAPF2) << (15-1));\r
   Rout = Rout * vAPF2 + (g_buffer(rvb->mRAPF2_dAPF2) << (15-1));\r
\r
   out0[0] = out1[0] = (Lout >> (15-1)) * rvb->VolLeft  >> 15;\r
   out0[1] = out1[1] = (Rout >> (15-1)) * rvb->VolRight >> 15;\r
   if (do_filter)\r
    reverb_interpolate(sb, curr_addr, out0, out1);\r
\r
   SSumLR[ns++] += out0[0];\r
   SSumLR[ns++] += out0[1];\r
   SSumLR[ns++] += out1[0];\r
   SSumLR[ns++] += out1[1];\r
\r
   curr_addr++;\r
   curr_addr = rvb_wrap(curr_addr, space);\r
  }\r
}\r
\r
static void MixREVERB_off(int *SSumLR, int ns_to, int curr_addr)\r
{\r
 const REVERBInfo *rvb = spu.rvb;\r
 unsigned short *spuMem = spu.spuMem;\r
 int space = 0x40000 - rvb->StartAddr;\r
 int Lout, Rout, ns;\r
\r
 for (ns = 0; ns < ns_to * 2; )\r
  {\r
   preload(SSumLR + ns + 64*2/4 - 4);\r
\r
   // todo: is this missing COMB and APF1?\r
   Lout = g_buffer(rvb->mLAPF2_dAPF2);\r
   Rout = g_buffer(rvb->mLAPF2_dAPF2);\r
\r
   Lout = (Lout * rvb->VolLeft)  >> 15;\r
   Rout = (Rout * rvb->VolRight) >> 15;\r
\r
   SSumLR[ns++] += Lout;\r
   SSumLR[ns++] += Rout;\r
   SSumLR[ns++] += Lout;\r
   SSumLR[ns++] += Rout;\r
\r
   curr_addr++;\r
   if (curr_addr >= 0x40000) curr_addr = rvb->StartAddr;\r
  }\r
}\r
\r
static void REVERBPrep(void)\r
{\r
 REVERBInfo *rvb = spu.rvb;\r
 int space, t;\r
\r
 t = regAreaGet(H_SPUReverbAddr);\r
 if (t == 0xFFFF || t <= 0x200)\r
  spu.rvb->StartAddr = spu.rvb->CurrAddr = 0;\r
 else if (spu.rvb->StartAddr != (t << 2))\r
  spu.rvb->StartAddr = spu.rvb->CurrAddr = t << 2;\r
\r
 space = 0x40000 - rvb->StartAddr;\r
\r
 #define prep_offs(v, r) \\r
   t = spu.regArea[(0x1c0 + r) >> 1] * 4; \\r
   while (t >= space) \\r
     t -= space; \\r
   rvb->v = t\r
 #define prep_offs2(d, r1, r2) \\r
   t = spu.regArea[(0x1c0 + r1) >> 1] * 4; \\r
   t -= spu.regArea[(0x1c0 + r2) >> 1] * 4; \\r
   while (t < 0) \\r
     t += space; \\r
   while (t >= space) \\r
     t -= space; \\r
   rvb->d = t\r
\r
 prep_offs(mLSAME,  0x14);\r
 prep_offs(mRSAME,  0x16);\r
 prep_offs(mLCOMB1, 0x18);\r
 prep_offs(mRCOMB1, 0x1a);\r
 prep_offs(mLCOMB2, 0x1c);\r
 prep_offs(mRCOMB2, 0x1e);\r
 prep_offs(dLSAME,  0x20);\r
 prep_offs(dRSAME,  0x22);\r
 prep_offs(mLDIFF,  0x24);\r
 prep_offs(mRDIFF,  0x26);\r
 prep_offs(mLCOMB3, 0x28);\r
 prep_offs(mRCOMB3, 0x2a);\r
 prep_offs(mLCOMB4, 0x2c);\r
 prep_offs(mRCOMB4, 0x2e);\r
 prep_offs(dLDIFF,  0x30);\r
 prep_offs(dRDIFF,  0x32);\r
 prep_offs(mLAPF1,  0x34);\r
 prep_offs(mRAPF1,  0x36);\r
 prep_offs(mLAPF2,  0x38);\r
 prep_offs(mRAPF2,  0x3a);\r
 prep_offs2(mLAPF1_dAPF1, 0x34, 0);\r
 prep_offs2(mRAPF1_dAPF1, 0x36, 0);\r
 prep_offs2(mLAPF2_dAPF2, 0x38, 2);\r
 prep_offs2(mRAPF2_dAPF2, 0x3a, 2);\r
\r
#undef prep_offs\r
#undef prep_offs2\r
 rvb->dirty = 0;\r
}\r
\r
INLINE void REVERBDo(int *SSumLR, int *RVB, int ns_to, int curr_addr)\r
{\r
 if (spu.spuCtrl & 0x80)                               // -> reverb on? oki\r
 {\r
  MixREVERB(SSumLR, RVB, ns_to, curr_addr, 0); //spu.interpolation > 1);\r
 }\r
 else if (spu.rvb->VolLeft || spu.rvb->VolRight)\r
 {\r
  MixREVERB_off(SSumLR, ns_to, curr_addr);\r
 }\r
}\r
\r
////////////////////////////////////////////////////////////////////////\r
\r
#endif\r
\r
// vim:shiftwidth=1:expandtab\r
Commit	Line	Data
	1	/***************************************************************************\r
	2	reverb.c - description\r
	3	-------------------\r
	4	begin : Wed May 15 2002\r
	5	copyright : (C) 2002 by Pete Bernert\r
	6	email : BlackDove@addcom.de\r
	7	\r
	8	Portions (C) Gražvydas "notaz" Ignotas, 2010-2011\r
	9	Portions (C) SPU2-X, gigaherz, Pcsx2 Development Team\r
	10	\r
	11	***************************************************************************/\r
	12	/***************************************************************************\r
	13	* *\r
	14	* This program is free software; you can redistribute it and/or modify *\r
	15	* it under the terms of the GNU General Public License as published by *\r
	16	* the Free Software Foundation; either version 2 of the License, or *\r
	17	* (at your option) any later version. See also the license.txt file for *\r
	18	* additional informations. *\r
	19	* *\r
	20	***************************************************************************/\r
	21	\r
	22	#include "stdafx.h"\r
	23	#include "spu.h"\r
	24	#include <assert.h>\r
	25	\r
	26	#define _IN_REVERB\r
	27	\r
	28	// will be included from spu.c\r
	29	#ifdef _IN_SPU\r
	30	\r
	31	////////////////////////////////////////////////////////////////////////\r
	32	// START REVERB\r
	33	////////////////////////////////////////////////////////////////////////\r
	34	\r
	35	INLINE void StartREVERB(int ch)\r
	36	{\r
	37	if(spu.s_chan[ch].bReverb && (spu.spuCtrl&0x80)) // reverb possible?\r
	38	{\r
	39	spu.s_chan[ch].bRVBActive=!!spu_config.iUseReverb;\r
	40	}\r
	41	else spu.s_chan[ch].bRVBActive=0; // else -> no reverb\r
	42	}\r
	43	\r
	44	////////////////////////////////////////////////////////////////////////\r
	45	\r
	46	INLINE int rvb_wrap(int ofs, int space)\r
	47	{\r
	48	#if 0\r
	49	int mask = (0x3ffff - ofs) >> 31;\r
	50	ofs = ofs - (space & mask);\r
	51	#else\r
	52	if (ofs >= 0x40000)\r
	53	ofs -= space;\r
	54	#endif\r
	55	//assert(ofs >= 0x40000 - space);\r
	56	//assert(ofs < 0x40000);\r
	57	return ofs;\r
	58	}\r
	59	\r
	60	INLINE int rvb2ram_offs(int curr, int space, int ofs)\r
	61	{\r
	62	ofs += curr;\r
	63	return rvb_wrap(ofs, space);\r
	64	}\r
	65	\r
	66	// get_buffer content helper: takes care about wraps\r
	67	#define g_buffer(var) \\r
	68	((int)(signed short)LE16TOH(spuMem[rvb2ram_offs(curr_addr, space, var)]))\r
	69	\r
	70	// saturate iVal and store it as var\r
	71	#define s_buffer_w(var, iVal) \\r
	72	ssat32_to_16(iVal); \\r
	73	spuMem[rvb2ram_offs(curr_addr, space, var)] = HTOLE16(iVal)\r
	74	\r
	75	////////////////////////////////////////////////////////////////////////\r
	76	\r
	77	static void reverb_interpolate(sample_buf *sb, int curr_addr,\r
	78	int out0[2], int out1[2])\r
	79	{\r
	80	int spos = (curr_addr - 3) & 3;\r
	81	int dpos = curr_addr & 3;\r
	82	int i;\r
	83	\r
	84	for (i = 0; i < 2; i++)\r
	85	sb->SB_rvb[i][dpos] = sb->SB_rvb[i][4 \| dpos] = out0[i];\r
	86	\r
	87	// mednafen uses some 20 coefs here, we just reuse gauss [0] and [128]\r
	88	for (i = 0; i < 2; i++)\r
	89	{\r
	90	const int *s;\r
	91	s = &sb->SB_rvb[i][spos];\r
	92	out0[i] = (s[0] * 0x12c7 + s[1] * 0x59b3 + s[2] * 0x1307) >> 15;\r
	93	out1[i] = (s[0] * 0x019c + s[1] * 0x3def + s[2] * 0x3e4c + s[3] * 0x01a8) >> 15;\r
	94	}\r
	95	}\r
	96	\r
	97	static void MixREVERB(int SSumLR, int RVB, int ns_to, int curr_addr,\r
	98	int do_filter)\r
	99	{\r
	100	unsigned short *spuMem = spu.spuMem;\r
	101	const REVERBInfo *rvb = spu.rvb;\r
	102	sample_buf *sb = &spu.sb[MAXCHAN];\r
	103	int space = 0x40000 - rvb->StartAddr;\r
	104	int mlsame_m2o = rvb->mLSAME + space - 1;\r
	105	int mrsame_m2o = rvb->mRSAME + space - 1;\r
	106	int mldiff_m2o = rvb->mLDIFF + space - 1;\r
	107	int mrdiff_m2o = rvb->mRDIFF + space - 1;\r
	108	int vCOMB1 = rvb->vCOMB1 >> 1, vCOMB2 = rvb->vCOMB2 >> 1;\r
	109	int vCOMB3 = rvb->vCOMB3 >> 1, vCOMB4 = rvb->vCOMB4 >> 1;\r
	110	int vAPF1 = rvb->vAPF1 >> 1, vAPF2 = rvb->vAPF2 >> 1;\r
	111	int vLIN = rvb->vLIN >> 1, vRIN = rvb->vRIN >> 1;\r
	112	int vWALL = rvb->vWALL >> 1;\r
	113	int vIIR = rvb->vIIR;\r
	114	int ns;\r
	115	\r
	116	#if P_HAVE_PTHREAD \|\| defined(WANT_THREAD_CODE)\r
	117	sb = &spu.sb_thread[MAXCHAN];\r
	118	#endif\r
	119	if (mlsame_m2o >= space) mlsame_m2o -= space;\r
	120	if (mrsame_m2o >= space) mrsame_m2o -= space;\r
	121	if (mldiff_m2o >= space) mldiff_m2o -= space;\r
	122	if (mrdiff_m2o >= space) mrdiff_m2o -= space;\r
	123	\r
	124	for (ns = 0; ns < ns_to * 2; )\r
	125	{\r
	126	int Lin = RVB[ns];\r
	127	int Rin = RVB[ns+1];\r
	128	int mlsame_m2 = g_buffer(mlsame_m2o) << (15-1);\r
	129	int mrsame_m2 = g_buffer(mrsame_m2o) << (15-1);\r
	130	int mldiff_m2 = g_buffer(mldiff_m2o) << (15-1);\r
	131	int mrdiff_m2 = g_buffer(mrdiff_m2o) << (15-1);\r
	132	int Lout, Rout, out0[2], out1[2];\r
	133	\r
	134	ssat32_to_16(Lin); Lin *= vLIN;\r
	135	ssat32_to_16(Rin); Rin *= vRIN;\r
	136	\r
	137	// from nocash psx-spx\r
	138	mlsame_m2 += ((Lin + g_buffer(rvb->dLSAME) * vWALL - mlsame_m2) >> 15) * vIIR;\r
	139	mrsame_m2 += ((Rin + g_buffer(rvb->dRSAME) * vWALL - mrsame_m2) >> 15) * vIIR;\r
	140	mldiff_m2 += ((Lin + g_buffer(rvb->dLDIFF) * vWALL - mldiff_m2) >> 15) * vIIR;\r
	141	mrdiff_m2 += ((Rin + g_buffer(rvb->dRDIFF) * vWALL - mrdiff_m2) >> 15) * vIIR;\r
	142	mlsame_m2 >>= (15-1); s_buffer_w(rvb->mLSAME, mlsame_m2);\r
	143	mrsame_m2 >>= (15-1); s_buffer_w(rvb->mRSAME, mrsame_m2);\r
	144	mldiff_m2 >>= (15-1); s_buffer_w(rvb->mLDIFF, mldiff_m2);\r
	145	mrdiff_m2 >>= (15-1); s_buffer_w(rvb->mRDIFF, mrdiff_m2);\r
	146	\r
	147	Lout = vCOMB1 * g_buffer(rvb->mLCOMB1) + vCOMB2 * g_buffer(rvb->mLCOMB2)\r
	148	+ vCOMB3 * g_buffer(rvb->mLCOMB3) + vCOMB4 * g_buffer(rvb->mLCOMB4);\r
	149	Rout = vCOMB1 * g_buffer(rvb->mRCOMB1) + vCOMB2 * g_buffer(rvb->mRCOMB2)\r
	150	+ vCOMB3 * g_buffer(rvb->mRCOMB3) + vCOMB4 * g_buffer(rvb->mRCOMB4);\r
	151	\r
	152	preload(SSumLR + ns + 64*2/4 - 4);\r
	153	\r
	154	Lout -= vAPF1 * g_buffer(rvb->mLAPF1_dAPF1); Lout >>= (15-1);\r
	155	Rout -= vAPF1 * g_buffer(rvb->mRAPF1_dAPF1); Rout >>= (15-1);\r
	156	s_buffer_w(rvb->mLAPF1, Lout);\r
	157	s_buffer_w(rvb->mRAPF1, Rout);\r
	158	Lout = Lout * vAPF1 + (g_buffer(rvb->mLAPF1_dAPF1) << (15-1));\r
	159	Rout = Rout * vAPF1 + (g_buffer(rvb->mRAPF1_dAPF1) << (15-1));\r
	160	\r
	161	preload(RVB + ns + 64*2/4 - 4);\r
	162	\r
	163	Lout -= vAPF2 * g_buffer(rvb->mLAPF2_dAPF2); Lout >>= (15-1);\r
	164	Rout -= vAPF2 * g_buffer(rvb->mRAPF2_dAPF2); Rout >>= (15-1);\r
	165	s_buffer_w(rvb->mLAPF2, Lout);\r
	166	s_buffer_w(rvb->mRAPF2, Rout);\r
	167	Lout = Lout * vAPF2 + (g_buffer(rvb->mLAPF2_dAPF2) << (15-1));\r
	168	Rout = Rout * vAPF2 + (g_buffer(rvb->mRAPF2_dAPF2) << (15-1));\r
	169	\r
	170	out0[0] = out1[0] = (Lout >> (15-1)) * rvb->VolLeft >> 15;\r
	171	out0[1] = out1[1] = (Rout >> (15-1)) * rvb->VolRight >> 15;\r
	172	if (do_filter)\r
	173	reverb_interpolate(sb, curr_addr, out0, out1);\r
	174	\r
	175	SSumLR[ns++] += out0[0];\r
	176	SSumLR[ns++] += out0[1];\r
	177	SSumLR[ns++] += out1[0];\r
	178	SSumLR[ns++] += out1[1];\r
	179	\r
	180	curr_addr++;\r
	181	curr_addr = rvb_wrap(curr_addr, space);\r
	182	}\r
	183	}\r
	184	\r
	185	static void MixREVERB_off(int *SSumLR, int ns_to, int curr_addr)\r
	186	{\r
	187	const REVERBInfo *rvb = spu.rvb;\r
	188	unsigned short *spuMem = spu.spuMem;\r
	189	int space = 0x40000 - rvb->StartAddr;\r
	190	int Lout, Rout, ns;\r
	191	\r
	192	for (ns = 0; ns < ns_to * 2; )\r
	193	{\r
	194	preload(SSumLR + ns + 64*2/4 - 4);\r
	195	\r
	196	// todo: is this missing COMB and APF1?\r
	197	Lout = g_buffer(rvb->mLAPF2_dAPF2);\r
	198	Rout = g_buffer(rvb->mLAPF2_dAPF2);\r
	199	\r
	200	Lout = (Lout * rvb->VolLeft) >> 15;\r
	201	Rout = (Rout * rvb->VolRight) >> 15;\r
	202	\r
	203	SSumLR[ns++] += Lout;\r
	204	SSumLR[ns++] += Rout;\r
	205	SSumLR[ns++] += Lout;\r
	206	SSumLR[ns++] += Rout;\r
	207	\r
	208	curr_addr++;\r
	209	if (curr_addr >= 0x40000) curr_addr = rvb->StartAddr;\r
	210	}\r
	211	}\r
	212	\r
	213	static void REVERBPrep(void)\r
	214	{\r
	215	REVERBInfo *rvb = spu.rvb;\r
	216	int space, t;\r
	217	\r
	218	t = regAreaGet(H_SPUReverbAddr);\r
	219	if (t == 0xFFFF \|\| t <= 0x200)\r
	220	spu.rvb->StartAddr = spu.rvb->CurrAddr = 0;\r
	221	else if (spu.rvb->StartAddr != (t << 2))\r
	222	spu.rvb->StartAddr = spu.rvb->CurrAddr = t << 2;\r
	223	\r
	224	space = 0x40000 - rvb->StartAddr;\r
	225	\r
	226	#define prep_offs(v, r) \\r
	227	t = spu.regArea[(0x1c0 + r) >> 1] * 4; \\r
	228	while (t >= space) \\r
	229	t -= space; \\r
	230	rvb->v = t\r
	231	#define prep_offs2(d, r1, r2) \\r
	232	t = spu.regArea[(0x1c0 + r1) >> 1] * 4; \\r
	233	t -= spu.regArea[(0x1c0 + r2) >> 1] * 4; \\r
	234	while (t < 0) \\r
	235	t += space; \\r
	236	while (t >= space) \\r
	237	t -= space; \\r
	238	rvb->d = t\r
	239	\r
	240	prep_offs(mLSAME, 0x14);\r
	241	prep_offs(mRSAME, 0x16);\r
	242	prep_offs(mLCOMB1, 0x18);\r
	243	prep_offs(mRCOMB1, 0x1a);\r
	244	prep_offs(mLCOMB2, 0x1c);\r
	245	prep_offs(mRCOMB2, 0x1e);\r
	246	prep_offs(dLSAME, 0x20);\r
	247	prep_offs(dRSAME, 0x22);\r
	248	prep_offs(mLDIFF, 0x24);\r
	249	prep_offs(mRDIFF, 0x26);\r
	250	prep_offs(mLCOMB3, 0x28);\r
	251	prep_offs(mRCOMB3, 0x2a);\r
	252	prep_offs(mLCOMB4, 0x2c);\r
	253	prep_offs(mRCOMB4, 0x2e);\r
	254	prep_offs(dLDIFF, 0x30);\r
	255	prep_offs(dRDIFF, 0x32);\r
	256	prep_offs(mLAPF1, 0x34);\r
	257	prep_offs(mRAPF1, 0x36);\r
	258	prep_offs(mLAPF2, 0x38);\r
	259	prep_offs(mRAPF2, 0x3a);\r
	260	prep_offs2(mLAPF1_dAPF1, 0x34, 0);\r
	261	prep_offs2(mRAPF1_dAPF1, 0x36, 0);\r
	262	prep_offs2(mLAPF2_dAPF2, 0x38, 2);\r
	263	prep_offs2(mRAPF2_dAPF2, 0x3a, 2);\r
	264	\r
	265	#undef prep_offs\r
	266	#undef prep_offs2\r
	267	rvb->dirty = 0;\r
	268	}\r
	269	\r
	270	INLINE void REVERBDo(int SSumLR, int RVB, int ns_to, int curr_addr)\r
	271	{\r
	272	if (spu.spuCtrl & 0x80) // -> reverb on? oki\r
	273	{\r
	274	MixREVERB(SSumLR, RVB, ns_to, curr_addr, 0); //spu.interpolation > 1);\r
	275	}\r
	276	else if (spu.rvb->VolLeft \|\| spu.rvb->VolRight)\r
	277	{\r
	278	MixREVERB_off(SSumLR, ns_to, curr_addr);\r
	279	}\r
	280	}\r
	281	\r
	282	////////////////////////////////////////////////////////////////////////\r
	283	\r
	284	#endif\r
	285	\r
	286	// vim:shiftwidth=1:expandtab\r