begin : Wed May 15 2002\r
copyright : (C) 2002 by Pete Bernert\r
email : BlackDove@addcom.de\r
+\r
+ Portions (C) GraÅžvydas "notaz" Ignotas, 2010-2011\r
+ Portions (C) SPU2-X, gigaherz, Pcsx2 Development Team\r
+\r
***************************************************************************/\r
/***************************************************************************\r
* *\r
// will be included from spu.c\r
#ifdef _IN_SPU\r
\r
-////////////////////////////////////////////////////////////////////////\r
-// globals\r
-////////////////////////////////////////////////////////////////////////\r
-\r
-// REVERB info and timing vars...\r
-\r
-int * sRVBPlay = 0;\r
-int * sRVBEnd = 0;\r
-int * sRVBStart = 0;\r
-int iReverbOff = -1; // some delay factor for reverb\r
-int iReverbRepeat = 0;\r
-int iReverbNum = 1; \r
-\r
-////////////////////////////////////////////////////////////////////////\r
-// SET REVERB\r
-////////////////////////////////////////////////////////////////////////\r
-\r
-void SetREVERB(unsigned short val)\r
-{\r
- switch(val)\r
- {\r
- case 0x0000: iReverbOff=-1; break; // off\r
- case 0x007D: iReverbOff=32; iReverbNum=2; iReverbRepeat=128; break; // ok room\r
-\r
- case 0x0033: iReverbOff=32; iReverbNum=2; iReverbRepeat=64; break; // studio small\r
- case 0x00B1: iReverbOff=48; iReverbNum=2; iReverbRepeat=96; break; // ok studio medium\r
- case 0x00E3: iReverbOff=64; iReverbNum=2; iReverbRepeat=128; break; // ok studio large ok\r
-\r
- case 0x01A5: iReverbOff=128; iReverbNum=4; iReverbRepeat=32; break; // ok hall\r
- case 0x033D: iReverbOff=256; iReverbNum=4; iReverbRepeat=64; break; // space echo\r
- case 0x0001: iReverbOff=184; iReverbNum=3; iReverbRepeat=128; break; // echo/delay\r
- case 0x0017: iReverbOff=128; iReverbNum=2; iReverbRepeat=128; break; // half echo\r
- default: iReverbOff=32; iReverbNum=1; iReverbRepeat=0; break;\r
- }\r
-}\r
-\r
////////////////////////////////////////////////////////////////////////\r
// START REVERB\r
////////////////////////////////////////////////////////////////////////\r
\r
INLINE void StartREVERB(int ch)\r
{\r
- if(s_chan[ch].bReverb && (spuCtrl&0x80)) // reverb possible?\r
+ if(spu.s_chan[ch].bReverb && (spu.spuCtrl&0x80)) // reverb possible?\r
{\r
- if(iUseReverb==2) s_chan[ch].bRVBActive=1;\r
- else\r
- if(iUseReverb==1 && iReverbOff>0) // -> fake reverb used?\r
- {\r
- s_chan[ch].bRVBActive=1; // -> activate it\r
- s_chan[ch].iRVBOffset=iReverbOff*45;\r
- s_chan[ch].iRVBRepeat=iReverbRepeat*45;\r
- s_chan[ch].iRVBNum =iReverbNum;\r
- }\r
+ spu.s_chan[ch].bRVBActive=!!spu_config.iUseReverb;\r
}\r
- else s_chan[ch].bRVBActive=0; // else -> no reverb\r
+ else spu.s_chan[ch].bRVBActive=0; // else -> no reverb\r
}\r
\r
-////////////////////////////////////////////////////////////////////////\r
-// HELPER FOR NEILL'S REVERB: re-inits our reverb mixing buf\r
////////////////////////////////////////////////////////////////////////\r
\r
-INLINE void InitREVERB(void)\r
+INLINE int rvb2ram_offs(int curr, int space, int iOff)\r
{\r
- if(iUseReverb==2)\r
- {memset(sRVBStart,0,NSSIZE*2*4);}\r
+ iOff += curr;\r
+ if (iOff >= 0x40000) iOff -= space;\r
+ return iOff;\r
}\r
\r
-////////////////////////////////////////////////////////////////////////\r
-// STORE REVERB\r
+// get_buffer content helper: takes care about wraps\r
+#define g_buffer(var) \\r
+ ((int)(signed short)spu.spuMem[rvb2ram_offs(curr_addr, space, rvb->var)])\r
+\r
+// saturate iVal and store it as var\r
+#define s_buffer(var, iVal) \\r
+ ssat32_to_16(iVal); \\r
+ spu.spuMem[rvb2ram_offs(curr_addr, space, rvb->var)] = iVal\r
+\r
+#define s_buffer1(var, iVal) \\r
+ ssat32_to_16(iVal); \\r
+ spu.spuMem[rvb2ram_offs(curr_addr, space, rvb->var + 1)] = iVal\r
+\r
////////////////////////////////////////////////////////////////////////\r
\r
-INLINE void StoreREVERB(int ch,int ns)\r
+// portions based on spu2-x from PCSX2\r
+static void MixREVERB(int *SSumLR, int *RVB, int ns_to, int curr_addr)\r
{\r
- if(iUseReverb==0) return;\r
- else\r
- if(iUseReverb==2) // -------------------------------- // Neil's reverb\r
- {\r
- const int iRxl=(s_chan[ch].sval*s_chan[ch].iLeftVolume)/0x4000;\r
- const int iRxr=(s_chan[ch].sval*s_chan[ch].iRightVolume)/0x4000;\r
+ const REVERBInfo *rvb = spu.rvb;\r
+ int IIR_ALPHA = rvb->IIR_ALPHA;\r
+ int IIR_COEF = rvb->IIR_COEF;\r
+ int space = 0x40000 - rvb->StartAddr;\r
+ int l, r, ns;\r
\r
- ns<<=1;\r
-\r
- *(sRVBStart+ns) +=iRxl; // -> we mix all active reverb channels into an extra buffer\r
- *(sRVBStart+ns+1)+=iRxr;\r
- }\r
- else // --------------------------------------------- // Pete's easy fake reverb\r
+ for (ns = 0; ns < ns_to * 2; )\r
{\r
- int * pN;int iRn,iRr=0;\r
-\r
- // we use the half channel volume (/0x8000) for the first reverb effects, quarter for next and so on\r
-\r
- int iRxl=(s_chan[ch].sval*s_chan[ch].iLeftVolume)/0x8000;\r
- int iRxr=(s_chan[ch].sval*s_chan[ch].iRightVolume)/0x8000;\r
- \r
- for(iRn=1;iRn<=s_chan[ch].iRVBNum;iRn++,iRr+=s_chan[ch].iRVBRepeat,iRxl/=2,iRxr/=2)\r
- {\r
- pN=sRVBPlay+((s_chan[ch].iRVBOffset+iRr+ns)<<1);\r
- if(pN>=sRVBEnd) pN=sRVBStart+(pN-sRVBEnd);\r
-\r
- (*pN)+=iRxl;\r
- pN++;\r
- (*pN)+=iRxr;\r
- }\r
+ int ACC0, ACC1, FB_A0, FB_A1, FB_B0, FB_B1;\r
+ int mix_dest_a0, mix_dest_a1, mix_dest_b0, mix_dest_b1;\r
+\r
+ int input_L = RVB[ns] * rvb->IN_COEF_L;\r
+ int input_R = RVB[ns+1] * rvb->IN_COEF_R;\r
+\r
+ int IIR_INPUT_A0 = ((g_buffer(IIR_SRC_A0) * IIR_COEF) + input_L) >> 15;\r
+ int IIR_INPUT_A1 = ((g_buffer(IIR_SRC_A1) * IIR_COEF) + input_R) >> 15;\r
+ int IIR_INPUT_B0 = ((g_buffer(IIR_SRC_B0) * IIR_COEF) + input_L) >> 15;\r
+ int IIR_INPUT_B1 = ((g_buffer(IIR_SRC_B1) * IIR_COEF) + input_R) >> 15;\r
+\r
+ int iir_dest_a0 = g_buffer(IIR_DEST_A0);\r
+ int iir_dest_a1 = g_buffer(IIR_DEST_A1);\r
+ int iir_dest_b0 = g_buffer(IIR_DEST_B0);\r
+ int iir_dest_b1 = g_buffer(IIR_DEST_B1);\r
+\r
+ int IIR_A0 = iir_dest_a0 + ((IIR_INPUT_A0 - iir_dest_a0) * IIR_ALPHA >> 15);\r
+ int IIR_A1 = iir_dest_a1 + ((IIR_INPUT_A1 - iir_dest_a1) * IIR_ALPHA >> 15);\r
+ int IIR_B0 = iir_dest_b0 + ((IIR_INPUT_B0 - iir_dest_b0) * IIR_ALPHA >> 15);\r
+ int IIR_B1 = iir_dest_b1 + ((IIR_INPUT_B1 - iir_dest_b1) * IIR_ALPHA >> 15);\r
+\r
+ preload(SSumLR + ns + 64*2/4 - 4);\r
+\r
+ s_buffer1(IIR_DEST_A0, IIR_A0);\r
+ s_buffer1(IIR_DEST_A1, IIR_A1);\r
+ s_buffer1(IIR_DEST_B0, IIR_B0);\r
+ s_buffer1(IIR_DEST_B1, IIR_B1);\r
+\r
+ preload(RVB + ns + 64*2/4 - 4);\r
+\r
+ ACC0 = (g_buffer(ACC_SRC_A0) * rvb->ACC_COEF_A +\r
+ g_buffer(ACC_SRC_B0) * rvb->ACC_COEF_B +\r
+ g_buffer(ACC_SRC_C0) * rvb->ACC_COEF_C +\r
+ g_buffer(ACC_SRC_D0) * rvb->ACC_COEF_D) >> 15;\r
+ ACC1 = (g_buffer(ACC_SRC_A1) * rvb->ACC_COEF_A +\r
+ g_buffer(ACC_SRC_B1) * rvb->ACC_COEF_B +\r
+ g_buffer(ACC_SRC_C1) * rvb->ACC_COEF_C +\r
+ g_buffer(ACC_SRC_D1) * rvb->ACC_COEF_D) >> 15;\r
+\r
+ FB_A0 = g_buffer(FB_SRC_A0);\r
+ FB_A1 = g_buffer(FB_SRC_A1);\r
+ FB_B0 = g_buffer(FB_SRC_B0);\r
+ FB_B1 = g_buffer(FB_SRC_B1);\r
+\r
+ mix_dest_a0 = ACC0 - ((FB_A0 * rvb->FB_ALPHA) >> 15);\r
+ mix_dest_a1 = ACC1 - ((FB_A1 * rvb->FB_ALPHA) >> 15);\r
+\r
+ mix_dest_b0 = FB_A0 + (((ACC0 - FB_A0) * rvb->FB_ALPHA - FB_B0 * rvb->FB_X) >> 15);\r
+ mix_dest_b1 = FB_A1 + (((ACC1 - FB_A1) * rvb->FB_ALPHA - FB_B1 * rvb->FB_X) >> 15);\r
+\r
+ s_buffer(MIX_DEST_A0, mix_dest_a0);\r
+ s_buffer(MIX_DEST_A1, mix_dest_a1);\r
+ s_buffer(MIX_DEST_B0, mix_dest_b0);\r
+ s_buffer(MIX_DEST_B1, mix_dest_b1);\r
+\r
+ l = (mix_dest_a0 + mix_dest_b0) / 2;\r
+ r = (mix_dest_a1 + mix_dest_b1) / 2;\r
+\r
+ l = (l * rvb->VolLeft) >> 15; // 15?\r
+ r = (r * rvb->VolRight) >> 15;\r
+\r
+ SSumLR[ns++] += l;\r
+ SSumLR[ns++] += r;\r
+ SSumLR[ns++] += l;\r
+ SSumLR[ns++] += r;\r
+\r
+ curr_addr++;\r
+ if (curr_addr >= 0x40000) curr_addr = rvb->StartAddr;\r
}\r
}\r
\r
-////////////////////////////////////////////////////////////////////////\r
-\r
-INLINE int g_buffer(int iOff) // get_buffer content helper: takes care about wraps\r
+static void MixREVERB_off(int *SSumLR, int ns_to, int curr_addr)\r
{\r
- short * p=(short *)spuMem;\r
- iOff=(iOff*4)+rvb.CurrAddr;\r
- while(iOff>0x3FFFF) iOff=rvb.StartAddr+(iOff-0x40000);\r
- while(iOff<rvb.StartAddr) iOff=0x3ffff-(rvb.StartAddr-iOff);\r
- return (int)*(p+iOff);\r
-}\r
+ const REVERBInfo *rvb = spu.rvb;\r
+ int space = 0x40000 - rvb->StartAddr;\r
+ int l, r, ns;\r
\r
-////////////////////////////////////////////////////////////////////////\r
-\r
-INLINE void s_buffer(int iOff,int iVal) // set_buffer content helper: takes care about wraps and clipping\r
-{\r
- short * p=(short *)spuMem;\r
- iOff=(iOff*4)+rvb.CurrAddr;\r
- while(iOff>0x3FFFF) iOff=rvb.StartAddr+(iOff-0x40000);\r
- while(iOff<rvb.StartAddr) iOff=0x3ffff-(rvb.StartAddr-iOff);\r
- if(iVal<-32768L) iVal=-32768L;if(iVal>32767L) iVal=32767L;\r
- *(p+iOff)=(short)iVal;\r
-}\r
+ for (ns = 0; ns < ns_to * 2; )\r
+ {\r
+ preload(SSumLR + ns + 64*2/4 - 4);\r
\r
-////////////////////////////////////////////////////////////////////////\r
+ l = (g_buffer(MIX_DEST_A0) + g_buffer(MIX_DEST_B0)) / 2;\r
+ r = (g_buffer(MIX_DEST_A1) + g_buffer(MIX_DEST_B1)) / 2;\r
\r
-INLINE void s_buffer1(int iOff,int iVal) // set_buffer (+1 sample) content helper: takes care about wraps and clipping\r
-{\r
- short * p=(short *)spuMem;\r
- iOff=(iOff*4)+rvb.CurrAddr+1;\r
- while(iOff>0x3FFFF) iOff=rvb.StartAddr+(iOff-0x40000);\r
- while(iOff<rvb.StartAddr) iOff=0x3ffff-(rvb.StartAddr-iOff);\r
- if(iVal<-32768L) iVal=-32768L;if(iVal>32767L) iVal=32767L;\r
- *(p+iOff)=(short)iVal;\r
-}\r
+ l = (l * rvb->VolLeft) >> 15;\r
+ r = (r * rvb->VolRight) >> 15;\r
\r
-////////////////////////////////////////////////////////////////////////\r
+ SSumLR[ns++] += l;\r
+ SSumLR[ns++] += r;\r
+ SSumLR[ns++] += l;\r
+ SSumLR[ns++] += r;\r
\r
-INLINE int MixREVERBLeft(int ns)\r
-{\r
- if(iUseReverb==0) return 0;\r
- else\r
- if(iUseReverb==2)\r
- {\r
- static int iCnt=0; // this func will be called with 44.1 khz\r
-\r
- if(!rvb.StartAddr) // reverb is off\r
- {\r
- rvb.iLastRVBLeft=rvb.iLastRVBRight=rvb.iRVBLeft=rvb.iRVBRight=0;\r
- return 0;\r
- }\r
-\r
- iCnt++; \r
-\r
- if(iCnt&1) // we work on every second left value: downsample to 22 khz\r
- {\r
- if(spuCtrl&0x80) // -> reverb on? oki\r
- {\r
- int ACC0,ACC1,FB_A0,FB_A1,FB_B0,FB_B1;\r
-\r
- const int INPUT_SAMPLE_L=*(sRVBStart+(ns<<1)); \r
- const int INPUT_SAMPLE_R=*(sRVBStart+(ns<<1)+1); \r
-\r
- const int IIR_INPUT_A0 = (g_buffer(rvb.IIR_SRC_A0) * rvb.IIR_COEF)/32768L + (INPUT_SAMPLE_L * rvb.IN_COEF_L)/32768L;\r
- const int IIR_INPUT_A1 = (g_buffer(rvb.IIR_SRC_A1) * rvb.IIR_COEF)/32768L + (INPUT_SAMPLE_R * rvb.IN_COEF_R)/32768L;\r
- const int IIR_INPUT_B0 = (g_buffer(rvb.IIR_SRC_B0) * rvb.IIR_COEF)/32768L + (INPUT_SAMPLE_L * rvb.IN_COEF_L)/32768L;\r
- const int IIR_INPUT_B1 = (g_buffer(rvb.IIR_SRC_B1) * rvb.IIR_COEF)/32768L + (INPUT_SAMPLE_R * rvb.IN_COEF_R)/32768L;\r
-\r
- const int IIR_A0 = (IIR_INPUT_A0 * rvb.IIR_ALPHA)/32768L + (g_buffer(rvb.IIR_DEST_A0) * (32768L - rvb.IIR_ALPHA))/32768L;\r
- const int IIR_A1 = (IIR_INPUT_A1 * rvb.IIR_ALPHA)/32768L + (g_buffer(rvb.IIR_DEST_A1) * (32768L - rvb.IIR_ALPHA))/32768L;\r
- const int IIR_B0 = (IIR_INPUT_B0 * rvb.IIR_ALPHA)/32768L + (g_buffer(rvb.IIR_DEST_B0) * (32768L - rvb.IIR_ALPHA))/32768L;\r
- const int IIR_B1 = (IIR_INPUT_B1 * rvb.IIR_ALPHA)/32768L + (g_buffer(rvb.IIR_DEST_B1) * (32768L - rvb.IIR_ALPHA))/32768L;\r
-\r
- s_buffer1(rvb.IIR_DEST_A0, IIR_A0);\r
- s_buffer1(rvb.IIR_DEST_A1, IIR_A1);\r
- s_buffer1(rvb.IIR_DEST_B0, IIR_B0);\r
- s_buffer1(rvb.IIR_DEST_B1, IIR_B1);\r
- \r
- ACC0 = (g_buffer(rvb.ACC_SRC_A0) * rvb.ACC_COEF_A)/32768L +\r
- (g_buffer(rvb.ACC_SRC_B0) * rvb.ACC_COEF_B)/32768L +\r
- (g_buffer(rvb.ACC_SRC_C0) * rvb.ACC_COEF_C)/32768L +\r
- (g_buffer(rvb.ACC_SRC_D0) * rvb.ACC_COEF_D)/32768L;\r
- ACC1 = (g_buffer(rvb.ACC_SRC_A1) * rvb.ACC_COEF_A)/32768L +\r
- (g_buffer(rvb.ACC_SRC_B1) * rvb.ACC_COEF_B)/32768L +\r
- (g_buffer(rvb.ACC_SRC_C1) * rvb.ACC_COEF_C)/32768L +\r
- (g_buffer(rvb.ACC_SRC_D1) * rvb.ACC_COEF_D)/32768L;\r
-\r
- FB_A0 = g_buffer(rvb.MIX_DEST_A0 - rvb.FB_SRC_A);\r
- FB_A1 = g_buffer(rvb.MIX_DEST_A1 - rvb.FB_SRC_A);\r
- FB_B0 = g_buffer(rvb.MIX_DEST_B0 - rvb.FB_SRC_B);\r
- FB_B1 = g_buffer(rvb.MIX_DEST_B1 - rvb.FB_SRC_B);\r
-\r
- s_buffer(rvb.MIX_DEST_A0, ACC0 - (FB_A0 * rvb.FB_ALPHA)/32768L);\r
- s_buffer(rvb.MIX_DEST_A1, ACC1 - (FB_A1 * rvb.FB_ALPHA)/32768L);\r
- \r
- s_buffer(rvb.MIX_DEST_B0, (rvb.FB_ALPHA * ACC0)/32768L - (FB_A0 * (int)(rvb.FB_ALPHA^0xFFFF8000))/32768L - (FB_B0 * rvb.FB_X)/32768L);\r
- s_buffer(rvb.MIX_DEST_B1, (rvb.FB_ALPHA * ACC1)/32768L - (FB_A1 * (int)(rvb.FB_ALPHA^0xFFFF8000))/32768L - (FB_B1 * rvb.FB_X)/32768L);\r
- \r
- rvb.iLastRVBLeft = rvb.iRVBLeft;\r
- rvb.iLastRVBRight = rvb.iRVBRight;\r
-\r
- rvb.iRVBLeft = (g_buffer(rvb.MIX_DEST_A0)+g_buffer(rvb.MIX_DEST_B0))/3;\r
- rvb.iRVBRight = (g_buffer(rvb.MIX_DEST_A1)+g_buffer(rvb.MIX_DEST_B1))/3;\r
-\r
- rvb.iRVBLeft = (rvb.iRVBLeft * rvb.VolLeft) / 0x4000;\r
- rvb.iRVBRight = (rvb.iRVBRight * rvb.VolRight) / 0x4000;\r
-\r
- rvb.CurrAddr++;\r
- if(rvb.CurrAddr>0x3ffff) rvb.CurrAddr=rvb.StartAddr;\r
-\r
- return rvb.iLastRVBLeft+(rvb.iRVBLeft-rvb.iLastRVBLeft)/2;\r
- }\r
- else // -> reverb off\r
- {\r
- rvb.iLastRVBLeft=rvb.iLastRVBRight=rvb.iRVBLeft=rvb.iRVBRight=0;\r
- }\r
-\r
- rvb.CurrAddr++;\r
- if(rvb.CurrAddr>0x3ffff) rvb.CurrAddr=rvb.StartAddr;\r
- }\r
-\r
- return rvb.iLastRVBLeft;\r
- }\r
- else // easy fake reverb:\r
- {\r
- const int iRV=*sRVBPlay; // -> simply take the reverb mix buf value\r
- *sRVBPlay++=0; // -> init it after\r
- if(sRVBPlay>=sRVBEnd) sRVBPlay=sRVBStart; // -> and take care about wrap arounds\r
- return iRV; // -> return reverb mix buf val\r
+ curr_addr++;\r
+ if (curr_addr >= 0x40000) curr_addr = rvb->StartAddr;\r
}\r
}\r
\r
-////////////////////////////////////////////////////////////////////////\r
+static void REVERBPrep(void)\r
+{\r
+ REVERBInfo *rvb = spu.rvb;\r
+ int space, t;\r
+\r
+ t = spu.regArea[(H_SPUReverbAddr - 0xc00) >> 1];\r
+ if (t == 0xFFFF || t <= 0x200)\r
+ spu.rvb->StartAddr = spu.rvb->CurrAddr = 0;\r
+ else if (spu.rvb->StartAddr != (t << 2))\r
+ spu.rvb->StartAddr = spu.rvb->CurrAddr = t << 2;\r
+\r
+ space = 0x40000 - rvb->StartAddr;\r
+\r
+ #define prep_offs(v, r) \\r
+ t = spu.regArea[(0x1c0 + r) >> 1] * 4; \\r
+ while (t >= space) \\r
+ t -= space; \\r
+ rvb->v = t\r
+ #define prep_offs2(d, r1, r2) \\r
+ t = spu.regArea[(0x1c0 + r1) >> 1] * 4; \\r
+ t -= spu.regArea[(0x1c0 + r2) >> 1] * 4; \\r
+ while (t < 0) \\r
+ t += space; \\r
+ while (t >= space) \\r
+ t -= space; \\r
+ rvb->d = t\r
+\r
+ prep_offs(IIR_SRC_A0, 32);\r
+ prep_offs(IIR_SRC_A1, 34);\r
+ prep_offs(IIR_SRC_B0, 36);\r
+ prep_offs(IIR_SRC_B1, 38);\r
+ prep_offs(IIR_DEST_A0, 20);\r
+ prep_offs(IIR_DEST_A1, 22);\r
+ prep_offs(IIR_DEST_B0, 36);\r
+ prep_offs(IIR_DEST_B1, 38);\r
+ prep_offs(ACC_SRC_A0, 24);\r
+ prep_offs(ACC_SRC_A1, 26);\r
+ prep_offs(ACC_SRC_B0, 28);\r
+ prep_offs(ACC_SRC_B1, 30);\r
+ prep_offs(ACC_SRC_C0, 40);\r
+ prep_offs(ACC_SRC_C1, 42);\r
+ prep_offs(ACC_SRC_D0, 44);\r
+ prep_offs(ACC_SRC_D1, 46);\r
+ prep_offs(MIX_DEST_A0, 52);\r
+ prep_offs(MIX_DEST_A1, 54);\r
+ prep_offs(MIX_DEST_B0, 56);\r
+ prep_offs(MIX_DEST_B1, 58);\r
+ prep_offs2(FB_SRC_A0, 52, 0);\r
+ prep_offs2(FB_SRC_A1, 54, 0);\r
+ prep_offs2(FB_SRC_B0, 56, 2);\r
+ prep_offs2(FB_SRC_B1, 58, 2);\r
+\r
+#undef prep_offs\r
+#undef prep_offs2\r
+ rvb->dirty = 0;\r
+}\r
\r
-INLINE int MixREVERBRight(void)\r
+INLINE void REVERBDo(int *SSumLR, int *RVB, int ns_to, int curr_addr)\r
{\r
- if(iUseReverb==0) return 0;\r
- else\r
- if(iUseReverb==2) // Neill's reverb:\r
- {\r
- int i=rvb.iLastRVBRight+(rvb.iRVBRight-rvb.iLastRVBRight)/2;\r
- rvb.iLastRVBRight=rvb.iRVBRight;\r
- return i; // -> just return the last right reverb val (little bit scaled by the previous right val)\r
- }\r
- else // easy fake reverb:\r
- {\r
- const int iRV=*sRVBPlay; // -> simply take the reverb mix buf value\r
- *sRVBPlay++=0; // -> init it after\r
- if(sRVBPlay>=sRVBEnd) sRVBPlay=sRVBStart; // -> and take care about wrap arounds\r
- return iRV; // -> return reverb mix buf val\r
- }\r
+ if (spu.spuCtrl & 0x80) // -> reverb on? oki\r
+ {\r
+ MixREVERB(SSumLR, RVB, ns_to, curr_addr);\r
+ }\r
+ else if (spu.rvb->VolLeft || spu.rvb->VolRight)\r
+ {\r
+ MixREVERB_off(SSumLR, ns_to, curr_addr);\r
+ }\r
}\r
\r
////////////////////////////////////////////////////////////////////////\r
-----------------------------------------------------------------------------\r
*/\r
\r
+// vim:shiftwidth=1:expandtab\r