GESTimeline *
testPatternTL (void)
{
GESTimeline *timeline;
GESLayer *layer;
GESTestClip *srca, *srcb;
timeline = ges_timeline_new_audio_video ();
layer = ges_layer_new ();
g_object_set (layer, "auto-transition", TRUE, NULL);
ges_timeline_add_layer (timeline, layer);
srca = ges_test_clip_new ();
srcb = ges_test_clip_new ();
g_object_set (srca,
"vpattern", GES_VIDEO_TEST_PATTERN_SMPTE,
"duration", 3 * GST_SECOND, "start", 0, NULL);
g_object_set (srcb,
"vpattern", GES_VIDEO_TEST_PATTERN_CIRCULAR,
"duration", 3 * GST_SECOND, "start", 2 * GST_SECOND, NULL);
ges_test_clip_set_frequency (srcb, 800);
ges_layer_add_clip (layer, GES_CLIP (srca));
ges_layer_add_clip (layer, GES_CLIP (srcb));
ges_timeline_commit (timeline);
return timeline;
}
GESPipeline *
make_timeline (char *path, float duration, char *text, guint32 color,
gdouble xpos, gdouble ypos)
{
GESTimeline *timeline;
GESTrack *trackv, *tracka;
GESLayer *layer1;
GESClip *srca;
GESClip *overlay;
GESPipeline *pipeline;
guint64 aduration;
pipeline = ges_pipeline_new ();
ges_pipeline_set_mode (pipeline, TIMELINE_MODE_PREVIEW_VIDEO);
timeline = ges_timeline_new ();
ges_pipeline_add_timeline (pipeline, timeline);
trackv = GES_TRACK (ges_video_track_new ());
ges_timeline_add_track (timeline, trackv);
tracka = GES_TRACK (ges_audio_track_new ());
ges_timeline_add_track (timeline, tracka);
layer1 = GES_LAYER (ges_layer_new ());
g_object_set (layer1, "priority", (gint32) 0, NULL);
if (!ges_timeline_add_layer (timeline, layer1))
exit (-1);
aduration = (guint64) (duration * GST_SECOND);
srca = make_source (path, 0, aduration, 1);
overlay = make_overlay (text, 0, aduration, 0, color, xpos, ypos);
ges_layer_add_clip (layer1, srca);
ges_layer_add_clip (layer1, overlay);
return pipeline;
}
static void
new_asset_cb (GESAsset * source, GAsyncResult * res, NewAssetUData * udata)
{
GError *error = NULL;
GESAsset *asset = ges_asset_request_finish (res, &error);
GST_DEBUG_OBJECT (udata->layer, "%" GST_PTR_FORMAT " Asset loaded, "
"setting its asset", udata->clip);
if (error) {
GESProject *project = udata->layer->timeline ?
GES_PROJECT (ges_extractable_get_asset (GES_EXTRACTABLE
(udata->layer->timeline))) : NULL;
if (project) {
gchar *possible_id;
possible_id = ges_project_try_updating_id (project, source, error);
if (possible_id) {
ges_asset_request_async (ges_asset_get_extractable_type (source),
possible_id, NULL, (GAsyncReadyCallback) new_asset_cb, udata);
g_free (possible_id);
return;
}
}
GST_ERROR ("Asset could not be created for uri %s, error: %s",
ges_asset_get_id (asset), error->message);
} else {
GESProject *project = udata->layer->timeline ?
GES_PROJECT (ges_extractable_get_asset (GES_EXTRACTABLE
(udata->layer->timeline))) : NULL;
ges_extractable_set_asset (GES_EXTRACTABLE (udata->clip), asset);
ges_project_add_asset (project, asset);
ges_layer_add_clip (udata->layer, udata->clip);
}
gst_object_unref (asset);
g_slice_free (NewAssetUData, udata);
}
/**
* ges_layer_add_asset:
* @layer: a #GESLayer
* @asset: The asset to add to
* @start: The start value to set on the new #GESClip
* @inpoint: The inpoint value to set on the new #GESClip
* @duration: The duration value to set on the new #GESClip
* @track_types: The #GESTrackType to set on the the new #GESClip
*
* Creates Clip from asset, adds it to layer and
* returns a reference to it.
*
* Returns: (transfer none): Created #GESClip
*/
GESClip *
ges_layer_add_asset (GESLayer * layer,
GESAsset * asset, GstClockTime start, GstClockTime inpoint,
GstClockTime duration, GESTrackType track_types)
{
GESClip *clip;
g_return_val_if_fail (GES_IS_LAYER (layer), NULL);
g_return_val_if_fail (GES_IS_ASSET (asset), NULL);
g_return_val_if_fail (g_type_is_a (ges_asset_get_extractable_type
(asset), GES_TYPE_CLIP), NULL);
GST_DEBUG_OBJECT (layer, "Adding asset %s with: start: %" GST_TIME_FORMAT
" inpoint: %" GST_TIME_FORMAT " duration: %" GST_TIME_FORMAT
" track types: %d (%s)", ges_asset_get_id (asset), GST_TIME_ARGS (start),
GST_TIME_ARGS (inpoint), GST_TIME_ARGS (duration), track_types,
ges_track_type_name (track_types));
clip = GES_CLIP (ges_asset_extract (asset, NULL));
_set_start0 (GES_TIMELINE_ELEMENT (clip), start);
_set_inpoint0 (GES_TIMELINE_ELEMENT (clip), inpoint);
if (track_types != GES_TRACK_TYPE_UNKNOWN)
ges_clip_set_supported_formats (clip, track_types);
if (GST_CLOCK_TIME_IS_VALID (duration)) {
_set_duration0 (GES_TIMELINE_ELEMENT (clip), duration);
}
if (!ges_layer_add_clip (layer, clip)) {
gst_object_unref (clip);
return NULL;
}
return clip;
}
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;
}
int
main (int argc, gchar ** argv)
{
GError *err = NULL;
GOptionContext *ctx;
GESPipeline *pipeline;
GESTimeline *timeline;
GESTrack *tracka, *trackv;
GESLayer *layer1, *layer2;
GESUriClip *src;
GMainLoop *mainloop;
gint inpoint = 0, duration = 10;
gboolean mute = FALSE;
gchar *audiofile = NULL;
GOptionEntry options[] = {
{"inpoint", 'i', 0, G_OPTION_ARG_INT, &inpoint,
"in-point in the file (in seconds, default:0s)", "seconds"},
{"duration", 'd', 0, G_OPTION_ARG_INT, &duration,
"duration to use from the file (in seconds, default:10s)", "seconds"},
{"mute", 'm', 0, G_OPTION_ARG_NONE, &mute,
"Whether to mute the audio from the file",},
{"audiofile", 'a', 0, G_OPTION_ARG_FILENAME, &audiofile,
"Use this audiofile instead of the original audio from the file",
"audiofile"},
{NULL}
};
ctx =
g_option_context_new
("- Plays an video file with sound (origin/muted/replaced)");
g_option_context_add_main_entries (ctx, options, NULL);
g_option_context_add_group (ctx, gst_init_get_option_group ());
if (!g_option_context_parse (ctx, &argc, &argv, &err)) {
g_print ("Error initializing %s\n", err->message);
exit (1);
}
if (argc == 1) {
g_print ("%s", g_option_context_get_help (ctx, TRUE, NULL));
exit (0);
}
g_option_context_free (ctx);
ges_init ();
/* Create an Audio/Video pipeline with two layers */
pipeline = ges_pipeline_new ();
timeline = ges_timeline_new ();
tracka = GES_TRACK (ges_audio_track_new ());
trackv = GES_TRACK (ges_video_track_new ());
layer1 = ges_layer_new ();
layer2 = ges_layer_new ();
g_object_set (layer2, "priority", 1, NULL);
if (!ges_timeline_add_layer (timeline, layer1) ||
!ges_timeline_add_layer (timeline, layer2) ||
!ges_timeline_add_track (timeline, tracka) ||
!ges_timeline_add_track (timeline, trackv) ||
!ges_pipeline_set_timeline (pipeline, timeline))
return -1;
if (1) {
gchar *uri = gst_filename_to_uri (argv[1], NULL);
/* Add the main audio/video file */
src = ges_uri_clip_new (uri);
g_free (uri);
g_object_set (src, "start", 0, "in-point", inpoint * GST_SECOND,
"duration", duration * GST_SECOND, "mute", mute, NULL);
ges_layer_add_clip (layer1, GES_CLIP (src));
}
/* Play the pipeline */
gst_element_set_state (GST_ELEMENT (pipeline), GST_STATE_PLAYING);
mainloop = g_main_loop_new (NULL, FALSE);
g_timeout_add_seconds (duration + 1, (GSourceFunc) g_main_loop_quit,
mainloop);
g_main_loop_run (mainloop);
return 0;
}
static void
make_source (GESFormatter * self, GList * reflist, GHashTable * source_table)
{
GHashTable *props_table, *effect_table;
gchar **prio_array;
GESLayer *layer;
GESPitiviFormatterPrivate *priv = GES_PITIVI_FORMATTER (self)->priv;
gchar *fac_ref = NULL, *media_type = NULL, *filename = NULL, *prio_str;
GList *tmp = NULL, *keys, *tmp_key;
GESUriClip *src = NULL;
gint prio;
gboolean a_avail = FALSE, v_avail = FALSE, video;
GHashTable *trackelement_table = priv->track_elements_table;
for (tmp = reflist; tmp; tmp = tmp->next) {
/* Get the layer */
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);
g_strfreev (prio_array);
/* If we do not have any layer with this priority, create it */
if (!(layer = g_hash_table_lookup (priv->layers_table, &prio))) {
layer = ges_layer_new ();
g_object_set (layer, "auto-transition", TRUE, "priority", prio, NULL);
ges_timeline_add_layer (self->timeline, layer);
g_hash_table_insert (priv->layers_table, g_memdup (&prio,
sizeof (guint64)), layer);
}
fac_ref = (gchar *) g_hash_table_lookup (props_table, "fac_ref");
media_type = (gchar *) g_hash_table_lookup (props_table, "media_type");
if (!g_strcmp0 (media_type, "pitivi.stream.VideoStream"))
video = TRUE;
else
video = FALSE;
/* FIXME I am sure we could reimplement this whole part
* in a simpler way */
if (g_strcmp0 (fac_ref, (gchar *) "effect")) {
/* FIXME this is a hack to get a ref to the formatter when receiving
* child-added */
g_hash_table_insert (props_table, (gchar *) "current-formatter", self);
if (a_avail && (!video)) {
a_avail = FALSE;
} else if (v_avail && (video)) {
v_avail = FALSE;
} else {
/* If we only have audio or only video in the previous source,
* set it has such */
if (a_avail) {
ges_clip_set_supported_formats (GES_CLIP (src), GES_TRACK_TYPE_VIDEO);
} else if (v_avail) {
ges_clip_set_supported_formats (GES_CLIP (src), GES_TRACK_TYPE_AUDIO);
}
filename = (gchar *) g_hash_table_lookup (source_table, "filename");
src = ges_uri_clip_new (filename);
if (!video) {
v_avail = TRUE;
a_avail = FALSE;
} else {
a_avail = TRUE;
v_avail = FALSE;
}
set_properties (G_OBJECT (src), props_table);
ges_layer_add_clip (layer, GES_CLIP (src));
g_signal_connect (src, "child-added",
G_CALLBACK (track_element_added_cb), props_table);
priv->sources_to_load = g_list_prepend (priv->sources_to_load, src);
}
} else {
GESEffect *effect;
gchar *active = (gchar *) g_hash_table_lookup (props_table, "active");
effect = ges_effect_new ((gchar *)
g_hash_table_lookup (props_table, (gchar *) "effect_name"));
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_container_add (GES_CONTAINER (src), GES_TIMELINE_ELEMENT (effect));
if (!g_strcmp0 (active, (gchar *) "(bool)False"))
ges_track_element_set_active (GES_TRACK_ELEMENT (effect), FALSE);
/* Set effect properties */
keys = g_hash_table_get_keys (effect_table);
for (tmp_key = keys; tmp_key; tmp_key = tmp_key->next) {
GstStructure *structure;
const GValue *value;
GParamSpec *spec;
GstCaps *caps;
gchar *prop_val;
prop_val = (gchar *) g_hash_table_lookup (effect_table,
(gchar *) tmp_key->data);
if (g_strstr_len (prop_val, -1, "(GEnum)")) {
gchar **val = g_strsplit (prop_val, ")", 2);
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_element_lookup_child (GES_TRACK_ELEMENT (effect),
(gchar *) tmp->data, NULL, &spec)) {
gchar *caps_str = g_strdup_printf ("structure1, property1=%s;",
prop_val);
caps = gst_caps_from_string (caps_str);
g_free (caps_str);
structure = gst_caps_get_structure (caps, 0);
value = gst_structure_get_value (structure, "property1");
ges_track_element_set_child_property_by_pspec (GES_TRACK_ELEMENT
(effect), spec, (GValue *) value);
gst_caps_unref (caps);
}
}
}
}
if (a_avail) {
ges_clip_set_supported_formats (GES_CLIP (src), GES_TRACK_TYPE_VIDEO);
} else if (v_avail) {
ges_clip_set_supported_formats (GES_CLIP (src), GES_TRACK_TYPE_AUDIO);
}
}
int
main (int argc, gchar ** argv)
{
GESPipeline *pipeline;
GESTimeline *timeline;
GESTrack *tracka;
GESLayer *layer;
GMainLoop *mainloop;
GstClockTime offset = 0;
guint i;
if (argc < 2) {
g_print ("Usage: %s <list of audio files>\n", argv[0]);
return -1;
}
/* Initialize GStreamer (this will parse environment variables and commandline
* arguments. */
gst_init (&argc, &argv);
/* Initialize the GStreamer Editing Services */
ges_init ();
/* Setup of an audio timeline */
/* This is our main GESTimeline */
timeline = ges_timeline_new ();
tracka = GES_TRACK (ges_audio_track_new ());
/* We are only going to be doing one layer of clips */
layer = ges_layer_new ();
/* Add the tracks and the layer to the timeline */
if (!ges_timeline_add_layer (timeline, layer))
return -1;
if (!ges_timeline_add_track (timeline, tracka))
return -1;
/* Here we've finished initializing our timeline, we're
* ready to start using it... by solely working with the layer ! */
for (i = 1; i < argc; i++, offset += GST_SECOND) {
gchar *uri = gst_filename_to_uri (argv[i], NULL);
GESUriClip *src = ges_uri_clip_new (uri);
g_assert (src);
g_free (uri);
g_object_set (src, "start", offset, "duration", GST_SECOND, NULL);
ges_layer_add_clip (layer, (GESClip *) src);
}
/* In order to listen our timeline, let's grab a convenience pipeline to put
* our timeline in. */
pipeline = ges_pipeline_new ();
/* Add the timeline to that pipeline */
if (!ges_pipeline_add_timeline (pipeline, timeline))
return -1;
/* The following is standard usage of a GStreamer pipeline (note how you
* haven't had to care about GStreamer so far ?).
*
* We set the pipeline to playing ... */
gst_element_set_state (GST_ELEMENT (pipeline), GST_STATE_PLAYING);
/* ... and we start a GMainLoop. GES **REQUIRES** a GMainLoop to be running in
* order to function properly ! */
mainloop = g_main_loop_new (NULL, FALSE);
/* Simple code to have the mainloop shutdown after 4s */
g_timeout_add_seconds (argc - 1, (GSourceFunc) g_main_loop_quit, mainloop);
g_main_loop_run (mainloop);
return 0;
}
