gst/vaapi/gstvaapisink.c

   1 /*
   2  *  gstvaapisink.c - VA-API video sink
   3  *
   4  *  gstreamer-vaapi (C) 2010-2011 Splitted-Desktop Systems
   5  *
   6  *  This library is free software; you can redistribute it and/or
   7  *  modify it under the terms of the GNU Lesser General Public License
   8  *  as published by the Free Software Foundation; either version 2.1
   9  *  of the License, or (at your option) any later version.
  10  *
  11  *  This library is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  *  Lesser General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU Lesser General Public
  17  *  License along with this library; if not, write to the Free
  18  *  Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  19  *  Boston, MA 02110-1301 USA
  20  */
  21
  22 /**
  23  * SECTION:gstvaapisink
  24  * @short_description: A VA-API based videosink
  25  *
  26  * vaapisink renders video frames to a drawable (X #Window) on a local
  27  * display using the Video Acceleration (VA) API. The element will
  28  * create its own internal window and render into it.
  29  */
  30
  31 #include "config.h"
  32 #include <gst/gst.h>
  33 #include <gst/video/video.h>
  34 #include <gst/gstutils_version.h>
  35 #include <gst/vaapi/gstvaapivideobuffer.h>
  36 #include <gst/vaapi/gstvaapivideosink.h>
  37 #include <gst/vaapi/gstvaapidisplay_x11.h>
  38 #include <gst/vaapi/gstvaapiwindow_x11.h>
  39 #if USE_VAAPISINK_GLX
  40 #include <gst/vaapi/gstvaapidisplay_glx.h>
  41 #include <gst/vaapi/gstvaapiwindow_glx.h>
  42 #endif
  43 #include "gstvaapisink.h"
  44
  45 /* Supported interfaces */
  46 #include <gst/interfaces/xoverlay.h>
  47
  48 #define HAVE_GST_XOVERLAY_SET_WINDOW_HANDLE \
  49     GST_PLUGINS_BASE_CHECK_VERSION(0,10,31)
  50
  51 #define GST_PLUGIN_NAME "vaapisink"
  52 #define GST_PLUGIN_DESC "A VA-API based videosink"
  53
  54 GST_DEBUG_CATEGORY_STATIC(gst_debug_vaapisink);
  55 #define GST_CAT_DEFAULT gst_debug_vaapisink
  56
  57 /* ElementFactory information */
  58 static const GstElementDetails gst_vaapisink_details =
  59     GST_ELEMENT_DETAILS(
  60         "VA-API sink",
  61         "Sink/Video",
  62         GST_PLUGIN_DESC,
  63         "Gwenole Beauchesne <gwenole.beauchesne@intel.com>");
  64
  65 /* Default template */
  66 static GstStaticPadTemplate gst_vaapisink_sink_factory =
  67     GST_STATIC_PAD_TEMPLATE(
  68         "sink",
  69         GST_PAD_SINK,
  70         GST_PAD_ALWAYS,
  71         GST_STATIC_CAPS(GST_VAAPI_SURFACE_CAPS));
  72
  73 static void gst_vaapisink_iface_init(GType type);
  74
  75 GST_BOILERPLATE_FULL(
  76     GstVaapiSink,
  77     gst_vaapisink,
  78     GstVideoSink,
  79     GST_TYPE_VIDEO_SINK,
  80     gst_vaapisink_iface_init);
  81
  82 enum {
  83     PROP_0,
  84
  85     PROP_USE_GLX,
  86     PROP_DISPLAY,
  87     PROP_FULLSCREEN,
  88     PROP_SYNCHRONOUS,
  89     PROP_USE_REFLECTION
  90 };
  91
  92 /* GstImplementsInterface interface */
  93
  94 static gboolean
  95 gst_vaapisink_implements_interface_supported(
  96     GstImplementsInterface *iface,
  97     GType                   type
  98 )
  99 {
 100     return (type == GST_VAAPI_TYPE_VIDEO_SINK ||
 101             type == GST_TYPE_X_OVERLAY);
 102 }
 103
 104 static void
 105 gst_vaapisink_implements_iface_init(GstImplementsInterfaceClass *iface)
 106 {
 107     iface->supported = gst_vaapisink_implements_interface_supported;
 108 }
 109
 110 /* GstVaapiVideoSink interface */
 111
 112 static GstVaapiDisplay *
 113 gst_vaapisink_get_display(GstVaapiSink *sink);
 114
 115 static GstVaapiDisplay *
 116 gst_vaapi_video_sink_do_get_display(GstVaapiVideoSink *sink)
 117 {
 118     return gst_vaapisink_get_display(GST_VAAPISINK(sink));
 119 }
 120
 121 static void
 122 gst_vaapi_video_sink_iface_init(GstVaapiVideoSinkInterface *iface)
 123 {
 124     iface->get_display = gst_vaapi_video_sink_do_get_display;
 125 }
 126
 127 /* GstXOverlay interface */
 128
 129 static gboolean
 130 gst_vaapisink_ensure_window_xid(GstVaapiSink *sink, guintptr window_id);
 131
 132 static GstFlowReturn
 133 gst_vaapisink_show_frame(GstBaseSink *base_sink, GstBuffer *buffer);
 134
 135 static inline void
 136 _gst_vaapisink_xoverlay_set_xid(GstXOverlay *overlay, guintptr window_id)
 137 {
 138     GstVaapiSink * const sink = GST_VAAPISINK(overlay);
 139
 140     /* Disable GLX rendering when vaapisink is using a foreign X
 141        window. It's pretty much useless */
 142     sink->use_glx = FALSE;
 143
 144     sink->foreign_window = TRUE;
 145     gst_vaapisink_ensure_window_xid(sink, window_id);
 146 }
 147
 148 #if HAVE_GST_XOVERLAY_SET_WINDOW_HANDLE
 149 static void
 150 gst_vaapisink_xoverlay_set_window_handle(GstXOverlay *overlay, guintptr window_id)
 151 {
 152     _gst_vaapisink_xoverlay_set_xid(overlay, window_id);
 153 }
 154 #else
 155 static void
 156 gst_vaapisink_xoverlay_set_xid(GstXOverlay *overlay, XID xid)
 157 {
 158     _gst_vaapisink_xoverlay_set_xid(overlay, xid);
 159 }
 160 #endif
 161
 162 static void
 163 gst_vaapisink_xoverlay_expose(GstXOverlay *overlay)
 164 {
 165     GstBaseSink * const base_sink = GST_BASE_SINK(overlay);
 166     GstBuffer *buffer;
 167
 168     buffer = gst_base_sink_get_last_buffer(base_sink);
 169     if (buffer) {
 170         gst_vaapisink_show_frame(base_sink, buffer);
 171         gst_buffer_unref(buffer);
 172     }
 173 }
 174
 175 static void
 176 gst_vaapisink_xoverlay_iface_init(GstXOverlayClass *iface)
 177 {
 178 #if HAVE_GST_XOVERLAY_SET_WINDOW_HANDLE
 179     iface->set_window_handle = gst_vaapisink_xoverlay_set_window_handle;
 180 #else
 181     iface->set_xwindow_id    = gst_vaapisink_xoverlay_set_xid;
 182 #endif
 183     iface->expose            = gst_vaapisink_xoverlay_expose;
 184 }
 185
 186 static void
 187 gst_vaapisink_iface_init(GType type)
 188 {
 189     const GType g_define_type_id = type;
 190
 191     G_IMPLEMENT_INTERFACE(GST_TYPE_IMPLEMENTS_INTERFACE,
 192                           gst_vaapisink_implements_iface_init);
 193     G_IMPLEMENT_INTERFACE(GST_VAAPI_TYPE_VIDEO_SINK,
 194                           gst_vaapi_video_sink_iface_init);
 195     G_IMPLEMENT_INTERFACE(GST_TYPE_X_OVERLAY,
 196                           gst_vaapisink_xoverlay_iface_init);
 197 }
 198
 199 static void
 200 gst_vaapisink_destroy(GstVaapiSink *sink)
 201 {
 202     if (sink->display) {
 203         g_object_unref(sink->display);
 204         sink->display = NULL;
 205     }
 206
 207     if (sink->display_name) {
 208         g_free(sink->display_name);
 209         sink->display_name = NULL;
 210     }
 211 }
 212
 213 /* Checks whether a ConfigureNotify event is in the queue */
 214 typedef struct _ConfigureNotifyEventPendingArgs ConfigureNotifyEventPendingArgs;
 215 struct _ConfigureNotifyEventPendingArgs {
 216     Window      window;
 217     guint       width;
 218     guint       height;
 219     gboolean    match;
 220 };
 221
 222 static Bool
 223 configure_notify_event_pending_cb(Display *dpy, XEvent *xev, XPointer arg)
 224 {
 225     ConfigureNotifyEventPendingArgs * const args =
 226         (ConfigureNotifyEventPendingArgs *)arg;
 227
 228     if (xev->type == ConfigureNotify &&
 229         xev->xconfigure.window == args->window &&
 230         xev->xconfigure.width  == args->width  &&
 231         xev->xconfigure.height == args->height)
 232         args->match = TRUE;
 233
 234     /* XXX: this is a hack to traverse the whole queue because we
 235        can't use XPeekIfEvent() since it could block */
 236     return False;
 237 }
 238
 239 static gboolean
 240 configure_notify_event_pending(
 241     GstVaapiSink *sink,
 242     Window        window,
 243     guint         width,
 244     guint         height
 245 )
 246 {
 247     ConfigureNotifyEventPendingArgs args;
 248     XEvent xev;
 249
 250     args.window = window;
 251     args.width  = width;
 252     args.height = height;
 253     args.match  = FALSE;
 254
 255     /* XXX: don't use XPeekIfEvent() because it might block */
 256     XCheckIfEvent(
 257         gst_vaapi_display_x11_get_display(GST_VAAPI_DISPLAY_X11(sink->display)),
 258         &xev,
 259         configure_notify_event_pending_cb, (XPointer)&args
 260     );
 261     return args.match;
 262 }
 263
 264 static inline gboolean
 265 gst_vaapisink_ensure_display(GstVaapiSink *sink)
 266 {
 267     if (!sink->display) {
 268 #if USE_VAAPISINK_GLX
 269         if (sink->use_glx)
 270             sink->display = gst_vaapi_display_glx_new(sink->display_name);
 271         else
 272 #endif
 273             sink->display = gst_vaapi_display_x11_new(sink->display_name);
 274         if (!sink->display || !gst_vaapi_display_get_display(sink->display))
 275             return FALSE;
 276         g_object_set(sink, "synchronous", sink->synchronous, NULL);
 277     }
 278     return sink->display != NULL;
 279 }
 280
 281 static gboolean
 282 gst_vaapisink_ensure_render_rect(GstVaapiSink *sink, guint width, guint height)
 283 {
 284     GstVaapiRectangle * const display_rect = &sink->display_rect;
 285     guint num, den, display_par_n, display_par_d;
 286     double display_ratio;
 287     gboolean success;
 288
 289     GST_DEBUG("ensure render rect within %ux%u bounds", width, height);
 290
 291     gst_vaapi_display_get_pixel_aspect_ratio(
 292         sink->display,
 293         &display_par_n, &display_par_d
 294     );
 295     GST_DEBUG("display pixel-aspect-ratio %d/%d",
 296               display_par_n, display_par_d);
 297
 298     success = gst_video_calculate_display_ratio(
 299         &num, &den,
 300         sink->video_width, sink->video_height,
 301         sink->video_par_n, sink->video_par_d,
 302         display_par_n, display_par_d
 303     );
 304     if (!success)
 305         return FALSE;
 306     GST_DEBUG("video size %dx%d, calculated ratio %d/%d",
 307               sink->video_width, sink->video_height, num, den);
 308
 309     if ((sink->video_height % den) == 0) {
 310         GST_DEBUG("keeping video height");
 311         display_rect->width  =
 312             gst_util_uint64_scale_int(sink->video_height, num, den);
 313         display_rect->height = sink->video_height;
 314     }
 315     else if ((sink->video_width % num) == 0) {
 316         GST_DEBUG("keeping video width");
 317         display_rect->width  = sink->video_width;
 318         display_rect->height =
 319             gst_util_uint64_scale_int(sink->video_width, den, num);
 320     }
 321     else {
 322         GST_DEBUG("approximating while keeping video height");
 323         display_rect->width  =
 324             gst_util_uint64_scale_int(sink->video_height, num, den);
 325         display_rect->height = sink->video_height;
 326     }
 327     display_ratio = (gdouble)display_rect->width / display_rect->height;
 328     GST_DEBUG("scaling to %ux%u", display_rect->width, display_rect->height);
 329
 330     if (sink->fullscreen || sink->foreign_window ||
 331         display_rect->width > width || display_rect->height > height) {
 332         if (sink->video_width > sink->video_height) {
 333             display_rect->width  = width;
 334             display_rect->height = width / display_ratio;
 335         }
 336         else {
 337             display_rect->width  = height * display_ratio;
 338             display_rect->height = height;
 339         }
 340     }
 341
 342     if (sink->fullscreen) {
 343         display_rect->x  = (width  - display_rect->width)  / 2;
 344         display_rect->y  = (height - display_rect->height) / 2;
 345     }
 346     else {
 347         display_rect->x  = 0;
 348         display_rect->y  = 0;
 349     }
 350
 351     GST_DEBUG("render rect (%d,%d):%ux%u",
 352               display_rect->x, display_rect->y,
 353               display_rect->width, display_rect->height);
 354     return TRUE;
 355 }
 356
 357 static inline gboolean
 358 gst_vaapisink_ensure_window(GstVaapiSink *sink, guint width, guint height)
 359 {
 360     GstVaapiDisplay * const display = sink->display;
 361
 362     if (!sink->window) {
 363 #if USE_VAAPISINK_GLX
 364         if (sink->use_glx)
 365             sink->window = gst_vaapi_window_glx_new(display, width, height);
 366         else
 367 #endif
 368             sink->window = gst_vaapi_window_x11_new(display, width, height);
 369         if (sink->window)
 370             gst_x_overlay_got_xwindow_id(
 371                 GST_X_OVERLAY(sink),
 372                 gst_vaapi_window_x11_get_xid(GST_VAAPI_WINDOW_X11(sink->window))
 373             );
 374     }
 375     return sink->window != NULL;
 376 }
 377
 378 static gboolean
 379 gst_vaapisink_ensure_window_xid(GstVaapiSink *sink, guintptr window_id)
 380 {
 381     Window rootwin;
 382     unsigned int width, height, border_width, depth;
 383     int x, y;
 384     XID xid = window_id;
 385
 386     if (!gst_vaapisink_ensure_display(sink))
 387         return FALSE;
 388
 389     gst_vaapi_display_lock(sink->display);
 390     XGetGeometry(
 391         gst_vaapi_display_x11_get_display(GST_VAAPI_DISPLAY_X11(sink->display)),
 392         xid,
 393         &rootwin,
 394         &x, &y, &width, &height, &border_width, &depth
 395     );
 396     gst_vaapi_display_unlock(sink->display);
 397
 398     if ((width != sink->window_width || height != sink->window_height) &&
 399         !configure_notify_event_pending(sink, xid, width, height)) {
 400         if (!gst_vaapisink_ensure_render_rect(sink, width, height))
 401             return FALSE;
 402         sink->window_width  = width;
 403         sink->window_height = height;
 404     }
 405
 406     if (sink->window &&
 407         gst_vaapi_window_x11_get_xid(GST_VAAPI_WINDOW_X11(sink->window)) == xid)
 408         return TRUE;
 409
 410     if (sink->window) {
 411         g_object_unref(sink->window);
 412         sink->window = NULL;
 413     }
 414
 415 #if USE_VAAPISINK_GLX
 416     if (sink->use_glx)
 417         sink->window = gst_vaapi_window_glx_new_with_xid(sink->display, xid);
 418     else
 419 #endif
 420         sink->window = gst_vaapi_window_x11_new_with_xid(sink->display, xid);
 421     return sink->window != NULL;
 422 }
 423
 424 static gboolean
 425 gst_vaapisink_start(GstBaseSink *base_sink)
 426 {
 427     GstVaapiSink * const sink = GST_VAAPISINK(base_sink);
 428
 429     if (!gst_vaapisink_ensure_display(sink))
 430         return FALSE;
 431     return TRUE;
 432 }
 433
 434 static gboolean
 435 gst_vaapisink_stop(GstBaseSink *base_sink)
 436 {
 437     GstVaapiSink * const sink = GST_VAAPISINK(base_sink);
 438
 439     if (sink->window) {
 440         g_object_unref(sink->window);
 441         sink->window = NULL;
 442     }
 443
 444     if (sink->display) {
 445         g_object_unref(sink->display);
 446         sink->display = NULL;
 447     }
 448     return TRUE;
 449 }
 450
 451 static gboolean
 452 gst_vaapisink_set_caps(GstBaseSink *base_sink, GstCaps *caps)
 453 {
 454     GstVaapiSink * const sink = GST_VAAPISINK(base_sink);
 455     GstStructure * const structure = gst_caps_get_structure(caps, 0);
 456     guint display_width, display_height, win_width, win_height;
 457     gint video_width, video_height, video_par_n = 1, video_par_d = 1;
 458
 459     if (!structure)
 460         return FALSE;
 461     if (!gst_structure_get_int(structure, "width",  &video_width))
 462         return FALSE;
 463     if (!gst_structure_get_int(structure, "height", &video_height))
 464         return FALSE;
 465     sink->video_width  = video_width;
 466     sink->video_height = video_height;
 467
 468     gst_video_parse_caps_pixel_aspect_ratio(caps, &video_par_n, &video_par_d);
 469     sink->video_par_n  = video_par_n;
 470     sink->video_par_d  = video_par_d;
 471     GST_DEBUG("video pixel-aspect-ratio %d/%d", video_par_n, video_par_d);
 472
 473     gst_vaapi_display_get_size(sink->display, &display_width, &display_height);
 474     if (!gst_vaapisink_ensure_render_rect(sink, display_width, display_height))
 475         return FALSE;
 476
 477     if (sink->fullscreen) {
 478         win_width  = display_width;
 479         win_height = display_height;
 480     }
 481     else {
 482         win_width  = sink->display_rect.width;
 483         win_height = sink->display_rect.height;
 484     }
 485
 486     if (sink->window)
 487         gst_vaapi_window_set_size(sink->window, win_width, win_height);
 488     else {
 489         gst_vaapi_display_lock(sink->display);
 490         gst_x_overlay_prepare_xwindow_id(GST_X_OVERLAY(sink));
 491         gst_vaapi_display_unlock(sink->display);
 492         if (sink->window)
 493             return TRUE;
 494         if (!gst_vaapisink_ensure_window(sink, win_width, win_height))
 495             return FALSE;
 496         gst_vaapi_window_set_fullscreen(sink->window, sink->fullscreen);
 497         gst_vaapi_window_show(sink->window);
 498     }
 499     sink->window_width  = win_width;
 500     sink->window_height = win_height;
 501     return TRUE;
 502 }
 503
 504 static GstFlowReturn
 505 gst_vaapisink_buffer_alloc(
 506     GstBaseSink *base_sink,
 507     guint64      offset,
 508     guint        size,
 509     GstCaps     *caps,
 510     GstBuffer  **pout_buffer
 511 )
 512 {
 513     GstVaapiSink * const sink = GST_VAAPISINK(base_sink);
 514     GstStructure *structure;
 515     GstBuffer *buffer;
 516
 517     structure = gst_caps_get_structure(caps, 0);
 518     if (!gst_structure_has_name(structure, "video/x-vaapi-surface"))
 519         goto error_invalid_caps;
 520
 521     buffer = gst_vaapi_video_buffer_new(sink->display);
 522     if (!buffer)
 523         goto error_create_buffer;
 524
 525     gst_buffer_set_caps(buffer, caps);
 526     *pout_buffer = buffer;
 527     return GST_FLOW_OK;
 528
 529     /* ERRORS */
 530 error_invalid_caps:
 531     {
 532         GST_DEBUG("failed to validate input caps");
 533         return GST_FLOW_UNEXPECTED;
 534     }
 535 error_create_buffer:
 536     {
 537         GST_DEBUG("failed to create video buffer");
 538         return GST_FLOW_UNEXPECTED;
 539     }
 540 }
 541
 542 #if USE_VAAPISINK_GLX
 543 static void
 544 render_background(GstVaapiSink *sink)
 545 {
 546     /* Original code from Mirco Muller (MacSlow):
 547        <http://cgit.freedesktop.org/~macslow/gl-gst-player/> */
 548     GLfloat fStartX = 0.0f;
 549     GLfloat fStartY = 0.0f;
 550     GLfloat fWidth  = (GLfloat)sink->window_width;
 551     GLfloat fHeight = (GLfloat)sink->window_height;
 552
 553     glClear(GL_COLOR_BUFFER_BIT);
 554     glBegin(GL_QUADS);
 555     {
 556         /* top third, darker grey to white */
 557         glColor3f(0.85f, 0.85f, 0.85f);
 558         glVertex3f(fStartX, fStartY, 0.0f);
 559         glColor3f(0.85f, 0.85f, 0.85f);
 560         glVertex3f(fStartX + fWidth, fStartY, 0.0f);
 561         glColor3f(1.0f, 1.0f, 1.0f);
 562         glVertex3f(fStartX + fWidth, fStartY + fHeight / 3.0f, 0.0f);
 563         glColor3f(1.0f, 1.0f, 1.0f);
 564         glVertex3f(fStartX, fStartY + fHeight / 3.0f, 0.0f);
 565
 566         /* middle third, just plain white */
 567         glColor3f(1.0f, 1.0f, 1.0f);
 568         glVertex3f(fStartX, fStartY + fHeight / 3.0f, 0.0f);
 569         glVertex3f(fStartX + fWidth, fStartY + fHeight / 3.0f, 0.0f);
 570         glVertex3f(fStartX + fWidth, fStartY + 2.0f * fHeight / 3.0f, 0.0f);
 571         glVertex3f(fStartX, fStartY + 2.0f * fHeight / 3.0f, 0.0f);
 572
 573         /* bottom third, white to lighter grey */
 574         glColor3f(1.0f, 1.0f, 1.0f);
 575         glVertex3f(fStartX, fStartY + 2.0f * fHeight / 3.0f, 0.0f);
 576         glColor3f(1.0f, 1.0f, 1.0f);
 577         glVertex3f(fStartX + fWidth, fStartY + 2.0f * fHeight / 3.0f, 0.0f);
 578         glColor3f(0.62f, 0.66f, 0.69f);
 579         glVertex3f(fStartX + fWidth, fStartY + fHeight, 0.0f);
 580         glColor3f(0.62f, 0.66f, 0.69f);
 581         glVertex3f(fStartX, fStartY + fHeight, 0.0f);
 582     }
 583     glEnd();
 584 }
 585
 586 static void
 587 render_frame(GstVaapiSink *sink)
 588 {
 589     const guint x1 = sink->display_rect.x;
 590     const guint x2 = sink->display_rect.x + sink->display_rect.width;
 591     const guint y1 = sink->display_rect.y;
 592     const guint y2 = sink->display_rect.y + sink->display_rect.height;
 593
 594     glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
 595     glBegin(GL_QUADS);
 596     {
 597         glTexCoord2f(0.0f, 0.0f); glVertex2i(x1, y1);
 598         glTexCoord2f(0.0f, 1.0f); glVertex2i(x1, y2);
 599         glTexCoord2f(1.0f, 1.0f); glVertex2i(x2, y2);
 600         glTexCoord2f(1.0f, 0.0f); glVertex2i(x2, y1);
 601     }
 602     glEnd();
 603 }
 604
 605 static void
 606 render_reflection(GstVaapiSink *sink)
 607 {
 608     const guint x1 = sink->display_rect.x;
 609     const guint x2 = sink->display_rect.x + sink->display_rect.width;
 610     const guint y1 = sink->display_rect.y;
 611     const guint rh = sink->display_rect.height / 5;
 612     GLfloat     ry = 1.0f - (GLfloat)rh / (GLfloat)sink->display_rect.height;
 613
 614     glBegin(GL_QUADS);
 615     {
 616         glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
 617         glTexCoord2f(0.0f, 1.0f); glVertex2i(x1, y1);
 618         glTexCoord2f(1.0f, 1.0f); glVertex2i(x2, y1);
 619
 620         glColor4f(1.0f, 1.0f, 1.0f, 0.0f);
 621         glTexCoord2f(1.0f, ry); glVertex2i(x2, y1 + rh);
 622         glTexCoord2f(0.0f, ry); glVertex2i(x1, y1 + rh);
 623     }
 624     glEnd();
 625 }
 626
 627 static gboolean
 628 gst_vaapisink_show_frame_glx(
 629     GstVaapiSink    *sink,
 630     GstVaapiSurface *surface,
 631     guint            flags
 632 )
 633 {
 634     GstVaapiWindowGLX * const window = GST_VAAPI_WINDOW_GLX(sink->window);
 635     GLenum target;
 636     GLuint texture;
 637
 638     gst_vaapi_window_glx_make_current(window);
 639     if (!sink->texture) {
 640         sink->texture = gst_vaapi_texture_new(
 641             sink->display,
 642             GL_TEXTURE_2D,
 643             GL_BGRA,
 644             sink->video_width,
 645             sink->video_height
 646         );
 647         if (!sink->texture)
 648             goto error_create_texture;
 649     }
 650     if (!gst_vaapi_texture_put_surface(sink->texture, surface, flags))
 651         goto error_transfer_surface;
 652
 653     target  = gst_vaapi_texture_get_target(sink->texture);
 654     texture = gst_vaapi_texture_get_id(sink->texture);
 655     if (target != GL_TEXTURE_2D || !texture)
 656         return FALSE;
 657
 658     if (sink->use_reflection)
 659         render_background(sink);
 660
 661     glEnable(target);
 662     glBindTexture(target, texture);
 663     {
 664         if (sink->use_reflection) {
 665             glPushMatrix();
 666             glRotatef(20.0f, 0.0f, 1.0f, 0.0f);
 667             glTranslatef(50.0f, 0.0f, 0.0f);
 668         }
 669         render_frame(sink);
 670         if (sink->use_reflection) {
 671             glPushMatrix();
 672             glTranslatef(0.0, (GLfloat)sink->display_rect.height + 5.0f, 0.0f);
 673             render_reflection(sink);
 674             glPopMatrix();
 675             glPopMatrix();
 676         }
 677     }
 678     glBindTexture(target, 0);
 679     glDisable(target);
 680     gst_vaapi_window_glx_swap_buffers(window);
 681     return TRUE;
 682
 683     /* ERRORS */
 684 error_create_texture:
 685     {
 686         GST_DEBUG("could not create VA/GLX texture");
 687         return FALSE;
 688     }
 689 error_transfer_surface:
 690     {
 691         GST_DEBUG("could not transfer VA surface to texture");
 692         return FALSE;
 693     }
 694 }
 695 #endif
 696
 697 static inline gboolean
 698 gst_vaapisink_show_frame_x11(
 699     GstVaapiSink    *sink,
 700     GstVaapiSurface *surface,
 701     guint            flags
 702 )
 703 {
 704     if (!gst_vaapi_window_put_surface(sink->window, surface,
 705                                       NULL, &sink->display_rect, flags)) {
 706         GST_DEBUG("could not render VA surface");
 707         return FALSE;
 708     }
 709     return TRUE;
 710 }
 711
 712 static GstFlowReturn
 713 gst_vaapisink_show_frame(GstBaseSink *base_sink, GstBuffer *buffer)
 714 {
 715     GstVaapiSink * const sink = GST_VAAPISINK(base_sink);
 716     GstVaapiVideoBuffer * const vbuffer = GST_VAAPI_VIDEO_BUFFER(buffer);
 717     GstVaapiSurface *surface;
 718     guint flags;
 719     gboolean success;
 720
 721     if (!sink->window)
 722         return GST_FLOW_UNEXPECTED;
 723
 724     surface = gst_vaapi_video_buffer_get_surface(vbuffer);
 725     if (!surface)
 726         return GST_FLOW_UNEXPECTED;
 727
 728     GST_DEBUG("render surface %" GST_VAAPI_ID_FORMAT,
 729               GST_VAAPI_ID_ARGS(gst_vaapi_surface_get_id(surface)));
 730
 731     flags = GST_VAAPI_PICTURE_STRUCTURE_FRAME;
 732
 733 #if USE_VAAPISINK_GLX
 734     if (sink->use_glx)
 735         success = gst_vaapisink_show_frame_glx(sink, surface, flags);
 736     else
 737 #endif
 738         success = gst_vaapisink_show_frame_x11(sink, surface, flags);
 739     return success ? GST_FLOW_OK : GST_FLOW_UNEXPECTED;
 740 }
 741
 742 static void
 743 gst_vaapisink_finalize(GObject *object)
 744 {
 745     gst_vaapisink_destroy(GST_VAAPISINK(object));
 746
 747     G_OBJECT_CLASS(parent_class)->finalize(object);
 748 }
 749
 750 static void
 751 gst_vaapisink_set_property(
 752     GObject      *object,
 753     guint         prop_id,
 754     const GValue *value,
 755     GParamSpec   *pspec
 756 )
 757 {
 758     GstVaapiSink * const sink = GST_VAAPISINK(object);
 759
 760     switch (prop_id) {
 761     case PROP_USE_GLX:
 762         sink->use_glx = g_value_get_boolean(value);
 763         break;
 764     case PROP_DISPLAY:
 765         g_free(sink->display_name);
 766         sink->display_name = g_strdup(g_value_get_string(value));
 767         break;
 768     case PROP_FULLSCREEN:
 769         sink->fullscreen = g_value_get_boolean(value);
 770         break;
 771     case PROP_SYNCHRONOUS:
 772         sink->synchronous = g_value_get_boolean(value);
 773         break;
 774     case PROP_USE_REFLECTION:
 775         sink->use_reflection = g_value_get_boolean(value);
 776         break;
 777     default:
 778         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
 779         break;
 780     }
 781 }
 782
 783 static void
 784 gst_vaapisink_get_property(
 785     GObject    *object,
 786     guint       prop_id,
 787     GValue     *value,
 788     GParamSpec *pspec
 789 )
 790 {
 791     GstVaapiSink * const sink = GST_VAAPISINK(object);
 792
 793     switch (prop_id) {
 794     case PROP_USE_GLX:
 795         g_value_set_boolean(value, sink->use_glx);
 796         break;
 797     case PROP_DISPLAY:
 798         g_value_set_string(value, sink->display_name);
 799         break;
 800     case PROP_FULLSCREEN:
 801         g_value_set_boolean(value, sink->fullscreen);
 802         break;
 803     case PROP_SYNCHRONOUS:
 804         g_value_set_boolean(value, sink->synchronous);
 805         break;
 806     case PROP_USE_REFLECTION:
 807         g_value_set_boolean(value, sink->use_reflection);
 808         break;
 809     default:
 810         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
 811         break;
 812     }
 813 }
 814
 815 static void
 816 gst_vaapisink_base_init(gpointer klass)
 817 {
 818     GstElementClass * const element_class = GST_ELEMENT_CLASS(klass);
 819
 820     gst_element_class_set_details(element_class, &gst_vaapisink_details);
 821
 822     gst_element_class_add_pad_template(
 823         element_class,
 824         gst_static_pad_template_get(&gst_vaapisink_sink_factory)
 825     );
 826 }
 827
 828 static void
 829 gst_vaapisink_class_init(GstVaapiSinkClass *klass)
 830 {
 831     GObjectClass * const     object_class   = G_OBJECT_CLASS(klass);
 832     GstBaseSinkClass * const basesink_class = GST_BASE_SINK_CLASS(klass);
 833
 834     GST_DEBUG_CATEGORY_INIT(gst_debug_vaapisink,
 835                             GST_PLUGIN_NAME, 0, GST_PLUGIN_DESC);
 836
 837     object_class->finalize       = gst_vaapisink_finalize;
 838     object_class->set_property   = gst_vaapisink_set_property;
 839     object_class->get_property   = gst_vaapisink_get_property;
 840
 841     basesink_class->start        = gst_vaapisink_start;
 842     basesink_class->stop         = gst_vaapisink_stop;
 843     basesink_class->set_caps     = gst_vaapisink_set_caps;
 844     basesink_class->buffer_alloc = gst_vaapisink_buffer_alloc;
 845     basesink_class->preroll      = gst_vaapisink_show_frame;
 846     basesink_class->render       = gst_vaapisink_show_frame;
 847
 848 #if USE_VAAPISINK_GLX
 849     g_object_class_install_property
 850         (object_class,
 851          PROP_USE_GLX,
 852          g_param_spec_boolean("use-glx",
 853                               "GLX rendering",
 854                               "Enables GLX rendering",
 855                               TRUE,
 856                               G_PARAM_READWRITE));
 857
 858     g_object_class_install_property
 859         (object_class,
 860          PROP_USE_REFLECTION,
 861          g_param_spec_boolean("use-reflection",
 862                               "Reflection effect",
 863                               "Enables OpenGL reflection effect",
 864                               FALSE,
 865                               G_PARAM_READWRITE));
 866 #endif
 867
 868     g_object_class_install_property
 869         (object_class,
 870          PROP_DISPLAY,
 871          g_param_spec_string("display",
 872                              "X11 display name",
 873                              "X11 display name",
 874                              "",
 875                              G_PARAM_READWRITE));
 876
 877     g_object_class_install_property
 878         (object_class,
 879          PROP_FULLSCREEN,
 880          g_param_spec_boolean("fullscreen",
 881                               "Fullscreen",
 882                               "Requests window in fullscreen state",
 883                               FALSE,
 884                               G_PARAM_READWRITE));
 885
 886     /**
 887      * GstVaapiSink:synchronous:
 888      *
 889      * When enabled, runs the X display in synchronous mode. Note that
 890      * this is used only for debugging.
 891      */
 892     g_object_class_install_property
 893         (object_class,
 894          PROP_SYNCHRONOUS,
 895          g_param_spec_boolean("synchronous",
 896                               "Synchronous mode",
 897                               "Toggles X display synchronous mode",
 898                               FALSE,
 899                               G_PARAM_READWRITE));
 900 }
 901
 902 static void
 903 gst_vaapisink_init(GstVaapiSink *sink, GstVaapiSinkClass *klass)
 904 {
 905     sink->display_name   = NULL;
 906     sink->display        = NULL;
 907     sink->window         = NULL;
 908     sink->window_width   = 0;
 909     sink->window_height  = 0;
 910     sink->texture        = NULL;
 911     sink->video_width    = 0;
 912     sink->video_height   = 0;
 913     sink->video_par_n    = 1;
 914     sink->video_par_d    = 1;
 915     sink->foreign_window = FALSE;
 916     sink->fullscreen     = FALSE;
 917     sink->synchronous    = FALSE;
 918     sink->use_glx        = USE_VAAPISINK_GLX;
 919     sink->use_reflection = FALSE;
 920 }
 921
 922 GstVaapiDisplay *
 923 gst_vaapisink_get_display(GstVaapiSink *sink)
 924 {
 925     if (!gst_vaapisink_ensure_display(sink))
 926         return NULL;
 927     return sink->display;
 928 }