mirror of
https://gitlab.freedesktop.org/gstreamer/gstreamer.git
synced 2024-12-04 23:46:43 +00:00
21dd66b5e4
This commit tries to centralize the selection of vaCreateSurfaces version, instead of having fallbacks everywhere. These fallbacks are hacks, added because new drivers use the latest version of vaCreateSurfaces (with surface attributes) [1], meanwhile old drivers (or profiles as JPEG decoder in i965) might rather use the old version. In order to select which method, there's detected hack: each config context has a list of valid formats, in the case of JPEG decoder the list only contains "rare" 4:2:2 formats (ICM3, GRAY8) which aren't handled correctly by the current gstreamer-vaapi code [2]. The hack consist in identify if the format list contains an arbitrary preferred format (which is suposedly well supported by gstreamer-vaapi, mostly NV12). If no prefered colour format is found, the the old version of vaCreateSurfaces is used, and the surfaces wil be mapped into a image with their own color format. 1. https://bugzilla.gnome.org/show_bug.cgi?id=797143 2. https://bugzilla.gnome.org/show_bug.cgi?id=797222
745 lines
22 KiB
C
745 lines
22 KiB
C
/*
|
|
* gstvaapicontext.c - VA context abstraction
|
|
*
|
|
* Copyright (C) 2010-2011 Splitted-Desktop Systems
|
|
* 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
|
|
* as published by the Free Software Foundation; either version 2.1
|
|
* of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free
|
|
* Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
|
|
* Boston, MA 02110-1301 USA
|
|
*/
|
|
|
|
/**
|
|
* SECTION:gstvaapicontext
|
|
* @short_description: VA context abstraction
|
|
*/
|
|
|
|
#include "sysdeps.h"
|
|
#include "gstvaapicompat.h"
|
|
#include "gstvaapicontext.h"
|
|
#include "gstvaapidisplay_priv.h"
|
|
#include "gstvaapisurface_priv.h"
|
|
#include "gstvaapisurfacepool.h"
|
|
#include "gstvaapisurfaceproxy.h"
|
|
#include "gstvaapivideopool_priv.h"
|
|
#include "gstvaapiutils.h"
|
|
|
|
/* Define default VA surface chroma format to YUV 4:2:0 */
|
|
#define DEFAULT_CHROMA_TYPE (GST_VAAPI_CHROMA_TYPE_YUV420)
|
|
|
|
/* Number of scratch surfaces beyond those used as reference */
|
|
#define SCRATCH_SURFACES_COUNT (4)
|
|
|
|
/* Debug category for GstVaapiContext */
|
|
GST_DEBUG_CATEGORY (gst_debug_vaapi_context);
|
|
#define GST_CAT_DEFAULT gst_debug_vaapi_context
|
|
|
|
static void
|
|
_init_vaapi_context_debug (void)
|
|
{
|
|
#ifndef GST_DISABLE_GST_DEBUG
|
|
static volatile gsize _init = 0;
|
|
|
|
if (g_once_init_enter (&_init)) {
|
|
GST_DEBUG_CATEGORY_INIT (gst_debug_vaapi_context, "vaapicontext", 0,
|
|
"VA-API context");
|
|
g_once_init_leave (&_init, 1);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
static gboolean
|
|
ensure_attributes (GstVaapiContext * context)
|
|
{
|
|
if (G_LIKELY (context->attribs))
|
|
return TRUE;
|
|
|
|
context->attribs =
|
|
gst_vaapi_config_surface_attributes_get (GST_VAAPI_CONTEXT_DISPLAY
|
|
(context), context->va_config);
|
|
return (context->attribs != NULL);
|
|
}
|
|
|
|
/* looks for the (very arbritrary) preferred format from the requested
|
|
* context chroma type, in the context attributes */
|
|
static GstVideoFormat
|
|
get_preferred_format (GstVaapiContext * context)
|
|
{
|
|
const GstVaapiContextInfo *const cip = &context->info;
|
|
GArray *formats;
|
|
guint i;
|
|
|
|
if (context->preferred_format != GST_VIDEO_FORMAT_UNKNOWN)
|
|
return context->preferred_format;
|
|
|
|
if (!ensure_attributes (context) || !context->attribs->formats)
|
|
return GST_VIDEO_FORMAT_UNKNOWN;
|
|
|
|
formats = context->attribs->formats;
|
|
for (i = 0; i < formats->len; i++) {
|
|
GstVideoFormat format = g_array_index (formats, GstVideoFormat, i);
|
|
if (format == gst_vaapi_video_format_from_chroma (cip->chroma_type)) {
|
|
context->preferred_format = format;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return context->preferred_format;
|
|
}
|
|
|
|
static inline gboolean
|
|
context_get_attribute (GstVaapiContext * context, VAConfigAttribType type,
|
|
guint * out_value_ptr)
|
|
{
|
|
return gst_vaapi_get_config_attribute (GST_VAAPI_CONTEXT_DISPLAY (context),
|
|
context->va_profile, context->va_entrypoint, type, out_value_ptr);
|
|
}
|
|
|
|
static void
|
|
context_destroy_surfaces (GstVaapiContext * context)
|
|
{
|
|
if (context->surfaces) {
|
|
g_ptr_array_unref (context->surfaces);
|
|
context->surfaces = NULL;
|
|
}
|
|
|
|
context->preferred_format = GST_VIDEO_FORMAT_UNKNOWN;
|
|
|
|
gst_vaapi_video_pool_replace (&context->surfaces_pool, NULL);
|
|
}
|
|
|
|
static void
|
|
context_destroy (GstVaapiContext * context)
|
|
{
|
|
GstVaapiDisplay *const display = GST_VAAPI_CONTEXT_DISPLAY (context);
|
|
VAContextID context_id;
|
|
VAStatus status;
|
|
|
|
context_id = GST_VAAPI_CONTEXT_ID (context);
|
|
GST_DEBUG ("context 0x%08x / config 0x%08x", context_id, context->va_config);
|
|
|
|
if (context_id != VA_INVALID_ID) {
|
|
GST_VAAPI_DISPLAY_LOCK (display);
|
|
status = vaDestroyContext (GST_VAAPI_DISPLAY_VADISPLAY (display),
|
|
context_id);
|
|
GST_VAAPI_DISPLAY_UNLOCK (display);
|
|
if (!vaapi_check_status (status, "vaDestroyContext()"))
|
|
GST_WARNING ("failed to destroy context 0x%08x", context_id);
|
|
GST_VAAPI_CONTEXT_ID (context) = VA_INVALID_ID;
|
|
}
|
|
|
|
if (context->va_config != VA_INVALID_ID) {
|
|
GST_VAAPI_DISPLAY_LOCK (display);
|
|
status = vaDestroyConfig (GST_VAAPI_DISPLAY_VADISPLAY (display),
|
|
context->va_config);
|
|
GST_VAAPI_DISPLAY_UNLOCK (display);
|
|
if (!vaapi_check_status (status, "vaDestroyConfig()"))
|
|
GST_WARNING ("failed to destroy config 0x%08x", context->va_config);
|
|
context->va_config = VA_INVALID_ID;
|
|
}
|
|
|
|
if (context->attribs) {
|
|
gst_vaapi_config_surface_attributes_free (context->attribs);
|
|
context->attribs = NULL;
|
|
}
|
|
}
|
|
|
|
static gboolean
|
|
context_ensure_surfaces (GstVaapiContext * context)
|
|
{
|
|
GstVaapiDisplay *display = GST_VAAPI_CONTEXT_DISPLAY (context);
|
|
const GstVaapiContextInfo *const cip = &context->info;
|
|
const guint num_surfaces = cip->ref_frames + SCRATCH_SURFACES_COUNT;
|
|
GstVaapiSurface *surface;
|
|
GstVideoFormat format;
|
|
guint i;
|
|
|
|
format = get_preferred_format (context);
|
|
for (i = context->surfaces->len; i < num_surfaces; i++) {
|
|
if (format != GST_VIDEO_FORMAT_UNKNOWN) {
|
|
surface = gst_vaapi_surface_new_with_format (display, format, cip->width,
|
|
cip->height);
|
|
} else {
|
|
surface = gst_vaapi_surface_new (display, cip->chroma_type, cip->width,
|
|
cip->height);
|
|
}
|
|
if (!surface)
|
|
return FALSE;
|
|
g_ptr_array_add (context->surfaces, surface);
|
|
if (!gst_vaapi_video_pool_add_object (context->surfaces_pool, surface))
|
|
return FALSE;
|
|
}
|
|
gst_vaapi_video_pool_set_capacity (context->surfaces_pool, num_surfaces);
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
context_create_surfaces (GstVaapiContext * context)
|
|
{
|
|
const GstVaapiContextInfo *const cip = &context->info;
|
|
GstVaapiDisplay *const display = GST_VAAPI_CONTEXT_DISPLAY (context);
|
|
guint num_surfaces;
|
|
|
|
num_surfaces = cip->ref_frames + SCRATCH_SURFACES_COUNT;
|
|
if (!context->surfaces) {
|
|
context->surfaces = g_ptr_array_new_full (num_surfaces,
|
|
(GDestroyNotify) gst_mini_object_unref);
|
|
if (!context->surfaces)
|
|
return FALSE;
|
|
}
|
|
|
|
if (!context->surfaces_pool) {
|
|
context->surfaces_pool =
|
|
gst_vaapi_surface_pool_new_with_chroma_type (display, cip->chroma_type,
|
|
cip->width, cip->height);
|
|
|
|
if (!context->surfaces_pool)
|
|
return FALSE;
|
|
}
|
|
return context_ensure_surfaces (context);
|
|
}
|
|
|
|
static gboolean
|
|
context_create (GstVaapiContext * context)
|
|
{
|
|
const GstVaapiContextInfo *const cip = &context->info;
|
|
GstVaapiDisplay *const display = GST_VAAPI_CONTEXT_DISPLAY (context);
|
|
VAContextID context_id;
|
|
VASurfaceID surface_id;
|
|
VAStatus status;
|
|
GArray *surfaces = NULL;
|
|
gboolean success = FALSE;
|
|
guint i;
|
|
|
|
if (!context->surfaces && !context_create_surfaces (context))
|
|
goto cleanup;
|
|
|
|
/* Create VA surfaces list for vaCreateContext() */
|
|
surfaces = g_array_sized_new (FALSE,
|
|
FALSE, sizeof (VASurfaceID), context->surfaces->len);
|
|
if (!surfaces)
|
|
goto cleanup;
|
|
|
|
for (i = 0; i < context->surfaces->len; i++) {
|
|
GstVaapiSurface *const surface = g_ptr_array_index (context->surfaces, i);
|
|
if (!surface)
|
|
goto cleanup;
|
|
surface_id = GST_VAAPI_SURFACE_ID (surface);
|
|
g_array_append_val (surfaces, surface_id);
|
|
}
|
|
g_assert (surfaces->len == context->surfaces->len);
|
|
|
|
GST_VAAPI_DISPLAY_LOCK (display);
|
|
status = vaCreateContext (GST_VAAPI_DISPLAY_VADISPLAY (display),
|
|
context->va_config, cip->width, cip->height, VA_PROGRESSIVE,
|
|
(VASurfaceID *) surfaces->data, surfaces->len, &context_id);
|
|
GST_VAAPI_DISPLAY_UNLOCK (display);
|
|
if (!vaapi_check_status (status, "vaCreateContext()"))
|
|
goto cleanup;
|
|
|
|
GST_VAAPI_CONTEXT_ID (context) = context_id;
|
|
success = TRUE;
|
|
|
|
cleanup:
|
|
if (surfaces)
|
|
g_array_free (surfaces, TRUE);
|
|
return success;
|
|
}
|
|
|
|
static gboolean
|
|
config_create (GstVaapiContext * context)
|
|
{
|
|
const GstVaapiContextInfo *const cip = &context->info;
|
|
GstVaapiDisplay *const display = GST_VAAPI_CONTEXT_DISPLAY (context);
|
|
VAConfigAttrib attribs[7], *attrib;
|
|
VAStatus status;
|
|
guint value, va_chroma_format, attrib_index;
|
|
|
|
/* Reset profile and entrypoint */
|
|
if (cip->profile == GST_VAAPI_PROFILE_UNKNOWN
|
|
|| cip->entrypoint == GST_VAAPI_ENTRYPOINT_INVALID)
|
|
goto cleanup;
|
|
context->va_profile = gst_vaapi_profile_get_va_profile (cip->profile);
|
|
context->va_entrypoint =
|
|
gst_vaapi_entrypoint_get_va_entrypoint (cip->entrypoint);
|
|
|
|
attrib_index = 0;
|
|
attrib = &attribs[attrib_index];
|
|
g_assert (attrib_index < G_N_ELEMENTS (attribs));
|
|
|
|
/* Validate VA surface format */
|
|
va_chroma_format = from_GstVaapiChromaType (cip->chroma_type);
|
|
if (!va_chroma_format)
|
|
goto cleanup;
|
|
attrib->type = VAConfigAttribRTFormat;
|
|
if (!context_get_attribute (context, attrib->type, &value))
|
|
goto cleanup;
|
|
if (!(value & va_chroma_format)) {
|
|
GST_ERROR ("unsupported chroma format (%s)",
|
|
string_of_va_chroma_format (va_chroma_format));
|
|
goto cleanup;
|
|
}
|
|
attrib->value = va_chroma_format;
|
|
attrib = &attribs[++attrib_index];
|
|
g_assert (attrib_index < G_N_ELEMENTS (attribs));
|
|
|
|
switch (cip->usage) {
|
|
#if USE_ENCODERS
|
|
case GST_VAAPI_CONTEXT_USAGE_ENCODE:
|
|
{
|
|
const GstVaapiConfigInfoEncoder *const config = &cip->config.encoder;
|
|
guint va_rate_control;
|
|
|
|
/* Rate control */
|
|
va_rate_control = from_GstVaapiRateControl (config->rc_mode);
|
|
if (va_rate_control != VA_RC_NONE) {
|
|
attrib->type = VAConfigAttribRateControl;
|
|
if (!context_get_attribute (context, attrib->type, &value))
|
|
goto cleanup;
|
|
|
|
if ((value & va_rate_control) != va_rate_control) {
|
|
GST_ERROR ("unsupported %s rate control",
|
|
string_of_VARateControl (va_rate_control));
|
|
goto cleanup;
|
|
}
|
|
attrib->value = va_rate_control;
|
|
attrib = &attribs[++attrib_index];
|
|
g_assert (attrib_index < G_N_ELEMENTS (attribs));
|
|
}
|
|
/* Packed headers */
|
|
if (config->packed_headers) {
|
|
attrib->type = VAConfigAttribEncPackedHeaders;
|
|
if (!context_get_attribute (context, attrib->type, &value))
|
|
goto cleanup;
|
|
|
|
if ((value & config->packed_headers) != config->packed_headers) {
|
|
GST_ERROR ("unsupported packed headers 0x%08x",
|
|
config->packed_headers & ~(value & config->packed_headers));
|
|
goto cleanup;
|
|
}
|
|
attrib->value = config->packed_headers;
|
|
attrib = &attribs[++attrib_index];
|
|
g_assert (attrib_index < G_N_ELEMENTS (attribs));
|
|
}
|
|
if (cip->profile == GST_VAAPI_PROFILE_JPEG_BASELINE) {
|
|
attrib->type = VAConfigAttribEncJPEG;
|
|
if (!context_get_attribute (context, attrib->type, &value))
|
|
goto cleanup;
|
|
attrib->value = value;
|
|
attrib = &attribs[++attrib_index];
|
|
g_assert (attrib_index < G_N_ELEMENTS (attribs));
|
|
}
|
|
#if VA_CHECK_VERSION(0,39,1)
|
|
if (config->roi_capability) {
|
|
VAConfigAttribValEncROI *roi_config;
|
|
|
|
attrib->type = VAConfigAttribEncROI;
|
|
if (!context_get_attribute (context, attrib->type, &value))
|
|
goto cleanup;
|
|
roi_config = (VAConfigAttribValEncROI *) & value;
|
|
if (roi_config->bits.num_roi_regions != config->roi_num_supported) {
|
|
GST_ERROR ("Mismatched ROI support: number of regions supported: %d",
|
|
roi_config->bits.num_roi_regions);
|
|
goto cleanup;
|
|
}
|
|
if (config->rc_mode != GST_VAAPI_RATECONTROL_CQP
|
|
&& VA_ROI_RC_QP_DELTA_SUPPORT (roi_config) == 0) {
|
|
GST_ERROR ("Mismatched ROI support: ROI delta QP: %d",
|
|
VA_ROI_RC_QP_DELTA_SUPPORT (roi_config));
|
|
goto cleanup;
|
|
}
|
|
attrib->value = value;
|
|
attrib = &attribs[++attrib_index];
|
|
g_assert (attrib_index < G_N_ELEMENTS (attribs));
|
|
}
|
|
#endif
|
|
break;
|
|
}
|
|
#endif
|
|
default:
|
|
break;
|
|
}
|
|
|
|
GST_VAAPI_DISPLAY_LOCK (display);
|
|
status = vaCreateConfig (GST_VAAPI_DISPLAY_VADISPLAY (display),
|
|
context->va_profile, context->va_entrypoint, attribs, attrib_index,
|
|
&context->va_config);
|
|
GST_VAAPI_DISPLAY_UNLOCK (display);
|
|
if (!vaapi_check_status (status, "vaCreateConfig()"))
|
|
goto cleanup;
|
|
|
|
return TRUE;
|
|
cleanup:
|
|
GST_WARNING ("Failed to create vaConfig");
|
|
return FALSE;
|
|
}
|
|
|
|
/** Updates config for encoding. Returns %TRUE if config changed */
|
|
static gboolean
|
|
context_update_config_encoder (GstVaapiContext * context,
|
|
const GstVaapiConfigInfoEncoder * new_config)
|
|
{
|
|
GstVaapiConfigInfoEncoder *const config = &context->info.config.encoder;
|
|
gboolean config_changed = FALSE;
|
|
|
|
g_assert (context->info.usage == GST_VAAPI_CONTEXT_USAGE_ENCODE);
|
|
|
|
if (config->rc_mode != new_config->rc_mode) {
|
|
config->rc_mode = new_config->rc_mode;
|
|
config_changed = TRUE;
|
|
}
|
|
|
|
if (config->packed_headers != new_config->packed_headers) {
|
|
config->packed_headers = new_config->packed_headers;
|
|
config_changed = TRUE;
|
|
}
|
|
|
|
if (config->roi_capability != new_config->roi_capability ||
|
|
config->roi_num_supported != new_config->roi_num_supported) {
|
|
config->roi_capability = new_config->roi_capability;
|
|
config->roi_num_supported = new_config->roi_num_supported;
|
|
config_changed = TRUE;
|
|
}
|
|
|
|
return config_changed;
|
|
}
|
|
|
|
static inline void
|
|
gst_vaapi_context_init (GstVaapiContext * context,
|
|
const GstVaapiContextInfo * new_cip)
|
|
{
|
|
GstVaapiContextInfo *const cip = &context->info;
|
|
|
|
*cip = *new_cip;
|
|
if (!cip->chroma_type)
|
|
cip->chroma_type = DEFAULT_CHROMA_TYPE;
|
|
|
|
context->va_config = VA_INVALID_ID;
|
|
context->reset_on_resize = TRUE;
|
|
|
|
context->attribs = NULL;
|
|
context->preferred_format = GST_VIDEO_FORMAT_UNKNOWN;
|
|
}
|
|
|
|
/**
|
|
* gst_vaapi_context_new:
|
|
* @display: a #GstVaapiDisplay
|
|
* @cip: a pointer to the #GstVaapiContextInfo
|
|
*
|
|
* Creates a new #GstVaapiContext with the configuration specified by
|
|
* @cip, thus including profile, entry-point, encoded size and maximum
|
|
* number of reference frames reported by the bitstream.
|
|
*
|
|
* Return value: the newly allocated #GstVaapiContext object
|
|
*/
|
|
GstVaapiContext *
|
|
gst_vaapi_context_new (GstVaapiDisplay * display,
|
|
const GstVaapiContextInfo * cip)
|
|
{
|
|
GstVaapiContext *context;
|
|
|
|
g_return_val_if_fail (display, NULL);
|
|
|
|
_init_vaapi_context_debug ();
|
|
|
|
if (cip->profile == GST_VAAPI_PROFILE_UNKNOWN
|
|
|| cip->entrypoint == GST_VAAPI_ENTRYPOINT_INVALID)
|
|
return NULL;
|
|
|
|
context = g_slice_new (GstVaapiContext);
|
|
if (!context)
|
|
return NULL;
|
|
|
|
GST_VAAPI_CONTEXT_DISPLAY (context) = gst_object_ref (display);
|
|
GST_VAAPI_CONTEXT_ID (context) = VA_INVALID_ID;
|
|
g_atomic_int_set (&context->ref_count, 1);
|
|
context->surfaces = NULL;
|
|
context->surfaces_pool = NULL;
|
|
|
|
gst_vaapi_context_init (context, cip);
|
|
|
|
if (!config_create (context))
|
|
goto error;
|
|
|
|
/* this means we don't want to create a VAcontext */
|
|
if (cip->width == 0 && cip->height == 0)
|
|
goto done;
|
|
|
|
/* this is not valid */
|
|
if (cip->width == 0 || cip->height == 0)
|
|
goto error;
|
|
|
|
if (!context_create (context))
|
|
goto error;
|
|
|
|
done:
|
|
GST_DEBUG ("context 0x%08lx / config 0x%08x",
|
|
GST_VAAPI_CONTEXT_ID (context), context->va_config);
|
|
return context;
|
|
|
|
/* ERRORS */
|
|
error:
|
|
{
|
|
gst_vaapi_context_unref (context);
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* gst_vaapi_context_reset:
|
|
* @context: a #GstVaapiContext
|
|
* @new_cip: a pointer to the new #GstVaapiContextInfo details
|
|
*
|
|
* Resets @context to the configuration specified by @new_cip, thus
|
|
* including profile, entry-point, encoded size and maximum number of
|
|
* reference frames reported by the bitstream.
|
|
*
|
|
* Return value: %TRUE on success
|
|
*/
|
|
gboolean
|
|
gst_vaapi_context_reset (GstVaapiContext * context,
|
|
const GstVaapiContextInfo * new_cip)
|
|
{
|
|
GstVaapiContextInfo *const cip = &context->info;
|
|
gboolean reset_surfaces = FALSE, reset_config = FALSE;
|
|
gboolean grow_surfaces = FALSE;
|
|
GstVaapiChromaType chroma_type;
|
|
|
|
if (new_cip->profile == GST_VAAPI_PROFILE_UNKNOWN
|
|
|| new_cip->entrypoint == GST_VAAPI_ENTRYPOINT_INVALID)
|
|
return FALSE;
|
|
|
|
chroma_type = new_cip->chroma_type ? new_cip->chroma_type :
|
|
DEFAULT_CHROMA_TYPE;
|
|
if (cip->chroma_type != chroma_type) {
|
|
cip->chroma_type = chroma_type;
|
|
reset_surfaces = TRUE;
|
|
}
|
|
|
|
if (cip->width != new_cip->width || cip->height != new_cip->height) {
|
|
cip->width = new_cip->width;
|
|
cip->height = new_cip->height;
|
|
reset_surfaces = TRUE;
|
|
}
|
|
|
|
if (cip->profile != new_cip->profile ||
|
|
cip->entrypoint != new_cip->entrypoint) {
|
|
cip->profile = new_cip->profile;
|
|
cip->entrypoint = new_cip->entrypoint;
|
|
reset_config = TRUE;
|
|
}
|
|
|
|
if (cip->ref_frames < new_cip->ref_frames) {
|
|
cip->ref_frames = new_cip->ref_frames;
|
|
grow_surfaces = TRUE;
|
|
}
|
|
|
|
if (cip->usage != new_cip->usage) {
|
|
cip->usage = new_cip->usage;
|
|
reset_config = TRUE;
|
|
memcpy (&cip->config, &new_cip->config, sizeof (cip->config));
|
|
} else if (new_cip->usage == GST_VAAPI_CONTEXT_USAGE_ENCODE) {
|
|
if (context_update_config_encoder (context, &new_cip->config.encoder))
|
|
reset_config = TRUE;
|
|
} else if (new_cip->usage == GST_VAAPI_CONTEXT_USAGE_DECODE) {
|
|
if ((reset_surfaces && context->reset_on_resize) || grow_surfaces)
|
|
reset_config = TRUE;
|
|
}
|
|
|
|
if (reset_surfaces)
|
|
context_destroy_surfaces (context);
|
|
if (reset_config)
|
|
context_destroy (context);
|
|
|
|
if (reset_config && !(config_create (context) && context_create (context)))
|
|
return FALSE;
|
|
if (reset_surfaces && !context_create_surfaces (context))
|
|
return FALSE;
|
|
else if (grow_surfaces && !context_ensure_surfaces (context))
|
|
return FALSE;
|
|
return TRUE;
|
|
}
|
|
|
|
/**
|
|
* gst_vaapi_context_get_id:
|
|
* @context: a #GstVaapiContext
|
|
*
|
|
* Returns the underlying VAContextID of the @context.
|
|
*
|
|
* Return value: the underlying VA context id
|
|
*/
|
|
GstVaapiID
|
|
gst_vaapi_context_get_id (GstVaapiContext * context)
|
|
{
|
|
g_return_val_if_fail (context != NULL, VA_INVALID_ID);
|
|
|
|
return GST_VAAPI_CONTEXT_ID (context);
|
|
}
|
|
|
|
/**
|
|
* gst_vaapi_context_get_surface_proxy:
|
|
* @context: a #GstVaapiContext
|
|
*
|
|
* Acquires a free surface, wrapped into a #GstVaapiSurfaceProxy. The
|
|
* returned surface will be automatically released when the proxy is
|
|
* destroyed. So, it is enough to call gst_vaapi_surface_proxy_unref()
|
|
* after usage.
|
|
*
|
|
* This function returns %NULL if there is no free surface available
|
|
* in the pool. The surfaces are pre-allocated during context creation
|
|
* though.
|
|
*
|
|
* Return value: a free surface, or %NULL if none is available
|
|
*/
|
|
GstVaapiSurfaceProxy *
|
|
gst_vaapi_context_get_surface_proxy (GstVaapiContext * context)
|
|
{
|
|
g_return_val_if_fail (context != NULL, NULL);
|
|
|
|
return
|
|
gst_vaapi_surface_proxy_new_from_pool (GST_VAAPI_SURFACE_POOL
|
|
(context->surfaces_pool));
|
|
}
|
|
|
|
/**
|
|
* gst_vaapi_context_get_surface_count:
|
|
* @context: a #GstVaapiContext
|
|
*
|
|
* Retrieves the number of free surfaces left in the pool.
|
|
*
|
|
* Return value: the number of free surfaces available in the pool
|
|
*/
|
|
guint
|
|
gst_vaapi_context_get_surface_count (GstVaapiContext * context)
|
|
{
|
|
g_return_val_if_fail (context != NULL, 0);
|
|
|
|
return gst_vaapi_video_pool_get_size (context->surfaces_pool);
|
|
}
|
|
|
|
/**
|
|
* gst_vaapi_context_reset_on_resize:
|
|
* @context: a #GstVaapiContext
|
|
* @reset_on_resize: Should the context be reset on size change
|
|
*
|
|
* Sets whether the underlying context should be reset when a size change
|
|
* happens. The proper setting for this is codec dependent.
|
|
*/
|
|
void
|
|
gst_vaapi_context_reset_on_resize (GstVaapiContext * context,
|
|
gboolean reset_on_resize)
|
|
{
|
|
g_return_if_fail (context != NULL);
|
|
|
|
context->reset_on_resize = reset_on_resize;
|
|
}
|
|
|
|
/**
|
|
* gst_vaapi_context_get_surface_formats:
|
|
* @context: a #GstVaapiContext
|
|
*
|
|
* Determines the set of supported formats by the surfaces associated
|
|
* to @context. The caller owns an extra reference of the resulting
|
|
* array of #GstVideoFormat elements, so it shall be released with
|
|
* g_array_unref after usage.
|
|
*
|
|
* Return value: (transfer full): the set of target formats supported
|
|
* by the surfaces in @context.
|
|
*/
|
|
GArray *
|
|
gst_vaapi_context_get_surface_formats (GstVaapiContext * context)
|
|
{
|
|
g_return_val_if_fail (context, NULL);
|
|
|
|
if (!ensure_attributes (context))
|
|
return NULL;
|
|
|
|
if (context->attribs->formats)
|
|
return g_array_ref (context->attribs->formats);
|
|
return NULL;
|
|
}
|
|
|
|
/**
|
|
* gst_vaapi_context_get_surface_attributes:
|
|
* @context: a #GstVaapiContext
|
|
* @out_attribs: an allocated #GstVaapiConfigSurfaceAttributes
|
|
*
|
|
* Copy context's surface restrictions to @out_attribs, EXCEPT the
|
|
* color formats. Use gst_vaapi_context_get_surface_formats() to get
|
|
* them.
|
|
*
|
|
* Returns: %TRUE if the attributes were extracted and copied; %FALSE,
|
|
* otherwise
|
|
**/
|
|
gboolean
|
|
gst_vaapi_context_get_surface_attributes (GstVaapiContext * context,
|
|
GstVaapiConfigSurfaceAttributes * out_attribs)
|
|
{
|
|
g_return_val_if_fail (context, FALSE);
|
|
|
|
if (!ensure_attributes (context))
|
|
return FALSE;
|
|
|
|
if (out_attribs) {
|
|
out_attribs->min_width = context->attribs->min_width;
|
|
out_attribs->min_height = context->attribs->min_height;
|
|
out_attribs->max_width = context->attribs->max_width;
|
|
out_attribs->max_height = context->attribs->max_height;
|
|
out_attribs->mem_types = context->attribs->mem_types;
|
|
out_attribs->formats = NULL;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/**
|
|
* gst_vaapi_context_ref:
|
|
* @context: a #GstVaapiContext
|
|
*
|
|
* Atomically increases the reference count of the given @context by one.
|
|
*
|
|
* Returns: The same @context argument
|
|
*/
|
|
GstVaapiContext *
|
|
gst_vaapi_context_ref (GstVaapiContext * context)
|
|
{
|
|
g_return_val_if_fail (context != NULL, NULL);
|
|
|
|
g_atomic_int_inc (&context->ref_count);
|
|
|
|
return context;
|
|
}
|
|
|
|
/**
|
|
* gst_vaapi_context_unref:
|
|
* @context: a #GstVaapiContext
|
|
*
|
|
* Atomically decreases the reference count of the @context by one. If
|
|
* the reference count reaches zero, the object will be free'd.
|
|
*/
|
|
void
|
|
gst_vaapi_context_unref (GstVaapiContext * context)
|
|
{
|
|
g_return_if_fail (context != NULL);
|
|
g_return_if_fail (context->ref_count > 0);
|
|
|
|
if (g_atomic_int_dec_and_test (&context->ref_count)) {
|
|
context_destroy (context);
|
|
context_destroy_surfaces (context);
|
|
gst_vaapi_display_replace (&context->display, NULL);
|
|
g_slice_free (GstVaapiContext, context);
|
|
}
|
|
}
|