gstreamer/subprojects/gst-plugins-bad/sys/wasapi2/gstwasapi2client.cpp
Seungha Yang 00536ea232 wasapi2: Adjust log level in device enumeration path
Audio device at requested index might not be available, but that's
expected case when enumerating devices.

Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/6996>
2024-06-11 11:11:30 +00:00

1342 lines
40 KiB
C++

/*
* 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.
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "AsyncOperations.h"
#include "gstwasapi2client.h"
#include "gstwasapi2util.h"
#include <initguid.h>
#include <windows.foundation.h>
#include <windows.ui.core.h>
#include <wrl.h>
#include <wrl/wrappers/corewrappers.h>
#include <audioclient.h>
#include <mmdeviceapi.h>
#include <string.h>
#include <string>
#include <locale>
#include <codecvt>
#include <atomic>
/* *INDENT-OFF* */
using namespace ABI::Windows::ApplicationModel::Core;
using namespace ABI::Windows::Foundation;
using namespace ABI::Windows::Foundation::Collections;
using namespace ABI::Windows::UI::Core;
using namespace ABI::Windows::Media::Devices;
using namespace ABI::Windows::Devices::Enumeration;
using namespace Microsoft::WRL;
using namespace Microsoft::WRL::Wrappers;
/* Copy of audioclientactivationparams.h since those types are defined only for
* NTDDI_VERSION >= NTDDI_WIN10_FE */
#define GST_VIRTUAL_AUDIO_DEVICE_PROCESS_LOOPBACK L"VAD\\Process_Loopback"
typedef enum
{
GST_PROCESS_LOOPBACK_MODE_INCLUDE_TARGET_PROCESS_TREE = 0,
GST_PROCESS_LOOPBACK_MODE_EXCLUDE_TARGET_PROCESS_TREE = 1
} GST_PROCESS_LOOPBACK_MODE;
typedef struct
{
DWORD TargetProcessId;
GST_PROCESS_LOOPBACK_MODE ProcessLoopbackMode;
} GST_AUDIOCLIENT_PROCESS_LOOPBACK_PARAMS;
typedef enum
{
GST_AUDIOCLIENT_ACTIVATION_TYPE_DEFAULT = 0,
GST_AUDIOCLIENT_ACTIVATION_TYPE_PROCESS_LOOPBACK = 1
} GST_AUDIOCLIENT_ACTIVATION_TYPE;
typedef struct
{
GST_AUDIOCLIENT_ACTIVATION_TYPE ActivationType;
union
{
GST_AUDIOCLIENT_PROCESS_LOOPBACK_PARAMS ProcessLoopbackParams;
} DUMMYUNIONNAME;
} GST_AUDIOCLIENT_ACTIVATION_PARAMS;
/* End of audioclientactivationparams.h */
G_BEGIN_DECLS
GST_DEBUG_CATEGORY_EXTERN (gst_wasapi2_client_debug);
#define GST_CAT_DEFAULT gst_wasapi2_client_debug
G_END_DECLS
/* *INDENT-ON* */
static void
gst_wasapi2_client_on_device_activated (GstWasapi2Client * client,
IAudioClient * audio_client);
static void
gst_wasapi2_client_on_endpoint_volume_activated (GstWasapi2Client * client,
IAudioEndpointVolume * audio_endpoint_volume);
static void
gst_wasapi2_client_set_endpoint_muted (GstWasapi2Client * client,
gboolean muted);
/* *INDENT-OFF* */
class GstWasapiDeviceActivator
: public RuntimeClass<RuntimeClassFlags<ClassicCom>, FtmBase,
IActivateAudioInterfaceCompletionHandler>
{
public:
typedef enum {
WASAPI_IFACE_AUDIO_CLIENT,
WASAPI_IFACE_AUDIO_ENDPOINT_VOLUME,
} WasapiInterface;
GstWasapiDeviceActivator ()
{
g_weak_ref_init (&listener_, nullptr);
interface_to_activate_ = WASAPI_IFACE_AUDIO_CLIENT;
}
~GstWasapiDeviceActivator ()
{
g_weak_ref_set (&listener_, nullptr);
}
HRESULT
RuntimeClassInitialize (GstWasapi2Client * listener,
gpointer dispatcher,
WasapiInterface interface_to_activate)
{
if (!listener)
return E_INVALIDARG;
g_weak_ref_set (&listener_, listener);
if (dispatcher) {
ComPtr<IInspectable> inspectable =
reinterpret_cast<IInspectable*> (dispatcher);
HRESULT hr;
hr = inspectable.As (&dispatcher_);
if (gst_wasapi2_result (hr))
GST_INFO("Main UI dispatcher is available");
}
interface_to_activate_ = interface_to_activate;
return S_OK;
}
STDMETHOD(ActivateCompleted)
(IActivateAudioInterfaceAsyncOperation *async_op)
{
ComPtr<IAudioClient> audio_client;
ComPtr<IAudioEndpointVolume> audio_endpoint_volume;
HRESULT hr = S_OK;
HRESULT hr_async_op = S_OK;
ComPtr<IUnknown> audio_interface;
GstWasapi2Client *client;
client = (GstWasapi2Client *) g_weak_ref_get (&listener_);
if (!client) {
GST_WARNING ("No listener was configured");
return S_OK;
}
GST_INFO_OBJECT (client, "AsyncOperation done");
hr = async_op->GetActivateResult(&hr_async_op, &audio_interface);
if (!gst_wasapi2_result (hr)) {
GST_WARNING_OBJECT (client, "Failed to get activate result, hr: 0x%x", hr);
goto done;
}
if (!gst_wasapi2_result (hr_async_op)) {
GST_WARNING_OBJECT (client, "Failed to activate device");
goto done;
}
switch (interface_to_activate_) {
case WASAPI_IFACE_AUDIO_CLIENT:
hr = audio_interface.As (&audio_client);
if (!gst_wasapi2_result (hr)) {
GST_ERROR_OBJECT (client, "Failed to get IAudioClient3 interface");
goto done;
}
break;
case WASAPI_IFACE_AUDIO_ENDPOINT_VOLUME:
hr = audio_interface.As (&audio_endpoint_volume);
if (!gst_wasapi2_result (hr)) {
GST_ERROR_OBJECT (client, "Failed to get IAudioEndpointVolume interface");
goto done;
}
break;
}
done:
/* Should call this method anyway, listener will wait this event */
switch (interface_to_activate_) {
case WASAPI_IFACE_AUDIO_CLIENT:
gst_wasapi2_client_on_device_activated (client, audio_client.Get());
break;
case WASAPI_IFACE_AUDIO_ENDPOINT_VOLUME:
gst_wasapi2_client_on_endpoint_volume_activated (client, audio_endpoint_volume.Get());
break;
}
gst_object_unref (client);
/* return S_OK anyway, but listener can know it's succeeded or not
* by passed IAudioClient handle via gst_wasapi2_client_on_device_activated
*/
return S_OK;
}
HRESULT
ActivateDeviceAsync(const std::wstring &device_id,
GST_AUDIOCLIENT_ACTIVATION_PARAMS * params)
{
ComPtr<IAsyncAction> async_action;
bool run_async = false;
HRESULT hr;
auto work_item = Callback<Implements<RuntimeClassFlags<ClassicCom>,
IDispatchedHandler, FtmBase>>([this, device_id, params]{
ComPtr<IActivateAudioInterfaceAsyncOperation> async_op;
HRESULT async_hr = S_OK;
PROPVARIANT activate_params = {};
IID iid = {};
switch (interface_to_activate_) {
case WASAPI_IFACE_AUDIO_CLIENT:
iid = __uuidof (IAudioClient);
break;
case WASAPI_IFACE_AUDIO_ENDPOINT_VOLUME:
iid = __uuidof (IAudioEndpointVolume);
break;
}
if (params) {
activate_params.vt = VT_BLOB;
activate_params.blob.cbSize = sizeof(GST_AUDIOCLIENT_ACTIVATION_PARAMS);
activate_params.blob.pBlobData = (BYTE *) params;
async_hr = ActivateAudioInterfaceAsync (device_id.c_str (),
iid, &activate_params, this, &async_op);
} else {
async_hr = ActivateAudioInterfaceAsync (device_id.c_str (),
iid, nullptr, this, &async_op);
}
/* for debugging */
gst_wasapi2_result (async_hr);
return async_hr;
});
if (dispatcher_) {
boolean can_now;
hr = dispatcher_->get_HasThreadAccess (&can_now);
if (!gst_wasapi2_result (hr))
return hr;
if (!can_now)
run_async = true;
}
if (run_async && dispatcher_) {
hr = dispatcher_->RunAsync (CoreDispatcherPriority_Normal,
work_item.Get (), &async_action);
} else {
hr = work_item->Invoke ();
}
return hr;
}
private:
GWeakRef listener_;
ComPtr<ICoreDispatcher> dispatcher_;
WasapiInterface interface_to_activate_;
};
class GstWasapiEndpointVolumeCallback
: public RuntimeClass<RuntimeClassFlags<ClassicCom>, FtmBase,
IAudioEndpointVolumeCallback>
{
public:
GstWasapiEndpointVolumeCallback ()
{
g_weak_ref_init (&client_, nullptr);
}
~GstWasapiEndpointVolumeCallback ()
{
g_weak_ref_set (&client_, nullptr);
}
HRESULT
RuntimeClassInitialize (GstWasapi2Client * client)
{
if (!client)
return E_INVALIDARG;
g_weak_ref_set (&client_, client);
return S_OK;
}
STDMETHOD(OnNotify)
(AUDIO_VOLUME_NOTIFICATION_DATA * notify)
{
GstWasapi2Client *client = (GstWasapi2Client *) g_weak_ref_get (&client_);
if (client) {
gst_wasapi2_client_set_endpoint_muted (client, notify->bMuted);
gst_object_unref (client);
}
return S_OK;
}
private:
GWeakRef client_;
};
/* *INDENT-ON* */
typedef enum
{
GST_WASAPI2_CLIENT_ACTIVATE_NOT_FOUND = -2,
GST_WASAPI2_CLIENT_ACTIVATE_FAILED = -1,
GST_WASAPI2_CLIENT_ACTIVATE_INIT = 0,
GST_WASAPI2_CLIENT_ACTIVATE_WAIT,
GST_WASAPI2_CLIENT_ACTIVATE_DONE,
} GstWasapi2ClientActivateState;
enum
{
PROP_0,
PROP_DEVICE,
PROP_DEVICE_NAME,
PROP_DEVICE_INDEX,
PROP_DEVICE_CLASS,
PROP_DISPATCHER,
PROP_CAN_AUTO_ROUTING,
PROP_LOOPBACK_TARGET_PID,
};
#define DEFAULT_DEVICE_INDEX -1
#define DEFAULT_DEVICE_CLASS GST_WASAPI2_CLIENT_DEVICE_CLASS_CAPTURE
struct GstWasapi2ClientPrivate
{
std::atomic < bool >is_endpoint_muted;
};
struct _GstWasapi2Client
{
GstObject parent;
GstWasapi2ClientPrivate *priv;
GstWasapi2ClientDeviceClass device_class;
gchar *device_id;
gchar *device_name;
gint device_index;
gpointer dispatcher;
gboolean can_auto_routing;
guint target_pid;
IAudioClient *audio_client;
GMutex endpoint_volume_lock;
IAudioEndpointVolume *audio_endpoint_volume;
GstWasapiEndpointVolumeCallback *endpoint_volume_callback;
GstCaps *supported_caps;
GThread *thread;
GMutex lock;
GCond cond;
GMainContext *context;
GMainLoop *loop;
/* To wait ActivateCompleted event */
GMutex init_lock;
GCond init_cond;
GstWasapi2ClientActivateState activate_state;
};
GType
gst_wasapi2_client_device_class_get_type (void)
{
static GType class_type = 0;
static const GEnumValue types[] = {
{GST_WASAPI2_CLIENT_DEVICE_CLASS_CAPTURE, "Capture", "capture"},
{GST_WASAPI2_CLIENT_DEVICE_CLASS_RENDER, "Render", "render"},
{GST_WASAPI2_CLIENT_DEVICE_CLASS_LOOPBACK_CAPTURE, "Loopback-Capture",
"loopback-capture"},
{GST_WASAPI2_CLIENT_DEVICE_CLASS_INCLUDE_PROCESS_LOOPBACK_CAPTURE,
"Include-Process-Loopback-Capture",
"include-process-loopback-capture"},
{GST_WASAPI2_CLIENT_DEVICE_CLASS_EXCLUDE_PROCESS_LOOPBACK_CAPTURE,
"Exclude-Process-Loopback-Capture",
"exclude-process-loopback-capture"},
{0, nullptr, nullptr}
};
if (g_once_init_enter (&class_type)) {
GType gtype = g_enum_register_static ("GstWasapi2ClientDeviceClass", types);
g_once_init_leave (&class_type, gtype);
}
return class_type;
}
static void gst_wasapi2_client_constructed (GObject * object);
static void gst_wasapi2_client_finalize (GObject * object);
static void gst_wasapi2_client_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec);
static void gst_wasapi2_client_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec);
static gpointer gst_wasapi2_client_thread_func (GstWasapi2Client * self);
static gboolean
gst_wasapi2_client_main_loop_running_cb (GstWasapi2Client * self);
#define gst_wasapi2_client_parent_class parent_class
G_DEFINE_TYPE (GstWasapi2Client, gst_wasapi2_client, GST_TYPE_OBJECT);
static void
gst_wasapi2_client_class_init (GstWasapi2ClientClass * klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
GParamFlags param_flags =
(GParamFlags) (G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY |
G_PARAM_STATIC_STRINGS);
gobject_class->constructed = gst_wasapi2_client_constructed;
gobject_class->finalize = gst_wasapi2_client_finalize;
gobject_class->get_property = gst_wasapi2_client_get_property;
gobject_class->set_property = gst_wasapi2_client_set_property;
g_object_class_install_property (gobject_class, PROP_DEVICE,
g_param_spec_string ("device", "Device",
"Audio device ID as provided by "
"Windows.Devices.Enumeration.DeviceInformation.Id",
nullptr, param_flags));
g_object_class_install_property (gobject_class, PROP_DEVICE_NAME,
g_param_spec_string ("device-name", "Device Name",
"The human-readable device name", nullptr, param_flags));
g_object_class_install_property (gobject_class, PROP_DEVICE_INDEX,
g_param_spec_int ("device-index", "Device Index",
"The zero-based device index", -1, G_MAXINT, DEFAULT_DEVICE_INDEX,
param_flags));
g_object_class_install_property (gobject_class, PROP_DEVICE_CLASS,
g_param_spec_enum ("device-class", "Device Class",
"Device class", GST_TYPE_WASAPI2_CLIENT_DEVICE_CLASS,
DEFAULT_DEVICE_CLASS, param_flags));
g_object_class_install_property (gobject_class, PROP_DISPATCHER,
g_param_spec_pointer ("dispatcher", "Dispatcher",
"ICoreDispatcher COM object to use", param_flags));
g_object_class_install_property (gobject_class, PROP_CAN_AUTO_ROUTING,
g_param_spec_boolean ("auto-routing", "Auto Routing",
"Whether client can support automatic stream routing", FALSE,
(GParamFlags) (G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)));
g_object_class_install_property (gobject_class, PROP_LOOPBACK_TARGET_PID,
g_param_spec_uint ("loopback-target-pid", "Loopback Target PID",
"Target process id to record", 0, G_MAXUINT32, 0, param_flags));
}
static void
gst_wasapi2_client_init (GstWasapi2Client * self)
{
self->device_index = DEFAULT_DEVICE_INDEX;
self->device_class = DEFAULT_DEVICE_CLASS;
self->can_auto_routing = FALSE;
g_mutex_init (&self->lock);
g_cond_init (&self->cond);
g_mutex_init (&self->init_lock);
g_cond_init (&self->init_cond);
self->activate_state = GST_WASAPI2_CLIENT_ACTIVATE_INIT;
g_mutex_init (&self->endpoint_volume_lock);
self->context = g_main_context_new ();
self->loop = g_main_loop_new (self->context, FALSE);
self->priv = new GstWasapi2ClientPrivate ();
self->priv->is_endpoint_muted.store (false, std::memory_order_release);
}
static void
gst_wasapi2_client_constructed (GObject * object)
{
GstWasapi2Client *self = GST_WASAPI2_CLIENT (object);
/* Create a new thread to ensure that COM thread can be MTA thread.
* We cannot ensure whether CoInitializeEx() was called outside of here for
* this thread or not. If it was called with non-COINIT_MULTITHREADED option,
* we cannot update it */
g_mutex_lock (&self->lock);
self->thread = g_thread_new ("GstWasapi2ClientWinRT",
(GThreadFunc) gst_wasapi2_client_thread_func, self);
while (!self->loop || !g_main_loop_is_running (self->loop))
g_cond_wait (&self->cond, &self->lock);
g_mutex_unlock (&self->lock);
G_OBJECT_CLASS (parent_class)->constructed (object);
}
static void
gst_wasapi2_client_finalize (GObject * object)
{
GstWasapi2Client *self = GST_WASAPI2_CLIENT (object);
if (self->loop) {
g_main_loop_quit (self->loop);
g_thread_join (self->thread);
g_main_context_unref (self->context);
g_main_loop_unref (self->loop);
self->thread = nullptr;
self->context = nullptr;
self->loop = nullptr;
}
gst_clear_caps (&self->supported_caps);
g_free (self->device_id);
g_free (self->device_name);
g_mutex_clear (&self->lock);
g_cond_clear (&self->cond);
g_mutex_clear (&self->init_lock);
g_cond_clear (&self->init_cond);
g_mutex_clear (&self->endpoint_volume_lock);
delete self->priv;
G_OBJECT_CLASS (parent_class)->finalize (object);
}
static void
gst_wasapi2_client_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec)
{
GstWasapi2Client *self = GST_WASAPI2_CLIENT (object);
switch (prop_id) {
case PROP_DEVICE:
g_value_set_string (value, self->device_id);
break;
case PROP_DEVICE_NAME:
g_value_set_string (value, self->device_name);
break;
case PROP_DEVICE_INDEX:
g_value_set_int (value, self->device_index);
break;
case PROP_DEVICE_CLASS:
g_value_set_enum (value, self->device_class);
break;
case PROP_DISPATCHER:
g_value_set_pointer (value, self->dispatcher);
break;
case PROP_CAN_AUTO_ROUTING:
g_value_set_boolean (value, self->can_auto_routing);
break;
case PROP_LOOPBACK_TARGET_PID:
g_value_set_uint (value, self->target_pid);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
gst_wasapi2_client_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec)
{
GstWasapi2Client *self = GST_WASAPI2_CLIENT (object);
switch (prop_id) {
case PROP_DEVICE:
g_free (self->device_id);
self->device_id = g_value_dup_string (value);
break;
case PROP_DEVICE_NAME:
g_free (self->device_name);
self->device_name = g_value_dup_string (value);
break;
case PROP_DEVICE_INDEX:
self->device_index = g_value_get_int (value);
break;
case PROP_DEVICE_CLASS:
self->device_class =
(GstWasapi2ClientDeviceClass) g_value_get_enum (value);
break;
case PROP_DISPATCHER:
self->dispatcher = g_value_get_pointer (value);
break;
case PROP_LOOPBACK_TARGET_PID:
self->target_pid = g_value_get_uint (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static gboolean
gst_wasapi2_client_main_loop_running_cb (GstWasapi2Client * self)
{
GST_DEBUG_OBJECT (self, "Main loop running now");
g_mutex_lock (&self->lock);
g_cond_signal (&self->cond);
g_mutex_unlock (&self->lock);
return G_SOURCE_REMOVE;
}
static void
gst_wasapi2_client_on_device_activated (GstWasapi2Client * self,
IAudioClient * audio_client)
{
GST_INFO_OBJECT (self, "Device activated");
g_mutex_lock (&self->init_lock);
if (audio_client) {
audio_client->AddRef ();
self->audio_client = audio_client;
self->activate_state = GST_WASAPI2_CLIENT_ACTIVATE_DONE;
} else {
GST_WARNING_OBJECT (self, "IAudioClient is unavailable");
self->activate_state = GST_WASAPI2_CLIENT_ACTIVATE_FAILED;
}
g_cond_broadcast (&self->init_cond);
g_mutex_unlock (&self->init_lock);
}
static void
gst_wasapi2_client_on_endpoint_volume_activated (GstWasapi2Client * self,
IAudioEndpointVolume * audio_endpoint_volume)
{
GST_INFO_OBJECT (self, "Audio Endpoint Volume activated");
if (audio_endpoint_volume) {
HRESULT hr;
ComPtr < GstWasapiEndpointVolumeCallback > callback;
g_mutex_lock (&self->endpoint_volume_lock);
audio_endpoint_volume->AddRef ();
self->audio_endpoint_volume = audio_endpoint_volume;
hr = MakeAndInitialize < GstWasapiEndpointVolumeCallback > (&callback,
self);
if (!gst_wasapi2_result (hr)) {
GST_WARNING_OBJECT (self,
"Could not create endpoint volume callback object");
} else {
hr = audio_endpoint_volume->RegisterControlChangeNotify (callback.Get ());
if (!gst_wasapi2_result (hr)) {
GST_WARNING_OBJECT (self,
"Failed to register endpoint volume callback");
} else {
BOOL initially_muted = FALSE;
self->endpoint_volume_callback = callback.Detach ();
hr = audio_endpoint_volume->GetMute (&initially_muted);
if (gst_wasapi2_result (hr)) {
gst_wasapi2_client_set_endpoint_muted (self, initially_muted);
}
}
}
g_mutex_unlock (&self->endpoint_volume_lock);
} else {
GST_WARNING_OBJECT (self, "IAudioEndpointVolume is unavailable");
}
}
static void
gst_wasapi2_client_set_endpoint_muted (GstWasapi2Client * self, gboolean muted)
{
GST_DEBUG_OBJECT (self, "Audio Endpoint Volume: muted=%d", muted);
self->priv->is_endpoint_muted.store (muted, std::memory_order_release);
}
/* *INDENT-OFF* */
static std::string
convert_wstring_to_string (const std::wstring &wstr)
{
std::wstring_convert<std::codecvt_utf8<wchar_t>, wchar_t> converter;
return converter.to_bytes (wstr.c_str());
}
static std::string
convert_hstring_to_string (HString * hstr)
{
const wchar_t *raw_hstr;
if (!hstr)
return std::string();
raw_hstr = hstr->GetRawBuffer (nullptr);
if (!raw_hstr)
return std::string();
return convert_wstring_to_string (std::wstring (raw_hstr));
}
static std::wstring
gst_wasapi2_client_get_default_device_id (GstWasapi2Client * self)
{
HRESULT hr;
PWSTR default_device_id_wstr = nullptr;
if (self->device_class == GST_WASAPI2_CLIENT_DEVICE_CLASS_CAPTURE)
hr = StringFromIID (DEVINTERFACE_AUDIO_CAPTURE, &default_device_id_wstr);
else
hr = StringFromIID (DEVINTERFACE_AUDIO_RENDER, &default_device_id_wstr);
if (!gst_wasapi2_result (hr))
return std::wstring();
std::wstring ret = std::wstring (default_device_id_wstr);
CoTaskMemFree (default_device_id_wstr);
return ret;
}
/* *INDENT-ON* */
static void
gst_wasapi2_client_activate_async (GstWasapi2Client * self,
GstWasapiDeviceActivator * activator,
GstWasapiDeviceActivator * endpoint_volume_activator)
{
/* *INDENT-OFF* */
ComPtr<IDeviceInformationStatics> device_info_static;
ComPtr<IAsyncOperation<DeviceInformationCollection*>> async_op;
ComPtr<IVectorView<DeviceInformation*>> device_list;
HStringReference hstr_device_info =
HStringReference(RuntimeClass_Windows_Devices_Enumeration_DeviceInformation);
/* *INDENT-ON* */
HRESULT hr;
DeviceClass device_class;
unsigned int count = 0;
gint device_index = 0;
std::wstring default_device_id_wstring;
std::string default_device_id;
std::wstring target_device_id_wstring;
std::string target_device_id;
std::string target_device_name;
gboolean use_default_device = FALSE;
GST_AUDIOCLIENT_ACTIVATION_PARAMS activation_params;
gboolean process_loopback = FALSE;
memset (&activation_params, 0, sizeof (GST_AUDIOCLIENT_ACTIVATION_PARAMS));
activation_params.ActivationType = GST_AUDIOCLIENT_ACTIVATION_TYPE_DEFAULT;
self->activate_state = GST_WASAPI2_CLIENT_ACTIVATE_NOT_FOUND;
if (self->device_class ==
GST_WASAPI2_CLIENT_DEVICE_CLASS_INCLUDE_PROCESS_LOOPBACK_CAPTURE ||
self->device_class ==
GST_WASAPI2_CLIENT_DEVICE_CLASS_EXCLUDE_PROCESS_LOOPBACK_CAPTURE) {
if (self->target_pid == 0) {
GST_ERROR_OBJECT (self, "Process loopback mode without PID");
return;
}
if (!gst_wasapi2_can_process_loopback ()) {
GST_ERROR_OBJECT (self, "Process loopback is not supported");
return;
}
process_loopback = TRUE;
activation_params.ActivationType =
GST_AUDIOCLIENT_ACTIVATION_TYPE_PROCESS_LOOPBACK;
activation_params.ProcessLoopbackParams.TargetProcessId =
(DWORD) self->target_pid;
target_device_id_wstring = GST_VIRTUAL_AUDIO_DEVICE_PROCESS_LOOPBACK;
target_device_id = convert_wstring_to_string (target_device_id_wstring);
if (self->device_class ==
GST_WASAPI2_CLIENT_DEVICE_CLASS_INCLUDE_PROCESS_LOOPBACK_CAPTURE) {
activation_params.ProcessLoopbackParams.ProcessLoopbackMode =
GST_PROCESS_LOOPBACK_MODE_INCLUDE_TARGET_PROCESS_TREE;
} else {
activation_params.ProcessLoopbackParams.ProcessLoopbackMode =
GST_PROCESS_LOOPBACK_MODE_EXCLUDE_TARGET_PROCESS_TREE;
}
target_device_name = "Process-loopback";
goto activate;
}
GST_INFO_OBJECT (self,
"requested device info, device-class: %s, device: %s, device-index: %d",
self->device_class ==
GST_WASAPI2_CLIENT_DEVICE_CLASS_CAPTURE ? "capture" : "render",
GST_STR_NULL (self->device_id), self->device_index);
if (self->device_class == GST_WASAPI2_CLIENT_DEVICE_CLASS_CAPTURE) {
device_class = DeviceClass::DeviceClass_AudioCapture;
} else {
device_class = DeviceClass::DeviceClass_AudioRender;
}
default_device_id_wstring = gst_wasapi2_client_get_default_device_id (self);
if (default_device_id_wstring.empty ()) {
GST_WARNING_OBJECT (self, "Couldn't get default device id");
return;
}
default_device_id = convert_wstring_to_string (default_device_id_wstring);
GST_DEBUG_OBJECT (self, "Default device id: %s", default_device_id.c_str ());
/* When
* 1) default device was requested or
* 2) no explicitly requested device or
* 3) requested device string id is null but device index is zero
* will use default device
*
* Note that default device is much preferred
* See https://docs.microsoft.com/en-us/windows/win32/coreaudio/automatic-stream-routing
*/
/* DEVINTERFACE_AUDIO_CAPTURE and DEVINTERFACE_AUDIO_RENDER are available
* as of Windows 10 */
if (gst_wasapi2_can_automatic_stream_routing ()) {
if (self->device_id &&
g_ascii_strcasecmp (self->device_id, default_device_id.c_str ()) == 0) {
GST_DEBUG_OBJECT (self, "Default device was requested");
use_default_device = TRUE;
} else if (self->device_index < 0 && !self->device_id) {
GST_DEBUG_OBJECT (self,
"No device was explicitly requested, use default device");
use_default_device = TRUE;
} else if (!self->device_id && self->device_index == 0) {
GST_DEBUG_OBJECT (self, "device-index == zero means default device");
use_default_device = TRUE;
}
}
if (use_default_device) {
target_device_id_wstring = default_device_id_wstring;
target_device_id = default_device_id;
if (self->device_class == GST_WASAPI2_CLIENT_DEVICE_CLASS_CAPTURE)
target_device_name = "Default Audio Capture Device";
else
target_device_name = "Default Audio Render Device";
goto activate;
}
hr = GetActivationFactory (hstr_device_info.Get (), &device_info_static);
if (!gst_wasapi2_result (hr))
return;
hr = device_info_static->FindAllAsyncDeviceClass (device_class, &async_op);
device_info_static.Reset ();
if (!gst_wasapi2_result (hr))
return;
/* *INDENT-OFF* */
hr = SyncWait<DeviceInformationCollection*>(async_op.Get ());
/* *INDENT-ON* */
if (!gst_wasapi2_result (hr))
return;
hr = async_op->GetResults (&device_list);
async_op.Reset ();
if (!gst_wasapi2_result (hr))
return;
hr = device_list->get_Size (&count);
if (!gst_wasapi2_result (hr))
return;
if (count == 0) {
GST_INFO_OBJECT (self, "No available device");
return;
}
/* device_index 0 will be assigned for default device
* so the number of available device is count + 1 (for default device) */
if (self->device_index >= 0 && self->device_index > (gint) count) {
GST_INFO_OBJECT (self, "Device index %d is unavailable",
self->device_index);
return;
}
GST_DEBUG_OBJECT (self, "Available device count: %d", count);
if (gst_wasapi2_can_automatic_stream_routing ()) {
/* zero is for default device */
device_index = 1;
} else {
device_index = 0;
}
for (unsigned int i = 0; i < count; i++) {
/* *INDENT-OFF* */
ComPtr<IDeviceInformation> device_info;
/* *INDENT-ON* */
HString id;
HString name;
boolean b_value;
std::string cur_device_id;
std::string cur_device_name;
hr = device_list->GetAt (i, &device_info);
if (!gst_wasapi2_result (hr))
continue;
hr = device_info->get_IsEnabled (&b_value);
if (!gst_wasapi2_result (hr))
continue;
/* select only enabled device */
if (!b_value) {
GST_DEBUG_OBJECT (self, "Device index %d is disabled", i);
continue;
}
/* To ensure device id and device name are available,
* will query this later again once target device is determined */
hr = device_info->get_Id (id.GetAddressOf ());
if (!gst_wasapi2_result (hr))
continue;
if (!id.IsValid ()) {
GST_WARNING_OBJECT (self, "Device index %d has invalid id", i);
continue;
}
hr = device_info->get_Name (name.GetAddressOf ());
if (!gst_wasapi2_result (hr))
continue;
if (!name.IsValid ()) {
GST_WARNING_OBJECT (self, "Device index %d has invalid name", i);
continue;
}
cur_device_id = convert_hstring_to_string (&id);
if (cur_device_id.empty ()) {
GST_WARNING_OBJECT (self, "Device index %d has empty id", i);
continue;
}
cur_device_name = convert_hstring_to_string (&name);
if (cur_device_name.empty ()) {
GST_WARNING_OBJECT (self, "Device index %d has empty device name", i);
continue;
}
GST_DEBUG_OBJECT (self, "device [%d] id: %s, name: %s",
device_index, cur_device_id.c_str (), cur_device_name.c_str ());
if (self->device_index < 0 && !self->device_id) {
GST_INFO_OBJECT (self, "Select the first device, device id %s",
cur_device_id.c_str ());
target_device_id_wstring = id.GetRawBuffer (nullptr);
target_device_id = cur_device_id;
target_device_name = cur_device_name;
break;
}
if (self->device_id &&
g_ascii_strcasecmp (self->device_id, cur_device_id.c_str ()) == 0) {
GST_INFO_OBJECT (self,
"Device index %d has matching device id %s", device_index,
cur_device_id.c_str ());
target_device_id_wstring = id.GetRawBuffer (nullptr);
target_device_id = cur_device_id;
target_device_name = cur_device_name;
break;
}
if (self->device_index >= 0 && self->device_index == device_index) {
GST_INFO_OBJECT (self, "Select device index %d, device id %s",
device_index, cur_device_id.c_str ());
target_device_id_wstring = id.GetRawBuffer (nullptr);
target_device_id = cur_device_id;
target_device_name = cur_device_name;
break;
}
/* count only available devices */
device_index++;
}
if (target_device_id_wstring.empty ()) {
GST_WARNING_OBJECT (self, "Couldn't find target device");
return;
}
activate:
/* fill device id and name */
g_free (self->device_id);
self->device_id = g_strdup (target_device_id.c_str ());
g_free (self->device_name);
self->device_name = g_strdup (target_device_name.c_str ());
self->device_index = device_index;
/* default device supports automatic stream routing */
self->can_auto_routing = use_default_device;
self->activate_state = GST_WASAPI2_CLIENT_ACTIVATE_INIT;
if (process_loopback) {
hr = activator->ActivateDeviceAsync (target_device_id_wstring,
&activation_params);
} else {
hr = activator->ActivateDeviceAsync (target_device_id_wstring, nullptr);
}
if (!gst_wasapi2_result (hr)) {
GST_WARNING_OBJECT (self, "Failed to activate device");
self->activate_state = GST_WASAPI2_CLIENT_ACTIVATE_FAILED;
return;
}
/* activate the endpoint volume interface */
if (endpoint_volume_activator) {
if (use_default_device) {
GST_INFO_OBJECT (self,
"Endpoint volume monitoring for the default device is not implemented.");
} else {
hr = endpoint_volume_activator->ActivateDeviceAsync
(target_device_id_wstring, nullptr);
if (!gst_wasapi2_result (hr)) {
GST_WARNING_OBJECT (self, "Failed to activate device");
}
}
}
g_mutex_lock (&self->lock);
if (self->activate_state == GST_WASAPI2_CLIENT_ACTIVATE_INIT)
self->activate_state = GST_WASAPI2_CLIENT_ACTIVATE_WAIT;
g_mutex_unlock (&self->lock);
}
static const gchar *
activate_state_to_string (GstWasapi2ClientActivateState state)
{
switch (state) {
case GST_WASAPI2_CLIENT_ACTIVATE_NOT_FOUND:
return "NOT-FOUND";
case GST_WASAPI2_CLIENT_ACTIVATE_FAILED:
return "FAILED";
case GST_WASAPI2_CLIENT_ACTIVATE_INIT:
return "INIT";
case GST_WASAPI2_CLIENT_ACTIVATE_WAIT:
return "WAIT";
case GST_WASAPI2_CLIENT_ACTIVATE_DONE:
return "DONE";
}
g_assert_not_reached ();
return "Undefined";
}
static gpointer
gst_wasapi2_client_thread_func (GstWasapi2Client * self)
{
RoInitializeWrapper initialize (RO_INIT_MULTITHREADED);
GSource *source;
HRESULT hr;
/* *INDENT-OFF* */
ComPtr<GstWasapiDeviceActivator> client_activator;
ComPtr<GstWasapiDeviceActivator> endpoint_volume_activator;
hr = MakeAndInitialize<GstWasapiDeviceActivator> (&client_activator,
self, self->dispatcher, GstWasapiDeviceActivator::WASAPI_IFACE_AUDIO_CLIENT);
/* *INDENT-ON* */
if (!gst_wasapi2_result (hr)) {
GST_ERROR_OBJECT (self, "Could not create activator object");
self->activate_state = GST_WASAPI2_CLIENT_ACTIVATE_NOT_FOUND;
goto run_loop;
}
/* Initialize audio endpoint volume activator */
hr = MakeAndInitialize < GstWasapiDeviceActivator >
(&endpoint_volume_activator, self, self->dispatcher,
GstWasapiDeviceActivator::WASAPI_IFACE_AUDIO_ENDPOINT_VOLUME);
if (!gst_wasapi2_result (hr)) {
GST_WARNING_OBJECT (self,
"Could not create endpoint volume activator object");
}
gst_wasapi2_client_activate_async (self, client_activator.Get (),
endpoint_volume_activator.Get ());
if (!self->dispatcher) {
/* In case that dispatcher is unavailable, wait activation synchroniously */
GST_DEBUG_OBJECT (self, "Wait device activation");
gst_wasapi2_client_ensure_activation (self);
GST_DEBUG_OBJECT (self, "Device activation result %s",
activate_state_to_string (self->activate_state));
}
run_loop:
g_main_context_push_thread_default (self->context);
source = g_idle_source_new ();
g_source_set_callback (source,
(GSourceFunc) gst_wasapi2_client_main_loop_running_cb, self, nullptr);
g_source_attach (source, self->context);
g_source_unref (source);
GST_DEBUG_OBJECT (self, "Starting main loop");
g_main_loop_run (self->loop);
GST_DEBUG_OBJECT (self, "Stopped main loop");
g_main_context_pop_thread_default (self->context);
/* Wait for pending async op if any */
if (self->dispatcher)
gst_wasapi2_client_ensure_activation (self);
GST_WASAPI2_CLEAR_COM (self->audio_client);
g_mutex_lock (&self->endpoint_volume_lock);
if (self->audio_endpoint_volume && self->endpoint_volume_callback) {
self->audio_endpoint_volume->
UnregisterControlChangeNotify (self->endpoint_volume_callback);
}
GST_WASAPI2_CLEAR_COM (self->endpoint_volume_callback);
GST_WASAPI2_CLEAR_COM (self->audio_endpoint_volume);
g_mutex_unlock (&self->endpoint_volume_lock);
/* Reset explicitly to ensure that it happens before
* RoInitializeWrapper dtor is called */
client_activator.Reset ();
endpoint_volume_activator.Reset ();
GST_DEBUG_OBJECT (self, "Exit thread function");
return nullptr;
}
GstCaps *
gst_wasapi2_client_get_caps (GstWasapi2Client * client)
{
WAVEFORMATEX *mix_format = nullptr;
static GstStaticCaps static_caps = GST_STATIC_CAPS (GST_WASAPI2_STATIC_CAPS);
GstCaps *scaps;
HRESULT hr;
g_return_val_if_fail (GST_IS_WASAPI2_CLIENT (client), nullptr);
if (client->supported_caps)
return gst_caps_ref (client->supported_caps);
if (!client->audio_client) {
GST_WARNING_OBJECT (client, "IAudioClient3 wasn't configured");
return nullptr;
}
hr = client->audio_client->GetMixFormat (&mix_format);
if (!gst_wasapi2_result (hr)) {
if (gst_wasapi2_device_class_is_process_loopback (client->device_class)) {
mix_format = gst_wasapi2_get_default_mix_format ();
} else {
GST_WARNING_OBJECT (client, "Failed to get mix format");
return nullptr;
}
}
scaps = gst_static_caps_get (&static_caps);
gst_wasapi2_util_parse_waveformatex (mix_format,
scaps, &client->supported_caps, nullptr);
gst_caps_unref (scaps);
CoTaskMemFree (mix_format);
if (!client->supported_caps) {
GST_ERROR_OBJECT (client, "No caps from subclass");
return nullptr;
}
return gst_caps_ref (client->supported_caps);
}
gboolean
gst_wasapi2_client_ensure_activation (GstWasapi2Client * client)
{
g_return_val_if_fail (GST_IS_WASAPI2_CLIENT (client), FALSE);
/* should not happen */
g_assert (client->activate_state != GST_WASAPI2_CLIENT_ACTIVATE_INIT);
g_mutex_lock (&client->init_lock);
while (client->activate_state == GST_WASAPI2_CLIENT_ACTIVATE_WAIT)
g_cond_wait (&client->init_cond, &client->init_lock);
g_mutex_unlock (&client->init_lock);
return client->activate_state == GST_WASAPI2_CLIENT_ACTIVATE_DONE;
}
static HRESULT
find_dispatcher (ICoreDispatcher ** dispatcher)
{
/* *INDENT-OFF* */
HStringReference hstr_core_app =
HStringReference(RuntimeClass_Windows_ApplicationModel_Core_CoreApplication);
ComPtr<ICoreApplication> core_app;
ComPtr<ICoreApplicationView> core_app_view;
ComPtr<ICoreWindow> core_window;
/* *INDENT-ON* */
HRESULT hr;
hr = GetActivationFactory (hstr_core_app.Get (), &core_app);
if (FAILED (hr))
return hr;
hr = core_app->GetCurrentView (&core_app_view);
if (FAILED (hr))
return hr;
hr = core_app_view->get_CoreWindow (&core_window);
if (FAILED (hr))
return hr;
return core_window->get_Dispatcher (dispatcher);
}
GstWasapi2Client *
gst_wasapi2_client_new (GstWasapi2ClientDeviceClass device_class,
gint device_index, const gchar * device_id, guint32 target_pid,
gpointer dispatcher)
{
GstWasapi2Client *self;
/* *INDENT-OFF* */
ComPtr<ICoreDispatcher> core_dispatcher;
/* *INDENT-ON* */
/* Multiple COM init is allowed */
RoInitializeWrapper init_wrapper (RO_INIT_MULTITHREADED);
/* If application didn't pass ICoreDispatcher object,
* try to get dispatcher object for the current thread */
if (!dispatcher) {
HRESULT hr;
hr = find_dispatcher (&core_dispatcher);
if (SUCCEEDED (hr)) {
GST_DEBUG ("UI dispatcher is available");
dispatcher = core_dispatcher.Get ();
} else {
GST_DEBUG ("UI dispatcher is unavailable");
}
} else {
GST_DEBUG ("Use user passed UI dispatcher");
}
self = (GstWasapi2Client *) g_object_new (GST_TYPE_WASAPI2_CLIENT,
"device-class", device_class, "device-index", device_index,
"device", device_id, "loopback-target-pid", target_pid,
"dispatcher", dispatcher, nullptr);
/* Reset explicitly to ensure that it happens before
* RoInitializeWrapper dtor is called */
core_dispatcher.Reset ();
if (self->activate_state == GST_WASAPI2_CLIENT_ACTIVATE_FAILED ||
self->activate_state == GST_WASAPI2_CLIENT_ACTIVATE_NOT_FOUND) {
gst_object_unref (self);
return nullptr;
}
gst_object_ref_sink (self);
return self;
}
GstWasapi2Result
gst_wasapi2_client_enumerate (GstWasapi2ClientDeviceClass device_class,
gint device_index, GstWasapi2Client ** client)
{
GstWasapi2Client *self;
/* *INDENT-OFF* */
ComPtr<ICoreDispatcher> core_dispatcher;
/* *INDENT-ON* */
/* Multiple COM init is allowed */
RoInitializeWrapper init_wrapper (RO_INIT_MULTITHREADED);
*client = nullptr;
find_dispatcher (&core_dispatcher);
self = (GstWasapi2Client *) g_object_new (GST_TYPE_WASAPI2_CLIENT,
"device-class", device_class, "device-index", device_index,
"dispatcher", core_dispatcher.Get (), nullptr);
/* Reset explicitly to ensure that it happens before
* RoInitializeWrapper dtor is called */
core_dispatcher.Reset ();
if (self->activate_state == GST_WASAPI2_CLIENT_ACTIVATE_NOT_FOUND) {
gst_object_unref (self);
return GST_WASAPI2_DEVICE_NOT_FOUND;
} else if (self->activate_state == GST_WASAPI2_CLIENT_ACTIVATE_FAILED) {
gst_object_unref (self);
return GST_WASAPI2_ACTIVATION_FAILED;
}
gst_object_ref_sink (self);
*client = self;
return GST_WASAPI2_OK;
}
IAudioClient *
gst_wasapi2_client_get_handle (GstWasapi2Client * client)
{
g_return_val_if_fail (GST_IS_WASAPI2_CLIENT (client), nullptr);
return client->audio_client;
}
gboolean
gst_wasapi2_client_is_endpoint_muted (GstWasapi2Client * client)
{
g_return_val_if_fail (GST_IS_WASAPI2_CLIENT (client), FALSE);
return client->priv->is_endpoint_muted.load (std::memory_order_acquire);
}