dlls/windows.media.devices/main.c

   1 /*
   2  * Copyright 2021 Andrew Eikum for CodeWeavers
   3  * Copyright 2021 Rémi Bernon for CodeWeavers
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  */
  19
  20 #include <stdarg.h>
  21
  22 #define COBJMACROS
  23 #include "initguid.h"
  24 #include "windef.h"
  25 #include "winbase.h"
  26 #include "winstring.h"
  27 #include "wine/debug.h"
  28 #include "wine/heap.h"
  29 #include "objbase.h"
  30
  31 #include "activation.h"
  32 #include "mmdeviceapi.h"
  33
  34 #define WIDL_using_Windows_Foundation
  35 #define WIDL_using_Windows_Foundation_Collections
  36 #include "windows.foundation.h"
  37 #define WIDL_using_Windows_Media_Devices
  38 #include "windows.media.devices.h"
  39
  40 WINE_DEFAULT_DEBUG_CHANNEL(mmdevapi);
  41
  42 static const char *debugstr_hstring(HSTRING hstr)
  43 {
  44     const WCHAR *str;
  45     UINT32 len;
  46     if (hstr && !((ULONG_PTR)hstr >> 16)) return "(invalid)";
  47     str = WindowsGetStringRawBuffer(hstr, &len);
  48     return wine_dbgstr_wn(str, len);
  49 }
  50
  51 static ERole AudioDeviceRole_to_ERole(AudioDeviceRole role)
  52 {
  53     switch(role){
  54         case AudioDeviceRole_Communications:
  55             return eCommunications;
  56         default:
  57             return eMultimedia;
  58     }
  59 }
  60
  61 struct windows_media_devices
  62 {
  63     IActivationFactory IActivationFactory_iface;
  64     IMediaDeviceStatics IMediaDeviceStatics_iface;
  65     LONG ref;
  66 };
  67
  68 static inline struct windows_media_devices *impl_from_IActivationFactory(IActivationFactory *iface)
  69 {
  70     return CONTAINING_RECORD(iface, struct windows_media_devices, IActivationFactory_iface);
  71 }
  72
  73 static inline struct windows_media_devices *impl_from_IMediaDeviceStatics(IMediaDeviceStatics *iface)
  74 {
  75     return CONTAINING_RECORD(iface, struct windows_media_devices, IMediaDeviceStatics_iface);
  76 }
  77
  78 static HRESULT STDMETHODCALLTYPE windows_media_devices_QueryInterface(
  79         IActivationFactory *iface, REFIID iid, void **out)
  80 {
  81     struct windows_media_devices *impl = impl_from_IActivationFactory(iface);
  82
  83     TRACE("iface %p, iid %s, out %p\n", iface, debugstr_guid(iid), out);
  84
  85     if (IsEqualGUID(iid, &IID_IUnknown) ||
  86             IsEqualGUID(iid, &IID_IInspectable) ||
  87             IsEqualGUID(iid, &IID_IAgileObject) ||
  88             IsEqualGUID(iid, &IID_IActivationFactory))
  89     {
  90         IUnknown_AddRef(iface);
  91         *out = iface;
  92         return S_OK;
  93     }
  94
  95     if (IsEqualGUID(iid, &IID_IMediaDeviceStatics))
  96     {
  97         IUnknown_AddRef(iface);
  98         *out = &impl->IMediaDeviceStatics_iface;
  99         return S_OK;
 100     }
 101
 102     FIXME("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid));
 103     *out = NULL;
 104     return E_NOINTERFACE;
 105 }
 106
 107 static ULONG STDMETHODCALLTYPE windows_media_devices_AddRef(
 108         IActivationFactory *iface)
 109 {
 110     struct windows_media_devices *impl = impl_from_IActivationFactory(iface);
 111     ULONG ref = InterlockedIncrement(&impl->ref);
 112     TRACE("iface %p, ref %u.\n", iface, ref);
 113     return ref;
 114 }
 115
 116 static ULONG STDMETHODCALLTYPE windows_media_devices_Release(
 117         IActivationFactory *iface)
 118 {
 119     struct windows_media_devices *impl = impl_from_IActivationFactory(iface);
 120     ULONG ref = InterlockedDecrement(&impl->ref);
 121     TRACE("iface %p, ref %u.\n", iface, ref);
 122     return ref;
 123 }
 124
 125 static HRESULT STDMETHODCALLTYPE windows_media_devices_GetIids(
 126         IActivationFactory *iface, ULONG *iid_count, IID **iids)
 127 {
 128     FIXME("iface %p, iid_count %p, iids %p stub!\n", iface, iid_count, iids);
 129     return E_NOTIMPL;
 130 }
 131
 132 static HRESULT STDMETHODCALLTYPE windows_media_devices_GetRuntimeClassName(
 133         IActivationFactory *iface, HSTRING *class_name)
 134 {
 135     FIXME("iface %p, class_name %p stub!\n", iface, class_name);
 136     return E_NOTIMPL;
 137 }
 138
 139 static HRESULT STDMETHODCALLTYPE windows_media_devices_GetTrustLevel(
 140         IActivationFactory *iface, TrustLevel *trust_level)
 141 {
 142     FIXME("iface %p, trust_level %p stub!\n", iface, trust_level);
 143     return E_NOTIMPL;
 144 }
 145
 146 static HRESULT STDMETHODCALLTYPE windows_media_devices_ActivateInstance(
 147         IActivationFactory *iface, IInspectable **instance)
 148 {
 149     FIXME("iface %p, instance %p stub!\n", iface, instance);
 150     return E_NOTIMPL;
 151 }
 152
 153 static const struct IActivationFactoryVtbl activation_factory_vtbl =
 154 {
 155     windows_media_devices_QueryInterface,
 156     windows_media_devices_AddRef,
 157     windows_media_devices_Release,
 158     /* IInspectable methods */
 159     windows_media_devices_GetIids,
 160     windows_media_devices_GetRuntimeClassName,
 161     windows_media_devices_GetTrustLevel,
 162     /* IActivationFactory methods */
 163     windows_media_devices_ActivateInstance,
 164 };
 165
 166 static HRESULT get_default_device_id(EDataFlow direction, AudioDeviceRole role, HSTRING *device_id_hstr)
 167 {
 168     HRESULT hr;
 169     WCHAR *devid, *s;
 170     IMMDevice *dev;
 171     IMMDeviceEnumerator *devenum;
 172     ERole mmdev_role = AudioDeviceRole_to_ERole(role);
 173
 174     static const WCHAR id_fmt_pre[] = L"\\\\?\\SWD#MMDEVAPI#";
 175     static const WCHAR id_fmt_hash[] = L"#";
 176     static const size_t GUID_STR_LEN = 38; /* == strlen("{00000000-0000-0000-0000-000000000000}") */
 177
 178     *device_id_hstr = NULL;
 179
 180     hr = CoCreateInstance(&CLSID_MMDeviceEnumerator, NULL,
 181             CLSCTX_INPROC_SERVER, &IID_IMMDeviceEnumerator, (void**)&devenum);
 182     if (FAILED(hr))
 183     {
 184         WARN("Failed to create MMDeviceEnumerator: %08x\n", hr);
 185         return hr;
 186     }
 187
 188     hr = IMMDeviceEnumerator_GetDefaultAudioEndpoint(devenum, direction, mmdev_role, &dev);
 189     if (FAILED(hr))
 190     {
 191         WARN("GetDefaultAudioEndpoint failed: %08x\n", hr);
 192         IMMDeviceEnumerator_Release(devenum);
 193         return hr;
 194     }
 195
 196     hr = IMMDevice_GetId(dev, &devid);
 197     if (FAILED(hr))
 198     {
 199         WARN("GetId failed: %08x\n", hr);
 200         IMMDevice_Release(dev);
 201         IMMDeviceEnumerator_Release(devenum);
 202         return hr;
 203     }
 204
 205     s = heap_alloc((sizeof(id_fmt_pre) - sizeof(WCHAR)) +
 206             (sizeof(id_fmt_hash) - sizeof(WCHAR)) +
 207             (wcslen(devid) + GUID_STR_LEN + 1 /* nul */) * sizeof(WCHAR));
 208
 209     wcscpy(s, id_fmt_pre);
 210     wcscat(s, devid);
 211     wcscat(s, id_fmt_hash);
 212
 213     if(direction == eRender)
 214         StringFromGUID2(&DEVINTERFACE_AUDIO_RENDER, s + wcslen(s), GUID_STR_LEN + 1);
 215     else
 216         StringFromGUID2(&DEVINTERFACE_AUDIO_CAPTURE, s + wcslen(s), GUID_STR_LEN + 1);
 217
 218     hr = WindowsCreateString(s, wcslen(s), device_id_hstr);
 219     if (FAILED(hr))
 220         WARN("WindowsCreateString failed: %08x\n", hr);
 221
 222     heap_free(s);
 223
 224     CoTaskMemFree(devid);
 225     IMMDevice_Release(dev);
 226     IMMDeviceEnumerator_Release(devenum);
 227
 228     return hr;
 229 }
 230
 231 static HRESULT WINAPI media_device_statics_QueryInterface(IMediaDeviceStatics *iface,
 232         REFIID riid, void **ppvObject)
 233 {
 234     struct windows_media_devices *This = impl_from_IMediaDeviceStatics(iface);
 235     return windows_media_devices_QueryInterface(&This->IActivationFactory_iface, riid, ppvObject);
 236 }
 237
 238 static ULONG WINAPI media_device_statics_AddRef(IMediaDeviceStatics *iface)
 239 {
 240     struct windows_media_devices *This = impl_from_IMediaDeviceStatics(iface);
 241     return windows_media_devices_AddRef(&This->IActivationFactory_iface);
 242 }
 243
 244 static ULONG WINAPI media_device_statics_Release(IMediaDeviceStatics *iface)
 245 {
 246     struct windows_media_devices *This = impl_from_IMediaDeviceStatics(iface);
 247     return windows_media_devices_Release(&This->IActivationFactory_iface);
 248 }
 249
 250 static HRESULT WINAPI media_device_statics_GetIids(IMediaDeviceStatics *iface,
 251         ULONG *iidCount, IID **iids)
 252 {
 253     struct windows_media_devices *This = impl_from_IMediaDeviceStatics(iface);
 254     return windows_media_devices_GetIids(&This->IActivationFactory_iface, iidCount, iids);
 255 }
 256
 257 static HRESULT WINAPI media_device_statics_GetRuntimeClassName(IMediaDeviceStatics *iface,
 258         HSTRING *className)
 259 {
 260     struct windows_media_devices *This = impl_from_IMediaDeviceStatics(iface);
 261     return windows_media_devices_GetRuntimeClassName(&This->IActivationFactory_iface, className);
 262 }
 263
 264 static HRESULT WINAPI media_device_statics_GetTrustLevel(IMediaDeviceStatics *iface,
 265         TrustLevel *trustLevel)
 266 {
 267     struct windows_media_devices *This = impl_from_IMediaDeviceStatics(iface);
 268     return windows_media_devices_GetTrustLevel(&This->IActivationFactory_iface, trustLevel);
 269 }
 270
 271 static HRESULT WINAPI media_device_statics_GetAudioCaptureSelector(IMediaDeviceStatics *iface,
 272         HSTRING *value)
 273 {
 274     FIXME("iface %p, value %p stub!\n", iface, value);
 275     return E_NOTIMPL;
 276 }
 277
 278 static HRESULT WINAPI media_device_statics_GetAudioRenderSelector(IMediaDeviceStatics *iface,
 279         HSTRING *value)
 280 {
 281     FIXME("iface %p, value %p stub!\n", iface, value);
 282     return E_NOTIMPL;
 283 }
 284
 285 static HRESULT WINAPI media_device_statics_GetVideoCaptureSelector(IMediaDeviceStatics *iface,
 286         HSTRING *value)
 287 {
 288     FIXME("iface %p, value %p stub!\n", iface, value);
 289     return E_NOTIMPL;
 290 }
 291
 292 static HRESULT WINAPI media_device_statics_GetDefaultAudioCaptureId(IMediaDeviceStatics *iface,
 293         AudioDeviceRole role, HSTRING *value)
 294 {
 295     TRACE("iface %p, role 0x%x, value %p\n", iface, role, value);
 296     return get_default_device_id(eCapture, role, value);
 297 }
 298
 299 static HRESULT WINAPI media_device_statics_GetDefaultAudioRenderId(IMediaDeviceStatics *iface,
 300         AudioDeviceRole role, HSTRING *value)
 301 {
 302     TRACE("iface %p, role 0x%x, value %p\n", iface, role, value);
 303     return get_default_device_id(eRender, role, value);
 304 }
 305
 306 static HRESULT WINAPI media_device_statics_add_DefaultAudioCaptureDeviceChanged(
 307         IMediaDeviceStatics *iface,
 308         ITypedEventHandler_IInspectable_DefaultAudioCaptureDeviceChangedEventArgs *handler,
 309         EventRegistrationToken *token)
 310 {
 311     FIXME("iface %p, handler %p token %p stub!\n", iface, handler, token);
 312     if(!token)
 313         return E_POINTER;
 314     token->value = 1;
 315     return S_OK;
 316 }
 317
 318 static HRESULT WINAPI media_device_statics_remove_DefaultAudioCaptureDeviceChanged(
 319         IMediaDeviceStatics *iface,
 320         EventRegistrationToken token)
 321 {
 322     FIXME("iface %p, token %#I64x stub!\n", iface, token.value);
 323     return S_OK;
 324 }
 325
 326 static HRESULT WINAPI media_device_statics_add_DefaultAudioRenderDeviceChanged(
 327         IMediaDeviceStatics *iface,
 328         ITypedEventHandler_IInspectable_DefaultAudioRenderDeviceChangedEventArgs *handler,
 329         EventRegistrationToken *token)
 330 {
 331     FIXME("iface %p, handler %p token %p stub!\n", iface, handler, token);
 332     if(!token)
 333         return E_POINTER;
 334     token->value = 1;
 335     return S_OK;
 336 }
 337
 338 static HRESULT WINAPI media_device_statics_remove_DefaultAudioRenderDeviceChanged(
 339         IMediaDeviceStatics *iface,
 340         EventRegistrationToken token)
 341 {
 342     FIXME("iface %p, token %#I64x stub!\n", iface, token.value);
 343     return S_OK;
 344 }
 345
 346 static IMediaDeviceStaticsVtbl media_device_statics_vtbl = {
 347     media_device_statics_QueryInterface,
 348     media_device_statics_AddRef,
 349     media_device_statics_Release,
 350     media_device_statics_GetIids,
 351     media_device_statics_GetRuntimeClassName,
 352     media_device_statics_GetTrustLevel,
 353     media_device_statics_GetAudioCaptureSelector,
 354     media_device_statics_GetAudioRenderSelector,
 355     media_device_statics_GetVideoCaptureSelector,
 356     media_device_statics_GetDefaultAudioCaptureId,
 357     media_device_statics_GetDefaultAudioRenderId,
 358     media_device_statics_add_DefaultAudioCaptureDeviceChanged,
 359     media_device_statics_remove_DefaultAudioCaptureDeviceChanged,
 360     media_device_statics_add_DefaultAudioRenderDeviceChanged,
 361     media_device_statics_remove_DefaultAudioRenderDeviceChanged,
 362 };
 363
 364 static struct windows_media_devices windows_media_devices =
 365 {
 366     {&activation_factory_vtbl},
 367     {&media_device_statics_vtbl},
 368     1
 369 };
 370
 371 HRESULT WINAPI DllGetClassObject(REFCLSID clsid, REFIID riid, void **out)
 372 {
 373     FIXME("clsid %s, riid %s, out %p stub!\n", debugstr_guid(clsid), debugstr_guid(riid), out);
 374     return CLASS_E_CLASSNOTAVAILABLE;
 375 }
 376
 377 HRESULT WINAPI DllGetActivationFactory(HSTRING classid, IActivationFactory **factory)
 378 {
 379     TRACE("classid %s, factory %p.\n", debugstr_hstring(classid), factory);
 380     *factory = &windows_media_devices.IActivationFactory_iface;
 381     IUnknown_AddRef(*factory);
 382     return S_OK;
 383 }