1 /***************************************************************************
\r
2 reverb.c - description
\r
4 begin : Wed May 15 2002
\r
5 copyright : (C) 2002 by Pete Bernert
\r
6 email : BlackDove@addcom.de
\r
8 Portions (C) GraÅžvydas "notaz" Ignotas, 2010-2011
\r
9 Portions (C) SPU2-X, gigaherz, Pcsx2 Development Team
\r
11 ***************************************************************************/
\r
12 /***************************************************************************
\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
20 ***************************************************************************/
\r
26 // will be included from spu.c
\r
29 ////////////////////////////////////////////////////////////////////////
\r
31 ////////////////////////////////////////////////////////////////////////
\r
33 INLINE void StartREVERB(int ch)
\r
35 if(s_chan[ch].bReverb && (spu.spuCtrl&0x80)) // reverb possible?
\r
37 s_chan[ch].bRVBActive=!!spu_config.iUseReverb;
\r
39 else s_chan[ch].bRVBActive=0; // else -> no reverb
\r
42 ////////////////////////////////////////////////////////////////////////
\r
43 // HELPER FOR NEILL'S REVERB: re-inits our reverb mixing buf
\r
44 ////////////////////////////////////////////////////////////////////////
\r
46 INLINE void InitREVERB(int ns_to)
\r
48 memset(spu.sRVBStart,0,ns_to*sizeof(spu.sRVBStart[0])*2);
\r
51 ////////////////////////////////////////////////////////////////////////
\r
53 INLINE int rvb2ram_offs(int curr, int space, int iOff)
\r
56 if (iOff >= 0x40000) iOff -= space;
\r
60 // get_buffer content helper: takes care about wraps
\r
61 #define g_buffer(var) \
\r
62 ((int)(signed short)spu.spuMem[rvb2ram_offs(curr_addr, space, rvb.n##var)])
\r
64 // saturate iVal and store it as var
\r
65 #define s_buffer(var, iVal) \
\r
66 ssat32_to_16(iVal); \
\r
67 spu.spuMem[rvb2ram_offs(curr_addr, space, rvb.n##var)] = iVal
\r
69 #define s_buffer1(var, iVal) \
\r
70 ssat32_to_16(iVal); \
\r
71 spu.spuMem[rvb2ram_offs(curr_addr, space, rvb.n##var + 1)] = iVal
\r
73 ////////////////////////////////////////////////////////////////////////
\r
75 // portions based on spu2-x from PCSX2
\r
76 static void MixREVERB(int ns_to)
\r
78 int l_old = rvb.iRVBLeft;
\r
79 int r_old = rvb.iRVBRight;
\r
80 int curr_addr = rvb.CurrAddr;
\r
81 int space = 0x40000 - rvb.StartAddr;
\r
82 int l = 0, r = 0, ns;
\r
84 for (ns = 0; ns < ns_to * 2; )
\r
86 int IIR_ALPHA = rvb.IIR_ALPHA;
\r
87 int ACC0, ACC1, FB_A0, FB_A1, FB_B0, FB_B1;
\r
88 int mix_dest_a0, mix_dest_a1, mix_dest_b0, mix_dest_b1;
\r
90 int input_L = spu.sRVBStart[ns] * rvb.IN_COEF_L;
\r
91 int input_R = spu.sRVBStart[ns+1] * rvb.IN_COEF_R;
\r
93 int IIR_INPUT_A0 = ((g_buffer(IIR_SRC_A0) * rvb.IIR_COEF) + input_L) >> 15;
\r
94 int IIR_INPUT_A1 = ((g_buffer(IIR_SRC_A1) * rvb.IIR_COEF) + input_R) >> 15;
\r
95 int IIR_INPUT_B0 = ((g_buffer(IIR_SRC_B0) * rvb.IIR_COEF) + input_L) >> 15;
\r
96 int IIR_INPUT_B1 = ((g_buffer(IIR_SRC_B1) * rvb.IIR_COEF) + input_R) >> 15;
\r
98 int iir_dest_a0 = g_buffer(IIR_DEST_A0);
\r
99 int iir_dest_a1 = g_buffer(IIR_DEST_A1);
\r
100 int iir_dest_b0 = g_buffer(IIR_DEST_B0);
\r
101 int iir_dest_b1 = g_buffer(IIR_DEST_B1);
\r
103 int IIR_A0 = iir_dest_a0 + ((IIR_INPUT_A0 - iir_dest_a0) * IIR_ALPHA >> 15);
\r
104 int IIR_A1 = iir_dest_a1 + ((IIR_INPUT_A1 - iir_dest_a1) * IIR_ALPHA >> 15);
\r
105 int IIR_B0 = iir_dest_b0 + ((IIR_INPUT_B0 - iir_dest_b0) * IIR_ALPHA >> 15);
\r
106 int IIR_B1 = iir_dest_b1 + ((IIR_INPUT_B1 - iir_dest_b1) * IIR_ALPHA >> 15);
\r
108 s_buffer1(IIR_DEST_A0, IIR_A0);
\r
109 s_buffer1(IIR_DEST_A1, IIR_A1);
\r
110 s_buffer1(IIR_DEST_B0, IIR_B0);
\r
111 s_buffer1(IIR_DEST_B1, IIR_B1);
\r
113 ACC0 = (g_buffer(ACC_SRC_A0) * rvb.ACC_COEF_A +
\r
114 g_buffer(ACC_SRC_B0) * rvb.ACC_COEF_B +
\r
115 g_buffer(ACC_SRC_C0) * rvb.ACC_COEF_C +
\r
116 g_buffer(ACC_SRC_D0) * rvb.ACC_COEF_D) >> 15;
\r
117 ACC1 = (g_buffer(ACC_SRC_A1) * rvb.ACC_COEF_A +
\r
118 g_buffer(ACC_SRC_B1) * rvb.ACC_COEF_B +
\r
119 g_buffer(ACC_SRC_C1) * rvb.ACC_COEF_C +
\r
120 g_buffer(ACC_SRC_D1) * rvb.ACC_COEF_D) >> 15;
\r
122 FB_A0 = g_buffer(FB_SRC_A0);
\r
123 FB_A1 = g_buffer(FB_SRC_A1);
\r
124 FB_B0 = g_buffer(FB_SRC_B0);
\r
125 FB_B1 = g_buffer(FB_SRC_B1);
\r
127 mix_dest_a0 = ACC0 - ((FB_A0 * rvb.FB_ALPHA) >> 15);
\r
128 mix_dest_a1 = ACC1 - ((FB_A1 * rvb.FB_ALPHA) >> 15);
\r
130 mix_dest_b0 = FB_A0 + (((ACC0 - FB_A0) * rvb.FB_ALPHA - FB_B0 * rvb.FB_X) >> 15);
\r
131 mix_dest_b1 = FB_A1 + (((ACC1 - FB_A1) * rvb.FB_ALPHA - FB_B1 * rvb.FB_X) >> 15);
\r
133 s_buffer(MIX_DEST_A0, mix_dest_a0);
\r
134 s_buffer(MIX_DEST_A1, mix_dest_a1);
\r
135 s_buffer(MIX_DEST_B0, mix_dest_b0);
\r
136 s_buffer(MIX_DEST_B1, mix_dest_b1);
\r
138 l = (mix_dest_a0 + mix_dest_b0) / 2;
\r
139 r = (mix_dest_a1 + mix_dest_b1) / 2;
\r
141 l = (l * rvb.VolLeft) >> 15; // 15?
\r
142 r = (r * rvb.VolRight) >> 15;
\r
144 SSumLR[ns++] += (l + l_old) / 2;
\r
145 SSumLR[ns++] += (r + r_old) / 2;
\r
153 if (curr_addr >= 0x40000) curr_addr = rvb.StartAddr;
\r
158 rvb.CurrAddr = curr_addr;
\r
161 static void MixREVERB_off(int ns_to)
\r
163 int l_old = rvb.iRVBLeft;
\r
164 int r_old = rvb.iRVBRight;
\r
165 int curr_addr = rvb.CurrAddr;
\r
166 int space = 0x40000 - rvb.StartAddr;
\r
167 int l = 0, r = 0, ns;
\r
169 for (ns = 0; ns < ns_to * 2; )
\r
171 l = (g_buffer(MIX_DEST_A0) + g_buffer(MIX_DEST_B0)) / 2;
\r
172 r = (g_buffer(MIX_DEST_A1) + g_buffer(MIX_DEST_B1)) / 2;
\r
174 l = (l * rvb.VolLeft) >> 15;
\r
175 r = (r * rvb.VolRight) >> 15;
\r
177 SSumLR[ns++] += (l + l_old) / 2;
\r
178 SSumLR[ns++] += (r + r_old) / 2;
\r
186 if (curr_addr >= 0x40000) curr_addr = rvb.StartAddr;
\r
191 rvb.CurrAddr = curr_addr;
\r
194 static void prepare_offsets(void)
\r
196 int space = 0x40000 - rvb.StartAddr;
\r
198 #define prep_offs(v) \
\r
200 while (t >= space) \
\r
203 #define prep_offs2(d, v1, v2) \
\r
204 t = rvb.v1 - rvb.v2; \
\r
205 while (t >= space) \
\r
209 prep_offs(IIR_SRC_A0);
\r
210 prep_offs(IIR_SRC_A1);
\r
211 prep_offs(IIR_SRC_B0);
\r
212 prep_offs(IIR_SRC_B1);
\r
213 prep_offs(IIR_DEST_A0);
\r
214 prep_offs(IIR_DEST_A1);
\r
215 prep_offs(IIR_DEST_B0);
\r
216 prep_offs(IIR_DEST_B1);
\r
217 prep_offs(ACC_SRC_A0);
\r
218 prep_offs(ACC_SRC_A1);
\r
219 prep_offs(ACC_SRC_B0);
\r
220 prep_offs(ACC_SRC_B1);
\r
221 prep_offs(ACC_SRC_C0);
\r
222 prep_offs(ACC_SRC_C1);
\r
223 prep_offs(ACC_SRC_D0);
\r
224 prep_offs(ACC_SRC_D1);
\r
225 prep_offs(MIX_DEST_A0);
\r
226 prep_offs(MIX_DEST_A1);
\r
227 prep_offs(MIX_DEST_B0);
\r
228 prep_offs(MIX_DEST_B1);
\r
229 prep_offs2(FB_SRC_A0, MIX_DEST_A0, FB_SRC_A);
\r
230 prep_offs2(FB_SRC_A1, MIX_DEST_A1, FB_SRC_A);
\r
231 prep_offs2(FB_SRC_B0, MIX_DEST_B0, FB_SRC_B);
\r
232 prep_offs2(FB_SRC_B1, MIX_DEST_B1, FB_SRC_B);
\r
239 INLINE void REVERBDo(int ns_to)
\r
241 if (!rvb.StartAddr) // reverb is off
\r
243 rvb.iRVBLeft = rvb.iRVBRight = 0;
\r
247 if (spu.spuCtrl & 0x80) // -> reverb on? oki
\r
249 if (unlikely(rvb.dirty))
\r
254 else if (rvb.VolLeft || rvb.VolRight)
\r
256 if (unlikely(rvb.dirty))
\r
259 MixREVERB_off(ns_to);
\r
261 else // -> reverb off
\r
263 // reverb runs anyway
\r
264 rvb.CurrAddr += ns_to / 2;
\r
265 while (rvb.CurrAddr >= 0x40000)
\r
266 rvb.CurrAddr -= 0x40000 - rvb.StartAddr;
\r
270 ////////////////////////////////////////////////////////////////////////
\r
275 -----------------------------------------------------------------------------
\r
276 PSX reverb hardware notes
\r
278 -----------------------------------------------------------------------------
\r
280 Yadda yadda disclaimer yadda probably not perfect yadda well it's okay anyway
\r
283 -----------------------------------------------------------------------------
\r
288 - The reverb buffer is 22khz 16-bit mono PCM.
\r
289 - It starts at the reverb address given by 1DA2, extends to
\r
290 the end of sound RAM, and wraps back to the 1DA2 address.
\r
292 Setting the address at 1DA2 resets the current reverb work address.
\r
294 This work address ALWAYS increments every 1/22050 sec., regardless of
\r
295 whether reverb is enabled (bit 7 of 1DAA set).
\r
297 And the contents of the reverb buffer ALWAYS play, scaled by the
\r
298 "reverberation depth left/right" volumes (1D84/1D86).
\r
299 (which, by the way, appear to be scaled so 3FFF=approx. 1.0, 4000=-1.0)
\r
301 -----------------------------------------------------------------------------
\r
306 These are probably not their real names.
\r
307 These are probably not even correct names.
\r
308 We will use them anyway, because we can.
\r
310 1DC0: FB_SRC_A (offset)
\r
311 1DC2: FB_SRC_B (offset)
\r
312 1DC4: IIR_ALPHA (coef.)
\r
313 1DC6: ACC_COEF_A (coef.)
\r
314 1DC8: ACC_COEF_B (coef.)
\r
315 1DCA: ACC_COEF_C (coef.)
\r
316 1DCC: ACC_COEF_D (coef.)
\r
317 1DCE: IIR_COEF (coef.)
\r
318 1DD0: FB_ALPHA (coef.)
\r
320 1DD4: IIR_DEST_A0 (offset)
\r
321 1DD6: IIR_DEST_A1 (offset)
\r
322 1DD8: ACC_SRC_A0 (offset)
\r
323 1DDA: ACC_SRC_A1 (offset)
\r
324 1DDC: ACC_SRC_B0 (offset)
\r
325 1DDE: ACC_SRC_B1 (offset)
\r
326 1DE0: IIR_SRC_A0 (offset)
\r
327 1DE2: IIR_SRC_A1 (offset)
\r
328 1DE4: IIR_DEST_B0 (offset)
\r
329 1DE6: IIR_DEST_B1 (offset)
\r
330 1DE8: ACC_SRC_C0 (offset)
\r
331 1DEA: ACC_SRC_C1 (offset)
\r
332 1DEC: ACC_SRC_D0 (offset)
\r
333 1DEE: ACC_SRC_D1 (offset)
\r
334 1DF0: IIR_SRC_B1 (offset)
\r
335 1DF2: IIR_SRC_B0 (offset)
\r
336 1DF4: MIX_DEST_A0 (offset)
\r
337 1DF6: MIX_DEST_A1 (offset)
\r
338 1DF8: MIX_DEST_B0 (offset)
\r
339 1DFA: MIX_DEST_B1 (offset)
\r
340 1DFC: IN_COEF_L (coef.)
\r
341 1DFE: IN_COEF_R (coef.)
\r
343 The coefficients are signed fractional values.
\r
344 -32768 would be -1.0
\r
345 32768 would be 1.0 (if it were possible... the highest is of course 32767)
\r
347 The offsets are (byte/8) offsets into the reverb buffer.
\r
348 i.e. you multiply them by 8, you get byte offsets.
\r
349 You can also think of them as (samples/4) offsets.
\r
350 They appear to be signed. They can be negative.
\r
351 None of the documented presets make them negative, though.
\r
353 Yes, 1DF0 and 1DF2 appear to be backwards. Not a typo.
\r
355 -----------------------------------------------------------------------------
\r
360 We take all reverb sources:
\r
361 - regular channels that have the reverb bit on
\r
362 - cd and external sources, if their reverb bits are on
\r
363 and mix them into one stereo 44100hz signal.
\r
365 Lowpass/downsample that to 22050hz. The PSX uses a proper bandlimiting
\r
366 algorithm here, but I haven't figured out the hysterically exact specifics.
\r
367 I use an 8-tap filter with these coefficients, which are nice but probably
\r
379 So we have two input samples (INPUT_SAMPLE_L, INPUT_SAMPLE_R) every 22050hz.
\r
381 * IN MY EMULATION, I divide these by 2 to make it clip less.
\r
382 (and of course the L/R output coefficients are adjusted to compensate)
\r
383 The real thing appears to not do this.
\r
385 At every 22050hz tick:
\r
386 - If the reverb bit is enabled (bit 7 of 1DAA), execute the reverb
\r
387 steady-state algorithm described below
\r
388 - AFTERWARDS, retrieve the "wet out" L and R samples from the reverb buffer
\r
389 (This part may not be exactly right and I guessed at the coefs. TODO: check later.)
\r
390 L is: 0.333 * (buffer[MIX_DEST_A0] + buffer[MIX_DEST_B0])
\r
391 R is: 0.333 * (buffer[MIX_DEST_A1] + buffer[MIX_DEST_B1])
\r
392 - Advance the current buffer position by 1 sample
\r
394 The wet out L and R are then upsampled to 44100hz and played at the
\r
395 "reverberation depth left/right" (1D84/1D86) volume, independent of the main
\r
398 -----------------------------------------------------------------------------
\r
400 Reverb steady-state
\r
401 -------------------
\r
403 The reverb steady-state algorithm is fairly clever, and of course by
\r
404 "clever" I mean "batshit insane".
\r
406 buffer[x] is relative to the current buffer position, not the beginning of
\r
407 the buffer. Note that all buffer offsets must wrap around so they're
\r
408 contained within the reverb work area.
\r
410 Clipping is performed at the end... maybe also sooner, but definitely at
\r
413 IIR_INPUT_A0 = buffer[IIR_SRC_A0] * IIR_COEF + INPUT_SAMPLE_L * IN_COEF_L;
\r
414 IIR_INPUT_A1 = buffer[IIR_SRC_A1] * IIR_COEF + INPUT_SAMPLE_R * IN_COEF_R;
\r
415 IIR_INPUT_B0 = buffer[IIR_SRC_B0] * IIR_COEF + INPUT_SAMPLE_L * IN_COEF_L;
\r
416 IIR_INPUT_B1 = buffer[IIR_SRC_B1] * IIR_COEF + INPUT_SAMPLE_R * IN_COEF_R;
\r
418 IIR_A0 = IIR_INPUT_A0 * IIR_ALPHA + buffer[IIR_DEST_A0] * (1.0 - IIR_ALPHA);
\r
419 IIR_A1 = IIR_INPUT_A1 * IIR_ALPHA + buffer[IIR_DEST_A1] * (1.0 - IIR_ALPHA);
\r
420 IIR_B0 = IIR_INPUT_B0 * IIR_ALPHA + buffer[IIR_DEST_B0] * (1.0 - IIR_ALPHA);
\r
421 IIR_B1 = IIR_INPUT_B1 * IIR_ALPHA + buffer[IIR_DEST_B1] * (1.0 - IIR_ALPHA);
\r
423 buffer[IIR_DEST_A0 + 1sample] = IIR_A0;
\r
424 buffer[IIR_DEST_A1 + 1sample] = IIR_A1;
\r
425 buffer[IIR_DEST_B0 + 1sample] = IIR_B0;
\r
426 buffer[IIR_DEST_B1 + 1sample] = IIR_B1;
\r
428 ACC0 = buffer[ACC_SRC_A0] * ACC_COEF_A +
\r
429 buffer[ACC_SRC_B0] * ACC_COEF_B +
\r
430 buffer[ACC_SRC_C0] * ACC_COEF_C +
\r
431 buffer[ACC_SRC_D0] * ACC_COEF_D;
\r
432 ACC1 = buffer[ACC_SRC_A1] * ACC_COEF_A +
\r
433 buffer[ACC_SRC_B1] * ACC_COEF_B +
\r
434 buffer[ACC_SRC_C1] * ACC_COEF_C +
\r
435 buffer[ACC_SRC_D1] * ACC_COEF_D;
\r
437 FB_A0 = buffer[MIX_DEST_A0 - FB_SRC_A];
\r
438 FB_A1 = buffer[MIX_DEST_A1 - FB_SRC_A];
\r
439 FB_B0 = buffer[MIX_DEST_B0 - FB_SRC_B];
\r
440 FB_B1 = buffer[MIX_DEST_B1 - FB_SRC_B];
\r
442 buffer[MIX_DEST_A0] = ACC0 - FB_A0 * FB_ALPHA;
\r
443 buffer[MIX_DEST_A1] = ACC1 - FB_A1 * FB_ALPHA;
\r
444 buffer[MIX_DEST_B0] = (FB_ALPHA * ACC0) - FB_A0 * (FB_ALPHA^0x8000) - FB_B0 * FB_X;
\r
445 buffer[MIX_DEST_B1] = (FB_ALPHA * ACC1) - FB_A1 * (FB_ALPHA^0x8000) - FB_B1 * FB_X;
\r
447 -----------------------------------------------------------------------------
\r
450 // vim:shiftwidth=1:expandtab
\r