diff --git a/gst/vaapi/gstvaapisink.c b/gst/vaapi/gstvaapisink.c index fd2e3813e1..90470006cf 100644 --- a/gst/vaapi/gstvaapisink.c +++ b/gst/vaapi/gstvaapisink.c @@ -65,18 +65,18 @@ #define GST_PLUGIN_NAME "vaapisink" #define GST_PLUGIN_DESC "A VA-API based videosink" -GST_DEBUG_CATEGORY_STATIC(gst_debug_vaapisink); +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); + 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) "; " + GST_VIDEO_CAPS_MAKE (GST_VIDEO_FORMATS_ALL) "; " #else "video/x-raw-yuv, " "width = (int) [ 1, MAX ], " @@ -86,66 +86,67 @@ static const char gst_vaapisink_sink_caps_str[] = #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)); +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) +gst_vaapisink_has_interface (GstVaapiPluginBase * plugin, GType type) { - return type == GST_TYPE_VIDEO_OVERLAY; + return type == GST_TYPE_VIDEO_OVERLAY; } static void -gst_vaapisink_video_overlay_iface_init(GstVideoOverlayInterface *iface); +gst_vaapisink_video_overlay_iface_init (GstVideoOverlayInterface * iface); -G_DEFINE_TYPE_WITH_CODE( - GstVaapiSink, +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)) + G_IMPLEMENT_INTERFACE (GST_TYPE_VIDEO_OVERLAY, + gst_vaapisink_video_overlay_iface_init)); -enum { - PROP_0, +enum +{ + PROP_0, - PROP_DISPLAY_TYPE, - PROP_DISPLAY_NAME, - PROP_FULLSCREEN, - PROP_ROTATION, - PROP_FORCE_ASPECT_RATIO, - PROP_VIEW_ID, + PROP_DISPLAY_TYPE, + PROP_DISPLAY_NAME, + PROP_FULLSCREEN, + PROP_ROTATION, + PROP_FORCE_ASPECT_RATIO, + PROP_VIEW_ID, }; #define DEFAULT_DISPLAY_TYPE GST_VAAPI_DISPLAY_TYPE_ANY #define DEFAULT_ROTATION GST_VAAPI_ROTATION_0 -static inline gboolean -gst_vaapisink_ensure_display(GstVaapiSink *sink); +static gboolean +gst_vaapisink_ensure_display (GstVaapiSink * sink); /* GstVideoOverlay interface */ static void -gst_vaapisink_video_overlay_expose(GstVideoOverlay *overlay); +gst_vaapisink_video_overlay_expose (GstVideoOverlay * overlay); static gboolean -gst_vaapisink_reconfigure_window(GstVaapiSink * sink); +gst_vaapisink_reconfigure_window (GstVaapiSink * sink); static void -gst_vaapisink_set_event_handling(GstVideoOverlay *overlay, gboolean handle_events); +gst_vaapisink_set_event_handling (GstVideoOverlay * overlay, + gboolean handle_events); static GstFlowReturn -gst_vaapisink_show_frame(GstBaseSink *base_sink, GstBuffer *buffer); +gst_vaapisink_show_frame (GstBaseSink * base_sink, GstBuffer * buffer); static gboolean -gst_vaapisink_put_surface(GstVaapiSink *sink, GstVaapiSurface *surface, - const GstVaapiRectangle *surface_rect, guint flags); +gst_vaapisink_put_surface (GstVaapiSink * sink, GstVaapiSurface * surface, + const GstVaapiRectangle * surface_rect, guint flags); static gboolean -gst_vaapisink_ensure_render_rect(GstVaapiSink *sink, guint width, guint height); +gst_vaapisink_ensure_render_rect (GstVaapiSink * sink, guint width, + guint height); /* ------------------------------------------------------------------------ */ /* --- DRM Backend --- */ @@ -155,29 +156,30 @@ gst_vaapisink_ensure_render_rect(GstVaapiSink *sink, guint width, guint height); #include static gboolean -gst_vaapisink_drm_create_window(GstVaapiSink *sink, guint width, guint height) +gst_vaapisink_drm_create_window (GstVaapiSink * sink, guint width, guint height) { - g_return_val_if_fail(sink->window == NULL, FALSE); + g_return_val_if_fail (sink->window == NULL, FALSE); - GST_ERROR("failed to create a window for VA/DRM display"); - return 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) +gst_vaapisink_drm_render_surface (GstVaapiSink * sink, + GstVaapiSurface * surface, const GstVaapiRectangle * surface_rect, + guint flags) { - return TRUE; + return TRUE; } static const inline GstVaapiSinkBackend * -gst_vaapisink_backend_drm(void) +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; + static const GstVaapiSinkBackend GstVaapiSinkBackendDRM = { + .create_window = gst_vaapisink_drm_create_window, + .render_surface = gst_vaapisink_drm_render_surface, + }; + return &GstVaapiSinkBackendDRM; } #endif @@ -191,196 +193,192 @@ gst_vaapisink_backend_drm(void) /* Checks whether a ConfigureNotify event is in the queue */ typedef struct _ConfigureNotifyEventPendingArgs ConfigureNotifyEventPendingArgs; -struct _ConfigureNotifyEventPendingArgs { - Window window; - guint width; - guint height; - gboolean match; +struct _ConfigureNotifyEventPendingArgs +{ + Window window; + guint width; + guint height; + gboolean match; }; static Bool -configure_notify_event_pending_cb(Display *dpy, XEvent *xev, XPointer arg) +configure_notify_event_pending_cb (Display * dpy, XEvent * xev, XPointer arg) { - ConfigureNotifyEventPendingArgs * const args = - (ConfigureNotifyEventPendingArgs *)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; + 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; + /* 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, +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; + 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; + 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; + /* 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) +gst_vaapisink_x11_create_window (GstVaapiSink * sink, guint width, guint height) { - GstVaapiDisplay * const display = GST_VAAPI_PLUGIN_BASE_DISPLAY(sink); + GstVaapiDisplay *const display = GST_VAAPI_PLUGIN_BASE_DISPLAY (sink); - g_return_val_if_fail(sink->window == NULL, FALSE); + g_return_val_if_fail (sink->window == NULL, FALSE); - sink->window = gst_vaapi_window_x11_new(display, width, height); + 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; + 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; + gst_vaapisink_set_event_handling (GST_VIDEO_OVERLAY (sink), + sink->handle_events); + return TRUE; } static gboolean -gst_vaapisink_x11_create_window_from_handle(GstVaapiSink *sink, guintptr window) +gst_vaapisink_x11_handle_events (GstVaapiSink * sink) { - GstVaapiDisplay *display; - Window rootwin; - unsigned int width, height, border_width, depth; - int x, y; - XID xid = window; + GstVaapiDisplay *const display = GST_VAAPI_PLUGIN_BASE_DISPLAY (sink); + gboolean has_events, do_expose = FALSE; + XEvent e; - if (!gst_vaapisink_ensure_display(sink)) - return FALSE; - display = GST_VAAPI_PLUGIN_BASE_DISPLAY(sink); + 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)); - 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); + /* 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; - 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; + switch (e.type) { + case Expose: + do_expose = TRUE; + break; + case ConfigureNotify: + if (gst_vaapisink_reconfigure_window (sink)) + do_expose = TRUE; + break; + default: + break; + } } - - 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(GST_VIDEO_OVERLAY(sink), - sink->handle_events); - return TRUE; + 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_handle_events(GstVaapiSink *sink) +gst_vaapisink_x11_pre_start_event_thread (GstVaapiSink * sink) { - GstVaapiDisplay * const display = GST_VAAPI_PLUGIN_BASE_DISPLAY(sink); - gboolean has_events, do_expose = FALSE; - XEvent e; + GstVaapiDisplayX11 *const display = + GST_VAAPI_DISPLAY_X11 (GST_VAAPI_PLUGIN_BASE_DISPLAY (sink)); - 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; + 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_start_event_thread(GstVaapiSink *sink) +gst_vaapisink_x11_pre_stop_event_thread (GstVaapiSink * sink) { - GstVaapiDisplayX11 * const display = - GST_VAAPI_DISPLAY_X11(GST_VAAPI_PLUGIN_BASE_DISPLAY(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; + 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) +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_put_surface, + 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_put_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; + .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 @@ -393,27 +391,27 @@ gst_vaapisink_backend_x11(void) #include static gboolean -gst_vaapisink_wayland_create_window(GstVaapiSink *sink, guint width, +gst_vaapisink_wayland_create_window (GstVaapiSink * sink, guint width, guint height) { - GstVaapiDisplay * const display = GST_VAAPI_PLUGIN_BASE_DISPLAY(sink); + GstVaapiDisplay *const display = GST_VAAPI_PLUGIN_BASE_DISPLAY (sink); - g_return_val_if_fail(sink->window == NULL, FALSE); + 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; + 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) +gst_vaapisink_backend_wayland (void) { - static const GstVaapiSinkBackend GstVaapiSinkBackendWayland = { - .create_window = gst_vaapisink_wayland_create_window, - .render_surface = gst_vaapisink_put_surface, - }; - return &GstVaapiSinkBackendWayland; + static const GstVaapiSinkBackend GstVaapiSinkBackendWayland = { + .create_window = gst_vaapisink_wayland_create_window, + .render_surface = gst_vaapisink_put_surface, + }; + return &GstVaapiSinkBackendWayland; } #endif @@ -422,941 +420,900 @@ gst_vaapisink_backend_wayland(void) /* ------------------------------------------------------------------------ */ static void -gst_vaapisink_video_overlay_set_window_handle(GstVideoOverlay *overlay, +gst_vaapisink_video_overlay_set_window_handle (GstVideoOverlay * overlay, guintptr window) { - GstVaapiSink * const sink = GST_VAAPISINK(overlay); - const GstVaapiSinkBackend * const backend = sink->backend; - GstVaapiDisplayType display_type; + GstVaapiSink *const sink = GST_VAAPISINK (overlay); + const GstVaapiSinkBackend *const backend = sink->backend; + GstVaapiDisplayType display_type; - if (!gst_vaapisink_ensure_display(sink)) - return; + if (!gst_vaapisink_ensure_display (sink)) + return; - display_type = GST_VAAPI_PLUGIN_BASE_DISPLAY_TYPE(sink); + 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); - } + /* 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 (backend->create_window_from_handle) - backend->create_window_from_handle(sink, window); + sink->foreign_window = TRUE; + if (backend->create_window_from_handle) + 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 -) +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; + 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); + 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 gboolean -gst_vaapisink_reconfigure_window(GstVaapiSink * sink) +gst_vaapisink_reconfigure_window (GstVaapiSink * sink) { - guint win_width, win_height; + 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; + 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_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); + 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_video_overlay_expose(GstVideoOverlay *overlay) +gst_vaapisink_video_overlay_expose (GstVideoOverlay * overlay) { - GstVaapiSink * const sink = GST_VAAPISINK(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); - } + 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_set_event_handling(GstVideoOverlay *overlay, +gst_vaapisink_set_event_handling (GstVideoOverlay * overlay, gboolean handle_events) { - GThread *thread = NULL; - GstVaapiSink * const sink = GST_VAAPISINK(overlay); + GThread *thread = NULL; + GstVaapiSink *const sink = GST_VAAPISINK (overlay); - if (!sink->backend->event_thread_needed) - return; + if (!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); + 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); + 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); + /* 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"); - } + /* Wait for our event thread to finish */ + if (thread) { + g_thread_join (thread); + GST_DEBUG ("xevent thread stopped"); + } } static void -gst_vaapisink_video_overlay_iface_init(GstVideoOverlayInterface *iface) +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_set_event_handling; + 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_set_event_handling; } static void -gst_vaapisink_destroy(GstVaapiSink *sink) +gst_vaapisink_destroy (GstVaapiSink * sink) { - gst_vaapisink_set_event_handling(GST_VIDEO_OVERLAY(sink), FALSE); + gst_vaapisink_set_event_handling (GST_VIDEO_OVERLAY (sink), FALSE); - gst_buffer_replace(&sink->video_buffer, NULL); - gst_caps_replace(&sink->caps, NULL); + gst_buffer_replace (&sink->video_buffer, NULL); + gst_caps_replace (&sink->caps, NULL); } static const gchar * -get_display_type_name(GstVaapiDisplayType display_type) +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); + 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 ""; + if (e) + return e->value_name; + return ""; } -static inline gboolean -gst_vaapisink_ensure_display(GstVaapiSink *sink) +static gboolean +gst_vaapisink_ensure_display (GstVaapiSink * sink) { - return gst_vaapi_plugin_base_ensure_display(GST_VAAPI_PLUGIN_BASE(sink)); + return gst_vaapi_plugin_base_ensure_display (GST_VAAPI_PLUGIN_BASE (sink)); } static void -gst_vaapisink_display_changed(GstVaapiPluginBase *plugin) +gst_vaapisink_display_changed (GstVaapiPluginBase * plugin) { - GstVaapiSink * const sink = GST_VAAPISINK(plugin); - GstVaapiRenderMode render_mode; + GstVaapiSink *const sink = GST_VAAPISINK (plugin); + GstVaapiRenderMode render_mode; - GST_INFO("created %s %p", get_display_type_name(plugin->display_type), - plugin->display); + GST_INFO ("created %s %p", get_display_type_name (plugin->display_type), + plugin->display); - switch (GST_VAAPI_PLUGIN_BASE_DISPLAY_TYPE(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; + sink->backend = gst_vaapisink_backend_drm (); + break; #endif #if USE_X11 case GST_VAAPI_DISPLAY_TYPE_X11: - sink->backend = gst_vaapisink_backend_x11(); - break; + sink->backend = gst_vaapisink_backend_x11 (); + break; #endif #if USE_GLX case GST_VAAPI_DISPLAY_TYPE_GLX: - sink->backend = gst_vaapisink_backend_x11(); - break; + sink->backend = gst_vaapisink_backend_x11 (); + break; #endif #if USE_WAYLAND case GST_VAAPI_DISPLAY_TYPE_WAYLAND: - sink->backend = gst_vaapisink_backend_wayland(); - break; + sink->backend = gst_vaapisink_backend_wayland (); + break; #endif default: - GST_ERROR("failed to initialize GstVaapiSink backend"); - g_assert_not_reached(); - break; - } + GST_ERROR ("failed to initialize GstVaapiSink backend"); + g_assert_not_reached (); + break; + } - 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_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); + sink->use_rotation = gst_vaapi_display_has_property (plugin->display, + GST_VAAPI_DISPLAY_PROP_ROTATION); } static gboolean -gst_vaapisink_ensure_uploader(GstVaapiSink *sink) +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; + 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) +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; + 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 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 void -gst_vaapisink_ensure_window_size(GstVaapiSink *sink, guint *pwidth, guint *pheight) +gst_vaapisink_ensure_window_size (GstVaapiSink * sink, guint * pwidth, + guint * pheight) { - 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; + 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) { - *pwidth = sink->window_width; - *pheight = sink->window_height; - return; - } + if (sink->foreign_window) { + *pwidth = sink->window_width; + *pheight = sink->window_height; + return; + } - gst_vaapi_display_get_size(display, &display_width, &display_height); - if (sink->fullscreen) { - *pwidth = display_width; - *pheight = display_height; - return; - } + gst_vaapi_display_get_size (display, &display_width, &display_height); + if (sink->fullscreen) { + *pwidth = display_width; + *pheight = display_height; + return; + } - gst_vaapi_display_get_pixel_aspect_ratio( - display, - &display_par_n, &display_par_d - ); + 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; - } + 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); - *pwidth = out_rect.w; - *pheight = out_rect.h; + 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); + *pwidth = out_rect.w; + *pheight = out_rect.h; } static inline gboolean -gst_vaapisink_ensure_window(GstVaapiSink *sink, guint width, guint height) +gst_vaapisink_ensure_window (GstVaapiSink * sink, guint width, guint height) { - return sink->window || sink->backend->create_window(sink, width, height); + return sink->window || sink->backend->create_window (sink, width, height); } static gboolean -gst_vaapisink_ensure_rotation(GstVaapiSink *sink, gboolean recalc_display_rect) +gst_vaapisink_ensure_rotation (GstVaapiSink * sink, + gboolean recalc_display_rect) { - GstVaapiDisplay * const display = GST_VAAPI_PLUGIN_BASE_DISPLAY(sink); - gboolean success = FALSE; + GstVaapiDisplay *const display = GST_VAAPI_PLUGIN_BASE_DISPLAY (sink); + gboolean success = FALSE; - g_return_val_if_fail(display, FALSE); + g_return_val_if_fail (display, FALSE); - if (sink->rotation == sink->rotation_req) - return TRUE; + if (sink->rotation == sink->rotation_req) + return TRUE; - if (!sink->use_rotation) { - GST_WARNING("VA display does not support rotation"); - goto end; - } + 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; - } + 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 (((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; + 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; + sink->rotation = sink->rotation_req; + return success; } static gboolean -gst_vaapisink_start(GstBaseSink *base_sink) +gst_vaapisink_start (GstBaseSink * base_sink) { - GstVaapiSink * const sink = GST_VAAPISINK(base_sink); + GstVaapiSink *const sink = GST_VAAPISINK (base_sink); - if (!gst_vaapi_plugin_base_open(GST_VAAPI_PLUGIN_BASE(sink))) - return FALSE; - return gst_vaapisink_ensure_uploader(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) +gst_vaapisink_stop (GstBaseSink * base_sink) { - GstVaapiSink * const sink = GST_VAAPISINK(base_sink); + GstVaapiSink *const sink = GST_VAAPISINK (base_sink); - gst_buffer_replace(&sink->video_buffer, NULL); - gst_vaapi_window_replace(&sink->window, NULL); + 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; + gst_vaapi_plugin_base_close (GST_VAAPI_PLUGIN_BASE (sink)); + return TRUE; } static GstCaps * -gst_vaapisink_get_caps_impl(GstBaseSink *base_sink) +gst_vaapisink_get_caps_impl (GstBaseSink * base_sink) { - GstVaapiSink * const sink = GST_VAAPISINK(base_sink); - GstCaps *out_caps, *yuv_caps; + GstVaapiSink *const sink = GST_VAAPISINK (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); + out_caps = gst_static_pad_template_get_caps (&gst_vaapisink_sink_factory); #else - out_caps = gst_caps_from_string(GST_VAAPI_SURFACE_CAPS); + out_caps = gst_caps_from_string (GST_VAAPI_SURFACE_CAPS); #endif - if (!out_caps) - return NULL; + 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)); - } + 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; + } + return out_caps; } #if GST_CHECK_VERSION(1,0,0) static inline GstCaps * -gst_vaapisink_get_caps(GstBaseSink *base_sink, GstCaps *filter) +gst_vaapisink_get_caps (GstBaseSink * base_sink, GstCaps * filter) { - GstCaps *caps, *out_caps; + 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; + 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) +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; + 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)); + GST_DEBUG ("colorimetry %s", gst_video_colorimetry_to_string (cinfo)); #endif } static gboolean -gst_vaapisink_set_caps(GstBaseSink *base_sink, GstCaps *caps) +gst_vaapisink_set_caps (GstBaseSink * base_sink, GstCaps * caps) { - GstVaapiPluginBase * const plugin = GST_VAAPI_PLUGIN_BASE(base_sink); - GstVaapiSink * const sink = GST_VAAPISINK(base_sink); - GstVideoInfo * const vip = GST_VAAPI_PLUGIN_BASE_SINK_PAD_INFO(sink); - GstVaapiDisplay *display; - guint win_width, win_height; + GstVaapiPluginBase *const plugin = GST_VAAPI_PLUGIN_BASE (base_sink); + GstVaapiSink *const sink = GST_VAAPISINK (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_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_DISPLAY_TYPE (sink) == GST_VAAPI_DISPLAY_TYPE_DRM) + return TRUE; - if (!gst_vaapi_plugin_base_set_caps(plugin, caps, NULL)) - return FALSE; + 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); + 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); + update_colorimetry (sink, &vip->colorimetry); + gst_caps_replace (&sink->caps, caps); - gst_vaapisink_ensure_rotation(sink, FALSE); + 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(GST_VIDEO_OVERLAY(sink), sink->handle_events); - } - sink->window_width = win_width; - sink->window_height = win_height; - GST_DEBUG("window size %ux%u", win_width, win_height); + 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 (GST_VIDEO_OVERLAY (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); + return gst_vaapisink_ensure_render_rect (sink, win_width, win_height); } static inline gboolean -gst_vaapisink_put_surface( - GstVaapiSink *sink, - GstVaapiSurface *surface, - const GstVaapiRectangle *surface_rect, - guint flags -) +gst_vaapisink_put_surface (GstVaapiSink * sink, + GstVaapiSurface * surface, + const GstVaapiRectangle * surface_rect, guint flags) { - if (!sink->window) - return FALSE; + if (!sink->window) + return FALSE; - if (!gst_vaapi_window_put_surface(sink->window, surface, - surface_rect, &sink->display_rect, flags)) { - GST_DEBUG("could not render VA surface"); - return FALSE; - } - return TRUE; + if (!gst_vaapi_window_put_surface (sink->window, surface, + surface_rect, &sink->display_rect, flags)) { + GST_DEBUG ("could not render VA surface"); + return FALSE; + } + return TRUE; } static GstFlowReturn -gst_vaapisink_show_frame_unlocked(GstVaapiSink *sink, GstBuffer *src_buffer) +gst_vaapisink_show_frame_unlocked (GstVaapiSink * sink, GstBuffer * src_buffer) { - GstVaapiVideoMeta *meta; - GstVaapiSurfaceProxy *proxy; - GstVaapiSurface *surface; - GstBuffer *buffer; - guint flags; - GstVaapiRectangle *surface_rect = NULL; + GstVaapiVideoMeta *meta; + GstVaapiSurfaceProxy *proxy; + GstVaapiSurface *surface; + GstBuffer *buffer; + guint flags; + GstVaapiRectangle *surface_rect = NULL; #if GST_CHECK_VERSION(1,0,0) - GstVaapiRectangle tmp_rect; + GstVaapiRectangle tmp_rect; #endif - GstFlowReturn ret; - gint32 view_id; + 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; - } + 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; + 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)); + meta = gst_buffer_get_vaapi_video_meta (buffer); + GST_VAAPI_PLUGIN_BASE_DISPLAY_REPLACE (sink, + gst_vaapi_video_meta_get_display (meta)); - gst_vaapisink_ensure_rotation(sink, TRUE); + gst_vaapisink_ensure_rotation (sink, TRUE); - proxy = gst_vaapi_video_meta_get_surface_proxy(meta); - if (!proxy) - goto error; + proxy = gst_vaapi_video_meta_get_surface_proxy (meta); + if (!proxy) + goto error; - /* Valide 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; - } - - surface = gst_vaapi_video_meta_get_surface(meta); - if (!surface) - goto error; - - 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); + /* Valide 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; + } + + surface = gst_vaapi_video_meta_get_surface (meta); + if (!surface) + goto error; + + 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; + gst_buffer_unref (buffer); + return GST_FLOW_EOS; } static GstFlowReturn -gst_vaapisink_show_frame(GstBaseSink *base_sink, GstBuffer *src_buffer) +gst_vaapisink_show_frame (GstBaseSink * base_sink, GstBuffer * src_buffer) { - GstVaapiSink * const sink = GST_VAAPISINK(base_sink); - GstFlowReturn ret; + GstVaapiSink *const sink = GST_VAAPISINK (base_sink); + GstFlowReturn ret; - /* At least we need at least to protect the _set_subpictures_() - * call to prevent a race during subpicture desctruction. - * FIXME: Could use a less coarse grained lock, 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; + /* At least we need at least to protect the _set_subpictures_() + * call to prevent a race during subpicture desctruction. + * FIXME: Could use a less coarse grained lock, 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) +gst_vaapisink_propose_allocation (GstBaseSink * base_sink, GstQuery * query) { - GstVaapiPluginBase * const plugin = GST_VAAPI_PLUGIN_BASE(base_sink); + GstVaapiPluginBase *const plugin = GST_VAAPI_PLUGIN_BASE (base_sink); - if (!gst_vaapi_plugin_base_propose_allocation(plugin, query)) - return FALSE; + 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); + 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 (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; -} -#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(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); + return GST_BASE_SINK_CLASS (gst_vaapisink_parent_class)->query (base_sink, + query); } static void -gst_vaapisink_finalize(GObject *object) +gst_vaapisink_finalize (GObject * object) { - gst_vaapisink_destroy(GST_VAAPISINK(object)); + gst_vaapisink_destroy (GST_VAAPISINK (object)); - gst_vaapi_plugin_base_finalize(GST_VAAPI_PLUGIN_BASE(object)); - G_OBJECT_CLASS(gst_vaapisink_parent_class)->finalize(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 -) +gst_vaapisink_set_property (GObject * object, + guint prop_id, const GValue * value, GParamSpec * pspec) { - GstVaapiSink * const sink = GST_VAAPISINK(object); + GstVaapiSink *const sink = GST_VAAPISINK (object); - switch (prop_id) { + 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; + 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; + 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; + sink->fullscreen = g_value_get_boolean (value); + break; case PROP_VIEW_ID: - sink->view_id = g_value_get_int(value); - break; + sink->view_id = g_value_get_int (value); + break; case PROP_ROTATION: - sink->rotation_req = g_value_get_enum(value); - break; + sink->rotation_req = g_value_get_enum (value); + break; case PROP_FORCE_ASPECT_RATIO: - sink->keep_aspect = g_value_get_boolean(value); - break; + sink->keep_aspect = g_value_get_boolean (value); + break; default: - G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec); - break; - } + 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 -) +gst_vaapisink_get_property (GObject * object, + guint prop_id, GValue * value, GParamSpec * pspec) { - GstVaapiSink * const sink = GST_VAAPISINK(object); + GstVaapiSink *const sink = GST_VAAPISINK (object); - switch (prop_id) { + switch (prop_id) { case PROP_DISPLAY_TYPE: - g_value_set_enum(value, GST_VAAPI_PLUGIN_BASE_DISPLAY_TYPE(sink)); - break; + 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; + g_value_set_string (value, GST_VAAPI_PLUGIN_BASE_DISPLAY_NAME (sink)); + break; case PROP_FULLSCREEN: - g_value_set_boolean(value, sink->fullscreen); - break; + g_value_set_boolean (value, sink->fullscreen); + break; case PROP_VIEW_ID: - g_value_set_int(value, sink->view_id); - break; + g_value_set_int (value, sink->view_id); + break; case PROP_ROTATION: - g_value_set_enum(value, sink->rotation); - break; + g_value_set_enum (value, sink->rotation); + break; case PROP_FORCE_ASPECT_RATIO: - g_value_set_boolean(value, sink->keep_aspect); - break; + g_value_set_boolean (value, sink->keep_aspect); + break; default: - G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec); - break; - } + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } } static void -gst_vaapisink_set_bus(GstElement *element, GstBus *bus) +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(element)); + /* 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 (element)); - GST_ELEMENT_CLASS(gst_vaapisink_parent_class)->set_bus(element, bus); + GST_ELEMENT_CLASS (gst_vaapisink_parent_class)->set_bus (element, bus); } static void -gst_vaapisink_class_init(GstVaapiSinkClass *klass) +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; + 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_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; + 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; + 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; + 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; + basesink_class->propose_allocation = gst_vaapisink_propose_allocation; #else - basesink_class->buffer_alloc = gst_vaapisink_buffer_alloc; + 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 "); + 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); + pad_template = gst_static_pad_template_get (&gst_vaapisink_sink_factory); + gst_element_class_add_pad_template (element_class, pad_template); - g_object_class_install_property - (object_class, - 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)); + g_object_class_install_property (object_class, + 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)); - g_object_class_install_property - (object_class, - PROP_DISPLAY_NAME, - g_param_spec_string("display-name", - "display name", - "display name to use", - NULL, - G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); + g_object_class_install_property (object_class, + PROP_DISPLAY_NAME, + g_param_spec_string ("display-name", + "display name", + "display name to use", + NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); - g_object_class_install_property - (object_class, - PROP_FULLSCREEN, - g_param_spec_boolean("fullscreen", - "Fullscreen", - "Requests window in fullscreen state", - FALSE, - G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); + g_object_class_install_property (object_class, + 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_object_class_install_property - (object_class, - 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:rotation: + * + * The VA display rotation mode, expressed as a #GstVaapiRotation. + */ + g_object_class_install_property (object_class, + 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_object_class_install_property - (object_class, - 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:force-aspect-ratio: + * + * When enabled, scaling respects video aspect ratio; when disabled, + * the video is distorted to fit the window. + */ + g_object_class_install_property (object_class, + 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_object_class_install_property - (object_class, - 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)); + /** + * 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_object_class_install_property (object_class, + 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)); } static void -gst_vaapisink_init(GstVaapiSink *sink) +gst_vaapisink_init (GstVaapiSink * sink) { - GstVaapiPluginBase * const plugin = GST_VAAPI_PLUGIN_BASE(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); + gst_vaapi_plugin_base_init (plugin, GST_CAT_DEFAULT); + gst_vaapi_plugin_base_set_display_type (plugin, DEFAULT_DISPLAY_TYPE); - sink->caps = NULL; - sink->window = NULL; - sink->window_width = 0; - sink->window_height = 0; - sink->video_buffer = NULL; - sink->video_width = 0; - sink->video_height = 0; - sink->video_par_n = 1; - sink->video_par_d = 1; - sink->view_id = -1; - sink->handle_events = TRUE; - sink->foreign_window = FALSE; - sink->fullscreen = FALSE; - sink->rotation = DEFAULT_ROTATION; - sink->rotation_req = DEFAULT_ROTATION; - sink->use_overlay = FALSE; - sink->use_rotation = FALSE; - sink->keep_aspect = TRUE; - gst_video_info_init(&sink->video_info); + sink->caps = NULL; + sink->window = NULL; + sink->window_width = 0; + sink->window_height = 0; + sink->video_buffer = NULL; + sink->video_width = 0; + sink->video_height = 0; + sink->video_par_n = 1; + sink->video_par_d = 1; + sink->view_id = -1; + sink->handle_events = TRUE; + sink->foreign_window = FALSE; + sink->fullscreen = FALSE; + sink->rotation = DEFAULT_ROTATION; + sink->rotation_req = DEFAULT_ROTATION; + sink->use_overlay = FALSE; + sink->use_rotation = FALSE; + sink->keep_aspect = TRUE; + gst_video_info_init (&sink->video_info); } diff --git a/gst/vaapi/gstvaapisink.h b/gst/vaapi/gstvaapisink.h index f55dbf53db..573f168360 100644 --- a/gst/vaapi/gstvaapisink.h +++ b/gst/vaapi/gstvaapisink.h @@ -20,7 +20,7 @@ * License along with this library; if not, write to the Free * Software Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301 USA -*/ + */ #ifndef GST_VAAPISINK_H #define GST_VAAPISINK_H @@ -32,93 +32,86 @@ G_BEGIN_DECLS #define GST_TYPE_VAAPISINK \ - (gst_vaapisink_get_type()) - -#define GST_VAAPISINK(obj) \ - (G_TYPE_CHECK_INSTANCE_CAST((obj), \ - GST_TYPE_VAAPISINK, \ - GstVaapiSink)) - -#define GST_VAAPISINK_CLASS(klass) \ - (G_TYPE_CHECK_CLASS_CAST((klass), \ - GST_TYPE_VAAPISINK, \ - GstVaapiSinkClass)) - + (gst_vaapisink_get_type ()) +#define GST_VAAPISINK(obj) \ + (G_TYPE_CHECK_INSTANCE_CAST ((obj), GST_TYPE_VAAPISINK, GstVaapiSink)) +#define GST_VAAPISINK_CLASS(klass) \ + (G_TYPE_CHECK_CLASS_CAST ((klass), GST_TYPE_VAAPISINK, GstVaapiSinkClass)) #define GST_IS_VAAPISINK(obj) \ - (G_TYPE_CHECK_INSTANCE_TYPE((obj), GST_TYPE_VAAPISINK)) - + (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GST_TYPE_VAAPISINK)) #define GST_IS_VAAPISINK_CLASS(klass) \ - (G_TYPE_CHECK_CLASS_TYPE((klass), GST_TYPE_VAAPISINK)) - -#define GST_VAAPISINK_GET_CLASS(obj) \ - (G_TYPE_INSTANCE_GET_CLASS((obj), \ - GST_TYPE_VAAPISINK, \ - GstVaapiSinkClass)) + (G_TYPE_CHECK_CLASS_TYPE ((klass), GST_TYPE_VAAPISINK)) +#define GST_VAAPISINK_GET_CLASS(obj) \ + (G_TYPE_INSTANCE_GET_CLASS ((obj), GST_TYPE_VAAPISINK, GstVaapiSinkClass)) typedef struct _GstVaapiSink GstVaapiSink; typedef struct _GstVaapiSinkClass GstVaapiSinkClass; typedef struct _GstVaapiSinkBackend GstVaapiSinkBackend; -typedef gboolean (*GstVaapiSinkCreateWindowFunc)(GstVaapiSink *sink, +typedef gboolean (*GstVaapiSinkCreateWindowFunc) (GstVaapiSink * sink, guint width, guint height); -typedef gboolean (*GstVaapiSinkCreateWindowFromHandleFunc)(GstVaapiSink *sink, +typedef gboolean (*GstVaapiSinkCreateWindowFromHandleFunc) (GstVaapiSink * sink, guintptr window); -typedef gboolean (*GstVaapiSinkRenderSurfaceFunc)(GstVaapiSink *sink, - GstVaapiSurface *surface, const GstVaapiRectangle *surface_rect, guint flags); -typedef gboolean (*GstVaapiSinkHandleEventsFunc)(GstVaapiSink *sink); -typedef gboolean (*GstVaapiSinkPreStartEventThreadFunc)(GstVaapiSink *sink); -typedef gboolean (*GstVaapiSinkPreStopEventThreadFunc)(GstVaapiSink *sink); +typedef gboolean (*GstVaapiSinkRenderSurfaceFunc) (GstVaapiSink * sink, + GstVaapiSurface * surface, const GstVaapiRectangle * surface_rect, + guint flags); +typedef gboolean (*GstVaapiSinkHandleEventsFunc) (GstVaapiSink * sink); +typedef gboolean (*GstVaapiSinkPreStartEventThreadFunc) (GstVaapiSink * sink); +typedef gboolean (*GstVaapiSinkPreStopEventThreadFunc) (GstVaapiSink * sink); -struct _GstVaapiSinkBackend { - GstVaapiSinkCreateWindowFunc create_window; - GstVaapiSinkCreateWindowFromHandleFunc create_window_from_handle; - GstVaapiSinkRenderSurfaceFunc render_surface; +struct _GstVaapiSinkBackend +{ + GstVaapiSinkCreateWindowFunc create_window; + GstVaapiSinkCreateWindowFromHandleFunc create_window_from_handle; + GstVaapiSinkRenderSurfaceFunc render_surface; - /* Event threads handling */ - gboolean event_thread_needed; - GstVaapiSinkHandleEventsFunc handle_events; - GstVaapiSinkPreStartEventThreadFunc pre_start_event_thread; - GstVaapiSinkPreStopEventThreadFunc pre_stop_event_thread; + /* Event threads handling */ + gboolean event_thread_needed; + GstVaapiSinkHandleEventsFunc handle_events; + GstVaapiSinkPreStartEventThreadFunc pre_start_event_thread; + GstVaapiSinkPreStopEventThreadFunc pre_stop_event_thread; }; -struct _GstVaapiSink { - /*< private >*/ - GstVaapiPluginBase parent_instance; +struct _GstVaapiSink +{ + /*< private >*/ + GstVaapiPluginBase parent_instance; - const GstVaapiSinkBackend *backend; + const GstVaapiSinkBackend *backend; - GstCaps *caps; - GstVaapiWindow *window; - guint window_width; - guint window_height; - GstBuffer *video_buffer; - guint video_width; - guint video_height; - gint video_par_n; - gint video_par_d; - GstVideoInfo video_info; - GstVaapiRectangle display_rect; - GstVaapiRotation rotation; - GstVaapiRotation rotation_req; - guint color_standard; - gint32 view_id; - GThread *event_thread; - volatile gboolean event_thread_cancel; - guint handle_events : 1; - guint foreign_window : 1; - guint fullscreen : 1; - guint use_overlay : 1; - guint use_rotation : 1; - guint keep_aspect : 1; + GstCaps *caps; + GstVaapiWindow *window; + guint window_width; + guint window_height; + GstBuffer *video_buffer; + guint video_width; + guint video_height; + gint video_par_n; + gint video_par_d; + GstVideoInfo video_info; + GstVaapiRectangle display_rect; + GstVaapiRotation rotation; + GstVaapiRotation rotation_req; + guint color_standard; + gint32 view_id; + GThread *event_thread; + volatile gboolean event_thread_cancel; + guint handle_events : 1; + guint foreign_window : 1; + guint fullscreen : 1; + guint use_overlay : 1; + guint use_rotation : 1; + guint keep_aspect : 1; }; -struct _GstVaapiSinkClass { - /*< private >*/ - GstVaapiPluginBaseClass parent_class; +struct _GstVaapiSinkClass +{ + /*< private >*/ + GstVaapiPluginBaseClass parent_class; }; GType -gst_vaapisink_get_type(void) G_GNUC_CONST; +gst_vaapisink_get_type (void) G_GNUC_CONST; G_END_DECLS