Vulkan-Hpp
vulkan_video.hpp
Go to the documentation of this file.
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 
279  operator StdVideoH264SpsVuiFlags const &() const VULKAN_HPP_NOEXCEPT
280  {
281  return *reinterpret_cast<const StdVideoH264SpsVuiFlags *>( this );
282  }
283 
284  operator StdVideoH264SpsVuiFlags &() VULKAN_HPP_NOEXCEPT
285  {
286  return *reinterpret_cast<StdVideoH264SpsVuiFlags *>( this );
287  }
288 
289  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 
300  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 
324  operator StdVideoH264HrdParameters const &() const VULKAN_HPP_NOEXCEPT
325  {
326  return *reinterpret_cast<const StdVideoH264HrdParameters *>( this );
327  }
328 
329  operator StdVideoH264HrdParameters &() VULKAN_HPP_NOEXCEPT
330  {
331  return *reinterpret_cast<StdVideoH264HrdParameters *>( this );
332  }
333 
334  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 
344  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 
367  operator StdVideoH264SequenceParameterSetVui const &() const VULKAN_HPP_NOEXCEPT
368  {
369  return *reinterpret_cast<const StdVideoH264SequenceParameterSetVui *>( this );
370  }
371 
372  operator StdVideoH264SequenceParameterSetVui &() VULKAN_HPP_NOEXCEPT
373  {
374  return *reinterpret_cast<StdVideoH264SequenceParameterSetVui *>( this );
375  }
376 
377  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 
388  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 
417  operator StdVideoH264SpsFlags const &() const VULKAN_HPP_NOEXCEPT
418  {
419  return *reinterpret_cast<const StdVideoH264SpsFlags *>( this );
420  }
421 
422  operator StdVideoH264SpsFlags &() VULKAN_HPP_NOEXCEPT
423  {
424  return *reinterpret_cast<StdVideoH264SpsFlags *>( this );
425  }
426 
427  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 
440  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 
468  operator StdVideoH264ScalingLists const &() const VULKAN_HPP_NOEXCEPT
469  {
470  return *reinterpret_cast<const StdVideoH264ScalingLists *>( this );
471  }
472 
473  operator StdVideoH264ScalingLists &() VULKAN_HPP_NOEXCEPT
474  {
475  return *reinterpret_cast<StdVideoH264ScalingLists *>( this );
476  }
477 
478  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 
484  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 
502  operator StdVideoH264SequenceParameterSet const &() const VULKAN_HPP_NOEXCEPT
503  {
504  return *reinterpret_cast<const StdVideoH264SequenceParameterSet *>( this );
505  }
506 
507  operator StdVideoH264SequenceParameterSet &() VULKAN_HPP_NOEXCEPT
508  {
509  return *reinterpret_cast<StdVideoH264SequenceParameterSet *>( this );
510  }
511 
512  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 
529  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 
568  operator StdVideoH264PpsFlags const &() const VULKAN_HPP_NOEXCEPT
569  {
570  return *reinterpret_cast<const StdVideoH264PpsFlags *>( this );
571  }
572 
573  operator StdVideoH264PpsFlags &() VULKAN_HPP_NOEXCEPT
574  {
575  return *reinterpret_cast<StdVideoH264PpsFlags *>( this );
576  }
577 
578  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 
587  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 
607  operator StdVideoH264PictureParameterSet const &() const VULKAN_HPP_NOEXCEPT
608  {
609  return *reinterpret_cast<const StdVideoH264PictureParameterSet *>( this );
610  }
611 
612  operator StdVideoH264PictureParameterSet &() VULKAN_HPP_NOEXCEPT
613  {
614  return *reinterpret_cast<StdVideoH264PictureParameterSet *>( this );
615  }
616 
617  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 
627  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 
653  operator StdVideoDecodeH264PictureInfoFlags const &() const VULKAN_HPP_NOEXCEPT
654  {
655  return *reinterpret_cast<const StdVideoDecodeH264PictureInfoFlags *>( this );
656  }
657 
658  operator StdVideoDecodeH264PictureInfoFlags &() VULKAN_HPP_NOEXCEPT
659  {
660  return *reinterpret_cast<StdVideoDecodeH264PictureInfoFlags *>( this );
661  }
662 
663  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 
670  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 
688  operator StdVideoDecodeH264PictureInfo const &() const VULKAN_HPP_NOEXCEPT
689  {
690  return *reinterpret_cast<const StdVideoDecodeH264PictureInfo *>( this );
691  }
692 
693  operator StdVideoDecodeH264PictureInfo &() VULKAN_HPP_NOEXCEPT
694  {
695  return *reinterpret_cast<StdVideoDecodeH264PictureInfo *>( this );
696  }
697 
698  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 
705  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 
725  operator StdVideoDecodeH264ReferenceInfoFlags const &() const VULKAN_HPP_NOEXCEPT
726  {
727  return *reinterpret_cast<const StdVideoDecodeH264ReferenceInfoFlags *>( this );
728  }
729 
730  operator StdVideoDecodeH264ReferenceInfoFlags &() VULKAN_HPP_NOEXCEPT
731  {
732  return *reinterpret_cast<StdVideoDecodeH264ReferenceInfoFlags *>( this );
733  }
734 
735  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 
741  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 
757  operator StdVideoDecodeH264ReferenceInfo const &() const VULKAN_HPP_NOEXCEPT
758  {
759  return *reinterpret_cast<const StdVideoDecodeH264ReferenceInfo *>( this );
760  }
761 
762  operator StdVideoDecodeH264ReferenceInfo &() VULKAN_HPP_NOEXCEPT
763  {
764  return *reinterpret_cast<StdVideoDecodeH264ReferenceInfo *>( this );
765  }
766 
767  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 
772  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 
790  operator StdVideoEncodeH264WeightTableFlags const &() const VULKAN_HPP_NOEXCEPT
791  {
792  return *reinterpret_cast<const StdVideoEncodeH264WeightTableFlags *>( this );
793  }
794 
795  operator StdVideoEncodeH264WeightTableFlags &() VULKAN_HPP_NOEXCEPT
796  {
797  return *reinterpret_cast<StdVideoEncodeH264WeightTableFlags *>( this );
798  }
799 
800  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 
806  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 
822  operator StdVideoEncodeH264WeightTable const &() const VULKAN_HPP_NOEXCEPT
823  {
824  return *reinterpret_cast<const StdVideoEncodeH264WeightTable *>( this );
825  }
826 
827  operator StdVideoEncodeH264WeightTable &() VULKAN_HPP_NOEXCEPT
828  {
829  return *reinterpret_cast<StdVideoEncodeH264WeightTable *>( this );
830  }
831 
832  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 
841  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 
864  operator StdVideoEncodeH264SliceHeaderFlags const &() const VULKAN_HPP_NOEXCEPT
865  {
866  return *reinterpret_cast<const StdVideoEncodeH264SliceHeaderFlags *>( this );
867  }
868 
869  operator StdVideoEncodeH264SliceHeaderFlags &() VULKAN_HPP_NOEXCEPT
870  {
871  return *reinterpret_cast<StdVideoEncodeH264SliceHeaderFlags *>( this );
872  }
873 
874  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 
880  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 
895  operator StdVideoEncodeH264PictureInfoFlags const &() const VULKAN_HPP_NOEXCEPT
896  {
897  return *reinterpret_cast<const StdVideoEncodeH264PictureInfoFlags *>( this );
898  }
899 
900  operator StdVideoEncodeH264PictureInfoFlags &() VULKAN_HPP_NOEXCEPT
901  {
902  return *reinterpret_cast<StdVideoEncodeH264PictureInfoFlags *>( this );
903  }
904 
905  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 
912  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 
930  operator StdVideoEncodeH264ReferenceInfoFlags const &() const VULKAN_HPP_NOEXCEPT
931  {
932  return *reinterpret_cast<const StdVideoEncodeH264ReferenceInfoFlags *>( this );
933  }
934 
935  operator StdVideoEncodeH264ReferenceInfoFlags &() VULKAN_HPP_NOEXCEPT
936  {
937  return *reinterpret_cast<StdVideoEncodeH264ReferenceInfoFlags *>( this );
938  }
939 
940  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 
945  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 
959  operator StdVideoEncodeH264ReferenceListsInfoFlags const &() const VULKAN_HPP_NOEXCEPT
960  {
961  return *reinterpret_cast<const StdVideoEncodeH264ReferenceListsInfoFlags *>( this );
962  }
963 
964  operator StdVideoEncodeH264ReferenceListsInfoFlags &() VULKAN_HPP_NOEXCEPT
965  {
966  return *reinterpret_cast<StdVideoEncodeH264ReferenceListsInfoFlags *>( this );
967  }
968 
969  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 
975  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 
990  operator StdVideoEncodeH264RefListModEntry const &() const VULKAN_HPP_NOEXCEPT
991  {
992  return *reinterpret_cast<const StdVideoEncodeH264RefListModEntry *>( this );
993  }
994 
995  operator StdVideoEncodeH264RefListModEntry &() VULKAN_HPP_NOEXCEPT
996  {
997  return *reinterpret_cast<StdVideoEncodeH264RefListModEntry *>( this );
998  }
999 
1000  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 
1006  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 
1022  operator StdVideoEncodeH264RefPicMarkingEntry const &() const VULKAN_HPP_NOEXCEPT
1023  {
1024  return *reinterpret_cast<const StdVideoEncodeH264RefPicMarkingEntry *>( this );
1025  }
1026 
1027  operator StdVideoEncodeH264RefPicMarkingEntry &() VULKAN_HPP_NOEXCEPT
1028  {
1029  return *reinterpret_cast<StdVideoEncodeH264RefPicMarkingEntry *>( this );
1030  }
1031 
1032  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 
1039  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 
1057  operator StdVideoEncodeH264ReferenceListsInfo const &() const VULKAN_HPP_NOEXCEPT
1058  {
1059  return *reinterpret_cast<const StdVideoEncodeH264ReferenceListsInfo *>( this );
1060  }
1061 
1062  operator StdVideoEncodeH264ReferenceListsInfo &() VULKAN_HPP_NOEXCEPT
1063  {
1064  return *reinterpret_cast<StdVideoEncodeH264ReferenceListsInfo *>( this );
1065  }
1066 
1067  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 
1077  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 
1101  operator StdVideoEncodeH264PictureInfo const &() const VULKAN_HPP_NOEXCEPT
1102  {
1103  return *reinterpret_cast<const StdVideoEncodeH264PictureInfo *>( this );
1104  }
1105 
1106  operator StdVideoEncodeH264PictureInfo &() VULKAN_HPP_NOEXCEPT
1107  {
1108  return *reinterpret_cast<StdVideoEncodeH264PictureInfo *>( this );
1109  }
1110 
1111  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 
1118  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 
1141  operator StdVideoEncodeH264ReferenceInfo const &() const VULKAN_HPP_NOEXCEPT
1142  {
1143  return *reinterpret_cast<const StdVideoEncodeH264ReferenceInfo *>( this );
1144  }
1145 
1146  operator StdVideoEncodeH264ReferenceInfo &() VULKAN_HPP_NOEXCEPT
1147  {
1148  return *reinterpret_cast<StdVideoEncodeH264ReferenceInfo *>( this );
1149  }
1150 
1151  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 
1157  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 
1177  operator StdVideoEncodeH264SliceHeader const &() const VULKAN_HPP_NOEXCEPT
1178  {
1179  return *reinterpret_cast<const StdVideoEncodeH264SliceHeader *>( this );
1180  }
1181 
1182  operator StdVideoEncodeH264SliceHeader &() VULKAN_HPP_NOEXCEPT
1183  {
1184  return *reinterpret_cast<StdVideoEncodeH264SliceHeader *>( this );
1185  }
1186 
1187  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 
1195  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 
1221  operator StdVideoH265DecPicBufMgr const &() const VULKAN_HPP_NOEXCEPT
1222  {
1223  return *reinterpret_cast<const StdVideoH265DecPicBufMgr *>( this );
1224  }
1225 
1226  operator StdVideoH265DecPicBufMgr &() VULKAN_HPP_NOEXCEPT
1227  {
1228  return *reinterpret_cast<StdVideoH265DecPicBufMgr *>( this );
1229  }
1230 
1231  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 
1237  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 
1252  operator StdVideoH265SubLayerHrdParameters const &() const VULKAN_HPP_NOEXCEPT
1253  {
1254  return *reinterpret_cast<const StdVideoH265SubLayerHrdParameters *>( this );
1255  }
1256 
1257  operator StdVideoH265SubLayerHrdParameters &() VULKAN_HPP_NOEXCEPT
1258  {
1259  return *reinterpret_cast<StdVideoH265SubLayerHrdParameters *>( this );
1260  }
1261 
1262  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 
1269  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 
1286  operator StdVideoH265HrdFlags const &() const VULKAN_HPP_NOEXCEPT
1287  {
1288  return *reinterpret_cast<const StdVideoH265HrdFlags *>( this );
1289  }
1290 
1291  operator StdVideoH265HrdFlags &() VULKAN_HPP_NOEXCEPT
1292  {
1293  return *reinterpret_cast<StdVideoH265HrdFlags *>( this );
1294  }
1295 
1296  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 
1306  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 
1325  operator StdVideoH265HrdParameters const &() const VULKAN_HPP_NOEXCEPT
1326  {
1327  return *reinterpret_cast<const StdVideoH265HrdParameters *>( this );
1328  }
1329 
1330  operator StdVideoH265HrdParameters &() VULKAN_HPP_NOEXCEPT
1331  {
1332  return *reinterpret_cast<StdVideoH265HrdParameters *>( this );
1333  }
1334 
1335  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 
1348  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 
1375  operator StdVideoH265VpsFlags const &() const VULKAN_HPP_NOEXCEPT
1376  {
1377  return *reinterpret_cast<const StdVideoH265VpsFlags *>( this );
1378  }
1379 
1380  operator StdVideoH265VpsFlags &() VULKAN_HPP_NOEXCEPT
1381  {
1382  return *reinterpret_cast<StdVideoH265VpsFlags *>( this );
1383  }
1384 
1385  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 
1393  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 
1409  operator StdVideoH265ProfileTierLevelFlags const &() const VULKAN_HPP_NOEXCEPT
1410  {
1411  return *reinterpret_cast<const StdVideoH265ProfileTierLevelFlags *>( this );
1412  }
1413 
1414  operator StdVideoH265ProfileTierLevelFlags &() VULKAN_HPP_NOEXCEPT
1415  {
1416  return *reinterpret_cast<StdVideoH265ProfileTierLevelFlags *>( this );
1417  }
1418 
1419  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 
1427  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 
1444  operator StdVideoH265ProfileTierLevel const &() const VULKAN_HPP_NOEXCEPT
1445  {
1446  return *reinterpret_cast<const StdVideoH265ProfileTierLevel *>( this );
1447  }
1448 
1449  operator StdVideoH265ProfileTierLevel &() VULKAN_HPP_NOEXCEPT
1450  {
1451  return *reinterpret_cast<StdVideoH265ProfileTierLevel *>( this );
1452  }
1453 
1454  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 
1459  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 
1475  operator StdVideoH265VideoParameterSet const &() const VULKAN_HPP_NOEXCEPT
1476  {
1477  return *reinterpret_cast<const StdVideoH265VideoParameterSet *>( this );
1478  }
1479 
1480  operator StdVideoH265VideoParameterSet &() VULKAN_HPP_NOEXCEPT
1481  {
1482  return *reinterpret_cast<StdVideoH265VideoParameterSet *>( this );
1483  }
1484 
1485  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 
1494  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 
1518  operator StdVideoH265ScalingLists const &() const VULKAN_HPP_NOEXCEPT
1519  {
1520  return *reinterpret_cast<const StdVideoH265ScalingLists *>( this );
1521  }
1522 
1523  operator StdVideoH265ScalingLists &() VULKAN_HPP_NOEXCEPT
1524  {
1525  return *reinterpret_cast<StdVideoH265ScalingLists *>( this );
1526  }
1527 
1528  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 
1535  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 
1557  operator StdVideoH265SpsVuiFlags const &() const VULKAN_HPP_NOEXCEPT
1558  {
1559  return *reinterpret_cast<const StdVideoH265SpsVuiFlags *>( this );
1560  }
1561 
1562  operator StdVideoH265SpsVuiFlags &() VULKAN_HPP_NOEXCEPT
1563  {
1564  return *reinterpret_cast<StdVideoH265SpsVuiFlags *>( this );
1565  }
1566 
1567  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 
1583  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 
1613  operator StdVideoH265SequenceParameterSetVui const &() const VULKAN_HPP_NOEXCEPT
1614  {
1615  return *reinterpret_cast<const StdVideoH265SequenceParameterSetVui *>( this );
1616  }
1617 
1618  operator StdVideoH265SequenceParameterSetVui &() VULKAN_HPP_NOEXCEPT
1619  {
1620  return *reinterpret_cast<StdVideoH265SequenceParameterSetVui *>( this );
1621  }
1622 
1623  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 
1640  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 
1679  operator StdVideoH265PredictorPaletteEntries const &() const VULKAN_HPP_NOEXCEPT
1680  {
1681  return *reinterpret_cast<const StdVideoH265PredictorPaletteEntries *>( this );
1682  }
1683 
1684  operator StdVideoH265PredictorPaletteEntries &() VULKAN_HPP_NOEXCEPT
1685  {
1686  return *reinterpret_cast<StdVideoH265PredictorPaletteEntries *>( this );
1687  }
1688 
1689  bool operator==( H265PredictorPaletteEntries const & rhs ) const VULKAN_HPP_NOEXCEPT
1690  {
1691  return ( PredictorPaletteEntries == rhs.PredictorPaletteEntries );
1692  }
1693 
1694  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 
1709  operator StdVideoH265SpsFlags const &() const VULKAN_HPP_NOEXCEPT
1710  {
1711  return *reinterpret_cast<const StdVideoH265SpsFlags *>( this );
1712  }
1713 
1714  operator StdVideoH265SpsFlags &() VULKAN_HPP_NOEXCEPT
1715  {
1716  return *reinterpret_cast<StdVideoH265SpsFlags *>( this );
1717  }
1718 
1719  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 
1746  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 
1788  operator StdVideoH265ShortTermRefPicSetFlags const &() const VULKAN_HPP_NOEXCEPT
1789  {
1790  return *reinterpret_cast<const StdVideoH265ShortTermRefPicSetFlags *>( this );
1791  }
1792 
1793  operator StdVideoH265ShortTermRefPicSetFlags &() VULKAN_HPP_NOEXCEPT
1794  {
1795  return *reinterpret_cast<StdVideoH265ShortTermRefPicSetFlags *>( this );
1796  }
1797 
1798  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 
1803  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 
1817  operator StdVideoH265ShortTermRefPicSet const &() const VULKAN_HPP_NOEXCEPT
1818  {
1819  return *reinterpret_cast<const StdVideoH265ShortTermRefPicSet *>( this );
1820  }
1821 
1822  operator StdVideoH265ShortTermRefPicSet &() VULKAN_HPP_NOEXCEPT
1823  {
1824  return *reinterpret_cast<StdVideoH265ShortTermRefPicSet *>( this );
1825  }
1826 
1827  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 
1837  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 
1863  operator StdVideoH265LongTermRefPicsSps const &() const VULKAN_HPP_NOEXCEPT
1864  {
1865  return *reinterpret_cast<const StdVideoH265LongTermRefPicsSps *>( this );
1866  }
1867 
1868  operator StdVideoH265LongTermRefPicsSps &() VULKAN_HPP_NOEXCEPT
1869  {
1870  return *reinterpret_cast<StdVideoH265LongTermRefPicsSps *>( this );
1871  }
1872 
1873  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 
1878  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 
1892  operator StdVideoH265SequenceParameterSet const &() const VULKAN_HPP_NOEXCEPT
1893  {
1894  return *reinterpret_cast<const StdVideoH265SequenceParameterSet *>( this );
1895  }
1896 
1897  operator StdVideoH265SequenceParameterSet &() VULKAN_HPP_NOEXCEPT
1898  {
1899  return *reinterpret_cast<StdVideoH265SequenceParameterSet *>( this );
1900  }
1901 
1902  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 
1931  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 
1983  operator StdVideoH265PpsFlags const &() const VULKAN_HPP_NOEXCEPT
1984  {
1985  return *reinterpret_cast<const StdVideoH265PpsFlags *>( this );
1986  }
1987 
1988  operator StdVideoH265PpsFlags &() VULKAN_HPP_NOEXCEPT
1989  {
1990  return *reinterpret_cast<StdVideoH265PpsFlags *>( this );
1991  }
1992 
1993  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 
2021  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 
2064  operator StdVideoH265PictureParameterSet const &() const VULKAN_HPP_NOEXCEPT
2065  {
2066  return *reinterpret_cast<const StdVideoH265PictureParameterSet *>( this );
2067  }
2068 
2069  operator StdVideoH265PictureParameterSet &() VULKAN_HPP_NOEXCEPT
2070  {
2071  return *reinterpret_cast<StdVideoH265PictureParameterSet *>( this );
2072  }
2073 
2074  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 
2098  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 
2148  operator StdVideoDecodeH265PictureInfoFlags const &() const VULKAN_HPP_NOEXCEPT
2149  {
2150  return *reinterpret_cast<const StdVideoDecodeH265PictureInfoFlags *>( this );
2151  }
2152 
2153  operator StdVideoDecodeH265PictureInfoFlags &() VULKAN_HPP_NOEXCEPT
2154  {
2155  return *reinterpret_cast<StdVideoDecodeH265PictureInfoFlags *>( this );
2156  }
2157 
2158  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 
2164  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 
2180  operator StdVideoDecodeH265PictureInfo const &() const VULKAN_HPP_NOEXCEPT
2181  {
2182  return *reinterpret_cast<const StdVideoDecodeH265PictureInfo *>( this );
2183  }
2184 
2185  operator StdVideoDecodeH265PictureInfo &() VULKAN_HPP_NOEXCEPT
2186  {
2187  return *reinterpret_cast<StdVideoDecodeH265PictureInfo *>( this );
2188  }
2189 
2190  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 
2200  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 
2223  operator StdVideoDecodeH265ReferenceInfoFlags const &() const VULKAN_HPP_NOEXCEPT
2224  {
2225  return *reinterpret_cast<const StdVideoDecodeH265ReferenceInfoFlags *>( this );
2226  }
2227 
2228  operator StdVideoDecodeH265ReferenceInfoFlags &() VULKAN_HPP_NOEXCEPT
2229  {
2230  return *reinterpret_cast<StdVideoDecodeH265ReferenceInfoFlags *>( this );
2231  }
2232 
2233  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 
2238  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 
2252  operator StdVideoDecodeH265ReferenceInfo const &() const VULKAN_HPP_NOEXCEPT
2253  {
2254  return *reinterpret_cast<const StdVideoDecodeH265ReferenceInfo *>( this );
2255  }
2256 
2257  operator StdVideoDecodeH265ReferenceInfo &() VULKAN_HPP_NOEXCEPT
2258  {
2259  return *reinterpret_cast<StdVideoDecodeH265ReferenceInfo *>( this );
2260  }
2261 
2262  bool operator==( DecodeH265ReferenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
2263  {
2264  return ( flags == rhs.flags ) && ( PicOrderCntVal == rhs.PicOrderCntVal );
2265  }
2266 
2267  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 
2283  operator StdVideoEncodeH265WeightTableFlags const &() const VULKAN_HPP_NOEXCEPT
2284  {
2285  return *reinterpret_cast<const StdVideoEncodeH265WeightTableFlags *>( this );
2286  }
2287 
2288  operator StdVideoEncodeH265WeightTableFlags &() VULKAN_HPP_NOEXCEPT
2289  {
2290  return *reinterpret_cast<StdVideoEncodeH265WeightTableFlags *>( this );
2291  }
2292 
2293  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 
2299  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 
2315  operator StdVideoEncodeH265WeightTable const &() const VULKAN_HPP_NOEXCEPT
2316  {
2317  return *reinterpret_cast<const StdVideoEncodeH265WeightTable *>( this );
2318  }
2319 
2320  operator StdVideoEncodeH265WeightTable &() VULKAN_HPP_NOEXCEPT
2321  {
2322  return *reinterpret_cast<StdVideoEncodeH265WeightTable *>( this );
2323  }
2324 
2325  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 
2335  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 
2358  operator StdVideoEncodeH265SliceSegmentHeaderFlags const &() const VULKAN_HPP_NOEXCEPT
2359  {
2360  return *reinterpret_cast<const StdVideoEncodeH265SliceSegmentHeaderFlags *>( this );
2361  }
2362 
2363  operator StdVideoEncodeH265SliceSegmentHeaderFlags &() VULKAN_HPP_NOEXCEPT
2364  {
2365  return *reinterpret_cast<StdVideoEncodeH265SliceSegmentHeaderFlags *>( this );
2366  }
2367 
2368  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 
2381  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 
2406  operator StdVideoEncodeH265SliceSegmentHeader const &() const VULKAN_HPP_NOEXCEPT
2407  {
2408  return *reinterpret_cast<const StdVideoEncodeH265SliceSegmentHeader *>( this );
2409  }
2410 
2411  operator StdVideoEncodeH265SliceSegmentHeader &() VULKAN_HPP_NOEXCEPT
2412  {
2413  return *reinterpret_cast<StdVideoEncodeH265SliceSegmentHeader *>( this );
2414  }
2415 
2416  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 
2427  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 
2454  operator StdVideoEncodeH265ReferenceListsInfoFlags const &() const VULKAN_HPP_NOEXCEPT
2455  {
2456  return *reinterpret_cast<const StdVideoEncodeH265ReferenceListsInfoFlags *>( this );
2457  }
2458 
2459  operator StdVideoEncodeH265ReferenceListsInfoFlags &() VULKAN_HPP_NOEXCEPT
2460  {
2461  return *reinterpret_cast<StdVideoEncodeH265ReferenceListsInfoFlags *>( this );
2462  }
2463 
2464  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 
2470  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 
2485  operator StdVideoEncodeH265ReferenceListsInfo const &() const VULKAN_HPP_NOEXCEPT
2486  {
2487  return *reinterpret_cast<const StdVideoEncodeH265ReferenceListsInfo *>( this );
2488  }
2489 
2490  operator StdVideoEncodeH265ReferenceListsInfo &() VULKAN_HPP_NOEXCEPT
2491  {
2492  return *reinterpret_cast<StdVideoEncodeH265ReferenceListsInfo *>( this );
2493  }
2494 
2495  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 
2502  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 
2521  operator StdVideoEncodeH265PictureInfoFlags const &() const VULKAN_HPP_NOEXCEPT
2522  {
2523  return *reinterpret_cast<const StdVideoEncodeH265PictureInfoFlags *>( this );
2524  }
2525 
2526  operator StdVideoEncodeH265PictureInfoFlags &() VULKAN_HPP_NOEXCEPT
2527  {
2528  return *reinterpret_cast<StdVideoEncodeH265PictureInfoFlags *>( this );
2529  }
2530 
2531  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 
2541  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 
2563  operator StdVideoEncodeH265LongTermRefPics const &() const VULKAN_HPP_NOEXCEPT
2564  {
2565  return *reinterpret_cast<const StdVideoEncodeH265LongTermRefPics *>( this );
2566  }
2567 
2568  operator StdVideoEncodeH265LongTermRefPics &() VULKAN_HPP_NOEXCEPT
2569  {
2570  return *reinterpret_cast<StdVideoEncodeH265LongTermRefPics *>( this );
2571  }
2572 
2573  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 
2580  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 
2599  operator StdVideoEncodeH265PictureInfo const &() const VULKAN_HPP_NOEXCEPT
2600  {
2601  return *reinterpret_cast<const StdVideoEncodeH265PictureInfo *>( this );
2602  }
2603 
2604  operator StdVideoEncodeH265PictureInfo &() VULKAN_HPP_NOEXCEPT
2605  {
2606  return *reinterpret_cast<StdVideoEncodeH265PictureInfo *>( this );
2607  }
2608 
2609  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 
2618  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 
2642  operator StdVideoEncodeH265ReferenceInfoFlags const &() const VULKAN_HPP_NOEXCEPT
2643  {
2644  return *reinterpret_cast<const StdVideoEncodeH265ReferenceInfoFlags *>( this );
2645  }
2646 
2647  operator StdVideoEncodeH265ReferenceInfoFlags &() VULKAN_HPP_NOEXCEPT
2648  {
2649  return *reinterpret_cast<StdVideoEncodeH265ReferenceInfoFlags *>( this );
2650  }
2651 
2652  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 
2658  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 
2673  operator StdVideoEncodeH265ReferenceInfo const &() const VULKAN_HPP_NOEXCEPT
2674  {
2675  return *reinterpret_cast<const StdVideoEncodeH265ReferenceInfo *>( this );
2676  }
2677 
2678  operator StdVideoEncodeH265ReferenceInfo &() VULKAN_HPP_NOEXCEPT
2679  {
2680  return *reinterpret_cast<StdVideoEncodeH265ReferenceInfo *>( this );
2681  }
2682 
2683  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 
2688  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
vk::video::H264DisableDeblockingFilterIdc
H264DisableDeblockingFilterIdc
Definition: vulkan_video.hpp:145
vk::video::H264ModificationOfPicNumsIdc
H264ModificationOfPicNumsIdc
Definition: vulkan_video.hpp:116
vk::operator==
bool operator==(std::string const &lhs, ArrayWrapper1D< char, N > const &rhs) VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:234
vk::video::DecodeH264PictureInfoFlags::operator!=
bool operator!=(DecodeH264PictureInfoFlags const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:670
vk::video::DecodeH264PictureInfoFlags::operator==
bool operator==(DecodeH264PictureInfoFlags const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:663
vk::video::DecodeH264PictureInfo::operator!=
bool operator!=(DecodeH264PictureInfo const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:705
vk::video::DecodeH264PictureInfo::operator==
bool operator==(DecodeH264PictureInfo const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:698
vk::video::DecodeH264ReferenceInfoFlags::operator!=
bool operator!=(DecodeH264ReferenceInfoFlags const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:741
vk::video::DecodeH264ReferenceInfoFlags::operator==
bool operator==(DecodeH264ReferenceInfoFlags const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:735
vk::video::DecodeH264ReferenceInfo::operator==
bool operator==(DecodeH264ReferenceInfo const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:767
vk::video::DecodeH264ReferenceInfo::operator!=
bool operator!=(DecodeH264ReferenceInfo const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:772
vk::video::DecodeH265PictureInfoFlags::operator!=
bool operator!=(DecodeH265PictureInfoFlags const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:2164
vk::video::DecodeH265PictureInfoFlags::operator==
bool operator==(DecodeH265PictureInfoFlags const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:2158
vk::video::DecodeH265PictureInfo::operator==
bool operator==(DecodeH265PictureInfo const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:2190
vk::video::DecodeH265PictureInfo::operator!=
bool operator!=(DecodeH265PictureInfo const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:2200
vk::video::DecodeH265ReferenceInfoFlags::operator==
bool operator==(DecodeH265ReferenceInfoFlags const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:2233
vk::video::DecodeH265ReferenceInfoFlags::operator!=
bool operator!=(DecodeH265ReferenceInfoFlags const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:2238
vk::video::DecodeH265ReferenceInfo::operator!=
bool operator!=(DecodeH265ReferenceInfo const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:2267
vk::video::DecodeH265ReferenceInfo::operator==
bool operator==(DecodeH265ReferenceInfo const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:2262
vk::video::EncodeH264PictureInfoFlags::operator==
bool operator==(EncodeH264PictureInfoFlags const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:905
vk::video::EncodeH264PictureInfoFlags::operator!=
bool operator!=(EncodeH264PictureInfoFlags const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:912
vk::video::EncodeH264PictureInfo::operator!=
bool operator!=(EncodeH264PictureInfo const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:1118
vk::video::EncodeH264PictureInfo::operator==
bool operator==(EncodeH264PictureInfo const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:1111
vk::video::EncodeH264RefListModEntry::operator!=
bool operator!=(EncodeH264RefListModEntry const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:1006
vk::video::EncodeH264RefListModEntry::operator==
bool operator==(EncodeH264RefListModEntry const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:1000
vk::video::EncodeH264RefPicMarkingEntry::operator!=
bool operator!=(EncodeH264RefPicMarkingEntry const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:1039
vk::video::EncodeH264RefPicMarkingEntry::operator==
bool operator==(EncodeH264RefPicMarkingEntry const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:1032
vk::video::EncodeH264ReferenceInfoFlags::operator==
bool operator==(EncodeH264ReferenceInfoFlags const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:940
vk::video::EncodeH264ReferenceInfoFlags::operator!=
bool operator!=(EncodeH264ReferenceInfoFlags const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:945
vk::video::EncodeH264ReferenceInfo::operator==
bool operator==(EncodeH264ReferenceInfo const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:1151
vk::video::EncodeH264ReferenceInfo::operator!=
bool operator!=(EncodeH264ReferenceInfo const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:1157
vk::video::EncodeH264ReferenceListsInfoFlags::operator!=
bool operator!=(EncodeH264ReferenceListsInfoFlags const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:975
vk::video::EncodeH264ReferenceListsInfoFlags::operator==
bool operator==(EncodeH264ReferenceListsInfoFlags const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:969
vk::video::EncodeH264ReferenceListsInfo::operator==
bool operator==(EncodeH264ReferenceListsInfo const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:1067
vk::video::EncodeH264ReferenceListsInfo::operator!=
bool operator!=(EncodeH264ReferenceListsInfo const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:1077
vk::video::EncodeH264SliceHeaderFlags::operator!=
bool operator!=(EncodeH264SliceHeaderFlags const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:880
vk::video::EncodeH264SliceHeaderFlags::operator==
bool operator==(EncodeH264SliceHeaderFlags const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:874
vk::video::EncodeH264SliceHeader::operator==
bool operator==(EncodeH264SliceHeader const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:1187
vk::video::EncodeH264SliceHeader::operator!=
bool operator!=(EncodeH264SliceHeader const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:1195
vk::video::EncodeH264WeightTableFlags::operator!=
bool operator!=(EncodeH264WeightTableFlags const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:806
vk::video::EncodeH264WeightTableFlags::operator==
bool operator==(EncodeH264WeightTableFlags const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:800
vk::video::EncodeH264WeightTable::operator!=
bool operator!=(EncodeH264WeightTable const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:841
vk::video::EncodeH264WeightTable::operator==
bool operator==(EncodeH264WeightTable const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:832
vk::video::EncodeH265LongTermRefPics::operator!=
bool operator!=(EncodeH265LongTermRefPics const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:2580
vk::video::EncodeH265LongTermRefPics::operator==
bool operator==(EncodeH265LongTermRefPics const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:2573
vk::video::EncodeH265PictureInfoFlags::operator==
bool operator==(EncodeH265PictureInfoFlags const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:2531
vk::video::EncodeH265PictureInfoFlags::operator!=
bool operator!=(EncodeH265PictureInfoFlags const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:2541
vk::video::EncodeH265PictureInfo::operator!=
bool operator!=(EncodeH265PictureInfo const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:2618
vk::video::EncodeH265PictureInfo::operator==
bool operator==(EncodeH265PictureInfo const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:2609
vk::video::EncodeH265ReferenceInfoFlags::operator==
bool operator==(EncodeH265ReferenceInfoFlags const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:2652
vk::video::EncodeH265ReferenceInfoFlags::operator!=
bool operator!=(EncodeH265ReferenceInfoFlags const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:2658
vk::video::EncodeH265ReferenceInfo::operator==
bool operator==(EncodeH265ReferenceInfo const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:2683
vk::video::EncodeH265ReferenceInfo::operator!=
bool operator!=(EncodeH265ReferenceInfo const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:2688
vk::video::EncodeH265ReferenceListsInfoFlags::operator==
bool operator==(EncodeH265ReferenceListsInfoFlags const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:2464
vk::video::EncodeH265ReferenceListsInfoFlags::operator!=
bool operator!=(EncodeH265ReferenceListsInfoFlags const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:2470
vk::video::EncodeH265ReferenceListsInfo::operator==
bool operator==(EncodeH265ReferenceListsInfo const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:2495
vk::video::EncodeH265ReferenceListsInfo::operator!=
bool operator!=(EncodeH265ReferenceListsInfo const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:2502
vk::video::EncodeH265SliceSegmentHeaderFlags::operator==
bool operator==(EncodeH265SliceSegmentHeaderFlags const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:2368
vk::video::EncodeH265SliceSegmentHeaderFlags::operator!=
bool operator!=(EncodeH265SliceSegmentHeaderFlags const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:2381
vk::video::EncodeH265SliceSegmentHeader::operator!=
bool operator!=(EncodeH265SliceSegmentHeader const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:2427
vk::video::EncodeH265SliceSegmentHeader::operator==
bool operator==(EncodeH265SliceSegmentHeader const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:2416
vk::video::EncodeH265WeightTableFlags::operator!=
bool operator!=(EncodeH265WeightTableFlags const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:2299
vk::video::EncodeH265WeightTableFlags::operator==
bool operator==(EncodeH265WeightTableFlags const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:2293
vk::video::EncodeH265WeightTable::operator==
bool operator==(EncodeH265WeightTable const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:2325
vk::video::EncodeH265WeightTable::operator!=
bool operator!=(EncodeH265WeightTable const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:2335
vk::video::H264HrdParameters::operator!=
bool operator!=(H264HrdParameters const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:344
vk::video::H264HrdParameters::operator==
bool operator==(H264HrdParameters const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:334
vk::video::H264PictureParameterSet::operator!=
bool operator!=(H264PictureParameterSet const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:627
vk::video::H264PictureParameterSet::operator==
bool operator==(H264PictureParameterSet const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:617
vk::video::H264PpsFlags::constrained_intra_pred_flag
uint32_t constrained_intra_pred_flag
Definition: vulkan_video.hpp:595
vk::video::H264PpsFlags::pic_scaling_matrix_present_flag
uint32_t pic_scaling_matrix_present_flag
Definition: vulkan_video.hpp:600
vk::video::H264PpsFlags::operator!=
bool operator!=(H264PpsFlags const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:587
vk::video::H264PpsFlags::redundant_pic_cnt_present_flag
uint32_t redundant_pic_cnt_present_flag
Definition: vulkan_video.hpp:594
vk::video::H264PpsFlags::bottom_field_pic_order_in_frame_present_flag
uint32_t bottom_field_pic_order_in_frame_present_flag
Definition: vulkan_video.hpp:598
vk::video::H264PpsFlags::operator==
bool operator==(H264PpsFlags const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:578
vk::video::H264PpsFlags::deblocking_filter_control_present_flag
uint32_t deblocking_filter_control_present_flag
Definition: vulkan_video.hpp:596
vk::video::H264ScalingLists::operator==
bool operator==(H264ScalingLists const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:478
vk::video::H264ScalingLists::operator!=
bool operator!=(H264ScalingLists const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:484
vk::video::H264SequenceParameterSetVui::operator!=
bool operator!=(H264SequenceParameterSetVui const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:388
vk::video::H264SequenceParameterSetVui::operator==
bool operator==(H264SequenceParameterSetVui const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:377
vk::video::H264SequenceParameterSet::operator!=
bool operator!=(H264SequenceParameterSet const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:529
vk::video::H264SequenceParameterSet::operator==
bool operator==(H264SequenceParameterSet const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:512
vk::video::H264SpsFlags::operator==
bool operator==(H264SpsFlags const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:427
vk::video::H264SpsFlags::gaps_in_frame_num_value_allowed_flag
uint32_t gaps_in_frame_num_value_allowed_flag
Definition: vulkan_video.hpp:457
vk::video::H264SpsFlags::operator!=
bool operator!=(H264SpsFlags const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:440
vk::video::H264SpsFlags::qpprime_y_zero_transform_bypass_flag
uint32_t qpprime_y_zero_transform_bypass_flag
Definition: vulkan_video.hpp:458
vk::video::H264SpsFlags::vui_parameters_present_flag
uint32_t vui_parameters_present_flag
Definition: vulkan_video.hpp:461
vk::video::H264SpsFlags::seq_scaling_matrix_present_flag
uint32_t seq_scaling_matrix_present_flag
Definition: vulkan_video.hpp:460
vk::video::H264SpsFlags::delta_pic_order_always_zero_flag
uint32_t delta_pic_order_always_zero_flag
Definition: vulkan_video.hpp:455
vk::video::H264SpsFlags::mb_adaptive_frame_field_flag
uint32_t mb_adaptive_frame_field_flag
Definition: vulkan_video.hpp:453
vk::video::H264SpsVuiFlags::operator==
bool operator==(H264SpsVuiFlags const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:289
vk::video::H264SpsVuiFlags::operator!=
bool operator!=(H264SpsVuiFlags const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:300
vk::video::H265DecPicBufMgr::operator==
bool operator==(H265DecPicBufMgr const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:1231
vk::video::H265DecPicBufMgr::operator!=
bool operator!=(H265DecPicBufMgr const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:1237
vk::video::H265HrdFlags::operator!=
bool operator!=(H265HrdFlags const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:1306
vk::video::H265HrdFlags::operator==
bool operator==(H265HrdFlags const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:1296
vk::video::H265HrdFlags::vcl_hrd_parameters_present_flag
uint32_t vcl_hrd_parameters_present_flag
Definition: vulkan_video.hpp:1313
vk::video::H265HrdFlags::nal_hrd_parameters_present_flag
uint32_t nal_hrd_parameters_present_flag
Definition: vulkan_video.hpp:1312
vk::video::H265HrdFlags::sub_pic_hrd_params_present_flag
uint32_t sub_pic_hrd_params_present_flag
Definition: vulkan_video.hpp:1314
vk::video::H265HrdFlags::fixed_pic_rate_within_cvs_flag
uint32_t fixed_pic_rate_within_cvs_flag
Definition: vulkan_video.hpp:1317
vk::video::H265HrdFlags::sub_pic_cpb_params_in_pic_timing_sei_flag
uint32_t sub_pic_cpb_params_in_pic_timing_sei_flag
Definition: vulkan_video.hpp:1315
vk::video::H265HrdParameters::operator!=
bool operator!=(H265HrdParameters const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:1348
vk::video::H265HrdParameters::operator==
bool operator==(H265HrdParameters const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:1335
vk::video::H265LongTermRefPicsSps::operator==
bool operator==(H265LongTermRefPicsSps const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:1873
vk::video::H265LongTermRefPicsSps::operator!=
bool operator!=(H265LongTermRefPicsSps const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:1878
vk::video::H265PictureParameterSet::operator==
bool operator==(H265PictureParameterSet const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:2074
vk::video::H265PictureParameterSet::operator!=
bool operator!=(H265PictureParameterSet const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:2098
vk::video::H265PpsFlags::loop_filter_across_tiles_enabled_flag
uint32_t loop_filter_across_tiles_enabled_flag
Definition: vulkan_video.hpp:2041
vk::video::H265PpsFlags::sign_data_hiding_enabled_flag
uint32_t sign_data_hiding_enabled_flag
Definition: vulkan_video.hpp:2029
vk::video::H265PpsFlags::pps_deblocking_filter_disabled_flag
uint32_t pps_deblocking_filter_disabled_flag
Definition: vulkan_video.hpp:2045
vk::video::H265PpsFlags::pps_scaling_list_data_present_flag
uint32_t pps_scaling_list_data_present_flag
Definition: vulkan_video.hpp:2046
vk::video::H265PpsFlags::entropy_coding_sync_enabled_flag
uint32_t entropy_coding_sync_enabled_flag
Definition: vulkan_video.hpp:2039
vk::video::H265PpsFlags::pps_palette_predictor_initializers_present_flag
uint32_t pps_palette_predictor_initializers_present_flag
Definition: vulkan_video.hpp:2055
vk::video::H265PpsFlags::pps_slice_act_qp_offsets_present_flag
uint32_t pps_slice_act_qp_offsets_present_flag
Definition: vulkan_video.hpp:2054
vk::video::H265PpsFlags::deblocking_filter_override_enabled_flag
uint32_t deblocking_filter_override_enabled_flag
Definition: vulkan_video.hpp:2044
vk::video::H265PpsFlags::residual_adaptive_colour_transform_enabled_flag
uint32_t residual_adaptive_colour_transform_enabled_flag
Definition: vulkan_video.hpp:2053
vk::video::H265PpsFlags::slice_segment_header_extension_present_flag
uint32_t slice_segment_header_extension_present_flag
Definition: vulkan_video.hpp:2048
vk::video::H265PpsFlags::deblocking_filter_control_present_flag
uint32_t deblocking_filter_control_present_flag
Definition: vulkan_video.hpp:2043
vk::video::H265PpsFlags::pps_curr_pic_ref_enabled_flag
uint32_t pps_curr_pic_ref_enabled_flag
Definition: vulkan_video.hpp:2052
vk::video::H265PpsFlags::transquant_bypass_enabled_flag
uint32_t transquant_bypass_enabled_flag
Definition: vulkan_video.hpp:2037
vk::video::H265PpsFlags::pps_slice_chroma_qp_offsets_present_flag
uint32_t pps_slice_chroma_qp_offsets_present_flag
Definition: vulkan_video.hpp:2034
vk::video::H265PpsFlags::chroma_qp_offset_list_enabled_flag
uint32_t chroma_qp_offset_list_enabled_flag
Definition: vulkan_video.hpp:2051
vk::video::H265PpsFlags::pps_loop_filter_across_slices_enabled_flag
uint32_t pps_loop_filter_across_slices_enabled_flag
Definition: vulkan_video.hpp:2042
vk::video::H265PpsFlags::operator==
bool operator==(H265PpsFlags const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:1993
vk::video::H265PpsFlags::dependent_slice_segments_enabled_flag
uint32_t dependent_slice_segments_enabled_flag
Definition: vulkan_video.hpp:2027
vk::video::H265PpsFlags::lists_modification_present_flag
uint32_t lists_modification_present_flag
Definition: vulkan_video.hpp:2047
vk::video::H265PpsFlags::cross_component_prediction_enabled_flag
uint32_t cross_component_prediction_enabled_flag
Definition: vulkan_video.hpp:2050
vk::video::H265PpsFlags::operator!=
bool operator!=(H265PpsFlags const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:2021
vk::video::H265PredictorPaletteEntries::operator!=
bool operator!=(H265PredictorPaletteEntries const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:1694
vk::video::H265PredictorPaletteEntries::operator==
bool operator==(H265PredictorPaletteEntries const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:1689
vk::video::H265ProfileTierLevelFlags::operator==
bool operator==(H265ProfileTierLevelFlags const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:1419
vk::video::H265ProfileTierLevelFlags::operator!=
bool operator!=(H265ProfileTierLevelFlags const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:1427
vk::video::H265ProfileTierLevel::operator==
bool operator==(H265ProfileTierLevel const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:1454
vk::video::H265ProfileTierLevel::operator!=
bool operator!=(H265ProfileTierLevel const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:1459
vk::video::H265ScalingLists::operator!=
bool operator!=(H265ScalingLists const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:1535
vk::video::H265ScalingLists::operator==
bool operator==(H265ScalingLists const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:1528
vk::video::H265SequenceParameterSetVui::operator!=
bool operator!=(H265SequenceParameterSetVui const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:1640
vk::video::H265SequenceParameterSetVui::operator==
bool operator==(H265SequenceParameterSetVui const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:1623
vk::video::H265SequenceParameterSet::operator==
bool operator==(H265SequenceParameterSet const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:1902
vk::video::H265SequenceParameterSet::operator!=
bool operator!=(H265SequenceParameterSet const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:1931
vk::video::H265ShortTermRefPicSetFlags::operator==
bool operator==(H265ShortTermRefPicSetFlags const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:1798
vk::video::H265ShortTermRefPicSetFlags::operator!=
bool operator!=(H265ShortTermRefPicSetFlags const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:1803
vk::video::H265ShortTermRefPicSet::operator==
bool operator==(H265ShortTermRefPicSet const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:1827
vk::video::H265ShortTermRefPicSet::operator!=
bool operator!=(H265ShortTermRefPicSet const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:1837
vk::video::H265SpsFlags::strong_intra_smoothing_enabled_flag
uint32_t strong_intra_smoothing_enabled_flag
Definition: vulkan_video.hpp:1764
vk::video::H265SpsFlags::sps_sub_layer_ordering_info_present_flag
uint32_t sps_sub_layer_ordering_info_present_flag
Definition: vulkan_video.hpp:1755
vk::video::H265SpsFlags::extended_precision_processing_flag
uint32_t extended_precision_processing_flag
Definition: vulkan_video.hpp:1772
vk::video::H265SpsFlags::intra_boundary_filtering_disabled_flag
uint32_t intra_boundary_filtering_disabled_flag
Definition: vulkan_video.hpp:1781
vk::video::H265SpsFlags::transform_skip_rotation_enabled_flag
uint32_t transform_skip_rotation_enabled_flag
Definition: vulkan_video.hpp:1768
vk::video::H265SpsFlags::high_precision_offsets_enabled_flag
uint32_t high_precision_offsets_enabled_flag
Definition: vulkan_video.hpp:1774
vk::video::H265SpsFlags::sps_scaling_list_data_present_flag
uint32_t sps_scaling_list_data_present_flag
Definition: vulkan_video.hpp:1757
vk::video::H265SpsFlags::operator!=
bool operator!=(H265SpsFlags const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:1746
vk::video::H265SpsFlags::sps_temporal_mvp_enabled_flag
uint32_t sps_temporal_mvp_enabled_flag
Definition: vulkan_video.hpp:1763
vk::video::H265SpsFlags::sps_curr_pic_ref_enabled_flag
uint32_t sps_curr_pic_ref_enabled_flag
Definition: vulkan_video.hpp:1778
vk::video::H265SpsFlags::transform_skip_context_enabled_flag
uint32_t transform_skip_context_enabled_flag
Definition: vulkan_video.hpp:1769
vk::video::H265SpsFlags::cabac_bypass_alignment_enabled_flag
uint32_t cabac_bypass_alignment_enabled_flag
Definition: vulkan_video.hpp:1776
vk::video::H265SpsFlags::sample_adaptive_offset_enabled_flag
uint32_t sample_adaptive_offset_enabled_flag
Definition: vulkan_video.hpp:1759
vk::video::H265SpsFlags::pcm_loop_filter_disabled_flag
uint32_t pcm_loop_filter_disabled_flag
Definition: vulkan_video.hpp:1761
vk::video::H265SpsFlags::intra_smoothing_disabled_flag
uint32_t intra_smoothing_disabled_flag
Definition: vulkan_video.hpp:1773
vk::video::H265SpsFlags::long_term_ref_pics_present_flag
uint32_t long_term_ref_pics_present_flag
Definition: vulkan_video.hpp:1762
vk::video::H265SpsFlags::sps_palette_predictor_initializers_present_flag
uint32_t sps_palette_predictor_initializers_present_flag
Definition: vulkan_video.hpp:1780
vk::video::H265SpsFlags::persistent_rice_adaptation_enabled_flag
uint32_t persistent_rice_adaptation_enabled_flag
Definition: vulkan_video.hpp:1775
vk::video::H265SpsFlags::operator==
bool operator==(H265SpsFlags const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:1719
vk::video::H265SpsVuiFlags::operator!=
bool operator!=(H265SpsVuiFlags const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:1583
vk::video::H265SpsVuiFlags::vui_poc_proportional_to_timing_flag
uint32_t vui_poc_proportional_to_timing_flag
Definition: vulkan_video.hpp:1601
vk::video::H265SpsVuiFlags::operator==
bool operator==(H265SpsVuiFlags const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:1567
vk::video::H265SpsVuiFlags::motion_vectors_over_pic_boundaries_flag
uint32_t motion_vectors_over_pic_boundaries_flag
Definition: vulkan_video.hpp:1605
vk::video::H265SubLayerHrdParameters::operator!=
bool operator!=(H265SubLayerHrdParameters const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:1269
vk::video::H265SubLayerHrdParameters::operator==
bool operator==(H265SubLayerHrdParameters const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:1262
vk::video::H265VideoParameterSet::operator!=
bool operator!=(H265VideoParameterSet const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:1494
vk::video::H265VideoParameterSet::operator==
bool operator==(H265VideoParameterSet const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:1485
vk::video::H265VpsFlags::vps_sub_layer_ordering_info_present_flag
uint32_t vps_sub_layer_ordering_info_present_flag
Definition: vulkan_video.hpp:1400
vk::video::H265VpsFlags::operator!=
bool operator!=(H265VpsFlags const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:1393
vk::video::H265VpsFlags::operator==
bool operator==(H265VpsFlags const &rhs) const VULKAN_HPP_NOEXCEPT
Definition: vulkan_video.hpp:1385
vk::video::H265VpsFlags::vps_poc_proportional_to_timing_flag
uint32_t vps_poc_proportional_to_timing_flag
Definition: vulkan_video.hpp:1402
VULKAN_HPP_NOEXCEPT
#define VULKAN_HPP_NOEXCEPT
Definition: vulkan_hpp_macros.hpp:171
VULKAN_HPP_VIDEO_NAMESPACE
#define VULKAN_HPP_VIDEO_NAMESPACE
Definition: vulkan_video.hpp:20
vulkan_video_codec_h264std.h
STD_VIDEO_H264_PICTURE_TYPE_INVALID
@ STD_VIDEO_H264_PICTURE_TYPE_INVALID
Definition: vulkan_video_codec_h264std.h:165
STD_VIDEO_H264_PICTURE_TYPE_IDR
@ STD_VIDEO_H264_PICTURE_TYPE_IDR
Definition: vulkan_video_codec_h264std.h:164
STD_VIDEO_H264_PICTURE_TYPE_I
@ STD_VIDEO_H264_PICTURE_TYPE_I
Definition: vulkan_video_codec_h264std.h:163
STD_VIDEO_H264_PICTURE_TYPE_B
@ STD_VIDEO_H264_PICTURE_TYPE_B
Definition: vulkan_video_codec_h264std.h:162
STD_VIDEO_H264_PICTURE_TYPE_P
@ STD_VIDEO_H264_PICTURE_TYPE_P
Definition: vulkan_video_codec_h264std.h:161
STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_INVALID
@ STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_INVALID
Definition: vulkan_video_codec_h264std.h:120
STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_LONG_TERM
@ STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_LONG_TERM
Definition: vulkan_video_codec_h264std.h:118
STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_END
@ STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_END
Definition: vulkan_video_codec_h264std.h:119
STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_SHORT_TERM_SUBTRACT
@ STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_SHORT_TERM_SUBTRACT
Definition: vulkan_video_codec_h264std.h:116
STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_SHORT_TERM_ADD
@ STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_SHORT_TERM_ADD
Definition: vulkan_video_codec_h264std.h:117
STD_VIDEO_H264_NON_VCL_NALU_TYPE_PREFIX
@ STD_VIDEO_H264_NON_VCL_NALU_TYPE_PREFIX
Definition: vulkan_video_codec_h264std.h:173
STD_VIDEO_H264_NON_VCL_NALU_TYPE_AUD
@ STD_VIDEO_H264_NON_VCL_NALU_TYPE_AUD
Definition: vulkan_video_codec_h264std.h:172
STD_VIDEO_H264_NON_VCL_NALU_TYPE_PPS
@ STD_VIDEO_H264_NON_VCL_NALU_TYPE_PPS
Definition: vulkan_video_codec_h264std.h:171
STD_VIDEO_H264_NON_VCL_NALU_TYPE_END_OF_SEQUENCE
@ STD_VIDEO_H264_NON_VCL_NALU_TYPE_END_OF_SEQUENCE
Definition: vulkan_video_codec_h264std.h:174
STD_VIDEO_H264_NON_VCL_NALU_TYPE_END_OF_STREAM
@ STD_VIDEO_H264_NON_VCL_NALU_TYPE_END_OF_STREAM
Definition: vulkan_video_codec_h264std.h:175
STD_VIDEO_H264_NON_VCL_NALU_TYPE_PRECODED
@ STD_VIDEO_H264_NON_VCL_NALU_TYPE_PRECODED
Definition: vulkan_video_codec_h264std.h:176
STD_VIDEO_H264_NON_VCL_NALU_TYPE_SPS
@ STD_VIDEO_H264_NON_VCL_NALU_TYPE_SPS
Definition: vulkan_video_codec_h264std.h:170
STD_VIDEO_H264_NON_VCL_NALU_TYPE_INVALID
@ STD_VIDEO_H264_NON_VCL_NALU_TYPE_INVALID
Definition: vulkan_video_codec_h264std.h:177
STD_VIDEO_H264_LEVEL_IDC_6_1
@ STD_VIDEO_H264_LEVEL_IDC_6_1
Definition: vulkan_video_codec_h264std.h:70
STD_VIDEO_H264_LEVEL_IDC_6_0
@ STD_VIDEO_H264_LEVEL_IDC_6_0
Definition: vulkan_video_codec_h264std.h:69
STD_VIDEO_H264_LEVEL_IDC_3_1
@ STD_VIDEO_H264_LEVEL_IDC_3_1
Definition: vulkan_video_codec_h264std.h:61
STD_VIDEO_H264_LEVEL_IDC_1_1
@ STD_VIDEO_H264_LEVEL_IDC_1_1
Definition: vulkan_video_codec_h264std.h:54
STD_VIDEO_H264_LEVEL_IDC_6_2
@ STD_VIDEO_H264_LEVEL_IDC_6_2
Definition: vulkan_video_codec_h264std.h:71
STD_VIDEO_H264_LEVEL_IDC_5_2
@ STD_VIDEO_H264_LEVEL_IDC_5_2
Definition: vulkan_video_codec_h264std.h:68
STD_VIDEO_H264_LEVEL_IDC_4_0
@ STD_VIDEO_H264_LEVEL_IDC_4_0
Definition: vulkan_video_codec_h264std.h:63
STD_VIDEO_H264_LEVEL_IDC_1_3
@ STD_VIDEO_H264_LEVEL_IDC_1_3
Definition: vulkan_video_codec_h264std.h:56
STD_VIDEO_H264_LEVEL_IDC_3_2
@ STD_VIDEO_H264_LEVEL_IDC_3_2
Definition: vulkan_video_codec_h264std.h:62
STD_VIDEO_H264_LEVEL_IDC_1_2
@ STD_VIDEO_H264_LEVEL_IDC_1_2
Definition: vulkan_video_codec_h264std.h:55
STD_VIDEO_H264_LEVEL_IDC_1_0
@ STD_VIDEO_H264_LEVEL_IDC_1_0
Definition: vulkan_video_codec_h264std.h:53
STD_VIDEO_H264_LEVEL_IDC_4_2
@ STD_VIDEO_H264_LEVEL_IDC_4_2
Definition: vulkan_video_codec_h264std.h:65
STD_VIDEO_H264_LEVEL_IDC_5_0
@ STD_VIDEO_H264_LEVEL_IDC_5_0
Definition: vulkan_video_codec_h264std.h:66
STD_VIDEO_H264_LEVEL_IDC_2_1
@ STD_VIDEO_H264_LEVEL_IDC_2_1
Definition: vulkan_video_codec_h264std.h:58
STD_VIDEO_H264_LEVEL_IDC_INVALID
@ STD_VIDEO_H264_LEVEL_IDC_INVALID
Definition: vulkan_video_codec_h264std.h:72
STD_VIDEO_H264_LEVEL_IDC_4_1
@ STD_VIDEO_H264_LEVEL_IDC_4_1
Definition: vulkan_video_codec_h264std.h:64
STD_VIDEO_H264_LEVEL_IDC_2_0
@ STD_VIDEO_H264_LEVEL_IDC_2_0
Definition: vulkan_video_codec_h264std.h:57
STD_VIDEO_H264_LEVEL_IDC_5_1
@ STD_VIDEO_H264_LEVEL_IDC_5_1
Definition: vulkan_video_codec_h264std.h:67
STD_VIDEO_H264_LEVEL_IDC_3_0
@ STD_VIDEO_H264_LEVEL_IDC_3_0
Definition: vulkan_video_codec_h264std.h:60
STD_VIDEO_H264_LEVEL_IDC_2_2
@ STD_VIDEO_H264_LEVEL_IDC_2_2
Definition: vulkan_video_codec_h264std.h:59
STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_MARK_LONG_TERM
@ STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_MARK_LONG_TERM
Definition: vulkan_video_codec_h264std.h:128
STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_END
@ STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_END
Definition: vulkan_video_codec_h264std.h:125
STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_SHORT_TERM
@ STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_SHORT_TERM
Definition: vulkan_video_codec_h264std.h:126
STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_ALL
@ STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_ALL
Definition: vulkan_video_codec_h264std.h:130
STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_SET_MAX_LONG_TERM_INDEX
@ STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_SET_MAX_LONG_TERM_INDEX
Definition: vulkan_video_codec_h264std.h:129
STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_MARK_CURRENT_AS_LONG_TERM
@ STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_MARK_CURRENT_AS_LONG_TERM
Definition: vulkan_video_codec_h264std.h:131
STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_INVALID
@ STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_INVALID
Definition: vulkan_video_codec_h264std.h:132
STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_LONG_TERM
@ STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_LONG_TERM
Definition: vulkan_video_codec_h264std.h:127
STD_VIDEO_H264_PROFILE_IDC_HIGH
@ STD_VIDEO_H264_PROFILE_IDC_HIGH
Definition: vulkan_video_codec_h264std.h:46
STD_VIDEO_H264_PROFILE_IDC_INVALID
@ STD_VIDEO_H264_PROFILE_IDC_INVALID
Definition: vulkan_video_codec_h264std.h:48
STD_VIDEO_H264_PROFILE_IDC_HIGH_444_PREDICTIVE
@ STD_VIDEO_H264_PROFILE_IDC_HIGH_444_PREDICTIVE
Definition: vulkan_video_codec_h264std.h:47
STD_VIDEO_H264_PROFILE_IDC_MAIN
@ STD_VIDEO_H264_PROFILE_IDC_MAIN
Definition: vulkan_video_codec_h264std.h:45
STD_VIDEO_H264_PROFILE_IDC_BASELINE
@ STD_VIDEO_H264_PROFILE_IDC_BASELINE
Definition: vulkan_video_codec_h264std.h:44
STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_DISABLED
@ STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_DISABLED
Definition: vulkan_video_codec_h264std.h:145
STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_ENABLED
@ STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_ENABLED
Definition: vulkan_video_codec_h264std.h:146
STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_INVALID
@ STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_INVALID
Definition: vulkan_video_codec_h264std.h:148
STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_PARTIAL
@ STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_PARTIAL
Definition: vulkan_video_codec_h264std.h:147
STD_VIDEO_H264_CABAC_INIT_IDC_2
@ STD_VIDEO_H264_CABAC_INIT_IDC_2
Definition: vulkan_video_codec_h264std.h:139
STD_VIDEO_H264_CABAC_INIT_IDC_0
@ STD_VIDEO_H264_CABAC_INIT_IDC_0
Definition: vulkan_video_codec_h264std.h:137
STD_VIDEO_H264_CABAC_INIT_IDC_INVALID
@ STD_VIDEO_H264_CABAC_INIT_IDC_INVALID
Definition: vulkan_video_codec_h264std.h:140
STD_VIDEO_H264_CABAC_INIT_IDC_1
@ STD_VIDEO_H264_CABAC_INIT_IDC_1
Definition: vulkan_video_codec_h264std.h:138
STD_VIDEO_H264_CHROMA_FORMAT_IDC_INVALID
@ STD_VIDEO_H264_CHROMA_FORMAT_IDC_INVALID
Definition: vulkan_video_codec_h264std.h:39
STD_VIDEO_H264_CHROMA_FORMAT_IDC_422
@ STD_VIDEO_H264_CHROMA_FORMAT_IDC_422
Definition: vulkan_video_codec_h264std.h:37
STD_VIDEO_H264_CHROMA_FORMAT_IDC_420
@ STD_VIDEO_H264_CHROMA_FORMAT_IDC_420
Definition: vulkan_video_codec_h264std.h:36
STD_VIDEO_H264_CHROMA_FORMAT_IDC_444
@ STD_VIDEO_H264_CHROMA_FORMAT_IDC_444
Definition: vulkan_video_codec_h264std.h:38
STD_VIDEO_H264_CHROMA_FORMAT_IDC_MONOCHROME
@ STD_VIDEO_H264_CHROMA_FORMAT_IDC_MONOCHROME
Definition: vulkan_video_codec_h264std.h:35
STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_IMPLICIT
@ STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_IMPLICIT
Definition: vulkan_video_codec_h264std.h:110
STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_INVALID
@ STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_INVALID
Definition: vulkan_video_codec_h264std.h:111
STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_DEFAULT
@ STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_DEFAULT
Definition: vulkan_video_codec_h264std.h:108
STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_EXPLICIT
@ STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_EXPLICIT
Definition: vulkan_video_codec_h264std.h:109
StdVideoH264SpsVuiFlags
struct StdVideoH264SpsVuiFlags StdVideoH264SpsVuiFlags
STD_VIDEO_H264_SLICE_TYPE_B
@ STD_VIDEO_H264_SLICE_TYPE_B
Definition: vulkan_video_codec_h264std.h:154
STD_VIDEO_H264_SLICE_TYPE_INVALID
@ STD_VIDEO_H264_SLICE_TYPE_INVALID
Definition: vulkan_video_codec_h264std.h:156
STD_VIDEO_H264_SLICE_TYPE_P
@ STD_VIDEO_H264_SLICE_TYPE_P
Definition: vulkan_video_codec_h264std.h:153
STD_VIDEO_H264_SLICE_TYPE_I
@ STD_VIDEO_H264_SLICE_TYPE_I
Definition: vulkan_video_codec_h264std.h:155
StdVideoH264HrdParameters
struct StdVideoH264HrdParameters StdVideoH264HrdParameters
StdVideoH264ScalingLists
struct StdVideoH264ScalingLists StdVideoH264ScalingLists
StdVideoH264SequenceParameterSetVui
struct StdVideoH264SequenceParameterSetVui StdVideoH264SequenceParameterSetVui
StdVideoH264SequenceParameterSet
struct StdVideoH264SequenceParameterSet StdVideoH264SequenceParameterSet
STD_VIDEO_H264_POC_TYPE_INVALID
@ STD_VIDEO_H264_POC_TYPE_INVALID
Definition: vulkan_video_codec_h264std.h:80
STD_VIDEO_H264_POC_TYPE_0
@ STD_VIDEO_H264_POC_TYPE_0
Definition: vulkan_video_codec_h264std.h:77
STD_VIDEO_H264_POC_TYPE_1
@ STD_VIDEO_H264_POC_TYPE_1
Definition: vulkan_video_codec_h264std.h:78
STD_VIDEO_H264_POC_TYPE_2
@ STD_VIDEO_H264_POC_TYPE_2
Definition: vulkan_video_codec_h264std.h:79
StdVideoH264PpsFlags
struct StdVideoH264PpsFlags StdVideoH264PpsFlags
STD_VIDEO_H264_ASPECT_RATIO_IDC_40_33
@ STD_VIDEO_H264_ASPECT_RATIO_IDC_40_33
Definition: vulkan_video_codec_h264std.h:90
STD_VIDEO_H264_ASPECT_RATIO_IDC_160_99
@ STD_VIDEO_H264_ASPECT_RATIO_IDC_160_99
Definition: vulkan_video_codec_h264std.h:98
STD_VIDEO_H264_ASPECT_RATIO_IDC_16_11
@ STD_VIDEO_H264_ASPECT_RATIO_IDC_16_11
Definition: vulkan_video_codec_h264std.h:89
STD_VIDEO_H264_ASPECT_RATIO_IDC_64_33
@ STD_VIDEO_H264_ASPECT_RATIO_IDC_64_33
Definition: vulkan_video_codec_h264std.h:97
STD_VIDEO_H264_ASPECT_RATIO_IDC_UNSPECIFIED
@ STD_VIDEO_H264_ASPECT_RATIO_IDC_UNSPECIFIED
Definition: vulkan_video_codec_h264std.h:85
STD_VIDEO_H264_ASPECT_RATIO_IDC_12_11
@ STD_VIDEO_H264_ASPECT_RATIO_IDC_12_11
Definition: vulkan_video_codec_h264std.h:87
STD_VIDEO_H264_ASPECT_RATIO_IDC_20_11
@ STD_VIDEO_H264_ASPECT_RATIO_IDC_20_11
Definition: vulkan_video_codec_h264std.h:92
STD_VIDEO_H264_ASPECT_RATIO_IDC_10_11
@ STD_VIDEO_H264_ASPECT_RATIO_IDC_10_11
Definition: vulkan_video_codec_h264std.h:88
STD_VIDEO_H264_ASPECT_RATIO_IDC_3_2
@ STD_VIDEO_H264_ASPECT_RATIO_IDC_3_2
Definition: vulkan_video_codec_h264std.h:100
STD_VIDEO_H264_ASPECT_RATIO_IDC_80_33
@ STD_VIDEO_H264_ASPECT_RATIO_IDC_80_33
Definition: vulkan_video_codec_h264std.h:94
STD_VIDEO_H264_ASPECT_RATIO_IDC_2_1
@ STD_VIDEO_H264_ASPECT_RATIO_IDC_2_1
Definition: vulkan_video_codec_h264std.h:101
STD_VIDEO_H264_ASPECT_RATIO_IDC_SQUARE
@ STD_VIDEO_H264_ASPECT_RATIO_IDC_SQUARE
Definition: vulkan_video_codec_h264std.h:86
STD_VIDEO_H264_ASPECT_RATIO_IDC_INVALID
@ STD_VIDEO_H264_ASPECT_RATIO_IDC_INVALID
Definition: vulkan_video_codec_h264std.h:103
STD_VIDEO_H264_ASPECT_RATIO_IDC_32_11
@ STD_VIDEO_H264_ASPECT_RATIO_IDC_32_11
Definition: vulkan_video_codec_h264std.h:93
STD_VIDEO_H264_ASPECT_RATIO_IDC_4_3
@ STD_VIDEO_H264_ASPECT_RATIO_IDC_4_3
Definition: vulkan_video_codec_h264std.h:99
STD_VIDEO_H264_ASPECT_RATIO_IDC_24_11
@ STD_VIDEO_H264_ASPECT_RATIO_IDC_24_11
Definition: vulkan_video_codec_h264std.h:91
STD_VIDEO_H264_ASPECT_RATIO_IDC_15_11
@ STD_VIDEO_H264_ASPECT_RATIO_IDC_15_11
Definition: vulkan_video_codec_h264std.h:96
STD_VIDEO_H264_ASPECT_RATIO_IDC_EXTENDED_SAR
@ STD_VIDEO_H264_ASPECT_RATIO_IDC_EXTENDED_SAR
Definition: vulkan_video_codec_h264std.h:102
STD_VIDEO_H264_ASPECT_RATIO_IDC_18_11
@ STD_VIDEO_H264_ASPECT_RATIO_IDC_18_11
Definition: vulkan_video_codec_h264std.h:95
StdVideoH264SpsFlags
struct StdVideoH264SpsFlags StdVideoH264SpsFlags
StdVideoH264PictureParameterSet
struct StdVideoH264PictureParameterSet StdVideoH264PictureParameterSet
vulkan_video_codec_h264std_decode.h
StdVideoDecodeH264PictureInfo
struct StdVideoDecodeH264PictureInfo StdVideoDecodeH264PictureInfo
StdVideoDecodeH264ReferenceInfoFlags
struct StdVideoDecodeH264ReferenceInfoFlags StdVideoDecodeH264ReferenceInfoFlags
StdVideoDecodeH264ReferenceInfo
struct StdVideoDecodeH264ReferenceInfo StdVideoDecodeH264ReferenceInfo
StdVideoDecodeH264PictureInfoFlags
struct StdVideoDecodeH264PictureInfoFlags StdVideoDecodeH264PictureInfoFlags
STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_INVALID
@ STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_INVALID
Definition: vulkan_video_codec_h264std_decode.h:35
STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_TOP
@ STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_TOP
Definition: vulkan_video_codec_h264std_decode.h:33
STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_BOTTOM
@ STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_BOTTOM
Definition: vulkan_video_codec_h264std_decode.h:34
vulkan_video_codec_h264std_encode.h
StdVideoEncodeH264RefListModEntry
struct StdVideoEncodeH264RefListModEntry StdVideoEncodeH264RefListModEntry
StdVideoEncodeH264ReferenceInfo
struct StdVideoEncodeH264ReferenceInfo StdVideoEncodeH264ReferenceInfo
StdVideoEncodeH264RefPicMarkingEntry
struct StdVideoEncodeH264RefPicMarkingEntry StdVideoEncodeH264RefPicMarkingEntry
StdVideoEncodeH264PictureInfoFlags
struct StdVideoEncodeH264PictureInfoFlags StdVideoEncodeH264PictureInfoFlags
StdVideoEncodeH264SliceHeaderFlags
struct StdVideoEncodeH264SliceHeaderFlags StdVideoEncodeH264SliceHeaderFlags
StdVideoEncodeH264PictureInfo
struct StdVideoEncodeH264PictureInfo StdVideoEncodeH264PictureInfo
StdVideoEncodeH264SliceHeader
struct StdVideoEncodeH264SliceHeader StdVideoEncodeH264SliceHeader
StdVideoEncodeH264ReferenceListsInfo
struct StdVideoEncodeH264ReferenceListsInfo StdVideoEncodeH264ReferenceListsInfo
StdVideoEncodeH264WeightTable
struct StdVideoEncodeH264WeightTable StdVideoEncodeH264WeightTable
StdVideoEncodeH264WeightTableFlags
struct StdVideoEncodeH264WeightTableFlags StdVideoEncodeH264WeightTableFlags
StdVideoEncodeH264ReferenceListsInfoFlags
struct StdVideoEncodeH264ReferenceListsInfoFlags StdVideoEncodeH264ReferenceListsInfoFlags
StdVideoEncodeH264ReferenceInfoFlags
struct StdVideoEncodeH264ReferenceInfoFlags StdVideoEncodeH264ReferenceInfoFlags
vulkan_video_codec_h265std.h
StdVideoH265PictureParameterSet
struct StdVideoH265PictureParameterSet StdVideoH265PictureParameterSet
StdVideoH265VideoParameterSet
struct StdVideoH265VideoParameterSet StdVideoH265VideoParameterSet
StdVideoH265LongTermRefPicsSps
struct StdVideoH265LongTermRefPicsSps StdVideoH265LongTermRefPicsSps
StdVideoH265DecPicBufMgr
struct StdVideoH265DecPicBufMgr StdVideoH265DecPicBufMgr
StdVideoH265ShortTermRefPicSetFlags
struct StdVideoH265ShortTermRefPicSetFlags StdVideoH265ShortTermRefPicSetFlags
StdVideoH265ScalingLists
struct StdVideoH265ScalingLists StdVideoH265ScalingLists
STD_VIDEO_H265_PROFILE_IDC_MAIN_10
@ STD_VIDEO_H265_PROFILE_IDC_MAIN_10
Definition: vulkan_video_codec_h265std.h:60
STD_VIDEO_H265_PROFILE_IDC_MAIN_STILL_PICTURE
@ STD_VIDEO_H265_PROFILE_IDC_MAIN_STILL_PICTURE
Definition: vulkan_video_codec_h265std.h:61
STD_VIDEO_H265_PROFILE_IDC_INVALID
@ STD_VIDEO_H265_PROFILE_IDC_INVALID
Definition: vulkan_video_codec_h265std.h:64
STD_VIDEO_H265_PROFILE_IDC_SCC_EXTENSIONS
@ STD_VIDEO_H265_PROFILE_IDC_SCC_EXTENSIONS
Definition: vulkan_video_codec_h265std.h:63
STD_VIDEO_H265_PROFILE_IDC_MAIN
@ STD_VIDEO_H265_PROFILE_IDC_MAIN
Definition: vulkan_video_codec_h265std.h:59
STD_VIDEO_H265_PROFILE_IDC_FORMAT_RANGE_EXTENSIONS
@ STD_VIDEO_H265_PROFILE_IDC_FORMAT_RANGE_EXTENSIONS
Definition: vulkan_video_codec_h265std.h:62
StdVideoH265ProfileTierLevel
struct StdVideoH265ProfileTierLevel StdVideoH265ProfileTierLevel
StdVideoH265SubLayerHrdParameters
struct StdVideoH265SubLayerHrdParameters StdVideoH265SubLayerHrdParameters
STD_VIDEO_H265_ASPECT_RATIO_IDC_160_99
@ STD_VIDEO_H265_ASPECT_RATIO_IDC_160_99
Definition: vulkan_video_codec_h265std.h:117
STD_VIDEO_H265_ASPECT_RATIO_IDC_15_11
@ STD_VIDEO_H265_ASPECT_RATIO_IDC_15_11
Definition: vulkan_video_codec_h265std.h:115
STD_VIDEO_H265_ASPECT_RATIO_IDC_80_33
@ STD_VIDEO_H265_ASPECT_RATIO_IDC_80_33
Definition: vulkan_video_codec_h265std.h:113
STD_VIDEO_H265_ASPECT_RATIO_IDC_2_1
@ STD_VIDEO_H265_ASPECT_RATIO_IDC_2_1
Definition: vulkan_video_codec_h265std.h:120
STD_VIDEO_H265_ASPECT_RATIO_IDC_INVALID
@ STD_VIDEO_H265_ASPECT_RATIO_IDC_INVALID
Definition: vulkan_video_codec_h265std.h:122
STD_VIDEO_H265_ASPECT_RATIO_IDC_64_33
@ STD_VIDEO_H265_ASPECT_RATIO_IDC_64_33
Definition: vulkan_video_codec_h265std.h:116
STD_VIDEO_H265_ASPECT_RATIO_IDC_10_11
@ STD_VIDEO_H265_ASPECT_RATIO_IDC_10_11
Definition: vulkan_video_codec_h265std.h:107
STD_VIDEO_H265_ASPECT_RATIO_IDC_32_11
@ STD_VIDEO_H265_ASPECT_RATIO_IDC_32_11
Definition: vulkan_video_codec_h265std.h:112
STD_VIDEO_H265_ASPECT_RATIO_IDC_UNSPECIFIED
@ STD_VIDEO_H265_ASPECT_RATIO_IDC_UNSPECIFIED
Definition: vulkan_video_codec_h265std.h:104
STD_VIDEO_H265_ASPECT_RATIO_IDC_EXTENDED_SAR
@ STD_VIDEO_H265_ASPECT_RATIO_IDC_EXTENDED_SAR
Definition: vulkan_video_codec_h265std.h:121
STD_VIDEO_H265_ASPECT_RATIO_IDC_16_11
@ STD_VIDEO_H265_ASPECT_RATIO_IDC_16_11
Definition: vulkan_video_codec_h265std.h:108
STD_VIDEO_H265_ASPECT_RATIO_IDC_40_33
@ STD_VIDEO_H265_ASPECT_RATIO_IDC_40_33
Definition: vulkan_video_codec_h265std.h:109
STD_VIDEO_H265_ASPECT_RATIO_IDC_12_11
@ STD_VIDEO_H265_ASPECT_RATIO_IDC_12_11
Definition: vulkan_video_codec_h265std.h:106
STD_VIDEO_H265_ASPECT_RATIO_IDC_4_3
@ STD_VIDEO_H265_ASPECT_RATIO_IDC_4_3
Definition: vulkan_video_codec_h265std.h:118
STD_VIDEO_H265_ASPECT_RATIO_IDC_SQUARE
@ STD_VIDEO_H265_ASPECT_RATIO_IDC_SQUARE
Definition: vulkan_video_codec_h265std.h:105
STD_VIDEO_H265_ASPECT_RATIO_IDC_24_11
@ STD_VIDEO_H265_ASPECT_RATIO_IDC_24_11
Definition: vulkan_video_codec_h265std.h:110
STD_VIDEO_H265_ASPECT_RATIO_IDC_20_11
@ STD_VIDEO_H265_ASPECT_RATIO_IDC_20_11
Definition: vulkan_video_codec_h265std.h:111
STD_VIDEO_H265_ASPECT_RATIO_IDC_3_2
@ STD_VIDEO_H265_ASPECT_RATIO_IDC_3_2
Definition: vulkan_video_codec_h265std.h:119
STD_VIDEO_H265_ASPECT_RATIO_IDC_18_11
@ STD_VIDEO_H265_ASPECT_RATIO_IDC_18_11
Definition: vulkan_video_codec_h265std.h:114
StdVideoH265PredictorPaletteEntries
struct StdVideoH265PredictorPaletteEntries StdVideoH265PredictorPaletteEntries
StdVideoH265SpsVuiFlags
struct StdVideoH265SpsVuiFlags StdVideoH265SpsVuiFlags
STD_VIDEO_H265_SLICE_TYPE_I
@ STD_VIDEO_H265_SLICE_TYPE_I
Definition: vulkan_video_codec_h265std.h:89
STD_VIDEO_H265_SLICE_TYPE_P
@ STD_VIDEO_H265_SLICE_TYPE_P
Definition: vulkan_video_codec_h265std.h:88
STD_VIDEO_H265_SLICE_TYPE_B
@ STD_VIDEO_H265_SLICE_TYPE_B
Definition: vulkan_video_codec_h265std.h:87
STD_VIDEO_H265_SLICE_TYPE_INVALID
@ STD_VIDEO_H265_SLICE_TYPE_INVALID
Definition: vulkan_video_codec_h265std.h:90
STD_VIDEO_H265_LEVEL_IDC_3_1
@ STD_VIDEO_H265_LEVEL_IDC_3_1
Definition: vulkan_video_codec_h265std.h:73
STD_VIDEO_H265_LEVEL_IDC_4_1
@ STD_VIDEO_H265_LEVEL_IDC_4_1
Definition: vulkan_video_codec_h265std.h:75
STD_VIDEO_H265_LEVEL_IDC_3_0
@ STD_VIDEO_H265_LEVEL_IDC_3_0
Definition: vulkan_video_codec_h265std.h:72
STD_VIDEO_H265_LEVEL_IDC_2_1
@ STD_VIDEO_H265_LEVEL_IDC_2_1
Definition: vulkan_video_codec_h265std.h:71
STD_VIDEO_H265_LEVEL_IDC_2_0
@ STD_VIDEO_H265_LEVEL_IDC_2_0
Definition: vulkan_video_codec_h265std.h:70
STD_VIDEO_H265_LEVEL_IDC_5_1
@ STD_VIDEO_H265_LEVEL_IDC_5_1
Definition: vulkan_video_codec_h265std.h:77
STD_VIDEO_H265_LEVEL_IDC_6_0
@ STD_VIDEO_H265_LEVEL_IDC_6_0
Definition: vulkan_video_codec_h265std.h:79
STD_VIDEO_H265_LEVEL_IDC_1_0
@ STD_VIDEO_H265_LEVEL_IDC_1_0
Definition: vulkan_video_codec_h265std.h:69
STD_VIDEO_H265_LEVEL_IDC_5_0
@ STD_VIDEO_H265_LEVEL_IDC_5_0
Definition: vulkan_video_codec_h265std.h:76
STD_VIDEO_H265_LEVEL_IDC_6_2
@ STD_VIDEO_H265_LEVEL_IDC_6_2
Definition: vulkan_video_codec_h265std.h:81
STD_VIDEO_H265_LEVEL_IDC_INVALID
@ STD_VIDEO_H265_LEVEL_IDC_INVALID
Definition: vulkan_video_codec_h265std.h:82
STD_VIDEO_H265_LEVEL_IDC_4_0
@ STD_VIDEO_H265_LEVEL_IDC_4_0
Definition: vulkan_video_codec_h265std.h:74
STD_VIDEO_H265_LEVEL_IDC_6_1
@ STD_VIDEO_H265_LEVEL_IDC_6_1
Definition: vulkan_video_codec_h265std.h:80
STD_VIDEO_H265_LEVEL_IDC_5_2
@ STD_VIDEO_H265_LEVEL_IDC_5_2
Definition: vulkan_video_codec_h265std.h:78
StdVideoH265HrdFlags
struct StdVideoH265HrdFlags StdVideoH265HrdFlags
StdVideoH265ShortTermRefPicSet
struct StdVideoH265ShortTermRefPicSet StdVideoH265ShortTermRefPicSet
STD_VIDEO_H265_PICTURE_TYPE_P
@ STD_VIDEO_H265_PICTURE_TYPE_P
Definition: vulkan_video_codec_h265std.h:95
STD_VIDEO_H265_PICTURE_TYPE_I
@ STD_VIDEO_H265_PICTURE_TYPE_I
Definition: vulkan_video_codec_h265std.h:97
STD_VIDEO_H265_PICTURE_TYPE_INVALID
@ STD_VIDEO_H265_PICTURE_TYPE_INVALID
Definition: vulkan_video_codec_h265std.h:99
STD_VIDEO_H265_PICTURE_TYPE_B
@ STD_VIDEO_H265_PICTURE_TYPE_B
Definition: vulkan_video_codec_h265std.h:96
STD_VIDEO_H265_PICTURE_TYPE_IDR
@ STD_VIDEO_H265_PICTURE_TYPE_IDR
Definition: vulkan_video_codec_h265std.h:98
StdVideoH265SpsFlags
struct StdVideoH265SpsFlags StdVideoH265SpsFlags
StdVideoH265ProfileTierLevelFlags
struct StdVideoH265ProfileTierLevelFlags StdVideoH265ProfileTierLevelFlags
StdVideoH265VpsFlags
struct StdVideoH265VpsFlags StdVideoH265VpsFlags
StdVideoH265SequenceParameterSetVui
struct StdVideoH265SequenceParameterSetVui StdVideoH265SequenceParameterSetVui
StdVideoH265PpsFlags
struct StdVideoH265PpsFlags StdVideoH265PpsFlags
StdVideoH265SequenceParameterSet
struct StdVideoH265SequenceParameterSet StdVideoH265SequenceParameterSet
StdVideoH265HrdParameters
struct StdVideoH265HrdParameters StdVideoH265HrdParameters
STD_VIDEO_H265_CHROMA_FORMAT_IDC_INVALID
@ STD_VIDEO_H265_CHROMA_FORMAT_IDC_INVALID
Definition: vulkan_video_codec_h265std.h:54
STD_VIDEO_H265_CHROMA_FORMAT_IDC_422
@ STD_VIDEO_H265_CHROMA_FORMAT_IDC_422
Definition: vulkan_video_codec_h265std.h:52
STD_VIDEO_H265_CHROMA_FORMAT_IDC_MONOCHROME
@ STD_VIDEO_H265_CHROMA_FORMAT_IDC_MONOCHROME
Definition: vulkan_video_codec_h265std.h:50
STD_VIDEO_H265_CHROMA_FORMAT_IDC_420
@ STD_VIDEO_H265_CHROMA_FORMAT_IDC_420
Definition: vulkan_video_codec_h265std.h:51
STD_VIDEO_H265_CHROMA_FORMAT_IDC_444
@ STD_VIDEO_H265_CHROMA_FORMAT_IDC_444
Definition: vulkan_video_codec_h265std.h:53
vulkan_video_codec_h265std_decode.h
StdVideoDecodeH265PictureInfoFlags
struct StdVideoDecodeH265PictureInfoFlags StdVideoDecodeH265PictureInfoFlags
StdVideoDecodeH265ReferenceInfo
struct StdVideoDecodeH265ReferenceInfo StdVideoDecodeH265ReferenceInfo
StdVideoDecodeH265PictureInfo
struct StdVideoDecodeH265PictureInfo StdVideoDecodeH265PictureInfo
StdVideoDecodeH265ReferenceInfoFlags
struct StdVideoDecodeH265ReferenceInfoFlags StdVideoDecodeH265ReferenceInfoFlags
vulkan_video_codec_h265std_encode.h
StdVideoEncodeH265ReferenceInfoFlags
struct StdVideoEncodeH265ReferenceInfoFlags StdVideoEncodeH265ReferenceInfoFlags
StdVideoEncodeH265ReferenceListsInfoFlags
struct StdVideoEncodeH265ReferenceListsInfoFlags StdVideoEncodeH265ReferenceListsInfoFlags
StdVideoEncodeH265WeightTable
struct StdVideoEncodeH265WeightTable StdVideoEncodeH265WeightTable
StdVideoEncodeH265PictureInfoFlags
struct StdVideoEncodeH265PictureInfoFlags StdVideoEncodeH265PictureInfoFlags
StdVideoEncodeH265ReferenceListsInfo
struct StdVideoEncodeH265ReferenceListsInfo StdVideoEncodeH265ReferenceListsInfo
StdVideoEncodeH265SliceSegmentHeaderFlags
struct StdVideoEncodeH265SliceSegmentHeaderFlags StdVideoEncodeH265SliceSegmentHeaderFlags
StdVideoEncodeH265PictureInfo
struct StdVideoEncodeH265PictureInfo StdVideoEncodeH265PictureInfo
StdVideoEncodeH265WeightTableFlags
struct StdVideoEncodeH265WeightTableFlags StdVideoEncodeH265WeightTableFlags
StdVideoEncodeH265SliceSegmentHeader
struct StdVideoEncodeH265SliceSegmentHeader StdVideoEncodeH265SliceSegmentHeader
StdVideoEncodeH265LongTermRefPics
struct StdVideoEncodeH265LongTermRefPics StdVideoEncodeH265LongTermRefPics
StdVideoEncodeH265ReferenceInfo
struct StdVideoEncodeH265ReferenceInfo StdVideoEncodeH265ReferenceInfo
vulkan_video_codecs_common.h