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