ges-overlay-clip.c \
ges-text-overlay-clip.c \
ges-track.c \
- ges-track-object.c \
+ ges-track-element.c \
ges-track-source.c \
ges-track-operation.c \
ges-track-filesource.c \
<xi:include href="xml/ges-overlay-clip.xml"/>
<xi:include href="xml/ges-base-effect-clip.xml"/>
<xi:include href="xml/ges-track.xml"/>
- <xi:include href="xml/ges-track-object.xml"/>
+ <xi:include href="xml/ges-track-element.xml"/>
<xi:include href="xml/ges-track-source.xml"/>
<xi:include href="xml/ges-track-effect.xml"/>
<xi:include href="xml/ges-track-operation.xml"/>
</SECTION>
<SECTION>
-<FILE>ges-track-object</FILE>
-<TITLE>GESTrackObject</TITLE>
-GESTrackObject
-GESTrackObjectClass
-ges_track_object_set_max_duration
-ges_track_object_set_active
-ges_track_object_set_locked
-ges_track_object_is_locked
-ges_track_object_get_track
-ges_track_object_get_clip
-ges_track_object_get_gnlobject
-ges_track_object_get_element
-ges_track_object_get_max_duration
-ges_track_object_is_active
-ges_track_object_lookup_child
-ges_track_object_list_children_properties
-ges_track_object_set_child_property
-ges_track_object_set_child_properties
-ges_track_object_set_child_property_valist
-ges_track_object_set_child_property_by_pspec
-ges_track_object_get_child_property
-ges_track_object_get_child_properties
-ges_track_object_get_child_property_valist
-ges_track_object_get_child_property_by_pspec
-ges_track_object_edit
-ges_track_object_copy
+<FILE>ges-track-element</FILE>
+<TITLE>GESTrackElement</TITLE>
+GESTrackElement
+GESTrackElementClass
+ges_track_element_set_max_duration
+ges_track_element_set_active
+ges_track_element_set_locked
+ges_track_element_is_locked
+ges_track_element_get_track
+ges_track_element_get_clip
+ges_track_element_get_gnlobject
+ges_track_element_get_element
+ges_track_element_get_max_duration
+ges_track_element_is_active
+ges_track_element_lookup_child
+ges_track_element_list_children_properties
+ges_track_element_set_child_property
+ges_track_element_set_child_properties
+ges_track_element_set_child_property_valist
+ges_track_element_set_child_property_by_pspec
+ges_track_element_get_child_property
+ges_track_element_get_child_properties
+ges_track_element_get_child_property_valist
+ges_track_element_get_child_property_by_pspec
+ges_track_element_edit
+ges_track_element_copy
<SUBSECTION Standard>
-GESTrackObjectPrivate
-ges_track_object_set_clip
-ges_track_object_set_track
-ges_track_object_get_type
-GES_IS_TRACK_OBJECT
-GES_IS_TRACK_OBJECT_CLASS
-GES_TRACK_OBJECT
-GES_TRACK_OBJECT_CLASS
-GES_TRACK_OBJECT_GET_CLASS
-GES_TYPE_TRACK_OBJECT
+GESTrackElementPrivate
+ges_track_element_set_clip
+ges_track_element_set_track
+ges_track_element_get_type
+GES_IS_TRACK_ELEMENT
+GES_IS_TRACK_ELEMENT_CLASS
+GES_TRACK_ELEMENT
+GES_TRACK_ELEMENT_CLASS
+GES_TRACK_ELEMENT_GET_CLASS
+GES_TYPE_TRACK_ELEMENT
</SECTION>
<SECTION>
<TITLE>GESClip</TITLE>
GESClip
GESClipClass
-GESCreateTrackObjectFunc
-GESCreateTrackObjectsFunc
-GESFillTrackObjectFunc
+GESCreateTrackElementFunc
+GESCreateTrackElementsFunc
+GESFillTrackElementFunc
ges_clip_get_layer
-ges_clip_find_track_object
-ges_clip_add_track_object
+ges_clip_find_track_element
+ges_clip_add_track_element
ges_clip_add_asset
ges_clip_get_top_effects
ges_clip_get_top_effect_position
ges_clip_set_max_duration
<SUBSECTION Standard>
GES_CLIP_HEIGHT
-ges_clip_create_track_objects
-ges_clip_create_track_object
-ges_clip_fill_track_object
+ges_clip_create_track_elements
+ges_clip_create_track_element
+ges_clip_fill_track_element
ges_clip_is_moving_from_layer
-ges_clip_release_track_object
-ges_clip_get_track_objects
+ges_clip_release_track_element
+ges_clip_get_track_elements
ges_clip_set_layer
ges_clip_set_moving_from_layer
-ges_clip_lock_track_objects
+ges_clip_lock_track_elements
GESClipPrivate
GES_IS_CLIP
GES_IS_CLIP_CLASS
<FILE>ges-custom-source-clip</FILE>
<TITLE>GESCustomSourceClip</TITLE>
GESCustomSourceClip
-GESFillTrackObjectUserFunc
+GESFillTrackElementUserFunc
ges_custom_source_clip_new
<SUBSECTION Standard>
GESCustomSourceClipClass
<SECTION>
<FILE>ges-asset-track-object</FILE>
-<TITLE>GESAssetTrackObject</TITLE>
-GESAssetTrackObject
-ges_asset_track_object_get_type
-ges_asset_track_object_get_track_type
-ges_asset_track_object_set_track_type
+<TITLE>GESAssetTrackElement</TITLE>
+GESAssetTrackElement
+ges_asset_track_element_get_type
+ges_asset_track_element_get_track_type
+ges_asset_track_element_set_track_type
<SUBSECTION Standard>
-GESAssetTrackObjectPrivate
-GES_ASSET_TRACK_OBJECT
-GES_TYPE_ASSET_TRACK_OBJECT
-GES_ASSET_TRACK_OBJECT_CLASS
-GES_IS_ASSET_TRACK_OBJECT
-GES_IS_ASSET_TRACK_OBJECT_CLASS
-GES_ASSET_TRACK_OBJECT_GET_CLASS
+GESAssetTrackElementPrivate
+GES_ASSET_TRACK_ELEMENT
+GES_TYPE_ASSET_TRACK_ELEMENT
+GES_ASSET_TRACK_ELEMENT_CLASS
+GES_IS_ASSET_TRACK_ELEMENT
+GES_IS_ASSET_TRACK_ELEMENT_CLASS
+GES_ASSET_TRACK_ELEMENT_GET_CLASS
</SECTION>
<SECTION>
ges_track_filesource_get_type
ges_track_get_type
ges_track_image_source_get_type
-ges_track_object_get_type
+ges_track_element_get_type
ges_track_effect_get_type
ges_track_parse_launch_effect_get_type
ges_track_operation_get_type
ges-overlay-clip.c \
ges-text-overlay-clip.c \
ges-track.c \
- ges-track-object.c \
+ ges-track-element.c \
ges-track-source.c \
ges-track-operation.c \
ges-track-filesource.c \
ges-track-effect.h \
ges-track-parse-launch-effect.h \
ges-track.h \
- ges-track-object.h \
+ ges-track-element.h \
ges-track-source.h \
ges-track-operation.h \
ges-track-filesource.h \
*
* The #GESUriClipAsset is a special #GESAsset specilized in #GESClip.
* it is mostly used to get information about the #GESTrackType-s the objects extracted
- * from it can potentialy create #GESTrackObject for.
+ * from it can potentialy create #GESTrackElement for.
*/
#include "ges-asset-clip.h"
* @self: a #GESAssetClip
* @supportedformats: The track types supported by the GESAssetClip
*
- * Sets track types for which objects extracted from @self can create #GESTrackObject
+ * Sets track types for which objects extracted from @self can create #GESTrackElement
*/
void
ges_asset_clip_set_supported_formats (GESAssetClip * self,
* ges_asset_clip_get_supported_formats:
* @self: a #GESAssetClip
*
- * Gets track types for which objects extracted from @self can create #GESTrackObject
+ * Gets track types for which objects extracted from @self can create #GESTrackElement
*
- * Returns: The track types on which @self will create TrackObject when added to
+ * Returns: The track types on which @self will create TrackElement when added to
* a layer
*/
GESTrackType
/**
* SECTION: ges-asset-track-object
- * @short_description: A GESAsset subclass specialized in GESTrackObject extraction
+ * @short_description: A GESAsset subclass specialized in GESTrackElement extraction
*/
#include "ges-asset-track-object.h"
static GParamSpec *properties[PROP_LAST];
-G_DEFINE_TYPE (GESAssetTrackObject, ges_asset_track_object, GES_TYPE_ASSET);
+G_DEFINE_TYPE (GESAssetTrackElement, ges_asset_track_element, GES_TYPE_ASSET);
-struct _GESAssetTrackObjectPrivate
+struct _GESAssetTrackElementPrivate
{
GESTrackType type;
};
_get_property (GObject * object, guint property_id,
GValue * value, GParamSpec * pspec)
{
- GESAssetTrackObject *asset = GES_ASSET_TRACK_OBJECT (object);
+ GESAssetTrackElement *asset = GES_ASSET_TRACK_ELEMENT (object);
switch (property_id) {
case PROP_TRACK_TYPE:
_set_property (GObject * object, guint property_id,
const GValue * value, GParamSpec * pspec)
{
- GESAssetTrackObject *asset = GES_ASSET_TRACK_OBJECT (object);
+ GESAssetTrackElement *asset = GES_ASSET_TRACK_ELEMENT (object);
switch (property_id) {
case PROP_TRACK_TYPE:
}
static void
-ges_asset_track_object_class_init (GESAssetTrackObjectClass * klass)
+ges_asset_track_element_class_init (GESAssetTrackElementClass * klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
- g_type_class_add_private (klass, sizeof (GESAssetTrackObjectPrivate));
+ g_type_class_add_private (klass, sizeof (GESAssetTrackElementPrivate));
object_class->get_property = _get_property;
object_class->set_property = _set_property;
}
static void
-ges_asset_track_object_init (GESAssetTrackObject * self)
+ges_asset_track_element_init (GESAssetTrackElement * self)
{
- GESAssetTrackObjectPrivate *priv;
+ GESAssetTrackElementPrivate *priv;
priv = self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
- GES_TYPE_ASSET_TRACK_OBJECT, GESAssetTrackObjectPrivate);
+ GES_TYPE_ASSET_TRACK_ELEMENT, GESAssetTrackElementPrivate);
priv->type = GES_TRACK_TYPE_UNKNOWN;
}
/**
- * ges_asset_track_object_set_track_type:
+ * ges_asset_track_element_set_track_type:
* @asset: A #GESAssetObject
* @type: A #GESTrackType
*
- * Set the #GESAssetTrackType the #GESTrackObject extracted from @self
+ * Set the #GESAssetTrackType the #GESTrackElement extracted from @self
* should get into
*/
void
-ges_asset_track_object_set_track_type (GESAssetTrackObject * asset,
+ges_asset_track_element_set_track_type (GESAssetTrackElement * asset,
GESTrackType type)
{
- g_return_if_fail (GES_IS_ASSET_TRACK_OBJECT (asset));
+ g_return_if_fail (GES_IS_ASSET_TRACK_ELEMENT (asset));
asset->priv->type = type;
}
/**
- * ges_asset_track_object_get_track_type:
+ * ges_asset_track_element_get_track_type:
* @asset: A #GESAssetObject
*
- * Get the GESAssetTrackType the #GESTrackObject extracted from @self
+ * Get the GESAssetTrackType the #GESTrackElement extracted from @self
* should get into
*
* Returns: a #GESTrackType
*/
const GESTrackType
-ges_asset_track_object_get_track_type (GESAssetTrackObject * asset)
+ges_asset_track_element_get_track_type (GESAssetTrackElement * asset)
{
- g_return_val_if_fail (GES_IS_ASSET_TRACK_OBJECT (asset),
+ g_return_val_if_fail (GES_IS_ASSET_TRACK_ELEMENT (asset),
GES_TRACK_TYPE_UNKNOWN);
return asset->priv->type;
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
-#ifndef _GES_ASSET_TRACK_OBJECT_
-#define _GES_ASSET_TRACK_OBJECT_
+#ifndef _GES_ASSET_TRACK_ELEMENT_
+#define _GES_ASSET_TRACK_ELEMENT_
#include <glib-object.h>
#include <gio/gio.h>
G_BEGIN_DECLS
-#define GES_TYPE_ASSET_TRACK_OBJECT ges_asset_track_object_get_type()
-#define GES_ASSET_TRACK_OBJECT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GES_TYPE_ASSET_TRACK_OBJECT, GESAssetTrackObject))
-#define GES_ASSET_TRACK_OBJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GES_TYPE_ASSET_TRACK_OBJECT, GESAssetTrackObjectClass))
-#define GES_IS_ASSET_TRACK_OBJECT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GES_TYPE_ASSET_TRACK_OBJECT))
-#define GES_IS_ASSET_TRACK_OBJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GES_TYPE_ASSET_TRACK_OBJECT))
-#define GES_ASSET_TRACK_OBJECT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GES_TYPE_ASSET_TRACK_OBJECT, GESAssetTrackObjectClass))
+#define GES_TYPE_ASSET_TRACK_ELEMENT ges_asset_track_element_get_type()
+#define GES_ASSET_TRACK_ELEMENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GES_TYPE_ASSET_TRACK_ELEMENT, GESAssetTrackElement))
+#define GES_ASSET_TRACK_ELEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GES_TYPE_ASSET_TRACK_ELEMENT, GESAssetTrackElementClass))
+#define GES_IS_ASSET_TRACK_ELEMENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GES_TYPE_ASSET_TRACK_ELEMENT))
+#define GES_IS_ASSET_TRACK_ELEMENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GES_TYPE_ASSET_TRACK_ELEMENT))
+#define GES_ASSET_TRACK_ELEMENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GES_TYPE_ASSET_TRACK_ELEMENT, GESAssetTrackElementClass))
-typedef struct _GESAssetTrackObjectPrivate GESAssetTrackObjectPrivate;
+typedef struct _GESAssetTrackElementPrivate GESAssetTrackElementPrivate;
-GType ges_asset_track_object_get_type (void);
+GType ges_asset_track_element_get_type (void);
-struct _GESAssetTrackObject
+struct _GESAssetTrackElement
{
GESAsset parent;
/* <private> */
- GESAssetTrackObjectPrivate *priv;
+ GESAssetTrackElementPrivate *priv;
/* Padding for API extension */
gpointer __ges_reserved[GES_PADDING];
};
-struct _GESAssetTrackObjectClass
+struct _GESAssetTrackElementClass
{
GESAssetClass parent_class;
gpointer _ges_reserved[GES_PADDING];
};
-const GESTrackType ges_asset_track_object_get_track_type (GESAssetTrackObject *asset);
-void ges_asset_track_object_set_track_type (GESAssetTrackObject * asset, GESTrackType type);
+const GESTrackType ges_asset_track_element_get_track_type (GESAssetTrackElement *asset);
+void ges_asset_track_element_set_track_type (GESAssetTrackElement * asset, GESTrackType type);
G_END_DECLS
-#endif /* _GES_ASSET_TRACK_OBJECT */
+#endif /* _GES_ASSET_TRACK_ELEMENT */
*
* The Assets in the GStreamer Editing Services represent the ressources
* that can be used. You can create assets for any type that implements the #GESExtractable
- * interface, for example #GESClips, #GESFormatter, and #GESTrackObject do implement it.
+ * interface, for example #GESClips, #GESFormatter, and #GESTrackElement do implement it.
* This means that asssets will represent for example a #GESUriClips, #GESTrackEffect etc,
* and then you can extract objects of those types with the appropriate parameters from the asset
* using the #ges_asset_extract method:
}
static void
-_track_changed_cb (GESTrackObject * obj, GParamSpec * arg G_GNUC_UNUSED,
+_track_changed_cb (GESTrackElement * obj, GParamSpec * arg G_GNUC_UNUSED,
GESAutoTransition * self)
{
- if (ges_track_object_get_track (obj) == NULL) {
+ if (ges_track_element_get_track (obj) == NULL) {
GST_DEBUG_OBJECT (self, "Neighboor %" GST_PTR_FORMAT
" removed from track ... auto destructing", obj);
GESAutoTransition *
-ges_auto_transition_new (GESTrackObject * transition,
- GESTrackObject * previous_source, GESTrackObject * next_source)
+ges_auto_transition_new (GESTrackElement * transition,
+ GESTrackElement * previous_source, GESTrackElement * next_source)
{
GESAutoTransition *self = g_object_new (GES_TYPE_AUTO_TRANSITION, NULL);
self->next_source = next_source;
self->transition = transition;
- self->previous_clip = ges_track_object_get_clip (previous_source);
- self->next_clip = ges_track_object_get_clip (next_source);
- self->transition_clip = ges_track_object_get_clip (transition);
+ self->previous_clip = ges_track_element_get_clip (previous_source);
+ self->next_clip = ges_track_element_get_clip (next_source);
+ self->transition_clip = ges_track_element_get_clip (transition);
g_signal_connect (previous_source, "notify::start",
G_CALLBACK (neighbour_changed_cb), self);
#define _GES_AUTO_TRANSITION_H_
#include <glib-object.h>
-#include "ges-track-object.h"
+#include "ges-track-element.h"
#include "ges-clip.h"
#include "ges-timeline-layer.h"
GObject parent_instance;
/* <read only and construct only> */
- GESTrackObject *previous_source;
- GESTrackObject *next_source;
- GESTrackObject *transition;
+ GESTrackElement *previous_source;
+ GESTrackElement *next_source;
+ GESTrackElement *transition;
GESTimelineLayer *layer;
GType ges_auto_transition_get_type (void) G_GNUC_CONST;
-GESAutoTransition * ges_auto_transition_new (GESTrackObject * transition,
- GESTrackObject * previous_source,
- GESTrackObject * next_source);
+GESAutoTransition * ges_auto_transition_new (GESTrackElement * transition,
+ GESTrackElement * previous_source,
+ GESTrackElement * next_source);
G_END_DECLS
#endif /* _GES_AUTO_TRANSITION_H_ */
typedef struct PendingEffects
{
gchar *track_id;
- GESTrackObject *tckobj;
+ GESTrackElement *trackelement;
GstStructure *children_properties;
GstStructure *properties;
GList *effects;
/* TODO Implement asset effect management
- * PendingTrackObjects *track_objects; */
+ * PendingTrackElements *track_elements; */
} PendingClip;
typedef struct LayerEntry
static void
_set_child_property (GQuark field_id, const GValue * value,
- GESTrackObject * effect)
+ GESTrackElement * effect)
{
GParamSpec *pspec;
GstElement *element;
- if (!ges_track_object_lookup_child (effect,
+ if (!ges_track_element_lookup_child (effect,
g_quark_to_string (field_id), &element, &pspec))
return;
}
static void
-_add_track_object (GESFormatter * self, GESClip * clip,
- GESTrackObject * tckobj, const gchar * track_id,
+_add_track_element (GESFormatter * self, GESClip * clip,
+ GESTrackElement * trackelement, const gchar * track_id,
GstStructure * children_properties, GstStructure * properties)
{
GESBaseXmlFormatterPrivate *priv = _GET_PRIV (self);
GESTrack *track = g_hash_table_lookup (priv->tracks, track_id);
if (track == NULL) {
- GST_WARNING_OBJECT (self, "No track with id %s, can not add tckobj",
+ GST_WARNING_OBJECT (self, "No track with id %s, can not add trackelement",
track_id);
- gst_object_unref (tckobj);
+ gst_object_unref (trackelement);
return;
}
- GST_DEBUG_OBJECT (self, "Adding track_object: %" GST_PTR_FORMAT
- " To : %" GST_PTR_FORMAT, tckobj, clip);
+ GST_DEBUG_OBJECT (self, "Adding track_element: %" GST_PTR_FORMAT
+ " To : %" GST_PTR_FORMAT, trackelement, clip);
- ges_clip_add_track_object (clip, tckobj);
- ges_track_add_object (track, tckobj);
+ ges_clip_add_track_element (clip, trackelement);
+ ges_track_add_object (track, trackelement);
gst_structure_foreach (children_properties,
- (GstStructureForeachFunc) _set_child_property, tckobj);
+ (GstStructureForeachFunc) _set_child_property, trackelement);
}
static void
_free_pending_effect (PendingEffects * pend)
{
g_free (pend->track_id);
- gst_object_unref (pend->tckobj);
+ gst_object_unref (pend->trackelement);
if (pend->children_properties)
gst_structure_free (pend->children_properties);
if (pend->properties)
PendingEffects *peffect = (PendingEffects *) tmpeffect->data;
/* We keep a ref as _free_pending_effect unrefs it */
- _add_track_object (self, clip, gst_object_ref (peffect->tckobj),
+ _add_track_element (self, clip, gst_object_ref (peffect->trackelement),
peffect->track_id, peffect->children_properties, peffect->properties);
}
_free_pending_clip (priv, pend);
}
void
-ges_base_xml_formatter_add_track_object (GESBaseXmlFormatter * self,
- GType track_object_type, const gchar * asset_id, const gchar * track_id,
+ges_base_xml_formatter_add_track_element (GESBaseXmlFormatter * self,
+ GType track_element_type, const gchar * asset_id, const gchar * track_id,
const gchar * timeline_obj_id, GstStructure * children_properties,
GstStructure * properties, const gchar * metadatas, GError ** error)
{
- GESTrackObject *tckobj;
+ GESTrackElement *trackelement;
GError *err = NULL;
GESAsset *asset = NULL;
if (priv->check_only)
return;
- if (g_type_is_a (track_object_type, GES_TYPE_TRACK_OBJECT) == FALSE) {
- GST_DEBUG_OBJECT (self, "%s is not a TrackObject, can not create it",
- g_type_name (track_object_type));
+ if (g_type_is_a (track_element_type, GES_TYPE_TRACK_ELEMENT) == FALSE) {
+ GST_DEBUG_OBJECT (self, "%s is not a TrackElement, can not create it",
+ g_type_name (track_element_type));
goto out;
}
- if (g_type_is_a (track_object_type, GES_TYPE_TRACK_EFFECT) == FALSE) {
+ if (g_type_is_a (track_element_type, GES_TYPE_TRACK_EFFECT) == FALSE) {
GST_FIXME_OBJECT (self, "%s currently not supported",
- g_type_name (track_object_type));
+ g_type_name (track_element_type));
goto out;
}
- asset = ges_asset_request (track_object_type, asset_id, &err);
+ asset = ges_asset_request (track_element_type, asset_id, &err);
if (asset == NULL) {
- GST_DEBUG_OBJECT (self, "Can not create tckobj %s", asset_id);
+ GST_DEBUG_OBJECT (self, "Can not create trackelement %s", asset_id);
GST_FIXME_OBJECT (self, "Check if missing plugins etc %s",
err ? err->message : "");
goto out;
}
- tckobj = GES_TRACK_OBJECT (ges_asset_extract (asset, NULL));
- if (tckobj) {
+ trackelement = GES_TRACK_ELEMENT (ges_asset_extract (asset, NULL));
+ if (trackelement) {
GESClip *clip;
if (metadatas)
- ges_meta_container_add_metas_from_string (GES_META_CONTAINER (tckobj),
- metadatas);
+ ges_meta_container_add_metas_from_string (GES_META_CONTAINER
+ (trackelement), metadatas);
clip = g_hash_table_lookup (priv->clips, timeline_obj_id);
if (clip) {
- _add_track_object (GES_FORMATTER (self), clip, tckobj, track_id,
+ _add_track_element (GES_FORMATTER (self), clip, trackelement, track_id,
children_properties, properties);
} else {
PendingEffects *peffect;
timeline_obj_id);
if (pend == NULL) {
GST_WARNING_OBJECT (self, "No Clip with id: %s can not "
- "add TrackObject", timeline_obj_id);
+ "add TrackElement", timeline_obj_id);
goto out;
}
peffect = g_slice_new0 (PendingEffects);
- peffect->tckobj = tckobj;
+ peffect->trackelement = trackelement;
peffect->track_id = g_strdup (track_id);
peffect->properties = properties ? gst_structure_copy (properties) : NULL;
peffect->children_properties = children_properties ?
* @short_description: Base Class for objects in a GESTimelineLayer
*
* A #GESClip is a 'natural' object which controls one or more
- * #GESTrackObject(s) in one or more #GESTrack(s).
+ * #GESTrackElement(s) in one or more #GESTrack(s).
*
- * Keeps a reference to the #GESTrackObject(s) it created and
+ * Keeps a reference to the #GESTrackElement(s) it created and
* sets/updates their properties.
*/
#include <string.h>
gboolean
-ges_clip_fill_track_object_func (GESClip * object,
- GESTrackObject * trackobj, GstElement * gnlobj);
+ges_clip_fill_track_element_func (GESClip * object,
+ GESTrackElement * trackelement, GstElement * gnlobj);
-GList *ges_clip_create_track_objects_func (GESClip * object, GESTrackType type);
+GList *ges_clip_create_track_elements_func (GESClip * object,
+ GESTrackType type);
static gboolean _set_max_duration (GESTimelineElement * element,
GstClockTime maxduration);
static void
-track_object_start_changed_cb (GESTrackObject * child,
+track_element_start_changed_cb (GESTrackElement * child,
GParamSpec * arg G_GNUC_UNUSED, GESClip * object);
static void
-track_object_inpoint_changed_cb (GESTrackObject * child,
+track_element_inpoint_changed_cb (GESTrackElement * child,
GParamSpec * arg G_GNUC_UNUSED, GESClip * object);
static void
-track_object_duration_changed_cb (GESTrackObject * child,
+track_element_duration_changed_cb (GESTrackElement * child,
GParamSpec * arg G_GNUC_UNUSED, GESClip * object);
static void
-track_object_priority_changed_cb (GESTrackObject * child,
+track_element_priority_changed_cb (GESTrackElement * child,
GParamSpec * arg G_GNUC_UNUSED, GESClip * object);
static void update_height (GESClip * object);
G_DEFINE_ABSTRACT_TYPE (GESClip, ges_clip, GES_TYPE_TIMELINE_ELEMENT);
-/* Mapping of relationship between a Clip and the TrackObjects
+/* Mapping of relationship between a Clip and the TrackElements
* it controls
*
* NOTE : how do we make this public in the future ?
*/
typedef struct
{
- GESTrackObject *object;
+ GESTrackElement *object;
gint64 start_offset;
gint64 duration_offset;
gint64 inpoint_offset;
{
EFFECT_ADDED,
EFFECT_REMOVED,
- TRACK_OBJECT_ADDED,
- TRACK_OBJECT_REMOVED,
+ TRACK_ELEMENT_ADDED,
+ TRACK_ELEMENT_REMOVED,
LAST_SIGNAL
};
guint nb_effects;
- GESTrackObject *initiated_move;
+ GESTrackElement *initiated_move;
/* The formats supported by this Clip */
GESTrackType supportedformats;
object_class->get_property = ges_clip_get_property;
object_class->set_property = ges_clip_set_property;
- klass->create_track_objects = ges_clip_create_track_objects_func;
- klass->create_track_object = NULL;
- klass->track_object_added = NULL;
- klass->track_object_released = NULL;
+ klass->create_track_elements = ges_clip_create_track_elements_func;
+ klass->create_track_element = NULL;
+ klass->track_element_added = NULL;
+ klass->track_element_released = NULL;
/**
* GESClip:height:
/**
* GESClip::track-object-added:
* @object: the #GESClip
- * @tckobj: the #GESTrackObject that was added.
+ * @trackelement: the #GESTrackElement that was added.
*
* Will be emitted after a track object was added to the object.
*
* Since: 0.10.2
*/
- ges_clip_signals[TRACK_OBJECT_ADDED] =
+ ges_clip_signals[TRACK_ELEMENT_ADDED] =
g_signal_new ("track-object-added", G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST, 0, NULL, NULL, g_cclosure_marshal_generic,
- G_TYPE_NONE, 1, GES_TYPE_TRACK_OBJECT);
+ G_TYPE_NONE, 1, GES_TYPE_TRACK_ELEMENT);
/**
* GESClip::track-object-removed:
* @object: the #GESClip
- * @tckobj: the #GESTrackObject that was removed.
+ * @trackelement: the #GESTrackElement that was removed.
*
* Will be emitted after a track object was removed from @object.
*
* Since: 0.10.2
*/
- ges_clip_signals[TRACK_OBJECT_REMOVED] =
+ ges_clip_signals[TRACK_ELEMENT_REMOVED] =
g_signal_new ("track-object-removed", G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST, 0, NULL, NULL, g_cclosure_marshal_generic,
- G_TYPE_NONE, 1, GES_TYPE_TRACK_OBJECT);
+ G_TYPE_NONE, 1, GES_TYPE_TRACK_ELEMENT);
element_class->set_start = _set_start;
GES_TYPE_CLIP, GESClipPrivate);
/* FIXME, check why it was done this way _DURATION (self) = GST_SECOND; */
self->height = 1;
- self->trackobjects = NULL;
+ self->trackelements = NULL;
self->priv->layer = NULL;
self->priv->nb_effects = 0;
self->priv->is_moving = FALSE;
}
/**
- * ges_clip_create_track_object:
+ * ges_clip_create_track_element:
* @object: The origin #GESClip
- * @type: The #GESTrackType to create a #GESTrackObject for.
+ * @type: The #GESTrackType to create a #GESTrackElement for.
*
- * Creates a #GESTrackObject for the provided @type. The timeline object
- * keep a reference to the newly created trackobject, you therefore need to
- * call @ges_clip_release_track_object when you are done with it.
+ * Creates a #GESTrackElement for the provided @type. The timeline object
+ * keep a reference to the newly created trackelement, you therefore need to
+ * call @ges_clip_release_track_element when you are done with it.
*
- * Returns: (transfer none): A #GESTrackObject. Returns NULL if the #GESTrackObject could not
+ * Returns: (transfer none): A #GESTrackElement. Returns NULL if the #GESTrackElement could not
* be created.
*/
-GESTrackObject *
-ges_clip_create_track_object (GESClip * object, GESTrackType type)
+GESTrackElement *
+ges_clip_create_track_element (GESClip * object, GESTrackType type)
{
GESClipClass *class;
- GESTrackObject *res;
+ GESTrackElement *res;
g_return_val_if_fail (GES_IS_CLIP (object), NULL);
class = GES_CLIP_GET_CLASS (object);
- if (G_UNLIKELY (class->create_track_object == NULL)) {
- GST_ERROR ("No 'create_track_object' implementation available fo type %s",
+ if (G_UNLIKELY (class->create_track_element == NULL)) {
+ GST_ERROR ("No 'create_track_element' implementation available fo type %s",
G_OBJECT_TYPE_NAME (object));
return NULL;
}
- res = class->create_track_object (object, type);
+ res = class->create_track_element (object, type);
return res;
}
/**
- * ges_clip_create_track_objects:
+ * ges_clip_create_track_elements:
* @object: The origin #GESClip
- * @type: The #GESTrackType to create each #GESTrackObject for.
+ * @type: The #GESTrackType to create each #GESTrackElement for.
*
- * Creates all #GESTrackObjects supported by this object for the track type.
+ * Creates all #GESTrackElements supported by this object for the track type.
*
- * Returns: (element-type GESTrackObject) (transfer full): A #GList of
- * newly created #GESTrackObject-s
+ * Returns: (element-type GESTrackElement) (transfer full): A #GList of
+ * newly created #GESTrackElement-s
*/
GList *
-ges_clip_create_track_objects (GESClip * object, GESTrackType type)
+ges_clip_create_track_elements (GESClip * object, GESTrackType type)
{
GESClipClass *klass;
klass = GES_CLIP_GET_CLASS (object);
- if (!(klass->create_track_objects)) {
- GST_WARNING ("no GESClip::create_track_objects implentation");
+ if (!(klass->create_track_elements)) {
+ GST_WARNING ("no GESClip::create_track_elements implentation");
return NULL;
}
- GST_DEBUG_OBJECT (object, "Creating TrackObjects for type: %s",
+ GST_DEBUG_OBJECT (object, "Creating TrackElements for type: %s",
ges_track_type_name (type));
- return klass->create_track_objects (object, type);
+ return klass->create_track_elements (object, type);
}
gboolean
{
GList *tmp;
- for (tmp = GES_CLIP (element)->trackobjects; tmp; tmp = g_list_next (tmp))
+ for (tmp = GES_CLIP (element)->trackelements; tmp; tmp = g_list_next (tmp))
ges_timeline_element_set_max_duration (GES_TIMELINE_ELEMENT (tmp->data),
maxduration);
}
/*
- * default implementation of GESClipClass::create_track_objects
+ * default implementation of GESClipClass::create_track_elements
*/
GList *
-ges_clip_create_track_objects_func (GESClip * object, GESTrackType type)
+ges_clip_create_track_elements_func (GESClip * object, GESTrackType type)
{
- GESTrackObject *result;
+ GESTrackElement *result;
- GST_DEBUG_OBJECT (object, "Creating trackobject for track: %s",
+ GST_DEBUG_OBJECT (object, "Creating trackelement for track: %s",
ges_track_type_name (type));
- result = ges_clip_create_track_object (object, type);
+ result = ges_clip_create_track_element (object, type);
if (!result) {
GST_DEBUG ("Did not create track object");
return NULL;
}
/**
- * ges_clip_add_track_object:
+ * ges_clip_add_track_element:
* @object: a #GESClip
- * @trobj: the GESTrackObject
+ * @trobj: the GESTrackElement
*
* Add a track object to the timeline object. Should only be called by
- * subclasses implementing the create_track_objects (plural) vmethod.
+ * subclasses implementing the create_track_elements (plural) vmethod.
*
* Takes a reference on @trobj.
*
*/
gboolean
-ges_clip_add_track_object (GESClip * object, GESTrackObject * trobj)
+ges_clip_add_track_element (GESClip * object, GESTrackElement * trobj)
{
GList *tmp;
gboolean is_effect;
GESClipPrivate *priv;
g_return_val_if_fail (GES_IS_CLIP (object), FALSE);
- g_return_val_if_fail (GES_IS_TRACK_OBJECT (trobj), FALSE);
+ g_return_val_if_fail (GES_IS_TRACK_ELEMENT (trobj), FALSE);
priv = object->priv;
is_effect = GES_IS_TRACK_EFFECT (trobj);
- GST_LOG ("Got a TrackObject : %p , setting the timeline object as its"
+ GST_LOG ("Got a TrackElement : %p , setting the timeline object as its"
"creator. Is a TrackEffect %i", trobj, is_effect);
if (!trobj)
return FALSE;
- ges_track_object_set_clip (trobj, object);
+ ges_track_element_set_clip (trobj, object);
g_object_ref (trobj);
mapping->object = trobj;
priv->mappings = g_list_append (priv->mappings, mapping);
- GST_DEBUG ("Adding TrackObject to the list of controlled track objects");
+ GST_DEBUG ("Adding TrackElement to the list of controlled track objects");
/* We steal the initial reference */
- GST_DEBUG ("Setting properties on newly created TrackObject");
+ GST_DEBUG ("Setting properties on newly created TrackElement");
mapping->priority_offset = priv->nb_effects;
- /* If the trackobject is an effect:
+ /* If the trackelement is an effect:
* - We add it on top of the list of TrackEffect
- * - We put all TrackObject present in the Clip
+ * - We put all TrackElement present in the Clip
* which are not TrackEffect on top of them
*
* FIXME: Let the full control over priorities to the user
*/
if (is_effect) {
GST_DEBUG
- ("Moving non on top effect under other TrackObject-s, nb effects %i",
+ ("Moving non on top effect under other TrackElement-s, nb effects %i",
priv->nb_effects);
- for (tmp = g_list_nth (object->trackobjects, priv->nb_effects); tmp;
+ for (tmp = g_list_nth (object->trackelements, priv->nb_effects); tmp;
tmp = tmp->next) {
- GESTrackObject *tmpo = GES_TRACK_OBJECT (tmp->data);
+ GESTrackElement *tmpo = GES_TRACK_ELEMENT (tmp->data);
/* We make sure not to move the entire #Clip */
- ges_track_object_set_locked (tmpo, FALSE);
+ ges_track_element_set_locked (tmpo, FALSE);
_set_priority0 (GES_TIMELINE_ELEMENT (tmpo), _PRIORITY (tmpo) + 1);
- ges_track_object_set_locked (tmpo, TRUE);
+ ges_track_element_set_locked (tmpo, TRUE);
}
priv->nb_effects++;
}
- object->trackobjects =
- g_list_insert_sorted_with_data (object->trackobjects, trobj,
+ object->trackelements =
+ g_list_insert_sorted_with_data (object->trackelements, trobj,
(GCompareDataFunc) sort_track_effects, object);
_set_start0 (GES_TIMELINE_ELEMENT (trobj), _START (object));
_MAXDURATION (object));
klass = GES_CLIP_GET_CLASS (object);
- if (klass->track_object_added) {
- GST_DEBUG ("Calling track_object_added subclass method");
- klass->track_object_added (object, trobj);
+ if (klass->track_element_added) {
+ GST_DEBUG ("Calling track_element_added subclass method");
+ klass->track_element_added (object, trobj);
} else {
- GST_DEBUG ("%s doesn't have any track_object_added vfunc implementation",
+ GST_DEBUG ("%s doesn't have any track_element_added vfunc implementation",
G_OBJECT_CLASS_NAME (klass));
}
/* Listen to all property changes */
mapping->start_notifyid =
g_signal_connect (G_OBJECT (trobj), "notify::start",
- G_CALLBACK (track_object_start_changed_cb), object);
+ G_CALLBACK (track_element_start_changed_cb), object);
mapping->duration_notifyid =
g_signal_connect (G_OBJECT (trobj), "notify::duration",
- G_CALLBACK (track_object_duration_changed_cb), object);
+ G_CALLBACK (track_element_duration_changed_cb), object);
mapping->inpoint_notifyid =
g_signal_connect (G_OBJECT (trobj), "notify::inpoint",
- G_CALLBACK (track_object_inpoint_changed_cb), object);
+ G_CALLBACK (track_element_inpoint_changed_cb), object);
mapping->priority_notifyid =
g_signal_connect (G_OBJECT (trobj), "notify::priority",
- G_CALLBACK (track_object_priority_changed_cb), object);
+ G_CALLBACK (track_element_priority_changed_cb), object);
get_layer_priorities (priv->layer, &min_prio, &max_prio);
_set_priority0 (GES_TIMELINE_ELEMENT (trobj), min_prio +
GST_DEBUG ("Returning trobj:%p", trobj);
if (!GES_IS_TRACK_EFFECT (trobj)) {
- g_signal_emit (object, ges_clip_signals[TRACK_OBJECT_ADDED], 0,
- GES_TRACK_OBJECT (trobj));
+ g_signal_emit (object, ges_clip_signals[TRACK_ELEMENT_ADDED], 0,
+ GES_TRACK_ELEMENT (trobj));
} else {
/* emit 'effect-added' */
g_signal_emit (object, ges_clip_signals[EFFECT_ADDED], 0,
}
/**
- * ges_clip_release_track_object:
+ * ges_clip_release_track_element:
* @object: a #GESClip
- * @trackobject: the #GESTrackObject to release
+ * @trackelement: the #GESTrackElement to release
*
- * Release the @trackobject from the control of @object.
+ * Release the @trackelement from the control of @object.
*
- * Returns: %TRUE if the @trackobject was properly released, else %FALSE.
+ * Returns: %TRUE if the @trackelement was properly released, else %FALSE.
*/
gboolean
-ges_clip_release_track_object (GESClip * object, GESTrackObject * trackobject)
+ges_clip_release_track_element (GESClip * object,
+ GESTrackElement * trackelement)
{
GList *tmp;
ObjectMapping *mapping = NULL;
GESClipClass *klass;
g_return_val_if_fail (GES_IS_CLIP (object), FALSE);
- g_return_val_if_fail (GES_IS_TRACK_OBJECT (trackobject), FALSE);
+ g_return_val_if_fail (GES_IS_TRACK_ELEMENT (trackelement), FALSE);
- GST_DEBUG ("object:%p, trackobject:%p", object, trackobject);
+ GST_DEBUG ("object:%p, trackelement:%p", object, trackelement);
klass = GES_CLIP_GET_CLASS (object);
- if (!(g_list_find (object->trackobjects, trackobject))) {
- GST_WARNING ("TrackObject isn't controlled by this object");
+ if (!(g_list_find (object->trackelements, trackelement))) {
+ GST_WARNING ("TrackElement isn't controlled by this object");
return FALSE;
}
for (tmp = object->priv->mappings; tmp; tmp = tmp->next) {
mapping = (ObjectMapping *) tmp->data;
- if (mapping->object == trackobject)
+ if (mapping->object == trackelement)
break;
}
if (tmp && mapping) {
/* Disconnect all notify listeners */
- g_signal_handler_disconnect (trackobject, mapping->start_notifyid);
- g_signal_handler_disconnect (trackobject, mapping->duration_notifyid);
- g_signal_handler_disconnect (trackobject, mapping->inpoint_notifyid);
- g_signal_handler_disconnect (trackobject, mapping->priority_notifyid);
+ g_signal_handler_disconnect (trackelement, mapping->start_notifyid);
+ g_signal_handler_disconnect (trackelement, mapping->duration_notifyid);
+ g_signal_handler_disconnect (trackelement, mapping->inpoint_notifyid);
+ g_signal_handler_disconnect (trackelement, mapping->priority_notifyid);
g_slice_free (ObjectMapping, mapping);
object->priv->mappings = g_list_delete_link (object->priv->mappings, tmp);
}
- object->trackobjects = g_list_remove (object->trackobjects, trackobject);
+ object->trackelements = g_list_remove (object->trackelements, trackelement);
- if (GES_IS_TRACK_EFFECT (trackobject)) {
+ if (GES_IS_TRACK_EFFECT (trackelement)) {
/* emit 'object-removed' */
object->priv->nb_effects--;
g_signal_emit (object, ges_clip_signals[EFFECT_REMOVED], 0,
- GES_TRACK_EFFECT (trackobject));
+ GES_TRACK_EFFECT (trackelement));
} else
- g_signal_emit (object, ges_clip_signals[TRACK_OBJECT_REMOVED], 0,
- GES_TRACK_OBJECT (trackobject));
+ g_signal_emit (object, ges_clip_signals[TRACK_ELEMENT_REMOVED], 0,
+ GES_TRACK_ELEMENT (trackelement));
- ges_track_object_set_clip (trackobject, NULL);
+ ges_track_element_set_clip (trackelement, NULL);
- GST_DEBUG ("Removing reference to track object %p", trackobject);
+ GST_DEBUG ("Removing reference to track object %p", trackelement);
- if (klass->track_object_released) {
- GST_DEBUG ("Calling track_object_released subclass method");
- klass->track_object_released (object, trackobject);
+ if (klass->track_element_released) {
+ GST_DEBUG ("Calling track_element_released subclass method");
+ klass->track_element_released (object, trackelement);
}
- g_object_unref (trackobject);
+ g_object_unref (trackelement);
/* FIXME : resync properties ? */
}
gboolean
-ges_clip_fill_track_object (GESClip * object,
- GESTrackObject * trackobj, GstElement * gnlobj)
+ges_clip_fill_track_element (GESClip * object,
+ GESTrackElement * trackelement, GstElement * gnlobj)
{
GESClipClass *class;
gboolean res = TRUE;
- GST_DEBUG ("object:%p, trackobject:%p, gnlobject:%p",
- object, trackobj, gnlobj);
+ GST_DEBUG ("object:%p, trackelement:%p, gnlobject:%p",
+ object, trackelement, gnlobj);
class = GES_CLIP_GET_CLASS (object);
if (class->need_fill_track) {
- if (G_UNLIKELY (class->fill_track_object == NULL)) {
- GST_WARNING ("No 'fill_track_object' implementation available");
+ if (G_UNLIKELY (class->fill_track_element == NULL)) {
+ GST_WARNING ("No 'fill_track_element' implementation available");
return FALSE;
}
- res = class->fill_track_object (object, trackobj, gnlobj);
+ res = class->fill_track_element (object, trackelement, gnlobj);
}
GST_DEBUG ("Returning res:%d", res);
}
gboolean
-ges_clip_fill_track_object_func (GESClip * object,
- GESTrackObject * trackobj, GstElement * gnlobj)
+ges_clip_fill_track_element_func (GESClip * object,
+ GESTrackElement * trackelement, GstElement * gnlobj)
{
- GST_WARNING ("No 'fill_track_object' implementation !");
+ GST_WARNING ("No 'fill_track_element' implementation !");
return FALSE;
}
static ObjectMapping *
-find_object_mapping (GESClip * object, GESTrackObject * child)
+find_object_mapping (GESClip * object, GESTrackElement * child)
{
GList *tmp;
_set_start (GESTimelineElement * element, GstClockTime start)
{
GList *tmp;
- GESTrackObject *tr;
+ GESTrackElement *tr;
ObjectMapping *map;
gboolean snap = FALSE;
GESTimeline *timeline = NULL;
object->priv->ignore_notifies = TRUE;
- for (tmp = object->trackobjects; tmp; tmp = g_list_next (tmp)) {
- tr = (GESTrackObject *) tmp->data;
+ for (tmp = object->trackelements; tmp; tmp = g_list_next (tmp)) {
+ tr = (GESTrackElement *) tmp->data;
map = find_object_mapping (object, tr);
- if (ges_track_object_is_locked (tr) && tr != object->priv->initiated_move) {
+ if (ges_track_element_is_locked (tr) && tr != object->priv->initiated_move) {
gint64 new_start = start - map->start_offset;
/* Move the child... */
_set_inpoint (GESTimelineElement * element, GstClockTime inpoint)
{
GList *tmp;
- GESTrackObject *tr;
+ GESTrackElement *tr;
GESClip *object = GES_CLIP (element);
- for (tmp = object->trackobjects; tmp; tmp = g_list_next (tmp)) {
- tr = (GESTrackObject *) tmp->data;
+ for (tmp = object->trackelements; tmp; tmp = g_list_next (tmp)) {
+ tr = (GESTrackElement *) tmp->data;
- if (ges_track_object_is_locked (tr))
- /* call set_inpoint on each trackobject */
+ if (ges_track_element_is_locked (tr))
+ /* call set_inpoint on each trackelement */
_set_inpoint0 (GES_TIMELINE_ELEMENT (tr), inpoint);
}
_set_duration (GESTimelineElement * element, GstClockTime duration)
{
GList *tmp;
- GESTrackObject *tr;
+ GESTrackElement *tr;
GESTimeline *timeline = NULL;
gboolean snap = FALSE;
timeline = ges_timeline_layer_get_timeline (object->priv->layer);
/* If the class has snapping enabled, the object is in a timeline,
- * and we are not following a moved TrackObject, we snap */
+ * and we are not following a moved TrackElement, we snap */
snap = timeline && priv->initiated_move == NULL ? TRUE : FALSE;
object->priv->ignore_notifies = TRUE;
- for (tmp = object->trackobjects; tmp; tmp = g_list_next (tmp)) {
- tr = (GESTrackObject *) tmp->data;
+ for (tmp = object->trackelements; tmp; tmp = g_list_next (tmp)) {
+ tr = (GESTrackElement *) tmp->data;
- if (ges_track_object_is_locked (tr)) {
- /* call set_duration on each trackobject
+ if (ges_track_element_is_locked (tr)) {
+ /* call set_duration on each trackelement
* and make the snapping happen if in a timeline */
if (G_LIKELY (snap))
ges_timeline_trim_object_simple (timeline, tr, NULL, GES_EDGE_END,
_set_priority (GESTimelineElement * element, guint32 priority)
{
GList *tmp;
- GESTrackObject *tr;
+ GESTrackElement *tr;
ObjectMapping *map;
GESClipPrivate *priv;
guint32 layer_min_gnl_prio, layer_max_gnl_prio;
get_layer_priorities (priv->layer, &layer_min_gnl_prio, &layer_max_gnl_prio);
priv->ignore_notifies = TRUE;
- for (tmp = object->trackobjects; tmp; tmp = g_list_next (tmp)) {
- tr = (GESTrackObject *) tmp->data;
+ for (tmp = object->trackelements; tmp; tmp = g_list_next (tmp)) {
+ tr = (GESTrackElement *) tmp->data;
map = find_object_mapping (object, tr);
- if (ges_track_object_is_locked (tr)) {
+ if (ges_track_element_is_locked (tr)) {
guint32 real_tck_prio;
/* Move the child... */
}
}
- object->trackobjects = g_list_sort_with_data (object->trackobjects,
+ object->trackelements = g_list_sort_with_data (object->trackelements,
(GCompareDataFunc) sort_track_effects, object);
priv->ignore_notifies = FALSE;
}
/**
- * ges_clip_find_track_object:
+ * ges_clip_find_track_element:
* @object: a #GESClip
* @track: a #GESTrack or NULL
* @type: a #GType indicating the type of track object you are looking
* for or %G_TYPE_NONE if you do not care about the track type.
*
- * Finds the #GESTrackObject controlled by @object that is used in @track. You
+ * Finds the #GESTrackElement controlled by @object that is used in @track. You
* may optionally specify a GType to further narrow search criteria.
*
* Note: If many objects match, then the one with the highest priority will be
* returned.
*
- * Returns: (transfer full): The #GESTrackObject used by @track, else %NULL.
+ * Returns: (transfer full): The #GESTrackElement used by @track, else %NULL.
* Unref after usage.
*/
-GESTrackObject *
-ges_clip_find_track_object (GESClip * object, GESTrack * track, GType type)
+GESTrackElement *
+ges_clip_find_track_element (GESClip * object, GESTrack * track, GType type)
{
- GESTrackObject *ret = NULL;
+ GESTrackElement *ret = NULL;
GList *tmp;
- GESTrackObject *otmp;
+ GESTrackElement *otmp;
g_return_val_if_fail (GES_IS_CLIP (object), NULL);
g_return_val_if_fail (GES_IS_TRACK (track), NULL);
- for (tmp = object->trackobjects; tmp; tmp = g_list_next (tmp)) {
- otmp = (GESTrackObject *) tmp->data;
+ for (tmp = object->trackelements; tmp; tmp = g_list_next (tmp)) {
+ otmp = (GESTrackElement *) tmp->data;
- if (ges_track_object_get_track (otmp) == track) {
+ if (ges_track_element_get_track (otmp) == track) {
if ((type != G_TYPE_NONE) &&
!G_TYPE_CHECK_INSTANCE_TYPE (tmp->data, type))
continue;
- ret = GES_TRACK_OBJECT (tmp->data);
+ ret = GES_TRACK_ELEMENT (tmp->data);
g_object_ref (ret);
break;
}
}
/**
- * ges_clip_get_track_objects:
+ * ges_clip_get_track_elements:
* @object: a #GESClip
*
- * Get the list of #GESTrackObject contained in @object
+ * Get the list of #GESTrackElement contained in @object
*
- * Returns: (transfer full) (element-type GESTrackObject): The list of
- * trackobject contained in @object.
+ * Returns: (transfer full) (element-type GESTrackElement): The list of
+ * trackelement contained in @object.
* The user is responsible for unreffing the contained objects
* and freeing the list.
*/
GList *
-ges_clip_get_track_objects (GESClip * object)
+ges_clip_get_track_elements (GESClip * object)
{
GList *ret;
GList *tmp;
g_return_val_if_fail (GES_IS_CLIP (object), NULL);
- ret = g_list_copy (object->trackobjects);
+ ret = g_list_copy (object->trackelements);
for (tmp = ret; tmp; tmp = tmp->next) {
g_object_ref (tmp->data);
{
guint prio_offset_a, prio_offset_b;
ObjectMapping *map_a, *map_b;
- GESTrackObject *obj_a, *obj_b;
+ GESTrackElement *obj_a, *obj_b;
- obj_a = GES_TRACK_OBJECT (a);
- obj_b = GES_TRACK_OBJECT (b);
+ obj_a = GES_TRACK_ELEMENT (a);
+ obj_b = GES_TRACK_ELEMENT (b);
map_a = find_object_mapping (object, obj_a);
map_b = find_object_mapping (object, obj_b);
*
* Get effects applied on @object
*
- * Returns: (transfer full) (element-type GESTrackObject): a #GList of the
+ * Returns: (transfer full) (element-type GESTrackElement): a #GList of the
* #GESTrackEffect that are applied on @object order by ascendant priorities.
* The refcount of the objects will be increased. The user will have to
* unref each #GESTrackEffect and free the #GList.
object->priv->nb_effects);
ret = NULL;
- for (tmp = object->trackobjects, i = 0; i < object->priv->nb_effects;
+ for (tmp = object->trackelements, i = 0; i < object->priv->nb_effects;
tmp = tmp->next, i++) {
ret = g_list_append (ret, g_object_ref (tmp->data));
}
g_return_val_if_fail (GES_IS_CLIP (object), -1);
return find_object_mapping (object,
- GES_TRACK_OBJECT (effect))->priority_offset;
+ GES_TRACK_ELEMENT (effect))->priority_offset;
}
/**
gint inc;
GList *tmp;
guint current_prio;
- GESTrackObject *tck_obj;
+ GESTrackElement *tck_obj;
g_return_val_if_fail (GES_IS_CLIP (object), FALSE);
- tck_obj = GES_TRACK_OBJECT (effect);
+ tck_obj = GES_TRACK_ELEMENT (effect);
current_prio = _PRIORITY (tck_obj);
/* We don't change the priority */
if (current_prio == newpriority ||
- (G_UNLIKELY (ges_track_object_get_clip (tck_obj) != object)))
+ (G_UNLIKELY (ges_track_element_get_clip (tck_obj) != object)))
return FALSE;
if (newpriority > (object->priv->nb_effects - 1)) {
inc = +1;
_set_priority0 (GES_TIMELINE_ELEMENT (tck_obj), newpriority);
- for (tmp = object->trackobjects; tmp; tmp = tmp->next) {
- GESTrackObject *tmpo = GES_TRACK_OBJECT (tmp->data);
+ for (tmp = object->trackelements; tmp; tmp = tmp->next) {
+ GESTrackElement *tmpo = GES_TRACK_ELEMENT (tmp->data);
guint tck_priority = _PRIORITY (tmpo);
if ((inc == +1 && tck_priority >= newpriority) ||
}
}
- object->trackobjects = g_list_sort_with_data (object->trackobjects,
+ object->trackelements = g_list_sort_with_data (object->trackelements,
(GCompareDataFunc) sort_track_effects, object);
return TRUE;
g_return_val_if_fail (GES_IS_CLIP (object), FALSE);
- if (!G_UNLIKELY (object->trackobjects)) {
+ if (!G_UNLIKELY (object->trackelements)) {
GST_WARNING_OBJECT (object, "Trying to edit, but not containing"
- "any TrackObject yet.");
+ "any TrackElement yet.");
return FALSE;
}
- for (tmp = object->trackobjects; tmp; tmp = g_list_next (tmp)) {
- if (ges_track_object_is_locked (tmp->data)
+ for (tmp = object->trackelements; tmp; tmp = g_list_next (tmp)) {
+ if (ges_track_element_is_locked (tmp->data)
&& GES_IS_TRACK_SOURCE (tmp->data)) {
- ret &= ges_track_object_edit (tmp->data, layers, mode, edge, position);
+ ret &= ges_track_element_edit (tmp->data, layers, mode, edge, position);
break;
}
}
duration + start - position);
if (object->priv->layer) {
- /* We do not want the timeline to create again TrackObject-s */
+ /* We do not want the timeline to create again TrackElement-s */
ges_clip_set_moving_from_layer (new_object, TRUE);
ges_timeline_layer_add_object (object->priv->layer, new_object);
ges_clip_set_moving_from_layer (new_object, FALSE);
* properly in the following loop
* FIXME: Avoid setting it oureself reworking the API */
GES_TIMELINE_ELEMENT (object)->duration = position - _START (object);
- for (tmp = object->trackobjects; tmp; tmp = tmp->next) {
+ for (tmp = object->trackelements; tmp; tmp = tmp->next) {
GESTrack *track;
- GESTrackObject *new_tckobj, *tckobj = GES_TRACK_OBJECT (tmp->data);
+ GESTrackElement *new_trackelement, *trackelement =
+ GES_TRACK_ELEMENT (tmp->data);
- duration = _DURATION (tckobj);
- start = _START (tckobj);
- inpoint = _INPOINT (tckobj);
+ duration = _DURATION (trackelement);
+ start = _START (trackelement);
+ inpoint = _INPOINT (trackelement);
if (position <= start || position >= (start + duration)) {
- GST_DEBUG_OBJECT (tckobj, "Outside %" GST_TIME_FORMAT "the boundaries "
+ GST_DEBUG_OBJECT (trackelement,
+ "Outside %" GST_TIME_FORMAT "the boundaries "
"not copying it ( start %" GST_TIME_FORMAT ", end %" GST_TIME_FORMAT
- ")", GST_TIME_ARGS (position),
- GST_TIME_ARGS (_START (tckobj)),
- GST_TIME_ARGS (_START (tckobj) + _DURATION (tckobj)));
+ ")", GST_TIME_ARGS (position), GST_TIME_ARGS (_START (trackelement)),
+ GST_TIME_ARGS (_START (trackelement) + _DURATION (trackelement)));
continue;
}
- new_tckobj =
- GES_TRACK_OBJECT (ges_timeline_element_copy (GES_TIMELINE_ELEMENT
- (tckobj), TRUE));
- if (new_tckobj == NULL) {
- GST_WARNING_OBJECT (tckobj, "Could not create a copy");
+ new_trackelement =
+ GES_TRACK_ELEMENT (ges_timeline_element_copy (GES_TIMELINE_ELEMENT
+ (trackelement), TRUE));
+ if (new_trackelement == NULL) {
+ GST_WARNING_OBJECT (trackelement, "Could not create a copy");
continue;
}
- ges_clip_add_track_object (new_object, new_tckobj);
+ ges_clip_add_track_element (new_object, new_trackelement);
- track = ges_track_object_get_track (tckobj);
+ track = ges_track_element_get_track (trackelement);
if (track == NULL)
- GST_DEBUG_OBJECT (tckobj, "Was not in a track, not adding %p to"
- "any track", new_tckobj);
+ GST_DEBUG_OBJECT (trackelement, "Was not in a track, not adding %p to"
+ "any track", new_trackelement);
else
- ges_track_add_object (track, new_tckobj);
+ ges_track_add_object (track, new_trackelement);
- /* Unlock TrackObject-s as we do not want the container to move
+ /* Unlock TrackElement-s as we do not want the container to move
* syncronously */
- locked = ges_track_object_is_locked (tckobj);
- ges_track_object_set_locked (new_tckobj, FALSE);
- ges_track_object_set_locked (tckobj, FALSE);
+ locked = ges_track_element_is_locked (trackelement);
+ ges_track_element_set_locked (new_trackelement, FALSE);
+ ges_track_element_set_locked (trackelement, FALSE);
/* Set 'new' track object timing propeties */
- _set_start0 (GES_TIMELINE_ELEMENT (new_tckobj), position);
- _set_inpoint0 (GES_TIMELINE_ELEMENT (new_tckobj),
+ _set_start0 (GES_TIMELINE_ELEMENT (new_trackelement), position);
+ _set_inpoint0 (GES_TIMELINE_ELEMENT (new_trackelement),
inpoint + duration - (duration + start - position));
- _set_duration0 (GES_TIMELINE_ELEMENT (new_tckobj),
+ _set_duration0 (GES_TIMELINE_ELEMENT (new_trackelement),
duration + start - position);
/* Set 'old' track object duration */
- _set_duration0 (GES_TIMELINE_ELEMENT (tckobj), position - start);
+ _set_duration0 (GES_TIMELINE_ELEMENT (trackelement), position - start);
/* And let track objects in the same locking state as before. */
- ges_track_object_set_locked (tckobj, locked);
- ges_track_object_set_locked (new_tckobj, locked);
+ ges_track_element_set_locked (trackelement, locked);
+ ges_track_element_set_locked (new_trackelement, locked);
}
return new_object;
/**
* ges_clip_objects_set_locked:
* @object: the #GESClip
- * @locked: whether the #GESTrackObject contained in @object are locked to it.
+ * @locked: whether the #GESTrackElement contained in @object are locked to it.
*
- * Set the locking status of all the #GESTrackObject contained in @object to @locked.
- * See the ges_track_object_set_locked documentation for more details.
+ * Set the locking status of all the #GESTrackElement contained in @object to @locked.
+ * See the ges_track_element_set_locked documentation for more details.
*
* Since: 0.10.XX
*/
g_return_if_fail (GES_IS_CLIP (object));
for (tmp = object->priv->mappings; tmp; tmp = g_list_next (tmp)) {
- ges_track_object_set_locked (((ObjectMapping *) tmp->data)->object, locked);
+ ges_track_element_set_locked (((ObjectMapping *) tmp->data)->object,
+ locked);
}
}
gboolean
_ripple (GESTimelineElement * element, GstClockTime start)
{
- GList *tmp, *tckobjs;
+ GList *tmp, *trackelements;
gboolean ret = TRUE;
GESTimeline *timeline;
GESClip *object = GES_CLIP (element);
return FALSE;
}
- tckobjs = ges_clip_get_track_objects (object);
- for (tmp = tckobjs; tmp; tmp = g_list_next (tmp)) {
- if (ges_track_object_is_locked (tmp->data)) {
- ret = timeline_ripple_object (timeline, GES_TRACK_OBJECT (tmp->data),
+ trackelements = ges_clip_get_track_elements (object);
+ for (tmp = trackelements; tmp; tmp = g_list_next (tmp)) {
+ if (ges_track_element_is_locked (tmp->data)) {
+ ret = timeline_ripple_object (timeline, GES_TRACK_ELEMENT (tmp->data),
NULL, GES_EDGE_NONE, start);
/* As we work only with locked objects, the changes will be reflected
- * to others controlled TrackObjects */
+ * to others controlled TrackElements */
break;
}
}
- g_list_free_full (tckobjs, g_object_unref);
+ g_list_free_full (trackelements, g_object_unref);
return ret;
}
static gboolean
_ripple_end (GESTimelineElement * element, GstClockTime end)
{
- GList *tmp, *tckobjs;
+ GList *tmp, *trackelements;
gboolean ret = TRUE;
GESTimeline *timeline;
GESClip *object = GES_CLIP (element);
return FALSE;
}
- tckobjs = ges_clip_get_track_objects (object);
- for (tmp = tckobjs; tmp; tmp = g_list_next (tmp)) {
- if (ges_track_object_is_locked (tmp->data)) {
- ret = timeline_ripple_object (timeline, GES_TRACK_OBJECT (tmp->data),
+ trackelements = ges_clip_get_track_elements (object);
+ for (tmp = trackelements; tmp; tmp = g_list_next (tmp)) {
+ if (ges_track_element_is_locked (tmp->data)) {
+ ret = timeline_ripple_object (timeline, GES_TRACK_ELEMENT (tmp->data),
NULL, GES_EDGE_END, end);
/* As we work only with locked objects, the changes will be reflected
- * to others controlled TrackObjects */
+ * to others controlled TrackElements */
break;
}
}
- g_list_free_full (tckobjs, g_object_unref);
+ g_list_free_full (trackelements, g_object_unref);
return ret;
}
gboolean
_roll_start (GESTimelineElement * element, GstClockTime start)
{
- GList *tmp, *tckobjs;
+ GList *tmp, *trackelements;
gboolean ret = TRUE;
GESTimeline *timeline;
return FALSE;
}
- tckobjs = ges_clip_get_track_objects (object);
- for (tmp = tckobjs; tmp; tmp = g_list_next (tmp)) {
- if (ges_track_object_is_locked (tmp->data)) {
- ret = timeline_roll_object (timeline, GES_TRACK_OBJECT (tmp->data),
+ trackelements = ges_clip_get_track_elements (object);
+ for (tmp = trackelements; tmp; tmp = g_list_next (tmp)) {
+ if (ges_track_element_is_locked (tmp->data)) {
+ ret = timeline_roll_object (timeline, GES_TRACK_ELEMENT (tmp->data),
NULL, GES_EDGE_START, start);
/* As we work only with locked objects, the changes will be reflected
- * to others controlled TrackObjects */
+ * to others controlled TrackElements */
break;
}
}
- g_list_free_full (tckobjs, g_object_unref);
+ g_list_free_full (trackelements, g_object_unref);
return ret;
}
gboolean
_roll_end (GESTimelineElement * element, GstClockTime end)
{
- GList *tmp, *tckobjs;
+ GList *tmp, *trackelements;
gboolean ret = TRUE;
GESTimeline *timeline;
}
- tckobjs = ges_clip_get_track_objects (object);
- for (tmp = tckobjs; tmp; tmp = g_list_next (tmp)) {
- if (ges_track_object_is_locked (tmp->data)) {
- ret = timeline_roll_object (timeline, GES_TRACK_OBJECT (tmp->data),
+ trackelements = ges_clip_get_track_elements (object);
+ for (tmp = trackelements; tmp; tmp = g_list_next (tmp)) {
+ if (ges_track_element_is_locked (tmp->data)) {
+ ret = timeline_roll_object (timeline, GES_TRACK_ELEMENT (tmp->data),
NULL, GES_EDGE_END, end);
/* As we work only with locked objects, the changes will be reflected
- * to others controlled TrackObjects */
+ * to others controlled TrackElements */
break;
}
}
- g_list_free_full (tckobjs, g_object_unref);
+ g_list_free_full (trackelements, g_object_unref);
return ret;
}
gboolean
_trim (GESTimelineElement * element, GstClockTime start)
{
- GList *tmp, *tckobjs;
+ GList *tmp, *trackelements;
gboolean ret = TRUE;
GESTimeline *timeline;
return FALSE;
}
- tckobjs = ges_clip_get_track_objects (object);
- for (tmp = tckobjs; tmp; tmp = g_list_next (tmp)) {
- if (ges_track_object_is_locked (tmp->data)) {
- ret = timeline_trim_object (timeline, GES_TRACK_OBJECT (tmp->data),
+ trackelements = ges_clip_get_track_elements (object);
+ for (tmp = trackelements; tmp; tmp = g_list_next (tmp)) {
+ if (ges_track_element_is_locked (tmp->data)) {
+ ret = timeline_trim_object (timeline, GES_TRACK_ELEMENT (tmp->data),
NULL, GES_EDGE_START, start);
break;
}
}
- g_list_free_full (tckobjs, g_object_unref);
+ g_list_free_full (trackelements, g_object_unref);
return ret;
}
/**
* ges_clip_add_asset:
* @object: a #GESClip
- * @asset: a #GESAsset with #GES_TYPE_TRACK_OBJECT as extractable_type
+ * @asset: a #GESAsset with #GES_TYPE_TRACK_ELEMENT as extractable_type
*
- * Extracts a #GESTrackObject from @asset and adds it to the @object.
+ * Extracts a #GESTrackElement from @asset and adds it to the @object.
* Should only be called in order to add operations to a #GESClip,
- * ni other cases TrackObject are added automatically when adding the
+ * ni other cases TrackElement are added automatically when adding the
* #GESClip/#GESAsset to a layer.
*
* Takes a reference on @trobj.
g_return_val_if_fail (GES_IS_CLIP (object), FALSE);
g_return_val_if_fail (GES_IS_ASSET (asset), FALSE);
g_return_val_if_fail (g_type_is_a (ges_asset_get_extractable_type
- (asset), GES_TYPE_TRACK_OBJECT), FALSE);
+ (asset), GES_TYPE_TRACK_ELEMENT), FALSE);
- return ges_clip_add_track_object (object,
- GES_TRACK_OBJECT (ges_asset_extract (asset, NULL)));
+ return ges_clip_add_track_element (object,
+ GES_TRACK_ELEMENT (ges_asset_extract (asset, NULL)));
}
static void
guint32 min_prio = G_MAXUINT32, max_prio = 0;
/* Go over all childs and check if height has changed */
- for (tmp = object->trackobjects; tmp; tmp = tmp->next) {
+ for (tmp = object->trackelements; tmp; tmp = tmp->next) {
guint tck_priority = _PRIORITY (tmp->data);
if (tck_priority < min_prio)
*/
static void
-track_object_start_changed_cb (GESTrackObject * child,
+track_element_start_changed_cb (GESTrackElement * child,
GParamSpec * arg G_GNUC_UNUSED, GESClip * object)
{
ObjectMapping *map;
/* something massively screwed up if we get this */
return;
- if (!ges_track_object_is_locked (child)) {
+ if (!ges_track_element_is_locked (child)) {
/* Update the internal start_offset */
map->start_offset = _START (element) - _START (child);
} else {
}
static void
-track_object_inpoint_changed_cb (GESTrackObject * child,
+track_element_inpoint_changed_cb (GESTrackElement * child,
GParamSpec * arg G_GNUC_UNUSED, GESClip * object)
{
ObjectMapping *map;
/* something massively screwed up if we get this */
return;
- if (!ges_track_object_is_locked (child)) {
+ if (!ges_track_element_is_locked (child)) {
/* Update the internal start_offset */
map->inpoint_offset = _INPOINT (element) - _INPOINT (child);
} else {
}
static void
-track_object_duration_changed_cb (GESTrackObject * child,
+track_element_duration_changed_cb (GESTrackElement * child,
GParamSpec * arg G_GNUC_UNUSED, GESClip * object)
{
ObjectMapping *map;
/* something massively screwed up if we get this */
return;
- if (!ges_track_object_is_locked (child)) {
+ if (!ges_track_element_is_locked (child)) {
/* Update the internal start_offset */
map->duration_offset = _DURATION (element) - _DURATION (child);
} else {
}
static void
-track_object_priority_changed_cb (GESTrackObject * child,
+track_element_priority_changed_cb (GESTrackElement * child,
GParamSpec * arg G_GNUC_UNUSED, GESClip * object)
{
ObjectMapping *map;
guint tck_priority = _PRIORITY (child);
- GST_DEBUG ("TrackObject %p priority changed to %i", child, _PRIORITY (child));
+ GST_DEBUG ("TrackElement %p priority changed to %i", child,
+ _PRIORITY (child));
if (object->priv->ignore_notifies)
return;
/* something massively screwed up if we get this */
return;
- if (!ges_track_object_is_locked (child)) {
+ if (!ges_track_element_is_locked (child)) {
if (tck_priority < layer_min_gnl_prio || tck_priority > layer_max_gnl_prio) {
GST_WARNING ("%p priority of %i, is outside of its containing "
"layer space. (%d/%d). This is a bug in the program.", element,
typedef struct _GESClipPrivate GESClipPrivate;
/**
- * GESFillTrackObjectFunc:
+ * GESFillTrackElementFunc:
* @object: the #GESClip controlling the track object
- * @trobject: the #GESTrackObject
+ * @trobject: the #GESTrackElement
* @gnlobj: the GNonLin object that needs to be filled.
*
* A function that will be called when the GNonLin object of a corresponding
*
* Returns: TRUE if the implementer succesfully filled the @gnlobj, else #FALSE.
*/
-typedef gboolean (*GESFillTrackObjectFunc) (GESClip *object,
- GESTrackObject *trobject,
+typedef gboolean (*GESFillTrackElementFunc) (GESClip *object,
+ GESTrackElement *trobject,
GstElement *gnlobj);
/**
- * GESCreateTrackObjectFunc:
+ * GESCreateTrackElementFunc:
* @object: a #GESClip
* @type: a #GESTrackType
*
* Creates the 'primary' track object for this @object.
*
* Subclasses should implement this method if they only provide a
- * single #GESTrackObject per track.
+ * single #GESTrackElement per track.
*
- * If the subclass needs to create more than one #GESTrackObject for a
- * given track, then it should implement the 'create_track_objects'
+ * If the subclass needs to create more than one #GESTrackElement for a
+ * given track, then it should implement the 'create_track_elements'
* method instead.
*
- * The implementer of this function shall return the proper #GESTrackObject
+ * The implementer of this function shall return the proper #GESTrackElement
* that should be controlled by @object for the given @track.
*
- * The returned #GESTrackObject will be automatically added to the list
+ * The returned #GESTrackElement will be automatically added to the list
* of objects controlled by the #GESClip.
*
- * Returns: the #GESTrackObject to be used, or %NULL if it can't provide one
+ * Returns: the #GESTrackElement to be used, or %NULL if it can't provide one
* for the given @track.
*/
-typedef GESTrackObject *(*GESCreateTrackObjectFunc) (GESClip * object,
+typedef GESTrackElement *(*GESCreateTrackElementFunc) (GESClip * object,
GESTrackType type);
/**
- * GESCreateTrackObjectsFunc:
+ * GESCreateTrackElementsFunc:
* @object: a #GESClip
* @type: a #GESTrackType
*
* Create all track objects this object handles for this type of track.
*
* Subclasses should implement this method if they potentially need to
- * return more than one #GESTrackObject(s) for a given #GESTrack.
+ * return more than one #GESTrackElement(s) for a given #GESTrack.
*
* For each object created, the subclass must call
- * ges_clip_add_track_object() with the newly created object
+ * ges_clip_add_track_element() with the newly created object
* and provided @type.
*
* Returns: %TRUE on success %FALSE on failure.
*/
-typedef GList * (*GESCreateTrackObjectsFunc) (GESClip * object, GESTrackType type);
+typedef GList * (*GESCreateTrackElementsFunc) (GESClip * object, GESTrackType type);
/**
* GES_CLIP_HEIGHT:
/**
* GESClip:
- * @trackobjects: (element-type GES.TrackObject): A list of TrackObject
+ * @trackelements: (element-type GES.TrackElement): A list of TrackElement
* controlled by this Clip sorted by priority. NOTE: Do not modify.
*
* The #GESClip base class.
GESTimelineElement parent;
/*< readonly >*/
- GList *trackobjects;
+ GList *trackelements;
/* We don't add those properties to the priv struct for optimization purposes
* start, inpoint, duration and fullduration are in nanoseconds */
/**
* GESClipClass:
- * @create_track_object: method to create a single #GESTrackObject for a given #GESTrack.
- * @create_track_objects: method to create multiple #GESTrackObjects for a
+ * @create_track_element: method to create a single #GESTrackElement for a given #GESTrack.
+ * @create_track_elements: method to create multiple #GESTrackElements for a
* #GESTrack.
- * @fill_track_object: method to fill an associated #GESTrackObject.
- * @need_fill_track: Set to TRUE if @fill_track_object needs to be called.
+ * @fill_track_element: method to fill an associated #GESTrackElement.
+ * @need_fill_track: Set to TRUE if @fill_track_element needs to be called.
* @snaps: Set to %TRUE if the objects of this type snap with
* other objects in a timeline %FALSE otherwise (default is %FALSE). Basically only
* sources snap.
- * @track_object_added: Should be overridden by subclasses if they need to perform an
- * operation when a #GESTrackObject is added. Since: 0.10.2
- * @track_object_released: Should be overridden by subclasses if they need to perform
- * action when a #GESTrackObject is released. Since: 0.10.2
+ * @track_element_added: Should be overridden by subclasses if they need to perform an
+ * operation when a #GESTrackElement is added. Since: 0.10.2
+ * @track_element_released: Should be overridden by subclasses if they need to perform
+ * action when a #GESTrackElement is released. Since: 0.10.2
*
- * Subclasses can override the @create_track_object and @fill_track_object methods.
+ * Subclasses can override the @create_track_element and @fill_track_element methods.
*/
struct _GESClipClass
{
GESTimelineElementClass parent_class;
/*< public > */
- GESCreateTrackObjectFunc create_track_object;
- GESCreateTrackObjectsFunc create_track_objects;
+ GESCreateTrackElementFunc create_track_element;
+ GESCreateTrackElementsFunc create_track_elements;
- /* FIXME : might need a release_track_object */
- GESFillTrackObjectFunc fill_track_object;
+ /* FIXME : might need a release_track_element */
+ GESFillTrackElementFunc fill_track_element;
gboolean need_fill_track;
gboolean snaps;
- void (*track_object_added) (GESClip *object,
- GESTrackObject *tck_object);
- void (*track_object_released) (GESClip *object,
- GESTrackObject *tck_object);
+ void (*track_element_added) (GESClip *object,
+ GESTrackElement *tck_object);
+ void (*track_element_released) (GESClip *object,
+ GESTrackElement *tck_object);
/*< private >*/
/* Padding for API extension */
void ges_clip_set_layer (GESClip *object,
GESTimelineLayer *layer);
-/* TrackObject handling */
-GList* ges_clip_get_track_objects (GESClip *object);
+/* TrackElement handling */
+GList* ges_clip_get_track_elements (GESClip *object);
GESTrackType ges_clip_get_supported_formats (GESClip *object);
-GESTrackObject *ges_clip_create_track_object (GESClip *object, GESTrackType type);
-GList * ges_clip_create_track_objects (GESClip *object, GESTrackType type);
-gboolean ges_clip_release_track_object (GESClip *object, GESTrackObject *trackobject);
+GESTrackElement *ges_clip_create_track_element (GESClip *object, GESTrackType type);
+GList * ges_clip_create_track_elements (GESClip *object, GESTrackType type);
+gboolean ges_clip_release_track_element (GESClip *object, GESTrackElement *trackelement);
void ges_clip_set_supported_formats (GESClip *object, GESTrackType supportedformats);
gboolean ges_clip_add_asset (GESClip *object, GESAsset *asset);
-gboolean ges_clip_add_track_object (GESClip *object, GESTrackObject *trobj);
-gboolean ges_clip_fill_track_object (GESClip *object, GESTrackObject *trackobj, GstElement *gnlobj);
-GESTrackObject *ges_clip_find_track_object (GESClip *object, GESTrack *track, GType type);
+gboolean ges_clip_add_track_element (GESClip *object, GESTrackElement *trobj);
+gboolean ges_clip_fill_track_element (GESClip *object, GESTrackElement *trackelement, GstElement *gnlobj);
+GESTrackElement *ges_clip_find_track_element (GESClip *object, GESTrack *track, GType type);
/* Layer */
GESTimelineLayer *ges_clip_get_layer (GESClip *object);
struct _GESCustomSourceClipPrivate
{
- GESFillTrackObjectUserFunc filltrackobjectfunc;
+ GESFillTrackElementUserFunc filltrackelementfunc;
gpointer user_data;
};
{
GESCustomSourceClipPrivate *priv = GES_CUSTOM_SOURCE_CLIP (self)->priv;
- return g_strdup_printf ("%i!%i", GPOINTER_TO_INT (priv->filltrackobjectfunc),
+ return g_strdup_printf ("%i!%i", GPOINTER_TO_INT (priv->filltrackelementfunc),
GPOINTER_TO_INT (priv->user_data));
}
}
static gboolean
-ges_custom_source_clip_fill_track_object (GESClip * object,
- GESTrackObject * trobject, GstElement * gnlobj);
+ges_custom_source_clip_fill_track_element (GESClip * object,
+ GESTrackElement * trobject, GstElement * gnlobj);
-static GESTrackObject *
-ges_custom_source_clip_create_track_object (GESClip * obj, GESTrackType type)
+static GESTrackElement *
+ges_custom_source_clip_create_track_element (GESClip * obj, GESTrackType type)
{
return g_object_new (GES_TYPE_TRACK_SOURCE, "track-type", type, NULL);
}
GESCustomSourceClipPrivate *priv = GES_CUSTOM_SOURCE_CLIP (object)->priv;
switch (property_id) {
case PROP_FILL_FUNC:
- priv->filltrackobjectfunc = g_value_get_pointer (value);
+ priv->filltrackelementfunc = g_value_get_pointer (value);
break;
case PROP_USER_DATA:
priv->user_data = g_value_get_pointer (value);
g_type_class_add_private (klass, sizeof (GESCustomSourceClipPrivate));
- clip_class->fill_track_object = ges_custom_source_clip_fill_track_object;
- clip_class->create_track_object = ges_custom_source_clip_create_track_object;
+ clip_class->fill_track_element = ges_custom_source_clip_fill_track_element;
+ clip_class->create_track_element =
+ ges_custom_source_clip_create_track_element;
object_class->set_property = _set_property;
/**
* GESCustomSourceClip:fill-func:
*
- * The function pointer to create the TrackObject content
+ * The function pointer to create the TrackElement content
*/
g_object_class_install_property (object_class, PROP_FILL_FUNC,
g_param_spec_pointer ("fill-func", "Fill func",
- "A pointer to a GESFillTrackObjectUserFunc",
+ "A pointer to a GESFillTrackElementUserFunc",
G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
/**
*/
g_object_class_install_property (object_class, PROP_USER_DATA,
g_param_spec_pointer ("user-data", "User data",
- "The user data pointer that will be passed when creating TrackObjects",
+ "The user data pointer that will be passed when creating TrackElements",
G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
}
}
static gboolean
-ges_custom_source_clip_fill_track_object (GESClip * object,
- GESTrackObject * trobject, GstElement * gnlobj)
+ges_custom_source_clip_fill_track_element (GESClip * object,
+ GESTrackElement * trobject, GstElement * gnlobj)
{
gboolean res;
GESCustomSourceClipPrivate *priv;
- GST_DEBUG ("Calling callback (timelineobj:%p, trackobj:%p, gnlobj:%p)",
+ GST_DEBUG ("Calling callback (timelineobj:%p, trackelement:%p, gnlobj:%p)",
object, trobject, gnlobj);
priv = GES_CUSTOM_SOURCE_CLIP (object)->priv;
- res = priv->filltrackobjectfunc (object, trobject, gnlobj, priv->user_data);
+ res = priv->filltrackelementfunc (object, trobject, gnlobj, priv->user_data);
GST_DEBUG ("Returning res:%d", res);
/**
* ges_custom_source_clip_new:
- * @func: (scope notified): The #GESFillTrackObjectUserFunc that will be used to fill the track
+ * @func: (scope notified): The #GESFillTrackElementUserFunc that will be used to fill the track
* objects.
* @user_data: (closure): a gpointer that will be used when @func is called.
*
* Returns: The new #GESCustomSourceClip.
*/
GESCustomSourceClip *
-ges_custom_source_clip_new (GESFillTrackObjectUserFunc func, gpointer user_data)
+ges_custom_source_clip_new (GESFillTrackElementUserFunc func,
+ gpointer user_data)
{
GESCustomSourceClip *src;
src = g_object_new (GES_TYPE_CUSTOM_SOURCE_CLIP, "supported-formats",
GES_TRACK_TYPE_CUSTOM, NULL);
- src->priv->filltrackobjectfunc = func;
+ src->priv->filltrackelementfunc = func;
src->priv->user_data = user_data;
return src;
/**
* ges_asset_custom_source_clip_new:
- * @func: (scope notified): The #GESFillTrackObjectUserFunc that will be used to fill the track
+ * @func: (scope notified): The #GESFillTrackElementUserFunc that will be used to fill the track
* objects.
* @user_data: (closure): a gpointer that will be used when @func is called.
*
* Returns: The new #GESAsset.
*/
GESAsset *
-ges_asset_custom_source_clip_new (GESFillTrackObjectUserFunc func,
+ges_asset_custom_source_clip_new (GESFillTrackElementUserFunc func,
gpointer user_data)
{
GESAsset *asset;
typedef struct _GESCustomSourceClipPrivate GESCustomSourceClipPrivate;
/**
- * GESFillTrackObjectUserFunc:
+ * GESFillTrackElementUserFunc:
* @object: the #GESClip controlling the track object
- * @trobject: the #GESTrackObject
+ * @trobject: the #GESTrackElement
* @gnlobj: the GNonLin object that needs to be filled.
* @user_data: the gpointer to optional user data
*
*
* Returns: TRUE if the implementer succesfully filled the @gnlobj, else #FALSE.
*/
-typedef gboolean (*GESFillTrackObjectUserFunc) (GESClip * object,
- GESTrackObject * trobject,
+typedef gboolean (*GESFillTrackElementUserFunc) (GESClip * object,
+ GESTrackElement * trobject,
GstElement * gnlobj,
gpointer user_data);
GType ges_custom_source_clip_get_type (void);
GESCustomSourceClip*
-ges_custom_source_clip_new (GESFillTrackObjectUserFunc func,
+ges_custom_source_clip_new (GESFillTrackElementUserFunc func,
gpointer user_data);
GESAsset*
-ges_asset_custom_source_clip_new (GESFillTrackObjectUserFunc func,
+ges_asset_custom_source_clip_new (GESFillTrackElementUserFunc func,
gpointer user_data);
};
static void ges_effect_clip_finalize (GObject * object);
-static GESTrackObject
+static GESTrackElement
* ges_tl_parse_launch_effect_create_track_obj (GESClip * self,
GESTrackType type);
"Bin description of the audio track of the effect",
NULL, G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
- timobj_class->create_track_object =
+ timobj_class->create_track_element =
ges_tl_parse_launch_effect_create_track_obj;
timobj_class->need_fill_track = FALSE;
}
}
-static GESTrackObject *
+static GESTrackElement *
ges_tl_parse_launch_effect_create_track_obj (GESClip * self, GESTrackType type)
{
const gchar *bin_description = NULL;
#include <gio/gio.h>
#include "ges-timeline.h"
-#include "ges-track-object.h"
+#include "ges-track-element.h"
#include "ges-timeline-element.h"
#include "ges-asset.h"
#define _set_priority0 ges_timeline_element_set_priority
G_GNUC_INTERNAL gboolean
-timeline_ripple_object (GESTimeline *timeline, GESTrackObject *obj,
+timeline_ripple_object (GESTimeline *timeline, GESTrackElement *obj,
GList * layers, GESEdge edge,
guint64 position);
G_GNUC_INTERNAL gboolean
-timeline_slide_object (GESTimeline *timeline, GESTrackObject *obj,
+timeline_slide_object (GESTimeline *timeline, GESTrackElement *obj,
GList * layers, GESEdge edge, guint64 position);
G_GNUC_INTERNAL gboolean
-timeline_roll_object (GESTimeline *timeline, GESTrackObject *obj,
+timeline_roll_object (GESTimeline *timeline, GESTrackElement *obj,
GList * layers, GESEdge edge, guint64 position);
G_GNUC_INTERNAL gboolean
-timeline_trim_object (GESTimeline *timeline, GESTrackObject * object,
+timeline_trim_object (GESTimeline *timeline, GESTrackElement * object,
GList * layers, GESEdge edge, guint64 position);
G_GNUC_INTERNAL gboolean
-ges_timeline_trim_object_simple (GESTimeline * timeline, GESTrackObject * obj,
+ges_timeline_trim_object_simple (GESTimeline * timeline, GESTrackElement * obj,
GList * layers, GESEdge edge, guint64 position, gboolean snapping);
G_GNUC_INTERNAL gboolean
-ges_timeline_move_object_simple (GESTimeline * timeline, GESTrackObject * object,
+ges_timeline_move_object_simple (GESTimeline * timeline, GESTrackElement * object,
GList * layers, GESEdge edge, guint64 position);
G_GNUC_INTERNAL gboolean
-timeline_move_object (GESTimeline *timeline, GESTrackObject * object,
+timeline_move_object (GESTimeline *timeline, GESTrackElement * object,
GList * layers, GESEdge edge, guint64 position);
G_GNUC_INTERNAL gboolean
gboolean variableframerate,
GstStructure * properties,
GError ** error);
-G_GNUC_INTERNAL void ges_base_xml_formatter_add_track_object (GESBaseXmlFormatter *self,
+G_GNUC_INTERNAL void ges_base_xml_formatter_add_track_element (GESBaseXmlFormatter *self,
GType effect_type,
const gchar *asset_id,
const gchar * track_id,
* "effect_name": name
* "effect_props": {"propname": value}}}
*/
- GHashTable *track_objects_table;
+ GHashTable *track_elements_table;
/* {factory-ref: [track-object-ref-id,...]} */
GHashTable *clips_table;
}
static void
-save_track_objects (xmlTextWriterPtr writer, GList * source_list,
+save_track_elements (xmlTextWriterPtr writer, GList * source_list,
GESTrackType type, gint * id)
{
GList *tmp, *tck_objs, *tmp_tck;
object = srcmap->obj;
/* Save track associated objects */
- tck_objs = ges_clip_get_track_objects (object);
+ tck_objs = ges_clip_get_track_elements (object);
for (tmp_tck = tck_objs; tmp_tck; tmp_tck = tmp_tck->next) {
xmlChar *cast;
- GESTrackObject *tckobj = GES_TRACK_OBJECT (tmp_tck->data);
- GESTrack *track = ges_track_object_get_track (tckobj);
+ GESTrackElement *trackelement = GES_TRACK_ELEMENT (tmp_tck->data);
+ GESTrack *track = ges_track_element_get_track (trackelement);
const gchar *active, *locked;
if (!track) {
- GST_WARNING ("Track object %p not in a track yet", tckobj);
+ GST_WARNING ("Track object %p not in a track yet", trackelement);
continue;
}
xmlTextWriterStartElement (writer, BAD_CAST "track-object");
active =
- ges_track_object_is_active (tckobj) ? "(bool)True" : "(bool)False";
+ ges_track_element_is_active (trackelement) ? "(bool)True" :
+ "(bool)False";
xmlTextWriterWriteAttribute (writer, BAD_CAST "active", BAD_CAST active);
locked =
- ges_track_object_is_locked (tckobj) ? "(bool)True" : "(bool)False";
+ ges_track_element_is_locked (trackelement) ? "(bool)True" :
+ "(bool)False";
xmlTextWriterWriteAttribute (writer, BAD_CAST "locked", BAD_CAST locked);
/* Here the priority correspond to the layer priority */
write_int_attribute (writer, srcmap->priority, "priority", "(int)");
- g_object_get (G_OBJECT (tckobj), "duration", &duration, "start", &start,
- "in-point", &inpoint, NULL);
+ g_object_get (G_OBJECT (trackelement), "duration", &duration, "start",
+ &start, "in-point", &inpoint, NULL);
write_int_attribute (writer, duration, "duration", "(gint64)");
write_int_attribute (writer, start, "start", "(gint64)");
write_int_attribute (writer, inpoint, "in_point", "(gint64)");
xmlTextWriterWriteAttribute (writer, BAD_CAST "id", BAD_CAST cast);
xmlFree (cast);
- if (GES_IS_TRACK_EFFECT (tckobj)) {
+ if (GES_IS_TRACK_EFFECT (trackelement)) {
GParamSpec **pspecs, *spec;
gchar *serialized, *concatenated;
guint n_props = 0;
xmlTextWriterWriteAttribute (writer, BAD_CAST "type",
BAD_CAST "pitivi.timeline.track.TrackEffect");
- g_object_get (tckobj, "bin-description", &bin_desc, NULL);
+ g_object_get (trackelement, "bin-description", &bin_desc, NULL);
xmlTextWriterStartElement (writer, BAD_CAST "effect");
xmlTextWriterStartElement (writer, BAD_CAST "factory");
xmlTextWriterWriteAttribute (writer, BAD_CAST "name",
xmlTextWriterEndElement (writer);
xmlTextWriterStartElement (writer, BAD_CAST "gst-element-properties");
- pspecs = ges_track_object_list_children_properties (tckobj, &n_props);
+ pspecs =
+ ges_track_element_list_children_properties (trackelement, &n_props);
j = 0;
spec = pspecs[j];
g_value_init (&val, spec->value_type);
- ges_track_object_get_child_property_by_pspec (tckobj, spec, &val);
+ ges_track_element_get_child_property_by_pspec (trackelement, spec,
+ &val);
serialized = gst_value_serialize (&val);
if (!g_strcmp0 (spec->name, (gchar *) "preset")) {
concatenated =
} else {
xmlTextWriterWriteAttribute (writer, BAD_CAST "type",
- BAD_CAST "pitivi.timeline.track.SourceTrackObject");
+ BAD_CAST "pitivi.timeline.track.SourceTrackElement");
xmlTextWriterStartElement (writer, BAD_CAST "factory-ref");
xmlTextWriterWriteAttribute (writer, BAD_CAST "id",
xmlTextWriterEndElement (writer);
xmlTextWriterEndElement (writer);
- /* We add effects at the end of the trackobject list */
- if (GES_IS_TRACK_EFFECT (tckobj)) {
+ /* We add effects at the end of the trackelement list */
+ if (GES_IS_TRACK_EFFECT (trackelement)) {
srcmap->tck_obj_ids = g_list_append (srcmap->tck_obj_ids,
xmlXPathCastNumberToString (*id));
} else {
continue;
}
- save_track_objects (writer, source_list, type, &id);
+ save_track_elements (writer, source_list, type, &id);
xmlTextWriterEndElement (writer);
}
uriclip_uri));
srcmap->obj = g_object_ref (clip);
srcmap->priority = ges_timeline_layer_get_priority (layer);
- /* We fill up the tck_obj_ids in save_track_objects */
+ /* We fill up the tck_obj_ids in save_track_elements */
source_list = g_list_append (source_list, srcmap);
}
}
}
static gboolean
-parse_track_objects (GESFormatter * self)
+parse_track_elements (GESFormatter * self)
{
GESPitiviFormatterPrivate *priv = GES_PITIVI_FORMATTER (self)->priv;
xmlXPathObjectPtr xpathObj;
if (effect_table)
g_hash_table_insert (table, g_strdup ("effect_props"), effect_table);
- g_hash_table_insert (priv->track_objects_table, g_strdup (id), table);
+ g_hash_table_insert (priv->track_elements_table, g_strdup (id), table);
}
xmlXPathFreeObject (xpathObj);
xmlNodeSetPtr nodes;
xmlXPathObjectPtr xpathObj;
xmlNodePtr clip_nd, tmp_nd, tmp_nd2;
- xmlChar *tckobjrefId, *facrefId = NULL;
+ xmlChar *trackelementrefId, *facrefId = NULL;
GList *reflist = NULL;
GESPitiviFormatterPrivate *priv = GES_PITIVI_FORMATTER (self)->priv;
clip_nd = nodes->nodeTab[j];
for (tmp_nd = clip_nd->children; tmp_nd; tmp_nd = tmp_nd->next) {
- /* We assume that factory-ref is always before the tckobjs-ref */
+ /* We assume that factory-ref is always before the trackelements-ref */
if (!xmlStrcmp (tmp_nd->name, (xmlChar *) "factory-ref")) {
facrefId = xmlGetProp (tmp_nd, (xmlChar *) "id");
if (!xmlStrcmp (tmp_nd2->name, (xmlChar *) "track-object-ref")) {
/* We add the track object ref ID to the list of the current
* Clip tracks, this way we can merge 2
- * Clip-s into 1 when we have unlinked TrackObject-s */
+ * Clip-s into 1 when we have unlinked TrackElement-s */
reflist = g_hash_table_lookup (clips_table, facrefId);
- tckobjrefId = xmlGetProp (tmp_nd2, (xmlChar *) "id");
- reflist = g_list_append (reflist, g_strdup ((gchar *) tckobjrefId));
+ trackelementrefId = xmlGetProp (tmp_nd2, (xmlChar *) "id");
+ reflist =
+ g_list_append (reflist, g_strdup ((gchar *) trackelementrefId));
g_hash_table_insert (clips_table, g_strdup ((gchar *) facrefId),
reflist);
- xmlFree (tckobjrefId);
+ xmlFree (trackelementrefId);
}
}
}
}
static void
-track_object_added_cb (GESClip * object,
- GESTrackObject * track_object, GHashTable * props_table)
+track_element_added_cb (GESClip * object,
+ GESTrackElement * track_element, GHashTable * props_table)
{
gchar *media_type = NULL, *lockedstr;
GList *tck_objs = NULL, *tmp = NULL;
gint type = 0;
GESPitiviFormatter *formatter;
- tck_objs = ges_clip_get_track_objects (object);
+ tck_objs = ges_clip_get_track_elements (object);
media_type = (gchar *) g_hash_table_lookup (props_table, "media_type");
lockedstr = (gchar *) g_hash_table_lookup (props_table, "locked");
for (tmp = tck_objs; tmp; tmp = tmp->next) {
- if (!GES_IS_TRACK_OBJECT (tmp->data)) {
+ if (!GES_IS_TRACK_ELEMENT (tmp->data)) {
/* If we arrive here something massively screwed */
- GST_ERROR ("Not a TrackObject, this is a bug");
+ GST_ERROR ("Not a TrackElement, this is a bug");
continue;
}
- track = ges_track_object_get_track (tmp->data);
+ track = ges_track_element_get_track (tmp->data);
if (!track) {
- GST_WARNING ("TrackObject not in a track yet");
+ GST_WARNING ("TrackElement not in a track yet");
continue;
}
&& track->type == GES_TRACK_TYPE_AUDIO)) {
/* We unlock the track objects so we do not move the whole Clip */
- ges_track_object_set_locked (tmp->data, FALSE);
+ ges_track_element_set_locked (tmp->data, FALSE);
set_properties (G_OBJECT (tmp->data), props_table);
if (locked)
- ges_track_object_set_locked (tmp->data, TRUE);
+ ges_track_element_set_locked (tmp->data, TRUE);
type = track->type;
g_object_get (tmp->data, "start", &start, "duration", &duration, NULL);
}
if (has_effect) {
- tck_objs = ges_clip_get_track_objects (object);
+ tck_objs = ges_clip_get_track_elements (object);
/* FIXME make sure this is the way we want to handle that
- * ie: set duration and start as the other trackobject
+ * ie: set duration and start as the other trackelement
* and no let full control to the user. */
for (tmp = tck_objs; tmp; tmp = tmp->next) {
/* We set the effects start and duration */
- track = ges_track_object_get_track (tmp->data);
+ track = ges_track_element_get_track (tmp->data);
if (GES_IS_TRACK_PARSE_LAUNCH_EFFECT (tmp->data)
&& (type == track->type)) {
/* We lock the track objects so we do not move the whole Clip */
- ges_track_object_set_locked (tmp->data, FALSE);
+ ges_track_element_set_locked (tmp->data, FALSE);
g_object_set (tmp->data, "start", start, "duration", duration, NULL);
if (locked)
- ges_track_object_set_locked (tmp->data, TRUE);
+ ges_track_element_set_locked (tmp->data, TRUE);
}
}
}
/* Disconnect the signal */
- g_signal_handlers_disconnect_by_func (object, track_object_added_cb,
+ g_signal_handlers_disconnect_by_func (object, track_element_added_cb,
props_table);
}
GESUriClip *src = NULL;
gint prio;
gboolean a_avail = FALSE, v_avail = FALSE, video;
- GHashTable *tckobj_table = priv->track_objects_table;
+ GHashTable *trackelement_table = priv->track_elements_table;
for (tmp = reflist; tmp; tmp = tmp->next) {
/* Get the layer */
- props_table = g_hash_table_lookup (tckobj_table, (gchar *) tmp->data);
+ props_table = g_hash_table_lookup (trackelement_table, (gchar *) tmp->data);
prio_str = (gchar *) g_hash_table_lookup (props_table, "priority");
prio_array = g_strsplit (prio_str, ")", 0);
prio = (gint) g_ascii_strtod (prio_array[1], NULL);
ges_timeline_layer_add_object (layer, GES_CLIP (src));
g_signal_connect (src, "track-object-added",
- G_CALLBACK (track_object_added_cb), props_table);
+ G_CALLBACK (track_element_added_cb), props_table);
priv->sources_to_load = g_list_prepend (priv->sources_to_load, src);
}
effect = ges_track_parse_launch_effect_new ((gchar *)
g_hash_table_lookup (props_table, (gchar *) "effect_name"));
- ges_track_object_set_track_type (GES_TRACK_OBJECT (effect),
+ ges_track_element_set_track_type (GES_TRACK_ELEMENT (effect),
(video ? GES_TRACK_TYPE_VIDEO : GES_TRACK_TYPE_AUDIO));
effect_table =
g_hash_table_lookup (props_table, (gchar *) "effect_props");
- ges_clip_add_track_object (GES_CLIP (src), GES_TRACK_OBJECT (effect));
+ ges_clip_add_track_element (GES_CLIP (src), GES_TRACK_ELEMENT (effect));
if (!g_strcmp0 (active, (gchar *) "(bool)False"))
- ges_track_object_set_active (GES_TRACK_OBJECT (effect), FALSE);
+ ges_track_element_set_active (GES_TRACK_ELEMENT (effect), FALSE);
if (video)
- ges_track_add_object (priv->trackv, GES_TRACK_OBJECT (effect));
+ ges_track_add_object (priv->trackv, GES_TRACK_ELEMENT (effect));
else
- ges_track_add_object (priv->tracka, GES_TRACK_OBJECT (effect));
+ ges_track_add_object (priv->tracka, GES_TRACK_ELEMENT (effect));
/* Set effect properties */
keys = g_hash_table_get_keys (effect_table);
if (g_strstr_len (prop_val, -1, "(GEnum)")) {
gchar **val = g_strsplit (prop_val, ")", 2);
- ges_track_object_set_child_properties (GES_TRACK_OBJECT (effect),
+ ges_track_element_set_child_properties (GES_TRACK_ELEMENT (effect),
(gchar *) tmp_key->data, atoi (val[1]), NULL);
g_strfreev (val);
- } else if (ges_track_object_lookup_child (GES_TRACK_OBJECT (effect),
+ } else if (ges_track_element_lookup_child (GES_TRACK_ELEMENT (effect),
(gchar *) tmp->data, NULL, &spec)) {
gchar *caps_str = g_strdup_printf ("structure1, property1=%s;",
prop_val);
structure = gst_caps_get_structure (caps, 0);
value = gst_structure_get_value (structure, "property1");
- ges_track_object_set_child_property_by_pspec (GES_TRACK_OBJECT
+ ges_track_element_set_child_property_by_pspec (GES_TRACK_ELEMENT
(effect), spec, (GValue *) value);
gst_caps_unref (caps);
}
return FALSE;
}
- if (!parse_track_objects (self)) {
+ if (!parse_track_elements (self)) {
GST_ERROR ("Couldn't find track objects markup in the xptv file");
return FALSE;
}
if (priv->layers_table != NULL)
g_hash_table_destroy (priv->layers_table);
- if (priv->track_objects_table != NULL) {
- g_hash_table_destroy (priv->track_objects_table);
+ if (priv->track_elements_table != NULL) {
+ g_hash_table_destroy (priv->track_elements_table);
}
G_OBJECT_CLASS (ges_pitivi_formatter_parent_class)->finalize (object);
priv = self->priv;
- priv->track_objects_table =
+ priv->track_elements_table =
g_hash_table_new_full (g_str_hash, g_str_equal, g_free,
(GDestroyNotify) g_hash_table_destroy);
#include "ges-internal.h"
#include "ges-test-clip.h"
#include "ges-source-clip.h"
-#include "ges-track-object.h"
+#include "ges-track-element.h"
#include "ges-track-video-test-source.h"
#include "ges-track-audio-test-source.h"
#include <string.h>
PROP_VOLUME,
};
-static GESTrackObject
- * ges_test_clip_create_track_object (GESClip * obj, GESTrackType type);
+static GESTrackElement
+ * ges_test_clip_create_track_element (GESClip * obj, GESTrackType type);
static void
ges_test_clip_get_property (GObject * object, guint property_id,
g_param_spec_boolean ("mute", "Mute", "Mute audio track",
FALSE, G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
- timobj_class->create_track_object = ges_test_clip_create_track_object;
+ timobj_class->create_track_element = ges_test_clip_create_track_element;
timobj_class->need_fill_track = FALSE;
}
void
ges_test_clip_set_mute (GESTestClip * self, gboolean mute)
{
- GList *tmp, *trackobjects;
+ GList *tmp, *trackelements;
GESClip *object = (GESClip *) self;
GST_DEBUG ("self:%p, mute:%d", self, mute);
self->priv->mute = mute;
/* Go over tracked objects, and update 'active' status on all audio objects */
- trackobjects = ges_clip_get_track_objects (object);
- for (tmp = trackobjects; tmp; tmp = tmp->next) {
- GESTrackObject *trackobject = (GESTrackObject *) tmp->data;
+ trackelements = ges_clip_get_track_elements (object);
+ for (tmp = trackelements; tmp; tmp = tmp->next) {
+ GESTrackElement *trackelement = (GESTrackElement *) tmp->data;
- if (ges_track_object_get_track (trackobject)->type == GES_TRACK_TYPE_AUDIO)
- ges_track_object_set_active (trackobject, !mute);
+ if (ges_track_element_get_track (trackelement)->type ==
+ GES_TRACK_TYPE_AUDIO)
+ ges_track_element_set_active (trackelement, !mute);
- g_object_unref (GES_TRACK_OBJECT (tmp->data));
+ g_object_unref (GES_TRACK_ELEMENT (tmp->data));
}
- g_list_free (trackobjects);
+ g_list_free (trackelements);
}
/**
void
ges_test_clip_set_vpattern (GESTestClip * self, GESVideoTestPattern vpattern)
{
- GList *tmp, *trackobjects;
+ GList *tmp, *trackelements;
GESClip *object = (GESClip *) self;
self->priv->vpattern = vpattern;
- trackobjects = ges_clip_get_track_objects (object);
- for (tmp = trackobjects; tmp; tmp = tmp->next) {
- GESTrackObject *trackobject = (GESTrackObject *) tmp->data;
- if (GES_IS_TRACK_VIDEO_TEST_SOURCE (trackobject))
+ trackelements = ges_clip_get_track_elements (object);
+ for (tmp = trackelements; tmp; tmp = tmp->next) {
+ GESTrackElement *trackelement = (GESTrackElement *) tmp->data;
+ if (GES_IS_TRACK_VIDEO_TEST_SOURCE (trackelement))
ges_track_video_test_source_set_pattern (
- (GESTrackVideoTestSource *) trackobject, vpattern);
+ (GESTrackVideoTestSource *) trackelement, vpattern);
- g_object_unref (GES_TRACK_OBJECT (tmp->data));
+ g_object_unref (GES_TRACK_ELEMENT (tmp->data));
}
- g_list_free (trackobjects);
+ g_list_free (trackelements);
}
/**
void
ges_test_clip_set_frequency (GESTestClip * self, gdouble freq)
{
- GList *tmp, *trackobjects;
+ GList *tmp, *trackelements;
GESClip *object = (GESClip *) self;
self->priv->freq = freq;
- trackobjects = ges_clip_get_track_objects (object);
- for (tmp = trackobjects; tmp; tmp = tmp->next) {
- GESTrackObject *trackobject = (GESTrackObject *) tmp->data;
- if (GES_IS_TRACK_AUDIO_TEST_SOURCE (trackobject))
+ trackelements = ges_clip_get_track_elements (object);
+ for (tmp = trackelements; tmp; tmp = tmp->next) {
+ GESTrackElement *trackelement = (GESTrackElement *) tmp->data;
+ if (GES_IS_TRACK_AUDIO_TEST_SOURCE (trackelement))
ges_track_audio_test_source_set_freq (
- (GESTrackAudioTestSource *) trackobject, freq);
+ (GESTrackAudioTestSource *) trackelement, freq);
- g_object_unref (GES_TRACK_OBJECT (tmp->data));
+ g_object_unref (GES_TRACK_ELEMENT (tmp->data));
}
- g_list_free (trackobjects);
+ g_list_free (trackelements);
}
/**
void
ges_test_clip_set_volume (GESTestClip * self, gdouble volume)
{
- GList *tmp, *trackobjects;
+ GList *tmp, *trackelements;
GESClip *object = (GESClip *) self;
self->priv->volume = volume;
- trackobjects = ges_clip_get_track_objects (object);
- for (tmp = trackobjects; tmp; tmp = tmp->next) {
- GESTrackObject *trackobject = (GESTrackObject *) tmp->data;
- if (GES_IS_TRACK_AUDIO_TEST_SOURCE (trackobject))
+ trackelements = ges_clip_get_track_elements (object);
+ for (tmp = trackelements; tmp; tmp = tmp->next) {
+ GESTrackElement *trackelement = (GESTrackElement *) tmp->data;
+ if (GES_IS_TRACK_AUDIO_TEST_SOURCE (trackelement))
ges_track_audio_test_source_set_volume (
- (GESTrackAudioTestSource *) trackobject, volume);
+ (GESTrackAudioTestSource *) trackelement, volume);
- g_object_unref (GES_TRACK_OBJECT (tmp->data));
+ g_object_unref (GES_TRACK_ELEMENT (tmp->data));
}
- g_list_free (trackobjects);
+ g_list_free (trackelements);
}
/**
return self->priv->volume;
}
-static GESTrackObject *
-ges_test_clip_create_track_object (GESClip * obj, GESTrackType type)
+static GESTrackElement *
+ges_test_clip_create_track_element (GESClip * obj, GESTrackType type)
{
GESTestClipPrivate *priv = GES_TEST_CLIP (obj)->priv;
- GESTrackObject *res = NULL;
+ GESTrackElement *res = NULL;
GST_DEBUG ("Creating a GESTrackTestSource for type: %s",
ges_track_type_name (type));
if (type == GES_TRACK_TYPE_VIDEO) {
- res = (GESTrackObject *) ges_track_video_test_source_new ();
+ res = (GESTrackElement *) ges_track_video_test_source_new ();
ges_track_video_test_source_set_pattern (
(GESTrackVideoTestSource *) res, priv->vpattern);
} else if (type == GES_TRACK_TYPE_AUDIO) {
- res = (GESTrackObject *) ges_track_audio_test_source_new ();
+ res = (GESTrackElement *) ges_track_audio_test_source_new ();
if (priv->mute)
- ges_track_object_set_active (res, FALSE);
+ ges_track_element_set_active (res, FALSE);
ges_track_audio_test_source_set_freq ((GESTrackAudioTestSource *) res,
priv->freq);
#include "ges-internal.h"
#include "ges-text-overlay-clip.h"
-#include "ges-track-object.h"
+#include "ges-track-element.h"
#include "ges-track-text-overlay.h"
#include <string.h>
PROP_YPOS,
};
-static GESTrackObject
- * ges_overlay_text_clip_create_track_object (GESClip * obj,
+static GESTrackElement
+ * ges_overlay_text_clip_create_track_element (GESClip * obj,
GESTrackType type);
static void
GES_TEXT_HALIGN_TYPE, DEFAULT_PROP_HALIGNMENT,
G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS));
- timobj_class->create_track_object = ges_overlay_text_clip_create_track_object;
+ timobj_class->create_track_element =
+ ges_overlay_text_clip_create_track_element;
timobj_class->need_fill_track = FALSE;
/**
void
ges_overlay_text_clip_set_text (GESTextOverlayClip * self, const gchar * text)
{
- GList *tmp, *trackobjects;
+ GList *tmp, *trackelements;
GESClip *object = (GESClip *) self;
GST_DEBUG ("self:%p, text:%s", self, text);
self->priv->text = g_strdup (text);
- trackobjects = ges_clip_get_track_objects (object);
- for (tmp = trackobjects; tmp; tmp = tmp->next) {
- GESTrackObject *trackobject = (GESTrackObject *) tmp->data;
+ trackelements = ges_clip_get_track_elements (object);
+ for (tmp = trackelements; tmp; tmp = tmp->next) {
+ GESTrackElement *trackelement = (GESTrackElement *) tmp->data;
- if (ges_track_object_get_track (trackobject)->type == GES_TRACK_TYPE_VIDEO)
- ges_track_text_overlay_set_text (GES_TRACK_TEXT_OVERLAY
- (trackobject), self->priv->text);
+ if (ges_track_element_get_track (trackelement)->type ==
+ GES_TRACK_TYPE_VIDEO)
+ ges_track_text_overlay_set_text (GES_TRACK_TEXT_OVERLAY (trackelement),
+ self->priv->text);
- g_object_unref (GES_TRACK_OBJECT (tmp->data));
+ g_object_unref (GES_TRACK_ELEMENT (tmp->data));
}
- g_list_free (trackobjects);
+ g_list_free (trackelements);
}
/**
ges_overlay_text_clip_set_font_desc (GESTextOverlayClip * self,
const gchar * font_desc)
{
- GList *tmp, *trackobjects;
+ GList *tmp, *trackelements;
GESClip *object = (GESClip *) self;
GST_DEBUG ("self:%p, font_desc:%s", self, font_desc);
self->priv->font_desc = g_strdup (font_desc);
- trackobjects = ges_clip_get_track_objects (object);
- for (tmp = trackobjects; tmp; tmp = tmp->next) {
- GESTrackObject *trackobject = (GESTrackObject *) tmp->data;
+ trackelements = ges_clip_get_track_elements (object);
+ for (tmp = trackelements; tmp; tmp = tmp->next) {
+ GESTrackElement *trackelement = (GESTrackElement *) tmp->data;
- if (ges_track_object_get_track (trackobject)->type == GES_TRACK_TYPE_VIDEO)
+ if (ges_track_element_get_track (trackelement)->type ==
+ GES_TRACK_TYPE_VIDEO)
ges_track_text_overlay_set_font_desc (GES_TRACK_TEXT_OVERLAY
- (trackobject), self->priv->font_desc);
+ (trackelement), self->priv->font_desc);
- g_object_unref (GES_TRACK_OBJECT (tmp->data));
+ g_object_unref (GES_TRACK_ELEMENT (tmp->data));
}
- g_list_free (trackobjects);
+ g_list_free (trackelements);
}
ges_overlay_text_clip_set_halign (GESTextOverlayClip * self,
GESTextHAlign halign)
{
- GList *tmp, *trackobjects;
+ GList *tmp, *trackelements;
GESClip *object = (GESClip *) self;
GST_DEBUG ("self:%p, halign:%d", self, halign);
self->priv->halign = halign;
- trackobjects = ges_clip_get_track_objects (object);
- for (tmp = trackobjects; tmp; tmp = tmp->next) {
- GESTrackObject *trackobject = (GESTrackObject *) tmp->data;
+ trackelements = ges_clip_get_track_elements (object);
+ for (tmp = trackelements; tmp; tmp = tmp->next) {
+ GESTrackElement *trackelement = (GESTrackElement *) tmp->data;
- if (ges_track_object_get_track (trackobject)->type == GES_TRACK_TYPE_VIDEO)
+ if (ges_track_element_get_track (trackelement)->type ==
+ GES_TRACK_TYPE_VIDEO)
ges_track_text_overlay_set_halignment (GES_TRACK_TEXT_OVERLAY
- (trackobject), self->priv->halign);
+ (trackelement), self->priv->halign);
- g_object_unref (GES_TRACK_OBJECT (tmp->data));
+ g_object_unref (GES_TRACK_ELEMENT (tmp->data));
}
- g_list_free (trackobjects);
+ g_list_free (trackelements);
}
ges_overlay_text_clip_set_valign (GESTextOverlayClip * self,
GESTextVAlign valign)
{
- GList *tmp, *trackobjects;
+ GList *tmp, *trackelements;
GESClip *object = (GESClip *) self;
GST_DEBUG ("self:%p, valign:%d", self, valign);
self->priv->valign = valign;
- trackobjects = ges_clip_get_track_objects (object);
- for (tmp = trackobjects; tmp; tmp = tmp->next) {
- GESTrackObject *trackobject = (GESTrackObject *) tmp->data;
+ trackelements = ges_clip_get_track_elements (object);
+ for (tmp = trackelements; tmp; tmp = tmp->next) {
+ GESTrackElement *trackelement = (GESTrackElement *) tmp->data;
- if (ges_track_object_get_track (trackobject)->type == GES_TRACK_TYPE_VIDEO)
+ if (ges_track_element_get_track (trackelement)->type ==
+ GES_TRACK_TYPE_VIDEO)
ges_track_text_overlay_set_valignment (GES_TRACK_TEXT_OVERLAY
- (trackobject), self->priv->valign);
+ (trackelement), self->priv->valign);
- g_object_unref (GES_TRACK_OBJECT (tmp->data));
+ g_object_unref (GES_TRACK_ELEMENT (tmp->data));
}
- g_list_free (trackobjects);
+ g_list_free (trackelements);
}
void
ges_overlay_text_clip_set_color (GESTextOverlayClip * self, guint32 color)
{
- GList *tmp, *trackobjects;
+ GList *tmp, *trackelements;
GESClip *object = (GESClip *) self;
GST_DEBUG ("self:%p, color:%d", self, color);
self->priv->color = color;
- trackobjects = ges_clip_get_track_objects (object);
- for (tmp = trackobjects; tmp; tmp = tmp->next) {
- GESTrackObject *trackobject = (GESTrackObject *) tmp->data;
+ trackelements = ges_clip_get_track_elements (object);
+ for (tmp = trackelements; tmp; tmp = tmp->next) {
+ GESTrackElement *trackelement = (GESTrackElement *) tmp->data;
- if (ges_track_object_get_track (trackobject)->type == GES_TRACK_TYPE_VIDEO)
- ges_track_text_overlay_set_color (GES_TRACK_TEXT_OVERLAY
- (trackobject), self->priv->color);
+ if (ges_track_element_get_track (trackelement)->type ==
+ GES_TRACK_TYPE_VIDEO)
+ ges_track_text_overlay_set_color (GES_TRACK_TEXT_OVERLAY (trackelement),
+ self->priv->color);
- g_object_unref (GES_TRACK_OBJECT (tmp->data));
+ g_object_unref (GES_TRACK_ELEMENT (tmp->data));
}
- g_list_free (trackobjects);
+ g_list_free (trackelements);
}
/**
void
ges_overlay_text_clip_set_xpos (GESTextOverlayClip * self, gdouble position)
{
- GList *tmp, *trackobjects;
+ GList *tmp, *trackelements;
GESClip *object = (GESClip *) self;
GST_DEBUG ("self:%p, xpos:%f", self, position);
self->priv->xpos = position;
- trackobjects = ges_clip_get_track_objects (object);
- for (tmp = trackobjects; tmp; tmp = tmp->next) {
- GESTrackObject *trackobject = (GESTrackObject *) tmp->data;
+ trackelements = ges_clip_get_track_elements (object);
+ for (tmp = trackelements; tmp; tmp = tmp->next) {
+ GESTrackElement *trackelement = (GESTrackElement *) tmp->data;
- if (ges_track_object_get_track (trackobject)->type == GES_TRACK_TYPE_VIDEO)
- ges_track_text_overlay_set_xpos (GES_TRACK_TEXT_OVERLAY
- (trackobject), self->priv->xpos);
+ if (ges_track_element_get_track (trackelement)->type ==
+ GES_TRACK_TYPE_VIDEO)
+ ges_track_text_overlay_set_xpos (GES_TRACK_TEXT_OVERLAY (trackelement),
+ self->priv->xpos);
- g_object_unref (GES_TRACK_OBJECT (tmp->data));
+ g_object_unref (GES_TRACK_ELEMENT (tmp->data));
}
- g_list_free (trackobjects);
+ g_list_free (trackelements);
}
/**
void
ges_overlay_text_clip_set_ypos (GESTextOverlayClip * self, gdouble position)
{
- GList *tmp, *trackobjects;
+ GList *tmp, *trackelements;
GESClip *object = (GESClip *) self;
GST_DEBUG ("self:%p, ypos:%f", self, position);
self->priv->ypos = position;
- trackobjects = ges_clip_get_track_objects (object);
- for (tmp = trackobjects; tmp; tmp = tmp->next) {
- GESTrackObject *trackobject = (GESTrackObject *) tmp->data;
+ trackelements = ges_clip_get_track_elements (object);
+ for (tmp = trackelements; tmp; tmp = tmp->next) {
+ GESTrackElement *trackelement = (GESTrackElement *) tmp->data;
- if (ges_track_object_get_track (trackobject)->type == GES_TRACK_TYPE_VIDEO)
- ges_track_text_overlay_set_ypos (GES_TRACK_TEXT_OVERLAY
- (trackobject), self->priv->ypos);
+ if (ges_track_element_get_track (trackelement)->type ==
+ GES_TRACK_TYPE_VIDEO)
+ ges_track_text_overlay_set_ypos (GES_TRACK_TEXT_OVERLAY (trackelement),
+ self->priv->ypos);
- g_object_unref (GES_TRACK_OBJECT (tmp->data));
+ g_object_unref (GES_TRACK_ELEMENT (tmp->data));
}
- g_list_free (trackobjects);
+ g_list_free (trackelements);
}
/**
return self->priv->ypos;
}
-static GESTrackObject *
-ges_overlay_text_clip_create_track_object (GESClip * obj, GESTrackType type)
+static GESTrackElement *
+ges_overlay_text_clip_create_track_element (GESClip * obj, GESTrackType type)
{
GESTextOverlayClipPrivate *priv = GES_OVERLAY_TEXT_CLIP (obj)->priv;
- GESTrackObject *res = NULL;
+ GESTrackElement *res = NULL;
GST_DEBUG ("Creating a GESTrackOverlay");
if (type == GES_TRACK_TYPE_VIDEO) {
- res = (GESTrackObject *) ges_track_text_overlay_new ();
+ res = (GESTrackElement *) ges_track_text_overlay_new ();
GST_DEBUG ("Setting text property");
ges_track_text_overlay_set_text ((GESTrackTextOverlay *) res, priv->text);
ges_track_text_overlay_set_font_desc ((GESTrackTextOverlay *) res,
* An object can only be added to one layer.
*
* Calling this method will construct and properly set all the media related
- * elements on @object. If you need to know when those objects (actually #GESTrackObject)
+ * elements on @object. If you need to know when those objects (actually #GESTrackElement)
* are constructed, you should connect to the object::track-object-added signal which
* is emited right after those elements are ready to be used.
*
typedef struct _MoveContext MoveContext;
static GPtrArray *select_tracks_for_object_default (GESTimeline * timeline,
- GESClip * clip, GESTrackObject * tr_obj, gpointer user_data);
+ GESClip * clip, GESTrackElement * tr_obj, gpointer user_data);
static inline void init_movecontext (MoveContext * mv_ctx, gboolean first_init);
static void ges_extractable_interface_init (GESExtractableInterface * iface);
static void ges_meta_container_interface_init
GSequenceIter *iter_by_layer;
GESTimelineLayer *layer;
- GESTrackObject *tckobj;
+ GESTrackElement *trackelement;
} TrackObjIters;
static void
GESEditMode mode;
/* Ripple and Roll Objects */
- GList *moving_tckobjs;
+ GList *moving_trackelements;
/* We use it as a set of Clip to move between layers */
GHashTable *moving_clips;
gboolean needs_move_ctx;
/* Last snapping properties */
- GESTrackObject *last_snaped1;
- GESTrackObject *last_snaped2;
+ GESTrackElement *last_snaped1;
+ GESTrackElement *last_snaped2;
GstClockTime *last_snap_ts;
};
GHashTable *by_object; /* {timecode: TrackSource} */
GHashTable *obj_iters; /* {TrackSource: TrackObjIters} */
GSequence *starts_ends; /* Sorted list of starts/ends */
- /* We keep 1 reference to our trackobject here */
+ /* We keep 1 reference to our trackelement here */
GSequence *tracksources; /* TrackSource-s sorted by start/priorities */
GList *priv_tracks;
/* FIXME: We should definitly offer an API over this,
- * probably through a ges_timeline_layer_get_track_objects () method */
- GHashTable *by_layer; /* {layer: GSequence of TrackObject by start/priorities} */
+ * probably through a ges_timeline_layer_get_track_elements () method */
+ GHashTable *by_layer; /* {layer: GSequence of TrackElement by start/priorities} */
/* The set of auto_transitions we control, currently the key is
* pointerToPreviousiTrackObjAdresspointerToNextTrackObjAdress as a string,
g_hash_table_unref (priv->obj_iters);
g_sequence_free (priv->starts_ends);
g_sequence_free (priv->tracksources);
- g_list_free (priv->movecontext.moving_tckobjs);
+ g_list_free (priv->movecontext.moving_trackelements);
g_hash_table_unref (priv->movecontext.moving_clips);
g_hash_table_unref (priv->auto_transitions);
/**
* GESTimeline::track-objects-snapping:
* @timeline: the #GESTimeline
- * @obj1: the first #GESTrackObject that was snapping.
- * @obj2: the second #GESTrackObject that was snapping.
+ * @obj1: the first #GESTrackElement that was snapping.
+ * @obj2: the second #GESTrackElement that was snapping.
* @position: the position where the two objects finally snapping.
*
- * Will be emitted when the 2 #GESTrackObject first snapped
+ * Will be emitted when the 2 #GESTrackElement first snapped
*
* Since: 0.10.XX
*/
ges_timeline_signals[SNAPING_STARTED] =
g_signal_new ("snapping-started", G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST, 0, NULL, NULL, NULL,
- G_TYPE_NONE, 3, GES_TYPE_TRACK_OBJECT, GES_TYPE_TRACK_OBJECT,
+ G_TYPE_NONE, 3, GES_TYPE_TRACK_ELEMENT, GES_TYPE_TRACK_ELEMENT,
G_TYPE_UINT64);
/**
* GESTimeline::snapping-end:
* @timeline: the #GESTimeline
- * @obj1: the first #GESTrackObject that was snapping.
- * @obj2: the second #GESTrackObject that was snapping.
+ * @obj1: the first #GESTrackElement that was snapping.
+ * @obj2: the second #GESTrackElement that was snapping.
* @position: the position where the two objects finally snapping.
*
- * Will be emitted when the 2 #GESTrackObject ended to snap
+ * Will be emitted when the 2 #GESTrackElement ended to snap
*
* Since: 0.10.XX
*/
ges_timeline_signals[SNAPING_ENDED] =
g_signal_new ("snapping-ended", G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST, 0, NULL, NULL, NULL,
- G_TYPE_NONE, 3, GES_TYPE_TRACK_OBJECT, GES_TYPE_TRACK_OBJECT,
+ G_TYPE_NONE, 3, GES_TYPE_TRACK_ELEMENT, GES_TYPE_TRACK_ELEMENT,
G_TYPE_UINT64);
/**
* GESTimeline::select-tracks-for-object:
* @timeline: the #GESTimeline
* @clip: The #GESClip on which @track-object will land
- * @track-object: The #GESTrackObject for which to choose the tracks it should land into
+ * @track-object: The #GESTrackElement for which to choose the tracks it should land into
*
* Returns: (transfer full) (element-type GESTrack): a #GPtrArray of #GESTrack-s where that object should be added
*
ges_timeline_signals[SELECT_TRACKS_FOR_OBJECT] =
g_signal_new ("select-tracks-for-object", G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST, 0, _gst_array_accumulator, NULL, NULL,
- G_TYPE_PTR_ARRAY, 2, GES_TYPE_CLIP, GES_TYPE_TRACK_OBJECT);
+ G_TYPE_PTR_ARRAY, 2, GES_TYPE_CLIP, GES_TYPE_TRACK_ELEMENT);
}
static void
}
static void
-sort_track_objects (GESTimeline * timeline, TrackObjIters * iters)
+sort_track_elements (GESTimeline * timeline, TrackObjIters * iters)
{
g_sequence_sort_changed (iters->iter_obj,
(GCompareDataFunc) element_start_compare, NULL);
static inline void
sort_starts_ends_end (GESTimeline * timeline, TrackObjIters * iters)
{
- GESTimelineElement *obj = GES_TIMELINE_ELEMENT (iters->tckobj);
+ GESTimelineElement *obj = GES_TIMELINE_ELEMENT (iters->trackelement);
GESTimelinePrivate *priv = timeline->priv;
guint64 *end = g_hash_table_lookup (priv->by_end, obj);
static inline void
sort_starts_ends_start (GESTimeline * timeline, TrackObjIters * iters)
{
- GESTimelineElement *obj = GES_TIMELINE_ELEMENT (iters->tckobj);
+ GESTimelineElement *obj = GES_TIMELINE_ELEMENT (iters->trackelement);
GESTimelinePrivate *priv = timeline->priv;
guint64 *start = g_hash_table_lookup (priv->by_start, obj);
}
static GESAutoTransition *
-create_transition (GESTimeline * timeline, GESTrackObject * previous,
- GESTrackObject * next, GESClip * transition,
+create_transition (GESTimeline * timeline, GESTrackElement * previous,
+ GESTrackElement * next, GESClip * transition,
GESTimelineLayer * layer, guint64 start, guint64 duration)
{
- GList *tckobjs;
+ GList *trackelements;
GESAsset *asset;
GESAutoTransition *auto_transition;
asset = ges_asset_request (GES_TYPE_TRANSITION_CLIP, "crossfade", NULL);
transition =
ges_timeline_layer_add_asset (layer, asset, start, 0, duration, 1,
- ges_track_object_get_track_type (next));
+ ges_track_element_get_track_type (next));
} else {
GST_DEBUG_OBJECT (timeline,
"Reusing already existing transition: %" GST_PTR_FORMAT, transition);
}
- /* We know there is only 1 TrackObject */
- tckobjs = ges_clip_get_track_objects (transition);
- auto_transition = ges_auto_transition_new (tckobjs->data, previous, next);
- g_list_free_full (tckobjs, gst_object_unref);
+ /* We know there is only 1 TrackElement */
+ trackelements = ges_clip_get_track_elements (transition);
+ auto_transition =
+ ges_auto_transition_new (trackelements->data, previous, next);
+ g_list_free_full (trackelements, gst_object_unref);
g_signal_connect (auto_transition, "destroy-me",
G_CALLBACK (_destroy_auto_transition_cb), timeline);
}
typedef GESAutoTransition *(*GetAutoTransitionFunc) (GESTimeline * timeline,
- GESTimelineLayer * layer, GESTrack * track, GESTrackObject * previous,
- GESTrackObject * next, GstClockTime transition_duration);
+ GESTimelineLayer * layer, GESTrack * track, GESTrackElement * previous,
+ GESTrackElement * next, GstClockTime transition_duration);
static GESAutoTransition *
_find_transition_from_auto_transitions (GESTimeline * timeline,
- GESTimelineLayer * layer, GESTrack * track, GESTrackObject * prev,
- GESTrackObject * next, GstClockTime transition_duration)
+ GESTimelineLayer * layer, GESTrack * track, GESTrackElement * prev,
+ GESTrackElement * next, GstClockTime transition_duration)
{
GESAutoTransition *auto_transition;
static GESAutoTransition *
_create_auto_transition_from_transitions (GESTimeline * timeline,
- GESTimelineLayer * layer, GESTrack * track, GESTrackObject * prev,
- GESTrackObject * next, GstClockTime transition_duration)
+ GESTimelineLayer * layer, GESTrack * track, GESTrackElement * prev,
+ GESTrackElement * next, GstClockTime transition_duration)
{
GSequenceIter *tmp_iter;
GSequence *by_layer_sequence;
for (tmp_iter = g_sequence_get_begin_iter (by_layer_sequence);
tmp_iter && !g_sequence_iter_is_end (tmp_iter);
tmp_iter = g_sequence_iter_next (tmp_iter)) {
- GESTrackObject *maybe_transition = g_sequence_get (tmp_iter);
+ GESTrackElement *maybe_transition = g_sequence_get (tmp_iter);
- if (ges_track_object_get_track (maybe_transition) != track)
+ if (ges_track_element_get_track (maybe_transition) != track)
continue;
if (_START (maybe_transition) > _START (next))
else if (GES_IS_TRACK_TRANSITION (maybe_transition))
/* Use that transition */
/* TODO We should make sure that the transition contains only
- * TrackObject-s in @track and if it is not the case properly unlink the
+ * TrackElement-s in @track and if it is not the case properly unlink the
* object to use it */
return create_transition (timeline, prev, next,
- ges_track_object_get_clip (maybe_transition), layer,
+ ges_track_element_get_clip (maybe_transition), layer,
_START (next), transition_duration);
}
* track */
static void
_create_transitions_on_layer (GESTimeline * timeline, GESTimelineLayer * layer,
- GESTrack * track, GESTrackObject * initiating_obj,
+ GESTrack * track, GESTrackElement * initiating_obj,
GetAutoTransitionFunc get_auto_transition)
{
guint32 layer_prio;
GESAutoTransition *transition;
GESTrack *ctrack = track;
- GList *entered = NULL; /* List of TrackObject for wich we walk through the
+ GList *entered = NULL; /* List of TrackElement for wich we walk through the
* "start" but not the "end" in the starts_ends list */
GESTimelinePrivate *priv = timeline->priv;
iter = g_sequence_iter_next (iter)) {
GList *tmp;
guint *start_or_end = g_sequence_get (iter);
- GESTrackObject *next = g_hash_table_lookup (timeline->priv->by_object,
+ GESTrackElement *next = g_hash_table_lookup (timeline->priv->by_object,
start_or_end);
/* Only object that are in that layer and track */
if ((_PRIORITY (next) / LAYER_HEIGHT) != layer_prio ||
- (track && track != ges_track_object_get_track (next)))
+ (track && track != ges_track_element_get_track (next)))
continue;
if (track == NULL)
- ctrack = ges_track_object_get_track (next);
+ ctrack = ges_track_element_get_track (next);
if (start_or_end == g_hash_table_lookup (priv->by_end, next)) {
if (initiating_obj == next) {
for (tmp = entered; tmp; tmp = tmp->next) {
gint64 transition_duration;
- GESTrackObject *prev = tmp->data;
+ GESTrackElement *prev = tmp->data;
- if (ctrack != ges_track_object_get_track (prev))
+ if (ctrack != ges_track_element_get_track (prev))
continue;
transition_duration = (_START (prev) + _DURATION (prev)) - _START (next);
/* @tck_obj must be a GESTrackSource */
static void
-create_transitions (GESTimeline * timeline, GESTrackObject * tck_obj)
+create_transitions (GESTimeline * timeline, GESTrackElement * tck_obj)
{
GESTrack *track;
GList *layer_node;
GST_DEBUG_OBJECT (timeline, "Creating transitions around %p", tck_obj);
- track = ges_track_object_get_track (tck_obj);
+ track = ges_track_element_get_track (tck_obj);
layer_node = g_list_find_custom (timeline->layers,
GINT_TO_POINTER (_PRIORITY (tck_obj) / LAYER_HEIGHT),
(GCompareFunc) find_layer_by_prio);
if (G_UNLIKELY (first_init))
mv_ctx->moving_clips = g_hash_table_new (g_direct_hash, g_direct_equal);
- mv_ctx->moving_tckobjs = NULL;
+ mv_ctx->moving_trackelements = NULL;
mv_ctx->max_trim_pos = G_MAXUINT64;
mv_ctx->min_move_layer = G_MAXUINT;
mv_ctx->max_layer_prio = 0;
static inline void
clean_movecontext (MoveContext * mv_ctx)
{
- g_list_free (mv_ctx->moving_tckobjs);
+ g_list_free (mv_ctx->moving_trackelements);
g_hash_table_remove_all (mv_ctx->moving_clips);
init_movecontext (mv_ctx, FALSE);
}
static void
-stop_tracking_track_object (GESTimeline * timeline, GESTrackObject * tckobj)
+stop_tracking_track_element (GESTimeline * timeline,
+ GESTrackElement * trackelement)
{
guint64 *start, *end;
TrackObjIters *iters;
GESTimelinePrivate *priv = timeline->priv;
- iters = g_hash_table_lookup (priv->obj_iters, tckobj);
+ iters = g_hash_table_lookup (priv->obj_iters, trackelement);
if (G_LIKELY (iters->iter_by_layer)) {
g_sequence_remove (iters->iter_by_layer);
} else {
- GST_WARNING_OBJECT (timeline, "TrackObject %p was in no layer", tckobj);
+ GST_WARNING_OBJECT (timeline, "TrackElement %p was in no layer",
+ trackelement);
}
- if (GES_IS_TRACK_SOURCE (tckobj)) {
- start = g_hash_table_lookup (priv->by_start, tckobj);
- end = g_hash_table_lookup (priv->by_end, tckobj);
+ if (GES_IS_TRACK_SOURCE (trackelement)) {
+ start = g_hash_table_lookup (priv->by_start, trackelement);
+ end = g_hash_table_lookup (priv->by_end, trackelement);
- g_hash_table_remove (priv->by_start, tckobj);
- g_hash_table_remove (priv->by_end, tckobj);
+ g_hash_table_remove (priv->by_start, trackelement);
+ g_hash_table_remove (priv->by_end, trackelement);
g_hash_table_remove (priv->by_object, end);
g_hash_table_remove (priv->by_object, start);
g_sequence_remove (iters->iter_start);
g_sequence_remove (iters->iter_obj);
timeline_update_duration (timeline);
}
- g_hash_table_remove (priv->obj_iters, tckobj);
+ g_hash_table_remove (priv->obj_iters, trackelement);
}
static void
-start_tracking_track_object (GESTimeline * timeline, GESTrackObject * tckobj)
+start_tracking_track_element (GESTimeline * timeline,
+ GESTrackElement * trackelement)
{
guint64 *pstart, *pend;
GSequence *by_layer_sequence;
TrackObjIters *iters;
GESTimelinePrivate *priv = timeline->priv;
- guint layer_prio = _PRIORITY (tckobj) / LAYER_HEIGHT;
+ guint layer_prio = _PRIORITY (trackelement) / LAYER_HEIGHT;
GList *layer_node = g_list_find_custom (timeline->layers,
GINT_TO_POINTER (layer_prio), (GCompareFunc) find_layer_by_prio);
GESTimelineLayer *layer = layer_node ? layer_node->data : NULL;
iters = g_slice_new0 (TrackObjIters);
- /* We add all TrackObject to obj_iters as we always follow them
+ /* We add all TrackElement to obj_iters as we always follow them
* in the by_layer Sequences */
- g_hash_table_insert (priv->obj_iters, tckobj, iters);
+ g_hash_table_insert (priv->obj_iters, trackelement, iters);
/* Track all objects by layer */
if (G_UNLIKELY (layer == NULL)) {
- /* We handle the case where we have TrackObject that are in no layer by not
+ /* We handle the case where we have TrackElement that are in no layer by not
* tracking them
*
* FIXME: Check if we should rather try to track them in some sort of
- * dummy layer, or even refuse TrackObjects to be added in Tracks if
+ * dummy layer, or even refuse TrackElements to be added in Tracks if
* they land in no layer the timeline controls.
*/
- GST_ERROR_OBJECT (timeline, "Adding a TrackObject that lands in no layer "
+ GST_ERROR_OBJECT (timeline, "Adding a TrackElement that lands in no layer "
"we are controlling");
} else {
by_layer_sequence = g_hash_table_lookup (priv->by_layer, layer);
- iters->iter_by_layer = g_sequence_insert_sorted (by_layer_sequence, tckobj,
+ iters->iter_by_layer =
+ g_sequence_insert_sorted (by_layer_sequence, trackelement,
(GCompareDataFunc) element_start_compare, NULL);
iters->layer = layer;
}
- if (GES_IS_TRACK_SOURCE (tckobj)) {
+ if (GES_IS_TRACK_SOURCE (trackelement)) {
/* Track only sources for timeline edition and snapping */
pstart = g_malloc (sizeof (guint64));
pend = g_malloc (sizeof (guint64));
- *pstart = _START (tckobj);
- *pend = *pstart + _DURATION (tckobj);
+ *pstart = _START (trackelement);
+ *pend = *pstart + _DURATION (trackelement);
iters->iter_start = g_sequence_insert_sorted (priv->starts_ends, pstart,
(GCompareDataFunc) compare_uint64, NULL);
iters->iter_end = g_sequence_insert_sorted (priv->starts_ends, pend,
(GCompareDataFunc) compare_uint64, NULL);
iters->iter_obj =
- g_sequence_insert_sorted (priv->tracksources, g_object_ref (tckobj),
- (GCompareDataFunc) element_start_compare, NULL);
- iters->tckobj = tckobj;
+ g_sequence_insert_sorted (priv->tracksources,
+ g_object_ref (trackelement), (GCompareDataFunc) element_start_compare,
+ NULL);
+ iters->trackelement = trackelement;
- g_hash_table_insert (priv->by_start, tckobj, pstart);
- g_hash_table_insert (priv->by_object, pstart, tckobj);
- g_hash_table_insert (priv->by_end, tckobj, pend);
- g_hash_table_insert (priv->by_object, pend, tckobj);
+ g_hash_table_insert (priv->by_start, trackelement, pstart);
+ g_hash_table_insert (priv->by_object, pstart, trackelement);
+ g_hash_table_insert (priv->by_end, trackelement, pend);
+ g_hash_table_insert (priv->by_object, pend, trackelement);
timeline->priv->movecontext.needs_move_ctx = TRUE;
timeline_update_duration (timeline);
- create_transitions (timeline, tckobj);
+ create_transitions (timeline, trackelement);
}
}
static inline void
-ges_timeline_emit_snappig (GESTimeline * timeline, GESTrackObject * obj1,
+ges_timeline_emit_snappig (GESTimeline * timeline, GESTrackElement * obj1,
guint64 * timecode)
{
- GESTrackObject *obj2;
+ GESTrackElement *obj2;
MoveContext *mv_ctx = &timeline->priv->movecontext;
GstClockTime snap_time = timecode ? *timecode : 0;
GstClockTime last_snap_ts = mv_ctx->last_snap_ts ?
}
static guint64 *
-ges_timeline_snap_position (GESTimeline * timeline, GESTrackObject * trackobj,
- guint64 * current, guint64 timecode, gboolean emit)
+ges_timeline_snap_position (GESTimeline * timeline,
+ GESTrackElement * trackelement, guint64 * current, guint64 timecode,
+ gboolean emit)
{
GESTimelinePrivate *priv = timeline->priv;
GSequenceIter *iter, *prev_iter, *nxt_iter;
- GESTrackObject *tmp_tckobj;
+ GESTrackElement *tmp_trackelement;
GESClip *tmp_clip, *clip;
GstClockTime *last_snap_ts = priv->movecontext.last_snap_ts;
}
}
- clip = ges_track_object_get_clip (trackobj);
+ clip = ges_track_element_get_clip (trackelement);
iter = g_sequence_search (priv->starts_ends, &timecode,
(GCompareDataFunc) compare_uint64, NULL);
nxt_iter = iter;
while (!g_sequence_iter_is_end (nxt_iter)) {
next_tc = g_sequence_get (iter);
- tmp_tckobj = g_hash_table_lookup (timeline->priv->by_object, next_tc);
- tmp_clip = ges_track_object_get_clip (tmp_tckobj);
+ tmp_trackelement = g_hash_table_lookup (timeline->priv->by_object, next_tc);
+ tmp_clip = ges_track_element_get_clip (tmp_trackelement);
off = timecode > *next_tc ? timecode - *next_tc : *next_tc - timecode;
if (next_tc != current && off <= snap_distance && clip != tmp_clip) {
prev_iter = g_sequence_iter_prev (iter);
while (!g_sequence_iter_is_begin (prev_iter)) {
prev_tc = g_sequence_get (prev_iter);
- tmp_tckobj = g_hash_table_lookup (timeline->priv->by_object, prev_tc);
- tmp_clip = ges_track_object_get_clip (tmp_tckobj);
+ tmp_trackelement = g_hash_table_lookup (timeline->priv->by_object, prev_tc);
+ tmp_clip = ges_track_element_get_clip (tmp_trackelement);
off1 = timecode > *prev_tc ? timecode - *prev_tc : *prev_tc - timecode;
if (prev_tc != current && off1 < off && off1 <= snap_distance &&
if (emit) {
GstClockTime snap_time = ret ? *ret : GST_CLOCK_TIME_NONE;
- ges_timeline_emit_snappig (timeline, trackobj, ret);
+ ges_timeline_emit_snappig (timeline, trackelement, ret);
GST_DEBUG_OBJECT (timeline, "Snaping at %" GST_TIME_FORMAT,
GST_TIME_ARGS (snap_time));
}
static inline GESClip *
-add_moving_clip (MoveContext * mv_ctx, GESTrackObject * tckobj)
+add_moving_clip (MoveContext * mv_ctx, GESTrackElement * trackelement)
{
GESClip *clip;
GESTimelineLayer *layer;
guint layer_prio;
- clip = ges_track_object_get_clip (tckobj);
+ clip = ges_track_element_get_clip (trackelement);
/* Avoid recalculating */
if (!g_hash_table_lookup (mv_ctx->moving_clips, clip)) {
}
static gboolean
-ges_move_context_set_objects (GESTimeline * timeline, GESTrackObject * obj,
+ges_move_context_set_objects (GESTimeline * timeline, GESTrackElement * obj,
GESEdge edge)
{
TrackObjIters *iters;
- GESTrackObject *tmptckobj;
+ GESTrackElement *tmptrackelement;
guint64 start, end, tmpend;
- GSequenceIter *iter, *tckobj_iter;
+ GSequenceIter *iter, *trackelement_iter;
MoveContext *mv_ctx = &timeline->priv->movecontext;
iters = g_hash_table_lookup (timeline->priv->obj_iters, obj);
- tckobj_iter = iters->iter_obj;
+ trackelement_iter = iters->iter_obj;
switch (edge) {
case GES_EDGE_START:
/* set it properly in the context of "trimming" */
mv_ctx->max_trim_pos = 0;
start = _START (obj);
- if (g_sequence_iter_is_begin (tckobj_iter))
+ if (g_sequence_iter_is_begin (trackelement_iter))
break;
/* Look for the objects */
- for (iter = g_sequence_iter_prev (tckobj_iter);
+ for (iter = g_sequence_iter_prev (trackelement_iter);
iter && !g_sequence_iter_is_end (iter);
iter = g_sequence_iter_prev (iter)) {
- tmptckobj = GES_TRACK_OBJECT (g_sequence_get (iter));
- tmpend = _START (tmptckobj) + _DURATION (tmptckobj);
+ tmptrackelement = GES_TRACK_ELEMENT (g_sequence_get (iter));
+ tmpend = _START (tmptrackelement) + _DURATION (tmptrackelement);
if (tmpend <= start) {
- mv_ctx->max_trim_pos = MAX (mv_ctx->max_trim_pos, _START (tmptckobj));
- mv_ctx->moving_tckobjs =
- g_list_prepend (mv_ctx->moving_tckobjs, tmptckobj);
+ mv_ctx->max_trim_pos =
+ MAX (mv_ctx->max_trim_pos, _START (tmptrackelement));
+ mv_ctx->moving_trackelements =
+ g_list_prepend (mv_ctx->moving_trackelements, tmptrackelement);
}
if (g_sequence_iter_is_begin (iter))
mv_ctx->max_trim_pos = G_MAXUINT64;
/* Look for folowing objects */
- for (iter = g_sequence_iter_next (tckobj_iter);
+ for (iter = g_sequence_iter_next (trackelement_iter);
iter && !g_sequence_iter_is_end (iter);
iter = g_sequence_iter_next (iter)) {
- tmptckobj = GES_TRACK_OBJECT (g_sequence_get (iter));
+ tmptrackelement = GES_TRACK_ELEMENT (g_sequence_get (iter));
- if (_START (tmptckobj) >= end) {
- tmpend = _START (tmptckobj) + _DURATION (tmptckobj);
+ if (_START (tmptrackelement) >= end) {
+ tmpend = _START (tmptrackelement) + _DURATION (tmptrackelement);
mv_ctx->max_trim_pos = MIN (mv_ctx->max_trim_pos, tmpend);
- mv_ctx->moving_tckobjs =
- g_list_prepend (mv_ctx->moving_tckobjs, tmptckobj);
+ mv_ctx->moving_trackelements =
+ g_list_prepend (mv_ctx->moving_trackelements, tmptrackelement);
}
}
break;
}
static gboolean
-ges_timeline_set_moving_context (GESTimeline * timeline, GESTrackObject * obj,
+ges_timeline_set_moving_context (GESTimeline * timeline, GESTrackElement * obj,
GESEditMode mode, GESEdge edge, GList * layers)
{
- /* A TrackObject that could initiate movement for other object */
- GESTrackObject *editor_tckobj = NULL;
+ /* A TrackElement that could initiate movement for other object */
+ GESTrackElement *editor_trackelement = NULL;
MoveContext *mv_ctx = &timeline->priv->movecontext;
- GESClip *clip = ges_track_object_get_clip (obj);
+ GESClip *clip = ges_track_element_get_clip (obj);
/* Still in the same mv_ctx */
if ((mv_ctx->obj == clip && mv_ctx->mode == mode &&
if (GES_IS_TRACK_SOURCE (obj) == FALSE) {
GList *tmp;
- for (tmp = clip->trackobjects; tmp; tmp = tmp->next) {
+ for (tmp = clip->trackelements; tmp; tmp = tmp->next) {
if (GES_IS_TRACK_SOURCE (tmp->data)) {
- editor_tckobj = tmp->data;
+ editor_trackelement = tmp->data;
break;
}
}
} else {
- editor_tckobj = obj;
+ editor_trackelement = obj;
}
- if (editor_tckobj) {
+ if (editor_trackelement) {
switch (mode) {
case GES_EDIT_MODE_RIPPLE:
case GES_EDIT_MODE_ROLL:
- if (!(ges_move_context_set_objects (timeline, editor_tckobj, edge)))
+ if (!(ges_move_context_set_objects (timeline, editor_trackelement,
+ edge)))
return FALSE;
default:
break;
}
- add_moving_clip (&timeline->priv->movecontext, editor_tckobj);
+ add_moving_clip (&timeline->priv->movecontext, editor_trackelement);
} else {
/* We add the main object to the moving_clips set */
add_moving_clip (&timeline->priv->movecontext, obj);
}
gboolean
-ges_timeline_trim_object_simple (GESTimeline * timeline, GESTrackObject * obj,
+ges_timeline_trim_object_simple (GESTimeline * timeline, GESTrackElement * obj,
GList * layers, GESEdge edge, guint64 position, gboolean snapping)
{
guint64 nstart, start, inpoint, duration, max_duration, *snapped, *cur;
}
gboolean
-timeline_ripple_object (GESTimeline * timeline, GESTrackObject * obj,
+timeline_ripple_object (GESTimeline * timeline, GESTrackElement * obj,
GList * layers, GESEdge edge, guint64 position)
{
GList *tmp, *moved_clips = NULL;
- GESTrackObject *tckobj;
+ GESTrackElement *trackelement;
GESClip *clip;
guint64 duration, new_start, *snapped, *cur;
gint64 offset;
offset = position - _START (obj);
- for (tmp = mv_ctx->moving_tckobjs; tmp; tmp = tmp->next) {
- tckobj = GES_TRACK_OBJECT (tmp->data);
- new_start = _START (tckobj) + offset;
+ for (tmp = mv_ctx->moving_trackelements; tmp; tmp = tmp->next) {
+ trackelement = GES_TRACK_ELEMENT (tmp->data);
+ new_start = _START (trackelement) + offset;
- clip = add_moving_clip (mv_ctx, tckobj);
+ clip = add_moving_clip (mv_ctx, trackelement);
- if (ges_track_object_is_locked (tckobj) == TRUE) {
+ if (ges_track_element_is_locked (trackelement) == TRUE) {
/* Make sure not to move 2 times the same Clip */
if (g_list_find (moved_clips, clip) == NULL) {
- _set_start0 (GES_TIMELINE_ELEMENT (tckobj), new_start);
+ _set_start0 (GES_TIMELINE_ELEMENT (trackelement), new_start);
moved_clips = g_list_prepend (moved_clips, clip);
}
} else {
- _set_start0 (GES_TIMELINE_ELEMENT (tckobj), new_start);
+ _set_start0 (GES_TIMELINE_ELEMENT (trackelement), new_start);
}
}
g_list_free (moved_clips);
_set_duration0 (GES_TIMELINE_ELEMENT (obj), position - _START (obj));
offset = _DURATION (obj) - duration;
- for (tmp = mv_ctx->moving_tckobjs; tmp; tmp = tmp->next) {
- tckobj = GES_TRACK_OBJECT (tmp->data);
- new_start = _START (tckobj) + offset;
+ for (tmp = mv_ctx->moving_trackelements; tmp; tmp = tmp->next) {
+ trackelement = GES_TRACK_ELEMENT (tmp->data);
+ new_start = _START (trackelement) + offset;
- clip = add_moving_clip (mv_ctx, tckobj);
+ clip = add_moving_clip (mv_ctx, trackelement);
- if (ges_track_object_is_locked (tckobj) == TRUE) {
+ if (ges_track_element_is_locked (trackelement) == TRUE) {
/* Make sure not to move 2 times the same Clip */
if (g_list_find (moved_clips, clip) == NULL) {
- _set_start0 (GES_TIMELINE_ELEMENT (tckobj), new_start);
+ _set_start0 (GES_TIMELINE_ELEMENT (trackelement), new_start);
moved_clips = g_list_prepend (moved_clips, clip);
}
} else {
- _set_start0 (GES_TIMELINE_ELEMENT (tckobj), new_start);
+ _set_start0 (GES_TIMELINE_ELEMENT (trackelement), new_start);
}
}
}
gboolean
-timeline_slide_object (GESTimeline * timeline, GESTrackObject * obj,
+timeline_slide_object (GESTimeline * timeline, GESTrackElement * obj,
GList * layers, GESEdge edge, guint64 position)
{
}
gboolean
-timeline_trim_object (GESTimeline * timeline, GESTrackObject * object,
+timeline_trim_object (GESTimeline * timeline, GESTrackElement * object,
GList * layers, GESEdge edge, guint64 position)
{
gboolean ret = FALSE;
}
gboolean
-timeline_roll_object (GESTimeline * timeline, GESTrackObject * obj,
+timeline_roll_object (GESTimeline * timeline, GESTrackElement * obj,
GList * layers, GESEdge edge, guint64 position)
{
MoveContext *mv_ctx = &timeline->priv->movecontext;
position = _START (obj);
/* Send back changes to the neighbourhood */
- for (tmp = mv_ctx->moving_tckobjs; tmp; tmp = tmp->next) {
- GESTrackObject *tmptckobj = GES_TRACK_OBJECT (tmp->data);
+ for (tmp = mv_ctx->moving_trackelements; tmp; tmp = tmp->next) {
+ GESTrackElement *tmptrackelement = GES_TRACK_ELEMENT (tmp->data);
- tmpstart = _START (tmptckobj);
- tmpduration = _DURATION (tmptckobj);
+ tmpstart = _START (tmptrackelement);
+ tmpduration = _DURATION (tmptrackelement);
tmpend = tmpstart + tmpduration;
/* Check that the object should be resized at this position
* even if an error accurs, we keep doing our job */
if (tmpend == start) {
- ret &= ges_timeline_trim_object_simple (timeline, tmptckobj, NULL,
+ ret &=
+ ges_timeline_trim_object_simple (timeline, tmptrackelement, NULL,
GES_EDGE_END, position, FALSE);
break;
}
position = _START (obj) + _DURATION (obj);
/* Send back changes to the neighbourhood */
- for (tmp = mv_ctx->moving_tckobjs; tmp; tmp = tmp->next) {
- GESTrackObject *tmptckobj = GES_TRACK_OBJECT (tmp->data);
+ for (tmp = mv_ctx->moving_trackelements; tmp; tmp = tmp->next) {
+ GESTrackElement *tmptrackelement = GES_TRACK_ELEMENT (tmp->data);
- tmpstart = _START (tmptckobj);
- tmpduration = _DURATION (tmptckobj);
+ tmpstart = _START (tmptrackelement);
+ tmpduration = _DURATION (tmptrackelement);
tmpend = tmpstart + tmpduration;
/* Check that the object should be resized at this position
* even if an error accure, we keep doing our job */
if (end == tmpstart) {
- ret &= ges_timeline_trim_object_simple (timeline, tmptckobj, NULL,
+ ret &=
+ ges_timeline_trim_object_simple (timeline, tmptrackelement, NULL,
GES_EDGE_START, position, FALSE);
}
}
}
gboolean
-timeline_move_object (GESTimeline * timeline, GESTrackObject * object,
+timeline_move_object (GESTimeline * timeline, GESTrackElement * object,
GList * layers, GESEdge edge, guint64 position)
{
if (!ges_timeline_set_moving_context (timeline, object, GES_EDIT_MODE_RIPPLE,
gboolean
ges_timeline_move_object_simple (GESTimeline * timeline,
- GESTrackObject * object, GList * layers, GESEdge edge, guint64 position)
+ GESTrackElement * object, GList * layers, GESEdge edge, guint64 position)
{
guint64 *snap_end, *snap_st, *cur, off1, off2, end;
}
static void
-add_object_to_track (GESClip * object, GESTrackObject * track_object,
+add_object_to_track (GESClip * object, GESTrackElement * track_element,
GESTrack * track)
{
- if (!ges_clip_add_track_object (object, track_object)) {
+ if (!ges_clip_add_track_element (object, track_element)) {
GST_WARNING_OBJECT (object,
"Failed to add track object to timeline object");
- gst_object_unref (track_object);
+ gst_object_unref (track_element);
return;
}
- if (!ges_track_add_object (track, track_object)) {
+ if (!ges_track_add_object (track, track_element)) {
GST_WARNING_OBJECT (object, "Failed to add track object to track");
- ges_clip_release_track_object (object, track_object);
- gst_object_unref (track_object);
+ ges_clip_release_track_element (object, track_element);
+ gst_object_unref (track_element);
return;
}
}
static GPtrArray *
select_tracks_for_object_default (GESTimeline * timeline,
- GESClip * clip, GESTrackObject * tr_object, gpointer user_data)
+ GESClip * clip, GESTrackElement * tr_object, gpointer user_data)
{
GPtrArray *result;
GList *tmp;
for (tmp = timeline->tracks; tmp; tmp = tmp->next) {
GESTrack *track = GES_TRACK (tmp->data);
- if ((track->type & ges_track_object_get_track_type (tr_object))) {
+ if ((track->type & ges_track_element_get_track_type (tr_object))) {
gst_object_ref (track);
g_ptr_array_add (result, track);
}
gint i;
GPtrArray *tracks = NULL;
GESTrackType types, visited_type = GES_TRACK_TYPE_UNKNOWN;
- GList *tmp, *l, *track_objects;
+ GList *tmp, *l, *track_elements;
GST_DEBUG_OBJECT (timeline, "Creating %" GST_PTR_FORMAT
- " trackobjects and adding them to our tracks", object);
+ " trackelements and adding them to our tracks", object);
types = ges_clip_get_supported_formats (object);
if (track) {
if (((track->type & types) == 0 || (track->type & visited_type)))
continue;
- track_objects = ges_clip_create_track_objects (object, track->type);
- for (l = track_objects; l; l = l->next) {
+ track_elements = ges_clip_create_track_elements (object, track->type);
+ for (l = track_elements; l; l = l->next) {
GESTrack *tmp_track;
- GESTrackObject *track_object = l->data;
+ GESTrackElement *track_element = l->data;
- GST_DEBUG_OBJECT (timeline, "Got trackobject: %" GST_PTR_FORMAT
- "Asking to which track it should be added", track_object);
+ GST_DEBUG_OBJECT (timeline, "Got trackelement: %" GST_PTR_FORMAT
+ "Asking to which track it should be added", track_element);
g_signal_emit (G_OBJECT (timeline),
ges_timeline_signals[SELECT_TRACKS_FOR_OBJECT], 0, object,
- track_object, &tracks);
+ track_element, &tracks);
if (!tracks || tracks->len == 0) {
GST_DEBUG_OBJECT (timeline, "Got no Track to add %p (type %s)",
- track_object,
- ges_track_type_name (ges_track_object_get_track_type
- (track_object)));
- goto next_track_object;
+ track_element,
+ ges_track_type_name (ges_track_element_get_track_type
+ (track_element)));
+ goto next_track_element;
}
for (i = 0; i < tracks->len; i++) {
- GESTrackObject *track_object_copy;
+ GESTrackElement *track_element_copy;
tmp_track = g_ptr_array_index (tracks, i);
if (track && tmp_track != track) {
GST_LOG_OBJECT (timeline,
- "Not adding %" GST_PTR_FORMAT " to any track", track_object);
+ "Not adding %" GST_PTR_FORMAT " to any track", track_element);
continue;
}
- track_object_copy =
- GES_TRACK_OBJECT (ges_timeline_element_copy (GES_TIMELINE_ELEMENT
- (track_object), TRUE));
+ track_element_copy =
+ GES_TRACK_ELEMENT (ges_timeline_element_copy (GES_TIMELINE_ELEMENT
+ (track_element), TRUE));
GST_LOG_OBJECT (timeline, "Trying to add %p to track %p",
- track_object_copy, tmp_track);
- add_object_to_track (object, track_object_copy, tmp_track);
+ track_element_copy, tmp_track);
+ add_object_to_track (object, track_element_copy, tmp_track);
gst_object_unref (tmp_track);
}
- next_track_object:
+ next_track_element:
if (tracks) {
g_ptr_array_unref (tracks);
tracks = NULL;
}
- gst_object_unref (track_object);
+ gst_object_unref (track_element);
}
}
}
layer_object_removed_cb (GESTimelineLayer * layer, GESClip * object,
GESTimeline * timeline)
{
- GList *trackobjects, *tmp;
+ GList *trackelements, *tmp;
if (ges_clip_is_moving_from_layer (object)) {
GST_DEBUG ("Clip %p is moving from a layer to another, not doing"
/* Go over the object's track objects and figure out which one belongs to
* the list of tracks we control */
- trackobjects = ges_clip_get_track_objects (object);
- for (tmp = trackobjects; tmp; tmp = tmp->next) {
- GESTrackObject *trobj = (GESTrackObject *) tmp->data;
+ trackelements = ges_clip_get_track_elements (object);
+ for (tmp = trackelements; tmp; tmp = tmp->next) {
+ GESTrackElement *trobj = (GESTrackElement *) tmp->data;
- GST_DEBUG_OBJECT (timeline, "Trying to remove TrackObject %p", trobj);
+ GST_DEBUG_OBJECT (timeline, "Trying to remove TrackElement %p", trobj);
if (G_LIKELY (g_list_find_custom (timeline->priv->priv_tracks,
- ges_track_object_get_track (trobj),
+ ges_track_element_get_track (trobj),
(GCompareFunc) custom_find_track))) {
GST_DEBUG ("Belongs to one of the tracks we control");
- ges_track_remove_object (ges_track_object_get_track (trobj), trobj);
- ges_clip_release_track_object (object, trobj);
+ ges_track_remove_object (ges_track_element_get_track (trobj), trobj);
+ ges_clip_release_track_element (object, trobj);
}
- /* removing the reference added by _get_track_objects() */
+ /* removing the reference added by _get_track_elements() */
g_object_unref (trobj);
}
- g_list_free (trackobjects);
+ g_list_free (trackelements);
GST_DEBUG ("Done");
}
static void
-trackobj_start_changed_cb (GESTrackObject * child,
+trackelement_start_changed_cb (GESTrackElement * child,
GParamSpec * arg G_GNUC_UNUSED, GESTimeline * timeline)
{
GESTimelinePrivate *priv = timeline->priv;
(GCompareDataFunc) element_start_compare, NULL);
if (GES_IS_TRACK_SOURCE (child)) {
- sort_track_objects (timeline, iters);
+ sort_track_elements (timeline, iters);
sort_starts_ends_start (timeline, iters);
sort_starts_ends_end (timeline, iters);
/* If the timeline is set to snap objects together, we
- * are sure that all movement of TrackObject-s are done within
+ * are sure that all movement of TrackElement-s are done within
* the moving context, so we do not need to recalculate the
* move context as often */
if (timeline->priv->movecontext.ignore_needs_ctx &&
}
static void
-trackobj_priority_changed_cb (GESTrackObject * child,
+trackelement_priority_changed_cb (GESTrackElement * child,
GParamSpec * arg G_GNUC_UNUSED, GESTimeline * timeline)
{
GESTimelinePrivate *priv = timeline->priv;
if (G_UNLIKELY (layer == NULL)) {
GST_ERROR_OBJECT (timeline,
- "Changing a TrackObject prio, which would not "
+ "Changing a TrackElement prio, which would not "
"land in no layer we are controlling");
g_sequence_remove (iters->iter_by_layer);
iters->iter_by_layer = NULL;
}
if (GES_IS_TRACK_SOURCE (child))
- sort_track_objects (timeline, iters);
+ sort_track_elements (timeline, iters);
}
static void
-trackobj_duration_changed_cb (GESTrackObject * child,
+trackelement_duration_changed_cb (GESTrackElement * child,
GParamSpec * arg G_GNUC_UNUSED, GESTimeline * timeline)
{
GESTimelinePrivate *priv = timeline->priv;
sort_starts_ends_end (timeline, iters);
/* If the timeline is set to snap objects together, we
- * are sure that all movement of TrackObject-s are done within
+ * are sure that all movement of TrackElement-s are done within
* the moving context, so we do not need to recalculate the
* move context as often */
if (timeline->priv->movecontext.ignore_needs_ctx &&
}
static void
-track_object_added_cb (GESTrack * track, GESTrackObject * object,
+track_element_added_cb (GESTrack * track, GESTrackElement * object,
GESTimeline * timeline)
{
/* Auto transition should be updated before we receive the signal */
- g_signal_connect_after (GES_TRACK_OBJECT (object), "notify::start",
- G_CALLBACK (trackobj_start_changed_cb), timeline);
- g_signal_connect_after (GES_TRACK_OBJECT (object), "notify::duration",
- G_CALLBACK (trackobj_duration_changed_cb), timeline);
- g_signal_connect_after (GES_TRACK_OBJECT (object), "notify::priority",
- G_CALLBACK (trackobj_priority_changed_cb), timeline);
+ g_signal_connect_after (GES_TRACK_ELEMENT (object), "notify::start",
+ G_CALLBACK (trackelement_start_changed_cb), timeline);
+ g_signal_connect_after (GES_TRACK_ELEMENT (object), "notify::duration",
+ G_CALLBACK (trackelement_duration_changed_cb), timeline);
+ g_signal_connect_after (GES_TRACK_ELEMENT (object), "notify::priority",
+ G_CALLBACK (trackelement_priority_changed_cb), timeline);
- start_tracking_track_object (timeline, object);
+ start_tracking_track_element (timeline, object);
}
static void
-track_object_removed_cb (GESTrack * track, GESTrackObject * object,
+track_element_removed_cb (GESTrack * track, GESTrackElement * object,
GESTimeline * timeline)
{
}
/* Disconnect all signal handlers */
- g_signal_handlers_disconnect_by_func (object, trackobj_start_changed_cb,
- NULL);
- g_signal_handlers_disconnect_by_func (object, trackobj_duration_changed_cb,
- NULL);
- g_signal_handlers_disconnect_by_func (object, trackobj_priority_changed_cb,
+ g_signal_handlers_disconnect_by_func (object, trackelement_start_changed_cb,
NULL);
+ g_signal_handlers_disconnect_by_func (object,
+ trackelement_duration_changed_cb, NULL);
+ g_signal_handlers_disconnect_by_func (object,
+ trackelement_priority_changed_cb, NULL);
- stop_tracking_track_object (timeline, object);
+ stop_tracking_track_element (timeline, object);
}
static void
/* We connect to the object for the timeline editing mode management */
g_signal_connect (G_OBJECT (track), "track-object-added",
- G_CALLBACK (track_object_added_cb), timeline);
+ G_CALLBACK (track_element_added_cb), timeline);
g_signal_connect (G_OBJECT (track), "track-object-removed",
- G_CALLBACK (track_object_removed_cb), timeline);
+ G_CALLBACK (track_element_removed_cb), timeline);
for (tmp = timeline->layers; tmp; tmp = tmp->next) {
GList *objects, *obj;
/* Remove pad-added/-removed handlers */
g_signal_handlers_disconnect_by_func (track, pad_added_cb, tr_priv);
g_signal_handlers_disconnect_by_func (track, pad_removed_cb, tr_priv);
- g_signal_handlers_disconnect_by_func (track, track_object_added_cb, timeline);
- g_signal_handlers_disconnect_by_func (track, track_object_removed_cb,
+ g_signal_handlers_disconnect_by_func (track, track_element_added_cb,
+ timeline);
+ g_signal_handlers_disconnect_by_func (track, track_element_removed_cb,
timeline);
/* Signal track removal to all layers/objects */
#include "ges-internal.h"
#include "ges-title-clip.h"
#include "ges-source-clip.h"
-#include "ges-track-object.h"
+#include "ges-track-element.h"
#include "ges-track-title-source.h"
#include <string.h>
PROP_YPOS,
};
-static GESTrackObject
- * ges_title_clip_create_track_object (GESClip * obj, GESTrackType type);
+static GESTrackElement
+ * ges_title_clip_create_track_element (GESClip * obj, GESTrackType type);
static void
-ges_title_clip_track_object_added (GESClip * obj, GESTrackObject * tckobj);
-static void
-ges_title_clip_track_object_released (GESClip * obj, GESTrackObject * tckobj);
+ges_title_clip_track_element_added (GESClip * obj,
+ GESTrackElement * trackelement);
+static void ges_title_clip_track_element_released (GESClip * obj,
+ GESTrackElement * trackelement);
static void
ges_title_clip_get_property (GObject * object, guint property_id,
g_param_spec_boolean ("mute", "Mute", "Mute audio track",
FALSE, G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
- timobj_class->create_track_object = ges_title_clip_create_track_object;
+ timobj_class->create_track_element = ges_title_clip_create_track_element;
timobj_class->need_fill_track = FALSE;
- timobj_class->track_object_added = ges_title_clip_track_object_added;
- timobj_class->track_object_released = ges_title_clip_track_object_released;
+ timobj_class->track_element_added = ges_title_clip_track_element_added;
+ timobj_class->track_element_released = ges_title_clip_track_element_released;
/**
* GESTitleClip:color:
void
ges_title_clip_set_mute (GESTitleClip * self, gboolean mute)
{
- GList *tmp, *trackobjects;
+ GList *tmp, *trackelements;
GESClip *object = (GESClip *) self;
GST_DEBUG_OBJECT (self, "mute:%d", mute);
self->priv->mute = mute;
/* Go over tracked objects, and update 'active' status on all audio objects */
- /* FIXME : We need a much less crack way to find the trackobject to change */
- trackobjects = ges_clip_get_track_objects (object);
- for (tmp = trackobjects; tmp; tmp = tmp->next) {
- GESTrackObject *trackobject = (GESTrackObject *) tmp->data;
+ /* FIXME : We need a much less crack way to find the trackelement to change */
+ trackelements = ges_clip_get_track_elements (object);
+ for (tmp = trackelements; tmp; tmp = tmp->next) {
+ GESTrackElement *trackelement = (GESTrackElement *) tmp->data;
- if (ges_track_object_get_track (trackobject)->type == GES_TRACK_TYPE_AUDIO)
- ges_track_object_set_active (trackobject, !mute);
+ if (ges_track_element_get_track (trackelement)->type ==
+ GES_TRACK_TYPE_AUDIO)
+ ges_track_element_set_active (trackelement, !mute);
- g_object_unref (GES_TRACK_OBJECT (tmp->data));
+ g_object_unref (GES_TRACK_ELEMENT (tmp->data));
}
- g_list_free (trackobjects);
+ g_list_free (trackelements);
}
/**
}
static void
-ges_title_clip_track_object_released (GESClip * obj, GESTrackObject * tckobj)
+ges_title_clip_track_element_released (GESClip * obj,
+ GESTrackElement * trackelement)
{
GESTitleClipPrivate *priv = GES_TITLE_CLIP (obj)->priv;
- /* If this is called, we should be sure the tckobj exists */
- if (GES_IS_TRACK_TITLE_SOURCE (tckobj)) {
- GST_DEBUG_OBJECT (obj, "%p released from %p", tckobj, obj);
- priv->track_titles = g_slist_remove (priv->track_titles, tckobj);
- g_object_unref (tckobj);
+ /* If this is called, we should be sure the trackelement exists */
+ if (GES_IS_TRACK_TITLE_SOURCE (trackelement)) {
+ GST_DEBUG_OBJECT (obj, "%p released from %p", trackelement, obj);
+ priv->track_titles = g_slist_remove (priv->track_titles, trackelement);
+ g_object_unref (trackelement);
}
}
static void
-ges_title_clip_track_object_added (GESClip * obj, GESTrackObject * tckobj)
+ges_title_clip_track_element_added (GESClip * obj,
+ GESTrackElement * trackelement)
{
GESTitleClipPrivate *priv = GES_TITLE_CLIP (obj)->priv;
- if (GES_IS_TRACK_TITLE_SOURCE (tckobj)) {
- GST_DEBUG_OBJECT (obj, "%p added to %p", tckobj, obj);
+ if (GES_IS_TRACK_TITLE_SOURCE (trackelement)) {
+ GST_DEBUG_OBJECT (obj, "%p added to %p", trackelement, obj);
priv->track_titles =
- g_slist_prepend (priv->track_titles, g_object_ref (tckobj));
+ g_slist_prepend (priv->track_titles, g_object_ref (trackelement));
}
}
-static GESTrackObject *
-ges_title_clip_create_track_object (GESClip * obj, GESTrackType type)
+static GESTrackElement *
+ges_title_clip_create_track_element (GESClip * obj, GESTrackType type)
{
GESTitleClipPrivate *priv = GES_TITLE_CLIP (obj)->priv;
- GESTrackObject *res = NULL;
+ GESTrackElement *res = NULL;
GST_DEBUG_OBJECT (obj, "a GESTrackTitleSource");
if (type == GES_TRACK_TYPE_VIDEO) {
- res = (GESTrackObject *) ges_track_title_source_new ();
+ res = (GESTrackElement *) ges_track_title_source_new ();
GST_DEBUG_OBJECT (obj, "text property");
ges_track_title_source_set_text ((GESTrackTitleSource *) res, priv->text);
ges_track_title_source_set_font_desc ((GESTrackTitleSource *) res,
*/
#include "ges-internal.h"
-#include "ges-track-object.h"
+#include "ges-track-element.h"
#include "ges-track-audio-test-source.h"
G_DEFINE_TYPE (GESTrackAudioTestSource, ges_track_audio_test_source,
static void ges_track_audio_test_source_set_property (GObject * object, guint
property_id, const GValue * value, GParamSpec * pspec);
-static GstElement *ges_track_audio_test_source_create_element (GESTrackObject *
+static GstElement *ges_track_audio_test_source_create_element (GESTrackElement *
self);
static void
ges_track_audio_test_source_class_init (GESTrackAudioTestSourceClass * klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
- GESTrackObjectClass *bg_class = GES_TRACK_OBJECT_CLASS (klass);
+ GESTrackElementClass *bg_class = GES_TRACK_ELEMENT_CLASS (klass);
g_type_class_add_private (klass, sizeof (GESTrackAudioTestSourcePrivate));
}
static GstElement *
-ges_track_audio_test_source_create_element (GESTrackObject * trksrc)
+ges_track_audio_test_source_create_element (GESTrackElement * trksrc)
{
GESTrackAudioTestSource *self;
GstElement *ret;
ges_track_audio_test_source_set_freq (GESTrackAudioTestSource * self,
gdouble freq)
{
- GstElement *element = ges_track_object_get_element (GES_TRACK_OBJECT (self));
+ GstElement *element =
+ ges_track_element_get_element (GES_TRACK_ELEMENT (self));
self->priv->freq = freq;
if (element)
ges_track_audio_test_source_set_volume (GESTrackAudioTestSource * self,
gdouble volume)
{
- GstElement *element = ges_track_object_get_element (GES_TRACK_OBJECT (self));
+ GstElement *element =
+ ges_track_element_get_element (GES_TRACK_ELEMENT (self));
self->priv->volume = volume;
if (element)
*/
#include "ges-internal.h"
-#include "ges-track-object.h"
+#include "ges-track-element.h"
#include "ges-track-audio-transition.h"
#include <gst/controller/gstdirectcontrolbinding.h>
#define fast_element_link(a,b) gst_element_link_pads_full((a),"src",(b),"sink",GST_PAD_LINK_CHECK_NOTHING)
static void
-ges_track_audio_transition_duration_changed (GESTrackObject * self, guint64);
+ges_track_audio_transition_duration_changed (GESTrackElement * self, guint64);
-static GstElement *ges_track_audio_transition_create_element (GESTrackObject
+static GstElement *ges_track_audio_transition_create_element (GESTrackElement
* self);
static void ges_track_audio_transition_dispose (GObject * object);
ges_track_audio_transition_class_init (GESTrackAudioTransitionClass * klass)
{
GObjectClass *object_class;
- GESTrackObjectClass *toclass;
+ GESTrackElementClass *toclass;
g_type_class_add_private (klass, sizeof (GESTrackAudioTransitionPrivate));
object_class = G_OBJECT_CLASS (klass);
- toclass = GES_TRACK_OBJECT_CLASS (klass);
+ toclass = GES_TRACK_ELEMENT_CLASS (klass);
object_class->get_property = ges_track_audio_transition_get_property;
object_class->set_property = ges_track_audio_transition_set_property;
}
static GstElement *
-ges_track_audio_transition_create_element (GESTrackObject * object)
+ges_track_audio_transition_create_element (GESTrackElement * object)
{
GESTrackAudioTransition *self;
GstElement *topbin, *iconva, *iconvb, *oconv;
}
static void
-ges_track_audio_transition_duration_changed (GESTrackObject * object,
+ges_track_audio_transition_duration_changed (GESTrackElement * object,
guint64 duration)
{
GESTrackAudioTransition *self;
- GstElement *gnlobj = ges_track_object_get_gnlobject (object);
+ GstElement *gnlobj = ges_track_element_get_gnlobject (object);
GstTimedValueControlSource *ta, *tb;
self = GES_TRACK_AUDIO_TRANSITION (object);
#include <string.h>
#include "ges-internal.h"
-#include "ges-track-object.h"
+#include "ges-track-element.h"
#include "ges-track-effect.h"
G_DEFINE_ABSTRACT_TYPE (GESTrackEffect, ges_track_effect,
GES_TYPE_TRACK_OPERATION);
-static GHashTable *ges_track_effect_get_props_hashtable (GESTrackObject * self);
+static GHashTable *ges_track_effect_get_props_hashtable (GESTrackElement *
+ self);
guint pspec_hash (gconstpointer key_spec);
static gboolean pspec_equal (gconstpointer key_spec_1,
gconstpointer key_spec_2);
static void
ges_track_effect_class_init (GESTrackEffectClass * klass)
{
- GESTrackObjectClass *obj_bg_class = GES_TRACK_OBJECT_CLASS (klass);
+ GESTrackElementClass *obj_bg_class = GES_TRACK_ELEMENT_CLASS (klass);
g_type_class_add_private (klass, sizeof (GESTrackEffectPrivate));
/* Virtual methods */
static GHashTable *
-ges_track_effect_get_props_hashtable (GESTrackObject * self)
+ges_track_effect_get_props_hashtable (GESTrackElement * self)
{
GValue item = { 0, };
GstIterator *it;
gboolean done = FALSE;
GHashTable *ret = NULL;
- element = ges_track_object_get_element (self);
+ element = ges_track_element_get_element (self);
if (!element) {
GST_DEBUG
("Can't build the property hashtable until the gnlobject is created");
--- /dev/null
+/* GStreamer Editing Services
+ * Copyright (C) 2009 Edward Hervey <edward.hervey@collabora.co.uk>
+ * 2009 Nokia Corporation
+ *
+ * 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:ges-track-element
+ * @short_description: Base Class for objects contained in a GESTrack
+ *
+ * #GESTrackElement is the Base Class for any object that can be contained in a
+ * #GESTrack.
+ *
+ * It contains the basic information as to the location of the object within
+ * its container, like the start position, the inpoint, the duration and the
+ * priority.
+ */
+
+#include "ges-internal.h"
+#include "ges-extractable.h"
+#include "ges-track-element.h"
+#include "ges-clip.h"
+#include "ges-meta-container.h"
+#include <gobject/gvaluecollector.h>
+
+G_DEFINE_ABSTRACT_TYPE (GESTrackElement, ges_track_element,
+ GES_TYPE_TIMELINE_ELEMENT);
+
+struct _GESTrackElementPrivate
+{
+ GESTrackType track_type;
+
+ /* These fields are only used before the gnlobject is available */
+ guint64 pending_start;
+ guint64 pending_inpoint;
+ guint64 pending_duration;
+ guint32 pending_priority;
+ gboolean pending_active;
+
+ GstElement *gnlobject; /* The GnlObject */
+ GstElement *element; /* The element contained in the gnlobject (can be NULL) */
+
+ /* We keep a link between properties name and elements internally
+ * The hashtable should look like
+ * {GParamaSpec ---> element,}*/
+ GHashTable *properties_hashtable;
+
+ GESClip *timelineobj;
+ GESTrack *track;
+
+ gboolean valid;
+
+ gboolean locked; /* If TRUE, then moves in sync with its controlling
+ * GESClip */
+};
+
+enum
+{
+ PROP_0,
+ PROP_ACTIVE,
+ PROP_LOCKED,
+ PROP_TRACK_TYPE,
+ PROP_TRACK,
+ PROP_LAST
+};
+
+static GParamSpec *properties[PROP_LAST];
+
+enum
+{
+ DEEP_NOTIFY,
+ LAST_SIGNAL
+};
+
+static guint ges_track_element_signals[LAST_SIGNAL] = { 0 };
+
+static GstElement *ges_track_element_create_gnl_object_func (GESTrackElement *
+ object);
+
+static void gnlobject_start_cb (GstElement * gnlobject, GParamSpec * arg
+ G_GNUC_UNUSED, GESTrackElement * obj);
+
+static void gnlobject_media_start_cb (GstElement * gnlobject, GParamSpec * arg
+ G_GNUC_UNUSED, GESTrackElement * obj);
+
+static void gnlobject_priority_cb (GstElement * gnlobject, GParamSpec * arg
+ G_GNUC_UNUSED, GESTrackElement * obj);
+
+static void gnlobject_duration_cb (GstElement * gnlobject, GParamSpec * arg
+ G_GNUC_UNUSED, GESTrackElement * obj);
+
+static void gnlobject_active_cb (GstElement * gnlobject, GParamSpec * arg
+ G_GNUC_UNUSED, GESTrackElement * obj);
+
+static void connect_properties_signals (GESTrackElement * object);
+static void connect_signal (gpointer key, gpointer value, gpointer user_data);
+static void gst_element_prop_changed_cb (GstElement * element, GParamSpec * arg
+ G_GNUC_UNUSED, GESTrackElement * obj);
+
+static gboolean _set_start (GESTimelineElement * element, GstClockTime start);
+static gboolean _set_inpoint (GESTimelineElement * element,
+ GstClockTime inpoint);
+static gboolean _set_duration (GESTimelineElement * element,
+ GstClockTime duration);
+static gboolean _set_priority (GESTimelineElement * element, guint32 priority);
+static void _deep_copy (GESTimelineElement * element,
+ GESTimelineElement * copy);
+
+static inline void
+ges_track_element_set_locked_internal (GESTrackElement * object,
+ gboolean locked);
+
+static GParamSpec **default_list_children_properties (GESTrackElement * object,
+ guint * n_properties);
+
+static void
+ges_track_element_get_property (GObject * object, guint property_id,
+ GValue * value, GParamSpec * pspec)
+{
+ GESTrackElement *tobj = GES_TRACK_ELEMENT (object);
+
+ switch (property_id) {
+ case PROP_ACTIVE:
+ g_value_set_boolean (value, ges_track_element_is_active (tobj));
+ break;
+ case PROP_LOCKED:
+ g_value_set_boolean (value, ges_track_element_is_locked (tobj));
+ break;
+ case PROP_TRACK_TYPE:
+ g_value_set_flags (value, tobj->priv->track_type);
+ break;
+ case PROP_TRACK:
+ g_value_set_object (value, tobj->priv->track);
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+ }
+}
+
+static void
+ges_track_element_set_property (GObject * object, guint property_id,
+ const GValue * value, GParamSpec * pspec)
+{
+ GESTrackElement *tobj = GES_TRACK_ELEMENT (object);
+
+ switch (property_id) {
+ case PROP_ACTIVE:
+ ges_track_element_set_active (tobj, g_value_get_boolean (value));
+ break;
+ case PROP_LOCKED:
+ ges_track_element_set_locked_internal (tobj, g_value_get_boolean (value));
+ break;
+ case PROP_TRACK_TYPE:
+ tobj->priv->track_type = g_value_get_flags (value);
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+ }
+}
+
+static void
+ges_track_element_dispose (GObject * object)
+{
+ GESTrackElementPrivate *priv = GES_TRACK_ELEMENT (object)->priv;
+
+ if (priv->properties_hashtable)
+ g_hash_table_destroy (priv->properties_hashtable);
+
+ if (priv->gnlobject) {
+ GstState cstate;
+
+ if (priv->track != NULL) {
+ GST_ERROR_OBJECT (object, "Still in %p, this means that you forgot"
+ " to remove it from the GESTrack it is contained in. You always need"
+ " to remove a GESTrackElement from its track before dropping the last"
+ " reference\n"
+ "This problem may also be caused by a refcounting bug in"
+ " the application or GES itself.", priv->track);
+ gst_element_get_state (priv->gnlobject, &cstate, NULL, 0);
+ if (cstate != GST_STATE_NULL)
+ gst_element_set_state (priv->gnlobject, GST_STATE_NULL);
+ }
+
+ gst_object_unref (priv->gnlobject);
+ priv->gnlobject = NULL;
+ }
+
+ G_OBJECT_CLASS (ges_track_element_parent_class)->dispose (object);
+}
+
+static void
+ges_track_element_finalize (GObject * object)
+{
+ G_OBJECT_CLASS (ges_track_element_parent_class)->finalize (object);
+}
+
+static void
+ges_track_element_class_init (GESTrackElementClass * klass)
+{
+ GObjectClass *object_class = G_OBJECT_CLASS (klass);
+ GESTimelineElementClass *element_class = GES_TIMELINE_ELEMENT_CLASS (klass);
+
+ g_type_class_add_private (klass, sizeof (GESTrackElementPrivate));
+
+ object_class->get_property = ges_track_element_get_property;
+ object_class->set_property = ges_track_element_set_property;
+ object_class->dispose = ges_track_element_dispose;
+ object_class->finalize = ges_track_element_finalize;
+
+
+ /**
+ * GESTrackElement:active:
+ *
+ * Whether the object should be taken into account in the #GESTrack output.
+ * If #FALSE, then its contents will not be used in the resulting track.
+ */
+ properties[PROP_ACTIVE] =
+ g_param_spec_boolean ("active", "Active", "Use object in output", TRUE,
+ G_PARAM_READWRITE);
+ g_object_class_install_property (object_class, PROP_ACTIVE,
+ properties[PROP_ACTIVE]);
+
+ /**
+ * GESTrackElement:locked:
+ *
+ * If %TRUE, then moves in sync with its controlling #GESClip
+ */
+ properties[PROP_LOCKED] =
+ g_param_spec_boolean ("locked", "Locked",
+ "Moves in sync with its controling Clip", TRUE, G_PARAM_READWRITE);
+ g_object_class_install_property (object_class, PROP_LOCKED,
+ properties[PROP_LOCKED]);
+
+ properties[PROP_TRACK_TYPE] = g_param_spec_flags ("track-type", "Track Type",
+ "The track type of the object", GES_TYPE_TRACK_TYPE,
+ GES_TRACK_TYPE_UNKNOWN, G_PARAM_READWRITE | G_PARAM_CONSTRUCT);
+ g_object_class_install_property (object_class, PROP_TRACK_TYPE,
+ properties[PROP_TRACK_TYPE]);
+
+ properties[PROP_TRACK] = g_param_spec_object ("track", "Track",
+ "The track the object is in", GES_TYPE_TRACK, G_PARAM_READABLE);
+ g_object_class_install_property (object_class, PROP_TRACK,
+ properties[PROP_TRACK]);
+
+
+ /**
+ * GESTrackElement::deep-notify:
+ * @track_element: a #GESTrackElement
+ * @prop_object: the object that originated the signal
+ * @prop: the property that changed
+ *
+ * The deep notify signal is used to be notified of property changes of all
+ * the childs of @track_element
+ *
+ * Since: 0.10.2
+ */
+ ges_track_element_signals[DEEP_NOTIFY] =
+ g_signal_new ("deep-notify", G_TYPE_FROM_CLASS (klass),
+ G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE | G_SIGNAL_DETAILED |
+ G_SIGNAL_NO_HOOKS, 0, NULL, NULL, g_cclosure_marshal_generic,
+ G_TYPE_NONE, 2, GST_TYPE_ELEMENT, G_TYPE_PARAM);
+
+ element_class->set_start = _set_start;
+ element_class->set_duration = _set_duration;
+ element_class->set_inpoint = _set_inpoint;
+ element_class->set_priority = _set_priority;
+ element_class->deep_copy = _deep_copy;
+
+ klass->create_gnl_object = ges_track_element_create_gnl_object_func;
+ /* There is no 'get_props_hashtable' default implementation */
+ klass->get_props_hastable = NULL;
+ klass->list_children_properties = default_list_children_properties;
+}
+
+static void
+ges_track_element_init (GESTrackElement * self)
+{
+ GESTrackElementPrivate *priv = self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
+ GES_TYPE_TRACK_ELEMENT, GESTrackElementPrivate);
+
+ /* Sane default values */
+ priv->pending_start = 0;
+ priv->pending_inpoint = 0;
+ priv->pending_duration = GST_SECOND;
+ priv->pending_priority = 1;
+ priv->pending_active = TRUE;
+ priv->locked = TRUE;
+ priv->properties_hashtable = NULL;
+}
+
+static gboolean
+_set_start (GESTimelineElement * element, GstClockTime start)
+{
+ GESTrackElement *object = GES_TRACK_ELEMENT (element);
+
+ GST_DEBUG ("object:%p, start:%" GST_TIME_FORMAT,
+ object, GST_TIME_ARGS (start));
+
+ if (object->priv->gnlobject != NULL) {
+ if (G_UNLIKELY (start == _START (object)))
+ return FALSE;
+
+ g_object_set (object->priv->gnlobject, "start", start, NULL);
+ } else
+ object->priv->pending_start = start;
+
+ return TRUE;
+}
+
+static gboolean
+_set_inpoint (GESTimelineElement * element, GstClockTime inpoint)
+{
+ GESTrackElement *object = GES_TRACK_ELEMENT (element);
+
+ GST_DEBUG ("object:%p, inpoint:%" GST_TIME_FORMAT,
+ object, GST_TIME_ARGS (inpoint));
+
+ if (object->priv->gnlobject != NULL) {
+ if (G_UNLIKELY (inpoint == _INPOINT (object)))
+
+ return FALSE;
+
+ g_object_set (object->priv->gnlobject, "media-start", inpoint, NULL);
+ } else
+ object->priv->pending_inpoint = inpoint;
+
+ return TRUE;
+}
+
+static gboolean
+_set_duration (GESTimelineElement * element, GstClockTime duration)
+{
+ GESTrackElement *object = GES_TRACK_ELEMENT (element);
+ GESTrackElementPrivate *priv = object->priv;
+
+ GST_DEBUG ("object:%p, duration:%" GST_TIME_FORMAT,
+ object, GST_TIME_ARGS (duration));
+
+ if (GST_CLOCK_TIME_IS_VALID (_MAXDURATION (element)) &&
+ duration > _INPOINT (object) + _MAXDURATION (element))
+ duration = _MAXDURATION (element) - _INPOINT (object);
+
+ if (priv->gnlobject != NULL) {
+ if (G_UNLIKELY (duration == _DURATION (object)))
+ return FALSE;
+
+ g_object_set (priv->gnlobject, "duration", duration,
+ "media-duration", duration, NULL);
+ } else
+ priv->pending_duration = duration;
+
+ return TRUE;
+}
+
+static gboolean
+_set_priority (GESTimelineElement * element, guint32 priority)
+{
+ GESTrackElement *object = GES_TRACK_ELEMENT (element);
+
+ GST_DEBUG ("object:%p, priority:%" G_GUINT32_FORMAT, object, priority);
+
+ if (object->priv->gnlobject != NULL) {
+ if (G_UNLIKELY (priority == _PRIORITY (object)))
+ return FALSE;
+
+ g_object_set (object->priv->gnlobject, "priority", priority, NULL);
+ } else
+ object->priv->pending_priority = priority;
+
+ return TRUE;
+}
+
+/**
+ * ges_track_element_set_active:
+ * @object: a #GESTrackElement
+ * @active: visibility
+ *
+ * Sets the usage of the @object. If @active is %TRUE, the object will be used for
+ * playback and rendering, else it will be ignored.
+ *
+ * Returns: %TRUE if the property was toggled, else %FALSE
+ */
+gboolean
+ges_track_element_set_active (GESTrackElement * object, gboolean active)
+{
+ g_return_val_if_fail (GES_IS_TRACK_ELEMENT (object), FALSE);
+
+ GST_DEBUG ("object:%p, active:%d", object, active);
+
+ if (object->priv->gnlobject != NULL) {
+ if (G_UNLIKELY (active == object->active))
+ return FALSE;
+
+ g_object_set (object->priv->gnlobject, "active", active, NULL);
+ } else
+ object->priv->pending_active = active;
+ return TRUE;
+}
+
+void
+ges_track_element_set_track_type (GESTrackElement * object, GESTrackType type)
+{
+ g_return_if_fail (GES_IS_TRACK_ELEMENT (object));
+
+ if (object->priv->track_type != type) {
+ object->priv->track_type = type;
+ g_object_notify_by_pspec (G_OBJECT (object), properties[PROP_TRACK_TYPE]);
+ }
+}
+
+GESTrackType
+ges_track_element_get_track_type (GESTrackElement * object)
+{
+ g_return_val_if_fail (GES_IS_TRACK_ELEMENT (object), GES_TRACK_TYPE_UNKNOWN);
+
+ return object->priv->track_type;
+}
+
+/* Callbacks from the GNonLin object */
+static void
+gnlobject_start_cb (GstElement * gnlobject, GParamSpec * arg G_GNUC_UNUSED,
+ GESTrackElement * obj)
+{
+ guint64 start;
+
+ g_object_get (gnlobject, "start", &start, NULL);
+
+ GST_DEBUG ("gnlobject start : %" GST_TIME_FORMAT " current : %"
+ GST_TIME_FORMAT, GST_TIME_ARGS (start), GST_TIME_ARGS (_START (obj)));
+
+ if (start != _START (obj)) {
+ _START (obj) = start;
+ g_object_notify (G_OBJECT (obj), "start");
+ }
+}
+
+static void
+gst_element_prop_changed_cb (GstElement * element, GParamSpec * arg
+ G_GNUC_UNUSED, GESTrackElement * obj)
+{
+ g_signal_emit (obj, ges_track_element_signals[DEEP_NOTIFY], 0,
+ GST_ELEMENT (element), arg);
+}
+
+static void
+connect_signal (gpointer key, gpointer value, gpointer user_data)
+{
+ gchar *signame = g_strconcat ("notify::", G_PARAM_SPEC (key)->name, NULL);
+
+ g_signal_connect (G_OBJECT (value),
+ signame, G_CALLBACK (gst_element_prop_changed_cb),
+ GES_TRACK_ELEMENT (user_data));
+
+ g_free (signame);
+}
+
+static void
+connect_properties_signals (GESTrackElement * object)
+{
+ if (G_UNLIKELY (!object->priv->properties_hashtable)) {
+ GST_WARNING ("The properties_hashtable hasn't been set");
+ return;
+ }
+
+ g_hash_table_foreach (object->priv->properties_hashtable,
+ (GHFunc) connect_signal, object);
+
+}
+
+/* Callbacks from the GNonLin object */
+static void
+gnlobject_media_start_cb (GstElement * gnlobject,
+ GParamSpec * arg G_GNUC_UNUSED, GESTrackElement * obj)
+{
+ guint64 inpoint;
+
+ g_object_get (gnlobject, "media-start", &inpoint, NULL);
+
+ GST_DEBUG ("gnlobject in-point : %" GST_TIME_FORMAT " current : %"
+ GST_TIME_FORMAT, GST_TIME_ARGS (inpoint), GST_TIME_ARGS (_INPOINT (obj)));
+
+ if (inpoint != _INPOINT (obj)) {
+ _INPOINT (obj) = inpoint;
+ g_object_notify (G_OBJECT (obj), "in-point");
+ }
+}
+
+static void
+gnlobject_priority_cb (GstElement * gnlobject, GParamSpec * arg G_GNUC_UNUSED,
+ GESTrackElement * obj)
+{
+ guint32 priority;
+
+ g_object_get (gnlobject, "priority", &priority, NULL);
+
+ GST_DEBUG ("gnlobject priority : %d current : %d", priority, _PRIORITY (obj));
+
+ if (priority != _PRIORITY (obj)) {
+ _PRIORITY (obj) = priority;
+ g_object_notify (G_OBJECT (obj), "priority");
+ }
+}
+
+static void
+gnlobject_duration_cb (GstElement * gnlobject, GParamSpec * arg G_GNUC_UNUSED,
+ GESTrackElement * obj)
+{
+ guint64 duration;
+ GESTrackElementClass *klass;
+
+ klass = GES_TRACK_ELEMENT_GET_CLASS (obj);
+
+ g_object_get (gnlobject, "duration", &duration, NULL);
+
+ GST_DEBUG_OBJECT (gnlobject, "duration : %" GST_TIME_FORMAT " current : %"
+ GST_TIME_FORMAT, GST_TIME_ARGS (duration),
+ GST_TIME_ARGS (_DURATION (obj)));
+
+ if (duration != _DURATION (obj)) {
+ _DURATION (obj) = duration;
+ if (klass->duration_changed)
+ klass->duration_changed (obj, duration);
+ g_object_notify (G_OBJECT (obj), "duration");
+ }
+}
+
+static void
+gnlobject_active_cb (GstElement * gnlobject, GParamSpec * arg G_GNUC_UNUSED,
+ GESTrackElement * obj)
+{
+ gboolean active;
+ GESTrackElementClass *klass;
+
+ klass = GES_TRACK_ELEMENT_GET_CLASS (obj);
+
+ g_object_get (gnlobject, "active", &active, NULL);
+
+ GST_DEBUG ("gnlobject active : %d current : %d", active, obj->active);
+
+ if (active != obj->active) {
+ obj->active = active;
+ if (klass->active_changed)
+ klass->active_changed (obj, active);
+ }
+}
+
+
+/* default 'create_gnl_object' virtual method implementation */
+static GstElement *
+ges_track_element_create_gnl_object_func (GESTrackElement * self)
+{
+ GESTrackElementClass *klass = NULL;
+ GstElement *child = NULL;
+ GstElement *gnlobject;
+
+ klass = GES_TRACK_ELEMENT_GET_CLASS (self);
+
+ if (G_UNLIKELY (self->priv->gnlobject != NULL))
+ goto already_have_gnlobject;
+
+ if (G_UNLIKELY (klass->gnlobject_factorytype == NULL))
+ goto no_gnlfactory;
+
+ GST_DEBUG ("Creating a supporting gnlobject of type '%s'",
+ klass->gnlobject_factorytype);
+
+ gnlobject = gst_element_factory_make (klass->gnlobject_factorytype, NULL);
+
+ if (G_UNLIKELY (gnlobject == NULL))
+ goto no_gnlobject;
+
+ if (klass->create_element) {
+ GST_DEBUG ("Calling subclass 'create_element' vmethod");
+ child = klass->create_element (self);
+
+ if (G_UNLIKELY (!child))
+ goto child_failure;
+
+ if (!gst_bin_add (GST_BIN (gnlobject), child))
+ goto add_failure;
+
+ GST_DEBUG ("Succesfully got the element to put in the gnlobject");
+ self->priv->element = child;
+ }
+
+ GST_DEBUG ("done");
+ return gnlobject;
+
+
+ /* ERROR CASES */
+
+already_have_gnlobject:
+ {
+ GST_ERROR ("Already controlling a GnlObject %s",
+ GST_ELEMENT_NAME (self->priv->gnlobject));
+ return NULL;
+ }
+
+no_gnlfactory:
+ {
+ GST_ERROR ("No GESTrackElement::gnlobject_factorytype implementation!");
+ return NULL;
+ }
+
+no_gnlobject:
+ {
+ GST_ERROR ("Error creating a gnlobject of type '%s'",
+ klass->gnlobject_factorytype);
+ return NULL;
+ }
+
+child_failure:
+ {
+ GST_ERROR ("create_element returned NULL");
+ gst_object_unref (gnlobject);
+ return NULL;
+ }
+
+add_failure:
+ {
+ GST_ERROR ("Error adding the contents to the gnlobject");
+ gst_object_unref (child);
+ gst_object_unref (gnlobject);
+ return NULL;
+ }
+}
+
+static gboolean
+ensure_gnl_object (GESTrackElement * object)
+{
+ GESTrackElementClass *class;
+ GstElement *gnlobject;
+ GHashTable *props_hash;
+ gboolean res = TRUE;
+
+ if (object->priv->gnlobject && object->priv->valid)
+ return FALSE;
+
+ /* 1. Create the GnlObject */
+ GST_DEBUG ("Creating GnlObject");
+
+ class = GES_TRACK_ELEMENT_GET_CLASS (object);
+
+ if (G_UNLIKELY (class->create_gnl_object == NULL)) {
+ GST_ERROR ("No 'create_gnl_object' implementation !");
+ goto done;
+ }
+
+ GST_DEBUG ("Calling virtual method");
+
+ /* 2. Fill in the GnlObject */
+ if (object->priv->gnlobject == NULL) {
+
+ /* call the create_gnl_object virtual method */
+ gnlobject = class->create_gnl_object (object);
+
+ if (G_UNLIKELY (gnlobject == NULL)) {
+ GST_ERROR
+ ("'create_gnl_object' implementation returned TRUE but no GnlObject is available");
+ goto done;
+ }
+
+ GST_DEBUG_OBJECT (object, "Got a valid GnlObject, now filling it in");
+
+ object->priv->gnlobject = gst_object_ref (gnlobject);
+
+ if (object->priv->timelineobj)
+ res = ges_clip_fill_track_element (object->priv->timelineobj,
+ object, object->priv->gnlobject);
+ else
+ res = TRUE;
+
+ if (res) {
+ /* Connect to property notifications */
+ /* FIXME : remember the signalids so we can remove them later on !!! */
+ g_signal_connect (G_OBJECT (object->priv->gnlobject), "notify::start",
+ G_CALLBACK (gnlobject_start_cb), object);
+ g_signal_connect (G_OBJECT (object->priv->gnlobject),
+ "notify::media-start", G_CALLBACK (gnlobject_media_start_cb), object);
+ g_signal_connect (G_OBJECT (object->priv->gnlobject), "notify::duration",
+ G_CALLBACK (gnlobject_duration_cb), object);
+ g_signal_connect (G_OBJECT (object->priv->gnlobject), "notify::priority",
+ G_CALLBACK (gnlobject_priority_cb), object);
+ g_signal_connect (G_OBJECT (object->priv->gnlobject), "notify::active",
+ G_CALLBACK (gnlobject_active_cb), object);
+
+ /* Set some properties on the GnlObject */
+ g_object_set (object->priv->gnlobject,
+ "duration", object->priv->pending_duration,
+ "media-duration", object->priv->pending_duration,
+ "start", object->priv->pending_start,
+ "media-start", object->priv->pending_inpoint,
+ "priority", object->priv->pending_priority,
+ "active", object->priv->pending_active, NULL);
+
+ if (object->priv->track != NULL)
+ g_object_set (object->priv->gnlobject,
+ "caps", ges_track_get_caps (object->priv->track), NULL);
+
+ /* We feed up the props_hashtable if possible */
+ if (class->get_props_hastable) {
+ props_hash = class->get_props_hastable (object);
+
+ if (props_hash == NULL) {
+ GST_DEBUG ("'get_props_hastable' implementation returned TRUE but no"
+ "properties_hashtable is available");
+ } else {
+ object->priv->properties_hashtable = props_hash;
+ connect_properties_signals (object);
+ }
+ }
+ }
+ }
+
+done:
+ object->priv->valid = res;
+
+ GST_DEBUG ("Returning res:%d", res);
+
+ return res;
+}
+
+/* INTERNAL USAGE */
+gboolean
+ges_track_element_set_track (GESTrackElement * object, GESTrack * track)
+{
+ gboolean ret = TRUE;
+ GST_DEBUG ("object:%p, track:%p", object, track);
+
+ object->priv->track = track;
+
+ if (object->priv->track) {
+ /* If we already have a gnlobject, we just set its caps properly */
+ if (object->priv->gnlobject) {
+ g_object_set (object->priv->gnlobject,
+ "caps", ges_track_get_caps (object->priv->track), NULL);
+ } else {
+ ret = ensure_gnl_object (object);
+ }
+ }
+
+ g_object_notify_by_pspec (G_OBJECT (object), properties[PROP_TRACK]);
+ return ret;
+}
+
+/**
+ * ges_track_element_get_track:
+ * @object: a #GESTrackElement
+ *
+ * Get the #GESTrack to which this object belongs.
+ *
+ * Returns: (transfer none): The #GESTrack to which this object belongs. Can be %NULL if it
+ * is not in any track
+ */
+GESTrack *
+ges_track_element_get_track (GESTrackElement * object)
+{
+ g_return_val_if_fail (GES_IS_TRACK_ELEMENT (object), NULL);
+
+ return object->priv->track;
+}
+
+/**
+ * ges_track_element_set_clip:
+ * @object: The #GESTrackElement to set the parent to
+ * @clipect: The #GESClip, parent of @clip or %NULL
+ *
+ * Set the #GESClip to which @object belongs.
+ */
+void
+ges_track_element_set_clip (GESTrackElement * object, GESClip * clipect)
+{
+ GST_DEBUG ("object:%p, clip:%p", object, clipect);
+
+ object->priv->timelineobj = clipect;
+}
+
+/**
+ * ges_track_element_get_clip:
+ * @object: a #GESTrackElement
+ *
+ * Get the #GESClip which is controlling this track object
+ *
+ * Returns: (transfer none): the #GESClip which is controlling
+ * this track object
+ */
+GESClip *
+ges_track_element_get_clip (GESTrackElement * object)
+{
+ g_return_val_if_fail (GES_IS_TRACK_ELEMENT (object), NULL);
+
+ return object->priv->timelineobj;
+}
+
+/**
+ * ges_track_element_get_gnlobject:
+ * @object: a #GESTrackElement
+ *
+ * Get the GNonLin object this object is controlling.
+ *
+ * Returns: (transfer none): the GNonLin object this object is controlling.
+ */
+GstElement *
+ges_track_element_get_gnlobject (GESTrackElement * object)
+{
+ g_return_val_if_fail (GES_IS_TRACK_ELEMENT (object), NULL);
+
+ return object->priv->gnlobject;
+}
+
+/**
+ * ges_track_element_get_element:
+ * @object: a #GESTrackElement
+ *
+ * Get the #GstElement this track object is controlling within GNonLin.
+ *
+ * Returns: (transfer none): the #GstElement this track object is controlling
+ * within GNonLin.
+ */
+GstElement *
+ges_track_element_get_element (GESTrackElement * object)
+{
+ g_return_val_if_fail (GES_IS_TRACK_ELEMENT (object), NULL);
+
+ return object->priv->element;
+}
+
+static inline void
+ges_track_element_set_locked_internal (GESTrackElement * object,
+ gboolean locked)
+{
+ object->priv->locked = locked;
+}
+
+/**
+ * ges_track_element_set_locked:
+ * @object: a #GESTrackElement
+ * @locked: whether the object is lock to its parent
+ *
+ * Set the locking status of the @object in relationship to its controlling
+ * #GESClip. If @locked is %TRUE, then this object will move synchronously
+ * with its controlling #GESClip.
+ */
+void
+ges_track_element_set_locked (GESTrackElement * object, gboolean locked)
+{
+ g_return_if_fail (GES_IS_TRACK_ELEMENT (object));
+
+ GST_DEBUG_OBJECT (object, "%s object", locked ? "Locking" : "Unlocking");
+
+ ges_track_element_set_locked_internal (object, locked);
+ g_object_notify_by_pspec (G_OBJECT (object), properties[PROP_LOCKED]);
+
+}
+
+/**
+ * ges_track_element_is_locked:
+ * @object: a #GESTrackElement
+ *
+ * Let you know if object us locked or not (moving synchronously).
+ *
+ * Returns: %TRUE if the object is moving synchronously to its controlling
+ * #GESClip, else %FALSE.
+ */
+gboolean
+ges_track_element_is_locked (GESTrackElement * object)
+{
+ g_return_val_if_fail (GES_IS_TRACK_ELEMENT (object), FALSE);
+
+ return object->priv->locked;
+}
+
+
+/**
+ * ges_track_element_is_active:
+ * @object: a #GESTrackElement
+ *
+ * Lets you know if @object will be used for playback and rendering,
+ * or not.
+ *
+ * Returns: %TRUE if @object is active, %FALSE otherwize
+ *
+ * Since: 0.10.2
+ */
+gboolean
+ges_track_element_is_active (GESTrackElement * object)
+{
+ g_return_val_if_fail (GES_IS_TRACK_ELEMENT (object), FALSE);
+
+ if (G_UNLIKELY (object->priv->gnlobject == NULL))
+ return object->priv->pending_active;
+ else
+ return object->active;
+}
+
+/**
+ * ges_track_element_lookup_child:
+ * @object: object to lookup the property in
+ * @prop_name: name of the property to look up. You can specify the name of the
+ * class as such: "ClassName::property-name", to guarantee that you get the
+ * proper GParamSpec in case various GstElement-s contain the same property
+ * name. If you don't do so, you will get the first element found, having
+ * this property and the and the corresponding GParamSpec.
+ * @element: (out) (allow-none) (transfer full): pointer to a #GstElement that
+ * takes the real object to set property on
+ * @pspec: (out) (allow-none) (transfer full): pointer to take the #GParamSpec
+ * describing the property
+ *
+ * Looks up which @element and @pspec would be effected by the given @name. If various
+ * contained elements have this property name you will get the first one, unless you
+ * specify the class name in @name.
+ *
+ * Returns: TRUE if @element and @pspec could be found. FALSE otherwise. In that
+ * case the values for @pspec and @element are not modified. Unref @element after
+ * usage.
+ *
+ * Since: 0.10.2
+ */
+gboolean
+ges_track_element_lookup_child (GESTrackElement * object,
+ const gchar * prop_name, GstElement ** element, GParamSpec ** pspec)
+{
+ GHashTableIter iter;
+ gpointer key, value;
+ gchar **names, *name, *classename;
+ gboolean res;
+ GESTrackElementPrivate *priv;
+
+ g_return_val_if_fail (GES_IS_TRACK_ELEMENT (object), FALSE);
+
+ priv = object->priv;
+
+ if (!priv->properties_hashtable)
+ goto prop_hash_not_set;
+
+ classename = NULL;
+ res = FALSE;
+
+ names = g_strsplit (prop_name, "::", 2);
+ if (names[1] != NULL) {
+ classename = names[0];
+ name = names[1];
+ } else
+ name = names[0];
+
+ g_hash_table_iter_init (&iter, priv->properties_hashtable);
+ while (g_hash_table_iter_next (&iter, &key, &value)) {
+ if (g_strcmp0 (G_PARAM_SPEC (key)->name, name) == 0) {
+ if (classename == NULL ||
+ g_strcmp0 (G_OBJECT_TYPE_NAME (G_OBJECT (value)), classename) == 0) {
+ GST_DEBUG ("The %s property from %s has been found", name, classename);
+ if (element)
+ *element = g_object_ref (value);
+
+ *pspec = g_param_spec_ref (key);
+ res = TRUE;
+ break;
+ }
+ }
+ }
+ g_strfreev (names);
+
+ return res;
+
+prop_hash_not_set:
+ {
+ GST_WARNING_OBJECT (object, "The child properties haven't been set yet");
+ return FALSE;
+ }
+}
+
+/**
+ * ges_track_element_set_child_property_by_pspec:
+ * @object: a #GESTrackElement
+ * @pspec: The #GParamSpec that specifies the property you want to set
+ * @value: the value
+ *
+ * Sets a property of a child of @object.
+ *
+ * Since: 0.10.2
+ */
+void
+ges_track_element_set_child_property_by_pspec (GESTrackElement * object,
+ GParamSpec * pspec, GValue * value)
+{
+ GstElement *element;
+ GESTrackElementPrivate *priv;
+
+ g_return_if_fail (GES_IS_TRACK_ELEMENT (object));
+
+ priv = object->priv;
+
+ if (!priv->properties_hashtable)
+ goto prop_hash_not_set;
+
+ element = g_hash_table_lookup (priv->properties_hashtable, pspec);
+ if (!element)
+ goto not_found;
+
+ g_object_set_property (G_OBJECT (element), pspec->name, value);
+
+ return;
+
+not_found:
+ {
+ GST_ERROR ("The %s property doesn't exist", pspec->name);
+ return;
+ }
+prop_hash_not_set:
+ {
+ GST_DEBUG ("The child properties haven't been set on %p", object);
+ return;
+ }
+}
+
+/**
+ * ges_track_element_set_child_property_valist:
+ * @object: The #GESTrackElement parent object
+ * @first_property_name: The name of the first property to set
+ * @var_args: value for the first property, followed optionally by more
+ * name/return location pairs, followed by NULL
+ *
+ * Sets a property of a child of @object. If there are various child elements
+ * that have the same property name, you can distinguish them using the following
+ * syntax: 'ClasseName::property_name' as property name. If you don't, the
+ * corresponding property of the first element found will be set.
+ *
+ * Since: 0.10.2
+ */
+void
+ges_track_element_set_child_property_valist (GESTrackElement * object,
+ const gchar * first_property_name, va_list var_args)
+{
+ const gchar *name;
+ GParamSpec *pspec;
+ GstElement *element;
+
+ gchar *error = NULL;
+ GValue value = { 0, };
+
+ g_return_if_fail (GES_IS_TRACK_ELEMENT (object));
+
+ name = first_property_name;
+
+ /* Note: This part is in big part copied from the gst_child_object_set_valist
+ * method. */
+
+ /* iterate over pairs */
+ while (name) {
+ if (!ges_track_element_lookup_child (object, name, &element, &pspec))
+ goto not_found;
+
+#if GLIB_CHECK_VERSION(2,23,3)
+ G_VALUE_COLLECT_INIT (&value, pspec->value_type, var_args,
+ G_VALUE_NOCOPY_CONTENTS, &error);
+#else
+ g_value_init (&value, G_PARAM_SPEC_VALUE_TYPE (pspec));
+ G_VALUE_COLLECT (&value, var_args, G_VALUE_NOCOPY_CONTENTS, &error);
+#endif
+
+ if (error)
+ goto cant_copy;
+
+ g_object_set_property (G_OBJECT (element), pspec->name, &value);
+
+ g_object_unref (element);
+ g_value_unset (&value);
+
+ name = va_arg (var_args, gchar *);
+ }
+ return;
+
+not_found:
+ {
+ GST_WARNING ("No property %s in OBJECT\n", name);
+ return;
+ }
+cant_copy:
+ {
+ GST_WARNING ("error copying value %s in object %p: %s", pspec->name, object,
+ error);
+ g_value_unset (&value);
+ return;
+ }
+}
+
+/**
+ * ges_track_element_set_child_properties:
+ * @object: The #GESTrackElement parent object
+ * @first_property_name: The name of the first property to set
+ * @...: value for the first property, followed optionally by more
+ * name/return location pairs, followed by NULL
+ *
+ * Sets a property of a child of @object. If there are various child elements
+ * that have the same property name, you can distinguish them using the following
+ * syntax: 'ClasseName::property_name' as property name. If you don't, the
+ * corresponding property of the first element found will be set.
+ *
+ * Since: 0.10.2
+ */
+void
+ges_track_element_set_child_properties (GESTrackElement * object,
+ const gchar * first_property_name, ...)
+{
+ va_list var_args;
+
+ g_return_if_fail (GES_IS_TRACK_ELEMENT (object));
+
+ va_start (var_args, first_property_name);
+ ges_track_element_set_child_property_valist (object, first_property_name,
+ var_args);
+ va_end (var_args);
+}
+
+/**
+ * ges_track_element_get_child_property_valist:
+ * @object: The #GESTrackElement parent object
+ * @first_property_name: The name of the first property to get
+ * @var_args: value for the first property, followed optionally by more
+ * name/return location pairs, followed by NULL
+ *
+ * Gets a property of a child of @object. If there are various child elements
+ * that have the same property name, you can distinguish them using the following
+ * syntax: 'ClasseName::property_name' as property name. If you don't, the
+ * corresponding property of the first element found will be set.
+ *
+ * Since: 0.10.2
+ */
+void
+ges_track_element_get_child_property_valist (GESTrackElement * object,
+ const gchar * first_property_name, va_list var_args)
+{
+ const gchar *name;
+ gchar *error = NULL;
+ GValue value = { 0, };
+ GParamSpec *pspec;
+ GstElement *element;
+
+ g_return_if_fail (G_IS_OBJECT (object));
+
+ name = first_property_name;
+
+ /* This part is in big part copied from the gst_child_object_get_valist method */
+ while (name) {
+ if (!ges_track_element_lookup_child (object, name, &element, &pspec))
+ goto not_found;
+
+ g_value_init (&value, pspec->value_type);
+ g_object_get_property (G_OBJECT (element), pspec->name, &value);
+ g_object_unref (element);
+
+ G_VALUE_LCOPY (&value, var_args, 0, &error);
+ if (error)
+ goto cant_copy;
+ g_value_unset (&value);
+ name = va_arg (var_args, gchar *);
+ }
+ return;
+
+not_found:
+ {
+ GST_WARNING ("no property %s in object", name);
+ return;
+ }
+cant_copy:
+ {
+ GST_WARNING ("error copying value %s in object %p: %s", pspec->name, object,
+ error);
+ g_value_unset (&value);
+ return;
+ }
+}
+
+/**
+ * ges_track_element_list_children_properties:
+ * @object: The #GESTrackElement to get the list of children properties from
+ * @n_properties: (out): return location for the length of the returned array
+ *
+ * Gets an array of #GParamSpec* for all configurable properties of the
+ * children of @object.
+ *
+ * Returns: (transfer full) (array length=n_properties): an array of #GParamSpec* which should be freed after use or
+ * %NULL if something went wrong
+ *
+ * Since: 0.10.2
+ */
+GParamSpec **
+ges_track_element_list_children_properties (GESTrackElement * object,
+ guint * n_properties)
+{
+ GESTrackElementClass *class;
+
+ g_return_val_if_fail (GES_IS_TRACK_ELEMENT (object), NULL);
+
+ class = GES_TRACK_ELEMENT_GET_CLASS (object);
+
+ return class->list_children_properties (object, n_properties);
+}
+
+/**
+ * ges_track_element_get_child_properties:
+ * @object: The origin #GESTrackElement
+ * @first_property_name: The name of the first property to get
+ * @...: return location for the first property, followed optionally by more
+ * name/return location pairs, followed by NULL
+ *
+ * Gets properties of a child of @object.
+ *
+ * Since: 0.10.2
+ */
+void
+ges_track_element_get_child_properties (GESTrackElement * object,
+ const gchar * first_property_name, ...)
+{
+ va_list var_args;
+
+ g_return_if_fail (GES_IS_TRACK_ELEMENT (object));
+
+ va_start (var_args, first_property_name);
+ ges_track_element_get_child_property_valist (object, first_property_name,
+ var_args);
+ va_end (var_args);
+}
+
+/**
+ * ges_track_element_get_child_property_by_pspec:
+ * @object: a #GESTrackElement
+ * @pspec: The #GParamSpec that specifies the property you want to get
+ * @value: (out): return location for the value
+ *
+ * Gets a property of a child of @object.
+ *
+ * Since: 0.10.2
+ */
+void
+ges_track_element_get_child_property_by_pspec (GESTrackElement * object,
+ GParamSpec * pspec, GValue * value)
+{
+ GstElement *element;
+ GESTrackElementPrivate *priv;
+
+ g_return_if_fail (GES_IS_TRACK_ELEMENT (object));
+
+ priv = object->priv;
+
+ if (!priv->properties_hashtable)
+ goto prop_hash_not_set;
+
+ element = g_hash_table_lookup (priv->properties_hashtable, pspec);
+ if (!element)
+ goto not_found;
+
+ g_object_get_property (G_OBJECT (element), pspec->name, value);
+
+ return;
+
+not_found:
+ {
+ GST_ERROR ("The %s property doesn't exist", pspec->name);
+ return;
+ }
+prop_hash_not_set:
+ {
+ GST_ERROR ("The child properties haven't been set on %p", object);
+ return;
+ }
+}
+
+/**
+ * ges_track_element_set_child_property:
+ * @object: The origin #GESTrackElement
+ * @property_name: The name of the property
+ * @value: the value
+ *
+ * Sets a property of a GstElement contained in @object.
+ *
+ * Note that #ges_track_element_set_child_property is really
+ * intended for language bindings, #ges_track_element_set_child_properties
+ * is much more convenient for C programming.
+ *
+ * Returns: %TRUE if the property was set, %FALSE otherwize
+ */
+gboolean
+ges_track_element_set_child_property (GESTrackElement * object,
+ const gchar * property_name, GValue * value)
+{
+ GParamSpec *pspec;
+ GstElement *element;
+
+ g_return_val_if_fail (GES_IS_TRACK_ELEMENT (object), FALSE);
+
+ if (!ges_track_element_lookup_child (object, property_name, &element, &pspec))
+ goto not_found;
+
+ g_object_set_property (G_OBJECT (element), pspec->name, value);
+
+ g_object_unref (element);
+ g_param_spec_unref (pspec);
+
+ return TRUE;
+
+not_found:
+ {
+ GST_WARNING_OBJECT (object, "The %s property doesn't exist", property_name);
+
+ return FALSE;
+ }
+}
+
+/**
+* ges_track_element_get_child_property:
+* @object: The origin #GESTrackElement
+* @property_name: The name of the property
+* @value: (out): return location for the property value, it will
+* be initialized if it is initialized with 0
+*
+* In general, a copy is made of the property contents and
+* the caller is responsible for freeing the memory by calling
+* g_value_unset().
+*
+* Gets a property of a GstElement contained in @object.
+*
+* Note that #ges_track_element_get_child_property is really
+* intended for language bindings, #ges_track_element_get_child_properties
+* is much more convenient for C programming.
+*
+* Returns: %TRUE if the property was found, %FALSE otherwize
+*/
+gboolean
+ges_track_element_get_child_property (GESTrackElement * object,
+ const gchar * property_name, GValue * value)
+{
+ GParamSpec *pspec;
+ GstElement *element;
+
+ g_return_val_if_fail (GES_IS_TRACK_ELEMENT (object), FALSE);
+
+ if (!ges_track_element_lookup_child (object, property_name, &element, &pspec))
+ goto not_found;
+
+ if (G_VALUE_TYPE (value) == G_TYPE_INVALID)
+ g_value_init (value, pspec->value_type);
+
+ g_object_get_property (G_OBJECT (element), pspec->name, value);
+
+ g_object_unref (element);
+ g_param_spec_unref (pspec);
+
+ return TRUE;
+
+not_found:
+ {
+ GST_WARNING_OBJECT (object, "The %s property doesn't exist", property_name);
+
+ return FALSE;
+ }
+}
+
+static GParamSpec **
+default_list_children_properties (GESTrackElement * object,
+ guint * n_properties)
+{
+ GParamSpec **pspec, *spec;
+ GHashTableIter iter;
+ gpointer key, value;
+
+ guint i = 0;
+
+ if (!object->priv->properties_hashtable)
+ goto prop_hash_not_set;
+
+ *n_properties = g_hash_table_size (object->priv->properties_hashtable);
+ pspec = g_new (GParamSpec *, *n_properties);
+
+ g_hash_table_iter_init (&iter, object->priv->properties_hashtable);
+ while (g_hash_table_iter_next (&iter, &key, &value)) {
+ spec = G_PARAM_SPEC (key);
+ pspec[i] = g_param_spec_ref (spec);
+ i++;
+ }
+
+ return pspec;
+
+prop_hash_not_set:
+ {
+ *n_properties = 0;
+ GST_DEBUG_OBJECT (object, "No child properties have been set yet");
+ return NULL;
+ }
+}
+
+void
+_deep_copy (GESTimelineElement * element, GESTimelineElement * elementcopy)
+{
+ GParamSpec **specs;
+ guint n, n_specs;
+ GValue val = { 0 };
+ GESTrackElement *copy = GES_TRACK_ELEMENT (elementcopy);
+
+ ensure_gnl_object (copy);
+ specs =
+ ges_track_element_list_children_properties (GES_TRACK_ELEMENT (element),
+ &n_specs);
+ for (n = 0; n < n_specs; ++n) {
+ g_value_init (&val, specs[n]->value_type);
+ g_object_get_property (G_OBJECT (element), specs[n]->name, &val);
+ ges_track_element_set_child_property_by_pspec (copy, specs[n], &val);
+ g_value_unset (&val);
+ }
+
+ g_free (specs);
+}
+
+/**
+ * ges_track_element_edit:
+ * @object: the #GESTrackElement to edit
+ * @layers: (element-type GESTimelineLayer): The layers you want the edit to
+ * happen in, %NULL means that the edition is done in all the
+ * #GESTimelineLayers contained in the current timeline.
+ * FIXME: This is not implemented yet.
+ * @mode: The #GESEditMode in which the editition will happen.
+ * @edge: The #GESEdge the edit should happen on.
+ * @position: The position at which to edit @object (in nanosecond)
+ *
+ * Edit @object in the different exisiting #GESEditMode modes. In the case of
+ * slide, and roll, you need to specify a #GESEdge
+ *
+ * Returns: %TRUE if the object as been edited properly, %FALSE if an error
+ * occured
+ *
+ * Since: 0.10.XX
+ */
+gboolean
+ges_track_element_edit (GESTrackElement * object,
+ GList * layers, GESEditMode mode, GESEdge edge, guint64 position)
+{
+ GESTrack *track = ges_track_element_get_track (object);
+ GESTimeline *timeline;
+
+ g_return_val_if_fail (GES_IS_TRACK_ELEMENT (object), FALSE);
+
+ if (G_UNLIKELY (!track)) {
+ GST_WARNING_OBJECT (object, "Trying to edit in %d mode but not in"
+ "any Track yet.", mode);
+ return FALSE;
+ }
+
+ timeline = GES_TIMELINE (ges_track_get_timeline (track));
+
+ if (G_UNLIKELY (!timeline)) {
+ GST_WARNING_OBJECT (object, "Trying to edit in %d mode but not in"
+ "track %p no in any timeline yet.", mode, track);
+ return FALSE;
+ }
+
+ switch (mode) {
+ case GES_EDIT_MODE_NORMAL:
+ timeline_move_object (timeline, object, layers, edge, position);
+ break;
+ case GES_EDIT_MODE_TRIM:
+ timeline_trim_object (timeline, object, layers, edge, position);
+ break;
+ case GES_EDIT_MODE_RIPPLE:
+ timeline_ripple_object (timeline, object, layers, edge, position);
+ break;
+ case GES_EDIT_MODE_ROLL:
+ timeline_roll_object (timeline, object, layers, edge, position);
+ break;
+ case GES_EDIT_MODE_SLIDE:
+ timeline_slide_object (timeline, object, layers, edge, position);
+ break;
+ default:
+ GST_ERROR ("Unkown edit mode: %d", mode);
+ return FALSE;
+ }
+
+ return TRUE;
+}
--- /dev/null
+/* GStreamer Editing Services
+ * Copyright (C) 2009 Edward Hervey <edward.hervey@collabora.co.uk>
+ * 2009 Nokia Corporation
+ *
+ * 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.
+ */
+
+#ifndef _GES_TRACK_ELEMENT
+#define _GES_TRACK_ELEMENT
+
+#include <glib-object.h>
+#include <gst/gst.h>
+#include <ges/ges-types.h>
+#include <ges/ges-clip.h>
+#include <ges/ges-track.h>
+
+G_BEGIN_DECLS
+
+#define GES_TYPE_TRACK_ELEMENT ges_track_element_get_type()
+
+#define GES_TRACK_ELEMENT(obj) \
+ (G_TYPE_CHECK_INSTANCE_CAST ((obj), GES_TYPE_TRACK_ELEMENT, GESTrackElement))
+
+#define GES_TRACK_ELEMENT_CLASS(klass) \
+ (G_TYPE_CHECK_CLASS_CAST ((klass), GES_TYPE_TRACK_ELEMENT, GESTrackElementClass))
+
+#define GES_IS_TRACK_ELEMENT(obj) \
+ (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GES_TYPE_TRACK_ELEMENT))
+
+#define GES_IS_TRACK_ELEMENT_CLASS(klass) \
+ (G_TYPE_CHECK_CLASS_TYPE ((klass), GES_TYPE_TRACK_ELEMENT))
+
+#define GES_TRACK_ELEMENT_GET_CLASS(obj) \
+ (G_TYPE_INSTANCE_GET_CLASS ((obj), GES_TYPE_TRACK_ELEMENT, GESTrackElementClass))
+
+typedef struct _GESTrackElementPrivate GESTrackElementPrivate;
+
+/**
+ * GESTrackElement:
+ *
+ * The GESTrackElement base class.
+ */
+struct _GESTrackElement {
+ GESTimelineElement parent;
+
+ /*< private >*/
+ gboolean active;
+
+ GESTrackElementPrivate *priv;
+
+ GESAsset *asset;
+
+ /* Padding for API extension */
+ gpointer _ges_reserved[GES_PADDING_LARGE];
+};
+
+/**
+ * GESTrackElementClass:
+ * @gnlobject_factorytype: name of the GNonLin GStElementFactory type to use.
+ * @create_gnl_object: method to create the GNonLin container object.
+ * @create_element: method to return the GstElement to put in the gnlobject.
+ * @duration_changed: duration property glnobject has changed
+ * @active_changed: active property of gnlobject has changed
+ * @get_props_hastable: method to list children properties that user could like
+ * to configure. Since: 0.10.2
+ * @list_children_properties: method to get children properties that user could
+ * like to configure.
+ * The default implementation will create an object
+ * of type @gnlobject_factorytype and call
+ * @create_element. Since: 0.10.2
+ *
+ * Subclasses can override the @create_gnl_object method to override what type
+ * of GNonLin object will be created.
+ */
+struct _GESTrackElementClass {
+ /*< private >*/
+ GESTimelineElementClass parent_class;
+
+ /*< public >*/
+ /* virtual methods for subclasses */
+ const gchar *gnlobject_factorytype;
+ GstElement* (*create_gnl_object) (GESTrackElement * object);
+ GstElement* (*create_element) (GESTrackElement * object);
+
+ void (*duration_changed) (GESTrackElement *object, guint64 duration);
+ void (*active_changed) (GESTrackElement *object, gboolean active);
+
+ /*< private >*/
+ /* signals (currently unused) */
+ void (*changed) (GESTrackElement * object);
+
+ /*< public >*/
+ /* virtual methods for subclasses */
+ GHashTable* (*get_props_hastable) (GESTrackElement * object);
+ GParamSpec** (*list_children_properties) (GESTrackElement * object,
+ guint *n_properties);
+ /*< private >*/
+ /* Padding for API extension */
+ gpointer _ges_reserved[GES_PADDING_LARGE];
+};
+
+GType ges_track_element_get_type (void);
+
+gboolean ges_track_element_set_track (GESTrackElement * object,
+ GESTrack * track);
+GESTrack* ges_track_element_get_track (GESTrackElement * object);
+
+GESTrackType ges_track_element_get_track_type (GESTrackElement * object);
+void ges_track_element_set_track_type (GESTrackElement * object,
+ GESTrackType type);
+
+void ges_track_element_set_clip (GESTrackElement * object,
+ GESClip * clipect);
+GESClip *
+ges_track_element_get_clip (GESTrackElement* object);
+
+GstElement * ges_track_element_get_gnlobject (GESTrackElement * object);
+
+GstElement * ges_track_element_get_element (GESTrackElement * object);
+
+void ges_track_element_set_locked (GESTrackElement * object,
+ gboolean locked);
+
+gboolean ges_track_element_is_locked (GESTrackElement * object);
+
+gboolean ges_track_element_set_active (GESTrackElement * object,
+ gboolean active);
+
+gboolean ges_track_element_is_active (GESTrackElement * object);
+
+GParamSpec **
+ges_track_element_list_children_properties (GESTrackElement *object,
+ guint *n_properties);
+
+gboolean ges_track_element_lookup_child (GESTrackElement *object,
+ const gchar *prop_name,
+ GstElement **element,
+ GParamSpec **pspec);
+
+void
+ges_track_element_get_child_property_by_pspec (GESTrackElement * object,
+ GParamSpec * pspec,
+ GValue * value);
+
+void
+ges_track_element_get_child_property_valist (GESTrackElement * object,
+ const gchar * first_property_name,
+ va_list var_args);
+
+void ges_track_element_get_child_properties (GESTrackElement *object,
+ const gchar * first_property_name,
+ ...) G_GNUC_NULL_TERMINATED;
+
+void
+ges_track_element_set_child_property_valist (GESTrackElement * object,
+ const gchar * first_property_name,
+ va_list var_args);
+
+void
+ges_track_element_set_child_property_by_pspec (GESTrackElement * object,
+ GParamSpec * pspec,
+ GValue * value);
+
+void ges_track_element_set_child_properties (GESTrackElement * object,
+ const gchar * first_property_name,
+ ...) G_GNUC_NULL_TERMINATED;
+
+gboolean ges_track_element_set_child_property (GESTrackElement *object,
+ const gchar *property_name,
+ GValue * value);
+
+gboolean ges_track_element_get_child_property (GESTrackElement *object,
+ const gchar *property_name,
+ GValue * value);
+
+gboolean
+ges_track_element_edit (GESTrackElement * object,
+ GList *layers, GESEditMode mode,
+ GESEdge edge, guint64 position);
+
+G_END_DECLS
+#endif /* _GES_TRACK_ELEMENT */
*/
#include "ges-internal.h"
-#include "ges-track-object.h"
+#include "ges-track-element.h"
#include "ges-track-filesource.h"
#include "ges-uri-asset.h"
#include "ges-extractable.h"
static void
extractable_set_asset (GESExtractable * self, GESAsset * asset)
{
- /* FIXME That should go into #GESTrackObject, but
+ /* FIXME That should go into #GESTrackElement, but
* some work is needed to make sure it works properly */
- if (ges_track_object_get_track_type (GES_TRACK_OBJECT (self)) ==
+ if (ges_track_element_get_track_type (GES_TRACK_ELEMENT (self)) ==
GES_TRACK_TYPE_UNKNOWN) {
- ges_track_object_set_track_type (GES_TRACK_OBJECT (self),
- ges_asset_track_object_get_track_type (GES_ASSET_TRACK_OBJECT (asset)));
+ ges_track_element_set_track_type (GES_TRACK_ELEMENT (self),
+ ges_asset_track_element_get_track_type (GES_ASSET_TRACK_ELEMENT
+ (asset)));
}
}
}
static GstElement *
-ges_track_filesource_create_gnl_object (GESTrackObject * object)
+ges_track_filesource_create_gnl_object (GESTrackElement * object)
{
GstElement *gnlobject;
ges_track_filesource_class_init (GESTrackFileSourceClass * klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
- GESTrackObjectClass *track_class = GES_TRACK_OBJECT_CLASS (klass);
+ GESTrackElementClass *track_class = GES_TRACK_ELEMENT_CLASS (klass);
g_type_class_add_private (klass, sizeof (GESTrackFileSourcePrivate));
*/
#include "ges-internal.h"
-#include "ges-track-object.h"
+#include "ges-track-element.h"
#include "ges-track-image-source.h"
G_DEFINE_TYPE (GESTrackImageSource, ges_track_image_source,
}
static GstElement *
-ges_track_image_source_create_element (GESTrackObject * object)
+ges_track_image_source_create_element (GESTrackElement * object)
{
GstElement *bin, *source, *scale, *freeze, *iconv;
GstPad *src, *target;
ges_track_image_source_class_init (GESTrackImageSourceClass * klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
- GESTrackObjectClass *gesobj_class = GES_TRACK_OBJECT_CLASS (klass);
+ GESTrackElementClass *gesobj_class = GES_TRACK_ELEMENT_CLASS (klass);
g_type_class_add_private (klass, sizeof (GESTrackImageSourcePrivate));
+++ /dev/null
-/* GStreamer Editing Services
- * Copyright (C) 2009 Edward Hervey <edward.hervey@collabora.co.uk>
- * 2009 Nokia Corporation
- *
- * 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:ges-track-object
- * @short_description: Base Class for objects contained in a GESTrack
- *
- * #GESTrackObject is the Base Class for any object that can be contained in a
- * #GESTrack.
- *
- * It contains the basic information as to the location of the object within
- * its container, like the start position, the inpoint, the duration and the
- * priority.
- */
-
-#include "ges-internal.h"
-#include "ges-extractable.h"
-#include "ges-track-object.h"
-#include "ges-clip.h"
-#include "ges-meta-container.h"
-#include <gobject/gvaluecollector.h>
-
-G_DEFINE_ABSTRACT_TYPE (GESTrackObject, ges_track_object,
- GES_TYPE_TIMELINE_ELEMENT);
-
-struct _GESTrackObjectPrivate
-{
- GESTrackType track_type;
-
- /* These fields are only used before the gnlobject is available */
- guint64 pending_start;
- guint64 pending_inpoint;
- guint64 pending_duration;
- guint32 pending_priority;
- gboolean pending_active;
-
- GstElement *gnlobject; /* The GnlObject */
- GstElement *element; /* The element contained in the gnlobject (can be NULL) */
-
- /* We keep a link between properties name and elements internally
- * The hashtable should look like
- * {GParamaSpec ---> element,}*/
- GHashTable *properties_hashtable;
-
- GESClip *timelineobj;
- GESTrack *track;
-
- gboolean valid;
-
- gboolean locked; /* If TRUE, then moves in sync with its controlling
- * GESClip */
-};
-
-enum
-{
- PROP_0,
- PROP_ACTIVE,
- PROP_LOCKED,
- PROP_TRACK_TYPE,
- PROP_TRACK,
- PROP_LAST
-};
-
-static GParamSpec *properties[PROP_LAST];
-
-enum
-{
- DEEP_NOTIFY,
- LAST_SIGNAL
-};
-
-static guint ges_track_object_signals[LAST_SIGNAL] = { 0 };
-
-static GstElement *ges_track_object_create_gnl_object_func (GESTrackObject *
- object);
-
-static void gnlobject_start_cb (GstElement * gnlobject, GParamSpec * arg
- G_GNUC_UNUSED, GESTrackObject * obj);
-
-static void gnlobject_media_start_cb (GstElement * gnlobject, GParamSpec * arg
- G_GNUC_UNUSED, GESTrackObject * obj);
-
-static void gnlobject_priority_cb (GstElement * gnlobject, GParamSpec * arg
- G_GNUC_UNUSED, GESTrackObject * obj);
-
-static void gnlobject_duration_cb (GstElement * gnlobject, GParamSpec * arg
- G_GNUC_UNUSED, GESTrackObject * obj);
-
-static void gnlobject_active_cb (GstElement * gnlobject, GParamSpec * arg
- G_GNUC_UNUSED, GESTrackObject * obj);
-
-static void connect_properties_signals (GESTrackObject * object);
-static void connect_signal (gpointer key, gpointer value, gpointer user_data);
-static void gst_element_prop_changed_cb (GstElement * element, GParamSpec * arg
- G_GNUC_UNUSED, GESTrackObject * obj);
-
-static gboolean _set_start (GESTimelineElement * element, GstClockTime start);
-static gboolean _set_inpoint (GESTimelineElement * element,
- GstClockTime inpoint);
-static gboolean _set_duration (GESTimelineElement * element,
- GstClockTime duration);
-static gboolean _set_priority (GESTimelineElement * element, guint32 priority);
-static void _deep_copy (GESTimelineElement * element,
- GESTimelineElement * copy);
-
-static inline void
-ges_track_object_set_locked_internal (GESTrackObject * object, gboolean locked);
-
-static GParamSpec **default_list_children_properties (GESTrackObject * object,
- guint * n_properties);
-
-static void
-ges_track_object_get_property (GObject * object, guint property_id,
- GValue * value, GParamSpec * pspec)
-{
- GESTrackObject *tobj = GES_TRACK_OBJECT (object);
-
- switch (property_id) {
- case PROP_ACTIVE:
- g_value_set_boolean (value, ges_track_object_is_active (tobj));
- break;
- case PROP_LOCKED:
- g_value_set_boolean (value, ges_track_object_is_locked (tobj));
- break;
- case PROP_TRACK_TYPE:
- g_value_set_flags (value, tobj->priv->track_type);
- break;
- case PROP_TRACK:
- g_value_set_object (value, tobj->priv->track);
- break;
- default:
- G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
- }
-}
-
-static void
-ges_track_object_set_property (GObject * object, guint property_id,
- const GValue * value, GParamSpec * pspec)
-{
- GESTrackObject *tobj = GES_TRACK_OBJECT (object);
-
- switch (property_id) {
- case PROP_ACTIVE:
- ges_track_object_set_active (tobj, g_value_get_boolean (value));
- break;
- case PROP_LOCKED:
- ges_track_object_set_locked_internal (tobj, g_value_get_boolean (value));
- break;
- case PROP_TRACK_TYPE:
- tobj->priv->track_type = g_value_get_flags (value);
- break;
- default:
- G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
- }
-}
-
-static void
-ges_track_object_dispose (GObject * object)
-{
- GESTrackObjectPrivate *priv = GES_TRACK_OBJECT (object)->priv;
-
- if (priv->properties_hashtable)
- g_hash_table_destroy (priv->properties_hashtable);
-
- if (priv->gnlobject) {
- GstState cstate;
-
- if (priv->track != NULL) {
- GST_ERROR_OBJECT (object, "Still in %p, this means that you forgot"
- " to remove it from the GESTrack it is contained in. You always need"
- " to remove a GESTrackObject from its track before dropping the last"
- " reference\n"
- "This problem may also be caused by a refcounting bug in"
- " the application or GES itself.", priv->track);
- gst_element_get_state (priv->gnlobject, &cstate, NULL, 0);
- if (cstate != GST_STATE_NULL)
- gst_element_set_state (priv->gnlobject, GST_STATE_NULL);
- }
-
- gst_object_unref (priv->gnlobject);
- priv->gnlobject = NULL;
- }
-
- G_OBJECT_CLASS (ges_track_object_parent_class)->dispose (object);
-}
-
-static void
-ges_track_object_finalize (GObject * object)
-{
- G_OBJECT_CLASS (ges_track_object_parent_class)->finalize (object);
-}
-
-static void
-ges_track_object_class_init (GESTrackObjectClass * klass)
-{
- GObjectClass *object_class = G_OBJECT_CLASS (klass);
- GESTimelineElementClass *element_class = GES_TIMELINE_ELEMENT_CLASS (klass);
-
- g_type_class_add_private (klass, sizeof (GESTrackObjectPrivate));
-
- object_class->get_property = ges_track_object_get_property;
- object_class->set_property = ges_track_object_set_property;
- object_class->dispose = ges_track_object_dispose;
- object_class->finalize = ges_track_object_finalize;
-
-
- /**
- * GESTrackObject:active:
- *
- * Whether the object should be taken into account in the #GESTrack output.
- * If #FALSE, then its contents will not be used in the resulting track.
- */
- properties[PROP_ACTIVE] =
- g_param_spec_boolean ("active", "Active", "Use object in output", TRUE,
- G_PARAM_READWRITE);
- g_object_class_install_property (object_class, PROP_ACTIVE,
- properties[PROP_ACTIVE]);
-
- /**
- * GESTrackObject:locked:
- *
- * If %TRUE, then moves in sync with its controlling #GESClip
- */
- properties[PROP_LOCKED] =
- g_param_spec_boolean ("locked", "Locked",
- "Moves in sync with its controling Clip", TRUE, G_PARAM_READWRITE);
- g_object_class_install_property (object_class, PROP_LOCKED,
- properties[PROP_LOCKED]);
-
- properties[PROP_TRACK_TYPE] = g_param_spec_flags ("track-type", "Track Type",
- "The track type of the object", GES_TYPE_TRACK_TYPE,
- GES_TRACK_TYPE_UNKNOWN, G_PARAM_READWRITE | G_PARAM_CONSTRUCT);
- g_object_class_install_property (object_class, PROP_TRACK_TYPE,
- properties[PROP_TRACK_TYPE]);
-
- properties[PROP_TRACK] = g_param_spec_object ("track", "Track",
- "The track the object is in", GES_TYPE_TRACK, G_PARAM_READABLE);
- g_object_class_install_property (object_class, PROP_TRACK,
- properties[PROP_TRACK]);
-
-
- /**
- * GESTrackObject::deep-notify:
- * @track_object: a #GESTrackObject
- * @prop_object: the object that originated the signal
- * @prop: the property that changed
- *
- * The deep notify signal is used to be notified of property changes of all
- * the childs of @track_object
- *
- * Since: 0.10.2
- */
- ges_track_object_signals[DEEP_NOTIFY] =
- g_signal_new ("deep-notify", G_TYPE_FROM_CLASS (klass),
- G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE | G_SIGNAL_DETAILED |
- G_SIGNAL_NO_HOOKS, 0, NULL, NULL, g_cclosure_marshal_generic,
- G_TYPE_NONE, 2, GST_TYPE_ELEMENT, G_TYPE_PARAM);
-
- element_class->set_start = _set_start;
- element_class->set_duration = _set_duration;
- element_class->set_inpoint = _set_inpoint;
- element_class->set_priority = _set_priority;
- element_class->deep_copy = _deep_copy;
-
- klass->create_gnl_object = ges_track_object_create_gnl_object_func;
- /* There is no 'get_props_hashtable' default implementation */
- klass->get_props_hastable = NULL;
- klass->list_children_properties = default_list_children_properties;
-}
-
-static void
-ges_track_object_init (GESTrackObject * self)
-{
- GESTrackObjectPrivate *priv = self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
- GES_TYPE_TRACK_OBJECT, GESTrackObjectPrivate);
-
- /* Sane default values */
- priv->pending_start = 0;
- priv->pending_inpoint = 0;
- priv->pending_duration = GST_SECOND;
- priv->pending_priority = 1;
- priv->pending_active = TRUE;
- priv->locked = TRUE;
- priv->properties_hashtable = NULL;
-}
-
-static gboolean
-_set_start (GESTimelineElement * element, GstClockTime start)
-{
- GESTrackObject *object = GES_TRACK_OBJECT (element);
-
- GST_DEBUG ("object:%p, start:%" GST_TIME_FORMAT,
- object, GST_TIME_ARGS (start));
-
- if (object->priv->gnlobject != NULL) {
- if (G_UNLIKELY (start == _START (object)))
- return FALSE;
-
- g_object_set (object->priv->gnlobject, "start", start, NULL);
- } else
- object->priv->pending_start = start;
-
- return TRUE;
-}
-
-static gboolean
-_set_inpoint (GESTimelineElement * element, GstClockTime inpoint)
-{
- GESTrackObject *object = GES_TRACK_OBJECT (element);
-
- GST_DEBUG ("object:%p, inpoint:%" GST_TIME_FORMAT,
- object, GST_TIME_ARGS (inpoint));
-
- if (object->priv->gnlobject != NULL) {
- if (G_UNLIKELY (inpoint == _INPOINT (object)))
-
- return FALSE;
-
- g_object_set (object->priv->gnlobject, "media-start", inpoint, NULL);
- } else
- object->priv->pending_inpoint = inpoint;
-
- return TRUE;
-}
-
-static gboolean
-_set_duration (GESTimelineElement * element, GstClockTime duration)
-{
- GESTrackObject *object = GES_TRACK_OBJECT (element);
- GESTrackObjectPrivate *priv = object->priv;
-
- GST_DEBUG ("object:%p, duration:%" GST_TIME_FORMAT,
- object, GST_TIME_ARGS (duration));
-
- if (GST_CLOCK_TIME_IS_VALID (_MAXDURATION (element)) &&
- duration > _INPOINT (object) + _MAXDURATION (element))
- duration = _MAXDURATION (element) - _INPOINT (object);
-
- if (priv->gnlobject != NULL) {
- if (G_UNLIKELY (duration == _DURATION (object)))
- return FALSE;
-
- g_object_set (priv->gnlobject, "duration", duration,
- "media-duration", duration, NULL);
- } else
- priv->pending_duration = duration;
-
- return TRUE;
-}
-
-static gboolean
-_set_priority (GESTimelineElement * element, guint32 priority)
-{
- GESTrackObject *object = GES_TRACK_OBJECT (element);
-
- GST_DEBUG ("object:%p, priority:%" G_GUINT32_FORMAT, object, priority);
-
- if (object->priv->gnlobject != NULL) {
- if (G_UNLIKELY (priority == _PRIORITY (object)))
- return FALSE;
-
- g_object_set (object->priv->gnlobject, "priority", priority, NULL);
- } else
- object->priv->pending_priority = priority;
-
- return TRUE;
-}
-
-/**
- * ges_track_object_set_active:
- * @object: a #GESTrackObject
- * @active: visibility
- *
- * Sets the usage of the @object. If @active is %TRUE, the object will be used for
- * playback and rendering, else it will be ignored.
- *
- * Returns: %TRUE if the property was toggled, else %FALSE
- */
-gboolean
-ges_track_object_set_active (GESTrackObject * object, gboolean active)
-{
- g_return_val_if_fail (GES_IS_TRACK_OBJECT (object), FALSE);
-
- GST_DEBUG ("object:%p, active:%d", object, active);
-
- if (object->priv->gnlobject != NULL) {
- if (G_UNLIKELY (active == object->active))
- return FALSE;
-
- g_object_set (object->priv->gnlobject, "active", active, NULL);
- } else
- object->priv->pending_active = active;
- return TRUE;
-}
-
-void
-ges_track_object_set_track_type (GESTrackObject * object, GESTrackType type)
-{
- g_return_if_fail (GES_IS_TRACK_OBJECT (object));
-
- if (object->priv->track_type != type) {
- object->priv->track_type = type;
- g_object_notify_by_pspec (G_OBJECT (object), properties[PROP_TRACK_TYPE]);
- }
-}
-
-GESTrackType
-ges_track_object_get_track_type (GESTrackObject * object)
-{
- g_return_val_if_fail (GES_IS_TRACK_OBJECT (object), GES_TRACK_TYPE_UNKNOWN);
-
- return object->priv->track_type;
-}
-
-/* Callbacks from the GNonLin object */
-static void
-gnlobject_start_cb (GstElement * gnlobject, GParamSpec * arg G_GNUC_UNUSED,
- GESTrackObject * obj)
-{
- guint64 start;
-
- g_object_get (gnlobject, "start", &start, NULL);
-
- GST_DEBUG ("gnlobject start : %" GST_TIME_FORMAT " current : %"
- GST_TIME_FORMAT, GST_TIME_ARGS (start), GST_TIME_ARGS (_START (obj)));
-
- if (start != _START (obj)) {
- _START (obj) = start;
- g_object_notify (G_OBJECT (obj), "start");
- }
-}
-
-static void
-gst_element_prop_changed_cb (GstElement * element, GParamSpec * arg
- G_GNUC_UNUSED, GESTrackObject * obj)
-{
- g_signal_emit (obj, ges_track_object_signals[DEEP_NOTIFY], 0,
- GST_ELEMENT (element), arg);
-}
-
-static void
-connect_signal (gpointer key, gpointer value, gpointer user_data)
-{
- gchar *signame = g_strconcat ("notify::", G_PARAM_SPEC (key)->name, NULL);
-
- g_signal_connect (G_OBJECT (value),
- signame, G_CALLBACK (gst_element_prop_changed_cb),
- GES_TRACK_OBJECT (user_data));
-
- g_free (signame);
-}
-
-static void
-connect_properties_signals (GESTrackObject * object)
-{
- if (G_UNLIKELY (!object->priv->properties_hashtable)) {
- GST_WARNING ("The properties_hashtable hasn't been set");
- return;
- }
-
- g_hash_table_foreach (object->priv->properties_hashtable,
- (GHFunc) connect_signal, object);
-
-}
-
-/* Callbacks from the GNonLin object */
-static void
-gnlobject_media_start_cb (GstElement * gnlobject,
- GParamSpec * arg G_GNUC_UNUSED, GESTrackObject * obj)
-{
- guint64 inpoint;
-
- g_object_get (gnlobject, "media-start", &inpoint, NULL);
-
- GST_DEBUG ("gnlobject in-point : %" GST_TIME_FORMAT " current : %"
- GST_TIME_FORMAT, GST_TIME_ARGS (inpoint), GST_TIME_ARGS (_INPOINT (obj)));
-
- if (inpoint != _INPOINT (obj)) {
- _INPOINT (obj) = inpoint;
- g_object_notify (G_OBJECT (obj), "in-point");
- }
-}
-
-static void
-gnlobject_priority_cb (GstElement * gnlobject, GParamSpec * arg G_GNUC_UNUSED,
- GESTrackObject * obj)
-{
- guint32 priority;
-
- g_object_get (gnlobject, "priority", &priority, NULL);
-
- GST_DEBUG ("gnlobject priority : %d current : %d", priority, _PRIORITY (obj));
-
- if (priority != _PRIORITY (obj)) {
- _PRIORITY (obj) = priority;
- g_object_notify (G_OBJECT (obj), "priority");
- }
-}
-
-static void
-gnlobject_duration_cb (GstElement * gnlobject, GParamSpec * arg G_GNUC_UNUSED,
- GESTrackObject * obj)
-{
- guint64 duration;
- GESTrackObjectClass *klass;
-
- klass = GES_TRACK_OBJECT_GET_CLASS (obj);
-
- g_object_get (gnlobject, "duration", &duration, NULL);
-
- GST_DEBUG_OBJECT (gnlobject, "duration : %" GST_TIME_FORMAT " current : %"
- GST_TIME_FORMAT, GST_TIME_ARGS (duration),
- GST_TIME_ARGS (_DURATION (obj)));
-
- if (duration != _DURATION (obj)) {
- _DURATION (obj) = duration;
- if (klass->duration_changed)
- klass->duration_changed (obj, duration);
- g_object_notify (G_OBJECT (obj), "duration");
- }
-}
-
-static void
-gnlobject_active_cb (GstElement * gnlobject, GParamSpec * arg G_GNUC_UNUSED,
- GESTrackObject * obj)
-{
- gboolean active;
- GESTrackObjectClass *klass;
-
- klass = GES_TRACK_OBJECT_GET_CLASS (obj);
-
- g_object_get (gnlobject, "active", &active, NULL);
-
- GST_DEBUG ("gnlobject active : %d current : %d", active, obj->active);
-
- if (active != obj->active) {
- obj->active = active;
- if (klass->active_changed)
- klass->active_changed (obj, active);
- }
-}
-
-
-/* default 'create_gnl_object' virtual method implementation */
-static GstElement *
-ges_track_object_create_gnl_object_func (GESTrackObject * self)
-{
- GESTrackObjectClass *klass = NULL;
- GstElement *child = NULL;
- GstElement *gnlobject;
-
- klass = GES_TRACK_OBJECT_GET_CLASS (self);
-
- if (G_UNLIKELY (self->priv->gnlobject != NULL))
- goto already_have_gnlobject;
-
- if (G_UNLIKELY (klass->gnlobject_factorytype == NULL))
- goto no_gnlfactory;
-
- GST_DEBUG ("Creating a supporting gnlobject of type '%s'",
- klass->gnlobject_factorytype);
-
- gnlobject = gst_element_factory_make (klass->gnlobject_factorytype, NULL);
-
- if (G_UNLIKELY (gnlobject == NULL))
- goto no_gnlobject;
-
- if (klass->create_element) {
- GST_DEBUG ("Calling subclass 'create_element' vmethod");
- child = klass->create_element (self);
-
- if (G_UNLIKELY (!child))
- goto child_failure;
-
- if (!gst_bin_add (GST_BIN (gnlobject), child))
- goto add_failure;
-
- GST_DEBUG ("Succesfully got the element to put in the gnlobject");
- self->priv->element = child;
- }
-
- GST_DEBUG ("done");
- return gnlobject;
-
-
- /* ERROR CASES */
-
-already_have_gnlobject:
- {
- GST_ERROR ("Already controlling a GnlObject %s",
- GST_ELEMENT_NAME (self->priv->gnlobject));
- return NULL;
- }
-
-no_gnlfactory:
- {
- GST_ERROR ("No GESTrackObject::gnlobject_factorytype implementation!");
- return NULL;
- }
-
-no_gnlobject:
- {
- GST_ERROR ("Error creating a gnlobject of type '%s'",
- klass->gnlobject_factorytype);
- return NULL;
- }
-
-child_failure:
- {
- GST_ERROR ("create_element returned NULL");
- gst_object_unref (gnlobject);
- return NULL;
- }
-
-add_failure:
- {
- GST_ERROR ("Error adding the contents to the gnlobject");
- gst_object_unref (child);
- gst_object_unref (gnlobject);
- return NULL;
- }
-}
-
-static gboolean
-ensure_gnl_object (GESTrackObject * object)
-{
- GESTrackObjectClass *class;
- GstElement *gnlobject;
- GHashTable *props_hash;
- gboolean res = TRUE;
-
- if (object->priv->gnlobject && object->priv->valid)
- return FALSE;
-
- /* 1. Create the GnlObject */
- GST_DEBUG ("Creating GnlObject");
-
- class = GES_TRACK_OBJECT_GET_CLASS (object);
-
- if (G_UNLIKELY (class->create_gnl_object == NULL)) {
- GST_ERROR ("No 'create_gnl_object' implementation !");
- goto done;
- }
-
- GST_DEBUG ("Calling virtual method");
-
- /* 2. Fill in the GnlObject */
- if (object->priv->gnlobject == NULL) {
-
- /* call the create_gnl_object virtual method */
- gnlobject = class->create_gnl_object (object);
-
- if (G_UNLIKELY (gnlobject == NULL)) {
- GST_ERROR
- ("'create_gnl_object' implementation returned TRUE but no GnlObject is available");
- goto done;
- }
-
- GST_DEBUG_OBJECT (object, "Got a valid GnlObject, now filling it in");
-
- object->priv->gnlobject = gst_object_ref (gnlobject);
-
- if (object->priv->timelineobj)
- res = ges_clip_fill_track_object (object->priv->timelineobj,
- object, object->priv->gnlobject);
- else
- res = TRUE;
-
- if (res) {
- /* Connect to property notifications */
- /* FIXME : remember the signalids so we can remove them later on !!! */
- g_signal_connect (G_OBJECT (object->priv->gnlobject), "notify::start",
- G_CALLBACK (gnlobject_start_cb), object);
- g_signal_connect (G_OBJECT (object->priv->gnlobject),
- "notify::media-start", G_CALLBACK (gnlobject_media_start_cb), object);
- g_signal_connect (G_OBJECT (object->priv->gnlobject), "notify::duration",
- G_CALLBACK (gnlobject_duration_cb), object);
- g_signal_connect (G_OBJECT (object->priv->gnlobject), "notify::priority",
- G_CALLBACK (gnlobject_priority_cb), object);
- g_signal_connect (G_OBJECT (object->priv->gnlobject), "notify::active",
- G_CALLBACK (gnlobject_active_cb), object);
-
- /* Set some properties on the GnlObject */
- g_object_set (object->priv->gnlobject,
- "duration", object->priv->pending_duration,
- "media-duration", object->priv->pending_duration,
- "start", object->priv->pending_start,
- "media-start", object->priv->pending_inpoint,
- "priority", object->priv->pending_priority,
- "active", object->priv->pending_active, NULL);
-
- if (object->priv->track != NULL)
- g_object_set (object->priv->gnlobject,
- "caps", ges_track_get_caps (object->priv->track), NULL);
-
- /* We feed up the props_hashtable if possible */
- if (class->get_props_hastable) {
- props_hash = class->get_props_hastable (object);
-
- if (props_hash == NULL) {
- GST_DEBUG ("'get_props_hastable' implementation returned TRUE but no"
- "properties_hashtable is available");
- } else {
- object->priv->properties_hashtable = props_hash;
- connect_properties_signals (object);
- }
- }
- }
- }
-
-done:
- object->priv->valid = res;
-
- GST_DEBUG ("Returning res:%d", res);
-
- return res;
-}
-
-/* INTERNAL USAGE */
-gboolean
-ges_track_object_set_track (GESTrackObject * object, GESTrack * track)
-{
- gboolean ret = TRUE;
- GST_DEBUG ("object:%p, track:%p", object, track);
-
- object->priv->track = track;
-
- if (object->priv->track) {
- /* If we already have a gnlobject, we just set its caps properly */
- if (object->priv->gnlobject) {
- g_object_set (object->priv->gnlobject,
- "caps", ges_track_get_caps (object->priv->track), NULL);
- } else {
- ret = ensure_gnl_object (object);
- }
- }
-
- g_object_notify_by_pspec (G_OBJECT (object), properties[PROP_TRACK]);
- return ret;
-}
-
-/**
- * ges_track_object_get_track:
- * @object: a #GESTrackObject
- *
- * Get the #GESTrack to which this object belongs.
- *
- * Returns: (transfer none): The #GESTrack to which this object belongs. Can be %NULL if it
- * is not in any track
- */
-GESTrack *
-ges_track_object_get_track (GESTrackObject * object)
-{
- g_return_val_if_fail (GES_IS_TRACK_OBJECT (object), NULL);
-
- return object->priv->track;
-}
-
-/**
- * ges_track_object_set_clip:
- * @object: The #GESTrackObject to set the parent to
- * @clipect: The #GESClip, parent of @clip or %NULL
- *
- * Set the #GESClip to which @object belongs.
- */
-void
-ges_track_object_set_clip (GESTrackObject * object, GESClip * clipect)
-{
- GST_DEBUG ("object:%p, clip:%p", object, clipect);
-
- object->priv->timelineobj = clipect;
-}
-
-/**
- * ges_track_object_get_clip:
- * @object: a #GESTrackObject
- *
- * Get the #GESClip which is controlling this track object
- *
- * Returns: (transfer none): the #GESClip which is controlling
- * this track object
- */
-GESClip *
-ges_track_object_get_clip (GESTrackObject * object)
-{
- g_return_val_if_fail (GES_IS_TRACK_OBJECT (object), NULL);
-
- return object->priv->timelineobj;
-}
-
-/**
- * ges_track_object_get_gnlobject:
- * @object: a #GESTrackObject
- *
- * Get the GNonLin object this object is controlling.
- *
- * Returns: (transfer none): the GNonLin object this object is controlling.
- */
-GstElement *
-ges_track_object_get_gnlobject (GESTrackObject * object)
-{
- g_return_val_if_fail (GES_IS_TRACK_OBJECT (object), NULL);
-
- return object->priv->gnlobject;
-}
-
-/**
- * ges_track_object_get_element:
- * @object: a #GESTrackObject
- *
- * Get the #GstElement this track object is controlling within GNonLin.
- *
- * Returns: (transfer none): the #GstElement this track object is controlling
- * within GNonLin.
- */
-GstElement *
-ges_track_object_get_element (GESTrackObject * object)
-{
- g_return_val_if_fail (GES_IS_TRACK_OBJECT (object), NULL);
-
- return object->priv->element;
-}
-
-static inline void
-ges_track_object_set_locked_internal (GESTrackObject * object, gboolean locked)
-{
- object->priv->locked = locked;
-}
-
-/**
- * ges_track_object_set_locked:
- * @object: a #GESTrackObject
- * @locked: whether the object is lock to its parent
- *
- * Set the locking status of the @object in relationship to its controlling
- * #GESClip. If @locked is %TRUE, then this object will move synchronously
- * with its controlling #GESClip.
- */
-void
-ges_track_object_set_locked (GESTrackObject * object, gboolean locked)
-{
- g_return_if_fail (GES_IS_TRACK_OBJECT (object));
-
- GST_DEBUG_OBJECT (object, "%s object", locked ? "Locking" : "Unlocking");
-
- ges_track_object_set_locked_internal (object, locked);
- g_object_notify_by_pspec (G_OBJECT (object), properties[PROP_LOCKED]);
-
-}
-
-/**
- * ges_track_object_is_locked:
- * @object: a #GESTrackObject
- *
- * Let you know if object us locked or not (moving synchronously).
- *
- * Returns: %TRUE if the object is moving synchronously to its controlling
- * #GESClip, else %FALSE.
- */
-gboolean
-ges_track_object_is_locked (GESTrackObject * object)
-{
- g_return_val_if_fail (GES_IS_TRACK_OBJECT (object), FALSE);
-
- return object->priv->locked;
-}
-
-
-/**
- * ges_track_object_is_active:
- * @object: a #GESTrackObject
- *
- * Lets you know if @object will be used for playback and rendering,
- * or not.
- *
- * Returns: %TRUE if @object is active, %FALSE otherwize
- *
- * Since: 0.10.2
- */
-gboolean
-ges_track_object_is_active (GESTrackObject * object)
-{
- g_return_val_if_fail (GES_IS_TRACK_OBJECT (object), FALSE);
-
- if (G_UNLIKELY (object->priv->gnlobject == NULL))
- return object->priv->pending_active;
- else
- return object->active;
-}
-
-/**
- * ges_track_object_lookup_child:
- * @object: object to lookup the property in
- * @prop_name: name of the property to look up. You can specify the name of the
- * class as such: "ClassName::property-name", to guarantee that you get the
- * proper GParamSpec in case various GstElement-s contain the same property
- * name. If you don't do so, you will get the first element found, having
- * this property and the and the corresponding GParamSpec.
- * @element: (out) (allow-none) (transfer full): pointer to a #GstElement that
- * takes the real object to set property on
- * @pspec: (out) (allow-none) (transfer full): pointer to take the #GParamSpec
- * describing the property
- *
- * Looks up which @element and @pspec would be effected by the given @name. If various
- * contained elements have this property name you will get the first one, unless you
- * specify the class name in @name.
- *
- * Returns: TRUE if @element and @pspec could be found. FALSE otherwise. In that
- * case the values for @pspec and @element are not modified. Unref @element after
- * usage.
- *
- * Since: 0.10.2
- */
-gboolean
-ges_track_object_lookup_child (GESTrackObject * object, const gchar * prop_name,
- GstElement ** element, GParamSpec ** pspec)
-{
- GHashTableIter iter;
- gpointer key, value;
- gchar **names, *name, *classename;
- gboolean res;
- GESTrackObjectPrivate *priv;
-
- g_return_val_if_fail (GES_IS_TRACK_OBJECT (object), FALSE);
-
- priv = object->priv;
-
- if (!priv->properties_hashtable)
- goto prop_hash_not_set;
-
- classename = NULL;
- res = FALSE;
-
- names = g_strsplit (prop_name, "::", 2);
- if (names[1] != NULL) {
- classename = names[0];
- name = names[1];
- } else
- name = names[0];
-
- g_hash_table_iter_init (&iter, priv->properties_hashtable);
- while (g_hash_table_iter_next (&iter, &key, &value)) {
- if (g_strcmp0 (G_PARAM_SPEC (key)->name, name) == 0) {
- if (classename == NULL ||
- g_strcmp0 (G_OBJECT_TYPE_NAME (G_OBJECT (value)), classename) == 0) {
- GST_DEBUG ("The %s property from %s has been found", name, classename);
- if (element)
- *element = g_object_ref (value);
-
- *pspec = g_param_spec_ref (key);
- res = TRUE;
- break;
- }
- }
- }
- g_strfreev (names);
-
- return res;
-
-prop_hash_not_set:
- {
- GST_WARNING_OBJECT (object, "The child properties haven't been set yet");
- return FALSE;
- }
-}
-
-/**
- * ges_track_object_set_child_property_by_pspec:
- * @object: a #GESTrackObject
- * @pspec: The #GParamSpec that specifies the property you want to set
- * @value: the value
- *
- * Sets a property of a child of @object.
- *
- * Since: 0.10.2
- */
-void
-ges_track_object_set_child_property_by_pspec (GESTrackObject * object,
- GParamSpec * pspec, GValue * value)
-{
- GstElement *element;
- GESTrackObjectPrivate *priv;
-
- g_return_if_fail (GES_IS_TRACK_OBJECT (object));
-
- priv = object->priv;
-
- if (!priv->properties_hashtable)
- goto prop_hash_not_set;
-
- element = g_hash_table_lookup (priv->properties_hashtable, pspec);
- if (!element)
- goto not_found;
-
- g_object_set_property (G_OBJECT (element), pspec->name, value);
-
- return;
-
-not_found:
- {
- GST_ERROR ("The %s property doesn't exist", pspec->name);
- return;
- }
-prop_hash_not_set:
- {
- GST_DEBUG ("The child properties haven't been set on %p", object);
- return;
- }
-}
-
-/**
- * ges_track_object_set_child_property_valist:
- * @object: The #GESTrackObject parent object
- * @first_property_name: The name of the first property to set
- * @var_args: value for the first property, followed optionally by more
- * name/return location pairs, followed by NULL
- *
- * Sets a property of a child of @object. If there are various child elements
- * that have the same property name, you can distinguish them using the following
- * syntax: 'ClasseName::property_name' as property name. If you don't, the
- * corresponding property of the first element found will be set.
- *
- * Since: 0.10.2
- */
-void
-ges_track_object_set_child_property_valist (GESTrackObject * object,
- const gchar * first_property_name, va_list var_args)
-{
- const gchar *name;
- GParamSpec *pspec;
- GstElement *element;
-
- gchar *error = NULL;
- GValue value = { 0, };
-
- g_return_if_fail (GES_IS_TRACK_OBJECT (object));
-
- name = first_property_name;
-
- /* Note: This part is in big part copied from the gst_child_object_set_valist
- * method. */
-
- /* iterate over pairs */
- while (name) {
- if (!ges_track_object_lookup_child (object, name, &element, &pspec))
- goto not_found;
-
-#if GLIB_CHECK_VERSION(2,23,3)
- G_VALUE_COLLECT_INIT (&value, pspec->value_type, var_args,
- G_VALUE_NOCOPY_CONTENTS, &error);
-#else
- g_value_init (&value, G_PARAM_SPEC_VALUE_TYPE (pspec));
- G_VALUE_COLLECT (&value, var_args, G_VALUE_NOCOPY_CONTENTS, &error);
-#endif
-
- if (error)
- goto cant_copy;
-
- g_object_set_property (G_OBJECT (element), pspec->name, &value);
-
- g_object_unref (element);
- g_value_unset (&value);
-
- name = va_arg (var_args, gchar *);
- }
- return;
-
-not_found:
- {
- GST_WARNING ("No property %s in OBJECT\n", name);
- return;
- }
-cant_copy:
- {
- GST_WARNING ("error copying value %s in object %p: %s", pspec->name, object,
- error);
- g_value_unset (&value);
- return;
- }
-}
-
-/**
- * ges_track_object_set_child_properties:
- * @object: The #GESTrackObject parent object
- * @first_property_name: The name of the first property to set
- * @...: value for the first property, followed optionally by more
- * name/return location pairs, followed by NULL
- *
- * Sets a property of a child of @object. If there are various child elements
- * that have the same property name, you can distinguish them using the following
- * syntax: 'ClasseName::property_name' as property name. If you don't, the
- * corresponding property of the first element found will be set.
- *
- * Since: 0.10.2
- */
-void
-ges_track_object_set_child_properties (GESTrackObject * object,
- const gchar * first_property_name, ...)
-{
- va_list var_args;
-
- g_return_if_fail (GES_IS_TRACK_OBJECT (object));
-
- va_start (var_args, first_property_name);
- ges_track_object_set_child_property_valist (object, first_property_name,
- var_args);
- va_end (var_args);
-}
-
-/**
- * ges_track_object_get_child_property_valist:
- * @object: The #GESTrackObject parent object
- * @first_property_name: The name of the first property to get
- * @var_args: value for the first property, followed optionally by more
- * name/return location pairs, followed by NULL
- *
- * Gets a property of a child of @object. If there are various child elements
- * that have the same property name, you can distinguish them using the following
- * syntax: 'ClasseName::property_name' as property name. If you don't, the
- * corresponding property of the first element found will be set.
- *
- * Since: 0.10.2
- */
-void
-ges_track_object_get_child_property_valist (GESTrackObject * object,
- const gchar * first_property_name, va_list var_args)
-{
- const gchar *name;
- gchar *error = NULL;
- GValue value = { 0, };
- GParamSpec *pspec;
- GstElement *element;
-
- g_return_if_fail (G_IS_OBJECT (object));
-
- name = first_property_name;
-
- /* This part is in big part copied from the gst_child_object_get_valist method */
- while (name) {
- if (!ges_track_object_lookup_child (object, name, &element, &pspec))
- goto not_found;
-
- g_value_init (&value, pspec->value_type);
- g_object_get_property (G_OBJECT (element), pspec->name, &value);
- g_object_unref (element);
-
- G_VALUE_LCOPY (&value, var_args, 0, &error);
- if (error)
- goto cant_copy;
- g_value_unset (&value);
- name = va_arg (var_args, gchar *);
- }
- return;
-
-not_found:
- {
- GST_WARNING ("no property %s in object", name);
- return;
- }
-cant_copy:
- {
- GST_WARNING ("error copying value %s in object %p: %s", pspec->name, object,
- error);
- g_value_unset (&value);
- return;
- }
-}
-
-/**
- * ges_track_object_list_children_properties:
- * @object: The #GESTrackObject to get the list of children properties from
- * @n_properties: (out): return location for the length of the returned array
- *
- * Gets an array of #GParamSpec* for all configurable properties of the
- * children of @object.
- *
- * Returns: (transfer full) (array length=n_properties): an array of #GParamSpec* which should be freed after use or
- * %NULL if something went wrong
- *
- * Since: 0.10.2
- */
-GParamSpec **
-ges_track_object_list_children_properties (GESTrackObject * object,
- guint * n_properties)
-{
- GESTrackObjectClass *class;
-
- g_return_val_if_fail (GES_IS_TRACK_OBJECT (object), NULL);
-
- class = GES_TRACK_OBJECT_GET_CLASS (object);
-
- return class->list_children_properties (object, n_properties);
-}
-
-/**
- * ges_track_object_get_child_properties:
- * @object: The origin #GESTrackObject
- * @first_property_name: The name of the first property to get
- * @...: return location for the first property, followed optionally by more
- * name/return location pairs, followed by NULL
- *
- * Gets properties of a child of @object.
- *
- * Since: 0.10.2
- */
-void
-ges_track_object_get_child_properties (GESTrackObject * object,
- const gchar * first_property_name, ...)
-{
- va_list var_args;
-
- g_return_if_fail (GES_IS_TRACK_OBJECT (object));
-
- va_start (var_args, first_property_name);
- ges_track_object_get_child_property_valist (object, first_property_name,
- var_args);
- va_end (var_args);
-}
-
-/**
- * ges_track_object_get_child_property_by_pspec:
- * @object: a #GESTrackObject
- * @pspec: The #GParamSpec that specifies the property you want to get
- * @value: (out): return location for the value
- *
- * Gets a property of a child of @object.
- *
- * Since: 0.10.2
- */
-void
-ges_track_object_get_child_property_by_pspec (GESTrackObject * object,
- GParamSpec * pspec, GValue * value)
-{
- GstElement *element;
- GESTrackObjectPrivate *priv;
-
- g_return_if_fail (GES_IS_TRACK_OBJECT (object));
-
- priv = object->priv;
-
- if (!priv->properties_hashtable)
- goto prop_hash_not_set;
-
- element = g_hash_table_lookup (priv->properties_hashtable, pspec);
- if (!element)
- goto not_found;
-
- g_object_get_property (G_OBJECT (element), pspec->name, value);
-
- return;
-
-not_found:
- {
- GST_ERROR ("The %s property doesn't exist", pspec->name);
- return;
- }
-prop_hash_not_set:
- {
- GST_ERROR ("The child properties haven't been set on %p", object);
- return;
- }
-}
-
-/**
- * ges_track_object_set_child_property:
- * @object: The origin #GESTrackObject
- * @property_name: The name of the property
- * @value: the value
- *
- * Sets a property of a GstElement contained in @object.
- *
- * Note that #ges_track_object_set_child_property is really
- * intended for language bindings, #ges_track_object_set_child_properties
- * is much more convenient for C programming.
- *
- * Returns: %TRUE if the property was set, %FALSE otherwize
- */
-gboolean
-ges_track_object_set_child_property (GESTrackObject * object,
- const gchar * property_name, GValue * value)
-{
- GParamSpec *pspec;
- GstElement *element;
-
- g_return_val_if_fail (GES_IS_TRACK_OBJECT (object), FALSE);
-
- if (!ges_track_object_lookup_child (object, property_name, &element, &pspec))
- goto not_found;
-
- g_object_set_property (G_OBJECT (element), pspec->name, value);
-
- g_object_unref (element);
- g_param_spec_unref (pspec);
-
- return TRUE;
-
-not_found:
- {
- GST_WARNING_OBJECT (object, "The %s property doesn't exist", property_name);
-
- return FALSE;
- }
-}
-
-/**
-* ges_track_object_get_child_property:
-* @object: The origin #GESTrackObject
-* @property_name: The name of the property
-* @value: (out): return location for the property value, it will
-* be initialized if it is initialized with 0
-*
-* In general, a copy is made of the property contents and
-* the caller is responsible for freeing the memory by calling
-* g_value_unset().
-*
-* Gets a property of a GstElement contained in @object.
-*
-* Note that #ges_track_object_get_child_property is really
-* intended for language bindings, #ges_track_object_get_child_properties
-* is much more convenient for C programming.
-*
-* Returns: %TRUE if the property was found, %FALSE otherwize
-*/
-gboolean
-ges_track_object_get_child_property (GESTrackObject * object,
- const gchar * property_name, GValue * value)
-{
- GParamSpec *pspec;
- GstElement *element;
-
- g_return_val_if_fail (GES_IS_TRACK_OBJECT (object), FALSE);
-
- if (!ges_track_object_lookup_child (object, property_name, &element, &pspec))
- goto not_found;
-
- if (G_VALUE_TYPE (value) == G_TYPE_INVALID)
- g_value_init (value, pspec->value_type);
-
- g_object_get_property (G_OBJECT (element), pspec->name, value);
-
- g_object_unref (element);
- g_param_spec_unref (pspec);
-
- return TRUE;
-
-not_found:
- {
- GST_WARNING_OBJECT (object, "The %s property doesn't exist", property_name);
-
- return FALSE;
- }
-}
-
-static GParamSpec **
-default_list_children_properties (GESTrackObject * object, guint * n_properties)
-{
- GParamSpec **pspec, *spec;
- GHashTableIter iter;
- gpointer key, value;
-
- guint i = 0;
-
- if (!object->priv->properties_hashtable)
- goto prop_hash_not_set;
-
- *n_properties = g_hash_table_size (object->priv->properties_hashtable);
- pspec = g_new (GParamSpec *, *n_properties);
-
- g_hash_table_iter_init (&iter, object->priv->properties_hashtable);
- while (g_hash_table_iter_next (&iter, &key, &value)) {
- spec = G_PARAM_SPEC (key);
- pspec[i] = g_param_spec_ref (spec);
- i++;
- }
-
- return pspec;
-
-prop_hash_not_set:
- {
- *n_properties = 0;
- GST_DEBUG_OBJECT (object, "No child properties have been set yet");
- return NULL;
- }
-}
-
-void
-_deep_copy (GESTimelineElement * element, GESTimelineElement * elementcopy)
-{
- GParamSpec **specs;
- guint n, n_specs;
- GValue val = { 0 };
- GESTrackObject *copy = GES_TRACK_OBJECT (elementcopy);
-
- ensure_gnl_object (copy);
- specs =
- ges_track_object_list_children_properties (GES_TRACK_OBJECT (element),
- &n_specs);
- for (n = 0; n < n_specs; ++n) {
- g_value_init (&val, specs[n]->value_type);
- g_object_get_property (G_OBJECT (element), specs[n]->name, &val);
- ges_track_object_set_child_property_by_pspec (copy, specs[n], &val);
- g_value_unset (&val);
- }
-
- g_free (specs);
-}
-
-/**
- * ges_track_object_edit:
- * @object: the #GESTrackObject to edit
- * @layers: (element-type GESTimelineLayer): The layers you want the edit to
- * happen in, %NULL means that the edition is done in all the
- * #GESTimelineLayers contained in the current timeline.
- * FIXME: This is not implemented yet.
- * @mode: The #GESEditMode in which the editition will happen.
- * @edge: The #GESEdge the edit should happen on.
- * @position: The position at which to edit @object (in nanosecond)
- *
- * Edit @object in the different exisiting #GESEditMode modes. In the case of
- * slide, and roll, you need to specify a #GESEdge
- *
- * Returns: %TRUE if the object as been edited properly, %FALSE if an error
- * occured
- *
- * Since: 0.10.XX
- */
-gboolean
-ges_track_object_edit (GESTrackObject * object,
- GList * layers, GESEditMode mode, GESEdge edge, guint64 position)
-{
- GESTrack *track = ges_track_object_get_track (object);
- GESTimeline *timeline;
-
- g_return_val_if_fail (GES_IS_TRACK_OBJECT (object), FALSE);
-
- if (G_UNLIKELY (!track)) {
- GST_WARNING_OBJECT (object, "Trying to edit in %d mode but not in"
- "any Track yet.", mode);
- return FALSE;
- }
-
- timeline = GES_TIMELINE (ges_track_get_timeline (track));
-
- if (G_UNLIKELY (!timeline)) {
- GST_WARNING_OBJECT (object, "Trying to edit in %d mode but not in"
- "track %p no in any timeline yet.", mode, track);
- return FALSE;
- }
-
- switch (mode) {
- case GES_EDIT_MODE_NORMAL:
- timeline_move_object (timeline, object, layers, edge, position);
- break;
- case GES_EDIT_MODE_TRIM:
- timeline_trim_object (timeline, object, layers, edge, position);
- break;
- case GES_EDIT_MODE_RIPPLE:
- timeline_ripple_object (timeline, object, layers, edge, position);
- break;
- case GES_EDIT_MODE_ROLL:
- timeline_roll_object (timeline, object, layers, edge, position);
- break;
- case GES_EDIT_MODE_SLIDE:
- timeline_slide_object (timeline, object, layers, edge, position);
- break;
- default:
- GST_ERROR ("Unkown edit mode: %d", mode);
- return FALSE;
- }
-
- return TRUE;
-}
+++ /dev/null
-/* GStreamer Editing Services
- * Copyright (C) 2009 Edward Hervey <edward.hervey@collabora.co.uk>
- * 2009 Nokia Corporation
- *
- * 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.
- */
-
-#ifndef _GES_TRACK_OBJECT
-#define _GES_TRACK_OBJECT
-
-#include <glib-object.h>
-#include <gst/gst.h>
-#include <ges/ges-types.h>
-#include <ges/ges-clip.h>
-#include <ges/ges-track.h>
-
-G_BEGIN_DECLS
-
-#define GES_TYPE_TRACK_OBJECT ges_track_object_get_type()
-
-#define GES_TRACK_OBJECT(obj) \
- (G_TYPE_CHECK_INSTANCE_CAST ((obj), GES_TYPE_TRACK_OBJECT, GESTrackObject))
-
-#define GES_TRACK_OBJECT_CLASS(klass) \
- (G_TYPE_CHECK_CLASS_CAST ((klass), GES_TYPE_TRACK_OBJECT, GESTrackObjectClass))
-
-#define GES_IS_TRACK_OBJECT(obj) \
- (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GES_TYPE_TRACK_OBJECT))
-
-#define GES_IS_TRACK_OBJECT_CLASS(klass) \
- (G_TYPE_CHECK_CLASS_TYPE ((klass), GES_TYPE_TRACK_OBJECT))
-
-#define GES_TRACK_OBJECT_GET_CLASS(obj) \
- (G_TYPE_INSTANCE_GET_CLASS ((obj), GES_TYPE_TRACK_OBJECT, GESTrackObjectClass))
-
-typedef struct _GESTrackObjectPrivate GESTrackObjectPrivate;
-
-/**
- * GESTrackObject:
- *
- * The GESTrackObject base class.
- */
-struct _GESTrackObject {
- GESTimelineElement parent;
-
- /*< private >*/
- gboolean active;
-
- GESTrackObjectPrivate *priv;
-
- GESAsset *asset;
-
- /* Padding for API extension */
- gpointer _ges_reserved[GES_PADDING_LARGE];
-};
-
-/**
- * GESTrackObjectClass:
- * @gnlobject_factorytype: name of the GNonLin GStElementFactory type to use.
- * @create_gnl_object: method to create the GNonLin container object.
- * @create_element: method to return the GstElement to put in the gnlobject.
- * @duration_changed: duration property glnobject has changed
- * @active_changed: active property of gnlobject has changed
- * @get_props_hastable: method to list children properties that user could like
- * to configure. Since: 0.10.2
- * @list_children_properties: method to get children properties that user could
- * like to configure.
- * The default implementation will create an object
- * of type @gnlobject_factorytype and call
- * @create_element. Since: 0.10.2
- *
- * Subclasses can override the @create_gnl_object method to override what type
- * of GNonLin object will be created.
- */
-struct _GESTrackObjectClass {
- /*< private >*/
- GESTimelineElementClass parent_class;
-
- /*< public >*/
- /* virtual methods for subclasses */
- const gchar *gnlobject_factorytype;
- GstElement* (*create_gnl_object) (GESTrackObject * object);
- GstElement* (*create_element) (GESTrackObject * object);
-
- void (*duration_changed) (GESTrackObject *object, guint64 duration);
- void (*active_changed) (GESTrackObject *object, gboolean active);
-
- /*< private >*/
- /* signals (currently unused) */
- void (*changed) (GESTrackObject * object);
-
- /*< public >*/
- /* virtual methods for subclasses */
- GHashTable* (*get_props_hastable) (GESTrackObject * object);
- GParamSpec** (*list_children_properties) (GESTrackObject * object,
- guint *n_properties);
- /*< private >*/
- /* Padding for API extension */
- gpointer _ges_reserved[GES_PADDING_LARGE];
-};
-
-GType ges_track_object_get_type (void);
-
-gboolean ges_track_object_set_track (GESTrackObject * object,
- GESTrack * track);
-GESTrack* ges_track_object_get_track (GESTrackObject * object);
-
-GESTrackType ges_track_object_get_track_type (GESTrackObject * object);
-void ges_track_object_set_track_type (GESTrackObject * object,
- GESTrackType type);
-
-void ges_track_object_set_clip (GESTrackObject * object,
- GESClip * clipect);
-GESClip *
-ges_track_object_get_clip (GESTrackObject* object);
-
-GstElement * ges_track_object_get_gnlobject (GESTrackObject * object);
-
-GstElement * ges_track_object_get_element (GESTrackObject * object);
-
-void ges_track_object_set_locked (GESTrackObject * object,
- gboolean locked);
-
-gboolean ges_track_object_is_locked (GESTrackObject * object);
-
-gboolean ges_track_object_set_active (GESTrackObject * object,
- gboolean active);
-
-gboolean ges_track_object_is_active (GESTrackObject * object);
-
-GParamSpec **
-ges_track_object_list_children_properties (GESTrackObject *object,
- guint *n_properties);
-
-gboolean ges_track_object_lookup_child (GESTrackObject *object,
- const gchar *prop_name,
- GstElement **element,
- GParamSpec **pspec);
-
-void
-ges_track_object_get_child_property_by_pspec (GESTrackObject * object,
- GParamSpec * pspec,
- GValue * value);
-
-void
-ges_track_object_get_child_property_valist (GESTrackObject * object,
- const gchar * first_property_name,
- va_list var_args);
-
-void ges_track_object_get_child_properties (GESTrackObject *object,
- const gchar * first_property_name,
- ...) G_GNUC_NULL_TERMINATED;
-
-void
-ges_track_object_set_child_property_valist (GESTrackObject * object,
- const gchar * first_property_name,
- va_list var_args);
-
-void
-ges_track_object_set_child_property_by_pspec (GESTrackObject * object,
- GParamSpec * pspec,
- GValue * value);
-
-void ges_track_object_set_child_properties (GESTrackObject * object,
- const gchar * first_property_name,
- ...) G_GNUC_NULL_TERMINATED;
-
-gboolean ges_track_object_set_child_property (GESTrackObject *object,
- const gchar *property_name,
- GValue * value);
-
-gboolean ges_track_object_get_child_property (GESTrackObject *object,
- const gchar *property_name,
- GValue * value);
-
-gboolean
-ges_track_object_edit (GESTrackObject * object,
- GList *layers, GESEditMode mode,
- GESEdge edge, guint64 position);
-
-G_END_DECLS
-#endif /* _GES_TRACK_OBJECT */
*/
#include "ges-internal.h"
-#include "ges-track-object.h"
+#include "ges-track-element.h"
#include "ges-track-operation.h"
G_DEFINE_ABSTRACT_TYPE (GESTrackOperation, ges_track_operation,
- GES_TYPE_TRACK_OBJECT);
+ GES_TYPE_TRACK_ELEMENT);
struct _GESTrackOperationPrivate
{
static void
ges_track_operation_class_init (GESTrackOperationClass * klass)
{
- GESTrackObjectClass *track_class = GES_TRACK_OBJECT_CLASS (klass);
+ GESTrackElementClass *track_class = GES_TRACK_ELEMENT_CLASS (klass);
g_type_class_add_private (klass, sizeof (GESTrackOperationPrivate));
#include <glib-object.h>
#include <gst/gst.h>
#include <ges/ges-types.h>
-#include <ges/ges-track-object.h>
+#include <ges/ges-track-element.h>
G_BEGIN_DECLS
struct _GESTrackOperation {
/*< private >*/
- GESTrackObject parent;
+ GESTrackElement parent;
GESTrackOperationPrivate *priv;
struct _GESTrackOperationClass {
/*< private >*/
- GESTrackObjectClass parent_class;
+ GESTrackElementClass parent_class;
/*< private >*/
/* Padding for API extension */
#include "ges-internal.h"
#include "ges-extractable.h"
-#include "ges-track-object.h"
+#include "ges-track-element.h"
#include "ges-track-effect.h"
#include "ges-track-parse-launch-effect.h"
static void ges_track_parse_launch_effect_dispose (GObject * object);
static void ges_track_parse_launch_effect_finalize (GObject * object);
-static GstElement *ges_track_parse_launch_effect_create_element (GESTrackObject
+static GstElement *ges_track_parse_launch_effect_create_element (GESTrackElement
* self);
struct _GESTrackParseLaunchEffectPrivate
klass)
{
GObjectClass *object_class;
- GESTrackObjectClass *obj_bg_class;
+ GESTrackElementClass *obj_bg_class;
object_class = G_OBJECT_CLASS (klass);
- obj_bg_class = GES_TRACK_OBJECT_CLASS (klass);
+ obj_bg_class = GES_TRACK_ELEMENT_CLASS (klass);
g_type_class_add_private (klass, sizeof (GESTrackParseLaunchEffectPrivate));
}
static GstElement *
-ges_track_parse_launch_effect_create_element (GESTrackObject * object)
+ges_track_parse_launch_effect_create_element (GESTrackElement * object)
{
GstElement *effect;
gchar *bin_desc;
GError *error = NULL;
GESTrackParseLaunchEffect *self = GES_TRACK_PARSE_LAUNCH_EFFECT (object);
- GESTrack *track = ges_track_object_get_track (object);
+ GESTrack *track = ges_track_element_get_track (object);
if (!track) {
GST_WARNING
*/
#include "ges-internal.h"
-#include "ges-track-object.h"
+#include "ges-track-element.h"
#include "ges-track-source.h"
-G_DEFINE_TYPE (GESTrackSource, ges_track_source, GES_TYPE_TRACK_OBJECT);
+G_DEFINE_TYPE (GESTrackSource, ges_track_source, GES_TYPE_TRACK_ELEMENT);
struct _GESTrackSourcePrivate
{
static void
ges_track_source_class_init (GESTrackSourceClass * klass)
{
- GESTrackObjectClass *track_class = GES_TRACK_OBJECT_CLASS (klass);
+ GESTrackElementClass *track_class = GES_TRACK_ELEMENT_CLASS (klass);
g_type_class_add_private (klass, sizeof (GESTrackSourcePrivate));
#include <glib-object.h>
#include <gst/gst.h>
#include <ges/ges-types.h>
-#include <ges/ges-track-object.h>
+#include <ges/ges-track-element.h>
G_BEGIN_DECLS
struct _GESTrackSource {
/*< private >*/
- GESTrackObject parent;
+ GESTrackElement parent;
GESTrackSourcePrivate *priv;
struct _GESTrackSourceClass {
/*< private >*/
- GESTrackObjectClass parent_class;
+ GESTrackElementClass parent_class;
/*< private >*/
/* Padding for API extension */
*/
#include "ges-internal.h"
-#include "ges-track-object.h"
+#include "ges-track-element.h"
#include "ges-track-title-source.h"
#include "ges-track-text-overlay.h"
static void ges_track_text_overlay_set_property (GObject * object, guint
property_id, const GValue * value, GParamSpec * pspec);
-static GstElement *ges_track_text_overlay_create_element (GESTrackObject
+static GstElement *ges_track_text_overlay_create_element (GESTrackElement
* self);
static void
ges_track_text_overlay_class_init (GESTrackTextOverlayClass * klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
- GESTrackObjectClass *bg_class = GES_TRACK_OBJECT_CLASS (klass);
+ GESTrackElementClass *bg_class = GES_TRACK_ELEMENT_CLASS (klass);
g_type_class_add_private (klass, sizeof (GESTrackTextOverlayPrivate));
}
static GstElement *
-ges_track_text_overlay_create_element (GESTrackObject * object)
+ges_track_text_overlay_create_element (GESTrackElement * object)
{
GstElement *ret, *text, *iconv, *oconv;
GstPad *src_target, *sink_target;
*/
#include "ges-internal.h"
-#include "ges-track-object.h"
+#include "ges-track-element.h"
#include "ges-track-title-source.h"
#include "ges-track-video-test-source.h"
static void ges_track_title_source_set_property (GObject * object, guint
property_id, const GValue * value, GParamSpec * pspec);
-static GstElement *ges_track_title_source_create_element (GESTrackObject *
+static GstElement *ges_track_title_source_create_element (GESTrackElement *
self);
static void
ges_track_title_source_class_init (GESTrackTitleSourceClass * klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
- GESTrackObjectClass *bg_class = GES_TRACK_OBJECT_CLASS (klass);
+ GESTrackElementClass *bg_class = GES_TRACK_ELEMENT_CLASS (klass);
g_type_class_add_private (klass, sizeof (GESTrackTitleSourcePrivate));
}
static GstElement *
-ges_track_title_source_create_element (GESTrackObject * object)
+ges_track_title_source_create_element (GESTrackElement * object)
{
GESTrackTitleSource *self = GES_TRACK_TITLE_SOURCE (object);
GESTrackTitleSourcePrivate *priv = self->priv;
*/
#include "ges-internal.h"
-#include "ges-track-object.h"
+#include "ges-track-element.h"
#include "ges-track-video-test-source.h"
G_DEFINE_TYPE (GESTrackVideoTestSource, ges_track_video_test_source,
GESVideoTestPattern pattern;
};
-static GstElement *ges_track_video_test_source_create_element (GESTrackObject *
+static GstElement *ges_track_video_test_source_create_element (GESTrackElement *
self);
static void
ges_track_video_test_source_class_init (GESTrackVideoTestSourceClass * klass)
{
- GESTrackObjectClass *track_object_class = GES_TRACK_OBJECT_CLASS (klass);
+ GESTrackElementClass *track_element_class = GES_TRACK_ELEMENT_CLASS (klass);
g_type_class_add_private (klass, sizeof (GESTrackVideoTestSourcePrivate));
- track_object_class->create_element =
+ track_element_class->create_element =
ges_track_video_test_source_create_element;
}
}
static GstElement *
-ges_track_video_test_source_create_element (GESTrackObject * self)
+ges_track_video_test_source_create_element (GESTrackElement * self)
{
GstElement *ret;
gint pattern;
ges_track_video_test_source_set_pattern (GESTrackVideoTestSource
* self, GESVideoTestPattern pattern)
{
- GstElement *element = ges_track_object_get_element (GES_TRACK_OBJECT (self));
+ GstElement *element =
+ ges_track_element_get_element (GES_TRACK_ELEMENT (self));
self->priv->pattern = pattern;
GstElement ** smpteref);
static void
-ges_track_video_transition_duration_changed (GESTrackObject * self,
+ges_track_video_transition_duration_changed (GESTrackElement * self,
guint64 duration);
-static GstElement *ges_track_video_transition_create_element (GESTrackObject
+static GstElement *ges_track_video_transition_create_element (GESTrackElement
* self);
static void ges_track_video_transition_dispose (GObject * object);
ges_track_video_transition_class_init (GESTrackVideoTransitionClass * klass)
{
GObjectClass *object_class;
- GESTrackObjectClass *toclass;
+ GESTrackElementClass *toclass;
g_type_class_add_private (klass, sizeof (GESTrackVideoTransitionPrivate));
g_object_class_install_property (object_class, PROP_INVERT,
properties[PROP_INVERT]);
- toclass = GES_TRACK_OBJECT_CLASS (klass);
+ toclass = GES_TRACK_ELEMENT_CLASS (klass);
toclass->duration_changed = ges_track_video_transition_duration_changed;
toclass->create_element = ges_track_video_transition_create_element;
}
}
static GstElement *
-ges_track_video_transition_create_element (GESTrackObject * object)
+ges_track_video_transition_create_element (GESTrackElement * object)
{
GstElement *topbin, *iconva, *iconvb, *scalea, *scaleb, *capsfilt, *oconv;
GstObject *target = NULL;
priv->end_value = 0.0;
set_interpolation (GST_OBJECT (smptealphab), priv, (gchar *) "position");
- ges_track_video_transition_duration_changed (GES_TRACK_OBJECT (transition),
+ ges_track_video_transition_duration_changed (GES_TRACK_ELEMENT (transition),
priv->dur);
priv->start_value = 0.0;
priv->end_value = 1.0;
set_interpolation (GST_OBJECT (priv->sinkb), priv, (gchar *) "alpha");
- ges_track_video_transition_duration_changed (GES_TRACK_OBJECT (transition),
+ ges_track_video_transition_duration_changed (GES_TRACK_ELEMENT (transition),
priv->dur);
priv->smpte = NULL;
}
static void
-ges_track_video_transition_duration_changed (GESTrackObject * object,
+ges_track_video_transition_duration_changed (GESTrackElement * object,
guint64 duration)
{
- GstElement *gnlobj = ges_track_object_get_gnlobject (object);
+ GstElement *gnlobj = ges_track_element_get_gnlobject (object);
GESTrackVideoTransition *self = GES_TRACK_VIDEO_TRANSITION (object);
GESTrackVideoTransitionPrivate *priv = self->priv;
GstTimedValueControlSource *ts;
*
* Corresponds to one output format (i.e. audio OR video).
*
- * Contains the compatible TrackObject(s).
+ * Contains the compatible TrackElement(s).
*
* Wraps GNonLin's 'gnlcomposition' element.
*/
#include "ges-internal.h"
#include "ges-track.h"
-#include "ges-track-object.h"
+#include "ges-track-element.h"
#include "ges-meta-container.h"
G_DEFINE_TYPE_WITH_CODE (GESTrack, ges_track, GST_TYPE_BIN,
{
/*< private > */
GESTimeline *timeline;
- GSequence *tckobjs_by_start;
- GHashTable *tckobjs_iter;
+ GSequence *trackelements_by_start;
+ GHashTable *trackelements_iter;
GList *gaps;
guint64 duration;
ARG_TYPE,
ARG_DURATION,
ARG_LAST,
- TRACK_OBJECT_ADDED,
- TRACK_OBJECT_REMOVED,
+ TRACK_ELEMENT_ADDED,
+ TRACK_ELEMENT_REMOVED,
LAST_SIGNAL
};
/* Private methods/functions/callbacks */
static void
-add_trackobj_to_list_foreach (GESTrackObject * trackobj, GList ** list)
+add_trackelement_to_list_foreach (GESTrackElement * trackelement, GList ** list)
{
- g_object_ref (trackobj);
- *list = g_list_prepend (*list, trackobj);
+ g_object_ref (trackelement);
+ *list = g_list_prepend (*list, trackelement);
}
static Gap *
Gap *gap;
GSequenceIter *it;
- GESTrackObject *tckobj;
+ GESTrackElement *trackelement;
GstClockTime start, end, duration = 0, timeline_duration;
GESTrackPrivate *priv = track->priv;
priv->gaps = NULL;
/* 2- And recalculate gaps */
- for (it = g_sequence_get_begin_iter (priv->tckobjs_by_start);
+ for (it = g_sequence_get_begin_iter (priv->trackelements_by_start);
g_sequence_iter_is_end (it) == FALSE; it = g_sequence_iter_next (it)) {
- tckobj = g_sequence_get (it);
+ trackelement = g_sequence_get (it);
- start = _START (tckobj);
- end = start + _DURATION (tckobj);
+ start = _START (trackelement);
+ end = start + _DURATION (trackelement);
if (start > duration) {
/* 3- Fill gap */
static inline void
resort_and_fill_gaps (GESTrack * track)
{
- g_sequence_sort (track->priv->tckobjs_by_start,
+ g_sequence_sort (track->priv->trackelements_by_start,
(GCompareDataFunc) element_start_compare, NULL);
if (track->priv->updating == TRUE) {
}
static void
-sort_track_objects_cb (GESTrackObject * child,
+sort_track_elements_cb (GESTrackElement * child,
GParamSpec * arg G_GNUC_UNUSED, GESTrack * track)
{
resort_and_fill_gaps (track);
* accessing it
*/
static gboolean
-remove_object_internal (GESTrack * track, GESTrackObject * object)
+remove_object_internal (GESTrack * track, GESTrackElement * object)
{
GESTrackPrivate *priv;
GstElement *gnlobject;
priv = track->priv;
- if (G_UNLIKELY (ges_track_object_get_track (object) != track)) {
+ if (G_UNLIKELY (ges_track_element_get_track (object) != track)) {
GST_WARNING ("Object belongs to another track");
return FALSE;
}
- if ((gnlobject = ges_track_object_get_gnlobject (object))) {
+ if ((gnlobject = ges_track_element_get_gnlobject (object))) {
GST_DEBUG ("Removing GnlObject '%s' from composition '%s'",
GST_ELEMENT_NAME (gnlobject), GST_ELEMENT_NAME (priv->composition));
gst_element_set_state (gnlobject, GST_STATE_NULL);
}
- g_signal_handlers_disconnect_by_func (object, sort_track_objects_cb, NULL);
+ g_signal_handlers_disconnect_by_func (object, sort_track_elements_cb, NULL);
- ges_track_object_set_track (object, NULL);
+ ges_track_element_set_track (object, NULL);
- g_signal_emit (track, ges_track_signals[TRACK_OBJECT_REMOVED], 0,
- GES_TRACK_OBJECT (object));
+ g_signal_emit (track, ges_track_signals[TRACK_ELEMENT_REMOVED], 0,
+ GES_TRACK_ELEMENT (object));
g_object_unref (object);
}
static void
-dispose_tckobjs_foreach (GESTrackObject * tckobj, GESTrack * track)
+dispose_trackelements_foreach (GESTrackElement * trackelement, GESTrack * track)
{
GESClip *clip;
- clip = ges_track_object_get_clip (tckobj);
+ clip = ges_track_element_get_clip (trackelement);
- remove_object_internal (track, tckobj);
- ges_clip_release_track_object (clip, tckobj);
+ remove_object_internal (track, trackelement);
+ ges_clip_release_track_element (clip, trackelement);
}
/* GObject virtual methods */
GESTrack *track = (GESTrack *) object;
GESTrackPrivate *priv = track->priv;
- /* Remove all TrackObjects and drop our reference */
- g_hash_table_unref (priv->tckobjs_iter);
- g_sequence_foreach (track->priv->tckobjs_by_start,
- (GFunc) dispose_tckobjs_foreach, track);
- g_sequence_free (priv->tckobjs_by_start);
+ /* Remove all TrackElements and drop our reference */
+ g_hash_table_unref (priv->trackelements_iter);
+ g_sequence_foreach (track->priv->trackelements_by_start,
+ (GFunc) dispose_trackelements_foreach, track);
+ g_sequence_free (priv->trackelements_by_start);
g_list_free_full (priv->gaps, (GDestroyNotify) free_gap);
if (priv->composition) {
/**
* GESTrack::track-object-added:
* @object: the #GESTrack
- * @effect: the #GESTrackObject that was added.
+ * @effect: the #GESTrackElement that was added.
*
* Will be emitted after a track object was added to the track.
*
* Since: 0.10.2
*/
- ges_track_signals[TRACK_OBJECT_ADDED] =
+ ges_track_signals[TRACK_ELEMENT_ADDED] =
g_signal_new ("track-object-added", G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST, 0, NULL, NULL, g_cclosure_marshal_generic,
- G_TYPE_NONE, 1, GES_TYPE_TRACK_OBJECT);
+ G_TYPE_NONE, 1, GES_TYPE_TRACK_ELEMENT);
/**
* GESTrack::track-object-removed:
* @object: the #GESTrack
- * @effect: the #GESTrackObject that was removed.
+ * @effect: the #GESTrackElement that was removed.
*
* Will be emitted after a track object was removed from the track.
*
* Since: 0.10.2
*/
- ges_track_signals[TRACK_OBJECT_REMOVED] =
+ ges_track_signals[TRACK_ELEMENT_REMOVED] =
g_signal_new ("track-object-removed", G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_FIRST, 0, NULL, NULL, g_cclosure_marshal_generic,
- G_TYPE_NONE, 1, GES_TYPE_TRACK_OBJECT);
+ G_TYPE_NONE, 1, GES_TYPE_TRACK_ELEMENT);
}
static void
self->priv->composition = gst_element_factory_make ("gnlcomposition", NULL);
self->priv->updating = TRUE;
- self->priv->tckobjs_by_start = g_sequence_new (NULL);
- self->priv->tckobjs_iter = g_hash_table_new (g_direct_hash, g_direct_equal);
+ self->priv->trackelements_by_start = g_sequence_new (NULL);
+ self->priv->trackelements_iter =
+ g_hash_table_new (g_direct_hash, g_direct_equal);
self->priv->create_element_for_gaps = NULL;
self->priv->gaps = NULL;
priv->caps = gst_caps_copy (caps);
g_object_set (priv->composition, "caps", caps, NULL);
- /* FIXME : update all trackobjects ? */
+ /* FIXME : update all trackelements ? */
}
/**
* ges_track_add_object:
* @track: a #GESTrack
- * @object: (transfer full): the #GESTrackObject to add
+ * @object: (transfer full): the #GESTrackElement to add
*
* Adds the given object to the track. Sets the object's controlling track,
* and thus takes ownership of the @object.
* want to accept the object.
*/
gboolean
-ges_track_add_object (GESTrack * track, GESTrackObject * object)
+ges_track_add_object (GESTrack * track, GESTrackElement * object)
{
g_return_val_if_fail (GES_IS_TRACK (track), FALSE);
- g_return_val_if_fail (GES_IS_TRACK_OBJECT (object), FALSE);
+ g_return_val_if_fail (GES_IS_TRACK_ELEMENT (object), FALSE);
GST_DEBUG ("track:%p, object:%p", track, object);
- if (G_UNLIKELY (ges_track_object_get_track (object) != NULL)) {
+ if (G_UNLIKELY (ges_track_element_get_track (object) != NULL)) {
GST_WARNING ("Object already belongs to another track");
return FALSE;
}
- if (G_UNLIKELY (!ges_track_object_set_track (object, track))) {
+ if (G_UNLIKELY (!ges_track_element_set_track (object, track))) {
GST_ERROR ("Couldn't properly add the object to the Track");
return FALSE;
}
GST_DEBUG ("Adding object %s to ourself %s",
- GST_OBJECT_NAME (ges_track_object_get_gnlobject (object)),
+ GST_OBJECT_NAME (ges_track_element_get_gnlobject (object)),
GST_OBJECT_NAME (track->priv->composition));
if (G_UNLIKELY (!gst_bin_add (GST_BIN (track->priv->composition),
- ges_track_object_get_gnlobject (object)))) {
+ ges_track_element_get_gnlobject (object)))) {
GST_WARNING ("Couldn't add object to the GnlComposition");
return FALSE;
}
g_object_ref_sink (object);
- g_hash_table_insert (track->priv->tckobjs_iter, object,
- g_sequence_insert_sorted (track->priv->tckobjs_by_start, object,
+ g_hash_table_insert (track->priv->trackelements_iter, object,
+ g_sequence_insert_sorted (track->priv->trackelements_by_start, object,
(GCompareDataFunc) element_start_compare, NULL));
- g_signal_emit (track, ges_track_signals[TRACK_OBJECT_ADDED], 0,
- GES_TRACK_OBJECT (object));
+ g_signal_emit (track, ges_track_signals[TRACK_ELEMENT_ADDED], 0,
+ GES_TRACK_ELEMENT (object));
- g_signal_connect (GES_TRACK_OBJECT (object), "notify::start",
- G_CALLBACK (sort_track_objects_cb), track);
+ g_signal_connect (GES_TRACK_ELEMENT (object), "notify::start",
+ G_CALLBACK (sort_track_elements_cb), track);
- g_signal_connect (GES_TRACK_OBJECT (object), "notify::duration",
- G_CALLBACK (sort_track_objects_cb), track);
+ g_signal_connect (GES_TRACK_ELEMENT (object), "notify::duration",
+ G_CALLBACK (sort_track_elements_cb), track);
- g_signal_connect (GES_TRACK_OBJECT (object), "notify::priority",
- G_CALLBACK (sort_track_objects_cb), track);
+ g_signal_connect (GES_TRACK_ELEMENT (object), "notify::priority",
+ G_CALLBACK (sort_track_elements_cb), track);
resort_and_fill_gaps (track);
* ges_track_get_objects:
* @track: a #GESTrack
*
- * Gets the #GESTrackObject contained in @track
+ * Gets the #GESTrackElement contained in @track
*
- * Returns: (transfer full) (element-type GESTrackObject): the list of
- * #GESTrackObject present in the Track sorted by priority and start.
+ * Returns: (transfer full) (element-type GESTrackElement): the list of
+ * #GESTrackElement present in the Track sorted by priority and start.
*/
GList *
ges_track_get_objects (GESTrack * track)
g_return_val_if_fail (GES_IS_TRACK (track), NULL);
- g_sequence_foreach (track->priv->tckobjs_by_start,
- (GFunc) add_trackobj_to_list_foreach, &ret);
+ g_sequence_foreach (track->priv->trackelements_by_start,
+ (GFunc) add_trackelement_to_list_foreach, &ret);
ret = g_list_reverse (ret);
return ret;
/**
* ges_track_remove_object:
* @track: a #GESTrack
- * @object: the #GESTrackObject to remove
+ * @object: the #GESTrackElement to remove
*
* Removes the object from the track and unparents it.
* Unparenting it means the reference owned by @track on the @object will be
* could not remove the object (like if it didn't belong to the track).
*/
gboolean
-ges_track_remove_object (GESTrack * track, GESTrackObject * object)
+ges_track_remove_object (GESTrack * track, GESTrackElement * object)
{
GSequenceIter *it;
GESTrackPrivate *priv;
g_return_val_if_fail (GES_IS_TRACK (track), FALSE);
- g_return_val_if_fail (GES_IS_TRACK_OBJECT (object), FALSE);
+ g_return_val_if_fail (GES_IS_TRACK_ELEMENT (object), FALSE);
priv = track->priv;
if (remove_object_internal (track, object) == TRUE) {
- it = g_hash_table_lookup (priv->tckobjs_iter, object);
+ it = g_hash_table_lookup (priv->trackelements_iter, object);
g_sequence_remove (it);
resort_and_fill_gaps (track);
const GESTimeline *ges_track_get_timeline (GESTrack *track);
gboolean ges_track_add_object (GESTrack * track,
- GESTrackObject * object);
+ GESTrackElement * object);
gboolean ges_track_remove_object (GESTrack * track,
- GESTrackObject * object);
+ GESTrackElement * object);
GESTrack *ges_track_video_raw_new (void);
GESTrack *ges_track_audio_raw_new (void);
PROP_VTYPE = 5,
};
-static GESTrackObject *ges_tl_transition_create_track_object (GESClip
+static GESTrackElement *ges_tl_transition_create_track_element (GESClip
* self, GESTrackType type);
static void
-ges_transition_clip_track_object_added (GESClip * obj, GESTrackObject * tckobj);
-static void
-ges_transition_clip_track_object_released (GESClip * obj,
- GESTrackObject * tckobj);
+ges_transition_clip_track_element_added (GESClip * obj,
+ GESTrackElement * trackelement);
+static void ges_transition_clip_track_element_released (GESClip * obj,
+ GESTrackElement * trackelement);
/* Internal methods */
static void
G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
- timobj_class->create_track_object = ges_tl_transition_create_track_object;
+ timobj_class->create_track_element = ges_tl_transition_create_track_element;
timobj_class->need_fill_track = FALSE;
- timobj_class->track_object_added = ges_transition_clip_track_object_added;
- timobj_class->track_object_released =
- ges_transition_clip_track_object_released;
+ timobj_class->track_element_added = ges_transition_clip_track_element_added;
+ timobj_class->track_element_released =
+ ges_transition_clip_track_element_released;
}
static void
}
static void
-ges_transition_clip_track_object_released (GESClip * obj,
- GESTrackObject * tckobj)
+ges_transition_clip_track_element_released (GESClip * obj,
+ GESTrackElement * trackelement)
{
GESTransitionClipPrivate *priv = GES_TRANSITION_CLIP (obj)->priv;
- /* If this is called, we should be sure the tckobj exists */
- if (GES_IS_TRACK_VIDEO_TRANSITION (tckobj)) {
- GST_DEBUG ("GESTrackVideoTransition %p released from %p", tckobj, obj);
+ /* If this is called, we should be sure the trackelement exists */
+ if (GES_IS_TRACK_VIDEO_TRANSITION (trackelement)) {
+ GST_DEBUG ("GESTrackVideoTransition %p released from %p", trackelement,
+ obj);
priv->track_video_transitions =
- g_slist_remove (priv->track_video_transitions, tckobj);
- g_object_unref (tckobj);
+ g_slist_remove (priv->track_video_transitions, trackelement);
+ g_object_unref (trackelement);
}
}
static void
-ges_transition_clip_track_object_added (GESClip * obj, GESTrackObject * tckobj)
+ges_transition_clip_track_element_added (GESClip * obj,
+ GESTrackElement * trackelement)
{
GESTransitionClipPrivate *priv = GES_TRANSITION_CLIP (obj)->priv;
- if (GES_IS_TRACK_VIDEO_TRANSITION (tckobj)) {
- GST_DEBUG ("GESTrackVideoTransition %p added to %p", tckobj, obj);
+ if (GES_IS_TRACK_VIDEO_TRANSITION (trackelement)) {
+ GST_DEBUG ("GESTrackVideoTransition %p added to %p", trackelement, obj);
priv->track_video_transitions =
- g_slist_prepend (priv->track_video_transitions, g_object_ref (tckobj));
+ g_slist_prepend (priv->track_video_transitions,
+ g_object_ref (trackelement));
}
}
-static GESTrackObject *
-ges_tl_transition_create_track_object (GESClip * obj, GESTrackType type)
+static GESTrackElement *
+ges_tl_transition_create_track_element (GESClip * obj, GESTrackType type)
{
GESTransitionClip *transition = (GESTransitionClip *) obj;
- GESTrackObject *res = NULL;
+ GESTrackElement *res = NULL;
GESTrackType supportedformats;
GST_DEBUG ("Creating a GESTrackTransition");
trans = ges_track_video_transition_new ();
ges_track_video_transition_set_transition_type (trans, transition->vtype);
- res = GES_TRACK_OBJECT (trans);
+ res = GES_TRACK_ELEMENT (trans);
} else {
GST_DEBUG ("Not creating transition as video track not on"
" supportedformats");
if (supportedformats == GES_TRACK_TYPE_UNKNOWN ||
supportedformats & GES_TRACK_TYPE_AUDIO)
- res = GES_TRACK_OBJECT (ges_track_audio_transition_new ());
+ res = GES_TRACK_ELEMENT (ges_track_audio_transition_new ());
else
GST_DEBUG ("Not creating transition as audio track"
" not on supportedformats");
typedef struct _GESTrack GESTrack;
typedef struct _GESTrackClass GESTrackClass;
-typedef struct _GESTrackObject GESTrackObject;
-typedef struct _GESTrackObjectClass GESTrackObjectClass;
+typedef struct _GESTrackElement GESTrackElement;
+typedef struct _GESTrackElementClass GESTrackElementClass;
typedef struct _GESTrackSource GESTrackSource;
typedef struct _GESTrackSourceClass GESTrackSourceClass;
typedef struct _GESUriClipAsset GESUriClipAsset;
typedef struct _GESUriClipAssetClass GESUriClipAssetClass;
-typedef struct _GESAssetTrackObject GESAssetTrackObject;
-typedef struct _GESAssetTrackObjectClass GESAssetTrackObjectClass;
+typedef struct _GESAssetTrackElement GESAssetTrackElement;
+typedef struct _GESAssetTrackElementClass GESAssetTrackElementClass;
typedef struct _GESAssetTrackFileSource GESAssetTrackFileSource;
typedef struct _GESAssetTrackFileSourceClass GESAssetTrackFileSourceClass;
priv_tckasset->uri = ges_asset_get_id (GES_ASSET (asset));
priv_tckasset->sinfo = g_object_ref (sinfo);
priv_tckasset->parent_asset = asset;
- ges_asset_track_object_set_track_type (GES_ASSET_TRACK_OBJECT
+ ges_asset_track_element_set_track_type (GES_ASSET_TRACK_ELEMENT
(tck_filesource_asset), type);
priv->asset_trackfilesources = g_list_append (priv->asset_trackfilesources,
*/
G_DEFINE_TYPE (GESAssetTrackFileSource, ges_asset_track_filesource,
- GES_TYPE_ASSET_TRACK_OBJECT);
+ GES_TYPE_ASSET_TRACK_ELEMENT);
static GESExtractable *
_extract (GESAsset * asset, GError ** error)
{
- GESTrackObject *tckobj;
+ GESTrackElement *trackelement;
GESAssetTrackFileSourcePrivate *priv =
GES_ASSET_TRACK_FILESOURCE (asset)->priv;
return NULL;
}
- tckobj = GES_TRACK_OBJECT (ges_track_filesource_new (g_strdup (priv->uri)));
- ges_track_object_set_track_type (tckobj, priv->type);
+ trackelement =
+ GES_TRACK_ELEMENT (ges_track_filesource_new (g_strdup (priv->uri)));
+ ges_track_element_set_track_type (trackelement, priv->type);
- return GES_EXTRACTABLE (tckobj);
+ return GES_EXTRACTABLE (trackelement);
}
static void
struct _GESAssetTrackFileSource
{
- GESAssetTrackObject parent;
+ GESAssetTrackElement parent;
/* <private> */
GESAssetTrackFileSourcePrivate *priv;
struct _GESAssetTrackFileSourceClass
{
- GESAssetTrackObjectClass parent_class;
+ GESAssetTrackElementClass parent_class;
gpointer _ges_reserved[GES_PADDING];
};
};
-static GList *ges_uri_clip_create_track_objects (GESClip *
+static GList *ges_uri_clip_create_track_elements (GESClip *
obj, GESTrackType type);
-static GESTrackObject
- * ges_uri_clip_create_track_object (GESClip * obj, GESTrackType type);
+static GESTrackElement
+ * ges_uri_clip_create_track_element (GESClip * obj, GESTrackType type);
void ges_uri_clip_set_uri (GESUriClip * self, gchar * uri);
gboolean
* GESUriClip:is-image:
*
* Whether this filesource represents a still image or not. This must be set
- * before create_track_objects is called.
+ * before create_track_elements is called.
*/
g_object_class_install_property (object_class, PROP_IS_IMAGE,
g_param_spec_boolean ("is-image", "Is still image",
element_class->set_max_duration = filesource_set_max_duration;
- timobj_class->create_track_objects = ges_uri_clip_create_track_objects;
- timobj_class->create_track_object = ges_uri_clip_create_track_object;
+ timobj_class->create_track_elements = ges_uri_clip_create_track_elements;
+ timobj_class->create_track_element = ges_uri_clip_create_track_element;
timobj_class->need_fill_track = FALSE;
}
void
ges_uri_clip_set_mute (GESUriClip * self, gboolean mute)
{
- GList *tmp, *trackobjects;
+ GList *tmp, *trackelements;
GESClip *object = (GESClip *) self;
GST_DEBUG ("self:%p, mute:%d", self, mute);
self->priv->mute = mute;
/* Go over tracked objects, and update 'active' status on all audio objects */
- trackobjects = ges_clip_get_track_objects (object);
- for (tmp = trackobjects; tmp; tmp = tmp->next) {
- GESTrackObject *trackobject = (GESTrackObject *) tmp->data;
+ trackelements = ges_clip_get_track_elements (object);
+ for (tmp = trackelements; tmp; tmp = tmp->next) {
+ GESTrackElement *trackelement = (GESTrackElement *) tmp->data;
- if (ges_track_object_get_track (trackobject)->type == GES_TRACK_TYPE_AUDIO)
- ges_track_object_set_active (trackobject, !mute);
+ if (ges_track_element_get_track (trackelement)->type ==
+ GES_TRACK_TYPE_AUDIO)
+ ges_track_element_set_active (trackelement, !mute);
- g_object_unref (GES_TRACK_OBJECT (tmp->data));
+ g_object_unref (GES_TRACK_ELEMENT (tmp->data));
}
- g_list_free (trackobjects);
+ g_list_free (trackelements);
}
gboolean
}
static GList *
-ges_uri_clip_create_track_objects (GESClip * obj, GESTrackType type)
+ges_uri_clip_create_track_elements (GESClip * obj, GESTrackType type)
{
GList *res = NULL;
const GList *tmp, *stream_assets;
ges_uri_clip_asset_get_stream_assets (GES_URI_CLIP_ASSET
(GES_TIMELINE_ELEMENT (obj)->asset));
for (tmp = stream_assets; tmp; tmp = tmp->next) {
- GESAssetTrackObject *asset = GES_ASSET_TRACK_OBJECT (tmp->data);
+ GESAssetTrackElement *asset = GES_ASSET_TRACK_ELEMENT (tmp->data);
- if (ges_asset_track_object_get_track_type (asset) == type)
+ if (ges_asset_track_element_get_track_type (asset) == type)
res = g_list_prepend (res, ges_asset_extract (GES_ASSET (asset), NULL));
}
return res;
}
-static GESTrackObject *
-ges_uri_clip_create_track_object (GESClip * obj, GESTrackType type)
+static GESTrackElement *
+ges_uri_clip_create_track_element (GESClip * obj, GESTrackType type)
{
GESUriClipPrivate *priv = GES_URI_CLIP (obj)->priv;
- GESTrackObject *res;
+ GESTrackElement *res;
if (priv->is_image) {
if (type != GES_TRACK_TYPE_VIDEO) {
return NULL;
} else {
GST_DEBUG ("Creating a GESTrackImageSource");
- res = (GESTrackObject *) ges_track_image_source_new (priv->uri);
+ res = (GESTrackElement *) ges_track_image_source_new (priv->uri);
}
} else {
GST_DEBUG ("Creating a GESTrackFileSource");
/* FIXME : Implement properly ! */
- res = (GESTrackObject *) ges_track_filesource_new (priv->uri);
+ res = (GESTrackElement *) ges_track_filesource_new (priv->uri);
/* If mute and track is audio, deactivate the track object */
if (type == GES_TRACK_TYPE_AUDIO && priv->mute)
- ges_track_object_set_active (res, FALSE);
+ ges_track_element_set_active (res, FALSE);
}
if (res)
- ges_track_object_set_track_type (res, type);
+ ges_track_element_set_track_type (res, type);
return res;
}
ges_uri_clip_set_uri (GESUriClip * self, gchar * uri)
{
GESClip *clip = GES_CLIP (self);
- GList *tckobjs = ges_clip_get_track_objects (clip);
+ GList *trackelements = ges_clip_get_track_elements (clip);
- if (tckobjs) {
+ if (trackelements) {
/* FIXME handle this case properly */
GST_WARNING_OBJECT (clip, "Can not change uri when already"
- "containing TrackObjects");
+ "containing TrackElements");
return;
}
goto wrong_properties;
}
- ges_base_xml_formatter_add_track_object (GES_BASE_XML_FORMATTER (self),
+ ges_base_xml_formatter_add_track_element (GES_BASE_XML_FORMATTER (self),
type, asset_id, track_id, clip_id, children_props, props, metadatas,
error);
}
static inline void
-_save_effect (GString * str, guint clip_id, GESTrackObject * tckobj,
+_save_effect (GString * str, guint clip_id, GESTrackElement * trackelement,
GESTimeline * timeline)
{
GESTrack *tck;
GParamSpec **pspecs, *spec;
guint j, n_props = 0, track_id = 0;
- tck = ges_track_object_get_track (tckobj);
+ tck = ges_track_element_get_track (trackelement);
if (tck == NULL) {
- GST_WARNING_OBJECT (tckobj, " Not in any track, can not save it");
+ GST_WARNING_OBJECT (trackelement, " Not in any track, can not save it");
return;
}
}
g_list_free_full (tracks, gst_object_unref);
- properties = _serialize_properties (G_OBJECT (tckobj), "start",
+ properties = _serialize_properties (G_OBJECT (trackelement), "start",
"in-point", "duration", "locked", "max-duration", "name", NULL);
- metas = ges_meta_container_metas_to_string (GES_META_CONTAINER (tckobj));
- append_printf_escaped (str, "<effect asset-id='%s' clip-id='%u'"
+ metas =
+ ges_meta_container_metas_to_string (GES_META_CONTAINER (trackelement));
+ append_printf_escaped (str,
+ "<effect asset-id='%s' clip-id='%u'"
" type-name='%s' track-type='%i' track-id='%i' properties='%s' metadatas='%s'",
- ges_extractable_get_id (GES_EXTRACTABLE (tckobj)), clip_id,
- g_type_name (G_OBJECT_TYPE (tckobj)), tck->type, track_id, properties,
- metas);
+ ges_extractable_get_id (GES_EXTRACTABLE (trackelement)), clip_id,
+ g_type_name (G_OBJECT_TYPE (trackelement)), tck->type, track_id,
+ properties, metas);
g_free (properties);
g_free (metas);
- pspecs = ges_track_object_list_children_properties (tckobj, &n_props);
+ pspecs = ges_track_element_list_children_properties (trackelement, &n_props);
structure = gst_structure_new_empty ("properties");
for (j = 0; j < n_props; j++) {
GValue val = { 0 };
spec = pspecs[j];
if (_can_serialize_spec (spec)) {
_init_value_from_spec_for_serialization (&val, spec);
- ges_track_object_get_child_property_by_pspec (tckobj, spec, &val);
+ ges_track_element_get_child_property_by_pspec (trackelement, spec, &val);
gst_structure_set_value (structure, spec->name, &val);
g_value_unset (&val);
}
g_free (properties);
for (tmpeffect = effects; tmpeffect; tmpeffect = tmpeffect->next)
- _save_effect (str, nbclips, GES_TRACK_OBJECT (tmpeffect->data),
+ _save_effect (str, nbclips, GES_TRACK_ELEMENT (tmpeffect->data),
timeline);
g_string_append (str, "</clip>\n");
nbclips++;
#include <ges/ges-xml-formatter.h>
#include <ges/ges-track.h>
-#include <ges/ges-track-object.h>
+#include <ges/ges-track-element.h>
#include <ges/ges-track-source.h>
#include <ges/ges-track-operation.h>
GST_START_TEST (test_test_source_properties)
{
GESTrack *track;
- GESTrackObject *trackobject;
+ GESTrackElement *trackelement;
GESClip *object;
ges_init ();
assert_equals_uint64 (_DURATION (object), 51);
assert_equals_uint64 (_INPOINT (object), 12);
- trackobject = ges_clip_create_track_object (object, track->type);
- ges_clip_add_track_object (object, trackobject);
- fail_unless (trackobject != NULL);
- fail_unless (ges_track_object_set_track (trackobject, track));
+ trackelement = ges_clip_create_track_element (object, track->type);
+ ges_clip_add_track_element (object, trackelement);
+ fail_unless (trackelement != NULL);
+ fail_unless (ges_track_element_set_track (trackelement, track));
- /* Check that trackobject has the same properties */
- assert_equals_uint64 (_START (trackobject), 42);
- assert_equals_uint64 (_DURATION (trackobject), 51);
- assert_equals_uint64 (_INPOINT (trackobject), 12);
+ /* Check that trackelement has the same properties */
+ assert_equals_uint64 (_START (trackelement), 42);
+ assert_equals_uint64 (_DURATION (trackelement), 51);
+ assert_equals_uint64 (_INPOINT (trackelement), 12);
/* And let's also check that it propagated correctly to GNonLin */
- gnl_object_check (ges_track_object_get_gnlobject (trackobject), 42, 51, 12,
+ gnl_object_check (ges_track_element_get_gnlobject (trackelement), 42, 51, 12,
51, 0, TRUE);
/* Change more properties, see if they propagate */
assert_equals_uint64 (_START (object), 420);
assert_equals_uint64 (_DURATION (object), 510);
assert_equals_uint64 (_INPOINT (object), 120);
- assert_equals_uint64 (_START (trackobject), 420);
- assert_equals_uint64 (_DURATION (trackobject), 510);
- assert_equals_uint64 (_INPOINT (trackobject), 120);
+ assert_equals_uint64 (_START (trackelement), 420);
+ assert_equals_uint64 (_DURATION (trackelement), 510);
+ assert_equals_uint64 (_INPOINT (trackelement), 120);
/* And let's also check that it propagated correctly to GNonLin */
- gnl_object_check (ges_track_object_get_gnlobject (trackobject), 420, 510, 120,
- 510, 0, TRUE);
+ gnl_object_check (ges_track_element_get_gnlobject (trackelement), 420, 510,
+ 120, 510, 0, TRUE);
/* Test mute support */
g_object_set (object, "mute", TRUE, NULL);
- gnl_object_check (ges_track_object_get_gnlobject (trackobject), 420, 510, 120,
- 510, 0, FALSE);
+ gnl_object_check (ges_track_element_get_gnlobject (trackelement), 420, 510,
+ 120, 510, 0, FALSE);
g_object_set (object, "mute", FALSE, NULL);
- gnl_object_check (ges_track_object_get_gnlobject (trackobject), 420, 510, 120,
- 510, 0, TRUE);
+ gnl_object_check (ges_track_element_get_gnlobject (trackelement), 420, 510,
+ 120, 510, 0, TRUE);
- ges_clip_release_track_object (object, trackobject);
+ ges_clip_release_track_element (object, trackelement);
g_object_unref (object);
}
GESTimeline *timeline;
GESTimelineLayer *layer;
GESTrack *a, *v;
- GESTrackObject *trobj;
+ GESTrackElement *trobj;
GESTestClip *source;
GESVideoTestPattern ptrn;
gdouble freq, volume;
assert_equals_int (ptrn, GES_VIDEO_TEST_PATTERN_WHITE);
trobj =
- ges_clip_find_track_object (GES_CLIP (source), v,
+ ges_clip_find_track_element (GES_CLIP (source), v,
GES_TYPE_TRACK_VIDEO_TEST_SOURCE);
g_assert (GES_IS_TRACK_VIDEO_TEST_SOURCE (trobj));
/* test audio properties as well */
- trobj = ges_clip_find_track_object (GES_CLIP (source),
+ trobj = ges_clip_find_track_element (GES_CLIP (source),
a, GES_TYPE_TRACK_AUDIO_TEST_SOURCE);
g_assert (GES_IS_TRACK_AUDIO_TEST_SOURCE (trobj));
assert_equals_float (ges_test_clip_get_frequency (source), 440);
GST_START_TEST (test_gap_filling_basic)
{
GESTrack *track;
- GESTrackObject *trackobject, *trackobject1, *trackobject2;
+ GESTrackElement *trackelement, *trackelement1, *trackelement2;
/*GESTimelineLayer *layer; */
GESClip *object, *object1, *object2;
GstElement *gnlsrc, *gnlsrc1, *gap = NULL;
assert_equals_uint64 (_START (object), 0);
assert_equals_uint64 (_DURATION (object), 5);
- trackobject = ges_clip_create_track_object (object, track->type);
- ges_clip_add_track_object (object, trackobject);
+ trackelement = ges_clip_create_track_element (object, track->type);
+ ges_clip_add_track_element (object, trackelement);
- fail_unless (ges_track_add_object (track, trackobject));
- fail_unless (trackobject != NULL);
- gnlsrc = ges_track_object_get_gnlobject (trackobject);
+ fail_unless (ges_track_add_object (track, trackelement));
+ fail_unless (trackelement != NULL);
+ gnlsrc = ges_track_element_get_gnlobject (trackelement);
fail_unless (gnlsrc != NULL);
- /* Check that trackobject has the same properties */
- assert_equals_uint64 (_START (trackobject), 0);
- assert_equals_uint64 (_DURATION (trackobject), 5);
+ /* Check that trackelement has the same properties */
+ assert_equals_uint64 (_START (trackelement), 0);
+ assert_equals_uint64 (_DURATION (trackelement), 5);
/* Check no gap were wrongly added */
assert_equals_int (g_list_length (GST_BIN_CHILDREN (composition)), 1);
assert_equals_uint64 (_START (object1), 15);
assert_equals_uint64 (_DURATION (object1), 5);
- trackobject1 = ges_clip_create_track_object (object1, track->type);
- ges_clip_add_track_object (object1, trackobject1);
- fail_unless (ges_track_add_object (track, trackobject1));
- fail_unless (trackobject1 != NULL);
- gnlsrc1 = ges_track_object_get_gnlobject (trackobject1);
+ trackelement1 = ges_clip_create_track_element (object1, track->type);
+ ges_clip_add_track_element (object1, trackelement1);
+ fail_unless (ges_track_add_object (track, trackelement1));
+ fail_unless (trackelement1 != NULL);
+ gnlsrc1 = ges_track_element_get_gnlobject (trackelement1);
fail_unless (gnlsrc1 != NULL);
- /* Check that trackobject1 has the same properties */
- assert_equals_uint64 (_START (trackobject1), 15);
- assert_equals_uint64 (_DURATION (trackobject1), 5);
+ /* Check that trackelement1 has the same properties */
+ assert_equals_uint64 (_START (trackelement1), 15);
+ assert_equals_uint64 (_DURATION (trackelement1), 5);
/* Check the gap as properly been added */
assert_equals_int (g_list_length (GST_BIN_CHILDREN (composition)), 3);
object2 = GES_CLIP (ges_test_clip_new ());
fail_unless (object2 != NULL);
g_object_set (object2, "start", (guint64) 35, "duration", (guint64) 5, NULL);
- trackobject2 = ges_clip_create_track_object (object2, track->type);
- ges_clip_add_track_object (object2, trackobject2);
- fail_unless (ges_track_add_object (track, trackobject2));
- fail_unless (trackobject2 != NULL);
- assert_equals_uint64 (_START (trackobject2), 35);
- assert_equals_uint64 (_DURATION (trackobject2), 5);
+ trackelement2 = ges_clip_create_track_element (object2, track->type);
+ ges_clip_add_track_element (object2, trackelement2);
+ fail_unless (ges_track_add_object (track, trackelement2));
+ fail_unless (trackelement2 != NULL);
+ assert_equals_uint64 (_START (trackelement2), 35);
+ assert_equals_uint64 (_DURATION (trackelement2), 5);
assert_equals_int (g_list_length (GST_BIN_CHILDREN (composition)), 5);
gst_object_unref (track);
static gboolean
my_fill_track_func (GESClip * object,
- GESTrackObject * trobject, GstElement * gnlobj, gpointer user_data)
+ GESTrackElement * trobject, GstElement * gnlobj, gpointer user_data)
{
GstElement *src;
- GST_DEBUG ("timelineobj:%p, trackobject:%p, gnlobj:%p",
+ GST_DEBUG ("timelineobj:%p, trackelement:%p, gnlobj:%p",
object, trobject, gnlobj);
/* Let's just put a fakesource in for the time being */
GESTimelineLayer *layer, *tmp_layer;
GESTrack *track;
GESCustomSourceClip *source;
- GESTrackObject *trackobject;
- GList *trackobjects, *tmp, *layers, *tracks;
+ GESTrackElement *trackelement;
+ GList *trackelements, *tmp, *layers, *tracks;
ges_init ();
/* This is the simplest scenario ever */
g_object_unref (tmp_layer);
ASSERT_OBJECT_REFCOUNT (layer, "layer", 1);
- /* Make sure the associated TrackObject is in the Track */
- trackobjects = ges_clip_get_track_objects (GES_CLIP (source));
- fail_unless (trackobjects != NULL);
- trackobject = GES_TRACK_OBJECT (trackobjects->data);
+ /* Make sure the associated TrackElement is in the Track */
+ trackelements = ges_clip_get_track_elements (GES_CLIP (source));
+ fail_unless (trackelements != NULL);
+ trackelement = GES_TRACK_ELEMENT (trackelements->data);
/* There are 4 references:
* 1 by the clip
* 1 by the track
* 1 by the timeline
- * 1 added by the call to _get_track_objects() above */
- ASSERT_OBJECT_REFCOUNT (trackobject, "trackobject", 4);
- for (tmp = trackobjects; tmp; tmp = tmp->next) {
- g_object_unref (GES_TRACK_OBJECT (tmp->data));
+ * 1 added by the call to _get_track_elements() above */
+ ASSERT_OBJECT_REFCOUNT (trackelement, "trackelement", 4);
+ for (tmp = trackelements; tmp; tmp = tmp->next) {
+ g_object_unref (GES_TRACK_ELEMENT (tmp->data));
}
- g_list_free (trackobjects);
+ g_list_free (trackelements);
/* There are 3 references:
* 1 by the clip
* 1 by the timeline
* 1 by the track */
- ASSERT_OBJECT_REFCOUNT (trackobject, "trackobject", 3);
+ ASSERT_OBJECT_REFCOUNT (trackelement, "trackelement", 3);
GST_DEBUG ("Remove the Clip from the layer");
ASSERT_OBJECT_REFCOUNT (layer, "layer", 1);
tmp_layer = ges_clip_get_layer (GES_CLIP (source));
fail_unless (tmp_layer == NULL);
- trackobjects = ges_clip_get_track_objects (GES_CLIP (source));
- fail_unless (trackobjects == NULL); /* No unreffing then */
+ trackelements = ges_clip_get_track_elements (GES_CLIP (source));
+ fail_unless (trackelements == NULL); /* No unreffing then */
g_object_unref (source);
GST_DEBUG ("Removing track from the timeline");
GESTimelineLayer *layer, *tmp_layer;
GESTrack *track;
GESCustomSourceClip *s1, *s2, *s3;
- GList *trackobjects, *tmp, *layers;
- GESTrackObject *trackobject;
+ GList *trackelements, *tmp, *layers;
+ GESTrackElement *trackelement;
ges_init ();
g_list_foreach (layers, (GFunc) g_object_unref, NULL);
g_list_free (layers);
- /* Make sure the associated TrackObjects are in the Track */
- trackobjects = ges_clip_get_track_objects (GES_CLIP (s1));
- fail_unless (trackobjects != NULL);
- trackobject = GES_TRACK_OBJECT (trackobjects->data);
+ /* Make sure the associated TrackElements are in the Track */
+ trackelements = ges_clip_get_track_elements (GES_CLIP (s1));
+ fail_unless (trackelements != NULL);
+ trackelement = GES_TRACK_ELEMENT (trackelements->data);
/* There are 4 references:
* 1 by the clip
- * 1 by the trackobject
+ * 1 by the trackelement
* 1 by the timeline
- * 1 added by the call to _get_track_objects() above */
- ASSERT_OBJECT_REFCOUNT (trackobject, "trackobject", 4);
- for (tmp = trackobjects; tmp; tmp = tmp->next) {
- g_object_unref (GES_TRACK_OBJECT (tmp->data));
+ * 1 added by the call to _get_track_elements() above */
+ ASSERT_OBJECT_REFCOUNT (trackelement, "trackelement", 4);
+ for (tmp = trackelements; tmp; tmp = tmp->next) {
+ g_object_unref (GES_TRACK_ELEMENT (tmp->data));
}
- g_list_free (trackobjects);
+ g_list_free (trackelements);
/* There are 3 references:
* 1 by the clip
* 1 by the timeline
- * 1 by the trackobject */
- ASSERT_OBJECT_REFCOUNT (trackobject, "trackobject", 3);
-
- trackobjects = ges_clip_get_track_objects (GES_CLIP (s2));
- trackobject = GES_TRACK_OBJECT (trackobjects->data);
- fail_unless (trackobjects != NULL);
- for (tmp = trackobjects; tmp; tmp = tmp->next) {
- g_object_unref (GES_TRACK_OBJECT (tmp->data));
+ * 1 by the trackelement */
+ ASSERT_OBJECT_REFCOUNT (trackelement, "trackelement", 3);
+
+ trackelements = ges_clip_get_track_elements (GES_CLIP (s2));
+ trackelement = GES_TRACK_ELEMENT (trackelements->data);
+ fail_unless (trackelements != NULL);
+ for (tmp = trackelements; tmp; tmp = tmp->next) {
+ g_object_unref (GES_TRACK_ELEMENT (tmp->data));
}
- g_list_free (trackobjects);
+ g_list_free (trackelements);
/* There are 3 references:
* 1 by the clip
* 1 by the timeline
- * 1 by the trackobject */
- ASSERT_OBJECT_REFCOUNT (GES_TRACK_OBJECT (trackobject), "trackobject", 3);
-
- trackobjects = ges_clip_get_track_objects (GES_CLIP (s3));
- trackobject = GES_TRACK_OBJECT (trackobjects->data);
- fail_unless (trackobjects != NULL);
- for (tmp = trackobjects; tmp; tmp = tmp->next) {
- g_object_unref (GES_TRACK_OBJECT (tmp->data));
+ * 1 by the trackelement */
+ ASSERT_OBJECT_REFCOUNT (GES_TRACK_ELEMENT (trackelement), "trackelement", 3);
+
+ trackelements = ges_clip_get_track_elements (GES_CLIP (s3));
+ trackelement = GES_TRACK_ELEMENT (trackelements->data);
+ fail_unless (trackelements != NULL);
+ for (tmp = trackelements; tmp; tmp = tmp->next) {
+ g_object_unref (GES_TRACK_ELEMENT (tmp->data));
}
- g_list_free (trackobjects);
+ g_list_free (trackelements);
/* There are 3 references:
* 1 by the clip
* 1 by the timeline
- * 1 by the trackobject */
- ASSERT_OBJECT_REFCOUNT (trackobject, "trackobject", 3);
+ * 1 by the trackelement */
+ ASSERT_OBJECT_REFCOUNT (trackelement, "trackelement", 3);
/* theoretically this is all we need to do to ensure cleanup */
g_object_unref (timeline);
GESTimelineLayer *layer, *tmp_layer;
GESTrack *track;
GESCustomSourceClip *s1, *s2, *s3;
- GList *trackobjects, *tmp, *layers;
+ GList *trackelements, *tmp, *layers;
ges_init ();
fail_unless (ges_track_get_timeline (track) == timeline);
fail_unless ((gpointer) GST_ELEMENT_PARENT (track) == (gpointer) timeline);
- /* Make sure the associated TrackObjects are in the Track */
- trackobjects = ges_clip_get_track_objects (GES_CLIP (s1));
- fail_unless (trackobjects != NULL);
- for (tmp = trackobjects; tmp; tmp = tmp->next) {
+ /* Make sure the associated TrackElements are in the Track */
+ trackelements = ges_clip_get_track_elements (GES_CLIP (s1));
+ fail_unless (trackelements != NULL);
+ for (tmp = trackelements; tmp; tmp = tmp->next) {
/* Each object has 4 references:
* 1 by the clip
* 1 by the track
* 1 by the timeline
- * 1 added by _get_track_object() above */
- ASSERT_OBJECT_REFCOUNT (GES_TRACK_OBJECT (tmp->data), "trackobject", 4);
- g_object_unref (GES_TRACK_OBJECT (tmp->data));
+ * 1 added by _get_track_element() above */
+ ASSERT_OBJECT_REFCOUNT (GES_TRACK_ELEMENT (tmp->data), "trackelement", 4);
+ g_object_unref (GES_TRACK_ELEMENT (tmp->data));
}
- g_list_free (trackobjects);
+ g_list_free (trackelements);
- trackobjects = ges_clip_get_track_objects (GES_CLIP (s2));
- fail_unless (trackobjects != NULL);
- for (tmp = trackobjects; tmp; tmp = tmp->next) {
+ trackelements = ges_clip_get_track_elements (GES_CLIP (s2));
+ fail_unless (trackelements != NULL);
+ for (tmp = trackelements; tmp; tmp = tmp->next) {
/* Each object has 4 references:
* 1 by the clip
* 1 by the track
* 1 by the timeline
- * 1 added by _get_track_object() above */
- ASSERT_OBJECT_REFCOUNT (GES_TRACK_OBJECT (tmp->data), "trackobject", 4);
- g_object_unref (GES_TRACK_OBJECT (tmp->data));
+ * 1 added by _get_track_element() above */
+ ASSERT_OBJECT_REFCOUNT (GES_TRACK_ELEMENT (tmp->data), "trackelement", 4);
+ g_object_unref (GES_TRACK_ELEMENT (tmp->data));
}
- g_list_free (trackobjects);
+ g_list_free (trackelements);
- trackobjects = ges_clip_get_track_objects (GES_CLIP (s3));
- fail_unless (trackobjects != NULL);
- for (tmp = trackobjects; tmp; tmp = tmp->next) {
+ trackelements = ges_clip_get_track_elements (GES_CLIP (s3));
+ fail_unless (trackelements != NULL);
+ for (tmp = trackelements; tmp; tmp = tmp->next) {
/* Each object has 4 references:
* 1 by the clip
* 1 by the track
* 1 by the timeline
- * 1 added by _get_track_object() above */
- ASSERT_OBJECT_REFCOUNT (GES_TRACK_OBJECT (tmp->data), "trackobject", 4);
- g_object_unref (GES_TRACK_OBJECT (tmp->data));
+ * 1 added by _get_track_element() above */
+ ASSERT_OBJECT_REFCOUNT (GES_TRACK_ELEMENT (tmp->data), "trackelement", 4);
+ g_object_unref (GES_TRACK_ELEMENT (tmp->data));
}
- g_list_free (trackobjects);
+ g_list_free (trackelements);
/* theoretically this is all we need to do to ensure cleanup */
g_object_unref (timeline);
GESTimelineLayer *layer, *tmp_layer;
GESTrack *track;
GESCustomSourceClip *s1, *s2, *s3;
- GESTrackObject *t1, *t2, *t3;
- GList *trackobjects, *tmp, *layers;
+ GESTrackElement *t1, *t2, *t3;
+ GList *trackelements, *tmp, *layers;
ges_init ();
fail_unless (ges_track_get_timeline (track) == timeline);
fail_unless ((gpointer) GST_ELEMENT_PARENT (track) == (gpointer) timeline);
- /* Make sure the associated TrackObjects are in the Track */
- trackobjects = ges_clip_get_track_objects (GES_CLIP (s1));
- fail_unless (trackobjects != NULL);
- t1 = GES_TRACK_OBJECT ((trackobjects)->data);
- for (tmp = trackobjects; tmp; tmp = tmp->next) {
+ /* Make sure the associated TrackElements are in the Track */
+ trackelements = ges_clip_get_track_elements (GES_CLIP (s1));
+ fail_unless (trackelements != NULL);
+ t1 = GES_TRACK_ELEMENT ((trackelements)->data);
+ for (tmp = trackelements; tmp; tmp = tmp->next) {
/* There are 4 references held:
* 1 by the clip
* 1 by the track
* 1 by the timeline
- * 1 added by the call to _get_track_objects() above */
- ASSERT_OBJECT_REFCOUNT (GES_TRACK_OBJECT (tmp->data), "trackobject", 4);
- g_object_unref (GES_TRACK_OBJECT (tmp->data));
+ * 1 added by the call to _get_track_elements() above */
+ ASSERT_OBJECT_REFCOUNT (GES_TRACK_ELEMENT (tmp->data), "trackelement", 4);
+ g_object_unref (GES_TRACK_ELEMENT (tmp->data));
}
g_object_ref (t1);
- g_list_free (trackobjects);
+ g_list_free (trackelements);
/* There are 4 references held:
* 1 by the timelinobject
* 1 by the track
* 1 by the timeline
* 1 added by ourselves above (g_object_ref (t1)) */
- ASSERT_OBJECT_REFCOUNT (t1, "trackobject", 4);
+ ASSERT_OBJECT_REFCOUNT (t1, "trackelement", 4);
- trackobjects = ges_clip_get_track_objects (GES_CLIP (s2));
- fail_unless (trackobjects != NULL);
- t2 = GES_TRACK_OBJECT (trackobjects->data);
- for (tmp = trackobjects; tmp; tmp = tmp->next) {
+ trackelements = ges_clip_get_track_elements (GES_CLIP (s2));
+ fail_unless (trackelements != NULL);
+ t2 = GES_TRACK_ELEMENT (trackelements->data);
+ for (tmp = trackelements; tmp; tmp = tmp->next) {
/* There are 4 references held:
* 1 by the clip
* 1 by the track
* 1 by the timeline
- * 1 added by the call to _get_track_objects() above */
- ASSERT_OBJECT_REFCOUNT (GES_TRACK_OBJECT (tmp->data), "trackobject", 4);
- g_object_unref (GES_TRACK_OBJECT (tmp->data));
+ * 1 added by the call to _get_track_elements() above */
+ ASSERT_OBJECT_REFCOUNT (GES_TRACK_ELEMENT (tmp->data), "trackelement", 4);
+ g_object_unref (GES_TRACK_ELEMENT (tmp->data));
}
g_object_ref (t2);
- g_list_free (trackobjects);
+ g_list_free (trackelements);
/* There are 4 references held:
* 1 by the timelinobject
* 1 by the track
* 1 added by ourselves above (g_object_ref (t1)) */
ASSERT_OBJECT_REFCOUNT (t2, "t2", 4);
- trackobjects = ges_clip_get_track_objects (GES_CLIP (s3));
- fail_unless (trackobjects != NULL);
- t3 = GES_TRACK_OBJECT (trackobjects->data);
- for (tmp = trackobjects; tmp; tmp = tmp->next) {
+ trackelements = ges_clip_get_track_elements (GES_CLIP (s3));
+ fail_unless (trackelements != NULL);
+ t3 = GES_TRACK_ELEMENT (trackelements->data);
+ for (tmp = trackelements; tmp; tmp = tmp->next) {
/* There are 4 references held:
* 1 by the clip
* 1 by the track
* 1 by the timeline
- * 1 added by the call to _get_track_objects() above */
- ASSERT_OBJECT_REFCOUNT (GES_TRACK_OBJECT (tmp->data), "trackobject", 4);
- g_object_unref (GES_TRACK_OBJECT (tmp->data));
+ * 1 added by the call to _get_track_elements() above */
+ ASSERT_OBJECT_REFCOUNT (GES_TRACK_ELEMENT (tmp->data), "trackelement", 4);
+ g_object_unref (GES_TRACK_ELEMENT (tmp->data));
}
g_object_ref (t3);
- g_list_free (trackobjects);
+ g_list_free (trackelements);
/* There are 4 references held:
* 1 by the timelinobject
* 1 by the track
/* remove the track and check that the track objects have been released */
fail_unless (ges_timeline_remove_track (timeline, track));
- ASSERT_OBJECT_REFCOUNT (t1, "trackobject", 2);
- ASSERT_OBJECT_REFCOUNT (t2, "trackobject", 2);
- ASSERT_OBJECT_REFCOUNT (t3, "trackobject", 2);
+ ASSERT_OBJECT_REFCOUNT (t1, "trackelement", 2);
+ ASSERT_OBJECT_REFCOUNT (t2, "trackelement", 2);
+ ASSERT_OBJECT_REFCOUNT (t3, "trackelement", 2);
g_object_unref (t1);
g_object_unref (t2);
static GPtrArray *
select_tracks_cb (GESTimeline * timeline, GESClip * tobj,
- GESTrackObject * trobj, SelectTracksData * st_data)
+ GESTrackElement * trobj, SelectTracksData * st_data)
{
GESTrack *track;
GESTimelineLayer *layer, *tmp_layer;
GESTrack *track1, *track2;
GESCustomSourceClip *s1, *s2, *s3;
- GESTrackObject *t1, *t2, *t3;
- GList *trackobjects, *tmp, *layers;
+ GESTrackElement *t1, *t2, *t3;
+ GList *trackelements, *tmp, *layers;
SelectTracksData st_data = { &s1, &s2, &s3, &track1, &track2 };
ges_init ();
g_list_foreach (layers, (GFunc) g_object_unref, NULL);
g_list_free (layers);
- /* Make sure the associated TrackObjects are in the Track */
- trackobjects = ges_clip_get_track_objects (GES_CLIP (s1));
- fail_unless (trackobjects != NULL);
- t1 = GES_TRACK_OBJECT ((trackobjects)->data);
- for (tmp = trackobjects; tmp; tmp = tmp->next) {
+ /* Make sure the associated TrackElements are in the Track */
+ trackelements = ges_clip_get_track_elements (GES_CLIP (s1));
+ fail_unless (trackelements != NULL);
+ t1 = GES_TRACK_ELEMENT ((trackelements)->data);
+ for (tmp = trackelements; tmp; tmp = tmp->next) {
/* There are 4 references held:
* 1 by the clip
* 1 by the track
* 1 by the timeline
- * 1 added by the call to _get_track_objects() above */
- ASSERT_OBJECT_REFCOUNT (GES_TRACK_OBJECT (tmp->data), "trackobject", 4);
- fail_unless (ges_track_object_get_track (tmp->data) == track1);
- g_object_unref (GES_TRACK_OBJECT (tmp->data));
+ * 1 added by the call to _get_track_elements() above */
+ ASSERT_OBJECT_REFCOUNT (GES_TRACK_ELEMENT (tmp->data), "trackelement", 4);
+ fail_unless (ges_track_element_get_track (tmp->data) == track1);
+ g_object_unref (GES_TRACK_ELEMENT (tmp->data));
}
g_object_ref (t1);
- g_list_free (trackobjects);
+ g_list_free (trackelements);
/* There are 4 references held:
* 1 by the timelinobject
* 1 by the track
* 1 by the timeline
* 1 added by ourselves above (g_object_ref (t1)) */
- ASSERT_OBJECT_REFCOUNT (t1, "trackobject", 4);
+ ASSERT_OBJECT_REFCOUNT (t1, "trackelement", 4);
- trackobjects = ges_clip_get_track_objects (GES_CLIP (s2));
- fail_unless (trackobjects != NULL);
- t2 = GES_TRACK_OBJECT (trackobjects->data);
- for (tmp = trackobjects; tmp; tmp = tmp->next) {
+ trackelements = ges_clip_get_track_elements (GES_CLIP (s2));
+ fail_unless (trackelements != NULL);
+ t2 = GES_TRACK_ELEMENT (trackelements->data);
+ for (tmp = trackelements; tmp; tmp = tmp->next) {
/* There are 4 references held:
* 1 by the clip
* 1 by the track
* 1 by the timeline
- * 1 added by the call to _get_track_objects() above */
- ASSERT_OBJECT_REFCOUNT (GES_TRACK_OBJECT (tmp->data), "trackobject", 4);
- fail_unless (ges_track_object_get_track (tmp->data) == track2);
- g_object_unref (GES_TRACK_OBJECT (tmp->data));
+ * 1 added by the call to _get_track_elements() above */
+ ASSERT_OBJECT_REFCOUNT (GES_TRACK_ELEMENT (tmp->data), "trackelement", 4);
+ fail_unless (ges_track_element_get_track (tmp->data) == track2);
+ g_object_unref (GES_TRACK_ELEMENT (tmp->data));
}
g_object_ref (t2);
- g_list_free (trackobjects);
+ g_list_free (trackelements);
/* There are 4 references held:
* 1 by the timelinobject
* 1 by the track
* 1 added by ourselves above (g_object_ref (t1)) */
ASSERT_OBJECT_REFCOUNT (t2, "t2", 4);
- trackobjects = ges_clip_get_track_objects (GES_CLIP (s3));
- fail_unless (trackobjects != NULL);
- t3 = GES_TRACK_OBJECT (trackobjects->data);
- for (tmp = trackobjects; tmp; tmp = tmp->next) {
+ trackelements = ges_clip_get_track_elements (GES_CLIP (s3));
+ fail_unless (trackelements != NULL);
+ t3 = GES_TRACK_ELEMENT (trackelements->data);
+ for (tmp = trackelements; tmp; tmp = tmp->next) {
/* There are 4 references held:
* 1 by the clip
* 1 by the track
* 1 by the timeline
- * 1 added by the call to _get_track_objects() above */
- ASSERT_OBJECT_REFCOUNT (GES_TRACK_OBJECT (tmp->data), "trackobject", 4);
- fail_unless (ges_track_object_get_track (tmp->data) == track1);
- g_object_unref (GES_TRACK_OBJECT (tmp->data));
+ * 1 added by the call to _get_track_elements() above */
+ ASSERT_OBJECT_REFCOUNT (GES_TRACK_ELEMENT (tmp->data), "trackelement", 4);
+ fail_unless (ges_track_element_get_track (tmp->data) == track1);
+ g_object_unref (GES_TRACK_ELEMENT (tmp->data));
}
g_object_ref (t3);
- g_list_free (trackobjects);
+ g_list_free (trackelements);
/* There are 4 references held:
* 1 by the timelinobject
* 1 by the track
static gboolean
my_fill_track_func (GESClip * object,
- GESTrackObject * trobject, GstElement * gnlobj, gpointer user_data)
+ GESTrackElement * trobject, GstElement * gnlobj, gpointer user_data)
{
GstElement *src;
- GST_DEBUG ("timelineobj:%p, trackobjec:%p, gnlobj:%p",
+ GST_DEBUG ("timelineobj:%p, trackelementec:%p, gnlobj:%p",
object, trobject, gnlobj);
/* Let's just put a fakesource in for the time being */
GST_START_TEST (test_object_properties)
{
GESTrack *track;
- GESTrackObject *trackobject;
+ GESTrackElement *trackelement;
GESClip *object;
ges_init ();
assert_equals_uint64 (_DURATION (object), 51);
assert_equals_uint64 (_INPOINT (object), 12);
- trackobject = ges_clip_create_track_object (object, track->type);
- ges_clip_add_track_object (object, trackobject);
- fail_unless (trackobject != NULL);
- fail_unless (ges_track_object_set_track (trackobject, track));
+ trackelement = ges_clip_create_track_element (object, track->type);
+ ges_clip_add_track_element (object, trackelement);
+ fail_unless (trackelement != NULL);
+ fail_unless (ges_track_element_set_track (trackelement, track));
- /* Check that trackobject has the same properties */
- assert_equals_uint64 (_START (trackobject), 42);
- assert_equals_uint64 (_DURATION (trackobject), 51);
- assert_equals_uint64 (_INPOINT (trackobject), 12);
+ /* Check that trackelement has the same properties */
+ assert_equals_uint64 (_START (trackelement), 42);
+ assert_equals_uint64 (_DURATION (trackelement), 51);
+ assert_equals_uint64 (_INPOINT (trackelement), 12);
/* And let's also check that it propagated correctly to GNonLin */
- gnl_object_check (ges_track_object_get_gnlobject (trackobject), 42, 51, 12,
+ gnl_object_check (ges_track_element_get_gnlobject (trackelement), 42, 51, 12,
51, 0, TRUE);
/* Change more properties, see if they propagate */
assert_equals_uint64 (_START (object), 420);
assert_equals_uint64 (_DURATION (object), 510);
assert_equals_uint64 (_INPOINT (object), 120);
- assert_equals_uint64 (_START (trackobject), 420);
- assert_equals_uint64 (_DURATION (trackobject), 510);
- assert_equals_uint64 (_INPOINT (trackobject), 120);
+ assert_equals_uint64 (_START (trackelement), 420);
+ assert_equals_uint64 (_DURATION (trackelement), 510);
+ assert_equals_uint64 (_INPOINT (trackelement), 120);
/* And let's also check that it propagated correctly to GNonLin */
- gnl_object_check (ges_track_object_get_gnlobject (trackobject), 420, 510, 120,
- 510, 0, TRUE);
+ gnl_object_check (ges_track_element_get_gnlobject (trackelement), 420, 510,
+ 120, 510, 0, TRUE);
- /* This time, we move the trackobject to see if the changes move
+ /* This time, we move the trackelement to see if the changes move
* along to the parent and the gnonlin object */
- g_object_set (trackobject, "start", (guint64) 400, NULL);
+ g_object_set (trackelement, "start", (guint64) 400, NULL);
assert_equals_uint64 (_START (object), 400);
- assert_equals_uint64 (_START (trackobject), 400);
- gnl_object_check (ges_track_object_get_gnlobject (trackobject), 400, 510, 120,
- 510, 0, TRUE);
+ assert_equals_uint64 (_START (trackelement), 400);
+ gnl_object_check (ges_track_element_get_gnlobject (trackelement), 400, 510,
+ 120, 510, 0, TRUE);
- ges_clip_release_track_object (object, trackobject);
+ ges_clip_release_track_element (object, trackelement);
g_object_unref (object);
g_object_unref (track);
GST_START_TEST (test_object_properties_unlocked)
{
GESTrack *track;
- GESTrackObject *trackobject;
+ GESTrackElement *trackelement;
GESClip *object;
ges_init ();
assert_equals_uint64 (_DURATION (object), 51);
assert_equals_uint64 (_INPOINT (object), 12);
- trackobject = ges_clip_create_track_object (object, track->type);
- ges_clip_add_track_object (object, trackobject);
- fail_unless (trackobject != NULL);
- fail_unless (ges_track_object_set_track (trackobject, track));
+ trackelement = ges_clip_create_track_element (object, track->type);
+ ges_clip_add_track_element (object, trackelement);
+ fail_unless (trackelement != NULL);
+ fail_unless (ges_track_element_set_track (trackelement, track));
- /* Check that trackobject has the same properties */
- assert_equals_uint64 (_START (trackobject), 42);
- assert_equals_uint64 (_DURATION (trackobject), 51);
- assert_equals_uint64 (_INPOINT (trackobject), 12);
+ /* Check that trackelement has the same properties */
+ assert_equals_uint64 (_START (trackelement), 42);
+ assert_equals_uint64 (_DURATION (trackelement), 51);
+ assert_equals_uint64 (_INPOINT (trackelement), 12);
/* And let's also check that it propagated correctly to GNonLin */
- gnl_object_check (ges_track_object_get_gnlobject (trackobject), 42, 51, 12,
+ gnl_object_check (ges_track_element_get_gnlobject (trackelement), 42, 51, 12,
51, 0, TRUE);
- /* This time we unlock the trackobject and make sure it doesn't propagate */
- ges_track_object_set_locked (trackobject, FALSE);
+ /* This time we unlock the trackelement and make sure it doesn't propagate */
+ ges_track_element_set_locked (trackelement, FALSE);
/* Change more properties, they will be set on the GESClip */
g_object_set (object, "start", (guint64) 420, "duration", (guint64) 510,
assert_equals_uint64 (_START (object), 420);
assert_equals_uint64 (_DURATION (object), 510);
assert_equals_uint64 (_INPOINT (object), 120);
- /* ... but not on the GESTrackObject since it was unlocked... */
- assert_equals_uint64 (_START (trackobject), 42);
- assert_equals_uint64 (_DURATION (trackobject), 51);
- assert_equals_uint64 (_INPOINT (trackobject), 12);
+ /* ... but not on the GESTrackElement since it was unlocked... */
+ assert_equals_uint64 (_START (trackelement), 42);
+ assert_equals_uint64 (_DURATION (trackelement), 51);
+ assert_equals_uint64 (_INPOINT (trackelement), 12);
/* ... and neither on the GNonLin object */
- gnl_object_check (ges_track_object_get_gnlobject (trackobject), 42, 51, 12,
+ gnl_object_check (ges_track_element_get_gnlobject (trackelement), 42, 51, 12,
51, 0, TRUE);
- /* When unlocked, moving the GESTrackObject won't move the GESClip
+ /* When unlocked, moving the GESTrackElement won't move the GESClip
* either */
- /* This time, we move the trackobject to see if the changes move
+ /* This time, we move the trackelement to see if the changes move
* along to the parent and the gnonlin object */
- g_object_set (trackobject, "start", (guint64) 400, NULL);
+ g_object_set (trackelement, "start", (guint64) 400, NULL);
assert_equals_uint64 (_START (object), 420);
- assert_equals_uint64 (_START (trackobject), 400);
- gnl_object_check (ges_track_object_get_gnlobject (trackobject), 400, 51, 12,
+ assert_equals_uint64 (_START (trackelement), 400);
+ gnl_object_check (ges_track_element_get_gnlobject (trackelement), 400, 51, 12,
51, 0, TRUE);
- ges_clip_release_track_object (object, trackobject);
+ ges_clip_release_track_element (object, trackelement);
g_object_unref (object);
g_object_unref (track);
GST_START_TEST (test_split_object)
{
GESTrack *track;
- GESTrackObject *trackobject, *splittckobj;
+ GESTrackElement *trackelement, *splittrackelement;
GESClip *object, *splitobj;
- GList *splittckobjs;
+ GList *splittrackelements;
ges_init ();
assert_equals_uint64 (_DURATION (object), 50);
assert_equals_uint64 (_INPOINT (object), 12);
- trackobject = ges_clip_create_track_object (object, track->type);
- ges_clip_add_track_object (object, trackobject);
- fail_unless (trackobject != NULL);
- fail_unless (ges_track_object_set_track (trackobject, track));
+ trackelement = ges_clip_create_track_element (object, track->type);
+ ges_clip_add_track_element (object, trackelement);
+ fail_unless (trackelement != NULL);
+ fail_unless (ges_track_element_set_track (trackelement, track));
- /* Check that trackobject has the same properties */
- assert_equals_uint64 (_START (trackobject), 42);
- assert_equals_uint64 (_DURATION (trackobject), 50);
- assert_equals_uint64 (_INPOINT (trackobject), 12);
+ /* Check that trackelement has the same properties */
+ assert_equals_uint64 (_START (trackelement), 42);
+ assert_equals_uint64 (_DURATION (trackelement), 50);
+ assert_equals_uint64 (_INPOINT (trackelement), 12);
/* And let's also check that it propagated correctly to GNonLin */
- gnl_object_check (ges_track_object_get_gnlobject (trackobject), 42, 50, 12,
+ gnl_object_check (ges_track_element_get_gnlobject (trackelement), 42, 50, 12,
50, 0, TRUE);
splitobj = ges_clip_split (object, 67);
assert_equals_uint64 (_DURATION (splitobj), 25);
assert_equals_uint64 (_INPOINT (splitobj), 37);
- splittckobjs = ges_clip_get_track_objects (splitobj);
- fail_unless_equals_int (g_list_length (splittckobjs), 1);
+ splittrackelements = ges_clip_get_track_elements (splitobj);
+ fail_unless_equals_int (g_list_length (splittrackelements), 1);
- splittckobj = GES_TRACK_OBJECT (splittckobjs->data);
- fail_unless (GES_IS_TRACK_OBJECT (splittckobj));
- assert_equals_uint64 (_START (splittckobj), 67);
- assert_equals_uint64 (_DURATION (splittckobj), 25);
- assert_equals_uint64 (_INPOINT (splittckobj), 37);
+ splittrackelement = GES_TRACK_ELEMENT (splittrackelements->data);
+ fail_unless (GES_IS_TRACK_ELEMENT (splittrackelement));
+ assert_equals_uint64 (_START (splittrackelement), 67);
+ assert_equals_uint64 (_DURATION (splittrackelement), 25);
+ assert_equals_uint64 (_INPOINT (splittrackelement), 37);
- fail_unless (splittckobj != trackobject);
+ fail_unless (splittrackelement != trackelement);
fail_unless (splitobj != object);
/* We own the only ref */
ASSERT_OBJECT_REFCOUNT (splitobj, "splitobj", 1);
- /* 1 ref for the Clip, 1 ref for the Track and 1 in splittckobjs */
- ASSERT_OBJECT_REFCOUNT (splittckobj, "splittckobj", 3);
+ /* 1 ref for the Clip, 1 ref for the Track and 1 in splittrackelements */
+ ASSERT_OBJECT_REFCOUNT (splittrackelement, "splittrackelement", 3);
g_object_unref (track);
g_object_unref (splitobj);
g_object_unref (object);
- ASSERT_OBJECT_REFCOUNT (splittckobj, "splittckobj", 1);
- g_list_free_full (splittckobjs, g_object_unref);
+ ASSERT_OBJECT_REFCOUNT (splittrackelement, "splittrackelement", 1);
+ g_list_free_full (splittrackelements, g_object_unref);
}
GST_END_TEST;
void effect_added_cb (GESClip * obj, GESTrackEffect * trop, gpointer data);
void
-deep_prop_changed_cb (GESTrackObject * obj, GstElement * element,
+deep_prop_changed_cb (GESTrackElement * obj, GstElement * element,
GParamSpec * spec);
GST_START_TEST (test_effect_basic)
fail_unless (GES_IS_TRACK_EFFECT (track_effect));
- fail_unless (ges_clip_add_track_object (GES_CLIP
- (source), GES_TRACK_OBJECT (track_effect)));
+ fail_unless (ges_clip_add_track_element (GES_CLIP
+ (source), GES_TRACK_ELEMENT (track_effect)));
fail_unless (ges_track_add_object (track_video,
- GES_TRACK_OBJECT (track_effect)));
+ GES_TRACK_ELEMENT (track_effect)));
- assert_equals_int (GES_TRACK_OBJECT (track_effect)->active, TRUE);
+ assert_equals_int (GES_TRACK_ELEMENT (track_effect)->active, TRUE);
ges_timeline_layer_remove_object (layer, (GESClip *) source);
fail_unless (GES_IS_TRACK_EFFECT (track_effect1));
fail_unless (GES_IS_TRACK_EFFECT (track_effect2));
- fail_unless (ges_clip_add_track_object (GES_CLIP
- (source), GES_TRACK_OBJECT (track_effect)));
+ fail_unless (ges_clip_add_track_element (GES_CLIP
+ (source), GES_TRACK_ELEMENT (track_effect)));
fail_unless (ges_track_add_object (track_video,
- GES_TRACK_OBJECT (track_effect)));
+ GES_TRACK_ELEMENT (track_effect)));
- fail_unless (ges_clip_add_track_object (GES_CLIP
- (source), GES_TRACK_OBJECT (track_effect1)));
+ fail_unless (ges_clip_add_track_element (GES_CLIP
+ (source), GES_TRACK_ELEMENT (track_effect1)));
fail_unless (ges_track_add_object (track_video,
- GES_TRACK_OBJECT (track_effect1)));
+ GES_TRACK_ELEMENT (track_effect1)));
- fail_unless (ges_clip_add_track_object (GES_CLIP
- (source), GES_TRACK_OBJECT (track_effect2)));
+ fail_unless (ges_clip_add_track_element (GES_CLIP
+ (source), GES_TRACK_ELEMENT (track_effect2)));
fail_unless (ges_track_add_object (track_video,
- GES_TRACK_OBJECT (track_effect2)));
+ GES_TRACK_ELEMENT (track_effect2)));
g_object_get (G_OBJECT (source), "height", &clip_height, NULL);
fail_unless (clip_height == 4);
(GESClip *) effect_clip, 0);
tck_effect = ges_track_parse_launch_effect_new ("identity");
- fail_unless (ges_clip_add_track_object (GES_CLIP
- (effect_clip), GES_TRACK_OBJECT (tck_effect)));
+ fail_unless (ges_clip_add_track_element (GES_CLIP
+ (effect_clip), GES_TRACK_ELEMENT (tck_effect)));
fail_unless (ges_track_add_object (track_video,
- GES_TRACK_OBJECT (tck_effect)));
+ GES_TRACK_ELEMENT (tck_effect)));
g_object_get (effect_clip, "height", &clip_height, NULL);
assert_equals_int (clip_height, 3);
tck_effect1 = ges_track_parse_launch_effect_new ("identity");
- fail_unless (ges_clip_add_track_object (GES_CLIP
- (effect_clip), GES_TRACK_OBJECT (tck_effect1)));
+ fail_unless (ges_clip_add_track_element (GES_CLIP
+ (effect_clip), GES_TRACK_ELEMENT (tck_effect1)));
fail_unless (ges_track_add_object (track_audio,
- GES_TRACK_OBJECT (tck_effect1)));
+ GES_TRACK_ELEMENT (tck_effect1)));
g_object_get (effect_clip, "height", &clip_height, NULL);
assert_equals_int (clip_height, 4);
GES_TRACK_EFFECT (tmp->data));
fail_unless (priority > effect_prio);
fail_unless (GES_IS_TRACK_EFFECT (tmp->data));
- fail_unless (ges_track_object_get_track (GES_TRACK_OBJECT (tmp->
+ fail_unless (ges_track_element_get_track (GES_TRACK_ELEMENT (tmp->
data))->type == track_type[i]);
effect_prio = priority;
(GESClip *) effect_clip, 0);
tck_effect = ges_track_parse_launch_effect_new ("identity");
- fail_unless (ges_clip_add_track_object (GES_CLIP
- (effect_clip), GES_TRACK_OBJECT (tck_effect)));
+ fail_unless (ges_clip_add_track_element (GES_CLIP
+ (effect_clip), GES_TRACK_ELEMENT (tck_effect)));
fail_unless (ges_track_add_object (track_video,
- GES_TRACK_OBJECT (tck_effect)));
+ GES_TRACK_ELEMENT (tck_effect)));
g_object_get (effect_clip, "height", &clip_height, NULL);
fail_unless (clip_height == 3);
tck_effect1 = ges_track_parse_launch_effect_new ("identity");
- fail_unless (ges_clip_add_track_object (GES_CLIP
- (effect_clip), GES_TRACK_OBJECT (tck_effect1)));
+ fail_unless (ges_clip_add_track_element (GES_CLIP
+ (effect_clip), GES_TRACK_ELEMENT (tck_effect1)));
fail_unless (ges_track_add_object (track_audio,
- GES_TRACK_OBJECT (tck_effect1)));
+ GES_TRACK_ELEMENT (tck_effect1)));
fail_unless (ges_clip_set_top_effect_priority (GES_CLIP
(effect_clip), GES_TRACK_EFFECT (tck_effect1), 0));
GESTimelineLayer *layer;
GESTrack *track_video;
GESEffectClip *effect_clip;
- GESTrackObject *tck_effect;
+ GESTrackElement *tck_effect;
guint scratch_line, n_props, i;
gboolean color_aging;
GParamSpec **pspecs, *spec;
ges_simple_timeline_layer_add_object ((GESSimpleTimelineLayer *) (layer),
(GESClip *) effect_clip, 0);
- tck_effect = GES_TRACK_OBJECT (ges_track_parse_launch_effect_new ("agingtv"));
- fail_unless (ges_clip_add_track_object (GES_CLIP (effect_clip), tck_effect));
+ tck_effect =
+ GES_TRACK_ELEMENT (ges_track_parse_launch_effect_new ("agingtv"));
+ fail_unless (ges_clip_add_track_element (GES_CLIP (effect_clip), tck_effect));
fail_unless (ges_track_add_object (track_video, tck_effect));
- ges_track_object_set_child_properties (tck_effect,
+ ges_track_element_set_child_properties (tck_effect,
"GstAgingTV::scratch-lines", 17, "color-aging", FALSE, NULL);
- ges_track_object_get_child_properties (tck_effect,
+ ges_track_element_get_child_properties (tck_effect,
"GstAgingTV::scratch-lines", &scratch_line,
"color-aging", &color_aging, NULL);
fail_unless (scratch_line == 17);
fail_unless (color_aging == FALSE);
- pspecs = ges_track_object_list_children_properties (tck_effect, &n_props);
+ pspecs = ges_track_element_list_children_properties (tck_effect, &n_props);
fail_unless (n_props == 7);
spec = pspecs[0];
g_value_init (&nval, G_TYPE_UINT);
g_value_set_uint (&val, 10);
- ges_track_object_set_child_property_by_pspec (tck_effect, spec, &val);
- ges_track_object_get_child_property_by_pspec (tck_effect, spec, &nval);
+ ges_track_element_set_child_property_by_pspec (tck_effect, spec, &val);
+ ges_track_element_get_child_property_by_pspec (tck_effect, spec, &nval);
fail_unless (g_value_get_uint (&nval) == 10);
for (i = 0; i < n_props; i++) {
}
void
-deep_prop_changed_cb (GESTrackObject * obj, GstElement * element,
+deep_prop_changed_cb (GESTrackElement * obj, GstElement * element,
GParamSpec * spec)
{
GST_DEBUG ("%s property changed", g_param_spec_get_name (spec));
- fail_unless (GES_IS_TRACK_OBJECT (obj));
+ fail_unless (GES_IS_TRACK_ELEMENT (obj));
fail_unless (GST_IS_ELEMENT (element));
}
(GESClip *) effect_clip, 0);
tck_effect = ges_track_parse_launch_effect_new ("agingtv");
- fail_unless (ges_clip_add_track_object (GES_CLIP
- (effect_clip), GES_TRACK_OBJECT (tck_effect)));
+ fail_unless (ges_clip_add_track_element (GES_CLIP
+ (effect_clip), GES_TRACK_ELEMENT (tck_effect)));
fail_unless (ges_track_add_object (track_video,
- GES_TRACK_OBJECT (tck_effect)));
+ GES_TRACK_ELEMENT (tck_effect)));
g_signal_connect (tck_effect, "deep-notify", (GCallback) deep_prop_changed_cb,
tck_effect);
- ges_track_object_set_child_properties (GES_TRACK_OBJECT (tck_effect),
+ ges_track_element_set_child_properties (GES_TRACK_ELEMENT (tck_effect),
"GstAgingTV::scratch-lines", 17, NULL);
g_value_init (&val, G_TYPE_UINT);
- ges_track_object_get_child_property (GES_TRACK_OBJECT (tck_effect),
+ ges_track_element_get_child_property (GES_TRACK_ELEMENT (tck_effect),
"GstAgingTV::scratch-lines", &val);
fail_unless (G_VALUE_HOLDS_UINT (&val));
g_value_unset (&val);
static gboolean
my_fill_track_func (GESClip * object,
- GESTrackObject * trobject, GstElement * gnlobj, gpointer user_data)
+ GESTrackElement * trobject, GstElement * gnlobj, gpointer user_data)
{
GstElement *src;
- GST_DEBUG ("timelineobj:%p, trackobjec:%p, gnlobj:%p",
+ GST_DEBUG ("timelineobj:%p, trackelementec:%p, gnlobj:%p",
object, trobject, gnlobj);
/* Let's just put a fakesource in for the time being */
GESTimeline *timeline;
GESTimelineLayer *layer;
GESTrack *track;
- GESTrackObject *trackobject;
+ GESTrackElement *trackelement;
GESClip *object;
ges_init ();
fail_unless (g_object_is_floating (object));
fail_unless (ges_timeline_layer_add_object (layer, GES_CLIP (object)));
fail_if (g_object_is_floating (object));
- trackobject = ges_clip_find_track_object (object, track, G_TYPE_NONE);
- fail_unless (trackobject != NULL);
+ trackelement = ges_clip_find_track_element (object, track, G_TYPE_NONE);
+ fail_unless (trackelement != NULL);
/* This is not a SimpleLayer, therefore the properties shouldn't have changed */
assert_equals_uint64 (_START (object), 42);
assert_equals_uint64 (_DURATION (object), 51);
assert_equals_uint64 (_INPOINT (object), 12);
assert_equals_uint64 (_PRIORITY (object), 0);
- gnl_object_check (ges_track_object_get_gnlobject (trackobject), 42, 51, 12,
+ gnl_object_check (ges_track_element_get_gnlobject (trackelement), 42, 51, 12,
51, 0, TRUE);
/* Change the priority of the layer */
g_object_set (layer, "priority", 1, NULL);
assert_equals_int (ges_timeline_layer_get_priority (layer), 1);
assert_equals_uint64 (_PRIORITY (object), 0);
- gnl_object_check (ges_track_object_get_gnlobject (trackobject), 42, 51, 12,
+ gnl_object_check (ges_track_element_get_gnlobject (trackelement), 42, 51, 12,
51, LAYER_HEIGHT, TRUE);
/* Change it to an insanely high value */
g_object_set (layer, "priority", 31, NULL);
assert_equals_int (ges_timeline_layer_get_priority (layer), 31);
assert_equals_uint64 (_PRIORITY (object), 0);
- gnl_object_check (ges_track_object_get_gnlobject (trackobject), 42, 51, 12,
+ gnl_object_check (ges_track_element_get_gnlobject (trackelement), 42, 51, 12,
51, LAYER_HEIGHT * 31, TRUE);
/* and back to 0 */
g_object_set (layer, "priority", 0, NULL);
assert_equals_int (ges_timeline_layer_get_priority (layer), 0);
assert_equals_uint64 (_PRIORITY (object), 0);
- gnl_object_check (ges_track_object_get_gnlobject (trackobject), 42, 51, 12,
+ gnl_object_check (ges_track_element_get_gnlobject (trackelement), 42, 51, 12,
51, 0, TRUE);
- g_object_unref (trackobject);
+ g_object_unref (trackelement);
fail_unless (ges_timeline_layer_remove_object (layer, object));
fail_unless (ges_timeline_remove_track (timeline, track));
fail_unless (ges_timeline_remove_layer (timeline, layer));
GESTrack *track;
GESTimeline *timeline;
GESTimelineLayer *layer1, *layer2, *layer3;
- GESTrackObject *tckobj1, *tckobj2, *tckobj3;
+ GESTrackElement *trackelement1, *trackelement2, *trackelement3;
GESClip *object1, *object2, *object3;
GstElement *gnlobj1, *gnlobj2, *gnlobj3;
guint prio1, prio2, prio3;
/* Add objects to the timeline */
fail_unless (ges_timeline_layer_add_object (layer1, object1));
- tckobj1 = ges_clip_find_track_object (object1, track, G_TYPE_NONE);
- fail_unless (tckobj1 != NULL);
+ trackelement1 = ges_clip_find_track_element (object1, track, G_TYPE_NONE);
+ fail_unless (trackelement1 != NULL);
fail_unless (ges_timeline_layer_add_object (layer2, object2));
- tckobj2 = ges_clip_find_track_object (object2, track, G_TYPE_NONE);
- fail_unless (tckobj2 != NULL);
+ trackelement2 = ges_clip_find_track_element (object2, track, G_TYPE_NONE);
+ fail_unless (trackelement2 != NULL);
fail_unless (ges_timeline_layer_add_object (layer3, object3));
- tckobj3 = ges_clip_find_track_object (object3, track, G_TYPE_NONE);
- fail_unless (tckobj3 != NULL);
+ trackelement3 = ges_clip_find_track_element (object3, track, G_TYPE_NONE);
+ fail_unless (trackelement3 != NULL);
assert_equals_int (_PRIORITY (object1), 0);
- gnlobj1 = ges_track_object_get_gnlobject (tckobj1);
+ gnlobj1 = ges_track_element_get_gnlobject (trackelement1);
fail_unless (gnlobj1 != NULL);
g_object_get (gnlobj1, "priority", &prio1, NULL);
assert_equals_int (prio1, 0);
assert_equals_int (_PRIORITY (object2), 1);
- gnlobj2 = ges_track_object_get_gnlobject (tckobj2);
+ gnlobj2 = ges_track_element_get_gnlobject (trackelement2);
fail_unless (gnlobj2 != NULL);
g_object_get (gnlobj2, "priority", &prio2, NULL);
/* object2 is on the second layer and has a priority of 1 */
assert_equals_int (prio2, LAYER_HEIGHT + 1);
assert_equals_int (_PRIORITY (object3), LAYER_HEIGHT - 1);
- gnlobj3 = ges_track_object_get_gnlobject (tckobj3);
+ gnlobj3 = ges_track_element_get_gnlobject (trackelement3);
fail_unless (gnlobj3 != NULL);
/* object3 is on the third layer and has a priority of LAYER_HEIGHT + 1
* it priority must have the maximum priority of this layer*/
assert_equals_int (prio2, 2 * LAYER_HEIGHT + 1);
assert_equals_int (prio3, LAYER_HEIGHT * 3 - 1);
- /* And change TrackObject-s priorities and check that changes are well
+ /* And change TrackElement-s priorities and check that changes are well
* refected on it containing Clip */
- ges_timeline_element_set_priority (GES_TIMELINE_ELEMENT (tckobj3),
+ ges_timeline_element_set_priority (GES_TIMELINE_ELEMENT (trackelement3),
LAYER_HEIGHT * 2);
g_object_get (gnlobj3, "priority", &prio3, NULL);
assert_equals_int (prio3, 2 * LAYER_HEIGHT);
assert_equals_int (_PRIORITY (object3), 0);
- g_object_unref (tckobj1);
- g_object_unref (tckobj2);
- g_object_unref (tckobj3);
+ g_object_unref (trackelement1);
+ g_object_unref (trackelement2);
+ g_object_unref (trackelement3);
g_object_unref (timeline);
}
GES_CLIP (ges_timeline_layer_add_asset (layer,
transition_asset, 1000, 0, 500, 1, GES_TRACK_TYPE_VIDEO));
fail_unless (GES_IS_TRANSITION_CLIP (transition));
- objects = ges_clip_get_track_objects (transition);
+ objects = ges_clip_get_track_elements (transition);
assert_equals_int (g_list_length (objects), 1);
g_list_free_full (objects, gst_object_unref);
GST_START_TEST (test_overlay_properties)
{
GESTrack *track;
- GESTrackObject *trackobject;
+ GESTrackElement *trackelement;
GESClip *object;
ges_init ();
assert_equals_uint64 (_DURATION (object), 51);
assert_equals_uint64 (_INPOINT (object), 12);
- trackobject = ges_clip_create_track_object (object, track->type);
- ges_clip_add_track_object (object, trackobject);
- fail_unless (trackobject != NULL);
- fail_unless (ges_track_object_set_track (trackobject, track));
+ trackelement = ges_clip_create_track_element (object, track->type);
+ ges_clip_add_track_element (object, trackelement);
+ fail_unless (trackelement != NULL);
+ fail_unless (ges_track_element_set_track (trackelement, track));
- /* Check that trackobject has the same properties */
- assert_equals_uint64 (_START (trackobject), 42);
- assert_equals_uint64 (_DURATION (trackobject), 51);
- assert_equals_uint64 (_INPOINT (trackobject), 12);
+ /* Check that trackelement has the same properties */
+ assert_equals_uint64 (_START (trackelement), 42);
+ assert_equals_uint64 (_DURATION (trackelement), 51);
+ assert_equals_uint64 (_INPOINT (trackelement), 12);
/* And let's also check that it propagated correctly to GNonLin */
- gnl_object_check (ges_track_object_get_gnlobject (trackobject), 42, 51, 12,
+ gnl_object_check (ges_track_element_get_gnlobject (trackelement), 42, 51, 12,
51, 0, TRUE);
/* Change more properties, see if they propagate */
assert_equals_uint64 (_START (object), 420);
assert_equals_uint64 (_DURATION (object), 510);
assert_equals_uint64 (_INPOINT (object), 120);
- assert_equals_uint64 (_START (trackobject), 420);
- assert_equals_uint64 (_DURATION (trackobject), 510);
- assert_equals_uint64 (_INPOINT (trackobject), 120);
+ assert_equals_uint64 (_START (trackelement), 420);
+ assert_equals_uint64 (_DURATION (trackelement), 510);
+ assert_equals_uint64 (_INPOINT (trackelement), 120);
/* And let's also check that it propagated correctly to GNonLin */
- gnl_object_check (ges_track_object_get_gnlobject (trackobject), 420, 510, 120,
- 510, 0, TRUE);
+ gnl_object_check (ges_track_element_get_gnlobject (trackelement), 420, 510,
+ 120, 510, 0, TRUE);
- ges_clip_release_track_object (object, trackobject);
+ ges_clip_release_track_element (object, trackelement);
g_object_unref (object);
}
GESTimeline *timeline;
GESTimelineLayer *layer;
GESTrack *a, *v;
- GESTrackObject *trobj;
+ GESTrackElement *trobj;
GESTextOverlayClip *source;
gchar *text;
gint halign, valign;
assert_equals_string ("some text", text);
g_free (text);
- trobj = ges_clip_find_track_object (GES_CLIP (source), v, G_TYPE_NONE);
+ trobj = ges_clip_find_track_element (GES_CLIP (source), v, G_TYPE_NONE);
/* test the font-desc property */
g_object_set (source, "font-desc", (gchar *) "sans 72", NULL);
GESTrack *track;
const GList *profiles;
GstEncodingContainerProfile *profile;
- GList *tracks, *tmp, *tmptckobj, *clips;
+ GList *tracks, *tmp, *tmptrackelement, *clips;
fail_unless (GES_IS_TIMELINE (timeline));
assert_equals_int (g_list_length (timeline->layers), 2);
tracks = ges_timeline_get_tracks (timeline);
assert_equals_int (g_list_length (tracks), 2);
for (tmp = tracks; tmp; tmp = tmp->next) {
- GList *trackobjs;
+ GList *trackelements;
track = GES_TRACK (tmp->data);
- trackobjs = ges_track_get_objects (track);
+ trackelements = ges_track_get_objects (track);
GST_DEBUG_OBJECT (track, "Testing track");
switch (track->type) {
case GES_TRACK_TYPE_VIDEO:
- assert_equals_int (g_list_length (trackobjs), 2);
- for (tmptckobj = trackobjs; tmptckobj; tmptckobj = tmptckobj->next) {
- GESTrackObject *tckobj = GES_TRACK_OBJECT (tmptckobj->data);
+ assert_equals_int (g_list_length (trackelements), 2);
+ for (tmptrackelement = trackelements; tmptrackelement;
+ tmptrackelement = tmptrackelement->next) {
+ GESTrackElement *trackelement =
+ GES_TRACK_ELEMENT (tmptrackelement->data);
- if (GES_IS_TRACK_EFFECT (tckobj)) {
+ if (GES_IS_TRACK_EFFECT (trackelement)) {
guint nb_scratch_lines;
- ges_track_object_get_child_properties (tckobj, "scratch-lines",
- &nb_scratch_lines, NULL);
+ ges_track_element_get_child_properties (trackelement,
+ "scratch-lines", &nb_scratch_lines, NULL);
assert_equals_int (nb_scratch_lines, 12);
- gnl_object_check (ges_track_object_get_gnlobject (tckobj),
+ gnl_object_check (ges_track_element_get_gnlobject (trackelement),
0, 1000000000, 0, 1000000000, 0, TRUE);
} else {
- gnl_object_check (ges_track_object_get_gnlobject (tckobj),
+ gnl_object_check (ges_track_element_get_gnlobject (trackelement),
0, 1000000000, 0, 1000000000, 1, TRUE);
}
}
break;
case GES_TRACK_TYPE_AUDIO:
- assert_equals_int (g_list_length (trackobjs), 2);
+ assert_equals_int (g_list_length (trackelements), 2);
break;
default:
g_assert (1);
}
- g_list_free_full (trackobjs, gst_object_unref);
+ g_list_free_full (trackelements, gst_object_unref);
}
g_list_free_full (tracks, gst_object_unref);
static gboolean
my_fill_track_func (GESClip * object,
- GESTrackObject * trobject, GstElement * gnlobj, gpointer user_data)
+ GESTrackElement * trobject, GstElement * gnlobj, gpointer user_data)
{
GstElement *src;
- GST_DEBUG ("timelineobj:%p, trackobjec:%p, gnlobj:%p",
+ GST_DEBUG ("timelineobj:%p, trackelementec:%p, gnlobj:%p",
object, trobject, gnlobj);
/* Let's just put a fakesource in for the time being */
static gboolean
arbitrary_fill_track_func (GESClip * object,
- GESTrackObject * trobject, GstElement * gnlobj, gpointer user_data)
+ GESTrackElement * trobject, GstElement * gnlobj, gpointer user_data)
{
GstElement *src;
g_assert (user_data);
- GST_DEBUG ("element:%s, timelineobj:%p, trackobjects:%p, gnlobj:%p,",
+ GST_DEBUG ("element:%s, timelineobj:%p, trackelements:%p, gnlobj:%p,",
(const gchar *) user_data, object, trobject, gnlobj);
/* interpret user_data as name of element to create */
GESTimeline *timeline;
GESTimelineLayer *layer;
GESTrack *a, *v;
- GESTrackObject *trobj;
+ GESTrackElement *trobj;
GESTestClip *source;
gchar *text;
gint halign, valign;
(GESClip *) source, 0);
trobj =
- ges_clip_find_track_object (GES_CLIP (source), v,
+ ges_clip_find_track_element (GES_CLIP (source), v,
GES_TYPE_TRACK_TEXT_OVERLAY);
fail_unless (trobj != NULL);
static gboolean
my_fill_track_func (GESClip * object,
- GESTrackObject * trobject, GstElement * gnlobj, gpointer user_data)
+ GESTrackElement * trobject, GstElement * gnlobj, gpointer user_data)
{
GstElement *src;
- GST_DEBUG ("timelineobj:%p, trackobjec:%p, gnlobj:%p",
+ GST_DEBUG ("timelineobj:%p, trackelementec:%p, gnlobj:%p",
object, trobject, gnlobj);
/* Let's just put a fakesource in for the time being */
{
GESTrack *track;
GESTimeline *timeline;
- GESTrackObject *tckobj, *tckobj1, *tckobj2;
+ GESTrackElement *trackelement, *trackelement1, *trackelement2;
GESClip *obj, *obj1, *obj2;
ges_init ();
g_object_set (obj2, "start", (guint64) 50, "duration", (guint64) 60,
"in-point", (guint64) 0, NULL);
- tckobj = ges_clip_create_track_object (obj, track->type);
- fail_unless (tckobj != NULL);
- fail_unless (ges_clip_add_track_object (obj, tckobj));
- fail_unless (ges_track_add_object (track, tckobj));
- assert_equals_uint64 (_DURATION (tckobj), 10);
+ trackelement = ges_clip_create_track_element (obj, track->type);
+ fail_unless (trackelement != NULL);
+ fail_unless (ges_clip_add_track_element (obj, trackelement));
+ fail_unless (ges_track_add_object (track, trackelement));
+ assert_equals_uint64 (_DURATION (trackelement), 10);
- tckobj1 = ges_clip_create_track_object (obj1, track->type);
- fail_unless (tckobj1 != NULL);
- fail_unless (ges_clip_add_track_object (obj1, tckobj1));
- fail_unless (ges_track_add_object (track, tckobj1));
- assert_equals_uint64 (_DURATION (tckobj1), 10);
+ trackelement1 = ges_clip_create_track_element (obj1, track->type);
+ fail_unless (trackelement1 != NULL);
+ fail_unless (ges_clip_add_track_element (obj1, trackelement1));
+ fail_unless (ges_track_add_object (track, trackelement1));
+ assert_equals_uint64 (_DURATION (trackelement1), 10);
- tckobj2 = ges_clip_create_track_object (obj2, track->type);
- fail_unless (ges_clip_add_track_object (obj2, tckobj2));
- fail_unless (tckobj2 != NULL);
- fail_unless (ges_track_add_object (track, tckobj2));
- assert_equals_uint64 (_DURATION (tckobj2), 60);
+ trackelement2 = ges_clip_create_track_element (obj2, track->type);
+ fail_unless (ges_clip_add_track_element (obj2, trackelement2));
+ fail_unless (trackelement2 != NULL);
+ fail_unless (ges_track_add_object (track, trackelement2));
+ assert_equals_uint64 (_DURATION (trackelement2), 60);
/**
* Simple rippling obj to: 10
*/
fail_unless (ges_clip_edit (obj, NULL, -1, GES_EDIT_MODE_RIPPLE,
GES_EDGE_NONE, 10) == TRUE);
- CHECK_OBJECT_PROPS (tckobj, 10, 0, 10);
- CHECK_OBJECT_PROPS (tckobj1, 20, 0, 10);
- CHECK_OBJECT_PROPS (tckobj2, 60, 0, 60);
+ CHECK_OBJECT_PROPS (trackelement, 10, 0, 10);
+ CHECK_OBJECT_PROPS (trackelement1, 20, 0, 10);
+ CHECK_OBJECT_PROPS (trackelement2, 60, 0, 60);
/* FIXME find a way to check that we are using the same MovingContext
* inside the GESTrack */
fail_unless (ges_clip_edit (obj1, NULL, -1, GES_EDIT_MODE_RIPPLE,
GES_EDGE_NONE, 40) == TRUE);
- CHECK_OBJECT_PROPS (tckobj, 10, 0, 10);
- CHECK_OBJECT_PROPS (tckobj1, 40, 0, 10);
- CHECK_OBJECT_PROPS (tckobj2, 80, 0, 60);
+ CHECK_OBJECT_PROPS (trackelement, 10, 0, 10);
+ CHECK_OBJECT_PROPS (trackelement1, 40, 0, 10);
+ CHECK_OBJECT_PROPS (trackelement2, 80, 0, 60);
/**
* Rippling obj1 back to: 20 (getting to the exact same timeline as before
*/
fail_unless (ges_clip_edit (obj1, NULL, -1, GES_EDIT_MODE_RIPPLE,
GES_EDGE_NONE, 20) == TRUE);
- CHECK_OBJECT_PROPS (tckobj, 10, 0, 10);
- CHECK_OBJECT_PROPS (tckobj1, 20, 0, 10);
- CHECK_OBJECT_PROPS (tckobj2, 60, 0, 60);
+ CHECK_OBJECT_PROPS (trackelement, 10, 0, 10);
+ CHECK_OBJECT_PROPS (trackelement1, 20, 0, 10);
+ CHECK_OBJECT_PROPS (trackelement2, 60, 0, 60);
/**
* Simple move obj to: 27 and obj2 to 35
GES_EDGE_NONE, 27) == TRUE);
fail_unless (ges_clip_edit (obj2, NULL, -1, GES_EDIT_MODE_NORMAL,
GES_EDGE_NONE, 35) == TRUE);
- CHECK_OBJECT_PROPS (tckobj, 27, 0, 10);
- CHECK_OBJECT_PROPS (tckobj1, 20, 0, 10);
- CHECK_OBJECT_PROPS (tckobj2, 35, 0, 60);
+ CHECK_OBJECT_PROPS (trackelement, 27, 0, 10);
+ CHECK_OBJECT_PROPS (trackelement1, 20, 0, 10);
+ CHECK_OBJECT_PROPS (trackelement2, 35, 0, 60);
/**
* Trim start obj to: 32 and obj2 to 35
*/
fail_unless (ges_clip_edit (obj, NULL, -1, GES_EDIT_MODE_TRIM,
GES_EDGE_START, 32) == TRUE);
- CHECK_OBJECT_PROPS (tckobj, 32, 5, 5);
- CHECK_OBJECT_PROPS (tckobj1, 20, 0, 10);
- CHECK_OBJECT_PROPS (tckobj2, 35, 0, 60);
+ CHECK_OBJECT_PROPS (trackelement, 32, 5, 5);
+ CHECK_OBJECT_PROPS (trackelement1, 20, 0, 10);
+ CHECK_OBJECT_PROPS (trackelement2, 35, 0, 60);
/* Ripple end obj to 42
* New timeline:
*/
fail_unless (ges_clip_edit (obj, NULL, -1, GES_EDIT_MODE_RIPPLE,
GES_EDGE_END, 42) == TRUE);
- CHECK_OBJECT_PROPS (tckobj, 32, 5, 10);
- CHECK_OBJECT_PROPS (tckobj1, 20, 0, 10);
- CHECK_OBJECT_PROPS (tckobj2, 35, 0, 60);
+ CHECK_OBJECT_PROPS (trackelement, 32, 5, 10);
+ CHECK_OBJECT_PROPS (trackelement1, 20, 0, 10);
+ CHECK_OBJECT_PROPS (trackelement2, 35, 0, 60);
/**
* New timeline:
GES_EDGE_NONE, 42) == TRUE);
fail_unless (ges_clip_edit (obj, NULL, -1, GES_EDIT_MODE_RIPPLE,
GES_EDGE_END, 52) == TRUE);
- CHECK_OBJECT_PROPS (tckobj, 32, 5, 20);
- CHECK_OBJECT_PROPS (tckobj1, 20, 0, 10);
- CHECK_OBJECT_PROPS (tckobj2, 52, 0, 60);
+ CHECK_OBJECT_PROPS (trackelement, 32, 5, 20);
+ CHECK_OBJECT_PROPS (trackelement1, 20, 0, 10);
+ CHECK_OBJECT_PROPS (trackelement2, 52, 0, 60);
/**
* New timeline:
*/
fail_unless (ges_clip_edit (obj1, NULL, -1, GES_EDIT_MODE_RIPPLE,
GES_EDGE_END, 40) == TRUE);
- CHECK_OBJECT_PROPS (tckobj, 42, 5, 20);
- CHECK_OBJECT_PROPS (tckobj1, 20, 0, 20);
- CHECK_OBJECT_PROPS (tckobj2, 62, 0, 60);
+ CHECK_OBJECT_PROPS (trackelement, 42, 5, 20);
+ CHECK_OBJECT_PROPS (trackelement1, 20, 0, 20);
+ CHECK_OBJECT_PROPS (trackelement2, 62, 0, 60);
/**
* New timeline:
GES_EDGE_START, 40) == TRUE);
fail_unless (ges_clip_edit (obj, NULL, -1, GES_EDIT_MODE_ROLL,
GES_EDGE_START, 25) == TRUE);
- CHECK_OBJECT_PROPS (tckobj, 25, 0, 37);
- CHECK_OBJECT_PROPS (tckobj1, 20, 0, 5);
- CHECK_OBJECT_PROPS (tckobj2, 62, 0, 60);
+ CHECK_OBJECT_PROPS (trackelement, 25, 0, 37);
+ CHECK_OBJECT_PROPS (trackelement1, 20, 0, 5);
+ CHECK_OBJECT_PROPS (trackelement2, 62, 0, 60);
/* Make sure that not doing anything when not able to roll */
fail_unless (ges_clip_edit (obj, NULL, -1, GES_EDIT_MODE_ROLL,
GES_EDGE_START, 65) == TRUE);
fail_unless (ges_clip_edit (obj1, NULL, -1, GES_EDIT_MODE_ROLL,
GES_EDGE_END, 65) == TRUE, 0);
- CHECK_OBJECT_PROPS (tckobj, 25, 0, 37);
- CHECK_OBJECT_PROPS (tckobj1, 20, 0, 5);
- CHECK_OBJECT_PROPS (tckobj2, 62, 0, 60);
+ CHECK_OBJECT_PROPS (trackelement, 25, 0, 37);
+ CHECK_OBJECT_PROPS (trackelement1, 20, 0, 5);
+ CHECK_OBJECT_PROPS (trackelement2, 62, 0, 60);
g_object_unref (timeline);
g_object_unref (obj);
{
GESTrack *track;
GESTimeline *timeline;
- GESTrackObject *tckobj, *tckobj1, *tckobj2;
+ GESTrackElement *trackelement, *trackelement1, *trackelement2;
GESClip *obj, *obj1, *obj2;
GESTimelineLayer *layer;
- GList *tckobjs;
+ GList *trackelements;
ges_init ();
fail_unless (ges_timeline_layer_add_object (layer, obj));
- fail_unless ((tckobjs = ges_clip_get_track_objects (obj)) != NULL);
- fail_unless ((tckobj = GES_TRACK_OBJECT (tckobjs->data)) != NULL);
- fail_unless (ges_track_object_get_track (tckobj) == track);
- assert_equals_uint64 (_DURATION (tckobj), 37);
- g_list_free_full (tckobjs, g_object_unref);
-
- /* We have 3 references to tckobj from:
+ fail_unless ((trackelements = ges_clip_get_track_elements (obj)) != NULL);
+ fail_unless ((trackelement =
+ GES_TRACK_ELEMENT (trackelements->data)) != NULL);
+ fail_unless (ges_track_element_get_track (trackelement) == track);
+ assert_equals_uint64 (_DURATION (trackelement), 37);
+ g_list_free_full (trackelements, g_object_unref);
+
+ /* We have 3 references to trackelement from:
* track + timeline + obj */
- ASSERT_OBJECT_REFCOUNT (tckobj, "First tckobj", 3);
+ ASSERT_OBJECT_REFCOUNT (trackelement, "First trackelement", 3);
/* We have 1 ref to obj1:
* + layer */
ASSERT_OBJECT_REFCOUNT (obj, "First clip", 1);
fail_unless (ges_timeline_layer_add_object (layer, obj1));
- fail_unless ((tckobjs = ges_clip_get_track_objects (obj1)) != NULL);
- fail_unless ((tckobj1 = GES_TRACK_OBJECT (tckobjs->data)) != NULL);
- fail_unless (ges_track_object_get_track (tckobj1) == track);
- assert_equals_uint64 (_DURATION (tckobj1), 15);
- g_list_free_full (tckobjs, g_object_unref);
+ fail_unless ((trackelements = ges_clip_get_track_elements (obj1)) != NULL);
+ fail_unless ((trackelement1 =
+ GES_TRACK_ELEMENT (trackelements->data)) != NULL);
+ fail_unless (ges_track_element_get_track (trackelement1) == track);
+ assert_equals_uint64 (_DURATION (trackelement1), 15);
+ g_list_free_full (trackelements, g_object_unref);
/* Same ref logic */
- ASSERT_OBJECT_REFCOUNT (tckobj1, "First tckobj", 3);
+ ASSERT_OBJECT_REFCOUNT (trackelement1, "First trackelement", 3);
ASSERT_OBJECT_REFCOUNT (obj1, "First clip", 1);
fail_unless (ges_timeline_layer_add_object (layer, obj2));
- fail_unless ((tckobjs = ges_clip_get_track_objects (obj2)) != NULL);
- fail_unless ((tckobj2 = GES_TRACK_OBJECT (tckobjs->data)) != NULL);
- fail_unless (ges_track_object_get_track (tckobj2) == track);
- assert_equals_uint64 (_DURATION (tckobj2), 60);
- g_list_free_full (tckobjs, g_object_unref);
+ fail_unless ((trackelements = ges_clip_get_track_elements (obj2)) != NULL);
+ fail_unless ((trackelement2 =
+ GES_TRACK_ELEMENT (trackelements->data)) != NULL);
+ fail_unless (ges_track_element_get_track (trackelement2) == track);
+ assert_equals_uint64 (_DURATION (trackelement2), 60);
+ g_list_free_full (trackelements, g_object_unref);
/* Same ref logic */
- ASSERT_OBJECT_REFCOUNT (tckobj2, "First tckobj", 3);
+ ASSERT_OBJECT_REFCOUNT (trackelement2, "First trackelement", 3);
ASSERT_OBJECT_REFCOUNT (obj2, "First clip", 1);
/* Snaping to edge, so no move */
g_object_set (timeline, "snapping-distance", (guint64) 3, NULL);
fail_unless (ges_clip_edit (obj1, NULL, -1, GES_EDIT_MODE_TRIM,
GES_EDGE_END, 27) == TRUE);
- CHECK_OBJECT_PROPS (tckobj, 25, 0, 37);
- CHECK_OBJECT_PROPS (tckobj1, 20, 0, 5);
- CHECK_OBJECT_PROPS (tckobj2, 62, 0, 60);
+ CHECK_OBJECT_PROPS (trackelement, 25, 0, 37);
+ CHECK_OBJECT_PROPS (trackelement1, 20, 0, 5);
+ CHECK_OBJECT_PROPS (trackelement2, 62, 0, 60);
/* Snaping to edge, so no move */
fail_unless (ges_clip_edit (obj1, NULL, -1, GES_EDIT_MODE_TRIM,
GES_EDGE_END, 27) == TRUE);
- CHECK_OBJECT_PROPS (tckobj, 25, 0, 37);
- CHECK_OBJECT_PROPS (tckobj1, 20, 0, 5);
- CHECK_OBJECT_PROPS (tckobj2, 62, 0, 60);
+ CHECK_OBJECT_PROPS (trackelement, 25, 0, 37);
+ CHECK_OBJECT_PROPS (trackelement1, 20, 0, 5);
+ CHECK_OBJECT_PROPS (trackelement2, 62, 0, 60);
/**
* New timeline:
*/
g_object_set (timeline, "snapping-distance", (guint64) 0, NULL);
ges_timeline_element_set_duration (GES_TIMELINE_ELEMENT (obj1), 10);
- CHECK_OBJECT_PROPS (tckobj, 25, 0, 37);
- CHECK_OBJECT_PROPS (tckobj1, 20, 0, 10);
- CHECK_OBJECT_PROPS (tckobj2, 62, 0, 60);
+ CHECK_OBJECT_PROPS (trackelement, 25, 0, 37);
+ CHECK_OBJECT_PROPS (trackelement1, 20, 0, 10);
+ CHECK_OBJECT_PROPS (trackelement2, 62, 0, 60);
/**
* New timeline(the "layers" are just to help reading diagram, nothing else):
fail_unless (ges_timeline_element_roll_end (GES_TIMELINE_ELEMENT (obj1), 62));
fail_unless (ges_timeline_element_roll_end (GES_TIMELINE_ELEMENT (obj1),
72) == TRUE);
- CHECK_OBJECT_PROPS (tckobj, 25, 0, 37);
- CHECK_OBJECT_PROPS (tckobj1, 20, 0, 52);
- CHECK_OBJECT_PROPS (tckobj2, 72, 10, 50);
+ CHECK_OBJECT_PROPS (trackelement, 25, 0, 37);
+ CHECK_OBJECT_PROPS (trackelement1, 20, 0, 52);
+ CHECK_OBJECT_PROPS (trackelement2, 72, 10, 50);
/**
* 0----------
g_object_set (timeline, "snapping-distance", (guint64) 4, NULL);
fail_unless (ges_timeline_element_trim (GES_TIMELINE_ELEMENT (obj1),
28) == TRUE);
- CHECK_OBJECT_PROPS (tckobj, 25, 0, 37);
- CHECK_OBJECT_PROPS (tckobj1, 25, 5, 47);
- CHECK_OBJECT_PROPS (tckobj2, 72, 10, 50);
+ CHECK_OBJECT_PROPS (trackelement, 25, 0, 37);
+ CHECK_OBJECT_PROPS (trackelement1, 25, 5, 47);
+ CHECK_OBJECT_PROPS (trackelement2, 72, 10, 50);
/**
* 0----------
*/
fail_unless (ges_timeline_element_roll_start (GES_TIMELINE_ELEMENT (obj2),
59) == TRUE);
- CHECK_OBJECT_PROPS (tckobj, 25, 0, 37);
- CHECK_OBJECT_PROPS (tckobj1, 25, 5, 37);
- CHECK_OBJECT_PROPS (tckobj2, 62, 0, 60);
+ CHECK_OBJECT_PROPS (trackelement, 25, 0, 37);
+ CHECK_OBJECT_PROPS (trackelement1, 25, 5, 37);
+ CHECK_OBJECT_PROPS (trackelement2, 62, 0, 60);
/**
* inpoints 0----------5---------- 0----------
*/
fail_unless (ges_timeline_element_ripple (GES_TIMELINE_ELEMENT (obj1),
58) == TRUE);
- CHECK_OBJECT_PROPS (tckobj, 25, 0, 37);
- CHECK_OBJECT_PROPS (tckobj1, 62, 5, 37);
- CHECK_OBJECT_PROPS (tckobj2, 99, 0, 60);
+ CHECK_OBJECT_PROPS (trackelement, 25, 0, 37);
+ CHECK_OBJECT_PROPS (trackelement1, 62, 5, 37);
+ CHECK_OBJECT_PROPS (trackelement2, 99, 0, 60);
/**
* inpoints 0----------5---------- 0----------
* time 25---------62-------- 99 110--------170
*/
ges_timeline_element_set_start (GES_TIMELINE_ELEMENT (obj2), 110);
- CHECK_OBJECT_PROPS (tckobj, 25, 0, 37);
- CHECK_OBJECT_PROPS (tckobj1, 62, 5, 37);
- CHECK_OBJECT_PROPS (tckobj2, 110, 0, 60);
+ CHECK_OBJECT_PROPS (trackelement, 25, 0, 37);
+ CHECK_OBJECT_PROPS (trackelement1, 62, 5, 37);
+ CHECK_OBJECT_PROPS (trackelement2, 110, 0, 60);
/**
* inpoints 0----------5 5 --------- 0----------
*/
fail_unless (ges_clip_edit (obj1, NULL, -1, GES_EDIT_MODE_NORMAL,
GES_EDGE_NONE, 72) == TRUE);
- CHECK_OBJECT_PROPS (tckobj, 25, 0, 37);
- CHECK_OBJECT_PROPS (tckobj1, 73, 5, 37);
- CHECK_OBJECT_PROPS (tckobj2, 110, 0, 60);
+ CHECK_OBJECT_PROPS (trackelement, 25, 0, 37);
+ CHECK_OBJECT_PROPS (trackelement1, 73, 5, 37);
+ CHECK_OBJECT_PROPS (trackelement2, 110, 0, 60);
/**
* inpoints 0----------5---------- 0----------
*/
fail_unless (ges_clip_edit (obj1, NULL, -1, GES_EDIT_MODE_NORMAL,
GES_EDGE_NONE, 58) == TRUE);
- CHECK_OBJECT_PROPS (tckobj, 25, 0, 37);
- CHECK_OBJECT_PROPS (tckobj1, 62, 5, 37);
- CHECK_OBJECT_PROPS (tckobj2, 110, 0, 60);
+ CHECK_OBJECT_PROPS (trackelement, 25, 0, 37);
+ CHECK_OBJECT_PROPS (trackelement1, 62, 5, 37);
+ CHECK_OBJECT_PROPS (trackelement2, 110, 0, 60);
/**
* time 25---------62--------110--------170
*/
g_object_set (obj1, "duration", 46, NULL);
- CHECK_OBJECT_PROPS (tckobj, 25, 0, 37);
- CHECK_OBJECT_PROPS (tckobj1, 62, 5, 48);
- CHECK_OBJECT_PROPS (tckobj2, 110, 0, 60);
+ CHECK_OBJECT_PROPS (trackelement, 25, 0, 37);
+ CHECK_OBJECT_PROPS (trackelement1, 62, 5, 48);
+ CHECK_OBJECT_PROPS (trackelement2, 110, 0, 60);
/**
* inpoints 5----------- 0--------- 0----------
* time 62---------110--------170--------207
*/
g_object_set (obj, "start", 168, NULL);
- CHECK_OBJECT_PROPS (tckobj, 170, 0, 37);
- CHECK_OBJECT_PROPS (tckobj1, 62, 5, 48);
- CHECK_OBJECT_PROPS (tckobj2, 110, 0, 60);
+ CHECK_OBJECT_PROPS (trackelement, 170, 0, 37);
+ CHECK_OBJECT_PROPS (trackelement1, 62, 5, 48);
+ CHECK_OBJECT_PROPS (trackelement2, 110, 0, 60);
/* Check we didn't lose/screwed any references */
- ASSERT_OBJECT_REFCOUNT (tckobj, "First tckobj", 3);
- ASSERT_OBJECT_REFCOUNT (tckobj1, "Second tckobj", 3);
- ASSERT_OBJECT_REFCOUNT (tckobj2, "Third tckobj", 3);
+ ASSERT_OBJECT_REFCOUNT (trackelement, "First trackelement", 3);
+ ASSERT_OBJECT_REFCOUNT (trackelement1, "Second trackelement", 3);
+ ASSERT_OBJECT_REFCOUNT (trackelement2, "Third trackelement", 3);
ASSERT_OBJECT_REFCOUNT (obj, "First clip", 1);
ASSERT_OBJECT_REFCOUNT (obj1, "Second clip", 1);
ASSERT_OBJECT_REFCOUNT (obj2, "Third clip", 1);
g_object_unref (timeline);
/* Check we destroyed everything */
- fail_if (G_IS_OBJECT (tckobj));
- fail_if (G_IS_OBJECT (tckobj1));
- fail_if (G_IS_OBJECT (tckobj2));
+ fail_if (G_IS_OBJECT (trackelement));
+ fail_if (G_IS_OBJECT (trackelement1));
+ fail_if (G_IS_OBJECT (trackelement2));
fail_if (G_IS_OBJECT (obj));
fail_if (G_IS_OBJECT (obj1));
fail_if (G_IS_OBJECT (obj2));
guint i;
GESTrack *track;
GESTimeline *timeline;
- GESTrackObject *tckobj, *tckobj1, *tckobj2;
+ GESTrackElement *trackelement, *trackelement1, *trackelement2;
GESClip *obj, *obj1, *obj2;
GESTimelineLayer *layer, *layer1, *layer2;
- GList *tckobjs, *layers, *tmp;
+ GList *trackelements, *layers, *tmp;
ges_init ();
fail_unless (ges_timeline_layer_add_object (layer, obj));
- fail_unless ((tckobjs = ges_clip_get_track_objects (obj)) != NULL);
- fail_unless ((tckobj = GES_TRACK_OBJECT (tckobjs->data)) != NULL);
- fail_unless (ges_track_object_get_track (tckobj) == track);
- assert_equals_uint64 (_DURATION (tckobj), 10);
- g_list_free_full (tckobjs, g_object_unref);
+ fail_unless ((trackelements = ges_clip_get_track_elements (obj)) != NULL);
+ fail_unless ((trackelement =
+ GES_TRACK_ELEMENT (trackelements->data)) != NULL);
+ fail_unless (ges_track_element_get_track (trackelement) == track);
+ assert_equals_uint64 (_DURATION (trackelement), 10);
+ g_list_free_full (trackelements, g_object_unref);
/* Add a new layer and add objects to it */
fail_unless ((layer1 = ges_timeline_append_layer (timeline)) != NULL);
assert_equals_int (ges_timeline_layer_get_priority (layer1), 1);
fail_unless (ges_timeline_layer_add_object (layer1, obj1));
- fail_unless ((tckobjs = ges_clip_get_track_objects (obj1)) != NULL);
- fail_unless ((tckobj1 = GES_TRACK_OBJECT (tckobjs->data)) != NULL);
- fail_unless (ges_track_object_get_track (tckobj1) == track);
- assert_equals_uint64 (_DURATION (tckobj1), 10);
- g_list_free_full (tckobjs, g_object_unref);
+ fail_unless ((trackelements = ges_clip_get_track_elements (obj1)) != NULL);
+ fail_unless ((trackelement1 =
+ GES_TRACK_ELEMENT (trackelements->data)) != NULL);
+ fail_unless (ges_track_element_get_track (trackelement1) == track);
+ assert_equals_uint64 (_DURATION (trackelement1), 10);
+ g_list_free_full (trackelements, g_object_unref);
fail_unless (ges_timeline_layer_add_object (layer1, obj2));
- fail_unless ((tckobjs = ges_clip_get_track_objects (obj2)) != NULL);
- fail_unless ((tckobj2 = GES_TRACK_OBJECT (tckobjs->data)) != NULL);
- fail_unless (ges_track_object_get_track (tckobj2) == track);
- assert_equals_uint64 (_DURATION (tckobj2), 60);
- g_list_free_full (tckobjs, g_object_unref);
+ fail_unless ((trackelements = ges_clip_get_track_elements (obj2)) != NULL);
+ fail_unless ((trackelement2 =
+ GES_TRACK_ELEMENT (trackelements->data)) != NULL);
+ fail_unless (ges_track_element_get_track (trackelement2) == track);
+ assert_equals_uint64 (_DURATION (trackelement2), 60);
+ g_list_free_full (trackelements, g_object_unref);
/**
* Simple rippling obj to: 10
*/
fail_unless (ges_clip_edit (obj, NULL, -1, GES_EDIT_MODE_RIPPLE,
GES_EDGE_NONE, 10) == TRUE);
- CHECK_OBJECT_PROPS (tckobj, 10, 0, 10);
- CHECK_OBJECT_PROPS (tckobj1, 20, 0, 10);
- CHECK_OBJECT_PROPS (tckobj2, 60, 0, 60);
+ CHECK_OBJECT_PROPS (trackelement, 10, 0, 10);
+ CHECK_OBJECT_PROPS (trackelement1, 20, 0, 10);
+ CHECK_OBJECT_PROPS (trackelement2, 60, 0, 60);
/* FIXME find a way to check that we are using the same MovingContext
* inside the GESTimeline */
fail_unless (ges_clip_edit (obj1, NULL, 3, GES_EDIT_MODE_RIPPLE,
GES_EDGE_NONE, 40) == TRUE);
- CHECK_OBJECT_PROPS (tckobj, 10, 0, 10);
- CHECK_OBJECT_PROPS (tckobj1, 40, 0, 10);
- CHECK_OBJECT_PROPS (tckobj2, 80, 0, 60);
+ CHECK_OBJECT_PROPS (trackelement, 10, 0, 10);
+ CHECK_OBJECT_PROPS (trackelement1, 40, 0, 10);
+ CHECK_OBJECT_PROPS (trackelement2, 80, 0, 60);
layer2 = ges_clip_get_layer (obj1);
assert_equals_int (ges_timeline_layer_get_priority (layer2), 3);
/* obj2 should have moved layer too */
*/
fail_unless (ges_clip_edit (obj1, NULL, 1, GES_EDIT_MODE_RIPPLE,
GES_EDGE_NONE, 20) == TRUE);
- CHECK_OBJECT_PROPS (tckobj, 10, 0, 10);
- CHECK_OBJECT_PROPS (tckobj1, 20, 0, 10);
- CHECK_OBJECT_PROPS (tckobj2, 60, 0, 60);
+ CHECK_OBJECT_PROPS (trackelement, 10, 0, 10);
+ CHECK_OBJECT_PROPS (trackelement1, 20, 0, 10);
+ CHECK_OBJECT_PROPS (trackelement2, 60, 0, 60);
layer2 = ges_clip_get_layer (obj1);
assert_equals_int (ges_timeline_layer_get_priority (layer2), 1);
/* obj2 should have moved layer too */
GES_EDGE_NONE, 27) == TRUE);
fail_unless (ges_clip_edit (obj2, NULL, -1, GES_EDIT_MODE_NORMAL,
GES_EDGE_NONE, 35) == TRUE);
- CHECK_OBJECT_PROPS (tckobj, 27, 0, 10);
- CHECK_OBJECT_PROPS (tckobj1, 20, 0, 10);
- CHECK_OBJECT_PROPS (tckobj2, 35, 0, 60);
+ CHECK_OBJECT_PROPS (trackelement, 27, 0, 10);
+ CHECK_OBJECT_PROPS (trackelement1, 20, 0, 10);
+ CHECK_OBJECT_PROPS (trackelement2, 35, 0, 60);
/**
* Simple trimming start obj to: 32
*/
fail_unless (ges_clip_edit (obj, NULL, -1, GES_EDIT_MODE_TRIM,
GES_EDGE_START, 32) == TRUE);
- CHECK_OBJECT_PROPS (tckobj, 32, 5, 5);
- CHECK_OBJECT_PROPS (tckobj1, 20, 0, 10);
- CHECK_OBJECT_PROPS (tckobj2, 35, 0, 60);
+ CHECK_OBJECT_PROPS (trackelement, 32, 5, 5);
+ CHECK_OBJECT_PROPS (trackelement1, 20, 0, 10);
+ CHECK_OBJECT_PROPS (trackelement2, 35, 0, 60);
/* Ripple end obj to 35 and move to layer 2
* New timeline:
*/
fail_unless (ges_clip_edit (obj, NULL, 2, GES_EDIT_MODE_RIPPLE,
GES_EDGE_END, 35) == TRUE);
- CHECK_OBJECT_PROPS (tckobj, 32, 5, 3);
- CHECK_OBJECT_PROPS (tckobj1, 20, 0, 10);
- CHECK_OBJECT_PROPS (tckobj2, 35, 0, 60);
+ CHECK_OBJECT_PROPS (trackelement, 32, 5, 3);
+ CHECK_OBJECT_PROPS (trackelement1, 20, 0, 10);
+ CHECK_OBJECT_PROPS (trackelement2, 35, 0, 60);
layer = ges_clip_get_layer (obj);
assert_equals_int (ges_timeline_layer_get_priority (layer), 2);
g_object_unref (layer);
*/
fail_unless (ges_clip_edit (obj, NULL, 2, GES_EDIT_MODE_ROLL,
GES_EDGE_END, 50) == TRUE);
- CHECK_OBJECT_PROPS (tckobj, 32, 5, 18);
- CHECK_OBJECT_PROPS (tckobj1, 20, 0, 10);
- CHECK_OBJECT_PROPS (tckobj2, 50, 15, 45);
+ CHECK_OBJECT_PROPS (trackelement, 32, 5, 18);
+ CHECK_OBJECT_PROPS (trackelement1, 20, 0, 10);
+ CHECK_OBJECT_PROPS (trackelement2, 50, 15, 45);
layer = ges_clip_get_layer (obj);
assert_equals_int (ges_timeline_layer_get_priority (layer), 2);
g_object_unref (layer);
fail_unless (ges_clip_edit (obj, NULL, -1, GES_EDIT_MODE_ROLL,
GES_EDGE_END, random) == TRUE);
- CHECK_OBJECT_PROPS (tckobj, 32, 5, random - 32);
- CHECK_OBJECT_PROPS (tckobj1, 20, 0, 10);
- CHECK_OBJECT_PROPS (tckobj2, random, tck3_inpoint, 95 - random);
+ CHECK_OBJECT_PROPS (trackelement, 32, 5, random - 32);
+ CHECK_OBJECT_PROPS (trackelement1, 20, 0, 10);
+ CHECK_OBJECT_PROPS (trackelement2, random, tck3_inpoint, 95 - random);
}
/* Roll end obj back to 35
*/
fail_unless (ges_clip_edit (obj, NULL, 2, GES_EDIT_MODE_ROLL,
GES_EDGE_END, 35) == TRUE);
- CHECK_OBJECT_PROPS (tckobj, 32, 5, 3);
- CHECK_OBJECT_PROPS (tckobj1, 20, 0, 10);
- CHECK_OBJECT_PROPS (tckobj2, 35, 0, 60);
+ CHECK_OBJECT_PROPS (trackelement, 32, 5, 3);
+ CHECK_OBJECT_PROPS (trackelement1, 20, 0, 10);
+ CHECK_OBJECT_PROPS (trackelement2, 35, 0, 60);
layer = ges_clip_get_layer (obj);
assert_equals_int (ges_timeline_layer_get_priority (layer), 2);
g_object_unref (layer);
/* Can not move to the first layer as obj2 should move to a layer with priority < 0 */
fail_unless (ges_clip_edit (obj, NULL, 0, GES_EDIT_MODE_RIPPLE,
GES_EDGE_END, 52) == TRUE);
- CHECK_OBJECT_PROPS (tckobj, 32, 5, 20);
- CHECK_OBJECT_PROPS (tckobj1, 20, 0, 10);
- CHECK_OBJECT_PROPS (tckobj2, 52, 0, 60)
+ CHECK_OBJECT_PROPS (trackelement, 32, 5, 20);
+ CHECK_OBJECT_PROPS (trackelement1, 20, 0, 10);
+ CHECK_OBJECT_PROPS (trackelement2, 52, 0, 60)
layer = ges_clip_get_layer (obj);
assert_equals_int (ges_timeline_layer_get_priority (layer), 2);
g_object_unref (layer);
/* We have 3 references:
* track + timeline + obj
*/
- ASSERT_OBJECT_REFCOUNT (tckobj, "First tckobj", 3);
- ASSERT_OBJECT_REFCOUNT (tckobj1, "Second tckobj", 3);
- ASSERT_OBJECT_REFCOUNT (tckobj2, "Third tckobj", 3);
+ ASSERT_OBJECT_REFCOUNT (trackelement, "First trackelement", 3);
+ ASSERT_OBJECT_REFCOUNT (trackelement1, "Second trackelement", 3);
+ ASSERT_OBJECT_REFCOUNT (trackelement2, "Third trackelement", 3);
/* We have 1 ref:
* + layer */
ASSERT_OBJECT_REFCOUNT (obj, "First clip", 1);
*/
fail_unless (ges_clip_edit (obj1, NULL, 0, GES_EDIT_MODE_RIPPLE,
GES_EDGE_END, 40) == TRUE);
- CHECK_OBJECT_PROPS (tckobj, 42, 5, 20);
- CHECK_OBJECT_PROPS (tckobj1, 20, 0, 20);
- CHECK_OBJECT_PROPS (tckobj2, 62, 0, 60);
+ CHECK_OBJECT_PROPS (trackelement, 42, 5, 20);
+ CHECK_OBJECT_PROPS (trackelement1, 20, 0, 20);
+ CHECK_OBJECT_PROPS (trackelement2, 62, 0, 60);
/* Check that movement between layer has been done properly */
layer1 = ges_clip_get_layer (obj);
*/
fail_unless (ges_clip_edit (obj, NULL, -1, GES_EDIT_MODE_TRIM,
GES_EDGE_START, 40) == TRUE);
- CHECK_OBJECT_PROPS (tckobj, 40, 3, 22);
- CHECK_OBJECT_PROPS (tckobj1, 20, 0, 20);
- CHECK_OBJECT_PROPS (tckobj2, 62, 0, 60);
+ CHECK_OBJECT_PROPS (trackelement, 40, 3, 22);
+ CHECK_OBJECT_PROPS (trackelement1, 20, 0, 20);
+ CHECK_OBJECT_PROPS (trackelement2, 62, 0, 60);
/* Roll obj end to 25
* New timeline:
*/
fail_unless (ges_clip_edit (obj1, NULL, -1, GES_EDIT_MODE_ROLL,
GES_EDGE_END, 25) == TRUE);
- CHECK_OBJECT_PROPS (tckobj, 25, 0, 37);
- CHECK_OBJECT_PROPS (tckobj1, 20, 0, 5);
- CHECK_OBJECT_PROPS (tckobj2, 62, 0, 60);
+ CHECK_OBJECT_PROPS (trackelement, 25, 0, 37);
+ CHECK_OBJECT_PROPS (trackelement1, 20, 0, 5);
+ CHECK_OBJECT_PROPS (trackelement2, 62, 0, 60);
/* Make sure that not doing anything when not able to roll */
fail_unless (ges_clip_edit (obj, NULL, -1, GES_EDIT_MODE_ROLL,
GES_EDGE_START, 65) == TRUE);
fail_unless (ges_clip_edit (obj1, NULL, -1, GES_EDIT_MODE_ROLL,
GES_EDGE_END, 65) == TRUE, 0);
- CHECK_OBJECT_PROPS (tckobj, 25, 0, 37);
- CHECK_OBJECT_PROPS (tckobj1, 20, 0, 5);
- CHECK_OBJECT_PROPS (tckobj2, 62, 0, 60);
+ CHECK_OBJECT_PROPS (trackelement, 25, 0, 37);
+ CHECK_OBJECT_PROPS (trackelement1, 20, 0, 5);
+ CHECK_OBJECT_PROPS (trackelement2, 62, 0, 60);
/* Snaping to edge, so no move */
g_object_set (timeline, "snapping-distance", (guint64) 3, NULL);
fail_unless (ges_clip_edit (obj1, NULL, -1, GES_EDIT_MODE_TRIM,
GES_EDGE_END, 27) == TRUE);
- CHECK_OBJECT_PROPS (tckobj, 25, 0, 37);
- CHECK_OBJECT_PROPS (tckobj1, 20, 0, 5);
- CHECK_OBJECT_PROPS (tckobj2, 62, 0, 60);
+ CHECK_OBJECT_PROPS (trackelement, 25, 0, 37);
+ CHECK_OBJECT_PROPS (trackelement1, 20, 0, 5);
+ CHECK_OBJECT_PROPS (trackelement2, 62, 0, 60);
/* Snaping to edge, so no move */
fail_unless (ges_clip_edit (obj1, NULL, -1, GES_EDIT_MODE_TRIM,
GES_EDGE_END, 27) == TRUE);
- CHECK_OBJECT_PROPS (tckobj, 25, 0, 37);
- CHECK_OBJECT_PROPS (tckobj1, 20, 0, 5);
- CHECK_OBJECT_PROPS (tckobj2, 62, 0, 60);
+ CHECK_OBJECT_PROPS (trackelement, 25, 0, 37);
+ CHECK_OBJECT_PROPS (trackelement1, 20, 0, 5);
+ CHECK_OBJECT_PROPS (trackelement2, 62, 0, 60);
/**
* New timeline:
g_object_set (timeline, "snapping-distance", (guint64) 0, NULL);
fail_unless (ges_clip_edit (obj1, NULL, -1, GES_EDIT_MODE_TRIM,
GES_EDGE_END, 30) == TRUE);
- CHECK_OBJECT_PROPS (tckobj, 25, 0, 37);
- CHECK_OBJECT_PROPS (tckobj1, 20, 0, 10);
- CHECK_OBJECT_PROPS (tckobj2, 62, 0, 60);
+ CHECK_OBJECT_PROPS (trackelement, 25, 0, 37);
+ CHECK_OBJECT_PROPS (trackelement1, 20, 0, 10);
+ CHECK_OBJECT_PROPS (trackelement2, 62, 0, 60);
/**
* New timeline
GES_EDGE_END, 62) == TRUE);
fail_unless (ges_clip_edit (obj1, NULL, -1, GES_EDIT_MODE_ROLL,
GES_EDGE_END, 72) == TRUE);
- CHECK_OBJECT_PROPS (tckobj, 25, 0, 37);
- CHECK_OBJECT_PROPS (tckobj1, 20, 0, 52);
- CHECK_OBJECT_PROPS (tckobj2, 72, 10, 50);
+ CHECK_OBJECT_PROPS (trackelement, 25, 0, 37);
+ CHECK_OBJECT_PROPS (trackelement1, 20, 0, 52);
+ CHECK_OBJECT_PROPS (trackelement2, 72, 10, 50);
/* Test Snapping */
/**
g_object_set (timeline, "snapping-distance", (guint64) 4, NULL);
fail_unless (ges_clip_edit (obj1, NULL, -1, GES_EDIT_MODE_TRIM,
GES_EDGE_START, 28) == TRUE);
- CHECK_OBJECT_PROPS (tckobj, 25, 0, 37);
- CHECK_OBJECT_PROPS (tckobj1, 25, 5, 47);
- CHECK_OBJECT_PROPS (tckobj2, 72, 10, 50);
+ CHECK_OBJECT_PROPS (trackelement, 25, 0, 37);
+ CHECK_OBJECT_PROPS (trackelement1, 25, 5, 47);
+ CHECK_OBJECT_PROPS (trackelement2, 72, 10, 50);
/**
* 0----------
*/
fail_unless (ges_clip_edit (obj2, NULL, -1, GES_EDIT_MODE_ROLL,
GES_EDGE_START, 59) == TRUE);
- CHECK_OBJECT_PROPS (tckobj, 25, 0, 37);
- CHECK_OBJECT_PROPS (tckobj1, 25, 5, 37);
- CHECK_OBJECT_PROPS (tckobj2, 62, 0, 60);
+ CHECK_OBJECT_PROPS (trackelement, 25, 0, 37);
+ CHECK_OBJECT_PROPS (trackelement1, 25, 5, 37);
+ CHECK_OBJECT_PROPS (trackelement2, 62, 0, 60);
}
GST_START_TEST (test_title_source_properties)
{
GESTrack *track;
- GESTrackObject *trackobject;
+ GESTrackElement *trackelement;
GESClip *object;
ges_init ();
assert_equals_uint64 (_DURATION (object), 51);
assert_equals_uint64 (_INPOINT (object), 12);
- trackobject = ges_clip_create_track_object (object, track->type);
- ges_clip_add_track_object (object, trackobject);
- fail_unless (trackobject != NULL);
- fail_unless (ges_track_object_set_track (trackobject, track));
+ trackelement = ges_clip_create_track_element (object, track->type);
+ ges_clip_add_track_element (object, trackelement);
+ fail_unless (trackelement != NULL);
+ fail_unless (ges_track_element_set_track (trackelement, track));
- /* Check that trackobject has the same properties */
- assert_equals_uint64 (_START (trackobject), 42);
- assert_equals_uint64 (_DURATION (trackobject), 51);
- assert_equals_uint64 (_INPOINT (trackobject), 12);
+ /* Check that trackelement has the same properties */
+ assert_equals_uint64 (_START (trackelement), 42);
+ assert_equals_uint64 (_DURATION (trackelement), 51);
+ assert_equals_uint64 (_INPOINT (trackelement), 12);
/* And let's also check that it propagated correctly to GNonLin */
- gnl_object_check (ges_track_object_get_gnlobject (trackobject), 42, 51, 12,
+ gnl_object_check (ges_track_element_get_gnlobject (trackelement), 42, 51, 12,
51, 0, TRUE);
/* Change more properties, see if they propagate */
assert_equals_uint64 (_START (object), 420);
assert_equals_uint64 (_DURATION (object), 510);
assert_equals_uint64 (_INPOINT (object), 120);
- assert_equals_uint64 (_START (trackobject), 420);
- assert_equals_uint64 (_DURATION (trackobject), 510);
- assert_equals_uint64 (_INPOINT (trackobject), 120);
+ assert_equals_uint64 (_START (trackelement), 420);
+ assert_equals_uint64 (_DURATION (trackelement), 510);
+ assert_equals_uint64 (_INPOINT (trackelement), 120);
/* And let's also check that it propagated correctly to GNonLin */
- gnl_object_check (ges_track_object_get_gnlobject (trackobject), 420, 510, 120,
- 510, 0, TRUE);
+ gnl_object_check (ges_track_element_get_gnlobject (trackelement), 420, 510,
+ 120, 510, 0, TRUE);
- ges_clip_release_track_object (object, trackobject);
+ ges_clip_release_track_element (object, trackelement);
g_object_unref (object);
}
GESTimeline *timeline;
GESTimelineLayer *layer;
GESTrack *a, *v;
- GESTrackObject *trobj;
+ GESTrackElement *trobj;
GESTitleClip *source;
gchar *text;
gint halign, valign;
g_free (text);
trobj =
- ges_clip_find_track_object (GES_CLIP (source), v,
+ ges_clip_find_track_element (GES_CLIP (source), v,
GES_TYPE_TRACK_TITLE_SOURCE);
/* Check the text is still the same */
GST_START_TEST (test_transition_basic)
{
GESTransitionClip *tr1, *tr2;
- GESTrackObject *trackobject;
+ GESTrackElement *trackelement;
GESTrack *track;
ges_init ();
fail_unless (tr2->vtype == 1);
/* Make sure track object is created and vtype is set */
- trackobject = ges_clip_create_track_object (GES_CLIP (tr2), track->type);
- ges_clip_add_track_object (GES_CLIP (tr2), trackobject);
+ trackelement = ges_clip_create_track_element (GES_CLIP (tr2), track->type);
+ ges_clip_add_track_element (GES_CLIP (tr2), trackelement);
- fail_unless (trackobject != NULL);
+ fail_unless (trackelement != NULL);
fail_unless (ges_track_video_transition_get_transition_type
- (GES_TRACK_VIDEO_TRANSITION (trackobject)) == 1);
+ (GES_TRACK_VIDEO_TRANSITION (trackelement)) == 1);
- fail_unless (ges_clip_release_track_object (GES_CLIP
- (tr2), trackobject) == TRUE);
+ fail_unless (ges_clip_release_track_element (GES_CLIP
+ (tr2), trackelement) == TRUE);
g_object_unref (track);
g_object_unref (tr1);
GST_START_TEST (test_transition_properties)
{
GESTrack *track;
- GESTrackObject *trackobject;
+ GESTrackElement *trackelement;
GESClip *object;
ges_init ();
assert_equals_uint64 (_DURATION (object), 51);
assert_equals_uint64 (_INPOINT (object), 12);
- trackobject = ges_clip_create_track_object (object, track->type);
- ges_clip_add_track_object (object, trackobject);
- fail_unless (trackobject != NULL);
- fail_unless (ges_track_object_set_track (trackobject, track));
+ trackelement = ges_clip_create_track_element (object, track->type);
+ ges_clip_add_track_element (object, trackelement);
+ fail_unless (trackelement != NULL);
+ fail_unless (ges_track_element_set_track (trackelement, track));
- /* Check that trackobject has the same properties */
- assert_equals_uint64 (_START (trackobject), 42);
- assert_equals_uint64 (_DURATION (trackobject), 51);
- assert_equals_uint64 (_INPOINT (trackobject), 12);
+ /* Check that trackelement has the same properties */
+ assert_equals_uint64 (_START (trackelement), 42);
+ assert_equals_uint64 (_DURATION (trackelement), 51);
+ assert_equals_uint64 (_INPOINT (trackelement), 12);
/* And let's also check that it propagated correctly to GNonLin */
- gnl_object_check (ges_track_object_get_gnlobject (trackobject), 42, 51, 12,
+ gnl_object_check (ges_track_element_get_gnlobject (trackelement), 42, 51, 12,
51, 0, TRUE);
/* Change more properties, see if they propagate */
assert_equals_uint64 (_START (object), 420);
assert_equals_uint64 (_DURATION (object), 510);
assert_equals_uint64 (_INPOINT (object), 120);
- assert_equals_uint64 (_START (trackobject), 420);
- assert_equals_uint64 (_DURATION (trackobject), 510);
- assert_equals_uint64 (_INPOINT (trackobject), 120);
+ assert_equals_uint64 (_START (trackelement), 420);
+ assert_equals_uint64 (_DURATION (trackelement), 510);
+ assert_equals_uint64 (_INPOINT (trackelement), 120);
/* And let's also check that it propagated correctly to GNonLin */
- gnl_object_check (ges_track_object_get_gnlobject (trackobject), 420, 510, 120,
- 510, 0, TRUE);
+ gnl_object_check (ges_track_element_get_gnlobject (trackelement), 420, 510,
+ 120, 510, 0, TRUE);
/* test changing vtype */
GST_DEBUG ("Setting to crossfade");
assert_equals_int (GES_TRANSITION_CLIP (object)->vtype,
GES_VIDEO_STANDARD_TRANSITION_TYPE_CROSSFADE);
assert_equals_int (ges_track_video_transition_get_transition_type
- (GES_TRACK_VIDEO_TRANSITION (trackobject)),
+ (GES_TRACK_VIDEO_TRANSITION (trackelement)),
GES_VIDEO_STANDARD_TRANSITION_TYPE_CROSSFADE);
/* Check that changing from crossfade to anything else fails (it should
assert_equals_int (GES_TRANSITION_CLIP (object)->vtype, 1);
assert_equals_int (ges_track_video_transition_get_transition_type
- (GES_TRACK_VIDEO_TRANSITION (trackobject)), 1);
+ (GES_TRACK_VIDEO_TRANSITION (trackelement)), 1);
GST_DEBUG ("Releasing track object");
- ges_clip_release_track_object (object, trackobject);
+ ges_clip_release_track_element (object, trackelement);
g_object_set (object, "vtype", 1, NULL);
GST_DEBUG ("creating track object");
- trackobject = ges_clip_create_track_object (object, track->type);
- ges_clip_add_track_object (object, trackobject);
- fail_unless (trackobject != NULL);
- fail_unless (ges_track_object_set_track (trackobject, track));
+ trackelement = ges_clip_create_track_element (object, track->type);
+ ges_clip_add_track_element (object, trackelement);
+ fail_unless (trackelement != NULL);
+ fail_unless (ges_track_element_set_track (trackelement, track));
/* The new track object should have taken the previously set transition
* type (in this case 1) */
GST_DEBUG ("Setting to vtype:1");
assert_equals_int (ges_track_video_transition_get_transition_type
- (GES_TRACK_VIDEO_TRANSITION (trackobject)), 1);
+ (GES_TRACK_VIDEO_TRANSITION (trackelement)), 1);
assert_equals_int (GES_TRANSITION_CLIP (object)->vtype, 1);
- ges_clip_release_track_object (object, trackobject);
+ ges_clip_release_track_element (object, trackelement);
g_object_unref (object);
g_object_unref (track);
}
tracks = ges_timeline_get_tracks (ges_timeline_layer_get_timeline (layer));
for (tmp = tracks; tmp; tmp = tmp->next) {
- GList *tckobjs = ges_track_get_objects (GES_TRACK (tmp->data));
+ GList *trackelements = ges_track_get_objects (GES_TRACK (tmp->data));
- assert_equals_int (g_list_length (tckobjs), 1);
- fail_unless (GES_IS_TRACK_FILESOURCE (tckobjs->data));
- g_list_free_full (tckobjs, gst_object_unref);
+ assert_equals_int (g_list_length (trackelements), 1);
+ fail_unless (GES_IS_TRACK_FILESOURCE (trackelements->data));
+ g_list_free_full (trackelements, gst_object_unref);
}
g_list_free_full (tracks, gst_object_unref);
GST_START_TEST (test_filesource_properties)
{
GESTrack *track;
- GESTrackObject *trackobject;
+ GESTrackElement *trackelement;
GESClip *object;
ges_init ();
assert_equals_uint64 (_DURATION (object), 51);
assert_equals_uint64 (_INPOINT (object), 12);
- trackobject = ges_clip_create_track_object (object, track->type);
- ges_clip_add_track_object (object, trackobject);
- fail_unless (trackobject != NULL);
- fail_unless (ges_track_object_set_track (trackobject, track));
+ trackelement = ges_clip_create_track_element (object, track->type);
+ ges_clip_add_track_element (object, trackelement);
+ fail_unless (trackelement != NULL);
+ fail_unless (ges_track_element_set_track (trackelement, track));
- /* Check that trackobject has the same properties */
- assert_equals_uint64 (_START (trackobject), 42);
- assert_equals_uint64 (_DURATION (trackobject), 51);
- assert_equals_uint64 (_INPOINT (trackobject), 12);
+ /* Check that trackelement has the same properties */
+ assert_equals_uint64 (_START (trackelement), 42);
+ assert_equals_uint64 (_DURATION (trackelement), 51);
+ assert_equals_uint64 (_INPOINT (trackelement), 12);
/* And let's also check that it propagated correctly to GNonLin */
- gnl_object_check (ges_track_object_get_gnlobject (trackobject), 42, 51, 12,
+ gnl_object_check (ges_track_element_get_gnlobject (trackelement), 42, 51, 12,
51, 0, TRUE);
/* Change more properties, see if they propagate */
assert_equals_uint64 (_START (object), 420);
assert_equals_uint64 (_DURATION (object), 510);
assert_equals_uint64 (_INPOINT (object), 120);
- assert_equals_uint64 (_START (trackobject), 420);
- assert_equals_uint64 (_DURATION (trackobject), 510);
- assert_equals_uint64 (_INPOINT (trackobject), 120);
+ assert_equals_uint64 (_START (trackelement), 420);
+ assert_equals_uint64 (_DURATION (trackelement), 510);
+ assert_equals_uint64 (_INPOINT (trackelement), 120);
/* And let's also check that it propagated correctly to GNonLin */
- gnl_object_check (ges_track_object_get_gnlobject (trackobject), 420, 510, 120,
- 510, 0, TRUE);
+ gnl_object_check (ges_track_element_get_gnlobject (trackelement), 420, 510,
+ 120, 510, 0, TRUE);
/* Test mute support */
g_object_set (object, "mute", TRUE, NULL);
- gnl_object_check (ges_track_object_get_gnlobject (trackobject), 420, 510, 120,
- 510, 0, FALSE);
+ gnl_object_check (ges_track_element_get_gnlobject (trackelement), 420, 510,
+ 120, 510, 0, FALSE);
g_object_set (object, "mute", FALSE, NULL);
- gnl_object_check (ges_track_object_get_gnlobject (trackobject), 420, 510, 120,
- 510, 0, TRUE);
+ gnl_object_check (ges_track_element_get_gnlobject (trackelement), 420, 510,
+ 120, 510, 0, TRUE);
- ges_clip_release_track_object (object, trackobject);
+ ges_clip_release_track_element (object, trackelement);
g_object_unref (object);
g_object_unref (track);
GST_START_TEST (test_filesource_images)
{
- GESTrackObject *trobj;
+ GESTrackElement *trobj;
GESClip *clip;
GESUriClip *uriclip;
GESTrack *a, *v;
g_object_set (G_OBJECT (uriclip), "is-image", TRUE, NULL);
/* the returned track object should be an image source */
- trobj = ges_clip_create_track_object (clip, v->type);
- ges_clip_add_track_object (clip, trobj);
+ trobj = ges_clip_create_track_element (clip, v->type);
+ ges_clip_add_track_element (clip, trobj);
fail_unless (GES_IS_TRACK_IMAGE_SOURCE (trobj));
/* The track holds a reference to the object
ASSERT_OBJECT_REFCOUNT (trobj, "Video Track Object", 2);
ges_track_remove_object (v, trobj);
- ges_clip_release_track_object (clip, trobj);
+ ges_clip_release_track_element (clip, trobj);
- /* the timeline object should not create any TrackObject in the audio track */
- trobj = ges_clip_create_track_object (clip, a->type);
+ /* the timeline object should not create any TrackElement in the audio track */
+ trobj = ges_clip_create_track_element (clip, a->type);
fail_unless (trobj == NULL);
g_object_unref (a);
GESTrackType type)
{
GList *objects, *tmp;
- GESTrackObject *effect = NULL;
+ GESTrackElement *effect = NULL;
/* No crash if the video is playing */
gst_element_set_state (GST_ELEMENT (app->pipeline), GST_STATE_PAUSED);
objects = ges_timeline_layer_get_objects (app->layer);
for (tmp = objects; tmp; tmp = tmp->next) {
- effect = GES_TRACK_OBJECT (ges_track_parse_launch_effect_new (bin_desc));
- ges_clip_add_track_object (GES_CLIP (tmp->data), effect);
+ effect = GES_TRACK_ELEMENT (ges_track_parse_launch_effect_new (bin_desc));
+ ges_clip_add_track_element (GES_CLIP (tmp->data), effect);
if (type == GES_TRACK_TYPE_VIDEO)
ges_track_add_object (app->video_track, effect);
gboolean
print_transition_data (GESClip * tr)
{
- GESTrackObject *trackobj;
+ GESTrackElement *trackelement;
GstElement *gnlobj;
guint64 start, duration;
gint priority;
char *name;
- GList *trackobjects, *tmp;
+ GList *trackelements, *tmp;
if (!tr)
return FALSE;
- if (!(trackobjects = ges_clip_get_track_objects (tr)))
+ if (!(trackelements = ges_clip_get_track_elements (tr)))
return FALSE;
- if (!(trackobj = GES_TRACK_OBJECT (trackobjects->data)))
+ if (!(trackelement = GES_TRACK_ELEMENT (trackelements->data)))
return FALSE;
- if (!(gnlobj = ges_track_object_get_gnlobject (trackobj)))
+ if (!(gnlobj = ges_track_element_get_gnlobject (trackelement)))
return FALSE;
g_object_get (gnlobj, "start", &start, "duration", &duration,
((gfloat) start) / GST_SECOND,
((gfloat) duration) / GST_SECOND, priority);
- for (tmp = trackobjects; tmp; tmp = tmp->next) {
- g_object_unref (GES_TRACK_OBJECT (tmp->data));
+ for (tmp = trackelements; tmp; tmp = tmp->next) {
+ g_object_unref (GES_TRACK_ELEMENT (tmp->data));
}
- g_list_free (trackobjects);
+ g_list_free (trackelements);
return FALSE;
}
projects / platform / upstream / gstreamer.git / commitdiff