1 #ifndef _VKTVIDEOTESTUTILS_HPP 2 #define _VKTVIDEOTESTUTILS_HPP 3 /*------------------------------------------------------------------------ 4 * Vulkan Conformance Tests 5 * ------------------------ 6 * 7 * Copyright (c) 2021 The Khronos Group Inc. 8 * 9 * Licensed under the Apache License, Version 2.0 (the "License"); 10 * you may not use this file except in compliance with the License. 11 * You may obtain a copy of the License at 12 * 13 * http://www.apache.org/licenses/LICENSE-2.0 14 * 15 * Unless required by applicable law or agreed to in writing, software 16 * distributed under the License is distributed on an "AS IS" BASIS, 17 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 18 * See the License for the specific language governing permissions and 19 * limitations under the License. 20 * 21 *//*! 22 * \file 23 * \brief Video Encoding and Decoding Utility Functions 24 *//*--------------------------------------------------------------------*/ 25 26 #include "vktVideoTestUtils.hpp" 27 28 #include "vkDefs.hpp" 29 #include "vkRefUtil.hpp" 30 #include "vkMemUtil.hpp" 31 #include "vkCmdUtil.hpp" 32 #include "vkBarrierUtil.hpp" 33 #include "vkPlatform.hpp" 34 #include "vktTestCase.hpp" 35 #include "vktCustomInstancesDevices.hpp" 36 37 #include "ycbcr/vktYCbCrUtil.hpp" 38 #include "vkMd5Sum.hpp" 39 40 namespace vkt 41 { 42 namespace video 43 { 44 45 using namespace vk; 46 using namespace std; 47 48 typedef de::MovePtr<Allocation> AllocationPtr; 49 50 struct DeviceContext 51 { 52 53 Context *context{}; 54 VideoDevice *vd{}; 55 VkPhysicalDevice phys{VK_NULL_HANDLE}; 56 VkDevice device{VK_NULL_HANDLE}; 57 VkQueue decodeQueue{VK_NULL_HANDLE}; 58 VkQueue encodeQueue{VK_NULL_HANDLE}; 59 VkQueue transferQueue{VK_NULL_HANDLE}; 60 DeviceContextvkt::video::DeviceContext61 DeviceContext(Context *c, VideoDevice *v, VkPhysicalDevice p = VK_NULL_HANDLE, VkDevice d = VK_NULL_HANDLE, 62 VkQueue decodeQ = VK_NULL_HANDLE, VkQueue encodeQ = VK_NULL_HANDLE, 63 VkQueue transferQ = VK_NULL_HANDLE) 64 : context(c) 65 , vd(v) 66 , phys(p) 67 , device(d) 68 , decodeQueue(decodeQ) 69 , encodeQueue(encodeQ) 70 , transferQueue(transferQ) 71 { 72 } 73 updateDevicevkt::video::DeviceContext74 void updateDevice(VkPhysicalDevice p, VkDevice d, VkQueue decodeQ, VkQueue encodeQ, VkQueue transferQ) 75 { 76 phys = p; 77 device = d; 78 decodeQueue = decodeQ; 79 encodeQueue = encodeQ; 80 transferQueue = transferQ; 81 } 82 getInstanceInterfacevkt::video::DeviceContext83 const InstanceInterface &getInstanceInterface() const 84 { 85 return context->getInstanceInterface(); 86 } getDeviceDrivervkt::video::DeviceContext87 const DeviceDriver &getDeviceDriver() const 88 { 89 return vd->getDeviceDriver(); 90 } decodeQueueFamilyIdxvkt::video::DeviceContext91 uint32_t decodeQueueFamilyIdx() const 92 { 93 return vd->getQueueFamilyIndexDecode(); 94 } encodeQueueFamilyIdxvkt::video::DeviceContext95 uint32_t encodeQueueFamilyIdx() const 96 { 97 return vd->getQueueFamilyIndexEncode(); 98 } transferQueueFamilyIdxvkt::video::DeviceContext99 uint32_t transferQueueFamilyIdx() const 100 { 101 return vd->getQueueFamilyIndexTransfer(); 102 } allocatorvkt::video::DeviceContext103 Allocator &allocator() const 104 { 105 return vd->getAllocator(); 106 } waitDecodeQueuevkt::video::DeviceContext107 void waitDecodeQueue() const 108 { 109 VK_CHECK(getDeviceDriver().queueWaitIdle(decodeQueue)); 110 } waitEncodeQueuevkt::video::DeviceContext111 void waitEncodeQueue() const 112 { 113 VK_CHECK(getDeviceDriver().queueWaitIdle(encodeQueue)); 114 } deviceWaitIdlevkt::video::DeviceContext115 void deviceWaitIdle() const 116 { 117 VK_CHECK(getDeviceDriver().deviceWaitIdle(device)); 118 } 119 }; 120 121 typedef de::MovePtr<Allocation> AllocationPtr; 122 123 bool videoLoggingEnabled(); 124 125 bool videoLoggingEnabled(); 126 127 VkVideoDecodeH264ProfileInfoKHR getProfileOperationH264Decode( 128 StdVideoH264ProfileIdc stdProfileIdc = STD_VIDEO_H264_PROFILE_IDC_MAIN, 129 VkVideoDecodeH264PictureLayoutFlagBitsKHR pictureLayout = 130 VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_INTERLEAVED_LINES_BIT_KHR); 131 VkVideoEncodeH264ProfileInfoKHR getProfileOperationH264Encode( 132 StdVideoH264ProfileIdc stdProfileIdc = STD_VIDEO_H264_PROFILE_IDC_MAIN); 133 VkVideoDecodeH265ProfileInfoKHR getProfileOperationH265Decode( 134 StdVideoH265ProfileIdc stdProfileIdc = STD_VIDEO_H265_PROFILE_IDC_MAIN); 135 VkVideoEncodeH265ProfileInfoKHR getProfileOperationH265Encode( 136 StdVideoH265ProfileIdc stdProfileIdc = STD_VIDEO_H265_PROFILE_IDC_MAIN); 137 VkVideoDecodeAV1ProfileInfoKHR getProfileOperationAV1Decode(StdVideoAV1Profile stdProfile = STD_VIDEO_AV1_PROFILE_MAIN, 138 bool filmgrainSupport = true); 139 const VkExtensionProperties *getVideoExtensionProperties(const VkVideoCodecOperationFlagBitsKHR codecOperation); 140 141 de::MovePtr<vector<VkFormat>> getSupportedFormats(const InstanceInterface &vk, const VkPhysicalDevice physicalDevice, 142 const VkImageUsageFlags imageUsageFlags, 143 const VkVideoProfileListInfoKHR *videoProfileList); 144 145 void cmdPipelineImageMemoryBarrier2(const DeviceInterface &vk, const VkCommandBuffer commandBuffer, 146 const VkImageMemoryBarrier2KHR *pImageMemoryBarriers, 147 const size_t imageMemoryBarrierCount = 1u, 148 const VkDependencyFlags dependencyFlags = 0); 149 150 void validateVideoProfileList(const InstanceInterface &vk, VkPhysicalDevice physicalDevice, 151 const VkVideoProfileListInfoKHR *videoProfileList, const VkFormat format, 152 const VkImageUsageFlags usage); 153 154 de::MovePtr<VkVideoDecodeCapabilitiesKHR> getVideoDecodeCapabilities(void *pNext); 155 156 de::MovePtr<VkVideoDecodeH264CapabilitiesKHR> getVideoCapabilitiesExtensionH264D(void); 157 de::MovePtr<VkVideoEncodeH264CapabilitiesKHR> getVideoCapabilitiesExtensionH264E(void); 158 de::MovePtr<VkVideoDecodeH265CapabilitiesKHR> getVideoCapabilitiesExtensionH265D(void); 159 de::MovePtr<VkVideoEncodeH265CapabilitiesKHR> getVideoCapabilitiesExtensionH265E(void); 160 de::MovePtr<VkVideoEncodeCapabilitiesKHR> getVideoEncodeCapabilities(void *pNext); 161 de::MovePtr<VkVideoCapabilitiesKHR> getVideoCapabilities(const InstanceInterface &vk, VkPhysicalDevice physicalDevice, 162 const VkVideoProfileInfoKHR *videoProfile, void *pNext); 163 164 de::MovePtr<VkVideoDecodeH264ProfileInfoKHR> getVideoProfileExtensionH264D( 165 StdVideoH264ProfileIdc stdProfileIdc = STD_VIDEO_H264_PROFILE_IDC_MAIN, 166 VkVideoDecodeH264PictureLayoutFlagBitsKHR pictureLayout = 167 VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_INTERLEAVED_LINES_BIT_KHR); 168 de::MovePtr<VkVideoEncodeH264ProfileInfoKHR> getVideoProfileExtensionH264E( 169 StdVideoH264ProfileIdc stdProfileIdc = STD_VIDEO_H264_PROFILE_IDC_MAIN); 170 de::MovePtr<VkVideoDecodeH265ProfileInfoKHR> getVideoProfileExtensionH265D( 171 StdVideoH265ProfileIdc stdProfileIdc = STD_VIDEO_H265_PROFILE_IDC_MAIN); 172 de::MovePtr<VkVideoEncodeH265ProfileInfoKHR> getVideoProfileExtensionH265E( 173 StdVideoH265ProfileIdc stdProfileIdc = STD_VIDEO_H265_PROFILE_IDC_MAIN); 174 175 de::MovePtr<VkVideoEncodeUsageInfoKHR> getEncodeUsageInfo(void *pNext, VkVideoEncodeUsageFlagsKHR videoUsageHints, 176 VkVideoEncodeContentFlagsKHR videoContentHints, 177 VkVideoEncodeTuningModeKHR tuningMode); 178 de::MovePtr<VkVideoProfileInfoKHR> getVideoProfile( 179 VkVideoCodecOperationFlagBitsKHR videoCodecOperation, void *pNext, 180 VkVideoChromaSubsamplingFlagsKHR chromaSubsampling = VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR, 181 VkVideoComponentBitDepthFlagsKHR lumaBitDepth = VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR, 182 VkVideoComponentBitDepthFlagsKHR chromaBitDepth = VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR); 183 de::MovePtr<VkVideoProfileListInfoKHR> getVideoProfileList(const VkVideoProfileInfoKHR *videoProfile, 184 const uint32_t profileCount); 185 186 de::MovePtr<VkVideoSessionCreateInfoKHR> getVideoSessionCreateInfo( 187 uint32_t queueFamilyIndex, VkVideoSessionCreateFlagsKHR flags, const VkVideoProfileInfoKHR *videoProfile, 188 const VkExtent2D &codedExtent = {1920, 1080}, VkFormat pictureFormat = VK_FORMAT_G8_B8R8_2PLANE_420_UNORM, 189 VkFormat referencePicturesFormat = VK_FORMAT_G8_B8R8_2PLANE_420_UNORM, uint32_t maxReferencePicturesSlotsCount = 2u, 190 uint32_t maxReferencePicturesActiveCount = 2u); 191 192 vector<AllocationPtr> getAndBindVideoSessionMemory(const DeviceInterface &vkd, const VkDevice device, 193 VkVideoSessionKHR videoSession, Allocator &allocator); 194 195 bool validateFormatSupport(const InstanceInterface &vk, VkPhysicalDevice physicalDevice, 196 const VkImageUsageFlags imageUsageFlags, const VkVideoProfileListInfoKHR *videoProfileList, 197 const VkFormat format, const bool throwException = true); 198 199 VkImageCreateInfo makeImageCreateInfo(VkFormat format, const VkExtent2D &extent, const VkImageCreateFlags flags, 200 const uint32_t *queueFamilyIndex, const VkImageUsageFlags usage, void *pNext, 201 const uint32_t arrayLayers = 1, 202 const VkImageLayout initialLayout = VK_IMAGE_LAYOUT_UNDEFINED); 203 204 de::MovePtr<StdVideoH264SequenceParameterSet> getStdVideoH264DecodeSequenceParameterSet( 205 uint32_t width, uint32_t height, StdVideoH264SequenceParameterSetVui *stdVideoH264SequenceParameterSetVui); 206 de::MovePtr<StdVideoH264SequenceParameterSet> getStdVideoH264EncodeSequenceParameterSet( 207 uint32_t width, uint32_t height, uint8_t maxNumRefs, 208 StdVideoH264SequenceParameterSetVui *stdVideoH264SequenceParameterSetVui); 209 210 de::MovePtr<StdVideoH264PictureParameterSet> getStdVideoH264DecodePictureParameterSet(void); 211 de::MovePtr<StdVideoH264PictureParameterSet> getStdVideoH264EncodePictureParameterSet(uint8_t numL0, uint8_t numL1); 212 213 de::MovePtr<VkVideoEncodeH264SessionParametersAddInfoKHR> createVideoEncodeH264SessionParametersAddInfoKHR( 214 uint32_t stdSPSCount, const StdVideoH264SequenceParameterSet *pStdSPSs, uint32_t stdPPSCount, 215 const StdVideoH264PictureParameterSet *pStdPPSs); 216 217 de::MovePtr<VkVideoEncodeH264SessionParametersCreateInfoKHR> createVideoEncodeH264SessionParametersCreateInfoKHR( 218 const void *pNext, uint32_t maxStdSPSCount, uint32_t maxStdPPSCount, 219 const VkVideoEncodeH264SessionParametersAddInfoKHR *pParametersAddInfo); 220 221 de::MovePtr<StdVideoH265ProfileTierLevel> getStdVideoH265ProfileTierLevel(StdVideoH265ProfileIdc general_profile_idc, 222 StdVideoH265LevelIdc general_level_idc); 223 de::MovePtr<StdVideoH265DecPicBufMgr> getStdVideoH265DecPicBufMgr(void); 224 de::MovePtr<StdVideoH265VideoParameterSet> getStdVideoH265VideoParameterSet( 225 const StdVideoH265DecPicBufMgr *pDecPicBufMgr, const StdVideoH265ProfileTierLevel *pProfileTierLevel); 226 227 de::MovePtr<StdVideoH265SequenceParameterSetVui> getStdVideoH265SequenceParameterSetVui(uint32_t vui_time_scale); 228 de::MovePtr<StdVideoH265ShortTermRefPicSet> getStdVideoH265ShortTermRefPicSet(StdVideoH265PictureType pictureType, 229 uint32_t frameIdx, 230 uint32_t consecutiveBFrameCount); 231 de::MovePtr<StdVideoH265SequenceParameterSet> getStdVideoH265SequenceParameterSet( 232 uint32_t width, uint32_t height, VkVideoEncodeH265CtbSizeFlagsKHR ctbSizesFlag, 233 VkVideoEncodeH265TransformBlockSizeFlagsKHR transformBlockSizesFlag, const StdVideoH265DecPicBufMgr *pDecPicBufMgr, 234 const StdVideoH265ProfileTierLevel *pProfileTierLevel, 235 const StdVideoH265SequenceParameterSetVui *pSequenceParameterSetVui); 236 237 de::MovePtr<StdVideoH265PictureParameterSet> getStdVideoH265PictureParameterSet( 238 const VkVideoEncodeH265CapabilitiesKHR *videoH265CapabilitiesExtension); 239 240 de::MovePtr<VkVideoEncodeH265SessionParametersAddInfoKHR> getVideoEncodeH265SessionParametersAddInfoKHR( 241 uint32_t stdVPSCount, const StdVideoH265VideoParameterSet *pStdVPSs, uint32_t stdSPSCount, 242 const StdVideoH265SequenceParameterSet *pStdSPSs, uint32_t stdPPSCount, 243 const StdVideoH265PictureParameterSet *pStdPPSs); 244 245 de::MovePtr<VkVideoEncodeH265SessionParametersCreateInfoKHR> getVideoEncodeH265SessionParametersCreateInfoKHR( 246 const void *pNext, uint32_t maxStdVPSCount, uint32_t maxStdSPSCount, uint32_t maxStdPPSCount, 247 const VkVideoEncodeH265SessionParametersAddInfoKHR *pParametersAddInfo); 248 249 de::MovePtr<VkVideoSessionParametersCreateInfoKHR> getVideoSessionParametersCreateInfoKHR( 250 const void *pNext, VkVideoSessionKHR videoSession); 251 252 de::MovePtr<StdVideoEncodeH264ReferenceInfo> getStdVideoEncodeH264ReferenceInfo( 253 StdVideoH264PictureType primary_pic_type, uint32_t FrameNum, int32_t PicOrderCnt); 254 de::MovePtr<VkVideoEncodeH264DpbSlotInfoKHR> getVideoEncodeH264DpbSlotInfo( 255 const StdVideoEncodeH264ReferenceInfo *pStdReferenceInfo); 256 de::MovePtr<StdVideoEncodeH265ReferenceInfo> getStdVideoEncodeH265ReferenceInfo(StdVideoH265PictureType pic_type, 257 int32_t PicOrderCntVal); 258 de::MovePtr<VkVideoEncodeH265DpbSlotInfoKHR> getVideoEncodeH265DpbSlotInfo( 259 const StdVideoEncodeH265ReferenceInfo *pStdReferenceInfo); 260 261 de::MovePtr<StdVideoEncodeH264SliceHeader> getStdVideoEncodeH264SliceHeader(StdVideoH264SliceType sliceType, 262 bool activeOverrideFlag); 263 de::MovePtr<StdVideoEncodeH265SliceSegmentHeader> getStdVideoEncodeH265SliceSegmentHeader( 264 StdVideoH265SliceType sliceType); 265 266 de::MovePtr<VkVideoEncodeH264NaluSliceInfoKHR> getVideoEncodeH264NaluSlice( 267 StdVideoEncodeH264SliceHeader *stdVideoEncodeH264SliceHeader, const int32_t qpValue = 0); 268 de::MovePtr<VkVideoEncodeH265NaluSliceSegmentInfoKHR> getVideoEncodeH265NaluSliceSegment( 269 StdVideoEncodeH265SliceSegmentHeader *stdVideoEncodeH265SliceSegmentHeader, const int32_t qpValue = 0); 270 271 de::MovePtr<StdVideoEncodeH264ReferenceListsInfo> getVideoEncodeH264ReferenceListsInfo( 272 uint8_t RefPicList0[STD_VIDEO_H264_MAX_NUM_LIST_REF], uint8_t RefPicList1[STD_VIDEO_H264_MAX_NUM_LIST_REF], 273 uint8_t numL0, uint8_t numL1); 274 de::MovePtr<StdVideoEncodeH265ReferenceListsInfo> getVideoEncodeH265ReferenceListsInfo( 275 uint8_t RefPicList0[STD_VIDEO_H265_MAX_NUM_LIST_REF], uint8_t RefPicList1[STD_VIDEO_H265_MAX_NUM_LIST_REF]); 276 277 de::MovePtr<StdVideoEncodeH264PictureInfo> getStdVideoEncodeH264PictureInfo( 278 StdVideoH264PictureType pictureType, uint32_t frameNum, int32_t PicOrderCnt, uint16_t idr_pic_id, 279 const StdVideoEncodeH264ReferenceListsInfo *pRefLists); 280 281 de::MovePtr<VkVideoEncodeH264PictureInfoKHR> getVideoEncodeH264PictureInfo( 282 const StdVideoEncodeH264PictureInfo *pictureInfo, 283 const VkVideoEncodeH264NaluSliceInfoKHR *pNaluSliceEntries = DE_NULL); 284 285 de::MovePtr<StdVideoEncodeH265PictureInfo> getStdVideoEncodeH265PictureInfo( 286 StdVideoH265PictureType pictureType, int32_t PicOrderCntVal, const StdVideoEncodeH265ReferenceListsInfo *pRefLists, 287 StdVideoH265ShortTermRefPicSet *pShortTermRefPicSet); 288 289 de::MovePtr<VkVideoEncodeH265PictureInfoKHR> getVideoEncodeH265PictureInfo( 290 const StdVideoEncodeH265PictureInfo *pictureInfo, 291 const VkVideoEncodeH265NaluSliceSegmentInfoKHR *pNaluSliceSegmentInfo); 292 293 de::MovePtr<VkVideoBeginCodingInfoKHR> getVideoBeginCodingInfo( 294 VkVideoSessionKHR videoEncodeSession, VkVideoSessionParametersKHR videoEncodeSessionParameters, 295 uint32_t referenceSlotCount = 0, const VkVideoReferenceSlotInfoKHR *pReferenceSlots = DE_NULL, 296 const void *pNext = DE_NULL); 297 298 de::MovePtr<VkVideoInlineQueryInfoKHR> getVideoInlineQueryInfo(VkQueryPool queryPool, uint32_t firstQuery, 299 uint32_t queryCount, const void *pNext = DE_NULL); 300 301 de::MovePtr<StdVideoDecodeH264PictureInfo> getStdVideoDecodeH264PictureInfo(void); 302 303 de::SharedPtr<VkVideoDecodeH264PictureInfoKHR> getVideoDecodeH264PictureInfo( 304 StdVideoDecodeH264PictureInfo *stdPictureInfo, uint32_t *sliceOffset); 305 306 de::MovePtr<VkVideoEncodeH264RateControlLayerInfoKHR> getVideoEncodeH264RateControlLayerInfo( 307 VkBool32 useMinQp, int32_t minQpI = 0, int32_t minQpP = 0, int32_t minQpB = 0, VkBool32 useMaxQp = 0, 308 int32_t maxQpI = 0, int32_t maxQpP = 0, int32_t maxQpB = 0); 309 de::MovePtr<VkVideoEncodeH265RateControlLayerInfoKHR> getVideoEncodeH265RateControlLayerInfo(VkBool32 useQp, 310 int32_t qpI = 0, 311 int32_t qpP = 0, 312 int32_t qpB = 0); 313 314 de::MovePtr<VkVideoEncodeRateControlLayerInfoKHR> getVideoEncodeRateControlLayerInfo( 315 const void *pNext, VkVideoEncodeRateControlModeFlagBitsKHR rateControlMode, const uint32_t frameRateNumerator); 316 de::MovePtr<VkVideoEncodeRateControlInfoKHR> getVideoEncodeRateControlInfo( 317 const void *pNext, VkVideoEncodeRateControlModeFlagBitsKHR rateControlMode, 318 VkVideoEncodeRateControlLayerInfoKHR *videoEncodeRateControlLayerInfo); 319 320 de::MovePtr<VkVideoEncodeH264QualityLevelPropertiesKHR> getvideoEncodeH264QualityLevelProperties(int32_t qpI, 321 int32_t qpP, 322 int32_t qpB); 323 de::MovePtr<VkVideoEncodeH265QualityLevelPropertiesKHR> getvideoEncodeH265QualityLevelProperties(int32_t qpI, 324 int32_t qpP, 325 int32_t qpB); 326 327 de::MovePtr<VkVideoEncodeQualityLevelPropertiesKHR> getVideoEncodeQualityLevelProperties( 328 void *pNext, VkVideoEncodeRateControlModeFlagBitsKHR preferredRateControlMode); 329 de::MovePtr<VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR> getPhysicalDeviceVideoEncodeQualityLevelInfo( 330 const VkVideoProfileInfoKHR *pVideoProfile, uint32_t qualityLevel); 331 332 de::MovePtr<VkVideoEncodeQualityLevelInfoKHR> getVideoEncodeQualityLevelInfo( 333 uint32_t qualityLevel, VkVideoEncodeQualityLevelPropertiesKHR *videoEncodeQualityLevelProperties = DE_NULL); 334 335 de::MovePtr<VkVideoCodingControlInfoKHR> getVideoCodingControlInfo(VkVideoCodingControlFlagsKHR flags, 336 const void *pNext = DE_NULL); 337 338 de::MovePtr<VkVideoEncodeInfoKHR> getVideoEncodeInfo(const void *pNext, const VkBuffer &dstBuffer, 339 const VkDeviceSize &dstBufferOffset, 340 const VkVideoPictureResourceInfoKHR &srcPictureResource, 341 const VkVideoReferenceSlotInfoKHR *pSetupReferenceSlot, 342 const uint32_t &referenceSlotCount, 343 const VkVideoReferenceSlotInfoKHR *pReferenceSlots); 344 345 void transferImageOwnership(const DeviceInterface &vkd, VkDevice device, VkImage image, 346 uint32_t transferQueueFamilyIndex, uint32_t encodeQueueFamilyIndex, 347 VkImageLayout newLayout); 348 349 VkDeviceSize getBufferSize(VkFormat format, uint32_t width, uint32_t height); 350 351 de::MovePtr<vkt::ycbcr::MultiPlaneImageData> getDecodedImage(const DeviceInterface &vkd, VkDevice device, 352 Allocator &allocator, VkImage image, VkImageLayout layout, 353 VkFormat format, VkExtent2D codedExtent, 354 uint32_t queueFamilyIndexTransfer, 355 uint32_t queueFamilyIndexDecode); 356 357 const VkImageFormatProperties getImageFormatProperties(const InstanceInterface &vk, VkPhysicalDevice physicalDevice, 358 const VkVideoProfileListInfoKHR *videoProfileList, 359 const VkFormat format, const VkImageUsageFlags usage); 360 361 class VideoBaseTestInstance : public TestInstance 362 { 363 public: VideoBaseTestInstance(Context & context)364 explicit VideoBaseTestInstance(Context &context) : TestInstance(context), m_videoDevice(context) 365 { 366 } 367 VideoBaseTestInstance(Context & context,const VkVideoCodecOperationFlagsKHR videoCodecOperation,const uint32_t videoDeviceFlags)368 explicit VideoBaseTestInstance(Context &context, const VkVideoCodecOperationFlagsKHR videoCodecOperation, 369 const uint32_t videoDeviceFlags) 370 : TestInstance(context) 371 , m_videoDevice(context, videoCodecOperation, videoDeviceFlags) 372 { 373 } 374 375 ~VideoBaseTestInstance() override = default; 376 377 VkDevice getDeviceSupportingQueue( 378 VkQueueFlags queueFlagsRequired = 0, VkVideoCodecOperationFlagsKHR videoCodecOperationFlags = 0, 379 VideoDevice::VideoDeviceFlags videoDeviceFlags = VideoDevice::VIDEO_DEVICE_FLAG_NONE); 380 bool createDeviceSupportingQueue( 381 VkQueueFlags queueFlagsRequired, VkVideoCodecOperationFlagsKHR videoCodecOperationFlags, 382 VideoDevice::VideoDeviceFlags videoDeviceFlags = VideoDevice::VIDEO_DEVICE_FLAG_NONE); 383 const DeviceDriver &getDeviceDriver(); 384 uint32_t getQueueFamilyIndexTransfer(); 385 uint32_t getQueueFamilyIndexDecode(); 386 uint32_t getQueueFamilyIndexEncode(); 387 Allocator &getAllocator(); 388 389 protected: 390 de::MovePtr<vector<uint8_t>> loadVideoData(const string &filename); 391 VideoDevice m_videoDevice; 392 }; 393 394 typedef enum StdChromaFormatIdc 395 { 396 chroma_format_idc_monochrome = STD_VIDEO_H264_CHROMA_FORMAT_IDC_MONOCHROME, 397 chroma_format_idc_420 = STD_VIDEO_H264_CHROMA_FORMAT_IDC_420, 398 chroma_format_idc_422 = STD_VIDEO_H264_CHROMA_FORMAT_IDC_422, 399 chroma_format_idc_444 = STD_VIDEO_H264_CHROMA_FORMAT_IDC_444, 400 } StdChromaFormatIdc; 401 402 class VkVideoCoreProfile 403 { 404 public: isValidCodec(VkVideoCodecOperationFlagsKHR videoCodecOperations)405 static bool isValidCodec(VkVideoCodecOperationFlagsKHR videoCodecOperations) 406 { 407 return (videoCodecOperations & 408 (VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR | VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR | 409 VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR | VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR | 410 VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR)); 411 } 412 PopulateProfileExt(VkBaseInStructure const * pVideoProfileExt)413 bool PopulateProfileExt(VkBaseInStructure const *pVideoProfileExt) 414 { 415 if (m_profile.videoCodecOperation == VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR) 416 { 417 VkVideoDecodeH264ProfileInfoKHR const *pProfileExt = 418 (VkVideoDecodeH264ProfileInfoKHR const *)pVideoProfileExt; 419 if (pProfileExt && (pProfileExt->sType != VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR)) 420 { 421 m_profile.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO; 422 return false; 423 } 424 if (pProfileExt) 425 { 426 m_h264DecodeProfile = *pProfileExt; 427 } 428 else 429 { 430 // Use default ext profile parameters 431 m_h264DecodeProfile.sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR; 432 m_h264DecodeProfile.stdProfileIdc = STD_VIDEO_H264_PROFILE_IDC_MAIN; 433 m_h264DecodeProfile.pictureLayout = 434 VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_INTERLEAVED_LINES_BIT_KHR; 435 } 436 m_profile.pNext = &m_h264DecodeProfile; 437 m_h264DecodeProfile.pNext = NULL; 438 } 439 else if (m_profile.videoCodecOperation == VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR) 440 { 441 VkVideoDecodeH265ProfileInfoKHR const *pProfileExt = 442 (VkVideoDecodeH265ProfileInfoKHR const *)pVideoProfileExt; 443 if (pProfileExt && (pProfileExt->sType != VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR)) 444 { 445 m_profile.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO; 446 return false; 447 } 448 if (pProfileExt) 449 { 450 m_h265DecodeProfile = *pProfileExt; 451 } 452 else 453 { 454 // Use default ext profile parameters 455 m_h265DecodeProfile.sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR; 456 m_h265DecodeProfile.stdProfileIdc = STD_VIDEO_H265_PROFILE_IDC_MAIN; 457 } 458 m_profile.pNext = &m_h265DecodeProfile; 459 m_h265DecodeProfile.pNext = NULL; 460 } 461 else if (m_profile.videoCodecOperation == VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR) 462 { 463 VkVideoDecodeAV1ProfileInfoKHR const *pProfileExt = 464 (VkVideoDecodeAV1ProfileInfoKHR const *)pVideoProfileExt; 465 if (pProfileExt && (pProfileExt->sType != VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR)) 466 { 467 m_profile.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO; 468 return false; 469 } 470 if (pProfileExt) 471 { 472 m_av1DecodeProfile = *pProfileExt; 473 } 474 else 475 { 476 // Use default ext profile parameters 477 m_av1DecodeProfile.sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR; 478 m_av1DecodeProfile.stdProfile = STD_VIDEO_AV1_PROFILE_MAIN; 479 } 480 m_profile.pNext = &m_av1DecodeProfile; 481 m_av1DecodeProfile.pNext = NULL; 482 } 483 else if (m_profile.videoCodecOperation == VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR) 484 { 485 VkVideoEncodeH264ProfileInfoKHR const *pProfileExt = 486 (VkVideoEncodeH264ProfileInfoKHR const *)pVideoProfileExt; 487 if (pProfileExt && (pProfileExt->sType != VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR)) 488 { 489 m_profile.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO; 490 return false; 491 } 492 if (pProfileExt) 493 { 494 m_h264EncodeProfile = *pProfileExt; 495 } 496 else 497 { 498 // Use default ext profile parameters 499 m_h264DecodeProfile.sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR; 500 m_h264DecodeProfile.stdProfileIdc = STD_VIDEO_H264_PROFILE_IDC_MAIN; 501 } 502 m_profile.pNext = &m_h264EncodeProfile; 503 m_h264EncodeProfile.pNext = NULL; 504 } 505 else if (m_profile.videoCodecOperation == VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR) 506 { 507 VkVideoEncodeH265ProfileInfoKHR const *pProfileExt = 508 (VkVideoEncodeH265ProfileInfoKHR const *)pVideoProfileExt; 509 if (pProfileExt && (pProfileExt->sType != VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_KHR)) 510 { 511 m_profile.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO; 512 return false; 513 } 514 if (pProfileExt) 515 { 516 m_h265EncodeProfile = *pProfileExt; 517 } 518 else 519 { 520 // Use default ext profile parameters 521 m_h265EncodeProfile.sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_KHR; 522 m_h265EncodeProfile.stdProfileIdc = STD_VIDEO_H265_PROFILE_IDC_MAIN; 523 } 524 m_profile.pNext = &m_h265EncodeProfile; 525 m_h265EncodeProfile.pNext = NULL; 526 } 527 else 528 { 529 DE_ASSERT(false && "Unknown codec!"); 530 return false; 531 } 532 533 return true; 534 } 535 InitFromProfile(const VkVideoProfileInfoKHR * pVideoProfile)536 bool InitFromProfile(const VkVideoProfileInfoKHR *pVideoProfile) 537 { 538 m_profile = *pVideoProfile; 539 m_profile.pNext = NULL; 540 return PopulateProfileExt((VkBaseInStructure const *)pVideoProfile->pNext); 541 } 542 VkVideoCoreProfile(const VkVideoProfileInfoKHR * pVideoProfile)543 VkVideoCoreProfile(const VkVideoProfileInfoKHR *pVideoProfile) : m_profile(*pVideoProfile) 544 { 545 546 PopulateProfileExt((VkBaseInStructure const *)pVideoProfile->pNext); 547 } 548 VkVideoCoreProfile(VkVideoCodecOperationFlagBitsKHR videoCodecOperation=VK_VIDEO_CODEC_OPERATION_NONE_KHR,VkVideoChromaSubsamplingFlagsKHR chromaSubsampling=VK_VIDEO_CHROMA_SUBSAMPLING_INVALID_KHR,VkVideoComponentBitDepthFlagsKHR lumaBitDepth=VK_VIDEO_COMPONENT_BIT_DEPTH_INVALID_KHR,VkVideoComponentBitDepthFlagsKHR chromaBitDepth=VK_VIDEO_COMPONENT_BIT_DEPTH_INVALID_KHR,uint32_t videoProfileIdc=0,bool filmGrainPresent=false)549 VkVideoCoreProfile(VkVideoCodecOperationFlagBitsKHR videoCodecOperation = VK_VIDEO_CODEC_OPERATION_NONE_KHR, 550 VkVideoChromaSubsamplingFlagsKHR chromaSubsampling = VK_VIDEO_CHROMA_SUBSAMPLING_INVALID_KHR, 551 VkVideoComponentBitDepthFlagsKHR lumaBitDepth = VK_VIDEO_COMPONENT_BIT_DEPTH_INVALID_KHR, 552 VkVideoComponentBitDepthFlagsKHR chromaBitDepth = VK_VIDEO_COMPONENT_BIT_DEPTH_INVALID_KHR, 553 uint32_t videoProfileIdc = 0, bool filmGrainPresent = false) 554 : m_profile({VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR, NULL, videoCodecOperation, chromaSubsampling, 555 lumaBitDepth, chromaBitDepth}) 556 , m_profileList({VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR, NULL, 1, &m_profile}) 557 { 558 if (!isValidCodec(videoCodecOperation)) 559 { 560 return; 561 } 562 563 VkVideoDecodeH264ProfileInfoKHR decodeH264ProfilesRequest; 564 VkVideoDecodeH265ProfileInfoKHR decodeH265ProfilesRequest; 565 VkVideoDecodeAV1ProfileInfoKHR decodeAV1ProfilesRequest; 566 VkVideoEncodeH264ProfileInfoKHR encodeH264ProfilesRequest; 567 VkVideoEncodeH265ProfileInfoKHR encodeH265ProfilesRequest; 568 VkBaseInStructure *pVideoProfileExt = NULL; 569 570 if (videoCodecOperation == VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR) 571 { 572 decodeH264ProfilesRequest.sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR; 573 decodeH264ProfilesRequest.pNext = NULL; 574 decodeH264ProfilesRequest.stdProfileIdc = 575 (videoProfileIdc == 0) ? STD_VIDEO_H264_PROFILE_IDC_INVALID : (StdVideoH264ProfileIdc)videoProfileIdc; 576 decodeH264ProfilesRequest.pictureLayout = 577 VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_INTERLEAVED_LINES_BIT_KHR; 578 pVideoProfileExt = (VkBaseInStructure *)&decodeH264ProfilesRequest; 579 } 580 else if (videoCodecOperation == VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR) 581 { 582 decodeH265ProfilesRequest.sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR; 583 decodeH265ProfilesRequest.pNext = NULL; 584 decodeH265ProfilesRequest.stdProfileIdc = 585 (videoProfileIdc == 0) ? STD_VIDEO_H265_PROFILE_IDC_INVALID : (StdVideoH265ProfileIdc)videoProfileIdc; 586 pVideoProfileExt = (VkBaseInStructure *)&decodeH265ProfilesRequest; 587 } 588 else if (videoCodecOperation == VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR) 589 { 590 decodeAV1ProfilesRequest.sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR; 591 decodeAV1ProfilesRequest.pNext = NULL; 592 decodeAV1ProfilesRequest.stdProfile = (StdVideoAV1Profile)videoProfileIdc; 593 decodeAV1ProfilesRequest.filmGrainSupport = filmGrainPresent; 594 pVideoProfileExt = (VkBaseInStructure *)&decodeAV1ProfilesRequest; 595 } 596 else if (videoCodecOperation == VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR) 597 { 598 encodeH264ProfilesRequest.sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR; 599 encodeH264ProfilesRequest.pNext = NULL; 600 encodeH264ProfilesRequest.stdProfileIdc = 601 (videoProfileIdc == 0) ? STD_VIDEO_H264_PROFILE_IDC_INVALID : (StdVideoH264ProfileIdc)videoProfileIdc; 602 pVideoProfileExt = (VkBaseInStructure *)&encodeH264ProfilesRequest; 603 } 604 else if (videoCodecOperation == VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR) 605 { 606 encodeH265ProfilesRequest.sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_KHR; 607 encodeH265ProfilesRequest.pNext = NULL; 608 encodeH265ProfilesRequest.stdProfileIdc = 609 (videoProfileIdc == 0) ? STD_VIDEO_H265_PROFILE_IDC_INVALID : (StdVideoH265ProfileIdc)videoProfileIdc; 610 pVideoProfileExt = (VkBaseInStructure *)&encodeH265ProfilesRequest; 611 } 612 else 613 { 614 DE_ASSERT(false && "Unknown codec!"); 615 return; 616 } 617 618 PopulateProfileExt(pVideoProfileExt); 619 } 620 GetCodecType() const621 VkVideoCodecOperationFlagBitsKHR GetCodecType() const 622 { 623 return m_profile.videoCodecOperation; 624 } 625 IsEncodeCodecType() const626 bool IsEncodeCodecType() const 627 { 628 return ((m_profile.videoCodecOperation == VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR) || 629 (m_profile.videoCodecOperation == VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR)); 630 } 631 IsDecodeCodecType() const632 bool IsDecodeCodecType() const 633 { 634 return ((m_profile.videoCodecOperation == VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR) || 635 (m_profile.videoCodecOperation == VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR)); 636 } 637 IsH264() const638 bool IsH264() const 639 { 640 return ((m_profile.videoCodecOperation == VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR) || 641 (m_profile.videoCodecOperation == VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR)); 642 } 643 IsH265() const644 bool IsH265() const 645 { 646 return ((m_profile.videoCodecOperation == VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR) || 647 (m_profile.videoCodecOperation == VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR)); 648 } 649 operator bool() const650 operator bool() const 651 { 652 return (m_profile.sType == VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR); 653 } 654 GetProfile() const655 const VkVideoProfileInfoKHR *GetProfile() const 656 { 657 if (m_profile.sType == VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR) 658 { 659 return &m_profile; 660 } 661 else 662 { 663 return NULL; 664 } 665 } 666 GetProfileListInfo() const667 const VkVideoProfileListInfoKHR *GetProfileListInfo() const 668 { 669 if (m_profileList.sType == VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR) 670 { 671 return &m_profileList; 672 } 673 else 674 { 675 return NULL; 676 } 677 } 678 GetDecodeH264Profile() const679 const VkVideoDecodeH264ProfileInfoKHR *GetDecodeH264Profile() const 680 { 681 if (m_h264DecodeProfile.sType == VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR) 682 { 683 return &m_h264DecodeProfile; 684 } 685 else 686 { 687 return NULL; 688 } 689 } 690 GetDecodeH265Profile() const691 const VkVideoDecodeH265ProfileInfoKHR *GetDecodeH265Profile() const 692 { 693 if (m_h265DecodeProfile.sType == VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR) 694 { 695 return &m_h265DecodeProfile; 696 } 697 else 698 { 699 return NULL; 700 } 701 } 702 GetEncodeH264Profile() const703 const VkVideoEncodeH264ProfileInfoKHR *GetEncodeH264Profile() const 704 { 705 if (m_h264EncodeProfile.sType == VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR) 706 { 707 return &m_h264EncodeProfile; 708 } 709 else 710 { 711 return NULL; 712 } 713 } 714 GetEncodeH265Profile() const715 const VkVideoEncodeH265ProfileInfoKHR *GetEncodeH265Profile() const 716 { 717 if (m_h265EncodeProfile.sType == VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_KHR) 718 { 719 return &m_h265EncodeProfile; 720 } 721 else 722 { 723 return NULL; 724 } 725 } 726 copyProfile(const VkVideoCoreProfile & src)727 bool copyProfile(const VkVideoCoreProfile &src) 728 { 729 if (!src) 730 { 731 return false; 732 } 733 734 m_profile = src.m_profile; 735 m_profile.pNext = nullptr; 736 737 m_profileList = src.m_profileList; 738 m_profileList.pNext = nullptr; 739 740 m_profileList.pProfiles = &m_profile; 741 742 PopulateProfileExt((VkBaseInStructure const *)src.m_profile.pNext); 743 744 return true; 745 } 746 VkVideoCoreProfile(const VkVideoCoreProfile & other)747 VkVideoCoreProfile(const VkVideoCoreProfile &other) 748 { 749 copyProfile(other); 750 } 751 operator =(const VkVideoCoreProfile & other)752 VkVideoCoreProfile &operator=(const VkVideoCoreProfile &other) 753 { 754 copyProfile(other); 755 return *this; 756 } 757 operator ==(const VkVideoCoreProfile & other) const758 bool operator==(const VkVideoCoreProfile &other) const 759 { 760 if (m_profile.videoCodecOperation != other.m_profile.videoCodecOperation) 761 { 762 return false; 763 } 764 765 if (m_profile.chromaSubsampling != other.m_profile.chromaSubsampling) 766 { 767 return false; 768 } 769 770 if (m_profile.lumaBitDepth != other.m_profile.lumaBitDepth) 771 { 772 return false; 773 } 774 775 if (m_profile.chromaBitDepth != other.m_profile.chromaBitDepth) 776 { 777 return false; 778 } 779 780 if (m_profile.pNext != nullptr) 781 { 782 switch (m_profile.videoCodecOperation) 783 { 784 case vk::VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR: 785 { 786 auto *ours = (VkVideoDecodeH264ProfileInfoKHR *)m_profile.pNext; 787 auto *theirs = (VkVideoDecodeH264ProfileInfoKHR *)other.m_profile.pNext; 788 if (ours->sType != theirs->sType) 789 return false; 790 if (ours->stdProfileIdc != theirs->stdProfileIdc) 791 return false; 792 if (ours->pictureLayout != theirs->pictureLayout) 793 return false; 794 break; 795 } 796 case VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR: 797 { 798 auto *ours = (VkVideoDecodeH265ProfileInfoKHR *)m_profile.pNext; 799 auto *theirs = (VkVideoDecodeH265ProfileInfoKHR *)other.m_profile.pNext; 800 if (ours->sType != theirs->sType) 801 return false; 802 if (ours->stdProfileIdc != theirs->stdProfileIdc) 803 return false; 804 break; 805 } 806 case VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR: 807 { 808 auto *ours = (VkVideoDecodeAV1ProfileInfoKHR *)m_profile.pNext; 809 auto *theirs = (VkVideoDecodeAV1ProfileInfoKHR *)other.m_profile.pNext; 810 if (ours->sType != theirs->sType) 811 return false; 812 if (ours->stdProfile != theirs->stdProfile) 813 return false; 814 break; 815 } 816 default: 817 tcu::die("Unknown codec"); 818 } 819 } 820 821 return true; 822 } 823 operator !=(const VkVideoCoreProfile & other) const824 bool operator!=(const VkVideoCoreProfile &other) const 825 { 826 return !(*this == other); 827 } 828 GetColorSubsampling() const829 VkVideoChromaSubsamplingFlagsKHR GetColorSubsampling() const 830 { 831 return m_profile.chromaSubsampling; 832 } 833 GetNvColorSubsampling() const834 StdChromaFormatIdc GetNvColorSubsampling() const 835 { 836 if (m_profile.chromaSubsampling & VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR) 837 { 838 return chroma_format_idc_monochrome; 839 } 840 else if (m_profile.chromaSubsampling & VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR) 841 { 842 return chroma_format_idc_420; 843 } 844 else if (m_profile.chromaSubsampling & VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR) 845 { 846 return chroma_format_idc_422; 847 } 848 else if (m_profile.chromaSubsampling & VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR) 849 { 850 return chroma_format_idc_444; 851 } 852 853 return chroma_format_idc_monochrome; 854 } 855 GetLumaBitDepthMinus8() const856 uint32_t GetLumaBitDepthMinus8() const 857 { 858 if (m_profile.lumaBitDepth & VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR) 859 { 860 return 8 - 8; 861 } 862 else if (m_profile.lumaBitDepth & VK_VIDEO_COMPONENT_BIT_DEPTH_10_BIT_KHR) 863 { 864 return 10 - 8; 865 } 866 else if (m_profile.lumaBitDepth & VK_VIDEO_COMPONENT_BIT_DEPTH_12_BIT_KHR) 867 { 868 return 12 - 8; 869 } 870 return 0; 871 } 872 GetChromaBitDepthMinus8() const873 uint32_t GetChromaBitDepthMinus8() const 874 { 875 if (m_profile.chromaBitDepth & VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR) 876 { 877 return 8 - 8; 878 } 879 else if (m_profile.chromaBitDepth & VK_VIDEO_COMPONENT_BIT_DEPTH_10_BIT_KHR) 880 { 881 return 10 - 8; 882 } 883 else if (m_profile.chromaBitDepth & VK_VIDEO_COMPONENT_BIT_DEPTH_12_BIT_KHR) 884 { 885 return 12 - 8; 886 } 887 return 0; 888 } 889 is16BitFormat() const890 bool is16BitFormat() const 891 { 892 return !!GetLumaBitDepthMinus8() || !!GetChromaBitDepthMinus8(); 893 } 894 CodecGetVkFormat(VkVideoChromaSubsamplingFlagBitsKHR chromaFormatIdc,VkVideoComponentBitDepthFlagBitsKHR lumaBitDepth,bool isSemiPlanar)895 static VkFormat CodecGetVkFormat(VkVideoChromaSubsamplingFlagBitsKHR chromaFormatIdc, 896 VkVideoComponentBitDepthFlagBitsKHR lumaBitDepth, bool isSemiPlanar) 897 { 898 VkFormat vkFormat = VK_FORMAT_UNDEFINED; 899 switch (chromaFormatIdc) 900 { 901 case VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR: 902 switch (lumaBitDepth) 903 { 904 case VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR: 905 vkFormat = VK_FORMAT_R8_UNORM; 906 break; 907 case VK_VIDEO_COMPONENT_BIT_DEPTH_10_BIT_KHR: 908 vkFormat = VK_FORMAT_R10X6_UNORM_PACK16; 909 break; 910 case VK_VIDEO_COMPONENT_BIT_DEPTH_12_BIT_KHR: 911 vkFormat = VK_FORMAT_R12X4_UNORM_PACK16; 912 break; 913 default: 914 DE_ASSERT(false); 915 } 916 break; 917 case VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR: 918 switch (lumaBitDepth) 919 { 920 case VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR: 921 vkFormat = isSemiPlanar ? VK_FORMAT_G8_B8R8_2PLANE_420_UNORM : VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM; 922 break; 923 case VK_VIDEO_COMPONENT_BIT_DEPTH_10_BIT_KHR: 924 vkFormat = isSemiPlanar ? VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 : 925 VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16; 926 break; 927 case VK_VIDEO_COMPONENT_BIT_DEPTH_12_BIT_KHR: 928 vkFormat = isSemiPlanar ? VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 : 929 VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16; 930 break; 931 default: 932 DE_ASSERT(false); 933 } 934 break; 935 case VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR: 936 switch (lumaBitDepth) 937 { 938 case VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR: 939 vkFormat = isSemiPlanar ? VK_FORMAT_G8_B8R8_2PLANE_422_UNORM : VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM; 940 break; 941 case VK_VIDEO_COMPONENT_BIT_DEPTH_10_BIT_KHR: 942 vkFormat = isSemiPlanar ? VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 : 943 VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16; 944 break; 945 case VK_VIDEO_COMPONENT_BIT_DEPTH_12_BIT_KHR: 946 vkFormat = isSemiPlanar ? VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 : 947 VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16; 948 break; 949 default: 950 DE_ASSERT(false); 951 } 952 break; 953 case VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR: 954 switch (lumaBitDepth) 955 { 956 case VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR: 957 vkFormat = isSemiPlanar ? VK_FORMAT_G8_B8R8_2PLANE_444_UNORM_EXT : VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM; 958 break; 959 case VK_VIDEO_COMPONENT_BIT_DEPTH_10_BIT_KHR: 960 vkFormat = isSemiPlanar ? VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16_EXT : 961 VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16; 962 break; 963 case VK_VIDEO_COMPONENT_BIT_DEPTH_12_BIT_KHR: 964 vkFormat = isSemiPlanar ? VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16_EXT : 965 VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16; 966 break; 967 default: 968 DE_ASSERT(false); 969 } 970 break; 971 default: 972 DE_ASSERT(false); 973 } 974 975 return vkFormat; 976 } 977 GetVideoChromaFormatFromVkFormat(VkFormat format)978 static StdChromaFormatIdc GetVideoChromaFormatFromVkFormat(VkFormat format) 979 { 980 StdChromaFormatIdc videoChromaFormat = chroma_format_idc_420; 981 switch ((uint32_t)format) 982 { 983 case VK_FORMAT_R8_UNORM: 984 case VK_FORMAT_R10X6_UNORM_PACK16: 985 case VK_FORMAT_R12X4_UNORM_PACK16: 986 videoChromaFormat = chroma_format_idc_monochrome; 987 break; 988 989 case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM: 990 case VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM: 991 case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16: 992 case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16: 993 case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16: 994 case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16: 995 videoChromaFormat = chroma_format_idc_420; 996 break; 997 998 case VK_FORMAT_G8_B8R8_2PLANE_422_UNORM: 999 case VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM: 1000 case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16: 1001 case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16: 1002 case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16: 1003 case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16: 1004 videoChromaFormat = chroma_format_idc_422; 1005 break; 1006 1007 case VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM: 1008 case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16: 1009 case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16: 1010 case VK_FORMAT_G8_B8R8_2PLANE_444_UNORM_EXT: 1011 case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16_EXT: 1012 case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16_EXT: 1013 case VK_FORMAT_G16_B16R16_2PLANE_444_UNORM_EXT: 1014 videoChromaFormat = chroma_format_idc_444; 1015 break; 1016 default: 1017 DE_ASSERT(false); 1018 } 1019 1020 return videoChromaFormat; 1021 } 1022 CodecToName(VkVideoCodecOperationFlagBitsKHR codec)1023 static const char *CodecToName(VkVideoCodecOperationFlagBitsKHR codec) 1024 { 1025 switch ((int32_t)codec) 1026 { 1027 case VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR: 1028 return "decode h.264"; 1029 case VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR: 1030 return "decode h.265"; 1031 case VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR: 1032 return "decode av1"; 1033 case VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR: 1034 return "encode h.264"; 1035 case VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR: 1036 return "encode h.265"; 1037 default:; 1038 } 1039 DE_ASSERT(false && "Unknown codec"); 1040 return "UNKNON"; 1041 } 1042 DumpFormatProfiles(VkVideoProfileInfoKHR * pVideoProfile)1043 static void DumpFormatProfiles(VkVideoProfileInfoKHR *pVideoProfile) 1044 { 1045 // formatProfile info based on supported chroma_format_idc 1046 if (pVideoProfile->chromaSubsampling & VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR) 1047 { 1048 std::cout << "MONO, "; 1049 } 1050 if (pVideoProfile->chromaSubsampling & VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR) 1051 { 1052 std::cout << " 420, "; 1053 } 1054 if (pVideoProfile->chromaSubsampling & VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR) 1055 { 1056 std::cout << " 422, "; 1057 } 1058 if (pVideoProfile->chromaSubsampling & VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR) 1059 { 1060 std::cout << " 444, "; 1061 } 1062 1063 // Profile info based on max bit_depth_luma_minus8 1064 if (pVideoProfile->lumaBitDepth & VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR) 1065 { 1066 std::cout << "LUMA: 8-bit, "; 1067 } 1068 if (pVideoProfile->lumaBitDepth & VK_VIDEO_COMPONENT_BIT_DEPTH_10_BIT_KHR) 1069 { 1070 std::cout << "LUMA: 10-bit, "; 1071 } 1072 if (pVideoProfile->lumaBitDepth & VK_VIDEO_COMPONENT_BIT_DEPTH_12_BIT_KHR) 1073 { 1074 std::cout << "LUMA: 12-bit, "; 1075 } 1076 1077 // Profile info based on max bit_depth_chroma_minus8 1078 if (pVideoProfile->chromaBitDepth & VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR) 1079 { 1080 std::cout << "CHROMA: 8-bit, "; 1081 } 1082 if (pVideoProfile->chromaBitDepth & VK_VIDEO_COMPONENT_BIT_DEPTH_10_BIT_KHR) 1083 { 1084 std::cout << "CHROMA:10-bit, "; 1085 } 1086 if (pVideoProfile->chromaBitDepth & VK_VIDEO_COMPONENT_BIT_DEPTH_12_BIT_KHR) 1087 { 1088 std::cout << "CHROMA:12-bit,"; 1089 } 1090 } 1091 DumpH264Profiles(VkVideoDecodeH264ProfileInfoKHR * pH264Profiles)1092 static void DumpH264Profiles(VkVideoDecodeH264ProfileInfoKHR *pH264Profiles) 1093 { 1094 switch (pH264Profiles->stdProfileIdc) 1095 { 1096 case STD_VIDEO_H264_PROFILE_IDC_BASELINE: 1097 std::cout << "BASELINE, "; 1098 break; 1099 case STD_VIDEO_H264_PROFILE_IDC_MAIN: 1100 std::cout << "MAIN, "; 1101 break; 1102 case STD_VIDEO_H264_PROFILE_IDC_HIGH: 1103 std::cout << "HIGH, "; 1104 break; 1105 case STD_VIDEO_H264_PROFILE_IDC_HIGH_444_PREDICTIVE: 1106 std::cout << "HIGH_444_PREDICTIVE, "; 1107 break; 1108 default: 1109 std::cout << "UNKNOWN PROFILE, "; 1110 break; 1111 } 1112 } 1113 DumpH265Profiles(VkVideoDecodeH265ProfileInfoKHR * pH265Profiles)1114 static void DumpH265Profiles(VkVideoDecodeH265ProfileInfoKHR *pH265Profiles) 1115 { 1116 switch (pH265Profiles->stdProfileIdc) 1117 { 1118 case STD_VIDEO_H265_PROFILE_IDC_MAIN: 1119 std::cout << "MAIN, "; 1120 break; 1121 case STD_VIDEO_H265_PROFILE_IDC_MAIN_10: 1122 std::cout << "MAIN_10, "; 1123 break; 1124 case STD_VIDEO_H265_PROFILE_IDC_MAIN_STILL_PICTURE: 1125 std::cout << "MAIN_STILL_PICTURE, "; 1126 break; 1127 case STD_VIDEO_H265_PROFILE_IDC_FORMAT_RANGE_EXTENSIONS: 1128 std::cout << "FORMAT_RANGE_EXTENSIONS, "; 1129 break; 1130 case STD_VIDEO_H265_PROFILE_IDC_SCC_EXTENSIONS: 1131 std::cout << "SCC_EXTENSIONS, "; 1132 break; 1133 default: 1134 std::cout << "UNKNOWN PROFILE, "; 1135 break; 1136 } 1137 } 1138 1139 private: 1140 VkVideoProfileInfoKHR m_profile; 1141 VkVideoProfileListInfoKHR m_profileList; 1142 union 1143 { 1144 VkVideoDecodeH264ProfileInfoKHR m_h264DecodeProfile; 1145 VkVideoDecodeH265ProfileInfoKHR m_h265DecodeProfile; 1146 VkVideoDecodeAV1ProfileInfoKHR m_av1DecodeProfile; 1147 VkVideoEncodeH264ProfileInfoKHR m_h264EncodeProfile; 1148 VkVideoEncodeH265ProfileInfoKHR m_h265EncodeProfile; 1149 }; 1150 }; 1151 1152 namespace util 1153 { 1154 const char *getVideoCodecString(VkVideoCodecOperationFlagBitsKHR codec); 1155 1156 const char *getVideoChromaFormatString(VkVideoChromaSubsamplingFlagBitsKHR chromaFormat); 1157 1158 VkVideoCodecOperationFlagsKHR getSupportedCodecs( 1159 DeviceContext &devCtx, uint32_t selectedVideoQueueFamily, 1160 VkQueueFlags queueFlagsRequired = (VK_QUEUE_VIDEO_DECODE_BIT_KHR | VK_QUEUE_VIDEO_ENCODE_BIT_KHR), 1161 VkVideoCodecOperationFlagsKHR videoCodeOperations = (VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR | 1162 VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR | 1163 VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR | 1164 VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR)); 1165 1166 VkResult getVideoFormats(DeviceContext &devCtx, const VkVideoCoreProfile &videoProfile, VkImageUsageFlags imageUsage, 1167 uint32_t &formatCount, VkFormat *formats, bool dumpData = false); 1168 1169 VkResult getSupportedVideoFormats(DeviceContext &devCtx, const VkVideoCoreProfile &videoProfile, 1170 VkVideoDecodeCapabilityFlagsKHR capabilityFlags, VkFormat &pictureFormat, 1171 VkFormat &referencePicturesFormat); 1172 1173 const char *codecToName(VkVideoCodecOperationFlagBitsKHR codec); 1174 1175 VkResult getVideoCapabilities(DeviceContext &devCtx, const VkVideoCoreProfile &videoProfile, 1176 VkVideoCapabilitiesKHR *pVideoCapabilities); 1177 1178 VkResult getVideoDecodeCapabilities(DeviceContext &devCtx, const VkVideoCoreProfile &videoProfile, 1179 VkVideoCapabilitiesKHR &videoCapabilities, 1180 VkVideoDecodeCapabilitiesKHR &videoDecodeCapabilities); 1181 double PSNR(const std::vector<uint8_t> &img1, const std::vector<uint8_t> &img2); 1182 1183 } // namespace util 1184 1185 } // namespace video 1186 } // namespace vkt 1187 1188 #endif // _VKTVIDEOTESTUTILS_HPP 1189