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)\r
  68 {\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
  74 \r
  75  for (ns = 0; ns < ns_to * 2; )\r
  76   {\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
  80 \r
  81    int input_L = RVB[ns]   * rvb.IN_COEF_L;\r
  82    int input_R = RVB[ns+1] * rvb.IN_COEF_R;\r
  83 \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
  88 \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
  93 \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
  98 \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
 103 \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
 112 \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
 117 \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
 120 \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
 123 \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
 128 \r
 129    l = (mix_dest_a0 + mix_dest_b0) / 2;\r
 130    r = (mix_dest_a1 + mix_dest_b1) / 2;\r
 131 \r
 132    l = (l * rvb.VolLeft)  >> 15; // 15?\r
 133    r = (r * rvb.VolRight) >> 15;\r
 134 \r
 135    SSumLR[ns++] += (l + l_old) / 2;\r
 136    SSumLR[ns++] += (r + r_old) / 2;\r
 137    SSumLR[ns++] += l;\r
 138    SSumLR[ns++] += r;\r
 139 \r
 140    l_old = l;\r
 141    r_old = r;\r
 142 \r
 143    curr_addr++;\r
 144    if (curr_addr >= 0x40000) curr_addr = rvb.StartAddr;\r
 145   }\r
 146 \r
 147  rvb.iRVBLeft = l;\r
 148  rvb.iRVBRight = r;\r
 149  rvb.CurrAddr = curr_addr;\r
 150 }\r
 151 \r
 152 static void MixREVERB_off(int *SSumLR, int ns_to)\r
 153 {\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
 159 \r
 160  for (ns = 0; ns < ns_to * 2; )\r
 161   {\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
 164 \r
 165    l = (l * rvb.VolLeft)  >> 15;\r
 166    r = (r * rvb.VolRight) >> 15;\r
 167 \r
 168    SSumLR[ns++] += (l + l_old) / 2;\r
 169    SSumLR[ns++] += (r + r_old) / 2;\r
 170    SSumLR[ns++] += l;\r
 171    SSumLR[ns++] += r;\r
 172 \r
 173    l_old = l;\r
 174    r_old = r;\r
 175 \r
 176    curr_addr++;\r
 177    if (curr_addr >= 0x40000) curr_addr = rvb.StartAddr;\r
 178   }\r
 179 \r
 180  rvb.iRVBLeft = l;\r
 181  rvb.iRVBRight = r;\r
 182  rvb.CurrAddr = curr_addr;\r
 183 }\r
 184 \r
 185 static void prepare_offsets(void)\r
 186 {\r
 187  int space = 0x40000 - rvb.StartAddr;\r
 188  int t;\r
 189  #define prep_offs(v) \\r
 190    t = rvb.v; \\r
 191    while (t >= space) \\r
 192      t -= space; \\r
 193    rvb.n##v = t\r
 194  #define prep_offs2(d, v1, v2) \\r
 195    t = rvb.v1 - rvb.v2; \\r
 196    while (t >= space) \\r
 197      t -= space; \\r
 198    rvb.n##d = t\r
 199 \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
 224 \r
 225 #undef prep_offs\r
 226 #undef prep_offs2\r
 227  rvb.dirty = 0;\r
 228 }\r
 229 \r
 230 INLINE void REVERBDo(int *SSumLR, int *RVB, int ns_to)\r
 231 {\r
 232  if (!rvb.StartAddr)                                   // reverb is off\r
 233  {\r
 234   rvb.iRVBLeft = rvb.iRVBRight = 0;\r
 235   return;\r
 236  }\r
 237 \r
 238  if (spu.spuCtrl & 0x80)                               // -> reverb on? oki\r
 239  {\r
 240   if (unlikely(rvb.dirty))\r
 241    prepare_offsets();\r
 242 \r
 243   MixREVERB(SSumLR, RVB, ns_to);\r
 244  }\r
 245  else if (rvb.VolLeft || rvb.VolRight)\r
 246  {\r
 247   if (unlikely(rvb.dirty))\r
 248    prepare_offsets();\r
 249 \r
 250   MixREVERB_off(SSumLR, ns_to);\r
 251  }\r
 252  else                                                  // -> reverb off\r
 253  {\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
 258  }\r
 259 }\r
 260 \r
 261 ////////////////////////////////////////////////////////////////////////\r
 262 \r
 263 #endif\r
 264 \r
 265 /*\r
 266 -----------------------------------------------------------------------------\r
 267 PSX reverb hardware notes\r
 268 by Neill Corlett\r
 269 -----------------------------------------------------------------------------\r
 270 \r
 271 Yadda yadda disclaimer yadda probably not perfect yadda well it's okay anyway\r
 272 yadda yadda.\r
 273 \r
 274 -----------------------------------------------------------------------------\r
 275 \r
 276 Basics\r
 277 ------\r
 278 \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
 282 \r
 283 Setting the address at 1DA2 resets the current reverb work address.\r
 284 \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
 287 \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
 291 \r
 292 -----------------------------------------------------------------------------\r
 293 \r
 294 Register names\r
 295 --------------\r
 296 \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
 300 \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
 310 1DD2: FB_X           (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
 333 \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
 337 \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
 343 \r
 344 Yes, 1DF0 and 1DF2 appear to be backwards.  Not a typo.\r
 345 \r
 346 -----------------------------------------------------------------------------\r
 347 \r
 348 What it does\r
 349 ------------\r
 350 \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
 355 \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
 359 not the real ones:\r
 360 \r
 361 0.037828187894\r
 362 0.157538631280\r
 363 0.321159685278\r
 364 0.449322115345\r
 365 0.449322115345\r
 366 0.321159685278\r
 367 0.157538631280\r
 368 0.037828187894\r
 369 \r
 370 So we have two input samples (INPUT_SAMPLE_L, INPUT_SAMPLE_R) every 22050hz.\r
 371 \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
 375 \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
 384 \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
 387 volume.\r
 388 \r
 389 -----------------------------------------------------------------------------\r
 390 \r
 391 Reverb steady-state\r
 392 -------------------\r
 393 \r
 394 The reverb steady-state algorithm is fairly clever, and of course by\r
 395 "clever" I mean "batshit insane".\r
 396 \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
 400 \r
 401 Clipping is performed at the end... maybe also sooner, but definitely at\r
 402 the end.\r
 403 \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
 408 \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
 413 \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
 418 \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
 427 \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
 432 \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
 437 \r
 438 -----------------------------------------------------------------------------\r
 439 */\r
 440 \r
 441 // vim:shiftwidth=1:expandtab\r