dlls/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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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 "windef.h"
  30 #include "winbase.h"
  31 #include "wingdi.h"
  32 #include "winuser.h"
  33 #include "mmddk.h"
  34 #include "winreg.h"
  35 #include "wine/unicode.h"
  36 #include "wine/debug.h"
  37
  38 /*
  39  * Here's how Windows stores the midiOut mapping information.
  40  *
  41  * Full form (in HKU) is:
  42  *
  43  * [Software\\Microsoft\\Windows\\CurrentVersion\\Multimedia\\MIDIMap] 988836060
  44  * "AutoScheme"=dword:00000000
  45  * "ConfigureCount"=dword:00000004
  46  * "CurrentInstrument"="Wine OSS midi"
  47  * "CurrentScheme"="epp"
  48  * "DriverList"=""
  49  * "UseScheme"=dword:00000000
  50  *
  51  * AutoScheme:          ?
  52  * CurrentInstrument:   name of midiOut device to use when UseScheme is 0. Wine uses an extension
  53  *                      of the form #n to link to n'th midiOut device of the system
  54  * CurrentScheme:       when UseScheme is non null, it's the scheme to use (see below)
  55  * DriverList:          ?
  56  * UseScheme:           trigger for simple/complex mapping
  57  *
  58  * A scheme is defined (in HKLM) as:
  59  *
  60  * [System\\CurrentControlSet\\Control\\MediaProperties\\PrivateProperties\\Midi\\Schemes\\<nameScheme>]
  61  * <nameScheme>:        one key for each defined scheme (system wide)
  62  * under each one of these <nameScheme> keys, there's:
  63  * [...\\<nameScheme>\\<idxDevice>]
  64  * "Channels"="<bitMask>"
  65  * (the default value of this key also refers to the name of the device).
  66  *
  67  * this defines, for each midiOut device (identified by its index in <idxDevice>), which
  68  * channels have to be mapped onto it. The <bitMask> defines the channels (from 0 to 15)
  69  * will be mapped (mapping occurs for channel <ch> if bit <ch> is set in <bitMask>
  70  *
  71  * Further mapping information can also be defined in:
  72  * [System\\CurrentControlSet\\Control\\MediaProperties\\PrivateProperties\\Midi\\Ports\\<nameDevice>\\Instruments\\<idx>]
  73  * "Definition"="<.idf file>"
  74  * "FriendlyName"="#for .idx file#"
  75  * "Port"="<idxPort>"
  76  *
  77  * This last part isn't implemented (.idf file support).
  78  */
  79
  80 WINE_DEFAULT_DEBUG_CHANNEL(msacm);
  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 } MIDIMAPDATA;
  97
  98 static  MIDIOUTPORT*    midiOutPorts;
  99 static  unsigned        numMidiOutPorts;
 100
 101 static  BOOL    MIDIMAP_IsBadData(MIDIMAPDATA* mm)
 102 {
 103     if (!IsBadReadPtr(mm, sizeof(MIDIMAPDATA)) && mm->self == mm)
 104         return FALSE;
 105     TRACE("Bad midimap data (%p)\n", mm);
 106     return TRUE;
 107 }
 108
 109 static BOOL     MIDIMAP_FindPort(const WCHAR* name, unsigned* dev)
 110 {
 111     for (*dev = 0; *dev < numMidiOutPorts; (*dev)++)
 112     {
 113         TRACE("%s\n", wine_dbgstr_w(midiOutPorts[*dev].name));
 114         if (strcmpW(midiOutPorts[*dev].name, name) == 0)
 115             return TRUE;
 116     }
 117     /* try the form #nnn */
 118     if (*name == '#' && isdigit(name[1]))
 119     {
 120         const WCHAR*  ptr = name + 1;
 121         *dev = 0;
 122         do
 123         {
 124             *dev = *dev * 10 + *ptr - '0';
 125         } while (isdigit(*++ptr));
 126         if (*dev < numMidiOutPorts)
 127             return TRUE;
 128     }
 129     return FALSE;
 130 }
 131
 132 static BOOL     MIDIMAP_LoadSettingsDefault(MIDIMAPDATA* mom, const WCHAR* port)
 133 {
 134     unsigned i, dev = 0;
 135
 136     if (port != NULL && !MIDIMAP_FindPort(port, &dev))
 137     {
 138         ERR("Registry glitch: couldn't find midi out (%s)\n", wine_dbgstr_w(port));
 139         dev = 0;
 140     }
 141
 142     /* this is necessary when no midi out ports are present */
 143     if (dev >= numMidiOutPorts)
 144         return FALSE;
 145     /* sets default */
 146     for (i = 0; i < 16; i++) mom->ChannelMap[i] = &midiOutPorts[dev];
 147
 148     return TRUE;
 149 }
 150
 151 static BOOL     MIDIMAP_LoadSettingsScheme(MIDIMAPDATA* mom, const WCHAR* scheme)
 152 {
 153     HKEY        hSchemesKey, hKey, hPortKey;
 154     unsigned    i, idx, dev;
 155     WCHAR       buffer[256], port[256];
 156     DWORD       type, size, mask;
 157
 158     for (i = 0; i < 16; i++)    mom->ChannelMap[i] = NULL;
 159
 160     if (RegOpenKeyA(HKEY_LOCAL_MACHINE,
 161                     "System\\CurrentControlSet\\Control\\MediaProperties\\PrivateProperties\\Midi\\Schemes",
 162                     &hSchemesKey))
 163     {
 164         return FALSE;
 165     }
 166     if (RegOpenKeyW(hSchemesKey, scheme, &hKey))
 167     {
 168         RegCloseKey(hSchemesKey);
 169         return FALSE;
 170     }
 171
 172     for (idx = 0; !RegEnumKeyW(hKey, idx, buffer, sizeof(buffer)); idx++)
 173     {
 174         if (RegOpenKeyW(hKey, buffer, &hPortKey)) continue;
 175
 176         size = sizeof(port);
 177         if (RegQueryValueExW(hPortKey, NULL, 0, &type, (void*)port, &size)) continue;
 178
 179         if (!MIDIMAP_FindPort(port, &dev)) continue;
 180
 181         size = sizeof(mask);
 182         if (RegQueryValueExA(hPortKey, "Channels", 0, &type, (void*)&mask, &size))
 183             continue;
 184
 185         for (i = 0; i < 16; i++)
 186         {
 187             if (mask & (1 << i))
 188             {
 189                 if (mom->ChannelMap[i])
 190                     ERR("Quirks in registry, channel %u is mapped twice\n", i);
 191                 mom->ChannelMap[i] = &midiOutPorts[dev];
 192             }
 193         }
 194     }
 195
 196     RegCloseKey(hSchemesKey);
 197     RegCloseKey(hKey);
 198
 199     return TRUE;
 200 }
 201
 202 static BOOL     MIDIMAP_LoadSettings(MIDIMAPDATA* mom)
 203 {
 204     HKEY        hKey;
 205     BOOL        ret;
 206
 207     if (RegOpenKeyA(HKEY_CURRENT_USER,
 208                     "Software\\Microsoft\\Windows\\CurrentVersion\\Multimedia\\MIDIMap", &hKey))
 209     {
 210         ret = MIDIMAP_LoadSettingsDefault(mom, NULL);
 211     }
 212     else
 213     {
 214         DWORD   type, size, out;
 215         WCHAR   buffer[256];
 216
 217         ret = 2;
 218         size = sizeof(out);
 219         if (!RegQueryValueExA(hKey, "UseScheme", 0, &type, (void*)&out, &size) && out)
 220         {
 221             static const WCHAR cs[] = {'C','u','r','r','e','n','t','S','c','h','e','m','e',0};
 222             size = sizeof(buffer);
 223             if (!RegQueryValueExW(hKey, cs, 0, &type, (void*)buffer, &size))
 224             {
 225                 if (!(ret = MIDIMAP_LoadSettingsScheme(mom, buffer)))
 226                     ret = MIDIMAP_LoadSettingsDefault(mom, NULL);
 227             }
 228             else
 229             {
 230                 ERR("Wrong registry: UseScheme is active, but no CurrentScheme found\n");
 231             }
 232         }
 233         if (ret == 2)
 234         {
 235             static const WCHAR ci[] = {'C','u','r','r','e','n','t','I','n','s','t','r','u','m','e','n','t',0};
 236             size = sizeof(buffer);
 237             if (!RegQueryValueExW(hKey, ci, 0, &type, (void*)buffer, &size) && *buffer)
 238             {
 239                 ret = MIDIMAP_LoadSettingsDefault(mom, buffer);
 240             }
 241             else
 242             {
 243                 ret = MIDIMAP_LoadSettingsDefault(mom, NULL);
 244             }
 245         }
 246     }
 247     RegCloseKey(hKey);
 248
 249     if (ret && TRACE_ON(msacm))
 250     {
 251         unsigned        i;
 252
 253         for (i = 0; i < 16; i++)
 254         {
 255             TRACE("chnMap[%2d] => %d\n",
 256                   i, mom->ChannelMap[i] ? mom->ChannelMap[i]->uDevID : -1);
 257         }
 258     }
 259     return ret;
 260 }
 261
 262 static  DWORD   modOpen(LPDWORD lpdwUser, LPMIDIOPENDESC lpDesc, DWORD dwFlags)
 263 {
 264     MIDIMAPDATA*        mom = HeapAlloc(GetProcessHeap(), 0, sizeof(MIDIMAPDATA));
 265
 266     TRACE("(%p %p %08lx)\n", lpdwUser, lpDesc, dwFlags);
 267
 268     if (!mom) return MMSYSERR_NOMEM;
 269
 270     if (MIDIMAP_LoadSettings(mom))
 271     {
 272         *lpdwUser = (DWORD)mom;
 273         mom->self = mom;
 274
 275         return MMSYSERR_NOERROR;
 276     }
 277     HeapFree(GetProcessHeap(), 0, mom);
 278     return MIDIERR_INVALIDSETUP;
 279 }
 280
 281 static  DWORD   modClose(MIDIMAPDATA* mom)
 282 {
 283     UINT        i;
 284     DWORD       ret = MMSYSERR_NOERROR;
 285
 286     if (MIDIMAP_IsBadData(mom))         return MMSYSERR_ERROR;
 287
 288     for (i = 0; i < 16; i++)
 289     {
 290         DWORD   t;
 291         if (mom->ChannelMap[i] && mom->ChannelMap[i]->loaded > 0)
 292         {
 293             t = midiOutClose(mom->ChannelMap[i]->hMidi);
 294             if (t == MMSYSERR_NOERROR)
 295             {
 296                 mom->ChannelMap[i]->loaded = 0;
 297                 mom->ChannelMap[i]->hMidi = 0;
 298             }
 299             else if (ret == MMSYSERR_NOERROR)
 300                 ret = t;
 301         }
 302     }
 303     if (ret == MMSYSERR_NOERROR)
 304         HeapFree(GetProcessHeap(), 0, mom);
 305     return ret;
 306 }
 307
 308 static  DWORD   modLongData(MIDIMAPDATA* mom, LPMIDIHDR lpMidiHdr, DWORD dwParam2)
 309 {
 310     WORD        chn;
 311     DWORD       ret = MMSYSERR_NOERROR;
 312     MIDIHDR     mh;
 313
 314     if (MIDIMAP_IsBadData(mom))
 315         return MMSYSERR_ERROR;
 316
 317     mh = *lpMidiHdr;
 318     for (chn = 0; chn < 16; chn++)
 319     {
 320         if (mom->ChannelMap[chn] && mom->ChannelMap[chn]->loaded > 0)
 321         {
 322             mh.dwFlags = 0;
 323             midiOutPrepareHeader(mom->ChannelMap[chn]->hMidi, &mh, sizeof(mh));
 324             ret = midiOutLongMsg(mom->ChannelMap[chn]->hMidi, &mh, sizeof(mh));
 325             midiOutUnprepareHeader(mom->ChannelMap[chn]->hMidi, &mh, sizeof(mh));
 326             if (ret != MMSYSERR_NOERROR) break;
 327         }
 328     }
 329     return ret;
 330 }
 331
 332 static  DWORD   modData(MIDIMAPDATA* mom, DWORD dwParam)
 333 {
 334     BYTE        lb = LOBYTE(LOWORD(dwParam));
 335     WORD        chn = lb & 0x0F;
 336     DWORD       ret = MMSYSERR_NOERROR;
 337
 338     if (MIDIMAP_IsBadData(mom))
 339         return MMSYSERR_ERROR;
 340
 341     if (!mom->ChannelMap[chn]) return MMSYSERR_NOERROR;
 342
 343     switch (lb & 0xF0)
 344     {
 345     case 0x80:
 346     case 0x90:
 347     case 0xA0:
 348     case 0xB0:
 349     case 0xC0:
 350     case 0xD0:
 351     case 0xE0:
 352         if (mom->ChannelMap[chn]->loaded == 0)
 353         {
 354             if (midiOutOpen(&mom->ChannelMap[chn]->hMidi, mom->ChannelMap[chn]->uDevID,
 355                             0L, 0L, CALLBACK_NULL) == MMSYSERR_NOERROR)
 356                 mom->ChannelMap[chn]->loaded = 1;
 357             else
 358                 mom->ChannelMap[chn]->loaded = -1;
 359             /* FIXME: should load here the IDF midi data... and allow channel and
 360              * patch mappings
 361              */
 362         }
 363         if (mom->ChannelMap[chn]->loaded > 0)
 364         {
 365             /* change channel */
 366             dwParam &= ~0x0F;
 367             dwParam |= mom->ChannelMap[chn]->aChn[chn];
 368
 369             if ((LOBYTE(LOWORD(dwParam)) & 0xF0) == 0xC0 /* program change */ &&
 370                 mom->ChannelMap[chn]->lpbPatch)
 371             {
 372                 BYTE patch = HIBYTE(LOWORD(dwParam));
 373
 374                 /* change patch */
 375                 dwParam &= ~0x0000FF00;
 376                 dwParam |= mom->ChannelMap[chn]->lpbPatch[patch];
 377             }
 378             ret = midiOutShortMsg(mom->ChannelMap[chn]->hMidi, dwParam);
 379         }
 380         break;
 381     case 0xF0:
 382         for (chn = 0; chn < 16; chn++)
 383         {
 384             if (mom->ChannelMap[chn]->loaded > 0)
 385                 ret = midiOutShortMsg(mom->ChannelMap[chn]->hMidi, dwParam);
 386         }
 387         break;
 388     default:
 389         FIXME("ooch %lu\n", dwParam);
 390     }
 391
 392     return ret;
 393 }
 394
 395 static  DWORD   modPrepare(MIDIMAPDATA* mom, LPMIDIHDR lpMidiHdr, DWORD dwParam2)
 396 {
 397     if (MIDIMAP_IsBadData(mom)) return MMSYSERR_ERROR;
 398     if (lpMidiHdr->dwFlags & (MHDR_ISSTRM|MHDR_PREPARED))
 399         return MMSYSERR_INVALPARAM;
 400
 401     lpMidiHdr->dwFlags |= MHDR_PREPARED;
 402     return MMSYSERR_NOERROR;
 403 }
 404
 405 static  DWORD   modUnprepare(MIDIMAPDATA* mom, LPMIDIHDR lpMidiHdr, DWORD dwParam2)
 406 {
 407     if (MIDIMAP_IsBadData(mom)) return MMSYSERR_ERROR;
 408     if ((lpMidiHdr->dwFlags & MHDR_ISSTRM) || !(lpMidiHdr->dwFlags & MHDR_PREPARED))
 409         return MMSYSERR_INVALPARAM;
 410
 411     lpMidiHdr->dwFlags &= ~MHDR_PREPARED;
 412     return MMSYSERR_NOERROR;
 413 }
 414
 415 static  DWORD   modGetDevCaps(UINT wDevID, MIDIMAPDATA* mom, LPMIDIOUTCAPSW lpMidiCaps, DWORD size)
 416 {
 417     static const WCHAR name[] = {'W','i','n','e',' ','m','i','d','i',' ','m','a','p','p','e','r',0};
 418     lpMidiCaps->wMid = 0x00FF;
 419     lpMidiCaps->wPid = 0x0001;
 420     lpMidiCaps->vDriverVersion = 0x0100;
 421     lstrcpyW(lpMidiCaps->szPname, name);
 422     lpMidiCaps->wTechnology = MOD_MAPPER;
 423     lpMidiCaps->wVoices = 0;
 424     lpMidiCaps->wNotes = 0;
 425     lpMidiCaps->wChannelMask = 0xFFFF;
 426     lpMidiCaps->dwSupport = 0L;
 427
 428     return MMSYSERR_NOERROR;
 429 }
 430
 431 static  DWORD   modReset(MIDIMAPDATA* mom)
 432 {
 433     WORD        chn;
 434     DWORD       ret = MMSYSERR_NOERROR;
 435
 436     if (MIDIMAP_IsBadData(mom))
 437         return MMSYSERR_ERROR;
 438
 439     for (chn = 0; chn < 16; chn++)
 440     {
 441         if (mom->ChannelMap[chn] && mom->ChannelMap[chn]->loaded > 0)
 442         {
 443             ret = midiOutReset(mom->ChannelMap[chn]->hMidi);
 444             if (ret != MMSYSERR_NOERROR) break;
 445         }
 446     }
 447     return ret;
 448 }
 449
 450 /**************************************************************************
 451  *                              modMessage (MIDIMAP.@)
 452  */
 453 DWORD WINAPI MIDIMAP_modMessage(UINT wDevID, UINT wMsg, DWORD dwUser,
 454                                 DWORD dwParam1, DWORD dwParam2)
 455 {
 456     TRACE("(%u, %04X, %08lX, %08lX, %08lX);\n",
 457           wDevID, wMsg, dwUser, dwParam1, dwParam2);
 458
 459     switch (wMsg)
 460     {
 461     case DRVM_INIT:
 462     case DRVM_EXIT:
 463     case DRVM_ENABLE:
 464     case DRVM_DISABLE:
 465         /* FIXME: Pretend this is supported */
 466         return 0;
 467
 468     case MODM_OPEN:             return modOpen          ((LPDWORD)dwUser,      (LPMIDIOPENDESC)dwParam1,dwParam2);
 469     case MODM_CLOSE:            return modClose         ((MIDIMAPDATA*)dwUser);
 470
 471     case MODM_DATA:             return modData          ((MIDIMAPDATA*)dwUser, dwParam1);
 472     case MODM_LONGDATA:         return modLongData      ((MIDIMAPDATA*)dwUser, (LPMIDIHDR)dwParam1,     dwParam2);
 473     case MODM_PREPARE:          return modPrepare       ((MIDIMAPDATA*)dwUser, (LPMIDIHDR)dwParam1,     dwParam2);
 474     case MODM_UNPREPARE:        return modUnprepare     ((MIDIMAPDATA*)dwUser, (LPMIDIHDR)dwParam1,     dwParam2);
 475     case MODM_RESET:            return modReset         ((MIDIMAPDATA*)dwUser);
 476
 477     case MODM_GETDEVCAPS:       return modGetDevCaps    (wDevID, (MIDIMAPDATA*)dwUser, (LPMIDIOUTCAPSW)dwParam1,dwParam2);
 478     case MODM_GETNUMDEVS:       return 1;
 479     case MODM_GETVOLUME:        return MMSYSERR_NOTSUPPORTED;
 480     case MODM_SETVOLUME:        return MMSYSERR_NOTSUPPORTED;
 481     default:
 482         FIXME("unknown message %d!\n", wMsg);
 483     }
 484     return MMSYSERR_NOTSUPPORTED;
 485 }
 486
 487 /*======================================================================*
 488  *                  Driver part                                         *
 489  *======================================================================*/
 490
 491 /**************************************************************************
 492  *                              MIDIMAP_drvOpen                 [internal]
 493  */
 494 static  DWORD   MIDIMAP_drvOpen(LPSTR str)
 495 {
 496     MIDIOUTCAPSW        moc;
 497     unsigned            dev, i;
 498
 499     if (midiOutPorts)
 500         return 0;
 501
 502     numMidiOutPorts = midiOutGetNumDevs();
 503     midiOutPorts = HeapAlloc(GetProcessHeap(), 0,
 504                              numMidiOutPorts * sizeof(MIDIOUTPORT));
 505     for (dev = 0; dev < numMidiOutPorts; dev++)
 506     {
 507         if (midiOutGetDevCapsW(dev, &moc, sizeof(moc)) == 0L)
 508         {
 509             strcpyW(midiOutPorts[dev].name, moc.szPname);
 510             midiOutPorts[dev].loaded = 0;
 511             midiOutPorts[dev].hMidi = 0;
 512             midiOutPorts[dev].uDevID = dev;
 513             midiOutPorts[dev].lpbPatch = NULL;
 514             for (i = 0; i < 16; i++)
 515                 midiOutPorts[dev].aChn[i] = i;
 516         }
 517         else
 518         {
 519             midiOutPorts[dev].loaded = -1;
 520         }
 521     }
 522
 523     return 1;
 524 }
 525
 526 /**************************************************************************
 527  *                              MIDIMAP_drvClose                [internal]
 528  */
 529 static  DWORD   MIDIMAP_drvClose(DWORD dwDevID)
 530 {
 531     if (midiOutPorts)
 532     {
 533         HeapFree(GetProcessHeap(), 0, midiOutPorts);
 534         midiOutPorts = NULL;
 535         return 1;
 536     }
 537     return 0;
 538 }
 539
 540 /**************************************************************************
 541  *                              DriverProc (MIDIMAP.@)
 542  */
 543 LONG CALLBACK   MIDIMAP_DriverProc(DWORD dwDevID, HDRVR hDriv, DWORD wMsg,
 544                                    DWORD dwParam1, DWORD dwParam2)
 545 {
 546 /* EPP     TRACE("(%08lX, %04X, %08lX, %08lX, %08lX)\n",  */
 547 /* EPP    dwDevID, hDriv, wMsg, dwParam1, dwParam2); */
 548
 549     switch (wMsg)
 550     {
 551     case DRV_LOAD:              return 1;
 552     case DRV_FREE:              return 1;
 553     case DRV_OPEN:              return MIDIMAP_drvOpen((LPSTR)dwParam1);
 554     case DRV_CLOSE:             return MIDIMAP_drvClose(dwDevID);
 555     case DRV_ENABLE:            return 1;
 556     case DRV_DISABLE:           return 1;
 557     case DRV_QUERYCONFIGURE:    return 1;
 558     case DRV_CONFIGURE:         MessageBoxA(0, "MIDIMAP MultiMedia Driver !", "OSS Driver", MB_OK);     return 1;
 559     case DRV_INSTALL:           return DRVCNF_RESTART;
 560     case DRV_REMOVE:            return DRVCNF_RESTART;
 561     default:
 562         return DefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
 563     }
 564 }