modules/access/wasapi.c

   1 /**
   2  * \file wasapi.c
   3  * \brief Windows Audio Session API capture plugin for VLC
   4  */
   5 /*****************************************************************************
   6  * Copyright (C) 2014-2015 Rémi Denis-Courmont
   7  *
   8  * This program is free software; you can redistribute it and/or modify it
   9  * under the terms of the GNU Lesser General Public License as published by
  10  * the Free Software Foundation; either version 2.1 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  16  * GNU Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public License
  19  * along with this program; if not, write to the Free Software Foundation,
  20  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  21  *****************************************************************************/
  22
  23 #ifdef HAVE_CONFIG_H
  24 # include "config.h"
  25 #endif
  26
  27 #define INITGUID
  28 #define COBJMACROS
  29 #define CONST_VTABLE
  30
  31 #include <assert.h>
  32 #include <stdlib.h>
  33
  34 #include <vlc_common.h>
  35 #include <vlc_aout.h>
  36 #include <vlc_demux.h>
  37 #include <vlc_plugin.h>
  38 #include <mmdeviceapi.h>
  39 #include <audioclient.h>
  40
  41 static LARGE_INTEGER freq; /* performance counters frequency */
  42
  43 BOOL WINAPI DllMain(HINSTANCE, DWORD, LPVOID); /* avoid warning */
  44
  45 BOOL WINAPI DllMain(HINSTANCE dll, DWORD reason, LPVOID reserved)
  46 {
  47     (void) dll;
  48     (void) reserved;
  49
  50     switch (reason)
  51     {
  52         case DLL_PROCESS_ATTACH:
  53             if (!QueryPerformanceFrequency(&freq))
  54                 return FALSE;
  55             break;
  56     }
  57     return TRUE;
  58 }
  59
  60 static UINT64 GetQPC(void)
  61 {
  62     LARGE_INTEGER counter;
  63
  64     if (!QueryPerformanceCounter(&counter))
  65         abort();
  66
  67     lldiv_t d = lldiv(counter.QuadPart, freq.QuadPart);
  68     return (d.quot * 10000000) + ((d.rem * 10000000) / freq.QuadPart);
  69 }
  70
  71 static_assert(CLOCK_FREQ * 10 == 10000000,
  72               "REFERENCE_TIME conversion broken");
  73
  74 static EDataFlow GetDeviceFlow(IMMDevice *dev)
  75 {
  76     void *pv;
  77
  78     if (FAILED(IMMDevice_QueryInterface(dev, &IID_IMMEndpoint, &pv)))
  79         return false;
  80
  81     IMMEndpoint *ep = pv;
  82     EDataFlow flow;
  83
  84     if (SUCCEEDED(IMMEndpoint_GetDataFlow(ep, &flow)))
  85         flow = eAll;
  86     IMMEndpoint_Release(ep);
  87     return flow;
  88 }
  89
  90 static IAudioClient *GetClient(demux_t *demux, bool *restrict loopbackp)
  91 {
  92     IMMDeviceEnumerator *e;
  93     IMMDevice *dev;
  94     void *pv;
  95     HRESULT hr;
  96
  97     hr = CoCreateInstance(&CLSID_MMDeviceEnumerator, NULL, CLSCTX_ALL,
  98                           &IID_IMMDeviceEnumerator, &pv);
  99     if (FAILED(hr))
 100     {
 101         msg_Err(demux, "cannot create device enumerator (error 0x%lx)", hr);
 102         return NULL;
 103     }
 104     e = pv;
 105
 106     bool loopback = var_InheritBool(demux, "wasapi-loopback");
 107     EDataFlow flow = loopback ? eRender : eCapture;
 108     ERole role = loopback ? eConsole : eCommunications;
 109
 110     hr = IMMDeviceEnumerator_GetDefaultAudioEndpoint(e, flow, role, &dev);
 111     IMMDeviceEnumerator_Release(e);
 112     if (FAILED(hr))
 113     {
 114         msg_Err(demux, "cannot get default device (error 0x%lx)", hr);
 115         return NULL;
 116     }
 117
 118     hr = IMMDevice_Activate(dev, &IID_IAudioClient, CLSCTX_ALL, NULL, &pv);
 119     *loopbackp = GetDeviceFlow(dev) == eRender;
 120     IMMDevice_Release(dev);
 121     if (FAILED(hr))
 122         msg_Err(demux, "cannot activate device (error 0x%lx)", hr);
 123     return pv;
 124 }
 125
 126 static int vlc_FromWave(const WAVEFORMATEX *restrict wf,
 127                         audio_sample_format_t *restrict fmt)
 128 {
 129     fmt->i_rate = wf->nSamplesPerSec;
 130
 131     /* As per MSDN, IAudioClient::GetMixFormat() always uses this format. */
 132     assert(wf->wFormatTag == WAVE_FORMAT_EXTENSIBLE);
 133
 134     const WAVEFORMATEXTENSIBLE *wfe = (void *)wf;
 135
 136     fmt->i_physical_channels = 0;
 137     if (wfe->dwChannelMask & SPEAKER_FRONT_LEFT)
 138         fmt->i_physical_channels |= AOUT_CHAN_LEFT;
 139     if (wfe->dwChannelMask & SPEAKER_FRONT_RIGHT)
 140         fmt->i_physical_channels |= AOUT_CHAN_RIGHT;
 141     if (wfe->dwChannelMask & SPEAKER_FRONT_CENTER)
 142         fmt->i_physical_channels |= AOUT_CHAN_CENTER;
 143     if (wfe->dwChannelMask & SPEAKER_LOW_FREQUENCY)
 144         fmt->i_physical_channels |= AOUT_CHAN_LFE;
 145
 146     fmt->i_original_channels = fmt->i_physical_channels;
 147     assert(popcount(wfe->dwChannelMask) == wf->nChannels);
 148
 149     if (IsEqualIID(&wfe->SubFormat, &KSDATAFORMAT_SUBTYPE_PCM))
 150     {
 151         switch (wf->wBitsPerSample)
 152         {
 153             case 32:
 154                 switch (wfe->Samples.wValidBitsPerSample)
 155                 {
 156                     case 32:
 157                         fmt->i_format = VLC_CODEC_S32N;
 158                         break;
 159                     case 24:
 160 #ifdef WORDS_BIGENDIAN
 161                         fmt->i_format = VLC_CODEC_S24B32;
 162 #else
 163                         fmt->i_format = VLC_CODEC_S24L32;
 164 #endif
 165                         break;
 166                     default:
 167                         return -1;
 168                 }
 169                 break;
 170             case 24:
 171                 if (wfe->Samples.wValidBitsPerSample == 24)
 172                     fmt->i_format = VLC_CODEC_S24N;
 173                 else
 174                     return -1;
 175                 break;
 176             case 16:
 177                 if (wfe->Samples.wValidBitsPerSample == 16)
 178                     fmt->i_format = VLC_CODEC_S16N;
 179                 else
 180                     return -1;
 181                 break;
 182             case 8:
 183                 if (wfe->Samples.wValidBitsPerSample == 8)
 184                     fmt->i_format = VLC_CODEC_S8;
 185                 else
 186                     return -1;
 187                 break;
 188             default:
 189                 return -1;
 190         }
 191     }
 192     else if (IsEqualIID(&wfe->SubFormat, &KSDATAFORMAT_SUBTYPE_IEEE_FLOAT))
 193     {
 194         if (wf->wBitsPerSample != wfe->Samples.wValidBitsPerSample)
 195             return -1;
 196
 197         switch (wf->wBitsPerSample)
 198         {
 199             case 64:
 200                 fmt->i_format = VLC_CODEC_FL64;
 201                 break;
 202             case 32:
 203                 fmt->i_format = VLC_CODEC_FL32;
 204                 break;
 205             default:
 206                 return -1;
 207         }
 208     }
 209     /*else if (IsEqualIID(&wfe->Subformat, &KSDATAFORMAT_SUBTYPE_DRM)) {} */
 210     else if (IsEqualIID(&wfe->SubFormat, &KSDATAFORMAT_SUBTYPE_ALAW))
 211         fmt->i_format = VLC_CODEC_ALAW;
 212     else if (IsEqualIID(&wfe->SubFormat, &KSDATAFORMAT_SUBTYPE_MULAW))
 213         fmt->i_format = VLC_CODEC_MULAW;
 214     else if (IsEqualIID(&wfe->SubFormat, &KSDATAFORMAT_SUBTYPE_ADPCM))
 215         fmt->i_format = VLC_CODEC_ADPCM_MS;
 216     else
 217         return -1;
 218
 219     aout_FormatPrepare(fmt);
 220     if (wf->nChannels != fmt->i_channels)
 221         return -1;
 222
 223     return 0;
 224 }
 225
 226 static es_out_id_t *CreateES(demux_t *demux, IAudioClient *client, bool loop,
 227                              mtime_t caching, size_t *restrict frame_size)
 228 {
 229     es_format_t fmt;
 230     WAVEFORMATEX *pwf;
 231     HRESULT hr;
 232
 233     hr = IAudioClient_GetMixFormat(client, &pwf);
 234     if (FAILED(hr))
 235     {
 236         msg_Err(demux, "cannot get mix format (error 0x%lx)", hr);
 237         return NULL;
 238     }
 239
 240     es_format_Init(&fmt, AUDIO_ES, 0);
 241     if (vlc_FromWave(pwf, &fmt.audio))
 242     {
 243         msg_Err(demux, "unsupported mix format");
 244         CoTaskMemFree(pwf);
 245         return NULL;
 246     }
 247
 248     fmt.i_codec = fmt.audio.i_format;
 249     fmt.i_bitrate = fmt.audio.i_bitspersample * fmt.audio.i_channels
 250                                               * fmt.audio.i_rate;
 251     *frame_size = fmt.audio.i_bitspersample * fmt.audio.i_channels / 8;
 252
 253     DWORD flags = AUDCLNT_STREAMFLAGS_EVENTCALLBACK;
 254     if (loop)
 255         flags |= AUDCLNT_STREAMFLAGS_LOOPBACK;
 256
 257     /* Request at least thrice the PTS delay */
 258     REFERENCE_TIME bufsize = caching * INT64_C(10) * 3;
 259
 260     hr = IAudioClient_Initialize(client, AUDCLNT_SHAREMODE_SHARED, flags,
 261                                  bufsize, 0, pwf, NULL);
 262     CoTaskMemFree(pwf);
 263     if (FAILED(hr))
 264     {
 265         msg_Err(demux, "cannot initialize audio client (error 0x%lx)", hr);
 266         return NULL;
 267     }
 268     return es_out_Add(demux->out, &fmt);
 269 }
 270
 271 struct demux_sys_t
 272 {
 273     IAudioClient *client;
 274     es_out_id_t *es;
 275
 276     size_t frame_size;
 277     mtime_t caching;
 278     mtime_t start_time;
 279
 280     HANDLE events[2];
 281     union {
 282         HANDLE thread;
 283         HANDLE ready;
 284     };
 285 };
 286
 287 static unsigned __stdcall Thread(void *data)
 288 {
 289     demux_t *demux = data;
 290     demux_sys_t *sys = demux->p_sys;
 291     IAudioCaptureClient *capture = NULL;
 292     void *pv;
 293     HRESULT hr;
 294
 295     hr = CoInitializeEx(NULL, COINIT_MULTITHREADED);
 296     assert(SUCCEEDED(hr)); /* COM already allocated by parent thread */
 297     SetEvent(sys->ready);
 298
 299     hr = IAudioClient_GetService(sys->client, &IID_IAudioCaptureClient, &pv);
 300     if (FAILED(hr))
 301     {
 302         msg_Err(demux, "cannot get capture client (error 0x%lx)", hr);
 303         goto out;
 304     }
 305     capture = pv;
 306
 307     hr = IAudioClient_Start(sys->client);
 308     if (FAILED(hr))
 309     {
 310         msg_Err(demux, "cannot start client (error 0x%lx)", hr);
 311         IAudioCaptureClient_Release(capture);
 312         goto out;
 313     }
 314
 315     while (WaitForMultipleObjects(2, sys->events, FALSE, INFINITE)
 316             != WAIT_OBJECT_0)
 317     {
 318         BYTE *data;
 319         UINT32 frames;
 320         DWORD flags;
 321         UINT64 qpc;
 322         mtime_t pts;
 323
 324         hr = IAudioCaptureClient_GetBuffer(capture, &data, &frames, &flags,
 325                                            NULL, &qpc);
 326         if (hr != S_OK)
 327             continue;
 328
 329         pts = mdate() - ((GetQPC() - qpc) / 10);
 330
 331         es_out_Control(demux->out, ES_OUT_SET_PCR, pts);
 332
 333         size_t bytes = frames * sys->frame_size;
 334         block_t *block = block_Alloc(bytes);
 335
 336         if (likely(block != NULL)) {
 337             memcpy(block->p_buffer, data, bytes);
 338             block->i_nb_samples = frames;
 339             block->i_pts = block->i_dts = pts;
 340             es_out_Send(demux->out, sys->es, block);
 341         }
 342
 343         IAudioCaptureClient_ReleaseBuffer(capture, frames);
 344     }
 345
 346     IAudioClient_Stop(sys->client);
 347     IAudioCaptureClient_Release(capture);
 348 out:
 349     CoUninitialize();
 350     return 0;
 351 }
 352
 353 static int Control(demux_t *demux, int query, va_list ap)
 354 {
 355     demux_sys_t *sys = demux->p_sys;
 356
 357     switch (query)
 358     {
 359         case DEMUX_GET_TIME:
 360             *(va_arg(ap, int64_t *)) = mdate() - sys->start_time;
 361             break;
 362
 363         case DEMUX_GET_PTS_DELAY:
 364             *(va_arg(ap, int64_t *)) = sys->caching;
 365             break;
 366
 367         case DEMUX_HAS_UNSUPPORTED_META:
 368         case DEMUX_CAN_RECORD:
 369         case DEMUX_CAN_PAUSE:
 370         case DEMUX_CAN_CONTROL_PACE:
 371         case DEMUX_CAN_CONTROL_RATE:
 372         case DEMUX_CAN_SEEK:
 373             *(va_arg(ap, bool *)) = false;
 374             break;
 375
 376         default:
 377             return VLC_EGENERIC;
 378     }
 379
 380     return VLC_SUCCESS;
 381 }
 382
 383 static int Open(vlc_object_t *obj)
 384 {
 385     demux_t *demux = (demux_t *)obj;
 386     HRESULT hr;
 387
 388     if (demux->psz_location != NULL && demux->psz_location != '\0')
 389         return VLC_EGENERIC; /* TODO non-default device */
 390
 391     demux_sys_t *sys = malloc(sizeof (*sys));
 392     if (unlikely(sys == NULL))
 393         return VLC_ENOMEM;
 394
 395     sys->client = NULL;
 396     sys->es = NULL;
 397     sys->caching = INT64_C(1000) * var_InheritInteger(obj, "live-caching");
 398     sys->start_time = mdate();
 399     for (unsigned i = 0; i < 2; i++)
 400         sys->events[i] = NULL;
 401
 402     for (unsigned i = 0; i < 2; i++) {
 403         sys->events[i] = CreateEvent(NULL, FALSE, FALSE, NULL);
 404         if (sys->events[i] == NULL)
 405             goto error;
 406     }
 407
 408     hr = CoInitializeEx(NULL, COINIT_MULTITHREADED);
 409     if (unlikely(FAILED(hr))) {
 410         msg_Err(demux, "cannot initialize COM (error 0x%lx)", hr);
 411         goto error;
 412     }
 413
 414     bool loopback;
 415     sys->client = GetClient(demux, &loopback);
 416     if (sys->client == NULL) {
 417         CoUninitialize();
 418         goto error;
 419     }
 420
 421     sys->es = CreateES(demux, sys->client, loopback, sys->caching,
 422                        &sys->frame_size);
 423     if (sys->es == NULL)
 424         goto error;
 425
 426     hr = IAudioClient_SetEventHandle(sys->client, sys->events[1]);
 427     if (FAILED(hr)) {
 428         msg_Err(demux, "cannot set event handle (error 0x%lx)", hr);
 429         goto error;
 430     }
 431
 432     demux->p_sys = sys;
 433
 434     sys->ready = CreateEvent(NULL, FALSE, FALSE, NULL);
 435     if (sys->ready == NULL)
 436         goto error;
 437
 438     uintptr_t h = _beginthreadex(NULL, 0, Thread, demux, 0, NULL);
 439     if (h != 0)
 440         WaitForSingleObject(sys->ready, INFINITE);
 441     CloseHandle(sys->ready);
 442
 443     sys->thread = (HANDLE)h;
 444     if (sys->thread == NULL)
 445         goto error;
 446     CoUninitialize();
 447
 448     demux->pf_demux = NULL;
 449     demux->pf_control = Control;
 450     return VLC_SUCCESS;
 451
 452 error:
 453     if (sys->es != NULL)
 454         es_out_Del(demux->out, sys->es);
 455     if (sys->client != NULL)
 456     {
 457         IAudioClient_Release(sys->client);
 458         CoUninitialize();
 459     }
 460     for (unsigned i = 0; i < 2; i++)
 461         if (sys->events[i] != NULL)
 462             CloseHandle(sys->events[i]);
 463     free(sys);
 464     return VLC_ENOMEM;
 465 }
 466
 467 static void Close (vlc_object_t *obj)
 468 {
 469     demux_t *demux = (demux_t *)obj;
 470     demux_sys_t *sys = demux->p_sys;
 471     HRESULT hr;
 472
 473     hr = CoInitializeEx(NULL, COINIT_MULTITHREADED);
 474     assert(SUCCEEDED(hr));
 475
 476     SetEvent(sys->events[0]);
 477     WaitForSingleObject(sys->thread, INFINITE);
 478     CloseHandle(sys->thread);
 479
 480     es_out_Del(demux->out, sys->es);
 481     IAudioClient_Release(sys->client);
 482     CoUninitialize();
 483     for (unsigned i = 0; i < 2; i++)
 484         CloseHandle(sys->events[i]);
 485     free(sys);
 486 }
 487
 488 #define LOOPBACK_TEXT N_("Loopback mode")
 489 #define LOOPBACK_LONGTEXT N_("Record an audio rendering endpoint.")
 490
 491 vlc_module_begin()
 492     set_shortname(N_("WASAPI"))
 493     set_description(N_("Windows Audio Session API input"))
 494     set_capability("access_demux", 0)
 495     set_category(CAT_INPUT)
 496     set_subcategory(SUBCAT_INPUT_ACCESS)
 497
 498     add_bool("wasapi-loopback", false, LOOPBACK_TEXT, LOOPBACK_LONGTEXT, true)
 499
 500     add_shortcut("wasapi")
 501     set_callbacks(Open, Close)
 502 vlc_module_end()