int
main (int argc, gchar ** argv)
{
GMainLoop *mainloop;
if (argc != 2) {
return 1;
}
/* Initialize GStreamer (this will parse environment variables and commandline
* arguments. */
gst_init (NULL, NULL);
/* Initialize the GStreamer Editing Services */
ges_init ();
/* ... and we start a GMainLoop. GES **REQUIRES** a GMainLoop to be running in
* order to function properly ! */
mainloop = g_main_loop_new (NULL, FALSE);
ges_asset_request_async (GES_TYPE_URI_CLIP, argv[1], NULL,
(GAsyncReadyCallback) asset_loaded_cb, mainloop);
g_main_loop_run (mainloop);
g_main_loop_unref (mainloop);
return 0;
}
int
main (int argc, char **argv)
{
GMainLoop *mainloop = NULL;
GESTimeline *timeline;
GESLayer *layer = NULL;
GstBus *bus = NULL;
guint i;
if (argc < 3) {
g_print ("Usage: %s <output uri> <list of files>\n", argv[0]);
return -1;
}
gst_init (&argc, &argv);
ges_init ();
timeline = ges_timeline_new_audio_video ();
layer = (GESLayer *) ges_simple_layer_new ();
if (!ges_timeline_add_layer (timeline, layer))
return -1;
output_uri = argv[1];
assetsCount = argc - 2;
for (i = 2; i < argc; i++) {
ges_asset_request_async (GES_TYPE_URI_CLIP, argv[i],
NULL, (GAsyncReadyCallback) asset_loaded_cb, mainloop);
}
/* In order to view 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;
mainloop = g_main_loop_new (NULL, FALSE);
bus = gst_pipeline_get_bus (GST_PIPELINE (pipeline));
gst_bus_add_signal_watch (bus);
g_signal_connect (bus, "message", G_CALLBACK (bus_message_cb), mainloop);
g_main_loop_run (mainloop);
return 0;
}
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);
}
void
ges_base_xml_formatter_add_asset (GESBaseXmlFormatter * self,
const gchar * id, GType extractable_type, GstStructure * properties,
const gchar * metadatas, GError ** error)
{
PendingAsset *passet;
GESBaseXmlFormatterPrivate *priv = _GET_PRIV (self);
if (priv->check_only)
return;
passet = g_slice_new0 (PendingAsset);
passet->metadatas = g_strdup (metadatas);
passet->formatter = gst_object_ref (self);
if (properties)
passet->properties = gst_structure_copy (properties);
ges_asset_request_async (extractable_type, id, NULL,
(GAsyncReadyCallback) new_asset_cb, passet);
ges_project_add_loading_asset (GES_FORMATTER (self)->project,
extractable_type, id);
priv->pending_assets = g_list_prepend (priv->pending_assets, passet);
}
/**
* ges_project_create_asset:
* @project: A #GESProject
* @id: (allow-none): The id of the asset to create and add to @project
* @extractable_type: The #GType of the asset to create
*
* Create and add a #GESAsset to @project. You should connect to the
* "asset-added" signal to get the asset when it finally gets added to
* @project
*
* Returns: %TRUE if the asset started to be added %FALSE it was already
* in the project
*/
gboolean
ges_project_create_asset (GESProject * project, const gchar * id,
GType extractable_type)
{
g_return_val_if_fail (GES_IS_PROJECT (project), FALSE);
g_return_val_if_fail (g_type_is_a (extractable_type, GES_TYPE_EXTRACTABLE),
FALSE);
if (id == NULL)
id = g_type_name (extractable_type);
if (g_hash_table_lookup (project->priv->assets, id) ||
g_hash_table_lookup (project->priv->loading_assets, id) ||
g_hash_table_lookup (project->priv->loaded_with_error, id))
return FALSE;
/* TODO Add a GCancellable somewhere in our API */
ges_asset_request_async (extractable_type, id, NULL,
(GAsyncReadyCallback) new_asset_cb, project);
ges_project_add_loading_asset (project, extractable_type, id);
return TRUE;
}
static void
new_asset_cb (GESAsset * source, GAsyncResult * res, PendingAsset * passet)
{
GError *error = NULL;
gchar *possible_id = NULL;
GList *tmp, *pendings = NULL;
GESFormatter *self = passet->formatter;
const gchar *id = ges_asset_get_id (source);
GESBaseXmlFormatterPrivate *priv = _GET_PRIV (self);
GESAsset *asset = ges_asset_request_finish (res, &error);
if (error) {
GST_LOG_OBJECT (self, "Error %s creating asset id: %s", error->message, id);
/* We set the metas on the Asset to give hints to the user */
if (passet->metadatas)
ges_meta_container_add_metas_from_string (GES_META_CONTAINER (source),
passet->metadatas);
if (passet->properties)
gst_structure_foreach (passet->properties,
(GstStructureForeachFunc) set_property_foreach, source);
possible_id = ges_project_try_updating_id (GES_FORMATTER (self)->project,
source, error);
if (possible_id == NULL) {
GST_WARNING_OBJECT (self, "Abandoning creation of asset %s with ID %s"
"- Error: %s", g_type_name (G_OBJECT_TYPE (source)), id,
error->message);
pendings = g_hash_table_lookup (priv->assetid_pendingclips, id);
for (tmp = pendings; tmp; tmp = tmp->next)
_free_pending_clip (priv, (PendingClip *) tmp->data);
_free_pending_asset (priv, passet);
goto done;
}
/* We got a possible ID replacement for that asset, create it, and
* make sure the assetid_pendingclips will use it */
ges_asset_request_async (ges_asset_get_extractable_type (source),
possible_id, NULL, (GAsyncReadyCallback) new_asset_cb, passet);
ges_project_add_loading_asset (GES_FORMATTER (self)->project,
ges_asset_get_extractable_type (source), possible_id);
pendings = g_hash_table_lookup (priv->assetid_pendingclips, id);
if (pendings) {
g_hash_table_remove (priv->assetid_pendingclips, id);
g_hash_table_insert (priv->assetid_pendingclips,
g_strdup (possible_id), pendings);
/* pendings should no be freed */
pendings = NULL;
}
goto done;
}
/* now that we have the GESAsset, we create the GESClips */
pendings = g_hash_table_lookup (priv->assetid_pendingclips, id);
GST_DEBUG_OBJECT (self, "Asset created with ID %s, now creating pending "
" Clips, nb pendings: %i", id, g_list_length (pendings));
for (tmp = pendings; tmp; tmp = tmp->next) {
GList *tmpeffect;
GESClip *clip;
PendingClip *pend = (PendingClip *) tmp->data;
clip =
_add_object_to_layer (priv, pend->id, pend->layer, asset,
pend->start, pend->inpoint, pend->duration, pend->track_types,
pend->metadatas, pend->properties);
if (clip == NULL)
continue;
_add_children_properties (priv, pend->children_props, clip);
_add_pending_bindings (priv, pend->pending_bindings, clip);
GST_DEBUG_OBJECT (self, "Adding %i effect to new object",
g_list_length (pend->effects));
for (tmpeffect = pend->effects; tmpeffect; tmpeffect = tmpeffect->next) {
PendingEffects *peffect = (PendingEffects *) tmpeffect->data;
/* We keep a ref as _free_pending_effect unrefs it */
_add_track_element (self, clip, gst_object_ref (peffect->trackelement),
peffect->track_id, peffect->children_properties, peffect->properties);
}
_free_pending_clip (priv, pend);
}
/* And now add to the project */
ges_project_add_asset (self->project, asset);
gst_object_unref (self);
_free_pending_asset (priv, passet);
done:
if (asset)
gst_object_unref (asset);
if (possible_id)
g_free (possible_id);
if (pendings) {
g_hash_table_remove (priv->assetid_pendingclips, id);
g_list_free (pendings);
}
if (g_hash_table_size (priv->assetid_pendingclips) == 0 &&
priv->pending_assets == NULL)
_loading_done (self);
}
/**
* ges_layer_add_clip:
* @layer: a #GESLayer
* @clip: (transfer full): the #GESClip to add.
*
* Adds the given clip to the layer. Sets the clip's parent, and thus
* takes ownership of the clip.
*
* An clip can only be added to one layer.
*
* Calling this method will construct and properly set all the media related
* elements on @clip. If you need to know when those objects (actually #GESTrackElement)
* are constructed, you should connect to the container::child-added signal which
* is emited right after those elements are ready to be used.
*
* Returns: TRUE if the clip was properly added to the layer, or FALSE
* if the @layer refuses to add the clip.
*/
gboolean
ges_layer_add_clip (GESLayer * layer, GESClip * clip)
{
GESAsset *asset;
GESLayerPrivate *priv;
GESLayer *current_layer;
g_return_val_if_fail (GES_IS_LAYER (layer), FALSE);
g_return_val_if_fail (GES_IS_CLIP (clip), FALSE);
GST_DEBUG_OBJECT (layer, "adding clip:%p", clip);
priv = layer->priv;
current_layer = ges_clip_get_layer (clip);
if (G_UNLIKELY (current_layer)) {
GST_WARNING ("Clip %p already belongs to another layer", clip);
gst_object_unref (current_layer);
return FALSE;
}
asset = ges_extractable_get_asset (GES_EXTRACTABLE (clip));
if (asset == NULL) {
gchar *id;
NewAssetUData *mudata = g_slice_new (NewAssetUData);
mudata->clip = clip;
mudata->layer = layer;
GST_DEBUG_OBJECT (layer, "%" GST_PTR_FORMAT " as no reference to any "
"assets creating a asset... trying sync", clip);
id = ges_extractable_get_id (GES_EXTRACTABLE (clip));
asset = ges_asset_request (G_OBJECT_TYPE (clip), id, NULL);
if (asset == NULL) {
GESProject *project = layer->timeline ?
GES_PROJECT (ges_extractable_get_asset (GES_EXTRACTABLE
(layer->timeline))) : NULL;
ges_asset_request_async (G_OBJECT_TYPE (clip),
id, NULL, (GAsyncReadyCallback) new_asset_cb, mudata);
if (project)
ges_project_add_loading_asset (project, G_OBJECT_TYPE (clip), id);
g_free (id);
GST_LOG_OBJECT (layer, "Object added async");
return TRUE;
}
g_free (id);
ges_extractable_set_asset (GES_EXTRACTABLE (clip), asset);
g_slice_free (NewAssetUData, mudata);
}
gst_object_ref_sink (clip);
/* Take a reference to the clip and store it stored by start/priority */
priv->clips_start = g_list_insert_sorted (priv->clips_start, clip,
(GCompareFunc) element_start_compare);
/* Inform the clip it's now in this layer */
ges_clip_set_layer (clip, layer);
GST_DEBUG ("current clip priority : %d, Height: %d", _PRIORITY (clip),
LAYER_HEIGHT);
/* Set the priority. */
if (_PRIORITY (clip) > LAYER_HEIGHT) {
GST_WARNING_OBJECT (layer,
"%p is out of the layer space, setting its priority to "
"%d, setting it to the maximum priority of the layer: %d", clip,
_PRIORITY (clip), LAYER_HEIGHT - 1);
_set_priority0 (GES_TIMELINE_ELEMENT (clip), LAYER_HEIGHT - 1);
}
/* If the clip has an acceptable priority, we just let it with its current
* priority */
ges_layer_resync_priorities (layer);
ges_timeline_element_set_timeline (GES_TIMELINE_ELEMENT (clip),
layer->timeline);
/* emit 'clip-added' */
g_signal_emit (layer, ges_layer_signals[OBJECT_ADDED], 0, clip);
return TRUE;
}
