FaSTTUBe/GST-Tensordecoder-ov_ep
37
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

wasapi2: Add support for dynamic device switch

Browse Source 
Ringbuffer implementation is re-written to support "device" property
change in playing state

Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/9326>
This commit is contained in:
Seungha Yang 2025-07-01 00:33:18 +09:00 committed by GStreamer Marge Bot
parent 6b32228573
commit 9dbc7a491e
12 changed files with 2639 additions and 2904 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

461
subprojects/gst-plugins-bad/sys/wasapi2/gstwasapi2object.cpp
View File

@ -1,461 +0,0 @@
/* GStreamer
* Copyright (C) 2025 Seungha Yang <seungha@centricular.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "gstwasapi2object.h"
#include "gstwasapi2activator.h"
#include <endpointvolume.h>
#include <mutex>
#include <condition_variable>
#include <wrl.h>
#include <string>
#include <atomic>
#include <string.h>
/* *INDENT-OFF* */
using namespace Microsoft::WRL;
GST_DEBUG_CATEGORY_EXTERN (gst_wasapi2_debug);
#define GST_CAT_DEFAULT gst_wasapi2_debug
static GstStaticCaps template_caps = GST_STATIC_CAPS (GST_WASAPI2_STATIC_CAPS);
static void gst_wasapi2_object_set_endpoint_muted (GstWasapi2Object * object,
bool muted);
DEFINE_GUID (IID_Wasapi2EndpointVolumeCallback, 0x21ba991f, 0x4d78,
0x418c, 0xa1, 0xea, 0x8a, 0xc7, 0xdd, 0xa2, 0xdc, 0x39);
class Wasapi2EndpointVolumeCallback : public IAudioEndpointVolumeCallback
{
public:
static void CreateInstance (Wasapi2EndpointVolumeCallback ** iface,
GstWasapi2Object * client)
{
auto self = new Wasapi2EndpointVolumeCallback ();
g_weak_ref_set (&self->client_, client);
*iface = self;
}
STDMETHODIMP_ (ULONG)
AddRef (void)
{
return InterlockedIncrement (&refcount_);
}
STDMETHODIMP_ (ULONG)
Release (void)
{
ULONG ref_count;
ref_count = InterlockedDecrement (&refcount_);
if (ref_count == 0)
delete this;
return ref_count;
}
STDMETHODIMP
QueryInterface (REFIID riid, void ** object)
{
if (riid == __uuidof(IUnknown) || riid == __uuidof(IAgileObject)) {
*object = static_cast<IUnknown *>(
static_cast<Wasapi2EndpointVolumeCallback*>(this));
} else if (riid == __uuidof(IAudioEndpointVolumeCallback)) {
*object = static_cast<IAudioEndpointVolumeCallback *>(
static_cast<Wasapi2EndpointVolumeCallback*>(this));
} else if (riid == IID_Wasapi2EndpointVolumeCallback) {
*object = static_cast<Wasapi2EndpointVolumeCallback *> (this);
} else {
*object = nullptr;
return E_NOINTERFACE;
}
AddRef ();
return S_OK;
}
STDMETHODIMP
OnNotify (AUDIO_VOLUME_NOTIFICATION_DATA * notify)
{
auto client = (GstWasapi2Object *) g_weak_ref_get (&client_);
if (client) {
gst_wasapi2_object_set_endpoint_muted (client, notify->bMuted);
gst_object_unref (client);
}
return S_OK;
}
private:
Wasapi2EndpointVolumeCallback ()
{
g_weak_ref_init (&client_, nullptr);
}
virtual ~Wasapi2EndpointVolumeCallback ()
{
g_weak_ref_set (&client_, nullptr);
}
private:
ULONG refcount_ = 1;
GWeakRef client_;
};
struct GstWasapi2ObjectPrivate
{
ComPtr<IMMDeviceEnumerator> enumerator;
ComPtr<IMMDevice> device;
ComPtr<IAudioClient> client;
ComPtr<IAudioEndpointVolume> endpoint_volume;
std::atomic<bool> endpoint_muted = { false };
Wasapi2EndpointVolumeCallback *volume_callback = nullptr;
Wasapi2ActivationHandler *activator = nullptr;
std::mutex lock;
std::condition_variable cond;
std::string device_id;
GstWasapi2EndpointClass device_class;
guint target_pid;
gboolean is_default_device = FALSE;
void ClearCOM ()
{
if (volume_callback && endpoint_volume)
endpoint_volume->UnregisterControlChangeNotify (volume_callback);
if (activator)
activator->Release ();
client = nullptr;
if (volume_callback)
volume_callback->Release ();
endpoint_volume = nullptr;
device = nullptr;
enumerator = nullptr;
}
};
/* *INDENT-ON* */
struct _GstWasapi2Object
{
GstObject parent;
GstWasapi2ObjectPrivate *priv;
GThread *thread;
GMainContext *context;
GMainLoop *loop;
GstCaps *caps;
};
static void gst_wasapi2_object_finalize (GObject * object);
#define gst_wasapi2_object_parent_class parent_class
G_DEFINE_TYPE (GstWasapi2Object, gst_wasapi2_object, GST_TYPE_OBJECT);
static void
gst_wasapi2_object_class_init (GstWasapi2ObjectClass * klass)
{
auto object_class = G_OBJECT_CLASS (klass);
object_class->finalize = gst_wasapi2_object_finalize;
}
static void
gst_wasapi2_object_init (GstWasapi2Object * self)
{
self->priv = new GstWasapi2ObjectPrivate ();
self->context = g_main_context_new ();
self->loop = g_main_loop_new (self->context, FALSE);
}
static void
gst_wasapi2_object_finalize (GObject * object)
{
auto self = GST_WASAPI2_OBJECT (object);
g_main_loop_quit (self->loop);
g_thread_join (self->thread);
g_main_loop_unref (self->loop);
g_main_context_unref (self->context);
gst_clear_caps (&self->caps);
delete self->priv;
G_OBJECT_CLASS (parent_class)->finalize (object);
}
static void
gst_wasapi2_object_set_endpoint_muted (GstWasapi2Object * object, bool muted)
{
auto priv = object->priv;
priv->endpoint_muted.store (muted, std::memory_order_release);
}
static gboolean
is_equal_device_id (const gchar * a, const gchar * b)
{
auto len_a = strlen (a);
auto len_b = strlen (b);
if (len_a != len_b)
return FALSE;
#ifdef _MSC_VER
return _strnicmp (a, b, len_a) == 0;
#else
return strncasecmp (a, b, len_a) == 0;
#endif
}
static gpointer
gst_wasapi2_object_thread_func (GstWasapi2Object * self)
{
auto priv = self->priv;
CoInitializeEx (nullptr, COINIT_MULTITHREADED);
g_main_context_push_thread_default (self->context);
auto idle_source = g_idle_source_new ();
/* *INDENT-OFF* */
g_source_set_callback (idle_source,
[] (gpointer user_data) -> gboolean {
auto self = (GstWasapi2Object *) user_data;
auto priv = self->priv;
std::lock_guard < std::mutex > lk (priv->lock);
priv->cond.notify_all ();
return G_SOURCE_REMOVE;
},
self, nullptr);
/* *INDENT-ON* */
g_source_attach (idle_source, self->context);
g_source_unref (idle_source);
auto hr = CoCreateInstance (__uuidof (MMDeviceEnumerator),
nullptr, CLSCTX_ALL, IID_PPV_ARGS (&priv->enumerator));
if (FAILED (hr)) {
GST_ERROR_OBJECT (self, "Failed to create IMMDeviceEnumerator instance");
goto run_loop;
}
switch (priv->device_class) {
case GST_WASAPI2_ENDPOINT_CLASS_CAPTURE:
if (priv->device_id.empty () ||
is_equal_device_id (priv->device_id.c_str (),
gst_wasapi2_get_default_device_id (eCapture))) {
if (gst_wasapi2_can_automatic_stream_routing ()) {
Wasapi2ActivationHandler::CreateInstance (&priv->activator,
gst_wasapi2_get_default_device_id_wide (eCapture), nullptr);
GST_DEBUG_OBJECT (self, "Creating default capture device");
priv->is_default_device = TRUE;
} else {
GST_DEBUG_OBJECT (self, "Creating default capture MMdevice");
hr = priv->enumerator->GetDefaultAudioEndpoint (eCapture,
eConsole, &priv->device);
}
} else {
auto wstr = g_utf8_to_utf16 (priv->device_id.c_str (),
-1, nullptr, nullptr, nullptr);
hr = priv->enumerator->GetDevice ((LPCWSTR) wstr, &priv->device);
g_free (wstr);
}
break;
case GST_WASAPI2_ENDPOINT_CLASS_RENDER:
case GST_WASAPI2_ENDPOINT_CLASS_LOOPBACK_CAPTURE:
if (priv->device_id.empty () ||
is_equal_device_id (priv->device_id.c_str (),
gst_wasapi2_get_default_device_id (eRender))) {
if (gst_wasapi2_can_automatic_stream_routing ()) {
Wasapi2ActivationHandler::CreateInstance (&priv->activator,
gst_wasapi2_get_default_device_id_wide (eRender), nullptr);
GST_DEBUG_OBJECT (self, "Creating default render device");
priv->is_default_device = TRUE;
} else {
GST_DEBUG_OBJECT (self, "Creating default render MMdevice");
hr = priv->enumerator->GetDefaultAudioEndpoint (eRender,
eConsole, &priv->device);
}
} else {
auto wstr = g_utf8_to_utf16 (priv->device_id.c_str (),
-1, nullptr, nullptr, nullptr);
hr = priv->enumerator->GetDevice ((LPCWSTR) wstr, &priv->device);
g_free (wstr);
}
break;
case GST_WASAPI2_ENDPOINT_CLASS_INCLUDE_PROCESS_LOOPBACK_CAPTURE:
case GST_WASAPI2_ENDPOINT_CLASS_EXCLUDE_PROCESS_LOOPBACK_CAPTURE:
{
AUDIOCLIENT_ACTIVATION_PARAMS params = { };
params.ActivationType = AUDIOCLIENT_ACTIVATION_TYPE_PROCESS_LOOPBACK;
params.ProcessLoopbackParams.TargetProcessId = priv->target_pid;
if (priv->device_class ==
GST_WASAPI2_ENDPOINT_CLASS_INCLUDE_PROCESS_LOOPBACK_CAPTURE) {
params.ProcessLoopbackParams.ProcessLoopbackMode =
PROCESS_LOOPBACK_MODE_INCLUDE_TARGET_PROCESS_TREE;
} else {
params.ProcessLoopbackParams.ProcessLoopbackMode =
PROCESS_LOOPBACK_MODE_EXCLUDE_TARGET_PROCESS_TREE;
}
GST_DEBUG_OBJECT (self, "Creating process loopback capture device");
Wasapi2ActivationHandler::CreateInstance (&priv->activator,
VIRTUAL_AUDIO_DEVICE_PROCESS_LOOPBACK, &params);
break;
}
default:
g_assert_not_reached ();
break;
}
if (priv->activator || priv->device) {
if (priv->activator) {
hr = priv->activator->ActivateAsync ();
if (gst_wasapi2_result (hr))
hr = priv->activator->GetClient (&priv->client, INFINITE);
} else {
hr = priv->device->Activate (__uuidof (IAudioClient), CLSCTX_ALL,
nullptr, &priv->client);
}
if (!gst_wasapi2_result (hr)) {
GST_WARNING_OBJECT (self, "Couldn't activate device");
} else if (priv->device &&
priv->device_class == GST_WASAPI2_ENDPOINT_CLASS_LOOPBACK_CAPTURE) {
hr = priv->device->Activate (__uuidof (IAudioEndpointVolume),
CLSCTX_ALL, nullptr, &priv->endpoint_volume);
if (gst_wasapi2_result (hr)) {
Wasapi2EndpointVolumeCallback::CreateInstance (&priv->volume_callback,
self);
hr = priv->endpoint_volume->
RegisterControlChangeNotify (priv->volume_callback);
if (!gst_wasapi2_result (hr)) {
priv->volume_callback->Release ();
priv->volume_callback = nullptr;
} else {
BOOL muted = FALSE;
priv->endpoint_volume->GetMute (&muted);
if (gst_wasapi2_result (hr))
gst_wasapi2_object_set_endpoint_muted (self, muted);
}
}
}
} else {
GST_WARNING_OBJECT (self, "No device created");
}
if (priv->client) {
WAVEFORMATEX *mix_format = nullptr;
hr = priv->client->GetMixFormat (&mix_format);
if (!gst_wasapi2_result (hr)) {
if (gst_wasapi2_is_process_loopback_class (priv->device_class))
mix_format = gst_wasapi2_get_default_mix_format ();
}
if (mix_format) {
auto scaps = gst_static_caps_get (&template_caps);
gst_wasapi2_util_parse_waveformatex (mix_format,
scaps, &self->caps, nullptr);
gst_caps_unref (scaps);
CoTaskMemFree (mix_format);
}
}
run_loop:
GST_INFO_OBJECT (self, "Starting loop");
g_main_loop_run (self->loop);
GST_INFO_OBJECT (self, "Stopped loop");
priv->ClearCOM ();
g_main_context_pop_thread_default (self->context);
CoUninitialize ();
return nullptr;
}
GstWasapi2Object *
gst_wasapi2_object_new (GstWasapi2EndpointClass device_class,
const gchar * device_id, guint target_pid)
{
auto self = (GstWasapi2Object *)
g_object_new (GST_TYPE_WASAPI2_OBJECT, nullptr);
gst_object_ref_sink (self);
auto priv = self->priv;
priv->device_class = device_class;
if (device_id)
priv->device_id = device_id;
priv->target_pid = target_pid;
if (gst_wasapi2_is_process_loopback_class (device_class) && !target_pid) {
GST_ERROR_OBJECT (self, "Unspecified target PID");
gst_object_unref (self);
return nullptr;
}
{
std::unique_lock < std::mutex > lk (priv->lock);
self->thread = g_thread_new ("GstWasapi2Object",
(GThreadFunc) gst_wasapi2_object_thread_func, self);
while (!g_main_loop_is_running (self->loop))
priv->cond.wait (lk);
}
if (!priv->client) {
gst_object_unref (self);
return nullptr;
}
return self;
}
GstCaps *
gst_wasapi2_object_get_caps (GstWasapi2Object * object)
{
if (object->caps)
return gst_caps_ref (object->caps);
return nullptr;
}
IAudioClient *
gst_wasapi2_object_get_handle (GstWasapi2Object * object)
{
return object->priv->client.Get ();
}
gboolean
gst_wasapi2_object_is_endpoint_muted (GstWasapi2Object * object)
{
return object->priv->endpoint_muted.load (std::memory_order_acquire);
}
gboolean
gst_wasapi2_object_auto_routing_supported (GstWasapi2Object * object)
{
return object->priv->is_default_device;
}

44
subprojects/gst-plugins-bad/sys/wasapi2/gstwasapi2object.h
View File

@ -1,44 +0,0 @@
/* GStreamer
* Copyright (C) 2025 Seungha Yang <seungha@centricular.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#pragma once
#include <gst/gst.h>
#include "gstwasapi2util.h"
G_BEGIN_DECLS
#define GST_TYPE_WASAPI2_OBJECT (gst_wasapi2_object_get_type ())
G_DECLARE_FINAL_TYPE (GstWasapi2Object, gst_wasapi2_object,
GST, WASAPI2_OBJECT, GstObject);
GstWasapi2Object * gst_wasapi2_object_new (GstWasapi2EndpointClass device_class,
const gchar * device_id,
guint target_pid);
GstCaps * gst_wasapi2_object_get_caps (GstWasapi2Object * object);
IAudioClient * gst_wasapi2_object_get_handle (GstWasapi2Object * object);
gboolean gst_wasapi2_object_is_endpoint_muted (GstWasapi2Object * object);
gboolean gst_wasapi2_object_auto_routing_supported (GstWasapi2Object * object);
G_END_DECLS

2099
subprojects/gst-plugins-bad/sys/wasapi2/gstwasapi2rbuf.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

56
subprojects/gst-plugins-bad/sys/wasapi2/gstwasapi2rbuf.h Normal file
View File

@ -0,0 +1,56 @@
/* GStreamer
* Copyright (C) 2025 Seungha Yang <seungha@centricular.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#pragma once
#include <gst/gst.h>
#include <gst/audio/audio.h>
#include "gstwasapi2util.h"
G_BEGIN_DECLS
#define GST_TYPE_WASAPI2_RBUF (gst_wasapi2_rbuf_get_type())
G_DECLARE_FINAL_TYPE (GstWasapi2Rbuf, gst_wasapi2_rbuf,
GST, WASAPI2_RBUF, GstAudioRingBuffer);
GstWasapi2Rbuf * gst_wasapi2_rbuf_new (gpointer parent);
void gst_wasapi2_rbuf_set_device (GstWasapi2Rbuf * rbuf,
const gchar * device_id,
GstWasapi2EndpointClass endpoint_class,
guint pid,
gboolean low_latency);
GstCaps * gst_wasapi2_rbuf_get_caps (GstWasapi2Rbuf * rbuf);
void gst_wasapi2_rbuf_set_mute (GstWasapi2Rbuf * rbuf,
gboolean mute);
gboolean gst_wasapi2_rbuf_get_mute (GstWasapi2Rbuf * rbuf);
void gst_wasapi2_rbuf_set_volume (GstWasapi2Rbuf * rbuf,
gdouble volume);
gdouble gst_wasapi2_rbuf_get_volume (GstWasapi2Rbuf * rbuf);
void gst_wasapi2_rbuf_set_device_mute_monitoring (GstWasapi2Rbuf * rbuf,
gboolean value);
G_END_DECLS

1549
subprojects/gst-plugins-bad/sys/wasapi2/gstwasapi2ringbuffer.cpp
View File

File diff suppressed because it is too large Load Diff

59
subprojects/gst-plugins-bad/sys/wasapi2/gstwasapi2ringbuffer.h
View File

@ -1,59 +0,0 @@
/* GStreamer
* Copyright (C) 2021 Seungha Yang <seungha@centricular.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#ifndef __GST_WASAPI2_RING_BUFFER_H__
#define __GST_WASAPI2_RING_BUFFER_H__
#include <gst/gst.h>
#include <gst/audio/audio.h>
#include "gstwasapi2util.h"
G_BEGIN_DECLS
#define GST_TYPE_WASAPI2_RING_BUFFER (gst_wasapi2_ring_buffer_get_type())
G_DECLARE_FINAL_TYPE (GstWasapi2RingBuffer, gst_wasapi2_ring_buffer,
GST, WASAPI2_RING_BUFFER, GstAudioRingBuffer);
GstAudioRingBuffer * gst_wasapi2_ring_buffer_new (GstWasapi2EndpointClass device_class,
gboolean low_latency,
const gchar *device_id,
gpointer dispatcher,
const gchar * name,
guint loopback_target_pid);
GstCaps * gst_wasapi2_ring_buffer_get_caps (GstWasapi2RingBuffer * buf);
HRESULT gst_wasapi2_ring_buffer_set_mute (GstWasapi2RingBuffer * buf,
gboolean mute);
HRESULT gst_wasapi2_ring_buffer_get_mute (GstWasapi2RingBuffer * buf,
gboolean * mute);
HRESULT gst_wasapi2_ring_buffer_set_volume (GstWasapi2RingBuffer * buf,
gfloat volume);
HRESULT gst_wasapi2_ring_buffer_get_volume (GstWasapi2RingBuffer * buf,
gfloat * volume);
void gst_wasapi2_ring_buffer_set_device_mute_monitoring (GstWasapi2RingBuffer * buf,
gboolean value);
G_END_DECLS
#endif /* __GST_WASAPI2_RING_BUFFER_H__ */

460
subprojects/gst-plugins-bad/sys/wasapi2/gstwasapi2sink.c
View File

@ -1,460 +0,0 @@
/*
* Copyright (C) 2008 Ole André Vadla Ravnås <ole.andre.ravnas@tandberg.com>
* Copyright (C) 2013 Collabora Ltd.
* Author: Sebastian Dröge <sebastian.droege@collabora.co.uk>
* Copyright (C) 2018 Centricular Ltd.
* Author: Nirbheek Chauhan <nirbheek@centricular.com>
* Copyright (C) 2020 Seungha Yang <seungha@centricular.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
/**
* SECTION:element-wasapi2sink
* @title: wasapi2sink
*
* Provides audio playback using the Windows Audio Session API available with
* Windows 10.
*
* ## Example pipelines
* |[
* gst-launch-1.0 -v audiotestsrc ! wasapi2sink
* ]| Generate audio test buffers and render to the default audio device.
*
* |[
* gst-launch-1.0 -v audiotestsink samplesperbuffer=160 ! wasapi2sink low-latency=true
* ]| Same as above, but with the minimum possible latency
*
*/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "gstwasapi2sink.h"
#include "gstwasapi2util.h"
#include "gstwasapi2ringbuffer.h"
GST_DEBUG_CATEGORY_STATIC (gst_wasapi2_sink_debug);
#define GST_CAT_DEFAULT gst_wasapi2_sink_debug
static GstStaticPadTemplate sink_template = GST_STATIC_PAD_TEMPLATE ("sink",
GST_PAD_SINK,
GST_PAD_ALWAYS,
GST_STATIC_CAPS (GST_WASAPI2_STATIC_CAPS));
#define DEFAULT_LOW_LATENCY FALSE
#define DEFAULT_MUTE FALSE
#define DEFAULT_VOLUME 1.0
enum
{
PROP_0,
PROP_DEVICE,
PROP_LOW_LATENCY,
PROP_MUTE,
PROP_VOLUME,
PROP_DISPATCHER,
};
struct _GstWasapi2Sink
{
GstAudioBaseSink parent;
/* properties */
gchar *device_id;
gboolean low_latency;
gboolean mute;
gdouble volume;
gpointer dispatcher;
gboolean mute_changed;
gboolean volume_changed;
};
static void gst_wasapi2_sink_finalize (GObject * object);
static void gst_wasapi2_sink_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec);
static void gst_wasapi2_sink_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec);
static GstStateChangeReturn gst_wasapi2_sink_change_state (GstElement *
element, GstStateChange transition);
static GstCaps *gst_wasapi2_sink_get_caps (GstBaseSink * bsink,
GstCaps * filter);
static GstAudioRingBuffer *gst_wasapi2_sink_create_ringbuffer (GstAudioBaseSink
* sink);
static void gst_wasapi2_sink_set_mute (GstWasapi2Sink * self, gboolean mute);
static gboolean gst_wasapi2_sink_get_mute (GstWasapi2Sink * self);
static void gst_wasapi2_sink_set_volume (GstWasapi2Sink * self, gdouble volume);
static gdouble gst_wasapi2_sink_get_volume (GstWasapi2Sink * self);
#define gst_wasapi2_sink_parent_class parent_class
G_DEFINE_TYPE_WITH_CODE (GstWasapi2Sink, gst_wasapi2_sink,
GST_TYPE_AUDIO_BASE_SINK,
G_IMPLEMENT_INTERFACE (GST_TYPE_STREAM_VOLUME, NULL));
static void
gst_wasapi2_sink_class_init (GstWasapi2SinkClass * klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
GstElementClass *element_class = GST_ELEMENT_CLASS (klass);
GstBaseSinkClass *basesink_class = GST_BASE_SINK_CLASS (klass);
GstAudioBaseSinkClass *audiobasesink_class =
GST_AUDIO_BASE_SINK_CLASS (klass);
gobject_class->finalize = gst_wasapi2_sink_finalize;
gobject_class->set_property = gst_wasapi2_sink_set_property;
gobject_class->get_property = gst_wasapi2_sink_get_property;
g_object_class_install_property (gobject_class, PROP_DEVICE,
g_param_spec_string ("device", "Device",
"Audio device ID as provided by "
"WASAPI device endpoint ID as provided by IMMDevice::GetId",
NULL, GST_PARAM_MUTABLE_READY | G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class, PROP_LOW_LATENCY,
g_param_spec_boolean ("low-latency", "Low latency",
"Optimize all settings for lowest latency. Always safe to enable.",
DEFAULT_LOW_LATENCY, GST_PARAM_MUTABLE_READY | G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class, PROP_MUTE,
g_param_spec_boolean ("mute", "Mute", "Mute state of this stream",
DEFAULT_MUTE, GST_PARAM_MUTABLE_PLAYING | G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS));
g_object_class_install_property (gobject_class, PROP_VOLUME,
g_param_spec_double ("volume", "Volume", "Volume of this stream",
0.0, 1.0, DEFAULT_VOLUME,
GST_PARAM_MUTABLE_PLAYING | G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS));
/**
* GstWasapi2Sink:dispatcher:
*
* ICoreDispatcher COM object used for activating device from UI thread.
*
* Since: 1.18
*/
g_object_class_install_property (gobject_class, PROP_DISPATCHER,
g_param_spec_pointer ("dispatcher", "Dispatcher",
"ICoreDispatcher COM object to use. In order for application to ask "
"permission of audio device, device activation should be running "
"on UI thread via ICoreDispatcher. This element will increase "
"the reference count of given ICoreDispatcher and release it after "
"use. Therefore, caller does not need to consider additional "
"reference count management",
GST_PARAM_MUTABLE_READY | G_PARAM_WRITABLE | G_PARAM_STATIC_STRINGS));
gst_element_class_add_static_pad_template (element_class, &sink_template);
gst_element_class_set_static_metadata (element_class, "Wasapi2Sink",
"Sink/Audio/Hardware",
"Stream audio to an audio capture device through WASAPI",
"Nirbheek Chauhan <nirbheek@centricular.com>, "
"Ole André Vadla Ravnås <ole.andre.ravnas@tandberg.com>, "
"Seungha Yang <seungha@centricular.com>");
element_class->change_state =
GST_DEBUG_FUNCPTR (gst_wasapi2_sink_change_state);
basesink_class->get_caps = GST_DEBUG_FUNCPTR (gst_wasapi2_sink_get_caps);
audiobasesink_class->create_ringbuffer =
GST_DEBUG_FUNCPTR (gst_wasapi2_sink_create_ringbuffer);
GST_DEBUG_CATEGORY_INIT (gst_wasapi2_sink_debug, "wasapi2sink",
0, "Windows audio session API sink");
}
static void
gst_wasapi2_sink_init (GstWasapi2Sink * self)
{
self->low_latency = DEFAULT_LOW_LATENCY;
self->mute = DEFAULT_MUTE;
self->volume = DEFAULT_VOLUME;
}
static void
gst_wasapi2_sink_finalize (GObject * object)
{
GstWasapi2Sink *self = GST_WASAPI2_SINK (object);
g_free (self->device_id);
G_OBJECT_CLASS (parent_class)->finalize (object);
}
static void
gst_wasapi2_sink_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec)
{
GstWasapi2Sink *self = GST_WASAPI2_SINK (object);
switch (prop_id) {
case PROP_DEVICE:
g_free (self->device_id);
self->device_id = g_value_dup_string (value);
break;
case PROP_LOW_LATENCY:
self->low_latency = g_value_get_boolean (value);
break;
case PROP_MUTE:
gst_wasapi2_sink_set_mute (self, g_value_get_boolean (value));
break;
case PROP_VOLUME:
gst_wasapi2_sink_set_volume (self, g_value_get_double (value));
break;
case PROP_DISPATCHER:
self->dispatcher = g_value_get_pointer (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
gst_wasapi2_sink_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec)
{
GstWasapi2Sink *self = GST_WASAPI2_SINK (object);
switch (prop_id) {
case PROP_DEVICE:
g_value_set_string (value, self->device_id);
break;
case PROP_LOW_LATENCY:
g_value_set_boolean (value, self->low_latency);
break;
case PROP_MUTE:
g_value_set_boolean (value, gst_wasapi2_sink_get_mute (self));
break;
case PROP_VOLUME:
g_value_set_double (value, gst_wasapi2_sink_get_volume (self));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static GstStateChangeReturn
gst_wasapi2_sink_change_state (GstElement * element, GstStateChange transition)
{
GstWasapi2Sink *self = GST_WASAPI2_SINK (element);
GstAudioBaseSink *asink = GST_AUDIO_BASE_SINK_CAST (element);
switch (transition) {
case GST_STATE_CHANGE_READY_TO_PAUSED:
/* If we have pending volume/mute values to set, do here */
GST_OBJECT_LOCK (self);
if (asink->ringbuffer) {
GstWasapi2RingBuffer *ringbuffer =
GST_WASAPI2_RING_BUFFER (asink->ringbuffer);
if (self->volume_changed) {
gst_wasapi2_ring_buffer_set_volume (ringbuffer, self->volume);
self->volume_changed = FALSE;
}
if (self->mute_changed) {
gst_wasapi2_ring_buffer_set_mute (ringbuffer, self->mute);
self->mute_changed = FALSE;
}
}
GST_OBJECT_UNLOCK (self);
break;
default:
break;
}
return GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
}
static GstCaps *
gst_wasapi2_sink_get_caps (GstBaseSink * bsink, GstCaps * filter)
{
GstAudioBaseSink *asink = GST_AUDIO_BASE_SINK_CAST (bsink);
GstCaps *caps = NULL;
GST_OBJECT_LOCK (bsink);
if (asink->ringbuffer) {
GstWasapi2RingBuffer *ringbuffer =
GST_WASAPI2_RING_BUFFER (asink->ringbuffer);
gst_object_ref (ringbuffer);
GST_OBJECT_UNLOCK (bsink);
/* Get caps might be able to block if device is not activated yet */
caps = gst_wasapi2_ring_buffer_get_caps (ringbuffer);
gst_object_unref (ringbuffer);
} else {
GST_OBJECT_UNLOCK (bsink);
}
if (!caps)
caps = gst_pad_get_pad_template_caps (bsink->sinkpad);
if (filter) {
GstCaps *filtered =
gst_caps_intersect_full (filter, caps, GST_CAPS_INTERSECT_FIRST);
gst_caps_unref (caps);
caps = filtered;
}
GST_DEBUG_OBJECT (bsink, "returning caps %" GST_PTR_FORMAT, caps);
return caps;
}
static GstAudioRingBuffer *
gst_wasapi2_sink_create_ringbuffer (GstAudioBaseSink * sink)
{
GstWasapi2Sink *self = GST_WASAPI2_SINK (sink);
GstAudioRingBuffer *ringbuffer;
gchar *name;
name = g_strdup_printf ("%s-ringbuffer", GST_OBJECT_NAME (sink));
ringbuffer =
gst_wasapi2_ring_buffer_new (GST_WASAPI2_ENDPOINT_CLASS_RENDER,
self->low_latency, self->device_id, self->dispatcher, name, 0);
g_free (name);
return ringbuffer;
}
static void
gst_wasapi2_sink_set_mute (GstWasapi2Sink * self, gboolean mute)
{
GstAudioBaseSink *bsink = GST_AUDIO_BASE_SINK_CAST (self);
HRESULT hr;
GST_OBJECT_LOCK (self);
self->mute = mute;
self->mute_changed = TRUE;
if (bsink->ringbuffer) {
GstWasapi2RingBuffer *ringbuffer =
GST_WASAPI2_RING_BUFFER (bsink->ringbuffer);
hr = gst_wasapi2_ring_buffer_set_mute (ringbuffer, mute);
if (FAILED (hr)) {
GST_INFO_OBJECT (self, "Couldn't set mute");
} else {
self->mute_changed = FALSE;
}
}
GST_OBJECT_UNLOCK (self);
}
static gboolean
gst_wasapi2_sink_get_mute (GstWasapi2Sink * self)
{
GstAudioBaseSink *bsink = GST_AUDIO_BASE_SINK_CAST (self);
gboolean mute;
HRESULT hr;
GST_OBJECT_LOCK (self);
mute = self->mute;
if (bsink->ringbuffer) {
GstWasapi2RingBuffer *ringbuffer =
GST_WASAPI2_RING_BUFFER (bsink->ringbuffer);
hr = gst_wasapi2_ring_buffer_get_mute (ringbuffer, &mute);
if (FAILED (hr)) {
GST_INFO_OBJECT (self, "Couldn't get mute");
} else {
self->mute = mute;
}
}
GST_OBJECT_UNLOCK (self);
return mute;
}
static void
gst_wasapi2_sink_set_volume (GstWasapi2Sink * self, gdouble volume)
{
GstAudioBaseSink *bsink = GST_AUDIO_BASE_SINK_CAST (self);
HRESULT hr;
GST_OBJECT_LOCK (self);
self->volume = volume;
/* clip volume value */
self->volume = MAX (0.0, self->volume);
self->volume = MIN (1.0, self->volume);
self->volume_changed = TRUE;
if (bsink->ringbuffer) {
GstWasapi2RingBuffer *ringbuffer =
GST_WASAPI2_RING_BUFFER (bsink->ringbuffer);
hr = gst_wasapi2_ring_buffer_set_volume (ringbuffer, (gfloat) self->volume);
if (FAILED (hr)) {
GST_INFO_OBJECT (self, "Couldn't set volume");
} else {
self->volume_changed = FALSE;
}
}
GST_OBJECT_UNLOCK (self);
}
static gdouble
gst_wasapi2_sink_get_volume (GstWasapi2Sink * self)
{
GstAudioBaseSink *bsink = GST_AUDIO_BASE_SINK_CAST (self);
gfloat volume;
HRESULT hr;
GST_OBJECT_LOCK (self);
volume = (gfloat) self->volume;
if (bsink->ringbuffer) {
GstWasapi2RingBuffer *ringbuffer =
GST_WASAPI2_RING_BUFFER (bsink->ringbuffer);
hr = gst_wasapi2_ring_buffer_get_volume (ringbuffer, &volume);
if (FAILED (hr)) {
GST_INFO_OBJECT (self, "Couldn't set volume");
} else {
self->volume = volume;
}
}
GST_OBJECT_UNLOCK (self);
volume = MAX (0.0, volume);
volume = MIN (1.0, volume);
return volume;
}

311
subprojects/gst-plugins-bad/sys/wasapi2/gstwasapi2sink.cpp Normal file
View File

@ -0,0 +1,311 @@
/*
* Copyright (C) 2008 Ole André Vadla Ravnås <ole.andre.ravnas@tandberg.com>
* Copyright (C) 2013 Collabora Ltd.
* Author: Sebastian Dröge <sebastian.droege@collabora.co.uk>
* Copyright (C) 2018 Centricular Ltd.
* Author: Nirbheek Chauhan <nirbheek@centricular.com>
* Copyright (C) 2020 Seungha Yang <seungha@centricular.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
/**
* SECTION:element-wasapi2sink
* @title: wasapi2sink
*
* Provides audio playback using the Windows Audio Session API available with
* Windows 10.
*
* ## Example pipelines
* |[
* gst-launch-1.0 -v audiotestsrc ! wasapi2sink
* ]| Generate audio test buffers and render to the default audio device.
*
* |[
* gst-launch-1.0 -v audiotestsink samplesperbuffer=160 ! wasapi2sink low-latency=true
* ]| Same as above, but with the minimum possible latency
*
*/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "gstwasapi2sink.h"
#include "gstwasapi2util.h"
#include "gstwasapi2rbuf.h"
#include <mutex>
GST_DEBUG_CATEGORY_STATIC (gst_wasapi2_sink_debug);
#define GST_CAT_DEFAULT gst_wasapi2_sink_debug
static GstStaticPadTemplate sink_template = GST_STATIC_PAD_TEMPLATE ("sink",
GST_PAD_SINK,
GST_PAD_ALWAYS,
GST_STATIC_CAPS (GST_WASAPI2_STATIC_CAPS));
#define DEFAULT_LOW_LATENCY FALSE
#define DEFAULT_MUTE FALSE
#define DEFAULT_VOLUME 1.0
enum
{
PROP_0,
PROP_DEVICE,
PROP_LOW_LATENCY,
PROP_MUTE,
PROP_VOLUME,
PROP_DISPATCHER,
};
/* *INDENT-OFF* */
struct GstWasapi2SinkPrivate
{
~GstWasapi2SinkPrivate ()
{
gst_object_unref (rbuf);
g_free (device_id);
}
GstWasapi2Rbuf *rbuf = nullptr;
std::mutex lock;
/* properties */
gchar *device_id = nullptr;;
gboolean low_latency = DEFAULT_LOW_LATENCY;
};
/* *INDENT-ON* */
struct _GstWasapi2Sink
{
GstAudioBaseSink parent;
GstWasapi2SinkPrivate *priv;
};
static void gst_wasapi2_sink_finalize (GObject * object);
static void gst_wasapi2_sink_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec);
static void gst_wasapi2_sink_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec);
static GstCaps *gst_wasapi2_sink_get_caps (GstBaseSink * bsink,
GstCaps * filter);
static GstAudioRingBuffer *gst_wasapi2_sink_create_ringbuffer (GstAudioBaseSink
* sink);
#define gst_wasapi2_sink_parent_class parent_class
G_DEFINE_TYPE_WITH_CODE (GstWasapi2Sink, gst_wasapi2_sink,
GST_TYPE_AUDIO_BASE_SINK,
G_IMPLEMENT_INTERFACE (GST_TYPE_STREAM_VOLUME, nullptr));
static void
gst_wasapi2_sink_class_init (GstWasapi2SinkClass * klass)
{
auto gobject_class = G_OBJECT_CLASS (klass);
auto element_class = GST_ELEMENT_CLASS (klass);
auto basesink_class = GST_BASE_SINK_CLASS (klass);
auto audiobasesink_class = GST_AUDIO_BASE_SINK_CLASS (klass);
gobject_class->finalize = gst_wasapi2_sink_finalize;
gobject_class->set_property = gst_wasapi2_sink_set_property;
gobject_class->get_property = gst_wasapi2_sink_get_property;
g_object_class_install_property (gobject_class, PROP_DEVICE,
g_param_spec_string ("device", "Device",
"Audio device ID as provided by "
"WASAPI device endpoint ID as provided by IMMDevice::GetId",
nullptr, (GParamFlags) (GST_PARAM_MUTABLE_READY | G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS)));
g_object_class_install_property (gobject_class, PROP_LOW_LATENCY,
g_param_spec_boolean ("low-latency", "Low latency",
"Optimize all settings for lowest latency. Always safe to enable.",
DEFAULT_LOW_LATENCY, (GParamFlags) (GST_PARAM_MUTABLE_READY |
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
g_object_class_install_property (gobject_class, PROP_MUTE,
g_param_spec_boolean ("mute", "Mute", "Mute state of this stream",
DEFAULT_MUTE, (GParamFlags) (GST_PARAM_MUTABLE_PLAYING |
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
g_object_class_install_property (gobject_class, PROP_VOLUME,
g_param_spec_double ("volume", "Volume", "Volume of this stream",
0.0, 1.0, DEFAULT_VOLUME,
(GParamFlags) (GST_PARAM_MUTABLE_PLAYING | G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS)));
/**
* GstWasapi2Sink:dispatcher:
*
* ICoreDispatcher COM object used for activating device from UI thread.
*
* Since: 1.18
*/
g_object_class_install_property (gobject_class, PROP_DISPATCHER,
g_param_spec_pointer ("dispatcher", "Dispatcher",
"ICoreDispatcher COM object to use. In order for application to ask "
"permission of audio device, device activation should be running "
"on UI thread via ICoreDispatcher. This element will increase "
"the reference count of given ICoreDispatcher and release it after "
"use. Therefore, caller does not need to consider additional "
"reference count management",
(GParamFlags) (GST_PARAM_MUTABLE_READY | G_PARAM_WRITABLE |
G_PARAM_STATIC_STRINGS)));
gst_element_class_add_static_pad_template (element_class, &sink_template);
gst_element_class_set_static_metadata (element_class, "Wasapi2Sink",
"Sink/Audio/Hardware",
"Stream audio to an audio capture device through WASAPI",
"Seungha Yang <seungha@centricular.com>");
basesink_class->get_caps = GST_DEBUG_FUNCPTR (gst_wasapi2_sink_get_caps);
audiobasesink_class->create_ringbuffer =
GST_DEBUG_FUNCPTR (gst_wasapi2_sink_create_ringbuffer);
GST_DEBUG_CATEGORY_INIT (gst_wasapi2_sink_debug, "wasapi2sink",
0, "Windows audio session API sink");
}
static void
gst_wasapi2_sink_init (GstWasapi2Sink * self)
{
auto priv = new GstWasapi2SinkPrivate ();
priv->rbuf = gst_wasapi2_rbuf_new (self);
gst_wasapi2_rbuf_set_device (priv->rbuf, nullptr,
GST_WASAPI2_ENDPOINT_CLASS_RENDER, 0, DEFAULT_LOW_LATENCY);
self->priv = priv;
}
static void
gst_wasapi2_sink_finalize (GObject * object)
{
auto self = GST_WASAPI2_SINK (object);
GST_LOG_OBJECT (self, "Finalize");
delete self->priv;
G_OBJECT_CLASS (parent_class)->finalize (object);
}
static void
gst_wasapi2_sink_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec)
{
auto self = GST_WASAPI2_SINK (object);
auto priv = self->priv;
std::lock_guard < std::mutex > lk (priv->lock);
switch (prop_id) {
case PROP_DEVICE:
{
auto new_val = g_value_get_string (value);
if (g_strcmp0 (new_val, priv->device_id) != 0) {
g_free (priv->device_id);
priv->device_id = g_strdup (new_val);
gst_wasapi2_rbuf_set_device (priv->rbuf, priv->device_id,
GST_WASAPI2_ENDPOINT_CLASS_RENDER, 0, priv->low_latency);
}
break;
}
case PROP_LOW_LATENCY:
{
auto new_val = g_value_get_boolean (value);
if (new_val != priv->low_latency) {
priv->low_latency = new_val;
gst_wasapi2_rbuf_set_device (priv->rbuf, priv->device_id,
GST_WASAPI2_ENDPOINT_CLASS_RENDER, 0, priv->low_latency);
}
break;
}
case PROP_MUTE:
gst_wasapi2_rbuf_set_mute (priv->rbuf, g_value_get_boolean (value));
break;
case PROP_VOLUME:
gst_wasapi2_rbuf_set_volume (priv->rbuf, g_value_get_double (value));
break;
case PROP_DISPATCHER:
/* Unused */
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
gst_wasapi2_sink_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec)
{
auto self = GST_WASAPI2_SINK (object);
auto priv = self->priv;
std::lock_guard < std::mutex > lk (priv->lock);
switch (prop_id) {
case PROP_DEVICE:
g_value_set_string (value, priv->device_id);
break;
case PROP_LOW_LATENCY:
g_value_set_boolean (value, priv->low_latency);
break;
case PROP_MUTE:
g_value_set_boolean (value, gst_wasapi2_rbuf_get_mute (priv->rbuf));
break;
case PROP_VOLUME:
g_value_set_double (value, gst_wasapi2_rbuf_get_volume (priv->rbuf));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static GstCaps *
gst_wasapi2_sink_get_caps (GstBaseSink * bsink, GstCaps * filter)
{
auto self = GST_WASAPI2_SINK (bsink);
auto priv = self->priv;
auto caps = gst_wasapi2_rbuf_get_caps (priv->rbuf);
if (!caps)
caps = gst_pad_get_pad_template_caps (bsink->sinkpad);
if (filter) {
GstCaps *filtered =
gst_caps_intersect_full (filter, caps, GST_CAPS_INTERSECT_FIRST);
gst_caps_unref (caps);
caps = filtered;
}
GST_DEBUG_OBJECT (self, "returning caps %" GST_PTR_FORMAT, caps);
return caps;
}
static GstAudioRingBuffer *
gst_wasapi2_sink_create_ringbuffer (GstAudioBaseSink * sink)
{
auto self = GST_WASAPI2_SINK (sink);
auto priv = self->priv;
return GST_AUDIO_RING_BUFFER (priv->rbuf);
}

464
subprojects/gst-plugins-bad/sys/wasapi2/gstwasapi2src.c → subprojects/gst-plugins-bad/sys/wasapi2/gstwasapi2src.cpp
View File

@ -43,7 +43,8 @@
#include "gstwasapi2src.h"
#include "gstwasapi2util.h"
#include "gstwasapi2ringbuffer.h"
#include "gstwasapi2rbuf.h"
#include <mutex>
GST_DEBUG_CATEGORY_STATIC (gst_wasapi2_src_debug);
#define GST_CAT_DEFAULT gst_wasapi2_src_debug
@ -103,13 +104,12 @@ gst_wasapi2_src_loopback_mode_get_type (void)
{GST_WASAPI2_SRC_LOOPBACK_EXCLUDE_PROCESS_TREE,
"Exclude process and its child processes",
"exclude-process-tree"},
{0, NULL, NULL}
{0, nullptr, nullptr}
};
if (g_once_init_enter (&loopback_type)) {
GType gtype = g_enum_register_static ("GstWasapi2SrcLoopbackMode", types);
g_once_init_leave (&loopback_type, gtype);
}
GST_WASAPI2_CALL_ONCE_BEGIN {
loopback_type = g_enum_register_static ("GstWasapi2SrcLoopbackMode", types);
} GST_WASAPI2_CALL_ONCE_END;
return loopback_type;
}
@ -135,23 +135,35 @@ enum
PROP_LOOPBACK_SILENCE_ON_DEVICE_MUTE,
};
/* *INDENT-OFF* */
struct GstWasapi2SrcPrivate
{
~GstWasapi2SrcPrivate ()
{
gst_object_unref (rbuf);
g_free (device_id);
}
GstWasapi2Rbuf *rbuf = nullptr;
std::mutex lock;
/* properties */
gchar *device_id = nullptr;
gboolean low_latency = DEFAULT_LOW_LATENCY;
gboolean loopback = DEFAULT_LOOPBACK;
GstWasapi2SrcLoopbackMode loopback_mode = DEFAULT_LOOPBACK_MODE;
guint loopback_pid = 0;
gboolean loopback_silence_on_device_mute =
DEFAULT_LOOPBACK_SILENCE_ON_DEVICE_MUTE;
};
/* *INDENT-ON* */
struct _GstWasapi2Src
{
GstAudioBaseSrc parent;
/* properties */
gchar *device_id;
gboolean low_latency;
gboolean mute;
gdouble volume;
gpointer dispatcher;
gboolean loopback;
GstWasapi2SrcLoopbackMode loopback_mode;
guint loopback_pid;
gboolean loopback_silence_on_device_mute;
gboolean mute_changed;
gboolean volume_changed;
GstWasapi2SrcPrivate *priv;
};
static void gst_wasapi2_src_finalize (GObject * object);
@ -160,32 +172,22 @@ static void gst_wasapi2_src_set_property (GObject * object, guint prop_id,
static void gst_wasapi2_src_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec);
static GstStateChangeReturn gst_wasapi2_src_change_state (GstElement *
element, GstStateChange transition);
static GstCaps *gst_wasapi2_src_get_caps (GstBaseSrc * bsrc, GstCaps * filter);
static GstAudioRingBuffer *gst_wasapi2_src_create_ringbuffer (GstAudioBaseSrc *
src);
static void gst_wasapi2_src_set_mute (GstWasapi2Src * self, gboolean mute);
static gboolean gst_wasapi2_src_get_mute (GstWasapi2Src * self);
static void gst_wasapi2_src_set_volume (GstWasapi2Src * self, gdouble volume);
static gdouble gst_wasapi2_src_get_volume (GstWasapi2Src * self);
static void gst_wasapi2_src_set_silence_on_mute (GstWasapi2Src * self,
gboolean value);
#define gst_wasapi2_src_parent_class parent_class
G_DEFINE_TYPE_WITH_CODE (GstWasapi2Src, gst_wasapi2_src,
GST_TYPE_AUDIO_BASE_SRC,
G_IMPLEMENT_INTERFACE (GST_TYPE_STREAM_VOLUME, NULL));
G_IMPLEMENT_INTERFACE (GST_TYPE_STREAM_VOLUME, nullptr));
static void
gst_wasapi2_src_class_init (GstWasapi2SrcClass * klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
GstElementClass *element_class = GST_ELEMENT_CLASS (klass);
GstBaseSrcClass *basesrc_class = GST_BASE_SRC_CLASS (klass);
GstAudioBaseSrcClass *audiobasesrc_class = GST_AUDIO_BASE_SRC_CLASS (klass);
auto gobject_class = G_OBJECT_CLASS (klass);
auto element_class = GST_ELEMENT_CLASS (klass);
auto basesrc_class = GST_BASE_SRC_CLASS (klass);
auto audiobasesrc_class = GST_AUDIO_BASE_SRC_CLASS (klass);
gobject_class->finalize = gst_wasapi2_src_finalize;
gobject_class->set_property = gst_wasapi2_src_set_property;
@ -195,25 +197,24 @@ gst_wasapi2_src_class_init (GstWasapi2SrcClass * klass)
g_param_spec_string ("device", "Device",
"Audio device ID as provided by "
"WASAPI device endpoint ID as provided by IMMDevice::GetId",
NULL, GST_PARAM_MUTABLE_READY | G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS));
nullptr, (GParamFlags) (GST_PARAM_MUTABLE_PLAYING |
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
g_object_class_install_property (gobject_class, PROP_LOW_LATENCY,
g_param_spec_boolean ("low-latency", "Low latency",
"Optimize all settings for lowest latency. Always safe to enable.",
DEFAULT_LOW_LATENCY, GST_PARAM_MUTABLE_READY | G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS));
DEFAULT_LOW_LATENCY, (GParamFlags) (GST_PARAM_MUTABLE_READY |
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
g_object_class_install_property (gobject_class, PROP_MUTE,
g_param_spec_boolean ("mute", "Mute", "Mute state of this stream",
DEFAULT_MUTE, GST_PARAM_MUTABLE_PLAYING | G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS));
DEFAULT_MUTE, (GParamFlags) (GST_PARAM_MUTABLE_PLAYING |
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
g_object_class_install_property (gobject_class, PROP_VOLUME,
g_param_spec_double ("volume", "Volume", "Volume of this stream",
0.0, 1.0, DEFAULT_VOLUME,
GST_PARAM_MUTABLE_PLAYING | G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS));
0.0, 1.0, DEFAULT_VOLUME, (GParamFlags) (GST_PARAM_MUTABLE_PLAYING |
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
/**
* GstWasapi2Src:dispatcher:
@ -230,7 +231,8 @@ gst_wasapi2_src_class_init (GstWasapi2SrcClass * klass)
"the reference count of given ICoreDispatcher and release it after "
"use. Therefore, caller does not need to consider additional "
"reference count management",
GST_PARAM_MUTABLE_READY | G_PARAM_WRITABLE | G_PARAM_STATIC_STRINGS));
(GParamFlags) (GST_PARAM_MUTABLE_READY | G_PARAM_WRITABLE |
G_PARAM_STATIC_STRINGS)));
/**
* GstWasapi2Src:loopback:
@ -242,8 +244,8 @@ gst_wasapi2_src_class_init (GstWasapi2SrcClass * klass)
g_object_class_install_property (gobject_class, PROP_LOOPBACK,
g_param_spec_boolean ("loopback", "Loopback recording",
"Open render device for loopback recording", DEFAULT_LOOPBACK,
GST_PARAM_MUTABLE_READY | G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS));
(GParamFlags) (GST_PARAM_MUTABLE_READY | G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS)));
if (gst_wasapi2_can_process_loopback ()) {
/**
@ -260,8 +262,9 @@ gst_wasapi2_src_class_init (GstWasapi2SrcClass * klass)
g_param_spec_enum ("loopback-mode", "Loopback Mode",
"Loopback mode to use", GST_TYPE_WASAPI2_SRC_LOOPBACK_MODE,
DEFAULT_LOOPBACK_MODE,
GST_PARAM_CONDITIONALLY_AVAILABLE | GST_PARAM_MUTABLE_READY |
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
(GParamFlags) (GST_PARAM_CONDITIONALLY_AVAILABLE |
GST_PARAM_MUTABLE_READY | G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS)));
/**
* GstWasapi2Src:loopback-target-pid:
@ -276,8 +279,9 @@ gst_wasapi2_src_class_init (GstWasapi2SrcClass * klass)
g_param_spec_uint ("loopback-target-pid", "Loopback Target PID",
"Process ID to be recorded or excluded for process loopback mode",
0, G_MAXUINT32, 0,
GST_PARAM_CONDITIONALLY_AVAILABLE | GST_PARAM_MUTABLE_READY |
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
(GParamFlags) (GST_PARAM_CONDITIONALLY_AVAILABLE |
GST_PARAM_MUTABLE_READY | G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS)));
}
/**
@ -293,20 +297,15 @@ gst_wasapi2_src_class_init (GstWasapi2SrcClass * klass)
"Loopback Silence On Device Mute",
"When loopback recording, if the device is muted, inject silence in the pipeline",
DEFAULT_LOOPBACK_SILENCE_ON_DEVICE_MUTE,
GST_PARAM_MUTABLE_PLAYING | G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS));
(GParamFlags) (GST_PARAM_MUTABLE_PLAYING | G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS)));
gst_element_class_add_static_pad_template (element_class, &src_template);
gst_element_class_set_static_metadata (element_class, "Wasapi2Src",
"Source/Audio/Hardware",
"Stream audio from an audio capture device through WASAPI",
"Nirbheek Chauhan <nirbheek@centricular.com>, "
"Ole André Vadla Ravnås <ole.andre.ravnas@tandberg.com>, "
"Seungha Yang <seungha@centricular.com>");
element_class->change_state =
GST_DEBUG_FUNCPTR (gst_wasapi2_src_change_state);
basesrc_class->get_caps = GST_DEBUG_FUNCPTR (gst_wasapi2_src_get_caps);
audiobasesrc_class->create_ringbuffer =
@ -315,65 +314,126 @@ gst_wasapi2_src_class_init (GstWasapi2SrcClass * klass)
GST_DEBUG_CATEGORY_INIT (gst_wasapi2_src_debug, "wasapi2src",
0, "Windows audio session API source");
if (gst_wasapi2_can_process_loopback ())
gst_type_mark_as_plugin_api (GST_TYPE_WASAPI2_SRC_LOOPBACK_MODE, 0);
if (gst_wasapi2_can_process_loopback ()) {
gst_type_mark_as_plugin_api (GST_TYPE_WASAPI2_SRC_LOOPBACK_MODE,
(GstPluginAPIFlags) 0);
}
}
static void
gst_wasapi2_src_init (GstWasapi2Src * self)
{
self->mute = DEFAULT_MUTE;
self->volume = DEFAULT_VOLUME;
self->low_latency = DEFAULT_LOW_LATENCY;
self->loopback = DEFAULT_LOOPBACK;
self->loopback_silence_on_device_mute =
DEFAULT_LOOPBACK_SILENCE_ON_DEVICE_MUTE;
auto priv = new GstWasapi2SrcPrivate ();
priv->rbuf = gst_wasapi2_rbuf_new (self);
gst_wasapi2_rbuf_set_device (priv->rbuf, nullptr,
GST_WASAPI2_ENDPOINT_CLASS_CAPTURE, 0, DEFAULT_LOW_LATENCY);
self->priv = priv;
}
static void
gst_wasapi2_src_finalize (GObject * object)
{
GstWasapi2Src *self = GST_WASAPI2_SRC (object);
auto self = GST_WASAPI2_SRC (object);
g_free (self->device_id);
delete self->priv;
G_OBJECT_CLASS (parent_class)->finalize (object);
}
static void
gst_wasapi2_src_set_device (GstWasapi2Src * self)
{
auto priv = self->priv;
GstWasapi2EndpointClass device_class = GST_WASAPI2_ENDPOINT_CLASS_CAPTURE;
if (priv->loopback_pid) {
if (priv->loopback_mode == GST_WASAPI2_SRC_LOOPBACK_INCLUDE_PROCESS_TREE) {
device_class =
GST_WASAPI2_ENDPOINT_CLASS_INCLUDE_PROCESS_LOOPBACK_CAPTURE;
} else if (priv->loopback_mode ==
GST_WASAPI2_SRC_LOOPBACK_EXCLUDE_PROCESS_TREE) {
device_class =
GST_WASAPI2_ENDPOINT_CLASS_EXCLUDE_PROCESS_LOOPBACK_CAPTURE;
}
} else if (priv->loopback) {
device_class = GST_WASAPI2_ENDPOINT_CLASS_LOOPBACK_CAPTURE;
}
gst_wasapi2_rbuf_set_device (priv->rbuf, priv->device_id, device_class,
priv->loopback_pid, priv->low_latency);
}
static void
gst_wasapi2_src_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec)
{
GstWasapi2Src *self = GST_WASAPI2_SRC (object);
auto self = GST_WASAPI2_SRC (object);
auto priv = self->priv;
std::lock_guard < std::mutex > lk (priv->lock);
switch (prop_id) {
case PROP_DEVICE:
g_free (self->device_id);
self->device_id = g_value_dup_string (value);
{
auto new_val = g_value_get_string (value);
if (g_strcmp0 (new_val, priv->device_id) != 0) {
g_free (priv->device_id);
priv->device_id = g_strdup (new_val);
gst_wasapi2_src_set_device (self);
}
break;
}
case PROP_LOW_LATENCY:
self->low_latency = g_value_get_boolean (value);
{
auto new_val = g_value_get_boolean (value);
if (new_val != priv->low_latency) {
priv->low_latency = new_val;
gst_wasapi2_src_set_device (self);
}
break;
}
case PROP_MUTE:
gst_wasapi2_src_set_mute (self, g_value_get_boolean (value));
gst_wasapi2_rbuf_set_mute (priv->rbuf, g_value_get_boolean (value));
break;
case PROP_VOLUME:
gst_wasapi2_src_set_volume (self, g_value_get_double (value));
gst_wasapi2_rbuf_set_volume (priv->rbuf, g_value_get_double (value));
break;
case PROP_DISPATCHER:
self->dispatcher = g_value_get_pointer (value);
/* Unused */
break;
case PROP_LOOPBACK:
self->loopback = g_value_get_boolean (value);
{
auto new_val = g_value_get_boolean (value);
if (new_val != priv->loopback) {
priv->loopback = new_val;
gst_wasapi2_src_set_device (self);
}
break;
}
case PROP_LOOPBACK_MODE:
self->loopback_mode = g_value_get_enum (value);
{
auto new_val = (GstWasapi2SrcLoopbackMode) g_value_get_enum (value);
if (new_val != priv->loopback_mode) {
priv->loopback_mode = new_val;
gst_wasapi2_src_set_device (self);
}
break;
}
case PROP_LOOPBACK_TARGET_PID:
self->loopback_pid = g_value_get_uint (value);
{
auto new_val = g_value_get_uint (value);
if (new_val != priv->loopback_pid) {
priv->loopback_pid = new_val;
gst_wasapi2_src_set_device (self);
}
break;
}
case PROP_LOOPBACK_SILENCE_ON_DEVICE_MUTE:
gst_wasapi2_src_set_silence_on_mute (self, g_value_get_boolean (value));
priv->loopback_silence_on_device_mute = g_value_get_boolean (value);
gst_wasapi2_rbuf_set_device_mute_monitoring (priv->rbuf,
priv->loopback_silence_on_device_mute);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
@ -385,32 +445,35 @@ static void
gst_wasapi2_src_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec)
{
GstWasapi2Src *self = GST_WASAPI2_SRC (object);
auto self = GST_WASAPI2_SRC (object);
auto priv = self->priv;
std::lock_guard < std::mutex > lk (priv->lock);
switch (prop_id) {
case PROP_DEVICE:
g_value_set_string (value, self->device_id);
g_value_set_string (value, priv->device_id);
break;
case PROP_LOW_LATENCY:
g_value_set_boolean (value, self->low_latency);
g_value_set_boolean (value, priv->low_latency);
break;
case PROP_MUTE:
g_value_set_boolean (value, gst_wasapi2_src_get_mute (self));
g_value_set_boolean (value, gst_wasapi2_rbuf_get_mute (priv->rbuf));
break;
case PROP_VOLUME:
g_value_set_double (value, gst_wasapi2_src_get_volume (self));
g_value_set_double (value, gst_wasapi2_rbuf_get_volume (priv->rbuf));
break;
case PROP_LOOPBACK:
g_value_set_boolean (value, self->loopback);
g_value_set_boolean (value, priv->loopback);
break;
case PROP_LOOPBACK_MODE:
g_value_set_enum (value, self->loopback_mode);
g_value_set_enum (value, priv->loopback_mode);
break;
case PROP_LOOPBACK_TARGET_PID:
g_value_set_uint (value, self->loopback_pid);
g_value_set_uint (value, priv->loopback_pid);
break;
case PROP_LOOPBACK_SILENCE_ON_DEVICE_MUTE:
g_value_set_boolean (value, self->loopback_silence_on_device_mute);
g_value_set_boolean (value, priv->loopback_silence_on_device_mute);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
@ -418,59 +481,12 @@ gst_wasapi2_src_get_property (GObject * object, guint prop_id,
}
}
static GstStateChangeReturn
gst_wasapi2_src_change_state (GstElement * element, GstStateChange transition)
{
GstWasapi2Src *self = GST_WASAPI2_SRC (element);
GstAudioBaseSrc *asrc = GST_AUDIO_BASE_SRC_CAST (element);
switch (transition) {
case GST_STATE_CHANGE_READY_TO_PAUSED:
/* If we have pending volume/mute values to set, do here */
GST_OBJECT_LOCK (self);
if (asrc->ringbuffer) {
GstWasapi2RingBuffer *ringbuffer =
GST_WASAPI2_RING_BUFFER (asrc->ringbuffer);
if (self->volume_changed) {
gst_wasapi2_ring_buffer_set_volume (ringbuffer, self->volume);
self->volume_changed = FALSE;
}
if (self->mute_changed) {
gst_wasapi2_ring_buffer_set_mute (ringbuffer, self->mute);
self->mute_changed = FALSE;
}
}
GST_OBJECT_UNLOCK (self);
break;
default:
break;
}
return GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
}
static GstCaps *
gst_wasapi2_src_get_caps (GstBaseSrc * bsrc, GstCaps * filter)
{
GstAudioBaseSrc *asrc = GST_AUDIO_BASE_SRC_CAST (bsrc);
GstCaps *caps = NULL;
GST_OBJECT_LOCK (bsrc);
if (asrc->ringbuffer) {
GstWasapi2RingBuffer *ringbuffer =
GST_WASAPI2_RING_BUFFER (asrc->ringbuffer);
gst_object_ref (ringbuffer);
GST_OBJECT_UNLOCK (bsrc);
/* Get caps might be able to block if device is not activated yet */
caps = gst_wasapi2_ring_buffer_get_caps (ringbuffer);
gst_object_unref (ringbuffer);
} else {
GST_OBJECT_UNLOCK (bsrc);
}
auto self = GST_WASAPI2_SRC (bsrc);
auto priv = self->priv;
auto caps = gst_wasapi2_rbuf_get_caps (priv->rbuf);
if (!caps)
caps = gst_pad_get_pad_template_caps (bsrc->srcpad);
@ -482,7 +498,7 @@ gst_wasapi2_src_get_caps (GstBaseSrc * bsrc, GstCaps * filter)
caps = filtered;
}
GST_DEBUG_OBJECT (bsrc, "returning caps %" GST_PTR_FORMAT, caps);
GST_DEBUG_OBJECT (self, "returning caps %" GST_PTR_FORMAT, caps);
return caps;
}
@ -490,174 +506,8 @@ gst_wasapi2_src_get_caps (GstBaseSrc * bsrc, GstCaps * filter)
static GstAudioRingBuffer *
gst_wasapi2_src_create_ringbuffer (GstAudioBaseSrc * src)
{
GstWasapi2Src *self = GST_WASAPI2_SRC (src);
GstAudioRingBuffer *ringbuffer;
gchar *name;
GstWasapi2EndpointClass device_class = GST_WASAPI2_ENDPOINT_CLASS_CAPTURE;
auto self = GST_WASAPI2_SRC (src);
auto priv = self->priv;
if (self->loopback_pid) {
if (self->loopback_mode == GST_WASAPI2_SRC_LOOPBACK_INCLUDE_PROCESS_TREE) {
device_class =
GST_WASAPI2_ENDPOINT_CLASS_INCLUDE_PROCESS_LOOPBACK_CAPTURE;
} else if (self->loopback_mode ==
GST_WASAPI2_SRC_LOOPBACK_EXCLUDE_PROCESS_TREE) {
device_class =
GST_WASAPI2_ENDPOINT_CLASS_EXCLUDE_PROCESS_LOOPBACK_CAPTURE;
}
} else if (self->loopback) {
device_class = GST_WASAPI2_ENDPOINT_CLASS_LOOPBACK_CAPTURE;
}
GST_DEBUG_OBJECT (self, "Device class %d", device_class);
name = g_strdup_printf ("%s-ringbuffer", GST_OBJECT_NAME (src));
ringbuffer =
gst_wasapi2_ring_buffer_new (device_class,
self->low_latency, self->device_id, self->dispatcher, name,
self->loopback_pid);
g_free (name);
if (self->loopback) {
gst_wasapi2_ring_buffer_set_device_mute_monitoring (GST_WASAPI2_RING_BUFFER
(ringbuffer), self->loopback_silence_on_device_mute);
}
return ringbuffer;
}
static void
gst_wasapi2_src_set_mute (GstWasapi2Src * self, gboolean mute)
{
GstAudioBaseSrc *bsrc = GST_AUDIO_BASE_SRC_CAST (self);
HRESULT hr;
GST_OBJECT_LOCK (self);
self->mute = mute;
self->mute_changed = TRUE;
if (bsrc->ringbuffer) {
GstWasapi2RingBuffer *ringbuffer =
GST_WASAPI2_RING_BUFFER (bsrc->ringbuffer);
hr = gst_wasapi2_ring_buffer_set_mute (ringbuffer, mute);
if (FAILED (hr)) {
GST_INFO_OBJECT (self, "Couldn't set mute");
} else {
self->mute_changed = FALSE;
}
}
GST_OBJECT_UNLOCK (self);
}
static gboolean
gst_wasapi2_src_get_mute (GstWasapi2Src * self)
{
GstAudioBaseSrc *bsrc = GST_AUDIO_BASE_SRC_CAST (self);
gboolean mute;
HRESULT hr;
GST_OBJECT_LOCK (self);
mute = self->mute;
if (bsrc->ringbuffer) {
GstWasapi2RingBuffer *ringbuffer =
GST_WASAPI2_RING_BUFFER (bsrc->ringbuffer);
hr = gst_wasapi2_ring_buffer_get_mute (ringbuffer, &mute);
if (FAILED (hr)) {
GST_INFO_OBJECT (self, "Couldn't get mute");
} else {
self->mute = mute;
}
}
GST_OBJECT_UNLOCK (self);
return mute;
}
static void
gst_wasapi2_src_set_volume (GstWasapi2Src * self, gdouble volume)
{
GstAudioBaseSrc *bsrc = GST_AUDIO_BASE_SRC_CAST (self);
HRESULT hr;
GST_OBJECT_LOCK (self);
self->volume = volume;
/* clip volume value */
self->volume = MAX (0.0, self->volume);
self->volume = MIN (1.0, self->volume);
self->volume_changed = TRUE;
if (bsrc->ringbuffer) {
GstWasapi2RingBuffer *ringbuffer =
GST_WASAPI2_RING_BUFFER (bsrc->ringbuffer);
hr = gst_wasapi2_ring_buffer_set_volume (ringbuffer, (gfloat) self->volume);
if (FAILED (hr)) {
GST_INFO_OBJECT (self, "Couldn't set volume");
} else {
self->volume_changed = FALSE;
}
}
GST_OBJECT_UNLOCK (self);
}
static gdouble
gst_wasapi2_src_get_volume (GstWasapi2Src * self)
{
GstAudioBaseSrc *bsrc = GST_AUDIO_BASE_SRC_CAST (self);
gfloat volume;
HRESULT hr;
GST_OBJECT_LOCK (self);
volume = (gfloat) self->volume;
if (bsrc->ringbuffer) {
GstWasapi2RingBuffer *ringbuffer =
GST_WASAPI2_RING_BUFFER (bsrc->ringbuffer);
hr = gst_wasapi2_ring_buffer_get_volume (ringbuffer, &volume);
if (FAILED (hr)) {
GST_INFO_OBJECT (self, "Couldn't set volume");
} else {
self->volume = volume;
}
}
GST_OBJECT_UNLOCK (self);
volume = MAX (0.0, volume);
volume = MIN (1.0, volume);
return volume;
}
static void
gst_wasapi2_src_set_silence_on_mute (GstWasapi2Src * self, gboolean value)
{
GstAudioBaseSrc *bsrc = GST_AUDIO_BASE_SRC_CAST (self);
GST_OBJECT_LOCK (self);
self->loopback_silence_on_device_mute = value;
if (self->loopback && bsrc->ringbuffer) {
GstWasapi2RingBuffer *ringbuffer =
GST_WASAPI2_RING_BUFFER (bsrc->ringbuffer);
gst_wasapi2_ring_buffer_set_device_mute_monitoring (ringbuffer, value);
}
GST_OBJECT_UNLOCK (self);
return GST_AUDIO_RING_BUFFER (priv->rbuf);
}

12
subprojects/gst-plugins-bad/sys/wasapi2/gstwasapi2util.cpp
View File

@ -33,6 +33,13 @@
GST_DEBUG_CATEGORY_EXTERN (gst_wasapi2_debug);
#define GST_CAT_DEFAULT gst_wasapi2_debug
/* Define GUIDs instead of linking ksuser.lib */
DEFINE_GUID (GST_KSDATAFORMAT_SUBTYPE_PCM, 0x00000001, 0x0000, 0x0010,
0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71);
DEFINE_GUID (GST_KSDATAFORMAT_SUBTYPE_IEEE_FLOAT, 0x00000003, 0x0000, 0x0010,
0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71);
/* Desktop only defines */
#ifndef KSAUDIO_SPEAKER_MONO
#define KSAUDIO_SPEAKER_MONO (SPEAKER_FRONT_CENTER)
@ -379,10 +386,11 @@ gst_wasapi2_util_waveformatex_to_audio_format (WAVEFORMATEX * format)
case WAVE_FORMAT_EXTENSIBLE:
{
WAVEFORMATEXTENSIBLE *ex = (WAVEFORMATEXTENSIBLE *) format;
if (IsEqualGUID (ex->SubFormat, KSDATAFORMAT_SUBTYPE_PCM)) {
if (IsEqualGUID (ex->SubFormat, GST_KSDATAFORMAT_SUBTYPE_PCM)) {
fmt = gst_audio_format_build_integer (TRUE, G_LITTLE_ENDIAN,
format->wBitsPerSample, ex->Samples.wValidBitsPerSample);
} else if (IsEqualGUID (ex->SubFormat, KSDATAFORMAT_SUBTYPE_IEEE_FLOAT)) {
} else if (IsEqualGUID (ex->SubFormat,
GST_KSDATAFORMAT_SUBTYPE_IEEE_FLOAT)) {
if (format->wBitsPerSample == 32
&& ex->Samples.wValidBitsPerSample == 32)
fmt = GST_AUDIO_FORMAT_F32LE;

15
subprojects/gst-plugins-bad/sys/wasapi2/meson.build
View File

@ -1,22 +1,20 @@
wasapi2_sources = [
'gstwasapi2src.c',
'gstwasapi2sink.c',
'gstwasapi2src.cpp',
'gstwasapi2sink.cpp',
'gstwasapi2util.cpp',
'gstwasapi2device.cpp',
'gstwasapi2ringbuffer.cpp',
'gstwasapi2activator.cpp',
'gstwasapi2enumerator.cpp',
'gstwasapi2object.cpp',
'gstwasapi2rbuf.cpp',
'plugin.cpp',
]
wasapi2_headers = [
'gstwasapi2ringbuffer.h',
'gstwasapi2device.h',
'gstwasapi2util.h',
'gstwasapi2src.h',
'gstwasapi2sink.h',
'gstwasapi2object.h',
'gstwasapi2rbuf.h',
]
mmdeviceapi_symbols = [
@ -44,10 +42,9 @@ if host_system != 'windows'
endif
ole32_dep = cc.find_library('ole32', required : get_option('wasapi2'))
ksuser_dep = cc.find_library('ksuser', required : get_option('wasapi2'))
mmdeviceapi_dep = cc.find_library('mmdevapi', required : get_option('wasapi2'))
mfplat_dep = cc.find_library('mfplat', required : get_option('wasapi2'))
wasapi2_dep = [ole32_dep, ksuser_dep, mmdeviceapi_dep, mfplat_dep]
avrt_dep = cc.find_library('avrt', required : get_option('wasapi2'))
wasapi2_dep = [ole32_dep, mmdeviceapi_dep, avrt_dep]
extra_args = []
foreach dep: wasapi2_dep

13
subprojects/gst-plugins-bad/sys/wasapi2/plugin.cpp
View File

@ -21,13 +21,10 @@
#include <config.h>
#endif
#include <winapifamily.h>
#include "gstwasapi2sink.h"
#include "gstwasapi2src.h"
#include "gstwasapi2device.h"
#include "gstwasapi2util.h"
#include <mfapi.h>
GST_DEBUG_CATEGORY (gst_wasapi2_debug);
GST_DEBUG_CATEGORY (gst_wasapi2_client_debug);
@ -35,14 +32,12 @@ GST_DEBUG_CATEGORY (gst_wasapi2_client_debug);
static void
plugin_deinit (gpointer data)
{
MFShutdown ();
}
static gboolean
plugin_init (GstPlugin * plugin)
{
guint rank = GST_RANK_PRIMARY + 1;
HRESULT hr;
/**
* plugin-wasapi2:
@ -50,15 +45,7 @@ plugin_init (GstPlugin * plugin)
* Since: 1.18
*/
hr = MFStartup (MF_VERSION, MFSTARTUP_NOSOCKET);
if (!gst_wasapi2_result (hr)) {
GST_WARNING ("MFStartup failure, hr: 0x%x", (guint) hr);
return TRUE;
}
GST_DEBUG_CATEGORY_INIT (gst_wasapi2_debug, "wasapi2", 0, "wasapi2");
GST_DEBUG_CATEGORY_INIT (gst_wasapi2_client_debug, "wasapi2client",
0, "wasapi2client");
gst_element_register (plugin, "wasapi2sink", rank, GST_TYPE_WASAPI2_SINK);
gst_element_register (plugin, "wasapi2src", rank, GST_TYPE_WASAPI2_SRC);