/* * gstvaapisink.c - VA-API video sink * * Copyright (C) 2010-2011 Splitted-Desktop Systems * Author: Gwenole Beauchesne * Copyright (C) 2011-2014 Intel Corporation * Author: Gwenole Beauchesne * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public License * as published by the Free Software Foundation; either version 2.1 * of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free * Software Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301 USA */ /** * SECTION:gstvaapisink * @short_description: A VA-API based videosink * * vaapisink renders video frames to a drawable (X #Window) on a local * display using the Video Acceleration (VA) API. The element will * create its own internal window and render into it. */ #include "gst/vaapi/sysdeps.h" #include #include #include /* Supported interfaces */ #if GST_CHECK_VERSION(1,0,0) # include #else # include # define GST_TYPE_VIDEO_OVERLAY GST_TYPE_X_OVERLAY # define GST_VIDEO_OVERLAY GST_X_OVERLAY # define GstVideoOverlay GstXOverlay # define GstVideoOverlayInterface GstXOverlayClass # define gst_video_overlay_prepare_window_handle(sink) \ gst_x_overlay_prepare_xwindow_id(sink) # define gst_video_overlay_got_window_handle(sink, window_handle) \ gst_x_overlay_got_window_handle(sink, window_handle) #endif #include "gstvaapisink.h" #include "gstvaapipluginutil.h" #include "gstvaapivideometa.h" #if GST_CHECK_VERSION(1,0,0) #include "gstvaapivideobufferpool.h" #include "gstvaapivideomemory.h" #endif #define GST_PLUGIN_NAME "vaapisink" #define GST_PLUGIN_DESC "A VA-API based videosink" GST_DEBUG_CATEGORY_STATIC (gst_debug_vaapisink); #define GST_CAT_DEFAULT gst_debug_vaapisink /* Default template */ static const char gst_vaapisink_sink_caps_str[] = #if GST_CHECK_VERSION(1,1,0) GST_VIDEO_CAPS_MAKE_WITH_FEATURES (GST_CAPS_FEATURE_MEMORY_VAAPI_SURFACE, "{ ENCODED, NV12, I420, YV12 }") ";" GST_VIDEO_CAPS_MAKE (GST_VIDEO_FORMATS_ALL); #else #if GST_CHECK_VERSION(1,0,0) GST_VIDEO_CAPS_MAKE (GST_VIDEO_FORMATS_ALL) "; " #else "video/x-raw-yuv, " "width = (int) [ 1, MAX ], " "height = (int) [ 1, MAX ]; " #endif GST_VAAPI_SURFACE_CAPS; #endif static GstStaticPadTemplate gst_vaapisink_sink_factory = GST_STATIC_PAD_TEMPLATE ("sink", GST_PAD_SINK, GST_PAD_ALWAYS, GST_STATIC_CAPS (gst_vaapisink_sink_caps_str)); static gboolean gst_vaapisink_has_interface (GstVaapiPluginBase * plugin, GType type) { return type == GST_TYPE_VIDEO_OVERLAY; } static void gst_vaapisink_video_overlay_iface_init (GstVideoOverlayInterface * iface); G_DEFINE_TYPE_WITH_CODE (GstVaapiSink, gst_vaapisink, GST_TYPE_VIDEO_SINK, GST_VAAPI_PLUGIN_BASE_INIT_INTERFACES G_IMPLEMENT_INTERFACE (GST_TYPE_VIDEO_OVERLAY, gst_vaapisink_video_overlay_iface_init)); enum { PROP_0, PROP_DISPLAY_TYPE, PROP_DISPLAY_NAME, PROP_FULLSCREEN, PROP_ROTATION, PROP_FORCE_ASPECT_RATIO, PROP_VIEW_ID, N_PROPERTIES }; #define DEFAULT_DISPLAY_TYPE GST_VAAPI_DISPLAY_TYPE_ANY #define DEFAULT_ROTATION GST_VAAPI_ROTATION_0 static GParamSpec *g_properties[N_PROPERTIES] = { NULL, }; static void gst_vaapisink_video_overlay_expose (GstVideoOverlay * overlay); static gboolean gst_vaapisink_reconfigure_window (GstVaapiSink * sink); static void gst_vaapisink_set_event_handling (GstVaapiSink * sink, gboolean handle_events); static GstFlowReturn gst_vaapisink_show_frame (GstBaseSink * base_sink, GstBuffer * buffer); static gboolean gst_vaapisink_ensure_render_rect (GstVaapiSink * sink, guint width, guint height); static inline gboolean gst_vaapisink_ensure_display (GstVaapiSink * sink) { return gst_vaapi_plugin_base_ensure_display (GST_VAAPI_PLUGIN_BASE (sink)); } static inline gboolean gst_vaapisink_render_surface (GstVaapiSink * sink, GstVaapiSurface * surface, const GstVaapiRectangle * surface_rect, guint flags) { return sink->window && gst_vaapi_window_put_surface (sink->window, surface, surface_rect, &sink->display_rect, flags); } /* ------------------------------------------------------------------------ */ /* --- DRM Backend --- */ /* ------------------------------------------------------------------------ */ #if USE_DRM #include static gboolean gst_vaapisink_drm_create_window (GstVaapiSink * sink, guint width, guint height) { g_return_val_if_fail (sink->window == NULL, FALSE); GST_ERROR ("failed to create a window for VA/DRM display"); return FALSE; } static gboolean gst_vaapisink_drm_render_surface (GstVaapiSink * sink, GstVaapiSurface * surface, const GstVaapiRectangle * surface_rect, guint flags) { return TRUE; } static const inline GstVaapiSinkBackend * gst_vaapisink_backend_drm (void) { static const GstVaapiSinkBackend GstVaapiSinkBackendDRM = { .create_window = gst_vaapisink_drm_create_window, .render_surface = gst_vaapisink_drm_render_surface, }; return &GstVaapiSinkBackendDRM; } #endif /* ------------------------------------------------------------------------ */ /* --- X11 Backend --- */ /* ------------------------------------------------------------------------ */ #if USE_X11 #include #include /* Checks whether a ConfigureNotify event is in the queue */ typedef struct _ConfigureNotifyEventPendingArgs ConfigureNotifyEventPendingArgs; struct _ConfigureNotifyEventPendingArgs { Window window; guint width; guint height; gboolean match; }; static Bool configure_notify_event_pending_cb (Display * dpy, XEvent * xev, XPointer arg) { ConfigureNotifyEventPendingArgs *const args = (ConfigureNotifyEventPendingArgs *) arg; if (xev->type == ConfigureNotify && xev->xconfigure.window == args->window && xev->xconfigure.width == args->width && xev->xconfigure.height == args->height) args->match = TRUE; /* XXX: this is a hack to traverse the whole queue because we can't use XPeekIfEvent() since it could block */ return False; } static gboolean configure_notify_event_pending (GstVaapiSink * sink, Window window, guint width, guint height) { GstVaapiDisplayX11 *const display = GST_VAAPI_DISPLAY_X11 (GST_VAAPI_PLUGIN_BASE_DISPLAY (sink)); ConfigureNotifyEventPendingArgs args; XEvent xev; args.window = window; args.width = width; args.height = height; args.match = FALSE; /* XXX: don't use XPeekIfEvent() because it might block */ XCheckIfEvent (gst_vaapi_display_x11_get_display (display), &xev, configure_notify_event_pending_cb, (XPointer) & args); return args.match; } static gboolean gst_vaapisink_x11_create_window (GstVaapiSink * sink, guint width, guint height) { GstVaapiDisplay *const display = GST_VAAPI_PLUGIN_BASE_DISPLAY (sink); g_return_val_if_fail (sink->window == NULL, FALSE); sink->window = gst_vaapi_window_x11_new (display, width, height); if (!sink->window) return FALSE; gst_video_overlay_got_window_handle (GST_VIDEO_OVERLAY (sink), gst_vaapi_window_x11_get_xid (GST_VAAPI_WINDOW_X11 (sink->window))); return TRUE; } static gboolean gst_vaapisink_x11_create_window_from_handle (GstVaapiSink * sink, guintptr window) { GstVaapiDisplay *display; Window rootwin; unsigned int width, height, border_width, depth; int x, y; XID xid = window; if (!gst_vaapisink_ensure_display (sink)) return FALSE; display = GST_VAAPI_PLUGIN_BASE_DISPLAY (sink); gst_vaapi_display_lock (display); XGetGeometry (gst_vaapi_display_x11_get_display (GST_VAAPI_DISPLAY_X11 (display)), xid, &rootwin, &x, &y, &width, &height, &border_width, &depth); gst_vaapi_display_unlock (display); if ((width != sink->window_width || height != sink->window_height) && !configure_notify_event_pending (sink, xid, width, height)) { if (!gst_vaapisink_ensure_render_rect (sink, width, height)) return FALSE; sink->window_width = width; sink->window_height = height; } if (!sink->window || gst_vaapi_window_x11_get_xid (GST_VAAPI_WINDOW_X11 (sink->window)) != xid) { gst_vaapi_window_replace (&sink->window, NULL); sink->window = gst_vaapi_window_x11_new_with_xid (display, xid); if (!sink->window) return FALSE; } gst_vaapisink_set_event_handling (sink, sink->handle_events); return TRUE; } static gboolean gst_vaapisink_x11_handle_events (GstVaapiSink * sink) { GstVaapiDisplay *const display = GST_VAAPI_PLUGIN_BASE_DISPLAY (sink); gboolean has_events, do_expose = FALSE; XEvent e; if (sink->window) { Display *const x11_dpy = gst_vaapi_display_x11_get_display (GST_VAAPI_DISPLAY_X11 (display)); Window x11_win = gst_vaapi_window_x11_get_xid (GST_VAAPI_WINDOW_X11 (sink->window)); /* Handle Expose + ConfigureNotify */ /* Need to lock whole loop or we corrupt the XEvent queue: */ for (;;) { gst_vaapi_display_lock (display); has_events = XCheckWindowEvent (x11_dpy, x11_win, StructureNotifyMask | ExposureMask, &e); gst_vaapi_display_unlock (display); if (!has_events) break; switch (e.type) { case Expose: do_expose = TRUE; break; case ConfigureNotify: if (gst_vaapisink_reconfigure_window (sink)) do_expose = TRUE; break; default: break; } } if (do_expose) gst_vaapisink_video_overlay_expose (GST_VIDEO_OVERLAY (sink)); /* FIXME: handle mouse and key events */ } return TRUE; } static gboolean gst_vaapisink_x11_pre_start_event_thread (GstVaapiSink * sink) { GstVaapiDisplayX11 *const display = GST_VAAPI_DISPLAY_X11 (GST_VAAPI_PLUGIN_BASE_DISPLAY (sink)); if (sink->window) { XSelectInput (gst_vaapi_display_x11_get_display (display), gst_vaapi_window_x11_get_xid (GST_VAAPI_WINDOW_X11 (sink->window)), StructureNotifyMask | ExposureMask); } return TRUE; } static gboolean gst_vaapisink_x11_pre_stop_event_thread (GstVaapiSink * sink) { GstVaapiDisplayX11 *const display = GST_VAAPI_DISPLAY_X11 (GST_VAAPI_PLUGIN_BASE_DISPLAY (sink)); if (sink->window) { XSelectInput (gst_vaapi_display_x11_get_display (display), gst_vaapi_window_x11_get_xid (GST_VAAPI_WINDOW_X11 (sink->window)), 0); } return TRUE; } static const inline GstVaapiSinkBackend * gst_vaapisink_backend_x11 (void) { static const GstVaapiSinkBackend GstVaapiSinkBackendX11 = { .create_window = gst_vaapisink_x11_create_window, .create_window_from_handle = gst_vaapisink_x11_create_window_from_handle, .render_surface = gst_vaapisink_render_surface, .event_thread_needed = TRUE, .handle_events = gst_vaapisink_x11_handle_events, .pre_start_event_thread = gst_vaapisink_x11_pre_start_event_thread, .pre_stop_event_thread = gst_vaapisink_x11_pre_stop_event_thread, }; return &GstVaapiSinkBackendX11; } #endif /* ------------------------------------------------------------------------ */ /* --- Wayland Backend --- */ /* ------------------------------------------------------------------------ */ #if USE_WAYLAND #include #include static gboolean gst_vaapisink_wayland_create_window (GstVaapiSink * sink, guint width, guint height) { GstVaapiDisplay *const display = GST_VAAPI_PLUGIN_BASE_DISPLAY (sink); g_return_val_if_fail (sink->window == NULL, FALSE); sink->window = gst_vaapi_window_wayland_new (display, width, height); if (!sink->window) return FALSE; return TRUE; } static const inline GstVaapiSinkBackend * gst_vaapisink_backend_wayland (void) { static const GstVaapiSinkBackend GstVaapiSinkBackendWayland = { .create_window = gst_vaapisink_wayland_create_window, .render_surface = gst_vaapisink_render_surface, }; return &GstVaapiSinkBackendWayland; } #endif /* ------------------------------------------------------------------------ */ /* --- GstVideoOverlay interface --- */ /* ------------------------------------------------------------------------ */ static void gst_vaapisink_video_overlay_set_window_handle (GstVideoOverlay * overlay, guintptr window) { GstVaapiSink *const sink = GST_VAAPISINK (overlay); GstVaapiDisplayType display_type; if (!gst_vaapisink_ensure_display (sink)) return; display_type = GST_VAAPI_PLUGIN_BASE_DISPLAY_TYPE (sink); /* Disable GLX rendering when vaapisink is using a foreign X window. It's pretty much useless */ if (display_type == GST_VAAPI_DISPLAY_TYPE_GLX) { display_type = GST_VAAPI_DISPLAY_TYPE_X11; gst_vaapi_plugin_base_set_display_type (GST_VAAPI_PLUGIN_BASE (sink), display_type); } sink->foreign_window = TRUE; if (sink->backend->create_window_from_handle) sink->backend->create_window_from_handle (sink, window); } static void gst_vaapisink_video_overlay_set_render_rectangle (GstVideoOverlay * overlay, gint x, gint y, gint width, gint height) { GstVaapiSink *const sink = GST_VAAPISINK (overlay); GstVaapiRectangle *const display_rect = &sink->display_rect; display_rect->x = x; display_rect->y = y; display_rect->width = width; display_rect->height = height; GST_DEBUG ("render rect (%d,%d):%ux%u", display_rect->x, display_rect->y, display_rect->width, display_rect->height); } static void gst_vaapisink_video_overlay_expose (GstVideoOverlay * overlay) { GstVaapiSink *const sink = GST_VAAPISINK (overlay); if (sink->video_buffer) { gst_vaapisink_reconfigure_window (sink); gst_vaapisink_show_frame (GST_BASE_SINK_CAST (sink), sink->video_buffer); } } static void gst_vaapisink_video_overlay_set_event_handling (GstVideoOverlay * overlay, gboolean handle_events) { GstVaapiSink *const sink = GST_VAAPISINK (overlay); gst_vaapisink_set_event_handling (sink, handle_events); } static void gst_vaapisink_video_overlay_iface_init (GstVideoOverlayInterface * iface) { iface->set_window_handle = gst_vaapisink_video_overlay_set_window_handle; iface->set_render_rectangle = gst_vaapisink_video_overlay_set_render_rectangle; iface->expose = gst_vaapisink_video_overlay_expose; iface->handle_events = gst_vaapisink_video_overlay_set_event_handling; } /* ------------------------------------------------------------------------ */ /* --- Common implementation --- */ /* ------------------------------------------------------------------------ */ static gboolean gst_vaapisink_reconfigure_window (GstVaapiSink * sink) { guint win_width, win_height; gst_vaapi_window_reconfigure (sink->window); gst_vaapi_window_get_size (sink->window, &win_width, &win_height); if (win_width != sink->window_width || win_height != sink->window_height) { if (!gst_vaapisink_ensure_render_rect (sink, win_width, win_height)) return FALSE; GST_INFO ("window was resized from %ux%u to %ux%u", sink->window_width, sink->window_height, win_width, win_height); sink->window_width = win_width; sink->window_height = win_height; return TRUE; } return FALSE; } static gpointer gst_vaapisink_event_thread (GstVaapiSink * sink) { GST_OBJECT_LOCK (sink); while (!sink->event_thread_cancel) { GST_OBJECT_UNLOCK (sink); sink->backend->handle_events (sink); g_usleep (G_USEC_PER_SEC / 20); GST_OBJECT_LOCK (sink); } GST_OBJECT_UNLOCK (sink); return NULL; } static void gst_vaapisink_set_event_handling (GstVaapiSink * sink, gboolean handle_events) { GThread *thread = NULL; if (!sink->backend || !sink->backend->event_thread_needed) return; GST_OBJECT_LOCK (sink); sink->handle_events = handle_events; if (handle_events && !sink->event_thread) { /* Setup our event listening thread */ GST_DEBUG ("starting xevent thread"); if (sink->backend->pre_start_event_thread) sink->backend->pre_start_event_thread (sink); sink->event_thread_cancel = FALSE; sink->event_thread = g_thread_try_new ("vaapisink-events", (GThreadFunc) gst_vaapisink_event_thread, sink, NULL); } else if (!handle_events && sink->event_thread) { GST_DEBUG ("stopping xevent thread"); if (sink->backend->pre_stop_event_thread) sink->backend->pre_stop_event_thread (sink); /* Grab thread and mark it as NULL */ thread = sink->event_thread; sink->event_thread = NULL; sink->event_thread_cancel = TRUE; } GST_OBJECT_UNLOCK (sink); /* Wait for our event thread to finish */ if (thread) { g_thread_join (thread); GST_DEBUG ("xevent thread stopped"); } } static void gst_vaapisink_ensure_backend (GstVaapiSink * sink) { switch (GST_VAAPI_PLUGIN_BASE_DISPLAY_TYPE (sink)) { #if USE_DRM case GST_VAAPI_DISPLAY_TYPE_DRM: sink->backend = gst_vaapisink_backend_drm (); break; #endif #if USE_X11 case GST_VAAPI_DISPLAY_TYPE_X11: sink->backend = gst_vaapisink_backend_x11 (); break; #endif #if USE_GLX case GST_VAAPI_DISPLAY_TYPE_GLX: sink->backend = gst_vaapisink_backend_x11 (); break; #endif #if USE_WAYLAND case GST_VAAPI_DISPLAY_TYPE_WAYLAND: sink->backend = gst_vaapisink_backend_wayland (); break; #endif default: GST_ERROR ("failed to initialize GstVaapiSink backend"); g_assert_not_reached (); break; } } static gboolean gst_vaapisink_ensure_uploader (GstVaapiSink * sink) { if (!gst_vaapisink_ensure_display (sink)) return FALSE; if (!gst_vaapi_plugin_base_ensure_uploader (GST_VAAPI_PLUGIN_BASE (sink))) return FALSE; return TRUE; } static gboolean gst_vaapisink_ensure_render_rect (GstVaapiSink * sink, guint width, guint height) { GstVaapiRectangle *const display_rect = &sink->display_rect; guint num, den, display_par_n, display_par_d; gboolean success; /* Return success if caps are not set yet */ if (!sink->caps) return TRUE; if (!sink->keep_aspect) { display_rect->width = width; display_rect->height = height; display_rect->x = 0; display_rect->y = 0; GST_DEBUG ("force-aspect-ratio is false; distorting while scaling video"); GST_DEBUG ("render rect (%d,%d):%ux%u", display_rect->x, display_rect->y, display_rect->width, display_rect->height); return TRUE; } GST_DEBUG ("ensure render rect within %ux%u bounds", width, height); gst_vaapi_display_get_pixel_aspect_ratio (GST_VAAPI_PLUGIN_BASE_DISPLAY (sink), &display_par_n, &display_par_d); GST_DEBUG ("display pixel-aspect-ratio %d/%d", display_par_n, display_par_d); success = gst_video_calculate_display_ratio (&num, &den, sink->video_width, sink->video_height, sink->video_par_n, sink->video_par_d, display_par_n, display_par_d); if (!success) return FALSE; GST_DEBUG ("video size %dx%d, calculated ratio %d/%d", sink->video_width, sink->video_height, num, den); display_rect->width = gst_util_uint64_scale_int (height, num, den); if (display_rect->width <= width) { GST_DEBUG ("keeping window height"); display_rect->height = height; } else { GST_DEBUG ("keeping window width"); display_rect->width = width; display_rect->height = gst_util_uint64_scale_int (width, den, num); } GST_DEBUG ("scaling video to %ux%u", display_rect->width, display_rect->height); g_assert (display_rect->width <= width); g_assert (display_rect->height <= height); display_rect->x = (width - display_rect->width) / 2; display_rect->y = (height - display_rect->height) / 2; GST_DEBUG ("render rect (%d,%d):%ux%u", display_rect->x, display_rect->y, display_rect->width, display_rect->height); return TRUE; } static inline gboolean gst_vaapisink_ensure_window (GstVaapiSink * sink, guint width, guint height) { return sink->window || sink->backend->create_window (sink, width, height); } static void gst_vaapisink_ensure_window_size (GstVaapiSink * sink, guint * width_ptr, guint * height_ptr) { GstVaapiDisplay *const display = GST_VAAPI_PLUGIN_BASE_DISPLAY (sink); GstVideoRectangle src_rect, dst_rect, out_rect; guint num, den, display_width, display_height, display_par_n, display_par_d; gboolean success, scale; if (sink->foreign_window) { *width_ptr = sink->window_width; *height_ptr = sink->window_height; return; } gst_vaapi_display_get_size (display, &display_width, &display_height); if (sink->fullscreen) { *width_ptr = display_width; *height_ptr = display_height; return; } gst_vaapi_display_get_pixel_aspect_ratio (display, &display_par_n, &display_par_d); success = gst_video_calculate_display_ratio (&num, &den, sink->video_width, sink->video_height, sink->video_par_n, sink->video_par_d, display_par_n, display_par_d); if (!success) { num = sink->video_par_n; den = sink->video_par_d; } src_rect.x = 0; src_rect.y = 0; src_rect.w = gst_util_uint64_scale_int (sink->video_height, num, den); src_rect.h = sink->video_height; dst_rect.x = 0; dst_rect.y = 0; dst_rect.w = display_width; dst_rect.h = display_height; scale = (src_rect.w > dst_rect.w || src_rect.h > dst_rect.h); gst_video_sink_center_rect (src_rect, dst_rect, &out_rect, scale); *width_ptr = out_rect.w; *height_ptr = out_rect.h; } static gboolean gst_vaapisink_ensure_rotation (GstVaapiSink * sink, gboolean recalc_display_rect) { GstVaapiDisplay *const display = GST_VAAPI_PLUGIN_BASE_DISPLAY (sink); gboolean success = FALSE; g_return_val_if_fail (display, FALSE); if (sink->rotation == sink->rotation_req) return TRUE; if (!sink->use_rotation) { GST_WARNING ("VA display does not support rotation"); goto end; } gst_vaapi_display_lock (display); success = gst_vaapi_display_set_rotation (display, sink->rotation_req); gst_vaapi_display_unlock (display); if (!success) { GST_ERROR ("failed to change VA display rotation mode"); goto end; } if (((sink->rotation + sink->rotation_req) % 180) == 90) { /* Orientation changed */ G_PRIMITIVE_SWAP (guint, sink->video_width, sink->video_height); G_PRIMITIVE_SWAP (gint, sink->video_par_n, sink->video_par_d); } if (recalc_display_rect && !sink->foreign_window) gst_vaapisink_ensure_render_rect (sink, sink->window_width, sink->window_height); success = TRUE; end: sink->rotation = sink->rotation_req; return success; } static const gchar * get_display_type_name (GstVaapiDisplayType display_type) { gpointer const klass = g_type_class_peek (GST_VAAPI_TYPE_DISPLAY_TYPE); GEnumValue *const e = g_enum_get_value (klass, display_type); if (e) return e->value_name; return ""; } static void gst_vaapisink_display_changed (GstVaapiPluginBase * plugin) { GstVaapiSink *const sink = GST_VAAPISINK_CAST (plugin); GstVaapiRenderMode render_mode; GST_INFO ("created %s %p", get_display_type_name (plugin->display_type), plugin->display); gst_vaapisink_ensure_backend (sink); sink->use_overlay = gst_vaapi_display_get_render_mode (plugin->display, &render_mode) && render_mode == GST_VAAPI_RENDER_MODE_OVERLAY; GST_DEBUG ("use %s rendering mode", sink->use_overlay ? "overlay" : "texture"); sink->use_rotation = gst_vaapi_display_has_property (plugin->display, GST_VAAPI_DISPLAY_PROP_ROTATION); } static gboolean gst_vaapisink_start (GstBaseSink * base_sink) { GstVaapiSink *const sink = GST_VAAPISINK_CAST (base_sink); if (!gst_vaapi_plugin_base_open (GST_VAAPI_PLUGIN_BASE (sink))) return FALSE; return gst_vaapisink_ensure_uploader (sink); } static gboolean gst_vaapisink_stop (GstBaseSink * base_sink) { GstVaapiSink *const sink = GST_VAAPISINK_CAST (base_sink); gst_buffer_replace (&sink->video_buffer, NULL); gst_vaapi_window_replace (&sink->window, NULL); gst_vaapi_plugin_base_close (GST_VAAPI_PLUGIN_BASE (sink)); return TRUE; } static GstCaps * gst_vaapisink_get_caps_impl (GstBaseSink * base_sink) { GstVaapiSink *const sink = GST_VAAPISINK_CAST (base_sink); GstCaps *out_caps, *yuv_caps; #if GST_CHECK_VERSION(1,1,0) out_caps = gst_static_pad_template_get_caps (&gst_vaapisink_sink_factory); #else out_caps = gst_caps_from_string (GST_VAAPI_SURFACE_CAPS); #endif if (!out_caps) return NULL; if (gst_vaapisink_ensure_uploader (sink)) { yuv_caps = GST_VAAPI_PLUGIN_BASE_UPLOADER_CAPS (sink); if (yuv_caps) { out_caps = gst_caps_make_writable (out_caps); gst_caps_append (out_caps, gst_caps_copy (yuv_caps)); } } return out_caps; } #if GST_CHECK_VERSION(1,0,0) static inline GstCaps * gst_vaapisink_get_caps (GstBaseSink * base_sink, GstCaps * filter) { GstCaps *caps, *out_caps; caps = gst_vaapisink_get_caps_impl (base_sink); if (caps && filter) { out_caps = gst_caps_intersect_full (caps, filter, GST_CAPS_INTERSECT_FIRST); gst_caps_unref (caps); } else out_caps = caps; return out_caps; } #else #define gst_vaapisink_get_caps gst_vaapisink_get_caps_impl #endif static void update_colorimetry (GstVaapiSink * sink, GstVideoColorimetry * cinfo) { #if GST_CHECK_VERSION(1,0,0) if (gst_video_colorimetry_matches (cinfo, GST_VIDEO_COLORIMETRY_BT601)) sink->color_standard = GST_VAAPI_COLOR_STANDARD_ITUR_BT_601; else if (gst_video_colorimetry_matches (cinfo, GST_VIDEO_COLORIMETRY_BT709)) sink->color_standard = GST_VAAPI_COLOR_STANDARD_ITUR_BT_709; else if (gst_video_colorimetry_matches (cinfo, GST_VIDEO_COLORIMETRY_SMPTE240M)) sink->color_standard = GST_VAAPI_COLOR_STANDARD_SMPTE_240M; else sink->color_standard = 0; GST_DEBUG ("colorimetry %s", gst_video_colorimetry_to_string (cinfo)); #endif } static gboolean gst_vaapisink_set_caps (GstBaseSink * base_sink, GstCaps * caps) { GstVaapiPluginBase *const plugin = GST_VAAPI_PLUGIN_BASE (base_sink); GstVaapiSink *const sink = GST_VAAPISINK_CAST (base_sink); GstVideoInfo *const vip = GST_VAAPI_PLUGIN_BASE_SINK_PAD_INFO (sink); GstVaapiDisplay *display; guint win_width, win_height; if (!gst_vaapisink_ensure_display (sink)) return FALSE; display = GST_VAAPI_PLUGIN_BASE_DISPLAY (sink); if (GST_VAAPI_PLUGIN_BASE_DISPLAY_TYPE (sink) == GST_VAAPI_DISPLAY_TYPE_DRM) return TRUE; if (!gst_vaapi_plugin_base_set_caps (plugin, caps, NULL)) return FALSE; sink->video_width = GST_VIDEO_INFO_WIDTH (vip); sink->video_height = GST_VIDEO_INFO_HEIGHT (vip); sink->video_par_n = GST_VIDEO_INFO_PAR_N (vip); sink->video_par_d = GST_VIDEO_INFO_PAR_D (vip); GST_DEBUG ("video pixel-aspect-ratio %d/%d", sink->video_par_n, sink->video_par_d); update_colorimetry (sink, &vip->colorimetry); gst_caps_replace (&sink->caps, caps); gst_vaapisink_ensure_rotation (sink, FALSE); gst_vaapisink_ensure_window_size (sink, &win_width, &win_height); if (sink->window) { if (!sink->foreign_window || sink->fullscreen) gst_vaapi_window_set_size (sink->window, win_width, win_height); } else { gst_vaapi_display_lock (display); gst_video_overlay_prepare_window_handle (GST_VIDEO_OVERLAY (sink)); gst_vaapi_display_unlock (display); if (sink->window) return TRUE; if (!gst_vaapisink_ensure_window (sink, win_width, win_height)) return FALSE; gst_vaapi_window_set_fullscreen (sink->window, sink->fullscreen); gst_vaapi_window_show (sink->window); gst_vaapi_window_get_size (sink->window, &win_width, &win_height); gst_vaapisink_set_event_handling (sink, sink->handle_events); } sink->window_width = win_width; sink->window_height = win_height; GST_DEBUG ("window size %ux%u", win_width, win_height); return gst_vaapisink_ensure_render_rect (sink, win_width, win_height); } static GstFlowReturn gst_vaapisink_show_frame_unlocked (GstVaapiSink * sink, GstBuffer * src_buffer) { GstVaapiVideoMeta *meta; GstVaapiSurfaceProxy *proxy; GstVaapiSurface *surface; GstBuffer *buffer; guint flags; GstVaapiRectangle *surface_rect = NULL; #if GST_CHECK_VERSION(1,0,0) GstVaapiRectangle tmp_rect; #endif GstFlowReturn ret; gint32 view_id; #if GST_CHECK_VERSION(1,0,0) GstVideoCropMeta *const crop_meta = gst_buffer_get_video_crop_meta (src_buffer); if (crop_meta) { surface_rect = &tmp_rect; surface_rect->x = crop_meta->x; surface_rect->y = crop_meta->y; surface_rect->width = crop_meta->width; surface_rect->height = crop_meta->height; } #endif ret = gst_vaapi_plugin_base_get_input_buffer (GST_VAAPI_PLUGIN_BASE (sink), src_buffer, &buffer); if (ret != GST_FLOW_OK && ret != GST_FLOW_NOT_SUPPORTED) return ret; meta = gst_buffer_get_vaapi_video_meta (buffer); GST_VAAPI_PLUGIN_BASE_DISPLAY_REPLACE (sink, gst_vaapi_video_meta_get_display (meta)); proxy = gst_vaapi_video_meta_get_surface_proxy (meta); if (!proxy) goto error; surface = gst_vaapi_video_meta_get_surface (meta); if (!surface) goto error; /* Validate view component to display */ view_id = GST_VAAPI_SURFACE_PROXY_VIEW_ID (proxy); if (G_UNLIKELY (sink->view_id == -1)) sink->view_id = view_id; else if (sink->view_id != view_id) { gst_buffer_unref (buffer); return GST_FLOW_OK; } gst_vaapisink_ensure_rotation (sink, TRUE); GST_DEBUG ("render surface %" GST_VAAPI_ID_FORMAT, GST_VAAPI_ID_ARGS (gst_vaapi_surface_get_id (surface))); if (!surface_rect) surface_rect = (GstVaapiRectangle *) gst_vaapi_video_meta_get_render_rect (meta); if (surface_rect) GST_DEBUG ("render rect (%d,%d), size %ux%u", surface_rect->x, surface_rect->y, surface_rect->width, surface_rect->height); flags = gst_vaapi_video_meta_get_render_flags (meta); /* Append default color standard obtained from caps if none was available on a per-buffer basis */ if (!(flags & GST_VAAPI_COLOR_STANDARD_MASK)) flags |= sink->color_standard; if (!gst_vaapi_apply_composition (surface, src_buffer)) GST_WARNING ("could not update subtitles"); if (!sink->backend->render_surface (sink, surface, surface_rect, flags)) goto error; /* Retain VA surface until the next one is displayed */ gst_buffer_replace (&sink->video_buffer, buffer); gst_buffer_unref (buffer); return GST_FLOW_OK; error: gst_buffer_unref (buffer); return GST_FLOW_EOS; } static GstFlowReturn gst_vaapisink_show_frame (GstBaseSink * base_sink, GstBuffer * src_buffer) { GstVaapiSink *const sink = GST_VAAPISINK_CAST (base_sink); GstFlowReturn ret; /* We need at least to protect the gst_vaapi_aplpy_composition() * call to prevent a race during subpicture destruction. * FIXME: a less coarse grained lock could be used, though */ gst_vaapi_display_lock (GST_VAAPI_PLUGIN_BASE_DISPLAY (sink)); ret = gst_vaapisink_show_frame_unlocked (sink, src_buffer); gst_vaapi_display_unlock (GST_VAAPI_PLUGIN_BASE_DISPLAY (sink)); return ret; } #if GST_CHECK_VERSION(1,0,0) static gboolean gst_vaapisink_propose_allocation (GstBaseSink * base_sink, GstQuery * query) { GstVaapiPluginBase *const plugin = GST_VAAPI_PLUGIN_BASE (base_sink); if (!gst_vaapi_plugin_base_propose_allocation (plugin, query)) return FALSE; gst_query_add_allocation_meta (query, GST_VIDEO_CROP_META_API_TYPE, NULL); gst_query_add_allocation_meta (query, GST_VIDEO_OVERLAY_COMPOSITION_META_API_TYPE, NULL); return TRUE; } #else static GstFlowReturn gst_vaapisink_buffer_alloc (GstBaseSink * base_sink, guint64 offset, guint size, GstCaps * caps, GstBuffer ** outbuf_ptr) { return gst_vaapi_plugin_base_allocate_input_buffer (GST_VAAPI_PLUGIN_BASE (base_sink), caps, outbuf_ptr); } #endif static gboolean gst_vaapisink_query (GstBaseSink * base_sink, GstQuery * query) { GstVaapiSink *const sink = GST_VAAPISINK_CAST (base_sink); GST_INFO_OBJECT (sink, "query type %s", GST_QUERY_TYPE_NAME (query)); if (gst_vaapi_reply_to_query (query, GST_VAAPI_PLUGIN_BASE_DISPLAY (sink))) { GST_DEBUG ("sharing display %p", GST_VAAPI_PLUGIN_BASE_DISPLAY (sink)); return TRUE; } return GST_BASE_SINK_CLASS (gst_vaapisink_parent_class)->query (base_sink, query); } static void gst_vaapisink_destroy (GstVaapiSink * sink) { gst_vaapisink_set_event_handling (sink, FALSE); gst_buffer_replace (&sink->video_buffer, NULL); gst_caps_replace (&sink->caps, NULL); } static void gst_vaapisink_finalize (GObject * object) { gst_vaapisink_destroy (GST_VAAPISINK_CAST (object)); gst_vaapi_plugin_base_finalize (GST_VAAPI_PLUGIN_BASE (object)); G_OBJECT_CLASS (gst_vaapisink_parent_class)->finalize (object); } static void gst_vaapisink_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { GstVaapiSink *const sink = GST_VAAPISINK_CAST (object); switch (prop_id) { case PROP_DISPLAY_TYPE: gst_vaapi_plugin_base_set_display_type (GST_VAAPI_PLUGIN_BASE (sink), g_value_get_enum (value)); break; case PROP_DISPLAY_NAME: gst_vaapi_plugin_base_set_display_name (GST_VAAPI_PLUGIN_BASE (sink), g_value_get_string (value)); break; case PROP_FULLSCREEN: sink->fullscreen = g_value_get_boolean (value); break; case PROP_VIEW_ID: sink->view_id = g_value_get_int (value); break; case PROP_ROTATION: sink->rotation_req = g_value_get_enum (value); break; case PROP_FORCE_ASPECT_RATIO: sink->keep_aspect = g_value_get_boolean (value); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } } static void gst_vaapisink_get_property (GObject * object, guint prop_id, GValue * value, GParamSpec * pspec) { GstVaapiSink *const sink = GST_VAAPISINK_CAST (object); switch (prop_id) { case PROP_DISPLAY_TYPE: g_value_set_enum (value, GST_VAAPI_PLUGIN_BASE_DISPLAY_TYPE (sink)); break; case PROP_DISPLAY_NAME: g_value_set_string (value, GST_VAAPI_PLUGIN_BASE_DISPLAY_NAME (sink)); break; case PROP_FULLSCREEN: g_value_set_boolean (value, sink->fullscreen); break; case PROP_VIEW_ID: g_value_set_int (value, sink->view_id); break; case PROP_ROTATION: g_value_set_enum (value, sink->rotation); break; case PROP_FORCE_ASPECT_RATIO: g_value_set_boolean (value, sink->keep_aspect); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } } static void gst_vaapisink_set_bus (GstElement * element, GstBus * bus) { /* Make sure to allocate a VA display in the sink element first, so that upstream elements could query a display that was allocated here, and that exactly matches what the user requested through the "display" property */ if (!GST_ELEMENT_BUS (element) && bus) gst_vaapisink_ensure_display (GST_VAAPISINK_CAST (element)); GST_ELEMENT_CLASS (gst_vaapisink_parent_class)->set_bus (element, bus); } static void gst_vaapisink_class_init (GstVaapiSinkClass * klass) { GObjectClass *const object_class = G_OBJECT_CLASS (klass); GstElementClass *const element_class = GST_ELEMENT_CLASS (klass); GstBaseSinkClass *const basesink_class = GST_BASE_SINK_CLASS (klass); GstVaapiPluginBaseClass *const base_plugin_class = GST_VAAPI_PLUGIN_BASE_CLASS (klass); GstPadTemplate *pad_template; GST_DEBUG_CATEGORY_INIT (gst_debug_vaapisink, GST_PLUGIN_NAME, 0, GST_PLUGIN_DESC); gst_vaapi_plugin_base_class_init (base_plugin_class); base_plugin_class->has_interface = gst_vaapisink_has_interface; base_plugin_class->display_changed = gst_vaapisink_display_changed; object_class->finalize = gst_vaapisink_finalize; object_class->set_property = gst_vaapisink_set_property; object_class->get_property = gst_vaapisink_get_property; basesink_class->start = gst_vaapisink_start; basesink_class->stop = gst_vaapisink_stop; basesink_class->get_caps = gst_vaapisink_get_caps; basesink_class->set_caps = gst_vaapisink_set_caps; basesink_class->preroll = gst_vaapisink_show_frame; basesink_class->render = gst_vaapisink_show_frame; basesink_class->query = gst_vaapisink_query; #if GST_CHECK_VERSION(1,0,0) basesink_class->propose_allocation = gst_vaapisink_propose_allocation; #else basesink_class->buffer_alloc = gst_vaapisink_buffer_alloc; #endif element_class->set_bus = gst_vaapisink_set_bus; gst_element_class_set_static_metadata (element_class, "VA-API sink", "Sink/Video", GST_PLUGIN_DESC, "Gwenole Beauchesne "); pad_template = gst_static_pad_template_get (&gst_vaapisink_sink_factory); gst_element_class_add_pad_template (element_class, pad_template); /** * GstVaapiSink:display: * * The type of display to use. */ g_properties[PROP_DISPLAY_TYPE] = g_param_spec_enum ("display", "display type", "display type to use", GST_VAAPI_TYPE_DISPLAY_TYPE, GST_VAAPI_DISPLAY_TYPE_ANY, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS); /** * GstVaapiSink:display-name: * * The native display name. */ g_properties[PROP_DISPLAY_NAME] = g_param_spec_string ("display-name", "display name", "display name to use", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS); /** * GstVaapiSink:fullscreen: * * Selects whether fullscreen mode is enabled or not. */ g_properties[PROP_FULLSCREEN] = g_param_spec_boolean ("fullscreen", "Fullscreen", "Requests window in fullscreen state", FALSE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS); /** * GstVaapiSink:rotation: * * The VA display rotation mode, expressed as a #GstVaapiRotation. */ g_properties[PROP_ROTATION] = g_param_spec_enum (GST_VAAPI_DISPLAY_PROP_ROTATION, "rotation", "The display rotation mode", GST_VAAPI_TYPE_ROTATION, DEFAULT_ROTATION, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS); /** * GstVaapiSink:force-aspect-ratio: * * When enabled, scaling respects video aspect ratio; when disabled, * the video is distorted to fit the window. */ g_properties[PROP_FORCE_ASPECT_RATIO] = g_param_spec_boolean ("force-aspect-ratio", "Force aspect ratio", "When enabled, scaling will respect original aspect ratio", TRUE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS); /** * GstVaapiSink:view-id: * * When not set to -1, the displayed frame will always be the one * that matches the view-id of the very first displayed frame. Any * other number will indicate the desire to display the supplied * view-id only. */ g_properties[PROP_VIEW_ID] = g_param_spec_int ("view-id", "View ID", "ID of the view component of interest to display", -1, G_MAXINT32, -1, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS); g_object_class_install_properties (object_class, N_PROPERTIES, g_properties); } static void gst_vaapisink_init (GstVaapiSink * sink) { GstVaapiPluginBase *const plugin = GST_VAAPI_PLUGIN_BASE (sink); gst_vaapi_plugin_base_init (plugin, GST_CAT_DEFAULT); gst_vaapi_plugin_base_set_display_type (plugin, DEFAULT_DISPLAY_TYPE); sink->video_par_n = 1; sink->video_par_d = 1; sink->view_id = -1; sink->handle_events = TRUE; sink->rotation = DEFAULT_ROTATION; sink->rotation_req = DEFAULT_ROTATION; sink->keep_aspect = TRUE; gst_video_info_init (&sink->video_info); }