git.oblomov.eu Git - wine/blob - 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 #ifdef HAVE_AL_AL_H
  24 #include <AL/al.h>
  25 #include <AL/alc.h>
  26 #elif defined(HAVE_OPENAL_AL_H)
  27 #include <OpenAL/al.h>
  28 #include <OpenAL/alc.h>
  29 #endif
  30
  31 #define NONAMELESSUNION
  32 #define CINTERFACE
  33 #define COBJMACROS
  34 #include "windef.h"
  35 #include "winbase.h"
  36 #include "winnls.h"
  37 #include "winreg.h"
  38 #include "wine/debug.h"
  39 #include "wine/unicode.h"
  40
  41 #include "ole2.h"
  42 #include "mmdeviceapi.h"
  43 #include "dshow.h"
  44 #include "dsound.h"
  45 #include "audioclient.h"
  46 #include "endpointvolume.h"
  47 #include "audiopolicy.h"
  48
  49 #include "mmdevapi.h"
  50 #include "devpkey.h"
  51
  52 WINE_DEFAULT_DEBUG_CHANNEL(mmdevapi);
  53
  54 static const WCHAR software_mmdevapi[] =
  55     { 'S','o','f','t','w','a','r','e','\\',
  56       'M','i','c','r','o','s','o','f','t','\\',
  57       'W','i','n','d','o','w','s','\\',
  58       'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
  59       'M','M','D','e','v','i','c','e','s','\\',
  60       'A','u','d','i','o',0};
  61 static const WCHAR reg_render[] =
  62     { 'R','e','n','d','e','r',0 };
  63 static const WCHAR reg_capture[] =
  64     { 'C','a','p','t','u','r','e',0 };
  65 static const WCHAR reg_devicestate[] =
  66     { 'D','e','v','i','c','e','S','t','a','t','e',0 };
  67 static const WCHAR reg_properties[] =
  68     { 'P','r','o','p','e','r','t','i','e','s',0 };
  69
  70 static HKEY key_render;
  71 static HKEY key_capture;
  72
  73 typedef struct MMDevPropStoreImpl
  74 {
  75     const IPropertyStoreVtbl *lpVtbl;
  76     LONG ref;
  77     MMDevice *parent;
  78     DWORD access;
  79 } MMDevPropStore;
  80
  81 typedef struct MMDevEnumImpl
  82 {
  83     const IMMDeviceEnumeratorVtbl *lpVtbl;
  84     LONG ref;
  85 } MMDevEnumImpl;
  86
  87 static MMDevEnumImpl *MMDevEnumerator;
  88 static MMDevice **MMDevice_head;
  89 static MMDevice *MMDevice_def_rec, *MMDevice_def_play;
  90 static DWORD MMDevice_count;
  91 static const IMMDeviceEnumeratorVtbl MMDevEnumVtbl;
  92 static const IMMDeviceCollectionVtbl MMDevColVtbl;
  93 static const IMMDeviceVtbl MMDeviceVtbl;
  94 static const IPropertyStoreVtbl MMDevPropVtbl;
  95 static const IMMEndpointVtbl MMEndpointVtbl;
  96
  97 typedef struct MMDevColImpl
  98 {
  99     const IMMDeviceCollectionVtbl *lpVtbl;
 100     LONG ref;
 101     EDataFlow flow;
 102     DWORD state;
 103 } MMDevColImpl;
 104
 105 typedef struct IPropertyBagImpl {
 106     const IPropertyBagVtbl *lpVtbl;
 107     GUID devguid;
 108 } IPropertyBagImpl;
 109 static const IPropertyBagVtbl PB_Vtbl;
 110
 111 static HRESULT MMDevPropStore_Create(MMDevice *This, DWORD access, IPropertyStore **ppv);
 112
 113 /* Creates or updates the state of a device
 114  * If GUID is null, a random guid will be assigned
 115  * and the device will be created
 116  */
 117 static void MMDevice_Create(MMDevice **dev, WCHAR *name, GUID *id, EDataFlow flow, DWORD state, BOOL setdefault)
 118 {
 119     HKEY key, root;
 120     MMDevice *cur;
 121     WCHAR guidstr[39];
 122     DWORD i;
 123
 124     for (i = 0; i < MMDevice_count; ++i)
 125     {
 126         cur = MMDevice_head[i];
 127         if (cur->flow == flow && !lstrcmpW(cur->alname, name))
 128         {
 129             LONG ret;
 130             /* Same device, update state */
 131             cur->state = state;
 132             StringFromGUID2(&cur->devguid, guidstr, sizeof(guidstr)/sizeof(*guidstr));
 133             ret = RegOpenKeyExW(flow == eRender ? key_render : key_capture, guidstr, 0, KEY_WRITE, &key);
 134             if (ret == ERROR_SUCCESS)
 135             {
 136                 RegSetValueExW(key, reg_devicestate, 0, REG_DWORD, (const BYTE*)&state, sizeof(DWORD));
 137                 RegCloseKey(key);
 138             }
 139             goto done;
 140         }
 141     }
 142
 143     /* No device found, allocate new one */
 144     cur = HeapAlloc(GetProcessHeap(), 0, sizeof(*cur));
 145     if (!cur)
 146         return;
 147     cur->alname = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(name)+1)*sizeof(WCHAR));
 148     if (!cur->alname)
 149     {
 150         HeapFree(GetProcessHeap(), 0, cur);
 151         return;
 152     }
 153     lstrcpyW(cur->alname, name);
 154     cur->lpVtbl = &MMDeviceVtbl;
 155     cur->lpEndpointVtbl = &MMEndpointVtbl;
 156     cur->ref = 0;
 157     InitializeCriticalSection(&cur->crst);
 158     cur->crst.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": MMDevice.crst");
 159     cur->flow = flow;
 160     cur->state = state;
 161     cur->device = NULL;
 162     if (!id)
 163     {
 164         id = &cur->devguid;
 165         CoCreateGuid(id);
 166     }
 167     cur->devguid = *id;
 168     StringFromGUID2(id, guidstr, sizeof(guidstr)/sizeof(*guidstr));
 169     if (flow == eRender)
 170         root = key_render;
 171     else
 172         root = key_capture;
 173     if (!RegCreateKeyExW(root, guidstr, 0, NULL, 0, KEY_WRITE|KEY_READ, NULL, &key, NULL))
 174     {
 175         HKEY keyprop;
 176         RegSetValueExW(key, reg_devicestate, 0, REG_DWORD, (const BYTE*)&state, sizeof(DWORD));
 177         if (!RegCreateKeyExW(key, reg_properties, 0, NULL, 0, KEY_WRITE|KEY_READ, NULL, &keyprop, NULL))
 178         {
 179             PROPVARIANT pv;
 180             pv.vt = VT_LPWSTR;
 181             pv.u.pwszVal = name;
 182             MMDevice_SetPropValue(id, flow, (const PROPERTYKEY*)&DEVPKEY_Device_FriendlyName, &pv);
 183             MMDevice_SetPropValue(id, flow, (const PROPERTYKEY*)&DEVPKEY_Device_DeviceDesc, &pv);
 184             RegCloseKey(keyprop);
 185         }
 186         RegCloseKey(key);
 187     }
 188     if (!MMDevice_head)
 189         MMDevice_head = HeapAlloc(GetProcessHeap(), 0, sizeof(*MMDevice_head));
 190     else
 191         MMDevice_head = HeapReAlloc(GetProcessHeap(), 0, MMDevice_head, sizeof(*MMDevice_head)*(1+MMDevice_count));
 192     MMDevice_head[MMDevice_count++] = cur;
 193
 194 done:
 195     if (setdefault)
 196     {
 197         if (flow == eRender)
 198             MMDevice_def_play = cur;
 199         else
 200             MMDevice_def_rec = cur;
 201     }
 202     if (dev)
 203         *dev = cur;
 204 }
 205
 206 static void MMDevice_Destroy(MMDevice *This)
 207 {
 208     DWORD i;
 209     TRACE("Freeing %s\n", debugstr_w(This->alname));
 210     /* Since this function is called at destruction time, reordering of the list is unimportant */
 211     for (i = 0; i < MMDevice_count; ++i)
 212     {
 213         if (MMDevice_head[i] == This)
 214         {
 215             MMDevice_head[i] = MMDevice_head[--MMDevice_count];
 216             break;
 217         }
 218     }
 219 #ifdef HAVE_OPENAL
 220     if (This->device)
 221         palcCloseDevice(This->device);
 222 #endif
 223     This->crst.DebugInfo->Spare[0] = 0;
 224     DeleteCriticalSection(&This->crst);
 225     HeapFree(GetProcessHeap(), 0, This->alname);
 226     HeapFree(GetProcessHeap(), 0, This);
 227 }
 228
 229 static HRESULT WINAPI MMDevice_QueryInterface(IMMDevice *iface, REFIID riid, void **ppv)
 230 {
 231     MMDevice *This = (MMDevice *)iface;
 232     TRACE("(%p)->(%s,%p)\n", iface, debugstr_guid(riid), ppv);
 233
 234     if (!ppv)
 235         return E_POINTER;
 236     *ppv = NULL;
 237     if (IsEqualIID(riid, &IID_IUnknown)
 238         || IsEqualIID(riid, &IID_IMMDevice))
 239         *ppv = This;
 240     else if (IsEqualIID(riid, &IID_IMMEndpoint))
 241         *ppv = &This->lpEndpointVtbl;
 242     if (*ppv)
 243     {
 244         IUnknown_AddRef((IUnknown*)*ppv);
 245         return S_OK;
 246     }
 247     WARN("Unknown interface %s\n", debugstr_guid(riid));
 248     return E_NOINTERFACE;
 249 }
 250
 251 static ULONG WINAPI MMDevice_AddRef(IMMDevice *iface)
 252 {
 253     MMDevice *This = (MMDevice *)iface;
 254     LONG ref;
 255
 256     ref = InterlockedIncrement(&This->ref);
 257     TRACE("Refcount now %i\n", ref);
 258     return ref;
 259 }
 260
 261 static ULONG WINAPI MMDevice_Release(IMMDevice *iface)
 262 {
 263     MMDevice *This = (MMDevice *)iface;
 264     LONG ref;
 265
 266     ref = InterlockedDecrement(&This->ref);
 267     TRACE("Refcount now %i\n", ref);
 268     return ref;
 269 }
 270
 271 static HRESULT WINAPI MMDevice_Activate(IMMDevice *iface, REFIID riid, DWORD clsctx, PROPVARIANT *params, void **ppv)
 272 {
 273     MMDevice *This = (MMDevice *)iface;
 274     HRESULT hr = E_NOINTERFACE;
 275     TRACE("(%p)->(%p,%x,%p,%p)\n", iface, riid, clsctx, params, ppv);
 276
 277     if (!ppv)
 278         return E_POINTER;
 279
 280     if (IsEqualIID(riid, &IID_IAudioClient))
 281     {
 282 #ifdef HAVE_OPENAL
 283         if (openal_loaded)
 284             hr = AudioClient_Create(This, (IAudioClient**)ppv);
 285         else
 286 #endif
 287         {
 288             ERR("Trying to open a device with openal not available\n");
 289             hr = AUDCLNT_E_SERVICE_NOT_RUNNING;
 290         }
 291     }
 292     else if (IsEqualIID(riid, &IID_IAudioEndpointVolume))
 293     {
 294         FIXME("IID_IAudioEndpointVolume unsupported\n");
 295     }
 296     else if (IsEqualIID(riid, &IID_IAudioSessionManager)
 297              || IsEqualIID(riid, &IID_IAudioSessionManager2))
 298     {
 299         FIXME("IID_IAudioSessionManager unsupported\n");
 300     }
 301     else if (IsEqualIID(riid, &IID_IBaseFilter))
 302     {
 303         if (This->flow == eRender)
 304             hr = CoCreateInstance(&CLSID_DSoundRender, NULL, clsctx, riid, ppv);
 305         else
 306             ERR("Not supported for recording?\n");
 307         if (SUCCEEDED(hr))
 308         {
 309             IPersistPropertyBag *ppb;
 310             hr = IUnknown_QueryInterface((IUnknown*)*ppv, &IID_IPersistPropertyBag, (void*)&ppb);
 311             if (SUCCEEDED(hr))
 312             {
 313                 /* ::Load cannot assume the interface stays alive after the function returns,
 314                  * so just create the interface on the stack, saves a lot of complicated code */
 315                 IPropertyBagImpl bag = { &PB_Vtbl, This->devguid };
 316                 hr = IPersistPropertyBag_Load(ppb, (IPropertyBag*)&bag, NULL);
 317                 IPersistPropertyBag_Release(ppb);
 318                 if (FAILED(hr))
 319                     IBaseFilter_Release((IBaseFilter*)*ppv);
 320             }
 321             else
 322             {
 323                 FIXME("Wine doesn't support IPersistPropertyBag on DSoundRender yet, ignoring..\n");
 324                 hr = S_OK;
 325             }
 326         }
 327     }
 328     else if (IsEqualIID(riid, &IID_IDeviceTopology))
 329     {
 330         FIXME("IID_IDeviceTopology unsupported\n");
 331     }
 332     else if (IsEqualIID(riid, &IID_IDirectSound)
 333              || IsEqualIID(riid, &IID_IDirectSound8))
 334     {
 335         if (This->flow == eRender)
 336             hr = CoCreateInstance(&CLSID_DirectSound8, NULL, clsctx, riid, ppv);
 337         if (SUCCEEDED(hr))
 338         {
 339             hr = IDirectSound_Initialize((IDirectSound*)*ppv, &This->devguid);
 340             if (FAILED(hr))
 341                 IDirectSound_Release((IDirectSound*)*ppv);
 342         }
 343     }
 344     else if (IsEqualIID(riid, &IID_IDirectSoundCapture)
 345              || IsEqualIID(riid, &IID_IDirectSoundCapture8))
 346     {
 347         if (This->flow == eCapture)
 348             hr = CoCreateInstance(&CLSID_DirectSoundCapture8, NULL, clsctx, riid, ppv);
 349         if (SUCCEEDED(hr))
 350         {
 351             hr = IDirectSoundCapture_Initialize((IDirectSoundCapture*)*ppv, &This->devguid);
 352             if (FAILED(hr))
 353                 IDirectSoundCapture_Release((IDirectSoundCapture*)*ppv);
 354         }
 355     }
 356     else
 357         ERR("Invalid/unknown iid %s\n", debugstr_guid(riid));
 358
 359     if (FAILED(hr))
 360         *ppv = NULL;
 361
 362     TRACE("Returning %08x\n", hr);
 363     return hr;
 364 }
 365
 366 static HRESULT WINAPI MMDevice_OpenPropertyStore(IMMDevice *iface, DWORD access, IPropertyStore **ppv)
 367 {
 368     MMDevice *This = (MMDevice *)iface;
 369     TRACE("(%p)->(%x,%p)\n", This, access, ppv);
 370
 371     if (!ppv)
 372         return E_POINTER;
 373     return MMDevPropStore_Create(This, access, ppv);
 374 }
 375
 376 static HRESULT WINAPI MMDevice_GetId(IMMDevice *iface, WCHAR **itemid)
 377 {
 378     MMDevice *This = (MMDevice *)iface;
 379     WCHAR *str;
 380     GUID *id = &This->devguid;
 381     static const WCHAR formatW[] = { '{','0','.','0','.','0','.','0','0','0','0','0','0','0','0','}','.',
 382                                      '{','%','0','8','X','-','%','0','4','X','-',
 383                                      '%','0','4','X','-','%','0','2','X','%','0','2','X','-',
 384                                      '%','0','2','X','%','0','2','X','%','0','2','X','%','0','2','X',
 385                                      '%','0','2','X','%','0','2','X','}',0 };
 386
 387     TRACE("(%p)->(%p)\n", This, itemid);
 388     if (!itemid)
 389         return E_POINTER;
 390     *itemid = str = CoTaskMemAlloc(56 * sizeof(WCHAR));
 391     if (!str)
 392         return E_OUTOFMEMORY;
 393     wsprintfW( str, formatW, id->Data1, id->Data2, id->Data3,
 394                id->Data4[0], id->Data4[1], id->Data4[2], id->Data4[3],
 395                id->Data4[4], id->Data4[5], id->Data4[6], id->Data4[7] );
 396     return S_OK;
 397 }
 398
 399 static HRESULT WINAPI MMDevice_GetState(IMMDevice *iface, DWORD *state)
 400 {
 401     MMDevice *This = (MMDevice *)iface;
 402     TRACE("(%p)->(%p)\n", iface, state);
 403
 404     if (!state)
 405         return E_POINTER;
 406     *state = This->state;
 407     return S_OK;
 408 }
 409
 410 static const IMMDeviceVtbl MMDeviceVtbl =
 411 {
 412     MMDevice_QueryInterface,
 413     MMDevice_AddRef,
 414     MMDevice_Release,
 415     MMDevice_Activate,
 416     MMDevice_OpenPropertyStore,
 417     MMDevice_GetId,
 418     MMDevice_GetState
 419 };
 420
 421 static MMDevice *get_this_from_endpoint(IMMEndpoint *iface)
 422 {
 423     return (MMDevice*)((char*)iface - offsetof(MMDevice,lpEndpointVtbl));
 424 }
 425
 426 static HRESULT WINAPI MMEndpoint_QueryInterface(IMMEndpoint *iface, REFIID riid, void **ppv)
 427 {
 428     MMDevice *This = get_this_from_endpoint(iface);
 429     return IMMDevice_QueryInterface((IMMDevice*)This, riid, ppv);
 430 }
 431
 432 static ULONG WINAPI MMEndpoint_AddRef(IMMEndpoint *iface)
 433 {
 434     MMDevice *This = get_this_from_endpoint(iface);
 435     return IMMDevice_AddRef((IMMDevice*)This);
 436 }
 437
 438 static ULONG WINAPI MMEndpoint_Release(IMMEndpoint *iface)
 439 {
 440     MMDevice *This = get_this_from_endpoint(iface);
 441     return IMMDevice_Release((IMMDevice*)This);
 442 }
 443
 444 static HRESULT WINAPI MMEndpoint_GetDataFlow(IMMEndpoint *iface, EDataFlow *flow)
 445 {
 446     MMDevice *This = get_this_from_endpoint(iface);
 447     if (!flow)
 448         return E_POINTER;
 449     *flow = This->flow;
 450     return S_OK;
 451 }
 452
 453 static const IMMEndpointVtbl MMEndpointVtbl =
 454 {
 455     MMEndpoint_QueryInterface,
 456     MMEndpoint_AddRef,
 457     MMEndpoint_Release,
 458     MMEndpoint_GetDataFlow
 459 };
 460
 461 static HRESULT MMDevCol_Create(IMMDeviceCollection **ppv, EDataFlow flow, DWORD state)
 462 {
 463     MMDevColImpl *This;
 464
 465     This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
 466     *ppv = NULL;
 467     if (!This)
 468         return E_OUTOFMEMORY;
 469     This->lpVtbl = &MMDevColVtbl;
 470     This->ref = 1;
 471     This->flow = flow;
 472     This->state = state;
 473     *ppv = (IMMDeviceCollection*)This;
 474     return S_OK;
 475 }
 476
 477 static void MMDevCol_Destroy(MMDevColImpl *This)
 478 {
 479     HeapFree(GetProcessHeap(), 0, This);
 480 }
 481
 482 static HRESULT WINAPI MMDevCol_QueryInterface(IMMDeviceCollection *iface, REFIID riid, void **ppv)
 483 {
 484     MMDevColImpl *This = (MMDevColImpl*)iface;
 485
 486     if (!ppv)
 487         return E_POINTER;
 488     if (IsEqualIID(riid, &IID_IUnknown)
 489         || IsEqualIID(riid, &IID_IMMDeviceCollection))
 490         *ppv = This;
 491     else
 492         *ppv = NULL;
 493     if (!*ppv)
 494         return E_NOINTERFACE;
 495     IUnknown_AddRef((IUnknown*)*ppv);
 496     return S_OK;
 497 }
 498
 499 static ULONG WINAPI MMDevCol_AddRef(IMMDeviceCollection *iface)
 500 {
 501     MMDevColImpl *This = (MMDevColImpl*)iface;
 502     LONG ref = InterlockedIncrement(&This->ref);
 503     TRACE("Refcount now %i\n", ref);
 504     return ref;
 505 }
 506
 507 static ULONG WINAPI MMDevCol_Release(IMMDeviceCollection *iface)
 508 {
 509     MMDevColImpl *This = (MMDevColImpl*)iface;
 510     LONG ref = InterlockedDecrement(&This->ref);
 511     TRACE("Refcount now %i\n", ref);
 512     if (!ref)
 513         MMDevCol_Destroy(This);
 514     return ref;
 515 }
 516
 517 static HRESULT WINAPI MMDevCol_GetCount(IMMDeviceCollection *iface, UINT *numdevs)
 518 {
 519     MMDevColImpl *This = (MMDevColImpl*)iface;
 520     DWORD i;
 521
 522     TRACE("(%p)->(%p)\n", This, numdevs);
 523     if (!numdevs)
 524         return E_POINTER;
 525
 526     *numdevs = 0;
 527     for (i = 0; i < MMDevice_count; ++i)
 528     {
 529         MMDevice *cur = MMDevice_head[i];
 530         if ((cur->flow == This->flow || This->flow == eAll)
 531             && (cur->state & This->state))
 532             ++(*numdevs);
 533     }
 534     return S_OK;
 535 }
 536
 537 static HRESULT WINAPI MMDevCol_Item(IMMDeviceCollection *iface, UINT n, IMMDevice **dev)
 538 {
 539     MMDevColImpl *This = (MMDevColImpl*)iface;
 540     DWORD i = 0, j = 0;
 541
 542     TRACE("(%p)->(%u, %p)\n", This, n, dev);
 543     if (!dev)
 544         return E_POINTER;
 545
 546     for (j = 0; j < MMDevice_count; ++j)
 547     {
 548         MMDevice *cur = MMDevice_head[j];
 549         if ((cur->flow == This->flow || This->flow == eAll)
 550             && (cur->state & This->state)
 551             && i++ == n)
 552         {
 553             *dev = (IMMDevice *)cur;
 554             IMMDevice_AddRef(*dev);
 555             return S_OK;
 556         }
 557     }
 558     WARN("Could not obtain item %u\n", n);
 559     *dev = NULL;
 560     return E_INVALIDARG;
 561 }
 562
 563 static const IMMDeviceCollectionVtbl MMDevColVtbl =
 564 {
 565     MMDevCol_QueryInterface,
 566     MMDevCol_AddRef,
 567     MMDevCol_Release,
 568     MMDevCol_GetCount,
 569     MMDevCol_Item
 570 };
 571
 572 static const WCHAR propkey_formatW[] = {
 573     '{','%','0','8','X','-','%','0','4','X','-',
 574     '%','0','4','X','-','%','0','2','X','%','0','2','X','-',
 575     '%','0','2','X','%','0','2','X','%','0','2','X','%','0','2','X',
 576     '%','0','2','X','%','0','2','X','}',',','%','d',0 };
 577
 578 static HRESULT MMDevPropStore_OpenPropKey(const GUID *guid, DWORD flow, HKEY *propkey)
 579 {
 580     WCHAR buffer[39];
 581     LONG ret;
 582     HKEY key;
 583     StringFromGUID2(guid, buffer, 39);
 584     if ((ret = RegOpenKeyExW(flow == eRender ? key_render : key_capture, buffer, 0, KEY_READ|KEY_WRITE, &key)) != ERROR_SUCCESS)
 585     {
 586         WARN("Opening key %s failed with %u\n", debugstr_w(buffer), ret);
 587         return E_FAIL;
 588     }
 589     ret = RegOpenKeyExW(key, reg_properties, 0, KEY_READ|KEY_WRITE, propkey);
 590     RegCloseKey(key);
 591     if (ret != ERROR_SUCCESS)
 592     {
 593         WARN("Opening key %s failed with %u\n", debugstr_w(reg_properties), ret);
 594         return E_FAIL;
 595     }
 596     return S_OK;
 597 }
 598
 599 HRESULT MMDevice_GetPropValue(const GUID *devguid, DWORD flow, REFPROPERTYKEY key, PROPVARIANT *pv)
 600 {
 601     WCHAR buffer[80];
 602     const GUID *id = &key->fmtid;
 603     DWORD type, size;
 604     HRESULT hr = S_OK;
 605     HKEY regkey;
 606     LONG ret;
 607
 608     hr = MMDevPropStore_OpenPropKey(devguid, flow, &regkey);
 609     if (FAILED(hr))
 610         return hr;
 611     wsprintfW( buffer, propkey_formatW, id->Data1, id->Data2, id->Data3,
 612                id->Data4[0], id->Data4[1], id->Data4[2], id->Data4[3],
 613                id->Data4[4], id->Data4[5], id->Data4[6], id->Data4[7], key->pid );
 614     ret = RegGetValueW(regkey, NULL, buffer, RRF_RT_ANY, &type, NULL, &size);
 615     if (ret != ERROR_SUCCESS)
 616     {
 617         WARN("Reading %s returned %d\n", debugstr_w(buffer), ret);
 618         RegCloseKey(regkey);
 619         PropVariantClear(pv);
 620         return S_OK;
 621     }
 622
 623     switch (type)
 624     {
 625         case REG_SZ:
 626         {
 627             pv->vt = VT_LPWSTR;
 628             pv->u.pwszVal = CoTaskMemAlloc(size);
 629             if (!pv->u.pwszVal)
 630                 hr = E_OUTOFMEMORY;
 631             else
 632                 RegGetValueW(regkey, NULL, buffer, RRF_RT_REG_SZ, NULL, (BYTE*)pv->u.pwszVal, &size);
 633             break;
 634         }
 635         case REG_DWORD:
 636         {
 637             pv->vt = VT_UI4;
 638             RegGetValueW(regkey, NULL, buffer, RRF_RT_REG_DWORD, NULL, (BYTE*)&pv->u.ulVal, &size);
 639             break;
 640         }
 641         case REG_BINARY:
 642         {
 643             pv->vt = VT_BLOB;
 644             pv->u.blob.cbSize = size;
 645             pv->u.blob.pBlobData = CoTaskMemAlloc(size);
 646             if (!pv->u.blob.pBlobData)
 647                 hr = E_OUTOFMEMORY;
 648             else
 649                 RegGetValueW(regkey, NULL, buffer, RRF_RT_REG_BINARY, NULL, (BYTE*)pv->u.blob.pBlobData, &size);
 650             break;
 651         }
 652         default:
 653             ERR("Unknown/unhandled type: %u\n", type);
 654             PropVariantClear(pv);
 655             break;
 656     }
 657     RegCloseKey(regkey);
 658     return hr;
 659 }
 660
 661 HRESULT MMDevice_SetPropValue(const GUID *devguid, DWORD flow, REFPROPERTYKEY key, REFPROPVARIANT pv)
 662 {
 663     WCHAR buffer[80];
 664     const GUID *id = &key->fmtid;
 665     HRESULT hr;
 666     HKEY regkey;
 667     LONG ret;
 668
 669     hr = MMDevPropStore_OpenPropKey(devguid, flow, &regkey);
 670     if (FAILED(hr))
 671         return hr;
 672     wsprintfW( buffer, propkey_formatW, id->Data1, id->Data2, id->Data3,
 673                id->Data4[0], id->Data4[1], id->Data4[2], id->Data4[3],
 674                id->Data4[4], id->Data4[5], id->Data4[6], id->Data4[7], key->pid );
 675     switch (pv->vt)
 676     {
 677         case VT_UI4:
 678         {
 679             ret = RegSetValueExW(regkey, buffer, 0, REG_DWORD, (const BYTE*)&pv->u.ulVal, sizeof(DWORD));
 680             break;
 681         }
 682         case VT_BLOB:
 683         {
 684             ret = RegSetValueExW(regkey, buffer, 0, REG_BINARY, pv->u.blob.pBlobData, pv->u.blob.cbSize);
 685             TRACE("Blob %p %u\n", pv->u.blob.pBlobData, pv->u.blob.cbSize);
 686
 687             break;
 688         }
 689         case VT_LPWSTR:
 690         {
 691             ret = RegSetValueExW(regkey, buffer, 0, REG_SZ, (const BYTE*)pv->u.pwszVal, sizeof(WCHAR)*(1+lstrlenW(pv->u.pwszVal)));
 692             break;
 693         }
 694         default:
 695             ret = 0;
 696             FIXME("Unhandled type %u\n", pv->vt);
 697             hr = E_INVALIDARG;
 698             break;
 699     }
 700     RegCloseKey(regkey);
 701     TRACE("Writing %s returned %u\n", debugstr_w(buffer), ret);
 702     return hr;
 703 }
 704
 705 #ifdef HAVE_OPENAL
 706
 707 static void openal_setformat(MMDevice *This, DWORD freq)
 708 {
 709     HRESULT hr;
 710     PROPVARIANT pv = { VT_EMPTY };
 711
 712     hr = MMDevice_GetPropValue(&This->devguid, This->flow, &PKEY_AudioEngine_DeviceFormat, &pv);
 713     if (SUCCEEDED(hr) && pv.vt == VT_BLOB)
 714     {
 715         WAVEFORMATEX *pwfx;
 716         pwfx = (WAVEFORMATEX*)pv.u.blob.pBlobData;
 717         if (pwfx->nSamplesPerSec != freq)
 718         {
 719             pwfx->nSamplesPerSec = freq;
 720             pwfx->nAvgBytesPerSec = freq * pwfx->nBlockAlign;
 721             MMDevice_SetPropValue(&This->devguid, This->flow, &PKEY_AudioEngine_DeviceFormat, &pv);
 722         }
 723         CoTaskMemFree(pwfx);
 724     }
 725     else
 726     {
 727         WAVEFORMATEXTENSIBLE wfxe;
 728
 729         wfxe.Format.wFormatTag = WAVE_FORMAT_EXTENSIBLE;
 730         wfxe.Format.nChannels = 2;
 731         wfxe.Format.wBitsPerSample = 32;
 732         wfxe.Format.nBlockAlign = wfxe.Format.nChannels * wfxe.Format.wBitsPerSample/8;
 733         wfxe.Format.nSamplesPerSec = freq;
 734         wfxe.Format.nAvgBytesPerSec = wfxe.Format.nSamplesPerSec * wfxe.Format.nBlockAlign;
 735         wfxe.Format.cbSize = sizeof(wfxe)-sizeof(WAVEFORMATEX);
 736         wfxe.Samples.wValidBitsPerSample = 32;
 737         wfxe.SubFormat = KSDATAFORMAT_SUBTYPE_IEEE_FLOAT;
 738         wfxe.dwChannelMask = SPEAKER_FRONT_LEFT|SPEAKER_FRONT_RIGHT;
 739
 740         pv.vt = VT_BLOB;
 741         pv.u.blob.cbSize = sizeof(wfxe);
 742         pv.u.blob.pBlobData = (BYTE*)&wfxe;
 743         MMDevice_SetPropValue(&This->devguid, This->flow, &PKEY_AudioEngine_DeviceFormat, &pv);
 744         MMDevice_SetPropValue(&This->devguid, This->flow, &PKEY_AudioEngine_OEMFormat, &pv);
 745     }
 746 }
 747
 748 static int blacklist_pulse;
 749
 750 static int blacklist(const char *dev) {
 751 #ifdef __linux__
 752     if (!strncmp(dev, "OSS ", 4))
 753         return 1;
 754 #endif
 755     if (blacklist_pulse && !strncmp(dev, "PulseAudio ", 11))
 756         return 1;
 757     if (!strncmp(dev, "ALSA ", 5) && strstr(dev, "hw:"))
 758         return 1;
 759     return 0;
 760 }
 761
 762 static void pulse_fixup(const char *devstr, const char **defstr) {
 763     static int warned;
 764
 765     if (!blacklist_pulse && !local_contexts)
 766         blacklist_pulse = 1;
 767
 768     if (!blacklist_pulse || !devstr || strncmp(*defstr, "PulseAudio ", 11))
 769         return;
 770
 771     if (!warned++) {
 772         ERR("Disabling pulseaudio because of old openal version\n");
 773         ERR("Please upgrade to openal-soft v1.12 or newer\n");
 774     }
 775     while (*devstr && !strncmp(devstr, "PulseAudio ", 11)) {
 776         devstr += strlen(devstr) + 1;
 777     }
 778     TRACE("New default: %s\n", devstr);
 779     *defstr = devstr;
 780 }
 781
 782 static void openal_scanrender(void)
 783 {
 784     WCHAR name[MAX_PATH];
 785     ALCdevice *dev;
 786     const ALCchar *devstr, *defaultstr;
 787     int defblacklisted;
 788     EnterCriticalSection(&openal_crst);
 789     if (palcIsExtensionPresent(NULL, "ALC_ENUMERATE_ALL_EXT")) {
 790         defaultstr = palcGetString(NULL, ALC_DEFAULT_ALL_DEVICES_SPECIFIER);
 791         devstr = palcGetString(NULL, ALC_ALL_DEVICES_SPECIFIER);
 792     } else {
 793         defaultstr = palcGetString(NULL, ALC_DEFAULT_DEVICE_SPECIFIER);
 794         devstr = palcGetString(NULL, ALC_DEVICE_SPECIFIER);
 795     }
 796     pulse_fixup(devstr, &defaultstr);
 797     defblacklisted = blacklist(defaultstr);
 798     if (defblacklisted)
 799         WARN("Disabling blacklist because %s is blacklisted\n", defaultstr);
 800     if (devstr)
 801         for (; *devstr; devstr += strlen(devstr)+1) {
 802             MMDevice *mmdev;
 803             MultiByteToWideChar( CP_UNIXCP, 0, devstr, -1,
 804                                  name, sizeof(name)/sizeof(*name)-1 );
 805             name[sizeof(name)/sizeof(*name)-1] = 0;
 806             /* Only enable blacklist if the default device isn't blacklisted */
 807             if (!defblacklisted && blacklist(devstr)) {
 808                 WARN("Not adding %s: device is blacklisted\n", devstr);
 809                 continue;
 810             }
 811             TRACE("Adding %s\n", devstr);
 812             dev = palcOpenDevice(devstr);
 813             MMDevice_Create(&mmdev, name, NULL, eRender, dev ? DEVICE_STATE_ACTIVE : DEVICE_STATE_NOTPRESENT, !strcmp(devstr, defaultstr));
 814             if (dev)
 815             {
 816                 ALint freq = 44100;
 817                 palcGetIntegerv(dev, ALC_FREQUENCY, 1, &freq);
 818                 openal_setformat(mmdev, freq);
 819                 palcCloseDevice(dev);
 820             }
 821             else
 822                 WARN("Could not open device: %04x\n", palcGetError(NULL));
 823         }
 824     LeaveCriticalSection(&openal_crst);
 825 }
 826
 827 static void openal_scancapture(void)
 828 {
 829     WCHAR name[MAX_PATH];
 830     ALCdevice *dev;
 831     const ALCchar *devstr, *defaultstr;
 832     int defblacklisted;
 833
 834     EnterCriticalSection(&openal_crst);
 835     devstr = palcGetString(NULL, ALC_CAPTURE_DEVICE_SPECIFIER);
 836     defaultstr = palcGetString(NULL, ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER);
 837     pulse_fixup(devstr, &defaultstr);
 838     defblacklisted = blacklist(defaultstr);
 839     if (defblacklisted)
 840         WARN("Disabling blacklist because %s is blacklisted\n", defaultstr);
 841     if (devstr && *devstr)
 842         for (; *devstr; devstr += strlen(devstr)+1) {
 843             MMDevice *mmdev;
 844             ALint freq = 44100;
 845             MultiByteToWideChar( CP_UNIXCP, 0, devstr, -1,
 846                                  name, sizeof(name)/sizeof(*name)-1 );
 847             name[sizeof(name)/sizeof(*name)-1] = 0;
 848             if (!defblacklisted && blacklist(devstr)) {
 849                 WARN("Not adding %s: device is blacklisted\n", devstr);
 850                 continue;
 851             }
 852             TRACE("Adding %s\n", devstr);
 853             dev = palcCaptureOpenDevice(devstr, freq, AL_FORMAT_MONO16, 65536);
 854             MMDevice_Create(&mmdev, name, NULL, eCapture, dev ? DEVICE_STATE_ACTIVE : DEVICE_STATE_NOTPRESENT, !strcmp(devstr, defaultstr));
 855             if (dev) {
 856                 openal_setformat(mmdev, freq);
 857                 palcCaptureCloseDevice(dev);
 858             } else
 859                 WARN("Could not open device: %04x\n", palcGetError(NULL));
 860         }
 861     LeaveCriticalSection(&openal_crst);
 862 }
 863 #endif /*HAVE_OPENAL*/
 864
 865 HRESULT MMDevEnum_Create(REFIID riid, void **ppv)
 866 {
 867     MMDevEnumImpl *This = MMDevEnumerator;
 868
 869     if (!This)
 870     {
 871         DWORD i = 0;
 872         HKEY root, cur;
 873         LONG ret;
 874         DWORD curflow;
 875
 876         This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
 877         *ppv = NULL;
 878         if (!This)
 879             return E_OUTOFMEMORY;
 880         This->ref = 1;
 881         This->lpVtbl = &MMDevEnumVtbl;
 882         MMDevEnumerator = This;
 883
 884         ret = RegCreateKeyExW(HKEY_LOCAL_MACHINE, software_mmdevapi, 0, NULL, 0, KEY_WRITE|KEY_READ, NULL, &root, NULL);
 885         if (ret == ERROR_SUCCESS)
 886             ret = RegCreateKeyExW(root, reg_capture, 0, NULL, 0, KEY_READ|KEY_WRITE, NULL, &key_capture, NULL);
 887         if (ret == ERROR_SUCCESS)
 888             ret = RegCreateKeyExW(root, reg_render, 0, NULL, 0, KEY_READ|KEY_WRITE, NULL, &key_render, NULL);
 889         RegCloseKey(root);
 890         cur = key_capture;
 891         curflow = eCapture;
 892         if (ret != ERROR_SUCCESS)
 893         {
 894             RegCloseKey(key_capture);
 895             key_render = key_capture = NULL;
 896             WARN("Couldn't create key: %u\n", ret);
 897             return E_FAIL;
 898         }
 899         else do {
 900             WCHAR guidvalue[39];
 901             GUID guid;
 902             DWORD len;
 903             PROPVARIANT pv = { VT_EMPTY };
 904
 905             len = sizeof(guidvalue);
 906             ret = RegEnumKeyExW(cur, i++, guidvalue, &len, NULL, NULL, NULL, NULL);
 907             if (ret == ERROR_NO_MORE_ITEMS)
 908             {
 909                 if (cur == key_capture)
 910                 {
 911                     cur = key_render;
 912                     curflow = eRender;
 913                     i = 0;
 914                     continue;
 915                 }
 916                 break;
 917             }
 918             if (ret != ERROR_SUCCESS)
 919                 continue;
 920             if (SUCCEEDED(CLSIDFromString(guidvalue, &guid))
 921                 && SUCCEEDED(MMDevice_GetPropValue(&guid, curflow, (const PROPERTYKEY*)&DEVPKEY_Device_FriendlyName, &pv))
 922                 && pv.vt == VT_LPWSTR)
 923             {
 924                 MMDevice_Create(NULL, pv.u.pwszVal, &guid, curflow,
 925                                 DEVICE_STATE_NOTPRESENT, FALSE);
 926                 CoTaskMemFree(pv.u.pwszVal);
 927             }
 928         } while (1);
 929 #ifdef HAVE_OPENAL
 930         if (openal_loaded)
 931         {
 932             openal_scanrender();
 933             openal_scancapture();
 934         }
 935 #endif /*HAVE_OPENAL*/
 936     }
 937     return IUnknown_QueryInterface((IUnknown*)This, riid, ppv);
 938 }
 939
 940 void MMDevEnum_Free(void)
 941 {
 942     while (MMDevice_count)
 943         MMDevice_Destroy(MMDevice_head[0]);
 944     RegCloseKey(key_render);
 945     RegCloseKey(key_capture);
 946     key_render = key_capture = NULL;
 947     HeapFree(GetProcessHeap(), 0, MMDevEnumerator);
 948     MMDevEnumerator = NULL;
 949 }
 950
 951 static HRESULT WINAPI MMDevEnum_QueryInterface(IMMDeviceEnumerator *iface, REFIID riid, void **ppv)
 952 {
 953     MMDevEnumImpl *This = (MMDevEnumImpl*)iface;
 954
 955     if (!ppv)
 956         return E_POINTER;
 957     if (IsEqualIID(riid, &IID_IUnknown)
 958         || IsEqualIID(riid, &IID_IMMDeviceEnumerator))
 959         *ppv = This;
 960     else
 961         *ppv = NULL;
 962     if (!*ppv)
 963         return E_NOINTERFACE;
 964     IUnknown_AddRef((IUnknown*)*ppv);
 965     return S_OK;
 966 }
 967
 968 static ULONG WINAPI MMDevEnum_AddRef(IMMDeviceEnumerator *iface)
 969 {
 970     MMDevEnumImpl *This = (MMDevEnumImpl*)iface;
 971     LONG ref = InterlockedIncrement(&This->ref);
 972     TRACE("Refcount now %i\n", ref);
 973     return ref;
 974 }
 975
 976 static ULONG WINAPI MMDevEnum_Release(IMMDeviceEnumerator *iface)
 977 {
 978     MMDevEnumImpl *This = (MMDevEnumImpl*)iface;
 979     LONG ref = InterlockedDecrement(&This->ref);
 980     if (!ref)
 981         MMDevEnum_Free();
 982     TRACE("Refcount now %i\n", ref);
 983     return ref;
 984 }
 985
 986 static HRESULT WINAPI MMDevEnum_EnumAudioEndpoints(IMMDeviceEnumerator *iface, EDataFlow flow, DWORD mask, IMMDeviceCollection **devices)
 987 {
 988     MMDevEnumImpl *This = (MMDevEnumImpl*)iface;
 989     TRACE("(%p)->(%u,%u,%p)\n", This, flow, mask, devices);
 990     if (!devices)
 991         return E_POINTER;
 992     *devices = NULL;
 993     if (flow >= EDataFlow_enum_count)
 994         return E_INVALIDARG;
 995     if (mask & ~DEVICE_STATEMASK_ALL)
 996         return E_INVALIDARG;
 997     return MMDevCol_Create(devices, flow, mask);
 998 }
 999
1000 static HRESULT WINAPI MMDevEnum_GetDefaultAudioEndpoint(IMMDeviceEnumerator *iface, EDataFlow flow, ERole role, IMMDevice **device)
1001 {
1002     MMDevEnumImpl *This = (MMDevEnumImpl*)iface;
1003     TRACE("(%p)->(%u,%u,%p)\n", This, flow, role, device);
1004
1005     if (!device)
1006         return E_POINTER;
1007     *device = NULL;
1008
1009     if (flow == eRender)
1010         *device = (IMMDevice*)MMDevice_def_play;
1011     else if (flow == eCapture)
1012         *device = (IMMDevice*)MMDevice_def_rec;
1013     else
1014     {
1015         WARN("Unknown flow %u\n", flow);
1016         return E_INVALIDARG;
1017     }
1018
1019     if (!*device)
1020         return E_NOTFOUND;
1021     IMMDevice_AddRef(*device);
1022     return S_OK;
1023 }
1024
1025 static HRESULT WINAPI MMDevEnum_GetDevice(IMMDeviceEnumerator *iface, const WCHAR *name, IMMDevice **device)
1026 {
1027     MMDevEnumImpl *This = (MMDevEnumImpl*)iface;
1028     DWORD i=0;
1029     IMMDevice *dev = NULL;
1030
1031     TRACE("(%p)->(%s,%p)\n", This, debugstr_w(name), device);
1032     for (i = 0; i < MMDevice_count; ++i)
1033     {
1034         WCHAR *str;
1035         dev = (IMMDevice*)MMDevice_head[i];
1036         IMMDevice_GetId(dev, &str);
1037
1038         if (str && !lstrcmpW(str, name))
1039         {
1040             CoTaskMemFree(str);
1041             break;
1042         }
1043         CoTaskMemFree(str);
1044     }
1045     if (dev)
1046     {
1047         IUnknown_AddRef(dev);
1048         *device = dev;
1049         return S_OK;
1050     }
1051     WARN("Could not find device %s\n", debugstr_w(name));
1052     return E_NOTFOUND;
1053 }
1054
1055 static HRESULT WINAPI MMDevEnum_RegisterEndpointNotificationCallback(IMMDeviceEnumerator *iface, IMMNotificationClient *client)
1056 {
1057     MMDevEnumImpl *This = (MMDevEnumImpl*)iface;
1058     TRACE("(%p)->(%p)\n", This, client);
1059     FIXME("stub\n");
1060     return S_OK;
1061 }
1062
1063 static HRESULT WINAPI MMDevEnum_UnregisterEndpointNotificationCallback(IMMDeviceEnumerator *iface, IMMNotificationClient *client)
1064 {
1065     MMDevEnumImpl *This = (MMDevEnumImpl*)iface;
1066     TRACE("(%p)->(%p)\n", This, client);
1067     FIXME("stub\n");
1068     return S_OK;
1069 }
1070
1071 static const IMMDeviceEnumeratorVtbl MMDevEnumVtbl =
1072 {
1073     MMDevEnum_QueryInterface,
1074     MMDevEnum_AddRef,
1075     MMDevEnum_Release,
1076     MMDevEnum_EnumAudioEndpoints,
1077     MMDevEnum_GetDefaultAudioEndpoint,
1078     MMDevEnum_GetDevice,
1079     MMDevEnum_RegisterEndpointNotificationCallback,
1080     MMDevEnum_UnregisterEndpointNotificationCallback
1081 };
1082
1083 static HRESULT MMDevPropStore_Create(MMDevice *parent, DWORD access, IPropertyStore **ppv)
1084 {
1085     MMDevPropStore *This;
1086     if (access != STGM_READ
1087         && access != STGM_WRITE
1088         && access != STGM_READWRITE)
1089     {
1090         WARN("Invalid access %08x\n", access);
1091         return E_INVALIDARG;
1092     }
1093     This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
1094     *ppv = (IPropertyStore*)This;
1095     if (!This)
1096         return E_OUTOFMEMORY;
1097     This->lpVtbl = &MMDevPropVtbl;
1098     This->ref = 1;
1099     This->parent = parent;
1100     This->access = access;
1101     return S_OK;
1102 }
1103
1104 static void MMDevPropStore_Destroy(MMDevPropStore *This)
1105 {
1106     HeapFree(GetProcessHeap(), 0, This);
1107 }
1108
1109 static HRESULT WINAPI MMDevPropStore_QueryInterface(IPropertyStore *iface, REFIID riid, void **ppv)
1110 {
1111     MMDevPropStore *This = (MMDevPropStore*)iface;
1112
1113     if (!ppv)
1114         return E_POINTER;
1115     if (IsEqualIID(riid, &IID_IUnknown)
1116         || IsEqualIID(riid, &IID_IPropertyStore))
1117         *ppv = This;
1118     else
1119         *ppv = NULL;
1120     if (!*ppv)
1121         return E_NOINTERFACE;
1122     IUnknown_AddRef((IUnknown*)*ppv);
1123     return S_OK;
1124 }
1125
1126 static ULONG WINAPI MMDevPropStore_AddRef(IPropertyStore *iface)
1127 {
1128     MMDevPropStore *This = (MMDevPropStore*)iface;
1129     LONG ref = InterlockedIncrement(&This->ref);
1130     TRACE("Refcount now %i\n", ref);
1131     return ref;
1132 }
1133
1134 static ULONG WINAPI MMDevPropStore_Release(IPropertyStore *iface)
1135 {
1136     MMDevPropStore *This = (MMDevPropStore*)iface;
1137     LONG ref = InterlockedDecrement(&This->ref);
1138     TRACE("Refcount now %i\n", ref);
1139     if (!ref)
1140         MMDevPropStore_Destroy(This);
1141     return ref;
1142 }
1143
1144 static HRESULT WINAPI MMDevPropStore_GetCount(IPropertyStore *iface, DWORD *nprops)
1145 {
1146     MMDevPropStore *This = (MMDevPropStore*)iface;
1147     WCHAR buffer[50];
1148     DWORD i = 0;
1149     HKEY propkey;
1150     HRESULT hr;
1151
1152     TRACE("(%p)->(%p)\n", iface, nprops);
1153     if (!nprops)
1154         return E_POINTER;
1155     hr = MMDevPropStore_OpenPropKey(&This->parent->devguid, This->parent->flow, &propkey);
1156     if (FAILED(hr))
1157         return hr;
1158     *nprops = 0;
1159     do {
1160         DWORD len = sizeof(buffer)/sizeof(*buffer);
1161         if (RegEnumKeyExW(propkey, i, buffer, &len, NULL, NULL, NULL, NULL) != ERROR_SUCCESS)
1162             break;
1163         i++;
1164     } while (0);
1165     RegCloseKey(propkey);
1166     TRACE("Returning %i\n", i);
1167     *nprops = i;
1168     return S_OK;
1169 }
1170
1171 static HRESULT WINAPI MMDevPropStore_GetAt(IPropertyStore *iface, DWORD prop, PROPERTYKEY *key)
1172 {
1173     MMDevPropStore *This = (MMDevPropStore*)iface;
1174     WCHAR buffer[50];
1175     DWORD len = sizeof(buffer)/sizeof(*buffer);
1176     HRESULT hr;
1177     HKEY propkey;
1178
1179     TRACE("(%p)->(%u,%p)\n", iface, prop, key);
1180     if (!key)
1181         return E_POINTER;
1182
1183     hr = MMDevPropStore_OpenPropKey(&This->parent->devguid, This->parent->flow, &propkey);
1184     if (FAILED(hr))
1185         return hr;
1186
1187     if (RegEnumKeyExW(propkey, prop, buffer, &len, NULL, NULL, NULL, NULL) != ERROR_SUCCESS
1188         || len <= 40)
1189     {
1190         WARN("GetAt %u failed\n", prop);
1191         return E_INVALIDARG;
1192     }
1193     RegCloseKey(propkey);
1194     buffer[39] = 0;
1195     CLSIDFromString(buffer, &key->fmtid);
1196     key->pid = atoiW(&buffer[40]);
1197     return S_OK;
1198 }
1199
1200 static HRESULT WINAPI MMDevPropStore_GetValue(IPropertyStore *iface, REFPROPERTYKEY key, PROPVARIANT *pv)
1201 {
1202     MMDevPropStore *This = (MMDevPropStore*)iface;
1203     TRACE("(%p)->(\"%s,%u\", %p\n", This, debugstr_guid(&key->fmtid), key ? key->pid : 0, pv);
1204
1205     if (!key || !pv)
1206         return E_POINTER;
1207     if (This->access != STGM_READ
1208         && This->access != STGM_READWRITE)
1209         return STG_E_ACCESSDENIED;
1210
1211     /* Special case */
1212     if (IsEqualPropertyKey(*key, PKEY_AudioEndpoint_GUID))
1213     {
1214         pv->u.pwszVal = CoTaskMemAlloc(39 * sizeof(WCHAR));
1215         if (!pv->u.pwszVal)
1216             return E_OUTOFMEMORY;
1217         StringFromGUID2(&This->parent->devguid, pv->u.pwszVal, 39);
1218         return S_OK;
1219     }
1220
1221     return MMDevice_GetPropValue(&This->parent->devguid, This->parent->flow, key, pv);
1222 }
1223
1224 static HRESULT WINAPI MMDevPropStore_SetValue(IPropertyStore *iface, REFPROPERTYKEY key, REFPROPVARIANT pv)
1225 {
1226     MMDevPropStore *This = (MMDevPropStore*)iface;
1227
1228     if (!key || !pv)
1229         return E_POINTER;
1230
1231     if (This->access != STGM_WRITE
1232         && This->access != STGM_READWRITE)
1233         return STG_E_ACCESSDENIED;
1234     return MMDevice_SetPropValue(&This->parent->devguid, This->parent->flow, key, pv);
1235 }
1236
1237 static HRESULT WINAPI MMDevPropStore_Commit(IPropertyStore *iface)
1238 {
1239     FIXME("stub\n");
1240     return E_NOTIMPL;
1241 }
1242
1243 static const IPropertyStoreVtbl MMDevPropVtbl =
1244 {
1245     MMDevPropStore_QueryInterface,
1246     MMDevPropStore_AddRef,
1247     MMDevPropStore_Release,
1248     MMDevPropStore_GetCount,
1249     MMDevPropStore_GetAt,
1250     MMDevPropStore_GetValue,
1251     MMDevPropStore_SetValue,
1252     MMDevPropStore_Commit
1253 };
1254
1255
1256 /* Property bag for IBaseFilter activation */
1257 static HRESULT WINAPI PB_QueryInterface(IPropertyBag *iface, REFIID riid, void **ppv)
1258 {
1259     ERR("Should not be called\n");
1260     *ppv = NULL;
1261     return E_NOINTERFACE;
1262 }
1263
1264 static ULONG WINAPI PB_AddRef(IPropertyBag *iface)
1265 {
1266     ERR("Should not be called\n");
1267     return 2;
1268 }
1269
1270 static ULONG WINAPI PB_Release(IPropertyBag *iface)
1271 {
1272     ERR("Should not be called\n");
1273     return 1;
1274 }
1275
1276 static HRESULT WINAPI PB_Read(IPropertyBag *iface, LPCOLESTR name, VARIANT *var, IErrorLog *log)
1277 {
1278     static const WCHAR dsguid[] = { 'D','S','G','u','i','d', 0 };
1279     IPropertyBagImpl *This = (IPropertyBagImpl*)iface;
1280     TRACE("Trying to read %s, type %u\n", debugstr_w(name), var->n1.n2.vt);
1281     if (!lstrcmpW(name, dsguid))
1282     {
1283         WCHAR guidstr[39];
1284         StringFromGUID2(&This->devguid, guidstr,sizeof(guidstr)/sizeof(*guidstr));
1285         var->n1.n2.vt = VT_BSTR;
1286         var->n1.n2.n3.bstrVal = SysAllocString(guidstr);
1287         return S_OK;
1288     }
1289     ERR("Unknown property '%s' queried\n", debugstr_w(name));
1290     return E_FAIL;
1291 }
1292
1293 static HRESULT WINAPI PB_Write(IPropertyBag *iface, LPCOLESTR name, VARIANT *var)
1294 {
1295     ERR("Should not be called\n");
1296     return E_FAIL;
1297 }
1298
1299 static const IPropertyBagVtbl PB_Vtbl =
1300 {
1301     PB_QueryInterface,
1302     PB_AddRef,
1303     PB_Release,
1304     PB_Read,
1305     PB_Write
1306 };