#include <sys/stat.h>

 #include <fcntl.h>

 #include <unistd.h>

 #include <string.h>

 #include <gst/gst.h>

 #include <glib.h>

 #include "gmencoder.h"

 #define FILE_OUT  1

 static GMainLoop *mainloop = NULL;

 /* Options */

 static gchar*   input_file      = NULL;

 static gchar*   video_encode    = NULL;

 static gchar*   video_opts      = NULL;

 static gdouble  video_fps       = 0.0;

 static gint     video_rate      = 0;

 static gint     video_width     = 0;

 static gint     video_height    = 0;

 static gchar*   audio_encode    = NULL;

 static gchar*   audio_opts      = NULL;

 static double   audio_rate      = 0.0;

 static gchar*   mux_name        = NULL;

 static gchar*   output_uri      = NULL;

 static gboolean

 _quit (gpointer data)

 {

     g_object_unref (data);

     g_main_loop_quit (mainloop);

     return FALSE;

 }

 static void

 _mencoder_eos_cb (GMencoder *mencoder, gpointer data)

 {

     g_print ("EOS\n");

     g_idle_add (_quit, mencoder);

 }

 static void

 _mencoder_error_cb (GMencoder *mencoder, const gchar* msg, gpointer data)

 {

     g_print ("Error: %s\n", msg);

     g_idle_add (_quit, mencoder);

 }

 static gboolean

 _io_channel_cb (GIOChannel *ch,

                 GIOCondition condition,

                 gpointer data)

 {

     GString *cmd = g_string_new ("");

     g_io_channel_read_line_string (ch, cmd, NULL, NULL);

     if (strcmp (cmd->str, "PLAY\n") == 0) {

         g_mencoder_play_stream (G_MENCODER (data));

     } else if (strcmp (cmd->str, "PAUSE\n") == 0) {

         g_mencoder_pause_stream (G_MENCODER (data));

     } else if (strcmp (cmd->str, "STOP\n") == 0) {

         g_mencoder_close_stream (G_MENCODER (data));

     } else if (strcmp (cmd->str, "QUIT\n") == 0) {

         g_mencoder_close_stream (G_MENCODER (data));

         g_main_loop_quit (mainloop);

     }

     g_string_free (cmd, TRUE);

     return TRUE;

 }

 int

 main (int argc, char** argv)

 {

     GMencoder *coder = NULL;

     GIOChannel *ch;

     gchar **vopts;

     gchar **aopts;

     gchar **files;

     gint i;

     GOptionContext *context;

     static const GOptionEntry options []  = {

         {"input-files", 'i', 0, G_OPTION_ARG_STRING, &input_file,

          "Input File", NULL},

         {"video-encode", 0, 0, G_OPTION_ARG_STRING, &video_encode,

          "GstElementName for used to video encode", NULL},

         {"video-opts", 0, 0, G_OPTION_ARG_STRING, &video_opts,

          "Properties to set on video element", NULL},

         {"video-fps", 0, 0, G_OPTION_ARG_DOUBLE, &video_fps,

          "Video FPS", NULL},

         {"video-rate", 0, 0, G_OPTION_ARG_INT, &video_rate,

          "Video rate", NULL},

         {"video-width", 0, 0, G_OPTION_ARG_INT, &video_width,

          "Video width", NULL},

         {"video-height", 0, 0, G_OPTION_ARG_INT, &video_height,

          "Video height", NULL},

         {"audio-encode", 0, 0, G_OPTION_ARG_STRING, &audio_encode,

          "GstElementName for use to audio encode", NULL},

         {"audio-opts", 0, 0, G_OPTION_ARG_STRING, &audio_opts,

          "Properties to set on audio element", NULL},

         {"audio-rate", 0, 0, G_OPTION_ARG_INT, &audio_rate,

          "Audio rate", NULL},

         {"mux-element", 0, 0, G_OPTION_ARG_STRING, &mux_name,

          "GstElementName for use to mux file", NULL},

         {"output-uri", 'o', 0, G_OPTION_ARG_STRING, &output_uri,

          "Uri to output", NULL},

         { NULL }

     };

     g_type_init ();

     g_thread_init (NULL);

     mainloop = g_main_loop_new (NULL, FALSE);

     g_set_prgname ("gmemcoder");

     context = g_option_context_new (NULL);

     g_option_context_set_help_enabled (context, TRUE);

     g_option_context_add_main_entries (context, options, NULL);

     g_option_context_add_group (context, gst_init_get_option_group ());

     g_option_context_parse (context, &argc, &argv, NULL);

     gst_init (&argc, &argv);

     if (output_uri == NULL) {

         g_print ("You need to specify output-uri.\nTry --help "

                  "for more information.\n");

         return 1;

     }

     if (input_file == NULL) {

         g_print ("You need to specify input file\nTry --help "

                  "for more information.\n");

     }

     coder = g_mencoder_new ();

     ch = g_io_channel_unix_new (0);

     aopts = g_strsplit (audio_opts, ",", 0);

     vopts = g_strsplit (video_opts, ",", 0);

     g_mencoder_setup_stream (coder, mux_name,

                              video_encode, vopts, video_fps,

                              video_rate, video_width, video_height,

                              audio_encode, aopts, audio_rate,

                              output_uri);

     files = g_strsplit (input_file, ",", 0);

     for (i=0; i < g_strv_length (files); i++) {

         if (!g_mencoder_append_uri (coder, files[i])) {

             g_debug ("Invalid uri: %s", files[i]);

         }

     }

     g_strfreev (files);

     g_strfreev (aopts);

     g_strfreev (vopts);

     g_io_add_watch (ch, G_IO_IN, _io_channel_cb, coder);

     g_signal_connect (G_OBJECT (coder),

                       "eos",

                       G_CALLBACK (_mencoder_eos_cb),

                       mainloop);

     g_signal_connect (G_OBJECT (coder),

                       "error",

                       G_CALLBACK (_mencoder_error_cb),

                       mainloop);

     g_mencoder_play_stream (coder);

     g_debug ("RUNNING..");

     g_main_loop_run (mainloop);

     g_debug ("DONE");

     g_object_unref (coder);

     return 0;

 }