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 // HELPER FOR NEILL'S REVERB: re-inits our reverb mixing buf\r
  44 ////////////////////////////////////////////////////////////////////////\r
  45 \r
  46 INLINE void InitREVERB(int ns_to)\r
  47 {\r
  48  memset(spu.sRVBStart,0,ns_to*sizeof(spu.sRVBStart[0])*2);\r
  49 }\r
  50 \r
  51 ////////////////////////////////////////////////////////////////////////\r
  52 \r
  53 INLINE int rvb2ram_offs(int curr, int space, int iOff)\r
  54 {\r
  55  iOff += curr;\r
  56  if (iOff >= 0x40000) iOff -= space;\r
  57  return iOff;\r
  58 }\r
  59 \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
  63 \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
  68 \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
  72 \r
  73 ////////////////////////////////////////////////////////////////////////\r
  74 \r
  75 // portions based on spu2-x from PCSX2\r
  76 static void MixREVERB(int ns_to)\r
  77 {\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
  83 \r
  84  for (ns = 0; ns < ns_to * 2; )\r
  85   {\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
  89 \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
  92 \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
  97 \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
 102 \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
 107 \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
 112 \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
 121 \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
 126 \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
 129 \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
 132 \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
 137 \r
 138    l = (mix_dest_a0 + mix_dest_b0) / 2;\r
 139    r = (mix_dest_a1 + mix_dest_b1) / 2;\r
 140 \r
 141    l = (l * rvb.VolLeft)  >> 15; // 15?\r
 142    r = (r * rvb.VolRight) >> 15;\r
 143 \r
 144    SSumLR[ns++] += (l + l_old) / 2;\r
 145    SSumLR[ns++] += (r + r_old) / 2;\r
 146    SSumLR[ns++] += l;\r
 147    SSumLR[ns++] += r;\r
 148 \r
 149    l_old = l;\r
 150    r_old = r;\r
 151 \r
 152    curr_addr++;\r
 153    if (curr_addr >= 0x40000) curr_addr = rvb.StartAddr;\r
 154   }\r
 155 \r
 156  rvb.iRVBLeft = l;\r
 157  rvb.iRVBRight = r;\r
 158  rvb.CurrAddr = curr_addr;\r
 159 }\r
 160 \r
 161 static void MixREVERB_off(int ns_to)\r
 162 {\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
 168 \r
 169  for (ns = 0; ns < ns_to * 2; )\r
 170   {\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
 173 \r
 174    l = (l * rvb.VolLeft)  >> 15;\r
 175    r = (r * rvb.VolRight) >> 15;\r
 176 \r
 177    SSumLR[ns++] += (l + l_old) / 2;\r
 178    SSumLR[ns++] += (r + r_old) / 2;\r
 179    SSumLR[ns++] += l;\r
 180    SSumLR[ns++] += r;\r
 181 \r
 182    l_old = l;\r
 183    r_old = r;\r
 184 \r
 185    curr_addr++;\r
 186    if (curr_addr >= 0x40000) curr_addr = rvb.StartAddr;\r
 187   }\r
 188 \r
 189  rvb.iRVBLeft = l;\r
 190  rvb.iRVBRight = r;\r
 191  rvb.CurrAddr = curr_addr;\r
 192 }\r
 193 \r
 194 static void prepare_offsets(void)\r
 195 {\r
 196  int space = 0x40000 - rvb.StartAddr;\r
 197  int t;\r
 198  #define prep_offs(v) \\r
 199    t = rvb.v; \\r
 200    while (t >= space) \\r
 201      t -= space; \\r
 202    rvb.n##v = t\r
 203  #define prep_offs2(d, v1, v2) \\r
 204    t = rvb.v1 - rvb.v2; \\r
 205    while (t >= space) \\r
 206      t -= space; \\r
 207    rvb.n##d = t\r
 208 \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
 233 \r
 234 #undef prep_offs\r
 235 #undef prep_offs2\r
 236  rvb.dirty = 0;\r
 237 }\r
 238 \r
 239 INLINE void REVERBDo(int ns_to)\r
 240 {\r
 241  if (!rvb.StartAddr)                                   // reverb is off\r
 242  {\r
 243   rvb.iRVBLeft = rvb.iRVBRight = 0;\r
 244   return;\r
 245  }\r
 246 \r
 247  if (spu.spuCtrl & 0x80)                               // -> reverb on? oki\r
 248  {\r
 249   if (unlikely(rvb.dirty))\r
 250    prepare_offsets();\r
 251 \r
 252   MixREVERB(ns_to);\r
 253  }\r
 254  else if (rvb.VolLeft || rvb.VolRight)\r
 255  {\r
 256   if (unlikely(rvb.dirty))\r
 257    prepare_offsets();\r
 258 \r
 259   MixREVERB_off(ns_to);\r
 260  }\r
 261  else                                                  // -> reverb off\r
 262  {\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
 267  }\r
 268 }\r
 269 \r
 270 ////////////////////////////////////////////////////////////////////////\r
 271 \r
 272 #endif\r
 273 \r
 274 /*\r
 275 -----------------------------------------------------------------------------\r
 276 PSX reverb hardware notes\r
 277 by Neill Corlett\r
 278 -----------------------------------------------------------------------------\r
 279 \r
 280 Yadda yadda disclaimer yadda probably not perfect yadda well it's okay anyway\r
 281 yadda yadda.\r
 282 \r
 283 -----------------------------------------------------------------------------\r
 284 \r
 285 Basics\r
 286 ------\r
 287 \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
 291 \r
 292 Setting the address at 1DA2 resets the current reverb work address.\r
 293 \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
 296 \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
 300 \r
 301 -----------------------------------------------------------------------------\r
 302 \r
 303 Register names\r
 304 --------------\r
 305 \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
 309 \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
 319 1DD2: FB_X           (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
 342 \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
 346 \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
 352 \r
 353 Yes, 1DF0 and 1DF2 appear to be backwards.  Not a typo.\r
 354 \r
 355 -----------------------------------------------------------------------------\r
 356 \r
 357 What it does\r
 358 ------------\r
 359 \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
 364 \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
 368 not the real ones:\r
 369 \r
 370 0.037828187894\r
 371 0.157538631280\r
 372 0.321159685278\r
 373 0.449322115345\r
 374 0.449322115345\r
 375 0.321159685278\r
 376 0.157538631280\r
 377 0.037828187894\r
 378 \r
 379 So we have two input samples (INPUT_SAMPLE_L, INPUT_SAMPLE_R) every 22050hz.\r
 380 \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
 384 \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
 393 \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
 396 volume.\r
 397 \r
 398 -----------------------------------------------------------------------------\r
 399 \r
 400 Reverb steady-state\r
 401 -------------------\r
 402 \r
 403 The reverb steady-state algorithm is fairly clever, and of course by\r
 404 "clever" I mean "batshit insane".\r
 405 \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
 409 \r
 410 Clipping is performed at the end... maybe also sooner, but definitely at\r
 411 the end.\r
 412 \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
 417 \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
 422 \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
 427 \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
 436 \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
 441 \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
 446 \r
 447 -----------------------------------------------------------------------------\r
 448 */\r
 449 \r
 450 // vim:shiftwidth=1:expandtab\r