gstreamer/gst-libs/gst/vaapi/gstvaapicontext.c
He Junyan ac3e8c7c40 libs: decoder: context: remove surfaces binding from context.
The vaCreateContext do not need to specify the surfaces for the
context creation now. So we do not need to bind any surface to the
context anymore. Surfaces should be the resource belong to display
and just be used in encoder/decoder context.

The previous manner has big limitation for decoder. The context's
surface number is decided by dpb size. All the surfaces in dpb will
be attached to a gstbuffer and be pushed to down stream, and the
decoder need to wait down stream free the surface and go on if not
enough surface available. For more and more use cases, this causes
deadlock. For example,

gst-launch-1.0 filesrc location=a.h264 ! h264parse ! vaapih264dec
! x264enc ! filesink location=./output.h264

will cause deadlock and make the whole pipeline hang.
the x264enc encoder need to cache more than dpb size surfaces.

The best solution is seperating the surfaces number and the dpb size.
dpb and dpb size shoule be virtual concepts maintained by the decoder.
And let the surfaces_pool in context maintain the re-use of all surfaces.

For encoder, the situation is better, all the surfaces are just used
as reference frame and no need to be pushed to down stream. We can
just reserve and set the capacity of the surfaces_pool to meet the
request.

Fix: #147
Fix: #88

Co-Author: Víctor Manuel Jáquez Leal <vjaquez@igalia.com>
Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer-vaapi/-/merge_requests/353>
2020-07-09 16:06:23 +00:00

761 lines
23 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, capacity;
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, 0);
} 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;
}
capacity = cip->usage == GST_VAAPI_CONTEXT_USAGE_DECODE ? 0 : num_surfaces;
gst_vaapi_video_pool_set_capacity (context->surfaces_pool, capacity);
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, 0);
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;
VASurfaceID *surfaces_data = NULL;
VAStatus status;
GArray *surfaces = NULL;
gboolean success = FALSE;
guint i;
gint num_surfaces = 0;
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);
/* vaCreateContext() doesn't really need an array of VASurfaceIDs (see
* https://lists.01.org/pipermail/intel-vaapi-media/2017-July/000052.html and
* https://github.com/intel/libva/issues/251); pass a dummy list of valid
* (non-null) IDs until the signature gets updated. */
if (cip->usage != GST_VAAPI_CONTEXT_USAGE_DECODE) {
surfaces_data = (VASurfaceID *) surfaces->data;
num_surfaces = surfaces->len;
}
GST_VAAPI_DISPLAY_LOCK (display);
status = vaCreateContext (GST_VAAPI_DISPLAY_VADISPLAY (display),
context->va_config, cip->width, cip->height, VA_PROGRESSIVE,
surfaces_data, num_surfaces, &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_unref (surfaces);
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%08" G_GSIZE_MODIFIER "x / 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);
if (gst_vaapi_video_pool_get_capacity (context->surfaces_pool) == 0)
return G_MAXUINT;
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);
}
}