git.oblomov.eu Git - wine/blob - dlls/winmm/lolvldrv.c

   1 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
   2
   3 /*
   4  * MMSYSTEM low level drivers handling functions
   5  *
   6  * Copyright 1999 Eric Pouech
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  21  */
  22
  23 #include "config.h"
  24 #include "wine/port.h"
  25
  26 #define NONAMELESSUNION
  27 #define NONAMELESSSTRUCT
  28 #define COBJMACROS
  29 #include <string.h>
  30 #include <stdarg.h>
  31 #include <stdio.h>
  32 #include <assert.h>
  33 #include "windef.h"
  34 #include "winbase.h"
  35 #include "winreg.h"
  36 #include "winnls.h"
  37 #include "winemm.h"
  38 #include "wine/debug.h"
  39 #include "wine/exception.h"
  40
  41 #include "wingdi.h"
  42 #include "ole2.h"
  43 #include "devpkey.h"
  44 #include "mmdeviceapi.h"
  45
  46 WINE_DEFAULT_DEBUG_CHANNEL(winmm);
  47
  48 /* Default set of drivers to be loaded */
  49 #define WINE_DEFAULT_WINMM_DRIVER "alsa,oss,coreaudio"
  50
  51 /* each known type of driver has an instance of this structure */
  52 typedef struct tagWINE_LLTYPE {
  53     /* those attributes depend on the specification of the type */
  54     LPCSTR              typestr;        /* name (for debugging) */
  55     /* those attributes reflect the loaded/current situation for the type */
  56     UINT                wMaxId;         /* number of loaded devices (sum across all loaded drivers) */
  57     LPWINE_MLD          lpMlds;         /* "static" mlds to access the part though device IDs */
  58     int                 nMapper;        /* index to mapper */
  59 } WINE_LLTYPE;
  60
  61 static WINE_LLTYPE llTypes[MMDRV_MAX] = {
  62     { "Aux", 0, 0, -1 },
  63     { "Mixer", 0, 0, -1 },
  64     { "MidiIn", 0, 0, -1 },
  65     { "MidiOut", 0, 0, -1 },
  66     { "WaveIn", 0, 0, -1 },
  67     { "WaveOut", 0, 0, -1 }
  68 };
  69
  70 static int drivers_loaded, MMDrvsHi;
  71 static WINE_MM_DRIVER   MMDrvs[8];
  72 static LPWINE_MLD       MM_MLDrvs[40];
  73 #define MAX_MM_MLDRVS   (sizeof(MM_MLDrvs) / sizeof(MM_MLDrvs[0]))
  74
  75 static void MMDRV_Init(void);
  76
  77 static void MMDRV_InitSingleType(UINT type) {
  78     if (!drivers_loaded) {
  79         drivers_loaded = 1;
  80         MMDRV_Init();
  81     }
  82 }
  83
  84 /**************************************************************************
  85  *                      MMDRV_GetNum                            [internal]
  86  */
  87 UINT    MMDRV_GetNum(UINT type)
  88 {
  89     TRACE("(%04x)\n", type);
  90     assert(type < MMDRV_MAX);
  91     MMDRV_InitSingleType(type);
  92     return llTypes[type].wMaxId;
  93 }
  94
  95 /**************************************************************************
  96  *                              MMDRV_Message                   [internal]
  97  */
  98 DWORD  MMDRV_Message(LPWINE_MLD mld, UINT wMsg, DWORD_PTR dwParam1,
  99                      DWORD_PTR dwParam2)
 100 {
 101     LPWINE_MM_DRIVER            lpDrv;
 102     DWORD                       ret;
 103     WINE_MM_DRIVER_PART*        part;
 104     WINE_LLTYPE*                llType = &llTypes[mld->type];
 105
 106     TRACE("(%s %d %u 0x%08lx 0x%08lx 0x%08lx)\n",
 107           llTypes[mld->type].typestr, mld->uDeviceID, wMsg,
 108           mld->dwDriverInstance, dwParam1, dwParam2);
 109
 110     if ((UINT16)mld->uDeviceID == (UINT16)-1) {
 111         if (llType->nMapper == -1) {
 112             WARN("uDev=-1 requested on non-mapped ll type %s\n",
 113                  llTypes[mld->type].typestr);
 114             return MMSYSERR_BADDEVICEID;
 115         }
 116     } else {
 117         if (mld->uDeviceID >= llType->wMaxId) {
 118             WARN("uDev(%u) requested >= max (%d)\n", mld->uDeviceID, llType->wMaxId);
 119             return MMSYSERR_BADDEVICEID;
 120         }
 121     }
 122
 123     lpDrv = &MMDrvs[mld->mmdIndex];
 124     part = &lpDrv->parts[mld->type];
 125
 126     assert(part->fnMessage32);
 127
 128     TRACE("Calling message(dev=%d msg=%u usr=0x%08lx p1=0x%08lx p2=0x%08lx)\n",
 129           mld->uDeviceID, wMsg, mld->dwDriverInstance, dwParam1, dwParam2);
 130     ret = part->fnMessage32(mld->uDeviceID, wMsg, mld->dwDriverInstance, dwParam1, dwParam2);
 131     TRACE("=> %s\n", WINMM_ErrorToString(ret));
 132
 133     return ret;
 134 }
 135
 136 /**************************************************************************
 137  *                              MMDRV_Alloc                     [internal]
 138  */
 139 LPWINE_MLD      MMDRV_Alloc(UINT size, UINT type, LPHANDLE hndl, DWORD* dwFlags,
 140                             DWORD_PTR* dwCallback, DWORD_PTR* dwInstance)
 141 {
 142     LPWINE_MLD  mld;
 143     UINT_PTR i;
 144     TRACE("(%d, %04x, %p, %p, %p, %p)\n",
 145           size, type, hndl, dwFlags, dwCallback, dwInstance);
 146
 147     mld = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size);
 148     if (!mld)   return NULL;
 149
 150     /* find an empty slot in MM_MLDrvs table */
 151     for (i = 0; i < MAX_MM_MLDRVS; i++) if (!MM_MLDrvs[i]) break;
 152
 153     if (i == MAX_MM_MLDRVS) {
 154         /* the MM_MLDrvs table could be made growable in the future if needed */
 155         ERR("Too many open drivers\n");
 156         HeapFree(GetProcessHeap(), 0, mld);
 157         return NULL;
 158     }
 159     MM_MLDrvs[i] = mld;
 160     *hndl = (HANDLE)(i | 0x8000);
 161
 162     mld->type = type;
 163     if ((UINT_PTR)*hndl < MMDRV_GetNum(type) || ((UINT_PTR)*hndl >> 16)) {
 164         /* FIXME: those conditions must be fulfilled so that:
 165          * - we can distinguish between device IDs and handles
 166          * - we can use handles as 16 or 32 bit entities
 167          */
 168         ERR("Shouldn't happen. Bad allocation scheme\n");
 169     }
 170
 171     mld->dwFlags = HIWORD(*dwFlags);
 172     mld->dwCallback = *dwCallback;
 173     mld->dwClientInstance = *dwInstance;
 174
 175     return mld;
 176 }
 177
 178 /**************************************************************************
 179  *                              MMDRV_Free                      [internal]
 180  */
 181 void    MMDRV_Free(HANDLE hndl, LPWINE_MLD mld)
 182 {
 183     TRACE("(%p, %p)\n", hndl, mld);
 184
 185     if ((UINT_PTR)hndl & 0x8000) {
 186         UINT_PTR idx = (UINT_PTR)hndl & ~0x8000;
 187         if (idx < sizeof(MM_MLDrvs) / sizeof(MM_MLDrvs[0])) {
 188             MM_MLDrvs[idx] = NULL;
 189             HeapFree(GetProcessHeap(), 0, mld);
 190             return;
 191         }
 192     }
 193     ERR("Bad Handle %p at %p (not freed)\n", hndl, mld);
 194 }
 195
 196 /**************************************************************************
 197  *                              MMDRV_Open                      [internal]
 198  */
 199 DWORD MMDRV_Open(LPWINE_MLD mld, UINT wMsg, DWORD_PTR dwParam1, DWORD dwFlags)
 200 {
 201     DWORD               dwRet = MMSYSERR_BADDEVICEID;
 202     DWORD_PTR           dwInstance;
 203     WINE_LLTYPE*        llType = &llTypes[mld->type];
 204     TRACE("(%p, %04x, 0x%08lx, 0x%08x)\n", mld, wMsg, dwParam1, dwFlags);
 205
 206     mld->dwDriverInstance = (DWORD_PTR)&dwInstance;
 207
 208     if (mld->uDeviceID == (UINT)-1 || mld->uDeviceID == (UINT16)-1) {
 209         TRACE("MAPPER mode requested !\n");
 210         if (llType->nMapper == -1) {
 211             WARN("Mapper not supported for type %s\n", llTypes[mld->type].typestr);
 212             return MMSYSERR_BADDEVICEID;
 213         }
 214         mld->mmdIndex = llType->lpMlds[-1].mmdIndex;
 215         TRACE("Setting mmdIndex to %u\n", mld->mmdIndex);
 216         dwRet = MMDRV_Message(mld, wMsg, dwParam1, dwFlags);
 217     } else {
 218         if (mld->uDeviceID < llType->wMaxId) {
 219             mld->mmdIndex = llType->lpMlds[mld->uDeviceID].mmdIndex;
 220             TRACE("Setting mmdIndex to %u\n", mld->mmdIndex);
 221             dwRet = MMDRV_Message(mld, wMsg, dwParam1, dwFlags);
 222         }
 223     }
 224     if (dwRet == MMSYSERR_NOERROR)
 225         mld->dwDriverInstance = dwInstance;
 226     return dwRet;
 227 }
 228
 229 /**************************************************************************
 230  *                              MMDRV_Close                     [internal]
 231  */
 232 DWORD   MMDRV_Close(LPWINE_MLD mld, UINT wMsg)
 233 {
 234     TRACE("(%p, %04x)\n", mld, wMsg);
 235     return MMDRV_Message(mld, wMsg, 0L, 0L);
 236 }
 237
 238 /**************************************************************************
 239  *                              MMDRV_GetByID                   [internal]
 240  */
 241 static LPWINE_MLD MMDRV_GetByID(UINT uDevID, UINT type)
 242 {
 243     TRACE("(%04x, %04x)\n", uDevID, type);
 244     if (uDevID < llTypes[type].wMaxId)
 245         return &llTypes[type].lpMlds[uDevID];
 246     if ((uDevID == (UINT16)-1 || uDevID == (UINT)-1) && llTypes[type].nMapper != -1)
 247         return &llTypes[type].lpMlds[-1];
 248     return NULL;
 249 }
 250
 251 /**************************************************************************
 252  *                              MMDRV_Get                       [internal]
 253  */
 254 LPWINE_MLD      MMDRV_Get(HANDLE _hndl, UINT type, BOOL bCanBeID)
 255 {
 256     LPWINE_MLD  mld = NULL;
 257     UINT_PTR    hndl = (UINT_PTR)_hndl;
 258     TRACE("(%p, %04x, %c)\n", _hndl, type, bCanBeID ? 'Y' : 'N');
 259
 260     assert(type < MMDRV_MAX);
 261     MMDRV_InitSingleType(type);
 262
 263     if (hndl >= llTypes[type].wMaxId &&
 264         hndl != (UINT16)-1 && hndl != (UINT)-1) {
 265         if (hndl & 0x8000) {
 266             UINT idx = hndl & ~0x8000;
 267             if (idx < sizeof(MM_MLDrvs) / sizeof(MM_MLDrvs[0])) {
 268                 __TRY
 269                 {
 270                     mld = MM_MLDrvs[idx];
 271                     if (mld && mld->type != type) mld = NULL;
 272                 }
 273                 __EXCEPT_PAGE_FAULT
 274                 {
 275                     mld = NULL;
 276                 }
 277                 __ENDTRY;
 278             }
 279         }
 280     }
 281     if (mld == NULL && bCanBeID) {
 282         mld = MMDRV_GetByID(hndl, type);
 283     }
 284     return mld;
 285 }
 286
 287 /**************************************************************************
 288  *                              MMDRV_GetRelated                [internal]
 289  */
 290 LPWINE_MLD      MMDRV_GetRelated(HANDLE hndl, UINT srcType,
 291                                  BOOL bSrcCanBeID, UINT dstType)
 292 {
 293     LPWINE_MLD          mld;
 294     TRACE("(%p, %04x, %c, %04x)\n",
 295           hndl, srcType, bSrcCanBeID ? 'Y' : 'N', dstType);
 296
 297     if ((mld = MMDRV_Get(hndl, srcType, bSrcCanBeID)) != NULL) {
 298         WINE_MM_DRIVER_PART*    part = &MMDrvs[mld->mmdIndex].parts[dstType];
 299         if (part->nIDMin < part->nIDMax)
 300             return MMDRV_GetByID(part->nIDMin, dstType);
 301     }
 302     return NULL;
 303 }
 304
 305 /**************************************************************************
 306  *                              MMDRV_PhysicalFeatures          [internal]
 307  */
 308 UINT    MMDRV_PhysicalFeatures(LPWINE_MLD mld, UINT uMsg,
 309                                DWORD_PTR dwParam1, DWORD_PTR dwParam2)
 310 {
 311     WINE_MM_DRIVER*     lpDrv = &MMDrvs[mld->mmdIndex];
 312
 313     TRACE("(%p, %04x, %08lx, %08lx)\n", mld, uMsg, dwParam1, dwParam2);
 314
 315     /* all those function calls are undocumented */
 316     switch (uMsg) {
 317     case DRV_QUERYDRVENTRY:
 318         lstrcpynA((LPSTR)dwParam1, lpDrv->drvname, LOWORD(dwParam2));
 319         break;
 320     case DRV_QUERYDEVNODE:
 321         *(LPDWORD)dwParam1 = 0L; /* should be DevNode */
 322         break;
 323     case DRV_QUERYNAME:
 324         WARN("NIY QueryName\n");
 325         break;
 326     case DRV_QUERYDRIVERIDS:
 327         WARN("NIY call VxD\n");
 328         /* should call VxD MMDEVLDR with (DevNode, dwParam1 and dwParam2) as pmts
 329          * dwParam1 is buffer and dwParam2 is sizeof(buffer)
 330          * I don't know where the result is stored though
 331          */
 332         break;
 333     case DRV_QUERYMAPPABLE:
 334         return (lpDrv->bIsMapper) ? 2 : 0;
 335
 336     case DRVM_MAPPER_PREFERRED_GET:
 337         /* FIXME: get from registry someday */
 338         *((LPDWORD)dwParam1) = -1;      /* No preferred device */
 339         *((LPDWORD)dwParam2) = 0;
 340         break;
 341
 342     case DRV_QUERYDEVICEINTERFACE:
 343     case DRV_QUERYDEVICEINTERFACESIZE:
 344         return MMDRV_Message(mld, uMsg, dwParam1, dwParam2);
 345
 346     case DRV_QUERYDSOUNDIFACE: /* Wine-specific: Retrieve DirectSound interface */
 347     case DRV_QUERYDSOUNDDESC: /* Wine-specific: Retrieve DirectSound driver description*/
 348         return MMDRV_Message(mld, uMsg, dwParam1, dwParam2);
 349
 350     default:
 351         WARN("Unknown call %04x\n", uMsg);
 352         return MMSYSERR_INVALPARAM;
 353     }
 354     return 0L;
 355 }
 356
 357 /**************************************************************************
 358  *                              MMDRV_InitPerType               [internal]
 359  */
 360 static  BOOL    MMDRV_InitPerType(LPWINE_MM_DRIVER lpDrv, UINT type, UINT wMsg)
 361 {
 362     WINE_MM_DRIVER_PART*        part = &lpDrv->parts[type];
 363     DWORD                       ret;
 364     UINT                        count = 0;
 365     int                         i, k;
 366     TRACE("(%p, %04x, %04x)\n", lpDrv, type, wMsg);
 367
 368     part->nIDMin = part->nIDMax = 0;
 369
 370     /* for DRVM_INIT and DRVM_ENABLE, dwParam2 should be PnP node */
 371     /* the DRVM_ENABLE is only required when the PnP node is non zero */
 372     if (part->fnMessage32) {
 373         ret = part->fnMessage32(0, DRVM_INIT, 0L, 0L, 0L);
 374         TRACE("DRVM_INIT => %s\n", WINMM_ErrorToString(ret));
 375 #if 0
 376         ret = part->fnMessage32(0, DRVM_ENABLE, 0L, 0L, 0L);
 377         TRACE("DRVM_ENABLE => %08lx\n", ret);
 378 #endif
 379         count = part->fnMessage32(0, wMsg, 0L, 0L, 0L);
 380     }
 381     else return FALSE;
 382
 383     TRACE("Got %u dev for (%s:%s)\n", count, lpDrv->drvname, llTypes[type].typestr);
 384
 385     if (HIWORD(count))
 386         return FALSE;
 387
 388     /* got some drivers */
 389     if (lpDrv->bIsMapper) {
 390         llTypes[type].nMapper = MMDrvsHi;
 391     } else {
 392         if (count == 0)
 393             return FALSE;
 394         part->nIDMin = llTypes[type].wMaxId;
 395         llTypes[type].wMaxId += count;
 396         part->nIDMax = llTypes[type].wMaxId;
 397     }
 398     TRACE("Setting min=%d max=%d (ttop=%d) for (%s:%s)\n",
 399           part->nIDMin, part->nIDMax, llTypes[type].wMaxId,
 400           lpDrv->drvname, llTypes[type].typestr);
 401     /* realloc translation table */
 402     if (llTypes[type].lpMlds)
 403         llTypes[type].lpMlds = (LPWINE_MLD)
 404         HeapReAlloc(GetProcessHeap(), 0, llTypes[type].lpMlds - 1,
 405                     sizeof(WINE_MLD) * (llTypes[type].wMaxId + 1)) + 1;
 406     else
 407         llTypes[type].lpMlds = (LPWINE_MLD)
 408         HeapAlloc(GetProcessHeap(), 0,
 409                     sizeof(WINE_MLD) * (llTypes[type].wMaxId + 1)) + 1;
 410
 411     /* re-build the translation table */
 412     if (lpDrv->bIsMapper) {
 413         TRACE("%s:Trans[%d] -> %s\n", llTypes[type].typestr, -1, MMDrvs[llTypes[type].nMapper].drvname);
 414         llTypes[type].lpMlds[-1].uDeviceID = (UINT)-1;
 415         llTypes[type].lpMlds[-1].type = type;
 416         llTypes[type].lpMlds[-1].mmdIndex = llTypes[type].nMapper;
 417         llTypes[type].lpMlds[-1].dwDriverInstance = 0;
 418     }
 419     for (i = k = 0; i <= MMDrvsHi; i++) {
 420         while (MMDrvs[i].parts[type].nIDMin <= k && k < MMDrvs[i].parts[type].nIDMax) {
 421             TRACE("%s:Trans[%d] -> %s\n", llTypes[type].typestr, k, MMDrvs[i].drvname);
 422             llTypes[type].lpMlds[k].uDeviceID = k;
 423             llTypes[type].lpMlds[k].type = type;
 424             llTypes[type].lpMlds[k].mmdIndex = i;
 425             llTypes[type].lpMlds[k].dwDriverInstance = 0;
 426             k++;
 427         }
 428     }
 429     return TRUE;
 430 }
 431
 432 /**************************************************************************
 433  *                              MMDRV_Install                   [internal]
 434  */
 435 static  BOOL    MMDRV_Install(LPCSTR drvRegName, LPCSTR drvFileName, BOOL bIsMapper)
 436 {
 437     int                 i, count = 0;
 438     LPWINE_MM_DRIVER    lpDrv = &MMDrvs[MMDrvsHi];
 439     LPWINE_DRIVER       d;
 440     WINEMM_msgFunc32    func;
 441
 442     TRACE("('%s', '%s', mapper=%c);\n", drvRegName, drvFileName, bIsMapper ? 'Y' : 'N');
 443
 444     for (i = 0; i < MMDrvsHi; i++) {
 445         if (!strcmp(drvRegName, MMDrvs[i].drvname)) return FALSE;
 446     }
 447
 448     /* Be sure that size of MMDrvs matches the max number of loadable
 449      * drivers !!
 450      * If not just increase size of MMDrvs
 451      */
 452     assert(MMDrvsHi <= sizeof(MMDrvs)/sizeof(MMDrvs[0]));
 453
 454     memset(lpDrv, 0, sizeof(*lpDrv));
 455
 456     if (!(lpDrv->hDriver = OpenDriverA(drvFileName, 0, 0))) {
 457         WARN("Couldn't open driver '%s'\n", drvFileName);
 458         return FALSE;
 459     }
 460
 461     d = DRIVER_FindFromHDrvr(lpDrv->hDriver);
 462
 463     /* Then look for xxxMessage functions */
 464 #define AA(_h,_w,_x,_y,_z)                                      \
 465     func = (WINEMM_msgFunc##_y) _z ((_h), #_x);                 \
 466     if (func != NULL)                                           \
 467         { lpDrv->parts[_w].fnMessage##_y = func; count++;       \
 468           TRACE("Got %d bit func '%s'\n", _y, #_x);         }
 469
 470     if (d->hModule) {
 471 #define A(_x,_y)        AA(d->hModule,_x,_y,32,GetProcAddress)
 472             A(MMDRV_AUX,        auxMessage);
 473             A(MMDRV_MIXER,      mxdMessage);
 474             A(MMDRV_MIDIIN,     midMessage);
 475             A(MMDRV_MIDIOUT,    modMessage);
 476             A(MMDRV_WAVEIN,     widMessage);
 477             A(MMDRV_WAVEOUT,    wodMessage);
 478 #undef A
 479     }
 480 #undef AA
 481
 482     if (!count) {
 483         CloseDriver(lpDrv->hDriver, 0, 0);
 484         WARN("No message functions found\n");
 485         return FALSE;
 486     }
 487
 488     /* FIXME: being a mapper or not should be known by another way */
 489     /* it's known for NE drvs (the description is of the form '*mapper: *'
 490      * I don't have any clue for PE drvs
 491      */
 492     lpDrv->bIsMapper = bIsMapper;
 493     lpDrv->drvname = strcpy(HeapAlloc(GetProcessHeap(), 0, strlen(drvRegName) + 1), drvRegName);
 494
 495     /* Finish init and get the count of the devices */
 496     i = 0;
 497     if (MMDRV_InitPerType(lpDrv, MMDRV_AUX,     AUXDM_GETNUMDEVS))      i = 1;
 498     if (MMDRV_InitPerType(lpDrv, MMDRV_MIXER,   MXDM_GETNUMDEVS))       i = 1;
 499     if (MMDRV_InitPerType(lpDrv, MMDRV_MIDIIN,  MIDM_GETNUMDEVS))       i = 1;
 500     if (MMDRV_InitPerType(lpDrv, MMDRV_MIDIOUT, MODM_GETNUMDEVS))       i = 1;
 501     if (MMDRV_InitPerType(lpDrv, MMDRV_WAVEIN,  WIDM_GETNUMDEVS))       i = 1;
 502     if (MMDRV_InitPerType(lpDrv, MMDRV_WAVEOUT, WODM_GETNUMDEVS))       i = 1;
 503     /* if all those func calls return FALSE, then the driver must be unloaded */
 504     if (!i) {
 505         CloseDriver(lpDrv->hDriver, 0, 0);
 506         HeapFree(GetProcessHeap(), 0, lpDrv->drvname);
 507         WARN("Driver initialization failed\n");
 508         return FALSE;
 509     }
 510
 511     MMDrvsHi++;
 512
 513     return TRUE;
 514 }
 515
 516 /**************************************************************************
 517  *                              MMDRV_Init
 518  */
 519 static void MMDRV_Init(void)
 520 {
 521     IMMDeviceEnumerator *devenum;
 522     IMMDevice *device;
 523     IPropertyStore *ps;
 524     PROPVARIANT pv;
 525     DWORD size;
 526     char *drvA;
 527     HRESULT init_hr, hr;
 528
 529     static const WCHAR wine_info_deviceW[] = {'W','i','n','e',' ',
 530         'i','n','f','o',' ','d','e','v','i','c','e',0};
 531
 532     TRACE("()\n");
 533
 534     init_hr = CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
 535
 536     hr = CoCreateInstance(&CLSID_MMDeviceEnumerator, NULL,
 537             CLSCTX_INPROC_SERVER, &IID_IMMDeviceEnumerator, (void**)&devenum);
 538     if(FAILED(hr)){
 539         ERR("CoCreateInstance failed: %08x\n", hr);
 540         goto exit;
 541     }
 542
 543     hr = IMMDeviceEnumerator_GetDevice(devenum, wine_info_deviceW, &device);
 544     IMMDeviceEnumerator_Release(devenum);
 545     if(FAILED(hr)){
 546         ERR("GetDevice failed: %08x\n", hr);
 547         goto exit;
 548     }
 549
 550     hr = IMMDevice_OpenPropertyStore(device, STGM_READ, &ps);
 551     if(FAILED(hr)){
 552         ERR("OpenPropertyStore failed: %08x\n", hr);
 553         IMMDevice_Release(device);
 554         goto exit;
 555     }
 556
 557     hr = IPropertyStore_GetValue(ps,
 558             (const PROPERTYKEY *)&DEVPKEY_Device_Driver, &pv);
 559     IPropertyStore_Release(ps);
 560     IMMDevice_Release(device);
 561     if(FAILED(hr)){
 562         ERR("GetValue failed: %08x\n", hr);
 563         goto exit;
 564     }
 565
 566     size = WideCharToMultiByte(CP_ACP, 0, pv.u.pwszVal, -1,
 567             NULL, 0, NULL, NULL);
 568     drvA = HeapAlloc(GetProcessHeap(), 0, size);
 569     WideCharToMultiByte(CP_ACP, 0, pv.u.pwszVal, -1, drvA, size, NULL, NULL);
 570
 571     MMDRV_Install(drvA, drvA, FALSE);
 572
 573     HeapFree(GetProcessHeap(), 0, drvA);
 574     PropVariantClear(&pv);
 575
 576     MMDRV_Install("wavemapper", "msacm32.drv", TRUE);
 577     MMDRV_Install("midimapper", "midimap.dll", TRUE);
 578
 579 exit:
 580     if(SUCCEEDED(init_hr))
 581         CoUninitialize();
 582 }
 583
 584 /******************************************************************
 585  *              ExitPerType
 586  *
 587  *
 588  */
 589 static  BOOL    MMDRV_ExitPerType(LPWINE_MM_DRIVER lpDrv, UINT type)
 590 {
 591     WINE_MM_DRIVER_PART*        part = &lpDrv->parts[type];
 592     DWORD                       ret;
 593     TRACE("(%p, %04x)\n", lpDrv, type);
 594
 595     if (part->fnMessage32) {
 596 #if 0
 597         ret = part->fnMessage32(0, DRVM_DISABLE, 0L, 0L, 0L);
 598         TRACE("DRVM_DISABLE => %08lx\n", ret);
 599 #endif
 600         ret = part->fnMessage32(0, DRVM_EXIT, 0L, 0L, 0L);
 601         TRACE("DRVM_EXIT => %s\n", WINMM_ErrorToString(ret));
 602     }
 603
 604     return TRUE;
 605 }
 606
 607 /******************************************************************
 608  *              Exit
 609  *
 610  *
 611  */
 612 void MMDRV_Exit(void)
 613 {
 614     unsigned int i;
 615     TRACE("()\n");
 616
 617     for (i = 0; i < sizeof(MM_MLDrvs) / sizeof(MM_MLDrvs[0]); i++)
 618     {
 619         if (MM_MLDrvs[i] != NULL)
 620         {
 621             FIXME("Closing while ll-driver open\n");
 622 #if 0
 623             /* FIXME: should generate a message depending on type */
 624             MMDRV_Free((HANDLE)(i | 0x8000), MM_MLDrvs[i]);
 625 #endif
 626         }
 627     }
 628
 629     /* unload driver, in reverse order of loading */
 630     i = sizeof(MMDrvs) / sizeof(MMDrvs[0]);
 631     while (i-- > 0)
 632     {
 633         MMDRV_ExitPerType(&MMDrvs[i], MMDRV_AUX);
 634         MMDRV_ExitPerType(&MMDrvs[i], MMDRV_MIXER);
 635         MMDRV_ExitPerType(&MMDrvs[i], MMDRV_MIDIIN);
 636         MMDRV_ExitPerType(&MMDrvs[i], MMDRV_MIDIOUT);
 637         MMDRV_ExitPerType(&MMDrvs[i], MMDRV_WAVEIN);
 638         MMDRV_ExitPerType(&MMDrvs[i], MMDRV_WAVEOUT);
 639         CloseDriver(MMDrvs[i].hDriver, 0, 0);
 640     }
 641     if (llTypes[MMDRV_AUX].lpMlds)
 642         HeapFree(GetProcessHeap(), 0, llTypes[MMDRV_AUX].lpMlds - 1);
 643     if (llTypes[MMDRV_MIXER].lpMlds)
 644         HeapFree(GetProcessHeap(), 0, llTypes[MMDRV_MIXER].lpMlds - 1);
 645     if (llTypes[MMDRV_MIDIIN].lpMlds)
 646         HeapFree(GetProcessHeap(), 0, llTypes[MMDRV_MIDIIN].lpMlds - 1);
 647     if (llTypes[MMDRV_MIDIOUT].lpMlds)
 648         HeapFree(GetProcessHeap(), 0, llTypes[MMDRV_MIDIOUT].lpMlds - 1);
 649     if (llTypes[MMDRV_WAVEIN].lpMlds)
 650         HeapFree(GetProcessHeap(), 0, llTypes[MMDRV_WAVEIN].lpMlds - 1);
 651     if (llTypes[MMDRV_WAVEOUT].lpMlds)
 652         HeapFree(GetProcessHeap(), 0, llTypes[MMDRV_WAVEOUT].lpMlds - 1);
 653 }