static gboolean
ges_pipeline_update_caps (GESPipeline * self)
{
GList *ltrack, *tracks, *lstream;
if (!self->priv->profile)
return TRUE;
GST_DEBUG ("Updating track caps");
tracks = ges_timeline_get_tracks (self->priv->timeline);
/* Take each stream of the encoding profile and find a matching
* track to set the caps on */
for (ltrack = tracks; ltrack; ltrack = ltrack->next) {
GESTrack *track = (GESTrack *) ltrack->data;
GList *allstreams;
if (!GST_IS_ENCODING_CONTAINER_PROFILE (self->priv->profile)) {
if (_track_is_compatible_with_profile (self, track, self->priv->profile)) {
gst_object_unref (track);
goto done;
} else {
gst_object_unref (track);
continue;
}
}
allstreams = (GList *)
gst_encoding_container_profile_get_profiles (
(GstEncodingContainerProfile *) self->priv->profile);
/* Find a matching stream setting */
for (lstream = allstreams; lstream; lstream = lstream->next) {
GstEncodingProfile *prof = (GstEncodingProfile *) lstream->data;
if (_track_is_compatible_with_profile (self, track, prof))
break;
}
gst_object_unref (track);
}
done:
if (tracks)
g_list_free (tracks);
GST_DEBUG ("Done updating caps");
return TRUE;
}
static void
asset_created_cb (GObject * source, GAsyncResult * res, gpointer udata)
{
GList *tracks, *tmp;
GESAsset *asset;
GESLayer *layer;
GESUriClip *tlfs;
GError *error = NULL;
asset = ges_asset_request_finish (res, &error);
ASSERT_OBJECT_REFCOUNT (asset, "1 for us + for the cache + 1 taken "
"by g_simple_async_result_complete_in_idle", 3);
fail_unless (error == NULL);
fail_if (asset == NULL);
fail_if (g_strcmp0 (ges_asset_get_id (asset), av_uri));
layer = GES_LAYER (g_async_result_get_user_data (res));
tlfs = GES_URI_CLIP (ges_layer_add_asset (layer,
asset, 0, 0, GST_CLOCK_TIME_NONE, GES_TRACK_TYPE_UNKNOWN));
fail_unless (GES_IS_URI_CLIP (tlfs));
fail_if (g_strcmp0 (ges_uri_clip_get_uri (tlfs), av_uri));
assert_equals_uint64 (_DURATION (tlfs), GST_SECOND);
fail_unless (ges_clip_get_supported_formats
(GES_CLIP (tlfs)) & GES_TRACK_TYPE_VIDEO);
fail_unless (ges_clip_get_supported_formats
(GES_CLIP (tlfs)) & GES_TRACK_TYPE_AUDIO);
tracks = ges_timeline_get_tracks (ges_layer_get_timeline (layer));
for (tmp = tracks; tmp; tmp = tmp->next) {
GList *trackelements = ges_track_get_elements (GES_TRACK (tmp->data));
assert_equals_int (g_list_length (trackelements), 1);
fail_unless (GES_IS_VIDEO_URI_SOURCE (trackelements->data)
|| GES_IS_AUDIO_URI_SOURCE (trackelements->data));
g_list_free_full (trackelements, gst_object_unref);
}
g_list_free_full (tracks, gst_object_unref);
gst_object_unref (asset);
g_main_loop_quit (mainloop);
}
static gboolean
create_tracks (GESFormatter * self)
{
GESPitiviFormatterPrivate *priv = GES_PITIVI_FORMATTER (self)->priv;
GList *tracks = NULL;
tracks = ges_timeline_get_tracks (self->timeline);
GST_DEBUG ("Creating tracks, current number of tracks %d",
g_list_length (tracks));
if (tracks) {
GList *tmp = NULL;
GESTrack *track;
for (tmp = tracks; tmp; tmp = tmp->next) {
track = tmp->data;
if (track->type == GES_TRACK_TYPE_AUDIO) {
priv->tracka = track;
} else {
priv->trackv = track;
}
}
g_list_foreach (tracks, (GFunc) gst_object_unref, NULL);
g_list_free (tracks);
return TRUE;
}
priv->tracka = GES_TRACK (ges_audio_track_new ());
priv->trackv = GES_TRACK (ges_video_track_new ());
if (!ges_timeline_add_track (self->timeline, priv->trackv)) {
return FALSE;
}
if (!ges_timeline_add_track (self->timeline, priv->tracka)) {
return FALSE;
}
return TRUE;
}
static gboolean
ges_timeline_pipeline_update_caps (GESTimelinePipeline * self)
{
GList *ltrack, *tracks, *lstream;
if (!self->priv->profile)
return TRUE;
GST_DEBUG ("Updating track caps");
tracks = ges_timeline_get_tracks (self->priv->timeline);
/* Take each stream of the encoding profile and find a matching
* track to set the caps on */
for (ltrack = tracks; ltrack; ltrack = ltrack->next) {
GESTrack *track = (GESTrack *) ltrack->data;
GList *allstreams;
allstreams = (GList *)
gst_encoding_container_profile_get_profiles (
(GstEncodingContainerProfile *) self->priv->profile);
/* Find a matching stream setting */
for (lstream = allstreams; lstream; lstream = lstream->next) {
GstEncodingProfile *prof = (GstEncodingProfile *) lstream->data;
if (TRACK_COMPATIBLE_PROFILE (track->type, prof)) {
if (self->priv->mode == TIMELINE_MODE_SMART_RENDER) {
GstCaps *ocaps, *rcaps;
GST_DEBUG ("Smart Render mode, setting input caps");
ocaps = gst_encoding_profile_get_input_caps (prof);
if (track->type == GES_TRACK_TYPE_AUDIO)
rcaps = gst_caps_from_string ("audio/x-raw-int;audio/x-raw-float");
else
rcaps = gst_caps_from_string ("video/x-raw-yuv;video/x-raw-rgb");
gst_caps_append (ocaps, rcaps);
ges_track_set_caps (track, ocaps);
} else {
GstCaps *caps = NULL;
/* Raw preview or rendering mode */
if (track->type == GES_TRACK_TYPE_VIDEO)
caps = gst_caps_from_string ("video/x-raw-yuv;video/x-raw-rgb");
else if (track->type == GES_TRACK_TYPE_AUDIO)
gst_caps_from_string ("audio/x-raw-int;audio/x-raw-float");
if (caps) {
ges_track_set_caps (track, caps);
gst_caps_unref (caps);
}
}
break;
}
}
g_object_unref (track);
}
if (tracks)
g_list_free (tracks);
GST_DEBUG ("Done updating caps");
return TRUE;
}
/**
* ges_pipeline_set_render_settings:
* @pipeline: a #GESPipeline
* @output_uri: the URI to which the timeline will be rendered
* @profile: the #GstEncodingProfile to use to render the timeline.
*
* Specify where the pipeline shall be rendered and with what settings.
*
* A copy of @profile and @output_uri will be done internally, the caller can
* safely free those values afterwards.
*
* This method must be called before setting the pipeline mode to
* #GES_PIPELINE_MODE_RENDER
*
* Returns: %TRUE if the settings were aknowledged properly, else %FALSE
*/
gboolean
ges_pipeline_set_render_settings (GESPipeline * pipeline,
const gchar * output_uri, GstEncodingProfile * profile)
{
GError *err = NULL;
GstEncodingProfile *set_profile;
g_return_val_if_fail (GES_IS_PIPELINE (pipeline), FALSE);
/* FIXME Properly handle multi track, for now GESPipeline
* only hanles single track per type, so we should just set the
* presence to 1.
*/
if (GST_IS_ENCODING_CONTAINER_PROFILE (profile)) {
const GList *tmpprofiles =
gst_encoding_container_profile_get_profiles
(GST_ENCODING_CONTAINER_PROFILE (profile));
GList *tmptrack, *tracks =
ges_timeline_get_tracks (pipeline->priv->timeline);
for (; tmpprofiles; tmpprofiles = tmpprofiles->next) {
for (tmptrack = tracks; tmptrack; tmptrack = tmptrack->next) {
if ((GST_IS_ENCODING_AUDIO_PROFILE (tmpprofiles->data) &&
GES_IS_AUDIO_TRACK (tmptrack->data)) ||
(GST_IS_ENCODING_VIDEO_PROFILE (tmpprofiles->data) &&
GES_IS_VIDEO_TRACK (tmptrack->data))) {
GST_DEBUG_OBJECT (pipeline, "Setting presence to 1!");
gst_encoding_profile_set_presence (tmpprofiles->data, 1);
gst_encoding_profile_set_allow_dynamic_output (tmpprofiles->data,
FALSE);
}
}
}
g_list_free_full (tracks, gst_object_unref);
}
/* Clear previous URI sink if it existed */
/* FIXME : We should figure out if it was added to the pipeline,
* and if so, remove it. */
if (pipeline->priv->urisink) {
gst_object_unref (pipeline->priv->urisink);
pipeline->priv->urisink = NULL;
}
pipeline->priv->urisink =
gst_element_make_from_uri (GST_URI_SINK, output_uri, "urisink", &err);
if (G_UNLIKELY (pipeline->priv->urisink == NULL)) {
GST_ERROR_OBJECT (pipeline, "Couldn't not create sink for URI %s: '%s'",
output_uri, ((err
&& err->message) ? err->message : "failed to create element"));
g_clear_error (&err);
return FALSE;
}
if (pipeline->priv->profile)
gst_encoding_profile_unref (pipeline->priv->profile);
g_object_set (pipeline->priv->encodebin, "avoid-reencoding",
!(!(pipeline->priv->mode & GES_PIPELINE_MODE_SMART_RENDER)), NULL);
g_object_set (pipeline->priv->encodebin, "profile", profile, NULL);
g_object_get (pipeline->priv->encodebin, "profile", &set_profile, NULL);
if (set_profile == NULL) {
GST_ERROR_OBJECT (pipeline, "Profile %" GST_PTR_FORMAT " could no be set",
profile);
return FALSE;
}
/* We got a referencer when getting back the profile */
pipeline->priv->profile = profile;
return TRUE;
}
void
getClips (JsonReader * reader, GESLayer * layer, GESTrackType type,
gboolean absolute_paths)
{
int i;
json_reader_read_member (reader, "clips");
g_print ("= clips =\n");
for (i = 0; i < json_reader_count_elements (reader); i++) {
json_reader_read_element (reader, i);
const char *src = getString (reader, "src");
int start = getInt (reader, "start");
int in = getInt (reader, "in");
int dur = getInt (reader, "dur");
g_print ("Clip: %s (start: %d, in: %d, dur: %d)\n", src, start, in, dur);
GESClip *clip;
if (is_in_members (reader, "multi") && getBool (reader, "multi")) {
g_print ("multi on.\n");
clip =
ges_multi_clip_from_path (src, layer, start, in, dur, absolute_paths);
} else {
const char *path;
if (absolute_paths == TRUE) {
path = src;
} else {
path = ges_renderer_get_absolute_path (src);
}
clip = ges_clip_from_path (path, layer, start, in, dur, type);
}
GESTimeline *tl = ges_layer_get_timeline (layer);
GList *tracks = ges_timeline_get_tracks (tl);
GESTrack *trackv = g_list_first (tracks)->data;
GESTrack *tracka = g_list_last (tracks)->data;
if (is_in_members (reader, "volume")) {
double volume = getDouble (reader, "volume");
GESTrackElement *audioElement =
ges_clip_find_track_element (clip, tracka, G_TYPE_NONE);
if (audioElement != NULL) {
ges_track_element_set_child_properties (audioElement, "volume", volume,
NULL);
}
}
GESTrackElement *videoElement =
ges_clip_find_track_element (clip, trackv, G_TYPE_NONE);
if (videoElement != NULL) {
if (is_in_members (reader, "x")) {
int x = getInt (reader, "x");
ges_track_element_set_child_properties (videoElement, "posx", x, NULL);
}
if (is_in_members (reader, "y")) {
int y = getInt (reader, "y");
ges_track_element_set_child_properties (videoElement, "posy", y, NULL);
}
if (is_in_members (reader, "alpha")) {
gdouble alpha = getDouble (reader, "alpha");
ges_track_element_set_child_properties (videoElement, "alpha", alpha,
NULL);
}
if (is_in_members (reader, "size")) {
gdouble size = getDouble (reader, "size");
GESUriClipAsset *asset =
GES_URI_CLIP_ASSET (ges_extractable_get_asset (GES_EXTRACTABLE
(clip)));
guint width = ges_asset_get_width (asset);
guint height = ges_asset_get_height (asset);
if (width != 0 && height != 0) {
double dw = width * size;
double dh = height * size;
g_print ("%dx%d => * %f => %dx%d\n", width, height, size, (int) dw,
(int) dh);
ges_track_element_set_child_properties (videoElement,
"width", (int) dw, "height", (int) dh, NULL);
}
}
if (is_in_members (reader, "effect")) {
const char *effect_str = getString (reader, "effect");
if (strcmp (effect_str, "") != 0) {
g_print ("Using effect %s", effect_str);
GESEffect *effect = ges_effect_new (effect_str);
ges_container_add (GES_CONTAINER (clip),
GES_TIMELINE_ELEMENT (effect));
}
}
}
json_reader_end_element (reader);
}
json_reader_end_member (reader);
}
