#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include <gst/gst.h>

#include <gst/base/gstcollectpads.h>

#include <stdlib.h> 

#include <string.h>

/* gpac includes */

#include <gpac/isomedia.h>

#define GST_TYPE_GPAC_MUX (gst_gpac_mux_get_type())

#define GST_GPAC_MUX(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_GPAC_MUX, GstGpacMux))

#define GST_GPAC_MUX_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_GPAC_MUX, GstGpacMux))

#define GST_IS_GPAC_MUX(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_GPAC_MUX))

#define GST_IS_GPAC_MUX_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_GPAC_MUX))

typedef struct _GstGpacMux GstGpacMux;

typedef struct _GstGpacMuxClass GstGpacMuxClass;

typedef enum

{

  GST_GPAC_PAD_STATE_CONTROL = 0,

  GST_GPAC_PAD_STATE_DATA = 1

}

GstGpacPadState;

typedef struct

{

  GstCollectData collect;       /* we extend the CollectData */

  gint track_number;

  guint32 di; /* outDescriptionIndex */

  guint32 frame_count;

  gboolean is_video;

} GstGpacPad;

struct _GstGpacMux

{

  GstElement element;

  GstPad *srcpad;

  GstCollectPads *collect;

  GF_ISOFile *file;

};

struct _GstGpacMuxClass

{

  GstElementClass parent_class;

};

/* elementfactory information */

static const GstElementDetails gst_gpac_mux_details =

GST_ELEMENT_DETAILS ("Gpac muxer",

    "Codec/Muxer",

    "mux mp4 streams",

    "Hallyson Melo <hallyson.melo@indt.org.br");

/* GpacMux signals and args */

enum

{

  /* FILL ME */

  LAST_SIGNAL

};

static GstStaticPadTemplate src_factory = GST_STATIC_PAD_TEMPLATE ("src",

    GST_PAD_SRC,

    GST_PAD_ALWAYS,

    GST_STATIC_CAPS ("video/quicktime")

    );

static GstStaticPadTemplate audio_sink_factory = GST_STATIC_PAD_TEMPLATE ("audio_%d",

    GST_PAD_SINK,

    GST_PAD_REQUEST,

    GST_STATIC_CAPS (

        "audio/mpeg, " 

        "mpegversion = (int) 4, " 

        "channels = (int) { 1, 2 }, " 

        "rate = (int) [ 8000, 96000 ]")

    );

    //GST_STATIC_CAPS ("audio/mpeg, mpegversion = 1, layer = 3")

static GstStaticPadTemplate video_sink_factory = GST_STATIC_PAD_TEMPLATE ("video_%d",

    GST_PAD_SINK,

    GST_PAD_REQUEST,

    GST_STATIC_CAPS ("video/mpeg, mpegversion = 4")

   );

static void gst_gpac_mux_base_init (gpointer g_class);

static void gst_gpac_mux_class_init (GstGpacMuxClass * klass);

static void gst_gpac_mux_init (GstGpacMux * gpac_mux);

static void gst_gpac_mux_finalize (GObject * object);

static GstFlowReturn

gst_gpac_mux_collected (GstCollectPads * pads, GstGpacMux * gpac_mux);

static gboolean gst_gpac_mux_handle_src_event (GstPad * pad, GstEvent * event);

static GstPad *gst_gpac_mux_request_new_pad (GstElement * element,

    GstPadTemplate * templ, const gchar * name);

static void gst_gpac_mux_release_pad (GstElement * element, GstPad * pad);

static GstStateChangeReturn gst_gpac_mux_change_state (GstElement * element,

    GstStateChange transition);

static GstElementClass *parent_class = NULL;

GType

gst_gpac_mux_get_type (void)

{

  static GType gpac_mux_type = 0;

  if (G_UNLIKELY (gpac_mux_type == 0)) {

    static const GTypeInfo gpac_mux_info = {

      sizeof (GstGpacMuxClass),

      gst_gpac_mux_base_init,

      NULL,

      (GClassInitFunc) gst_gpac_mux_class_init,

      NULL,

      NULL,

      sizeof (GstGpacMux),

      0,

      (GInstanceInitFunc) gst_gpac_mux_init,

    };

    gpac_mux_type =

        g_type_register_static (GST_TYPE_ELEMENT, "GstGpacMux", &gpac_mux_info,

        0);

  }

  return gpac_mux_type;

}

static void

gst_gpac_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 (&audio_sink_factory));

  gst_element_class_add_pad_template (element_class,

      gst_static_pad_template_get (&video_sink_factory));

  gst_element_class_set_details (element_class, &gst_gpac_mux_details);

}

static void

gst_gpac_mux_class_init (GstGpacMuxClass * 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_gpac_mux_finalize;

  gstelement_class->request_new_pad = gst_gpac_mux_request_new_pad;

  gstelement_class->release_pad = gst_gpac_mux_release_pad;

  gstelement_class->change_state = gst_gpac_mux_change_state;

}

static void

gst_gpac_mux_init (GstGpacMux * gpac_mux)

{

  GstElementClass *klass = GST_ELEMENT_GET_CLASS (gpac_mux);

  gpac_mux->srcpad =

      gst_pad_new_from_template (gst_element_class_get_pad_template (klass,

          "src"), "src");

  gst_pad_set_event_function (gpac_mux->srcpad, gst_gpac_mux_handle_src_event);

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

  gpac_mux->collect = gst_collect_pads_new ();

  gst_collect_pads_set_function (gpac_mux->collect,

      (GstCollectPadsFunction) GST_DEBUG_FUNCPTR (gst_gpac_mux_collected),

      gpac_mux);

  /* Opens gpac library */

  /* FIXME */

  gpac_mux->file = gf_isom_open("/tmp/gpac.mp4", GF_ISOM_OPEN_WRITE, NULL);

  gf_isom_set_storage_mode(gpac_mux->file, GF_ISOM_STORE_FLAT /*STREAMABLE*/);

  //gst_gpac_mux_clear (gpac_mux);

}

static void

gst_gpac_mux_finalize (GObject * object)

{

  GstGpacMux *gpac_mux;

  gpac_mux = GST_GPAC_MUX (object);

  if (gpac_mux->collect) {

    gst_object_unref (gpac_mux->collect);

    gpac_mux->collect = NULL;

  }

  G_OBJECT_CLASS (parent_class)->finalize (object);

}

static void

gst_gpac_mux_gpac_pad_destroy_notify (GstCollectData * data)

{

  GstGpacPad *gpacpad = (GstGpacPad *) data;

  GstBuffer *buf;

/*  if (gpacpad->pagebuffers) {

    while ((buf = g_queue_pop_head (gpacpad->pagebuffers)) != NULL) {

      gst_buffer_unref (buf);

    }

    g_queue_free (gpacpad->pagebuffers);

    gpacpad->pagebuffers = NULL;

  }*/

}

static GstPadLinkReturn

gst_gpac_mux_sinkconnect (GstPad * pad, GstPad * peer)

{

  GstGpacMux *gpac_mux;

  gpac_mux = GST_GPAC_MUX (gst_pad_get_parent (pad));

  GST_DEBUG_OBJECT (gpac_mux, "sinkconnect triggered on %s", GST_PAD_NAME (pad));

  gst_object_unref (gpac_mux);

  return GST_PAD_LINK_OK;

}

static GstPad *

gst_gpac_mux_request_new_pad (GstElement * element,

    GstPadTemplate * templ, const gchar * req_name)

{

  GstGpacMux *gpac_mux;

  GstPad *newpad;

  GstElementClass *klass;

  gchar *padname = NULL;

  gint serial;

  gboolean is_video = FALSE;

  g_return_val_if_fail (templ != NULL, NULL);

  if (templ->direction != GST_PAD_SINK)

    goto wrong_direction;

  g_return_val_if_fail (GST_IS_GPAC_MUX (element), NULL);

  gpac_mux = GST_GPAC_MUX (element);

  klass = GST_ELEMENT_GET_CLASS (element);

    if (req_name == NULL || strlen (req_name) < 6) {

      /* no name given when requesting the pad, use random serial number */

      serial = rand ();

    } else {

      /* parse serial number from requested padname */

      serial = atoi (&req_name[5]);

    }

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

    is_video = TRUE;      

    padname = g_strdup_printf ("video_%d", serial);

  } else if (templ != gst_element_class_get_pad_template (klass, "audio_%d")) {

    goto wrong_template;

  } else {

    padname = g_strdup_printf ("audio_%d", serial);

  }

  {

    /* create new pad with the name */

    GST_DEBUG_OBJECT (gpac_mux, "Creating new pad for serial %d", serial);

    printf ("XXXX new pad from template\n");

    newpad = gst_pad_new_from_template (templ, padname);

    g_free (padname);

    /* construct our own wrapper data structure for the pad to

     * keep track of its status */

    {

      GstGpacPad *gpacpad;

      gpacpad = (GstGpacPad *)

          gst_collect_pads_add_pad_full (gpac_mux->collect, newpad,

          sizeof (GstGpacPad), gst_gpac_mux_gpac_pad_destroy_notify);

      /* gpac new track */

      gpacpad->is_video = is_video;

      if (gpacpad->is_video) {

        gpacpad->track_number = gf_isom_new_track(gpac_mux->file, 0, 

          GF_ISOM_MEDIA_VISUAL, 10 * 1000 /* time scale */);

      } else {

        gpacpad->track_number = gf_isom_new_track(gpac_mux->file, 0, 

          GF_ISOM_MEDIA_AUDIO, 48000 /*time scale */);

      }

      if (gpacpad->track_number == 0) {

        g_warning ("Error while adding the new gpac track");

      } else {

        gf_isom_set_track_enabled(gpac_mux->file, gpacpad->track_number, 1);

        if (is_video) {

          GF_ESD *esd = gf_odf_desc_esd_new (0);

          esd->ESID = gf_isom_get_track_id(gpac_mux->file, gpacpad->track_number);

          gf_isom_new_mpeg4_description( gpac_mux->file, gpacpad->track_number,

                        esd, NULL, NULL, &(gpacpad->di));

           gf_isom_set_visual_info (gpac_mux->file, gpacpad->track_number, gpacpad->di, 320, 240);//fixme

          //gf_isom_set_cts_packing (gpac_mux->file, gpacpad->track_number, 0);

        } else {

          GF_ESD *esd = gf_odf_desc_esd_new (2);

          esd->ESID = gf_isom_get_track_id(gpac_mux->file, gpacpad->track_number);

          gf_isom_new_mpeg4_description(gpac_mux->file, gpacpad->track_number,

                         esd, NULL, NULL, &(gpacpad->di));

          gf_isom_set_audio_info(gpac_mux->file, gpacpad->track_number, 

                          gpacpad->di, 48000, 2 /*num channels */, 16);

        }

      }

    }

  }

  /* setup some pad functions */

  gst_pad_set_link_function (newpad, gst_gpac_mux_sinkconnect);

  /* dd the pad to the element */

  gst_element_add_pad (element, newpad);

  return newpad;

  /* ERRORS */

wrong_direction:

  {

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

    return NULL;

  }

wrong_template:

  {

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

    return NULL;

  }

}

static void

gst_gpac_mux_release_pad (GstElement * element, GstPad * pad)

{

  GstGpacMux *gpac_mux;

  gpac_mux = GST_GPAC_MUX (gst_pad_get_parent (pad));

  gst_collect_pads_remove_pad (gpac_mux->collect, pad);

  gst_element_remove_pad (element, pad);

}

/* handle events */

static gboolean

gst_gpac_mux_handle_src_event (GstPad * pad, GstEvent * event)

{

  GstEventType type;

  type = event ? GST_EVENT_TYPE (event) : GST_EVENT_UNKNOWN;

  switch (type) {

    case GST_EVENT_SEEK:

      /* disable seeking for now */

      return FALSE;

    default:

      break;

  }

  return gst_pad_event_default (pad, event);

}

static GstFlowReturn

gst_gpac_mux_push_buffer (GstGpacMux * mux, GstBuffer * buffer)

{

  GstCaps *caps;

#if 0

  /* fix up OFFSET and OFFSET_END again */

  GST_BUFFER_OFFSET (buffer) = mux->offset;

  mux->offset += GST_BUFFER_SIZE (buffer);

  GST_BUFFER_OFFSET_END (buffer) = mux->offset;

  /* Ensure we have monotonically increasing timestamps in the output. */

  if (GST_BUFFER_TIMESTAMP_IS_VALID (buffer)) {

    if (mux->last_ts != GST_CLOCK_TIME_NONE &&

        GST_BUFFER_TIMESTAMP (buffer) < mux->last_ts)

      GST_BUFFER_TIMESTAMP (buffer) = mux->last_ts;

    else

      mux->last_ts = GST_BUFFER_TIMESTAMP (buffer);

  }

#endif

  caps = gst_pad_get_negotiated_caps (mux->srcpad);

  gst_buffer_set_caps (buffer, caps);

  if (caps != NULL) {

    gst_caps_unref (caps);

  }

  return gst_pad_push (mux->srcpad, buffer);

}

static gboolean

all_pads_eos (GstCollectPads * pads)

{

  GSList *iter;

  gboolean alleos = TRUE;

  iter = pads->data;

  while (iter) {

    GstBuffer *buf;

    GstCollectData *data = (GstCollectData *) iter->data;

    buf = gst_collect_pads_peek (pads, data);

    if (buf) {

      alleos = FALSE;

      gst_buffer_unref (buf);

      goto beach;

    }

    iter = iter->next;

  }

beach:

  return alleos;

}

static GstFlowReturn

gst_gpac_mux_collected (GstCollectPads * pads, GstGpacMux * gpac_mux)

{

  GstFlowReturn ret = GST_FLOW_OK;

  GSList *iter;

  GstBuffer *buf;

  gint i = 0;

  GST_LOG_OBJECT (gpac_mux, "collected");

  iter = gpac_mux->collect->data;

  while (iter) {

    GstCollectData *data = (GstCollectData *) iter->data;

    GstGpacPad *pad = (GstGpacPad *) data;

    buf = gst_collect_pads_pop (gpac_mux->collect, data);

  if (buf == NULL) {

    iter = g_slist_next (iter);

      continue;

  }

    GST_LOG_OBJECT (data->pad, "popped buffer %" GST_PTR_FORMAT, buf);

    /* gpac output */

    printf ("xxxxxx buffer size: %d\n", GST_BUFFER_SIZE(buf)); fflush (stdout);

    if (pad->frame_count < 300) {

      GF_ISOSample *sample = gf_isom_sample_new();

       sample->dataLength = GST_BUFFER_SIZE(buf);

       sample->data = GST_BUFFER_DATA(buf);

       sample->CTS_Offset = 0;

      if (pad->is_video) {

        sample->IsRAP = 0;

        sample->DTS += 1000*pad->frame_count;

      } else {

        sample->IsRAP = 0;

        sample->DTS = 2048*pad->frame_count;

      }

      gf_isom_add_sample(gpac_mux->file, pad->track_number, 

                      pad->di, sample);

      sample->data = NULL;

      gf_isom_sample_del(&sample);

      printf ("xxxx frames %d\n", pad->frame_count);

    } else if (pad->frame_count == 300) {

      printf ("XXX closing gpac output file\n"); fflush (stdout);

      gf_isom_close (gpac_mux->file);

    }

    /* gstreamer output (push) */

    if (gst_gpac_mux_push_buffer (gpac_mux, buf) != GST_FLOW_OK) {

      printf ("EEEEEEEE push failed\n");

    }

    iter = g_slist_next (iter);

    pad->frame_count++;

    i++;

  }

  /* fixme */

  return ret;

}

/* reset all variables in the gpac pads. */

static void

gst_gpac_mux_init_collectpads (GstCollectPads * collect)

{

  GSList *walk;

  walk = collect->data;

  while (walk) {

    GstGpacPad *gpacpad = (GstGpacPad *) walk->data;

    //ogg_stream_init (&gpacpad->stream, gpacpad->serial);

    //gpacpad->packetno = 0;

    //gpacpad->pageno = 0;

    //gpacpad->eos = FALSE;

    /* we assume there will be some control data first for this pad */

    //gpacpad->state = GST_GPAC_PAD_STATE_CONTROL;

    //gpacpad->new_page = TRUE;

    //gpacpad->first_delta = FALSE;

    //gpacpad->prev_delta = FALSE;

    //gpacpad->pagebuffers = g_queue_new ();

    walk = g_slist_next (walk);

  }

}

/* Clear all buffers from the collectpads object */

static void

gst_gpac_mux_clear_collectpads (GstCollectPads * collect)

{

  GSList *walk;

  for (walk = collect->data; walk; walk = g_slist_next (walk)) {

    GstGpacPad *gpacpad = (GstGpacPad *) walk->data;

    GstBuffer *buf;

    //gpac_stream_clear (&gpacpad->stream);

/*

    while ((buf = g_queue_pop_head (gpacpad->pagebuffers)) != NULL) {

      gst_buffer_unref (buf);

    }

    g_queue_free (gpacpad->pagebuffers);

    gpacpad->pagebuffers = NULL;*/

  }

}

static GstStateChangeReturn

gst_gpac_mux_change_state (GstElement * element, GstStateChange transition)

{

  GstGpacMux *gpac_mux;

  GstStateChangeReturn ret;

  gpac_mux = GST_GPAC_MUX (element);

  switch (transition) {

    case GST_STATE_CHANGE_NULL_TO_READY:

      break;

    case GST_STATE_CHANGE_READY_TO_PAUSED:

      //gst_gpac_mux_clear (gpac_mux);

      //gst_gpac_mux_init_collectpads (gpac_mux->collect);

      gst_collect_pads_start (gpac_mux->collect);

      break;

    case GST_STATE_CHANGE_PAUSED_TO_PLAYING:

      break;

    case GST_STATE_CHANGE_PAUSED_TO_READY:

      gst_collect_pads_stop (gpac_mux->collect);

      break;

    default:

      break;

  }

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

  switch (transition) {

    case GST_STATE_CHANGE_PLAYING_TO_PAUSED:

      break;

    case GST_STATE_CHANGE_PAUSED_TO_READY:

      gst_gpac_mux_clear_collectpads (gpac_mux->collect);

      break;

    case GST_STATE_CHANGE_READY_TO_NULL:

      break;

    default:

      break;

  }

  return ret;

}

static gboolean

gst_gpac_mux_plugin_init (GstPlugin * plugin)

{

  return gst_element_register (plugin, "gpacmux", GST_RANK_NONE,

      GST_TYPE_GPAC_MUX);

}

GST_PLUGIN_DEFINE(GST_VERSION_MAJOR,

                  GST_VERSION_MINOR,

                  "gpacmux",

                  "Muxes audio and video",

                  gst_gpac_mux_plugin_init, VERSION, GST_LICENSE, GST_PACKAGE_NAME,

                  GST_PACKAGE_ORIGIN)