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
  81 typedef struct tagMIDIOUTPORT
  82 {
  83     WCHAR               name[MAXPNAMELEN];
  84     int                 loaded;
  85     HMIDIOUT            hMidi;
  86     unsigned short      uDevID;
  87     LPBYTE              lpbPatch;
  88     unsigned int        aChn[16];
  89 } MIDIOUTPORT;
  90
  91 typedef struct tagMIDIMAPDATA
  92 {
  93     struct tagMIDIMAPDATA*      self;
  94     MIDIOUTPORT*        ChannelMap[16];
  95     MIDIOPENDESC        midiDesc;
  96     WORD                wCbFlags;
  97 } MIDIMAPDATA;
  98
  99 static  MIDIOUTPORT*    midiOutPorts;
 100 static  unsigned        numMidiOutPorts;
 101
 102 static  BOOL    MIDIMAP_IsBadData(MIDIMAPDATA* mm)
 103 {
 104     if (!IsBadReadPtr(mm, sizeof(MIDIMAPDATA)) && mm->self == mm)
 105         return FALSE;
 106     TRACE("Bad midimap data (%p)\n", mm);
 107     return TRUE;
 108 }
 109
 110 static BOOL     MIDIMAP_FindPort(const WCHAR* name, unsigned* dev)
 111 {
 112     for (*dev = 0; *dev < numMidiOutPorts; (*dev)++)
 113     {
 114         TRACE("%s\n", wine_dbgstr_w(midiOutPorts[*dev].name));
 115         if (strcmpW(midiOutPorts[*dev].name, name) == 0)
 116             return TRUE;
 117     }
 118     /* try the form #nnn */
 119     if (*name == '#' && isdigit(name[1]))
 120     {
 121         const WCHAR*  ptr = name + 1;
 122         *dev = 0;
 123         do
 124         {
 125             *dev = *dev * 10 + *ptr - '0';
 126         } while (isdigit(*++ptr));
 127         if (*dev < numMidiOutPorts)
 128             return TRUE;
 129     }
 130     return FALSE;
 131 }
 132
 133 static BOOL     MIDIMAP_LoadSettingsDefault(MIDIMAPDATA* mom, const WCHAR* port)
 134 {
 135     unsigned i, dev = 0;
 136
 137     if (port != NULL && !MIDIMAP_FindPort(port, &dev))
 138     {
 139         ERR("Registry glitch: couldn't find midi out (%s)\n", wine_dbgstr_w(port));
 140         dev = 0;
 141     }
 142
 143     /* this is necessary when no midi out ports are present */
 144     if (dev >= numMidiOutPorts)
 145         return FALSE;
 146     /* sets default */
 147     for (i = 0; i < 16; i++) mom->ChannelMap[i] = &midiOutPorts[dev];
 148
 149     return TRUE;
 150 }
 151
 152 static BOOL     MIDIMAP_LoadSettingsScheme(MIDIMAPDATA* mom, const WCHAR* scheme)
 153 {
 154     HKEY        hSchemesKey, hKey, hPortKey;
 155     unsigned    i, idx, dev;
 156     WCHAR       buffer[256], port[256];
 157     DWORD       type, size, mask;
 158
 159     for (i = 0; i < 16; i++)    mom->ChannelMap[i] = NULL;
 160
 161     if (RegOpenKeyA(HKEY_LOCAL_MACHINE,
 162                     "System\\CurrentControlSet\\Control\\MediaProperties\\PrivateProperties\\Midi\\Schemes",
 163                     &hSchemesKey))
 164     {
 165         return FALSE;
 166     }
 167     if (RegOpenKeyW(hSchemesKey, scheme, &hKey))
 168     {
 169         RegCloseKey(hSchemesKey);
 170         return FALSE;
 171     }
 172
 173     for (idx = 0; !RegEnumKeyW(hKey, idx, buffer, sizeof(buffer)/sizeof(buffer[0])); idx++)
 174     {
 175         if (RegOpenKeyW(hKey, buffer, &hPortKey)) continue;
 176
 177         size = sizeof(port);
 178         if (RegQueryValueExW(hPortKey, NULL, 0, &type, (void*)port, &size)) continue;
 179
 180         if (!MIDIMAP_FindPort(port, &dev)) continue;
 181
 182         size = sizeof(mask);
 183         if (RegQueryValueExA(hPortKey, "Channels", 0, &type, (void*)&mask, &size))
 184             continue;
 185
 186         for (i = 0; i < 16; i++)
 187         {
 188             if (mask & (1 << i))
 189             {
 190                 if (mom->ChannelMap[i])
 191                     ERR("Quirks in registry, channel %u is mapped twice\n", i);
 192                 mom->ChannelMap[i] = &midiOutPorts[dev];
 193             }
 194         }
 195     }
 196
 197     RegCloseKey(hSchemesKey);
 198     RegCloseKey(hKey);
 199
 200     return TRUE;
 201 }
 202
 203 static BOOL     MIDIMAP_LoadSettings(MIDIMAPDATA* mom)
 204 {
 205     HKEY        hKey;
 206     BOOL        ret;
 207
 208     if (RegOpenKeyA(HKEY_CURRENT_USER,
 209                     "Software\\Microsoft\\Windows\\CurrentVersion\\Multimedia\\MIDIMap", &hKey))
 210     {
 211         ret = MIDIMAP_LoadSettingsDefault(mom, NULL);
 212     }
 213     else
 214     {
 215         DWORD   type, size, out;
 216         WCHAR   buffer[256];
 217
 218         ret = 2;
 219         size = sizeof(out);
 220         if (!RegQueryValueExA(hKey, "UseScheme", 0, &type, (void*)&out, &size) && out)
 221         {
 222             static const WCHAR cs[] = {'C','u','r','r','e','n','t','S','c','h','e','m','e',0};
 223             size = sizeof(buffer);
 224             if (!RegQueryValueExW(hKey, cs, 0, &type, (void*)buffer, &size))
 225             {
 226                 if (!(ret = MIDIMAP_LoadSettingsScheme(mom, buffer)))
 227                     ret = MIDIMAP_LoadSettingsDefault(mom, NULL);
 228             }
 229             else
 230             {
 231                 ERR("Wrong registry: UseScheme is active, but no CurrentScheme found\n");
 232             }
 233         }
 234         if (ret == 2)
 235         {
 236             static const WCHAR ci[] = {'C','u','r','r','e','n','t','I','n','s','t','r','u','m','e','n','t',0};
 237             size = sizeof(buffer);
 238             if (!RegQueryValueExW(hKey, ci, 0, &type, (void*)buffer, &size) && *buffer)
 239             {
 240                 ret = MIDIMAP_LoadSettingsDefault(mom, buffer);
 241             }
 242             else
 243             {
 244                 ret = MIDIMAP_LoadSettingsDefault(mom, NULL);
 245             }
 246         }
 247     }
 248     RegCloseKey(hKey);
 249
 250     if (ret && TRACE_ON(msacm))
 251     {
 252         unsigned        i;
 253
 254         for (i = 0; i < 16; i++)
 255         {
 256             TRACE("chnMap[%2d] => %d\n",
 257                   i, mom->ChannelMap[i] ? mom->ChannelMap[i]->uDevID : -1);
 258         }
 259     }
 260     return ret;
 261 }
 262
 263 static void MIDIMAP_NotifyClient(MIDIMAPDATA* mom, WORD wMsg,
 264                                  DWORD_PTR dwParam1, DWORD_PTR dwParam2)
 265 {
 266     DriverCallback(mom->midiDesc.dwCallback, mom->wCbFlags, (HDRVR)mom->midiDesc.hMidi,
 267                    wMsg, mom->midiDesc.dwInstance, dwParam1, dwParam2);
 268 }
 269
 270 static DWORD modOpen(DWORD_PTR *lpdwUser, LPMIDIOPENDESC lpDesc, DWORD dwFlags)
 271 {
 272     MIDIMAPDATA*        mom = HeapAlloc(GetProcessHeap(), 0, sizeof(MIDIMAPDATA));
 273
 274     TRACE("(%p %p %08x)\n", lpdwUser, lpDesc, dwFlags);
 275
 276     if (!mom) return MMSYSERR_NOMEM;
 277     if (!lpDesc) {
 278         HeapFree(GetProcessHeap(), 0, mom);
 279         return MMSYSERR_INVALPARAM;
 280     }
 281
 282     if (MIDIMAP_LoadSettings(mom))
 283     {
 284         *lpdwUser = (DWORD_PTR)mom;
 285         mom->self = mom;
 286
 287         mom->wCbFlags = HIWORD(dwFlags & CALLBACK_TYPEMASK);
 288         mom->midiDesc = *lpDesc;
 289         MIDIMAP_NotifyClient(mom, MOM_OPEN, 0L, 0L);
 290
 291         return MMSYSERR_NOERROR;
 292     }
 293     HeapFree(GetProcessHeap(), 0, mom);
 294     return MIDIERR_INVALIDSETUP;
 295 }
 296
 297 static  DWORD   modClose(MIDIMAPDATA* mom)
 298 {
 299     UINT        i;
 300     DWORD       ret = MMSYSERR_NOERROR;
 301
 302     if (MIDIMAP_IsBadData(mom))         return MMSYSERR_ERROR;
 303
 304     for (i = 0; i < 16; i++)
 305     {
 306         DWORD   t;
 307         if (mom->ChannelMap[i] && mom->ChannelMap[i]->loaded > 0)
 308         {
 309             t = midiOutClose(mom->ChannelMap[i]->hMidi);
 310             if (t == MMSYSERR_NOERROR)
 311             {
 312                 mom->ChannelMap[i]->loaded = 0;
 313                 mom->ChannelMap[i]->hMidi = 0;
 314             }
 315             else if (ret == MMSYSERR_NOERROR)
 316                 ret = t;
 317         }
 318     }
 319     if (ret == MMSYSERR_NOERROR) {
 320         MIDIMAP_NotifyClient(mom, MOM_CLOSE, 0L, 0L);
 321         HeapFree(GetProcessHeap(), 0, mom);
 322     }
 323     return ret;
 324 }
 325
 326 static DWORD modLongData(MIDIMAPDATA* mom, LPMIDIHDR lpMidiHdr, DWORD_PTR dwParam2)
 327 {
 328     WORD        chn;
 329     DWORD       ret = MMSYSERR_NOERROR;
 330     MIDIHDR     mh;
 331
 332     if (MIDIMAP_IsBadData(mom))
 333         return MMSYSERR_ERROR;
 334     if (!(lpMidiHdr->dwFlags & MHDR_PREPARED))
 335         return MIDIERR_UNPREPARED;
 336     if (lpMidiHdr->dwFlags & MHDR_INQUEUE)
 337         return MIDIERR_STILLPLAYING;
 338
 339     mh = *lpMidiHdr;
 340     lpMidiHdr->dwFlags &= ~MHDR_DONE;
 341     lpMidiHdr->dwFlags |= MHDR_INQUEUE;
 342     for (chn = 0; chn < 16; chn++)
 343     {
 344         if (mom->ChannelMap[chn] && mom->ChannelMap[chn]->loaded > 0)
 345         {
 346             mh.dwFlags = 0;
 347             midiOutPrepareHeader(mom->ChannelMap[chn]->hMidi, &mh, sizeof(mh));
 348             ret = midiOutLongMsg(mom->ChannelMap[chn]->hMidi, &mh, sizeof(mh));
 349             /* As of 2009, wineXYZ.drv's LongData handlers are synchronous */
 350             if (!ret && !(mh.dwFlags & MHDR_DONE))
 351                 FIXME("wait until MHDR_DONE\n");
 352             midiOutUnprepareHeader(mom->ChannelMap[chn]->hMidi, &mh, sizeof(mh));
 353             if (ret != MMSYSERR_NOERROR) break;
 354         }
 355     }
 356     lpMidiHdr->dwFlags &= ~MHDR_INQUEUE;
 357     lpMidiHdr->dwFlags |= MHDR_DONE;
 358     MIDIMAP_NotifyClient(mom, MOM_DONE, (DWORD_PTR)lpMidiHdr, 0L);
 359     return ret;
 360 }
 361
 362 static DWORD modData(MIDIMAPDATA* mom, DWORD_PTR dwParam)
 363 {
 364     BYTE        lb = LOBYTE(LOWORD(dwParam));
 365     WORD        chn = lb & 0x0F;
 366     DWORD       ret = MMSYSERR_NOERROR;
 367
 368     if (MIDIMAP_IsBadData(mom))
 369         return MMSYSERR_ERROR;
 370
 371     if (!mom->ChannelMap[chn]) return MMSYSERR_NOERROR;
 372
 373     switch (lb & 0xF0)
 374     {
 375     case 0x80:
 376     case 0x90:
 377     case 0xA0:
 378     case 0xB0:
 379     case 0xC0:
 380     case 0xD0:
 381     case 0xE0:
 382         if (mom->ChannelMap[chn]->loaded == 0)
 383         {
 384             if (midiOutOpen(&mom->ChannelMap[chn]->hMidi, mom->ChannelMap[chn]->uDevID,
 385                             0L, 0L, CALLBACK_NULL) == MMSYSERR_NOERROR)
 386                 mom->ChannelMap[chn]->loaded = 1;
 387             else
 388                 mom->ChannelMap[chn]->loaded = -1;
 389             /* FIXME: should load here the IDF midi data... and allow channel and
 390              * patch mappings
 391              */
 392         }
 393         if (mom->ChannelMap[chn]->loaded > 0)
 394         {
 395             /* change channel */
 396             dwParam &= ~0x0F;
 397             dwParam |= mom->ChannelMap[chn]->aChn[chn];
 398
 399             if ((LOBYTE(LOWORD(dwParam)) & 0xF0) == 0xC0 /* program change */ &&
 400                 mom->ChannelMap[chn]->lpbPatch)
 401             {
 402                 BYTE patch = HIBYTE(LOWORD(dwParam));
 403
 404                 /* change patch */
 405                 dwParam &= ~0x0000FF00;
 406                 dwParam |= mom->ChannelMap[chn]->lpbPatch[patch];
 407             }
 408             ret = midiOutShortMsg(mom->ChannelMap[chn]->hMidi, dwParam);
 409         }
 410         break;
 411     case 0xF0:
 412         for (chn = 0; chn < 16; chn++)
 413         {
 414             if (mom->ChannelMap[chn]->loaded > 0)
 415                 ret = midiOutShortMsg(mom->ChannelMap[chn]->hMidi, dwParam);
 416         }
 417         break;
 418     default:
 419         FIXME("ooch %lx\n", dwParam);
 420     }
 421
 422     return ret;
 423 }
 424
 425 static DWORD modPrepare(MIDIMAPDATA* mom, LPMIDIHDR lpMidiHdr, DWORD_PTR dwSize)
 426 {
 427     if (MIDIMAP_IsBadData(mom)) return MMSYSERR_ERROR;
 428     if (dwSize < offsetof(MIDIHDR,dwOffset) || lpMidiHdr == 0 ||
 429         lpMidiHdr->lpData == 0 || (lpMidiHdr->dwFlags & MHDR_INQUEUE))
 430         return MMSYSERR_INVALPARAM;
 431
 432     lpMidiHdr->dwFlags |= MHDR_PREPARED;
 433     lpMidiHdr->dwFlags &= ~MHDR_DONE;
 434     return MMSYSERR_NOERROR;
 435 }
 436
 437 static DWORD modUnprepare(MIDIMAPDATA* mom, LPMIDIHDR lpMidiHdr, DWORD_PTR dwParam2)
 438 {
 439     if (MIDIMAP_IsBadData(mom)) return MMSYSERR_ERROR;
 440     if (!(lpMidiHdr->dwFlags & MHDR_PREPARED)) return MIDIERR_UNPREPARED;
 441     if (lpMidiHdr->dwFlags & MHDR_INQUEUE) return MIDIERR_STILLPLAYING;
 442
 443     lpMidiHdr->dwFlags &= ~MHDR_PREPARED;
 444     return MMSYSERR_NOERROR;
 445 }
 446
 447 static DWORD modGetVolume(MIDIMAPDATA* mom, DWORD* lpdwVolume)
 448 {
 449     if (!lpdwVolume) return MMSYSERR_INVALPARAM;
 450     *lpdwVolume = 0xFFFFFFFF; /* tests show this initial value */
 451     return MMSYSERR_NOERROR;
 452 }
 453
 454 static DWORD modSetVolume(MIDIMAPDATA* mom, DWORD dwVolume)
 455 {
 456     /* Native forwards it to some underlying device
 457      * GetVolume returns what was last set here. */
 458     FIXME("stub\n");
 459     return MMSYSERR_NOERROR;
 460 }
 461
 462 static DWORD modGetDevCaps(UINT wDevID, MIDIMAPDATA* mom, LPMIDIOUTCAPSW lpMidiCaps, DWORD_PTR size)
 463 {
 464     static const MIDIOUTCAPSW mappercaps = {
 465         0x00FF, 0x0001, 0x0100, /* Manufacturer and Product ID */
 466         {'W','i','n','e',' ','m','i','d','i',' ','m','a','p','p','e','r',0},
 467         MOD_MAPPER, 0, 0, 0xFFFF,
 468         /* Native returns volume caps of underlying device + MIDICAPS_STREAM */
 469         MIDICAPS_VOLUME|MIDICAPS_LRVOLUME
 470     };
 471     if (lpMidiCaps == NULL) return MMSYSERR_INVALPARAM;
 472     if (!numMidiOutPorts) return MMSYSERR_BADDEVICEID;
 473
 474     memcpy(lpMidiCaps, &mappercaps, min(size, sizeof(*lpMidiCaps)));
 475     return MMSYSERR_NOERROR;
 476 }
 477
 478 static  DWORD   modReset(MIDIMAPDATA* mom)
 479 {
 480     WORD        chn;
 481     DWORD       ret = MMSYSERR_NOERROR;
 482
 483     if (MIDIMAP_IsBadData(mom))
 484         return MMSYSERR_ERROR;
 485
 486     for (chn = 0; chn < 16; chn++)
 487     {
 488         if (mom->ChannelMap[chn] && mom->ChannelMap[chn]->loaded > 0)
 489         {
 490             ret = midiOutReset(mom->ChannelMap[chn]->hMidi);
 491             if (ret != MMSYSERR_NOERROR) break;
 492         }
 493     }
 494     return ret;
 495 }
 496
 497 static LRESULT MIDIMAP_drvOpen(void);
 498 static LRESULT MIDIMAP_drvClose(void);
 499
 500 /**************************************************************************
 501  *                              modMessage (MIDIMAP.@)
 502  */
 503 DWORD WINAPI MIDIMAP_modMessage(UINT wDevID, UINT wMsg, DWORD_PTR dwUser,
 504                                 DWORD_PTR dwParam1, DWORD_PTR dwParam2)
 505 {
 506     TRACE("(%u, %04X, %08lX, %08lX, %08lX);\n",
 507           wDevID, wMsg, dwUser, dwParam1, dwParam2);
 508
 509     switch (wMsg)
 510     {
 511     case DRVM_INIT:
 512         return MIDIMAP_drvOpen();
 513     case DRVM_EXIT:
 514         return MIDIMAP_drvClose();
 515     case DRVM_ENABLE:
 516     case DRVM_DISABLE:
 517         /* FIXME: Pretend this is supported */
 518         return 0;
 519
 520     case MODM_OPEN: return modOpen((DWORD_PTR *)dwUser, (LPMIDIOPENDESC)dwParam1, dwParam2);
 521     case MODM_CLOSE:            return modClose         ((MIDIMAPDATA*)dwUser);
 522
 523     case MODM_DATA:             return modData          ((MIDIMAPDATA*)dwUser, dwParam1);
 524     case MODM_LONGDATA:         return modLongData      ((MIDIMAPDATA*)dwUser, (LPMIDIHDR)dwParam1,     dwParam2);
 525     case MODM_PREPARE:          return modPrepare       ((MIDIMAPDATA*)dwUser, (LPMIDIHDR)dwParam1,     dwParam2);
 526     case MODM_UNPREPARE:        return modUnprepare     ((MIDIMAPDATA*)dwUser, (LPMIDIHDR)dwParam1,     dwParam2);
 527     case MODM_RESET:            return modReset         ((MIDIMAPDATA*)dwUser);
 528
 529     case MODM_GETDEVCAPS:       return modGetDevCaps    (wDevID, (MIDIMAPDATA*)dwUser, (LPMIDIOUTCAPSW)dwParam1,dwParam2);
 530     case MODM_GETNUMDEVS:       return 1;
 531     case MODM_GETVOLUME:        return modGetVolume     ((MIDIMAPDATA*)dwUser, (DWORD*)dwParam1);
 532     case MODM_SETVOLUME:        return modSetVolume     ((MIDIMAPDATA*)dwUser, dwParam1);
 533     default:
 534         FIXME("unknown message %d!\n", wMsg);
 535     }
 536     return MMSYSERR_NOTSUPPORTED;
 537 }
 538
 539 /*======================================================================*
 540  *                  Driver part                                         *
 541  *======================================================================*/
 542
 543 /**************************************************************************
 544  *                              MIDIMAP_drvOpen                 [internal]
 545  */
 546 static LRESULT MIDIMAP_drvOpen(void)
 547 {
 548     MIDIOUTCAPSW        moc;
 549     unsigned            dev, i;
 550
 551     if (midiOutPorts)
 552         return 0;
 553
 554     numMidiOutPorts = midiOutGetNumDevs();
 555     midiOutPorts = HeapAlloc(GetProcessHeap(), 0,
 556                              numMidiOutPorts * sizeof(MIDIOUTPORT));
 557     for (dev = 0; dev < numMidiOutPorts; dev++)
 558     {
 559         if (midiOutGetDevCapsW(dev, &moc, sizeof(moc)) == 0L)
 560         {
 561             strcpyW(midiOutPorts[dev].name, moc.szPname);
 562             midiOutPorts[dev].loaded = 0;
 563             midiOutPorts[dev].hMidi = 0;
 564             midiOutPorts[dev].uDevID = dev;
 565             midiOutPorts[dev].lpbPatch = NULL;
 566             for (i = 0; i < 16; i++)
 567                 midiOutPorts[dev].aChn[i] = i;
 568         }
 569         else
 570         {
 571             midiOutPorts[dev].loaded = -1;
 572         }
 573     }
 574
 575     return 1;
 576 }
 577
 578 /**************************************************************************
 579  *                              MIDIMAP_drvClose                [internal]
 580  */
 581 static LRESULT MIDIMAP_drvClose(void)
 582 {
 583     if (midiOutPorts)
 584     {
 585         HeapFree(GetProcessHeap(), 0, midiOutPorts);
 586         midiOutPorts = NULL;
 587         return 1;
 588     }
 589     return 0;
 590 }
 591
 592 /**************************************************************************
 593  *                              DriverProc (MIDIMAP.@)
 594  */
 595 LRESULT CALLBACK MIDIMAP_DriverProc(DWORD_PTR dwDevID, HDRVR hDriv, UINT wMsg,
 596                                     LPARAM dwParam1, LPARAM dwParam2)
 597 {
 598 /* EPP     TRACE("(%08lX, %04X, %08lX, %08lX, %08lX)\n",  */
 599 /* EPP    dwDevID, hDriv, wMsg, dwParam1, dwParam2); */
 600
 601     switch (wMsg)
 602     {
 603     case DRV_LOAD:              return 1;
 604     case DRV_FREE:              return 1;
 605     case DRV_OPEN:              return 1;
 606     case DRV_CLOSE:             return 1;
 607     case DRV_ENABLE:            return 1;
 608     case DRV_DISABLE:           return 1;
 609     case DRV_QUERYCONFIGURE:    return 1;
 610     case DRV_CONFIGURE:         MessageBoxA(0, "MIDIMAP MultiMedia Driver !", "OSS Driver", MB_OK);     return 1;
 611     case DRV_INSTALL:           return DRVCNF_RESTART;
 612     case DRV_REMOVE:            return DRVCNF_RESTART;
 613     default:
 614         return DefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
 615     }
 616 }