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

Diff for /np2/win9x/cmmidi.cpp between versions 1.6 and 1.8

version 1.6, 2005/02/09 20:11:35 version 1.8, 2005/03/03 06:59:42
Line 2 Line 2
 #include        "np2.h"  #include        "np2.h"
 #include        "mimpidef.h"  #include        "mimpidef.h"
 #include        "commng.h"  #include        "commng.h"
 #if defined(VERMOUTH_LIB)  #if defined(VERMOUTH_LIB) || defined(MT32SOUND_DLL)
 #include        "sound.h"  #include        "sound.h"
   #endif
   #if defined(VERMOUTH_LIB)
 #include        "vermouth.h"  #include        "vermouth.h"
 #endif  #endif
   #if defined(MT32SOUND_DLL)
   #include        "mt32snd.h"
   #endif
 #include        "keydisp.h"  #include        "keydisp.h"
   
   
Line 23  const OEMCHAR cmmidi_midimapper[] = OEMT Line 28  const OEMCHAR cmmidi_midimapper[] = OEMT
 #if defined(VERMOUTH_LIB)  #if defined(VERMOUTH_LIB)
 const OEMCHAR cmmidi_vermouth[] = OEMTEXT("VERMOUTH");  const OEMCHAR cmmidi_vermouth[] = OEMTEXT("VERMOUTH");
 #endif  #endif
   #if defined(MT32SOUND_DLL)
   const OEMCHAR cmmidi_mt32sound[] = OEMTEXT("MT32Sound");
   #endif
   
 const OEMCHAR *cmmidi_mdlname[12] = {  const OEMCHAR *cmmidi_mdlname[12] = {
                 OEMTEXT("MT-32"),       OEMTEXT("CM-32L"),              OEMTEXT("CM-64"),                  OEMTEXT("MT-32"),       OEMTEXT("CM-32L"),              OEMTEXT("CM-64"),
                 OEMTEXT("CM-300"),      OEMTEXT("CM-500(LA)"),  OEMTEXT("CM-500(GS)"),                  OEMTEXT("CM-300"),      OEMTEXT("CM-500(LA)"),  OEMTEXT("CM-500(GS)"),
Line 35  enum {  MIDI_MT32 = 0, MIDI_CM32L,  MIDI Line 44  enum {  MIDI_MT32 = 0, MIDI_CM32L,  MIDI
                         MIDI_GM,                MIDI_GS,                MIDI_XG,        MIDI_OTHER};                          MIDI_GM,                MIDI_GS,                MIDI_XG,        MIDI_OTHER};
   
 static const UINT8 EXCV_MTRESET[] = {  static const UINT8 EXCV_MTRESET[] = {
                         0xfe, 0xfe, 0xfe};                          0xf0,0x41,0x10,0x16,0x12,0x7f,0x00,0x00,0x00,0x01,0xf7};
 static const UINT8 EXCV_GMRESET[] = {  static const UINT8 EXCV_GMRESET[] = {
                         0xf0, 0x7e, 0x7f, 0x09, 0x01, 0xf7};                          0xf0,0x7e,0x7f,0x09,0x01,0xf7};
   static const UINT8 EXCV_GM2RESET[] = {
                           0xf0,0x7e,0x7f,0x09,0x03,0xf7};
 static const UINT8 EXCV_GSRESET[] = {  static const UINT8 EXCV_GSRESET[] = {
                         0xf0, 0x41, 0x10, 0x42, 0x12, 0x40, 0x00, 0x7f, 0x00, 0x41, 0xf7};                          0xf0,0x41,0x10,0x42,0x12,0x40,0x00,0x7f,0x00,0x41,0xf7};
 static const UINT8 EXCV_XGRESET[] = {  static const UINT8 EXCV_XGRESET[] = {
                         0xf0, 0x43, 0x10, 0x4C, 0x00, 0x00, 0x7E, 0x00, 0xf7};                          0xf0,0x43,0x10,0x4c,0x00,0x00,0x7e,0x00,0xf7};
 static const UINT8 EXCV_GMVOLUME[] = {  
                         0xf0, 0x7F, 0x7F, 0x04, 0x01, 0x00, 0x00, 0xF7};  
   
 enum {  enum {
         MIDI_EXCLUSIVE          = 0xf0,          MIDI_EXCLUSIVE          = 0xf0,
Line 70  enum { Line 79  enum {
 #if defined(VERMOUTH_LIB)  #if defined(VERMOUTH_LIB)
         CMMIDI_VERMOUTH         = 0x08,          CMMIDI_VERMOUTH         = 0x08,
 #endif  #endif
   #if defined(MT32SOUND_DLL)
           CMMIDI_MT32SOUND        = 0x10,
   #endif
   
         MIDICTRL_READY          = 0,          MIDICTRL_READY          = 0,
         MIDICTRL_2BYTES,          MIDICTRL_2BYTES,
Line 90  typedef struct { Line 102  typedef struct {
         UINT8   ctrl[28];          UINT8   ctrl[28];
 } _MIDICH, *MIDICH;  } _MIDICH, *MIDICH;
   
 struct _cmmidi {  typedef struct {
         UINT            opened;  
         void            (*outfn)(CMMIDI self, UINT32 msg);  
         HMIDIOUT        hmidiout;          HMIDIOUT        hmidiout;
         MIDIHDR         hmidiouthdr;          MIDIHDR         midihdr;
   } OUTFNWIN32;
   
   typedef union {
           OUTFNWIN32      win32;
 #if defined(VERMOUTH_LIB)  #if defined(VERMOUTH_LIB)
         MIDIHDL         vermouth;          MIDIHDL         vermouth;
 #endif  #endif
   } HMIDIFNOUT;
   
   struct _cmmidi {
           UINT            opened;
           void            (*shortout)(CMMIDI self, UINT32 msg);
           void            (*longout)(CMMIDI self, const UINT8 *msg, UINT leng);
           HMIDIFNOUT      out;
   
         HMIDIIN         hmidiin;          HMIDIIN         hmidiin;
         MIDIHDR         hmidiinhdr;          MIDIHDR         hmidiinhdr;
         UINT            midictrl;          UINT            midictrl;
Line 139  static UINT8 midictrlindex[128]; Line 161  static UINT8 midictrlindex[128];
   
 // ----  // ----
   
 static BOOL getmidioutid(const OEMCHAR *midiout, UINT *ret) {  static BRESULT getmidioutid(const OEMCHAR *midiout, UINT *ret) {
   
         UINT            num;          UINT            num;
         UINT            i;          UINT            i;
Line 160  static BOOL getmidioutid(const OEMCHAR * Line 182  static BOOL getmidioutid(const OEMCHAR *
         return(FAILURE);          return(FAILURE);
 }  }
   
 static BOOL getmidiinid(const OEMCHAR *midiin, UINT *ret) {  static BRESULT getmidiinid(const OEMCHAR *midiin, UINT *ret) {
   
         UINT            num;          UINT            num;
         UINT            i;          UINT            i;
Line 193  static UINT module2number(const OEMCHAR  Line 215  static UINT module2number(const OEMCHAR 
         return(i);          return(i);
 }  }
   
   
   // ---- N/C
   
   static void midi_ncshort(CMMIDI midi, UINT32 msg) {
   
           (void)midi;
           (void)msg;
   }
   
   static void midi_nclong(CMMIDI midi, const UINT8 *msg, UINT leng) {
   
           (void)midi;
           (void)msg;
           (void)leng;
   }
   
   
   // ---- Win32 API
   
 static void waitlastexclusiveout(CMMIDI midi) {  static void waitlastexclusiveout(CMMIDI midi) {
   
         if (midi->midiexcvwait) {          if (midi->midiexcvwait) {
                 midi->midiexcvwait = 0;                  midi->midiexcvwait = 0;
                 while(midiOutUnprepareHeader(midi->hmidiout, &midi->hmidiouthdr,                  while(midiOutUnprepareHeader(midi->out.win32.hmidiout,
                                                                         sizeof(MIDIHDR)) == MIDIERR_STILLPLAYING);                                                                                  &midi->out.win32.midihdr,
                                                                                   sizeof(midi->out.win32.midihdr))
                                                                                                   == MIDIERR_STILLPLAYING) { }
         }          }
 }  }
   
 static void sendexclusive(CMMIDI midi, const UINT8 *buf, UINT leng) {  static void midi_win32short(CMMIDI midi, UINT32 msg) {
   
         CopyMemory(midi->excvbuf, buf, leng);          waitlastexclusiveout(midi);
         midi->hmidiouthdr.lpData = (char *)midi->excvbuf;          midiOutShortMsg(midi->out.win32.hmidiout, (DWORD)msg);
         midi->hmidiouthdr.dwFlags = 0;  
         midi->hmidiouthdr.dwBufferLength = leng;  
         midiOutPrepareHeader(midi->hmidiout, &midi->hmidiouthdr, sizeof(MIDIHDR));  
         midiOutLongMsg(midi->hmidiout, &midi->hmidiouthdr, sizeof(MIDIHDR));  
         midi->midiexcvwait = 1;  
 }  }
   
 static void midiout_none(CMMIDI midi, UINT32 msg) {  static void midi_win32long(CMMIDI midi, const UINT8 *msg, UINT leng) {
   
         (void)midi;          waitlastexclusiveout(midi);
         (void)msg;          CopyMemory(midi->excvbuf, msg, leng);
           midi->out.win32.midihdr.lpData = (char *)midi->excvbuf;
           midi->out.win32.midihdr.dwFlags = 0;
           midi->out.win32.midihdr.dwBufferLength = leng;
           midiOutPrepareHeader(midi->out.win32.hmidiout, &midi->out.win32.midihdr,
                                                                                           sizeof(midi->out.win32.midihdr));
           midiOutLongMsg(midi->out.win32.hmidiout, &midi->out.win32.midihdr,
                                                                                           sizeof(midi->out.win32.midihdr));
           midi->midiexcvwait = 1;
 }  }
   
 static void midiout_win32(CMMIDI midi, UINT32 msg) {  
   
         waitlastexclusiveout(midi);  // ---- Vermouth
         midiOutShortMsg(midi->hmidiout, (DWORD)msg);  
 }  
   
 #if defined(VERMOUTH_LIB)  #if defined(VERMOUTH_LIB)
 static void midiout_vermouth(CMMIDI midi, UINT32 msg) {  static void midi_vermouthshort(CMMIDI midi, UINT32 msg) {
   
           sound_sync();
           midiout_shortmsg(midi->out.vermouth, msg);
   }
   
   static void midi_vermouthlong(CMMIDI midi, const UINT8 *msg, UINT leng) {
   
         sound_sync();          sound_sync();
         midiout_shortmsg(midi->vermouth, msg);          midiout_longmsg(midi->out.vermouth, msg, leng);
 }  }
   
 static void SOUNDCALL vermouth_getpcm(MIDIHDL hdl, SINT32 *pcm, UINT count) {  static void SOUNDCALL vermouth_getpcm(MIDIHDL hdl, SINT32 *pcm, UINT count) {
Line 254  const SINT32 *ptr; Line 303  const SINT32 *ptr;
 }  }
 #endif  #endif
   
   
   // ---- MT-32
   
   #if defined(MT32SOUND_DLL)
   static void midi_mt32short(CMMIDI midi, UINT32 msg) {
   
           sound_sync();
           mt32sound_shortmsg(msg);
   }
   
   static void midi_mt32long(CMMIDI midi, const UINT8 *msg, UINT leng) {
   
           sound_sync();
           mt32sound_longmsg(msg, leng);
   }
   
   static void SOUNDCALL mt32_getpcm(MIDIHDL hdl, SINT32 *pcm, UINT count) {
   
           mt32sound_mix32(pcm, count);
   }
   #endif
   
   
   
   // ----
   
   static void midiallnoteoff(CMMIDI midi) {
   
           UINT    i;
           UINT8   msg[4];
   
           for (i=0; i<0x10; i++) {
                   msg[0] = (UINT8)(0xb0 + i);
                   msg[1] = 0x7b;
                   msg[2] = 0x00;
                   keydisp_midi(msg);
                   midi->shortout(midi, MIDIOUTS3(msg));
           }
   }
   
 static void midireset(CMMIDI midi) {  static void midireset(CMMIDI midi) {
   
 const UINT8     *excv;  const UINT8     *excv;
         UINT    excvsize;          UINT    excvsize;
         UINT8   work[4];  
   
         switch(midi->midimodule) {          switch(midi->midimodule) {
                 case MIDI_GM:                  case MIDI_GM:
Line 295  const UINT8 *excv; Line 383  const UINT8 *excv;
                         break;                          break;
         }          }
         if (excv) {          if (excv) {
                 if (midi->opened & CMMIDI_MIDIOUT) {                  midi->longout(midi, excv, excvsize);
                         waitlastexclusiveout(midi);  
                         sendexclusive(midi, excv, excvsize);  
                 }  
 #if defined(VERMOUTH_LIB)  
                 else if (midi->opened & CMMIDI_VERMOUTH) {  
                         midiout_longmsg(midi->vermouth, excv, excvsize);  
                 }  
 #endif  
         }  
   
         work[1] = 0x7b;  
         work[2] = 0x00;  
         for (work[0]=0xb0; work[0]<0xc0; work[0]++) {  
                 keydisp_midi(work);  
                 midi->outfn(midi, MIDIOUTS3(work));  
         }          }
           midiallnoteoff(midi);
 }  }
   
 static void midisetparam(CMMIDI midi) {  static void midisetparam(CMMIDI midi) {
Line 323  static void midisetparam(CMMIDI midi) { Line 397  static void midisetparam(CMMIDI midi) {
         mch = midi->mch;          mch = midi->mch;
         for (i=0; i<16; i++, mch++) {          for (i=0; i<16; i++, mch++) {
                 if (mch->press != 0xff) {                  if (mch->press != 0xff) {
                         midi->outfn(midi, MIDIOUTS(0xa0+i, mch->press, 0));                          midi->shortout(midi, MIDIOUTS(0xa0+i, mch->press, 0));
                 }                  }
                 if (mch->bend != 0xffff) {                  if (mch->bend != 0xffff) {
                         midi->outfn(midi, (mch->bend << 8) + 0xe0+i);                          midi->shortout(midi, (mch->bend << 8) + 0xe0+i);
                 }                  }
                 for (j=0; j<NELEMENTS(midictrltbl); j++) {                  for (j=0; j<NELEMENTS(midictrltbl); j++) {
                         if (mch->ctrl[j+1] != 0xff) {                          if (mch->ctrl[j+1] != 0xff) {
                                 midi->outfn(midi,                                  midi->shortout(midi,
                                                         MIDIOUTS(0xb0+i, midictrltbl[j], mch->ctrl[j+1]));                                                          MIDIOUTS(0xb0+i, midictrltbl[j], mch->ctrl[j+1]));
                         }                          }
                 }                  }
                 if (mch->prog != 0xff) {                  if (mch->prog != 0xff) {
                         midi->outfn(midi, MIDIOUTS(0xc0+i, mch->prog, 0));                          midi->shortout(midi, MIDIOUTS(0xc0+i, mch->prog, 0));
                 }                  }
         }          }
 }  }
Line 455  static UINT midiwrite(COMMNG self, UINT8 Line 529  static UINT midiwrite(COMMNG self, UINT8
                                                 break;                                                  break;
                                 }                                  }
                                 keydisp_midi(midi->buffer);                                  keydisp_midi(midi->buffer);
                                 midi->outfn(midi, MIDIOUTS2(midi->buffer));                                  midi->shortout(midi, MIDIOUTS2(midi->buffer));
                                 midi->midictrl = MIDICTRL_READY;                                  midi->midictrl = MIDICTRL_READY;
                                 return(2);                                  return(2);
                         }                          }
Line 488  static UINT midiwrite(COMMNG self, UINT8 Line 562  static UINT midiwrite(COMMNG self, UINT8
                                                 break;                                                  break;
                                 }                                  }
                                 keydisp_midi(midi->buffer);                                  keydisp_midi(midi->buffer);
                                 midi->outfn(midi, MIDIOUTS3(midi->buffer));                                  midi->shortout(midi, MIDIOUTS3(midi->buffer));
                                 midi->midictrl = MIDICTRL_READY;                                  midi->midictrl = MIDICTRL_READY;
                                 return(3);                                  return(3);
                         }                          }
Line 496  static UINT midiwrite(COMMNG self, UINT8 Line 570  static UINT midiwrite(COMMNG self, UINT8
   
                 case MIDICTRL_EXCLUSIVE:                  case MIDICTRL_EXCLUSIVE:
                         if (data == MIDI_EOX) {                          if (data == MIDI_EOX) {
                                 if (midi->opened & CMMIDI_MIDIOUT) {                                  midi->longout(midi, midi->buffer, midi->mpos);
                                         waitlastexclusiveout(midi);  
                                         sendexclusive(midi, midi->buffer, midi->mpos);  
                                 }  
 #if defined(VERMOUTH_LIB)  
                                 else if (midi->opened & CMMIDI_VERMOUTH) {  
                                         midiout_longmsg(midi->vermouth, midi->buffer, midi->mpos);  
                                 }  
 #endif  
                                 midi->midictrl = MIDICTRL_READY;                                  midi->midictrl = MIDICTRL_READY;
                                 return(midi->mpos);                                  return(midi->mpos);
                         }                          }
Line 587  static long midimsg(COMMNG self, UINT ms Line 653  static long midimsg(COMMNG self, UINT ms
         return(0);          return(0);
 }  }
   
 static BOOL midiinhdlreg(CMMIDI midi, HMIDIIN hmidiin) {  static BRESULT midiinhdlreg(CMMIDI midi, HMIDIIN hmidiin) {
   
         if (midiinhdls < MIDIIN_MAX) {          if (midiinhdls < MIDIIN_MAX) {
                 midiinhdl[midiinhdls].hmidiin = hmidiin;                  midiinhdl[midiinhdls].hmidiin = hmidiin;
Line 635  static void midirelease(COMMNG self) { Line 701  static void midirelease(COMMNG self) {
         CMMIDI  midi;          CMMIDI  midi;
   
         midi = (CMMIDI)(self + 1);          midi = (CMMIDI)(self + 1);
           midiallnoteoff(midi);
         if (midi->opened & CMMIDI_MIDIOUT) {          if (midi->opened & CMMIDI_MIDIOUT) {
                 waitlastexclusiveout(midi);                  waitlastexclusiveout(midi);
                 midiOutReset(midi->hmidiout);                  midiOutReset(midi->out.win32.hmidiout);
                 midiOutClose(midi->hmidiout);                  midiOutClose(midi->out.win32.hmidiout);
         }          }
         if (midi->opened & CMMIDI_MIDIIN) {          if (midi->opened & CMMIDI_MIDIIN) {
                 if (midi->opened & CMMIDI_MIDIINSTART) {                  if (midi->opened & CMMIDI_MIDIINSTART) {
Line 652  static void midirelease(COMMNG self) { Line 719  static void midirelease(COMMNG self) {
         }          }
 #if defined(VERMOUTH_LIB)  #if defined(VERMOUTH_LIB)
         if (midi->opened & CMMIDI_VERMOUTH) {          if (midi->opened & CMMIDI_VERMOUTH) {
                 midiout_destroy(midi->vermouth);                  midiout_destroy(midi->out.vermouth);
           }
   #endif
   #if defined(MT32SOUND_DLL)
           if (midi->opened & CMMIDI_MT32SOUND) {
                   mt32sound_close();
         }          }
 #endif  #endif
         _MFREE(self);          _MFREE(self);
Line 677  COMMNG cmmidi_create(const OEMCHAR *midi Line 749  COMMNG cmmidi_create(const OEMCHAR *midi
   
         UINT            opened;          UINT            opened;
         UINT            id;          UINT            id;
         void            (*outfn)(CMMIDI midi, UINT32 msg);          void            (*shortout)(CMMIDI self, UINT32 msg);
         HMIDIOUT        hmidiout = NULL;          void            (*longout)(CMMIDI self, const UINT8 *msg, UINT leng);
           HMIDIFNOUT      out;
         HMIDIIN         hmidiin = NULL;          HMIDIIN         hmidiin = NULL;
 #if defined(VERMOUTH_LIB)  
         MIDIHDL         vermouth = NULL;  
 #endif  
         COMMNG          ret;          COMMNG          ret;
         CMMIDI          midi;          CMMIDI          midi;
   
         opened = 0;          opened = 0;
         outfn = midiout_none;          ZeroMemory(&out, sizeof(out));
           shortout = midi_ncshort;
           longout = midi_nclong;
         if (getmidioutid(midiout, &id) == SUCCESS) {          if (getmidioutid(midiout, &id) == SUCCESS) {
                 if (midiOutOpen(&hmidiout, id, 0, 0, CALLBACK_NULL)                  if (midiOutOpen(&out.win32.hmidiout, id, 0, 0, CALLBACK_NULL)
                                                                                                                 == MMSYSERR_NOERROR) {                                                                                                                  == MMSYSERR_NOERROR) {
                         midiOutReset(hmidiout);                          midiOutReset(out.win32.hmidiout);
                         outfn = midiout_win32;                          shortout = midi_win32short;
                           longout = midi_win32long;
                         opened |= CMMIDI_MIDIOUT;                          opened |= CMMIDI_MIDIOUT;
                 }                  }
         }          }
Line 705  COMMNG cmmidi_create(const OEMCHAR *midi Line 778  COMMNG cmmidi_create(const OEMCHAR *midi
         }          }
 #if defined(VERMOUTH_LIB)  #if defined(VERMOUTH_LIB)
         else if (!milstr_cmp(midiout, cmmidi_vermouth)) {          else if (!milstr_cmp(midiout, cmmidi_vermouth)) {
                 vermouth = midiout_create(vermouth_module, 512);                  out.vermouth = midiout_create(vermouth_module, 512);
                 if (vermouth != NULL) {                  if (out.vermouth != NULL) {
                         outfn = midiout_vermouth;                          shortout = midi_vermouthshort;
                           longout = midi_vermouthlong;
                         opened |= CMMIDI_VERMOUTH;                          opened |= CMMIDI_VERMOUTH;
                 }                  }
         }          }
 #endif  #endif
   #if defined(MT32SOUND_DLL)
           else if (!milstr_cmp(midiout, cmmidi_mt32sound)) {
                   if (mt32sound_open() == SUCCESS) {
                           shortout = midi_mt32short;
                           longout = midi_mt32long;
                           opened |= CMMIDI_MT32SOUND;
                   }
           }
   #endif
         if (!opened) {          if (!opened) {
                 goto cmcre_err1;                  goto cmcre_err1;
         }          }
Line 728  COMMNG cmmidi_create(const OEMCHAR *midi Line 811  COMMNG cmmidi_create(const OEMCHAR *midi
         midi = (CMMIDI)(ret + 1);          midi = (CMMIDI)(ret + 1);
         ZeroMemory(midi, sizeof(_CMMIDI));          ZeroMemory(midi, sizeof(_CMMIDI));
         midi->opened = opened;          midi->opened = opened;
         midi->outfn = outfn;          midi->shortout = shortout;
           midi->longout = longout;
           midi->out = out;
         midi->midictrl = MIDICTRL_READY;          midi->midictrl = MIDICTRL_READY;
         midi->hmidiout = hmidiout;  
 #if 1  #if 1
         midi->hmidiin = hmidiin;          midi->hmidiin = hmidiin;
         if (opened & CMMIDI_MIDIIN) {          if (opened & CMMIDI_MIDIIN) {
Line 745  COMMNG cmmidi_create(const OEMCHAR *midi Line 829  COMMNG cmmidi_create(const OEMCHAR *midi
         }          }
 #endif  #endif
 #if defined(VERMOUTH_LIB)  #if defined(VERMOUTH_LIB)
         midi->vermouth = vermouth;  
         if (opened & CMMIDI_VERMOUTH) {          if (opened & CMMIDI_VERMOUTH) {
                 sound_streamregist((void *)vermouth, (SOUNDCB)vermouth_getpcm);                  sound_streamregist((void *)out.vermouth, (SOUNDCB)vermouth_getpcm);
           }
   #endif
   #if defined(MT32SOUND_DLL)
           if (opened & CMMIDI_MT32SOUND) {
                   sound_streamregist(NULL, (SOUNDCB)mt32_getpcm);
         }          }
 #endif  #endif
 //      midi->midisyscnt = 0;  //      midi->midisyscnt = 0;
Line 761  COMMNG cmmidi_create(const OEMCHAR *midi Line 849  COMMNG cmmidi_create(const OEMCHAR *midi
   
 cmcre_err2:  cmcre_err2:
         if (opened & CMMIDI_MIDIOUT) {          if (opened & CMMIDI_MIDIOUT) {
                 midiOutReset(hmidiout);                  midiOutReset(out.win32.hmidiout);
                 midiOutClose(hmidiout);                  midiOutClose(out.win32.hmidiout);
         }          }
 #if defined(VERMOUTH_LIB)  #if defined(VERMOUTH_LIB)
         if (opened & CMMIDI_VERMOUTH) {          if (opened & CMMIDI_VERMOUTH) {
                 midiout_destroy(vermouth);                  midiout_destroy(out.vermouth);
           }
   #endif
   #if defined(MT32SOUND_DLL)
           if (opened & CMMIDI_MT32SOUND) {
                   mt32sound_close();
         }          }
 #endif  #endif
   
Removed from v.1.6  
changed lines
  Added in v.1.8

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