spu: rework synchronization

11 files changed, 324 insertions, 229 deletions

diff --git a/plugins/dfsound/alsa.c b/plugins/dfsound/alsa.c
index 1c02d37..b5655a9 100644
--- a/plugins/dfsound/alsa.c
+++ b/plugins/dfsound/alsa.c
@@ -16,6 +16,7 @@
  ***************************************************************************/
 
 #include <stdio.h>
+#include <string.h>
 #define ALSA_PCM_NEW_HW_PARAMS_API
 #define ALSA_PCM_NEW_SW_PARAMS_API
 #include <alsa/asoundlib.h>
@@ -184,10 +185,17 @@ static int alsa_busy(void)
 // FEED SOUND DATA
 static void alsa_feed(void *pSound, int lBytes)
 {
+ char sbuf[4096];
+
  if (handle == NULL) return;
 
  if (snd_pcm_state(handle) == SND_PCM_STATE_XRUN)
-  snd_pcm_prepare(handle);
+  {
+   memset(sbuf, 0, sizeof(sbuf));
+   snd_pcm_prepare(handle);
+   snd_pcm_writei(handle, sbuf, sizeof(sbuf) / 4);
+   snd_pcm_writei(handle, sbuf, sizeof(sbuf) / 4);
+  }
  snd_pcm_writei(handle,pSound, lBytes / 4);
 }
 
diff --git a/plugins/dfsound/dma.c b/plugins/dfsound/dma.c
index 7c164ac..85b746c 100644
--- a/plugins/dfsound/dma.c
+++ b/plugins/dfsound/dma.c
@@ -38,10 +38,13 @@ unsigned short CALLBACK SPUreadDMA(void)
 // READ DMA (many values)

 ////////////////////////////////////////////////////////////////////////

 

-void CALLBACK SPUreadDMAMem(unsigned short * pusPSXMem,int iSize)

+void CALLBACK SPUreadDMAMem(unsigned short *pusPSXMem, int iSize,

+ unsigned int cycles)

 {

  int i;

 

+ do_samples_if_needed(cycles);

+

  for(i=0;i<iSize;i++)

   {

    *pusPSXMem++=spuMem[spuAddr>>1];                    // spu addr got by writeregister

@@ -74,11 +77,12 @@ void CALLBACK SPUwriteDMA(unsigned short val)
 // WRITE DMA (many values)

 ////////////////////////////////////////////////////////////////////////

 

-void CALLBACK SPUwriteDMAMem(unsigned short * pusPSXMem,int iSize)

+void CALLBACK SPUwriteDMAMem(unsigned short *pusPSXMem, int iSize,

+ unsigned int cycles)

 {

  int i;

  

- had_dma = 1;

+ do_samples_if_needed(cycles);

 

  if(spuAddr + iSize*2 < 0x80000)

   {

diff --git a/plugins/dfsound/externals.h b/plugins/dfsound/externals.h
index 2f3028e..9096399 100644
--- a/plugins/dfsound/externals.h
+++ b/plugins/dfsound/externals.h
@@ -46,10 +46,8 @@
 // num of channels

 #define MAXCHAN     24

 

-// ~ FRAG_MSECS ms of data

 // note: must be even due to the way reverb works now

-#define FRAG_MSECS 2

-#define NSSIZE ((44100 * FRAG_MSECS / 1000 + 1) & ~1)

+#define NSSIZE ((44100 / 50 + 16) & ~1)

 

 ///////////////////////////////////////////////////////////

 // struct defines

@@ -90,6 +88,7 @@ typedef struct
  int               iSBPos;                             // mixing stuff

  int               spos;

  int               sinc;

+ int               sinc_inv;

 

  unsigned char *   pCurr;                              // current pos in sound mem

  unsigned char *   pLoop;                              // loop ptr in sound mem

@@ -191,7 +190,6 @@ extern int        iUseReverb;
 extern int        iUseInterpolation;

 // MISC

 

-extern int had_dma;

 extern int decode_pos;

 

 extern SPUCHAN s_chan[];

@@ -209,11 +207,21 @@ extern unsigned int dwChannelDead;
 

 extern int      SSumR[];

 extern int      SSumL[];

-extern int      iCycle;

 extern short *  pS;

 

 extern void (CALLBACK *cddavCallback)(unsigned short,unsigned short);

 

+extern unsigned int cycles_played;

+

+void do_samples(unsigned int cycles_to);

+void schedule_next_irq(void);

+

+#define do_samples_if_needed(c) \

+ do { \

+  if ((int)((c) - cycles_played) >= 16 * 768) \

+   do_samples(c); \

+ } while (0)

+

 #endif

 

 ///////////////////////////////////////////////////////////

diff --git a/plugins/dfsound/freeze.c b/plugins/dfsound/freeze.c
index 0601bf5..9fa29f0 100644
--- a/plugins/dfsound/freeze.c
+++ b/plugins/dfsound/freeze.c
@@ -132,9 +132,7 @@ typedef struct
 ////////////////////////////////////////////////////////////////////////

 

 void LoadStateV5(SPUFreeze_t * pF);                    // newest version

-void LoadStateUnknown(SPUFreeze_t * pF);               // unknown format

-

-extern int lastch;

+void LoadStateUnknown(SPUFreeze_t * pF, uint32_t cycles); // unknown format

 

 // we want to retain compatibility between versions,

 // so use original channel struct

@@ -183,8 +181,10 @@ static void load_channel(SPUCHAN *d, const SPUCHAN_orig *s, int ch)
  memset(d, 0, sizeof(*d));

  if (s->bNew) dwNewChannel |= 1<<ch;

  d->iSBPos = s->iSBPos;

+ if ((uint32_t)d->iSBPos >= 28) d->iSBPos = 27;

  d->spos = s->spos;

  d->sinc = s->sinc;

+ d->sinc_inv = 0;

  memcpy(d->SB, s->SB, sizeof(d->SB));

  d->pCurr = (void *)((long)s->iCurr & 0x7fff0);

  d->pLoop = (void *)((long)s->iLoop & 0x7fff0);

@@ -212,11 +212,20 @@ static void load_channel(SPUCHAN *d, const SPUCHAN_orig *s, int ch)
  else d->ADSRX.EnvelopeVol = 0;

 }

 

+// force load from regArea to variables

+static void load_register(unsigned long reg, unsigned int cycles)

+{

+ unsigned short *r = &regArea[((reg & 0xfff) - 0xc00) >> 1];

+ *r ^= 1;

+ SPUwriteRegister(reg, *r ^ 1, cycles);

+}

+

 ////////////////////////////////////////////////////////////////////////

 // SPUFREEZE: called by main emu on savestate load/save

 ////////////////////////////////////////////////////////////////////////

 

-long CALLBACK SPUfreeze(uint32_t ulFreezeMode,SPUFreeze_t * pF)

+long CALLBACK SPUfreeze(uint32_t ulFreezeMode, SPUFreeze_t * pF,

+ uint32_t cycles)

 {

  int i;SPUOSSFreeze_t * pFO;

 

@@ -233,6 +242,8 @@ long CALLBACK SPUfreeze(uint32_t ulFreezeMode,SPUFreeze_t * pF)
 

    if(ulFreezeMode==2) return 1;                       // info mode? ok, bye

                                                        // save mode:

+   do_samples(cycles);

+

    memcpy(pF->cSPURam,spuMem,0x80000);                 // copy common infos

    memcpy(pF->cSPUPort,regArea,0x200);

 

@@ -276,26 +287,25 @@ long CALLBACK SPUfreeze(uint32_t ulFreezeMode,SPUFreeze_t * pF)
 

  if(!strcmp(pF->szSPUName,"PBOSS") && pF->ulFreezeVersion==5)

    LoadStateV5(pF);

- else LoadStateUnknown(pF);

-

- lastch = -1;

+ else LoadStateUnknown(pF, cycles);

 

  // repair some globals

  for(i=0;i<=62;i+=2)

-  SPUwriteRegister(H_Reverb+i,regArea[(H_Reverb+i-0xc00)>>1]);

- SPUwriteRegister(H_SPUReverbAddr,regArea[(H_SPUReverbAddr-0xc00)>>1]);

- SPUwriteRegister(H_SPUrvolL,regArea[(H_SPUrvolL-0xc00)>>1]);

- SPUwriteRegister(H_SPUrvolR,regArea[(H_SPUrvolR-0xc00)>>1]);

+  load_register(H_Reverb+i, cycles);

+ load_register(H_SPUReverbAddr, cycles);

+ load_register(H_SPUrvolL, cycles);

+ load_register(H_SPUrvolR, cycles);

 

- SPUwriteRegister(H_SPUctrl,(unsigned short)(regArea[(H_SPUctrl-0xc00)>>1]|0x4000));

- SPUwriteRegister(H_SPUstat,regArea[(H_SPUstat-0xc00)>>1]);

- SPUwriteRegister(H_CDLeft,regArea[(H_CDLeft-0xc00)>>1]);

- SPUwriteRegister(H_CDRight,regArea[(H_CDRight-0xc00)>>1]);

+ load_register(H_SPUctrl, cycles);

+ load_register(H_SPUstat, cycles);

+ load_register(H_CDLeft, cycles);

+ load_register(H_CDRight, cycles);

 

  // fix to prevent new interpolations from crashing

  for(i=0;i<MAXCHAN;i++) s_chan[i].SB[28]=0;

 

  ClearWorkingState();

+ cycles_played = cycles;

 

  return 1;

 }

@@ -331,7 +341,7 @@ void LoadStateV5(SPUFreeze_t * pF)
 

 ////////////////////////////////////////////////////////////////////////

 

-void LoadStateUnknown(SPUFreeze_t * pF)

+void LoadStateUnknown(SPUFreeze_t * pF, uint32_t cycles)

 {

  int i;

 

@@ -348,7 +358,7 @@ void LoadStateUnknown(SPUFreeze_t * pF)
 

  for(i=0;i<0xc0;i++)

   {

-   SPUwriteRegister(0x1f801c00+i*2,regArea[i]);

+   load_register(0x1f801c00 + i*2, cycles);

   }

 }

 

diff --git a/plugins/dfsound/oss.c b/plugins/dfsound/oss.c
index 709cb37..8093ae4 100644
--- a/plugins/dfsound/oss.c
+++ b/plugins/dfsound/oss.c
@@ -16,6 +16,7 @@
  ***************************************************************************/
 
 #include <stdio.h>
+#include <string.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
@@ -153,7 +154,20 @@ static int oss_busy(void)
 
 static void oss_feed(void *buf, int bytes)
 {
+ audio_buf_info info;
+ char sbuf[4096];
+
  if(oss_audio_fd == -1) return;
+ if(ioctl(oss_audio_fd,SNDCTL_DSP_GETOSPACE,&info)==0)
+  {
+   if(info.fragments==info.fragstotal)
+    {
+     memset(sbuf, 0, sizeof(sbuf));
+     write(oss_audio_fd, sbuf, sizeof(sbuf));
+     write(oss_audio_fd, sbuf, sizeof(sbuf));
+    }
+  }
+
  write(oss_audio_fd, buf, bytes);
 }
 
diff --git a/plugins/dfsound/registers.c b/plugins/dfsound/registers.c
index b9c1256..730c753 100644
--- a/plugins/dfsound/registers.c
+++ b/plugins/dfsound/registers.c
@@ -35,10 +35,28 @@ static void ReverbOn(int start,int end,unsigned short val);
 // WRITE REGISTERS: called by main emu

 ////////////////////////////////////////////////////////////////////////

 

-void CALLBACK SPUwriteRegister(unsigned long reg, unsigned short val)

+static const uint32_t ignore_dupe[8] = {

+ // ch 0-15  c40         c80         cc0

+ 0x7f7f7f7f, 0x7f7f7f7f, 0x7f7f7f7f, 0x7f7f7f7f,

+ // ch 16-24 d40         control     reverb

+ 0x7f7f7f7f, 0x7f7f7f7f, 0xff05ff0f, 0xffffffff

+};

+

+void CALLBACK SPUwriteRegister(unsigned long reg, unsigned short val,

+ unsigned int cycles)

 {

- const unsigned long r=reg&0xfff;

- regArea[(r-0xc00)>>1] = val;

+ int r = reg & 0xfff;

+ int rofs = (r - 0xc00) >> 1;

+ int changed = regArea[rofs] != val;

+ regArea[rofs] = val;

+

+ if (!changed && (ignore_dupe[rofs >> 5] & (1 << (rofs & 0x1f))))

+  return;

+ // zero keyon/keyoff?

+ if (val == 0 && (r & 0xff8) == 0xd88)

+  return;

+

+ do_samples_if_needed(cycles);

 

  if(r>=0x0c00 && r<0x0d80)                             // some channel info?

   {

@@ -56,7 +74,7 @@ void CALLBACK SPUwriteRegister(unsigned long reg, unsigned short val)
      //------------------------------------------------// pitch

      case 4:                                           

        SetPitch(ch,val);

-       break;

+       goto upd_irq;

      //------------------------------------------------// start

      case 6:      

        // taken from regArea later

@@ -93,7 +111,7 @@ void CALLBACK SPUwriteRegister(unsigned long reg, unsigned short val)
      //------------------------------------------------//

      case 14:                                          // loop?

        s_chan[ch].pLoop=spuMemC+((val&~1)<<3);

-       break;

+       goto upd_irq;

      //------------------------------------------------//

     }

    return;

@@ -113,8 +131,11 @@ void CALLBACK SPUwriteRegister(unsigned long reg, unsigned short val)
       break;

     //-------------------------------------------------//

     case H_SPUctrl:

-      if(!(spuCtrl & CTRL_IRQ))

+      if (!(spuCtrl & CTRL_IRQ)) {

         spuStat&=~STAT_IRQ;

+        if (val & CTRL_IRQ)

+         schedule_next_irq();

+      }

       spuCtrl=val;

       break;

     //-------------------------------------------------//

@@ -137,13 +158,12 @@ void CALLBACK SPUwriteRegister(unsigned long reg, unsigned short val)
             rvb.CurrAddr+=decode_pos/2;

          }

        }

-      rvb.dirty = 1;

-      break;

+      goto rvbd;

     //-------------------------------------------------//

     case H_SPUirqAddr:

       spuIrq = val;

       pSpuIrq=spuMemC+(((unsigned long) val<<3)&~0xf);

-      break;

+      goto upd_irq;

     //-------------------------------------------------//

     case H_SPUrvolL:

       rvb.VolLeft=val;

@@ -229,42 +249,48 @@ void CALLBACK SPUwriteRegister(unsigned long reg, unsigned short val)
       ReverbOn(16,24,val);

       break;

     //-------------------------------------------------//

-    case H_Reverb+0   : rvb.FB_SRC_A=val*4;            break;

-    case H_Reverb+2   : rvb.FB_SRC_B=val*4;            break;

-    case H_Reverb+4   : rvb.IIR_ALPHA=(short)val;      break;

-    case H_Reverb+6   : rvb.ACC_COEF_A=(short)val;     break;

-    case H_Reverb+8   : rvb.ACC_COEF_B=(short)val;     break;

-    case H_Reverb+10  : rvb.ACC_COEF_C=(short)val;     break;

-    case H_Reverb+12  : rvb.ACC_COEF_D=(short)val;     break;

-    case H_Reverb+14  : rvb.IIR_COEF=(short)val;       break;

-    case H_Reverb+16  : rvb.FB_ALPHA=(short)val;       break;

-    case H_Reverb+18  : rvb.FB_X=(short)val;           break;

-    case H_Reverb+20  : rvb.IIR_DEST_A0=val*4;         break;

-    case H_Reverb+22  : rvb.IIR_DEST_A1=val*4;         break;

-    case H_Reverb+24  : rvb.ACC_SRC_A0=val*4;          break;

-    case H_Reverb+26  : rvb.ACC_SRC_A1=val*4;          break;

-    case H_Reverb+28  : rvb.ACC_SRC_B0=val*4;          break;

-    case H_Reverb+30  : rvb.ACC_SRC_B1=val*4;          break;

-    case H_Reverb+32  : rvb.IIR_SRC_A0=val*4;          break;

-    case H_Reverb+34  : rvb.IIR_SRC_A1=val*4;          break;

-    case H_Reverb+36  : rvb.IIR_DEST_B0=val*4;         break;

-    case H_Reverb+38  : rvb.IIR_DEST_B1=val*4;         break;

-    case H_Reverb+40  : rvb.ACC_SRC_C0=val*4;          break;

-    case H_Reverb+42  : rvb.ACC_SRC_C1=val*4;          break;

-    case H_Reverb+44  : rvb.ACC_SRC_D0=val*4;          break;

-    case H_Reverb+46  : rvb.ACC_SRC_D1=val*4;          break;

-    case H_Reverb+48  : rvb.IIR_SRC_B1=val*4;          break;

-    case H_Reverb+50  : rvb.IIR_SRC_B0=val*4;          break;

-    case H_Reverb+52  : rvb.MIX_DEST_A0=val*4;         break;

-    case H_Reverb+54  : rvb.MIX_DEST_A1=val*4;         break;

-    case H_Reverb+56  : rvb.MIX_DEST_B0=val*4;         break;

-    case H_Reverb+58  : rvb.MIX_DEST_B1=val*4;         break;

-    case H_Reverb+60  : rvb.IN_COEF_L=(short)val;      break;

-    case H_Reverb+62  : rvb.IN_COEF_R=(short)val;      break;

+    case H_Reverb+0   : rvb.FB_SRC_A=val*4;         goto rvbd;

+    case H_Reverb+2   : rvb.FB_SRC_B=val*4;         goto rvbd;

+    case H_Reverb+4   : rvb.IIR_ALPHA=(short)val;   goto rvbd;

+    case H_Reverb+6   : rvb.ACC_COEF_A=(short)val;  goto rvbd;

+    case H_Reverb+8   : rvb.ACC_COEF_B=(short)val;  goto rvbd;

+    case H_Reverb+10  : rvb.ACC_COEF_C=(short)val;  goto rvbd;

+    case H_Reverb+12  : rvb.ACC_COEF_D=(short)val;  goto rvbd;

+    case H_Reverb+14  : rvb.IIR_COEF=(short)val;    goto rvbd;

+    case H_Reverb+16  : rvb.FB_ALPHA=(short)val;    goto rvbd;

+    case H_Reverb+18  : rvb.FB_X=(short)val;        goto rvbd;

+    case H_Reverb+20  : rvb.IIR_DEST_A0=val*4;      goto rvbd;

+    case H_Reverb+22  : rvb.IIR_DEST_A1=val*4;      goto rvbd;

+    case H_Reverb+24  : rvb.ACC_SRC_A0=val*4;       goto rvbd;

+    case H_Reverb+26  : rvb.ACC_SRC_A1=val*4;       goto rvbd;

+    case H_Reverb+28  : rvb.ACC_SRC_B0=val*4;       goto rvbd;

+    case H_Reverb+30  : rvb.ACC_SRC_B1=val*4;       goto rvbd;

+    case H_Reverb+32  : rvb.IIR_SRC_A0=val*4;       goto rvbd;

+    case H_Reverb+34  : rvb.IIR_SRC_A1=val*4;       goto rvbd;

+    case H_Reverb+36  : rvb.IIR_DEST_B0=val*4;      goto rvbd;

+    case H_Reverb+38  : rvb.IIR_DEST_B1=val*4;      goto rvbd;

+    case H_Reverb+40  : rvb.ACC_SRC_C0=val*4;       goto rvbd;

+    case H_Reverb+42  : rvb.ACC_SRC_C1=val*4;       goto rvbd;

+    case H_Reverb+44  : rvb.ACC_SRC_D0=val*4;       goto rvbd;

+    case H_Reverb+46  : rvb.ACC_SRC_D1=val*4;       goto rvbd;

+    case H_Reverb+48  : rvb.IIR_SRC_B1=val*4;       goto rvbd;

+    case H_Reverb+50  : rvb.IIR_SRC_B0=val*4;       goto rvbd;

+    case H_Reverb+52  : rvb.MIX_DEST_A0=val*4;      goto rvbd;

+    case H_Reverb+54  : rvb.MIX_DEST_A1=val*4;      goto rvbd;

+    case H_Reverb+56  : rvb.MIX_DEST_B0=val*4;      goto rvbd;

+    case H_Reverb+58  : rvb.MIX_DEST_B1=val*4;      goto rvbd;

+    case H_Reverb+60  : rvb.IN_COEF_L=(short)val;   goto rvbd;

+    case H_Reverb+62  : rvb.IN_COEF_R=(short)val;   goto rvbd;

    }

+ return;

+

+upd_irq:

+ if (spuCtrl & CTRL_IRQ)

+  schedule_next_irq();

+ return;

 

- if ((r & ~0x3f) == H_Reverb)

-  rvb.dirty = 1; // recalculate on next update

+rvbd:

+ rvb.dirty = 1; // recalculate on next update

 }

 

 ////////////////////////////////////////////////////////////////////////

@@ -484,6 +510,7 @@ static void SetPitch(int ch,unsigned short val)               // SET PITCH
 

  s_chan[ch].iRawPitch=NP;

  s_chan[ch].sinc=(NP<<4)|8;

+ s_chan[ch].sinc_inv=0;

  if(iUseInterpolation==1) s_chan[ch].SB[32]=1;         // -> freq change in simple interpolation mode: set flag

 }

 

diff --git a/plugins/dfsound/registers.h b/plugins/dfsound/registers.h
index cb95bc1..3bca518 100644
--- a/plugins/dfsound/registers.h
+++ b/plugins/dfsound/registers.h
@@ -152,5 +152,5 @@
 

 ///////////////////////////////////////////////////////////

 

-void CALLBACK SPUwriteRegister(unsigned long reg, unsigned short val);

+void CALLBACK SPUwriteRegister(unsigned long reg, unsigned short val, unsigned int cycles);

 

diff --git a/plugins/dfsound/reverb.c b/plugins/dfsound/reverb.c
index ebb709b..0a94ff4 100644
--- a/plugins/dfsound/reverb.c
+++ b/plugins/dfsound/reverb.c
@@ -53,21 +53,9 @@ INLINE void StartREVERB(int ch)
 // HELPER FOR NEILL'S REVERB: re-inits our reverb mixing buf

 ////////////////////////////////////////////////////////////////////////

 

-INLINE void InitREVERB(void)

+INLINE void InitREVERB(int ns_to)

 {

- memset(sRVBStart,0,NSSIZE*2*4);

-}

-

-////////////////////////////////////////////////////////////////////////

-// STORE REVERB

-////////////////////////////////////////////////////////////////////////

-

-INLINE void StoreREVERB(int ch,int ns,int l,int r)

-{

- ns<<=1;

-

- sRVBStart[ns]  +=l;                                   // -> we mix all active reverb channels into an extra buffer

- sRVBStart[ns+1]+=r;

+ memset(sRVBStart,0,ns_to*sizeof(sRVBStart[0])*2);

 }

 

 ////////////////////////////////////////////////////////////////////////

@@ -95,15 +83,15 @@ INLINE int rvb2ram_offs(int curr, int space, int iOff)
 ////////////////////////////////////////////////////////////////////////

 

 // portions based on spu2-x from PCSX2

-static void MixREVERB(void)

+static void MixREVERB(int ns_to)

 {

  int l_old = rvb.iRVBLeft;

  int r_old = rvb.iRVBRight;

  int curr_addr = rvb.CurrAddr;

  int space = 0x40000 - rvb.StartAddr;

- int l, r, ns;

+ int l = 0, r = 0, ns;

 

- for (ns = 0; ns < NSSIZE*2; )

+ for (ns = 0; ns < ns_to * 2; )

   {

    int IIR_ALPHA = rvb.IIR_ALPHA;

    int ACC0, ACC1, FB_A0, FB_A1, FB_B0, FB_B1;

@@ -180,15 +168,15 @@ static void MixREVERB(void)
  rvb.CurrAddr = curr_addr;

 }

 

-static void MixREVERB_off(void)

+static void MixREVERB_off(int ns_to)

 {

  int l_old = rvb.iRVBLeft;

  int r_old = rvb.iRVBRight;

  int curr_addr = rvb.CurrAddr;

  int space = 0x40000 - rvb.StartAddr;

- int l, r, ns;

+ int l = 0, r = 0, ns;

 

- for (ns = 0; ns < NSSIZE*2; )

+ for (ns = 0; ns < ns_to * 2; )

   {

    l = (g_buffer(MIX_DEST_A0) + g_buffer(MIX_DEST_B0)) / 2;

    r = (g_buffer(MIX_DEST_A1) + g_buffer(MIX_DEST_B1)) / 2;

@@ -258,7 +246,7 @@ static void prepare_offsets(void)
  rvb.dirty = 0;

 }

 

-INLINE void REVERBDo(void)

+INLINE void REVERBDo(int ns_to)

 {

  if (!rvb.StartAddr)                                   // reverb is off

  {

@@ -271,19 +259,19 @@ INLINE void REVERBDo(void)
   if (unlikely(rvb.dirty))

    prepare_offsets();

 

-  MixREVERB();

+  MixREVERB(ns_to);

  }

  else if (rvb.VolLeft || rvb.VolRight)

  {

   if (unlikely(rvb.dirty))

    prepare_offsets();

 

-  MixREVERB_off();

+  MixREVERB_off(ns_to);

  }

  else                                                  // -> reverb off

  {

   // reverb runs anyway

-  rvb.CurrAddr += NSSIZE/2;

+  rvb.CurrAddr += ns_to / 2;

   while (rvb.CurrAddr >= 0x40000)

    rvb.CurrAddr -= 0x40000 - rvb.StartAddr;

  }

diff --git a/plugins/dfsound/spu.c b/plugins/dfsound/spu.c
index 7d3f1a0..3d598db 100644
--- a/plugins/dfsound/spu.c
+++ b/plugins/dfsound/spu.c
@@ -49,6 +49,9 @@
 
 #define PSXCLK	33868800	/* 33.8688 MHz */
 
+// intended to be ~1 frame
+#define IRQ_NEAR_BLOCKS 32
+
 /*
 #if defined (USEMACOSX)
 static char * libraryName     = N_("Mac OS X Sound");
@@ -106,6 +109,7 @@ unsigned int dwChannelDead=0;                          // silent+not useful chan
 
 void (CALLBACK *irqCallback)(void)=0;                  // func of main emu, called on spu irq
 void (CALLBACK *cddavCallback)(unsigned short,unsigned short)=0;
+void (CALLBACK *scheduleCallback)(unsigned int)=0;
 
 // certain globals (were local before, but with the new timeproc I need em global)
 
@@ -117,15 +121,11 @@ static const int f[8][2] = {   {    0,  0  },
 int ChanBuf[NSSIZE+3];
 int SSumLR[(NSSIZE+3)*2];
 int iFMod[NSSIZE];
-int iCycle = 0;
 short * pS;
 
 static int decode_dirty_ch;
 int decode_pos;
-int had_dma;
-int lastch=-1;             // last channel processed on spu irq in timer mode
-static int lastns=0;       // last ns pos
-static int cycles_since_update;
+unsigned int cycles_played;
 
 #define CDDA_BUFFER_SIZE (16384 * sizeof(uint32_t)) // must be power of 2
 
@@ -518,8 +518,48 @@ static int skip_block(int ch)
  return ret;
 }
 
+// if irq is going to trigger sooner than in upd_samples, set upd_samples
+static void scan_for_irq(int ch, unsigned int *upd_samples)
+{
+ int pos, sinc, sinc_inv, end;
+ unsigned char *block;
+ int flags;
+
+ block = s_chan[ch].pCurr;
+ pos = s_chan[ch].spos;
+ sinc = s_chan[ch].sinc;
+ end = pos + *upd_samples * sinc;
+
+ pos += (28 - s_chan[ch].iSBPos) << 16;
+ while (pos < end)
+ {
+  if (block == pSpuIrq)
+   break;
+  flags = block[1];
+  block += 16;
+  if (flags & 1) {                          // 1: stop/loop
+   block = s_chan[ch].pLoop;
+   if (block == pSpuIrq)                    // hack.. (see decode_block)
+    break;
+  }
+  pos += 28 << 16;
+ }
+
+ if (pos < end)
+ {
+  sinc_inv = s_chan[ch].sinc_inv;
+  if (sinc_inv == 0)
+   sinc_inv = s_chan[ch].sinc_inv = (0x80000000u / (uint32_t)sinc) << 1;
+
+  pos -= s_chan[ch].spos;
+  *upd_samples = (((uint64_t)pos * sinc_inv) >> 32) + 1;
+  //xprintf("ch%02d: irq sched: %3d %03d\n",
+  // ch, *upd_samples, *upd_samples * 60 * 263 / 44100);
+ }
+}
+
 #define make_do_samples(name, fmod_code, interp_start, interp1_code, interp2_code, interp_end) \
-static int do_samples_##name(int ch, int ns, int ns_to) \
+static noinline int do_samples_##name(int ch, int ns, int ns_to) \
 {                                            \
  int sinc = s_chan[ch].sinc;                 \
  int spos = s_chan[ch].spos;                 \
@@ -533,23 +573,23 @@ static int do_samples_##name(int ch, int ns, int ns_to) \
  {                                           \
   fmod_code;                                 \
                                              \
+  spos += sinc;                              \
   while (spos >= 0x10000)                    \
   {                                          \
-   if(sbpos == 28)                           \
+   fa = SB[sbpos++];                         \
+   if(sbpos >= 28)                           \
    {                                         \
     sbpos = 0;                               \
     d = decode_block(ch);                    \
     if(d)                                    \
-     ret = ns_to = ns + 1;                   \
+     ret = /*ns_to =*/ ns + 1;               \
    }                                         \
                                              \
-   fa = SB[sbpos++];                         \
    interp1_code;                             \
    spos -= 0x10000;                          \
   }                                          \
                                              \
   interp2_code;                              \
-  spos += sinc;                              \
  }                                           \
                                              \
  s_chan[ch].sinc = sinc;                     \
@@ -585,7 +625,7 @@ make_do_samples(noint, , fa = s_chan[ch].SB[29], , ChanBuf[ns] = fa, s_chan[ch].
 make_do_samples(simple, , ,
   simple_interp_store, simple_interp_get, )
 
-static int do_samples_noise(int ch, int ns, int ns_to)
+static noinline int do_samples_noise(int ch, int ns, int ns_to)
 {
  int level, shift, bit;
  int ret = -1, d;
@@ -667,7 +707,7 @@ static void mix_chan_rvb(int start, int count, int lv, int rv)
 
 // 0x0800-0x0bff  Voice 1
 // 0x0c00-0x0fff  Voice 3
-static void noinline do_decode_bufs(int which, int start, int count)
+static noinline void do_decode_bufs(int which, int start, int count)
 {
  const int *src = ChanBuf + start;
  unsigned short *dst = &spuMem[0x800/2 + which*0x400/2];
@@ -689,57 +729,84 @@ static void noinline do_decode_bufs(int which, int start, int count)
 // basically the whole sound processing is done in this fat func!
 ////////////////////////////////////////////////////////////////////////
 
-static int do_samples(int forced_updates)
+void do_samples(unsigned int cycles_to)
 {
+ const int ns_from = 0;
+ int ns,ns_to,ns_len;
  int volmult = iVolume;
- int ns,ns_from,ns_to,ns_len;
  int ch,d,silentch;
- int bIRQReturn=0;
+ int cycle_diff;
 
- // ok, at the beginning we are looking if there is
- // enuff free place in the dsound/oss buffer to
- // fill in new data, or if there is a new channel to start.
- // if not, we return until enuff free place is available
- // /a new channel gets started
+ cycle_diff = cycles_to - cycles_played;
+ if (cycle_diff < -2*1048576 || cycle_diff > 2*1048576)
+  {
+   //xprintf("desync %u %d\n", cycles_to, cycle_diff);
+   cycles_played = cycles_to;
+   return;
+  }
 
- if(!forced_updates && out_current->busy())            // still enuff data in sound buffer?
-  return 0;
+ if (cycle_diff < 2 * 768)
+  return;
 
- while(!bIRQReturn)
-  {
-   ns_from=0;
-   ns_to=NSSIZE;
-   ch=0;
-   if(lastch>=0)                                       // will be -1 if no continue is pending
-    {
-     ch=lastch; ns_from=lastns; lastch=-1;             // -> setup all kind of vars to continue
-    }
+ ns_to = (cycle_diff / 768 + 1) & ~1;
+ if (ns_to > NSSIZE) {
+  // should never happen
+  //xprintf("ns_to oflow %d %d\n", ns_to, NSSIZE);
+  ns_to = NSSIZE;
+ }
+
+  //////////////////////////////////////////////////////
+  // special irq handling in the decode buffers (0x0000-0x1000)
+  // we know:
+  // the decode buffers are located in spu memory in the following way:
+  // 0x0000-0x03ff  CD audio left
+  // 0x0400-0x07ff  CD audio right
+  // 0x0800-0x0bff  Voice 1
+  // 0x0c00-0x0fff  Voice 3
+  // and decoded data is 16 bit for one sample
+  // we assume:
+  // even if voices 1/3 are off or no cd audio is playing, the internal
+  // play positions will move on and wrap after 0x400 bytes.
+  // Therefore: we just need a pointer from spumem+0 to spumem+3ff, and
+  // increase this pointer on each sample by 2 bytes. If this pointer
+  // (or 0x400 offsets of this pointer) hits the spuirq address, we generate
+  // an IRQ.
+
+  if (unlikely((spuCtrl & CTRL_IRQ) && pSpuIrq && pSpuIrq < spuMemC+0x1000))
+   {
+    int irq_pos = (pSpuIrq - spuMemC) / 2 & 0x1ff;
+    int left = (irq_pos - decode_pos) & 0x1ff;
+    if (0 < left && left <= ns_to)
+     {
+      //xprintf("decoder irq %x\n", decode_pos);
+      do_irq();
+      ns_to = left;
+     }
+   }
+
+  InitREVERB(ns_to);
 
+  {
    silentch=~(dwChannelOn|dwNewChannel);
 
    //--------------------------------------------------//
    //- main channel loop                              -// 
    //--------------------------------------------------//
     {
-     for(;ch<MAXCHAN;ch++)                             // loop em all... we will collect 1 ms of sound of each playing channel
+     for(ch=0;ch<MAXCHAN;ch++)                         // loop em all...
       {
        if(dwNewChannel&(1<<ch)) StartSound(ch);        // start new sound
        if(!(dwChannelOn&(1<<ch))) continue;            // channel not playing? next
 
        if(s_chan[ch].bNoise)
-        d=do_samples_noise(ch, ns_from, ns_to);
+        do_samples_noise(ch, ns_from, ns_to);
        else if(s_chan[ch].bFMod==2 || (s_chan[ch].bFMod==0 && iUseInterpolation==0))
-        d=do_samples_noint(ch, ns_from, ns_to);
+        do_samples_noint(ch, ns_from, ns_to);
        else if(s_chan[ch].bFMod==0 && iUseInterpolation==1)
-        d=do_samples_simple(ch, ns_from, ns_to);
+        do_samples_simple(ch, ns_from, ns_to);
        else
-        d=do_samples_default(ch, ns_from, ns_to);
-       if(d>=0)
-        {
-         bIRQReturn=1;
-         lastch=ch; 
-         lastns=ns_to=d;
-        }
+        do_samples_default(ch, ns_from, ns_to);
+
        ns_len = ns_to - ns_from;
 
        MixADSR(ch, ns_from, ns_to);
@@ -774,7 +841,6 @@ static int do_samples(int forced_updates)
         {
          unsigned char *start = s_chan[ch].pCurr;
 
-         // no need for bIRQReturn since the channel is silent
          skip_block(ch);
          if(start == s_chan[ch].pCurr || start - spuMemC < 0x1000)
           {
@@ -788,9 +854,6 @@ static int do_samples(int forced_updates)
         }
       }
 
-    if(bIRQReturn)                                     // special return for "spu irq - wait for cpu action"
-      return 0;
-
   if(unlikely(silentch & decode_dirty_ch & (1<<1)))    // must clear silent channel decode buffers
    {
     memset(&spuMem[0x800/2], 0, 0x400);
@@ -807,21 +870,21 @@ static int do_samples(int forced_updates)
   //---------------------------------------------------//
   // mix XA infos (if any)
 
-  MixXA();
+  MixXA(ns_to);
   
   ///////////////////////////////////////////////////////
   // mix all channels (including reverb) into one buffer
 
   if(iUseReverb)
-   REVERBDo();
+   REVERBDo(ns_to);
 
   if((spuCtrl&0x4000)==0) // muted? (rare, don't optimize for this)
    {
-    memset(pS, 0, NSSIZE * 2 * sizeof(pS[0]));
-    pS += NSSIZE*2;
+    memset(pS, 0, ns_to * 2 * sizeof(pS[0]));
+    pS += ns_to * 2;
    }
   else
-  for (ns = 0; ns < NSSIZE*2; )
+  for (ns = 0; ns < ns_to * 2; )
    {
     d = SSumLR[ns]; SSumLR[ns] = 0;
     d = d * volmult >> 10;
@@ -836,97 +899,70 @@ static int do_samples(int forced_updates)
     ns++;
    }
 
-   cycles_since_update -= PSXCLK / 44100 * NSSIZE;
+  cycles_played += ns_to * 768;
 
-  //////////////////////////////////////////////////////                   
-  // special irq handling in the decode buffers (0x0000-0x1000)
-  // we know: 
-  // the decode buffers are located in spu memory in the following way:
-  // 0x0000-0x03ff  CD audio left
-  // 0x0400-0x07ff  CD audio right
-  // 0x0800-0x0bff  Voice 1
-  // 0x0c00-0x0fff  Voice 3
-  // and decoded data is 16 bit for one sample
-  // we assume: 
-  // even if voices 1/3 are off or no cd audio is playing, the internal
-  // play positions will move on and wrap after 0x400 bytes.
-  // Therefore: we just need a pointer from spumem+0 to spumem+3ff, and 
-  // increase this pointer on each sample by 2 bytes. If this pointer
-  // (or 0x400 offsets of this pointer) hits the spuirq address, we generate
-  // an IRQ. Only problem: the "wait for cpu" option is kinda hard to do here
-  // in some of Peops timer modes. So: we ignore this option here (for now).
-
-  if(unlikely((spuCtrl&CTRL_IRQ) && pSpuIrq && pSpuIrq<spuMemC+0x1000))
-   {
-    int irq_pos=(pSpuIrq-spuMemC)/2 & 0x1ff;
-    if((decode_pos <= irq_pos && irq_pos < decode_pos+NSSIZE)
-       || (decode_pos+NSSIZE > 0x200 && irq_pos < ((decode_pos+NSSIZE) & 0x1ff)))
-     {
-      //printf("decoder irq %x\n", decode_pos);
-      do_irq();
-      bIRQReturn = 1;
-     }
-   }
-  decode_pos = (decode_pos + NSSIZE) & 0x1ff;
+  decode_pos = (decode_pos + ns_to) & 0x1ff;
+ }
+}
 
-  InitREVERB();
+void schedule_next_irq(void)
+{
+ unsigned int upd_samples;
+ int ch;
 
-  // feed the sound
-  // wanna have around 1/60 sec (16.666 ms) updates
-  if (iCycle++ >= 16/FRAG_MSECS)
-   {
-    out_current->feed(pSpuBuffer, (unsigned char *)pS - pSpuBuffer);
-    pS = (short *)pSpuBuffer;
-    iCycle = 0;
+ if (scheduleCallback == NULL)
+  return;
 
-    if(!forced_updates && out_current->busy())
-     break;
-   }
+ upd_samples = 44100 / 50;
 
-  if(forced_updates > 0)
-   {
-    forced_updates--;
-    if(forced_updates == 0 && out_current->busy())
-     break;
-   }
+ for (ch = 0; ch < MAXCHAN; ch++)
+ {
+  if (dwChannelDead & (1 << ch))
+   continue;
+  if ((unsigned long)(pSpuIrq - s_chan[ch].pCurr) > IRQ_NEAR_BLOCKS * 16
+    && (unsigned long)(pSpuIrq - s_chan[ch].pLoop) > IRQ_NEAR_BLOCKS * 16)
+   continue;
 
-  if(cycles_since_update <= -PSXCLK/60 / 4)
-   break;
+  scan_for_irq(ch, &upd_samples);
  }
 
- // this may cause desync, but help audio when the emu can't keep up..
- if(cycles_since_update < 0)
-  cycles_since_update = 0;
+ if (unlikely(pSpuIrq < spuMemC + 0x1000))
+ {
+  int irq_pos = (pSpuIrq - spuMemC) / 2 & 0x1ff;
+  int left = (irq_pos - decode_pos) & 0x1ff;
+  if (0 < left && left < upd_samples) {
+   //xprintf("decode: %3d (%3d/%3d)\n", left, decode_pos, irq_pos);
+   upd_samples = left;
+  }
+ }
 
- return 0;
+ if (upd_samples < 44100 / 50)
+  scheduleCallback(upd_samples * 768);
 }
 
 // SPU ASYNC... even newer epsxe func
 //  1 time every 'cycle' cycles... harhar
 
-// rearmed: called every 2ms now
+// rearmed: called dynamically now
 
-void CALLBACK SPUasync(unsigned long cycle)
+void CALLBACK SPUasync(unsigned int cycle, unsigned int flags)
 {
- int forced_updates = 0;
- int do_update = 0;
+ do_samples(cycle);
 
- if(!bSpuInit) return;                               // -> no init, no call
+ if (spuCtrl & CTRL_IRQ)
+  schedule_next_irq();
 
- cycles_since_update += cycle;
+ if (flags & 1) {
+  out_current->feed(pSpuBuffer, (unsigned char *)pS - pSpuBuffer);
+  pS = (short *)pSpuBuffer;
 
- if(dwNewChannel || had_dma)
-  {
-   forced_updates = 1;
-   do_update = 1;
-   had_dma = 0;
+  if (0) {
+   if (!out_current->busy())
+    // cause more samples to be generated
+    // (and break some games because of bad sync)
+    cycles_played -= 44100 / 60 / 2 * 768;
   }
-
- if(cycles_since_update > PSXCLK/60 * 5/4)
-  do_update = 1;
-
- if(do_update)
-  do_samples(forced_updates);
+ }
 }
 
 // SPU UPDATE... new epsxe func
@@ -940,7 +976,6 @@ void CALLBACK SPUasync(unsigned long cycle)
 
 void CALLBACK SPUupdate(void)
 {
- SPUasync(0);
 }
 
 // XA AUDIO
@@ -1003,6 +1038,7 @@ void SetupStreams(void)
 // slow us down:
 //   s_chan[i].hMutex=CreateMutex(NULL,FALSE,NULL);
    s_chan[i].ADSRX.SustainLevel = 0xf;                 // -> init sustain
+   s_chan[i].ADSRX.SustainIncrease = 1;
    s_chan[i].pLoop=spuMemC;
    s_chan[i].pCurr=spuMemC;
   }
@@ -1040,7 +1076,6 @@ long CALLBACK SPUinit(void)
  decode_pos = 0;
  memset((void *)s_chan, 0, (MAXCHAN + 1) * sizeof(SPUCHAN));
  pSpuIrq = 0;
- lastch = -1;
 
  SetupStreams();                                       // prepare streaming
 
@@ -1123,6 +1158,7 @@ void CALLBACK SPUregisterCDDAVolume(void (CALLBACK *CDDAVcallback)(unsigned shor
 
 void CALLBACK SPUregisterScheduleCb(void (CALLBACK *callback)(unsigned int))
 {
+ scheduleCallback = callback;
 }
 
 // COMMON PLUGIN INFO FUNCS
diff --git a/plugins/dfsound/xa.c b/plugins/dfsound/xa.c
index e58bca2..4c016aa 100644
--- a/plugins/dfsound/xa.c
+++ b/plugins/dfsound/xa.c
@@ -56,7 +56,7 @@ static int gauss_window[8] = {0, 0, 0, 0, 0, 0, 0, 0};
 // MIX XA & CDDA
 ////////////////////////////////////////////////////////////////////////
 
-INLINE void MixXA(void)
+INLINE void MixXA(int ns_to)
 {
  int ns;
  short l, r;
@@ -69,7 +69,7 @@ INLINE void MixXA(void)
    XARepeat--;
 
   v = XALastVal;
-  for(ns=0;ns<NSSIZE*2;)
+  for(ns = 0; ns < ns_to*2; )
    {
     if(XAPlay != XAFeed) v=*XAPlay++;
     if(XAPlay == XAEnd) XAPlay=XAStart;
@@ -86,7 +86,7 @@ INLINE void MixXA(void)
   XALastVal = v;
  }
 
- for(ns=0;ns<NSSIZE*2 && CDDAPlay!=CDDAFeed && (CDDAPlay!=CDDAEnd-1||CDDAFeed!=CDDAStart);)
+ for(ns = 0; ns < ns_to * 2 && CDDAPlay!=CDDAFeed && (CDDAPlay!=CDDAEnd-1||CDDAFeed!=CDDAStart);)
   {
    v=*CDDAPlay++;
    if(CDDAPlay==CDDAEnd) CDDAPlay=CDDAStart;
diff --git a/plugins/spunull/spunull.c b/plugins/spunull/spunull.c
index 4390be3..96bd390 100644
--- a/plugins/spunull/spunull.c
+++ b/plugins/spunull/spunull.c
@@ -59,7 +59,7 @@ void (CALLBACK *cddavCallback)(unsigned short,unsigned short)=0;
 // CODE AREA
 ////////////////////////////////////////////////////////////////////////
 
-void CALLBACK SPUwriteRegister(unsigned long reg, unsigned short val)
+void CALLBACK SPUwriteRegister(unsigned long reg, unsigned short val, unsigned int cycles)
 {
  unsigned long r=reg&0xfff;
  regArea[(r-0xc00)>>1] = val;
@@ -252,7 +252,7 @@ void CALLBACK SPUwriteDMA(unsigned short val)
 
 ////////////////////////////////////////////////////////////////////////
 
-void CALLBACK SPUwriteDMAMem(unsigned short * pusPSXMem,int iSize)
+void CALLBACK SPUwriteDMAMem(unsigned short * pusPSXMem,int iSize,unsigned int cycles)
 {
  int i;
  for(i=0;i<iSize;i++)
@@ -265,7 +265,7 @@ void CALLBACK SPUwriteDMAMem(unsigned short * pusPSXMem,int iSize)
 
 ////////////////////////////////////////////////////////////////////////
 
-void CALLBACK SPUreadDMAMem(unsigned short * pusPSXMem,int iSize)
+void CALLBACK SPUreadDMAMem(unsigned short * pusPSXMem,int iSize,unsigned int cycles)
 {
  int i;
  for(i=0;i<iSize;i++)
@@ -343,7 +343,7 @@ long CALLBACK SPUtest(void)
  return 0;
 }
 
-void SPUasync(unsigned int cycle)
+void SPUasync(unsigned int cycle, unsigned int flags)
 {
 }
 
@@ -413,7 +413,7 @@ typedef struct
 
 ////////////////////////////////////////////////////////////////////////

 
-long CALLBACK SPUfreeze(unsigned long ulFreezeMode,SPUFreeze_t * pF)
+long CALLBACK SPUfreeze(unsigned long ulFreezeMode,SPUFreeze_t * pF,unsigned int cycles)
 {
  int i;
 
@@ -445,10 +445,10 @@ long CALLBACK SPUfreeze(unsigned long ulFreezeMode,SPUFreeze_t * pF)
  for(i=0;i<0x100;i++)
   {
    if(i!=H_SPUon1-0xc00 && i!=H_SPUon2-0xc00)
-    SPUwriteRegister(0x1f801c00+i*2,regArea[i]);
+    SPUwriteRegister(0x1f801c00+i*2,regArea[i],cycles);
   }
- SPUwriteRegister(H_SPUon1,regArea[(H_SPUon1-0xc00)/2]);
- SPUwriteRegister(H_SPUon2,regArea[(H_SPUon2-0xc00)/2]);
+ SPUwriteRegister(H_SPUon1,regArea[(H_SPUon1-0xc00)/2],cycles);
+ SPUwriteRegister(H_SPUon2,regArea[(H_SPUon2-0xc00)/2],cycles);
 
  return 1;
 }