sys/wasapi/gstwasapisrc.c

   1 /*
   2  * Copyright (C) 2008 Ole André Vadla Ravnås <ole.andre.ravnas@tandberg.com>
   3  * Copyright (C) 2018 Centricular Ltd.
   4  *   Author: Nirbheek Chauhan <nirbheek@centricular.com>
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Library General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Library General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Library General Public
  17  * License along with this library; if not, write to the
  18  * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
  19  * Boston, MA 02110-1301, USA.
  20  */
  21
  22 /**
  23  * SECTION:element-wasapisrc
  24  * @title: wasapisrc
  25  *
  26  * Provides audio capture from the Windows Audio Session API available with
  27  * Vista and newer.
  28  *
  29  * ## Example pipelines
  30  * |[
  31  * gst-launch-1.0 -v wasapisrc ! fakesink
  32  * ]| Capture from the default audio device and render to fakesink.
  33  *
  34  */
  35 #ifdef HAVE_CONFIG_H
  36 #  include <config.h>
  37 #endif
  38
  39 #include "gstwasapisrc.h"
  40
  41 #include <avrt.h>
  42
  43 GST_DEBUG_CATEGORY_STATIC (gst_wasapi_src_debug);
  44 #define GST_CAT_DEFAULT gst_wasapi_src_debug
  45
  46 static GstStaticPadTemplate src_template = GST_STATIC_PAD_TEMPLATE ("src",
  47     GST_PAD_SRC,
  48     GST_PAD_ALWAYS,
  49     GST_STATIC_CAPS (GST_WASAPI_STATIC_CAPS));
  50
  51 #define DEFAULT_ROLE          GST_WASAPI_DEVICE_ROLE_CONSOLE
  52 #define DEFAULT_EXCLUSIVE     FALSE
  53 #define DEFAULT_LOW_LATENCY   FALSE
  54
  55 enum
  56 {
  57   PROP_0,
  58   PROP_ROLE,
  59   PROP_DEVICE,
  60   PROP_EXCLUSIVE,
  61   PROP_LOW_LATENCY
  62 };
  63
  64 static void gst_wasapi_src_dispose (GObject * object);
  65 static void gst_wasapi_src_finalize (GObject * object);
  66 static void gst_wasapi_src_set_property (GObject * object, guint prop_id,
  67     const GValue * value, GParamSpec * pspec);
  68 static void gst_wasapi_src_get_property (GObject * object, guint prop_id,
  69     GValue * value, GParamSpec * pspec);
  70
  71 static GstCaps *gst_wasapi_src_get_caps (GstBaseSrc * bsrc, GstCaps * filter);
  72
  73 static gboolean gst_wasapi_src_open (GstAudioSrc * asrc);
  74 static gboolean gst_wasapi_src_close (GstAudioSrc * asrc);
  75 static gboolean gst_wasapi_src_prepare (GstAudioSrc * asrc,
  76     GstAudioRingBufferSpec * spec);
  77 static gboolean gst_wasapi_src_unprepare (GstAudioSrc * asrc);
  78 static guint gst_wasapi_src_read (GstAudioSrc * asrc, gpointer data,
  79     guint length, GstClockTime * timestamp);
  80 static guint gst_wasapi_src_delay (GstAudioSrc * asrc);
  81 static void gst_wasapi_src_reset (GstAudioSrc * asrc);
  82
  83 static GstClockTime gst_wasapi_src_get_time (GstClock * clock,
  84     gpointer user_data);
  85
  86 #define gst_wasapi_src_parent_class parent_class
  87 G_DEFINE_TYPE (GstWasapiSrc, gst_wasapi_src, GST_TYPE_AUDIO_SRC);
  88
  89 static void
  90 gst_wasapi_src_class_init (GstWasapiSrcClass * klass)
  91 {
  92   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
  93   GstElementClass *gstelement_class = GST_ELEMENT_CLASS (klass);
  94   GstBaseSrcClass *gstbasesrc_class = GST_BASE_SRC_CLASS (klass);
  95   GstAudioSrcClass *gstaudiosrc_class = GST_AUDIO_SRC_CLASS (klass);
  96
  97   gobject_class->dispose = gst_wasapi_src_dispose;
  98   gobject_class->finalize = gst_wasapi_src_finalize;
  99   gobject_class->set_property = gst_wasapi_src_set_property;
 100   gobject_class->get_property = gst_wasapi_src_get_property;
 101
 102   g_object_class_install_property (gobject_class,
 103       PROP_ROLE,
 104       g_param_spec_enum ("role", "Role",
 105           "Role of the device: communications, multimedia, etc",
 106           GST_WASAPI_DEVICE_TYPE_ROLE, DEFAULT_ROLE, G_PARAM_READWRITE |
 107           G_PARAM_STATIC_STRINGS | GST_PARAM_MUTABLE_READY));
 108
 109   g_object_class_install_property (gobject_class,
 110       PROP_DEVICE,
 111       g_param_spec_string ("device", "Device",
 112           "WASAPI playback device as a GUID string",
 113           NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 114
 115   g_object_class_install_property (gobject_class,
 116       PROP_EXCLUSIVE,
 117       g_param_spec_boolean ("exclusive", "Exclusive mode",
 118           "Open the device in exclusive mode",
 119           DEFAULT_EXCLUSIVE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 120
 121   g_object_class_install_property (gobject_class,
 122       PROP_LOW_LATENCY,
 123       g_param_spec_boolean ("low-latency", "Low latency",
 124           "Optimize all settings for lowest latency",
 125           DEFAULT_LOW_LATENCY, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 126
 127   gst_element_class_add_static_pad_template (gstelement_class, &src_template);
 128   gst_element_class_set_static_metadata (gstelement_class, "WasapiSrc",
 129       "Source/Audio",
 130       "Stream audio from an audio capture device through WASAPI",
 131       "Ole André Vadla Ravnås <ole.andre.ravnas@tandberg.com>");
 132
 133   gstbasesrc_class->get_caps = GST_DEBUG_FUNCPTR (gst_wasapi_src_get_caps);
 134
 135   gstaudiosrc_class->open = GST_DEBUG_FUNCPTR (gst_wasapi_src_open);
 136   gstaudiosrc_class->close = GST_DEBUG_FUNCPTR (gst_wasapi_src_close);
 137   gstaudiosrc_class->read = GST_DEBUG_FUNCPTR (gst_wasapi_src_read);
 138   gstaudiosrc_class->prepare = GST_DEBUG_FUNCPTR (gst_wasapi_src_prepare);
 139   gstaudiosrc_class->unprepare = GST_DEBUG_FUNCPTR (gst_wasapi_src_unprepare);
 140   gstaudiosrc_class->delay = GST_DEBUG_FUNCPTR (gst_wasapi_src_delay);
 141   gstaudiosrc_class->reset = GST_DEBUG_FUNCPTR (gst_wasapi_src_reset);
 142
 143   GST_DEBUG_CATEGORY_INIT (gst_wasapi_src_debug, "wasapisrc",
 144       0, "Windows audio session API source");
 145 }
 146
 147 static void
 148 gst_wasapi_src_init (GstWasapiSrc * self)
 149 {
 150   /* override with a custom clock */
 151   if (GST_AUDIO_BASE_SRC (self)->clock)
 152     gst_object_unref (GST_AUDIO_BASE_SRC (self)->clock);
 153
 154   GST_AUDIO_BASE_SRC (self)->clock = gst_audio_clock_new ("GstWasapiSrcClock",
 155       gst_wasapi_src_get_time, gst_object_ref (self),
 156       (GDestroyNotify) gst_object_unref);
 157
 158   self->event_handle = CreateEvent (NULL, FALSE, FALSE, NULL);
 159
 160   CoInitialize (NULL);
 161 }
 162
 163 static void
 164 gst_wasapi_src_dispose (GObject * object)
 165 {
 166   GstWasapiSrc *self = GST_WASAPI_SRC (object);
 167
 168   if (self->event_handle != NULL) {
 169     CloseHandle (self->event_handle);
 170     self->event_handle = NULL;
 171   }
 172
 173   if (self->client_clock != NULL) {
 174     IUnknown_Release (self->client_clock);
 175     self->client_clock = NULL;
 176   }
 177
 178   if (self->client != NULL) {
 179     IUnknown_Release (self->client);
 180     self->client = NULL;
 181   }
 182
 183   if (self->capture_client != NULL) {
 184     IUnknown_Release (self->capture_client);
 185     self->capture_client = NULL;
 186   }
 187
 188   G_OBJECT_CLASS (parent_class)->dispose (object);
 189 }
 190
 191 static void
 192 gst_wasapi_src_finalize (GObject * object)
 193 {
 194   GstWasapiSrc *self = GST_WASAPI_SRC (object);
 195
 196   g_clear_pointer (&self->mix_format, CoTaskMemFree);
 197
 198   CoUninitialize ();
 199
 200   g_clear_pointer (&self->cached_caps, gst_caps_unref);
 201   g_clear_pointer (&self->positions, g_free);
 202   g_clear_pointer (&self->device_strid, g_free);
 203
 204   G_OBJECT_CLASS (parent_class)->finalize (object);
 205 }
 206
 207 static void
 208 gst_wasapi_src_set_property (GObject * object, guint prop_id,
 209     const GValue * value, GParamSpec * pspec)
 210 {
 211   GstWasapiSrc *self = GST_WASAPI_SRC (object);
 212
 213   switch (prop_id) {
 214     case PROP_ROLE:
 215       self->role = gst_wasapi_device_role_to_erole (g_value_get_enum (value));
 216       break;
 217     case PROP_DEVICE:
 218     {
 219       const gchar *device = g_value_get_string (value);
 220       g_free (self->device_strid);
 221       self->device_strid =
 222           device ? g_utf8_to_utf16 (device, -1, NULL, NULL, NULL) : NULL;
 223       break;
 224     }
 225     case PROP_EXCLUSIVE:
 226       self->sharemode = g_value_get_boolean (value)
 227           ? AUDCLNT_SHAREMODE_EXCLUSIVE : AUDCLNT_SHAREMODE_SHARED;
 228       break;
 229     case PROP_LOW_LATENCY:
 230       self->low_latency = g_value_get_boolean (value);
 231       break;
 232     default:
 233       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 234       break;
 235   }
 236 }
 237
 238 static void
 239 gst_wasapi_src_get_property (GObject * object, guint prop_id,
 240     GValue * value, GParamSpec * pspec)
 241 {
 242   GstWasapiSrc *self = GST_WASAPI_SRC (object);
 243
 244   switch (prop_id) {
 245     case PROP_ROLE:
 246       g_value_set_enum (value, gst_wasapi_erole_to_device_role (self->role));
 247       break;
 248     case PROP_DEVICE:
 249       g_value_take_string (value, self->device_strid ?
 250           g_utf16_to_utf8 (self->device_strid, -1, NULL, NULL, NULL) : NULL);
 251       break;
 252     case PROP_EXCLUSIVE:
 253       g_value_set_boolean (value,
 254           self->sharemode == AUDCLNT_SHAREMODE_EXCLUSIVE);
 255       break;
 256     case PROP_LOW_LATENCY:
 257       g_value_set_boolean (value, self->low_latency);
 258       break;
 259     default:
 260       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 261       break;
 262   }
 263 }
 264
 265 static GstCaps *
 266 gst_wasapi_src_get_caps (GstBaseSrc * bsrc, GstCaps * filter)
 267 {
 268   GstWasapiSrc *self = GST_WASAPI_SRC (bsrc);
 269   WAVEFORMATEX *format = NULL;
 270   GstCaps *caps = NULL;
 271
 272   GST_DEBUG_OBJECT (self, "entering get caps");
 273
 274   if (self->cached_caps) {
 275     caps = gst_caps_ref (self->cached_caps);
 276   } else {
 277     GstCaps *template_caps;
 278     gboolean ret;
 279
 280     template_caps = gst_pad_get_pad_template_caps (bsrc->srcpad);
 281
 282     if (!self->client)
 283       gst_wasapi_src_open (GST_AUDIO_SRC (bsrc));
 284
 285     ret = gst_wasapi_util_get_device_format (GST_ELEMENT (self),
 286         self->sharemode, self->device, self->client, &format);
 287     if (!ret) {
 288       GST_ELEMENT_ERROR (self, STREAM, FORMAT, (NULL),
 289           ("failed to detect format"));
 290       goto out;
 291     }
 292
 293     gst_wasapi_util_parse_waveformatex ((WAVEFORMATEXTENSIBLE *) format,
 294         template_caps, &caps, &self->positions);
 295     if (caps == NULL) {
 296       GST_ELEMENT_ERROR (self, STREAM, FORMAT, (NULL), ("unknown format"));
 297       goto out;
 298     }
 299
 300     {
 301       gchar *pos_str = gst_audio_channel_positions_to_string (self->positions,
 302           format->nChannels);
 303       GST_INFO_OBJECT (self, "positions are: %s", pos_str);
 304       g_free (pos_str);
 305     }
 306
 307     self->mix_format = format;
 308     gst_caps_replace (&self->cached_caps, caps);
 309     gst_caps_unref (template_caps);
 310   }
 311
 312   if (filter) {
 313     GstCaps *filtered =
 314         gst_caps_intersect_full (filter, caps, GST_CAPS_INTERSECT_FIRST);
 315     gst_caps_unref (caps);
 316     caps = filtered;
 317   }
 318
 319   GST_DEBUG_OBJECT (self, "returning caps %" GST_PTR_FORMAT, caps);
 320
 321 out:
 322   return caps;
 323 }
 324
 325 static gboolean
 326 gst_wasapi_src_open (GstAudioSrc * asrc)
 327 {
 328   GstWasapiSrc *self = GST_WASAPI_SRC (asrc);
 329   gboolean res = FALSE;
 330   IAudioClient *client = NULL;
 331   IMMDevice *device = NULL;
 332
 333   if (self->client)
 334     return TRUE;
 335
 336   /* FIXME: Switching the default device does not switch the stream to it,
 337    * even if the old device was unplugged. We need to handle this somehow.
 338    * For example, perhaps we should automatically switch to the new device if
 339    * the default device is changed and a device isn't explicitly selected. */
 340   if (!gst_wasapi_util_get_device_client (GST_ELEMENT (self), TRUE,
 341           self->role, self->device_strid, &device, &client)) {
 342     if (!self->device_strid)
 343       GST_ELEMENT_ERROR (self, RESOURCE, OPEN_READ, (NULL),
 344           ("Failed to get default device"));
 345     else
 346       GST_ELEMENT_ERROR (self, RESOURCE, OPEN_READ, (NULL),
 347           ("Failed to open device %S", self->device_strid));
 348     goto beach;
 349   }
 350
 351   self->client = client;
 352   self->device = device;
 353   res = TRUE;
 354
 355 beach:
 356
 357   return res;
 358 }
 359
 360 static gboolean
 361 gst_wasapi_src_close (GstAudioSrc * asrc)
 362 {
 363   GstWasapiSrc *self = GST_WASAPI_SRC (asrc);
 364
 365   if (self->device != NULL) {
 366     IUnknown_Release (self->device);
 367     self->device = NULL;
 368   }
 369
 370   if (self->client != NULL) {
 371     IUnknown_Release (self->client);
 372     self->client = NULL;
 373   }
 374
 375   return TRUE;
 376 }
 377
 378 static gboolean
 379 gst_wasapi_src_prepare (GstAudioSrc * asrc, GstAudioRingBufferSpec * spec)
 380 {
 381   GstWasapiSrc *self = GST_WASAPI_SRC (asrc);
 382   gboolean res = FALSE;
 383   REFERENCE_TIME latency_rt, default_period, min_period;
 384   REFERENCE_TIME device_period, device_buffer_duration;
 385   guint bpf, rate, buffer_frames;
 386   HRESULT hr;
 387
 388   hr = IAudioClient_GetDevicePeriod (self->client, &default_period,
 389       &min_period);
 390   if (hr != S_OK) {
 391     GST_ERROR_OBJECT (self, "IAudioClient::GetDevicePeriod failed");
 392     return FALSE;
 393   }
 394   GST_INFO_OBJECT (self, "wasapi default period: %" G_GINT64_FORMAT
 395       ", min period: %" G_GINT64_FORMAT, default_period, min_period);
 396
 397   bpf = GST_AUDIO_INFO_BPF (&spec->info);
 398   rate = GST_AUDIO_INFO_RATE (&spec->info);
 399
 400   if (self->low_latency) {
 401     if (self->sharemode == AUDCLNT_SHAREMODE_SHARED) {
 402       device_period = default_period;
 403       device_buffer_duration = 0;
 404     } else {
 405       device_period = min_period;
 406       device_buffer_duration = min_period;
 407     }
 408   } else {
 409     /* Clamp values to integral multiples of an appropriate period */
 410     gst_wasapi_util_get_best_buffer_sizes (spec,
 411         self->sharemode == AUDCLNT_SHAREMODE_EXCLUSIVE, default_period,
 412         min_period, &device_period, &device_buffer_duration);
 413   }
 414
 415   /* For some reason, we need to call this a second time for exclusive mode */
 416   if (self->sharemode == AUDCLNT_SHAREMODE_EXCLUSIVE)
 417     CoInitialize (NULL);
 418
 419   hr = IAudioClient_Initialize (self->client, self->sharemode,
 420       AUDCLNT_STREAMFLAGS_EVENTCALLBACK, device_buffer_duration,
 421       /* This must always be 0 in shared mode */
 422       self->sharemode == AUDCLNT_SHAREMODE_SHARED ? 0 : device_period,
 423       self->mix_format, NULL);
 424
 425   if (hr == AUDCLNT_E_BUFFER_SIZE_NOT_ALIGNED &&
 426       self->sharemode == AUDCLNT_SHAREMODE_EXCLUSIVE) {
 427     guint32 n_frames;
 428
 429     GST_WARNING_OBJECT (self, "initialize failed due to unaligned period %i",
 430         (int) device_period);
 431
 432     /* Calculate a new aligned period. First get the aligned buffer size. */
 433     hr = IAudioClient_GetBufferSize (self->client, &n_frames);
 434     if (hr != S_OK) {
 435       gchar *msg = gst_wasapi_util_hresult_to_string (hr);
 436       GST_ELEMENT_ERROR (self, RESOURCE, OPEN_WRITE, (NULL),
 437           ("IAudioClient::GetBufferSize() failed: %s", msg));
 438       g_free (msg);
 439       goto beach;
 440     }
 441
 442     device_period = (GST_SECOND / 100) * n_frames / rate;
 443
 444     GST_WARNING_OBJECT (self, "trying to re-initialize with period %i "
 445         "(%i frames, %i rate)", (int) device_period, n_frames, rate);
 446
 447     hr = IAudioClient_Initialize (self->client, self->sharemode,
 448         AUDCLNT_STREAMFLAGS_EVENTCALLBACK, device_period,
 449         device_period, self->mix_format, NULL);
 450   }
 451   if (hr != S_OK) {
 452     gchar *msg = gst_wasapi_util_hresult_to_string (hr);
 453     GST_ELEMENT_ERROR (self, RESOURCE, OPEN_READ, (NULL),
 454         ("IAudioClient::Initialize () failed: %s", msg));
 455     g_free (msg);
 456     goto beach;
 457   }
 458
 459   /* Total size in frames of the allocated buffer that we will read from */
 460   hr = IAudioClient_GetBufferSize (self->client, &buffer_frames);
 461   if (hr != S_OK) {
 462     GST_ERROR_OBJECT (self, "IAudioClient::GetBufferSize failed");
 463     goto beach;
 464   }
 465
 466   GST_INFO_OBJECT (self, "buffer size is %i frames, bpf is %i bytes, "
 467       "rate is %i Hz", buffer_frames, bpf, rate);
 468
 469   spec->segsize = gst_util_uint64_scale_int_round (rate * bpf,
 470       device_period * 100, GST_SECOND);
 471
 472   /* We need a minimum of 2 segments to ensure glitch-free playback */
 473   spec->segtotal = MAX (self->buffer_frame_count * bpf / spec->segsize, 2);
 474
 475   GST_INFO_OBJECT (self, "segsize is %i, segtotal is %i", spec->segsize,
 476       spec->segtotal);
 477
 478   /* Get WASAPI latency for logging */
 479   hr = IAudioClient_GetStreamLatency (self->client, &latency_rt);
 480   if (hr != S_OK) {
 481     GST_ERROR_OBJECT (self, "IAudioClient::GetStreamLatency failed");
 482     goto beach;
 483   }
 484   GST_INFO_OBJECT (self, "wasapi stream latency: %" G_GINT64_FORMAT " (%"
 485       G_GINT64_FORMAT " ms)", latency_rt, latency_rt / 10000);
 486
 487   /* Set the event handler which will trigger reads */
 488   hr = IAudioClient_SetEventHandle (self->client, self->event_handle);
 489   if (hr != S_OK) {
 490     GST_ERROR_OBJECT (self, "IAudioClient::SetEventHandle failed");
 491     goto beach;
 492   }
 493
 494   /* Get the clock and the clock freq */
 495   if (!gst_wasapi_util_get_clock (GST_ELEMENT (self), self->client,
 496           &self->client_clock)) {
 497     goto beach;
 498   }
 499
 500   hr = IAudioClock_GetFrequency (self->client_clock, &self->client_clock_freq);
 501   if (hr != S_OK) {
 502     GST_ERROR_OBJECT (self, "IAudioClock::GetFrequency failed");
 503     goto beach;
 504   }
 505
 506   /* Get capture source client and start it up */
 507   if (!gst_wasapi_util_get_capture_client (GST_ELEMENT (self), self->client,
 508           &self->capture_client)) {
 509     goto beach;
 510   }
 511
 512   hr = IAudioClient_Start (self->client);
 513   if (hr != S_OK) {
 514     GST_ERROR_OBJECT (self, "IAudioClient::Start failed");
 515     goto beach;
 516   }
 517
 518   gst_audio_ring_buffer_set_channel_positions (GST_AUDIO_BASE_SRC
 519       (self)->ringbuffer, self->positions);
 520
 521 #if defined(_MSC_VER) || defined(GST_FORCE_WIN_AVRT)
 522   /* Increase the thread priority to reduce glitches */
 523   {
 524     DWORD taskIndex = 0;
 525     self->thread_priority_handle =
 526         AvSetMmThreadCharacteristics (TEXT ("Pro Audio"), &taskIndex);
 527   }
 528 #endif
 529
 530   res = TRUE;
 531 beach:
 532   /* unprepare() is not called if prepare() fails, but we want it to be, so call
 533    * it manually when needed */
 534   if (!res)
 535     gst_wasapi_src_unprepare (asrc);
 536
 537   return res;
 538 }
 539
 540 static gboolean
 541 gst_wasapi_src_unprepare (GstAudioSrc * asrc)
 542 {
 543   GstWasapiSrc *self = GST_WASAPI_SRC (asrc);
 544
 545   if (self->sharemode == AUDCLNT_SHAREMODE_EXCLUSIVE)
 546     CoUninitialize ();
 547
 548 #if defined(_MSC_VER) || defined(GST_FORCE_WIN_AVRT)
 549   if (self->thread_priority_handle != NULL) {
 550     AvRevertMmThreadCharacteristics (self->thread_priority_handle);
 551     self->thread_priority_handle = NULL;
 552   }
 553 #endif
 554
 555   if (self->client != NULL) {
 556     IAudioClient_Stop (self->client);
 557   }
 558
 559   if (self->capture_client != NULL) {
 560     IUnknown_Release (self->capture_client);
 561     self->capture_client = NULL;
 562   }
 563
 564   if (self->client_clock != NULL) {
 565     IUnknown_Release (self->client_clock);
 566     self->client_clock = NULL;
 567   }
 568
 569   self->client_clock_freq = 0;
 570
 571   return TRUE;
 572 }
 573
 574 static guint
 575 gst_wasapi_src_read (GstAudioSrc * asrc, gpointer data, guint length,
 576     GstClockTime * timestamp)
 577 {
 578   GstWasapiSrc *self = GST_WASAPI_SRC (asrc);
 579   HRESULT hr;
 580   gint16 *from = NULL;
 581   guint wanted = length;
 582   DWORD flags;
 583
 584   while (wanted > 0) {
 585     guint have_frames, n_frames, want_frames, read_len;
 586
 587     /* Wait for data to become available */
 588     WaitForSingleObject (self->event_handle, INFINITE);
 589
 590     hr = IAudioCaptureClient_GetBuffer (self->capture_client,
 591         (BYTE **) & from, &have_frames, &flags, NULL, NULL);
 592     if (hr != S_OK) {
 593       gchar *msg = gst_wasapi_util_hresult_to_string (hr);
 594       if (hr == AUDCLNT_S_BUFFER_EMPTY)
 595         GST_WARNING_OBJECT (self, "IAudioCaptureClient::GetBuffer failed: %s"
 596             ", retrying", msg);
 597       else
 598         GST_ERROR_OBJECT (self, "IAudioCaptureClient::GetBuffer failed: %s",
 599             msg);
 600       g_free (msg);
 601       length = 0;
 602       goto beach;
 603     }
 604
 605     if (flags != 0)
 606       GST_INFO_OBJECT (self, "buffer flags=%#08x", (guint) flags);
 607
 608     /* XXX: How do we handle AUDCLNT_BUFFERFLAGS_SILENT? We're supposed to write
 609      * out silence when that flag is set? See:
 610      * https://msdn.microsoft.com/en-us/library/windows/desktop/dd370800(v=vs.85).aspx */
 611
 612     if (flags & AUDCLNT_BUFFERFLAGS_DATA_DISCONTINUITY)
 613       GST_WARNING_OBJECT (self, "WASAPI reported glitch in buffer");
 614
 615     want_frames = wanted / self->mix_format->nBlockAlign;
 616
 617     /* If GetBuffer is returning more frames than we can handle, all we can do is
 618      * hope that this is temporary and that things will settle down later. */
 619     if (G_UNLIKELY (have_frames > want_frames))
 620       GST_WARNING_OBJECT (self, "captured too many frames: have %i, want %i",
 621           have_frames, want_frames);
 622
 623     /* Only copy data that will fit into the allocated buffer of size @length */
 624     n_frames = MIN (have_frames, want_frames);
 625     read_len = n_frames * self->mix_format->nBlockAlign;
 626
 627     {
 628       guint bpf = self->mix_format->nBlockAlign;
 629       GST_DEBUG_OBJECT (self, "have: %i (%i bytes), can read: %i (%i bytes), "
 630           "will read: %i (%i bytes)", have_frames, have_frames * bpf,
 631           want_frames, wanted, n_frames, read_len);
 632     }
 633
 634     memcpy (data, from, read_len);
 635     wanted -= read_len;
 636
 637     /* Always release all captured buffers if we've captured any at all */
 638     hr = IAudioCaptureClient_ReleaseBuffer (self->capture_client, have_frames);
 639     if (hr != S_OK) {
 640       gchar *msg = gst_wasapi_util_hresult_to_string (hr);
 641       GST_ERROR_OBJECT (self,
 642           "IAudioCaptureClient::ReleaseBuffer () failed: %s", msg);
 643       g_free (msg);
 644       goto beach;
 645     }
 646   }
 647
 648
 649 beach:
 650
 651   return length;
 652 }
 653
 654 static guint
 655 gst_wasapi_src_delay (GstAudioSrc * asrc)
 656 {
 657   GstWasapiSrc *self = GST_WASAPI_SRC (asrc);
 658   guint delay = 0;
 659   HRESULT hr;
 660
 661   hr = IAudioClient_GetCurrentPadding (self->client, &delay);
 662   if (hr != S_OK) {
 663     gchar *msg = gst_wasapi_util_hresult_to_string (hr);
 664     GST_ELEMENT_ERROR (self, RESOURCE, READ, (NULL),
 665         ("IAudioClient::GetCurrentPadding failed %s", msg));
 666     g_free (msg);
 667   }
 668
 669   return delay;
 670 }
 671
 672 static void
 673 gst_wasapi_src_reset (GstAudioSrc * asrc)
 674 {
 675   GstWasapiSrc *self = GST_WASAPI_SRC (asrc);
 676   HRESULT hr;
 677
 678   if (self->client) {
 679     hr = IAudioClient_Stop (self->client);
 680     if (hr != S_OK) {
 681       gchar *msg = gst_wasapi_util_hresult_to_string (hr);
 682       GST_ERROR_OBJECT (self, "IAudioClient::Stop () failed: %s", msg);
 683       g_free (msg);
 684       return;
 685     }
 686
 687     hr = IAudioClient_Reset (self->client);
 688     if (hr != S_OK) {
 689       gchar *msg = gst_wasapi_util_hresult_to_string (hr);
 690       GST_ERROR_OBJECT (self, "IAudioClient::Reset () failed: %s", msg);
 691       g_free (msg);
 692       return;
 693     }
 694   }
 695 }
 696
 697 static GstClockTime
 698 gst_wasapi_src_get_time (GstClock * clock, gpointer user_data)
 699 {
 700   GstWasapiSrc *self = GST_WASAPI_SRC (user_data);
 701   HRESULT hr;
 702   guint64 devpos;
 703   GstClockTime result;
 704
 705   if (G_UNLIKELY (self->client_clock == NULL))
 706     return GST_CLOCK_TIME_NONE;
 707
 708   hr = IAudioClock_GetPosition (self->client_clock, &devpos, NULL);
 709   if (G_UNLIKELY (hr != S_OK))
 710     return GST_CLOCK_TIME_NONE;
 711
 712   result = gst_util_uint64_scale_int (devpos, GST_SECOND,
 713       self->client_clock_freq);
 714
 715   /*
 716      GST_DEBUG_OBJECT (self, "devpos = %" G_GUINT64_FORMAT
 717      " frequency = %" G_GUINT64_FORMAT
 718      " result = %" G_GUINT64_FORMAT " ms",
 719      devpos, self->client_clock_freq, GST_TIME_AS_MSECONDS (result));
 720    */
 721
 722   return result;
 723 }