gtk/src/preview.c

   1 /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*- */
   2 /*
   3  * preview.c
   4  * Copyright (C) John Stebbins 2008 <stebbins@stebbins>
   5  *
   6  * preview.c is free software.
   7  *
   8  * You may redistribute it and/or modify it under the terms of the
   9  * GNU General Public License, as published by the Free Software
  10  * Foundation; either version 2 of the License, or (at your option)
  11  * any later version.
  12  *
  13  */
  14 #include <unistd.h>
  15 #include <glib.h>
  16 #include <glib/gstdio.h>
  17 #include <glib-object.h>
  18 #include <gtk/gtk.h>
  19 #include <gdk/gdkx.h>
  20 #include <gst/gst.h>
  21 #include <gst/interfaces/xoverlay.h>
  22 #include <gst/video/video.h>
  23 #include <gst/pbutils/missing-plugins.h>
  24 #include "settings.h"
  25 #include "callbacks.h"
  26 #include "hb-backend.h"
  27 #include "preview.h"
  28 #include "values.h"
  29 #include "hb.h"
  30
  31 #define PREVIEW_STATE_IMAGE 0
  32 #define PREVIEW_STATE_LIVE 1
  33
  34 struct preview_s
  35 {
  36         GstElement *play;
  37         gint64 len;
  38         gint64 pos;
  39         gboolean seek_lock;
  40         gboolean progress_lock;
  41         gint width;
  42         gint height;
  43         GtkWidget *view;
  44         gulong xid;
  45         GdkPixbuf *pix;
  46         gint button_width;
  47         gint button_height;
  48         gint frame;
  49         gint state;
  50         gboolean pause;
  51         gboolean encoded[10];
  52         gint encode_frame;
  53         gchar *current;
  54 };
  55
  56 static gboolean live_preview_cb(GstBus *bus, GstMessage *msg, gpointer data);
  57 static GstBusSyncReply create_window(GstBus *bus, GstMessage *msg,
  58                                 gpointer data);
  59 gboolean preview_expose_cb(GtkWidget *widget, GdkEventExpose *event,
  60                                 signal_user_data_t *ud);
  61
  62 void
  63 ghb_preview_init(signal_user_data_t *ud)
  64 {
  65         GstBus *bus;
  66         GstElement *xover;
  67
  68         ud->preview = g_malloc0(sizeof(preview_t));
  69         ud->preview->view = GHB_WIDGET(ud->builder, "preview_image");
  70         gtk_widget_realize(ud->preview->view);
  71         g_signal_connect(G_OBJECT(ud->preview->view), "expose_event",
  72                                         G_CALLBACK(preview_expose_cb), ud);
  73         ud->preview->xid = GDK_DRAWABLE_XID(ud->preview->view->window);
  74
  75         ud->preview->play = gst_element_factory_make("playbin", "play");
  76         ud->preview->pause = TRUE;
  77         //xover = gst_element_factory_make("xvimagesink", "xover");
  78         xover = gst_element_factory_make("gconfvideosink", "xover");
  79         g_object_set(G_OBJECT(ud->preview->play), "video-sink", xover, NULL);
  80         //g_object_set(G_OBJECT(xover), "force-aspect-ratio", TRUE, NULL);
  81
  82         bus = gst_pipeline_get_bus(GST_PIPELINE(ud->preview->play));
  83         gst_bus_add_watch(bus, live_preview_cb, ud);
  84         gst_bus_set_sync_handler(bus, create_window, ud->preview);
  85         gst_object_unref(bus);
  86 }
  87
  88 void
  89 ghb_preview_cleanup(signal_user_data_t *ud)
  90 {
  91         if (ud->preview->current)
  92         {
  93                 ud->preview->current = NULL;
  94                 g_free(ud->preview->current);
  95         }
  96 }
  97
  98 static GstBusSyncReply
  99 create_window(GstBus *bus, GstMessage *msg, gpointer data)
 100 {
 101         preview_t *preview = (preview_t*)data;
 102
 103         switch (GST_MESSAGE_TYPE(msg))
 104         {
 105         case GST_MESSAGE_ELEMENT:
 106         {
 107                 if (!gst_structure_has_name(msg->structure, "prepare-xwindow-id"))
 108                         return GST_BUS_PASS;
 109                 gst_x_overlay_set_xwindow_id(
 110                         GST_X_OVERLAY(GST_MESSAGE_SRC(msg)), preview->xid);
 111                 gst_message_unref(msg);
 112                 return GST_BUS_DROP;
 113         } break;
 114
 115         default:
 116         {
 117         } break;
 118         }
 119         return GST_BUS_PASS;
 120 }
 121
 122 static GList *
 123 get_stream_info_objects_for_type (GstElement *play, const gchar *typestr)
 124 {
 125         GValueArray *info_arr = NULL;
 126         GList *ret = NULL;
 127         guint ii;
 128
 129         if (play == NULL)
 130                 return NULL;
 131
 132         g_object_get(play, "stream-info-value-array", &info_arr, NULL);
 133         if (info_arr == NULL)
 134                 return NULL;
 135
 136         for (ii = 0; ii < info_arr->n_values; ++ii)
 137         {
 138                 GObject *info_obj;
 139                 GValue *val;
 140
 141                 val = g_value_array_get_nth(info_arr, ii);
 142                 info_obj = g_value_get_object(val);
 143                 if (info_obj)
 144                 {
 145                         GParamSpec *pspec;
 146                         GEnumValue *value;
 147                         gint type = -1;
 148
 149                         g_object_get(info_obj, "type", &type, NULL);
 150                         pspec = g_object_class_find_property(
 151                                                 G_OBJECT_GET_CLASS (info_obj), "type");
 152                         value = g_enum_get_value(
 153                                                 G_PARAM_SPEC_ENUM (pspec)->enum_class, type);
 154                         if (value)
 155                         {
 156                                 if (g_ascii_strcasecmp (value->value_nick, typestr) == 0 ||
 157                                         g_ascii_strcasecmp (value->value_name, typestr) == 0)
 158                                 {
 159                                         ret = g_list_prepend (ret, g_object_ref (info_obj));
 160                                 }
 161                         }
 162                 }
 163         }
 164         g_value_array_free (info_arr);
 165         return g_list_reverse (ret);
 166 }
 167
 168 static void
 169 caps_set(GstCaps *caps, preview_t *preview)
 170 {
 171         GstStructure *ss;
 172
 173         ss = gst_caps_get_structure(caps, 0);
 174         if (ss)
 175         {
 176                 gint fps_n, fps_d, width, height;
 177                 guint num, den, par_n, par_d;
 178                 guint disp_par_n, disp_par_d;
 179                 const GValue *par;
 180                 GValue disp_par = {0,};
 181                 GstElement *xover;
 182                 GObjectClass *klass;
 183                 GParamSpec *pspec;
 184
 185                 gst_structure_get_fraction(ss, "framerate", &fps_n, &fps_d);
 186                 gst_structure_get_int(ss, "width", &width);
 187                 gst_structure_get_int(ss, "height", &height);
 188                 par = gst_structure_get_value(ss, "pixel-aspect-ratio");
 189                 par_n = gst_value_get_fraction_numerator(par);
 190                 par_d = gst_value_get_fraction_denominator(par);
 191
 192                 g_value_init(&disp_par, GST_TYPE_FRACTION);
 193                 gst_value_set_fraction(&disp_par, 1, 1);
 194                 g_object_get(preview->play, "video-sink", &xover, NULL);
 195                 klass = G_OBJECT_GET_CLASS(xover);
 196                 pspec = g_object_class_find_property(klass, "pixel-aspect_ratio");
 197                 if (pspec)
 198                 {
 199                         GValue par_prop = {0,};
 200
 201                         g_value_init(&par_prop, pspec->value_type);
 202                         g_object_get_property(G_OBJECT(xover), "pixel-aspect-ratio",
 203                                                                         &par_prop);
 204                         if (!g_value_transform(&par_prop, &disp_par))
 205                         {
 206                                 g_warning("transform failed");
 207                                 gst_value_set_fraction(&disp_par, 1, 1);
 208                         }
 209                         g_value_unset(&par_prop);
 210                 }
 211                 disp_par_n = gst_value_get_fraction_numerator(&disp_par);
 212                 disp_par_d = gst_value_get_fraction_denominator(&disp_par);
 213                 g_value_unset(&disp_par);
 214                 gst_video_calculate_display_ratio(
 215                         &num, &den, width, height, par_n, par_d, disp_par_n, disp_par_d);
 216
 217                 width = gst_util_uint64_scale_int(height, num, den);
 218                 if (width != preview->width || height != preview->height)
 219                 {
 220                         gtk_widget_set_size_request(preview->view, width, height);
 221                         preview->width = width;
 222                         preview->height = height;
 223                 }
 224         }
 225 }
 226
 227 static void
 228 update_stream_info(preview_t *preview)
 229 {
 230         GList *vstreams, *ll;
 231         GstPad *vpad = NULL;
 232
 233         vstreams = get_stream_info_objects_for_type(preview->play, "video");
 234         if (vstreams)
 235         {
 236                 for (ll = vstreams; vpad == NULL && ll != NULL; ll = ll->next)
 237                 {
 238                         g_object_get(ll->data, "object", &vpad, NULL);
 239                 }
 240         }
 241         if (vpad)
 242         {
 243                 GstCaps *caps;
 244
 245                 caps = gst_pad_get_negotiated_caps(vpad);
 246                 if (caps)
 247                 {
 248                         caps_set(caps, preview);
 249                         gst_caps_unref(caps);
 250                 }
 251                 //g_signal_connect(vpad, "notify::caps", G_CALLBACK(caps_set_cb), preview);
 252                 gst_object_unref(vpad);
 253         }
 254         g_list_foreach(vstreams, (GFunc)g_object_unref, NULL);
 255         g_list_free(vstreams);
 256 }
 257
 258 static gboolean
 259 live_preview_cb(GstBus *bus, GstMessage *msg, gpointer data)
 260 {
 261         signal_user_data_t *ud = (signal_user_data_t*)data;
 262
 263         switch (GST_MESSAGE_TYPE(msg))
 264         {
 265         case GST_MESSAGE_ERROR:
 266         {
 267                 GError *err;
 268                 gchar *debug;
 269
 270                 gst_message_parse_error(msg, &err, &debug);
 271                 g_warning("Gstreamer Error: %s", err->message);
 272                 g_error_free(err);
 273                 g_free(debug);
 274         } break;
 275
 276         case GST_MESSAGE_ELEMENT:
 277         {
 278                 if (gst_is_missing_plugin_message(msg))
 279                 {
 280                         gst_element_set_state(ud->preview->play, GST_STATE_PAUSED);
 281                         gchar *message, *desc;
 282                         desc = gst_missing_plugin_message_get_description(msg);
 283                         message = g_strdup_printf(
 284                                                 "Missing GStreamer plugin\n"
 285                                                 "Audio or Video may not play as expected\n\n%s",
 286                                                 desc);
 287                         ghb_message_dialog(GTK_MESSAGE_WARNING, message, "Ok", NULL);
 288                         g_free(message);
 289                         gst_element_set_state(ud->preview->play, GST_STATE_PLAYING);
 290                 }
 291         } break;
 292
 293         case GST_MESSAGE_STATE_CHANGED:
 294         {
 295                 GstState state, pending;
 296                 gst_element_get_state(ud->preview->play, &state, &pending, 0);
 297                 if (state == GST_STATE_PAUSED || state == GST_STATE_PLAYING)
 298                 {
 299                         update_stream_info(ud->preview);
 300                 }
 301         } break;
 302
 303         case GST_MESSAGE_EOS:
 304         {
 305                 // Done
 306                 GtkImage *img;
 307
 308                 img = GTK_IMAGE(GHB_WIDGET(ud->builder, "live_preview_play_image"));
 309                 gtk_image_set_from_stock(img, "gtk-media-play", GTK_ICON_SIZE_BUTTON);
 310                 gst_element_set_state(ud->preview->play, GST_STATE_PAUSED);
 311                 ud->preview->pause = TRUE;
 312                 gst_element_seek(ud->preview->play, 1.0,
 313                         GST_FORMAT_TIME, GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_KEY_UNIT,
 314                         GST_SEEK_TYPE_SET, 0,
 315                         GST_SEEK_TYPE_NONE, GST_CLOCK_TIME_NONE);
 316         } break;
 317
 318         default:
 319         {
 320                 // Ignore
 321         }
 322         }
 323         return TRUE;
 324 }
 325
 326 void
 327 live_preview_start(signal_user_data_t *ud)
 328 {
 329         GtkImage *img;
 330         gchar *uri;
 331
 332         img = GTK_IMAGE(GHB_WIDGET(ud->builder, "live_preview_play_image"));
 333         if (!ud->preview->encoded[ud->preview->frame])
 334         {
 335                 gtk_image_set_from_stock(img, "gtk-media-play", GTK_ICON_SIZE_BUTTON);
 336                 gst_element_set_state(ud->preview->play, GST_STATE_NULL);
 337                 ud->preview->pause = TRUE;
 338                 return;
 339         }
 340
 341         uri = g_strdup_printf("file://%s", ud->preview->current);
 342         gtk_image_set_from_stock(img, "gtk-media-pause", GTK_ICON_SIZE_BUTTON);
 343         ud->preview->state = PREVIEW_STATE_LIVE;
 344         g_object_set(G_OBJECT(ud->preview->play), "uri", uri, NULL);
 345         gst_element_set_state(ud->preview->play, GST_STATE_PLAYING);
 346         ud->preview->pause = FALSE;
 347         g_free(uri);
 348 }
 349
 350 void
 351 live_preview_pause(signal_user_data_t *ud)
 352 {
 353         GtkImage *img;
 354
 355         img = GTK_IMAGE(GHB_WIDGET(ud->builder, "live_preview_play_image"));
 356         gtk_image_set_from_stock(img, "gtk-media-play", GTK_ICON_SIZE_BUTTON);
 357         gst_element_set_state(ud->preview->play, GST_STATE_PAUSED);
 358         ud->preview->pause = TRUE;
 359 }
 360
 361 void
 362 live_preview_stop(signal_user_data_t *ud)
 363 {
 364         GtkImage *img;
 365         GtkRange *progress;
 366
 367         img = GTK_IMAGE(GHB_WIDGET(ud->builder, "live_preview_play_image"));
 368         gtk_image_set_from_stock(img, "gtk-media-play", GTK_ICON_SIZE_BUTTON);
 369         gst_element_set_state(ud->preview->play, GST_STATE_NULL);
 370         ud->preview->pause = TRUE;
 371         ud->preview->state = PREVIEW_STATE_IMAGE;
 372
 373         progress = GTK_RANGE(GHB_WIDGET(ud->builder, "live_preview_progress"));
 374         gtk_range_set_value(progress, 0);
 375 }
 376
 377 void
 378 ghb_live_reset(signal_user_data_t *ud)
 379 {
 380         gboolean encoded;
 381
 382         if (!ud->preview->pause)
 383                 live_preview_stop(ud);
 384         if (ud->preview->current)
 385         {
 386                 g_free(ud->preview->current);
 387                 ud->preview->current = NULL;
 388         }
 389         encoded = ud->preview->encoded[ud->preview->frame];
 390         memset(ud->preview->encoded, 0, sizeof(gboolean) * 10);
 391         if (encoded)
 392                 ghb_set_preview_image(ud);
 393 }
 394
 395 extern void hb_get_tempory_directory(hb_handle_t *h, char path[512]);
 396
 397 void
 398 live_preview_start_cb(GtkWidget *xwidget, signal_user_data_t *ud)
 399 {
 400         gchar *tmp_dir;
 401         gchar *name;
 402         gint frame = ud->preview->frame;
 403
 404         tmp_dir = ghb_get_tmp_dir();
 405         name = g_strdup_printf("%s/live%02d", tmp_dir, ud->preview->frame);
 406         if (ud->preview->current)
 407                 g_free(ud->preview->current);
 408         ud->preview->current = name;
 409
 410         if (ud->preview->encoded[frame] &&
 411                 g_file_test(name, G_FILE_TEST_IS_REGULAR))
 412         {
 413                 if (ud->preview->pause)
 414                         live_preview_start(ud);
 415                 else
 416                         live_preview_pause(ud);
 417         }
 418         else
 419         {
 420                 GValue *js;
 421
 422                 ud->preview->encode_frame = frame;
 423                 js = ghb_value_dup(ud->settings);
 424                 ghb_settings_set_string(js, "destination", name);
 425                 ghb_settings_set_int(js, "start_frame", ud->preview->frame);
 426                 ghb_settings_set_int(js, "live_duration", 15);
 427                 ghb_add_live_job(js, 0);
 428                 ghb_start_live_encode();
 429                 ghb_value_free(js);
 430         }
 431 }
 432
 433 void
 434 ghb_live_encode_done(signal_user_data_t *ud, gboolean success)
 435 {
 436         GtkWidget *widget;
 437         GtkWidget *prog;
 438
 439         prog = GHB_WIDGET(ud->builder, "live_encode_progress");
 440         if (success &&
 441                 ud->preview->encode_frame == ud->preview->frame)
 442         {
 443                 gtk_progress_bar_set_text(GTK_PROGRESS_BAR(prog), "Done");
 444                 gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(prog), 1);
 445                 ud->preview->encoded[ud->preview->encode_frame] = TRUE;
 446                 live_preview_start(ud);
 447                 widget = GHB_WIDGET(ud->builder, "live_progress_box");
 448                 gtk_widget_hide (widget);
 449                 widget = GHB_WIDGET(ud->builder, "live_preview_progress");
 450                 gtk_widget_show (widget);
 451         }
 452         else
 453         {
 454                 gtk_progress_bar_set_text(GTK_PROGRESS_BAR(prog), "");
 455                 gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(prog), 0);
 456                 ud->preview->encoded[ud->preview->encode_frame] = FALSE;
 457         }
 458 }
 459
 460 static gboolean
 461 unlock_progress_cb(signal_user_data_t *ud)
 462 {
 463         ud->preview->progress_lock = FALSE;
 464         // This function is initiated by g_idle_add.  Must return false
 465         // so that it is not called again
 466         return FALSE;
 467 }
 468
 469 void
 470 ghb_live_preview_progress(signal_user_data_t *ud)
 471 {
 472         GstFormat fmt = GST_FORMAT_TIME;
 473         gint64 len = -1, pos = -1;
 474
 475         if (ud->preview->state != PREVIEW_STATE_LIVE || ud->preview->seek_lock)
 476                 return;
 477
 478         ud->preview->progress_lock = TRUE;
 479         if (gst_element_query_duration(ud->preview->play, &fmt, &len))
 480         {
 481                 if (len != -1 && fmt == GST_FORMAT_TIME)
 482                 {
 483                         ud->preview->len = len / GST_MSECOND;
 484                 }
 485         }
 486         if (gst_element_query_position(ud->preview->play, &fmt, &pos))
 487         {
 488                 if (pos != -1 && fmt == GST_FORMAT_TIME)
 489                 {
 490                         ud->preview->pos = pos / GST_MSECOND;
 491                 }
 492         }
 493         if (ud->preview->len > 0)
 494         {
 495                 GtkRange *progress;
 496                 gdouble percent;
 497
 498                 percent = (gdouble)ud->preview->pos * 100 / ud->preview->len;
 499                 progress = GTK_RANGE(GHB_WIDGET(ud->builder, "live_preview_progress"));
 500                 gtk_range_set_value(progress, percent);
 501         }
 502         g_idle_add((GSourceFunc)unlock_progress_cb, ud);
 503 }
 504
 505 static gboolean
 506 unlock_seek_cb(signal_user_data_t *ud)
 507 {
 508         ud->preview->seek_lock = FALSE;
 509         // This function is initiated by g_idle_add.  Must return false
 510         // so that it is not called again
 511         return FALSE;
 512 }
 513
 514 void
 515 live_preview_seek_cb(GtkWidget *widget, signal_user_data_t *ud)
 516 {
 517         gdouble dval;
 518         gint64 pos;
 519
 520         if (ud->preview->progress_lock)
 521                 return;
 522
 523         ud->preview->seek_lock = TRUE;
 524         dval = gtk_range_get_value(GTK_RANGE(widget));
 525         pos = ((ud->preview->len * dval) / 100) * GST_MSECOND;
 526         gst_element_seek(ud->preview->play, 1.0,
 527                 GST_FORMAT_TIME, GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_ACCURATE,
 528                 GST_SEEK_TYPE_SET, pos,
 529                 GST_SEEK_TYPE_NONE, GST_CLOCK_TIME_NONE);
 530         g_idle_add((GSourceFunc)unlock_seek_cb, ud);
 531 }
 532
 533 void
 534 ghb_set_preview_image(signal_user_data_t *ud)
 535 {
 536         GtkWidget *widget;
 537         gint preview_width, preview_height, target_height, width, height;
 538
 539         g_debug("set_preview_button_image ()");
 540         gint titleindex;
 541
 542         live_preview_stop(ud);
 543
 544         titleindex = ghb_settings_combo_int(ud->settings, "title");
 545         if (titleindex < 0) return;
 546         widget = GHB_WIDGET (ud->builder, "preview_frame");
 547         ud->preview->frame = ghb_widget_int(widget) - 1;
 548         if (ud->preview->encoded[ud->preview->frame])
 549         {
 550                 widget = GHB_WIDGET(ud->builder, "live_progress_box");
 551                 gtk_widget_hide (widget);
 552                 widget = GHB_WIDGET(ud->builder, "live_preview_progress");
 553                 gtk_widget_show (widget);
 554         }
 555         else
 556         {
 557                 widget = GHB_WIDGET(ud->builder, "live_preview_progress");
 558                 gtk_widget_hide (widget);
 559                 widget = GHB_WIDGET(ud->builder, "live_progress_box");
 560                 gtk_widget_show (widget);
 561                 widget = GHB_WIDGET(ud->builder, "live_encode_progress");
 562                 gtk_progress_bar_set_text(GTK_PROGRESS_BAR(widget), "");
 563                 gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(widget), 0);
 564         }
 565         if (ud->preview->pix != NULL)
 566                 g_object_unref(ud->preview->pix);
 567         ud->preview->pix = ghb_get_preview_image(titleindex, ud->preview->frame,
 568                                                                                         ud->settings, TRUE);
 569         if (ud->preview->pix == NULL) return;
 570         preview_width = gdk_pixbuf_get_width(ud->preview->pix);
 571         preview_height = gdk_pixbuf_get_height(ud->preview->pix);
 572         widget = GHB_WIDGET (ud->builder, "preview_image");
 573         if (preview_width != ud->preview->width ||
 574                 preview_height != ud->preview->height)
 575         {
 576                 gtk_widget_set_size_request(widget, preview_width, preview_height);
 577                 ud->preview->width = preview_width;
 578                 ud->preview->height = preview_height;
 579         }
 580         gdk_draw_pixbuf(
 581                 widget->window, NULL, ud->preview->pix, 0, 0, 0, 0,
 582                 -1, -1, GDK_RGB_DITHER_NONE, 0, 0);
 583
 584         gchar *text = g_strdup_printf("%d x %d", preview_width, preview_height);
 585         widget = GHB_WIDGET (ud->builder, "preview_dims");
 586         gtk_label_set_text(GTK_LABEL(widget), text);
 587         g_free(text);
 588
 589         g_debug("preview %d x %d", preview_width, preview_height);
 590         target_height = MIN(ud->preview->button_height - 12, 128);
 591         height = target_height;
 592         width = preview_width * height / preview_height;
 593
 594         if ((height >= 16) && (width >= 16))
 595         {
 596                 GdkPixbuf *scaled_preview;
 597                 scaled_preview = gdk_pixbuf_scale_simple (ud->preview->pix, width,
 598                                                                                                 height, GDK_INTERP_NEAREST);
 599                 if (scaled_preview != NULL)
 600                 {
 601                         widget = GHB_WIDGET (ud->builder, "preview_button_image");
 602                         gtk_image_set_from_pixbuf(GTK_IMAGE(widget), scaled_preview);
 603                         g_object_unref (scaled_preview);
 604                 }
 605         }
 606 }
 607
 608 static gboolean
 609 delayed_expose_cb(signal_user_data_t *ud)
 610 {
 611         GstElement *vsink;
 612         GstXOverlay *xover;
 613
 614         g_object_get(ud->preview->play, "video-sink", &vsink, NULL);
 615         if (GST_IS_BIN(vsink))
 616                 xover = GST_X_OVERLAY(gst_bin_get_by_interface(
 617                                                                 GST_BIN(vsink), GST_TYPE_X_OVERLAY));
 618         else
 619                 xover = GST_X_OVERLAY(vsink);
 620         gst_x_overlay_expose(xover);
 621         // This function is initiated by g_idle_add.  Must return false
 622         // so that it is not called again
 623         return FALSE;
 624 }
 625
 626 gboolean
 627 preview_expose_cb(
 628         GtkWidget *widget,
 629         GdkEventExpose *event,
 630         signal_user_data_t *ud)
 631 {
 632         if (ud->preview->state == PREVIEW_STATE_LIVE)
 633         {
 634                 if (GST_STATE(ud->preview->play) >= GST_STATE_PAUSED)
 635                 {
 636                         GstElement *vsink;
 637                         GstXOverlay *xover;
 638
 639                         g_object_get(ud->preview->play, "video-sink", &vsink, NULL);
 640                         if (GST_IS_BIN(vsink))
 641                                 xover = GST_X_OVERLAY(gst_bin_get_by_interface(
 642                                                                                 GST_BIN(vsink), GST_TYPE_X_OVERLAY));
 643                         else
 644                                 xover = GST_X_OVERLAY(vsink);
 645                         gst_x_overlay_expose(xover);
 646                         // For some reason, the exposed region doesn't always get
 647                         // cleaned up here. But a delayed gst_x_overlay_expose()
 648                         // takes care of it.
 649                         g_idle_add((GSourceFunc)delayed_expose_cb, ud);
 650                         return FALSE;
 651                 }
 652                 return TRUE;
 653         }
 654
 655         gdk_draw_pixbuf(
 656                 widget->window, NULL, ud->preview->pix, 0, 0, 0, 0,
 657                 -1, -1, GDK_RGB_DITHER_NONE, 0, 0);
 658         return TRUE;
 659 }
 660
 661 void
 662 preview_button_size_allocate_cb(GtkWidget *widget, GtkAllocation *allocation, signal_user_data_t *ud)
 663 {
 664         g_debug("allocate %d x %d", allocation->width, allocation->height);
 665         if (ud->preview->button_width == allocation->width &&
 666                 ud->preview->button_height == allocation->height)
 667         {
 668                 // Nothing to do. Bug out.
 669                 g_debug("nothing to do");
 670                 return;
 671         }
 672         g_debug("prev allocate %d x %d", ud->preview->button_width,
 673                         ud->preview->button_height);
 674         ud->preview->button_width = allocation->width;
 675         ud->preview->button_height = allocation->height;
 676         ghb_set_preview_image(ud);
 677 }
 678
 679 void
 680 preview_button_clicked_cb(GtkWidget *xwidget, signal_user_data_t *ud)
 681 {
 682         gint titleindex;
 683
 684         titleindex = ghb_settings_combo_int(ud->settings, "title");
 685         if (titleindex < 0) return;
 686         g_debug("titleindex %d", titleindex);
 687
 688         GtkWidget *widget = GHB_WIDGET (ud->builder, "preview_window");
 689         gtk_widget_show (widget);
 690 }
 691
 692 void
 693 preview_frame_value_changed_cb(GtkWidget *widget, signal_user_data_t *ud)
 694 {
 695         ghb_set_preview_image(ud);
 696 }
 697