Download modules/gapi/src/streaming/onevpl/utils.cpp from tgollogly/test: direct link, hf CLI and curl.
- Browser
- Download file 19.6 kB
-
https://huggingface.co/tgollogly/test/resolve/main/modules/gapi/src/streaming/onevpl/utils.cpp
- Command line
-
hf download hf://tgollogly/test/modules/gapi/src/streaming/onevpl/utils.cpp
-
curl -L -o utils.cpp https://huggingface.co/tgollogly/test/resolve/main/modules/gapi/src/streaming/onevpl/utils.cpp
19.6 kB
| // 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 | |
| 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 | |