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

Diff for /np2/win9x/cmmidi.cpp between versions 1.5 and 1.12

version 1.5, 2005/02/07 14:46:14 version 1.12, 2011/03/07 09:54:11
Line 1 Line 1
 #include        "compiler.h"  /**
 #include        "np2.h"   * @file        cmmidi.cpp
 #include        "mimpidef.h"   * @brief       Communication port manager (MIDI)
 #include        "commng.h"   *
 #if defined(VERMOUTH_LIB)   * @author      $Author$
 #include        "sound.h"   * @date        $Date$
 #include        "vermouth.h"   */
 #endif  
 #include        "keydisp.h"  #include "compiler.h"
   #include "np2.h"
   #include "mimpidef.h"
   #include "commng.h"
   #if defined(VERMOUTH_LIB) || defined(MT32SOUND_DLL)
   #include "sound.h"
   #endif
   #if defined(VERMOUTH_LIB)
   #include "vermouth.h"
   #endif
   #if defined(MT32SOUND_DLL)
   #include "mt32snd.h"
   #endif
   #include "keydisp.h"
   
   #if !defined(__GNUC__)
   #pragma comment(lib, "winmm.lib")
   #endif  // !defined(__GNUC__)
   
 #if defined(VERMOUTH_LIB)  #if defined(VERMOUTH_LIB)
 extern  MIDIMOD vermouth_module;  extern  MIDIMOD vermouth_module;
Line 19  extern MIDIMOD vermouth_module; Line 35  extern MIDIMOD vermouth_module;
 #define MIDIOUTS3(a)            ((*(UINT32 *)(a)) & 0xffffff)  #define MIDIOUTS3(a)            ((*(UINT32 *)(a)) & 0xffffff)
   
   
 const char cmmidi_midimapper[] = "MIDI MAPPER";  const OEMCHAR cmmidi_midimapper[] = OEMTEXT("MIDI MAPPER");
 #if defined(VERMOUTH_LIB)  #if defined(VERMOUTH_LIB)
 const char cmmidi_vermouth[] = "VERMOUTH";  const OEMCHAR cmmidi_vermouth[] = OEMTEXT("VERMOUTH");
 #endif  #endif
 const char *cmmidi_mdlname[12] = {  #if defined(MT32SOUND_DLL)
                         "MT-32",                "CM-32L",               "CM-64",  const OEMCHAR cmmidi_mt32sound[] = OEMTEXT("MT32Sound");
                         "CM-300",               "CM-500(LA)",   "CM-500(GS)",  #endif
                         "SC-55",                "SC-88",                "LA",  
                         "GM",                   "GS",                   "XG"};  const OEMCHAR *cmmidi_mdlname[12] = {
                   OEMTEXT("MT-32"),       OEMTEXT("CM-32L"),              OEMTEXT("CM-64"),
                   OEMTEXT("CM-300"),      OEMTEXT("CM-500(LA)"),  OEMTEXT("CM-500(GS)"),
                   OEMTEXT("SC-55"),       OEMTEXT("SC-88"),               OEMTEXT("LA"),
                   OEMTEXT("GM"),          OEMTEXT("GS"),                  OEMTEXT("XG")};
   
 enum {          MIDI_MT32 = 0,  MIDI_CM32L,             MIDI_CM64,  enum {          MIDI_MT32 = 0,  MIDI_CM32L,             MIDI_CM64,
                         MIDI_CM300,             MIDI_CM500LA,   MIDI_CM500GS,                          MIDI_CM300,             MIDI_CM500LA,   MIDI_CM500GS,
Line 35  enum {  MIDI_MT32 = 0, MIDI_CM32L,  MIDI Line 55  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,
         MIDI_TIMECODE           = 0xf1,          MIDI_TIMECODE           = 0xf1,
         MIDI_SONGPOS            = 0xf2,          MIDI_SONGPOS            = 0xf2,
         MIDI_SONGSELECT         = 0xf3,          MIDI_SONGSELECT         = 0xf3,
           MIDI_CABLESELECT        = 0xf5,
         MIDI_TUNEREQUEST        = 0xf6,          MIDI_TUNEREQUEST        = 0xf6,
         MIDI_EOX                        = 0xf7,          MIDI_EOX                        = 0xf7,
         MIDI_TIMING                     = 0xf8,          MIDI_TIMING                     = 0xf8,
Line 70  enum { Line 91  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 114  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 173  static UINT8 midictrlindex[128];
   
 // ----  // ----
   
 static BOOL getmidioutid(const char *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 char *mid Line 194  static BOOL getmidioutid(const char *mid
         return(FAILURE);          return(FAILURE);
 }  }
   
 static BOOL getmidiinid(const char *midiin, UINT *ret) {  static BRESULT getmidiinid(const OEMCHAR *midiin, UINT *ret) {
   
         UINT            num;          UINT            num;
         UINT            i;          UINT            i;
Line 181  static BOOL getmidiinid(const char *midi Line 215  static BOOL getmidiinid(const char *midi
         return(FAILURE);          return(FAILURE);
 }  }
   
 static UINT module2number(const char *module) {  static UINT module2number(const OEMCHAR *module) {
   
         UINT    i;          UINT    i;
   
         for (i=0; i<NELEMENTS(cmmidi_mdlname); i++) {          for (i=0; i<NELEMENTS(cmmidi_mdlname); i++) {
                 if (milstr_extendcmp(module, cmmidi_mdlname[i])) {                  if (!milstr_extendcmp(module, cmmidi_mdlname[i])) {
                         break;                          break;
                 }                  }
         }          }
         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 315  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 395  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 409  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 411  static UINT midiwrite(COMMNG self, UINT8 Line 497  static UINT midiwrite(COMMNG self, UINT8
                                                         midi->midisyscnt = 2;                                                          midi->midisyscnt = 2;
                                                         break;                                                          break;
   
                                                 case MIDI_TUNEREQUEST:                                                  case MIDI_CABLESELECT:
                                                         midi->midictrl = MIDICTRL_SYSTEM;                                                          midi->midictrl = MIDICTRL_SYSTEM;
                                                         midi->midisyscnt = 1;                                                          midi->midisyscnt = 1;
                                                         break;                                                          break;
   
   //                                              case MIDI_TUNEREQUEST:
 //                                              case MIDI_EOX:  //                                              case MIDI_EOX:
                                                 default:                                                  default:
                                                         return(1);                                                          return(1);
Line 455  static UINT midiwrite(COMMNG self, UINT8 Line 542  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 575  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 583  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 577  static long midimsg(COMMNG self, UINT ms Line 656  static long midimsg(COMMNG self, UINT ms
                         break;                          break;
   
                 case COMMSG_MIMPIDEFFILE:                  case COMMSG_MIMPIDEFFILE:
                         mimpidef_load(&midi->def, (char *)param);                          mimpidef_load(&midi->def, (OEMCHAR *)param);
                         return(1);                          return(1);
   
                 case COMMSG_MIMPIDEFEN:                  case COMMSG_MIMPIDEFEN:
Line 587  static long midimsg(COMMNG self, UINT ms Line 666  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 714  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 732  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 672  void cmmidi_initailize(void) { Line 757  void cmmidi_initailize(void) {
         midictrlindex[32] = 1;          midictrlindex[32] = 1;
 }  }
   
 COMMNG cmmidi_create(const char *midiout, const char *midiin,  COMMNG cmmidi_create(const OEMCHAR *midiout, const OEMCHAR *midiin,
                                                                                                                 const char *module) {                                                                                                          const OEMCHAR *module) {
   
         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;
                 }                  }
         }          }
         if (getmidiinid(midiin, &id) == SUCCESS) {          if (getmidiinid(midiin, &id) == SUCCESS) {
                 if (midiInOpen(&hmidiin, id, (DWORD)hWndMain, 0, CALLBACK_WINDOW)                  if (midiInOpen(&hmidiin, id, (DWORD)g_hWndMain, 0, CALLBACK_WINDOW)
                                                                                                                 == MMSYSERR_NOERROR) {                                                                                                                  == MMSYSERR_NOERROR) {
                         midiInReset(hmidiin);                          midiInReset(hmidiin);
                         opened |= CMMIDI_MIDIIN;                          opened |= CMMIDI_MIDIIN;
Line 705  COMMNG cmmidi_create(const char *midiout Line 791  COMMNG cmmidi_create(const char *midiout
         }          }
 #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 char *midiout Line 824  COMMNG cmmidi_create(const char *midiout
         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 char *midiout Line 842  COMMNG cmmidi_create(const char *midiout
         }          }
 #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 char *midiout Line 862  COMMNG cmmidi_create(const char *midiout
   
 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.5  
changed lines
  Added in v.1.12

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