x264_gtk_encode_main_window.c

linux下编译已经通过

#if defined __FreeBSD__ || defined __OpenBSD__ || defined __NetBSD__ || defined __DragonFly__
#  include <inttypes.h>
#else
#  include <stdint.h>
#endif
#include <unistd.h>
#ifdef _WIN32 /* Needed to define _O_BINARY */
#  include <fcntl.h>
#  define strncasecmp _strnicmp
#endif
#include <errno.h>
#include <string.h>
#include <sys/stat.h>  /* For stat */

#include <gtk/gtk.h>

#include "../x264.h"
#include "../config.h"
#include "x264_icon.h"
#include "x264_gtk.h"
#include "x264_gtk_i18n.h"
#include "x264_gtk_demuxers.h"
#include "x264_gtk_encode_private.h"
#include "x264_gtk_encode_encode.h"
#include "x264_gtk_encode_status_window.h"


typedef struct X264_Gtk_Encode_ X264_Gtk_Encode;

struct X264_Gtk_Encode_
{
  GtkWidget         *main_dialog;

  /* input */
  X264_Demuxer_Type  container;
  guint64            size; /* For YUV formats */
  GtkWidget         *file_input;
  GtkWidget         *width;
  GtkWidget         *height;
  GtkWidget         *fps_num;
  GtkWidget         *fps_den;
  GtkWidget         *frame_count;

  /* output */
  GtkWidget         *path_output;
  GtkWidget         *file_output;
  GtkWidget         *combo;
};


/* Callbacks */
static gboolean _delete_window_cb    (GtkWidget   *widget,
                                      GdkEvent    *event,
                                      gpointer     user_data);
static void     _configure_window_cb (GtkButton   *button,
                                      gpointer     user_data);
static void     _chooser_window_cb   (GtkDialog   *dialog,
                                      gint         res,
                                      gpointer     user_data);
static void     _response_window_cb  (GtkDialog   *dialog,
                                      gint         res,
                                      gpointer     user_data);
static void     _dimension_entry_cb  (GtkEditable *editable,
                                      gpointer     user_data);

static gboolean _fill_status_window (GIOChannel  *io,
                                     GIOCondition condition,
                                     gpointer     user_data);
/* Code */
guint64
_file_size(const char* name)
{
  struct stat buf;
  memset(&buf, 0, sizeof(struct stat));

  if (stat(name, &buf) < 0)
  {
    fprintf(stderr, _("Can't stat file\n"));
    return 0;
  }
  return buf.st_size;
}

void
x264_gtk_encode_main_window ()
{
  GtkWidget       *dialog;
  GtkWidget       *frame;
  GtkWidget       *button;
  GtkWidget       *table;
  GtkWidget       *label;
  GtkFileChooser  *chooser;
  GtkFileFilter   *filter;
  GdkPixbuf       *icon;
  X264_Gtk_Encode *encode;

  encode = (X264_Gtk_Encode *)g_malloc0 (sizeof (X264_Gtk_Encode));

  dialog = gtk_dialog_new_with_buttons (_("X264 Gtk Encoder"),
                                        NULL, 0,
                                        NULL);
  icon = gdk_pixbuf_new_from_inline (-1, x264_icon,
                                        FALSE, NULL);
  gtk_window_set_icon (GTK_WINDOW (dialog), icon);
  g_signal_connect (G_OBJECT (dialog),
                    "delete-event",
                    G_CALLBACK (_delete_window_cb),
                    encode);
  g_signal_connect (G_OBJECT (dialog),
                    "response",
                    G_CALLBACK (_response_window_cb),
                    encode);
  encode->main_dialog = dialog;

  button = gtk_button_new_with_label (_("Configure"));
  gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->action_area), button, FALSE, TRUE, 6);
  g_signal_connect (G_OBJECT (button),
                    "clicked",
                    G_CALLBACK (_configure_window_cb),
                    dialog);
  gtk_widget_show (button);

  gtk_dialog_add_buttons (GTK_DIALOG (dialog),
                          GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
                          GTK_STOCK_EXECUTE, GTK_RESPONSE_APPLY,
                          NULL);

  /* input */
  frame = gtk_frame_new (_("Input file"));
  gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), frame, FALSE, TRUE, 6);
  gtk_widget_show (frame);

  table = gtk_table_new (6, 2, TRUE);
  gtk_table_set_row_spacings (GTK_TABLE (table), 6);
  gtk_table_set_col_spacings (GTK_TABLE (table), 6);
  gtk_container_set_border_width (GTK_CONTAINER (table), 6);
  gtk_container_add (GTK_CONTAINER (frame), table);
  gtk_widget_show (table);

  label = gtk_label_new (_("Input file:"));
  gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
  gtk_table_attach_defaults (GTK_TABLE (table), label, 0, 1, 0, 1);
  gtk_widget_show (label);

  chooser = (GtkFileChooser*)
      gtk_file_chooser_dialog_new(_("Select a file"),
                                  GTK_WINDOW(dialog),
                                  GTK_FILE_CHOOSER_ACTION_OPEN,
                                  GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
                                  GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
                                  NULL);
  gtk_file_chooser_set_current_folder (chooser, g_get_home_dir ());
   /* All supported */
  filter = gtk_file_filter_new ();
  gtk_file_filter_set_name (filter, _("All supported"));
  gtk_file_filter_add_pattern (filter, "*.yuv");
  gtk_file_filter_add_pattern (filter, "*.cif");
  gtk_file_filter_add_pattern (filter, "*.qcif");
  gtk_file_filter_add_pattern (filter, "*.y4m");
#ifdef AVIS_INPUT
  gtk_file_filter_add_pattern (filter, "*.avs");
  gtk_file_filter_add_pattern (filter, "*.avi");
#endif
  gtk_file_chooser_add_filter (chooser, filter);
  /* YUV filter */
  filter = gtk_file_filter_new ();
  gtk_file_filter_set_name (filter, _("YUV sequence"));
  gtk_file_filter_add_pattern (filter, "*.yuv");
  gtk_file_chooser_add_filter (chooser, filter);

  /* CIF filter */
  filter = gtk_file_filter_new ();
  gtk_file_filter_set_name (filter, _("YUV CIF sequence"));
  gtk_file_filter_add_pattern (filter, "*.cif");
  gtk_file_chooser_add_filter (chooser, filter);

  /* QCIF filter */
  filter = gtk_file_filter_new ();
  gtk_file_filter_set_name (filter, _("YUV QCIF sequence"));
  gtk_file_filter_add_pattern (filter, "*.qcif");
  gtk_file_chooser_add_filter (chooser, filter);

  /* YUV4MPEG2 filter */
  filter = gtk_file_filter_new ();
  gtk_file_filter_set_name (filter, _("YUV4MPEG2 sequence"));
  gtk_file_filter_add_pattern (filter, "*.y4m");
  gtk_file_chooser_add_filter (chooser, filter);

#ifdef AVIS_INPUT
  /* AVI filter */
  filter = gtk_file_filter_new ();
  gtk_file_filter_set_name (filter, "AVI");
  gtk_file_filter_add_pattern (filter, "*.avi");
  gtk_file_chooser_add_filter (chooser, filter);
  /* AVS filter */
  filter = gtk_file_filter_new ();
  gtk_file_filter_set_name (filter, _("Avisynth Script"));
  gtk_file_filter_add_pattern (filter, "*.avs");
  gtk_file_chooser_add_filter (chooser, filter);
#endif
  g_signal_connect_after(G_OBJECT (chooser), "response",
                         G_CALLBACK (_chooser_window_cb),
                         encode);
  encode->file_input = gtk_file_chooser_button_new_with_dialog (GTK_WIDGET(chooser));
  gtk_table_attach_defaults (GTK_TABLE (table), encode->file_input, 1, 2, 0, 1);
  gtk_widget_show (encode->file_input);

  label = gtk_label_new (_("Width:"));
  gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
  gtk_table_attach_defaults (GTK_TABLE (table), label, 0, 1, 1, 2);
  gtk_widget_show (label);

  encode->width = gtk_entry_new_with_max_length (255);
  gtk_entry_set_text (GTK_ENTRY (encode->width), "352");
  g_signal_connect_after(G_OBJECT (encode->width), "changed",
                   G_CALLBACK (_dimension_entry_cb),
                   encode);
  gtk_table_attach_defaults (GTK_TABLE (table), encode->width, 1, 2, 1, 2);
  gtk_widget_show (encode->width);

  label = gtk_label_new (_("Height:"));
  gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
  gtk_table_attach_defaults (GTK_TABLE (table), label, 0, 1, 2, 3);
  gtk_widget_show (label);

  encode->height = gtk_entry_new_with_max_length (255);
  gtk_entry_set_text (GTK_ENTRY (encode->height), "288");
  gtk_table_attach_defaults (GTK_TABLE (table), encode->height, 1, 2, 2, 3);
  g_signal_connect_after(G_OBJECT (encode->height), "changed",
                   G_CALLBACK (_dimension_entry_cb),
                   encode);
  gtk_widget_show (encode->height);

  label = gtk_label_new (_("Frame rate num:"));
  gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
  gtk_table_attach_defaults (GTK_TABLE (table), label, 0, 1, 3, 4);
  gtk_widget_show (label);

  encode->fps_num = gtk_entry_new_with_max_length (255);
  gtk_entry_set_text (GTK_ENTRY (encode->fps_num), "25");
  gtk_table_attach_defaults (GTK_TABLE (table), encode->fps_num, 1, 2, 3, 4);
  gtk_widget_show (encode->fps_num);

  label = gtk_label_new (_("Frame rate den:"));
  gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
  gtk_table_attach_defaults (GTK_TABLE (table), label, 0, 1, 4, 5);
  gtk_widget_show (label);

  encode->fps_den = gtk_entry_new_with_max_length (255);
  gtk_entry_set_text (GTK_ENTRY (encode->fps_den), "1");
  gtk_table_attach_defaults (GTK_TABLE (table), encode->fps_den, 1, 2, 4, 5);
  gtk_widget_show (encode->fps_den);

  label = gtk_label_new (_("Frame count:"));
  gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
  gtk_table_attach_defaults (GTK_TABLE (table), label, 0, 1, 5, 6);
  gtk_widget_show (label);

  encode->frame_count = gtk_entry_new_with_max_length (255);
  gtk_entry_set_text (GTK_ENTRY (encode->frame_count), "0");
  gtk_table_attach_defaults (GTK_TABLE (table), encode->frame_count, 1, 2, 5, 6);
  gtk_widget_show (encode->frame_count);

  /* output */
  frame = gtk_frame_new (_("Output file"));
  gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), frame, FALSE, TRUE, 6);
  gtk_widget_show (frame);

  table = gtk_table_new (3, 2, TRUE);
  gtk_table_set_row_spacings (GTK_TABLE (table), 6);
  gtk_table_set_col_spacings (GTK_TABLE (table), 6);
  gtk_container_set_border_width (GTK_CONTAINER (table), 6);
  gtk_container_add (GTK_CONTAINER (frame), table);
  gtk_widget_show (table);

  label = gtk_label_new (_("Output path:"));
  gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
  gtk_table_attach_defaults (GTK_TABLE (table), label, 0, 1, 0, 1);
  gtk_widget_show (label);

  encode->path_output = gtk_file_chooser_button_new (_("Select a path"),
                                                     GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER);
  gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (encode->path_output),
                                       g_get_home_dir ());
  gtk_table_attach_defaults (GTK_TABLE (table), encode->path_output, 1, 2, 0, 1);
  gtk_widget_show (encode->path_output);

  label = gtk_label_new (_("Output file (without ext.):"));
  gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
  gtk_table_attach_defaults (GTK_TABLE (table), label, 0, 1, 1, 2);
  gtk_widget_show (label);

  encode->file_output = gtk_entry_new_with_max_length (4095);
  gtk_table_attach_defaults (GTK_TABLE (table), encode->file_output, 1, 2, 1, 2);
  gtk_widget_show (encode->file_output);

  label = gtk_label_new (_("Container:"));
  gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
  gtk_table_attach_defaults (GTK_TABLE (table), label, 0, 1, 2, 3);
  gtk_widget_show (label);

  encode->combo = gtk_combo_box_new_text ();
  gtk_combo_box_append_text (GTK_COMBO_BOX (encode->combo),
                             "Raw ES");
  gtk_combo_box_append_text (GTK_COMBO_BOX (encode->combo),
                             "Matroska");
#ifdef MP4_OUTPUT
  gtk_combo_box_append_text (GTK_COMBO_BOX (encode->combo),
                             "Mp4");
#endif
  gtk_table_attach_defaults (GTK_TABLE (table), encode->combo, 1, 2, 2, 3);
  gtk_widget_show (encode->combo);

  gtk_combo_box_set_active (GTK_COMBO_BOX (encode->combo), 0);

  gtk_widget_show (dialog);
}

/* Callbacks */

static void
_encode_shutdown (X264_Gtk_Encode *encode)
{
  if (!encode) return;

  g_free (encode);
  encode = NULL;
}

static gboolean
_delete_window_cb (GtkWidget *widget __UNUSED__,
                   GdkEvent  *event __UNUSED__,
                   gpointer   user_data)
{
  gtk_main_quit ();
  _encode_shutdown ((X264_Gtk_Encode *)user_data);

  return TRUE;
}

static void
_chooser_window_cb (GtkDialog *dialog,
                    gint       res,
                    gpointer   user_data)
{
  X264_Gtk_Encode *encode;
  gboolean         sensitivity = TRUE;
  x264_param_t     param;
  hnd_t            hin;
  char            *in;
#define       BUFFER_LENGTH  64
  gchar            buffer[BUFFER_LENGTH];

  /* input interface */
  int              (*p_open_infile)( char *psz_filename, hnd_t *p_handle, x264_param_t *p_param );
  int              (*p_get_frame_total)( hnd_t handle );
  int              (*p_close_infile)( hnd_t handle );

  encode = (X264_Gtk_Encode *)user_data;
  in = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (encode->file_input));
  if (!in) return;

  /* Set defaults */
  p_open_infile = open_file_yuv;
  p_get_frame_total = get_frame_total_yuv;
  p_close_infile = close_file_yuv;
  param.i_width = (gint)(g_ascii_strtod (gtk_entry_get_text (GTK_ENTRY (encode->width)), NULL));
  param.i_height = (gint)(g_ascii_strtod (gtk_entry_get_text (GTK_ENTRY (encode->height)), NULL));
  param.i_fps_num = 25;
  param.i_fps_den = 1;
  param.i_frame_total = 0;

  switch (res) {
  case GTK_RESPONSE_OK:
  case GTK_RESPONSE_ACCEPT:
  case GTK_RESPONSE_APPLY: {
    X264_Gtk_Encode  *encode = (X264_Gtk_Encode *)user_data;
    GSList           *filters;
    GtkFileFilter    *selected;