1 // Copyright 2021-2023 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_h264std.h> 11 #include <vk_video/vulkan_video_codec_h264std_decode.h> 12 #include <vk_video/vulkan_video_codec_h264std_encode.h> 13 #include <vk_video/vulkan_video_codec_h265std.h> 14 #include <vk_video/vulkan_video_codec_h265std_decode.h> 15 #include <vk_video/vulkan_video_codec_h265std_encode.h> 16 #include <vk_video/vulkan_video_codecs_common.h> 17 #include <vulkan/vulkan.hpp> 18 19 #if !defined( VULKAN_HPP_VIDEO_NAMESPACE ) 20 # define VULKAN_HPP_VIDEO_NAMESPACE video 21 #endif 22 23 namespace VULKAN_HPP_NAMESPACE 24 { 25 namespace VULKAN_HPP_VIDEO_NAMESPACE 26 { 27 28 //============= 29 //=== ENUMs === 30 //============= 31 32 //=== vulkan_video_codec_h264std === 33 34 enum class H264ChromaFormatIdc 35 { 36 eMonochrome = STD_VIDEO_H264_CHROMA_FORMAT_IDC_MONOCHROME, 37 e420 = STD_VIDEO_H264_CHROMA_FORMAT_IDC_420, 38 e422 = STD_VIDEO_H264_CHROMA_FORMAT_IDC_422, 39 e444 = STD_VIDEO_H264_CHROMA_FORMAT_IDC_444, 40 eInvalid = STD_VIDEO_H264_CHROMA_FORMAT_IDC_INVALID 41 }; 42 43 enum class H264ProfileIdc 44 { 45 eBaseline = STD_VIDEO_H264_PROFILE_IDC_BASELINE, 46 eMain = STD_VIDEO_H264_PROFILE_IDC_MAIN, 47 eHigh = STD_VIDEO_H264_PROFILE_IDC_HIGH, 48 eHigh444Predictive = STD_VIDEO_H264_PROFILE_IDC_HIGH_444_PREDICTIVE, 49 eInvalid = STD_VIDEO_H264_PROFILE_IDC_INVALID 50 }; 51 52 enum class H264LevelIdc 53 { 54 e1_0 = STD_VIDEO_H264_LEVEL_IDC_1_0, 55 e1_1 = STD_VIDEO_H264_LEVEL_IDC_1_1, 56 e1_2 = STD_VIDEO_H264_LEVEL_IDC_1_2, 57 e1_3 = STD_VIDEO_H264_LEVEL_IDC_1_3, 58 e2_0 = STD_VIDEO_H264_LEVEL_IDC_2_0, 59 e2_1 = STD_VIDEO_H264_LEVEL_IDC_2_1, 60 e2_2 = STD_VIDEO_H264_LEVEL_IDC_2_2, 61 e3_0 = STD_VIDEO_H264_LEVEL_IDC_3_0, 62 e3_1 = STD_VIDEO_H264_LEVEL_IDC_3_1, 63 e3_2 = STD_VIDEO_H264_LEVEL_IDC_3_2, 64 e4_0 = STD_VIDEO_H264_LEVEL_IDC_4_0, 65 e4_1 = STD_VIDEO_H264_LEVEL_IDC_4_1, 66 e4_2 = STD_VIDEO_H264_LEVEL_IDC_4_2, 67 e5_0 = STD_VIDEO_H264_LEVEL_IDC_5_0, 68 e5_1 = STD_VIDEO_H264_LEVEL_IDC_5_1, 69 e5_2 = STD_VIDEO_H264_LEVEL_IDC_5_2, 70 e6_0 = STD_VIDEO_H264_LEVEL_IDC_6_0, 71 e6_1 = STD_VIDEO_H264_LEVEL_IDC_6_1, 72 e6_2 = STD_VIDEO_H264_LEVEL_IDC_6_2, 73 eInvalid = STD_VIDEO_H264_LEVEL_IDC_INVALID 74 }; 75 76 enum class H264PocType 77 { 78 e0 = STD_VIDEO_H264_POC_TYPE_0, 79 e1 = STD_VIDEO_H264_POC_TYPE_1, 80 e2 = STD_VIDEO_H264_POC_TYPE_2, 81 eInvalid = STD_VIDEO_H264_POC_TYPE_INVALID 82 }; 83 84 enum class H264AspectRatioIdc 85 { 86 eUnspecified = STD_VIDEO_H264_ASPECT_RATIO_IDC_UNSPECIFIED, 87 eSquare = STD_VIDEO_H264_ASPECT_RATIO_IDC_SQUARE, 88 e12_11 = STD_VIDEO_H264_ASPECT_RATIO_IDC_12_11, 89 e10_11 = STD_VIDEO_H264_ASPECT_RATIO_IDC_10_11, 90 e16_11 = STD_VIDEO_H264_ASPECT_RATIO_IDC_16_11, 91 e40_33 = STD_VIDEO_H264_ASPECT_RATIO_IDC_40_33, 92 e24_11 = STD_VIDEO_H264_ASPECT_RATIO_IDC_24_11, 93 e20_11 = STD_VIDEO_H264_ASPECT_RATIO_IDC_20_11, 94 e32_11 = STD_VIDEO_H264_ASPECT_RATIO_IDC_32_11, 95 e80_33 = STD_VIDEO_H264_ASPECT_RATIO_IDC_80_33, 96 e18_11 = STD_VIDEO_H264_ASPECT_RATIO_IDC_18_11, 97 e15_11 = STD_VIDEO_H264_ASPECT_RATIO_IDC_15_11, 98 e64_33 = STD_VIDEO_H264_ASPECT_RATIO_IDC_64_33, 99 e160_99 = STD_VIDEO_H264_ASPECT_RATIO_IDC_160_99, 100 e4_3 = STD_VIDEO_H264_ASPECT_RATIO_IDC_4_3, 101 e3_2 = STD_VIDEO_H264_ASPECT_RATIO_IDC_3_2, 102 e2_1 = STD_VIDEO_H264_ASPECT_RATIO_IDC_2_1, 103 eExtendedSar = STD_VIDEO_H264_ASPECT_RATIO_IDC_EXTENDED_SAR, 104 eInvalid = STD_VIDEO_H264_ASPECT_RATIO_IDC_INVALID 105 }; 106 107 enum class H264WeightedBipredIdc 108 { 109 eDefault = STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_DEFAULT, 110 eExplicit = STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_EXPLICIT, 111 eImplicit = STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_IMPLICIT, 112 eInvalid = STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_INVALID 113 }; 114 115 enum class H264ModificationOfPicNumsIdc 116 { 117 eShortTermSubtract = STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_SHORT_TERM_SUBTRACT, 118 eShortTermAdd = STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_SHORT_TERM_ADD, 119 eLongTerm = STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_LONG_TERM, 120 eEnd = STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_END, 121 eInvalid = STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_INVALID 122 }; 123 124 enum class H264MemMgmtControlOp 125 { 126 eEnd = STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_END, 127 eUnmarkShortTerm = STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_SHORT_TERM, 128 eUnmarkLongTerm = STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_LONG_TERM, 129 eMarkLongTerm = STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_MARK_LONG_TERM, 130 eSetMaxLongTermIndex = STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_SET_MAX_LONG_TERM_INDEX, 131 eUnmarkAll = STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_ALL, 132 eMarkCurrentAsLongTerm = STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_MARK_CURRENT_AS_LONG_TERM, 133 eInvalid = STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_INVALID 134 }; 135 136 enum class H264CabacInitIdc 137 { 138 e0 = STD_VIDEO_H264_CABAC_INIT_IDC_0, 139 e1 = STD_VIDEO_H264_CABAC_INIT_IDC_1, 140 e2 = STD_VIDEO_H264_CABAC_INIT_IDC_2, 141 eInvalid = STD_VIDEO_H264_CABAC_INIT_IDC_INVALID 142 }; 143 144 enum class H264DisableDeblockingFilterIdc 145 { 146 eDisabled = STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_DISABLED, 147 eEnabled = STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_ENABLED, 148 ePartial = STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_PARTIAL, 149 eInvalid = STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_INVALID 150 }; 151 152 enum class H264SliceType 153 { 154 eP = STD_VIDEO_H264_SLICE_TYPE_P, 155 eB = STD_VIDEO_H264_SLICE_TYPE_B, 156 eI = STD_VIDEO_H264_SLICE_TYPE_I, 157 eInvalid = STD_VIDEO_H264_SLICE_TYPE_INVALID 158 }; 159 160 enum class H264PictureType 161 { 162 eP = STD_VIDEO_H264_PICTURE_TYPE_P, 163 eB = STD_VIDEO_H264_PICTURE_TYPE_B, 164 eI = STD_VIDEO_H264_PICTURE_TYPE_I, 165 eIdr = STD_VIDEO_H264_PICTURE_TYPE_IDR, 166 eInvalid = STD_VIDEO_H264_PICTURE_TYPE_INVALID 167 }; 168 169 enum class H264NonVclNaluType 170 { 171 eSps = STD_VIDEO_H264_NON_VCL_NALU_TYPE_SPS, 172 ePps = STD_VIDEO_H264_NON_VCL_NALU_TYPE_PPS, 173 eAud = STD_VIDEO_H264_NON_VCL_NALU_TYPE_AUD, 174 ePrefix = STD_VIDEO_H264_NON_VCL_NALU_TYPE_PREFIX, 175 eEndOfSequence = STD_VIDEO_H264_NON_VCL_NALU_TYPE_END_OF_SEQUENCE, 176 eEndOfStream = STD_VIDEO_H264_NON_VCL_NALU_TYPE_END_OF_STREAM, 177 ePrecoded = STD_VIDEO_H264_NON_VCL_NALU_TYPE_PRECODED, 178 eInvalid = STD_VIDEO_H264_NON_VCL_NALU_TYPE_INVALID 179 }; 180 181 //=== vulkan_video_codec_h264std_decode === 182 183 enum class DecodeH264FieldOrderCount 184 { 185 eTop = STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_TOP, 186 eBottom = STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_BOTTOM, 187 eInvalid = STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_INVALID 188 }; 189 190 //=== vulkan_video_codec_h265std === 191 192 enum class H265ChromaFormatIdc 193 { 194 eMonochrome = STD_VIDEO_H265_CHROMA_FORMAT_IDC_MONOCHROME, 195 e420 = STD_VIDEO_H265_CHROMA_FORMAT_IDC_420, 196 e422 = STD_VIDEO_H265_CHROMA_FORMAT_IDC_422, 197 e444 = STD_VIDEO_H265_CHROMA_FORMAT_IDC_444, 198 eInvalid = STD_VIDEO_H265_CHROMA_FORMAT_IDC_INVALID 199 }; 200 201 enum class H265ProfileIdc 202 { 203 eMain = STD_VIDEO_H265_PROFILE_IDC_MAIN, 204 eMain10 = STD_VIDEO_H265_PROFILE_IDC_MAIN_10, 205 eMainStillPicture = STD_VIDEO_H265_PROFILE_IDC_MAIN_STILL_PICTURE, 206 eFormatRangeExtensions = STD_VIDEO_H265_PROFILE_IDC_FORMAT_RANGE_EXTENSIONS, 207 eSccExtensions = STD_VIDEO_H265_PROFILE_IDC_SCC_EXTENSIONS, 208 eInvalid = STD_VIDEO_H265_PROFILE_IDC_INVALID 209 }; 210 211 enum class H265LevelIdc 212 { 213 e1_0 = STD_VIDEO_H265_LEVEL_IDC_1_0, 214 e2_0 = STD_VIDEO_H265_LEVEL_IDC_2_0, 215 e2_1 = STD_VIDEO_H265_LEVEL_IDC_2_1, 216 e3_0 = STD_VIDEO_H265_LEVEL_IDC_3_0, 217 e3_1 = STD_VIDEO_H265_LEVEL_IDC_3_1, 218 e4_0 = STD_VIDEO_H265_LEVEL_IDC_4_0, 219 e4_1 = STD_VIDEO_H265_LEVEL_IDC_4_1, 220 e5_0 = STD_VIDEO_H265_LEVEL_IDC_5_0, 221 e5_1 = STD_VIDEO_H265_LEVEL_IDC_5_1, 222 e5_2 = STD_VIDEO_H265_LEVEL_IDC_5_2, 223 e6_0 = STD_VIDEO_H265_LEVEL_IDC_6_0, 224 e6_1 = STD_VIDEO_H265_LEVEL_IDC_6_1, 225 e6_2 = STD_VIDEO_H265_LEVEL_IDC_6_2, 226 eInvalid = STD_VIDEO_H265_LEVEL_IDC_INVALID 227 }; 228 229 enum class H265SliceType 230 { 231 eB = STD_VIDEO_H265_SLICE_TYPE_B, 232 eP = STD_VIDEO_H265_SLICE_TYPE_P, 233 eI = STD_VIDEO_H265_SLICE_TYPE_I, 234 eInvalid = STD_VIDEO_H265_SLICE_TYPE_INVALID 235 }; 236 237 enum class H265PictureType 238 { 239 eP = STD_VIDEO_H265_PICTURE_TYPE_P, 240 eB = STD_VIDEO_H265_PICTURE_TYPE_B, 241 eI = STD_VIDEO_H265_PICTURE_TYPE_I, 242 eIdr = STD_VIDEO_H265_PICTURE_TYPE_IDR, 243 eInvalid = STD_VIDEO_H265_PICTURE_TYPE_INVALID 244 }; 245 246 enum class H265AspectRatioIdc 247 { 248 eUnspecified = STD_VIDEO_H265_ASPECT_RATIO_IDC_UNSPECIFIED, 249 eSquare = STD_VIDEO_H265_ASPECT_RATIO_IDC_SQUARE, 250 e12_11 = STD_VIDEO_H265_ASPECT_RATIO_IDC_12_11, 251 e10_11 = STD_VIDEO_H265_ASPECT_RATIO_IDC_10_11, 252 e16_11 = STD_VIDEO_H265_ASPECT_RATIO_IDC_16_11, 253 e40_33 = STD_VIDEO_H265_ASPECT_RATIO_IDC_40_33, 254 e24_11 = STD_VIDEO_H265_ASPECT_RATIO_IDC_24_11, 255 e20_11 = STD_VIDEO_H265_ASPECT_RATIO_IDC_20_11, 256 e32_11 = STD_VIDEO_H265_ASPECT_RATIO_IDC_32_11, 257 e80_33 = STD_VIDEO_H265_ASPECT_RATIO_IDC_80_33, 258 e18_11 = STD_VIDEO_H265_ASPECT_RATIO_IDC_18_11, 259 e15_11 = STD_VIDEO_H265_ASPECT_RATIO_IDC_15_11, 260 e64_33 = STD_VIDEO_H265_ASPECT_RATIO_IDC_64_33, 261 e160_99 = STD_VIDEO_H265_ASPECT_RATIO_IDC_160_99, 262 e4_3 = STD_VIDEO_H265_ASPECT_RATIO_IDC_4_3, 263 e3_2 = STD_VIDEO_H265_ASPECT_RATIO_IDC_3_2, 264 e2_1 = STD_VIDEO_H265_ASPECT_RATIO_IDC_2_1, 265 eExtendedSar = STD_VIDEO_H265_ASPECT_RATIO_IDC_EXTENDED_SAR, 266 eInvalid = STD_VIDEO_H265_ASPECT_RATIO_IDC_INVALID 267 }; 268 269 //=============== 270 //=== STRUCTS === 271 //=============== 272 273 //=== vulkan_video_codec_h264std === 274 275 struct H264SpsVuiFlags 276 { 277 using NativeType = StdVideoH264SpsVuiFlags; 278 operator StdVideoH264SpsVuiFlags const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SpsVuiFlags279 operator StdVideoH264SpsVuiFlags const &() const VULKAN_HPP_NOEXCEPT 280 { 281 return *reinterpret_cast<const StdVideoH264SpsVuiFlags *>( this ); 282 } 283 operator StdVideoH264SpsVuiFlags&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SpsVuiFlags284 operator StdVideoH264SpsVuiFlags &() VULKAN_HPP_NOEXCEPT 285 { 286 return *reinterpret_cast<StdVideoH264SpsVuiFlags *>( this ); 287 } 288 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SpsVuiFlags289 bool operator==( H264SpsVuiFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 290 { 291 return ( aspect_ratio_info_present_flag == rhs.aspect_ratio_info_present_flag ) && ( overscan_info_present_flag == rhs.overscan_info_present_flag ) && 292 ( overscan_appropriate_flag == rhs.overscan_appropriate_flag ) && ( video_signal_type_present_flag == rhs.video_signal_type_present_flag ) && 293 ( video_full_range_flag == rhs.video_full_range_flag ) && ( color_description_present_flag == rhs.color_description_present_flag ) && 294 ( chroma_loc_info_present_flag == rhs.chroma_loc_info_present_flag ) && ( timing_info_present_flag == rhs.timing_info_present_flag ) && 295 ( fixed_frame_rate_flag == rhs.fixed_frame_rate_flag ) && ( bitstream_restriction_flag == rhs.bitstream_restriction_flag ) && 296 ( nal_hrd_parameters_present_flag == rhs.nal_hrd_parameters_present_flag ) && 297 ( vcl_hrd_parameters_present_flag == rhs.vcl_hrd_parameters_present_flag ); 298 } 299 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SpsVuiFlags300 bool operator!=( H264SpsVuiFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 301 { 302 return !operator==( rhs ); 303 } 304 305 public: 306 uint32_t aspect_ratio_info_present_flag : 1; 307 uint32_t overscan_info_present_flag : 1; 308 uint32_t overscan_appropriate_flag : 1; 309 uint32_t video_signal_type_present_flag : 1; 310 uint32_t video_full_range_flag : 1; 311 uint32_t color_description_present_flag : 1; 312 uint32_t chroma_loc_info_present_flag : 1; 313 uint32_t timing_info_present_flag : 1; 314 uint32_t fixed_frame_rate_flag : 1; 315 uint32_t bitstream_restriction_flag : 1; 316 uint32_t nal_hrd_parameters_present_flag : 1; 317 uint32_t vcl_hrd_parameters_present_flag : 1; 318 }; 319 320 struct H264HrdParameters 321 { 322 using NativeType = StdVideoH264HrdParameters; 323 operator StdVideoH264HrdParameters const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264HrdParameters324 operator StdVideoH264HrdParameters const &() const VULKAN_HPP_NOEXCEPT 325 { 326 return *reinterpret_cast<const StdVideoH264HrdParameters *>( this ); 327 } 328 operator StdVideoH264HrdParameters&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264HrdParameters329 operator StdVideoH264HrdParameters &() VULKAN_HPP_NOEXCEPT 330 { 331 return *reinterpret_cast<StdVideoH264HrdParameters *>( this ); 332 } 333 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264HrdParameters334 bool operator==( H264HrdParameters const & rhs ) const VULKAN_HPP_NOEXCEPT 335 { 336 return ( cpb_cnt_minus1 == rhs.cpb_cnt_minus1 ) && ( bit_rate_scale == rhs.bit_rate_scale ) && ( cpb_size_scale == rhs.cpb_size_scale ) && 337 ( reserved1 == rhs.reserved1 ) && ( bit_rate_value_minus1 == rhs.bit_rate_value_minus1 ) && 338 ( cpb_size_value_minus1 == rhs.cpb_size_value_minus1 ) && ( cbr_flag == rhs.cbr_flag ) && 339 ( initial_cpb_removal_delay_length_minus1 == rhs.initial_cpb_removal_delay_length_minus1 ) && 340 ( cpb_removal_delay_length_minus1 == rhs.cpb_removal_delay_length_minus1 ) && 341 ( dpb_output_delay_length_minus1 == rhs.dpb_output_delay_length_minus1 ) && ( time_offset_length == rhs.time_offset_length ); 342 } 343 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264HrdParameters344 bool operator!=( H264HrdParameters const & rhs ) const VULKAN_HPP_NOEXCEPT 345 { 346 return !operator==( rhs ); 347 } 348 349 public: 350 uint8_t cpb_cnt_minus1 = {}; 351 uint8_t bit_rate_scale = {}; 352 uint8_t cpb_size_scale = {}; 353 uint8_t reserved1 = {}; 354 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint32_t, STD_VIDEO_H264_CPB_CNT_LIST_SIZE> bit_rate_value_minus1 = {}; 355 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint32_t, STD_VIDEO_H264_CPB_CNT_LIST_SIZE> cpb_size_value_minus1 = {}; 356 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_H264_CPB_CNT_LIST_SIZE> cbr_flag = {}; 357 uint32_t initial_cpb_removal_delay_length_minus1 = {}; 358 uint32_t cpb_removal_delay_length_minus1 = {}; 359 uint32_t dpb_output_delay_length_minus1 = {}; 360 uint32_t time_offset_length = {}; 361 }; 362 363 struct H264SequenceParameterSetVui 364 { 365 using NativeType = StdVideoH264SequenceParameterSetVui; 366 operator StdVideoH264SequenceParameterSetVui const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SequenceParameterSetVui367 operator StdVideoH264SequenceParameterSetVui const &() const VULKAN_HPP_NOEXCEPT 368 { 369 return *reinterpret_cast<const StdVideoH264SequenceParameterSetVui *>( this ); 370 } 371 operator StdVideoH264SequenceParameterSetVui&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SequenceParameterSetVui372 operator StdVideoH264SequenceParameterSetVui &() VULKAN_HPP_NOEXCEPT 373 { 374 return *reinterpret_cast<StdVideoH264SequenceParameterSetVui *>( this ); 375 } 376 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SequenceParameterSetVui377 bool operator==( H264SequenceParameterSetVui const & rhs ) const VULKAN_HPP_NOEXCEPT 378 { 379 return ( flags == rhs.flags ) && ( aspect_ratio_idc == rhs.aspect_ratio_idc ) && ( sar_width == rhs.sar_width ) && ( sar_height == rhs.sar_height ) && 380 ( video_format == rhs.video_format ) && ( colour_primaries == rhs.colour_primaries ) && 381 ( transfer_characteristics == rhs.transfer_characteristics ) && ( matrix_coefficients == rhs.matrix_coefficients ) && 382 ( num_units_in_tick == rhs.num_units_in_tick ) && ( time_scale == rhs.time_scale ) && ( max_num_reorder_frames == rhs.max_num_reorder_frames ) && 383 ( max_dec_frame_buffering == rhs.max_dec_frame_buffering ) && ( chroma_sample_loc_type_top_field == rhs.chroma_sample_loc_type_top_field ) && 384 ( chroma_sample_loc_type_bottom_field == rhs.chroma_sample_loc_type_bottom_field ) && ( reserved1 == rhs.reserved1 ) && 385 ( pHrdParameters == rhs.pHrdParameters ); 386 } 387 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SequenceParameterSetVui388 bool operator!=( H264SequenceParameterSetVui const & rhs ) const VULKAN_HPP_NOEXCEPT 389 { 390 return !operator==( rhs ); 391 } 392 393 public: 394 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SpsVuiFlags flags = {}; 395 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264AspectRatioIdc aspect_ratio_idc = 396 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264AspectRatioIdc::eUnspecified; 397 uint16_t sar_width = {}; 398 uint16_t sar_height = {}; 399 uint8_t video_format = {}; 400 uint8_t colour_primaries = {}; 401 uint8_t transfer_characteristics = {}; 402 uint8_t matrix_coefficients = {}; 403 uint32_t num_units_in_tick = {}; 404 uint32_t time_scale = {}; 405 uint8_t max_num_reorder_frames = {}; 406 uint8_t max_dec_frame_buffering = {}; 407 uint8_t chroma_sample_loc_type_top_field = {}; 408 uint8_t chroma_sample_loc_type_bottom_field = {}; 409 uint32_t reserved1 = {}; 410 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264HrdParameters * pHrdParameters = {}; 411 }; 412 413 struct H264SpsFlags 414 { 415 using NativeType = StdVideoH264SpsFlags; 416 operator StdVideoH264SpsFlags const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SpsFlags417 operator StdVideoH264SpsFlags const &() const VULKAN_HPP_NOEXCEPT 418 { 419 return *reinterpret_cast<const StdVideoH264SpsFlags *>( this ); 420 } 421 operator StdVideoH264SpsFlags&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SpsFlags422 operator StdVideoH264SpsFlags &() VULKAN_HPP_NOEXCEPT 423 { 424 return *reinterpret_cast<StdVideoH264SpsFlags *>( this ); 425 } 426 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SpsFlags427 bool operator==( H264SpsFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 428 { 429 return ( constraint_set0_flag == rhs.constraint_set0_flag ) && ( constraint_set1_flag == rhs.constraint_set1_flag ) && 430 ( constraint_set2_flag == rhs.constraint_set2_flag ) && ( constraint_set3_flag == rhs.constraint_set3_flag ) && 431 ( constraint_set4_flag == rhs.constraint_set4_flag ) && ( constraint_set5_flag == rhs.constraint_set5_flag ) && 432 ( direct_8x8_inference_flag == rhs.direct_8x8_inference_flag ) && ( mb_adaptive_frame_field_flag == rhs.mb_adaptive_frame_field_flag ) && 433 ( frame_mbs_only_flag == rhs.frame_mbs_only_flag ) && ( delta_pic_order_always_zero_flag == rhs.delta_pic_order_always_zero_flag ) && 434 ( separate_colour_plane_flag == rhs.separate_colour_plane_flag ) && 435 ( gaps_in_frame_num_value_allowed_flag == rhs.gaps_in_frame_num_value_allowed_flag ) && 436 ( qpprime_y_zero_transform_bypass_flag == rhs.qpprime_y_zero_transform_bypass_flag ) && ( frame_cropping_flag == rhs.frame_cropping_flag ) && 437 ( seq_scaling_matrix_present_flag == rhs.seq_scaling_matrix_present_flag ) && ( vui_parameters_present_flag == rhs.vui_parameters_present_flag ); 438 } 439 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SpsFlags440 bool operator!=( H264SpsFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 441 { 442 return !operator==( rhs ); 443 } 444 445 public: 446 uint32_t constraint_set0_flag : 1; 447 uint32_t constraint_set1_flag : 1; 448 uint32_t constraint_set2_flag : 1; 449 uint32_t constraint_set3_flag : 1; 450 uint32_t constraint_set4_flag : 1; 451 uint32_t constraint_set5_flag : 1; 452 uint32_t direct_8x8_inference_flag : 1; 453 uint32_t mb_adaptive_frame_field_flag : 1; 454 uint32_t frame_mbs_only_flag : 1; 455 uint32_t delta_pic_order_always_zero_flag : 1; 456 uint32_t separate_colour_plane_flag : 1; 457 uint32_t gaps_in_frame_num_value_allowed_flag : 1; 458 uint32_t qpprime_y_zero_transform_bypass_flag : 1; 459 uint32_t frame_cropping_flag : 1; 460 uint32_t seq_scaling_matrix_present_flag : 1; 461 uint32_t vui_parameters_present_flag : 1; 462 }; 463 464 struct H264ScalingLists 465 { 466 using NativeType = StdVideoH264ScalingLists; 467 operator StdVideoH264ScalingLists const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ScalingLists468 operator StdVideoH264ScalingLists const &() const VULKAN_HPP_NOEXCEPT 469 { 470 return *reinterpret_cast<const StdVideoH264ScalingLists *>( this ); 471 } 472 operator StdVideoH264ScalingLists&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ScalingLists473 operator StdVideoH264ScalingLists &() VULKAN_HPP_NOEXCEPT 474 { 475 return *reinterpret_cast<StdVideoH264ScalingLists *>( this ); 476 } 477 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ScalingLists478 bool operator==( H264ScalingLists const & rhs ) const VULKAN_HPP_NOEXCEPT 479 { 480 return ( scaling_list_present_mask == rhs.scaling_list_present_mask ) && ( use_default_scaling_matrix_mask == rhs.use_default_scaling_matrix_mask ) && 481 ( ScalingList4x4 == rhs.ScalingList4x4 ) && ( ScalingList8x8 == rhs.ScalingList8x8 ); 482 } 483 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ScalingLists484 bool operator!=( H264ScalingLists const & rhs ) const VULKAN_HPP_NOEXCEPT 485 { 486 return !operator==( rhs ); 487 } 488 489 public: 490 uint16_t scaling_list_present_mask = {}; 491 uint16_t use_default_scaling_matrix_mask = {}; 492 VULKAN_HPP_NAMESPACE::ArrayWrapper2D<uint8_t, STD_VIDEO_H264_SCALING_LIST_4X4_NUM_LISTS, STD_VIDEO_H264_SCALING_LIST_4X4_NUM_ELEMENTS> 493 ScalingList4x4 = {}; 494 VULKAN_HPP_NAMESPACE::ArrayWrapper2D<uint8_t, STD_VIDEO_H264_SCALING_LIST_8X8_NUM_LISTS, STD_VIDEO_H264_SCALING_LIST_8X8_NUM_ELEMENTS> 495 ScalingList8x8 = {}; 496 }; 497 498 struct H264SequenceParameterSet 499 { 500 using NativeType = StdVideoH264SequenceParameterSet; 501 operator StdVideoH264SequenceParameterSet const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SequenceParameterSet502 operator StdVideoH264SequenceParameterSet const &() const VULKAN_HPP_NOEXCEPT 503 { 504 return *reinterpret_cast<const StdVideoH264SequenceParameterSet *>( this ); 505 } 506 operator StdVideoH264SequenceParameterSet&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SequenceParameterSet507 operator StdVideoH264SequenceParameterSet &() VULKAN_HPP_NOEXCEPT 508 { 509 return *reinterpret_cast<StdVideoH264SequenceParameterSet *>( this ); 510 } 511 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SequenceParameterSet512 bool operator==( H264SequenceParameterSet const & rhs ) const VULKAN_HPP_NOEXCEPT 513 { 514 return ( flags == rhs.flags ) && ( profile_idc == rhs.profile_idc ) && ( level_idc == rhs.level_idc ) && 515 ( chroma_format_idc == rhs.chroma_format_idc ) && ( seq_parameter_set_id == rhs.seq_parameter_set_id ) && 516 ( bit_depth_luma_minus8 == rhs.bit_depth_luma_minus8 ) && ( bit_depth_chroma_minus8 == rhs.bit_depth_chroma_minus8 ) && 517 ( log2_max_frame_num_minus4 == rhs.log2_max_frame_num_minus4 ) && ( pic_order_cnt_type == rhs.pic_order_cnt_type ) && 518 ( offset_for_non_ref_pic == rhs.offset_for_non_ref_pic ) && ( offset_for_top_to_bottom_field == rhs.offset_for_top_to_bottom_field ) && 519 ( log2_max_pic_order_cnt_lsb_minus4 == rhs.log2_max_pic_order_cnt_lsb_minus4 ) && 520 ( 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 ) && 521 ( reserved1 == rhs.reserved1 ) && ( pic_width_in_mbs_minus1 == rhs.pic_width_in_mbs_minus1 ) && 522 ( pic_height_in_map_units_minus1 == rhs.pic_height_in_map_units_minus1 ) && ( frame_crop_left_offset == rhs.frame_crop_left_offset ) && 523 ( frame_crop_right_offset == rhs.frame_crop_right_offset ) && ( frame_crop_top_offset == rhs.frame_crop_top_offset ) && 524 ( frame_crop_bottom_offset == rhs.frame_crop_bottom_offset ) && ( reserved2 == rhs.reserved2 ) && 525 ( pOffsetForRefFrame == rhs.pOffsetForRefFrame ) && ( pScalingLists == rhs.pScalingLists ) && 526 ( pSequenceParameterSetVui == rhs.pSequenceParameterSetVui ); 527 } 528 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SequenceParameterSet529 bool operator!=( H264SequenceParameterSet const & rhs ) const VULKAN_HPP_NOEXCEPT 530 { 531 return !operator==( rhs ); 532 } 533 534 public: 535 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SpsFlags flags = {}; 536 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ProfileIdc profile_idc = 537 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ProfileIdc::eBaseline; 538 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264LevelIdc level_idc = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264LevelIdc::e1_0; 539 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ChromaFormatIdc chroma_format_idc = 540 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ChromaFormatIdc::eMonochrome; 541 uint8_t seq_parameter_set_id = {}; 542 uint8_t bit_depth_luma_minus8 = {}; 543 uint8_t bit_depth_chroma_minus8 = {}; 544 uint8_t log2_max_frame_num_minus4 = {}; 545 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PocType pic_order_cnt_type = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PocType::e0; 546 int32_t offset_for_non_ref_pic = {}; 547 int32_t offset_for_top_to_bottom_field = {}; 548 uint8_t log2_max_pic_order_cnt_lsb_minus4 = {}; 549 uint8_t num_ref_frames_in_pic_order_cnt_cycle = {}; 550 uint8_t max_num_ref_frames = {}; 551 uint8_t reserved1 = {}; 552 uint32_t pic_width_in_mbs_minus1 = {}; 553 uint32_t pic_height_in_map_units_minus1 = {}; 554 uint32_t frame_crop_left_offset = {}; 555 uint32_t frame_crop_right_offset = {}; 556 uint32_t frame_crop_top_offset = {}; 557 uint32_t frame_crop_bottom_offset = {}; 558 uint32_t reserved2 = {}; 559 const int32_t * pOffsetForRefFrame = {}; 560 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ScalingLists * pScalingLists = {}; 561 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SequenceParameterSetVui * pSequenceParameterSetVui = {}; 562 }; 563 564 struct H264PpsFlags 565 { 566 using NativeType = StdVideoH264PpsFlags; 567 operator StdVideoH264PpsFlags const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PpsFlags568 operator StdVideoH264PpsFlags const &() const VULKAN_HPP_NOEXCEPT 569 { 570 return *reinterpret_cast<const StdVideoH264PpsFlags *>( this ); 571 } 572 operator StdVideoH264PpsFlags&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PpsFlags573 operator StdVideoH264PpsFlags &() VULKAN_HPP_NOEXCEPT 574 { 575 return *reinterpret_cast<StdVideoH264PpsFlags *>( this ); 576 } 577 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PpsFlags578 bool operator==( H264PpsFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 579 { 580 return ( transform_8x8_mode_flag == rhs.transform_8x8_mode_flag ) && ( redundant_pic_cnt_present_flag == rhs.redundant_pic_cnt_present_flag ) && 581 ( constrained_intra_pred_flag == rhs.constrained_intra_pred_flag ) && 582 ( deblocking_filter_control_present_flag == rhs.deblocking_filter_control_present_flag ) && ( weighted_pred_flag == rhs.weighted_pred_flag ) && 583 ( bottom_field_pic_order_in_frame_present_flag == rhs.bottom_field_pic_order_in_frame_present_flag ) && 584 ( entropy_coding_mode_flag == rhs.entropy_coding_mode_flag ) && ( pic_scaling_matrix_present_flag == rhs.pic_scaling_matrix_present_flag ); 585 } 586 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PpsFlags587 bool operator!=( H264PpsFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 588 { 589 return !operator==( rhs ); 590 } 591 592 public: 593 uint32_t transform_8x8_mode_flag : 1; 594 uint32_t redundant_pic_cnt_present_flag : 1; 595 uint32_t constrained_intra_pred_flag : 1; 596 uint32_t deblocking_filter_control_present_flag : 1; 597 uint32_t weighted_pred_flag : 1; 598 uint32_t bottom_field_pic_order_in_frame_present_flag : 1; 599 uint32_t entropy_coding_mode_flag : 1; 600 uint32_t pic_scaling_matrix_present_flag : 1; 601 }; 602 603 struct H264PictureParameterSet 604 { 605 using NativeType = StdVideoH264PictureParameterSet; 606 operator StdVideoH264PictureParameterSet const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PictureParameterSet607 operator StdVideoH264PictureParameterSet const &() const VULKAN_HPP_NOEXCEPT 608 { 609 return *reinterpret_cast<const StdVideoH264PictureParameterSet *>( this ); 610 } 611 operator StdVideoH264PictureParameterSet&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PictureParameterSet612 operator StdVideoH264PictureParameterSet &() VULKAN_HPP_NOEXCEPT 613 { 614 return *reinterpret_cast<StdVideoH264PictureParameterSet *>( this ); 615 } 616 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PictureParameterSet617 bool operator==( H264PictureParameterSet const & rhs ) const VULKAN_HPP_NOEXCEPT 618 { 619 return ( flags == rhs.flags ) && ( seq_parameter_set_id == rhs.seq_parameter_set_id ) && ( pic_parameter_set_id == rhs.pic_parameter_set_id ) && 620 ( num_ref_idx_l0_default_active_minus1 == rhs.num_ref_idx_l0_default_active_minus1 ) && 621 ( num_ref_idx_l1_default_active_minus1 == rhs.num_ref_idx_l1_default_active_minus1 ) && ( weighted_bipred_idc == rhs.weighted_bipred_idc ) && 622 ( pic_init_qp_minus26 == rhs.pic_init_qp_minus26 ) && ( pic_init_qs_minus26 == rhs.pic_init_qs_minus26 ) && 623 ( chroma_qp_index_offset == rhs.chroma_qp_index_offset ) && ( second_chroma_qp_index_offset == rhs.second_chroma_qp_index_offset ) && 624 ( pScalingLists == rhs.pScalingLists ); 625 } 626 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PictureParameterSet627 bool operator!=( H264PictureParameterSet const & rhs ) const VULKAN_HPP_NOEXCEPT 628 { 629 return !operator==( rhs ); 630 } 631 632 public: 633 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PpsFlags flags = {}; 634 uint8_t seq_parameter_set_id = {}; 635 uint8_t pic_parameter_set_id = {}; 636 uint8_t num_ref_idx_l0_default_active_minus1 = {}; 637 uint8_t num_ref_idx_l1_default_active_minus1 = {}; 638 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264WeightedBipredIdc weighted_bipred_idc = 639 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264WeightedBipredIdc::eDefault; 640 int8_t pic_init_qp_minus26 = {}; 641 int8_t pic_init_qs_minus26 = {}; 642 int8_t chroma_qp_index_offset = {}; 643 int8_t second_chroma_qp_index_offset = {}; 644 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ScalingLists * pScalingLists = {}; 645 }; 646 647 //=== vulkan_video_codec_h264std_decode === 648 649 struct DecodeH264PictureInfoFlags 650 { 651 using NativeType = StdVideoDecodeH264PictureInfoFlags; 652 operator StdVideoDecodeH264PictureInfoFlags const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264PictureInfoFlags653 operator StdVideoDecodeH264PictureInfoFlags const &() const VULKAN_HPP_NOEXCEPT 654 { 655 return *reinterpret_cast<const StdVideoDecodeH264PictureInfoFlags *>( this ); 656 } 657 operator StdVideoDecodeH264PictureInfoFlags&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264PictureInfoFlags658 operator StdVideoDecodeH264PictureInfoFlags &() VULKAN_HPP_NOEXCEPT 659 { 660 return *reinterpret_cast<StdVideoDecodeH264PictureInfoFlags *>( this ); 661 } 662 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264PictureInfoFlags663 bool operator==( DecodeH264PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 664 { 665 return ( field_pic_flag == rhs.field_pic_flag ) && ( is_intra == rhs.is_intra ) && ( IdrPicFlag == rhs.IdrPicFlag ) && 666 ( bottom_field_flag == rhs.bottom_field_flag ) && ( is_reference == rhs.is_reference ) && 667 ( complementary_field_pair == rhs.complementary_field_pair ); 668 } 669 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264PictureInfoFlags670 bool operator!=( DecodeH264PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 671 { 672 return !operator==( rhs ); 673 } 674 675 public: 676 uint32_t field_pic_flag : 1; 677 uint32_t is_intra : 1; 678 uint32_t IdrPicFlag : 1; 679 uint32_t bottom_field_flag : 1; 680 uint32_t is_reference : 1; 681 uint32_t complementary_field_pair : 1; 682 }; 683 684 struct DecodeH264PictureInfo 685 { 686 using NativeType = StdVideoDecodeH264PictureInfo; 687 operator StdVideoDecodeH264PictureInfo const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264PictureInfo688 operator StdVideoDecodeH264PictureInfo const &() const VULKAN_HPP_NOEXCEPT 689 { 690 return *reinterpret_cast<const StdVideoDecodeH264PictureInfo *>( this ); 691 } 692 operator StdVideoDecodeH264PictureInfo&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264PictureInfo693 operator StdVideoDecodeH264PictureInfo &() VULKAN_HPP_NOEXCEPT 694 { 695 return *reinterpret_cast<StdVideoDecodeH264PictureInfo *>( this ); 696 } 697 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264PictureInfo698 bool operator==( DecodeH264PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT 699 { 700 return ( flags == rhs.flags ) && ( seq_parameter_set_id == rhs.seq_parameter_set_id ) && ( pic_parameter_set_id == rhs.pic_parameter_set_id ) && 701 ( reserved1 == rhs.reserved1 ) && ( reserved2 == rhs.reserved2 ) && ( frame_num == rhs.frame_num ) && ( idr_pic_id == rhs.idr_pic_id ) && 702 ( PicOrderCnt == rhs.PicOrderCnt ); 703 } 704 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264PictureInfo705 bool operator!=( DecodeH264PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT 706 { 707 return !operator==( rhs ); 708 } 709 710 public: 711 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264PictureInfoFlags flags = {}; 712 uint8_t seq_parameter_set_id = {}; 713 uint8_t pic_parameter_set_id = {}; 714 uint8_t reserved1 = {}; 715 uint8_t reserved2 = {}; 716 uint16_t frame_num = {}; 717 uint16_t idr_pic_id = {}; 718 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<int32_t, STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_LIST_SIZE> PicOrderCnt = {}; 719 }; 720 721 struct DecodeH264ReferenceInfoFlags 722 { 723 using NativeType = StdVideoDecodeH264ReferenceInfoFlags; 724 operator StdVideoDecodeH264ReferenceInfoFlags const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264ReferenceInfoFlags725 operator StdVideoDecodeH264ReferenceInfoFlags const &() const VULKAN_HPP_NOEXCEPT 726 { 727 return *reinterpret_cast<const StdVideoDecodeH264ReferenceInfoFlags *>( this ); 728 } 729 operator StdVideoDecodeH264ReferenceInfoFlags&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264ReferenceInfoFlags730 operator StdVideoDecodeH264ReferenceInfoFlags &() VULKAN_HPP_NOEXCEPT 731 { 732 return *reinterpret_cast<StdVideoDecodeH264ReferenceInfoFlags *>( this ); 733 } 734 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264ReferenceInfoFlags735 bool operator==( DecodeH264ReferenceInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 736 { 737 return ( top_field_flag == rhs.top_field_flag ) && ( bottom_field_flag == rhs.bottom_field_flag ) && 738 ( used_for_long_term_reference == rhs.used_for_long_term_reference ) && ( is_non_existing == rhs.is_non_existing ); 739 } 740 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264ReferenceInfoFlags741 bool operator!=( DecodeH264ReferenceInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 742 { 743 return !operator==( rhs ); 744 } 745 746 public: 747 uint32_t top_field_flag : 1; 748 uint32_t bottom_field_flag : 1; 749 uint32_t used_for_long_term_reference : 1; 750 uint32_t is_non_existing : 1; 751 }; 752 753 struct DecodeH264ReferenceInfo 754 { 755 using NativeType = StdVideoDecodeH264ReferenceInfo; 756 operator StdVideoDecodeH264ReferenceInfo const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264ReferenceInfo757 operator StdVideoDecodeH264ReferenceInfo const &() const VULKAN_HPP_NOEXCEPT 758 { 759 return *reinterpret_cast<const StdVideoDecodeH264ReferenceInfo *>( this ); 760 } 761 operator StdVideoDecodeH264ReferenceInfo&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264ReferenceInfo762 operator StdVideoDecodeH264ReferenceInfo &() VULKAN_HPP_NOEXCEPT 763 { 764 return *reinterpret_cast<StdVideoDecodeH264ReferenceInfo *>( this ); 765 } 766 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264ReferenceInfo767 bool operator==( DecodeH264ReferenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT 768 { 769 return ( flags == rhs.flags ) && ( FrameNum == rhs.FrameNum ) && ( reserved == rhs.reserved ) && ( PicOrderCnt == rhs.PicOrderCnt ); 770 } 771 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264ReferenceInfo772 bool operator!=( DecodeH264ReferenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT 773 { 774 return !operator==( rhs ); 775 } 776 777 public: 778 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264ReferenceInfoFlags flags = {}; 779 uint16_t FrameNum = {}; 780 uint16_t reserved = {}; 781 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<int32_t, STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_LIST_SIZE> PicOrderCnt = {}; 782 }; 783 784 //=== vulkan_video_codec_h264std_encode === 785 786 struct EncodeH264WeightTableFlags 787 { 788 using NativeType = StdVideoEncodeH264WeightTableFlags; 789 operator StdVideoEncodeH264WeightTableFlags const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264WeightTableFlags790 operator StdVideoEncodeH264WeightTableFlags const &() const VULKAN_HPP_NOEXCEPT 791 { 792 return *reinterpret_cast<const StdVideoEncodeH264WeightTableFlags *>( this ); 793 } 794 operator StdVideoEncodeH264WeightTableFlags&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264WeightTableFlags795 operator StdVideoEncodeH264WeightTableFlags &() VULKAN_HPP_NOEXCEPT 796 { 797 return *reinterpret_cast<StdVideoEncodeH264WeightTableFlags *>( this ); 798 } 799 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264WeightTableFlags800 bool operator==( EncodeH264WeightTableFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 801 { 802 return ( luma_weight_l0_flag == rhs.luma_weight_l0_flag ) && ( chroma_weight_l0_flag == rhs.chroma_weight_l0_flag ) && 803 ( luma_weight_l1_flag == rhs.luma_weight_l1_flag ) && ( chroma_weight_l1_flag == rhs.chroma_weight_l1_flag ); 804 } 805 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264WeightTableFlags806 bool operator!=( EncodeH264WeightTableFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 807 { 808 return !operator==( rhs ); 809 } 810 811 public: 812 uint32_t luma_weight_l0_flag = {}; 813 uint32_t chroma_weight_l0_flag = {}; 814 uint32_t luma_weight_l1_flag = {}; 815 uint32_t chroma_weight_l1_flag = {}; 816 }; 817 818 struct EncodeH264WeightTable 819 { 820 using NativeType = StdVideoEncodeH264WeightTable; 821 operator StdVideoEncodeH264WeightTable const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264WeightTable822 operator StdVideoEncodeH264WeightTable const &() const VULKAN_HPP_NOEXCEPT 823 { 824 return *reinterpret_cast<const StdVideoEncodeH264WeightTable *>( this ); 825 } 826 operator StdVideoEncodeH264WeightTable&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264WeightTable827 operator StdVideoEncodeH264WeightTable &() VULKAN_HPP_NOEXCEPT 828 { 829 return *reinterpret_cast<StdVideoEncodeH264WeightTable *>( this ); 830 } 831 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264WeightTable832 bool operator==( EncodeH264WeightTable const & rhs ) const VULKAN_HPP_NOEXCEPT 833 { 834 return ( flags == rhs.flags ) && ( luma_log2_weight_denom == rhs.luma_log2_weight_denom ) && 835 ( chroma_log2_weight_denom == rhs.chroma_log2_weight_denom ) && ( luma_weight_l0 == rhs.luma_weight_l0 ) && 836 ( luma_offset_l0 == rhs.luma_offset_l0 ) && ( chroma_weight_l0 == rhs.chroma_weight_l0 ) && ( chroma_offset_l0 == rhs.chroma_offset_l0 ) && 837 ( luma_weight_l1 == rhs.luma_weight_l1 ) && ( luma_offset_l1 == rhs.luma_offset_l1 ) && ( chroma_weight_l1 == rhs.chroma_weight_l1 ) && 838 ( chroma_offset_l1 == rhs.chroma_offset_l1 ); 839 } 840 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264WeightTable841 bool operator!=( EncodeH264WeightTable const & rhs ) const VULKAN_HPP_NOEXCEPT 842 { 843 return !operator==( rhs ); 844 } 845 846 public: 847 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264WeightTableFlags flags = {}; 848 uint8_t luma_log2_weight_denom = {}; 849 uint8_t chroma_log2_weight_denom = {}; 850 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<int8_t, STD_VIDEO_H264_MAX_NUM_LIST_REF> luma_weight_l0 = {}; 851 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<int8_t, STD_VIDEO_H264_MAX_NUM_LIST_REF> luma_offset_l0 = {}; 852 VULKAN_HPP_NAMESPACE::ArrayWrapper2D<int8_t, STD_VIDEO_H264_MAX_NUM_LIST_REF, STD_VIDEO_H264_MAX_CHROMA_PLANES> chroma_weight_l0 = {}; 853 VULKAN_HPP_NAMESPACE::ArrayWrapper2D<int8_t, STD_VIDEO_H264_MAX_NUM_LIST_REF, STD_VIDEO_H264_MAX_CHROMA_PLANES> chroma_offset_l0 = {}; 854 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<int8_t, STD_VIDEO_H264_MAX_NUM_LIST_REF> luma_weight_l1 = {}; 855 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<int8_t, STD_VIDEO_H264_MAX_NUM_LIST_REF> luma_offset_l1 = {}; 856 VULKAN_HPP_NAMESPACE::ArrayWrapper2D<int8_t, STD_VIDEO_H264_MAX_NUM_LIST_REF, STD_VIDEO_H264_MAX_CHROMA_PLANES> chroma_weight_l1 = {}; 857 VULKAN_HPP_NAMESPACE::ArrayWrapper2D<int8_t, STD_VIDEO_H264_MAX_NUM_LIST_REF, STD_VIDEO_H264_MAX_CHROMA_PLANES> chroma_offset_l1 = {}; 858 }; 859 860 struct EncodeH264SliceHeaderFlags 861 { 862 using NativeType = StdVideoEncodeH264SliceHeaderFlags; 863 operator StdVideoEncodeH264SliceHeaderFlags const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264SliceHeaderFlags864 operator StdVideoEncodeH264SliceHeaderFlags const &() const VULKAN_HPP_NOEXCEPT 865 { 866 return *reinterpret_cast<const StdVideoEncodeH264SliceHeaderFlags *>( this ); 867 } 868 operator StdVideoEncodeH264SliceHeaderFlags&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264SliceHeaderFlags869 operator StdVideoEncodeH264SliceHeaderFlags &() VULKAN_HPP_NOEXCEPT 870 { 871 return *reinterpret_cast<StdVideoEncodeH264SliceHeaderFlags *>( this ); 872 } 873 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264SliceHeaderFlags874 bool operator==( EncodeH264SliceHeaderFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 875 { 876 return ( direct_spatial_mv_pred_flag == rhs.direct_spatial_mv_pred_flag ) && 877 ( num_ref_idx_active_override_flag == rhs.num_ref_idx_active_override_flag ) && ( reserved == rhs.reserved ); 878 } 879 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264SliceHeaderFlags880 bool operator!=( EncodeH264SliceHeaderFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 881 { 882 return !operator==( rhs ); 883 } 884 885 public: 886 uint32_t direct_spatial_mv_pred_flag : 1; 887 uint32_t num_ref_idx_active_override_flag : 1; 888 uint32_t reserved : 30; 889 }; 890 891 struct EncodeH264PictureInfoFlags 892 { 893 using NativeType = StdVideoEncodeH264PictureInfoFlags; 894 operator StdVideoEncodeH264PictureInfoFlags const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264PictureInfoFlags895 operator StdVideoEncodeH264PictureInfoFlags const &() const VULKAN_HPP_NOEXCEPT 896 { 897 return *reinterpret_cast<const StdVideoEncodeH264PictureInfoFlags *>( this ); 898 } 899 operator StdVideoEncodeH264PictureInfoFlags&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264PictureInfoFlags900 operator StdVideoEncodeH264PictureInfoFlags &() VULKAN_HPP_NOEXCEPT 901 { 902 return *reinterpret_cast<StdVideoEncodeH264PictureInfoFlags *>( this ); 903 } 904 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264PictureInfoFlags905 bool operator==( EncodeH264PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 906 { 907 return ( IdrPicFlag == rhs.IdrPicFlag ) && ( is_reference == rhs.is_reference ) && 908 ( no_output_of_prior_pics_flag == rhs.no_output_of_prior_pics_flag ) && ( long_term_reference_flag == rhs.long_term_reference_flag ) && 909 ( adaptive_ref_pic_marking_mode_flag == rhs.adaptive_ref_pic_marking_mode_flag ) && ( reserved == rhs.reserved ); 910 } 911 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264PictureInfoFlags912 bool operator!=( EncodeH264PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 913 { 914 return !operator==( rhs ); 915 } 916 917 public: 918 uint32_t IdrPicFlag : 1; 919 uint32_t is_reference : 1; 920 uint32_t no_output_of_prior_pics_flag : 1; 921 uint32_t long_term_reference_flag : 1; 922 uint32_t adaptive_ref_pic_marking_mode_flag : 1; 923 uint32_t reserved : 27; 924 }; 925 926 struct EncodeH264ReferenceInfoFlags 927 { 928 using NativeType = StdVideoEncodeH264ReferenceInfoFlags; 929 operator StdVideoEncodeH264ReferenceInfoFlags const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceInfoFlags930 operator StdVideoEncodeH264ReferenceInfoFlags const &() const VULKAN_HPP_NOEXCEPT 931 { 932 return *reinterpret_cast<const StdVideoEncodeH264ReferenceInfoFlags *>( this ); 933 } 934 operator StdVideoEncodeH264ReferenceInfoFlags&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceInfoFlags935 operator StdVideoEncodeH264ReferenceInfoFlags &() VULKAN_HPP_NOEXCEPT 936 { 937 return *reinterpret_cast<StdVideoEncodeH264ReferenceInfoFlags *>( this ); 938 } 939 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceInfoFlags940 bool operator==( EncodeH264ReferenceInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 941 { 942 return ( used_for_long_term_reference == rhs.used_for_long_term_reference ) && ( reserved == rhs.reserved ); 943 } 944 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceInfoFlags945 bool operator!=( EncodeH264ReferenceInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 946 { 947 return !operator==( rhs ); 948 } 949 950 public: 951 uint32_t used_for_long_term_reference : 1; 952 uint32_t reserved : 31; 953 }; 954 955 struct EncodeH264ReferenceListsInfoFlags 956 { 957 using NativeType = StdVideoEncodeH264ReferenceListsInfoFlags; 958 operator StdVideoEncodeH264ReferenceListsInfoFlags const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceListsInfoFlags959 operator StdVideoEncodeH264ReferenceListsInfoFlags const &() const VULKAN_HPP_NOEXCEPT 960 { 961 return *reinterpret_cast<const StdVideoEncodeH264ReferenceListsInfoFlags *>( this ); 962 } 963 operator StdVideoEncodeH264ReferenceListsInfoFlags&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceListsInfoFlags964 operator StdVideoEncodeH264ReferenceListsInfoFlags &() VULKAN_HPP_NOEXCEPT 965 { 966 return *reinterpret_cast<StdVideoEncodeH264ReferenceListsInfoFlags *>( this ); 967 } 968 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceListsInfoFlags969 bool operator==( EncodeH264ReferenceListsInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 970 { 971 return ( ref_pic_list_modification_flag_l0 == rhs.ref_pic_list_modification_flag_l0 ) && 972 ( ref_pic_list_modification_flag_l1 == rhs.ref_pic_list_modification_flag_l1 ) && ( reserved == rhs.reserved ); 973 } 974 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceListsInfoFlags975 bool operator!=( EncodeH264ReferenceListsInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 976 { 977 return !operator==( rhs ); 978 } 979 980 public: 981 uint32_t ref_pic_list_modification_flag_l0 : 1; 982 uint32_t ref_pic_list_modification_flag_l1 : 1; 983 uint32_t reserved : 30; 984 }; 985 986 struct EncodeH264RefListModEntry 987 { 988 using NativeType = StdVideoEncodeH264RefListModEntry; 989 operator StdVideoEncodeH264RefListModEntry const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264RefListModEntry990 operator StdVideoEncodeH264RefListModEntry const &() const VULKAN_HPP_NOEXCEPT 991 { 992 return *reinterpret_cast<const StdVideoEncodeH264RefListModEntry *>( this ); 993 } 994 operator StdVideoEncodeH264RefListModEntry&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264RefListModEntry995 operator StdVideoEncodeH264RefListModEntry &() VULKAN_HPP_NOEXCEPT 996 { 997 return *reinterpret_cast<StdVideoEncodeH264RefListModEntry *>( this ); 998 } 999 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264RefListModEntry1000 bool operator==( EncodeH264RefListModEntry const & rhs ) const VULKAN_HPP_NOEXCEPT 1001 { 1002 return ( modification_of_pic_nums_idc == rhs.modification_of_pic_nums_idc ) && ( abs_diff_pic_num_minus1 == rhs.abs_diff_pic_num_minus1 ) && 1003 ( long_term_pic_num == rhs.long_term_pic_num ); 1004 } 1005 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264RefListModEntry1006 bool operator!=( EncodeH264RefListModEntry const & rhs ) const VULKAN_HPP_NOEXCEPT 1007 { 1008 return !operator==( rhs ); 1009 } 1010 1011 public: 1012 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ModificationOfPicNumsIdc modification_of_pic_nums_idc = 1013 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ModificationOfPicNumsIdc::eShortTermSubtract; 1014 uint16_t abs_diff_pic_num_minus1 = {}; 1015 uint16_t long_term_pic_num = {}; 1016 }; 1017 1018 struct EncodeH264RefPicMarkingEntry 1019 { 1020 using NativeType = StdVideoEncodeH264RefPicMarkingEntry; 1021 operator StdVideoEncodeH264RefPicMarkingEntry const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264RefPicMarkingEntry1022 operator StdVideoEncodeH264RefPicMarkingEntry const &() const VULKAN_HPP_NOEXCEPT 1023 { 1024 return *reinterpret_cast<const StdVideoEncodeH264RefPicMarkingEntry *>( this ); 1025 } 1026 operator StdVideoEncodeH264RefPicMarkingEntry&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264RefPicMarkingEntry1027 operator StdVideoEncodeH264RefPicMarkingEntry &() VULKAN_HPP_NOEXCEPT 1028 { 1029 return *reinterpret_cast<StdVideoEncodeH264RefPicMarkingEntry *>( this ); 1030 } 1031 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264RefPicMarkingEntry1032 bool operator==( EncodeH264RefPicMarkingEntry const & rhs ) const VULKAN_HPP_NOEXCEPT 1033 { 1034 return ( memory_management_control_operation == rhs.memory_management_control_operation ) && 1035 ( difference_of_pic_nums_minus1 == rhs.difference_of_pic_nums_minus1 ) && ( long_term_pic_num == rhs.long_term_pic_num ) && 1036 ( long_term_frame_idx == rhs.long_term_frame_idx ) && ( max_long_term_frame_idx_plus1 == rhs.max_long_term_frame_idx_plus1 ); 1037 } 1038 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264RefPicMarkingEntry1039 bool operator!=( EncodeH264RefPicMarkingEntry const & rhs ) const VULKAN_HPP_NOEXCEPT 1040 { 1041 return !operator==( rhs ); 1042 } 1043 1044 public: 1045 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264MemMgmtControlOp memory_management_control_operation = 1046 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264MemMgmtControlOp::eEnd; 1047 uint16_t difference_of_pic_nums_minus1 = {}; 1048 uint16_t long_term_pic_num = {}; 1049 uint16_t long_term_frame_idx = {}; 1050 uint16_t max_long_term_frame_idx_plus1 = {}; 1051 }; 1052 1053 struct EncodeH264ReferenceListsInfo 1054 { 1055 using NativeType = StdVideoEncodeH264ReferenceListsInfo; 1056 operator StdVideoEncodeH264ReferenceListsInfo const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceListsInfo1057 operator StdVideoEncodeH264ReferenceListsInfo const &() const VULKAN_HPP_NOEXCEPT 1058 { 1059 return *reinterpret_cast<const StdVideoEncodeH264ReferenceListsInfo *>( this ); 1060 } 1061 operator StdVideoEncodeH264ReferenceListsInfo&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceListsInfo1062 operator StdVideoEncodeH264ReferenceListsInfo &() VULKAN_HPP_NOEXCEPT 1063 { 1064 return *reinterpret_cast<StdVideoEncodeH264ReferenceListsInfo *>( this ); 1065 } 1066 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceListsInfo1067 bool operator==( EncodeH264ReferenceListsInfo const & rhs ) const VULKAN_HPP_NOEXCEPT 1068 { 1069 return ( flags == rhs.flags ) && ( num_ref_idx_l0_active_minus1 == rhs.num_ref_idx_l0_active_minus1 ) && 1070 ( num_ref_idx_l1_active_minus1 == rhs.num_ref_idx_l1_active_minus1 ) && ( RefPicList0 == rhs.RefPicList0 ) && 1071 ( RefPicList1 == rhs.RefPicList1 ) && ( refList0ModOpCount == rhs.refList0ModOpCount ) && ( refList1ModOpCount == rhs.refList1ModOpCount ) && 1072 ( refPicMarkingOpCount == rhs.refPicMarkingOpCount ) && ( reserved1 == rhs.reserved1 ) && 1073 ( pRefList0ModOperations == rhs.pRefList0ModOperations ) && ( pRefList1ModOperations == rhs.pRefList1ModOperations ) && 1074 ( pRefPicMarkingOperations == rhs.pRefPicMarkingOperations ); 1075 } 1076 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceListsInfo1077 bool operator!=( EncodeH264ReferenceListsInfo const & rhs ) const VULKAN_HPP_NOEXCEPT 1078 { 1079 return !operator==( rhs ); 1080 } 1081 1082 public: 1083 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceListsInfoFlags flags = {}; 1084 uint8_t num_ref_idx_l0_active_minus1 = {}; 1085 uint8_t num_ref_idx_l1_active_minus1 = {}; 1086 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_H264_MAX_NUM_LIST_REF> RefPicList0 = {}; 1087 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_H264_MAX_NUM_LIST_REF> RefPicList1 = {}; 1088 uint8_t refList0ModOpCount = {}; 1089 uint8_t refList1ModOpCount = {}; 1090 uint8_t refPicMarkingOpCount = {}; 1091 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, 7> reserved1 = {}; 1092 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264RefListModEntry * pRefList0ModOperations = {}; 1093 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264RefListModEntry * pRefList1ModOperations = {}; 1094 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264RefPicMarkingEntry * pRefPicMarkingOperations = {}; 1095 }; 1096 1097 struct EncodeH264PictureInfo 1098 { 1099 using NativeType = StdVideoEncodeH264PictureInfo; 1100 operator StdVideoEncodeH264PictureInfo const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264PictureInfo1101 operator StdVideoEncodeH264PictureInfo const &() const VULKAN_HPP_NOEXCEPT 1102 { 1103 return *reinterpret_cast<const StdVideoEncodeH264PictureInfo *>( this ); 1104 } 1105 operator StdVideoEncodeH264PictureInfo&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264PictureInfo1106 operator StdVideoEncodeH264PictureInfo &() VULKAN_HPP_NOEXCEPT 1107 { 1108 return *reinterpret_cast<StdVideoEncodeH264PictureInfo *>( this ); 1109 } 1110 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264PictureInfo1111 bool operator==( EncodeH264PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT 1112 { 1113 return ( flags == rhs.flags ) && ( seq_parameter_set_id == rhs.seq_parameter_set_id ) && ( pic_parameter_set_id == rhs.pic_parameter_set_id ) && 1114 ( idr_pic_id == rhs.idr_pic_id ) && ( primary_pic_type == rhs.primary_pic_type ) && ( frame_num == rhs.frame_num ) && 1115 ( PicOrderCnt == rhs.PicOrderCnt ) && ( temporal_id == rhs.temporal_id ) && ( reserved1 == rhs.reserved1 ) && ( pRefLists == rhs.pRefLists ); 1116 } 1117 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264PictureInfo1118 bool operator!=( EncodeH264PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT 1119 { 1120 return !operator==( rhs ); 1121 } 1122 1123 public: 1124 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264PictureInfoFlags flags = {}; 1125 uint8_t seq_parameter_set_id = {}; 1126 uint8_t pic_parameter_set_id = {}; 1127 uint16_t idr_pic_id = {}; 1128 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PictureType primary_pic_type = 1129 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PictureType::eP; 1130 uint32_t frame_num = {}; 1131 int32_t PicOrderCnt = {}; 1132 uint8_t temporal_id = {}; 1133 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, 3> reserved1 = {}; 1134 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceListsInfo * pRefLists = {}; 1135 }; 1136 1137 struct EncodeH264ReferenceInfo 1138 { 1139 using NativeType = StdVideoEncodeH264ReferenceInfo; 1140 operator StdVideoEncodeH264ReferenceInfo const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceInfo1141 operator StdVideoEncodeH264ReferenceInfo const &() const VULKAN_HPP_NOEXCEPT 1142 { 1143 return *reinterpret_cast<const StdVideoEncodeH264ReferenceInfo *>( this ); 1144 } 1145 operator StdVideoEncodeH264ReferenceInfo&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceInfo1146 operator StdVideoEncodeH264ReferenceInfo &() VULKAN_HPP_NOEXCEPT 1147 { 1148 return *reinterpret_cast<StdVideoEncodeH264ReferenceInfo *>( this ); 1149 } 1150 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceInfo1151 bool operator==( EncodeH264ReferenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT 1152 { 1153 return ( flags == rhs.flags ) && ( primary_pic_type == rhs.primary_pic_type ) && ( FrameNum == rhs.FrameNum ) && ( PicOrderCnt == rhs.PicOrderCnt ) && 1154 ( long_term_pic_num == rhs.long_term_pic_num ) && ( long_term_frame_idx == rhs.long_term_frame_idx ) && ( temporal_id == rhs.temporal_id ); 1155 } 1156 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceInfo1157 bool operator!=( EncodeH264ReferenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT 1158 { 1159 return !operator==( rhs ); 1160 } 1161 1162 public: 1163 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceInfoFlags flags = {}; 1164 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PictureType primary_pic_type = 1165 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PictureType::eP; 1166 uint32_t FrameNum = {}; 1167 int32_t PicOrderCnt = {}; 1168 uint16_t long_term_pic_num = {}; 1169 uint16_t long_term_frame_idx = {}; 1170 uint8_t temporal_id = {}; 1171 }; 1172 1173 struct EncodeH264SliceHeader 1174 { 1175 using NativeType = StdVideoEncodeH264SliceHeader; 1176 operator StdVideoEncodeH264SliceHeader const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264SliceHeader1177 operator StdVideoEncodeH264SliceHeader const &() const VULKAN_HPP_NOEXCEPT 1178 { 1179 return *reinterpret_cast<const StdVideoEncodeH264SliceHeader *>( this ); 1180 } 1181 operator StdVideoEncodeH264SliceHeader&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264SliceHeader1182 operator StdVideoEncodeH264SliceHeader &() VULKAN_HPP_NOEXCEPT 1183 { 1184 return *reinterpret_cast<StdVideoEncodeH264SliceHeader *>( this ); 1185 } 1186 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264SliceHeader1187 bool operator==( EncodeH264SliceHeader const & rhs ) const VULKAN_HPP_NOEXCEPT 1188 { 1189 return ( flags == rhs.flags ) && ( first_mb_in_slice == rhs.first_mb_in_slice ) && ( slice_type == rhs.slice_type ) && 1190 ( slice_alpha_c0_offset_div2 == rhs.slice_alpha_c0_offset_div2 ) && ( slice_beta_offset_div2 == rhs.slice_beta_offset_div2 ) && 1191 ( slice_qp_delta == rhs.slice_qp_delta ) && ( reserved1 == rhs.reserved1 ) && ( cabac_init_idc == rhs.cabac_init_idc ) && 1192 ( disable_deblocking_filter_idc == rhs.disable_deblocking_filter_idc ) && ( pWeightTable == rhs.pWeightTable ); 1193 } 1194 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264SliceHeader1195 bool operator!=( EncodeH264SliceHeader const & rhs ) const VULKAN_HPP_NOEXCEPT 1196 { 1197 return !operator==( rhs ); 1198 } 1199 1200 public: 1201 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264SliceHeaderFlags flags = {}; 1202 uint32_t first_mb_in_slice = {}; 1203 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SliceType slice_type = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SliceType::eP; 1204 int8_t slice_alpha_c0_offset_div2 = {}; 1205 int8_t slice_beta_offset_div2 = {}; 1206 int8_t slice_qp_delta = {}; 1207 uint8_t reserved1 = {}; 1208 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264CabacInitIdc cabac_init_idc = 1209 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264CabacInitIdc::e0; 1210 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264DisableDeblockingFilterIdc disable_deblocking_filter_idc = 1211 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264DisableDeblockingFilterIdc::eDisabled; 1212 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264WeightTable * pWeightTable = {}; 1213 }; 1214 1215 //=== vulkan_video_codec_h265std === 1216 1217 struct H265DecPicBufMgr 1218 { 1219 using NativeType = StdVideoH265DecPicBufMgr; 1220 operator StdVideoH265DecPicBufMgr const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265DecPicBufMgr1221 operator StdVideoH265DecPicBufMgr const &() const VULKAN_HPP_NOEXCEPT 1222 { 1223 return *reinterpret_cast<const StdVideoH265DecPicBufMgr *>( this ); 1224 } 1225 operator StdVideoH265DecPicBufMgr&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265DecPicBufMgr1226 operator StdVideoH265DecPicBufMgr &() VULKAN_HPP_NOEXCEPT 1227 { 1228 return *reinterpret_cast<StdVideoH265DecPicBufMgr *>( this ); 1229 } 1230 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265DecPicBufMgr1231 bool operator==( H265DecPicBufMgr const & rhs ) const VULKAN_HPP_NOEXCEPT 1232 { 1233 return ( max_latency_increase_plus1 == rhs.max_latency_increase_plus1 ) && ( max_dec_pic_buffering_minus1 == rhs.max_dec_pic_buffering_minus1 ) && 1234 ( max_num_reorder_pics == rhs.max_num_reorder_pics ); 1235 } 1236 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265DecPicBufMgr1237 bool operator!=( H265DecPicBufMgr const & rhs ) const VULKAN_HPP_NOEXCEPT 1238 { 1239 return !operator==( rhs ); 1240 } 1241 1242 public: 1243 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint32_t, STD_VIDEO_H265_SUBLAYERS_LIST_SIZE> max_latency_increase_plus1 = {}; 1244 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_H265_SUBLAYERS_LIST_SIZE> max_dec_pic_buffering_minus1 = {}; 1245 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_H265_SUBLAYERS_LIST_SIZE> max_num_reorder_pics = {}; 1246 }; 1247 1248 struct H265SubLayerHrdParameters 1249 { 1250 using NativeType = StdVideoH265SubLayerHrdParameters; 1251 operator StdVideoH265SubLayerHrdParameters const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SubLayerHrdParameters1252 operator StdVideoH265SubLayerHrdParameters const &() const VULKAN_HPP_NOEXCEPT 1253 { 1254 return *reinterpret_cast<const StdVideoH265SubLayerHrdParameters *>( this ); 1255 } 1256 operator StdVideoH265SubLayerHrdParameters&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SubLayerHrdParameters1257 operator StdVideoH265SubLayerHrdParameters &() VULKAN_HPP_NOEXCEPT 1258 { 1259 return *reinterpret_cast<StdVideoH265SubLayerHrdParameters *>( this ); 1260 } 1261 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SubLayerHrdParameters1262 bool operator==( H265SubLayerHrdParameters const & rhs ) const VULKAN_HPP_NOEXCEPT 1263 { 1264 return ( bit_rate_value_minus1 == rhs.bit_rate_value_minus1 ) && ( cpb_size_value_minus1 == rhs.cpb_size_value_minus1 ) && 1265 ( cpb_size_du_value_minus1 == rhs.cpb_size_du_value_minus1 ) && ( bit_rate_du_value_minus1 == rhs.bit_rate_du_value_minus1 ) && 1266 ( cbr_flag == rhs.cbr_flag ); 1267 } 1268 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SubLayerHrdParameters1269 bool operator!=( H265SubLayerHrdParameters const & rhs ) const VULKAN_HPP_NOEXCEPT 1270 { 1271 return !operator==( rhs ); 1272 } 1273 1274 public: 1275 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint32_t, STD_VIDEO_H265_CPB_CNT_LIST_SIZE> bit_rate_value_minus1 = {}; 1276 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint32_t, STD_VIDEO_H265_CPB_CNT_LIST_SIZE> cpb_size_value_minus1 = {}; 1277 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint32_t, STD_VIDEO_H265_CPB_CNT_LIST_SIZE> cpb_size_du_value_minus1 = {}; 1278 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint32_t, STD_VIDEO_H265_CPB_CNT_LIST_SIZE> bit_rate_du_value_minus1 = {}; 1279 uint32_t cbr_flag = {}; 1280 }; 1281 1282 struct H265HrdFlags 1283 { 1284 using NativeType = StdVideoH265HrdFlags; 1285 operator StdVideoH265HrdFlags const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265HrdFlags1286 operator StdVideoH265HrdFlags const &() const VULKAN_HPP_NOEXCEPT 1287 { 1288 return *reinterpret_cast<const StdVideoH265HrdFlags *>( this ); 1289 } 1290 operator StdVideoH265HrdFlags&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265HrdFlags1291 operator StdVideoH265HrdFlags &() VULKAN_HPP_NOEXCEPT 1292 { 1293 return *reinterpret_cast<StdVideoH265HrdFlags *>( this ); 1294 } 1295 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265HrdFlags1296 bool operator==( H265HrdFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 1297 { 1298 return ( nal_hrd_parameters_present_flag == rhs.nal_hrd_parameters_present_flag ) && 1299 ( vcl_hrd_parameters_present_flag == rhs.vcl_hrd_parameters_present_flag ) && 1300 ( sub_pic_hrd_params_present_flag == rhs.sub_pic_hrd_params_present_flag ) && 1301 ( sub_pic_cpb_params_in_pic_timing_sei_flag == rhs.sub_pic_cpb_params_in_pic_timing_sei_flag ) && 1302 ( fixed_pic_rate_general_flag == rhs.fixed_pic_rate_general_flag ) && ( fixed_pic_rate_within_cvs_flag == rhs.fixed_pic_rate_within_cvs_flag ) && 1303 ( low_delay_hrd_flag == rhs.low_delay_hrd_flag ); 1304 } 1305 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265HrdFlags1306 bool operator!=( H265HrdFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 1307 { 1308 return !operator==( rhs ); 1309 } 1310 1311 public: 1312 uint32_t nal_hrd_parameters_present_flag : 1; 1313 uint32_t vcl_hrd_parameters_present_flag : 1; 1314 uint32_t sub_pic_hrd_params_present_flag : 1; 1315 uint32_t sub_pic_cpb_params_in_pic_timing_sei_flag : 1; 1316 uint32_t fixed_pic_rate_general_flag : 8; 1317 uint32_t fixed_pic_rate_within_cvs_flag : 8; 1318 uint32_t low_delay_hrd_flag : 8; 1319 }; 1320 1321 struct H265HrdParameters 1322 { 1323 using NativeType = StdVideoH265HrdParameters; 1324 operator StdVideoH265HrdParameters const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265HrdParameters1325 operator StdVideoH265HrdParameters const &() const VULKAN_HPP_NOEXCEPT 1326 { 1327 return *reinterpret_cast<const StdVideoH265HrdParameters *>( this ); 1328 } 1329 operator StdVideoH265HrdParameters&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265HrdParameters1330 operator StdVideoH265HrdParameters &() VULKAN_HPP_NOEXCEPT 1331 { 1332 return *reinterpret_cast<StdVideoH265HrdParameters *>( this ); 1333 } 1334 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265HrdParameters1335 bool operator==( H265HrdParameters const & rhs ) const VULKAN_HPP_NOEXCEPT 1336 { 1337 return ( flags == rhs.flags ) && ( tick_divisor_minus2 == rhs.tick_divisor_minus2 ) && 1338 ( du_cpb_removal_delay_increment_length_minus1 == rhs.du_cpb_removal_delay_increment_length_minus1 ) && 1339 ( dpb_output_delay_du_length_minus1 == rhs.dpb_output_delay_du_length_minus1 ) && ( bit_rate_scale == rhs.bit_rate_scale ) && 1340 ( cpb_size_scale == rhs.cpb_size_scale ) && ( cpb_size_du_scale == rhs.cpb_size_du_scale ) && 1341 ( initial_cpb_removal_delay_length_minus1 == rhs.initial_cpb_removal_delay_length_minus1 ) && 1342 ( au_cpb_removal_delay_length_minus1 == rhs.au_cpb_removal_delay_length_minus1 ) && 1343 ( dpb_output_delay_length_minus1 == rhs.dpb_output_delay_length_minus1 ) && ( cpb_cnt_minus1 == rhs.cpb_cnt_minus1 ) && 1344 ( elemental_duration_in_tc_minus1 == rhs.elemental_duration_in_tc_minus1 ) && ( reserved == rhs.reserved ) && 1345 ( pSubLayerHrdParametersNal == rhs.pSubLayerHrdParametersNal ) && ( pSubLayerHrdParametersVcl == rhs.pSubLayerHrdParametersVcl ); 1346 } 1347 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265HrdParameters1348 bool operator!=( H265HrdParameters const & rhs ) const VULKAN_HPP_NOEXCEPT 1349 { 1350 return !operator==( rhs ); 1351 } 1352 1353 public: 1354 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265HrdFlags flags = {}; 1355 uint8_t tick_divisor_minus2 = {}; 1356 uint8_t du_cpb_removal_delay_increment_length_minus1 = {}; 1357 uint8_t dpb_output_delay_du_length_minus1 = {}; 1358 uint8_t bit_rate_scale = {}; 1359 uint8_t cpb_size_scale = {}; 1360 uint8_t cpb_size_du_scale = {}; 1361 uint8_t initial_cpb_removal_delay_length_minus1 = {}; 1362 uint8_t au_cpb_removal_delay_length_minus1 = {}; 1363 uint8_t dpb_output_delay_length_minus1 = {}; 1364 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_H265_SUBLAYERS_LIST_SIZE> cpb_cnt_minus1 = {}; 1365 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint16_t, STD_VIDEO_H265_SUBLAYERS_LIST_SIZE> elemental_duration_in_tc_minus1 = {}; 1366 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint16_t, 3> reserved = {}; 1367 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SubLayerHrdParameters * pSubLayerHrdParametersNal = {}; 1368 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SubLayerHrdParameters * pSubLayerHrdParametersVcl = {}; 1369 }; 1370 1371 struct H265VpsFlags 1372 { 1373 using NativeType = StdVideoH265VpsFlags; 1374 operator StdVideoH265VpsFlags const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265VpsFlags1375 operator StdVideoH265VpsFlags const &() const VULKAN_HPP_NOEXCEPT 1376 { 1377 return *reinterpret_cast<const StdVideoH265VpsFlags *>( this ); 1378 } 1379 operator StdVideoH265VpsFlags&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265VpsFlags1380 operator StdVideoH265VpsFlags &() VULKAN_HPP_NOEXCEPT 1381 { 1382 return *reinterpret_cast<StdVideoH265VpsFlags *>( this ); 1383 } 1384 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265VpsFlags1385 bool operator==( H265VpsFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 1386 { 1387 return ( vps_temporal_id_nesting_flag == rhs.vps_temporal_id_nesting_flag ) && 1388 ( vps_sub_layer_ordering_info_present_flag == rhs.vps_sub_layer_ordering_info_present_flag ) && 1389 ( vps_timing_info_present_flag == rhs.vps_timing_info_present_flag ) && 1390 ( vps_poc_proportional_to_timing_flag == rhs.vps_poc_proportional_to_timing_flag ); 1391 } 1392 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265VpsFlags1393 bool operator!=( H265VpsFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 1394 { 1395 return !operator==( rhs ); 1396 } 1397 1398 public: 1399 uint32_t vps_temporal_id_nesting_flag : 1; 1400 uint32_t vps_sub_layer_ordering_info_present_flag : 1; 1401 uint32_t vps_timing_info_present_flag : 1; 1402 uint32_t vps_poc_proportional_to_timing_flag : 1; 1403 }; 1404 1405 struct H265ProfileTierLevelFlags 1406 { 1407 using NativeType = StdVideoH265ProfileTierLevelFlags; 1408 operator StdVideoH265ProfileTierLevelFlags const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ProfileTierLevelFlags1409 operator StdVideoH265ProfileTierLevelFlags const &() const VULKAN_HPP_NOEXCEPT 1410 { 1411 return *reinterpret_cast<const StdVideoH265ProfileTierLevelFlags *>( this ); 1412 } 1413 operator StdVideoH265ProfileTierLevelFlags&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ProfileTierLevelFlags1414 operator StdVideoH265ProfileTierLevelFlags &() VULKAN_HPP_NOEXCEPT 1415 { 1416 return *reinterpret_cast<StdVideoH265ProfileTierLevelFlags *>( this ); 1417 } 1418 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ProfileTierLevelFlags1419 bool operator==( H265ProfileTierLevelFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 1420 { 1421 return ( general_tier_flag == rhs.general_tier_flag ) && ( general_progressive_source_flag == rhs.general_progressive_source_flag ) && 1422 ( general_interlaced_source_flag == rhs.general_interlaced_source_flag ) && 1423 ( general_non_packed_constraint_flag == rhs.general_non_packed_constraint_flag ) && 1424 ( general_frame_only_constraint_flag == rhs.general_frame_only_constraint_flag ); 1425 } 1426 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ProfileTierLevelFlags1427 bool operator!=( H265ProfileTierLevelFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 1428 { 1429 return !operator==( rhs ); 1430 } 1431 1432 public: 1433 uint32_t general_tier_flag : 1; 1434 uint32_t general_progressive_source_flag : 1; 1435 uint32_t general_interlaced_source_flag : 1; 1436 uint32_t general_non_packed_constraint_flag : 1; 1437 uint32_t general_frame_only_constraint_flag : 1; 1438 }; 1439 1440 struct H265ProfileTierLevel 1441 { 1442 using NativeType = StdVideoH265ProfileTierLevel; 1443 operator StdVideoH265ProfileTierLevel const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ProfileTierLevel1444 operator StdVideoH265ProfileTierLevel const &() const VULKAN_HPP_NOEXCEPT 1445 { 1446 return *reinterpret_cast<const StdVideoH265ProfileTierLevel *>( this ); 1447 } 1448 operator StdVideoH265ProfileTierLevel&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ProfileTierLevel1449 operator StdVideoH265ProfileTierLevel &() VULKAN_HPP_NOEXCEPT 1450 { 1451 return *reinterpret_cast<StdVideoH265ProfileTierLevel *>( this ); 1452 } 1453 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ProfileTierLevel1454 bool operator==( H265ProfileTierLevel const & rhs ) const VULKAN_HPP_NOEXCEPT 1455 { 1456 return ( flags == rhs.flags ) && ( general_profile_idc == rhs.general_profile_idc ) && ( general_level_idc == rhs.general_level_idc ); 1457 } 1458 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ProfileTierLevel1459 bool operator!=( H265ProfileTierLevel const & rhs ) const VULKAN_HPP_NOEXCEPT 1460 { 1461 return !operator==( rhs ); 1462 } 1463 1464 public: 1465 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ProfileTierLevelFlags flags = {}; 1466 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ProfileIdc general_profile_idc = 1467 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ProfileIdc::eMain; 1468 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265LevelIdc general_level_idc = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265LevelIdc::e1_0; 1469 }; 1470 1471 struct H265VideoParameterSet 1472 { 1473 using NativeType = StdVideoH265VideoParameterSet; 1474 operator StdVideoH265VideoParameterSet const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265VideoParameterSet1475 operator StdVideoH265VideoParameterSet const &() const VULKAN_HPP_NOEXCEPT 1476 { 1477 return *reinterpret_cast<const StdVideoH265VideoParameterSet *>( this ); 1478 } 1479 operator StdVideoH265VideoParameterSet&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265VideoParameterSet1480 operator StdVideoH265VideoParameterSet &() VULKAN_HPP_NOEXCEPT 1481 { 1482 return *reinterpret_cast<StdVideoH265VideoParameterSet *>( this ); 1483 } 1484 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265VideoParameterSet1485 bool operator==( H265VideoParameterSet const & rhs ) const VULKAN_HPP_NOEXCEPT 1486 { 1487 return ( flags == rhs.flags ) && ( vps_video_parameter_set_id == rhs.vps_video_parameter_set_id ) && 1488 ( vps_max_sub_layers_minus1 == rhs.vps_max_sub_layers_minus1 ) && ( reserved1 == rhs.reserved1 ) && ( reserved2 == rhs.reserved2 ) && 1489 ( vps_num_units_in_tick == rhs.vps_num_units_in_tick ) && ( vps_time_scale == rhs.vps_time_scale ) && 1490 ( vps_num_ticks_poc_diff_one_minus1 == rhs.vps_num_ticks_poc_diff_one_minus1 ) && ( reserved3 == rhs.reserved3 ) && 1491 ( pDecPicBufMgr == rhs.pDecPicBufMgr ) && ( pHrdParameters == rhs.pHrdParameters ) && ( pProfileTierLevel == rhs.pProfileTierLevel ); 1492 } 1493 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265VideoParameterSet1494 bool operator!=( H265VideoParameterSet const & rhs ) const VULKAN_HPP_NOEXCEPT 1495 { 1496 return !operator==( rhs ); 1497 } 1498 1499 public: 1500 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265VpsFlags flags = {}; 1501 uint8_t vps_video_parameter_set_id = {}; 1502 uint8_t vps_max_sub_layers_minus1 = {}; 1503 uint8_t reserved1 = {}; 1504 uint8_t reserved2 = {}; 1505 uint32_t vps_num_units_in_tick = {}; 1506 uint32_t vps_time_scale = {}; 1507 uint32_t vps_num_ticks_poc_diff_one_minus1 = {}; 1508 uint32_t reserved3 = {}; 1509 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265DecPicBufMgr * pDecPicBufMgr = {}; 1510 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265HrdParameters * pHrdParameters = {}; 1511 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ProfileTierLevel * pProfileTierLevel = {}; 1512 }; 1513 1514 struct H265ScalingLists 1515 { 1516 using NativeType = StdVideoH265ScalingLists; 1517 operator StdVideoH265ScalingLists const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingLists1518 operator StdVideoH265ScalingLists const &() const VULKAN_HPP_NOEXCEPT 1519 { 1520 return *reinterpret_cast<const StdVideoH265ScalingLists *>( this ); 1521 } 1522 operator StdVideoH265ScalingLists&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingLists1523 operator StdVideoH265ScalingLists &() VULKAN_HPP_NOEXCEPT 1524 { 1525 return *reinterpret_cast<StdVideoH265ScalingLists *>( this ); 1526 } 1527 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingLists1528 bool operator==( H265ScalingLists const & rhs ) const VULKAN_HPP_NOEXCEPT 1529 { 1530 return ( ScalingList4x4 == rhs.ScalingList4x4 ) && ( ScalingList8x8 == rhs.ScalingList8x8 ) && ( ScalingList16x16 == rhs.ScalingList16x16 ) && 1531 ( ScalingList32x32 == rhs.ScalingList32x32 ) && ( ScalingListDCCoef16x16 == rhs.ScalingListDCCoef16x16 ) && 1532 ( ScalingListDCCoef32x32 == rhs.ScalingListDCCoef32x32 ); 1533 } 1534 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingLists1535 bool operator!=( H265ScalingLists const & rhs ) const VULKAN_HPP_NOEXCEPT 1536 { 1537 return !operator==( rhs ); 1538 } 1539 1540 public: 1541 VULKAN_HPP_NAMESPACE::ArrayWrapper2D<uint8_t, STD_VIDEO_H265_SCALING_LIST_4X4_NUM_LISTS, STD_VIDEO_H265_SCALING_LIST_4X4_NUM_ELEMENTS> 1542 ScalingList4x4 = {}; 1543 VULKAN_HPP_NAMESPACE::ArrayWrapper2D<uint8_t, STD_VIDEO_H265_SCALING_LIST_8X8_NUM_LISTS, STD_VIDEO_H265_SCALING_LIST_8X8_NUM_ELEMENTS> 1544 ScalingList8x8 = {}; 1545 VULKAN_HPP_NAMESPACE::ArrayWrapper2D<uint8_t, STD_VIDEO_H265_SCALING_LIST_16X16_NUM_LISTS, STD_VIDEO_H265_SCALING_LIST_16X16_NUM_ELEMENTS> 1546 ScalingList16x16 = {}; 1547 VULKAN_HPP_NAMESPACE::ArrayWrapper2D<uint8_t, STD_VIDEO_H265_SCALING_LIST_32X32_NUM_LISTS, STD_VIDEO_H265_SCALING_LIST_32X32_NUM_ELEMENTS> 1548 ScalingList32x32 = {}; 1549 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_H265_SCALING_LIST_16X16_NUM_LISTS> ScalingListDCCoef16x16 = {}; 1550 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_H265_SCALING_LIST_32X32_NUM_LISTS> ScalingListDCCoef32x32 = {}; 1551 }; 1552 1553 struct H265SpsVuiFlags 1554 { 1555 using NativeType = StdVideoH265SpsVuiFlags; 1556 operator StdVideoH265SpsVuiFlags const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SpsVuiFlags1557 operator StdVideoH265SpsVuiFlags const &() const VULKAN_HPP_NOEXCEPT 1558 { 1559 return *reinterpret_cast<const StdVideoH265SpsVuiFlags *>( this ); 1560 } 1561 operator StdVideoH265SpsVuiFlags&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SpsVuiFlags1562 operator StdVideoH265SpsVuiFlags &() VULKAN_HPP_NOEXCEPT 1563 { 1564 return *reinterpret_cast<StdVideoH265SpsVuiFlags *>( this ); 1565 } 1566 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SpsVuiFlags1567 bool operator==( H265SpsVuiFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 1568 { 1569 return ( aspect_ratio_info_present_flag == rhs.aspect_ratio_info_present_flag ) && ( overscan_info_present_flag == rhs.overscan_info_present_flag ) && 1570 ( overscan_appropriate_flag == rhs.overscan_appropriate_flag ) && ( video_signal_type_present_flag == rhs.video_signal_type_present_flag ) && 1571 ( video_full_range_flag == rhs.video_full_range_flag ) && ( colour_description_present_flag == rhs.colour_description_present_flag ) && 1572 ( chroma_loc_info_present_flag == rhs.chroma_loc_info_present_flag ) && 1573 ( neutral_chroma_indication_flag == rhs.neutral_chroma_indication_flag ) && ( field_seq_flag == rhs.field_seq_flag ) && 1574 ( frame_field_info_present_flag == rhs.frame_field_info_present_flag ) && ( default_display_window_flag == rhs.default_display_window_flag ) && 1575 ( vui_timing_info_present_flag == rhs.vui_timing_info_present_flag ) && 1576 ( vui_poc_proportional_to_timing_flag == rhs.vui_poc_proportional_to_timing_flag ) && 1577 ( vui_hrd_parameters_present_flag == rhs.vui_hrd_parameters_present_flag ) && ( bitstream_restriction_flag == rhs.bitstream_restriction_flag ) && 1578 ( tiles_fixed_structure_flag == rhs.tiles_fixed_structure_flag ) && 1579 ( motion_vectors_over_pic_boundaries_flag == rhs.motion_vectors_over_pic_boundaries_flag ) && 1580 ( restricted_ref_pic_lists_flag == rhs.restricted_ref_pic_lists_flag ); 1581 } 1582 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SpsVuiFlags1583 bool operator!=( H265SpsVuiFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 1584 { 1585 return !operator==( rhs ); 1586 } 1587 1588 public: 1589 uint32_t aspect_ratio_info_present_flag : 1; 1590 uint32_t overscan_info_present_flag : 1; 1591 uint32_t overscan_appropriate_flag : 1; 1592 uint32_t video_signal_type_present_flag : 1; 1593 uint32_t video_full_range_flag : 1; 1594 uint32_t colour_description_present_flag : 1; 1595 uint32_t chroma_loc_info_present_flag : 1; 1596 uint32_t neutral_chroma_indication_flag : 1; 1597 uint32_t field_seq_flag : 1; 1598 uint32_t frame_field_info_present_flag : 1; 1599 uint32_t default_display_window_flag : 1; 1600 uint32_t vui_timing_info_present_flag : 1; 1601 uint32_t vui_poc_proportional_to_timing_flag : 1; 1602 uint32_t vui_hrd_parameters_present_flag : 1; 1603 uint32_t bitstream_restriction_flag : 1; 1604 uint32_t tiles_fixed_structure_flag : 1; 1605 uint32_t motion_vectors_over_pic_boundaries_flag : 1; 1606 uint32_t restricted_ref_pic_lists_flag : 1; 1607 }; 1608 1609 struct H265SequenceParameterSetVui 1610 { 1611 using NativeType = StdVideoH265SequenceParameterSetVui; 1612 operator StdVideoH265SequenceParameterSetVui const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SequenceParameterSetVui1613 operator StdVideoH265SequenceParameterSetVui const &() const VULKAN_HPP_NOEXCEPT 1614 { 1615 return *reinterpret_cast<const StdVideoH265SequenceParameterSetVui *>( this ); 1616 } 1617 operator StdVideoH265SequenceParameterSetVui&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SequenceParameterSetVui1618 operator StdVideoH265SequenceParameterSetVui &() VULKAN_HPP_NOEXCEPT 1619 { 1620 return *reinterpret_cast<StdVideoH265SequenceParameterSetVui *>( this ); 1621 } 1622 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SequenceParameterSetVui1623 bool operator==( H265SequenceParameterSetVui const & rhs ) const VULKAN_HPP_NOEXCEPT 1624 { 1625 return ( flags == rhs.flags ) && ( aspect_ratio_idc == rhs.aspect_ratio_idc ) && ( sar_width == rhs.sar_width ) && ( sar_height == rhs.sar_height ) && 1626 ( video_format == rhs.video_format ) && ( colour_primaries == rhs.colour_primaries ) && 1627 ( transfer_characteristics == rhs.transfer_characteristics ) && ( matrix_coeffs == rhs.matrix_coeffs ) && 1628 ( chroma_sample_loc_type_top_field == rhs.chroma_sample_loc_type_top_field ) && 1629 ( chroma_sample_loc_type_bottom_field == rhs.chroma_sample_loc_type_bottom_field ) && ( reserved1 == rhs.reserved1 ) && 1630 ( reserved2 == rhs.reserved2 ) && ( def_disp_win_left_offset == rhs.def_disp_win_left_offset ) && 1631 ( def_disp_win_right_offset == rhs.def_disp_win_right_offset ) && ( def_disp_win_top_offset == rhs.def_disp_win_top_offset ) && 1632 ( def_disp_win_bottom_offset == rhs.def_disp_win_bottom_offset ) && ( vui_num_units_in_tick == rhs.vui_num_units_in_tick ) && 1633 ( vui_time_scale == rhs.vui_time_scale ) && ( vui_num_ticks_poc_diff_one_minus1 == rhs.vui_num_ticks_poc_diff_one_minus1 ) && 1634 ( min_spatial_segmentation_idc == rhs.min_spatial_segmentation_idc ) && ( reserved3 == rhs.reserved3 ) && 1635 ( max_bytes_per_pic_denom == rhs.max_bytes_per_pic_denom ) && ( max_bits_per_min_cu_denom == rhs.max_bits_per_min_cu_denom ) && 1636 ( log2_max_mv_length_horizontal == rhs.log2_max_mv_length_horizontal ) && ( log2_max_mv_length_vertical == rhs.log2_max_mv_length_vertical ) && 1637 ( pHrdParameters == rhs.pHrdParameters ); 1638 } 1639 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SequenceParameterSetVui1640 bool operator!=( H265SequenceParameterSetVui const & rhs ) const VULKAN_HPP_NOEXCEPT 1641 { 1642 return !operator==( rhs ); 1643 } 1644 1645 public: 1646 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SpsVuiFlags flags = {}; 1647 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265AspectRatioIdc aspect_ratio_idc = 1648 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265AspectRatioIdc::eUnspecified; 1649 uint16_t sar_width = {}; 1650 uint16_t sar_height = {}; 1651 uint8_t video_format = {}; 1652 uint8_t colour_primaries = {}; 1653 uint8_t transfer_characteristics = {}; 1654 uint8_t matrix_coeffs = {}; 1655 uint8_t chroma_sample_loc_type_top_field = {}; 1656 uint8_t chroma_sample_loc_type_bottom_field = {}; 1657 uint8_t reserved1 = {}; 1658 uint8_t reserved2 = {}; 1659 uint16_t def_disp_win_left_offset = {}; 1660 uint16_t def_disp_win_right_offset = {}; 1661 uint16_t def_disp_win_top_offset = {}; 1662 uint16_t def_disp_win_bottom_offset = {}; 1663 uint32_t vui_num_units_in_tick = {}; 1664 uint32_t vui_time_scale = {}; 1665 uint32_t vui_num_ticks_poc_diff_one_minus1 = {}; 1666 uint16_t min_spatial_segmentation_idc = {}; 1667 uint16_t reserved3 = {}; 1668 uint8_t max_bytes_per_pic_denom = {}; 1669 uint8_t max_bits_per_min_cu_denom = {}; 1670 uint8_t log2_max_mv_length_horizontal = {}; 1671 uint8_t log2_max_mv_length_vertical = {}; 1672 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265HrdParameters * pHrdParameters = {}; 1673 }; 1674 1675 struct H265PredictorPaletteEntries 1676 { 1677 using NativeType = StdVideoH265PredictorPaletteEntries; 1678 operator StdVideoH265PredictorPaletteEntries const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PredictorPaletteEntries1679 operator StdVideoH265PredictorPaletteEntries const &() const VULKAN_HPP_NOEXCEPT 1680 { 1681 return *reinterpret_cast<const StdVideoH265PredictorPaletteEntries *>( this ); 1682 } 1683 operator StdVideoH265PredictorPaletteEntries&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PredictorPaletteEntries1684 operator StdVideoH265PredictorPaletteEntries &() VULKAN_HPP_NOEXCEPT 1685 { 1686 return *reinterpret_cast<StdVideoH265PredictorPaletteEntries *>( this ); 1687 } 1688 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PredictorPaletteEntries1689 bool operator==( H265PredictorPaletteEntries const & rhs ) const VULKAN_HPP_NOEXCEPT 1690 { 1691 return ( PredictorPaletteEntries == rhs.PredictorPaletteEntries ); 1692 } 1693 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PredictorPaletteEntries1694 bool operator!=( H265PredictorPaletteEntries const & rhs ) const VULKAN_HPP_NOEXCEPT 1695 { 1696 return !operator==( rhs ); 1697 } 1698 1699 public: 1700 VULKAN_HPP_NAMESPACE:: 1701 ArrayWrapper2D<uint16_t, STD_VIDEO_H265_PREDICTOR_PALETTE_COMPONENTS_LIST_SIZE, STD_VIDEO_H265_PREDICTOR_PALETTE_COMP_ENTRIES_LIST_SIZE> 1702 PredictorPaletteEntries = {}; 1703 }; 1704 1705 struct H265SpsFlags 1706 { 1707 using NativeType = StdVideoH265SpsFlags; 1708 operator StdVideoH265SpsFlags const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SpsFlags1709 operator StdVideoH265SpsFlags const &() const VULKAN_HPP_NOEXCEPT 1710 { 1711 return *reinterpret_cast<const StdVideoH265SpsFlags *>( this ); 1712 } 1713 operator StdVideoH265SpsFlags&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SpsFlags1714 operator StdVideoH265SpsFlags &() VULKAN_HPP_NOEXCEPT 1715 { 1716 return *reinterpret_cast<StdVideoH265SpsFlags *>( this ); 1717 } 1718 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SpsFlags1719 bool operator==( H265SpsFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 1720 { 1721 return ( sps_temporal_id_nesting_flag == rhs.sps_temporal_id_nesting_flag ) && ( separate_colour_plane_flag == rhs.separate_colour_plane_flag ) && 1722 ( conformance_window_flag == rhs.conformance_window_flag ) && 1723 ( sps_sub_layer_ordering_info_present_flag == rhs.sps_sub_layer_ordering_info_present_flag ) && 1724 ( scaling_list_enabled_flag == rhs.scaling_list_enabled_flag ) && 1725 ( sps_scaling_list_data_present_flag == rhs.sps_scaling_list_data_present_flag ) && ( amp_enabled_flag == rhs.amp_enabled_flag ) && 1726 ( sample_adaptive_offset_enabled_flag == rhs.sample_adaptive_offset_enabled_flag ) && ( pcm_enabled_flag == rhs.pcm_enabled_flag ) && 1727 ( pcm_loop_filter_disabled_flag == rhs.pcm_loop_filter_disabled_flag ) && 1728 ( long_term_ref_pics_present_flag == rhs.long_term_ref_pics_present_flag ) && 1729 ( sps_temporal_mvp_enabled_flag == rhs.sps_temporal_mvp_enabled_flag ) && 1730 ( strong_intra_smoothing_enabled_flag == rhs.strong_intra_smoothing_enabled_flag ) && 1731 ( vui_parameters_present_flag == rhs.vui_parameters_present_flag ) && ( sps_extension_present_flag == rhs.sps_extension_present_flag ) && 1732 ( sps_range_extension_flag == rhs.sps_range_extension_flag ) && 1733 ( transform_skip_rotation_enabled_flag == rhs.transform_skip_rotation_enabled_flag ) && 1734 ( transform_skip_context_enabled_flag == rhs.transform_skip_context_enabled_flag ) && 1735 ( implicit_rdpcm_enabled_flag == rhs.implicit_rdpcm_enabled_flag ) && ( explicit_rdpcm_enabled_flag == rhs.explicit_rdpcm_enabled_flag ) && 1736 ( extended_precision_processing_flag == rhs.extended_precision_processing_flag ) && 1737 ( intra_smoothing_disabled_flag == rhs.intra_smoothing_disabled_flag ) && 1738 ( high_precision_offsets_enabled_flag == rhs.high_precision_offsets_enabled_flag ) && 1739 ( persistent_rice_adaptation_enabled_flag == rhs.persistent_rice_adaptation_enabled_flag ) && 1740 ( cabac_bypass_alignment_enabled_flag == rhs.cabac_bypass_alignment_enabled_flag ) && ( sps_scc_extension_flag == rhs.sps_scc_extension_flag ) && 1741 ( sps_curr_pic_ref_enabled_flag == rhs.sps_curr_pic_ref_enabled_flag ) && ( palette_mode_enabled_flag == rhs.palette_mode_enabled_flag ) && 1742 ( sps_palette_predictor_initializers_present_flag == rhs.sps_palette_predictor_initializers_present_flag ) && 1743 ( intra_boundary_filtering_disabled_flag == rhs.intra_boundary_filtering_disabled_flag ); 1744 } 1745 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SpsFlags1746 bool operator!=( H265SpsFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 1747 { 1748 return !operator==( rhs ); 1749 } 1750 1751 public: 1752 uint32_t sps_temporal_id_nesting_flag : 1; 1753 uint32_t separate_colour_plane_flag : 1; 1754 uint32_t conformance_window_flag : 1; 1755 uint32_t sps_sub_layer_ordering_info_present_flag : 1; 1756 uint32_t scaling_list_enabled_flag : 1; 1757 uint32_t sps_scaling_list_data_present_flag : 1; 1758 uint32_t amp_enabled_flag : 1; 1759 uint32_t sample_adaptive_offset_enabled_flag : 1; 1760 uint32_t pcm_enabled_flag : 1; 1761 uint32_t pcm_loop_filter_disabled_flag : 1; 1762 uint32_t long_term_ref_pics_present_flag : 1; 1763 uint32_t sps_temporal_mvp_enabled_flag : 1; 1764 uint32_t strong_intra_smoothing_enabled_flag : 1; 1765 uint32_t vui_parameters_present_flag : 1; 1766 uint32_t sps_extension_present_flag : 1; 1767 uint32_t sps_range_extension_flag : 1; 1768 uint32_t transform_skip_rotation_enabled_flag : 1; 1769 uint32_t transform_skip_context_enabled_flag : 1; 1770 uint32_t implicit_rdpcm_enabled_flag : 1; 1771 uint32_t explicit_rdpcm_enabled_flag : 1; 1772 uint32_t extended_precision_processing_flag : 1; 1773 uint32_t intra_smoothing_disabled_flag : 1; 1774 uint32_t high_precision_offsets_enabled_flag : 1; 1775 uint32_t persistent_rice_adaptation_enabled_flag : 1; 1776 uint32_t cabac_bypass_alignment_enabled_flag : 1; 1777 uint32_t sps_scc_extension_flag : 1; 1778 uint32_t sps_curr_pic_ref_enabled_flag : 1; 1779 uint32_t palette_mode_enabled_flag : 1; 1780 uint32_t sps_palette_predictor_initializers_present_flag : 1; 1781 uint32_t intra_boundary_filtering_disabled_flag : 1; 1782 }; 1783 1784 struct H265ShortTermRefPicSetFlags 1785 { 1786 using NativeType = StdVideoH265ShortTermRefPicSetFlags; 1787 operator StdVideoH265ShortTermRefPicSetFlags const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ShortTermRefPicSetFlags1788 operator StdVideoH265ShortTermRefPicSetFlags const &() const VULKAN_HPP_NOEXCEPT 1789 { 1790 return *reinterpret_cast<const StdVideoH265ShortTermRefPicSetFlags *>( this ); 1791 } 1792 operator StdVideoH265ShortTermRefPicSetFlags&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ShortTermRefPicSetFlags1793 operator StdVideoH265ShortTermRefPicSetFlags &() VULKAN_HPP_NOEXCEPT 1794 { 1795 return *reinterpret_cast<StdVideoH265ShortTermRefPicSetFlags *>( this ); 1796 } 1797 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ShortTermRefPicSetFlags1798 bool operator==( H265ShortTermRefPicSetFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 1799 { 1800 return ( inter_ref_pic_set_prediction_flag == rhs.inter_ref_pic_set_prediction_flag ) && ( delta_rps_sign == rhs.delta_rps_sign ); 1801 } 1802 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ShortTermRefPicSetFlags1803 bool operator!=( H265ShortTermRefPicSetFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 1804 { 1805 return !operator==( rhs ); 1806 } 1807 1808 public: 1809 uint32_t inter_ref_pic_set_prediction_flag : 1; 1810 uint32_t delta_rps_sign : 1; 1811 }; 1812 1813 struct H265ShortTermRefPicSet 1814 { 1815 using NativeType = StdVideoH265ShortTermRefPicSet; 1816 operator StdVideoH265ShortTermRefPicSet const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ShortTermRefPicSet1817 operator StdVideoH265ShortTermRefPicSet const &() const VULKAN_HPP_NOEXCEPT 1818 { 1819 return *reinterpret_cast<const StdVideoH265ShortTermRefPicSet *>( this ); 1820 } 1821 operator StdVideoH265ShortTermRefPicSet&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ShortTermRefPicSet1822 operator StdVideoH265ShortTermRefPicSet &() VULKAN_HPP_NOEXCEPT 1823 { 1824 return *reinterpret_cast<StdVideoH265ShortTermRefPicSet *>( this ); 1825 } 1826 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ShortTermRefPicSet1827 bool operator==( H265ShortTermRefPicSet const & rhs ) const VULKAN_HPP_NOEXCEPT 1828 { 1829 return ( flags == rhs.flags ) && ( delta_idx_minus1 == rhs.delta_idx_minus1 ) && ( use_delta_flag == rhs.use_delta_flag ) && 1830 ( abs_delta_rps_minus1 == rhs.abs_delta_rps_minus1 ) && ( used_by_curr_pic_flag == rhs.used_by_curr_pic_flag ) && 1831 ( 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 ) && 1832 ( reserved1 == rhs.reserved1 ) && ( reserved2 == rhs.reserved2 ) && ( reserved3 == rhs.reserved3 ) && 1833 ( num_negative_pics == rhs.num_negative_pics ) && ( num_positive_pics == rhs.num_positive_pics ) && 1834 ( delta_poc_s0_minus1 == rhs.delta_poc_s0_minus1 ) && ( delta_poc_s1_minus1 == rhs.delta_poc_s1_minus1 ); 1835 } 1836 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ShortTermRefPicSet1837 bool operator!=( H265ShortTermRefPicSet const & rhs ) const VULKAN_HPP_NOEXCEPT 1838 { 1839 return !operator==( rhs ); 1840 } 1841 1842 public: 1843 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ShortTermRefPicSetFlags flags = {}; 1844 uint32_t delta_idx_minus1 = {}; 1845 uint16_t use_delta_flag = {}; 1846 uint16_t abs_delta_rps_minus1 = {}; 1847 uint16_t used_by_curr_pic_flag = {}; 1848 uint16_t used_by_curr_pic_s0_flag = {}; 1849 uint16_t used_by_curr_pic_s1_flag = {}; 1850 uint16_t reserved1 = {}; 1851 uint8_t reserved2 = {}; 1852 uint8_t reserved3 = {}; 1853 uint8_t num_negative_pics = {}; 1854 uint8_t num_positive_pics = {}; 1855 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint16_t, STD_VIDEO_H265_MAX_DPB_SIZE> delta_poc_s0_minus1 = {}; 1856 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint16_t, STD_VIDEO_H265_MAX_DPB_SIZE> delta_poc_s1_minus1 = {}; 1857 }; 1858 1859 struct H265LongTermRefPicsSps 1860 { 1861 using NativeType = StdVideoH265LongTermRefPicsSps; 1862 operator StdVideoH265LongTermRefPicsSps const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265LongTermRefPicsSps1863 operator StdVideoH265LongTermRefPicsSps const &() const VULKAN_HPP_NOEXCEPT 1864 { 1865 return *reinterpret_cast<const StdVideoH265LongTermRefPicsSps *>( this ); 1866 } 1867 operator StdVideoH265LongTermRefPicsSps&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265LongTermRefPicsSps1868 operator StdVideoH265LongTermRefPicsSps &() VULKAN_HPP_NOEXCEPT 1869 { 1870 return *reinterpret_cast<StdVideoH265LongTermRefPicsSps *>( this ); 1871 } 1872 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265LongTermRefPicsSps1873 bool operator==( H265LongTermRefPicsSps const & rhs ) const VULKAN_HPP_NOEXCEPT 1874 { 1875 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 ); 1876 } 1877 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265LongTermRefPicsSps1878 bool operator!=( H265LongTermRefPicsSps const & rhs ) const VULKAN_HPP_NOEXCEPT 1879 { 1880 return !operator==( rhs ); 1881 } 1882 1883 public: 1884 uint32_t used_by_curr_pic_lt_sps_flag = {}; 1885 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint32_t, STD_VIDEO_H265_MAX_LONG_TERM_REF_PICS_SPS> lt_ref_pic_poc_lsb_sps = {}; 1886 }; 1887 1888 struct H265SequenceParameterSet 1889 { 1890 using NativeType = StdVideoH265SequenceParameterSet; 1891 operator StdVideoH265SequenceParameterSet const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SequenceParameterSet1892 operator StdVideoH265SequenceParameterSet const &() const VULKAN_HPP_NOEXCEPT 1893 { 1894 return *reinterpret_cast<const StdVideoH265SequenceParameterSet *>( this ); 1895 } 1896 operator StdVideoH265SequenceParameterSet&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SequenceParameterSet1897 operator StdVideoH265SequenceParameterSet &() VULKAN_HPP_NOEXCEPT 1898 { 1899 return *reinterpret_cast<StdVideoH265SequenceParameterSet *>( this ); 1900 } 1901 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SequenceParameterSet1902 bool operator==( H265SequenceParameterSet const & rhs ) const VULKAN_HPP_NOEXCEPT 1903 { 1904 return ( flags == rhs.flags ) && ( chroma_format_idc == rhs.chroma_format_idc ) && ( pic_width_in_luma_samples == rhs.pic_width_in_luma_samples ) && 1905 ( pic_height_in_luma_samples == rhs.pic_height_in_luma_samples ) && ( sps_video_parameter_set_id == rhs.sps_video_parameter_set_id ) && 1906 ( sps_max_sub_layers_minus1 == rhs.sps_max_sub_layers_minus1 ) && ( sps_seq_parameter_set_id == rhs.sps_seq_parameter_set_id ) && 1907 ( bit_depth_luma_minus8 == rhs.bit_depth_luma_minus8 ) && ( bit_depth_chroma_minus8 == rhs.bit_depth_chroma_minus8 ) && 1908 ( log2_max_pic_order_cnt_lsb_minus4 == rhs.log2_max_pic_order_cnt_lsb_minus4 ) && 1909 ( log2_min_luma_coding_block_size_minus3 == rhs.log2_min_luma_coding_block_size_minus3 ) && 1910 ( log2_diff_max_min_luma_coding_block_size == rhs.log2_diff_max_min_luma_coding_block_size ) && 1911 ( log2_min_luma_transform_block_size_minus2 == rhs.log2_min_luma_transform_block_size_minus2 ) && 1912 ( log2_diff_max_min_luma_transform_block_size == rhs.log2_diff_max_min_luma_transform_block_size ) && 1913 ( max_transform_hierarchy_depth_inter == rhs.max_transform_hierarchy_depth_inter ) && 1914 ( max_transform_hierarchy_depth_intra == rhs.max_transform_hierarchy_depth_intra ) && 1915 ( 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 ) && 1916 ( pcm_sample_bit_depth_luma_minus1 == rhs.pcm_sample_bit_depth_luma_minus1 ) && 1917 ( pcm_sample_bit_depth_chroma_minus1 == rhs.pcm_sample_bit_depth_chroma_minus1 ) && 1918 ( log2_min_pcm_luma_coding_block_size_minus3 == rhs.log2_min_pcm_luma_coding_block_size_minus3 ) && 1919 ( log2_diff_max_min_pcm_luma_coding_block_size == rhs.log2_diff_max_min_pcm_luma_coding_block_size ) && ( reserved1 == rhs.reserved1 ) && 1920 ( reserved2 == rhs.reserved2 ) && ( palette_max_size == rhs.palette_max_size ) && 1921 ( delta_palette_max_predictor_size == rhs.delta_palette_max_predictor_size ) && 1922 ( motion_vector_resolution_control_idc == rhs.motion_vector_resolution_control_idc ) && 1923 ( sps_num_palette_predictor_initializers_minus1 == rhs.sps_num_palette_predictor_initializers_minus1 ) && 1924 ( conf_win_left_offset == rhs.conf_win_left_offset ) && ( conf_win_right_offset == rhs.conf_win_right_offset ) && 1925 ( conf_win_top_offset == rhs.conf_win_top_offset ) && ( conf_win_bottom_offset == rhs.conf_win_bottom_offset ) && 1926 ( pProfileTierLevel == rhs.pProfileTierLevel ) && ( pDecPicBufMgr == rhs.pDecPicBufMgr ) && ( pScalingLists == rhs.pScalingLists ) && 1927 ( pShortTermRefPicSet == rhs.pShortTermRefPicSet ) && ( pLongTermRefPicsSps == rhs.pLongTermRefPicsSps ) && 1928 ( pSequenceParameterSetVui == rhs.pSequenceParameterSetVui ) && ( pPredictorPaletteEntries == rhs.pPredictorPaletteEntries ); 1929 } 1930 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SequenceParameterSet1931 bool operator!=( H265SequenceParameterSet const & rhs ) const VULKAN_HPP_NOEXCEPT 1932 { 1933 return !operator==( rhs ); 1934 } 1935 1936 public: 1937 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SpsFlags flags = {}; 1938 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ChromaFormatIdc chroma_format_idc = 1939 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ChromaFormatIdc::eMonochrome; 1940 uint32_t pic_width_in_luma_samples = {}; 1941 uint32_t pic_height_in_luma_samples = {}; 1942 uint8_t sps_video_parameter_set_id = {}; 1943 uint8_t sps_max_sub_layers_minus1 = {}; 1944 uint8_t sps_seq_parameter_set_id = {}; 1945 uint8_t bit_depth_luma_minus8 = {}; 1946 uint8_t bit_depth_chroma_minus8 = {}; 1947 uint8_t log2_max_pic_order_cnt_lsb_minus4 = {}; 1948 uint8_t log2_min_luma_coding_block_size_minus3 = {}; 1949 uint8_t log2_diff_max_min_luma_coding_block_size = {}; 1950 uint8_t log2_min_luma_transform_block_size_minus2 = {}; 1951 uint8_t log2_diff_max_min_luma_transform_block_size = {}; 1952 uint8_t max_transform_hierarchy_depth_inter = {}; 1953 uint8_t max_transform_hierarchy_depth_intra = {}; 1954 uint8_t num_short_term_ref_pic_sets = {}; 1955 uint8_t num_long_term_ref_pics_sps = {}; 1956 uint8_t pcm_sample_bit_depth_luma_minus1 = {}; 1957 uint8_t pcm_sample_bit_depth_chroma_minus1 = {}; 1958 uint8_t log2_min_pcm_luma_coding_block_size_minus3 = {}; 1959 uint8_t log2_diff_max_min_pcm_luma_coding_block_size = {}; 1960 uint8_t reserved1 = {}; 1961 uint8_t reserved2 = {}; 1962 uint8_t palette_max_size = {}; 1963 uint8_t delta_palette_max_predictor_size = {}; 1964 uint8_t motion_vector_resolution_control_idc = {}; 1965 uint8_t sps_num_palette_predictor_initializers_minus1 = {}; 1966 uint32_t conf_win_left_offset = {}; 1967 uint32_t conf_win_right_offset = {}; 1968 uint32_t conf_win_top_offset = {}; 1969 uint32_t conf_win_bottom_offset = {}; 1970 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ProfileTierLevel * pProfileTierLevel = {}; 1971 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265DecPicBufMgr * pDecPicBufMgr = {}; 1972 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingLists * pScalingLists = {}; 1973 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ShortTermRefPicSet * pShortTermRefPicSet = {}; 1974 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265LongTermRefPicsSps * pLongTermRefPicsSps = {}; 1975 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SequenceParameterSetVui * pSequenceParameterSetVui = {}; 1976 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PredictorPaletteEntries * pPredictorPaletteEntries = {}; 1977 }; 1978 1979 struct H265PpsFlags 1980 { 1981 using NativeType = StdVideoH265PpsFlags; 1982 operator StdVideoH265PpsFlags const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PpsFlags1983 operator StdVideoH265PpsFlags const &() const VULKAN_HPP_NOEXCEPT 1984 { 1985 return *reinterpret_cast<const StdVideoH265PpsFlags *>( this ); 1986 } 1987 operator StdVideoH265PpsFlags&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PpsFlags1988 operator StdVideoH265PpsFlags &() VULKAN_HPP_NOEXCEPT 1989 { 1990 return *reinterpret_cast<StdVideoH265PpsFlags *>( this ); 1991 } 1992 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PpsFlags1993 bool operator==( H265PpsFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 1994 { 1995 return ( dependent_slice_segments_enabled_flag == rhs.dependent_slice_segments_enabled_flag ) && 1996 ( output_flag_present_flag == rhs.output_flag_present_flag ) && ( sign_data_hiding_enabled_flag == rhs.sign_data_hiding_enabled_flag ) && 1997 ( cabac_init_present_flag == rhs.cabac_init_present_flag ) && ( constrained_intra_pred_flag == rhs.constrained_intra_pred_flag ) && 1998 ( transform_skip_enabled_flag == rhs.transform_skip_enabled_flag ) && ( cu_qp_delta_enabled_flag == rhs.cu_qp_delta_enabled_flag ) && 1999 ( pps_slice_chroma_qp_offsets_present_flag == rhs.pps_slice_chroma_qp_offsets_present_flag ) && 2000 ( weighted_pred_flag == rhs.weighted_pred_flag ) && ( weighted_bipred_flag == rhs.weighted_bipred_flag ) && 2001 ( transquant_bypass_enabled_flag == rhs.transquant_bypass_enabled_flag ) && ( tiles_enabled_flag == rhs.tiles_enabled_flag ) && 2002 ( entropy_coding_sync_enabled_flag == rhs.entropy_coding_sync_enabled_flag ) && ( uniform_spacing_flag == rhs.uniform_spacing_flag ) && 2003 ( loop_filter_across_tiles_enabled_flag == rhs.loop_filter_across_tiles_enabled_flag ) && 2004 ( pps_loop_filter_across_slices_enabled_flag == rhs.pps_loop_filter_across_slices_enabled_flag ) && 2005 ( deblocking_filter_control_present_flag == rhs.deblocking_filter_control_present_flag ) && 2006 ( deblocking_filter_override_enabled_flag == rhs.deblocking_filter_override_enabled_flag ) && 2007 ( pps_deblocking_filter_disabled_flag == rhs.pps_deblocking_filter_disabled_flag ) && 2008 ( pps_scaling_list_data_present_flag == rhs.pps_scaling_list_data_present_flag ) && 2009 ( lists_modification_present_flag == rhs.lists_modification_present_flag ) && 2010 ( slice_segment_header_extension_present_flag == rhs.slice_segment_header_extension_present_flag ) && 2011 ( pps_extension_present_flag == rhs.pps_extension_present_flag ) && 2012 ( cross_component_prediction_enabled_flag == rhs.cross_component_prediction_enabled_flag ) && 2013 ( chroma_qp_offset_list_enabled_flag == rhs.chroma_qp_offset_list_enabled_flag ) && 2014 ( pps_curr_pic_ref_enabled_flag == rhs.pps_curr_pic_ref_enabled_flag ) && 2015 ( residual_adaptive_colour_transform_enabled_flag == rhs.residual_adaptive_colour_transform_enabled_flag ) && 2016 ( pps_slice_act_qp_offsets_present_flag == rhs.pps_slice_act_qp_offsets_present_flag ) && 2017 ( pps_palette_predictor_initializers_present_flag == rhs.pps_palette_predictor_initializers_present_flag ) && 2018 ( monochrome_palette_flag == rhs.monochrome_palette_flag ) && ( pps_range_extension_flag == rhs.pps_range_extension_flag ); 2019 } 2020 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PpsFlags2021 bool operator!=( H265PpsFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 2022 { 2023 return !operator==( rhs ); 2024 } 2025 2026 public: 2027 uint32_t dependent_slice_segments_enabled_flag : 1; 2028 uint32_t output_flag_present_flag : 1; 2029 uint32_t sign_data_hiding_enabled_flag : 1; 2030 uint32_t cabac_init_present_flag : 1; 2031 uint32_t constrained_intra_pred_flag : 1; 2032 uint32_t transform_skip_enabled_flag : 1; 2033 uint32_t cu_qp_delta_enabled_flag : 1; 2034 uint32_t pps_slice_chroma_qp_offsets_present_flag : 1; 2035 uint32_t weighted_pred_flag : 1; 2036 uint32_t weighted_bipred_flag : 1; 2037 uint32_t transquant_bypass_enabled_flag : 1; 2038 uint32_t tiles_enabled_flag : 1; 2039 uint32_t entropy_coding_sync_enabled_flag : 1; 2040 uint32_t uniform_spacing_flag : 1; 2041 uint32_t loop_filter_across_tiles_enabled_flag : 1; 2042 uint32_t pps_loop_filter_across_slices_enabled_flag : 1; 2043 uint32_t deblocking_filter_control_present_flag : 1; 2044 uint32_t deblocking_filter_override_enabled_flag : 1; 2045 uint32_t pps_deblocking_filter_disabled_flag : 1; 2046 uint32_t pps_scaling_list_data_present_flag : 1; 2047 uint32_t lists_modification_present_flag : 1; 2048 uint32_t slice_segment_header_extension_present_flag : 1; 2049 uint32_t pps_extension_present_flag : 1; 2050 uint32_t cross_component_prediction_enabled_flag : 1; 2051 uint32_t chroma_qp_offset_list_enabled_flag : 1; 2052 uint32_t pps_curr_pic_ref_enabled_flag : 1; 2053 uint32_t residual_adaptive_colour_transform_enabled_flag : 1; 2054 uint32_t pps_slice_act_qp_offsets_present_flag : 1; 2055 uint32_t pps_palette_predictor_initializers_present_flag : 1; 2056 uint32_t monochrome_palette_flag : 1; 2057 uint32_t pps_range_extension_flag : 1; 2058 }; 2059 2060 struct H265PictureParameterSet 2061 { 2062 using NativeType = StdVideoH265PictureParameterSet; 2063 operator StdVideoH265PictureParameterSet const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PictureParameterSet2064 operator StdVideoH265PictureParameterSet const &() const VULKAN_HPP_NOEXCEPT 2065 { 2066 return *reinterpret_cast<const StdVideoH265PictureParameterSet *>( this ); 2067 } 2068 operator StdVideoH265PictureParameterSet&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PictureParameterSet2069 operator StdVideoH265PictureParameterSet &() VULKAN_HPP_NOEXCEPT 2070 { 2071 return *reinterpret_cast<StdVideoH265PictureParameterSet *>( this ); 2072 } 2073 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PictureParameterSet2074 bool operator==( H265PictureParameterSet const & rhs ) const VULKAN_HPP_NOEXCEPT 2075 { 2076 return ( flags == rhs.flags ) && ( pps_pic_parameter_set_id == rhs.pps_pic_parameter_set_id ) && 2077 ( pps_seq_parameter_set_id == rhs.pps_seq_parameter_set_id ) && ( sps_video_parameter_set_id == rhs.sps_video_parameter_set_id ) && 2078 ( num_extra_slice_header_bits == rhs.num_extra_slice_header_bits ) && 2079 ( num_ref_idx_l0_default_active_minus1 == rhs.num_ref_idx_l0_default_active_minus1 ) && 2080 ( num_ref_idx_l1_default_active_minus1 == rhs.num_ref_idx_l1_default_active_minus1 ) && ( init_qp_minus26 == rhs.init_qp_minus26 ) && 2081 ( diff_cu_qp_delta_depth == rhs.diff_cu_qp_delta_depth ) && ( pps_cb_qp_offset == rhs.pps_cb_qp_offset ) && 2082 ( pps_cr_qp_offset == rhs.pps_cr_qp_offset ) && ( pps_beta_offset_div2 == rhs.pps_beta_offset_div2 ) && 2083 ( pps_tc_offset_div2 == rhs.pps_tc_offset_div2 ) && ( log2_parallel_merge_level_minus2 == rhs.log2_parallel_merge_level_minus2 ) && 2084 ( log2_max_transform_skip_block_size_minus2 == rhs.log2_max_transform_skip_block_size_minus2 ) && 2085 ( diff_cu_chroma_qp_offset_depth == rhs.diff_cu_chroma_qp_offset_depth ) && 2086 ( chroma_qp_offset_list_len_minus1 == rhs.chroma_qp_offset_list_len_minus1 ) && ( cb_qp_offset_list == rhs.cb_qp_offset_list ) && 2087 ( cr_qp_offset_list == rhs.cr_qp_offset_list ) && ( log2_sao_offset_scale_luma == rhs.log2_sao_offset_scale_luma ) && 2088 ( log2_sao_offset_scale_chroma == rhs.log2_sao_offset_scale_chroma ) && ( pps_act_y_qp_offset_plus5 == rhs.pps_act_y_qp_offset_plus5 ) && 2089 ( 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 ) && 2090 ( pps_num_palette_predictor_initializers == rhs.pps_num_palette_predictor_initializers ) && 2091 ( luma_bit_depth_entry_minus8 == rhs.luma_bit_depth_entry_minus8 ) && ( chroma_bit_depth_entry_minus8 == rhs.chroma_bit_depth_entry_minus8 ) && 2092 ( num_tile_columns_minus1 == rhs.num_tile_columns_minus1 ) && ( num_tile_rows_minus1 == rhs.num_tile_rows_minus1 ) && 2093 ( reserved1 == rhs.reserved1 ) && ( reserved2 == rhs.reserved2 ) && ( column_width_minus1 == rhs.column_width_minus1 ) && 2094 ( row_height_minus1 == rhs.row_height_minus1 ) && ( reserved3 == rhs.reserved3 ) && ( pScalingLists == rhs.pScalingLists ) && 2095 ( pPredictorPaletteEntries == rhs.pPredictorPaletteEntries ); 2096 } 2097 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PictureParameterSet2098 bool operator!=( H265PictureParameterSet const & rhs ) const VULKAN_HPP_NOEXCEPT 2099 { 2100 return !operator==( rhs ); 2101 } 2102 2103 public: 2104 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PpsFlags flags = {}; 2105 uint8_t pps_pic_parameter_set_id = {}; 2106 uint8_t pps_seq_parameter_set_id = {}; 2107 uint8_t sps_video_parameter_set_id = {}; 2108 uint8_t num_extra_slice_header_bits = {}; 2109 uint8_t num_ref_idx_l0_default_active_minus1 = {}; 2110 uint8_t num_ref_idx_l1_default_active_minus1 = {}; 2111 int8_t init_qp_minus26 = {}; 2112 uint8_t diff_cu_qp_delta_depth = {}; 2113 int8_t pps_cb_qp_offset = {}; 2114 int8_t pps_cr_qp_offset = {}; 2115 int8_t pps_beta_offset_div2 = {}; 2116 int8_t pps_tc_offset_div2 = {}; 2117 uint8_t log2_parallel_merge_level_minus2 = {}; 2118 uint8_t log2_max_transform_skip_block_size_minus2 = {}; 2119 uint8_t diff_cu_chroma_qp_offset_depth = {}; 2120 uint8_t chroma_qp_offset_list_len_minus1 = {}; 2121 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<int8_t, STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE> cb_qp_offset_list = {}; 2122 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<int8_t, STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE> cr_qp_offset_list = {}; 2123 uint8_t log2_sao_offset_scale_luma = {}; 2124 uint8_t log2_sao_offset_scale_chroma = {}; 2125 int8_t pps_act_y_qp_offset_plus5 = {}; 2126 int8_t pps_act_cb_qp_offset_plus5 = {}; 2127 int8_t pps_act_cr_qp_offset_plus3 = {}; 2128 uint8_t pps_num_palette_predictor_initializers = {}; 2129 uint8_t luma_bit_depth_entry_minus8 = {}; 2130 uint8_t chroma_bit_depth_entry_minus8 = {}; 2131 uint8_t num_tile_columns_minus1 = {}; 2132 uint8_t num_tile_rows_minus1 = {}; 2133 uint8_t reserved1 = {}; 2134 uint8_t reserved2 = {}; 2135 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint16_t, STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_COLS_LIST_SIZE> column_width_minus1 = {}; 2136 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint16_t, STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_ROWS_LIST_SIZE> row_height_minus1 = {}; 2137 uint32_t reserved3 = {}; 2138 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingLists * pScalingLists = {}; 2139 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PredictorPaletteEntries * pPredictorPaletteEntries = {}; 2140 }; 2141 2142 //=== vulkan_video_codec_h265std_decode === 2143 2144 struct DecodeH265PictureInfoFlags 2145 { 2146 using NativeType = StdVideoDecodeH265PictureInfoFlags; 2147 operator StdVideoDecodeH265PictureInfoFlags const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265PictureInfoFlags2148 operator StdVideoDecodeH265PictureInfoFlags const &() const VULKAN_HPP_NOEXCEPT 2149 { 2150 return *reinterpret_cast<const StdVideoDecodeH265PictureInfoFlags *>( this ); 2151 } 2152 operator StdVideoDecodeH265PictureInfoFlags&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265PictureInfoFlags2153 operator StdVideoDecodeH265PictureInfoFlags &() VULKAN_HPP_NOEXCEPT 2154 { 2155 return *reinterpret_cast<StdVideoDecodeH265PictureInfoFlags *>( this ); 2156 } 2157 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265PictureInfoFlags2158 bool operator==( DecodeH265PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 2159 { 2160 return ( IrapPicFlag == rhs.IrapPicFlag ) && ( IdrPicFlag == rhs.IdrPicFlag ) && ( IsReference == rhs.IsReference ) && 2161 ( short_term_ref_pic_set_sps_flag == rhs.short_term_ref_pic_set_sps_flag ); 2162 } 2163 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265PictureInfoFlags2164 bool operator!=( DecodeH265PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 2165 { 2166 return !operator==( rhs ); 2167 } 2168 2169 public: 2170 uint32_t IrapPicFlag : 1; 2171 uint32_t IdrPicFlag : 1; 2172 uint32_t IsReference : 1; 2173 uint32_t short_term_ref_pic_set_sps_flag : 1; 2174 }; 2175 2176 struct DecodeH265PictureInfo 2177 { 2178 using NativeType = StdVideoDecodeH265PictureInfo; 2179 operator StdVideoDecodeH265PictureInfo const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265PictureInfo2180 operator StdVideoDecodeH265PictureInfo const &() const VULKAN_HPP_NOEXCEPT 2181 { 2182 return *reinterpret_cast<const StdVideoDecodeH265PictureInfo *>( this ); 2183 } 2184 operator StdVideoDecodeH265PictureInfo&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265PictureInfo2185 operator StdVideoDecodeH265PictureInfo &() VULKAN_HPP_NOEXCEPT 2186 { 2187 return *reinterpret_cast<StdVideoDecodeH265PictureInfo *>( this ); 2188 } 2189 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265PictureInfo2190 bool operator==( DecodeH265PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT 2191 { 2192 return ( flags == rhs.flags ) && ( sps_video_parameter_set_id == rhs.sps_video_parameter_set_id ) && 2193 ( pps_seq_parameter_set_id == rhs.pps_seq_parameter_set_id ) && ( pps_pic_parameter_set_id == rhs.pps_pic_parameter_set_id ) && 2194 ( NumDeltaPocsOfRefRpsIdx == rhs.NumDeltaPocsOfRefRpsIdx ) && ( PicOrderCntVal == rhs.PicOrderCntVal ) && 2195 ( NumBitsForSTRefPicSetInSlice == rhs.NumBitsForSTRefPicSetInSlice ) && ( reserved == rhs.reserved ) && 2196 ( RefPicSetStCurrBefore == rhs.RefPicSetStCurrBefore ) && ( RefPicSetStCurrAfter == rhs.RefPicSetStCurrAfter ) && 2197 ( RefPicSetLtCurr == rhs.RefPicSetLtCurr ); 2198 } 2199 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265PictureInfo2200 bool operator!=( DecodeH265PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT 2201 { 2202 return !operator==( rhs ); 2203 } 2204 2205 public: 2206 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265PictureInfoFlags flags = {}; 2207 uint8_t sps_video_parameter_set_id = {}; 2208 uint8_t pps_seq_parameter_set_id = {}; 2209 uint8_t pps_pic_parameter_set_id = {}; 2210 uint8_t NumDeltaPocsOfRefRpsIdx = {}; 2211 int32_t PicOrderCntVal = {}; 2212 uint16_t NumBitsForSTRefPicSetInSlice = {}; 2213 uint16_t reserved = {}; 2214 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE> RefPicSetStCurrBefore = {}; 2215 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE> RefPicSetStCurrAfter = {}; 2216 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE> RefPicSetLtCurr = {}; 2217 }; 2218 2219 struct DecodeH265ReferenceInfoFlags 2220 { 2221 using NativeType = StdVideoDecodeH265ReferenceInfoFlags; 2222 operator StdVideoDecodeH265ReferenceInfoFlags const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265ReferenceInfoFlags2223 operator StdVideoDecodeH265ReferenceInfoFlags const &() const VULKAN_HPP_NOEXCEPT 2224 { 2225 return *reinterpret_cast<const StdVideoDecodeH265ReferenceInfoFlags *>( this ); 2226 } 2227 operator StdVideoDecodeH265ReferenceInfoFlags&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265ReferenceInfoFlags2228 operator StdVideoDecodeH265ReferenceInfoFlags &() VULKAN_HPP_NOEXCEPT 2229 { 2230 return *reinterpret_cast<StdVideoDecodeH265ReferenceInfoFlags *>( this ); 2231 } 2232 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265ReferenceInfoFlags2233 bool operator==( DecodeH265ReferenceInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 2234 { 2235 return ( used_for_long_term_reference == rhs.used_for_long_term_reference ) && ( unused_for_reference == rhs.unused_for_reference ); 2236 } 2237 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265ReferenceInfoFlags2238 bool operator!=( DecodeH265ReferenceInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 2239 { 2240 return !operator==( rhs ); 2241 } 2242 2243 public: 2244 uint32_t used_for_long_term_reference : 1; 2245 uint32_t unused_for_reference : 1; 2246 }; 2247 2248 struct DecodeH265ReferenceInfo 2249 { 2250 using NativeType = StdVideoDecodeH265ReferenceInfo; 2251 operator StdVideoDecodeH265ReferenceInfo const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265ReferenceInfo2252 operator StdVideoDecodeH265ReferenceInfo const &() const VULKAN_HPP_NOEXCEPT 2253 { 2254 return *reinterpret_cast<const StdVideoDecodeH265ReferenceInfo *>( this ); 2255 } 2256 operator StdVideoDecodeH265ReferenceInfo&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265ReferenceInfo2257 operator StdVideoDecodeH265ReferenceInfo &() VULKAN_HPP_NOEXCEPT 2258 { 2259 return *reinterpret_cast<StdVideoDecodeH265ReferenceInfo *>( this ); 2260 } 2261 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265ReferenceInfo2262 bool operator==( DecodeH265ReferenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT 2263 { 2264 return ( flags == rhs.flags ) && ( PicOrderCntVal == rhs.PicOrderCntVal ); 2265 } 2266 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265ReferenceInfo2267 bool operator!=( DecodeH265ReferenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT 2268 { 2269 return !operator==( rhs ); 2270 } 2271 2272 public: 2273 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265ReferenceInfoFlags flags = {}; 2274 int32_t PicOrderCntVal = {}; 2275 }; 2276 2277 //=== vulkan_video_codec_h265std_encode === 2278 2279 struct EncodeH265WeightTableFlags 2280 { 2281 using NativeType = StdVideoEncodeH265WeightTableFlags; 2282 operator StdVideoEncodeH265WeightTableFlags const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265WeightTableFlags2283 operator StdVideoEncodeH265WeightTableFlags const &() const VULKAN_HPP_NOEXCEPT 2284 { 2285 return *reinterpret_cast<const StdVideoEncodeH265WeightTableFlags *>( this ); 2286 } 2287 operator StdVideoEncodeH265WeightTableFlags&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265WeightTableFlags2288 operator StdVideoEncodeH265WeightTableFlags &() VULKAN_HPP_NOEXCEPT 2289 { 2290 return *reinterpret_cast<StdVideoEncodeH265WeightTableFlags *>( this ); 2291 } 2292 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265WeightTableFlags2293 bool operator==( EncodeH265WeightTableFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 2294 { 2295 return ( luma_weight_l0_flag == rhs.luma_weight_l0_flag ) && ( chroma_weight_l0_flag == rhs.chroma_weight_l0_flag ) && 2296 ( luma_weight_l1_flag == rhs.luma_weight_l1_flag ) && ( chroma_weight_l1_flag == rhs.chroma_weight_l1_flag ); 2297 } 2298 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265WeightTableFlags2299 bool operator!=( EncodeH265WeightTableFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 2300 { 2301 return !operator==( rhs ); 2302 } 2303 2304 public: 2305 uint16_t luma_weight_l0_flag = {}; 2306 uint16_t chroma_weight_l0_flag = {}; 2307 uint16_t luma_weight_l1_flag = {}; 2308 uint16_t chroma_weight_l1_flag = {}; 2309 }; 2310 2311 struct EncodeH265WeightTable 2312 { 2313 using NativeType = StdVideoEncodeH265WeightTable; 2314 operator StdVideoEncodeH265WeightTable const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265WeightTable2315 operator StdVideoEncodeH265WeightTable const &() const VULKAN_HPP_NOEXCEPT 2316 { 2317 return *reinterpret_cast<const StdVideoEncodeH265WeightTable *>( this ); 2318 } 2319 operator StdVideoEncodeH265WeightTable&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265WeightTable2320 operator StdVideoEncodeH265WeightTable &() VULKAN_HPP_NOEXCEPT 2321 { 2322 return *reinterpret_cast<StdVideoEncodeH265WeightTable *>( this ); 2323 } 2324 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265WeightTable2325 bool operator==( EncodeH265WeightTable const & rhs ) const VULKAN_HPP_NOEXCEPT 2326 { 2327 return ( flags == rhs.flags ) && ( luma_log2_weight_denom == rhs.luma_log2_weight_denom ) && 2328 ( delta_chroma_log2_weight_denom == rhs.delta_chroma_log2_weight_denom ) && ( delta_luma_weight_l0 == rhs.delta_luma_weight_l0 ) && 2329 ( luma_offset_l0 == rhs.luma_offset_l0 ) && ( delta_chroma_weight_l0 == rhs.delta_chroma_weight_l0 ) && 2330 ( delta_chroma_offset_l0 == rhs.delta_chroma_offset_l0 ) && ( delta_luma_weight_l1 == rhs.delta_luma_weight_l1 ) && 2331 ( luma_offset_l1 == rhs.luma_offset_l1 ) && ( delta_chroma_weight_l1 == rhs.delta_chroma_weight_l1 ) && 2332 ( delta_chroma_offset_l1 == rhs.delta_chroma_offset_l1 ); 2333 } 2334 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265WeightTable2335 bool operator!=( EncodeH265WeightTable const & rhs ) const VULKAN_HPP_NOEXCEPT 2336 { 2337 return !operator==( rhs ); 2338 } 2339 2340 public: 2341 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265WeightTableFlags flags = {}; 2342 uint8_t luma_log2_weight_denom = {}; 2343 int8_t delta_chroma_log2_weight_denom = {}; 2344 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<int8_t, STD_VIDEO_H265_MAX_NUM_LIST_REF> delta_luma_weight_l0 = {}; 2345 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<int8_t, STD_VIDEO_H265_MAX_NUM_LIST_REF> luma_offset_l0 = {}; 2346 VULKAN_HPP_NAMESPACE::ArrayWrapper2D<int8_t, STD_VIDEO_H265_MAX_NUM_LIST_REF, STD_VIDEO_H265_MAX_CHROMA_PLANES> delta_chroma_weight_l0 = {}; 2347 VULKAN_HPP_NAMESPACE::ArrayWrapper2D<int8_t, STD_VIDEO_H265_MAX_NUM_LIST_REF, STD_VIDEO_H265_MAX_CHROMA_PLANES> delta_chroma_offset_l0 = {}; 2348 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<int8_t, STD_VIDEO_H265_MAX_NUM_LIST_REF> delta_luma_weight_l1 = {}; 2349 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<int8_t, STD_VIDEO_H265_MAX_NUM_LIST_REF> luma_offset_l1 = {}; 2350 VULKAN_HPP_NAMESPACE::ArrayWrapper2D<int8_t, STD_VIDEO_H265_MAX_NUM_LIST_REF, STD_VIDEO_H265_MAX_CHROMA_PLANES> delta_chroma_weight_l1 = {}; 2351 VULKAN_HPP_NAMESPACE::ArrayWrapper2D<int8_t, STD_VIDEO_H265_MAX_NUM_LIST_REF, STD_VIDEO_H265_MAX_CHROMA_PLANES> delta_chroma_offset_l1 = {}; 2352 }; 2353 2354 struct EncodeH265SliceSegmentHeaderFlags 2355 { 2356 using NativeType = StdVideoEncodeH265SliceSegmentHeaderFlags; 2357 operator StdVideoEncodeH265SliceSegmentHeaderFlags const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265SliceSegmentHeaderFlags2358 operator StdVideoEncodeH265SliceSegmentHeaderFlags const &() const VULKAN_HPP_NOEXCEPT 2359 { 2360 return *reinterpret_cast<const StdVideoEncodeH265SliceSegmentHeaderFlags *>( this ); 2361 } 2362 operator StdVideoEncodeH265SliceSegmentHeaderFlags&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265SliceSegmentHeaderFlags2363 operator StdVideoEncodeH265SliceSegmentHeaderFlags &() VULKAN_HPP_NOEXCEPT 2364 { 2365 return *reinterpret_cast<StdVideoEncodeH265SliceSegmentHeaderFlags *>( this ); 2366 } 2367 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265SliceSegmentHeaderFlags2368 bool operator==( EncodeH265SliceSegmentHeaderFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 2369 { 2370 return ( first_slice_segment_in_pic_flag == rhs.first_slice_segment_in_pic_flag ) && 2371 ( dependent_slice_segment_flag == rhs.dependent_slice_segment_flag ) && ( slice_sao_luma_flag == rhs.slice_sao_luma_flag ) && 2372 ( slice_sao_chroma_flag == rhs.slice_sao_chroma_flag ) && ( num_ref_idx_active_override_flag == rhs.num_ref_idx_active_override_flag ) && 2373 ( mvd_l1_zero_flag == rhs.mvd_l1_zero_flag ) && ( cabac_init_flag == rhs.cabac_init_flag ) && 2374 ( cu_chroma_qp_offset_enabled_flag == rhs.cu_chroma_qp_offset_enabled_flag ) && 2375 ( deblocking_filter_override_flag == rhs.deblocking_filter_override_flag ) && 2376 ( slice_deblocking_filter_disabled_flag == rhs.slice_deblocking_filter_disabled_flag ) && 2377 ( collocated_from_l0_flag == rhs.collocated_from_l0_flag ) && 2378 ( slice_loop_filter_across_slices_enabled_flag == rhs.slice_loop_filter_across_slices_enabled_flag ) && ( reserved == rhs.reserved ); 2379 } 2380 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265SliceSegmentHeaderFlags2381 bool operator!=( EncodeH265SliceSegmentHeaderFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 2382 { 2383 return !operator==( rhs ); 2384 } 2385 2386 public: 2387 uint32_t first_slice_segment_in_pic_flag : 1; 2388 uint32_t dependent_slice_segment_flag : 1; 2389 uint32_t slice_sao_luma_flag : 1; 2390 uint32_t slice_sao_chroma_flag : 1; 2391 uint32_t num_ref_idx_active_override_flag : 1; 2392 uint32_t mvd_l1_zero_flag : 1; 2393 uint32_t cabac_init_flag : 1; 2394 uint32_t cu_chroma_qp_offset_enabled_flag : 1; 2395 uint32_t deblocking_filter_override_flag : 1; 2396 uint32_t slice_deblocking_filter_disabled_flag : 1; 2397 uint32_t collocated_from_l0_flag : 1; 2398 uint32_t slice_loop_filter_across_slices_enabled_flag : 1; 2399 uint32_t reserved : 20; 2400 }; 2401 2402 struct EncodeH265SliceSegmentHeader 2403 { 2404 using NativeType = StdVideoEncodeH265SliceSegmentHeader; 2405 operator StdVideoEncodeH265SliceSegmentHeader const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265SliceSegmentHeader2406 operator StdVideoEncodeH265SliceSegmentHeader const &() const VULKAN_HPP_NOEXCEPT 2407 { 2408 return *reinterpret_cast<const StdVideoEncodeH265SliceSegmentHeader *>( this ); 2409 } 2410 operator StdVideoEncodeH265SliceSegmentHeader&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265SliceSegmentHeader2411 operator StdVideoEncodeH265SliceSegmentHeader &() VULKAN_HPP_NOEXCEPT 2412 { 2413 return *reinterpret_cast<StdVideoEncodeH265SliceSegmentHeader *>( this ); 2414 } 2415 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265SliceSegmentHeader2416 bool operator==( EncodeH265SliceSegmentHeader const & rhs ) const VULKAN_HPP_NOEXCEPT 2417 { 2418 return ( flags == rhs.flags ) && ( slice_type == rhs.slice_type ) && ( slice_segment_address == rhs.slice_segment_address ) && 2419 ( collocated_ref_idx == rhs.collocated_ref_idx ) && ( MaxNumMergeCand == rhs.MaxNumMergeCand ) && 2420 ( slice_cb_qp_offset == rhs.slice_cb_qp_offset ) && ( slice_cr_qp_offset == rhs.slice_cr_qp_offset ) && 2421 ( slice_beta_offset_div2 == rhs.slice_beta_offset_div2 ) && ( slice_tc_offset_div2 == rhs.slice_tc_offset_div2 ) && 2422 ( slice_act_y_qp_offset == rhs.slice_act_y_qp_offset ) && ( slice_act_cb_qp_offset == rhs.slice_act_cb_qp_offset ) && 2423 ( slice_act_cr_qp_offset == rhs.slice_act_cr_qp_offset ) && ( slice_qp_delta == rhs.slice_qp_delta ) && ( reserved1 == rhs.reserved1 ) && 2424 ( pWeightTable == rhs.pWeightTable ); 2425 } 2426 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265SliceSegmentHeader2427 bool operator!=( EncodeH265SliceSegmentHeader const & rhs ) const VULKAN_HPP_NOEXCEPT 2428 { 2429 return !operator==( rhs ); 2430 } 2431 2432 public: 2433 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265SliceSegmentHeaderFlags flags = {}; 2434 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SliceType slice_type = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SliceType::eB; 2435 uint32_t slice_segment_address = {}; 2436 uint8_t collocated_ref_idx = {}; 2437 uint8_t MaxNumMergeCand = {}; 2438 int8_t slice_cb_qp_offset = {}; 2439 int8_t slice_cr_qp_offset = {}; 2440 int8_t slice_beta_offset_div2 = {}; 2441 int8_t slice_tc_offset_div2 = {}; 2442 int8_t slice_act_y_qp_offset = {}; 2443 int8_t slice_act_cb_qp_offset = {}; 2444 int8_t slice_act_cr_qp_offset = {}; 2445 int8_t slice_qp_delta = {}; 2446 uint16_t reserved1 = {}; 2447 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265WeightTable * pWeightTable = {}; 2448 }; 2449 2450 struct EncodeH265ReferenceListsInfoFlags 2451 { 2452 using NativeType = StdVideoEncodeH265ReferenceListsInfoFlags; 2453 operator StdVideoEncodeH265ReferenceListsInfoFlags const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceListsInfoFlags2454 operator StdVideoEncodeH265ReferenceListsInfoFlags const &() const VULKAN_HPP_NOEXCEPT 2455 { 2456 return *reinterpret_cast<const StdVideoEncodeH265ReferenceListsInfoFlags *>( this ); 2457 } 2458 operator StdVideoEncodeH265ReferenceListsInfoFlags&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceListsInfoFlags2459 operator StdVideoEncodeH265ReferenceListsInfoFlags &() VULKAN_HPP_NOEXCEPT 2460 { 2461 return *reinterpret_cast<StdVideoEncodeH265ReferenceListsInfoFlags *>( this ); 2462 } 2463 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceListsInfoFlags2464 bool operator==( EncodeH265ReferenceListsInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 2465 { 2466 return ( ref_pic_list_modification_flag_l0 == rhs.ref_pic_list_modification_flag_l0 ) && 2467 ( ref_pic_list_modification_flag_l1 == rhs.ref_pic_list_modification_flag_l1 ) && ( reserved == rhs.reserved ); 2468 } 2469 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceListsInfoFlags2470 bool operator!=( EncodeH265ReferenceListsInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 2471 { 2472 return !operator==( rhs ); 2473 } 2474 2475 public: 2476 uint32_t ref_pic_list_modification_flag_l0 : 1; 2477 uint32_t ref_pic_list_modification_flag_l1 : 1; 2478 uint32_t reserved : 30; 2479 }; 2480 2481 struct EncodeH265ReferenceListsInfo 2482 { 2483 using NativeType = StdVideoEncodeH265ReferenceListsInfo; 2484 operator StdVideoEncodeH265ReferenceListsInfo const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceListsInfo2485 operator StdVideoEncodeH265ReferenceListsInfo const &() const VULKAN_HPP_NOEXCEPT 2486 { 2487 return *reinterpret_cast<const StdVideoEncodeH265ReferenceListsInfo *>( this ); 2488 } 2489 operator StdVideoEncodeH265ReferenceListsInfo&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceListsInfo2490 operator StdVideoEncodeH265ReferenceListsInfo &() VULKAN_HPP_NOEXCEPT 2491 { 2492 return *reinterpret_cast<StdVideoEncodeH265ReferenceListsInfo *>( this ); 2493 } 2494 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceListsInfo2495 bool operator==( EncodeH265ReferenceListsInfo const & rhs ) const VULKAN_HPP_NOEXCEPT 2496 { 2497 return ( flags == rhs.flags ) && ( num_ref_idx_l0_active_minus1 == rhs.num_ref_idx_l0_active_minus1 ) && 2498 ( num_ref_idx_l1_active_minus1 == rhs.num_ref_idx_l1_active_minus1 ) && ( RefPicList0 == rhs.RefPicList0 ) && 2499 ( RefPicList1 == rhs.RefPicList1 ) && ( list_entry_l0 == rhs.list_entry_l0 ) && ( list_entry_l1 == rhs.list_entry_l1 ); 2500 } 2501 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceListsInfo2502 bool operator!=( EncodeH265ReferenceListsInfo const & rhs ) const VULKAN_HPP_NOEXCEPT 2503 { 2504 return !operator==( rhs ); 2505 } 2506 2507 public: 2508 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceListsInfoFlags flags = {}; 2509 uint8_t num_ref_idx_l0_active_minus1 = {}; 2510 uint8_t num_ref_idx_l1_active_minus1 = {}; 2511 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_H265_MAX_NUM_LIST_REF> RefPicList0 = {}; 2512 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_H265_MAX_NUM_LIST_REF> RefPicList1 = {}; 2513 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_H265_MAX_NUM_LIST_REF> list_entry_l0 = {}; 2514 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_H265_MAX_NUM_LIST_REF> list_entry_l1 = {}; 2515 }; 2516 2517 struct EncodeH265PictureInfoFlags 2518 { 2519 using NativeType = StdVideoEncodeH265PictureInfoFlags; 2520 operator StdVideoEncodeH265PictureInfoFlags const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265PictureInfoFlags2521 operator StdVideoEncodeH265PictureInfoFlags const &() const VULKAN_HPP_NOEXCEPT 2522 { 2523 return *reinterpret_cast<const StdVideoEncodeH265PictureInfoFlags *>( this ); 2524 } 2525 operator StdVideoEncodeH265PictureInfoFlags&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265PictureInfoFlags2526 operator StdVideoEncodeH265PictureInfoFlags &() VULKAN_HPP_NOEXCEPT 2527 { 2528 return *reinterpret_cast<StdVideoEncodeH265PictureInfoFlags *>( this ); 2529 } 2530 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265PictureInfoFlags2531 bool operator==( EncodeH265PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 2532 { 2533 return ( is_reference == rhs.is_reference ) && ( IrapPicFlag == rhs.IrapPicFlag ) && 2534 ( used_for_long_term_reference == rhs.used_for_long_term_reference ) && ( discardable_flag == rhs.discardable_flag ) && 2535 ( cross_layer_bla_flag == rhs.cross_layer_bla_flag ) && ( pic_output_flag == rhs.pic_output_flag ) && 2536 ( no_output_of_prior_pics_flag == rhs.no_output_of_prior_pics_flag ) && 2537 ( short_term_ref_pic_set_sps_flag == rhs.short_term_ref_pic_set_sps_flag ) && 2538 ( slice_temporal_mvp_enabled_flag == rhs.slice_temporal_mvp_enabled_flag ) && ( reserved == rhs.reserved ); 2539 } 2540 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265PictureInfoFlags2541 bool operator!=( EncodeH265PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 2542 { 2543 return !operator==( rhs ); 2544 } 2545 2546 public: 2547 uint32_t is_reference : 1; 2548 uint32_t IrapPicFlag : 1; 2549 uint32_t used_for_long_term_reference : 1; 2550 uint32_t discardable_flag : 1; 2551 uint32_t cross_layer_bla_flag : 1; 2552 uint32_t pic_output_flag : 1; 2553 uint32_t no_output_of_prior_pics_flag : 1; 2554 uint32_t short_term_ref_pic_set_sps_flag : 1; 2555 uint32_t slice_temporal_mvp_enabled_flag : 1; 2556 uint32_t reserved : 23; 2557 }; 2558 2559 struct EncodeH265LongTermRefPics 2560 { 2561 using NativeType = StdVideoEncodeH265LongTermRefPics; 2562 operator StdVideoEncodeH265LongTermRefPics const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265LongTermRefPics2563 operator StdVideoEncodeH265LongTermRefPics const &() const VULKAN_HPP_NOEXCEPT 2564 { 2565 return *reinterpret_cast<const StdVideoEncodeH265LongTermRefPics *>( this ); 2566 } 2567 operator StdVideoEncodeH265LongTermRefPics&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265LongTermRefPics2568 operator StdVideoEncodeH265LongTermRefPics &() VULKAN_HPP_NOEXCEPT 2569 { 2570 return *reinterpret_cast<StdVideoEncodeH265LongTermRefPics *>( this ); 2571 } 2572 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265LongTermRefPics2573 bool operator==( EncodeH265LongTermRefPics const & rhs ) const VULKAN_HPP_NOEXCEPT 2574 { 2575 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 ) && 2576 ( poc_lsb_lt == rhs.poc_lsb_lt ) && ( used_by_curr_pic_lt_flag == rhs.used_by_curr_pic_lt_flag ) && 2577 ( delta_poc_msb_present_flag == rhs.delta_poc_msb_present_flag ) && ( delta_poc_msb_cycle_lt == rhs.delta_poc_msb_cycle_lt ); 2578 } 2579 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265LongTermRefPics2580 bool operator!=( EncodeH265LongTermRefPics const & rhs ) const VULKAN_HPP_NOEXCEPT 2581 { 2582 return !operator==( rhs ); 2583 } 2584 2585 public: 2586 uint8_t num_long_term_sps = {}; 2587 uint8_t num_long_term_pics = {}; 2588 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_H265_MAX_LONG_TERM_REF_PICS_SPS> lt_idx_sps = {}; 2589 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_H265_MAX_LONG_TERM_PICS> poc_lsb_lt = {}; 2590 uint16_t used_by_curr_pic_lt_flag = {}; 2591 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_H265_MAX_DELTA_POC> delta_poc_msb_present_flag = {}; 2592 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_H265_MAX_DELTA_POC> delta_poc_msb_cycle_lt = {}; 2593 }; 2594 2595 struct EncodeH265PictureInfo 2596 { 2597 using NativeType = StdVideoEncodeH265PictureInfo; 2598 operator StdVideoEncodeH265PictureInfo const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265PictureInfo2599 operator StdVideoEncodeH265PictureInfo const &() const VULKAN_HPP_NOEXCEPT 2600 { 2601 return *reinterpret_cast<const StdVideoEncodeH265PictureInfo *>( this ); 2602 } 2603 operator StdVideoEncodeH265PictureInfo&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265PictureInfo2604 operator StdVideoEncodeH265PictureInfo &() VULKAN_HPP_NOEXCEPT 2605 { 2606 return *reinterpret_cast<StdVideoEncodeH265PictureInfo *>( this ); 2607 } 2608 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265PictureInfo2609 bool operator==( EncodeH265PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT 2610 { 2611 return ( flags == rhs.flags ) && ( pic_type == rhs.pic_type ) && ( sps_video_parameter_set_id == rhs.sps_video_parameter_set_id ) && 2612 ( pps_seq_parameter_set_id == rhs.pps_seq_parameter_set_id ) && ( pps_pic_parameter_set_id == rhs.pps_pic_parameter_set_id ) && 2613 ( short_term_ref_pic_set_idx == rhs.short_term_ref_pic_set_idx ) && ( PicOrderCntVal == rhs.PicOrderCntVal ) && 2614 ( TemporalId == rhs.TemporalId ) && ( reserved1 == rhs.reserved1 ) && ( pRefLists == rhs.pRefLists ) && 2615 ( pShortTermRefPicSet == rhs.pShortTermRefPicSet ) && ( pLongTermRefPics == rhs.pLongTermRefPics ); 2616 } 2617 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265PictureInfo2618 bool operator!=( EncodeH265PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT 2619 { 2620 return !operator==( rhs ); 2621 } 2622 2623 public: 2624 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265PictureInfoFlags flags = {}; 2625 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PictureType pic_type = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PictureType::eP; 2626 uint8_t sps_video_parameter_set_id = {}; 2627 uint8_t pps_seq_parameter_set_id = {}; 2628 uint8_t pps_pic_parameter_set_id = {}; 2629 uint8_t short_term_ref_pic_set_idx = {}; 2630 int32_t PicOrderCntVal = {}; 2631 uint8_t TemporalId = {}; 2632 VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, 7> reserved1 = {}; 2633 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceListsInfo * pRefLists = {}; 2634 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ShortTermRefPicSet * pShortTermRefPicSet = {}; 2635 const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265LongTermRefPics * pLongTermRefPics = {}; 2636 }; 2637 2638 struct EncodeH265ReferenceInfoFlags 2639 { 2640 using NativeType = StdVideoEncodeH265ReferenceInfoFlags; 2641 operator StdVideoEncodeH265ReferenceInfoFlags const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceInfoFlags2642 operator StdVideoEncodeH265ReferenceInfoFlags const &() const VULKAN_HPP_NOEXCEPT 2643 { 2644 return *reinterpret_cast<const StdVideoEncodeH265ReferenceInfoFlags *>( this ); 2645 } 2646 operator StdVideoEncodeH265ReferenceInfoFlags&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceInfoFlags2647 operator StdVideoEncodeH265ReferenceInfoFlags &() VULKAN_HPP_NOEXCEPT 2648 { 2649 return *reinterpret_cast<StdVideoEncodeH265ReferenceInfoFlags *>( this ); 2650 } 2651 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceInfoFlags2652 bool operator==( EncodeH265ReferenceInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 2653 { 2654 return ( used_for_long_term_reference == rhs.used_for_long_term_reference ) && ( unused_for_reference == rhs.unused_for_reference ) && 2655 ( reserved == rhs.reserved ); 2656 } 2657 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceInfoFlags2658 bool operator!=( EncodeH265ReferenceInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT 2659 { 2660 return !operator==( rhs ); 2661 } 2662 2663 public: 2664 uint32_t used_for_long_term_reference : 1; 2665 uint32_t unused_for_reference : 1; 2666 uint32_t reserved : 30; 2667 }; 2668 2669 struct EncodeH265ReferenceInfo 2670 { 2671 using NativeType = StdVideoEncodeH265ReferenceInfo; 2672 operator StdVideoEncodeH265ReferenceInfo const&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceInfo2673 operator StdVideoEncodeH265ReferenceInfo const &() const VULKAN_HPP_NOEXCEPT 2674 { 2675 return *reinterpret_cast<const StdVideoEncodeH265ReferenceInfo *>( this ); 2676 } 2677 operator StdVideoEncodeH265ReferenceInfo&VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceInfo2678 operator StdVideoEncodeH265ReferenceInfo &() VULKAN_HPP_NOEXCEPT 2679 { 2680 return *reinterpret_cast<StdVideoEncodeH265ReferenceInfo *>( this ); 2681 } 2682 operator ==VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceInfo2683 bool operator==( EncodeH265ReferenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT 2684 { 2685 return ( flags == rhs.flags ) && ( pic_type == rhs.pic_type ) && ( PicOrderCntVal == rhs.PicOrderCntVal ) && ( TemporalId == rhs.TemporalId ); 2686 } 2687 operator !=VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceInfo2688 bool operator!=( EncodeH265ReferenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT 2689 { 2690 return !operator==( rhs ); 2691 } 2692 2693 public: 2694 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceInfoFlags flags = {}; 2695 VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PictureType pic_type = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PictureType::eP; 2696 int32_t PicOrderCntVal = {}; 2697 uint8_t TemporalId = {}; 2698 }; 2699 2700 } // namespace VULKAN_HPP_VIDEO_NAMESPACE 2701 } // namespace VULKAN_HPP_NAMESPACE 2702 #endif 2703