/* concat muxer plugin for GStreamer

  * Copyright (C) 2004 Renato Filhps <renato.filho@indt.org.br>

  *

  * 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., 59 Temple Place - Suite 330,

  * Boston, MA 02111-1307, USA.

  */

 /**

  * SECTION:element-concatmux

  * @short_description: Concat that takes one or several digital streams

  * and muxes them to a single stream.

  *

  * <refsect2>

  * <title>Sample pipelines</title>

  * <para>

  * Here is a simple pipeline to concat 2 files into a another file:

  * <programlisting>

  * gst-launch concatmux name=m ! filesink location=output.txt  filesrc location=file_a.txt !  m. filesrc location=file_b.txt ! m.

  * </programlisting>

  * </para>

  * </refsect2>

  */

 #ifdef HAVE_CONFIG_H

 #include "config.h"

 #endif

 #include <gst/gst.h>

 #include <gst/base/gstcollectpads.h>

 #include <string.h>

 GST_DEBUG_CATEGORY_STATIC (gst_concat_mux_debug);

 #define GST_CAT_DEFAULT gst_concat_mux_debug

 #define GST_TYPE_CONCAT_MUX (gst_concat_mux_get_type())

 #define GST_CONCAT_MUX(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_CONCAT_MUX, GstConcatMux))

 #define GST_CONCAT_MUX_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_CONCAT_MUX, GstConcatMux))

 #define GST_IS_CONCAT_MUX(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_CONCAT_MUX))

 #define GST_IS_CONCAT_MUX_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_CONCAT_MUX))

 typedef struct _GstConcatMux GstConcatMux;

 typedef struct _GstConcatMuxClass GstConcatMuxClass;

 /**

  * GstConcatMux:

  *

  * The opaque #GstConcatMux structure.

  */

 struct _GstConcatMux

 {

   GstElement element;

   /* Caps */

   GstCaps *sink_caps;

   /* pad */

   GstPad *srcpad;

   GstPad *sinkpad;

   /* sinkpads */

   GSList *sinks;

   gint numpads;

   /* offset in stream */

   guint64 offset;

   guint64 timeoffset;

   guint64 start_time;

   gboolean negotiated;

   gboolean resync;

   gboolean done;

 };

 struct _GstConcatMuxClass

 {

   GstElementClass parent_class;

 };

 /* elementfactory information */

 static const GstElementDetails gst_concat_mux_details =

 GST_ELEMENT_DETAILS ("Concat muxer",

     "Codec/Muxer",

     "mux concat streams",

     "Renato Filho <renato.filho@indt.org>");

 static GstStaticPadTemplate src_factory = GST_STATIC_PAD_TEMPLATE ("src",

     GST_PAD_SRC,

     GST_PAD_ALWAYS,

     GST_STATIC_CAPS_ANY

     );

 static GstStaticPadTemplate sink_factory = GST_STATIC_PAD_TEMPLATE ("sink_%d",

     GST_PAD_SINK,

     GST_PAD_REQUEST,

     GST_STATIC_CAPS_ANY         

     );

 static void gst_concat_mux_base_init (gpointer g_class);

 static void gst_concat_mux_class_init (GstConcatMuxClass * klass);

 static void gst_concat_mux_init (GstConcatMux * concat_mux);

 static void gst_concat_mux_finalize (GObject * object);

 static gboolean gst_concat_mux_handle_src_event (GstPad * pad,

     GstEvent * event);

 static gboolean gst_concat_mux_handle_sink_event (GstPad * pad,

     GstEvent * event);

 static GstPad *gst_concat_mux_request_new_pad (GstElement * element,

     GstPadTemplate * templ, const gchar * name);

 static GstStateChangeReturn gst_concat_mux_change_state (GstElement *

     element, GstStateChange transition);

 static GstFlowReturn gst_concat_mux_chain (GstPad * pad,  GstBuffer * buf);

 static void gst_concat_mux_clear (GstConcatMux *mux);

 static GstElementClass *parent_class = NULL;

 GType

 gst_concat_mux_get_type (void)

 {

   static GType concat_mux_type = 0;

   if (!concat_mux_type) {

     static const GTypeInfo concat_mux_info = {

       sizeof (GstConcatMuxClass),

       gst_concat_mux_base_init,

       NULL,

       (GClassInitFunc) gst_concat_mux_class_init,

       NULL,

       NULL,

       sizeof (GstConcatMux),

       0,

       (GInstanceInitFunc) gst_concat_mux_init,

     };

     concat_mux_type =

         g_type_register_static (GST_TYPE_ELEMENT, "GstConcatMux",

         &concat_mux_info, 0);

   }

   return concat_mux_type;

 }

 static void

 gst_concat_mux_base_init (gpointer g_class)

 {

   GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);

   gst_element_class_add_pad_template (element_class,

       gst_static_pad_template_get (&src_factory));

   gst_element_class_add_pad_template (element_class,

       gst_static_pad_template_get (&sink_factory));

   gst_element_class_set_details (element_class, &gst_concat_mux_details);

 }

 static void

 gst_concat_mux_class_init (GstConcatMuxClass * klass)

 {

   GObjectClass *gobject_class;

   GstElementClass *gstelement_class;

   gobject_class = (GObjectClass *) klass;

   gstelement_class = (GstElementClass *) klass;

   parent_class = g_type_class_peek_parent (klass);

   gobject_class->finalize = gst_concat_mux_finalize;

   gstelement_class->request_new_pad = gst_concat_mux_request_new_pad;

   gstelement_class->change_state = gst_concat_mux_change_state;

 }

 static void

 gst_concat_mux_init (GstConcatMux * concat_mux)

 {

   GstElementClass *klass = GST_ELEMENT_GET_CLASS (concat_mux);

   concat_mux->srcpad =

       gst_pad_new_from_template (gst_element_class_get_pad_template (klass,

           "src"), "src");

   gst_pad_set_event_function (concat_mux->srcpad,

       gst_concat_mux_handle_src_event);

   gst_element_add_pad (GST_ELEMENT (concat_mux), concat_mux->srcpad);

 }

 static void

 gst_concat_mux_finalize (GObject * object)

 {

   GstConcatMux *concat_mux;

   concat_mux = GST_CONCAT_MUX (object);

   gst_concat_mux_clear (GST_CONCAT_MUX (object));

   G_OBJECT_CLASS (parent_class)->finalize (object);

 }

 static void

 gst_concat_mux_free_pad (gpointer data,

                             gpointer user_data)

 {

    GMutex *mux;

    mux = gst_pad_get_element_private (GST_PAD (data));

    g_mutex_unlock (mux);

    g_mutex_free (mux);

    gst_object_unref (GST_OBJECT (data)); 

 }

 static void

 gst_concat_mux_clear (GstConcatMux *mux)

 {

   mux->resync = TRUE;

   mux->timeoffset = 0;

   mux->offset = 0;

   mux->negotiated = FALSE;

   mux->done = TRUE;

   if (mux->sinks != NULL) {

     g_slist_foreach (mux->sinks, gst_concat_mux_free_pad, mux);

     g_slist_free (mux->sinks);

     mux->sinks = NULL;

   }

 }

 static GstPadLinkReturn

 gst_concat_mux_sinkconnect (GstPad * pad, GstPad * peer)

 {

   gchar *pad_name = NULL;

   GstConcatMux *concat_mux;

   concat_mux = GST_CONCAT_MUX (gst_pad_get_parent (pad));

   if (concat_mux->sink_caps != NULL) {

       GstCaps *peer_caps = gst_pad_get_caps (peer);

       GstCaps *intersect;

       intersect =  gst_caps_intersect (concat_mux->sink_caps, peer_caps);

       if (intersect == NULL) {

           gst_caps_unref (peer_caps);

           return GST_PAD_LINK_NOFORMAT;

       }

       gst_caps_unref (peer_caps);

       gst_caps_unref (intersect);

   } else {

       concat_mux->sink_caps = gst_pad_get_caps (pad);

   }

   pad_name = gst_pad_get_name (pad);

   GST_DEBUG_OBJECT (concat_mux, "sinkconnect triggered on %s", pad_name);

   g_free (pad_name);

   gst_object_unref (concat_mux);

   return GST_PAD_LINK_OK;

 }

 static GstPad *

 gst_concat_mux_request_new_pad (GstElement * element,

     GstPadTemplate * templ, const gchar * req_name)

 {

   GstConcatMux *concat_mux;

   GstPad *newpad;

   GstElementClass *klass = GST_ELEMENT_GET_CLASS (element);

   GMutex *mutex;

   g_return_val_if_fail (templ != NULL, NULL);

   if (templ->direction != GST_PAD_SINK) {

     g_warning ("concat_mux: request pad that is not a SINK pad\n");

     return NULL;

   }

   g_return_val_if_fail (GST_IS_CONCAT_MUX (element), NULL);

   concat_mux = GST_CONCAT_MUX (element);

   if (templ == gst_element_class_get_pad_template (klass, "sink_%d")) {

     gchar *name;

     /* create new pad with the name */

     name = g_strdup_printf ("sink_%02d", concat_mux->numpads);

     g_debug ("NEw pad %s", name);

     newpad = gst_pad_new_from_template (templ, name);

     g_free (name);

     concat_mux->sinks = g_slist_append (concat_mux->sinks, newpad);

     g_debug ("New sink %p / %d", newpad, g_slist_length (concat_mux->sinks));

     concat_mux->numpads++;

   } else {

     g_warning ("concat_mux: this is not our template!\n");

     return NULL;

   }

   mutex = g_mutex_new ();

   if (concat_mux->sinkpad == NULL) {

       concat_mux->sinkpad = newpad;

   }

   else {

       g_mutex_lock (mutex);

   }

   gst_pad_set_element_private (newpad, mutex);

   /* setup some pad functions */

   gst_pad_set_link_function (newpad, gst_concat_mux_sinkconnect);

   gst_pad_set_event_function (newpad, gst_concat_mux_handle_sink_event);

   gst_pad_set_chain_function (newpad, gst_concat_mux_chain);

   /* add the pad to the element */

   gst_element_add_pad (element, newpad);

   return newpad;

 }

 /* handle events */

 static gboolean

 gst_concat_mux_handle_src_event (GstPad * pad, GstEvent * event)

 {

   GstConcatMux *concat_mux;

   GstEventType type;

   concat_mux = GST_CONCAT_MUX (gst_pad_get_parent (pad));

   type = event ? GST_EVENT_TYPE (event) : GST_EVENT_UNKNOWN;

   switch (type) {

     case GST_EVENT_SEEK:

       /* disable seeking for now */

       return FALSE;

     default:

       break;

   }

   gst_object_unref (concat_mux);

   return gst_pad_event_default (pad, event);

 }

 /* handle events */

 static gboolean

 gst_concat_mux_handle_sink_event (GstPad * pad, GstEvent * event)

 {

   GstConcatMux *mux;

   GstEventType type;

   mux = GST_CONCAT_MUX (gst_pad_get_parent (pad));

   type = event ? GST_EVENT_TYPE (event) : GST_EVENT_UNKNOWN;

   switch (type) {

     case GST_EVENT_EOS:

     {

         mux->resync = TRUE;

         g_debug ("sink EOS %p / %d", pad, g_slist_length (mux->sinks));

         /* mark pad eos */

         mux->sinks  = g_slist_remove (mux->sinks, pad);

         g_debug ("sink len %d", g_slist_length (mux->sinks));

         if (g_slist_length (mux->sinks) != 0) {

            GMutex *mutex;

            mux->sinkpad = mux->sinks->data;

            mutex = (GMutex *) gst_pad_get_element_private (mux->sinkpad);

            g_mutex_unlock (mutex);

            g_debug ("sink pad %p", mux->sinkpad);

            return TRUE;

         }

         g_debug ("sink list is empty");

     }

     default:

       break;

   }

   gst_object_unref (mux);

   return gst_pad_event_default (pad, event);

 }

 static GstFlowReturn

 gst_concat_mux_chain (GstPad * pad,  GstBuffer * buf)

 {

   GstConcatMux *mux = (GstConcatMux *) GST_PAD_PARENT (pad);

   GstBuffer *databuf = NULL;

   GstFlowReturn ret = GST_FLOW_OK;

   GMutex *mutex;

   mutex = (GMutex*) gst_pad_get_element_private (pad);

   g_mutex_lock (mutex);

   if (mux->done) {

       g_debug ("DONE pad %p", pad);

       g_mutex_unlock (mutex);

       return GST_FLOW_OK;

   }

   databuf = gst_buffer_make_metadata_writable (buf);

   if (!mux->negotiated) {

       /*

     GstCaps *newcaps;

     newcaps = gst_pad_get_caps (mux->sinkpad);

     g_debug ("CAPS: %s",gst_caps_to_string (newcaps));

     if (!gst_pad_set_caps (mux->srcpad, newcaps))

       goto nego_error;

     */

     mux->negotiated = TRUE;            

   } 

   /*

   g_debug ("Running [%s]\n"

         "\tTOFFSET    [%"G_GUINT64_FORMAT"]\n"

         "\tB_TSTAMP   [%"G_GUINT64_FORMAT"]\n"

         "\tB_DURATION [%"G_GUINT64_FORMAT"]\n"

         "\tOFFSET     [%"G_GUINT64_FORMAT"]\n"

         "\tB_OFFSET   [%"G_GUINT64_FORMAT"]",

         gst_element_get_name (mux),

         mux->timeoffset, 

         GST_BUFFER_TIMESTAMP (databuf),

         GST_BUFFER_DURATION (databuf),

         mux->offset,

         GST_BUFFER_OFFSET (databuf));

   */        

   if (mux->resync) {

     g_debug ("RESYNC [%s]", gst_element_get_name (mux));

     mux->timeoffset += GST_BUFFER_TIMESTAMP (databuf);

     GST_BUFFER_TIMESTAMP (databuf) = mux->timeoffset;

     mux->timeoffset += GST_BUFFER_DURATION (databuf);

     mux->offset += GST_BUFFER_OFFSET (databuf);

     GST_BUFFER_OFFSET (databuf) = mux->offset;

     mux->offset += GST_BUFFER_SIZE (databuf);

     mux->resync = FALSE;

   } else {

     GST_BUFFER_TIMESTAMP (databuf) = mux->timeoffset;

     mux->timeoffset += GST_BUFFER_DURATION (databuf);

     GST_BUFFER_OFFSET (databuf) = mux->offset;

     mux->offset += GST_BUFFER_SIZE (databuf);

   }

   gst_buffer_set_caps (databuf, GST_PAD_CAPS (pad));

   ret = gst_pad_push (mux->srcpad, databuf);

   //gst_buffer_unref (buf);

   g_mutex_unlock (mutex);

   return ret;

 /*

 nego_error:

   {

     GST_WARNING_OBJECT (mux, "failed to set caps");

     GST_ELEMENT_ERROR (mux, CORE, NEGOTIATION, (NULL), (NULL));

     return GST_FLOW_NOT_NEGOTIATED;

   }

   */

   /*

 no_caps:

   {

     GST_WARNING_OBJECT (mux, "no caps on the incoming buffer %p", best->buffer);

     GST_ELEMENT_ERROR (mux, CORE, NEGOTIATION, (NULL), (NULL));

     ret = GST_FLOW_NOT_NEGOTIATED;

     goto beach;

   }

   */

 }

 static GstStateChangeReturn

 gst_concat_mux_change_state (GstElement * element, GstStateChange transition)

 {

   GstConcatMux *concat_mux;

   GstStateChangeReturn ret;

   concat_mux = GST_CONCAT_MUX (element);

   switch (transition) {

     case GST_STATE_CHANGE_READY_TO_PAUSED:

       concat_mux->done = FALSE;

       concat_mux->resync = TRUE;

       GST_DEBUG_OBJECT (concat_mux, "starting collect pads");

       break;

     case GST_STATE_CHANGE_PAUSED_TO_READY:

       GST_DEBUG_OBJECT (concat_mux, "stopping collect pads");

       gst_concat_mux_clear (concat_mux);

       break;

     default:

       break;

   }

   ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);

   if (ret == GST_STATE_CHANGE_FAILURE)

     return ret;

   switch (transition) {

     default:

       break;

   }

   return ret;

 }

 gboolean

 gst_concat_mux_plugin_init (GstPlugin * plugin)

 {

 #ifdef ENABLE_NLS

   setlocale (LC_ALL, "");

   bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);

 #endif /* ENABLE_NLS */

   GST_DEBUG_CATEGORY_INIT (gst_concat_mux_debug, "concatmux", 0,

       "concat muxer");

   return gst_element_register (plugin, "concatmux", GST_RANK_NONE,

       GST_TYPE_CONCAT_MUX);

 }

 GST_PLUGIN_DEFINE (GST_VERSION_MAJOR,

     GST_VERSION_MINOR,

     "concatmux",

     "Concat streamers",

      gst_concat_mux_plugin_init, VERSION, GST_LICENSE, GST_PACKAGE_NAME, GST_PACKAGE_ORIGIN)