dll/win32/winmm/midimap/midimap.c

   1 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
   2 /*
   3  * Wine MIDI mapper driver
   4  *
   5  * Copyright    1999, 2000, 2001 Eric Pouech
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  20  *
  21  * TODO:
  22  *      notification has to be implemented
  23  *      IDF file loading
  24  */
  25
  26 #include <stdarg.h>
  27 //#include <string.h>
  28 //#include <stdlib.h>
  29 //#include <ctype.h>
  30 #include <windef.h>
  31 //#include "winbase.h"
  32 //#include "wingdi.h"
  33 #include <winuser.h>
  34 #include <mmddk.h>
  35 #include <winreg.h>
  36 #include <wine/unicode.h>
  37 #include <wine/debug.h>
  38
  39 /*
  40  * Here's how Windows stores the midiOut mapping information.
  41  *
  42  * Full form (in HKU) is:
  43  *
  44  * [Software\\Microsoft\\Windows\\CurrentVersion\\Multimedia\\MIDIMap] 988836060
  45  * "AutoScheme"=dword:00000000
  46  * "ConfigureCount"=dword:00000004
  47  * "CurrentInstrument"="Wine OSS midi"
  48  * "CurrentScheme"="epp"
  49  * "DriverList"=""
  50  * "UseScheme"=dword:00000000
  51  *
  52  * AutoScheme:          ?
  53  * CurrentInstrument:   name of midiOut device to use when UseScheme is 0. Wine uses an extension
  54  *                      of the form #n to link to n'th midiOut device of the system
  55  * CurrentScheme:       when UseScheme is non null, it's the scheme to use (see below)
  56  * DriverList:          ?
  57  * UseScheme:           trigger for simple/complex mapping
  58  *
  59  * A scheme is defined (in HKLM) as:
  60  *
  61  * [System\\CurrentControlSet\\Control\\MediaProperties\\PrivateProperties\\Midi\\Schemes\\<nameScheme>]
  62  * <nameScheme>:        one key for each defined scheme (system wide)
  63  * under each one of these <nameScheme> keys, there's:
  64  * [...\\<nameScheme>\\<idxDevice>]
  65  * "Channels"="<bitMask>"
  66  * (the default value of this key also refers to the name of the device).
  67  *
  68  * this defines, for each midiOut device (identified by its index in <idxDevice>), which
  69  * channels have to be mapped onto it. The <bitMask> defines the channels (from 0 to 15)
  70  * will be mapped (mapping occurs for channel <ch> if bit <ch> is set in <bitMask>
  71  *
  72  * Further mapping information can also be defined in:
  73  * [System\\CurrentControlSet\\Control\\MediaProperties\\PrivateProperties\\Midi\\Ports\\<nameDevice>\\Instruments\\<idx>]
  74  * "Definition"="<.idf file>"
  75  * "FriendlyName"="#for .idx file#"
  76  * "Port"="<idxPort>"
  77  *
  78  * This last part isn't implemented (.idf file support).
  79  */
  80
  81 WINE_DEFAULT_DEBUG_CHANNEL(msacm);
  82
  83 typedef struct tagMIDIOUTPORT
  84 {
  85     WCHAR               name[MAXPNAMELEN];
  86     int                 loaded;
  87     HMIDIOUT            hMidi;
  88     unsigned short      uDevID;
  89     LPBYTE              lpbPatch;
  90     unsigned int        aChn[16];
  91 } MIDIOUTPORT;
  92
  93 typedef struct tagMIDIMAPDATA
  94 {
  95     struct tagMIDIMAPDATA*      self;
  96     MIDIOUTPORT*        ChannelMap[16];
  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)); 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  DWORD   modOpen(DWORD_PTR *lpdwUser, LPMIDIOPENDESC lpDesc, DWORD dwFlags)
 264 {
 265     MIDIMAPDATA*        mom = HeapAlloc(GetProcessHeap(), 0, sizeof(MIDIMAPDATA));
 266
 267     TRACE("(%p %p %08lx)\n", lpdwUser, lpDesc, dwFlags);
 268
 269     if (!mom) return MMSYSERR_NOMEM;
 270
 271     if (MIDIMAP_LoadSettings(mom))
 272     {
 273         *lpdwUser = (DWORD_PTR)mom;
 274         mom->self = mom;
 275
 276         return MMSYSERR_NOERROR;
 277     }
 278     HeapFree(GetProcessHeap(), 0, mom);
 279     return MIDIERR_INVALIDSETUP;
 280 }
 281
 282 static  DWORD   modClose(MIDIMAPDATA* mom)
 283 {
 284     UINT        i;
 285     DWORD       ret = MMSYSERR_NOERROR;
 286
 287     if (MIDIMAP_IsBadData(mom))         return MMSYSERR_ERROR;
 288
 289     for (i = 0; i < 16; i++)
 290     {
 291         DWORD   t;
 292         if (mom->ChannelMap[i] && mom->ChannelMap[i]->loaded > 0)
 293         {
 294             t = midiOutClose(mom->ChannelMap[i]->hMidi);
 295             if (t == MMSYSERR_NOERROR)
 296             {
 297                 mom->ChannelMap[i]->loaded = 0;
 298                 mom->ChannelMap[i]->hMidi = 0;
 299             }
 300             else if (ret == MMSYSERR_NOERROR)
 301                 ret = t;
 302         }
 303     }
 304     if (ret == MMSYSERR_NOERROR)
 305         HeapFree(GetProcessHeap(), 0, mom);
 306     return ret;
 307 }
 308
 309 static  DWORD   modLongData(MIDIMAPDATA* mom, LPMIDIHDR lpMidiHdr, DWORD_PTR dwParam2)
 310 {
 311     WORD        chn;
 312     DWORD       ret = MMSYSERR_NOERROR;
 313     MIDIHDR     mh;
 314
 315     if (MIDIMAP_IsBadData(mom))
 316         return MMSYSERR_ERROR;
 317
 318     mh = *lpMidiHdr;
 319     for (chn = 0; chn < 16; chn++)
 320     {
 321         if (mom->ChannelMap[chn] && mom->ChannelMap[chn]->loaded > 0)
 322         {
 323             mh.dwFlags = 0;
 324             midiOutPrepareHeader(mom->ChannelMap[chn]->hMidi, &mh, sizeof(mh));
 325             ret = midiOutLongMsg(mom->ChannelMap[chn]->hMidi, &mh, sizeof(mh));
 326             midiOutUnprepareHeader(mom->ChannelMap[chn]->hMidi, &mh, sizeof(mh));
 327             if (ret != MMSYSERR_NOERROR) break;
 328         }
 329     }
 330     return ret;
 331 }
 332
 333 static  DWORD   modData(MIDIMAPDATA* mom, DWORD_PTR dwParam)
 334 {
 335     BYTE        lb = LOBYTE(LOWORD(dwParam));
 336     WORD        chn = lb & 0x0F;
 337     DWORD       ret = MMSYSERR_NOERROR;
 338
 339     if (MIDIMAP_IsBadData(mom))
 340         return MMSYSERR_ERROR;
 341
 342     if (!mom->ChannelMap[chn]) return MMSYSERR_NOERROR;
 343
 344     switch (lb & 0xF0)
 345     {
 346     case 0x80:
 347     case 0x90:
 348     case 0xA0:
 349     case 0xB0:
 350     case 0xC0:
 351     case 0xD0:
 352     case 0xE0:
 353         if (mom->ChannelMap[chn]->loaded == 0)
 354         {
 355             if (midiOutOpen(&mom->ChannelMap[chn]->hMidi, mom->ChannelMap[chn]->uDevID,
 356                             0L, 0L, CALLBACK_NULL) == MMSYSERR_NOERROR)
 357                 mom->ChannelMap[chn]->loaded = 1;
 358             else
 359                 mom->ChannelMap[chn]->loaded = -1;
 360             /* FIXME: should load here the IDF midi data... and allow channel and
 361              * patch mappings
 362              */
 363         }
 364         if (mom->ChannelMap[chn]->loaded > 0)
 365         {
 366             /* change channel */
 367             dwParam &= ~0x0F;
 368             dwParam |= mom->ChannelMap[chn]->aChn[chn];
 369
 370             if ((LOBYTE(LOWORD(dwParam)) & 0xF0) == 0xC0 /* program change */ &&
 371                 mom->ChannelMap[chn]->lpbPatch)
 372             {
 373                 BYTE patch = HIBYTE(LOWORD(dwParam));
 374
 375                 /* change patch */
 376                 dwParam &= ~0x0000FF00;
 377                 dwParam |= mom->ChannelMap[chn]->lpbPatch[patch];
 378             }
 379             ret = midiOutShortMsg(mom->ChannelMap[chn]->hMidi, dwParam);
 380         }
 381         break;
 382     case 0xF0:
 383         for (chn = 0; chn < 16; chn++)
 384         {
 385             if (mom->ChannelMap[chn]->loaded > 0)
 386                 ret = midiOutShortMsg(mom->ChannelMap[chn]->hMidi, dwParam);
 387         }
 388         break;
 389     default:
 390         FIXME("ooch %lu\n", dwParam);
 391     }
 392
 393     return ret;
 394 }
 395
 396 static  DWORD   modPrepare(MIDIMAPDATA* mom, LPMIDIHDR lpMidiHdr, DWORD_PTR dwParam2)
 397 {
 398     if (MIDIMAP_IsBadData(mom)) return MMSYSERR_ERROR;
 399     if (lpMidiHdr->dwFlags & (MHDR_ISSTRM|MHDR_PREPARED))
 400         return MMSYSERR_INVALPARAM;
 401
 402     lpMidiHdr->dwFlags |= MHDR_PREPARED;
 403     return MMSYSERR_NOERROR;
 404 }
 405
 406 static  DWORD   modUnprepare(MIDIMAPDATA* mom, LPMIDIHDR lpMidiHdr, DWORD_PTR dwParam2)
 407 {
 408     if (MIDIMAP_IsBadData(mom)) return MMSYSERR_ERROR;
 409     if ((lpMidiHdr->dwFlags & MHDR_ISSTRM) || !(lpMidiHdr->dwFlags & MHDR_PREPARED))
 410         return MMSYSERR_INVALPARAM;
 411
 412     lpMidiHdr->dwFlags &= ~MHDR_PREPARED;
 413     return MMSYSERR_NOERROR;
 414 }
 415
 416 static  DWORD   modGetDevCaps(UINT wDevID, MIDIMAPDATA* mom, LPMIDIOUTCAPSW lpMidiCaps, DWORD_PTR size)
 417 {
 418     static const WCHAR name[] = {'W','i','n','e',' ','m','i','d','i',' ','m','a','p','p','e','r',0};
 419     lpMidiCaps->wMid = 0x00FF;
 420     lpMidiCaps->wPid = 0x0001;
 421     lpMidiCaps->vDriverVersion = 0x0100;
 422     lstrcpyW(lpMidiCaps->szPname, name);
 423     lpMidiCaps->wTechnology = MOD_MAPPER;
 424     lpMidiCaps->wVoices = 0;
 425     lpMidiCaps->wNotes = 0;
 426     lpMidiCaps->wChannelMask = 0xFFFF;
 427     lpMidiCaps->dwSupport = 0L;
 428
 429     return MMSYSERR_NOERROR;
 430 }
 431
 432 static  DWORD   modReset(MIDIMAPDATA* mom)
 433 {
 434     WORD        chn;
 435     DWORD       ret = MMSYSERR_NOERROR;
 436
 437     if (MIDIMAP_IsBadData(mom))
 438         return MMSYSERR_ERROR;
 439
 440     for (chn = 0; chn < 16; chn++)
 441     {
 442         if (mom->ChannelMap[chn] && mom->ChannelMap[chn]->loaded > 0)
 443         {
 444             ret = midiOutReset(mom->ChannelMap[chn]->hMidi);
 445             if (ret != MMSYSERR_NOERROR) break;
 446         }
 447     }
 448     return ret;
 449 }
 450
 451 /**************************************************************************
 452  *                              modMessage (MIDIMAP.@)
 453  */
 454 DWORD WINAPI MIDIMAP_modMessage(UINT wDevID, UINT wMsg, DWORD_PTR dwUser,
 455                                 DWORD_PTR dwParam1, DWORD_PTR dwParam2)
 456 {
 457     TRACE("(%u, %04X, %08lX, %08lX, %08lX);\n",
 458           wDevID, wMsg, dwUser, dwParam1, dwParam2);
 459
 460     switch (wMsg)
 461     {
 462     case DRVM_INIT:
 463     case DRVM_EXIT:
 464     case DRVM_ENABLE:
 465     case DRVM_DISABLE:
 466         /* FIXME: Pretend this is supported */
 467         return 0;
 468
 469     case MODM_OPEN:             return modOpen          ((LPDWORD)dwUser,      (LPMIDIOPENDESC)dwParam1,dwParam2);
 470     case MODM_CLOSE:            return modClose         ((MIDIMAPDATA*)dwUser);
 471
 472     case MODM_DATA:             return modData          ((MIDIMAPDATA*)dwUser, dwParam1);
 473     case MODM_LONGDATA:         return modLongData      ((MIDIMAPDATA*)dwUser, (LPMIDIHDR)dwParam1,     dwParam2);
 474     case MODM_PREPARE:          return modPrepare       ((MIDIMAPDATA*)dwUser, (LPMIDIHDR)dwParam1,     dwParam2);
 475     case MODM_UNPREPARE:        return modUnprepare     ((MIDIMAPDATA*)dwUser, (LPMIDIHDR)dwParam1,     dwParam2);
 476     case MODM_RESET:            return modReset         ((MIDIMAPDATA*)dwUser);
 477
 478     case MODM_GETDEVCAPS:       return modGetDevCaps    (wDevID, (MIDIMAPDATA*)dwUser, (LPMIDIOUTCAPSW)dwParam1,dwParam2);
 479     case MODM_GETNUMDEVS:       return 1;
 480     case MODM_GETVOLUME:        return MMSYSERR_NOTSUPPORTED;
 481     case MODM_SETVOLUME:        return MMSYSERR_NOTSUPPORTED;
 482     default:
 483         FIXME("unknown message %d!\n", wMsg);
 484     }
 485     return MMSYSERR_NOTSUPPORTED;
 486 }
 487
 488 /*======================================================================*
 489  *                  Driver part                                         *
 490  *======================================================================*/
 491
 492 /**************************************************************************
 493  *                              MIDIMAP_drvOpen                 [internal]
 494  */
 495 static  LRESULT MIDIMAP_drvOpen(LPSTR str)
 496 {
 497     MIDIOUTCAPSW        moc;
 498     unsigned            dev, i;
 499
 500     if (midiOutPorts)
 501         return 0;
 502
 503     numMidiOutPorts = midiOutGetNumDevs();
 504     midiOutPorts = HeapAlloc(GetProcessHeap(), 0,
 505                              numMidiOutPorts * sizeof(MIDIOUTPORT));
 506     for (dev = 0; dev < numMidiOutPorts; dev++)
 507     {
 508         if (midiOutGetDevCapsW(dev, &moc, sizeof(moc)) == 0L)
 509         {
 510             strcpyW(midiOutPorts[dev].name, moc.szPname);
 511             midiOutPorts[dev].loaded = 0;
 512             midiOutPorts[dev].hMidi = 0;
 513             midiOutPorts[dev].uDevID = dev;
 514             midiOutPorts[dev].lpbPatch = NULL;
 515             for (i = 0; i < 16; i++)
 516                 midiOutPorts[dev].aChn[i] = i;
 517         }
 518         else
 519         {
 520             midiOutPorts[dev].loaded = -1;
 521         }
 522     }
 523
 524     return 1;
 525 }
 526
 527 /**************************************************************************
 528  *                              MIDIMAP_drvClose                [internal]
 529  */
 530 static  LRESULT MIDIMAP_drvClose(DWORD_PTR dwDevID)
 531 {
 532     if (midiOutPorts)
 533     {
 534         HeapFree(GetProcessHeap(), 0, midiOutPorts);
 535         midiOutPorts = NULL;
 536         return 1;
 537     }
 538     return 0;
 539 }
 540
 541 /**************************************************************************
 542  *                              DriverProc (MIDIMAP.@)
 543  */
 544 LRESULT CALLBACK        MIDIMAP_DriverProc(DWORD_PTR dwDevID, HDRVR hDriv, UINT wMsg,
 545                                    LPARAM dwParam1, LPARAM dwParam2)
 546 {
 547 /* EPP     TRACE("(%08lX, %04X, %08lX, %08lX, %08lX)\n",  */
 548 /* EPP    dwDevID, hDriv, wMsg, dwParam1, dwParam2); */
 549
 550     switch (wMsg)
 551     {
 552     case DRV_LOAD:              return 1;
 553     case DRV_FREE:              return 1;
 554     case DRV_OPEN:              return MIDIMAP_drvOpen((LPSTR)dwParam1);
 555     case DRV_CLOSE:             return MIDIMAP_drvClose(dwDevID);
 556     case DRV_ENABLE:            return 1;
 557     case DRV_DISABLE:           return 1;
 558     case DRV_QUERYCONFIGURE:    return 1;
 559     case DRV_CONFIGURE:         MessageBoxA(0, "MIDIMAP MultiMedia Driver !", "OSS Driver", MB_OK);     return 1;
 560     case DRV_INSTALL:           return DRVCNF_RESTART;
 561     case DRV_REMOVE:            return DRVCNF_RESTART;
 562     default:
 563         return DefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
 564     }
 565 }