sys/wasapi/gstwasapisink.c

   1 /*
   2  * Copyright (C) 2008 Ole André Vadla Ravnås <ole.andre.ravnas@tandberg.com>
   3  * Copyright (C) 2013 Collabora Ltd.
   4  *   Author: Sebastian Dröge <sebastian.droege@collabora.co.uk>
   5  * Copyright (C) 2018 Centricular Ltd.
   6  *   Author: Nirbheek Chauhan <nirbheek@centricular.com>
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Library General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2 of the License, or (at your option) any later version.
  12  *
  13  * This library 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 GNU
  16  * Library General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Library General Public
  19  * License along with this library; if not, write to the
  20  * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
  21  * Boston, MA 02110-1301, USA.
  22  */
  23
  24 /**
  25  * SECTION:element-wasapisink
  26  * @title: wasapisink
  27  *
  28  * Provides audio playback using the Windows Audio Session API available with
  29  * Vista and newer.
  30  *
  31  * ## Example pipelines
  32  * |[
  33  * gst-launch-1.0 -v audiotestsrc samplesperbuffer=160 ! wasapisink
  34  * ]| Generate 20 ms buffers and render to the default audio device.
  35  *
  36  * |[
  37  * gst-launch-1.0 -v audiotestsrc samplesperbuffer=160 ! wasapisink low-latency=true
  38  * ]| Same as above, but with the minimum possible latency
  39  *
  40  */
  41 #ifdef HAVE_CONFIG_H
  42 #  include <config.h>
  43 #endif
  44
  45 #include "gstwasapisink.h"
  46
  47 #include <avrt.h>
  48
  49 GST_DEBUG_CATEGORY_STATIC (gst_wasapi_sink_debug);
  50 #define GST_CAT_DEFAULT gst_wasapi_sink_debug
  51
  52 static GstStaticPadTemplate sink_template = GST_STATIC_PAD_TEMPLATE ("sink",
  53     GST_PAD_SINK,
  54     GST_PAD_ALWAYS,
  55     GST_STATIC_CAPS (GST_WASAPI_STATIC_CAPS));
  56
  57 #define DEFAULT_ROLE          GST_WASAPI_DEVICE_ROLE_CONSOLE
  58 #define DEFAULT_MUTE          FALSE
  59 #define DEFAULT_EXCLUSIVE     FALSE
  60 #define DEFAULT_LOW_LATENCY   FALSE
  61 #define DEFAULT_AUDIOCLIENT3  TRUE
  62
  63 enum
  64 {
  65   PROP_0,
  66   PROP_ROLE,
  67   PROP_MUTE,
  68   PROP_DEVICE,
  69   PROP_EXCLUSIVE,
  70   PROP_LOW_LATENCY,
  71   PROP_AUDIOCLIENT3
  72 };
  73
  74 static void gst_wasapi_sink_dispose (GObject * object);
  75 static void gst_wasapi_sink_finalize (GObject * object);
  76 static void gst_wasapi_sink_set_property (GObject * object, guint prop_id,
  77     const GValue * value, GParamSpec * pspec);
  78 static void gst_wasapi_sink_get_property (GObject * object, guint prop_id,
  79     GValue * value, GParamSpec * pspec);
  80
  81 static GstCaps *gst_wasapi_sink_get_caps (GstBaseSink * bsink,
  82     GstCaps * filter);
  83
  84 static gboolean gst_wasapi_sink_prepare (GstAudioSink * asink,
  85     GstAudioRingBufferSpec * spec);
  86 static gboolean gst_wasapi_sink_unprepare (GstAudioSink * asink);
  87 static gboolean gst_wasapi_sink_open (GstAudioSink * asink);
  88 static gboolean gst_wasapi_sink_close (GstAudioSink * asink);
  89 static gint gst_wasapi_sink_write (GstAudioSink * asink,
  90     gpointer data, guint length);
  91 static guint gst_wasapi_sink_delay (GstAudioSink * asink);
  92 static void gst_wasapi_sink_reset (GstAudioSink * asink);
  93
  94 #define gst_wasapi_sink_parent_class parent_class
  95 G_DEFINE_TYPE (GstWasapiSink, gst_wasapi_sink, GST_TYPE_AUDIO_SINK);
  96
  97 static void
  98 gst_wasapi_sink_class_init (GstWasapiSinkClass * klass)
  99 {
 100   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
 101   GstElementClass *gstelement_class = GST_ELEMENT_CLASS (klass);
 102   GstBaseSinkClass *gstbasesink_class = GST_BASE_SINK_CLASS (klass);
 103   GstAudioSinkClass *gstaudiosink_class = GST_AUDIO_SINK_CLASS (klass);
 104
 105   gobject_class->dispose = gst_wasapi_sink_dispose;
 106   gobject_class->finalize = gst_wasapi_sink_finalize;
 107   gobject_class->set_property = gst_wasapi_sink_set_property;
 108   gobject_class->get_property = gst_wasapi_sink_get_property;
 109
 110   g_object_class_install_property (gobject_class,
 111       PROP_ROLE,
 112       g_param_spec_enum ("role", "Role",
 113           "Role of the device: communications, multimedia, etc",
 114           GST_WASAPI_DEVICE_TYPE_ROLE, DEFAULT_ROLE, G_PARAM_READWRITE |
 115           G_PARAM_STATIC_STRINGS | GST_PARAM_MUTABLE_READY));
 116
 117   g_object_class_install_property (gobject_class,
 118       PROP_MUTE,
 119       g_param_spec_boolean ("mute", "Mute", "Mute state of this stream",
 120           DEFAULT_MUTE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS |
 121           GST_PARAM_MUTABLE_PLAYING));
 122
 123   g_object_class_install_property (gobject_class,
 124       PROP_DEVICE,
 125       g_param_spec_string ("device", "Device",
 126           "WASAPI playback device as a GUID string",
 127           NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 128
 129   g_object_class_install_property (gobject_class,
 130       PROP_EXCLUSIVE,
 131       g_param_spec_boolean ("exclusive", "Exclusive mode",
 132           "Open the device in exclusive mode",
 133           DEFAULT_EXCLUSIVE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 134
 135   g_object_class_install_property (gobject_class,
 136       PROP_LOW_LATENCY,
 137       g_param_spec_boolean ("low-latency", "Low latency",
 138           "Optimize all settings for lowest latency. Always safe to enable.",
 139           DEFAULT_LOW_LATENCY, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 140
 141   g_object_class_install_property (gobject_class,
 142       PROP_AUDIOCLIENT3,
 143       g_param_spec_boolean ("use-audioclient3", "Use the AudioClient3 API",
 144           "Use the Windows 10 AudioClient3 API when available",
 145           DEFAULT_AUDIOCLIENT3, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 146
 147   gst_element_class_add_static_pad_template (gstelement_class, &sink_template);
 148   gst_element_class_set_static_metadata (gstelement_class, "WasapiSrc",
 149       "Sink/Audio",
 150       "Stream audio to an audio capture device through WASAPI",
 151       "Nirbheek Chauhan <nirbheek@centricular.com>, "
 152       "Ole André Vadla Ravnås <ole.andre.ravnas@tandberg.com>");
 153
 154   gstbasesink_class->get_caps = GST_DEBUG_FUNCPTR (gst_wasapi_sink_get_caps);
 155
 156   gstaudiosink_class->prepare = GST_DEBUG_FUNCPTR (gst_wasapi_sink_prepare);
 157   gstaudiosink_class->unprepare = GST_DEBUG_FUNCPTR (gst_wasapi_sink_unprepare);
 158   gstaudiosink_class->open = GST_DEBUG_FUNCPTR (gst_wasapi_sink_open);
 159   gstaudiosink_class->close = GST_DEBUG_FUNCPTR (gst_wasapi_sink_close);
 160   gstaudiosink_class->write = GST_DEBUG_FUNCPTR (gst_wasapi_sink_write);
 161   gstaudiosink_class->delay = GST_DEBUG_FUNCPTR (gst_wasapi_sink_delay);
 162   gstaudiosink_class->reset = GST_DEBUG_FUNCPTR (gst_wasapi_sink_reset);
 163
 164   GST_DEBUG_CATEGORY_INIT (gst_wasapi_sink_debug, "wasapisink",
 165       0, "Windows audio session API sink");
 166 }
 167
 168 static void
 169 gst_wasapi_sink_init (GstWasapiSink * self)
 170 {
 171   self->role = DEFAULT_ROLE;
 172   self->mute = DEFAULT_MUTE;
 173   self->sharemode = AUDCLNT_SHAREMODE_SHARED;
 174   self->low_latency = DEFAULT_LOW_LATENCY;
 175   self->try_audioclient3 = DEFAULT_AUDIOCLIENT3;
 176   self->event_handle = CreateEvent (NULL, FALSE, FALSE, NULL);
 177
 178   CoInitialize (NULL);
 179 }
 180
 181 static void
 182 gst_wasapi_sink_dispose (GObject * object)
 183 {
 184   GstWasapiSink *self = GST_WASAPI_SINK (object);
 185
 186   if (self->event_handle != NULL) {
 187     CloseHandle (self->event_handle);
 188     self->event_handle = NULL;
 189   }
 190
 191   if (self->client != NULL) {
 192     IUnknown_Release (self->client);
 193     self->client = NULL;
 194   }
 195
 196   if (self->render_client != NULL) {
 197     IUnknown_Release (self->render_client);
 198     self->render_client = NULL;
 199   }
 200
 201   G_OBJECT_CLASS (gst_wasapi_sink_parent_class)->dispose (object);
 202 }
 203
 204 static void
 205 gst_wasapi_sink_finalize (GObject * object)
 206 {
 207   GstWasapiSink *self = GST_WASAPI_SINK (object);
 208
 209   g_clear_pointer (&self->mix_format, CoTaskMemFree);
 210
 211   CoUninitialize ();
 212
 213   if (self->cached_caps != NULL) {
 214     gst_caps_unref (self->cached_caps);
 215     self->cached_caps = NULL;
 216   }
 217
 218   g_clear_pointer (&self->positions, g_free);
 219   g_clear_pointer (&self->device_strid, g_free);
 220   self->mute = FALSE;
 221
 222   G_OBJECT_CLASS (gst_wasapi_sink_parent_class)->finalize (object);
 223 }
 224
 225 static void
 226 gst_wasapi_sink_set_property (GObject * object, guint prop_id,
 227     const GValue * value, GParamSpec * pspec)
 228 {
 229   GstWasapiSink *self = GST_WASAPI_SINK (object);
 230
 231   switch (prop_id) {
 232     case PROP_ROLE:
 233       self->role = gst_wasapi_device_role_to_erole (g_value_get_enum (value));
 234       break;
 235     case PROP_MUTE:
 236       self->mute = g_value_get_boolean (value);
 237       break;
 238     case PROP_DEVICE:
 239     {
 240       const gchar *device = g_value_get_string (value);
 241       g_free (self->device_strid);
 242       self->device_strid =
 243           device ? g_utf8_to_utf16 (device, -1, NULL, NULL, NULL) : NULL;
 244       break;
 245     }
 246     case PROP_EXCLUSIVE:
 247       self->sharemode = g_value_get_boolean (value)
 248           ? AUDCLNT_SHAREMODE_EXCLUSIVE : AUDCLNT_SHAREMODE_SHARED;
 249       break;
 250     case PROP_LOW_LATENCY:
 251       self->low_latency = g_value_get_boolean (value);
 252       break;
 253     case PROP_AUDIOCLIENT3:
 254       self->try_audioclient3 = g_value_get_boolean (value);
 255       break;
 256     default:
 257       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 258       break;
 259   }
 260 }
 261
 262 static void
 263 gst_wasapi_sink_get_property (GObject * object, guint prop_id,
 264     GValue * value, GParamSpec * pspec)
 265 {
 266   GstWasapiSink *self = GST_WASAPI_SINK (object);
 267
 268   switch (prop_id) {
 269     case PROP_ROLE:
 270       g_value_set_enum (value, gst_wasapi_erole_to_device_role (self->role));
 271       break;
 272     case PROP_MUTE:
 273       g_value_set_boolean (value, self->mute);
 274       break;
 275     case PROP_DEVICE:
 276       g_value_take_string (value, self->device_strid ?
 277           g_utf16_to_utf8 (self->device_strid, -1, NULL, NULL, NULL) : NULL);
 278       break;
 279     case PROP_EXCLUSIVE:
 280       g_value_set_boolean (value,
 281           self->sharemode == AUDCLNT_SHAREMODE_EXCLUSIVE);
 282       break;
 283     case PROP_LOW_LATENCY:
 284       g_value_set_boolean (value, self->low_latency);
 285       break;
 286     case PROP_AUDIOCLIENT3:
 287       g_value_set_boolean (value, self->try_audioclient3);
 288       break;
 289     default:
 290       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 291       break;
 292   }
 293 }
 294
 295 static gboolean
 296 gst_wasapi_sink_can_audioclient3 (GstWasapiSink * self)
 297 {
 298   if (self->sharemode == AUDCLNT_SHAREMODE_SHARED &&
 299       self->try_audioclient3 && gst_wasapi_util_have_audioclient3 ())
 300     return TRUE;
 301   return FALSE;
 302 }
 303
 304 static GstCaps *
 305 gst_wasapi_sink_get_caps (GstBaseSink * bsink, GstCaps * filter)
 306 {
 307   GstWasapiSink *self = GST_WASAPI_SINK (bsink);
 308   WAVEFORMATEX *format = NULL;
 309   GstCaps *caps = NULL;
 310
 311   GST_DEBUG_OBJECT (self, "entering get caps");
 312
 313   if (self->cached_caps) {
 314     caps = gst_caps_ref (self->cached_caps);
 315   } else {
 316     GstCaps *template_caps;
 317     gboolean ret;
 318
 319     template_caps = gst_pad_get_pad_template_caps (bsink->sinkpad);
 320
 321     if (!self->client)
 322       gst_wasapi_sink_open (GST_AUDIO_SINK (bsink));
 323
 324     ret = gst_wasapi_util_get_device_format (GST_ELEMENT (self),
 325         self->sharemode, self->device, self->client, &format);
 326     if (!ret) {
 327       GST_ELEMENT_ERROR (self, STREAM, FORMAT, (NULL),
 328           ("failed to detect format"));
 329       goto out;
 330     }
 331
 332     gst_wasapi_util_parse_waveformatex ((WAVEFORMATEXTENSIBLE *) format,
 333         template_caps, &caps, &self->positions);
 334     if (caps == NULL) {
 335       GST_ELEMENT_ERROR (self, STREAM, FORMAT, (NULL), ("unknown format"));
 336       goto out;
 337     }
 338
 339     {
 340       gchar *pos_str = gst_audio_channel_positions_to_string (self->positions,
 341           format->nChannels);
 342       GST_INFO_OBJECT (self, "positions are: %s", pos_str);
 343       g_free (pos_str);
 344     }
 345
 346     self->mix_format = format;
 347     gst_caps_replace (&self->cached_caps, caps);
 348     gst_caps_unref (template_caps);
 349   }
 350
 351   if (filter) {
 352     GstCaps *filtered =
 353         gst_caps_intersect_full (filter, caps, GST_CAPS_INTERSECT_FIRST);
 354     gst_caps_unref (caps);
 355     caps = filtered;
 356   }
 357
 358   GST_DEBUG_OBJECT (self, "returning caps %" GST_PTR_FORMAT, caps);
 359
 360 out:
 361   return caps;
 362 }
 363
 364 static gboolean
 365 gst_wasapi_sink_open (GstAudioSink * asink)
 366 {
 367   GstWasapiSink *self = GST_WASAPI_SINK (asink);
 368   gboolean res = FALSE;
 369   IMMDevice *device = NULL;
 370   IAudioClient *client = NULL;
 371
 372   GST_DEBUG_OBJECT (self, "opening device");
 373
 374   if (self->client)
 375     return TRUE;
 376
 377   /* FIXME: Switching the default device does not switch the stream to it,
 378    * even if the old device was unplugged. We need to handle this somehow.
 379    * For example, perhaps we should automatically switch to the new device if
 380    * the default device is changed and a device isn't explicitly selected. */
 381   if (!gst_wasapi_util_get_device_client (GST_ELEMENT (self), eRender,
 382           self->role, self->device_strid, &device, &client)) {
 383     if (!self->device_strid)
 384       GST_ELEMENT_ERROR (self, RESOURCE, OPEN_WRITE, (NULL),
 385           ("Failed to get default device"));
 386     else
 387       GST_ELEMENT_ERROR (self, RESOURCE, OPEN_WRITE, (NULL),
 388           ("Failed to open device %S", self->device_strid));
 389     goto beach;
 390   }
 391
 392   self->client = client;
 393   self->device = device;
 394   res = TRUE;
 395
 396 beach:
 397
 398   return res;
 399 }
 400
 401 static gboolean
 402 gst_wasapi_sink_close (GstAudioSink * asink)
 403 {
 404   GstWasapiSink *self = GST_WASAPI_SINK (asink);
 405
 406   if (self->device != NULL) {
 407     IUnknown_Release (self->device);
 408     self->device = NULL;
 409   }
 410
 411   if (self->client != NULL) {
 412     IUnknown_Release (self->client);
 413     self->client = NULL;
 414   }
 415
 416   return TRUE;
 417 }
 418
 419 /* Get the empty space in the buffer that we have to write to */
 420 static gint
 421 gst_wasapi_sink_get_can_frames (GstWasapiSink * self)
 422 {
 423   HRESULT hr;
 424   guint n_frames_padding;
 425
 426   /* There is no padding in exclusive mode since there is no ringbuffer */
 427   if (self->sharemode == AUDCLNT_SHAREMODE_EXCLUSIVE) {
 428     GST_DEBUG_OBJECT (self, "exclusive mode, can write: %i",
 429         self->buffer_frame_count);
 430     return self->buffer_frame_count;
 431   }
 432
 433   /* Frames the card hasn't rendered yet */
 434   hr = IAudioClient_GetCurrentPadding (self->client, &n_frames_padding);
 435   HR_FAILED_RET (hr, IAudioClient::GetCurrentPadding, -1);
 436
 437   GST_DEBUG_OBJECT (self, "%i unread frames (padding)", n_frames_padding);
 438
 439   /* We can write out these many frames */
 440   return self->buffer_frame_count - n_frames_padding;
 441 }
 442
 443 static gboolean
 444 gst_wasapi_sink_prepare (GstAudioSink * asink, GstAudioRingBufferSpec * spec)
 445 {
 446   GstWasapiSink *self = GST_WASAPI_SINK (asink);
 447   gboolean res = FALSE;
 448   REFERENCE_TIME latency_rt;
 449   guint bpf, rate, devicep_frames;
 450   HRESULT hr;
 451
 452   if (gst_wasapi_sink_can_audioclient3 (self)) {
 453     if (!gst_wasapi_util_initialize_audioclient3 (GST_ELEMENT (self), spec,
 454             (IAudioClient3 *) self->client, self->mix_format, self->low_latency,
 455             FALSE, &devicep_frames))
 456       goto beach;
 457   } else {
 458     if (!gst_wasapi_util_initialize_audioclient (GST_ELEMENT (self), spec,
 459             self->client, self->mix_format, self->sharemode, self->low_latency,
 460             FALSE, &devicep_frames))
 461       goto beach;
 462   }
 463
 464   bpf = GST_AUDIO_INFO_BPF (&spec->info);
 465   rate = GST_AUDIO_INFO_RATE (&spec->info);
 466
 467   /* Total size of the allocated buffer that we will write to */
 468   hr = IAudioClient_GetBufferSize (self->client, &self->buffer_frame_count);
 469   HR_FAILED_GOTO (hr, IAudioClient::GetBufferSize, beach);
 470
 471   GST_INFO_OBJECT (self, "buffer size is %i frames, device period is %i "
 472       "frames, bpf is %i bytes, rate is %i Hz", self->buffer_frame_count,
 473       devicep_frames, bpf, rate);
 474
 475   /* Actual latency-time/buffer-time will be different now */
 476   spec->segsize = devicep_frames * bpf;
 477
 478   /* We need a minimum of 2 segments to ensure glitch-free playback */
 479   spec->segtotal = MAX (self->buffer_frame_count * bpf / spec->segsize, 2);
 480
 481   GST_INFO_OBJECT (self, "segsize is %i, segtotal is %i", spec->segsize,
 482       spec->segtotal);
 483
 484   /* Get latency for logging */
 485   hr = IAudioClient_GetStreamLatency (self->client, &latency_rt);
 486   HR_FAILED_GOTO (hr, IAudioClient::GetStreamLatency, beach);
 487
 488   GST_INFO_OBJECT (self, "wasapi stream latency: %" G_GINT64_FORMAT " (%"
 489       G_GINT64_FORMAT "ms)", latency_rt, latency_rt / 10000);
 490
 491   /* Set the event handler which will trigger writes */
 492   hr = IAudioClient_SetEventHandle (self->client, self->event_handle);
 493   HR_FAILED_GOTO (hr, IAudioClient::SetEventHandle, beach);
 494
 495   /* Get render sink client and start it up */
 496   if (!gst_wasapi_util_get_render_client (GST_ELEMENT (self), self->client,
 497           &self->render_client)) {
 498     goto beach;
 499   }
 500
 501   GST_INFO_OBJECT (self, "got render client");
 502
 503   /* To avoid start-up glitches, before starting the streaming, we fill the
 504    * buffer with silence as recommended by the documentation:
 505    * https://msdn.microsoft.com/en-us/library/windows/desktop/dd370879%28v=vs.85%29.aspx */
 506   {
 507     gint n_frames, len;
 508     gint16 *dst = NULL;
 509
 510     n_frames = gst_wasapi_sink_get_can_frames (self);
 511     if (n_frames < 1) {
 512       GST_ELEMENT_ERROR (self, RESOURCE, WRITE, (NULL),
 513           ("should have more than %i frames to write", n_frames));
 514       goto beach;
 515     }
 516
 517     len = n_frames * self->mix_format->nBlockAlign;
 518
 519     hr = IAudioRenderClient_GetBuffer (self->render_client, n_frames,
 520         (BYTE **) & dst);
 521     HR_FAILED_GOTO (hr, IAudioRenderClient::GetBuffer, beach);
 522
 523     GST_DEBUG_OBJECT (self, "pre-wrote %i bytes of silence", len);
 524
 525     hr = IAudioRenderClient_ReleaseBuffer (self->render_client, n_frames,
 526         AUDCLNT_BUFFERFLAGS_SILENT);
 527     HR_FAILED_GOTO (hr, IAudioRenderClient::ReleaseBuffer, beach);
 528   }
 529
 530   hr = IAudioClient_Start (self->client);
 531   HR_FAILED_GOTO (hr, IAudioClient::Start, beach);
 532
 533   gst_audio_ring_buffer_set_channel_positions (GST_AUDIO_BASE_SINK
 534       (self)->ringbuffer, self->positions);
 535
 536   /* Increase the thread priority to reduce glitches */
 537   self->thread_priority_handle = gst_wasapi_util_set_thread_characteristics ();
 538
 539   res = TRUE;
 540
 541 beach:
 542   /* unprepare() is not called if prepare() fails, but we want it to be, so call
 543    * it manually when needed */
 544   if (!res)
 545     gst_wasapi_sink_unprepare (asink);
 546
 547   return res;
 548 }
 549
 550 static gboolean
 551 gst_wasapi_sink_unprepare (GstAudioSink * asink)
 552 {
 553   GstWasapiSink *self = GST_WASAPI_SINK (asink);
 554
 555   if (self->sharemode == AUDCLNT_SHAREMODE_EXCLUSIVE &&
 556       !gst_wasapi_sink_can_audioclient3 (self))
 557     CoUninitialize ();
 558
 559   if (self->thread_priority_handle != NULL) {
 560     gst_wasapi_util_revert_thread_characteristics
 561         (self->thread_priority_handle);
 562     self->thread_priority_handle = NULL;
 563   }
 564
 565   if (self->client != NULL) {
 566     IAudioClient_Stop (self->client);
 567   }
 568
 569   if (self->render_client != NULL) {
 570     IUnknown_Release (self->render_client);
 571     self->render_client = NULL;
 572   }
 573
 574   return TRUE;
 575 }
 576
 577 static gint
 578 gst_wasapi_sink_write (GstAudioSink * asink, gpointer data, guint length)
 579 {
 580   GstWasapiSink *self = GST_WASAPI_SINK (asink);
 581   HRESULT hr;
 582   gint16 *dst = NULL;
 583   guint pending = length;
 584
 585   while (pending > 0) {
 586     guint can_frames, have_frames, n_frames, write_len;
 587
 588     WaitForSingleObject (self->event_handle, INFINITE);
 589
 590     /* We have N frames to be written out */
 591     have_frames = pending / (self->mix_format->nBlockAlign);
 592     /* We have can_frames space in the output buffer */
 593     can_frames = gst_wasapi_sink_get_can_frames (self);
 594     /* We will write out these many frames, and this much length */
 595     n_frames = MIN (can_frames, have_frames);
 596     write_len = n_frames * self->mix_format->nBlockAlign;
 597
 598     GST_DEBUG_OBJECT (self, "total: %i, have_frames: %i (%i bytes), "
 599         "can_frames: %i, will write: %i (%i bytes)", self->buffer_frame_count,
 600         have_frames, pending, can_frames, n_frames, write_len);
 601
 602     hr = IAudioRenderClient_GetBuffer (self->render_client, n_frames,
 603         (BYTE **) & dst);
 604     HR_FAILED_AND (hr, IAudioRenderClient::GetBuffer, length = 0; goto beach);
 605
 606     memcpy (dst, data, write_len);
 607
 608     hr = IAudioRenderClient_ReleaseBuffer (self->render_client, n_frames,
 609         self->mute ? AUDCLNT_BUFFERFLAGS_SILENT : 0);
 610     HR_FAILED_AND (hr, IAudioRenderClient::ReleaseBuffer, length = 0;
 611         goto beach);
 612
 613     pending -= write_len;
 614   }
 615
 616 beach:
 617
 618   return length;
 619 }
 620
 621 static guint
 622 gst_wasapi_sink_delay (GstAudioSink * asink)
 623 {
 624   GstWasapiSink *self = GST_WASAPI_SINK (asink);
 625   guint delay = 0;
 626   HRESULT hr;
 627
 628   hr = IAudioClient_GetCurrentPadding (self->client, &delay);
 629   HR_FAILED_RET (hr, IAudioClient::GetCurrentPadding, 0);
 630
 631   return delay;
 632 }
 633
 634 static void
 635 gst_wasapi_sink_reset (GstAudioSink * asink)
 636 {
 637   GstWasapiSink *self = GST_WASAPI_SINK (asink);
 638   HRESULT hr;
 639
 640   if (!self->client)
 641     return;
 642
 643   hr = IAudioClient_Stop (self->client);
 644   HR_FAILED_RET (hr, IAudioClient::Stop,);
 645
 646   hr = IAudioClient_Reset (self->client);
 647   HR_FAILED_RET (hr, IAudioClient::Reset,);
 648 }