[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
\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 rvb2ram_offs(int curr, int space, int iOff)\r
{\r
 iOff += curr;\r
 if (iOff >= 0x40000) iOff -= space;\r
 return iOff;\r
}\r
\r
// get_buffer content helper: takes care about wraps\r
#define g_buffer(var) \\r
 ((int)(signed short)spu.spuMem[rvb2ram_offs(curr_addr, space, rvb->n##var)])\r
\r
// saturate iVal and store it as var\r
#define s_buffer(var, iVal) \\r
 ssat32_to_16(iVal); \\r
 spu.spuMem[rvb2ram_offs(curr_addr, space, rvb->n##var)] = iVal\r
\r
#define s_buffer1(var, iVal) \\r
 ssat32_to_16(iVal); \\r
 spu.spuMem[rvb2ram_offs(curr_addr, space, rvb->n##var + 1)] = iVal\r
\r
////////////////////////////////////////////////////////////////////////\r
\r
// portions based on spu2-x from PCSX2\r
static void MixREVERB(int *SSumLR, int *RVB, int ns_to, int curr_addr)\r
{\r
 const REVERBInfo *rvb = spu.rvb;\r
 int IIR_ALPHA = rvb->IIR_ALPHA;\r
 int IIR_COEF = rvb->IIR_COEF;\r
 int space = 0x40000 - rvb->StartAddr;\r
 int l, r, ns;\r
\r
 for (ns = 0; ns < ns_to * 2; )\r
  {\r
   int ACC0, ACC1, FB_A0, FB_A1, FB_B0, FB_B1;\r
   int mix_dest_a0, mix_dest_a1, mix_dest_b0, mix_dest_b1;\r
\r
   int input_L = RVB[ns]   * rvb->IN_COEF_L;\r
   int input_R = RVB[ns+1] * rvb->IN_COEF_R;\r
\r
   int IIR_INPUT_A0 = ((g_buffer(IIR_SRC_A0) * IIR_COEF) + input_L) >> 15;\r
   int IIR_INPUT_A1 = ((g_buffer(IIR_SRC_A1) * IIR_COEF) + input_R) >> 15;\r
   int IIR_INPUT_B0 = ((g_buffer(IIR_SRC_B0) * IIR_COEF) + input_L) >> 15;\r
   int IIR_INPUT_B1 = ((g_buffer(IIR_SRC_B1) * IIR_COEF) + input_R) >> 15;\r
\r
   int iir_dest_a0 = g_buffer(IIR_DEST_A0);\r
   int iir_dest_a1 = g_buffer(IIR_DEST_A1);\r
   int iir_dest_b0 = g_buffer(IIR_DEST_B0);\r
   int iir_dest_b1 = g_buffer(IIR_DEST_B1);\r
\r
   int IIR_A0 = iir_dest_a0 + ((IIR_INPUT_A0 - iir_dest_a0) * IIR_ALPHA >> 15);\r
   int IIR_A1 = iir_dest_a1 + ((IIR_INPUT_A1 - iir_dest_a1) * IIR_ALPHA >> 15);\r
   int IIR_B0 = iir_dest_b0 + ((IIR_INPUT_B0 - iir_dest_b0) * IIR_ALPHA >> 15);\r
   int IIR_B1 = iir_dest_b1 + ((IIR_INPUT_B1 - iir_dest_b1) * IIR_ALPHA >> 15);\r
\r
   preload(SSumLR + ns + 64*2/4 - 4);\r
\r
   s_buffer1(IIR_DEST_A0, IIR_A0);\r
   s_buffer1(IIR_DEST_A1, IIR_A1);\r
   s_buffer1(IIR_DEST_B0, IIR_B0);\r
   s_buffer1(IIR_DEST_B1, IIR_B1);\r
\r
   preload(RVB + ns + 64*2/4 - 4);\r
\r
   ACC0 = (g_buffer(ACC_SRC_A0) * rvb->ACC_COEF_A +\r
           g_buffer(ACC_SRC_B0) * rvb->ACC_COEF_B +\r
           g_buffer(ACC_SRC_C0) * rvb->ACC_COEF_C +\r
           g_buffer(ACC_SRC_D0) * rvb->ACC_COEF_D) >> 15;\r
   ACC1 = (g_buffer(ACC_SRC_A1) * rvb->ACC_COEF_A +\r
           g_buffer(ACC_SRC_B1) * rvb->ACC_COEF_B +\r
           g_buffer(ACC_SRC_C1) * rvb->ACC_COEF_C +\r
           g_buffer(ACC_SRC_D1) * rvb->ACC_COEF_D) >> 15;\r
\r
   FB_A0 = g_buffer(FB_SRC_A0);\r
   FB_A1 = g_buffer(FB_SRC_A1);\r
   FB_B0 = g_buffer(FB_SRC_B0);\r
   FB_B1 = g_buffer(FB_SRC_B1);\r
\r
   mix_dest_a0 = ACC0 - ((FB_A0 * rvb->FB_ALPHA) >> 15);\r
   mix_dest_a1 = ACC1 - ((FB_A1 * rvb->FB_ALPHA) >> 15);\r
\r
   mix_dest_b0 = FB_A0 + (((ACC0 - FB_A0) * rvb->FB_ALPHA - FB_B0 * rvb->FB_X) >> 15);\r
   mix_dest_b1 = FB_A1 + (((ACC1 - FB_A1) * rvb->FB_ALPHA - FB_B1 * rvb->FB_X) >> 15);\r
\r
   s_buffer(MIX_DEST_A0, mix_dest_a0);\r
   s_buffer(MIX_DEST_A1, mix_dest_a1);\r
   s_buffer(MIX_DEST_B0, mix_dest_b0);\r
   s_buffer(MIX_DEST_B1, mix_dest_b1);\r
\r
   l = (mix_dest_a0 + mix_dest_b0) / 2;\r
   r = (mix_dest_a1 + mix_dest_b1) / 2;\r
\r
   l = (l * rvb->VolLeft)  >> 15; // 15?\r
   r = (r * rvb->VolRight) >> 15;\r
\r
   SSumLR[ns++] += l;\r
   SSumLR[ns++] += r;\r
   SSumLR[ns++] += l;\r
   SSumLR[ns++] += r;\r
\r
   curr_addr++;\r
   if (curr_addr >= 0x40000) curr_addr = rvb->StartAddr;\r
  }\r
}\r
\r
static void MixREVERB_off(int *SSumLR, int ns_to, int curr_addr)\r
{\r
 const REVERBInfo *rvb = spu.rvb;\r
 int space = 0x40000 - rvb->StartAddr;\r
 int l, r, ns;\r
\r
 for (ns = 0; ns < ns_to * 2; )\r
  {\r
   preload(SSumLR + ns + 64*2/4 - 4);\r
\r
   l = (g_buffer(MIX_DEST_A0) + g_buffer(MIX_DEST_B0)) / 2;\r
   r = (g_buffer(MIX_DEST_A1) + g_buffer(MIX_DEST_B1)) / 2;\r
\r
   l = (l * rvb->VolLeft)  >> 15;\r
   r = (r * rvb->VolRight) >> 15;\r
\r
   SSumLR[ns++] += l;\r
   SSumLR[ns++] += r;\r
   SSumLR[ns++] += l;\r
   SSumLR[ns++] += r;\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 = 0x40000 - rvb->StartAddr;\r
 int t;\r
 #define prep_offs(v) \\r
   t = rvb->v; \\r
   while (t >= space) \\r
     t -= space; \\r
   rvb->n##v = t\r
 #define prep_offs2(d, v1, v2) \\r
   t = rvb->v1 - rvb->v2; \\r
   while (t >= space) \\r
     t -= space; \\r
   rvb->n##d = t\r
\r
 prep_offs(IIR_SRC_A0);\r
 prep_offs(IIR_SRC_A1);\r
 prep_offs(IIR_SRC_B0);\r
 prep_offs(IIR_SRC_B1);\r
 prep_offs(IIR_DEST_A0);\r
 prep_offs(IIR_DEST_A1);\r
 prep_offs(IIR_DEST_B0);\r
 prep_offs(IIR_DEST_B1);\r
 prep_offs(ACC_SRC_A0);\r
 prep_offs(ACC_SRC_A1);\r
 prep_offs(ACC_SRC_B0);\r
 prep_offs(ACC_SRC_B1);\r
 prep_offs(ACC_SRC_C0);\r
 prep_offs(ACC_SRC_C1);\r
 prep_offs(ACC_SRC_D0);\r
 prep_offs(ACC_SRC_D1);\r
 prep_offs(MIX_DEST_A0);\r
 prep_offs(MIX_DEST_A1);\r
 prep_offs(MIX_DEST_B0);\r
 prep_offs(MIX_DEST_B1);\r
 prep_offs2(FB_SRC_A0, MIX_DEST_A0, FB_SRC_A);\r
 prep_offs2(FB_SRC_A1, MIX_DEST_A1, FB_SRC_A);\r
 prep_offs2(FB_SRC_B0, MIX_DEST_B0, FB_SRC_B);\r
 prep_offs2(FB_SRC_B1, MIX_DEST_B1, FB_SRC_B);\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);\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
/*\r
-----------------------------------------------------------------------------\r
PSX reverb hardware notes\r
by Neill Corlett\r
-----------------------------------------------------------------------------\r
\r
Yadda yadda disclaimer yadda probably not perfect yadda well it's okay anyway\r
yadda yadda.\r
\r
-----------------------------------------------------------------------------\r
\r
Basics\r
------\r
\r
- The reverb buffer is 22khz 16-bit mono PCM.\r
- It starts at the reverb address given by 1DA2, extends to\r
  the end of sound RAM, and wraps back to the 1DA2 address.\r
\r
Setting the address at 1DA2 resets the current reverb work address.\r
\r
This work address ALWAYS increments every 1/22050 sec., regardless of\r
whether reverb is enabled (bit 7 of 1DAA set).\r
\r
And the contents of the reverb buffer ALWAYS play, scaled by the\r
"reverberation depth left/right" volumes (1D84/1D86).\r
(which, by the way, appear to be scaled so 3FFF=approx. 1.0, 4000=-1.0)\r
\r
-----------------------------------------------------------------------------\r
\r
Register names\r
--------------\r
\r
These are probably not their real names.\r
These are probably not even correct names.\r
We will use them anyway, because we can.\r
\r
1DC0: FB_SRC_A       (offset)\r
1DC2: FB_SRC_B       (offset)\r
1DC4: IIR_ALPHA      (coef.)\r
1DC6: ACC_COEF_A     (coef.)\r
1DC8: ACC_COEF_B     (coef.)\r
1DCA: ACC_COEF_C     (coef.)\r
1DCC: ACC_COEF_D     (coef.)\r
1DCE: IIR_COEF       (coef.)\r
1DD0: FB_ALPHA       (coef.)\r
1DD2: FB_X           (coef.)\r
1DD4: IIR_DEST_A0    (offset)\r
1DD6: IIR_DEST_A1    (offset)\r
1DD8: ACC_SRC_A0     (offset)\r
1DDA: ACC_SRC_A1     (offset)\r
1DDC: ACC_SRC_B0     (offset)\r
1DDE: ACC_SRC_B1     (offset)\r
1DE0: IIR_SRC_A0     (offset)\r
1DE2: IIR_SRC_A1     (offset)\r
1DE4: IIR_DEST_B0    (offset)\r
1DE6: IIR_DEST_B1    (offset)\r
1DE8: ACC_SRC_C0     (offset)\r
1DEA: ACC_SRC_C1     (offset)\r
1DEC: ACC_SRC_D0     (offset)\r
1DEE: ACC_SRC_D1     (offset)\r
1DF0: IIR_SRC_B1     (offset)\r
1DF2: IIR_SRC_B0     (offset)\r
1DF4: MIX_DEST_A0    (offset)\r
1DF6: MIX_DEST_A1    (offset)\r
1DF8: MIX_DEST_B0    (offset)\r
1DFA: MIX_DEST_B1    (offset)\r
1DFC: IN_COEF_L      (coef.)\r
1DFE: IN_COEF_R      (coef.)\r
\r
The coefficients are signed fractional values.\r
-32768 would be -1.0\r
 32768 would be  1.0 (if it were possible... the highest is of course 32767)\r
\r
The offsets are (byte/8) offsets into the reverb buffer.\r
i.e. you multiply them by 8, you get byte offsets.\r
You can also think of them as (samples/4) offsets.\r
They appear to be signed.  They can be negative.\r
None of the documented presets make them negative, though.\r
\r
Yes, 1DF0 and 1DF2 appear to be backwards.  Not a typo.\r
\r
-----------------------------------------------------------------------------\r
\r
What it does\r
------------\r
\r
We take all reverb sources:\r
- regular channels that have the reverb bit on\r
- cd and external sources, if their reverb bits are on\r
and mix them into one stereo 44100hz signal.\r
\r
Lowpass/downsample that to 22050hz.  The PSX uses a proper bandlimiting\r
algorithm here, but I haven't figured out the hysterically exact specifics.\r
I use an 8-tap filter with these coefficients, which are nice but probably\r
not the real ones:\r
\r
0.037828187894\r
0.157538631280\r
0.321159685278\r
0.449322115345\r
0.449322115345\r
0.321159685278\r
0.157538631280\r
0.037828187894\r
\r
So we have two input samples (INPUT_SAMPLE_L, INPUT_SAMPLE_R) every 22050hz.\r
\r
* IN MY EMULATION, I divide these by 2 to make it clip less.\r
  (and of course the L/R output coefficients are adjusted to compensate)\r
  The real thing appears to not do this.\r
\r
At every 22050hz tick:\r
- If the reverb bit is enabled (bit 7 of 1DAA), execute the reverb\r
  steady-state algorithm described below\r
- AFTERWARDS, retrieve the "wet out" L and R samples from the reverb buffer\r
  (This part may not be exactly right and I guessed at the coefs. TODO: check later.)\r
  L is: 0.333 * (buffer[MIX_DEST_A0] + buffer[MIX_DEST_B0])\r
  R is: 0.333 * (buffer[MIX_DEST_A1] + buffer[MIX_DEST_B1])\r
- Advance the current buffer position by 1 sample\r
\r
The wet out L and R are then upsampled to 44100hz and played at the\r
"reverberation depth left/right" (1D84/1D86) volume, independent of the main\r
volume.\r
\r
-----------------------------------------------------------------------------\r
\r
Reverb steady-state\r
-------------------\r
\r
The reverb steady-state algorithm is fairly clever, and of course by\r
"clever" I mean "batshit insane".\r
\r
buffer[x] is relative to the current buffer position, not the beginning of\r
the buffer.  Note that all buffer offsets must wrap around so they're\r
contained within the reverb work area.\r
\r
Clipping is performed at the end... maybe also sooner, but definitely at\r
the end.\r
\r
IIR_INPUT_A0 = buffer[IIR_SRC_A0] * IIR_COEF + INPUT_SAMPLE_L * IN_COEF_L;\r
IIR_INPUT_A1 = buffer[IIR_SRC_A1] * IIR_COEF + INPUT_SAMPLE_R * IN_COEF_R;\r
IIR_INPUT_B0 = buffer[IIR_SRC_B0] * IIR_COEF + INPUT_SAMPLE_L * IN_COEF_L;\r
IIR_INPUT_B1 = buffer[IIR_SRC_B1] * IIR_COEF + INPUT_SAMPLE_R * IN_COEF_R;\r
\r
IIR_A0 = IIR_INPUT_A0 * IIR_ALPHA + buffer[IIR_DEST_A0] * (1.0 - IIR_ALPHA);\r
IIR_A1 = IIR_INPUT_A1 * IIR_ALPHA + buffer[IIR_DEST_A1] * (1.0 - IIR_ALPHA);\r
IIR_B0 = IIR_INPUT_B0 * IIR_ALPHA + buffer[IIR_DEST_B0] * (1.0 - IIR_ALPHA);\r
IIR_B1 = IIR_INPUT_B1 * IIR_ALPHA + buffer[IIR_DEST_B1] * (1.0 - IIR_ALPHA);\r
\r
buffer[IIR_DEST_A0 + 1sample] = IIR_A0;\r
buffer[IIR_DEST_A1 + 1sample] = IIR_A1;\r
buffer[IIR_DEST_B0 + 1sample] = IIR_B0;\r
buffer[IIR_DEST_B1 + 1sample] = IIR_B1;\r
\r
ACC0 = buffer[ACC_SRC_A0] * ACC_COEF_A +\r
       buffer[ACC_SRC_B0] * ACC_COEF_B +\r
       buffer[ACC_SRC_C0] * ACC_COEF_C +\r
       buffer[ACC_SRC_D0] * ACC_COEF_D;\r
ACC1 = buffer[ACC_SRC_A1] * ACC_COEF_A +\r
       buffer[ACC_SRC_B1] * ACC_COEF_B +\r
       buffer[ACC_SRC_C1] * ACC_COEF_C +\r
       buffer[ACC_SRC_D1] * ACC_COEF_D;\r
\r
FB_A0 = buffer[MIX_DEST_A0 - FB_SRC_A];\r
FB_A1 = buffer[MIX_DEST_A1 - FB_SRC_A];\r
FB_B0 = buffer[MIX_DEST_B0 - FB_SRC_B];\r
FB_B1 = buffer[MIX_DEST_B1 - FB_SRC_B];\r
\r
buffer[MIX_DEST_A0] = ACC0 - FB_A0 * FB_ALPHA;\r
buffer[MIX_DEST_A1] = ACC1 - FB_A1 * FB_ALPHA;\r
buffer[MIX_DEST_B0] = (FB_ALPHA * ACC0) - FB_A0 * (FB_ALPHA^0x8000) - FB_B0 * FB_X;\r
buffer[MIX_DEST_B1] = (FB_ALPHA * ACC1) - FB_A1 * (FB_ALPHA^0x8000) - FB_B1 * FB_X;\r
\r
-----------------------------------------------------------------------------\r
*/\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	\r
	24	#define _IN_REVERB\r
	25	\r
	26	// will be included from spu.c\r
	27	#ifdef _IN_SPU\r
	28	\r
	29	////////////////////////////////////////////////////////////////////////\r
	30	// START REVERB\r
	31	////////////////////////////////////////////////////////////////////////\r
	32	\r
	33	INLINE void StartREVERB(int ch)\r
	34	{\r
	35	if(spu.s_chan[ch].bReverb && (spu.spuCtrl&0x80)) // reverb possible?\r
	36	{\r
	37	spu.s_chan[ch].bRVBActive=!!spu_config.iUseReverb;\r
	38	}\r
	39	else spu.s_chan[ch].bRVBActive=0; // else -> no reverb\r
	40	}\r
	41	\r
	42	////////////////////////////////////////////////////////////////////////\r
	43	\r
	44	INLINE int rvb2ram_offs(int curr, int space, int iOff)\r
	45	{\r
	46	iOff += curr;\r
	47	if (iOff >= 0x40000) iOff -= space;\r
	48	return iOff;\r
	49	}\r
	50	\r
	51	// get_buffer content helper: takes care about wraps\r
	52	#define g_buffer(var) \\r
	53	((int)(signed short)spu.spuMem[rvb2ram_offs(curr_addr, space, rvb->n##var)])\r
	54	\r
	55	// saturate iVal and store it as var\r
	56	#define s_buffer(var, iVal) \\r
	57	ssat32_to_16(iVal); \\r
	58	spu.spuMem[rvb2ram_offs(curr_addr, space, rvb->n##var)] = iVal\r
	59	\r
	60	#define s_buffer1(var, iVal) \\r
	61	ssat32_to_16(iVal); \\r
	62	spu.spuMem[rvb2ram_offs(curr_addr, space, rvb->n##var + 1)] = iVal\r
	63	\r
	64	////////////////////////////////////////////////////////////////////////\r
	65	\r
	66	// portions based on spu2-x from PCSX2\r
	67	static void MixREVERB(int SSumLR, int RVB, int ns_to, int curr_addr)\r
	68	{\r
	69	const REVERBInfo *rvb = spu.rvb;\r
	70	int IIR_ALPHA = rvb->IIR_ALPHA;\r
	71	int IIR_COEF = rvb->IIR_COEF;\r
	72	int space = 0x40000 - rvb->StartAddr;\r
	73	int l, r, ns;\r
	74	\r
	75	for (ns = 0; ns < ns_to * 2; )\r
	76	{\r
	77	int ACC0, ACC1, FB_A0, FB_A1, FB_B0, FB_B1;\r
	78	int mix_dest_a0, mix_dest_a1, mix_dest_b0, mix_dest_b1;\r
	79	\r
	80	int input_L = RVB[ns] * rvb->IN_COEF_L;\r
	81	int input_R = RVB[ns+1] * rvb->IN_COEF_R;\r
	82	\r
	83	int IIR_INPUT_A0 = ((g_buffer(IIR_SRC_A0) * IIR_COEF) + input_L) >> 15;\r
	84	int IIR_INPUT_A1 = ((g_buffer(IIR_SRC_A1) * IIR_COEF) + input_R) >> 15;\r
	85	int IIR_INPUT_B0 = ((g_buffer(IIR_SRC_B0) * IIR_COEF) + input_L) >> 15;\r
	86	int IIR_INPUT_B1 = ((g_buffer(IIR_SRC_B1) * IIR_COEF) + input_R) >> 15;\r
	87	\r
	88	int iir_dest_a0 = g_buffer(IIR_DEST_A0);\r
	89	int iir_dest_a1 = g_buffer(IIR_DEST_A1);\r
	90	int iir_dest_b0 = g_buffer(IIR_DEST_B0);\r
	91	int iir_dest_b1 = g_buffer(IIR_DEST_B1);\r
	92	\r
	93	int IIR_A0 = iir_dest_a0 + ((IIR_INPUT_A0 - iir_dest_a0) * IIR_ALPHA >> 15);\r
	94	int IIR_A1 = iir_dest_a1 + ((IIR_INPUT_A1 - iir_dest_a1) * IIR_ALPHA >> 15);\r
	95	int IIR_B0 = iir_dest_b0 + ((IIR_INPUT_B0 - iir_dest_b0) * IIR_ALPHA >> 15);\r
	96	int IIR_B1 = iir_dest_b1 + ((IIR_INPUT_B1 - iir_dest_b1) * IIR_ALPHA >> 15);\r
	97	\r
	98	preload(SSumLR + ns + 64*2/4 - 4);\r
	99	\r
	100	s_buffer1(IIR_DEST_A0, IIR_A0);\r
	101	s_buffer1(IIR_DEST_A1, IIR_A1);\r
	102	s_buffer1(IIR_DEST_B0, IIR_B0);\r
	103	s_buffer1(IIR_DEST_B1, IIR_B1);\r
	104	\r
	105	preload(RVB + ns + 64*2/4 - 4);\r
	106	\r
	107	ACC0 = (g_buffer(ACC_SRC_A0) * rvb->ACC_COEF_A +\r
	108	g_buffer(ACC_SRC_B0) * rvb->ACC_COEF_B +\r
	109	g_buffer(ACC_SRC_C0) * rvb->ACC_COEF_C +\r
	110	g_buffer(ACC_SRC_D0) * rvb->ACC_COEF_D) >> 15;\r
	111	ACC1 = (g_buffer(ACC_SRC_A1) * rvb->ACC_COEF_A +\r
	112	g_buffer(ACC_SRC_B1) * rvb->ACC_COEF_B +\r
	113	g_buffer(ACC_SRC_C1) * rvb->ACC_COEF_C +\r
	114	g_buffer(ACC_SRC_D1) * rvb->ACC_COEF_D) >> 15;\r
	115	\r
	116	FB_A0 = g_buffer(FB_SRC_A0);\r
	117	FB_A1 = g_buffer(FB_SRC_A1);\r
	118	FB_B0 = g_buffer(FB_SRC_B0);\r
	119	FB_B1 = g_buffer(FB_SRC_B1);\r
	120	\r
	121	mix_dest_a0 = ACC0 - ((FB_A0 * rvb->FB_ALPHA) >> 15);\r
	122	mix_dest_a1 = ACC1 - ((FB_A1 * rvb->FB_ALPHA) >> 15);\r
	123	\r
	124	mix_dest_b0 = FB_A0 + (((ACC0 - FB_A0) * rvb->FB_ALPHA - FB_B0 * rvb->FB_X) >> 15);\r
	125	mix_dest_b1 = FB_A1 + (((ACC1 - FB_A1) * rvb->FB_ALPHA - FB_B1 * rvb->FB_X) >> 15);\r
	126	\r
	127	s_buffer(MIX_DEST_A0, mix_dest_a0);\r
	128	s_buffer(MIX_DEST_A1, mix_dest_a1);\r
	129	s_buffer(MIX_DEST_B0, mix_dest_b0);\r
	130	s_buffer(MIX_DEST_B1, mix_dest_b1);\r
	131	\r
	132	l = (mix_dest_a0 + mix_dest_b0) / 2;\r
	133	r = (mix_dest_a1 + mix_dest_b1) / 2;\r
	134	\r
	135	l = (l * rvb->VolLeft) >> 15; // 15?\r
	136	r = (r * rvb->VolRight) >> 15;\r
	137	\r
	138	SSumLR[ns++] += l;\r
	139	SSumLR[ns++] += r;\r
	140	SSumLR[ns++] += l;\r
	141	SSumLR[ns++] += r;\r
	142	\r
	143	curr_addr++;\r
	144	if (curr_addr >= 0x40000) curr_addr = rvb->StartAddr;\r
	145	}\r
	146	}\r
	147	\r
	148	static void MixREVERB_off(int *SSumLR, int ns_to, int curr_addr)\r
	149	{\r
	150	const REVERBInfo *rvb = spu.rvb;\r
	151	int space = 0x40000 - rvb->StartAddr;\r
	152	int l, r, ns;\r
	153	\r
	154	for (ns = 0; ns < ns_to * 2; )\r
	155	{\r
	156	preload(SSumLR + ns + 64*2/4 - 4);\r
	157	\r
	158	l = (g_buffer(MIX_DEST_A0) + g_buffer(MIX_DEST_B0)) / 2;\r
	159	r = (g_buffer(MIX_DEST_A1) + g_buffer(MIX_DEST_B1)) / 2;\r
	160	\r
	161	l = (l * rvb->VolLeft) >> 15;\r
	162	r = (r * rvb->VolRight) >> 15;\r
	163	\r
	164	SSumLR[ns++] += l;\r
	165	SSumLR[ns++] += r;\r
	166	SSumLR[ns++] += l;\r
	167	SSumLR[ns++] += r;\r
	168	\r
	169	curr_addr++;\r
	170	if (curr_addr >= 0x40000) curr_addr = rvb->StartAddr;\r
	171	}\r
	172	}\r
	173	\r
	174	static void REVERBPrep(void)\r
	175	{\r
	176	REVERBInfo *rvb = spu.rvb;\r
	177	int space = 0x40000 - rvb->StartAddr;\r
	178	int t;\r
	179	#define prep_offs(v) \\r
	180	t = rvb->v; \\r
	181	while (t >= space) \\r
	182	t -= space; \\r
	183	rvb->n##v = t\r
	184	#define prep_offs2(d, v1, v2) \\r
	185	t = rvb->v1 - rvb->v2; \\r
	186	while (t >= space) \\r
	187	t -= space; \\r
	188	rvb->n##d = t\r
	189	\r
	190	prep_offs(IIR_SRC_A0);\r
	191	prep_offs(IIR_SRC_A1);\r
	192	prep_offs(IIR_SRC_B0);\r
	193	prep_offs(IIR_SRC_B1);\r
	194	prep_offs(IIR_DEST_A0);\r
	195	prep_offs(IIR_DEST_A1);\r
	196	prep_offs(IIR_DEST_B0);\r
	197	prep_offs(IIR_DEST_B1);\r
	198	prep_offs(ACC_SRC_A0);\r
	199	prep_offs(ACC_SRC_A1);\r
	200	prep_offs(ACC_SRC_B0);\r
	201	prep_offs(ACC_SRC_B1);\r
	202	prep_offs(ACC_SRC_C0);\r
	203	prep_offs(ACC_SRC_C1);\r
	204	prep_offs(ACC_SRC_D0);\r
	205	prep_offs(ACC_SRC_D1);\r
	206	prep_offs(MIX_DEST_A0);\r
	207	prep_offs(MIX_DEST_A1);\r
	208	prep_offs(MIX_DEST_B0);\r
	209	prep_offs(MIX_DEST_B1);\r
	210	prep_offs2(FB_SRC_A0, MIX_DEST_A0, FB_SRC_A);\r
	211	prep_offs2(FB_SRC_A1, MIX_DEST_A1, FB_SRC_A);\r
	212	prep_offs2(FB_SRC_B0, MIX_DEST_B0, FB_SRC_B);\r
	213	prep_offs2(FB_SRC_B1, MIX_DEST_B1, FB_SRC_B);\r
	214	\r
	215	#undef prep_offs\r
	216	#undef prep_offs2\r
	217	rvb->dirty = 0;\r
	218	}\r
	219	\r
	220	INLINE void REVERBDo(int SSumLR, int RVB, int ns_to, int curr_addr)\r
	221	{\r
	222	if (spu.spuCtrl & 0x80) // -> reverb on? oki\r
	223	{\r
	224	MixREVERB(SSumLR, RVB, ns_to, curr_addr);\r
	225	}\r
	226	else if (spu.rvb->VolLeft \|\| spu.rvb->VolRight)\r
	227	{\r
	228	MixREVERB_off(SSumLR, ns_to, curr_addr);\r
	229	}\r
	230	}\r
	231	\r
	232	////////////////////////////////////////////////////////////////////////\r
	233	\r
	234	#endif\r
	235	\r
	236	/*\r
	237	-----------------------------------------------------------------------------\r
	238	PSX reverb hardware notes\r
	239	by Neill Corlett\r
	240	-----------------------------------------------------------------------------\r
	241	\r
	242	Yadda yadda disclaimer yadda probably not perfect yadda well it's okay anyway\r
	243	yadda yadda.\r
	244	\r
	245	-----------------------------------------------------------------------------\r
	246	\r
	247	Basics\r
	248	------\r
	249	\r
	250	- The reverb buffer is 22khz 16-bit mono PCM.\r
	251	- It starts at the reverb address given by 1DA2, extends to\r
	252	the end of sound RAM, and wraps back to the 1DA2 address.\r
	253	\r
	254	Setting the address at 1DA2 resets the current reverb work address.\r
	255	\r
	256	This work address ALWAYS increments every 1/22050 sec., regardless of\r
	257	whether reverb is enabled (bit 7 of 1DAA set).\r
	258	\r
	259	And the contents of the reverb buffer ALWAYS play, scaled by the\r
	260	"reverberation depth left/right" volumes (1D84/1D86).\r
	261	(which, by the way, appear to be scaled so 3FFF=approx. 1.0, 4000=-1.0)\r
	262	\r
	263	-----------------------------------------------------------------------------\r
	264	\r
	265	Register names\r
	266	--------------\r
	267	\r
	268	These are probably not their real names.\r
	269	These are probably not even correct names.\r
	270	We will use them anyway, because we can.\r
	271	\r
	272	1DC0: FB_SRC_A (offset)\r
	273	1DC2: FB_SRC_B (offset)\r
	274	1DC4: IIR_ALPHA (coef.)\r
	275	1DC6: ACC_COEF_A (coef.)\r
	276	1DC8: ACC_COEF_B (coef.)\r
	277	1DCA: ACC_COEF_C (coef.)\r
	278	1DCC: ACC_COEF_D (coef.)\r
	279	1DCE: IIR_COEF (coef.)\r
	280	1DD0: FB_ALPHA (coef.)\r
	281	1DD2: FB_X (coef.)\r
	282	1DD4: IIR_DEST_A0 (offset)\r
	283	1DD6: IIR_DEST_A1 (offset)\r
	284	1DD8: ACC_SRC_A0 (offset)\r
	285	1DDA: ACC_SRC_A1 (offset)\r
	286	1DDC: ACC_SRC_B0 (offset)\r
	287	1DDE: ACC_SRC_B1 (offset)\r
	288	1DE0: IIR_SRC_A0 (offset)\r
	289	1DE2: IIR_SRC_A1 (offset)\r
	290	1DE4: IIR_DEST_B0 (offset)\r
	291	1DE6: IIR_DEST_B1 (offset)\r
	292	1DE8: ACC_SRC_C0 (offset)\r
	293	1DEA: ACC_SRC_C1 (offset)\r
	294	1DEC: ACC_SRC_D0 (offset)\r
	295	1DEE: ACC_SRC_D1 (offset)\r
	296	1DF0: IIR_SRC_B1 (offset)\r
	297	1DF2: IIR_SRC_B0 (offset)\r
	298	1DF4: MIX_DEST_A0 (offset)\r
	299	1DF6: MIX_DEST_A1 (offset)\r
	300	1DF8: MIX_DEST_B0 (offset)\r
	301	1DFA: MIX_DEST_B1 (offset)\r
	302	1DFC: IN_COEF_L (coef.)\r
	303	1DFE: IN_COEF_R (coef.)\r
	304	\r
	305	The coefficients are signed fractional values.\r
	306	-32768 would be -1.0\r
	307	32768 would be 1.0 (if it were possible... the highest is of course 32767)\r
	308	\r
	309	The offsets are (byte/8) offsets into the reverb buffer.\r
	310	i.e. you multiply them by 8, you get byte offsets.\r
	311	You can also think of them as (samples/4) offsets.\r
	312	They appear to be signed. They can be negative.\r
	313	None of the documented presets make them negative, though.\r
	314	\r
	315	Yes, 1DF0 and 1DF2 appear to be backwards. Not a typo.\r
	316	\r
	317	-----------------------------------------------------------------------------\r
	318	\r
	319	What it does\r
	320	------------\r
	321	\r
	322	We take all reverb sources:\r
	323	- regular channels that have the reverb bit on\r
	324	- cd and external sources, if their reverb bits are on\r
	325	and mix them into one stereo 44100hz signal.\r
	326	\r
	327	Lowpass/downsample that to 22050hz. The PSX uses a proper bandlimiting\r
	328	algorithm here, but I haven't figured out the hysterically exact specifics.\r
	329	I use an 8-tap filter with these coefficients, which are nice but probably\r
	330	not the real ones:\r
	331	\r
	332	0.037828187894\r
	333	0.157538631280\r
	334	0.321159685278\r
	335	0.449322115345\r
	336	0.449322115345\r
	337	0.321159685278\r
	338	0.157538631280\r
	339	0.037828187894\r
	340	\r
	341	So we have two input samples (INPUT_SAMPLE_L, INPUT_SAMPLE_R) every 22050hz.\r
	342	\r
	343	* IN MY EMULATION, I divide these by 2 to make it clip less.\r
	344	(and of course the L/R output coefficients are adjusted to compensate)\r
	345	The real thing appears to not do this.\r
	346	\r
	347	At every 22050hz tick:\r
	348	- If the reverb bit is enabled (bit 7 of 1DAA), execute the reverb\r
	349	steady-state algorithm described below\r
	350	- AFTERWARDS, retrieve the "wet out" L and R samples from the reverb buffer\r
	351	(This part may not be exactly right and I guessed at the coefs. TODO: check later.)\r
	352	L is: 0.333 * (buffer[MIX_DEST_A0] + buffer[MIX_DEST_B0])\r
	353	R is: 0.333 * (buffer[MIX_DEST_A1] + buffer[MIX_DEST_B1])\r
	354	- Advance the current buffer position by 1 sample\r
	355	\r
	356	The wet out L and R are then upsampled to 44100hz and played at the\r
	357	"reverberation depth left/right" (1D84/1D86) volume, independent of the main\r
	358	volume.\r
	359	\r
	360	-----------------------------------------------------------------------------\r
	361	\r
	362	Reverb steady-state\r
	363	-------------------\r
	364	\r
	365	The reverb steady-state algorithm is fairly clever, and of course by\r
	366	"clever" I mean "batshit insane".\r
	367	\r
	368	buffer[x] is relative to the current buffer position, not the beginning of\r
	369	the buffer. Note that all buffer offsets must wrap around so they're\r
	370	contained within the reverb work area.\r
	371	\r
	372	Clipping is performed at the end... maybe also sooner, but definitely at\r
	373	the end.\r
	374	\r
	375	IIR_INPUT_A0 = buffer[IIR_SRC_A0] * IIR_COEF + INPUT_SAMPLE_L * IN_COEF_L;\r
	376	IIR_INPUT_A1 = buffer[IIR_SRC_A1] * IIR_COEF + INPUT_SAMPLE_R * IN_COEF_R;\r
	377	IIR_INPUT_B0 = buffer[IIR_SRC_B0] * IIR_COEF + INPUT_SAMPLE_L * IN_COEF_L;\r
	378	IIR_INPUT_B1 = buffer[IIR_SRC_B1] * IIR_COEF + INPUT_SAMPLE_R * IN_COEF_R;\r
	379	\r
	380	IIR_A0 = IIR_INPUT_A0 * IIR_ALPHA + buffer[IIR_DEST_A0] * (1.0 - IIR_ALPHA);\r
	381	IIR_A1 = IIR_INPUT_A1 * IIR_ALPHA + buffer[IIR_DEST_A1] * (1.0 - IIR_ALPHA);\r
	382	IIR_B0 = IIR_INPUT_B0 * IIR_ALPHA + buffer[IIR_DEST_B0] * (1.0 - IIR_ALPHA);\r
	383	IIR_B1 = IIR_INPUT_B1 * IIR_ALPHA + buffer[IIR_DEST_B1] * (1.0 - IIR_ALPHA);\r
	384	\r
	385	buffer[IIR_DEST_A0 + 1sample] = IIR_A0;\r
	386	buffer[IIR_DEST_A1 + 1sample] = IIR_A1;\r
	387	buffer[IIR_DEST_B0 + 1sample] = IIR_B0;\r
	388	buffer[IIR_DEST_B1 + 1sample] = IIR_B1;\r
	389	\r
	390	ACC0 = buffer[ACC_SRC_A0] * ACC_COEF_A +\r
	391	buffer[ACC_SRC_B0] * ACC_COEF_B +\r
	392	buffer[ACC_SRC_C0] * ACC_COEF_C +\r
	393	buffer[ACC_SRC_D0] * ACC_COEF_D;\r
	394	ACC1 = buffer[ACC_SRC_A1] * ACC_COEF_A +\r
	395	buffer[ACC_SRC_B1] * ACC_COEF_B +\r
	396	buffer[ACC_SRC_C1] * ACC_COEF_C +\r
	397	buffer[ACC_SRC_D1] * ACC_COEF_D;\r
	398	\r
	399	FB_A0 = buffer[MIX_DEST_A0 - FB_SRC_A];\r
	400	FB_A1 = buffer[MIX_DEST_A1 - FB_SRC_A];\r
	401	FB_B0 = buffer[MIX_DEST_B0 - FB_SRC_B];\r
	402	FB_B1 = buffer[MIX_DEST_B1 - FB_SRC_B];\r
	403	\r
	404	buffer[MIX_DEST_A0] = ACC0 - FB_A0 * FB_ALPHA;\r
	405	buffer[MIX_DEST_A1] = ACC1 - FB_A1 * FB_ALPHA;\r
	406	buffer[MIX_DEST_B0] = (FB_ALPHA * ACC0) - FB_A0 * (FB_ALPHA^0x8000) - FB_B0 * FB_X;\r
	407	buffer[MIX_DEST_B1] = (FB_ALPHA * ACC1) - FB_A1 * (FB_ALPHA^0x8000) - FB_B1 * FB_X;\r
	408	\r
	409	-----------------------------------------------------------------------------\r
	410	*/\r
	411	\r
	412	// vim:shiftwidth=1:expandtab\r