#include <sys/stat.h>

 #include <fcntl.h>

 #include <unistd.h>

 #include <string.h>

 #include <gst/gst.h>

 #include <glib.h>

 static GMainLoop *mainloop = NULL;

 static gint64 d = 0;

 static gint64 gap = 10;

 typedef enum

 {

   MY_STREAM_TYPE_AUDIO = 0,

   MY_STREAM_TYPE_VIDEO = 1

 } MyStreamType;

 typedef struct _StreamData StreamData;

 struct _StreamData

 {

   GstElement *bin;

   MyStreamType type;

 };

 static void

 _stream_decode_pad_added_cb(GstElement * decode,

 							GstPad * pad, gboolean arg1, gpointer user_data)

 {

   StreamData *data = (StreamData *) user_data;

   GstElement *queue;

   GstPad *sink_pad;

   GstCaps *caps = gst_pad_get_caps(pad);

   gchar *str_caps = gst_caps_to_string(caps);

   g_debug("decode caps: [%d] [%s]", data->type, str_caps);

   switch (data->type)

 	{

 	case MY_STREAM_TYPE_AUDIO:

 	  g_debug("Audio");

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

 		goto done;

 	  break;

 	case MY_STREAM_TYPE_VIDEO:

 	  g_debug("Video");

 	  if (strstr(str_caps, "video") == NULL)

 		goto done;

 	  break;

 	}

   queue = gst_bin_get_by_name(GST_BIN(data->bin), "queue");

   sink_pad = gst_element_get_pad(queue, "sink");

   if (gst_pad_link(pad, sink_pad) != GST_PAD_LINK_OK)

 	{

 	  g_warning("Failed to link decode");

 	}

   gst_object_unref(queue);

   gst_object_unref(sink_pad);

  //g_free (data);

   g_debug("Linked");

 done:

   gst_caps_unref(caps);

   g_free(str_caps);

 }

 static GstElement *

 _create_src_element(const gchar * name,

 					const gchar * uri, MyStreamType type, guint priority)

 {

   StreamData *data;

   GstElement *bin;

   GstElement *src;

   GstElement *decode;

   GstElement *queue;

   GstPad *src_pad;

   GstElement *gnl_src;

   g_debug("element from uri: %s", uri);

   bin = gst_bin_new("bin");

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

   g_return_val_if_fail(src != NULL, NULL);

   decode = gst_element_factory_make("decodebin", NULL);

   g_return_val_if_fail(decode != NULL, NULL);

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

   g_return_val_if_fail(queue != NULL, NULL);

   gst_bin_add_many(GST_BIN(bin), src, decode, queue, NULL);

   gst_element_link(src, decode);

   data = g_new0(StreamData, 1);

   data->bin = bin;

   data->type = type;

   g_debug("Type : %d = %d", type, data->type);

   g_signal_connect(G_OBJECT(decode), "new-decoded-pad",

 				   G_CALLBACK(_stream_decode_pad_added_cb), data);

   src_pad = gst_element_get_pad(queue, "src");

   g_return_val_if_fail(src_pad != NULL, NULL);

   gst_element_add_pad(bin, gst_ghost_pad_new("src", src_pad));

   gst_object_unref(src_pad);

   gnl_src = gst_element_factory_make("gnlsource", name);

   g_return_val_if_fail(gnl_src != NULL, NULL);

   gst_bin_add(GST_BIN(gnl_src), bin);

   g_debug("ADDING WITH: START [%lli] DUR [%lli]", d, gap);

   if (d == 0)

 	{

 	  g_object_set(G_OBJECT(gnl_src),

 				  //"start", 0L,

 				   "duration", 10 * GST_SECOND,

 				  //"media-start", 0L,

 				  //"media-duration", 10 * GST_SECOND,

 				   "priority", priority, NULL);

 	}

   else

 	{

 	  g_object_set(G_OBJECT(gnl_src),

 				   "start", 10 * GST_SECOND, "duration", 10 * GST_SECOND,

 				  ///"media-start", 10 * GST_SECOND,

 				  //"media-duration", 10 * GST_SECOND,

 				   "priority", priority, NULL);

 	}

   d++;

   return gnl_src;

 }

 static void

 _composition_pad_added_cb(GstElement * composition,

 						  GstPad * pad, gpointer data)

 {

   GstPad *sink_pad = gst_element_get_pad(GST_ELEMENT(data), "sink");

   g_debug("compose pad added");

   if (gst_pad_link(pad, sink_pad) != GST_PAD_LINK_OK)

 	{

 	  g_warning("Failed to link decode");

 	}

   g_debug("Linked ok");

 }

 static void

 _compose_add_file(GstElement * compose,

 				  const gchar * e_name,

 				  const gchar * uri, MyStreamType type, guint priority)

 {

   GstElement *src;

   src = _create_src_element(e_name, uri, type, priority);

   gst_bin_add(GST_BIN(compose), src);

 }

 int

 main(int argc, char **argv)

 {

   GstElement *pipe;

   GstElement *gnl_compose_a;

   GstElement *gnl_compose_v;

   GstElement *asink;

   GstElement *vsink;

   GstElement *aqueue;

   GstElement *vqueue;

   g_type_init();

   gst_init(&argc, &argv);

   mainloop = g_main_loop_new(NULL, FALSE);

   pipe = gst_pipeline_new("test_pipeline");

   gnl_compose_a = gst_element_factory_make("gnlcomposition", "acompose");

   g_return_val_if_fail(gnl_compose_a != NULL, 1);

   gnl_compose_v = gst_element_factory_make("gnlcomposition", "vcompose");

   g_return_val_if_fail(gnl_compose_v != NULL, 1);

  //_compose_add_file (gnl_compose_a, "src0", argv[1], MY_STREAM_TYPE_AUDIO, 1);

  //_compose_add_file (gnl_compose_a, "src1", argv[2], MY_STREAM_TYPE_AUDIO, 1);

   d = 0;

   _compose_add_file(gnl_compose_v, "src2", argv[1], MY_STREAM_TYPE_VIDEO, 1);

   _compose_add_file(gnl_compose_v, "src3", argv[2], MY_STREAM_TYPE_VIDEO, 1);

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

  //asink = gst_element_factory_make ("alsasink", "asink");

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

   vsink = gst_element_factory_make("xvimagesink", "vsink");

   gst_bin_add_many(GST_BIN(pipe), gnl_compose_a, gnl_compose_v, vqueue, vsink,

 				  //aqueue, asink, 

 				   NULL);

   gst_element_link(vqueue, vsink);

  //gst_element_link (aqueue, asink);

  //g_signal_connect (G_OBJECT (gnl_compose_a), "pad-added",

  //                  G_CALLBACK (_composition_pad_added_cb), aqueue);

   g_signal_connect(G_OBJECT(gnl_compose_v), "pad-added",

 				   G_CALLBACK(_composition_pad_added_cb), vqueue);

  //g_idle_add (_play, pipe);

   gst_element_set_state(GST_ELEMENT(pipe), GST_STATE_PLAYING);

   g_main_loop_run(mainloop);

   return 0;

 }