mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2024-11-15 22:01:27 +00:00
Code Issues 1 Projects Releases Wiki Activity
gstreamer/gst/switchbin/gstswitchbin.c
Jan Schmidt bd9f675318 switchbin: When collecting srcpad caps, don't intersect with path caps. 
The path caps describe the input caps that will select each path, don't
intersect those with the srcpad caps, which could be completely
different. Instead, when querying allowed caps for the srcpad, just
construct the union of all possible output caps from all path srcpads.

Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-plugins-bad/-/merge_requests/2018>
2021-04-12 14:27:00 +00:00

1181 lines
38 KiB
C
Raw Blame History

/* switchbin
* Copyright (C) 2016 Carlos Rafael Giani
*
* gstswitchbin.c: Element for switching between paths based on input caps
*
* 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.
*/
/**
* SECTION:element-switchbin
* @title: switchbin
*
* switchbin is a helper element which chooses between a set of
* processing chains (paths) based on input caps, and changes if new caps
* arrive. Paths are child objects, which are accessed by the
* #GstChildProxy interface.
*
* Whenever new input caps are encountered at the switchbin's sinkpad,
* the * first path with matching caps is picked. The paths are looked at
* in order: path \#0's caps are looked at first, checked against the new
* input caps with gst_caps_can_intersect(), and if its return value
* is TRUE, path \#0 is picked. Otherwise, path \#1's caps are looked at etc.
* If no path matches, an error is reported.
*
* <refsect2>
* <title>Example launch line</title>
*
* In this example, if the data is raw PCM audio with 44.1 kHz, a volume
* element is used for reducing the audio volume to 10%. Otherwise, it is
* just passed through. So, a 44.1 kHz MP3 will sound quiet, a 48 kHz MP3
* will be at full volume.
*
* |[
* gst-launch-1.0 uridecodebin uri=<URI> ! switchbin num-paths=2 \
* path0::element="audioconvert ! volume volume=0.1" path0::caps="audio/x-raw, rate=44100" \
* path1::element="identity" path1::caps="ANY" ! \
* autoaudiosink
* ]|
*
* This example's path \#1 is a fallback "catch-all" path. Its caps are "ANY" caps,
* so any input caps will match against this. A catch-all path with an identity element
* is useful for cases where certain kinds of processing should only be done for specific
* formats, like the example above (it applies volume only to 44.1 kHz PCM audio).
* </refsect2>
*
*/
#include <string.h>
#include <stdio.h>
#include "gstswitchbin.h"
GST_DEBUG_CATEGORY (switch_bin_debug);
#define GST_CAT_DEFAULT switch_bin_debug
enum
{
PROP_0,
PROP_NUM_PATHS,
PROP_CURRENT_PATH,
PROP_LAST
};
#define DEFAULT_NUM_PATHS 0
GParamSpec *switchbin_props[PROP_LAST];
#define PATH_LOCK(obj) g_mutex_lock(&(GST_SWITCH_BIN_CAST (obj)->path_mutex))
#define PATH_UNLOCK(obj) g_mutex_unlock(&(GST_SWITCH_BIN_CAST (obj)->path_mutex))
#define PATH_UNLOCK_AND_CHECK(obj) gst_switch_bin_unlock_paths_and_notify(GST_SWITCH_BIN_CAST (obj));
static GstStaticPadTemplate static_sink_template =
GST_STATIC_PAD_TEMPLATE ("sink",
GST_PAD_SINK,
GST_PAD_ALWAYS,
GST_STATIC_CAPS_ANY);
static GstStaticPadTemplate static_src_template =
GST_STATIC_PAD_TEMPLATE ("src",
GST_PAD_SRC,
GST_PAD_ALWAYS,
GST_STATIC_CAPS_ANY);
static void gst_switch_bin_child_proxy_iface_init (gpointer iface,
gpointer iface_data);
static GObject *gst_switch_bin_child_proxy_get_child_by_index (GstChildProxy *
child_proxy, guint index);
static guint gst_switch_bin_child_proxy_get_children_count (GstChildProxy *
child_proxy);
G_DEFINE_TYPE_WITH_CODE (GstSwitchBin,
gst_switch_bin,
GST_TYPE_BIN,
G_IMPLEMENT_INTERFACE (GST_TYPE_CHILD_PROXY,
gst_switch_bin_child_proxy_iface_init)
);
GST_ELEMENT_REGISTER_DEFINE (switchbin, "switchbin", GST_RANK_NONE,
gst_switch_bin_get_type ());
static void gst_switch_bin_unlock_paths_and_notify (GstSwitchBin * switchbin);
static void gst_switch_bin_dispose (GObject * object);
static void gst_switch_bin_finalize (GObject * object);
static void gst_switch_bin_set_property (GObject * object, guint prop_id,
GValue const *value, GParamSpec * pspec);
static void gst_switch_bin_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec);
static gboolean gst_switch_bin_sink_event (GstPad * pad,
GstObject * parent, GstEvent * event);
static gboolean gst_switch_bin_sink_query (GstPad * pad,
GstObject * parent, GstQuery * query);
static gboolean gst_switch_bin_src_query (GstPad * pad, GstObject * parent,
GstQuery * query);
static gboolean gst_switch_bin_set_num_paths (GstSwitchBin * switch_bin,
guint new_num_paths);
static gboolean gst_switch_bin_select_path_for_caps (GstSwitchBin *
switch_bin, GstCaps * caps);
static gboolean gst_switch_bin_switch_to_path (GstSwitchBin * switch_bin,
GstSwitchBinPath * switch_bin_path);
static GstSwitchBinPath *gst_switch_bin_find_matching_path (GstSwitchBin *
switch_bin, GstCaps const *caps);
static void gst_switch_bin_set_sinkpad_block (GstSwitchBin * switch_bin,
gboolean do_block);
static GstPadProbeReturn gst_switch_bin_blocking_pad_probe (GstPad * pad,
GstPadProbeInfo * info, gpointer user_data);
static GstCaps *gst_switch_bin_get_allowed_caps (GstSwitchBin * switch_bin,
GstPad * switch_bin_pad, gchar const *pad_name, GstCaps * filter);
static gboolean gst_switch_bin_are_caps_acceptable (GstSwitchBin *
switch_bin, GstCaps const *caps);
static void
gst_switch_bin_unlock_paths_and_notify (GstSwitchBin * switchbin)
{
gboolean do_notify = switchbin->path_changed;
switchbin->path_changed = FALSE;
PATH_UNLOCK (switchbin);
if (do_notify)
g_object_notify_by_pspec (G_OBJECT (switchbin),
switchbin_props[PROP_CURRENT_PATH]);
}
static void
gst_switch_bin_child_proxy_iface_init (gpointer iface,
G_GNUC_UNUSED gpointer iface_data)
{
GstChildProxyInterface *child_proxy_iface = iface;
child_proxy_iface->get_child_by_index =
GST_DEBUG_FUNCPTR (gst_switch_bin_child_proxy_get_child_by_index);
child_proxy_iface->get_children_count =
GST_DEBUG_FUNCPTR (gst_switch_bin_child_proxy_get_children_count);
}
static GObject *
gst_switch_bin_child_proxy_get_child_by_index (GstChildProxy * child_proxy,
guint index)
{
GObject *result;
GstSwitchBin *switch_bin = GST_SWITCH_BIN (child_proxy);
PATH_LOCK (switch_bin);
if (G_UNLIKELY (index >= switch_bin->num_paths))
result = NULL;
else
result = g_object_ref (G_OBJECT (switch_bin->paths[index]));
PATH_UNLOCK (switch_bin);
return result;
}
static guint
gst_switch_bin_child_proxy_get_children_count (GstChildProxy * child_proxy)
{
guint result;
GstSwitchBin *switch_bin = GST_SWITCH_BIN (child_proxy);
PATH_LOCK (switch_bin);
result = switch_bin->num_paths;
PATH_UNLOCK (switch_bin);
return result;
}
static void
gst_switch_bin_class_init (GstSwitchBinClass * klass)
{
GObjectClass *object_class;
GstElementClass *element_class;
GST_DEBUG_CATEGORY_INIT (switch_bin_debug, "switchbin", 0, "switch bin");
object_class = G_OBJECT_CLASS (klass);
element_class = GST_ELEMENT_CLASS (klass);
gst_element_class_add_pad_template (element_class,
gst_static_pad_template_get (&static_sink_template));
gst_element_class_add_pad_template (element_class,
gst_static_pad_template_get (&static_src_template));
object_class->dispose = GST_DEBUG_FUNCPTR (gst_switch_bin_dispose);
object_class->finalize = GST_DEBUG_FUNCPTR (gst_switch_bin_finalize);
object_class->set_property = GST_DEBUG_FUNCPTR (gst_switch_bin_set_property);
object_class->get_property = GST_DEBUG_FUNCPTR (gst_switch_bin_get_property);
/**
* GstSwitchBin:num-paths
*
* Configure how many paths the switchbin will be choosing between. Attempting
* to configure a path outside the range 0..(n-1) will fail. Reducing the
* number of paths will release any paths outside the new range, which might
* trigger activation of a new path by re-assessing the current caps.
*/
switchbin_props[PROP_NUM_PATHS] = g_param_spec_uint ("num-paths",
"Number of paths", "Number of paths", 0, G_MAXUINT - 1,
DEFAULT_NUM_PATHS, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
g_object_class_install_property (object_class,
PROP_NUM_PATHS, switchbin_props[PROP_NUM_PATHS]);
/**
* GstSwitchBin:current-path
*
* Returns the currently selected path number. If there is no current
* path (due to no caps, or unsupported caps), the value is #G_MAXUINT. Read-only.
*/
switchbin_props[PROP_CURRENT_PATH] =
g_param_spec_uint ("current-path", "Current Path",
"Currently selected path", 0, G_MAXUINT,
0, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
g_object_class_install_property (object_class,
PROP_CURRENT_PATH, switchbin_props[PROP_CURRENT_PATH]);
gst_element_class_set_static_metadata (element_class,
"switchbin",
"Generic/Bin",
"Switch between sub-pipelines (paths) based on input caps",
"Carlos Rafael Giani <dv@pseudoterminal.org>");
}
static void
gst_switch_bin_init (GstSwitchBin * switch_bin)
{
GstPad *pad;
switch_bin->num_paths = DEFAULT_NUM_PATHS;
switch_bin->paths = NULL;
switch_bin->current_path = NULL;
switch_bin->last_stream_start = NULL;
switch_bin->blocking_probe_id = 0;
switch_bin->drop_probe_id = 0;
switch_bin->last_caps = NULL;
switch_bin->sinkpad = gst_ghost_pad_new_no_target_from_template ("sink",
gst_element_class_get_pad_template (GST_ELEMENT_GET_CLASS (switch_bin),
"sink")
);
gst_element_add_pad (GST_ELEMENT (switch_bin), switch_bin->sinkpad);
switch_bin->srcpad = gst_ghost_pad_new_no_target_from_template ("src",
gst_element_class_get_pad_template (GST_ELEMENT_GET_CLASS (switch_bin),
"src")
);
gst_element_add_pad (GST_ELEMENT (switch_bin), switch_bin->srcpad);
gst_pad_set_event_function (switch_bin->sinkpad, gst_switch_bin_sink_event);
gst_pad_set_query_function (switch_bin->sinkpad, gst_switch_bin_sink_query);
gst_pad_set_query_function (switch_bin->srcpad, gst_switch_bin_src_query);
switch_bin->input_identity =
gst_element_factory_make ("identity", "input-identity");
gst_bin_add (GST_BIN (switch_bin), switch_bin->input_identity);
pad = gst_element_get_static_pad (switch_bin->input_identity, "sink");
gst_ghost_pad_set_target (GST_GHOST_PAD (switch_bin->sinkpad), pad);
gst_object_unref (GST_OBJECT (pad));
}
static void
gst_switch_bin_dispose (GObject * object)
{
GstSwitchBin *switch_bin = GST_SWITCH_BIN (object);
guint i;
/* Chaining up will release all children of the bin,
* invalidating any pointer to elements in the paths, so make sure
* and clear those first */
PATH_LOCK (switch_bin);
for (i = 0; i < switch_bin->num_paths; ++i) {
if (switch_bin->paths[i])
switch_bin->paths[i]->element = NULL;
}
PATH_UNLOCK (switch_bin);
G_OBJECT_CLASS (gst_switch_bin_parent_class)->dispose (object);
}
static void
gst_switch_bin_finalize (GObject * object)
{
GstSwitchBin *switch_bin = GST_SWITCH_BIN (object);
guint i;
if (switch_bin->last_caps != NULL)
gst_caps_unref (switch_bin->last_caps);
if (switch_bin->last_stream_start != NULL)
gst_event_unref (switch_bin->last_stream_start);
for (i = 0; i < switch_bin->num_paths; ++i) {
gst_object_unparent (GST_OBJECT (switch_bin->paths[i]));
}
g_free (switch_bin->paths);
G_OBJECT_CLASS (gst_switch_bin_parent_class)->finalize (object);
}
static void
gst_switch_bin_set_property (GObject * object, guint prop_id,
GValue const *value, GParamSpec * pspec)
{
GstSwitchBin *switch_bin = GST_SWITCH_BIN (object);
switch (prop_id) {
case PROP_NUM_PATHS:
PATH_LOCK (switch_bin);
gst_switch_bin_set_num_paths (switch_bin, g_value_get_uint (value));
PATH_UNLOCK_AND_CHECK (switch_bin);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
gst_switch_bin_get_property (GObject * object, guint prop_id, GValue * value,
GParamSpec * pspec)
{
GstSwitchBin *switch_bin = GST_SWITCH_BIN (object);
switch (prop_id) {
case PROP_NUM_PATHS:
PATH_LOCK (switch_bin);
g_value_set_uint (value, switch_bin->num_paths);
PATH_UNLOCK_AND_CHECK (switch_bin);
break;
case PROP_CURRENT_PATH:
PATH_LOCK (switch_bin);
if (switch_bin->current_path) {
guint i;
for (i = 0; i < switch_bin->num_paths; ++i) {
if (switch_bin->paths[i] == switch_bin->current_path) {
g_value_set_uint (value, i);
break;
}
}
} else {
/* No valid path, return MAXUINT */
g_value_set_uint (value, G_MAXUINT);
}
PATH_UNLOCK (switch_bin);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static gboolean
gst_switch_bin_sink_event (GstPad * pad, GstObject * parent, GstEvent * event)
{
GstSwitchBin *switch_bin = GST_SWITCH_BIN (parent);
switch (GST_EVENT_TYPE (event)) {
case GST_EVENT_STREAM_START:
{
GST_DEBUG_OBJECT (switch_bin,
"stream-start event observed; copying it for later use");
gst_event_replace (&(switch_bin->last_stream_start), event);
return gst_pad_event_default (pad, parent, event);
}
case GST_EVENT_CAPS:
{
/* Intercept the caps event to switch to an appropriate path, then
* resume default caps event processing */
GstCaps *caps;
gboolean ret;
gst_event_parse_caps (event, &caps);
GST_DEBUG_OBJECT (switch_bin,
"sink pad got caps event with caps %" GST_PTR_FORMAT
" ; looking for matching path", (gpointer) caps);
PATH_LOCK (switch_bin);
ret = gst_switch_bin_select_path_for_caps (switch_bin, caps);
PATH_UNLOCK_AND_CHECK (switch_bin);
if (!ret) {
gst_event_unref (event);
return FALSE;
} else
return gst_pad_event_default (pad, parent, event);
}
default:
GST_DEBUG_OBJECT (switch_bin, "sink event: %s",
gst_event_type_get_name (GST_EVENT_TYPE (event)));
return gst_pad_event_default (pad, parent, event);
}
}
static gboolean
gst_switch_bin_handle_query (GstPad * pad, GstObject * parent, GstQuery * query,
char const *pad_name)
{
GstSwitchBin *switch_bin = GST_SWITCH_BIN (parent);
switch (GST_QUERY_TYPE (query)) {
case GST_QUERY_CAPS:
{
GstCaps *filter, *caps;
gst_query_parse_caps (query, &filter);
PATH_LOCK (switch_bin);
if (switch_bin->num_paths == 0) {
/* No paths exist - cannot return any caps */
caps = NULL;
} else if ((switch_bin->current_path == NULL)
|| (switch_bin->current_path->element == NULL)) {
/* Paths exist, but there is no current path (or the path is a dropping path,
* so no element exists) - just return all allowed caps */
caps =
gst_switch_bin_get_allowed_caps (switch_bin, pad, pad_name, filter);
} else {
/* Paths exist and there is a current path
* Forward the query to its element */
GstQuery *caps_query = gst_query_new_caps (NULL);
GstPad *element_pad =
gst_element_get_static_pad (switch_bin->current_path->element,
pad_name);
caps = NULL;
if (gst_pad_query (element_pad, caps_query)) {
GstCaps *query_caps;
gst_query_parse_caps_result (caps_query, &query_caps);
caps = gst_caps_copy (query_caps);
}
gst_query_unref (caps_query);
gst_object_unref (GST_OBJECT (element_pad));
}
PATH_UNLOCK (switch_bin);
if (caps != NULL) {
GST_DEBUG_OBJECT (switch_bin, "%s caps query: caps: %" GST_PTR_FORMAT,
pad_name, (gpointer) caps);
gst_query_set_caps_result (query, caps);
gst_caps_unref (caps);
return TRUE;
} else
return FALSE;
}
case GST_QUERY_ACCEPT_CAPS:
{
GstCaps *caps;
gboolean acceptable;
gst_query_parse_accept_caps (query, &caps);
PATH_LOCK (switch_bin);
acceptable = gst_switch_bin_are_caps_acceptable (switch_bin, caps);
PATH_UNLOCK (switch_bin);
GST_DEBUG_OBJECT (switch_bin,
"%s accept_caps query: acceptable: %d caps: %" GST_PTR_FORMAT,
pad_name, (gint) acceptable, (gpointer) caps);
gst_query_set_accept_caps_result (query, acceptable);
return TRUE;
}
default:
return gst_pad_query_default (pad, parent, query);
}
}
static gboolean
gst_switch_bin_sink_query (GstPad * pad, GstObject * parent, GstQuery * query)
{
return gst_switch_bin_handle_query (pad, parent, query, "sink");
}
static gboolean
gst_switch_bin_src_query (GstPad * pad, GstObject * parent, GstQuery * query)
{
return gst_switch_bin_handle_query (pad, parent, query, "src");
}
static gboolean
gst_switch_bin_set_num_paths (GstSwitchBin * switch_bin, guint new_num_paths)
{
guint i;
gboolean cur_path_removed = FALSE;
/* must be called with path lock held */
if (switch_bin->num_paths == new_num_paths) {
GST_DEBUG_OBJECT (switch_bin,
"no change in number of paths - ignoring call");
return TRUE;
} else if (switch_bin->num_paths < new_num_paths) {
/* New number of paths is larger -> N new paths need to be created & added,
* where N = new_num_paths - switch_bin->num_paths. */
GST_DEBUG_OBJECT (switch_bin, "adding %u new paths",
new_num_paths - switch_bin->num_paths);
switch_bin->paths =
g_realloc (switch_bin->paths, sizeof (GstObject *) * new_num_paths);
for (i = switch_bin->num_paths; i < new_num_paths; ++i) {
GstSwitchBinPath *path;
gchar *path_name;
/* default names would be something like "switchbinpath0" */
path_name = g_strdup_printf ("path%u", i);
switch_bin->paths[i] = path =
g_object_new (gst_switch_bin_path_get_type (), "name", path_name,
NULL);
path->bin = switch_bin;
gst_object_set_parent (GST_OBJECT (path), GST_OBJECT (switch_bin));
gst_child_proxy_child_added (GST_CHILD_PROXY (switch_bin),
G_OBJECT (path), path_name);
GST_DEBUG_OBJECT (switch_bin, "added path #%u \"%s\" (%p)", i, path_name,
(gpointer) path);
g_free (path_name);
}
} else {
/* New number of paths is smaller -> the last N paths need to be removed,
* where N = switch_bin->num_paths - new_num_paths. If one of the paths
* that are being removed is the current path, then a new current path
* is selected. */
gchar *path_name;
GST_DEBUG_OBJECT (switch_bin, "removing the last %u paths",
switch_bin->num_paths - new_num_paths);
for (i = new_num_paths; i < switch_bin->num_paths; ++i) {
GstSwitchBinPath *path = switch_bin->paths[i];
path_name = g_strdup (GST_OBJECT_NAME (path));
if (path == switch_bin->current_path) {
cur_path_removed = TRUE;
gst_switch_bin_switch_to_path (switch_bin, NULL);
GST_DEBUG_OBJECT (switch_bin,
"path #%u \"%s\" (%p) is the current path - selecting a new current path will be necessary",
i, path_name, (gpointer) (switch_bin->paths[i]));
}
gst_child_proxy_child_removed (GST_CHILD_PROXY (switch_bin),
G_OBJECT (path), path_name);
gst_object_unparent (GST_OBJECT (switch_bin->paths[i]));
GST_DEBUG_OBJECT (switch_bin, "removed path #%u \"%s\" (%p)", i,
path_name, (gpointer) (switch_bin->paths[i]));
g_free (path_name);
}
switch_bin->paths =
g_realloc (switch_bin->paths, sizeof (GstObject *) * new_num_paths);
}
switch_bin->num_paths = new_num_paths;
if (new_num_paths > 0) {
if (cur_path_removed) {
/* Select a new current path if the previous one was removed above */
if (switch_bin->last_caps != NULL) {
GST_DEBUG_OBJECT (switch_bin,
"current path was removed earlier - need to select a new one based on the last caps %"
GST_PTR_FORMAT, (gpointer) (switch_bin->last_caps));
return gst_switch_bin_select_path_for_caps (switch_bin,
switch_bin->last_caps);
} else {
/* This should not happen. Every time a current path is selected, the
* caps that were used for the selection are copied as the last_caps.
* So, if a current path exists, but last_caps is NULL, it indicates
* a bug. For example, if the current path was selected without calling
* gst_switch_bin_select_path_for_caps(). */
g_assert_not_reached ();
return FALSE; /* shuts up compiler warning */
}
} else
return TRUE;
} else
return gst_switch_bin_switch_to_path (switch_bin, NULL);
}
static gboolean
gst_switch_bin_select_path_for_caps (GstSwitchBin * switch_bin, GstCaps * caps)
{
/* must be called with path lock held */
gboolean ret;
GstSwitchBinPath *path;
path = gst_switch_bin_find_matching_path (switch_bin, caps);
if (path == NULL) {
/* No matching path found, the caps are incompatible. Report this and exit. */
GST_ELEMENT_ERROR (switch_bin, STREAM, WRONG_TYPE,
("could not find compatible path"), ("sink caps: %" GST_PTR_FORMAT,
(gpointer) caps));
ret = FALSE;
} else {
/* Matching path found. Try to switch to it. */
GST_DEBUG_OBJECT (switch_bin, "found matching path \"%s\" (%p) - switching",
GST_OBJECT_NAME (path), (gpointer) path);
ret = gst_switch_bin_switch_to_path (switch_bin, path);
}
if (ret && (caps != switch_bin->last_caps))
gst_caps_replace (&(switch_bin->last_caps), caps);
return ret;
}
static gboolean
gst_switch_bin_switch_to_path (GstSwitchBin * switch_bin,
GstSwitchBinPath * switch_bin_path)
{
/* must be called with path lock held */
gboolean ret = TRUE;
if (switch_bin_path != NULL)
GST_DEBUG_OBJECT (switch_bin, "switching to path \"%s\" (%p)",
GST_OBJECT_NAME (switch_bin_path), (gpointer) switch_bin_path);
else
GST_DEBUG_OBJECT (switch_bin,
"switching to NULL path (= disabling current path)");
/* No current path set and no path is to be set -> nothing to do */
if ((switch_bin_path == NULL) && (switch_bin->current_path == NULL))
return TRUE;
/* If this path is already the current one, do nothing */
if (switch_bin->current_path == switch_bin_path)
return TRUE;
/* Block incoming data to be able to safely switch */
gst_switch_bin_set_sinkpad_block (switch_bin, TRUE);
/* Unlink the current path's element (if there is a current path) */
if (switch_bin->current_path != NULL) {
GstSwitchBinPath *cur_path = switch_bin->current_path;
if (cur_path->element != NULL) {
gst_element_set_state (cur_path->element, GST_STATE_NULL);
gst_element_unlink (switch_bin->input_identity, cur_path->element);
}
gst_ghost_pad_set_target (GST_GHOST_PAD (switch_bin->srcpad), NULL);
switch_bin->current_path = NULL;
switch_bin->path_changed = TRUE;
}
/* Link the new path's element (if a new path is specified) */
if (switch_bin_path != NULL) {
if (switch_bin_path->element != NULL) {
GstPad *pad;
/* There is a path element. Link it into the pipeline. Data passes through
* it now, since its associated path just became the current one. */
/* TODO: currently, only elements with one "src" "sink" always-pad are supported;
* add support for request and sometimes pads */
pad = gst_element_get_static_pad (switch_bin_path->element, "src");
if (pad == NULL) {
GST_ERROR_OBJECT (switch_bin,
"path element has no static srcpad - cannot link");
ret = FALSE;
goto finish;
}
if (!gst_ghost_pad_set_target (GST_GHOST_PAD (switch_bin->srcpad), pad)) {
GST_ERROR_OBJECT (switch_bin,
"could not set the path element's srcpad as the ghost srcpad's target");
ret = FALSE;
}
gst_object_unref (GST_OBJECT (pad));
if (!ret)
goto finish;
if (!gst_element_link (switch_bin->input_identity,
switch_bin_path->element)) {
GST_ERROR_OBJECT (switch_bin,
"linking the path element's sinkpad failed ; check if the path element's sink caps and the upstream elements connected to the switchbin's sinkpad match");
ret = FALSE;
goto finish;
}
/* Unlock the element's state in case it was locked earlier
* so its state can be synced to the switchbin's */
gst_element_set_locked_state (switch_bin_path->element, FALSE);
if (!gst_element_sync_state_with_parent (switch_bin_path->element)) {
GST_ERROR_OBJECT (switch_bin,
"could not sync the path element's state with that of the switchbin");
ret = FALSE;
goto finish;
}
} else {
GstPad *srcpad;
/* There is no path element. This will probably yield an error
* into the pipeline unless we're shutting down */
GST_DEBUG_OBJECT (switch_bin, "path has no element ; will drop data");
srcpad = gst_element_get_static_pad (switch_bin->input_identity, "src");
g_assert (srcpad != NULL);
if (!gst_ghost_pad_set_target (GST_GHOST_PAD (switch_bin->srcpad),
srcpad)) {
GST_ERROR_OBJECT (switch_bin,
"could not set the path element's srcpad as the ghost srcpad's target");
ret = FALSE;
}
GST_DEBUG_OBJECT (switch_bin,
"pushing stream-start downstream before disabling");
gst_element_send_event (switch_bin->input_identity,
gst_event_ref (switch_bin->last_stream_start));
gst_object_unref (GST_OBJECT (srcpad));
}
}
switch_bin->current_path = switch_bin_path;
switch_bin->path_changed = TRUE;
/* If there is a new path to use, unblock the input */
if (switch_bin_path != NULL)
gst_switch_bin_set_sinkpad_block (switch_bin, FALSE);
finish:
return ret;
}
static GstSwitchBinPath *
gst_switch_bin_find_matching_path (GstSwitchBin * switch_bin,
GstCaps const *caps)
{
/* must be called with path lock held */
guint i;
for (i = 0; i < switch_bin->num_paths; ++i) {
GstSwitchBinPath *path = switch_bin->paths[i];
if (gst_caps_can_intersect (caps, path->caps))
return path;
}
return NULL;
}
static GstCaps *
gst_switch_bin_get_allowed_caps (GstSwitchBin * switch_bin,
GstPad * switch_bin_pad, gchar const *pad_name, GstCaps * filter)
{
/* must be called with path lock held */
guint i;
GstCaps *total_path_caps;
gboolean is_sink_pad =
(gst_pad_get_direction (switch_bin_pad) == GST_PAD_SINK);
/* The allowed caps are a combination of the caps of all paths, the
* filter caps, and the allowed caps as indicated by the result
* of the CAPS query on the current path's element.
* Since the CAPS query result can be influenced by an element's
* current state and link to other elements, the non-current
* path elements are not queried.
*
* In theory, it would be enough to just append all path caps. However,
* to refine this a bit further, in case of the current path, the
* path caps are first intersected with the result of the CAPS query.
* This narrows down the acceptable caps for this current path,
* hopefully providing better quality caps. */
if (switch_bin->num_paths == 0) {
/* No paths exist, so nothing can be returned */
GST_ELEMENT_ERROR (switch_bin, STREAM, FAILED, ("no paths defined"),
("there must be at least one path in order for switchbin to do anything"));
return NULL;
}
total_path_caps = gst_caps_new_empty ();
for (i = 0; i < switch_bin->num_paths; ++i) {
GstSwitchBinPath *path = switch_bin->paths[i];
if (path->element != NULL) {
GstPad *pad;
GstCaps *caps, *intersected_caps;
GstQuery *caps_query = NULL;
pad = gst_element_get_static_pad (path->element, pad_name);
caps_query = gst_query_new_caps (NULL);
/* Query the path element for allowed caps. If this is
* successful, intersect the returned caps with the path caps for the sink pad,
* and append the result of the intersection to the total_path_caps,
* or just append the result to the total_path_caps if collecting srcpad caps. */
if (gst_pad_query (pad, caps_query)) {
gst_query_parse_caps_result (caps_query, &caps);
if (is_sink_pad) {
intersected_caps = gst_caps_intersect (caps, path->caps);
} else {
intersected_caps = gst_caps_copy (caps);
}
gst_caps_append (total_path_caps, intersected_caps);
} else if (is_sink_pad) {
/* Just assume the sink pad has the path caps if the query failed */
gst_caps_append (total_path_caps, gst_caps_ref (path->caps));
}
gst_object_unref (GST_OBJECT (pad));
gst_query_unref (caps_query);
} else {
/* This is a path with no element (= is a dropping path),
* If querying the sink caps, append the path
* input caps, otherwise the output caps can be ANY */
if (is_sink_pad)
gst_caps_append (total_path_caps, gst_caps_ref (path->caps));
else
gst_caps_append (total_path_caps, gst_caps_new_any ());
}
}
/* Apply filter caps if present */
if (filter != NULL) {
GstCaps *tmp_caps = total_path_caps;
total_path_caps = gst_caps_intersect (tmp_caps, filter);
gst_caps_unref (tmp_caps);
}
return total_path_caps;
}
static gboolean
gst_switch_bin_are_caps_acceptable (GstSwitchBin * switch_bin,
GstCaps const *caps)
{
/* must be called with path lock held */
return (gst_switch_bin_find_matching_path (switch_bin, caps) != NULL);
}
static void
gst_switch_bin_set_sinkpad_block (GstSwitchBin * switch_bin, gboolean do_block)
{
GstPad *pad;
if ((do_block && (switch_bin->blocking_probe_id != 0)) || (!do_block
&& (switch_bin->blocking_probe_id == 0)))
return;
pad = gst_element_get_static_pad (switch_bin->input_identity, "sink");
if (do_block) {
switch_bin->blocking_probe_id =
gst_pad_add_probe (pad, GST_PAD_PROBE_TYPE_BLOCK_DOWNSTREAM,
gst_switch_bin_blocking_pad_probe, NULL, NULL);
} else {
gst_pad_remove_probe (pad, switch_bin->blocking_probe_id);
switch_bin->blocking_probe_id = 0;
}
GST_DEBUG_OBJECT (switch_bin, "sinkpad block enabled: %d", do_block);
gst_object_unref (GST_OBJECT (pad));
}
static GstPadProbeReturn
gst_switch_bin_blocking_pad_probe (G_GNUC_UNUSED GstPad * pad,
GstPadProbeInfo * info, G_GNUC_UNUSED gpointer user_data)
{
if (GST_PAD_PROBE_INFO_TYPE (info) & GST_PAD_PROBE_TYPE_EVENT_DOWNSTREAM) {
GstEvent *event = GST_PAD_PROBE_INFO_EVENT (info);
switch (GST_EVENT_TYPE (event)) {
case GST_EVENT_CAPS:
case GST_EVENT_STREAM_START:
return GST_PAD_PROBE_PASS;
default:
break;
}
}
return GST_PAD_PROBE_OK;
}
/************ GstSwitchBinPath ************/
typedef struct _GstSwitchBinPathClass GstSwitchBinPathClass;
#define GST_TYPE_SWITCH_BIN_PATH (gst_switch_bin_path_get_type())
#define GST_SWITCH_BIN_PATH(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), GST_TYPE_SWITCH_BIN_PATH, GstSwitchBinPath))
#define GST_SWITCH_BIN_PATH_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), GST_TYPE_SWITCH_BIN_PATH, GstSwitchBinPathClass))
#define GST_SWITCH_BIN_PATH_CAST(obj) ((GstSwitchBinPath *)(obj))
#define GST_IS_SWITCH_BIN_PATH(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), GST_TYPE_SWITCH_BIN_PATH))
#define GST_IS_SWITCH_BIN_PATH_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GST_TYPE_SWITCH_BIN_PATH))
struct _GstSwitchBinPathClass
{
GstObjectClass parent_class;
};
enum
{
PROP_PATH_0,
PROP_ELEMENT,
PROP_PATH_CAPS
};
G_DEFINE_TYPE (GstSwitchBinPath, gst_switch_bin_path, GST_TYPE_OBJECT);
static void gst_switch_bin_path_dispose (GObject * object);
static void gst_switch_bin_path_set_property (GObject * object,
guint prop_id, GValue const *value, GParamSpec * pspec);
static void gst_switch_bin_path_get_property (GObject * object,
guint prop_id, GValue * value, GParamSpec * pspec);
static gboolean gst_switch_bin_path_use_new_element (GstSwitchBinPath *
switch_bin_path, GstElement * new_element);
static void
gst_switch_bin_path_class_init (GstSwitchBinPathClass * klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
object_class->dispose = GST_DEBUG_FUNCPTR (gst_switch_bin_path_dispose);
object_class->set_property =
GST_DEBUG_FUNCPTR (gst_switch_bin_path_set_property);
object_class->get_property =
GST_DEBUG_FUNCPTR (gst_switch_bin_path_get_property);
g_object_class_install_property (object_class,
PROP_ELEMENT,
g_param_spec_object ("element",
"Element",
"The path's element (if set to NULL, this path will drop any incoming data)",
GST_TYPE_ELEMENT, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)
);
g_object_class_install_property (object_class,
PROP_PATH_CAPS,
g_param_spec_boxed ("caps",
"Caps",
"Caps which, if they are a subset of the input caps, select this path as the active one",
GST_TYPE_CAPS, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)
);
}
static void
gst_switch_bin_path_init (GstSwitchBinPath * switch_bin_path)
{
switch_bin_path->caps = gst_caps_new_any ();
switch_bin_path->element = NULL;
switch_bin_path->bin = NULL;
}
static void
gst_switch_bin_path_dispose (GObject * object)
{
GstSwitchBinPath *switch_bin_path = GST_SWITCH_BIN_PATH (object);
if (switch_bin_path->caps != NULL) {
gst_caps_unref (switch_bin_path->caps);
switch_bin_path->caps = NULL;
}
if (switch_bin_path->element != NULL) {
gst_switch_bin_path_use_new_element (switch_bin_path, NULL);
}
/* element is managed by the bin itself */
G_OBJECT_CLASS (gst_switch_bin_path_parent_class)->dispose (object);
}
static void
gst_switch_bin_path_set_property (GObject * object, guint prop_id,
GValue const *value, GParamSpec * pspec)
{
GstSwitchBinPath *switch_bin_path = GST_SWITCH_BIN_PATH (object);
switch (prop_id) {
case PROP_ELEMENT:
{
/* Get the object without modifying the refcount */
GstElement *new_element = GST_ELEMENT (g_value_get_object (value));
GST_OBJECT_LOCK (switch_bin_path);
PATH_LOCK (switch_bin_path->bin);
gst_switch_bin_path_use_new_element (switch_bin_path, new_element);
PATH_UNLOCK_AND_CHECK (switch_bin_path->bin);
GST_OBJECT_UNLOCK (switch_bin_path);
break;
}
case PROP_PATH_CAPS:
{
GstCaps *old_caps;
GstCaps const *new_caps = gst_value_get_caps (value);
GST_OBJECT_LOCK (switch_bin_path);
old_caps = switch_bin_path->caps;
if (new_caps == NULL) {
/* NULL caps are interpreted as ANY */
switch_bin_path->caps = gst_caps_new_any ();
} else
switch_bin_path->caps = gst_caps_copy (new_caps);
GST_OBJECT_UNLOCK (switch_bin_path);
if (old_caps != NULL)
gst_caps_unref (old_caps);
/* the new caps do not get applied right away
* they only start to be used with the next stream */
break;
}
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
gst_switch_bin_path_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec)
{
GstSwitchBinPath *switch_bin_path = GST_SWITCH_BIN_PATH (object);
switch (prop_id) {
case PROP_ELEMENT:
/* If a path element exists, increase its refcount first. This is
* necessary because the code that called g_object_get() to fetch this
* element will also unref it when it is finished with it. */
if (switch_bin_path->element != NULL)
gst_object_ref (GST_OBJECT (switch_bin_path->element));
/* Use g_value_take_object() instead of g_value_set_object() as the latter
* increases the element's refcount for the duration of the GValue's lifetime */
g_value_take_object (value, switch_bin_path->element);
break;
case PROP_PATH_CAPS:
GST_OBJECT_LOCK (switch_bin_path);
gst_value_set_caps (value, switch_bin_path->caps);
GST_OBJECT_UNLOCK (switch_bin_path);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static gboolean
gst_switch_bin_path_use_new_element (GstSwitchBinPath * switch_bin_path,
GstElement * new_element)
{
/* Must be called with lock */
GstSwitchBinPath *current_path = switch_bin_path->bin->current_path;
gboolean is_current_path = (current_path == switch_bin_path);
/* Before switching the element, make sure it is not linked,
* which is the case if this is the current path. */
if (is_current_path)
gst_switch_bin_switch_to_path (switch_bin_path->bin, NULL);
/* Remove any present path element prior to using the new one */
if (switch_bin_path->element != NULL) {
gst_element_set_state (switch_bin_path->element, GST_STATE_NULL);
/* gst_bin_remove automatically unrefs the path element */
gst_bin_remove (GST_BIN (switch_bin_path->bin), switch_bin_path->element);
switch_bin_path->element = NULL;
}
/* If there *is* a new element, use it. new_element == NULL is a valid case;
* a NULL element is used in dropping paths, which will just use the drop probe
* to drop buffers if they become the current path. */
if (new_element != NULL) {
gst_bin_add (GST_BIN (switch_bin_path->bin), new_element);
switch_bin_path->element = new_element;
/* Lock the element's state in case. This prevents freezes, which can happen
* when an element from a not-current path tries to follow a state change,
* but is unable to do so as long as it isn't linked. By locking the state,
* it won't follow state changes, so the freeze does not happen. */
gst_element_set_locked_state (new_element, TRUE);
}
/* We are done. Switch back to the path if it is the current one,
* since we switched away from it earlier. */
if (is_current_path)
return gst_switch_bin_switch_to_path (switch_bin_path->bin, current_path);
else
return TRUE;
}
Reference in a new issue View git blame Copy permalink