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