* gstvaapisink.c - VA-API video sink
*
* Copyright (C) 2010-2011 Splitted-Desktop Systems
- * Copyright (C) 2011-2013 Intel Corporation
+ * Author: Gwenole Beauchesne <gwenole.beauchesne@splitted-desktop.com>
+ * Copyright (C) 2011-2014 Intel Corporation
+ * Author: Gwenole Beauchesne <gwenole.beauchesne@intel.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public License
#include "gstvaapisink.h"
#include "gstvaapipluginutil.h"
-#include "gstvaapivideocontext.h"
#include "gstvaapivideometa.h"
#if GST_CHECK_VERSION(1,0,0)
#include "gstvaapivideobufferpool.h"
/* 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
"height = (int) [ 1, MAX ]; "
#endif
GST_VAAPI_SURFACE_CAPS;
+#endif
static GstStaticPadTemplate gst_vaapisink_sink_factory =
GST_STATIC_PAD_TEMPLATE(
GST_PAD_ALWAYS,
GST_STATIC_CAPS(gst_vaapisink_sink_caps_str));
-/* GstImplementsInterface interface */
-#if !GST_CHECK_VERSION(1,0,0)
static gboolean
-gst_vaapisink_implements_interface_supported(
- GstImplementsInterface *iface,
- GType type
-)
-{
- return (type == GST_TYPE_VIDEO_CONTEXT ||
- type == GST_TYPE_VIDEO_OVERLAY);
-}
-
-static void
-gst_vaapisink_implements_iface_init(GstImplementsInterfaceClass *iface)
-{
- iface->supported = gst_vaapisink_implements_interface_supported;
-}
-#endif
-
-/* GstVideoContext interface */
-#if !GST_CHECK_VERSION(1,1,0)
-static void
-gst_vaapisink_set_video_context(GstVideoContext *context, const gchar *type,
- const GValue *value)
+gst_vaapisink_has_interface(GstVaapiPluginBase *plugin, GType type)
{
- GstVaapiSink *sink = GST_VAAPISINK (context);
- gst_vaapi_set_display (type, value, &sink->display);
+ return type == GST_TYPE_VIDEO_OVERLAY;
}
static void
-gst_vaapisink_video_context_iface_init(GstVideoContextInterface *iface)
-{
- iface->set_context = gst_vaapisink_set_video_context;
-}
-#endif
-
-static void
gst_vaapisink_video_overlay_iface_init(GstVideoOverlayInterface *iface);
G_DEFINE_TYPE_WITH_CODE(
GstVaapiSink,
gst_vaapisink,
GST_TYPE_VIDEO_SINK,
-#if !GST_CHECK_VERSION(1,0,0)
- G_IMPLEMENT_INTERFACE(GST_TYPE_IMPLEMENTS_INTERFACE,
- gst_vaapisink_implements_iface_init);
-#endif
-#if !GST_CHECK_VERSION(1,1,0)
- G_IMPLEMENT_INTERFACE(GST_TYPE_VIDEO_CONTEXT,
- gst_vaapisink_video_context_iface_init);
-#endif
+ GST_VAAPI_PLUGIN_BASE_INIT_INTERFACES
G_IMPLEMENT_INTERFACE(GST_TYPE_VIDEO_OVERLAY,
gst_vaapisink_video_overlay_iface_init))
PROP_0,
PROP_DISPLAY_TYPE,
+ PROP_DISPLAY_NAME,
PROP_FULLSCREEN,
PROP_SYNCHRONOUS,
PROP_USE_GLX,
#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);
+
/* GstVideoOverlay interface */
#if USE_X11
gst_vaapisink_show_frame(GstBaseSink *base_sink, GstBuffer *buffer);
static void
-gst_vaapisink_video_overlay_set_window_handle(GstVideoOverlay *overlay, guintptr window)
+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 (sink->display_type == GST_VAAPI_DISPLAY_TYPE_GLX)
- sink->display_type = GST_VAAPI_DISPLAY_TYPE_X11;
+ 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;
- switch (sink->display_type) {
+ switch (display_type) {
#if USE_X11
case GST_VAAPI_DISPLAY_TYPE_X11:
gst_vaapisink_ensure_window_xid(sink, window);
gst_vaapisink_video_overlay_expose(GstVideoOverlay *overlay)
{
GstVaapiSink * const sink = GST_VAAPISINK(overlay);
- GstBaseSink * const base_sink = GST_BASE_SINK(overlay);
- GstBuffer *buffer;
- if (sink->use_overlay)
- buffer = sink->video_buffer ? gst_buffer_ref(sink->video_buffer) : NULL;
- else {
-#if GST_CHECK_VERSION(1,0,0)
- GstSample * const sample = gst_base_sink_get_last_sample(base_sink);
- if (!sample)
- return;
- buffer = gst_buffer_ref(gst_sample_get_buffer(sample));
- gst_sample_unref(sample);
-#else
- buffer = gst_base_sink_get_last_buffer(base_sink);
-#endif
- }
- if (buffer) {
- gst_vaapisink_show_frame(base_sink, buffer);
- gst_buffer_unref(buffer);
- }
+ if (sink->video_buffer)
+ gst_vaapisink_show_frame(GST_BASE_SINK_CAST(sink),
+ gst_buffer_ref(sink->video_buffer));
}
static void
#if USE_GLX
gst_vaapi_texture_replace(&sink->texture, NULL);
#endif
- gst_vaapi_display_replace(&sink->display, NULL);
- g_clear_object(&sink->uploader);
-
gst_caps_replace(&sink->caps, NULL);
}
guint height
)
{
+ GstVaapiDisplayX11 * const display =
+ GST_VAAPI_DISPLAY_X11(GST_VAAPI_PLUGIN_BASE_DISPLAY(sink));
ConfigureNotifyEventPendingArgs args;
XEvent xev;
/* XXX: don't use XPeekIfEvent() because it might block */
XCheckIfEvent(
- gst_vaapi_display_x11_get_display(GST_VAAPI_DISPLAY_X11(sink->display)),
+ gst_vaapi_display_x11_get_display(display),
&xev,
configure_notify_event_pending_cb, (XPointer)&args
);
static inline gboolean
gst_vaapisink_ensure_display(GstVaapiSink *sink)
{
- GstVaapiDisplayType display_type;
- GstVaapiRenderMode render_mode;
- const gboolean had_display = sink->display != NULL;
+ return gst_vaapi_plugin_base_ensure_display(GST_VAAPI_PLUGIN_BASE(sink));
+}
- if (!gst_vaapi_ensure_display(sink, sink->display_type, &sink->display))
- return FALSE;
+static void
+gst_vaapisink_display_changed(GstVaapiPluginBase *plugin)
+{
+ GstVaapiSink * const sink = GST_VAAPISINK(plugin);
+ GstVaapiRenderMode render_mode;
- display_type = gst_vaapi_display_get_display_type(sink->display);
- if (display_type != sink->display_type || (!had_display && sink->display)) {
- GST_INFO("created %s %p", get_display_type_name(display_type),
- sink->display);
- sink->display_type = display_type;
+ GST_INFO("created %s %p", get_display_type_name(plugin->display_type),
+ plugin->display);
- sink->use_overlay =
- gst_vaapi_display_get_render_mode(sink->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(
- sink->display, GST_VAAPI_DISPLAY_PROP_ROTATION);
- }
- return TRUE;
+ sink->use_rotation = gst_vaapi_display_has_property(plugin->display,
+ GST_VAAPI_DISPLAY_PROP_ROTATION);
}
static gboolean
{
if (!gst_vaapisink_ensure_display(sink))
return FALSE;
-
- if (!sink->uploader) {
- sink->uploader = gst_vaapi_uploader_new(sink->display);
- if (!sink->uploader)
- return FALSE;
- }
+ if (!gst_vaapi_plugin_base_ensure_uploader(GST_VAAPI_PLUGIN_BASE(sink)))
+ return FALSE;
return TRUE;
}
GST_DEBUG("ensure render rect within %ux%u bounds", width, height);
gst_vaapi_display_get_pixel_aspect_ratio(
- sink->display,
+ GST_VAAPI_PLUGIN_BASE_DISPLAY(sink),
&display_par_n, &display_par_d
);
GST_DEBUG("display pixel-aspect-ratio %d/%d",
static void
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;
return;
}
- gst_vaapi_display_get_size(sink->display, &display_width, &display_height);
+ gst_vaapi_display_get_size(display, &display_width, &display_height);
if (sink->fullscreen) {
*pwidth = display_width;
*pheight = display_height;
}
gst_vaapi_display_get_pixel_aspect_ratio(
- sink->display,
+ display,
&display_par_n, &display_par_d
);
static inline gboolean
gst_vaapisink_ensure_window(GstVaapiSink *sink, guint width, guint height)
{
- GstVaapiDisplay * const display = sink->display;
+ GstVaapiDisplay * const display = GST_VAAPI_PLUGIN_BASE_DISPLAY(sink);
if (!sink->window) {
- switch (sink->display_type) {
+ const GstVaapiDisplayType display_type =
+ GST_VAAPI_PLUGIN_BASE_DISPLAY_TYPE(sink);
+ switch (display_type) {
#if USE_GLX
case GST_VAAPI_DISPLAY_TYPE_GLX:
sink->window = gst_vaapi_window_glx_new(display, width, height);
break;
#endif
default:
- GST_ERROR("unsupported display type %d", sink->display_type);
+ GST_ERROR("unsupported display type %d", display_type);
return FALSE;
}
}
static gboolean
gst_vaapisink_ensure_window_xid(GstVaapiSink *sink, guintptr window_id)
{
+ GstVaapiDisplay *display;
Window rootwin;
unsigned int width, height, border_width, depth;
int x, y;
if (!gst_vaapisink_ensure_display(sink))
return FALSE;
+ display = GST_VAAPI_PLUGIN_BASE_DISPLAY(sink);
- gst_vaapi_display_lock(sink->display);
+ gst_vaapi_display_lock(display);
XGetGeometry(
- gst_vaapi_display_x11_get_display(GST_VAAPI_DISPLAY_X11(sink->display)),
+ gst_vaapi_display_x11_get_display(GST_VAAPI_DISPLAY_X11(display)),
xid,
&rootwin,
&x, &y, &width, &height, &border_width, &depth
);
- gst_vaapi_display_unlock(sink->display);
+ gst_vaapi_display_unlock(display);
if ((width != sink->window_width || height != sink->window_height) &&
!configure_notify_event_pending(sink, xid, width, height)) {
gst_vaapi_window_replace(&sink->window, NULL);
- switch (sink->display_type) {
+ switch (GST_VAAPI_PLUGIN_BASE_DISPLAY_TYPE(sink)) {
#if USE_GLX
case GST_VAAPI_DISPLAY_TYPE_GLX:
- sink->window = gst_vaapi_window_glx_new_with_xid(sink->display, xid);
+ sink->window = gst_vaapi_window_glx_new_with_xid(display, xid);
break;
#endif
case GST_VAAPI_DISPLAY_TYPE_X11:
- sink->window = gst_vaapi_window_x11_new_with_xid(sink->display, xid);
+ sink->window = gst_vaapi_window_x11_new_with_xid(display, xid);
break;
default:
- GST_ERROR("unsupported display type %d", sink->display_type);
+ GST_ERROR("unsupported display type %d",
+ GST_VAAPI_PLUGIN_BASE_DISPLAY_TYPE(sink));
return FALSE;
}
return sink->window != NULL;
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(sink->display, FALSE);
+ g_return_val_if_fail(display, FALSE);
if (sink->rotation == sink->rotation_req)
return TRUE;
goto end;
}
- gst_vaapi_display_lock(sink->display);
- success = gst_vaapi_display_set_rotation(sink->display, sink->rotation_req);
- gst_vaapi_display_unlock(sink->display);
+ 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;
}
static gboolean
-gst_vaapisink_ensure_video_buffer_pool(GstVaapiSink *sink, GstCaps *caps)
-{
-#if GST_CHECK_VERSION(1,0,0)
- GstBufferPool *pool;
- GstCaps *pool_caps;
- GstStructure *config;
- GstVideoInfo vi;
- gboolean need_pool;
-
- if (!gst_vaapisink_ensure_display(sink))
- return FALSE;
-
- if (sink->video_buffer_pool) {
- config = gst_buffer_pool_get_config(sink->video_buffer_pool);
- gst_buffer_pool_config_get_params(config, &pool_caps, NULL, NULL, NULL);
- need_pool = !gst_caps_is_equal(caps, pool_caps);
- gst_structure_free(config);
- if (!need_pool)
- return TRUE;
- g_clear_object(&sink->video_buffer_pool);
- sink->video_buffer_size = 0;
- }
-
- pool = gst_vaapi_video_buffer_pool_new(sink->display);
- if (!pool)
- goto error_create_pool;
-
- gst_video_info_init(&vi);
- gst_video_info_from_caps(&vi, caps);
- if (GST_VIDEO_INFO_FORMAT(&vi) == GST_VIDEO_FORMAT_ENCODED) {
- GST_DEBUG("assume video buffer pool format is NV12");
- gst_video_info_set_format(&vi, GST_VIDEO_FORMAT_NV12,
- GST_VIDEO_INFO_WIDTH(&vi), GST_VIDEO_INFO_HEIGHT(&vi));
- }
- sink->video_buffer_size = vi.size;
-
- config = gst_buffer_pool_get_config(pool);
- gst_buffer_pool_config_set_params(config, caps, sink->video_buffer_size,
- 0, 0);
- gst_buffer_pool_config_add_option(config,
- GST_BUFFER_POOL_OPTION_VAAPI_VIDEO_META);
- gst_buffer_pool_config_add_option(config,
- GST_BUFFER_POOL_OPTION_VIDEO_META);
- if (!gst_buffer_pool_set_config(pool, config))
- goto error_pool_config;
- sink->video_buffer_pool = pool;
- return TRUE;
-
- /* ERRORS */
-error_create_pool:
- {
- GST_ERROR("failed to create buffer pool");
- return FALSE;
- }
-error_pool_config:
- {
- GST_ERROR("failed to reset buffer pool config");
- gst_object_unref(pool);
- return FALSE;
- }
-#else
- return TRUE;
-#endif
-}
-
-static gboolean
gst_vaapisink_start(GstBaseSink *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);
}
g_clear_object(&sink->video_buffer_pool);
#endif
gst_vaapi_window_replace(&sink->window, NULL);
- gst_vaapi_display_replace(&sink->display, NULL);
- g_clear_object(&sink->uploader);
+ gst_vaapi_plugin_base_close(GST_VAAPI_PLUGIN_BASE(sink));
return TRUE;
}
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);
+#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_uploader_get_caps(sink->uploader);
- if (yuv_caps)
+ 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;
}
#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(base_sink);
- GstVideoInfo * const vip = &sink->video_info;
+ 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 USE_DRM
- if (sink->display_type == GST_VAAPI_DISPLAY_TYPE_DRM)
+ if (GST_VAAPI_PLUGIN_BASE_DISPLAY_TYPE(sink) == GST_VAAPI_DISPLAY_TYPE_DRM)
return TRUE;
#endif
- if (!gst_vaapisink_ensure_video_buffer_pool(sink, caps))
+ if (!gst_vaapi_plugin_base_set_caps(plugin, caps, NULL))
return FALSE;
- if (!gst_video_info_from_caps(vip, caps))
- return FALSE;
- sink->use_video_raw = GST_VIDEO_INFO_IS_YUV(vip);
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);
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);
- if (!gst_vaapisink_ensure_display(sink))
- return FALSE;
-
-#if !GST_CHECK_VERSION(1,0,0)
- if (sink->use_video_raw) {
- /* Ensure the uploader is set up for upstream allocated buffers */
- if (!gst_vaapi_uploader_ensure_display(sink->uploader, sink->display))
- return FALSE;
- if (!gst_vaapi_uploader_ensure_caps(sink->uploader, caps, NULL))
- return FALSE;
- }
-#endif
-
gst_vaapisink_ensure_rotation(sink, FALSE);
gst_vaapisink_ensure_window_size(sink, &win_width, &win_height);
gst_vaapi_window_set_size(sink->window, win_width, win_height);
}
else {
- gst_vaapi_display_lock(sink->display);
+ gst_vaapi_display_lock(display);
gst_video_overlay_prepare_window_handle(GST_VIDEO_OVERLAY(sink));
- gst_vaapi_display_unlock(sink->display);
+ gst_vaapi_display_unlock(display);
if (sink->window)
return TRUE;
if (!gst_vaapisink_ensure_window(sink, win_width, win_height))
static gboolean
gst_vaapisink_ensure_texture(GstVaapiSink *sink, GstVaapiSurface *surface)
{
+ GstVaapiDisplay * display = GST_VAAPI_PLUGIN_BASE_DISPLAY(sink);
GstVideoRectangle tex_rect, dis_rect, out_rect;
guint width, height;
tex_rect.w = width;
tex_rect.h = height;
- gst_vaapi_display_get_size(sink->display, &width, &height);
+ gst_vaapi_display_get_size(display, &width, &height);
dis_rect.x = 0;
dis_rect.y = 0;
dis_rect.w = width;
height = tex_rect.h;
GST_INFO("texture size %ux%u", width, height);
- sink->texture = gst_vaapi_texture_new(sink->display,
+ sink->texture = gst_vaapi_texture_new(display,
GL_TEXTURE_2D, GL_BGRA, width, height);
return sink->texture != NULL;
}
guint flags
)
{
- GstVaapiWindowGLX * const window = GST_VAAPI_WINDOW_GLX(sink->window);
+ GstVaapiWindowGLX *window;
GLenum target;
GLuint texture;
+ if (!sink->window)
+ return FALSE;
+ window = GST_VAAPI_WINDOW_GLX(sink->window);
+
gst_vaapi_window_glx_make_current(window);
if (!gst_vaapisink_ensure_texture(sink, surface))
goto error_create_texture;
guint flags
)
{
+ 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 TRUE;
}
-#if GST_CHECK_VERSION(1,0,0)
-static GstFlowReturn
-gst_vaapisink_get_render_buffer(GstVaapiSink *sink, GstBuffer *src_buffer,
- GstBuffer **out_buffer_ptr)
-{
- GstVaapiVideoMeta *meta;
- GstBuffer *out_buffer;
- GstBufferPoolAcquireParams params = { 0, };
- GstVideoFrame src_frame, out_frame;
- GstFlowReturn ret;
-
- meta = gst_buffer_get_vaapi_video_meta(src_buffer);
- if (meta) {
- *out_buffer_ptr = gst_buffer_ref(src_buffer);
- return GST_FLOW_OK;
- }
-
- if (!sink->use_video_raw) {
- GST_ERROR("unsupported video buffer");
- return GST_FLOW_EOS;
- }
-
- GST_DEBUG("buffer %p not from our pool, copying", src_buffer);
-
- *out_buffer_ptr = NULL;
- if (!sink->video_buffer_pool)
- goto error_no_pool;
-
- if (!gst_buffer_pool_set_active(sink->video_buffer_pool, TRUE))
- goto error_activate_pool;
-
- params.flags = GST_BUFFER_POOL_ACQUIRE_FLAG_DONTWAIT;
- ret = gst_buffer_pool_acquire_buffer(sink->video_buffer_pool, &out_buffer,
- ¶ms);
- if (ret != GST_FLOW_OK)
- goto error_create_buffer;
-
- if (!gst_video_frame_map(&src_frame, &sink->video_info, src_buffer,
- GST_MAP_READ))
- goto error_map_src_buffer;
-
- if (!gst_video_frame_map(&out_frame, &sink->video_info, out_buffer,
- GST_MAP_WRITE))
- goto error_map_dst_buffer;
-
- gst_video_frame_copy(&out_frame, &src_frame);
- gst_video_frame_unmap(&out_frame);
- gst_video_frame_unmap(&src_frame);
-
- *out_buffer_ptr = out_buffer;
- return GST_FLOW_OK;
-
- /* ERRORS */
-error_no_pool:
- GST_ERROR("no buffer pool was negotiated");
- return GST_FLOW_ERROR;
-error_activate_pool:
- GST_ERROR("failed to activate buffer pool");
- return GST_FLOW_ERROR;
-error_create_buffer:
- GST_WARNING("failed to create image. Skipping this frame");
- return GST_FLOW_OK;
-error_map_dst_buffer:
- gst_video_frame_unmap(&src_frame);
- // fall-through
-error_map_src_buffer:
- GST_WARNING("failed to map buffer. Skipping this frame");
- gst_buffer_unref(out_buffer);
- return GST_FLOW_OK;
-}
-#else
-static GstFlowReturn
-gst_vaapisink_get_render_buffer(GstVaapiSink *sink, GstBuffer *src_buffer,
- GstBuffer **out_buffer_ptr)
-{
- GstVaapiVideoMeta *meta;
- GstBuffer *out_buffer;
-
- *out_buffer_ptr = NULL;
- meta = gst_buffer_get_vaapi_video_meta(src_buffer);
- if (meta)
- out_buffer = gst_buffer_ref(src_buffer);
- else if (sink->use_video_raw) {
- out_buffer = gst_vaapi_uploader_get_buffer(sink->uploader);
- if (!out_buffer)
- goto error_create_buffer;
- }
- else {
- GST_ERROR("unsupported video buffer");
- return GST_FLOW_EOS;
- }
-
- if (sink->use_video_raw &&
- !gst_vaapi_uploader_process(sink->uploader, src_buffer, out_buffer))
- goto error_copy_buffer;
-
- *out_buffer_ptr = out_buffer;
- return GST_FLOW_OK;
-
- /* ERRORS */
-error_create_buffer:
- GST_WARNING("failed to create buffer. Skipping this frame");
- return GST_FLOW_OK;
-error_copy_buffer:
- GST_WARNING("failed to copy buffers. Skipping this frame");
- gst_buffer_unref(out_buffer);
- return GST_FLOW_OK;
-}
-#endif
-
static GstFlowReturn
gst_vaapisink_show_frame(GstBaseSink *base_sink, GstBuffer *src_buffer)
{
}
#endif
- ret = gst_vaapisink_get_render_buffer(sink, src_buffer, &buffer);
- if (ret != GST_FLOW_OK || !buffer)
+ 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);
- if (sink->display != gst_vaapi_video_meta_get_display(meta))
- gst_vaapi_display_replace(&sink->display,
- gst_vaapi_video_meta_get_display(meta));
-
- if (!sink->window)
- goto error;
+ GST_VAAPI_PLUGIN_BASE_DISPLAY_REPLACE(sink,
+ gst_vaapi_video_meta_get_display(meta));
gst_vaapisink_ensure_rotation(sink, TRUE);
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");
- switch (sink->display_type) {
+ switch (GST_VAAPI_PLUGIN_BASE_DISPLAY_TYPE(sink)) {
#if USE_DRM
case GST_VAAPI_DISPLAY_TYPE_DRM:
success = TRUE;
break;
#endif
default:
- GST_ERROR("unsupported display type %d", sink->display_type);
+ GST_ERROR("unsupported display type %d",
+ GST_VAAPI_PLUGIN_BASE_DISPLAY_TYPE(sink));
success = FALSE;
break;
}
goto error;
/* Retain VA surface until the next one is displayed */
- if (sink->use_overlay)
- gst_buffer_replace(&sink->video_buffer, buffer);
+ gst_buffer_replace(&sink->video_buffer, buffer);
gst_buffer_unref(buffer);
return GST_FLOW_OK;
static gboolean
gst_vaapisink_propose_allocation(GstBaseSink *base_sink, GstQuery *query)
{
- GstVaapiSink * const sink = GST_VAAPISINK(base_sink);
- GstCaps *caps = NULL;
- gboolean need_pool;
-
- gst_query_parse_allocation(query, &caps, &need_pool);
+ GstVaapiPluginBase * const plugin = GST_VAAPI_PLUGIN_BASE(base_sink);
- if (need_pool) {
- if (!caps)
- goto error_no_caps;
- if (!gst_vaapisink_ensure_video_buffer_pool(sink, caps))
- return FALSE;
- gst_query_add_allocation_pool(query, sink->video_buffer_pool,
- sink->video_buffer_size, 0, 0);
- }
+ if (!gst_vaapi_plugin_base_propose_allocation(plugin, query))
+ return FALSE;
- gst_query_add_allocation_meta(query,
- GST_VAAPI_VIDEO_META_API_TYPE, NULL);
- gst_query_add_allocation_meta(query,
- GST_VIDEO_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_CROP_META_API_TYPE, NULL);
gst_query_add_allocation_meta(query,
GST_VIDEO_OVERLAY_COMPOSITION_META_API_TYPE, NULL);
return TRUE;
-
- /* ERRORS */
-error_no_caps:
- {
- GST_ERROR("no caps specified");
- return FALSE;
- }
}
#else
static GstFlowReturn
-gst_vaapisink_buffer_alloc(
- GstBaseSink *base_sink,
- guint64 offset,
- guint size,
- GstCaps *caps,
- GstBuffer **pbuf
-)
+gst_vaapisink_buffer_alloc(GstBaseSink *base_sink, guint64 offset, guint size,
+ GstCaps *caps, GstBuffer **outbuf_ptr)
{
- GstVaapiSink * const sink = GST_VAAPISINK(base_sink);
- GstVideoInfo vi;
- GstBuffer *buf;
-
- *pbuf = NULL;
-
- if (!sink->use_video_raw) {
- /* Note: this code path is rarely used but for raw YUV formats
- from custom pipeline. Otherwise, GstBaseSink::set_caps() is
- called first, and GstBaseSink::buffer_alloc() is not called
- in VA surface format mode */
- if (!gst_video_info_from_caps(&vi, caps))
- return GST_FLOW_NOT_SUPPORTED;
- if (!GST_VIDEO_INFO_IS_YUV(&vi))
- return GST_FLOW_OK;
- }
-
- if (!gst_vaapi_uploader_ensure_display(sink->uploader, sink->display))
- return GST_FLOW_NOT_SUPPORTED;
- if (!gst_vaapi_uploader_ensure_caps(sink->uploader, caps, NULL))
- return GST_FLOW_NOT_SUPPORTED;
-
- buf = gst_vaapi_uploader_get_buffer(sink->uploader);
- if (!buf) {
- GST_WARNING("failed to allocate resources for raw YUV buffer");
- return GST_FLOW_NOT_SUPPORTED;
- }
-
- *pbuf = buf;
- return GST_FLOW_OK;
-}
-#endif
-
-#if GST_CHECK_VERSION(1,1,0)
-static void
-gst_vaapisink_set_context(GstElement *element, GstContext *context)
-{
- GstVaapiSink * const sink = GST_VAAPISINK(element);
- GstVaapiDisplay *display = NULL;
-
- if (gst_vaapi_video_context_get_display(context, &display)) {
- GST_INFO_OBJECT(element, "set display %p", display);
- gst_vaapi_display_replace(&sink->display, display);
- }
+ return gst_vaapi_plugin_base_allocate_input_buffer(
+ GST_VAAPI_PLUGIN_BASE(base_sink), caps, outbuf_ptr);
}
#endif
{
GstVaapiSink * const sink = GST_VAAPISINK(base_sink);
- if (gst_vaapi_reply_to_query(query, sink->display)) {
- GST_DEBUG("sharing display %p", sink->display);
- return TRUE;
- }
+ GST_INFO_OBJECT(sink, "query type %s", GST_QUERY_TYPE_NAME(query));
- switch(GST_QUERY_TYPE(query)) {
-#if GST_CHECK_VERSION(1,1,0)
- case GST_QUERY_CONTEXT: {
- const gchar *context_type = NULL;
-
- if (gst_query_parse_context_type(query, &context_type) &&
- !g_strcmp0(context_type, GST_VAAPI_DISPLAY_CONTEXT_TYPE_NAME) &&
- sink->display) {
- GstContext *context;
-
- context = gst_vaapi_video_context_new_with_display(
- sink->display, FALSE);
- gst_query_set_context(query, context);
- gst_context_unref(context);
- return TRUE;
- }
- // fall-through
- }
-#endif
- default:
- break;
+ 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,
{
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);
}
switch (prop_id) {
case PROP_DISPLAY_TYPE:
- sink->display_type = g_value_get_enum(value);
+ 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);
switch (prop_id) {
case PROP_DISPLAY_TYPE:
- g_value_set_enum(value, sink->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);
}
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(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->buffer_alloc = gst_vaapisink_buffer_alloc;
#endif
-#if GST_CHECK_VERSION(1,1,0)
- element_class->set_context = gst_vaapisink_set_context;
-#endif
-
+ element_class->set_bus = gst_vaapisink_set_bus;
gst_element_class_set_static_metadata(element_class,
"VA-API sink",
"Sink/Video",
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));
+
#if USE_GLX
g_object_class_install_property
(object_class,
"OpenGL rendering",
"Enables OpenGL rendering",
FALSE,
- G_PARAM_READWRITE));
+ G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
g_object_class_install_property
(object_class,
"Reflection effect",
"Enables OpenGL reflection effect",
FALSE,
- G_PARAM_READWRITE));
+ G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
#endif
g_object_class_install_property
"Fullscreen",
"Requests window in fullscreen state",
FALSE,
- G_PARAM_READWRITE));
+ G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
/**
* GstVaapiSink:synchronous:
"Synchronous mode",
"Toggles X display synchronous mode",
FALSE,
- G_PARAM_READWRITE));
+ G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
/**
* GstVaapiSink:rotation:
"Force aspect ratio",
"When enabled, scaling will respect original aspect ratio",
TRUE,
- G_PARAM_READWRITE));
+ G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
}
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->caps = NULL;
- sink->display = NULL;
sink->window = NULL;
sink->window_width = 0;
sink->window_height = 0;
sink->foreign_window = FALSE;
sink->fullscreen = FALSE;
sink->synchronous = FALSE;
- sink->display_type = DEFAULT_DISPLAY_TYPE;
sink->rotation = DEFAULT_ROTATION;
sink->rotation_req = DEFAULT_ROTATION;
sink->use_reflection = FALSE;
projects / platform / upstream / gstreamer-vaapi.git / blobdiff