dlls/mmdevapi/client.c

   1 /*
   2  * Copyright 2011-2012 Maarten Lankhorst
   3  * Copyright 2010-2011 Maarten Lankhorst for CodeWeavers
   4  * Copyright 2011 Andrew Eikum for CodeWeavers
   5  * Copyright 2022 Huw Davies
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #define COBJMACROS
  23
  24 #include <audiopolicy.h>
  25 #include <mmdeviceapi.h>
  26 #include <winternl.h>
  27
  28 #include <wine/debug.h>
  29 #include <wine/unixlib.h>
  30
  31 #include "mmdevdrv.h"
  32 #include "unixlib.h"
  33
  34 WINE_DEFAULT_DEBUG_CHANNEL(mmdevapi);
  35
  36 extern void sessions_lock(void) DECLSPEC_HIDDEN;
  37 extern void sessions_unlock(void) DECLSPEC_HIDDEN;
  38
  39 void set_stream_volumes(struct audio_client *This)
  40 {
  41     struct set_volumes_params params;
  42
  43     params.stream          = This->stream;
  44     params.master_volume   = (This->session->mute ? 0.0f : This->session->master_vol);
  45     params.volumes         = This->vols;
  46     params.session_volumes = This->session->channel_vols;
  47
  48     WINE_UNIX_CALL(set_volumes, &params);
  49 }
  50
  51 static inline struct audio_client *impl_from_IAudioCaptureClient(IAudioCaptureClient *iface)
  52 {
  53     return CONTAINING_RECORD(iface, struct audio_client, IAudioCaptureClient_iface);
  54 }
  55
  56 static inline struct audio_client *impl_from_IAudioClock(IAudioClock *iface)
  57 {
  58     return CONTAINING_RECORD(iface, struct audio_client, IAudioClock_iface);
  59 }
  60
  61 static inline struct audio_client *impl_from_IAudioClock2(IAudioClock2 *iface)
  62 {
  63     return CONTAINING_RECORD(iface, struct audio_client, IAudioClock2_iface);
  64 }
  65
  66 static inline struct audio_client *impl_from_IAudioStreamVolume(IAudioStreamVolume *iface)
  67 {
  68     return CONTAINING_RECORD(iface, struct audio_client, IAudioStreamVolume_iface);
  69 }
  70
  71 static HRESULT WINAPI capture_QueryInterface(IAudioCaptureClient *iface, REFIID riid, void **ppv)
  72 {
  73     struct audio_client *This = impl_from_IAudioCaptureClient(iface);
  74
  75     TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
  76
  77     if (!ppv)
  78         return E_POINTER;
  79
  80     if (IsEqualIID(riid, &IID_IUnknown) ||
  81         IsEqualIID(riid, &IID_IAudioCaptureClient))
  82         *ppv = iface;
  83     else if (IsEqualIID(riid, &IID_IMarshal)) {
  84         return IUnknown_QueryInterface(This->marshal, riid, ppv);
  85     } else {
  86         *ppv = NULL;
  87         return E_NOINTERFACE;
  88     }
  89
  90     IUnknown_AddRef((IUnknown *)*ppv);
  91
  92     return S_OK;
  93 }
  94
  95 static ULONG WINAPI capture_AddRef(IAudioCaptureClient *iface)
  96 {
  97     struct audio_client *This = impl_from_IAudioCaptureClient(iface);
  98     return IAudioClient3_AddRef(&This->IAudioClient3_iface);
  99 }
 100
 101 static ULONG WINAPI capture_Release(IAudioCaptureClient *iface)
 102 {
 103     struct audio_client *This = impl_from_IAudioCaptureClient(iface);
 104     return IAudioClient3_Release(&This->IAudioClient3_iface);
 105 }
 106
 107 static HRESULT WINAPI capture_GetBuffer(IAudioCaptureClient *iface, BYTE **data, UINT32 *frames,
 108                                         DWORD *flags, UINT64 *devpos, UINT64 *qpcpos)
 109 {
 110     struct audio_client *This = impl_from_IAudioCaptureClient(iface);
 111     struct get_capture_buffer_params params;
 112
 113     TRACE("(%p)->(%p, %p, %p, %p, %p)\n", This, data, frames, flags, devpos, qpcpos);
 114
 115     if (!data)
 116         return E_POINTER;
 117
 118     *data = NULL;
 119
 120     if (!frames || !flags)
 121         return E_POINTER;
 122
 123     if (!This->stream)
 124         return AUDCLNT_E_NOT_INITIALIZED;
 125
 126     params.stream = This->stream;
 127     params.data   = data;
 128     params.frames = frames;
 129     params.flags  = (UINT *)flags;
 130     params.devpos = devpos;
 131     params.qpcpos = qpcpos;
 132
 133     WINE_UNIX_CALL(get_capture_buffer, &params);
 134
 135     return params.result;
 136 }
 137
 138 static HRESULT WINAPI capture_ReleaseBuffer(IAudioCaptureClient *iface, UINT32 done)
 139 {
 140     struct audio_client *This = impl_from_IAudioCaptureClient(iface);
 141     struct release_capture_buffer_params params;
 142
 143     TRACE("(%p)->(%u)\n", This, done);
 144
 145     if (!This->stream)
 146         return AUDCLNT_E_NOT_INITIALIZED;
 147
 148     params.stream = This->stream;
 149     params.done   = done;
 150
 151     WINE_UNIX_CALL(release_capture_buffer, &params);
 152
 153     return params.result;
 154 }
 155
 156 static HRESULT WINAPI capture_GetNextPacketSize(IAudioCaptureClient *iface, UINT32 *frames)
 157 {
 158     struct audio_client *This = impl_from_IAudioCaptureClient(iface);
 159     struct get_next_packet_size_params params;
 160
 161     TRACE("(%p)->(%p)\n", This, frames);
 162
 163     if (!frames)
 164         return E_POINTER;
 165
 166     if (!This->stream)
 167         return AUDCLNT_E_NOT_INITIALIZED;
 168
 169     params.stream = This->stream;
 170     params.frames = frames;
 171
 172     WINE_UNIX_CALL(get_next_packet_size, &params);
 173
 174     return params.result;
 175 }
 176
 177 const IAudioCaptureClientVtbl AudioCaptureClient_Vtbl =
 178 {
 179     capture_QueryInterface,
 180     capture_AddRef,
 181     capture_Release,
 182     capture_GetBuffer,
 183     capture_ReleaseBuffer,
 184     capture_GetNextPacketSize
 185 };
 186
 187 static HRESULT WINAPI clock_QueryInterface(IAudioClock *iface, REFIID riid, void **ppv)
 188 {
 189     struct audio_client *This = impl_from_IAudioClock(iface);
 190
 191     TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
 192
 193     if (!ppv)
 194         return E_POINTER;
 195
 196     if (IsEqualIID(riid, &IID_IUnknown) ||
 197         IsEqualIID(riid, &IID_IAudioClock))
 198         *ppv = iface;
 199     else if (IsEqualIID(riid, &IID_IAudioClock2))
 200         *ppv = &This->IAudioClock2_iface;
 201     else if (IsEqualIID(riid, &IID_IMarshal)) {
 202         return IUnknown_QueryInterface(This->marshal, riid, ppv);
 203     } else {
 204         *ppv = NULL;
 205         return E_NOINTERFACE;
 206     }
 207
 208     IUnknown_AddRef((IUnknown *)*ppv);
 209
 210     return S_OK;
 211 }
 212
 213 static ULONG WINAPI clock_AddRef(IAudioClock *iface)
 214 {
 215     struct audio_client *This = impl_from_IAudioClock(iface);
 216     return IAudioClient3_AddRef(&This->IAudioClient3_iface);
 217 }
 218
 219 static ULONG WINAPI clock_Release(IAudioClock *iface)
 220 {
 221     struct audio_client *This = impl_from_IAudioClock(iface);
 222     return IAudioClient3_Release(&This->IAudioClient3_iface);
 223 }
 224
 225 static HRESULT WINAPI clock_GetFrequency(IAudioClock *iface, UINT64 *freq)
 226 {
 227     struct audio_client *This = impl_from_IAudioClock(iface);
 228     struct get_frequency_params params;
 229
 230     TRACE("(%p)->(%p)\n", This, freq);
 231
 232     if (!This->stream)
 233         return AUDCLNT_E_NOT_INITIALIZED;
 234
 235     params.stream = This->stream;
 236     params.freq   = freq;
 237
 238     WINE_UNIX_CALL(get_frequency, &params);
 239
 240     return params.result;
 241 }
 242
 243 static HRESULT WINAPI clock_GetPosition(IAudioClock *iface, UINT64 *pos, UINT64 *qpctime)
 244 {
 245     struct audio_client *This = impl_from_IAudioClock(iface);
 246     struct get_position_params params;
 247
 248     TRACE("(%p)->(%p, %p)\n", This, pos, qpctime);
 249
 250     if (!pos)
 251         return E_POINTER;
 252
 253     if (!This->stream)
 254         return AUDCLNT_E_NOT_INITIALIZED;
 255
 256     params.stream  = This->stream;
 257     params.device  = FALSE;
 258     params.pos     = pos;
 259     params.qpctime = qpctime;
 260
 261     WINE_UNIX_CALL(get_position, &params);
 262
 263     return params.result;
 264 }
 265
 266 static HRESULT WINAPI clock_GetCharacteristics(IAudioClock *iface, DWORD *chars)
 267 {
 268     struct audio_client *This = impl_from_IAudioClock(iface);
 269
 270     TRACE("(%p)->(%p)\n", This, chars);
 271
 272     if (!chars)
 273         return E_POINTER;
 274
 275     *chars = AUDIOCLOCK_CHARACTERISTIC_FIXED_FREQ;
 276
 277     return S_OK;
 278 }
 279
 280 const IAudioClockVtbl AudioClock_Vtbl =
 281 {
 282     clock_QueryInterface,
 283     clock_AddRef,
 284     clock_Release,
 285     clock_GetFrequency,
 286     clock_GetPosition,
 287     clock_GetCharacteristics
 288 };
 289
 290 static HRESULT WINAPI clock2_QueryInterface(IAudioClock2 *iface, REFIID riid, void **ppv)
 291 {
 292     struct audio_client *This = impl_from_IAudioClock2(iface);
 293     return IAudioClock_QueryInterface(&This->IAudioClock_iface, riid, ppv);
 294 }
 295
 296 static ULONG WINAPI clock2_AddRef(IAudioClock2 *iface)
 297 {
 298     struct audio_client *This = impl_from_IAudioClock2(iface);
 299     return IAudioClient3_AddRef(&This->IAudioClient3_iface);
 300 }
 301
 302 static ULONG WINAPI clock2_Release(IAudioClock2 *iface)
 303 {
 304     struct audio_client *This = impl_from_IAudioClock2(iface);
 305     return IAudioClient3_Release(&This->IAudioClient3_iface);
 306 }
 307
 308 static HRESULT WINAPI clock2_GetDevicePosition(IAudioClock2 *iface, UINT64 *pos, UINT64 *qpctime)
 309 {
 310     struct audio_client *This = impl_from_IAudioClock2(iface);
 311     struct get_position_params params;
 312
 313     TRACE("(%p)->(%p, %p)\n", This, pos, qpctime);
 314
 315     if (!pos)
 316         return E_POINTER;
 317
 318     if (!This->stream)
 319         return AUDCLNT_E_NOT_INITIALIZED;
 320
 321     params.stream  = This->stream;
 322     params.device  = TRUE;
 323     params.pos     = pos;
 324     params.qpctime = qpctime;
 325
 326     WINE_UNIX_CALL(get_position, &params);
 327
 328     return params.result;
 329 }
 330
 331 const IAudioClock2Vtbl AudioClock2_Vtbl =
 332 {
 333     clock2_QueryInterface,
 334     clock2_AddRef,
 335     clock2_Release,
 336     clock2_GetDevicePosition
 337 };
 338
 339 static HRESULT WINAPI streamvolume_QueryInterface(IAudioStreamVolume *iface, REFIID riid,
 340                                                   void **ppv)
 341 {
 342     TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
 343
 344     if (!ppv)
 345         return E_POINTER;
 346
 347     if (IsEqualIID(riid, &IID_IUnknown) ||
 348         IsEqualIID(riid, &IID_IAudioStreamVolume))
 349         *ppv = iface;
 350     else if (IsEqualIID(riid, &IID_IMarshal)) {
 351         struct audio_client *This = impl_from_IAudioStreamVolume(iface);
 352         return IUnknown_QueryInterface(This->marshal, riid, ppv);
 353     } else {
 354         *ppv = NULL;
 355         return E_NOINTERFACE;
 356     }
 357
 358     IUnknown_AddRef((IUnknown *)*ppv);
 359
 360     return S_OK;
 361 }
 362
 363 static ULONG WINAPI streamvolume_AddRef(IAudioStreamVolume *iface)
 364 {
 365     struct audio_client *This = impl_from_IAudioStreamVolume(iface);
 366     return IAudioClient3_AddRef(&This->IAudioClient3_iface);
 367 }
 368
 369 static ULONG WINAPI streamvolume_Release(IAudioStreamVolume *iface)
 370 {
 371     struct audio_client *This = impl_from_IAudioStreamVolume(iface);
 372     return IAudioClient3_Release(&This->IAudioClient3_iface);
 373 }
 374
 375 static HRESULT WINAPI streamvolume_GetChannelCount(IAudioStreamVolume *iface, UINT32 *out)
 376 {
 377     struct audio_client *This = impl_from_IAudioStreamVolume(iface);
 378
 379     TRACE("(%p)->(%p)\n", This, out);
 380
 381     if (!out)
 382         return E_POINTER;
 383
 384     *out = This->channel_count;
 385
 386     return S_OK;
 387 }
 388
 389 static HRESULT WINAPI streamvolume_SetChannelVolume(IAudioStreamVolume *iface, UINT32 index,
 390                                                     float level)
 391 {
 392     struct audio_client *This = impl_from_IAudioStreamVolume(iface);
 393
 394     TRACE("(%p)->(%d, %f)\n", This, index, level);
 395
 396     if (level < 0.f || level > 1.f)
 397         return E_INVALIDARG;
 398
 399     if (!This->stream)
 400         return AUDCLNT_E_NOT_INITIALIZED;
 401
 402     if (index >= This->channel_count)
 403         return E_INVALIDARG;
 404
 405     sessions_lock();
 406
 407     This->vols[index] = level;
 408     set_stream_volumes(This);
 409
 410     sessions_unlock();
 411
 412     return S_OK;
 413 }
 414
 415 static HRESULT WINAPI streamvolume_GetChannelVolume(IAudioStreamVolume *iface, UINT32 index,
 416                                                     float *level)
 417 {
 418     struct audio_client *This = impl_from_IAudioStreamVolume(iface);
 419
 420     TRACE("(%p)->(%d, %p)\n", This, index, level);
 421
 422     if (!level)
 423         return E_POINTER;
 424
 425     if (!This->stream)
 426         return AUDCLNT_E_NOT_INITIALIZED;
 427
 428     if (index >= This->channel_count)
 429         return E_INVALIDARG;
 430
 431     *level = This->vols[index];
 432
 433     return S_OK;
 434 }
 435
 436 static HRESULT WINAPI streamvolume_SetAllVolumes(IAudioStreamVolume *iface, UINT32 count,
 437                                                  const float *levels)
 438 {
 439     struct audio_client *This = impl_from_IAudioStreamVolume(iface);
 440     unsigned int i;
 441
 442     TRACE("(%p)->(%d, %p)\n", This, count, levels);
 443
 444     if (!levels)
 445         return E_POINTER;
 446
 447     if (!This->stream)
 448         return AUDCLNT_E_NOT_INITIALIZED;
 449
 450     if (count != This->channel_count)
 451         return E_INVALIDARG;
 452
 453     sessions_lock();
 454
 455     for (i = 0; i < count; ++i)
 456         This->vols[i] = levels[i];
 457     set_stream_volumes(This);
 458
 459     sessions_unlock();
 460
 461     return S_OK;
 462 }
 463
 464 static HRESULT WINAPI streamvolume_GetAllVolumes(IAudioStreamVolume *iface, UINT32 count,
 465                                                  float *levels)
 466 {
 467     struct audio_client *This = impl_from_IAudioStreamVolume(iface);
 468     unsigned int i;
 469
 470     TRACE("(%p)->(%d, %p)\n", This, count, levels);
 471
 472     if (!levels)
 473         return E_POINTER;
 474
 475     if (!This->stream)
 476         return AUDCLNT_E_NOT_INITIALIZED;
 477
 478     if (count != This->channel_count)
 479         return E_INVALIDARG;
 480
 481     sessions_lock();
 482
 483     for (i = 0; i < count; ++i)
 484         levels[i] = This->vols[i];
 485
 486     sessions_unlock();
 487
 488     return S_OK;
 489 }
 490
 491 const IAudioStreamVolumeVtbl AudioStreamVolume_Vtbl =
 492 {
 493     streamvolume_QueryInterface,
 494     streamvolume_AddRef,
 495     streamvolume_Release,
 496     streamvolume_GetChannelCount,
 497     streamvolume_SetChannelVolume,
 498     streamvolume_GetChannelVolume,
 499     streamvolume_SetAllVolumes,
 500     streamvolume_GetAllVolumes
 501 };