dlls/mmdevapi/devenum.c

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