mirror of
https://gitlab.freedesktop.org/gstreamer/gstreamer.git
synced 2024-12-04 23:46:43 +00:00
0e4c750918
This helper function iterate all profiles and entrypoints belong to the specified codec, query the VAConfigAttribRTFormat and list all possible video formats. This function is used by each codec to get the template sink caps (for encode) or src caps(for decode) at register time, when just all possible formats are listed and no need to be very accurate. So there is no context created for the performance reason. Most codecs just use YUV kinds of formats as the input/output, so we do not include RGB kinds of formats. User can specified more formats in extra_fmts(For example, jpeg may need BGRA) if needed. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-vaapi/-/merge_requests/315>
1245 lines
34 KiB
C
1245 lines
34 KiB
C
/*
|
|
* gstvaapipluginutil.h - VA-API plugin helpers
|
|
*
|
|
* Copyright (C) 2011-2014 Intel Corporation
|
|
* Author: Gwenole Beauchesne <gwenole.beauchesne@intel.com>
|
|
* Copyright (C) 2011 Collabora
|
|
* Author: Nicolas Dufresne <nicolas.dufresne@collabora.co.uk>
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public License
|
|
* as published by the Free Software Foundation; either version 2.1
|
|
* of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free
|
|
* Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
|
|
* Boston, MA 02110-1301 USA
|
|
*/
|
|
|
|
#include "gstcompat.h"
|
|
#include "gstvaapivideocontext.h"
|
|
#include <gst/vaapi/gstvaapiprofilecaps.h>
|
|
#include <gst/vaapi/gstvaapiutils.h>
|
|
#if USE_DRM
|
|
# include <gst/vaapi/gstvaapidisplay_drm.h>
|
|
#endif
|
|
#if USE_X11
|
|
# include <gst/vaapi/gstvaapidisplay_x11.h>
|
|
#endif
|
|
#if USE_GLX
|
|
# include <gst/vaapi/gstvaapidisplay_glx.h>
|
|
#endif
|
|
#if USE_EGL
|
|
# include <gst/vaapi/gstvaapidisplay_egl.h>
|
|
#endif
|
|
#if USE_WAYLAND
|
|
# include <gst/vaapi/gstvaapidisplay_wayland.h>
|
|
#endif
|
|
#if USE_GST_GL_HELPERS
|
|
# include <gst/gl/gl.h>
|
|
#if USE_EGL && GST_GL_HAVE_PLATFORM_EGL
|
|
# include <gst/gl/egl/gstgldisplay_egl.h>
|
|
#endif
|
|
#endif
|
|
#include "gstvaapipluginutil.h"
|
|
#include "gstvaapipluginbase.h"
|
|
|
|
/* Environment variable for disable driver white-list */
|
|
#define GST_VAAPI_ALL_DRIVERS_ENV "GST_VAAPI_ALL_DRIVERS"
|
|
|
|
typedef GstVaapiDisplay *(*GstVaapiDisplayCreateFunc) (const gchar *);
|
|
typedef GstVaapiDisplay *(*GstVaapiDisplayCreateFromHandleFunc) (gpointer);
|
|
|
|
typedef struct
|
|
{
|
|
const gchar *type_str;
|
|
GstVaapiDisplayType type;
|
|
GstVaapiDisplayCreateFunc create_display;
|
|
GstVaapiDisplayCreateFromHandleFunc create_display_from_handle;
|
|
} DisplayMap;
|
|
|
|
/* *INDENT-OFF* */
|
|
static const DisplayMap g_display_map[] = {
|
|
#if USE_WAYLAND
|
|
{"wayland",
|
|
GST_VAAPI_DISPLAY_TYPE_WAYLAND,
|
|
gst_vaapi_display_wayland_new,
|
|
(GstVaapiDisplayCreateFromHandleFunc)
|
|
gst_vaapi_display_wayland_new_with_display},
|
|
#endif
|
|
#if USE_GLX
|
|
{"glx",
|
|
GST_VAAPI_DISPLAY_TYPE_GLX,
|
|
gst_vaapi_display_glx_new,
|
|
(GstVaapiDisplayCreateFromHandleFunc)
|
|
gst_vaapi_display_glx_new_with_display},
|
|
#endif
|
|
#if USE_X11
|
|
{"x11",
|
|
GST_VAAPI_DISPLAY_TYPE_X11,
|
|
gst_vaapi_display_x11_new,
|
|
(GstVaapiDisplayCreateFromHandleFunc)
|
|
gst_vaapi_display_x11_new_with_display},
|
|
#endif
|
|
#if USE_DRM
|
|
{"drm",
|
|
GST_VAAPI_DISPLAY_TYPE_DRM,
|
|
gst_vaapi_display_drm_new},
|
|
#endif
|
|
{NULL,}
|
|
};
|
|
/* *INDENT-ON* */
|
|
|
|
static GstVaapiDisplay *
|
|
gst_vaapi_create_display (GstVaapiDisplayType display_type,
|
|
const gchar * display_name)
|
|
{
|
|
GstVaapiDisplay *display = NULL;
|
|
const DisplayMap *m;
|
|
|
|
for (m = g_display_map; m->type_str != NULL; m++) {
|
|
if (display_type != GST_VAAPI_DISPLAY_TYPE_ANY && display_type != m->type)
|
|
continue;
|
|
|
|
display = m->create_display (display_name);
|
|
if (display || display_type != GST_VAAPI_DISPLAY_TYPE_ANY)
|
|
break;
|
|
}
|
|
return display;
|
|
}
|
|
|
|
#if USE_GST_GL_HELPERS
|
|
static GstVaapiDisplay *
|
|
gst_vaapi_create_display_from_handle (GstVaapiDisplayType display_type,
|
|
gpointer handle)
|
|
{
|
|
GstVaapiDisplay *display;
|
|
const DisplayMap *m;
|
|
|
|
if (display_type == GST_VAAPI_DISPLAY_TYPE_ANY)
|
|
return NULL;
|
|
|
|
for (m = g_display_map; m->type_str != NULL; m++) {
|
|
if (m->type == display_type) {
|
|
display = m->create_display_from_handle ?
|
|
m->create_display_from_handle (handle) : NULL;
|
|
return display;
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
static GstVaapiDisplayType
|
|
gst_vaapi_get_display_type_from_gl (GstGLDisplayType gl_display_type,
|
|
GstGLPlatform gl_platform)
|
|
{
|
|
switch (gl_display_type) {
|
|
#if USE_X11
|
|
case GST_GL_DISPLAY_TYPE_X11:{
|
|
#if USE_GLX
|
|
if (gl_platform == GST_GL_PLATFORM_GLX)
|
|
return GST_VAAPI_DISPLAY_TYPE_GLX;
|
|
#endif
|
|
return GST_VAAPI_DISPLAY_TYPE_X11;
|
|
}
|
|
#endif
|
|
#if USE_WAYLAND
|
|
case GST_GL_DISPLAY_TYPE_WAYLAND:{
|
|
return GST_VAAPI_DISPLAY_TYPE_WAYLAND;
|
|
}
|
|
#endif
|
|
#if USE_EGL
|
|
case GST_GL_DISPLAY_TYPE_EGL:{
|
|
return GST_VAAPI_DISPLAY_TYPE_EGL;
|
|
}
|
|
#endif
|
|
#if USE_DRM
|
|
case GST_GL_DISPLAY_TYPE_GBM:{
|
|
return GST_VAAPI_DISPLAY_TYPE_DRM;
|
|
}
|
|
#endif
|
|
default:
|
|
/* unsupported display. Still DRM may work. */
|
|
break;
|
|
}
|
|
|
|
return GST_VAAPI_DISPLAY_TYPE_ANY;
|
|
}
|
|
|
|
static GstVaapiDisplayType
|
|
gst_vaapi_get_display_type_from_gl_env (void)
|
|
{
|
|
const gchar *const gl_window_type = g_getenv ("GST_GL_WINDOW");
|
|
|
|
if (!gl_window_type) {
|
|
#if USE_X11 && GST_GL_HAVE_WINDOW_X11
|
|
return GST_VAAPI_DISPLAY_TYPE_X11;
|
|
#elif USE_WAYLAND && GST_GL_HAVE_WINDOW_WAYLAND
|
|
return GST_VAAPI_DISPLAY_TYPE_WAYLAND;
|
|
#elif USE_EGL && GST_GL_HAVE_PLATFORM_EGL
|
|
return GST_VAAPI_DISPLAY_TYPE_EGL;
|
|
#endif
|
|
}
|
|
#if USE_X11
|
|
if (g_strcmp0 (gl_window_type, "x11") == 0)
|
|
return GST_VAAPI_DISPLAY_TYPE_X11;
|
|
#endif
|
|
#if USE_WAYLAND
|
|
if (g_strcmp0 (gl_window_type, "wayland") == 0)
|
|
return GST_VAAPI_DISPLAY_TYPE_WAYLAND;
|
|
#endif
|
|
#if USE_EGL
|
|
{
|
|
const gchar *const gl_platform_type = g_getenv ("GST_GL_PLATFORM");
|
|
if (g_strcmp0 (gl_platform_type, "egl") == 0)
|
|
return GST_VAAPI_DISPLAY_TYPE_EGL;
|
|
}
|
|
#endif
|
|
|
|
return GST_VAAPI_DISPLAY_TYPE_ANY;
|
|
}
|
|
|
|
#if USE_EGL
|
|
static gint
|
|
gst_vaapi_get_gles_version_from_gl_api (GstGLAPI gl_api)
|
|
{
|
|
switch (gl_api) {
|
|
case GST_GL_API_GLES1:
|
|
return 1;
|
|
case GST_GL_API_GLES2:
|
|
return 2;
|
|
case GST_GL_API_OPENGL:
|
|
case GST_GL_API_OPENGL3:
|
|
return 0;
|
|
default:
|
|
break;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
static guintptr
|
|
gst_vaapi_get_egl_handle_from_gl_display (GstGLDisplay * gl_display)
|
|
{
|
|
guintptr egl_handle = 0;
|
|
GstGLDisplayEGL *egl_display;
|
|
|
|
egl_display = gst_gl_display_egl_from_gl_display (gl_display);
|
|
if (egl_display) {
|
|
egl_handle = gst_gl_display_get_handle (GST_GL_DISPLAY (egl_display));
|
|
gst_object_unref (egl_display);
|
|
}
|
|
return egl_handle;
|
|
}
|
|
#endif /* USE_EGL */
|
|
|
|
static GstVaapiDisplay *
|
|
gst_vaapi_create_display_from_egl (GstGLDisplay * gl_display,
|
|
GstGLContext * gl_context, GstVaapiDisplayType display_type,
|
|
gpointer native_display)
|
|
{
|
|
GstVaapiDisplay *display = NULL;
|
|
#if USE_EGL
|
|
GstGLAPI gl_api;
|
|
gint gles_version;
|
|
guintptr egl_handler;
|
|
|
|
gl_api = gst_gl_context_get_gl_api (gl_context);
|
|
gles_version = gst_vaapi_get_gles_version_from_gl_api (gl_api);
|
|
if (gles_version == -1)
|
|
return NULL;
|
|
|
|
egl_handler = gst_vaapi_get_egl_handle_from_gl_display (gl_display);
|
|
if (egl_handler != 0) {
|
|
gpointer native_display_egl = GSIZE_TO_POINTER (egl_handler);
|
|
display = gst_vaapi_display_egl_new_with_native_display (native_display_egl,
|
|
display_type, gles_version);
|
|
}
|
|
|
|
if (!display) {
|
|
GstVaapiDisplay *wrapped_display;
|
|
|
|
wrapped_display =
|
|
gst_vaapi_create_display_from_handle (display_type, native_display);
|
|
if (wrapped_display) {
|
|
display = gst_vaapi_display_egl_new (wrapped_display, gles_version);
|
|
gst_object_unref (wrapped_display);
|
|
}
|
|
}
|
|
|
|
if (display) {
|
|
gst_vaapi_display_egl_set_gl_context (GST_VAAPI_DISPLAY_EGL (display),
|
|
GSIZE_TO_POINTER (gst_gl_context_get_gl_context (gl_context)));
|
|
}
|
|
#endif
|
|
return display;
|
|
}
|
|
#endif /* USE_GST_GL_HELPERS */
|
|
|
|
static GstVaapiDisplay *
|
|
gst_vaapi_create_display_from_gl_context (GstObject * gl_context_object)
|
|
{
|
|
#if USE_GST_GL_HELPERS
|
|
GstGLContext *const gl_context = GST_GL_CONTEXT (gl_context_object);
|
|
GstGLDisplay *const gl_display = gst_gl_context_get_display (gl_context);
|
|
GstGLDisplayType gl_display_type;
|
|
GstGLPlatform gl_platform;
|
|
gpointer native_display;
|
|
GstVaapiDisplay *display = NULL;
|
|
GstVaapiDisplayType display_type;
|
|
|
|
/* Get display type and the native hanler */
|
|
gl_display_type = gst_gl_display_get_handle_type (gl_display);
|
|
gl_platform = gst_gl_context_get_gl_platform (gl_context);
|
|
display_type =
|
|
gst_vaapi_get_display_type_from_gl (gl_display_type, gl_platform);
|
|
|
|
native_display = GSIZE_TO_POINTER (gst_gl_display_get_handle (gl_display));
|
|
|
|
if (display_type == GST_VAAPI_DISPLAY_TYPE_ANY) {
|
|
/* derive type and native_display from the active window */
|
|
GstGLWindow *const gl_window = gst_gl_context_get_window (gl_context);
|
|
if (gl_window)
|
|
native_display = GSIZE_TO_POINTER (gst_gl_window_get_display (gl_window));
|
|
display_type = gst_vaapi_get_display_type_from_gl_env ();
|
|
}
|
|
|
|
if (gl_platform == GST_GL_PLATFORM_EGL) {
|
|
display = gst_vaapi_create_display_from_egl (gl_display, gl_context,
|
|
display_type, native_display);
|
|
}
|
|
|
|
/* Non-EGL and fallback */
|
|
if (!display) {
|
|
display =
|
|
gst_vaapi_create_display_from_handle (display_type, native_display);
|
|
}
|
|
|
|
gst_object_unref (gl_display);
|
|
|
|
return display;
|
|
#endif
|
|
GST_ERROR ("No GstGL support");
|
|
return NULL;
|
|
}
|
|
|
|
static void
|
|
gst_vaapi_find_gl_context (GstElement * element)
|
|
{
|
|
#if USE_GST_GL_HELPERS
|
|
GstVaapiPluginBase *const plugin = GST_VAAPI_PLUGIN_BASE (element);
|
|
|
|
/* if the element is vaapisink or any vaapi encoder it doesn't need
|
|
* to know a GstGLContext in order to create an appropriate
|
|
* GstVaapiDisplay. Let's them to choose their own
|
|
* GstVaapiDisplay */
|
|
if (GST_IS_VIDEO_SINK (element) || GST_IS_VIDEO_ENCODER (element))
|
|
return;
|
|
|
|
if (!gst_gl_ensure_element_data (plugin,
|
|
(GstGLDisplay **) & plugin->gl_display,
|
|
(GstGLContext **) & plugin->gl_other_context))
|
|
goto no_valid_gl_display;
|
|
|
|
gst_vaapi_find_gl_local_context (element, &plugin->gl_context);
|
|
|
|
if (plugin->gl_context) {
|
|
gst_vaapi_plugin_base_set_srcpad_can_dmabuf (plugin, plugin->gl_context);
|
|
} else {
|
|
GstObject *gl_context;
|
|
|
|
gl_context = gst_vaapi_plugin_base_create_gl_context (plugin);
|
|
if (gl_context) {
|
|
gst_vaapi_plugin_base_set_gl_context (plugin, gl_context);
|
|
gst_object_unref (gl_context);
|
|
}
|
|
}
|
|
|
|
/* ERRORS */
|
|
no_valid_gl_display:
|
|
{
|
|
GST_INFO_OBJECT (plugin, "No valid GL display found");
|
|
gst_object_replace (&plugin->gl_display, NULL);
|
|
gst_object_replace (&plugin->gl_other_context, NULL);
|
|
return;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
gboolean
|
|
gst_vaapi_ensure_display (GstElement * element, GstVaapiDisplayType type)
|
|
{
|
|
GstVaapiPluginBase *const plugin = GST_VAAPI_PLUGIN_BASE (element);
|
|
GstVaapiDisplay *display = NULL;
|
|
|
|
g_return_val_if_fail (GST_IS_ELEMENT (element), FALSE);
|
|
|
|
if (gst_vaapi_video_context_prepare (element, &plugin->display)) {
|
|
/* Neighbour found and it updated the display */
|
|
if (gst_vaapi_plugin_base_has_display_type (plugin, type))
|
|
return TRUE;
|
|
}
|
|
|
|
/* Query for a local GstGL context. If it's found, it will be used
|
|
* to create the VA display */
|
|
if (!plugin->gl_context)
|
|
gst_vaapi_find_gl_context (element);
|
|
|
|
/* If no neighboor, or application not interested, use system default */
|
|
if (plugin->gl_context) {
|
|
display = gst_vaapi_create_display_from_gl_context (plugin->gl_context);
|
|
/* Cannot instantiate VA display based on GL context. Reset the
|
|
* requested display type to ANY to try again */
|
|
if (!display)
|
|
gst_vaapi_plugin_base_set_display_type (plugin,
|
|
GST_VAAPI_DISPLAY_TYPE_ANY);
|
|
}
|
|
if (!display)
|
|
display = gst_vaapi_create_display (type, plugin->display_name);
|
|
if (!display)
|
|
return FALSE;
|
|
|
|
gst_vaapi_video_context_propagate (element, display);
|
|
gst_object_unref (display);
|
|
return TRUE;
|
|
}
|
|
|
|
gboolean
|
|
gst_vaapi_handle_context_query (GstElement * element, GstQuery * query)
|
|
{
|
|
GstVaapiPluginBase *const plugin = GST_VAAPI_PLUGIN_BASE (element);
|
|
const gchar *type = NULL;
|
|
GstContext *context, *old_context;
|
|
|
|
g_return_val_if_fail (query != NULL, FALSE);
|
|
|
|
#if USE_GST_GL_HELPERS
|
|
if (plugin->gl_display && plugin->gl_context && plugin->gl_other_context) {
|
|
if (gst_gl_handle_context_query (element, query,
|
|
(GstGLDisplay *) plugin->gl_display,
|
|
(GstGLContext *) plugin->gl_context,
|
|
(GstGLContext *) plugin->gl_other_context))
|
|
return TRUE;
|
|
}
|
|
#endif
|
|
|
|
if (!plugin->display)
|
|
return FALSE;
|
|
|
|
if (!gst_query_parse_context_type (query, &type))
|
|
return FALSE;
|
|
|
|
if (g_strcmp0 (type, GST_VAAPI_DISPLAY_CONTEXT_TYPE_NAME))
|
|
return FALSE;
|
|
|
|
gst_query_parse_context (query, &old_context);
|
|
if (old_context) {
|
|
context = gst_context_copy (old_context);
|
|
gst_vaapi_video_context_set_display (context, plugin->display);
|
|
} else {
|
|
context = gst_vaapi_video_context_new_with_display (plugin->display, FALSE);
|
|
}
|
|
|
|
gst_query_set_context (query, context);
|
|
gst_context_unref (context);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
gboolean
|
|
gst_vaapi_append_surface_caps (GstCaps * out_caps, GstCaps * in_caps)
|
|
{
|
|
GstStructure *structure;
|
|
const GValue *v_width, *v_height, *v_framerate, *v_par;
|
|
guint i, n_structures;
|
|
|
|
structure = gst_caps_get_structure (in_caps, 0);
|
|
v_width = gst_structure_get_value (structure, "width");
|
|
v_height = gst_structure_get_value (structure, "height");
|
|
v_framerate = gst_structure_get_value (structure, "framerate");
|
|
v_par = gst_structure_get_value (structure, "pixel-aspect-ratio");
|
|
if (!v_width || !v_height)
|
|
return FALSE;
|
|
|
|
n_structures = gst_caps_get_size (out_caps);
|
|
for (i = 0; i < n_structures; i++) {
|
|
structure = gst_caps_get_structure (out_caps, i);
|
|
gst_structure_set_value (structure, "width", v_width);
|
|
gst_structure_set_value (structure, "height", v_height);
|
|
if (v_framerate)
|
|
gst_structure_set_value (structure, "framerate", v_framerate);
|
|
if (v_par)
|
|
gst_structure_set_value (structure, "pixel-aspect-ratio", v_par);
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
gboolean
|
|
gst_vaapi_apply_composition (GstVaapiSurface * surface, GstBuffer * buffer)
|
|
{
|
|
GstVideoOverlayCompositionMeta *const cmeta =
|
|
gst_buffer_get_video_overlay_composition_meta (buffer);
|
|
GstVideoOverlayComposition *composition = NULL;
|
|
|
|
if (cmeta)
|
|
composition = cmeta->overlay;
|
|
return gst_vaapi_surface_set_subpictures_from_composition (surface,
|
|
composition);
|
|
}
|
|
|
|
gboolean
|
|
gst_vaapi_value_set_format (GValue * value, GstVideoFormat format)
|
|
{
|
|
const gchar *str;
|
|
|
|
str = gst_video_format_to_string (format);
|
|
if (!str)
|
|
return FALSE;
|
|
|
|
g_value_init (value, G_TYPE_STRING);
|
|
g_value_set_string (value, str);
|
|
return TRUE;
|
|
}
|
|
|
|
gboolean
|
|
gst_vaapi_value_set_format_list (GValue * value, GArray * formats)
|
|
{
|
|
GValue v_format = G_VALUE_INIT;
|
|
guint i;
|
|
|
|
g_value_init (value, GST_TYPE_LIST);
|
|
for (i = 0; i < formats->len; i++) {
|
|
GstVideoFormat const format = g_array_index (formats, GstVideoFormat, i);
|
|
|
|
if (!gst_vaapi_value_set_format (&v_format, format))
|
|
continue;
|
|
gst_value_list_append_value (value, &v_format);
|
|
g_value_unset (&v_format);
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
static void
|
|
set_video_template_caps (GstCaps * caps)
|
|
{
|
|
GstStructure *const structure = gst_caps_get_structure (caps, 0);
|
|
|
|
gst_structure_set (structure,
|
|
"width", GST_TYPE_INT_RANGE, 1, G_MAXINT,
|
|
"height", GST_TYPE_INT_RANGE, 1, G_MAXINT,
|
|
"framerate", GST_TYPE_FRACTION_RANGE, 0, 1, G_MAXINT, 1, NULL);
|
|
}
|
|
|
|
GstCaps *
|
|
gst_vaapi_video_format_new_template_caps (GstVideoFormat format)
|
|
{
|
|
GstCaps *caps;
|
|
|
|
g_return_val_if_fail (format != GST_VIDEO_FORMAT_UNKNOWN, NULL);
|
|
|
|
caps = gst_caps_new_empty_simple ("video/x-raw");
|
|
if (!caps)
|
|
return NULL;
|
|
|
|
gst_caps_set_simple (caps,
|
|
"format", G_TYPE_STRING, gst_video_format_to_string (format), NULL);
|
|
set_video_template_caps (caps);
|
|
return caps;
|
|
}
|
|
|
|
GstCaps *
|
|
gst_vaapi_video_format_new_template_caps_from_list (GArray * formats)
|
|
{
|
|
GValue v_formats = G_VALUE_INIT;
|
|
GstCaps *caps;
|
|
|
|
caps = gst_caps_new_empty_simple ("video/x-raw");
|
|
if (!caps)
|
|
return NULL;
|
|
|
|
if (!gst_vaapi_value_set_format_list (&v_formats, formats)) {
|
|
gst_caps_unref (caps);
|
|
return NULL;
|
|
}
|
|
|
|
gst_caps_set_value (caps, "format", &v_formats);
|
|
set_video_template_caps (caps);
|
|
g_value_unset (&v_formats);
|
|
return caps;
|
|
}
|
|
|
|
GstCaps *
|
|
gst_vaapi_video_format_new_template_caps_with_features (GstVideoFormat format,
|
|
const gchar * features_string)
|
|
{
|
|
GstCapsFeatures *features;
|
|
GstCaps *caps;
|
|
|
|
caps = gst_vaapi_video_format_new_template_caps (format);
|
|
if (!caps)
|
|
return NULL;
|
|
|
|
features = gst_caps_features_new (features_string, NULL);
|
|
if (!features) {
|
|
gst_caps_unref (caps);
|
|
return NULL;
|
|
}
|
|
gst_caps_set_features (caps, 0, features);
|
|
return caps;
|
|
}
|
|
|
|
static GstVideoFormat
|
|
gst_vaapi_find_preferred_format (const GValue * format_list,
|
|
GstVideoFormat native_format)
|
|
{
|
|
const GValue *frmt;
|
|
GstVideoFormat out_format;
|
|
guint i;
|
|
|
|
/* if one format, that is the one */
|
|
if (G_VALUE_HOLDS_STRING (format_list))
|
|
return gst_video_format_from_string (g_value_get_string (format_list));
|
|
|
|
if (!GST_VALUE_HOLDS_LIST (format_list)) {
|
|
GST_ERROR ("negotiated caps do not have a valid format");
|
|
return GST_VIDEO_FORMAT_UNKNOWN;
|
|
}
|
|
|
|
if (native_format == GST_VIDEO_FORMAT_UNKNOWN
|
|
|| native_format == GST_VIDEO_FORMAT_ENCODED) {
|
|
native_format = GST_VIDEO_FORMAT_NV12; /* default VA format */
|
|
}
|
|
|
|
/* search our native format in the list */
|
|
for (i = 0; i < gst_value_list_get_size (format_list); i++) {
|
|
frmt = gst_value_list_get_value (format_list, i);
|
|
out_format = gst_video_format_from_string (g_value_get_string (frmt));
|
|
|
|
/* GStreamer do not handle encoded formats nicely. Try the next
|
|
* one. */
|
|
if (out_format == GST_VIDEO_FORMAT_ENCODED)
|
|
continue;
|
|
|
|
if (native_format == out_format)
|
|
return out_format;
|
|
}
|
|
|
|
/* just pick the first valid format in the list */
|
|
i = 0;
|
|
do {
|
|
frmt = gst_value_list_get_value (format_list, i++);
|
|
out_format = gst_video_format_from_string (g_value_get_string (frmt));
|
|
} while (out_format == GST_VIDEO_FORMAT_ENCODED);
|
|
|
|
return out_format;
|
|
}
|
|
|
|
GstVaapiCapsFeature
|
|
gst_vaapi_find_preferred_caps_feature (GstPad * pad, GstCaps * allowed_caps,
|
|
GstVideoFormat * out_format_ptr)
|
|
{
|
|
GstVaapiCapsFeature feature = GST_VAAPI_CAPS_FEATURE_NOT_NEGOTIATED;
|
|
guint i, j, num_structures;
|
|
GstCaps *peer_caps, *out_caps = NULL, *caps = NULL;
|
|
static const guint feature_list[] = { GST_VAAPI_CAPS_FEATURE_VAAPI_SURFACE,
|
|
GST_VAAPI_CAPS_FEATURE_DMABUF,
|
|
GST_VAAPI_CAPS_FEATURE_GL_TEXTURE_UPLOAD_META,
|
|
GST_VAAPI_CAPS_FEATURE_SYSTEM_MEMORY,
|
|
};
|
|
|
|
/* query with no filter */
|
|
peer_caps = gst_pad_peer_query_caps (pad, NULL);
|
|
if (!peer_caps)
|
|
goto cleanup;
|
|
if (gst_caps_is_empty (peer_caps))
|
|
goto cleanup;
|
|
|
|
/* filter against our allowed caps */
|
|
out_caps = gst_caps_intersect_full (allowed_caps, peer_caps,
|
|
GST_CAPS_INTERSECT_FIRST);
|
|
|
|
/* default feature */
|
|
feature = GST_VAAPI_CAPS_FEATURE_SYSTEM_MEMORY;
|
|
|
|
/* if downstream requests caps ANY, system memory is preferred */
|
|
if (gst_caps_is_any (peer_caps))
|
|
goto find_format;
|
|
|
|
num_structures = gst_caps_get_size (out_caps);
|
|
for (i = 0; i < num_structures; i++) {
|
|
GstCapsFeatures *const features = gst_caps_get_features (out_caps, i);
|
|
GstStructure *const structure = gst_caps_get_structure (out_caps, i);
|
|
|
|
/* Skip ANY features, we need an exact match for correct evaluation */
|
|
if (gst_caps_features_is_any (features))
|
|
continue;
|
|
|
|
gst_caps_replace (&caps, NULL);
|
|
caps = gst_caps_new_full (gst_structure_copy (structure), NULL);
|
|
if (!caps)
|
|
continue;
|
|
gst_caps_set_features (caps, 0, gst_caps_features_copy (features));
|
|
|
|
for (j = 0; j < G_N_ELEMENTS (feature_list); j++) {
|
|
if (gst_vaapi_caps_feature_contains (caps, feature_list[j])
|
|
&& feature < feature_list[j]) {
|
|
feature = feature_list[j];
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* Stop at the first match, the caps should already be sorted out
|
|
by preference order from downstream elements */
|
|
if (feature != GST_VAAPI_CAPS_FEATURE_SYSTEM_MEMORY)
|
|
break;
|
|
}
|
|
|
|
if (!caps)
|
|
goto cleanup;
|
|
|
|
find_format:
|
|
if (out_format_ptr) {
|
|
GstVideoFormat out_format;
|
|
GstStructure *structure = NULL;
|
|
const GValue *format_list;
|
|
GstCapsFeatures *features;
|
|
|
|
/* if the best feature is SystemMemory, we should choose the
|
|
* vidoe/x-raw caps in the filtered peer caps set. If not, use
|
|
* the first caps, which is the preferred by downstream. */
|
|
if (feature == GST_VAAPI_CAPS_FEATURE_SYSTEM_MEMORY) {
|
|
gst_caps_replace (&caps, out_caps);
|
|
num_structures = gst_caps_get_size (caps);
|
|
for (i = 0; i < num_structures; i++) {
|
|
structure = gst_caps_get_structure (caps, i);
|
|
features = gst_caps_get_features (caps, i);
|
|
if (!gst_caps_features_is_any (features)
|
|
&& gst_caps_features_contains (features,
|
|
gst_vaapi_caps_feature_to_string
|
|
(GST_VAAPI_CAPS_FEATURE_SYSTEM_MEMORY)))
|
|
break;
|
|
}
|
|
} else {
|
|
structure = gst_caps_get_structure (caps, 0);
|
|
}
|
|
if (!structure)
|
|
goto cleanup;
|
|
format_list = gst_structure_get_value (structure, "format");
|
|
if (!format_list)
|
|
goto cleanup;
|
|
out_format = gst_vaapi_find_preferred_format (format_list, *out_format_ptr);
|
|
if (out_format == GST_VIDEO_FORMAT_UNKNOWN)
|
|
goto cleanup;
|
|
|
|
*out_format_ptr = out_format;
|
|
}
|
|
|
|
cleanup:
|
|
gst_caps_replace (&caps, NULL);
|
|
gst_caps_replace (&out_caps, NULL);
|
|
gst_caps_replace (&peer_caps, NULL);
|
|
return feature;
|
|
}
|
|
|
|
const gchar *
|
|
gst_vaapi_caps_feature_to_string (GstVaapiCapsFeature feature)
|
|
{
|
|
const gchar *str;
|
|
|
|
switch (feature) {
|
|
case GST_VAAPI_CAPS_FEATURE_SYSTEM_MEMORY:
|
|
str = GST_CAPS_FEATURE_MEMORY_SYSTEM_MEMORY;
|
|
break;
|
|
case GST_VAAPI_CAPS_FEATURE_GL_TEXTURE_UPLOAD_META:
|
|
str = GST_CAPS_FEATURE_META_GST_VIDEO_GL_TEXTURE_UPLOAD_META;
|
|
break;
|
|
case GST_VAAPI_CAPS_FEATURE_DMABUF:
|
|
str = GST_CAPS_FEATURE_MEMORY_DMABUF;
|
|
break;
|
|
case GST_VAAPI_CAPS_FEATURE_VAAPI_SURFACE:
|
|
str = GST_CAPS_FEATURE_MEMORY_VAAPI_SURFACE;
|
|
break;
|
|
default:
|
|
str = NULL;
|
|
break;
|
|
}
|
|
return str;
|
|
}
|
|
|
|
gboolean
|
|
gst_caps_set_interlaced (GstCaps * caps, GstVideoInfo * vip)
|
|
{
|
|
GstVideoInterlaceMode mode;
|
|
const gchar *mode_str;
|
|
|
|
mode = vip ? GST_VIDEO_INFO_INTERLACE_MODE (vip) :
|
|
GST_VIDEO_INTERLACE_MODE_PROGRESSIVE;
|
|
switch (mode) {
|
|
case GST_VIDEO_INTERLACE_MODE_PROGRESSIVE:
|
|
mode_str = "progressive";
|
|
break;
|
|
case GST_VIDEO_INTERLACE_MODE_INTERLEAVED:
|
|
mode_str = "interleaved";
|
|
break;
|
|
case GST_VIDEO_INTERLACE_MODE_MIXED:
|
|
mode_str = "mixed";
|
|
break;
|
|
default:
|
|
GST_ERROR ("unsupported `interlace-mode' %d", mode);
|
|
return FALSE;
|
|
}
|
|
|
|
gst_caps_set_simple (caps, "interlace-mode", G_TYPE_STRING, mode_str, NULL);
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
_gst_caps_has_feature (const GstCaps * caps, const gchar * feature)
|
|
{
|
|
guint i;
|
|
|
|
for (i = 0; i < gst_caps_get_size (caps); i++) {
|
|
GstCapsFeatures *const features = gst_caps_get_features (caps, i);
|
|
/* Skip ANY features, we need an exact match for correct evaluation */
|
|
if (gst_caps_features_is_any (features))
|
|
continue;
|
|
if (gst_caps_features_contains (features, feature))
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
gboolean
|
|
gst_vaapi_caps_feature_contains (const GstCaps * caps,
|
|
GstVaapiCapsFeature feature)
|
|
{
|
|
const gchar *feature_str;
|
|
|
|
g_return_val_if_fail (caps != NULL, FALSE);
|
|
|
|
feature_str = gst_vaapi_caps_feature_to_string (feature);
|
|
if (!feature_str)
|
|
return FALSE;
|
|
|
|
return _gst_caps_has_feature (caps, feature_str);
|
|
}
|
|
|
|
/* Checks whether the supplied caps contain VA surfaces */
|
|
gboolean
|
|
gst_caps_has_vaapi_surface (GstCaps * caps)
|
|
{
|
|
g_return_val_if_fail (caps != NULL, FALSE);
|
|
|
|
return _gst_caps_has_feature (caps, GST_CAPS_FEATURE_MEMORY_VAAPI_SURFACE);
|
|
}
|
|
|
|
gboolean
|
|
gst_caps_is_video_raw (GstCaps * caps)
|
|
{
|
|
GstStructure *structure;
|
|
|
|
g_return_val_if_fail (caps != NULL, FALSE);
|
|
|
|
if (!gst_caps_is_fixed (caps))
|
|
return FALSE;
|
|
if (!_gst_caps_has_feature (caps, GST_CAPS_FEATURE_MEMORY_SYSTEM_MEMORY))
|
|
return FALSE;
|
|
structure = gst_caps_get_structure (caps, 0);
|
|
return gst_structure_has_name (structure, "video/x-raw");
|
|
}
|
|
|
|
void
|
|
gst_video_info_change_format (GstVideoInfo * vip, GstVideoFormat format,
|
|
guint width, guint height)
|
|
{
|
|
GstVideoInfo vi = *vip;
|
|
|
|
gst_video_info_set_format (vip, format, width, height);
|
|
|
|
GST_VIDEO_INFO_INTERLACE_MODE (vip) = GST_VIDEO_INFO_INTERLACE_MODE (&vi);
|
|
GST_VIDEO_FORMAT_INFO_FLAGS (vip) = GST_VIDEO_FORMAT_INFO_FLAGS (&vi);
|
|
GST_VIDEO_INFO_VIEWS (vip) = GST_VIDEO_INFO_VIEWS (&vi);
|
|
GST_VIDEO_INFO_PAR_N (vip) = GST_VIDEO_INFO_PAR_N (&vi);
|
|
GST_VIDEO_INFO_PAR_D (vip) = GST_VIDEO_INFO_PAR_D (&vi);
|
|
GST_VIDEO_INFO_FPS_N (vip) = GST_VIDEO_INFO_FPS_N (&vi);
|
|
GST_VIDEO_INFO_FPS_D (vip) = GST_VIDEO_INFO_FPS_D (&vi);
|
|
GST_VIDEO_INFO_MULTIVIEW_MODE (vip) = GST_VIDEO_INFO_MULTIVIEW_MODE (&vi);
|
|
GST_VIDEO_INFO_MULTIVIEW_FLAGS (vip) = GST_VIDEO_INFO_MULTIVIEW_FLAGS (&vi);
|
|
}
|
|
|
|
/**
|
|
* gst_video_info_changed:
|
|
* @old: old #GstVideoInfo
|
|
* @new: new #GstVideoInfo
|
|
*
|
|
* Compares @old and @new
|
|
*
|
|
* Returns: %TRUE if @old has different format/width/height than
|
|
* @new. Otherwise, %FALSE.
|
|
**/
|
|
gboolean
|
|
gst_video_info_changed (const GstVideoInfo * old, const GstVideoInfo * new)
|
|
{
|
|
if (GST_VIDEO_INFO_FORMAT (old) != GST_VIDEO_INFO_FORMAT (new))
|
|
return TRUE;
|
|
if (GST_VIDEO_INFO_WIDTH (old) != GST_VIDEO_INFO_WIDTH (new))
|
|
return TRUE;
|
|
if (GST_VIDEO_INFO_HEIGHT (old) != GST_VIDEO_INFO_HEIGHT (new))
|
|
return TRUE;
|
|
return FALSE;
|
|
}
|
|
|
|
/**
|
|
* gst_video_info_force_nv12_if_encoded:
|
|
* @vinfo: a #GstVideoInfo
|
|
*
|
|
* If the format of @vinfo is %GST_VIDEO_FORMAT_ENCODED it is changed
|
|
* to %GST_VIDEO_FORMAT_NV12.
|
|
**/
|
|
void
|
|
gst_video_info_force_nv12_if_encoded (GstVideoInfo * vinfo)
|
|
{
|
|
if (GST_VIDEO_INFO_FORMAT (vinfo) != GST_VIDEO_FORMAT_ENCODED)
|
|
return;
|
|
gst_video_info_set_format (vinfo, GST_VIDEO_FORMAT_NV12,
|
|
GST_VIDEO_INFO_WIDTH (vinfo), GST_VIDEO_INFO_HEIGHT (vinfo));
|
|
}
|
|
|
|
/**
|
|
* gst_vaapi_create_test_display:
|
|
*
|
|
* Creates a temporal #GstVaapiDisplay instance, just for testing the
|
|
* supported features.
|
|
*
|
|
* Returns: a new #GstVaapiDisplay instances. Free with
|
|
* gst_object_unref () after use. Or %NULL if no VA display is
|
|
* available.
|
|
**/
|
|
GstVaapiDisplay *
|
|
gst_vaapi_create_test_display (void)
|
|
{
|
|
guint i;
|
|
GstVaapiDisplay *display = NULL;
|
|
const GstVaapiDisplayType test_display_map[] = {
|
|
#if USE_DRM
|
|
GST_VAAPI_DISPLAY_TYPE_DRM,
|
|
#endif
|
|
#if USE_WAYLAND
|
|
GST_VAAPI_DISPLAY_TYPE_WAYLAND,
|
|
#endif
|
|
#if USE_X11
|
|
GST_VAAPI_DISPLAY_TYPE_X11,
|
|
#endif
|
|
};
|
|
|
|
for (i = 0; i < G_N_ELEMENTS (test_display_map); i++) {
|
|
display = gst_vaapi_create_display (test_display_map[i], NULL);
|
|
if (display)
|
|
break;
|
|
}
|
|
return display;
|
|
}
|
|
|
|
/**
|
|
* gst_vaapi_driver_is_whitelisted:
|
|
* @display: a #GstVaapiDisplay
|
|
*
|
|
* Looks the VA-API driver vendors in an internal white-list.
|
|
*
|
|
* Returns: %TRUE if driver is in the white-list, otherwise %FALSE
|
|
**/
|
|
gboolean
|
|
gst_vaapi_driver_is_whitelisted (GstVaapiDisplay * display)
|
|
{
|
|
const gchar *vendor;
|
|
guint i;
|
|
static const gchar *whitelist[] = {
|
|
"Intel i965 driver",
|
|
"Intel iHD driver",
|
|
"Mesa Gallium driver",
|
|
NULL
|
|
};
|
|
|
|
g_return_val_if_fail (display, FALSE);
|
|
|
|
if (g_getenv (GST_VAAPI_ALL_DRIVERS_ENV))
|
|
return TRUE;
|
|
|
|
vendor = gst_vaapi_display_get_vendor_string (display);
|
|
if (!vendor)
|
|
goto no_vendor;
|
|
|
|
for (i = 0; whitelist[i]; i++) {
|
|
if (g_ascii_strncasecmp (vendor, whitelist[i], strlen (whitelist[i])) == 0)
|
|
return TRUE;
|
|
}
|
|
|
|
GST_WARNING ("Unsupported VA driver: %s. Export environment variable "
|
|
GST_VAAPI_ALL_DRIVERS_ENV " to bypass", vendor);
|
|
return FALSE;
|
|
|
|
/* ERRORS */
|
|
no_vendor:
|
|
{
|
|
GST_WARNING ("no VA-API driver vendor description");
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* gst_vaapi_codecs_has_codec:
|
|
* @codecs: a #GArray of #GstVaapiCodec
|
|
* @codec: a #GstVaapiCodec to find in @codec
|
|
*
|
|
* Search in the available @codecs for the specific @codec.
|
|
*
|
|
* Returns: %TRUE if @codec is in @codecs
|
|
**/
|
|
gboolean
|
|
gst_vaapi_codecs_has_codec (GArray * codecs, GstVaapiCodec codec)
|
|
{
|
|
guint i;
|
|
GstVaapiCodec c;
|
|
|
|
g_return_val_if_fail (codec, FALSE);
|
|
|
|
for (i = 0; i < codecs->len; i++) {
|
|
c = g_array_index (codecs, GstVaapiCodec, i);
|
|
if (c == codec)
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
/**
|
|
* gst_vaapi_h26x_encoder_get_profiles_from_caps:
|
|
* @caps: a #GstCaps to detect
|
|
* @func: a #GstVaapiStrToProfileFunc
|
|
*
|
|
* This function will detect all profile strings in @caps and
|
|
* return the according GstVaapiProfile in array. This can just
|
|
* work for h264 and h265 now.
|
|
*
|
|
* Return: A #GArray of @GstVaapiProfile if succeed, %NULL if fail.
|
|
**/
|
|
GArray *
|
|
gst_vaapi_h26x_encoder_get_profiles_from_caps (GstCaps * caps,
|
|
GstVaapiStrToProfileFunc func)
|
|
{
|
|
guint i, j;
|
|
GstVaapiProfile profile;
|
|
GArray *profiles = NULL;
|
|
|
|
if (!caps)
|
|
return NULL;
|
|
|
|
profiles = g_array_new (FALSE, FALSE, sizeof (GstVaapiProfile));
|
|
if (!profiles)
|
|
return NULL;
|
|
|
|
for (i = 0; i < gst_caps_get_size (caps); i++) {
|
|
GstStructure *const structure = gst_caps_get_structure (caps, i);
|
|
const GValue *const value = gst_structure_get_value (structure, "profile");
|
|
|
|
if (value && G_VALUE_HOLDS_STRING (value)) {
|
|
const gchar *str = g_value_get_string (value);
|
|
if (str) {
|
|
profile = func (str);
|
|
if (profile == GST_VAAPI_PROFILE_H264_BASELINE)
|
|
profile = GST_VAAPI_PROFILE_H264_CONSTRAINED_BASELINE;
|
|
if (profile != GST_VAAPI_PROFILE_UNKNOWN)
|
|
g_array_append_val (profiles, profile);
|
|
}
|
|
} else if (value && GST_VALUE_HOLDS_LIST (value)) {
|
|
const GValue *v;
|
|
const gchar *str;
|
|
for (j = 0; j < gst_value_list_get_size (value); j++) {
|
|
v = gst_value_list_get_value (value, j);
|
|
if (!v || !G_VALUE_HOLDS_STRING (v))
|
|
continue;
|
|
|
|
str = g_value_get_string (v);
|
|
if (str) {
|
|
profile = func (str);
|
|
if (profile != GST_VAAPI_PROFILE_UNKNOWN)
|
|
g_array_append_val (profiles, profile);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (profiles->len == 0) {
|
|
g_array_unref (profiles);
|
|
profiles = NULL;
|
|
}
|
|
|
|
return profiles;
|
|
}
|
|
|
|
/**
|
|
* gst_vaapi_build_caps_from_formats:
|
|
* @formats: an array of supported #GstVideoFormat
|
|
* @min_width: the min supported width
|
|
* @min_height: the min supported height
|
|
* @max_width: the max supported width
|
|
* @max_height: the max supported height
|
|
* @mem_types: the supported VA mem types
|
|
*
|
|
* This function generates a #GstCaps based on the information such as
|
|
* formats, width and height.
|
|
*
|
|
* Return: A #GstCaps.
|
|
**/
|
|
GstCaps *
|
|
gst_vaapi_build_caps_from_formats (GArray * formats, gint min_width,
|
|
gint min_height, gint max_width, gint max_height, guint mem_types)
|
|
{
|
|
GstCaps *out_caps = NULL;
|
|
GstCaps *raw_caps = NULL;
|
|
GstCaps *va_caps, *dma_caps;
|
|
guint i, size;
|
|
GstStructure *structure;
|
|
|
|
raw_caps = gst_vaapi_video_format_new_template_caps_from_list (formats);
|
|
if (!raw_caps)
|
|
return NULL;
|
|
|
|
/* Set the width/height info to caps */
|
|
size = gst_caps_get_size (raw_caps);
|
|
for (i = 0; i < size; i++) {
|
|
structure = gst_caps_get_structure (raw_caps, i);
|
|
if (!structure)
|
|
continue;
|
|
gst_structure_set (structure, "width", GST_TYPE_INT_RANGE, min_width,
|
|
max_width, "height", GST_TYPE_INT_RANGE, min_height, max_height, NULL);
|
|
}
|
|
|
|
out_caps = gst_caps_copy (raw_caps);
|
|
|
|
va_caps = gst_caps_copy (raw_caps);
|
|
gst_caps_set_features_simple (va_caps,
|
|
gst_caps_features_from_string (GST_CAPS_FEATURE_MEMORY_VAAPI_SURFACE));
|
|
gst_caps_append (out_caps, va_caps);
|
|
|
|
if (gst_vaapi_mem_type_supports (mem_types,
|
|
GST_VAAPI_BUFFER_MEMORY_TYPE_DMA_BUF)) {
|
|
dma_caps = gst_caps_copy (raw_caps);
|
|
gst_caps_set_features_simple (dma_caps,
|
|
gst_caps_features_from_string (GST_CAPS_FEATURE_MEMORY_DMABUF));
|
|
gst_caps_append (out_caps, dma_caps);
|
|
}
|
|
|
|
gst_caps_unref (raw_caps);
|
|
|
|
return out_caps;
|
|
}
|
|
|
|
/**
|
|
* gst_vaapi_build_template_caps_by_codec:
|
|
* @display: a #GstVaapiDisplay
|
|
* @usage: used for encode, decode or postproc
|
|
* @codec: a #GstVaapiCodec specify the codec to detect
|
|
* @extra_fmts: a #GArray of extra #GstVideoFormat
|
|
*
|
|
* Called by vaapi elements to detect the all possible video formats belong to
|
|
* the specified codec and build the caps. Only YUV kinds of formats are detected
|
|
* because so far almost all codecs use YUV kinds of formats as input/output.
|
|
* extra_fmts can specified more formats to be included.
|
|
*
|
|
* Returns: a built #GstCaps if succeeds, or %NULL if error.
|
|
**/
|
|
GstCaps *
|
|
gst_vaapi_build_template_caps_by_codec (GstVaapiDisplay * display,
|
|
GstVaapiContextUsage usage, GstVaapiCodec codec, GArray * extra_fmts)
|
|
{
|
|
GArray *profiles = NULL;
|
|
GArray *supported_fmts = NULL;
|
|
GstCaps *out_caps = NULL;
|
|
guint i, e;
|
|
GstVaapiProfile profile;
|
|
guint value;
|
|
guint chroma;
|
|
GstVaapiChromaType gst_chroma;
|
|
GstVaapiEntrypoint entrypoint_start, entrypoint_end;
|
|
|
|
if (usage == GST_VAAPI_CONTEXT_USAGE_ENCODE) {
|
|
profiles = gst_vaapi_display_get_encode_profiles (display);
|
|
entrypoint_start = GST_VAAPI_ENTRYPOINT_SLICE_ENCODE;
|
|
entrypoint_end = GST_VAAPI_ENTRYPOINT_SLICE_ENCODE_LP;
|
|
} else if (usage == GST_VAAPI_CONTEXT_USAGE_DECODE) {
|
|
profiles = gst_vaapi_display_get_decode_profiles (display);
|
|
entrypoint_start = GST_VAAPI_ENTRYPOINT_VLD;
|
|
entrypoint_end = GST_VAAPI_ENTRYPOINT_MOCO;
|
|
}
|
|
/* TODO: VPP */
|
|
|
|
if (!profiles)
|
|
goto out;
|
|
|
|
chroma = 0;
|
|
for (i = 0; i < profiles->len; i++) {
|
|
profile = g_array_index (profiles, GstVaapiProfile, i);
|
|
if (gst_vaapi_profile_get_codec (profile) != codec)
|
|
continue;
|
|
|
|
for (e = entrypoint_start; e <= entrypoint_end; e++) {
|
|
if (!gst_vaapi_get_config_attribute (display,
|
|
gst_vaapi_profile_get_va_profile (profile),
|
|
gst_vaapi_entrypoint_get_va_entrypoint (e),
|
|
VAConfigAttribRTFormat, &value))
|
|
continue;
|
|
|
|
chroma |= value;
|
|
}
|
|
}
|
|
|
|
if (!chroma)
|
|
goto out;
|
|
|
|
for (gst_chroma = GST_VAAPI_CHROMA_TYPE_YUV420;
|
|
gst_chroma <= GST_VAAPI_CHROMA_TYPE_YUV444_12BPP; gst_chroma++) {
|
|
GArray *fmts;
|
|
if (!(chroma & from_GstVaapiChromaType (gst_chroma)))
|
|
continue;
|
|
|
|
fmts = gst_vaapi_video_format_get_formats_by_chroma (gst_chroma);
|
|
if (!fmts)
|
|
continue;
|
|
|
|
/* One format can not belong to different chroma, no need to merge */
|
|
if (supported_fmts == NULL) {
|
|
supported_fmts = fmts;
|
|
} else {
|
|
for (i = 0; i < fmts->len; i++)
|
|
g_array_append_val (supported_fmts,
|
|
g_array_index (fmts, GstVideoFormat, i));
|
|
g_array_unref (fmts);
|
|
}
|
|
}
|
|
|
|
if (!supported_fmts)
|
|
goto out;
|
|
|
|
if (extra_fmts) {
|
|
for (i = 0; i < extra_fmts->len; i++)
|
|
g_array_append_val (supported_fmts,
|
|
g_array_index (extra_fmts, GstVideoFormat, i));
|
|
}
|
|
|
|
out_caps = gst_vaapi_build_caps_from_formats (supported_fmts, 1, 1,
|
|
G_MAXINT, G_MAXINT, TRUE);
|
|
|
|
out:
|
|
if (profiles)
|
|
g_array_unref (profiles);
|
|
if (supported_fmts)
|
|
g_array_unref (supported_fmts);
|
|
|
|
return out_caps;
|
|
}
|