mirror of
https://gitlab.freedesktop.org/gstreamer/gstreamer.git
synced 2024-09-09 05:38:58 +00:00
Right now this only works for video. An attempt was made at adding monitoring following the example winks, but it seems the only devices that can be easily detected are KS sources, which winks already handles.
310 lines
8.7 KiB
C++
310 lines
8.7 KiB
C++
/* GStreamer
|
|
* Copyright (C) 2018 Joshua M. Doe <oss@nvl.army.mil>
|
|
*
|
|
* dshowdeviceprovider.cpp: DirectShow device probing
|
|
*
|
|
* 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., 59 Temple Place - Suite 330,
|
|
* Boston, MA 02111-1307, USA.
|
|
*/
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
#include "config.h"
|
|
#endif
|
|
|
|
#include "gstdshow.h"
|
|
#include "gstdshowvideosrc.h"
|
|
#include "dshowdeviceprovider.h"
|
|
|
|
#include <gst/gst.h>
|
|
|
|
#include <windows.h>
|
|
|
|
GST_DEBUG_CATEGORY_EXTERN (dshowsrcwrapper_debug);
|
|
#define GST_CAT_DEFAULT dshowsrcwrapper_debug
|
|
|
|
|
|
static GstDevice *gst_dshow_device_new (guint id,
|
|
const gchar * device_name, GstCaps * caps, const gchar * device_path,
|
|
GstDshowDeviceType type);
|
|
|
|
G_DEFINE_TYPE (GstDshowDeviceProvider, gst_dshow_device_provider,
|
|
GST_TYPE_DEVICE_PROVIDER);
|
|
|
|
static void gst_dshow_device_provider_dispose (GObject * gobject);
|
|
|
|
static GList *gst_dshow_device_provider_probe (GstDeviceProvider * provider);
|
|
static gboolean gst_dshow_device_provider_start (GstDeviceProvider * provider);
|
|
static void gst_dshow_device_provider_stop (GstDeviceProvider * provider);
|
|
|
|
static void
|
|
gst_dshow_device_provider_class_init (GstDshowDeviceProviderClass * klass)
|
|
{
|
|
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
|
|
GstDeviceProviderClass *dm_class = GST_DEVICE_PROVIDER_CLASS (klass);
|
|
|
|
gobject_class->dispose = gst_dshow_device_provider_dispose;
|
|
|
|
dm_class->probe = gst_dshow_device_provider_probe;
|
|
dm_class->start = gst_dshow_device_provider_start;
|
|
dm_class->stop = gst_dshow_device_provider_stop;
|
|
|
|
gst_device_provider_class_set_static_metadata (dm_class,
|
|
"DirectShow Device Provider", "Source/Audio/Video",
|
|
"List and provide DirectShow source devices",
|
|
"Руслан Ижбулатов <lrn1986@gmail.com>");
|
|
}
|
|
|
|
static void
|
|
gst_dshow_device_provider_init (GstDshowDeviceProvider * self)
|
|
{
|
|
CoInitializeEx (NULL, COINIT_MULTITHREADED);
|
|
}
|
|
|
|
static void
|
|
gst_dshow_device_provider_dispose (GObject * gobject)
|
|
{
|
|
CoUninitialize ();
|
|
}
|
|
|
|
static GstDevice *
|
|
new_video_source (const DshowDeviceEntry * info)
|
|
{
|
|
g_assert (info && info->device != NULL);
|
|
|
|
return gst_dshow_device_new (info->device_index, info->device_name,
|
|
info->caps, info->device, GST_DSHOW_DEVICE_TYPE_VIDEO_SOURCE);
|
|
}
|
|
|
|
static GList *
|
|
gst_dshow_device_provider_probe (GstDeviceProvider * provider)
|
|
{
|
|
/*GstDshowDeviceProvider *self = GST_DSHOW_DEVICE_PROVIDER (provider); */
|
|
GList *devices, *cur;
|
|
GList *result;
|
|
|
|
result = NULL;
|
|
|
|
devices = gst_dshow_enumerate_devices (&CLSID_VideoInputDeviceCategory, TRUE);
|
|
if (devices == NULL)
|
|
return result;
|
|
|
|
/* TODO: try and sort camera first like ksvideosrc? */
|
|
|
|
for (cur = devices; cur != NULL; cur = cur->next) {
|
|
GstDevice *source;
|
|
DshowDeviceEntry *entry = (DshowDeviceEntry *) cur->data;
|
|
|
|
source = new_video_source (entry);
|
|
if (source)
|
|
result = g_list_prepend (result, gst_object_ref_sink (source));
|
|
}
|
|
|
|
result = g_list_reverse (result);
|
|
|
|
gst_dshow_device_list_free (devices);
|
|
|
|
return result;
|
|
}
|
|
|
|
static gboolean
|
|
gst_dshow_device_provider_start (GstDeviceProvider * provider)
|
|
{
|
|
GList *devs;
|
|
GList *dev;
|
|
GstDshowDeviceProvider *self = GST_DSHOW_DEVICE_PROVIDER (provider);
|
|
|
|
devs = gst_dshow_device_provider_probe (provider);
|
|
for (dev = devs; dev; dev = dev->next) {
|
|
if (dev->data)
|
|
gst_device_provider_device_add (provider, (GstDevice *) dev->data);
|
|
}
|
|
g_list_free (devs);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static void
|
|
gst_dshow_device_provider_stop (GstDeviceProvider * provider)
|
|
{
|
|
|
|
}
|
|
|
|
enum
|
|
{
|
|
PROP_0,
|
|
PROP_DEVICE,
|
|
PROP_DEVICE_NAME,
|
|
PROP_DEVICE_INDEX
|
|
};
|
|
|
|
G_DEFINE_TYPE (GstDshowDevice, gst_dshow_device, GST_TYPE_DEVICE);
|
|
|
|
static void gst_dshow_device_get_property (GObject * object, guint prop_id,
|
|
GValue * value, GParamSpec * pspec);
|
|
static void gst_dshow_device_set_property (GObject * object, guint prop_id,
|
|
const GValue * value, GParamSpec * pspec);
|
|
static void gst_dshow_device_finalize (GObject * object);
|
|
static GstElement *gst_dshow_device_create_element (GstDevice * device,
|
|
const gchar * name);
|
|
|
|
static void
|
|
gst_dshow_device_class_init (GstDshowDeviceClass * klass)
|
|
{
|
|
GstDeviceClass *dev_class = GST_DEVICE_CLASS (klass);
|
|
GObjectClass *object_class = G_OBJECT_CLASS (klass);
|
|
|
|
dev_class->create_element = gst_dshow_device_create_element;
|
|
|
|
object_class->get_property = gst_dshow_device_get_property;
|
|
object_class->set_property = gst_dshow_device_set_property;
|
|
object_class->finalize = gst_dshow_device_finalize;
|
|
|
|
g_object_class_install_property (object_class, PROP_DEVICE,
|
|
g_param_spec_string ("device", "Device",
|
|
"DirectShow device path (@..classID/name)", "",
|
|
(GParamFlags) (G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE |
|
|
G_PARAM_CONSTRUCT_ONLY)));
|
|
|
|
g_object_class_install_property (object_class, PROP_DEVICE_NAME,
|
|
g_param_spec_string ("device-name", "Device name",
|
|
"Human-readable name of the audio/video device", "",
|
|
(GParamFlags) (G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE |
|
|
G_PARAM_CONSTRUCT_ONLY)));
|
|
|
|
g_object_class_install_property (object_class, PROP_DEVICE_INDEX,
|
|
g_param_spec_int ("device-index", "Device index",
|
|
"Index of the enumerated audio/video device", 0, G_MAXINT, 0,
|
|
(GParamFlags) (G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE |
|
|
G_PARAM_CONSTRUCT_ONLY)));
|
|
}
|
|
|
|
static void
|
|
gst_dshow_device_init (GstDshowDevice * device)
|
|
{
|
|
}
|
|
|
|
static void
|
|
gst_dshow_device_finalize (GObject * object)
|
|
{
|
|
GstDshowDevice *device = GST_DSHOW_DEVICE (object);
|
|
|
|
g_free (device->device);
|
|
g_free (device->device_name);
|
|
|
|
G_OBJECT_CLASS (gst_dshow_device_parent_class)->finalize (object);
|
|
}
|
|
|
|
static GstElement *
|
|
gst_dshow_device_create_element (GstDevice * device, const gchar * name)
|
|
{
|
|
GstDshowDevice *dev = GST_DSHOW_DEVICE (device);
|
|
GstElement *elem;
|
|
|
|
elem = gst_element_factory_make (dev->element, name);
|
|
g_object_set (elem, "device", dev->device, NULL);
|
|
g_object_set (elem, "device-name", dev->device_name, NULL);
|
|
|
|
return elem;
|
|
}
|
|
|
|
|
|
static GstDevice *
|
|
gst_dshow_device_new (guint device_index, const gchar * device_name,
|
|
GstCaps * caps, const gchar * device_path, GstDshowDeviceType type)
|
|
{
|
|
GstDshowDevice *gstdev;
|
|
const gchar *element = NULL;
|
|
const gchar *klass = NULL;
|
|
|
|
g_return_val_if_fail (device_name, NULL);
|
|
g_return_val_if_fail (device_path, NULL);
|
|
g_return_val_if_fail (caps, NULL);
|
|
|
|
switch (type) {
|
|
case GST_DSHOW_DEVICE_TYPE_VIDEO_SOURCE:
|
|
element = "dshowvideosrc";
|
|
klass = "Video/Source";
|
|
break;
|
|
case GST_DSHOW_DEVICE_TYPE_AUDIO_SOURCE:
|
|
element = "dshowaudiosrc";
|
|
klass = "Audio/Source";
|
|
break;
|
|
default:
|
|
g_assert_not_reached ();
|
|
break;
|
|
}
|
|
|
|
/* set props of parent device class */
|
|
gstdev = (GstDshowDevice *) g_object_new (GST_TYPE_DSHOW_DEVICE,
|
|
"display-name", device_name, "caps", caps, "device-class", klass, NULL);
|
|
|
|
gstdev->type = type;
|
|
gstdev->device = g_strdup (device_path);
|
|
gstdev->device_name = g_strdup (device_name);
|
|
gstdev->device_index = device_index;
|
|
gstdev->element = element;
|
|
|
|
return GST_DEVICE (gstdev);
|
|
}
|
|
|
|
|
|
static void
|
|
gst_dshow_device_get_property (GObject * object, guint prop_id,
|
|
GValue * value, GParamSpec * pspec)
|
|
{
|
|
GstDshowDevice *device;
|
|
|
|
device = GST_DSHOW_DEVICE_CAST (object);
|
|
|
|
switch (prop_id) {
|
|
case PROP_DEVICE:
|
|
g_value_set_string (value, device->device);
|
|
break;
|
|
case PROP_DEVICE_NAME:
|
|
g_value_set_string (value, device->device_name);
|
|
break;
|
|
case PROP_DEVICE_INDEX:
|
|
g_value_set_int (value, device->device_index);
|
|
break;
|
|
default:
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
static void
|
|
gst_dshow_device_set_property (GObject * object, guint prop_id,
|
|
const GValue * value, GParamSpec * pspec)
|
|
{
|
|
GstDshowDevice *device;
|
|
|
|
device = GST_DSHOW_DEVICE_CAST (object);
|
|
|
|
switch (prop_id) {
|
|
case PROP_DEVICE:
|
|
device->device = g_value_dup_string (value);
|
|
break;
|
|
case PROP_DEVICE_NAME:
|
|
device->device_name = g_value_dup_string (value);
|
|
break;
|
|
case PROP_DEVICE_INDEX:
|
|
device->device_index = g_value_get_int (value);
|
|
break;
|
|
default:
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
|
|
break;
|
|
}
|
|
}
|