mirror of
https://gitlab.freedesktop.org/gstreamer/gstreamer.git
synced 2024-11-18 07:47:17 +00:00
665 lines
18 KiB
C
665 lines
18 KiB
C
/* GStreamer Intel MSDK plugin
|
|
* Copyright (c) 2016, Oblong Industries, Inc.
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions are met:
|
|
*
|
|
* 1. Redistributions of source code must retain the above copyright notice,
|
|
* this list of conditions and the following disclaimer.
|
|
*
|
|
* 2. Redistributions in binary form must reproduce the above copyright notice,
|
|
* this list of conditions and the following disclaimer in the documentation
|
|
* and/or other materials provided with the distribution.
|
|
*
|
|
* 3. Neither the name of the copyright holder nor the names of its contributors
|
|
* may be used to endorse or promote products derived from this software
|
|
* without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
|
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
|
|
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
|
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
|
|
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
|
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
|
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
|
|
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
|
|
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
|
|
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
|
|
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
#include "msdk.h"
|
|
#include "gstmsdkvideomemory.h"
|
|
#include "gstmsdksystemmemory.h"
|
|
|
|
GST_DEBUG_CATEGORY_EXTERN (gst_msdk_debug);
|
|
#define GST_CAT_DEFAULT gst_msdk_debug
|
|
|
|
#define INVALID_INDEX ((guint) -1)
|
|
#define GST_MSDK_ALIGNMENT_PADDING(num,padding) ((padding) - ((num) & ((padding) - 1)))
|
|
|
|
struct map
|
|
{
|
|
GstVideoFormat format;
|
|
mfxU16 mfx_chroma_format;
|
|
mfxU32 mfx_fourcc;
|
|
};
|
|
|
|
#define GST_VIDEO_INFO_TO_MFX_MAP(FORMAT, CHROMA, FOURCC) \
|
|
{ GST_VIDEO_FORMAT_##FORMAT, MFX_CHROMAFORMAT_##CHROMA, MFX_FOURCC_##FOURCC }
|
|
|
|
static const struct map gst_msdk_video_format_to_mfx_map[] = {
|
|
GST_VIDEO_INFO_TO_MFX_MAP (NV12, YUV420, NV12),
|
|
GST_VIDEO_INFO_TO_MFX_MAP (YV12, YUV420, YV12),
|
|
GST_VIDEO_INFO_TO_MFX_MAP (I420, YUV420, YV12),
|
|
GST_VIDEO_INFO_TO_MFX_MAP (P010_10LE, YUV420, P010),
|
|
GST_VIDEO_INFO_TO_MFX_MAP (YUY2, YUV422, YUY2),
|
|
GST_VIDEO_INFO_TO_MFX_MAP (UYVY, YUV422, UYVY),
|
|
GST_VIDEO_INFO_TO_MFX_MAP (BGRA, YUV444, RGB4),
|
|
GST_VIDEO_INFO_TO_MFX_MAP (BGRx, YUV444, RGB4),
|
|
#if (MFX_VERSION >= 1028)
|
|
GST_VIDEO_INFO_TO_MFX_MAP (RGB16, YUV444, RGB565),
|
|
#endif
|
|
GST_VIDEO_INFO_TO_MFX_MAP (VUYA, YUV444, AYUV),
|
|
GST_VIDEO_INFO_TO_MFX_MAP (BGR10A2_LE, YUV444, A2RGB10),
|
|
#if (MFX_VERSION >= 1027)
|
|
GST_VIDEO_INFO_TO_MFX_MAP (Y210, YUV422, Y210),
|
|
GST_VIDEO_INFO_TO_MFX_MAP (Y410, YUV444, Y410),
|
|
#endif
|
|
#if (MFX_VERSION >= 1031)
|
|
/* P016 is used for semi-planar 12 bits format in MSDK */
|
|
GST_VIDEO_INFO_TO_MFX_MAP (P012_LE, YUV420, P016),
|
|
/* Y216 is used for 12bit 4:2:2 format in MSDK */
|
|
GST_VIDEO_INFO_TO_MFX_MAP (Y212_LE, YUV422, Y216),
|
|
/* Y416 is used for 12bit 4:4:4:4 format in MSDK */
|
|
GST_VIDEO_INFO_TO_MFX_MAP (Y412_LE, YUV444, Y416),
|
|
#endif
|
|
#if (MFX_VERSION >=2004)
|
|
GST_VIDEO_INFO_TO_MFX_MAP (RGBP, YUV444, RGBP),
|
|
GST_VIDEO_INFO_TO_MFX_MAP (BGRP, YUV444, BGRP),
|
|
#endif
|
|
{0, 0, 0}
|
|
};
|
|
|
|
const gchar *
|
|
msdk_status_to_string (mfxStatus status)
|
|
{
|
|
switch (status) {
|
|
/* no error */
|
|
case MFX_ERR_NONE:
|
|
return "no error";
|
|
/* reserved for unexpected errors */
|
|
case MFX_ERR_UNKNOWN:
|
|
return "unknown error";
|
|
/* error codes <0 */
|
|
case MFX_ERR_NULL_PTR:
|
|
return "null pointer";
|
|
case MFX_ERR_UNSUPPORTED:
|
|
return "undeveloped feature";
|
|
case MFX_ERR_MEMORY_ALLOC:
|
|
return "failed to allocate memory";
|
|
case MFX_ERR_NOT_ENOUGH_BUFFER:
|
|
return "insufficient buffer at input/output";
|
|
case MFX_ERR_INVALID_HANDLE:
|
|
return "invalid handle";
|
|
case MFX_ERR_LOCK_MEMORY:
|
|
return "failed to lock the memory block";
|
|
case MFX_ERR_NOT_INITIALIZED:
|
|
return "member function called before initialization";
|
|
case MFX_ERR_NOT_FOUND:
|
|
return "the specified object is not found";
|
|
case MFX_ERR_MORE_DATA:
|
|
return "expect more data at input";
|
|
case MFX_ERR_MORE_SURFACE:
|
|
return "expect more surface at output";
|
|
case MFX_ERR_ABORTED:
|
|
return "operation aborted";
|
|
case MFX_ERR_DEVICE_LOST:
|
|
return "lose the HW acceleration device";
|
|
case MFX_ERR_INCOMPATIBLE_VIDEO_PARAM:
|
|
return "incompatible video parameters";
|
|
case MFX_ERR_INVALID_VIDEO_PARAM:
|
|
return "invalid video parameters";
|
|
case MFX_ERR_UNDEFINED_BEHAVIOR:
|
|
return "undefined behavior";
|
|
case MFX_ERR_DEVICE_FAILED:
|
|
return "device operation failure";
|
|
case MFX_ERR_MORE_BITSTREAM:
|
|
return "expect more bitstream buffers at output";
|
|
#if (MFX_VERSION < 2000)
|
|
case MFX_ERR_INCOMPATIBLE_AUDIO_PARAM:
|
|
return "incompatible audio parameters";
|
|
case MFX_ERR_INVALID_AUDIO_PARAM:
|
|
return "invalid audio parameters";
|
|
#endif
|
|
/* warnings >0 */
|
|
case MFX_WRN_IN_EXECUTION:
|
|
return "the previous asynchronous operation is in execution";
|
|
case MFX_WRN_DEVICE_BUSY:
|
|
return "the HW acceleration device is busy";
|
|
case MFX_WRN_VIDEO_PARAM_CHANGED:
|
|
return "the video parameters are changed during decoding";
|
|
case MFX_WRN_PARTIAL_ACCELERATION:
|
|
return "SW is used";
|
|
case MFX_WRN_INCOMPATIBLE_VIDEO_PARAM:
|
|
return "incompatible video parameters";
|
|
case MFX_WRN_VALUE_NOT_CHANGED:
|
|
return "the value is saturated based on its valid range";
|
|
case MFX_WRN_OUT_OF_RANGE:
|
|
return "the value is out of valid range";
|
|
case MFX_WRN_FILTER_SKIPPED:
|
|
return "one of requested filters has been skipped";
|
|
#if (MFX_VERSION < 2000)
|
|
case MFX_WRN_INCOMPATIBLE_AUDIO_PARAM:
|
|
return "incompatible audio parameters";
|
|
#endif
|
|
default:
|
|
break;
|
|
}
|
|
return "undefined error";
|
|
}
|
|
|
|
mfxU16
|
|
msdk_get_platform_codename (mfxSession session)
|
|
{
|
|
mfxU16 codename = MFX_PLATFORM_UNKNOWN;
|
|
|
|
#if (MFX_VERSION >= 1019)
|
|
{
|
|
mfxStatus status;
|
|
mfxPlatform platform = { 0 };
|
|
status = MFXVideoCORE_QueryPlatform (session, &platform);
|
|
if (MFX_ERR_NONE == status)
|
|
codename = platform.CodeName;
|
|
}
|
|
#endif
|
|
|
|
return codename;
|
|
}
|
|
|
|
#if (MFX_VERSION >= 2000)
|
|
|
|
mfxStatus
|
|
msdk_init_msdk_session (mfxIMPL impl, mfxVersion * pver,
|
|
MsdkSession * msdk_session)
|
|
{
|
|
mfxStatus sts = MFX_ERR_NONE;
|
|
mfxLoader loader = NULL;
|
|
mfxSession session = NULL;
|
|
uint32_t impl_idx = 0;
|
|
mfxConfig cfg;
|
|
mfxVariant impl_value;
|
|
|
|
loader = msdk_session->loader;
|
|
|
|
if (!loader) {
|
|
loader = MFXLoad ();
|
|
|
|
GST_INFO ("Use the Intel oneVPL SDK to create MFX session");
|
|
|
|
if (!loader) {
|
|
GST_ERROR ("Failed to create a MFX loader");
|
|
return MFX_ERR_UNKNOWN;
|
|
}
|
|
|
|
/* Create configurations for implementation */
|
|
cfg = MFXCreateConfig (loader);
|
|
|
|
if (!cfg) {
|
|
GST_ERROR ("Failed to create a MFX configuration");
|
|
MFXUnload (loader);
|
|
return MFX_ERR_UNKNOWN;
|
|
}
|
|
|
|
impl_value.Type = MFX_VARIANT_TYPE_U32;
|
|
impl_value.Data.U32 =
|
|
(impl ==
|
|
MFX_IMPL_SOFTWARE) ? MFX_IMPL_TYPE_SOFTWARE : MFX_IMPL_TYPE_HARDWARE;
|
|
sts =
|
|
MFXSetConfigFilterProperty (cfg,
|
|
(const mfxU8 *) "mfxImplDescription.Impl", impl_value);
|
|
|
|
if (sts != MFX_ERR_NONE) {
|
|
GST_ERROR ("Failed to add an additional MFX configuration (%s)",
|
|
msdk_status_to_string (sts));
|
|
MFXUnload (loader);
|
|
return sts;
|
|
}
|
|
|
|
impl_value.Type = MFX_VARIANT_TYPE_U32;
|
|
impl_value.Data.U32 = pver->Version;
|
|
sts =
|
|
MFXSetConfigFilterProperty (cfg,
|
|
(const mfxU8 *) "mfxImplDescription.ApiVersion.Version", impl_value);
|
|
|
|
if (sts != MFX_ERR_NONE) {
|
|
GST_ERROR ("Failed to add an additional MFX configuration (%s)",
|
|
msdk_status_to_string (sts));
|
|
MFXUnload (loader);
|
|
return sts;
|
|
}
|
|
}
|
|
|
|
while (1) {
|
|
/* Enumerate all implementations */
|
|
mfxImplDescription *impl_desc;
|
|
|
|
sts = MFXEnumImplementations (loader, impl_idx,
|
|
MFX_IMPLCAPS_IMPLDESCSTRUCTURE, (mfxHDL *) & impl_desc);
|
|
|
|
/* Failed to find an available implementation */
|
|
if (sts == MFX_ERR_NOT_FOUND)
|
|
break;
|
|
else if (sts != MFX_ERR_NONE) {
|
|
impl_idx++;
|
|
continue;
|
|
}
|
|
|
|
sts = MFXCreateSession (loader, impl_idx, &session);
|
|
MFXDispReleaseImplDescription (loader, impl_desc);
|
|
|
|
if (sts == MFX_ERR_NONE)
|
|
break;
|
|
|
|
impl_idx++;
|
|
}
|
|
|
|
if (sts != MFX_ERR_NONE) {
|
|
GST_ERROR ("Failed to create a MFX session (%s)",
|
|
msdk_status_to_string (sts));
|
|
|
|
if (!msdk_session->loader)
|
|
MFXUnload (loader);
|
|
|
|
return sts;
|
|
}
|
|
|
|
msdk_session->session = session;
|
|
msdk_session->loader = loader;
|
|
|
|
return MFX_ERR_NONE;
|
|
}
|
|
|
|
#else
|
|
|
|
mfxStatus
|
|
msdk_init_msdk_session (mfxIMPL impl, mfxVersion * pver,
|
|
MsdkSession * msdk_session)
|
|
{
|
|
mfxStatus status;
|
|
mfxSession session = NULL;
|
|
mfxInitParam init_par = { impl, *pver };
|
|
|
|
GST_INFO ("Use the " MFX_API_SDK " to create MFX session");
|
|
|
|
#if (MFX_VERSION >= 1025)
|
|
init_par.GPUCopy = 1;
|
|
#endif
|
|
|
|
status = MFXInitEx (init_par, &session);
|
|
|
|
if (status != MFX_ERR_NONE) {
|
|
GST_ERROR ("Failed to initialize a MFX session (%s)",
|
|
msdk_status_to_string (status));
|
|
return status;
|
|
}
|
|
|
|
msdk_session->session = session;
|
|
msdk_session->loader = NULL;
|
|
|
|
return MFX_ERR_NONE;
|
|
}
|
|
|
|
void
|
|
MFXUnload (mfxLoader loader)
|
|
{
|
|
g_assert (loader == NULL);
|
|
}
|
|
|
|
#endif
|
|
|
|
void
|
|
msdk_close_mfx_session (mfxSession session)
|
|
{
|
|
mfxStatus status;
|
|
|
|
if (!session)
|
|
return;
|
|
|
|
status = MFXClose (session);
|
|
if (status != MFX_ERR_NONE)
|
|
GST_ERROR ("Close failed (%s)", msdk_status_to_string (status));
|
|
}
|
|
|
|
void
|
|
msdk_close_session (MsdkSession * msdk_session)
|
|
{
|
|
msdk_close_mfx_session (msdk_session->session);
|
|
MFXUnload (msdk_session->loader);
|
|
}
|
|
|
|
MsdkSession
|
|
msdk_open_session (mfxIMPL impl)
|
|
{
|
|
mfxSession session = NULL;
|
|
mfxVersion version = { {1, 1}
|
|
};
|
|
mfxIMPL implementation;
|
|
mfxStatus status;
|
|
MsdkSession msdk_session;
|
|
|
|
static const gchar *implementation_names[] = {
|
|
"AUTO", "SOFTWARE", "HARDWARE", "AUTO_ANY", "HARDWARE_ANY", "HARDWARE2",
|
|
"HARDWARE3", "HARDWARE4", "RUNTIME"
|
|
};
|
|
|
|
msdk_session.session = NULL;
|
|
msdk_session.loader = NULL;
|
|
status = msdk_init_msdk_session (impl, &version, &msdk_session);
|
|
|
|
if (status != MFX_ERR_NONE)
|
|
return msdk_session;
|
|
else
|
|
session = msdk_session.session;
|
|
|
|
status = MFXQueryIMPL (session, &implementation);
|
|
if (status != MFX_ERR_NONE) {
|
|
GST_ERROR ("Query implementation failed (%s)",
|
|
msdk_status_to_string (status));
|
|
goto failed;
|
|
}
|
|
|
|
status = MFXQueryVersion (session, &version);
|
|
if (status != MFX_ERR_NONE) {
|
|
GST_ERROR ("Query version failed (%s)", msdk_status_to_string (status));
|
|
goto failed;
|
|
}
|
|
|
|
GST_INFO ("MFX implementation: 0x%04x (%s)", implementation,
|
|
implementation_names[MFX_IMPL_BASETYPE (implementation)]);
|
|
GST_INFO ("MFX version: %d.%d", version.Major, version.Minor);
|
|
|
|
return msdk_session;
|
|
|
|
failed:
|
|
msdk_close_session (&msdk_session);
|
|
msdk_session.session = NULL;
|
|
msdk_session.loader = NULL;
|
|
return msdk_session;
|
|
}
|
|
|
|
gboolean
|
|
msdk_is_available (void)
|
|
{
|
|
/* Make sure we can create GstMsdkContext instance (the job type is not used actually) */
|
|
GstMsdkContext *msdk_context = gst_msdk_context_new (1, GST_MSDK_JOB_DECODER);
|
|
|
|
if (!msdk_context) {
|
|
return FALSE;
|
|
}
|
|
|
|
gst_object_unref (msdk_context);
|
|
return TRUE;
|
|
}
|
|
|
|
void
|
|
gst_msdk_set_video_alignment (GstVideoInfo * info, guint alloc_w, guint alloc_h,
|
|
GstVideoAlignment * alignment)
|
|
{
|
|
guint i, width, height;
|
|
guint stride_align = 127; /* 128-byte alignment */
|
|
|
|
width = GST_VIDEO_INFO_WIDTH (info);
|
|
height = GST_VIDEO_INFO_HEIGHT (info);
|
|
|
|
g_assert (alloc_w == 0 || alloc_w >= width);
|
|
g_assert (alloc_h == 0 || alloc_h >= height);
|
|
|
|
if (alloc_w == 0)
|
|
alloc_w = width;
|
|
|
|
if (alloc_h == 0)
|
|
alloc_h = height;
|
|
|
|
/* PitchAlignment is set to 64 bytes in the media driver for the following formats */
|
|
if (GST_VIDEO_INFO_FORMAT (info) == GST_VIDEO_FORMAT_BGRA ||
|
|
GST_VIDEO_INFO_FORMAT (info) == GST_VIDEO_FORMAT_BGRx ||
|
|
GST_VIDEO_INFO_FORMAT (info) == GST_VIDEO_FORMAT_BGR10A2_LE ||
|
|
GST_VIDEO_INFO_FORMAT (info) == GST_VIDEO_FORMAT_RGB16)
|
|
stride_align = 63; /* 64-byte alignment */
|
|
|
|
gst_video_alignment_reset (alignment);
|
|
for (i = 0; i < GST_VIDEO_INFO_N_PLANES (info); i++)
|
|
alignment->stride_align[i] = stride_align;
|
|
|
|
alignment->padding_right = GST_ROUND_UP_16 (alloc_w) - width;
|
|
alignment->padding_bottom = GST_ROUND_UP_32 (alloc_h) - height;
|
|
}
|
|
|
|
static const struct map *
|
|
_map_lookup_format (GstVideoFormat format)
|
|
{
|
|
const struct map *m = gst_msdk_video_format_to_mfx_map;
|
|
|
|
for (; m->format != 0; m++) {
|
|
if (m->format == format)
|
|
return m;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
gint
|
|
gst_msdk_get_mfx_chroma_from_format (GstVideoFormat format)
|
|
{
|
|
const struct map *const m = _map_lookup_format (format);
|
|
|
|
return m ? m->mfx_chroma_format : -1;
|
|
}
|
|
|
|
gint
|
|
gst_msdk_get_mfx_fourcc_from_format (GstVideoFormat format)
|
|
{
|
|
const struct map *const m = _map_lookup_format (format);
|
|
|
|
return m ? m->mfx_fourcc : -1;
|
|
}
|
|
|
|
void
|
|
gst_msdk_set_mfx_frame_info_from_video_info (mfxFrameInfo * mfx_info,
|
|
GstVideoInfo * info)
|
|
{
|
|
g_return_if_fail (info && mfx_info);
|
|
|
|
/* Use the first component in info to calculate mfx width / height */
|
|
mfx_info->Width =
|
|
GST_ROUND_UP_16 (GST_VIDEO_INFO_COMP_STRIDE (info,
|
|
0) / GST_VIDEO_INFO_COMP_PSTRIDE (info, 0));
|
|
|
|
if (GST_VIDEO_INFO_N_PLANES (info) > 1)
|
|
mfx_info->Height =
|
|
GST_ROUND_UP_32 (GST_VIDEO_INFO_COMP_OFFSET (info,
|
|
1) / GST_VIDEO_INFO_COMP_STRIDE (info, 0));
|
|
else
|
|
mfx_info->Height =
|
|
GST_ROUND_UP_32 (GST_VIDEO_INFO_SIZE (info) /
|
|
GST_VIDEO_INFO_COMP_STRIDE (info, 0));
|
|
|
|
mfx_info->CropW = GST_VIDEO_INFO_WIDTH (info);
|
|
mfx_info->CropH = GST_VIDEO_INFO_HEIGHT (info);
|
|
mfx_info->FrameRateExtN = GST_VIDEO_INFO_FPS_N (info);
|
|
mfx_info->FrameRateExtD = GST_VIDEO_INFO_FPS_D (info);
|
|
mfx_info->AspectRatioW = GST_VIDEO_INFO_PAR_N (info);
|
|
mfx_info->AspectRatioH = GST_VIDEO_INFO_PAR_D (info);
|
|
mfx_info->PicStruct =
|
|
!GST_VIDEO_INFO_IS_INTERLACED (info) ? MFX_PICSTRUCT_PROGRESSIVE :
|
|
MFX_PICSTRUCT_UNKNOWN;
|
|
mfx_info->FourCC =
|
|
gst_msdk_get_mfx_fourcc_from_format (GST_VIDEO_INFO_FORMAT (info));
|
|
mfx_info->ChromaFormat =
|
|
gst_msdk_get_mfx_chroma_from_format (GST_VIDEO_INFO_FORMAT (info));
|
|
|
|
switch (mfx_info->FourCC) {
|
|
case MFX_FOURCC_P010:
|
|
#if (MFX_VERSION >= 1027)
|
|
case MFX_FOURCC_Y210:
|
|
#endif
|
|
mfx_info->BitDepthLuma = 10;
|
|
mfx_info->BitDepthChroma = 10;
|
|
mfx_info->Shift = 1;
|
|
|
|
break;
|
|
|
|
#if (MFX_VERSION >= 1027)
|
|
case MFX_FOURCC_Y410:
|
|
mfx_info->BitDepthLuma = 10;
|
|
mfx_info->BitDepthChroma = 10;
|
|
mfx_info->Shift = 0;
|
|
|
|
break;
|
|
#endif
|
|
|
|
#if (MFX_VERSION >= 1031)
|
|
case MFX_FOURCC_P016:
|
|
case MFX_FOURCC_Y216:
|
|
case MFX_FOURCC_Y416:
|
|
mfx_info->BitDepthLuma = 12;
|
|
mfx_info->BitDepthChroma = 12;
|
|
mfx_info->Shift = 1;
|
|
|
|
break;
|
|
#endif
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
gboolean
|
|
gst_msdk_is_msdk_buffer (GstBuffer * buf)
|
|
{
|
|
GstAllocator *allocator;
|
|
GstMemory *mem = gst_buffer_peek_memory (buf, 0);
|
|
|
|
allocator = GST_MEMORY_CAST (mem)->allocator;
|
|
|
|
if (allocator && (GST_IS_MSDK_VIDEO_ALLOCATOR (allocator) ||
|
|
GST_IS_MSDK_SYSTEM_ALLOCATOR (allocator) ||
|
|
GST_IS_MSDK_DMABUF_ALLOCATOR (allocator)))
|
|
return TRUE;
|
|
else
|
|
return FALSE;
|
|
}
|
|
|
|
mfxFrameSurface1 *
|
|
gst_msdk_get_surface_from_buffer (GstBuffer * buf)
|
|
{
|
|
GstAllocator *allocator;
|
|
GstMemory *mem = gst_buffer_peek_memory (buf, 0);
|
|
|
|
allocator = GST_MEMORY_CAST (mem)->allocator;
|
|
|
|
if (GST_IS_MSDK_VIDEO_ALLOCATOR (allocator))
|
|
return GST_MSDK_VIDEO_MEMORY_CAST (mem)->surface;
|
|
else if (GST_IS_MSDK_SYSTEM_ALLOCATOR (allocator))
|
|
return GST_MSDK_SYSTEM_MEMORY_CAST (mem)->surface;
|
|
else if (GST_IS_MSDK_DMABUF_ALLOCATOR (allocator)) {
|
|
return gst_mini_object_get_qdata (GST_MINI_OBJECT (mem),
|
|
g_quark_from_static_string ("GstMsdkBufferSurface"));
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
GstVideoFormat
|
|
gst_msdk_get_video_format_from_mfx_fourcc (mfxU32 fourcc)
|
|
{
|
|
const struct map *m = gst_msdk_video_format_to_mfx_map;
|
|
|
|
for (; m->mfx_fourcc != 0; m++) {
|
|
if (m->mfx_fourcc == fourcc)
|
|
return m->format;
|
|
}
|
|
|
|
return GST_VIDEO_FORMAT_UNKNOWN;
|
|
}
|
|
|
|
void
|
|
gst_msdk_update_mfx_frame_info_from_mfx_video_param (mfxFrameInfo * mfx_info,
|
|
mfxVideoParam * param)
|
|
{
|
|
mfx_info->BitDepthLuma = param->mfx.FrameInfo.BitDepthLuma;
|
|
mfx_info->BitDepthChroma = param->mfx.FrameInfo.BitDepthChroma;
|
|
mfx_info->Shift = param->mfx.FrameInfo.Shift;
|
|
}
|
|
|
|
void
|
|
gst_msdk_get_mfx_video_orientation_from_video_direction (guint value,
|
|
guint * mfx_mirror, guint * mfx_rotation)
|
|
{
|
|
*mfx_mirror = MFX_MIRRORING_DISABLED;
|
|
*mfx_rotation = MFX_ANGLE_0;
|
|
|
|
switch (value) {
|
|
case GST_VIDEO_ORIENTATION_IDENTITY:
|
|
*mfx_mirror = MFX_MIRRORING_DISABLED;
|
|
*mfx_rotation = MFX_ANGLE_0;
|
|
break;
|
|
case GST_VIDEO_ORIENTATION_HORIZ:
|
|
*mfx_mirror = MFX_MIRRORING_HORIZONTAL;
|
|
*mfx_rotation = MFX_ANGLE_0;
|
|
break;
|
|
case GST_VIDEO_ORIENTATION_VERT:
|
|
*mfx_mirror = MFX_MIRRORING_VERTICAL;
|
|
*mfx_rotation = MFX_ANGLE_0;
|
|
break;
|
|
case GST_VIDEO_ORIENTATION_90R:
|
|
*mfx_mirror = MFX_MIRRORING_DISABLED;
|
|
*mfx_rotation = MFX_ANGLE_90;
|
|
break;
|
|
case GST_VIDEO_ORIENTATION_180:
|
|
*mfx_mirror = MFX_MIRRORING_DISABLED;
|
|
*mfx_rotation = MFX_ANGLE_180;
|
|
break;
|
|
case GST_VIDEO_ORIENTATION_90L:
|
|
*mfx_mirror = MFX_MIRRORING_DISABLED;
|
|
*mfx_rotation = MFX_ANGLE_270;
|
|
break;
|
|
case GST_VIDEO_ORIENTATION_UL_LR:
|
|
*mfx_mirror = MFX_MIRRORING_HORIZONTAL;
|
|
*mfx_rotation = MFX_ANGLE_90;
|
|
break;
|
|
case GST_VIDEO_ORIENTATION_UR_LL:
|
|
*mfx_mirror = MFX_MIRRORING_VERTICAL;
|
|
*mfx_rotation = MFX_ANGLE_90;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
gboolean
|
|
gst_msdk_load_plugin (mfxSession session, const mfxPluginUID * uid,
|
|
mfxU32 version, const gchar * plugin)
|
|
{
|
|
#if (MFX_VERSION < 2000)
|
|
mfxStatus status;
|
|
|
|
status = MFXVideoUSER_Load (session, uid, version);
|
|
|
|
if (status == MFX_ERR_UNDEFINED_BEHAVIOR) {
|
|
GST_WARNING ("Media SDK Plugin for %s has been loaded", plugin);
|
|
} else if (status < MFX_ERR_NONE) {
|
|
GST_ERROR ("Media SDK Plugin for %s load failed (%s)", plugin,
|
|
msdk_status_to_string (status));
|
|
return FALSE;
|
|
} else if (status > MFX_ERR_NONE) {
|
|
GST_WARNING ("Media SDK Plugin for %s load warning: %s", plugin,
|
|
msdk_status_to_string (status));
|
|
}
|
|
#endif
|
|
|
|
return TRUE;
|
|
}
|