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