#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include <sys/stat.h>

#include <fcntl.h>

#include <unistd.h>

#include <glib.h>

#include <gst/gst.h>

#include <string.h>

#include "gmencoder.h"

#define G_MENCODER_GET_PRIVATE(obj) \

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

//#define SUPPORT_MULT_INPUT  0

typedef struct _GMencoderPrivate GMencoderPrivate;

typedef struct _SetupInfo SetupInfo;

struct _SetupInfo

{

  gchar *video_encode;

  gchar *mux_name;

  gchar **video_encode_prop;

  gdouble video_fps;

  gdouble video_rate;

  guint video_width;

  guint video_height;

  gchar *audio_encode;

  gchar **audio_encode_prop;

  guint audio_rate;

};

struct _GMencoderPrivate

{

  GstElement *pipe;

  GstElement *abin;

  GstElement *vbin;

  GstElement *sink;

  GstElement *src;

  gboolean ready;

  SetupInfo *info;

  GstClockTime videot;

  GstClockTime audiot;

  gint fd;

  gint sources;

  gint tick_id;

  gint64 duration;

};

enum

{

  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 GstElement *_create_audio_bin(const gchar * encode,

									 gchar ** encode_prop, gint rate);

static GstElement *_create_video_bin(const gchar * encode,

									 gchar ** encode_prop,

									 gdouble fps,

									 gint rate, guint width, guint height);

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 void _close_output(GMencoder * self);

static void _open_output(GMencoder * self, const gchar * uri);

static GstElement *_create_source(const gchar * uri);

static GstElement *_create_pipeline(GMencoder * self,

									const gchar * video_encode,

									const gchar * mux_name,

									gchar ** video_encode_prop,

									gdouble video_fps,

									gdouble video_rate,

									guint video_width,

									guint video_height,

									const gchar * audio_encode,

									gchar ** audio_encode_prop,

									guint audio_rate);

static gboolean _tick_cb(gpointer 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[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_LAST,

				 0, NULL, NULL,

				 g_cclosure_marshal_VOID__STRING,

				 G_TYPE_NONE, 1, G_TYPE_STRING);

}

static void

g_mencoder_init(GMencoder * self)

{

  GMencoderPrivate *priv = G_MENCODER_GET_PRIVATE(self);

  priv->info = g_new0(SetupInfo, 1);

}

static void

g_mencoder_dispose(GObject * object)

{

}

static void

g_mencoder_finalize(GObject * object)

{

 //TODO: clear vars

  g_mencoder_close_stream(G_MENCODER(object));

}

GMencoder *

g_mencoder_new(void)

{

  return g_object_new(G_TYPE_MENCODER, NULL);

}

static void

_obj_set_prop(GObject * obj, const gchar * prop_name, const gchar * prop_val)

{

  GValue p = { 0 };

  GValue v = { 0 };

  GParamSpec *s = NULL;

  GObjectClass *k = G_OBJECT_GET_CLASS(obj);

  g_value_init(&v, G_TYPE_STRING);

  g_value_set_string(&v, prop_val);

  s = g_object_class_find_property(k, prop_name);

  if (s == NULL)

	{

	  g_print("Invalid property name: %s\n", prop_name);

	  return;

	}

  g_value_init(&p, s->value_type);

  switch (s->value_type)

	{

	case G_TYPE_INT:

	  g_value_set_int(&p, atoi(prop_val));

	  break;

	case G_TYPE_STRING:

	  g_value_set_string(&p, prop_val);

	  break;

	default:

	  return;

	}

  g_object_set_property(obj, prop_name, &p);

  g_value_unset(&v);

  g_value_unset(&p);

}

static GstElement *

_create_element_with_prop(const gchar * factory_name,

						  const gchar * element_name, gchar ** prop)

{

  GstElement *ret;

  int i;

  ret = gst_element_factory_make(factory_name, element_name);

  if (ret == NULL)

	return NULL;

  if (prop != NULL)

	{

	  for (i = 0; i < g_strv_length(prop); i++)

		{

		  if (prop[i] != NULL)

			{

			  char **v = g_strsplit(prop[i], "=", 2);

			  if (g_strv_length(v) == 2)

				{

				  _obj_set_prop(G_OBJECT(ret), v[0], v[1]);

				}

			  g_strfreev(v);

			}

		}

	}

  return ret;

}

static GstElement *

_create_audio_bin(const gchar * encode, gchar ** encode_prop, gint rate)

{

  GstElement *abin = NULL;

  GstElement *aqueue = NULL;

  GstElement *aconvert = NULL;

  GstElement *aencode = NULL;

  GstElement *aqueue_src = NULL;

  GstPad *apad = NULL;

 //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 =

	_create_element_with_prop((encode ? encode : "lame"), "aencode",

							  encode_prop);

  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;

	}

  g_object_set(G_OBJECT(aencode), "bitrate", 32, NULL);

 /*

    if (rate > 0) {

    g_object_set (G_OBJECT (aencode), "bitrate", 32, NULL);

    }

  */

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

				   NULL);

  if (gst_element_link_many(aqueue, aconvert, aencode, aqueue_src, NULL) ==

	  FALSE)

	{

	  g_warning("Not Link audio elements");

	}

 //TODO: apply audio rate

 // ghost pad the audio bin

  apad = gst_element_get_pad(aqueue, "sink");

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

  gst_object_unref(apad);

  apad = gst_element_get_pad(aqueue_src, "src");

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

  gst_object_unref(apad);

  return abin;

error:

  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 (apad != NULL)

	gst_object_unref(apad);

  return NULL;

}

//queue ! videoscale ! video/x-raw-yuv,width=240,height=144 ! colorspace ! rate ! encode ! queue

static GstElement *

_create_video_bin(const gchar * encode,

				  gchar ** encode_prop,

				  gdouble fps, gint rate, guint width, guint height)

{

  GstElement *vbin = NULL;

  GstElement *vqueue = NULL;

  GstElement *vqueue_src = NULL;

  GstElement *vcolorspace = NULL;

  GstElement *vencode = NULL;

  GstElement *vrate = NULL;

  GstPad *vpad = NULL;

  vbin = gst_bin_new("vbin");

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

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

  vencode = _create_element_with_prop((encode !=

									   NULL ? encode : "ffenc_mpeg1video"),

									  "vencode", encode_prop);

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

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

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

	{

	  g_warning("Video elements not found");

	  goto error;

	}

  gst_bin_add_many(GST_BIN(vbin), vqueue, vcolorspace, vencode, vqueue_src,

				   NULL);

  if ((width > 0) && (height > 0))

	{

	 //Scalling video

	  GstCaps *vcaps;

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

	  gst_bin_add(GST_BIN(vbin), vscale);

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

								  "width", G_TYPE_INT, width,

								  "height", G_TYPE_INT, height, NULL);

	  gst_element_link(vqueue, vscale);

	  if (gst_element_link_filtered(vscale, vcolorspace, vcaps) == FALSE)

		{

		  g_warning("Fail to resize video");

		  gst_object_unref(vcaps);

		  gst_object_unref(vscale);

		  goto error;

		}

	  gst_caps_unref(vcaps);

	}

  else

	{

	  gst_element_link(vqueue, vcolorspace);

	}

  if (fps > 0)

	{

	 //Changing the video fps

	  GstCaps *vcaps;

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

	  gst_bin_add(GST_BIN(vbin), vrate);

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

		{

		  g_warning("Fail to link video elements");

		  goto error;

		}

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

								  "framerate", GST_TYPE_FRACTION,

								  (int) (fps * 1000), 1000, NULL);

	  if (gst_element_link_filtered(vrate, vencode, vcaps) == FALSE)

		{

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

		  goto error;

		}

	  gst_caps_unref(vcaps);

	}

  else

	{

	  if (gst_element_link(vcolorspace, vencode) == FALSE)

		{

		  g_warning("Fail to link colorspace and video encode element.");

		  goto error;

		}

	}

  gst_element_link(vencode, vqueue_src);

 // ghost pad the video  bin

  vpad = gst_element_get_pad(vqueue, "sink");

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

  gst_object_unref(vpad);

  vpad = gst_element_get_pad(vqueue_src, "src");

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

  gst_object_unref(vpad);

  return vbin;

error:

  if (vpad != NULL)

	gst_object_unref(vpad);

  if (vbin != NULL)

	gst_object_unref(vbin);

  if (vqueue != NULL)

	gst_object_unref(vqueue);

  if (vencode != NULL)

	gst_object_unref(vencode);

  if (vqueue_src != NULL)

	gst_object_unref(vqueue_src);

  if (vcolorspace != NULL)

	gst_object_unref(vcolorspace);

  return NULL;

}

void

g_mencoder_setup_stream(GMencoder * self,

						const gchar * mux_name,

						const gchar * video_encode,

						gchar ** video_encode_prop,

						gdouble video_fps,

						gdouble video_rate,

						guint video_width,

						guint video_height,

						const gchar * audio_encode,

						gchar ** audio_encode_prop,

						guint audio_rate, const gchar * out_uri)

{

  GMencoderPrivate *priv = G_MENCODER_GET_PRIVATE(self);

  if (priv->ready == TRUE)

	{

	  g_warning("Stream already configured. You need close stream first.");

	  return;

	}

  _close_output(self);

  _open_output(self, out_uri);

  priv->sources = 0;

  priv->pipe = _create_pipeline(self,

								video_encode,

								mux_name,

								video_encode_prop,

								video_fps,

								video_rate,

								video_width,

								video_height,

								audio_encode, audio_encode_prop, audio_rate);

}

gboolean

g_mencoder_append_uri(GMencoder * self, const gchar * uri)

{

  GstPad *pad_src;

  GstPad *pad_sink;

  GstElement *src;

  GMencoderPrivate *priv = G_MENCODER_GET_PRIVATE(self);

  gboolean ret = FALSE;

  GstElement *ap = NULL;

  GstElement *vp = NULL;

  g_return_val_if_fail(priv->pipe != NULL, FALSE);

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

#ifndef SUPPORT_MULT_INPUT

  g_return_val_if_fail(priv->sources < 1, FALSE);

#endif

  src = _create_source(uri);

  if (src == NULL)

	return FALSE;

  priv->src = gst_bin_get_by_name(GST_BIN(src), "src");

  gst_bin_add(GST_BIN(priv->pipe), src);

#ifdef SUPPORT_MULT_INPUT

  ap = gst_bin_get_by_name(GST_BIN(priv->pipe), "ap");

  vp = gst_bin_get_by_name(GST_BIN(priv->pipe), "vp");

#else

  ap = gst_bin_get_by_name(GST_BIN(priv->pipe), "abin");

  vp = gst_bin_get_by_name(GST_BIN(priv->pipe), "vbin");

#endif

  if ((vp == NULL) || (ap == NULL))

	{

	  g_warning("Fail to get output bin");

	  goto error;

	}

  pad_src = gst_element_get_pad(src, "src_audio");

  pad_sink = gst_element_get_compatible_pad(ap,

											pad_src,

											gst_pad_get_caps(pad_src));

  if ((pad_sink == NULL) || (pad_src == NULL))

	goto error;

  GstPadLinkReturn lret = gst_pad_link(pad_src, pad_sink);

  if (lret != GST_PAD_LINK_OK)

	goto error;

  gst_object_unref(pad_src);

  gst_object_unref(pad_sink);

  pad_src = gst_element_get_pad(src, "src_video");

  pad_sink = gst_element_get_compatible_pad(vp,

											pad_src,

											gst_pad_get_caps(pad_src));

  if ((pad_src == NULL) || (pad_sink == NULL))

	goto error;

  if (gst_pad_link(pad_src, pad_sink) != GST_PAD_LINK_OK)

	{

	  g_warning("invalid source. video");

	  goto error;

	}

  priv->sources++;

  ret = TRUE;

error:

  if ((src != NULL) && (ret == FALSE))

	{

	  gst_bin_remove(GST_BIN(priv->pipe), src);

	  gst_object_unref(src);

	}

  if (ap != NULL)

	gst_object_unref(ap);

  if (vp != NULL)

	gst_object_unref(vp);

  if (pad_src != NULL)

	gst_object_unref(pad_src);

  if (pad_sink != NULL)

	gst_object_unref(pad_sink);

  return ret;

}

void

g_mencoder_remove_uri(GMencoder * self, const gchar * uri)

{

 // GMencoderPrivate *priv = G_MENCODER_GET_PRIVATE (self);

 //TODO: remove src

}

void

g_mencoder_play_stream(GMencoder * self)

{

  GMencoderPrivate *priv = G_MENCODER_GET_PRIVATE(self);

  g_return_if_fail(priv->ready == FALSE);

  priv->ready = TRUE;

  gst_element_set_state(priv->pipe, GST_STATE_PLAYING);

  priv->tick_id = g_timeout_add(500, _tick_cb, self);

}

void

g_mencoder_pause_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_PAUSED);

}

void

g_mencoder_close_stream(GMencoder * self)

{

  GMencoderPrivate *priv = G_MENCODER_GET_PRIVATE(self);

  if (priv->tick_id != 0)

	{

	  g_source_remove(priv->tick_id);

	  priv->tick_id = 0;

	}

  if (priv->pipe != NULL)

	{

	 //TODO: fixe pipeline dispose

	 //gst_element_set_state (priv->pipe, GST_STATE_NULL);

	 //g_debug ("SETING STATE TO NULL: OK");

	 //gst_element_set_state (priv->pipe, GST_STATE_NULL);

	 //gst_object_unref (priv->pipe);

	  gst_object_unref(priv->src);

	  priv->src = NULL;

	  priv->pipe = NULL;

	  priv->abin = NULL;

	  priv->vbin = NULL;

	  priv->sink = NULL;

	}

  priv->ready = FALSE;

}

static GstElement *

_create_pipeline(GMencoder * self,

				 const gchar * video_encode,

				 const gchar * mux_name,

				 gchar ** video_encode_prop,

				 gdouble video_fps,

				 gdouble video_rate,

				 guint video_width,

				 guint video_height,

				 const gchar * audio_encode,

				 gchar ** audio_encode_prop, guint audio_rate)

{

  GstBus *bus = NULL;

  GstElement *pipe = NULL;

  GstElement *sink = NULL;

  GstElement *mux = NULL;

  GstElement *abin = NULL;

  GstElement *vbin = NULL;

  GstElement *queue = NULL;

  GstPad *aux_pad = NULL;

  GstPad *mux_pad = NULL;

#ifdef SUPPORT_MULT_INPUT

  GstElement *ap = NULL;

  GstElement *vp = NULL;

#endif

  GMencoderPrivate *priv = G_MENCODER_GET_PRIVATE(self);

  pipe = gst_pipeline_new("pipe");

#ifdef SUPPORT_MULT_INPUT

  ap = gst_element_factory_make("concatmux", "ap");

  vp = gst_element_factory_make("concatmux", "vp");

  gst_bin_add_many(GST_BIN(pipe), ap, vp, NULL);

#endif

  mux = gst_element_factory_make((mux_name ? mux_name : "ffmux_mpeg"), "mux");

  if (mux == NULL)

	goto error;

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

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

  if (sink == NULL)

	goto error;

  g_object_set(G_OBJECT(sink), "fd", priv->fd, "sync", FALSE, NULL);

  abin = _create_audio_bin(audio_encode, audio_encode_prop, audio_rate);

  if (abin == NULL)

	goto error;

  vbin =

	_create_video_bin(video_encode, video_encode_prop, video_fps, video_rate,

					  video_width, video_height);

  if (vbin == NULL)

	goto error;

 // Finish Pipe

  gst_bin_add_many(GST_BIN(pipe), abin, vbin, mux, queue, sink, NULL);

#ifdef SUPPORT_MULT_INPUT

  if (gst_element_link(ap, abin) == FALSE)

	{

	  g_warning("Fail to link concat and abin");

	  goto error;

	}

  if (gst_element_link(vp, vbin) == FALSE)

	{

	  g_warning("Fail to link concat and vbin");

	}

#endif

 //Link bins with mux

  aux_pad = gst_element_get_pad(abin, "src");

  mux_pad =

	gst_element_get_compatible_pad(mux, aux_pad, GST_PAD_CAPS(aux_pad));

  if (mux_pad == NULL)

	{

	  g_warning("Mux element no have audio PAD");

	  goto error;

	}

  GstPadLinkReturn ret = gst_pad_link(aux_pad, mux_pad);

  if (ret != GST_PAD_LINK_OK)

	{

	  g_warning("Fail link audio and mux: %d", ret);

	  goto error;

	}

  gst_object_unref(aux_pad);

  gst_object_unref(mux_pad);

  aux_pad = gst_element_get_pad(vbin, "src");

  mux_pad =

	gst_element_get_compatible_pad(mux, aux_pad, GST_PAD_CAPS(aux_pad));

  if (mux_pad == NULL)

	{

	  g_warning("Mux element no have video PAD");

	  goto error;

	}

  ret = gst_pad_link(aux_pad, mux_pad);

  if (ret != GST_PAD_LINK_OK)

	{

	  g_warning("Fail link video and mux: %d", ret);

	  goto error;

	}

  gst_object_unref(aux_pad);

  gst_object_unref(mux_pad);

  aux_pad = NULL;

  mux_pad = NULL;

 //Link mux with sink

  gst_element_link_many(mux, queue, sink, NULL);

  bus = gst_pipeline_get_bus(GST_PIPELINE(pipe));

  gst_bus_add_watch(bus, _pipeline_bus_cb, self);

  gst_object_unref(bus);

  return pipe;

error:

  g_warning("Invalid uri");

  if (pipe != NULL)

	{

	  gst_object_unref(pipe);

	}

  if (mux != NULL)

	{

	  gst_object_unref(mux);

	}

  if (mux_pad != NULL)

	{

	  gst_object_unref(mux_pad);

	}

  if (aux_pad != NULL)

	{

	  gst_object_unref(mux_pad);

	}

  if (sink != NULL)

	{

	  gst_object_unref(sink);

	}

  if (abin != NULL)

	{

	  gst_object_unref(abin);

	}

  if (vbin != NULL)

	{

	  gst_object_unref(vbin);

	}

  return FALSE;

}

static void

_close_output(GMencoder * self)

{

}

static GstElement *

_create_source(const gchar * uri)

{

  GstElement *bsrc = NULL;

  GstElement *src = NULL;

  GstElement *queue = NULL;

  GstElement *aqueue = NULL;

  GstElement *vqueue = NULL;

  GstElement *decode = NULL;

  GstPad *src_pad = NULL;

  bsrc = gst_bin_new(NULL);

 //src = gst_element_factory_make ("gnomevfssrc", "src");

 //g_object_set (G_OBJECT (src), "location", uri, NULL);

  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;

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

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

  if (aqueue == NULL)

	goto error;

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

  if (vqueue == NULL)

	goto error;

  gst_bin_add_many(GST_BIN(bsrc), src, queue, decode, aqueue, vqueue, NULL);

  gst_element_link_many(src, queue, decode, NULL);

  g_signal_connect(G_OBJECT(decode),

				   "new-decoded-pad",

				   G_CALLBACK(_decodebin_new_pad_cb), bsrc);

  g_signal_connect(G_OBJECT(decode),

				   "unknown-type",

				   G_CALLBACK(_decodebin_unknown_type_cb), pipe);

  src_pad = gst_element_get_pad(aqueue, "src");

  gst_element_add_pad(bsrc, gst_ghost_pad_new("src_audio", src_pad));

  gst_object_unref(src_pad);

  src_pad = gst_element_get_pad(vqueue, "src");

  gst_element_add_pad(bsrc, gst_ghost_pad_new("src_video", src_pad));

  gst_object_unref(src_pad);

  return bsrc;

error:

  if (src != NULL)

	{

	  gst_object_unref(src);

	}

  if (decode != NULL)

	{

	  gst_object_unref(decode);

	}

  if (aqueue != NULL)

	{

	  gst_object_unref(aqueue);

	}

  if (vqueue != NULL)

	{

	  gst_object_unref(vqueue);

	}

  return NULL;

}

static void

_open_output(GMencoder * self, const gchar * uri)

{

  gchar **i;

  GMencoderPrivate *priv = G_MENCODER_GET_PRIVATE(self);

  i = g_strsplit(uri, "://", 0);

  if (strcmp(i[0], "fd") == 0)

	{

	  priv->fd = atoi(i[1]);

	}

  else if (strcmp(i[0], "file") == 0)

	{

	  priv->fd = open(i[1], O_WRONLY | O_CREAT | O_TRUNC,

					  S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);

	}

  else

	{

	  g_warning("Output uri not supported");

	}

  g_strfreev(i);

}

static gboolean

_pipeline_bus_cb(GstBus * bus, GstMessage * msg, gpointer user_data)

{

  GMencoderPrivate *priv = G_MENCODER_GET_PRIVATE(user_data);

  switch (GST_MESSAGE_TYPE(msg))

	{

	case GST_MESSAGE_STATE_CHANGED:

	  {

		GstState oldstate;

		GstState newstate;

		GstState pendingstate;

		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 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;

		if (priv->tick_id != 0)

		  {

			g_source_remove(priv->tick_id);

			priv->tick_id = 0;

		  }

		gst_message_parse_error(msg, &error, &debug);

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

								  error->message, debug);

		priv->ready = FALSE;

		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:

	  priv->ready = FALSE;

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

	  break;

	case GST_MESSAGE_DURATION:

	  {

		GstFormat format;

		gint64 duration;

		gst_message_parse_duration(msg, &format, &duration);

		if (format == GST_FORMAT_BYTES)

		  priv->duration = duration;

		break;

	  }

	default:

	  {