gstreamer/subprojects/gst-plugins-bad/sys/mediafoundation/gstmfsourceobject.cpp
Seungha Yang 4b05736c63 mfvideosrc: Add support for DirectShow capture filter
Adding DirecShow video capture filter mode, in addition
to existing MediaFoundation and WinRT(UWP) mode, to support
DirectShow only filters (not KS driver compatible)
such as custom virtual camera filters.

Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/3350>
2022-11-08 01:33:14 +09:00

458 lines
12 KiB
C++

/* GStreamer
* Copyright (C) 2019 Seungha Yang <seungha.yang@navercorp.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 "gstmfconfig.h"
#include "gstmfsourceobject.h"
#if GST_MF_WINAPI_APP
#include "gstmfcapturewinrt.h"
#endif
#if GST_MF_WINAPI_DESKTOP
#include "gstmfsourcereader.h"
#endif
GST_DEBUG_CATEGORY_EXTERN (gst_mf_source_object_debug);
#define GST_CAT_DEFAULT gst_mf_source_object_debug
enum
{
PROP_0,
PROP_DEVICE_PATH,
PROP_DEVICE_NAME,
PROP_DEVICE_INDEX,
PROP_SOURCE_TYPE,
};
#define DEFAULT_DEVICE_PATH nullptr
#define DEFAULT_DEVICE_NAME nullptr
#define DEFAULT_DEVICE_INDEX -1
#define DEFAULT_SOURCE_TYPE GST_MF_SOURCE_TYPE_VIDEO
GType
gst_mf_source_type_get_type (void)
{
static GType source_type = 0;
static const GEnumValue source_types[] = {
{GST_MF_SOURCE_TYPE_VIDEO, "Video", "video"},
{0, nullptr, nullptr}
};
if (!source_type) {
source_type = g_enum_register_static ("GstMFSourceMode", source_types);
}
return source_type;
}
static void gst_mf_source_object_finalize (GObject * object);
static void gst_mf_source_object_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec);
static void gst_mf_source_object_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec);
#define gst_mf_source_object_parent_class parent_class
G_DEFINE_ABSTRACT_TYPE (GstMFSourceObject, gst_mf_source_object,
GST_TYPE_OBJECT);
static void
gst_mf_source_object_class_init (GstMFSourceObjectClass * klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
GParamFlags flags =
(GParamFlags) (G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY |
G_PARAM_STATIC_STRINGS);
gobject_class->finalize = gst_mf_source_object_finalize;
gobject_class->get_property = gst_mf_source_object_get_property;
gobject_class->set_property = gst_mf_source_object_set_property;
g_object_class_install_property (gobject_class, PROP_DEVICE_PATH,
g_param_spec_string ("device-path", "Device Path",
"The device path", DEFAULT_DEVICE_PATH, flags));
g_object_class_install_property (gobject_class, PROP_DEVICE_NAME,
g_param_spec_string ("device-name", "Device Name",
"The human-readable device name", DEFAULT_DEVICE_NAME, 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,
flags));
g_object_class_install_property (gobject_class, PROP_SOURCE_TYPE,
g_param_spec_enum ("source-type", "Source Type",
"Source Type", GST_TYPE_MF_SOURCE_TYPE, DEFAULT_SOURCE_TYPE, flags));
}
static void
gst_mf_source_object_init (GstMFSourceObject * self)
{
self->device_index = DEFAULT_DEVICE_INDEX;
self->source_type = DEFAULT_SOURCE_TYPE;
g_weak_ref_init (&self->client, nullptr);
}
static void
gst_mf_source_object_finalize (GObject * object)
{
GstMFSourceObject *self = GST_MF_SOURCE_OBJECT (object);
g_free (self->device_path);
g_free (self->device_name);
g_weak_ref_clear (&self->client);
G_OBJECT_CLASS (parent_class)->finalize (object);
}
static void
gst_mf_source_object_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec)
{
GstMFSourceObject *self = GST_MF_SOURCE_OBJECT (object);
switch (prop_id) {
case PROP_DEVICE_PATH:
g_value_set_string (value, self->device_path);
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_SOURCE_TYPE:
g_value_set_enum (value, self->source_type);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
gst_mf_source_object_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec)
{
GstMFSourceObject *self = GST_MF_SOURCE_OBJECT (object);
switch (prop_id) {
case PROP_DEVICE_PATH:
g_free (self->device_path);
self->device_path = 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_SOURCE_TYPE:
self->source_type = (GstMFSourceType) g_value_get_enum (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
gboolean
gst_mf_source_object_start (GstMFSourceObject * object)
{
GstMFSourceObjectClass *klass;
g_return_val_if_fail (GST_IS_MF_SOURCE_OBJECT (object), FALSE);
klass = GST_MF_SOURCE_OBJECT_GET_CLASS (object);
g_assert (klass->start != nullptr);
return klass->start (object);
}
gboolean
gst_mf_source_object_stop (GstMFSourceObject * object)
{
GstMFSourceObjectClass *klass;
g_return_val_if_fail (GST_IS_MF_SOURCE_OBJECT (object), FALSE);
klass = GST_MF_SOURCE_OBJECT_GET_CLASS (object);
g_assert (klass->stop != nullptr);
return klass->stop (object);
}
GstFlowReturn
gst_mf_source_object_fill (GstMFSourceObject * object, GstBuffer * buffer)
{
GstMFSourceObjectClass *klass;
g_return_val_if_fail (GST_IS_MF_SOURCE_OBJECT (object), GST_FLOW_ERROR);
g_return_val_if_fail (GST_IS_BUFFER (buffer), GST_FLOW_ERROR);
klass = GST_MF_SOURCE_OBJECT_GET_CLASS (object);
g_assert (klass->fill != nullptr);
return klass->fill (object, buffer);
}
GstFlowReturn
gst_mf_source_object_create (GstMFSourceObject * object, GstBuffer ** buffer)
{
GstMFSourceObjectClass *klass;
g_return_val_if_fail (GST_IS_MF_SOURCE_OBJECT (object), GST_FLOW_ERROR);
g_return_val_if_fail (buffer != nullptr, GST_FLOW_ERROR);
klass = GST_MF_SOURCE_OBJECT_GET_CLASS (object);
g_assert (klass->create != nullptr);
return klass->create (object, buffer);
}
GstFlowReturn
gst_mf_source_object_get_sample (GstMFSourceObject * object,
GstSample ** sample)
{
GstMFSourceObjectClass *klass;
g_return_val_if_fail (GST_IS_MF_SOURCE_OBJECT (object), GST_FLOW_ERROR);
g_return_val_if_fail (sample != nullptr, GST_FLOW_ERROR);
klass = GST_MF_SOURCE_OBJECT_GET_CLASS (object);
g_assert (klass->get_sample != nullptr);
return klass->get_sample (object, sample);
}
void
gst_mf_source_object_set_flushing (GstMFSourceObject * object,
gboolean flushing)
{
GstMFSourceObjectClass *klass;
g_return_if_fail (GST_IS_MF_SOURCE_OBJECT (object));
klass = GST_MF_SOURCE_OBJECT_GET_CLASS (object);
if (flushing) {
if (klass->unlock)
klass->unlock (object);
} else {
if (klass->unlock_stop)
klass->unlock_stop (object);
}
}
gboolean
gst_mf_source_object_set_caps (GstMFSourceObject * object, GstCaps * caps)
{
GstMFSourceObjectClass *klass;
g_return_val_if_fail (GST_IS_MF_SOURCE_OBJECT (object), FALSE);
klass = GST_MF_SOURCE_OBJECT_GET_CLASS (object);
g_assert (klass->set_caps != nullptr);
return klass->set_caps (object, caps);
}
GstCaps *
gst_mf_source_object_get_caps (GstMFSourceObject * object)
{
GstMFSourceObjectClass *klass;
g_return_val_if_fail (GST_IS_MF_SOURCE_OBJECT (object), nullptr);
klass = GST_MF_SOURCE_OBJECT_GET_CLASS (object);
g_assert (klass->get_caps != nullptr);
return klass->get_caps (object);
}
gboolean
gst_mf_source_object_set_client (GstMFSourceObject * object,
GstElement * client)
{
g_return_val_if_fail (GST_IS_MF_SOURCE_OBJECT (object), FALSE);
g_weak_ref_set (&object->client, client);
return TRUE;
}
GstClockTime
gst_mf_source_object_get_running_time (GstMFSourceObject * object)
{
GstElement *client = nullptr;
GstClockTime timestamp = GST_CLOCK_TIME_NONE;
g_return_val_if_fail (GST_IS_MF_SOURCE_OBJECT (object), GST_CLOCK_TIME_NONE);
client = (GstElement *) g_weak_ref_get (&object->client);
if (client) {
GstClockTime basetime = client->base_time;
GstClock *clock;
clock = gst_element_get_clock (client);
if (clock) {
GstClockTime now;
now = gst_clock_get_time (clock);
timestamp = now - basetime;
gst_object_unref (clock);
}
gst_object_unref (client);
}
return timestamp;
}
static gboolean
gst_mf_source_object_use_winrt_api (void)
{
static gsize check_once = 0;
static gboolean ret = FALSE;
if (g_once_init_enter (&check_once)) {
#if (!GST_MF_WINAPI_APP)
/* WinRT is not supported, always false */
ret = FALSE;
#else
#if (!GST_MF_WINAPI_DESKTOP)
/* WinRT is supported but desktop API was disabled,
* always true */
ret = TRUE;
#else
/* Both app and desktop APIs were enabled, check user choice */
{
const gchar *env;
env = g_getenv ("GST_USE_MF_WINRT_CAPTURE");
if (env && g_str_has_prefix (env, "1"))
ret = TRUE;
else
ret = FALSE;
}
#endif
#endif
g_once_init_leave (&check_once, 1);
}
return ret;
}
GstMFSourceObject *
gst_mf_source_object_new (GstMFSourceType type, gint device_index,
const gchar * device_name, const gchar * device_path, gpointer dispatcher)
{
#if (!GST_MF_WINAPI_APP)
GST_INFO ("Try IMFSourceReader implementation");
return gst_mf_source_reader_new (type,
device_index, device_name, device_path);
#else
#if (!GST_MF_WINAPI_DESKTOP)
GST_INFO ("Try WinRT implementation");
return gst_mf_capture_winrt_new (type,
device_index, device_name, device_path, dispatcher);
#else
if (gst_mf_source_object_use_winrt_api ()) {
GST_INFO ("Both Desktop and WinRT APIs were enabled, user choice: WinRT");
return gst_mf_capture_winrt_new (type,
device_index, device_name, device_path, dispatcher);
} else {
GST_INFO
("Both Desktop and WinRT APIs were enabled, default: IMFSourceReader");
return gst_mf_source_reader_new (type,
device_index, device_name, device_path);
}
#endif
#endif
g_assert_not_reached ();
return nullptr;
}
gint
gst_mf_source_object_caps_compare (GstCaps * caps1, GstCaps * caps2)
{
GstStructure *s1, *s2;
const gchar *n1, *n2;
gboolean m1_is_raw, m2_is_raw;
gint w1 = 0, h1 = 0, w2 = 0, h2 = 0;
gint r1, r2;
gint num1 = 0, den1 = 1, num2 = 0, den2 = 1;
gint fraction_cmp;
/* sorting priority
* - raw video > comprssed
* - raw video format
* - higher resolution
* - higher framerate
*/
s1 = gst_caps_get_structure (caps1, 0);
n1 = gst_structure_get_name (s1);
s2 = gst_caps_get_structure (caps2, 0);
n2 = gst_structure_get_name (s2);
m1_is_raw = g_strcmp0 (n1, "video/x-raw") == 0;
m2_is_raw = g_strcmp0 (n2, "video/x-raw") == 0;
if (m1_is_raw && !m2_is_raw)
return -1;
else if (!m1_is_raw && m2_is_raw)
return 1;
/* if both are raw formats */
if (m1_is_raw) {
gint format_cmp = g_strcmp0 (gst_structure_get_string (s1, "format"),
gst_structure_get_string (s2, "format"));
if (format_cmp)
return format_cmp;
}
/* resolution */
gst_structure_get_int (s1, "width", &w1);
gst_structure_get_int (s1, "height", &h1);
gst_structure_get_int (s2, "width", &w2);
gst_structure_get_int (s2, "height", &h2);
r1 = w1 * h1;
r2 = w2 * h2;
/* higher resolution first */
if (r1 != r2)
return r2 - r1;
gst_structure_get_fraction (s1, "framerate", &num1, &den1);
gst_structure_get_fraction (s2, "framerate", &num2, &den2);
fraction_cmp = gst_util_fraction_compare (num1, den1, num2, den2);
/* higher framerate first */
return fraction_cmp * -1;
}