mirror of
https://gitlab.freedesktop.org/gstreamer/gstreamer.git
synced 2024-09-22 20:10:13 +00:00
9d865453e1
Addresses #228 on iHD side. It seems iHD can't handle VAProcColorStandardSRGB in all situations for vpp. But it has no problem when we specify the sRGB parameters via VAProcColorStandardExplicit parameters.
1008 lines
25 KiB
C
1008 lines
25 KiB
C
/*
|
|
* gstvaapiutils.c - VA-API utilities
|
|
*
|
|
* 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
|
|
*/
|
|
|
|
#include "sysdeps.h"
|
|
#include "gstvaapicompat.h"
|
|
#include "gstvaapiutils.h"
|
|
#include "gstvaapibufferproxy.h"
|
|
#include "gstvaapifilter.h"
|
|
#include "gstvaapisubpicture.h"
|
|
#include "gstvaapisurface.h"
|
|
#include <stdio.h>
|
|
#include <stdarg.h>
|
|
|
|
#define DEBUG 1
|
|
#include "gstvaapidebug.h"
|
|
|
|
/* string case an enum */
|
|
#define STRCASEP(p, x) STRCASE(G_PASTE(p, x))
|
|
#define STRCASE(x) case x: return G_STRINGIFY(x)
|
|
|
|
/* string case a macro */
|
|
#define STRCASEM(p, x) case G_PASTE(p, x): return G_STRINGIFY(x)
|
|
|
|
#if VA_CHECK_VERSION (0,40,0)
|
|
static gchar *
|
|
strip_msg (const char *message)
|
|
{
|
|
gchar *msg;
|
|
|
|
msg = g_strdup (message);
|
|
if (!msg)
|
|
return NULL;
|
|
return g_strstrip (msg);
|
|
}
|
|
|
|
#if VA_CHECK_VERSION (1,0,0)
|
|
static void
|
|
gst_vaapi_err (void *data, const char *message)
|
|
{
|
|
gchar *msg;
|
|
|
|
msg = strip_msg (message);
|
|
if (!msg)
|
|
return;
|
|
GST_ERROR ("%s", msg);
|
|
g_free (msg);
|
|
}
|
|
|
|
static void
|
|
gst_vaapi_warning (void *data, const char *message)
|
|
{
|
|
gchar *msg;
|
|
|
|
msg = strip_msg (message);
|
|
if (!msg)
|
|
return;
|
|
GST_WARNING ("%s", msg);
|
|
g_free (msg);
|
|
}
|
|
#endif
|
|
|
|
static void
|
|
gst_vaapi_log (
|
|
#if VA_CHECK_VERSION (1,0,0)
|
|
void *data,
|
|
#endif
|
|
const char *message)
|
|
{
|
|
gchar *msg;
|
|
|
|
msg = strip_msg (message);
|
|
if (!msg)
|
|
return;
|
|
GST_INFO ("%s", msg);
|
|
g_free (msg);
|
|
}
|
|
#endif
|
|
|
|
gboolean
|
|
vaapi_initialize (VADisplay dpy)
|
|
{
|
|
gint major_version, minor_version;
|
|
VAStatus status;
|
|
|
|
#if VA_CHECK_VERSION (1,0,0)
|
|
vaSetErrorCallback (dpy, gst_vaapi_warning, NULL);
|
|
vaSetInfoCallback (dpy, gst_vaapi_log, NULL);
|
|
#elif VA_CHECK_VERSION (0,40,0)
|
|
vaSetInfoCallback (gst_vaapi_log);
|
|
#endif
|
|
|
|
status = vaInitialize (dpy, &major_version, &minor_version);
|
|
|
|
#if VA_CHECK_VERSION (1,0,0)
|
|
vaSetErrorCallback (dpy, gst_vaapi_err, NULL);
|
|
#endif
|
|
|
|
if (!vaapi_check_status (status, "vaInitialize()"))
|
|
return FALSE;
|
|
|
|
GST_INFO ("VA-API version %d.%d", major_version, minor_version);
|
|
return TRUE;
|
|
}
|
|
|
|
/* Check VA status for success or print out an error */
|
|
gboolean
|
|
vaapi_check_status (VAStatus status, const gchar * msg)
|
|
{
|
|
if (status != VA_STATUS_SUCCESS) {
|
|
GST_DEBUG ("%s: %s", msg, vaErrorStr (status));
|
|
return FALSE;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
/* Maps VA buffer */
|
|
gpointer
|
|
vaapi_map_buffer (VADisplay dpy, VABufferID buf_id)
|
|
{
|
|
VAStatus status;
|
|
gpointer data = NULL;
|
|
|
|
status = vaMapBuffer (dpy, buf_id, &data);
|
|
if (!vaapi_check_status (status, "vaMapBuffer()"))
|
|
return NULL;
|
|
return data;
|
|
}
|
|
|
|
/* Unmaps VA buffer */
|
|
void
|
|
vaapi_unmap_buffer (VADisplay dpy, VABufferID buf_id, gpointer * pbuf)
|
|
{
|
|
VAStatus status;
|
|
|
|
if (pbuf)
|
|
*pbuf = NULL;
|
|
|
|
status = vaUnmapBuffer (dpy, buf_id);
|
|
if (!vaapi_check_status (status, "vaUnmapBuffer()"))
|
|
return;
|
|
}
|
|
|
|
/* Creates and maps VA buffer */
|
|
gboolean
|
|
vaapi_create_buffer (VADisplay dpy, VAContextID ctx, int type, guint size,
|
|
gconstpointer buf, VABufferID * buf_id_ptr, gpointer * mapped_data)
|
|
{
|
|
return vaapi_create_n_elements_buffer (dpy, ctx, type, size, buf, buf_id_ptr,
|
|
mapped_data, 1);
|
|
}
|
|
|
|
gboolean
|
|
vaapi_create_n_elements_buffer (VADisplay dpy, VAContextID ctx, int type,
|
|
guint size, gconstpointer buf, VABufferID * buf_id_ptr,
|
|
gpointer * mapped_data, int num_elements)
|
|
{
|
|
VABufferID buf_id;
|
|
VAStatus status;
|
|
gpointer data = (gpointer) buf;
|
|
|
|
status = vaCreateBuffer (dpy, ctx, type, size, num_elements, data, &buf_id);
|
|
if (!vaapi_check_status (status, "vaCreateBuffer()"))
|
|
return FALSE;
|
|
|
|
if (mapped_data) {
|
|
data = vaapi_map_buffer (dpy, buf_id);
|
|
if (!data)
|
|
goto error;
|
|
*mapped_data = data;
|
|
}
|
|
|
|
*buf_id_ptr = buf_id;
|
|
return TRUE;
|
|
|
|
/* ERRORS */
|
|
error:
|
|
{
|
|
vaapi_destroy_buffer (dpy, &buf_id);
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
/* Destroy VA buffer */
|
|
void
|
|
vaapi_destroy_buffer (VADisplay dpy, VABufferID * buf_id_ptr)
|
|
{
|
|
if (!buf_id_ptr || *buf_id_ptr == VA_INVALID_ID)
|
|
return;
|
|
|
|
vaDestroyBuffer (dpy, *buf_id_ptr);
|
|
*buf_id_ptr = VA_INVALID_ID;
|
|
}
|
|
|
|
/* Return a string representation of a VAProfile */
|
|
const gchar *
|
|
string_of_VAProfile (VAProfile profile)
|
|
{
|
|
switch (profile) {
|
|
#define MAP(profile) \
|
|
STRCASEP(VAProfile, profile)
|
|
MAP (MPEG2Simple);
|
|
MAP (MPEG2Main);
|
|
MAP (MPEG4Simple);
|
|
MAP (MPEG4AdvancedSimple);
|
|
MAP (MPEG4Main);
|
|
MAP (JPEGBaseline);
|
|
MAP (H263Baseline);
|
|
MAP (H264ConstrainedBaseline);
|
|
#if !VA_CHECK_VERSION(1,0,0)
|
|
MAP (H264Baseline);
|
|
#endif
|
|
MAP (H264Main);
|
|
MAP (H264High);
|
|
MAP (H264MultiviewHigh);
|
|
MAP (H264StereoHigh);
|
|
#if VA_CHECK_VERSION(1,2,0)
|
|
MAP (HEVCMain422_10);
|
|
MAP (HEVCMain444);
|
|
#endif
|
|
MAP (HEVCMain);
|
|
MAP (HEVCMain10);
|
|
MAP (VC1Simple);
|
|
MAP (VC1Main);
|
|
MAP (VC1Advanced);
|
|
MAP (VP8Version0_3);
|
|
MAP (VP9Profile0);
|
|
MAP (VP9Profile1);
|
|
MAP (VP9Profile2);
|
|
MAP (VP9Profile3);
|
|
#undef MAP
|
|
default:
|
|
break;
|
|
}
|
|
return "<unknown>";
|
|
}
|
|
|
|
/* Return a string representation of a VAEntrypoint */
|
|
const gchar *
|
|
string_of_VAEntrypoint (VAEntrypoint entrypoint)
|
|
{
|
|
switch (entrypoint) {
|
|
#define MAP(entrypoint) \
|
|
STRCASEP(VAEntrypoint, entrypoint)
|
|
MAP (VLD);
|
|
MAP (IZZ);
|
|
MAP (IDCT);
|
|
MAP (MoComp);
|
|
MAP (Deblocking);
|
|
MAP (EncSlice);
|
|
MAP (EncPicture);
|
|
MAP (EncSliceLP);
|
|
MAP (VideoProc);
|
|
#if VA_CHECK_VERSION(1,0,0)
|
|
MAP (FEI);
|
|
#endif
|
|
#undef MAP
|
|
default:
|
|
break;
|
|
}
|
|
return "<unknown>";
|
|
}
|
|
|
|
/* Return a string representation of a VADisplayAttributeType */
|
|
const gchar *
|
|
string_of_VADisplayAttributeType (VADisplayAttribType attribute_type)
|
|
{
|
|
switch (attribute_type) {
|
|
#define MAP(attribute_type) \
|
|
STRCASEP(VADisplayAttrib, attribute_type)
|
|
MAP (Brightness);
|
|
MAP (Contrast);
|
|
MAP (Hue);
|
|
MAP (Saturation);
|
|
MAP (BackgroundColor);
|
|
MAP (Rotation);
|
|
MAP (OutofLoopDeblock);
|
|
MAP (CSCMatrix);
|
|
MAP (BlendColor);
|
|
MAP (OverlayAutoPaintColorKey);
|
|
MAP (OverlayColorKey);
|
|
MAP (RenderMode);
|
|
MAP (RenderDevice);
|
|
MAP (RenderRect);
|
|
#undef MAP
|
|
default:
|
|
break;
|
|
}
|
|
return "<unknown>";
|
|
}
|
|
|
|
/* Return a string representation of a VA chroma format */
|
|
const gchar *
|
|
string_of_va_chroma_format (guint chroma_format)
|
|
{
|
|
switch (chroma_format) {
|
|
#define MAP(value) \
|
|
STRCASEM(VA_RT_FORMAT_, value)
|
|
MAP (YUV420);
|
|
MAP (YUV422);
|
|
MAP (YUV444);
|
|
MAP (YUV400);
|
|
MAP (RGB16);
|
|
MAP (RGB32);
|
|
MAP (RGBP);
|
|
MAP (YUV420_10BPP);
|
|
#if VA_CHECK_VERSION(1,2,0)
|
|
MAP (YUV422_10);
|
|
MAP (YUV444_10);
|
|
MAP (YUV420_12);
|
|
MAP (YUV422_12);
|
|
MAP (YUV444_12);
|
|
MAP (RGB32_10);
|
|
#endif
|
|
#undef MAP
|
|
default:
|
|
break;
|
|
}
|
|
return "<unknown>";
|
|
}
|
|
|
|
const gchar *
|
|
string_of_VARateControl (guint rate_control)
|
|
{
|
|
switch (rate_control) {
|
|
case VA_RC_NONE:
|
|
return "None";
|
|
case VA_RC_CQP:
|
|
return "CQP";
|
|
case VA_RC_CBR:
|
|
return "CBR";
|
|
case VA_RC_VCM:
|
|
return "VCM";
|
|
case VA_RC_VBR:
|
|
return "VBR";
|
|
case VA_RC_VBR_CONSTRAINED:
|
|
return "VBR-Constrained";
|
|
#if VA_CHECK_VERSION(0,39,1)
|
|
case VA_RC_MB:
|
|
return "MB";
|
|
#endif
|
|
#if VA_CHECK_VERSION(1,1,0)
|
|
case VA_RC_ICQ:
|
|
return "VA_RC_ICQ";
|
|
#endif
|
|
#if VA_CHECK_VERSION(1,3,0)
|
|
case VA_RC_QVBR:
|
|
return "VA_RC_QVBR";
|
|
#endif
|
|
default:
|
|
break;
|
|
}
|
|
return "<unknown>";
|
|
}
|
|
|
|
/**
|
|
* to_GstVaapiChromaType:
|
|
* @va_rt_format: the value of VAConfigAttribRTFormat
|
|
*
|
|
* Converts the VA_RT_FORMAT_* to #GstVaapiChromaType
|
|
*
|
|
* Returns: the #GstVaapiChromaType associated to @va_rt_format or
|
|
* zero.
|
|
**/
|
|
guint
|
|
to_GstVaapiChromaType (guint va_rt_format)
|
|
{
|
|
if (va_rt_format & VA_RT_FORMAT_YUV420)
|
|
return GST_VAAPI_CHROMA_TYPE_YUV420;
|
|
if (va_rt_format & VA_RT_FORMAT_YUV422)
|
|
return GST_VAAPI_CHROMA_TYPE_YUV422;
|
|
if (va_rt_format & VA_RT_FORMAT_YUV444)
|
|
return GST_VAAPI_CHROMA_TYPE_YUV444;
|
|
if (va_rt_format & VA_RT_FORMAT_YUV411)
|
|
return GST_VAAPI_CHROMA_TYPE_YUV411;
|
|
if (va_rt_format & VA_RT_FORMAT_YUV400)
|
|
return GST_VAAPI_CHROMA_TYPE_YUV400;
|
|
if (va_rt_format & VA_RT_FORMAT_RGB32)
|
|
return GST_VAAPI_CHROMA_TYPE_RGB32;
|
|
if (va_rt_format & VA_RT_FORMAT_RGB16)
|
|
return GST_VAAPI_CHROMA_TYPE_RGB16;
|
|
if (va_rt_format & VA_RT_FORMAT_RGBP)
|
|
return GST_VAAPI_CHROMA_TYPE_RGBP;
|
|
if (va_rt_format & VA_RT_FORMAT_YUV420_10BPP)
|
|
return GST_VAAPI_CHROMA_TYPE_YUV420_10BPP;
|
|
#if VA_CHECK_VERSION(1,2,0)
|
|
if (va_rt_format & VA_RT_FORMAT_YUV422_10)
|
|
return GST_VAAPI_CHROMA_TYPE_YUV422_10BPP;
|
|
if (va_rt_format & VA_RT_FORMAT_YUV444_10)
|
|
return GST_VAAPI_CHROMA_TYPE_YUV444_10BPP;
|
|
if (va_rt_format & VA_RT_FORMAT_YUV420_12)
|
|
return GST_VAAPI_CHROMA_TYPE_YUV420_12BPP;
|
|
if (va_rt_format & VA_RT_FORMAT_YUV422_12)
|
|
return GST_VAAPI_CHROMA_TYPE_YUV422_12BPP;
|
|
if (va_rt_format & VA_RT_FORMAT_YUV444_12)
|
|
return GST_VAAPI_CHROMA_TYPE_YUV444_12BPP;
|
|
if (va_rt_format & VA_RT_FORMAT_RGB32_10)
|
|
return GST_VAAPI_CHROMA_TYPE_RGB32_10BPP;
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* from_GstVaapiChromaType:
|
|
* @chroma_type: the #GstVaapiChromaType
|
|
*
|
|
* Converts #GstVaapiChromaType to a chroma format suitable for
|
|
* vaCreateSurfaces().
|
|
*/
|
|
guint
|
|
from_GstVaapiChromaType (guint chroma_type)
|
|
{
|
|
guint format;
|
|
|
|
switch (chroma_type) {
|
|
case GST_VAAPI_CHROMA_TYPE_YUV420:
|
|
format = VA_RT_FORMAT_YUV420;
|
|
break;
|
|
case GST_VAAPI_CHROMA_TYPE_YUV422:
|
|
format = VA_RT_FORMAT_YUV422;
|
|
break;
|
|
case GST_VAAPI_CHROMA_TYPE_YUV444:
|
|
format = VA_RT_FORMAT_YUV444;
|
|
break;
|
|
case GST_VAAPI_CHROMA_TYPE_YUV411:
|
|
format = VA_RT_FORMAT_YUV411;
|
|
break;
|
|
case GST_VAAPI_CHROMA_TYPE_YUV400:
|
|
format = VA_RT_FORMAT_YUV400;
|
|
break;
|
|
case GST_VAAPI_CHROMA_TYPE_RGB32:
|
|
format = VA_RT_FORMAT_RGB32;
|
|
break;
|
|
case GST_VAAPI_CHROMA_TYPE_RGB16:
|
|
format = VA_RT_FORMAT_RGB16;
|
|
break;
|
|
case GST_VAAPI_CHROMA_TYPE_RGBP:
|
|
format = VA_RT_FORMAT_RGBP;
|
|
break;
|
|
case GST_VAAPI_CHROMA_TYPE_YUV420_10BPP:
|
|
format = VA_RT_FORMAT_YUV420_10BPP;
|
|
break;
|
|
#if VA_CHECK_VERSION(1,2,0)
|
|
case GST_VAAPI_CHROMA_TYPE_YUV422_10BPP:
|
|
format = VA_RT_FORMAT_YUV422_10;
|
|
break;
|
|
case GST_VAAPI_CHROMA_TYPE_YUV444_10BPP:
|
|
format = VA_RT_FORMAT_YUV444_10;
|
|
break;
|
|
case GST_VAAPI_CHROMA_TYPE_YUV420_12BPP:
|
|
format = VA_RT_FORMAT_YUV420_12;
|
|
break;
|
|
case GST_VAAPI_CHROMA_TYPE_YUV422_12BPP:
|
|
format = VA_RT_FORMAT_YUV422_12;
|
|
break;
|
|
case GST_VAAPI_CHROMA_TYPE_YUV444_12BPP:
|
|
format = VA_RT_FORMAT_YUV444_12;
|
|
break;
|
|
case GST_VAAPI_CHROMA_TYPE_RGB32_10BPP:
|
|
format = VA_RT_FORMAT_RGB32_10;
|
|
break;
|
|
#endif
|
|
default:
|
|
format = 0;
|
|
break;
|
|
}
|
|
return format;
|
|
}
|
|
|
|
/**
|
|
* from_GstVaapiSubpictureFlags:
|
|
* @flags: the #GstVaapiSubpictureFlags
|
|
*
|
|
* Converts #GstVaapiSubpictureFlags to flags suitable for
|
|
* vaAssociateSubpicture().
|
|
*/
|
|
guint
|
|
from_GstVaapiSubpictureFlags (guint flags)
|
|
{
|
|
guint va_flags = 0;
|
|
|
|
if (flags & GST_VAAPI_SUBPICTURE_FLAG_GLOBAL_ALPHA)
|
|
va_flags |= VA_SUBPICTURE_GLOBAL_ALPHA;
|
|
#ifdef VA_SUBPICTURE_PREMULTIPLIED_ALPHA
|
|
if (flags & GST_VAAPI_SUBPICTURE_FLAG_PREMULTIPLIED_ALPHA)
|
|
flags |= VA_SUBPICTURE_PREMULTIPLIED_ALPHA;
|
|
#endif
|
|
return va_flags;
|
|
}
|
|
|
|
/**
|
|
* to_GstVaapiSubpictureFlags:
|
|
* @flags: the #GstVaapiSubpictureFlags flags to translate
|
|
*
|
|
* Converts vaQuerySubpictureFormats() @flags to #GstVaapiSubpictureFlags
|
|
* flags.
|
|
*
|
|
* Return value: the #GstVaapiSubpictureFlags flags
|
|
*/
|
|
guint
|
|
to_GstVaapiSubpictureFlags (guint va_flags)
|
|
{
|
|
guint flags = 0;
|
|
|
|
if (va_flags & VA_SUBPICTURE_GLOBAL_ALPHA)
|
|
flags |= GST_VAAPI_SUBPICTURE_FLAG_GLOBAL_ALPHA;
|
|
#ifdef VA_SUBPICTURE_PREMULTIPLIED_ALPHA
|
|
if (va_flags & VA_SUBPICTURE_PREMULTIPLIED_ALPHA)
|
|
flags |= GST_VAAPI_SUBPICTURE_FLAG_PREMULTIPLIED_ALPHA;
|
|
#endif
|
|
return flags;
|
|
}
|
|
|
|
/**
|
|
* from_GstVideoOverlayFormatFlags:
|
|
* @flags: the #GstVideoOverlayFormatFlags flags to translate
|
|
*
|
|
* Converts #GstVaapiSubpictureFlags to #GstVaapiSubpictureFlags.
|
|
*
|
|
* Return value: the #GstVaapiSubpictureFlags flags
|
|
*/
|
|
guint
|
|
from_GstVideoOverlayFormatFlags (guint ovl_flags)
|
|
{
|
|
guint flags = 0;
|
|
|
|
if (ovl_flags & GST_VIDEO_OVERLAY_FORMAT_FLAG_PREMULTIPLIED_ALPHA)
|
|
flags |= GST_VAAPI_SUBPICTURE_FLAG_PREMULTIPLIED_ALPHA;
|
|
if (ovl_flags & GST_VIDEO_OVERLAY_FORMAT_FLAG_GLOBAL_ALPHA)
|
|
flags |= GST_VAAPI_SUBPICTURE_FLAG_GLOBAL_ALPHA;
|
|
return flags;
|
|
}
|
|
|
|
/**
|
|
* to_GstVideoOverlayFormatFlags:
|
|
* @flags: the #GstVaapiSubpictureFlags flags to translate
|
|
*
|
|
* Converts #GstVaapiSubpictureFlags to #GstVideoOverlayFormatFlags.
|
|
*
|
|
* Return value: the #GstVideoOverlayFormatFlags flags
|
|
*/
|
|
guint
|
|
to_GstVideoOverlayFormatFlags (guint flags)
|
|
{
|
|
guint ovl_flags = 0;
|
|
|
|
if (flags & GST_VAAPI_SUBPICTURE_FLAG_PREMULTIPLIED_ALPHA)
|
|
ovl_flags |= GST_VIDEO_OVERLAY_FORMAT_FLAG_PREMULTIPLIED_ALPHA;
|
|
if (flags & GST_VAAPI_SUBPICTURE_FLAG_GLOBAL_ALPHA)
|
|
ovl_flags |= GST_VIDEO_OVERLAY_FORMAT_FLAG_GLOBAL_ALPHA;
|
|
return ovl_flags;
|
|
}
|
|
|
|
/**
|
|
* from_GstVaapiSurfaceRenderFlags:
|
|
* @flags: the #GstVaapiSurfaceRenderFlags
|
|
*
|
|
* Converts #GstVaapiSurfaceRenderFlags to flags suitable for
|
|
* vaPutSurface().
|
|
*/
|
|
guint
|
|
from_GstVaapiSurfaceRenderFlags (guint flags)
|
|
{
|
|
guint va_fields, va_csc;
|
|
|
|
/* Picture structure */
|
|
switch (flags & GST_VAAPI_PICTURE_STRUCTURE_MASK) {
|
|
case GST_VAAPI_PICTURE_STRUCTURE_TOP_FIELD:
|
|
va_fields = VA_TOP_FIELD;
|
|
break;
|
|
case GST_VAAPI_PICTURE_STRUCTURE_BOTTOM_FIELD:
|
|
va_fields = VA_BOTTOM_FIELD;
|
|
break;
|
|
default:
|
|
va_fields = VA_FRAME_PICTURE;
|
|
break;
|
|
}
|
|
|
|
/* Color standard */
|
|
switch (flags & GST_VAAPI_COLOR_STANDARD_MASK) {
|
|
#ifdef VA_SRC_BT601
|
|
case GST_VAAPI_COLOR_STANDARD_ITUR_BT_601:
|
|
va_csc = VA_SRC_BT601;
|
|
break;
|
|
#endif
|
|
#ifdef VA_SRC_BT709
|
|
case GST_VAAPI_COLOR_STANDARD_ITUR_BT_709:
|
|
va_csc = VA_SRC_BT709;
|
|
break;
|
|
#endif
|
|
#ifdef VA_SRC_SMPTE_240
|
|
case GST_VAAPI_COLOR_STANDARD_SMPTE_240M:
|
|
va_csc = VA_SRC_SMPTE_240;
|
|
break;
|
|
#endif
|
|
default:
|
|
va_csc = 0;
|
|
break;
|
|
}
|
|
return va_fields | va_csc;
|
|
}
|
|
|
|
/**
|
|
* to_GstVaapiSurfaceStatus:
|
|
* @flags: the #GstVaapiSurfaceStatus flags to translate
|
|
*
|
|
* Converts vaQuerySurfaceStatus() @flags to #GstVaapiSurfaceStatus
|
|
* flags.
|
|
*
|
|
* Return value: the #GstVaapiSurfaceStatus flags
|
|
*/
|
|
guint
|
|
to_GstVaapiSurfaceStatus (guint va_flags)
|
|
{
|
|
guint flags;
|
|
const guint va_flags_mask = (VASurfaceReady |
|
|
VASurfaceRendering | VASurfaceDisplaying);
|
|
|
|
/* Check for core status */
|
|
switch (va_flags & va_flags_mask) {
|
|
case VASurfaceReady:
|
|
flags = GST_VAAPI_SURFACE_STATUS_IDLE;
|
|
break;
|
|
case VASurfaceRendering:
|
|
flags = GST_VAAPI_SURFACE_STATUS_RENDERING;
|
|
break;
|
|
case VASurfaceDisplaying:
|
|
flags = GST_VAAPI_SURFACE_STATUS_DISPLAYING;
|
|
break;
|
|
default:
|
|
flags = 0;
|
|
break;
|
|
}
|
|
|
|
/* Check for encoder status */
|
|
if (va_flags & VASurfaceSkipped)
|
|
flags |= GST_VAAPI_SURFACE_STATUS_SKIPPED;
|
|
return flags;
|
|
}
|
|
|
|
/* Translate GstVaapiRotation value to VA-API rotation value */
|
|
guint
|
|
from_GstVaapiRotation (guint value)
|
|
{
|
|
switch (value) {
|
|
case GST_VAAPI_ROTATION_0:
|
|
return VA_ROTATION_NONE;
|
|
case GST_VAAPI_ROTATION_90:
|
|
return VA_ROTATION_90;
|
|
case GST_VAAPI_ROTATION_180:
|
|
return VA_ROTATION_180;
|
|
case GST_VAAPI_ROTATION_270:
|
|
return VA_ROTATION_270;
|
|
}
|
|
GST_ERROR ("unsupported GstVaapiRotation value %d", value);
|
|
return VA_ROTATION_NONE;
|
|
}
|
|
|
|
/* Translate VA-API rotation value to GstVaapiRotation value */
|
|
guint
|
|
to_GstVaapiRotation (guint value)
|
|
{
|
|
switch (value) {
|
|
case VA_ROTATION_NONE:
|
|
return GST_VAAPI_ROTATION_0;
|
|
case VA_ROTATION_90:
|
|
return GST_VAAPI_ROTATION_90;
|
|
case VA_ROTATION_180:
|
|
return GST_VAAPI_ROTATION_180;
|
|
case VA_ROTATION_270:
|
|
return GST_VAAPI_ROTATION_270;
|
|
}
|
|
GST_ERROR ("unsupported VA-API rotation value %d", value);
|
|
return GST_VAAPI_ROTATION_0;
|
|
}
|
|
|
|
guint
|
|
from_GstVaapiRateControl (guint value)
|
|
{
|
|
switch (value) {
|
|
case GST_VAAPI_RATECONTROL_NONE:
|
|
return VA_RC_NONE;
|
|
case GST_VAAPI_RATECONTROL_CQP:
|
|
return VA_RC_CQP;
|
|
case GST_VAAPI_RATECONTROL_CBR:
|
|
return VA_RC_CBR;
|
|
case GST_VAAPI_RATECONTROL_VCM:
|
|
return VA_RC_VCM;
|
|
case GST_VAAPI_RATECONTROL_VBR:
|
|
return VA_RC_VBR;
|
|
case GST_VAAPI_RATECONTROL_VBR_CONSTRAINED:
|
|
return VA_RC_VBR_CONSTRAINED;
|
|
#if VA_CHECK_VERSION(0,39,1)
|
|
case GST_VAAPI_RATECONTROL_MB:
|
|
return VA_RC_MB;
|
|
#endif
|
|
#if VA_CHECK_VERSION(1,1,0)
|
|
case GST_VAAPI_RATECONTROL_ICQ:
|
|
return VA_RC_ICQ;
|
|
#endif
|
|
#if VA_CHECK_VERSION(1,3,0)
|
|
case GST_VAAPI_RATECONTROL_QVBR:
|
|
return VA_RC_QVBR;
|
|
#endif
|
|
}
|
|
GST_ERROR ("unsupported GstVaapiRateControl value %u", value);
|
|
return VA_RC_NONE;
|
|
}
|
|
|
|
guint
|
|
to_GstVaapiRateControl (guint value)
|
|
{
|
|
switch (value) {
|
|
case VA_RC_NONE:
|
|
return GST_VAAPI_RATECONTROL_NONE;
|
|
case VA_RC_CQP:
|
|
return GST_VAAPI_RATECONTROL_CQP;
|
|
case VA_RC_CBR:
|
|
return GST_VAAPI_RATECONTROL_CBR;
|
|
case VA_RC_VCM:
|
|
return GST_VAAPI_RATECONTROL_VCM;
|
|
case VA_RC_VBR:
|
|
return GST_VAAPI_RATECONTROL_VBR;
|
|
case VA_RC_VBR_CONSTRAINED:
|
|
return GST_VAAPI_RATECONTROL_VBR_CONSTRAINED;
|
|
#if VA_CHECK_VERSION(0,39,1)
|
|
case VA_RC_MB:
|
|
return GST_VAAPI_RATECONTROL_MB;
|
|
#endif
|
|
#if VA_CHECK_VERSION(1,1,0)
|
|
case VA_RC_ICQ:
|
|
return GST_VAAPI_RATECONTROL_ICQ;
|
|
#endif
|
|
#if VA_CHECK_VERSION(1,3,0)
|
|
case VA_RC_QVBR:
|
|
return GST_VAAPI_RATECONTROL_QVBR;
|
|
#endif
|
|
|
|
}
|
|
GST_ERROR ("unsupported VA-API Rate Control value %u", value);
|
|
return GST_VAAPI_RATECONTROL_NONE;
|
|
}
|
|
|
|
/* VPP: translate GstVaapiDeinterlaceMethod to VA deinterlacing algorithm */
|
|
guint
|
|
from_GstVaapiDeinterlaceMethod (guint value)
|
|
{
|
|
switch (value) {
|
|
case GST_VAAPI_DEINTERLACE_METHOD_NONE:
|
|
return 0;
|
|
case GST_VAAPI_DEINTERLACE_METHOD_BOB:
|
|
return VAProcDeinterlacingBob;
|
|
case GST_VAAPI_DEINTERLACE_METHOD_WEAVE:
|
|
return VAProcDeinterlacingWeave;
|
|
case GST_VAAPI_DEINTERLACE_METHOD_MOTION_ADAPTIVE:
|
|
return VAProcDeinterlacingMotionAdaptive;
|
|
case GST_VAAPI_DEINTERLACE_METHOD_MOTION_COMPENSATED:
|
|
return VAProcDeinterlacingMotionCompensated;
|
|
}
|
|
GST_ERROR ("unsupported GstVaapiDeinterlaceMethod value %d", value);
|
|
return 0;
|
|
}
|
|
|
|
/* VPP: translate GstVaapiDeinterlaceFlags into VA deinterlacing flags */
|
|
guint
|
|
from_GstVaapiDeinterlaceFlags (guint flags)
|
|
{
|
|
guint va_flags = 0;
|
|
|
|
if (!(flags & GST_VAAPI_DEINTERLACE_FLAG_TFF))
|
|
va_flags |= VA_DEINTERLACING_BOTTOM_FIELD_FIRST;
|
|
|
|
if (flags & GST_VAAPI_DEINTERLACE_FLAG_ONEFIELD)
|
|
va_flags |= VA_DEINTERLACING_ONE_FIELD;
|
|
|
|
if (!(flags & GST_VAAPI_DEINTERLACE_FLAG_TOPFIELD))
|
|
va_flags |= VA_DEINTERLACING_BOTTOM_FIELD;
|
|
return va_flags;
|
|
}
|
|
|
|
/* VPP: translate GstVaapiScaleMethod into VA scaling flags */
|
|
guint
|
|
from_GstVaapiScaleMethod (guint value)
|
|
{
|
|
guint va_flags;
|
|
|
|
switch (value) {
|
|
case GST_VAAPI_SCALE_METHOD_DEFAULT:
|
|
va_flags = VA_FILTER_SCALING_DEFAULT;
|
|
break;
|
|
case GST_VAAPI_SCALE_METHOD_FAST:
|
|
va_flags = VA_FILTER_SCALING_FAST;
|
|
break;
|
|
case GST_VAAPI_SCALE_METHOD_HQ:
|
|
va_flags = VA_FILTER_SCALING_HQ;
|
|
break;
|
|
default:
|
|
va_flags = 0;
|
|
break;
|
|
}
|
|
return va_flags;
|
|
}
|
|
|
|
/* VPP: translate VA scaling flags into GstVaapiScale Method */
|
|
guint
|
|
to_GstVaapiScaleMethod (guint flags)
|
|
{
|
|
GstVaapiScaleMethod method;
|
|
|
|
switch (flags) {
|
|
case VA_FILTER_SCALING_FAST:
|
|
method = GST_VAAPI_SCALE_METHOD_FAST;
|
|
break;
|
|
case VA_FILTER_SCALING_HQ:
|
|
method = GST_VAAPI_SCALE_METHOD_HQ;
|
|
break;
|
|
default:
|
|
method = GST_VAAPI_SCALE_METHOD_DEFAULT;
|
|
break;
|
|
}
|
|
return method;
|
|
}
|
|
|
|
/* VPP: translate GstVideoOrientationMethod into VA mirror/rotation flags */
|
|
void
|
|
from_GstVideoOrientationMethod (guint value, guint * va_mirror,
|
|
guint * va_rotation)
|
|
{
|
|
*va_mirror = 0;
|
|
*va_rotation = 0;
|
|
|
|
switch (value) {
|
|
#if VA_CHECK_VERSION(1,1,0)
|
|
case GST_VIDEO_ORIENTATION_IDENTITY:
|
|
*va_mirror = VA_MIRROR_NONE;
|
|
*va_rotation = VA_ROTATION_NONE;
|
|
break;
|
|
case GST_VIDEO_ORIENTATION_HORIZ:
|
|
*va_mirror = VA_MIRROR_HORIZONTAL;
|
|
*va_rotation = VA_ROTATION_NONE;
|
|
break;
|
|
case GST_VIDEO_ORIENTATION_VERT:
|
|
*va_mirror = VA_MIRROR_VERTICAL;
|
|
*va_rotation = VA_ROTATION_NONE;
|
|
break;
|
|
case GST_VIDEO_ORIENTATION_90R:
|
|
*va_mirror = VA_MIRROR_NONE;
|
|
*va_rotation = VA_ROTATION_90;
|
|
break;
|
|
case GST_VIDEO_ORIENTATION_180:
|
|
*va_mirror = VA_MIRROR_NONE;
|
|
*va_rotation = VA_ROTATION_180;
|
|
break;
|
|
case GST_VIDEO_ORIENTATION_90L:
|
|
*va_mirror = VA_MIRROR_NONE;
|
|
*va_rotation = VA_ROTATION_270;
|
|
break;
|
|
case GST_VIDEO_ORIENTATION_UL_LR:
|
|
*va_mirror = VA_MIRROR_HORIZONTAL;
|
|
*va_rotation = VA_ROTATION_90;
|
|
break;
|
|
case GST_VIDEO_ORIENTATION_UR_LL:
|
|
*va_mirror = VA_MIRROR_VERTICAL;
|
|
*va_rotation = VA_ROTATION_90;
|
|
break;
|
|
#endif
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* from_GstVaapiBufferMemoryType:
|
|
* @type: a #GstVaapiBufferMemoryType
|
|
*
|
|
* Returns: the VA's memory type symbol
|
|
**/
|
|
guint
|
|
from_GstVaapiBufferMemoryType (guint type)
|
|
{
|
|
guint va_type;
|
|
|
|
switch (type) {
|
|
#if VA_CHECK_VERSION(1,1,0)
|
|
case GST_VAAPI_BUFFER_MEMORY_TYPE_DMA_BUF2:
|
|
va_type = VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME_2;
|
|
break;
|
|
#endif
|
|
case GST_VAAPI_BUFFER_MEMORY_TYPE_DMA_BUF:
|
|
va_type = VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME;
|
|
break;
|
|
case GST_VAAPI_BUFFER_MEMORY_TYPE_GEM_BUF:
|
|
va_type = VA_SURFACE_ATTRIB_MEM_TYPE_KERNEL_DRM;
|
|
break;
|
|
case GST_VAAPI_BUFFER_MEMORY_TYPE_V4L2:
|
|
va_type = VA_SURFACE_ATTRIB_MEM_TYPE_V4L2;
|
|
break;
|
|
case GST_VAAPI_BUFFER_MEMORY_TYPE_USER_PTR:
|
|
va_type = VA_SURFACE_ATTRIB_MEM_TYPE_USER_PTR;
|
|
break;
|
|
default:
|
|
va_type = 0;
|
|
break;
|
|
}
|
|
return va_type;
|
|
}
|
|
|
|
/**
|
|
* to_GstVaapiBufferMemoryType:
|
|
* @va_type: a VA's memory type symbol
|
|
*
|
|
* It will return the first "supported" memory type from @va_type bit
|
|
* flag.
|
|
*
|
|
* Returns: a #GstVaapiBufferMemoryType or 0 if unknown.
|
|
**/
|
|
guint
|
|
to_GstVaapiBufferMemoryType (guint va_type)
|
|
{
|
|
#if VA_CHECK_VERSION(1,1,0)
|
|
if ((va_type & VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME_2))
|
|
return GST_VAAPI_BUFFER_MEMORY_TYPE_DMA_BUF2;
|
|
#endif
|
|
if ((va_type & VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME))
|
|
return GST_VAAPI_BUFFER_MEMORY_TYPE_DMA_BUF;
|
|
if ((va_type & VA_SURFACE_ATTRIB_MEM_TYPE_KERNEL_DRM))
|
|
return GST_VAAPI_BUFFER_MEMORY_TYPE_GEM_BUF;
|
|
if ((va_type & VA_SURFACE_ATTRIB_MEM_TYPE_V4L2))
|
|
return GST_VAAPI_BUFFER_MEMORY_TYPE_V4L2;
|
|
if ((va_type & VA_SURFACE_ATTRIB_MEM_TYPE_USER_PTR))
|
|
return GST_VAAPI_BUFFER_MEMORY_TYPE_USER_PTR;
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* from_GstVideoColorimetry:
|
|
* @colorimetry: a #GstVideoColorimetry type
|
|
*
|
|
* VPP: maps the #GstVideoColorimetry type to the VAProcColorStandardType. If
|
|
* @colorimetry is NULL or colorimetry->primaries are unknown, then returns
|
|
* VAProcColorStandardNone. If there is no 1:1 correlation, then returns
|
|
* VAProcColorStandardExplicit. Otherwise, the correlating
|
|
* VAProcColorStandardType is returned.
|
|
*
|
|
* Returns: a VAProcColorStandardType.
|
|
**/
|
|
guint
|
|
from_GstVideoColorimetry (const GstVideoColorimetry * const colorimetry)
|
|
{
|
|
if (!colorimetry
|
|
|| colorimetry->primaries == GST_VIDEO_COLOR_PRIMARIES_UNKNOWN)
|
|
return VAProcColorStandardNone;
|
|
if (gst_video_colorimetry_matches (colorimetry, GST_VIDEO_COLORIMETRY_BT709))
|
|
return VAProcColorStandardBT709;
|
|
/* NOTE: VAProcColorStandardBT2020 in VAAPI is the same as
|
|
* GST_VIDEO_COLORIMETRY_BT2020_10 in gstreamer. */
|
|
if (gst_video_colorimetry_matches (colorimetry,
|
|
GST_VIDEO_COLORIMETRY_BT2020_10))
|
|
return VAProcColorStandardBT2020;
|
|
if (gst_video_colorimetry_matches (colorimetry, GST_VIDEO_COLORIMETRY_BT601))
|
|
return VAProcColorStandardBT601;
|
|
if (gst_video_colorimetry_matches (colorimetry,
|
|
GST_VIDEO_COLORIMETRY_SMPTE240M))
|
|
return VAProcColorStandardSMPTE240M;
|
|
|
|
return VAProcColorStandardExplicit;
|
|
}
|
|
|
|
/**
|
|
* from_GstVideoColorRange:
|
|
* @value: a #GstVideoColorRange
|
|
*
|
|
* VPP: maps the #GstVideoColorRange to the VA value.
|
|
*
|
|
* Returns: the VA color range.
|
|
**/
|
|
guint
|
|
from_GstVideoColorRange (const GstVideoColorRange value)
|
|
{
|
|
switch (value) {
|
|
case GST_VIDEO_COLOR_RANGE_0_255:
|
|
return VA_SOURCE_RANGE_FULL;
|
|
case GST_VIDEO_COLOR_RANGE_16_235:
|
|
return VA_SOURCE_RANGE_REDUCED;
|
|
default:
|
|
return VA_SOURCE_RANGE_UNKNOWN;
|
|
}
|
|
}
|