sys/wasapi2/gstwasapi2sink.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  * Copyright (C) 2020 Seungha Yang <seungha@centricular.com>
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Library General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Library General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Library General Public
  20  * License along with this library; if not, write to the
  21  * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
  22  * Boston, MA 02110-1301, USA.
  23  */
  24
  25 /**
  26  * SECTION:element-wasapi2sink
  27  * @title: wasapi2sink
  28  *
  29  * Provides audio playback using the Windows Audio Session API available with
  30  * Windows 10.
  31  *
  32  * ## Example pipelines
  33  * |[
  34  * gst-launch-1.0 -v audiotestsrc samplesperbuffer=160 ! wasapi2sink
  35  * ]| Generate 20 ms buffers and render to the default audio device.
  36  *
  37  * |[
  38  * gst-launch-1.0 -v audiotestsrc samplesperbuffer=160 ! wasapi2sink low-latency=true
  39  * ]| Same as above, but with the minimum possible latency
  40  *
  41  */
  42 #ifdef HAVE_CONFIG_H
  43 #include <config.h>
  44 #endif
  45
  46 #include "gstwasapi2sink.h"
  47 #include "gstwasapi2util.h"
  48 #include "gstwasapi2client.h"
  49
  50 GST_DEBUG_CATEGORY_STATIC (gst_wasapi2_sink_debug);
  51 #define GST_CAT_DEFAULT gst_wasapi2_sink_debug
  52
  53 static GstStaticPadTemplate sink_template = GST_STATIC_PAD_TEMPLATE ("sink",
  54     GST_PAD_SINK,
  55     GST_PAD_ALWAYS,
  56     GST_STATIC_CAPS (GST_WASAPI2_STATIC_CAPS));
  57
  58 #define DEFAULT_LOW_LATENCY   FALSE
  59 #define DEFAULT_MUTE          FALSE
  60 #define DEFAULT_VOLUME        1.0
  61
  62 #define GST_WASAPI2_SINK_LOCK(s) g_mutex_lock(&(s)->lock)
  63 #define GST_WASAPI2_SINK_UNLOCK(s) g_mutex_unlock(&(s)->lock)
  64
  65 enum
  66 {
  67   PROP_0,
  68   PROP_DEVICE,
  69   PROP_LOW_LATENCY,
  70   PROP_MUTE,
  71   PROP_VOLUME,
  72 };
  73
  74 struct _GstWasapi2Sink
  75 {
  76   GstAudioSink parent;
  77
  78   GstWasapi2Client *client;
  79   GstCaps *cached_caps;
  80   gboolean started;
  81
  82   /* properties */
  83   gchar *device_id;
  84   gboolean low_latency;
  85   gboolean mute;
  86   gdouble volume;
  87
  88   gboolean mute_changed;
  89   gboolean volume_changed;
  90
  91   /* to protect audioclient from set/get property */
  92   GMutex lock;
  93 };
  94
  95 static void gst_wasapi2_sink_dispose (GObject * object);
  96 static void gst_wasapi2_sink_finalize (GObject * object);
  97 static void gst_wasapi2_sink_set_property (GObject * object, guint prop_id,
  98     const GValue * value, GParamSpec * pspec);
  99 static void gst_wasapi2_sink_get_property (GObject * object, guint prop_id,
 100     GValue * value, GParamSpec * pspec);
 101
 102 static GstCaps *gst_wasapi2_sink_get_caps (GstBaseSink * bsink,
 103     GstCaps * filter);
 104
 105 static gboolean gst_wasapi2_sink_prepare (GstAudioSink * asink,
 106     GstAudioRingBufferSpec * spec);
 107 static gboolean gst_wasapi2_sink_unprepare (GstAudioSink * asink);
 108 static gboolean gst_wasapi2_sink_open (GstAudioSink * asink);
 109 static gboolean gst_wasapi2_sink_close (GstAudioSink * asink);
 110 static gint gst_wasapi2_sink_write (GstAudioSink * asink,
 111     gpointer data, guint length);
 112 static guint gst_wasapi2_sink_delay (GstAudioSink * asink);
 113 static void gst_wasapi2_sink_reset (GstAudioSink * asink);
 114
 115 static void gst_wasapi2_sink_set_mute (GstWasapi2Sink * self, gboolean mute);
 116 static gboolean gst_wasapi2_sink_get_mute (GstWasapi2Sink * self);
 117 static void gst_wasapi2_sink_set_volume (GstWasapi2Sink * self, gdouble volume);
 118 static gdouble gst_wasapi2_sink_get_volume (GstWasapi2Sink * self);
 119
 120 #define gst_wasapi2_sink_parent_class parent_class
 121 G_DEFINE_TYPE_WITH_CODE (GstWasapi2Sink, gst_wasapi2_sink, GST_TYPE_AUDIO_SINK,
 122     G_IMPLEMENT_INTERFACE (GST_TYPE_STREAM_VOLUME, NULL));
 123
 124 static void
 125 gst_wasapi2_sink_class_init (GstWasapi2SinkClass * klass)
 126 {
 127   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
 128   GstElementClass *element_class = GST_ELEMENT_CLASS (klass);
 129   GstBaseSinkClass *basesink_class = GST_BASE_SINK_CLASS (klass);
 130   GstAudioSinkClass *audiosink_class = GST_AUDIO_SINK_CLASS (klass);
 131
 132   gobject_class->dispose = gst_wasapi2_sink_dispose;
 133   gobject_class->finalize = gst_wasapi2_sink_finalize;
 134   gobject_class->set_property = gst_wasapi2_sink_set_property;
 135   gobject_class->get_property = gst_wasapi2_sink_get_property;
 136
 137   g_object_class_install_property (gobject_class, PROP_DEVICE,
 138       g_param_spec_string ("device", "Device",
 139           "WASAPI playback device as a GUID string",
 140           NULL, GST_PARAM_MUTABLE_READY | G_PARAM_READWRITE |
 141           G_PARAM_STATIC_STRINGS));
 142
 143   g_object_class_install_property (gobject_class, PROP_LOW_LATENCY,
 144       g_param_spec_boolean ("low-latency", "Low latency",
 145           "Optimize all settings for lowest latency. Always safe to enable.",
 146           DEFAULT_LOW_LATENCY, GST_PARAM_MUTABLE_READY | G_PARAM_READWRITE |
 147           G_PARAM_STATIC_STRINGS));
 148
 149   g_object_class_install_property (gobject_class, PROP_MUTE,
 150       g_param_spec_boolean ("mute", "Mute", "Mute state of this stream",
 151           DEFAULT_MUTE, GST_PARAM_MUTABLE_PLAYING | G_PARAM_READWRITE |
 152           G_PARAM_STATIC_STRINGS));
 153
 154   g_object_class_install_property (gobject_class, PROP_VOLUME,
 155       g_param_spec_double ("volume", "Volume", "Volume of this stream",
 156           0.0, 1.0, DEFAULT_VOLUME,
 157           GST_PARAM_MUTABLE_PLAYING | G_PARAM_READWRITE |
 158           G_PARAM_STATIC_STRINGS));
 159
 160   gst_element_class_add_static_pad_template (element_class, &sink_template);
 161   gst_element_class_set_static_metadata (element_class, "Wasapi2Sink",
 162       "Sink/Audio/Hardware",
 163       "Stream audio to an audio capture device through WASAPI",
 164       "Nirbheek Chauhan <nirbheek@centricular.com>, "
 165       "Ole André Vadla Ravnås <ole.andre.ravnas@tandberg.com>, "
 166       "Seungha Yang <seungha@centricular.com>");
 167
 168   basesink_class->get_caps = GST_DEBUG_FUNCPTR (gst_wasapi2_sink_get_caps);
 169
 170   audiosink_class->prepare = GST_DEBUG_FUNCPTR (gst_wasapi2_sink_prepare);
 171   audiosink_class->unprepare = GST_DEBUG_FUNCPTR (gst_wasapi2_sink_unprepare);
 172   audiosink_class->open = GST_DEBUG_FUNCPTR (gst_wasapi2_sink_open);
 173   audiosink_class->close = GST_DEBUG_FUNCPTR (gst_wasapi2_sink_close);
 174   audiosink_class->write = GST_DEBUG_FUNCPTR (gst_wasapi2_sink_write);
 175   audiosink_class->delay = GST_DEBUG_FUNCPTR (gst_wasapi2_sink_delay);
 176   audiosink_class->reset = GST_DEBUG_FUNCPTR (gst_wasapi2_sink_reset);
 177
 178   GST_DEBUG_CATEGORY_INIT (gst_wasapi2_sink_debug, "wasapi2sink",
 179       0, "Windows audio session API sink");
 180 }
 181
 182 static void
 183 gst_wasapi2_sink_init (GstWasapi2Sink * self)
 184 {
 185   self->low_latency = DEFAULT_LOW_LATENCY;
 186   self->mute = DEFAULT_MUTE;
 187   self->volume = DEFAULT_VOLUME;
 188
 189   g_mutex_init (&self->lock);
 190 }
 191
 192 static void
 193 gst_wasapi2_sink_dispose (GObject * object)
 194 {
 195   GstWasapi2Sink *self = GST_WASAPI2_SINK (object);
 196
 197   GST_WASAPI2_SINK_LOCK (self);
 198   gst_clear_object (&self->client);
 199   gst_clear_caps (&self->cached_caps);
 200   GST_WASAPI2_SINK_UNLOCK (self);
 201
 202   G_OBJECT_CLASS (parent_class)->dispose (object);
 203 }
 204
 205 static void
 206 gst_wasapi2_sink_finalize (GObject * object)
 207 {
 208   GstWasapi2Sink *self = GST_WASAPI2_SINK (object);
 209
 210   g_free (self->device_id);
 211   g_mutex_clear (&self->lock);
 212
 213   G_OBJECT_CLASS (parent_class)->finalize (object);
 214 }
 215
 216 static void
 217 gst_wasapi2_sink_set_property (GObject * object, guint prop_id,
 218     const GValue * value, GParamSpec * pspec)
 219 {
 220   GstWasapi2Sink *self = GST_WASAPI2_SINK (object);
 221
 222   switch (prop_id) {
 223     case PROP_DEVICE:
 224       g_free (self->device_id);
 225       self->device_id = g_value_dup_string (value);
 226       break;
 227     case PROP_LOW_LATENCY:
 228       self->low_latency = g_value_get_boolean (value);
 229       break;
 230     case PROP_MUTE:
 231       gst_wasapi2_sink_set_mute (self, g_value_get_boolean (value));
 232       break;
 233     case PROP_VOLUME:
 234       gst_wasapi2_sink_set_volume (self, g_value_get_double (value));
 235       break;
 236     default:
 237       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 238       break;
 239   }
 240 }
 241
 242 static void
 243 gst_wasapi2_sink_get_property (GObject * object, guint prop_id,
 244     GValue * value, GParamSpec * pspec)
 245 {
 246   GstWasapi2Sink *self = GST_WASAPI2_SINK (object);
 247
 248   switch (prop_id) {
 249     case PROP_DEVICE:
 250       g_value_set_string (value, self->device_id);
 251       break;
 252     case PROP_LOW_LATENCY:
 253       g_value_set_boolean (value, self->low_latency);
 254       break;
 255     case PROP_MUTE:
 256       g_value_set_boolean (value, gst_wasapi2_sink_get_mute (self));
 257       break;
 258     case PROP_VOLUME:
 259       g_value_set_double (value, gst_wasapi2_sink_get_volume (self));
 260       break;
 261     default:
 262       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 263       break;
 264   }
 265 }
 266
 267 static GstCaps *
 268 gst_wasapi2_sink_get_caps (GstBaseSink * bsink, GstCaps * filter)
 269 {
 270   GstWasapi2Sink *self = GST_WASAPI2_SINK (bsink);
 271   GstCaps *caps = NULL;
 272
 273   /* store one caps here so that we can return device caps even if
 274    * audioclient was closed due to unprepare() */
 275   if (!self->cached_caps && self->client)
 276     self->cached_caps = gst_wasapi2_client_get_caps (self->client);
 277
 278   if (self->client)
 279     caps = gst_wasapi2_client_get_caps (self->client);
 280
 281   if (!caps && self->cached_caps)
 282     caps = gst_caps_ref (self->cached_caps);
 283
 284   if (!caps)
 285     caps = gst_pad_get_pad_template_caps (bsink->sinkpad);
 286
 287   if (filter) {
 288     GstCaps *filtered =
 289         gst_caps_intersect_full (filter, caps, GST_CAPS_INTERSECT_FIRST);
 290     gst_caps_unref (caps);
 291     caps = filtered;
 292   }
 293
 294   GST_DEBUG_OBJECT (self, "returning caps %" GST_PTR_FORMAT, caps);
 295
 296   return caps;
 297 }
 298
 299 static gboolean
 300 gst_wasapi2_sink_open_unlocked (GstAudioSink * asink)
 301 {
 302   GstWasapi2Sink *self = GST_WASAPI2_SINK (asink);
 303
 304   self->client =
 305       gst_wasapi2_client_new (GST_WASAPI2_CLIENT_DEVICE_CLASS_RENDER,
 306       self->low_latency, -1, self->device_id);
 307
 308   return ! !self->client;
 309 }
 310
 311 static gboolean
 312 gst_wasapi2_sink_open (GstAudioSink * asink)
 313 {
 314   GstWasapi2Sink *self = GST_WASAPI2_SINK (asink);
 315   gboolean ret;
 316
 317   GST_DEBUG_OBJECT (self, "Opening device");
 318
 319   GST_WASAPI2_SINK_LOCK (self);
 320   ret = gst_wasapi2_sink_open_unlocked (asink);
 321   GST_WASAPI2_SINK_UNLOCK (self);
 322
 323   if (!ret) {
 324     GST_ELEMENT_ERROR (self, RESOURCE, OPEN_WRITE, (NULL),
 325         ("Failed to open device"));
 326     return FALSE;
 327   }
 328
 329   return TRUE;
 330 }
 331
 332 static gboolean
 333 gst_wasapi2_sink_close (GstAudioSink * asink)
 334 {
 335   GstWasapi2Sink *self = GST_WASAPI2_SINK (asink);
 336
 337   GST_WASAPI2_SINK_LOCK (self);
 338
 339   gst_clear_object (&self->client);
 340   gst_clear_caps (&self->cached_caps);
 341   self->started = FALSE;
 342
 343   GST_WASAPI2_SINK_UNLOCK (self);
 344
 345   return TRUE;
 346 }
 347
 348 static gboolean
 349 gst_wasapi2_sink_prepare (GstAudioSink * asink, GstAudioRingBufferSpec * spec)
 350 {
 351   GstWasapi2Sink *self = GST_WASAPI2_SINK (asink);
 352   GstAudioBaseSink *bsink = GST_AUDIO_BASE_SINK (asink);
 353   gboolean ret = FALSE;
 354
 355   GST_WASAPI2_SINK_LOCK (self);
 356   if (!self->client && !gst_wasapi2_sink_open_unlocked (asink)) {
 357     GST_ERROR_OBJECT (self, "No audio client was configured");
 358     goto done;
 359   }
 360
 361   if (!gst_wasapi2_client_open (self->client, spec, bsink->ringbuffer)) {
 362     GST_ERROR_OBJECT (self, "Couldn't open audio client");
 363     goto done;
 364   }
 365
 366   /* Set mute and volume here again, maybe when "mute" property was set, audioclient
 367    * might not be configured at that moment */
 368   if (self->mute_changed) {
 369     gst_wasapi2_client_set_mute (self->client, self->mute);
 370     self->mute_changed = FALSE;
 371   }
 372
 373   if (self->volume_changed) {
 374     gst_wasapi2_client_set_volume (self->client, self->volume);
 375     self->volume_changed = FALSE;
 376   }
 377
 378   /* Will start IAudioClient on the first write request */
 379   self->started = FALSE;
 380   ret = TRUE;
 381
 382 done:
 383   GST_WASAPI2_SINK_UNLOCK (self);
 384
 385   return ret;
 386 }
 387
 388 static gboolean
 389 gst_wasapi2_sink_unprepare (GstAudioSink * asink)
 390 {
 391   GstWasapi2Sink *self = GST_WASAPI2_SINK (asink);
 392
 393   self->started = FALSE;
 394
 395   /* Will reopen device later prepare() */
 396   GST_WASAPI2_SINK_LOCK (self);
 397   if (self->client) {
 398     gst_wasapi2_client_stop (self->client);
 399     gst_clear_object (&self->client);
 400   }
 401   GST_WASAPI2_SINK_UNLOCK (self);
 402
 403   return TRUE;
 404 }
 405
 406 static gint
 407 gst_wasapi2_sink_write (GstAudioSink * asink, gpointer data, guint length)
 408 {
 409   GstWasapi2Sink *self = GST_WASAPI2_SINK (asink);
 410
 411   if (!self->client) {
 412     GST_ERROR_OBJECT (self, "No audio client was configured");
 413     return -1;
 414   }
 415
 416   if (!self->started) {
 417     if (!gst_wasapi2_client_start (self->client)) {
 418       GST_ERROR_OBJECT (self, "Failed to re-start client");
 419       return -1;
 420     }
 421
 422     self->started = TRUE;
 423   }
 424
 425   return gst_wasapi2_client_write (self->client, data, length);
 426 }
 427
 428 static guint
 429 gst_wasapi2_sink_delay (GstAudioSink * asink)
 430 {
 431   GstWasapi2Sink *self = GST_WASAPI2_SINK (asink);
 432
 433   if (!self->client)
 434     return 0;
 435
 436   return gst_wasapi2_client_delay (self->client);
 437 }
 438
 439 static void
 440 gst_wasapi2_sink_reset (GstAudioSink * asink)
 441 {
 442   GstWasapi2Sink *self = GST_WASAPI2_SINK (asink);
 443
 444   GST_INFO_OBJECT (self, "reset called");
 445
 446   self->started = FALSE;
 447
 448   if (!self->client)
 449     return;
 450
 451   gst_wasapi2_client_stop (self->client);
 452 }
 453
 454 static void
 455 gst_wasapi2_sink_set_mute (GstWasapi2Sink * self, gboolean mute)
 456 {
 457   GST_WASAPI2_SINK_LOCK (self);
 458
 459   self->mute = mute;
 460   self->mute_changed = TRUE;
 461
 462   if (self->client) {
 463     if (!gst_wasapi2_client_set_mute (self->client, mute)) {
 464       GST_INFO_OBJECT (self, "Couldn't set mute");
 465     } else {
 466       self->mute_changed = FALSE;
 467     }
 468   } else {
 469     GST_DEBUG_OBJECT (self, "audio client is not configured yet");
 470   }
 471
 472   GST_WASAPI2_SINK_UNLOCK (self);
 473 }
 474
 475 static gboolean
 476 gst_wasapi2_sink_get_mute (GstWasapi2Sink * self)
 477 {
 478   gboolean mute;
 479
 480   GST_WASAPI2_SINK_LOCK (self);
 481
 482   mute = self->mute;
 483
 484   if (self->client) {
 485     if (!gst_wasapi2_client_get_mute (self->client, &mute)) {
 486       GST_INFO_OBJECT (self, "Couldn't get mute state");
 487     } else {
 488       self->mute = mute;
 489     }
 490   } else {
 491     GST_DEBUG_OBJECT (self, "audio client is not configured yet");
 492   }
 493
 494   GST_WASAPI2_SINK_UNLOCK (self);
 495
 496   return mute;
 497 }
 498
 499 static void
 500 gst_wasapi2_sink_set_volume (GstWasapi2Sink * self, gdouble volume)
 501 {
 502   GST_WASAPI2_SINK_LOCK (self);
 503
 504   self->volume = volume;
 505   /* clip volume value */
 506   self->volume = MAX (0.0, self->volume);
 507   self->volume = MIN (1.0, self->volume);
 508   self->volume_changed = TRUE;
 509
 510   if (self->client) {
 511     if (!gst_wasapi2_client_set_volume (self->client, (gfloat) self->volume)) {
 512       GST_INFO_OBJECT (self, "Couldn't set volume");
 513     } else {
 514       self->volume_changed = FALSE;
 515     }
 516   } else {
 517     GST_DEBUG_OBJECT (self, "audio client is not configured yet");
 518   }
 519
 520   GST_WASAPI2_SINK_UNLOCK (self);
 521 }
 522
 523 static gdouble
 524 gst_wasapi2_sink_get_volume (GstWasapi2Sink * self)
 525 {
 526   gfloat volume;
 527
 528   GST_WASAPI2_SINK_LOCK (self);
 529
 530   volume = (gfloat) self->volume;
 531
 532   if (self->client) {
 533     if (!gst_wasapi2_client_get_volume (self->client, &volume)) {
 534       GST_INFO_OBJECT (self, "Couldn't get volume");
 535     } else {
 536       self->volume = volume;
 537     }
 538   } else {
 539     GST_DEBUG_OBJECT (self, "audio client is not configured yet");
 540   }
 541
 542   GST_WASAPI2_SINK_UNLOCK (self);
 543
 544   volume = MAX (0.0, volume);
 545   volume = MIN (1.0, volume);
 546
 547   return volume;
 548 }