mirror of
https://github.com/opencv/opencv.git
synced 2025-06-12 20:42:53 +08:00
4c74e6d89d
Minor refactoring Partially address review comments Move DX-related stuff from the sample to a default source Simplify the default OneVPL config Address minor review comments Add class for the default VPL source WIP: Add initial stub for tests with description Removing default vpl source and minor refactoring Refactor default files Fix build and application crash Address review comments Add test on VPL + OCL interaction compared to CPU behavior Fix test
434 lines
19 KiB
C++
434 lines
19 KiB
C++
// This file is part of OpenCV project.
|
|
// It is subject to the license terms in the LICENSE file found in the top-level directory
|
|
// of this distribution and at http://opencv.org/license.html.
|
|
//
|
|
// Copyright (C) 2021 Intel Corporation
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <algorithm>
|
|
#include <sstream>
|
|
|
|
#ifdef HAVE_ONEVPL
|
|
|
|
#include "streaming/onevpl/utils.hpp"
|
|
#include "logger.hpp"
|
|
|
|
#define ONEVPL_STRINGIFY_CASE(value) \
|
|
case value: return #value;
|
|
|
|
#define ONEVPL_STRINGIFY_IF(value) \
|
|
if (!strcmp(cstr, #value)) { \
|
|
return value; \
|
|
}
|
|
|
|
#define APPEND_STRINGIFY_MASK_N_ERASE(value, pref, mask) \
|
|
if (value & mask) { ss << pref << #mask; value ^= mask; }
|
|
|
|
#define DUMP_MEMBER(stream, object, member) \
|
|
stream << #member << ": " << object.member << "\n";
|
|
|
|
namespace cv {
|
|
namespace gapi {
|
|
namespace wip {
|
|
namespace onevpl {
|
|
|
|
const char* mfx_impl_to_cstr(const mfxIMPL impl) {
|
|
switch (impl) {
|
|
ONEVPL_STRINGIFY_CASE(MFX_IMPL_TYPE_SOFTWARE);
|
|
ONEVPL_STRINGIFY_CASE(MFX_IMPL_TYPE_HARDWARE);
|
|
default: return "unknown mfxIMPL";
|
|
}
|
|
}
|
|
|
|
mfxIMPL cstr_to_mfx_impl(const char* cstr) {
|
|
ONEVPL_STRINGIFY_IF(MFX_IMPL_TYPE_SOFTWARE)
|
|
ONEVPL_STRINGIFY_IF(MFX_IMPL_TYPE_HARDWARE)
|
|
throw std::logic_error(std::string("Invalid \"") + CfgParam::implementation_name() +
|
|
"\":" + cstr);
|
|
}
|
|
|
|
const char* mfx_accel_mode_to_cstr (const mfxAccelerationMode mode) {
|
|
switch (mode) {
|
|
ONEVPL_STRINGIFY_CASE(MFX_ACCEL_MODE_NA)
|
|
ONEVPL_STRINGIFY_CASE(MFX_ACCEL_MODE_VIA_D3D9)
|
|
ONEVPL_STRINGIFY_CASE(MFX_ACCEL_MODE_VIA_D3D11)
|
|
ONEVPL_STRINGIFY_CASE(MFX_ACCEL_MODE_VIA_VAAPI)
|
|
ONEVPL_STRINGIFY_CASE(MFX_ACCEL_MODE_VIA_VAAPI_DRM_MODESET)
|
|
ONEVPL_STRINGIFY_CASE(MFX_ACCEL_MODE_VIA_VAAPI_GLX)
|
|
ONEVPL_STRINGIFY_CASE(MFX_ACCEL_MODE_VIA_VAAPI_X11)
|
|
ONEVPL_STRINGIFY_CASE(MFX_ACCEL_MODE_VIA_VAAPI_WAYLAND)
|
|
ONEVPL_STRINGIFY_CASE(MFX_ACCEL_MODE_VIA_HDDLUNITE)
|
|
default: return "unknown mfxAccelerationMode";
|
|
}
|
|
}
|
|
|
|
mfxAccelerationMode cstr_to_mfx_accel_mode(const char* cstr) {
|
|
ONEVPL_STRINGIFY_IF(MFX_ACCEL_MODE_NA)
|
|
ONEVPL_STRINGIFY_IF(MFX_ACCEL_MODE_VIA_D3D9)
|
|
ONEVPL_STRINGIFY_IF(MFX_ACCEL_MODE_VIA_D3D11)
|
|
ONEVPL_STRINGIFY_IF(MFX_ACCEL_MODE_VIA_VAAPI)
|
|
ONEVPL_STRINGIFY_IF(MFX_ACCEL_MODE_VIA_VAAPI_DRM_MODESET)
|
|
ONEVPL_STRINGIFY_IF(MFX_ACCEL_MODE_VIA_VAAPI_GLX)
|
|
ONEVPL_STRINGIFY_IF(MFX_ACCEL_MODE_VIA_VAAPI_X11)
|
|
ONEVPL_STRINGIFY_IF(MFX_ACCEL_MODE_VIA_VAAPI_WAYLAND)
|
|
ONEVPL_STRINGIFY_IF(MFX_ACCEL_MODE_VIA_HDDLUNITE)
|
|
throw std::logic_error(std::string("Invalid \"") +
|
|
CfgParam::acceleration_mode_name() +
|
|
"\":" + cstr);
|
|
}
|
|
|
|
const char* mfx_resource_type_to_cstr (const mfxResourceType type) {
|
|
switch (type) {
|
|
ONEVPL_STRINGIFY_CASE(MFX_RESOURCE_SYSTEM_SURFACE)
|
|
ONEVPL_STRINGIFY_CASE(MFX_RESOURCE_VA_SURFACE)
|
|
ONEVPL_STRINGIFY_CASE(MFX_RESOURCE_VA_BUFFER)
|
|
ONEVPL_STRINGIFY_CASE(MFX_RESOURCE_DX9_SURFACE)
|
|
ONEVPL_STRINGIFY_CASE(MFX_RESOURCE_DX11_TEXTURE)
|
|
ONEVPL_STRINGIFY_CASE(MFX_RESOURCE_DX12_RESOURCE)
|
|
ONEVPL_STRINGIFY_CASE(MFX_RESOURCE_DMA_RESOURCE)
|
|
ONEVPL_STRINGIFY_CASE(MFX_RESOURCE_HDDLUNITE_REMOTE_MEMORY)
|
|
default: return "unknown mfxResourceType";
|
|
}
|
|
}
|
|
|
|
mfxResourceType cstr_to_mfx_resource_type(const char* cstr) {
|
|
ONEVPL_STRINGIFY_IF(MFX_RESOURCE_SYSTEM_SURFACE)
|
|
ONEVPL_STRINGIFY_IF(MFX_RESOURCE_VA_SURFACE)
|
|
ONEVPL_STRINGIFY_IF(MFX_RESOURCE_VA_BUFFER)
|
|
ONEVPL_STRINGIFY_IF(MFX_RESOURCE_DX9_SURFACE)
|
|
ONEVPL_STRINGIFY_IF(MFX_RESOURCE_DX11_TEXTURE)
|
|
ONEVPL_STRINGIFY_IF(MFX_RESOURCE_DX12_RESOURCE)
|
|
ONEVPL_STRINGIFY_IF(MFX_RESOURCE_DMA_RESOURCE)
|
|
ONEVPL_STRINGIFY_IF(MFX_RESOURCE_HDDLUNITE_REMOTE_MEMORY)
|
|
throw std::logic_error(std::string("Invalid \"decoder.Profiles.MemDesc.MemHandleType\":") + cstr);
|
|
}
|
|
|
|
mfxU32 cstr_to_mfx_codec_id(const char* cstr) {
|
|
ONEVPL_STRINGIFY_IF(MFX_CODEC_AVC)
|
|
ONEVPL_STRINGIFY_IF(MFX_CODEC_HEVC)
|
|
ONEVPL_STRINGIFY_IF(MFX_CODEC_MPEG2)
|
|
ONEVPL_STRINGIFY_IF(MFX_CODEC_VC1)
|
|
ONEVPL_STRINGIFY_IF(MFX_CODEC_CAPTURE)
|
|
ONEVPL_STRINGIFY_IF(MFX_CODEC_VP9)
|
|
ONEVPL_STRINGIFY_IF(MFX_CODEC_AV1)
|
|
throw std::logic_error(std::string("Cannot parse \"") + CfgParam::decoder_id_name() +
|
|
"\" value: " + cstr);
|
|
}
|
|
|
|
const char* mfx_codec_id_to_cstr(mfxU32 mfx_id) {
|
|
switch(mfx_id) {
|
|
ONEVPL_STRINGIFY_CASE(MFX_CODEC_AVC)
|
|
ONEVPL_STRINGIFY_CASE(MFX_CODEC_HEVC)
|
|
ONEVPL_STRINGIFY_CASE(MFX_CODEC_MPEG2)
|
|
ONEVPL_STRINGIFY_CASE(MFX_CODEC_VC1)
|
|
ONEVPL_STRINGIFY_CASE(MFX_CODEC_VP9)
|
|
ONEVPL_STRINGIFY_CASE(MFX_CODEC_AV1)
|
|
ONEVPL_STRINGIFY_CASE(MFX_CODEC_JPEG)
|
|
default:
|
|
return "<unsupported>";
|
|
}
|
|
}
|
|
|
|
const std::set<mfxU32>& get_supported_mfx_codec_ids()
|
|
{
|
|
static std::set<mfxU32> supported_codecs({MFX_CODEC_AVC,
|
|
MFX_CODEC_HEVC,
|
|
MFX_CODEC_MPEG2,
|
|
MFX_CODEC_VC1,
|
|
MFX_CODEC_VP9,
|
|
MFX_CODEC_AV1,
|
|
MFX_CODEC_JPEG});
|
|
return supported_codecs;
|
|
}
|
|
|
|
const char* mfx_codec_type_to_cstr(const mfxU32 fourcc, const mfxU32 type) {
|
|
switch (fourcc) {
|
|
case MFX_CODEC_JPEG: {
|
|
switch (type) {
|
|
ONEVPL_STRINGIFY_CASE(MFX_PROFILE_UNKNOWN)
|
|
ONEVPL_STRINGIFY_CASE(MFX_PROFILE_JPEG_BASELINE)
|
|
default: return "<unknown MFX_CODEC_JPEG profile";
|
|
}
|
|
}
|
|
case MFX_CODEC_AVC: {
|
|
switch (type) {
|
|
ONEVPL_STRINGIFY_CASE(MFX_PROFILE_UNKNOWN)
|
|
ONEVPL_STRINGIFY_CASE(MFX_PROFILE_AVC_BASELINE)
|
|
ONEVPL_STRINGIFY_CASE(MFX_PROFILE_AVC_MAIN)
|
|
ONEVPL_STRINGIFY_CASE(MFX_PROFILE_AVC_EXTENDED)
|
|
ONEVPL_STRINGIFY_CASE(MFX_PROFILE_AVC_HIGH)
|
|
ONEVPL_STRINGIFY_CASE(MFX_PROFILE_AVC_HIGH10)
|
|
ONEVPL_STRINGIFY_CASE(MFX_PROFILE_AVC_HIGH_422)
|
|
ONEVPL_STRINGIFY_CASE(MFX_PROFILE_AVC_CONSTRAINED_BASELINE)
|
|
ONEVPL_STRINGIFY_CASE(MFX_PROFILE_AVC_CONSTRAINED_HIGH)
|
|
ONEVPL_STRINGIFY_CASE(MFX_PROFILE_AVC_PROGRESSIVE_HIGH)
|
|
default: return "<unknown MFX_CODEC_AVC profile";
|
|
}
|
|
}
|
|
case MFX_CODEC_HEVC: {
|
|
switch (type) {
|
|
ONEVPL_STRINGIFY_CASE(MFX_PROFILE_UNKNOWN)
|
|
ONEVPL_STRINGIFY_CASE(MFX_PROFILE_HEVC_MAIN)
|
|
ONEVPL_STRINGIFY_CASE(MFX_PROFILE_HEVC_MAIN10)
|
|
ONEVPL_STRINGIFY_CASE(MFX_PROFILE_HEVC_MAINSP)
|
|
ONEVPL_STRINGIFY_CASE(MFX_PROFILE_HEVC_REXT)
|
|
ONEVPL_STRINGIFY_CASE(MFX_PROFILE_HEVC_SCC)
|
|
default: return "<unknown MFX_CODEC_HEVC profile";
|
|
}
|
|
}
|
|
|
|
case MFX_CODEC_MPEG2: {
|
|
switch (type) {
|
|
ONEVPL_STRINGIFY_CASE(MFX_PROFILE_UNKNOWN)
|
|
ONEVPL_STRINGIFY_CASE(MFX_PROFILE_MPEG2_SIMPLE)
|
|
ONEVPL_STRINGIFY_CASE(MFX_PROFILE_MPEG2_MAIN)
|
|
ONEVPL_STRINGIFY_CASE(MFX_LEVEL_MPEG2_HIGH)
|
|
ONEVPL_STRINGIFY_CASE(MFX_LEVEL_MPEG2_HIGH1440)
|
|
default: return "<unknown MFX_CODEC_MPEG2 profile";
|
|
}
|
|
}
|
|
|
|
case MFX_CODEC_VP8: {
|
|
switch (type) {
|
|
ONEVPL_STRINGIFY_CASE(MFX_PROFILE_UNKNOWN)
|
|
ONEVPL_STRINGIFY_CASE(MFX_PROFILE_VP8_0)
|
|
ONEVPL_STRINGIFY_CASE(MFX_PROFILE_VP8_1)
|
|
ONEVPL_STRINGIFY_CASE(MFX_PROFILE_VP8_2)
|
|
ONEVPL_STRINGIFY_CASE(MFX_PROFILE_VP8_3)
|
|
default: return "<unknown MFX_CODEC_VP8 profile";
|
|
}
|
|
}
|
|
|
|
case MFX_CODEC_VC1: {
|
|
switch (type) {
|
|
ONEVPL_STRINGIFY_CASE(MFX_PROFILE_UNKNOWN)
|
|
ONEVPL_STRINGIFY_CASE(MFX_PROFILE_VC1_SIMPLE)
|
|
ONEVPL_STRINGIFY_CASE(MFX_PROFILE_VC1_MAIN)
|
|
ONEVPL_STRINGIFY_CASE(MFX_PROFILE_VC1_ADVANCED)
|
|
default: return "<unknown MFX_CODEC_VC1 profile";
|
|
}
|
|
}
|
|
|
|
case MFX_CODEC_VP9: {
|
|
switch (type) {
|
|
ONEVPL_STRINGIFY_CASE(MFX_PROFILE_UNKNOWN)
|
|
ONEVPL_STRINGIFY_CASE(MFX_PROFILE_VP9_0)
|
|
ONEVPL_STRINGIFY_CASE(MFX_PROFILE_VP9_1)
|
|
ONEVPL_STRINGIFY_CASE(MFX_PROFILE_VP9_2)
|
|
ONEVPL_STRINGIFY_CASE(MFX_PROFILE_VP9_3)
|
|
default: return "<unknown MFX_CODEC_VP9 profile";
|
|
}
|
|
}
|
|
|
|
case MFX_CODEC_AV1: {
|
|
switch (type) {
|
|
ONEVPL_STRINGIFY_CASE(MFX_PROFILE_UNKNOWN)
|
|
ONEVPL_STRINGIFY_CASE(MFX_PROFILE_AV1_MAIN)
|
|
ONEVPL_STRINGIFY_CASE(MFX_PROFILE_AV1_HIGH)
|
|
ONEVPL_STRINGIFY_CASE(MFX_PROFILE_AV1_PRO)
|
|
default: return "<unknown MFX_CODEC_AV1 profile";
|
|
}
|
|
}
|
|
|
|
default: return "unknown codec type :";
|
|
}
|
|
}
|
|
|
|
mfxU32 cstr_to_mfx_version(const char* cstr) {
|
|
if (!cstr) {
|
|
return std::numeric_limits<mfxU32>::max();
|
|
}
|
|
|
|
const char* delim = strchr(cstr, '.');
|
|
if (!delim) {
|
|
// in digital form - return as is
|
|
return std::stoul(cstr, nullptr, 10);
|
|
}
|
|
std::string major (cstr, delim - cstr);
|
|
std::string minor (delim + 1);
|
|
mfxU32 major_val = std::stoul(major, nullptr, 10);
|
|
mfxU32 minor_val = std::stoul(minor, nullptr, 10);
|
|
|
|
// pack to digital form
|
|
return {major_val << 16 | minor_val};
|
|
}
|
|
|
|
std::ostream& operator<< (std::ostream& out, const mfxImplDescription& idesc)
|
|
{
|
|
out << "mfxImplDescription.Version: " << static_cast<int>(idesc.Version.Major)
|
|
<< "." << static_cast<int>(idesc.Version.Minor) << std::endl;
|
|
out << "(*)" << CfgParam::implementation_name() << ": " << mfx_impl_to_cstr(idesc.Impl) << std::endl;
|
|
out << "(*)" << CfgParam::acceleration_mode_name() << ": " << mfx_accel_mode_to_cstr(idesc.AccelerationMode) << std::endl;
|
|
out << "mfxImplDescription.ApiVersion: " << idesc.ApiVersion.Major << "." << idesc.ApiVersion.Minor << std::endl;
|
|
out << "(*)mfxImplDescription.ApiVersion.Version: " << idesc.ApiVersion.Version << std::endl;
|
|
out << "mfxImplDescription.ImplName: " << idesc.ImplName << std::endl;
|
|
out << "mfxImplDescription.License: " << idesc.License << std::endl;
|
|
out << "mfxImplDescription.Keywords: " << idesc.Keywords << std::endl;
|
|
out << "mfxImplDescription.VendorID: " << idesc.VendorID << std::endl;
|
|
out << "mfxImplDescription.VendorImplID: " << idesc.VendorImplID << std::endl;
|
|
|
|
const mfxAccelerationModeDescription &accel = idesc.AccelerationModeDescription;
|
|
out << "mfxImplDescription.mfxAccelerationMode.Version: " << static_cast<int>(accel.Version.Major)
|
|
<< "." << static_cast<int>(accel.Version.Minor) << std::endl;
|
|
for (int mode = 0; mode < accel.NumAccelerationModes; mode++) {
|
|
out << "mfxImplDescription.mfxAccelerationMode.Mode: " << mfx_accel_mode_to_cstr(accel.Mode[mode]) << std::endl;
|
|
}
|
|
|
|
const mfxDeviceDescription &dev = idesc.Dev;
|
|
out << "mfxImplDescription.mfxDeviceDescription.Version: " << static_cast<int>(dev.Version.Major)
|
|
<< "." << static_cast<int>(dev.Version.Minor) << std::endl;
|
|
out << "mfxImplDescription.mfxDeviceDescription.DeviceID: " << dev.DeviceID << std::endl;
|
|
for (int subdevice = 0; subdevice < dev.NumSubDevices; subdevice++) {
|
|
out << "mfxImplDescription.mfxDeviceDescription.subdevices.Index: " << dev.SubDevices[subdevice].Index << std::endl;
|
|
out << "mfxImplDescription.mfxDeviceDescription.subdevices.SubDeviceID: " << dev.SubDevices[subdevice].SubDeviceID << std::endl;
|
|
}
|
|
|
|
/* mfxDecoderDescription */
|
|
const mfxDecoderDescription &dec = idesc.Dec;
|
|
out << "mfxImplDescription.mfxDecoderDescription.Version: " << static_cast<int>(dec.Version.Major)
|
|
<< "." << static_cast<int>(dec.Version.Minor) << std::endl;
|
|
for (int codec = 0; codec < dec.NumCodecs; codec++) {
|
|
auto cid = dec.Codecs[codec].CodecID;
|
|
out << "(*)" << CfgParam::decoder_id_name() << ": " << cid;//(cid & 0xff) << "." << (cid >> 8 & 0xff) << "." << (cid >> 16 & 0xff) << "." << (cid >> 24 & 0xff) << std::endl;
|
|
out << "mfxImplDescription.mfxDecoderDescription.decoder.MaxcodecLevel: " << dec.Codecs[codec].MaxcodecLevel << std::endl;
|
|
for (int profile = 0; profile < dec.Codecs[codec].NumProfiles; profile++) {
|
|
out << "mfxImplDescription.mfxDecoderDescription.decoder.Profiles: "
|
|
<< mfx_codec_type_to_cstr(dec.Codecs[codec].CodecID,
|
|
dec.Codecs[codec].Profiles[profile].Profile) << std::endl;
|
|
for (int memtype = 0; memtype < dec.Codecs[codec].Profiles[profile].NumMemTypes; memtype++) {
|
|
out << "mfxImplDescription.mfxDecoderDescription.decoder.Profiles.MemDesc.MemHandleType: "
|
|
<< mfx_resource_type_to_cstr(dec.Codecs[codec].Profiles[profile].MemDesc[memtype].MemHandleType) << std::endl;
|
|
out << "mfxImplDescription.mfxDecoderDescription.decoder.Profiles.MemDesc.Width.Min: "
|
|
<< dec.Codecs[codec].Profiles[profile].MemDesc[memtype].Width.Min << std::endl;
|
|
out << "mfxImplDescription.mfxDecoderDescription.decoder.Profiles.MemDesc.Width.Max: "
|
|
<< dec.Codecs[codec].Profiles[profile].MemDesc[memtype].Width.Max << std::endl;
|
|
out << "mfxImplDescription.mfxDecoderDescription.decoder.Profiles.MemDesc.Width.Step: "
|
|
<< dec.Codecs[codec].Profiles[profile].MemDesc[memtype].Width.Step << std::endl;
|
|
out << "mfxImplDescription.mfxDecoderDescription.decoder.Profiles.MemDesc.Height.Min: "
|
|
<< dec.Codecs[codec].Profiles[profile].MemDesc[memtype].Height.Min << std::endl;
|
|
out << "mfxImplDescription.mfxDecoderDescription.decoder.Profiles.MemDesc.Height.Max: "
|
|
<< dec.Codecs[codec].Profiles[profile].MemDesc[memtype].Height.Max << std::endl;
|
|
out << "mfxImplDescription.mfxDecoderDescription.decoder.Profiles.MemDesc.Height.Step: "
|
|
<< dec.Codecs[codec].Profiles[profile].MemDesc[memtype].Height.Step << std::endl;
|
|
}
|
|
}
|
|
}
|
|
|
|
out << "mfxImplDescription.NumExtParam: " << idesc.NumExtParam << std::endl;
|
|
|
|
out << "\n(*) - configurable params" << std::endl;
|
|
return out;
|
|
}
|
|
|
|
std::string mfxstatus_to_string(int64_t err) {
|
|
return mfxstatus_to_string(static_cast<mfxStatus>(err));
|
|
}
|
|
|
|
std::string mfxstatus_to_string(mfxStatus err) {
|
|
switch(err) {
|
|
ONEVPL_STRINGIFY_CASE(MFX_ERR_NONE)
|
|
ONEVPL_STRINGIFY_CASE(MFX_ERR_UNKNOWN)
|
|
ONEVPL_STRINGIFY_CASE(MFX_ERR_NULL_PTR)
|
|
ONEVPL_STRINGIFY_CASE(MFX_ERR_UNSUPPORTED)
|
|
ONEVPL_STRINGIFY_CASE(MFX_ERR_MEMORY_ALLOC)
|
|
ONEVPL_STRINGIFY_CASE(MFX_ERR_NOT_ENOUGH_BUFFER)
|
|
ONEVPL_STRINGIFY_CASE(MFX_ERR_INVALID_HANDLE)
|
|
ONEVPL_STRINGIFY_CASE(MFX_ERR_LOCK_MEMORY)
|
|
ONEVPL_STRINGIFY_CASE(MFX_ERR_NOT_INITIALIZED)
|
|
ONEVPL_STRINGIFY_CASE(MFX_ERR_NOT_FOUND)
|
|
ONEVPL_STRINGIFY_CASE(MFX_ERR_MORE_DATA)
|
|
ONEVPL_STRINGIFY_CASE(MFX_ERR_MORE_SURFACE)
|
|
ONEVPL_STRINGIFY_CASE(MFX_ERR_ABORTED)
|
|
ONEVPL_STRINGIFY_CASE(MFX_ERR_DEVICE_LOST)
|
|
ONEVPL_STRINGIFY_CASE(MFX_ERR_INCOMPATIBLE_VIDEO_PARAM)
|
|
ONEVPL_STRINGIFY_CASE(MFX_ERR_INVALID_VIDEO_PARAM)
|
|
ONEVPL_STRINGIFY_CASE(MFX_ERR_UNDEFINED_BEHAVIOR)
|
|
ONEVPL_STRINGIFY_CASE(MFX_ERR_DEVICE_FAILED)
|
|
ONEVPL_STRINGIFY_CASE(MFX_ERR_MORE_BITSTREAM)
|
|
ONEVPL_STRINGIFY_CASE(MFX_ERR_GPU_HANG)
|
|
ONEVPL_STRINGIFY_CASE(MFX_ERR_REALLOC_SURFACE)
|
|
ONEVPL_STRINGIFY_CASE(MFX_ERR_RESOURCE_MAPPED)
|
|
ONEVPL_STRINGIFY_CASE(MFX_ERR_NOT_IMPLEMENTED)
|
|
ONEVPL_STRINGIFY_CASE(MFX_WRN_DEVICE_BUSY)
|
|
ONEVPL_STRINGIFY_CASE(MFX_WRN_VIDEO_PARAM_CHANGED)
|
|
ONEVPL_STRINGIFY_CASE(MFX_WRN_IN_EXECUTION)
|
|
default: break;
|
|
}
|
|
|
|
std::string ret("<unknown ");
|
|
ret += std::to_string(static_cast<size_t>(err)) + ">";
|
|
return ret;
|
|
}
|
|
|
|
std::string mfx_frame_info_to_string(const mfxFrameInfo &info) {
|
|
std::stringstream ss;
|
|
DUMP_MEMBER(ss, info, FrameRateExtN)
|
|
DUMP_MEMBER(ss, info, FrameRateExtD)
|
|
DUMP_MEMBER(ss, info, AspectRatioW)
|
|
DUMP_MEMBER(ss, info, AspectRatioH)
|
|
DUMP_MEMBER(ss, info, CropX)
|
|
DUMP_MEMBER(ss, info, CropY)
|
|
DUMP_MEMBER(ss, info, CropW)
|
|
DUMP_MEMBER(ss, info, CropH)
|
|
DUMP_MEMBER(ss, info, ChannelId)
|
|
DUMP_MEMBER(ss, info, BitDepthLuma)
|
|
DUMP_MEMBER(ss, info, BitDepthChroma)
|
|
DUMP_MEMBER(ss, info, Shift)
|
|
DUMP_MEMBER(ss, info, FourCC)
|
|
DUMP_MEMBER(ss, info, Width)
|
|
DUMP_MEMBER(ss, info, Height)
|
|
DUMP_MEMBER(ss, info, BufferSize)
|
|
DUMP_MEMBER(ss, info, PicStruct)
|
|
DUMP_MEMBER(ss, info, ChromaFormat);
|
|
return ss.str();
|
|
}
|
|
|
|
static int compare(const mfxFrameInfo &lhs, const mfxFrameInfo &rhs) {
|
|
//NB: mfxFrameInfo is a `packed` struct declared in VPL
|
|
return memcmp(&lhs, &rhs, sizeof(mfxFrameInfo));
|
|
}
|
|
|
|
bool operator< (const mfxFrameInfo &lhs, const mfxFrameInfo &rhs) {
|
|
return (compare(lhs, rhs) < 0);
|
|
}
|
|
|
|
bool operator== (const mfxFrameInfo &lhs, const mfxFrameInfo &rhs) {
|
|
return (compare(lhs, rhs) == 0);
|
|
}
|
|
|
|
std::string ext_mem_frame_type_to_cstr(int type) {
|
|
std::stringstream ss;
|
|
APPEND_STRINGIFY_MASK_N_ERASE(type, "|", MFX_MEMTYPE_DXVA2_DECODER_TARGET);
|
|
APPEND_STRINGIFY_MASK_N_ERASE(type, "|", MFX_MEMTYPE_DXVA2_PROCESSOR_TARGET);
|
|
// NB: according to VPL source the commented MFX_* constane below are belong to the
|
|
// same actual integral value as condition abobe. So it is impossible
|
|
// to distinct them in condition branch. Just put this comment and possible
|
|
// constans here...
|
|
//APPEND_STRINGIFY_MASK_N_ERASE(type, "|", MFX_MEMTYPE_VIDEO_MEMORY_DECODER_TARGET);
|
|
//APPEND_STRINGIFY_MASK_N_ERASE(type, "|", MFX_MEMTYPE_VIDEO_MEMORY_PROCESSOR_TARGET);
|
|
APPEND_STRINGIFY_MASK_N_ERASE(type, "|", MFX_MEMTYPE_SYSTEM_MEMORY);
|
|
APPEND_STRINGIFY_MASK_N_ERASE(type, "|", MFX_MEMTYPE_RESERVED1);
|
|
APPEND_STRINGIFY_MASK_N_ERASE(type, "|", MFX_MEMTYPE_FROM_ENCODE);
|
|
APPEND_STRINGIFY_MASK_N_ERASE(type, "|", MFX_MEMTYPE_FROM_DECODE);
|
|
APPEND_STRINGIFY_MASK_N_ERASE(type, "|", MFX_MEMTYPE_FROM_VPPIN);
|
|
APPEND_STRINGIFY_MASK_N_ERASE(type, "|", MFX_MEMTYPE_FROM_VPPOUT);
|
|
APPEND_STRINGIFY_MASK_N_ERASE(type, "|", MFX_MEMTYPE_FROM_ENC);
|
|
APPEND_STRINGIFY_MASK_N_ERASE(type, "|", MFX_MEMTYPE_INTERNAL_FRAME);
|
|
APPEND_STRINGIFY_MASK_N_ERASE(type, "|", MFX_MEMTYPE_EXTERNAL_FRAME);
|
|
APPEND_STRINGIFY_MASK_N_ERASE(type, "|", MFX_MEMTYPE_EXPORT_FRAME);
|
|
//APPEND_STRINGIFY_MASK_N_ERASE(type, "|", MFX_MEMTYPE_SHARED_RESOURCE);
|
|
APPEND_STRINGIFY_MASK_N_ERASE(type, "|", MFX_MEMTYPE_VIDEO_MEMORY_ENCODER_TARGET);
|
|
|
|
if (type != 0) {
|
|
ss << "(rest: " << std::to_string(type) << ")";
|
|
}
|
|
return ss.str();
|
|
}
|
|
} // namespace onevpl
|
|
} // namespace wip
|
|
} // namespace gapi
|
|
} // namespace cv
|
|
|
|
#endif // HAVE_ONEVPL
|