x264_gtk_encode_main_window.c

linux下编译已经通过

    int               container;

    filters = gtk_file_chooser_list_filters(GTK_FILE_CHOOSER (encode->file_input));
    selected = gtk_file_chooser_get_filter(GTK_FILE_CHOOSER (encode->file_input));
    container = g_slist_index(filters, selected);
    g_slist_free (filters);

    if (container == 0)
    {
      /* All format needed, search for extension */
      const char *ext = strrchr(in, '.');
      if (!strncasecmp(ext, ".y4m", 4))
        encode->container = X264_DEMUXER_Y4M;
      else if (!strncasecmp(ext, ".avs", 4))
        encode->container = X264_DEMUXER_AVS;
      else if (!strncasecmp(ext, ".avi", 4))
        encode->container = X264_DEMUXER_AVI;
      else if (!strncasecmp(ext, ".cif", 4))
        encode->container = X264_DEMUXER_CIF;
      else if (!strncasecmp(ext, ".qcif", 4))
        encode->container = X264_DEMUXER_QCIF;
      else
        encode->container = X264_DEMUXER_YUV;
    }
    else
    {
      /* The all supproted type is 0 => shift of 1 */
      encode->container = (X264_Demuxer_Type)container-1;
    }

    switch (encode->container) {
    case X264_DEMUXER_YUV: /* YUV */
      break;
    case X264_DEMUXER_CIF: /* YUV CIF */
      param.i_width = 352;
      param.i_height = 288;
      break;
    case X264_DEMUXER_QCIF: /* YUV QCIF */
      /*   Default input file driver */
      param.i_width = 176;
      param.i_height = 144;
      break;
    case X264_DEMUXER_Y4M: /* YUV4MPEG */
      /*   Default input file driver */
      sensitivity = FALSE;
      p_open_infile = open_file_y4m;
      p_get_frame_total = get_frame_total_y4m;
      p_close_infile = close_file_y4m;
      break;
#ifdef AVIS_INPUT
    case X264_DEMUXER_AVI: /* AVI */
    case X264_DEMUXER_AVS: /* AVS */
      sensitivity = FALSE;
      p_open_infile = open_file_avis;
      p_get_frame_total = get_frame_total_avis;
      p_close_infile = close_file_avis;
    break;
#endif
    default: /* Unknown */
      break;
    }
    break;
  }
  default:
    break;
  }

  /* Modify dialog */
  gtk_widget_set_sensitive(encode->width, sensitivity);
  gtk_widget_set_sensitive(encode->height, sensitivity);
  gtk_widget_set_sensitive(encode->fps_num, sensitivity);
  gtk_widget_set_sensitive(encode->fps_den, sensitivity);
  gtk_widget_set_sensitive(encode->frame_count, sensitivity);

  /* Inquire input format */
  if (param.i_width < 2) param.i_width = 352;
  if (param.i_height < 2) param.i_height = 288;
  if (p_open_infile (in, &hin, &param) >= 0) {
    param.i_frame_total = p_get_frame_total(hin);
    p_close_infile (hin);
  } else {
    GtkWidget *dialog_message;

    dialog_message = gtk_message_dialog_new (GTK_WINDOW (dialog),
                                             GTK_DIALOG_DESTROY_WITH_PARENT,
                                             GTK_MESSAGE_ERROR,
                                             GTK_BUTTONS_CLOSE,
                                             strerror(errno));
    gtk_dialog_run (GTK_DIALOG (dialog_message));
    gtk_widget_destroy (dialog_message);
  }
  encode->size = _file_size(in);

  if (g_snprintf(buffer, BUFFER_LENGTH, "%i", param.i_width) > 0)
    gtk_entry_set_text (GTK_ENTRY (encode->width), buffer);
  if (g_snprintf(buffer, BUFFER_LENGTH, "%i", param.i_height) > 0)
    gtk_entry_set_text (GTK_ENTRY (encode->height), buffer);
  if (g_snprintf(buffer, BUFFER_LENGTH, "%i", param.i_fps_num) > 0)
    gtk_entry_set_text (GTK_ENTRY (encode->fps_num), buffer);
  if (g_snprintf(buffer, BUFFER_LENGTH, "%i", param.i_fps_den) > 0)
    gtk_entry_set_text (GTK_ENTRY (encode->fps_den), buffer);

  if (g_snprintf(buffer, BUFFER_LENGTH, "%i", param.i_frame_total) > 0)
    gtk_entry_set_text (GTK_ENTRY (encode->frame_count), buffer);
}
static void
_dimension_entry_cb (GtkEditable *editable,
                     gpointer     user_data)
{
  X264_Gtk_Encode *encode = (X264_Gtk_Encode *)user_data;
  char             buffer[32];
  gint             width;
  gint             height;
  gint             frame_size;

  width = (gint)(g_ascii_strtod (gtk_entry_get_text (GTK_ENTRY (encode->width)), NULL));
  height = (gint)(g_ascii_strtod (gtk_entry_get_text (GTK_ENTRY (encode->height)), NULL));
  frame_size = (3*width*height)/2;

  if (frame_size > 0 && encode->container <= X264_DEMUXER_QCIF)
  {
    snprintf(buffer, 32, "%lu", (long unsigned int)((encode->size+frame_size/2)/frame_size));
    gtk_entry_set_text (GTK_ENTRY (encode->frame_count), buffer);
  }
}

static void
_configure_window_cb (GtkButton *button __UNUSED__,
                      gpointer   user_data)
{
  GtkWidget *window;

  window = x264_gtk_window_create (GTK_WIDGET (user_data));
  x264_gtk_shutdown (window);
}

static void
_response_window_cb (GtkDialog *dialog,
                     gint       res,
                     gpointer   user_data)
{
  switch (res) {
  case GTK_RESPONSE_APPLY: {
    x264_param_t     *param;
    X264_Gtk         *x264_gtk;
    X264_Gtk_Encode  *encode;
    X264_Thread_Data *thread_data;
    GtkWidget        *win_status;
    GThread          *thread;
    const gchar      *file_input = NULL;
    const gchar      *path_output = NULL;
    const gchar      *filename_output = NULL;
    gchar            *file_output = NULL;
    gchar            *ext;
    gint              fds[2];
    gint              out_container;

    encode = (X264_Gtk_Encode *)user_data;
    file_input = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (encode->file_input));
    path_output = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (encode->path_output));
    filename_output = gtk_entry_get_text (GTK_ENTRY (encode->file_output));

    if (!file_input ||
        (file_input[0] == '\0')) {
      GtkWidget *dialog_message;

      dialog_message = gtk_message_dialog_new (GTK_WINDOW (dialog),
                                               GTK_DIALOG_DESTROY_WITH_PARENT,
                                               GTK_MESSAGE_ERROR,
                                               GTK_BUTTONS_CLOSE,
                                               _("Error: input file name is not set"));
      gtk_dialog_run (GTK_DIALOG (dialog_message));
      gtk_widget_destroy (dialog_message);
      break;
    }

    if (!filename_output ||
        (filename_output[0] == '\0')) {
      GtkWidget *dialog_message;

      dialog_message = gtk_message_dialog_new (GTK_WINDOW (dialog),
                                               GTK_DIALOG_DESTROY_WITH_PARENT,
                                               GTK_MESSAGE_ERROR,
                                               GTK_BUTTONS_CLOSE,
                                               _("Error: output file name is not set"));
      gtk_dialog_run (GTK_DIALOG (dialog_message));
      gtk_widget_destroy (dialog_message);
      break;
    }

    out_container = gtk_combo_box_get_active (GTK_COMBO_BOX (encode->combo));

    switch (out_container) {
    case 1:
      ext = ".mkv";
      break;
#ifdef MP4_OUTPUT
    case 2:
      ext = ".mp4";
      break;
#endif
    case 0:
    default:
      ext = ".264";
    }

    file_output = g_strconcat (path_output, "/", filename_output, ext, NULL);
    g_print (_("file output : %s\n"), file_output);

    {
      GIOChannel *file;

      file = g_io_channel_new_file (file_output, "r", NULL);
      if (file) {
        GtkWidget   *dialog_overwrite;
        GtkWidget   *eb;
        GtkWidget   *label;
        const gchar *label_text = NULL;
        gint         res;

        dialog_overwrite = gtk_dialog_new_with_buttons (_("Existing file"),
                                                        GTK_WINDOW (dialog),
                                                        GTK_DIALOG_DESTROY_WITH_PARENT,
                                                        GTK_STOCK_YES,
                                                        GTK_RESPONSE_ACCEPT,
                                                        GTK_STOCK_NO,
                                                        GTK_RESPONSE_REJECT,
                                                        NULL);

        eb = gtk_event_box_new ();
        gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog_overwrite)->vbox), eb);
        gtk_container_set_border_width (GTK_CONTAINER (eb), 6);
        gtk_widget_show (eb);

        label_text = g_strconcat (_("Do you want to overwrite file\n"),
                                  file_output, " ?", NULL);
        label = gtk_label_new (label_text);
        gtk_container_add (GTK_CONTAINER (eb), label);
        gtk_widget_show (label);

        res = gtk_dialog_run (GTK_DIALOG (dialog_overwrite));
        gtk_widget_destroy (dialog_overwrite);
        g_io_channel_unref (file);
        if ((res == GTK_RESPONSE_REJECT) || (res == GTK_RESPONSE_DELETE_EVENT))
          break;
      }
    }

    x264_gtk = x264_gtk_load ();
    param = x264_gtk_param_get (x264_gtk);
    x264_gtk_free (x264_gtk);

    {
      gint width;
      gint height;
      gint fps_num;
      gint fps_den;
      gint frame_count;

      width = (gint)(g_ascii_strtod (gtk_entry_get_text (GTK_ENTRY (encode->width)), NULL));
      height = (gint)(g_ascii_strtod (gtk_entry_get_text (GTK_ENTRY (encode->height)), NULL));
      fps_num = (gint)(g_ascii_strtod (gtk_entry_get_text (GTK_ENTRY (encode->fps_num)), NULL));
      fps_den = (gint)(g_ascii_strtod (gtk_entry_get_text (GTK_ENTRY (encode->fps_den)), NULL));
      frame_count = (gint)(g_ascii_strtod (gtk_entry_get_text (GTK_ENTRY (encode->frame_count)), NULL));

      if ((width <= 0) ||
          (height <= 0) ||
          (fps_num <= 0) ||
          (fps_den <= 0) ||
          (frame_count < 0))
        break;

      param->i_width = width;
      param->i_height = height;
      param->i_fps_num = fps_num;
      param->i_fps_den = fps_den;
      param->i_frame_total = frame_count;
    }

    if (pipe (fds) == -1)
      break;

    thread_data = (X264_Thread_Data *)g_malloc0 (sizeof (X264_Thread_Data));
    thread_data->param = param;
    thread_data->file_input = g_strdup (file_input);
    thread_data->file_output = g_strdup (file_output);
    thread_data->in_container = encode->container;
    thread_data->out_container = out_container;
    g_free (file_output);

    thread_data->io_read = g_io_channel_unix_new (fds[0]);
    g_io_channel_set_encoding (thread_data->io_read, NULL, NULL);
    thread_data->io_write = g_io_channel_unix_new (fds[1]);
    g_io_channel_set_encoding (thread_data->io_write, NULL, NULL);

    g_io_add_watch (thread_data->io_read, G_IO_IN,
                    (GIOFunc)_fill_status_window, thread_data);

    win_status = x264_gtk_encode_status_window (thread_data);
    gtk_window_set_transient_for (GTK_WINDOW (win_status), GTK_WINDOW (dialog));
    gtk_window_set_modal (GTK_WINDOW (win_status), TRUE);
    gtk_widget_show (win_status);
    //gtk_widget_hide(thread_data->end_button);

    thread = g_thread_create ((GThreadFunc)x264_gtk_encode_encode, thread_data, FALSE, NULL);

    break;
  }
  case GTK_RESPONSE_CLOSE:
  default:
    gtk_main_quit ();
    _encode_shutdown ((X264_Gtk_Encode *)user_data);
  }
}

static gboolean
_fill_status_window (GIOChannel  *io __UNUSED__,
                     GIOCondition condition __UNUSED__,
                     gpointer     user_data)
{
  gchar             str[128];
  X264_Thread_Data *thread_data;
  X264_Pipe_Data    pipe_data;
  GIOStatus         status;
  gsize             size;
  gint              eta;
  gdouble           progress;
  gdouble           fps;

  thread_data = (X264_Thread_Data *)user_data;
  status = g_io_channel_read_chars (thread_data->io_read,
                                    (gchar *)&pipe_data,
                                    sizeof (X264_Pipe_Data),
                                    &size, NULL);
  if (status != G_IO_STATUS_NORMAL) {
    g_print (_("Error ! %d %d %d\n"), status, (int)sizeof (X264_Pipe_Data), (int)size);
    return FALSE;
  }

  snprintf (str, 128, "%d/%d", pipe_data.frame, pipe_data.frame_total);
  gtk_entry_set_text (GTK_ENTRY (thread_data->current_video_frame),
                      str);

  snprintf (str, 128, _("%dKB"),
            pipe_data.file >> 10);
  gtk_entry_set_text (GTK_ENTRY (thread_data->video_data),
                      str);

  fps = pipe_data.elapsed > 0 ? 1000000.0 * (gdouble)pipe_data.frame / (gdouble)pipe_data.elapsed : 0.0;
  snprintf (str, 128, _("%.2fKB/s (%.2f fps)"),
            (double) pipe_data.file * 8 * thread_data->param->i_fps_num /
            ((double) thread_data->param->i_fps_den * pipe_data.frame * 1000),
            fps);
  gtk_entry_set_text (GTK_ENTRY (thread_data->video_rendering_rate),
                      str);

  snprintf (str, 128, "%lld:%02lld:%02lld",
            (pipe_data.elapsed / 1000000) / 3600,
            ((pipe_data.elapsed / 1000000) / 60) % 60,
            (pipe_data.elapsed / 1000000) % 60);
  gtk_entry_set_text (GTK_ENTRY (thread_data->time_elapsed),
                      str);

  eta = pipe_data.elapsed * (pipe_data.frame_total - pipe_data.frame) / ((int64_t)pipe_data.frame * 1000000);
  snprintf (str, 128, "%d:%02d:%02d", eta / 3600, (eta / 60) % 60, eta % 60);
  gtk_entry_set_text (GTK_ENTRY (thread_data->time_remaining),
                      str);

  progress = (gdouble)pipe_data.frame / (gdouble)pipe_data.frame_total;
  gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (thread_data->progress),
                                 progress);

  snprintf (str, 128, "%0.1f%%", 100.0 * progress);
  gtk_progress_bar_set_text (GTK_PROGRESS_BAR (thread_data->progress), str);

  return TRUE;
}