plugins/dfsound/reverb.c

   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