From 62dba13ccfe4a1bd200b087af94434850f36060e Mon Sep 17 00:00:00 2001 From: Thibault Saunier Date: Fri, 18 Jan 2019 09:52:47 -0300 Subject: [PATCH] plugins: Add an a gesdemux element to 'demux' serialized timelines --- plugins/ges/gesdemux.c | 454 ++++++++++++++++++++++++++++++++++++++++ plugins/ges/gesdemux.h | 58 +++++ plugins/ges/gesplugin.c | 6 + 3 files changed, 518 insertions(+) create mode 100644 plugins/ges/gesdemux.c create mode 100644 plugins/ges/gesdemux.h diff --git a/plugins/ges/gesdemux.c b/plugins/ges/gesdemux.c new file mode 100644 index 0000000000..1096790b74 --- /dev/null +++ b/plugins/ges/gesdemux.c @@ -0,0 +1,454 @@ +/* GStreamer GES plugin + * + * Copyright (C) 2019 Thibault Saunier + * + * gesdemux.c + * + * 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:gstdemux + * @short_description: A GstBin subclasses use to use GESTimeline + * as demux inside any GstPipeline. + * @see_also: #GESTimeline + * + * The gstdemux is a bin that will simply expose the track source pads + * and implements the GstUriHandler interface using a custom ges://0Xpointer + * uri scheme. + **/ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include +#include +#include +#include "gesdemux.h" + +GST_DEBUG_CATEGORY_STATIC (gesdemux); +#define GST_CAT_DEFAULT gesdemux + +static GstStaticPadTemplate video_src_template = +GST_STATIC_PAD_TEMPLATE ("video_src", + GST_PAD_SRC, + GST_PAD_SOMETIMES, + GST_STATIC_CAPS ("video/x-raw(ANY)")); + +static GstStaticPadTemplate audio_src_template = + GST_STATIC_PAD_TEMPLATE ("audio_src", + GST_PAD_SRC, + GST_PAD_SOMETIMES, + GST_STATIC_CAPS ("audio/x-raw(ANY);")); + +static GstStaticPadTemplate sink_template = GST_STATIC_PAD_TEMPLATE ("sink", + GST_PAD_SINK, + GST_PAD_ALWAYS, + GST_STATIC_CAPS ("application/xges")); + +G_DEFINE_TYPE (GESDemux, ges_demux, GST_TYPE_BIN); + +enum +{ + PROP_0, + PROP_TIMELINE, + PROP_LAST +}; + +static GParamSpec *properties[PROP_LAST]; + +static gboolean +ges_demux_set_timeline (GESDemux * self, GESTimeline * timeline) +{ + GList *tmp; + guint naudiopad = 0, nvideopad = 0; + GstBin *sbin = GST_BIN (self); + + g_return_val_if_fail (GES_IS_TIMELINE (timeline), FALSE); + + if (self->timeline) { + GST_ERROR_OBJECT (self, "Implement changing timeline support"); + + return FALSE; + } + + GST_INFO_OBJECT (self, "Setting timeline: %" GST_PTR_FORMAT, timeline); + self->timeline = gst_object_ref (timeline); + + if (!gst_bin_add (sbin, GST_ELEMENT (self->timeline))) { + GST_ERROR_OBJECT (self, "Could not add timeline to myself!"); + + return FALSE; + } + for (tmp = self->timeline->tracks; tmp; tmp = tmp->next) { + GstPad *gpad; + gchar *name = NULL; + GstElement *queue; + GESTrack *track = GES_TRACK (tmp->data); + GstPad *tmppad, *pad = + ges_timeline_get_pad_for_track (self->timeline, track); + GstStaticPadTemplate *template; + + if (!pad) { + GST_WARNING_OBJECT (self, "No pad for track: %" GST_PTR_FORMAT, track); + + continue; + } + + if (track->type == GES_TRACK_TYPE_AUDIO) { + name = g_strdup_printf ("audio_%u", naudiopad++); + template = &audio_src_template; + } else if (track->type == GES_TRACK_TYPE_VIDEO) { + name = g_strdup_printf ("video_%u", nvideopad++); + template = &video_src_template; + } else { + GST_INFO_OBJECT (self, "Track type not handled: %" GST_PTR_FORMAT, track); + continue; + } + + queue = gst_element_factory_make ("queue", NULL); + /* Add queues the same way as in GESPipeline */ + g_object_set (G_OBJECT (queue), "max-size-buffers", 0, + "max-size-bytes", 0, "max-size-time", (gint64) 2 * GST_SECOND, NULL); + gst_bin_add (GST_BIN (self), queue); + gst_element_sync_state_with_parent (GST_ELEMENT (queue)); + + tmppad = gst_element_get_static_pad (queue, "sink"); + if (gst_pad_link (pad, tmppad) != GST_PAD_LINK_OK) { + GST_ERROR_OBJECT (self, "Could not link %s:%s and %s:%s", + GST_DEBUG_PAD_NAME (pad), GST_DEBUG_PAD_NAME (tmppad)); + + gst_object_unref (tmppad); + gst_object_unref (queue); + continue; + } + + tmppad = gst_element_get_static_pad (queue, "src"); + gpad = gst_ghost_pad_new_from_template (name, tmppad, + gst_static_pad_template_get (template)); + + gst_pad_set_active (gpad, TRUE); + gst_element_add_pad (GST_ELEMENT (self), gpad); + GST_DEBUG_OBJECT (self, "Adding pad: %" GST_PTR_FORMAT, gpad); + } + + gst_element_sync_state_with_parent (GST_ELEMENT (self->timeline)); + + return TRUE; +} + +static void +ges_demux_get_property (GObject * object, guint property_id, + GValue * value, GParamSpec * pspec) +{ + GESDemux *self = GES_DEMUX (object); + + switch (property_id) { + case PROP_TIMELINE: + g_value_set_object (value, self->timeline); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + } +} + +static void +ges_demux_set_property (GObject * object, guint property_id, + const GValue * value, GParamSpec * pspec) +{ + switch (property_id) { + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + } +} + +static void +ges_demux_dispose (GObject * object) +{ + GESDemux *self = GES_DEMUX (object); + + if (self->timeline) + gst_clear_object (&self->timeline); +} + +static void +ges_demux_class_init (GESDemuxClass * self_class) +{ + GObjectClass *gclass = G_OBJECT_CLASS (self_class); + GstElementClass *gstelement_klass = GST_ELEMENT_CLASS (self_class); + + GST_DEBUG_CATEGORY_INIT (gesdemux, "gesdemux", 0, "ges demux element"); + + gclass->get_property = ges_demux_get_property; + gclass->set_property = ges_demux_set_property; + gclass->dispose = ges_demux_dispose; + + /** + * GESDemux:timeline: + * + * Timeline to use in this source. + */ + properties[PROP_TIMELINE] = g_param_spec_object ("timeline", "Timeline", + "Timeline to use in this source.", + GES_TYPE_TIMELINE, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS); + + g_object_class_install_properties (gclass, PROP_LAST, properties); + + gst_element_class_set_static_metadata (gstelement_klass, + "GStreamer Editing Services based 'demuxer'", + "Codec/Demux/Editing", + "Demuxer for complex timeline file formats using GES.", + "Thibault Saunier lock); + data->timeline = timeline; + g_signal_handler_disconnect (project, data->loaded_sigid); + data->loaded_sigid = 0; + g_mutex_unlock (&data->lock); + + g_main_loop_quit (data->ml); +} + +static void +error_loading_asset_cb (GESProject * project, GError * error, gchar * id, + GType extractable_type, TimelineConstructionData * data) +{ + g_mutex_lock (&data->lock); + data->error = g_error_copy (error); + g_signal_handler_disconnect (project, data->error_sigid); + data->error_sigid = 0; + g_mutex_unlock (&data->lock); + + g_main_loop_quit (data->ml); +} + +/* TODO: Add a way to run a function in the right GES thread */ +static gboolean +ges_timeline_new_from_uri_from_main_thread (TimelineConstructionData * data) +{ + GESProject *project = ges_project_new (data->uri); + GESUriClipAssetClass *klass = g_type_class_peek (GES_TYPE_URI_CLIP_ASSET); + GstDiscoverer *previous_discoverer = klass->discoverer; + GstClockTime timeout; + + g_object_get (previous_discoverer, "timeout", &timeout, NULL); + + /* Make sure to use a new discoverer in case we are being discovered, + * as discovering is done one by one, and the global discoverer won't + * have the chance to discover the project assets */ + g_mutex_lock (&data->lock); + klass->discoverer = gst_discoverer_new (timeout, &data->error); + if (data->error) { + klass->discoverer = previous_discoverer; + g_mutex_unlock (&data->lock); + + goto done; + } + g_signal_connect (klass->discoverer, "discovered", + G_CALLBACK (klass->discovered), NULL); + gst_discoverer_start (klass->discoverer); + + data->ml = g_main_loop_new (NULL, TRUE); + data->loaded_sigid = + g_signal_connect (project, "loaded", G_CALLBACK (project_loaded_cb), + data); + data->error_sigid = + g_signal_connect (project, "error-loading-asset", + G_CALLBACK (error_loading_asset_cb), data); + + GES_TIMELINE (ges_asset_extract (GES_ASSET (project), &data->error)); + if (data->error) { + g_mutex_unlock (&data->lock); + + goto done; + } + g_mutex_unlock (&data->lock); + + g_main_loop_run (data->ml); + g_main_loop_unref (data->ml); + +done: + + g_mutex_lock (&data->lock); + + /* Set previous discoverer back! */ + + if (klass->discoverer) + gst_object_unref (klass->discoverer); + klass->discoverer = previous_discoverer; + + if (data->timeline) + ges_timeline_commit (data->timeline); + + if (data->loaded_sigid) + g_signal_handler_disconnect (project, data->loaded_sigid); + + if (data->error_sigid) + g_signal_handler_disconnect (project, data->error_sigid); + + gst_clear_object (&project); + + g_cond_broadcast (&data->cond); + g_mutex_unlock (&data->lock); + + return G_SOURCE_REMOVE; +} + +static gboolean +ges_demux_sink_event (GstPad * pad, GstObject * parent, GstEvent * event) +{ + GESDemux *self = GES_DEMUX (parent); + + switch (event->type) { + case GST_EVENT_EOS:{ + GstMapInfo map; + GstBuffer *xges_buffer; + gboolean ret = TRUE; + gsize available; + + available = gst_adapter_available (self->input_adapter); + if (available == 0) { + GST_WARNING_OBJECT (self, + "Received EOS without any serialized timeline."); + + return gst_pad_event_default (pad, parent, event); + } + + xges_buffer = gst_adapter_take_buffer (self->input_adapter, available); + if (gst_buffer_map (xges_buffer, &map, GST_MAP_READ)) { + GError *err = NULL; + gchar *filename = NULL, *uri = NULL; + TimelineConstructionData data = { 0, }; + gint f = g_file_open_tmp (NULL, &filename, &err); + GMainContext *main_context = g_main_context_default (); + + GST_ERROR ("Loading %s", filename); + if (err) { + GST_ELEMENT_ERROR (self, RESOURCE, OPEN_WRITE, + ("Could not open temporary file to write timeline description"), + ("%s", err->message)); + + goto error; + } + + g_file_set_contents (filename, (gchar *) map.data, map.size, &err); + if (err) { + GST_ELEMENT_ERROR (self, RESOURCE, WRITE, + ("Could not write temporary timeline description file"), + ("%s", err->message)); + + goto error; + } + + uri = gst_uri_construct ("file", filename); + data.uri = uri; + + g_main_context_invoke (main_context, + (GSourceFunc) ges_timeline_new_from_uri_from_main_thread, &data); + g_mutex_lock (&data.lock); + while (!data.error && !data.timeline) + g_cond_wait (&data.cond, &data.lock); + data.loaded_sigid = 0; + data.error_sigid = 0; + g_mutex_unlock (&data.lock); + + if (data.error) { + GST_ELEMENT_ERROR (self, STREAM, DEMUX, + ("Could not create timeline from description"), + ("%s", data.error->message)); + g_clear_error (&data.error); + + goto error; + } + + GST_INFO_OBJECT (self, "Timeline properly loaded: %" GST_PTR_FORMAT, + data.timeline); + ges_demux_set_timeline (self, data.timeline); + done: + g_free (filename); + g_free (uri); + g_close (f, NULL); + return ret; + error: + ret = FALSE; + goto done; + } else { + GST_ELEMENT_ERROR (self, RESOURCE, READ, + ("Could not map buffer containing timeline description"), + ("Not info")); + } + GST_ERROR_OBJECT (xges_buffer, ":YAY"); + } + default: + break; + } + + return gst_pad_event_default (pad, parent, event); +} + +static GstFlowReturn +ges_demux_sink_chain (GstPad * pad, GstObject * parent, GstBuffer * buffer) +{ + GESDemux *self = GES_DEMUX (parent); + + gst_adapter_push (self->input_adapter, buffer); + + GST_INFO_OBJECT (self, "Received buffer, total size is %i bytes", + (gint) gst_adapter_available (self->input_adapter)); + + return GST_FLOW_OK; +} + +static void +ges_demux_init (GESDemux * self) +{ + ges_init (); + self->sinkpad = gst_pad_new_from_static_template (&sink_template, "sink"); + gst_element_add_pad (GST_ELEMENT (self), self->sinkpad); + + self->input_adapter = gst_adapter_new (); + + gst_pad_set_chain_function (self->sinkpad, + GST_DEBUG_FUNCPTR (ges_demux_sink_chain)); + + gst_pad_set_event_function (self->sinkpad, + GST_DEBUG_FUNCPTR (ges_demux_sink_event)); +} diff --git a/plugins/ges/gesdemux.h b/plugins/ges/gesdemux.h new file mode 100644 index 0000000000..eaa2b4384b --- /dev/null +++ b/plugins/ges/gesdemux.h @@ -0,0 +1,58 @@ +/* GStreamer GES plugin + * + * Copyright (C) 2019 Thibault Saunier + * + * gesdemux.h + * + * 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_DEMUX_H__ +#define __GES_DEMUX_H__ + +#include +#include +#include + +G_BEGIN_DECLS + +GType ges_demux_get_type (void); + +#define GES_DEMUX_TYPE (ges_demux_get_type ()) +#define GES_DEMUX(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GES_DEMUX_TYPE, GESDemux)) +#define GES_DEMUX_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GES_DEMUX_TYPE, GESDemuxClass)) +#define GES_IS_DEMUX(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GES_DEMUX_TYPE)) +#define GES_IS_DEMUX_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GES_DEMUX_TYPE)) +#define GES_DEMUX_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GES_DEMUX_TYPE, GESDemuxClass)) + +typedef struct { + GstBin parent; + + GESTimeline *timeline; + GstPad *sinkpad; + + GstAdapter *input_adapter; +} GESDemux; + +typedef struct { + GstBinClass parent; + +} GESDemuxClass; + +G_END_DECLS +#endif /* __GES_DEMUX_H__ */ + diff --git a/plugins/ges/gesplugin.c b/plugins/ges/gesplugin.c index c56edd1689..a12d6b7cee 100644 --- a/plugins/ges/gesplugin.c +++ b/plugins/ges/gesplugin.c @@ -26,14 +26,20 @@ #endif #include + #include "gessrc.h" +#include "gesdemux.h" static gboolean plugin_init (GstPlugin * plugin) { gboolean res = 1; + res |= gst_element_register (plugin, "gessrc", GST_RANK_NONE, GES_SRC_TYPE); + res |= gst_element_register (plugin, "gesdemux", GST_RANK_PRIMARY, + GES_DEMUX_TYPE); + return res; }