[BACK]Return to sound.c CVS log [TXT] [DIR] Up to [RetroPC.NET] / np2 / sound

Diff for /np2/sound/sound.c between versions 1.4 and 1.12

version 1.4, 2003/10/20 06:36:33 version 1.12, 2004/01/13 05:30:59
Line 1 Line 1
 #include        "compiler.h"  #include        "compiler.h"
 #include        "soundmng.h"  #include        "soundmng.h"
 #include        "i286.h"  #include        "cpucore.h"
 #include        "pccore.h"  #include        "pccore.h"
 #include        "iocore.h"  #include        "iocore.h"
 #include        "sound.h"  #include        "sound.h"
 #include        "sndcsec.h"  #include        "sndcsec.h"
 #include        "beep.h"  #include        "beep.h"
   
   
         SOUNDCFG        soundcfg;          SOUNDCFG        soundcfg;
   
   
Line 22  typedef struct { Line 21  typedef struct {
         SINT32  *buffer;          SINT32  *buffer;
         SINT32  *ptr;          SINT32  *ptr;
         UINT    samples;          UINT    samples;
           UINT    reserve;
         UINT    remain;          UINT    remain;
         CBTBL   *cbreg;          CBTBL   *cbreg;
         CBTBL   cb[STREAM_CBMAX];          CBTBL   cb[STREAM_CBMAX];
Line 32  static SNDSTREAM sndstream; Line 32  static SNDSTREAM sndstream;
   
 static void streamreset(void) {  static void streamreset(void) {
   
           SNDCSEC_ENTER;
         sndstream.ptr = sndstream.buffer;          sndstream.ptr = sndstream.buffer;
         sndstream.remain = sndstream.samples;          sndstream.remain = sndstream.samples + sndstream.reserve;
         sndstream.cbreg = sndstream.cb;          sndstream.cbreg = sndstream.cb;
           SNDCSEC_LEAVE;
 }  }
   
 static void streamprepare(UINT samples) {  static void streamprepare(UINT samples) {
Line 61  static void streamprepare(UINT samples)  Line 63  static void streamprepare(UINT samples) 
 BOOL sound_create(UINT rate, UINT ms) {  BOOL sound_create(UINT rate, UINT ms) {
   
         UINT    samples;          UINT    samples;
           UINT    reserve;
   
         ZeroMemory(&sndstream, sizeof(sndstream));          ZeroMemory(&sndstream, sizeof(sndstream));
         switch(rate) {          switch(rate) {
Line 81  BOOL sound_create(UINT rate, UINT ms) { Line 84  BOOL sound_create(UINT rate, UINT ms) {
         soundcfg.rate = rate;          soundcfg.rate = rate;
         sound_changeclock();          sound_changeclock();
   
         sndstream.buffer = (SINT32 *)_MALLOC(samples * 2 * sizeof(SINT32),  #if defined(SOUNDRESERVE)
                                                                                                                                 "stream");          reserve = rate * SOUNDRESERVE / 1000;
   #else
           reserve = 0;
   #endif
           sndstream.buffer = (SINT32 *)_MALLOC((samples + reserve) * 2 
                                                                                                   * sizeof(SINT32), "stream");
         if (sndstream.buffer == NULL) {          if (sndstream.buffer == NULL) {
                 goto scre_err2;                  goto scre_err2;
         }          }
         sndstream.samples = samples;          sndstream.samples = samples;
         streamreset();          sndstream.reserve = reserve;
   
         SNDCSEC_INIT;          SNDCSEC_INIT;
           streamreset();
         return(SUCCESS);          return(SUCCESS);
   
 scre_err2:  scre_err2:
Line 102  scre_err1: Line 111  scre_err1:
 void sound_destroy(void) {  void sound_destroy(void) {
   
         if (sndstream.buffer) {          if (sndstream.buffer) {
                 SNDCSEC_TERM;  
   
                 soundmng_stop();                  soundmng_stop();
                   streamreset();
                 soundmng_destroy();                  soundmng_destroy();
                   SNDCSEC_TERM;
                 _MFREE(sndstream.buffer);                  _MFREE(sndstream.buffer);
                 sndstream.buffer = NULL;                  sndstream.buffer = NULL;
         }          }
Line 116  void sound_reset(void) { Line 125  void sound_reset(void) {
         if (sndstream.buffer) {          if (sndstream.buffer) {
                 soundmng_reset();                  soundmng_reset();
                 streamreset();                  streamreset();
                 soundcfg.lastclock = I286_CLOCK;                  soundcfg.lastclock = CPU_CLOCK;
                 beep_eventreset();                  beep_eventreset();
         }          }
 }  }
Line 132  void sound_changeclock(void) { Line 141  void sound_changeclock(void) {
         }          }
   
         // とりあえず 25で割り切れる。          // とりあえず 25で割り切れる。
         clock = pc.realclock / 25;          clock = pccore.realclock / 25;
         hz = soundcfg.rate / 25;          hz = soundcfg.rate / 25;
   
         // で、クロック数に合せて調整。(64bit演算しろよな的)          // で、クロック数に合せて調整。(64bit演算しろよな的)
Line 144  void sound_changeclock(void) { Line 153  void sound_changeclock(void) {
         soundcfg.hzbase = hz;          soundcfg.hzbase = hz;
         soundcfg.clockbase = clock;          soundcfg.clockbase = clock;
         soundcfg.minclock = 2 * clock / hz;          soundcfg.minclock = 2 * clock / hz;
         soundcfg.lastclock = I286_CLOCK;          soundcfg.lastclock = CPU_CLOCK;
 }  }
   
 void sound_streamregist(void *hdl, SOUNDCB cbfn) {  void sound_streamregist(void *hdl, SOUNDCB cbfn) {
Line 170  void sound_sync(void) { Line 179  void sound_sync(void) {
                 return;                  return;
         }          }
   
         length = I286_CLOCK + I286_BASECLOCK - I286_REMCLOCK - soundcfg.lastclock;          length = CPU_CLOCK + CPU_BASECLOCK - CPU_REMCLOCK - soundcfg.lastclock;
         if (length < soundcfg.minclock) {          if (length < soundcfg.minclock) {
                 return;                  return;
         }          }
Line 180  void sound_sync(void) { Line 189  void sound_sync(void) {
         }          }
         SNDCSEC_ENTER;          SNDCSEC_ENTER;
         streamprepare(length);          streamprepare(length);
         SNDCSEC_LEAVE;  
         soundcfg.writecount += length;  
         soundcfg.lastclock += length * soundcfg.clockbase / soundcfg.hzbase;          soundcfg.lastclock += length * soundcfg.clockbase / soundcfg.hzbase;
         beep_eventreset();          beep_eventreset();
           SNDCSEC_LEAVE;
   
           soundcfg.writecount += length;
         if (soundcfg.writecount >= 100) {          if (soundcfg.writecount >= 100) {
                 soundcfg.writecount = 0;                  soundcfg.writecount = 0;
                 soundmng_sync();                  soundmng_sync();
         }          }
 }  }
   
   static volatile int locks = 0;
   
 const SINT32 *sound_pcmlock(void) {  const SINT32 *sound_pcmlock(void) {
   
 const SINT32 *ret;  const SINT32 *ret;
   
           if (locks) {
                   TRACEOUT(("sound pcm lock: already locked"));
                   return(NULL);
           }
           locks++;
         ret = sndstream.buffer;          ret = sndstream.buffer;
         if (ret) {          if (ret) {
                 SNDCSEC_ENTER;                  SNDCSEC_ENTER;
                 if (sndstream.remain) {                  if (sndstream.remain > sndstream.reserve) {
                         streamprepare(sndstream.remain);                          streamprepare(sndstream.remain - sndstream.reserve);
                         soundcfg.lastclock = I286_CLOCK + I286_BASECLOCK - I286_REMCLOCK;                          soundcfg.lastclock = CPU_CLOCK + CPU_BASECLOCK - CPU_REMCLOCK;
                         beep_eventreset();                          beep_eventreset();
                 }                  }
         }          }
           else {
                   locks--;
           }
         return(ret);          return(ret);
 }  }
   
 void sound_pcmunlock(const SINT32 *hdl) {  void sound_pcmunlock(const SINT32 *hdl) {
   
           int             leng;
   
         if (hdl) {          if (hdl) {
                 sndstream.ptr = sndstream.buffer;                  leng = sndstream.reserve - sndstream.remain;
                 sndstream.remain = sndstream.samples;                  if (leng > 0) {
                           CopyMemory(sndstream.buffer,
                                                   sndstream.buffer + (sndstream.samples * 2),
                                                                                                   leng * 2 * sizeof(SINT32));
                   }
                   sndstream.ptr = sndstream.buffer + (leng * 2);
                   sndstream.remain = sndstream.samples + sndstream.reserve - leng;
   //              sndstream.remain += sndstream.samples;
                 SNDCSEC_LEAVE;                  SNDCSEC_LEAVE;
                   locks--;
         }          }
 }  }
   
Removed from v.1.4  
changed lines
  Added in v.1.12

RetroPC.NET-CVS <cvs@retropc.net>