X-Git-Url: https://notaz.gp2x.de/cgi-bin/gitweb.cgi?p=pcsx_rearmed.git;a=blobdiff_plain;f=plugins%2Fdfsound%2Fspu.c;h=79e534cd5da246976935acfa9e7d6642a51dbfc8;hp=e289b86196177ba13850d3522dc359e200a9ecba;hb=1ab7621a76d1ef82fde77322c12d4076889bed01;hpb=e11ae5c58194de196c57ba0a2107d6eec5c0394a

diff --git a/plugins/dfsound/spu.c b/plugins/dfsound/spu.c
index e289b861..79e534cd 100644
--- a/plugins/dfsound/spu.c
+++ b/plugins/dfsound/spu.c
@@ -20,6 +20,7 @@
 #define _IN_SPU
 
 #include "externals.h"
+#include "registers.h"
 #include "cfg.h"
 #include "dsoundoss.h"
 #include "regs.h"
@@ -95,6 +96,7 @@ static pthread_t thread = (pthread_t)-1;               // thread id (linux)
 
 unsigned long dwNewChannel=0;                          // flags for faster testing, if new channel starts
 unsigned long dwChannelOn=0;
+unsigned long dwPendingChanOff=0;
 
 void (CALLBACK *irqCallback)(void)=0;                  // func of main emu, called on spu irq
 void (CALLBACK *cddavCallback)(unsigned short,unsigned short)=0;
@@ -106,6 +108,7 @@ static const int f[8][2] = {   {    0,  0  },
                         {  115, -52 },
                         {   98, -55 },
                         {  122, -60 } };
+int ChanBuf[NSSIZE];
 int SSumLR[NSSIZE*2];
 int iFMod[NSSIZE];
 int iCycle = 0;
@@ -423,6 +426,15 @@ INLINE int iGetInterpolationVal(int ch)
  return fa;
 }
 
+static void do_irq(void)
+{
+ if(!(spuStat & STAT_IRQ))
+ {
+  spuStat |= STAT_IRQ;
+  if(irqCallback) irqCallback();
+ }
+}
+
 static int decode_block(int ch)
 {
  unsigned char *start;
@@ -434,15 +446,26 @@ static int decode_block(int ch)
  s_chan[ch].iSBPos=0;
 
  start=s_chan[ch].pCurr;                   // set up the current pos
- if (start == (unsigned char*)-1)          // special "stop" sign
+ if(start == (unsigned char*)-1 ||         // special "stop" sign
+    (dwPendingChanOff&(1<<ch)))
  {
   dwChannelOn&=~(1<<ch);                   // -> turn everything off
+  dwPendingChanOff&=~(1<<ch);
   s_chan[ch].bStop=1;
   s_chan[ch].ADSRX.EnvelopeVol=0;
   return 0;                                // -> and done for this channel
  }
 
- //////////////////////////////////////////// spu irq handler here? mmm... do it later
+ //////////////////////////////////////////// irq check
+
+ if(spuCtrl&CTRL_IRQ)
+ {
+  if(pSpuIrq == start)                     // irq address reached?
+  {
+   do_irq();                               // -> call main emu
+   ret = 1;
+  }
+ }
 
  s_1=s_chan[ch].s_1;
  s_2=s_chan[ch].s_2;
@@ -475,21 +498,6 @@ static int decode_block(int ch)
   s_chan[ch].SB[nSample++]=fa;
  }
 
- //////////////////////////////////////////// irq check
-
- if(irqCallback && (spuCtrl&0x40))         // some callback and irq active?
- {
-  if((pSpuIrq >  start-16 &&              // irq address reached?
-     pSpuIrq <= start) ||
-    ((flags&1) &&                        // special: irq on looping addr, when stop/loop flag is set 
-     (pSpuIrq >  s_chan[ch].pLoop-16 &&
-      pSpuIrq <= s_chan[ch].pLoop)))
-  {
-   irqCallback();                        // -> call main emu
-   ret = 1;
-  }
- }
-
  //////////////////////////////////////////// flag handler
 
  if((flags&4) && (!s_chan[ch].bIgnoreLoop))
@@ -497,16 +505,10 @@ static int decode_block(int ch)
 
  if(flags&1)                               // 1: stop/loop
  {
-  // We play this block out first...
-  //if(!(flags&2))                         // 1+2: do loop... otherwise: stop
-  if(flags!=3 && flags!=7)                 // PETE: if we don't check exactly for 3, loop hang ups will happen (DQ4, for example)
-  {
-   start = (unsigned char*)-1;
-  }
-  else
-  {
-   start = s_chan[ch].pLoop;
-  }
+  if(!(flags&2))
+   dwPendingChanOff|=1<<ch;
+
+  start = s_chan[ch].pLoop;
  }
 
  if (start - spuMemC >= 0x80000)
@@ -596,8 +598,6 @@ static void *MAINThread(void *arg)
 
        for(ns=ns_from;ns<ns_to;ns++)                   // loop until 1 ms of data is reached
         {
-         int sval;
-
          if(!(dwChannelOn&(1<<ch))) break;             // something turned ch off (adsr or flags)
 
          if(s_chan[ch].bFMod==1 && iFMod[ns])          // fmod freq channel
@@ -627,12 +627,23 @@ static void *MAINThread(void *arg)
          if(s_chan[ch].bNoise)
               fa=iGetNoiseVal(ch);                     // get noise val
          else fa=iGetInterpolationVal(ch);             // get sample val
+         ChanBuf[ns]=fa;
+
+         ////////////////////////////////////////////////
+         // ok, go on until 1 ms data of this channel is collected
+
+         s_chan[ch].spos += s_chan[ch].sinc;
+ENDX: ;
+        }
+
+       MixADSR(ch, ns_from, ns_to);
 
-         sval = (MixADSR(ch) * fa) / 1024;  // mix adsr
+       if(s_chan[ch].bFMod==2)                         // fmod freq channel
+        memcpy(iFMod, ChanBuf, sizeof(iFMod));
+       else for(ns=ns_from;ns<ns_to;ns++)
+        {
+         int sval = ChanBuf[ns];
 
-         if(s_chan[ch].bFMod==2)                       // fmod freq channel
-          iFMod[ns]=sval;                              // -> store 1T sample data, use that to do fmod on next channel
-         else                                          // no fmod freq channel
           {
            //////////////////////////////////////////////
            // ok, left/right sound volume (psx volume goes from 0 ... 0x3fff)
@@ -645,15 +656,56 @@ static void *MAINThread(void *arg)
 
            if(s_chan[ch].bRVBActive) StoreREVERB(ch,ns,sval);
           }
+        }
+      }
+    }
 
-         ////////////////////////////////////////////////
-         // ok, go on until 1 ms data of this channel is collected
+    // advance "stopped" channels that can cause irqs
+    // (all chans are always playing on the real thing..)
+    if(!bIRQReturn && (spuCtrl&CTRL_IRQ))
+     for(ch=0;ch<MAXCHAN;ch++)
+      {
+       if(dwChannelOn&(1<<ch)) continue;               // already handled
+       if(s_chan[ch].pCurr == (unsigned char *)-1)
+        continue;
+       if(s_chan[ch].pCurr > pSpuIrq && s_chan[ch].pLoop > pSpuIrq)
+        continue;
 
-         s_chan[ch].spos += s_chan[ch].sinc;
+       if(s_chan[ch].iActFreq!=s_chan[ch].iUsedFreq)   // new psx frequency?
+         VoiceChangeFrequency(ch);
+
+       s_chan[ch].spos += s_chan[ch].sinc * NSSIZE;
+       while(s_chan[ch].spos >= 28 * 0x10000)
+        {
+         unsigned char *start=s_chan[ch].pCurr;
+         int flags = start[1];
+
+         // Tron Bonne hack, probably wrong (could be wrong memory contents..)
+         if(flags & ~7) flags = 0;
+
+         if(start == pSpuIrq)
+          {
+           do_irq();
+           bIRQReturn = 1;
+          }
+         else if((flags & 1) && start == s_chan[ch].pLoop)
+          {
+           // looping on self
+           s_chan[ch].pCurr=(unsigned char *)-1;
+           break;
+          }
+
+         if((flags&4) && !s_chan[ch].bIgnoreLoop)
+          s_chan[ch].pLoop=start;
+
+         s_chan[ch].pCurr += 16;
+
+         if(flags & 1)
+          s_chan[ch].pCurr = s_chan[ch].pLoop;
+
+         s_chan[ch].spos -= 28 * 0x10000;
         }
-ENDX: ;
       }
-    }
 
     if(bIRQReturn && iSPUIRQWait)                      // special return for "spu irq - wait for cpu action"
      {
@@ -720,7 +772,7 @@ ENDX: ;
   // 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 && irqCallback)
+  if(pMixIrq)
    {
     for(ns=0;ns<NSSIZE;ns++)
      {
@@ -729,7 +781,7 @@ ENDX: ;
         for(ch=0;ch<4;ch++)
          {
           if(pSpuIrq>=pMixIrq+(ch*0x400) && pSpuIrq<pMixIrq+(ch*0x400)+2)
-           irqCallback();
+           do_irq();
          }
        }
       pMixIrq+=2;if(pMixIrq>spuMemC+0x3ff) pMixIrq=spuMemC;
@@ -1027,4 +1079,24 @@ char * SPUgetLibInfos(void)
 }
 */
 
+// debug
+void spu_get_debug_info(int *chans_out, int *fmod_chans_out, int *noise_chans_out)
+{
+ int ch = 0, fmod_chans = 0, noise_chans = 0;
+
+ for(;ch<MAXCHAN;ch++)
+ {
+  if (!(dwChannelOn & (1<<ch)))
+   continue;
+  if (s_chan[ch].bFMod == 2)
+   fmod_chans |= 1 << ch;
+  if (s_chan[ch].bNoise)
+   noise_chans |= 1 << ch;
+ }
+
+ *chans_out = dwChannelOn;
+ *fmod_chans_out = fmod_chans;
+ *noise_chans_out = noise_chans;
+}
+
 // vim:shiftwidth=1:expandtab