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 #include "spatialaudioclient.h"
  39
  40 #include "mmdevapi_private.h"
  41 #include "devpkey.h"
  42
  43 WINE_DEFAULT_DEBUG_CHANNEL(mmdevapi);
  44
  45 static HKEY key_render;
  46 static HKEY key_capture;
  47
  48 typedef struct MMDevPropStoreImpl
  49 {
  50     IPropertyStore IPropertyStore_iface;
  51     LONG ref;
  52     MMDevice *parent;
  53     DWORD access;
  54 } MMDevPropStore;
  55
  56 typedef struct MMDevEnumImpl
  57 {
  58     IMMDeviceEnumerator IMMDeviceEnumerator_iface;
  59     LONG ref;
  60 } MMDevEnumImpl;
  61
  62 static MMDevice *MMDevice_def_rec, *MMDevice_def_play;
  63 static const IMMDeviceEnumeratorVtbl MMDevEnumVtbl;
  64 static const IMMDeviceCollectionVtbl MMDevColVtbl;
  65 static const IMMDeviceVtbl MMDeviceVtbl;
  66 static const IPropertyStoreVtbl MMDevPropVtbl;
  67 static const IMMEndpointVtbl MMEndpointVtbl;
  68
  69 static MMDevEnumImpl enumerator;
  70 static struct list device_list = LIST_INIT(device_list);
  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 %lu\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 %lu\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 %ld\n", debugstr_w(buffer), ret);
 152         RegCloseKey(regkey);
 153         pv->vt = VT_EMPTY;
 154         return S_OK;
 155     }
 156
 157     switch (type)
 158     {
 159         case REG_SZ:
 160         {
 161             pv->vt = VT_LPWSTR;
 162             pv->pwszVal = CoTaskMemAlloc(size);
 163             if (!pv->pwszVal)
 164                 hr = E_OUTOFMEMORY;
 165             else
 166                 RegGetValueW(regkey, NULL, buffer, RRF_RT_REG_SZ, NULL, (BYTE*)pv->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->ulVal, &size);
 173             break;
 174         }
 175         case REG_BINARY:
 176         {
 177             pv->vt = VT_BLOB;
 178             pv->blob.cbSize = size;
 179             pv->blob.pBlobData = CoTaskMemAlloc(size);
 180             if (!pv->blob.pBlobData)
 181                 hr = E_OUTOFMEMORY;
 182             else
 183                 RegGetValueW(regkey, NULL, buffer, RRF_RT_REG_BINARY, NULL, (BYTE*)pv->blob.pBlobData, &size);
 184             break;
 185         }
 186         default:
 187             ERR("Unknown/unhandled type: %lu\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->ulVal, sizeof(DWORD));
 214             break;
 215         }
 216         case VT_BLOB:
 217         {
 218             ret = RegSetValueExW(regkey, buffer, 0, REG_BINARY, pv->blob.pBlobData, pv->blob.cbSize);
 219             TRACE("Blob %p %lu\n", pv->blob.pBlobData, pv->blob.cbSize);
 220
 221             break;
 222         }
 223         case VT_LPWSTR:
 224         {
 225             ret = RegSetValueExW(regkey, buffer, 0, REG_SZ, (const BYTE*)pv->pwszVal, sizeof(WCHAR)*(1+lstrlenW(pv->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 %lu\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 struct product_name_overrides
 259 {
 260     const WCHAR *id;
 261     const WCHAR *product;
 262 };
 263
 264 static const struct product_name_overrides product_name_overrides[] =
 265 {
 266     /* Sony controllers */
 267     { .id = L"VID_054C&PID_0CE6", .product = L"Wireless Controller" },
 268 };
 269
 270 static const WCHAR *find_product_name_override(const WCHAR *device_id)
 271 {
 272     const WCHAR *match_id = wcschr( device_id, '\\' ) + 1;
 273     DWORD i;
 274
 275     for (i = 0; i < ARRAY_SIZE(product_name_overrides); ++i)
 276         if (!wcsnicmp( product_name_overrides[i].id, match_id, 17 ))
 277             return product_name_overrides[i].product;
 278
 279     return NULL;
 280 }
 281
 282 /* Creates or updates the state of a device
 283  * If GUID is null, a random guid will be assigned
 284  * and the device will be created
 285  */
 286 static MMDevice *MMDevice_Create(WCHAR *name, GUID *id, EDataFlow flow, DWORD state, BOOL setdefault)
 287 {
 288     HKEY key, root;
 289     MMDevice *device, *cur = NULL;
 290     WCHAR guidstr[39];
 291
 292     static const PROPERTYKEY deviceinterface_key = {
 293         {0x233164c8, 0x1b2c, 0x4c7d, {0xbc, 0x68, 0xb6, 0x71, 0x68, 0x7a, 0x25, 0x67}}, 1
 294     };
 295
 296     static const PROPERTYKEY devicepath_key = {
 297         {0xb3f8fa53, 0x0004, 0x438e, {0x90, 0x03, 0x51, 0xa4, 0x6e, 0x13, 0x9b, 0xfc}}, 2
 298     };
 299
 300     LIST_FOR_EACH_ENTRY(device, &device_list, MMDevice, entry)
 301     {
 302         if (device->flow == flow && IsEqualGUID(&device->devguid, id)){
 303             cur = device;
 304             break;
 305         }
 306     }
 307
 308     if(!cur){
 309         /* No device found, allocate new one */
 310         cur = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*cur));
 311         if (!cur)
 312             return NULL;
 313
 314         cur->IMMDevice_iface.lpVtbl = &MMDeviceVtbl;
 315         cur->IMMEndpoint_iface.lpVtbl = &MMEndpointVtbl;
 316
 317         InitializeCriticalSection(&cur->crst);
 318         cur->crst.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": MMDevice.crst");
 319
 320         list_add_tail(&device_list, &cur->entry);
 321     }else if(cur->ref > 0)
 322         WARN("Modifying an MMDevice with postitive reference count!\n");
 323
 324     HeapFree(GetProcessHeap(), 0, cur->drv_id);
 325     cur->drv_id = name;
 326
 327     cur->flow = flow;
 328     cur->state = state;
 329     cur->devguid = *id;
 330
 331     StringFromGUID2(&cur->devguid, guidstr, ARRAY_SIZE(guidstr));
 332
 333     if (flow == eRender)
 334         root = key_render;
 335     else
 336         root = key_capture;
 337
 338     if (RegCreateKeyExW(root, guidstr, 0, NULL, 0, KEY_WRITE|KEY_READ|KEY_WOW64_64KEY, NULL, &key, NULL) == ERROR_SUCCESS)
 339     {
 340         HKEY keyprop;
 341         RegSetValueExW(key, L"DeviceState", 0, REG_DWORD, (const BYTE*)&state, sizeof(DWORD));
 342         if (!RegCreateKeyExW(key, L"Properties", 0, NULL, 0, KEY_WRITE|KEY_READ|KEY_WOW64_64KEY, NULL, &keyprop, NULL))
 343         {
 344             PROPVARIANT pv;
 345
 346             pv.vt = VT_LPWSTR;
 347             pv.pwszVal = name;
 348
 349             if (SUCCEEDED(set_driver_prop_value(id, flow, &devicepath_key))) {
 350                 PROPVARIANT pv2;
 351
 352                 PropVariantInit(&pv2);
 353
 354                 if (SUCCEEDED(MMDevice_GetPropValue(id, flow, &devicepath_key, &pv2)) && pv2.vt == VT_LPWSTR) {
 355                     const WCHAR *override;
 356                     if ((override = find_product_name_override(pv2.pwszVal)) != NULL)
 357                         pv.pwszVal = (WCHAR*) override;
 358                 }
 359
 360                 PropVariantClear(&pv2);
 361             }
 362
 363             MMDevice_SetPropValue(id, flow, (const PROPERTYKEY*)&DEVPKEY_Device_FriendlyName, &pv);
 364             MMDevice_SetPropValue(id, flow, (const PROPERTYKEY*)&DEVPKEY_DeviceInterface_FriendlyName, &pv);
 365             MMDevice_SetPropValue(id, flow, (const PROPERTYKEY*)&DEVPKEY_Device_DeviceDesc, &pv);
 366
 367             pv.pwszVal = guidstr;
 368             MMDevice_SetPropValue(id, flow, &deviceinterface_key, &pv);
 369
 370             if (FAILED(set_driver_prop_value(id, flow, &PKEY_AudioEndpoint_FormFactor)))
 371             {
 372                 pv.vt = VT_UI4;
 373                 pv.ulVal = (flow == eCapture) ? Microphone : Speakers;
 374
 375                 MMDevice_SetPropValue(id, flow, &PKEY_AudioEndpoint_FormFactor, &pv);
 376             }
 377
 378             if (flow != eCapture)
 379             {
 380                 PROPVARIANT pv2;
 381
 382                 PropVariantInit(&pv2);
 383
 384                 /* make read-write by not overwriting if already set */
 385                 if (FAILED(MMDevice_GetPropValue(id, flow, &PKEY_AudioEndpoint_PhysicalSpeakers, &pv2)) || pv2.vt != VT_UI4)
 386                     set_driver_prop_value(id, flow, &PKEY_AudioEndpoint_PhysicalSpeakers);
 387
 388                 PropVariantClear(&pv2);
 389             }
 390
 391             RegCloseKey(keyprop);
 392         }
 393         RegCloseKey(key);
 394     }
 395
 396     if (setdefault)
 397     {
 398         if (flow == eRender)
 399             MMDevice_def_play = cur;
 400         else
 401             MMDevice_def_rec = cur;
 402     }
 403     return cur;
 404 }
 405
 406 HRESULT load_devices_from_reg(void)
 407 {
 408     DWORD i = 0;
 409     HKEY root, cur;
 410     LONG ret;
 411     DWORD curflow;
 412
 413     ret = RegCreateKeyExW(HKEY_LOCAL_MACHINE,
 414             L"Software\\Microsoft\\Windows\\CurrentVersion\\MMDevices\\Audio", 0, NULL, 0,
 415             KEY_WRITE|KEY_READ|KEY_WOW64_64KEY, NULL, &root, NULL);
 416     if (ret == ERROR_SUCCESS)
 417         ret = RegCreateKeyExW(root, L"Capture", 0, NULL, 0, KEY_READ|KEY_WRITE|KEY_WOW64_64KEY, NULL, &key_capture, NULL);
 418     if (ret == ERROR_SUCCESS)
 419         ret = RegCreateKeyExW(root, L"Render", 0, NULL, 0, KEY_READ|KEY_WRITE|KEY_WOW64_64KEY, NULL, &key_render, NULL);
 420     RegCloseKey(root);
 421     cur = key_capture;
 422     curflow = eCapture;
 423     if (ret != ERROR_SUCCESS)
 424     {
 425         RegCloseKey(key_capture);
 426         key_render = key_capture = NULL;
 427         WARN("Couldn't create key: %lu\n", ret);
 428         return E_FAIL;
 429     }
 430
 431     do {
 432         WCHAR guidvalue[39];
 433         GUID guid;
 434         DWORD len;
 435         PROPVARIANT pv = { VT_EMPTY };
 436
 437         len = ARRAY_SIZE(guidvalue);
 438         ret = RegEnumKeyExW(cur, i++, guidvalue, &len, NULL, NULL, NULL, NULL);
 439         if (ret == ERROR_NO_MORE_ITEMS)
 440         {
 441             if (cur == key_capture)
 442             {
 443                 cur = key_render;
 444                 curflow = eRender;
 445                 i = 0;
 446                 continue;
 447             }
 448             break;
 449         }
 450         if (ret != ERROR_SUCCESS)
 451             continue;
 452         if (SUCCEEDED(CLSIDFromString(guidvalue, &guid))
 453             && SUCCEEDED(MMDevice_GetPropValue(&guid, curflow, (const PROPERTYKEY*)&DEVPKEY_Device_FriendlyName, &pv))
 454             && pv.vt == VT_LPWSTR)
 455         {
 456             DWORD size_bytes = (lstrlenW(pv.pwszVal) + 1) * sizeof(WCHAR);
 457             WCHAR *name = HeapAlloc(GetProcessHeap(), 0, size_bytes);
 458             memcpy(name, pv.pwszVal, size_bytes);
 459             MMDevice_Create(name, &guid, curflow,
 460                     DEVICE_STATE_NOTPRESENT, FALSE);
 461             CoTaskMemFree(pv.pwszVal);
 462         }
 463     } while (1);
 464
 465     return S_OK;
 466 }
 467
 468 static HRESULT set_format(MMDevice *dev)
 469 {
 470     HRESULT hr;
 471     IAudioClient *client;
 472     WAVEFORMATEX *fmt;
 473     PROPVARIANT pv = { VT_EMPTY };
 474
 475     hr = drvs.pGetAudioEndpoint(&dev->devguid, &dev->IMMDevice_iface, &client);
 476     if(FAILED(hr))
 477         return hr;
 478
 479     hr = IAudioClient_GetMixFormat(client, &fmt);
 480     if(FAILED(hr)){
 481         IAudioClient_Release(client);
 482         return hr;
 483     }
 484
 485     IAudioClient_Release(client);
 486
 487     pv.vt = VT_BLOB;
 488     pv.blob.cbSize = sizeof(WAVEFORMATEX) + fmt->cbSize;
 489     pv.blob.pBlobData = (BYTE*)fmt;
 490     MMDevice_SetPropValue(&dev->devguid, dev->flow,
 491             &PKEY_AudioEngine_DeviceFormat, &pv);
 492     MMDevice_SetPropValue(&dev->devguid, dev->flow,
 493             &PKEY_AudioEngine_OEMFormat, &pv);
 494     CoTaskMemFree(fmt);
 495
 496     return S_OK;
 497 }
 498
 499 HRESULT load_driver_devices(EDataFlow flow)
 500 {
 501     WCHAR **ids;
 502     GUID *guids;
 503     UINT num, def, i;
 504     HRESULT hr;
 505
 506     if(!drvs.pGetEndpointIDs)
 507         return S_OK;
 508
 509     hr = drvs.pGetEndpointIDs(flow, &ids, &guids, &num, &def);
 510     if(FAILED(hr))
 511         return hr;
 512
 513     for(i = 0; i < num; ++i){
 514         MMDevice *dev;
 515         dev = MMDevice_Create(ids[i], &guids[i], flow, DEVICE_STATE_ACTIVE,
 516                 def == i);
 517         set_format(dev);
 518     }
 519
 520     HeapFree(GetProcessHeap(), 0, guids);
 521     HeapFree(GetProcessHeap(), 0, ids);
 522
 523     return S_OK;
 524 }
 525
 526 static void MMDevice_Destroy(MMDevice *This)
 527 {
 528     TRACE("Freeing %s\n", debugstr_w(This->drv_id));
 529     list_remove(&This->entry);
 530     This->crst.DebugInfo->Spare[0] = 0;
 531     DeleteCriticalSection(&This->crst);
 532     HeapFree(GetProcessHeap(), 0, This->drv_id);
 533     HeapFree(GetProcessHeap(), 0, This);
 534 }
 535
 536 static inline MMDevice *impl_from_IMMDevice(IMMDevice *iface)
 537 {
 538     return CONTAINING_RECORD(iface, MMDevice, IMMDevice_iface);
 539 }
 540
 541 static HRESULT WINAPI MMDevice_QueryInterface(IMMDevice *iface, REFIID riid, void **ppv)
 542 {
 543     MMDevice *This = impl_from_IMMDevice(iface);
 544     TRACE("(%p)->(%s,%p)\n", iface, debugstr_guid(riid), ppv);
 545
 546     if (!ppv)
 547         return E_POINTER;
 548     *ppv = NULL;
 549     if (IsEqualIID(riid, &IID_IUnknown)
 550         || IsEqualIID(riid, &IID_IMMDevice))
 551         *ppv = &This->IMMDevice_iface;
 552     else if (IsEqualIID(riid, &IID_IMMEndpoint))
 553         *ppv = &This->IMMEndpoint_iface;
 554     if (*ppv)
 555     {
 556         IUnknown_AddRef((IUnknown*)*ppv);
 557         return S_OK;
 558     }
 559     WARN("Unknown interface %s\n", debugstr_guid(riid));
 560     return E_NOINTERFACE;
 561 }
 562
 563 static ULONG WINAPI MMDevice_AddRef(IMMDevice *iface)
 564 {
 565     MMDevice *This = impl_from_IMMDevice(iface);
 566     LONG ref;
 567
 568     ref = InterlockedIncrement(&This->ref);
 569     TRACE("Refcount now %li\n", ref);
 570     return ref;
 571 }
 572
 573 static ULONG WINAPI MMDevice_Release(IMMDevice *iface)
 574 {
 575     MMDevice *This = impl_from_IMMDevice(iface);
 576     LONG ref;
 577
 578     ref = InterlockedDecrement(&This->ref);
 579     TRACE("Refcount now %li\n", ref);
 580     return ref;
 581 }
 582
 583 static HRESULT WINAPI MMDevice_Activate(IMMDevice *iface, REFIID riid, DWORD clsctx, PROPVARIANT *params, void **ppv)
 584 {
 585     HRESULT hr = E_NOINTERFACE;
 586     MMDevice *This = impl_from_IMMDevice(iface);
 587
 588     TRACE("(%p)->(%s, %lx, %p, %p)\n", iface, debugstr_guid(riid), clsctx, params, ppv);
 589
 590     if (!ppv)
 591         return E_POINTER;
 592
 593     if (IsEqualIID(riid, &IID_IAudioClient) ||
 594             IsEqualIID(riid, &IID_IAudioClient2) ||
 595             IsEqualIID(riid, &IID_IAudioClient3)){
 596         hr = drvs.pGetAudioEndpoint(&This->devguid, iface, (IAudioClient**)ppv);
 597     }else if (IsEqualIID(riid, &IID_IAudioEndpointVolume) ||
 598             IsEqualIID(riid, &IID_IAudioEndpointVolumeEx))
 599         hr = AudioEndpointVolume_Create(This, (IAudioEndpointVolumeEx**)ppv);
 600     else if (IsEqualIID(riid, &IID_IAudioSessionManager)
 601              || IsEqualIID(riid, &IID_IAudioSessionManager2))
 602     {
 603         hr = AudioSessionManager_Create(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 if (IsEqualIID(riid, &IID_ISpatialAudioClient))
 661     {
 662         hr = SpatialAudioClient_Create(iface, (ISpatialAudioClient**)ppv);
 663     }
 664     else
 665         ERR("Invalid/unknown iid %s\n", debugstr_guid(riid));
 666
 667     if (FAILED(hr))
 668         *ppv = NULL;
 669
 670     TRACE("Returning %08lx\n", hr);
 671     return hr;
 672 }
 673
 674 static HRESULT WINAPI MMDevice_OpenPropertyStore(IMMDevice *iface, DWORD access, IPropertyStore **ppv)
 675 {
 676     MMDevice *This = impl_from_IMMDevice(iface);
 677     TRACE("(%p)->(%lx,%p)\n", This, access, ppv);
 678
 679     if (!ppv)
 680         return E_POINTER;
 681     return MMDevPropStore_Create(This, access, ppv);
 682 }
 683
 684 static HRESULT WINAPI MMDevice_GetId(IMMDevice *iface, WCHAR **itemid)
 685 {
 686     MMDevice *This = impl_from_IMMDevice(iface);
 687     WCHAR *str;
 688     GUID *id = &This->devguid;
 689
 690     TRACE("(%p)->(%p)\n", This, itemid);
 691     if (!itemid)
 692         return E_POINTER;
 693     *itemid = str = CoTaskMemAlloc(56 * sizeof(WCHAR));
 694     if (!str)
 695         return E_OUTOFMEMORY;
 696     wsprintfW(str, L"{0.0.%u.00000000}.{%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}",
 697               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->IMMDeviceCollection_iface;
 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 %li\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 %li\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     MMDevice *cur;
 831
 832     TRACE("(%p)->(%p)\n", This, numdevs);
 833     if (!numdevs)
 834         return E_POINTER;
 835
 836     *numdevs = 0;
 837     LIST_FOR_EACH_ENTRY(cur, &device_list, MMDevice, entry)
 838     {
 839         if ((cur->flow == This->flow || This->flow == eAll)
 840             && (cur->state & This->state))
 841             ++(*numdevs);
 842     }
 843     return S_OK;
 844 }
 845
 846 static HRESULT WINAPI MMDevCol_Item(IMMDeviceCollection *iface, UINT n, IMMDevice **dev)
 847 {
 848     MMDevColImpl *This = impl_from_IMMDeviceCollection(iface);
 849     MMDevice *cur;
 850     DWORD i = 0;
 851
 852     TRACE("(%p)->(%u, %p)\n", This, n, dev);
 853     if (!dev)
 854         return E_POINTER;
 855
 856     LIST_FOR_EACH_ENTRY(cur, &device_list, MMDevice, entry)
 857     {
 858         if ((cur->flow == This->flow || This->flow == eAll)
 859             && (cur->state & This->state)
 860             && i++ == n)
 861         {
 862             *dev = &cur->IMMDevice_iface;
 863             IMMDevice_AddRef(*dev);
 864             return S_OK;
 865         }
 866     }
 867     WARN("Could not obtain item %u\n", n);
 868     *dev = NULL;
 869     return E_INVALIDARG;
 870 }
 871
 872 static const IMMDeviceCollectionVtbl MMDevColVtbl =
 873 {
 874     MMDevCol_QueryInterface,
 875     MMDevCol_AddRef,
 876     MMDevCol_Release,
 877     MMDevCol_GetCount,
 878     MMDevCol_Item
 879 };
 880
 881 HRESULT MMDevEnum_Create(REFIID riid, void **ppv)
 882 {
 883     return IMMDeviceEnumerator_QueryInterface(&enumerator.IMMDeviceEnumerator_iface, riid, ppv);
 884 }
 885
 886 void MMDevEnum_Free(void)
 887 {
 888     MMDevice *device, *next;
 889     LIST_FOR_EACH_ENTRY_SAFE(device, next, &device_list, MMDevice, entry)
 890         MMDevice_Destroy(device);
 891     RegCloseKey(key_render);
 892     RegCloseKey(key_capture);
 893     key_render = key_capture = NULL;
 894 }
 895
 896 static HRESULT WINAPI MMDevEnum_QueryInterface(IMMDeviceEnumerator *iface, REFIID riid, void **ppv)
 897 {
 898     MMDevEnumImpl *This = impl_from_IMMDeviceEnumerator(iface);
 899     TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), ppv);
 900
 901     if (!ppv)
 902         return E_POINTER;
 903     if (IsEqualIID(riid, &IID_IUnknown)
 904         || IsEqualIID(riid, &IID_IMMDeviceEnumerator))
 905         *ppv = &This->IMMDeviceEnumerator_iface;
 906     else
 907         *ppv = NULL;
 908     if (!*ppv)
 909         return E_NOINTERFACE;
 910     IUnknown_AddRef((IUnknown*)*ppv);
 911     return S_OK;
 912 }
 913
 914 static ULONG WINAPI MMDevEnum_AddRef(IMMDeviceEnumerator *iface)
 915 {
 916     MMDevEnumImpl *This = impl_from_IMMDeviceEnumerator(iface);
 917     LONG ref = InterlockedIncrement(&This->ref);
 918     TRACE("Refcount now %li\n", ref);
 919     return ref;
 920 }
 921
 922 static ULONG WINAPI MMDevEnum_Release(IMMDeviceEnumerator *iface)
 923 {
 924     MMDevEnumImpl *This = impl_from_IMMDeviceEnumerator(iface);
 925     LONG ref = InterlockedDecrement(&This->ref);
 926     TRACE("Refcount now %li\n", ref);
 927     return ref;
 928 }
 929
 930 static HRESULT WINAPI MMDevEnum_EnumAudioEndpoints(IMMDeviceEnumerator *iface, EDataFlow flow, DWORD mask, IMMDeviceCollection **devices)
 931 {
 932     MMDevEnumImpl *This = impl_from_IMMDeviceEnumerator(iface);
 933     TRACE("(%p)->(%u,%lu,%p)\n", This, flow, mask, devices);
 934     if (!devices)
 935         return E_POINTER;
 936     *devices = NULL;
 937     if (flow >= EDataFlow_enum_count)
 938         return E_INVALIDARG;
 939     if (mask & ~DEVICE_STATEMASK_ALL)
 940         return E_INVALIDARG;
 941     return MMDevCol_Create(devices, flow, mask);
 942 }
 943
 944 static HRESULT WINAPI MMDevEnum_GetDefaultAudioEndpoint(IMMDeviceEnumerator *iface, EDataFlow flow, ERole role, IMMDevice **device)
 945 {
 946     MMDevEnumImpl *This = impl_from_IMMDeviceEnumerator(iface);
 947     WCHAR reg_key[256];
 948     HKEY key;
 949     HRESULT hr;
 950
 951     TRACE("(%p)->(%u,%u,%p)\n", This, flow, role, device);
 952
 953     if (!device)
 954         return E_POINTER;
 955
 956     if((flow != eRender && flow != eCapture) ||
 957             (role != eConsole && role != eMultimedia && role != eCommunications)){
 958         WARN("Unknown flow (%u) or role (%u)\n", flow, role);
 959         return E_INVALIDARG;
 960     }
 961
 962     *device = NULL;
 963
 964     if(!drvs.module_name[0])
 965         return E_NOTFOUND;
 966
 967     lstrcpyW(reg_key, drv_keyW);
 968     lstrcatW(reg_key, L"\\");
 969     lstrcatW(reg_key, drvs.module_name);
 970
 971     if(RegOpenKeyW(HKEY_CURRENT_USER, reg_key, &key) == ERROR_SUCCESS){
 972         const WCHAR *reg_x_name, *reg_vx_name;
 973         WCHAR def_id[256];
 974         DWORD size = sizeof(def_id), state;
 975
 976         if(flow == eRender){
 977             reg_x_name = L"DefaultOutput";
 978             reg_vx_name = L"DefaultVoiceOutput";
 979         }else{
 980             reg_x_name = L"DefaultInput";
 981             reg_vx_name = L"DefaultVoiceInput";
 982         }
 983
 984         if(role == eCommunications &&
 985                 RegQueryValueExW(key, reg_vx_name, 0, NULL,
 986                     (BYTE*)def_id, &size) == ERROR_SUCCESS){
 987             hr = IMMDeviceEnumerator_GetDevice(iface, def_id, device);
 988             if(SUCCEEDED(hr)){
 989                 if(SUCCEEDED(IMMDevice_GetState(*device, &state)) &&
 990                         state == DEVICE_STATE_ACTIVE){
 991                     RegCloseKey(key);
 992                     return S_OK;
 993                 }
 994             }
 995
 996             TRACE("Unable to find voice device %s\n", wine_dbgstr_w(def_id));
 997         }
 998
 999         if(RegQueryValueExW(key, reg_x_name, 0, NULL,
1000                     (BYTE*)def_id, &size) == ERROR_SUCCESS){
1001             hr = IMMDeviceEnumerator_GetDevice(iface, def_id, device);
1002             if(SUCCEEDED(hr)){
1003                 if(SUCCEEDED(IMMDevice_GetState(*device, &state)) &&
1004                         state == DEVICE_STATE_ACTIVE){
1005                     RegCloseKey(key);
1006                     return S_OK;
1007                 }
1008             }
1009
1010             TRACE("Unable to find device %s\n", wine_dbgstr_w(def_id));
1011         }
1012
1013         RegCloseKey(key);
1014     }
1015
1016     if (flow == eRender)
1017         *device = &MMDevice_def_play->IMMDevice_iface;
1018     else
1019         *device = &MMDevice_def_rec->IMMDevice_iface;
1020
1021     if (!*device)
1022         return E_NOTFOUND;
1023     IMMDevice_AddRef(*device);
1024     return S_OK;
1025 }
1026
1027 static HRESULT WINAPI MMDevEnum_GetDevice(IMMDeviceEnumerator *iface, const WCHAR *name, IMMDevice **device)
1028 {
1029     MMDevEnumImpl *This = impl_from_IMMDeviceEnumerator(iface);
1030     MMDevice *impl;
1031     IMMDevice *dev = NULL;
1032
1033     TRACE("(%p)->(%s,%p)\n", This, debugstr_w(name), device);
1034
1035     if(!name || !device)
1036         return E_POINTER;
1037
1038     if(!lstrcmpW(name, L"Wine info device")){
1039         *device = &info_device;
1040         return S_OK;
1041     }
1042
1043     LIST_FOR_EACH_ENTRY(impl, &device_list, MMDevice, entry)
1044     {
1045         HRESULT hr;
1046         WCHAR *str;
1047         dev = &impl->IMMDevice_iface;
1048         hr = IMMDevice_GetId(dev, &str);
1049         if (FAILED(hr))
1050         {
1051             WARN("GetId failed: %08lx\n", hr);
1052             continue;
1053         }
1054
1055         if (str && !lstrcmpW(str, name))
1056         {
1057             CoTaskMemFree(str);
1058             IMMDevice_AddRef(dev);
1059             *device = dev;
1060             return S_OK;
1061         }
1062         CoTaskMemFree(str);
1063     }
1064     TRACE("Could not find device %s\n", debugstr_w(name));
1065     return E_INVALIDARG;
1066 }
1067
1068 struct NotificationClientWrapper {
1069     IMMNotificationClient *client;
1070     struct list entry;
1071 };
1072
1073 static struct list g_notif_clients = LIST_INIT(g_notif_clients);
1074 static HANDLE g_notif_thread;
1075
1076 static CRITICAL_SECTION g_notif_lock;
1077 static CRITICAL_SECTION_DEBUG g_notif_lock_debug =
1078 {
1079     0, 0, &g_notif_lock,
1080     { &g_notif_lock_debug.ProcessLocksList, &g_notif_lock_debug.ProcessLocksList },
1081       0, 0, { (DWORD_PTR)(__FILE__ ": g_notif_lock") }
1082 };
1083 static CRITICAL_SECTION g_notif_lock = { &g_notif_lock_debug, -1, 0, 0, 0, 0 };
1084
1085 static void notify_clients(EDataFlow flow, ERole role, const WCHAR *id)
1086 {
1087     struct NotificationClientWrapper *wrapper;
1088     LIST_FOR_EACH_ENTRY(wrapper, &g_notif_clients,
1089             struct NotificationClientWrapper, entry)
1090         IMMNotificationClient_OnDefaultDeviceChanged(wrapper->client, flow,
1091                 role, id);
1092
1093     /* Windows 7 treats changes to eConsole as changes to eMultimedia */
1094     if(role == eConsole)
1095         notify_clients(flow, eMultimedia, id);
1096 }
1097
1098 static BOOL notify_if_changed(EDataFlow flow, ERole role, HKEY key,
1099                               const WCHAR *val_name, WCHAR *old_val, IMMDevice *def_dev)
1100 {
1101     WCHAR new_val[64], *id;
1102     DWORD size;
1103     HRESULT hr;
1104
1105     size = sizeof(new_val);
1106     if(RegQueryValueExW(key, val_name, 0, NULL,
1107                 (BYTE*)new_val, &size) != ERROR_SUCCESS){
1108         if(old_val[0] != 0){
1109             /* set by user -> system default */
1110             if(def_dev){
1111                 hr = IMMDevice_GetId(def_dev, &id);
1112                 if(FAILED(hr)){
1113                     ERR("GetId failed: %08lx\n", hr);
1114                     return FALSE;
1115                 }
1116             }else
1117                 id = NULL;
1118
1119             notify_clients(flow, role, id);
1120             old_val[0] = 0;
1121             CoTaskMemFree(id);
1122
1123             return TRUE;
1124         }
1125
1126         /* system default -> system default, noop */
1127         return FALSE;
1128     }
1129
1130     if(!lstrcmpW(old_val, new_val)){
1131         /* set by user -> same value */
1132         return FALSE;
1133     }
1134
1135     if(new_val[0] != 0){
1136         /* set by user -> different value */
1137         notify_clients(flow, role, new_val);
1138         memcpy(old_val, new_val, sizeof(new_val));
1139         return TRUE;
1140     }
1141
1142     /* set by user -> system default */
1143     if(def_dev){
1144         hr = IMMDevice_GetId(def_dev, &id);
1145         if(FAILED(hr)){
1146             ERR("GetId failed: %08lx\n", hr);
1147             return FALSE;
1148         }
1149     }else
1150         id = NULL;
1151
1152     notify_clients(flow, role, id);
1153     old_val[0] = 0;
1154     CoTaskMemFree(id);
1155
1156     return TRUE;
1157 }
1158
1159 static DWORD WINAPI notif_thread_proc(void *user)
1160 {
1161     HKEY key;
1162     WCHAR reg_key[256];
1163     WCHAR out_name[64], vout_name[64], in_name[64], vin_name[64];
1164     DWORD size;
1165
1166     SetThreadDescription(GetCurrentThread(), L"wine_mmdevapi_notification");
1167
1168     lstrcpyW(reg_key, drv_keyW);
1169     lstrcatW(reg_key, L"\\");
1170     lstrcatW(reg_key, drvs.module_name);
1171
1172     if(RegCreateKeyExW(HKEY_CURRENT_USER, reg_key, 0, NULL, 0,
1173                 MAXIMUM_ALLOWED, NULL, &key, NULL) != ERROR_SUCCESS){
1174         ERR("RegCreateKeyEx failed: %lu\n", GetLastError());
1175         return 1;
1176     }
1177
1178     size = sizeof(out_name);
1179     if(RegQueryValueExW(key, L"DefaultOutput", 0, NULL, (BYTE*)out_name, &size) != ERROR_SUCCESS)
1180         out_name[0] = 0;
1181
1182     size = sizeof(vout_name);
1183     if(RegQueryValueExW(key, L"DefaultVoiceOutput", 0, NULL, (BYTE*)vout_name, &size) != ERROR_SUCCESS)
1184         vout_name[0] = 0;
1185
1186     size = sizeof(in_name);
1187     if(RegQueryValueExW(key, L"DefaultInput", 0, NULL, (BYTE*)in_name, &size) != ERROR_SUCCESS)
1188         in_name[0] = 0;
1189
1190     size = sizeof(vin_name);
1191     if(RegQueryValueExW(key, L"DefaultVoiceInput", 0, NULL, (BYTE*)vin_name, &size) != ERROR_SUCCESS)
1192         vin_name[0] = 0;
1193
1194     while(1){
1195         if(RegNotifyChangeKeyValue(key, FALSE, REG_NOTIFY_CHANGE_LAST_SET,
1196                     NULL, FALSE) != ERROR_SUCCESS){
1197             ERR("RegNotifyChangeKeyValue failed: %lu\n", GetLastError());
1198             RegCloseKey(key);
1199             g_notif_thread = NULL;
1200             return 1;
1201         }
1202
1203         EnterCriticalSection(&g_notif_lock);
1204
1205         notify_if_changed(eRender, eConsole, key, L"DefaultOutput",
1206                 out_name, &MMDevice_def_play->IMMDevice_iface);
1207         notify_if_changed(eRender, eCommunications, key, L"DefaultVoiceOutput",
1208                 vout_name, &MMDevice_def_play->IMMDevice_iface);
1209         notify_if_changed(eCapture, eConsole, key, L"DefaultInput",
1210                 in_name, &MMDevice_def_rec->IMMDevice_iface);
1211         notify_if_changed(eCapture, eCommunications, key, L"DefaultVoiceInput",
1212                 vin_name, &MMDevice_def_rec->IMMDevice_iface);
1213
1214         LeaveCriticalSection(&g_notif_lock);
1215     }
1216
1217     RegCloseKey(key);
1218
1219     g_notif_thread = NULL;
1220
1221     return 0;
1222 }
1223
1224 static HRESULT WINAPI MMDevEnum_RegisterEndpointNotificationCallback(IMMDeviceEnumerator *iface, IMMNotificationClient *client)
1225 {
1226     MMDevEnumImpl *This = impl_from_IMMDeviceEnumerator(iface);
1227     struct NotificationClientWrapper *wrapper;
1228
1229     TRACE("(%p)->(%p)\n", This, client);
1230
1231     if(!client)
1232         return E_POINTER;
1233
1234     wrapper = HeapAlloc(GetProcessHeap(), 0, sizeof(*wrapper));
1235     if(!wrapper)
1236         return E_OUTOFMEMORY;
1237
1238     wrapper->client = client;
1239
1240     EnterCriticalSection(&g_notif_lock);
1241
1242     list_add_tail(&g_notif_clients, &wrapper->entry);
1243
1244     if(!g_notif_thread){
1245         g_notif_thread = CreateThread(NULL, 0, notif_thread_proc, NULL, 0, NULL);
1246         if(!g_notif_thread)
1247             ERR("CreateThread failed: %lu\n", GetLastError());
1248     }
1249
1250     LeaveCriticalSection(&g_notif_lock);
1251
1252     return S_OK;
1253 }
1254
1255 static HRESULT WINAPI MMDevEnum_UnregisterEndpointNotificationCallback(IMMDeviceEnumerator *iface, IMMNotificationClient *client)
1256 {
1257     MMDevEnumImpl *This = impl_from_IMMDeviceEnumerator(iface);
1258     struct NotificationClientWrapper *wrapper;
1259
1260     TRACE("(%p)->(%p)\n", This, client);
1261
1262     if(!client)
1263         return E_POINTER;
1264
1265     EnterCriticalSection(&g_notif_lock);
1266
1267     LIST_FOR_EACH_ENTRY(wrapper, &g_notif_clients, struct NotificationClientWrapper, entry){
1268         if(wrapper->client == client){
1269             list_remove(&wrapper->entry);
1270             HeapFree(GetProcessHeap(), 0, wrapper);
1271             LeaveCriticalSection(&g_notif_lock);
1272             return S_OK;
1273         }
1274     }
1275
1276     LeaveCriticalSection(&g_notif_lock);
1277
1278     return E_NOTFOUND;
1279 }
1280
1281 static const IMMDeviceEnumeratorVtbl MMDevEnumVtbl =
1282 {
1283     MMDevEnum_QueryInterface,
1284     MMDevEnum_AddRef,
1285     MMDevEnum_Release,
1286     MMDevEnum_EnumAudioEndpoints,
1287     MMDevEnum_GetDefaultAudioEndpoint,
1288     MMDevEnum_GetDevice,
1289     MMDevEnum_RegisterEndpointNotificationCallback,
1290     MMDevEnum_UnregisterEndpointNotificationCallback
1291 };
1292
1293 static MMDevEnumImpl enumerator =
1294 {
1295     {&MMDevEnumVtbl},
1296     1,
1297 };
1298
1299 static HRESULT MMDevPropStore_Create(MMDevice *parent, DWORD access, IPropertyStore **ppv)
1300 {
1301     MMDevPropStore *This;
1302     if (access != STGM_READ
1303         && access != STGM_WRITE
1304         && access != STGM_READWRITE)
1305     {
1306         WARN("Invalid access %08lx\n", access);
1307         return E_INVALIDARG;
1308     }
1309     This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
1310     *ppv = &This->IPropertyStore_iface;
1311     if (!This)
1312         return E_OUTOFMEMORY;
1313     This->IPropertyStore_iface.lpVtbl = &MMDevPropVtbl;
1314     This->ref = 1;
1315     This->parent = parent;
1316     This->access = access;
1317     return S_OK;
1318 }
1319
1320 static void MMDevPropStore_Destroy(MMDevPropStore *This)
1321 {
1322     HeapFree(GetProcessHeap(), 0, This);
1323 }
1324
1325 static HRESULT WINAPI MMDevPropStore_QueryInterface(IPropertyStore *iface, REFIID riid, void **ppv)
1326 {
1327     MMDevPropStore *This = impl_from_IPropertyStore(iface);
1328     TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), ppv);
1329
1330     if (!ppv)
1331         return E_POINTER;
1332     if (IsEqualIID(riid, &IID_IUnknown)
1333         || IsEqualIID(riid, &IID_IPropertyStore))
1334         *ppv = &This->IPropertyStore_iface;
1335     else
1336         *ppv = NULL;
1337     if (!*ppv)
1338         return E_NOINTERFACE;
1339     IUnknown_AddRef((IUnknown*)*ppv);
1340     return S_OK;
1341 }
1342
1343 static ULONG WINAPI MMDevPropStore_AddRef(IPropertyStore *iface)
1344 {
1345     MMDevPropStore *This = impl_from_IPropertyStore(iface);
1346     LONG ref = InterlockedIncrement(&This->ref);
1347     TRACE("Refcount now %li\n", ref);
1348     return ref;
1349 }
1350
1351 static ULONG WINAPI MMDevPropStore_Release(IPropertyStore *iface)
1352 {
1353     MMDevPropStore *This = impl_from_IPropertyStore(iface);
1354     LONG ref = InterlockedDecrement(&This->ref);
1355     TRACE("Refcount now %li\n", ref);
1356     if (!ref)
1357         MMDevPropStore_Destroy(This);
1358     return ref;
1359 }
1360
1361 static HRESULT WINAPI MMDevPropStore_GetCount(IPropertyStore *iface, DWORD *nprops)
1362 {
1363     MMDevPropStore *This = impl_from_IPropertyStore(iface);
1364     WCHAR buffer[50];
1365     DWORD i = 0;
1366     HKEY propkey;
1367     HRESULT hr;
1368
1369     TRACE("(%p)->(%p)\n", iface, nprops);
1370     if (!nprops)
1371         return E_POINTER;
1372     hr = MMDevPropStore_OpenPropKey(&This->parent->devguid, This->parent->flow, &propkey);
1373     if (FAILED(hr))
1374         return hr;
1375     *nprops = 0;
1376     do {
1377         DWORD len = ARRAY_SIZE(buffer);
1378         if (RegEnumValueW(propkey, i, buffer, &len, NULL, NULL, NULL, NULL) != ERROR_SUCCESS)
1379             break;
1380         i++;
1381     } while (1);
1382     RegCloseKey(propkey);
1383     TRACE("Returning %li\n", i);
1384     *nprops = i;
1385     return S_OK;
1386 }
1387
1388 static HRESULT WINAPI MMDevPropStore_GetAt(IPropertyStore *iface, DWORD prop, PROPERTYKEY *key)
1389 {
1390     MMDevPropStore *This = impl_from_IPropertyStore(iface);
1391     WCHAR buffer[50];
1392     DWORD len = ARRAY_SIZE(buffer);
1393     HRESULT hr;
1394     HKEY propkey;
1395
1396     TRACE("(%p)->(%lu,%p)\n", iface, prop, key);
1397     if (!key)
1398         return E_POINTER;
1399
1400     hr = MMDevPropStore_OpenPropKey(&This->parent->devguid, This->parent->flow, &propkey);
1401     if (FAILED(hr))
1402         return hr;
1403
1404     if (RegEnumValueW(propkey, prop, buffer, &len, NULL, NULL, NULL, NULL) != ERROR_SUCCESS
1405         || len <= 39)
1406     {
1407         WARN("GetAt %lu failed\n", prop);
1408         return E_INVALIDARG;
1409     }
1410     RegCloseKey(propkey);
1411     buffer[38] = 0;
1412     CLSIDFromString(buffer, &key->fmtid);
1413     key->pid = wcstol(&buffer[39], NULL, 10);
1414     return S_OK;
1415 }
1416
1417 static HRESULT WINAPI MMDevPropStore_GetValue(IPropertyStore *iface, REFPROPERTYKEY key, PROPVARIANT *pv)
1418 {
1419     MMDevPropStore *This = impl_from_IPropertyStore(iface);
1420     HRESULT hres;
1421     TRACE("(%p)->(\"%s,%lu\", %p)\n", This, key ? debugstr_guid(&key->fmtid) : NULL, key ? key->pid : 0, pv);
1422
1423     if (!key || !pv)
1424         return E_POINTER;
1425     if (This->access != STGM_READ
1426         && This->access != STGM_READWRITE)
1427         return STG_E_ACCESSDENIED;
1428
1429     /* Special case */
1430     if (IsEqualPropertyKey(*key, PKEY_AudioEndpoint_GUID))
1431     {
1432         pv->vt = VT_LPWSTR;
1433         pv->pwszVal = CoTaskMemAlloc(39 * sizeof(WCHAR));
1434         if (!pv->pwszVal)
1435             return E_OUTOFMEMORY;
1436         StringFromGUID2(&This->parent->devguid, pv->pwszVal, 39);
1437         return S_OK;
1438     }
1439
1440     hres = MMDevice_GetPropValue(&This->parent->devguid, This->parent->flow, key, pv);
1441     if (FAILED(hres))
1442         return hres;
1443
1444     if (WARN_ON(mmdevapi))
1445     {
1446         if ((IsEqualPropertyKey(*key, DEVPKEY_Device_FriendlyName) ||
1447              IsEqualPropertyKey(*key, DEVPKEY_DeviceInterface_FriendlyName) ||
1448              IsEqualPropertyKey(*key, DEVPKEY_Device_DeviceDesc)) &&
1449             pv->vt == VT_LPWSTR && wcslen(pv->pwszVal) > 62)
1450             WARN("Returned name exceeds length limit of some broken apps/libs, might crash: %s\n", debugstr_w(pv->pwszVal));
1451     }
1452     return hres;
1453 }
1454
1455 static HRESULT WINAPI MMDevPropStore_SetValue(IPropertyStore *iface, REFPROPERTYKEY key, REFPROPVARIANT pv)
1456 {
1457     MMDevPropStore *This = impl_from_IPropertyStore(iface);
1458     TRACE("(%p)->(\"%s,%lu\", %p)\n", This, key ? debugstr_guid(&key->fmtid) : NULL, key ? key->pid : 0, pv);
1459
1460     if (!key || !pv)
1461         return E_POINTER;
1462
1463     if (This->access != STGM_WRITE
1464         && This->access != STGM_READWRITE)
1465         return STG_E_ACCESSDENIED;
1466     return MMDevice_SetPropValue(&This->parent->devguid, This->parent->flow, key, pv);
1467 }
1468
1469 static HRESULT WINAPI MMDevPropStore_Commit(IPropertyStore *iface)
1470 {
1471     MMDevPropStore *This = impl_from_IPropertyStore(iface);
1472     TRACE("(%p)\n", iface);
1473
1474     if (This->access != STGM_WRITE
1475         && This->access != STGM_READWRITE)
1476         return STG_E_ACCESSDENIED;
1477
1478     /* Does nothing - for mmdevapi, the propstore values are written on SetValue,
1479      * not on Commit. */
1480
1481     return S_OK;
1482 }
1483
1484 static const IPropertyStoreVtbl MMDevPropVtbl =
1485 {
1486     MMDevPropStore_QueryInterface,
1487     MMDevPropStore_AddRef,
1488     MMDevPropStore_Release,
1489     MMDevPropStore_GetCount,
1490     MMDevPropStore_GetAt,
1491     MMDevPropStore_GetValue,
1492     MMDevPropStore_SetValue,
1493     MMDevPropStore_Commit
1494 };
1495
1496
1497 /* Property bag for IBaseFilter activation */
1498 static HRESULT WINAPI PB_QueryInterface(IPropertyBag *iface, REFIID riid, void **ppv)
1499 {
1500     ERR("Should not be called\n");
1501     *ppv = NULL;
1502     return E_NOINTERFACE;
1503 }
1504
1505 static ULONG WINAPI PB_AddRef(IPropertyBag *iface)
1506 {
1507     ERR("Should not be called\n");
1508     return 2;
1509 }
1510
1511 static ULONG WINAPI PB_Release(IPropertyBag *iface)
1512 {
1513     ERR("Should not be called\n");
1514     return 1;
1515 }
1516
1517 static HRESULT WINAPI PB_Read(IPropertyBag *iface, LPCOLESTR name, VARIANT *var, IErrorLog *log)
1518 {
1519     IPropertyBagImpl *This = impl_from_IPropertyBag(iface);
1520     TRACE("Trying to read %s, type %u\n", debugstr_w(name), var->n1.n2.vt);
1521     if (!lstrcmpW(name, L"DSGuid"))
1522     {
1523         WCHAR guidstr[39];
1524         StringFromGUID2(&This->devguid, guidstr,ARRAY_SIZE(guidstr));
1525         var->n1.n2.vt = VT_BSTR;
1526         var->n1.n2.n3.bstrVal = SysAllocString(guidstr);
1527         return S_OK;
1528     }
1529     ERR("Unknown property '%s' queried\n", debugstr_w(name));
1530     return E_FAIL;
1531 }
1532
1533 static HRESULT WINAPI PB_Write(IPropertyBag *iface, LPCOLESTR name, VARIANT *var)
1534 {
1535     ERR("Should not be called\n");
1536     return E_FAIL;
1537 }
1538
1539 static const IPropertyBagVtbl PB_Vtbl =
1540 {
1541     PB_QueryInterface,
1542     PB_AddRef,
1543     PB_Release,
1544     PB_Read,
1545     PB_Write
1546 };
1547
1548 static ULONG WINAPI info_device_ps_AddRef(IPropertyStore *iface)
1549 {
1550     return 2;
1551 }
1552
1553 static ULONG WINAPI info_device_ps_Release(IPropertyStore *iface)
1554 {
1555     return 1;
1556 }
1557
1558 static HRESULT WINAPI info_device_ps_GetValue(IPropertyStore *iface,
1559         REFPROPERTYKEY key, PROPVARIANT *pv)
1560 {
1561     TRACE("(static)->(\"%s,%lu\", %p)\n", debugstr_guid(&key->fmtid), key ? key->pid : 0, pv);
1562
1563     if (!key || !pv)
1564         return E_POINTER;
1565
1566     if (IsEqualPropertyKey(*key, DEVPKEY_Device_Driver))
1567     {
1568         INT size = (lstrlenW(drvs.module_name) + 1) * sizeof(WCHAR);
1569         pv->vt = VT_LPWSTR;
1570         pv->pwszVal = CoTaskMemAlloc(size);
1571         if (!pv->pwszVal)
1572             return E_OUTOFMEMORY;
1573         memcpy(pv->pwszVal, drvs.module_name, size);
1574         return S_OK;
1575     }
1576
1577     return E_INVALIDARG;
1578 }
1579
1580 static const IPropertyStoreVtbl info_device_ps_Vtbl =
1581 {
1582     NULL,
1583     info_device_ps_AddRef,
1584     info_device_ps_Release,
1585     NULL,
1586     NULL,
1587     info_device_ps_GetValue,
1588     NULL,
1589     NULL
1590 };
1591
1592 static IPropertyStore info_device_ps = {
1593     &info_device_ps_Vtbl
1594 };
1595
1596 static ULONG WINAPI info_device_AddRef(IMMDevice *iface)
1597 {
1598     return 2;
1599 }
1600
1601 static ULONG WINAPI info_device_Release(IMMDevice *iface)
1602 {
1603     return 1;
1604 }
1605
1606 static HRESULT WINAPI info_device_OpenPropertyStore(IMMDevice *iface,
1607         DWORD access, IPropertyStore **ppv)
1608 {
1609     TRACE("(static)->(%lx, %p)\n", access, ppv);
1610     *ppv = &info_device_ps;
1611     return S_OK;
1612 }
1613
1614 static const IMMDeviceVtbl info_device_Vtbl =
1615 {
1616     NULL,
1617     info_device_AddRef,
1618     info_device_Release,
1619     NULL,
1620     info_device_OpenPropertyStore,
1621     NULL,
1622     NULL
1623 };
1624
1625 static IMMDevice info_device = {
1626     &info_device_Vtbl
1627 };