#ifdef HAVE_CONFIG_H

 #include "config.h"

 #endif

 #include <stdio.h>

 #include <glib.h>

 #include "gmyth_backendinfo.h"

 #include "gmyth_file_transfer.h"

 #include "gmyth_livetv.h"

 #include "gmyth_util.h"

 #include "gmyth_common.h"

 typedef struct {

     GMythBackendInfo *b_info;

     char           *filename;

     char           *channel;

 } cat_options_t;

 static cat_options_t *

 _cat_options_new()

 {

     cat_options_t  *options = g_new0(cat_options_t, 1);

     options->b_info = gmyth_backend_info_new();

     return options;

 }

 static void

 _cat_options_free(cat_options_t * options)

 {

     g_return_if_fail(options != NULL);

     if (options->b_info)

         g_object_unref(options->b_info);

     g_free(options->filename);

     g_free(options->channel);

 }

 static          gboolean

 _parse_args(int argc, char *argv[], cat_options_t * options)

 {

     GError         *error = NULL;

     GOptionContext *context;

     gchar          *host_ip = NULL;

     gint            host_port = 0;

     gchar          *filename = NULL;

     gchar          *channel = NULL;

     GOptionEntry    entries[] = {

         {"hostname", 'h', 0, G_OPTION_ARG_STRING, &host_ip,

          "Mythtv backend hostname or " "IP address", "IP_ADDRESS"},

         {"port", 'p', 0, G_OPTION_ARG_INT, &host_port,

          "Mythtv backend port",

          "PORT"},

         {"filename", 'f', 0, G_OPTION_ARG_STRING, &filename,

          "Recorded file name available " "in the Mythtv backend", "FILE"},

         {"channel", 'c', 0, G_OPTION_ARG_STRING, &channel,

          "Mythtv channel number", "CHANNEL"},

         {NULL}

     };

     g_return_val_if_fail(options != NULL, FALSE);

     context =

         g_option_context_new

         ("- loads a mythtv backend recorded file and prints "

          "it on the standard output\n");

     g_option_context_add_main_entries(context, entries, NULL);

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

     g_option_context_set_help_enabled(context, TRUE);

     g_option_context_free(context);

     if ((!host_ip) || (host_port == 0)) {

         g_free(host_ip);

         g_free(filename);

         g_free(channel);

         return FALSE;

     }

     gmyth_backend_info_set_hostname(options->b_info, host_ip);

     gmyth_backend_info_set_port(options->b_info, host_port);

     if (filename)

         options->filename = g_strdup(filename);

     if (channel)

         options->channel = g_strdup(channel);

     g_free(host_ip);

     g_free(filename);

     g_free(channel);

     return TRUE;

 }

 static          gboolean

 _cat_recorded_file(cat_options_t * options)

 {

     GArray         *array = NULL;

     GMythFileTransfer *transfer;

     guint64         size = 0,

         total = 0;

     g_return_val_if_fail(options != NULL, FALSE);

     g_return_val_if_fail(options->b_info != NULL, FALSE);

     g_return_val_if_fail(options->filename != NULL, FALSE);

     if (!gmyth_util_file_exists(options->b_info, options->filename)) {

         g_printerr("File %s was not found in the mythtv server\n",

                    options->filename);

         return FALSE;

     }

     transfer = gmyth_file_transfer_new(options->b_info);

     if (!gmyth_file_transfer_open(transfer, options->filename)) {

         g_printerr("File %s could not be opened\n", options->filename);

         return FALSE;

     }

     size = gmyth_file_transfer_get_filesize(transfer);

     fprintf(stderr, "Size:%" G_GUINT64_FORMAT "\n", size);

     array = g_array_new(FALSE, TRUE, sizeof(gchar));

     while (total != size) {

         GMythFileReadResult res;

         res = gmyth_file_transfer_read(transfer, (GByteArray *) array,

                                        (size - total) >

                                        64000 ? 64000 : (size - total),

                                        FALSE);

         if ((res != GMYTH_FILE_READ_OK) && (res != GMYTH_FILE_READ_EOF)) {

             g_array_free(array, TRUE);

             g_printerr("Error while reading the file: aborting!!\n");

             break;

         }

         fwrite(array->data, array->len, 1, stdout);

         fflush(stdout);

         total += array->len;

         fprintf(stderr, "%" G_GUINT64_FORMAT "\n", total);

         g_array_remove_range(array, 0, array->len);

         // usleep(300000);

     }

     gmyth_file_transfer_close(transfer);

     g_array_free(array, TRUE);

     g_object_unref(transfer);

     return TRUE;

 }

 static          gboolean

 _cat_channel(cat_options_t * options)

 {

     GMythLiveTV    *livetv = NULL;

     GMythFile      *gmyth_file = NULL;

     GArray         *array = NULL;

     gint            file_transf_ret;

     g_return_val_if_fail(options != NULL, FALSE);

     g_return_val_if_fail(options->b_info != NULL, FALSE);

     g_return_val_if_fail(options->channel != NULL, FALSE);

     livetv = gmyth_livetv_new(options->b_info);

     if (gmyth_livetv_channel_name_setup(livetv, options->channel) == FALSE) {

         g_printerr("Could not setup remote livetv");

         g_object_unref(livetv);

         return FALSE;

     }

     gmyth_file = GMYTH_FILE(gmyth_livetv_create_file_transfer(livetv));

     if (gmyth_file == NULL) {

         g_printerr("Could not open livetv recording file for transfer");

         g_object_unref(livetv);

         return FALSE;

     }

     if (!gmyth_file_transfer_open(GMYTH_FILE_TRANSFER(gmyth_file),

                                   livetv->uri != NULL ?

                                   gmyth_uri_get_path(livetv->uri) :

                                   livetv->proginfo->pathname->str)) {

         g_printerr("Couldn't open MythTV. FileTransfer is NULL!\n");

         return FALSE;

     }

     array = g_array_new(FALSE, TRUE, sizeof(gchar));

     while (((file_transf_ret = gmyth_file_transfer_read

              (GMYTH_FILE_TRANSFER(gmyth_file),

               (GByteArray *) array, 64000, TRUE)) == GMYTH_FILE_READ_OK) ||

            file_transf_ret == GMYTH_FILE_READ_NEXT_PROG_CHAIN) {

         fwrite(array->data, array->len, 1, stdout);

         fflush(stdout);

         g_array_remove_range(array, 0, array->len);

         g_main_context_iteration(g_main_context_default(), FALSE);

     }

     g_array_free(array, TRUE);

     g_object_unref(gmyth_file);

     g_object_unref(livetv);

     return TRUE;

 }

 int

 main(int argc, char *argv[])

 {

     gboolean        res = FALSE;

     cat_options_t  *options;

     g_type_init();

     if (!g_thread_supported())

         g_thread_init(NULL);

     options = _cat_options_new();

     res = _parse_args(argc, argv, options);

     if (!res) {

         g_printerr("Argument invalid. Type --help\n");

         return 1;

     }

     if (options->filename)

         res = _cat_recorded_file(options);

     else if (options->channel)

         res = _cat_channel(options);

     else

         g_printerr

             ("Argument invalid. You must specify --filename or --channel.\n"

              "Type --help for more information.\n");

     _cat_options_free(options);

     return 0;

 }