X-Git-Url: https://notaz.gp2x.de/cgi-bin/gitweb.cgi?p=pcsx_rearmed.git;a=blobdiff_plain;f=plugins%2Fdfsound%2Fregisters.c;h=b9c1256a11d1a6ff8f6e6fc356026eee68769b2b;hp=f6c30588e3854215748fa5939073299633b51ed1;hb=fa56d36096cd4ab2b227ce2aa61c8404b8874689;hpb=174c454a98a71475b72958c9f76293af7d6fb502

diff --git a/plugins/dfsound/registers.c b/plugins/dfsound/registers.c
index f6c30588..b9c1256a 100644
--- a/plugins/dfsound/registers.c
+++ b/plugins/dfsound/registers.c
@@ -21,25 +21,15 @@
 
 #include "externals.h"
 #include "registers.h"
-#include "regs.h"
 
-/*
-// adsr time values (in ms) by James Higgs ... see the end of
-// the adsr.c source for details
-
-#define ATTACK_MS     514L
-#define DECAYHALF_MS  292L
-#define DECAY_MS      584L
-#define SUSTAIN_MS    450L
-#define RELEASE_MS    446L
-*/
-
-// we have a timebase of 1.020408f ms, not 1 ms... so adjust adsr defines
-#define ATTACK_MS      494L
-#define DECAYHALF_MS   286L
-#define DECAY_MS       572L
-#define SUSTAIN_MS     441L
-#define RELEASE_MS     437L
+static void SoundOn(int start,int end,unsigned short val);
+static void SoundOff(int start,int end,unsigned short val);
+static void FModOn(int start,int end,unsigned short val);
+static void NoiseOn(int start,int end,unsigned short val);
+static void SetVolumeL(unsigned char ch,short vol);
+static void SetVolumeR(unsigned char ch,short vol);
+static void SetPitch(int ch,unsigned short val);
+static void ReverbOn(int start,int end,unsigned short val);
 
 ////////////////////////////////////////////////////////////////////////
 // WRITE REGISTERS: called by main emu
@@ -69,8 +59,7 @@ void CALLBACK SPUwriteRegister(unsigned long reg, unsigned short val)
        break;
      //------------------------------------------------// start
      case 6:      
-       // Brain Dead 13 - align to 16 boundary
-       s_chan[ch].pStart= spuMemC+(unsigned long)((val<<3)&~0xf);
+       // taken from regArea later
        break;
      //------------------------------------------------// level with pre-calcs
      case 8:
@@ -82,35 +71,6 @@ void CALLBACK SPUwriteRegister(unsigned long reg, unsigned short val)
         s_chan[ch].ADSRX.DecayRate=(lval>>4) & 0x000f;
         s_chan[ch].ADSRX.SustainLevel=lval & 0x000f;
         //---------------------------------------------//
-#if 0
-        if(!iDebugMode) break;
-        //---------------------------------------------// stuff below is only for debug mode
-
-        s_chan[ch].ADSR.AttackModeExp=(lval&0x8000)?1:0;        //0x007f
-
-        lx=(((lval>>8) & 0x007f)>>2);                  // attack time to run from 0 to 100% volume
-        lx=min(31,lx);                                 // no overflow on shift!
-        if(lx) 
-         { 
-          lx = (1<<lx);
-          if(lx<2147483) lx=(lx*ATTACK_MS)/10000L;     // another overflow check
-          else           lx=(lx/10000L)*ATTACK_MS;
-          if(!lx) lx=1;
-         }
-        s_chan[ch].ADSR.AttackTime=lx;                
-
-        s_chan[ch].ADSR.SustainLevel=                 // our adsr vol runs from 0 to 1024, so scale the sustain level
-         (1024*((lval) & 0x000f))/15;
-
-        lx=(lval>>4) & 0x000f;                         // decay:
-        if(lx)                                         // our const decay value is time it takes from 100% to 0% of volume
-         {
-          lx = ((1<<(lx))*DECAY_MS)/10000L;
-          if(!lx) lx=1;
-         }
-        s_chan[ch].ADSR.DecayTime =                   // so calc how long does it take to run from 100% to the wanted sus level
-         (lx*(1024-s_chan[ch].ADSR.SustainLevel))/1024;
-#endif
        }
       break;
      //------------------------------------------------// adsr times with pre-calcs
@@ -125,39 +85,6 @@ void CALLBACK SPUwriteRegister(unsigned long reg, unsigned short val)
        s_chan[ch].ADSRX.ReleaseModeExp = (lval&0x0020)?1:0;
        s_chan[ch].ADSRX.ReleaseRate = lval & 0x001f;
        //----------------------------------------------//
-#if 0
-       if(!iDebugMode) break;
-       //----------------------------------------------// stuff below is only for debug mode
-
-       s_chan[ch].ADSR.SustainModeExp = (lval&0x8000)?1:0;
-       s_chan[ch].ADSR.ReleaseModeExp = (lval&0x0020)?1:0;
-                   
-       lx=((((lval>>6) & 0x007f)>>2));                 // sustain time... often very high
-       lx=min(31,lx);                                  // values are used to hold the volume
-       if(lx)                                          // until a sound stop occurs
-        {                                              // the highest value we reach (due to 
-         lx = (1<<lx);                                 // overflow checking) is: 
-         if(lx<2147483) lx=(lx*SUSTAIN_MS)/10000L;     // 94704 seconds = 1578 minutes = 26 hours... 
-         else           lx=(lx/10000L)*SUSTAIN_MS;     // should be enuff... if the stop doesn't 
-         if(!lx) lx=1;                                 // come in this time span, I don't care :)
-        }
-       s_chan[ch].ADSR.SustainTime = lx;
-
-       lx=(lval & 0x001f);
-       s_chan[ch].ADSR.ReleaseVal     =lx;
-       if(lx)                                          // release time from 100% to 0%
-        {                                              // note: the release time will be
-         lx = (1<<lx);                                 // adjusted when a stop is coming,
-         if(lx<2147483) lx=(lx*RELEASE_MS)/10000L;     // so at this time the adsr vol will 
-         else           lx=(lx/10000L)*RELEASE_MS;     // run from (current volume) to 0%
-         if(!lx) lx=1;
-        }
-       s_chan[ch].ADSR.ReleaseTime=lx;
-
-       if(lval & 0x4000)                               // add/dec flag
-            s_chan[ch].ADSR.SustainModeDec=-1;
-       else s_chan[ch].ADSR.SustainModeDec=1;
-#endif
       }
      break;
      //------------------------------------------------// adsr volume... mmm have to investigate this
@@ -165,15 +92,10 @@ void CALLBACK SPUwriteRegister(unsigned long reg, unsigned short val)
        break;
      //------------------------------------------------//
      case 14:                                          // loop?
-       //WaitForSingleObject(s_chan[ch].hMutex,2000);        // -> no multithread fuckups
-       s_chan[ch].pLoop=spuMemC+((unsigned long)((val<<3)&~0xf));
-       //s_chan[ch].bIgnoreLoop=1;
-       //ReleaseMutex(s_chan[ch].hMutex);                    // -> oki, on with the thread
-       dwChannelDead&=~(1<<ch);
+       s_chan[ch].pLoop=spuMemC+((val&~1)<<3);
        break;
      //------------------------------------------------//
     }
-   iSpuAsyncWait=0;
    return;
   }
 
@@ -210,6 +132,9 @@ void CALLBACK SPUwriteRegister(unsigned long reg, unsigned short val)
          {
           rvb.StartAddr=(unsigned long)val<<2;
           rvb.CurrAddr=rvb.StartAddr;
+          // sync-with-decode-buffers hack..
+          if(rvb.StartAddr==0x3ff00)
+            rvb.CurrAddr+=decode_pos/2;
          }
        }
       rvb.dirty = 1;
@@ -340,8 +265,6 @@ void CALLBACK SPUwriteRegister(unsigned long reg, unsigned short val)
 
  if ((r & ~0x3f) == H_Reverb)
   rvb.dirty = 1; // recalculate on next update
-
- iSpuAsyncWait=0;
 }
 
 ////////////////////////////////////////////////////////////////////////
@@ -352,8 +275,6 @@ unsigned short CALLBACK SPUreadRegister(unsigned long reg)
 {
  const unsigned long r=reg&0xfff;
         
- iSpuAsyncWait=0;
-
  if(r>=0x0c00 && r<0x0d80)
   {
    switch(r&0x0f)
@@ -413,20 +334,20 @@ unsigned short CALLBACK SPUreadRegister(unsigned long reg)
 // SOUND ON register write
 ////////////////////////////////////////////////////////////////////////
 
-void SoundOn(int start,int end,unsigned short val)     // SOUND ON PSX COMAND
+static void SoundOn(int start,int end,unsigned short val)
 {
  int ch;
 
  for(ch=start;ch<end;ch++,val>>=1)                     // loop channels
   {
-   if((val&1) && s_chan[ch].pStart)                    // mmm... start has to be set before key on !?!
+   if((val&1) && regAreaGet(ch,6))                     // mmm... start has to be set before key on !?!
     {
-     s_chan[ch].bIgnoreLoop=0;
-
      // do this here, not in StartSound
      // - fixes fussy timing issues
      s_chan[ch].bStop=0;
-     s_chan[ch].pCurr=s_chan[ch].pStart;
+     s_chan[ch].pCurr=spuMemC+((regAreaGet(ch,6)&~1)<<3); // must be block aligned
+     s_chan[ch].pLoop=spuMemC+((regAreaGet(ch,14)&~1)<<3);
+     s_chan[ch].prevflags=2;
 
      dwNewChannel|=(1<<ch);                            // bitfield for faster testing
      dwChannelOn|=1<<ch;
@@ -439,7 +360,7 @@ void SoundOn(int start,int end,unsigned short val)     // SOUND ON PSX COMAND
 // SOUND OFF register write
 ////////////////////////////////////////////////////////////////////////
 
-void SoundOff(int start,int end,unsigned short val)    // SOUND OFF PSX COMMAND
+static void SoundOff(int start,int end,unsigned short val)
 {
  int ch;
  for(ch=start;ch<end;ch++,val>>=1)                     // loop channels
@@ -459,7 +380,7 @@ void SoundOff(int start,int end,unsigned short val)    // SOUND OFF PSX COMMAND
 // FMOD register write
 ////////////////////////////////////////////////////////////////////////
 
-void FModOn(int start,int end,unsigned short val)      // FMOD ON PSX COMMAND
+static void FModOn(int start,int end,unsigned short val)
 {
  int ch;
 
@@ -486,7 +407,7 @@ void FModOn(int start,int end,unsigned short val)      // FMOD ON PSX COMMAND
 // NOISE register write
 ////////////////////////////////////////////////////////////////////////
 
-void NoiseOn(int start,int end,unsigned short val)     // NOISE ON PSX COMMAND
+static void NoiseOn(int start,int end,unsigned short val)
 {
  int ch;
 
@@ -503,7 +424,7 @@ void NoiseOn(int start,int end,unsigned short val)     // NOISE ON PSX COMMAND
 // please note: sweep and phase invert are wrong... but I've never seen
 // them used
 
-void SetVolumeL(unsigned char ch,short vol)            // LEFT VOLUME
+static void SetVolumeL(unsigned char ch,short vol)     // LEFT VOLUME
 {
  if(vol&0x8000)                                        // sweep?
   {
@@ -529,7 +450,7 @@ void SetVolumeL(unsigned char ch,short vol)            // LEFT VOLUME
 // RIGHT VOLUME register write
 ////////////////////////////////////////////////////////////////////////
 
-void SetVolumeR(unsigned char ch,short vol)            // RIGHT VOLUME
+static void SetVolumeR(unsigned char ch,short vol)     // RIGHT VOLUME
 {
  if(vol&0x8000)                                        // comments... see above :)
   {
@@ -555,24 +476,22 @@ void SetVolumeR(unsigned char ch,short vol)            // RIGHT VOLUME
 // PITCH register write
 ////////////////////////////////////////////////////////////////////////
 
-void SetPitch(int ch,unsigned short val)               // SET PITCH
+static void SetPitch(int ch,unsigned short val)               // SET PITCH
 {
  int NP;
  if(val>0x3fff) NP=0x3fff;                             // get pitch val
  else           NP=val;
 
  s_chan[ch].iRawPitch=NP;
-
- NP=(44100L*NP)/4096L;                                 // calc frequency
- if(NP<1) NP=1;                                        // some security
- s_chan[ch].iActFreq=NP;                               // store frequency
+ s_chan[ch].sinc=(NP<<4)|8;
+ if(iUseInterpolation==1) s_chan[ch].SB[32]=1;         // -> freq change in simple interpolation mode: set flag
 }
 
 ////////////////////////////////////////////////////////////////////////
 // REVERB register write
 ////////////////////////////////////////////////////////////////////////
 
-void ReverbOn(int start,int end,unsigned short val)    // REVERB ON PSX COMMAND
+static void ReverbOn(int start,int end,unsigned short val)
 {
  int ch;