# include <compare>
#endif
-static_assert( VK_HEADER_VERSION == 186, "Wrong VK_HEADER_VERSION!" );
+static_assert( VK_HEADER_VERSION == 187, "Wrong VK_HEADER_VERSION!" );
// 32-bit vulkan is not typesafe for handles, so don't allow copy constructors on this platform by default.
// To enable this feature on 32-bit platforms please define VULKAN_HPP_TYPESAFE_CONVERSION
ObjectDestroy( OwnerType owner,
Optional<const AllocationCallbacks> allocationCallbacks
VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
- Dispatch const & dispatch = VULKAN_HPP_DEFAULT_DISPATCHER ) VULKAN_HPP_NOEXCEPT
+ Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT
: m_owner( owner )
, m_allocationCallbacks( allocationCallbacks )
, m_dispatch( &dispatch )
ObjectDestroy() = default;
ObjectDestroy( Optional<const AllocationCallbacks> allocationCallbacks,
- Dispatch const & dispatch = VULKAN_HPP_DEFAULT_DISPATCHER ) VULKAN_HPP_NOEXCEPT
+ Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT
: m_allocationCallbacks( allocationCallbacks )
, m_dispatch( &dispatch )
{}
ObjectFree( OwnerType owner,
Optional<const AllocationCallbacks> allocationCallbacks VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
- Dispatch const & dispatch = VULKAN_HPP_DEFAULT_DISPATCHER ) VULKAN_HPP_NOEXCEPT
+ Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT
: m_owner( owner )
, m_allocationCallbacks( allocationCallbacks )
, m_dispatch( &dispatch )
public:
ObjectRelease() = default;
- ObjectRelease( OwnerType owner, Dispatch const & dispatch = VULKAN_HPP_DEFAULT_DISPATCHER ) VULKAN_HPP_NOEXCEPT
+ ObjectRelease( OwnerType owner,
+ Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT
: m_owner( owner )
, m_dispatch( &dispatch )
{}
PoolFree( OwnerType owner,
PoolType pool,
- Dispatch const & dispatch = VULKAN_HPP_DEFAULT_DISPATCHER ) VULKAN_HPP_NOEXCEPT
+ Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT
: m_owner( owner )
, m_pool( pool )
, m_dispatch( &dispatch )
#define VK_KHR_video_queue 1
VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkVideoSessionKHR)
VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkVideoSessionParametersKHR)
-#define VK_KHR_VIDEO_QUEUE_SPEC_VERSION 1
+#define VK_KHR_VIDEO_QUEUE_SPEC_VERSION 2
#define VK_KHR_VIDEO_QUEUE_EXTENSION_NAME "VK_KHR_video_queue"
typedef enum VkQueryResultStatusKHR {
} VkVideoComponentBitDepthFlagBitsKHR;
typedef VkFlags VkVideoComponentBitDepthFlagsKHR;
-typedef enum VkVideoCapabilitiesFlagBitsKHR {
- VK_VIDEO_CAPABILITIES_PROTECTED_CONTENT_BIT_KHR = 0x00000001,
- VK_VIDEO_CAPABILITIES_SEPARATE_REFERENCE_IMAGES_BIT_KHR = 0x00000002,
- VK_VIDEO_CAPABILITIES_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
-} VkVideoCapabilitiesFlagBitsKHR;
-typedef VkFlags VkVideoCapabilitiesFlagsKHR;
+typedef enum VkVideoCapabilityFlagBitsKHR {
+ VK_VIDEO_CAPABILITY_PROTECTED_CONTENT_BIT_KHR = 0x00000001,
+ VK_VIDEO_CAPABILITY_SEPARATE_REFERENCE_IMAGES_BIT_KHR = 0x00000002,
+ VK_VIDEO_CAPABILITY_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF
+} VkVideoCapabilityFlagBitsKHR;
+typedef VkFlags VkVideoCapabilityFlagsKHR;
typedef enum VkVideoSessionCreateFlagBitsKHR {
VK_VIDEO_SESSION_CREATE_DEFAULT_KHR = 0,
} VkVideoProfilesKHR;
typedef struct VkVideoCapabilitiesKHR {
- VkStructureType sType;
- void* pNext;
- VkVideoCapabilitiesFlagsKHR capabilityFlags;
- VkDeviceSize minBitstreamBufferOffsetAlignment;
- VkDeviceSize minBitstreamBufferSizeAlignment;
- VkExtent2D videoPictureExtentGranularity;
- VkExtent2D minExtent;
- VkExtent2D maxExtent;
- uint32_t maxReferencePicturesSlotsCount;
- uint32_t maxReferencePicturesActiveCount;
+ VkStructureType sType;
+ void* pNext;
+ VkVideoCapabilityFlagsKHR capabilityFlags;
+ VkDeviceSize minBitstreamBufferOffsetAlignment;
+ VkDeviceSize minBitstreamBufferSizeAlignment;
+ VkExtent2D videoPictureExtentGranularity;
+ VkExtent2D minExtent;
+ VkExtent2D maxExtent;
+ uint32_t maxReferencePicturesSlotsCount;
+ uint32_t maxReferencePicturesActiveCount;
} VkVideoCapabilitiesKHR;
typedef struct VkPhysicalDeviceVideoFormatInfoKHR {
#define VK_EXT_video_encode_h264 1
#include "vk_video/vulkan_video_codec_h264std.h"
#include "vk_video/vulkan_video_codec_h264std_encode.h"
-#define VK_EXT_VIDEO_ENCODE_H264_SPEC_VERSION 1
+#define VK_EXT_VIDEO_ENCODE_H264_SPEC_VERSION 2
#define VK_EXT_VIDEO_ENCODE_H264_EXTENSION_NAME "VK_EXT_video_encode_h264"
-typedef enum VkVideoEncodeH264CapabilitiesFlagBitsEXT {
+typedef enum VkVideoEncodeH264CapabilityFlagBitsEXT {
VK_VIDEO_ENCODE_H264_CAPABILITY_CABAC_BIT_EXT = 0x00000001,
VK_VIDEO_ENCODE_H264_CAPABILITY_CAVLC_BIT_EXT = 0x00000002,
VK_VIDEO_ENCODE_H264_CAPABILITY_WEIGHTED_BI_PRED_IMPLICIT_BIT_EXT = 0x00000004,
VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_PARTIAL_BIT_EXT = 0x00000100,
VK_VIDEO_ENCODE_H264_CAPABILITY_MULTIPLE_SLICE_PER_FRAME_BIT_EXT = 0x00000200,
VK_VIDEO_ENCODE_H264_CAPABILITY_EVENLY_DISTRIBUTED_SLICE_SIZE_BIT_EXT = 0x00000400,
- VK_VIDEO_ENCODE_H264_CAPABILITIES_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
-} VkVideoEncodeH264CapabilitiesFlagBitsEXT;
-typedef VkFlags VkVideoEncodeH264CapabilitiesFlagsEXT;
+ VK_VIDEO_ENCODE_H264_CAPABILITY_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
+} VkVideoEncodeH264CapabilityFlagBitsEXT;
+typedef VkFlags VkVideoEncodeH264CapabilityFlagsEXT;
typedef enum VkVideoEncodeH264InputModeFlagBitsEXT {
VK_VIDEO_ENCODE_H264_INPUT_MODE_FRAME_BIT_EXT = 0x00000001,
} VkVideoEncodeH264CreateFlagBitsEXT;
typedef VkFlags VkVideoEncodeH264CreateFlagsEXT;
typedef struct VkVideoEncodeH264CapabilitiesEXT {
- VkStructureType sType;
- const void* pNext;
- VkVideoEncodeH264CapabilitiesFlagsEXT flags;
- VkVideoEncodeH264InputModeFlagsEXT inputModeFlags;
- VkVideoEncodeH264OutputModeFlagsEXT outputModeFlags;
- VkExtent2D minPictureSizeInMbs;
- VkExtent2D maxPictureSizeInMbs;
- VkExtent2D inputImageDataAlignment;
- uint8_t maxNumL0ReferenceForP;
- uint8_t maxNumL0ReferenceForB;
- uint8_t maxNumL1Reference;
- uint8_t qualityLevelCount;
- VkExtensionProperties stdExtensionVersion;
+ VkStructureType sType;
+ const void* pNext;
+ VkVideoEncodeH264CapabilityFlagsEXT flags;
+ VkVideoEncodeH264InputModeFlagsEXT inputModeFlags;
+ VkVideoEncodeH264OutputModeFlagsEXT outputModeFlags;
+ VkExtent2D minPictureSizeInMbs;
+ VkExtent2D maxPictureSizeInMbs;
+ VkExtent2D inputImageDataAlignment;
+ uint8_t maxNumL0ReferenceForP;
+ uint8_t maxNumL0ReferenceForB;
+ uint8_t maxNumL1Reference;
+ uint8_t qualityLevelCount;
+ VkExtensionProperties stdExtensionVersion;
} VkVideoEncodeH264CapabilitiesEXT;
typedef struct VkVideoEncodeH264SessionCreateInfoEXT {
#define VK_EXT_video_decode_h264 1
#include "vk_video/vulkan_video_codec_h264std_decode.h"
-#define VK_EXT_VIDEO_DECODE_H264_SPEC_VERSION 1
+#define VK_EXT_VIDEO_DECODE_H264_SPEC_VERSION 3
#define VK_EXT_VIDEO_DECODE_H264_EXTENSION_NAME "VK_EXT_video_decode_h264"
-typedef enum VkVideoDecodeH264FieldLayoutFlagBitsEXT {
- VK_VIDEO_DECODE_H264_PROGRESSIVE_PICTURES_ONLY_EXT = 0,
- VK_VIDEO_DECODE_H264_FIELD_LAYOUT_LINE_INTERLACED_PLANE_BIT_EXT = 0x00000001,
- VK_VIDEO_DECODE_H264_FIELD_LAYOUT_SEPARATE_INTERLACED_PLANE_BIT_EXT = 0x00000002,
- VK_VIDEO_DECODE_H264_FIELD_LAYOUT_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
-} VkVideoDecodeH264FieldLayoutFlagBitsEXT;
-typedef VkFlags VkVideoDecodeH264FieldLayoutFlagsEXT;
+typedef enum VkVideoDecodeH264PictureLayoutFlagBitsEXT {
+ VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_PROGRESSIVE_EXT = 0,
+ VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_INTERLEAVED_LINES_BIT_EXT = 0x00000001,
+ VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_SEPARATE_PLANES_BIT_EXT = 0x00000002,
+ VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF
+} VkVideoDecodeH264PictureLayoutFlagBitsEXT;
+typedef VkFlags VkVideoDecodeH264PictureLayoutFlagsEXT;
typedef VkFlags VkVideoDecodeH264CreateFlagsEXT;
typedef struct VkVideoDecodeH264ProfileEXT {
- VkStructureType sType;
- const void* pNext;
- StdVideoH264ProfileIdc stdProfileIdc;
- VkVideoDecodeH264FieldLayoutFlagsEXT fieldLayout;
+ VkStructureType sType;
+ const void* pNext;
+ StdVideoH264ProfileIdc stdProfileIdc;
+ VkVideoDecodeH264PictureLayoutFlagsEXT pictureLayout;
} VkVideoDecodeH264ProfileEXT;
typedef struct VkVideoDecodeH264CapabilitiesEXT {
#define VK_API_VERSION_1_0 VK_MAKE_API_VERSION(0, 1, 0, 0)// Patch version should always be set to 0
// Version of this file
-#define VK_HEADER_VERSION 186
+#define VK_HEADER_VERSION 187
// Complete version of this file
#define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 2, VK_HEADER_VERSION)
}
}
- enum class VideoCapabilitiesFlagBitsKHR : VkVideoCapabilitiesFlagsKHR
+ enum class VideoCapabilityFlagBitsKHR : VkVideoCapabilityFlagsKHR
{
- eProtectedContent = VK_VIDEO_CAPABILITIES_PROTECTED_CONTENT_BIT_KHR,
- eSeparateReferenceImages = VK_VIDEO_CAPABILITIES_SEPARATE_REFERENCE_IMAGES_BIT_KHR
+ eProtectedContent = VK_VIDEO_CAPABILITY_PROTECTED_CONTENT_BIT_KHR,
+ eSeparateReferenceImages = VK_VIDEO_CAPABILITY_SEPARATE_REFERENCE_IMAGES_BIT_KHR
};
- VULKAN_HPP_INLINE std::string to_string( VideoCapabilitiesFlagBitsKHR value )
+ VULKAN_HPP_INLINE std::string to_string( VideoCapabilityFlagBitsKHR value )
{
switch ( value )
{
- case VideoCapabilitiesFlagBitsKHR::eProtectedContent: return "ProtectedContent";
- case VideoCapabilitiesFlagBitsKHR::eSeparateReferenceImages: return "SeparateReferenceImages";
+ case VideoCapabilityFlagBitsKHR::eProtectedContent: return "ProtectedContent";
+ case VideoCapabilityFlagBitsKHR::eSeparateReferenceImages: return "SeparateReferenceImages";
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
}
}
#if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== VK_EXT_video_encode_h264 ===
- enum class VideoEncodeH264CapabilitiesFlagBitsEXT : VkVideoEncodeH264CapabilitiesFlagsEXT
- {
- eVkVideoEncodeH264CapabilityCabac = VK_VIDEO_ENCODE_H264_CAPABILITY_CABAC_BIT_EXT,
- eVkVideoEncodeH264CapabilityCavlc = VK_VIDEO_ENCODE_H264_CAPABILITY_CAVLC_BIT_EXT,
- eVkVideoEncodeH264CapabilityWeightedBiPredImplicit =
- VK_VIDEO_ENCODE_H264_CAPABILITY_WEIGHTED_BI_PRED_IMPLICIT_BIT_EXT,
- eVkVideoEncodeH264CapabilityTransform8X8 = VK_VIDEO_ENCODE_H264_CAPABILITY_TRANSFORM_8X8_BIT_EXT,
- eVkVideoEncodeH264CapabilityChromaQpOffset = VK_VIDEO_ENCODE_H264_CAPABILITY_CHROMA_QP_OFFSET_BIT_EXT,
- eVkVideoEncodeH264CapabilitySecondChromaQpOffset = VK_VIDEO_ENCODE_H264_CAPABILITY_SECOND_CHROMA_QP_OFFSET_BIT_EXT,
- eVkVideoEncodeH264CapabilityDeblockingFilterDisabled =
- VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_DISABLED_BIT_EXT,
- eVkVideoEncodeH264CapabilityDeblockingFilterEnabled =
- VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_ENABLED_BIT_EXT,
- eVkVideoEncodeH264CapabilityDeblockingFilterPartial =
- VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_PARTIAL_BIT_EXT,
- eVkVideoEncodeH264CapabilityMultipleSlicePerFrame =
- VK_VIDEO_ENCODE_H264_CAPABILITY_MULTIPLE_SLICE_PER_FRAME_BIT_EXT,
- eVkVideoEncodeH264CapabilityEvenlyDistributedSliceSize =
- VK_VIDEO_ENCODE_H264_CAPABILITY_EVENLY_DISTRIBUTED_SLICE_SIZE_BIT_EXT
- };
-
- VULKAN_HPP_INLINE std::string to_string( VideoEncodeH264CapabilitiesFlagBitsEXT value )
- {
- switch ( value )
- {
- case VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityCabac:
- return "VkVideoEncodeH264CapabilityCabac";
- case VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityCavlc:
- return "VkVideoEncodeH264CapabilityCavlc";
- case VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityWeightedBiPredImplicit:
- return "VkVideoEncodeH264CapabilityWeightedBiPredImplicit";
- case VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityTransform8X8:
- return "VkVideoEncodeH264CapabilityTransform8X8";
- case VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityChromaQpOffset:
- return "VkVideoEncodeH264CapabilityChromaQpOffset";
- case VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilitySecondChromaQpOffset:
- return "VkVideoEncodeH264CapabilitySecondChromaQpOffset";
- case VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityDeblockingFilterDisabled:
- return "VkVideoEncodeH264CapabilityDeblockingFilterDisabled";
- case VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityDeblockingFilterEnabled:
- return "VkVideoEncodeH264CapabilityDeblockingFilterEnabled";
- case VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityDeblockingFilterPartial:
- return "VkVideoEncodeH264CapabilityDeblockingFilterPartial";
- case VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityMultipleSlicePerFrame:
- return "VkVideoEncodeH264CapabilityMultipleSlicePerFrame";
- case VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityEvenlyDistributedSliceSize:
- return "VkVideoEncodeH264CapabilityEvenlyDistributedSliceSize";
+ enum class VideoEncodeH264CapabilityFlagBitsEXT : VkVideoEncodeH264CapabilityFlagsEXT
+ {
+ eCabac = VK_VIDEO_ENCODE_H264_CAPABILITY_CABAC_BIT_EXT,
+ eCavlc = VK_VIDEO_ENCODE_H264_CAPABILITY_CAVLC_BIT_EXT,
+ eWeightedBiPredImplicit = VK_VIDEO_ENCODE_H264_CAPABILITY_WEIGHTED_BI_PRED_IMPLICIT_BIT_EXT,
+ eTransform8X8 = VK_VIDEO_ENCODE_H264_CAPABILITY_TRANSFORM_8X8_BIT_EXT,
+ eChromaQpOffset = VK_VIDEO_ENCODE_H264_CAPABILITY_CHROMA_QP_OFFSET_BIT_EXT,
+ eSecondChromaQpOffset = VK_VIDEO_ENCODE_H264_CAPABILITY_SECOND_CHROMA_QP_OFFSET_BIT_EXT,
+ eDeblockingFilterDisabled = VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_DISABLED_BIT_EXT,
+ eDeblockingFilterEnabled = VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_ENABLED_BIT_EXT,
+ eDeblockingFilterPartial = VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_PARTIAL_BIT_EXT,
+ eMultipleSlicePerFrame = VK_VIDEO_ENCODE_H264_CAPABILITY_MULTIPLE_SLICE_PER_FRAME_BIT_EXT,
+ eEvenlyDistributedSliceSize = VK_VIDEO_ENCODE_H264_CAPABILITY_EVENLY_DISTRIBUTED_SLICE_SIZE_BIT_EXT
+ };
+
+ VULKAN_HPP_INLINE std::string to_string( VideoEncodeH264CapabilityFlagBitsEXT value )
+ {
+ switch ( value )
+ {
+ case VideoEncodeH264CapabilityFlagBitsEXT::eCabac: return "Cabac";
+ case VideoEncodeH264CapabilityFlagBitsEXT::eCavlc: return "Cavlc";
+ case VideoEncodeH264CapabilityFlagBitsEXT::eWeightedBiPredImplicit: return "WeightedBiPredImplicit";
+ case VideoEncodeH264CapabilityFlagBitsEXT::eTransform8X8: return "Transform8X8";
+ case VideoEncodeH264CapabilityFlagBitsEXT::eChromaQpOffset: return "ChromaQpOffset";
+ case VideoEncodeH264CapabilityFlagBitsEXT::eSecondChromaQpOffset: return "SecondChromaQpOffset";
+ case VideoEncodeH264CapabilityFlagBitsEXT::eDeblockingFilterDisabled: return "DeblockingFilterDisabled";
+ case VideoEncodeH264CapabilityFlagBitsEXT::eDeblockingFilterEnabled: return "DeblockingFilterEnabled";
+ case VideoEncodeH264CapabilityFlagBitsEXT::eDeblockingFilterPartial: return "DeblockingFilterPartial";
+ case VideoEncodeH264CapabilityFlagBitsEXT::eMultipleSlicePerFrame: return "MultipleSlicePerFrame";
+ case VideoEncodeH264CapabilityFlagBitsEXT::eEvenlyDistributedSliceSize: return "EvenlyDistributedSliceSize";
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
}
}
#if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== VK_EXT_video_decode_h264 ===
- enum class VideoDecodeH264FieldLayoutFlagBitsEXT : VkVideoDecodeH264FieldLayoutFlagsEXT
+ enum class VideoDecodeH264PictureLayoutFlagBitsEXT : VkVideoDecodeH264PictureLayoutFlagsEXT
{
- eVkVideoDecodeH264ProgressivePicturesOnly = VK_VIDEO_DECODE_H264_PROGRESSIVE_PICTURES_ONLY_EXT,
- eLineInterlacedPlane = VK_VIDEO_DECODE_H264_FIELD_LAYOUT_LINE_INTERLACED_PLANE_BIT_EXT,
- eSeparateInterlacedPlane = VK_VIDEO_DECODE_H264_FIELD_LAYOUT_SEPARATE_INTERLACED_PLANE_BIT_EXT
+ eProgressive = VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_PROGRESSIVE_EXT,
+ eInterlacedInterleavedLines = VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_INTERLEAVED_LINES_BIT_EXT,
+ eInterlacedSeparatePlanes = VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_SEPARATE_PLANES_BIT_EXT
};
- VULKAN_HPP_INLINE std::string to_string( VideoDecodeH264FieldLayoutFlagBitsEXT value )
+ VULKAN_HPP_INLINE std::string to_string( VideoDecodeH264PictureLayoutFlagBitsEXT value )
{
switch ( value )
{
- case VideoDecodeH264FieldLayoutFlagBitsEXT::eVkVideoDecodeH264ProgressivePicturesOnly:
- return "VkVideoDecodeH264ProgressivePicturesOnly";
- case VideoDecodeH264FieldLayoutFlagBitsEXT::eLineInterlacedPlane: return "LineInterlacedPlane";
- case VideoDecodeH264FieldLayoutFlagBitsEXT::eSeparateInterlacedPlane: return "SeparateInterlacedPlane";
+ case VideoDecodeH264PictureLayoutFlagBitsEXT::eProgressive: return "Progressive";
+ case VideoDecodeH264PictureLayoutFlagBitsEXT::eInterlacedInterleavedLines: return "InterlacedInterleavedLines";
+ case VideoDecodeH264PictureLayoutFlagBitsEXT::eInterlacedSeparatePlanes: return "InterlacedSeparatePlanes";
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
}
}
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
- using VideoCapabilitiesFlagsKHR = Flags<VideoCapabilitiesFlagBitsKHR>;
+ using VideoCapabilityFlagsKHR = Flags<VideoCapabilityFlagBitsKHR>;
template <>
- struct FlagTraits<VideoCapabilitiesFlagBitsKHR>
+ struct FlagTraits<VideoCapabilityFlagBitsKHR>
{
enum : VkFlags
{
- allFlags = VkFlags( VideoCapabilitiesFlagBitsKHR::eProtectedContent ) |
- VkFlags( VideoCapabilitiesFlagBitsKHR::eSeparateReferenceImages )
+ allFlags = VkFlags( VideoCapabilityFlagBitsKHR::eProtectedContent ) |
+ VkFlags( VideoCapabilityFlagBitsKHR::eSeparateReferenceImages )
};
};
- VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoCapabilitiesFlagsKHR
- operator|( VideoCapabilitiesFlagBitsKHR bit0, VideoCapabilitiesFlagBitsKHR bit1 ) VULKAN_HPP_NOEXCEPT
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoCapabilityFlagsKHR
+ operator|( VideoCapabilityFlagBitsKHR bit0, VideoCapabilityFlagBitsKHR bit1 ) VULKAN_HPP_NOEXCEPT
{
- return VideoCapabilitiesFlagsKHR( bit0 ) | bit1;
+ return VideoCapabilityFlagsKHR( bit0 ) | bit1;
}
- VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoCapabilitiesFlagsKHR
- operator&(VideoCapabilitiesFlagBitsKHR bit0, VideoCapabilitiesFlagBitsKHR bit1)VULKAN_HPP_NOEXCEPT
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoCapabilityFlagsKHR
+ operator&(VideoCapabilityFlagBitsKHR bit0, VideoCapabilityFlagBitsKHR bit1)VULKAN_HPP_NOEXCEPT
{
- return VideoCapabilitiesFlagsKHR( bit0 ) & bit1;
+ return VideoCapabilityFlagsKHR( bit0 ) & bit1;
}
- VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoCapabilitiesFlagsKHR
- operator^( VideoCapabilitiesFlagBitsKHR bit0, VideoCapabilitiesFlagBitsKHR bit1 ) VULKAN_HPP_NOEXCEPT
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoCapabilityFlagsKHR
+ operator^( VideoCapabilityFlagBitsKHR bit0, VideoCapabilityFlagBitsKHR bit1 ) VULKAN_HPP_NOEXCEPT
{
- return VideoCapabilitiesFlagsKHR( bit0 ) ^ bit1;
+ return VideoCapabilityFlagsKHR( bit0 ) ^ bit1;
}
- VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoCapabilitiesFlagsKHR operator~( VideoCapabilitiesFlagBitsKHR bits )
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoCapabilityFlagsKHR operator~( VideoCapabilityFlagBitsKHR bits )
VULKAN_HPP_NOEXCEPT
{
- return ~( VideoCapabilitiesFlagsKHR( bits ) );
+ return ~( VideoCapabilityFlagsKHR( bits ) );
}
- VULKAN_HPP_INLINE std::string to_string( VideoCapabilitiesFlagsKHR value )
+ VULKAN_HPP_INLINE std::string to_string( VideoCapabilityFlagsKHR value )
{
if ( !value )
return "{}";
std::string result;
- if ( value & VideoCapabilitiesFlagBitsKHR::eProtectedContent )
+ if ( value & VideoCapabilityFlagBitsKHR::eProtectedContent )
result += "ProtectedContent | ";
- if ( value & VideoCapabilitiesFlagBitsKHR::eSeparateReferenceImages )
+ if ( value & VideoCapabilityFlagBitsKHR::eSeparateReferenceImages )
result += "SeparateReferenceImages | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
#if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== VK_EXT_video_encode_h264 ===
- using VideoEncodeH264CapabilitiesFlagsEXT = Flags<VideoEncodeH264CapabilitiesFlagBitsEXT>;
+ using VideoEncodeH264CapabilityFlagsEXT = Flags<VideoEncodeH264CapabilityFlagBitsEXT>;
template <>
- struct FlagTraits<VideoEncodeH264CapabilitiesFlagBitsEXT>
+ struct FlagTraits<VideoEncodeH264CapabilityFlagBitsEXT>
{
enum : VkFlags
{
- allFlags =
- VkFlags( VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityCabac ) |
- VkFlags( VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityCavlc ) |
- VkFlags( VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityWeightedBiPredImplicit ) |
- VkFlags( VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityTransform8X8 ) |
- VkFlags( VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityChromaQpOffset ) |
- VkFlags( VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilitySecondChromaQpOffset ) |
- VkFlags( VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityDeblockingFilterDisabled ) |
- VkFlags( VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityDeblockingFilterEnabled ) |
- VkFlags( VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityDeblockingFilterPartial ) |
- VkFlags( VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityMultipleSlicePerFrame ) |
- VkFlags( VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityEvenlyDistributedSliceSize )
+ allFlags = VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eCabac ) |
+ VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eCavlc ) |
+ VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eWeightedBiPredImplicit ) |
+ VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eTransform8X8 ) |
+ VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eChromaQpOffset ) |
+ VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eSecondChromaQpOffset ) |
+ VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eDeblockingFilterDisabled ) |
+ VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eDeblockingFilterEnabled ) |
+ VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eDeblockingFilterPartial ) |
+ VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eMultipleSlicePerFrame ) |
+ VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eEvenlyDistributedSliceSize )
};
};
- VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoEncodeH264CapabilitiesFlagsEXT operator|(
- VideoEncodeH264CapabilitiesFlagBitsEXT bit0, VideoEncodeH264CapabilitiesFlagBitsEXT bit1 ) VULKAN_HPP_NOEXCEPT
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoEncodeH264CapabilityFlagsEXT operator|(
+ VideoEncodeH264CapabilityFlagBitsEXT bit0, VideoEncodeH264CapabilityFlagBitsEXT bit1 ) VULKAN_HPP_NOEXCEPT
{
- return VideoEncodeH264CapabilitiesFlagsEXT( bit0 ) | bit1;
+ return VideoEncodeH264CapabilityFlagsEXT( bit0 ) | bit1;
}
- VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoEncodeH264CapabilitiesFlagsEXT operator&(
- VideoEncodeH264CapabilitiesFlagBitsEXT bit0, VideoEncodeH264CapabilitiesFlagBitsEXT bit1)VULKAN_HPP_NOEXCEPT
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoEncodeH264CapabilityFlagsEXT
+ operator&(VideoEncodeH264CapabilityFlagBitsEXT bit0, VideoEncodeH264CapabilityFlagBitsEXT bit1)VULKAN_HPP_NOEXCEPT
{
- return VideoEncodeH264CapabilitiesFlagsEXT( bit0 ) & bit1;
+ return VideoEncodeH264CapabilityFlagsEXT( bit0 ) & bit1;
}
- VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoEncodeH264CapabilitiesFlagsEXT operator^(
- VideoEncodeH264CapabilitiesFlagBitsEXT bit0, VideoEncodeH264CapabilitiesFlagBitsEXT bit1 ) VULKAN_HPP_NOEXCEPT
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoEncodeH264CapabilityFlagsEXT operator^(
+ VideoEncodeH264CapabilityFlagBitsEXT bit0, VideoEncodeH264CapabilityFlagBitsEXT bit1 ) VULKAN_HPP_NOEXCEPT
{
- return VideoEncodeH264CapabilitiesFlagsEXT( bit0 ) ^ bit1;
+ return VideoEncodeH264CapabilityFlagsEXT( bit0 ) ^ bit1;
}
- VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoEncodeH264CapabilitiesFlagsEXT
- operator~( VideoEncodeH264CapabilitiesFlagBitsEXT bits ) VULKAN_HPP_NOEXCEPT
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoEncodeH264CapabilityFlagsEXT
+ operator~( VideoEncodeH264CapabilityFlagBitsEXT bits ) VULKAN_HPP_NOEXCEPT
{
- return ~( VideoEncodeH264CapabilitiesFlagsEXT( bits ) );
+ return ~( VideoEncodeH264CapabilityFlagsEXT( bits ) );
}
- VULKAN_HPP_INLINE std::string to_string( VideoEncodeH264CapabilitiesFlagsEXT value )
+ VULKAN_HPP_INLINE std::string to_string( VideoEncodeH264CapabilityFlagsEXT value )
{
if ( !value )
return "{}";
std::string result;
- if ( value & VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityCabac )
- result += "VkVideoEncodeH264CapabilityCabac | ";
- if ( value & VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityCavlc )
- result += "VkVideoEncodeH264CapabilityCavlc | ";
- if ( value & VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityWeightedBiPredImplicit )
- result += "VkVideoEncodeH264CapabilityWeightedBiPredImplicit | ";
- if ( value & VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityTransform8X8 )
- result += "VkVideoEncodeH264CapabilityTransform8X8 | ";
- if ( value & VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityChromaQpOffset )
- result += "VkVideoEncodeH264CapabilityChromaQpOffset | ";
- if ( value & VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilitySecondChromaQpOffset )
- result += "VkVideoEncodeH264CapabilitySecondChromaQpOffset | ";
- if ( value & VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityDeblockingFilterDisabled )
- result += "VkVideoEncodeH264CapabilityDeblockingFilterDisabled | ";
- if ( value & VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityDeblockingFilterEnabled )
- result += "VkVideoEncodeH264CapabilityDeblockingFilterEnabled | ";
- if ( value & VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityDeblockingFilterPartial )
- result += "VkVideoEncodeH264CapabilityDeblockingFilterPartial | ";
- if ( value & VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityMultipleSlicePerFrame )
- result += "VkVideoEncodeH264CapabilityMultipleSlicePerFrame | ";
- if ( value & VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityEvenlyDistributedSliceSize )
- result += "VkVideoEncodeH264CapabilityEvenlyDistributedSliceSize | ";
+ if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eCabac )
+ result += "Cabac | ";
+ if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eCavlc )
+ result += "Cavlc | ";
+ if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eWeightedBiPredImplicit )
+ result += "WeightedBiPredImplicit | ";
+ if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eTransform8X8 )
+ result += "Transform8X8 | ";
+ if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eChromaQpOffset )
+ result += "ChromaQpOffset | ";
+ if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eSecondChromaQpOffset )
+ result += "SecondChromaQpOffset | ";
+ if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eDeblockingFilterDisabled )
+ result += "DeblockingFilterDisabled | ";
+ if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eDeblockingFilterEnabled )
+ result += "DeblockingFilterEnabled | ";
+ if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eDeblockingFilterPartial )
+ result += "DeblockingFilterPartial | ";
+ if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eMultipleSlicePerFrame )
+ result += "MultipleSlicePerFrame | ";
+ if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eEvenlyDistributedSliceSize )
+ result += "EvenlyDistributedSliceSize | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
#if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== VK_EXT_video_decode_h264 ===
- using VideoDecodeH264FieldLayoutFlagsEXT = Flags<VideoDecodeH264FieldLayoutFlagBitsEXT>;
+ using VideoDecodeH264PictureLayoutFlagsEXT = Flags<VideoDecodeH264PictureLayoutFlagBitsEXT>;
template <>
- struct FlagTraits<VideoDecodeH264FieldLayoutFlagBitsEXT>
+ struct FlagTraits<VideoDecodeH264PictureLayoutFlagBitsEXT>
{
enum : VkFlags
{
- allFlags = VkFlags( VideoDecodeH264FieldLayoutFlagBitsEXT::eVkVideoDecodeH264ProgressivePicturesOnly ) |
- VkFlags( VideoDecodeH264FieldLayoutFlagBitsEXT::eLineInterlacedPlane ) |
- VkFlags( VideoDecodeH264FieldLayoutFlagBitsEXT::eSeparateInterlacedPlane )
+ allFlags = VkFlags( VideoDecodeH264PictureLayoutFlagBitsEXT::eProgressive ) |
+ VkFlags( VideoDecodeH264PictureLayoutFlagBitsEXT::eInterlacedInterleavedLines ) |
+ VkFlags( VideoDecodeH264PictureLayoutFlagBitsEXT::eInterlacedSeparatePlanes )
};
};
- VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoDecodeH264FieldLayoutFlagsEXT operator|(
- VideoDecodeH264FieldLayoutFlagBitsEXT bit0, VideoDecodeH264FieldLayoutFlagBitsEXT bit1 ) VULKAN_HPP_NOEXCEPT
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoDecodeH264PictureLayoutFlagsEXT operator|(
+ VideoDecodeH264PictureLayoutFlagBitsEXT bit0, VideoDecodeH264PictureLayoutFlagBitsEXT bit1 ) VULKAN_HPP_NOEXCEPT
{
- return VideoDecodeH264FieldLayoutFlagsEXT( bit0 ) | bit1;
+ return VideoDecodeH264PictureLayoutFlagsEXT( bit0 ) | bit1;
}
- VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoDecodeH264FieldLayoutFlagsEXT
- operator&(VideoDecodeH264FieldLayoutFlagBitsEXT bit0, VideoDecodeH264FieldLayoutFlagBitsEXT bit1)VULKAN_HPP_NOEXCEPT
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoDecodeH264PictureLayoutFlagsEXT operator&(
+ VideoDecodeH264PictureLayoutFlagBitsEXT bit0, VideoDecodeH264PictureLayoutFlagBitsEXT bit1)VULKAN_HPP_NOEXCEPT
{
- return VideoDecodeH264FieldLayoutFlagsEXT( bit0 ) & bit1;
+ return VideoDecodeH264PictureLayoutFlagsEXT( bit0 ) & bit1;
}
- VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoDecodeH264FieldLayoutFlagsEXT operator^(
- VideoDecodeH264FieldLayoutFlagBitsEXT bit0, VideoDecodeH264FieldLayoutFlagBitsEXT bit1 ) VULKAN_HPP_NOEXCEPT
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoDecodeH264PictureLayoutFlagsEXT operator^(
+ VideoDecodeH264PictureLayoutFlagBitsEXT bit0, VideoDecodeH264PictureLayoutFlagBitsEXT bit1 ) VULKAN_HPP_NOEXCEPT
{
- return VideoDecodeH264FieldLayoutFlagsEXT( bit0 ) ^ bit1;
+ return VideoDecodeH264PictureLayoutFlagsEXT( bit0 ) ^ bit1;
}
- VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoDecodeH264FieldLayoutFlagsEXT
- operator~( VideoDecodeH264FieldLayoutFlagBitsEXT bits ) VULKAN_HPP_NOEXCEPT
+ VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoDecodeH264PictureLayoutFlagsEXT
+ operator~( VideoDecodeH264PictureLayoutFlagBitsEXT bits ) VULKAN_HPP_NOEXCEPT
{
- return ~( VideoDecodeH264FieldLayoutFlagsEXT( bits ) );
+ return ~( VideoDecodeH264PictureLayoutFlagsEXT( bits ) );
}
- VULKAN_HPP_INLINE std::string to_string( VideoDecodeH264FieldLayoutFlagsEXT value )
+ VULKAN_HPP_INLINE std::string to_string( VideoDecodeH264PictureLayoutFlagsEXT value )
{
if ( !value )
return "{}";
std::string result;
- if ( value & VideoDecodeH264FieldLayoutFlagBitsEXT::eLineInterlacedPlane )
- result += "LineInterlacedPlane | ";
- if ( value & VideoDecodeH264FieldLayoutFlagBitsEXT::eSeparateInterlacedPlane )
- result += "SeparateInterlacedPlane | ";
+ if ( value & VideoDecodeH264PictureLayoutFlagBitsEXT::eInterlacedInterleavedLines )
+ result += "InterlacedInterleavedLines | ";
+ if ( value & VideoDecodeH264PictureLayoutFlagBitsEXT::eInterlacedSeparatePlanes )
+ result += "InterlacedSeparatePlanes | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }";
}
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoCapabilitiesKHR;
# if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
- VULKAN_HPP_CONSTEXPR VideoCapabilitiesKHR( VULKAN_HPP_NAMESPACE::VideoCapabilitiesFlagsKHR capabilityFlags_ = {},
+ VULKAN_HPP_CONSTEXPR VideoCapabilitiesKHR( VULKAN_HPP_NAMESPACE::VideoCapabilityFlagsKHR capabilityFlags_ = {},
VULKAN_HPP_NAMESPACE::DeviceSize minBitstreamBufferOffsetAlignment_ = {},
VULKAN_HPP_NAMESPACE::DeviceSize minBitstreamBufferSizeAlignment_ = {},
VULKAN_HPP_NAMESPACE::Extent2D videoPictureExtentGranularity_ = {},
# endif
public:
- VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoCapabilitiesKHR;
- void * pNext = {};
- VULKAN_HPP_NAMESPACE::VideoCapabilitiesFlagsKHR capabilityFlags = {};
- VULKAN_HPP_NAMESPACE::DeviceSize minBitstreamBufferOffsetAlignment = {};
- VULKAN_HPP_NAMESPACE::DeviceSize minBitstreamBufferSizeAlignment = {};
- VULKAN_HPP_NAMESPACE::Extent2D videoPictureExtentGranularity = {};
- VULKAN_HPP_NAMESPACE::Extent2D minExtent = {};
- VULKAN_HPP_NAMESPACE::Extent2D maxExtent = {};
- uint32_t maxReferencePicturesSlotsCount = {};
- uint32_t maxReferencePicturesActiveCount = {};
+ VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoCapabilitiesKHR;
+ void * pNext = {};
+ VULKAN_HPP_NAMESPACE::VideoCapabilityFlagsKHR capabilityFlags = {};
+ VULKAN_HPP_NAMESPACE::DeviceSize minBitstreamBufferOffsetAlignment = {};
+ VULKAN_HPP_NAMESPACE::DeviceSize minBitstreamBufferSizeAlignment = {};
+ VULKAN_HPP_NAMESPACE::Extent2D videoPictureExtentGranularity = {};
+ VULKAN_HPP_NAMESPACE::Extent2D minExtent = {};
+ VULKAN_HPP_NAMESPACE::Extent2D maxExtent = {};
+ uint32_t maxReferencePicturesSlotsCount = {};
+ uint32_t maxReferencePicturesActiveCount = {};
};
static_assert( sizeof( VideoCapabilitiesKHR ) == sizeof( VkVideoCapabilitiesKHR ),
"struct and wrapper have different size!" );
# if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR VideoDecodeH264ProfileEXT(
- StdVideoH264ProfileIdc stdProfileIdc_ = {},
- VULKAN_HPP_NAMESPACE::VideoDecodeH264FieldLayoutFlagsEXT fieldLayout_ = {} ) VULKAN_HPP_NOEXCEPT
+ StdVideoH264ProfileIdc stdProfileIdc_ = {},
+ VULKAN_HPP_NAMESPACE::VideoDecodeH264PictureLayoutFlagsEXT pictureLayout_ = {} ) VULKAN_HPP_NOEXCEPT
: stdProfileIdc( stdProfileIdc_ )
- , fieldLayout( fieldLayout_ )
+ , pictureLayout( pictureLayout_ )
{}
VULKAN_HPP_CONSTEXPR
}
VideoDecodeH264ProfileEXT &
- setFieldLayout( VULKAN_HPP_NAMESPACE::VideoDecodeH264FieldLayoutFlagsEXT fieldLayout_ ) VULKAN_HPP_NOEXCEPT
+ setPictureLayout( VULKAN_HPP_NAMESPACE::VideoDecodeH264PictureLayoutFlagsEXT pictureLayout_ ) VULKAN_HPP_NOEXCEPT
{
- fieldLayout = fieldLayout_;
+ pictureLayout = pictureLayout_;
return *this;
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
{
return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
( memcmp( &stdProfileIdc, &rhs.stdProfileIdc, sizeof( StdVideoH264ProfileIdc ) ) == 0 ) &&
- ( fieldLayout == rhs.fieldLayout );
+ ( pictureLayout == rhs.pictureLayout );
}
bool operator!=( VideoDecodeH264ProfileEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
# endif
public:
- VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoDecodeH264ProfileEXT;
- const void * pNext = {};
- StdVideoH264ProfileIdc stdProfileIdc = {};
- VULKAN_HPP_NAMESPACE::VideoDecodeH264FieldLayoutFlagsEXT fieldLayout = {};
+ VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoDecodeH264ProfileEXT;
+ const void * pNext = {};
+ StdVideoH264ProfileIdc stdProfileIdc = {};
+ VULKAN_HPP_NAMESPACE::VideoDecodeH264PictureLayoutFlagsEXT pictureLayout = {};
};
static_assert( sizeof( VideoDecodeH264ProfileEXT ) == sizeof( VkVideoDecodeH264ProfileEXT ),
"struct and wrapper have different size!" );
# if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264CapabilitiesEXT(
- VULKAN_HPP_NAMESPACE::VideoEncodeH264CapabilitiesFlagsEXT flags_ = {},
- VULKAN_HPP_NAMESPACE::VideoEncodeH264InputModeFlagsEXT inputModeFlags_ = {},
- VULKAN_HPP_NAMESPACE::VideoEncodeH264OutputModeFlagsEXT outputModeFlags_ = {},
- VULKAN_HPP_NAMESPACE::Extent2D minPictureSizeInMbs_ = {},
- VULKAN_HPP_NAMESPACE::Extent2D maxPictureSizeInMbs_ = {},
- VULKAN_HPP_NAMESPACE::Extent2D inputImageDataAlignment_ = {},
- uint8_t maxNumL0ReferenceForP_ = {},
- uint8_t maxNumL0ReferenceForB_ = {},
- uint8_t maxNumL1Reference_ = {},
- uint8_t qualityLevelCount_ = {},
- VULKAN_HPP_NAMESPACE::ExtensionProperties stdExtensionVersion_ = {} ) VULKAN_HPP_NOEXCEPT
+ VULKAN_HPP_NAMESPACE::VideoEncodeH264CapabilityFlagsEXT flags_ = {},
+ VULKAN_HPP_NAMESPACE::VideoEncodeH264InputModeFlagsEXT inputModeFlags_ = {},
+ VULKAN_HPP_NAMESPACE::VideoEncodeH264OutputModeFlagsEXT outputModeFlags_ = {},
+ VULKAN_HPP_NAMESPACE::Extent2D minPictureSizeInMbs_ = {},
+ VULKAN_HPP_NAMESPACE::Extent2D maxPictureSizeInMbs_ = {},
+ VULKAN_HPP_NAMESPACE::Extent2D inputImageDataAlignment_ = {},
+ uint8_t maxNumL0ReferenceForP_ = {},
+ uint8_t maxNumL0ReferenceForB_ = {},
+ uint8_t maxNumL1Reference_ = {},
+ uint8_t qualityLevelCount_ = {},
+ VULKAN_HPP_NAMESPACE::ExtensionProperties stdExtensionVersion_ = {} ) VULKAN_HPP_NOEXCEPT
: flags( flags_ )
, inputModeFlags( inputModeFlags_ )
, outputModeFlags( outputModeFlags_ )
}
VideoEncodeH264CapabilitiesEXT &
- setFlags( VULKAN_HPP_NAMESPACE::VideoEncodeH264CapabilitiesFlagsEXT flags_ ) VULKAN_HPP_NOEXCEPT
+ setFlags( VULKAN_HPP_NAMESPACE::VideoEncodeH264CapabilityFlagsEXT flags_ ) VULKAN_HPP_NOEXCEPT
{
flags = flags_;
return *this;
# endif
public:
- VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeH264CapabilitiesEXT;
- const void * pNext = {};
- VULKAN_HPP_NAMESPACE::VideoEncodeH264CapabilitiesFlagsEXT flags = {};
- VULKAN_HPP_NAMESPACE::VideoEncodeH264InputModeFlagsEXT inputModeFlags = {};
- VULKAN_HPP_NAMESPACE::VideoEncodeH264OutputModeFlagsEXT outputModeFlags = {};
- VULKAN_HPP_NAMESPACE::Extent2D minPictureSizeInMbs = {};
- VULKAN_HPP_NAMESPACE::Extent2D maxPictureSizeInMbs = {};
- VULKAN_HPP_NAMESPACE::Extent2D inputImageDataAlignment = {};
- uint8_t maxNumL0ReferenceForP = {};
- uint8_t maxNumL0ReferenceForB = {};
- uint8_t maxNumL1Reference = {};
- uint8_t qualityLevelCount = {};
- VULKAN_HPP_NAMESPACE::ExtensionProperties stdExtensionVersion = {};
+ VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeH264CapabilitiesEXT;
+ const void * pNext = {};
+ VULKAN_HPP_NAMESPACE::VideoEncodeH264CapabilityFlagsEXT flags = {};
+ VULKAN_HPP_NAMESPACE::VideoEncodeH264InputModeFlagsEXT inputModeFlags = {};
+ VULKAN_HPP_NAMESPACE::VideoEncodeH264OutputModeFlagsEXT outputModeFlags = {};
+ VULKAN_HPP_NAMESPACE::Extent2D minPictureSizeInMbs = {};
+ VULKAN_HPP_NAMESPACE::Extent2D maxPictureSizeInMbs = {};
+ VULKAN_HPP_NAMESPACE::Extent2D inputImageDataAlignment = {};
+ uint8_t maxNumL0ReferenceForP = {};
+ uint8_t maxNumL0ReferenceForB = {};
+ uint8_t maxNumL1Reference = {};
+ uint8_t qualityLevelCount = {};
+ VULKAN_HPP_NAMESPACE::ExtensionProperties stdExtensionVersion = {};
};
static_assert( sizeof( VideoEncodeH264CapabilitiesEXT ) == sizeof( VkVideoEncodeH264CapabilitiesEXT ),
"struct and wrapper have different size!" );
{
"version info": {
"schema version": 2,
- "api version": "1.2.186",
- "comment": "from git branch: github-main commit: 907c556530050b0f4af073753335f23c885c02bf",
- "date": "2021-07-27 09:51:57Z"
+ "api version": "1.2.187",
+ "comment": "from git branch: github-main commit: cd8da6a515811c4ff9e1f10a6d6ce4ab968333fb",
+ "date": "2021-08-03 11:15:40Z"
},
"validation": {
"vkGetInstanceProcAddr": {
},
{
"vuid": "VUID-vkGetDeviceQueue-queueIndex-00385",
- "text": " <code>queueIndex</code> <strong class=\"purple\">must</strong> be less than the number of queues created for the specified queue family index when <code>device</code> was created, via the <code>queueCount</code> member of the <a href=\"#VkDeviceQueueCreateInfo\">VkDeviceQueueCreateInfo</a> structure"
+ "text": " <code>queueIndex</code> <strong class=\"purple\">must</strong> be less than the value of <a href=\"#VkDeviceQueueCreateInfo\">VkDeviceQueueCreateInfo</a>::<code>queueCount</code> for the queue family indicated by <code>queueFamilyIndex</code> when <code>device</code> was created"
},
{
"vuid": "VUID-vkGetDeviceQueue-flags-01841",
"text": " <code>queueFamilyIndex</code> <strong class=\"purple\">must</strong> be one of the queue family indices specified when <code>device</code> was created, via the <a href=\"#VkDeviceQueueCreateInfo\">VkDeviceQueueCreateInfo</a> structure"
},
{
+ "vuid": "VUID-VkDeviceQueueInfo2-flags-06225",
+ "text": " <code>flags</code> <strong class=\"purple\">must</strong> be equal to <a href=\"#VkDeviceQueueCreateInfo\">VkDeviceQueueCreateInfo</a>::<code>flags</code> for a <a href=\"#VkDeviceQueueCreateInfo\">VkDeviceQueueCreateInfo</a> structure for the queue family indicated by <code>queueFamilyIndex</code> when <code>device</code> was created"
+ },
+ {
"vuid": "VUID-VkDeviceQueueInfo2-queueIndex-01843",
- "text": " <code>queueIndex</code> <strong class=\"purple\">must</strong> be less than the number of queues created for the specified queue family index and <a href=\"#VkDeviceQueueCreateFlags\">VkDeviceQueueCreateFlags</a> member <code>flags</code> equal to this <code>flags</code> value when <code>device</code> was created, via the <code>queueCount</code> member of the <a href=\"#VkDeviceQueueCreateInfo\">VkDeviceQueueCreateInfo</a> structure"
+ "text": " <code>queueIndex</code> <strong class=\"purple\">must</strong> be less than <a href=\"#VkDeviceQueueCreateInfo\">VkDeviceQueueCreateInfo</a>::<code>queueCount</code> for the corresponding queue family and flags indicated by <code>queueFamilyIndex</code> and <code>flags</code> when <code>device</code> was created"
},
{
"vuid": "VUID-VkDeviceQueueInfo2-sType-sType",
"text": " If the <a href=\"#features-tessellationShader\">tessellation shaders</a> feature is not enabled, pname:stageMask <strong class=\"purple\">must</strong> not contain <code>VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT</code> or <code>VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT</code>"
},
{
- "vuid": "VUID-vkCmdSetEvent-stageMask-4098",
+ "vuid": "VUID-vkCmdSetEvent-stageMask-04098",
"text": " Any pipeline stage included in pname:stageMask <strong class=\"purple\">must</strong> be supported by the capabilities of the queue family specified by the <code>queueFamilyIndex</code> member of the <a href=\"#VkCommandPoolCreateInfo\">VkCommandPoolCreateInfo</a> structure that was used to create the <code>VkCommandPool</code> that <code>commandBuffer</code> was allocated from, as specified in the <a href=\"#synchronization-pipeline-stages-supported\">table of supported pipeline stages</a>"
},
{
"text": " If the <a href=\"#features-tessellationShader\">tessellation shaders</a> feature is not enabled, pname:stageMask <strong class=\"purple\">must</strong> not contain <code>VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT</code> or <code>VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT</code>"
},
{
- "vuid": "VUID-vkCmdResetEvent-stageMask-4098",
+ "vuid": "VUID-vkCmdResetEvent-stageMask-04098",
"text": " Any pipeline stage included in pname:stageMask <strong class=\"purple\">must</strong> be supported by the capabilities of the queue family specified by the <code>queueFamilyIndex</code> member of the <a href=\"#VkCommandPoolCreateInfo\">VkCommandPoolCreateInfo</a> structure that was used to create the <code>VkCommandPool</code> that <code>commandBuffer</code> was allocated from, as specified in the <a href=\"#synchronization-pipeline-stages-supported\">table of supported pipeline stages</a>"
},
{
"text": " If the <a href=\"#features-tessellationShader\">tessellation shaders</a> feature is not enabled, pname:srcStageMask <strong class=\"purple\">must</strong> not contain <code>VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT</code> or <code>VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT</code>"
},
{
- "vuid": "VUID-vkCmdWaitEvents-srcStageMask-4098",
+ "vuid": "VUID-vkCmdWaitEvents-srcStageMask-04098",
"text": " Any pipeline stage included in pname:srcStageMask <strong class=\"purple\">must</strong> be supported by the capabilities of the queue family specified by the <code>queueFamilyIndex</code> member of the <a href=\"#VkCommandPoolCreateInfo\">VkCommandPoolCreateInfo</a> structure that was used to create the <code>VkCommandPool</code> that <code>commandBuffer</code> was allocated from, as specified in the <a href=\"#synchronization-pipeline-stages-supported\">table of supported pipeline stages</a>"
},
{
"text": " If the <a href=\"#features-tessellationShader\">tessellation shaders</a> feature is not enabled, pname:dstStageMask <strong class=\"purple\">must</strong> not contain <code>VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT</code> or <code>VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT</code>"
},
{
- "vuid": "VUID-vkCmdWaitEvents-dstStageMask-4098",
+ "vuid": "VUID-vkCmdWaitEvents-dstStageMask-04098",
"text": " Any pipeline stage included in pname:dstStageMask <strong class=\"purple\">must</strong> be supported by the capabilities of the queue family specified by the <code>queueFamilyIndex</code> member of the <a href=\"#VkCommandPoolCreateInfo\">VkCommandPoolCreateInfo</a> structure that was used to create the <code>VkCommandPool</code> that <code>commandBuffer</code> was allocated from, as specified in the <a href=\"#synchronization-pipeline-stages-supported\">table of supported pipeline stages</a>"
},
{
"text": " If the <a href=\"#features-tessellationShader\">tessellation shaders</a> feature is not enabled, pname:srcStageMask <strong class=\"purple\">must</strong> not contain <code>VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT</code> or <code>VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT</code>"
},
{
- "vuid": "VUID-vkCmdPipelineBarrier-srcStageMask-4098",
+ "vuid": "VUID-vkCmdPipelineBarrier-srcStageMask-04098",
"text": " Any pipeline stage included in pname:srcStageMask <strong class=\"purple\">must</strong> be supported by the capabilities of the queue family specified by the <code>queueFamilyIndex</code> member of the <a href=\"#VkCommandPoolCreateInfo\">VkCommandPoolCreateInfo</a> structure that was used to create the <code>VkCommandPool</code> that <code>commandBuffer</code> was allocated from, as specified in the <a href=\"#synchronization-pipeline-stages-supported\">table of supported pipeline stages</a>"
},
{
"text": " If the <a href=\"#features-tessellationShader\">tessellation shaders</a> feature is not enabled, pname:dstStageMask <strong class=\"purple\">must</strong> not contain <code>VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT</code> or <code>VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT</code>"
},
{
- "vuid": "VUID-vkCmdPipelineBarrier-dstStageMask-4098",
+ "vuid": "VUID-vkCmdPipelineBarrier-dstStageMask-04098",
"text": " Any pipeline stage included in pname:dstStageMask <strong class=\"purple\">must</strong> be supported by the capabilities of the queue family specified by the <code>queueFamilyIndex</code> member of the <a href=\"#VkCommandPoolCreateInfo\">VkCommandPoolCreateInfo</a> structure that was used to create the <code>VkCommandPool</code> that <code>commandBuffer</code> was allocated from, as specified in the <a href=\"#synchronization-pipeline-stages-supported\">table of supported pipeline stages</a>"
},
{
},
{
"vuid": "VUID-VkRenderPassBeginInfo-renderArea-02848",
- "text": " <span class=\"eq\"><code>renderArea.offset.x</code> + <code>renderArea.
offset.width</code></span> <strong class=\"purple\">must</strong> be less than or equal to <a href=\"#VkFramebufferCreateInfo\">VkFramebufferCreateInfo</a>::<code>width</code> the <code>framebuffer</code> was created with"
+ "text": " <span class=\"eq\"><code>renderArea.offset.x</code> + <code>renderArea.
extent.width</code></span> <strong class=\"purple\">must</strong> be less than or equal to <a href=\"#VkFramebufferCreateInfo\">VkFramebufferCreateInfo</a>::<code>width</code> the <code>framebuffer</code> was created with"
},
{
"vuid": "VUID-VkRenderPassBeginInfo-renderArea-02849",
- "text": " <span class=\"eq\"><code>renderArea.offset.y</code> + <code>renderArea.
offset.height</code></span> <strong class=\"purple\">must</strong> be less than or equal to <a href=\"#VkFramebufferCreateInfo\">VkFramebufferCreateInfo</a>::<code>height</code> the <code>framebuffer</code> was created with"
+ "text": " <span class=\"eq\"><code>renderArea.offset.y</code> + <code>renderArea.
extent.height</code></span> <strong class=\"purple\">must</strong> be less than or equal to <a href=\"#VkFramebufferCreateInfo\">VkFramebufferCreateInfo</a>::<code>height</code> the <code>framebuffer</code> was created with"
}
],
"(VK_VERSION_1_1,VK_KHR_device_group)": [
},
{
"vuid": "VUID-VkRenderPassBeginInfo-pNext-02852",
- "text": " If the <code>pNext</code> chain does not contain <a href=\"#VkDeviceGroupRenderPassBeginInfo\">VkDeviceGroupRenderPassBeginInfo</a> or its <code>deviceRenderAreaCount</code> member is equal to 0, <span class=\"eq\"><code>renderArea.offset.x</code> + <code>renderArea.
offset.width</code></span> <strong class=\"purple\">must</strong> be less than or equal to <a href=\"#VkFramebufferCreateInfo\">VkFramebufferCreateInfo</a>::<code>width</code> the <code>framebuffer</code> was created with"
+ "text": " If the <code>pNext</code> chain does not contain <a href=\"#VkDeviceGroupRenderPassBeginInfo\">VkDeviceGroupRenderPassBeginInfo</a> or its <code>deviceRenderAreaCount</code> member is equal to 0, <span class=\"eq\"><code>renderArea.offset.x</code> + <code>renderArea.
extent.width</code></span> <strong class=\"purple\">must</strong> be less than or equal to <a href=\"#VkFramebufferCreateInfo\">VkFramebufferCreateInfo</a>::<code>width</code> the <code>framebuffer</code> was created with"
},
{
"vuid": "VUID-VkRenderPassBeginInfo-pNext-02853",
- "text": " If the <code>pNext</code> chain does not contain <a href=\"#VkDeviceGroupRenderPassBeginInfo\">VkDeviceGroupRenderPassBeginInfo</a> or its <code>deviceRenderAreaCount</code> member is equal to 0, <span class=\"eq\"><code>renderArea.offset.y</code> + <code>renderArea.
offset.height</code></span> <strong class=\"purple\">must</strong> be less than or equal to <a href=\"#VkFramebufferCreateInfo\">VkFramebufferCreateInfo</a>::<code>height</code> the <code>framebuffer</code> was created with"
+ "text": " If the <code>pNext</code> chain does not contain <a href=\"#VkDeviceGroupRenderPassBeginInfo\">VkDeviceGroupRenderPassBeginInfo</a> or its <code>deviceRenderAreaCount</code> member is equal to 0, <span class=\"eq\"><code>renderArea.offset.y</code> + <code>renderArea.
extent.height</code></span> <strong class=\"purple\">must</strong> be less than or equal to <a href=\"#VkFramebufferCreateInfo\">VkFramebufferCreateInfo</a>::<code>height</code> the <code>framebuffer</code> was created with"
},
{
"vuid": "VUID-VkRenderPassBeginInfo-pNext-02854",
},
{
"vuid": "VUID-VkRenderPassBeginInfo-pNext-02856",
- "text": " If the <code>pNext</code> chain contains <a href=\"#VkDeviceGroupRenderPassBeginInfo\">VkDeviceGroupRenderPassBeginInfo</a>, <span class=\"eq\"><code>offset.x</code> + <code>
offset.width</code></span> of each element of <code>pDeviceRenderAreas</code> <strong class=\"purple\">must</strong> be less than or equal to <a href=\"#VkFramebufferCreateInfo\">VkFramebufferCreateInfo</a>::<code>width</code> the <code>framebuffer</code> was created with"
+ "text": " If the <code>pNext</code> chain contains <a href=\"#VkDeviceGroupRenderPassBeginInfo\">VkDeviceGroupRenderPassBeginInfo</a>, <span class=\"eq\"><code>offset.x</code> + <code>
extent.width</code></span> of each element of <code>pDeviceRenderAreas</code> <strong class=\"purple\">must</strong> be less than or equal to <a href=\"#VkFramebufferCreateInfo\">VkFramebufferCreateInfo</a>::<code>width</code> the <code>framebuffer</code> was created with"
},
{
"vuid": "VUID-VkRenderPassBeginInfo-pNext-02857",
- "text": " If the <code>pNext</code> chain contains <a href=\"#VkDeviceGroupRenderPassBeginInfo\">VkDeviceGroupRenderPassBeginInfo</a>, <span class=\"eq\"><code>offset.y</code> + <code>
offset.height</code></span> of each element of <code>pDeviceRenderAreas</code> <strong class=\"purple\">must</strong> be less than or equal to <a href=\"#VkFramebufferCreateInfo\">VkFramebufferCreateInfo</a>::<code>height</code> the <code>framebuffer</code> was created with"
+ "text": " If the <code>pNext</code> chain contains <a href=\"#VkDeviceGroupRenderPassBeginInfo\">VkDeviceGroupRenderPassBeginInfo</a>, <span class=\"eq\"><code>offset.y</code> + <code>
extent.height</code></span> of each element of <code>pDeviceRenderAreas</code> <strong class=\"purple\">must</strong> be less than or equal to <a href=\"#VkFramebufferCreateInfo\">VkFramebufferCreateInfo</a>::<code>height</code> the <code>framebuffer</code> was created with"
}
],
"(VK_VERSION_1_2,VK_KHR_imageless_framebuffer)": [
"text": " The number of resources in <code>layout</code> accessible to each shader stage that is used by the pipeline <strong class=\"purple\">must</strong> be less than or equal to <a href=\"#VkPhysicalDeviceLimits\">VkPhysicalDeviceLimits</a>::<code>maxPerStageResources</code>"
},
{
- "vuid": "VUID-VkRayTracingPipelineCreateInfoNV-stage-03425",
+ "vuid": "VUID-VkRayTracingPipelineCreateInfoNV-stage-06232",
"text": " The <code>stage</code> member of at least one element of <code>pStages</code> <strong class=\"purple\">must</strong> be <code>VK_SHADER_STAGE_RAYGEN_BIT_KHR</code>"
},
{
"text": " If the parameters define an import operation and the external handle type is <code>VK_EXTERNAL_MEMORY_HANDLE_TYPE_ZIRCON_VMO_BIT_FUCHSIA</code>, the value of <code>allocationSize</code> <strong class=\"purple\">must</strong> be greater than <code>0</code> and <strong class=\"purple\">must</strong> be less than or equal to the size of the VMO as determined by <code>zx_vmo_get_size</code>(<code>handle</code>) where <code>handle</code> is the VMO handle to the imported external memory."
}
],
+ "(VK_KHR_maintenance3)": [
+ {
+ "vuid": "VUID-VkMemoryAllocateInfo-allocationSize-06231",
+ "text": " <code>allocationSize</code> <strong class=\"purple\">must</strong> be less than <a href=\"#VkPhysicalDeviceMaintenance3Properties\">VkPhysicalDeviceMaintenance3Properties</a>::<code>maxMemoryAllocationSize</code>."
+ }
+ ],
"core": [
{
"vuid": "VUID-VkMemoryAllocateInfo-sType-sType",
],
"core": [
{
- "vuid": "VUID-vkCmdCopyBufferToImage-pRegions-00172",
+ "vuid": "VUID-vkCmdCopyBufferToImage-pRegions-06217",
"text": " The image region specified by each element of <code>pRegions</code> <strong class=\"purple\">must</strong> be contained within the specified <code>imageSubresource</code> of <code>dstImage</code>"
},
{
"text": " If the queue family used to create the <a href=\"#VkCommandPool\">VkCommandPool</a> which <code>commandBuffer</code> was allocated from does not support <code>VK_QUEUE_GRAPHICS_BIT</code>, for each element of <code>pRegions</code>, the <code>aspectMask</code> member of <code>imageSubresource</code> <strong class=\"purple\">must</strong> not be <code>VK_IMAGE_ASPECT_DEPTH_BIT</code> or <code>VK_IMAGE_ASPECT_STENCIL_BIT</code>."
},
{
- "vuid": "VUID-vkCmdCopyBufferToImage-imageOffset-00197",
+ "vuid": "VUID-vkCmdCopyBufferToImage-pRegions-06218",
"text": " For each element of <code>pRegions</code>, <code>imageOffset.x</code> and <span class=\"eq\">(<code>imageExtent.width</code> + <code>imageOffset.x</code>)</span> <strong class=\"purple\">must</strong> both be greater than or equal to <code>0</code> and less than or equal to the width of the specified <code>imageSubresource</code> of <code>dstImage</code>"
},
{
- "vuid": "VUID-vkCmdCopyBufferToImage-imageOffset-00198",
+ "vuid": "VUID-vkCmdCopyBufferToImage-pRegions-06219",
"text": " For each element of <code>pRegions</code>, <code>imageOffset.y</code> and <span class=\"eq\">(<code>imageExtent.height</code> + <code>imageOffset.y</code>)</span> <strong class=\"purple\">must</strong> both be greater than or equal to <code>0</code> and less than or equal to the height of the specified <code>imageSubresource</code> of <code>dstImage</code>"
},
{
],
"core": [
{
- "vuid": "VUID-vkCmdCopyImageToBuffer-pRegions-00182",
+ "vuid": "VUID-vkCmdCopyImageToBuffer-pRegions-06220",
"text": " The image region specified by each element of <code>pRegions</code> <strong class=\"purple\">must</strong> be contained within the specified <code>imageSubresource</code> of <code>srcImage</code>"
},
{
"text": " The <code>imageOffset</code> and <code>imageExtent</code> members of each element of <code>pRegions</code> <strong class=\"purple\">must</strong> respect the image transfer granularity requirements of <code>commandBuffer</code>’s command pool’s queue family, as described in <a href=\"#VkQueueFamilyProperties\">VkQueueFamilyProperties</a>"
},
{
- "vuid": "VUID-vkCmdCopyImageToBuffer-imageOffset-00197",
+ "vuid": "VUID-vkCmdCopyImageToBuffer-pRegions-06221",
"text": " For each element of <code>pRegions</code>, <code>imageOffset.x</code> and <span class=\"eq\">(<code>imageExtent.width</code> + <code>imageOffset.x</code>)</span> <strong class=\"purple\">must</strong> both be greater than or equal to <code>0</code> and less than or equal to the width of the specified <code>imageSubresource</code> of <code>srcImage</code>"
},
{
- "vuid": "VUID-vkCmdCopyImageToBuffer-imageOffset-00198",
+ "vuid": "VUID-vkCmdCopyImageToBuffer-pRegions-06222",
"text": " For each element of <code>pRegions</code>, <code>imageOffset.y</code> and <span class=\"eq\">(imageExtent.height + <code>imageOffset.y</code>)</span> <strong class=\"purple\">must</strong> both be greater than or equal to <code>0</code> and less than or equal to the height of the specified <code>imageSubresource</code> of <code>srcImage</code>"
},
{
"text": " If the queue family used to create the <a href=\"#VkCommandPool\">VkCommandPool</a> which <code>commandBuffer</code> was allocated from does not support <code>VK_QUEUE_GRAPHICS_BIT</code>, for each element of <code>pRegions</code>, the <code>aspectMask</code> member of <code>imageSubresource</code> <strong class=\"purple\">must</strong> not be <code>VK_IMAGE_ASPECT_DEPTH_BIT</code> or <code>VK_IMAGE_ASPECT_STENCIL_BIT</code>."
},
{
- "vuid": "VUID-VkCopyBufferToImageInfo2KHR-imageOffset-00197",
+ "vuid": "VUID-VkCopyBufferToImageInfo2KHR-pRegions-06223",
"text": " For each element of <code>pRegions</code> not containing <a href=\"#VkCopyCommandTransformInfoQCOM\">VkCopyCommandTransformInfoQCOM</a> in its <code>pNext</code> chain, <code>imageOffset.x</code> and <span class=\"eq\">(<code>imageExtent.width</code> + <code>imageOffset.x</code>)</span> <strong class=\"purple\">must</strong> both be greater than or equal to <code>0</code> and less than or equal to the width of the specified <code>imageSubresource</code> of <code>dstImage</code>"
},
{
- "vuid": "VUID-VkCopyBufferToImageInfo2KHR-imageOffset-00198",
+ "vuid": "VUID-VkCopyBufferToImageInfo2KHR-pRegions-06224",
"text": " For each element of <code>pRegions</code> not containing <a href=\"#VkCopyCommandTransformInfoQCOM\">VkCopyCommandTransformInfoQCOM</a> in its <code>pNext</code> chain, <code>imageOffset.y</code> and <span class=\"eq\">(<code>imageExtent.height</code> + <code>imageOffset.y</code>)</span> <strong class=\"purple\">must</strong> both be greater than or equal to <code>0</code> and less than or equal to the height of the specified <code>imageSubresource</code> of <code>dstImage</code>"
},
{
"text": " If the <a href=\"#features-vertexAttributeInstanceRateDivisor\">vertexAttributeInstanceRateDivisor</a> feature is not enabled, <code>divisor</code> <strong class=\"purple\">must</strong> be <code>1</code>"
},
{
- "vuid": "VUID-VkVertexInputBindingDescription2EXT-divisor-04800",
+ "vuid": "VUID-VkVertexInputBindingDescription2EXT-divisor-06226",
"text": " <code>divisor</code> <strong class=\"purple\">must</strong> be a value between <code>0</code> and <code>VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT</code>::<code>maxVertexAttribDivisor</code>, inclusive"
},
{
- "vuid": "VUID-VkVertexInputBindingDescription2EXT-divisor-04801",
+ "vuid": "VUID-VkVertexInputBindingDescription2EXT-divisor-06227",
"text": " If <code>divisor</code> is not <code>1</code> then <code>inputRate</code> <strong class=\"purple\">must</strong> be of type <code>VK_VERTEX_INPUT_RATE_INSTANCE</code>"
},
{
"VkVertexInputAttributeDescription2EXT": {
"(VK_EXT_vertex_input_dynamic_state)": [
{
- "vuid": "VUID-VkVertexInputAttributeDescription2EXT-location-04802",
+ "vuid": "VUID-VkVertexInputAttributeDescription2EXT-location-06228",
"text": " <code>location</code> <strong class=\"purple\">must</strong> be less than <code>VkPhysicalDeviceLimits</code>::<code>maxVertexInputAttributes</code>"
},
{
- "vuid": "VUID-VkVertexInputAttributeDescription2EXT-binding-04803",
+ "vuid": "VUID-VkVertexInputAttributeDescription2EXT-binding-06229",
"text": " <code>binding</code> <strong class=\"purple\">must</strong> be less than <code>VkPhysicalDeviceLimits</code>::<code>maxVertexInputBindings</code>"
},
{
- "vuid": "VUID-VkVertexInputAttributeDescription2EXT-offset-04804",
+ "vuid": "VUID-VkVertexInputAttributeDescription2EXT-offset-06230",
"text": " <code>offset</code> <strong class=\"purple\">must</strong> be less than or equal to <code>VkPhysicalDeviceLimits</code>::<code>maxVertexInputAttributeOffset</code>"
},
{
"text": " All acceleration structures in <code>pAccelerationStructures</code> <strong class=\"purple\">must</strong> have been built prior to the execution of this command"
},
{
- "vuid": "VUID-vkCmdWriteAccelerationStructuresPropertiesNV-accelerationStructures-03431",
+ "vuid": "VUID-vkCmdWriteAccelerationStructuresPropertiesNV-pAccelerationStructures-06215",
"text": " All acceleration structures in <code>pAccelerationStructures</code> <strong class=\"purple\">must</strong> have been built with <code>VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_KHR</code> if <code>queryType</code> is <code>VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV</code>"
},
{
- "vuid": "VUID-vkCmdWriteAccelerationStructuresPropertiesNV-queryType-03432",
+ "vuid": "VUID-vkCmdWriteAccelerationStructuresPropertiesNV-queryType-06216",
"text": " <code>queryType</code> <strong class=\"purple\">must</strong> be <code>VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV</code>"
},
{
},
{
"vuid": "VUID-vkCmdTraceRaysNV-maxRecursionDepth-03625",
- "text": " This command <strong class=\"purple\">must</strong> not cause a trace ray instruction to be executed from a shader invocation with a <a href=\"#ray-tracing-recursion-depth\">recursion depth</a> greater than the value of <code>maxRecursionDepth</code> used to create the bound ray tracing pipeline"
+ "text": " This command <strong class=\"purple\">must</strong> not cause a
pipeline trace ray instruction to be executed from a shader invocation with a <a href=\"#ray-tracing-recursion-depth\">recursion depth</a> greater than the value of <code>maxRecursionDepth</code> used to create the bound ray tracing pipeline"
},
{
"vuid": "VUID-vkCmdTraceRaysNV-raygenShaderBindingTableBuffer-04042",
"text": " <code>sType</code> <strong class=\"purple\">must</strong> be <code>VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_EXT</code>"
},
{
- "vuid": "VUID-VkVideoDecodeH264ProfileEXT-fieldLayout-parameter",
- "text": " <code>fieldLayout</code> <strong class=\"purple\">must</strong> be a valid combination of <a href=\"#VkVideoDecodeH264FieldLayoutFlagBitsEXT\">VkVideoDecodeH264FieldLayoutFlagBitsEXT</a> values"
+ "vuid": "VUID-VkVideoDecodeH264ProfileEXT-pictureLayout-parameter",
+ "text": " <code>pictureLayout</code> <strong class=\"purple\">must</strong> be a valid combination of <a href=\"#VkVideoDecodeH264PictureLayoutFlagBitsEXT\">VkVideoDecodeH264PictureLayoutFlagBitsEXT</a> values"
},
{
- "vuid": "VUID-VkVideoDecodeH264ProfileEXT-fieldLayout-requiredbitmask",
- "text": " <code>fieldLayout</code> <strong class=\"purple\">must</strong> not be <code>0</code>"
+ "vuid": "VUID-VkVideoDecodeH264ProfileEXT-pictureLayout-requiredbitmask",
+ "text": " <code>pictureLayout</code> <strong class=\"purple\">must</strong> not be <code>0</code>"
}
]
},
},
{
"vuid": "VUID-VkVideoEncodeH264CapabilitiesEXT-flags-parameter",
- "text": " <code>flags</code> <strong class=\"purple\">must</strong> be a valid combination of <a href=\"#VkVideoEncodeH264CapabilitiesFlagBitsEXT\">VkVideoEncodeH264CapabilitiesFlagBitsEXT</a> values"
+ "text": " <code>flags</code> <strong class=\"purple\">must</strong> be a valid combination of <a href=\"#VkVideoEncodeH264CapabilityFlagBitsEXT\">VkVideoEncodeH264CapabilityFlagBitsEXT</a> values"
},
{
"vuid": "VUID-VkVideoEncodeH264CapabilitiesEXT-flags-requiredbitmask",
<type category="define" requires="VK_MAKE_API_VERSION">// Vulkan 1.2 version number
#define <name>VK_API_VERSION_1_2</name> <type>VK_MAKE_API_VERSION</type>(0, 1, 2, 0)// Patch version should always be set to 0</type>
<type category="define">// Version of this file
-#define <name>VK_HEADER_VERSION</name> 186</type>
+#define <name>VK_HEADER_VERSION</name> 187</type>
<type category="define" requires="VK_HEADER_VERSION">// Complete version of this file
#define <name>VK_HEADER_VERSION_COMPLETE</name> <type>VK_MAKE_API_VERSION</type>(0, 1, 2, VK_HEADER_VERSION)</type>
<comment>Video Core extension</comment>
<type requires="VkVideoCodecOperationFlagBitsKHR" category="bitmask">typedef <type>VkFlags</type> <name>VkVideoCodecOperationFlagsKHR</name>;</type>
- <type requires="VkVideoCapabilitiesFlagBitsKHR" category="bitmask">typedef <type>VkFlags</type> <name>VkVideoCapabilitiesFlagsKHR</name>;</type>
+ <type requires="VkVideoCapabilityFlagBitsKHR" category="bitmask">typedef <type>VkFlags</type> <name>VkVideoCapabilityFlagsKHR</name>;</type>
<type requires="VkVideoSessionCreateFlagBitsKHR" category="bitmask">typedef <type>VkFlags</type> <name>VkVideoSessionCreateFlagsKHR</name>;</type>
<type category="bitmask">typedef <type>VkFlags</type> <name>VkVideoBeginCodingFlagsKHR</name>;</type>
<type category="bitmask">typedef <type>VkFlags</type> <name>VkVideoEndCodingFlagsKHR</name>;</type>
<type requires="VkVideoDecodeFlagBitsKHR" category="bitmask">typedef <type>VkFlags</type> <name>VkVideoDecodeFlagsKHR</name>;</type>
<comment>Video Decode H.264 extension</comment>
- <type requires="VkVideoDecodeH264FieldLayoutFlagBitsEXT" category="bitmask">typedef <type>VkFlags</type> <name>VkVideoDecodeH264FieldLayoutFlagsEXT</name>;</type>
+ <type requires="VkVideoDecodeH264PictureLayoutFlagBitsEXT" category="bitmask">typedef <type>VkFlags</type> <name>VkVideoDecodeH264PictureLayoutFlagsEXT</name>;</type>
<type category="bitmask">typedef <type>VkFlags</type> <name>VkVideoDecodeH264CreateFlagsEXT</name>;</type>
<comment>Video Decode H.265 extension</comment>
<type requires="VkVideoComponentBitDepthFlagBitsKHR" category="bitmask">typedef <type>VkFlags</type> <name>VkVideoComponentBitDepthFlagsKHR</name>;</type>
<comment>Video Encode H.264 extension</comment>
- <type requires="VkVideoEncodeH264CapabilitiesFlagBitsEXT" category="bitmask">typedef <type>VkFlags</type> <name>VkVideoEncodeH264CapabilitiesFlagsEXT</name>;</type>
+ <type requires="VkVideoEncodeH264CapabilityFlagBitsEXT" category="bitmask">typedef <type>VkFlags</type> <name>VkVideoEncodeH264CapabilityFlagsEXT</name>;</type>
<type requires="VkVideoEncodeH264InputModeFlagBitsEXT" category="bitmask">typedef <type>VkFlags</type> <name>VkVideoEncodeH264InputModeFlagsEXT</name>;</type>
<type requires="VkVideoEncodeH264OutputModeFlagBitsEXT" category="bitmask">typedef <type>VkFlags</type> <name>VkVideoEncodeH264OutputModeFlagsEXT</name>;</type>
<type requires="VkVideoEncodeH264CreateFlagBitsEXT" category="bitmask">typedef <type>VkFlags</type> <name>VkVideoEncodeH264CreateFlagsEXT</name>;</type>
<type name="VkVideoCodecOperationFlagBitsKHR" category="enum"/>
<type name="VkVideoChromaSubsamplingFlagBitsKHR" category="enum"/>
<type name="VkVideoComponentBitDepthFlagBitsKHR" category="enum"/>
- <type name="VkVideoCapabilitiesFlagBitsKHR" category="enum"/>
+ <type name="VkVideoCapabilityFlagBitsKHR" category="enum"/>
<type name="VkVideoSessionCreateFlagBitsKHR" category="enum"/>
<type name="VkVideoCodingQualityPresetFlagBitsKHR" category="enum"/>
<type name="VkVideoCodingControlFlagBitsKHR" category="enum"/>
<type name="VkVideoDecodeFlagBitsKHR" category="enum"/>
<comment>Video H.264 Decode extensions</comment>
- <type name="VkVideoDecodeH264FieldLayoutFlagBitsEXT" category="enum"/>
+ <type name="VkVideoDecodeH264PictureLayoutFlagBitsEXT" category="enum"/>
<comment>Video H.265 Decode extensions</comment>
<type name="VkVideoEncodeRateControlModeFlagBitsKHR" category="enum"/>
<comment>Video H.264 Encode extensions</comment>
- <type name="VkVideoEncodeH264CapabilitiesFlagBitsEXT" category="enum"/>
+ <type name="VkVideoEncodeH264CapabilityFlagBitsEXT" category="enum"/>
<type name="VkVideoEncodeH264InputModeFlagBitsEXT" category="enum"/>
<type name="VkVideoEncodeH264OutputModeFlagBitsEXT" category="enum"/>
<type name="VkVideoEncodeH264CreateFlagBitsEXT" category="enum"/>
<type category="struct" name="VkVideoCapabilitiesKHR" returnedonly="true">
<member values="VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR"><type>VkStructureType</type><name>sType</name></member>
<member><type>void</type>* <name>pNext</name></member>
- <member><type>VkVideoCapabilitiesFlagsKHR</type> <name>capabilityFlags</name></member>
+ <member><type>VkVideoCapabilityFlagsKHR</type> <name>capabilityFlags</name></member>
<member><type>VkDeviceSize</type> <name>minBitstreamBufferOffsetAlignment</name></member>
<member><type>VkDeviceSize</type> <name>minBitstreamBufferSizeAlignment</name></member>
<member><type>VkExtent2D</type> <name>videoPictureExtentGranularity</name></member>
<type requires="vk_video/vulkan_video_codec_h264std_decode.h" name="StdVideoDecodeH264MvcElementFlags"/>
<type category="struct" name="VkVideoDecodeH264ProfileEXT" structextends="VkVideoProfileKHR">
<member values="VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_EXT"><type>VkStructureType</type><name>sType</name></member>
- <member>const <type>void</type>* <name>pNext</name></member>
- <member><type>StdVideoH264ProfileIdc</type> <name>stdProfileIdc</name></member>
- <member><type>VkVideoDecodeH264FieldLayoutFlagsEXT</type> <name>fieldLayout</name></member>
+ <member>const <type>void</type>* <name>pNext</name></member>
+ <member><type>StdVideoH264ProfileIdc</type> <name>stdProfileIdc</name></member>
+ <member><type>VkVideoDecodeH264PictureLayoutFlagsEXT</type> <name>pictureLayout</name></member>
</type>
<type category="struct" name="VkVideoDecodeH264CapabilitiesEXT" returnedonly="true" structextends="VkVideoCapabilitiesKHR">
<member values="VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_EXT"><type>VkStructureType</type><name>sType</name></member>
<type category="struct" name="VkVideoEncodeH264CapabilitiesEXT" structextends="VkVideoCapabilitiesKHR">
<member values="VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT"><type>VkStructureType</type><name>sType</name></member>
<member>const <type>void</type>* <name>pNext</name></member>
- <member><type>VkVideoEncodeH264CapabilitiesFlagsEXT</type> <name>flags</name></member>
+ <member><type>VkVideoEncodeH264CapabilityFlagsEXT</type> <name>flags</name></member>
<member><type>VkVideoEncodeH264InputModeFlagsEXT</type> <name>inputModeFlags</name></member>
<member><type>VkVideoEncodeH264OutputModeFlagsEXT</type> <name>outputModeFlags</name></member>
<member><type>VkExtent2D</type> <name>minPictureSizeInMbs</name></member>
<enum bitpos="2" name="VK_VIDEO_COMPONENT_BIT_DEPTH_10_BIT_KHR"/>
<enum bitpos="4" name="VK_VIDEO_COMPONENT_BIT_DEPTH_12_BIT_KHR"/>
</enums>
- <enums name="VkVideoCapabilitiesFlagBitsKHR" type="bitmask">
- <enum bitpos="0" name="VK_VIDEO_CAPABILITIES_PROTECTED_CONTENT_BIT_KHR"/>
- <enum bitpos="1" name="VK_VIDEO_CAPABILITIES_SEPARATE_REFERENCE_IMAGES_BIT_KHR"/>
+ <enums name="VkVideoCapabilityFlagBitsKHR" type="bitmask">
+ <enum bitpos="0" name="VK_VIDEO_CAPABILITY_PROTECTED_CONTENT_BIT_KHR"/>
+ <enum bitpos="1" name="VK_VIDEO_CAPABILITY_SEPARATE_REFERENCE_IMAGES_BIT_KHR"/>
</enums>
<enums name="VkVideoSessionCreateFlagBitsKHR" type="bitmask">
<enum value="0" name="VK_VIDEO_SESSION_CREATE_DEFAULT_KHR"/>
<enum bitpos="1" name="VK_VIDEO_CODING_QUALITY_PRESET_POWER_BIT_KHR"/>
<enum bitpos="2" name="VK_VIDEO_CODING_QUALITY_PRESET_QUALITY_BIT_KHR"/>
</enums>
- <enums name="VkVideoDecodeH264FieldLayoutFlagBitsEXT" type="bitmask">
- <enum value="0" name="VK_VIDEO_DECODE_H264_PROGRESSIVE_PICTURES_ONLY_EXT"/>
- <enum bitpos="0" name="VK_VIDEO_DECODE_H264_FIELD_LAYOUT_LINE_INTERLACED_PLANE_BIT_EXT"/>
- <enum bitpos="1" name="VK_VIDEO_DECODE_H264_FIELD_LAYOUT_SEPARATE_INTERLACED_PLANE_BIT_EXT"/>
+ <enums name="VkVideoDecodeH264PictureLayoutFlagBitsEXT" type="bitmask">
+ <enum value="0" name="VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_PROGRESSIVE_EXT"/>
+ <enum bitpos="0" name="VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_INTERLEAVED_LINES_BIT_EXT"/>
+ <enum bitpos="1" name="VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_SEPARATE_PLANES_BIT_EXT"/>
</enums>
<enums name="VkVideoCodingControlFlagBitsKHR" type="bitmask">
<enum value="0" name="VK_VIDEO_CODING_CONTROL_DEFAULT_KHR"/>
<enum value="1" name="VK_VIDEO_ENCODE_RATE_CONTROL_MODE_CBR_BIT_KHR"/>
<enum value="2" name="VK_VIDEO_ENCODE_RATE_CONTROL_MODE_VBR_BIT_KHR"/>
</enums>
- <enums name="VkVideoEncodeH264CapabilitiesFlagBitsEXT" type="bitmask">
+ <enums name="VkVideoEncodeH264CapabilityFlagBitsEXT" type="bitmask">
<enum bitpos="0" name="VK_VIDEO_ENCODE_H264_CAPABILITY_CABAC_BIT_EXT"/>
<enum bitpos="1" name="VK_VIDEO_ENCODE_H264_CAPABILITY_CAVLC_BIT_EXT"/>
<enum bitpos="2" name="VK_VIDEO_ENCODE_H264_CAPABILITY_WEIGHTED_BI_PRED_IMPLICIT_BIT_EXT"/>
<param><type>uint32_t</type> <name>connectorId</name></param>
<param><type>VkDisplayKHR</type>* <name>display</name></param>
</command>
- <command successcodes="VK_SUCCESS,VK_TIMEOUT" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_DEVICE_LOST">
- <proto><type>VkResult</type> <name>vkWaitForPresentKHR</name></proto>
- <param><type>VkDevice</type> <name>device</name></param>
- <param externsync="true"><type>VkSwapchainKHR</type> <name>swapchain</name></param>
- <param><type>uint64_t</type> <name>presentId</name></param>
- <param><type>uint64_t</type> <name>timeout</name></param>
- </command>
+ <command successcodes="VK_SUCCESS,VK_TIMEOUT" errorcodes="VK_ERROR_OUT_OF_HOST_MEMORY,VK_ERROR_OUT_OF_DEVICE_MEMORY,VK_ERROR_DEVICE_LOST">
+
<proto><type>VkResult</type> <name>vkWaitForPresentKHR</name></proto>
+
<param><type>VkDevice</type> <name>device</name></param>
+
<param externsync="true"><type>VkSwapchainKHR</type> <name>swapchain</name></param>
+
<param><type>uint64_t</type> <name>presentId</name></param>
+
<param><type>uint64_t</type> <name>timeout</name></param>
+ </command>
</commands>
<feature api="vulkan" name="VK_VERSION_1_0" number="1.0" comment="Vulkan core API interface definitions">
</extension>
<extension name="VK_KHR_video_queue" number="24" type="device" requires="VK_KHR_get_physical_device_properties2,VK_KHR_sampler_ycbcr_conversion" author="KHR" contact="Tony Zlatinski @tzlatinski" provisional="true" platform="provisional" supported="vulkan">
<require>
- <enum value="1" name="VK_KHR_VIDEO_QUEUE_SPEC_VERSION"/>
+ <enum value="2" name="VK_KHR_VIDEO_QUEUE_SPEC_VERSION"/>
<enum value=""VK_KHR_video_queue"" name="VK_KHR_VIDEO_QUEUE_EXTENSION_NAME"/>
<enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_VIDEO_PROFILE_KHR" protect="VK_ENABLE_BETA_EXTENSIONS"/>
<enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR" protect="VK_ENABLE_BETA_EXTENSIONS"/>
<type name="VkVideoChromaSubsamplingFlagsKHR"/>
<type name="VkVideoComponentBitDepthFlagBitsKHR"/>
<type name="VkVideoComponentBitDepthFlagsKHR"/>
- <type name="VkVideoCapabilitiesFlagBitsKHR"/>
- <type name="VkVideoCapabilitiesFlagsKHR"/>
+ <type name="VkVideoCapabilityFlagBitsKHR"/>
+ <type name="VkVideoCapabilityFlagsKHR"/>
<type name="VkVideoSessionCreateFlagBitsKHR"/>
<type name="VkVideoSessionCreateFlagsKHR"/>
<type name="VkVideoBeginCodingFlagsKHR"/>
</extension>
<extension name="VK_EXT_video_encode_h264" number="39" type="device" requires="VK_KHR_video_encode_queue" author="KHR" contact="Ahmed Abdelkhalek @aabdelkh" provisional="true" platform="provisional" supported="vulkan">
<require>
- <enum value="1" name="VK_EXT_VIDEO_ENCODE_H264_SPEC_VERSION"/>
+ <enum value="2" name="VK_EXT_VIDEO_ENCODE_H264_SPEC_VERSION"/>
<enum value=""VK_EXT_video_encode_h264"" name="VK_EXT_VIDEO_ENCODE_H264_EXTENSION_NAME"/>
<enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT" protect="VK_ENABLE_BETA_EXTENSIONS"/>
<enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT" protect="VK_ENABLE_BETA_EXTENSIONS"/>
<enum offset="8" extends="VkStructureType" name="VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_EXT" protect="VK_ENABLE_BETA_EXTENSIONS"/>
<enum bitpos="16" extends="VkVideoCodecOperationFlagBitsKHR" name="VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_EXT" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- <type name="VkVideoEncodeH264CapabilitiesFlagBitsEXT"/>
- <type name="VkVideoEncodeH264CapabilitiesFlagsEXT"/>
+ <type name="VkVideoEncodeH264CapabilityFlagBitsEXT"/>
+ <type name="VkVideoEncodeH264CapabilityFlagsEXT"/>
<type name="VkVideoEncodeH264InputModeFlagBitsEXT"/>
<type name="VkVideoEncodeH264InputModeFlagsEXT"/>
<type name="VkVideoEncodeH264OutputModeFlagBitsEXT"/>
</extension>
<extension name="VK_EXT_video_decode_h264" number="41" type="device" requires="VK_KHR_video_decode_queue" author="KHR" contact="peter.fang@amd.com" provisional="true" platform="provisional" supported="vulkan">
<require>
- <enum value="1" name="VK_EXT_VIDEO_DECODE_H264_SPEC_VERSION"/>
+ <enum value="3" name="VK_EXT_VIDEO_DECODE_H264_SPEC_VERSION"/>
<enum value=""VK_EXT_video_decode_h264"" name="VK_EXT_VIDEO_DECODE_H264_EXTENSION_NAME"/>
<enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_EXT" protect="VK_ENABLE_BETA_EXTENSIONS"/>
<enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_CREATE_INFO_EXT" protect="VK_ENABLE_BETA_EXTENSIONS"/>
<enum offset="6" extends="VkStructureType" name="VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT" protect="VK_ENABLE_BETA_EXTENSIONS"/>
<enum offset="7" extends="VkStructureType" name="VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_EXT" protect="VK_ENABLE_BETA_EXTENSIONS"/>
<enum bitpos="0" extends="VkVideoCodecOperationFlagBitsKHR" name="VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_EXT" protect="VK_ENABLE_BETA_EXTENSIONS"/>
- <type name="VkVideoDecodeH264FieldLayoutFlagBitsEXT"/>
- <type name="VkVideoDecodeH264FieldLayoutFlagsEXT"/>
+ <type name="VkVideoDecodeH264PictureLayoutFlagBitsEXT"/>
+ <type name="VkVideoDecodeH264PictureLayoutFlagsEXT"/>
<type name="VkVideoDecodeH264CreateFlagsEXT"/>
<type name="VkVideoDecodeH264ProfileEXT"/>
<type name="VkVideoDecodeH264CapabilitiesEXT"/>
<require>
<enum value="1" name="VK_KHR_PRESENT_WAIT_SPEC_VERSION"/>
<enum value=""VK_KHR_present_wait"" name="VK_KHR_PRESENT_WAIT_EXTENSION_NAME"/>
- <command name="vkWaitForPresentKHR"/>
- <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR"/>
- <type name="VkPhysicalDevicePresentWaitFeaturesKHR"/>
+ <command name="vkWaitForPresentKHR"/>
+ <enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR"/>
+ <type name="VkPhysicalDevicePresentWaitFeaturesKHR"/>
</require>
</extension>
<extension name="VK_NV_cooperative_matrix" number="250" type="device" requires="VK_KHR_get_physical_device_properties2" author="NV" contact="Jeff Bolz @jeffbolznv" supported="vulkan">
<enum value=""VK_KHR_present_id"" name="VK_KHR_PRESENT_ID_EXTENSION_NAME"/>
<enum offset="0" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PRESENT_ID_KHR"/>
<type name="VkPresentIdKHR"/>
- <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR"/>
- <type name="VkPhysicalDevicePresentIdFeaturesKHR"/>
+ <enum offset="1" extends="VkStructureType" name="VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR"/>
+ <type name="VkPhysicalDevicePresentIdFeaturesKHR"/>
</require>
</extension>
<extension name="VK_EXT_private_data" number="296" type="device" author="NV" contact="Matthew Rusch @mattruschnv" supported="vulkan">
<enum value=""VK_KHR_extension_421"" name="VK_KHR_EXTENSION_421_EXTENSION_NAME"/>
</require>
</extension>
+ <extension name="VK_EXT_extension_422" number="422" author="EXT" contact="Graeme Leese @gnl21" supported="disabled">
+ <require>
+ <enum value="0" name="VK_EXT_EXTENSION_422_SPEC_VERSION"/>
+ <enum value=""VK_EXT_extension_422"" name="VK_EXT_EXTENSION_422_EXTENSION_NAME"/>
+ </require>
+ </extension>
</extensions>
<spirvextensions comment="SPIR-V Extensions allowed in Vulkan and what is required to use it">
projects / platform / upstream / Vulkan-Headers.git / commitdiff