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