/*

  * 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)