gstreamer/plugins/nle/nleobject.c
Matthew Waters 083ae2b8ed gst: don't use volatile to mean atomic
volatile is not sufficient to provide atomic guarantees and real atomics
should be used instead.  GCC 11 has started warning about using volatile
with atomic operations.

https://gitlab.gnome.org/GNOME/glib/-/merge_requests/1719

Discovered in https://gitlab.freedesktop.org/gstreamer/gst-plugins-good/-/issues/868

Part-of: <https://gitlab.freedesktop.org/gstreamer/gst-editing-services/-/merge_requests/234>
2021-03-19 17:21:22 +11:00

859 lines
27 KiB
C

/* Gnonlin
* Copyright (C) <2001> Wim Taymans <wim.taymans@gmail.com>
* <2004-2008> Edward Hervey <bilboed@bilboed.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <string.h>
#include "nle.h"
/**
* SECTION:nleobject
* @short_description: Base class for GNonLin elements
*
* NleObject encapsulates default behaviour and implements standard
* properties provided by all the GNonLin elements.
*/
GST_DEBUG_CATEGORY_STATIC (nleobject_debug);
#define GST_CAT_DEFAULT nleobject_debug
static GObjectClass *parent_class = NULL;
/****************************************************
* Helper macros *
****************************************************/
#define CHECK_AND_SET(PROPERTY, property, prop_str, print_format) \
{ \
if (object->pending_##property != object->property) { \
object->property = object->pending_##property; \
GST_DEBUG_OBJECT(object, "Setting " prop_str " to %" \
print_format, object->property); \
} else \
GST_DEBUG_OBJECT(object, "Nothing to do for " prop_str); \
}
#define SET_PENDING_VALUE(property, property_str, type, print_format) \
nleobject->pending_##property = g_value_get_##type (value); \
if (nleobject->property != nleobject->pending_##property) { \
GST_DEBUG_OBJECT(object, "Setting pending " property_str " to %" \
print_format, nleobject->pending_##property); \
nle_object_set_commit_needed (nleobject); \
} else \
GST_DEBUG_OBJECT(object, "Pending " property_str " did not change");
enum
{
PROP_0,
PROP_START,
PROP_DURATION,
PROP_STOP,
PROP_INPOINT,
PROP_PRIORITY,
PROP_ACTIVE,
PROP_CAPS,
PROP_EXPANDABLE,
PROP_MEDIA_DURATION_FACTOR,
PROP_LAST
};
enum
{
COMMIT_SIGNAL,
LAST_SIGNAL
};
static guint _signals[LAST_SIGNAL] = { 0 };
static GParamSpec *properties[PROP_LAST];
static void nle_object_dispose (GObject * object);
static void nle_object_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec);
static void nle_object_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec);
static void nle_object_constructed (GObject * object);
static GstStateChangeReturn nle_object_change_state (GstElement * element,
GstStateChange transition);
static gboolean nle_object_prepare_func (NleObject * object);
static gboolean nle_object_cleanup_func (NleObject * object);
static gboolean nle_object_commit_func (NleObject * object, gboolean recurse);
static GstStateChangeReturn nle_object_prepare (NleObject * object);
static void
nle_object_class_init (NleObjectClass * klass)
{
GObjectClass *gobject_class;
GstElementClass *gstelement_class;
NleObjectClass *nleobject_class;
gobject_class = (GObjectClass *) klass;
gstelement_class = (GstElementClass *) klass;
nleobject_class = (NleObjectClass *) klass;
GST_DEBUG_CATEGORY_INIT (nleobject_debug, "nleobject",
GST_DEBUG_FG_BLUE | GST_DEBUG_BOLD, "GNonLin object");
parent_class = g_type_class_ref (GST_TYPE_BIN);
gobject_class->set_property = GST_DEBUG_FUNCPTR (nle_object_set_property);
gobject_class->get_property = GST_DEBUG_FUNCPTR (nle_object_get_property);
gobject_class->constructed = GST_DEBUG_FUNCPTR (nle_object_constructed);
gobject_class->dispose = GST_DEBUG_FUNCPTR (nle_object_dispose);
gstelement_class->change_state = GST_DEBUG_FUNCPTR (nle_object_change_state);
nleobject_class->prepare = GST_DEBUG_FUNCPTR (nle_object_prepare_func);
nleobject_class->cleanup = GST_DEBUG_FUNCPTR (nle_object_cleanup_func);
nleobject_class->commit_signal_handler =
GST_DEBUG_FUNCPTR (nle_object_commit);
nleobject_class->commit = GST_DEBUG_FUNCPTR (nle_object_commit_func);
/**
* NleObject:start
*
* The start position relative to the parent in nanoseconds.
*/
properties[PROP_START] = g_param_spec_uint64 ("start", "Start",
"The start position relative to the parent (in nanoseconds)",
0, G_MAXUINT64, 0, G_PARAM_READWRITE);
g_object_class_install_property (gobject_class, PROP_START,
properties[PROP_START]);
/**
* NleObject:duration
*
* The outgoing duration in nanoseconds.
*/
properties[PROP_DURATION] = g_param_spec_int64 ("duration", "Duration",
"Outgoing duration (in nanoseconds)", 0, G_MAXINT64, 0,
G_PARAM_READWRITE);
g_object_class_install_property (gobject_class, PROP_DURATION,
properties[PROP_DURATION]);
/**
* NleObject:stop
*
* The stop position relative to the parent in nanoseconds.
*
* This value is computed based on the values of start and duration.
*/
properties[PROP_STOP] = g_param_spec_uint64 ("stop", "Stop",
"The stop position relative to the parent (in nanoseconds)",
0, G_MAXUINT64, 0, G_PARAM_READABLE);
g_object_class_install_property (gobject_class, PROP_STOP,
properties[PROP_STOP]);
/**
* NleObject:inpoint
*
* The media start position in nanoseconds.
*
* Also called 'in-point' in video-editing, this corresponds to
* what position in the 'contained' object we should start outputting from.
*/
properties[PROP_INPOINT] =
g_param_spec_uint64 ("inpoint", "Media start",
"The media start position (in nanoseconds)", 0, G_MAXUINT64,
GST_CLOCK_TIME_NONE, G_PARAM_READWRITE);
g_object_class_install_property (gobject_class, PROP_INPOINT,
properties[PROP_INPOINT]);
/**
* NleObject:priority
*
* The priority of the object in the container.
*
* The highest priority is 0, meaning this object will be selected over
* any other between start and stop.
*
* The lowest priority is G_MAXUINT32.
*
* Objects whose priority is (-1) will be considered as 'default' objects
* in NleComposition and their start/stop values will be modified as to
* fit the whole duration of the composition.
*/
properties[PROP_PRIORITY] = g_param_spec_uint ("priority", "Priority",
"The priority of the object (0 = highest priority)", 0, G_MAXUINT, 0,
G_PARAM_READWRITE);
g_object_class_install_property (gobject_class, PROP_PRIORITY,
properties[PROP_PRIORITY]);
/**
* NleObject:active
*
* Indicates whether this object should be used by its container.
*
* Set to #TRUE to temporarily disable this object in a #NleComposition.
*/
properties[PROP_ACTIVE] = g_param_spec_boolean ("active", "Active",
"Use this object in the NleComposition", TRUE, G_PARAM_READWRITE);
g_object_class_install_property (gobject_class, PROP_ACTIVE,
properties[PROP_ACTIVE]);
/**
* NleObject:caps
*
* Caps used to filter/choose the output stream.
*
* If the controlled object produces several stream, you can set this
* property to choose a specific stream.
*
* If nothing is specified then a source pad will be chosen at random.
*/
properties[PROP_CAPS] = g_param_spec_boxed ("caps", "Caps",
"Caps used to filter/choose the output stream",
GST_TYPE_CAPS, G_PARAM_READWRITE);
g_object_class_install_property (gobject_class, PROP_CAPS,
properties[PROP_CAPS]);
/**
* NleObject:expandable
*
* Indicates whether this object should expand to the full duration of its
* container #NleComposition.
*/
properties[PROP_EXPANDABLE] =
g_param_spec_boolean ("expandable", "Expandable",
"Expand to the full duration of the container composition", FALSE,
G_PARAM_READWRITE);
g_object_class_install_property (gobject_class, PROP_EXPANDABLE,
properties[PROP_EXPANDABLE]);
/**
* NleObject:media-duration-factor
*
* Indicates the relative rate caused by this object, in other words, the
* relation between the rate of media entering and leaving this object. I.e.
* if object pulls data at twice the speed it sends it (e.g. `pitch
* tempo=2.0`), this value is set to 2.0.
*
* Deprecated: 1.18: This property is ignored since the wrapped
* #GstElement-s themselves should internally perform any additional time
* translations.
*/
properties[PROP_MEDIA_DURATION_FACTOR] =
g_param_spec_double ("media-duration-factor", "Media duration factor",
"The relative rate caused by this object", 0.01, G_MAXDOUBLE,
1.0, G_PARAM_READWRITE | G_PARAM_DEPRECATED);
g_object_class_install_property (gobject_class, PROP_MEDIA_DURATION_FACTOR,
properties[PROP_MEDIA_DURATION_FACTOR]);
/**
* NleObject::commit
* @object: a #NleObject
* @recurse: Whether to commit recursiverly into (NleComposition) children of
* @object. This is used in case we have composition inside
* a nlesource composition, telling it to commit the included
* composition state.
*
* Action signal to commit all the pending changes of the composition and
* its children timing properties
*
* Returns: %TRUE if changes have been commited, %FALSE if nothing had to
* be commited
*/
_signals[COMMIT_SIGNAL] = g_signal_new ("commit", G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (NleObjectClass, commit_signal_handler), NULL, NULL, NULL,
G_TYPE_BOOLEAN, 1, G_TYPE_BOOLEAN);
gst_type_mark_as_plugin_api (NLE_TYPE_OBJECT, 0);
}
static void
nle_object_init (NleObject * object, NleObjectClass * klass)
{
object->start = object->pending_start = 0;
object->duration = object->pending_duration = 0;
object->stop = 0;
object->inpoint = object->pending_inpoint = GST_CLOCK_TIME_NONE;
object->priority = object->pending_priority = 0;
object->active = object->pending_active = TRUE;
object->caps = gst_caps_new_any ();
object->segment_rate = 1.0;
object->segment_start = -1;
object->segment_stop = -1;
object->srcpad = nle_object_ghost_pad_no_target (object,
"src", GST_PAD_SRC,
gst_element_class_get_pad_template ((GstElementClass *) klass, "src"));
gst_element_add_pad (GST_ELEMENT (object), object->srcpad);
}
static void
nle_object_dispose (GObject * object)
{
NleObject *nle = (NleObject *) object;
if (nle->caps) {
gst_caps_unref (nle->caps);
nle->caps = NULL;
}
if (nle->srcpad) {
nle_object_remove_ghost_pad (nle, nle->srcpad);
nle->srcpad = NULL;
}
G_OBJECT_CLASS (parent_class)->dispose (object);
}
/**
* nle_object_to_media_time:
* @object: a #NleObject
* @objecttime: The #GstClockTime we want to convert
* @mediatime: A pointer on a #GstClockTime to fill
*
* Converts a #GstClockTime timestamp received from another nleobject pad
* in the same nlecomposition, or from the nlecomposition itself, to an
* internal source time.
*
* If the object is furthest downstream in the nlecomposition (highest
* priority in the current stack), this will convert the timestamp from
* the composition coordinate time to the internal source coordinate time
* of the object.
*
* If the object is upstream from another nleobject, then this can convert
* the timestamp received from the downstream sink pad to the internal
* source coordinates of the object, to be passed to its internal
* elements.
*
* If the object is downstream from another nleobject, then this can
* convert the timestamp received from the upstream source pad to the
* internal sink coordinates of the object, to be passed to its internal
* elements.
*
* In these latter two cases, the timestamp should have been converted
* by the peer pad using nle_media_to_object_time().
*
* Note, if an object introduces a time effect, it must have a 0 in-point
* and the same #nleobject:start and #nleobject:duration as all the other
* objects that are further upstream.
*
* Returns: TRUE if @objecttime was below the @object start time,
* FALSE otherwise.
*/
gboolean
nle_object_to_media_time (NleObject * object, GstClockTime otime,
GstClockTime * mtime)
{
gboolean ret = TRUE;
g_return_val_if_fail (mtime, FALSE);
GST_DEBUG_OBJECT (object, "ObjectTime : %" GST_TIME_FORMAT,
GST_TIME_ARGS (otime));
GST_DEBUG_OBJECT (object,
"Start/Stop:[%" GST_TIME_FORMAT " -- %" GST_TIME_FORMAT "] "
"Media start: %" GST_TIME_FORMAT, GST_TIME_ARGS (object->start),
GST_TIME_ARGS (object->stop), GST_TIME_ARGS (object->inpoint));
if (G_UNLIKELY (!GST_CLOCK_TIME_IS_VALID (otime))) {
GST_DEBUG_OBJECT (object, "converting none object time to none");
*mtime = GST_CLOCK_TIME_NONE;
return TRUE;
}
/* We do not allow @otime to be below the start of the object.
* If it was below, then the object would have a negative external
* source/sink time.
*
* Note that ges only supports time effects that map the time 0 to
* 0. Such time effects would also not produce an external timestamp
* below start, nor can they receive such a timestamp. */
if (G_UNLIKELY ((otime < object->start))) {
GST_DEBUG_OBJECT (object, "ObjectTime is before start");
otime = object->start;
ret = FALSE;
}
/* NOTE: if an nlecomposition contains time effect operations, then
* @otime can reasonably exceed the stop time of the object. So we
* do not limit it here. */
/* first we convert the timestamp to the object's external source/sink
* coordinates:
* + For an object that is furthest downstream, we translate from the
* composition coordinates to the external source coordinates by
* subtracting the object start.
* + For an object that is upstream from d_object, we need to
* translate from its external sink coordinates to our external
* source coordinates. This is done by adding
* (d_object->start - object->start)
* However, the sink pad of d_object should have already added the
* d_object->start to the timestamp (see nle_media_to_object_time)
* so we also only need to subtract the object start.
* + For an object that is downstream from u_object, we need to
* translate from its external source coordinates to our external
* sink coordinates. This is similarly done by adding
* (u_object->start - object->start)
* However, the source pad of u_object should have already added the
* u_object->start to the timestamp (see nle_media_to_object_time)
* so we also only need to subtract the object start.
*/
*mtime = otime - object->start;
/* we then convert the timestamp from the object's external source/sink
* coordinates to its internal source/sink coordinates, to be used by
* internal elements that the object wraps. This is done by adding
* the object in-point. */
if (G_LIKELY (GST_CLOCK_TIME_IS_VALID (object->inpoint)))
*mtime += object->inpoint;
GST_DEBUG_OBJECT (object, "Returning MediaTime : %" GST_TIME_FORMAT,
GST_TIME_ARGS (*mtime));
return ret;
}
/**
* nle_media_to_object_time:
* @object: The #NleObject
* @mediatime: The #GstClockTime we want to convert
* @objecttime: A pointer on a #GstClockTime to fill
*
* Converts a #GstClockTime timestamp from an internal time to an
* nleobject pad time.
*
* If the object is furthest downstream in an nlecomposition (highest
* priority in the current stack), this will convert the timestamp from
* the internal source coordinate time of the object to the composition
* coordinate time.
*
* If the object is upstream from another nleobject, then this can convert
* the timestamp from the internal source coordinates of the object to be
* sent to the downstream sink pad.
*
* If the object is downstream from another nleobject, then this can
* convert the timestamp from the internal sink coordinates of the object
* to be sent to the upstream source pad.
*
* Note, if an object introduces a time effect, it must have a 0 in-point
* and the same #nleobject:start and #nleobject:duration as all the other
* objects that are further upstream.
*
* Returns: TRUE if @objecttime was below the @object in-point time,
* FALSE otherwise.
*/
gboolean
nle_media_to_object_time (NleObject * object, GstClockTime mtime,
GstClockTime * otime)
{
g_return_val_if_fail (otime, FALSE);
GST_DEBUG_OBJECT (object, "MediaTime : %" GST_TIME_FORMAT,
GST_TIME_ARGS (mtime));
GST_DEBUG_OBJECT (object,
"Start/Stop:[%" GST_TIME_FORMAT " -- %" GST_TIME_FORMAT "] "
"inpoint %" GST_TIME_FORMAT, GST_TIME_ARGS (object->start),
GST_TIME_ARGS (object->stop), GST_TIME_ARGS (object->inpoint));
if (G_UNLIKELY (!GST_CLOCK_TIME_IS_VALID (mtime))) {
GST_DEBUG_OBJECT (object, "converting none media time to none");
*otime = GST_CLOCK_TIME_NONE;
return TRUE;
}
/* the internal time should never go below the in-point! */
if (G_UNLIKELY (GST_CLOCK_TIME_IS_VALID (object->inpoint)
&& (mtime < object->inpoint))) {
GST_DEBUG_OBJECT (object, "media time is before inpoint, forcing to start");
*otime = object->start;
return FALSE;
}
/* first we convert the timestamp to the object's external source/sink
* coordinates by removing the in-point */
if (G_LIKELY (GST_CLOCK_TIME_IS_VALID (object->inpoint)))
*otime = mtime - object->inpoint;
else
*otime = mtime;
/* then we convert the timestamp by adding start.
* If the object is furthest downstream, this will translate it from
* the external source coordinates to the composition coordinates.
* Otherwise, this will perform part of the conversion from the object's
* source/sink coordinates to the downstream/upstream sink/source
* coordinates (the conversion is completed in
* nle_object_to_media_time). */
*otime += object->start;
GST_DEBUG_OBJECT (object, "Returning ObjectTime : %" GST_TIME_FORMAT,
GST_TIME_ARGS (*otime));
return TRUE;
}
static gboolean
nle_object_prepare_func (NleObject * object)
{
GST_DEBUG_OBJECT (object, "default prepare function, returning TRUE");
return TRUE;
}
static GstStateChangeReturn
nle_object_prepare (NleObject * object)
{
GstStateChangeReturn ret = GST_STATE_CHANGE_SUCCESS;
GST_DEBUG_OBJECT (object, "preparing");
if (!(NLE_OBJECT_GET_CLASS (object)->prepare (object)))
ret = GST_STATE_CHANGE_FAILURE;
GST_DEBUG_OBJECT (object, "finished preparing, returning %d", ret);
return ret;
}
static gboolean
nle_object_cleanup_func (NleObject * object)
{
GST_DEBUG_OBJECT (object, "default cleanup function, returning TRUE");
return TRUE;
}
GstStateChangeReturn
nle_object_cleanup (NleObject * object)
{
GstStateChangeReturn ret = GST_STATE_CHANGE_SUCCESS;
GST_DEBUG_OBJECT (object, "cleaning-up");
if (!(NLE_OBJECT_GET_CLASS (object)->cleanup (object)))
ret = GST_STATE_CHANGE_FAILURE;
GST_DEBUG_OBJECT (object, "finished preparing, returning %d", ret);
return ret;
}
void
nle_object_set_caps (NleObject * object, const GstCaps * caps)
{
if (object->caps)
gst_caps_unref (object->caps);
object->caps = gst_caps_copy (caps);
}
static inline void
_update_stop (NleObject * nleobject)
{
/* check if start/duration has changed */
if ((nleobject->pending_start + nleobject->pending_duration) !=
nleobject->stop) {
nleobject->stop = nleobject->pending_start + nleobject->pending_duration;
GST_LOG_OBJECT (nleobject,
"Updating stop value : %" GST_TIME_FORMAT " [start:%" GST_TIME_FORMAT
", duration:%" GST_TIME_FORMAT "]", GST_TIME_ARGS (nleobject->stop),
GST_TIME_ARGS (nleobject->pending_start),
GST_TIME_ARGS (nleobject->pending_duration));
g_object_notify_by_pspec (G_OBJECT (nleobject), properties[PROP_STOP]);
}
}
static void
update_values (NleObject * object)
{
CHECK_AND_SET (START, start, "start", G_GUINT64_FORMAT);
CHECK_AND_SET (INPOINT, inpoint, "inpoint", G_GUINT64_FORMAT);
CHECK_AND_SET (DURATION, duration, "duration", G_GINT64_FORMAT);
CHECK_AND_SET (PRIORITY, priority, "priority", G_GUINT32_FORMAT);
CHECK_AND_SET (ACTIVE, active, "active", G_GUINT32_FORMAT);
_update_stop (object);
}
static gboolean
nle_object_commit_func (NleObject * object, gboolean recurse)
{
GST_DEBUG_OBJECT (object, "Commiting object changed");
if (object->commit_needed == FALSE) {
GST_INFO_OBJECT (object, "No changes to commit");
return FALSE;
}
update_values (object);
GST_DEBUG_OBJECT (object, "Done commiting");
return TRUE;
}
static void
nle_object_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec)
{
NleObject *nleobject = (NleObject *) object;
g_return_if_fail (NLE_IS_OBJECT (object));
GST_OBJECT_LOCK (object);
switch (prop_id) {
case PROP_START:
SET_PENDING_VALUE (start, "start", uint64, G_GUINT64_FORMAT);
break;
case PROP_DURATION:
SET_PENDING_VALUE (duration, "duration", int64, G_GINT64_FORMAT);
break;
case PROP_INPOINT:
SET_PENDING_VALUE (inpoint, "inpoint", uint64, G_GUINT64_FORMAT);
break;
case PROP_PRIORITY:
SET_PENDING_VALUE (priority, "priority", uint, G_GUINT32_FORMAT);
break;
case PROP_ACTIVE:
SET_PENDING_VALUE (active, "active", boolean, G_GUINT32_FORMAT);
break;
case PROP_CAPS:
nle_object_set_caps (nleobject, gst_value_get_caps (value));
break;
case PROP_EXPANDABLE:
if (g_value_get_boolean (value))
GST_OBJECT_FLAG_SET (nleobject, NLE_OBJECT_EXPANDABLE);
else
GST_OBJECT_FLAG_UNSET (nleobject, NLE_OBJECT_EXPANDABLE);
break;
case PROP_MEDIA_DURATION_FACTOR:
{
gdouble val = g_value_get_double (value);
if (val != 1.0)
g_warning ("Ignoring media-duration-factor value of %g since the "
"property is deprecated", val);
}
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
GST_OBJECT_UNLOCK (object);
}
static void
nle_object_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec)
{
NleObject *nleobject = (NleObject *) object;
switch (prop_id) {
case PROP_START:
g_value_set_uint64 (value, nleobject->pending_start);
break;
case PROP_DURATION:
g_value_set_int64 (value, nleobject->pending_duration);
break;
case PROP_STOP:
g_value_set_uint64 (value, nleobject->stop);
break;
case PROP_INPOINT:
g_value_set_uint64 (value, nleobject->pending_inpoint);
break;
case PROP_PRIORITY:
g_value_set_uint (value, nleobject->pending_priority);
break;
case PROP_ACTIVE:
g_value_set_boolean (value, nleobject->pending_active);
break;
case PROP_CAPS:
gst_value_set_caps (value, nleobject->caps);
break;
case PROP_EXPANDABLE:
g_value_set_boolean (value, NLE_OBJECT_IS_EXPANDABLE (object));
break;
case PROP_MEDIA_DURATION_FACTOR:
g_value_set_double (value, 1.0);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
nle_object_constructed (GObject * object)
{
NleObject *nleobject = (NleObject *) object;
_update_stop (nleobject);
}
static GstStateChangeReturn
nle_object_change_state (GstElement * element, GstStateChange transition)
{
GstStateChangeReturn ret = GST_STATE_CHANGE_SUCCESS;
switch (transition) {
case GST_STATE_CHANGE_NULL_TO_READY:
{
GstObject *parent = gst_object_get_parent (GST_OBJECT (element));
/* Going to READY and if we are not in a composition, we need to make
* sure that the object positioning state is properly commited */
if (parent) {
if (g_strcmp0 (GST_ELEMENT_NAME (GST_ELEMENT (parent)), "current-bin")
&& !NLE_OBJECT_IS_COMPOSITION (NLE_OBJECT (element))) {
GST_INFO ("Adding nleobject to something that is not a composition,"
" commiting ourself");
nle_object_commit (NLE_OBJECT (element), FALSE);
}
gst_object_unref (parent);
}
}
break;
case GST_STATE_CHANGE_READY_TO_PAUSED:
if (nle_object_prepare (NLE_OBJECT (element)) == GST_STATE_CHANGE_FAILURE) {
ret = GST_STATE_CHANGE_FAILURE;
goto beach;
}
break;
default:
break;
}
GST_DEBUG_OBJECT (element, "Calling parent change_state");
ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
GST_DEBUG_OBJECT (element, "Return from parent change_state was %d", ret);
if (ret == GST_STATE_CHANGE_FAILURE)
goto beach;
switch (transition) {
case GST_STATE_CHANGE_PAUSED_TO_READY:
/* cleanup nleobject */
if (nle_object_cleanup (NLE_OBJECT (element)) == GST_STATE_CHANGE_FAILURE)
ret = GST_STATE_CHANGE_FAILURE;
break;
default:
break;
}
beach:
return ret;
}
void
nle_object_set_commit_needed (NleObject * object)
{
if (G_UNLIKELY (object->commiting)) {
GST_WARNING_OBJECT (object,
"Trying to set 'commit-needed' while commiting");
return;
}
GST_DEBUG_OBJECT (object, "Setting 'commit_needed'");
object->commit_needed = TRUE;
}
gboolean
nle_object_commit (NleObject * object, gboolean recurse)
{
gboolean ret;
GST_DEBUG_OBJECT (object, "Commiting object state");
object->commiting = TRUE;
ret = NLE_OBJECT_GET_CLASS (object)->commit (object, recurse);
object->commiting = FALSE;
return ret;
}
static void
_send_seek_event (const GValue * item, gpointer seek_event)
{
GstElement *child = g_value_get_object (item);
gst_element_send_event (child, gst_event_ref (seek_event));
}
void
nle_object_seek_all_children (NleObject * object, GstEvent * seek_event)
{
GstIterator *it = gst_bin_iterate_recurse (GST_BIN (object));
while (gst_iterator_foreach (it, _send_seek_event,
seek_event) == GST_ITERATOR_RESYNC)
gst_iterator_resync (it);
gst_iterator_free (it);
gst_event_unref (seek_event);
}
void
nle_object_reset (NleObject * object)
{
GST_INFO_OBJECT (object, "Resetting child timing values to default");
object->start = 0;
object->duration = 0;
object->stop = 0;
object->inpoint = GST_CLOCK_TIME_NONE;
object->priority = 0;
object->active = TRUE;
object->in_composition = FALSE;
}
GType
nle_object_get_type (void)
{
static gsize type = 0;
if (g_once_init_enter (&type)) {
GType _type;
static const GTypeInfo info = {
sizeof (NleObjectClass),
NULL,
NULL,
(GClassInitFunc) nle_object_class_init,
NULL,
NULL,
sizeof (NleObject),
0,
(GInstanceInitFunc) nle_object_init,
};
_type = g_type_register_static (GST_TYPE_BIN,
"NleObject", &info, G_TYPE_FLAG_ABSTRACT);
g_once_init_leave (&type, _type);
}
return type;
}