dlls/midimap/midimap.c

   1 /*
   2  * Wine MIDI mapper driver
   3  *
   4  * Copyright    1999, 2000, 2001 Eric Pouech
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  *
  20  * TODO:
  21  *      notification has to be implemented
  22  *      IDF file loading
  23  */
  24
  25 #include <stdarg.h>
  26 #include <string.h>
  27 #include <stdlib.h>
  28 #include "windef.h"
  29 #include "winbase.h"
  30 #include "wingdi.h"
  31 #include "winuser.h"
  32 #include "mmddk.h"
  33 #include "winreg.h"
  34 #include "wine/unicode.h"
  35 #include "wine/debug.h"
  36
  37 /*
  38  * Here's how Windows stores the midiOut mapping information.
  39  *
  40  * Full form (in HKU) is:
  41  *
  42  * [Software\\Microsoft\\Windows\\CurrentVersion\\Multimedia\\MIDIMap] 988836060
  43  * "AutoScheme"=dword:00000000
  44  * "ConfigureCount"=dword:00000004
  45  * "CurrentInstrument"="Wine OSS midi"
  46  * "CurrentScheme"="epp"
  47  * "DriverList"=""
  48  * "UseScheme"=dword:00000000
  49  *
  50  * AutoScheme:          ?
  51  * CurrentInstrument:   name of midiOut device to use when UseScheme is 0. Wine uses an extension
  52  *                      of the form #n to link to n'th midiOut device of the system
  53  * CurrentScheme:       when UseScheme is non null, it's the scheme to use (see below)
  54  * DriverList:          ?
  55  * UseScheme:           trigger for simple/complex mapping
  56  *
  57  * A scheme is defined (in HKLM) as:
  58  *
  59  * [System\\CurrentControlSet\\Control\\MediaProperties\\PrivateProperties\\Midi\\Schemes\\<nameScheme>]
  60  * <nameScheme>:        one key for each defined scheme (system wide)
  61  * under each one of these <nameScheme> keys, there's:
  62  * [...\\<nameScheme>\\<idxDevice>]
  63  * "Channels"="<bitMask>"
  64  * (the default value of this key also refers to the name of the device).
  65  *
  66  * this defines, for each midiOut device (identified by its index in <idxDevice>), which
  67  * channels have to be mapped onto it. The <bitMask> defines the channels (from 0 to 15)
  68  * will be mapped (mapping occurs for channel <ch> if bit <ch> is set in <bitMask>
  69  *
  70  * Further mapping information can also be defined in:
  71  * [System\\CurrentControlSet\\Control\\MediaProperties\\PrivateProperties\\Midi\\Ports\\<nameDevice>\\Instruments\\<idx>]
  72  * "Definition"="<.idf file>"
  73  * "FriendlyName"="#for .idx file#"
  74  * "Port"="<idxPort>"
  75  *
  76  * This last part isn't implemented (.idf file support).
  77  */
  78
  79 WINE_DEFAULT_DEBUG_CHANNEL(msacm);
  80 WINE_DECLARE_DEBUG_CHANNEL(winediag);
  81
  82 typedef struct tagMIDIOUTPORT
  83 {
  84     WCHAR               name[MAXPNAMELEN];
  85     int                 loaded;
  86     HMIDIOUT            hMidi;
  87     unsigned short      uDevID;
  88     LPBYTE              lpbPatch;
  89     unsigned int        aChn[16];
  90 } MIDIOUTPORT;
  91
  92 typedef struct tagMIDIMAPDATA
  93 {
  94     struct tagMIDIMAPDATA*      self;
  95     MIDIOUTPORT*        ChannelMap[16];
  96     MIDIOPENDESC        midiDesc;
  97     WORD                wCbFlags;
  98 } MIDIMAPDATA;
  99
 100 static  MIDIOUTPORT*    midiOutPorts;
 101 static  unsigned        numMidiOutPorts;
 102
 103 static  BOOL    MIDIMAP_IsBadData(MIDIMAPDATA* mm)
 104 {
 105     if (!IsBadReadPtr(mm, sizeof(MIDIMAPDATA)) && mm->self == mm)
 106         return FALSE;
 107     TRACE("Bad midimap data (%p)\n", mm);
 108     return TRUE;
 109 }
 110
 111 static BOOL     MIDIMAP_FindPort(const WCHAR* name, unsigned* dev)
 112 {
 113     for (*dev = 0; *dev < numMidiOutPorts; (*dev)++)
 114     {
 115         TRACE("%s\n", wine_dbgstr_w(midiOutPorts[*dev].name));
 116         if (strcmpW(midiOutPorts[*dev].name, name) == 0)
 117             return TRUE;
 118     }
 119     /* try the form #nnn */
 120     if (*name == '#' && name[1] >= '0' && name[1] <= '9')
 121     {
 122         const WCHAR*  ptr = name + 1;
 123         *dev = 0;
 124         do
 125         {
 126             *dev = *dev * 10 + *ptr - '0';
 127             ptr++;
 128         } while (*ptr >= '0' && *ptr <= '9');
 129         if (*dev < numMidiOutPorts)
 130             return TRUE;
 131     }
 132     return FALSE;
 133 }
 134
 135 static BOOL     MIDIMAP_LoadSettingsDefault(MIDIMAPDATA* mom, const WCHAR* port)
 136 {
 137     unsigned i, dev = 0;
 138
 139     if (port != NULL && !MIDIMAP_FindPort(port, &dev))
 140     {
 141         ERR("Registry glitch: couldn't find midi out (%s)\n", wine_dbgstr_w(port));
 142         dev = 0;
 143     }
 144
 145     /* this is necessary when no midi out ports are present */
 146     if (dev >= numMidiOutPorts)
 147         return FALSE;
 148     /* sets default */
 149     for (i = 0; i < 16; i++) mom->ChannelMap[i] = &midiOutPorts[dev];
 150
 151     return TRUE;
 152 }
 153
 154 static BOOL     MIDIMAP_LoadSettingsScheme(MIDIMAPDATA* mom, const WCHAR* scheme)
 155 {
 156     HKEY        hSchemesKey, hKey, hPortKey;
 157     unsigned    i, idx, dev;
 158     WCHAR       buffer[256], port[256];
 159     DWORD       type, size, mask;
 160
 161     for (i = 0; i < 16; i++)    mom->ChannelMap[i] = NULL;
 162
 163     if (RegOpenKeyA(HKEY_LOCAL_MACHINE,
 164                     "System\\CurrentControlSet\\Control\\MediaProperties\\PrivateProperties\\Midi\\Schemes",
 165                     &hSchemesKey))
 166     {
 167         return FALSE;
 168     }
 169     if (RegOpenKeyW(hSchemesKey, scheme, &hKey))
 170     {
 171         RegCloseKey(hSchemesKey);
 172         return FALSE;
 173     }
 174
 175     for (idx = 0; !RegEnumKeyW(hKey, idx, buffer, ARRAY_SIZE(buffer)); idx++)
 176     {
 177         if (RegOpenKeyW(hKey, buffer, &hPortKey)) continue;
 178
 179         size = sizeof(port);
 180         if (RegQueryValueExW(hPortKey, NULL, 0, &type, (void*)port, &size)) continue;
 181
 182         if (!MIDIMAP_FindPort(port, &dev)) continue;
 183
 184         size = sizeof(mask);
 185         if (RegQueryValueExA(hPortKey, "Channels", 0, &type, (void*)&mask, &size))
 186             continue;
 187
 188         for (i = 0; i < 16; i++)
 189         {
 190             if (mask & (1 << i))
 191             {
 192                 if (mom->ChannelMap[i])
 193                     ERR("Quirks in registry, channel %u is mapped twice\n", i);
 194                 mom->ChannelMap[i] = &midiOutPorts[dev];
 195             }
 196         }
 197     }
 198
 199     RegCloseKey(hSchemesKey);
 200     RegCloseKey(hKey);
 201
 202     return TRUE;
 203 }
 204
 205 static BOOL     MIDIMAP_LoadSettings(MIDIMAPDATA* mom)
 206 {
 207     HKEY        hKey;
 208     BOOL        ret;
 209
 210     if (RegOpenKeyA(HKEY_CURRENT_USER,
 211                     "Software\\Microsoft\\Windows\\CurrentVersion\\Multimedia\\MIDIMap", &hKey))
 212     {
 213         ret = MIDIMAP_LoadSettingsDefault(mom, NULL);
 214     }
 215     else
 216     {
 217         DWORD   type, size, out;
 218         WCHAR   buffer[256];
 219
 220         ret = 2;
 221         size = sizeof(out);
 222         if (!RegQueryValueExA(hKey, "UseScheme", 0, &type, (void*)&out, &size) && out)
 223         {
 224             static const WCHAR cs[] = {'C','u','r','r','e','n','t','S','c','h','e','m','e',0};
 225             size = sizeof(buffer);
 226             if (!RegQueryValueExW(hKey, cs, 0, &type, (void*)buffer, &size))
 227             {
 228                 if (!(ret = MIDIMAP_LoadSettingsScheme(mom, buffer)))
 229                     ret = MIDIMAP_LoadSettingsDefault(mom, NULL);
 230             }
 231             else
 232             {
 233                 ERR("Wrong registry: UseScheme is active, but no CurrentScheme found\n");
 234             }
 235         }
 236         if (ret == 2)
 237         {
 238             static const WCHAR ci[] = {'C','u','r','r','e','n','t','I','n','s','t','r','u','m','e','n','t',0};
 239             size = sizeof(buffer);
 240             if (!RegQueryValueExW(hKey, ci, 0, &type, (void*)buffer, &size) && *buffer)
 241             {
 242                 ret = MIDIMAP_LoadSettingsDefault(mom, buffer);
 243             }
 244             else
 245             {
 246                 ret = MIDIMAP_LoadSettingsDefault(mom, NULL);
 247             }
 248         }
 249     }
 250     RegCloseKey(hKey);
 251
 252     if (ret && TRACE_ON(msacm))
 253     {
 254         unsigned        i;
 255
 256         for (i = 0; i < 16; i++)
 257         {
 258             TRACE("chnMap[%2d] => %d\n",
 259                   i, mom->ChannelMap[i] ? mom->ChannelMap[i]->uDevID : -1);
 260         }
 261     }
 262     return ret;
 263 }
 264
 265 static void MIDIMAP_NotifyClient(MIDIMAPDATA* mom, WORD wMsg,
 266                                  DWORD_PTR dwParam1, DWORD_PTR dwParam2)
 267 {
 268     DriverCallback(mom->midiDesc.dwCallback, mom->wCbFlags, (HDRVR)mom->midiDesc.hMidi,
 269                    wMsg, mom->midiDesc.dwInstance, dwParam1, dwParam2);
 270 }
 271
 272 static DWORD modOpen(DWORD_PTR *lpdwUser, LPMIDIOPENDESC lpDesc, DWORD dwFlags)
 273 {
 274     MIDIMAPDATA*        mom = HeapAlloc(GetProcessHeap(), 0, sizeof(MIDIMAPDATA));
 275
 276     TRACE("(%p %p %08x)\n", lpdwUser, lpDesc, dwFlags);
 277
 278     if (!mom) return MMSYSERR_NOMEM;
 279     if (!lpDesc) {
 280         HeapFree(GetProcessHeap(), 0, mom);
 281         return MMSYSERR_INVALPARAM;
 282     }
 283
 284     if (MIDIMAP_LoadSettings(mom))
 285     {
 286         UINT chn;
 287         *lpdwUser = (DWORD_PTR)mom;
 288         mom->self = mom;
 289         mom->wCbFlags = HIWORD(dwFlags & CALLBACK_TYPEMASK);
 290         mom->midiDesc = *lpDesc;
 291
 292         for (chn = 0; chn < 16; chn++)
 293         {
 294             if (mom->ChannelMap[chn]->loaded) continue;
 295             if (midiOutOpen(&mom->ChannelMap[chn]->hMidi, mom->ChannelMap[chn]->uDevID,
 296                             0L, 0L, CALLBACK_NULL) == MMSYSERR_NOERROR)
 297                 mom->ChannelMap[chn]->loaded = 1;
 298             else
 299                 mom->ChannelMap[chn]->loaded = -1;
 300             /* FIXME: should load here the IDF midi data... and allow channel and
 301              * patch mappings
 302              */
 303         }
 304         MIDIMAP_NotifyClient(mom, MOM_OPEN, 0L, 0L);
 305         return MMSYSERR_NOERROR;
 306     }
 307     HeapFree(GetProcessHeap(), 0, mom);
 308     return MIDIERR_INVALIDSETUP;
 309 }
 310
 311 static  DWORD   modClose(MIDIMAPDATA* mom)
 312 {
 313     UINT        i;
 314     DWORD       ret = MMSYSERR_NOERROR;
 315
 316     if (MIDIMAP_IsBadData(mom))         return MMSYSERR_ERROR;
 317
 318     for (i = 0; i < 16; i++)
 319     {
 320         DWORD   t;
 321         if (mom->ChannelMap[i] && mom->ChannelMap[i]->loaded > 0)
 322         {
 323             t = midiOutClose(mom->ChannelMap[i]->hMidi);
 324             if (t == MMSYSERR_NOERROR)
 325             {
 326                 mom->ChannelMap[i]->loaded = 0;
 327                 mom->ChannelMap[i]->hMidi = 0;
 328             }
 329             else if (ret == MMSYSERR_NOERROR)
 330                 ret = t;
 331         }
 332     }
 333     if (ret == MMSYSERR_NOERROR) {
 334         MIDIMAP_NotifyClient(mom, MOM_CLOSE, 0L, 0L);
 335         HeapFree(GetProcessHeap(), 0, mom);
 336     }
 337     return ret;
 338 }
 339
 340 static DWORD modLongData(MIDIMAPDATA* mom, LPMIDIHDR lpMidiHdr, DWORD_PTR dwParam2)
 341 {
 342     WORD        chn;
 343     DWORD       ret = MMSYSERR_NOERROR;
 344     MIDIHDR     mh;
 345
 346     if (MIDIMAP_IsBadData(mom))
 347         return MMSYSERR_ERROR;
 348     if (!(lpMidiHdr->dwFlags & MHDR_PREPARED))
 349         return MIDIERR_UNPREPARED;
 350     if (lpMidiHdr->dwFlags & MHDR_INQUEUE)
 351         return MIDIERR_STILLPLAYING;
 352
 353     mh = *lpMidiHdr;
 354     lpMidiHdr->dwFlags &= ~MHDR_DONE;
 355     lpMidiHdr->dwFlags |= MHDR_INQUEUE;
 356     for (chn = 0; chn < 16; chn++)
 357     {
 358         if (mom->ChannelMap[chn] && mom->ChannelMap[chn]->loaded > 0)
 359         {
 360             mh.dwFlags = 0;
 361             midiOutPrepareHeader(mom->ChannelMap[chn]->hMidi, &mh, sizeof(mh));
 362             ret = midiOutLongMsg(mom->ChannelMap[chn]->hMidi, &mh, sizeof(mh));
 363             /* As of 2009, wineXYZ.drv's LongData handlers are synchronous */
 364             if (!ret && !(mh.dwFlags & MHDR_DONE))
 365                 FIXME("wait until MHDR_DONE\n");
 366             midiOutUnprepareHeader(mom->ChannelMap[chn]->hMidi, &mh, sizeof(mh));
 367             if (ret != MMSYSERR_NOERROR) break;
 368         }
 369     }
 370     lpMidiHdr->dwFlags &= ~MHDR_INQUEUE;
 371     lpMidiHdr->dwFlags |= MHDR_DONE;
 372     MIDIMAP_NotifyClient(mom, MOM_DONE, (DWORD_PTR)lpMidiHdr, 0L);
 373     return ret;
 374 }
 375
 376 static DWORD modData(MIDIMAPDATA* mom, DWORD_PTR dwParam)
 377 {
 378     BYTE        lb = LOBYTE(LOWORD(dwParam));
 379     WORD        chn = lb & 0x0F;
 380     DWORD       ret = MMSYSERR_NOERROR;
 381
 382     if (MIDIMAP_IsBadData(mom))
 383         return MMSYSERR_ERROR;
 384
 385     if (!mom->ChannelMap[chn]) return MMSYSERR_NOERROR;
 386
 387     switch (lb & 0xF0)
 388     {
 389     case 0x80:
 390     case 0x90:
 391     case 0xA0:
 392     case 0xB0:
 393     case 0xC0:
 394     case 0xD0:
 395     case 0xE0:
 396         if (mom->ChannelMap[chn]->loaded > 0)
 397         {
 398             /* change channel */
 399             dwParam &= ~0x0F;
 400             dwParam |= mom->ChannelMap[chn]->aChn[chn];
 401
 402             if ((LOBYTE(LOWORD(dwParam)) & 0xF0) == 0xC0 /* program change */ &&
 403                 mom->ChannelMap[chn]->lpbPatch)
 404             {
 405                 BYTE patch = HIBYTE(LOWORD(dwParam));
 406
 407                 /* change patch */
 408                 dwParam &= ~0x0000FF00;
 409                 dwParam |= mom->ChannelMap[chn]->lpbPatch[patch];
 410             }
 411             ret = midiOutShortMsg(mom->ChannelMap[chn]->hMidi, dwParam);
 412         }
 413         break;
 414     case 0xF0:
 415         for (chn = 0; chn < 16; chn++)
 416         {
 417             if (mom->ChannelMap[chn]->loaded > 0)
 418                 ret = midiOutShortMsg(mom->ChannelMap[chn]->hMidi, dwParam);
 419         }
 420         break;
 421     default:
 422         FIXME("ooch %lx\n", dwParam);
 423     }
 424
 425     return ret;
 426 }
 427
 428 static DWORD modPrepare(MIDIMAPDATA* mom, LPMIDIHDR lpMidiHdr, DWORD_PTR dwSize)
 429 {
 430     if (MIDIMAP_IsBadData(mom)) return MMSYSERR_ERROR;
 431     if (dwSize < offsetof(MIDIHDR,dwOffset) || lpMidiHdr == 0 || lpMidiHdr->lpData == 0)
 432         return MMSYSERR_INVALPARAM;
 433     if (lpMidiHdr->dwFlags & MHDR_PREPARED)
 434         return MMSYSERR_NOERROR;
 435
 436     lpMidiHdr->dwFlags |= MHDR_PREPARED;
 437     lpMidiHdr->dwFlags &= ~(MHDR_DONE|MHDR_INQUEUE); /* flags cleared since w2k */
 438     return MMSYSERR_NOERROR;
 439 }
 440
 441 static DWORD modUnprepare(MIDIMAPDATA* mom, LPMIDIHDR lpMidiHdr, DWORD_PTR dwSize)
 442 {
 443     if (MIDIMAP_IsBadData(mom)) return MMSYSERR_ERROR;
 444     if (dwSize < offsetof(MIDIHDR,dwOffset) || lpMidiHdr == 0 || lpMidiHdr->lpData == 0)
 445         return MMSYSERR_INVALPARAM;
 446     if (!(lpMidiHdr->dwFlags & MHDR_PREPARED))
 447         return MMSYSERR_NOERROR;
 448     if (lpMidiHdr->dwFlags & MHDR_INQUEUE)
 449         return MIDIERR_STILLPLAYING;
 450
 451     lpMidiHdr->dwFlags &= ~MHDR_PREPARED;
 452     return MMSYSERR_NOERROR;
 453 }
 454
 455 static DWORD modGetVolume(MIDIMAPDATA* mom, DWORD* lpdwVolume)
 456 {
 457     if (!lpdwVolume) return MMSYSERR_INVALPARAM;
 458     *lpdwVolume = 0xFFFFFFFF; /* tests show this initial value */
 459     return MMSYSERR_NOERROR;
 460 }
 461
 462 static DWORD modSetVolume(MIDIMAPDATA* mom, DWORD dwVolume)
 463 {
 464     /* Native forwards it to some underlying device
 465      * GetVolume returns what was last set here. */
 466     FIXME("stub\n");
 467     return MMSYSERR_NOERROR;
 468 }
 469
 470 static DWORD modGetDevCaps(UINT wDevID, MIDIMAPDATA* mom, LPMIDIOUTCAPSW lpMidiCaps, DWORD_PTR size)
 471 {
 472     static const MIDIOUTCAPSW mappercaps = {
 473         0x00FF, 0x0001, 0x0100, /* Manufacturer and Product ID */
 474         {'W','i','n','e',' ','m','i','d','i',' ','m','a','p','p','e','r',0},
 475         MOD_MAPPER, 0, 0, 0xFFFF,
 476         /* Native returns volume caps of underlying device + MIDICAPS_STREAM */
 477         MIDICAPS_VOLUME|MIDICAPS_LRVOLUME
 478     };
 479     if (lpMidiCaps == NULL) return MMSYSERR_INVALPARAM;
 480     if (!numMidiOutPorts) return MMSYSERR_BADDEVICEID;
 481
 482     memcpy(lpMidiCaps, &mappercaps, min(size, sizeof(*lpMidiCaps)));
 483     return MMSYSERR_NOERROR;
 484 }
 485
 486 static  DWORD   modReset(MIDIMAPDATA* mom)
 487 {
 488     WORD        chn;
 489     DWORD       ret = MMSYSERR_NOERROR;
 490
 491     if (MIDIMAP_IsBadData(mom))
 492         return MMSYSERR_ERROR;
 493
 494     for (chn = 0; chn < 16; chn++)
 495     {
 496         if (mom->ChannelMap[chn] && mom->ChannelMap[chn]->loaded > 0)
 497         {
 498             ret = midiOutReset(mom->ChannelMap[chn]->hMidi);
 499             if (ret != MMSYSERR_NOERROR) break;
 500         }
 501     }
 502     return ret;
 503 }
 504
 505 static LRESULT MIDIMAP_drvOpen(void);
 506 static LRESULT MIDIMAP_drvClose(void);
 507
 508 /**************************************************************************
 509  *                              modMessage (MIDIMAP.@)
 510  */
 511 DWORD WINAPI MIDIMAP_modMessage(UINT wDevID, UINT wMsg, DWORD_PTR dwUser,
 512                                 DWORD_PTR dwParam1, DWORD_PTR dwParam2)
 513 {
 514     TRACE("(%u, %04X, %08lX, %08lX, %08lX);\n",
 515           wDevID, wMsg, dwUser, dwParam1, dwParam2);
 516
 517     switch (wMsg)
 518     {
 519     case DRVM_INIT:
 520         return MIDIMAP_drvOpen();
 521     case DRVM_EXIT:
 522         return MIDIMAP_drvClose();
 523     case DRVM_ENABLE:
 524     case DRVM_DISABLE:
 525         /* FIXME: Pretend this is supported */
 526         return 0;
 527
 528     case MODM_OPEN: return modOpen((DWORD_PTR *)dwUser, (LPMIDIOPENDESC)dwParam1, dwParam2);
 529     case MODM_CLOSE:            return modClose         ((MIDIMAPDATA*)dwUser);
 530
 531     case MODM_DATA:             return modData          ((MIDIMAPDATA*)dwUser, dwParam1);
 532     case MODM_LONGDATA:         return modLongData      ((MIDIMAPDATA*)dwUser, (LPMIDIHDR)dwParam1,     dwParam2);
 533     case MODM_PREPARE:          return modPrepare       ((MIDIMAPDATA*)dwUser, (LPMIDIHDR)dwParam1,     dwParam2);
 534     case MODM_UNPREPARE:        return modUnprepare     ((MIDIMAPDATA*)dwUser, (LPMIDIHDR)dwParam1,     dwParam2);
 535     case MODM_RESET:            return modReset         ((MIDIMAPDATA*)dwUser);
 536
 537     case MODM_GETDEVCAPS:       return modGetDevCaps    (wDevID, (MIDIMAPDATA*)dwUser, (LPMIDIOUTCAPSW)dwParam1,dwParam2);
 538     case MODM_GETNUMDEVS:       return 1;
 539     case MODM_GETVOLUME:        return modGetVolume     ((MIDIMAPDATA*)dwUser, (DWORD*)dwParam1);
 540     case MODM_SETVOLUME:        return modSetVolume     ((MIDIMAPDATA*)dwUser, dwParam1);
 541     default:
 542         FIXME("unknown message %d!\n", wMsg);
 543     }
 544     return MMSYSERR_NOTSUPPORTED;
 545 }
 546
 547 /*======================================================================*
 548  *                  Driver part                                         *
 549  *======================================================================*/
 550
 551 /**************************************************************************
 552  *                              MIDIMAP_drvOpen                 [internal]
 553  */
 554 static LRESULT MIDIMAP_drvOpen(void)
 555 {
 556     MIDIOUTCAPSW        moc;
 557     unsigned            dev, i;
 558     WCHAR               throughportW[] = {'M','i','d','i',' ','T','h','r','o','u','g','h',0};
 559     BOOL                found_valid_port = FALSE;
 560
 561     if (midiOutPorts)
 562         return 0;
 563
 564     numMidiOutPorts = midiOutGetNumDevs();
 565     midiOutPorts = HeapAlloc(GetProcessHeap(), 0,
 566                              numMidiOutPorts * sizeof(MIDIOUTPORT));
 567     for (dev = 0; dev < numMidiOutPorts; dev++)
 568     {
 569         if (midiOutGetDevCapsW(dev, &moc, sizeof(moc)) == 0L)
 570         {
 571             strcpyW(midiOutPorts[dev].name, moc.szPname);
 572             midiOutPorts[dev].loaded = 0;
 573             midiOutPorts[dev].hMidi = 0;
 574             midiOutPorts[dev].uDevID = dev;
 575             midiOutPorts[dev].lpbPatch = NULL;
 576             for (i = 0; i < 16; i++)
 577                 midiOutPorts[dev].aChn[i] = i;
 578             if (strncmpW(midiOutPorts[dev].name, throughportW, strlenW(throughportW)) != 0)
 579                 found_valid_port = TRUE;
 580         }
 581         else
 582         {
 583             midiOutPorts[dev].loaded = -1;
 584         }
 585     }
 586
 587     if (!found_valid_port)
 588         ERR_(winediag)("No software synthesizer midi port found, Midi sound output probably won't work.\n");
 589
 590     return 1;
 591 }
 592
 593 /**************************************************************************
 594  *                              MIDIMAP_drvClose                [internal]
 595  */
 596 static LRESULT MIDIMAP_drvClose(void)
 597 {
 598     if (midiOutPorts)
 599     {
 600         HeapFree(GetProcessHeap(), 0, midiOutPorts);
 601         midiOutPorts = NULL;
 602         return 1;
 603     }
 604     return 0;
 605 }
 606
 607 /**************************************************************************
 608  *                              DriverProc (MIDIMAP.@)
 609  */
 610 LRESULT CALLBACK MIDIMAP_DriverProc(DWORD_PTR dwDevID, HDRVR hDriv, UINT wMsg,
 611                                     LPARAM dwParam1, LPARAM dwParam2)
 612 {
 613 /* EPP     TRACE("(%08lX, %04X, %08lX, %08lX, %08lX)\n",  */
 614 /* EPP    dwDevID, hDriv, wMsg, dwParam1, dwParam2); */
 615
 616     switch (wMsg)
 617     {
 618     case DRV_LOAD:              return 1;
 619     case DRV_FREE:              return 1;
 620     case DRV_OPEN:              return 1;
 621     case DRV_CLOSE:             return 1;
 622     case DRV_ENABLE:            return 1;
 623     case DRV_DISABLE:           return 1;
 624     case DRV_QUERYCONFIGURE:    return 1;
 625     case DRV_CONFIGURE:         MessageBoxA(0, "MIDIMAP MultiMedia Driver !", "OSS Driver", MB_OK);     return 1;
 626     case DRV_INSTALL:           return DRVCNF_RESTART;
 627     case DRV_REMOVE:            return DRVCNF_RESTART;
 628     default:
 629         return DefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
 630     }
 631 }