/***************************************************************************
* GetDeviceID [DSOUND.9]
*
* Retrieves unique identifier of default device specified
*
* PARAMS
* pGuidSrc [I] Address of device GUID.
* pGuidDest [O] Address to receive unique device GUID.
*
* RETURNS
* Success: DS_OK
* Failure: DSERR_INVALIDPARAM
*
* NOTES
* pGuidSrc is a valid device GUID or DSDEVID_DefaultPlayback,
* DSDEVID_DefaultCapture, DSDEVID_DefaultVoicePlayback, or
* DSDEVID_DefaultVoiceCapture.
* Returns pGuidSrc if pGuidSrc is a valid device or the device
* GUID for the specified constants.
*/
HRESULT WINAPI GetDeviceID(LPCGUID pGuidSrc, LPGUID pGuidDest)
{
IMMDeviceEnumerator *devenum;
EDataFlow flow = (EDataFlow)-1;
ERole role = (ERole)-1;
HRESULT hr, init_hr;
TRACE("(%s,%p)\n", get_device_id(pGuidSrc),pGuidDest);
if(!pGuidSrc || !pGuidDest)
return DSERR_INVALIDPARAM;
init_hr = get_mmdevenum(&devenum);
if(!devenum)
return init_hr;
if(IsEqualGUID(&DSDEVID_DefaultPlayback, pGuidSrc)){
role = eMultimedia;
flow = eRender;
}else if(IsEqualGUID(&DSDEVID_DefaultVoicePlayback, pGuidSrc)){
role = eCommunications;
flow = eRender;
}else if(IsEqualGUID(&DSDEVID_DefaultCapture, pGuidSrc)){
role = eMultimedia;
flow = eCapture;
}else if(IsEqualGUID(&DSDEVID_DefaultVoiceCapture, pGuidSrc)){
role = eCommunications;
flow = eCapture;
}
if(role != (ERole)-1 && flow != (EDataFlow)-1){
IMMDevice *device;
hr = IMMDeviceEnumerator_GetDefaultAudioEndpoint(devenum,
flow, role, &device);
if(FAILED(hr)){
WARN("GetDefaultAudioEndpoint failed: %08x\n", hr);
release_mmdevenum(devenum, init_hr);
return DSERR_NODRIVER;
}
hr = get_mmdevice_guid(device, NULL, pGuidDest);
IMMDevice_Release(device);
release_mmdevenum(devenum, init_hr);
return (hr == S_OK) ? DS_OK : hr;
}
release_mmdevenum(devenum, init_hr);
*pGuidDest = *pGuidSrc;
return DS_OK;
}
static DevMap *ProbeDevices(IMMDeviceEnumerator *devenum, EDataFlow flowdir, ALuint *numdevs)
{
IMMDeviceCollection *coll;
IMMDevice *defdev = NULL;
DevMap *devlist = NULL;
HRESULT hr;
UINT count;
UINT idx;
UINT i;
hr = IMMDeviceEnumerator_EnumAudioEndpoints(devenum, flowdir, DEVICE_STATE_ACTIVE, &coll);
if(FAILED(hr))
{
ERR("Failed to enumerate audio endpoints: 0x%08lx\n", hr);
return NULL;
}
idx = count = 0;
hr = IMMDeviceCollection_GetCount(coll, &count);
if(SUCCEEDED(hr) && count > 0)
{
devlist = calloc(count, sizeof(*devlist));
if(!devlist)
{
IMMDeviceCollection_Release(coll);
return NULL;
}
hr = IMMDeviceEnumerator_GetDefaultAudioEndpoint(devenum, flowdir,
eMultimedia, &defdev);
}
if(SUCCEEDED(hr) && defdev != NULL)
add_device(defdev, &devlist[idx++]);
for(i = 0;i < count && idx < count;++i)
{
IMMDevice *device;
if(FAILED(IMMDeviceCollection_Item(coll, i, &device)))
continue;
if(device != defdev)
add_device(device, &devlist[idx++]);
IMMDevice_Release(device);
}
if(defdev) IMMDevice_Release(defdev);
IMMDeviceCollection_Release(coll);
*numdevs = idx;
return devlist;
}
static HRESULT probe_devices(IMMDeviceEnumerator *devenum, EDataFlow flowdir, vector_DevMap *list)
{
IMMDeviceCollection *coll;
IMMDevice *defdev = NULL;
HRESULT hr;
UINT count;
UINT i;
hr = IMMDeviceEnumerator_EnumAudioEndpoints(devenum, flowdir, DEVICE_STATE_ACTIVE, &coll);
if(FAILED(hr))
{
ERR("Failed to enumerate audio endpoints: 0x%08lx\n", hr);
return hr;
}
count = 0;
hr = IMMDeviceCollection_GetCount(coll, &count);
if(SUCCEEDED(hr) && count > 0)
{
clear_devlist(list);
if(!VECTOR_RESERVE(*list, count+1))
{
IMMDeviceCollection_Release(coll);
return E_OUTOFMEMORY;
}
hr = IMMDeviceEnumerator_GetDefaultAudioEndpoint(devenum, flowdir,
eMultimedia, &defdev);
}
if(SUCCEEDED(hr) && defdev != NULL)
add_device(defdev, list);
for(i = 0;i < count;++i)
{
IMMDevice *device;
if(FAILED(IMMDeviceCollection_Item(coll, i, &device)))
continue;
if(device != defdev)
add_device(device, list);
IMMDevice_Release(device);
}
if(defdev) IMMDevice_Release(defdev);
IMMDeviceCollection_Release(coll);
return S_OK;
}
static void test_first_device(void)
{
IMMDeviceEnumerator *devenum;
IMMDevice *defdev;
IPropertyStore *ps;
PROPVARIANT pv;
HRESULT hr;
hr = CoCreateInstance(&CLSID_MMDeviceEnumerator, NULL,
CLSCTX_INPROC_SERVER, &IID_IMMDeviceEnumerator, (void**)&devenum);
if(FAILED(hr)){
win_skip("MMDevAPI is not available, skipping default device test\n");
return;
}
hr = IMMDeviceEnumerator_GetDefaultAudioEndpoint(devenum, eRender,
eMultimedia, &defdev);
if (hr == E_NOTFOUND) {
win_skip("No default device found\n");
return;
}
ok(hr == S_OK, "GetDefaultAudioEndpoint failed: %08x\n", hr);
hr = IMMDevice_OpenPropertyStore(defdev, STGM_READ, &ps);
ok(hr == S_OK, "OpenPropertyStore failed: %08x\n", hr);
PropVariantInit(&pv);
hr = IPropertyStore_GetValue(ps, &PKEY_AudioEndpoint_GUID, &pv);
ok(hr == S_OK, "GetValue failed: %08x\n", hr);
CLSIDFromString(pv.u.pwszVal, &default_info.guid);
PropVariantClear(&pv);
IPropertyStore_Release(ps);
IMMDevice_Release(defdev);
IMMDeviceEnumerator_Release(devenum);
hr = pDirectSoundEnumerateA(&default_device_cb, NULL);
ok(hr == S_OK, "DirectSoundEnumerateA failed: %08x\n", hr);
}
/* S_FALSE means the callback returned FALSE at some point
* S_OK means the callback always returned TRUE */
HRESULT enumerate_mmdevices(EDataFlow flow, GUID *guids,
LPDSENUMCALLBACKW cb, void *user)
{
IMMDeviceEnumerator *devenum;
IMMDeviceCollection *coll;
IMMDevice *defdev = NULL;
UINT count, i, n;
BOOL keep_going;
HRESULT hr, init_hr;
static const WCHAR primary_desc[] = {'P','r','i','m','a','r','y',' ',
'S','o','u','n','d',' ','D','r','i','v','e','r',0};
static const WCHAR empty_drv[] = {0};
init_hr = get_mmdevenum(&devenum);
if(!devenum)
return init_hr;
hr = IMMDeviceEnumerator_EnumAudioEndpoints(devenum, flow,
DEVICE_STATE_ACTIVE, &coll);
if(FAILED(hr)){
release_mmdevenum(devenum, init_hr);
WARN("EnumAudioEndpoints failed: %08x\n", hr);
return DS_OK;
}
hr = IMMDeviceCollection_GetCount(coll, &count);
if(FAILED(hr)){
IMMDeviceCollection_Release(coll);
release_mmdevenum(devenum, init_hr);
WARN("GetCount failed: %08x\n", hr);
return DS_OK;
}
if(count == 0){
release_mmdevenum(devenum, init_hr);
return DS_OK;
}
TRACE("Calling back with NULL (%s)\n", wine_dbgstr_w(primary_desc));
keep_going = cb(NULL, primary_desc, empty_drv, user);
/* always send the default device first */
if(keep_going){
hr = IMMDeviceEnumerator_GetDefaultAudioEndpoint(devenum, flow,
eMultimedia, &defdev);
if(FAILED(hr)){
defdev = NULL;
n = 0;
}else{
keep_going = send_device(defdev, &guids[0], cb, user);
n = 1;
}
}
for(i = 0; keep_going && i < count; ++i){
IMMDevice *device;
hr = IMMDeviceCollection_Item(coll, i, &device);
if(FAILED(hr)){
WARN("Item failed: %08x\n", hr);
continue;
}
if(device != defdev){
send_device(device, &guids[n], cb, user);
++n;
}
IMMDevice_Release(device);
}
if(defdev)
IMMDevice_Release(defdev);
IMMDeviceCollection_Release(coll);
release_mmdevenum(devenum, init_hr);
return (keep_going == TRUE) ? S_OK : S_FALSE;
}
static void test_session(void)
{
IAudioClient *ses1_ac1, *ses1_ac2, *cap_ac = NULL;
IAudioSessionControl2 *ses1_ctl, *ses1_ctl2, *cap_ctl;
IMMDevice *cap_dev;
GUID ses1_guid;
AudioSessionState state;
WAVEFORMATEX *pwfx;
ULONG ref;
HRESULT hr;
hr = CoCreateGuid(&ses1_guid);
ok(hr == S_OK, "CoCreateGuid failed: %08x\n", hr);
hr = IMMDevice_Activate(dev, &IID_IAudioClient, CLSCTX_INPROC_SERVER,
NULL, (void**)&ses1_ac1);
ok(hr == S_OK, "Activation failed with %08x\n", hr);
hr = IAudioClient_GetMixFormat(ses1_ac1, &pwfx);
ok(hr == S_OK, "GetMixFormat failed: %08x\n", hr);
hr = IAudioClient_Initialize(ses1_ac1, AUDCLNT_SHAREMODE_SHARED,
0, 5000000, 0, pwfx, &ses1_guid);
ok(hr == S_OK, "Initialize failed: %08x\n", hr);
hr = IMMDevice_Activate(dev, &IID_IAudioClient, CLSCTX_INPROC_SERVER,
NULL, (void**)&ses1_ac2);
ok(hr == S_OK, "Activation failed with %08x\n", hr);
hr = IAudioClient_Initialize(ses1_ac2, AUDCLNT_SHAREMODE_SHARED,
0, 5000000, 0, pwfx, &ses1_guid);
ok(hr == S_OK, "Initialize failed: %08x\n", hr);
hr = IMMDeviceEnumerator_GetDefaultAudioEndpoint(mme, eCapture,
eMultimedia, &cap_dev);
if(hr == S_OK){
WAVEFORMATEX *cap_pwfx;
hr = IMMDevice_Activate(cap_dev, &IID_IAudioClient, CLSCTX_INPROC_SERVER,
NULL, (void**)&cap_ac);
ok(hr == S_OK, "Activate failed: %08x\n", hr);
hr = IAudioClient_GetMixFormat(cap_ac, &cap_pwfx);
ok(hr == S_OK, "GetMixFormat failed: %08x\n", hr);
hr = IAudioClient_Initialize(cap_ac, AUDCLNT_SHAREMODE_SHARED,
0, 5000000, 0, cap_pwfx, &ses1_guid);
ok(hr == S_OK, "Initialize failed: %08x\n", hr);
hr = IAudioClient_GetService(cap_ac, &IID_IAudioSessionControl, (void**)&cap_ctl);
ok(hr == S_OK, "GetService failed: %08x\n", hr);
IMMDevice_Release(cap_dev);
CoTaskMemFree(cap_pwfx);
}else
skip("No capture device available; skipping capture device in render session tests\n");
hr = IAudioClient_GetService(ses1_ac1, &IID_IAudioSessionControl2, (void**)&ses1_ctl);
ok(hr == E_NOINTERFACE, "GetService gave wrong error: %08x\n", hr);
hr = IAudioClient_GetService(ses1_ac1, &IID_IAudioSessionControl, (void**)&ses1_ctl);
ok(hr == S_OK, "GetService failed: %08x\n", hr);
hr = IAudioClient_GetService(ses1_ac1, &IID_IAudioSessionControl, (void**)&ses1_ctl2);
ok(hr == S_OK, "GetService failed: %08x\n", hr);
ok(ses1_ctl == ses1_ctl2, "Got different controls: %p %p\n", ses1_ctl, ses1_ctl2);
ref = IAudioSessionControl_Release(ses1_ctl2);
ok(ref != 0, "AudioSessionControl was destroyed\n");
hr = IAudioClient_GetService(ses1_ac2, &IID_IAudioSessionControl, (void**)&ses1_ctl2);
ok(hr == S_OK, "GetService failed: %08x\n", hr);
hr = IAudioSessionControl_GetState(ses1_ctl, NULL);
ok(hr == NULL_PTR_ERR, "GetState gave wrong error: %08x\n", hr);
hr = IAudioSessionControl_GetState(ses1_ctl, &state);
ok(hr == S_OK, "GetState failed: %08x\n", hr);
ok(state == AudioSessionStateInactive, "Got wrong state: %d\n", state);
hr = IAudioSessionControl_GetState(ses1_ctl2, &state);
ok(hr == S_OK, "GetState failed: %08x\n", hr);
ok(state == AudioSessionStateInactive, "Got wrong state: %d\n", state);
if(cap_ac){
hr = IAudioSessionControl_GetState(cap_ctl, &state);
ok(hr == S_OK, "GetState failed: %08x\n", hr);
ok(state == AudioSessionStateInactive, "Got wrong state: %d\n", state);
}
hr = IAudioClient_Start(ses1_ac1);
ok(hr == S_OK, "Start failed: %08x\n", hr);
hr = IAudioSessionControl_GetState(ses1_ctl, &state);
ok(hr == S_OK, "GetState failed: %08x\n", hr);
ok(state == AudioSessionStateActive, "Got wrong state: %d\n", state);
hr = IAudioSessionControl_GetState(ses1_ctl2, &state);
ok(hr == S_OK, "GetState failed: %08x\n", hr);
ok(state == AudioSessionStateActive, "Got wrong state: %d\n", state);
if(cap_ac){
hr = IAudioSessionControl_GetState(cap_ctl, &state);
ok(hr == S_OK, "GetState failed: %08x\n", hr);
ok(state == AudioSessionStateInactive, "Got wrong state: %d\n", state);
}
hr = IAudioClient_Stop(ses1_ac1);
ok(hr == S_OK, "Start failed: %08x\n", hr);
hr = IAudioSessionControl_GetState(ses1_ctl, &state);
ok(hr == S_OK, "GetState failed: %08x\n", hr);
ok(state == AudioSessionStateInactive, "Got wrong state: %d\n", state);
hr = IAudioSessionControl_GetState(ses1_ctl2, &state);
ok(hr == S_OK, "GetState failed: %08x\n", hr);
ok(state == AudioSessionStateInactive, "Got wrong state: %d\n", state);
if(cap_ac){
hr = IAudioSessionControl_GetState(cap_ctl, &state);
ok(hr == S_OK, "GetState failed: %08x\n", hr);
ok(state == AudioSessionStateInactive, "Got wrong state: %d\n", state);
hr = IAudioClient_Start(cap_ac);
ok(hr == S_OK, "Start failed: %08x\n", hr);
hr = IAudioSessionControl_GetState(ses1_ctl, &state);
ok(hr == S_OK, "GetState failed: %08x\n", hr);
ok(state == AudioSessionStateInactive, "Got wrong state: %d\n", state);
hr = IAudioSessionControl_GetState(ses1_ctl2, &state);
ok(hr == S_OK, "GetState failed: %08x\n", hr);
ok(state == AudioSessionStateInactive, "Got wrong state: %d\n", state);
hr = IAudioSessionControl_GetState(cap_ctl, &state);
ok(hr == S_OK, "GetState failed: %08x\n", hr);
ok(state == AudioSessionStateActive, "Got wrong state: %d\n", state);
hr = IAudioClient_Stop(cap_ac);
ok(hr == S_OK, "Stop failed: %08x\n", hr);
hr = IAudioSessionControl_GetState(ses1_ctl, &state);
ok(hr == S_OK, "GetState failed: %08x\n", hr);
ok(state == AudioSessionStateInactive, "Got wrong state: %d\n", state);
hr = IAudioSessionControl_GetState(ses1_ctl2, &state);
ok(hr == S_OK, "GetState failed: %08x\n", hr);
ok(state == AudioSessionStateInactive, "Got wrong state: %d\n", state);
hr = IAudioSessionControl_GetState(cap_ctl, &state);
ok(hr == S_OK, "GetState failed: %08x\n", hr);
ok(state == AudioSessionStateInactive, "Got wrong state: %d\n", state);
ref = IAudioSessionControl_Release(cap_ctl);
ok(ref == 0, "AudioSessionControl wasn't released: %u\n", ref);
ref = IAudioClient_Release(cap_ac);
ok(ref == 0, "AudioClient wasn't released: %u\n", ref);
}
ref = IAudioSessionControl_Release(ses1_ctl);
ok(ref == 0, "AudioSessionControl wasn't released: %u\n", ref);
ref = IAudioClient_Release(ses1_ac1);
ok(ref == 0, "AudioClient wasn't released: %u\n", ref);
ref = IAudioClient_Release(ses1_ac2);
ok(ref == 1, "AudioClient had wrong refcount: %u\n", ref);
/* we've released all of our IAudioClient references, so check GetState */
hr = IAudioSessionControl_GetState(ses1_ctl2, &state);
ok(hr == S_OK, "GetState failed: %08x\n", hr);
ok(state == AudioSessionStateInactive, "Got wrong state: %d\n", state);
ref = IAudioSessionControl_Release(ses1_ctl2);
ok(ref == 0, "AudioSessionControl wasn't released: %u\n", ref);
CoTaskMemFree(pwfx);
}
int open_ep_mixers(px_mixer *Px, UINT deviceIn, UINT deviceOut)
{
PxEPInfo *info;
IMMDeviceEnumerator *denum = NULL;
IMMDevice *device = NULL;
HRESULT hr;
MMRESULT res;
LPWSTR idStr;
size_t idLen;
if (!initialize(Px)) {
goto fail;
}
info = (PxEPInfo *) Px->info;
info->inputEP = NULL;
info->outputEP = NULL;
// Create an audio endpoint device enumerator.
hr = CoCreateInstance(&CLSID_MMDeviceEnumerator,
NULL,
CLSCTX_ALL,
&IID_IMMDeviceEnumerator,
&denum);
if (FAILED(hr)) {
goto fail;
}
if (deviceIn == WAVE_MAPPER) {
hr = IMMDeviceEnumerator_GetDefaultAudioEndpoint(denum,
eCapture,
eMultimedia,
&device);
if (SUCCEEDED(hr)) {
hr = IMMDevice_Activate(device,
&IID_IAudioEndpointVolume,
CLSCTX_ALL,
NULL,
&info->inputEP);
IUnknown_Release(device);
}
if (FAILED(hr)) {
goto fail;
}
}
else {
res = waveInMessage((HWAVEIN)IntToPtr(deviceIn),
DRV_QUERYFUNCTIONINSTANCEIDSIZE,
(DWORD_PTR)&idLen,
(DWORD_PTR)NULL);
if (res != MMSYSERR_NOERROR) {
goto fail;
}
idStr = (WCHAR *) CoTaskMemAlloc(idLen + sizeof(WCHAR));
if (idStr == NULL) {
goto fail;
}
res = waveInMessage((HWAVEIN)IntToPtr(deviceIn),
DRV_QUERYFUNCTIONINSTANCEID,
(DWORD_PTR)idStr,
(DWORD_PTR)idLen);
if (res != MMSYSERR_NOERROR) {
CoTaskMemFree(idStr);
goto fail;
}
hr = IMMDeviceEnumerator_GetDevice(denum, idStr, &device);
if (SUCCEEDED(hr)) {
hr = IMMDevice_Activate(device,
&IID_IAudioEndpointVolume,
CLSCTX_ALL,
NULL,
&info->inputEP);
IUnknown_Release(device);
}
CoTaskMemFree(idStr);
if (FAILED(hr)) {
goto fail;
}
}
if (deviceOut == WAVE_MAPPER) {
hr = IMMDeviceEnumerator_GetDefaultAudioEndpoint(denum,
eRender,
eMultimedia,
&device);
if (SUCCEEDED(hr)) {
hr = IMMDevice_Activate(device,
&IID_IAudioEndpointVolume,
CLSCTX_ALL,
NULL,
&info->outputEP);
IUnknown_Release(device);
}
if (FAILED(hr)) {
goto fail;
}
}
else {
res = waveOutMessage((HWAVEOUT)IntToPtr(deviceOut),
DRV_QUERYFUNCTIONINSTANCEIDSIZE,
(DWORD_PTR)&idLen,
(DWORD_PTR)NULL);
if (res != MMSYSERR_NOERROR) {
goto fail;
}
idStr = (WCHAR *) CoTaskMemAlloc(idLen + sizeof(WCHAR));
if (idStr == NULL) {
goto fail;
}
res = waveOutMessage((HWAVEOUT)IntToPtr(deviceOut),
DRV_QUERYFUNCTIONINSTANCEID,
(DWORD_PTR)idStr,
(DWORD_PTR)idLen);
if (res != MMSYSERR_NOERROR) {
CoTaskMemFree(idStr);
goto fail;
}
hr = IMMDeviceEnumerator_GetDevice(denum, idStr, &device);
if (SUCCEEDED(hr)) {
hr = IMMDevice_Activate(device,
&IID_IAudioEndpointVolume,
CLSCTX_ALL,
NULL,
&info->outputEP);
IUnknown_Release(device);
}
CoTaskMemFree(idStr);
if (FAILED(hr)) {
goto fail;
}
}
if (denum) {
IUnknown_Release(denum);
}
return TRUE;
fail:
if (denum) {
IUnknown_Release(denum);
}
return cleanup(Px);
}
static DWORD CALLBACK MMDevApiMsgProc(void *ptr)
{
ThreadRequest *req = ptr;
IMMDeviceEnumerator *Enumerator;
ALuint deviceCount = 0;
MMDevApiData *data;
ALCdevice *device;
HRESULT hr, cohr;
MSG msg;
TRACE("Starting message thread\n");
cohr = CoInitialize(NULL);
if(FAILED(cohr))
{
WARN("Failed to initialize COM: 0x%08lx\n", cohr);
req->result = cohr;
SetEvent(req->FinishedEvt);
return 0;
}
hr = CoCreateInstance(&CLSID_MMDeviceEnumerator, NULL, CLSCTX_INPROC_SERVER, &IID_IMMDeviceEnumerator, &ptr);
if(FAILED(hr))
{
WARN("Failed to create IMMDeviceEnumerator instance: 0x%08lx\n", hr);
CoUninitialize();
req->result = hr;
SetEvent(req->FinishedEvt);
return 0;
}
Enumerator = ptr;
IMMDeviceEnumerator_Release(Enumerator);
Enumerator = NULL;
CoUninitialize();
req->result = S_OK;
SetEvent(req->FinishedEvt);
TRACE("Starting message loop\n");
while(GetMessage(&msg, NULL, 0, 0))
{
TRACE("Got message %u\n", msg.message);
switch(msg.message)
{
case WM_USER_OpenDevice:
req = (ThreadRequest*)msg.wParam;
device = (ALCdevice*)msg.lParam;
data = device->ExtraData;
hr = cohr = S_OK;
if(++deviceCount == 1)
hr = cohr = CoInitialize(NULL);
if(SUCCEEDED(hr))
hr = CoCreateInstance(&CLSID_MMDeviceEnumerator, NULL, CLSCTX_INPROC_SERVER, &IID_IMMDeviceEnumerator, &ptr);
if(SUCCEEDED(hr))
{
Enumerator = ptr;
if(!data->devid)
hr = IMMDeviceEnumerator_GetDefaultAudioEndpoint(Enumerator, eRender, eMultimedia, &data->mmdev);
else
hr = IMMDeviceEnumerator_GetDevice(Enumerator, data->devid, &data->mmdev);
IMMDeviceEnumerator_Release(Enumerator);
Enumerator = NULL;
}
if(SUCCEEDED(hr))
hr = IMMDevice_Activate(data->mmdev, &IID_IAudioClient, CLSCTX_INPROC_SERVER, NULL, &ptr);
if(SUCCEEDED(hr))
{
data->client = ptr;
device->DeviceName = get_device_name(data->mmdev);
}
if(FAILED(hr))
{
if(data->mmdev)
IMMDevice_Release(data->mmdev);
data->mmdev = NULL;
if(--deviceCount == 0 && SUCCEEDED(cohr))
CoUninitialize();
}
req->result = hr;
SetEvent(req->FinishedEvt);
continue;
case WM_USER_ResetDevice:
req = (ThreadRequest*)msg.wParam;
device = (ALCdevice*)msg.lParam;
req->result = DoReset(device);
SetEvent(req->FinishedEvt);
continue;
case WM_USER_StartDevice:
req = (ThreadRequest*)msg.wParam;
device = (ALCdevice*)msg.lParam;
data = device->ExtraData;
ResetEvent(data->NotifyEvent);
hr = IAudioClient_SetEventHandle(data->client, data->NotifyEvent);
if(FAILED(hr))
ERR("Failed to set event handle: 0x%08lx\n", hr);
else
{
hr = IAudioClient_Start(data->client);
if(FAILED(hr))
ERR("Failed to start audio client: 0x%08lx\n", hr);
}
if(SUCCEEDED(hr))
hr = IAudioClient_GetService(data->client, &IID_IAudioRenderClient, &ptr);
if(SUCCEEDED(hr))
{
data->render = ptr;
data->thread = StartThread(MMDevApiProc, device);
if(!data->thread)
{
if(data->render)
IAudioRenderClient_Release(data->render);
data->render = NULL;
IAudioClient_Stop(data->client);
ERR("Failed to start thread\n");
hr = E_FAIL;
}
}
req->result = hr;
SetEvent(req->FinishedEvt);
continue;
case WM_USER_StopDevice:
req = (ThreadRequest*)msg.wParam;
device = (ALCdevice*)msg.lParam;
data = device->ExtraData;
if(data->thread)
{
data->killNow = 1;
StopThread(data->thread);
data->thread = NULL;
data->killNow = 0;
IAudioRenderClient_Release(data->render);
data->render = NULL;
IAudioClient_Stop(data->client);
}
req->result = S_OK;
SetEvent(req->FinishedEvt);
continue;
case WM_USER_CloseDevice:
req = (ThreadRequest*)msg.wParam;
device = (ALCdevice*)msg.lParam;
data = device->ExtraData;
IAudioClient_Release(data->client);
data->client = NULL;
IMMDevice_Release(data->mmdev);
data->mmdev = NULL;
if(--deviceCount == 0)
CoUninitialize();
req->result = S_OK;
SetEvent(req->FinishedEvt);
continue;
case WM_USER_Enumerate:
req = (ThreadRequest*)msg.wParam;
hr = cohr = S_OK;
if(++deviceCount == 1)
hr = cohr = CoInitialize(NULL);
if(SUCCEEDED(hr))
hr = CoCreateInstance(&CLSID_MMDeviceEnumerator, NULL, CLSCTX_INPROC_SERVER, &IID_IMMDeviceEnumerator, &ptr);
if(SUCCEEDED(hr))
{
EDataFlow flowdir;
DevMap **devlist;
ALuint *numdevs;
ALuint i;
Enumerator = ptr;
if(msg.lParam == CAPTURE_DEVICE_PROBE)
{
flowdir = eCapture;
devlist = &CaptureDeviceList;
numdevs = &NumCaptureDevices;
}
else
{
flowdir = eRender;
devlist = &PlaybackDeviceList;
numdevs = &NumPlaybackDevices;
}
for(i = 0;i < *numdevs;i++)
{
free((*devlist)[i].name);
free((*devlist)[i].devid);
}
free(*devlist);
*devlist = NULL;
*numdevs = 0;
*devlist = ProbeDevices(Enumerator, flowdir, numdevs);
IMMDeviceEnumerator_Release(Enumerator);
Enumerator = NULL;
}
if(--deviceCount == 0 && SUCCEEDED(cohr))
CoUninitialize();
req->result = S_OK;
SetEvent(req->FinishedEvt);
continue;
default:
ERR("Unexpected message: %u\n", msg.message);
continue;
}
}
TRACE("Message loop finished\n");
return 0;
}