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 4759f3f..8f6ed13 100644 (file)
--- a/plugins/dfsound/spu.c
+++ b/plugins/dfsound/spu.c
@@ -5,7 +5,7 @@
     copyright            : (C) 2002 by Pete Bernert
     email                : BlackDove@addcom.de
 
     copyright            : (C) 2002 by Pete Bernert
     email                : BlackDove@addcom.de
 

- Portions (C) Gražvydas "notaz" Ignotas, 2010-2011
+ Portions (C) Gražvydas "notaz" Ignotas, 2010-2012

 
  ***************************************************************************/
 /***************************************************************************
 
  ***************************************************************************/
 /***************************************************************************


@@ -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"
 


@@ -250,6 +252,26 @@ INLINE void InterpolateDown(int ch)
 
 #include "xa.c"
 
 
 #include "xa.c"
 

+static void do_irq(void)
+{
+ //if(!(spuStat & STAT_IRQ))
+ {
+  spuStat |= STAT_IRQ;                                 // asserted status?
+  if(irqCallback) irqCallback();
+ }
+}
+
+static int check_irq(int ch, unsigned char *pos)
+{
+ if((spuCtrl & CTRL_IRQ) && pos == pSpuIrq)
+ {
+  //printf("ch%d irq %04x\n", ch, pos - spuMemC);
+  do_irq();
+  return 1;
+ }
+ return 0;
+}
+

 ////////////////////////////////////////////////////////////////////////
 // START SOUND... called by main thread to setup a new sound on a channel
 ////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////
 // START SOUND... called by main thread to setup a new sound on a channel
 ////////////////////////////////////////////////////////////////////////


@@ -365,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;


@@ -390,15 +412,6 @@ INLINE int iGetInterpolationVal(int ch, int spos)
  return fa;
 }
 
  return fa;
 }
 

-static void do_irq(void)
-{
- //if(!(spuStat & STAT_IRQ))
- {
-  spuStat |= STAT_IRQ;                                 // asserted status?
-  if(irqCallback) irqCallback();
- }
-}
-

 static void decode_block_data(int *dest, const unsigned char *src, int predict_nr, int shift_factor)
 {
  int nSample;
 static void decode_block_data(int *dest, const unsigned char *src, int predict_nr, int shift_factor)
 {
  int nSample;


@@ -431,26 +444,28 @@ 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
- if(dwPendingChanOff&(1<<ch))
+ start = s_chan[ch].pCurr;                 // set up the current pos
+ if(start == spuMemC)                      // ?
+  stop = 1;
+
+ if(s_chan[ch].prevflags&1)                // 1: stop/loop

  {
  {

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

 
 

- //////////////////////////////////////////// irq check
+  start = s_chan[ch].pLoop;
+ }
+ else
+  ret = check_irq(ch, start);              // hack, see check_irq below..

 
 

- if(spuCtrl&CTRL_IRQ)
+ if(stop)

  {
  {

-  if(pSpuIrq == start)                     // irq address reached?
-  {
-   do_irq();                               // -> call main emu
-   ret = 1;
-  }
+  dwChannelOn &= ~(1<<ch);                 // -> turn everything off
+  s_chan[ch].bStop = 1;
+  s_chan[ch].ADSRX.EnvelopeVol = 0;

  }
 
  predict_nr=(int)start[0];
  }
 
  predict_nr=(int)start[0];


@@ -459,29 +474,22 @@ static int decode_block(int ch)
 
  decode_block_data(s_chan[ch].SB, start + 2, predict_nr, shift_factor);
 
 
  decode_block_data(s_chan[ch].SB, start + 2, predict_nr, shift_factor);
 

- //////////////////////////////////////////// flag handler
-

  flags=(int)start[1];
  if(flags&4)
   s_chan[ch].pLoop=start;                  // loop adress
 
  start+=16;
  flags=(int)start[1];
  if(flags&4)
   s_chan[ch].pLoop=start;                  // loop adress
 
  start+=16;

- if(flags&1)                               // 1: stop/loop
- {
-  if(!(flags&2))
-   dwPendingChanOff|=1<<ch;

 
 

+ 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) {
-  // most likely wrong
+ if (start - spuMemC >= 0x80000)

   start = spuMemC;
   start = spuMemC;

-  printf("ch%d oflow\n", ch);
- }

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

- s_chan[ch].bJump = flags & 1;
+ s_chan[ch].prevflags = flags;

 
  return ret;
 }
 
  return ret;
 }


@@ -491,23 +499,22 @@ 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 = 0;
+ int ret = check_irq(ch, start);

 
 

- if(start == pSpuIrq)
- {
-  do_irq();
-  ret = 1;
- }
+ if(s_chan[ch].prevflags & 1)
+  start = s_chan[ch].pLoop;

 
  if(flags & 4)
   s_chan[ch].pLoop = start;
 
 
  if(flags & 4)
   s_chan[ch].pLoop = start;
 

- s_chan[ch].pCurr += 16;
+ start += 16;

 
  if(flags & 1)
 
  if(flags & 1)

-  s_chan[ch].pCurr = s_chan[ch].pLoop;
+  start = s_chan[ch].pLoop;
+
+ s_chan[ch].pCurr = start;
+ s_chan[ch].prevflags = flags;

 
 

- s_chan[ch].bJump = flags & 1;

  return ret;
 }
 
  return ret;
 }
 


@@ -533,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++];                         \


@@ -548,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;                  \


@@ -585,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;
  }
 


@@ -613,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);


@@ -659,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...


@@ -668,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;


@@ -724,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);

       }
     }
 
       }
     }
 


@@ -756,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;


@@ -771,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


@@ -806,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: 


@@ -824,35 +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)
+  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)))

      {
      {

-      if((spuCtrl&0x40) && pSpuIrq && pSpuIrq<spuMemC+0x1000)                 
-       {
-        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;
 }
 


@@ -877,7 +922,6 @@ void CALLBACK SPUasync(unsigned long cycle)
    had_dma = 0;
   }
 
    had_dma = 0;
   }
 

- // once per frame should be fine (using a bit more because of BIAS)

  if(cycles_since_update > PSXCLK/60 * 5/4)
   do_update = 1;
 
  if(cycles_since_update > PSXCLK/60 * 5/4)
   do_update = 1;
 


@@ -963,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


@@ -995,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;


@@ -1024,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;
 }