spu: fix some fmod related breakage

[pcsx_rearmed.git] / plugins / dfsound / spu.c

diff --git a/plugins/dfsound/spu.c b/plugins/dfsound/spu.c
index d5a8215..8f6ed13 100644 (file)
--- a/plugins/dfsound/spu.c
+++ b/plugins/dfsound/spu.c
@@ -24,7 +24,8 @@
 
 #include "externals.h"
 #include "registers.h"
 
 #include "externals.h"
 #include "registers.h"

-#include "dsoundoss.h"
+#include "out.h"
+#include "arm_features.h"

 
 #ifdef ENABLE_NLS
 #include <libintl.h>
 
 #ifdef ENABLE_NLS
 #include <libintl.h>


@@ -75,7 +76,6 @@ unsigned short  spuMem[256*1024];
 unsigned char * spuMemC;
 unsigned char * pSpuIrq=0;
 unsigned char * pSpuBuffer;
 unsigned char * spuMemC;
 unsigned char * pSpuIrq=0;
 unsigned char * pSpuBuffer;

-unsigned char * pMixIrq=0;

 
 // user settings
 
 
 // user settings
 


@@ -120,6 +120,8 @@ int iFMod[NSSIZE];
 int iCycle = 0;
 short * pS;
 
 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
 int had_dma;
 int lastch=-1;             // last channel processed on spu irq in timer mode
 static int lastns=0;       // last ns pos


@@ -242,7 +244,7 @@ INLINE void InterpolateDown(int ch)
 // helpers for gauss interpolation
 
 #define gval0 (((short*)(&s_chan[ch].SB[29]))[gpos])
 // helpers for gauss interpolation
 
 #define gval0 (((short*)(&s_chan[ch].SB[29]))[gpos])

-#define gval(x) (((short*)(&s_chan[ch].SB[29]))[(gpos+x)&3])
+#define gval(x) ((int)((short*)(&s_chan[ch].SB[29]))[(gpos+x)&3])

 
 #include "gauss_i.h"
 
 
 #include "gauss_i.h"
 


@@ -295,8 +297,6 @@ INLINE void StartSound(int ch)
       {s_chan[ch].spos=0x30000L;s_chan[ch].SB[28]=0;}  // -> start with more decoding
  else {s_chan[ch].spos=0x10000L;s_chan[ch].SB[31]=0;}  // -> no/simple interpolation starts with one 44100 decoding
 
       {s_chan[ch].spos=0x30000L;s_chan[ch].SB[28]=0;}  // -> start with more decoding
  else {s_chan[ch].spos=0x10000L;s_chan[ch].SB[31]=0;}  // -> no/simple interpolation starts with one 44100 decoding
 

- check_irq(ch, s_chan[ch].pCurr);                      // just in case
-

  dwNewChannel&=~(1<<ch);                               // clear new channel bit
 }
 
  dwNewChannel&=~(1<<ch);                               // clear new channel bit
 }
 


@@ -387,7 +387,7 @@ INLINE int iGetInterpolationVal(int ch, int spos)
      int vl, vr;int gpos;
      vl = (spos >> 6) & ~3;
      gpos = s_chan[ch].SB[28];
      int vl, vr;int gpos;
      vl = (spos >> 6) & ~3;
      gpos = s_chan[ch].SB[28];

-     vr=(gauss[vl]*gval0)&~2047;
+     vr=(gauss[vl]*(int)gval0)&~2047;

      vr+=(gauss[vl+1]*gval(1))&~2047;
      vr+=(gauss[vl+2]*gval(2))&~2047;
      vr+=(gauss[vl+3]*gval(3))&~2047;
      vr+=(gauss[vl+1]*gval(1))&~2047;
      vr+=(gauss[vl+2]*gval(2))&~2047;
      vr+=(gauss[vl+3]*gval(3))&~2047;


@@ -444,21 +444,29 @@ static int decode_block(int ch)
 {
  unsigned char *start;
  int predict_nr,shift_factor,flags;
 {
  unsigned char *start;
  int predict_nr,shift_factor,flags;

+ int stop = 0;

  int ret = 0;
 
  int ret = 0;
 

- start=s_chan[ch].pCurr;                   // set up the current pos
+ start = s_chan[ch].pCurr;                 // set up the current pos
+ if(start == spuMemC)                      // ?
+  stop = 1;

 
  if(s_chan[ch].prevflags&1)                // 1: stop/loop
  {
   if(!(s_chan[ch].prevflags&2))
 
  if(s_chan[ch].prevflags&1)                // 1: stop/loop
  {
   if(!(s_chan[ch].prevflags&2))

-  {
-   dwChannelOn&=~(1<<ch);                  // -> turn everything off
-   s_chan[ch].bStop=1;
-   s_chan[ch].ADSRX.EnvelopeVol=0;
-  }
+   stop = 1;

 
   start = s_chan[ch].pLoop;
  }
 
   start = s_chan[ch].pLoop;
  }

+ else
+  ret = check_irq(ch, start);              // hack, see check_irq below..
+
+ if(stop)
+ {
+  dwChannelOn &= ~(1<<ch);                 // -> turn everything off
+  s_chan[ch].bStop = 1;
+  s_chan[ch].ADSRX.EnvelopeVol = 0;
+ }

 
  predict_nr=(int)start[0];
  shift_factor=predict_nr&0xf;
 
  predict_nr=(int)start[0];
  shift_factor=predict_nr&0xf;


@@ -472,14 +480,14 @@ static int decode_block(int ch)
 
  start+=16;
 
 
  start+=16;
 

- if(flags&1)                               // 1: stop/loop
+ if(flags&1) {                             // 1: stop/loop

   start = s_chan[ch].pLoop;
   start = s_chan[ch].pLoop;

+  ret |= check_irq(ch, start);             // hack.. :(
+ }

 
  if (start - spuMemC >= 0x80000)
   start = spuMemC;
 
 
  if (start - spuMemC >= 0x80000)
   start = spuMemC;
 

- ret = check_irq(ch, start);
-

  s_chan[ch].pCurr = start;                 // store values for next cycle
  s_chan[ch].prevflags = flags;
 
  s_chan[ch].pCurr = start;                 // store values for next cycle
  s_chan[ch].prevflags = flags;
 


@@ -491,6 +499,7 @@ static int skip_block(int ch)
 {
  unsigned char *start = s_chan[ch].pCurr;
  int flags = start[1];
 {
  unsigned char *start = s_chan[ch].pCurr;
  int flags = start[1];

+ int ret = check_irq(ch, start);

 
  if(s_chan[ch].prevflags & 1)
   start = s_chan[ch].pLoop;
 
  if(s_chan[ch].prevflags & 1)
   start = s_chan[ch].pLoop;


@@ -506,7 +515,7 @@ static int skip_block(int ch)
  s_chan[ch].pCurr = start;
  s_chan[ch].prevflags = flags;
 
  s_chan[ch].pCurr = start;
  s_chan[ch].prevflags = flags;
 

- return check_irq(ch, start);
+ return ret;

 }
 
 #define make_do_samples(name, fmod_code, interp_start, interp1_code, interp2_code, interp_end) \
 }
 
 #define make_do_samples(name, fmod_code, interp_start, interp1_code, interp2_code, interp_end) \


@@ -531,10 +540,7 @@ static int do_samples_##name(int ch, int ns, int ns_to) \
     sbpos = 0;                               \
     d = decode_block(ch);                    \
     if(d)                                    \
     sbpos = 0;                               \
     d = decode_block(ch);                    \
     if(d)                                    \

-    {                                        \
-     ret = ns;                               \
-     goto out;                               \
-    }                                        \
+     ret = ns_to = ns + 1;                   \

    }                                         \
                                              \
    fa = SB[sbpos++];                         \
    }                                         \
                                              \
    fa = SB[sbpos++];                         \


@@ -546,7 +552,6 @@ static int do_samples_##name(int ch, int ns, int ns_to) \
   spos += sinc;                              \
  }                                           \
                                              \
   spos += sinc;                              \
  }                                           \
                                              \

-out:                                         \

  s_chan[ch].sinc = sinc;                     \
  s_chan[ch].spos = spos;                     \
  s_chan[ch].iSBPos = sbpos;                  \
  s_chan[ch].sinc = sinc;                     \
  s_chan[ch].spos = spos;                     \
  s_chan[ch].iSBPos = sbpos;                  \


@@ -583,11 +588,14 @@ make_do_samples(simple, , ,
 static int do_samples_noise(int ch, int ns, int ns_to)
 {
  int level, shift, bit;
 static int do_samples_noise(int ch, int ns, int ns_to)
 {
  int level, shift, bit;

+ int ret = -1, d;

 
  s_chan[ch].spos += s_chan[ch].sinc * (ns_to - ns);
  while (s_chan[ch].spos >= 28*0x10000)
  {
 
  s_chan[ch].spos += s_chan[ch].sinc * (ns_to - ns);
  while (s_chan[ch].spos >= 28*0x10000)
  {

-  skip_block(ch);
+  d = skip_block(ch);
+  if (d)
+   ret = ns_to;

   s_chan[ch].spos -= 28*0x10000;
  }
 
   s_chan[ch].spos -= 28*0x10000;
  }
 


@@ -611,10 +619,10 @@ static int do_samples_noise(int ch, int ns, int ns_to)
   ChanBuf[ns] = (signed short)dwNoiseVal;
  }
 
   ChanBuf[ns] = (signed short)dwNoiseVal;
  }
 

- return -1;
+ return ret;

 }
 
 }
 

-#ifdef __arm__
+#ifdef HAVE_ARMV5

 // asm code; lv and rv must be 0-3fff
 extern void mix_chan(int start, int count, int lv, int rv);
 extern void mix_chan_rvb(int start, int count, int lv, int rv);
 // asm code; lv and rv must be 0-3fff
 extern void mix_chan(int start, int count, int lv, int rv);
 extern void mix_chan_rvb(int start, int count, int lv, int rv);


@@ -657,6 +665,24 @@ static void mix_chan_rvb(int start, int count, int lv, int rv)
 }
 #endif
 
 }
 #endif
 

+// 0x0800-0x0bff  Voice 1
+// 0x0c00-0x0fff  Voice 3
+static void noinline do_decode_bufs(int which, int start, int count)
+{
+ const int *src = ChanBuf + start;
+ unsigned short *dst = &spuMem[0x800/2 + which*0x400/2];
+ int cursor = decode_pos + start;
+
+ while (count-- > 0)
+  {
+   cursor &= 0x1ff;
+   dst[cursor] = *src++;
+   cursor++;
+  }
+
+ // decode_pos is updated and irqs are checked later, after voice loop
+}
+

 ////////////////////////////////////////////////////////////////////////
 // MAIN SPU FUNCTION
 // here is the main job handler...
 ////////////////////////////////////////////////////////////////////////
 // MAIN SPU FUNCTION
 // here is the main job handler...


@@ -666,30 +692,21 @@ static void mix_chan_rvb(int start, int count, int lv, int rv)
 static int do_samples(int forced_updates)
 {
  int volmult = iVolume;
 static int do_samples(int forced_updates)
 {
  int volmult = iVolume;

- int ns,ns_from,ns_to;
+ int ns,ns_from,ns_to,ns_len;

  int ch,d,silentch;
  int bIRQReturn=0;
 
  int ch,d,silentch;
  int bIRQReturn=0;
 

- while(1)
-  {
-   // 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 wait (thread) or return (timer/spuasync)
-   // until enuff free place is available/a new channel gets
-   // started
-
-   if(!forced_updates && SoundGetBytesBuffered())      // still enuff data in sound buffer?
-    {
-     return 0;
-    }
-
-   cycles_since_update = 0;
-   if(forced_updates > 0)
-    forced_updates--;
+ // 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

 
 

-   //--------------------------------------------------// continue from irq handling in timer mode? 
+ if(!forced_updates && out_current->busy())            // still enuff data in sound buffer?
+  return 0;

 
 

+ while(!bIRQReturn)
+  {

    ns_from=0;
    ns_to=NSSIZE;
    ch=0;
    ns_from=0;
    ns_to=NSSIZE;
    ch=0;


@@ -722,18 +739,23 @@ static int do_samples(int forced_updates)
          bIRQReturn=1;
          lastch=ch; 
          lastns=ns_to=d;
          bIRQReturn=1;
          lastch=ch; 
          lastns=ns_to=d;

-         if(d==0)
-          break;

         }
         }

+       ns_len = ns_to - ns_from;

 
        MixADSR(ch, ns_from, ns_to);
 
 
        MixADSR(ch, ns_from, ns_to);
 

+       if(ch==1 || ch==3)
+        {
+         do_decode_bufs(ch/2, ns_from, ns_len);
+         decode_dirty_ch |= 1<<ch;
+        }
+

        if(s_chan[ch].bFMod==2)                         // fmod freq channel
        if(s_chan[ch].bFMod==2)                         // fmod freq channel

-        memcpy(iFMod, ChanBuf, sizeof(iFMod));
-       else if(s_chan[ch].bRVBActive)
-        mix_chan_rvb(ns_from,ns_to-ns_from,s_chan[ch].iLeftVolume,s_chan[ch].iRightVolume);
+        memcpy(&iFMod[ns_from], &ChanBuf[ns_from], ns_len * sizeof(iFMod[0]));
+       if(s_chan[ch].bRVBActive)
+        mix_chan_rvb(ns_from, ns_len, s_chan[ch].iLeftVolume, s_chan[ch].iRightVolume);

        else
        else

-        mix_chan(ns_from,ns_to-ns_from,s_chan[ch].iLeftVolume,s_chan[ch].iRightVolume);
+        mix_chan(ns_from, ns_len, s_chan[ch].iLeftVolume, s_chan[ch].iRightVolume);

       }
     }
 
       }
     }
 


@@ -754,9 +776,9 @@ static int do_samples(int forced_updates)
 
          // no need for bIRQReturn since the channel is silent
          skip_block(ch);
 
          // no need for bIRQReturn since the channel is silent
          skip_block(ch);

-         if(start == s_chan[ch].pCurr)
+         if(start == s_chan[ch].pCurr || start - spuMemC < 0x1000)

           {
           {

-           // looping on self
+           // looping on self or stopped(?)

            dwChannelDead |= 1<<ch;
            s_chan[ch].spos = 0;
            break;
            dwChannelDead |= 1<<ch;
            s_chan[ch].spos = 0;
            break;


@@ -769,6 +791,16 @@ static int do_samples(int forced_updates)
     if(bIRQReturn)                                     // special return for "spu irq - wait for cpu action"
       return 0;
 
     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);
+    decode_dirty_ch &= ~(1<<1);
+   }
+  if(unlikely(silentch & decode_dirty_ch & (1<<3)))
+   {
+    memset(&spuMem[0xc00/2], 0, 0x400);
+    decode_dirty_ch &= ~(1<<3);
+   }

 
   //---------------------------------------------------//
   //- here we have another 1 ms of sound data
 
   //---------------------------------------------------//
   //- here we have another 1 ms of sound data


@@ -804,6 +836,8 @@ static int do_samples(int forced_updates)
     ns++;
    }
 
     ns++;
    }
 

+   cycles_since_update -= PSXCLK / 44100 * NSSIZE;
+

   //////////////////////////////////////////////////////                   
   // special irq handling in the decode buffers (0x0000-0x1000)
   // we know: 
   //////////////////////////////////////////////////////                   
   // special irq handling in the decode buffers (0x0000-0x1000)
   // we know: 


@@ -822,32 +856,48 @@ static int do_samples(int forced_updates)
   // 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).
 
   // 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(pMixIrq && (spuCtrl&CTRL_IRQ) && pSpuIrq && pSpuIrq<spuMemC+0x1000)                 
+  if(unlikely((spuCtrl&CTRL_IRQ) && pSpuIrq && pSpuIrq<spuMemC+0x1000))

    {
    {

-    for(ns=0;ns<NSSIZE;ns++)
+    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)))

      {
      {

-        for(ch=0;ch<4;ch++)
-         {
-          if(pSpuIrq>=pMixIrq+(ch*0x400) && pSpuIrq<pMixIrq+(ch*0x400)+2)
-           do_irq();
-         }
-      pMixIrq+=2;if(pMixIrq>spuMemC+0x3ff) pMixIrq=spuMemC;
+      //printf("decoder irq %x\n", decode_pos);
+      do_irq();
+      bIRQReturn = 1;

      }
    }
      }
    }

+  decode_pos = (decode_pos + NSSIZE) & 0x1ff;

 
   InitREVERB();
 
   // feed the sound
   // wanna have around 1/60 sec (16.666 ms) updates
 
   InitREVERB();
 
   // feed the sound
   // wanna have around 1/60 sec (16.666 ms) updates

-  if (iCycle++ > 16/FRAG_MSECS)
+  if (iCycle++ >= 16/FRAG_MSECS)

    {
    {

-    SoundFeedStreamData((unsigned char *)pSpuBuffer,
-                        ((unsigned char *)pS) - ((unsigned char *)pSpuBuffer));
+    out_current->feed(pSpuBuffer, (unsigned char *)pS - pSpuBuffer);

     pS = (short *)pSpuBuffer;
     iCycle = 0;
     pS = (short *)pSpuBuffer;
     iCycle = 0;

+
+    if(!forced_updates && out_current->busy())
+     break;
+   }
+
+  if(forced_updates > 0)
+   {
+    forced_updates--;
+    if(forced_updates == 0 && out_current->busy())
+     break;

    }
    }

+
+  if(cycles_since_update <= -PSXCLK/60 / 4)
+   break;

  }
 
  }
 

+ // this may cause desync, but help audio when the emu can't keep up..
+ if(cycles_since_update < 0)
+  cycles_since_update = 0;
+

  return 0;
 }
 
  return 0;
 }
 


@@ -858,7 +908,6 @@ static int do_samples(int forced_updates)
 
 void CALLBACK SPUasync(unsigned long cycle)
 {
 
 void CALLBACK SPUasync(unsigned long cycle)
 {

- static int old_ctrl;

  int forced_updates = 0;
  int do_update = 0;
 
  int forced_updates = 0;
  int do_update = 0;
 


@@ -873,17 +922,9 @@ void CALLBACK SPUasync(unsigned long cycle)
    had_dma = 0;
   }
 
    had_dma = 0;
   }
 

- if((spuCtrl&CTRL_IRQ) && (((spuCtrl^old_ctrl)&CTRL_IRQ) // irq was enabled
-    || cycles_since_update > PSXCLK/60 / 4)) {
-  do_update = 1;
-  forced_updates = cycles_since_update / (PSXCLK/44100) / NSSIZE;
- }
- // with no irqs, once per frame should be fine (using a bit more because of BIAS)
- else if(cycles_since_update > PSXCLK/60 * 5/4)
+ if(cycles_since_update > PSXCLK/60 * 5/4)

   do_update = 1;
 
   do_update = 1;
 

- old_ctrl = spuCtrl;
-

  if(do_update)
   do_samples(forced_updates);
 }
  if(do_update)
   do_samples(forced_updates);
 }


@@ -966,8 +1007,6 @@ void SetupStreams(void)
    s_chan[i].pCurr=spuMemC;
   }
 
    s_chan[i].pCurr=spuMemC;
   }
 

- pMixIrq=spuMemC;                                      // enable decoded buffer irqs by setting the address
-

  ClearWorkingState();
 
  bSpuInit=1;                                           // flag: we are inited
  ClearWorkingState();
 
  bSpuInit=1;                                           // flag: we are inited


@@ -998,7 +1037,7 @@ long CALLBACK SPUinit(void)
  spuIrq = 0;
  spuAddr = 0xffffffff;
  spuMemC = (unsigned char *)spuMem;
  spuIrq = 0;
  spuAddr = 0xffffffff;
  spuMemC = (unsigned char *)spuMem;

- pMixIrq = 0;
+ decode_pos = 0;

  memset((void *)s_chan, 0, (MAXCHAN + 1) * sizeof(SPUCHAN));
  pSpuIrq = 0;
  lastch = -1;
  memset((void *)s_chan, 0, (MAXCHAN + 1) * sizeof(SPUCHAN));
  pSpuIrq = 0;
  lastch = -1;


@@ -1027,7 +1066,7 @@ long CALLBACK SPUclose(void)
 
  bSPUIsOpen = 0;                                       // no more open
 
 
  bSPUIsOpen = 0;                                       // no more open
 

- RemoveSound();                                        // no more sound handling
+ out_current->finish();                                // no more sound handling

 
  return 0;
 }
 
  return 0;
 }