1 #ifndef VULKAN_BETA_H_ 2 #define VULKAN_BETA_H_ 1 3 4 /* 5 ** Copyright 2015-2022 The Khronos Group Inc. 6 ** 7 ** SPDX-License-Identifier: Apache-2.0 8 */ 9 10 /* 11 ** This header is generated from the Khronos Vulkan XML API Registry. 12 ** 13 */ 14 15 16 #ifdef __cplusplus 17 extern "C" { 18 #endif 19 20 21 22 #define VK_KHR_video_queue 1 23 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkVideoSessionKHR) 24 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkVideoSessionParametersKHR) 25 #define VK_KHR_VIDEO_QUEUE_SPEC_VERSION 7 26 #define VK_KHR_VIDEO_QUEUE_EXTENSION_NAME "VK_KHR_video_queue" 27 28 typedef enum VkQueryResultStatusKHR { 29 VK_QUERY_RESULT_STATUS_ERROR_KHR = -1, 30 VK_QUERY_RESULT_STATUS_NOT_READY_KHR = 0, 31 VK_QUERY_RESULT_STATUS_COMPLETE_KHR = 1, 32 VK_QUERY_RESULT_STATUS_MAX_ENUM_KHR = 0x7FFFFFFF 33 } VkQueryResultStatusKHR; 34 35 typedef enum VkVideoCodecOperationFlagBitsKHR { 36 VK_VIDEO_CODEC_OPERATION_NONE_KHR = 0, 37 #ifdef VK_ENABLE_BETA_EXTENSIONS 38 VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_EXT = 0x00010000, 39 #endif 40 #ifdef VK_ENABLE_BETA_EXTENSIONS 41 VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_EXT = 0x00020000, 42 #endif 43 #ifdef VK_ENABLE_BETA_EXTENSIONS 44 VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_EXT = 0x00000001, 45 #endif 46 #ifdef VK_ENABLE_BETA_EXTENSIONS 47 VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_EXT = 0x00000002, 48 #endif 49 VK_VIDEO_CODEC_OPERATION_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF 50 } VkVideoCodecOperationFlagBitsKHR; 51 typedef VkFlags VkVideoCodecOperationFlagsKHR; 52 53 typedef enum VkVideoChromaSubsamplingFlagBitsKHR { 54 VK_VIDEO_CHROMA_SUBSAMPLING_INVALID_KHR = 0, 55 VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR = 0x00000001, 56 VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR = 0x00000002, 57 VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR = 0x00000004, 58 VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR = 0x00000008, 59 VK_VIDEO_CHROMA_SUBSAMPLING_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF 60 } VkVideoChromaSubsamplingFlagBitsKHR; 61 typedef VkFlags VkVideoChromaSubsamplingFlagsKHR; 62 63 typedef enum VkVideoComponentBitDepthFlagBitsKHR { 64 VK_VIDEO_COMPONENT_BIT_DEPTH_INVALID_KHR = 0, 65 VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR = 0x00000001, 66 VK_VIDEO_COMPONENT_BIT_DEPTH_10_BIT_KHR = 0x00000004, 67 VK_VIDEO_COMPONENT_BIT_DEPTH_12_BIT_KHR = 0x00000010, 68 VK_VIDEO_COMPONENT_BIT_DEPTH_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF 69 } VkVideoComponentBitDepthFlagBitsKHR; 70 typedef VkFlags VkVideoComponentBitDepthFlagsKHR; 71 72 typedef enum VkVideoCapabilityFlagBitsKHR { 73 VK_VIDEO_CAPABILITY_PROTECTED_CONTENT_BIT_KHR = 0x00000001, 74 VK_VIDEO_CAPABILITY_SEPARATE_REFERENCE_IMAGES_BIT_KHR = 0x00000002, 75 VK_VIDEO_CAPABILITY_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF 76 } VkVideoCapabilityFlagBitsKHR; 77 typedef VkFlags VkVideoCapabilityFlagsKHR; 78 79 typedef enum VkVideoSessionCreateFlagBitsKHR { 80 VK_VIDEO_SESSION_CREATE_PROTECTED_CONTENT_BIT_KHR = 0x00000001, 81 VK_VIDEO_SESSION_CREATE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF 82 } VkVideoSessionCreateFlagBitsKHR; 83 typedef VkFlags VkVideoSessionCreateFlagsKHR; 84 typedef VkFlags VkVideoSessionParametersCreateFlagsKHR; 85 typedef VkFlags VkVideoBeginCodingFlagsKHR; 86 typedef VkFlags VkVideoEndCodingFlagsKHR; 87 88 typedef enum VkVideoCodingControlFlagBitsKHR { 89 VK_VIDEO_CODING_CONTROL_RESET_BIT_KHR = 0x00000001, 90 #ifdef VK_ENABLE_BETA_EXTENSIONS 91 VK_VIDEO_CODING_CONTROL_ENCODE_RATE_CONTROL_BIT_KHR = 0x00000002, 92 #endif 93 #ifdef VK_ENABLE_BETA_EXTENSIONS 94 VK_VIDEO_CODING_CONTROL_ENCODE_RATE_CONTROL_LAYER_BIT_KHR = 0x00000004, 95 #endif 96 VK_VIDEO_CODING_CONTROL_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF 97 } VkVideoCodingControlFlagBitsKHR; 98 typedef VkFlags VkVideoCodingControlFlagsKHR; 99 typedef struct VkQueueFamilyQueryResultStatusPropertiesKHR { 100 VkStructureType sType; 101 void* pNext; 102 VkBool32 queryResultStatusSupport; 103 } VkQueueFamilyQueryResultStatusPropertiesKHR; 104 105 typedef struct VkQueueFamilyVideoPropertiesKHR { 106 VkStructureType sType; 107 void* pNext; 108 VkVideoCodecOperationFlagsKHR videoCodecOperations; 109 } VkQueueFamilyVideoPropertiesKHR; 110 111 typedef struct VkVideoProfileInfoKHR { 112 VkStructureType sType; 113 const void* pNext; 114 VkVideoCodecOperationFlagBitsKHR videoCodecOperation; 115 VkVideoChromaSubsamplingFlagsKHR chromaSubsampling; 116 VkVideoComponentBitDepthFlagsKHR lumaBitDepth; 117 VkVideoComponentBitDepthFlagsKHR chromaBitDepth; 118 } VkVideoProfileInfoKHR; 119 120 typedef struct VkVideoProfileListInfoKHR { 121 VkStructureType sType; 122 const void* pNext; 123 uint32_t profileCount; 124 const VkVideoProfileInfoKHR* pProfiles; 125 } VkVideoProfileListInfoKHR; 126 127 typedef struct VkVideoCapabilitiesKHR { 128 VkStructureType sType; 129 void* pNext; 130 VkVideoCapabilityFlagsKHR flags; 131 VkDeviceSize minBitstreamBufferOffsetAlignment; 132 VkDeviceSize minBitstreamBufferSizeAlignment; 133 VkExtent2D pictureAccessGranularity; 134 VkExtent2D minCodedExtent; 135 VkExtent2D maxCodedExtent; 136 uint32_t maxDpbSlots; 137 uint32_t maxActiveReferencePictures; 138 VkExtensionProperties stdHeaderVersion; 139 } VkVideoCapabilitiesKHR; 140 141 typedef struct VkPhysicalDeviceVideoFormatInfoKHR { 142 VkStructureType sType; 143 const void* pNext; 144 VkImageUsageFlags imageUsage; 145 } VkPhysicalDeviceVideoFormatInfoKHR; 146 147 typedef struct VkVideoFormatPropertiesKHR { 148 VkStructureType sType; 149 void* pNext; 150 VkFormat format; 151 VkComponentMapping componentMapping; 152 VkImageCreateFlags imageCreateFlags; 153 VkImageType imageType; 154 VkImageTiling imageTiling; 155 VkImageUsageFlags imageUsageFlags; 156 } VkVideoFormatPropertiesKHR; 157 158 typedef struct VkVideoPictureResourceInfoKHR { 159 VkStructureType sType; 160 const void* pNext; 161 VkOffset2D codedOffset; 162 VkExtent2D codedExtent; 163 uint32_t baseArrayLayer; 164 VkImageView imageViewBinding; 165 } VkVideoPictureResourceInfoKHR; 166 167 typedef struct VkVideoReferenceSlotInfoKHR { 168 VkStructureType sType; 169 const void* pNext; 170 int32_t slotIndex; 171 const VkVideoPictureResourceInfoKHR* pPictureResource; 172 } VkVideoReferenceSlotInfoKHR; 173 174 typedef struct VkVideoSessionMemoryRequirementsKHR { 175 VkStructureType sType; 176 void* pNext; 177 uint32_t memoryBindIndex; 178 VkMemoryRequirements memoryRequirements; 179 } VkVideoSessionMemoryRequirementsKHR; 180 181 typedef struct VkBindVideoSessionMemoryInfoKHR { 182 VkStructureType sType; 183 const void* pNext; 184 uint32_t memoryBindIndex; 185 VkDeviceMemory memory; 186 VkDeviceSize memoryOffset; 187 VkDeviceSize memorySize; 188 } VkBindVideoSessionMemoryInfoKHR; 189 190 typedef struct VkVideoSessionCreateInfoKHR { 191 VkStructureType sType; 192 const void* pNext; 193 uint32_t queueFamilyIndex; 194 VkVideoSessionCreateFlagsKHR flags; 195 const VkVideoProfileInfoKHR* pVideoProfile; 196 VkFormat pictureFormat; 197 VkExtent2D maxCodedExtent; 198 VkFormat referencePictureFormat; 199 uint32_t maxDpbSlots; 200 uint32_t maxActiveReferencePictures; 201 const VkExtensionProperties* pStdHeaderVersion; 202 } VkVideoSessionCreateInfoKHR; 203 204 typedef struct VkVideoSessionParametersCreateInfoKHR { 205 VkStructureType sType; 206 const void* pNext; 207 VkVideoSessionParametersCreateFlagsKHR flags; 208 VkVideoSessionParametersKHR videoSessionParametersTemplate; 209 VkVideoSessionKHR videoSession; 210 } VkVideoSessionParametersCreateInfoKHR; 211 212 typedef struct VkVideoSessionParametersUpdateInfoKHR { 213 VkStructureType sType; 214 const void* pNext; 215 uint32_t updateSequenceCount; 216 } VkVideoSessionParametersUpdateInfoKHR; 217 218 typedef struct VkVideoBeginCodingInfoKHR { 219 VkStructureType sType; 220 const void* pNext; 221 VkVideoBeginCodingFlagsKHR flags; 222 VkVideoSessionKHR videoSession; 223 VkVideoSessionParametersKHR videoSessionParameters; 224 uint32_t referenceSlotCount; 225 const VkVideoReferenceSlotInfoKHR* pReferenceSlots; 226 } VkVideoBeginCodingInfoKHR; 227 228 typedef struct VkVideoEndCodingInfoKHR { 229 VkStructureType sType; 230 const void* pNext; 231 VkVideoEndCodingFlagsKHR flags; 232 } VkVideoEndCodingInfoKHR; 233 234 typedef struct VkVideoCodingControlInfoKHR { 235 VkStructureType sType; 236 const void* pNext; 237 VkVideoCodingControlFlagsKHR flags; 238 } VkVideoCodingControlInfoKHR; 239 240 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR)(VkPhysicalDevice physicalDevice, const VkVideoProfileInfoKHR* pVideoProfile, VkVideoCapabilitiesKHR* pCapabilities); 241 typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoFormatInfoKHR* pVideoFormatInfo, uint32_t* pVideoFormatPropertyCount, VkVideoFormatPropertiesKHR* pVideoFormatProperties); 242 typedef VkResult (VKAPI_PTR *PFN_vkCreateVideoSessionKHR)(VkDevice device, const VkVideoSessionCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkVideoSessionKHR* pVideoSession); 243 typedef void (VKAPI_PTR *PFN_vkDestroyVideoSessionKHR)(VkDevice device, VkVideoSessionKHR videoSession, const VkAllocationCallbacks* pAllocator); 244 typedef VkResult (VKAPI_PTR *PFN_vkGetVideoSessionMemoryRequirementsKHR)(VkDevice device, VkVideoSessionKHR videoSession, uint32_t* pMemoryRequirementsCount, VkVideoSessionMemoryRequirementsKHR* pMemoryRequirements); 245 typedef VkResult (VKAPI_PTR *PFN_vkBindVideoSessionMemoryKHR)(VkDevice device, VkVideoSessionKHR videoSession, uint32_t bindSessionMemoryInfoCount, const VkBindVideoSessionMemoryInfoKHR* pBindSessionMemoryInfos); 246 typedef VkResult (VKAPI_PTR *PFN_vkCreateVideoSessionParametersKHR)(VkDevice device, const VkVideoSessionParametersCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkVideoSessionParametersKHR* pVideoSessionParameters); 247 typedef VkResult (VKAPI_PTR *PFN_vkUpdateVideoSessionParametersKHR)(VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo); 248 typedef void (VKAPI_PTR *PFN_vkDestroyVideoSessionParametersKHR)(VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkAllocationCallbacks* pAllocator); 249 typedef void (VKAPI_PTR *PFN_vkCmdBeginVideoCodingKHR)(VkCommandBuffer commandBuffer, const VkVideoBeginCodingInfoKHR* pBeginInfo); 250 typedef void (VKAPI_PTR *PFN_vkCmdEndVideoCodingKHR)(VkCommandBuffer commandBuffer, const VkVideoEndCodingInfoKHR* pEndCodingInfo); 251 typedef void (VKAPI_PTR *PFN_vkCmdControlVideoCodingKHR)(VkCommandBuffer commandBuffer, const VkVideoCodingControlInfoKHR* pCodingControlInfo); 252 253 #ifndef VK_NO_PROTOTYPES 254 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceVideoCapabilitiesKHR( 255 VkPhysicalDevice physicalDevice, 256 const VkVideoProfileInfoKHR* pVideoProfile, 257 VkVideoCapabilitiesKHR* pCapabilities); 258 259 VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceVideoFormatPropertiesKHR( 260 VkPhysicalDevice physicalDevice, 261 const VkPhysicalDeviceVideoFormatInfoKHR* pVideoFormatInfo, 262 uint32_t* pVideoFormatPropertyCount, 263 VkVideoFormatPropertiesKHR* pVideoFormatProperties); 264 265 VKAPI_ATTR VkResult VKAPI_CALL vkCreateVideoSessionKHR( 266 VkDevice device, 267 const VkVideoSessionCreateInfoKHR* pCreateInfo, 268 const VkAllocationCallbacks* pAllocator, 269 VkVideoSessionKHR* pVideoSession); 270 271 VKAPI_ATTR void VKAPI_CALL vkDestroyVideoSessionKHR( 272 VkDevice device, 273 VkVideoSessionKHR videoSession, 274 const VkAllocationCallbacks* pAllocator); 275 276 VKAPI_ATTR VkResult VKAPI_CALL vkGetVideoSessionMemoryRequirementsKHR( 277 VkDevice device, 278 VkVideoSessionKHR videoSession, 279 uint32_t* pMemoryRequirementsCount, 280 VkVideoSessionMemoryRequirementsKHR* pMemoryRequirements); 281 282 VKAPI_ATTR VkResult VKAPI_CALL vkBindVideoSessionMemoryKHR( 283 VkDevice device, 284 VkVideoSessionKHR videoSession, 285 uint32_t bindSessionMemoryInfoCount, 286 const VkBindVideoSessionMemoryInfoKHR* pBindSessionMemoryInfos); 287 288 VKAPI_ATTR VkResult VKAPI_CALL vkCreateVideoSessionParametersKHR( 289 VkDevice device, 290 const VkVideoSessionParametersCreateInfoKHR* pCreateInfo, 291 const VkAllocationCallbacks* pAllocator, 292 VkVideoSessionParametersKHR* pVideoSessionParameters); 293 294 VKAPI_ATTR VkResult VKAPI_CALL vkUpdateVideoSessionParametersKHR( 295 VkDevice device, 296 VkVideoSessionParametersKHR videoSessionParameters, 297 const VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo); 298 299 VKAPI_ATTR void VKAPI_CALL vkDestroyVideoSessionParametersKHR( 300 VkDevice device, 301 VkVideoSessionParametersKHR videoSessionParameters, 302 const VkAllocationCallbacks* pAllocator); 303 304 VKAPI_ATTR void VKAPI_CALL vkCmdBeginVideoCodingKHR( 305 VkCommandBuffer commandBuffer, 306 const VkVideoBeginCodingInfoKHR* pBeginInfo); 307 308 VKAPI_ATTR void VKAPI_CALL vkCmdEndVideoCodingKHR( 309 VkCommandBuffer commandBuffer, 310 const VkVideoEndCodingInfoKHR* pEndCodingInfo); 311 312 VKAPI_ATTR void VKAPI_CALL vkCmdControlVideoCodingKHR( 313 VkCommandBuffer commandBuffer, 314 const VkVideoCodingControlInfoKHR* pCodingControlInfo); 315 #endif 316 317 318 #define VK_KHR_video_decode_queue 1 319 #define VK_KHR_VIDEO_DECODE_QUEUE_SPEC_VERSION 6 320 #define VK_KHR_VIDEO_DECODE_QUEUE_EXTENSION_NAME "VK_KHR_video_decode_queue" 321 322 typedef enum VkVideoDecodeCapabilityFlagBitsKHR { 323 VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHR = 0x00000001, 324 VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_DISTINCT_BIT_KHR = 0x00000002, 325 VK_VIDEO_DECODE_CAPABILITY_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF 326 } VkVideoDecodeCapabilityFlagBitsKHR; 327 typedef VkFlags VkVideoDecodeCapabilityFlagsKHR; 328 329 typedef enum VkVideoDecodeUsageFlagBitsKHR { 330 VK_VIDEO_DECODE_USAGE_DEFAULT_KHR = 0, 331 VK_VIDEO_DECODE_USAGE_TRANSCODING_BIT_KHR = 0x00000001, 332 VK_VIDEO_DECODE_USAGE_OFFLINE_BIT_KHR = 0x00000002, 333 VK_VIDEO_DECODE_USAGE_STREAMING_BIT_KHR = 0x00000004, 334 VK_VIDEO_DECODE_USAGE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF 335 } VkVideoDecodeUsageFlagBitsKHR; 336 typedef VkFlags VkVideoDecodeUsageFlagsKHR; 337 typedef VkFlags VkVideoDecodeFlagsKHR; 338 typedef struct VkVideoDecodeCapabilitiesKHR { 339 VkStructureType sType; 340 void* pNext; 341 VkVideoDecodeCapabilityFlagsKHR flags; 342 } VkVideoDecodeCapabilitiesKHR; 343 344 typedef struct VkVideoDecodeUsageInfoKHR { 345 VkStructureType sType; 346 const void* pNext; 347 VkVideoDecodeUsageFlagsKHR videoUsageHints; 348 } VkVideoDecodeUsageInfoKHR; 349 350 typedef struct VkVideoDecodeInfoKHR { 351 VkStructureType sType; 352 const void* pNext; 353 VkVideoDecodeFlagsKHR flags; 354 VkBuffer srcBuffer; 355 VkDeviceSize srcBufferOffset; 356 VkDeviceSize srcBufferRange; 357 VkVideoPictureResourceInfoKHR dstPictureResource; 358 const VkVideoReferenceSlotInfoKHR* pSetupReferenceSlot; 359 uint32_t referenceSlotCount; 360 const VkVideoReferenceSlotInfoKHR* pReferenceSlots; 361 } VkVideoDecodeInfoKHR; 362 363 typedef void (VKAPI_PTR *PFN_vkCmdDecodeVideoKHR)(VkCommandBuffer commandBuffer, const VkVideoDecodeInfoKHR* pDecodeInfo); 364 365 #ifndef VK_NO_PROTOTYPES 366 VKAPI_ATTR void VKAPI_CALL vkCmdDecodeVideoKHR( 367 VkCommandBuffer commandBuffer, 368 const VkVideoDecodeInfoKHR* pDecodeInfo); 369 #endif 370 371 372 #define VK_KHR_portability_subset 1 373 #define VK_KHR_PORTABILITY_SUBSET_SPEC_VERSION 1 374 #define VK_KHR_PORTABILITY_SUBSET_EXTENSION_NAME "VK_KHR_portability_subset" 375 typedef struct VkPhysicalDevicePortabilitySubsetFeaturesKHR { 376 VkStructureType sType; 377 void* pNext; 378 VkBool32 constantAlphaColorBlendFactors; 379 VkBool32 events; 380 VkBool32 imageViewFormatReinterpretation; 381 VkBool32 imageViewFormatSwizzle; 382 VkBool32 imageView2DOn3DImage; 383 VkBool32 multisampleArrayImage; 384 VkBool32 mutableComparisonSamplers; 385 VkBool32 pointPolygons; 386 VkBool32 samplerMipLodBias; 387 VkBool32 separateStencilMaskRef; 388 VkBool32 shaderSampleRateInterpolationFunctions; 389 VkBool32 tessellationIsolines; 390 VkBool32 tessellationPointMode; 391 VkBool32 triangleFans; 392 VkBool32 vertexAttributeAccessBeyondStride; 393 } VkPhysicalDevicePortabilitySubsetFeaturesKHR; 394 395 typedef struct VkPhysicalDevicePortabilitySubsetPropertiesKHR { 396 VkStructureType sType; 397 void* pNext; 398 uint32_t minVertexInputBindingStrideAlignment; 399 } VkPhysicalDevicePortabilitySubsetPropertiesKHR; 400 401 402 403 #define VK_KHR_video_encode_queue 1 404 #define VK_KHR_VIDEO_ENCODE_QUEUE_SPEC_VERSION 7 405 #define VK_KHR_VIDEO_ENCODE_QUEUE_EXTENSION_NAME "VK_KHR_video_encode_queue" 406 407 typedef enum VkVideoEncodeTuningModeKHR { 408 VK_VIDEO_ENCODE_TUNING_MODE_DEFAULT_KHR = 0, 409 VK_VIDEO_ENCODE_TUNING_MODE_HIGH_QUALITY_KHR = 1, 410 VK_VIDEO_ENCODE_TUNING_MODE_LOW_LATENCY_KHR = 2, 411 VK_VIDEO_ENCODE_TUNING_MODE_ULTRA_LOW_LATENCY_KHR = 3, 412 VK_VIDEO_ENCODE_TUNING_MODE_LOSSLESS_KHR = 4, 413 VK_VIDEO_ENCODE_TUNING_MODE_MAX_ENUM_KHR = 0x7FFFFFFF 414 } VkVideoEncodeTuningModeKHR; 415 typedef VkFlags VkVideoEncodeFlagsKHR; 416 417 typedef enum VkVideoEncodeCapabilityFlagBitsKHR { 418 VK_VIDEO_ENCODE_CAPABILITY_PRECEDING_EXTERNALLY_ENCODED_BYTES_BIT_KHR = 0x00000001, 419 VK_VIDEO_ENCODE_CAPABILITY_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF 420 } VkVideoEncodeCapabilityFlagBitsKHR; 421 typedef VkFlags VkVideoEncodeCapabilityFlagsKHR; 422 423 typedef enum VkVideoEncodeRateControlModeFlagBitsKHR { 424 VK_VIDEO_ENCODE_RATE_CONTROL_MODE_NONE_BIT_KHR = 0, 425 VK_VIDEO_ENCODE_RATE_CONTROL_MODE_CBR_BIT_KHR = 1, 426 VK_VIDEO_ENCODE_RATE_CONTROL_MODE_VBR_BIT_KHR = 2, 427 VK_VIDEO_ENCODE_RATE_CONTROL_MODE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF 428 } VkVideoEncodeRateControlModeFlagBitsKHR; 429 typedef VkFlags VkVideoEncodeRateControlModeFlagsKHR; 430 431 typedef enum VkVideoEncodeUsageFlagBitsKHR { 432 VK_VIDEO_ENCODE_USAGE_DEFAULT_KHR = 0, 433 VK_VIDEO_ENCODE_USAGE_TRANSCODING_BIT_KHR = 0x00000001, 434 VK_VIDEO_ENCODE_USAGE_STREAMING_BIT_KHR = 0x00000002, 435 VK_VIDEO_ENCODE_USAGE_RECORDING_BIT_KHR = 0x00000004, 436 VK_VIDEO_ENCODE_USAGE_CONFERENCING_BIT_KHR = 0x00000008, 437 VK_VIDEO_ENCODE_USAGE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF 438 } VkVideoEncodeUsageFlagBitsKHR; 439 typedef VkFlags VkVideoEncodeUsageFlagsKHR; 440 441 typedef enum VkVideoEncodeContentFlagBitsKHR { 442 VK_VIDEO_ENCODE_CONTENT_DEFAULT_KHR = 0, 443 VK_VIDEO_ENCODE_CONTENT_CAMERA_BIT_KHR = 0x00000001, 444 VK_VIDEO_ENCODE_CONTENT_DESKTOP_BIT_KHR = 0x00000002, 445 VK_VIDEO_ENCODE_CONTENT_RENDERED_BIT_KHR = 0x00000004, 446 VK_VIDEO_ENCODE_CONTENT_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF 447 } VkVideoEncodeContentFlagBitsKHR; 448 typedef VkFlags VkVideoEncodeContentFlagsKHR; 449 typedef VkFlags VkVideoEncodeRateControlFlagsKHR; 450 typedef struct VkVideoEncodeInfoKHR { 451 VkStructureType sType; 452 const void* pNext; 453 VkVideoEncodeFlagsKHR flags; 454 uint32_t qualityLevel; 455 VkBuffer dstBitstreamBuffer; 456 VkDeviceSize dstBitstreamBufferOffset; 457 VkDeviceSize dstBitstreamBufferMaxRange; 458 VkVideoPictureResourceInfoKHR srcPictureResource; 459 const VkVideoReferenceSlotInfoKHR* pSetupReferenceSlot; 460 uint32_t referenceSlotCount; 461 const VkVideoReferenceSlotInfoKHR* pReferenceSlots; 462 uint32_t precedingExternallyEncodedBytes; 463 } VkVideoEncodeInfoKHR; 464 465 typedef struct VkVideoEncodeCapabilitiesKHR { 466 VkStructureType sType; 467 void* pNext; 468 VkVideoEncodeCapabilityFlagsKHR flags; 469 VkVideoEncodeRateControlModeFlagsKHR rateControlModes; 470 uint8_t rateControlLayerCount; 471 uint8_t qualityLevelCount; 472 VkExtent2D inputImageDataFillAlignment; 473 } VkVideoEncodeCapabilitiesKHR; 474 475 typedef struct VkVideoEncodeUsageInfoKHR { 476 VkStructureType sType; 477 const void* pNext; 478 VkVideoEncodeUsageFlagsKHR videoUsageHints; 479 VkVideoEncodeContentFlagsKHR videoContentHints; 480 VkVideoEncodeTuningModeKHR tuningMode; 481 } VkVideoEncodeUsageInfoKHR; 482 483 typedef struct VkVideoEncodeRateControlLayerInfoKHR { 484 VkStructureType sType; 485 const void* pNext; 486 uint32_t averageBitrate; 487 uint32_t maxBitrate; 488 uint32_t frameRateNumerator; 489 uint32_t frameRateDenominator; 490 uint32_t virtualBufferSizeInMs; 491 uint32_t initialVirtualBufferSizeInMs; 492 } VkVideoEncodeRateControlLayerInfoKHR; 493 494 typedef struct VkVideoEncodeRateControlInfoKHR { 495 VkStructureType sType; 496 const void* pNext; 497 VkVideoEncodeRateControlFlagsKHR flags; 498 VkVideoEncodeRateControlModeFlagBitsKHR rateControlMode; 499 uint8_t layerCount; 500 const VkVideoEncodeRateControlLayerInfoKHR* pLayerConfigs; 501 } VkVideoEncodeRateControlInfoKHR; 502 503 typedef void (VKAPI_PTR *PFN_vkCmdEncodeVideoKHR)(VkCommandBuffer commandBuffer, const VkVideoEncodeInfoKHR* pEncodeInfo); 504 505 #ifndef VK_NO_PROTOTYPES 506 VKAPI_ATTR void VKAPI_CALL vkCmdEncodeVideoKHR( 507 VkCommandBuffer commandBuffer, 508 const VkVideoEncodeInfoKHR* pEncodeInfo); 509 #endif 510 511 512 #define VK_EXT_video_encode_h264 1 513 #include "vk_video/vulkan_video_codec_h264std.h" 514 #include "vk_video/vulkan_video_codec_h264std_encode.h" 515 #define VK_EXT_VIDEO_ENCODE_H264_SPEC_VERSION 9 516 #define VK_EXT_VIDEO_ENCODE_H264_EXTENSION_NAME "VK_EXT_video_encode_h264" 517 518 typedef enum VkVideoEncodeH264RateControlStructureEXT { 519 VK_VIDEO_ENCODE_H264_RATE_CONTROL_STRUCTURE_UNKNOWN_EXT = 0, 520 VK_VIDEO_ENCODE_H264_RATE_CONTROL_STRUCTURE_FLAT_EXT = 1, 521 VK_VIDEO_ENCODE_H264_RATE_CONTROL_STRUCTURE_DYADIC_EXT = 2, 522 VK_VIDEO_ENCODE_H264_RATE_CONTROL_STRUCTURE_MAX_ENUM_EXT = 0x7FFFFFFF 523 } VkVideoEncodeH264RateControlStructureEXT; 524 525 typedef enum VkVideoEncodeH264CapabilityFlagBitsEXT { 526 VK_VIDEO_ENCODE_H264_CAPABILITY_DIRECT_8X8_INFERENCE_ENABLED_BIT_EXT = 0x00000001, 527 VK_VIDEO_ENCODE_H264_CAPABILITY_DIRECT_8X8_INFERENCE_DISABLED_BIT_EXT = 0x00000002, 528 VK_VIDEO_ENCODE_H264_CAPABILITY_SEPARATE_COLOUR_PLANE_BIT_EXT = 0x00000004, 529 VK_VIDEO_ENCODE_H264_CAPABILITY_QPPRIME_Y_ZERO_TRANSFORM_BYPASS_BIT_EXT = 0x00000008, 530 VK_VIDEO_ENCODE_H264_CAPABILITY_SCALING_LISTS_BIT_EXT = 0x00000010, 531 VK_VIDEO_ENCODE_H264_CAPABILITY_HRD_COMPLIANCE_BIT_EXT = 0x00000020, 532 VK_VIDEO_ENCODE_H264_CAPABILITY_CHROMA_QP_OFFSET_BIT_EXT = 0x00000040, 533 VK_VIDEO_ENCODE_H264_CAPABILITY_SECOND_CHROMA_QP_OFFSET_BIT_EXT = 0x00000080, 534 VK_VIDEO_ENCODE_H264_CAPABILITY_PIC_INIT_QP_MINUS26_BIT_EXT = 0x00000100, 535 VK_VIDEO_ENCODE_H264_CAPABILITY_WEIGHTED_PRED_BIT_EXT = 0x00000200, 536 VK_VIDEO_ENCODE_H264_CAPABILITY_WEIGHTED_BIPRED_EXPLICIT_BIT_EXT = 0x00000400, 537 VK_VIDEO_ENCODE_H264_CAPABILITY_WEIGHTED_BIPRED_IMPLICIT_BIT_EXT = 0x00000800, 538 VK_VIDEO_ENCODE_H264_CAPABILITY_WEIGHTED_PRED_NO_TABLE_BIT_EXT = 0x00001000, 539 VK_VIDEO_ENCODE_H264_CAPABILITY_TRANSFORM_8X8_BIT_EXT = 0x00002000, 540 VK_VIDEO_ENCODE_H264_CAPABILITY_CABAC_BIT_EXT = 0x00004000, 541 VK_VIDEO_ENCODE_H264_CAPABILITY_CAVLC_BIT_EXT = 0x00008000, 542 VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_DISABLED_BIT_EXT = 0x00010000, 543 VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_ENABLED_BIT_EXT = 0x00020000, 544 VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_PARTIAL_BIT_EXT = 0x00040000, 545 VK_VIDEO_ENCODE_H264_CAPABILITY_DISABLE_DIRECT_SPATIAL_MV_PRED_BIT_EXT = 0x00080000, 546 VK_VIDEO_ENCODE_H264_CAPABILITY_MULTIPLE_SLICE_PER_FRAME_BIT_EXT = 0x00100000, 547 VK_VIDEO_ENCODE_H264_CAPABILITY_SLICE_MB_COUNT_BIT_EXT = 0x00200000, 548 VK_VIDEO_ENCODE_H264_CAPABILITY_ROW_UNALIGNED_SLICE_BIT_EXT = 0x00400000, 549 VK_VIDEO_ENCODE_H264_CAPABILITY_DIFFERENT_SLICE_TYPE_BIT_EXT = 0x00800000, 550 VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_EXT = 0x01000000, 551 VK_VIDEO_ENCODE_H264_CAPABILITY_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF 552 } VkVideoEncodeH264CapabilityFlagBitsEXT; 553 typedef VkFlags VkVideoEncodeH264CapabilityFlagsEXT; 554 555 typedef enum VkVideoEncodeH264InputModeFlagBitsEXT { 556 VK_VIDEO_ENCODE_H264_INPUT_MODE_FRAME_BIT_EXT = 0x00000001, 557 VK_VIDEO_ENCODE_H264_INPUT_MODE_SLICE_BIT_EXT = 0x00000002, 558 VK_VIDEO_ENCODE_H264_INPUT_MODE_NON_VCL_BIT_EXT = 0x00000004, 559 VK_VIDEO_ENCODE_H264_INPUT_MODE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF 560 } VkVideoEncodeH264InputModeFlagBitsEXT; 561 typedef VkFlags VkVideoEncodeH264InputModeFlagsEXT; 562 563 typedef enum VkVideoEncodeH264OutputModeFlagBitsEXT { 564 VK_VIDEO_ENCODE_H264_OUTPUT_MODE_FRAME_BIT_EXT = 0x00000001, 565 VK_VIDEO_ENCODE_H264_OUTPUT_MODE_SLICE_BIT_EXT = 0x00000002, 566 VK_VIDEO_ENCODE_H264_OUTPUT_MODE_NON_VCL_BIT_EXT = 0x00000004, 567 VK_VIDEO_ENCODE_H264_OUTPUT_MODE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF 568 } VkVideoEncodeH264OutputModeFlagBitsEXT; 569 typedef VkFlags VkVideoEncodeH264OutputModeFlagsEXT; 570 typedef struct VkVideoEncodeH264CapabilitiesEXT { 571 VkStructureType sType; 572 void* pNext; 573 VkVideoEncodeH264CapabilityFlagsEXT flags; 574 VkVideoEncodeH264InputModeFlagsEXT inputModeFlags; 575 VkVideoEncodeH264OutputModeFlagsEXT outputModeFlags; 576 uint8_t maxPPictureL0ReferenceCount; 577 uint8_t maxBPictureL0ReferenceCount; 578 uint8_t maxL1ReferenceCount; 579 VkBool32 motionVectorsOverPicBoundariesFlag; 580 uint32_t maxBytesPerPicDenom; 581 uint32_t maxBitsPerMbDenom; 582 uint32_t log2MaxMvLengthHorizontal; 583 uint32_t log2MaxMvLengthVertical; 584 } VkVideoEncodeH264CapabilitiesEXT; 585 586 typedef struct VkVideoEncodeH264SessionParametersAddInfoEXT { 587 VkStructureType sType; 588 const void* pNext; 589 uint32_t stdSPSCount; 590 const StdVideoH264SequenceParameterSet* pStdSPSs; 591 uint32_t stdPPSCount; 592 const StdVideoH264PictureParameterSet* pStdPPSs; 593 } VkVideoEncodeH264SessionParametersAddInfoEXT; 594 595 typedef struct VkVideoEncodeH264SessionParametersCreateInfoEXT { 596 VkStructureType sType; 597 const void* pNext; 598 uint32_t maxStdSPSCount; 599 uint32_t maxStdPPSCount; 600 const VkVideoEncodeH264SessionParametersAddInfoEXT* pParametersAddInfo; 601 } VkVideoEncodeH264SessionParametersCreateInfoEXT; 602 603 typedef struct VkVideoEncodeH264DpbSlotInfoEXT { 604 VkStructureType sType; 605 const void* pNext; 606 int8_t slotIndex; 607 const StdVideoEncodeH264ReferenceInfo* pStdReferenceInfo; 608 } VkVideoEncodeH264DpbSlotInfoEXT; 609 610 typedef struct VkVideoEncodeH264ReferenceListsInfoEXT { 611 VkStructureType sType; 612 const void* pNext; 613 uint8_t referenceList0EntryCount; 614 const VkVideoEncodeH264DpbSlotInfoEXT* pReferenceList0Entries; 615 uint8_t referenceList1EntryCount; 616 const VkVideoEncodeH264DpbSlotInfoEXT* pReferenceList1Entries; 617 const StdVideoEncodeH264RefMemMgmtCtrlOperations* pMemMgmtCtrlOperations; 618 } VkVideoEncodeH264ReferenceListsInfoEXT; 619 620 typedef struct VkVideoEncodeH264NaluSliceInfoEXT { 621 VkStructureType sType; 622 const void* pNext; 623 uint32_t mbCount; 624 const VkVideoEncodeH264ReferenceListsInfoEXT* pReferenceFinalLists; 625 const StdVideoEncodeH264SliceHeader* pSliceHeaderStd; 626 } VkVideoEncodeH264NaluSliceInfoEXT; 627 628 typedef struct VkVideoEncodeH264VclFrameInfoEXT { 629 VkStructureType sType; 630 const void* pNext; 631 const VkVideoEncodeH264ReferenceListsInfoEXT* pReferenceFinalLists; 632 uint32_t naluSliceEntryCount; 633 const VkVideoEncodeH264NaluSliceInfoEXT* pNaluSliceEntries; 634 const StdVideoEncodeH264PictureInfo* pCurrentPictureInfo; 635 } VkVideoEncodeH264VclFrameInfoEXT; 636 637 typedef struct VkVideoEncodeH264EmitPictureParametersInfoEXT { 638 VkStructureType sType; 639 const void* pNext; 640 uint8_t spsId; 641 VkBool32 emitSpsEnable; 642 uint32_t ppsIdEntryCount; 643 const uint8_t* ppsIdEntries; 644 } VkVideoEncodeH264EmitPictureParametersInfoEXT; 645 646 typedef struct VkVideoEncodeH264ProfileInfoEXT { 647 VkStructureType sType; 648 const void* pNext; 649 StdVideoH264ProfileIdc stdProfileIdc; 650 } VkVideoEncodeH264ProfileInfoEXT; 651 652 typedef struct VkVideoEncodeH264RateControlInfoEXT { 653 VkStructureType sType; 654 const void* pNext; 655 uint32_t gopFrameCount; 656 uint32_t idrPeriod; 657 uint32_t consecutiveBFrameCount; 658 VkVideoEncodeH264RateControlStructureEXT rateControlStructure; 659 uint8_t temporalLayerCount; 660 } VkVideoEncodeH264RateControlInfoEXT; 661 662 typedef struct VkVideoEncodeH264QpEXT { 663 int32_t qpI; 664 int32_t qpP; 665 int32_t qpB; 666 } VkVideoEncodeH264QpEXT; 667 668 typedef struct VkVideoEncodeH264FrameSizeEXT { 669 uint32_t frameISize; 670 uint32_t framePSize; 671 uint32_t frameBSize; 672 } VkVideoEncodeH264FrameSizeEXT; 673 674 typedef struct VkVideoEncodeH264RateControlLayerInfoEXT { 675 VkStructureType sType; 676 const void* pNext; 677 uint8_t temporalLayerId; 678 VkBool32 useInitialRcQp; 679 VkVideoEncodeH264QpEXT initialRcQp; 680 VkBool32 useMinQp; 681 VkVideoEncodeH264QpEXT minQp; 682 VkBool32 useMaxQp; 683 VkVideoEncodeH264QpEXT maxQp; 684 VkBool32 useMaxFrameSize; 685 VkVideoEncodeH264FrameSizeEXT maxFrameSize; 686 } VkVideoEncodeH264RateControlLayerInfoEXT; 687 688 689 690 #define VK_EXT_video_encode_h265 1 691 #include "vk_video/vulkan_video_codec_h265std.h" 692 #include "vk_video/vulkan_video_codec_h265std_encode.h" 693 #define VK_EXT_VIDEO_ENCODE_H265_SPEC_VERSION 9 694 #define VK_EXT_VIDEO_ENCODE_H265_EXTENSION_NAME "VK_EXT_video_encode_h265" 695 696 typedef enum VkVideoEncodeH265RateControlStructureEXT { 697 VK_VIDEO_ENCODE_H265_RATE_CONTROL_STRUCTURE_UNKNOWN_EXT = 0, 698 VK_VIDEO_ENCODE_H265_RATE_CONTROL_STRUCTURE_FLAT_EXT = 1, 699 VK_VIDEO_ENCODE_H265_RATE_CONTROL_STRUCTURE_DYADIC_EXT = 2, 700 VK_VIDEO_ENCODE_H265_RATE_CONTROL_STRUCTURE_MAX_ENUM_EXT = 0x7FFFFFFF 701 } VkVideoEncodeH265RateControlStructureEXT; 702 703 typedef enum VkVideoEncodeH265CapabilityFlagBitsEXT { 704 VK_VIDEO_ENCODE_H265_CAPABILITY_SEPARATE_COLOUR_PLANE_BIT_EXT = 0x00000001, 705 VK_VIDEO_ENCODE_H265_CAPABILITY_SCALING_LISTS_BIT_EXT = 0x00000002, 706 VK_VIDEO_ENCODE_H265_CAPABILITY_SAMPLE_ADAPTIVE_OFFSET_ENABLED_BIT_EXT = 0x00000004, 707 VK_VIDEO_ENCODE_H265_CAPABILITY_PCM_ENABLE_BIT_EXT = 0x00000008, 708 VK_VIDEO_ENCODE_H265_CAPABILITY_SPS_TEMPORAL_MVP_ENABLED_BIT_EXT = 0x00000010, 709 VK_VIDEO_ENCODE_H265_CAPABILITY_HRD_COMPLIANCE_BIT_EXT = 0x00000020, 710 VK_VIDEO_ENCODE_H265_CAPABILITY_INIT_QP_MINUS26_BIT_EXT = 0x00000040, 711 VK_VIDEO_ENCODE_H265_CAPABILITY_LOG2_PARALLEL_MERGE_LEVEL_MINUS2_BIT_EXT = 0x00000080, 712 VK_VIDEO_ENCODE_H265_CAPABILITY_SIGN_DATA_HIDING_ENABLED_BIT_EXT = 0x00000100, 713 VK_VIDEO_ENCODE_H265_CAPABILITY_TRANSFORM_SKIP_ENABLED_BIT_EXT = 0x00000200, 714 VK_VIDEO_ENCODE_H265_CAPABILITY_TRANSFORM_SKIP_DISABLED_BIT_EXT = 0x00000400, 715 VK_VIDEO_ENCODE_H265_CAPABILITY_PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT_BIT_EXT = 0x00000800, 716 VK_VIDEO_ENCODE_H265_CAPABILITY_WEIGHTED_PRED_BIT_EXT = 0x00001000, 717 VK_VIDEO_ENCODE_H265_CAPABILITY_WEIGHTED_BIPRED_BIT_EXT = 0x00002000, 718 VK_VIDEO_ENCODE_H265_CAPABILITY_WEIGHTED_PRED_NO_TABLE_BIT_EXT = 0x00004000, 719 VK_VIDEO_ENCODE_H265_CAPABILITY_TRANSQUANT_BYPASS_ENABLED_BIT_EXT = 0x00008000, 720 VK_VIDEO_ENCODE_H265_CAPABILITY_ENTROPY_CODING_SYNC_ENABLED_BIT_EXT = 0x00010000, 721 VK_VIDEO_ENCODE_H265_CAPABILITY_DEBLOCKING_FILTER_OVERRIDE_ENABLED_BIT_EXT = 0x00020000, 722 VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_TILE_PER_FRAME_BIT_EXT = 0x00040000, 723 VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_SLICE_PER_TILE_BIT_EXT = 0x00080000, 724 VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_TILE_PER_SLICE_BIT_EXT = 0x00100000, 725 VK_VIDEO_ENCODE_H265_CAPABILITY_SLICE_SEGMENT_CTB_COUNT_BIT_EXT = 0x00200000, 726 VK_VIDEO_ENCODE_H265_CAPABILITY_ROW_UNALIGNED_SLICE_SEGMENT_BIT_EXT = 0x00400000, 727 VK_VIDEO_ENCODE_H265_CAPABILITY_DEPENDENT_SLICE_SEGMENT_BIT_EXT = 0x00800000, 728 VK_VIDEO_ENCODE_H265_CAPABILITY_DIFFERENT_SLICE_TYPE_BIT_EXT = 0x01000000, 729 VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_EXT = 0x02000000, 730 VK_VIDEO_ENCODE_H265_CAPABILITY_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF 731 } VkVideoEncodeH265CapabilityFlagBitsEXT; 732 typedef VkFlags VkVideoEncodeH265CapabilityFlagsEXT; 733 734 typedef enum VkVideoEncodeH265InputModeFlagBitsEXT { 735 VK_VIDEO_ENCODE_H265_INPUT_MODE_FRAME_BIT_EXT = 0x00000001, 736 VK_VIDEO_ENCODE_H265_INPUT_MODE_SLICE_SEGMENT_BIT_EXT = 0x00000002, 737 VK_VIDEO_ENCODE_H265_INPUT_MODE_NON_VCL_BIT_EXT = 0x00000004, 738 VK_VIDEO_ENCODE_H265_INPUT_MODE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF 739 } VkVideoEncodeH265InputModeFlagBitsEXT; 740 typedef VkFlags VkVideoEncodeH265InputModeFlagsEXT; 741 742 typedef enum VkVideoEncodeH265OutputModeFlagBitsEXT { 743 VK_VIDEO_ENCODE_H265_OUTPUT_MODE_FRAME_BIT_EXT = 0x00000001, 744 VK_VIDEO_ENCODE_H265_OUTPUT_MODE_SLICE_SEGMENT_BIT_EXT = 0x00000002, 745 VK_VIDEO_ENCODE_H265_OUTPUT_MODE_NON_VCL_BIT_EXT = 0x00000004, 746 VK_VIDEO_ENCODE_H265_OUTPUT_MODE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF 747 } VkVideoEncodeH265OutputModeFlagBitsEXT; 748 typedef VkFlags VkVideoEncodeH265OutputModeFlagsEXT; 749 750 typedef enum VkVideoEncodeH265CtbSizeFlagBitsEXT { 751 VK_VIDEO_ENCODE_H265_CTB_SIZE_16_BIT_EXT = 0x00000001, 752 VK_VIDEO_ENCODE_H265_CTB_SIZE_32_BIT_EXT = 0x00000002, 753 VK_VIDEO_ENCODE_H265_CTB_SIZE_64_BIT_EXT = 0x00000004, 754 VK_VIDEO_ENCODE_H265_CTB_SIZE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF 755 } VkVideoEncodeH265CtbSizeFlagBitsEXT; 756 typedef VkFlags VkVideoEncodeH265CtbSizeFlagsEXT; 757 758 typedef enum VkVideoEncodeH265TransformBlockSizeFlagBitsEXT { 759 VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_4_BIT_EXT = 0x00000001, 760 VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_8_BIT_EXT = 0x00000002, 761 VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_16_BIT_EXT = 0x00000004, 762 VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_32_BIT_EXT = 0x00000008, 763 VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF 764 } VkVideoEncodeH265TransformBlockSizeFlagBitsEXT; 765 typedef VkFlags VkVideoEncodeH265TransformBlockSizeFlagsEXT; 766 typedef struct VkVideoEncodeH265CapabilitiesEXT { 767 VkStructureType sType; 768 void* pNext; 769 VkVideoEncodeH265CapabilityFlagsEXT flags; 770 VkVideoEncodeH265InputModeFlagsEXT inputModeFlags; 771 VkVideoEncodeH265OutputModeFlagsEXT outputModeFlags; 772 VkVideoEncodeH265CtbSizeFlagsEXT ctbSizes; 773 VkVideoEncodeH265TransformBlockSizeFlagsEXT transformBlockSizes; 774 uint8_t maxPPictureL0ReferenceCount; 775 uint8_t maxBPictureL0ReferenceCount; 776 uint8_t maxL1ReferenceCount; 777 uint8_t maxSubLayersCount; 778 uint8_t minLog2MinLumaCodingBlockSizeMinus3; 779 uint8_t maxLog2MinLumaCodingBlockSizeMinus3; 780 uint8_t minLog2MinLumaTransformBlockSizeMinus2; 781 uint8_t maxLog2MinLumaTransformBlockSizeMinus2; 782 uint8_t minMaxTransformHierarchyDepthInter; 783 uint8_t maxMaxTransformHierarchyDepthInter; 784 uint8_t minMaxTransformHierarchyDepthIntra; 785 uint8_t maxMaxTransformHierarchyDepthIntra; 786 uint8_t maxDiffCuQpDeltaDepth; 787 uint8_t minMaxNumMergeCand; 788 uint8_t maxMaxNumMergeCand; 789 } VkVideoEncodeH265CapabilitiesEXT; 790 791 typedef struct VkVideoEncodeH265SessionParametersAddInfoEXT { 792 VkStructureType sType; 793 const void* pNext; 794 uint32_t stdVPSCount; 795 const StdVideoH265VideoParameterSet* pStdVPSs; 796 uint32_t stdSPSCount; 797 const StdVideoH265SequenceParameterSet* pStdSPSs; 798 uint32_t stdPPSCount; 799 const StdVideoH265PictureParameterSet* pStdPPSs; 800 } VkVideoEncodeH265SessionParametersAddInfoEXT; 801 802 typedef struct VkVideoEncodeH265SessionParametersCreateInfoEXT { 803 VkStructureType sType; 804 const void* pNext; 805 uint32_t maxStdVPSCount; 806 uint32_t maxStdSPSCount; 807 uint32_t maxStdPPSCount; 808 const VkVideoEncodeH265SessionParametersAddInfoEXT* pParametersAddInfo; 809 } VkVideoEncodeH265SessionParametersCreateInfoEXT; 810 811 typedef struct VkVideoEncodeH265DpbSlotInfoEXT { 812 VkStructureType sType; 813 const void* pNext; 814 int8_t slotIndex; 815 const StdVideoEncodeH265ReferenceInfo* pStdReferenceInfo; 816 } VkVideoEncodeH265DpbSlotInfoEXT; 817 818 typedef struct VkVideoEncodeH265ReferenceListsInfoEXT { 819 VkStructureType sType; 820 const void* pNext; 821 uint8_t referenceList0EntryCount; 822 const VkVideoEncodeH265DpbSlotInfoEXT* pReferenceList0Entries; 823 uint8_t referenceList1EntryCount; 824 const VkVideoEncodeH265DpbSlotInfoEXT* pReferenceList1Entries; 825 const StdVideoEncodeH265ReferenceModifications* pReferenceModifications; 826 } VkVideoEncodeH265ReferenceListsInfoEXT; 827 828 typedef struct VkVideoEncodeH265NaluSliceSegmentInfoEXT { 829 VkStructureType sType; 830 const void* pNext; 831 uint32_t ctbCount; 832 const VkVideoEncodeH265ReferenceListsInfoEXT* pReferenceFinalLists; 833 const StdVideoEncodeH265SliceSegmentHeader* pSliceSegmentHeaderStd; 834 } VkVideoEncodeH265NaluSliceSegmentInfoEXT; 835 836 typedef struct VkVideoEncodeH265VclFrameInfoEXT { 837 VkStructureType sType; 838 const void* pNext; 839 const VkVideoEncodeH265ReferenceListsInfoEXT* pReferenceFinalLists; 840 uint32_t naluSliceSegmentEntryCount; 841 const VkVideoEncodeH265NaluSliceSegmentInfoEXT* pNaluSliceSegmentEntries; 842 const StdVideoEncodeH265PictureInfo* pCurrentPictureInfo; 843 } VkVideoEncodeH265VclFrameInfoEXT; 844 845 typedef struct VkVideoEncodeH265EmitPictureParametersInfoEXT { 846 VkStructureType sType; 847 const void* pNext; 848 uint8_t vpsId; 849 uint8_t spsId; 850 VkBool32 emitVpsEnable; 851 VkBool32 emitSpsEnable; 852 uint32_t ppsIdEntryCount; 853 const uint8_t* ppsIdEntries; 854 } VkVideoEncodeH265EmitPictureParametersInfoEXT; 855 856 typedef struct VkVideoEncodeH265ProfileInfoEXT { 857 VkStructureType sType; 858 const void* pNext; 859 StdVideoH265ProfileIdc stdProfileIdc; 860 } VkVideoEncodeH265ProfileInfoEXT; 861 862 typedef struct VkVideoEncodeH265RateControlInfoEXT { 863 VkStructureType sType; 864 const void* pNext; 865 uint32_t gopFrameCount; 866 uint32_t idrPeriod; 867 uint32_t consecutiveBFrameCount; 868 VkVideoEncodeH265RateControlStructureEXT rateControlStructure; 869 uint8_t subLayerCount; 870 } VkVideoEncodeH265RateControlInfoEXT; 871 872 typedef struct VkVideoEncodeH265QpEXT { 873 int32_t qpI; 874 int32_t qpP; 875 int32_t qpB; 876 } VkVideoEncodeH265QpEXT; 877 878 typedef struct VkVideoEncodeH265FrameSizeEXT { 879 uint32_t frameISize; 880 uint32_t framePSize; 881 uint32_t frameBSize; 882 } VkVideoEncodeH265FrameSizeEXT; 883 884 typedef struct VkVideoEncodeH265RateControlLayerInfoEXT { 885 VkStructureType sType; 886 const void* pNext; 887 uint8_t temporalId; 888 VkBool32 useInitialRcQp; 889 VkVideoEncodeH265QpEXT initialRcQp; 890 VkBool32 useMinQp; 891 VkVideoEncodeH265QpEXT minQp; 892 VkBool32 useMaxQp; 893 VkVideoEncodeH265QpEXT maxQp; 894 VkBool32 useMaxFrameSize; 895 VkVideoEncodeH265FrameSizeEXT maxFrameSize; 896 } VkVideoEncodeH265RateControlLayerInfoEXT; 897 898 899 900 #define VK_EXT_video_decode_h264 1 901 #include "vk_video/vulkan_video_codec_h264std_decode.h" 902 #define VK_EXT_VIDEO_DECODE_H264_SPEC_VERSION 7 903 #define VK_EXT_VIDEO_DECODE_H264_EXTENSION_NAME "VK_EXT_video_decode_h264" 904 905 typedef enum VkVideoDecodeH264PictureLayoutFlagBitsEXT { 906 VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_PROGRESSIVE_EXT = 0, 907 VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_INTERLEAVED_LINES_BIT_EXT = 0x00000001, 908 VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_SEPARATE_PLANES_BIT_EXT = 0x00000002, 909 VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF 910 } VkVideoDecodeH264PictureLayoutFlagBitsEXT; 911 typedef VkFlags VkVideoDecodeH264PictureLayoutFlagsEXT; 912 typedef struct VkVideoDecodeH264ProfileInfoEXT { 913 VkStructureType sType; 914 const void* pNext; 915 StdVideoH264ProfileIdc stdProfileIdc; 916 VkVideoDecodeH264PictureLayoutFlagBitsEXT pictureLayout; 917 } VkVideoDecodeH264ProfileInfoEXT; 918 919 typedef struct VkVideoDecodeH264CapabilitiesEXT { 920 VkStructureType sType; 921 void* pNext; 922 StdVideoH264LevelIdc maxLevelIdc; 923 VkOffset2D fieldOffsetGranularity; 924 } VkVideoDecodeH264CapabilitiesEXT; 925 926 typedef struct VkVideoDecodeH264SessionParametersAddInfoEXT { 927 VkStructureType sType; 928 const void* pNext; 929 uint32_t stdSPSCount; 930 const StdVideoH264SequenceParameterSet* pStdSPSs; 931 uint32_t stdPPSCount; 932 const StdVideoH264PictureParameterSet* pStdPPSs; 933 } VkVideoDecodeH264SessionParametersAddInfoEXT; 934 935 typedef struct VkVideoDecodeH264SessionParametersCreateInfoEXT { 936 VkStructureType sType; 937 const void* pNext; 938 uint32_t maxStdSPSCount; 939 uint32_t maxStdPPSCount; 940 const VkVideoDecodeH264SessionParametersAddInfoEXT* pParametersAddInfo; 941 } VkVideoDecodeH264SessionParametersCreateInfoEXT; 942 943 typedef struct VkVideoDecodeH264PictureInfoEXT { 944 VkStructureType sType; 945 const void* pNext; 946 const StdVideoDecodeH264PictureInfo* pStdPictureInfo; 947 uint32_t sliceCount; 948 const uint32_t* pSliceOffsets; 949 } VkVideoDecodeH264PictureInfoEXT; 950 951 typedef struct VkVideoDecodeH264DpbSlotInfoEXT { 952 VkStructureType sType; 953 const void* pNext; 954 const StdVideoDecodeH264ReferenceInfo* pStdReferenceInfo; 955 } VkVideoDecodeH264DpbSlotInfoEXT; 956 957 958 959 #define VK_EXT_video_decode_h265 1 960 #include "vk_video/vulkan_video_codec_h265std_decode.h" 961 #define VK_EXT_VIDEO_DECODE_H265_SPEC_VERSION 5 962 #define VK_EXT_VIDEO_DECODE_H265_EXTENSION_NAME "VK_EXT_video_decode_h265" 963 typedef struct VkVideoDecodeH265ProfileInfoEXT { 964 VkStructureType sType; 965 const void* pNext; 966 StdVideoH265ProfileIdc stdProfileIdc; 967 } VkVideoDecodeH265ProfileInfoEXT; 968 969 typedef struct VkVideoDecodeH265CapabilitiesEXT { 970 VkStructureType sType; 971 void* pNext; 972 StdVideoH265LevelIdc maxLevelIdc; 973 } VkVideoDecodeH265CapabilitiesEXT; 974 975 typedef struct VkVideoDecodeH265SessionParametersAddInfoEXT { 976 VkStructureType sType; 977 const void* pNext; 978 uint32_t stdVPSCount; 979 const StdVideoH265VideoParameterSet* pStdVPSs; 980 uint32_t stdSPSCount; 981 const StdVideoH265SequenceParameterSet* pStdSPSs; 982 uint32_t stdPPSCount; 983 const StdVideoH265PictureParameterSet* pStdPPSs; 984 } VkVideoDecodeH265SessionParametersAddInfoEXT; 985 986 typedef struct VkVideoDecodeH265SessionParametersCreateInfoEXT { 987 VkStructureType sType; 988 const void* pNext; 989 uint32_t maxStdVPSCount; 990 uint32_t maxStdSPSCount; 991 uint32_t maxStdPPSCount; 992 const VkVideoDecodeH265SessionParametersAddInfoEXT* pParametersAddInfo; 993 } VkVideoDecodeH265SessionParametersCreateInfoEXT; 994 995 typedef struct VkVideoDecodeH265PictureInfoEXT { 996 VkStructureType sType; 997 const void* pNext; 998 StdVideoDecodeH265PictureInfo* pStdPictureInfo; 999 uint32_t sliceCount; 1000 const uint32_t* pSliceOffsets; 1001 } VkVideoDecodeH265PictureInfoEXT; 1002 1003 typedef struct VkVideoDecodeH265DpbSlotInfoEXT { 1004 VkStructureType sType; 1005 const void* pNext; 1006 const StdVideoDecodeH265ReferenceInfo* pStdReferenceInfo; 1007 } VkVideoDecodeH265DpbSlotInfoEXT; 1008 1009 1010 #ifdef __cplusplus 1011 } 1012 #endif 1013 1014 #endif 1015