[BACK]Return to soundmng.cpp CVS log [TXT] [DIR] Up to [RetroPC.NET] / np2 / macosx

Diff for /np2/macosx/soundmng.cpp between versions 1.2 and 1.9

version 1.2, 2003/10/22 15:21:23 version 1.9, 2004/01/23 17:37:39
Line 6 Line 6
 #include        "soundmng.h"  #include        "soundmng.h"
 #include        "sound.h"  #include        "sound.h"
 #if defined(VERMOUTH_LIB)  #if defined(VERMOUTH_LIB)
 #include        "vermouth.h"  #include        "commng.h"
   #include        "cmver.h"
 #endif  #endif
   
   #include        "soundrecording.h"
   #include        "np2opening.h"
   
 #define SOUNDBUFFERS    2  #define SOUNDBUFFERS    2
   
Line 18  typedef struct { Line 21  typedef struct {
         UINT                    rate;          UINT                    rate;
         UINT                    samples;          UINT                    samples;
         UINT                    buffersize;          UINT                    buffersize;
   #if !defined(SOUND_CRITICAL)
           SINT16                  *indata;
           SINT16                  *extendbuffer;
   #endif
         ExtSoundHeader  *buf[SOUNDBUFFERS];          ExtSoundHeader  *buf[SOUNDBUFFERS];
         SndCommand              cmd[SOUNDBUFFERS];          SndCommand              cmd[SOUNDBUFFERS];
         SndCommand              cbcmd[SOUNDBUFFERS];          SndCommand              cbcmd[SOUNDBUFFERS];
Line 27  static BOOL  QS_Avail = FALSE; Line 34  static BOOL  QS_Avail = FALSE;
 static  _QSOUND         QSound;  static  _QSOUND         QSound;
 static  BOOL            QSound_Playing = FALSE;  static  BOOL            QSound_Playing = FALSE;
   
 #if defined(VERMOUTH_LIB)  static  void                            (PARTSCALL *fnmix)(SINT16 *dst,
                 MIDIMOD         vermouth_module = NULL;                                                                                                  const SINT32 *src, UINT size);
 #endif  
   
   
 static pascal void QSoundCallback(SndChannelPtr /*inChannel*/,  static pascal void QSoundCallback(SndChannelPtr /*inChannel*/,
                                                                                                 SndCommand *inCommand) {                                                                                                  SndCommand *inCommand) {
Line 38  static pascal void QSoundCallback(SndCha Line 43  static pascal void QSoundCallback(SndCha
         QSOUND          qs;          QSOUND          qs;
         int                     nextbuf;          int                     nextbuf;
         void            *dst;          void            *dst;
   #if defined(SOUND_CRITICAL)
 const SINT32    *src;  const SINT32    *src;
   #endif
   
         if (QS_Avail) {          if (QS_Avail) {
                 qs = &QSound;                  qs = &QSound;
                 nextbuf = inCommand->param1;                  nextbuf = inCommand->param1;
                 dst = qs->buf[nextbuf]->sampleArea;                  dst = qs->buf[nextbuf]->sampleArea;
   #if !defined(SOUND_CRITICAL)
                   if (qs->indata) {
                           CopyMemory((SINT16 *)dst, qs->indata, qs->buffersize);
                           qs->indata = NULL;
                   }
   #else
                 src = NULL;                  src = NULL;
                 if (QSound_Playing) {                  if (QSound_Playing) {
                         src = sound_pcmlock();                          src = sound_pcmlock();
                 }                  }
                 if (src) {                  if (src) {
                         satuation_s16((SINT16 *)dst, src, qs->buffersize);                          (*fnmix)((SINT16 *)dst, src, qs->buffersize);
               if (QSound_Playing) {
                   recOPM((BYTE*)dst, qs->buffersize);
               }
                         sound_pcmunlock(src);                          sound_pcmunlock(src);
                 }                  }
   #endif
                 else {                  else {
                         ZeroMemory(dst, qs->buffersize);                          ZeroMemory(dst, qs->buffersize);
                 }                  }
Line 117  static BOOL SoundBuffer_Init(UINT rate,  Line 134  static BOOL SoundBuffer_Init(UINT rate, 
         qs->buffersize = buffersize;          qs->buffersize = buffersize;
         drate = rate;          drate = rate;
         dtox80(&drate, &extFreq);          dtox80(&drate, &extFreq);
   
   #if !defined(SOUND_CRITICAL)
           qs->extendbuffer = (SINT16 *)_MALLOC(buffersize, "Extend buffer");
           if (qs->extendbuffer == NULL) {
                   goto sbinit_err;
           }
   #endif
   
         buffersize += sizeof(ExtSoundHeader);          buffersize += sizeof(ExtSoundHeader);
         for (i=0; i<SOUNDBUFFERS; i++) {          for (i=0; i<SOUNDBUFFERS; i++) {
                 buf = (ExtSoundHeader *)_MALLOC(buffersize, "ExtSoundHeader");                  buf = (ExtSoundHeader *)_MALLOC(buffersize, "ExtSoundHeader");
Line 161  static void SoundBuffer_Term(void) { Line 186  static void SoundBuffer_Term(void) {
                         buf[i] = NULL;                          buf[i] = NULL;
                 }                  }
         }          }
   #if !defined(SOUND_CRITICAL)
           qs->indata = NULL;
           if (qs->extendbuffer) {
                   _MFREE(qs->extendbuffer);
                   qs->extendbuffer = NULL;
           }
   #endif
 }  }
   
 UINT soundmng_create(UINT rate, UINT ms) {  UINT soundmng_create(UINT rate, UINT ms) {
   
         UINT    samples;          UINT    samples;
 #if defined(VERMOUTH_LIB)  
         UINT    num;  
 #endif  
   
         QSound_Playing = FALSE;          QSound_Playing = FALSE;
   
Line 182  UINT soundmng_create(UINT rate, UINT ms) Line 211  UINT soundmng_create(UINT rate, UINT ms)
         if (SoundChannel_Init()) {          if (SoundChannel_Init()) {
                 goto qsinit_err;                  goto qsinit_err;
         }          }
         samples = (rate / 3) & (~3);  #if !defined(SOUND_CRITICAL)
           samples = rate * ms / (SOUNDBUFFERS * 1000);
           samples = (samples + 3) & (~3);
   #else
           samples = rate * ms / 1000;
           samples = (samples + 255) & (~255);
   #endif
         if (SoundBuffer_Init(rate, samples)) {          if (SoundBuffer_Init(rate, samples)) {
                 goto qsinit_err;                  goto qsinit_err;
         }          }
 #if defined(VERMOUTH_LIB)  #if defined(VERMOUTH_LIB)
         vermouth_module = midimod_create(rate);          cmvermouth_load(rate);
         for (num=0; num<128; num++) {  
                 midimod_loadprogram(vermouth_module, num);  
                 midimod_loadrhythm(vermouth_module, num);  
         }  
 #endif  #endif
         return(samples);          return(samples);
   
 qsinit_err:  qsinit_err:
         soundmng_destroy();          soundmng_destroy();
         (void)ms;  
         return(0);          return(0);
 }  }
   
 void soundmng_destroy(void) {  void soundmng_destroy(void) {
   
         if (QS_Avail) {          if (QS_Avail) {
 #if defined(VERMOUTH_LIB)  
                 midimod_destroy(vermouth_module);  
                 vermouth_module = NULL;  
 #endif  
                 QS_Avail = FALSE;                  QS_Avail = FALSE;
                 SoundBuffer_Term();                  SoundBuffer_Term();
                 SoundChannel_Term();                  SoundChannel_Term();
   #if defined(VERMOUTH_LIB)
                   cmvermouth_unload();
   #endif
         }          }
 }  }
   
 void soundmng_play(void) {  void soundmng_play(void) {
   
         QSound_Playing = TRUE;      if (!QSound_Playing) QSound_Playing = TRUE;
 }  }
   
 void soundmng_stop(void) {  void soundmng_stop(void) {
   
         QSound_Playing = FALSE;          if (QSound_Playing) QSound_Playing = FALSE;
   }
   
   void soundmng_setreverse(BOOL reverse) {
   
           if (!reverse) {
           fnmix = satuation_s16;
           }
           else {
                   fnmix = satuation_s16x;
           }
   }
   
   #if !defined(SOUND_CRITICAL)
   void soundmng_sync(void) {
   
           QSOUND          qs;
   const SINT32    *src;
   
           qs = &QSound;
   
           if ((QSound_Playing) && (qs->indata == NULL)) {
                   src = sound_pcmlock();
                   if (src) {
                           (*fnmix)(qs->extendbuffer, src, qs->buffersize);
                           recOPM((BYTE *)qs->extendbuffer, qs->buffersize);
                           sound_pcmunlock(src);
                           qs->indata = qs->extendbuffer;
                   }
           }
   }
   #endif
   
   #ifndef SUPPORT_WAVEMIX
   // --------------------------------------------------------------------------
   #include <QuickTime/Movies.h>
   #include "np2.h"
   #include "dosio.h"
   
   static  Movie   seekWAV[2];
   
   static  Movie   setupWAV(const char* name) {
       FSSpec      fs;
       short       movieRefNum;
       short       resID = 0;
       Movie       wav = NULL;    
   
       if (!getResourceFile(name, &fs)) {
           char    path[MAX_PATH];
           Str255  fname;
   
           file_cpyname(path, file_getcd(name), MAX_PATH);
           mkstr255(fname, path);
           FSMakeFSSpec(0, 0, fname, &fs);
       }
   
       if (OpenMovieFile( &fs, &movieRefNum, fsRdPerm ) == noErr) {
           if (NewMovieFromFile(&wav,movieRefNum, &resID, NULL, newMovieActive, NULL) != noErr) {
               return NULL;
           }
       }
       return  wav;
   }
   
   void soundmng_deinitialize(void) {
       StopMovie(seekWAV[0]);
       StopMovie(seekWAV[1]);
       seekWAV[0]  = NULL;
       seekWAV[1] = NULL;
       ExitMovies();
   }
   
   BOOL soundmng_initialize(void) {
       EnterMovies();
       seekWAV[0] = setupWAV("fddseek.wav");
       seekWAV[1] = setupWAV("fddseek1.wav");
       if (seekWAV[0] == NULL || seekWAV[1] == NULL) {
           return  false;
       }
       return(true);
   }
   
   void soundmng_pcmvolume(UINT num, int volume) {
       if (seekWAV[num]) {
           SetMovieVolume(seekWAV[num], kFullVolume*volume/100);
       }
   }
   
   BOOL soundmng_pcmplay(UINT num, BOOL loop) {
       if (seekWAV[num]) {
           GoToBeginningOfMovie(seekWAV[num]);
           StartMovie(seekWAV[num]);
           return SUCCESS;
       }
           return(FAILURE);
 }  }
   
   void soundmng_pcmstop(UINT num) {
       if (seekWAV[num]) {
           StopMovie(seekWAV[num]);
       }
   }
   
   #endif
Removed from v.1.2  
changed lines
  Added in v.1.9

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