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