dlls/mmdevapi/devenum.c

   1 /*
   2  * Copyright 2009 Maarten Lankhorst
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #include "config.h"
  20
  21 #include <stdarg.h>
  22
  23 #define NONAMELESSUNION
  24 #define COBJMACROS
  25 #include "windef.h"
  26 #include "winbase.h"
  27 #include "winnls.h"
  28 #include "winreg.h"
  29 #include "wine/debug.h"
  30 #include "wine/list.h"
  31 #include "wine/unicode.h"
  32
  33 #include "initguid.h"
  34 #include "ole2.h"
  35 #include "mmdeviceapi.h"
  36 #include "dshow.h"
  37 #include "dsound.h"
  38 #include "audioclient.h"
  39 #include "endpointvolume.h"
  40 #include "audiopolicy.h"
  41
  42 #include "mmdevapi.h"
  43 #include "devpkey.h"
  44
  45 WINE_DEFAULT_DEBUG_CHANNEL(mmdevapi);
  46
  47 static const WCHAR software_mmdevapi[] =
  48     { 'S','o','f','t','w','a','r','e','\\',
  49       'M','i','c','r','o','s','o','f','t','\\',
  50       'W','i','n','d','o','w','s','\\',
  51       'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
  52       'M','M','D','e','v','i','c','e','s','\\',
  53       'A','u','d','i','o',0};
  54 static const WCHAR reg_render[] =
  55     { 'R','e','n','d','e','r',0 };
  56 static const WCHAR reg_capture[] =
  57     { 'C','a','p','t','u','r','e',0 };
  58 static const WCHAR reg_devicestate[] =
  59     { 'D','e','v','i','c','e','S','t','a','t','e',0 };
  60 static const WCHAR reg_properties[] =
  61     { 'P','r','o','p','e','r','t','i','e','s',0 };
  62 static const WCHAR slashW[] = {'\\',0};
  63 static const WCHAR reg_out_nameW[] = {'D','e','f','a','u','l','t','O','u','t','p','u','t',0};
  64 static const WCHAR reg_vout_nameW[] = {'D','e','f','a','u','l','t','V','o','i','c','e','O','u','t','p','u','t',0};
  65 static const WCHAR reg_in_nameW[] = {'D','e','f','a','u','l','t','I','n','p','u','t',0};
  66 static const WCHAR reg_vin_nameW[] = {'D','e','f','a','u','l','t','V','o','i','c','e','I','n','p','u','t',0};
  67
  68 static HKEY key_render;
  69 static HKEY key_capture;
  70
  71 typedef struct MMDevPropStoreImpl
  72 {
  73     IPropertyStore IPropertyStore_iface;
  74     LONG ref;
  75     MMDevice *parent;
  76     DWORD access;
  77 } MMDevPropStore;
  78
  79 typedef struct MMDevEnumImpl
  80 {
  81     IMMDeviceEnumerator IMMDeviceEnumerator_iface;
  82     LONG ref;
  83 } MMDevEnumImpl;
  84
  85 static MMDevEnumImpl *MMDevEnumerator;
  86 static MMDevice **MMDevice_head;
  87 static MMDevice *MMDevice_def_rec, *MMDevice_def_play;
  88 static DWORD MMDevice_count;
  89 static const IMMDeviceEnumeratorVtbl MMDevEnumVtbl;
  90 static const IMMDeviceCollectionVtbl MMDevColVtbl;
  91 static const IMMDeviceVtbl MMDeviceVtbl;
  92 static const IPropertyStoreVtbl MMDevPropVtbl;
  93 static const IMMEndpointVtbl MMEndpointVtbl;
  94
  95 static IMMDevice info_device;
  96
  97 typedef struct MMDevColImpl
  98 {
  99     IMMDeviceCollection IMMDeviceCollection_iface;
 100     LONG ref;
 101     EDataFlow flow;
 102     DWORD state;
 103 } MMDevColImpl;
 104
 105 typedef struct IPropertyBagImpl {
 106     IPropertyBag IPropertyBag_iface;
 107     GUID devguid;
 108 } IPropertyBagImpl;
 109
 110 static const IPropertyBagVtbl PB_Vtbl;
 111
 112 static HRESULT MMDevPropStore_Create(MMDevice *This, DWORD access, IPropertyStore **ppv);
 113
 114 static inline MMDevPropStore *impl_from_IPropertyStore(IPropertyStore *iface)
 115 {
 116     return CONTAINING_RECORD(iface, MMDevPropStore, IPropertyStore_iface);
 117 }
 118
 119 static inline MMDevEnumImpl *impl_from_IMMDeviceEnumerator(IMMDeviceEnumerator *iface)
 120 {
 121     return CONTAINING_RECORD(iface, MMDevEnumImpl, IMMDeviceEnumerator_iface);
 122 }
 123
 124 static inline MMDevColImpl *impl_from_IMMDeviceCollection(IMMDeviceCollection *iface)
 125 {
 126     return CONTAINING_RECORD(iface, MMDevColImpl, IMMDeviceCollection_iface);
 127 }
 128
 129 static inline IPropertyBagImpl *impl_from_IPropertyBag(IPropertyBag *iface)
 130 {
 131     return CONTAINING_RECORD(iface, IPropertyBagImpl, IPropertyBag_iface);
 132 }
 133
 134 static const WCHAR propkey_formatW[] = {
 135     '{','%','0','8','X','-','%','0','4','X','-',
 136     '%','0','4','X','-','%','0','2','X','%','0','2','X','-',
 137     '%','0','2','X','%','0','2','X','%','0','2','X','%','0','2','X',
 138     '%','0','2','X','%','0','2','X','}',',','%','d',0 };
 139
 140 static HRESULT MMDevPropStore_OpenPropKey(const GUID *guid, DWORD flow, HKEY *propkey)
 141 {
 142     WCHAR buffer[39];
 143     LONG ret;
 144     HKEY key;
 145     StringFromGUID2(guid, buffer, 39);
 146     if ((ret = RegOpenKeyExW(flow == eRender ? key_render : key_capture, buffer, 0, KEY_READ|KEY_WRITE|KEY_WOW64_64KEY, &key)) != ERROR_SUCCESS)
 147     {
 148         WARN("Opening key %s failed with %u\n", debugstr_w(buffer), ret);
 149         return E_FAIL;
 150     }
 151     ret = RegOpenKeyExW(key, reg_properties, 0, KEY_READ|KEY_WRITE|KEY_WOW64_64KEY, propkey);
 152     RegCloseKey(key);
 153     if (ret != ERROR_SUCCESS)
 154     {
 155         WARN("Opening key %s failed with %u\n", debugstr_w(reg_properties), ret);
 156         return E_FAIL;
 157     }
 158     return S_OK;
 159 }
 160
 161 static HRESULT MMDevice_GetPropValue(const GUID *devguid, DWORD flow, REFPROPERTYKEY key, PROPVARIANT *pv)
 162 {
 163     WCHAR buffer[80];
 164     const GUID *id = &key->fmtid;
 165     DWORD type, size;
 166     HRESULT hr = S_OK;
 167     HKEY regkey;
 168     LONG ret;
 169
 170     hr = MMDevPropStore_OpenPropKey(devguid, flow, &regkey);
 171     if (FAILED(hr))
 172         return hr;
 173     wsprintfW( buffer, propkey_formatW, id->Data1, id->Data2, id->Data3,
 174                id->Data4[0], id->Data4[1], id->Data4[2], id->Data4[3],
 175                id->Data4[4], id->Data4[5], id->Data4[6], id->Data4[7], key->pid );
 176     ret = RegGetValueW(regkey, NULL, buffer, RRF_RT_ANY, &type, NULL, &size);
 177     if (ret != ERROR_SUCCESS)
 178     {
 179         WARN("Reading %s returned %d\n", debugstr_w(buffer), ret);
 180         RegCloseKey(regkey);
 181         PropVariantClear(pv);
 182         return S_OK;
 183     }
 184
 185     switch (type)
 186     {
 187         case REG_SZ:
 188         {
 189             pv->vt = VT_LPWSTR;
 190             pv->u.pwszVal = CoTaskMemAlloc(size);
 191             if (!pv->u.pwszVal)
 192                 hr = E_OUTOFMEMORY;
 193             else
 194                 RegGetValueW(regkey, NULL, buffer, RRF_RT_REG_SZ, NULL, (BYTE*)pv->u.pwszVal, &size);
 195             break;
 196         }
 197         case REG_DWORD:
 198         {
 199             pv->vt = VT_UI4;
 200             RegGetValueW(regkey, NULL, buffer, RRF_RT_REG_DWORD, NULL, (BYTE*)&pv->u.ulVal, &size);
 201             break;
 202         }
 203         case REG_BINARY:
 204         {
 205             pv->vt = VT_BLOB;
 206             pv->u.blob.cbSize = size;
 207             pv->u.blob.pBlobData = CoTaskMemAlloc(size);
 208             if (!pv->u.blob.pBlobData)
 209                 hr = E_OUTOFMEMORY;
 210             else
 211                 RegGetValueW(regkey, NULL, buffer, RRF_RT_REG_BINARY, NULL, (BYTE*)pv->u.blob.pBlobData, &size);
 212             break;
 213         }
 214         default:
 215             ERR("Unknown/unhandled type: %u\n", type);
 216             PropVariantClear(pv);
 217             break;
 218     }
 219     RegCloseKey(regkey);
 220     return hr;
 221 }
 222
 223 static HRESULT MMDevice_SetPropValue(const GUID *devguid, DWORD flow, REFPROPERTYKEY key, REFPROPVARIANT pv)
 224 {
 225     WCHAR buffer[80];
 226     const GUID *id = &key->fmtid;
 227     HRESULT hr;
 228     HKEY regkey;
 229     LONG ret;
 230
 231     hr = MMDevPropStore_OpenPropKey(devguid, flow, &regkey);
 232     if (FAILED(hr))
 233         return hr;
 234     wsprintfW( buffer, propkey_formatW, id->Data1, id->Data2, id->Data3,
 235                id->Data4[0], id->Data4[1], id->Data4[2], id->Data4[3],
 236                id->Data4[4], id->Data4[5], id->Data4[6], id->Data4[7], key->pid );
 237     switch (pv->vt)
 238     {
 239         case VT_UI4:
 240         {
 241             ret = RegSetValueExW(regkey, buffer, 0, REG_DWORD, (const BYTE*)&pv->u.ulVal, sizeof(DWORD));
 242             break;
 243         }
 244         case VT_BLOB:
 245         {
 246             ret = RegSetValueExW(regkey, buffer, 0, REG_BINARY, pv->u.blob.pBlobData, pv->u.blob.cbSize);
 247             TRACE("Blob %p %u\n", pv->u.blob.pBlobData, pv->u.blob.cbSize);
 248
 249             break;
 250         }
 251         case VT_LPWSTR:
 252         {
 253             ret = RegSetValueExW(regkey, buffer, 0, REG_SZ, (const BYTE*)pv->u.pwszVal, sizeof(WCHAR)*(1+lstrlenW(pv->u.pwszVal)));
 254             break;
 255         }
 256         default:
 257             ret = 0;
 258             FIXME("Unhandled type %u\n", pv->vt);
 259             hr = E_INVALIDARG;
 260             break;
 261     }
 262     RegCloseKey(regkey);
 263     TRACE("Writing %s returned %u\n", debugstr_w(buffer), ret);
 264     return hr;
 265 }
 266
 267 static HRESULT set_driver_prop_value(GUID *id, const EDataFlow flow, const PROPERTYKEY *prop)
 268 {
 269     HRESULT hr;
 270     PROPVARIANT pv;
 271
 272     if (!drvs.pGetPropValue)
 273         return E_NOTIMPL;
 274
 275     hr = drvs.pGetPropValue(id, prop, &pv);
 276
 277     if (SUCCEEDED(hr))
 278     {
 279         MMDevice_SetPropValue(id, flow, prop, &pv);
 280         PropVariantClear(&pv);
 281     }
 282
 283     return hr;
 284 }
 285
 286 /* Creates or updates the state of a device
 287  * If GUID is null, a random guid will be assigned
 288  * and the device will be created
 289  */
 290 static MMDevice *MMDevice_Create(WCHAR *name, GUID *id, EDataFlow flow, DWORD state, BOOL setdefault)
 291 {
 292     HKEY key, root;
 293     MMDevice *cur = NULL;
 294     WCHAR guidstr[39];
 295     DWORD i;
 296
 297     static const PROPERTYKEY deviceinterface_key = {
 298         {0x233164c8, 0x1b2c, 0x4c7d, {0xbc, 0x68, 0xb6, 0x71, 0x68, 0x7a, 0x25, 0x67}}, 1
 299     };
 300
 301     static const PROPERTYKEY devicepath_key = {
 302         {0xb3f8fa53, 0x0004, 0x438e, {0x90, 0x03, 0x51, 0xa4, 0x6e, 0x13, 0x9b, 0xfc}}, 2
 303     };
 304
 305     for (i = 0; i < MMDevice_count; ++i)
 306     {
 307         MMDevice *device = MMDevice_head[i];
 308         if (device->flow == flow && IsEqualGUID(&device->devguid, id)){
 309             cur = device;
 310             break;
 311         }
 312     }
 313
 314     if(!cur){
 315         /* No device found, allocate new one */
 316         cur = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*cur));
 317         if (!cur)
 318             return NULL;
 319
 320         cur->IMMDevice_iface.lpVtbl = &MMDeviceVtbl;
 321         cur->IMMEndpoint_iface.lpVtbl = &MMEndpointVtbl;
 322
 323         InitializeCriticalSection(&cur->crst);
 324         cur->crst.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": MMDevice.crst");
 325
 326         if (!MMDevice_head)
 327             MMDevice_head = HeapAlloc(GetProcessHeap(), 0, sizeof(*MMDevice_head));
 328         else
 329             MMDevice_head = HeapReAlloc(GetProcessHeap(), 0, MMDevice_head, sizeof(*MMDevice_head)*(1+MMDevice_count));
 330         MMDevice_head[MMDevice_count++] = cur;
 331     }else if(cur->ref > 0)
 332         WARN("Modifying an MMDevice with postitive reference count!\n");
 333
 334     HeapFree(GetProcessHeap(), 0, cur->drv_id);
 335     cur->drv_id = name;
 336
 337     cur->flow = flow;
 338     cur->state = state;
 339     cur->devguid = *id;
 340
 341     StringFromGUID2(&cur->devguid, guidstr, sizeof(guidstr)/sizeof(*guidstr));
 342
 343     if (flow == eRender)
 344         root = key_render;
 345     else
 346         root = key_capture;
 347
 348     if (RegCreateKeyExW(root, guidstr, 0, NULL, 0, KEY_WRITE|KEY_READ|KEY_WOW64_64KEY, NULL, &key, NULL) == ERROR_SUCCESS)
 349     {
 350         HKEY keyprop;
 351         RegSetValueExW(key, reg_devicestate, 0, REG_DWORD, (const BYTE*)&state, sizeof(DWORD));
 352         if (!RegCreateKeyExW(key, reg_properties, 0, NULL, 0, KEY_WRITE|KEY_READ|KEY_WOW64_64KEY, NULL, &keyprop, NULL))
 353         {
 354             PROPVARIANT pv;
 355
 356             pv.vt = VT_LPWSTR;
 357             pv.u.pwszVal = name;
 358             MMDevice_SetPropValue(id, flow, (const PROPERTYKEY*)&DEVPKEY_Device_FriendlyName, &pv);
 359             MMDevice_SetPropValue(id, flow, (const PROPERTYKEY*)&DEVPKEY_Device_DeviceDesc, &pv);
 360
 361             pv.u.pwszVal = guidstr;
 362             MMDevice_SetPropValue(id, flow, &deviceinterface_key, &pv);
 363
 364             set_driver_prop_value(id, flow, &devicepath_key);
 365
 366             if (FAILED(set_driver_prop_value(id, flow, &PKEY_AudioEndpoint_FormFactor)))
 367             {
 368                 pv.vt = VT_UI4;
 369                 pv.u.ulVal = (flow == eCapture) ? Microphone : Speakers;
 370
 371                 MMDevice_SetPropValue(id, flow, &PKEY_AudioEndpoint_FormFactor, &pv);
 372             }
 373
 374             if (flow != eCapture)
 375             {
 376                 PROPVARIANT pv2;
 377
 378                 PropVariantInit(&pv2);
 379
 380                 /* make read-write by not overwriting if already set */
 381                 if (FAILED(MMDevice_GetPropValue(id, flow, &PKEY_AudioEndpoint_PhysicalSpeakers, &pv2)) || pv2.vt != VT_UI4)
 382                     set_driver_prop_value(id, flow, &PKEY_AudioEndpoint_PhysicalSpeakers);
 383
 384                 PropVariantClear(&pv2);
 385             }
 386
 387             RegCloseKey(keyprop);
 388         }
 389         RegCloseKey(key);
 390     }
 391
 392     if (setdefault)
 393     {
 394         if (flow == eRender)
 395             MMDevice_def_play = cur;
 396         else
 397             MMDevice_def_rec = cur;
 398     }
 399     return cur;
 400 }
 401
 402 static HRESULT load_devices_from_reg(void)
 403 {
 404     DWORD i = 0;
 405     HKEY root, cur;
 406     LONG ret;
 407     DWORD curflow;
 408
 409     ret = RegCreateKeyExW(HKEY_LOCAL_MACHINE, software_mmdevapi, 0, NULL, 0, KEY_WRITE|KEY_READ|KEY_WOW64_64KEY, NULL, &root, NULL);
 410     if (ret == ERROR_SUCCESS)
 411         ret = RegCreateKeyExW(root, reg_capture, 0, NULL, 0, KEY_READ|KEY_WRITE|KEY_WOW64_64KEY, NULL, &key_capture, NULL);
 412     if (ret == ERROR_SUCCESS)
 413         ret = RegCreateKeyExW(root, reg_render, 0, NULL, 0, KEY_READ|KEY_WRITE|KEY_WOW64_64KEY, NULL, &key_render, NULL);
 414     RegCloseKey(root);
 415     cur = key_capture;
 416     curflow = eCapture;
 417     if (ret != ERROR_SUCCESS)
 418     {
 419         RegCloseKey(key_capture);
 420         key_render = key_capture = NULL;
 421         WARN("Couldn't create key: %u\n", ret);
 422         return E_FAIL;
 423     }
 424
 425     do {
 426         WCHAR guidvalue[39];
 427         GUID guid;
 428         DWORD len;
 429         PROPVARIANT pv = { VT_EMPTY };
 430
 431         len = sizeof(guidvalue)/sizeof(guidvalue[0]);
 432         ret = RegEnumKeyExW(cur, i++, guidvalue, &len, NULL, NULL, NULL, NULL);
 433         if (ret == ERROR_NO_MORE_ITEMS)
 434         {
 435             if (cur == key_capture)
 436             {
 437                 cur = key_render;
 438                 curflow = eRender;
 439                 i = 0;
 440                 continue;
 441             }
 442             break;
 443         }
 444         if (ret != ERROR_SUCCESS)
 445             continue;
 446         if (SUCCEEDED(CLSIDFromString(guidvalue, &guid))
 447             && SUCCEEDED(MMDevice_GetPropValue(&guid, curflow, (const PROPERTYKEY*)&DEVPKEY_Device_FriendlyName, &pv))
 448             && pv.vt == VT_LPWSTR)
 449         {
 450             DWORD size_bytes = (strlenW(pv.u.pwszVal) + 1) * sizeof(WCHAR);
 451             WCHAR *name = HeapAlloc(GetProcessHeap(), 0, size_bytes);
 452             memcpy(name, pv.u.pwszVal, size_bytes);
 453             MMDevice_Create(name, &guid, curflow,
 454                     DEVICE_STATE_NOTPRESENT, FALSE);
 455             CoTaskMemFree(pv.u.pwszVal);
 456         }
 457     } while (1);
 458
 459     return S_OK;
 460 }
 461
 462 static HRESULT set_format(MMDevice *dev)
 463 {
 464     HRESULT hr;
 465     IAudioClient *client;
 466     WAVEFORMATEX *fmt;
 467     PROPVARIANT pv = { VT_EMPTY };
 468
 469     hr = drvs.pGetAudioEndpoint(&dev->devguid, &dev->IMMDevice_iface, &client);
 470     if(FAILED(hr))
 471         return hr;
 472
 473     hr = IAudioClient_GetMixFormat(client, &fmt);
 474     if(FAILED(hr)){
 475         IAudioClient_Release(client);
 476         return hr;
 477     }
 478
 479     IAudioClient_Release(client);
 480
 481     pv.vt = VT_BLOB;
 482     pv.u.blob.cbSize = sizeof(WAVEFORMATEX) + fmt->cbSize;
 483     pv.u.blob.pBlobData = (BYTE*)fmt;
 484     MMDevice_SetPropValue(&dev->devguid, dev->flow,
 485             &PKEY_AudioEngine_DeviceFormat, &pv);
 486     MMDevice_SetPropValue(&dev->devguid, dev->flow,
 487             &PKEY_AudioEngine_OEMFormat, &pv);
 488     CoTaskMemFree(fmt);
 489
 490     return S_OK;
 491 }
 492
 493 static HRESULT load_driver_devices(EDataFlow flow)
 494 {
 495     WCHAR **ids;
 496     GUID *guids;
 497     UINT num, def, i;
 498     HRESULT hr;
 499
 500     if(!drvs.pGetEndpointIDs)
 501         return S_OK;
 502
 503     hr = drvs.pGetEndpointIDs(flow, &ids, &guids, &num, &def);
 504     if(FAILED(hr))
 505         return hr;
 506
 507     for(i = 0; i < num; ++i){
 508         MMDevice *dev;
 509         dev = MMDevice_Create(ids[i], &guids[i], flow, DEVICE_STATE_ACTIVE,
 510                 def == i);
 511         set_format(dev);
 512     }
 513
 514     HeapFree(GetProcessHeap(), 0, guids);
 515     HeapFree(GetProcessHeap(), 0, ids);
 516
 517     return S_OK;
 518 }
 519
 520 static void MMDevice_Destroy(MMDevice *This)
 521 {
 522     DWORD i;
 523     TRACE("Freeing %s\n", debugstr_w(This->drv_id));
 524     /* Since this function is called at destruction time, reordering of the list is unimportant */
 525     for (i = 0; i < MMDevice_count; ++i)
 526     {
 527         if (MMDevice_head[i] == This)
 528         {
 529             MMDevice_head[i] = MMDevice_head[--MMDevice_count];
 530             break;
 531         }
 532     }
 533     This->crst.DebugInfo->Spare[0] = 0;
 534     DeleteCriticalSection(&This->crst);
 535     HeapFree(GetProcessHeap(), 0, This->drv_id);
 536     HeapFree(GetProcessHeap(), 0, This);
 537 }
 538
 539 static inline MMDevice *impl_from_IMMDevice(IMMDevice *iface)
 540 {
 541     return CONTAINING_RECORD(iface, MMDevice, IMMDevice_iface);
 542 }
 543
 544 static HRESULT WINAPI MMDevice_QueryInterface(IMMDevice *iface, REFIID riid, void **ppv)
 545 {
 546     MMDevice *This = impl_from_IMMDevice(iface);
 547     TRACE("(%p)->(%s,%p)\n", iface, debugstr_guid(riid), ppv);
 548
 549     if (!ppv)
 550         return E_POINTER;
 551     *ppv = NULL;
 552     if (IsEqualIID(riid, &IID_IUnknown)
 553         || IsEqualIID(riid, &IID_IMMDevice))
 554         *ppv = This;
 555     else if (IsEqualIID(riid, &IID_IMMEndpoint))
 556         *ppv = &This->IMMEndpoint_iface;
 557     if (*ppv)
 558     {
 559         IUnknown_AddRef((IUnknown*)*ppv);
 560         return S_OK;
 561     }
 562     WARN("Unknown interface %s\n", debugstr_guid(riid));
 563     return E_NOINTERFACE;
 564 }
 565
 566 static ULONG WINAPI MMDevice_AddRef(IMMDevice *iface)
 567 {
 568     MMDevice *This = impl_from_IMMDevice(iface);
 569     LONG ref;
 570
 571     ref = InterlockedIncrement(&This->ref);
 572     TRACE("Refcount now %i\n", ref);
 573     return ref;
 574 }
 575
 576 static ULONG WINAPI MMDevice_Release(IMMDevice *iface)
 577 {
 578     MMDevice *This = impl_from_IMMDevice(iface);
 579     LONG ref;
 580
 581     ref = InterlockedDecrement(&This->ref);
 582     TRACE("Refcount now %i\n", ref);
 583     return ref;
 584 }
 585
 586 static HRESULT WINAPI MMDevice_Activate(IMMDevice *iface, REFIID riid, DWORD clsctx, PROPVARIANT *params, void **ppv)
 587 {
 588     HRESULT hr = E_NOINTERFACE;
 589     MMDevice *This = impl_from_IMMDevice(iface);
 590
 591     TRACE("(%p)->(%p,%x,%p,%p)\n", iface, riid, clsctx, params, ppv);
 592
 593     if (!ppv)
 594         return E_POINTER;
 595
 596     if (IsEqualIID(riid, &IID_IAudioClient)){
 597         hr = drvs.pGetAudioEndpoint(&This->devguid, iface, (IAudioClient**)ppv);
 598     }else if (IsEqualIID(riid, &IID_IAudioEndpointVolume))
 599         hr = AudioEndpointVolume_Create(This, (IAudioEndpointVolume**)ppv);
 600     else if (IsEqualIID(riid, &IID_IAudioSessionManager)
 601              || IsEqualIID(riid, &IID_IAudioSessionManager2))
 602     {
 603         hr = drvs.pGetAudioSessionManager(iface, (IAudioSessionManager2**)ppv);
 604     }
 605     else if (IsEqualIID(riid, &IID_IBaseFilter))
 606     {
 607         if (This->flow == eRender)
 608             hr = CoCreateInstance(&CLSID_DSoundRender, NULL, clsctx, riid, ppv);
 609         else
 610             ERR("Not supported for recording?\n");
 611         if (SUCCEEDED(hr))
 612         {
 613             IPersistPropertyBag *ppb;
 614             hr = IUnknown_QueryInterface((IUnknown*)*ppv, &IID_IPersistPropertyBag, (void*)&ppb);
 615             if (SUCCEEDED(hr))
 616             {
 617                 /* ::Load cannot assume the interface stays alive after the function returns,
 618                  * so just create the interface on the stack, saves a lot of complicated code */
 619                 IPropertyBagImpl bag = { { &PB_Vtbl } };
 620                 bag.devguid = This->devguid;
 621                 hr = IPersistPropertyBag_Load(ppb, &bag.IPropertyBag_iface, NULL);
 622                 IPersistPropertyBag_Release(ppb);
 623                 if (FAILED(hr))
 624                     IBaseFilter_Release((IBaseFilter*)*ppv);
 625             }
 626             else
 627             {
 628                 FIXME("Wine doesn't support IPersistPropertyBag on DSoundRender yet, ignoring..\n");
 629                 hr = S_OK;
 630             }
 631         }
 632     }
 633     else if (IsEqualIID(riid, &IID_IDeviceTopology))
 634     {
 635         FIXME("IID_IDeviceTopology unsupported\n");
 636     }
 637     else if (IsEqualIID(riid, &IID_IDirectSound)
 638              || IsEqualIID(riid, &IID_IDirectSound8))
 639     {
 640         if (This->flow == eRender)
 641             hr = CoCreateInstance(&CLSID_DirectSound8, NULL, clsctx, riid, ppv);
 642         if (SUCCEEDED(hr))
 643         {
 644             hr = IDirectSound_Initialize((IDirectSound*)*ppv, &This->devguid);
 645             if (FAILED(hr))
 646                 IDirectSound_Release((IDirectSound*)*ppv);
 647         }
 648     }
 649     else if (IsEqualIID(riid, &IID_IDirectSoundCapture))
 650     {
 651         if (This->flow == eCapture)
 652             hr = CoCreateInstance(&CLSID_DirectSoundCapture8, NULL, clsctx, riid, ppv);
 653         if (SUCCEEDED(hr))
 654         {
 655             hr = IDirectSoundCapture_Initialize((IDirectSoundCapture*)*ppv, &This->devguid);
 656             if (FAILED(hr))
 657                 IDirectSoundCapture_Release((IDirectSoundCapture*)*ppv);
 658         }
 659     }
 660     else
 661         ERR("Invalid/unknown iid %s\n", debugstr_guid(riid));
 662
 663     if (FAILED(hr))
 664         *ppv = NULL;
 665
 666     TRACE("Returning %08x\n", hr);
 667     return hr;
 668 }
 669
 670 static HRESULT WINAPI MMDevice_OpenPropertyStore(IMMDevice *iface, DWORD access, IPropertyStore **ppv)
 671 {
 672     MMDevice *This = impl_from_IMMDevice(iface);
 673     TRACE("(%p)->(%x,%p)\n", This, access, ppv);
 674
 675     if (!ppv)
 676         return E_POINTER;
 677     return MMDevPropStore_Create(This, access, ppv);
 678 }
 679
 680 static HRESULT WINAPI MMDevice_GetId(IMMDevice *iface, WCHAR **itemid)
 681 {
 682     MMDevice *This = impl_from_IMMDevice(iface);
 683     WCHAR *str;
 684     GUID *id = &This->devguid;
 685     static const WCHAR formatW[] = { '{','0','.','0','.','%','u','.','0','0','0','0','0','0','0','0','}','.',
 686                                      '{','%','0','8','X','-','%','0','4','X','-',
 687                                      '%','0','4','X','-','%','0','2','X','%','0','2','X','-',
 688                                      '%','0','2','X','%','0','2','X','%','0','2','X','%','0','2','X',
 689                                      '%','0','2','X','%','0','2','X','}',0 };
 690
 691     TRACE("(%p)->(%p)\n", This, itemid);
 692     if (!itemid)
 693         return E_POINTER;
 694     *itemid = str = CoTaskMemAlloc(56 * sizeof(WCHAR));
 695     if (!str)
 696         return E_OUTOFMEMORY;
 697     wsprintfW( str, formatW, This->flow, id->Data1, id->Data2, id->Data3,
 698                id->Data4[0], id->Data4[1], id->Data4[2], id->Data4[3],
 699                id->Data4[4], id->Data4[5], id->Data4[6], id->Data4[7] );
 700     TRACE("returning %s\n", wine_dbgstr_w(str));
 701     return S_OK;
 702 }
 703
 704 static HRESULT WINAPI MMDevice_GetState(IMMDevice *iface, DWORD *state)
 705 {
 706     MMDevice *This = impl_from_IMMDevice(iface);
 707     TRACE("(%p)->(%p)\n", iface, state);
 708
 709     if (!state)
 710         return E_POINTER;
 711     *state = This->state;
 712     return S_OK;
 713 }
 714
 715 static const IMMDeviceVtbl MMDeviceVtbl =
 716 {
 717     MMDevice_QueryInterface,
 718     MMDevice_AddRef,
 719     MMDevice_Release,
 720     MMDevice_Activate,
 721     MMDevice_OpenPropertyStore,
 722     MMDevice_GetId,
 723     MMDevice_GetState
 724 };
 725
 726 static inline MMDevice *impl_from_IMMEndpoint(IMMEndpoint *iface)
 727 {
 728     return CONTAINING_RECORD(iface, MMDevice, IMMEndpoint_iface);
 729 }
 730
 731 static HRESULT WINAPI MMEndpoint_QueryInterface(IMMEndpoint *iface, REFIID riid, void **ppv)
 732 {
 733     MMDevice *This = impl_from_IMMEndpoint(iface);
 734     TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), ppv);
 735     return IMMDevice_QueryInterface(&This->IMMDevice_iface, riid, ppv);
 736 }
 737
 738 static ULONG WINAPI MMEndpoint_AddRef(IMMEndpoint *iface)
 739 {
 740     MMDevice *This = impl_from_IMMEndpoint(iface);
 741     TRACE("(%p)\n", This);
 742     return IMMDevice_AddRef(&This->IMMDevice_iface);
 743 }
 744
 745 static ULONG WINAPI MMEndpoint_Release(IMMEndpoint *iface)
 746 {
 747     MMDevice *This = impl_from_IMMEndpoint(iface);
 748     TRACE("(%p)\n", This);
 749     return IMMDevice_Release(&This->IMMDevice_iface);
 750 }
 751
 752 static HRESULT WINAPI MMEndpoint_GetDataFlow(IMMEndpoint *iface, EDataFlow *flow)
 753 {
 754     MMDevice *This = impl_from_IMMEndpoint(iface);
 755     TRACE("(%p)->(%p)\n", This, flow);
 756     if (!flow)
 757         return E_POINTER;
 758     *flow = This->flow;
 759     return S_OK;
 760 }
 761
 762 static const IMMEndpointVtbl MMEndpointVtbl =
 763 {
 764     MMEndpoint_QueryInterface,
 765     MMEndpoint_AddRef,
 766     MMEndpoint_Release,
 767     MMEndpoint_GetDataFlow
 768 };
 769
 770 static HRESULT MMDevCol_Create(IMMDeviceCollection **ppv, EDataFlow flow, DWORD state)
 771 {
 772     MMDevColImpl *This;
 773
 774     This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
 775     *ppv = NULL;
 776     if (!This)
 777         return E_OUTOFMEMORY;
 778     This->IMMDeviceCollection_iface.lpVtbl = &MMDevColVtbl;
 779     This->ref = 1;
 780     This->flow = flow;
 781     This->state = state;
 782     *ppv = &This->IMMDeviceCollection_iface;
 783     return S_OK;
 784 }
 785
 786 static void MMDevCol_Destroy(MMDevColImpl *This)
 787 {
 788     HeapFree(GetProcessHeap(), 0, This);
 789 }
 790
 791 static HRESULT WINAPI MMDevCol_QueryInterface(IMMDeviceCollection *iface, REFIID riid, void **ppv)
 792 {
 793     MMDevColImpl *This = impl_from_IMMDeviceCollection(iface);
 794     TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), ppv);
 795
 796     if (!ppv)
 797         return E_POINTER;
 798     if (IsEqualIID(riid, &IID_IUnknown)
 799         || IsEqualIID(riid, &IID_IMMDeviceCollection))
 800         *ppv = This;
 801     else
 802         *ppv = NULL;
 803     if (!*ppv)
 804         return E_NOINTERFACE;
 805     IUnknown_AddRef((IUnknown*)*ppv);
 806     return S_OK;
 807 }
 808
 809 static ULONG WINAPI MMDevCol_AddRef(IMMDeviceCollection *iface)
 810 {
 811     MMDevColImpl *This = impl_from_IMMDeviceCollection(iface);
 812     LONG ref = InterlockedIncrement(&This->ref);
 813     TRACE("Refcount now %i\n", ref);
 814     return ref;
 815 }
 816
 817 static ULONG WINAPI MMDevCol_Release(IMMDeviceCollection *iface)
 818 {
 819     MMDevColImpl *This = impl_from_IMMDeviceCollection(iface);
 820     LONG ref = InterlockedDecrement(&This->ref);
 821     TRACE("Refcount now %i\n", ref);
 822     if (!ref)
 823         MMDevCol_Destroy(This);
 824     return ref;
 825 }
 826
 827 static HRESULT WINAPI MMDevCol_GetCount(IMMDeviceCollection *iface, UINT *numdevs)
 828 {
 829     MMDevColImpl *This = impl_from_IMMDeviceCollection(iface);
 830     DWORD i;
 831
 832     TRACE("(%p)->(%p)\n", This, numdevs);
 833     if (!numdevs)
 834         return E_POINTER;
 835
 836     *numdevs = 0;
 837     for (i = 0; i < MMDevice_count; ++i)
 838     {
 839         MMDevice *cur = MMDevice_head[i];
 840         if ((cur->flow == This->flow || This->flow == eAll)
 841             && (cur->state & This->state))
 842             ++(*numdevs);
 843     }
 844     return S_OK;
 845 }
 846
 847 static HRESULT WINAPI MMDevCol_Item(IMMDeviceCollection *iface, UINT n, IMMDevice **dev)
 848 {
 849     MMDevColImpl *This = impl_from_IMMDeviceCollection(iface);
 850     DWORD i = 0, j = 0;
 851
 852     TRACE("(%p)->(%u, %p)\n", This, n, dev);
 853     if (!dev)
 854         return E_POINTER;
 855
 856     for (j = 0; j < MMDevice_count; ++j)
 857     {
 858         MMDevice *cur = MMDevice_head[j];
 859         if ((cur->flow == This->flow || This->flow == eAll)
 860             && (cur->state & This->state)
 861             && i++ == n)
 862         {
 863             *dev = &cur->IMMDevice_iface;
 864             IMMDevice_AddRef(*dev);
 865             return S_OK;
 866         }
 867     }
 868     WARN("Could not obtain item %u\n", n);
 869     *dev = NULL;
 870     return E_INVALIDARG;
 871 }
 872
 873 static const IMMDeviceCollectionVtbl MMDevColVtbl =
 874 {
 875     MMDevCol_QueryInterface,
 876     MMDevCol_AddRef,
 877     MMDevCol_Release,
 878     MMDevCol_GetCount,
 879     MMDevCol_Item
 880 };
 881
 882 HRESULT MMDevEnum_Create(REFIID riid, void **ppv)
 883 {
 884     MMDevEnumImpl *This = MMDevEnumerator;
 885
 886     if (!This)
 887     {
 888         This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
 889         *ppv = NULL;
 890         if (!This)
 891             return E_OUTOFMEMORY;
 892         This->ref = 1;
 893         This->IMMDeviceEnumerator_iface.lpVtbl = &MMDevEnumVtbl;
 894         MMDevEnumerator = This;
 895
 896         load_devices_from_reg();
 897         load_driver_devices(eRender);
 898         load_driver_devices(eCapture);
 899     }
 900     return IUnknown_QueryInterface((IUnknown*)This, riid, ppv);
 901 }
 902
 903 void MMDevEnum_Free(void)
 904 {
 905     while (MMDevice_count)
 906         MMDevice_Destroy(MMDevice_head[0]);
 907     RegCloseKey(key_render);
 908     RegCloseKey(key_capture);
 909     key_render = key_capture = NULL;
 910     HeapFree(GetProcessHeap(), 0, MMDevEnumerator);
 911     MMDevEnumerator = NULL;
 912 }
 913
 914 static HRESULT WINAPI MMDevEnum_QueryInterface(IMMDeviceEnumerator *iface, REFIID riid, void **ppv)
 915 {
 916     MMDevEnumImpl *This = impl_from_IMMDeviceEnumerator(iface);
 917     TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), ppv);
 918
 919     if (!ppv)
 920         return E_POINTER;
 921     if (IsEqualIID(riid, &IID_IUnknown)
 922         || IsEqualIID(riid, &IID_IMMDeviceEnumerator))
 923         *ppv = This;
 924     else
 925         *ppv = NULL;
 926     if (!*ppv)
 927         return E_NOINTERFACE;
 928     IUnknown_AddRef((IUnknown*)*ppv);
 929     return S_OK;
 930 }
 931
 932 static ULONG WINAPI MMDevEnum_AddRef(IMMDeviceEnumerator *iface)
 933 {
 934     MMDevEnumImpl *This = impl_from_IMMDeviceEnumerator(iface);
 935     LONG ref = InterlockedIncrement(&This->ref);
 936     TRACE("Refcount now %i\n", ref);
 937     return ref;
 938 }
 939
 940 static ULONG WINAPI MMDevEnum_Release(IMMDeviceEnumerator *iface)
 941 {
 942     MMDevEnumImpl *This = impl_from_IMMDeviceEnumerator(iface);
 943     LONG ref = InterlockedDecrement(&This->ref);
 944     if (!ref)
 945         MMDevEnum_Free();
 946     TRACE("Refcount now %i\n", ref);
 947     return ref;
 948 }
 949
 950 static HRESULT WINAPI MMDevEnum_EnumAudioEndpoints(IMMDeviceEnumerator *iface, EDataFlow flow, DWORD mask, IMMDeviceCollection **devices)
 951 {
 952     MMDevEnumImpl *This = impl_from_IMMDeviceEnumerator(iface);
 953     TRACE("(%p)->(%u,%u,%p)\n", This, flow, mask, devices);
 954     if (!devices)
 955         return E_POINTER;
 956     *devices = NULL;
 957     if (flow >= EDataFlow_enum_count)
 958         return E_INVALIDARG;
 959     if (mask & ~DEVICE_STATEMASK_ALL)
 960         return E_INVALIDARG;
 961     return MMDevCol_Create(devices, flow, mask);
 962 }
 963
 964 static HRESULT WINAPI MMDevEnum_GetDefaultAudioEndpoint(IMMDeviceEnumerator *iface, EDataFlow flow, ERole role, IMMDevice **device)
 965 {
 966     MMDevEnumImpl *This = impl_from_IMMDeviceEnumerator(iface);
 967     WCHAR reg_key[256];
 968     HKEY key;
 969     HRESULT hr;
 970
 971     TRACE("(%p)->(%u,%u,%p)\n", This, flow, role, device);
 972
 973     if (!device)
 974         return E_POINTER;
 975
 976     if((flow != eRender && flow != eCapture) ||
 977             (role != eConsole && role != eMultimedia && role != eCommunications)){
 978         WARN("Unknown flow (%u) or role (%u)\n", flow, role);
 979         return E_INVALIDARG;
 980     }
 981
 982     *device = NULL;
 983
 984     if(!drvs.module_name[0])
 985         return E_NOTFOUND;
 986
 987     lstrcpyW(reg_key, drv_keyW);
 988     lstrcatW(reg_key, slashW);
 989     lstrcatW(reg_key, drvs.module_name);
 990
 991     if(RegOpenKeyW(HKEY_CURRENT_USER, reg_key, &key) == ERROR_SUCCESS){
 992         const WCHAR *reg_x_name, *reg_vx_name;
 993         WCHAR def_id[256];
 994         DWORD size = sizeof(def_id), state;
 995
 996         if(flow == eRender){
 997             reg_x_name = reg_out_nameW;
 998             reg_vx_name = reg_vout_nameW;
 999         }else{
1000             reg_x_name = reg_in_nameW;
1001             reg_vx_name = reg_vin_nameW;
1002         }
1003
1004         if(role == eCommunications &&
1005                 RegQueryValueExW(key, reg_vx_name, 0, NULL,
1006                     (BYTE*)def_id, &size) == ERROR_SUCCESS){
1007             hr = IMMDeviceEnumerator_GetDevice(iface, def_id, device);
1008             if(SUCCEEDED(hr)){
1009                 if(SUCCEEDED(IMMDevice_GetState(*device, &state)) &&
1010                         state == DEVICE_STATE_ACTIVE){
1011                     RegCloseKey(key);
1012                     return S_OK;
1013                 }
1014             }
1015
1016             TRACE("Unable to find voice device %s\n", wine_dbgstr_w(def_id));
1017         }
1018
1019         if(RegQueryValueExW(key, reg_x_name, 0, NULL,
1020                     (BYTE*)def_id, &size) == ERROR_SUCCESS){
1021             hr = IMMDeviceEnumerator_GetDevice(iface, def_id, device);
1022             if(SUCCEEDED(hr)){
1023                 if(SUCCEEDED(IMMDevice_GetState(*device, &state)) &&
1024                         state == DEVICE_STATE_ACTIVE){
1025                     RegCloseKey(key);
1026                     return S_OK;
1027                 }
1028             }
1029
1030             TRACE("Unable to find device %s\n", wine_dbgstr_w(def_id));
1031         }
1032
1033         RegCloseKey(key);
1034     }
1035
1036     if (flow == eRender)
1037         *device = &MMDevice_def_play->IMMDevice_iface;
1038     else
1039         *device = &MMDevice_def_rec->IMMDevice_iface;
1040
1041     if (!*device)
1042         return E_NOTFOUND;
1043     IMMDevice_AddRef(*device);
1044     return S_OK;
1045 }
1046
1047 static HRESULT WINAPI MMDevEnum_GetDevice(IMMDeviceEnumerator *iface, const WCHAR *name, IMMDevice **device)
1048 {
1049     MMDevEnumImpl *This = impl_from_IMMDeviceEnumerator(iface);
1050     DWORD i=0;
1051     IMMDevice *dev = NULL;
1052
1053     static const WCHAR wine_info_deviceW[] = {'W','i','n','e',' ',
1054         'i','n','f','o',' ','d','e','v','i','c','e',0};
1055
1056     TRACE("(%p)->(%s,%p)\n", This, debugstr_w(name), device);
1057
1058     if(!name || !device)
1059         return E_POINTER;
1060
1061     if(!lstrcmpW(name, wine_info_deviceW)){
1062         *device = &info_device;
1063         return S_OK;
1064     }
1065
1066     for (i = 0; i < MMDevice_count; ++i)
1067     {
1068         WCHAR *str;
1069         dev = &MMDevice_head[i]->IMMDevice_iface;
1070         IMMDevice_GetId(dev, &str);
1071
1072         if (str && !lstrcmpW(str, name))
1073         {
1074             CoTaskMemFree(str);
1075             IMMDevice_AddRef(dev);
1076             *device = dev;
1077             return S_OK;
1078         }
1079         CoTaskMemFree(str);
1080     }
1081     TRACE("Could not find device %s\n", debugstr_w(name));
1082     return E_INVALIDARG;
1083 }
1084
1085 struct NotificationClientWrapper {
1086     IMMNotificationClient *client;
1087     struct list entry;
1088 };
1089
1090 static struct list g_notif_clients = LIST_INIT(g_notif_clients);
1091 static HANDLE g_notif_thread;
1092
1093 static CRITICAL_SECTION g_notif_lock;
1094 static CRITICAL_SECTION_DEBUG g_notif_lock_debug =
1095 {
1096     0, 0, &g_notif_lock,
1097     { &g_notif_lock_debug.ProcessLocksList, &g_notif_lock_debug.ProcessLocksList },
1098       0, 0, { (DWORD_PTR)(__FILE__ ": g_notif_lock") }
1099 };
1100 static CRITICAL_SECTION g_notif_lock = { &g_notif_lock_debug, -1, 0, 0, 0, 0 };
1101
1102 static void notify_clients(EDataFlow flow, ERole role, const WCHAR *id)
1103 {
1104     struct NotificationClientWrapper *wrapper;
1105     LIST_FOR_EACH_ENTRY(wrapper, &g_notif_clients,
1106             struct NotificationClientWrapper, entry)
1107         IMMNotificationClient_OnDefaultDeviceChanged(wrapper->client, flow,
1108                 role, id);
1109
1110     /* Windows 7 treats changes to eConsole as changes to eMultimedia */
1111     if(role == eConsole)
1112         notify_clients(flow, eMultimedia, id);
1113 }
1114
1115 static BOOL notify_if_changed(EDataFlow flow, ERole role, HKEY key,
1116                               const WCHAR *val_name, WCHAR *old_val, IMMDevice *def_dev)
1117 {
1118     WCHAR new_val[64], *id;
1119     DWORD size;
1120     HRESULT hr;
1121
1122     size = sizeof(new_val);
1123     if(RegQueryValueExW(key, val_name, 0, NULL,
1124                 (BYTE*)new_val, &size) != ERROR_SUCCESS){
1125         if(old_val[0] != 0){
1126             /* set by user -> system default */
1127             if(def_dev){
1128                 hr = IMMDevice_GetId(def_dev, &id);
1129                 if(FAILED(hr)){
1130                     ERR("GetId failed: %08x\n", hr);
1131                     return FALSE;
1132                 }
1133             }else
1134                 id = NULL;
1135
1136             notify_clients(flow, role, id);
1137             old_val[0] = 0;
1138             CoTaskMemFree(id);
1139
1140             return TRUE;
1141         }
1142
1143         /* system default -> system default, noop */
1144         return FALSE;
1145     }
1146
1147     if(!lstrcmpW(old_val, new_val)){
1148         /* set by user -> same value */
1149         return FALSE;
1150     }
1151
1152     if(new_val[0] != 0){
1153         /* set by user -> different value */
1154         notify_clients(flow, role, new_val);
1155         memcpy(old_val, new_val, sizeof(new_val));
1156         return TRUE;
1157     }
1158
1159     /* set by user -> system default */
1160     if(def_dev){
1161         hr = IMMDevice_GetId(def_dev, &id);
1162         if(FAILED(hr)){
1163             ERR("GetId failed: %08x\n", hr);
1164             return FALSE;
1165         }
1166     }else
1167         id = NULL;
1168
1169     notify_clients(flow, role, id);
1170     old_val[0] = 0;
1171     CoTaskMemFree(id);
1172
1173     return TRUE;
1174 }
1175
1176 static DWORD WINAPI notif_thread_proc(void *user)
1177 {
1178     HKEY key;
1179     WCHAR reg_key[256];
1180     WCHAR out_name[64], vout_name[64], in_name[64], vin_name[64];
1181     DWORD size;
1182
1183     lstrcpyW(reg_key, drv_keyW);
1184     lstrcatW(reg_key, slashW);
1185     lstrcatW(reg_key, drvs.module_name);
1186
1187     if(RegCreateKeyExW(HKEY_CURRENT_USER, reg_key, 0, NULL, 0,
1188                 MAXIMUM_ALLOWED, NULL, &key, NULL) != ERROR_SUCCESS){
1189         ERR("RegCreateKeyEx failed: %u\n", GetLastError());
1190         return 1;
1191     }
1192
1193     size = sizeof(out_name);
1194     if(RegQueryValueExW(key, reg_out_nameW, 0, NULL,
1195                 (BYTE*)out_name, &size) != ERROR_SUCCESS)
1196         out_name[0] = 0;
1197
1198     size = sizeof(vout_name);
1199     if(RegQueryValueExW(key, reg_vout_nameW, 0, NULL,
1200                 (BYTE*)vout_name, &size) != ERROR_SUCCESS)
1201         vout_name[0] = 0;
1202
1203     size = sizeof(in_name);
1204     if(RegQueryValueExW(key, reg_in_nameW, 0, NULL,
1205                 (BYTE*)in_name, &size) != ERROR_SUCCESS)
1206         in_name[0] = 0;
1207
1208     size = sizeof(vin_name);
1209     if(RegQueryValueExW(key, reg_vin_nameW, 0, NULL,
1210                 (BYTE*)vin_name, &size) != ERROR_SUCCESS)
1211         vin_name[0] = 0;
1212
1213     while(1){
1214         if(RegNotifyChangeKeyValue(key, FALSE, REG_NOTIFY_CHANGE_LAST_SET,
1215                     NULL, FALSE) != ERROR_SUCCESS){
1216             ERR("RegNotifyChangeKeyValue failed: %u\n", GetLastError());
1217             RegCloseKey(key);
1218             g_notif_thread = NULL;
1219             return 1;
1220         }
1221
1222         EnterCriticalSection(&g_notif_lock);
1223
1224         notify_if_changed(eRender, eConsole, key, reg_out_nameW,
1225                 out_name, &MMDevice_def_play->IMMDevice_iface);
1226         notify_if_changed(eRender, eCommunications, key, reg_vout_nameW,
1227                 vout_name, &MMDevice_def_play->IMMDevice_iface);
1228         notify_if_changed(eCapture, eConsole, key, reg_in_nameW,
1229                 in_name, &MMDevice_def_rec->IMMDevice_iface);
1230         notify_if_changed(eCapture, eCommunications, key, reg_vin_nameW,
1231                 vin_name, &MMDevice_def_rec->IMMDevice_iface);
1232
1233         LeaveCriticalSection(&g_notif_lock);
1234     }
1235
1236     RegCloseKey(key);
1237
1238     g_notif_thread = NULL;
1239
1240     return 0;
1241 }
1242
1243 static HRESULT WINAPI MMDevEnum_RegisterEndpointNotificationCallback(IMMDeviceEnumerator *iface, IMMNotificationClient *client)
1244 {
1245     MMDevEnumImpl *This = impl_from_IMMDeviceEnumerator(iface);
1246     struct NotificationClientWrapper *wrapper;
1247
1248     TRACE("(%p)->(%p)\n", This, client);
1249
1250     if(!client)
1251         return E_POINTER;
1252
1253     wrapper = HeapAlloc(GetProcessHeap(), 0, sizeof(*wrapper));
1254     if(!wrapper)
1255         return E_OUTOFMEMORY;
1256
1257     wrapper->client = client;
1258
1259     EnterCriticalSection(&g_notif_lock);
1260
1261     list_add_tail(&g_notif_clients, &wrapper->entry);
1262
1263     if(!g_notif_thread){
1264         g_notif_thread = CreateThread(NULL, 0, notif_thread_proc, NULL, 0, NULL);
1265         if(!g_notif_thread)
1266             ERR("CreateThread failed: %u\n", GetLastError());
1267     }
1268
1269     LeaveCriticalSection(&g_notif_lock);
1270
1271     return S_OK;
1272 }
1273
1274 static HRESULT WINAPI MMDevEnum_UnregisterEndpointNotificationCallback(IMMDeviceEnumerator *iface, IMMNotificationClient *client)
1275 {
1276     MMDevEnumImpl *This = impl_from_IMMDeviceEnumerator(iface);
1277     struct NotificationClientWrapper *wrapper, *wrapper2;
1278
1279     TRACE("(%p)->(%p)\n", This, client);
1280
1281     if(!client)
1282         return E_POINTER;
1283
1284     EnterCriticalSection(&g_notif_lock);
1285
1286     LIST_FOR_EACH_ENTRY_SAFE(wrapper, wrapper2, &g_notif_clients,
1287             struct NotificationClientWrapper, entry){
1288         if(wrapper->client == client){
1289             list_remove(&wrapper->entry);
1290             HeapFree(GetProcessHeap(), 0, wrapper);
1291             LeaveCriticalSection(&g_notif_lock);
1292             return S_OK;
1293         }
1294     }
1295
1296     LeaveCriticalSection(&g_notif_lock);
1297
1298     return E_NOTFOUND;
1299 }
1300
1301 static const IMMDeviceEnumeratorVtbl MMDevEnumVtbl =
1302 {
1303     MMDevEnum_QueryInterface,
1304     MMDevEnum_AddRef,
1305     MMDevEnum_Release,
1306     MMDevEnum_EnumAudioEndpoints,
1307     MMDevEnum_GetDefaultAudioEndpoint,
1308     MMDevEnum_GetDevice,
1309     MMDevEnum_RegisterEndpointNotificationCallback,
1310     MMDevEnum_UnregisterEndpointNotificationCallback
1311 };
1312
1313 static HRESULT MMDevPropStore_Create(MMDevice *parent, DWORD access, IPropertyStore **ppv)
1314 {
1315     MMDevPropStore *This;
1316     if (access != STGM_READ
1317         && access != STGM_WRITE
1318         && access != STGM_READWRITE)
1319     {
1320         WARN("Invalid access %08x\n", access);
1321         return E_INVALIDARG;
1322     }
1323     This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
1324     *ppv = &This->IPropertyStore_iface;
1325     if (!This)
1326         return E_OUTOFMEMORY;
1327     This->IPropertyStore_iface.lpVtbl = &MMDevPropVtbl;
1328     This->ref = 1;
1329     This->parent = parent;
1330     This->access = access;
1331     return S_OK;
1332 }
1333
1334 static void MMDevPropStore_Destroy(MMDevPropStore *This)
1335 {
1336     HeapFree(GetProcessHeap(), 0, This);
1337 }
1338
1339 static HRESULT WINAPI MMDevPropStore_QueryInterface(IPropertyStore *iface, REFIID riid, void **ppv)
1340 {
1341     MMDevPropStore *This = impl_from_IPropertyStore(iface);
1342     TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), ppv);
1343
1344     if (!ppv)
1345         return E_POINTER;
1346     if (IsEqualIID(riid, &IID_IUnknown)
1347         || IsEqualIID(riid, &IID_IPropertyStore))
1348         *ppv = This;
1349     else
1350         *ppv = NULL;
1351     if (!*ppv)
1352         return E_NOINTERFACE;
1353     IUnknown_AddRef((IUnknown*)*ppv);
1354     return S_OK;
1355 }
1356
1357 static ULONG WINAPI MMDevPropStore_AddRef(IPropertyStore *iface)
1358 {
1359     MMDevPropStore *This = impl_from_IPropertyStore(iface);
1360     LONG ref = InterlockedIncrement(&This->ref);
1361     TRACE("Refcount now %i\n", ref);
1362     return ref;
1363 }
1364
1365 static ULONG WINAPI MMDevPropStore_Release(IPropertyStore *iface)
1366 {
1367     MMDevPropStore *This = impl_from_IPropertyStore(iface);
1368     LONG ref = InterlockedDecrement(&This->ref);
1369     TRACE("Refcount now %i\n", ref);
1370     if (!ref)
1371         MMDevPropStore_Destroy(This);
1372     return ref;
1373 }
1374
1375 static HRESULT WINAPI MMDevPropStore_GetCount(IPropertyStore *iface, DWORD *nprops)
1376 {
1377     MMDevPropStore *This = impl_from_IPropertyStore(iface);
1378     WCHAR buffer[50];
1379     DWORD i = 0;
1380     HKEY propkey;
1381     HRESULT hr;
1382
1383     TRACE("(%p)->(%p)\n", iface, nprops);
1384     if (!nprops)
1385         return E_POINTER;
1386     hr = MMDevPropStore_OpenPropKey(&This->parent->devguid, This->parent->flow, &propkey);
1387     if (FAILED(hr))
1388         return hr;
1389     *nprops = 0;
1390     do {
1391         DWORD len = sizeof(buffer)/sizeof(*buffer);
1392         if (RegEnumValueW(propkey, i, buffer, &len, NULL, NULL, NULL, NULL) != ERROR_SUCCESS)
1393             break;
1394         i++;
1395     } while (1);
1396     RegCloseKey(propkey);
1397     TRACE("Returning %i\n", i);
1398     *nprops = i;
1399     return S_OK;
1400 }
1401
1402 static HRESULT WINAPI MMDevPropStore_GetAt(IPropertyStore *iface, DWORD prop, PROPERTYKEY *key)
1403 {
1404     MMDevPropStore *This = impl_from_IPropertyStore(iface);
1405     WCHAR buffer[50];
1406     DWORD len = sizeof(buffer)/sizeof(*buffer);
1407     HRESULT hr;
1408     HKEY propkey;
1409
1410     TRACE("(%p)->(%u,%p)\n", iface, prop, key);
1411     if (!key)
1412         return E_POINTER;
1413
1414     hr = MMDevPropStore_OpenPropKey(&This->parent->devguid, This->parent->flow, &propkey);
1415     if (FAILED(hr))
1416         return hr;
1417
1418     if (RegEnumValueW(propkey, prop, buffer, &len, NULL, NULL, NULL, NULL) != ERROR_SUCCESS
1419         || len <= 39)
1420     {
1421         WARN("GetAt %u failed\n", prop);
1422         return E_INVALIDARG;
1423     }
1424     RegCloseKey(propkey);
1425     buffer[38] = 0;
1426     CLSIDFromString(buffer, &key->fmtid);
1427     key->pid = atoiW(&buffer[39]);
1428     return S_OK;
1429 }
1430
1431 static HRESULT WINAPI MMDevPropStore_GetValue(IPropertyStore *iface, REFPROPERTYKEY key, PROPVARIANT *pv)
1432 {
1433     MMDevPropStore *This = impl_from_IPropertyStore(iface);
1434     TRACE("(%p)->(\"%s,%u\", %p)\n", This, key ? debugstr_guid(&key->fmtid) : NULL, key ? key->pid : 0, pv);
1435
1436     if (!key || !pv)
1437         return E_POINTER;
1438     if (This->access != STGM_READ
1439         && This->access != STGM_READWRITE)
1440         return STG_E_ACCESSDENIED;
1441
1442     /* Special case */
1443     if (IsEqualPropertyKey(*key, PKEY_AudioEndpoint_GUID))
1444     {
1445         pv->vt = VT_LPWSTR;
1446         pv->u.pwszVal = CoTaskMemAlloc(39 * sizeof(WCHAR));
1447         if (!pv->u.pwszVal)
1448             return E_OUTOFMEMORY;
1449         StringFromGUID2(&This->parent->devguid, pv->u.pwszVal, 39);
1450         return S_OK;
1451     }
1452
1453     return MMDevice_GetPropValue(&This->parent->devguid, This->parent->flow, key, pv);
1454 }
1455
1456 static HRESULT WINAPI MMDevPropStore_SetValue(IPropertyStore *iface, REFPROPERTYKEY key, REFPROPVARIANT pv)
1457 {
1458     MMDevPropStore *This = impl_from_IPropertyStore(iface);
1459     TRACE("(%p)->(\"%s,%u\", %p)\n", This, key ? debugstr_guid(&key->fmtid) : NULL, key ? key->pid : 0, pv);
1460
1461     if (!key || !pv)
1462         return E_POINTER;
1463
1464     if (This->access != STGM_WRITE
1465         && This->access != STGM_READWRITE)
1466         return STG_E_ACCESSDENIED;
1467     return MMDevice_SetPropValue(&This->parent->devguid, This->parent->flow, key, pv);
1468 }
1469
1470 static HRESULT WINAPI MMDevPropStore_Commit(IPropertyStore *iface)
1471 {
1472     MMDevPropStore *This = impl_from_IPropertyStore(iface);
1473     TRACE("(%p)\n", iface);
1474
1475     if (This->access != STGM_WRITE
1476         && This->access != STGM_READWRITE)
1477         return STG_E_ACCESSDENIED;
1478
1479     /* Does nothing - for mmdevapi, the propstore values are written on SetValue,
1480      * not on Commit. */
1481
1482     return S_OK;
1483 }
1484
1485 static const IPropertyStoreVtbl MMDevPropVtbl =
1486 {
1487     MMDevPropStore_QueryInterface,
1488     MMDevPropStore_AddRef,
1489     MMDevPropStore_Release,
1490     MMDevPropStore_GetCount,
1491     MMDevPropStore_GetAt,
1492     MMDevPropStore_GetValue,
1493     MMDevPropStore_SetValue,
1494     MMDevPropStore_Commit
1495 };
1496
1497
1498 /* Property bag for IBaseFilter activation */
1499 static HRESULT WINAPI PB_QueryInterface(IPropertyBag *iface, REFIID riid, void **ppv)
1500 {
1501     ERR("Should not be called\n");
1502     *ppv = NULL;
1503     return E_NOINTERFACE;
1504 }
1505
1506 static ULONG WINAPI PB_AddRef(IPropertyBag *iface)
1507 {
1508     ERR("Should not be called\n");
1509     return 2;
1510 }
1511
1512 static ULONG WINAPI PB_Release(IPropertyBag *iface)
1513 {
1514     ERR("Should not be called\n");
1515     return 1;
1516 }
1517
1518 static HRESULT WINAPI PB_Read(IPropertyBag *iface, LPCOLESTR name, VARIANT *var, IErrorLog *log)
1519 {
1520     static const WCHAR dsguid[] = { 'D','S','G','u','i','d', 0 };
1521     IPropertyBagImpl *This = impl_from_IPropertyBag(iface);
1522     TRACE("Trying to read %s, type %u\n", debugstr_w(name), var->n1.n2.vt);
1523     if (!lstrcmpW(name, dsguid))
1524     {
1525         WCHAR guidstr[39];
1526         StringFromGUID2(&This->devguid, guidstr,sizeof(guidstr)/sizeof(*guidstr));
1527         var->n1.n2.vt = VT_BSTR;
1528         var->n1.n2.n3.bstrVal = SysAllocString(guidstr);
1529         return S_OK;
1530     }
1531     ERR("Unknown property '%s' queried\n", debugstr_w(name));
1532     return E_FAIL;
1533 }
1534
1535 static HRESULT WINAPI PB_Write(IPropertyBag *iface, LPCOLESTR name, VARIANT *var)
1536 {
1537     ERR("Should not be called\n");
1538     return E_FAIL;
1539 }
1540
1541 static const IPropertyBagVtbl PB_Vtbl =
1542 {
1543     PB_QueryInterface,
1544     PB_AddRef,
1545     PB_Release,
1546     PB_Read,
1547     PB_Write
1548 };
1549
1550 static ULONG WINAPI info_device_ps_AddRef(IPropertyStore *iface)
1551 {
1552     return 2;
1553 }
1554
1555 static ULONG WINAPI info_device_ps_Release(IPropertyStore *iface)
1556 {
1557     return 1;
1558 }
1559
1560 static HRESULT WINAPI info_device_ps_GetValue(IPropertyStore *iface,
1561         REFPROPERTYKEY key, PROPVARIANT *pv)
1562 {
1563     TRACE("(static)->(\"%s,%u\", %p)\n", debugstr_guid(&key->fmtid), key ? key->pid : 0, pv);
1564
1565     if (!key || !pv)
1566         return E_POINTER;
1567
1568     if (IsEqualPropertyKey(*key, DEVPKEY_Device_Driver))
1569     {
1570         INT size = (lstrlenW(drvs.module_name) + 1) * sizeof(WCHAR);
1571         pv->vt = VT_LPWSTR;
1572         pv->u.pwszVal = CoTaskMemAlloc(size);
1573         if (!pv->u.pwszVal)
1574             return E_OUTOFMEMORY;
1575         memcpy(pv->u.pwszVal, drvs.module_name, size);
1576         return S_OK;
1577     }
1578
1579     return E_INVALIDARG;
1580 }
1581
1582 static const IPropertyStoreVtbl info_device_ps_Vtbl =
1583 {
1584     NULL,
1585     info_device_ps_AddRef,
1586     info_device_ps_Release,
1587     NULL,
1588     NULL,
1589     info_device_ps_GetValue,
1590     NULL,
1591     NULL
1592 };
1593
1594 static IPropertyStore info_device_ps = {
1595     &info_device_ps_Vtbl
1596 };
1597
1598 static ULONG WINAPI info_device_AddRef(IMMDevice *iface)
1599 {
1600     return 2;
1601 }
1602
1603 static ULONG WINAPI info_device_Release(IMMDevice *iface)
1604 {
1605     return 1;
1606 }
1607
1608 static HRESULT WINAPI info_device_OpenPropertyStore(IMMDevice *iface,
1609         DWORD access, IPropertyStore **ppv)
1610 {
1611     TRACE("(static)->(%x, %p)\n", access, ppv);
1612     *ppv = &info_device_ps;
1613     return S_OK;
1614 }
1615
1616 static const IMMDeviceVtbl info_device_Vtbl =
1617 {
1618     NULL,
1619     info_device_AddRef,
1620     info_device_Release,
1621     NULL,
1622     info_device_OpenPropertyStore,
1623     NULL,
1624     NULL
1625 };
1626
1627 static IMMDevice info_device = {
1628     &info_device_Vtbl
1629 };