1 // Copyright 2021-2024 The Khronos Group Inc. 2 // SPDX-License-Identifier: Apache-2.0 OR MIT 3 // 4 5 // This header is generated from the Khronos Vulkan XML API Registry. 6 7 #ifndef VULKAN_VIDEO_HPP 8 #define VULKAN_VIDEO_HPP 9 10 #include <vk_video/vulkan_video_codec_av1std.h> 11 #include <vk_video/vulkan_video_codec_av1std_decode.h> 12 #include <vk_video/vulkan_video_codec_h264std.h> 13 #include <vk_video/vulkan_video_codec_h264std_decode.h> 14 #include <vk_video/vulkan_video_codec_h264std_encode.h> 15 #include <vk_video/vulkan_video_codec_h265std.h> 16 #include <vk_video/vulkan_video_codec_h265std_decode.h> 17 #include <vk_video/vulkan_video_codec_h265std_encode.h> 18 #include <vk_video/vulkan_video_codecs_common.h> 19 #include <vulkan/vulkan.hpp> 20 21 #if !defined( VULKAN_HPP_VIDEO_NAMESPACE ) 22 # define VULKAN_HPP_VIDEO_NAMESPACE video 23 #endif 24 25 namespace VULKAN_HPP_NAMESPACE 26 { 27 namespace VULKAN_HPP_VIDEO_NAMESPACE 28 { 29 30 //============= 31 //=== ENUMs === 32 //============= 33 34 //=== vulkan_video_codec_h264std === 35 36 enum class H264ChromaFormatIdc 37 { 38 eMonochrome = STD_VIDEO_H264_CHROMA_FORMAT_IDC_MONOCHROME, 39 e420 = STD_VIDEO_H264_CHROMA_FORMAT_IDC_420, 40 e422 = STD_VIDEO_H264_CHROMA_FORMAT_IDC_422, 41 e444 = STD_VIDEO_H264_CHROMA_FORMAT_IDC_444, 42 eInvalid = STD_VIDEO_H264_CHROMA_FORMAT_IDC_INVALID 43 }; 44 45 enum class H264ProfileIdc 46 { 47 eBaseline = STD_VIDEO_H264_PROFILE_IDC_BASELINE, 48 eMain = STD_VIDEO_H264_PROFILE_IDC_MAIN, 49 eHigh = STD_VIDEO_H264_PROFILE_IDC_HIGH, 50 eHigh444Predictive = STD_VIDEO_H264_PROFILE_IDC_HIGH_444_PREDICTIVE, 51 eInvalid = STD_VIDEO_H264_PROFILE_IDC_INVALID 52 }; 53 54 enum class H264LevelIdc 55 { 56 e1_0 = STD_VIDEO_H264_LEVEL_IDC_1_0, 57 e1_1 = STD_VIDEO_H264_LEVEL_IDC_1_1, 58 e1_2 = STD_VIDEO_H264_LEVEL_IDC_1_2, 59 e1_3 = STD_VIDEO_H264_LEVEL_IDC_1_3, 60 e2_0 = STD_VIDEO_H264_LEVEL_IDC_2_0, 61 e2_1 = STD_VIDEO_H264_LEVEL_IDC_2_1, 62 e2_2 = STD_VIDEO_H264_LEVEL_IDC_2_2, 63 e3_0 = STD_VIDEO_H264_LEVEL_IDC_3_0, 64 e3_1 = STD_VIDEO_H264_LEVEL_IDC_3_1, 65 e3_2 = STD_VIDEO_H264_LEVEL_IDC_3_2, 66 e4_0 = STD_VIDEO_H264_LEVEL_IDC_4_0, 67 e4_1 = STD_VIDEO_H264_LEVEL_IDC_4_1, 68 e4_2 = STD_VIDEO_H264_LEVEL_IDC_4_2, 69 e5_0 = STD_VIDEO_H264_LEVEL_IDC_5_0, 70 e5_1 = STD_VIDEO_H264_LEVEL_IDC_5_1, 71 e5_2 = STD_VIDEO_H264_LEVEL_IDC_5_2, 72 e6_0 = STD_VIDEO_H264_LEVEL_IDC_6_0, 73 e6_1 = STD_VIDEO_H264_LEVEL_IDC_6_1, 74 e6_2 = STD_VIDEO_H264_LEVEL_IDC_6_2, 75 eInvalid = STD_VIDEO_H264_LEVEL_IDC_INVALID 76 }; 77 78 enum class H264PocType 79 { 80 e0 = STD_VIDEO_H264_POC_TYPE_0, 81 e1 = STD_VIDEO_H264_POC_TYPE_1, 82 e2 = STD_VIDEO_H264_POC_TYPE_2, 83 eInvalid = STD_VIDEO_H264_POC_TYPE_INVALID 84 }; 85 86 enum class H264AspectRatioIdc 87 { 88 eUnspecified = STD_VIDEO_H264_ASPECT_RATIO_IDC_UNSPECIFIED, 89 eSquare = STD_VIDEO_H264_ASPECT_RATIO_IDC_SQUARE, 90 e12_11 = STD_VIDEO_H264_ASPECT_RATIO_IDC_12_11, 91 e10_11 = STD_VIDEO_H264_ASPECT_RATIO_IDC_10_11, 92 e16_11 = STD_VIDEO_H264_ASPECT_RATIO_IDC_16_11, 93 e40_33 = STD_VIDEO_H264_ASPECT_RATIO_IDC_40_33, 94 e24_11 = STD_VIDEO_H264_ASPECT_RATIO_IDC_24_11, 95 e20_11 = STD_VIDEO_H264_ASPECT_RATIO_IDC_20_11, 96 e32_11 = STD_VIDEO_H264_ASPECT_RATIO_IDC_32_11, 97 e80_33 = STD_VIDEO_H264_ASPECT_RATIO_IDC_80_33, 98 e18_11 = STD_VIDEO_H264_ASPECT_RATIO_IDC_18_11, 99 e15_11 = STD_VIDEO_H264_ASPECT_RATIO_IDC_15_11, 100 e64_33 = STD_VIDEO_H264_ASPECT_RATIO_IDC_64_33, 101 e160_99 = STD_VIDEO_H264_ASPECT_RATIO_IDC_160_99, 102 e4_3 = STD_VIDEO_H264_ASPECT_RATIO_IDC_4_3, 103 e3_2 = STD_VIDEO_H264_ASPECT_RATIO_IDC_3_2, 104 e2_1 = STD_VIDEO_H264_ASPECT_RATIO_IDC_2_1, 105 eExtendedSar = STD_VIDEO_H264_ASPECT_RATIO_IDC_EXTENDED_SAR, 106 eInvalid = STD_VIDEO_H264_ASPECT_RATIO_IDC_INVALID 107 }; 108 109 enum class H264WeightedBipredIdc 110 { 111 eDefault = STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_DEFAULT, 112 eExplicit = STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_EXPLICIT, 113 eImplicit = STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_IMPLICIT, 114 eInvalid = STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_INVALID 115 }; 116 117 enum class H264ModificationOfPicNumsIdc 118 { 119 eShortTermSubtract = STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_SHORT_TERM_SUBTRACT, 120 eShortTermAdd = STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_SHORT_TERM_ADD, 121 eLongTerm = STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_LONG_TERM, 122 eEnd = STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_END, 123 eInvalid = STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_INVALID 124 }; 125 126 enum class H264MemMgmtControlOp 127 { 128 eEnd = STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_END, 129 eUnmarkShortTerm = STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_SHORT_TERM, 130 eUnmarkLongTerm = STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_LONG_TERM, 131 eMarkLongTerm = STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_MARK_LONG_TERM, 132 eSetMaxLongTermIndex = STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_SET_MAX_LONG_TERM_INDEX, 133 eUnmarkAll = STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_ALL, 134 eMarkCurrentAsLongTerm = STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_MARK_CURRENT_AS_LONG_TERM, 135 eInvalid = STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_INVALID 136 }; 137 138 enum class H264CabacInitIdc 139 { 140 e0 = STD_VIDEO_H264_CABAC_INIT_IDC_0, 141 e1 = STD_VIDEO_H264_CABAC_INIT_IDC_1, 142 e2 = STD_VIDEO_H264_CABAC_INIT_IDC_2, 143 eInvalid = STD_VIDEO_H264_CABAC_INIT_IDC_INVALID 144 }; 145 146 enum class H264DisableDeblockingFilterIdc 147 { 148 eDisabled = STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_DISABLED, 149 eEnabled = STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_ENABLED, 150 ePartial = STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_PARTIAL, 151 eInvalid = STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_INVALID 152 }; 153 154 enum class H264SliceType 155 { 156 eP = STD_VIDEO_H264_SLICE_TYPE_P, 157 eB = STD_VIDEO_H264_SLICE_TYPE_B, 158 eI = STD_VIDEO_H264_SLICE_TYPE_I, 159 eInvalid = STD_VIDEO_H264_SLICE_TYPE_INVALID 160 }; 161 162 enum class H264PictureType 163 { 164 eP = STD_VIDEO_H264_PICTURE_TYPE_P, 165 eB = STD_VIDEO_H264_PICTURE_TYPE_B, 166 eI = STD_VIDEO_H264_PICTURE_TYPE_I, 167 eIdr = STD_VIDEO_H264_PICTURE_TYPE_IDR, 168 eInvalid = STD_VIDEO_H264_PICTURE_TYPE_INVALID 169 }; 170 171 enum class H264NonVclNaluType 172 { 173 eSps = STD_VIDEO_H264_NON_VCL_NALU_TYPE_SPS, 174 ePps = STD_VIDEO_H264_NON_VCL_NALU_TYPE_PPS, 175 eAud = STD_VIDEO_H264_NON_VCL_NALU_TYPE_AUD, 176 ePrefix = STD_VIDEO_H264_NON_VCL_NALU_TYPE_PREFIX, 177 eEndOfSequence = STD_VIDEO_H264_NON_VCL_NALU_TYPE_END_OF_SEQUENCE, 178 eEndOfStream = STD_VIDEO_H264_NON_VCL_NALU_TYPE_END_OF_STREAM, 179 ePrecoded = STD_VIDEO_H264_NON_VCL_NALU_TYPE_PRECODED, 180 eInvalid = STD_VIDEO_H264_NON_VCL_NALU_TYPE_INVALID 181 }; 182 183 //=== vulkan_video_codec_h264std_decode === 184 185 enum class DecodeH264FieldOrderCount 186 { 187 eTop = STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_TOP, 188 eBottom = STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_BOTTOM, 189 eInvalid = STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_INVALID 190 }; 191 192 //=== vulkan_video_codec_h265std === 193 194 enum class H265ChromaFormatIdc 195 { 196 eMonochrome = STD_VIDEO_H265_CHROMA_FORMAT_IDC_MONOCHROME, 197 e420 = STD_VIDEO_H265_CHROMA_FORMAT_IDC_420, 198 e422 = STD_VIDEO_H265_CHROMA_FORMAT_IDC_422, 199 e444 = STD_VIDEO_H265_CHROMA_FORMAT_IDC_444, 200 eInvalid = STD_VIDEO_H265_CHROMA_FORMAT_IDC_INVALID 201 }; 202 203 enum class H265ProfileIdc 204 { 205 eMain = STD_VIDEO_H265_PROFILE_IDC_MAIN, 206 eMain10 = STD_VIDEO_H265_PROFILE_IDC_MAIN_10, 207 eMainStillPicture = STD_VIDEO_H265_PROFILE_IDC_MAIN_STILL_PICTURE, 208 eFormatRangeExtensions = STD_VIDEO_H265_PROFILE_IDC_FORMAT_RANGE_EXTENSIONS, 209 eSccExtensions = STD_VIDEO_H265_PROFILE_IDC_SCC_EXTENSIONS, 210 eInvalid = STD_VIDEO_H265_PROFILE_IDC_INVALID 211 }; 212 213 enum class H265LevelIdc 214 { 215 e1_0 = STD_VIDEO_H265_LEVEL_IDC_1_0, 216 e2_0 = STD_VIDEO_H265_LEVEL_IDC_2_0, 217 e2_1 = STD_VIDEO_H265_LEVEL_IDC_2_1, 218 e3_0 = STD_VIDEO_H265_LEVEL_IDC_3_0, 219 e3_1 = STD_VIDEO_H265_LEVEL_IDC_3_1, 220 e4_0 = STD_VIDEO_H265_LEVEL_IDC_4_0, 221 e4_1 = STD_VIDEO_H265_LEVEL_IDC_4_1, 222 e5_0 = STD_VIDEO_H265_LEVEL_IDC_5_0, 223 e5_1 = STD_VIDEO_H265_LEVEL_IDC_5_1, 224 e5_2 = STD_VIDEO_H265_LEVEL_IDC_5_2, 225 e6_0 = STD_VIDEO_H265_LEVEL_IDC_6_0, 226 e6_1 = STD_VIDEO_H265_LEVEL_IDC_6_1, 227 e6_2 = STD_VIDEO_H265_LEVEL_IDC_6_2, 228 eInvalid = STD_VIDEO_H265_LEVEL_IDC_INVALID 229 }; 230 231 enum class H265SliceType 232 { 233 eB = STD_VIDEO_H265_SLICE_TYPE_B, 234 eP = STD_VIDEO_H265_SLICE_TYPE_P, 235 eI = STD_VIDEO_H265_SLICE_TYPE_I, 236 eInvalid = STD_VIDEO_H265_SLICE_TYPE_INVALID 237 }; 238 239 enum class H265PictureType 240 { 241 eP = STD_VIDEO_H265_PICTURE_TYPE_P, 242 eB = STD_VIDEO_H265_PICTURE_TYPE_B, 243 eI = STD_VIDEO_H265_PICTURE_TYPE_I, 244 eIdr = STD_VIDEO_H265_PICTURE_TYPE_IDR, 245 eInvalid = STD_VIDEO_H265_PICTURE_TYPE_INVALID 246 }; 247 248 enum class H265AspectRatioIdc 249 { 250 eUnspecified = STD_VIDEO_H265_ASPECT_RATIO_IDC_UNSPECIFIED, 251 eSquare = STD_VIDEO_H265_ASPECT_RATIO_IDC_SQUARE, 252 e12_11 = STD_VIDEO_H265_ASPECT_RATIO_IDC_12_11, 253 e10_11 = STD_VIDEO_H265_ASPECT_RATIO_IDC_10_11, 254 e16_11 = STD_VIDEO_H265_ASPECT_RATIO_IDC_16_11, 255 e40_33 = STD_VIDEO_H265_ASPECT_RATIO_IDC_40_33, 256 e24_11 = STD_VIDEO_H265_ASPECT_RATIO_IDC_24_11, 257 e20_11 = STD_VIDEO_H265_ASPECT_RATIO_IDC_20_11, 258 e32_11 = STD_VIDEO_H265_ASPECT_RATIO_IDC_32_11, 259 e80_33 = STD_VIDEO_H265_ASPECT_RATIO_IDC_80_33, 260 e18_11 = STD_VIDEO_H265_ASPECT_RATIO_IDC_18_11, 261 e15_11 = STD_VIDEO_H265_ASPECT_RATIO_IDC_15_11, 262 e64_33 = STD_VIDEO_H265_ASPECT_RATIO_IDC_64_33, 263 e160_99 = STD_VIDEO_H265_ASPECT_RATIO_IDC_160_99, 264 e4_3 = STD_VIDEO_H265_ASPECT_RATIO_IDC_4_3, 265 e3_2 = STD_VIDEO_H265_ASPECT_RATIO_IDC_3_2, 266 e2_1 = STD_VIDEO_H265_ASPECT_RATIO_IDC_2_1, 267 eExtendedSar = STD_VIDEO_H265_ASPECT_RATIO_IDC_EXTENDED_SAR, 268 eInvalid = STD_VIDEO_H265_ASPECT_RATIO_IDC_INVALID 269 }; 270 271 //=== vulkan_video_codec_av1std === 272 273 enum class AV1Profile 274 { 275 eMain = STD_VIDEO_AV1_PROFILE_MAIN, 276 eHigh = STD_VIDEO_AV1_PROFILE_HIGH, 277 eProfessional = STD_VIDEO_AV1_PROFILE_PROFESSIONAL, 278 eInvalid = STD_VIDEO_AV1_PROFILE_INVALID 279 }; 280 281 enum class AV1Level 282 { 283 e2_0 = STD_VIDEO_AV1_LEVEL_2_0, 284 e2_1 = STD_VIDEO_AV1_LEVEL_2_1, 285 e2_2 = STD_VIDEO_AV1_LEVEL_2_2, 286 e2_3 = STD_VIDEO_AV1_LEVEL_2_3, 287 e3_0 = STD_VIDEO_AV1_LEVEL_3_0, 288 e3_1 = STD_VIDEO_AV1_LEVEL_3_1, 289 e3_2 = STD_VIDEO_AV1_LEVEL_3_2, 290 e3_3 = STD_VIDEO_AV1_LEVEL_3_3, 291 e4_0 = STD_VIDEO_AV1_LEVEL_4_0, 292 e4_1 = STD_VIDEO_AV1_LEVEL_4_1, 293 e4_2 = STD_VIDEO_AV1_LEVEL_4_2, 294 e4_3 = STD_VIDEO_AV1_LEVEL_4_3, 295 e5_0 = STD_VIDEO_AV1_LEVEL_5_0, 296 e5_1 = STD_VIDEO_AV1_LEVEL_5_1, 297 e5_2 = STD_VIDEO_AV1_LEVEL_5_2, 298 e5_3 = STD_VIDEO_AV1_LEVEL_5_3, 299 e6_0 = STD_VIDEO_AV1_LEVEL_6_0, 300 e6_1 = STD_VIDEO_AV1_LEVEL_6_1, 301 e6_2 = STD_VIDEO_AV1_LEVEL_6_2, 302 e6_3 = STD_VIDEO_AV1_LEVEL_6_3, 303 e7_0 = STD_VIDEO_AV1_LEVEL_7_0, 304 e7_1 = STD_VIDEO_AV1_LEVEL_7_1, 305 e7_2 = STD_VIDEO_AV1_LEVEL_7_2, 306 e7_3 = STD_VIDEO_AV1_LEVEL_7_3, 307 eInvalid = STD_VIDEO_AV1_LEVEL_INVALID 308 }; 309 310 enum class AV1FrameType 311 { 312 eKey = STD_VIDEO_AV1_FRAME_TYPE_KEY, 313 eInter = STD_VIDEO_AV1_FRAME_TYPE_INTER, 314 eIntraOnly = STD_VIDEO_AV1_FRAME_TYPE_INTRA_ONLY, 315 eSwitch = STD_VIDEO_AV1_FRAME_TYPE_SWITCH, 316 eInvalid = STD_VIDEO_AV1_FRAME_TYPE_INVALID 317 }; 318 319 enum class AV1ReferenceName 320 { 321 eIntraFrame = STD_VIDEO_AV1_REFERENCE_NAME_INTRA_FRAME, 322 eLastFrame = STD_VIDEO_AV1_REFERENCE_NAME_LAST_FRAME, 323 eLast2Frame = STD_VIDEO_AV1_REFERENCE_NAME_LAST2_FRAME, 324 eLast3Frame = STD_VIDEO_AV1_REFERENCE_NAME_LAST3_FRAME, 325 eGoldenFrame = STD_VIDEO_AV1_REFERENCE_NAME_GOLDEN_FRAME, 326 eBwdrefFrame = STD_VIDEO_AV1_REFERENCE_NAME_BWDREF_FRAME, 327 eAltref2Frame = STD_VIDEO_AV1_REFERENCE_NAME_ALTREF2_FRAME, 328 eAltrefFrame = STD_VIDEO_AV1_REFERENCE_NAME_ALTREF_FRAME, 329 eInvalid = STD_VIDEO_AV1_REFERENCE_NAME_INVALID 330 }; 331 332 enum class AV1InterpolationFilter 333 { 334 eEighttap = STD_VIDEO_AV1_INTERPOLATION_FILTER_EIGHTTAP, 335 eEighttapSmooth = STD_VIDEO_AV1_INTERPOLATION_FILTER_EIGHTTAP_SMOOTH, 336 eEighttapSharp = STD_VIDEO_AV1_INTERPOLATION_FILTER_EIGHTTAP_SHARP, 337 eBilinear = STD_VIDEO_AV1_INTERPOLATION_FILTER_BILINEAR, 338 eSwitchable = STD_VIDEO_AV1_INTERPOLATION_FILTER_SWITCHABLE, 339 eInvalid = STD_VIDEO_AV1_INTERPOLATION_FILTER_INVALID 340 }; 341 342 enum class AV1TxMode 343 { 344 eOnly4X4 = STD_VIDEO_AV1_TX_MODE_ONLY_4X4, 345 eLargest = STD_VIDEO_AV1_TX_MODE_LARGEST, 346 eSelect = STD_VIDEO_AV1_TX_MODE_SELECT, 347 eInvalid = STD_VIDEO_AV1_TX_MODE_INVALID 348 }; 349 350 enum class AV1FrameRestorationType 351 { 352 eNone = STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_NONE, 353 eWiener = STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_WIENER, 354 eSgrproj = STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_SGRPROJ, 355 eSwitchable = STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_SWITCHABLE, 356 eInvalid = STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_INVALID 357 }; 358 359 enum class AV1ColorPrimaries 360 { 361 eBt709 = STD_VIDEO_AV1_COLOR_PRIMARIES_BT_709, 362 eBtUnspecified = STD_VIDEO_AV1_COLOR_PRIMARIES_BT_UNSPECIFIED, 363 eBt470M = STD_VIDEO_AV1_COLOR_PRIMARIES_BT_470_M, 364 eBt470BG = STD_VIDEO_AV1_COLOR_PRIMARIES_BT_470_B_G, 365 eBt601 = STD_VIDEO_AV1_COLOR_PRIMARIES_BT_601, 366 eSmpte240 = STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_240, 367 eGenericFilm = STD_VIDEO_AV1_COLOR_PRIMARIES_GENERIC_FILM, 368 eBt2020 = STD_VIDEO_AV1_COLOR_PRIMARIES_BT_2020, 369 eXyz = STD_VIDEO_AV1_COLOR_PRIMARIES_XYZ, 370 eSmpte431 = STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_431, 371 eSmpte432 = STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_432, 372 eEbu3213 = STD_VIDEO_AV1_COLOR_PRIMARIES_EBU_3213, 373 eInvalid = STD_VIDEO_AV1_COLOR_PRIMARIES_INVALID 374 }; 375 376 enum class AV1TransferCharacteristics 377 { 378 eReserved0 = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_RESERVED_0, 379 eBt709 = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_709, 380 eUnspecified = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_UNSPECIFIED, 381 eReserved3 = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_RESERVED_3, 382 eBt470M = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_470_M, 383 eBt470BG = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_470_B_G, 384 eBt601 = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_601, 385 eSmpte240 = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SMPTE_240, 386 eLinear = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_LINEAR, 387 eLog100 = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_LOG_100, 388 eLog100Sqrt10 = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_LOG_100_SQRT10, 389 eIec61966 = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_IEC_61966, 390 eBt1361 = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_1361, 391 eSrgb = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SRGB, 392 eBt2020_10Bit = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_2020_10_BIT, 393 eBt2020_12Bit = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_2020_12_BIT, 394 eSmpte2084 = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SMPTE_2084, 395 eSmpte428 = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SMPTE_428, 396 eHlg = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_HLG, 397 eInvalid = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_INVALID 398 }; 399 400 enum class AV1MatrixCoefficients 401 { 402 eIdentity = STD_VIDEO_AV1_MATRIX_COEFFICIENTS_IDENTITY, 403 eBt709 = STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_709, 404 eUnspecified = STD_VIDEO_AV1_MATRIX_COEFFICIENTS_UNSPECIFIED, 405 eReserved3 = STD_VIDEO_AV1_MATRIX_COEFFICIENTS_RESERVED_3, 406 eFcc = STD_VIDEO_AV1_MATRIX_COEFFICIENTS_FCC, 407 eBt470BG = STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_470_B_G, 408 eBt601 = STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_601, 409 eSmpte240 = STD_VIDEO_AV1_MATRIX_COEFFICIENTS_SMPTE_240, 410 eSmpteYcgco = STD_VIDEO_AV1_MATRIX_COEFFICIENTS_SMPTE_YCGCO, 411 eBt2020Ncl = STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_2020_NCL, 412 eBt2020Cl = STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_2020_CL, 413 eSmpte2085 = STD_VIDEO_AV1_MATRIX_COEFFICIENTS_SMPTE_2085, 414 eChromatNcl = STD_VIDEO_AV1_MATRIX_COEFFICIENTS_CHROMAT_NCL, 415 eChromatCl = STD_VIDEO_AV1_MATRIX_COEFFICIENTS_CHROMAT_CL, 416 eIctcp = STD_VIDEO_AV1_MATRIX_COEFFICIENTS_ICTCP, 417 eInvalid = STD_VIDEO_AV1_MATRIX_COEFFICIENTS_INVALID 418 }; 419 420 enum class AV1ChromaSamplePosition 421 { 422 eUnknown = STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_UNKNOWN, 423 eVertical = STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_VERTICAL, 424 eColocated = STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_COLOCATED, 425 eReserved = STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_RESERVED, 426 eInvalid = STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_INVALID 427 }; 428 429 //=============== 430 //=== STRUCTS === 431 //=============== 432 433 //=== vulkan_video_codec_h264std === 434 435 struct H264SpsVuiFlags 436 { 437 using NativeType = StdVideoH264SpsVuiFlags; 438 operator StdVideoH264SpsVuiFlags const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SpsVuiFlags439 operator StdVideoH264SpsVuiFlags const &() const VULKAN_HPP_NOEXCEPT 440 { 441 return *reinterpret_cast<const StdVideoH264SpsVuiFlags *>( this ); 442 } 443 operator StdVideoH264SpsVuiFlags&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SpsVuiFlags444 operator StdVideoH264SpsVuiFlags &() VULKAN_HPP_NOEXCEPT 445 { 446 return *reinterpret_cast<StdVideoH264SpsVuiFlags *>( this ); 447 } 448 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SpsVuiFlags449 bool operator==( H264SpsVuiFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 450 { 451 return ( aspect_ratio_info_present_flag == rhs.aspect_ratio_info_present_flag ) && ( overscan_info_present_flag == rhs.overscan_info_present_flag ) && 452 ( overscan_appropriate_flag == rhs.overscan_appropriate_flag ) && ( video_signal_type_present_flag == rhs.video_signal_type_present_flag ) && 453 ( video_full_range_flag == rhs.video_full_range_flag ) && ( color_description_present_flag == rhs.color_description_present_flag ) && 454 ( chroma_loc_info_present_flag == rhs.chroma_loc_info_present_flag ) && ( timing_info_present_flag == rhs.timing_info_present_flag ) && 455 ( fixed_frame_rate_flag == rhs.fixed_frame_rate_flag ) && ( bitstream_restriction_flag == rhs.bitstream_restriction_flag ) && 456 ( nal_hrd_parameters_present_flag == rhs.nal_hrd_parameters_present_flag ) && 457 ( vcl_hrd_parameters_present_flag == rhs.vcl_hrd_parameters_present_flag ); 458 } 459 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SpsVuiFlags460 bool operator!=( H264SpsVuiFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 461 { 462 return !operator==( rhs ); 463 } 464 465 public: 466 uint32_t aspect_ratio_info_present_flag : 1; 467 uint32_t overscan_info_present_flag : 1; 468 uint32_t overscan_appropriate_flag : 1; 469 uint32_t video_signal_type_present_flag : 1; 470 uint32_t video_full_range_flag : 1; 471 uint32_t color_description_present_flag : 1; 472 uint32_t chroma_loc_info_present_flag : 1; 473 uint32_t timing_info_present_flag : 1; 474 uint32_t fixed_frame_rate_flag : 1; 475 uint32_t bitstream_restriction_flag : 1; 476 uint32_t nal_hrd_parameters_present_flag : 1; 477 uint32_t vcl_hrd_parameters_present_flag : 1; 478 }; 479 480 struct H264HrdParameters 481 { 482 using NativeType = StdVideoH264HrdParameters; 483 operator StdVideoH264HrdParameters const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264HrdParameters484 operator StdVideoH264HrdParameters const &() const VULKAN_HPP_NOEXCEPT 485 { 486 return *reinterpret_cast<const StdVideoH264HrdParameters *>( this ); 487 } 488 operator StdVideoH264HrdParameters&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264HrdParameters489 operator StdVideoH264HrdParameters &() VULKAN_HPP_NOEXCEPT 490 { 491 return *reinterpret_cast<StdVideoH264HrdParameters *>( this ); 492 } 493 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264HrdParameters494 bool operator==( H264HrdParameters const & rhs ) const VULKAN_HPP_NOEXCEPT 495 { 496 return ( cpb_cnt_minus1 == rhs.cpb_cnt_minus1 ) && ( bit_rate_scale == rhs.bit_rate_scale ) && ( cpb_size_scale == rhs.cpb_size_scale ) && 497 ( reserved1 == rhs.reserved1 ) && ( bit_rate_value_minus1 == rhs.bit_rate_value_minus1 ) && 498 ( cpb_size_value_minus1 == rhs.cpb_size_value_minus1 ) && ( cbr_flag == rhs.cbr_flag ) && 499 ( initial_cpb_removal_delay_length_minus1 == rhs.initial_cpb_removal_delay_length_minus1 ) && 500 ( cpb_removal_delay_length_minus1 == rhs.cpb_removal_delay_length_minus1 ) && 501 ( dpb_output_delay_length_minus1 == rhs.dpb_output_delay_length_minus1 ) && ( time_offset_length == rhs.time_offset_length ); 502 } 503 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264HrdParameters504 bool operator!=( H264HrdParameters const & rhs ) const VULKAN_HPP_NOEXCEPT 505 { 506 return !operator==( rhs ); 507 } 508 509 public: 510 uint8_t cpb_cnt_minus1 = {}; 511 uint8_t bit_rate_scale = {}; 512 uint8_t cpb_size_scale = {}; 513 uint8_t reserved1 = {}; 514 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint32_t, STD_VIDEO_H264_CPB_CNT_LIST_SIZE> bit_rate_value_minus1 = {}; 515 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint32_t, STD_VIDEO_H264_CPB_CNT_LIST_SIZE> cpb_size_value_minus1 = {}; 516 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_H264_CPB_CNT_LIST_SIZE> cbr_flag = {}; 517 uint32_t initial_cpb_removal_delay_length_minus1 = {}; 518 uint32_t cpb_removal_delay_length_minus1 = {}; 519 uint32_t dpb_output_delay_length_minus1 = {}; 520 uint32_t time_offset_length = {}; 521 }; 522 523 struct H264SequenceParameterSetVui 524 { 525 using NativeType = StdVideoH264SequenceParameterSetVui; 526 operator StdVideoH264SequenceParameterSetVui const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SequenceParameterSetVui527 operator StdVideoH264SequenceParameterSetVui const &() const VULKAN_HPP_NOEXCEPT 528 { 529 return *reinterpret_cast<const StdVideoH264SequenceParameterSetVui *>( this ); 530 } 531 operator StdVideoH264SequenceParameterSetVui&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SequenceParameterSetVui532 operator StdVideoH264SequenceParameterSetVui &() VULKAN_HPP_NOEXCEPT 533 { 534 return *reinterpret_cast<StdVideoH264SequenceParameterSetVui *>( this ); 535 } 536 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SequenceParameterSetVui537 bool operator==( H264SequenceParameterSetVui const & rhs ) const VULKAN_HPP_NOEXCEPT 538 { 539 return ( flags == rhs.flags ) && ( aspect_ratio_idc == rhs.aspect_ratio_idc ) && ( sar_width == rhs.sar_width ) && ( sar_height == rhs.sar_height ) && 540 ( video_format == rhs.video_format ) && ( colour_primaries == rhs.colour_primaries ) && 541 ( transfer_characteristics == rhs.transfer_characteristics ) && ( matrix_coefficients == rhs.matrix_coefficients ) && 542 ( num_units_in_tick == rhs.num_units_in_tick ) && ( time_scale == rhs.time_scale ) && ( max_num_reorder_frames == rhs.max_num_reorder_frames ) && 543 ( max_dec_frame_buffering == rhs.max_dec_frame_buffering ) && ( chroma_sample_loc_type_top_field == rhs.chroma_sample_loc_type_top_field ) && 544 ( chroma_sample_loc_type_bottom_field == rhs.chroma_sample_loc_type_bottom_field ) && ( reserved1 == rhs.reserved1 ) && 545 ( pHrdParameters == rhs.pHrdParameters ); 546 } 547 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SequenceParameterSetVui548 bool operator!=( H264SequenceParameterSetVui const & rhs ) const VULKAN_HPP_NOEXCEPT 549 { 550 return !operator==( rhs ); 551 } 552 553 public: 554 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SpsVuiFlags flags = {}; 555 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264AspectRatioIdc aspect_ratio_idc = 556 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264AspectRatioIdc::eUnspecified; 557 uint16_t sar_width = {}; 558 uint16_t sar_height = {}; 559 uint8_t video_format = {}; 560 uint8_t colour_primaries = {}; 561 uint8_t transfer_characteristics = {}; 562 uint8_t matrix_coefficients = {}; 563 uint32_t num_units_in_tick = {}; 564 uint32_t time_scale = {}; 565 uint8_t max_num_reorder_frames = {}; 566 uint8_t max_dec_frame_buffering = {}; 567 uint8_t chroma_sample_loc_type_top_field = {}; 568 uint8_t chroma_sample_loc_type_bottom_field = {}; 569 uint32_t reserved1 = {}; 570 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264HrdParameters * pHrdParameters = {}; 571 }; 572 573 struct H264SpsFlags 574 { 575 using NativeType = StdVideoH264SpsFlags; 576 operator StdVideoH264SpsFlags const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SpsFlags577 operator StdVideoH264SpsFlags const &() const VULKAN_HPP_NOEXCEPT 578 { 579 return *reinterpret_cast<const StdVideoH264SpsFlags *>( this ); 580 } 581 operator StdVideoH264SpsFlags&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SpsFlags582 operator StdVideoH264SpsFlags &() VULKAN_HPP_NOEXCEPT 583 { 584 return *reinterpret_cast<StdVideoH264SpsFlags *>( this ); 585 } 586 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SpsFlags587 bool operator==( H264SpsFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 588 { 589 return ( constraint_set0_flag == rhs.constraint_set0_flag ) && ( constraint_set1_flag == rhs.constraint_set1_flag ) && 590 ( constraint_set2_flag == rhs.constraint_set2_flag ) && ( constraint_set3_flag == rhs.constraint_set3_flag ) && 591 ( constraint_set4_flag == rhs.constraint_set4_flag ) && ( constraint_set5_flag == rhs.constraint_set5_flag ) && 592 ( direct_8x8_inference_flag == rhs.direct_8x8_inference_flag ) && ( mb_adaptive_frame_field_flag == rhs.mb_adaptive_frame_field_flag ) && 593 ( frame_mbs_only_flag == rhs.frame_mbs_only_flag ) && ( delta_pic_order_always_zero_flag == rhs.delta_pic_order_always_zero_flag ) && 594 ( separate_colour_plane_flag == rhs.separate_colour_plane_flag ) && 595 ( gaps_in_frame_num_value_allowed_flag == rhs.gaps_in_frame_num_value_allowed_flag ) && 596 ( qpprime_y_zero_transform_bypass_flag == rhs.qpprime_y_zero_transform_bypass_flag ) && ( frame_cropping_flag == rhs.frame_cropping_flag ) && 597 ( seq_scaling_matrix_present_flag == rhs.seq_scaling_matrix_present_flag ) && ( vui_parameters_present_flag == rhs.vui_parameters_present_flag ); 598 } 599 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SpsFlags600 bool operator!=( H264SpsFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 601 { 602 return !operator==( rhs ); 603 } 604 605 public: 606 uint32_t constraint_set0_flag : 1; 607 uint32_t constraint_set1_flag : 1; 608 uint32_t constraint_set2_flag : 1; 609 uint32_t constraint_set3_flag : 1; 610 uint32_t constraint_set4_flag : 1; 611 uint32_t constraint_set5_flag : 1; 612 uint32_t direct_8x8_inference_flag : 1; 613 uint32_t mb_adaptive_frame_field_flag : 1; 614 uint32_t frame_mbs_only_flag : 1; 615 uint32_t delta_pic_order_always_zero_flag : 1; 616 uint32_t separate_colour_plane_flag : 1; 617 uint32_t gaps_in_frame_num_value_allowed_flag : 1; 618 uint32_t qpprime_y_zero_transform_bypass_flag : 1; 619 uint32_t frame_cropping_flag : 1; 620 uint32_t seq_scaling_matrix_present_flag : 1; 621 uint32_t vui_parameters_present_flag : 1; 622 }; 623 624 struct H264ScalingLists 625 { 626 using NativeType = StdVideoH264ScalingLists; 627 operator StdVideoH264ScalingLists const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ScalingLists628 operator StdVideoH264ScalingLists const &() const VULKAN_HPP_NOEXCEPT 629 { 630 return *reinterpret_cast<const StdVideoH264ScalingLists *>( this ); 631 } 632 operator StdVideoH264ScalingLists&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ScalingLists633 operator StdVideoH264ScalingLists &() VULKAN_HPP_NOEXCEPT 634 { 635 return *reinterpret_cast<StdVideoH264ScalingLists *>( this ); 636 } 637 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ScalingLists638 bool operator==( H264ScalingLists const & rhs ) const VULKAN_HPP_NOEXCEPT 639 { 640 return ( scaling_list_present_mask == rhs.scaling_list_present_mask ) && ( use_default_scaling_matrix_mask == rhs.use_default_scaling_matrix_mask ) && 641 ( ScalingList4x4 == rhs.ScalingList4x4 ) && ( ScalingList8x8 == rhs.ScalingList8x8 ); 642 } 643 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ScalingLists644 bool operator!=( H264ScalingLists const & rhs ) const VULKAN_HPP_NOEXCEPT 645 { 646 return !operator==( rhs ); 647 } 648 649 public: 650 uint16_t scaling_list_present_mask = {}; 651 uint16_t use_default_scaling_matrix_mask = {}; 652 VULKAN_HPP_NAMESPACE::ArrayWrapper2D<uint8_t, STD_VIDEO_H264_SCALING_LIST_4X4_NUM_LISTS, STD_VIDEO_H264_SCALING_LIST_4X4_NUM_ELEMENTS> 653 ScalingList4x4 = {}; 654 VULKAN_HPP_NAMESPACE::ArrayWrapper2D<uint8_t, STD_VIDEO_H264_SCALING_LIST_8X8_NUM_LISTS, STD_VIDEO_H264_SCALING_LIST_8X8_NUM_ELEMENTS> 655 ScalingList8x8 = {}; 656 }; 657 658 struct H264SequenceParameterSet 659 { 660 using NativeType = StdVideoH264SequenceParameterSet; 661 operator StdVideoH264SequenceParameterSet const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SequenceParameterSet662 operator StdVideoH264SequenceParameterSet const &() const VULKAN_HPP_NOEXCEPT 663 { 664 return *reinterpret_cast<const StdVideoH264SequenceParameterSet *>( this ); 665 } 666 operator StdVideoH264SequenceParameterSet&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SequenceParameterSet667 operator StdVideoH264SequenceParameterSet &() VULKAN_HPP_NOEXCEPT 668 { 669 return *reinterpret_cast<StdVideoH264SequenceParameterSet *>( this ); 670 } 671 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SequenceParameterSet672 bool operator==( H264SequenceParameterSet const & rhs ) const VULKAN_HPP_NOEXCEPT 673 { 674 return ( flags == rhs.flags ) && ( profile_idc == rhs.profile_idc ) && ( level_idc == rhs.level_idc ) && 675 ( chroma_format_idc == rhs.chroma_format_idc ) && ( seq_parameter_set_id == rhs.seq_parameter_set_id ) && 676 ( bit_depth_luma_minus8 == rhs.bit_depth_luma_minus8 ) && ( bit_depth_chroma_minus8 == rhs.bit_depth_chroma_minus8 ) && 677 ( log2_max_frame_num_minus4 == rhs.log2_max_frame_num_minus4 ) && ( pic_order_cnt_type == rhs.pic_order_cnt_type ) && 678 ( offset_for_non_ref_pic == rhs.offset_for_non_ref_pic ) && ( offset_for_top_to_bottom_field == rhs.offset_for_top_to_bottom_field ) && 679 ( log2_max_pic_order_cnt_lsb_minus4 == rhs.log2_max_pic_order_cnt_lsb_minus4 ) && 680 ( num_ref_frames_in_pic_order_cnt_cycle == rhs.num_ref_frames_in_pic_order_cnt_cycle ) && ( max_num_ref_frames == rhs.max_num_ref_frames ) && 681 ( reserved1 == rhs.reserved1 ) && ( pic_width_in_mbs_minus1 == rhs.pic_width_in_mbs_minus1 ) && 682 ( pic_height_in_map_units_minus1 == rhs.pic_height_in_map_units_minus1 ) && ( frame_crop_left_offset == rhs.frame_crop_left_offset ) && 683 ( frame_crop_right_offset == rhs.frame_crop_right_offset ) && ( frame_crop_top_offset == rhs.frame_crop_top_offset ) && 684 ( frame_crop_bottom_offset == rhs.frame_crop_bottom_offset ) && ( reserved2 == rhs.reserved2 ) && 685 ( pOffsetForRefFrame == rhs.pOffsetForRefFrame ) && ( pScalingLists == rhs.pScalingLists ) && 686 ( pSequenceParameterSetVui == rhs.pSequenceParameterSetVui ); 687 } 688 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SequenceParameterSet689 bool operator!=( H264SequenceParameterSet const & rhs ) const VULKAN_HPP_NOEXCEPT 690 { 691 return !operator==( rhs ); 692 } 693 694 public: 695 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SpsFlags flags = {}; 696 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ProfileIdc profile_idc = 697 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ProfileIdc::eBaseline; 698 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264LevelIdc level_idc = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264LevelIdc::e1_0; 699 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ChromaFormatIdc chroma_format_idc = 700 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ChromaFormatIdc::eMonochrome; 701 uint8_t seq_parameter_set_id = {}; 702 uint8_t bit_depth_luma_minus8 = {}; 703 uint8_t bit_depth_chroma_minus8 = {}; 704 uint8_t log2_max_frame_num_minus4 = {}; 705 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PocType pic_order_cnt_type = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PocType::e0; 706 int32_t offset_for_non_ref_pic = {}; 707 int32_t offset_for_top_to_bottom_field = {}; 708 uint8_t log2_max_pic_order_cnt_lsb_minus4 = {}; 709 uint8_t num_ref_frames_in_pic_order_cnt_cycle = {}; 710 uint8_t max_num_ref_frames = {}; 711 uint8_t reserved1 = {}; 712 uint32_t pic_width_in_mbs_minus1 = {}; 713 uint32_t pic_height_in_map_units_minus1 = {}; 714 uint32_t frame_crop_left_offset = {}; 715 uint32_t frame_crop_right_offset = {}; 716 uint32_t frame_crop_top_offset = {}; 717 uint32_t frame_crop_bottom_offset = {}; 718 uint32_t reserved2 = {}; 719 const int32_t * pOffsetForRefFrame = {}; 720 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ScalingLists * pScalingLists = {}; 721 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SequenceParameterSetVui * pSequenceParameterSetVui = {}; 722 }; 723 724 struct H264PpsFlags 725 { 726 using NativeType = StdVideoH264PpsFlags; 727 operator StdVideoH264PpsFlags const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PpsFlags728 operator StdVideoH264PpsFlags const &() const VULKAN_HPP_NOEXCEPT 729 { 730 return *reinterpret_cast<const StdVideoH264PpsFlags *>( this ); 731 } 732 operator StdVideoH264PpsFlags&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PpsFlags733 operator StdVideoH264PpsFlags &() VULKAN_HPP_NOEXCEPT 734 { 735 return *reinterpret_cast<StdVideoH264PpsFlags *>( this ); 736 } 737 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PpsFlags738 bool operator==( H264PpsFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 739 { 740 return ( transform_8x8_mode_flag == rhs.transform_8x8_mode_flag ) && ( redundant_pic_cnt_present_flag == rhs.redundant_pic_cnt_present_flag ) && 741 ( constrained_intra_pred_flag == rhs.constrained_intra_pred_flag ) && 742 ( deblocking_filter_control_present_flag == rhs.deblocking_filter_control_present_flag ) && ( weighted_pred_flag == rhs.weighted_pred_flag ) && 743 ( bottom_field_pic_order_in_frame_present_flag == rhs.bottom_field_pic_order_in_frame_present_flag ) && 744 ( entropy_coding_mode_flag == rhs.entropy_coding_mode_flag ) && ( pic_scaling_matrix_present_flag == rhs.pic_scaling_matrix_present_flag ); 745 } 746 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PpsFlags747 bool operator!=( H264PpsFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 748 { 749 return !operator==( rhs ); 750 } 751 752 public: 753 uint32_t transform_8x8_mode_flag : 1; 754 uint32_t redundant_pic_cnt_present_flag : 1; 755 uint32_t constrained_intra_pred_flag : 1; 756 uint32_t deblocking_filter_control_present_flag : 1; 757 uint32_t weighted_pred_flag : 1; 758 uint32_t bottom_field_pic_order_in_frame_present_flag : 1; 759 uint32_t entropy_coding_mode_flag : 1; 760 uint32_t pic_scaling_matrix_present_flag : 1; 761 }; 762 763 struct H264PictureParameterSet 764 { 765 using NativeType = StdVideoH264PictureParameterSet; 766 operator StdVideoH264PictureParameterSet const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PictureParameterSet767 operator StdVideoH264PictureParameterSet const &() const VULKAN_HPP_NOEXCEPT 768 { 769 return *reinterpret_cast<const StdVideoH264PictureParameterSet *>( this ); 770 } 771 operator StdVideoH264PictureParameterSet&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PictureParameterSet772 operator StdVideoH264PictureParameterSet &() VULKAN_HPP_NOEXCEPT 773 { 774 return *reinterpret_cast<StdVideoH264PictureParameterSet *>( this ); 775 } 776 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PictureParameterSet777 bool operator==( H264PictureParameterSet const & rhs ) const VULKAN_HPP_NOEXCEPT 778 { 779 return ( flags == rhs.flags ) && ( seq_parameter_set_id == rhs.seq_parameter_set_id ) && ( pic_parameter_set_id == rhs.pic_parameter_set_id ) && 780 ( num_ref_idx_l0_default_active_minus1 == rhs.num_ref_idx_l0_default_active_minus1 ) && 781 ( num_ref_idx_l1_default_active_minus1 == rhs.num_ref_idx_l1_default_active_minus1 ) && ( weighted_bipred_idc == rhs.weighted_bipred_idc ) && 782 ( pic_init_qp_minus26 == rhs.pic_init_qp_minus26 ) && ( pic_init_qs_minus26 == rhs.pic_init_qs_minus26 ) && 783 ( chroma_qp_index_offset == rhs.chroma_qp_index_offset ) && ( second_chroma_qp_index_offset == rhs.second_chroma_qp_index_offset ) && 784 ( pScalingLists == rhs.pScalingLists ); 785 } 786 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PictureParameterSet787 bool operator!=( H264PictureParameterSet const & rhs ) const VULKAN_HPP_NOEXCEPT 788 { 789 return !operator==( rhs ); 790 } 791 792 public: 793 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PpsFlags flags = {}; 794 uint8_t seq_parameter_set_id = {}; 795 uint8_t pic_parameter_set_id = {}; 796 uint8_t num_ref_idx_l0_default_active_minus1 = {}; 797 uint8_t num_ref_idx_l1_default_active_minus1 = {}; 798 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264WeightedBipredIdc weighted_bipred_idc = 799 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264WeightedBipredIdc::eDefault; 800 int8_t pic_init_qp_minus26 = {}; 801 int8_t pic_init_qs_minus26 = {}; 802 int8_t chroma_qp_index_offset = {}; 803 int8_t second_chroma_qp_index_offset = {}; 804 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ScalingLists * pScalingLists = {}; 805 }; 806 807 //=== vulkan_video_codec_h264std_decode === 808 809 struct DecodeH264PictureInfoFlags 810 { 811 using NativeType = StdVideoDecodeH264PictureInfoFlags; 812 operator StdVideoDecodeH264PictureInfoFlags const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264PictureInfoFlags813 operator StdVideoDecodeH264PictureInfoFlags const &() const VULKAN_HPP_NOEXCEPT 814 { 815 return *reinterpret_cast<const StdVideoDecodeH264PictureInfoFlags *>( this ); 816 } 817 operator StdVideoDecodeH264PictureInfoFlags&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264PictureInfoFlags818 operator StdVideoDecodeH264PictureInfoFlags &() VULKAN_HPP_NOEXCEPT 819 { 820 return *reinterpret_cast<StdVideoDecodeH264PictureInfoFlags *>( this ); 821 } 822 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264PictureInfoFlags823 bool operator==( DecodeH264PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 824 { 825 return ( field_pic_flag == rhs.field_pic_flag ) && ( is_intra == rhs.is_intra ) && ( IdrPicFlag == rhs.IdrPicFlag ) && 826 ( bottom_field_flag == rhs.bottom_field_flag ) && ( is_reference == rhs.is_reference ) && 827 ( complementary_field_pair == rhs.complementary_field_pair ); 828 } 829 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264PictureInfoFlags830 bool operator!=( DecodeH264PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 831 { 832 return !operator==( rhs ); 833 } 834 835 public: 836 uint32_t field_pic_flag : 1; 837 uint32_t is_intra : 1; 838 uint32_t IdrPicFlag : 1; 839 uint32_t bottom_field_flag : 1; 840 uint32_t is_reference : 1; 841 uint32_t complementary_field_pair : 1; 842 }; 843 844 struct DecodeH264PictureInfo 845 { 846 using NativeType = StdVideoDecodeH264PictureInfo; 847 operator StdVideoDecodeH264PictureInfo const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264PictureInfo848 operator StdVideoDecodeH264PictureInfo const &() const VULKAN_HPP_NOEXCEPT 849 { 850 return *reinterpret_cast<const StdVideoDecodeH264PictureInfo *>( this ); 851 } 852 operator StdVideoDecodeH264PictureInfo&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264PictureInfo853 operator StdVideoDecodeH264PictureInfo &() VULKAN_HPP_NOEXCEPT 854 { 855 return *reinterpret_cast<StdVideoDecodeH264PictureInfo *>( this ); 856 } 857 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264PictureInfo858 bool operator==( DecodeH264PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT 859 { 860 return ( flags == rhs.flags ) && ( seq_parameter_set_id == rhs.seq_parameter_set_id ) && ( pic_parameter_set_id == rhs.pic_parameter_set_id ) && 861 ( reserved1 == rhs.reserved1 ) && ( reserved2 == rhs.reserved2 ) && ( frame_num == rhs.frame_num ) && ( idr_pic_id == rhs.idr_pic_id ) && 862 ( PicOrderCnt == rhs.PicOrderCnt ); 863 } 864 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264PictureInfo865 bool operator!=( DecodeH264PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT 866 { 867 return !operator==( rhs ); 868 } 869 870 public: 871 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264PictureInfoFlags flags = {}; 872 uint8_t seq_parameter_set_id = {}; 873 uint8_t pic_parameter_set_id = {}; 874 uint8_t reserved1 = {}; 875 uint8_t reserved2 = {}; 876 uint16_t frame_num = {}; 877 uint16_t idr_pic_id = {}; 878 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<int32_t, STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_LIST_SIZE> PicOrderCnt = {}; 879 }; 880 881 struct DecodeH264ReferenceInfoFlags 882 { 883 using NativeType = StdVideoDecodeH264ReferenceInfoFlags; 884 operator StdVideoDecodeH264ReferenceInfoFlags const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264ReferenceInfoFlags885 operator StdVideoDecodeH264ReferenceInfoFlags const &() const VULKAN_HPP_NOEXCEPT 886 { 887 return *reinterpret_cast<const StdVideoDecodeH264ReferenceInfoFlags *>( this ); 888 } 889 operator StdVideoDecodeH264ReferenceInfoFlags&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264ReferenceInfoFlags890 operator StdVideoDecodeH264ReferenceInfoFlags &() VULKAN_HPP_NOEXCEPT 891 { 892 return *reinterpret_cast<StdVideoDecodeH264ReferenceInfoFlags *>( this ); 893 } 894 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264ReferenceInfoFlags895 bool operator==( DecodeH264ReferenceInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 896 { 897 return ( top_field_flag == rhs.top_field_flag ) && ( bottom_field_flag == rhs.bottom_field_flag ) && 898 ( used_for_long_term_reference == rhs.used_for_long_term_reference ) && ( is_non_existing == rhs.is_non_existing ); 899 } 900 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264ReferenceInfoFlags901 bool operator!=( DecodeH264ReferenceInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 902 { 903 return !operator==( rhs ); 904 } 905 906 public: 907 uint32_t top_field_flag : 1; 908 uint32_t bottom_field_flag : 1; 909 uint32_t used_for_long_term_reference : 1; 910 uint32_t is_non_existing : 1; 911 }; 912 913 struct DecodeH264ReferenceInfo 914 { 915 using NativeType = StdVideoDecodeH264ReferenceInfo; 916 operator StdVideoDecodeH264ReferenceInfo const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264ReferenceInfo917 operator StdVideoDecodeH264ReferenceInfo const &() const VULKAN_HPP_NOEXCEPT 918 { 919 return *reinterpret_cast<const StdVideoDecodeH264ReferenceInfo *>( this ); 920 } 921 operator StdVideoDecodeH264ReferenceInfo&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264ReferenceInfo922 operator StdVideoDecodeH264ReferenceInfo &() VULKAN_HPP_NOEXCEPT 923 { 924 return *reinterpret_cast<StdVideoDecodeH264ReferenceInfo *>( this ); 925 } 926 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264ReferenceInfo927 bool operator==( DecodeH264ReferenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT 928 { 929 return ( flags == rhs.flags ) && ( FrameNum == rhs.FrameNum ) && ( reserved == rhs.reserved ) && ( PicOrderCnt == rhs.PicOrderCnt ); 930 } 931 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264ReferenceInfo932 bool operator!=( DecodeH264ReferenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT 933 { 934 return !operator==( rhs ); 935 } 936 937 public: 938 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264ReferenceInfoFlags flags = {}; 939 uint16_t FrameNum = {}; 940 uint16_t reserved = {}; 941 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<int32_t, STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_LIST_SIZE> PicOrderCnt = {}; 942 }; 943 944 //=== vulkan_video_codec_h264std_encode === 945 946 struct EncodeH264WeightTableFlags 947 { 948 using NativeType = StdVideoEncodeH264WeightTableFlags; 949 operator StdVideoEncodeH264WeightTableFlags const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264WeightTableFlags950 operator StdVideoEncodeH264WeightTableFlags const &() const VULKAN_HPP_NOEXCEPT 951 { 952 return *reinterpret_cast<const StdVideoEncodeH264WeightTableFlags *>( this ); 953 } 954 operator StdVideoEncodeH264WeightTableFlags&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264WeightTableFlags955 operator StdVideoEncodeH264WeightTableFlags &() VULKAN_HPP_NOEXCEPT 956 { 957 return *reinterpret_cast<StdVideoEncodeH264WeightTableFlags *>( this ); 958 } 959 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264WeightTableFlags960 bool operator==( EncodeH264WeightTableFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 961 { 962 return ( luma_weight_l0_flag == rhs.luma_weight_l0_flag ) && ( chroma_weight_l0_flag == rhs.chroma_weight_l0_flag ) && 963 ( luma_weight_l1_flag == rhs.luma_weight_l1_flag ) && ( chroma_weight_l1_flag == rhs.chroma_weight_l1_flag ); 964 } 965 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264WeightTableFlags966 bool operator!=( EncodeH264WeightTableFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 967 { 968 return !operator==( rhs ); 969 } 970 971 public: 972 uint32_t luma_weight_l0_flag = {}; 973 uint32_t chroma_weight_l0_flag = {}; 974 uint32_t luma_weight_l1_flag = {}; 975 uint32_t chroma_weight_l1_flag = {}; 976 }; 977 978 struct EncodeH264WeightTable 979 { 980 using NativeType = StdVideoEncodeH264WeightTable; 981 operator StdVideoEncodeH264WeightTable const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264WeightTable982 operator StdVideoEncodeH264WeightTable const &() const VULKAN_HPP_NOEXCEPT 983 { 984 return *reinterpret_cast<const StdVideoEncodeH264WeightTable *>( this ); 985 } 986 operator StdVideoEncodeH264WeightTable&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264WeightTable987 operator StdVideoEncodeH264WeightTable &() VULKAN_HPP_NOEXCEPT 988 { 989 return *reinterpret_cast<StdVideoEncodeH264WeightTable *>( this ); 990 } 991 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264WeightTable992 bool operator==( EncodeH264WeightTable const & rhs ) const VULKAN_HPP_NOEXCEPT 993 { 994 return ( flags == rhs.flags ) && ( luma_log2_weight_denom == rhs.luma_log2_weight_denom ) && 995 ( chroma_log2_weight_denom == rhs.chroma_log2_weight_denom ) && ( luma_weight_l0 == rhs.luma_weight_l0 ) && 996 ( luma_offset_l0 == rhs.luma_offset_l0 ) && ( chroma_weight_l0 == rhs.chroma_weight_l0 ) && ( chroma_offset_l0 == rhs.chroma_offset_l0 ) && 997 ( luma_weight_l1 == rhs.luma_weight_l1 ) && ( luma_offset_l1 == rhs.luma_offset_l1 ) && ( chroma_weight_l1 == rhs.chroma_weight_l1 ) && 998 ( chroma_offset_l1 == rhs.chroma_offset_l1 ); 999 } 1000 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264WeightTable1001 bool operator!=( EncodeH264WeightTable const & rhs ) const VULKAN_HPP_NOEXCEPT 1002 { 1003 return !operator==( rhs ); 1004 } 1005 1006 public: 1007 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264WeightTableFlags flags = {}; 1008 uint8_t luma_log2_weight_denom = {}; 1009 uint8_t chroma_log2_weight_denom = {}; 1010 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<int8_t, STD_VIDEO_H264_MAX_NUM_LIST_REF> luma_weight_l0 = {}; 1011 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<int8_t, STD_VIDEO_H264_MAX_NUM_LIST_REF> luma_offset_l0 = {}; 1012 VULKAN_HPP_NAMESPACE::ArrayWrapper2D<int8_t, STD_VIDEO_H264_MAX_NUM_LIST_REF, STD_VIDEO_H264_MAX_CHROMA_PLANES> chroma_weight_l0 = {}; 1013 VULKAN_HPP_NAMESPACE::ArrayWrapper2D<int8_t, STD_VIDEO_H264_MAX_NUM_LIST_REF, STD_VIDEO_H264_MAX_CHROMA_PLANES> chroma_offset_l0 = {}; 1014 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<int8_t, STD_VIDEO_H264_MAX_NUM_LIST_REF> luma_weight_l1 = {}; 1015 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<int8_t, STD_VIDEO_H264_MAX_NUM_LIST_REF> luma_offset_l1 = {}; 1016 VULKAN_HPP_NAMESPACE::ArrayWrapper2D<int8_t, STD_VIDEO_H264_MAX_NUM_LIST_REF, STD_VIDEO_H264_MAX_CHROMA_PLANES> chroma_weight_l1 = {}; 1017 VULKAN_HPP_NAMESPACE::ArrayWrapper2D<int8_t, STD_VIDEO_H264_MAX_NUM_LIST_REF, STD_VIDEO_H264_MAX_CHROMA_PLANES> chroma_offset_l1 = {}; 1018 }; 1019 1020 struct EncodeH264SliceHeaderFlags 1021 { 1022 using NativeType = StdVideoEncodeH264SliceHeaderFlags; 1023 operator StdVideoEncodeH264SliceHeaderFlags const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264SliceHeaderFlags1024 operator StdVideoEncodeH264SliceHeaderFlags const &() const VULKAN_HPP_NOEXCEPT 1025 { 1026 return *reinterpret_cast<const StdVideoEncodeH264SliceHeaderFlags *>( this ); 1027 } 1028 operator StdVideoEncodeH264SliceHeaderFlags&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264SliceHeaderFlags1029 operator StdVideoEncodeH264SliceHeaderFlags &() VULKAN_HPP_NOEXCEPT 1030 { 1031 return *reinterpret_cast<StdVideoEncodeH264SliceHeaderFlags *>( this ); 1032 } 1033 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264SliceHeaderFlags1034 bool operator==( EncodeH264SliceHeaderFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 1035 { 1036 return ( direct_spatial_mv_pred_flag == rhs.direct_spatial_mv_pred_flag ) && 1037 ( num_ref_idx_active_override_flag == rhs.num_ref_idx_active_override_flag ) && ( reserved == rhs.reserved ); 1038 } 1039 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264SliceHeaderFlags1040 bool operator!=( EncodeH264SliceHeaderFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 1041 { 1042 return !operator==( rhs ); 1043 } 1044 1045 public: 1046 uint32_t direct_spatial_mv_pred_flag : 1; 1047 uint32_t num_ref_idx_active_override_flag : 1; 1048 uint32_t reserved : 30; 1049 }; 1050 1051 struct EncodeH264PictureInfoFlags 1052 { 1053 using NativeType = StdVideoEncodeH264PictureInfoFlags; 1054 operator StdVideoEncodeH264PictureInfoFlags const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264PictureInfoFlags1055 operator StdVideoEncodeH264PictureInfoFlags const &() const VULKAN_HPP_NOEXCEPT 1056 { 1057 return *reinterpret_cast<const StdVideoEncodeH264PictureInfoFlags *>( this ); 1058 } 1059 operator StdVideoEncodeH264PictureInfoFlags&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264PictureInfoFlags1060 operator StdVideoEncodeH264PictureInfoFlags &() VULKAN_HPP_NOEXCEPT 1061 { 1062 return *reinterpret_cast<StdVideoEncodeH264PictureInfoFlags *>( this ); 1063 } 1064 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264PictureInfoFlags1065 bool operator==( EncodeH264PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 1066 { 1067 return ( IdrPicFlag == rhs.IdrPicFlag ) && ( is_reference == rhs.is_reference ) && 1068 ( no_output_of_prior_pics_flag == rhs.no_output_of_prior_pics_flag ) && ( long_term_reference_flag == rhs.long_term_reference_flag ) && 1069 ( adaptive_ref_pic_marking_mode_flag == rhs.adaptive_ref_pic_marking_mode_flag ) && ( reserved == rhs.reserved ); 1070 } 1071 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264PictureInfoFlags1072 bool operator!=( EncodeH264PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 1073 { 1074 return !operator==( rhs ); 1075 } 1076 1077 public: 1078 uint32_t IdrPicFlag : 1; 1079 uint32_t is_reference : 1; 1080 uint32_t no_output_of_prior_pics_flag : 1; 1081 uint32_t long_term_reference_flag : 1; 1082 uint32_t adaptive_ref_pic_marking_mode_flag : 1; 1083 uint32_t reserved : 27; 1084 }; 1085 1086 struct EncodeH264ReferenceInfoFlags 1087 { 1088 using NativeType = StdVideoEncodeH264ReferenceInfoFlags; 1089 operator StdVideoEncodeH264ReferenceInfoFlags const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceInfoFlags1090 operator StdVideoEncodeH264ReferenceInfoFlags const &() const VULKAN_HPP_NOEXCEPT 1091 { 1092 return *reinterpret_cast<const StdVideoEncodeH264ReferenceInfoFlags *>( this ); 1093 } 1094 operator StdVideoEncodeH264ReferenceInfoFlags&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceInfoFlags1095 operator StdVideoEncodeH264ReferenceInfoFlags &() VULKAN_HPP_NOEXCEPT 1096 { 1097 return *reinterpret_cast<StdVideoEncodeH264ReferenceInfoFlags *>( this ); 1098 } 1099 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceInfoFlags1100 bool operator==( EncodeH264ReferenceInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 1101 { 1102 return ( used_for_long_term_reference == rhs.used_for_long_term_reference ) && ( reserved == rhs.reserved ); 1103 } 1104 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceInfoFlags1105 bool operator!=( EncodeH264ReferenceInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 1106 { 1107 return !operator==( rhs ); 1108 } 1109 1110 public: 1111 uint32_t used_for_long_term_reference : 1; 1112 uint32_t reserved : 31; 1113 }; 1114 1115 struct EncodeH264ReferenceListsInfoFlags 1116 { 1117 using NativeType = StdVideoEncodeH264ReferenceListsInfoFlags; 1118 operator StdVideoEncodeH264ReferenceListsInfoFlags const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceListsInfoFlags1119 operator StdVideoEncodeH264ReferenceListsInfoFlags const &() const VULKAN_HPP_NOEXCEPT 1120 { 1121 return *reinterpret_cast<const StdVideoEncodeH264ReferenceListsInfoFlags *>( this ); 1122 } 1123 operator StdVideoEncodeH264ReferenceListsInfoFlags&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceListsInfoFlags1124 operator StdVideoEncodeH264ReferenceListsInfoFlags &() VULKAN_HPP_NOEXCEPT 1125 { 1126 return *reinterpret_cast<StdVideoEncodeH264ReferenceListsInfoFlags *>( this ); 1127 } 1128 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceListsInfoFlags1129 bool operator==( EncodeH264ReferenceListsInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 1130 { 1131 return ( ref_pic_list_modification_flag_l0 == rhs.ref_pic_list_modification_flag_l0 ) && 1132 ( ref_pic_list_modification_flag_l1 == rhs.ref_pic_list_modification_flag_l1 ) && ( reserved == rhs.reserved ); 1133 } 1134 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceListsInfoFlags1135 bool operator!=( EncodeH264ReferenceListsInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 1136 { 1137 return !operator==( rhs ); 1138 } 1139 1140 public: 1141 uint32_t ref_pic_list_modification_flag_l0 : 1; 1142 uint32_t ref_pic_list_modification_flag_l1 : 1; 1143 uint32_t reserved : 30; 1144 }; 1145 1146 struct EncodeH264RefListModEntry 1147 { 1148 using NativeType = StdVideoEncodeH264RefListModEntry; 1149 operator StdVideoEncodeH264RefListModEntry const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264RefListModEntry1150 operator StdVideoEncodeH264RefListModEntry const &() const VULKAN_HPP_NOEXCEPT 1151 { 1152 return *reinterpret_cast<const StdVideoEncodeH264RefListModEntry *>( this ); 1153 } 1154 operator StdVideoEncodeH264RefListModEntry&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264RefListModEntry1155 operator StdVideoEncodeH264RefListModEntry &() VULKAN_HPP_NOEXCEPT 1156 { 1157 return *reinterpret_cast<StdVideoEncodeH264RefListModEntry *>( this ); 1158 } 1159 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264RefListModEntry1160 bool operator==( EncodeH264RefListModEntry const & rhs ) const VULKAN_HPP_NOEXCEPT 1161 { 1162 return ( modification_of_pic_nums_idc == rhs.modification_of_pic_nums_idc ) && ( abs_diff_pic_num_minus1 == rhs.abs_diff_pic_num_minus1 ) && 1163 ( long_term_pic_num == rhs.long_term_pic_num ); 1164 } 1165 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264RefListModEntry1166 bool operator!=( EncodeH264RefListModEntry const & rhs ) const VULKAN_HPP_NOEXCEPT 1167 { 1168 return !operator==( rhs ); 1169 } 1170 1171 public: 1172 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ModificationOfPicNumsIdc modification_of_pic_nums_idc = 1173 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ModificationOfPicNumsIdc::eShortTermSubtract; 1174 uint16_t abs_diff_pic_num_minus1 = {}; 1175 uint16_t long_term_pic_num = {}; 1176 }; 1177 1178 struct EncodeH264RefPicMarkingEntry 1179 { 1180 using NativeType = StdVideoEncodeH264RefPicMarkingEntry; 1181 operator StdVideoEncodeH264RefPicMarkingEntry const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264RefPicMarkingEntry1182 operator StdVideoEncodeH264RefPicMarkingEntry const &() const VULKAN_HPP_NOEXCEPT 1183 { 1184 return *reinterpret_cast<const StdVideoEncodeH264RefPicMarkingEntry *>( this ); 1185 } 1186 operator StdVideoEncodeH264RefPicMarkingEntry&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264RefPicMarkingEntry1187 operator StdVideoEncodeH264RefPicMarkingEntry &() VULKAN_HPP_NOEXCEPT 1188 { 1189 return *reinterpret_cast<StdVideoEncodeH264RefPicMarkingEntry *>( this ); 1190 } 1191 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264RefPicMarkingEntry1192 bool operator==( EncodeH264RefPicMarkingEntry const & rhs ) const VULKAN_HPP_NOEXCEPT 1193 { 1194 return ( memory_management_control_operation == rhs.memory_management_control_operation ) && 1195 ( difference_of_pic_nums_minus1 == rhs.difference_of_pic_nums_minus1 ) && ( long_term_pic_num == rhs.long_term_pic_num ) && 1196 ( long_term_frame_idx == rhs.long_term_frame_idx ) && ( max_long_term_frame_idx_plus1 == rhs.max_long_term_frame_idx_plus1 ); 1197 } 1198 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264RefPicMarkingEntry1199 bool operator!=( EncodeH264RefPicMarkingEntry const & rhs ) const VULKAN_HPP_NOEXCEPT 1200 { 1201 return !operator==( rhs ); 1202 } 1203 1204 public: 1205 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264MemMgmtControlOp memory_management_control_operation = 1206 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264MemMgmtControlOp::eEnd; 1207 uint16_t difference_of_pic_nums_minus1 = {}; 1208 uint16_t long_term_pic_num = {}; 1209 uint16_t long_term_frame_idx = {}; 1210 uint16_t max_long_term_frame_idx_plus1 = {}; 1211 }; 1212 1213 struct EncodeH264ReferenceListsInfo 1214 { 1215 using NativeType = StdVideoEncodeH264ReferenceListsInfo; 1216 operator StdVideoEncodeH264ReferenceListsInfo const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceListsInfo1217 operator StdVideoEncodeH264ReferenceListsInfo const &() const VULKAN_HPP_NOEXCEPT 1218 { 1219 return *reinterpret_cast<const StdVideoEncodeH264ReferenceListsInfo *>( this ); 1220 } 1221 operator StdVideoEncodeH264ReferenceListsInfo&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceListsInfo1222 operator StdVideoEncodeH264ReferenceListsInfo &() VULKAN_HPP_NOEXCEPT 1223 { 1224 return *reinterpret_cast<StdVideoEncodeH264ReferenceListsInfo *>( this ); 1225 } 1226 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceListsInfo1227 bool operator==( EncodeH264ReferenceListsInfo const & rhs ) const VULKAN_HPP_NOEXCEPT 1228 { 1229 return ( flags == rhs.flags ) && ( num_ref_idx_l0_active_minus1 == rhs.num_ref_idx_l0_active_minus1 ) && 1230 ( num_ref_idx_l1_active_minus1 == rhs.num_ref_idx_l1_active_minus1 ) && ( RefPicList0 == rhs.RefPicList0 ) && 1231 ( RefPicList1 == rhs.RefPicList1 ) && ( refList0ModOpCount == rhs.refList0ModOpCount ) && ( refList1ModOpCount == rhs.refList1ModOpCount ) && 1232 ( refPicMarkingOpCount == rhs.refPicMarkingOpCount ) && ( reserved1 == rhs.reserved1 ) && 1233 ( pRefList0ModOperations == rhs.pRefList0ModOperations ) && ( pRefList1ModOperations == rhs.pRefList1ModOperations ) && 1234 ( pRefPicMarkingOperations == rhs.pRefPicMarkingOperations ); 1235 } 1236 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceListsInfo1237 bool operator!=( EncodeH264ReferenceListsInfo const & rhs ) const VULKAN_HPP_NOEXCEPT 1238 { 1239 return !operator==( rhs ); 1240 } 1241 1242 public: 1243 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceListsInfoFlags flags = {}; 1244 uint8_t num_ref_idx_l0_active_minus1 = {}; 1245 uint8_t num_ref_idx_l1_active_minus1 = {}; 1246 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_H264_MAX_NUM_LIST_REF> RefPicList0 = {}; 1247 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_H264_MAX_NUM_LIST_REF> RefPicList1 = {}; 1248 uint8_t refList0ModOpCount = {}; 1249 uint8_t refList1ModOpCount = {}; 1250 uint8_t refPicMarkingOpCount = {}; 1251 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, 7> reserved1 = {}; 1252 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264RefListModEntry * pRefList0ModOperations = {}; 1253 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264RefListModEntry * pRefList1ModOperations = {}; 1254 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264RefPicMarkingEntry * pRefPicMarkingOperations = {}; 1255 }; 1256 1257 struct EncodeH264PictureInfo 1258 { 1259 using NativeType = StdVideoEncodeH264PictureInfo; 1260 operator StdVideoEncodeH264PictureInfo const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264PictureInfo1261 operator StdVideoEncodeH264PictureInfo const &() const VULKAN_HPP_NOEXCEPT 1262 { 1263 return *reinterpret_cast<const StdVideoEncodeH264PictureInfo *>( this ); 1264 } 1265 operator StdVideoEncodeH264PictureInfo&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264PictureInfo1266 operator StdVideoEncodeH264PictureInfo &() VULKAN_HPP_NOEXCEPT 1267 { 1268 return *reinterpret_cast<StdVideoEncodeH264PictureInfo *>( this ); 1269 } 1270 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264PictureInfo1271 bool operator==( EncodeH264PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT 1272 { 1273 return ( flags == rhs.flags ) && ( seq_parameter_set_id == rhs.seq_parameter_set_id ) && ( pic_parameter_set_id == rhs.pic_parameter_set_id ) && 1274 ( idr_pic_id == rhs.idr_pic_id ) && ( primary_pic_type == rhs.primary_pic_type ) && ( frame_num == rhs.frame_num ) && 1275 ( PicOrderCnt == rhs.PicOrderCnt ) && ( temporal_id == rhs.temporal_id ) && ( reserved1 == rhs.reserved1 ) && ( pRefLists == rhs.pRefLists ); 1276 } 1277 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264PictureInfo1278 bool operator!=( EncodeH264PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT 1279 { 1280 return !operator==( rhs ); 1281 } 1282 1283 public: 1284 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264PictureInfoFlags flags = {}; 1285 uint8_t seq_parameter_set_id = {}; 1286 uint8_t pic_parameter_set_id = {}; 1287 uint16_t idr_pic_id = {}; 1288 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PictureType primary_pic_type = 1289 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PictureType::eP; 1290 uint32_t frame_num = {}; 1291 int32_t PicOrderCnt = {}; 1292 uint8_t temporal_id = {}; 1293 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, 3> reserved1 = {}; 1294 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceListsInfo * pRefLists = {}; 1295 }; 1296 1297 struct EncodeH264ReferenceInfo 1298 { 1299 using NativeType = StdVideoEncodeH264ReferenceInfo; 1300 operator StdVideoEncodeH264ReferenceInfo const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceInfo1301 operator StdVideoEncodeH264ReferenceInfo const &() const VULKAN_HPP_NOEXCEPT 1302 { 1303 return *reinterpret_cast<const StdVideoEncodeH264ReferenceInfo *>( this ); 1304 } 1305 operator StdVideoEncodeH264ReferenceInfo&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceInfo1306 operator StdVideoEncodeH264ReferenceInfo &() VULKAN_HPP_NOEXCEPT 1307 { 1308 return *reinterpret_cast<StdVideoEncodeH264ReferenceInfo *>( this ); 1309 } 1310 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceInfo1311 bool operator==( EncodeH264ReferenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT 1312 { 1313 return ( flags == rhs.flags ) && ( primary_pic_type == rhs.primary_pic_type ) && ( FrameNum == rhs.FrameNum ) && ( PicOrderCnt == rhs.PicOrderCnt ) && 1314 ( long_term_pic_num == rhs.long_term_pic_num ) && ( long_term_frame_idx == rhs.long_term_frame_idx ) && ( temporal_id == rhs.temporal_id ); 1315 } 1316 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceInfo1317 bool operator!=( EncodeH264ReferenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT 1318 { 1319 return !operator==( rhs ); 1320 } 1321 1322 public: 1323 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceInfoFlags flags = {}; 1324 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PictureType primary_pic_type = 1325 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PictureType::eP; 1326 uint32_t FrameNum = {}; 1327 int32_t PicOrderCnt = {}; 1328 uint16_t long_term_pic_num = {}; 1329 uint16_t long_term_frame_idx = {}; 1330 uint8_t temporal_id = {}; 1331 }; 1332 1333 struct EncodeH264SliceHeader 1334 { 1335 using NativeType = StdVideoEncodeH264SliceHeader; 1336 operator StdVideoEncodeH264SliceHeader const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264SliceHeader1337 operator StdVideoEncodeH264SliceHeader const &() const VULKAN_HPP_NOEXCEPT 1338 { 1339 return *reinterpret_cast<const StdVideoEncodeH264SliceHeader *>( this ); 1340 } 1341 operator StdVideoEncodeH264SliceHeader&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264SliceHeader1342 operator StdVideoEncodeH264SliceHeader &() VULKAN_HPP_NOEXCEPT 1343 { 1344 return *reinterpret_cast<StdVideoEncodeH264SliceHeader *>( this ); 1345 } 1346 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264SliceHeader1347 bool operator==( EncodeH264SliceHeader const & rhs ) const VULKAN_HPP_NOEXCEPT 1348 { 1349 return ( flags == rhs.flags ) && ( first_mb_in_slice == rhs.first_mb_in_slice ) && ( slice_type == rhs.slice_type ) && 1350 ( slice_alpha_c0_offset_div2 == rhs.slice_alpha_c0_offset_div2 ) && ( slice_beta_offset_div2 == rhs.slice_beta_offset_div2 ) && 1351 ( slice_qp_delta == rhs.slice_qp_delta ) && ( reserved1 == rhs.reserved1 ) && ( cabac_init_idc == rhs.cabac_init_idc ) && 1352 ( disable_deblocking_filter_idc == rhs.disable_deblocking_filter_idc ) && ( pWeightTable == rhs.pWeightTable ); 1353 } 1354 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264SliceHeader1355 bool operator!=( EncodeH264SliceHeader const & rhs ) const VULKAN_HPP_NOEXCEPT 1356 { 1357 return !operator==( rhs ); 1358 } 1359 1360 public: 1361 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264SliceHeaderFlags flags = {}; 1362 uint32_t first_mb_in_slice = {}; 1363 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SliceType slice_type = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SliceType::eP; 1364 int8_t slice_alpha_c0_offset_div2 = {}; 1365 int8_t slice_beta_offset_div2 = {}; 1366 int8_t slice_qp_delta = {}; 1367 uint8_t reserved1 = {}; 1368 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264CabacInitIdc cabac_init_idc = 1369 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264CabacInitIdc::e0; 1370 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264DisableDeblockingFilterIdc disable_deblocking_filter_idc = 1371 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264DisableDeblockingFilterIdc::eDisabled; 1372 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264WeightTable * pWeightTable = {}; 1373 }; 1374 1375 //=== vulkan_video_codec_h265std === 1376 1377 struct H265DecPicBufMgr 1378 { 1379 using NativeType = StdVideoH265DecPicBufMgr; 1380 operator StdVideoH265DecPicBufMgr const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265DecPicBufMgr1381 operator StdVideoH265DecPicBufMgr const &() const VULKAN_HPP_NOEXCEPT 1382 { 1383 return *reinterpret_cast<const StdVideoH265DecPicBufMgr *>( this ); 1384 } 1385 operator StdVideoH265DecPicBufMgr&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265DecPicBufMgr1386 operator StdVideoH265DecPicBufMgr &() VULKAN_HPP_NOEXCEPT 1387 { 1388 return *reinterpret_cast<StdVideoH265DecPicBufMgr *>( this ); 1389 } 1390 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265DecPicBufMgr1391 bool operator==( H265DecPicBufMgr const & rhs ) const VULKAN_HPP_NOEXCEPT 1392 { 1393 return ( max_latency_increase_plus1 == rhs.max_latency_increase_plus1 ) && ( max_dec_pic_buffering_minus1 == rhs.max_dec_pic_buffering_minus1 ) && 1394 ( max_num_reorder_pics == rhs.max_num_reorder_pics ); 1395 } 1396 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265DecPicBufMgr1397 bool operator!=( H265DecPicBufMgr const & rhs ) const VULKAN_HPP_NOEXCEPT 1398 { 1399 return !operator==( rhs ); 1400 } 1401 1402 public: 1403 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint32_t, STD_VIDEO_H265_SUBLAYERS_LIST_SIZE> max_latency_increase_plus1 = {}; 1404 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_H265_SUBLAYERS_LIST_SIZE> max_dec_pic_buffering_minus1 = {}; 1405 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_H265_SUBLAYERS_LIST_SIZE> max_num_reorder_pics = {}; 1406 }; 1407 1408 struct H265SubLayerHrdParameters 1409 { 1410 using NativeType = StdVideoH265SubLayerHrdParameters; 1411 operator StdVideoH265SubLayerHrdParameters const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SubLayerHrdParameters1412 operator StdVideoH265SubLayerHrdParameters const &() const VULKAN_HPP_NOEXCEPT 1413 { 1414 return *reinterpret_cast<const StdVideoH265SubLayerHrdParameters *>( this ); 1415 } 1416 operator StdVideoH265SubLayerHrdParameters&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SubLayerHrdParameters1417 operator StdVideoH265SubLayerHrdParameters &() VULKAN_HPP_NOEXCEPT 1418 { 1419 return *reinterpret_cast<StdVideoH265SubLayerHrdParameters *>( this ); 1420 } 1421 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SubLayerHrdParameters1422 bool operator==( H265SubLayerHrdParameters const & rhs ) const VULKAN_HPP_NOEXCEPT 1423 { 1424 return ( bit_rate_value_minus1 == rhs.bit_rate_value_minus1 ) && ( cpb_size_value_minus1 == rhs.cpb_size_value_minus1 ) && 1425 ( cpb_size_du_value_minus1 == rhs.cpb_size_du_value_minus1 ) && ( bit_rate_du_value_minus1 == rhs.bit_rate_du_value_minus1 ) && 1426 ( cbr_flag == rhs.cbr_flag ); 1427 } 1428 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SubLayerHrdParameters1429 bool operator!=( H265SubLayerHrdParameters const & rhs ) const VULKAN_HPP_NOEXCEPT 1430 { 1431 return !operator==( rhs ); 1432 } 1433 1434 public: 1435 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint32_t, STD_VIDEO_H265_CPB_CNT_LIST_SIZE> bit_rate_value_minus1 = {}; 1436 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint32_t, STD_VIDEO_H265_CPB_CNT_LIST_SIZE> cpb_size_value_minus1 = {}; 1437 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint32_t, STD_VIDEO_H265_CPB_CNT_LIST_SIZE> cpb_size_du_value_minus1 = {}; 1438 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint32_t, STD_VIDEO_H265_CPB_CNT_LIST_SIZE> bit_rate_du_value_minus1 = {}; 1439 uint32_t cbr_flag = {}; 1440 }; 1441 1442 struct H265HrdFlags 1443 { 1444 using NativeType = StdVideoH265HrdFlags; 1445 operator StdVideoH265HrdFlags const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265HrdFlags1446 operator StdVideoH265HrdFlags const &() const VULKAN_HPP_NOEXCEPT 1447 { 1448 return *reinterpret_cast<const StdVideoH265HrdFlags *>( this ); 1449 } 1450 operator StdVideoH265HrdFlags&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265HrdFlags1451 operator StdVideoH265HrdFlags &() VULKAN_HPP_NOEXCEPT 1452 { 1453 return *reinterpret_cast<StdVideoH265HrdFlags *>( this ); 1454 } 1455 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265HrdFlags1456 bool operator==( H265HrdFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 1457 { 1458 return ( nal_hrd_parameters_present_flag == rhs.nal_hrd_parameters_present_flag ) && 1459 ( vcl_hrd_parameters_present_flag == rhs.vcl_hrd_parameters_present_flag ) && 1460 ( sub_pic_hrd_params_present_flag == rhs.sub_pic_hrd_params_present_flag ) && 1461 ( sub_pic_cpb_params_in_pic_timing_sei_flag == rhs.sub_pic_cpb_params_in_pic_timing_sei_flag ) && 1462 ( fixed_pic_rate_general_flag == rhs.fixed_pic_rate_general_flag ) && ( fixed_pic_rate_within_cvs_flag == rhs.fixed_pic_rate_within_cvs_flag ) && 1463 ( low_delay_hrd_flag == rhs.low_delay_hrd_flag ); 1464 } 1465 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265HrdFlags1466 bool operator!=( H265HrdFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 1467 { 1468 return !operator==( rhs ); 1469 } 1470 1471 public: 1472 uint32_t nal_hrd_parameters_present_flag : 1; 1473 uint32_t vcl_hrd_parameters_present_flag : 1; 1474 uint32_t sub_pic_hrd_params_present_flag : 1; 1475 uint32_t sub_pic_cpb_params_in_pic_timing_sei_flag : 1; 1476 uint32_t fixed_pic_rate_general_flag : 8; 1477 uint32_t fixed_pic_rate_within_cvs_flag : 8; 1478 uint32_t low_delay_hrd_flag : 8; 1479 }; 1480 1481 struct H265HrdParameters 1482 { 1483 using NativeType = StdVideoH265HrdParameters; 1484 operator StdVideoH265HrdParameters const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265HrdParameters1485 operator StdVideoH265HrdParameters const &() const VULKAN_HPP_NOEXCEPT 1486 { 1487 return *reinterpret_cast<const StdVideoH265HrdParameters *>( this ); 1488 } 1489 operator StdVideoH265HrdParameters&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265HrdParameters1490 operator StdVideoH265HrdParameters &() VULKAN_HPP_NOEXCEPT 1491 { 1492 return *reinterpret_cast<StdVideoH265HrdParameters *>( this ); 1493 } 1494 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265HrdParameters1495 bool operator==( H265HrdParameters const & rhs ) const VULKAN_HPP_NOEXCEPT 1496 { 1497 return ( flags == rhs.flags ) && ( tick_divisor_minus2 == rhs.tick_divisor_minus2 ) && 1498 ( du_cpb_removal_delay_increment_length_minus1 == rhs.du_cpb_removal_delay_increment_length_minus1 ) && 1499 ( dpb_output_delay_du_length_minus1 == rhs.dpb_output_delay_du_length_minus1 ) && ( bit_rate_scale == rhs.bit_rate_scale ) && 1500 ( cpb_size_scale == rhs.cpb_size_scale ) && ( cpb_size_du_scale == rhs.cpb_size_du_scale ) && 1501 ( initial_cpb_removal_delay_length_minus1 == rhs.initial_cpb_removal_delay_length_minus1 ) && 1502 ( au_cpb_removal_delay_length_minus1 == rhs.au_cpb_removal_delay_length_minus1 ) && 1503 ( dpb_output_delay_length_minus1 == rhs.dpb_output_delay_length_minus1 ) && ( cpb_cnt_minus1 == rhs.cpb_cnt_minus1 ) && 1504 ( elemental_duration_in_tc_minus1 == rhs.elemental_duration_in_tc_minus1 ) && ( reserved == rhs.reserved ) && 1505 ( pSubLayerHrdParametersNal == rhs.pSubLayerHrdParametersNal ) && ( pSubLayerHrdParametersVcl == rhs.pSubLayerHrdParametersVcl ); 1506 } 1507 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265HrdParameters1508 bool operator!=( H265HrdParameters const & rhs ) const VULKAN_HPP_NOEXCEPT 1509 { 1510 return !operator==( rhs ); 1511 } 1512 1513 public: 1514 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265HrdFlags flags = {}; 1515 uint8_t tick_divisor_minus2 = {}; 1516 uint8_t du_cpb_removal_delay_increment_length_minus1 = {}; 1517 uint8_t dpb_output_delay_du_length_minus1 = {}; 1518 uint8_t bit_rate_scale = {}; 1519 uint8_t cpb_size_scale = {}; 1520 uint8_t cpb_size_du_scale = {}; 1521 uint8_t initial_cpb_removal_delay_length_minus1 = {}; 1522 uint8_t au_cpb_removal_delay_length_minus1 = {}; 1523 uint8_t dpb_output_delay_length_minus1 = {}; 1524 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_H265_SUBLAYERS_LIST_SIZE> cpb_cnt_minus1 = {}; 1525 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint16_t, STD_VIDEO_H265_SUBLAYERS_LIST_SIZE> elemental_duration_in_tc_minus1 = {}; 1526 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint16_t, 3> reserved = {}; 1527 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SubLayerHrdParameters * pSubLayerHrdParametersNal = {}; 1528 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SubLayerHrdParameters * pSubLayerHrdParametersVcl = {}; 1529 }; 1530 1531 struct H265VpsFlags 1532 { 1533 using NativeType = StdVideoH265VpsFlags; 1534 operator StdVideoH265VpsFlags const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265VpsFlags1535 operator StdVideoH265VpsFlags const &() const VULKAN_HPP_NOEXCEPT 1536 { 1537 return *reinterpret_cast<const StdVideoH265VpsFlags *>( this ); 1538 } 1539 operator StdVideoH265VpsFlags&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265VpsFlags1540 operator StdVideoH265VpsFlags &() VULKAN_HPP_NOEXCEPT 1541 { 1542 return *reinterpret_cast<StdVideoH265VpsFlags *>( this ); 1543 } 1544 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265VpsFlags1545 bool operator==( H265VpsFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 1546 { 1547 return ( vps_temporal_id_nesting_flag == rhs.vps_temporal_id_nesting_flag ) && 1548 ( vps_sub_layer_ordering_info_present_flag == rhs.vps_sub_layer_ordering_info_present_flag ) && 1549 ( vps_timing_info_present_flag == rhs.vps_timing_info_present_flag ) && 1550 ( vps_poc_proportional_to_timing_flag == rhs.vps_poc_proportional_to_timing_flag ); 1551 } 1552 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265VpsFlags1553 bool operator!=( H265VpsFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 1554 { 1555 return !operator==( rhs ); 1556 } 1557 1558 public: 1559 uint32_t vps_temporal_id_nesting_flag : 1; 1560 uint32_t vps_sub_layer_ordering_info_present_flag : 1; 1561 uint32_t vps_timing_info_present_flag : 1; 1562 uint32_t vps_poc_proportional_to_timing_flag : 1; 1563 }; 1564 1565 struct H265ProfileTierLevelFlags 1566 { 1567 using NativeType = StdVideoH265ProfileTierLevelFlags; 1568 operator StdVideoH265ProfileTierLevelFlags const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ProfileTierLevelFlags1569 operator StdVideoH265ProfileTierLevelFlags const &() const VULKAN_HPP_NOEXCEPT 1570 { 1571 return *reinterpret_cast<const StdVideoH265ProfileTierLevelFlags *>( this ); 1572 } 1573 operator StdVideoH265ProfileTierLevelFlags&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ProfileTierLevelFlags1574 operator StdVideoH265ProfileTierLevelFlags &() VULKAN_HPP_NOEXCEPT 1575 { 1576 return *reinterpret_cast<StdVideoH265ProfileTierLevelFlags *>( this ); 1577 } 1578 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ProfileTierLevelFlags1579 bool operator==( H265ProfileTierLevelFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 1580 { 1581 return ( general_tier_flag == rhs.general_tier_flag ) && ( general_progressive_source_flag == rhs.general_progressive_source_flag ) && 1582 ( general_interlaced_source_flag == rhs.general_interlaced_source_flag ) && 1583 ( general_non_packed_constraint_flag == rhs.general_non_packed_constraint_flag ) && 1584 ( general_frame_only_constraint_flag == rhs.general_frame_only_constraint_flag ); 1585 } 1586 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ProfileTierLevelFlags1587 bool operator!=( H265ProfileTierLevelFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 1588 { 1589 return !operator==( rhs ); 1590 } 1591 1592 public: 1593 uint32_t general_tier_flag : 1; 1594 uint32_t general_progressive_source_flag : 1; 1595 uint32_t general_interlaced_source_flag : 1; 1596 uint32_t general_non_packed_constraint_flag : 1; 1597 uint32_t general_frame_only_constraint_flag : 1; 1598 }; 1599 1600 struct H265ProfileTierLevel 1601 { 1602 using NativeType = StdVideoH265ProfileTierLevel; 1603 operator StdVideoH265ProfileTierLevel const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ProfileTierLevel1604 operator StdVideoH265ProfileTierLevel const &() const VULKAN_HPP_NOEXCEPT 1605 { 1606 return *reinterpret_cast<const StdVideoH265ProfileTierLevel *>( this ); 1607 } 1608 operator StdVideoH265ProfileTierLevel&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ProfileTierLevel1609 operator StdVideoH265ProfileTierLevel &() VULKAN_HPP_NOEXCEPT 1610 { 1611 return *reinterpret_cast<StdVideoH265ProfileTierLevel *>( this ); 1612 } 1613 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ProfileTierLevel1614 bool operator==( H265ProfileTierLevel const & rhs ) const VULKAN_HPP_NOEXCEPT 1615 { 1616 return ( flags == rhs.flags ) && ( general_profile_idc == rhs.general_profile_idc ) && ( general_level_idc == rhs.general_level_idc ); 1617 } 1618 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ProfileTierLevel1619 bool operator!=( H265ProfileTierLevel const & rhs ) const VULKAN_HPP_NOEXCEPT 1620 { 1621 return !operator==( rhs ); 1622 } 1623 1624 public: 1625 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ProfileTierLevelFlags flags = {}; 1626 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ProfileIdc general_profile_idc = 1627 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ProfileIdc::eMain; 1628 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265LevelIdc general_level_idc = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265LevelIdc::e1_0; 1629 }; 1630 1631 struct H265VideoParameterSet 1632 { 1633 using NativeType = StdVideoH265VideoParameterSet; 1634 operator StdVideoH265VideoParameterSet const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265VideoParameterSet1635 operator StdVideoH265VideoParameterSet const &() const VULKAN_HPP_NOEXCEPT 1636 { 1637 return *reinterpret_cast<const StdVideoH265VideoParameterSet *>( this ); 1638 } 1639 operator StdVideoH265VideoParameterSet&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265VideoParameterSet1640 operator StdVideoH265VideoParameterSet &() VULKAN_HPP_NOEXCEPT 1641 { 1642 return *reinterpret_cast<StdVideoH265VideoParameterSet *>( this ); 1643 } 1644 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265VideoParameterSet1645 bool operator==( H265VideoParameterSet const & rhs ) const VULKAN_HPP_NOEXCEPT 1646 { 1647 return ( flags == rhs.flags ) && ( vps_video_parameter_set_id == rhs.vps_video_parameter_set_id ) && 1648 ( vps_max_sub_layers_minus1 == rhs.vps_max_sub_layers_minus1 ) && ( reserved1 == rhs.reserved1 ) && ( reserved2 == rhs.reserved2 ) && 1649 ( vps_num_units_in_tick == rhs.vps_num_units_in_tick ) && ( vps_time_scale == rhs.vps_time_scale ) && 1650 ( vps_num_ticks_poc_diff_one_minus1 == rhs.vps_num_ticks_poc_diff_one_minus1 ) && ( reserved3 == rhs.reserved3 ) && 1651 ( pDecPicBufMgr == rhs.pDecPicBufMgr ) && ( pHrdParameters == rhs.pHrdParameters ) && ( pProfileTierLevel == rhs.pProfileTierLevel ); 1652 } 1653 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265VideoParameterSet1654 bool operator!=( H265VideoParameterSet const & rhs ) const VULKAN_HPP_NOEXCEPT 1655 { 1656 return !operator==( rhs ); 1657 } 1658 1659 public: 1660 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265VpsFlags flags = {}; 1661 uint8_t vps_video_parameter_set_id = {}; 1662 uint8_t vps_max_sub_layers_minus1 = {}; 1663 uint8_t reserved1 = {}; 1664 uint8_t reserved2 = {}; 1665 uint32_t vps_num_units_in_tick = {}; 1666 uint32_t vps_time_scale = {}; 1667 uint32_t vps_num_ticks_poc_diff_one_minus1 = {}; 1668 uint32_t reserved3 = {}; 1669 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265DecPicBufMgr * pDecPicBufMgr = {}; 1670 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265HrdParameters * pHrdParameters = {}; 1671 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ProfileTierLevel * pProfileTierLevel = {}; 1672 }; 1673 1674 struct H265ScalingLists 1675 { 1676 using NativeType = StdVideoH265ScalingLists; 1677 operator StdVideoH265ScalingLists const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingLists1678 operator StdVideoH265ScalingLists const &() const VULKAN_HPP_NOEXCEPT 1679 { 1680 return *reinterpret_cast<const StdVideoH265ScalingLists *>( this ); 1681 } 1682 operator StdVideoH265ScalingLists&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingLists1683 operator StdVideoH265ScalingLists &() VULKAN_HPP_NOEXCEPT 1684 { 1685 return *reinterpret_cast<StdVideoH265ScalingLists *>( this ); 1686 } 1687 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingLists1688 bool operator==( H265ScalingLists const & rhs ) const VULKAN_HPP_NOEXCEPT 1689 { 1690 return ( ScalingList4x4 == rhs.ScalingList4x4 ) && ( ScalingList8x8 == rhs.ScalingList8x8 ) && ( ScalingList16x16 == rhs.ScalingList16x16 ) && 1691 ( ScalingList32x32 == rhs.ScalingList32x32 ) && ( ScalingListDCCoef16x16 == rhs.ScalingListDCCoef16x16 ) && 1692 ( ScalingListDCCoef32x32 == rhs.ScalingListDCCoef32x32 ); 1693 } 1694 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingLists1695 bool operator!=( H265ScalingLists const & rhs ) const VULKAN_HPP_NOEXCEPT 1696 { 1697 return !operator==( rhs ); 1698 } 1699 1700 public: 1701 VULKAN_HPP_NAMESPACE::ArrayWrapper2D<uint8_t, STD_VIDEO_H265_SCALING_LIST_4X4_NUM_LISTS, STD_VIDEO_H265_SCALING_LIST_4X4_NUM_ELEMENTS> 1702 ScalingList4x4 = {}; 1703 VULKAN_HPP_NAMESPACE::ArrayWrapper2D<uint8_t, STD_VIDEO_H265_SCALING_LIST_8X8_NUM_LISTS, STD_VIDEO_H265_SCALING_LIST_8X8_NUM_ELEMENTS> 1704 ScalingList8x8 = {}; 1705 VULKAN_HPP_NAMESPACE::ArrayWrapper2D<uint8_t, STD_VIDEO_H265_SCALING_LIST_16X16_NUM_LISTS, STD_VIDEO_H265_SCALING_LIST_16X16_NUM_ELEMENTS> 1706 ScalingList16x16 = {}; 1707 VULKAN_HPP_NAMESPACE::ArrayWrapper2D<uint8_t, STD_VIDEO_H265_SCALING_LIST_32X32_NUM_LISTS, STD_VIDEO_H265_SCALING_LIST_32X32_NUM_ELEMENTS> 1708 ScalingList32x32 = {}; 1709 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_H265_SCALING_LIST_16X16_NUM_LISTS> ScalingListDCCoef16x16 = {}; 1710 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_H265_SCALING_LIST_32X32_NUM_LISTS> ScalingListDCCoef32x32 = {}; 1711 }; 1712 1713 struct H265SpsVuiFlags 1714 { 1715 using NativeType = StdVideoH265SpsVuiFlags; 1716 operator StdVideoH265SpsVuiFlags const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SpsVuiFlags1717 operator StdVideoH265SpsVuiFlags const &() const VULKAN_HPP_NOEXCEPT 1718 { 1719 return *reinterpret_cast<const StdVideoH265SpsVuiFlags *>( this ); 1720 } 1721 operator StdVideoH265SpsVuiFlags&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SpsVuiFlags1722 operator StdVideoH265SpsVuiFlags &() VULKAN_HPP_NOEXCEPT 1723 { 1724 return *reinterpret_cast<StdVideoH265SpsVuiFlags *>( this ); 1725 } 1726 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SpsVuiFlags1727 bool operator==( H265SpsVuiFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 1728 { 1729 return ( aspect_ratio_info_present_flag == rhs.aspect_ratio_info_present_flag ) && ( overscan_info_present_flag == rhs.overscan_info_present_flag ) && 1730 ( overscan_appropriate_flag == rhs.overscan_appropriate_flag ) && ( video_signal_type_present_flag == rhs.video_signal_type_present_flag ) && 1731 ( video_full_range_flag == rhs.video_full_range_flag ) && ( colour_description_present_flag == rhs.colour_description_present_flag ) && 1732 ( chroma_loc_info_present_flag == rhs.chroma_loc_info_present_flag ) && 1733 ( neutral_chroma_indication_flag == rhs.neutral_chroma_indication_flag ) && ( field_seq_flag == rhs.field_seq_flag ) && 1734 ( frame_field_info_present_flag == rhs.frame_field_info_present_flag ) && ( default_display_window_flag == rhs.default_display_window_flag ) && 1735 ( vui_timing_info_present_flag == rhs.vui_timing_info_present_flag ) && 1736 ( vui_poc_proportional_to_timing_flag == rhs.vui_poc_proportional_to_timing_flag ) && 1737 ( vui_hrd_parameters_present_flag == rhs.vui_hrd_parameters_present_flag ) && ( bitstream_restriction_flag == rhs.bitstream_restriction_flag ) && 1738 ( tiles_fixed_structure_flag == rhs.tiles_fixed_structure_flag ) && 1739 ( motion_vectors_over_pic_boundaries_flag == rhs.motion_vectors_over_pic_boundaries_flag ) && 1740 ( restricted_ref_pic_lists_flag == rhs.restricted_ref_pic_lists_flag ); 1741 } 1742 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SpsVuiFlags1743 bool operator!=( H265SpsVuiFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 1744 { 1745 return !operator==( rhs ); 1746 } 1747 1748 public: 1749 uint32_t aspect_ratio_info_present_flag : 1; 1750 uint32_t overscan_info_present_flag : 1; 1751 uint32_t overscan_appropriate_flag : 1; 1752 uint32_t video_signal_type_present_flag : 1; 1753 uint32_t video_full_range_flag : 1; 1754 uint32_t colour_description_present_flag : 1; 1755 uint32_t chroma_loc_info_present_flag : 1; 1756 uint32_t neutral_chroma_indication_flag : 1; 1757 uint32_t field_seq_flag : 1; 1758 uint32_t frame_field_info_present_flag : 1; 1759 uint32_t default_display_window_flag : 1; 1760 uint32_t vui_timing_info_present_flag : 1; 1761 uint32_t vui_poc_proportional_to_timing_flag : 1; 1762 uint32_t vui_hrd_parameters_present_flag : 1; 1763 uint32_t bitstream_restriction_flag : 1; 1764 uint32_t tiles_fixed_structure_flag : 1; 1765 uint32_t motion_vectors_over_pic_boundaries_flag : 1; 1766 uint32_t restricted_ref_pic_lists_flag : 1; 1767 }; 1768 1769 struct H265SequenceParameterSetVui 1770 { 1771 using NativeType = StdVideoH265SequenceParameterSetVui; 1772 operator StdVideoH265SequenceParameterSetVui const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SequenceParameterSetVui1773 operator StdVideoH265SequenceParameterSetVui const &() const VULKAN_HPP_NOEXCEPT 1774 { 1775 return *reinterpret_cast<const StdVideoH265SequenceParameterSetVui *>( this ); 1776 } 1777 operator StdVideoH265SequenceParameterSetVui&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SequenceParameterSetVui1778 operator StdVideoH265SequenceParameterSetVui &() VULKAN_HPP_NOEXCEPT 1779 { 1780 return *reinterpret_cast<StdVideoH265SequenceParameterSetVui *>( this ); 1781 } 1782 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SequenceParameterSetVui1783 bool operator==( H265SequenceParameterSetVui const & rhs ) const VULKAN_HPP_NOEXCEPT 1784 { 1785 return ( flags == rhs.flags ) && ( aspect_ratio_idc == rhs.aspect_ratio_idc ) && ( sar_width == rhs.sar_width ) && ( sar_height == rhs.sar_height ) && 1786 ( video_format == rhs.video_format ) && ( colour_primaries == rhs.colour_primaries ) && 1787 ( transfer_characteristics == rhs.transfer_characteristics ) && ( matrix_coeffs == rhs.matrix_coeffs ) && 1788 ( chroma_sample_loc_type_top_field == rhs.chroma_sample_loc_type_top_field ) && 1789 ( chroma_sample_loc_type_bottom_field == rhs.chroma_sample_loc_type_bottom_field ) && ( reserved1 == rhs.reserved1 ) && 1790 ( reserved2 == rhs.reserved2 ) && ( def_disp_win_left_offset == rhs.def_disp_win_left_offset ) && 1791 ( def_disp_win_right_offset == rhs.def_disp_win_right_offset ) && ( def_disp_win_top_offset == rhs.def_disp_win_top_offset ) && 1792 ( def_disp_win_bottom_offset == rhs.def_disp_win_bottom_offset ) && ( vui_num_units_in_tick == rhs.vui_num_units_in_tick ) && 1793 ( vui_time_scale == rhs.vui_time_scale ) && ( vui_num_ticks_poc_diff_one_minus1 == rhs.vui_num_ticks_poc_diff_one_minus1 ) && 1794 ( min_spatial_segmentation_idc == rhs.min_spatial_segmentation_idc ) && ( reserved3 == rhs.reserved3 ) && 1795 ( max_bytes_per_pic_denom == rhs.max_bytes_per_pic_denom ) && ( max_bits_per_min_cu_denom == rhs.max_bits_per_min_cu_denom ) && 1796 ( log2_max_mv_length_horizontal == rhs.log2_max_mv_length_horizontal ) && ( log2_max_mv_length_vertical == rhs.log2_max_mv_length_vertical ) && 1797 ( pHrdParameters == rhs.pHrdParameters ); 1798 } 1799 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SequenceParameterSetVui1800 bool operator!=( H265SequenceParameterSetVui const & rhs ) const VULKAN_HPP_NOEXCEPT 1801 { 1802 return !operator==( rhs ); 1803 } 1804 1805 public: 1806 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SpsVuiFlags flags = {}; 1807 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265AspectRatioIdc aspect_ratio_idc = 1808 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265AspectRatioIdc::eUnspecified; 1809 uint16_t sar_width = {}; 1810 uint16_t sar_height = {}; 1811 uint8_t video_format = {}; 1812 uint8_t colour_primaries = {}; 1813 uint8_t transfer_characteristics = {}; 1814 uint8_t matrix_coeffs = {}; 1815 uint8_t chroma_sample_loc_type_top_field = {}; 1816 uint8_t chroma_sample_loc_type_bottom_field = {}; 1817 uint8_t reserved1 = {}; 1818 uint8_t reserved2 = {}; 1819 uint16_t def_disp_win_left_offset = {}; 1820 uint16_t def_disp_win_right_offset = {}; 1821 uint16_t def_disp_win_top_offset = {}; 1822 uint16_t def_disp_win_bottom_offset = {}; 1823 uint32_t vui_num_units_in_tick = {}; 1824 uint32_t vui_time_scale = {}; 1825 uint32_t vui_num_ticks_poc_diff_one_minus1 = {}; 1826 uint16_t min_spatial_segmentation_idc = {}; 1827 uint16_t reserved3 = {}; 1828 uint8_t max_bytes_per_pic_denom = {}; 1829 uint8_t max_bits_per_min_cu_denom = {}; 1830 uint8_t log2_max_mv_length_horizontal = {}; 1831 uint8_t log2_max_mv_length_vertical = {}; 1832 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265HrdParameters * pHrdParameters = {}; 1833 }; 1834 1835 struct H265PredictorPaletteEntries 1836 { 1837 using NativeType = StdVideoH265PredictorPaletteEntries; 1838 operator StdVideoH265PredictorPaletteEntries const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PredictorPaletteEntries1839 operator StdVideoH265PredictorPaletteEntries const &() const VULKAN_HPP_NOEXCEPT 1840 { 1841 return *reinterpret_cast<const StdVideoH265PredictorPaletteEntries *>( this ); 1842 } 1843 operator StdVideoH265PredictorPaletteEntries&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PredictorPaletteEntries1844 operator StdVideoH265PredictorPaletteEntries &() VULKAN_HPP_NOEXCEPT 1845 { 1846 return *reinterpret_cast<StdVideoH265PredictorPaletteEntries *>( this ); 1847 } 1848 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PredictorPaletteEntries1849 bool operator==( H265PredictorPaletteEntries const & rhs ) const VULKAN_HPP_NOEXCEPT 1850 { 1851 return ( PredictorPaletteEntries == rhs.PredictorPaletteEntries ); 1852 } 1853 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PredictorPaletteEntries1854 bool operator!=( H265PredictorPaletteEntries const & rhs ) const VULKAN_HPP_NOEXCEPT 1855 { 1856 return !operator==( rhs ); 1857 } 1858 1859 public: 1860 VULKAN_HPP_NAMESPACE:: 1861 ArrayWrapper2D<uint16_t, STD_VIDEO_H265_PREDICTOR_PALETTE_COMPONENTS_LIST_SIZE, STD_VIDEO_H265_PREDICTOR_PALETTE_COMP_ENTRIES_LIST_SIZE> 1862 PredictorPaletteEntries = {}; 1863 }; 1864 1865 struct H265SpsFlags 1866 { 1867 using NativeType = StdVideoH265SpsFlags; 1868 operator StdVideoH265SpsFlags const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SpsFlags1869 operator StdVideoH265SpsFlags const &() const VULKAN_HPP_NOEXCEPT 1870 { 1871 return *reinterpret_cast<const StdVideoH265SpsFlags *>( this ); 1872 } 1873 operator StdVideoH265SpsFlags&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SpsFlags1874 operator StdVideoH265SpsFlags &() VULKAN_HPP_NOEXCEPT 1875 { 1876 return *reinterpret_cast<StdVideoH265SpsFlags *>( this ); 1877 } 1878 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SpsFlags1879 bool operator==( H265SpsFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 1880 { 1881 return ( sps_temporal_id_nesting_flag == rhs.sps_temporal_id_nesting_flag ) && ( separate_colour_plane_flag == rhs.separate_colour_plane_flag ) && 1882 ( conformance_window_flag == rhs.conformance_window_flag ) && 1883 ( sps_sub_layer_ordering_info_present_flag == rhs.sps_sub_layer_ordering_info_present_flag ) && 1884 ( scaling_list_enabled_flag == rhs.scaling_list_enabled_flag ) && 1885 ( sps_scaling_list_data_present_flag == rhs.sps_scaling_list_data_present_flag ) && ( amp_enabled_flag == rhs.amp_enabled_flag ) && 1886 ( sample_adaptive_offset_enabled_flag == rhs.sample_adaptive_offset_enabled_flag ) && ( pcm_enabled_flag == rhs.pcm_enabled_flag ) && 1887 ( pcm_loop_filter_disabled_flag == rhs.pcm_loop_filter_disabled_flag ) && 1888 ( long_term_ref_pics_present_flag == rhs.long_term_ref_pics_present_flag ) && 1889 ( sps_temporal_mvp_enabled_flag == rhs.sps_temporal_mvp_enabled_flag ) && 1890 ( strong_intra_smoothing_enabled_flag == rhs.strong_intra_smoothing_enabled_flag ) && 1891 ( vui_parameters_present_flag == rhs.vui_parameters_present_flag ) && ( sps_extension_present_flag == rhs.sps_extension_present_flag ) && 1892 ( sps_range_extension_flag == rhs.sps_range_extension_flag ) && 1893 ( transform_skip_rotation_enabled_flag == rhs.transform_skip_rotation_enabled_flag ) && 1894 ( transform_skip_context_enabled_flag == rhs.transform_skip_context_enabled_flag ) && 1895 ( implicit_rdpcm_enabled_flag == rhs.implicit_rdpcm_enabled_flag ) && ( explicit_rdpcm_enabled_flag == rhs.explicit_rdpcm_enabled_flag ) && 1896 ( extended_precision_processing_flag == rhs.extended_precision_processing_flag ) && 1897 ( intra_smoothing_disabled_flag == rhs.intra_smoothing_disabled_flag ) && 1898 ( high_precision_offsets_enabled_flag == rhs.high_precision_offsets_enabled_flag ) && 1899 ( persistent_rice_adaptation_enabled_flag == rhs.persistent_rice_adaptation_enabled_flag ) && 1900 ( cabac_bypass_alignment_enabled_flag == rhs.cabac_bypass_alignment_enabled_flag ) && ( sps_scc_extension_flag == rhs.sps_scc_extension_flag ) && 1901 ( sps_curr_pic_ref_enabled_flag == rhs.sps_curr_pic_ref_enabled_flag ) && ( palette_mode_enabled_flag == rhs.palette_mode_enabled_flag ) && 1902 ( sps_palette_predictor_initializers_present_flag == rhs.sps_palette_predictor_initializers_present_flag ) && 1903 ( intra_boundary_filtering_disabled_flag == rhs.intra_boundary_filtering_disabled_flag ); 1904 } 1905 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SpsFlags1906 bool operator!=( H265SpsFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 1907 { 1908 return !operator==( rhs ); 1909 } 1910 1911 public: 1912 uint32_t sps_temporal_id_nesting_flag : 1; 1913 uint32_t separate_colour_plane_flag : 1; 1914 uint32_t conformance_window_flag : 1; 1915 uint32_t sps_sub_layer_ordering_info_present_flag : 1; 1916 uint32_t scaling_list_enabled_flag : 1; 1917 uint32_t sps_scaling_list_data_present_flag : 1; 1918 uint32_t amp_enabled_flag : 1; 1919 uint32_t sample_adaptive_offset_enabled_flag : 1; 1920 uint32_t pcm_enabled_flag : 1; 1921 uint32_t pcm_loop_filter_disabled_flag : 1; 1922 uint32_t long_term_ref_pics_present_flag : 1; 1923 uint32_t sps_temporal_mvp_enabled_flag : 1; 1924 uint32_t strong_intra_smoothing_enabled_flag : 1; 1925 uint32_t vui_parameters_present_flag : 1; 1926 uint32_t sps_extension_present_flag : 1; 1927 uint32_t sps_range_extension_flag : 1; 1928 uint32_t transform_skip_rotation_enabled_flag : 1; 1929 uint32_t transform_skip_context_enabled_flag : 1; 1930 uint32_t implicit_rdpcm_enabled_flag : 1; 1931 uint32_t explicit_rdpcm_enabled_flag : 1; 1932 uint32_t extended_precision_processing_flag : 1; 1933 uint32_t intra_smoothing_disabled_flag : 1; 1934 uint32_t high_precision_offsets_enabled_flag : 1; 1935 uint32_t persistent_rice_adaptation_enabled_flag : 1; 1936 uint32_t cabac_bypass_alignment_enabled_flag : 1; 1937 uint32_t sps_scc_extension_flag : 1; 1938 uint32_t sps_curr_pic_ref_enabled_flag : 1; 1939 uint32_t palette_mode_enabled_flag : 1; 1940 uint32_t sps_palette_predictor_initializers_present_flag : 1; 1941 uint32_t intra_boundary_filtering_disabled_flag : 1; 1942 }; 1943 1944 struct H265ShortTermRefPicSetFlags 1945 { 1946 using NativeType = StdVideoH265ShortTermRefPicSetFlags; 1947 operator StdVideoH265ShortTermRefPicSetFlags const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ShortTermRefPicSetFlags1948 operator StdVideoH265ShortTermRefPicSetFlags const &() const VULKAN_HPP_NOEXCEPT 1949 { 1950 return *reinterpret_cast<const StdVideoH265ShortTermRefPicSetFlags *>( this ); 1951 } 1952 operator StdVideoH265ShortTermRefPicSetFlags&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ShortTermRefPicSetFlags1953 operator StdVideoH265ShortTermRefPicSetFlags &() VULKAN_HPP_NOEXCEPT 1954 { 1955 return *reinterpret_cast<StdVideoH265ShortTermRefPicSetFlags *>( this ); 1956 } 1957 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ShortTermRefPicSetFlags1958 bool operator==( H265ShortTermRefPicSetFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 1959 { 1960 return ( inter_ref_pic_set_prediction_flag == rhs.inter_ref_pic_set_prediction_flag ) && ( delta_rps_sign == rhs.delta_rps_sign ); 1961 } 1962 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ShortTermRefPicSetFlags1963 bool operator!=( H265ShortTermRefPicSetFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 1964 { 1965 return !operator==( rhs ); 1966 } 1967 1968 public: 1969 uint32_t inter_ref_pic_set_prediction_flag : 1; 1970 uint32_t delta_rps_sign : 1; 1971 }; 1972 1973 struct H265ShortTermRefPicSet 1974 { 1975 using NativeType = StdVideoH265ShortTermRefPicSet; 1976 operator StdVideoH265ShortTermRefPicSet const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ShortTermRefPicSet1977 operator StdVideoH265ShortTermRefPicSet const &() const VULKAN_HPP_NOEXCEPT 1978 { 1979 return *reinterpret_cast<const StdVideoH265ShortTermRefPicSet *>( this ); 1980 } 1981 operator StdVideoH265ShortTermRefPicSet&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ShortTermRefPicSet1982 operator StdVideoH265ShortTermRefPicSet &() VULKAN_HPP_NOEXCEPT 1983 { 1984 return *reinterpret_cast<StdVideoH265ShortTermRefPicSet *>( this ); 1985 } 1986 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ShortTermRefPicSet1987 bool operator==( H265ShortTermRefPicSet const & rhs ) const VULKAN_HPP_NOEXCEPT 1988 { 1989 return ( flags == rhs.flags ) && ( delta_idx_minus1 == rhs.delta_idx_minus1 ) && ( use_delta_flag == rhs.use_delta_flag ) && 1990 ( abs_delta_rps_minus1 == rhs.abs_delta_rps_minus1 ) && ( used_by_curr_pic_flag == rhs.used_by_curr_pic_flag ) && 1991 ( used_by_curr_pic_s0_flag == rhs.used_by_curr_pic_s0_flag ) && ( used_by_curr_pic_s1_flag == rhs.used_by_curr_pic_s1_flag ) && 1992 ( reserved1 == rhs.reserved1 ) && ( reserved2 == rhs.reserved2 ) && ( reserved3 == rhs.reserved3 ) && 1993 ( num_negative_pics == rhs.num_negative_pics ) && ( num_positive_pics == rhs.num_positive_pics ) && 1994 ( delta_poc_s0_minus1 == rhs.delta_poc_s0_minus1 ) && ( delta_poc_s1_minus1 == rhs.delta_poc_s1_minus1 ); 1995 } 1996 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ShortTermRefPicSet1997 bool operator!=( H265ShortTermRefPicSet const & rhs ) const VULKAN_HPP_NOEXCEPT 1998 { 1999 return !operator==( rhs ); 2000 } 2001 2002 public: 2003 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ShortTermRefPicSetFlags flags = {}; 2004 uint32_t delta_idx_minus1 = {}; 2005 uint16_t use_delta_flag = {}; 2006 uint16_t abs_delta_rps_minus1 = {}; 2007 uint16_t used_by_curr_pic_flag = {}; 2008 uint16_t used_by_curr_pic_s0_flag = {}; 2009 uint16_t used_by_curr_pic_s1_flag = {}; 2010 uint16_t reserved1 = {}; 2011 uint8_t reserved2 = {}; 2012 uint8_t reserved3 = {}; 2013 uint8_t num_negative_pics = {}; 2014 uint8_t num_positive_pics = {}; 2015 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint16_t, STD_VIDEO_H265_MAX_DPB_SIZE> delta_poc_s0_minus1 = {}; 2016 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint16_t, STD_VIDEO_H265_MAX_DPB_SIZE> delta_poc_s1_minus1 = {}; 2017 }; 2018 2019 struct H265LongTermRefPicsSps 2020 { 2021 using NativeType = StdVideoH265LongTermRefPicsSps; 2022 operator StdVideoH265LongTermRefPicsSps const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265LongTermRefPicsSps2023 operator StdVideoH265LongTermRefPicsSps const &() const VULKAN_HPP_NOEXCEPT 2024 { 2025 return *reinterpret_cast<const StdVideoH265LongTermRefPicsSps *>( this ); 2026 } 2027 operator StdVideoH265LongTermRefPicsSps&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265LongTermRefPicsSps2028 operator StdVideoH265LongTermRefPicsSps &() VULKAN_HPP_NOEXCEPT 2029 { 2030 return *reinterpret_cast<StdVideoH265LongTermRefPicsSps *>( this ); 2031 } 2032 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265LongTermRefPicsSps2033 bool operator==( H265LongTermRefPicsSps const & rhs ) const VULKAN_HPP_NOEXCEPT 2034 { 2035 return ( used_by_curr_pic_lt_sps_flag == rhs.used_by_curr_pic_lt_sps_flag ) && ( lt_ref_pic_poc_lsb_sps == rhs.lt_ref_pic_poc_lsb_sps ); 2036 } 2037 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265LongTermRefPicsSps2038 bool operator!=( H265LongTermRefPicsSps const & rhs ) const VULKAN_HPP_NOEXCEPT 2039 { 2040 return !operator==( rhs ); 2041 } 2042 2043 public: 2044 uint32_t used_by_curr_pic_lt_sps_flag = {}; 2045 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint32_t, STD_VIDEO_H265_MAX_LONG_TERM_REF_PICS_SPS> lt_ref_pic_poc_lsb_sps = {}; 2046 }; 2047 2048 struct H265SequenceParameterSet 2049 { 2050 using NativeType = StdVideoH265SequenceParameterSet; 2051 operator StdVideoH265SequenceParameterSet const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SequenceParameterSet2052 operator StdVideoH265SequenceParameterSet const &() const VULKAN_HPP_NOEXCEPT 2053 { 2054 return *reinterpret_cast<const StdVideoH265SequenceParameterSet *>( this ); 2055 } 2056 operator StdVideoH265SequenceParameterSet&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SequenceParameterSet2057 operator StdVideoH265SequenceParameterSet &() VULKAN_HPP_NOEXCEPT 2058 { 2059 return *reinterpret_cast<StdVideoH265SequenceParameterSet *>( this ); 2060 } 2061 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SequenceParameterSet2062 bool operator==( H265SequenceParameterSet const & rhs ) const VULKAN_HPP_NOEXCEPT 2063 { 2064 return ( flags == rhs.flags ) && ( chroma_format_idc == rhs.chroma_format_idc ) && ( pic_width_in_luma_samples == rhs.pic_width_in_luma_samples ) && 2065 ( pic_height_in_luma_samples == rhs.pic_height_in_luma_samples ) && ( sps_video_parameter_set_id == rhs.sps_video_parameter_set_id ) && 2066 ( sps_max_sub_layers_minus1 == rhs.sps_max_sub_layers_minus1 ) && ( sps_seq_parameter_set_id == rhs.sps_seq_parameter_set_id ) && 2067 ( bit_depth_luma_minus8 == rhs.bit_depth_luma_minus8 ) && ( bit_depth_chroma_minus8 == rhs.bit_depth_chroma_minus8 ) && 2068 ( log2_max_pic_order_cnt_lsb_minus4 == rhs.log2_max_pic_order_cnt_lsb_minus4 ) && 2069 ( log2_min_luma_coding_block_size_minus3 == rhs.log2_min_luma_coding_block_size_minus3 ) && 2070 ( log2_diff_max_min_luma_coding_block_size == rhs.log2_diff_max_min_luma_coding_block_size ) && 2071 ( log2_min_luma_transform_block_size_minus2 == rhs.log2_min_luma_transform_block_size_minus2 ) && 2072 ( log2_diff_max_min_luma_transform_block_size == rhs.log2_diff_max_min_luma_transform_block_size ) && 2073 ( max_transform_hierarchy_depth_inter == rhs.max_transform_hierarchy_depth_inter ) && 2074 ( max_transform_hierarchy_depth_intra == rhs.max_transform_hierarchy_depth_intra ) && 2075 ( num_short_term_ref_pic_sets == rhs.num_short_term_ref_pic_sets ) && ( num_long_term_ref_pics_sps == rhs.num_long_term_ref_pics_sps ) && 2076 ( pcm_sample_bit_depth_luma_minus1 == rhs.pcm_sample_bit_depth_luma_minus1 ) && 2077 ( pcm_sample_bit_depth_chroma_minus1 == rhs.pcm_sample_bit_depth_chroma_minus1 ) && 2078 ( log2_min_pcm_luma_coding_block_size_minus3 == rhs.log2_min_pcm_luma_coding_block_size_minus3 ) && 2079 ( log2_diff_max_min_pcm_luma_coding_block_size == rhs.log2_diff_max_min_pcm_luma_coding_block_size ) && ( reserved1 == rhs.reserved1 ) && 2080 ( reserved2 == rhs.reserved2 ) && ( palette_max_size == rhs.palette_max_size ) && 2081 ( delta_palette_max_predictor_size == rhs.delta_palette_max_predictor_size ) && 2082 ( motion_vector_resolution_control_idc == rhs.motion_vector_resolution_control_idc ) && 2083 ( sps_num_palette_predictor_initializers_minus1 == rhs.sps_num_palette_predictor_initializers_minus1 ) && 2084 ( conf_win_left_offset == rhs.conf_win_left_offset ) && ( conf_win_right_offset == rhs.conf_win_right_offset ) && 2085 ( conf_win_top_offset == rhs.conf_win_top_offset ) && ( conf_win_bottom_offset == rhs.conf_win_bottom_offset ) && 2086 ( pProfileTierLevel == rhs.pProfileTierLevel ) && ( pDecPicBufMgr == rhs.pDecPicBufMgr ) && ( pScalingLists == rhs.pScalingLists ) && 2087 ( pShortTermRefPicSet == rhs.pShortTermRefPicSet ) && ( pLongTermRefPicsSps == rhs.pLongTermRefPicsSps ) && 2088 ( pSequenceParameterSetVui == rhs.pSequenceParameterSetVui ) && ( pPredictorPaletteEntries == rhs.pPredictorPaletteEntries ); 2089 } 2090 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SequenceParameterSet2091 bool operator!=( H265SequenceParameterSet const & rhs ) const VULKAN_HPP_NOEXCEPT 2092 { 2093 return !operator==( rhs ); 2094 } 2095 2096 public: 2097 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SpsFlags flags = {}; 2098 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ChromaFormatIdc chroma_format_idc = 2099 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ChromaFormatIdc::eMonochrome; 2100 uint32_t pic_width_in_luma_samples = {}; 2101 uint32_t pic_height_in_luma_samples = {}; 2102 uint8_t sps_video_parameter_set_id = {}; 2103 uint8_t sps_max_sub_layers_minus1 = {}; 2104 uint8_t sps_seq_parameter_set_id = {}; 2105 uint8_t bit_depth_luma_minus8 = {}; 2106 uint8_t bit_depth_chroma_minus8 = {}; 2107 uint8_t log2_max_pic_order_cnt_lsb_minus4 = {}; 2108 uint8_t log2_min_luma_coding_block_size_minus3 = {}; 2109 uint8_t log2_diff_max_min_luma_coding_block_size = {}; 2110 uint8_t log2_min_luma_transform_block_size_minus2 = {}; 2111 uint8_t log2_diff_max_min_luma_transform_block_size = {}; 2112 uint8_t max_transform_hierarchy_depth_inter = {}; 2113 uint8_t max_transform_hierarchy_depth_intra = {}; 2114 uint8_t num_short_term_ref_pic_sets = {}; 2115 uint8_t num_long_term_ref_pics_sps = {}; 2116 uint8_t pcm_sample_bit_depth_luma_minus1 = {}; 2117 uint8_t pcm_sample_bit_depth_chroma_minus1 = {}; 2118 uint8_t log2_min_pcm_luma_coding_block_size_minus3 = {}; 2119 uint8_t log2_diff_max_min_pcm_luma_coding_block_size = {}; 2120 uint8_t reserved1 = {}; 2121 uint8_t reserved2 = {}; 2122 uint8_t palette_max_size = {}; 2123 uint8_t delta_palette_max_predictor_size = {}; 2124 uint8_t motion_vector_resolution_control_idc = {}; 2125 uint8_t sps_num_palette_predictor_initializers_minus1 = {}; 2126 uint32_t conf_win_left_offset = {}; 2127 uint32_t conf_win_right_offset = {}; 2128 uint32_t conf_win_top_offset = {}; 2129 uint32_t conf_win_bottom_offset = {}; 2130 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ProfileTierLevel * pProfileTierLevel = {}; 2131 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265DecPicBufMgr * pDecPicBufMgr = {}; 2132 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingLists * pScalingLists = {}; 2133 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ShortTermRefPicSet * pShortTermRefPicSet = {}; 2134 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265LongTermRefPicsSps * pLongTermRefPicsSps = {}; 2135 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SequenceParameterSetVui * pSequenceParameterSetVui = {}; 2136 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PredictorPaletteEntries * pPredictorPaletteEntries = {}; 2137 }; 2138 2139 struct H265PpsFlags 2140 { 2141 using NativeType = StdVideoH265PpsFlags; 2142 operator StdVideoH265PpsFlags const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PpsFlags2143 operator StdVideoH265PpsFlags const &() const VULKAN_HPP_NOEXCEPT 2144 { 2145 return *reinterpret_cast<const StdVideoH265PpsFlags *>( this ); 2146 } 2147 operator StdVideoH265PpsFlags&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PpsFlags2148 operator StdVideoH265PpsFlags &() VULKAN_HPP_NOEXCEPT 2149 { 2150 return *reinterpret_cast<StdVideoH265PpsFlags *>( this ); 2151 } 2152 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PpsFlags2153 bool operator==( H265PpsFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 2154 { 2155 return ( dependent_slice_segments_enabled_flag == rhs.dependent_slice_segments_enabled_flag ) && 2156 ( output_flag_present_flag == rhs.output_flag_present_flag ) && ( sign_data_hiding_enabled_flag == rhs.sign_data_hiding_enabled_flag ) && 2157 ( cabac_init_present_flag == rhs.cabac_init_present_flag ) && ( constrained_intra_pred_flag == rhs.constrained_intra_pred_flag ) && 2158 ( transform_skip_enabled_flag == rhs.transform_skip_enabled_flag ) && ( cu_qp_delta_enabled_flag == rhs.cu_qp_delta_enabled_flag ) && 2159 ( pps_slice_chroma_qp_offsets_present_flag == rhs.pps_slice_chroma_qp_offsets_present_flag ) && 2160 ( weighted_pred_flag == rhs.weighted_pred_flag ) && ( weighted_bipred_flag == rhs.weighted_bipred_flag ) && 2161 ( transquant_bypass_enabled_flag == rhs.transquant_bypass_enabled_flag ) && ( tiles_enabled_flag == rhs.tiles_enabled_flag ) && 2162 ( entropy_coding_sync_enabled_flag == rhs.entropy_coding_sync_enabled_flag ) && ( uniform_spacing_flag == rhs.uniform_spacing_flag ) && 2163 ( loop_filter_across_tiles_enabled_flag == rhs.loop_filter_across_tiles_enabled_flag ) && 2164 ( pps_loop_filter_across_slices_enabled_flag == rhs.pps_loop_filter_across_slices_enabled_flag ) && 2165 ( deblocking_filter_control_present_flag == rhs.deblocking_filter_control_present_flag ) && 2166 ( deblocking_filter_override_enabled_flag == rhs.deblocking_filter_override_enabled_flag ) && 2167 ( pps_deblocking_filter_disabled_flag == rhs.pps_deblocking_filter_disabled_flag ) && 2168 ( pps_scaling_list_data_present_flag == rhs.pps_scaling_list_data_present_flag ) && 2169 ( lists_modification_present_flag == rhs.lists_modification_present_flag ) && 2170 ( slice_segment_header_extension_present_flag == rhs.slice_segment_header_extension_present_flag ) && 2171 ( pps_extension_present_flag == rhs.pps_extension_present_flag ) && 2172 ( cross_component_prediction_enabled_flag == rhs.cross_component_prediction_enabled_flag ) && 2173 ( chroma_qp_offset_list_enabled_flag == rhs.chroma_qp_offset_list_enabled_flag ) && 2174 ( pps_curr_pic_ref_enabled_flag == rhs.pps_curr_pic_ref_enabled_flag ) && 2175 ( residual_adaptive_colour_transform_enabled_flag == rhs.residual_adaptive_colour_transform_enabled_flag ) && 2176 ( pps_slice_act_qp_offsets_present_flag == rhs.pps_slice_act_qp_offsets_present_flag ) && 2177 ( pps_palette_predictor_initializers_present_flag == rhs.pps_palette_predictor_initializers_present_flag ) && 2178 ( monochrome_palette_flag == rhs.monochrome_palette_flag ) && ( pps_range_extension_flag == rhs.pps_range_extension_flag ); 2179 } 2180 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PpsFlags2181 bool operator!=( H265PpsFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 2182 { 2183 return !operator==( rhs ); 2184 } 2185 2186 public: 2187 uint32_t dependent_slice_segments_enabled_flag : 1; 2188 uint32_t output_flag_present_flag : 1; 2189 uint32_t sign_data_hiding_enabled_flag : 1; 2190 uint32_t cabac_init_present_flag : 1; 2191 uint32_t constrained_intra_pred_flag : 1; 2192 uint32_t transform_skip_enabled_flag : 1; 2193 uint32_t cu_qp_delta_enabled_flag : 1; 2194 uint32_t pps_slice_chroma_qp_offsets_present_flag : 1; 2195 uint32_t weighted_pred_flag : 1; 2196 uint32_t weighted_bipred_flag : 1; 2197 uint32_t transquant_bypass_enabled_flag : 1; 2198 uint32_t tiles_enabled_flag : 1; 2199 uint32_t entropy_coding_sync_enabled_flag : 1; 2200 uint32_t uniform_spacing_flag : 1; 2201 uint32_t loop_filter_across_tiles_enabled_flag : 1; 2202 uint32_t pps_loop_filter_across_slices_enabled_flag : 1; 2203 uint32_t deblocking_filter_control_present_flag : 1; 2204 uint32_t deblocking_filter_override_enabled_flag : 1; 2205 uint32_t pps_deblocking_filter_disabled_flag : 1; 2206 uint32_t pps_scaling_list_data_present_flag : 1; 2207 uint32_t lists_modification_present_flag : 1; 2208 uint32_t slice_segment_header_extension_present_flag : 1; 2209 uint32_t pps_extension_present_flag : 1; 2210 uint32_t cross_component_prediction_enabled_flag : 1; 2211 uint32_t chroma_qp_offset_list_enabled_flag : 1; 2212 uint32_t pps_curr_pic_ref_enabled_flag : 1; 2213 uint32_t residual_adaptive_colour_transform_enabled_flag : 1; 2214 uint32_t pps_slice_act_qp_offsets_present_flag : 1; 2215 uint32_t pps_palette_predictor_initializers_present_flag : 1; 2216 uint32_t monochrome_palette_flag : 1; 2217 uint32_t pps_range_extension_flag : 1; 2218 }; 2219 2220 struct H265PictureParameterSet 2221 { 2222 using NativeType = StdVideoH265PictureParameterSet; 2223 operator StdVideoH265PictureParameterSet const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PictureParameterSet2224 operator StdVideoH265PictureParameterSet const &() const VULKAN_HPP_NOEXCEPT 2225 { 2226 return *reinterpret_cast<const StdVideoH265PictureParameterSet *>( this ); 2227 } 2228 operator StdVideoH265PictureParameterSet&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PictureParameterSet2229 operator StdVideoH265PictureParameterSet &() VULKAN_HPP_NOEXCEPT 2230 { 2231 return *reinterpret_cast<StdVideoH265PictureParameterSet *>( this ); 2232 } 2233 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PictureParameterSet2234 bool operator==( H265PictureParameterSet const & rhs ) const VULKAN_HPP_NOEXCEPT 2235 { 2236 return ( flags == rhs.flags ) && ( pps_pic_parameter_set_id == rhs.pps_pic_parameter_set_id ) && 2237 ( pps_seq_parameter_set_id == rhs.pps_seq_parameter_set_id ) && ( sps_video_parameter_set_id == rhs.sps_video_parameter_set_id ) && 2238 ( num_extra_slice_header_bits == rhs.num_extra_slice_header_bits ) && 2239 ( num_ref_idx_l0_default_active_minus1 == rhs.num_ref_idx_l0_default_active_minus1 ) && 2240 ( num_ref_idx_l1_default_active_minus1 == rhs.num_ref_idx_l1_default_active_minus1 ) && ( init_qp_minus26 == rhs.init_qp_minus26 ) && 2241 ( diff_cu_qp_delta_depth == rhs.diff_cu_qp_delta_depth ) && ( pps_cb_qp_offset == rhs.pps_cb_qp_offset ) && 2242 ( pps_cr_qp_offset == rhs.pps_cr_qp_offset ) && ( pps_beta_offset_div2 == rhs.pps_beta_offset_div2 ) && 2243 ( pps_tc_offset_div2 == rhs.pps_tc_offset_div2 ) && ( log2_parallel_merge_level_minus2 == rhs.log2_parallel_merge_level_minus2 ) && 2244 ( log2_max_transform_skip_block_size_minus2 == rhs.log2_max_transform_skip_block_size_minus2 ) && 2245 ( diff_cu_chroma_qp_offset_depth == rhs.diff_cu_chroma_qp_offset_depth ) && 2246 ( chroma_qp_offset_list_len_minus1 == rhs.chroma_qp_offset_list_len_minus1 ) && ( cb_qp_offset_list == rhs.cb_qp_offset_list ) && 2247 ( cr_qp_offset_list == rhs.cr_qp_offset_list ) && ( log2_sao_offset_scale_luma == rhs.log2_sao_offset_scale_luma ) && 2248 ( log2_sao_offset_scale_chroma == rhs.log2_sao_offset_scale_chroma ) && ( pps_act_y_qp_offset_plus5 == rhs.pps_act_y_qp_offset_plus5 ) && 2249 ( pps_act_cb_qp_offset_plus5 == rhs.pps_act_cb_qp_offset_plus5 ) && ( pps_act_cr_qp_offset_plus3 == rhs.pps_act_cr_qp_offset_plus3 ) && 2250 ( pps_num_palette_predictor_initializers == rhs.pps_num_palette_predictor_initializers ) && 2251 ( luma_bit_depth_entry_minus8 == rhs.luma_bit_depth_entry_minus8 ) && ( chroma_bit_depth_entry_minus8 == rhs.chroma_bit_depth_entry_minus8 ) && 2252 ( num_tile_columns_minus1 == rhs.num_tile_columns_minus1 ) && ( num_tile_rows_minus1 == rhs.num_tile_rows_minus1 ) && 2253 ( reserved1 == rhs.reserved1 ) && ( reserved2 == rhs.reserved2 ) && ( column_width_minus1 == rhs.column_width_minus1 ) && 2254 ( row_height_minus1 == rhs.row_height_minus1 ) && ( reserved3 == rhs.reserved3 ) && ( pScalingLists == rhs.pScalingLists ) && 2255 ( pPredictorPaletteEntries == rhs.pPredictorPaletteEntries ); 2256 } 2257 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PictureParameterSet2258 bool operator!=( H265PictureParameterSet const & rhs ) const VULKAN_HPP_NOEXCEPT 2259 { 2260 return !operator==( rhs ); 2261 } 2262 2263 public: 2264 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PpsFlags flags = {}; 2265 uint8_t pps_pic_parameter_set_id = {}; 2266 uint8_t pps_seq_parameter_set_id = {}; 2267 uint8_t sps_video_parameter_set_id = {}; 2268 uint8_t num_extra_slice_header_bits = {}; 2269 uint8_t num_ref_idx_l0_default_active_minus1 = {}; 2270 uint8_t num_ref_idx_l1_default_active_minus1 = {}; 2271 int8_t init_qp_minus26 = {}; 2272 uint8_t diff_cu_qp_delta_depth = {}; 2273 int8_t pps_cb_qp_offset = {}; 2274 int8_t pps_cr_qp_offset = {}; 2275 int8_t pps_beta_offset_div2 = {}; 2276 int8_t pps_tc_offset_div2 = {}; 2277 uint8_t log2_parallel_merge_level_minus2 = {}; 2278 uint8_t log2_max_transform_skip_block_size_minus2 = {}; 2279 uint8_t diff_cu_chroma_qp_offset_depth = {}; 2280 uint8_t chroma_qp_offset_list_len_minus1 = {}; 2281 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<int8_t, STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE> cb_qp_offset_list = {}; 2282 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<int8_t, STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE> cr_qp_offset_list = {}; 2283 uint8_t log2_sao_offset_scale_luma = {}; 2284 uint8_t log2_sao_offset_scale_chroma = {}; 2285 int8_t pps_act_y_qp_offset_plus5 = {}; 2286 int8_t pps_act_cb_qp_offset_plus5 = {}; 2287 int8_t pps_act_cr_qp_offset_plus3 = {}; 2288 uint8_t pps_num_palette_predictor_initializers = {}; 2289 uint8_t luma_bit_depth_entry_minus8 = {}; 2290 uint8_t chroma_bit_depth_entry_minus8 = {}; 2291 uint8_t num_tile_columns_minus1 = {}; 2292 uint8_t num_tile_rows_minus1 = {}; 2293 uint8_t reserved1 = {}; 2294 uint8_t reserved2 = {}; 2295 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint16_t, STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_COLS_LIST_SIZE> column_width_minus1 = {}; 2296 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint16_t, STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_ROWS_LIST_SIZE> row_height_minus1 = {}; 2297 uint32_t reserved3 = {}; 2298 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingLists * pScalingLists = {}; 2299 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PredictorPaletteEntries * pPredictorPaletteEntries = {}; 2300 }; 2301 2302 //=== vulkan_video_codec_h265std_decode === 2303 2304 struct DecodeH265PictureInfoFlags 2305 { 2306 using NativeType = StdVideoDecodeH265PictureInfoFlags; 2307 operator StdVideoDecodeH265PictureInfoFlags const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265PictureInfoFlags2308 operator StdVideoDecodeH265PictureInfoFlags const &() const VULKAN_HPP_NOEXCEPT 2309 { 2310 return *reinterpret_cast<const StdVideoDecodeH265PictureInfoFlags *>( this ); 2311 } 2312 operator StdVideoDecodeH265PictureInfoFlags&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265PictureInfoFlags2313 operator StdVideoDecodeH265PictureInfoFlags &() VULKAN_HPP_NOEXCEPT 2314 { 2315 return *reinterpret_cast<StdVideoDecodeH265PictureInfoFlags *>( this ); 2316 } 2317 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265PictureInfoFlags2318 bool operator==( DecodeH265PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 2319 { 2320 return ( IrapPicFlag == rhs.IrapPicFlag ) && ( IdrPicFlag == rhs.IdrPicFlag ) && ( IsReference == rhs.IsReference ) && 2321 ( short_term_ref_pic_set_sps_flag == rhs.short_term_ref_pic_set_sps_flag ); 2322 } 2323 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265PictureInfoFlags2324 bool operator!=( DecodeH265PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 2325 { 2326 return !operator==( rhs ); 2327 } 2328 2329 public: 2330 uint32_t IrapPicFlag : 1; 2331 uint32_t IdrPicFlag : 1; 2332 uint32_t IsReference : 1; 2333 uint32_t short_term_ref_pic_set_sps_flag : 1; 2334 }; 2335 2336 struct DecodeH265PictureInfo 2337 { 2338 using NativeType = StdVideoDecodeH265PictureInfo; 2339 operator StdVideoDecodeH265PictureInfo const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265PictureInfo2340 operator StdVideoDecodeH265PictureInfo const &() const VULKAN_HPP_NOEXCEPT 2341 { 2342 return *reinterpret_cast<const StdVideoDecodeH265PictureInfo *>( this ); 2343 } 2344 operator StdVideoDecodeH265PictureInfo&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265PictureInfo2345 operator StdVideoDecodeH265PictureInfo &() VULKAN_HPP_NOEXCEPT 2346 { 2347 return *reinterpret_cast<StdVideoDecodeH265PictureInfo *>( this ); 2348 } 2349 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265PictureInfo2350 bool operator==( DecodeH265PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT 2351 { 2352 return ( flags == rhs.flags ) && ( sps_video_parameter_set_id == rhs.sps_video_parameter_set_id ) && 2353 ( pps_seq_parameter_set_id == rhs.pps_seq_parameter_set_id ) && ( pps_pic_parameter_set_id == rhs.pps_pic_parameter_set_id ) && 2354 ( NumDeltaPocsOfRefRpsIdx == rhs.NumDeltaPocsOfRefRpsIdx ) && ( PicOrderCntVal == rhs.PicOrderCntVal ) && 2355 ( NumBitsForSTRefPicSetInSlice == rhs.NumBitsForSTRefPicSetInSlice ) && ( reserved == rhs.reserved ) && 2356 ( RefPicSetStCurrBefore == rhs.RefPicSetStCurrBefore ) && ( RefPicSetStCurrAfter == rhs.RefPicSetStCurrAfter ) && 2357 ( RefPicSetLtCurr == rhs.RefPicSetLtCurr ); 2358 } 2359 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265PictureInfo2360 bool operator!=( DecodeH265PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT 2361 { 2362 return !operator==( rhs ); 2363 } 2364 2365 public: 2366 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265PictureInfoFlags flags = {}; 2367 uint8_t sps_video_parameter_set_id = {}; 2368 uint8_t pps_seq_parameter_set_id = {}; 2369 uint8_t pps_pic_parameter_set_id = {}; 2370 uint8_t NumDeltaPocsOfRefRpsIdx = {}; 2371 int32_t PicOrderCntVal = {}; 2372 uint16_t NumBitsForSTRefPicSetInSlice = {}; 2373 uint16_t reserved = {}; 2374 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE> RefPicSetStCurrBefore = {}; 2375 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE> RefPicSetStCurrAfter = {}; 2376 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE> RefPicSetLtCurr = {}; 2377 }; 2378 2379 struct DecodeH265ReferenceInfoFlags 2380 { 2381 using NativeType = StdVideoDecodeH265ReferenceInfoFlags; 2382 operator StdVideoDecodeH265ReferenceInfoFlags const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265ReferenceInfoFlags2383 operator StdVideoDecodeH265ReferenceInfoFlags const &() const VULKAN_HPP_NOEXCEPT 2384 { 2385 return *reinterpret_cast<const StdVideoDecodeH265ReferenceInfoFlags *>( this ); 2386 } 2387 operator StdVideoDecodeH265ReferenceInfoFlags&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265ReferenceInfoFlags2388 operator StdVideoDecodeH265ReferenceInfoFlags &() VULKAN_HPP_NOEXCEPT 2389 { 2390 return *reinterpret_cast<StdVideoDecodeH265ReferenceInfoFlags *>( this ); 2391 } 2392 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265ReferenceInfoFlags2393 bool operator==( DecodeH265ReferenceInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 2394 { 2395 return ( used_for_long_term_reference == rhs.used_for_long_term_reference ) && ( unused_for_reference == rhs.unused_for_reference ); 2396 } 2397 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265ReferenceInfoFlags2398 bool operator!=( DecodeH265ReferenceInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 2399 { 2400 return !operator==( rhs ); 2401 } 2402 2403 public: 2404 uint32_t used_for_long_term_reference : 1; 2405 uint32_t unused_for_reference : 1; 2406 }; 2407 2408 struct DecodeH265ReferenceInfo 2409 { 2410 using NativeType = StdVideoDecodeH265ReferenceInfo; 2411 operator StdVideoDecodeH265ReferenceInfo const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265ReferenceInfo2412 operator StdVideoDecodeH265ReferenceInfo const &() const VULKAN_HPP_NOEXCEPT 2413 { 2414 return *reinterpret_cast<const StdVideoDecodeH265ReferenceInfo *>( this ); 2415 } 2416 operator StdVideoDecodeH265ReferenceInfo&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265ReferenceInfo2417 operator StdVideoDecodeH265ReferenceInfo &() VULKAN_HPP_NOEXCEPT 2418 { 2419 return *reinterpret_cast<StdVideoDecodeH265ReferenceInfo *>( this ); 2420 } 2421 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265ReferenceInfo2422 bool operator==( DecodeH265ReferenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT 2423 { 2424 return ( flags == rhs.flags ) && ( PicOrderCntVal == rhs.PicOrderCntVal ); 2425 } 2426 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265ReferenceInfo2427 bool operator!=( DecodeH265ReferenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT 2428 { 2429 return !operator==( rhs ); 2430 } 2431 2432 public: 2433 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265ReferenceInfoFlags flags = {}; 2434 int32_t PicOrderCntVal = {}; 2435 }; 2436 2437 //=== vulkan_video_codec_h265std_encode === 2438 2439 struct EncodeH265WeightTableFlags 2440 { 2441 using NativeType = StdVideoEncodeH265WeightTableFlags; 2442 operator StdVideoEncodeH265WeightTableFlags const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265WeightTableFlags2443 operator StdVideoEncodeH265WeightTableFlags const &() const VULKAN_HPP_NOEXCEPT 2444 { 2445 return *reinterpret_cast<const StdVideoEncodeH265WeightTableFlags *>( this ); 2446 } 2447 operator StdVideoEncodeH265WeightTableFlags&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265WeightTableFlags2448 operator StdVideoEncodeH265WeightTableFlags &() VULKAN_HPP_NOEXCEPT 2449 { 2450 return *reinterpret_cast<StdVideoEncodeH265WeightTableFlags *>( this ); 2451 } 2452 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265WeightTableFlags2453 bool operator==( EncodeH265WeightTableFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 2454 { 2455 return ( luma_weight_l0_flag == rhs.luma_weight_l0_flag ) && ( chroma_weight_l0_flag == rhs.chroma_weight_l0_flag ) && 2456 ( luma_weight_l1_flag == rhs.luma_weight_l1_flag ) && ( chroma_weight_l1_flag == rhs.chroma_weight_l1_flag ); 2457 } 2458 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265WeightTableFlags2459 bool operator!=( EncodeH265WeightTableFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 2460 { 2461 return !operator==( rhs ); 2462 } 2463 2464 public: 2465 uint16_t luma_weight_l0_flag = {}; 2466 uint16_t chroma_weight_l0_flag = {}; 2467 uint16_t luma_weight_l1_flag = {}; 2468 uint16_t chroma_weight_l1_flag = {}; 2469 }; 2470 2471 struct EncodeH265WeightTable 2472 { 2473 using NativeType = StdVideoEncodeH265WeightTable; 2474 operator StdVideoEncodeH265WeightTable const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265WeightTable2475 operator StdVideoEncodeH265WeightTable const &() const VULKAN_HPP_NOEXCEPT 2476 { 2477 return *reinterpret_cast<const StdVideoEncodeH265WeightTable *>( this ); 2478 } 2479 operator StdVideoEncodeH265WeightTable&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265WeightTable2480 operator StdVideoEncodeH265WeightTable &() VULKAN_HPP_NOEXCEPT 2481 { 2482 return *reinterpret_cast<StdVideoEncodeH265WeightTable *>( this ); 2483 } 2484 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265WeightTable2485 bool operator==( EncodeH265WeightTable const & rhs ) const VULKAN_HPP_NOEXCEPT 2486 { 2487 return ( flags == rhs.flags ) && ( luma_log2_weight_denom == rhs.luma_log2_weight_denom ) && 2488 ( delta_chroma_log2_weight_denom == rhs.delta_chroma_log2_weight_denom ) && ( delta_luma_weight_l0 == rhs.delta_luma_weight_l0 ) && 2489 ( luma_offset_l0 == rhs.luma_offset_l0 ) && ( delta_chroma_weight_l0 == rhs.delta_chroma_weight_l0 ) && 2490 ( delta_chroma_offset_l0 == rhs.delta_chroma_offset_l0 ) && ( delta_luma_weight_l1 == rhs.delta_luma_weight_l1 ) && 2491 ( luma_offset_l1 == rhs.luma_offset_l1 ) && ( delta_chroma_weight_l1 == rhs.delta_chroma_weight_l1 ) && 2492 ( delta_chroma_offset_l1 == rhs.delta_chroma_offset_l1 ); 2493 } 2494 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265WeightTable2495 bool operator!=( EncodeH265WeightTable const & rhs ) const VULKAN_HPP_NOEXCEPT 2496 { 2497 return !operator==( rhs ); 2498 } 2499 2500 public: 2501 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265WeightTableFlags flags = {}; 2502 uint8_t luma_log2_weight_denom = {}; 2503 int8_t delta_chroma_log2_weight_denom = {}; 2504 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<int8_t, STD_VIDEO_H265_MAX_NUM_LIST_REF> delta_luma_weight_l0 = {}; 2505 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<int8_t, STD_VIDEO_H265_MAX_NUM_LIST_REF> luma_offset_l0 = {}; 2506 VULKAN_HPP_NAMESPACE::ArrayWrapper2D<int8_t, STD_VIDEO_H265_MAX_NUM_LIST_REF, STD_VIDEO_H265_MAX_CHROMA_PLANES> delta_chroma_weight_l0 = {}; 2507 VULKAN_HPP_NAMESPACE::ArrayWrapper2D<int8_t, STD_VIDEO_H265_MAX_NUM_LIST_REF, STD_VIDEO_H265_MAX_CHROMA_PLANES> delta_chroma_offset_l0 = {}; 2508 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<int8_t, STD_VIDEO_H265_MAX_NUM_LIST_REF> delta_luma_weight_l1 = {}; 2509 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<int8_t, STD_VIDEO_H265_MAX_NUM_LIST_REF> luma_offset_l1 = {}; 2510 VULKAN_HPP_NAMESPACE::ArrayWrapper2D<int8_t, STD_VIDEO_H265_MAX_NUM_LIST_REF, STD_VIDEO_H265_MAX_CHROMA_PLANES> delta_chroma_weight_l1 = {}; 2511 VULKAN_HPP_NAMESPACE::ArrayWrapper2D<int8_t, STD_VIDEO_H265_MAX_NUM_LIST_REF, STD_VIDEO_H265_MAX_CHROMA_PLANES> delta_chroma_offset_l1 = {}; 2512 }; 2513 2514 struct EncodeH265SliceSegmentHeaderFlags 2515 { 2516 using NativeType = StdVideoEncodeH265SliceSegmentHeaderFlags; 2517 operator StdVideoEncodeH265SliceSegmentHeaderFlags const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265SliceSegmentHeaderFlags2518 operator StdVideoEncodeH265SliceSegmentHeaderFlags const &() const VULKAN_HPP_NOEXCEPT 2519 { 2520 return *reinterpret_cast<const StdVideoEncodeH265SliceSegmentHeaderFlags *>( this ); 2521 } 2522 operator StdVideoEncodeH265SliceSegmentHeaderFlags&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265SliceSegmentHeaderFlags2523 operator StdVideoEncodeH265SliceSegmentHeaderFlags &() VULKAN_HPP_NOEXCEPT 2524 { 2525 return *reinterpret_cast<StdVideoEncodeH265SliceSegmentHeaderFlags *>( this ); 2526 } 2527 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265SliceSegmentHeaderFlags2528 bool operator==( EncodeH265SliceSegmentHeaderFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 2529 { 2530 return ( first_slice_segment_in_pic_flag == rhs.first_slice_segment_in_pic_flag ) && 2531 ( dependent_slice_segment_flag == rhs.dependent_slice_segment_flag ) && ( slice_sao_luma_flag == rhs.slice_sao_luma_flag ) && 2532 ( slice_sao_chroma_flag == rhs.slice_sao_chroma_flag ) && ( num_ref_idx_active_override_flag == rhs.num_ref_idx_active_override_flag ) && 2533 ( mvd_l1_zero_flag == rhs.mvd_l1_zero_flag ) && ( cabac_init_flag == rhs.cabac_init_flag ) && 2534 ( cu_chroma_qp_offset_enabled_flag == rhs.cu_chroma_qp_offset_enabled_flag ) && 2535 ( deblocking_filter_override_flag == rhs.deblocking_filter_override_flag ) && 2536 ( slice_deblocking_filter_disabled_flag == rhs.slice_deblocking_filter_disabled_flag ) && 2537 ( collocated_from_l0_flag == rhs.collocated_from_l0_flag ) && 2538 ( slice_loop_filter_across_slices_enabled_flag == rhs.slice_loop_filter_across_slices_enabled_flag ) && ( reserved == rhs.reserved ); 2539 } 2540 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265SliceSegmentHeaderFlags2541 bool operator!=( EncodeH265SliceSegmentHeaderFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 2542 { 2543 return !operator==( rhs ); 2544 } 2545 2546 public: 2547 uint32_t first_slice_segment_in_pic_flag : 1; 2548 uint32_t dependent_slice_segment_flag : 1; 2549 uint32_t slice_sao_luma_flag : 1; 2550 uint32_t slice_sao_chroma_flag : 1; 2551 uint32_t num_ref_idx_active_override_flag : 1; 2552 uint32_t mvd_l1_zero_flag : 1; 2553 uint32_t cabac_init_flag : 1; 2554 uint32_t cu_chroma_qp_offset_enabled_flag : 1; 2555 uint32_t deblocking_filter_override_flag : 1; 2556 uint32_t slice_deblocking_filter_disabled_flag : 1; 2557 uint32_t collocated_from_l0_flag : 1; 2558 uint32_t slice_loop_filter_across_slices_enabled_flag : 1; 2559 uint32_t reserved : 20; 2560 }; 2561 2562 struct EncodeH265SliceSegmentHeader 2563 { 2564 using NativeType = StdVideoEncodeH265SliceSegmentHeader; 2565 operator StdVideoEncodeH265SliceSegmentHeader const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265SliceSegmentHeader2566 operator StdVideoEncodeH265SliceSegmentHeader const &() const VULKAN_HPP_NOEXCEPT 2567 { 2568 return *reinterpret_cast<const StdVideoEncodeH265SliceSegmentHeader *>( this ); 2569 } 2570 operator StdVideoEncodeH265SliceSegmentHeader&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265SliceSegmentHeader2571 operator StdVideoEncodeH265SliceSegmentHeader &() VULKAN_HPP_NOEXCEPT 2572 { 2573 return *reinterpret_cast<StdVideoEncodeH265SliceSegmentHeader *>( this ); 2574 } 2575 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265SliceSegmentHeader2576 bool operator==( EncodeH265SliceSegmentHeader const & rhs ) const VULKAN_HPP_NOEXCEPT 2577 { 2578 return ( flags == rhs.flags ) && ( slice_type == rhs.slice_type ) && ( slice_segment_address == rhs.slice_segment_address ) && 2579 ( collocated_ref_idx == rhs.collocated_ref_idx ) && ( MaxNumMergeCand == rhs.MaxNumMergeCand ) && 2580 ( slice_cb_qp_offset == rhs.slice_cb_qp_offset ) && ( slice_cr_qp_offset == rhs.slice_cr_qp_offset ) && 2581 ( slice_beta_offset_div2 == rhs.slice_beta_offset_div2 ) && ( slice_tc_offset_div2 == rhs.slice_tc_offset_div2 ) && 2582 ( slice_act_y_qp_offset == rhs.slice_act_y_qp_offset ) && ( slice_act_cb_qp_offset == rhs.slice_act_cb_qp_offset ) && 2583 ( slice_act_cr_qp_offset == rhs.slice_act_cr_qp_offset ) && ( slice_qp_delta == rhs.slice_qp_delta ) && ( reserved1 == rhs.reserved1 ) && 2584 ( pWeightTable == rhs.pWeightTable ); 2585 } 2586 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265SliceSegmentHeader2587 bool operator!=( EncodeH265SliceSegmentHeader const & rhs ) const VULKAN_HPP_NOEXCEPT 2588 { 2589 return !operator==( rhs ); 2590 } 2591 2592 public: 2593 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265SliceSegmentHeaderFlags flags = {}; 2594 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SliceType slice_type = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SliceType::eB; 2595 uint32_t slice_segment_address = {}; 2596 uint8_t collocated_ref_idx = {}; 2597 uint8_t MaxNumMergeCand = {}; 2598 int8_t slice_cb_qp_offset = {}; 2599 int8_t slice_cr_qp_offset = {}; 2600 int8_t slice_beta_offset_div2 = {}; 2601 int8_t slice_tc_offset_div2 = {}; 2602 int8_t slice_act_y_qp_offset = {}; 2603 int8_t slice_act_cb_qp_offset = {}; 2604 int8_t slice_act_cr_qp_offset = {}; 2605 int8_t slice_qp_delta = {}; 2606 uint16_t reserved1 = {}; 2607 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265WeightTable * pWeightTable = {}; 2608 }; 2609 2610 struct EncodeH265ReferenceListsInfoFlags 2611 { 2612 using NativeType = StdVideoEncodeH265ReferenceListsInfoFlags; 2613 operator StdVideoEncodeH265ReferenceListsInfoFlags const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceListsInfoFlags2614 operator StdVideoEncodeH265ReferenceListsInfoFlags const &() const VULKAN_HPP_NOEXCEPT 2615 { 2616 return *reinterpret_cast<const StdVideoEncodeH265ReferenceListsInfoFlags *>( this ); 2617 } 2618 operator StdVideoEncodeH265ReferenceListsInfoFlags&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceListsInfoFlags2619 operator StdVideoEncodeH265ReferenceListsInfoFlags &() VULKAN_HPP_NOEXCEPT 2620 { 2621 return *reinterpret_cast<StdVideoEncodeH265ReferenceListsInfoFlags *>( this ); 2622 } 2623 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceListsInfoFlags2624 bool operator==( EncodeH265ReferenceListsInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 2625 { 2626 return ( ref_pic_list_modification_flag_l0 == rhs.ref_pic_list_modification_flag_l0 ) && 2627 ( ref_pic_list_modification_flag_l1 == rhs.ref_pic_list_modification_flag_l1 ) && ( reserved == rhs.reserved ); 2628 } 2629 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceListsInfoFlags2630 bool operator!=( EncodeH265ReferenceListsInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 2631 { 2632 return !operator==( rhs ); 2633 } 2634 2635 public: 2636 uint32_t ref_pic_list_modification_flag_l0 : 1; 2637 uint32_t ref_pic_list_modification_flag_l1 : 1; 2638 uint32_t reserved : 30; 2639 }; 2640 2641 struct EncodeH265ReferenceListsInfo 2642 { 2643 using NativeType = StdVideoEncodeH265ReferenceListsInfo; 2644 operator StdVideoEncodeH265ReferenceListsInfo const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceListsInfo2645 operator StdVideoEncodeH265ReferenceListsInfo const &() const VULKAN_HPP_NOEXCEPT 2646 { 2647 return *reinterpret_cast<const StdVideoEncodeH265ReferenceListsInfo *>( this ); 2648 } 2649 operator StdVideoEncodeH265ReferenceListsInfo&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceListsInfo2650 operator StdVideoEncodeH265ReferenceListsInfo &() VULKAN_HPP_NOEXCEPT 2651 { 2652 return *reinterpret_cast<StdVideoEncodeH265ReferenceListsInfo *>( this ); 2653 } 2654 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceListsInfo2655 bool operator==( EncodeH265ReferenceListsInfo const & rhs ) const VULKAN_HPP_NOEXCEPT 2656 { 2657 return ( flags == rhs.flags ) && ( num_ref_idx_l0_active_minus1 == rhs.num_ref_idx_l0_active_minus1 ) && 2658 ( num_ref_idx_l1_active_minus1 == rhs.num_ref_idx_l1_active_minus1 ) && ( RefPicList0 == rhs.RefPicList0 ) && 2659 ( RefPicList1 == rhs.RefPicList1 ) && ( list_entry_l0 == rhs.list_entry_l0 ) && ( list_entry_l1 == rhs.list_entry_l1 ); 2660 } 2661 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceListsInfo2662 bool operator!=( EncodeH265ReferenceListsInfo const & rhs ) const VULKAN_HPP_NOEXCEPT 2663 { 2664 return !operator==( rhs ); 2665 } 2666 2667 public: 2668 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceListsInfoFlags flags = {}; 2669 uint8_t num_ref_idx_l0_active_minus1 = {}; 2670 uint8_t num_ref_idx_l1_active_minus1 = {}; 2671 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_H265_MAX_NUM_LIST_REF> RefPicList0 = {}; 2672 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_H265_MAX_NUM_LIST_REF> RefPicList1 = {}; 2673 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_H265_MAX_NUM_LIST_REF> list_entry_l0 = {}; 2674 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_H265_MAX_NUM_LIST_REF> list_entry_l1 = {}; 2675 }; 2676 2677 struct EncodeH265PictureInfoFlags 2678 { 2679 using NativeType = StdVideoEncodeH265PictureInfoFlags; 2680 operator StdVideoEncodeH265PictureInfoFlags const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265PictureInfoFlags2681 operator StdVideoEncodeH265PictureInfoFlags const &() const VULKAN_HPP_NOEXCEPT 2682 { 2683 return *reinterpret_cast<const StdVideoEncodeH265PictureInfoFlags *>( this ); 2684 } 2685 operator StdVideoEncodeH265PictureInfoFlags&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265PictureInfoFlags2686 operator StdVideoEncodeH265PictureInfoFlags &() VULKAN_HPP_NOEXCEPT 2687 { 2688 return *reinterpret_cast<StdVideoEncodeH265PictureInfoFlags *>( this ); 2689 } 2690 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265PictureInfoFlags2691 bool operator==( EncodeH265PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 2692 { 2693 return ( is_reference == rhs.is_reference ) && ( IrapPicFlag == rhs.IrapPicFlag ) && 2694 ( used_for_long_term_reference == rhs.used_for_long_term_reference ) && ( discardable_flag == rhs.discardable_flag ) && 2695 ( cross_layer_bla_flag == rhs.cross_layer_bla_flag ) && ( pic_output_flag == rhs.pic_output_flag ) && 2696 ( no_output_of_prior_pics_flag == rhs.no_output_of_prior_pics_flag ) && 2697 ( short_term_ref_pic_set_sps_flag == rhs.short_term_ref_pic_set_sps_flag ) && 2698 ( slice_temporal_mvp_enabled_flag == rhs.slice_temporal_mvp_enabled_flag ) && ( reserved == rhs.reserved ); 2699 } 2700 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265PictureInfoFlags2701 bool operator!=( EncodeH265PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 2702 { 2703 return !operator==( rhs ); 2704 } 2705 2706 public: 2707 uint32_t is_reference : 1; 2708 uint32_t IrapPicFlag : 1; 2709 uint32_t used_for_long_term_reference : 1; 2710 uint32_t discardable_flag : 1; 2711 uint32_t cross_layer_bla_flag : 1; 2712 uint32_t pic_output_flag : 1; 2713 uint32_t no_output_of_prior_pics_flag : 1; 2714 uint32_t short_term_ref_pic_set_sps_flag : 1; 2715 uint32_t slice_temporal_mvp_enabled_flag : 1; 2716 uint32_t reserved : 23; 2717 }; 2718 2719 struct EncodeH265LongTermRefPics 2720 { 2721 using NativeType = StdVideoEncodeH265LongTermRefPics; 2722 operator StdVideoEncodeH265LongTermRefPics const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265LongTermRefPics2723 operator StdVideoEncodeH265LongTermRefPics const &() const VULKAN_HPP_NOEXCEPT 2724 { 2725 return *reinterpret_cast<const StdVideoEncodeH265LongTermRefPics *>( this ); 2726 } 2727 operator StdVideoEncodeH265LongTermRefPics&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265LongTermRefPics2728 operator StdVideoEncodeH265LongTermRefPics &() VULKAN_HPP_NOEXCEPT 2729 { 2730 return *reinterpret_cast<StdVideoEncodeH265LongTermRefPics *>( this ); 2731 } 2732 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265LongTermRefPics2733 bool operator==( EncodeH265LongTermRefPics const & rhs ) const VULKAN_HPP_NOEXCEPT 2734 { 2735 return ( num_long_term_sps == rhs.num_long_term_sps ) && ( num_long_term_pics == rhs.num_long_term_pics ) && ( lt_idx_sps == rhs.lt_idx_sps ) && 2736 ( poc_lsb_lt == rhs.poc_lsb_lt ) && ( used_by_curr_pic_lt_flag == rhs.used_by_curr_pic_lt_flag ) && 2737 ( delta_poc_msb_present_flag == rhs.delta_poc_msb_present_flag ) && ( delta_poc_msb_cycle_lt == rhs.delta_poc_msb_cycle_lt ); 2738 } 2739 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265LongTermRefPics2740 bool operator!=( EncodeH265LongTermRefPics const & rhs ) const VULKAN_HPP_NOEXCEPT 2741 { 2742 return !operator==( rhs ); 2743 } 2744 2745 public: 2746 uint8_t num_long_term_sps = {}; 2747 uint8_t num_long_term_pics = {}; 2748 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_H265_MAX_LONG_TERM_REF_PICS_SPS> lt_idx_sps = {}; 2749 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_H265_MAX_LONG_TERM_PICS> poc_lsb_lt = {}; 2750 uint16_t used_by_curr_pic_lt_flag = {}; 2751 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_H265_MAX_DELTA_POC> delta_poc_msb_present_flag = {}; 2752 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_H265_MAX_DELTA_POC> delta_poc_msb_cycle_lt = {}; 2753 }; 2754 2755 struct EncodeH265PictureInfo 2756 { 2757 using NativeType = StdVideoEncodeH265PictureInfo; 2758 operator StdVideoEncodeH265PictureInfo const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265PictureInfo2759 operator StdVideoEncodeH265PictureInfo const &() const VULKAN_HPP_NOEXCEPT 2760 { 2761 return *reinterpret_cast<const StdVideoEncodeH265PictureInfo *>( this ); 2762 } 2763 operator StdVideoEncodeH265PictureInfo&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265PictureInfo2764 operator StdVideoEncodeH265PictureInfo &() VULKAN_HPP_NOEXCEPT 2765 { 2766 return *reinterpret_cast<StdVideoEncodeH265PictureInfo *>( this ); 2767 } 2768 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265PictureInfo2769 bool operator==( EncodeH265PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT 2770 { 2771 return ( flags == rhs.flags ) && ( pic_type == rhs.pic_type ) && ( sps_video_parameter_set_id == rhs.sps_video_parameter_set_id ) && 2772 ( pps_seq_parameter_set_id == rhs.pps_seq_parameter_set_id ) && ( pps_pic_parameter_set_id == rhs.pps_pic_parameter_set_id ) && 2773 ( short_term_ref_pic_set_idx == rhs.short_term_ref_pic_set_idx ) && ( PicOrderCntVal == rhs.PicOrderCntVal ) && 2774 ( TemporalId == rhs.TemporalId ) && ( reserved1 == rhs.reserved1 ) && ( pRefLists == rhs.pRefLists ) && 2775 ( pShortTermRefPicSet == rhs.pShortTermRefPicSet ) && ( pLongTermRefPics == rhs.pLongTermRefPics ); 2776 } 2777 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265PictureInfo2778 bool operator!=( EncodeH265PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT 2779 { 2780 return !operator==( rhs ); 2781 } 2782 2783 public: 2784 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265PictureInfoFlags flags = {}; 2785 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PictureType pic_type = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PictureType::eP; 2786 uint8_t sps_video_parameter_set_id = {}; 2787 uint8_t pps_seq_parameter_set_id = {}; 2788 uint8_t pps_pic_parameter_set_id = {}; 2789 uint8_t short_term_ref_pic_set_idx = {}; 2790 int32_t PicOrderCntVal = {}; 2791 uint8_t TemporalId = {}; 2792 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, 7> reserved1 = {}; 2793 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceListsInfo * pRefLists = {}; 2794 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ShortTermRefPicSet * pShortTermRefPicSet = {}; 2795 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265LongTermRefPics * pLongTermRefPics = {}; 2796 }; 2797 2798 struct EncodeH265ReferenceInfoFlags 2799 { 2800 using NativeType = StdVideoEncodeH265ReferenceInfoFlags; 2801 operator StdVideoEncodeH265ReferenceInfoFlags const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceInfoFlags2802 operator StdVideoEncodeH265ReferenceInfoFlags const &() const VULKAN_HPP_NOEXCEPT 2803 { 2804 return *reinterpret_cast<const StdVideoEncodeH265ReferenceInfoFlags *>( this ); 2805 } 2806 operator StdVideoEncodeH265ReferenceInfoFlags&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceInfoFlags2807 operator StdVideoEncodeH265ReferenceInfoFlags &() VULKAN_HPP_NOEXCEPT 2808 { 2809 return *reinterpret_cast<StdVideoEncodeH265ReferenceInfoFlags *>( this ); 2810 } 2811 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceInfoFlags2812 bool operator==( EncodeH265ReferenceInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 2813 { 2814 return ( used_for_long_term_reference == rhs.used_for_long_term_reference ) && ( unused_for_reference == rhs.unused_for_reference ) && 2815 ( reserved == rhs.reserved ); 2816 } 2817 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceInfoFlags2818 bool operator!=( EncodeH265ReferenceInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 2819 { 2820 return !operator==( rhs ); 2821 } 2822 2823 public: 2824 uint32_t used_for_long_term_reference : 1; 2825 uint32_t unused_for_reference : 1; 2826 uint32_t reserved : 30; 2827 }; 2828 2829 struct EncodeH265ReferenceInfo 2830 { 2831 using NativeType = StdVideoEncodeH265ReferenceInfo; 2832 operator StdVideoEncodeH265ReferenceInfo const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceInfo2833 operator StdVideoEncodeH265ReferenceInfo const &() const VULKAN_HPP_NOEXCEPT 2834 { 2835 return *reinterpret_cast<const StdVideoEncodeH265ReferenceInfo *>( this ); 2836 } 2837 operator StdVideoEncodeH265ReferenceInfo&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceInfo2838 operator StdVideoEncodeH265ReferenceInfo &() VULKAN_HPP_NOEXCEPT 2839 { 2840 return *reinterpret_cast<StdVideoEncodeH265ReferenceInfo *>( this ); 2841 } 2842 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceInfo2843 bool operator==( EncodeH265ReferenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT 2844 { 2845 return ( flags == rhs.flags ) && ( pic_type == rhs.pic_type ) && ( PicOrderCntVal == rhs.PicOrderCntVal ) && ( TemporalId == rhs.TemporalId ); 2846 } 2847 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceInfo2848 bool operator!=( EncodeH265ReferenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT 2849 { 2850 return !operator==( rhs ); 2851 } 2852 2853 public: 2854 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceInfoFlags flags = {}; 2855 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PictureType pic_type = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PictureType::eP; 2856 int32_t PicOrderCntVal = {}; 2857 uint8_t TemporalId = {}; 2858 }; 2859 2860 //=== vulkan_video_codec_av1std === 2861 2862 struct AV1ColorConfigFlags 2863 { 2864 using NativeType = StdVideoAV1ColorConfigFlags; 2865 operator StdVideoAV1ColorConfigFlags const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ColorConfigFlags2866 operator StdVideoAV1ColorConfigFlags const &() const VULKAN_HPP_NOEXCEPT 2867 { 2868 return *reinterpret_cast<const StdVideoAV1ColorConfigFlags *>( this ); 2869 } 2870 operator StdVideoAV1ColorConfigFlags&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ColorConfigFlags2871 operator StdVideoAV1ColorConfigFlags &() VULKAN_HPP_NOEXCEPT 2872 { 2873 return *reinterpret_cast<StdVideoAV1ColorConfigFlags *>( this ); 2874 } 2875 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ColorConfigFlags2876 bool operator==( AV1ColorConfigFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 2877 { 2878 return ( mono_chrome == rhs.mono_chrome ) && ( color_range == rhs.color_range ) && ( separate_uv_delta_q == rhs.separate_uv_delta_q ) && 2879 ( color_description_present_flag == rhs.color_description_present_flag ) && ( reserved == rhs.reserved ); 2880 } 2881 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ColorConfigFlags2882 bool operator!=( AV1ColorConfigFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 2883 { 2884 return !operator==( rhs ); 2885 } 2886 2887 public: 2888 uint32_t mono_chrome : 1; 2889 uint32_t color_range : 1; 2890 uint32_t separate_uv_delta_q : 1; 2891 uint32_t color_description_present_flag : 1; 2892 uint32_t reserved : 28; 2893 }; 2894 2895 struct AV1ColorConfig 2896 { 2897 using NativeType = StdVideoAV1ColorConfig; 2898 operator StdVideoAV1ColorConfig const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ColorConfig2899 operator StdVideoAV1ColorConfig const &() const VULKAN_HPP_NOEXCEPT 2900 { 2901 return *reinterpret_cast<const StdVideoAV1ColorConfig *>( this ); 2902 } 2903 operator StdVideoAV1ColorConfig&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ColorConfig2904 operator StdVideoAV1ColorConfig &() VULKAN_HPP_NOEXCEPT 2905 { 2906 return *reinterpret_cast<StdVideoAV1ColorConfig *>( this ); 2907 } 2908 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ColorConfig2909 bool operator==( AV1ColorConfig const & rhs ) const VULKAN_HPP_NOEXCEPT 2910 { 2911 return ( flags == rhs.flags ) && ( BitDepth == rhs.BitDepth ) && ( subsampling_x == rhs.subsampling_x ) && ( subsampling_y == rhs.subsampling_y ) && 2912 ( reserved1 == rhs.reserved1 ) && ( color_primaries == rhs.color_primaries ) && ( transfer_characteristics == rhs.transfer_characteristics ) && 2913 ( matrix_coefficients == rhs.matrix_coefficients ) && ( chroma_sample_position == rhs.chroma_sample_position ); 2914 } 2915 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ColorConfig2916 bool operator!=( AV1ColorConfig const & rhs ) const VULKAN_HPP_NOEXCEPT 2917 { 2918 return !operator==( rhs ); 2919 } 2920 2921 public: 2922 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ColorConfigFlags flags = {}; 2923 uint8_t BitDepth = {}; 2924 uint8_t subsampling_x = {}; 2925 uint8_t subsampling_y = {}; 2926 uint8_t reserved1 = {}; 2927 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ColorPrimaries color_primaries = 2928 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ColorPrimaries::eBt709; 2929 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TransferCharacteristics transfer_characteristics = 2930 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TransferCharacteristics::eReserved0; 2931 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1MatrixCoefficients matrix_coefficients = 2932 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1MatrixCoefficients::eIdentity; 2933 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ChromaSamplePosition chroma_sample_position = 2934 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ChromaSamplePosition::eUnknown; 2935 }; 2936 2937 struct AV1TimingInfoFlags 2938 { 2939 using NativeType = StdVideoAV1TimingInfoFlags; 2940 operator StdVideoAV1TimingInfoFlags const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TimingInfoFlags2941 operator StdVideoAV1TimingInfoFlags const &() const VULKAN_HPP_NOEXCEPT 2942 { 2943 return *reinterpret_cast<const StdVideoAV1TimingInfoFlags *>( this ); 2944 } 2945 operator StdVideoAV1TimingInfoFlags&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TimingInfoFlags2946 operator StdVideoAV1TimingInfoFlags &() VULKAN_HPP_NOEXCEPT 2947 { 2948 return *reinterpret_cast<StdVideoAV1TimingInfoFlags *>( this ); 2949 } 2950 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TimingInfoFlags2951 bool operator==( AV1TimingInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 2952 { 2953 return ( equal_picture_interval == rhs.equal_picture_interval ) && ( reserved == rhs.reserved ); 2954 } 2955 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TimingInfoFlags2956 bool operator!=( AV1TimingInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 2957 { 2958 return !operator==( rhs ); 2959 } 2960 2961 public: 2962 uint32_t equal_picture_interval : 1; 2963 uint32_t reserved : 31; 2964 }; 2965 2966 struct AV1TimingInfo 2967 { 2968 using NativeType = StdVideoAV1TimingInfo; 2969 operator StdVideoAV1TimingInfo const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TimingInfo2970 operator StdVideoAV1TimingInfo const &() const VULKAN_HPP_NOEXCEPT 2971 { 2972 return *reinterpret_cast<const StdVideoAV1TimingInfo *>( this ); 2973 } 2974 operator StdVideoAV1TimingInfo&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TimingInfo2975 operator StdVideoAV1TimingInfo &() VULKAN_HPP_NOEXCEPT 2976 { 2977 return *reinterpret_cast<StdVideoAV1TimingInfo *>( this ); 2978 } 2979 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TimingInfo2980 bool operator==( AV1TimingInfo const & rhs ) const VULKAN_HPP_NOEXCEPT 2981 { 2982 return ( flags == rhs.flags ) && ( num_units_in_display_tick == rhs.num_units_in_display_tick ) && ( time_scale == rhs.time_scale ) && 2983 ( num_ticks_per_picture_minus_1 == rhs.num_ticks_per_picture_minus_1 ); 2984 } 2985 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TimingInfo2986 bool operator!=( AV1TimingInfo const & rhs ) const VULKAN_HPP_NOEXCEPT 2987 { 2988 return !operator==( rhs ); 2989 } 2990 2991 public: 2992 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TimingInfoFlags flags = {}; 2993 uint32_t num_units_in_display_tick = {}; 2994 uint32_t time_scale = {}; 2995 uint32_t num_ticks_per_picture_minus_1 = {}; 2996 }; 2997 2998 struct AV1LoopFilterFlags 2999 { 3000 using NativeType = StdVideoAV1LoopFilterFlags; 3001 operator StdVideoAV1LoopFilterFlags const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1LoopFilterFlags3002 operator StdVideoAV1LoopFilterFlags const &() const VULKAN_HPP_NOEXCEPT 3003 { 3004 return *reinterpret_cast<const StdVideoAV1LoopFilterFlags *>( this ); 3005 } 3006 operator StdVideoAV1LoopFilterFlags&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1LoopFilterFlags3007 operator StdVideoAV1LoopFilterFlags &() VULKAN_HPP_NOEXCEPT 3008 { 3009 return *reinterpret_cast<StdVideoAV1LoopFilterFlags *>( this ); 3010 } 3011 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1LoopFilterFlags3012 bool operator==( AV1LoopFilterFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 3013 { 3014 return ( loop_filter_delta_enabled == rhs.loop_filter_delta_enabled ) && ( loop_filter_delta_update == rhs.loop_filter_delta_update ) && 3015 ( reserved == rhs.reserved ); 3016 } 3017 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1LoopFilterFlags3018 bool operator!=( AV1LoopFilterFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 3019 { 3020 return !operator==( rhs ); 3021 } 3022 3023 public: 3024 uint32_t loop_filter_delta_enabled : 1; 3025 uint32_t loop_filter_delta_update : 1; 3026 uint32_t reserved : 30; 3027 }; 3028 3029 struct AV1LoopFilter 3030 { 3031 using NativeType = StdVideoAV1LoopFilter; 3032 operator StdVideoAV1LoopFilter const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1LoopFilter3033 operator StdVideoAV1LoopFilter const &() const VULKAN_HPP_NOEXCEPT 3034 { 3035 return *reinterpret_cast<const StdVideoAV1LoopFilter *>( this ); 3036 } 3037 operator StdVideoAV1LoopFilter&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1LoopFilter3038 operator StdVideoAV1LoopFilter &() VULKAN_HPP_NOEXCEPT 3039 { 3040 return *reinterpret_cast<StdVideoAV1LoopFilter *>( this ); 3041 } 3042 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1LoopFilter3043 bool operator==( AV1LoopFilter const & rhs ) const VULKAN_HPP_NOEXCEPT 3044 { 3045 return ( flags == rhs.flags ) && ( loop_filter_level == rhs.loop_filter_level ) && ( loop_filter_sharpness == rhs.loop_filter_sharpness ) && 3046 ( update_ref_delta == rhs.update_ref_delta ) && ( loop_filter_ref_deltas == rhs.loop_filter_ref_deltas ) && 3047 ( update_mode_delta == rhs.update_mode_delta ) && ( loop_filter_mode_deltas == rhs.loop_filter_mode_deltas ); 3048 } 3049 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1LoopFilter3050 bool operator!=( AV1LoopFilter const & rhs ) const VULKAN_HPP_NOEXCEPT 3051 { 3052 return !operator==( rhs ); 3053 } 3054 3055 public: 3056 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1LoopFilterFlags flags = {}; 3057 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_AV1_MAX_LOOP_FILTER_STRENGTHS> loop_filter_level = {}; 3058 uint8_t loop_filter_sharpness = {}; 3059 uint8_t update_ref_delta = {}; 3060 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<int8_t, STD_VIDEO_AV1_TOTAL_REFS_PER_FRAME> loop_filter_ref_deltas = {}; 3061 uint8_t update_mode_delta = {}; 3062 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<int8_t, STD_VIDEO_AV1_LOOP_FILTER_ADJUSTMENTS> loop_filter_mode_deltas = {}; 3063 }; 3064 3065 struct AV1QuantizationFlags 3066 { 3067 using NativeType = StdVideoAV1QuantizationFlags; 3068 operator StdVideoAV1QuantizationFlags const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1QuantizationFlags3069 operator StdVideoAV1QuantizationFlags const &() const VULKAN_HPP_NOEXCEPT 3070 { 3071 return *reinterpret_cast<const StdVideoAV1QuantizationFlags *>( this ); 3072 } 3073 operator StdVideoAV1QuantizationFlags&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1QuantizationFlags3074 operator StdVideoAV1QuantizationFlags &() VULKAN_HPP_NOEXCEPT 3075 { 3076 return *reinterpret_cast<StdVideoAV1QuantizationFlags *>( this ); 3077 } 3078 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1QuantizationFlags3079 bool operator==( AV1QuantizationFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 3080 { 3081 return ( using_qmatrix == rhs.using_qmatrix ) && ( diff_uv_delta == rhs.diff_uv_delta ) && ( reserved == rhs.reserved ); 3082 } 3083 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1QuantizationFlags3084 bool operator!=( AV1QuantizationFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 3085 { 3086 return !operator==( rhs ); 3087 } 3088 3089 public: 3090 uint32_t using_qmatrix : 1; 3091 uint32_t diff_uv_delta : 1; 3092 uint32_t reserved : 30; 3093 }; 3094 3095 struct AV1Quantization 3096 { 3097 using NativeType = StdVideoAV1Quantization; 3098 operator StdVideoAV1Quantization const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Quantization3099 operator StdVideoAV1Quantization const &() const VULKAN_HPP_NOEXCEPT 3100 { 3101 return *reinterpret_cast<const StdVideoAV1Quantization *>( this ); 3102 } 3103 operator StdVideoAV1Quantization&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Quantization3104 operator StdVideoAV1Quantization &() VULKAN_HPP_NOEXCEPT 3105 { 3106 return *reinterpret_cast<StdVideoAV1Quantization *>( this ); 3107 } 3108 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Quantization3109 bool operator==( AV1Quantization const & rhs ) const VULKAN_HPP_NOEXCEPT 3110 { 3111 return ( flags == rhs.flags ) && ( base_q_idx == rhs.base_q_idx ) && ( DeltaQYDc == rhs.DeltaQYDc ) && ( DeltaQUDc == rhs.DeltaQUDc ) && 3112 ( DeltaQUAc == rhs.DeltaQUAc ) && ( DeltaQVDc == rhs.DeltaQVDc ) && ( DeltaQVAc == rhs.DeltaQVAc ) && ( qm_y == rhs.qm_y ) && 3113 ( qm_u == rhs.qm_u ) && ( qm_v == rhs.qm_v ); 3114 } 3115 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Quantization3116 bool operator!=( AV1Quantization const & rhs ) const VULKAN_HPP_NOEXCEPT 3117 { 3118 return !operator==( rhs ); 3119 } 3120 3121 public: 3122 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1QuantizationFlags flags = {}; 3123 uint8_t base_q_idx = {}; 3124 int8_t DeltaQYDc = {}; 3125 int8_t DeltaQUDc = {}; 3126 int8_t DeltaQUAc = {}; 3127 int8_t DeltaQVDc = {}; 3128 int8_t DeltaQVAc = {}; 3129 uint8_t qm_y = {}; 3130 uint8_t qm_u = {}; 3131 uint8_t qm_v = {}; 3132 }; 3133 3134 struct AV1Segmentation 3135 { 3136 using NativeType = StdVideoAV1Segmentation; 3137 operator StdVideoAV1Segmentation const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Segmentation3138 operator StdVideoAV1Segmentation const &() const VULKAN_HPP_NOEXCEPT 3139 { 3140 return *reinterpret_cast<const StdVideoAV1Segmentation *>( this ); 3141 } 3142 operator StdVideoAV1Segmentation&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Segmentation3143 operator StdVideoAV1Segmentation &() VULKAN_HPP_NOEXCEPT 3144 { 3145 return *reinterpret_cast<StdVideoAV1Segmentation *>( this ); 3146 } 3147 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Segmentation3148 bool operator==( AV1Segmentation const & rhs ) const VULKAN_HPP_NOEXCEPT 3149 { 3150 return ( FeatureEnabled == rhs.FeatureEnabled ) && ( FeatureData == rhs.FeatureData ); 3151 } 3152 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Segmentation3153 bool operator!=( AV1Segmentation const & rhs ) const VULKAN_HPP_NOEXCEPT 3154 { 3155 return !operator==( rhs ); 3156 } 3157 3158 public: 3159 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_AV1_MAX_SEGMENTS> FeatureEnabled = {}; 3160 VULKAN_HPP_NAMESPACE::ArrayWrapper2D<int16_t, STD_VIDEO_AV1_MAX_SEGMENTS, STD_VIDEO_AV1_SEG_LVL_MAX> FeatureData = {}; 3161 }; 3162 3163 struct AV1TileInfoFlags 3164 { 3165 using NativeType = StdVideoAV1TileInfoFlags; 3166 operator StdVideoAV1TileInfoFlags const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TileInfoFlags3167 operator StdVideoAV1TileInfoFlags const &() const VULKAN_HPP_NOEXCEPT 3168 { 3169 return *reinterpret_cast<const StdVideoAV1TileInfoFlags *>( this ); 3170 } 3171 operator StdVideoAV1TileInfoFlags&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TileInfoFlags3172 operator StdVideoAV1TileInfoFlags &() VULKAN_HPP_NOEXCEPT 3173 { 3174 return *reinterpret_cast<StdVideoAV1TileInfoFlags *>( this ); 3175 } 3176 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TileInfoFlags3177 bool operator==( AV1TileInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 3178 { 3179 return ( uniform_tile_spacing_flag == rhs.uniform_tile_spacing_flag ) && ( reserved == rhs.reserved ); 3180 } 3181 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TileInfoFlags3182 bool operator!=( AV1TileInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 3183 { 3184 return !operator==( rhs ); 3185 } 3186 3187 public: 3188 uint32_t uniform_tile_spacing_flag : 1; 3189 uint32_t reserved : 31; 3190 }; 3191 3192 struct AV1TileInfo 3193 { 3194 using NativeType = StdVideoAV1TileInfo; 3195 operator StdVideoAV1TileInfo const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TileInfo3196 operator StdVideoAV1TileInfo const &() const VULKAN_HPP_NOEXCEPT 3197 { 3198 return *reinterpret_cast<const StdVideoAV1TileInfo *>( this ); 3199 } 3200 operator StdVideoAV1TileInfo&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TileInfo3201 operator StdVideoAV1TileInfo &() VULKAN_HPP_NOEXCEPT 3202 { 3203 return *reinterpret_cast<StdVideoAV1TileInfo *>( this ); 3204 } 3205 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TileInfo3206 bool operator==( AV1TileInfo const & rhs ) const VULKAN_HPP_NOEXCEPT 3207 { 3208 return ( flags == rhs.flags ) && ( TileCols == rhs.TileCols ) && ( TileRows == rhs.TileRows ) && 3209 ( context_update_tile_id == rhs.context_update_tile_id ) && ( tile_size_bytes_minus_1 == rhs.tile_size_bytes_minus_1 ) && 3210 ( reserved1 == rhs.reserved1 ) && ( pMiColStarts == rhs.pMiColStarts ) && ( pMiRowStarts == rhs.pMiRowStarts ) && 3211 ( pWidthInSbsMinus1 == rhs.pWidthInSbsMinus1 ) && ( pHeightInSbsMinus1 == rhs.pHeightInSbsMinus1 ); 3212 } 3213 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TileInfo3214 bool operator!=( AV1TileInfo const & rhs ) const VULKAN_HPP_NOEXCEPT 3215 { 3216 return !operator==( rhs ); 3217 } 3218 3219 public: 3220 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TileInfoFlags flags = {}; 3221 uint8_t TileCols = {}; 3222 uint8_t TileRows = {}; 3223 uint16_t context_update_tile_id = {}; 3224 uint8_t tile_size_bytes_minus_1 = {}; 3225 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, 7> reserved1 = {}; 3226 const uint16_t * pMiColStarts = {}; 3227 const uint16_t * pMiRowStarts = {}; 3228 const uint16_t * pWidthInSbsMinus1 = {}; 3229 const uint16_t * pHeightInSbsMinus1 = {}; 3230 }; 3231 3232 struct AV1CDEF 3233 { 3234 using NativeType = StdVideoAV1CDEF; 3235 operator StdVideoAV1CDEF const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1CDEF3236 operator StdVideoAV1CDEF const &() const VULKAN_HPP_NOEXCEPT 3237 { 3238 return *reinterpret_cast<const StdVideoAV1CDEF *>( this ); 3239 } 3240 operator StdVideoAV1CDEF&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1CDEF3241 operator StdVideoAV1CDEF &() VULKAN_HPP_NOEXCEPT 3242 { 3243 return *reinterpret_cast<StdVideoAV1CDEF *>( this ); 3244 } 3245 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1CDEF3246 bool operator==( AV1CDEF const & rhs ) const VULKAN_HPP_NOEXCEPT 3247 { 3248 return ( cdef_damping_minus_3 == rhs.cdef_damping_minus_3 ) && ( cdef_bits == rhs.cdef_bits ) && ( cdef_y_pri_strength == rhs.cdef_y_pri_strength ) && 3249 ( cdef_y_sec_strength == rhs.cdef_y_sec_strength ) && ( cdef_uv_pri_strength == rhs.cdef_uv_pri_strength ) && 3250 ( cdef_uv_sec_strength == rhs.cdef_uv_sec_strength ); 3251 } 3252 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1CDEF3253 bool operator!=( AV1CDEF const & rhs ) const VULKAN_HPP_NOEXCEPT 3254 { 3255 return !operator==( rhs ); 3256 } 3257 3258 public: 3259 uint8_t cdef_damping_minus_3 = {}; 3260 uint8_t cdef_bits = {}; 3261 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS> cdef_y_pri_strength = {}; 3262 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS> cdef_y_sec_strength = {}; 3263 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS> cdef_uv_pri_strength = {}; 3264 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS> cdef_uv_sec_strength = {}; 3265 }; 3266 3267 struct AV1LoopRestoration 3268 { 3269 using NativeType = StdVideoAV1LoopRestoration; 3270 operator StdVideoAV1LoopRestoration const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1LoopRestoration3271 operator StdVideoAV1LoopRestoration const &() const VULKAN_HPP_NOEXCEPT 3272 { 3273 return *reinterpret_cast<const StdVideoAV1LoopRestoration *>( this ); 3274 } 3275 operator StdVideoAV1LoopRestoration&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1LoopRestoration3276 operator StdVideoAV1LoopRestoration &() VULKAN_HPP_NOEXCEPT 3277 { 3278 return *reinterpret_cast<StdVideoAV1LoopRestoration *>( this ); 3279 } 3280 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1LoopRestoration3281 bool operator==( AV1LoopRestoration const & rhs ) const VULKAN_HPP_NOEXCEPT 3282 { 3283 return ( FrameRestorationType == rhs.FrameRestorationType ) && ( LoopRestorationSize == rhs.LoopRestorationSize ); 3284 } 3285 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1LoopRestoration3286 bool operator!=( AV1LoopRestoration const & rhs ) const VULKAN_HPP_NOEXCEPT 3287 { 3288 return !operator==( rhs ); 3289 } 3290 3291 public: 3292 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<StdVideoAV1FrameRestorationType, STD_VIDEO_AV1_MAX_NUM_PLANES> FrameRestorationType = {}; 3293 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint16_t, STD_VIDEO_AV1_MAX_NUM_PLANES> LoopRestorationSize = {}; 3294 }; 3295 3296 struct AV1GlobalMotion 3297 { 3298 using NativeType = StdVideoAV1GlobalMotion; 3299 operator StdVideoAV1GlobalMotion const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1GlobalMotion3300 operator StdVideoAV1GlobalMotion const &() const VULKAN_HPP_NOEXCEPT 3301 { 3302 return *reinterpret_cast<const StdVideoAV1GlobalMotion *>( this ); 3303 } 3304 operator StdVideoAV1GlobalMotion&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1GlobalMotion3305 operator StdVideoAV1GlobalMotion &() VULKAN_HPP_NOEXCEPT 3306 { 3307 return *reinterpret_cast<StdVideoAV1GlobalMotion *>( this ); 3308 } 3309 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1GlobalMotion3310 bool operator==( AV1GlobalMotion const & rhs ) const VULKAN_HPP_NOEXCEPT 3311 { 3312 return ( GmType == rhs.GmType ) && ( gm_params == rhs.gm_params ); 3313 } 3314 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1GlobalMotion3315 bool operator!=( AV1GlobalMotion const & rhs ) const VULKAN_HPP_NOEXCEPT 3316 { 3317 return !operator==( rhs ); 3318 } 3319 3320 public: 3321 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_AV1_NUM_REF_FRAMES> GmType = {}; 3322 VULKAN_HPP_NAMESPACE::ArrayWrapper2D<int32_t, STD_VIDEO_AV1_NUM_REF_FRAMES, STD_VIDEO_AV1_GLOBAL_MOTION_PARAMS> gm_params = {}; 3323 }; 3324 3325 struct AV1FilmGrainFlags 3326 { 3327 using NativeType = StdVideoAV1FilmGrainFlags; 3328 operator StdVideoAV1FilmGrainFlags const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FilmGrainFlags3329 operator StdVideoAV1FilmGrainFlags const &() const VULKAN_HPP_NOEXCEPT 3330 { 3331 return *reinterpret_cast<const StdVideoAV1FilmGrainFlags *>( this ); 3332 } 3333 operator StdVideoAV1FilmGrainFlags&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FilmGrainFlags3334 operator StdVideoAV1FilmGrainFlags &() VULKAN_HPP_NOEXCEPT 3335 { 3336 return *reinterpret_cast<StdVideoAV1FilmGrainFlags *>( this ); 3337 } 3338 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FilmGrainFlags3339 bool operator==( AV1FilmGrainFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 3340 { 3341 return ( chroma_scaling_from_luma == rhs.chroma_scaling_from_luma ) && ( overlap_flag == rhs.overlap_flag ) && 3342 ( clip_to_restricted_range == rhs.clip_to_restricted_range ) && ( update_grain == rhs.update_grain ) && ( reserved == rhs.reserved ); 3343 } 3344 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FilmGrainFlags3345 bool operator!=( AV1FilmGrainFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 3346 { 3347 return !operator==( rhs ); 3348 } 3349 3350 public: 3351 uint32_t chroma_scaling_from_luma : 1; 3352 uint32_t overlap_flag : 1; 3353 uint32_t clip_to_restricted_range : 1; 3354 uint32_t update_grain : 1; 3355 uint32_t reserved : 28; 3356 }; 3357 3358 struct AV1FilmGrain 3359 { 3360 using NativeType = StdVideoAV1FilmGrain; 3361 operator StdVideoAV1FilmGrain const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FilmGrain3362 operator StdVideoAV1FilmGrain const &() const VULKAN_HPP_NOEXCEPT 3363 { 3364 return *reinterpret_cast<const StdVideoAV1FilmGrain *>( this ); 3365 } 3366 operator StdVideoAV1FilmGrain&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FilmGrain3367 operator StdVideoAV1FilmGrain &() VULKAN_HPP_NOEXCEPT 3368 { 3369 return *reinterpret_cast<StdVideoAV1FilmGrain *>( this ); 3370 } 3371 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FilmGrain3372 bool operator==( AV1FilmGrain const & rhs ) const VULKAN_HPP_NOEXCEPT 3373 { 3374 return ( flags == rhs.flags ) && ( grain_scaling_minus_8 == rhs.grain_scaling_minus_8 ) && ( ar_coeff_lag == rhs.ar_coeff_lag ) && 3375 ( ar_coeff_shift_minus_6 == rhs.ar_coeff_shift_minus_6 ) && ( grain_scale_shift == rhs.grain_scale_shift ) && ( grain_seed == rhs.grain_seed ) && 3376 ( film_grain_params_ref_idx == rhs.film_grain_params_ref_idx ) && ( num_y_points == rhs.num_y_points ) && 3377 ( point_y_value == rhs.point_y_value ) && ( point_y_scaling == rhs.point_y_scaling ) && ( num_cb_points == rhs.num_cb_points ) && 3378 ( point_cb_value == rhs.point_cb_value ) && ( point_cb_scaling == rhs.point_cb_scaling ) && ( num_cr_points == rhs.num_cr_points ) && 3379 ( point_cr_value == rhs.point_cr_value ) && ( point_cr_scaling == rhs.point_cr_scaling ) && 3380 ( ar_coeffs_y_plus_128 == rhs.ar_coeffs_y_plus_128 ) && ( ar_coeffs_cb_plus_128 == rhs.ar_coeffs_cb_plus_128 ) && 3381 ( ar_coeffs_cr_plus_128 == rhs.ar_coeffs_cr_plus_128 ) && ( cb_mult == rhs.cb_mult ) && ( cb_luma_mult == rhs.cb_luma_mult ) && 3382 ( cb_offset == rhs.cb_offset ) && ( cr_mult == rhs.cr_mult ) && ( cr_luma_mult == rhs.cr_luma_mult ) && ( cr_offset == rhs.cr_offset ); 3383 } 3384 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FilmGrain3385 bool operator!=( AV1FilmGrain const & rhs ) const VULKAN_HPP_NOEXCEPT 3386 { 3387 return !operator==( rhs ); 3388 } 3389 3390 public: 3391 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FilmGrainFlags flags = {}; 3392 uint8_t grain_scaling_minus_8 = {}; 3393 uint8_t ar_coeff_lag = {}; 3394 uint8_t ar_coeff_shift_minus_6 = {}; 3395 uint8_t grain_scale_shift = {}; 3396 uint16_t grain_seed = {}; 3397 uint8_t film_grain_params_ref_idx = {}; 3398 uint8_t num_y_points = {}; 3399 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_AV1_MAX_NUM_Y_POINTS> point_y_value = {}; 3400 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_AV1_MAX_NUM_Y_POINTS> point_y_scaling = {}; 3401 uint8_t num_cb_points = {}; 3402 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_AV1_MAX_NUM_CB_POINTS> point_cb_value = {}; 3403 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_AV1_MAX_NUM_CB_POINTS> point_cb_scaling = {}; 3404 uint8_t num_cr_points = {}; 3405 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_AV1_MAX_NUM_CR_POINTS> point_cr_value = {}; 3406 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_AV1_MAX_NUM_CR_POINTS> point_cr_scaling = {}; 3407 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<int8_t, STD_VIDEO_AV1_MAX_NUM_POS_LUMA> ar_coeffs_y_plus_128 = {}; 3408 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<int8_t, STD_VIDEO_AV1_MAX_NUM_POS_CHROMA> ar_coeffs_cb_plus_128 = {}; 3409 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<int8_t, STD_VIDEO_AV1_MAX_NUM_POS_CHROMA> ar_coeffs_cr_plus_128 = {}; 3410 uint8_t cb_mult = {}; 3411 uint8_t cb_luma_mult = {}; 3412 uint16_t cb_offset = {}; 3413 uint8_t cr_mult = {}; 3414 uint8_t cr_luma_mult = {}; 3415 uint16_t cr_offset = {}; 3416 }; 3417 3418 struct AV1SequenceHeaderFlags 3419 { 3420 using NativeType = StdVideoAV1SequenceHeaderFlags; 3421 operator StdVideoAV1SequenceHeaderFlags const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1SequenceHeaderFlags3422 operator StdVideoAV1SequenceHeaderFlags const &() const VULKAN_HPP_NOEXCEPT 3423 { 3424 return *reinterpret_cast<const StdVideoAV1SequenceHeaderFlags *>( this ); 3425 } 3426 operator StdVideoAV1SequenceHeaderFlags&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1SequenceHeaderFlags3427 operator StdVideoAV1SequenceHeaderFlags &() VULKAN_HPP_NOEXCEPT 3428 { 3429 return *reinterpret_cast<StdVideoAV1SequenceHeaderFlags *>( this ); 3430 } 3431 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1SequenceHeaderFlags3432 bool operator==( AV1SequenceHeaderFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 3433 { 3434 return ( still_picture == rhs.still_picture ) && ( reduced_still_picture_header == rhs.reduced_still_picture_header ) && 3435 ( use_128x128_superblock == rhs.use_128x128_superblock ) && ( enable_filter_intra == rhs.enable_filter_intra ) && 3436 ( enable_intra_edge_filter == rhs.enable_intra_edge_filter ) && ( enable_interintra_compound == rhs.enable_interintra_compound ) && 3437 ( enable_masked_compound == rhs.enable_masked_compound ) && ( enable_warped_motion == rhs.enable_warped_motion ) && 3438 ( enable_dual_filter == rhs.enable_dual_filter ) && ( enable_order_hint == rhs.enable_order_hint ) && 3439 ( enable_jnt_comp == rhs.enable_jnt_comp ) && ( enable_ref_frame_mvs == rhs.enable_ref_frame_mvs ) && 3440 ( frame_id_numbers_present_flag == rhs.frame_id_numbers_present_flag ) && ( enable_superres == rhs.enable_superres ) && 3441 ( enable_cdef == rhs.enable_cdef ) && ( enable_restoration == rhs.enable_restoration ) && 3442 ( film_grain_params_present == rhs.film_grain_params_present ) && ( timing_info_present_flag == rhs.timing_info_present_flag ) && 3443 ( initial_display_delay_present_flag == rhs.initial_display_delay_present_flag ) && ( reserved == rhs.reserved ); 3444 } 3445 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1SequenceHeaderFlags3446 bool operator!=( AV1SequenceHeaderFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 3447 { 3448 return !operator==( rhs ); 3449 } 3450 3451 public: 3452 uint32_t still_picture : 1; 3453 uint32_t reduced_still_picture_header : 1; 3454 uint32_t use_128x128_superblock : 1; 3455 uint32_t enable_filter_intra : 1; 3456 uint32_t enable_intra_edge_filter : 1; 3457 uint32_t enable_interintra_compound : 1; 3458 uint32_t enable_masked_compound : 1; 3459 uint32_t enable_warped_motion : 1; 3460 uint32_t enable_dual_filter : 1; 3461 uint32_t enable_order_hint : 1; 3462 uint32_t enable_jnt_comp : 1; 3463 uint32_t enable_ref_frame_mvs : 1; 3464 uint32_t frame_id_numbers_present_flag : 1; 3465 uint32_t enable_superres : 1; 3466 uint32_t enable_cdef : 1; 3467 uint32_t enable_restoration : 1; 3468 uint32_t film_grain_params_present : 1; 3469 uint32_t timing_info_present_flag : 1; 3470 uint32_t initial_display_delay_present_flag : 1; 3471 uint32_t reserved : 13; 3472 }; 3473 3474 struct AV1SequenceHeader 3475 { 3476 using NativeType = StdVideoAV1SequenceHeader; 3477 operator StdVideoAV1SequenceHeader const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1SequenceHeader3478 operator StdVideoAV1SequenceHeader const &() const VULKAN_HPP_NOEXCEPT 3479 { 3480 return *reinterpret_cast<const StdVideoAV1SequenceHeader *>( this ); 3481 } 3482 operator StdVideoAV1SequenceHeader&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1SequenceHeader3483 operator StdVideoAV1SequenceHeader &() VULKAN_HPP_NOEXCEPT 3484 { 3485 return *reinterpret_cast<StdVideoAV1SequenceHeader *>( this ); 3486 } 3487 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1SequenceHeader3488 bool operator==( AV1SequenceHeader const & rhs ) const VULKAN_HPP_NOEXCEPT 3489 { 3490 return ( flags == rhs.flags ) && ( seq_profile == rhs.seq_profile ) && ( frame_width_bits_minus_1 == rhs.frame_width_bits_minus_1 ) && 3491 ( frame_height_bits_minus_1 == rhs.frame_height_bits_minus_1 ) && ( max_frame_width_minus_1 == rhs.max_frame_width_minus_1 ) && 3492 ( max_frame_height_minus_1 == rhs.max_frame_height_minus_1 ) && ( delta_frame_id_length_minus_2 == rhs.delta_frame_id_length_minus_2 ) && 3493 ( additional_frame_id_length_minus_1 == rhs.additional_frame_id_length_minus_1 ) && ( order_hint_bits_minus_1 == rhs.order_hint_bits_minus_1 ) && 3494 ( seq_force_integer_mv == rhs.seq_force_integer_mv ) && ( seq_force_screen_content_tools == rhs.seq_force_screen_content_tools ) && 3495 ( reserved1 == rhs.reserved1 ) && ( pColorConfig == rhs.pColorConfig ) && ( pTimingInfo == rhs.pTimingInfo ); 3496 } 3497 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1SequenceHeader3498 bool operator!=( AV1SequenceHeader const & rhs ) const VULKAN_HPP_NOEXCEPT 3499 { 3500 return !operator==( rhs ); 3501 } 3502 3503 public: 3504 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1SequenceHeaderFlags flags = {}; 3505 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Profile seq_profile = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Profile::eMain; 3506 uint8_t frame_width_bits_minus_1 = {}; 3507 uint8_t frame_height_bits_minus_1 = {}; 3508 uint16_t max_frame_width_minus_1 = {}; 3509 uint16_t max_frame_height_minus_1 = {}; 3510 uint8_t delta_frame_id_length_minus_2 = {}; 3511 uint8_t additional_frame_id_length_minus_1 = {}; 3512 uint8_t order_hint_bits_minus_1 = {}; 3513 uint8_t seq_force_integer_mv = {}; 3514 uint8_t seq_force_screen_content_tools = {}; 3515 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, 5> reserved1 = {}; 3516 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ColorConfig * pColorConfig = {}; 3517 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TimingInfo * pTimingInfo = {}; 3518 }; 3519 3520 //=== vulkan_video_codec_av1std_decode === 3521 3522 struct DecodeAV1PictureInfoFlags 3523 { 3524 using NativeType = StdVideoDecodeAV1PictureInfoFlags; 3525 operator StdVideoDecodeAV1PictureInfoFlags const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeAV1PictureInfoFlags3526 operator StdVideoDecodeAV1PictureInfoFlags const &() const VULKAN_HPP_NOEXCEPT 3527 { 3528 return *reinterpret_cast<const StdVideoDecodeAV1PictureInfoFlags *>( this ); 3529 } 3530 operator StdVideoDecodeAV1PictureInfoFlags&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeAV1PictureInfoFlags3531 operator StdVideoDecodeAV1PictureInfoFlags &() VULKAN_HPP_NOEXCEPT 3532 { 3533 return *reinterpret_cast<StdVideoDecodeAV1PictureInfoFlags *>( this ); 3534 } 3535 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeAV1PictureInfoFlags3536 bool operator==( DecodeAV1PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 3537 { 3538 return ( error_resilient_mode == rhs.error_resilient_mode ) && ( disable_cdf_update == rhs.disable_cdf_update ) && 3539 ( use_superres == rhs.use_superres ) && ( render_and_frame_size_different == rhs.render_and_frame_size_different ) && 3540 ( allow_screen_content_tools == rhs.allow_screen_content_tools ) && ( is_filter_switchable == rhs.is_filter_switchable ) && 3541 ( force_integer_mv == rhs.force_integer_mv ) && ( frame_size_override_flag == rhs.frame_size_override_flag ) && 3542 ( buffer_removal_time_present_flag == rhs.buffer_removal_time_present_flag ) && ( allow_intrabc == rhs.allow_intrabc ) && 3543 ( frame_refs_short_signaling == rhs.frame_refs_short_signaling ) && ( allow_high_precision_mv == rhs.allow_high_precision_mv ) && 3544 ( is_motion_mode_switchable == rhs.is_motion_mode_switchable ) && ( use_ref_frame_mvs == rhs.use_ref_frame_mvs ) && 3545 ( disable_frame_end_update_cdf == rhs.disable_frame_end_update_cdf ) && ( allow_warped_motion == rhs.allow_warped_motion ) && 3546 ( reduced_tx_set == rhs.reduced_tx_set ) && ( reference_select == rhs.reference_select ) && ( skip_mode_present == rhs.skip_mode_present ) && 3547 ( delta_q_present == rhs.delta_q_present ) && ( delta_lf_present == rhs.delta_lf_present ) && ( delta_lf_multi == rhs.delta_lf_multi ) && 3548 ( segmentation_enabled == rhs.segmentation_enabled ) && ( segmentation_update_map == rhs.segmentation_update_map ) && 3549 ( segmentation_temporal_update == rhs.segmentation_temporal_update ) && ( segmentation_update_data == rhs.segmentation_update_data ) && 3550 ( UsesLr == rhs.UsesLr ) && ( usesChromaLr == rhs.usesChromaLr ) && ( apply_grain == rhs.apply_grain ) && ( reserved == rhs.reserved ); 3551 } 3552 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeAV1PictureInfoFlags3553 bool operator!=( DecodeAV1PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 3554 { 3555 return !operator==( rhs ); 3556 } 3557 3558 public: 3559 uint32_t error_resilient_mode : 1; 3560 uint32_t disable_cdf_update : 1; 3561 uint32_t use_superres : 1; 3562 uint32_t render_and_frame_size_different : 1; 3563 uint32_t allow_screen_content_tools : 1; 3564 uint32_t is_filter_switchable : 1; 3565 uint32_t force_integer_mv : 1; 3566 uint32_t frame_size_override_flag : 1; 3567 uint32_t buffer_removal_time_present_flag : 1; 3568 uint32_t allow_intrabc : 1; 3569 uint32_t frame_refs_short_signaling : 1; 3570 uint32_t allow_high_precision_mv : 1; 3571 uint32_t is_motion_mode_switchable : 1; 3572 uint32_t use_ref_frame_mvs : 1; 3573 uint32_t disable_frame_end_update_cdf : 1; 3574 uint32_t allow_warped_motion : 1; 3575 uint32_t reduced_tx_set : 1; 3576 uint32_t reference_select : 1; 3577 uint32_t skip_mode_present : 1; 3578 uint32_t delta_q_present : 1; 3579 uint32_t delta_lf_present : 1; 3580 uint32_t delta_lf_multi : 1; 3581 uint32_t segmentation_enabled : 1; 3582 uint32_t segmentation_update_map : 1; 3583 uint32_t segmentation_temporal_update : 1; 3584 uint32_t segmentation_update_data : 1; 3585 uint32_t UsesLr : 1; 3586 uint32_t usesChromaLr : 1; 3587 uint32_t apply_grain : 1; 3588 uint32_t reserved : 3; 3589 }; 3590 3591 struct DecodeAV1PictureInfo 3592 { 3593 using NativeType = StdVideoDecodeAV1PictureInfo; 3594 operator StdVideoDecodeAV1PictureInfo const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeAV1PictureInfo3595 operator StdVideoDecodeAV1PictureInfo const &() const VULKAN_HPP_NOEXCEPT 3596 { 3597 return *reinterpret_cast<const StdVideoDecodeAV1PictureInfo *>( this ); 3598 } 3599 operator StdVideoDecodeAV1PictureInfo&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeAV1PictureInfo3600 operator StdVideoDecodeAV1PictureInfo &() VULKAN_HPP_NOEXCEPT 3601 { 3602 return *reinterpret_cast<StdVideoDecodeAV1PictureInfo *>( this ); 3603 } 3604 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeAV1PictureInfo3605 bool operator==( DecodeAV1PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT 3606 { 3607 return ( flags == rhs.flags ) && ( frame_type == rhs.frame_type ) && ( current_frame_id == rhs.current_frame_id ) && ( OrderHint == rhs.OrderHint ) && 3608 ( primary_ref_frame == rhs.primary_ref_frame ) && ( refresh_frame_flags == rhs.refresh_frame_flags ) && ( reserved1 == rhs.reserved1 ) && 3609 ( interpolation_filter == rhs.interpolation_filter ) && ( TxMode == rhs.TxMode ) && ( delta_q_res == rhs.delta_q_res ) && 3610 ( delta_lf_res == rhs.delta_lf_res ) && ( SkipModeFrame == rhs.SkipModeFrame ) && ( coded_denom == rhs.coded_denom ) && 3611 ( reserved2 == rhs.reserved2 ) && ( OrderHints == rhs.OrderHints ) && ( expectedFrameId == rhs.expectedFrameId ) && 3612 ( pTileInfo == rhs.pTileInfo ) && ( pQuantization == rhs.pQuantization ) && ( pSegmentation == rhs.pSegmentation ) && 3613 ( pLoopFilter == rhs.pLoopFilter ) && ( pCDEF == rhs.pCDEF ) && ( pLoopRestoration == rhs.pLoopRestoration ) && 3614 ( pGlobalMotion == rhs.pGlobalMotion ) && ( pFilmGrain == rhs.pFilmGrain ); 3615 } 3616 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeAV1PictureInfo3617 bool operator!=( DecodeAV1PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT 3618 { 3619 return !operator==( rhs ); 3620 } 3621 3622 public: 3623 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeAV1PictureInfoFlags flags = {}; 3624 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FrameType frame_type = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FrameType::eKey; 3625 uint32_t current_frame_id = {}; 3626 uint8_t OrderHint = {}; 3627 uint8_t primary_ref_frame = {}; 3628 uint8_t refresh_frame_flags = {}; 3629 uint8_t reserved1 = {}; 3630 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1InterpolationFilter interpolation_filter = 3631 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1InterpolationFilter::eEighttap; 3632 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TxMode TxMode = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TxMode::eOnly4X4; 3633 uint8_t delta_q_res = {}; 3634 uint8_t delta_lf_res = {}; 3635 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_AV1_SKIP_MODE_FRAMES> SkipModeFrame = {}; 3636 uint8_t coded_denom = {}; 3637 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, 3> reserved2 = {}; 3638 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_AV1_NUM_REF_FRAMES> OrderHints = {}; 3639 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint32_t, STD_VIDEO_AV1_NUM_REF_FRAMES> expectedFrameId = {}; 3640 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TileInfo * pTileInfo = {}; 3641 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Quantization * pQuantization = {}; 3642 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Segmentation * pSegmentation = {}; 3643 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1LoopFilter * pLoopFilter = {}; 3644 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1CDEF * pCDEF = {}; 3645 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1LoopRestoration * pLoopRestoration = {}; 3646 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1GlobalMotion * pGlobalMotion = {}; 3647 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FilmGrain * pFilmGrain = {}; 3648 }; 3649 3650 struct DecodeAV1ReferenceInfoFlags 3651 { 3652 using NativeType = StdVideoDecodeAV1ReferenceInfoFlags; 3653 operator StdVideoDecodeAV1ReferenceInfoFlags const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeAV1ReferenceInfoFlags3654 operator StdVideoDecodeAV1ReferenceInfoFlags const &() const VULKAN_HPP_NOEXCEPT 3655 { 3656 return *reinterpret_cast<const StdVideoDecodeAV1ReferenceInfoFlags *>( this ); 3657 } 3658 operator StdVideoDecodeAV1ReferenceInfoFlags&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeAV1ReferenceInfoFlags3659 operator StdVideoDecodeAV1ReferenceInfoFlags &() VULKAN_HPP_NOEXCEPT 3660 { 3661 return *reinterpret_cast<StdVideoDecodeAV1ReferenceInfoFlags *>( this ); 3662 } 3663 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeAV1ReferenceInfoFlags3664 bool operator==( DecodeAV1ReferenceInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 3665 { 3666 return ( disable_frame_end_update_cdf == rhs.disable_frame_end_update_cdf ) && ( segmentation_enabled == rhs.segmentation_enabled ) && 3667 ( reserved == rhs.reserved ); 3668 } 3669 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeAV1ReferenceInfoFlags3670 bool operator!=( DecodeAV1ReferenceInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 3671 { 3672 return !operator==( rhs ); 3673 } 3674 3675 public: 3676 uint32_t disable_frame_end_update_cdf : 1; 3677 uint32_t segmentation_enabled : 1; 3678 uint32_t reserved : 30; 3679 }; 3680 3681 struct DecodeAV1ReferenceInfo 3682 { 3683 using NativeType = StdVideoDecodeAV1ReferenceInfo; 3684 operator StdVideoDecodeAV1ReferenceInfo const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeAV1ReferenceInfo3685 operator StdVideoDecodeAV1ReferenceInfo const &() const VULKAN_HPP_NOEXCEPT 3686 { 3687 return *reinterpret_cast<const StdVideoDecodeAV1ReferenceInfo *>( this ); 3688 } 3689 operator StdVideoDecodeAV1ReferenceInfo&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeAV1ReferenceInfo3690 operator StdVideoDecodeAV1ReferenceInfo &() VULKAN_HPP_NOEXCEPT 3691 { 3692 return *reinterpret_cast<StdVideoDecodeAV1ReferenceInfo *>( this ); 3693 } 3694 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeAV1ReferenceInfo3695 bool operator==( DecodeAV1ReferenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT 3696 { 3697 return ( flags == rhs.flags ) && ( frame_type == rhs.frame_type ) && ( RefFrameSignBias == rhs.RefFrameSignBias ) && ( OrderHint == rhs.OrderHint ) && 3698 ( SavedOrderHints == rhs.SavedOrderHints ); 3699 } 3700 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeAV1ReferenceInfo3701 bool operator!=( DecodeAV1ReferenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT 3702 { 3703 return !operator==( rhs ); 3704 } 3705 3706 public: 3707 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeAV1ReferenceInfoFlags flags = {}; 3708 uint8_t frame_type = {}; 3709 uint8_t RefFrameSignBias = {}; 3710 uint8_t OrderHint = {}; 3711 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_AV1_NUM_REF_FRAMES> SavedOrderHints = {}; 3712 }; 3713 3714 } // namespace VULKAN_HPP_VIDEO_NAMESPACE 3715 } // namespace VULKAN_HPP_NAMESPACE 3716 #endif 3717