mirror of
https://gitlab.freedesktop.org/gstreamer/gstreamer.git
synced 2024-09-09 05:38:58 +00:00
1566 lines
47 KiB
C
1566 lines
47 KiB
C
/* GStreamer
|
|
*
|
|
* Copyright 2007-2008 Collabora Ltd
|
|
* @author: Olivier Crete <olivier.crete@collabora.co.uk>
|
|
* Copyright 2007-2008 Nokia
|
|
*
|
|
* 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.
|
|
*/
|
|
/**
|
|
* SECTION:element-autoconvert
|
|
*
|
|
* The #autoconvert element has one sink and one source pad. It will look for
|
|
* other elements that also have one sink and one source pad.
|
|
* It will then pick an element that matches the caps on both sides.
|
|
* If the caps change, it may change the selected element if the current one
|
|
* no longer matches the caps.
|
|
*
|
|
* The list of element it will look into can be specified in the
|
|
* #GstAutoConvert::factories property, otherwise it will look at all available
|
|
* elements.
|
|
*/
|
|
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
#include "config.h"
|
|
#endif
|
|
|
|
#include "gstautoconvert.h"
|
|
|
|
#include <string.h>
|
|
|
|
GST_DEBUG_CATEGORY (autoconvert_debug);
|
|
#define GST_CAT_DEFAULT (autoconvert_debug)
|
|
|
|
#define DEFAULT_INITIAL_IDENTITY FALSE
|
|
|
|
#define GST_AUTOCONVERT_LOCK(ac) GST_OBJECT_LOCK (ac)
|
|
#define GST_AUTOCONVERT_UNLOCK(ac) GST_OBJECT_UNLOCK (ac)
|
|
|
|
/* elementfactory information */
|
|
static GstStaticPadTemplate sinktemplate = GST_STATIC_PAD_TEMPLATE ("sink",
|
|
GST_PAD_SINK,
|
|
GST_PAD_ALWAYS,
|
|
GST_STATIC_CAPS_ANY);
|
|
|
|
static GstStaticPadTemplate srctemplate = GST_STATIC_PAD_TEMPLATE ("src",
|
|
GST_PAD_SRC,
|
|
GST_PAD_ALWAYS,
|
|
GST_STATIC_CAPS_ANY);
|
|
|
|
static GstStaticPadTemplate sink_internal_template =
|
|
GST_STATIC_PAD_TEMPLATE ("sink_internal",
|
|
GST_PAD_SINK,
|
|
GST_PAD_ALWAYS,
|
|
GST_STATIC_CAPS_ANY);
|
|
|
|
static GstStaticPadTemplate src_internal_template =
|
|
GST_STATIC_PAD_TEMPLATE ("src_internal",
|
|
GST_PAD_SRC,
|
|
GST_PAD_ALWAYS,
|
|
GST_STATIC_CAPS_ANY);
|
|
|
|
/* GstAutoConvert signals and args */
|
|
enum
|
|
{
|
|
/* FILL ME */
|
|
LAST_SIGNAL
|
|
};
|
|
|
|
enum
|
|
{
|
|
PROP_0,
|
|
PROP_FACTORIES,
|
|
PROP_INITIAL_IDENTITY
|
|
};
|
|
|
|
static void gst_auto_convert_set_property (GObject * object,
|
|
guint prop_id, const GValue * value, GParamSpec * pspec);
|
|
static void gst_auto_convert_get_property (GObject * object,
|
|
guint prop_id, GValue * value, GParamSpec * pspec);
|
|
static void gst_auto_convert_dispose (GObject * object);
|
|
|
|
static GstStateChangeReturn gst_auto_convert_change_state (GstElement * element,
|
|
GstStateChange transition);
|
|
|
|
static GstElement *gst_auto_convert_get_subelement (GstAutoConvert *
|
|
autoconvert, gboolean query_only);
|
|
static GstPad *gst_auto_convert_get_internal_sinkpad (GstAutoConvert *
|
|
autoconvert);
|
|
static GstPad *gst_auto_convert_get_internal_srcpad (GstAutoConvert *
|
|
autoconvert);
|
|
|
|
static gboolean gst_auto_convert_sink_setcaps (GstPad * pad, GstCaps * caps);
|
|
static GstCaps *gst_auto_convert_sink_getcaps (GstPad * pad);
|
|
static GstFlowReturn gst_auto_convert_sink_chain (GstPad * pad,
|
|
GstBuffer * buffer);
|
|
static gboolean gst_auto_convert_sink_event (GstPad * pad, GstEvent * event);
|
|
static gboolean gst_auto_convert_sink_query (GstPad * pad, GstQuery * query);
|
|
static const GstQueryType *gst_auto_convert_sink_query_type (GstPad * pad);
|
|
static GstFlowReturn gst_auto_convert_sink_buffer_alloc (GstPad * pad,
|
|
guint64 offset, guint size, GstCaps * caps, GstBuffer ** buf);
|
|
static void gst_auto_convert_sink_fixatecaps (GstPad * pad, GstCaps * caps);
|
|
|
|
static gboolean gst_auto_convert_src_event (GstPad * pad, GstEvent * event);
|
|
static gboolean gst_auto_convert_src_query (GstPad * pad, GstQuery * query);
|
|
static const GstQueryType *gst_auto_convert_src_query_type (GstPad * pad);
|
|
|
|
static GstFlowReturn gst_auto_convert_internal_sink_chain (GstPad * pad,
|
|
GstBuffer * buffer);
|
|
static gboolean gst_auto_convert_internal_sink_event (GstPad * pad,
|
|
GstEvent * event);
|
|
static gboolean gst_auto_convert_internal_sink_query (GstPad * pad,
|
|
GstQuery * query);
|
|
static const GstQueryType *gst_auto_convert_internal_sink_query_type (GstPad *
|
|
pad);
|
|
static GstCaps *gst_auto_convert_internal_sink_getcaps (GstPad * pad);
|
|
static GstFlowReturn gst_auto_convert_internal_sink_buffer_alloc (GstPad * pad,
|
|
guint64 offset, guint size, GstCaps * caps, GstBuffer ** buf);
|
|
static void gst_auto_convert_internal_sink_fixatecaps (GstPad * pad,
|
|
GstCaps * caps);
|
|
|
|
static gboolean gst_auto_convert_internal_src_event (GstPad * pad,
|
|
GstEvent * event);
|
|
static gboolean gst_auto_convert_internal_src_query (GstPad * pad,
|
|
GstQuery * query);
|
|
static const GstQueryType *gst_auto_convert_internal_src_query_type (GstPad *
|
|
pad);
|
|
|
|
static GList *gst_auto_convert_load_factories (GstAutoConvert * autoconvert);
|
|
static GstElement
|
|
* gst_auto_convert_get_or_make_element_from_factory (GstAutoConvert *
|
|
autoconvert, GstElementFactory * factory);
|
|
static gboolean gst_auto_convert_activate_element (GstAutoConvert * autoconvert,
|
|
GstElement * element, GstCaps * caps);
|
|
|
|
static GQuark internal_srcpad_quark = 0;
|
|
static GQuark internal_sinkpad_quark = 0;
|
|
static GQuark parent_quark = 0;
|
|
|
|
static void
|
|
gst_auto_convert_do_init (GType type)
|
|
{
|
|
GST_DEBUG_CATEGORY_INIT (autoconvert_debug, "autoconvert", 0,
|
|
"Auto convert based on caps");
|
|
|
|
internal_srcpad_quark = g_quark_from_static_string ("internal_srcpad");
|
|
internal_sinkpad_quark = g_quark_from_static_string ("internal_sinkpad");
|
|
parent_quark = g_quark_from_static_string ("parent");
|
|
}
|
|
|
|
GST_BOILERPLATE_FULL (GstAutoConvert, gst_auto_convert, GstBin,
|
|
GST_TYPE_BIN, gst_auto_convert_do_init);
|
|
|
|
static void
|
|
gst_auto_convert_base_init (gpointer klass)
|
|
{
|
|
GstElementClass *element_class = GST_ELEMENT_CLASS (klass);
|
|
|
|
gst_element_class_add_pad_template (element_class,
|
|
gst_static_pad_template_get (&srctemplate));
|
|
gst_element_class_add_pad_template (element_class,
|
|
gst_static_pad_template_get (&sinktemplate));
|
|
|
|
gst_element_class_set_details_simple (element_class,
|
|
"Select convertor based on caps", "Generic/Bin",
|
|
"Selects the right transform element based on the caps",
|
|
"Olivier Crete <olivier.crete@collabora.co.uk>");
|
|
}
|
|
|
|
static void
|
|
gst_auto_convert_class_init (GstAutoConvertClass * klass)
|
|
{
|
|
GObjectClass *gobject_class = (GObjectClass *) klass;
|
|
GstElementClass *gstelement_class = (GstElementClass *) klass;
|
|
|
|
gobject_class->dispose = GST_DEBUG_FUNCPTR (gst_auto_convert_dispose);
|
|
|
|
gobject_class->set_property = gst_auto_convert_set_property;
|
|
gobject_class->get_property = gst_auto_convert_get_property;
|
|
|
|
g_object_class_install_property (gobject_class, PROP_FACTORIES,
|
|
g_param_spec_pointer ("factories",
|
|
"GList of GstElementFactory",
|
|
"GList of GstElementFactory objects to pick from (the element takes"
|
|
" ownership of the list (NULL means it will go through all possible"
|
|
" elements), can only be set once",
|
|
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
|
|
|
|
g_object_class_install_property (gobject_class, PROP_INITIAL_IDENTITY,
|
|
g_param_spec_boolean ("initial-identity",
|
|
"Install identity initially",
|
|
"If true, then the identity element will be installed initially "
|
|
"and used for event passing until the first data buffer arrives ",
|
|
DEFAULT_INITIAL_IDENTITY, G_PARAM_READWRITE));
|
|
|
|
gstelement_class->change_state =
|
|
GST_DEBUG_FUNCPTR (gst_auto_convert_change_state);
|
|
}
|
|
|
|
static void
|
|
gst_auto_convert_init (GstAutoConvert * autoconvert,
|
|
GstAutoConvertClass * klass)
|
|
{
|
|
autoconvert->sinkpad =
|
|
gst_pad_new_from_static_template (&sinktemplate, "sink");
|
|
autoconvert->srcpad = gst_pad_new_from_static_template (&srctemplate, "src");
|
|
|
|
gst_pad_set_setcaps_function (autoconvert->sinkpad,
|
|
GST_DEBUG_FUNCPTR (gst_auto_convert_sink_setcaps));
|
|
gst_pad_set_getcaps_function (autoconvert->sinkpad,
|
|
GST_DEBUG_FUNCPTR (gst_auto_convert_sink_getcaps));
|
|
gst_pad_set_chain_function (autoconvert->sinkpad,
|
|
GST_DEBUG_FUNCPTR (gst_auto_convert_sink_chain));
|
|
gst_pad_set_event_function (autoconvert->sinkpad,
|
|
GST_DEBUG_FUNCPTR (gst_auto_convert_sink_event));
|
|
gst_pad_set_query_function (autoconvert->sinkpad,
|
|
GST_DEBUG_FUNCPTR (gst_auto_convert_sink_query));
|
|
gst_pad_set_query_type_function (autoconvert->sinkpad,
|
|
GST_DEBUG_FUNCPTR (gst_auto_convert_sink_query_type));
|
|
gst_pad_set_bufferalloc_function (autoconvert->sinkpad,
|
|
GST_DEBUG_FUNCPTR (gst_auto_convert_sink_buffer_alloc));
|
|
|
|
gst_pad_set_event_function (autoconvert->srcpad,
|
|
GST_DEBUG_FUNCPTR (gst_auto_convert_src_event));
|
|
gst_pad_set_query_function (autoconvert->srcpad,
|
|
GST_DEBUG_FUNCPTR (gst_auto_convert_src_query));
|
|
gst_pad_set_query_type_function (autoconvert->srcpad,
|
|
GST_DEBUG_FUNCPTR (gst_auto_convert_src_query_type));
|
|
|
|
gst_element_add_pad (GST_ELEMENT (autoconvert), autoconvert->sinkpad);
|
|
gst_element_add_pad (GST_ELEMENT (autoconvert), autoconvert->srcpad);
|
|
|
|
gst_segment_init (&autoconvert->sink_segment, GST_FORMAT_UNDEFINED);
|
|
|
|
autoconvert->initial_identity = DEFAULT_INITIAL_IDENTITY;
|
|
}
|
|
|
|
static void
|
|
gst_auto_convert_dispose (GObject * object)
|
|
{
|
|
GstAutoConvert *autoconvert = GST_AUTO_CONVERT (object);
|
|
|
|
gst_pad_set_fixatecaps_function (autoconvert->sinkpad, NULL);
|
|
|
|
GST_AUTOCONVERT_LOCK (autoconvert);
|
|
if (autoconvert->current_subelement) {
|
|
gst_object_unref (autoconvert->current_subelement);
|
|
autoconvert->current_subelement = NULL;
|
|
autoconvert->current_internal_sinkpad = NULL;
|
|
autoconvert->current_internal_srcpad = NULL;
|
|
}
|
|
|
|
g_list_foreach (autoconvert->cached_events, (GFunc) gst_mini_object_unref,
|
|
NULL);
|
|
g_list_free (autoconvert->cached_events);
|
|
autoconvert->cached_events = NULL;
|
|
|
|
if (autoconvert->factories) {
|
|
gst_plugin_feature_list_free (autoconvert->factories);
|
|
autoconvert->factories = NULL;
|
|
}
|
|
GST_AUTOCONVERT_UNLOCK (autoconvert);
|
|
|
|
G_OBJECT_CLASS (parent_class)->dispose (object);
|
|
}
|
|
|
|
static void
|
|
gst_auto_convert_set_property (GObject * object,
|
|
guint prop_id, const GValue * value, GParamSpec * pspec)
|
|
{
|
|
GstAutoConvert *autoconvert = GST_AUTO_CONVERT (object);
|
|
|
|
switch (prop_id) {
|
|
default:
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
|
|
break;
|
|
case PROP_FACTORIES:
|
|
GST_AUTOCONVERT_LOCK (autoconvert);
|
|
if (autoconvert->factories == NULL) {
|
|
GList *factories = g_value_get_pointer (value);
|
|
autoconvert->factories = g_list_copy (factories);
|
|
g_list_foreach (autoconvert->factories, (GFunc) g_object_ref, NULL);
|
|
} else
|
|
GST_WARNING_OBJECT (object, "Can not reset factories after they"
|
|
" have been set or auto-discovered");
|
|
GST_AUTOCONVERT_UNLOCK (autoconvert);
|
|
break;
|
|
case PROP_INITIAL_IDENTITY:
|
|
GST_AUTOCONVERT_LOCK (autoconvert);
|
|
autoconvert->initial_identity = g_value_get_boolean (value);
|
|
GST_AUTOCONVERT_UNLOCK (autoconvert);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void
|
|
gst_auto_convert_get_property (GObject * object,
|
|
guint prop_id, GValue * value, GParamSpec * pspec)
|
|
{
|
|
GstAutoConvert *autoconvert = GST_AUTO_CONVERT (object);
|
|
|
|
switch (prop_id) {
|
|
default:
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
|
|
break;
|
|
case PROP_FACTORIES:
|
|
GST_AUTOCONVERT_LOCK (autoconvert);
|
|
g_value_set_pointer (value, &autoconvert->factories);
|
|
GST_AUTOCONVERT_UNLOCK (autoconvert);
|
|
break;
|
|
case PROP_INITIAL_IDENTITY:
|
|
GST_AUTOCONVERT_LOCK (autoconvert);
|
|
g_value_set_boolean (value, autoconvert->initial_identity);
|
|
GST_AUTOCONVERT_UNLOCK (autoconvert);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static GstStateChangeReturn
|
|
gst_auto_convert_change_state (GstElement * element, GstStateChange transition)
|
|
{
|
|
GstAutoConvert *autoconvert = GST_AUTO_CONVERT (element);
|
|
GstStateChangeReturn ret;
|
|
|
|
switch (transition) {
|
|
default:
|
|
break;
|
|
}
|
|
|
|
ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
|
|
if (ret == GST_STATE_CHANGE_FAILURE)
|
|
return ret;
|
|
|
|
switch (transition) {
|
|
case GST_STATE_CHANGE_PAUSED_TO_READY:
|
|
g_list_foreach (autoconvert->cached_events, (GFunc) gst_mini_object_unref,
|
|
NULL);
|
|
g_list_free (autoconvert->cached_events);
|
|
autoconvert->cached_events = NULL;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static GstElement *
|
|
gst_auto_convert_get_element_by_type (GstAutoConvert * autoconvert, GType type)
|
|
{
|
|
GstIterator *iter = NULL;
|
|
GstElement *elem = NULL;
|
|
gboolean done;
|
|
|
|
g_return_val_if_fail (type != 0, NULL);
|
|
|
|
iter = gst_bin_iterate_elements (GST_BIN (autoconvert));
|
|
|
|
if (!iter)
|
|
return NULL;
|
|
|
|
done = FALSE;
|
|
while (!done) {
|
|
switch (gst_iterator_next (iter, (gpointer) & elem)) {
|
|
case GST_ITERATOR_OK:
|
|
if (G_OBJECT_TYPE (elem) == type)
|
|
done = TRUE;
|
|
else
|
|
gst_object_unref (elem);
|
|
break;
|
|
case GST_ITERATOR_RESYNC:
|
|
gst_iterator_resync (iter);
|
|
elem = NULL;
|
|
break;
|
|
case GST_ITERATOR_ERROR:
|
|
GST_ERROR ("Error iterating elements in bin");
|
|
elem = NULL;
|
|
done = TRUE;
|
|
break;
|
|
case GST_ITERATOR_DONE:
|
|
elem = NULL;
|
|
done = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
gst_iterator_free (iter);
|
|
|
|
return elem;
|
|
}
|
|
|
|
/**
|
|
* get_pad_by_direction:
|
|
* @element: The Element
|
|
* @direction: The direction
|
|
*
|
|
* Gets a #GstPad that goes in the requested direction. I will return NULL
|
|
* if there is no pad or if there is more than one pad in this direction
|
|
*/
|
|
|
|
static GstPad *
|
|
get_pad_by_direction (GstElement * element, GstPadDirection direction)
|
|
{
|
|
GstIterator *iter = gst_element_iterate_pads (element);
|
|
GstPad *pad = NULL;
|
|
GstPad *selected_pad = NULL;
|
|
gboolean done;
|
|
|
|
if (!iter)
|
|
return NULL;
|
|
|
|
done = FALSE;
|
|
while (!done) {
|
|
switch (gst_iterator_next (iter, (gpointer) & pad)) {
|
|
case GST_ITERATOR_OK:
|
|
if (gst_pad_get_direction (pad) == direction) {
|
|
/* We check if there is more than one pad in this direction,
|
|
* if there is, we return NULL so that the element is refused
|
|
*/
|
|
if (selected_pad) {
|
|
done = TRUE;
|
|
gst_object_unref (selected_pad);
|
|
selected_pad = NULL;
|
|
} else {
|
|
selected_pad = pad;
|
|
}
|
|
} else {
|
|
gst_object_unref (pad);
|
|
}
|
|
break;
|
|
case GST_ITERATOR_RESYNC:
|
|
if (selected_pad) {
|
|
gst_object_unref (selected_pad);
|
|
selected_pad = NULL;
|
|
}
|
|
gst_iterator_resync (iter);
|
|
break;
|
|
case GST_ITERATOR_ERROR:
|
|
GST_ERROR ("Error iterating pads of element %s",
|
|
GST_OBJECT_NAME (element));
|
|
gst_object_unref (selected_pad);
|
|
selected_pad = NULL;
|
|
done = TRUE;
|
|
break;
|
|
case GST_ITERATOR_DONE:
|
|
done = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
gst_iterator_free (iter);
|
|
|
|
if (!selected_pad)
|
|
GST_ERROR ("Did not find pad of direction %d in %s",
|
|
direction, GST_OBJECT_NAME (element));
|
|
|
|
return selected_pad;
|
|
}
|
|
|
|
static GstElement *
|
|
gst_auto_convert_get_subelement (GstAutoConvert * autoconvert,
|
|
gboolean query_only)
|
|
{
|
|
GstElement *element = NULL;
|
|
gboolean initial_identity;
|
|
|
|
GST_AUTOCONVERT_LOCK (autoconvert);
|
|
if (autoconvert->current_subelement)
|
|
element = gst_object_ref (autoconvert->current_subelement);
|
|
initial_identity = autoconvert->initial_identity;
|
|
GST_AUTOCONVERT_UNLOCK (autoconvert);
|
|
|
|
if (G_UNLIKELY (!query_only && element == NULL && initial_identity)) {
|
|
/* No current sub-element - create an identity and install it */
|
|
GstElementFactory *identity_feature;
|
|
GstElement *identity;
|
|
|
|
GST_INFO_OBJECT (autoconvert,
|
|
"No existing child element - instantiating identity");
|
|
/* if the identity feature doesn't exist - something is very wrong */
|
|
identity_feature =
|
|
GST_ELEMENT_FACTORY_CAST (gst_default_registry_find_feature ("identity",
|
|
GST_TYPE_ELEMENT_FACTORY));
|
|
identity =
|
|
gst_auto_convert_get_or_make_element_from_factory (autoconvert,
|
|
identity_feature);
|
|
if (identity
|
|
&& gst_auto_convert_activate_element (autoconvert, identity, NULL)) {
|
|
GST_AUTOCONVERT_LOCK (autoconvert);
|
|
if (autoconvert->current_subelement)
|
|
element = gst_object_ref (autoconvert->current_subelement);
|
|
GST_AUTOCONVERT_UNLOCK (autoconvert);
|
|
}
|
|
}
|
|
|
|
return element;
|
|
}
|
|
|
|
static GstPad *
|
|
gst_auto_convert_get_internal_sinkpad (GstAutoConvert * autoconvert)
|
|
{
|
|
GstPad *pad = NULL;
|
|
|
|
GST_AUTOCONVERT_LOCK (autoconvert);
|
|
if (autoconvert->current_internal_sinkpad)
|
|
pad = gst_object_ref (autoconvert->current_internal_sinkpad);
|
|
GST_AUTOCONVERT_UNLOCK (autoconvert);
|
|
|
|
return pad;
|
|
}
|
|
|
|
static GstPad *
|
|
gst_auto_convert_get_internal_srcpad (GstAutoConvert * autoconvert)
|
|
{
|
|
GstPad *pad = NULL;
|
|
|
|
GST_AUTOCONVERT_LOCK (autoconvert);
|
|
if (autoconvert->current_internal_srcpad)
|
|
pad = gst_object_ref (autoconvert->current_internal_srcpad);
|
|
GST_AUTOCONVERT_UNLOCK (autoconvert);
|
|
|
|
return pad;
|
|
}
|
|
|
|
/*
|
|
* This function creates and adds an element to the GstAutoConvert
|
|
* it then creates the internal pads and links them
|
|
*
|
|
*/
|
|
|
|
static GstElement *
|
|
gst_auto_convert_add_element (GstAutoConvert * autoconvert,
|
|
GstElementFactory * factory)
|
|
{
|
|
GstElement *element = NULL;
|
|
GstPad *internal_sinkpad = NULL;
|
|
GstPad *internal_srcpad = NULL;
|
|
GstPad *sinkpad;
|
|
GstPad *srcpad;
|
|
GstPadLinkReturn padlinkret;
|
|
|
|
GST_DEBUG_OBJECT (autoconvert, "Adding element %s to the autoconvert bin",
|
|
gst_plugin_feature_get_name (GST_PLUGIN_FEATURE (factory)));
|
|
|
|
element = gst_element_factory_create (factory, NULL);
|
|
if (!element)
|
|
return NULL;
|
|
|
|
if (!gst_bin_add (GST_BIN (autoconvert), element)) {
|
|
GST_ERROR_OBJECT (autoconvert, "Could not add element %s to the bin",
|
|
GST_OBJECT_NAME (element));
|
|
gst_object_unref (element);
|
|
return NULL;
|
|
}
|
|
|
|
srcpad = get_pad_by_direction (element, GST_PAD_SRC);
|
|
if (!srcpad) {
|
|
GST_ERROR_OBJECT (autoconvert, "Could not find source in %s",
|
|
GST_OBJECT_NAME (element));
|
|
goto error;
|
|
}
|
|
|
|
sinkpad = get_pad_by_direction (element, GST_PAD_SINK);
|
|
if (!sinkpad) {
|
|
GST_ERROR_OBJECT (autoconvert, "Could not find sink in %s",
|
|
GST_OBJECT_NAME (element));
|
|
goto error;
|
|
}
|
|
|
|
internal_sinkpad =
|
|
gst_pad_new_from_static_template (&sink_internal_template,
|
|
"sink_internal");
|
|
internal_srcpad =
|
|
gst_pad_new_from_static_template (&src_internal_template, "src_internal");
|
|
|
|
if (!internal_sinkpad || !internal_srcpad) {
|
|
GST_ERROR_OBJECT (autoconvert, "Could not create internal pads");
|
|
goto error;
|
|
}
|
|
|
|
g_object_weak_ref (G_OBJECT (element), (GWeakNotify) gst_object_unref,
|
|
internal_sinkpad);
|
|
g_object_weak_ref (G_OBJECT (element), (GWeakNotify) gst_object_unref,
|
|
internal_srcpad);
|
|
|
|
gst_pad_set_active (internal_sinkpad, TRUE);
|
|
gst_pad_set_active (internal_srcpad, TRUE);
|
|
|
|
g_object_set_qdata (G_OBJECT (internal_srcpad), parent_quark, autoconvert);
|
|
g_object_set_qdata (G_OBJECT (internal_sinkpad), parent_quark, autoconvert);
|
|
|
|
gst_pad_set_chain_function (internal_sinkpad,
|
|
GST_DEBUG_FUNCPTR (gst_auto_convert_internal_sink_chain));
|
|
gst_pad_set_event_function (internal_sinkpad,
|
|
GST_DEBUG_FUNCPTR (gst_auto_convert_internal_sink_event));
|
|
gst_pad_set_query_function (internal_sinkpad,
|
|
GST_DEBUG_FUNCPTR (gst_auto_convert_internal_sink_query));
|
|
gst_pad_set_query_type_function (internal_sinkpad,
|
|
GST_DEBUG_FUNCPTR (gst_auto_convert_internal_sink_query_type));
|
|
gst_pad_set_getcaps_function (internal_sinkpad,
|
|
GST_DEBUG_FUNCPTR (gst_auto_convert_internal_sink_getcaps));
|
|
gst_pad_set_bufferalloc_function (internal_sinkpad,
|
|
GST_DEBUG_FUNCPTR (gst_auto_convert_internal_sink_buffer_alloc));
|
|
gst_pad_set_fixatecaps_function (internal_sinkpad,
|
|
GST_DEBUG_FUNCPTR (gst_auto_convert_internal_sink_fixatecaps));
|
|
|
|
gst_pad_set_event_function (internal_srcpad,
|
|
GST_DEBUG_FUNCPTR (gst_auto_convert_internal_src_event));
|
|
gst_pad_set_query_function (internal_srcpad,
|
|
GST_DEBUG_FUNCPTR (gst_auto_convert_internal_src_query));
|
|
gst_pad_set_query_type_function (internal_srcpad,
|
|
GST_DEBUG_FUNCPTR (gst_auto_convert_internal_src_query_type));
|
|
|
|
padlinkret = gst_pad_link (internal_srcpad, sinkpad);
|
|
if (GST_PAD_LINK_FAILED (padlinkret)) {
|
|
GST_WARNING_OBJECT (autoconvert, "Could not links pad %s:%s to %s:%s"
|
|
" for reason %d",
|
|
GST_DEBUG_PAD_NAME (internal_srcpad),
|
|
GST_DEBUG_PAD_NAME (sinkpad), padlinkret);
|
|
goto error;
|
|
}
|
|
|
|
padlinkret = gst_pad_link (srcpad, internal_sinkpad);
|
|
if (GST_PAD_LINK_FAILED (padlinkret)) {
|
|
GST_WARNING_OBJECT (autoconvert, "Could not links pad %s:%s to %s:%s"
|
|
" for reason %d",
|
|
GST_DEBUG_PAD_NAME (internal_srcpad),
|
|
GST_DEBUG_PAD_NAME (sinkpad), padlinkret);
|
|
goto error;
|
|
}
|
|
|
|
g_object_set_qdata (G_OBJECT (element),
|
|
internal_srcpad_quark, internal_srcpad);
|
|
g_object_set_qdata (G_OBJECT (element),
|
|
internal_sinkpad_quark, internal_sinkpad);
|
|
|
|
/* Iffy */
|
|
gst_element_sync_state_with_parent (element);
|
|
|
|
/* Increment the reference count we will return to the caller */
|
|
gst_object_ref (element);
|
|
|
|
return element;
|
|
|
|
error:
|
|
gst_bin_remove (GST_BIN (autoconvert), element);
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static GstElement *
|
|
gst_auto_convert_get_or_make_element_from_factory (GstAutoConvert * autoconvert,
|
|
GstElementFactory * factory)
|
|
{
|
|
GstElement *element = NULL;
|
|
GstElementFactory *loaded_factory =
|
|
GST_ELEMENT_FACTORY (gst_plugin_feature_load (GST_PLUGIN_FEATURE
|
|
(factory)));
|
|
|
|
if (!loaded_factory)
|
|
return NULL;
|
|
|
|
element = gst_auto_convert_get_element_by_type (autoconvert,
|
|
gst_element_factory_get_element_type (loaded_factory));
|
|
|
|
if (!element) {
|
|
element = gst_auto_convert_add_element (autoconvert, loaded_factory);
|
|
}
|
|
|
|
gst_object_unref (loaded_factory);
|
|
|
|
return element;
|
|
}
|
|
|
|
/*
|
|
* This function checks if there is one and only one pad template on the
|
|
* factory that can accept the given caps. If there is one and only one,
|
|
* it returns TRUE, otherwise, its FALSE
|
|
*/
|
|
|
|
static gboolean
|
|
factory_can_intersect (GstAutoConvert * autoconvert,
|
|
GstElementFactory * factory, GstPadDirection direction, GstCaps * caps)
|
|
{
|
|
GList *templates;
|
|
gint has_direction = FALSE;
|
|
gboolean ret = FALSE;
|
|
|
|
g_return_val_if_fail (factory != NULL, FALSE);
|
|
g_return_val_if_fail (caps != NULL, FALSE);
|
|
|
|
templates = factory->staticpadtemplates;
|
|
|
|
while (templates) {
|
|
GstStaticPadTemplate *template = (GstStaticPadTemplate *) templates->data;
|
|
|
|
if (template->direction == direction) {
|
|
GstCaps *intersect = NULL;
|
|
GstCaps *tmpl_caps = NULL;
|
|
|
|
/* If there is more than one pad in this direction, we return FALSE
|
|
* Only transform elements (with one sink and one source pad)
|
|
* are accepted
|
|
*/
|
|
if (has_direction) {
|
|
GST_DEBUG_OBJECT (autoconvert, "Factory %" GST_PTR_FORMAT
|
|
" has more than one static template with dir %d",
|
|
template, direction);
|
|
return FALSE;
|
|
}
|
|
has_direction = TRUE;
|
|
|
|
tmpl_caps = gst_static_caps_get (&template->static_caps);
|
|
intersect = gst_caps_intersect (tmpl_caps, caps);
|
|
GST_DEBUG_OBJECT (autoconvert, "Intersection of factory %" GST_PTR_FORMAT
|
|
" static caps %" GST_PTR_FORMAT " and caps %" GST_PTR_FORMAT
|
|
" is %" GST_PTR_FORMAT, factory, tmpl_caps, caps, intersect);
|
|
gst_caps_unref (tmpl_caps);
|
|
|
|
if (intersect) {
|
|
if (!gst_caps_is_empty (intersect))
|
|
ret = TRUE;
|
|
|
|
gst_caps_unref (intersect);
|
|
}
|
|
}
|
|
templates = g_list_next (templates);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static gboolean
|
|
gst_auto_convert_activate_element (GstAutoConvert * autoconvert,
|
|
GstElement * element, GstCaps * caps)
|
|
{
|
|
GstPad *internal_srcpad = g_object_get_qdata (G_OBJECT (element),
|
|
internal_srcpad_quark);
|
|
GstPad *internal_sinkpad = g_object_get_qdata (G_OBJECT (element),
|
|
internal_sinkpad_quark);
|
|
|
|
if (caps) {
|
|
/* check if the element can really accept said caps */
|
|
if (!gst_pad_peer_accept_caps (internal_srcpad, caps)) {
|
|
GST_DEBUG_OBJECT (autoconvert, "Could not set %s:%s to %"
|
|
GST_PTR_FORMAT, GST_DEBUG_PAD_NAME (internal_srcpad), caps);
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
gst_pad_set_fixatecaps_function (autoconvert->sinkpad,
|
|
gst_auto_convert_sink_fixatecaps);
|
|
GST_AUTOCONVERT_LOCK (autoconvert);
|
|
autoconvert->current_subelement = element;
|
|
autoconvert->current_internal_srcpad = internal_srcpad;
|
|
autoconvert->current_internal_sinkpad = internal_sinkpad;
|
|
GST_AUTOCONVERT_UNLOCK (autoconvert);
|
|
|
|
GST_INFO_OBJECT (autoconvert,
|
|
"Selected element %s",
|
|
GST_OBJECT_NAME (GST_OBJECT (autoconvert->current_subelement)));
|
|
|
|
/* Send new-segment event if we have one */
|
|
if (autoconvert->sink_segment.format != GST_FORMAT_UNDEFINED) {
|
|
GstEvent *event;
|
|
GstSegment *seg = &autoconvert->sink_segment;
|
|
event = gst_event_new_new_segment_full (TRUE,
|
|
seg->rate, seg->applied_rate, seg->format, seg->start,
|
|
seg->stop, seg->time);
|
|
|
|
autoconvert->drop_newseg = TRUE;
|
|
gst_pad_push_event (internal_srcpad, event);
|
|
autoconvert->drop_newseg = FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/*
|
|
* If there is already an internal element, it will try to call set_caps on it
|
|
*
|
|
* If there isn't an internal element or if the set_caps() on the internal
|
|
* element failed, it will try to find another element where it would succeed
|
|
* and will change the internal element.
|
|
*/
|
|
|
|
static gboolean
|
|
gst_auto_convert_sink_setcaps (GstPad * pad, GstCaps * caps)
|
|
{
|
|
GList *elem;
|
|
GstAutoConvert *autoconvert = GST_AUTO_CONVERT (gst_pad_get_parent (pad));
|
|
GstElement *subelement;
|
|
GstCaps *other_caps = NULL;
|
|
GstPad *peer;
|
|
GList *factories;
|
|
|
|
g_return_val_if_fail (autoconvert != NULL, FALSE);
|
|
|
|
subelement = gst_auto_convert_get_subelement (autoconvert, TRUE);
|
|
if (subelement) {
|
|
if (gst_pad_peer_accept_caps (autoconvert->current_internal_srcpad, caps)) {
|
|
/* If we can set the new caps on the current element,
|
|
* then we just get out
|
|
*/
|
|
GST_DEBUG_OBJECT (autoconvert, "Could set %s:%s to %" GST_PTR_FORMAT,
|
|
GST_DEBUG_PAD_NAME (autoconvert->current_internal_srcpad), caps);
|
|
gst_object_unref (subelement);
|
|
goto get_out;
|
|
} else {
|
|
/* If the current element doesn't work,
|
|
* then we remove the current element before finding a new one.
|
|
* By unsetting the fixatecaps function, we go back to the default one
|
|
*/
|
|
gst_pad_set_fixatecaps_function (autoconvert->sinkpad, NULL);
|
|
GST_AUTOCONVERT_LOCK (autoconvert);
|
|
if (autoconvert->current_subelement == subelement) {
|
|
gst_object_unref (autoconvert->current_subelement);
|
|
autoconvert->current_subelement = NULL;
|
|
autoconvert->current_internal_srcpad = NULL;
|
|
autoconvert->current_internal_sinkpad = NULL;
|
|
}
|
|
GST_AUTOCONVERT_UNLOCK (autoconvert);
|
|
gst_object_unref (subelement);
|
|
}
|
|
}
|
|
|
|
peer = gst_pad_get_peer (autoconvert->srcpad);
|
|
if (peer) {
|
|
other_caps = gst_pad_get_caps (peer);
|
|
gst_object_unref (peer);
|
|
}
|
|
|
|
GST_AUTOCONVERT_LOCK (autoconvert);
|
|
factories = autoconvert->factories;
|
|
GST_AUTOCONVERT_UNLOCK (autoconvert);
|
|
|
|
if (!factories)
|
|
factories = gst_auto_convert_load_factories (autoconvert);
|
|
|
|
for (elem = factories; elem; elem = g_list_next (elem)) {
|
|
GstElementFactory *factory = GST_ELEMENT_FACTORY (elem->data);
|
|
GstElement *element;
|
|
|
|
/* Lets first check if according to the static pad templates on the factory
|
|
* these caps have any chance of success
|
|
*/
|
|
if (!factory_can_intersect (autoconvert, factory, GST_PAD_SINK, caps)) {
|
|
GST_LOG_OBJECT (autoconvert, "Factory %s does not accept sink caps %"
|
|
GST_PTR_FORMAT,
|
|
gst_plugin_feature_get_name (GST_PLUGIN_FEATURE (factory)), caps);
|
|
continue;
|
|
}
|
|
if (other_caps != NULL) {
|
|
if (!factory_can_intersect (autoconvert, factory, GST_PAD_SRC,
|
|
other_caps)) {
|
|
GST_LOG_OBJECT (autoconvert,
|
|
"Factory %s does not accept src caps %" GST_PTR_FORMAT,
|
|
gst_plugin_feature_get_name (GST_PLUGIN_FEATURE (factory)),
|
|
other_caps);
|
|
continue;
|
|
}
|
|
}
|
|
|
|
/* The element had a chance of success, lets make it */
|
|
element =
|
|
gst_auto_convert_get_or_make_element_from_factory (autoconvert,
|
|
factory);
|
|
if (!element)
|
|
continue;
|
|
|
|
/* And make it the current child */
|
|
if (gst_auto_convert_activate_element (autoconvert, element, caps))
|
|
break;
|
|
}
|
|
|
|
get_out:
|
|
if (other_caps)
|
|
gst_caps_unref (other_caps);
|
|
gst_object_unref (autoconvert);
|
|
|
|
if (autoconvert->current_subelement) {
|
|
return TRUE;
|
|
} else {
|
|
GST_WARNING_OBJECT (autoconvert,
|
|
"Could not find a matching element for caps");
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* This function filters the pad pad templates, taking only transform element
|
|
* (with one sink and one src pad)
|
|
*/
|
|
|
|
static gboolean
|
|
gst_auto_convert_default_filter_func (GstPluginFeature * feature,
|
|
gpointer user_data)
|
|
{
|
|
GstElementFactory *factory = NULL;
|
|
const GList *static_pad_templates, *tmp;
|
|
GstStaticPadTemplate *src = NULL, *sink = NULL;
|
|
|
|
if (!GST_IS_ELEMENT_FACTORY (feature))
|
|
return FALSE;
|
|
|
|
factory = GST_ELEMENT_FACTORY (feature);
|
|
|
|
static_pad_templates = gst_element_factory_get_static_pad_templates (factory);
|
|
|
|
for (tmp = static_pad_templates; tmp; tmp = g_list_next (tmp)) {
|
|
GstStaticPadTemplate *template = tmp->data;
|
|
GstCaps *caps;
|
|
|
|
if (template->presence == GST_PAD_SOMETIMES)
|
|
return FALSE;
|
|
|
|
if (template->presence != GST_PAD_ALWAYS)
|
|
continue;
|
|
|
|
switch (template->direction) {
|
|
case GST_PAD_SRC:
|
|
if (src)
|
|
return FALSE;
|
|
src = template;
|
|
break;
|
|
case GST_PAD_SINK:
|
|
if (sink)
|
|
return FALSE;
|
|
sink = template;
|
|
break;
|
|
default:
|
|
return FALSE;
|
|
}
|
|
|
|
caps = gst_static_pad_template_get_caps (template);
|
|
|
|
if (gst_caps_is_any (caps) || gst_caps_is_empty (caps))
|
|
return FALSE;
|
|
}
|
|
|
|
if (!src || !sink)
|
|
return FALSE;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/* function used to sort element features
|
|
* Copy-pasted from decodebin */
|
|
static gint
|
|
compare_ranks (GstPluginFeature * f1, GstPluginFeature * f2)
|
|
{
|
|
gint diff;
|
|
const gchar *rname1, *rname2;
|
|
|
|
diff = gst_plugin_feature_get_rank (f2) - gst_plugin_feature_get_rank (f1);
|
|
if (diff != 0)
|
|
return diff;
|
|
|
|
rname1 = gst_plugin_feature_get_name (f1);
|
|
rname2 = gst_plugin_feature_get_name (f2);
|
|
|
|
diff = strcmp (rname2, rname1);
|
|
|
|
return diff;
|
|
}
|
|
|
|
static GList *
|
|
gst_auto_convert_load_factories (GstAutoConvert * autoconvert)
|
|
{
|
|
GList *all_factories;
|
|
GList *out_factories;
|
|
|
|
all_factories =
|
|
gst_default_registry_feature_filter (gst_auto_convert_default_filter_func,
|
|
FALSE, NULL);
|
|
|
|
all_factories = g_list_sort (all_factories, (GCompareFunc) compare_ranks);
|
|
|
|
g_assert (all_factories);
|
|
|
|
GST_AUTOCONVERT_LOCK (autoconvert);
|
|
if (autoconvert->factories == NULL) {
|
|
autoconvert->factories = all_factories;
|
|
all_factories = NULL;
|
|
}
|
|
out_factories = autoconvert->factories;
|
|
GST_AUTOCONVERT_UNLOCK (autoconvert);
|
|
|
|
if (all_factories) {
|
|
/* In this case, someone set the property while we were looking! */
|
|
gst_plugin_feature_list_free (all_factories);
|
|
}
|
|
|
|
return out_factories;
|
|
}
|
|
|
|
/* In this case, we should almost always have an internal element, because
|
|
* set_caps() should have been called first
|
|
*/
|
|
|
|
static GstFlowReturn
|
|
gst_auto_convert_sink_chain (GstPad * pad, GstBuffer * buffer)
|
|
{
|
|
GstFlowReturn ret = GST_FLOW_NOT_NEGOTIATED;
|
|
GstAutoConvert *autoconvert = GST_AUTO_CONVERT (gst_pad_get_parent (pad));
|
|
GstPad *internal_srcpad;
|
|
|
|
internal_srcpad = gst_auto_convert_get_internal_srcpad (autoconvert);
|
|
if (internal_srcpad) {
|
|
GList *events = NULL;
|
|
GList *l;
|
|
|
|
GST_AUTOCONVERT_LOCK (autoconvert);
|
|
if (autoconvert->cached_events) {
|
|
events = g_list_reverse (autoconvert->cached_events);
|
|
autoconvert->cached_events = NULL;
|
|
}
|
|
GST_AUTOCONVERT_UNLOCK (autoconvert);
|
|
|
|
if (events) {
|
|
GST_DEBUG_OBJECT (autoconvert, "Sending cached events downstream");
|
|
for (l = events; l; l = l->next)
|
|
gst_pad_push_event (internal_srcpad, l->data);
|
|
g_list_free (events);
|
|
}
|
|
|
|
ret = gst_pad_push (internal_srcpad, buffer);
|
|
gst_object_unref (internal_srcpad);
|
|
if (GST_FLOW_IS_FATAL (ret)) {
|
|
GstElement *child = gst_auto_convert_get_subelement (autoconvert, TRUE);
|
|
GST_DEBUG_OBJECT (autoconvert,
|
|
"Child element %" GST_PTR_FORMAT "returned flow %s", child,
|
|
gst_flow_get_name (ret));
|
|
if (child)
|
|
gst_object_unref (child);
|
|
}
|
|
} else {
|
|
GST_ERROR_OBJECT (autoconvert, "Got buffer without an negotiated element,"
|
|
" returning not-negotiated");
|
|
}
|
|
|
|
gst_object_unref (autoconvert);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static gboolean
|
|
gst_auto_convert_sink_event (GstPad * pad, GstEvent * event)
|
|
{
|
|
gboolean ret = TRUE;
|
|
GstAutoConvert *autoconvert = GST_AUTO_CONVERT (gst_pad_get_parent (pad));
|
|
GstPad *internal_srcpad;
|
|
|
|
if (GST_EVENT_TYPE (event) == GST_EVENT_NEWSEGMENT) {
|
|
GstFormat format;
|
|
gdouble rate, arate;
|
|
gint64 start, stop, time;
|
|
gboolean update;
|
|
|
|
gst_event_parse_new_segment_full (event, &update, &rate, &arate, &format,
|
|
&start, &stop, &time);
|
|
|
|
GST_DEBUG_OBJECT (autoconvert,
|
|
"newsegment: update %d, rate %g, arate %g, start %" GST_TIME_FORMAT
|
|
", stop %" GST_TIME_FORMAT ", time %" GST_TIME_FORMAT,
|
|
update, rate, arate, GST_TIME_ARGS (start), GST_TIME_ARGS (stop),
|
|
GST_TIME_ARGS (time));
|
|
|
|
/* Store the values for feeding to sub-elements */
|
|
gst_segment_set_newsegment_full (&autoconvert->sink_segment, update,
|
|
rate, arate, format, start, stop, time);
|
|
}
|
|
|
|
internal_srcpad = gst_auto_convert_get_internal_srcpad (autoconvert);
|
|
if (internal_srcpad == NULL) {
|
|
/* Query the subelement - triggers creation of an identity if necessary */
|
|
GstElement *subelement =
|
|
gst_auto_convert_get_subelement (autoconvert, FALSE);
|
|
if (subelement)
|
|
gst_object_unref (subelement);
|
|
internal_srcpad = gst_auto_convert_get_internal_srcpad (autoconvert);
|
|
}
|
|
|
|
if (internal_srcpad) {
|
|
ret = gst_pad_push_event (internal_srcpad, event);
|
|
gst_object_unref (internal_srcpad);
|
|
} else {
|
|
switch (GST_EVENT_TYPE (event)) {
|
|
case GST_EVENT_FLUSH_STOP:
|
|
GST_AUTOCONVERT_LOCK (autoconvert);
|
|
g_list_foreach (autoconvert->cached_events,
|
|
(GFunc) gst_mini_object_unref, NULL);
|
|
g_list_free (autoconvert->cached_events);
|
|
autoconvert->cached_events = NULL;
|
|
GST_AUTOCONVERT_UNLOCK (autoconvert);
|
|
/* fall through */
|
|
case GST_EVENT_FLUSH_START:
|
|
ret = gst_pad_push_event (autoconvert->srcpad, event);
|
|
break;
|
|
default:
|
|
GST_AUTOCONVERT_LOCK (autoconvert);
|
|
autoconvert->cached_events =
|
|
g_list_prepend (autoconvert->cached_events, event);
|
|
ret = TRUE;
|
|
GST_AUTOCONVERT_UNLOCK (autoconvert);
|
|
break;
|
|
}
|
|
}
|
|
|
|
gst_object_unref (autoconvert);
|
|
|
|
return ret;
|
|
}
|
|
|
|
/* TODO Properly test that this code works well for queries */
|
|
static gboolean
|
|
gst_auto_convert_sink_query (GstPad * pad, GstQuery * query)
|
|
{
|
|
gboolean ret = TRUE;
|
|
GstAutoConvert *autoconvert = GST_AUTO_CONVERT (gst_pad_get_parent (pad));
|
|
GstElement *subelement;
|
|
|
|
subelement = gst_auto_convert_get_subelement (autoconvert, TRUE);
|
|
if (subelement) {
|
|
GstPad *sub_sinkpad = get_pad_by_direction (subelement, GST_PAD_SINK);
|
|
|
|
ret = gst_pad_query (sub_sinkpad, query);
|
|
|
|
gst_object_unref (sub_sinkpad);
|
|
gst_object_unref (subelement);
|
|
} else {
|
|
GST_WARNING_OBJECT (autoconvert, "Got query while no element was selected,"
|
|
"letting through");
|
|
ret = gst_pad_peer_query (autoconvert->srcpad, query);
|
|
}
|
|
|
|
gst_object_unref (autoconvert);
|
|
|
|
return ret;
|
|
}
|
|
|
|
/* TODO Test that this code works properly for queries */
|
|
static const GstQueryType *
|
|
gst_auto_convert_sink_query_type (GstPad * pad)
|
|
{
|
|
const GstQueryType *ret = NULL;
|
|
GstAutoConvert *autoconvert = GST_AUTO_CONVERT (gst_pad_get_parent (pad));
|
|
GstElement *subelement;
|
|
|
|
subelement = gst_auto_convert_get_subelement (autoconvert, TRUE);
|
|
if (subelement) {
|
|
GstPad *sub_sinkpad = get_pad_by_direction (subelement, GST_PAD_SINK);
|
|
|
|
ret = gst_pad_get_query_types (sub_sinkpad);
|
|
|
|
gst_object_unref (sub_sinkpad);
|
|
gst_object_unref (subelement);
|
|
} else {
|
|
ret = gst_pad_get_query_types_default (pad);
|
|
}
|
|
|
|
gst_object_unref (autoconvert);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static void
|
|
gst_auto_convert_sink_fixatecaps (GstPad * pad, GstCaps * caps)
|
|
{
|
|
GstAutoConvert *autoconvert = GST_AUTO_CONVERT (gst_pad_get_parent (pad));
|
|
GstElement *subelement;
|
|
|
|
subelement = gst_auto_convert_get_subelement (autoconvert, TRUE);
|
|
if (subelement) {
|
|
GstPad *sinkpad = get_pad_by_direction (subelement, GST_PAD_SINK);
|
|
gst_pad_fixate_caps (sinkpad, caps);
|
|
gst_object_unref (sinkpad);
|
|
gst_object_unref (subelement);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* gst_auto_convert_sink_getcaps:
|
|
* @pad: the sink #GstPad
|
|
*
|
|
* This function returns the union of the caps of all the possible element
|
|
* factories, based on the static pad templates.
|
|
* It also checks does a getcaps on the downstream element and ignores all
|
|
* factories whose static caps can not satisfy it.
|
|
*
|
|
* It does not try to use each elements getcaps() function
|
|
*/
|
|
|
|
static GstCaps *
|
|
gst_auto_convert_sink_getcaps (GstPad * pad)
|
|
{
|
|
GstCaps *caps = NULL, *other_caps = NULL;
|
|
GstAutoConvert *autoconvert = GST_AUTO_CONVERT (gst_pad_get_parent (pad));
|
|
GstPad *peer;
|
|
GList *elem, *factories;
|
|
|
|
caps = gst_caps_new_empty ();
|
|
|
|
peer = gst_pad_get_peer (autoconvert->srcpad);
|
|
if (peer) {
|
|
other_caps = gst_pad_get_caps (peer);
|
|
gst_object_unref (peer);
|
|
}
|
|
|
|
GST_DEBUG_OBJECT (autoconvert,
|
|
"Lets find all the element that can fit here with src caps %"
|
|
GST_PTR_FORMAT, other_caps);
|
|
|
|
if (other_caps && gst_caps_is_empty (other_caps)) {
|
|
goto out;
|
|
}
|
|
|
|
GST_AUTOCONVERT_LOCK (autoconvert);
|
|
factories = autoconvert->factories;
|
|
GST_AUTOCONVERT_UNLOCK (autoconvert);
|
|
|
|
if (!factories)
|
|
factories = gst_auto_convert_load_factories (autoconvert);
|
|
|
|
for (elem = factories; elem; elem = g_list_next (elem)) {
|
|
GstElementFactory *factory = GST_ELEMENT_FACTORY (elem->data);
|
|
GstElement *element = NULL;
|
|
GstCaps *element_caps;
|
|
GstPad *internal_srcpad = NULL;
|
|
|
|
if (other_caps != NULL) {
|
|
if (!factory_can_intersect (autoconvert, factory, GST_PAD_SRC,
|
|
other_caps)) {
|
|
GST_LOG_OBJECT (autoconvert,
|
|
"Factory %s does not accept src caps %" GST_PTR_FORMAT,
|
|
gst_plugin_feature_get_name (GST_PLUGIN_FEATURE (factory)),
|
|
other_caps);
|
|
continue;
|
|
}
|
|
}
|
|
|
|
if (other_caps) {
|
|
|
|
element =
|
|
gst_auto_convert_get_or_make_element_from_factory (autoconvert,
|
|
factory);
|
|
if (!element)
|
|
continue;
|
|
|
|
internal_srcpad = g_object_get_qdata (G_OBJECT (element),
|
|
internal_srcpad_quark);
|
|
|
|
element_caps = gst_pad_peer_get_caps (internal_srcpad);
|
|
|
|
if (element_caps) {
|
|
if (!gst_caps_is_any (element_caps) &&
|
|
!gst_caps_is_empty (element_caps)) {
|
|
GstCaps *tmpcaps = NULL;
|
|
|
|
tmpcaps = gst_caps_union (caps, element_caps);
|
|
gst_caps_unref (caps);
|
|
caps = tmpcaps;
|
|
|
|
}
|
|
gst_caps_unref (element_caps);
|
|
}
|
|
|
|
gst_object_unref (element);
|
|
} else {
|
|
const GList *tmp;
|
|
|
|
for (tmp = gst_element_factory_get_static_pad_templates (factory);
|
|
tmp; tmp = g_list_next (tmp)) {
|
|
GstStaticPadTemplate *template = tmp->data;
|
|
GstCaps *static_caps = gst_static_pad_template_get_caps (template);
|
|
|
|
if (static_caps && !gst_caps_is_any (static_caps) &&
|
|
!gst_caps_is_empty (static_caps)) {
|
|
GstCaps *tmpcaps = NULL;
|
|
|
|
tmpcaps = gst_caps_union (caps, static_caps);
|
|
gst_caps_unref (caps);
|
|
caps = tmpcaps;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
GST_DEBUG_OBJECT (autoconvert, "Returning unioned caps %" GST_PTR_FORMAT,
|
|
caps);
|
|
|
|
out:
|
|
gst_object_unref (autoconvert);
|
|
|
|
if (other_caps)
|
|
gst_caps_unref (other_caps);
|
|
|
|
return caps;
|
|
}
|
|
|
|
|
|
static GstFlowReturn
|
|
gst_auto_convert_sink_buffer_alloc (GstPad * pad, guint64 offset,
|
|
guint size, GstCaps * caps, GstBuffer ** buf)
|
|
{
|
|
GstFlowReturn ret = GST_FLOW_OK;
|
|
GstAutoConvert *autoconvert = GST_AUTO_CONVERT (gst_pad_get_parent (pad));
|
|
GstPad *internal_srcpad;
|
|
|
|
g_return_val_if_fail (autoconvert != NULL, GST_FLOW_ERROR);
|
|
|
|
internal_srcpad = gst_auto_convert_get_internal_srcpad (autoconvert);
|
|
if (internal_srcpad) {
|
|
ret = gst_pad_alloc_buffer (internal_srcpad, offset, size, caps, buf);
|
|
gst_object_unref (internal_srcpad);
|
|
} else
|
|
/* Fallback to the default */
|
|
*buf = NULL;
|
|
|
|
gst_object_unref (autoconvert);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static gboolean
|
|
gst_auto_convert_src_event (GstPad * pad, GstEvent * event)
|
|
{
|
|
gboolean ret = TRUE;
|
|
GstAutoConvert *autoconvert = GST_AUTO_CONVERT (gst_pad_get_parent (pad));
|
|
GstPad *internal_sinkpad;
|
|
|
|
internal_sinkpad = gst_auto_convert_get_internal_sinkpad (autoconvert);
|
|
if (internal_sinkpad) {
|
|
ret = gst_pad_push_event (internal_sinkpad, event);
|
|
gst_object_unref (internal_sinkpad);
|
|
} else {
|
|
GST_WARNING_OBJECT (autoconvert,
|
|
"Got upstream event while no element was selected," "forwarding.");
|
|
ret = gst_pad_push_event (autoconvert->sinkpad, event);
|
|
}
|
|
|
|
gst_object_unref (autoconvert);
|
|
|
|
return ret;
|
|
}
|
|
|
|
/* TODO Properly test that this code works well for queries */
|
|
static gboolean
|
|
gst_auto_convert_src_query (GstPad * pad, GstQuery * query)
|
|
{
|
|
gboolean ret = TRUE;
|
|
GstAutoConvert *autoconvert = GST_AUTO_CONVERT (gst_pad_get_parent (pad));
|
|
GstElement *subelement;
|
|
|
|
subelement = gst_auto_convert_get_subelement (autoconvert, TRUE);
|
|
if (subelement) {
|
|
GstPad *sub_srcpad = get_pad_by_direction (subelement, GST_PAD_SRC);
|
|
|
|
ret = gst_pad_query (sub_srcpad, query);
|
|
|
|
gst_object_unref (sub_srcpad);
|
|
gst_object_unref (subelement);
|
|
} else {
|
|
GST_WARNING_OBJECT (autoconvert,
|
|
"Got upstream query while no element was selected," "forwarding.");
|
|
ret = gst_pad_peer_query (autoconvert->sinkpad, query);
|
|
}
|
|
|
|
gst_object_unref (autoconvert);
|
|
|
|
return ret;
|
|
}
|
|
|
|
/* TODO Properly test that this code works well for queries */
|
|
static const GstQueryType *
|
|
gst_auto_convert_src_query_type (GstPad * pad)
|
|
{
|
|
const GstQueryType *ret = NULL;
|
|
GstAutoConvert *autoconvert = GST_AUTO_CONVERT (gst_pad_get_parent (pad));
|
|
GstElement *subelement;
|
|
|
|
subelement = gst_auto_convert_get_subelement (autoconvert, TRUE);
|
|
if (subelement) {
|
|
GstPad *sub_srcpad = get_pad_by_direction (subelement, GST_PAD_SRC);
|
|
|
|
ret = gst_pad_get_query_types (sub_srcpad);
|
|
|
|
gst_object_unref (sub_srcpad);
|
|
gst_object_unref (subelement);
|
|
} else {
|
|
ret = gst_pad_get_query_types_default (pad);
|
|
}
|
|
|
|
gst_object_unref (autoconvert);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static GstFlowReturn
|
|
gst_auto_convert_internal_sink_chain (GstPad * pad, GstBuffer * buffer)
|
|
{
|
|
GstAutoConvert *autoconvert =
|
|
GST_AUTO_CONVERT (g_object_get_qdata (G_OBJECT (pad),
|
|
parent_quark));
|
|
|
|
return gst_pad_push (autoconvert->srcpad, buffer);
|
|
}
|
|
|
|
static gboolean
|
|
gst_auto_convert_internal_sink_event (GstPad * pad, GstEvent * event)
|
|
{
|
|
GstAutoConvert *autoconvert =
|
|
GST_AUTO_CONVERT (g_object_get_qdata (G_OBJECT (pad),
|
|
parent_quark));
|
|
|
|
if (GST_EVENT_TYPE (event) == GST_EVENT_NEWSEGMENT) {
|
|
if (autoconvert->drop_newseg) {
|
|
GST_DEBUG_OBJECT (autoconvert, "Dropping primer newsegment event");
|
|
gst_event_unref (event);
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
return gst_pad_push_event (autoconvert->srcpad, event);
|
|
}
|
|
|
|
static gboolean
|
|
gst_auto_convert_internal_sink_query (GstPad * pad, GstQuery * query)
|
|
{
|
|
GstAutoConvert *autoconvert =
|
|
GST_AUTO_CONVERT (g_object_get_qdata (G_OBJECT (pad),
|
|
parent_quark));
|
|
GstPad *peerpad = gst_pad_get_peer (autoconvert->srcpad);
|
|
gboolean ret = FALSE;
|
|
|
|
if (peerpad) {
|
|
ret = gst_pad_query (peerpad, query);
|
|
gst_object_unref (peerpad);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static const GstQueryType *
|
|
gst_auto_convert_internal_sink_query_type (GstPad * pad)
|
|
{
|
|
GstAutoConvert *autoconvert =
|
|
GST_AUTO_CONVERT (g_object_get_qdata (G_OBJECT (pad),
|
|
parent_quark));
|
|
GstPad *peerpad = gst_pad_get_peer (autoconvert->srcpad);
|
|
const GstQueryType *ret = NULL;
|
|
|
|
if (peerpad) {
|
|
ret = gst_pad_get_query_types (peerpad);
|
|
gst_object_unref (peerpad);
|
|
} else
|
|
ret = gst_pad_get_query_types_default (pad);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static GstCaps *
|
|
gst_auto_convert_internal_sink_getcaps (GstPad * pad)
|
|
{
|
|
GstAutoConvert *autoconvert =
|
|
GST_AUTO_CONVERT (g_object_get_qdata (G_OBJECT (pad),
|
|
parent_quark));
|
|
|
|
return gst_pad_peer_get_caps (autoconvert->srcpad);
|
|
}
|
|
|
|
static void
|
|
gst_auto_convert_internal_sink_fixatecaps (GstPad * pad, GstCaps * caps)
|
|
{
|
|
GstAutoConvert *autoconvert =
|
|
GST_AUTO_CONVERT (g_object_get_qdata (G_OBJECT (pad),
|
|
parent_quark));
|
|
GstPad *peerpad = gst_pad_get_peer (autoconvert->sinkpad);
|
|
|
|
if (peerpad) {
|
|
gst_pad_fixate_caps (peerpad, caps);
|
|
gst_object_unref (peerpad);
|
|
}
|
|
}
|
|
|
|
static GstFlowReturn
|
|
gst_auto_convert_internal_sink_buffer_alloc (GstPad * pad, guint64 offset,
|
|
guint size, GstCaps * caps, GstBuffer ** buf)
|
|
{
|
|
GstAutoConvert *autoconvert =
|
|
GST_AUTO_CONVERT (g_object_get_qdata (G_OBJECT (pad),
|
|
parent_quark));
|
|
|
|
return gst_pad_alloc_buffer (autoconvert->srcpad, offset, size, caps, buf);
|
|
}
|
|
|
|
static gboolean
|
|
gst_auto_convert_internal_src_event (GstPad * pad, GstEvent * event)
|
|
{
|
|
GstAutoConvert *autoconvert =
|
|
GST_AUTO_CONVERT (g_object_get_qdata (G_OBJECT (pad),
|
|
parent_quark));
|
|
|
|
return gst_pad_push_event (autoconvert->sinkpad, event);
|
|
}
|
|
|
|
static gboolean
|
|
gst_auto_convert_internal_src_query (GstPad * pad, GstQuery * query)
|
|
{
|
|
GstAutoConvert *autoconvert =
|
|
GST_AUTO_CONVERT (g_object_get_qdata (G_OBJECT (pad),
|
|
parent_quark));
|
|
GstPad *peerpad = gst_pad_get_peer (autoconvert->sinkpad);
|
|
gboolean ret = FALSE;
|
|
|
|
if (peerpad) {
|
|
ret = gst_pad_query (peerpad, query);
|
|
gst_object_unref (peerpad);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static const GstQueryType *
|
|
gst_auto_convert_internal_src_query_type (GstPad * pad)
|
|
{
|
|
GstAutoConvert *autoconvert =
|
|
GST_AUTO_CONVERT (g_object_get_qdata (G_OBJECT (pad),
|
|
parent_quark));
|
|
GstPad *peerpad = gst_pad_get_peer (autoconvert->sinkpad);
|
|
const GstQueryType *ret = NULL;
|
|
|
|
if (peerpad) {
|
|
ret = gst_pad_get_query_types (peerpad);
|
|
gst_object_unref (peerpad);
|
|
} else {
|
|
ret = gst_pad_get_query_types_default (pad);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
gboolean
|
|
gst_auto_convert_plugin_init (GstPlugin * plugin)
|
|
{
|
|
return gst_element_register (plugin, "autoconvert",
|
|
GST_RANK_NONE, GST_TYPE_AUTO_CONVERT);
|
|
}
|
|
|
|
GST_PLUGIN_DEFINE (GST_VERSION_MAJOR,
|
|
GST_VERSION_MINOR,
|
|
"autoconvert",
|
|
"Selects convertor element based on caps",
|
|
gst_auto_convert_plugin_init, VERSION, GST_LICENSE, GST_PACKAGE_NAME,
|
|
GST_PACKAGE_ORIGIN)
|