#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include <glib.h>

#include <gst/gst.h>

#include <string.h>

#include "gmemcoder.h"

#define G_MENCODER_GET_PRIVATE(obj) \

    (G_TYPE_INSTANCE_GET_PRIVATE ((obj), G_TYPE_MENCODER, GMencoderPrivate))

typedef struct _GMencoderPrivate GMencoderPrivate;

struct _GMencoderPrivate

{    

	GstElement *pipe;

	GstElement *abin;

	GstElement *vbin;

	GstElement *sink;

	gboolean ready;

};

enum {

  READY,

  PAUSED,

  PLAYING,

  STOPED,

  EOS,

  ERROR,

  LAST_SIGNAL

};

static void g_mencoder_class_init       (GMencoderClass *klass);

static void g_mencoder_init             (GMencoder *object);

static void g_mencoder_dispose  	    (GObject *object);

static void g_mencoder_finalize 	    (GObject *object);

static gboolean 

            _pipeline_bus_cb            (GstBus     *bus,

		                                 GstMessage *msg,

		                                 gpointer    user_data);

static void _decodebin_new_pad_cb 		(GstElement* object,

				                         GstPad* pad,

				                         gboolean flag,

				                         gpointer user_data);

static void  _decodebin_unknown_type_cb (GstElement* object,

		                         	     GstPad* pad,

                                         GstCaps* caps,

                                         gpointer user_data);

static guint g_mencoder_signals[LAST_SIGNAL] = { 0 };

G_DEFINE_TYPE(GMencoder, g_mencoder, G_TYPE_OBJECT)

static void

g_mencoder_class_init (GMencoderClass *klass)

{   

	GObjectClass *object_class;

	object_class = (GObjectClass *) klass;

	g_type_class_add_private (klass, sizeof (GMencoderPrivate));

	object_class->dispose  = g_mencoder_dispose;

	object_class->finalize = g_mencoder_finalize;	

    g_mencoder_signals[READY] =

        g_signal_new ("ready",

    		  G_OBJECT_CLASS_TYPE (object_class),

    		  G_SIGNAL_RUN_FIRST,

    		  0, NULL, NULL,

    		  g_cclosure_marshal_VOID__VOID,

    		  G_TYPE_NONE, 0);

    g_mencoder_signals[PAUSED] =

        g_signal_new ("paused",

    		  G_OBJECT_CLASS_TYPE (object_class),

    		  G_SIGNAL_RUN_FIRST,

    		  0, NULL, NULL,

    		  g_cclosure_marshal_VOID__VOID,

    		  G_TYPE_NONE, 0);

    g_mencoder_signals[PLAYING] =

        g_signal_new ("playing",

    		  G_OBJECT_CLASS_TYPE (object_class),

    		  G_SIGNAL_RUN_FIRST,

    		  0, NULL, NULL,

              g_cclosure_marshal_VOID__VOID,

    		  G_TYPE_NONE, 0);

    g_mencoder_signals[STOPED] =

        g_signal_new ("stoped",

    		  G_OBJECT_CLASS_TYPE (object_class),

    		  G_SIGNAL_RUN_FIRST,

    		  0, NULL, NULL,

    		  g_cclosure_marshal_VOID__VOID,

    		  G_TYPE_NONE, 0);

    g_mencoder_signals[EOS] =

        g_signal_new ("eos",

    		  G_OBJECT_CLASS_TYPE (object_class),

    		  G_SIGNAL_RUN_FIRST,

    		  0, NULL, NULL,

    		  g_cclosure_marshal_VOID__VOID,

    		  G_TYPE_NONE, 0);

    g_mencoder_signals[ERROR] =

        g_signal_new ("error",

    		  G_OBJECT_CLASS_TYPE (object_class),

    		  G_SIGNAL_RUN_FIRST,

    		  0, NULL, NULL,

    		  g_cclosure_marshal_VOID__STRING,

    		  G_TYPE_NONE, 1, G_TYPE_STRING);	

}

static void

g_mencoder_init (GMencoder *self)

{

}

static void 

g_mencoder_dispose (GObject *object)

{

}

static void 

g_mencoder_finalize (GObject *object)

{

	g_mencoder_close_stream (G_MENCODER (object));

}

GMencoder*  

g_mencoder_new (void)

{

    return g_object_new (G_TYPE_MENCODER, NULL);

}

gboolean

g_mencoder_setup_stream (GMencoder *self, 

                         const gchar* uri, 

                         guint width, guint height,

                         gint out_fd)

{

	GstBus *bus = NULL;

	GstElement *pipe = NULL;

	GstElement *decode = NULL;

	GstElement *fdsink = NULL;

    GstElement *mux = NULL;

	GstCaps *vscale_caps = NULL;

	GstPad *asinkpad = NULL;

	GstPad *vsinkpad = NULL;

    GstPad *video_src_pad = NULL;

    GstPad *audio_src_pad = NULL;

    GstPad *mux_pad = NULL;

	GstElement *src = NULL;

	GstElement *vbin, *vqueue, *vcolorspace, *vscale, *vrate, *vencode, *vqueue_src;

	GstElement *abin, *aqueue, *aconvert, *aencode, *aqueue_src;

	GMencoderPrivate *priv = G_MENCODER_GET_PRIVATE (self);

	vbin = vqueue = vscale = vrate = vencode = vqueue_src = NULL;

	abin = aqueue = aconvert = aencode = aqueue_src = NULL;

	pipe = gst_pipeline_new ("pipe");

	src = gst_element_make_from_uri (GST_URI_SRC, uri, "src");

	if (src == NULL) 

		goto error;

	decode = gst_element_factory_make ("decodebin", "decode");

	if (decode == NULL) 

		goto error;

    mux = gst_element_factory_make ("ffmux_mpeg", "mux");

    if (mux == NULL)

        goto error;

    fdsink = gst_element_factory_make ("fdsink", "sink");

    if (fdsink == NULL)

        goto error;

    g_debug ("Setting fd to %d", out_fd);

    g_object_set (G_OBJECT (fdsink), "fd", out_fd, NULL);        		

	//queue ! videoscale ! video/x-raw-yuv,width=240,height=144 ! videorate ! ffenc_h263p bitrate=256000 me-method=2 ! rtph263ppay ! udpsink  host=224.0.0.1 port=5000

	vbin    = gst_bin_new ("vbin");

	vqueue	= gst_element_factory_make ("queue", "vqueue");

	vscale  = gst_element_factory_make ("videoscale", "vscale");

	vcolorspace = gst_element_factory_make ("ffmpegcolorspace", "colorspace");

	vrate   = gst_element_factory_make ("videorate", "vrate");

	vencode = gst_element_factory_make ("ffenc_mpeg1video", "vencode");

	vqueue_src = gst_element_factory_make ("queue", "queue_src");

	if ((vbin == NULL) || (vqueue == NULL) || (vcolorspace == NULL) 

	    || (vscale == NULL) || (vrate == NULL) 

		|| (vencode == NULL) || (vqueue_src == NULL)) {

		g_warning ("Video elements not found");

		goto error;

	}

	g_object_set (G_OBJECT (vencode), "bitrate", 200, "pass", 2, "quantizer", 5, NULL);

	gst_bin_add_many (GST_BIN (vbin), vqueue, vscale, vcolorspace, vrate, vencode, vqueue_src, NULL);

    gst_element_link (vqueue, vscale);

	vscale_caps = gst_caps_new_simple ("video/x-raw-yuv",

					   "width", G_TYPE_INT, 320,

					   "height", G_TYPE_INT, 288,                           

					   NULL);

	if (gst_element_link_filtered (vscale, vcolorspace, vscale_caps) == FALSE) {

	    g_warning ("Fail to resize video");

	    goto error;

	}

	if (gst_element_link (vcolorspace, vrate) == FALSE) {

	    g_warning ("Fail to link video elements");

	    goto error;

	}

    gst_caps_unref (vscale_caps);

	vscale_caps = gst_caps_new_simple ("video/x-raw-yuv",

					   "framerate", GST_TYPE_FRACTION, 10, 1, NULL);

    if (gst_element_link_filtered (vrate, vencode, vscale_caps) == FALSE) { 

        g_warning ("Fail to link vrate with vencode.");

        goto error;

    }

    gst_element_link (vencode, vqueue_src);

	// ghost pad the video  bin

   	vsinkpad = gst_element_get_pad (vqueue, "sink");

   	gst_element_add_pad (vbin, gst_ghost_pad_new ("sink", vsinkpad));	

	gst_object_unref (vsinkpad);

   	video_src_pad = gst_element_get_pad (vqueue_src, "src");

   	gst_element_add_pad (vbin, gst_ghost_pad_new ("src", video_src_pad));	

	gst_object_unref (video_src_pad);

    //audio/x-raw-int ! queue ! audioconvert ! faac ! rtpmp4gpay !  udpsink name=upd_audio host=224.0.0.1 port=5002	

	abin 	= gst_bin_new ("abin");

	aqueue	= gst_element_factory_make ("queue", "aqueue");

	aconvert= gst_element_factory_make ("audioconvert", "aconvert");

	aencode = gst_element_factory_make ("lame", "aencode");

	aqueue_src= gst_element_factory_make ("queue", "aqueue_src");	

	if ((abin == NULL) || (aqueue == NULL) || (aconvert == NULL) 

		|| (aencode == NULL) || (aqueue_src == NULL)) {

		g_warning ("Audio elements not found");

		goto error;

	}

	gst_bin_add_many (GST_BIN (abin), aqueue, aconvert, aencode, aqueue_src, NULL);

	gst_element_link_many (aqueue, aconvert, aencode, aqueue_src, NULL);

	// ghost pad the audio bin

   	asinkpad = gst_element_get_pad (aqueue, "sink");

   	gst_element_add_pad (abin, gst_ghost_pad_new("sink", asinkpad));

	gst_object_unref (asinkpad);

   	audio_src_pad = gst_element_get_pad (aqueue_src, "src");

   	gst_element_add_pad (abin, gst_ghost_pad_new("src", audio_src_pad));

    gst_object_unref (audio_src_pad);

	// Finish Pipe

	gst_bin_add_many (GST_BIN (pipe), src, decode, abin, vbin, mux, fdsink, NULL);

	gst_element_link (src, decode);

    //Link bins with mux

    audio_src_pad = gst_element_get_pad (abin, "src");

    mux_pad = gst_element_get_pad (mux, "audio_0");

    if (gst_pad_link (audio_src_pad, mux_pad) != GST_PAD_LINK_OK) {

        g_warning ("Fail link audio and mux");

        goto error;

    }

	gst_object_unref (audio_src_pad);

    gst_object_unref (mux_pad);

    audio_src_pad = NULL;

    mux_pad = NULL;

    video_src_pad = gst_element_get_pad (vbin, "src");

    mux_pad = gst_element_get_pad (mux, "video_0");

    if (gst_pad_link (video_src_pad, mux_pad) != GST_PAD_LINK_OK) {

        g_warning ("Fail link video and mux");

        goto error;

    }

    gst_object_unref (video_src_pad);

    gst_object_unref (mux_pad);

    video_src_pad = NULL;

    mux_pad = NULL;

    //Link mux with sink

    gst_element_link (mux, fdsink);

	bus = gst_pipeline_get_bus (GST_PIPELINE (pipe));

	gst_bus_add_watch (bus, _pipeline_bus_cb, self);

	gst_object_unref (bus);

	g_signal_connect (G_OBJECT (decode), 

				"new-decoded-pad",

				G_CALLBACK (_decodebin_new_pad_cb),

				self);

	g_signal_connect (G_OBJECT (decode),

				"unknown-type",

				G_CALLBACK (_decodebin_unknown_type_cb),

				self);

	g_debug ("Setting pipe to PAUSE");

	priv->pipe = pipe;

	priv->abin = abin;

	priv->vbin = vbin;

	priv->sink = fdsink;

	priv->ready = FALSE;

	gst_element_set_state (pipe, GST_STATE_PAUSED);	   	

    g_debug ("End SETUP");

	return  TRUE;

error:

	g_warning ("Invalid uri");

	if (pipe != NULL)

		gst_object_unref (pipe);

	if (src != NULL)

		gst_object_unref (src);

	if (decode != NULL)

		gst_object_unref (decode);

	if (vscale_caps != NULL)

		gst_caps_unref  (vscale_caps);

	if (vbin != NULL)

		gst_object_unref (vbin);

	if (vqueue != NULL)

		gst_object_unref (vqueue);

	if (vrate != NULL)

		gst_object_unref (vrate);

	if (vencode != NULL)

		gst_object_unref (vencode);

	if (vqueue_src != NULL)

		gst_object_unref (vqueue_src);

	if (abin != NULL)

		gst_object_unref (abin);

	if (aqueue != NULL)

		gst_object_unref (aqueue);

	if (aconvert != NULL)

		gst_object_unref (aconvert);

	if (aencode != NULL)

		gst_object_unref (aencode);

	if (aqueue_src != NULL)

		gst_object_unref (aqueue_src);

    if (video_src_pad != NULL) {

        gst_object_unref (video_src_pad);

    }

    if (audio_src_pad != NULL) {

        gst_object_unref (audio_src_pad);

    }

    if (mux != NULL) {

        gst_object_unref (mux);

    }

    if (mux_pad != NULL) {

        gst_object_unref (mux_pad);

    }

	if (fdsink != NULL)

		gst_object_unref (fdsink);

	return FALSE;

}

gboolean 

g_mencoder_play_stream (GMencoder *self)

{

    GMencoderPrivate *priv = G_MENCODER_GET_PRIVATE (self);

    g_return_val_if_fail (priv->ready == TRUE, FALSE);

    if (gst_element_set_state (priv->pipe, GST_STATE_PLAYING) != GST_STATE_CHANGE_FAILURE) {

			g_debug ("PLAYING");

			return TRUE;

	}

	return FALSE;

}

gboolean

g_mencoder_pause_stream (GMencoder *self)

{

    GMencoderPrivate *priv = G_MENCODER_GET_PRIVATE (self);

    g_return_val_if_fail (priv->ready == TRUE, FALSE);

    if (gst_element_set_state (priv->pipe, GST_STATE_PAUSED) != GST_STATE_CHANGE_FAILURE) {

			g_debug ("PAUSED");

			return TRUE;

	}

	return FALSE;

}

void

g_mencoder_close_stream (GMencoder *self)

{

    GMencoderPrivate *priv = G_MENCODER_GET_PRIVATE (self);

    g_return_if_fail (priv->ready == TRUE);

    gst_element_set_state (priv->pipe, GST_STATE_NULL);

    gst_object_unref (priv->pipe);

    priv->pipe = NULL;

    priv->abin = NULL;

    priv->vbin = NULL;

    priv->sink = NULL;

    priv->ready = FALSE;

}

static gboolean

_pipeline_bus_cb (GstBus     *bus,

		  GstMessage *msg,

		  gpointer    user_data)

{

	switch (GST_MESSAGE_TYPE (msg)) 

	{

		case GST_MESSAGE_STATE_CHANGED:

		{

			GstState oldstate;

			GstState newstate;

			GstState pendingstate;

			GMencoderPrivate *priv = G_MENCODER_GET_PRIVATE (user_data);

			gst_message_parse_state_changed (msg, &oldstate,

				&newstate, &pendingstate);

            if (pendingstate != GST_STATE_VOID_PENDING)

                break;

            if ((oldstate == GST_STATE_READY) && 

                (newstate == GST_STATE_PAUSED)) {

                    if (priv->ready) 

                        g_signal_emit (user_data, g_mencoder_signals[PAUSED], 0);

                    else {

                        priv->ready = TRUE;

                        g_signal_emit (user_data, g_mencoder_signals[READY], 0);

                    }

            } else if ((oldstate == GST_STATE_PAUSED) &&

                       (newstate == GST_STATE_PLAYING)) {

                        g_signal_emit (user_data, g_mencoder_signals[PLAYING], 0);

            } else if ((oldstate == GST_STATE_READY) &&

                       (newstate == GST_STATE_NULL)) {

                        g_signal_emit (user_data, g_mencoder_signals[STOPED], 0);

            }			

            break;

		}

		case GST_MESSAGE_ERROR: 

		{

		    GError *error;

		    gchar *debug;

		    gchar *err_str;

		    gst_message_parse_error (msg, &error, &debug);

		    err_str = g_strdup_printf ("Error [%d] %s (%s)", error->code,

		        error->message,

		        debug);

		    g_signal_emit (user_data, g_mencoder_signals[ERROR], 0, err_str);

		    g_free (err_str);

		    g_clear_error (&error);

		    g_free (debug);

		    break;

		}

		case GST_MESSAGE_EOS:

		    g_signal_emit (user_data, g_mencoder_signals[EOS], 0);

		    break;		

		default:

			break;

	}

	return TRUE;

}

static void 

_decodebin_new_pad_cb (GstElement* object,

                       GstPad* pad,

                       gboolean flag,

                       gpointer user_data)

{

	GstCaps *caps;

	gchar *str_caps = NULL;

    GMencoderPrivate *priv = G_MENCODER_GET_PRIVATE (user_data);

	caps = gst_pad_get_caps (pad);

	str_caps = gst_caps_to_string (caps);

    g_debug ("CAPS : %s", str_caps);

	if (strstr (str_caps, "audio") != NULL) {

		GstPad *apad = gst_element_get_pad (priv->abin, "sink");

		g_debug ("Linked with Audio");

		gst_pad_link (pad, apad);

		gst_object_unref (apad);

	} else if (strstr (str_caps, "video") != NULL) {

		GstPad *vpad = gst_element_get_pad (priv->vbin, "sink");

		g_debug ("Linked with Video");

		gst_pad_link (pad, vpad);

		gst_object_unref (vpad);

	} else {

		g_warning ("invalid caps %s", str_caps);

	}

	g_free (str_caps);

	gst_caps_unref (caps);

	g_debug ("OK");

}

static void 

_decodebin_unknown_type_cb (GstElement* object,

                            GstPad* pad,

                            GstCaps* caps,

                            gpointer user_data)

{

    g_warning  ("Unknown Type");

}