2 * Copyright 2009 Maarten Lankhorst
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.
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.
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
26 #elif defined(HAVE_OPENAL_AL_H)
27 #include <OpenAL/al.h>
28 #include <OpenAL/alc.h>
31 #define NONAMELESSUNION
38 #include "wine/debug.h"
39 #include "wine/unicode.h"
42 #include "mmdeviceapi.h"
45 #include "audioclient.h"
46 #include "endpointvolume.h"
47 #include "audiopolicy.h"
52 WINE_DEFAULT_DEBUG_CHANNEL(mmdevapi);
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 };
70 static HKEY key_render;
71 static HKEY key_capture;
73 typedef struct MMDevPropStoreImpl
75 const IPropertyStoreVtbl *lpVtbl;
81 typedef struct MMDevEnumImpl
83 const IMMDeviceEnumeratorVtbl *lpVtbl;
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;
97 typedef struct MMDevColImpl
99 const IMMDeviceCollectionVtbl *lpVtbl;
105 typedef struct IPropertyBagImpl {
106 const IPropertyBagVtbl *lpVtbl;
109 static const IPropertyBagVtbl PB_Vtbl;
111 static HRESULT MMDevPropStore_Create(MMDevice *This, DWORD access, IPropertyStore **ppv);
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
117 static void MMDevice_Create(MMDevice **dev, WCHAR *name, GUID *id, EDataFlow flow, DWORD state, BOOL setdefault)
124 for (i = 0; i < MMDevice_count; ++i)
126 cur = MMDevice_head[i];
127 if (cur->flow == flow && !lstrcmpW(cur->alname, name))
130 /* Same device, update 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)
136 RegSetValueExW(key, reg_devicestate, 0, REG_DWORD, (const BYTE*)&state, sizeof(DWORD));
143 /* No device found, allocate new one */
144 cur = HeapAlloc(GetProcessHeap(), 0, sizeof(*cur));
147 cur->alname = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(name)+1)*sizeof(WCHAR));
150 HeapFree(GetProcessHeap(), 0, cur);
153 lstrcpyW(cur->alname, name);
154 cur->lpVtbl = &MMDeviceVtbl;
155 cur->lpEndpointVtbl = &MMEndpointVtbl;
157 InitializeCriticalSection(&cur->crst);
158 cur->crst.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": MMDevice.crst");
168 StringFromGUID2(id, guidstr, sizeof(guidstr)/sizeof(*guidstr));
173 if (!RegCreateKeyExW(root, guidstr, 0, NULL, 0, KEY_WRITE|KEY_READ, NULL, &key, NULL))
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))
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);
189 MMDevice_head = HeapAlloc(GetProcessHeap(), 0, sizeof(*MMDevice_head));
191 MMDevice_head = HeapReAlloc(GetProcessHeap(), 0, MMDevice_head, sizeof(*MMDevice_head)*(1+MMDevice_count));
192 MMDevice_head[MMDevice_count++] = cur;
198 MMDevice_def_play = cur;
200 MMDevice_def_rec = cur;
206 static void MMDevice_Destroy(MMDevice *This)
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)
213 if (MMDevice_head[i] == This)
215 MMDevice_head[i] = MMDevice_head[--MMDevice_count];
221 palcCloseDevice(This->device);
223 This->crst.DebugInfo->Spare[0] = 0;
224 DeleteCriticalSection(&This->crst);
225 HeapFree(GetProcessHeap(), 0, This->alname);
226 HeapFree(GetProcessHeap(), 0, This);
229 static HRESULT WINAPI MMDevice_QueryInterface(IMMDevice *iface, REFIID riid, void **ppv)
231 MMDevice *This = (MMDevice *)iface;
232 TRACE("(%p)->(%s,%p)\n", iface, debugstr_guid(riid), ppv);
237 if (IsEqualIID(riid, &IID_IUnknown)
238 || IsEqualIID(riid, &IID_IMMDevice))
240 else if (IsEqualIID(riid, &IID_IMMEndpoint))
241 *ppv = &This->lpEndpointVtbl;
244 IUnknown_AddRef((IUnknown*)*ppv);
247 WARN("Unknown interface %s\n", debugstr_guid(riid));
248 return E_NOINTERFACE;
251 static ULONG WINAPI MMDevice_AddRef(IMMDevice *iface)
253 MMDevice *This = (MMDevice *)iface;
256 ref = InterlockedIncrement(&This->ref);
257 TRACE("Refcount now %i\n", ref);
261 static ULONG WINAPI MMDevice_Release(IMMDevice *iface)
263 MMDevice *This = (MMDevice *)iface;
266 ref = InterlockedDecrement(&This->ref);
267 TRACE("Refcount now %i\n", ref);
271 static HRESULT WINAPI MMDevice_Activate(IMMDevice *iface, REFIID riid, DWORD clsctx, PROPVARIANT *params, void **ppv)
273 HRESULT hr = E_NOINTERFACE;
276 MMDevice *This = (MMDevice *)iface;
278 TRACE("(%p)->(%p,%x,%p,%p)\n", iface, riid, clsctx, params, ppv);
285 WARN("OpenAL is still not loaded\n");
286 hr = AUDCLNT_E_SERVICE_NOT_RUNNING;
288 else if (IsEqualIID(riid, &IID_IAudioClient))
289 hr = AudioClient_Create(This, (IAudioClient**)ppv);
290 else if (IsEqualIID(riid, &IID_IAudioEndpointVolume))
291 hr = AudioEndpointVolume_Create(This, (IAudioEndpointVolume**)ppv);
292 else if (IsEqualIID(riid, &IID_IAudioSessionManager)
293 || IsEqualIID(riid, &IID_IAudioSessionManager2))
295 FIXME("IID_IAudioSessionManager unsupported\n");
297 else if (IsEqualIID(riid, &IID_IBaseFilter))
299 if (This->flow == eRender)
300 hr = CoCreateInstance(&CLSID_DSoundRender, NULL, clsctx, riid, ppv);
302 ERR("Not supported for recording?\n");
305 IPersistPropertyBag *ppb;
306 hr = IUnknown_QueryInterface((IUnknown*)*ppv, &IID_IPersistPropertyBag, (void*)&ppb);
309 /* ::Load cannot assume the interface stays alive after the function returns,
310 * so just create the interface on the stack, saves a lot of complicated code */
311 IPropertyBagImpl bag = { &PB_Vtbl, This->devguid };
312 hr = IPersistPropertyBag_Load(ppb, (IPropertyBag*)&bag, NULL);
313 IPersistPropertyBag_Release(ppb);
315 IBaseFilter_Release((IBaseFilter*)*ppv);
319 FIXME("Wine doesn't support IPersistPropertyBag on DSoundRender yet, ignoring..\n");
324 else if (IsEqualIID(riid, &IID_IDeviceTopology))
326 FIXME("IID_IDeviceTopology unsupported\n");
328 else if (IsEqualIID(riid, &IID_IDirectSound)
329 || IsEqualIID(riid, &IID_IDirectSound8))
331 if (This->flow == eRender)
332 hr = CoCreateInstance(&CLSID_DirectSound8, NULL, clsctx, riid, ppv);
335 hr = IDirectSound_Initialize((IDirectSound*)*ppv, &This->devguid);
337 IDirectSound_Release((IDirectSound*)*ppv);
340 else if (IsEqualIID(riid, &IID_IDirectSoundCapture)
341 || IsEqualIID(riid, &IID_IDirectSoundCapture8))
343 if (This->flow == eCapture)
344 hr = CoCreateInstance(&CLSID_DirectSoundCapture8, NULL, clsctx, riid, ppv);
347 hr = IDirectSoundCapture_Initialize((IDirectSoundCapture*)*ppv, &This->devguid);
349 IDirectSoundCapture_Release((IDirectSoundCapture*)*ppv);
353 ERR("Invalid/unknown iid %s\n", debugstr_guid(riid));
355 if (!ppv) return E_POINTER;
356 hr = AUDCLNT_E_SERVICE_NOT_RUNNING;
362 TRACE("Returning %08x\n", hr);
366 static HRESULT WINAPI MMDevice_OpenPropertyStore(IMMDevice *iface, DWORD access, IPropertyStore **ppv)
368 MMDevice *This = (MMDevice *)iface;
369 TRACE("(%p)->(%x,%p)\n", This, access, ppv);
373 return MMDevPropStore_Create(This, access, ppv);
376 static HRESULT WINAPI MMDevice_GetId(IMMDevice *iface, WCHAR **itemid)
378 MMDevice *This = (MMDevice *)iface;
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 };
387 TRACE("(%p)->(%p)\n", This, itemid);
390 *itemid = str = CoTaskMemAlloc(56 * sizeof(WCHAR));
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] );
399 static HRESULT WINAPI MMDevice_GetState(IMMDevice *iface, DWORD *state)
401 MMDevice *This = (MMDevice *)iface;
402 TRACE("(%p)->(%p)\n", iface, state);
406 *state = This->state;
410 static const IMMDeviceVtbl MMDeviceVtbl =
412 MMDevice_QueryInterface,
416 MMDevice_OpenPropertyStore,
421 static MMDevice *get_this_from_endpoint(IMMEndpoint *iface)
423 return (MMDevice*)((char*)iface - offsetof(MMDevice,lpEndpointVtbl));
426 static HRESULT WINAPI MMEndpoint_QueryInterface(IMMEndpoint *iface, REFIID riid, void **ppv)
428 MMDevice *This = get_this_from_endpoint(iface);
429 return IMMDevice_QueryInterface((IMMDevice*)This, riid, ppv);
432 static ULONG WINAPI MMEndpoint_AddRef(IMMEndpoint *iface)
434 MMDevice *This = get_this_from_endpoint(iface);
435 return IMMDevice_AddRef((IMMDevice*)This);
438 static ULONG WINAPI MMEndpoint_Release(IMMEndpoint *iface)
440 MMDevice *This = get_this_from_endpoint(iface);
441 return IMMDevice_Release((IMMDevice*)This);
444 static HRESULT WINAPI MMEndpoint_GetDataFlow(IMMEndpoint *iface, EDataFlow *flow)
446 MMDevice *This = get_this_from_endpoint(iface);
453 static const IMMEndpointVtbl MMEndpointVtbl =
455 MMEndpoint_QueryInterface,
458 MMEndpoint_GetDataFlow
461 static HRESULT MMDevCol_Create(IMMDeviceCollection **ppv, EDataFlow flow, DWORD state)
465 This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
468 return E_OUTOFMEMORY;
469 This->lpVtbl = &MMDevColVtbl;
473 *ppv = (IMMDeviceCollection*)This;
477 static void MMDevCol_Destroy(MMDevColImpl *This)
479 HeapFree(GetProcessHeap(), 0, This);
482 static HRESULT WINAPI MMDevCol_QueryInterface(IMMDeviceCollection *iface, REFIID riid, void **ppv)
484 MMDevColImpl *This = (MMDevColImpl*)iface;
488 if (IsEqualIID(riid, &IID_IUnknown)
489 || IsEqualIID(riid, &IID_IMMDeviceCollection))
494 return E_NOINTERFACE;
495 IUnknown_AddRef((IUnknown*)*ppv);
499 static ULONG WINAPI MMDevCol_AddRef(IMMDeviceCollection *iface)
501 MMDevColImpl *This = (MMDevColImpl*)iface;
502 LONG ref = InterlockedIncrement(&This->ref);
503 TRACE("Refcount now %i\n", ref);
507 static ULONG WINAPI MMDevCol_Release(IMMDeviceCollection *iface)
509 MMDevColImpl *This = (MMDevColImpl*)iface;
510 LONG ref = InterlockedDecrement(&This->ref);
511 TRACE("Refcount now %i\n", ref);
513 MMDevCol_Destroy(This);
517 static HRESULT WINAPI MMDevCol_GetCount(IMMDeviceCollection *iface, UINT *numdevs)
519 MMDevColImpl *This = (MMDevColImpl*)iface;
522 TRACE("(%p)->(%p)\n", This, numdevs);
527 for (i = 0; i < MMDevice_count; ++i)
529 MMDevice *cur = MMDevice_head[i];
530 if ((cur->flow == This->flow || This->flow == eAll)
531 && (cur->state & This->state))
537 static HRESULT WINAPI MMDevCol_Item(IMMDeviceCollection *iface, UINT n, IMMDevice **dev)
539 MMDevColImpl *This = (MMDevColImpl*)iface;
542 TRACE("(%p)->(%u, %p)\n", This, n, dev);
546 for (j = 0; j < MMDevice_count; ++j)
548 MMDevice *cur = MMDevice_head[j];
549 if ((cur->flow == This->flow || This->flow == eAll)
550 && (cur->state & This->state)
553 *dev = (IMMDevice *)cur;
554 IMMDevice_AddRef(*dev);
558 WARN("Could not obtain item %u\n", n);
563 static const IMMDeviceCollectionVtbl MMDevColVtbl =
565 MMDevCol_QueryInterface,
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 };
578 static HRESULT MMDevPropStore_OpenPropKey(const GUID *guid, DWORD flow, HKEY *propkey)
583 StringFromGUID2(guid, buffer, 39);
584 if ((ret = RegOpenKeyExW(flow == eRender ? key_render : key_capture, buffer, 0, KEY_READ|KEY_WRITE, &key)) != ERROR_SUCCESS)
586 WARN("Opening key %s failed with %u\n", debugstr_w(buffer), ret);
589 ret = RegOpenKeyExW(key, reg_properties, 0, KEY_READ|KEY_WRITE, propkey);
591 if (ret != ERROR_SUCCESS)
593 WARN("Opening key %s failed with %u\n", debugstr_w(reg_properties), ret);
599 HRESULT MMDevice_GetPropValue(const GUID *devguid, DWORD flow, REFPROPERTYKEY key, PROPVARIANT *pv)
602 const GUID *id = &key->fmtid;
608 hr = MMDevPropStore_OpenPropKey(devguid, flow, ®key);
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)
617 WARN("Reading %s returned %d\n", debugstr_w(buffer), ret);
619 PropVariantClear(pv);
628 pv->u.pwszVal = CoTaskMemAlloc(size);
632 RegGetValueW(regkey, NULL, buffer, RRF_RT_REG_SZ, NULL, (BYTE*)pv->u.pwszVal, &size);
638 RegGetValueW(regkey, NULL, buffer, RRF_RT_REG_DWORD, NULL, (BYTE*)&pv->u.ulVal, &size);
644 pv->u.blob.cbSize = size;
645 pv->u.blob.pBlobData = CoTaskMemAlloc(size);
646 if (!pv->u.blob.pBlobData)
649 RegGetValueW(regkey, NULL, buffer, RRF_RT_REG_BINARY, NULL, (BYTE*)pv->u.blob.pBlobData, &size);
653 ERR("Unknown/unhandled type: %u\n", type);
654 PropVariantClear(pv);
661 HRESULT MMDevice_SetPropValue(const GUID *devguid, DWORD flow, REFPROPERTYKEY key, REFPROPVARIANT pv)
664 const GUID *id = &key->fmtid;
669 hr = MMDevPropStore_OpenPropKey(devguid, flow, ®key);
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 );
679 ret = RegSetValueExW(regkey, buffer, 0, REG_DWORD, (const BYTE*)&pv->u.ulVal, sizeof(DWORD));
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);
691 ret = RegSetValueExW(regkey, buffer, 0, REG_SZ, (const BYTE*)pv->u.pwszVal, sizeof(WCHAR)*(1+lstrlenW(pv->u.pwszVal)));
696 FIXME("Unhandled type %u\n", pv->vt);
701 TRACE("Writing %s returned %u\n", debugstr_w(buffer), ret);
707 static void openal_setformat(MMDevice *This, DWORD freq)
710 PROPVARIANT pv = { VT_EMPTY };
712 hr = MMDevice_GetPropValue(&This->devguid, This->flow, &PKEY_AudioEngine_DeviceFormat, &pv);
713 if (SUCCEEDED(hr) && pv.vt == VT_BLOB)
716 pwfx = (WAVEFORMATEX*)pv.u.blob.pBlobData;
717 if (pwfx->nSamplesPerSec != freq)
719 pwfx->nSamplesPerSec = freq;
720 pwfx->nAvgBytesPerSec = freq * pwfx->nBlockAlign;
721 MMDevice_SetPropValue(&This->devguid, This->flow, &PKEY_AudioEngine_DeviceFormat, &pv);
727 WAVEFORMATEXTENSIBLE wfxe;
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;
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);
748 static int blacklist_pulse;
750 static int blacklist(const char *dev) {
752 if (!strncmp(dev, "OSS ", 4))
755 if (blacklist_pulse && !strncmp(dev, "PulseAudio ", 11))
757 if (!strncmp(dev, "ALSA ", 5) && strstr(dev, "hw:"))
762 static void pulse_fixup(const char *devstr, const char **defstr, int render) {
766 if (render && !blacklist_pulse && !local_contexts)
769 if (!blacklist_pulse || !devstr || !*devstr)
772 default_pulse = !strncmp(*defstr, "PulseAudio ", 11);
774 while (*devstr && !strncmp(devstr, "PulseAudio ", 11))
775 devstr += strlen(devstr) + 1;
777 /* Could still be a newer version, so check for 1.11 if more devices are enabled */
778 if (render && *devstr) {
779 ALCdevice *dev = palcOpenDevice(devstr);
780 ALCcontext *ctx = palcCreateContext(dev, NULL);
785 ver = palGetString(AL_VERSION);
787 palcDestroyContext(ctx);
789 if (!strcmp(ver, "1.1 ALSOFT 1.11.753")) {
791 palcCloseDevice(dev);
796 palcCloseDevice(dev);
800 ERR("Disabling pulseaudio because of old openal version\n");
801 ERR("Please upgrade to openal-soft v1.12 or newer\n");
803 TRACE("New default: %s\n", devstr);
808 static void openal_scanrender(void)
810 WCHAR name[MAX_PATH];
812 const ALCchar *devstr, *defaultstr;
814 EnterCriticalSection(&openal_crst);
815 if (palcIsExtensionPresent(NULL, "ALC_ENUMERATE_ALL_EXT")) {
816 defaultstr = palcGetString(NULL, ALC_DEFAULT_ALL_DEVICES_SPECIFIER);
817 devstr = palcGetString(NULL, ALC_ALL_DEVICES_SPECIFIER);
819 defaultstr = palcGetString(NULL, ALC_DEFAULT_DEVICE_SPECIFIER);
820 devstr = palcGetString(NULL, ALC_DEVICE_SPECIFIER);
822 pulse_fixup(devstr, &defaultstr, 1);
823 defblacklisted = blacklist(defaultstr);
825 WARN("Disabling blacklist because %s is blacklisted\n", defaultstr);
827 for (; *devstr; devstr += strlen(devstr)+1) {
829 MultiByteToWideChar( CP_UNIXCP, 0, devstr, -1,
830 name, sizeof(name)/sizeof(*name)-1 );
831 name[sizeof(name)/sizeof(*name)-1] = 0;
832 /* Only enable blacklist if the default device isn't blacklisted */
833 if (!defblacklisted && blacklist(devstr)) {
834 WARN("Not adding %s: device is blacklisted\n", devstr);
837 TRACE("Adding %s\n", devstr);
838 dev = palcOpenDevice(devstr);
839 MMDevice_Create(&mmdev, name, NULL, eRender, dev ? DEVICE_STATE_ACTIVE : DEVICE_STATE_NOTPRESENT, !strcmp(devstr, defaultstr));
843 palcGetIntegerv(dev, ALC_FREQUENCY, 1, &freq);
844 openal_setformat(mmdev, freq);
845 palcCloseDevice(dev);
848 WARN("Could not open device: %04x\n", palcGetError(NULL));
850 LeaveCriticalSection(&openal_crst);
853 static void openal_scancapture(void)
855 WCHAR name[MAX_PATH];
857 const ALCchar *devstr, *defaultstr;
860 EnterCriticalSection(&openal_crst);
861 devstr = palcGetString(NULL, ALC_CAPTURE_DEVICE_SPECIFIER);
862 defaultstr = palcGetString(NULL, ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER);
863 pulse_fixup(devstr, &defaultstr, 0);
864 defblacklisted = blacklist(defaultstr);
866 WARN("Disabling blacklist because %s is blacklisted\n", defaultstr);
867 if (devstr && *devstr)
868 for (; *devstr; devstr += strlen(devstr)+1) {
871 MultiByteToWideChar( CP_UNIXCP, 0, devstr, -1,
872 name, sizeof(name)/sizeof(*name)-1 );
873 name[sizeof(name)/sizeof(*name)-1] = 0;
874 if (!defblacklisted && blacklist(devstr)) {
875 WARN("Not adding %s: device is blacklisted\n", devstr);
878 TRACE("Adding %s\n", devstr);
879 dev = palcCaptureOpenDevice(devstr, freq, AL_FORMAT_MONO16, 65536);
880 MMDevice_Create(&mmdev, name, NULL, eCapture, dev ? DEVICE_STATE_ACTIVE : DEVICE_STATE_NOTPRESENT, !strcmp(devstr, defaultstr));
882 openal_setformat(mmdev, freq);
883 palcCaptureCloseDevice(dev);
885 WARN("Could not open device: %04x\n", palcGetError(NULL));
887 LeaveCriticalSection(&openal_crst);
889 #endif /*HAVE_OPENAL*/
891 HRESULT MMDevEnum_Create(REFIID riid, void **ppv)
893 MMDevEnumImpl *This = MMDevEnumerator;
902 This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
905 return E_OUTOFMEMORY;
907 This->lpVtbl = &MMDevEnumVtbl;
908 MMDevEnumerator = This;
910 ret = RegCreateKeyExW(HKEY_LOCAL_MACHINE, software_mmdevapi, 0, NULL, 0, KEY_WRITE|KEY_READ, NULL, &root, NULL);
911 if (ret == ERROR_SUCCESS)
912 ret = RegCreateKeyExW(root, reg_capture, 0, NULL, 0, KEY_READ|KEY_WRITE, NULL, &key_capture, NULL);
913 if (ret == ERROR_SUCCESS)
914 ret = RegCreateKeyExW(root, reg_render, 0, NULL, 0, KEY_READ|KEY_WRITE, NULL, &key_render, NULL);
918 if (ret != ERROR_SUCCESS)
920 RegCloseKey(key_capture);
921 key_render = key_capture = NULL;
922 WARN("Couldn't create key: %u\n", ret);
929 PROPVARIANT pv = { VT_EMPTY };
931 len = sizeof(guidvalue);
932 ret = RegEnumKeyExW(cur, i++, guidvalue, &len, NULL, NULL, NULL, NULL);
933 if (ret == ERROR_NO_MORE_ITEMS)
935 if (cur == key_capture)
944 if (ret != ERROR_SUCCESS)
946 if (SUCCEEDED(CLSIDFromString(guidvalue, &guid))
947 && SUCCEEDED(MMDevice_GetPropValue(&guid, curflow, (const PROPERTYKEY*)&DEVPKEY_Device_FriendlyName, &pv))
948 && pv.vt == VT_LPWSTR)
950 MMDevice_Create(NULL, pv.u.pwszVal, &guid, curflow,
951 DEVICE_STATE_NOTPRESENT, FALSE);
952 CoTaskMemFree(pv.u.pwszVal);
959 openal_scancapture();
962 FIXME("OpenAL support not enabled, application will not find sound devices\n");
964 ERR("OpenAL support not compiled in, application will not find sound devices\n");
965 #endif /*HAVE_OPENAL*/
967 return IUnknown_QueryInterface((IUnknown*)This, riid, ppv);
970 void MMDevEnum_Free(void)
972 while (MMDevice_count)
973 MMDevice_Destroy(MMDevice_head[0]);
974 RegCloseKey(key_render);
975 RegCloseKey(key_capture);
976 key_render = key_capture = NULL;
977 HeapFree(GetProcessHeap(), 0, MMDevEnumerator);
978 MMDevEnumerator = NULL;
981 static HRESULT WINAPI MMDevEnum_QueryInterface(IMMDeviceEnumerator *iface, REFIID riid, void **ppv)
983 MMDevEnumImpl *This = (MMDevEnumImpl*)iface;
987 if (IsEqualIID(riid, &IID_IUnknown)
988 || IsEqualIID(riid, &IID_IMMDeviceEnumerator))
993 return E_NOINTERFACE;
994 IUnknown_AddRef((IUnknown*)*ppv);
998 static ULONG WINAPI MMDevEnum_AddRef(IMMDeviceEnumerator *iface)
1000 MMDevEnumImpl *This = (MMDevEnumImpl*)iface;
1001 LONG ref = InterlockedIncrement(&This->ref);
1002 TRACE("Refcount now %i\n", ref);
1006 static ULONG WINAPI MMDevEnum_Release(IMMDeviceEnumerator *iface)
1008 MMDevEnumImpl *This = (MMDevEnumImpl*)iface;
1009 LONG ref = InterlockedDecrement(&This->ref);
1012 TRACE("Refcount now %i\n", ref);
1016 static HRESULT WINAPI MMDevEnum_EnumAudioEndpoints(IMMDeviceEnumerator *iface, EDataFlow flow, DWORD mask, IMMDeviceCollection **devices)
1018 MMDevEnumImpl *This = (MMDevEnumImpl*)iface;
1019 TRACE("(%p)->(%u,%u,%p)\n", This, flow, mask, devices);
1023 if (flow >= EDataFlow_enum_count)
1024 return E_INVALIDARG;
1025 if (mask & ~DEVICE_STATEMASK_ALL)
1026 return E_INVALIDARG;
1027 return MMDevCol_Create(devices, flow, mask);
1030 static HRESULT WINAPI MMDevEnum_GetDefaultAudioEndpoint(IMMDeviceEnumerator *iface, EDataFlow flow, ERole role, IMMDevice **device)
1032 MMDevEnumImpl *This = (MMDevEnumImpl*)iface;
1033 TRACE("(%p)->(%u,%u,%p)\n", This, flow, role, device);
1039 if (flow == eRender)
1040 *device = (IMMDevice*)MMDevice_def_play;
1041 else if (flow == eCapture)
1042 *device = (IMMDevice*)MMDevice_def_rec;
1045 WARN("Unknown flow %u\n", flow);
1046 return E_INVALIDARG;
1051 IMMDevice_AddRef(*device);
1055 static HRESULT WINAPI MMDevEnum_GetDevice(IMMDeviceEnumerator *iface, const WCHAR *name, IMMDevice **device)
1057 MMDevEnumImpl *This = (MMDevEnumImpl*)iface;
1059 IMMDevice *dev = NULL;
1061 TRACE("(%p)->(%s,%p)\n", This, debugstr_w(name), device);
1062 for (i = 0; i < MMDevice_count; ++i)
1065 dev = (IMMDevice*)MMDevice_head[i];
1066 IMMDevice_GetId(dev, &str);
1068 if (str && !lstrcmpW(str, name))
1077 IUnknown_AddRef(dev);
1081 WARN("Could not find device %s\n", debugstr_w(name));
1085 static HRESULT WINAPI MMDevEnum_RegisterEndpointNotificationCallback(IMMDeviceEnumerator *iface, IMMNotificationClient *client)
1087 MMDevEnumImpl *This = (MMDevEnumImpl*)iface;
1088 TRACE("(%p)->(%p)\n", This, client);
1093 static HRESULT WINAPI MMDevEnum_UnregisterEndpointNotificationCallback(IMMDeviceEnumerator *iface, IMMNotificationClient *client)
1095 MMDevEnumImpl *This = (MMDevEnumImpl*)iface;
1096 TRACE("(%p)->(%p)\n", This, client);
1101 static const IMMDeviceEnumeratorVtbl MMDevEnumVtbl =
1103 MMDevEnum_QueryInterface,
1106 MMDevEnum_EnumAudioEndpoints,
1107 MMDevEnum_GetDefaultAudioEndpoint,
1108 MMDevEnum_GetDevice,
1109 MMDevEnum_RegisterEndpointNotificationCallback,
1110 MMDevEnum_UnregisterEndpointNotificationCallback
1113 static HRESULT MMDevPropStore_Create(MMDevice *parent, DWORD access, IPropertyStore **ppv)
1115 MMDevPropStore *This;
1116 if (access != STGM_READ
1117 && access != STGM_WRITE
1118 && access != STGM_READWRITE)
1120 WARN("Invalid access %08x\n", access);
1121 return E_INVALIDARG;
1123 This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
1124 *ppv = (IPropertyStore*)This;
1126 return E_OUTOFMEMORY;
1127 This->lpVtbl = &MMDevPropVtbl;
1129 This->parent = parent;
1130 This->access = access;
1134 static void MMDevPropStore_Destroy(MMDevPropStore *This)
1136 HeapFree(GetProcessHeap(), 0, This);
1139 static HRESULT WINAPI MMDevPropStore_QueryInterface(IPropertyStore *iface, REFIID riid, void **ppv)
1141 MMDevPropStore *This = (MMDevPropStore*)iface;
1145 if (IsEqualIID(riid, &IID_IUnknown)
1146 || IsEqualIID(riid, &IID_IPropertyStore))
1151 return E_NOINTERFACE;
1152 IUnknown_AddRef((IUnknown*)*ppv);
1156 static ULONG WINAPI MMDevPropStore_AddRef(IPropertyStore *iface)
1158 MMDevPropStore *This = (MMDevPropStore*)iface;
1159 LONG ref = InterlockedIncrement(&This->ref);
1160 TRACE("Refcount now %i\n", ref);
1164 static ULONG WINAPI MMDevPropStore_Release(IPropertyStore *iface)
1166 MMDevPropStore *This = (MMDevPropStore*)iface;
1167 LONG ref = InterlockedDecrement(&This->ref);
1168 TRACE("Refcount now %i\n", ref);
1170 MMDevPropStore_Destroy(This);
1174 static HRESULT WINAPI MMDevPropStore_GetCount(IPropertyStore *iface, DWORD *nprops)
1176 MMDevPropStore *This = (MMDevPropStore*)iface;
1182 TRACE("(%p)->(%p)\n", iface, nprops);
1185 hr = MMDevPropStore_OpenPropKey(&This->parent->devguid, This->parent->flow, &propkey);
1190 DWORD len = sizeof(buffer)/sizeof(*buffer);
1191 if (RegEnumKeyExW(propkey, i, buffer, &len, NULL, NULL, NULL, NULL) != ERROR_SUCCESS)
1195 RegCloseKey(propkey);
1196 TRACE("Returning %i\n", i);
1201 static HRESULT WINAPI MMDevPropStore_GetAt(IPropertyStore *iface, DWORD prop, PROPERTYKEY *key)
1203 MMDevPropStore *This = (MMDevPropStore*)iface;
1205 DWORD len = sizeof(buffer)/sizeof(*buffer);
1209 TRACE("(%p)->(%u,%p)\n", iface, prop, key);
1213 hr = MMDevPropStore_OpenPropKey(&This->parent->devguid, This->parent->flow, &propkey);
1217 if (RegEnumKeyExW(propkey, prop, buffer, &len, NULL, NULL, NULL, NULL) != ERROR_SUCCESS
1220 WARN("GetAt %u failed\n", prop);
1221 return E_INVALIDARG;
1223 RegCloseKey(propkey);
1225 CLSIDFromString(buffer, &key->fmtid);
1226 key->pid = atoiW(&buffer[40]);
1230 static HRESULT WINAPI MMDevPropStore_GetValue(IPropertyStore *iface, REFPROPERTYKEY key, PROPVARIANT *pv)
1232 MMDevPropStore *This = (MMDevPropStore*)iface;
1233 TRACE("(%p)->(\"%s,%u\", %p\n", This, debugstr_guid(&key->fmtid), key ? key->pid : 0, pv);
1237 if (This->access != STGM_READ
1238 && This->access != STGM_READWRITE)
1239 return STG_E_ACCESSDENIED;
1242 if (IsEqualPropertyKey(*key, PKEY_AudioEndpoint_GUID))
1245 pv->u.pwszVal = CoTaskMemAlloc(39 * sizeof(WCHAR));
1247 return E_OUTOFMEMORY;
1248 StringFromGUID2(&This->parent->devguid, pv->u.pwszVal, 39);
1252 return MMDevice_GetPropValue(&This->parent->devguid, This->parent->flow, key, pv);
1255 static HRESULT WINAPI MMDevPropStore_SetValue(IPropertyStore *iface, REFPROPERTYKEY key, REFPROPVARIANT pv)
1257 MMDevPropStore *This = (MMDevPropStore*)iface;
1262 if (This->access != STGM_WRITE
1263 && This->access != STGM_READWRITE)
1264 return STG_E_ACCESSDENIED;
1265 return MMDevice_SetPropValue(&This->parent->devguid, This->parent->flow, key, pv);
1268 static HRESULT WINAPI MMDevPropStore_Commit(IPropertyStore *iface)
1274 static const IPropertyStoreVtbl MMDevPropVtbl =
1276 MMDevPropStore_QueryInterface,
1277 MMDevPropStore_AddRef,
1278 MMDevPropStore_Release,
1279 MMDevPropStore_GetCount,
1280 MMDevPropStore_GetAt,
1281 MMDevPropStore_GetValue,
1282 MMDevPropStore_SetValue,
1283 MMDevPropStore_Commit
1287 /* Property bag for IBaseFilter activation */
1288 static HRESULT WINAPI PB_QueryInterface(IPropertyBag *iface, REFIID riid, void **ppv)
1290 ERR("Should not be called\n");
1292 return E_NOINTERFACE;
1295 static ULONG WINAPI PB_AddRef(IPropertyBag *iface)
1297 ERR("Should not be called\n");
1301 static ULONG WINAPI PB_Release(IPropertyBag *iface)
1303 ERR("Should not be called\n");
1307 static HRESULT WINAPI PB_Read(IPropertyBag *iface, LPCOLESTR name, VARIANT *var, IErrorLog *log)
1309 static const WCHAR dsguid[] = { 'D','S','G','u','i','d', 0 };
1310 IPropertyBagImpl *This = (IPropertyBagImpl*)iface;
1311 TRACE("Trying to read %s, type %u\n", debugstr_w(name), var->n1.n2.vt);
1312 if (!lstrcmpW(name, dsguid))
1315 StringFromGUID2(&This->devguid, guidstr,sizeof(guidstr)/sizeof(*guidstr));
1316 var->n1.n2.vt = VT_BSTR;
1317 var->n1.n2.n3.bstrVal = SysAllocString(guidstr);
1320 ERR("Unknown property '%s' queried\n", debugstr_w(name));
1324 static HRESULT WINAPI PB_Write(IPropertyBag *iface, LPCOLESTR name, VARIANT *var)
1326 ERR("Should not be called\n");
1330 static const IPropertyBagVtbl PB_Vtbl =