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