mirror of
https://gitlab.freedesktop.org/gstreamer/gstreamer.git
synced 2024-07-02 12:45:51 +00:00
17f92ab400
Drop MSVC specific bits and remove unused dependency Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/6404>
1907 lines
52 KiB
C++
1907 lines
52 KiB
C++
/* 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.
|
|
*/
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
#include "config.h"
|
|
#endif
|
|
|
|
#include "gstasioobject.h"
|
|
#include <string.h>
|
|
#include <avrt.h>
|
|
#include <string>
|
|
#include <functional>
|
|
#include <vector>
|
|
#include <mutex>
|
|
|
|
GST_DEBUG_CATEGORY_STATIC (gst_asio_object_debug);
|
|
#define GST_CAT_DEFAULT gst_asio_object_debug
|
|
|
|
/* List of GstAsioObject */
|
|
static GList *asio_object_list = nullptr;
|
|
|
|
/* *INDENT-OFF* */
|
|
/* Protect asio_object_list and other global values */
|
|
std::mutex global_lock;
|
|
|
|
/* Protect callback slots */
|
|
std::mutex slot_lock;
|
|
/* *INDENT-ON* */
|
|
|
|
/* ASIO COM interface */
|
|
struct IASIO : public IUnknown
|
|
{
|
|
virtual ASIOBool init (gpointer sysHandle) = 0;
|
|
virtual void getDriverName (gchar *name) = 0;
|
|
virtual glong getDriverVersion () = 0;
|
|
virtual void getErrorMessage (gchar * string) = 0;
|
|
virtual ASIOError start () = 0;
|
|
virtual ASIOError stop () = 0;
|
|
virtual ASIOError getChannels (glong * numInputChannels,
|
|
glong * numOutputChannels) = 0;
|
|
virtual ASIOError getLatencies (glong * inputLatency,
|
|
glong * outputLatency) = 0;
|
|
virtual ASIOError getBufferSize (glong *minSize, glong *maxSize,
|
|
glong * preferredSize, glong *granularity) = 0;
|
|
virtual ASIOError canSampleRate (ASIOSampleRate sampleRate) = 0;
|
|
virtual ASIOError getSampleRate (ASIOSampleRate * sampleRate) = 0;
|
|
virtual ASIOError setSampleRate (ASIOSampleRate sampleRate) = 0;
|
|
virtual ASIOError getClockSources (ASIOClockSource *clocks,
|
|
glong *numSources) = 0;
|
|
virtual ASIOError setClockSource (glong reference) = 0;
|
|
virtual ASIOError getSamplePosition (ASIOSamples * sPos,
|
|
ASIOTimeStamp *tStamp) = 0;
|
|
virtual ASIOError getChannelInfo (ASIOChannelInfo * info) = 0;
|
|
virtual ASIOError createBuffers (ASIOBufferInfo * bufferInfos,
|
|
glong numChannels, glong bufferSize, ASIOCallbacks * callbacks) = 0;
|
|
virtual ASIOError disposeBuffers () = 0;
|
|
virtual ASIOError controlPanel () = 0;
|
|
virtual ASIOError future (glong selector,gpointer opt) = 0;
|
|
virtual ASIOError outputReady () = 0;
|
|
};
|
|
|
|
static void gst_asio_object_buffer_switch (GstAsioObject * self,
|
|
glong index, ASIOBool process_now);
|
|
static void gst_asio_object_sample_rate_changed (GstAsioObject * self,
|
|
ASIOSampleRate rate);
|
|
static glong gst_asio_object_messages (GstAsioObject * self, glong selector,
|
|
glong value, gpointer message, gdouble * opt);
|
|
static ASIOTime *gst_asio_object_buffer_switch_time_info (GstAsioObject * self,
|
|
ASIOTime * time_info, glong index, ASIOBool process_now);
|
|
|
|
/* *INDENT-OFF* */
|
|
/* Object to delegate ASIO callbacks to dedicated GstAsioObject */
|
|
class GstAsioCallbacks
|
|
{
|
|
public:
|
|
GstAsioCallbacks (GstAsioObject * object)
|
|
{
|
|
g_weak_ref_init (&object_, object);
|
|
}
|
|
|
|
virtual ~GstAsioCallbacks ()
|
|
{
|
|
g_weak_ref_clear (&object_);
|
|
}
|
|
|
|
void BufferSwitch (glong index, ASIOBool process_now)
|
|
{
|
|
GstAsioObject *obj = (GstAsioObject *) g_weak_ref_get (&object_);
|
|
if (!obj)
|
|
return;
|
|
|
|
gst_asio_object_buffer_switch (obj, index, process_now);
|
|
gst_object_unref (obj);
|
|
}
|
|
|
|
void SampleRateChanged (ASIOSampleRate rate)
|
|
{
|
|
GstAsioObject *obj = (GstAsioObject *) g_weak_ref_get (&object_);
|
|
if (!obj)
|
|
return;
|
|
|
|
gst_asio_object_sample_rate_changed (obj, rate);
|
|
gst_object_unref (obj);
|
|
}
|
|
|
|
glong Messages (glong selector, glong value, gpointer message, gdouble *opt)
|
|
{
|
|
GstAsioObject *obj = (GstAsioObject *) g_weak_ref_get (&object_);
|
|
if (!obj)
|
|
return 0;
|
|
|
|
glong ret = gst_asio_object_messages (obj, selector, value, message, opt);
|
|
gst_object_unref (obj);
|
|
|
|
return ret;
|
|
}
|
|
|
|
ASIOTime * BufferSwitchTimeInfo (ASIOTime * time_info,
|
|
glong index, ASIOBool process_now)
|
|
{
|
|
GstAsioObject *obj = (GstAsioObject *) g_weak_ref_get (&object_);
|
|
if (!obj)
|
|
return nullptr;
|
|
|
|
ASIOTime * ret = gst_asio_object_buffer_switch_time_info (obj,
|
|
time_info, index, process_now);
|
|
gst_object_unref (obj);
|
|
|
|
return ret;
|
|
}
|
|
|
|
private:
|
|
GWeakRef object_;
|
|
};
|
|
|
|
template <int instance_id>
|
|
class GstAsioCallbacksSlot
|
|
{
|
|
public:
|
|
static void
|
|
BufferSwitchStatic(glong index, ASIOBool process_now)
|
|
{
|
|
buffer_switch(index, process_now);
|
|
}
|
|
|
|
static void
|
|
SampleRateChangedStatic (ASIOSampleRate rate)
|
|
{
|
|
sample_rate_changed(rate);
|
|
}
|
|
|
|
static glong
|
|
MessagesStatic(glong selector, glong value, gpointer message, gdouble *opt)
|
|
{
|
|
return messages(selector, value, message, opt);
|
|
}
|
|
|
|
static ASIOTime *
|
|
BufferSwitchTimeInfoStatic(ASIOTime * time_info, glong index,
|
|
ASIOBool process_now)
|
|
{
|
|
return buffer_switch_time_info(time_info, index, process_now);
|
|
}
|
|
|
|
static std::function<void(glong, ASIOBool)> buffer_switch;
|
|
static std::function<void(ASIOSampleRate)> sample_rate_changed;
|
|
static std::function<glong(glong, glong, gpointer, gdouble *)> messages;
|
|
static std::function<ASIOTime *(ASIOTime *, glong, ASIOBool)> buffer_switch_time_info;
|
|
|
|
static bool bound;
|
|
|
|
static void Init ()
|
|
{
|
|
buffer_switch = nullptr;
|
|
sample_rate_changed = nullptr;
|
|
messages = nullptr;
|
|
buffer_switch_time_info = nullptr;
|
|
bound = false;
|
|
}
|
|
|
|
static bool IsBound ()
|
|
{
|
|
return bound;
|
|
}
|
|
|
|
static void Bind (GstAsioCallbacks * cb, ASIOCallbacks * driver_cb)
|
|
{
|
|
buffer_switch = std::bind(&GstAsioCallbacks::BufferSwitch, cb,
|
|
std::placeholders::_1, std::placeholders::_2);
|
|
sample_rate_changed = std::bind(&GstAsioCallbacks::SampleRateChanged, cb,
|
|
std::placeholders::_1);
|
|
messages = std::bind(&GstAsioCallbacks::Messages, cb,
|
|
std::placeholders::_1, std::placeholders::_2, std::placeholders::_3,
|
|
std::placeholders::_4);
|
|
buffer_switch_time_info = std::bind(&GstAsioCallbacks::BufferSwitchTimeInfo,
|
|
cb, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3);
|
|
|
|
driver_cb->bufferSwitch = BufferSwitchStatic;
|
|
driver_cb->sampleRateDidChange = SampleRateChangedStatic;
|
|
driver_cb->asioMessage = MessagesStatic;
|
|
driver_cb->bufferSwitchTimeInfo = BufferSwitchTimeInfoStatic;
|
|
|
|
bound = true;
|
|
}
|
|
};
|
|
|
|
template <int instance_id>
|
|
std::function<void(glong, ASIOBool)> GstAsioCallbacksSlot<instance_id>::buffer_switch;
|
|
template <int instance_id>
|
|
std::function<void(ASIOSampleRate)> GstAsioCallbacksSlot<instance_id>::sample_rate_changed;
|
|
template <int instance_id>
|
|
std::function<glong(glong, glong, gpointer, gdouble *)> GstAsioCallbacksSlot<instance_id>::messages;
|
|
template <int instance_id>
|
|
std::function<ASIOTime *(ASIOTime *, glong, ASIOBool)> GstAsioCallbacksSlot<instance_id>::buffer_switch_time_info;
|
|
template <int instance_id>
|
|
bool GstAsioCallbacksSlot<instance_id>::bound;
|
|
|
|
/* XXX: Create global slot objects,
|
|
* because ASIO callback doesn't support user data, hum.... */
|
|
GstAsioCallbacksSlot<0> cb_slot_0;
|
|
GstAsioCallbacksSlot<1> cb_slot_1;
|
|
GstAsioCallbacksSlot<2> cb_slot_2;
|
|
GstAsioCallbacksSlot<3> cb_slot_3;
|
|
GstAsioCallbacksSlot<4> cb_slot_4;
|
|
GstAsioCallbacksSlot<5> cb_slot_5;
|
|
GstAsioCallbacksSlot<6> cb_slot_6;
|
|
GstAsioCallbacksSlot<7> cb_slot_7;
|
|
|
|
/* *INDENT-ON* */
|
|
|
|
typedef struct
|
|
{
|
|
GstAsioObjectCallbacks callbacks;
|
|
guint64 callback_id;
|
|
} GstAsioObjectCallbacksPrivate;
|
|
|
|
enum
|
|
{
|
|
PROP_0,
|
|
PROP_DEVICE_INFO,
|
|
};
|
|
|
|
typedef enum
|
|
{
|
|
GST_ASIO_OBJECT_STATE_LOADED,
|
|
GST_ASIO_OBJECT_STATE_INITIALIZED,
|
|
GST_ASIO_OBJECT_STATE_PREPARED,
|
|
GST_ASIO_OBJECT_STATE_RUNNING,
|
|
} GstAsioObjectState;
|
|
|
|
/* Protect singletone object */
|
|
struct _GstAsioObject
|
|
{
|
|
GstObject parent;
|
|
|
|
GstAsioDeviceInfo *device_info;
|
|
|
|
GstAsioObjectState state;
|
|
|
|
IASIO *asio_handle;
|
|
|
|
GThread *thread;
|
|
GMutex lock;
|
|
GCond cond;
|
|
GMainContext *context;
|
|
GMainLoop *loop;
|
|
|
|
GMutex thread_lock;
|
|
GCond thread_cond;
|
|
|
|
GMutex api_lock;
|
|
|
|
/* called after init() done */
|
|
glong max_num_input_channels;
|
|
glong max_num_output_channels;
|
|
|
|
glong min_buffer_size;
|
|
glong max_buffer_size;
|
|
glong preferred_buffer_size;
|
|
glong buffer_size_granularity;
|
|
|
|
glong selected_buffer_size;
|
|
|
|
/* List of supported sample rate */
|
|
GArray *supported_sample_rates;
|
|
|
|
/* List of ASIOChannelInfo */
|
|
ASIOChannelInfo *input_channel_infos;
|
|
ASIOChannelInfo *output_channel_infos;
|
|
|
|
/* Selected sample rate */
|
|
ASIOSampleRate sample_rate;
|
|
|
|
/* Input/Output buffer infors */
|
|
ASIOBufferInfo *buffer_infos;
|
|
|
|
/* Store requested channel before createbuffer */
|
|
gboolean *input_channel_requested;
|
|
gboolean *output_channel_requested;
|
|
|
|
glong num_requested_input_channels;
|
|
glong num_requested_output_channels;
|
|
guint num_allocated_buffers;
|
|
|
|
GList *src_client_callbacks;
|
|
GList *sink_client_callbacks;
|
|
GList *loopback_client_callbacks;
|
|
guint64 next_callback_id;
|
|
|
|
GstAsioCallbacks *callbacks;
|
|
ASIOCallbacks driver_callbacks;
|
|
int slot_id;
|
|
|
|
gboolean occupy_all_channels;
|
|
};
|
|
|
|
static void gst_asio_object_constructed (GObject * object);
|
|
static void gst_asio_object_finalize (GObject * object);
|
|
static void gst_asio_object_set_property (GObject * object, guint prop_id,
|
|
const GValue * value, GParamSpec * pspec);
|
|
|
|
static gpointer gst_asio_object_thread_func (GstAsioObject * self);
|
|
|
|
#define gst_asio_object_parent_class parent_class
|
|
G_DEFINE_TYPE (GstAsioObject, gst_asio_object, GST_TYPE_OBJECT);
|
|
|
|
static void
|
|
gst_asio_object_class_init (GstAsioObjectClass * klass)
|
|
{
|
|
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
|
|
|
|
gobject_class->constructed = gst_asio_object_constructed;
|
|
gobject_class->finalize = gst_asio_object_finalize;
|
|
gobject_class->set_property = gst_asio_object_set_property;
|
|
|
|
g_object_class_install_property (gobject_class, PROP_DEVICE_INFO,
|
|
g_param_spec_pointer ("device-info", "Device Info",
|
|
"A pointer to GstAsioDeviceInfo struct",
|
|
(GParamFlags) (G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY |
|
|
G_PARAM_STATIC_STRINGS)));
|
|
|
|
GST_DEBUG_CATEGORY_INIT (gst_asio_object_debug,
|
|
"asioobject", 0, "asioobject");
|
|
}
|
|
|
|
static void
|
|
gst_asio_object_init (GstAsioObject * self)
|
|
{
|
|
g_mutex_init (&self->lock);
|
|
g_cond_init (&self->cond);
|
|
|
|
g_mutex_init (&self->thread_lock);
|
|
g_cond_init (&self->thread_cond);
|
|
|
|
g_mutex_init (&self->api_lock);
|
|
|
|
self->supported_sample_rates = g_array_new (FALSE,
|
|
FALSE, sizeof (ASIOSampleRate));
|
|
|
|
self->slot_id = -1;
|
|
}
|
|
|
|
static void
|
|
gst_asio_object_constructed (GObject * object)
|
|
{
|
|
GstAsioObject *self = GST_ASIO_OBJECT (object);
|
|
|
|
if (!self->device_info) {
|
|
GST_ERROR_OBJECT (self, "Device info was not configured");
|
|
return;
|
|
}
|
|
|
|
self->context = g_main_context_new ();
|
|
self->loop = g_main_loop_new (self->context, FALSE);
|
|
|
|
g_mutex_lock (&self->lock);
|
|
self->thread = g_thread_new ("GstAsioObject",
|
|
(GThreadFunc) gst_asio_object_thread_func, self);
|
|
while (!g_main_loop_is_running (self->loop))
|
|
g_cond_wait (&self->cond, &self->lock);
|
|
g_mutex_unlock (&self->lock);
|
|
}
|
|
|
|
static void
|
|
gst_asio_object_finalize (GObject * object)
|
|
{
|
|
GstAsioObject *self = GST_ASIO_OBJECT (object);
|
|
|
|
if (self->loop) {
|
|
g_main_loop_quit (self->loop);
|
|
g_thread_join (self->thread);
|
|
g_main_loop_unref (self->loop);
|
|
g_main_context_unref (self->context);
|
|
}
|
|
|
|
g_mutex_clear (&self->lock);
|
|
g_cond_clear (&self->cond);
|
|
|
|
g_mutex_clear (&self->thread_lock);
|
|
g_cond_clear (&self->thread_cond);
|
|
|
|
g_mutex_clear (&self->api_lock);
|
|
|
|
g_array_unref (self->supported_sample_rates);
|
|
|
|
gst_asio_device_info_free (self->device_info);
|
|
g_free (self->input_channel_infos);
|
|
g_free (self->output_channel_infos);
|
|
g_free (self->input_channel_requested);
|
|
g_free (self->output_channel_requested);
|
|
|
|
if (self->src_client_callbacks)
|
|
g_list_free_full (self->src_client_callbacks, (GDestroyNotify) g_free);
|
|
if (self->sink_client_callbacks)
|
|
g_list_free_full (self->sink_client_callbacks, (GDestroyNotify) g_free);
|
|
if (self->loopback_client_callbacks)
|
|
g_list_free_full (self->loopback_client_callbacks, (GDestroyNotify) g_free);
|
|
|
|
G_OBJECT_CLASS (parent_class)->finalize (object);
|
|
}
|
|
|
|
static void
|
|
gst_asio_object_set_property (GObject * object, guint prop_id,
|
|
const GValue * value, GParamSpec * pspec)
|
|
{
|
|
GstAsioObject *self = GST_ASIO_OBJECT (object);
|
|
|
|
switch (prop_id) {
|
|
case PROP_DEVICE_INFO:
|
|
g_clear_pointer (&self->device_info, gst_asio_device_info_free);
|
|
self->device_info = gst_asio_device_info_copy ((GstAsioDeviceInfo *)
|
|
g_value_get_pointer (value));
|
|
break;
|
|
default:
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static HWND
|
|
gst_asio_object_create_internal_hwnd (GstAsioObject * self)
|
|
{
|
|
WNDCLASSEXW wc;
|
|
ATOM atom = 0;
|
|
HINSTANCE hinstance = GetModuleHandle (NULL);
|
|
|
|
atom = GetClassInfoExW (hinstance, L"GstAsioInternalWindow", &wc);
|
|
if (atom == 0) {
|
|
GST_LOG_OBJECT (self, "Register internal window class");
|
|
ZeroMemory (&wc, sizeof (WNDCLASSEX));
|
|
|
|
wc.cbSize = sizeof (WNDCLASSEX);
|
|
wc.lpfnWndProc = DefWindowProc;
|
|
wc.hInstance = GetModuleHandle (nullptr);
|
|
wc.style = CS_OWNDC;
|
|
wc.lpszClassName = L"GstAsioInternalWindow";
|
|
|
|
atom = RegisterClassExW (&wc);
|
|
|
|
if (atom == 0) {
|
|
GST_ERROR_OBJECT (self, "Failed to register window class 0x%x",
|
|
(unsigned int) GetLastError ());
|
|
return nullptr;
|
|
}
|
|
}
|
|
|
|
return CreateWindowExW (0, L"GstAsioInternalWindow", L"GstAsioInternal",
|
|
WS_POPUP, 0, 0, 1, 1, nullptr, nullptr, GetModuleHandle (nullptr),
|
|
nullptr);
|
|
}
|
|
|
|
static gboolean
|
|
hwnd_msg_cb (GIOChannel * source, GIOCondition condition, gpointer data)
|
|
{
|
|
MSG msg;
|
|
|
|
if (!PeekMessage (&msg, NULL, 0, 0, PM_REMOVE))
|
|
return G_SOURCE_CONTINUE;
|
|
|
|
TranslateMessage (&msg);
|
|
DispatchMessage (&msg);
|
|
|
|
return G_SOURCE_CONTINUE;
|
|
}
|
|
|
|
static gboolean
|
|
gst_asio_object_main_loop_running_cb (GstAsioObject * self)
|
|
{
|
|
GST_INFO_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 gboolean
|
|
gst_asio_object_bind_callbacks (GstAsioObject * self)
|
|
{
|
|
std::lock_guard < std::mutex > lk (slot_lock);
|
|
gboolean ret = TRUE;
|
|
|
|
if (!cb_slot_0.IsBound ()) {
|
|
cb_slot_0.Bind (self->callbacks, &self->driver_callbacks);
|
|
self->slot_id = 0;
|
|
} else if (!cb_slot_1.IsBound ()) {
|
|
cb_slot_1.Bind (self->callbacks, &self->driver_callbacks);
|
|
self->slot_id = 1;
|
|
} else if (!cb_slot_2.IsBound ()) {
|
|
cb_slot_2.Bind (self->callbacks, &self->driver_callbacks);
|
|
self->slot_id = 2;
|
|
} else if (!cb_slot_3.IsBound ()) {
|
|
cb_slot_3.Bind (self->callbacks, &self->driver_callbacks);
|
|
self->slot_id = 3;
|
|
} else if (!cb_slot_4.IsBound ()) {
|
|
cb_slot_4.Bind (self->callbacks, &self->driver_callbacks);
|
|
self->slot_id = 4;
|
|
} else if (!cb_slot_5.IsBound ()) {
|
|
cb_slot_5.Bind (self->callbacks, &self->driver_callbacks);
|
|
self->slot_id = 5;
|
|
} else if (!cb_slot_6.IsBound ()) {
|
|
cb_slot_6.Bind (self->callbacks, &self->driver_callbacks);
|
|
self->slot_id = 6;
|
|
} else if (!cb_slot_7.IsBound ()) {
|
|
cb_slot_7.Bind (self->callbacks, &self->driver_callbacks);
|
|
self->slot_id = 7;
|
|
} else {
|
|
self->slot_id = -1;
|
|
ret = FALSE;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static void
|
|
gst_asio_object_unbind_callbacks (GstAsioObject * self)
|
|
{
|
|
std::lock_guard < std::mutex > lk (slot_lock);
|
|
|
|
if (!self->callbacks || self->slot_id < 0)
|
|
return;
|
|
|
|
switch (self->slot_id) {
|
|
case 0:
|
|
cb_slot_0.Init ();
|
|
break;
|
|
case 1:
|
|
cb_slot_1.Init ();
|
|
break;
|
|
case 2:
|
|
cb_slot_2.Init ();
|
|
break;
|
|
case 3:
|
|
cb_slot_3.Init ();
|
|
break;
|
|
case 4:
|
|
cb_slot_4.Init ();
|
|
break;
|
|
case 5:
|
|
cb_slot_5.Init ();
|
|
break;
|
|
case 6:
|
|
cb_slot_6.Init ();
|
|
break;
|
|
case 7:
|
|
cb_slot_7.Init ();
|
|
break;
|
|
default:
|
|
g_assert_not_reached ();
|
|
break;
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
static gpointer
|
|
gst_asio_object_thread_func (GstAsioObject * self)
|
|
{
|
|
HANDLE avrt_handle = nullptr;
|
|
static DWORD task_idx = 0;
|
|
HWND hwnd;
|
|
GSource *source = nullptr;
|
|
GSource *hwnd_msg_source = nullptr;
|
|
GIOChannel *msg_io_channel = nullptr;
|
|
HRESULT hr;
|
|
ASIOError asio_rst;
|
|
IASIO *asio_handle = nullptr;
|
|
GstAsioDeviceInfo *device_info = self->device_info;
|
|
/* FIXME: check more sample rate */
|
|
static ASIOSampleRate sample_rate_to_check[] = {
|
|
48000.0, 44100.0, 192000.0, 96000.0, 88200.0,
|
|
};
|
|
|
|
g_assert (device_info);
|
|
|
|
GST_INFO_OBJECT (self,
|
|
"Enter loop, ThreadingModel: %s, driver-name: %s, driver-desc: %s",
|
|
device_info->sta_model ? "STA" : "MTA",
|
|
GST_STR_NULL (device_info->driver_name),
|
|
GST_STR_NULL (device_info->driver_desc));
|
|
|
|
if (device_info->sta_model)
|
|
CoInitializeEx (NULL, COINIT_APARTMENTTHREADED);
|
|
else
|
|
CoInitializeEx (NULL, COINIT_MULTITHREADED);
|
|
|
|
/* Our thread is unlikely different from driver's working thread though,
|
|
* let's do this. It should not cause any problem */
|
|
AvSetMmThreadCharacteristicsW (L"Pro Audio", &task_idx);
|
|
g_main_context_push_thread_default (self->context);
|
|
|
|
source = g_idle_source_new ();
|
|
g_source_set_callback (source,
|
|
(GSourceFunc) gst_asio_object_main_loop_running_cb, self, nullptr);
|
|
g_source_attach (source, self->context);
|
|
g_source_unref (source);
|
|
|
|
/* XXX: not sure why ASIO API wants Windows handle for init().
|
|
* Possibly it might be used for STA COM threading
|
|
* but it's undocummented... */
|
|
hwnd = gst_asio_object_create_internal_hwnd (self);
|
|
if (!hwnd)
|
|
goto run_loop;
|
|
|
|
hr = CoCreateInstance (device_info->clsid, nullptr, CLSCTX_INPROC_SERVER,
|
|
device_info->clsid, (gpointer *) & asio_handle);
|
|
if (FAILED (hr)) {
|
|
GST_WARNING_OBJECT (self, "Failed to create IASIO instance, hr: 0x%x",
|
|
(guint) hr);
|
|
goto run_loop;
|
|
}
|
|
|
|
if (!asio_handle->init (hwnd)) {
|
|
GST_WARNING_OBJECT (self, "Failed to init IASIO instance");
|
|
asio_handle->Release ();
|
|
asio_handle = nullptr;
|
|
goto run_loop;
|
|
}
|
|
|
|
/* Query device information */
|
|
asio_rst = asio_handle->getChannels (&self->max_num_input_channels,
|
|
&self->max_num_output_channels);
|
|
if (asio_rst != 0) {
|
|
GST_WARNING_OBJECT (self, "Failed to query in/out channels, ret %ld",
|
|
asio_rst);
|
|
asio_handle->Release ();
|
|
asio_handle = nullptr;
|
|
goto run_loop;
|
|
}
|
|
|
|
GST_INFO_OBJECT (self, "Input/Output channles: %ld/%ld",
|
|
self->max_num_input_channels, self->max_num_output_channels);
|
|
|
|
asio_rst = asio_handle->getBufferSize (&self->min_buffer_size,
|
|
&self->max_buffer_size, &self->preferred_buffer_size,
|
|
&self->buffer_size_granularity);
|
|
if (asio_rst != 0) {
|
|
GST_WARNING_OBJECT (self, "Failed to get buffer size, ret %ld", asio_rst);
|
|
asio_handle->Release ();
|
|
asio_handle = nullptr;
|
|
goto run_loop;
|
|
}
|
|
|
|
/* Use preferreed buffer size by default */
|
|
self->selected_buffer_size = self->preferred_buffer_size;
|
|
|
|
GST_INFO_OBJECT (self, "min-buffer-size %ld, max-buffer-size %ld, "
|
|
"preferred-buffer-size %ld, buffer-size-granularity %ld",
|
|
self->min_buffer_size, self->max_buffer_size,
|
|
self->preferred_buffer_size, self->buffer_size_granularity);
|
|
|
|
for (guint i = 0; i < G_N_ELEMENTS (sample_rate_to_check); i++) {
|
|
asio_rst = asio_handle->canSampleRate (sample_rate_to_check[i]);
|
|
if (asio_rst != 0)
|
|
continue;
|
|
|
|
GST_INFO_OBJECT (self, "SampleRate %.1lf is supported",
|
|
sample_rate_to_check[i]);
|
|
g_array_append_val (self->supported_sample_rates, sample_rate_to_check[i]);
|
|
}
|
|
|
|
if (self->supported_sample_rates->len == 0) {
|
|
GST_WARNING_OBJECT (self, "Failed to query supported sample rate");
|
|
asio_handle->Release ();
|
|
asio_handle = nullptr;
|
|
goto run_loop;
|
|
}
|
|
|
|
/* Pick the first supported samplerate */
|
|
self->sample_rate =
|
|
g_array_index (self->supported_sample_rates, ASIOSampleRate, 0);
|
|
if (asio_handle->setSampleRate (self->sample_rate) != 0) {
|
|
GST_WARNING_OBJECT (self, "Failed to set samplerate %.1lf",
|
|
self->sample_rate);
|
|
asio_handle->Release ();
|
|
asio_handle = nullptr;
|
|
goto run_loop;
|
|
}
|
|
|
|
if (self->max_num_input_channels > 0) {
|
|
self->input_channel_infos = g_new0 (ASIOChannelInfo,
|
|
self->max_num_input_channels);
|
|
for (glong i = 0; i < self->max_num_input_channels; i++) {
|
|
ASIOChannelInfo *info = &self->input_channel_infos[i];
|
|
info->channel = i;
|
|
info->isInput = TRUE;
|
|
|
|
asio_rst = asio_handle->getChannelInfo (info);
|
|
if (asio_rst != 0) {
|
|
GST_WARNING_OBJECT (self, "Failed to %ld input channel info, ret %ld",
|
|
i, asio_rst);
|
|
asio_handle->Release ();
|
|
asio_handle = nullptr;
|
|
goto run_loop;
|
|
}
|
|
|
|
GST_INFO_OBJECT (self,
|
|
"InputChannelInfo %ld: isActive %s, channelGroup %ld, "
|
|
"ASIOSampleType %ld, name %s", i, info->isActive ? "true" : "false",
|
|
info->channelGroup, info->type, GST_STR_NULL (info->name));
|
|
}
|
|
|
|
self->input_channel_requested =
|
|
g_new0 (gboolean, self->max_num_input_channels);
|
|
}
|
|
|
|
if (self->max_num_output_channels > 0) {
|
|
self->output_channel_infos = g_new0 (ASIOChannelInfo,
|
|
self->max_num_output_channels);
|
|
for (glong i = 0; i < self->max_num_output_channels; i++) {
|
|
ASIOChannelInfo *info = &self->output_channel_infos[i];
|
|
info->channel = i;
|
|
info->isInput = FALSE;
|
|
|
|
asio_rst = asio_handle->getChannelInfo (info);
|
|
if (asio_rst != 0) {
|
|
GST_WARNING_OBJECT (self, "Failed to %ld output channel info, ret %ld",
|
|
i, asio_rst);
|
|
asio_handle->Release ();
|
|
asio_handle = nullptr;
|
|
goto run_loop;
|
|
}
|
|
|
|
GST_INFO_OBJECT (self,
|
|
"OutputChannelInfo %ld: isActive %s, channelGroup %ld, "
|
|
"ASIOSampleType %ld, name %s", i, info->isActive ? "true" : "false",
|
|
info->channelGroup, info->type, GST_STR_NULL (info->name));
|
|
}
|
|
|
|
self->output_channel_requested =
|
|
g_new0 (gboolean, self->max_num_output_channels);
|
|
}
|
|
|
|
asio_rst = asio_handle->getSampleRate (&self->sample_rate);
|
|
if (asio_rst != 0) {
|
|
GST_WARNING_OBJECT (self,
|
|
"Failed to get current samplerate, ret %ld", asio_rst);
|
|
asio_handle->Release ();
|
|
asio_handle = nullptr;
|
|
goto run_loop;
|
|
}
|
|
|
|
GST_INFO_OBJECT (self, "Current samplerate %.1lf", self->sample_rate);
|
|
|
|
self->callbacks = new GstAsioCallbacks (self);
|
|
if (!gst_asio_object_bind_callbacks (self)) {
|
|
GST_ERROR_OBJECT (self, "Failed to bind callback to slot");
|
|
delete self->callbacks;
|
|
self->callbacks = nullptr;
|
|
|
|
asio_handle->Release ();
|
|
asio_handle = nullptr;
|
|
goto run_loop;
|
|
}
|
|
|
|
msg_io_channel = g_io_channel_win32_new_messages ((guintptr) hwnd);
|
|
hwnd_msg_source = g_io_create_watch (msg_io_channel, G_IO_IN);
|
|
g_source_set_callback (hwnd_msg_source, (GSourceFunc) hwnd_msg_cb,
|
|
self->context, nullptr);
|
|
g_source_attach (hwnd_msg_source, self->context);
|
|
|
|
self->state = GST_ASIO_OBJECT_STATE_INITIALIZED;
|
|
self->asio_handle = asio_handle;
|
|
|
|
run_loop:
|
|
g_main_loop_run (self->loop);
|
|
|
|
if (self->asio_handle) {
|
|
if (self->state > GST_ASIO_OBJECT_STATE_PREPARED)
|
|
self->asio_handle->stop ();
|
|
|
|
if (self->state > GST_ASIO_OBJECT_STATE_INITIALIZED)
|
|
self->asio_handle->disposeBuffers ();
|
|
}
|
|
|
|
gst_asio_object_unbind_callbacks (self);
|
|
if (self->callbacks) {
|
|
delete self->callbacks;
|
|
self->callbacks = nullptr;
|
|
}
|
|
|
|
if (hwnd_msg_source) {
|
|
g_source_destroy (hwnd_msg_source);
|
|
g_source_unref (hwnd_msg_source);
|
|
}
|
|
|
|
if (msg_io_channel)
|
|
g_io_channel_unref (msg_io_channel);
|
|
|
|
if (hwnd)
|
|
DestroyWindow (hwnd);
|
|
|
|
g_main_context_pop_thread_default (self->context);
|
|
|
|
if (avrt_handle)
|
|
AvRevertMmThreadCharacteristics (avrt_handle);
|
|
|
|
if (asio_handle) {
|
|
asio_handle->Release ();
|
|
asio_handle = nullptr;
|
|
}
|
|
|
|
CoUninitialize ();
|
|
|
|
GST_INFO_OBJECT (self, "Exit loop");
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
static void
|
|
gst_asio_object_weak_ref_notify (gpointer data, GstAsioObject * object)
|
|
{
|
|
std::lock_guard < std::mutex > lk (global_lock);
|
|
asio_object_list = g_list_remove (asio_object_list, object);
|
|
}
|
|
|
|
GstAsioObject *
|
|
gst_asio_object_new (const GstAsioDeviceInfo * info,
|
|
gboolean occupy_all_channels)
|
|
{
|
|
GstAsioObject *self = nullptr;
|
|
GList *iter;
|
|
std::lock_guard < std::mutex > lk (global_lock);
|
|
|
|
g_return_val_if_fail (info != nullptr, nullptr);
|
|
|
|
/* Check if we have object corresponding to CLSID, and if so return
|
|
* already existing object instead of allocating new one */
|
|
for (iter = asio_object_list; iter; iter = g_list_next (iter)) {
|
|
GstAsioObject *object = (GstAsioObject *) iter->data;
|
|
|
|
if (object->device_info->clsid == info->clsid) {
|
|
GST_DEBUG_OBJECT (object, "Found configured ASIO object");
|
|
self = (GstAsioObject *) gst_object_ref (object);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (self)
|
|
return self;
|
|
|
|
self = (GstAsioObject *) g_object_new (GST_TYPE_ASIO_OBJECT,
|
|
"device-info", info, nullptr);
|
|
|
|
if (!self->asio_handle) {
|
|
GST_WARNING_OBJECT (self, "ASIO handle is not available");
|
|
gst_object_unref (self);
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
self->occupy_all_channels = occupy_all_channels;
|
|
|
|
gst_object_ref_sink (self);
|
|
|
|
g_object_weak_ref (G_OBJECT (self),
|
|
(GWeakNotify) gst_asio_object_weak_ref_notify, nullptr);
|
|
asio_object_list = g_list_append (asio_object_list, self);
|
|
|
|
return self;
|
|
}
|
|
|
|
static GstCaps *
|
|
gst_asio_object_create_caps_from_channel_info (GstAsioObject * self,
|
|
ASIOChannelInfo * info, guint min_num_channels, guint max_num_channels)
|
|
{
|
|
GstCaps *caps;
|
|
std::string caps_str;
|
|
GstAudioFormat fmt;
|
|
const gchar *fmt_str;
|
|
|
|
g_assert (info);
|
|
g_assert (max_num_channels >= min_num_channels);
|
|
|
|
fmt = gst_asio_sample_type_to_gst (info->type);
|
|
if (fmt == GST_AUDIO_FORMAT_UNKNOWN) {
|
|
GST_ERROR_OBJECT (self, "Unknown format");
|
|
return nullptr;
|
|
}
|
|
|
|
fmt_str = gst_audio_format_to_string (fmt);
|
|
|
|
/* Actually we are non-interleaved, but element will interlave data */
|
|
caps_str = "audio/x-raw, layout = (string) interleaved, ";
|
|
caps_str += "format = (string) " + std::string (fmt_str) + ", ";
|
|
/* use fixated sample rate, otherwise get_caps/set_sample_rate() might
|
|
* be racy in case that multiple sink/src are used */
|
|
caps_str +=
|
|
"rate = (int) " + std::to_string ((gint) self->sample_rate) + ", ";
|
|
|
|
if (max_num_channels == min_num_channels)
|
|
caps_str += "channels = (int) " + std::to_string (max_num_channels);
|
|
else
|
|
caps_str += "channels = (int) [ " + std::to_string (min_num_channels) +
|
|
", " + std::to_string (max_num_channels) + " ]";
|
|
|
|
caps = gst_caps_from_string (caps_str.c_str ());
|
|
if (!caps) {
|
|
GST_ERROR_OBJECT (self, "Failed to create caps");
|
|
return nullptr;
|
|
}
|
|
|
|
GST_DEBUG_OBJECT (self, "Create caps %" GST_PTR_FORMAT, caps);
|
|
|
|
return caps;
|
|
}
|
|
|
|
/* FIXME: assuming all channels has the same format but it might not be true? */
|
|
GstCaps *
|
|
gst_asio_object_get_caps (GstAsioObject * obj, GstAsioDeviceClassType type,
|
|
guint min_num_channels, guint max_num_channels)
|
|
{
|
|
ASIOChannelInfo *infos;
|
|
|
|
g_return_val_if_fail (GST_IS_ASIO_OBJECT (obj), nullptr);
|
|
|
|
if (type == GST_ASIO_DEVICE_CLASS_CAPTURE) {
|
|
if (obj->max_num_input_channels == 0) {
|
|
GST_WARNING_OBJECT (obj, "Device doesn't support input");
|
|
return nullptr;
|
|
}
|
|
|
|
/* max_num_channels == 0 means [1, max-allowed-channles] */
|
|
if (max_num_channels > 0) {
|
|
if (max_num_channels > (guint) obj->max_num_input_channels) {
|
|
GST_WARNING_OBJECT (obj, "Too many max channels");
|
|
return nullptr;
|
|
}
|
|
} else {
|
|
max_num_channels = obj->max_num_input_channels;
|
|
}
|
|
|
|
if (min_num_channels > 0) {
|
|
if (min_num_channels > (guint) obj->max_num_input_channels) {
|
|
GST_WARNING_OBJECT (obj, "Too many min channels");
|
|
return nullptr;
|
|
}
|
|
} else {
|
|
min_num_channels = 1;
|
|
}
|
|
|
|
infos = obj->input_channel_infos;
|
|
} else {
|
|
if (obj->max_num_output_channels == 0) {
|
|
GST_WARNING_OBJECT (obj, "Device doesn't support output");
|
|
return nullptr;
|
|
}
|
|
|
|
/* max_num_channels == 0 means [1, max-allowed-channles] */
|
|
if (max_num_channels > 0) {
|
|
if (max_num_channels > (guint) obj->max_num_output_channels) {
|
|
GST_WARNING_OBJECT (obj, "Too many max channels");
|
|
return nullptr;
|
|
}
|
|
} else {
|
|
max_num_channels = obj->max_num_output_channels;
|
|
}
|
|
|
|
if (min_num_channels > 0) {
|
|
if (min_num_channels > (guint) obj->max_num_output_channels) {
|
|
GST_WARNING_OBJECT (obj, "Too many min channels");
|
|
return nullptr;
|
|
}
|
|
} else {
|
|
min_num_channels = 1;
|
|
}
|
|
|
|
infos = obj->output_channel_infos;
|
|
}
|
|
|
|
return gst_asio_object_create_caps_from_channel_info (obj,
|
|
infos, min_num_channels, max_num_channels);
|
|
}
|
|
|
|
gboolean
|
|
gst_asio_object_get_max_num_channels (GstAsioObject * obj, glong * num_input_ch,
|
|
glong * num_output_ch)
|
|
{
|
|
g_return_val_if_fail (GST_IS_ASIO_OBJECT (obj), FALSE);
|
|
|
|
if (num_input_ch)
|
|
*num_input_ch = obj->max_num_input_channels;
|
|
if (num_output_ch)
|
|
*num_output_ch = obj->max_num_output_channels;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
gboolean
|
|
gst_asio_object_get_buffer_size (GstAsioObject * obj, glong * min_size,
|
|
glong * max_size, glong * preferred_size, glong * granularity)
|
|
{
|
|
g_return_val_if_fail (GST_IS_ASIO_OBJECT (obj), FALSE);
|
|
|
|
if (min_size)
|
|
*min_size = obj->min_buffer_size;
|
|
if (max_size)
|
|
*max_size = obj->max_buffer_size;
|
|
if (preferred_size)
|
|
*preferred_size = obj->preferred_buffer_size;
|
|
if (granularity)
|
|
*granularity = obj->buffer_size_granularity;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
typedef void (*GstAsioObjectThreadFunc) (GstAsioObject * obj, gpointer data);
|
|
|
|
typedef struct
|
|
{
|
|
GstAsioObject *self;
|
|
GstAsioObjectThreadFunc func;
|
|
gpointer data;
|
|
gboolean fired;
|
|
} GstAsioObjectThreadRunData;
|
|
|
|
static gboolean
|
|
gst_asio_object_thread_run_func (GstAsioObjectThreadRunData * data)
|
|
{
|
|
GstAsioObject *self = data->self;
|
|
|
|
if (data->func)
|
|
data->func (self, data->data);
|
|
|
|
g_mutex_lock (&self->thread_lock);
|
|
data->fired = TRUE;
|
|
g_cond_broadcast (&self->thread_cond);
|
|
g_mutex_unlock (&self->thread_lock);
|
|
|
|
return G_SOURCE_REMOVE;
|
|
}
|
|
|
|
static void
|
|
gst_asio_object_thread_add (GstAsioObject * self, GstAsioObjectThreadFunc func,
|
|
gpointer data)
|
|
{
|
|
GstAsioObjectThreadRunData thread_data;
|
|
|
|
g_return_if_fail (GST_IS_ASIO_OBJECT (self));
|
|
|
|
thread_data.self = self;
|
|
thread_data.func = func;
|
|
thread_data.data = data;
|
|
thread_data.fired = FALSE;
|
|
|
|
g_main_context_invoke (self->context,
|
|
(GSourceFunc) gst_asio_object_thread_run_func, &thread_data);
|
|
|
|
g_mutex_lock (&self->thread_lock);
|
|
while (!thread_data.fired)
|
|
g_cond_wait (&self->thread_cond, &self->thread_lock);
|
|
g_mutex_unlock (&self->thread_lock);
|
|
}
|
|
|
|
static gboolean
|
|
gst_asio_object_validate_channels (GstAsioObject * self, gboolean is_input,
|
|
guint * channel_indices, guint num_channels)
|
|
{
|
|
if (is_input) {
|
|
if ((guint) self->max_num_input_channels < num_channels) {
|
|
GST_WARNING_OBJECT (self, "%d exceeds max input channels %ld",
|
|
num_channels, self->max_num_input_channels);
|
|
return FALSE;
|
|
}
|
|
|
|
for (guint i = 0; i < num_channels; i++) {
|
|
guint ch = channel_indices[i];
|
|
if ((guint) self->max_num_input_channels <= ch) {
|
|
GST_WARNING_OBJECT (self, "%d exceeds max input channels %ld",
|
|
ch, self->max_num_input_channels);
|
|
|
|
return FALSE;
|
|
}
|
|
}
|
|
} else {
|
|
if ((guint) self->max_num_output_channels < num_channels) {
|
|
GST_WARNING_OBJECT (self, "%d exceeds max output channels %ld",
|
|
num_channels, self->max_num_output_channels);
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
for (guint i = 0; i < num_channels; i++) {
|
|
guint ch = channel_indices[i];
|
|
if ((guint) self->max_num_output_channels <= ch) {
|
|
GST_WARNING_OBJECT (self, "%d exceeds max output channels %ld",
|
|
ch, self->max_num_output_channels);
|
|
|
|
return FALSE;
|
|
}
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
gst_asio_object_check_buffer_reuse (GstAsioObject * self, ASIOBool is_input,
|
|
guint * channel_indices, guint num_channels)
|
|
{
|
|
guint num_found = 0;
|
|
|
|
g_assert (self->buffer_infos);
|
|
g_assert (self->num_allocated_buffers > 0);
|
|
|
|
for (guint i = 0; i < self->num_allocated_buffers; i++) {
|
|
ASIOBufferInfo *info = &self->buffer_infos[i];
|
|
|
|
if (info->isInput != is_input)
|
|
continue;
|
|
|
|
for (guint j = 0; j < num_channels; j++) {
|
|
if ((guint) info->channelNum == channel_indices[j]) {
|
|
num_found++;
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return num_found == num_channels;
|
|
}
|
|
|
|
static void
|
|
gst_asio_object_dispose_buffers_async (GstAsioObject * self, ASIOError * rst)
|
|
{
|
|
g_assert (self->asio_handle);
|
|
g_assert (rst);
|
|
|
|
*rst = self->asio_handle->disposeBuffers ();
|
|
}
|
|
|
|
static gboolean
|
|
gst_asio_object_dispose_buffers (GstAsioObject * self)
|
|
{
|
|
ASIOError rst;
|
|
g_assert (self->asio_handle);
|
|
|
|
if (!self->buffer_infos)
|
|
return TRUE;
|
|
|
|
if (!self->device_info->sta_model) {
|
|
rst = self->asio_handle->disposeBuffers ();
|
|
} else {
|
|
gst_asio_object_thread_add (self,
|
|
(GstAsioObjectThreadFunc) gst_asio_object_dispose_buffers_async, &rst);
|
|
}
|
|
|
|
g_clear_pointer (&self->buffer_infos, g_free);
|
|
self->num_allocated_buffers = 0;
|
|
|
|
return rst == 0;
|
|
}
|
|
|
|
static ASIOError
|
|
gst_asio_object_create_buffers_real (GstAsioObject * self, glong * buffer_size)
|
|
{
|
|
ASIOError err;
|
|
|
|
g_assert (buffer_size);
|
|
|
|
err = self->asio_handle->createBuffers (self->buffer_infos,
|
|
self->num_requested_input_channels + self->num_requested_output_channels,
|
|
*buffer_size, &self->driver_callbacks);
|
|
|
|
/* It failed and buffer size is not equal to preferred size,
|
|
* try again with preferred size */
|
|
if (err != 0 && *buffer_size != self->preferred_buffer_size) {
|
|
GST_WARNING_OBJECT (self,
|
|
"Failed to create buffer with buffer size %ld, try again with %ld",
|
|
*buffer_size, self->preferred_buffer_size);
|
|
|
|
err = self->asio_handle->createBuffers (self->buffer_infos,
|
|
self->num_requested_input_channels +
|
|
self->num_requested_output_channels, self->preferred_buffer_size,
|
|
&self->driver_callbacks);
|
|
|
|
if (!err) {
|
|
*buffer_size = self->preferred_buffer_size;
|
|
}
|
|
}
|
|
|
|
return err;
|
|
}
|
|
|
|
typedef struct
|
|
{
|
|
glong buffer_size;
|
|
ASIOError err;
|
|
} CreateBuffersAsyncData;
|
|
|
|
static void
|
|
gst_asio_object_create_buffers_async (GstAsioObject * self,
|
|
CreateBuffersAsyncData * data)
|
|
{
|
|
data->err = gst_asio_object_create_buffers_real (self, &data->buffer_size);
|
|
}
|
|
|
|
static gboolean
|
|
gst_asio_object_create_buffers_internal (GstAsioObject * self,
|
|
glong * buffer_size)
|
|
{
|
|
ASIOError err;
|
|
g_assert (self->asio_handle);
|
|
|
|
if (!self->device_info->sta_model) {
|
|
err = gst_asio_object_create_buffers_real (self, buffer_size);
|
|
} else {
|
|
CreateBuffersAsyncData data;
|
|
data.buffer_size = *buffer_size;
|
|
|
|
gst_asio_object_thread_add (self,
|
|
(GstAsioObjectThreadFunc) gst_asio_object_create_buffers_async, &data);
|
|
|
|
err = data.err;
|
|
*buffer_size = data.buffer_size;
|
|
}
|
|
|
|
return !err;
|
|
}
|
|
|
|
gboolean
|
|
gst_asio_object_create_buffers (GstAsioObject * obj,
|
|
GstAsioDeviceClassType type,
|
|
guint * channel_indices, guint num_channels, guint * buffer_size)
|
|
{
|
|
gboolean can_reuse = FALSE;
|
|
guint i, j;
|
|
glong buf_size;
|
|
glong prev_buf_size = 0;
|
|
gboolean is_src;
|
|
|
|
g_return_val_if_fail (GST_IS_ASIO_OBJECT (obj), FALSE);
|
|
g_return_val_if_fail (channel_indices != nullptr, FALSE);
|
|
g_return_val_if_fail (num_channels > 0, FALSE);
|
|
|
|
GST_DEBUG_OBJECT (obj, "Create buffers");
|
|
|
|
if (type == GST_ASIO_DEVICE_CLASS_CAPTURE)
|
|
is_src = TRUE;
|
|
else
|
|
is_src = FALSE;
|
|
|
|
g_mutex_lock (&obj->api_lock);
|
|
if (!gst_asio_object_validate_channels (obj, is_src, channel_indices,
|
|
num_channels)) {
|
|
GST_ERROR_OBJECT (obj, "Invalid request");
|
|
g_mutex_unlock (&obj->api_lock);
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
if (obj->buffer_infos) {
|
|
GST_DEBUG_OBJECT (obj,
|
|
"Have configured buffer infors, checking whether we can reuse it");
|
|
can_reuse = gst_asio_object_check_buffer_reuse (obj,
|
|
is_src ? TRUE : FALSE, channel_indices, num_channels);
|
|
}
|
|
|
|
if (can_reuse) {
|
|
GST_DEBUG_OBJECT (obj, "We can reuse already allocated buffers");
|
|
if (buffer_size)
|
|
*buffer_size = obj->selected_buffer_size;
|
|
|
|
g_mutex_unlock (&obj->api_lock);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/* Cannot re-allocated buffers once started... */
|
|
if (obj->state > GST_ASIO_OBJECT_STATE_PREPARED) {
|
|
GST_WARNING_OBJECT (obj, "We are running already");
|
|
g_mutex_unlock (&obj->api_lock);
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
/* Use already configured buffer size */
|
|
if (obj->buffer_infos)
|
|
prev_buf_size = obj->selected_buffer_size;
|
|
|
|
/* If we have configured buffers, dispose and re-allocate */
|
|
if (!gst_asio_object_dispose_buffers (obj)) {
|
|
GST_ERROR_OBJECT (obj, "Failed to dispose buffers");
|
|
|
|
obj->state = GST_ASIO_OBJECT_STATE_INITIALIZED;
|
|
|
|
g_mutex_unlock (&obj->api_lock);
|
|
return FALSE;
|
|
}
|
|
|
|
if (obj->occupy_all_channels) {
|
|
GST_INFO_OBJECT (obj,
|
|
"occupy-all-channels mode, will allocate buffers for all channels");
|
|
/* In this case, we will allocate buffer for all available input/output
|
|
* channles, regardless of what requested here */
|
|
for (guint i = 0; i < (guint) obj->max_num_input_channels; i++)
|
|
obj->input_channel_requested[i] = TRUE;
|
|
for (guint i = 0; i < (guint) obj->max_num_output_channels; i++)
|
|
obj->output_channel_requested[i] = TRUE;
|
|
|
|
obj->num_requested_input_channels = obj->max_num_input_channels;
|
|
obj->num_requested_output_channels = obj->max_num_output_channels;
|
|
} else {
|
|
if (is_src) {
|
|
for (guint i = 0; i < num_channels; i++) {
|
|
guint ch = channel_indices[i];
|
|
|
|
obj->input_channel_requested[ch] = TRUE;
|
|
}
|
|
|
|
obj->num_requested_input_channels = 0;
|
|
for (guint i = 0; i < (guint) obj->max_num_input_channels; i++) {
|
|
if (obj->input_channel_requested[i])
|
|
obj->num_requested_input_channels++;
|
|
}
|
|
} else {
|
|
for (guint i = 0; i < num_channels; i++) {
|
|
guint ch = channel_indices[i];
|
|
|
|
obj->output_channel_requested[ch] = TRUE;
|
|
}
|
|
|
|
obj->num_requested_output_channels = 0;
|
|
for (guint i = 0; i < (guint) obj->max_num_output_channels; i++) {
|
|
if (obj->output_channel_requested[i])
|
|
obj->num_requested_output_channels++;
|
|
}
|
|
}
|
|
}
|
|
|
|
obj->num_allocated_buffers = obj->num_requested_input_channels +
|
|
obj->num_requested_output_channels;
|
|
|
|
obj->buffer_infos = g_new0 (ASIOBufferInfo, obj->num_allocated_buffers);
|
|
for (i = 0, j = 0; i < (guint) obj->num_requested_input_channels; i++) {
|
|
ASIOBufferInfo *info = &obj->buffer_infos[i];
|
|
|
|
info->isInput = TRUE;
|
|
while (!obj->input_channel_requested[j])
|
|
j++;
|
|
|
|
info->channelNum = j;
|
|
j++;
|
|
}
|
|
|
|
for (i = obj->num_requested_input_channels, j = 0;
|
|
i < (guint)
|
|
obj->num_requested_input_channels + obj->num_requested_output_channels;
|
|
i++) {
|
|
ASIOBufferInfo *info = &obj->buffer_infos[i];
|
|
|
|
info->isInput = FALSE;
|
|
while (!obj->output_channel_requested[j])
|
|
j++;
|
|
|
|
info->channelNum = j;
|
|
j++;
|
|
}
|
|
|
|
if (prev_buf_size > 0) {
|
|
buf_size = prev_buf_size;
|
|
} else if (buffer_size && *buffer_size > 0) {
|
|
buf_size = *buffer_size;
|
|
} else {
|
|
buf_size = obj->preferred_buffer_size;
|
|
}
|
|
|
|
GST_INFO_OBJECT (obj, "Creating buffer with size %ld", buf_size);
|
|
|
|
if (!gst_asio_object_create_buffers_internal (obj, &buf_size)) {
|
|
GST_ERROR_OBJECT (obj, "Failed to create buffers");
|
|
g_clear_pointer (&obj->buffer_infos, g_free);
|
|
obj->num_allocated_buffers = 0;
|
|
|
|
obj->state = GST_ASIO_OBJECT_STATE_INITIALIZED;
|
|
|
|
g_mutex_unlock (&obj->api_lock);
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
GST_INFO_OBJECT (obj, "Selected buffer size %ld", buf_size);
|
|
|
|
obj->selected_buffer_size = buf_size;
|
|
if (buffer_size)
|
|
*buffer_size = buf_size;
|
|
|
|
obj->state = GST_ASIO_OBJECT_STATE_PREPARED;
|
|
|
|
g_mutex_unlock (&obj->api_lock);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
typedef struct
|
|
{
|
|
glong arg[4];
|
|
ASIOError ret;
|
|
} RunAsyncData;
|
|
|
|
static void
|
|
gst_asio_object_get_latencies_async (GstAsioObject * self, RunAsyncData * data)
|
|
{
|
|
data->ret = self->asio_handle->getLatencies (&data->arg[0], &data->arg[1]);
|
|
}
|
|
|
|
gboolean
|
|
gst_asio_object_get_latencies (GstAsioObject * obj, glong * input_latency,
|
|
glong * output_latency)
|
|
{
|
|
RunAsyncData data = { 0 };
|
|
ASIOError err;
|
|
|
|
g_return_val_if_fail (GST_IS_ASIO_OBJECT (obj), FALSE);
|
|
g_assert (obj->asio_handle);
|
|
|
|
if (!obj->device_info->sta_model) {
|
|
err = obj->asio_handle->getLatencies (input_latency, output_latency);
|
|
} else {
|
|
gst_asio_object_thread_add (obj,
|
|
(GstAsioObjectThreadFunc) gst_asio_object_get_latencies_async, &data);
|
|
|
|
*input_latency = data.arg[0];
|
|
*output_latency = data.arg[1];
|
|
err = data.ret;
|
|
}
|
|
|
|
return !err;
|
|
}
|
|
|
|
typedef struct
|
|
{
|
|
ASIOSampleRate sample_rate;
|
|
ASIOError err;
|
|
} SampleRateAsyncData;
|
|
|
|
static void
|
|
gst_asio_object_can_sample_rate_async (GstAsioObject * self,
|
|
SampleRateAsyncData * data)
|
|
{
|
|
data->err = self->asio_handle->canSampleRate (data->sample_rate);
|
|
}
|
|
|
|
gboolean
|
|
gst_asio_object_can_sample_rate (GstAsioObject * obj,
|
|
ASIOSampleRate sample_rate)
|
|
{
|
|
SampleRateAsyncData data = { 0 };
|
|
ASIOError err = 0;
|
|
|
|
g_return_val_if_fail (GST_IS_ASIO_OBJECT (obj), FALSE);
|
|
g_assert (obj->asio_handle);
|
|
|
|
g_mutex_lock (&obj->api_lock);
|
|
for (guint i = 0; i < obj->supported_sample_rates->len; i++) {
|
|
ASIOSampleRate val = g_array_index (obj->supported_sample_rates,
|
|
ASIOSampleRate, i);
|
|
if (val == sample_rate) {
|
|
g_mutex_unlock (&obj->api_lock);
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
if (!obj->device_info->sta_model) {
|
|
err = obj->asio_handle->canSampleRate (sample_rate);
|
|
|
|
if (!err)
|
|
g_array_append_val (obj->supported_sample_rates, sample_rate);
|
|
|
|
g_mutex_unlock (&obj->api_lock);
|
|
return !err;
|
|
}
|
|
|
|
data.sample_rate = sample_rate;
|
|
gst_asio_object_thread_add (obj,
|
|
(GstAsioObjectThreadFunc) gst_asio_object_can_sample_rate_async, &data);
|
|
|
|
if (!data.err)
|
|
g_array_append_val (obj->supported_sample_rates, sample_rate);
|
|
|
|
g_mutex_unlock (&obj->api_lock);
|
|
|
|
return !data.err;
|
|
}
|
|
|
|
gboolean
|
|
gst_asio_object_get_sample_rate (GstAsioObject * obj,
|
|
ASIOSampleRate * sample_rate)
|
|
{
|
|
g_return_val_if_fail (GST_IS_ASIO_OBJECT (obj), FALSE);
|
|
|
|
*sample_rate = obj->sample_rate;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void
|
|
gst_asio_object_set_sample_rate_async (GstAsioObject * self,
|
|
SampleRateAsyncData * data)
|
|
{
|
|
data->err = self->asio_handle->setSampleRate (data->sample_rate);
|
|
if (!data->err)
|
|
self->sample_rate = data->sample_rate;
|
|
}
|
|
|
|
gboolean
|
|
gst_asio_object_set_sample_rate (GstAsioObject * obj,
|
|
ASIOSampleRate sample_rate)
|
|
{
|
|
SampleRateAsyncData data = { 0 };
|
|
ASIOError err = 0;
|
|
|
|
g_return_val_if_fail (GST_IS_ASIO_OBJECT (obj), FALSE);
|
|
g_assert (obj->asio_handle);
|
|
|
|
g_mutex_lock (&obj->api_lock);
|
|
if (sample_rate == obj->sample_rate) {
|
|
g_mutex_unlock (&obj->api_lock);
|
|
return TRUE;
|
|
}
|
|
|
|
if (!obj->device_info->sta_model) {
|
|
err = obj->asio_handle->setSampleRate (sample_rate);
|
|
if (!err)
|
|
obj->sample_rate = sample_rate;
|
|
|
|
g_mutex_unlock (&obj->api_lock);
|
|
return !err;
|
|
}
|
|
|
|
data.sample_rate = sample_rate;
|
|
gst_asio_object_thread_add (obj,
|
|
(GstAsioObjectThreadFunc) gst_asio_object_set_sample_rate_async, &data);
|
|
g_mutex_unlock (&obj->api_lock);
|
|
|
|
return !data.err;
|
|
}
|
|
|
|
static void
|
|
gst_asio_object_buffer_switch (GstAsioObject * self,
|
|
glong index, ASIOBool process_now)
|
|
{
|
|
ASIOTime time_info;
|
|
ASIOTime *our_time_info = nullptr;
|
|
ASIOError err = 0;
|
|
|
|
memset (&time_info, 0, sizeof (ASIOTime));
|
|
|
|
err =
|
|
self->asio_handle->getSamplePosition (&time_info.timeInfo.samplePosition,
|
|
&time_info.timeInfo.systemTime);
|
|
if (!err)
|
|
our_time_info = &time_info;
|
|
|
|
gst_asio_object_buffer_switch_time_info (self,
|
|
our_time_info, index, process_now);
|
|
}
|
|
|
|
static void
|
|
gst_asio_object_sample_rate_changed (GstAsioObject * self, ASIOSampleRate rate)
|
|
{
|
|
GST_INFO_OBJECT (self, "SampleRate changed to %lf", rate);
|
|
}
|
|
|
|
static glong
|
|
gst_asio_object_messages (GstAsioObject * self,
|
|
glong selector, glong value, gpointer message, gdouble * opt)
|
|
{
|
|
GST_DEBUG_OBJECT (self, "ASIO message: %ld, %ld", selector, value);
|
|
|
|
switch (selector) {
|
|
case kAsioSelectorSupported:
|
|
if (value == kAsioResetRequest || value == kAsioEngineVersion ||
|
|
value == kAsioResyncRequest || value == kAsioLatenciesChanged ||
|
|
value == kAsioSupportsTimeCode || value == kAsioSupportsInputMonitor)
|
|
return 0;
|
|
else if (value == kAsioSupportsTimeInfo)
|
|
return 1;
|
|
GST_WARNING_OBJECT (self, "Unsupported ASIO selector: %li", value);
|
|
break;
|
|
case kAsioBufferSizeChange:
|
|
GST_WARNING_OBJECT (self,
|
|
"Unsupported ASIO message: kAsioBufferSizeChange");
|
|
break;
|
|
case kAsioResetRequest:
|
|
GST_WARNING_OBJECT (self, "Unsupported ASIO message: kAsioResetRequest");
|
|
break;
|
|
case kAsioResyncRequest:
|
|
GST_WARNING_OBJECT (self, "Unsupported ASIO message: kAsioResyncRequest");
|
|
break;
|
|
case kAsioLatenciesChanged:
|
|
GST_WARNING_OBJECT (self,
|
|
"Unsupported ASIO message: kAsioLatenciesChanged");
|
|
break;
|
|
case kAsioEngineVersion:
|
|
/* We target the ASIO v2 API, which includes ASIOOutputReady() */
|
|
return 2;
|
|
case kAsioSupportsTimeInfo:
|
|
/* We use the new time info buffer switch callback */
|
|
return 1;
|
|
case kAsioSupportsTimeCode:
|
|
/* We don't use the time code info right now */
|
|
return 0;
|
|
default:
|
|
GST_WARNING_OBJECT (self, "Unsupported ASIO message: %li, %li", selector,
|
|
value);
|
|
break;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
#define PACK_ASIO_64(v) ((v).lo | ((guint64)((v).hi) << 32))
|
|
|
|
static ASIOTime *
|
|
gst_asio_object_buffer_switch_time_info (GstAsioObject * self,
|
|
ASIOTime * time_info, glong index, ASIOBool process_now)
|
|
{
|
|
GList *iter;
|
|
|
|
if (time_info) {
|
|
guint64 pos;
|
|
guint64 system_time;
|
|
|
|
pos = PACK_ASIO_64 (time_info->timeInfo.samplePosition);
|
|
system_time = PACK_ASIO_64 (time_info->timeInfo.systemTime);
|
|
|
|
GST_TRACE_OBJECT (self, "Sample Position: %" G_GUINT64_FORMAT
|
|
", System Time: %" GST_TIME_FORMAT, pos, GST_TIME_ARGS (system_time));
|
|
}
|
|
|
|
g_mutex_lock (&self->api_lock);
|
|
if (!self->src_client_callbacks && !self->sink_client_callbacks &&
|
|
!self->loopback_client_callbacks) {
|
|
GST_WARNING_OBJECT (self, "No installed client callback");
|
|
goto out;
|
|
}
|
|
|
|
for (iter = self->src_client_callbacks; iter;) {
|
|
GstAsioObjectCallbacksPrivate *cb =
|
|
(GstAsioObjectCallbacksPrivate *) iter->data;
|
|
gboolean ret;
|
|
|
|
ret = cb->callbacks.buffer_switch (self, index, self->buffer_infos,
|
|
self->num_allocated_buffers, self->input_channel_infos,
|
|
self->output_channel_infos, self->sample_rate,
|
|
self->selected_buffer_size, time_info, cb->callbacks.user_data);
|
|
if (!ret) {
|
|
GST_INFO_OBJECT (self, "Remove callback for id %" G_GUINT64_FORMAT,
|
|
cb->callback_id);
|
|
GList *to_remove = iter;
|
|
iter = g_list_next (iter);
|
|
|
|
g_free (to_remove->data);
|
|
g_list_free (to_remove);
|
|
}
|
|
|
|
iter = g_list_next (iter);
|
|
}
|
|
|
|
for (iter = self->sink_client_callbacks; iter;) {
|
|
GstAsioObjectCallbacksPrivate *cb =
|
|
(GstAsioObjectCallbacksPrivate *) iter->data;
|
|
gboolean ret;
|
|
|
|
ret = cb->callbacks.buffer_switch (self, index, self->buffer_infos,
|
|
self->num_allocated_buffers, self->input_channel_infos,
|
|
self->output_channel_infos, self->sample_rate,
|
|
self->selected_buffer_size, time_info, cb->callbacks.user_data);
|
|
if (!ret) {
|
|
GST_INFO_OBJECT (self, "Remove callback for id %" G_GUINT64_FORMAT,
|
|
cb->callback_id);
|
|
GList *to_remove = iter;
|
|
iter = g_list_next (iter);
|
|
|
|
g_free (to_remove->data);
|
|
g_list_free (to_remove);
|
|
}
|
|
|
|
iter = g_list_next (iter);
|
|
}
|
|
|
|
for (iter = self->loopback_client_callbacks; iter;) {
|
|
GstAsioObjectCallbacksPrivate *cb =
|
|
(GstAsioObjectCallbacksPrivate *) iter->data;
|
|
gboolean ret;
|
|
|
|
ret = cb->callbacks.buffer_switch (self, index, self->buffer_infos,
|
|
self->num_allocated_buffers, self->input_channel_infos,
|
|
self->output_channel_infos, self->sample_rate,
|
|
self->selected_buffer_size, time_info, cb->callbacks.user_data);
|
|
if (!ret) {
|
|
GST_INFO_OBJECT (self, "Remove callback for id %" G_GUINT64_FORMAT,
|
|
cb->callback_id);
|
|
GList *to_remove = iter;
|
|
iter = g_list_next (iter);
|
|
|
|
g_free (to_remove->data);
|
|
g_list_free (to_remove);
|
|
}
|
|
|
|
iter = g_list_next (iter);
|
|
}
|
|
|
|
self->asio_handle->outputReady ();
|
|
|
|
out:
|
|
g_mutex_unlock (&self->api_lock);
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
static void
|
|
gst_asio_object_start_async (GstAsioObject * self, ASIOError * rst)
|
|
{
|
|
*rst = self->asio_handle->start ();
|
|
}
|
|
|
|
gboolean
|
|
gst_asio_object_start (GstAsioObject * obj)
|
|
{
|
|
ASIOError ret;
|
|
|
|
g_return_val_if_fail (GST_IS_ASIO_OBJECT (obj), FALSE);
|
|
|
|
g_mutex_lock (&obj->api_lock);
|
|
if (obj->state > GST_ASIO_OBJECT_STATE_PREPARED) {
|
|
GST_DEBUG_OBJECT (obj, "We are running already");
|
|
g_mutex_unlock (&obj->api_lock);
|
|
|
|
return TRUE;
|
|
} else if (obj->state < GST_ASIO_OBJECT_STATE_PREPARED) {
|
|
GST_ERROR_OBJECT (obj, "We are not prepared");
|
|
g_mutex_unlock (&obj->api_lock);
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
/* Then start */
|
|
if (!obj->device_info->sta_model) {
|
|
ret = obj->asio_handle->start ();
|
|
} else {
|
|
gst_asio_object_thread_add (obj,
|
|
(GstAsioObjectThreadFunc) gst_asio_object_start_async, &ret);
|
|
}
|
|
|
|
if (ret != 0) {
|
|
GST_ERROR_OBJECT (obj, "Failed to start object");
|
|
g_mutex_unlock (&obj->api_lock);
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
obj->state = GST_ASIO_OBJECT_STATE_RUNNING;
|
|
g_mutex_unlock (&obj->api_lock);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
gboolean
|
|
gst_asio_object_install_callback (GstAsioObject * obj,
|
|
GstAsioDeviceClassType type,
|
|
GstAsioObjectCallbacks * callbacks, guint64 * callback_id)
|
|
{
|
|
GstAsioObjectCallbacksPrivate *cb;
|
|
|
|
g_return_val_if_fail (GST_IS_ASIO_OBJECT (obj), FALSE);
|
|
g_return_val_if_fail (callbacks != nullptr, FALSE);
|
|
g_return_val_if_fail (callback_id != nullptr, FALSE);
|
|
|
|
g_mutex_lock (&obj->api_lock);
|
|
cb = g_new0 (GstAsioObjectCallbacksPrivate, 1);
|
|
cb->callbacks = *callbacks;
|
|
cb->callback_id = obj->next_callback_id;
|
|
|
|
switch (type) {
|
|
case GST_ASIO_DEVICE_CLASS_CAPTURE:
|
|
obj->src_client_callbacks = g_list_append (obj->src_client_callbacks, cb);
|
|
break;
|
|
case GST_ASIO_DEVICE_CLASS_RENDER:
|
|
obj->sink_client_callbacks =
|
|
g_list_append (obj->sink_client_callbacks, cb);
|
|
break;
|
|
case GST_ASIO_DEVICE_CLASS_LOOPBACK_CAPTURE:
|
|
obj->loopback_client_callbacks =
|
|
g_list_append (obj->loopback_client_callbacks, cb);
|
|
break;
|
|
default:
|
|
g_assert_not_reached ();
|
|
g_free (cb);
|
|
return FALSE;
|
|
}
|
|
|
|
*callback_id = cb->callback_id;
|
|
g_mutex_unlock (&obj->api_lock);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
void
|
|
gst_asio_object_uninstall_callback (GstAsioObject * obj, guint64 callback_id)
|
|
{
|
|
GList *iter;
|
|
|
|
g_return_if_fail (GST_IS_ASIO_OBJECT (obj));
|
|
|
|
g_mutex_lock (&obj->api_lock);
|
|
|
|
GST_DEBUG_OBJECT (obj, "Removing callback id %" G_GUINT64_FORMAT,
|
|
callback_id);
|
|
|
|
for (iter = obj->src_client_callbacks; iter; iter = g_list_next (iter)) {
|
|
GstAsioObjectCallbacksPrivate *cb =
|
|
(GstAsioObjectCallbacksPrivate *) iter->data;
|
|
|
|
if (cb->callback_id != callback_id)
|
|
continue;
|
|
|
|
GST_DEBUG_OBJECT (obj, "Found src callback for id %" G_GUINT64_FORMAT,
|
|
callback_id);
|
|
|
|
obj->src_client_callbacks =
|
|
g_list_remove_link (obj->src_client_callbacks, iter);
|
|
g_free (iter->data);
|
|
g_list_free (iter);
|
|
g_mutex_unlock (&obj->api_lock);
|
|
|
|
return;
|
|
}
|
|
|
|
for (iter = obj->sink_client_callbacks; iter; iter = g_list_next (iter)) {
|
|
GstAsioObjectCallbacksPrivate *cb =
|
|
(GstAsioObjectCallbacksPrivate *) iter->data;
|
|
|
|
if (cb->callback_id != callback_id)
|
|
continue;
|
|
|
|
GST_DEBUG_OBJECT (obj, "Found sink callback for id %" G_GUINT64_FORMAT,
|
|
callback_id);
|
|
|
|
obj->sink_client_callbacks =
|
|
g_list_remove_link (obj->sink_client_callbacks, iter);
|
|
g_free (iter->data);
|
|
g_list_free (iter);
|
|
g_mutex_unlock (&obj->api_lock);
|
|
|
|
return;
|
|
}
|
|
|
|
for (iter = obj->loopback_client_callbacks; iter; iter = g_list_next (iter)) {
|
|
GstAsioObjectCallbacksPrivate *cb =
|
|
(GstAsioObjectCallbacksPrivate *) iter->data;
|
|
|
|
if (cb->callback_id != callback_id)
|
|
continue;
|
|
|
|
GST_DEBUG_OBJECT (obj, "Found loopback callback for id %" G_GUINT64_FORMAT,
|
|
callback_id);
|
|
|
|
obj->loopback_client_callbacks =
|
|
g_list_remove_link (obj->loopback_client_callbacks, iter);
|
|
g_free (iter->data);
|
|
g_list_free (iter);
|
|
break;
|
|
}
|
|
|
|
g_mutex_unlock (&obj->api_lock);
|
|
}
|