static void
deep_check (GESTimelineElement * element, GstClockTime start,
GstClockTime inpoint, GstClockTime duration)
{
GList *track_elements, *tmp;
GstClockTime rstart, rinpoint, rduration;
rstart = ges_timeline_element_get_start (GES_TIMELINE_ELEMENT (element));
rinpoint = ges_timeline_element_get_inpoint (GES_TIMELINE_ELEMENT (element));
rduration =
ges_timeline_element_get_duration (GES_TIMELINE_ELEMENT (element));
assert_equals_uint64 (rstart, start);
assert_equals_uint64 (rinpoint, inpoint);
assert_equals_uint64 (rduration, duration);
track_elements = GES_CONTAINER_CHILDREN (element);
for (tmp = track_elements; tmp; tmp = tmp->next) {
rstart = ges_timeline_element_get_start (GES_TIMELINE_ELEMENT (tmp->data));
rinpoint =
ges_timeline_element_get_inpoint (GES_TIMELINE_ELEMENT (tmp->data));
rduration =
ges_timeline_element_get_duration (GES_TIMELINE_ELEMENT (tmp->data));
assert_equals_uint64 (rstart, start);
assert_equals_uint64 (rinpoint, inpoint);
assert_equals_uint64 (rduration, duration);
}
}
/****************************************************
* Our listening of children *
****************************************************/
static void
_update_our_values (GESGroup * group)
{
GList *tmp;
GESContainer *container = GES_CONTAINER (group);
guint32 min_layer_prio = G_MAXINT32, max_layer_prio = 0;
for (tmp = GES_CONTAINER_CHILDREN (group); tmp; tmp = tmp->next) {
GESContainer *child = tmp->data;
if (GES_IS_CLIP (child)) {
GESLayer *layer = ges_clip_get_layer (GES_CLIP (child));
gint32 prio = ges_layer_get_priority (layer);
min_layer_prio = MIN (prio, min_layer_prio);
max_layer_prio = MAX (prio, max_layer_prio);
} else if (GES_IS_GROUP (child)) {
gint32 prio = _PRIORITY (child), height = GES_CONTAINER_HEIGHT (child);
min_layer_prio = MIN (prio, min_layer_prio);
max_layer_prio = MAX ((prio + height), max_layer_prio);
}
}
if (min_layer_prio != _PRIORITY (group)) {
group->priv->setting_value = TRUE;
_set_priority0 (GES_TIMELINE_ELEMENT (group), min_layer_prio);
group->priv->setting_value = FALSE;
for (tmp = GES_CONTAINER_CHILDREN (group); tmp; tmp = tmp->next) {
GESTimelineElement *child = tmp->data;
guint32 child_prio = GES_IS_CLIP (child) ?
ges_clip_get_layer_priority (GES_CLIP (child)) : _PRIORITY (child);
_ges_container_set_priority_offset (container,
child, min_layer_prio - child_prio);
}
}
group->priv->max_layer_prio = max_layer_prio;
_ges_container_set_height (GES_CONTAINER (group),
max_layer_prio - min_layer_prio + 1);
}
void
ges_uri_clip_set_uri (GESUriClip * self, gchar * uri)
{
if (GES_CONTAINER_CHILDREN (self)) {
/* FIXME handle this case properly */
GST_WARNING_OBJECT (self, "Can not change uri when already"
"containing TrackElements");
return;
}
self->priv->uri = uri;
}
static gboolean
_lookup_child (GESTimelineElement * self, const gchar * prop_name,
GObject ** child, GParamSpec ** pspec)
{
GList *tmp;
for (tmp = GES_CONTAINER_CHILDREN (self); tmp; tmp = tmp->next)
_ges_container_add_child_properties (GES_CONTAINER (self), tmp->data);
return
GES_TIMELINE_ELEMENT_CLASS (ges_container_parent_class)->lookup_child
(self, prop_name, child, pspec);
}
/**
* ges_test_clip_set_volume:
* @self: the #GESTestClip to set the volume on
* @volume: the volume of the audio signal you want to use on @self
*
* Sets the volume of the test audio signal.
*
*/
void
ges_test_clip_set_volume (GESTestClip * self, gdouble volume)
{
GList *tmp;
self->priv->volume = volume;
for (tmp = GES_CONTAINER_CHILDREN (self); tmp; tmp = tmp->next) {
GESTrackElement *trackelement = (GESTrackElement *) tmp->data;
if (GES_IS_AUDIO_TEST_SOURCE (trackelement))
ges_audio_test_source_set_volume (
(GESAudioTestSource *) trackelement, volume);
}
}
/**
* ges_test_clip_set_frequency:
* @self: the #GESTestClip to set the frequency on
* @freq: the frequency you want to use on @self
*
* Sets the frequency to generate. See audiotestsrc element.
*
*/
void
ges_test_clip_set_frequency (GESTestClip * self, gdouble freq)
{
GList *tmp;
self->priv->freq = freq;
for (tmp = GES_CONTAINER_CHILDREN (self); tmp; tmp = tmp->next) {
GESTrackElement *trackelement = (GESTrackElement *) tmp->data;
if (GES_IS_AUDIO_TEST_SOURCE (trackelement))
ges_audio_test_source_set_freq (
(GESAudioTestSource *) trackelement, freq);
}
}
/**
* ges_test_clip_set_vpattern:
* @self: the #GESTestClip to set the pattern on
* @vpattern: the #GESVideoTestPattern to use on @self
*
* Sets which video pattern to display on @self.
*
*/
void
ges_test_clip_set_vpattern (GESTestClip * self, GESVideoTestPattern vpattern)
{
GList *tmp;
self->priv->vpattern = vpattern;
for (tmp = GES_CONTAINER_CHILDREN (self); tmp; tmp = tmp->next) {
GESTrackElement *trackelement = (GESTrackElement *) tmp->data;
if (GES_IS_VIDEO_TEST_SOURCE (trackelement))
ges_video_test_source_set_pattern (
(GESVideoTestSource *) trackelement, vpattern);
}
}
/**
* ges_test_clip_set_mute:
* @self: the #GESTestClip on which to mute or unmute the audio track
* @mute: %TRUE to mute the audio track, %FALSE to unmute it
*
* Sets whether the audio track of this clip is muted or not.
*
*/
void
ges_test_clip_set_mute (GESTestClip * self, gboolean mute)
{
GList *tmp;
GST_DEBUG ("self:%p, mute:%d", self, mute);
self->priv->mute = mute;
/* Go over tracked objects, and update 'active' status on all audio objects */
for (tmp = GES_CONTAINER_CHILDREN (self); tmp; tmp = tmp->next) {
GESTrackElement *trackelement = (GESTrackElement *) tmp->data;
if (ges_track_element_get_track (trackelement)->type ==
GES_TRACK_TYPE_AUDIO)
ges_track_element_set_active (trackelement, !mute);
}
}
/**
* ges_text_overlay_clip_set_ypos:
* @self: the #GESTextOverlayClip* to set
* @position: The vertical position @self is being set to
*
* Sets the vertical position of the text.
*/
void
ges_text_overlay_clip_set_ypos (GESTextOverlayClip * self, gdouble position)
{
GList *tmp;
GST_DEBUG ("self:%p, ypos:%f", self, position);
self->priv->ypos = position;
for (tmp = GES_CONTAINER_CHILDREN (self); tmp; tmp = tmp->next) {
GESTrackElement *trackelement = (GESTrackElement *) tmp->data;
if (ges_track_element_get_track (trackelement)->type ==
GES_TRACK_TYPE_VIDEO)
ges_text_overlay_set_ypos (GES_TEXT_OVERLAY (trackelement),
self->priv->ypos);
}
}
/**
* ges_text_overlay_clip_set_color:
* @self: the #GESTextOverlayClip* to set
* @color: The color @self is being set to
*
* Sets the color of the text.
*/
void
ges_text_overlay_clip_set_color (GESTextOverlayClip * self, guint32 color)
{
GList *tmp;
GST_DEBUG ("self:%p, color:%d", self, color);
self->priv->color = color;
for (tmp = GES_CONTAINER_CHILDREN (self); tmp; tmp = tmp->next) {
GESTrackElement *trackelement = (GESTrackElement *) tmp->data;
if (ges_track_element_get_track (trackelement)->type ==
GES_TRACK_TYPE_VIDEO)
ges_text_overlay_set_color (GES_TEXT_OVERLAY (trackelement),
self->priv->color);
}
}
/**
* ges_text_overlay_clip_set_valign:
* @self: the #GESTextOverlayClip* to set vertical alignement of text on
* @valign: #GESTextVAlign
*
* Sets the vertical aligment of the text.
*
*/
void
ges_text_overlay_clip_set_valign (GESTextOverlayClip * self,
GESTextVAlign valign)
{
GList *tmp;
GST_DEBUG ("self:%p, valign:%d", self, valign);
self->priv->valign = valign;
for (tmp = GES_CONTAINER_CHILDREN (self); tmp; tmp = tmp->next) {
GESTrackElement *trackelement = (GESTrackElement *) tmp->data;
if (ges_track_element_get_track (trackelement)->type ==
GES_TRACK_TYPE_VIDEO)
ges_text_overlay_set_valignment (GES_TEXT_OVERLAY
(trackelement), self->priv->valign);
}
}
/**
* ges_text_overlay_clip_set_text:
* @self: the #GESTextOverlayClip* to set text on
* @text: the text to render. an internal copy of this text will be
* made.
*
* Sets the text this clip will render.
*
*/
void
ges_text_overlay_clip_set_text (GESTextOverlayClip * self, const gchar * text)
{
GList *tmp;
GST_DEBUG ("self:%p, text:%s", self, text);
if (self->priv->text)
g_free (self->priv->text);
self->priv->text = g_strdup (text);
for (tmp = GES_CONTAINER_CHILDREN (self); tmp; tmp = tmp->next) {
GESTrackElement *trackelement = (GESTrackElement *) tmp->data;
if (ges_track_element_get_track (trackelement)->type ==
GES_TRACK_TYPE_VIDEO)
ges_text_overlay_set_text (GES_TEXT_OVERLAY (trackelement),
self->priv->text);
}
}
static void
_deep_copy (GESTimelineElement * element, GESTimelineElement * copy)
{
GList *tmp;
GESContainer *self = GES_CONTAINER (element), *ccopy = GES_CONTAINER (copy);
for (tmp = GES_CONTAINER_CHILDREN (element); tmp; tmp = tmp->next) {
ChildMapping *map;
map =
g_slice_dup (ChildMapping, g_hash_table_lookup (self->priv->mappings,
tmp->data));
map->child = ges_timeline_element_copy (tmp->data, TRUE);
map->start_notifyid = 0;
map->inpoint_notifyid = 0;
map->duration_notifyid = 0;
ccopy->priv->copied_children = g_list_prepend (ccopy->priv->copied_children,
map);
}
}
static gboolean
extractable_set_asset (GESExtractable * self, GESAsset * asset)
{
gboolean res = TRUE;
GESUriClip *uriclip = GES_URI_CLIP (self);
GESUriClipAsset *uri_clip_asset;
GESClip *clip = GES_CLIP (self);
GESLayer *layer = ges_clip_get_layer (clip);
GList *tmp;
GESTimelineElement *audio_source = NULL, *video_source = NULL;
g_return_val_if_fail (GES_IS_URI_CLIP_ASSET (asset), FALSE);
uri_clip_asset = GES_URI_CLIP_ASSET (asset);
if (GST_CLOCK_TIME_IS_VALID (GES_TIMELINE_ELEMENT_DURATION (clip)) == FALSE)
_set_duration0 (GES_TIMELINE_ELEMENT (uriclip),
ges_uri_clip_asset_get_duration (uri_clip_asset));
ges_timeline_element_set_max_duration (GES_TIMELINE_ELEMENT (uriclip),
ges_uri_clip_asset_get_duration (uri_clip_asset));
ges_uri_clip_set_is_image (uriclip,
ges_uri_clip_asset_is_image (uri_clip_asset));
if (ges_clip_get_supported_formats (clip) == GES_TRACK_TYPE_UNKNOWN) {
ges_clip_set_supported_formats (clip,
ges_clip_asset_get_supported_formats (GES_CLIP_ASSET (uri_clip_asset)));
}
GES_TIMELINE_ELEMENT (uriclip)->asset = asset;
if (layer) {
GList *children = ges_container_get_children (GES_CONTAINER (self), TRUE);
for (tmp = children; tmp; tmp = tmp->next) {
if (GES_IS_SOURCE (tmp->data)) {
GESTrack *track = ges_track_element_get_track (tmp->data);
if (track->type == GES_TRACK_TYPE_AUDIO)
audio_source = gst_object_ref (tmp->data);
else if (track->type == GES_TRACK_TYPE_VIDEO)
video_source = gst_object_ref (tmp->data);
ges_track_remove_element (track, tmp->data);
ges_container_remove (GES_CONTAINER (self), tmp->data);
}
}
g_list_free_full (children, g_object_unref);
gst_object_ref (clip);
ges_layer_remove_clip (layer, clip);
res = ges_layer_add_clip (layer, clip);
for (tmp = GES_CONTAINER_CHILDREN (self); tmp; tmp = tmp->next) {
if (GES_IS_SOURCE (tmp->data)) {
GESTrack *track = ges_track_element_get_track (tmp->data);
if (track->type == GES_TRACK_TYPE_AUDIO && audio_source)
ges_track_element_copy_properties (audio_source, tmp->data);
else if (track->type == GES_TRACK_TYPE_VIDEO && video_source)
ges_track_element_copy_properties (video_source, tmp->data);
}
}
g_clear_object (&audio_source);
g_clear_object (&video_source);
gst_object_unref (clip);
gst_object_unref (layer);
}
if (res) {
g_free (uriclip->priv->uri);
uriclip->priv->uri = g_strdup (ges_asset_get_id (asset));
}
return res;
}
