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(spu.s_chan[ch].bReverb && (spu.spuCtrl&0x80)) // reverb possible?
\r
37 spu.s_chan[ch].bRVBActive=!!spu_config.iUseReverb;
\r
39 else spu.s_chan[ch].bRVBActive=0; // else -> no reverb
\r
42 ////////////////////////////////////////////////////////////////////////
\r
44 INLINE int rvb2ram_offs(int curr, int space, int iOff)
\r
47 if (iOff >= 0x40000) iOff -= space;
\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
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
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
64 ////////////////////////////////////////////////////////////////////////
\r
66 // portions based on spu2-x from PCSX2
\r
67 static void MixREVERB(int *SSumLR, int *RVB, int ns_to)
\r
69 int l_old = rvb.iRVBLeft;
\r
70 int r_old = rvb.iRVBRight;
\r
71 int curr_addr = rvb.CurrAddr;
\r
72 int space = 0x40000 - rvb.StartAddr;
\r
73 int l = 0, r = 0, ns;
\r
75 for (ns = 0; ns < ns_to * 2; )
\r
77 int IIR_ALPHA = rvb.IIR_ALPHA;
\r
78 int ACC0, ACC1, FB_A0, FB_A1, FB_B0, FB_B1;
\r
79 int mix_dest_a0, mix_dest_a1, mix_dest_b0, mix_dest_b1;
\r
81 int input_L = RVB[ns] * rvb.IN_COEF_L;
\r
82 int input_R = RVB[ns+1] * rvb.IN_COEF_R;
\r
84 int IIR_INPUT_A0 = ((g_buffer(IIR_SRC_A0) * rvb.IIR_COEF) + input_L) >> 15;
\r
85 int IIR_INPUT_A1 = ((g_buffer(IIR_SRC_A1) * rvb.IIR_COEF) + input_R) >> 15;
\r
86 int IIR_INPUT_B0 = ((g_buffer(IIR_SRC_B0) * rvb.IIR_COEF) + input_L) >> 15;
\r
87 int IIR_INPUT_B1 = ((g_buffer(IIR_SRC_B1) * rvb.IIR_COEF) + input_R) >> 15;
\r
89 int iir_dest_a0 = g_buffer(IIR_DEST_A0);
\r
90 int iir_dest_a1 = g_buffer(IIR_DEST_A1);
\r
91 int iir_dest_b0 = g_buffer(IIR_DEST_B0);
\r
92 int iir_dest_b1 = g_buffer(IIR_DEST_B1);
\r
94 int IIR_A0 = iir_dest_a0 + ((IIR_INPUT_A0 - iir_dest_a0) * IIR_ALPHA >> 15);
\r
95 int IIR_A1 = iir_dest_a1 + ((IIR_INPUT_A1 - iir_dest_a1) * IIR_ALPHA >> 15);
\r
96 int IIR_B0 = iir_dest_b0 + ((IIR_INPUT_B0 - iir_dest_b0) * IIR_ALPHA >> 15);
\r
97 int IIR_B1 = iir_dest_b1 + ((IIR_INPUT_B1 - iir_dest_b1) * IIR_ALPHA >> 15);
\r
99 s_buffer1(IIR_DEST_A0, IIR_A0);
\r
100 s_buffer1(IIR_DEST_A1, IIR_A1);
\r
101 s_buffer1(IIR_DEST_B0, IIR_B0);
\r
102 s_buffer1(IIR_DEST_B1, IIR_B1);
\r
104 ACC0 = (g_buffer(ACC_SRC_A0) * rvb.ACC_COEF_A +
\r
105 g_buffer(ACC_SRC_B0) * rvb.ACC_COEF_B +
\r
106 g_buffer(ACC_SRC_C0) * rvb.ACC_COEF_C +
\r
107 g_buffer(ACC_SRC_D0) * rvb.ACC_COEF_D) >> 15;
\r
108 ACC1 = (g_buffer(ACC_SRC_A1) * rvb.ACC_COEF_A +
\r
109 g_buffer(ACC_SRC_B1) * rvb.ACC_COEF_B +
\r
110 g_buffer(ACC_SRC_C1) * rvb.ACC_COEF_C +
\r
111 g_buffer(ACC_SRC_D1) * rvb.ACC_COEF_D) >> 15;
\r
113 FB_A0 = g_buffer(FB_SRC_A0);
\r
114 FB_A1 = g_buffer(FB_SRC_A1);
\r
115 FB_B0 = g_buffer(FB_SRC_B0);
\r
116 FB_B1 = g_buffer(FB_SRC_B1);
\r
118 mix_dest_a0 = ACC0 - ((FB_A0 * rvb.FB_ALPHA) >> 15);
\r
119 mix_dest_a1 = ACC1 - ((FB_A1 * rvb.FB_ALPHA) >> 15);
\r
121 mix_dest_b0 = FB_A0 + (((ACC0 - FB_A0) * rvb.FB_ALPHA - FB_B0 * rvb.FB_X) >> 15);
\r
122 mix_dest_b1 = FB_A1 + (((ACC1 - FB_A1) * rvb.FB_ALPHA - FB_B1 * rvb.FB_X) >> 15);
\r
124 s_buffer(MIX_DEST_A0, mix_dest_a0);
\r
125 s_buffer(MIX_DEST_A1, mix_dest_a1);
\r
126 s_buffer(MIX_DEST_B0, mix_dest_b0);
\r
127 s_buffer(MIX_DEST_B1, mix_dest_b1);
\r
129 l = (mix_dest_a0 + mix_dest_b0) / 2;
\r
130 r = (mix_dest_a1 + mix_dest_b1) / 2;
\r
132 l = (l * rvb.VolLeft) >> 15; // 15?
\r
133 r = (r * rvb.VolRight) >> 15;
\r
135 SSumLR[ns++] += (l + l_old) / 2;
\r
136 SSumLR[ns++] += (r + r_old) / 2;
\r
144 if (curr_addr >= 0x40000) curr_addr = rvb.StartAddr;
\r
149 rvb.CurrAddr = curr_addr;
\r
152 static void MixREVERB_off(int *SSumLR, int ns_to)
\r
154 int l_old = rvb.iRVBLeft;
\r
155 int r_old = rvb.iRVBRight;
\r
156 int curr_addr = rvb.CurrAddr;
\r
157 int space = 0x40000 - rvb.StartAddr;
\r
158 int l = 0, r = 0, ns;
\r
160 for (ns = 0; ns < ns_to * 2; )
\r
162 l = (g_buffer(MIX_DEST_A0) + g_buffer(MIX_DEST_B0)) / 2;
\r
163 r = (g_buffer(MIX_DEST_A1) + g_buffer(MIX_DEST_B1)) / 2;
\r
165 l = (l * rvb.VolLeft) >> 15;
\r
166 r = (r * rvb.VolRight) >> 15;
\r
168 SSumLR[ns++] += (l + l_old) / 2;
\r
169 SSumLR[ns++] += (r + r_old) / 2;
\r
177 if (curr_addr >= 0x40000) curr_addr = rvb.StartAddr;
\r
182 rvb.CurrAddr = curr_addr;
\r
185 static void prepare_offsets(void)
\r
187 int space = 0x40000 - rvb.StartAddr;
\r
189 #define prep_offs(v) \
\r
191 while (t >= space) \
\r
194 #define prep_offs2(d, v1, v2) \
\r
195 t = rvb.v1 - rvb.v2; \
\r
196 while (t >= space) \
\r
200 prep_offs(IIR_SRC_A0);
\r
201 prep_offs(IIR_SRC_A1);
\r
202 prep_offs(IIR_SRC_B0);
\r
203 prep_offs(IIR_SRC_B1);
\r
204 prep_offs(IIR_DEST_A0);
\r
205 prep_offs(IIR_DEST_A1);
\r
206 prep_offs(IIR_DEST_B0);
\r
207 prep_offs(IIR_DEST_B1);
\r
208 prep_offs(ACC_SRC_A0);
\r
209 prep_offs(ACC_SRC_A1);
\r
210 prep_offs(ACC_SRC_B0);
\r
211 prep_offs(ACC_SRC_B1);
\r
212 prep_offs(ACC_SRC_C0);
\r
213 prep_offs(ACC_SRC_C1);
\r
214 prep_offs(ACC_SRC_D0);
\r
215 prep_offs(ACC_SRC_D1);
\r
216 prep_offs(MIX_DEST_A0);
\r
217 prep_offs(MIX_DEST_A1);
\r
218 prep_offs(MIX_DEST_B0);
\r
219 prep_offs(MIX_DEST_B1);
\r
220 prep_offs2(FB_SRC_A0, MIX_DEST_A0, FB_SRC_A);
\r
221 prep_offs2(FB_SRC_A1, MIX_DEST_A1, FB_SRC_A);
\r
222 prep_offs2(FB_SRC_B0, MIX_DEST_B0, FB_SRC_B);
\r
223 prep_offs2(FB_SRC_B1, MIX_DEST_B1, FB_SRC_B);
\r
230 INLINE void REVERBDo(int *SSumLR, int *RVB, int ns_to)
\r
232 if (!rvb.StartAddr) // reverb is off
\r
234 rvb.iRVBLeft = rvb.iRVBRight = 0;
\r
238 if (spu.spuCtrl & 0x80) // -> reverb on? oki
\r
240 if (unlikely(rvb.dirty))
\r
243 MixREVERB(SSumLR, RVB, ns_to);
\r
245 else if (rvb.VolLeft || rvb.VolRight)
\r
247 if (unlikely(rvb.dirty))
\r
250 MixREVERB_off(SSumLR, ns_to);
\r
252 else // -> reverb off
\r
254 // reverb runs anyway
\r
255 rvb.CurrAddr += ns_to / 2;
\r
256 while (rvb.CurrAddr >= 0x40000)
\r
257 rvb.CurrAddr -= 0x40000 - rvb.StartAddr;
\r
261 ////////////////////////////////////////////////////////////////////////
\r
266 -----------------------------------------------------------------------------
\r
267 PSX reverb hardware notes
\r
269 -----------------------------------------------------------------------------
\r
271 Yadda yadda disclaimer yadda probably not perfect yadda well it's okay anyway
\r
274 -----------------------------------------------------------------------------
\r
279 - The reverb buffer is 22khz 16-bit mono PCM.
\r
280 - It starts at the reverb address given by 1DA2, extends to
\r
281 the end of sound RAM, and wraps back to the 1DA2 address.
\r
283 Setting the address at 1DA2 resets the current reverb work address.
\r
285 This work address ALWAYS increments every 1/22050 sec., regardless of
\r
286 whether reverb is enabled (bit 7 of 1DAA set).
\r
288 And the contents of the reverb buffer ALWAYS play, scaled by the
\r
289 "reverberation depth left/right" volumes (1D84/1D86).
\r
290 (which, by the way, appear to be scaled so 3FFF=approx. 1.0, 4000=-1.0)
\r
292 -----------------------------------------------------------------------------
\r
297 These are probably not their real names.
\r
298 These are probably not even correct names.
\r
299 We will use them anyway, because we can.
\r
301 1DC0: FB_SRC_A (offset)
\r
302 1DC2: FB_SRC_B (offset)
\r
303 1DC4: IIR_ALPHA (coef.)
\r
304 1DC6: ACC_COEF_A (coef.)
\r
305 1DC8: ACC_COEF_B (coef.)
\r
306 1DCA: ACC_COEF_C (coef.)
\r
307 1DCC: ACC_COEF_D (coef.)
\r
308 1DCE: IIR_COEF (coef.)
\r
309 1DD0: FB_ALPHA (coef.)
\r
311 1DD4: IIR_DEST_A0 (offset)
\r
312 1DD6: IIR_DEST_A1 (offset)
\r
313 1DD8: ACC_SRC_A0 (offset)
\r
314 1DDA: ACC_SRC_A1 (offset)
\r
315 1DDC: ACC_SRC_B0 (offset)
\r
316 1DDE: ACC_SRC_B1 (offset)
\r
317 1DE0: IIR_SRC_A0 (offset)
\r
318 1DE2: IIR_SRC_A1 (offset)
\r
319 1DE4: IIR_DEST_B0 (offset)
\r
320 1DE6: IIR_DEST_B1 (offset)
\r
321 1DE8: ACC_SRC_C0 (offset)
\r
322 1DEA: ACC_SRC_C1 (offset)
\r
323 1DEC: ACC_SRC_D0 (offset)
\r
324 1DEE: ACC_SRC_D1 (offset)
\r
325 1DF0: IIR_SRC_B1 (offset)
\r
326 1DF2: IIR_SRC_B0 (offset)
\r
327 1DF4: MIX_DEST_A0 (offset)
\r
328 1DF6: MIX_DEST_A1 (offset)
\r
329 1DF8: MIX_DEST_B0 (offset)
\r
330 1DFA: MIX_DEST_B1 (offset)
\r
331 1DFC: IN_COEF_L (coef.)
\r
332 1DFE: IN_COEF_R (coef.)
\r
334 The coefficients are signed fractional values.
\r
335 -32768 would be -1.0
\r
336 32768 would be 1.0 (if it were possible... the highest is of course 32767)
\r
338 The offsets are (byte/8) offsets into the reverb buffer.
\r
339 i.e. you multiply them by 8, you get byte offsets.
\r
340 You can also think of them as (samples/4) offsets.
\r
341 They appear to be signed. They can be negative.
\r
342 None of the documented presets make them negative, though.
\r
344 Yes, 1DF0 and 1DF2 appear to be backwards. Not a typo.
\r
346 -----------------------------------------------------------------------------
\r
351 We take all reverb sources:
\r
352 - regular channels that have the reverb bit on
\r
353 - cd and external sources, if their reverb bits are on
\r
354 and mix them into one stereo 44100hz signal.
\r
356 Lowpass/downsample that to 22050hz. The PSX uses a proper bandlimiting
\r
357 algorithm here, but I haven't figured out the hysterically exact specifics.
\r
358 I use an 8-tap filter with these coefficients, which are nice but probably
\r
370 So we have two input samples (INPUT_SAMPLE_L, INPUT_SAMPLE_R) every 22050hz.
\r
372 * IN MY EMULATION, I divide these by 2 to make it clip less.
\r
373 (and of course the L/R output coefficients are adjusted to compensate)
\r
374 The real thing appears to not do this.
\r
376 At every 22050hz tick:
\r
377 - If the reverb bit is enabled (bit 7 of 1DAA), execute the reverb
\r
378 steady-state algorithm described below
\r
379 - AFTERWARDS, retrieve the "wet out" L and R samples from the reverb buffer
\r
380 (This part may not be exactly right and I guessed at the coefs. TODO: check later.)
\r
381 L is: 0.333 * (buffer[MIX_DEST_A0] + buffer[MIX_DEST_B0])
\r
382 R is: 0.333 * (buffer[MIX_DEST_A1] + buffer[MIX_DEST_B1])
\r
383 - Advance the current buffer position by 1 sample
\r
385 The wet out L and R are then upsampled to 44100hz and played at the
\r
386 "reverberation depth left/right" (1D84/1D86) volume, independent of the main
\r
389 -----------------------------------------------------------------------------
\r
391 Reverb steady-state
\r
392 -------------------
\r
394 The reverb steady-state algorithm is fairly clever, and of course by
\r
395 "clever" I mean "batshit insane".
\r
397 buffer[x] is relative to the current buffer position, not the beginning of
\r
398 the buffer. Note that all buffer offsets must wrap around so they're
\r
399 contained within the reverb work area.
\r
401 Clipping is performed at the end... maybe also sooner, but definitely at
\r
404 IIR_INPUT_A0 = buffer[IIR_SRC_A0] * IIR_COEF + INPUT_SAMPLE_L * IN_COEF_L;
\r
405 IIR_INPUT_A1 = buffer[IIR_SRC_A1] * IIR_COEF + INPUT_SAMPLE_R * IN_COEF_R;
\r
406 IIR_INPUT_B0 = buffer[IIR_SRC_B0] * IIR_COEF + INPUT_SAMPLE_L * IN_COEF_L;
\r
407 IIR_INPUT_B1 = buffer[IIR_SRC_B1] * IIR_COEF + INPUT_SAMPLE_R * IN_COEF_R;
\r
409 IIR_A0 = IIR_INPUT_A0 * IIR_ALPHA + buffer[IIR_DEST_A0] * (1.0 - IIR_ALPHA);
\r
410 IIR_A1 = IIR_INPUT_A1 * IIR_ALPHA + buffer[IIR_DEST_A1] * (1.0 - IIR_ALPHA);
\r
411 IIR_B0 = IIR_INPUT_B0 * IIR_ALPHA + buffer[IIR_DEST_B0] * (1.0 - IIR_ALPHA);
\r
412 IIR_B1 = IIR_INPUT_B1 * IIR_ALPHA + buffer[IIR_DEST_B1] * (1.0 - IIR_ALPHA);
\r
414 buffer[IIR_DEST_A0 + 1sample] = IIR_A0;
\r
415 buffer[IIR_DEST_A1 + 1sample] = IIR_A1;
\r
416 buffer[IIR_DEST_B0 + 1sample] = IIR_B0;
\r
417 buffer[IIR_DEST_B1 + 1sample] = IIR_B1;
\r
419 ACC0 = buffer[ACC_SRC_A0] * ACC_COEF_A +
\r
420 buffer[ACC_SRC_B0] * ACC_COEF_B +
\r
421 buffer[ACC_SRC_C0] * ACC_COEF_C +
\r
422 buffer[ACC_SRC_D0] * ACC_COEF_D;
\r
423 ACC1 = buffer[ACC_SRC_A1] * ACC_COEF_A +
\r
424 buffer[ACC_SRC_B1] * ACC_COEF_B +
\r
425 buffer[ACC_SRC_C1] * ACC_COEF_C +
\r
426 buffer[ACC_SRC_D1] * ACC_COEF_D;
\r
428 FB_A0 = buffer[MIX_DEST_A0 - FB_SRC_A];
\r
429 FB_A1 = buffer[MIX_DEST_A1 - FB_SRC_A];
\r
430 FB_B0 = buffer[MIX_DEST_B0 - FB_SRC_B];
\r
431 FB_B1 = buffer[MIX_DEST_B1 - FB_SRC_B];
\r
433 buffer[MIX_DEST_A0] = ACC0 - FB_A0 * FB_ALPHA;
\r
434 buffer[MIX_DEST_A1] = ACC1 - FB_A1 * FB_ALPHA;
\r
435 buffer[MIX_DEST_B0] = (FB_ALPHA * ACC0) - FB_A0 * (FB_ALPHA^0x8000) - FB_B0 * FB_X;
\r
436 buffer[MIX_DEST_B1] = (FB_ALPHA * ACC1) - FB_A1 * (FB_ALPHA^0x8000) - FB_B1 * FB_X;
\r
438 -----------------------------------------------------------------------------
\r
441 // vim:shiftwidth=1:expandtab
\r