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 #define DEFAULT_AUDIOCLIENT3  FALSE
  55
  56 enum
  57 {
  58   PROP_0,
  59   PROP_ROLE,
  60   PROP_DEVICE,
  61   PROP_EXCLUSIVE,
  62   PROP_LOW_LATENCY,
  63   PROP_AUDIOCLIENT3
  64 };
  65
  66 static void gst_wasapi_src_dispose (GObject * object);
  67 static void gst_wasapi_src_finalize (GObject * object);
  68 static void gst_wasapi_src_set_property (GObject * object, guint prop_id,
  69     const GValue * value, GParamSpec * pspec);
  70 static void gst_wasapi_src_get_property (GObject * object, guint prop_id,
  71     GValue * value, GParamSpec * pspec);
  72
  73 static GstCaps *gst_wasapi_src_get_caps (GstBaseSrc * bsrc, GstCaps * filter);
  74
  75 static gboolean gst_wasapi_src_open (GstAudioSrc * asrc);
  76 static gboolean gst_wasapi_src_close (GstAudioSrc * asrc);
  77 static gboolean gst_wasapi_src_prepare (GstAudioSrc * asrc,
  78     GstAudioRingBufferSpec * spec);
  79 static gboolean gst_wasapi_src_unprepare (GstAudioSrc * asrc);
  80 static guint gst_wasapi_src_read (GstAudioSrc * asrc, gpointer data,
  81     guint length, GstClockTime * timestamp);
  82 static guint gst_wasapi_src_delay (GstAudioSrc * asrc);
  83 static void gst_wasapi_src_reset (GstAudioSrc * asrc);
  84
  85 static GstClockTime gst_wasapi_src_get_time (GstClock * clock,
  86     gpointer user_data);
  87
  88 #define gst_wasapi_src_parent_class parent_class
  89 G_DEFINE_TYPE (GstWasapiSrc, gst_wasapi_src, GST_TYPE_AUDIO_SRC);
  90
  91 static void
  92 gst_wasapi_src_class_init (GstWasapiSrcClass * klass)
  93 {
  94   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
  95   GstElementClass *gstelement_class = GST_ELEMENT_CLASS (klass);
  96   GstBaseSrcClass *gstbasesrc_class = GST_BASE_SRC_CLASS (klass);
  97   GstAudioSrcClass *gstaudiosrc_class = GST_AUDIO_SRC_CLASS (klass);
  98
  99   gobject_class->dispose = gst_wasapi_src_dispose;
 100   gobject_class->finalize = gst_wasapi_src_finalize;
 101   gobject_class->set_property = gst_wasapi_src_set_property;
 102   gobject_class->get_property = gst_wasapi_src_get_property;
 103
 104   g_object_class_install_property (gobject_class,
 105       PROP_ROLE,
 106       g_param_spec_enum ("role", "Role",
 107           "Role of the device: communications, multimedia, etc",
 108           GST_WASAPI_DEVICE_TYPE_ROLE, DEFAULT_ROLE, G_PARAM_READWRITE |
 109           G_PARAM_STATIC_STRINGS | GST_PARAM_MUTABLE_READY));
 110
 111   g_object_class_install_property (gobject_class,
 112       PROP_DEVICE,
 113       g_param_spec_string ("device", "Device",
 114           "WASAPI playback device as a GUID string",
 115           NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 116
 117   g_object_class_install_property (gobject_class,
 118       PROP_EXCLUSIVE,
 119       g_param_spec_boolean ("exclusive", "Exclusive mode",
 120           "Open the device in exclusive mode",
 121           DEFAULT_EXCLUSIVE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 122
 123   g_object_class_install_property (gobject_class,
 124       PROP_LOW_LATENCY,
 125       g_param_spec_boolean ("low-latency", "Low latency",
 126           "Optimize all settings for lowest latency",
 127           DEFAULT_LOW_LATENCY, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 128
 129   g_object_class_install_property (gobject_class,
 130       PROP_AUDIOCLIENT3,
 131       g_param_spec_boolean ("use-audioclient3", "Use the AudioClient3 API",
 132           "Whether to use the Windows 10 AudioClient3 API when available",
 133           DEFAULT_AUDIOCLIENT3, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 134
 135   gst_element_class_add_static_pad_template (gstelement_class, &src_template);
 136   gst_element_class_set_static_metadata (gstelement_class, "WasapiSrc",
 137       "Source/Audio",
 138       "Stream audio from an audio capture device through WASAPI",
 139       "Ole André Vadla Ravnås <ole.andre.ravnas@tandberg.com>");
 140
 141   gstbasesrc_class->get_caps = GST_DEBUG_FUNCPTR (gst_wasapi_src_get_caps);
 142
 143   gstaudiosrc_class->open = GST_DEBUG_FUNCPTR (gst_wasapi_src_open);
 144   gstaudiosrc_class->close = GST_DEBUG_FUNCPTR (gst_wasapi_src_close);
 145   gstaudiosrc_class->read = GST_DEBUG_FUNCPTR (gst_wasapi_src_read);
 146   gstaudiosrc_class->prepare = GST_DEBUG_FUNCPTR (gst_wasapi_src_prepare);
 147   gstaudiosrc_class->unprepare = GST_DEBUG_FUNCPTR (gst_wasapi_src_unprepare);
 148   gstaudiosrc_class->delay = GST_DEBUG_FUNCPTR (gst_wasapi_src_delay);
 149   gstaudiosrc_class->reset = GST_DEBUG_FUNCPTR (gst_wasapi_src_reset);
 150
 151   GST_DEBUG_CATEGORY_INIT (gst_wasapi_src_debug, "wasapisrc",
 152       0, "Windows audio session API source");
 153 }
 154
 155 static void
 156 gst_wasapi_src_init (GstWasapiSrc * self)
 157 {
 158   /* override with a custom clock */
 159   if (GST_AUDIO_BASE_SRC (self)->clock)
 160     gst_object_unref (GST_AUDIO_BASE_SRC (self)->clock);
 161
 162   GST_AUDIO_BASE_SRC (self)->clock = gst_audio_clock_new ("GstWasapiSrcClock",
 163       gst_wasapi_src_get_time, gst_object_ref (self),
 164       (GDestroyNotify) gst_object_unref);
 165
 166   self->role = DEFAULT_ROLE;
 167   self->sharemode = AUDCLNT_SHAREMODE_SHARED;
 168   self->low_latency = DEFAULT_LOW_LATENCY;
 169   self->try_audioclient3 = DEFAULT_AUDIOCLIENT3;
 170   self->event_handle = CreateEvent (NULL, FALSE, FALSE, NULL);
 171
 172   CoInitialize (NULL);
 173 }
 174
 175 static void
 176 gst_wasapi_src_dispose (GObject * object)
 177 {
 178   GstWasapiSrc *self = GST_WASAPI_SRC (object);
 179
 180   if (self->event_handle != NULL) {
 181     CloseHandle (self->event_handle);
 182     self->event_handle = NULL;
 183   }
 184
 185   if (self->client_clock != NULL) {
 186     IUnknown_Release (self->client_clock);
 187     self->client_clock = NULL;
 188   }
 189
 190   if (self->client != NULL) {
 191     IUnknown_Release (self->client);
 192     self->client = NULL;
 193   }
 194
 195   if (self->capture_client != NULL) {
 196     IUnknown_Release (self->capture_client);
 197     self->capture_client = NULL;
 198   }
 199
 200   G_OBJECT_CLASS (parent_class)->dispose (object);
 201 }
 202
 203 static void
 204 gst_wasapi_src_finalize (GObject * object)
 205 {
 206   GstWasapiSrc *self = GST_WASAPI_SRC (object);
 207
 208   g_clear_pointer (&self->mix_format, CoTaskMemFree);
 209
 210   CoUninitialize ();
 211
 212   g_clear_pointer (&self->cached_caps, gst_caps_unref);
 213   g_clear_pointer (&self->positions, g_free);
 214   g_clear_pointer (&self->device_strid, g_free);
 215
 216   G_OBJECT_CLASS (parent_class)->finalize (object);
 217 }
 218
 219 static void
 220 gst_wasapi_src_set_property (GObject * object, guint prop_id,
 221     const GValue * value, GParamSpec * pspec)
 222 {
 223   GstWasapiSrc *self = GST_WASAPI_SRC (object);
 224
 225   switch (prop_id) {
 226     case PROP_ROLE:
 227       self->role = gst_wasapi_device_role_to_erole (g_value_get_enum (value));
 228       break;
 229     case PROP_DEVICE:
 230     {
 231       const gchar *device = g_value_get_string (value);
 232       g_free (self->device_strid);
 233       self->device_strid =
 234           device ? g_utf8_to_utf16 (device, -1, NULL, NULL, NULL) : NULL;
 235       break;
 236     }
 237     case PROP_EXCLUSIVE:
 238       self->sharemode = g_value_get_boolean (value)
 239           ? AUDCLNT_SHAREMODE_EXCLUSIVE : AUDCLNT_SHAREMODE_SHARED;
 240       break;
 241     case PROP_LOW_LATENCY:
 242       self->low_latency = g_value_get_boolean (value);
 243       break;
 244     case PROP_AUDIOCLIENT3:
 245       self->try_audioclient3 = g_value_get_boolean (value);
 246       break;
 247     default:
 248       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 249       break;
 250   }
 251 }
 252
 253 static void
 254 gst_wasapi_src_get_property (GObject * object, guint prop_id,
 255     GValue * value, GParamSpec * pspec)
 256 {
 257   GstWasapiSrc *self = GST_WASAPI_SRC (object);
 258
 259   switch (prop_id) {
 260     case PROP_ROLE:
 261       g_value_set_enum (value, gst_wasapi_erole_to_device_role (self->role));
 262       break;
 263     case PROP_DEVICE:
 264       g_value_take_string (value, self->device_strid ?
 265           g_utf16_to_utf8 (self->device_strid, -1, NULL, NULL, NULL) : NULL);
 266       break;
 267     case PROP_EXCLUSIVE:
 268       g_value_set_boolean (value,
 269           self->sharemode == AUDCLNT_SHAREMODE_EXCLUSIVE);
 270       break;
 271     case PROP_LOW_LATENCY:
 272       g_value_set_boolean (value, self->low_latency);
 273       break;
 274     case PROP_AUDIOCLIENT3:
 275       g_value_set_boolean (value, self->try_audioclient3);
 276       break;
 277     default:
 278       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 279       break;
 280   }
 281 }
 282
 283 static gboolean
 284 gst_wasapi_src_can_audioclient3 (GstWasapiSrc * self)
 285 {
 286   if (self->sharemode == AUDCLNT_SHAREMODE_SHARED &&
 287       self->try_audioclient3 && gst_wasapi_util_have_audioclient3 ())
 288     return TRUE;
 289   return FALSE;
 290 }
 291
 292 static GstCaps *
 293 gst_wasapi_src_get_caps (GstBaseSrc * bsrc, GstCaps * filter)
 294 {
 295   GstWasapiSrc *self = GST_WASAPI_SRC (bsrc);
 296   WAVEFORMATEX *format = NULL;
 297   GstCaps *caps = NULL;
 298
 299   GST_DEBUG_OBJECT (self, "entering get caps");
 300
 301   if (self->cached_caps) {
 302     caps = gst_caps_ref (self->cached_caps);
 303   } else {
 304     GstCaps *template_caps;
 305     gboolean ret;
 306
 307     template_caps = gst_pad_get_pad_template_caps (bsrc->srcpad);
 308
 309     if (!self->client)
 310       gst_wasapi_src_open (GST_AUDIO_SRC (bsrc));
 311
 312     ret = gst_wasapi_util_get_device_format (GST_ELEMENT (self),
 313         self->sharemode, self->device, self->client, &format);
 314     if (!ret) {
 315       GST_ELEMENT_ERROR (self, STREAM, FORMAT, (NULL),
 316           ("failed to detect format"));
 317       goto out;
 318     }
 319
 320     gst_wasapi_util_parse_waveformatex ((WAVEFORMATEXTENSIBLE *) format,
 321         template_caps, &caps, &self->positions);
 322     if (caps == NULL) {
 323       GST_ELEMENT_ERROR (self, STREAM, FORMAT, (NULL), ("unknown format"));
 324       goto out;
 325     }
 326
 327     {
 328       gchar *pos_str = gst_audio_channel_positions_to_string (self->positions,
 329           format->nChannels);
 330       GST_INFO_OBJECT (self, "positions are: %s", pos_str);
 331       g_free (pos_str);
 332     }
 333
 334     self->mix_format = format;
 335     gst_caps_replace (&self->cached_caps, caps);
 336     gst_caps_unref (template_caps);
 337   }
 338
 339   if (filter) {
 340     GstCaps *filtered =
 341         gst_caps_intersect_full (filter, caps, GST_CAPS_INTERSECT_FIRST);
 342     gst_caps_unref (caps);
 343     caps = filtered;
 344   }
 345
 346   GST_DEBUG_OBJECT (self, "returning caps %" GST_PTR_FORMAT, caps);
 347
 348 out:
 349   return caps;
 350 }
 351
 352 static gboolean
 353 gst_wasapi_src_open (GstAudioSrc * asrc)
 354 {
 355   GstWasapiSrc *self = GST_WASAPI_SRC (asrc);
 356   gboolean res = FALSE;
 357   IAudioClient *client = NULL;
 358   IMMDevice *device = NULL;
 359
 360   if (self->client)
 361     return TRUE;
 362
 363   /* FIXME: Switching the default device does not switch the stream to it,
 364    * even if the old device was unplugged. We need to handle this somehow.
 365    * For example, perhaps we should automatically switch to the new device if
 366    * the default device is changed and a device isn't explicitly selected. */
 367   if (!gst_wasapi_util_get_device_client (GST_ELEMENT (self), TRUE,
 368           self->role, self->device_strid, &device, &client)) {
 369     if (!self->device_strid)
 370       GST_ELEMENT_ERROR (self, RESOURCE, OPEN_READ, (NULL),
 371           ("Failed to get default device"));
 372     else
 373       GST_ELEMENT_ERROR (self, RESOURCE, OPEN_READ, (NULL),
 374           ("Failed to open device %S", self->device_strid));
 375     goto beach;
 376   }
 377
 378   self->client = client;
 379   self->device = device;
 380   res = TRUE;
 381
 382 beach:
 383
 384   return res;
 385 }
 386
 387 static gboolean
 388 gst_wasapi_src_close (GstAudioSrc * asrc)
 389 {
 390   GstWasapiSrc *self = GST_WASAPI_SRC (asrc);
 391
 392   if (self->device != NULL) {
 393     IUnknown_Release (self->device);
 394     self->device = NULL;
 395   }
 396
 397   if (self->client != NULL) {
 398     IUnknown_Release (self->client);
 399     self->client = NULL;
 400   }
 401
 402   return TRUE;
 403 }
 404
 405 static gboolean
 406 gst_wasapi_src_prepare (GstAudioSrc * asrc, GstAudioRingBufferSpec * spec)
 407 {
 408   GstWasapiSrc *self = GST_WASAPI_SRC (asrc);
 409   gboolean res = FALSE;
 410   REFERENCE_TIME latency_rt;
 411   guint bpf, rate, devicep_frames, buffer_frames;
 412   HRESULT hr;
 413
 414   if (gst_wasapi_src_can_audioclient3 (self)) {
 415     if (!gst_wasapi_util_initialize_audioclient3 (GST_ELEMENT (self), spec,
 416             (IAudioClient3 *) self->client, self->mix_format, self->low_latency,
 417             &devicep_frames))
 418       goto beach;
 419   } else {
 420     if (!gst_wasapi_util_initialize_audioclient (GST_ELEMENT (self), spec,
 421             self->client, self->mix_format, self->sharemode, self->low_latency,
 422             &devicep_frames))
 423       goto beach;
 424   }
 425
 426   bpf = GST_AUDIO_INFO_BPF (&spec->info);
 427   rate = GST_AUDIO_INFO_RATE (&spec->info);
 428
 429   /* Total size in frames of the allocated buffer that we will read from */
 430   hr = IAudioClient_GetBufferSize (self->client, &buffer_frames);
 431   HR_FAILED_GOTO (hr, IAudioClient::GetBufferSize, beach);
 432
 433   GST_INFO_OBJECT (self, "buffer size is %i frames, device period is %i "
 434       "frames, bpf is %i bytes, rate is %i Hz", buffer_frames,
 435       devicep_frames, bpf, rate);
 436
 437   /* Actual latency-time/buffer-time will be different now */
 438   spec->segsize = devicep_frames * bpf;
 439
 440   /* We need a minimum of 2 segments to ensure glitch-free playback */
 441   spec->segtotal = MAX (self->buffer_frame_count * bpf / spec->segsize, 2);
 442
 443   GST_INFO_OBJECT (self, "segsize is %i, segtotal is %i", spec->segsize,
 444       spec->segtotal);
 445
 446   /* Get WASAPI latency for logging */
 447   hr = IAudioClient_GetStreamLatency (self->client, &latency_rt);
 448   HR_FAILED_GOTO (hr, IAudioClient::GetStreamLatency, beach);
 449
 450   GST_INFO_OBJECT (self, "wasapi stream latency: %" G_GINT64_FORMAT " (%"
 451       G_GINT64_FORMAT " ms)", latency_rt, latency_rt / 10000);
 452
 453   /* Set the event handler which will trigger reads */
 454   hr = IAudioClient_SetEventHandle (self->client, self->event_handle);
 455   HR_FAILED_GOTO (hr, IAudioClient::SetEventHandle, beach);
 456
 457   /* Get the clock and the clock freq */
 458   if (!gst_wasapi_util_get_clock (GST_ELEMENT (self), self->client,
 459           &self->client_clock))
 460     goto beach;
 461
 462   hr = IAudioClock_GetFrequency (self->client_clock, &self->client_clock_freq);
 463   HR_FAILED_GOTO (hr, IAudioClock::GetFrequency, beach);
 464
 465   /* Get capture source client and start it up */
 466   if (!gst_wasapi_util_get_capture_client (GST_ELEMENT (self), self->client,
 467           &self->capture_client)) {
 468     goto beach;
 469   }
 470
 471   hr = IAudioClient_Start (self->client);
 472   HR_FAILED_GOTO (hr, IAudioClock::Start, beach);
 473
 474   gst_audio_ring_buffer_set_channel_positions (GST_AUDIO_BASE_SRC
 475       (self)->ringbuffer, self->positions);
 476
 477   /* Increase the thread priority to reduce glitches */
 478   self->thread_priority_handle = gst_wasapi_util_set_thread_characteristics ();
 479
 480   res = TRUE;
 481 beach:
 482   /* unprepare() is not called if prepare() fails, but we want it to be, so call
 483    * it manually when needed */
 484   if (!res)
 485     gst_wasapi_src_unprepare (asrc);
 486
 487   return res;
 488 }
 489
 490 static gboolean
 491 gst_wasapi_src_unprepare (GstAudioSrc * asrc)
 492 {
 493   GstWasapiSrc *self = GST_WASAPI_SRC (asrc);
 494
 495   if (self->sharemode == AUDCLNT_SHAREMODE_EXCLUSIVE &&
 496       !gst_wasapi_src_can_audioclient3 (self))
 497     CoUninitialize ();
 498
 499   if (self->thread_priority_handle != NULL) {
 500     gst_wasapi_util_revert_thread_characteristics
 501         (self->thread_priority_handle);
 502     self->thread_priority_handle = NULL;
 503   }
 504
 505   if (self->client != NULL) {
 506     IAudioClient_Stop (self->client);
 507   }
 508
 509   if (self->capture_client != NULL) {
 510     IUnknown_Release (self->capture_client);
 511     self->capture_client = NULL;
 512   }
 513
 514   if (self->client_clock != NULL) {
 515     IUnknown_Release (self->client_clock);
 516     self->client_clock = NULL;
 517   }
 518
 519   self->client_clock_freq = 0;
 520
 521   return TRUE;
 522 }
 523
 524 static guint
 525 gst_wasapi_src_read (GstAudioSrc * asrc, gpointer data, guint length,
 526     GstClockTime * timestamp)
 527 {
 528   GstWasapiSrc *self = GST_WASAPI_SRC (asrc);
 529   HRESULT hr;
 530   gint16 *from = NULL;
 531   guint wanted = length;
 532   DWORD flags;
 533
 534   while (wanted > 0) {
 535     guint have_frames, n_frames, want_frames, read_len;
 536
 537     /* Wait for data to become available */
 538     WaitForSingleObject (self->event_handle, INFINITE);
 539
 540     hr = IAudioCaptureClient_GetBuffer (self->capture_client,
 541         (BYTE **) & from, &have_frames, &flags, NULL, NULL);
 542     if (hr != S_OK) {
 543       gchar *msg = gst_wasapi_util_hresult_to_string (hr);
 544       if (hr == AUDCLNT_S_BUFFER_EMPTY)
 545         GST_WARNING_OBJECT (self, "IAudioCaptureClient::GetBuffer failed: %s"
 546             ", retrying", msg);
 547       else
 548         GST_ERROR_OBJECT (self, "IAudioCaptureClient::GetBuffer failed: %s",
 549             msg);
 550       g_free (msg);
 551       length = 0;
 552       goto beach;
 553     }
 554
 555     if (flags != 0)
 556       GST_INFO_OBJECT (self, "buffer flags=%#08x", (guint) flags);
 557
 558     /* XXX: How do we handle AUDCLNT_BUFFERFLAGS_SILENT? We're supposed to write
 559      * out silence when that flag is set? See:
 560      * https://msdn.microsoft.com/en-us/library/windows/desktop/dd370800(v=vs.85).aspx */
 561
 562     if (flags & AUDCLNT_BUFFERFLAGS_DATA_DISCONTINUITY)
 563       GST_WARNING_OBJECT (self, "WASAPI reported glitch in buffer");
 564
 565     want_frames = wanted / self->mix_format->nBlockAlign;
 566
 567     /* If GetBuffer is returning more frames than we can handle, all we can do is
 568      * hope that this is temporary and that things will settle down later. */
 569     if (G_UNLIKELY (have_frames > want_frames))
 570       GST_WARNING_OBJECT (self, "captured too many frames: have %i, want %i",
 571           have_frames, want_frames);
 572
 573     /* Only copy data that will fit into the allocated buffer of size @length */
 574     n_frames = MIN (have_frames, want_frames);
 575     read_len = n_frames * self->mix_format->nBlockAlign;
 576
 577     {
 578       guint bpf = self->mix_format->nBlockAlign;
 579       GST_DEBUG_OBJECT (self, "have: %i (%i bytes), can read: %i (%i bytes), "
 580           "will read: %i (%i bytes)", have_frames, have_frames * bpf,
 581           want_frames, wanted, n_frames, read_len);
 582     }
 583
 584     memcpy (data, from, read_len);
 585     wanted -= read_len;
 586
 587     /* Always release all captured buffers if we've captured any at all */
 588     hr = IAudioCaptureClient_ReleaseBuffer (self->capture_client, have_frames);
 589     HR_FAILED_AND (hr, IAudioClock::ReleaseBuffer, goto beach);
 590   }
 591
 592
 593 beach:
 594
 595   return length;
 596 }
 597
 598 static guint
 599 gst_wasapi_src_delay (GstAudioSrc * asrc)
 600 {
 601   GstWasapiSrc *self = GST_WASAPI_SRC (asrc);
 602   guint delay = 0;
 603   HRESULT hr;
 604
 605   hr = IAudioClient_GetCurrentPadding (self->client, &delay);
 606   HR_FAILED_RET (hr, IAudioClock::GetCurrentPadding, 0);
 607
 608   return delay;
 609 }
 610
 611 static void
 612 gst_wasapi_src_reset (GstAudioSrc * asrc)
 613 {
 614   GstWasapiSrc *self = GST_WASAPI_SRC (asrc);
 615   HRESULT hr;
 616
 617   if (!self->client)
 618     return;
 619
 620   hr = IAudioClient_Stop (self->client);
 621   HR_FAILED_RET (hr, IAudioClock::Stop,);
 622
 623   hr = IAudioClient_Reset (self->client);
 624   HR_FAILED_RET (hr, IAudioClock::Reset,);
 625 }
 626
 627 static GstClockTime
 628 gst_wasapi_src_get_time (GstClock * clock, gpointer user_data)
 629 {
 630   GstWasapiSrc *self = GST_WASAPI_SRC (user_data);
 631   HRESULT hr;
 632   guint64 devpos;
 633   GstClockTime result;
 634
 635   if (G_UNLIKELY (self->client_clock == NULL))
 636     return GST_CLOCK_TIME_NONE;
 637
 638   hr = IAudioClock_GetPosition (self->client_clock, &devpos, NULL);
 639   HR_FAILED_RET (hr, IAudioClock::GetPosition, GST_CLOCK_TIME_NONE);
 640
 641   result = gst_util_uint64_scale_int (devpos, GST_SECOND,
 642       self->client_clock_freq);
 643
 644   /*
 645      GST_DEBUG_OBJECT (self, "devpos = %" G_GUINT64_FORMAT
 646      " frequency = %" G_GUINT64_FORMAT
 647      " result = %" G_GUINT64_FORMAT " ms",
 648      devpos, self->client_clock_freq, GST_TIME_AS_MSECONDS (result));
 649    */
 650
 651   return result;
 652 }