| /* |
| * Audio management UI code |
| * |
| * Copyright 2004 Chris Morgan |
| * |
| * This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Lesser General Public |
| * License as published by the Free Software Foundation; either |
| * version 2.1 of the License, or (at your option) any later version. |
| * |
| * This library is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Lesser General Public License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General Public |
| * License along with this library; if not, write to the Free Software |
| * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA |
| * |
| */ |
| |
| #define WIN32_LEAN_AND_MEAN |
| #define NONAMELESSSTRUCT |
| #define NONAMELESSUNION |
| |
| #include "config.h" |
| #include "wine/port.h" |
| |
| #include <assert.h> |
| #include <stdlib.h> |
| #include <stdio.h> |
| #include <string.h> |
| |
| #define COBJMACROS |
| #include <windows.h> |
| #include <wine/debug.h> |
| #include <shellapi.h> |
| #include <objbase.h> |
| #include <shlguid.h> |
| #include <shlwapi.h> |
| #include <shlobj.h> |
| #include <mmsystem.h> |
| #include <mmreg.h> |
| #include <mmddk.h> |
| |
| #include "ole2.h" |
| #include "initguid.h" |
| #include "devpkey.h" |
| #include "mmdeviceapi.h" |
| #include "audioclient.h" |
| #include "audiopolicy.h" |
| |
| #include "winecfg.h" |
| #include "resource.h" |
| |
| WINE_DEFAULT_DEBUG_CHANNEL(winecfg); |
| |
| struct DeviceInfo { |
| WCHAR *id; |
| PROPVARIANT name; |
| }; |
| |
| static WCHAR g_drv_keyW[256] = {'S','o','f','t','w','a','r','e','\\', |
| 'W','i','n','e','\\','D','r','i','v','e','r','s','\\',0}; |
| |
| static const WCHAR reg_out_nameW[] = {'D','e','f','a','u','l','t','O','u','t','p','u','t',0}; |
| static const WCHAR reg_in_nameW[] = {'D','e','f','a','u','l','t','I','n','p','u','t',0}; |
| static const WCHAR reg_vout_nameW[] = {'D','e','f','a','u','l','t','V','o','i','c','e','O','u','t','p','u','t',0}; |
| static const WCHAR reg_vin_nameW[] = {'D','e','f','a','u','l','t','V','o','i','c','e','I','n','p','u','t',0}; |
| |
| static UINT num_render_devs, num_capture_devs; |
| static struct DeviceInfo *render_devs, *capture_devs; |
| |
| static BOOL load_device(IMMDevice *dev, struct DeviceInfo *info) |
| { |
| IPropertyStore *ps; |
| HRESULT hr; |
| |
| hr = IMMDevice_GetId(dev, &info->id); |
| if(FAILED(hr)){ |
| info->id = NULL; |
| return FALSE; |
| } |
| |
| hr = IMMDevice_OpenPropertyStore(dev, STGM_READ, &ps); |
| if(FAILED(hr)){ |
| CoTaskMemFree(info->id); |
| info->id = NULL; |
| return FALSE; |
| } |
| |
| PropVariantInit(&info->name); |
| |
| hr = IPropertyStore_GetValue(ps, |
| (PROPERTYKEY*)&DEVPKEY_Device_FriendlyName, &info->name); |
| IPropertyStore_Release(ps); |
| if(FAILED(hr)){ |
| CoTaskMemFree(info->id); |
| info->id = NULL; |
| return FALSE; |
| } |
| |
| return TRUE; |
| } |
| |
| static BOOL load_devices(IMMDeviceEnumerator *devenum, EDataFlow dataflow, |
| UINT *ndevs, struct DeviceInfo **out) |
| { |
| IMMDeviceCollection *coll; |
| UINT i; |
| HRESULT hr; |
| |
| hr = IMMDeviceEnumerator_EnumAudioEndpoints(devenum, dataflow, |
| DEVICE_STATE_ACTIVE, &coll); |
| if(FAILED(hr)) |
| return FALSE; |
| |
| hr = IMMDeviceCollection_GetCount(coll, ndevs); |
| if(FAILED(hr)){ |
| IMMDeviceCollection_Release(coll); |
| return FALSE; |
| } |
| |
| if(*ndevs > 0){ |
| *out = HeapAlloc(GetProcessHeap(), 0, |
| sizeof(struct DeviceInfo) * (*ndevs)); |
| if(!*out){ |
| IMMDeviceCollection_Release(coll); |
| return FALSE; |
| } |
| |
| for(i = 0; i < *ndevs; ++i){ |
| IMMDevice *dev; |
| |
| hr = IMMDeviceCollection_Item(coll, i, &dev); |
| if(FAILED(hr)){ |
| (*out)[i].id = NULL; |
| continue; |
| } |
| |
| load_device(dev, &(*out)[i]); |
| |
| IMMDevice_Release(dev); |
| } |
| }else |
| *out = NULL; |
| |
| IMMDeviceCollection_Release(coll); |
| |
| return TRUE; |
| } |
| |
| static BOOL get_driver_name(IMMDeviceEnumerator *devenum, PROPVARIANT *pv) |
| { |
| IMMDevice *device; |
| IPropertyStore *ps; |
| HRESULT hr; |
| |
| static const WCHAR wine_info_deviceW[] = {'W','i','n','e',' ', |
| 'i','n','f','o',' ','d','e','v','i','c','e',0}; |
| |
| hr = IMMDeviceEnumerator_GetDevice(devenum, wine_info_deviceW, &device); |
| if(FAILED(hr)) |
| return FALSE; |
| |
| hr = IMMDevice_OpenPropertyStore(device, STGM_READ, &ps); |
| if(FAILED(hr)){ |
| IMMDevice_Release(device); |
| return FALSE; |
| } |
| |
| hr = IPropertyStore_GetValue(ps, |
| (const PROPERTYKEY *)&DEVPKEY_Device_Driver, pv); |
| IPropertyStore_Release(ps); |
| IMMDevice_Release(device); |
| if(FAILED(hr)) |
| return FALSE; |
| |
| return TRUE; |
| } |
| |
| static void initAudioDlg (HWND hDlg) |
| { |
| WCHAR display_str[256], format_str[256], sysdefault_str[256], disabled_str[64]; |
| IMMDeviceEnumerator *devenum; |
| BOOL have_driver = FALSE; |
| HRESULT hr; |
| |
| WINE_TRACE("\n"); |
| |
| LoadStringW(GetModuleHandleW(NULL), IDS_AUDIO_DRIVER, |
| format_str, sizeof(format_str) / sizeof(*format_str)); |
| LoadStringW(GetModuleHandleW(NULL), IDS_AUDIO_DRIVER_NONE, |
| disabled_str, sizeof(disabled_str) / sizeof(*disabled_str)); |
| LoadStringW(GetModuleHandleW(NULL), IDS_AUDIO_SYSDEFAULT, |
| sysdefault_str, sizeof(sysdefault_str) / sizeof(*sysdefault_str)); |
| |
| hr = CoCreateInstance(&CLSID_MMDeviceEnumerator, NULL, |
| CLSCTX_INPROC_SERVER, &IID_IMMDeviceEnumerator, (void**)&devenum); |
| if(SUCCEEDED(hr)){ |
| PROPVARIANT pv; |
| |
| load_devices(devenum, eRender, &num_render_devs, &render_devs); |
| load_devices(devenum, eCapture, &num_capture_devs, &capture_devs); |
| |
| PropVariantInit(&pv); |
| if(get_driver_name(devenum, &pv) && pv.u.pwszVal[0] != '\0'){ |
| have_driver = TRUE; |
| wnsprintfW(display_str, sizeof(display_str) / sizeof(*display_str), |
| format_str, pv.u.pwszVal); |
| lstrcatW(g_drv_keyW, pv.u.pwszVal); |
| } |
| PropVariantClear(&pv); |
| |
| IMMDeviceEnumerator_Release(devenum); |
| } |
| |
| SendDlgItemMessageW(hDlg, IDC_AUDIOOUT_DEVICE, CB_ADDSTRING, |
| 0, (LPARAM)sysdefault_str); |
| SendDlgItemMessageW(hDlg, IDC_AUDIOOUT_DEVICE, CB_SETCURSEL, 0, 0); |
| SendDlgItemMessageW(hDlg, IDC_VOICEOUT_DEVICE, CB_ADDSTRING, |
| 0, (LPARAM)sysdefault_str); |
| SendDlgItemMessageW(hDlg, IDC_VOICEOUT_DEVICE, CB_SETCURSEL, 0, 0); |
| |
| SendDlgItemMessageW(hDlg, IDC_AUDIOIN_DEVICE, CB_ADDSTRING, |
| 0, (LPARAM)sysdefault_str); |
| SendDlgItemMessageW(hDlg, IDC_AUDIOIN_DEVICE, CB_SETCURSEL, 0, 0); |
| SendDlgItemMessageW(hDlg, IDC_VOICEIN_DEVICE, CB_ADDSTRING, |
| 0, (LPARAM)sysdefault_str); |
| SendDlgItemMessageW(hDlg, IDC_VOICEIN_DEVICE, CB_SETCURSEL, 0, 0); |
| |
| if(have_driver){ |
| WCHAR *reg_out_dev, *reg_vout_dev, *reg_in_dev, *reg_vin_dev; |
| UINT i; |
| |
| reg_out_dev = get_reg_keyW(HKEY_CURRENT_USER, g_drv_keyW, reg_out_nameW, NULL); |
| reg_vout_dev = get_reg_keyW(HKEY_CURRENT_USER, g_drv_keyW, reg_vout_nameW, NULL); |
| reg_in_dev = get_reg_keyW(HKEY_CURRENT_USER, g_drv_keyW, reg_in_nameW, NULL); |
| reg_vin_dev = get_reg_keyW(HKEY_CURRENT_USER, g_drv_keyW, reg_vin_nameW, NULL); |
| |
| for(i = 0; i < num_render_devs; ++i){ |
| if(!render_devs[i].id) |
| continue; |
| |
| SendDlgItemMessageW(hDlg, IDC_AUDIOOUT_DEVICE, CB_ADDSTRING, |
| 0, (LPARAM)render_devs[i].name.u.pwszVal); |
| SendDlgItemMessageW(hDlg, IDC_AUDIOOUT_DEVICE, CB_SETITEMDATA, |
| i + 1, (LPARAM)&render_devs[i]); |
| if(reg_out_dev && !lstrcmpW(render_devs[i].id, reg_out_dev)) |
| SendDlgItemMessageW(hDlg, IDC_AUDIOOUT_DEVICE, CB_SETCURSEL, i + 1, 0); |
| |
| SendDlgItemMessageW(hDlg, IDC_VOICEOUT_DEVICE, CB_ADDSTRING, |
| 0, (LPARAM)render_devs[i].name.u.pwszVal); |
| SendDlgItemMessageW(hDlg, IDC_VOICEOUT_DEVICE, CB_SETITEMDATA, |
| i + 1, (LPARAM)&render_devs[i]); |
| if(reg_vout_dev && !lstrcmpW(render_devs[i].id, reg_vout_dev)) |
| SendDlgItemMessageW(hDlg, IDC_VOICEOUT_DEVICE, CB_SETCURSEL, i + 1, 0); |
| } |
| |
| for(i = 0; i < num_capture_devs; ++i){ |
| if(!capture_devs[i].id) |
| continue; |
| |
| SendDlgItemMessageW(hDlg, IDC_AUDIOIN_DEVICE, CB_ADDSTRING, |
| 0, (LPARAM)capture_devs[i].name.u.pwszVal); |
| SendDlgItemMessageW(hDlg, IDC_AUDIOIN_DEVICE, CB_SETITEMDATA, |
| i + 1, (LPARAM)&capture_devs[i]); |
| if(reg_in_dev && !lstrcmpW(capture_devs[i].id, reg_in_dev)) |
| SendDlgItemMessageW(hDlg, IDC_AUDIOIN_DEVICE, CB_SETCURSEL, i + 1, 0); |
| |
| SendDlgItemMessageW(hDlg, IDC_VOICEIN_DEVICE, CB_ADDSTRING, |
| 0, (LPARAM)capture_devs[i].name.u.pwszVal); |
| SendDlgItemMessageW(hDlg, IDC_VOICEIN_DEVICE, CB_SETITEMDATA, |
| i + 1, (LPARAM)&capture_devs[i]); |
| if(reg_vin_dev && !lstrcmpW(capture_devs[i].id, reg_vin_dev)) |
| SendDlgItemMessageW(hDlg, IDC_VOICEIN_DEVICE, CB_SETCURSEL, i + 1, 0); |
| } |
| |
| HeapFree(GetProcessHeap(), 0, reg_out_dev); |
| HeapFree(GetProcessHeap(), 0, reg_vout_dev); |
| HeapFree(GetProcessHeap(), 0, reg_in_dev); |
| HeapFree(GetProcessHeap(), 0, reg_vin_dev); |
| }else |
| wnsprintfW(display_str, sizeof(display_str) / sizeof(*display_str), |
| format_str, disabled_str); |
| |
| SetDlgItemTextW(hDlg, IDC_AUDIO_DRIVER, display_str); |
| } |
| |
| static void set_reg_device(HWND hDlg, int dlgitem, const WCHAR *key_name) |
| { |
| UINT idx; |
| struct DeviceInfo *info; |
| |
| idx = SendDlgItemMessageW(hDlg, dlgitem, CB_GETCURSEL, 0, 0); |
| |
| info = (struct DeviceInfo *)SendDlgItemMessageW(hDlg, dlgitem, |
| CB_GETITEMDATA, idx, 0); |
| |
| if(!info || info == (void*)CB_ERR) |
| set_reg_keyW(HKEY_CURRENT_USER, g_drv_keyW, key_name, NULL); |
| else |
| set_reg_keyW(HKEY_CURRENT_USER, g_drv_keyW, key_name, info->id); |
| } |
| |
| static void test_sound(void) |
| { |
| if(!PlaySoundW(MAKEINTRESOURCEW(IDW_TESTSOUND), NULL, SND_RESOURCE | SND_ASYNC)){ |
| WCHAR error_str[256], title_str[256]; |
| |
| LoadStringW(GetModuleHandleW(NULL), IDS_AUDIO_TEST_FAILED, |
| error_str, sizeof(error_str) / sizeof(*error_str)); |
| LoadStringW(GetModuleHandleW(NULL), IDS_AUDIO_TEST_FAILED_TITLE, |
| title_str, sizeof(title_str) / sizeof(*title_str)); |
| |
| MessageBoxW(NULL, error_str, title_str, MB_OK | MB_ICONERROR); |
| } |
| } |
| |
| INT_PTR CALLBACK |
| AudioDlgProc (HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam) |
| { |
| switch (uMsg) { |
| case WM_COMMAND: |
| switch (LOWORD(wParam)) { |
| case IDC_AUDIO_TEST: |
| test_sound(); |
| break; |
| case IDC_AUDIOOUT_DEVICE: |
| if(HIWORD(wParam) == CBN_SELCHANGE){ |
| set_reg_device(hDlg, IDC_AUDIOOUT_DEVICE, reg_out_nameW); |
| SendMessageW(GetParent(hDlg), PSM_CHANGED, 0, 0); |
| } |
| break; |
| case IDC_VOICEOUT_DEVICE: |
| if(HIWORD(wParam) == CBN_SELCHANGE){ |
| set_reg_device(hDlg, IDC_VOICEOUT_DEVICE, reg_vout_nameW); |
| SendMessageW(GetParent(hDlg), PSM_CHANGED, 0, 0); |
| } |
| break; |
| case IDC_AUDIOIN_DEVICE: |
| if(HIWORD(wParam) == CBN_SELCHANGE){ |
| set_reg_device(hDlg, IDC_AUDIOIN_DEVICE, reg_in_nameW); |
| SendMessageW(GetParent(hDlg), PSM_CHANGED, 0, 0); |
| } |
| break; |
| case IDC_VOICEIN_DEVICE: |
| if(HIWORD(wParam) == CBN_SELCHANGE){ |
| set_reg_device(hDlg, IDC_VOICEIN_DEVICE, reg_vin_nameW); |
| SendMessageW(GetParent(hDlg), PSM_CHANGED, 0, 0); |
| } |
| break; |
| } |
| break; |
| |
| case WM_SHOWWINDOW: |
| set_window_title(hDlg); |
| break; |
| |
| case WM_NOTIFY: |
| switch(((LPNMHDR)lParam)->code) { |
| case PSN_KILLACTIVE: |
| SetWindowLongPtrW(hDlg, DWLP_MSGRESULT, FALSE); |
| break; |
| case PSN_APPLY: |
| apply(); |
| SetWindowLongPtrW(hDlg, DWLP_MSGRESULT, PSNRET_NOERROR); |
| break; |
| case PSN_SETACTIVE: |
| break; |
| } |
| break; |
| case WM_INITDIALOG: |
| initAudioDlg(hDlg); |
| break; |
| } |
| |
| return FALSE; |
| } |