1#[repr(C)]
4#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
5pub struct __BindgenBitfieldUnit<Storage> {
6 storage: Storage,
7}
8impl<Storage> __BindgenBitfieldUnit<Storage> {
9 #[inline]
10 pub const fn new(storage: Storage) -> Self {
11 Self { storage }
12 }
13}
14impl<Storage> __BindgenBitfieldUnit<Storage>
15where
16 Storage: AsRef<[u8]> + AsMut<[u8]>,
17{
18 #[inline]
19 pub fn get_bit(&self, index: usize) -> bool {
20 debug_assert!(index / 8 < self.storage.as_ref().len());
21 let byte_index = index / 8;
22 let byte = self.storage.as_ref()[byte_index];
23 let bit_index = if cfg!(target_endian = "big") {
24 7 - (index % 8)
25 } else {
26 index % 8
27 };
28 let mask = 1 << bit_index;
29 byte & mask == mask
30 }
31 #[inline]
32 pub fn set_bit(&mut self, index: usize, val: bool) {
33 debug_assert!(index / 8 < self.storage.as_ref().len());
34 let byte_index = index / 8;
35 let byte = &mut self.storage.as_mut()[byte_index];
36 let bit_index = if cfg!(target_endian = "big") {
37 7 - (index % 8)
38 } else {
39 index % 8
40 };
41 let mask = 1 << bit_index;
42 if val {
43 *byte |= mask;
44 } else {
45 *byte &= !mask;
46 }
47 }
48 #[inline]
49 pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
50 debug_assert!(bit_width <= 64);
51 debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
52 debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
53 let mut val = 0;
54 for i in 0..(bit_width as usize) {
55 if self.get_bit(i + bit_offset) {
56 let index = if cfg!(target_endian = "big") {
57 bit_width as usize - 1 - i
58 } else {
59 i
60 };
61 val |= 1 << index;
62 }
63 }
64 val
65 }
66 #[inline]
67 pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
68 debug_assert!(bit_width <= 64);
69 debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
70 debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
71 for i in 0..(bit_width as usize) {
72 let mask = 1 << i;
73 let val_bit_is_set = val & mask == mask;
74 let index = if cfg!(target_endian = "big") {
75 bit_width as usize - 1 - i
76 } else {
77 i
78 };
79 self.set_bit(index + bit_offset, val_bit_is_set);
80 }
81 }
82}
83pub const StdVideoH264ChromaFormatIdc_STD_VIDEO_H264_CHROMA_FORMAT_IDC_MONOCHROME:
84 StdVideoH264ChromaFormatIdc = 0;
85pub const StdVideoH264ChromaFormatIdc_STD_VIDEO_H264_CHROMA_FORMAT_IDC_420:
86 StdVideoH264ChromaFormatIdc = 1;
87pub const StdVideoH264ChromaFormatIdc_STD_VIDEO_H264_CHROMA_FORMAT_IDC_422:
88 StdVideoH264ChromaFormatIdc = 2;
89pub const StdVideoH264ChromaFormatIdc_STD_VIDEO_H264_CHROMA_FORMAT_IDC_444:
90 StdVideoH264ChromaFormatIdc = 3;
91pub const StdVideoH264ChromaFormatIdc_STD_VIDEO_H264_CHROMA_FORMAT_IDC_INVALID:
92 StdVideoH264ChromaFormatIdc = 2147483647;
93pub type StdVideoH264ChromaFormatIdc = ::std::os::raw::c_uint;
94pub const StdVideoH264ProfileIdc_STD_VIDEO_H264_PROFILE_IDC_BASELINE: StdVideoH264ProfileIdc = 66;
95pub const StdVideoH264ProfileIdc_STD_VIDEO_H264_PROFILE_IDC_MAIN: StdVideoH264ProfileIdc = 77;
96pub const StdVideoH264ProfileIdc_STD_VIDEO_H264_PROFILE_IDC_HIGH: StdVideoH264ProfileIdc = 100;
97pub const StdVideoH264ProfileIdc_STD_VIDEO_H264_PROFILE_IDC_HIGH_444_PREDICTIVE:
98 StdVideoH264ProfileIdc = 244;
99pub const StdVideoH264ProfileIdc_STD_VIDEO_H264_PROFILE_IDC_INVALID: StdVideoH264ProfileIdc =
100 2147483647;
101pub type StdVideoH264ProfileIdc = ::std::os::raw::c_uint;
102pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_1_0: StdVideoH264LevelIdc = 0;
103pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_1_1: StdVideoH264LevelIdc = 1;
104pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_1_2: StdVideoH264LevelIdc = 2;
105pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_1_3: StdVideoH264LevelIdc = 3;
106pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_2_0: StdVideoH264LevelIdc = 4;
107pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_2_1: StdVideoH264LevelIdc = 5;
108pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_2_2: StdVideoH264LevelIdc = 6;
109pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_3_0: StdVideoH264LevelIdc = 7;
110pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_3_1: StdVideoH264LevelIdc = 8;
111pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_3_2: StdVideoH264LevelIdc = 9;
112pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_4_0: StdVideoH264LevelIdc = 10;
113pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_4_1: StdVideoH264LevelIdc = 11;
114pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_4_2: StdVideoH264LevelIdc = 12;
115pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_5_0: StdVideoH264LevelIdc = 13;
116pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_5_1: StdVideoH264LevelIdc = 14;
117pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_5_2: StdVideoH264LevelIdc = 15;
118pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_6_0: StdVideoH264LevelIdc = 16;
119pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_6_1: StdVideoH264LevelIdc = 17;
120pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_6_2: StdVideoH264LevelIdc = 18;
121pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_INVALID: StdVideoH264LevelIdc = 2147483647;
122pub type StdVideoH264LevelIdc = ::std::os::raw::c_uint;
123pub const StdVideoH264PocType_STD_VIDEO_H264_POC_TYPE_0: StdVideoH264PocType = 0;
124pub const StdVideoH264PocType_STD_VIDEO_H264_POC_TYPE_1: StdVideoH264PocType = 1;
125pub const StdVideoH264PocType_STD_VIDEO_H264_POC_TYPE_2: StdVideoH264PocType = 2;
126pub const StdVideoH264PocType_STD_VIDEO_H264_POC_TYPE_INVALID: StdVideoH264PocType = 2147483647;
127pub type StdVideoH264PocType = ::std::os::raw::c_uint;
128pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_UNSPECIFIED:
129 StdVideoH264AspectRatioIdc = 0;
130pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_SQUARE:
131 StdVideoH264AspectRatioIdc = 1;
132pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_12_11:
133 StdVideoH264AspectRatioIdc = 2;
134pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_10_11:
135 StdVideoH264AspectRatioIdc = 3;
136pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_16_11:
137 StdVideoH264AspectRatioIdc = 4;
138pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_40_33:
139 StdVideoH264AspectRatioIdc = 5;
140pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_24_11:
141 StdVideoH264AspectRatioIdc = 6;
142pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_20_11:
143 StdVideoH264AspectRatioIdc = 7;
144pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_32_11:
145 StdVideoH264AspectRatioIdc = 8;
146pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_80_33:
147 StdVideoH264AspectRatioIdc = 9;
148pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_18_11:
149 StdVideoH264AspectRatioIdc = 10;
150pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_15_11:
151 StdVideoH264AspectRatioIdc = 11;
152pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_64_33:
153 StdVideoH264AspectRatioIdc = 12;
154pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_160_99:
155 StdVideoH264AspectRatioIdc = 13;
156pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_4_3:
157 StdVideoH264AspectRatioIdc = 14;
158pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_3_2:
159 StdVideoH264AspectRatioIdc = 15;
160pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_2_1:
161 StdVideoH264AspectRatioIdc = 16;
162pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_EXTENDED_SAR:
163 StdVideoH264AspectRatioIdc = 255;
164pub const StdVideoH264AspectRatioIdc_STD_VIDEO_H264_ASPECT_RATIO_IDC_INVALID:
165 StdVideoH264AspectRatioIdc = 2147483647;
166pub type StdVideoH264AspectRatioIdc = ::std::os::raw::c_uint;
167pub const StdVideoH264WeightedBipredIdc_STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_DEFAULT:
168 StdVideoH264WeightedBipredIdc = 0;
169pub const StdVideoH264WeightedBipredIdc_STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_EXPLICIT:
170 StdVideoH264WeightedBipredIdc = 1;
171pub const StdVideoH264WeightedBipredIdc_STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_IMPLICIT:
172 StdVideoH264WeightedBipredIdc = 2;
173pub const StdVideoH264WeightedBipredIdc_STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_INVALID:
174 StdVideoH264WeightedBipredIdc = 2147483647;
175pub type StdVideoH264WeightedBipredIdc = ::std::os::raw::c_uint;
176pub const StdVideoH264ModificationOfPicNumsIdc_STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_SHORT_TERM_SUBTRACT : StdVideoH264ModificationOfPicNumsIdc = 0 ;
177pub const StdVideoH264ModificationOfPicNumsIdc_STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_SHORT_TERM_ADD : StdVideoH264ModificationOfPicNumsIdc = 1 ;
178pub const StdVideoH264ModificationOfPicNumsIdc_STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_LONG_TERM : StdVideoH264ModificationOfPicNumsIdc = 2 ;
179pub const StdVideoH264ModificationOfPicNumsIdc_STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_END:
180 StdVideoH264ModificationOfPicNumsIdc = 3;
181pub const StdVideoH264ModificationOfPicNumsIdc_STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_INVALID : StdVideoH264ModificationOfPicNumsIdc = 2147483647 ;
182pub type StdVideoH264ModificationOfPicNumsIdc = ::std::os::raw::c_uint;
183pub const StdVideoH264MemMgmtControlOp_STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_END:
184 StdVideoH264MemMgmtControlOp = 0;
185pub const StdVideoH264MemMgmtControlOp_STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_SHORT_TERM:
186 StdVideoH264MemMgmtControlOp = 1;
187pub const StdVideoH264MemMgmtControlOp_STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_LONG_TERM:
188 StdVideoH264MemMgmtControlOp = 2;
189pub const StdVideoH264MemMgmtControlOp_STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_MARK_LONG_TERM:
190 StdVideoH264MemMgmtControlOp = 3;
191pub const StdVideoH264MemMgmtControlOp_STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_SET_MAX_LONG_TERM_INDEX : StdVideoH264MemMgmtControlOp = 4 ;
192pub const StdVideoH264MemMgmtControlOp_STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_ALL:
193 StdVideoH264MemMgmtControlOp = 5;
194pub const StdVideoH264MemMgmtControlOp_STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_MARK_CURRENT_AS_LONG_TERM : StdVideoH264MemMgmtControlOp = 6 ;
195pub const StdVideoH264MemMgmtControlOp_STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_INVALID:
196 StdVideoH264MemMgmtControlOp = 2147483647;
197pub type StdVideoH264MemMgmtControlOp = ::std::os::raw::c_uint;
198pub const StdVideoH264CabacInitIdc_STD_VIDEO_H264_CABAC_INIT_IDC_0: StdVideoH264CabacInitIdc = 0;
199pub const StdVideoH264CabacInitIdc_STD_VIDEO_H264_CABAC_INIT_IDC_1: StdVideoH264CabacInitIdc = 1;
200pub const StdVideoH264CabacInitIdc_STD_VIDEO_H264_CABAC_INIT_IDC_2: StdVideoH264CabacInitIdc = 2;
201pub const StdVideoH264CabacInitIdc_STD_VIDEO_H264_CABAC_INIT_IDC_INVALID: StdVideoH264CabacInitIdc =
202 2147483647;
203pub type StdVideoH264CabacInitIdc = ::std::os::raw::c_uint;
204pub const StdVideoH264DisableDeblockingFilterIdc_STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_DISABLED : StdVideoH264DisableDeblockingFilterIdc = 0 ;
205pub const StdVideoH264DisableDeblockingFilterIdc_STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_ENABLED : StdVideoH264DisableDeblockingFilterIdc = 1 ;
206pub const StdVideoH264DisableDeblockingFilterIdc_STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_PARTIAL : StdVideoH264DisableDeblockingFilterIdc = 2 ;
207pub const StdVideoH264DisableDeblockingFilterIdc_STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_INVALID : StdVideoH264DisableDeblockingFilterIdc = 2147483647 ;
208pub type StdVideoH264DisableDeblockingFilterIdc = ::std::os::raw::c_uint;
209pub const StdVideoH264SliceType_STD_VIDEO_H264_SLICE_TYPE_P: StdVideoH264SliceType = 0;
210pub const StdVideoH264SliceType_STD_VIDEO_H264_SLICE_TYPE_B: StdVideoH264SliceType = 1;
211pub const StdVideoH264SliceType_STD_VIDEO_H264_SLICE_TYPE_I: StdVideoH264SliceType = 2;
212pub const StdVideoH264SliceType_STD_VIDEO_H264_SLICE_TYPE_INVALID: StdVideoH264SliceType =
213 2147483647;
214pub type StdVideoH264SliceType = ::std::os::raw::c_uint;
215pub const StdVideoH264PictureType_STD_VIDEO_H264_PICTURE_TYPE_P: StdVideoH264PictureType = 0;
216pub const StdVideoH264PictureType_STD_VIDEO_H264_PICTURE_TYPE_B: StdVideoH264PictureType = 1;
217pub const StdVideoH264PictureType_STD_VIDEO_H264_PICTURE_TYPE_I: StdVideoH264PictureType = 2;
218pub const StdVideoH264PictureType_STD_VIDEO_H264_PICTURE_TYPE_IDR: StdVideoH264PictureType = 5;
219pub const StdVideoH264PictureType_STD_VIDEO_H264_PICTURE_TYPE_INVALID: StdVideoH264PictureType =
220 2147483647;
221pub type StdVideoH264PictureType = ::std::os::raw::c_uint;
222#[repr(C)]
223#[repr(align(4))]
224#[derive(Debug, Copy, Clone)]
225pub struct StdVideoH264SpsVuiFlags {
226 pub _bitfield_align_1: [u8; 0],
227 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
228 pub __bindgen_padding_0: u16,
229}
230#[test]
231fn bindgen_test_layout_StdVideoH264SpsVuiFlags() {
232 assert_eq!(
233 ::std::mem::size_of::<StdVideoH264SpsVuiFlags>(),
234 4usize,
235 concat!("Size of: ", stringify!(StdVideoH264SpsVuiFlags))
236 );
237 assert_eq!(
238 ::std::mem::align_of::<StdVideoH264SpsVuiFlags>(),
239 4usize,
240 concat!("Alignment of ", stringify!(StdVideoH264SpsVuiFlags))
241 );
242}
243impl StdVideoH264SpsVuiFlags {
244 #[inline]
245 pub fn aspect_ratio_info_present_flag(&self) -> u32 {
246 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
247 }
248 #[inline]
249 pub fn set_aspect_ratio_info_present_flag(&mut self, val: u32) {
250 unsafe {
251 let val: u32 = ::std::mem::transmute(val);
252 self._bitfield_1.set(0usize, 1u8, val as u64)
253 }
254 }
255 #[inline]
256 pub fn overscan_info_present_flag(&self) -> u32 {
257 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
258 }
259 #[inline]
260 pub fn set_overscan_info_present_flag(&mut self, val: u32) {
261 unsafe {
262 let val: u32 = ::std::mem::transmute(val);
263 self._bitfield_1.set(1usize, 1u8, val as u64)
264 }
265 }
266 #[inline]
267 pub fn overscan_appropriate_flag(&self) -> u32 {
268 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
269 }
270 #[inline]
271 pub fn set_overscan_appropriate_flag(&mut self, val: u32) {
272 unsafe {
273 let val: u32 = ::std::mem::transmute(val);
274 self._bitfield_1.set(2usize, 1u8, val as u64)
275 }
276 }
277 #[inline]
278 pub fn video_signal_type_present_flag(&self) -> u32 {
279 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
280 }
281 #[inline]
282 pub fn set_video_signal_type_present_flag(&mut self, val: u32) {
283 unsafe {
284 let val: u32 = ::std::mem::transmute(val);
285 self._bitfield_1.set(3usize, 1u8, val as u64)
286 }
287 }
288 #[inline]
289 pub fn video_full_range_flag(&self) -> u32 {
290 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
291 }
292 #[inline]
293 pub fn set_video_full_range_flag(&mut self, val: u32) {
294 unsafe {
295 let val: u32 = ::std::mem::transmute(val);
296 self._bitfield_1.set(4usize, 1u8, val as u64)
297 }
298 }
299 #[inline]
300 pub fn color_description_present_flag(&self) -> u32 {
301 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
302 }
303 #[inline]
304 pub fn set_color_description_present_flag(&mut self, val: u32) {
305 unsafe {
306 let val: u32 = ::std::mem::transmute(val);
307 self._bitfield_1.set(5usize, 1u8, val as u64)
308 }
309 }
310 #[inline]
311 pub fn chroma_loc_info_present_flag(&self) -> u32 {
312 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) }
313 }
314 #[inline]
315 pub fn set_chroma_loc_info_present_flag(&mut self, val: u32) {
316 unsafe {
317 let val: u32 = ::std::mem::transmute(val);
318 self._bitfield_1.set(6usize, 1u8, val as u64)
319 }
320 }
321 #[inline]
322 pub fn timing_info_present_flag(&self) -> u32 {
323 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) }
324 }
325 #[inline]
326 pub fn set_timing_info_present_flag(&mut self, val: u32) {
327 unsafe {
328 let val: u32 = ::std::mem::transmute(val);
329 self._bitfield_1.set(7usize, 1u8, val as u64)
330 }
331 }
332 #[inline]
333 pub fn fixed_frame_rate_flag(&self) -> u32 {
334 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) }
335 }
336 #[inline]
337 pub fn set_fixed_frame_rate_flag(&mut self, val: u32) {
338 unsafe {
339 let val: u32 = ::std::mem::transmute(val);
340 self._bitfield_1.set(8usize, 1u8, val as u64)
341 }
342 }
343 #[inline]
344 pub fn bitstream_restriction_flag(&self) -> u32 {
345 unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) }
346 }
347 #[inline]
348 pub fn set_bitstream_restriction_flag(&mut self, val: u32) {
349 unsafe {
350 let val: u32 = ::std::mem::transmute(val);
351 self._bitfield_1.set(9usize, 1u8, val as u64)
352 }
353 }
354 #[inline]
355 pub fn nal_hrd_parameters_present_flag(&self) -> u32 {
356 unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) }
357 }
358 #[inline]
359 pub fn set_nal_hrd_parameters_present_flag(&mut self, val: u32) {
360 unsafe {
361 let val: u32 = ::std::mem::transmute(val);
362 self._bitfield_1.set(10usize, 1u8, val as u64)
363 }
364 }
365 #[inline]
366 pub fn vcl_hrd_parameters_present_flag(&self) -> u32 {
367 unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) }
368 }
369 #[inline]
370 pub fn set_vcl_hrd_parameters_present_flag(&mut self, val: u32) {
371 unsafe {
372 let val: u32 = ::std::mem::transmute(val);
373 self._bitfield_1.set(11usize, 1u8, val as u64)
374 }
375 }
376 #[inline]
377 pub fn new_bitfield_1(
378 aspect_ratio_info_present_flag: u32,
379 overscan_info_present_flag: u32,
380 overscan_appropriate_flag: u32,
381 video_signal_type_present_flag: u32,
382 video_full_range_flag: u32,
383 color_description_present_flag: u32,
384 chroma_loc_info_present_flag: u32,
385 timing_info_present_flag: u32,
386 fixed_frame_rate_flag: u32,
387 bitstream_restriction_flag: u32,
388 nal_hrd_parameters_present_flag: u32,
389 vcl_hrd_parameters_present_flag: u32,
390 ) -> __BindgenBitfieldUnit<[u8; 2usize]> {
391 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default();
392 __bindgen_bitfield_unit.set(0usize, 1u8, {
393 let aspect_ratio_info_present_flag: u32 =
394 unsafe { ::std::mem::transmute(aspect_ratio_info_present_flag) };
395 aspect_ratio_info_present_flag as u64
396 });
397 __bindgen_bitfield_unit.set(1usize, 1u8, {
398 let overscan_info_present_flag: u32 =
399 unsafe { ::std::mem::transmute(overscan_info_present_flag) };
400 overscan_info_present_flag as u64
401 });
402 __bindgen_bitfield_unit.set(2usize, 1u8, {
403 let overscan_appropriate_flag: u32 =
404 unsafe { ::std::mem::transmute(overscan_appropriate_flag) };
405 overscan_appropriate_flag as u64
406 });
407 __bindgen_bitfield_unit.set(3usize, 1u8, {
408 let video_signal_type_present_flag: u32 =
409 unsafe { ::std::mem::transmute(video_signal_type_present_flag) };
410 video_signal_type_present_flag as u64
411 });
412 __bindgen_bitfield_unit.set(4usize, 1u8, {
413 let video_full_range_flag: u32 =
414 unsafe { ::std::mem::transmute(video_full_range_flag) };
415 video_full_range_flag as u64
416 });
417 __bindgen_bitfield_unit.set(5usize, 1u8, {
418 let color_description_present_flag: u32 =
419 unsafe { ::std::mem::transmute(color_description_present_flag) };
420 color_description_present_flag as u64
421 });
422 __bindgen_bitfield_unit.set(6usize, 1u8, {
423 let chroma_loc_info_present_flag: u32 =
424 unsafe { ::std::mem::transmute(chroma_loc_info_present_flag) };
425 chroma_loc_info_present_flag as u64
426 });
427 __bindgen_bitfield_unit.set(7usize, 1u8, {
428 let timing_info_present_flag: u32 =
429 unsafe { ::std::mem::transmute(timing_info_present_flag) };
430 timing_info_present_flag as u64
431 });
432 __bindgen_bitfield_unit.set(8usize, 1u8, {
433 let fixed_frame_rate_flag: u32 =
434 unsafe { ::std::mem::transmute(fixed_frame_rate_flag) };
435 fixed_frame_rate_flag as u64
436 });
437 __bindgen_bitfield_unit.set(9usize, 1u8, {
438 let bitstream_restriction_flag: u32 =
439 unsafe { ::std::mem::transmute(bitstream_restriction_flag) };
440 bitstream_restriction_flag as u64
441 });
442 __bindgen_bitfield_unit.set(10usize, 1u8, {
443 let nal_hrd_parameters_present_flag: u32 =
444 unsafe { ::std::mem::transmute(nal_hrd_parameters_present_flag) };
445 nal_hrd_parameters_present_flag as u64
446 });
447 __bindgen_bitfield_unit.set(11usize, 1u8, {
448 let vcl_hrd_parameters_present_flag: u32 =
449 unsafe { ::std::mem::transmute(vcl_hrd_parameters_present_flag) };
450 vcl_hrd_parameters_present_flag as u64
451 });
452 __bindgen_bitfield_unit
453 }
454}
455#[repr(C)]
456#[derive(Debug, Copy, Clone)]
457pub struct StdVideoH264HrdParameters {
458 pub cpb_cnt_minus1: u8,
459 pub bit_rate_scale: u8,
460 pub cpb_size_scale: u8,
461 pub reserved1: u8,
462 pub bit_rate_value_minus1: [u32; 32usize],
463 pub cpb_size_value_minus1: [u32; 32usize],
464 pub cbr_flag: [u8; 32usize],
465 pub initial_cpb_removal_delay_length_minus1: u32,
466 pub cpb_removal_delay_length_minus1: u32,
467 pub dpb_output_delay_length_minus1: u32,
468 pub time_offset_length: u32,
469}
470#[test]
471fn bindgen_test_layout_StdVideoH264HrdParameters() {
472 const UNINIT: ::std::mem::MaybeUninit<StdVideoH264HrdParameters> =
473 ::std::mem::MaybeUninit::uninit();
474 let ptr = UNINIT.as_ptr();
475 assert_eq!(
476 ::std::mem::size_of::<StdVideoH264HrdParameters>(),
477 308usize,
478 concat!("Size of: ", stringify!(StdVideoH264HrdParameters))
479 );
480 assert_eq!(
481 ::std::mem::align_of::<StdVideoH264HrdParameters>(),
482 4usize,
483 concat!("Alignment of ", stringify!(StdVideoH264HrdParameters))
484 );
485 assert_eq!(
486 unsafe { ::std::ptr::addr_of!((*ptr).cpb_cnt_minus1) as usize - ptr as usize },
487 0usize,
488 concat!(
489 "Offset of field: ",
490 stringify!(StdVideoH264HrdParameters),
491 "::",
492 stringify!(cpb_cnt_minus1)
493 )
494 );
495 assert_eq!(
496 unsafe { ::std::ptr::addr_of!((*ptr).bit_rate_scale) as usize - ptr as usize },
497 1usize,
498 concat!(
499 "Offset of field: ",
500 stringify!(StdVideoH264HrdParameters),
501 "::",
502 stringify!(bit_rate_scale)
503 )
504 );
505 assert_eq!(
506 unsafe { ::std::ptr::addr_of!((*ptr).cpb_size_scale) as usize - ptr as usize },
507 2usize,
508 concat!(
509 "Offset of field: ",
510 stringify!(StdVideoH264HrdParameters),
511 "::",
512 stringify!(cpb_size_scale)
513 )
514 );
515 assert_eq!(
516 unsafe { ::std::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize },
517 3usize,
518 concat!(
519 "Offset of field: ",
520 stringify!(StdVideoH264HrdParameters),
521 "::",
522 stringify!(reserved1)
523 )
524 );
525 assert_eq!(
526 unsafe { ::std::ptr::addr_of!((*ptr).bit_rate_value_minus1) as usize - ptr as usize },
527 4usize,
528 concat!(
529 "Offset of field: ",
530 stringify!(StdVideoH264HrdParameters),
531 "::",
532 stringify!(bit_rate_value_minus1)
533 )
534 );
535 assert_eq!(
536 unsafe { ::std::ptr::addr_of!((*ptr).cpb_size_value_minus1) as usize - ptr as usize },
537 132usize,
538 concat!(
539 "Offset of field: ",
540 stringify!(StdVideoH264HrdParameters),
541 "::",
542 stringify!(cpb_size_value_minus1)
543 )
544 );
545 assert_eq!(
546 unsafe { ::std::ptr::addr_of!((*ptr).cbr_flag) as usize - ptr as usize },
547 260usize,
548 concat!(
549 "Offset of field: ",
550 stringify!(StdVideoH264HrdParameters),
551 "::",
552 stringify!(cbr_flag)
553 )
554 );
555 assert_eq!(
556 unsafe {
557 ::std::ptr::addr_of!((*ptr).initial_cpb_removal_delay_length_minus1) as usize
558 - ptr as usize
559 },
560 292usize,
561 concat!(
562 "Offset of field: ",
563 stringify!(StdVideoH264HrdParameters),
564 "::",
565 stringify!(initial_cpb_removal_delay_length_minus1)
566 )
567 );
568 assert_eq!(
569 unsafe {
570 ::std::ptr::addr_of!((*ptr).cpb_removal_delay_length_minus1) as usize - ptr as usize
571 },
572 296usize,
573 concat!(
574 "Offset of field: ",
575 stringify!(StdVideoH264HrdParameters),
576 "::",
577 stringify!(cpb_removal_delay_length_minus1)
578 )
579 );
580 assert_eq!(
581 unsafe {
582 ::std::ptr::addr_of!((*ptr).dpb_output_delay_length_minus1) as usize - ptr as usize
583 },
584 300usize,
585 concat!(
586 "Offset of field: ",
587 stringify!(StdVideoH264HrdParameters),
588 "::",
589 stringify!(dpb_output_delay_length_minus1)
590 )
591 );
592 assert_eq!(
593 unsafe { ::std::ptr::addr_of!((*ptr).time_offset_length) as usize - ptr as usize },
594 304usize,
595 concat!(
596 "Offset of field: ",
597 stringify!(StdVideoH264HrdParameters),
598 "::",
599 stringify!(time_offset_length)
600 )
601 );
602}
603#[repr(C)]
604#[derive(Debug, Copy, Clone)]
605pub struct StdVideoH264SequenceParameterSetVui {
606 pub flags: StdVideoH264SpsVuiFlags,
607 pub aspect_ratio_idc: StdVideoH264AspectRatioIdc,
608 pub sar_width: u16,
609 pub sar_height: u16,
610 pub video_format: u8,
611 pub colour_primaries: u8,
612 pub transfer_characteristics: u8,
613 pub matrix_coefficients: u8,
614 pub num_units_in_tick: u32,
615 pub time_scale: u32,
616 pub max_num_reorder_frames: u8,
617 pub max_dec_frame_buffering: u8,
618 pub chroma_sample_loc_type_top_field: u8,
619 pub chroma_sample_loc_type_bottom_field: u8,
620 pub reserved1: u32,
621 pub pHrdParameters: *const StdVideoH264HrdParameters,
622}
623#[test]
624fn bindgen_test_layout_StdVideoH264SequenceParameterSetVui() {
625 const UNINIT: ::std::mem::MaybeUninit<StdVideoH264SequenceParameterSetVui> =
626 ::std::mem::MaybeUninit::uninit();
627 let ptr = UNINIT.as_ptr();
628 assert_eq!(
629 ::std::mem::size_of::<StdVideoH264SequenceParameterSetVui>(),
630 40usize,
631 concat!("Size of: ", stringify!(StdVideoH264SequenceParameterSetVui))
632 );
633 assert_eq!(
634 ::std::mem::align_of::<StdVideoH264SequenceParameterSetVui>(),
635 8usize,
636 concat!(
637 "Alignment of ",
638 stringify!(StdVideoH264SequenceParameterSetVui)
639 )
640 );
641 assert_eq!(
642 unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
643 0usize,
644 concat!(
645 "Offset of field: ",
646 stringify!(StdVideoH264SequenceParameterSetVui),
647 "::",
648 stringify!(flags)
649 )
650 );
651 assert_eq!(
652 unsafe { ::std::ptr::addr_of!((*ptr).aspect_ratio_idc) as usize - ptr as usize },
653 4usize,
654 concat!(
655 "Offset of field: ",
656 stringify!(StdVideoH264SequenceParameterSetVui),
657 "::",
658 stringify!(aspect_ratio_idc)
659 )
660 );
661 assert_eq!(
662 unsafe { ::std::ptr::addr_of!((*ptr).sar_width) as usize - ptr as usize },
663 8usize,
664 concat!(
665 "Offset of field: ",
666 stringify!(StdVideoH264SequenceParameterSetVui),
667 "::",
668 stringify!(sar_width)
669 )
670 );
671 assert_eq!(
672 unsafe { ::std::ptr::addr_of!((*ptr).sar_height) as usize - ptr as usize },
673 10usize,
674 concat!(
675 "Offset of field: ",
676 stringify!(StdVideoH264SequenceParameterSetVui),
677 "::",
678 stringify!(sar_height)
679 )
680 );
681 assert_eq!(
682 unsafe { ::std::ptr::addr_of!((*ptr).video_format) as usize - ptr as usize },
683 12usize,
684 concat!(
685 "Offset of field: ",
686 stringify!(StdVideoH264SequenceParameterSetVui),
687 "::",
688 stringify!(video_format)
689 )
690 );
691 assert_eq!(
692 unsafe { ::std::ptr::addr_of!((*ptr).colour_primaries) as usize - ptr as usize },
693 13usize,
694 concat!(
695 "Offset of field: ",
696 stringify!(StdVideoH264SequenceParameterSetVui),
697 "::",
698 stringify!(colour_primaries)
699 )
700 );
701 assert_eq!(
702 unsafe { ::std::ptr::addr_of!((*ptr).transfer_characteristics) as usize - ptr as usize },
703 14usize,
704 concat!(
705 "Offset of field: ",
706 stringify!(StdVideoH264SequenceParameterSetVui),
707 "::",
708 stringify!(transfer_characteristics)
709 )
710 );
711 assert_eq!(
712 unsafe { ::std::ptr::addr_of!((*ptr).matrix_coefficients) as usize - ptr as usize },
713 15usize,
714 concat!(
715 "Offset of field: ",
716 stringify!(StdVideoH264SequenceParameterSetVui),
717 "::",
718 stringify!(matrix_coefficients)
719 )
720 );
721 assert_eq!(
722 unsafe { ::std::ptr::addr_of!((*ptr).num_units_in_tick) as usize - ptr as usize },
723 16usize,
724 concat!(
725 "Offset of field: ",
726 stringify!(StdVideoH264SequenceParameterSetVui),
727 "::",
728 stringify!(num_units_in_tick)
729 )
730 );
731 assert_eq!(
732 unsafe { ::std::ptr::addr_of!((*ptr).time_scale) as usize - ptr as usize },
733 20usize,
734 concat!(
735 "Offset of field: ",
736 stringify!(StdVideoH264SequenceParameterSetVui),
737 "::",
738 stringify!(time_scale)
739 )
740 );
741 assert_eq!(
742 unsafe { ::std::ptr::addr_of!((*ptr).max_num_reorder_frames) as usize - ptr as usize },
743 24usize,
744 concat!(
745 "Offset of field: ",
746 stringify!(StdVideoH264SequenceParameterSetVui),
747 "::",
748 stringify!(max_num_reorder_frames)
749 )
750 );
751 assert_eq!(
752 unsafe { ::std::ptr::addr_of!((*ptr).max_dec_frame_buffering) as usize - ptr as usize },
753 25usize,
754 concat!(
755 "Offset of field: ",
756 stringify!(StdVideoH264SequenceParameterSetVui),
757 "::",
758 stringify!(max_dec_frame_buffering)
759 )
760 );
761 assert_eq!(
762 unsafe {
763 ::std::ptr::addr_of!((*ptr).chroma_sample_loc_type_top_field) as usize - ptr as usize
764 },
765 26usize,
766 concat!(
767 "Offset of field: ",
768 stringify!(StdVideoH264SequenceParameterSetVui),
769 "::",
770 stringify!(chroma_sample_loc_type_top_field)
771 )
772 );
773 assert_eq!(
774 unsafe {
775 ::std::ptr::addr_of!((*ptr).chroma_sample_loc_type_bottom_field) as usize - ptr as usize
776 },
777 27usize,
778 concat!(
779 "Offset of field: ",
780 stringify!(StdVideoH264SequenceParameterSetVui),
781 "::",
782 stringify!(chroma_sample_loc_type_bottom_field)
783 )
784 );
785 assert_eq!(
786 unsafe { ::std::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize },
787 28usize,
788 concat!(
789 "Offset of field: ",
790 stringify!(StdVideoH264SequenceParameterSetVui),
791 "::",
792 stringify!(reserved1)
793 )
794 );
795 assert_eq!(
796 unsafe { ::std::ptr::addr_of!((*ptr).pHrdParameters) as usize - ptr as usize },
797 32usize,
798 concat!(
799 "Offset of field: ",
800 stringify!(StdVideoH264SequenceParameterSetVui),
801 "::",
802 stringify!(pHrdParameters)
803 )
804 );
805}
806#[repr(C)]
807#[repr(align(4))]
808#[derive(Debug, Copy, Clone)]
809pub struct StdVideoH264SpsFlags {
810 pub _bitfield_align_1: [u8; 0],
811 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
812 pub __bindgen_padding_0: u16,
813}
814#[test]
815fn bindgen_test_layout_StdVideoH264SpsFlags() {
816 assert_eq!(
817 ::std::mem::size_of::<StdVideoH264SpsFlags>(),
818 4usize,
819 concat!("Size of: ", stringify!(StdVideoH264SpsFlags))
820 );
821 assert_eq!(
822 ::std::mem::align_of::<StdVideoH264SpsFlags>(),
823 4usize,
824 concat!("Alignment of ", stringify!(StdVideoH264SpsFlags))
825 );
826}
827impl StdVideoH264SpsFlags {
828 #[inline]
829 pub fn constraint_set0_flag(&self) -> u32 {
830 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
831 }
832 #[inline]
833 pub fn set_constraint_set0_flag(&mut self, val: u32) {
834 unsafe {
835 let val: u32 = ::std::mem::transmute(val);
836 self._bitfield_1.set(0usize, 1u8, val as u64)
837 }
838 }
839 #[inline]
840 pub fn constraint_set1_flag(&self) -> u32 {
841 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
842 }
843 #[inline]
844 pub fn set_constraint_set1_flag(&mut self, val: u32) {
845 unsafe {
846 let val: u32 = ::std::mem::transmute(val);
847 self._bitfield_1.set(1usize, 1u8, val as u64)
848 }
849 }
850 #[inline]
851 pub fn constraint_set2_flag(&self) -> u32 {
852 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
853 }
854 #[inline]
855 pub fn set_constraint_set2_flag(&mut self, val: u32) {
856 unsafe {
857 let val: u32 = ::std::mem::transmute(val);
858 self._bitfield_1.set(2usize, 1u8, val as u64)
859 }
860 }
861 #[inline]
862 pub fn constraint_set3_flag(&self) -> u32 {
863 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
864 }
865 #[inline]
866 pub fn set_constraint_set3_flag(&mut self, val: u32) {
867 unsafe {
868 let val: u32 = ::std::mem::transmute(val);
869 self._bitfield_1.set(3usize, 1u8, val as u64)
870 }
871 }
872 #[inline]
873 pub fn constraint_set4_flag(&self) -> u32 {
874 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
875 }
876 #[inline]
877 pub fn set_constraint_set4_flag(&mut self, val: u32) {
878 unsafe {
879 let val: u32 = ::std::mem::transmute(val);
880 self._bitfield_1.set(4usize, 1u8, val as u64)
881 }
882 }
883 #[inline]
884 pub fn constraint_set5_flag(&self) -> u32 {
885 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
886 }
887 #[inline]
888 pub fn set_constraint_set5_flag(&mut self, val: u32) {
889 unsafe {
890 let val: u32 = ::std::mem::transmute(val);
891 self._bitfield_1.set(5usize, 1u8, val as u64)
892 }
893 }
894 #[inline]
895 pub fn direct_8x8_inference_flag(&self) -> u32 {
896 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) }
897 }
898 #[inline]
899 pub fn set_direct_8x8_inference_flag(&mut self, val: u32) {
900 unsafe {
901 let val: u32 = ::std::mem::transmute(val);
902 self._bitfield_1.set(6usize, 1u8, val as u64)
903 }
904 }
905 #[inline]
906 pub fn mb_adaptive_frame_field_flag(&self) -> u32 {
907 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) }
908 }
909 #[inline]
910 pub fn set_mb_adaptive_frame_field_flag(&mut self, val: u32) {
911 unsafe {
912 let val: u32 = ::std::mem::transmute(val);
913 self._bitfield_1.set(7usize, 1u8, val as u64)
914 }
915 }
916 #[inline]
917 pub fn frame_mbs_only_flag(&self) -> u32 {
918 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) }
919 }
920 #[inline]
921 pub fn set_frame_mbs_only_flag(&mut self, val: u32) {
922 unsafe {
923 let val: u32 = ::std::mem::transmute(val);
924 self._bitfield_1.set(8usize, 1u8, val as u64)
925 }
926 }
927 #[inline]
928 pub fn delta_pic_order_always_zero_flag(&self) -> u32 {
929 unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) }
930 }
931 #[inline]
932 pub fn set_delta_pic_order_always_zero_flag(&mut self, val: u32) {
933 unsafe {
934 let val: u32 = ::std::mem::transmute(val);
935 self._bitfield_1.set(9usize, 1u8, val as u64)
936 }
937 }
938 #[inline]
939 pub fn separate_colour_plane_flag(&self) -> u32 {
940 unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) }
941 }
942 #[inline]
943 pub fn set_separate_colour_plane_flag(&mut self, val: u32) {
944 unsafe {
945 let val: u32 = ::std::mem::transmute(val);
946 self._bitfield_1.set(10usize, 1u8, val as u64)
947 }
948 }
949 #[inline]
950 pub fn gaps_in_frame_num_value_allowed_flag(&self) -> u32 {
951 unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) }
952 }
953 #[inline]
954 pub fn set_gaps_in_frame_num_value_allowed_flag(&mut self, val: u32) {
955 unsafe {
956 let val: u32 = ::std::mem::transmute(val);
957 self._bitfield_1.set(11usize, 1u8, val as u64)
958 }
959 }
960 #[inline]
961 pub fn qpprime_y_zero_transform_bypass_flag(&self) -> u32 {
962 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u32) }
963 }
964 #[inline]
965 pub fn set_qpprime_y_zero_transform_bypass_flag(&mut self, val: u32) {
966 unsafe {
967 let val: u32 = ::std::mem::transmute(val);
968 self._bitfield_1.set(12usize, 1u8, val as u64)
969 }
970 }
971 #[inline]
972 pub fn frame_cropping_flag(&self) -> u32 {
973 unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) }
974 }
975 #[inline]
976 pub fn set_frame_cropping_flag(&mut self, val: u32) {
977 unsafe {
978 let val: u32 = ::std::mem::transmute(val);
979 self._bitfield_1.set(13usize, 1u8, val as u64)
980 }
981 }
982 #[inline]
983 pub fn seq_scaling_matrix_present_flag(&self) -> u32 {
984 unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) }
985 }
986 #[inline]
987 pub fn set_seq_scaling_matrix_present_flag(&mut self, val: u32) {
988 unsafe {
989 let val: u32 = ::std::mem::transmute(val);
990 self._bitfield_1.set(14usize, 1u8, val as u64)
991 }
992 }
993 #[inline]
994 pub fn vui_parameters_present_flag(&self) -> u32 {
995 unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u32) }
996 }
997 #[inline]
998 pub fn set_vui_parameters_present_flag(&mut self, val: u32) {
999 unsafe {
1000 let val: u32 = ::std::mem::transmute(val);
1001 self._bitfield_1.set(15usize, 1u8, val as u64)
1002 }
1003 }
1004 #[inline]
1005 pub fn new_bitfield_1(
1006 constraint_set0_flag: u32,
1007 constraint_set1_flag: u32,
1008 constraint_set2_flag: u32,
1009 constraint_set3_flag: u32,
1010 constraint_set4_flag: u32,
1011 constraint_set5_flag: u32,
1012 direct_8x8_inference_flag: u32,
1013 mb_adaptive_frame_field_flag: u32,
1014 frame_mbs_only_flag: u32,
1015 delta_pic_order_always_zero_flag: u32,
1016 separate_colour_plane_flag: u32,
1017 gaps_in_frame_num_value_allowed_flag: u32,
1018 qpprime_y_zero_transform_bypass_flag: u32,
1019 frame_cropping_flag: u32,
1020 seq_scaling_matrix_present_flag: u32,
1021 vui_parameters_present_flag: u32,
1022 ) -> __BindgenBitfieldUnit<[u8; 2usize]> {
1023 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default();
1024 __bindgen_bitfield_unit.set(0usize, 1u8, {
1025 let constraint_set0_flag: u32 = unsafe { ::std::mem::transmute(constraint_set0_flag) };
1026 constraint_set0_flag as u64
1027 });
1028 __bindgen_bitfield_unit.set(1usize, 1u8, {
1029 let constraint_set1_flag: u32 = unsafe { ::std::mem::transmute(constraint_set1_flag) };
1030 constraint_set1_flag as u64
1031 });
1032 __bindgen_bitfield_unit.set(2usize, 1u8, {
1033 let constraint_set2_flag: u32 = unsafe { ::std::mem::transmute(constraint_set2_flag) };
1034 constraint_set2_flag as u64
1035 });
1036 __bindgen_bitfield_unit.set(3usize, 1u8, {
1037 let constraint_set3_flag: u32 = unsafe { ::std::mem::transmute(constraint_set3_flag) };
1038 constraint_set3_flag as u64
1039 });
1040 __bindgen_bitfield_unit.set(4usize, 1u8, {
1041 let constraint_set4_flag: u32 = unsafe { ::std::mem::transmute(constraint_set4_flag) };
1042 constraint_set4_flag as u64
1043 });
1044 __bindgen_bitfield_unit.set(5usize, 1u8, {
1045 let constraint_set5_flag: u32 = unsafe { ::std::mem::transmute(constraint_set5_flag) };
1046 constraint_set5_flag as u64
1047 });
1048 __bindgen_bitfield_unit.set(6usize, 1u8, {
1049 let direct_8x8_inference_flag: u32 =
1050 unsafe { ::std::mem::transmute(direct_8x8_inference_flag) };
1051 direct_8x8_inference_flag as u64
1052 });
1053 __bindgen_bitfield_unit.set(7usize, 1u8, {
1054 let mb_adaptive_frame_field_flag: u32 =
1055 unsafe { ::std::mem::transmute(mb_adaptive_frame_field_flag) };
1056 mb_adaptive_frame_field_flag as u64
1057 });
1058 __bindgen_bitfield_unit.set(8usize, 1u8, {
1059 let frame_mbs_only_flag: u32 = unsafe { ::std::mem::transmute(frame_mbs_only_flag) };
1060 frame_mbs_only_flag as u64
1061 });
1062 __bindgen_bitfield_unit.set(9usize, 1u8, {
1063 let delta_pic_order_always_zero_flag: u32 =
1064 unsafe { ::std::mem::transmute(delta_pic_order_always_zero_flag) };
1065 delta_pic_order_always_zero_flag as u64
1066 });
1067 __bindgen_bitfield_unit.set(10usize, 1u8, {
1068 let separate_colour_plane_flag: u32 =
1069 unsafe { ::std::mem::transmute(separate_colour_plane_flag) };
1070 separate_colour_plane_flag as u64
1071 });
1072 __bindgen_bitfield_unit.set(11usize, 1u8, {
1073 let gaps_in_frame_num_value_allowed_flag: u32 =
1074 unsafe { ::std::mem::transmute(gaps_in_frame_num_value_allowed_flag) };
1075 gaps_in_frame_num_value_allowed_flag as u64
1076 });
1077 __bindgen_bitfield_unit.set(12usize, 1u8, {
1078 let qpprime_y_zero_transform_bypass_flag: u32 =
1079 unsafe { ::std::mem::transmute(qpprime_y_zero_transform_bypass_flag) };
1080 qpprime_y_zero_transform_bypass_flag as u64
1081 });
1082 __bindgen_bitfield_unit.set(13usize, 1u8, {
1083 let frame_cropping_flag: u32 = unsafe { ::std::mem::transmute(frame_cropping_flag) };
1084 frame_cropping_flag as u64
1085 });
1086 __bindgen_bitfield_unit.set(14usize, 1u8, {
1087 let seq_scaling_matrix_present_flag: u32 =
1088 unsafe { ::std::mem::transmute(seq_scaling_matrix_present_flag) };
1089 seq_scaling_matrix_present_flag as u64
1090 });
1091 __bindgen_bitfield_unit.set(15usize, 1u8, {
1092 let vui_parameters_present_flag: u32 =
1093 unsafe { ::std::mem::transmute(vui_parameters_present_flag) };
1094 vui_parameters_present_flag as u64
1095 });
1096 __bindgen_bitfield_unit
1097 }
1098}
1099#[repr(C)]
1100#[derive(Debug, Copy, Clone)]
1101pub struct StdVideoH264ScalingLists {
1102 pub scaling_list_present_mask: u16,
1103 pub use_default_scaling_matrix_mask: u16,
1104 pub ScalingList4x4: [[u8; 16usize]; 6usize],
1105 pub ScalingList8x8: [[u8; 64usize]; 6usize],
1106}
1107#[test]
1108fn bindgen_test_layout_StdVideoH264ScalingLists() {
1109 const UNINIT: ::std::mem::MaybeUninit<StdVideoH264ScalingLists> =
1110 ::std::mem::MaybeUninit::uninit();
1111 let ptr = UNINIT.as_ptr();
1112 assert_eq!(
1113 ::std::mem::size_of::<StdVideoH264ScalingLists>(),
1114 484usize,
1115 concat!("Size of: ", stringify!(StdVideoH264ScalingLists))
1116 );
1117 assert_eq!(
1118 ::std::mem::align_of::<StdVideoH264ScalingLists>(),
1119 2usize,
1120 concat!("Alignment of ", stringify!(StdVideoH264ScalingLists))
1121 );
1122 assert_eq!(
1123 unsafe { ::std::ptr::addr_of!((*ptr).scaling_list_present_mask) as usize - ptr as usize },
1124 0usize,
1125 concat!(
1126 "Offset of field: ",
1127 stringify!(StdVideoH264ScalingLists),
1128 "::",
1129 stringify!(scaling_list_present_mask)
1130 )
1131 );
1132 assert_eq!(
1133 unsafe {
1134 ::std::ptr::addr_of!((*ptr).use_default_scaling_matrix_mask) as usize - ptr as usize
1135 },
1136 2usize,
1137 concat!(
1138 "Offset of field: ",
1139 stringify!(StdVideoH264ScalingLists),
1140 "::",
1141 stringify!(use_default_scaling_matrix_mask)
1142 )
1143 );
1144 assert_eq!(
1145 unsafe { ::std::ptr::addr_of!((*ptr).ScalingList4x4) as usize - ptr as usize },
1146 4usize,
1147 concat!(
1148 "Offset of field: ",
1149 stringify!(StdVideoH264ScalingLists),
1150 "::",
1151 stringify!(ScalingList4x4)
1152 )
1153 );
1154 assert_eq!(
1155 unsafe { ::std::ptr::addr_of!((*ptr).ScalingList8x8) as usize - ptr as usize },
1156 100usize,
1157 concat!(
1158 "Offset of field: ",
1159 stringify!(StdVideoH264ScalingLists),
1160 "::",
1161 stringify!(ScalingList8x8)
1162 )
1163 );
1164}
1165#[repr(C)]
1166#[derive(Debug, Copy, Clone)]
1167pub struct StdVideoH264SequenceParameterSet {
1168 pub flags: StdVideoH264SpsFlags,
1169 pub profile_idc: StdVideoH264ProfileIdc,
1170 pub level_idc: StdVideoH264LevelIdc,
1171 pub chroma_format_idc: StdVideoH264ChromaFormatIdc,
1172 pub seq_parameter_set_id: u8,
1173 pub bit_depth_luma_minus8: u8,
1174 pub bit_depth_chroma_minus8: u8,
1175 pub log2_max_frame_num_minus4: u8,
1176 pub pic_order_cnt_type: StdVideoH264PocType,
1177 pub offset_for_non_ref_pic: i32,
1178 pub offset_for_top_to_bottom_field: i32,
1179 pub log2_max_pic_order_cnt_lsb_minus4: u8,
1180 pub num_ref_frames_in_pic_order_cnt_cycle: u8,
1181 pub max_num_ref_frames: u8,
1182 pub reserved1: u8,
1183 pub pic_width_in_mbs_minus1: u32,
1184 pub pic_height_in_map_units_minus1: u32,
1185 pub frame_crop_left_offset: u32,
1186 pub frame_crop_right_offset: u32,
1187 pub frame_crop_top_offset: u32,
1188 pub frame_crop_bottom_offset: u32,
1189 pub reserved2: u32,
1190 pub pOffsetForRefFrame: *const i32,
1191 pub pScalingLists: *const StdVideoH264ScalingLists,
1192 pub pSequenceParameterSetVui: *const StdVideoH264SequenceParameterSetVui,
1193}
1194#[test]
1195fn bindgen_test_layout_StdVideoH264SequenceParameterSet() {
1196 const UNINIT: ::std::mem::MaybeUninit<StdVideoH264SequenceParameterSet> =
1197 ::std::mem::MaybeUninit::uninit();
1198 let ptr = UNINIT.as_ptr();
1199 assert_eq!(
1200 ::std::mem::size_of::<StdVideoH264SequenceParameterSet>(),
1201 88usize,
1202 concat!("Size of: ", stringify!(StdVideoH264SequenceParameterSet))
1203 );
1204 assert_eq!(
1205 ::std::mem::align_of::<StdVideoH264SequenceParameterSet>(),
1206 8usize,
1207 concat!(
1208 "Alignment of ",
1209 stringify!(StdVideoH264SequenceParameterSet)
1210 )
1211 );
1212 assert_eq!(
1213 unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
1214 0usize,
1215 concat!(
1216 "Offset of field: ",
1217 stringify!(StdVideoH264SequenceParameterSet),
1218 "::",
1219 stringify!(flags)
1220 )
1221 );
1222 assert_eq!(
1223 unsafe { ::std::ptr::addr_of!((*ptr).profile_idc) as usize - ptr as usize },
1224 4usize,
1225 concat!(
1226 "Offset of field: ",
1227 stringify!(StdVideoH264SequenceParameterSet),
1228 "::",
1229 stringify!(profile_idc)
1230 )
1231 );
1232 assert_eq!(
1233 unsafe { ::std::ptr::addr_of!((*ptr).level_idc) as usize - ptr as usize },
1234 8usize,
1235 concat!(
1236 "Offset of field: ",
1237 stringify!(StdVideoH264SequenceParameterSet),
1238 "::",
1239 stringify!(level_idc)
1240 )
1241 );
1242 assert_eq!(
1243 unsafe { ::std::ptr::addr_of!((*ptr).chroma_format_idc) as usize - ptr as usize },
1244 12usize,
1245 concat!(
1246 "Offset of field: ",
1247 stringify!(StdVideoH264SequenceParameterSet),
1248 "::",
1249 stringify!(chroma_format_idc)
1250 )
1251 );
1252 assert_eq!(
1253 unsafe { ::std::ptr::addr_of!((*ptr).seq_parameter_set_id) as usize - ptr as usize },
1254 16usize,
1255 concat!(
1256 "Offset of field: ",
1257 stringify!(StdVideoH264SequenceParameterSet),
1258 "::",
1259 stringify!(seq_parameter_set_id)
1260 )
1261 );
1262 assert_eq!(
1263 unsafe { ::std::ptr::addr_of!((*ptr).bit_depth_luma_minus8) as usize - ptr as usize },
1264 17usize,
1265 concat!(
1266 "Offset of field: ",
1267 stringify!(StdVideoH264SequenceParameterSet),
1268 "::",
1269 stringify!(bit_depth_luma_minus8)
1270 )
1271 );
1272 assert_eq!(
1273 unsafe { ::std::ptr::addr_of!((*ptr).bit_depth_chroma_minus8) as usize - ptr as usize },
1274 18usize,
1275 concat!(
1276 "Offset of field: ",
1277 stringify!(StdVideoH264SequenceParameterSet),
1278 "::",
1279 stringify!(bit_depth_chroma_minus8)
1280 )
1281 );
1282 assert_eq!(
1283 unsafe { ::std::ptr::addr_of!((*ptr).log2_max_frame_num_minus4) as usize - ptr as usize },
1284 19usize,
1285 concat!(
1286 "Offset of field: ",
1287 stringify!(StdVideoH264SequenceParameterSet),
1288 "::",
1289 stringify!(log2_max_frame_num_minus4)
1290 )
1291 );
1292 assert_eq!(
1293 unsafe { ::std::ptr::addr_of!((*ptr).pic_order_cnt_type) as usize - ptr as usize },
1294 20usize,
1295 concat!(
1296 "Offset of field: ",
1297 stringify!(StdVideoH264SequenceParameterSet),
1298 "::",
1299 stringify!(pic_order_cnt_type)
1300 )
1301 );
1302 assert_eq!(
1303 unsafe { ::std::ptr::addr_of!((*ptr).offset_for_non_ref_pic) as usize - ptr as usize },
1304 24usize,
1305 concat!(
1306 "Offset of field: ",
1307 stringify!(StdVideoH264SequenceParameterSet),
1308 "::",
1309 stringify!(offset_for_non_ref_pic)
1310 )
1311 );
1312 assert_eq!(
1313 unsafe {
1314 ::std::ptr::addr_of!((*ptr).offset_for_top_to_bottom_field) as usize - ptr as usize
1315 },
1316 28usize,
1317 concat!(
1318 "Offset of field: ",
1319 stringify!(StdVideoH264SequenceParameterSet),
1320 "::",
1321 stringify!(offset_for_top_to_bottom_field)
1322 )
1323 );
1324 assert_eq!(
1325 unsafe {
1326 ::std::ptr::addr_of!((*ptr).log2_max_pic_order_cnt_lsb_minus4) as usize - ptr as usize
1327 },
1328 32usize,
1329 concat!(
1330 "Offset of field: ",
1331 stringify!(StdVideoH264SequenceParameterSet),
1332 "::",
1333 stringify!(log2_max_pic_order_cnt_lsb_minus4)
1334 )
1335 );
1336 assert_eq!(
1337 unsafe {
1338 ::std::ptr::addr_of!((*ptr).num_ref_frames_in_pic_order_cnt_cycle) as usize
1339 - ptr as usize
1340 },
1341 33usize,
1342 concat!(
1343 "Offset of field: ",
1344 stringify!(StdVideoH264SequenceParameterSet),
1345 "::",
1346 stringify!(num_ref_frames_in_pic_order_cnt_cycle)
1347 )
1348 );
1349 assert_eq!(
1350 unsafe { ::std::ptr::addr_of!((*ptr).max_num_ref_frames) as usize - ptr as usize },
1351 34usize,
1352 concat!(
1353 "Offset of field: ",
1354 stringify!(StdVideoH264SequenceParameterSet),
1355 "::",
1356 stringify!(max_num_ref_frames)
1357 )
1358 );
1359 assert_eq!(
1360 unsafe { ::std::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize },
1361 35usize,
1362 concat!(
1363 "Offset of field: ",
1364 stringify!(StdVideoH264SequenceParameterSet),
1365 "::",
1366 stringify!(reserved1)
1367 )
1368 );
1369 assert_eq!(
1370 unsafe { ::std::ptr::addr_of!((*ptr).pic_width_in_mbs_minus1) as usize - ptr as usize },
1371 36usize,
1372 concat!(
1373 "Offset of field: ",
1374 stringify!(StdVideoH264SequenceParameterSet),
1375 "::",
1376 stringify!(pic_width_in_mbs_minus1)
1377 )
1378 );
1379 assert_eq!(
1380 unsafe {
1381 ::std::ptr::addr_of!((*ptr).pic_height_in_map_units_minus1) as usize - ptr as usize
1382 },
1383 40usize,
1384 concat!(
1385 "Offset of field: ",
1386 stringify!(StdVideoH264SequenceParameterSet),
1387 "::",
1388 stringify!(pic_height_in_map_units_minus1)
1389 )
1390 );
1391 assert_eq!(
1392 unsafe { ::std::ptr::addr_of!((*ptr).frame_crop_left_offset) as usize - ptr as usize },
1393 44usize,
1394 concat!(
1395 "Offset of field: ",
1396 stringify!(StdVideoH264SequenceParameterSet),
1397 "::",
1398 stringify!(frame_crop_left_offset)
1399 )
1400 );
1401 assert_eq!(
1402 unsafe { ::std::ptr::addr_of!((*ptr).frame_crop_right_offset) as usize - ptr as usize },
1403 48usize,
1404 concat!(
1405 "Offset of field: ",
1406 stringify!(StdVideoH264SequenceParameterSet),
1407 "::",
1408 stringify!(frame_crop_right_offset)
1409 )
1410 );
1411 assert_eq!(
1412 unsafe { ::std::ptr::addr_of!((*ptr).frame_crop_top_offset) as usize - ptr as usize },
1413 52usize,
1414 concat!(
1415 "Offset of field: ",
1416 stringify!(StdVideoH264SequenceParameterSet),
1417 "::",
1418 stringify!(frame_crop_top_offset)
1419 )
1420 );
1421 assert_eq!(
1422 unsafe { ::std::ptr::addr_of!((*ptr).frame_crop_bottom_offset) as usize - ptr as usize },
1423 56usize,
1424 concat!(
1425 "Offset of field: ",
1426 stringify!(StdVideoH264SequenceParameterSet),
1427 "::",
1428 stringify!(frame_crop_bottom_offset)
1429 )
1430 );
1431 assert_eq!(
1432 unsafe { ::std::ptr::addr_of!((*ptr).reserved2) as usize - ptr as usize },
1433 60usize,
1434 concat!(
1435 "Offset of field: ",
1436 stringify!(StdVideoH264SequenceParameterSet),
1437 "::",
1438 stringify!(reserved2)
1439 )
1440 );
1441 assert_eq!(
1442 unsafe { ::std::ptr::addr_of!((*ptr).pOffsetForRefFrame) as usize - ptr as usize },
1443 64usize,
1444 concat!(
1445 "Offset of field: ",
1446 stringify!(StdVideoH264SequenceParameterSet),
1447 "::",
1448 stringify!(pOffsetForRefFrame)
1449 )
1450 );
1451 assert_eq!(
1452 unsafe { ::std::ptr::addr_of!((*ptr).pScalingLists) as usize - ptr as usize },
1453 72usize,
1454 concat!(
1455 "Offset of field: ",
1456 stringify!(StdVideoH264SequenceParameterSet),
1457 "::",
1458 stringify!(pScalingLists)
1459 )
1460 );
1461 assert_eq!(
1462 unsafe { ::std::ptr::addr_of!((*ptr).pSequenceParameterSetVui) as usize - ptr as usize },
1463 80usize,
1464 concat!(
1465 "Offset of field: ",
1466 stringify!(StdVideoH264SequenceParameterSet),
1467 "::",
1468 stringify!(pSequenceParameterSetVui)
1469 )
1470 );
1471}
1472#[repr(C)]
1473#[repr(align(4))]
1474#[derive(Debug, Copy, Clone)]
1475pub struct StdVideoH264PpsFlags {
1476 pub _bitfield_align_1: [u8; 0],
1477 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
1478 pub __bindgen_padding_0: [u8; 3usize],
1479}
1480#[test]
1481fn bindgen_test_layout_StdVideoH264PpsFlags() {
1482 assert_eq!(
1483 ::std::mem::size_of::<StdVideoH264PpsFlags>(),
1484 4usize,
1485 concat!("Size of: ", stringify!(StdVideoH264PpsFlags))
1486 );
1487 assert_eq!(
1488 ::std::mem::align_of::<StdVideoH264PpsFlags>(),
1489 4usize,
1490 concat!("Alignment of ", stringify!(StdVideoH264PpsFlags))
1491 );
1492}
1493impl StdVideoH264PpsFlags {
1494 #[inline]
1495 pub fn transform_8x8_mode_flag(&self) -> u32 {
1496 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
1497 }
1498 #[inline]
1499 pub fn set_transform_8x8_mode_flag(&mut self, val: u32) {
1500 unsafe {
1501 let val: u32 = ::std::mem::transmute(val);
1502 self._bitfield_1.set(0usize, 1u8, val as u64)
1503 }
1504 }
1505 #[inline]
1506 pub fn redundant_pic_cnt_present_flag(&self) -> u32 {
1507 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
1508 }
1509 #[inline]
1510 pub fn set_redundant_pic_cnt_present_flag(&mut self, val: u32) {
1511 unsafe {
1512 let val: u32 = ::std::mem::transmute(val);
1513 self._bitfield_1.set(1usize, 1u8, val as u64)
1514 }
1515 }
1516 #[inline]
1517 pub fn constrained_intra_pred_flag(&self) -> u32 {
1518 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
1519 }
1520 #[inline]
1521 pub fn set_constrained_intra_pred_flag(&mut self, val: u32) {
1522 unsafe {
1523 let val: u32 = ::std::mem::transmute(val);
1524 self._bitfield_1.set(2usize, 1u8, val as u64)
1525 }
1526 }
1527 #[inline]
1528 pub fn deblocking_filter_control_present_flag(&self) -> u32 {
1529 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
1530 }
1531 #[inline]
1532 pub fn set_deblocking_filter_control_present_flag(&mut self, val: u32) {
1533 unsafe {
1534 let val: u32 = ::std::mem::transmute(val);
1535 self._bitfield_1.set(3usize, 1u8, val as u64)
1536 }
1537 }
1538 #[inline]
1539 pub fn weighted_pred_flag(&self) -> u32 {
1540 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
1541 }
1542 #[inline]
1543 pub fn set_weighted_pred_flag(&mut self, val: u32) {
1544 unsafe {
1545 let val: u32 = ::std::mem::transmute(val);
1546 self._bitfield_1.set(4usize, 1u8, val as u64)
1547 }
1548 }
1549 #[inline]
1550 pub fn bottom_field_pic_order_in_frame_present_flag(&self) -> u32 {
1551 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
1552 }
1553 #[inline]
1554 pub fn set_bottom_field_pic_order_in_frame_present_flag(&mut self, val: u32) {
1555 unsafe {
1556 let val: u32 = ::std::mem::transmute(val);
1557 self._bitfield_1.set(5usize, 1u8, val as u64)
1558 }
1559 }
1560 #[inline]
1561 pub fn entropy_coding_mode_flag(&self) -> u32 {
1562 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) }
1563 }
1564 #[inline]
1565 pub fn set_entropy_coding_mode_flag(&mut self, val: u32) {
1566 unsafe {
1567 let val: u32 = ::std::mem::transmute(val);
1568 self._bitfield_1.set(6usize, 1u8, val as u64)
1569 }
1570 }
1571 #[inline]
1572 pub fn pic_scaling_matrix_present_flag(&self) -> u32 {
1573 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) }
1574 }
1575 #[inline]
1576 pub fn set_pic_scaling_matrix_present_flag(&mut self, val: u32) {
1577 unsafe {
1578 let val: u32 = ::std::mem::transmute(val);
1579 self._bitfield_1.set(7usize, 1u8, val as u64)
1580 }
1581 }
1582 #[inline]
1583 pub fn new_bitfield_1(
1584 transform_8x8_mode_flag: u32,
1585 redundant_pic_cnt_present_flag: u32,
1586 constrained_intra_pred_flag: u32,
1587 deblocking_filter_control_present_flag: u32,
1588 weighted_pred_flag: u32,
1589 bottom_field_pic_order_in_frame_present_flag: u32,
1590 entropy_coding_mode_flag: u32,
1591 pic_scaling_matrix_present_flag: u32,
1592 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
1593 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
1594 __bindgen_bitfield_unit.set(0usize, 1u8, {
1595 let transform_8x8_mode_flag: u32 =
1596 unsafe { ::std::mem::transmute(transform_8x8_mode_flag) };
1597 transform_8x8_mode_flag as u64
1598 });
1599 __bindgen_bitfield_unit.set(1usize, 1u8, {
1600 let redundant_pic_cnt_present_flag: u32 =
1601 unsafe { ::std::mem::transmute(redundant_pic_cnt_present_flag) };
1602 redundant_pic_cnt_present_flag as u64
1603 });
1604 __bindgen_bitfield_unit.set(2usize, 1u8, {
1605 let constrained_intra_pred_flag: u32 =
1606 unsafe { ::std::mem::transmute(constrained_intra_pred_flag) };
1607 constrained_intra_pred_flag as u64
1608 });
1609 __bindgen_bitfield_unit.set(3usize, 1u8, {
1610 let deblocking_filter_control_present_flag: u32 =
1611 unsafe { ::std::mem::transmute(deblocking_filter_control_present_flag) };
1612 deblocking_filter_control_present_flag as u64
1613 });
1614 __bindgen_bitfield_unit.set(4usize, 1u8, {
1615 let weighted_pred_flag: u32 = unsafe { ::std::mem::transmute(weighted_pred_flag) };
1616 weighted_pred_flag as u64
1617 });
1618 __bindgen_bitfield_unit.set(5usize, 1u8, {
1619 let bottom_field_pic_order_in_frame_present_flag: u32 =
1620 unsafe { ::std::mem::transmute(bottom_field_pic_order_in_frame_present_flag) };
1621 bottom_field_pic_order_in_frame_present_flag as u64
1622 });
1623 __bindgen_bitfield_unit.set(6usize, 1u8, {
1624 let entropy_coding_mode_flag: u32 =
1625 unsafe { ::std::mem::transmute(entropy_coding_mode_flag) };
1626 entropy_coding_mode_flag as u64
1627 });
1628 __bindgen_bitfield_unit.set(7usize, 1u8, {
1629 let pic_scaling_matrix_present_flag: u32 =
1630 unsafe { ::std::mem::transmute(pic_scaling_matrix_present_flag) };
1631 pic_scaling_matrix_present_flag as u64
1632 });
1633 __bindgen_bitfield_unit
1634 }
1635}
1636#[repr(C)]
1637#[derive(Debug, Copy, Clone)]
1638pub struct StdVideoH264PictureParameterSet {
1639 pub flags: StdVideoH264PpsFlags,
1640 pub seq_parameter_set_id: u8,
1641 pub pic_parameter_set_id: u8,
1642 pub num_ref_idx_l0_default_active_minus1: u8,
1643 pub num_ref_idx_l1_default_active_minus1: u8,
1644 pub weighted_bipred_idc: StdVideoH264WeightedBipredIdc,
1645 pub pic_init_qp_minus26: i8,
1646 pub pic_init_qs_minus26: i8,
1647 pub chroma_qp_index_offset: i8,
1648 pub second_chroma_qp_index_offset: i8,
1649 pub pScalingLists: *const StdVideoH264ScalingLists,
1650}
1651#[test]
1652fn bindgen_test_layout_StdVideoH264PictureParameterSet() {
1653 const UNINIT: ::std::mem::MaybeUninit<StdVideoH264PictureParameterSet> =
1654 ::std::mem::MaybeUninit::uninit();
1655 let ptr = UNINIT.as_ptr();
1656 assert_eq!(
1657 ::std::mem::size_of::<StdVideoH264PictureParameterSet>(),
1658 24usize,
1659 concat!("Size of: ", stringify!(StdVideoH264PictureParameterSet))
1660 );
1661 assert_eq!(
1662 ::std::mem::align_of::<StdVideoH264PictureParameterSet>(),
1663 8usize,
1664 concat!("Alignment of ", stringify!(StdVideoH264PictureParameterSet))
1665 );
1666 assert_eq!(
1667 unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
1668 0usize,
1669 concat!(
1670 "Offset of field: ",
1671 stringify!(StdVideoH264PictureParameterSet),
1672 "::",
1673 stringify!(flags)
1674 )
1675 );
1676 assert_eq!(
1677 unsafe { ::std::ptr::addr_of!((*ptr).seq_parameter_set_id) as usize - ptr as usize },
1678 4usize,
1679 concat!(
1680 "Offset of field: ",
1681 stringify!(StdVideoH264PictureParameterSet),
1682 "::",
1683 stringify!(seq_parameter_set_id)
1684 )
1685 );
1686 assert_eq!(
1687 unsafe { ::std::ptr::addr_of!((*ptr).pic_parameter_set_id) as usize - ptr as usize },
1688 5usize,
1689 concat!(
1690 "Offset of field: ",
1691 stringify!(StdVideoH264PictureParameterSet),
1692 "::",
1693 stringify!(pic_parameter_set_id)
1694 )
1695 );
1696 assert_eq!(
1697 unsafe {
1698 ::std::ptr::addr_of!((*ptr).num_ref_idx_l0_default_active_minus1) as usize
1699 - ptr as usize
1700 },
1701 6usize,
1702 concat!(
1703 "Offset of field: ",
1704 stringify!(StdVideoH264PictureParameterSet),
1705 "::",
1706 stringify!(num_ref_idx_l0_default_active_minus1)
1707 )
1708 );
1709 assert_eq!(
1710 unsafe {
1711 ::std::ptr::addr_of!((*ptr).num_ref_idx_l1_default_active_minus1) as usize
1712 - ptr as usize
1713 },
1714 7usize,
1715 concat!(
1716 "Offset of field: ",
1717 stringify!(StdVideoH264PictureParameterSet),
1718 "::",
1719 stringify!(num_ref_idx_l1_default_active_minus1)
1720 )
1721 );
1722 assert_eq!(
1723 unsafe { ::std::ptr::addr_of!((*ptr).weighted_bipred_idc) as usize - ptr as usize },
1724 8usize,
1725 concat!(
1726 "Offset of field: ",
1727 stringify!(StdVideoH264PictureParameterSet),
1728 "::",
1729 stringify!(weighted_bipred_idc)
1730 )
1731 );
1732 assert_eq!(
1733 unsafe { ::std::ptr::addr_of!((*ptr).pic_init_qp_minus26) as usize - ptr as usize },
1734 12usize,
1735 concat!(
1736 "Offset of field: ",
1737 stringify!(StdVideoH264PictureParameterSet),
1738 "::",
1739 stringify!(pic_init_qp_minus26)
1740 )
1741 );
1742 assert_eq!(
1743 unsafe { ::std::ptr::addr_of!((*ptr).pic_init_qs_minus26) as usize - ptr as usize },
1744 13usize,
1745 concat!(
1746 "Offset of field: ",
1747 stringify!(StdVideoH264PictureParameterSet),
1748 "::",
1749 stringify!(pic_init_qs_minus26)
1750 )
1751 );
1752 assert_eq!(
1753 unsafe { ::std::ptr::addr_of!((*ptr).chroma_qp_index_offset) as usize - ptr as usize },
1754 14usize,
1755 concat!(
1756 "Offset of field: ",
1757 stringify!(StdVideoH264PictureParameterSet),
1758 "::",
1759 stringify!(chroma_qp_index_offset)
1760 )
1761 );
1762 assert_eq!(
1763 unsafe {
1764 ::std::ptr::addr_of!((*ptr).second_chroma_qp_index_offset) as usize - ptr as usize
1765 },
1766 15usize,
1767 concat!(
1768 "Offset of field: ",
1769 stringify!(StdVideoH264PictureParameterSet),
1770 "::",
1771 stringify!(second_chroma_qp_index_offset)
1772 )
1773 );
1774 assert_eq!(
1775 unsafe { ::std::ptr::addr_of!((*ptr).pScalingLists) as usize - ptr as usize },
1776 16usize,
1777 concat!(
1778 "Offset of field: ",
1779 stringify!(StdVideoH264PictureParameterSet),
1780 "::",
1781 stringify!(pScalingLists)
1782 )
1783 );
1784}
1785#[repr(C)]
1786#[repr(align(4))]
1787#[derive(Debug, Copy, Clone)]
1788pub struct StdVideoDecodeH264PictureInfoFlags {
1789 pub _bitfield_align_1: [u8; 0],
1790 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
1791 pub __bindgen_padding_0: [u8; 3usize],
1792}
1793#[test]
1794fn bindgen_test_layout_StdVideoDecodeH264PictureInfoFlags() {
1795 assert_eq!(
1796 ::std::mem::size_of::<StdVideoDecodeH264PictureInfoFlags>(),
1797 4usize,
1798 concat!("Size of: ", stringify!(StdVideoDecodeH264PictureInfoFlags))
1799 );
1800 assert_eq!(
1801 ::std::mem::align_of::<StdVideoDecodeH264PictureInfoFlags>(),
1802 4usize,
1803 concat!(
1804 "Alignment of ",
1805 stringify!(StdVideoDecodeH264PictureInfoFlags)
1806 )
1807 );
1808}
1809impl StdVideoDecodeH264PictureInfoFlags {
1810 #[inline]
1811 pub fn field_pic_flag(&self) -> u32 {
1812 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
1813 }
1814 #[inline]
1815 pub fn set_field_pic_flag(&mut self, val: u32) {
1816 unsafe {
1817 let val: u32 = ::std::mem::transmute(val);
1818 self._bitfield_1.set(0usize, 1u8, val as u64)
1819 }
1820 }
1821 #[inline]
1822 pub fn is_intra(&self) -> u32 {
1823 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
1824 }
1825 #[inline]
1826 pub fn set_is_intra(&mut self, val: u32) {
1827 unsafe {
1828 let val: u32 = ::std::mem::transmute(val);
1829 self._bitfield_1.set(1usize, 1u8, val as u64)
1830 }
1831 }
1832 #[inline]
1833 pub fn IdrPicFlag(&self) -> u32 {
1834 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
1835 }
1836 #[inline]
1837 pub fn set_IdrPicFlag(&mut self, val: u32) {
1838 unsafe {
1839 let val: u32 = ::std::mem::transmute(val);
1840 self._bitfield_1.set(2usize, 1u8, val as u64)
1841 }
1842 }
1843 #[inline]
1844 pub fn bottom_field_flag(&self) -> u32 {
1845 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
1846 }
1847 #[inline]
1848 pub fn set_bottom_field_flag(&mut self, val: u32) {
1849 unsafe {
1850 let val: u32 = ::std::mem::transmute(val);
1851 self._bitfield_1.set(3usize, 1u8, val as u64)
1852 }
1853 }
1854 #[inline]
1855 pub fn is_reference(&self) -> u32 {
1856 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
1857 }
1858 #[inline]
1859 pub fn set_is_reference(&mut self, val: u32) {
1860 unsafe {
1861 let val: u32 = ::std::mem::transmute(val);
1862 self._bitfield_1.set(4usize, 1u8, val as u64)
1863 }
1864 }
1865 #[inline]
1866 pub fn complementary_field_pair(&self) -> u32 {
1867 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
1868 }
1869 #[inline]
1870 pub fn set_complementary_field_pair(&mut self, val: u32) {
1871 unsafe {
1872 let val: u32 = ::std::mem::transmute(val);
1873 self._bitfield_1.set(5usize, 1u8, val as u64)
1874 }
1875 }
1876 #[inline]
1877 pub fn new_bitfield_1(
1878 field_pic_flag: u32,
1879 is_intra: u32,
1880 IdrPicFlag: u32,
1881 bottom_field_flag: u32,
1882 is_reference: u32,
1883 complementary_field_pair: u32,
1884 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
1885 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
1886 __bindgen_bitfield_unit.set(0usize, 1u8, {
1887 let field_pic_flag: u32 = unsafe { ::std::mem::transmute(field_pic_flag) };
1888 field_pic_flag as u64
1889 });
1890 __bindgen_bitfield_unit.set(1usize, 1u8, {
1891 let is_intra: u32 = unsafe { ::std::mem::transmute(is_intra) };
1892 is_intra as u64
1893 });
1894 __bindgen_bitfield_unit.set(2usize, 1u8, {
1895 let IdrPicFlag: u32 = unsafe { ::std::mem::transmute(IdrPicFlag) };
1896 IdrPicFlag as u64
1897 });
1898 __bindgen_bitfield_unit.set(3usize, 1u8, {
1899 let bottom_field_flag: u32 = unsafe { ::std::mem::transmute(bottom_field_flag) };
1900 bottom_field_flag as u64
1901 });
1902 __bindgen_bitfield_unit.set(4usize, 1u8, {
1903 let is_reference: u32 = unsafe { ::std::mem::transmute(is_reference) };
1904 is_reference as u64
1905 });
1906 __bindgen_bitfield_unit.set(5usize, 1u8, {
1907 let complementary_field_pair: u32 =
1908 unsafe { ::std::mem::transmute(complementary_field_pair) };
1909 complementary_field_pair as u64
1910 });
1911 __bindgen_bitfield_unit
1912 }
1913}
1914#[repr(C)]
1915#[derive(Debug, Copy, Clone)]
1916pub struct StdVideoDecodeH264PictureInfo {
1917 pub flags: StdVideoDecodeH264PictureInfoFlags,
1918 pub seq_parameter_set_id: u8,
1919 pub pic_parameter_set_id: u8,
1920 pub reserved1: u8,
1921 pub reserved2: u8,
1922 pub frame_num: u16,
1923 pub idr_pic_id: u16,
1924 pub PicOrderCnt: [i32; 2usize],
1925}
1926#[test]
1927fn bindgen_test_layout_StdVideoDecodeH264PictureInfo() {
1928 const UNINIT: ::std::mem::MaybeUninit<StdVideoDecodeH264PictureInfo> =
1929 ::std::mem::MaybeUninit::uninit();
1930 let ptr = UNINIT.as_ptr();
1931 assert_eq!(
1932 ::std::mem::size_of::<StdVideoDecodeH264PictureInfo>(),
1933 20usize,
1934 concat!("Size of: ", stringify!(StdVideoDecodeH264PictureInfo))
1935 );
1936 assert_eq!(
1937 ::std::mem::align_of::<StdVideoDecodeH264PictureInfo>(),
1938 4usize,
1939 concat!("Alignment of ", stringify!(StdVideoDecodeH264PictureInfo))
1940 );
1941 assert_eq!(
1942 unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
1943 0usize,
1944 concat!(
1945 "Offset of field: ",
1946 stringify!(StdVideoDecodeH264PictureInfo),
1947 "::",
1948 stringify!(flags)
1949 )
1950 );
1951 assert_eq!(
1952 unsafe { ::std::ptr::addr_of!((*ptr).seq_parameter_set_id) as usize - ptr as usize },
1953 4usize,
1954 concat!(
1955 "Offset of field: ",
1956 stringify!(StdVideoDecodeH264PictureInfo),
1957 "::",
1958 stringify!(seq_parameter_set_id)
1959 )
1960 );
1961 assert_eq!(
1962 unsafe { ::std::ptr::addr_of!((*ptr).pic_parameter_set_id) as usize - ptr as usize },
1963 5usize,
1964 concat!(
1965 "Offset of field: ",
1966 stringify!(StdVideoDecodeH264PictureInfo),
1967 "::",
1968 stringify!(pic_parameter_set_id)
1969 )
1970 );
1971 assert_eq!(
1972 unsafe { ::std::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize },
1973 6usize,
1974 concat!(
1975 "Offset of field: ",
1976 stringify!(StdVideoDecodeH264PictureInfo),
1977 "::",
1978 stringify!(reserved1)
1979 )
1980 );
1981 assert_eq!(
1982 unsafe { ::std::ptr::addr_of!((*ptr).reserved2) as usize - ptr as usize },
1983 7usize,
1984 concat!(
1985 "Offset of field: ",
1986 stringify!(StdVideoDecodeH264PictureInfo),
1987 "::",
1988 stringify!(reserved2)
1989 )
1990 );
1991 assert_eq!(
1992 unsafe { ::std::ptr::addr_of!((*ptr).frame_num) as usize - ptr as usize },
1993 8usize,
1994 concat!(
1995 "Offset of field: ",
1996 stringify!(StdVideoDecodeH264PictureInfo),
1997 "::",
1998 stringify!(frame_num)
1999 )
2000 );
2001 assert_eq!(
2002 unsafe { ::std::ptr::addr_of!((*ptr).idr_pic_id) as usize - ptr as usize },
2003 10usize,
2004 concat!(
2005 "Offset of field: ",
2006 stringify!(StdVideoDecodeH264PictureInfo),
2007 "::",
2008 stringify!(idr_pic_id)
2009 )
2010 );
2011 assert_eq!(
2012 unsafe { ::std::ptr::addr_of!((*ptr).PicOrderCnt) as usize - ptr as usize },
2013 12usize,
2014 concat!(
2015 "Offset of field: ",
2016 stringify!(StdVideoDecodeH264PictureInfo),
2017 "::",
2018 stringify!(PicOrderCnt)
2019 )
2020 );
2021}
2022#[repr(C)]
2023#[repr(align(4))]
2024#[derive(Debug, Copy, Clone)]
2025pub struct StdVideoDecodeH264ReferenceInfoFlags {
2026 pub _bitfield_align_1: [u8; 0],
2027 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
2028 pub __bindgen_padding_0: [u8; 3usize],
2029}
2030#[test]
2031fn bindgen_test_layout_StdVideoDecodeH264ReferenceInfoFlags() {
2032 assert_eq!(
2033 ::std::mem::size_of::<StdVideoDecodeH264ReferenceInfoFlags>(),
2034 4usize,
2035 concat!(
2036 "Size of: ",
2037 stringify!(StdVideoDecodeH264ReferenceInfoFlags)
2038 )
2039 );
2040 assert_eq!(
2041 ::std::mem::align_of::<StdVideoDecodeH264ReferenceInfoFlags>(),
2042 4usize,
2043 concat!(
2044 "Alignment of ",
2045 stringify!(StdVideoDecodeH264ReferenceInfoFlags)
2046 )
2047 );
2048}
2049impl StdVideoDecodeH264ReferenceInfoFlags {
2050 #[inline]
2051 pub fn top_field_flag(&self) -> u32 {
2052 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
2053 }
2054 #[inline]
2055 pub fn set_top_field_flag(&mut self, val: u32) {
2056 unsafe {
2057 let val: u32 = ::std::mem::transmute(val);
2058 self._bitfield_1.set(0usize, 1u8, val as u64)
2059 }
2060 }
2061 #[inline]
2062 pub fn bottom_field_flag(&self) -> u32 {
2063 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
2064 }
2065 #[inline]
2066 pub fn set_bottom_field_flag(&mut self, val: u32) {
2067 unsafe {
2068 let val: u32 = ::std::mem::transmute(val);
2069 self._bitfield_1.set(1usize, 1u8, val as u64)
2070 }
2071 }
2072 #[inline]
2073 pub fn used_for_long_term_reference(&self) -> u32 {
2074 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
2075 }
2076 #[inline]
2077 pub fn set_used_for_long_term_reference(&mut self, val: u32) {
2078 unsafe {
2079 let val: u32 = ::std::mem::transmute(val);
2080 self._bitfield_1.set(2usize, 1u8, val as u64)
2081 }
2082 }
2083 #[inline]
2084 pub fn is_non_existing(&self) -> u32 {
2085 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
2086 }
2087 #[inline]
2088 pub fn set_is_non_existing(&mut self, val: u32) {
2089 unsafe {
2090 let val: u32 = ::std::mem::transmute(val);
2091 self._bitfield_1.set(3usize, 1u8, val as u64)
2092 }
2093 }
2094 #[inline]
2095 pub fn new_bitfield_1(
2096 top_field_flag: u32,
2097 bottom_field_flag: u32,
2098 used_for_long_term_reference: u32,
2099 is_non_existing: u32,
2100 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
2101 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
2102 __bindgen_bitfield_unit.set(0usize, 1u8, {
2103 let top_field_flag: u32 = unsafe { ::std::mem::transmute(top_field_flag) };
2104 top_field_flag as u64
2105 });
2106 __bindgen_bitfield_unit.set(1usize, 1u8, {
2107 let bottom_field_flag: u32 = unsafe { ::std::mem::transmute(bottom_field_flag) };
2108 bottom_field_flag as u64
2109 });
2110 __bindgen_bitfield_unit.set(2usize, 1u8, {
2111 let used_for_long_term_reference: u32 =
2112 unsafe { ::std::mem::transmute(used_for_long_term_reference) };
2113 used_for_long_term_reference as u64
2114 });
2115 __bindgen_bitfield_unit.set(3usize, 1u8, {
2116 let is_non_existing: u32 = unsafe { ::std::mem::transmute(is_non_existing) };
2117 is_non_existing as u64
2118 });
2119 __bindgen_bitfield_unit
2120 }
2121}
2122#[repr(C)]
2123#[derive(Debug, Copy, Clone)]
2124pub struct StdVideoDecodeH264ReferenceInfo {
2125 pub flags: StdVideoDecodeH264ReferenceInfoFlags,
2126 pub FrameNum: u16,
2127 pub reserved: u16,
2128 pub PicOrderCnt: [i32; 2usize],
2129}
2130#[test]
2131fn bindgen_test_layout_StdVideoDecodeH264ReferenceInfo() {
2132 const UNINIT: ::std::mem::MaybeUninit<StdVideoDecodeH264ReferenceInfo> =
2133 ::std::mem::MaybeUninit::uninit();
2134 let ptr = UNINIT.as_ptr();
2135 assert_eq!(
2136 ::std::mem::size_of::<StdVideoDecodeH264ReferenceInfo>(),
2137 16usize,
2138 concat!("Size of: ", stringify!(StdVideoDecodeH264ReferenceInfo))
2139 );
2140 assert_eq!(
2141 ::std::mem::align_of::<StdVideoDecodeH264ReferenceInfo>(),
2142 4usize,
2143 concat!("Alignment of ", stringify!(StdVideoDecodeH264ReferenceInfo))
2144 );
2145 assert_eq!(
2146 unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
2147 0usize,
2148 concat!(
2149 "Offset of field: ",
2150 stringify!(StdVideoDecodeH264ReferenceInfo),
2151 "::",
2152 stringify!(flags)
2153 )
2154 );
2155 assert_eq!(
2156 unsafe { ::std::ptr::addr_of!((*ptr).FrameNum) as usize - ptr as usize },
2157 4usize,
2158 concat!(
2159 "Offset of field: ",
2160 stringify!(StdVideoDecodeH264ReferenceInfo),
2161 "::",
2162 stringify!(FrameNum)
2163 )
2164 );
2165 assert_eq!(
2166 unsafe { ::std::ptr::addr_of!((*ptr).reserved) as usize - ptr as usize },
2167 6usize,
2168 concat!(
2169 "Offset of field: ",
2170 stringify!(StdVideoDecodeH264ReferenceInfo),
2171 "::",
2172 stringify!(reserved)
2173 )
2174 );
2175 assert_eq!(
2176 unsafe { ::std::ptr::addr_of!((*ptr).PicOrderCnt) as usize - ptr as usize },
2177 8usize,
2178 concat!(
2179 "Offset of field: ",
2180 stringify!(StdVideoDecodeH264ReferenceInfo),
2181 "::",
2182 stringify!(PicOrderCnt)
2183 )
2184 );
2185}
2186pub const StdVideoH265ChromaFormatIdc_STD_VIDEO_H265_CHROMA_FORMAT_IDC_MONOCHROME:
2187 StdVideoH265ChromaFormatIdc = 0;
2188pub const StdVideoH265ChromaFormatIdc_STD_VIDEO_H265_CHROMA_FORMAT_IDC_420:
2189 StdVideoH265ChromaFormatIdc = 1;
2190pub const StdVideoH265ChromaFormatIdc_STD_VIDEO_H265_CHROMA_FORMAT_IDC_422:
2191 StdVideoH265ChromaFormatIdc = 2;
2192pub const StdVideoH265ChromaFormatIdc_STD_VIDEO_H265_CHROMA_FORMAT_IDC_444:
2193 StdVideoH265ChromaFormatIdc = 3;
2194pub const StdVideoH265ChromaFormatIdc_STD_VIDEO_H265_CHROMA_FORMAT_IDC_INVALID:
2195 StdVideoH265ChromaFormatIdc = 2147483647;
2196pub type StdVideoH265ChromaFormatIdc = ::std::os::raw::c_uint;
2197pub const StdVideoH265ProfileIdc_STD_VIDEO_H265_PROFILE_IDC_MAIN: StdVideoH265ProfileIdc = 1;
2198pub const StdVideoH265ProfileIdc_STD_VIDEO_H265_PROFILE_IDC_MAIN_10: StdVideoH265ProfileIdc = 2;
2199pub const StdVideoH265ProfileIdc_STD_VIDEO_H265_PROFILE_IDC_MAIN_STILL_PICTURE:
2200 StdVideoH265ProfileIdc = 3;
2201pub const StdVideoH265ProfileIdc_STD_VIDEO_H265_PROFILE_IDC_FORMAT_RANGE_EXTENSIONS:
2202 StdVideoH265ProfileIdc = 4;
2203pub const StdVideoH265ProfileIdc_STD_VIDEO_H265_PROFILE_IDC_SCC_EXTENSIONS: StdVideoH265ProfileIdc =
2204 9;
2205pub const StdVideoH265ProfileIdc_STD_VIDEO_H265_PROFILE_IDC_INVALID: StdVideoH265ProfileIdc =
2206 2147483647;
2207pub type StdVideoH265ProfileIdc = ::std::os::raw::c_uint;
2208pub const StdVideoH265LevelIdc_STD_VIDEO_H265_LEVEL_IDC_1_0: StdVideoH265LevelIdc = 0;
2209pub const StdVideoH265LevelIdc_STD_VIDEO_H265_LEVEL_IDC_2_0: StdVideoH265LevelIdc = 1;
2210pub const StdVideoH265LevelIdc_STD_VIDEO_H265_LEVEL_IDC_2_1: StdVideoH265LevelIdc = 2;
2211pub const StdVideoH265LevelIdc_STD_VIDEO_H265_LEVEL_IDC_3_0: StdVideoH265LevelIdc = 3;
2212pub const StdVideoH265LevelIdc_STD_VIDEO_H265_LEVEL_IDC_3_1: StdVideoH265LevelIdc = 4;
2213pub const StdVideoH265LevelIdc_STD_VIDEO_H265_LEVEL_IDC_4_0: StdVideoH265LevelIdc = 5;
2214pub const StdVideoH265LevelIdc_STD_VIDEO_H265_LEVEL_IDC_4_1: StdVideoH265LevelIdc = 6;
2215pub const StdVideoH265LevelIdc_STD_VIDEO_H265_LEVEL_IDC_5_0: StdVideoH265LevelIdc = 7;
2216pub const StdVideoH265LevelIdc_STD_VIDEO_H265_LEVEL_IDC_5_1: StdVideoH265LevelIdc = 8;
2217pub const StdVideoH265LevelIdc_STD_VIDEO_H265_LEVEL_IDC_5_2: StdVideoH265LevelIdc = 9;
2218pub const StdVideoH265LevelIdc_STD_VIDEO_H265_LEVEL_IDC_6_0: StdVideoH265LevelIdc = 10;
2219pub const StdVideoH265LevelIdc_STD_VIDEO_H265_LEVEL_IDC_6_1: StdVideoH265LevelIdc = 11;
2220pub const StdVideoH265LevelIdc_STD_VIDEO_H265_LEVEL_IDC_6_2: StdVideoH265LevelIdc = 12;
2221pub const StdVideoH265LevelIdc_STD_VIDEO_H265_LEVEL_IDC_INVALID: StdVideoH265LevelIdc = 2147483647;
2222pub type StdVideoH265LevelIdc = ::std::os::raw::c_uint;
2223pub const StdVideoH265SliceType_STD_VIDEO_H265_SLICE_TYPE_B: StdVideoH265SliceType = 0;
2224pub const StdVideoH265SliceType_STD_VIDEO_H265_SLICE_TYPE_P: StdVideoH265SliceType = 1;
2225pub const StdVideoH265SliceType_STD_VIDEO_H265_SLICE_TYPE_I: StdVideoH265SliceType = 2;
2226pub const StdVideoH265SliceType_STD_VIDEO_H265_SLICE_TYPE_INVALID: StdVideoH265SliceType =
2227 2147483647;
2228pub type StdVideoH265SliceType = ::std::os::raw::c_uint;
2229pub const StdVideoH265PictureType_STD_VIDEO_H265_PICTURE_TYPE_P: StdVideoH265PictureType = 0;
2230pub const StdVideoH265PictureType_STD_VIDEO_H265_PICTURE_TYPE_B: StdVideoH265PictureType = 1;
2231pub const StdVideoH265PictureType_STD_VIDEO_H265_PICTURE_TYPE_I: StdVideoH265PictureType = 2;
2232pub const StdVideoH265PictureType_STD_VIDEO_H265_PICTURE_TYPE_IDR: StdVideoH265PictureType = 3;
2233pub const StdVideoH265PictureType_STD_VIDEO_H265_PICTURE_TYPE_INVALID: StdVideoH265PictureType =
2234 2147483647;
2235pub type StdVideoH265PictureType = ::std::os::raw::c_uint;
2236pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_UNSPECIFIED:
2237 StdVideoH265AspectRatioIdc = 0;
2238pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_SQUARE:
2239 StdVideoH265AspectRatioIdc = 1;
2240pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_12_11:
2241 StdVideoH265AspectRatioIdc = 2;
2242pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_10_11:
2243 StdVideoH265AspectRatioIdc = 3;
2244pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_16_11:
2245 StdVideoH265AspectRatioIdc = 4;
2246pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_40_33:
2247 StdVideoH265AspectRatioIdc = 5;
2248pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_24_11:
2249 StdVideoH265AspectRatioIdc = 6;
2250pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_20_11:
2251 StdVideoH265AspectRatioIdc = 7;
2252pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_32_11:
2253 StdVideoH265AspectRatioIdc = 8;
2254pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_80_33:
2255 StdVideoH265AspectRatioIdc = 9;
2256pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_18_11:
2257 StdVideoH265AspectRatioIdc = 10;
2258pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_15_11:
2259 StdVideoH265AspectRatioIdc = 11;
2260pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_64_33:
2261 StdVideoH265AspectRatioIdc = 12;
2262pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_160_99:
2263 StdVideoH265AspectRatioIdc = 13;
2264pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_4_3:
2265 StdVideoH265AspectRatioIdc = 14;
2266pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_3_2:
2267 StdVideoH265AspectRatioIdc = 15;
2268pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_2_1:
2269 StdVideoH265AspectRatioIdc = 16;
2270pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_EXTENDED_SAR:
2271 StdVideoH265AspectRatioIdc = 255;
2272pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_INVALID:
2273 StdVideoH265AspectRatioIdc = 2147483647;
2274pub type StdVideoH265AspectRatioIdc = ::std::os::raw::c_uint;
2275#[repr(C)]
2276#[derive(Debug, Copy, Clone)]
2277pub struct StdVideoH265DecPicBufMgr {
2278 pub max_latency_increase_plus1: [u32; 7usize],
2279 pub max_dec_pic_buffering_minus1: [u8; 7usize],
2280 pub max_num_reorder_pics: [u8; 7usize],
2281}
2282#[test]
2283fn bindgen_test_layout_StdVideoH265DecPicBufMgr() {
2284 const UNINIT: ::std::mem::MaybeUninit<StdVideoH265DecPicBufMgr> =
2285 ::std::mem::MaybeUninit::uninit();
2286 let ptr = UNINIT.as_ptr();
2287 assert_eq!(
2288 ::std::mem::size_of::<StdVideoH265DecPicBufMgr>(),
2289 44usize,
2290 concat!("Size of: ", stringify!(StdVideoH265DecPicBufMgr))
2291 );
2292 assert_eq!(
2293 ::std::mem::align_of::<StdVideoH265DecPicBufMgr>(),
2294 4usize,
2295 concat!("Alignment of ", stringify!(StdVideoH265DecPicBufMgr))
2296 );
2297 assert_eq!(
2298 unsafe { ::std::ptr::addr_of!((*ptr).max_latency_increase_plus1) as usize - ptr as usize },
2299 0usize,
2300 concat!(
2301 "Offset of field: ",
2302 stringify!(StdVideoH265DecPicBufMgr),
2303 "::",
2304 stringify!(max_latency_increase_plus1)
2305 )
2306 );
2307 assert_eq!(
2308 unsafe {
2309 ::std::ptr::addr_of!((*ptr).max_dec_pic_buffering_minus1) as usize - ptr as usize
2310 },
2311 28usize,
2312 concat!(
2313 "Offset of field: ",
2314 stringify!(StdVideoH265DecPicBufMgr),
2315 "::",
2316 stringify!(max_dec_pic_buffering_minus1)
2317 )
2318 );
2319 assert_eq!(
2320 unsafe { ::std::ptr::addr_of!((*ptr).max_num_reorder_pics) as usize - ptr as usize },
2321 35usize,
2322 concat!(
2323 "Offset of field: ",
2324 stringify!(StdVideoH265DecPicBufMgr),
2325 "::",
2326 stringify!(max_num_reorder_pics)
2327 )
2328 );
2329}
2330#[repr(C)]
2331#[derive(Debug, Copy, Clone)]
2332pub struct StdVideoH265SubLayerHrdParameters {
2333 pub bit_rate_value_minus1: [u32; 32usize],
2334 pub cpb_size_value_minus1: [u32; 32usize],
2335 pub cpb_size_du_value_minus1: [u32; 32usize],
2336 pub bit_rate_du_value_minus1: [u32; 32usize],
2337 pub cbr_flag: u32,
2338}
2339#[test]
2340fn bindgen_test_layout_StdVideoH265SubLayerHrdParameters() {
2341 const UNINIT: ::std::mem::MaybeUninit<StdVideoH265SubLayerHrdParameters> =
2342 ::std::mem::MaybeUninit::uninit();
2343 let ptr = UNINIT.as_ptr();
2344 assert_eq!(
2345 ::std::mem::size_of::<StdVideoH265SubLayerHrdParameters>(),
2346 516usize,
2347 concat!("Size of: ", stringify!(StdVideoH265SubLayerHrdParameters))
2348 );
2349 assert_eq!(
2350 ::std::mem::align_of::<StdVideoH265SubLayerHrdParameters>(),
2351 4usize,
2352 concat!(
2353 "Alignment of ",
2354 stringify!(StdVideoH265SubLayerHrdParameters)
2355 )
2356 );
2357 assert_eq!(
2358 unsafe { ::std::ptr::addr_of!((*ptr).bit_rate_value_minus1) as usize - ptr as usize },
2359 0usize,
2360 concat!(
2361 "Offset of field: ",
2362 stringify!(StdVideoH265SubLayerHrdParameters),
2363 "::",
2364 stringify!(bit_rate_value_minus1)
2365 )
2366 );
2367 assert_eq!(
2368 unsafe { ::std::ptr::addr_of!((*ptr).cpb_size_value_minus1) as usize - ptr as usize },
2369 128usize,
2370 concat!(
2371 "Offset of field: ",
2372 stringify!(StdVideoH265SubLayerHrdParameters),
2373 "::",
2374 stringify!(cpb_size_value_minus1)
2375 )
2376 );
2377 assert_eq!(
2378 unsafe { ::std::ptr::addr_of!((*ptr).cpb_size_du_value_minus1) as usize - ptr as usize },
2379 256usize,
2380 concat!(
2381 "Offset of field: ",
2382 stringify!(StdVideoH265SubLayerHrdParameters),
2383 "::",
2384 stringify!(cpb_size_du_value_minus1)
2385 )
2386 );
2387 assert_eq!(
2388 unsafe { ::std::ptr::addr_of!((*ptr).bit_rate_du_value_minus1) as usize - ptr as usize },
2389 384usize,
2390 concat!(
2391 "Offset of field: ",
2392 stringify!(StdVideoH265SubLayerHrdParameters),
2393 "::",
2394 stringify!(bit_rate_du_value_minus1)
2395 )
2396 );
2397 assert_eq!(
2398 unsafe { ::std::ptr::addr_of!((*ptr).cbr_flag) as usize - ptr as usize },
2399 512usize,
2400 concat!(
2401 "Offset of field: ",
2402 stringify!(StdVideoH265SubLayerHrdParameters),
2403 "::",
2404 stringify!(cbr_flag)
2405 )
2406 );
2407}
2408#[repr(C)]
2409#[repr(align(4))]
2410#[derive(Debug, Copy, Clone)]
2411pub struct StdVideoH265HrdFlags {
2412 pub _bitfield_align_1: [u8; 0],
2413 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
2414}
2415#[test]
2416fn bindgen_test_layout_StdVideoH265HrdFlags() {
2417 assert_eq!(
2418 ::std::mem::size_of::<StdVideoH265HrdFlags>(),
2419 4usize,
2420 concat!("Size of: ", stringify!(StdVideoH265HrdFlags))
2421 );
2422 assert_eq!(
2423 ::std::mem::align_of::<StdVideoH265HrdFlags>(),
2424 4usize,
2425 concat!("Alignment of ", stringify!(StdVideoH265HrdFlags))
2426 );
2427}
2428impl StdVideoH265HrdFlags {
2429 #[inline]
2430 pub fn nal_hrd_parameters_present_flag(&self) -> u32 {
2431 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
2432 }
2433 #[inline]
2434 pub fn set_nal_hrd_parameters_present_flag(&mut self, val: u32) {
2435 unsafe {
2436 let val: u32 = ::std::mem::transmute(val);
2437 self._bitfield_1.set(0usize, 1u8, val as u64)
2438 }
2439 }
2440 #[inline]
2441 pub fn vcl_hrd_parameters_present_flag(&self) -> u32 {
2442 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
2443 }
2444 #[inline]
2445 pub fn set_vcl_hrd_parameters_present_flag(&mut self, val: u32) {
2446 unsafe {
2447 let val: u32 = ::std::mem::transmute(val);
2448 self._bitfield_1.set(1usize, 1u8, val as u64)
2449 }
2450 }
2451 #[inline]
2452 pub fn sub_pic_hrd_params_present_flag(&self) -> u32 {
2453 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
2454 }
2455 #[inline]
2456 pub fn set_sub_pic_hrd_params_present_flag(&mut self, val: u32) {
2457 unsafe {
2458 let val: u32 = ::std::mem::transmute(val);
2459 self._bitfield_1.set(2usize, 1u8, val as u64)
2460 }
2461 }
2462 #[inline]
2463 pub fn sub_pic_cpb_params_in_pic_timing_sei_flag(&self) -> u32 {
2464 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
2465 }
2466 #[inline]
2467 pub fn set_sub_pic_cpb_params_in_pic_timing_sei_flag(&mut self, val: u32) {
2468 unsafe {
2469 let val: u32 = ::std::mem::transmute(val);
2470 self._bitfield_1.set(3usize, 1u8, val as u64)
2471 }
2472 }
2473 #[inline]
2474 pub fn fixed_pic_rate_general_flag(&self) -> u32 {
2475 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 8u8) as u32) }
2476 }
2477 #[inline]
2478 pub fn set_fixed_pic_rate_general_flag(&mut self, val: u32) {
2479 unsafe {
2480 let val: u32 = ::std::mem::transmute(val);
2481 self._bitfield_1.set(4usize, 8u8, val as u64)
2482 }
2483 }
2484 #[inline]
2485 pub fn fixed_pic_rate_within_cvs_flag(&self) -> u32 {
2486 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 8u8) as u32) }
2487 }
2488 #[inline]
2489 pub fn set_fixed_pic_rate_within_cvs_flag(&mut self, val: u32) {
2490 unsafe {
2491 let val: u32 = ::std::mem::transmute(val);
2492 self._bitfield_1.set(12usize, 8u8, val as u64)
2493 }
2494 }
2495 #[inline]
2496 pub fn low_delay_hrd_flag(&self) -> u32 {
2497 unsafe { ::std::mem::transmute(self._bitfield_1.get(20usize, 8u8) as u32) }
2498 }
2499 #[inline]
2500 pub fn set_low_delay_hrd_flag(&mut self, val: u32) {
2501 unsafe {
2502 let val: u32 = ::std::mem::transmute(val);
2503 self._bitfield_1.set(20usize, 8u8, val as u64)
2504 }
2505 }
2506 #[inline]
2507 pub fn new_bitfield_1(
2508 nal_hrd_parameters_present_flag: u32,
2509 vcl_hrd_parameters_present_flag: u32,
2510 sub_pic_hrd_params_present_flag: u32,
2511 sub_pic_cpb_params_in_pic_timing_sei_flag: u32,
2512 fixed_pic_rate_general_flag: u32,
2513 fixed_pic_rate_within_cvs_flag: u32,
2514 low_delay_hrd_flag: u32,
2515 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
2516 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
2517 __bindgen_bitfield_unit.set(0usize, 1u8, {
2518 let nal_hrd_parameters_present_flag: u32 =
2519 unsafe { ::std::mem::transmute(nal_hrd_parameters_present_flag) };
2520 nal_hrd_parameters_present_flag as u64
2521 });
2522 __bindgen_bitfield_unit.set(1usize, 1u8, {
2523 let vcl_hrd_parameters_present_flag: u32 =
2524 unsafe { ::std::mem::transmute(vcl_hrd_parameters_present_flag) };
2525 vcl_hrd_parameters_present_flag as u64
2526 });
2527 __bindgen_bitfield_unit.set(2usize, 1u8, {
2528 let sub_pic_hrd_params_present_flag: u32 =
2529 unsafe { ::std::mem::transmute(sub_pic_hrd_params_present_flag) };
2530 sub_pic_hrd_params_present_flag as u64
2531 });
2532 __bindgen_bitfield_unit.set(3usize, 1u8, {
2533 let sub_pic_cpb_params_in_pic_timing_sei_flag: u32 =
2534 unsafe { ::std::mem::transmute(sub_pic_cpb_params_in_pic_timing_sei_flag) };
2535 sub_pic_cpb_params_in_pic_timing_sei_flag as u64
2536 });
2537 __bindgen_bitfield_unit.set(4usize, 8u8, {
2538 let fixed_pic_rate_general_flag: u32 =
2539 unsafe { ::std::mem::transmute(fixed_pic_rate_general_flag) };
2540 fixed_pic_rate_general_flag as u64
2541 });
2542 __bindgen_bitfield_unit.set(12usize, 8u8, {
2543 let fixed_pic_rate_within_cvs_flag: u32 =
2544 unsafe { ::std::mem::transmute(fixed_pic_rate_within_cvs_flag) };
2545 fixed_pic_rate_within_cvs_flag as u64
2546 });
2547 __bindgen_bitfield_unit.set(20usize, 8u8, {
2548 let low_delay_hrd_flag: u32 = unsafe { ::std::mem::transmute(low_delay_hrd_flag) };
2549 low_delay_hrd_flag as u64
2550 });
2551 __bindgen_bitfield_unit
2552 }
2553}
2554#[repr(C)]
2555#[derive(Debug, Copy, Clone)]
2556pub struct StdVideoH265HrdParameters {
2557 pub flags: StdVideoH265HrdFlags,
2558 pub tick_divisor_minus2: u8,
2559 pub du_cpb_removal_delay_increment_length_minus1: u8,
2560 pub dpb_output_delay_du_length_minus1: u8,
2561 pub bit_rate_scale: u8,
2562 pub cpb_size_scale: u8,
2563 pub cpb_size_du_scale: u8,
2564 pub initial_cpb_removal_delay_length_minus1: u8,
2565 pub au_cpb_removal_delay_length_minus1: u8,
2566 pub dpb_output_delay_length_minus1: u8,
2567 pub cpb_cnt_minus1: [u8; 7usize],
2568 pub elemental_duration_in_tc_minus1: [u16; 7usize],
2569 pub reserved: [u16; 3usize],
2570 pub pSubLayerHrdParametersNal: *const StdVideoH265SubLayerHrdParameters,
2571 pub pSubLayerHrdParametersVcl: *const StdVideoH265SubLayerHrdParameters,
2572}
2573#[test]
2574fn bindgen_test_layout_StdVideoH265HrdParameters() {
2575 const UNINIT: ::std::mem::MaybeUninit<StdVideoH265HrdParameters> =
2576 ::std::mem::MaybeUninit::uninit();
2577 let ptr = UNINIT.as_ptr();
2578 assert_eq!(
2579 ::std::mem::size_of::<StdVideoH265HrdParameters>(),
2580 56usize,
2581 concat!("Size of: ", stringify!(StdVideoH265HrdParameters))
2582 );
2583 assert_eq!(
2584 ::std::mem::align_of::<StdVideoH265HrdParameters>(),
2585 8usize,
2586 concat!("Alignment of ", stringify!(StdVideoH265HrdParameters))
2587 );
2588 assert_eq!(
2589 unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
2590 0usize,
2591 concat!(
2592 "Offset of field: ",
2593 stringify!(StdVideoH265HrdParameters),
2594 "::",
2595 stringify!(flags)
2596 )
2597 );
2598 assert_eq!(
2599 unsafe { ::std::ptr::addr_of!((*ptr).tick_divisor_minus2) as usize - ptr as usize },
2600 4usize,
2601 concat!(
2602 "Offset of field: ",
2603 stringify!(StdVideoH265HrdParameters),
2604 "::",
2605 stringify!(tick_divisor_minus2)
2606 )
2607 );
2608 assert_eq!(
2609 unsafe {
2610 ::std::ptr::addr_of!((*ptr).du_cpb_removal_delay_increment_length_minus1) as usize
2611 - ptr as usize
2612 },
2613 5usize,
2614 concat!(
2615 "Offset of field: ",
2616 stringify!(StdVideoH265HrdParameters),
2617 "::",
2618 stringify!(du_cpb_removal_delay_increment_length_minus1)
2619 )
2620 );
2621 assert_eq!(
2622 unsafe {
2623 ::std::ptr::addr_of!((*ptr).dpb_output_delay_du_length_minus1) as usize - ptr as usize
2624 },
2625 6usize,
2626 concat!(
2627 "Offset of field: ",
2628 stringify!(StdVideoH265HrdParameters),
2629 "::",
2630 stringify!(dpb_output_delay_du_length_minus1)
2631 )
2632 );
2633 assert_eq!(
2634 unsafe { ::std::ptr::addr_of!((*ptr).bit_rate_scale) as usize - ptr as usize },
2635 7usize,
2636 concat!(
2637 "Offset of field: ",
2638 stringify!(StdVideoH265HrdParameters),
2639 "::",
2640 stringify!(bit_rate_scale)
2641 )
2642 );
2643 assert_eq!(
2644 unsafe { ::std::ptr::addr_of!((*ptr).cpb_size_scale) as usize - ptr as usize },
2645 8usize,
2646 concat!(
2647 "Offset of field: ",
2648 stringify!(StdVideoH265HrdParameters),
2649 "::",
2650 stringify!(cpb_size_scale)
2651 )
2652 );
2653 assert_eq!(
2654 unsafe { ::std::ptr::addr_of!((*ptr).cpb_size_du_scale) as usize - ptr as usize },
2655 9usize,
2656 concat!(
2657 "Offset of field: ",
2658 stringify!(StdVideoH265HrdParameters),
2659 "::",
2660 stringify!(cpb_size_du_scale)
2661 )
2662 );
2663 assert_eq!(
2664 unsafe {
2665 ::std::ptr::addr_of!((*ptr).initial_cpb_removal_delay_length_minus1) as usize
2666 - ptr as usize
2667 },
2668 10usize,
2669 concat!(
2670 "Offset of field: ",
2671 stringify!(StdVideoH265HrdParameters),
2672 "::",
2673 stringify!(initial_cpb_removal_delay_length_minus1)
2674 )
2675 );
2676 assert_eq!(
2677 unsafe {
2678 ::std::ptr::addr_of!((*ptr).au_cpb_removal_delay_length_minus1) as usize - ptr as usize
2679 },
2680 11usize,
2681 concat!(
2682 "Offset of field: ",
2683 stringify!(StdVideoH265HrdParameters),
2684 "::",
2685 stringify!(au_cpb_removal_delay_length_minus1)
2686 )
2687 );
2688 assert_eq!(
2689 unsafe {
2690 ::std::ptr::addr_of!((*ptr).dpb_output_delay_length_minus1) as usize - ptr as usize
2691 },
2692 12usize,
2693 concat!(
2694 "Offset of field: ",
2695 stringify!(StdVideoH265HrdParameters),
2696 "::",
2697 stringify!(dpb_output_delay_length_minus1)
2698 )
2699 );
2700 assert_eq!(
2701 unsafe { ::std::ptr::addr_of!((*ptr).cpb_cnt_minus1) as usize - ptr as usize },
2702 13usize,
2703 concat!(
2704 "Offset of field: ",
2705 stringify!(StdVideoH265HrdParameters),
2706 "::",
2707 stringify!(cpb_cnt_minus1)
2708 )
2709 );
2710 assert_eq!(
2711 unsafe {
2712 ::std::ptr::addr_of!((*ptr).elemental_duration_in_tc_minus1) as usize - ptr as usize
2713 },
2714 20usize,
2715 concat!(
2716 "Offset of field: ",
2717 stringify!(StdVideoH265HrdParameters),
2718 "::",
2719 stringify!(elemental_duration_in_tc_minus1)
2720 )
2721 );
2722 assert_eq!(
2723 unsafe { ::std::ptr::addr_of!((*ptr).reserved) as usize - ptr as usize },
2724 34usize,
2725 concat!(
2726 "Offset of field: ",
2727 stringify!(StdVideoH265HrdParameters),
2728 "::",
2729 stringify!(reserved)
2730 )
2731 );
2732 assert_eq!(
2733 unsafe { ::std::ptr::addr_of!((*ptr).pSubLayerHrdParametersNal) as usize - ptr as usize },
2734 40usize,
2735 concat!(
2736 "Offset of field: ",
2737 stringify!(StdVideoH265HrdParameters),
2738 "::",
2739 stringify!(pSubLayerHrdParametersNal)
2740 )
2741 );
2742 assert_eq!(
2743 unsafe { ::std::ptr::addr_of!((*ptr).pSubLayerHrdParametersVcl) as usize - ptr as usize },
2744 48usize,
2745 concat!(
2746 "Offset of field: ",
2747 stringify!(StdVideoH265HrdParameters),
2748 "::",
2749 stringify!(pSubLayerHrdParametersVcl)
2750 )
2751 );
2752}
2753#[repr(C)]
2754#[repr(align(4))]
2755#[derive(Debug, Copy, Clone)]
2756pub struct StdVideoH265VpsFlags {
2757 pub _bitfield_align_1: [u8; 0],
2758 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
2759 pub __bindgen_padding_0: [u8; 3usize],
2760}
2761#[test]
2762fn bindgen_test_layout_StdVideoH265VpsFlags() {
2763 assert_eq!(
2764 ::std::mem::size_of::<StdVideoH265VpsFlags>(),
2765 4usize,
2766 concat!("Size of: ", stringify!(StdVideoH265VpsFlags))
2767 );
2768 assert_eq!(
2769 ::std::mem::align_of::<StdVideoH265VpsFlags>(),
2770 4usize,
2771 concat!("Alignment of ", stringify!(StdVideoH265VpsFlags))
2772 );
2773}
2774impl StdVideoH265VpsFlags {
2775 #[inline]
2776 pub fn vps_temporal_id_nesting_flag(&self) -> u32 {
2777 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
2778 }
2779 #[inline]
2780 pub fn set_vps_temporal_id_nesting_flag(&mut self, val: u32) {
2781 unsafe {
2782 let val: u32 = ::std::mem::transmute(val);
2783 self._bitfield_1.set(0usize, 1u8, val as u64)
2784 }
2785 }
2786 #[inline]
2787 pub fn vps_sub_layer_ordering_info_present_flag(&self) -> u32 {
2788 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
2789 }
2790 #[inline]
2791 pub fn set_vps_sub_layer_ordering_info_present_flag(&mut self, val: u32) {
2792 unsafe {
2793 let val: u32 = ::std::mem::transmute(val);
2794 self._bitfield_1.set(1usize, 1u8, val as u64)
2795 }
2796 }
2797 #[inline]
2798 pub fn vps_timing_info_present_flag(&self) -> u32 {
2799 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
2800 }
2801 #[inline]
2802 pub fn set_vps_timing_info_present_flag(&mut self, val: u32) {
2803 unsafe {
2804 let val: u32 = ::std::mem::transmute(val);
2805 self._bitfield_1.set(2usize, 1u8, val as u64)
2806 }
2807 }
2808 #[inline]
2809 pub fn vps_poc_proportional_to_timing_flag(&self) -> u32 {
2810 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
2811 }
2812 #[inline]
2813 pub fn set_vps_poc_proportional_to_timing_flag(&mut self, val: u32) {
2814 unsafe {
2815 let val: u32 = ::std::mem::transmute(val);
2816 self._bitfield_1.set(3usize, 1u8, val as u64)
2817 }
2818 }
2819 #[inline]
2820 pub fn new_bitfield_1(
2821 vps_temporal_id_nesting_flag: u32,
2822 vps_sub_layer_ordering_info_present_flag: u32,
2823 vps_timing_info_present_flag: u32,
2824 vps_poc_proportional_to_timing_flag: u32,
2825 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
2826 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
2827 __bindgen_bitfield_unit.set(0usize, 1u8, {
2828 let vps_temporal_id_nesting_flag: u32 =
2829 unsafe { ::std::mem::transmute(vps_temporal_id_nesting_flag) };
2830 vps_temporal_id_nesting_flag as u64
2831 });
2832 __bindgen_bitfield_unit.set(1usize, 1u8, {
2833 let vps_sub_layer_ordering_info_present_flag: u32 =
2834 unsafe { ::std::mem::transmute(vps_sub_layer_ordering_info_present_flag) };
2835 vps_sub_layer_ordering_info_present_flag as u64
2836 });
2837 __bindgen_bitfield_unit.set(2usize, 1u8, {
2838 let vps_timing_info_present_flag: u32 =
2839 unsafe { ::std::mem::transmute(vps_timing_info_present_flag) };
2840 vps_timing_info_present_flag as u64
2841 });
2842 __bindgen_bitfield_unit.set(3usize, 1u8, {
2843 let vps_poc_proportional_to_timing_flag: u32 =
2844 unsafe { ::std::mem::transmute(vps_poc_proportional_to_timing_flag) };
2845 vps_poc_proportional_to_timing_flag as u64
2846 });
2847 __bindgen_bitfield_unit
2848 }
2849}
2850#[repr(C)]
2851#[repr(align(4))]
2852#[derive(Debug, Copy, Clone)]
2853pub struct StdVideoH265ProfileTierLevelFlags {
2854 pub _bitfield_align_1: [u8; 0],
2855 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
2856 pub __bindgen_padding_0: [u8; 3usize],
2857}
2858#[test]
2859fn bindgen_test_layout_StdVideoH265ProfileTierLevelFlags() {
2860 assert_eq!(
2861 ::std::mem::size_of::<StdVideoH265ProfileTierLevelFlags>(),
2862 4usize,
2863 concat!("Size of: ", stringify!(StdVideoH265ProfileTierLevelFlags))
2864 );
2865 assert_eq!(
2866 ::std::mem::align_of::<StdVideoH265ProfileTierLevelFlags>(),
2867 4usize,
2868 concat!(
2869 "Alignment of ",
2870 stringify!(StdVideoH265ProfileTierLevelFlags)
2871 )
2872 );
2873}
2874impl StdVideoH265ProfileTierLevelFlags {
2875 #[inline]
2876 pub fn general_tier_flag(&self) -> u32 {
2877 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
2878 }
2879 #[inline]
2880 pub fn set_general_tier_flag(&mut self, val: u32) {
2881 unsafe {
2882 let val: u32 = ::std::mem::transmute(val);
2883 self._bitfield_1.set(0usize, 1u8, val as u64)
2884 }
2885 }
2886 #[inline]
2887 pub fn general_progressive_source_flag(&self) -> u32 {
2888 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
2889 }
2890 #[inline]
2891 pub fn set_general_progressive_source_flag(&mut self, val: u32) {
2892 unsafe {
2893 let val: u32 = ::std::mem::transmute(val);
2894 self._bitfield_1.set(1usize, 1u8, val as u64)
2895 }
2896 }
2897 #[inline]
2898 pub fn general_interlaced_source_flag(&self) -> u32 {
2899 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
2900 }
2901 #[inline]
2902 pub fn set_general_interlaced_source_flag(&mut self, val: u32) {
2903 unsafe {
2904 let val: u32 = ::std::mem::transmute(val);
2905 self._bitfield_1.set(2usize, 1u8, val as u64)
2906 }
2907 }
2908 #[inline]
2909 pub fn general_non_packed_constraint_flag(&self) -> u32 {
2910 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
2911 }
2912 #[inline]
2913 pub fn set_general_non_packed_constraint_flag(&mut self, val: u32) {
2914 unsafe {
2915 let val: u32 = ::std::mem::transmute(val);
2916 self._bitfield_1.set(3usize, 1u8, val as u64)
2917 }
2918 }
2919 #[inline]
2920 pub fn general_frame_only_constraint_flag(&self) -> u32 {
2921 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
2922 }
2923 #[inline]
2924 pub fn set_general_frame_only_constraint_flag(&mut self, val: u32) {
2925 unsafe {
2926 let val: u32 = ::std::mem::transmute(val);
2927 self._bitfield_1.set(4usize, 1u8, val as u64)
2928 }
2929 }
2930 #[inline]
2931 pub fn new_bitfield_1(
2932 general_tier_flag: u32,
2933 general_progressive_source_flag: u32,
2934 general_interlaced_source_flag: u32,
2935 general_non_packed_constraint_flag: u32,
2936 general_frame_only_constraint_flag: u32,
2937 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
2938 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
2939 __bindgen_bitfield_unit.set(0usize, 1u8, {
2940 let general_tier_flag: u32 = unsafe { ::std::mem::transmute(general_tier_flag) };
2941 general_tier_flag as u64
2942 });
2943 __bindgen_bitfield_unit.set(1usize, 1u8, {
2944 let general_progressive_source_flag: u32 =
2945 unsafe { ::std::mem::transmute(general_progressive_source_flag) };
2946 general_progressive_source_flag as u64
2947 });
2948 __bindgen_bitfield_unit.set(2usize, 1u8, {
2949 let general_interlaced_source_flag: u32 =
2950 unsafe { ::std::mem::transmute(general_interlaced_source_flag) };
2951 general_interlaced_source_flag as u64
2952 });
2953 __bindgen_bitfield_unit.set(3usize, 1u8, {
2954 let general_non_packed_constraint_flag: u32 =
2955 unsafe { ::std::mem::transmute(general_non_packed_constraint_flag) };
2956 general_non_packed_constraint_flag as u64
2957 });
2958 __bindgen_bitfield_unit.set(4usize, 1u8, {
2959 let general_frame_only_constraint_flag: u32 =
2960 unsafe { ::std::mem::transmute(general_frame_only_constraint_flag) };
2961 general_frame_only_constraint_flag as u64
2962 });
2963 __bindgen_bitfield_unit
2964 }
2965}
2966#[repr(C)]
2967#[derive(Debug, Copy, Clone)]
2968pub struct StdVideoH265ProfileTierLevel {
2969 pub flags: StdVideoH265ProfileTierLevelFlags,
2970 pub general_profile_idc: StdVideoH265ProfileIdc,
2971 pub general_level_idc: StdVideoH265LevelIdc,
2972}
2973#[test]
2974fn bindgen_test_layout_StdVideoH265ProfileTierLevel() {
2975 const UNINIT: ::std::mem::MaybeUninit<StdVideoH265ProfileTierLevel> =
2976 ::std::mem::MaybeUninit::uninit();
2977 let ptr = UNINIT.as_ptr();
2978 assert_eq!(
2979 ::std::mem::size_of::<StdVideoH265ProfileTierLevel>(),
2980 12usize,
2981 concat!("Size of: ", stringify!(StdVideoH265ProfileTierLevel))
2982 );
2983 assert_eq!(
2984 ::std::mem::align_of::<StdVideoH265ProfileTierLevel>(),
2985 4usize,
2986 concat!("Alignment of ", stringify!(StdVideoH265ProfileTierLevel))
2987 );
2988 assert_eq!(
2989 unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
2990 0usize,
2991 concat!(
2992 "Offset of field: ",
2993 stringify!(StdVideoH265ProfileTierLevel),
2994 "::",
2995 stringify!(flags)
2996 )
2997 );
2998 assert_eq!(
2999 unsafe { ::std::ptr::addr_of!((*ptr).general_profile_idc) as usize - ptr as usize },
3000 4usize,
3001 concat!(
3002 "Offset of field: ",
3003 stringify!(StdVideoH265ProfileTierLevel),
3004 "::",
3005 stringify!(general_profile_idc)
3006 )
3007 );
3008 assert_eq!(
3009 unsafe { ::std::ptr::addr_of!((*ptr).general_level_idc) as usize - ptr as usize },
3010 8usize,
3011 concat!(
3012 "Offset of field: ",
3013 stringify!(StdVideoH265ProfileTierLevel),
3014 "::",
3015 stringify!(general_level_idc)
3016 )
3017 );
3018}
3019#[repr(C)]
3020#[derive(Debug, Copy, Clone)]
3021pub struct StdVideoH265VideoParameterSet {
3022 pub flags: StdVideoH265VpsFlags,
3023 pub vps_video_parameter_set_id: u8,
3024 pub vps_max_sub_layers_minus1: u8,
3025 pub reserved1: u8,
3026 pub reserved2: u8,
3027 pub vps_num_units_in_tick: u32,
3028 pub vps_time_scale: u32,
3029 pub vps_num_ticks_poc_diff_one_minus1: u32,
3030 pub reserved3: u32,
3031 pub pDecPicBufMgr: *const StdVideoH265DecPicBufMgr,
3032 pub pHrdParameters: *const StdVideoH265HrdParameters,
3033 pub pProfileTierLevel: *const StdVideoH265ProfileTierLevel,
3034}
3035#[test]
3036fn bindgen_test_layout_StdVideoH265VideoParameterSet() {
3037 const UNINIT: ::std::mem::MaybeUninit<StdVideoH265VideoParameterSet> =
3038 ::std::mem::MaybeUninit::uninit();
3039 let ptr = UNINIT.as_ptr();
3040 assert_eq!(
3041 ::std::mem::size_of::<StdVideoH265VideoParameterSet>(),
3042 48usize,
3043 concat!("Size of: ", stringify!(StdVideoH265VideoParameterSet))
3044 );
3045 assert_eq!(
3046 ::std::mem::align_of::<StdVideoH265VideoParameterSet>(),
3047 8usize,
3048 concat!("Alignment of ", stringify!(StdVideoH265VideoParameterSet))
3049 );
3050 assert_eq!(
3051 unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
3052 0usize,
3053 concat!(
3054 "Offset of field: ",
3055 stringify!(StdVideoH265VideoParameterSet),
3056 "::",
3057 stringify!(flags)
3058 )
3059 );
3060 assert_eq!(
3061 unsafe { ::std::ptr::addr_of!((*ptr).vps_video_parameter_set_id) as usize - ptr as usize },
3062 4usize,
3063 concat!(
3064 "Offset of field: ",
3065 stringify!(StdVideoH265VideoParameterSet),
3066 "::",
3067 stringify!(vps_video_parameter_set_id)
3068 )
3069 );
3070 assert_eq!(
3071 unsafe { ::std::ptr::addr_of!((*ptr).vps_max_sub_layers_minus1) as usize - ptr as usize },
3072 5usize,
3073 concat!(
3074 "Offset of field: ",
3075 stringify!(StdVideoH265VideoParameterSet),
3076 "::",
3077 stringify!(vps_max_sub_layers_minus1)
3078 )
3079 );
3080 assert_eq!(
3081 unsafe { ::std::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize },
3082 6usize,
3083 concat!(
3084 "Offset of field: ",
3085 stringify!(StdVideoH265VideoParameterSet),
3086 "::",
3087 stringify!(reserved1)
3088 )
3089 );
3090 assert_eq!(
3091 unsafe { ::std::ptr::addr_of!((*ptr).reserved2) as usize - ptr as usize },
3092 7usize,
3093 concat!(
3094 "Offset of field: ",
3095 stringify!(StdVideoH265VideoParameterSet),
3096 "::",
3097 stringify!(reserved2)
3098 )
3099 );
3100 assert_eq!(
3101 unsafe { ::std::ptr::addr_of!((*ptr).vps_num_units_in_tick) as usize - ptr as usize },
3102 8usize,
3103 concat!(
3104 "Offset of field: ",
3105 stringify!(StdVideoH265VideoParameterSet),
3106 "::",
3107 stringify!(vps_num_units_in_tick)
3108 )
3109 );
3110 assert_eq!(
3111 unsafe { ::std::ptr::addr_of!((*ptr).vps_time_scale) as usize - ptr as usize },
3112 12usize,
3113 concat!(
3114 "Offset of field: ",
3115 stringify!(StdVideoH265VideoParameterSet),
3116 "::",
3117 stringify!(vps_time_scale)
3118 )
3119 );
3120 assert_eq!(
3121 unsafe {
3122 ::std::ptr::addr_of!((*ptr).vps_num_ticks_poc_diff_one_minus1) as usize - ptr as usize
3123 },
3124 16usize,
3125 concat!(
3126 "Offset of field: ",
3127 stringify!(StdVideoH265VideoParameterSet),
3128 "::",
3129 stringify!(vps_num_ticks_poc_diff_one_minus1)
3130 )
3131 );
3132 assert_eq!(
3133 unsafe { ::std::ptr::addr_of!((*ptr).reserved3) as usize - ptr as usize },
3134 20usize,
3135 concat!(
3136 "Offset of field: ",
3137 stringify!(StdVideoH265VideoParameterSet),
3138 "::",
3139 stringify!(reserved3)
3140 )
3141 );
3142 assert_eq!(
3143 unsafe { ::std::ptr::addr_of!((*ptr).pDecPicBufMgr) as usize - ptr as usize },
3144 24usize,
3145 concat!(
3146 "Offset of field: ",
3147 stringify!(StdVideoH265VideoParameterSet),
3148 "::",
3149 stringify!(pDecPicBufMgr)
3150 )
3151 );
3152 assert_eq!(
3153 unsafe { ::std::ptr::addr_of!((*ptr).pHrdParameters) as usize - ptr as usize },
3154 32usize,
3155 concat!(
3156 "Offset of field: ",
3157 stringify!(StdVideoH265VideoParameterSet),
3158 "::",
3159 stringify!(pHrdParameters)
3160 )
3161 );
3162 assert_eq!(
3163 unsafe { ::std::ptr::addr_of!((*ptr).pProfileTierLevel) as usize - ptr as usize },
3164 40usize,
3165 concat!(
3166 "Offset of field: ",
3167 stringify!(StdVideoH265VideoParameterSet),
3168 "::",
3169 stringify!(pProfileTierLevel)
3170 )
3171 );
3172}
3173#[repr(C)]
3174#[derive(Debug, Copy, Clone)]
3175pub struct StdVideoH265ScalingLists {
3176 pub ScalingList4x4: [[u8; 16usize]; 6usize],
3177 pub ScalingList8x8: [[u8; 64usize]; 6usize],
3178 pub ScalingList16x16: [[u8; 64usize]; 6usize],
3179 pub ScalingList32x32: [[u8; 64usize]; 2usize],
3180 pub ScalingListDCCoef16x16: [u8; 6usize],
3181 pub ScalingListDCCoef32x32: [u8; 2usize],
3182}
3183#[test]
3184fn bindgen_test_layout_StdVideoH265ScalingLists() {
3185 const UNINIT: ::std::mem::MaybeUninit<StdVideoH265ScalingLists> =
3186 ::std::mem::MaybeUninit::uninit();
3187 let ptr = UNINIT.as_ptr();
3188 assert_eq!(
3189 ::std::mem::size_of::<StdVideoH265ScalingLists>(),
3190 1000usize,
3191 concat!("Size of: ", stringify!(StdVideoH265ScalingLists))
3192 );
3193 assert_eq!(
3194 ::std::mem::align_of::<StdVideoH265ScalingLists>(),
3195 1usize,
3196 concat!("Alignment of ", stringify!(StdVideoH265ScalingLists))
3197 );
3198 assert_eq!(
3199 unsafe { ::std::ptr::addr_of!((*ptr).ScalingList4x4) as usize - ptr as usize },
3200 0usize,
3201 concat!(
3202 "Offset of field: ",
3203 stringify!(StdVideoH265ScalingLists),
3204 "::",
3205 stringify!(ScalingList4x4)
3206 )
3207 );
3208 assert_eq!(
3209 unsafe { ::std::ptr::addr_of!((*ptr).ScalingList8x8) as usize - ptr as usize },
3210 96usize,
3211 concat!(
3212 "Offset of field: ",
3213 stringify!(StdVideoH265ScalingLists),
3214 "::",
3215 stringify!(ScalingList8x8)
3216 )
3217 );
3218 assert_eq!(
3219 unsafe { ::std::ptr::addr_of!((*ptr).ScalingList16x16) as usize - ptr as usize },
3220 480usize,
3221 concat!(
3222 "Offset of field: ",
3223 stringify!(StdVideoH265ScalingLists),
3224 "::",
3225 stringify!(ScalingList16x16)
3226 )
3227 );
3228 assert_eq!(
3229 unsafe { ::std::ptr::addr_of!((*ptr).ScalingList32x32) as usize - ptr as usize },
3230 864usize,
3231 concat!(
3232 "Offset of field: ",
3233 stringify!(StdVideoH265ScalingLists),
3234 "::",
3235 stringify!(ScalingList32x32)
3236 )
3237 );
3238 assert_eq!(
3239 unsafe { ::std::ptr::addr_of!((*ptr).ScalingListDCCoef16x16) as usize - ptr as usize },
3240 992usize,
3241 concat!(
3242 "Offset of field: ",
3243 stringify!(StdVideoH265ScalingLists),
3244 "::",
3245 stringify!(ScalingListDCCoef16x16)
3246 )
3247 );
3248 assert_eq!(
3249 unsafe { ::std::ptr::addr_of!((*ptr).ScalingListDCCoef32x32) as usize - ptr as usize },
3250 998usize,
3251 concat!(
3252 "Offset of field: ",
3253 stringify!(StdVideoH265ScalingLists),
3254 "::",
3255 stringify!(ScalingListDCCoef32x32)
3256 )
3257 );
3258}
3259#[repr(C)]
3260#[repr(align(4))]
3261#[derive(Debug, Copy, Clone)]
3262pub struct StdVideoH265SpsVuiFlags {
3263 pub _bitfield_align_1: [u8; 0],
3264 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 3usize]>,
3265 pub __bindgen_padding_0: u8,
3266}
3267#[test]
3268fn bindgen_test_layout_StdVideoH265SpsVuiFlags() {
3269 assert_eq!(
3270 ::std::mem::size_of::<StdVideoH265SpsVuiFlags>(),
3271 4usize,
3272 concat!("Size of: ", stringify!(StdVideoH265SpsVuiFlags))
3273 );
3274 assert_eq!(
3275 ::std::mem::align_of::<StdVideoH265SpsVuiFlags>(),
3276 4usize,
3277 concat!("Alignment of ", stringify!(StdVideoH265SpsVuiFlags))
3278 );
3279}
3280impl StdVideoH265SpsVuiFlags {
3281 #[inline]
3282 pub fn aspect_ratio_info_present_flag(&self) -> u32 {
3283 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
3284 }
3285 #[inline]
3286 pub fn set_aspect_ratio_info_present_flag(&mut self, val: u32) {
3287 unsafe {
3288 let val: u32 = ::std::mem::transmute(val);
3289 self._bitfield_1.set(0usize, 1u8, val as u64)
3290 }
3291 }
3292 #[inline]
3293 pub fn overscan_info_present_flag(&self) -> u32 {
3294 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
3295 }
3296 #[inline]
3297 pub fn set_overscan_info_present_flag(&mut self, val: u32) {
3298 unsafe {
3299 let val: u32 = ::std::mem::transmute(val);
3300 self._bitfield_1.set(1usize, 1u8, val as u64)
3301 }
3302 }
3303 #[inline]
3304 pub fn overscan_appropriate_flag(&self) -> u32 {
3305 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
3306 }
3307 #[inline]
3308 pub fn set_overscan_appropriate_flag(&mut self, val: u32) {
3309 unsafe {
3310 let val: u32 = ::std::mem::transmute(val);
3311 self._bitfield_1.set(2usize, 1u8, val as u64)
3312 }
3313 }
3314 #[inline]
3315 pub fn video_signal_type_present_flag(&self) -> u32 {
3316 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
3317 }
3318 #[inline]
3319 pub fn set_video_signal_type_present_flag(&mut self, val: u32) {
3320 unsafe {
3321 let val: u32 = ::std::mem::transmute(val);
3322 self._bitfield_1.set(3usize, 1u8, val as u64)
3323 }
3324 }
3325 #[inline]
3326 pub fn video_full_range_flag(&self) -> u32 {
3327 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
3328 }
3329 #[inline]
3330 pub fn set_video_full_range_flag(&mut self, val: u32) {
3331 unsafe {
3332 let val: u32 = ::std::mem::transmute(val);
3333 self._bitfield_1.set(4usize, 1u8, val as u64)
3334 }
3335 }
3336 #[inline]
3337 pub fn colour_description_present_flag(&self) -> u32 {
3338 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
3339 }
3340 #[inline]
3341 pub fn set_colour_description_present_flag(&mut self, val: u32) {
3342 unsafe {
3343 let val: u32 = ::std::mem::transmute(val);
3344 self._bitfield_1.set(5usize, 1u8, val as u64)
3345 }
3346 }
3347 #[inline]
3348 pub fn chroma_loc_info_present_flag(&self) -> u32 {
3349 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) }
3350 }
3351 #[inline]
3352 pub fn set_chroma_loc_info_present_flag(&mut self, val: u32) {
3353 unsafe {
3354 let val: u32 = ::std::mem::transmute(val);
3355 self._bitfield_1.set(6usize, 1u8, val as u64)
3356 }
3357 }
3358 #[inline]
3359 pub fn neutral_chroma_indication_flag(&self) -> u32 {
3360 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) }
3361 }
3362 #[inline]
3363 pub fn set_neutral_chroma_indication_flag(&mut self, val: u32) {
3364 unsafe {
3365 let val: u32 = ::std::mem::transmute(val);
3366 self._bitfield_1.set(7usize, 1u8, val as u64)
3367 }
3368 }
3369 #[inline]
3370 pub fn field_seq_flag(&self) -> u32 {
3371 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) }
3372 }
3373 #[inline]
3374 pub fn set_field_seq_flag(&mut self, val: u32) {
3375 unsafe {
3376 let val: u32 = ::std::mem::transmute(val);
3377 self._bitfield_1.set(8usize, 1u8, val as u64)
3378 }
3379 }
3380 #[inline]
3381 pub fn frame_field_info_present_flag(&self) -> u32 {
3382 unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) }
3383 }
3384 #[inline]
3385 pub fn set_frame_field_info_present_flag(&mut self, val: u32) {
3386 unsafe {
3387 let val: u32 = ::std::mem::transmute(val);
3388 self._bitfield_1.set(9usize, 1u8, val as u64)
3389 }
3390 }
3391 #[inline]
3392 pub fn default_display_window_flag(&self) -> u32 {
3393 unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) }
3394 }
3395 #[inline]
3396 pub fn set_default_display_window_flag(&mut self, val: u32) {
3397 unsafe {
3398 let val: u32 = ::std::mem::transmute(val);
3399 self._bitfield_1.set(10usize, 1u8, val as u64)
3400 }
3401 }
3402 #[inline]
3403 pub fn vui_timing_info_present_flag(&self) -> u32 {
3404 unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) }
3405 }
3406 #[inline]
3407 pub fn set_vui_timing_info_present_flag(&mut self, val: u32) {
3408 unsafe {
3409 let val: u32 = ::std::mem::transmute(val);
3410 self._bitfield_1.set(11usize, 1u8, val as u64)
3411 }
3412 }
3413 #[inline]
3414 pub fn vui_poc_proportional_to_timing_flag(&self) -> u32 {
3415 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u32) }
3416 }
3417 #[inline]
3418 pub fn set_vui_poc_proportional_to_timing_flag(&mut self, val: u32) {
3419 unsafe {
3420 let val: u32 = ::std::mem::transmute(val);
3421 self._bitfield_1.set(12usize, 1u8, val as u64)
3422 }
3423 }
3424 #[inline]
3425 pub fn vui_hrd_parameters_present_flag(&self) -> u32 {
3426 unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) }
3427 }
3428 #[inline]
3429 pub fn set_vui_hrd_parameters_present_flag(&mut self, val: u32) {
3430 unsafe {
3431 let val: u32 = ::std::mem::transmute(val);
3432 self._bitfield_1.set(13usize, 1u8, val as u64)
3433 }
3434 }
3435 #[inline]
3436 pub fn bitstream_restriction_flag(&self) -> u32 {
3437 unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) }
3438 }
3439 #[inline]
3440 pub fn set_bitstream_restriction_flag(&mut self, val: u32) {
3441 unsafe {
3442 let val: u32 = ::std::mem::transmute(val);
3443 self._bitfield_1.set(14usize, 1u8, val as u64)
3444 }
3445 }
3446 #[inline]
3447 pub fn tiles_fixed_structure_flag(&self) -> u32 {
3448 unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u32) }
3449 }
3450 #[inline]
3451 pub fn set_tiles_fixed_structure_flag(&mut self, val: u32) {
3452 unsafe {
3453 let val: u32 = ::std::mem::transmute(val);
3454 self._bitfield_1.set(15usize, 1u8, val as u64)
3455 }
3456 }
3457 #[inline]
3458 pub fn motion_vectors_over_pic_boundaries_flag(&self) -> u32 {
3459 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u32) }
3460 }
3461 #[inline]
3462 pub fn set_motion_vectors_over_pic_boundaries_flag(&mut self, val: u32) {
3463 unsafe {
3464 let val: u32 = ::std::mem::transmute(val);
3465 self._bitfield_1.set(16usize, 1u8, val as u64)
3466 }
3467 }
3468 #[inline]
3469 pub fn restricted_ref_pic_lists_flag(&self) -> u32 {
3470 unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 1u8) as u32) }
3471 }
3472 #[inline]
3473 pub fn set_restricted_ref_pic_lists_flag(&mut self, val: u32) {
3474 unsafe {
3475 let val: u32 = ::std::mem::transmute(val);
3476 self._bitfield_1.set(17usize, 1u8, val as u64)
3477 }
3478 }
3479 #[inline]
3480 pub fn new_bitfield_1(
3481 aspect_ratio_info_present_flag: u32,
3482 overscan_info_present_flag: u32,
3483 overscan_appropriate_flag: u32,
3484 video_signal_type_present_flag: u32,
3485 video_full_range_flag: u32,
3486 colour_description_present_flag: u32,
3487 chroma_loc_info_present_flag: u32,
3488 neutral_chroma_indication_flag: u32,
3489 field_seq_flag: u32,
3490 frame_field_info_present_flag: u32,
3491 default_display_window_flag: u32,
3492 vui_timing_info_present_flag: u32,
3493 vui_poc_proportional_to_timing_flag: u32,
3494 vui_hrd_parameters_present_flag: u32,
3495 bitstream_restriction_flag: u32,
3496 tiles_fixed_structure_flag: u32,
3497 motion_vectors_over_pic_boundaries_flag: u32,
3498 restricted_ref_pic_lists_flag: u32,
3499 ) -> __BindgenBitfieldUnit<[u8; 3usize]> {
3500 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 3usize]> = Default::default();
3501 __bindgen_bitfield_unit.set(0usize, 1u8, {
3502 let aspect_ratio_info_present_flag: u32 =
3503 unsafe { ::std::mem::transmute(aspect_ratio_info_present_flag) };
3504 aspect_ratio_info_present_flag as u64
3505 });
3506 __bindgen_bitfield_unit.set(1usize, 1u8, {
3507 let overscan_info_present_flag: u32 =
3508 unsafe { ::std::mem::transmute(overscan_info_present_flag) };
3509 overscan_info_present_flag as u64
3510 });
3511 __bindgen_bitfield_unit.set(2usize, 1u8, {
3512 let overscan_appropriate_flag: u32 =
3513 unsafe { ::std::mem::transmute(overscan_appropriate_flag) };
3514 overscan_appropriate_flag as u64
3515 });
3516 __bindgen_bitfield_unit.set(3usize, 1u8, {
3517 let video_signal_type_present_flag: u32 =
3518 unsafe { ::std::mem::transmute(video_signal_type_present_flag) };
3519 video_signal_type_present_flag as u64
3520 });
3521 __bindgen_bitfield_unit.set(4usize, 1u8, {
3522 let video_full_range_flag: u32 =
3523 unsafe { ::std::mem::transmute(video_full_range_flag) };
3524 video_full_range_flag as u64
3525 });
3526 __bindgen_bitfield_unit.set(5usize, 1u8, {
3527 let colour_description_present_flag: u32 =
3528 unsafe { ::std::mem::transmute(colour_description_present_flag) };
3529 colour_description_present_flag as u64
3530 });
3531 __bindgen_bitfield_unit.set(6usize, 1u8, {
3532 let chroma_loc_info_present_flag: u32 =
3533 unsafe { ::std::mem::transmute(chroma_loc_info_present_flag) };
3534 chroma_loc_info_present_flag as u64
3535 });
3536 __bindgen_bitfield_unit.set(7usize, 1u8, {
3537 let neutral_chroma_indication_flag: u32 =
3538 unsafe { ::std::mem::transmute(neutral_chroma_indication_flag) };
3539 neutral_chroma_indication_flag as u64
3540 });
3541 __bindgen_bitfield_unit.set(8usize, 1u8, {
3542 let field_seq_flag: u32 = unsafe { ::std::mem::transmute(field_seq_flag) };
3543 field_seq_flag as u64
3544 });
3545 __bindgen_bitfield_unit.set(9usize, 1u8, {
3546 let frame_field_info_present_flag: u32 =
3547 unsafe { ::std::mem::transmute(frame_field_info_present_flag) };
3548 frame_field_info_present_flag as u64
3549 });
3550 __bindgen_bitfield_unit.set(10usize, 1u8, {
3551 let default_display_window_flag: u32 =
3552 unsafe { ::std::mem::transmute(default_display_window_flag) };
3553 default_display_window_flag as u64
3554 });
3555 __bindgen_bitfield_unit.set(11usize, 1u8, {
3556 let vui_timing_info_present_flag: u32 =
3557 unsafe { ::std::mem::transmute(vui_timing_info_present_flag) };
3558 vui_timing_info_present_flag as u64
3559 });
3560 __bindgen_bitfield_unit.set(12usize, 1u8, {
3561 let vui_poc_proportional_to_timing_flag: u32 =
3562 unsafe { ::std::mem::transmute(vui_poc_proportional_to_timing_flag) };
3563 vui_poc_proportional_to_timing_flag as u64
3564 });
3565 __bindgen_bitfield_unit.set(13usize, 1u8, {
3566 let vui_hrd_parameters_present_flag: u32 =
3567 unsafe { ::std::mem::transmute(vui_hrd_parameters_present_flag) };
3568 vui_hrd_parameters_present_flag as u64
3569 });
3570 __bindgen_bitfield_unit.set(14usize, 1u8, {
3571 let bitstream_restriction_flag: u32 =
3572 unsafe { ::std::mem::transmute(bitstream_restriction_flag) };
3573 bitstream_restriction_flag as u64
3574 });
3575 __bindgen_bitfield_unit.set(15usize, 1u8, {
3576 let tiles_fixed_structure_flag: u32 =
3577 unsafe { ::std::mem::transmute(tiles_fixed_structure_flag) };
3578 tiles_fixed_structure_flag as u64
3579 });
3580 __bindgen_bitfield_unit.set(16usize, 1u8, {
3581 let motion_vectors_over_pic_boundaries_flag: u32 =
3582 unsafe { ::std::mem::transmute(motion_vectors_over_pic_boundaries_flag) };
3583 motion_vectors_over_pic_boundaries_flag as u64
3584 });
3585 __bindgen_bitfield_unit.set(17usize, 1u8, {
3586 let restricted_ref_pic_lists_flag: u32 =
3587 unsafe { ::std::mem::transmute(restricted_ref_pic_lists_flag) };
3588 restricted_ref_pic_lists_flag as u64
3589 });
3590 __bindgen_bitfield_unit
3591 }
3592}
3593#[repr(C)]
3594#[derive(Debug, Copy, Clone)]
3595pub struct StdVideoH265SequenceParameterSetVui {
3596 pub flags: StdVideoH265SpsVuiFlags,
3597 pub aspect_ratio_idc: StdVideoH265AspectRatioIdc,
3598 pub sar_width: u16,
3599 pub sar_height: u16,
3600 pub video_format: u8,
3601 pub colour_primaries: u8,
3602 pub transfer_characteristics: u8,
3603 pub matrix_coeffs: u8,
3604 pub chroma_sample_loc_type_top_field: u8,
3605 pub chroma_sample_loc_type_bottom_field: u8,
3606 pub reserved1: u8,
3607 pub reserved2: u8,
3608 pub def_disp_win_left_offset: u16,
3609 pub def_disp_win_right_offset: u16,
3610 pub def_disp_win_top_offset: u16,
3611 pub def_disp_win_bottom_offset: u16,
3612 pub vui_num_units_in_tick: u32,
3613 pub vui_time_scale: u32,
3614 pub vui_num_ticks_poc_diff_one_minus1: u32,
3615 pub min_spatial_segmentation_idc: u16,
3616 pub reserved3: u16,
3617 pub max_bytes_per_pic_denom: u8,
3618 pub max_bits_per_min_cu_denom: u8,
3619 pub log2_max_mv_length_horizontal: u8,
3620 pub log2_max_mv_length_vertical: u8,
3621 pub pHrdParameters: *const StdVideoH265HrdParameters,
3622}
3623#[test]
3624fn bindgen_test_layout_StdVideoH265SequenceParameterSetVui() {
3625 const UNINIT: ::std::mem::MaybeUninit<StdVideoH265SequenceParameterSetVui> =
3626 ::std::mem::MaybeUninit::uninit();
3627 let ptr = UNINIT.as_ptr();
3628 assert_eq!(
3629 ::std::mem::size_of::<StdVideoH265SequenceParameterSetVui>(),
3630 56usize,
3631 concat!("Size of: ", stringify!(StdVideoH265SequenceParameterSetVui))
3632 );
3633 assert_eq!(
3634 ::std::mem::align_of::<StdVideoH265SequenceParameterSetVui>(),
3635 8usize,
3636 concat!(
3637 "Alignment of ",
3638 stringify!(StdVideoH265SequenceParameterSetVui)
3639 )
3640 );
3641 assert_eq!(
3642 unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
3643 0usize,
3644 concat!(
3645 "Offset of field: ",
3646 stringify!(StdVideoH265SequenceParameterSetVui),
3647 "::",
3648 stringify!(flags)
3649 )
3650 );
3651 assert_eq!(
3652 unsafe { ::std::ptr::addr_of!((*ptr).aspect_ratio_idc) as usize - ptr as usize },
3653 4usize,
3654 concat!(
3655 "Offset of field: ",
3656 stringify!(StdVideoH265SequenceParameterSetVui),
3657 "::",
3658 stringify!(aspect_ratio_idc)
3659 )
3660 );
3661 assert_eq!(
3662 unsafe { ::std::ptr::addr_of!((*ptr).sar_width) as usize - ptr as usize },
3663 8usize,
3664 concat!(
3665 "Offset of field: ",
3666 stringify!(StdVideoH265SequenceParameterSetVui),
3667 "::",
3668 stringify!(sar_width)
3669 )
3670 );
3671 assert_eq!(
3672 unsafe { ::std::ptr::addr_of!((*ptr).sar_height) as usize - ptr as usize },
3673 10usize,
3674 concat!(
3675 "Offset of field: ",
3676 stringify!(StdVideoH265SequenceParameterSetVui),
3677 "::",
3678 stringify!(sar_height)
3679 )
3680 );
3681 assert_eq!(
3682 unsafe { ::std::ptr::addr_of!((*ptr).video_format) as usize - ptr as usize },
3683 12usize,
3684 concat!(
3685 "Offset of field: ",
3686 stringify!(StdVideoH265SequenceParameterSetVui),
3687 "::",
3688 stringify!(video_format)
3689 )
3690 );
3691 assert_eq!(
3692 unsafe { ::std::ptr::addr_of!((*ptr).colour_primaries) as usize - ptr as usize },
3693 13usize,
3694 concat!(
3695 "Offset of field: ",
3696 stringify!(StdVideoH265SequenceParameterSetVui),
3697 "::",
3698 stringify!(colour_primaries)
3699 )
3700 );
3701 assert_eq!(
3702 unsafe { ::std::ptr::addr_of!((*ptr).transfer_characteristics) as usize - ptr as usize },
3703 14usize,
3704 concat!(
3705 "Offset of field: ",
3706 stringify!(StdVideoH265SequenceParameterSetVui),
3707 "::",
3708 stringify!(transfer_characteristics)
3709 )
3710 );
3711 assert_eq!(
3712 unsafe { ::std::ptr::addr_of!((*ptr).matrix_coeffs) as usize - ptr as usize },
3713 15usize,
3714 concat!(
3715 "Offset of field: ",
3716 stringify!(StdVideoH265SequenceParameterSetVui),
3717 "::",
3718 stringify!(matrix_coeffs)
3719 )
3720 );
3721 assert_eq!(
3722 unsafe {
3723 ::std::ptr::addr_of!((*ptr).chroma_sample_loc_type_top_field) as usize - ptr as usize
3724 },
3725 16usize,
3726 concat!(
3727 "Offset of field: ",
3728 stringify!(StdVideoH265SequenceParameterSetVui),
3729 "::",
3730 stringify!(chroma_sample_loc_type_top_field)
3731 )
3732 );
3733 assert_eq!(
3734 unsafe {
3735 ::std::ptr::addr_of!((*ptr).chroma_sample_loc_type_bottom_field) as usize - ptr as usize
3736 },
3737 17usize,
3738 concat!(
3739 "Offset of field: ",
3740 stringify!(StdVideoH265SequenceParameterSetVui),
3741 "::",
3742 stringify!(chroma_sample_loc_type_bottom_field)
3743 )
3744 );
3745 assert_eq!(
3746 unsafe { ::std::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize },
3747 18usize,
3748 concat!(
3749 "Offset of field: ",
3750 stringify!(StdVideoH265SequenceParameterSetVui),
3751 "::",
3752 stringify!(reserved1)
3753 )
3754 );
3755 assert_eq!(
3756 unsafe { ::std::ptr::addr_of!((*ptr).reserved2) as usize - ptr as usize },
3757 19usize,
3758 concat!(
3759 "Offset of field: ",
3760 stringify!(StdVideoH265SequenceParameterSetVui),
3761 "::",
3762 stringify!(reserved2)
3763 )
3764 );
3765 assert_eq!(
3766 unsafe { ::std::ptr::addr_of!((*ptr).def_disp_win_left_offset) as usize - ptr as usize },
3767 20usize,
3768 concat!(
3769 "Offset of field: ",
3770 stringify!(StdVideoH265SequenceParameterSetVui),
3771 "::",
3772 stringify!(def_disp_win_left_offset)
3773 )
3774 );
3775 assert_eq!(
3776 unsafe { ::std::ptr::addr_of!((*ptr).def_disp_win_right_offset) as usize - ptr as usize },
3777 22usize,
3778 concat!(
3779 "Offset of field: ",
3780 stringify!(StdVideoH265SequenceParameterSetVui),
3781 "::",
3782 stringify!(def_disp_win_right_offset)
3783 )
3784 );
3785 assert_eq!(
3786 unsafe { ::std::ptr::addr_of!((*ptr).def_disp_win_top_offset) as usize - ptr as usize },
3787 24usize,
3788 concat!(
3789 "Offset of field: ",
3790 stringify!(StdVideoH265SequenceParameterSetVui),
3791 "::",
3792 stringify!(def_disp_win_top_offset)
3793 )
3794 );
3795 assert_eq!(
3796 unsafe { ::std::ptr::addr_of!((*ptr).def_disp_win_bottom_offset) as usize - ptr as usize },
3797 26usize,
3798 concat!(
3799 "Offset of field: ",
3800 stringify!(StdVideoH265SequenceParameterSetVui),
3801 "::",
3802 stringify!(def_disp_win_bottom_offset)
3803 )
3804 );
3805 assert_eq!(
3806 unsafe { ::std::ptr::addr_of!((*ptr).vui_num_units_in_tick) as usize - ptr as usize },
3807 28usize,
3808 concat!(
3809 "Offset of field: ",
3810 stringify!(StdVideoH265SequenceParameterSetVui),
3811 "::",
3812 stringify!(vui_num_units_in_tick)
3813 )
3814 );
3815 assert_eq!(
3816 unsafe { ::std::ptr::addr_of!((*ptr).vui_time_scale) as usize - ptr as usize },
3817 32usize,
3818 concat!(
3819 "Offset of field: ",
3820 stringify!(StdVideoH265SequenceParameterSetVui),
3821 "::",
3822 stringify!(vui_time_scale)
3823 )
3824 );
3825 assert_eq!(
3826 unsafe {
3827 ::std::ptr::addr_of!((*ptr).vui_num_ticks_poc_diff_one_minus1) as usize - ptr as usize
3828 },
3829 36usize,
3830 concat!(
3831 "Offset of field: ",
3832 stringify!(StdVideoH265SequenceParameterSetVui),
3833 "::",
3834 stringify!(vui_num_ticks_poc_diff_one_minus1)
3835 )
3836 );
3837 assert_eq!(
3838 unsafe {
3839 ::std::ptr::addr_of!((*ptr).min_spatial_segmentation_idc) as usize - ptr as usize
3840 },
3841 40usize,
3842 concat!(
3843 "Offset of field: ",
3844 stringify!(StdVideoH265SequenceParameterSetVui),
3845 "::",
3846 stringify!(min_spatial_segmentation_idc)
3847 )
3848 );
3849 assert_eq!(
3850 unsafe { ::std::ptr::addr_of!((*ptr).reserved3) as usize - ptr as usize },
3851 42usize,
3852 concat!(
3853 "Offset of field: ",
3854 stringify!(StdVideoH265SequenceParameterSetVui),
3855 "::",
3856 stringify!(reserved3)
3857 )
3858 );
3859 assert_eq!(
3860 unsafe { ::std::ptr::addr_of!((*ptr).max_bytes_per_pic_denom) as usize - ptr as usize },
3861 44usize,
3862 concat!(
3863 "Offset of field: ",
3864 stringify!(StdVideoH265SequenceParameterSetVui),
3865 "::",
3866 stringify!(max_bytes_per_pic_denom)
3867 )
3868 );
3869 assert_eq!(
3870 unsafe { ::std::ptr::addr_of!((*ptr).max_bits_per_min_cu_denom) as usize - ptr as usize },
3871 45usize,
3872 concat!(
3873 "Offset of field: ",
3874 stringify!(StdVideoH265SequenceParameterSetVui),
3875 "::",
3876 stringify!(max_bits_per_min_cu_denom)
3877 )
3878 );
3879 assert_eq!(
3880 unsafe {
3881 ::std::ptr::addr_of!((*ptr).log2_max_mv_length_horizontal) as usize - ptr as usize
3882 },
3883 46usize,
3884 concat!(
3885 "Offset of field: ",
3886 stringify!(StdVideoH265SequenceParameterSetVui),
3887 "::",
3888 stringify!(log2_max_mv_length_horizontal)
3889 )
3890 );
3891 assert_eq!(
3892 unsafe { ::std::ptr::addr_of!((*ptr).log2_max_mv_length_vertical) as usize - ptr as usize },
3893 47usize,
3894 concat!(
3895 "Offset of field: ",
3896 stringify!(StdVideoH265SequenceParameterSetVui),
3897 "::",
3898 stringify!(log2_max_mv_length_vertical)
3899 )
3900 );
3901 assert_eq!(
3902 unsafe { ::std::ptr::addr_of!((*ptr).pHrdParameters) as usize - ptr as usize },
3903 48usize,
3904 concat!(
3905 "Offset of field: ",
3906 stringify!(StdVideoH265SequenceParameterSetVui),
3907 "::",
3908 stringify!(pHrdParameters)
3909 )
3910 );
3911}
3912#[repr(C)]
3913#[derive(Debug, Copy, Clone)]
3914pub struct StdVideoH265PredictorPaletteEntries {
3915 pub PredictorPaletteEntries: [[u16; 128usize]; 3usize],
3916}
3917#[test]
3918fn bindgen_test_layout_StdVideoH265PredictorPaletteEntries() {
3919 const UNINIT: ::std::mem::MaybeUninit<StdVideoH265PredictorPaletteEntries> =
3920 ::std::mem::MaybeUninit::uninit();
3921 let ptr = UNINIT.as_ptr();
3922 assert_eq!(
3923 ::std::mem::size_of::<StdVideoH265PredictorPaletteEntries>(),
3924 768usize,
3925 concat!("Size of: ", stringify!(StdVideoH265PredictorPaletteEntries))
3926 );
3927 assert_eq!(
3928 ::std::mem::align_of::<StdVideoH265PredictorPaletteEntries>(),
3929 2usize,
3930 concat!(
3931 "Alignment of ",
3932 stringify!(StdVideoH265PredictorPaletteEntries)
3933 )
3934 );
3935 assert_eq!(
3936 unsafe { ::std::ptr::addr_of!((*ptr).PredictorPaletteEntries) as usize - ptr as usize },
3937 0usize,
3938 concat!(
3939 "Offset of field: ",
3940 stringify!(StdVideoH265PredictorPaletteEntries),
3941 "::",
3942 stringify!(PredictorPaletteEntries)
3943 )
3944 );
3945}
3946#[repr(C)]
3947#[repr(align(4))]
3948#[derive(Debug, Copy, Clone)]
3949pub struct StdVideoH265SpsFlags {
3950 pub _bitfield_align_1: [u8; 0],
3951 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
3952}
3953#[test]
3954fn bindgen_test_layout_StdVideoH265SpsFlags() {
3955 assert_eq!(
3956 ::std::mem::size_of::<StdVideoH265SpsFlags>(),
3957 4usize,
3958 concat!("Size of: ", stringify!(StdVideoH265SpsFlags))
3959 );
3960 assert_eq!(
3961 ::std::mem::align_of::<StdVideoH265SpsFlags>(),
3962 4usize,
3963 concat!("Alignment of ", stringify!(StdVideoH265SpsFlags))
3964 );
3965}
3966impl StdVideoH265SpsFlags {
3967 #[inline]
3968 pub fn sps_temporal_id_nesting_flag(&self) -> u32 {
3969 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
3970 }
3971 #[inline]
3972 pub fn set_sps_temporal_id_nesting_flag(&mut self, val: u32) {
3973 unsafe {
3974 let val: u32 = ::std::mem::transmute(val);
3975 self._bitfield_1.set(0usize, 1u8, val as u64)
3976 }
3977 }
3978 #[inline]
3979 pub fn separate_colour_plane_flag(&self) -> u32 {
3980 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
3981 }
3982 #[inline]
3983 pub fn set_separate_colour_plane_flag(&mut self, val: u32) {
3984 unsafe {
3985 let val: u32 = ::std::mem::transmute(val);
3986 self._bitfield_1.set(1usize, 1u8, val as u64)
3987 }
3988 }
3989 #[inline]
3990 pub fn conformance_window_flag(&self) -> u32 {
3991 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
3992 }
3993 #[inline]
3994 pub fn set_conformance_window_flag(&mut self, val: u32) {
3995 unsafe {
3996 let val: u32 = ::std::mem::transmute(val);
3997 self._bitfield_1.set(2usize, 1u8, val as u64)
3998 }
3999 }
4000 #[inline]
4001 pub fn sps_sub_layer_ordering_info_present_flag(&self) -> u32 {
4002 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
4003 }
4004 #[inline]
4005 pub fn set_sps_sub_layer_ordering_info_present_flag(&mut self, val: u32) {
4006 unsafe {
4007 let val: u32 = ::std::mem::transmute(val);
4008 self._bitfield_1.set(3usize, 1u8, val as u64)
4009 }
4010 }
4011 #[inline]
4012 pub fn scaling_list_enabled_flag(&self) -> u32 {
4013 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
4014 }
4015 #[inline]
4016 pub fn set_scaling_list_enabled_flag(&mut self, val: u32) {
4017 unsafe {
4018 let val: u32 = ::std::mem::transmute(val);
4019 self._bitfield_1.set(4usize, 1u8, val as u64)
4020 }
4021 }
4022 #[inline]
4023 pub fn sps_scaling_list_data_present_flag(&self) -> u32 {
4024 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
4025 }
4026 #[inline]
4027 pub fn set_sps_scaling_list_data_present_flag(&mut self, val: u32) {
4028 unsafe {
4029 let val: u32 = ::std::mem::transmute(val);
4030 self._bitfield_1.set(5usize, 1u8, val as u64)
4031 }
4032 }
4033 #[inline]
4034 pub fn amp_enabled_flag(&self) -> u32 {
4035 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) }
4036 }
4037 #[inline]
4038 pub fn set_amp_enabled_flag(&mut self, val: u32) {
4039 unsafe {
4040 let val: u32 = ::std::mem::transmute(val);
4041 self._bitfield_1.set(6usize, 1u8, val as u64)
4042 }
4043 }
4044 #[inline]
4045 pub fn sample_adaptive_offset_enabled_flag(&self) -> u32 {
4046 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) }
4047 }
4048 #[inline]
4049 pub fn set_sample_adaptive_offset_enabled_flag(&mut self, val: u32) {
4050 unsafe {
4051 let val: u32 = ::std::mem::transmute(val);
4052 self._bitfield_1.set(7usize, 1u8, val as u64)
4053 }
4054 }
4055 #[inline]
4056 pub fn pcm_enabled_flag(&self) -> u32 {
4057 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) }
4058 }
4059 #[inline]
4060 pub fn set_pcm_enabled_flag(&mut self, val: u32) {
4061 unsafe {
4062 let val: u32 = ::std::mem::transmute(val);
4063 self._bitfield_1.set(8usize, 1u8, val as u64)
4064 }
4065 }
4066 #[inline]
4067 pub fn pcm_loop_filter_disabled_flag(&self) -> u32 {
4068 unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) }
4069 }
4070 #[inline]
4071 pub fn set_pcm_loop_filter_disabled_flag(&mut self, val: u32) {
4072 unsafe {
4073 let val: u32 = ::std::mem::transmute(val);
4074 self._bitfield_1.set(9usize, 1u8, val as u64)
4075 }
4076 }
4077 #[inline]
4078 pub fn long_term_ref_pics_present_flag(&self) -> u32 {
4079 unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) }
4080 }
4081 #[inline]
4082 pub fn set_long_term_ref_pics_present_flag(&mut self, val: u32) {
4083 unsafe {
4084 let val: u32 = ::std::mem::transmute(val);
4085 self._bitfield_1.set(10usize, 1u8, val as u64)
4086 }
4087 }
4088 #[inline]
4089 pub fn sps_temporal_mvp_enabled_flag(&self) -> u32 {
4090 unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) }
4091 }
4092 #[inline]
4093 pub fn set_sps_temporal_mvp_enabled_flag(&mut self, val: u32) {
4094 unsafe {
4095 let val: u32 = ::std::mem::transmute(val);
4096 self._bitfield_1.set(11usize, 1u8, val as u64)
4097 }
4098 }
4099 #[inline]
4100 pub fn strong_intra_smoothing_enabled_flag(&self) -> u32 {
4101 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u32) }
4102 }
4103 #[inline]
4104 pub fn set_strong_intra_smoothing_enabled_flag(&mut self, val: u32) {
4105 unsafe {
4106 let val: u32 = ::std::mem::transmute(val);
4107 self._bitfield_1.set(12usize, 1u8, val as u64)
4108 }
4109 }
4110 #[inline]
4111 pub fn vui_parameters_present_flag(&self) -> u32 {
4112 unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) }
4113 }
4114 #[inline]
4115 pub fn set_vui_parameters_present_flag(&mut self, val: u32) {
4116 unsafe {
4117 let val: u32 = ::std::mem::transmute(val);
4118 self._bitfield_1.set(13usize, 1u8, val as u64)
4119 }
4120 }
4121 #[inline]
4122 pub fn sps_extension_present_flag(&self) -> u32 {
4123 unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) }
4124 }
4125 #[inline]
4126 pub fn set_sps_extension_present_flag(&mut self, val: u32) {
4127 unsafe {
4128 let val: u32 = ::std::mem::transmute(val);
4129 self._bitfield_1.set(14usize, 1u8, val as u64)
4130 }
4131 }
4132 #[inline]
4133 pub fn sps_range_extension_flag(&self) -> u32 {
4134 unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u32) }
4135 }
4136 #[inline]
4137 pub fn set_sps_range_extension_flag(&mut self, val: u32) {
4138 unsafe {
4139 let val: u32 = ::std::mem::transmute(val);
4140 self._bitfield_1.set(15usize, 1u8, val as u64)
4141 }
4142 }
4143 #[inline]
4144 pub fn transform_skip_rotation_enabled_flag(&self) -> u32 {
4145 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u32) }
4146 }
4147 #[inline]
4148 pub fn set_transform_skip_rotation_enabled_flag(&mut self, val: u32) {
4149 unsafe {
4150 let val: u32 = ::std::mem::transmute(val);
4151 self._bitfield_1.set(16usize, 1u8, val as u64)
4152 }
4153 }
4154 #[inline]
4155 pub fn transform_skip_context_enabled_flag(&self) -> u32 {
4156 unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 1u8) as u32) }
4157 }
4158 #[inline]
4159 pub fn set_transform_skip_context_enabled_flag(&mut self, val: u32) {
4160 unsafe {
4161 let val: u32 = ::std::mem::transmute(val);
4162 self._bitfield_1.set(17usize, 1u8, val as u64)
4163 }
4164 }
4165 #[inline]
4166 pub fn implicit_rdpcm_enabled_flag(&self) -> u32 {
4167 unsafe { ::std::mem::transmute(self._bitfield_1.get(18usize, 1u8) as u32) }
4168 }
4169 #[inline]
4170 pub fn set_implicit_rdpcm_enabled_flag(&mut self, val: u32) {
4171 unsafe {
4172 let val: u32 = ::std::mem::transmute(val);
4173 self._bitfield_1.set(18usize, 1u8, val as u64)
4174 }
4175 }
4176 #[inline]
4177 pub fn explicit_rdpcm_enabled_flag(&self) -> u32 {
4178 unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 1u8) as u32) }
4179 }
4180 #[inline]
4181 pub fn set_explicit_rdpcm_enabled_flag(&mut self, val: u32) {
4182 unsafe {
4183 let val: u32 = ::std::mem::transmute(val);
4184 self._bitfield_1.set(19usize, 1u8, val as u64)
4185 }
4186 }
4187 #[inline]
4188 pub fn extended_precision_processing_flag(&self) -> u32 {
4189 unsafe { ::std::mem::transmute(self._bitfield_1.get(20usize, 1u8) as u32) }
4190 }
4191 #[inline]
4192 pub fn set_extended_precision_processing_flag(&mut self, val: u32) {
4193 unsafe {
4194 let val: u32 = ::std::mem::transmute(val);
4195 self._bitfield_1.set(20usize, 1u8, val as u64)
4196 }
4197 }
4198 #[inline]
4199 pub fn intra_smoothing_disabled_flag(&self) -> u32 {
4200 unsafe { ::std::mem::transmute(self._bitfield_1.get(21usize, 1u8) as u32) }
4201 }
4202 #[inline]
4203 pub fn set_intra_smoothing_disabled_flag(&mut self, val: u32) {
4204 unsafe {
4205 let val: u32 = ::std::mem::transmute(val);
4206 self._bitfield_1.set(21usize, 1u8, val as u64)
4207 }
4208 }
4209 #[inline]
4210 pub fn high_precision_offsets_enabled_flag(&self) -> u32 {
4211 unsafe { ::std::mem::transmute(self._bitfield_1.get(22usize, 1u8) as u32) }
4212 }
4213 #[inline]
4214 pub fn set_high_precision_offsets_enabled_flag(&mut self, val: u32) {
4215 unsafe {
4216 let val: u32 = ::std::mem::transmute(val);
4217 self._bitfield_1.set(22usize, 1u8, val as u64)
4218 }
4219 }
4220 #[inline]
4221 pub fn persistent_rice_adaptation_enabled_flag(&self) -> u32 {
4222 unsafe { ::std::mem::transmute(self._bitfield_1.get(23usize, 1u8) as u32) }
4223 }
4224 #[inline]
4225 pub fn set_persistent_rice_adaptation_enabled_flag(&mut self, val: u32) {
4226 unsafe {
4227 let val: u32 = ::std::mem::transmute(val);
4228 self._bitfield_1.set(23usize, 1u8, val as u64)
4229 }
4230 }
4231 #[inline]
4232 pub fn cabac_bypass_alignment_enabled_flag(&self) -> u32 {
4233 unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 1u8) as u32) }
4234 }
4235 #[inline]
4236 pub fn set_cabac_bypass_alignment_enabled_flag(&mut self, val: u32) {
4237 unsafe {
4238 let val: u32 = ::std::mem::transmute(val);
4239 self._bitfield_1.set(24usize, 1u8, val as u64)
4240 }
4241 }
4242 #[inline]
4243 pub fn sps_scc_extension_flag(&self) -> u32 {
4244 unsafe { ::std::mem::transmute(self._bitfield_1.get(25usize, 1u8) as u32) }
4245 }
4246 #[inline]
4247 pub fn set_sps_scc_extension_flag(&mut self, val: u32) {
4248 unsafe {
4249 let val: u32 = ::std::mem::transmute(val);
4250 self._bitfield_1.set(25usize, 1u8, val as u64)
4251 }
4252 }
4253 #[inline]
4254 pub fn sps_curr_pic_ref_enabled_flag(&self) -> u32 {
4255 unsafe { ::std::mem::transmute(self._bitfield_1.get(26usize, 1u8) as u32) }
4256 }
4257 #[inline]
4258 pub fn set_sps_curr_pic_ref_enabled_flag(&mut self, val: u32) {
4259 unsafe {
4260 let val: u32 = ::std::mem::transmute(val);
4261 self._bitfield_1.set(26usize, 1u8, val as u64)
4262 }
4263 }
4264 #[inline]
4265 pub fn palette_mode_enabled_flag(&self) -> u32 {
4266 unsafe { ::std::mem::transmute(self._bitfield_1.get(27usize, 1u8) as u32) }
4267 }
4268 #[inline]
4269 pub fn set_palette_mode_enabled_flag(&mut self, val: u32) {
4270 unsafe {
4271 let val: u32 = ::std::mem::transmute(val);
4272 self._bitfield_1.set(27usize, 1u8, val as u64)
4273 }
4274 }
4275 #[inline]
4276 pub fn sps_palette_predictor_initializers_present_flag(&self) -> u32 {
4277 unsafe { ::std::mem::transmute(self._bitfield_1.get(28usize, 1u8) as u32) }
4278 }
4279 #[inline]
4280 pub fn set_sps_palette_predictor_initializers_present_flag(&mut self, val: u32) {
4281 unsafe {
4282 let val: u32 = ::std::mem::transmute(val);
4283 self._bitfield_1.set(28usize, 1u8, val as u64)
4284 }
4285 }
4286 #[inline]
4287 pub fn intra_boundary_filtering_disabled_flag(&self) -> u32 {
4288 unsafe { ::std::mem::transmute(self._bitfield_1.get(29usize, 1u8) as u32) }
4289 }
4290 #[inline]
4291 pub fn set_intra_boundary_filtering_disabled_flag(&mut self, val: u32) {
4292 unsafe {
4293 let val: u32 = ::std::mem::transmute(val);
4294 self._bitfield_1.set(29usize, 1u8, val as u64)
4295 }
4296 }
4297 #[inline]
4298 pub fn new_bitfield_1(
4299 sps_temporal_id_nesting_flag: u32,
4300 separate_colour_plane_flag: u32,
4301 conformance_window_flag: u32,
4302 sps_sub_layer_ordering_info_present_flag: u32,
4303 scaling_list_enabled_flag: u32,
4304 sps_scaling_list_data_present_flag: u32,
4305 amp_enabled_flag: u32,
4306 sample_adaptive_offset_enabled_flag: u32,
4307 pcm_enabled_flag: u32,
4308 pcm_loop_filter_disabled_flag: u32,
4309 long_term_ref_pics_present_flag: u32,
4310 sps_temporal_mvp_enabled_flag: u32,
4311 strong_intra_smoothing_enabled_flag: u32,
4312 vui_parameters_present_flag: u32,
4313 sps_extension_present_flag: u32,
4314 sps_range_extension_flag: u32,
4315 transform_skip_rotation_enabled_flag: u32,
4316 transform_skip_context_enabled_flag: u32,
4317 implicit_rdpcm_enabled_flag: u32,
4318 explicit_rdpcm_enabled_flag: u32,
4319 extended_precision_processing_flag: u32,
4320 intra_smoothing_disabled_flag: u32,
4321 high_precision_offsets_enabled_flag: u32,
4322 persistent_rice_adaptation_enabled_flag: u32,
4323 cabac_bypass_alignment_enabled_flag: u32,
4324 sps_scc_extension_flag: u32,
4325 sps_curr_pic_ref_enabled_flag: u32,
4326 palette_mode_enabled_flag: u32,
4327 sps_palette_predictor_initializers_present_flag: u32,
4328 intra_boundary_filtering_disabled_flag: u32,
4329 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
4330 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
4331 __bindgen_bitfield_unit.set(0usize, 1u8, {
4332 let sps_temporal_id_nesting_flag: u32 =
4333 unsafe { ::std::mem::transmute(sps_temporal_id_nesting_flag) };
4334 sps_temporal_id_nesting_flag as u64
4335 });
4336 __bindgen_bitfield_unit.set(1usize, 1u8, {
4337 let separate_colour_plane_flag: u32 =
4338 unsafe { ::std::mem::transmute(separate_colour_plane_flag) };
4339 separate_colour_plane_flag as u64
4340 });
4341 __bindgen_bitfield_unit.set(2usize, 1u8, {
4342 let conformance_window_flag: u32 =
4343 unsafe { ::std::mem::transmute(conformance_window_flag) };
4344 conformance_window_flag as u64
4345 });
4346 __bindgen_bitfield_unit.set(3usize, 1u8, {
4347 let sps_sub_layer_ordering_info_present_flag: u32 =
4348 unsafe { ::std::mem::transmute(sps_sub_layer_ordering_info_present_flag) };
4349 sps_sub_layer_ordering_info_present_flag as u64
4350 });
4351 __bindgen_bitfield_unit.set(4usize, 1u8, {
4352 let scaling_list_enabled_flag: u32 =
4353 unsafe { ::std::mem::transmute(scaling_list_enabled_flag) };
4354 scaling_list_enabled_flag as u64
4355 });
4356 __bindgen_bitfield_unit.set(5usize, 1u8, {
4357 let sps_scaling_list_data_present_flag: u32 =
4358 unsafe { ::std::mem::transmute(sps_scaling_list_data_present_flag) };
4359 sps_scaling_list_data_present_flag as u64
4360 });
4361 __bindgen_bitfield_unit.set(6usize, 1u8, {
4362 let amp_enabled_flag: u32 = unsafe { ::std::mem::transmute(amp_enabled_flag) };
4363 amp_enabled_flag as u64
4364 });
4365 __bindgen_bitfield_unit.set(7usize, 1u8, {
4366 let sample_adaptive_offset_enabled_flag: u32 =
4367 unsafe { ::std::mem::transmute(sample_adaptive_offset_enabled_flag) };
4368 sample_adaptive_offset_enabled_flag as u64
4369 });
4370 __bindgen_bitfield_unit.set(8usize, 1u8, {
4371 let pcm_enabled_flag: u32 = unsafe { ::std::mem::transmute(pcm_enabled_flag) };
4372 pcm_enabled_flag as u64
4373 });
4374 __bindgen_bitfield_unit.set(9usize, 1u8, {
4375 let pcm_loop_filter_disabled_flag: u32 =
4376 unsafe { ::std::mem::transmute(pcm_loop_filter_disabled_flag) };
4377 pcm_loop_filter_disabled_flag as u64
4378 });
4379 __bindgen_bitfield_unit.set(10usize, 1u8, {
4380 let long_term_ref_pics_present_flag: u32 =
4381 unsafe { ::std::mem::transmute(long_term_ref_pics_present_flag) };
4382 long_term_ref_pics_present_flag as u64
4383 });
4384 __bindgen_bitfield_unit.set(11usize, 1u8, {
4385 let sps_temporal_mvp_enabled_flag: u32 =
4386 unsafe { ::std::mem::transmute(sps_temporal_mvp_enabled_flag) };
4387 sps_temporal_mvp_enabled_flag as u64
4388 });
4389 __bindgen_bitfield_unit.set(12usize, 1u8, {
4390 let strong_intra_smoothing_enabled_flag: u32 =
4391 unsafe { ::std::mem::transmute(strong_intra_smoothing_enabled_flag) };
4392 strong_intra_smoothing_enabled_flag as u64
4393 });
4394 __bindgen_bitfield_unit.set(13usize, 1u8, {
4395 let vui_parameters_present_flag: u32 =
4396 unsafe { ::std::mem::transmute(vui_parameters_present_flag) };
4397 vui_parameters_present_flag as u64
4398 });
4399 __bindgen_bitfield_unit.set(14usize, 1u8, {
4400 let sps_extension_present_flag: u32 =
4401 unsafe { ::std::mem::transmute(sps_extension_present_flag) };
4402 sps_extension_present_flag as u64
4403 });
4404 __bindgen_bitfield_unit.set(15usize, 1u8, {
4405 let sps_range_extension_flag: u32 =
4406 unsafe { ::std::mem::transmute(sps_range_extension_flag) };
4407 sps_range_extension_flag as u64
4408 });
4409 __bindgen_bitfield_unit.set(16usize, 1u8, {
4410 let transform_skip_rotation_enabled_flag: u32 =
4411 unsafe { ::std::mem::transmute(transform_skip_rotation_enabled_flag) };
4412 transform_skip_rotation_enabled_flag as u64
4413 });
4414 __bindgen_bitfield_unit.set(17usize, 1u8, {
4415 let transform_skip_context_enabled_flag: u32 =
4416 unsafe { ::std::mem::transmute(transform_skip_context_enabled_flag) };
4417 transform_skip_context_enabled_flag as u64
4418 });
4419 __bindgen_bitfield_unit.set(18usize, 1u8, {
4420 let implicit_rdpcm_enabled_flag: u32 =
4421 unsafe { ::std::mem::transmute(implicit_rdpcm_enabled_flag) };
4422 implicit_rdpcm_enabled_flag as u64
4423 });
4424 __bindgen_bitfield_unit.set(19usize, 1u8, {
4425 let explicit_rdpcm_enabled_flag: u32 =
4426 unsafe { ::std::mem::transmute(explicit_rdpcm_enabled_flag) };
4427 explicit_rdpcm_enabled_flag as u64
4428 });
4429 __bindgen_bitfield_unit.set(20usize, 1u8, {
4430 let extended_precision_processing_flag: u32 =
4431 unsafe { ::std::mem::transmute(extended_precision_processing_flag) };
4432 extended_precision_processing_flag as u64
4433 });
4434 __bindgen_bitfield_unit.set(21usize, 1u8, {
4435 let intra_smoothing_disabled_flag: u32 =
4436 unsafe { ::std::mem::transmute(intra_smoothing_disabled_flag) };
4437 intra_smoothing_disabled_flag as u64
4438 });
4439 __bindgen_bitfield_unit.set(22usize, 1u8, {
4440 let high_precision_offsets_enabled_flag: u32 =
4441 unsafe { ::std::mem::transmute(high_precision_offsets_enabled_flag) };
4442 high_precision_offsets_enabled_flag as u64
4443 });
4444 __bindgen_bitfield_unit.set(23usize, 1u8, {
4445 let persistent_rice_adaptation_enabled_flag: u32 =
4446 unsafe { ::std::mem::transmute(persistent_rice_adaptation_enabled_flag) };
4447 persistent_rice_adaptation_enabled_flag as u64
4448 });
4449 __bindgen_bitfield_unit.set(24usize, 1u8, {
4450 let cabac_bypass_alignment_enabled_flag: u32 =
4451 unsafe { ::std::mem::transmute(cabac_bypass_alignment_enabled_flag) };
4452 cabac_bypass_alignment_enabled_flag as u64
4453 });
4454 __bindgen_bitfield_unit.set(25usize, 1u8, {
4455 let sps_scc_extension_flag: u32 =
4456 unsafe { ::std::mem::transmute(sps_scc_extension_flag) };
4457 sps_scc_extension_flag as u64
4458 });
4459 __bindgen_bitfield_unit.set(26usize, 1u8, {
4460 let sps_curr_pic_ref_enabled_flag: u32 =
4461 unsafe { ::std::mem::transmute(sps_curr_pic_ref_enabled_flag) };
4462 sps_curr_pic_ref_enabled_flag as u64
4463 });
4464 __bindgen_bitfield_unit.set(27usize, 1u8, {
4465 let palette_mode_enabled_flag: u32 =
4466 unsafe { ::std::mem::transmute(palette_mode_enabled_flag) };
4467 palette_mode_enabled_flag as u64
4468 });
4469 __bindgen_bitfield_unit.set(28usize, 1u8, {
4470 let sps_palette_predictor_initializers_present_flag: u32 =
4471 unsafe { ::std::mem::transmute(sps_palette_predictor_initializers_present_flag) };
4472 sps_palette_predictor_initializers_present_flag as u64
4473 });
4474 __bindgen_bitfield_unit.set(29usize, 1u8, {
4475 let intra_boundary_filtering_disabled_flag: u32 =
4476 unsafe { ::std::mem::transmute(intra_boundary_filtering_disabled_flag) };
4477 intra_boundary_filtering_disabled_flag as u64
4478 });
4479 __bindgen_bitfield_unit
4480 }
4481}
4482#[repr(C)]
4483#[repr(align(4))]
4484#[derive(Debug, Copy, Clone)]
4485pub struct StdVideoH265ShortTermRefPicSetFlags {
4486 pub _bitfield_align_1: [u8; 0],
4487 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
4488 pub __bindgen_padding_0: [u8; 3usize],
4489}
4490#[test]
4491fn bindgen_test_layout_StdVideoH265ShortTermRefPicSetFlags() {
4492 assert_eq!(
4493 ::std::mem::size_of::<StdVideoH265ShortTermRefPicSetFlags>(),
4494 4usize,
4495 concat!("Size of: ", stringify!(StdVideoH265ShortTermRefPicSetFlags))
4496 );
4497 assert_eq!(
4498 ::std::mem::align_of::<StdVideoH265ShortTermRefPicSetFlags>(),
4499 4usize,
4500 concat!(
4501 "Alignment of ",
4502 stringify!(StdVideoH265ShortTermRefPicSetFlags)
4503 )
4504 );
4505}
4506impl StdVideoH265ShortTermRefPicSetFlags {
4507 #[inline]
4508 pub fn inter_ref_pic_set_prediction_flag(&self) -> u32 {
4509 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
4510 }
4511 #[inline]
4512 pub fn set_inter_ref_pic_set_prediction_flag(&mut self, val: u32) {
4513 unsafe {
4514 let val: u32 = ::std::mem::transmute(val);
4515 self._bitfield_1.set(0usize, 1u8, val as u64)
4516 }
4517 }
4518 #[inline]
4519 pub fn delta_rps_sign(&self) -> u32 {
4520 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
4521 }
4522 #[inline]
4523 pub fn set_delta_rps_sign(&mut self, val: u32) {
4524 unsafe {
4525 let val: u32 = ::std::mem::transmute(val);
4526 self._bitfield_1.set(1usize, 1u8, val as u64)
4527 }
4528 }
4529 #[inline]
4530 pub fn new_bitfield_1(
4531 inter_ref_pic_set_prediction_flag: u32,
4532 delta_rps_sign: u32,
4533 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
4534 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
4535 __bindgen_bitfield_unit.set(0usize, 1u8, {
4536 let inter_ref_pic_set_prediction_flag: u32 =
4537 unsafe { ::std::mem::transmute(inter_ref_pic_set_prediction_flag) };
4538 inter_ref_pic_set_prediction_flag as u64
4539 });
4540 __bindgen_bitfield_unit.set(1usize, 1u8, {
4541 let delta_rps_sign: u32 = unsafe { ::std::mem::transmute(delta_rps_sign) };
4542 delta_rps_sign as u64
4543 });
4544 __bindgen_bitfield_unit
4545 }
4546}
4547#[repr(C)]
4548#[derive(Debug, Copy, Clone)]
4549pub struct StdVideoH265ShortTermRefPicSet {
4550 pub flags: StdVideoH265ShortTermRefPicSetFlags,
4551 pub delta_idx_minus1: u32,
4552 pub use_delta_flag: u16,
4553 pub abs_delta_rps_minus1: u16,
4554 pub used_by_curr_pic_flag: u16,
4555 pub used_by_curr_pic_s0_flag: u16,
4556 pub used_by_curr_pic_s1_flag: u16,
4557 pub reserved1: u16,
4558 pub reserved2: u8,
4559 pub reserved3: u8,
4560 pub num_negative_pics: u8,
4561 pub num_positive_pics: u8,
4562 pub delta_poc_s0_minus1: [u16; 16usize],
4563 pub delta_poc_s1_minus1: [u16; 16usize],
4564}
4565#[test]
4566fn bindgen_test_layout_StdVideoH265ShortTermRefPicSet() {
4567 const UNINIT: ::std::mem::MaybeUninit<StdVideoH265ShortTermRefPicSet> =
4568 ::std::mem::MaybeUninit::uninit();
4569 let ptr = UNINIT.as_ptr();
4570 assert_eq!(
4571 ::std::mem::size_of::<StdVideoH265ShortTermRefPicSet>(),
4572 88usize,
4573 concat!("Size of: ", stringify!(StdVideoH265ShortTermRefPicSet))
4574 );
4575 assert_eq!(
4576 ::std::mem::align_of::<StdVideoH265ShortTermRefPicSet>(),
4577 4usize,
4578 concat!("Alignment of ", stringify!(StdVideoH265ShortTermRefPicSet))
4579 );
4580 assert_eq!(
4581 unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
4582 0usize,
4583 concat!(
4584 "Offset of field: ",
4585 stringify!(StdVideoH265ShortTermRefPicSet),
4586 "::",
4587 stringify!(flags)
4588 )
4589 );
4590 assert_eq!(
4591 unsafe { ::std::ptr::addr_of!((*ptr).delta_idx_minus1) as usize - ptr as usize },
4592 4usize,
4593 concat!(
4594 "Offset of field: ",
4595 stringify!(StdVideoH265ShortTermRefPicSet),
4596 "::",
4597 stringify!(delta_idx_minus1)
4598 )
4599 );
4600 assert_eq!(
4601 unsafe { ::std::ptr::addr_of!((*ptr).use_delta_flag) as usize - ptr as usize },
4602 8usize,
4603 concat!(
4604 "Offset of field: ",
4605 stringify!(StdVideoH265ShortTermRefPicSet),
4606 "::",
4607 stringify!(use_delta_flag)
4608 )
4609 );
4610 assert_eq!(
4611 unsafe { ::std::ptr::addr_of!((*ptr).abs_delta_rps_minus1) as usize - ptr as usize },
4612 10usize,
4613 concat!(
4614 "Offset of field: ",
4615 stringify!(StdVideoH265ShortTermRefPicSet),
4616 "::",
4617 stringify!(abs_delta_rps_minus1)
4618 )
4619 );
4620 assert_eq!(
4621 unsafe { ::std::ptr::addr_of!((*ptr).used_by_curr_pic_flag) as usize - ptr as usize },
4622 12usize,
4623 concat!(
4624 "Offset of field: ",
4625 stringify!(StdVideoH265ShortTermRefPicSet),
4626 "::",
4627 stringify!(used_by_curr_pic_flag)
4628 )
4629 );
4630 assert_eq!(
4631 unsafe { ::std::ptr::addr_of!((*ptr).used_by_curr_pic_s0_flag) as usize - ptr as usize },
4632 14usize,
4633 concat!(
4634 "Offset of field: ",
4635 stringify!(StdVideoH265ShortTermRefPicSet),
4636 "::",
4637 stringify!(used_by_curr_pic_s0_flag)
4638 )
4639 );
4640 assert_eq!(
4641 unsafe { ::std::ptr::addr_of!((*ptr).used_by_curr_pic_s1_flag) as usize - ptr as usize },
4642 16usize,
4643 concat!(
4644 "Offset of field: ",
4645 stringify!(StdVideoH265ShortTermRefPicSet),
4646 "::",
4647 stringify!(used_by_curr_pic_s1_flag)
4648 )
4649 );
4650 assert_eq!(
4651 unsafe { ::std::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize },
4652 18usize,
4653 concat!(
4654 "Offset of field: ",
4655 stringify!(StdVideoH265ShortTermRefPicSet),
4656 "::",
4657 stringify!(reserved1)
4658 )
4659 );
4660 assert_eq!(
4661 unsafe { ::std::ptr::addr_of!((*ptr).reserved2) as usize - ptr as usize },
4662 20usize,
4663 concat!(
4664 "Offset of field: ",
4665 stringify!(StdVideoH265ShortTermRefPicSet),
4666 "::",
4667 stringify!(reserved2)
4668 )
4669 );
4670 assert_eq!(
4671 unsafe { ::std::ptr::addr_of!((*ptr).reserved3) as usize - ptr as usize },
4672 21usize,
4673 concat!(
4674 "Offset of field: ",
4675 stringify!(StdVideoH265ShortTermRefPicSet),
4676 "::",
4677 stringify!(reserved3)
4678 )
4679 );
4680 assert_eq!(
4681 unsafe { ::std::ptr::addr_of!((*ptr).num_negative_pics) as usize - ptr as usize },
4682 22usize,
4683 concat!(
4684 "Offset of field: ",
4685 stringify!(StdVideoH265ShortTermRefPicSet),
4686 "::",
4687 stringify!(num_negative_pics)
4688 )
4689 );
4690 assert_eq!(
4691 unsafe { ::std::ptr::addr_of!((*ptr).num_positive_pics) as usize - ptr as usize },
4692 23usize,
4693 concat!(
4694 "Offset of field: ",
4695 stringify!(StdVideoH265ShortTermRefPicSet),
4696 "::",
4697 stringify!(num_positive_pics)
4698 )
4699 );
4700 assert_eq!(
4701 unsafe { ::std::ptr::addr_of!((*ptr).delta_poc_s0_minus1) as usize - ptr as usize },
4702 24usize,
4703 concat!(
4704 "Offset of field: ",
4705 stringify!(StdVideoH265ShortTermRefPicSet),
4706 "::",
4707 stringify!(delta_poc_s0_minus1)
4708 )
4709 );
4710 assert_eq!(
4711 unsafe { ::std::ptr::addr_of!((*ptr).delta_poc_s1_minus1) as usize - ptr as usize },
4712 56usize,
4713 concat!(
4714 "Offset of field: ",
4715 stringify!(StdVideoH265ShortTermRefPicSet),
4716 "::",
4717 stringify!(delta_poc_s1_minus1)
4718 )
4719 );
4720}
4721#[repr(C)]
4722#[derive(Debug, Copy, Clone)]
4723pub struct StdVideoH265LongTermRefPicsSps {
4724 pub used_by_curr_pic_lt_sps_flag: u32,
4725 pub lt_ref_pic_poc_lsb_sps: [u32; 32usize],
4726}
4727#[test]
4728fn bindgen_test_layout_StdVideoH265LongTermRefPicsSps() {
4729 const UNINIT: ::std::mem::MaybeUninit<StdVideoH265LongTermRefPicsSps> =
4730 ::std::mem::MaybeUninit::uninit();
4731 let ptr = UNINIT.as_ptr();
4732 assert_eq!(
4733 ::std::mem::size_of::<StdVideoH265LongTermRefPicsSps>(),
4734 132usize,
4735 concat!("Size of: ", stringify!(StdVideoH265LongTermRefPicsSps))
4736 );
4737 assert_eq!(
4738 ::std::mem::align_of::<StdVideoH265LongTermRefPicsSps>(),
4739 4usize,
4740 concat!("Alignment of ", stringify!(StdVideoH265LongTermRefPicsSps))
4741 );
4742 assert_eq!(
4743 unsafe {
4744 ::std::ptr::addr_of!((*ptr).used_by_curr_pic_lt_sps_flag) as usize - ptr as usize
4745 },
4746 0usize,
4747 concat!(
4748 "Offset of field: ",
4749 stringify!(StdVideoH265LongTermRefPicsSps),
4750 "::",
4751 stringify!(used_by_curr_pic_lt_sps_flag)
4752 )
4753 );
4754 assert_eq!(
4755 unsafe { ::std::ptr::addr_of!((*ptr).lt_ref_pic_poc_lsb_sps) as usize - ptr as usize },
4756 4usize,
4757 concat!(
4758 "Offset of field: ",
4759 stringify!(StdVideoH265LongTermRefPicsSps),
4760 "::",
4761 stringify!(lt_ref_pic_poc_lsb_sps)
4762 )
4763 );
4764}
4765#[repr(C)]
4766#[derive(Debug, Copy, Clone)]
4767pub struct StdVideoH265SequenceParameterSet {
4768 pub flags: StdVideoH265SpsFlags,
4769 pub chroma_format_idc: StdVideoH265ChromaFormatIdc,
4770 pub pic_width_in_luma_samples: u32,
4771 pub pic_height_in_luma_samples: u32,
4772 pub sps_video_parameter_set_id: u8,
4773 pub sps_max_sub_layers_minus1: u8,
4774 pub sps_seq_parameter_set_id: u8,
4775 pub bit_depth_luma_minus8: u8,
4776 pub bit_depth_chroma_minus8: u8,
4777 pub log2_max_pic_order_cnt_lsb_minus4: u8,
4778 pub log2_min_luma_coding_block_size_minus3: u8,
4779 pub log2_diff_max_min_luma_coding_block_size: u8,
4780 pub log2_min_luma_transform_block_size_minus2: u8,
4781 pub log2_diff_max_min_luma_transform_block_size: u8,
4782 pub max_transform_hierarchy_depth_inter: u8,
4783 pub max_transform_hierarchy_depth_intra: u8,
4784 pub num_short_term_ref_pic_sets: u8,
4785 pub num_long_term_ref_pics_sps: u8,
4786 pub pcm_sample_bit_depth_luma_minus1: u8,
4787 pub pcm_sample_bit_depth_chroma_minus1: u8,
4788 pub log2_min_pcm_luma_coding_block_size_minus3: u8,
4789 pub log2_diff_max_min_pcm_luma_coding_block_size: u8,
4790 pub reserved1: u8,
4791 pub reserved2: u8,
4792 pub palette_max_size: u8,
4793 pub delta_palette_max_predictor_size: u8,
4794 pub motion_vector_resolution_control_idc: u8,
4795 pub sps_num_palette_predictor_initializers_minus1: u8,
4796 pub conf_win_left_offset: u32,
4797 pub conf_win_right_offset: u32,
4798 pub conf_win_top_offset: u32,
4799 pub conf_win_bottom_offset: u32,
4800 pub pProfileTierLevel: *const StdVideoH265ProfileTierLevel,
4801 pub pDecPicBufMgr: *const StdVideoH265DecPicBufMgr,
4802 pub pScalingLists: *const StdVideoH265ScalingLists,
4803 pub pShortTermRefPicSet: *const StdVideoH265ShortTermRefPicSet,
4804 pub pLongTermRefPicsSps: *const StdVideoH265LongTermRefPicsSps,
4805 pub pSequenceParameterSetVui: *const StdVideoH265SequenceParameterSetVui,
4806 pub pPredictorPaletteEntries: *const StdVideoH265PredictorPaletteEntries,
4807}
4808#[test]
4809fn bindgen_test_layout_StdVideoH265SequenceParameterSet() {
4810 const UNINIT: ::std::mem::MaybeUninit<StdVideoH265SequenceParameterSet> =
4811 ::std::mem::MaybeUninit::uninit();
4812 let ptr = UNINIT.as_ptr();
4813 assert_eq!(
4814 ::std::mem::size_of::<StdVideoH265SequenceParameterSet>(),
4815 112usize,
4816 concat!("Size of: ", stringify!(StdVideoH265SequenceParameterSet))
4817 );
4818 assert_eq!(
4819 ::std::mem::align_of::<StdVideoH265SequenceParameterSet>(),
4820 8usize,
4821 concat!(
4822 "Alignment of ",
4823 stringify!(StdVideoH265SequenceParameterSet)
4824 )
4825 );
4826 assert_eq!(
4827 unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
4828 0usize,
4829 concat!(
4830 "Offset of field: ",
4831 stringify!(StdVideoH265SequenceParameterSet),
4832 "::",
4833 stringify!(flags)
4834 )
4835 );
4836 assert_eq!(
4837 unsafe { ::std::ptr::addr_of!((*ptr).chroma_format_idc) as usize - ptr as usize },
4838 4usize,
4839 concat!(
4840 "Offset of field: ",
4841 stringify!(StdVideoH265SequenceParameterSet),
4842 "::",
4843 stringify!(chroma_format_idc)
4844 )
4845 );
4846 assert_eq!(
4847 unsafe { ::std::ptr::addr_of!((*ptr).pic_width_in_luma_samples) as usize - ptr as usize },
4848 8usize,
4849 concat!(
4850 "Offset of field: ",
4851 stringify!(StdVideoH265SequenceParameterSet),
4852 "::",
4853 stringify!(pic_width_in_luma_samples)
4854 )
4855 );
4856 assert_eq!(
4857 unsafe { ::std::ptr::addr_of!((*ptr).pic_height_in_luma_samples) as usize - ptr as usize },
4858 12usize,
4859 concat!(
4860 "Offset of field: ",
4861 stringify!(StdVideoH265SequenceParameterSet),
4862 "::",
4863 stringify!(pic_height_in_luma_samples)
4864 )
4865 );
4866 assert_eq!(
4867 unsafe { ::std::ptr::addr_of!((*ptr).sps_video_parameter_set_id) as usize - ptr as usize },
4868 16usize,
4869 concat!(
4870 "Offset of field: ",
4871 stringify!(StdVideoH265SequenceParameterSet),
4872 "::",
4873 stringify!(sps_video_parameter_set_id)
4874 )
4875 );
4876 assert_eq!(
4877 unsafe { ::std::ptr::addr_of!((*ptr).sps_max_sub_layers_minus1) as usize - ptr as usize },
4878 17usize,
4879 concat!(
4880 "Offset of field: ",
4881 stringify!(StdVideoH265SequenceParameterSet),
4882 "::",
4883 stringify!(sps_max_sub_layers_minus1)
4884 )
4885 );
4886 assert_eq!(
4887 unsafe { ::std::ptr::addr_of!((*ptr).sps_seq_parameter_set_id) as usize - ptr as usize },
4888 18usize,
4889 concat!(
4890 "Offset of field: ",
4891 stringify!(StdVideoH265SequenceParameterSet),
4892 "::",
4893 stringify!(sps_seq_parameter_set_id)
4894 )
4895 );
4896 assert_eq!(
4897 unsafe { ::std::ptr::addr_of!((*ptr).bit_depth_luma_minus8) as usize - ptr as usize },
4898 19usize,
4899 concat!(
4900 "Offset of field: ",
4901 stringify!(StdVideoH265SequenceParameterSet),
4902 "::",
4903 stringify!(bit_depth_luma_minus8)
4904 )
4905 );
4906 assert_eq!(
4907 unsafe { ::std::ptr::addr_of!((*ptr).bit_depth_chroma_minus8) as usize - ptr as usize },
4908 20usize,
4909 concat!(
4910 "Offset of field: ",
4911 stringify!(StdVideoH265SequenceParameterSet),
4912 "::",
4913 stringify!(bit_depth_chroma_minus8)
4914 )
4915 );
4916 assert_eq!(
4917 unsafe {
4918 ::std::ptr::addr_of!((*ptr).log2_max_pic_order_cnt_lsb_minus4) as usize - ptr as usize
4919 },
4920 21usize,
4921 concat!(
4922 "Offset of field: ",
4923 stringify!(StdVideoH265SequenceParameterSet),
4924 "::",
4925 stringify!(log2_max_pic_order_cnt_lsb_minus4)
4926 )
4927 );
4928 assert_eq!(
4929 unsafe {
4930 ::std::ptr::addr_of!((*ptr).log2_min_luma_coding_block_size_minus3) as usize
4931 - ptr as usize
4932 },
4933 22usize,
4934 concat!(
4935 "Offset of field: ",
4936 stringify!(StdVideoH265SequenceParameterSet),
4937 "::",
4938 stringify!(log2_min_luma_coding_block_size_minus3)
4939 )
4940 );
4941 assert_eq!(
4942 unsafe {
4943 ::std::ptr::addr_of!((*ptr).log2_diff_max_min_luma_coding_block_size) as usize
4944 - ptr as usize
4945 },
4946 23usize,
4947 concat!(
4948 "Offset of field: ",
4949 stringify!(StdVideoH265SequenceParameterSet),
4950 "::",
4951 stringify!(log2_diff_max_min_luma_coding_block_size)
4952 )
4953 );
4954 assert_eq!(
4955 unsafe {
4956 ::std::ptr::addr_of!((*ptr).log2_min_luma_transform_block_size_minus2) as usize
4957 - ptr as usize
4958 },
4959 24usize,
4960 concat!(
4961 "Offset of field: ",
4962 stringify!(StdVideoH265SequenceParameterSet),
4963 "::",
4964 stringify!(log2_min_luma_transform_block_size_minus2)
4965 )
4966 );
4967 assert_eq!(
4968 unsafe {
4969 ::std::ptr::addr_of!((*ptr).log2_diff_max_min_luma_transform_block_size) as usize
4970 - ptr as usize
4971 },
4972 25usize,
4973 concat!(
4974 "Offset of field: ",
4975 stringify!(StdVideoH265SequenceParameterSet),
4976 "::",
4977 stringify!(log2_diff_max_min_luma_transform_block_size)
4978 )
4979 );
4980 assert_eq!(
4981 unsafe {
4982 ::std::ptr::addr_of!((*ptr).max_transform_hierarchy_depth_inter) as usize - ptr as usize
4983 },
4984 26usize,
4985 concat!(
4986 "Offset of field: ",
4987 stringify!(StdVideoH265SequenceParameterSet),
4988 "::",
4989 stringify!(max_transform_hierarchy_depth_inter)
4990 )
4991 );
4992 assert_eq!(
4993 unsafe {
4994 ::std::ptr::addr_of!((*ptr).max_transform_hierarchy_depth_intra) as usize - ptr as usize
4995 },
4996 27usize,
4997 concat!(
4998 "Offset of field: ",
4999 stringify!(StdVideoH265SequenceParameterSet),
5000 "::",
5001 stringify!(max_transform_hierarchy_depth_intra)
5002 )
5003 );
5004 assert_eq!(
5005 unsafe { ::std::ptr::addr_of!((*ptr).num_short_term_ref_pic_sets) as usize - ptr as usize },
5006 28usize,
5007 concat!(
5008 "Offset of field: ",
5009 stringify!(StdVideoH265SequenceParameterSet),
5010 "::",
5011 stringify!(num_short_term_ref_pic_sets)
5012 )
5013 );
5014 assert_eq!(
5015 unsafe { ::std::ptr::addr_of!((*ptr).num_long_term_ref_pics_sps) as usize - ptr as usize },
5016 29usize,
5017 concat!(
5018 "Offset of field: ",
5019 stringify!(StdVideoH265SequenceParameterSet),
5020 "::",
5021 stringify!(num_long_term_ref_pics_sps)
5022 )
5023 );
5024 assert_eq!(
5025 unsafe {
5026 ::std::ptr::addr_of!((*ptr).pcm_sample_bit_depth_luma_minus1) as usize - ptr as usize
5027 },
5028 30usize,
5029 concat!(
5030 "Offset of field: ",
5031 stringify!(StdVideoH265SequenceParameterSet),
5032 "::",
5033 stringify!(pcm_sample_bit_depth_luma_minus1)
5034 )
5035 );
5036 assert_eq!(
5037 unsafe {
5038 ::std::ptr::addr_of!((*ptr).pcm_sample_bit_depth_chroma_minus1) as usize - ptr as usize
5039 },
5040 31usize,
5041 concat!(
5042 "Offset of field: ",
5043 stringify!(StdVideoH265SequenceParameterSet),
5044 "::",
5045 stringify!(pcm_sample_bit_depth_chroma_minus1)
5046 )
5047 );
5048 assert_eq!(
5049 unsafe {
5050 ::std::ptr::addr_of!((*ptr).log2_min_pcm_luma_coding_block_size_minus3) as usize
5051 - ptr as usize
5052 },
5053 32usize,
5054 concat!(
5055 "Offset of field: ",
5056 stringify!(StdVideoH265SequenceParameterSet),
5057 "::",
5058 stringify!(log2_min_pcm_luma_coding_block_size_minus3)
5059 )
5060 );
5061 assert_eq!(
5062 unsafe {
5063 ::std::ptr::addr_of!((*ptr).log2_diff_max_min_pcm_luma_coding_block_size) as usize
5064 - ptr as usize
5065 },
5066 33usize,
5067 concat!(
5068 "Offset of field: ",
5069 stringify!(StdVideoH265SequenceParameterSet),
5070 "::",
5071 stringify!(log2_diff_max_min_pcm_luma_coding_block_size)
5072 )
5073 );
5074 assert_eq!(
5075 unsafe { ::std::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize },
5076 34usize,
5077 concat!(
5078 "Offset of field: ",
5079 stringify!(StdVideoH265SequenceParameterSet),
5080 "::",
5081 stringify!(reserved1)
5082 )
5083 );
5084 assert_eq!(
5085 unsafe { ::std::ptr::addr_of!((*ptr).reserved2) as usize - ptr as usize },
5086 35usize,
5087 concat!(
5088 "Offset of field: ",
5089 stringify!(StdVideoH265SequenceParameterSet),
5090 "::",
5091 stringify!(reserved2)
5092 )
5093 );
5094 assert_eq!(
5095 unsafe { ::std::ptr::addr_of!((*ptr).palette_max_size) as usize - ptr as usize },
5096 36usize,
5097 concat!(
5098 "Offset of field: ",
5099 stringify!(StdVideoH265SequenceParameterSet),
5100 "::",
5101 stringify!(palette_max_size)
5102 )
5103 );
5104 assert_eq!(
5105 unsafe {
5106 ::std::ptr::addr_of!((*ptr).delta_palette_max_predictor_size) as usize - ptr as usize
5107 },
5108 37usize,
5109 concat!(
5110 "Offset of field: ",
5111 stringify!(StdVideoH265SequenceParameterSet),
5112 "::",
5113 stringify!(delta_palette_max_predictor_size)
5114 )
5115 );
5116 assert_eq!(
5117 unsafe {
5118 ::std::ptr::addr_of!((*ptr).motion_vector_resolution_control_idc) as usize
5119 - ptr as usize
5120 },
5121 38usize,
5122 concat!(
5123 "Offset of field: ",
5124 stringify!(StdVideoH265SequenceParameterSet),
5125 "::",
5126 stringify!(motion_vector_resolution_control_idc)
5127 )
5128 );
5129 assert_eq!(
5130 unsafe {
5131 ::std::ptr::addr_of!((*ptr).sps_num_palette_predictor_initializers_minus1) as usize
5132 - ptr as usize
5133 },
5134 39usize,
5135 concat!(
5136 "Offset of field: ",
5137 stringify!(StdVideoH265SequenceParameterSet),
5138 "::",
5139 stringify!(sps_num_palette_predictor_initializers_minus1)
5140 )
5141 );
5142 assert_eq!(
5143 unsafe { ::std::ptr::addr_of!((*ptr).conf_win_left_offset) as usize - ptr as usize },
5144 40usize,
5145 concat!(
5146 "Offset of field: ",
5147 stringify!(StdVideoH265SequenceParameterSet),
5148 "::",
5149 stringify!(conf_win_left_offset)
5150 )
5151 );
5152 assert_eq!(
5153 unsafe { ::std::ptr::addr_of!((*ptr).conf_win_right_offset) as usize - ptr as usize },
5154 44usize,
5155 concat!(
5156 "Offset of field: ",
5157 stringify!(StdVideoH265SequenceParameterSet),
5158 "::",
5159 stringify!(conf_win_right_offset)
5160 )
5161 );
5162 assert_eq!(
5163 unsafe { ::std::ptr::addr_of!((*ptr).conf_win_top_offset) as usize - ptr as usize },
5164 48usize,
5165 concat!(
5166 "Offset of field: ",
5167 stringify!(StdVideoH265SequenceParameterSet),
5168 "::",
5169 stringify!(conf_win_top_offset)
5170 )
5171 );
5172 assert_eq!(
5173 unsafe { ::std::ptr::addr_of!((*ptr).conf_win_bottom_offset) as usize - ptr as usize },
5174 52usize,
5175 concat!(
5176 "Offset of field: ",
5177 stringify!(StdVideoH265SequenceParameterSet),
5178 "::",
5179 stringify!(conf_win_bottom_offset)
5180 )
5181 );
5182 assert_eq!(
5183 unsafe { ::std::ptr::addr_of!((*ptr).pProfileTierLevel) as usize - ptr as usize },
5184 56usize,
5185 concat!(
5186 "Offset of field: ",
5187 stringify!(StdVideoH265SequenceParameterSet),
5188 "::",
5189 stringify!(pProfileTierLevel)
5190 )
5191 );
5192 assert_eq!(
5193 unsafe { ::std::ptr::addr_of!((*ptr).pDecPicBufMgr) as usize - ptr as usize },
5194 64usize,
5195 concat!(
5196 "Offset of field: ",
5197 stringify!(StdVideoH265SequenceParameterSet),
5198 "::",
5199 stringify!(pDecPicBufMgr)
5200 )
5201 );
5202 assert_eq!(
5203 unsafe { ::std::ptr::addr_of!((*ptr).pScalingLists) as usize - ptr as usize },
5204 72usize,
5205 concat!(
5206 "Offset of field: ",
5207 stringify!(StdVideoH265SequenceParameterSet),
5208 "::",
5209 stringify!(pScalingLists)
5210 )
5211 );
5212 assert_eq!(
5213 unsafe { ::std::ptr::addr_of!((*ptr).pShortTermRefPicSet) as usize - ptr as usize },
5214 80usize,
5215 concat!(
5216 "Offset of field: ",
5217 stringify!(StdVideoH265SequenceParameterSet),
5218 "::",
5219 stringify!(pShortTermRefPicSet)
5220 )
5221 );
5222 assert_eq!(
5223 unsafe { ::std::ptr::addr_of!((*ptr).pLongTermRefPicsSps) as usize - ptr as usize },
5224 88usize,
5225 concat!(
5226 "Offset of field: ",
5227 stringify!(StdVideoH265SequenceParameterSet),
5228 "::",
5229 stringify!(pLongTermRefPicsSps)
5230 )
5231 );
5232 assert_eq!(
5233 unsafe { ::std::ptr::addr_of!((*ptr).pSequenceParameterSetVui) as usize - ptr as usize },
5234 96usize,
5235 concat!(
5236 "Offset of field: ",
5237 stringify!(StdVideoH265SequenceParameterSet),
5238 "::",
5239 stringify!(pSequenceParameterSetVui)
5240 )
5241 );
5242 assert_eq!(
5243 unsafe { ::std::ptr::addr_of!((*ptr).pPredictorPaletteEntries) as usize - ptr as usize },
5244 104usize,
5245 concat!(
5246 "Offset of field: ",
5247 stringify!(StdVideoH265SequenceParameterSet),
5248 "::",
5249 stringify!(pPredictorPaletteEntries)
5250 )
5251 );
5252}
5253#[repr(C)]
5254#[repr(align(4))]
5255#[derive(Debug, Copy, Clone)]
5256pub struct StdVideoH265PpsFlags {
5257 pub _bitfield_align_1: [u8; 0],
5258 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
5259}
5260#[test]
5261fn bindgen_test_layout_StdVideoH265PpsFlags() {
5262 assert_eq!(
5263 ::std::mem::size_of::<StdVideoH265PpsFlags>(),
5264 4usize,
5265 concat!("Size of: ", stringify!(StdVideoH265PpsFlags))
5266 );
5267 assert_eq!(
5268 ::std::mem::align_of::<StdVideoH265PpsFlags>(),
5269 4usize,
5270 concat!("Alignment of ", stringify!(StdVideoH265PpsFlags))
5271 );
5272}
5273impl StdVideoH265PpsFlags {
5274 #[inline]
5275 pub fn dependent_slice_segments_enabled_flag(&self) -> u32 {
5276 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
5277 }
5278 #[inline]
5279 pub fn set_dependent_slice_segments_enabled_flag(&mut self, val: u32) {
5280 unsafe {
5281 let val: u32 = ::std::mem::transmute(val);
5282 self._bitfield_1.set(0usize, 1u8, val as u64)
5283 }
5284 }
5285 #[inline]
5286 pub fn output_flag_present_flag(&self) -> u32 {
5287 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
5288 }
5289 #[inline]
5290 pub fn set_output_flag_present_flag(&mut self, val: u32) {
5291 unsafe {
5292 let val: u32 = ::std::mem::transmute(val);
5293 self._bitfield_1.set(1usize, 1u8, val as u64)
5294 }
5295 }
5296 #[inline]
5297 pub fn sign_data_hiding_enabled_flag(&self) -> u32 {
5298 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
5299 }
5300 #[inline]
5301 pub fn set_sign_data_hiding_enabled_flag(&mut self, val: u32) {
5302 unsafe {
5303 let val: u32 = ::std::mem::transmute(val);
5304 self._bitfield_1.set(2usize, 1u8, val as u64)
5305 }
5306 }
5307 #[inline]
5308 pub fn cabac_init_present_flag(&self) -> u32 {
5309 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
5310 }
5311 #[inline]
5312 pub fn set_cabac_init_present_flag(&mut self, val: u32) {
5313 unsafe {
5314 let val: u32 = ::std::mem::transmute(val);
5315 self._bitfield_1.set(3usize, 1u8, val as u64)
5316 }
5317 }
5318 #[inline]
5319 pub fn constrained_intra_pred_flag(&self) -> u32 {
5320 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
5321 }
5322 #[inline]
5323 pub fn set_constrained_intra_pred_flag(&mut self, val: u32) {
5324 unsafe {
5325 let val: u32 = ::std::mem::transmute(val);
5326 self._bitfield_1.set(4usize, 1u8, val as u64)
5327 }
5328 }
5329 #[inline]
5330 pub fn transform_skip_enabled_flag(&self) -> u32 {
5331 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
5332 }
5333 #[inline]
5334 pub fn set_transform_skip_enabled_flag(&mut self, val: u32) {
5335 unsafe {
5336 let val: u32 = ::std::mem::transmute(val);
5337 self._bitfield_1.set(5usize, 1u8, val as u64)
5338 }
5339 }
5340 #[inline]
5341 pub fn cu_qp_delta_enabled_flag(&self) -> u32 {
5342 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) }
5343 }
5344 #[inline]
5345 pub fn set_cu_qp_delta_enabled_flag(&mut self, val: u32) {
5346 unsafe {
5347 let val: u32 = ::std::mem::transmute(val);
5348 self._bitfield_1.set(6usize, 1u8, val as u64)
5349 }
5350 }
5351 #[inline]
5352 pub fn pps_slice_chroma_qp_offsets_present_flag(&self) -> u32 {
5353 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) }
5354 }
5355 #[inline]
5356 pub fn set_pps_slice_chroma_qp_offsets_present_flag(&mut self, val: u32) {
5357 unsafe {
5358 let val: u32 = ::std::mem::transmute(val);
5359 self._bitfield_1.set(7usize, 1u8, val as u64)
5360 }
5361 }
5362 #[inline]
5363 pub fn weighted_pred_flag(&self) -> u32 {
5364 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) }
5365 }
5366 #[inline]
5367 pub fn set_weighted_pred_flag(&mut self, val: u32) {
5368 unsafe {
5369 let val: u32 = ::std::mem::transmute(val);
5370 self._bitfield_1.set(8usize, 1u8, val as u64)
5371 }
5372 }
5373 #[inline]
5374 pub fn weighted_bipred_flag(&self) -> u32 {
5375 unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) }
5376 }
5377 #[inline]
5378 pub fn set_weighted_bipred_flag(&mut self, val: u32) {
5379 unsafe {
5380 let val: u32 = ::std::mem::transmute(val);
5381 self._bitfield_1.set(9usize, 1u8, val as u64)
5382 }
5383 }
5384 #[inline]
5385 pub fn transquant_bypass_enabled_flag(&self) -> u32 {
5386 unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) }
5387 }
5388 #[inline]
5389 pub fn set_transquant_bypass_enabled_flag(&mut self, val: u32) {
5390 unsafe {
5391 let val: u32 = ::std::mem::transmute(val);
5392 self._bitfield_1.set(10usize, 1u8, val as u64)
5393 }
5394 }
5395 #[inline]
5396 pub fn tiles_enabled_flag(&self) -> u32 {
5397 unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) }
5398 }
5399 #[inline]
5400 pub fn set_tiles_enabled_flag(&mut self, val: u32) {
5401 unsafe {
5402 let val: u32 = ::std::mem::transmute(val);
5403 self._bitfield_1.set(11usize, 1u8, val as u64)
5404 }
5405 }
5406 #[inline]
5407 pub fn entropy_coding_sync_enabled_flag(&self) -> u32 {
5408 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u32) }
5409 }
5410 #[inline]
5411 pub fn set_entropy_coding_sync_enabled_flag(&mut self, val: u32) {
5412 unsafe {
5413 let val: u32 = ::std::mem::transmute(val);
5414 self._bitfield_1.set(12usize, 1u8, val as u64)
5415 }
5416 }
5417 #[inline]
5418 pub fn uniform_spacing_flag(&self) -> u32 {
5419 unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) }
5420 }
5421 #[inline]
5422 pub fn set_uniform_spacing_flag(&mut self, val: u32) {
5423 unsafe {
5424 let val: u32 = ::std::mem::transmute(val);
5425 self._bitfield_1.set(13usize, 1u8, val as u64)
5426 }
5427 }
5428 #[inline]
5429 pub fn loop_filter_across_tiles_enabled_flag(&self) -> u32 {
5430 unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) }
5431 }
5432 #[inline]
5433 pub fn set_loop_filter_across_tiles_enabled_flag(&mut self, val: u32) {
5434 unsafe {
5435 let val: u32 = ::std::mem::transmute(val);
5436 self._bitfield_1.set(14usize, 1u8, val as u64)
5437 }
5438 }
5439 #[inline]
5440 pub fn pps_loop_filter_across_slices_enabled_flag(&self) -> u32 {
5441 unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u32) }
5442 }
5443 #[inline]
5444 pub fn set_pps_loop_filter_across_slices_enabled_flag(&mut self, val: u32) {
5445 unsafe {
5446 let val: u32 = ::std::mem::transmute(val);
5447 self._bitfield_1.set(15usize, 1u8, val as u64)
5448 }
5449 }
5450 #[inline]
5451 pub fn deblocking_filter_control_present_flag(&self) -> u32 {
5452 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u32) }
5453 }
5454 #[inline]
5455 pub fn set_deblocking_filter_control_present_flag(&mut self, val: u32) {
5456 unsafe {
5457 let val: u32 = ::std::mem::transmute(val);
5458 self._bitfield_1.set(16usize, 1u8, val as u64)
5459 }
5460 }
5461 #[inline]
5462 pub fn deblocking_filter_override_enabled_flag(&self) -> u32 {
5463 unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 1u8) as u32) }
5464 }
5465 #[inline]
5466 pub fn set_deblocking_filter_override_enabled_flag(&mut self, val: u32) {
5467 unsafe {
5468 let val: u32 = ::std::mem::transmute(val);
5469 self._bitfield_1.set(17usize, 1u8, val as u64)
5470 }
5471 }
5472 #[inline]
5473 pub fn pps_deblocking_filter_disabled_flag(&self) -> u32 {
5474 unsafe { ::std::mem::transmute(self._bitfield_1.get(18usize, 1u8) as u32) }
5475 }
5476 #[inline]
5477 pub fn set_pps_deblocking_filter_disabled_flag(&mut self, val: u32) {
5478 unsafe {
5479 let val: u32 = ::std::mem::transmute(val);
5480 self._bitfield_1.set(18usize, 1u8, val as u64)
5481 }
5482 }
5483 #[inline]
5484 pub fn pps_scaling_list_data_present_flag(&self) -> u32 {
5485 unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 1u8) as u32) }
5486 }
5487 #[inline]
5488 pub fn set_pps_scaling_list_data_present_flag(&mut self, val: u32) {
5489 unsafe {
5490 let val: u32 = ::std::mem::transmute(val);
5491 self._bitfield_1.set(19usize, 1u8, val as u64)
5492 }
5493 }
5494 #[inline]
5495 pub fn lists_modification_present_flag(&self) -> u32 {
5496 unsafe { ::std::mem::transmute(self._bitfield_1.get(20usize, 1u8) as u32) }
5497 }
5498 #[inline]
5499 pub fn set_lists_modification_present_flag(&mut self, val: u32) {
5500 unsafe {
5501 let val: u32 = ::std::mem::transmute(val);
5502 self._bitfield_1.set(20usize, 1u8, val as u64)
5503 }
5504 }
5505 #[inline]
5506 pub fn slice_segment_header_extension_present_flag(&self) -> u32 {
5507 unsafe { ::std::mem::transmute(self._bitfield_1.get(21usize, 1u8) as u32) }
5508 }
5509 #[inline]
5510 pub fn set_slice_segment_header_extension_present_flag(&mut self, val: u32) {
5511 unsafe {
5512 let val: u32 = ::std::mem::transmute(val);
5513 self._bitfield_1.set(21usize, 1u8, val as u64)
5514 }
5515 }
5516 #[inline]
5517 pub fn pps_extension_present_flag(&self) -> u32 {
5518 unsafe { ::std::mem::transmute(self._bitfield_1.get(22usize, 1u8) as u32) }
5519 }
5520 #[inline]
5521 pub fn set_pps_extension_present_flag(&mut self, val: u32) {
5522 unsafe {
5523 let val: u32 = ::std::mem::transmute(val);
5524 self._bitfield_1.set(22usize, 1u8, val as u64)
5525 }
5526 }
5527 #[inline]
5528 pub fn cross_component_prediction_enabled_flag(&self) -> u32 {
5529 unsafe { ::std::mem::transmute(self._bitfield_1.get(23usize, 1u8) as u32) }
5530 }
5531 #[inline]
5532 pub fn set_cross_component_prediction_enabled_flag(&mut self, val: u32) {
5533 unsafe {
5534 let val: u32 = ::std::mem::transmute(val);
5535 self._bitfield_1.set(23usize, 1u8, val as u64)
5536 }
5537 }
5538 #[inline]
5539 pub fn chroma_qp_offset_list_enabled_flag(&self) -> u32 {
5540 unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 1u8) as u32) }
5541 }
5542 #[inline]
5543 pub fn set_chroma_qp_offset_list_enabled_flag(&mut self, val: u32) {
5544 unsafe {
5545 let val: u32 = ::std::mem::transmute(val);
5546 self._bitfield_1.set(24usize, 1u8, val as u64)
5547 }
5548 }
5549 #[inline]
5550 pub fn pps_curr_pic_ref_enabled_flag(&self) -> u32 {
5551 unsafe { ::std::mem::transmute(self._bitfield_1.get(25usize, 1u8) as u32) }
5552 }
5553 #[inline]
5554 pub fn set_pps_curr_pic_ref_enabled_flag(&mut self, val: u32) {
5555 unsafe {
5556 let val: u32 = ::std::mem::transmute(val);
5557 self._bitfield_1.set(25usize, 1u8, val as u64)
5558 }
5559 }
5560 #[inline]
5561 pub fn residual_adaptive_colour_transform_enabled_flag(&self) -> u32 {
5562 unsafe { ::std::mem::transmute(self._bitfield_1.get(26usize, 1u8) as u32) }
5563 }
5564 #[inline]
5565 pub fn set_residual_adaptive_colour_transform_enabled_flag(&mut self, val: u32) {
5566 unsafe {
5567 let val: u32 = ::std::mem::transmute(val);
5568 self._bitfield_1.set(26usize, 1u8, val as u64)
5569 }
5570 }
5571 #[inline]
5572 pub fn pps_slice_act_qp_offsets_present_flag(&self) -> u32 {
5573 unsafe { ::std::mem::transmute(self._bitfield_1.get(27usize, 1u8) as u32) }
5574 }
5575 #[inline]
5576 pub fn set_pps_slice_act_qp_offsets_present_flag(&mut self, val: u32) {
5577 unsafe {
5578 let val: u32 = ::std::mem::transmute(val);
5579 self._bitfield_1.set(27usize, 1u8, val as u64)
5580 }
5581 }
5582 #[inline]
5583 pub fn pps_palette_predictor_initializers_present_flag(&self) -> u32 {
5584 unsafe { ::std::mem::transmute(self._bitfield_1.get(28usize, 1u8) as u32) }
5585 }
5586 #[inline]
5587 pub fn set_pps_palette_predictor_initializers_present_flag(&mut self, val: u32) {
5588 unsafe {
5589 let val: u32 = ::std::mem::transmute(val);
5590 self._bitfield_1.set(28usize, 1u8, val as u64)
5591 }
5592 }
5593 #[inline]
5594 pub fn monochrome_palette_flag(&self) -> u32 {
5595 unsafe { ::std::mem::transmute(self._bitfield_1.get(29usize, 1u8) as u32) }
5596 }
5597 #[inline]
5598 pub fn set_monochrome_palette_flag(&mut self, val: u32) {
5599 unsafe {
5600 let val: u32 = ::std::mem::transmute(val);
5601 self._bitfield_1.set(29usize, 1u8, val as u64)
5602 }
5603 }
5604 #[inline]
5605 pub fn pps_range_extension_flag(&self) -> u32 {
5606 unsafe { ::std::mem::transmute(self._bitfield_1.get(30usize, 1u8) as u32) }
5607 }
5608 #[inline]
5609 pub fn set_pps_range_extension_flag(&mut self, val: u32) {
5610 unsafe {
5611 let val: u32 = ::std::mem::transmute(val);
5612 self._bitfield_1.set(30usize, 1u8, val as u64)
5613 }
5614 }
5615 #[inline]
5616 pub fn new_bitfield_1(
5617 dependent_slice_segments_enabled_flag: u32,
5618 output_flag_present_flag: u32,
5619 sign_data_hiding_enabled_flag: u32,
5620 cabac_init_present_flag: u32,
5621 constrained_intra_pred_flag: u32,
5622 transform_skip_enabled_flag: u32,
5623 cu_qp_delta_enabled_flag: u32,
5624 pps_slice_chroma_qp_offsets_present_flag: u32,
5625 weighted_pred_flag: u32,
5626 weighted_bipred_flag: u32,
5627 transquant_bypass_enabled_flag: u32,
5628 tiles_enabled_flag: u32,
5629 entropy_coding_sync_enabled_flag: u32,
5630 uniform_spacing_flag: u32,
5631 loop_filter_across_tiles_enabled_flag: u32,
5632 pps_loop_filter_across_slices_enabled_flag: u32,
5633 deblocking_filter_control_present_flag: u32,
5634 deblocking_filter_override_enabled_flag: u32,
5635 pps_deblocking_filter_disabled_flag: u32,
5636 pps_scaling_list_data_present_flag: u32,
5637 lists_modification_present_flag: u32,
5638 slice_segment_header_extension_present_flag: u32,
5639 pps_extension_present_flag: u32,
5640 cross_component_prediction_enabled_flag: u32,
5641 chroma_qp_offset_list_enabled_flag: u32,
5642 pps_curr_pic_ref_enabled_flag: u32,
5643 residual_adaptive_colour_transform_enabled_flag: u32,
5644 pps_slice_act_qp_offsets_present_flag: u32,
5645 pps_palette_predictor_initializers_present_flag: u32,
5646 monochrome_palette_flag: u32,
5647 pps_range_extension_flag: u32,
5648 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
5649 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
5650 __bindgen_bitfield_unit.set(0usize, 1u8, {
5651 let dependent_slice_segments_enabled_flag: u32 =
5652 unsafe { ::std::mem::transmute(dependent_slice_segments_enabled_flag) };
5653 dependent_slice_segments_enabled_flag as u64
5654 });
5655 __bindgen_bitfield_unit.set(1usize, 1u8, {
5656 let output_flag_present_flag: u32 =
5657 unsafe { ::std::mem::transmute(output_flag_present_flag) };
5658 output_flag_present_flag as u64
5659 });
5660 __bindgen_bitfield_unit.set(2usize, 1u8, {
5661 let sign_data_hiding_enabled_flag: u32 =
5662 unsafe { ::std::mem::transmute(sign_data_hiding_enabled_flag) };
5663 sign_data_hiding_enabled_flag as u64
5664 });
5665 __bindgen_bitfield_unit.set(3usize, 1u8, {
5666 let cabac_init_present_flag: u32 =
5667 unsafe { ::std::mem::transmute(cabac_init_present_flag) };
5668 cabac_init_present_flag as u64
5669 });
5670 __bindgen_bitfield_unit.set(4usize, 1u8, {
5671 let constrained_intra_pred_flag: u32 =
5672 unsafe { ::std::mem::transmute(constrained_intra_pred_flag) };
5673 constrained_intra_pred_flag as u64
5674 });
5675 __bindgen_bitfield_unit.set(5usize, 1u8, {
5676 let transform_skip_enabled_flag: u32 =
5677 unsafe { ::std::mem::transmute(transform_skip_enabled_flag) };
5678 transform_skip_enabled_flag as u64
5679 });
5680 __bindgen_bitfield_unit.set(6usize, 1u8, {
5681 let cu_qp_delta_enabled_flag: u32 =
5682 unsafe { ::std::mem::transmute(cu_qp_delta_enabled_flag) };
5683 cu_qp_delta_enabled_flag as u64
5684 });
5685 __bindgen_bitfield_unit.set(7usize, 1u8, {
5686 let pps_slice_chroma_qp_offsets_present_flag: u32 =
5687 unsafe { ::std::mem::transmute(pps_slice_chroma_qp_offsets_present_flag) };
5688 pps_slice_chroma_qp_offsets_present_flag as u64
5689 });
5690 __bindgen_bitfield_unit.set(8usize, 1u8, {
5691 let weighted_pred_flag: u32 = unsafe { ::std::mem::transmute(weighted_pred_flag) };
5692 weighted_pred_flag as u64
5693 });
5694 __bindgen_bitfield_unit.set(9usize, 1u8, {
5695 let weighted_bipred_flag: u32 = unsafe { ::std::mem::transmute(weighted_bipred_flag) };
5696 weighted_bipred_flag as u64
5697 });
5698 __bindgen_bitfield_unit.set(10usize, 1u8, {
5699 let transquant_bypass_enabled_flag: u32 =
5700 unsafe { ::std::mem::transmute(transquant_bypass_enabled_flag) };
5701 transquant_bypass_enabled_flag as u64
5702 });
5703 __bindgen_bitfield_unit.set(11usize, 1u8, {
5704 let tiles_enabled_flag: u32 = unsafe { ::std::mem::transmute(tiles_enabled_flag) };
5705 tiles_enabled_flag as u64
5706 });
5707 __bindgen_bitfield_unit.set(12usize, 1u8, {
5708 let entropy_coding_sync_enabled_flag: u32 =
5709 unsafe { ::std::mem::transmute(entropy_coding_sync_enabled_flag) };
5710 entropy_coding_sync_enabled_flag as u64
5711 });
5712 __bindgen_bitfield_unit.set(13usize, 1u8, {
5713 let uniform_spacing_flag: u32 = unsafe { ::std::mem::transmute(uniform_spacing_flag) };
5714 uniform_spacing_flag as u64
5715 });
5716 __bindgen_bitfield_unit.set(14usize, 1u8, {
5717 let loop_filter_across_tiles_enabled_flag: u32 =
5718 unsafe { ::std::mem::transmute(loop_filter_across_tiles_enabled_flag) };
5719 loop_filter_across_tiles_enabled_flag as u64
5720 });
5721 __bindgen_bitfield_unit.set(15usize, 1u8, {
5722 let pps_loop_filter_across_slices_enabled_flag: u32 =
5723 unsafe { ::std::mem::transmute(pps_loop_filter_across_slices_enabled_flag) };
5724 pps_loop_filter_across_slices_enabled_flag as u64
5725 });
5726 __bindgen_bitfield_unit.set(16usize, 1u8, {
5727 let deblocking_filter_control_present_flag: u32 =
5728 unsafe { ::std::mem::transmute(deblocking_filter_control_present_flag) };
5729 deblocking_filter_control_present_flag as u64
5730 });
5731 __bindgen_bitfield_unit.set(17usize, 1u8, {
5732 let deblocking_filter_override_enabled_flag: u32 =
5733 unsafe { ::std::mem::transmute(deblocking_filter_override_enabled_flag) };
5734 deblocking_filter_override_enabled_flag as u64
5735 });
5736 __bindgen_bitfield_unit.set(18usize, 1u8, {
5737 let pps_deblocking_filter_disabled_flag: u32 =
5738 unsafe { ::std::mem::transmute(pps_deblocking_filter_disabled_flag) };
5739 pps_deblocking_filter_disabled_flag as u64
5740 });
5741 __bindgen_bitfield_unit.set(19usize, 1u8, {
5742 let pps_scaling_list_data_present_flag: u32 =
5743 unsafe { ::std::mem::transmute(pps_scaling_list_data_present_flag) };
5744 pps_scaling_list_data_present_flag as u64
5745 });
5746 __bindgen_bitfield_unit.set(20usize, 1u8, {
5747 let lists_modification_present_flag: u32 =
5748 unsafe { ::std::mem::transmute(lists_modification_present_flag) };
5749 lists_modification_present_flag as u64
5750 });
5751 __bindgen_bitfield_unit.set(21usize, 1u8, {
5752 let slice_segment_header_extension_present_flag: u32 =
5753 unsafe { ::std::mem::transmute(slice_segment_header_extension_present_flag) };
5754 slice_segment_header_extension_present_flag as u64
5755 });
5756 __bindgen_bitfield_unit.set(22usize, 1u8, {
5757 let pps_extension_present_flag: u32 =
5758 unsafe { ::std::mem::transmute(pps_extension_present_flag) };
5759 pps_extension_present_flag as u64
5760 });
5761 __bindgen_bitfield_unit.set(23usize, 1u8, {
5762 let cross_component_prediction_enabled_flag: u32 =
5763 unsafe { ::std::mem::transmute(cross_component_prediction_enabled_flag) };
5764 cross_component_prediction_enabled_flag as u64
5765 });
5766 __bindgen_bitfield_unit.set(24usize, 1u8, {
5767 let chroma_qp_offset_list_enabled_flag: u32 =
5768 unsafe { ::std::mem::transmute(chroma_qp_offset_list_enabled_flag) };
5769 chroma_qp_offset_list_enabled_flag as u64
5770 });
5771 __bindgen_bitfield_unit.set(25usize, 1u8, {
5772 let pps_curr_pic_ref_enabled_flag: u32 =
5773 unsafe { ::std::mem::transmute(pps_curr_pic_ref_enabled_flag) };
5774 pps_curr_pic_ref_enabled_flag as u64
5775 });
5776 __bindgen_bitfield_unit.set(26usize, 1u8, {
5777 let residual_adaptive_colour_transform_enabled_flag: u32 =
5778 unsafe { ::std::mem::transmute(residual_adaptive_colour_transform_enabled_flag) };
5779 residual_adaptive_colour_transform_enabled_flag as u64
5780 });
5781 __bindgen_bitfield_unit.set(27usize, 1u8, {
5782 let pps_slice_act_qp_offsets_present_flag: u32 =
5783 unsafe { ::std::mem::transmute(pps_slice_act_qp_offsets_present_flag) };
5784 pps_slice_act_qp_offsets_present_flag as u64
5785 });
5786 __bindgen_bitfield_unit.set(28usize, 1u8, {
5787 let pps_palette_predictor_initializers_present_flag: u32 =
5788 unsafe { ::std::mem::transmute(pps_palette_predictor_initializers_present_flag) };
5789 pps_palette_predictor_initializers_present_flag as u64
5790 });
5791 __bindgen_bitfield_unit.set(29usize, 1u8, {
5792 let monochrome_palette_flag: u32 =
5793 unsafe { ::std::mem::transmute(monochrome_palette_flag) };
5794 monochrome_palette_flag as u64
5795 });
5796 __bindgen_bitfield_unit.set(30usize, 1u8, {
5797 let pps_range_extension_flag: u32 =
5798 unsafe { ::std::mem::transmute(pps_range_extension_flag) };
5799 pps_range_extension_flag as u64
5800 });
5801 __bindgen_bitfield_unit
5802 }
5803}
5804#[repr(C)]
5805#[derive(Debug, Copy, Clone)]
5806pub struct StdVideoH265PictureParameterSet {
5807 pub flags: StdVideoH265PpsFlags,
5808 pub pps_pic_parameter_set_id: u8,
5809 pub pps_seq_parameter_set_id: u8,
5810 pub sps_video_parameter_set_id: u8,
5811 pub num_extra_slice_header_bits: u8,
5812 pub num_ref_idx_l0_default_active_minus1: u8,
5813 pub num_ref_idx_l1_default_active_minus1: u8,
5814 pub init_qp_minus26: i8,
5815 pub diff_cu_qp_delta_depth: u8,
5816 pub pps_cb_qp_offset: i8,
5817 pub pps_cr_qp_offset: i8,
5818 pub pps_beta_offset_div2: i8,
5819 pub pps_tc_offset_div2: i8,
5820 pub log2_parallel_merge_level_minus2: u8,
5821 pub log2_max_transform_skip_block_size_minus2: u8,
5822 pub diff_cu_chroma_qp_offset_depth: u8,
5823 pub chroma_qp_offset_list_len_minus1: u8,
5824 pub cb_qp_offset_list: [i8; 6usize],
5825 pub cr_qp_offset_list: [i8; 6usize],
5826 pub log2_sao_offset_scale_luma: u8,
5827 pub log2_sao_offset_scale_chroma: u8,
5828 pub pps_act_y_qp_offset_plus5: i8,
5829 pub pps_act_cb_qp_offset_plus5: i8,
5830 pub pps_act_cr_qp_offset_plus3: i8,
5831 pub pps_num_palette_predictor_initializers: u8,
5832 pub luma_bit_depth_entry_minus8: u8,
5833 pub chroma_bit_depth_entry_minus8: u8,
5834 pub num_tile_columns_minus1: u8,
5835 pub num_tile_rows_minus1: u8,
5836 pub reserved1: u8,
5837 pub reserved2: u8,
5838 pub column_width_minus1: [u16; 19usize],
5839 pub row_height_minus1: [u16; 21usize],
5840 pub reserved3: u32,
5841 pub pScalingLists: *const StdVideoH265ScalingLists,
5842 pub pPredictorPaletteEntries: *const StdVideoH265PredictorPaletteEntries,
5843}
5844#[test]
5845fn bindgen_test_layout_StdVideoH265PictureParameterSet() {
5846 const UNINIT: ::std::mem::MaybeUninit<StdVideoH265PictureParameterSet> =
5847 ::std::mem::MaybeUninit::uninit();
5848 let ptr = UNINIT.as_ptr();
5849 assert_eq!(
5850 ::std::mem::size_of::<StdVideoH265PictureParameterSet>(),
5851 144usize,
5852 concat!("Size of: ", stringify!(StdVideoH265PictureParameterSet))
5853 );
5854 assert_eq!(
5855 ::std::mem::align_of::<StdVideoH265PictureParameterSet>(),
5856 8usize,
5857 concat!("Alignment of ", stringify!(StdVideoH265PictureParameterSet))
5858 );
5859 assert_eq!(
5860 unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
5861 0usize,
5862 concat!(
5863 "Offset of field: ",
5864 stringify!(StdVideoH265PictureParameterSet),
5865 "::",
5866 stringify!(flags)
5867 )
5868 );
5869 assert_eq!(
5870 unsafe { ::std::ptr::addr_of!((*ptr).pps_pic_parameter_set_id) as usize - ptr as usize },
5871 4usize,
5872 concat!(
5873 "Offset of field: ",
5874 stringify!(StdVideoH265PictureParameterSet),
5875 "::",
5876 stringify!(pps_pic_parameter_set_id)
5877 )
5878 );
5879 assert_eq!(
5880 unsafe { ::std::ptr::addr_of!((*ptr).pps_seq_parameter_set_id) as usize - ptr as usize },
5881 5usize,
5882 concat!(
5883 "Offset of field: ",
5884 stringify!(StdVideoH265PictureParameterSet),
5885 "::",
5886 stringify!(pps_seq_parameter_set_id)
5887 )
5888 );
5889 assert_eq!(
5890 unsafe { ::std::ptr::addr_of!((*ptr).sps_video_parameter_set_id) as usize - ptr as usize },
5891 6usize,
5892 concat!(
5893 "Offset of field: ",
5894 stringify!(StdVideoH265PictureParameterSet),
5895 "::",
5896 stringify!(sps_video_parameter_set_id)
5897 )
5898 );
5899 assert_eq!(
5900 unsafe { ::std::ptr::addr_of!((*ptr).num_extra_slice_header_bits) as usize - ptr as usize },
5901 7usize,
5902 concat!(
5903 "Offset of field: ",
5904 stringify!(StdVideoH265PictureParameterSet),
5905 "::",
5906 stringify!(num_extra_slice_header_bits)
5907 )
5908 );
5909 assert_eq!(
5910 unsafe {
5911 ::std::ptr::addr_of!((*ptr).num_ref_idx_l0_default_active_minus1) as usize
5912 - ptr as usize
5913 },
5914 8usize,
5915 concat!(
5916 "Offset of field: ",
5917 stringify!(StdVideoH265PictureParameterSet),
5918 "::",
5919 stringify!(num_ref_idx_l0_default_active_minus1)
5920 )
5921 );
5922 assert_eq!(
5923 unsafe {
5924 ::std::ptr::addr_of!((*ptr).num_ref_idx_l1_default_active_minus1) as usize
5925 - ptr as usize
5926 },
5927 9usize,
5928 concat!(
5929 "Offset of field: ",
5930 stringify!(StdVideoH265PictureParameterSet),
5931 "::",
5932 stringify!(num_ref_idx_l1_default_active_minus1)
5933 )
5934 );
5935 assert_eq!(
5936 unsafe { ::std::ptr::addr_of!((*ptr).init_qp_minus26) as usize - ptr as usize },
5937 10usize,
5938 concat!(
5939 "Offset of field: ",
5940 stringify!(StdVideoH265PictureParameterSet),
5941 "::",
5942 stringify!(init_qp_minus26)
5943 )
5944 );
5945 assert_eq!(
5946 unsafe { ::std::ptr::addr_of!((*ptr).diff_cu_qp_delta_depth) as usize - ptr as usize },
5947 11usize,
5948 concat!(
5949 "Offset of field: ",
5950 stringify!(StdVideoH265PictureParameterSet),
5951 "::",
5952 stringify!(diff_cu_qp_delta_depth)
5953 )
5954 );
5955 assert_eq!(
5956 unsafe { ::std::ptr::addr_of!((*ptr).pps_cb_qp_offset) as usize - ptr as usize },
5957 12usize,
5958 concat!(
5959 "Offset of field: ",
5960 stringify!(StdVideoH265PictureParameterSet),
5961 "::",
5962 stringify!(pps_cb_qp_offset)
5963 )
5964 );
5965 assert_eq!(
5966 unsafe { ::std::ptr::addr_of!((*ptr).pps_cr_qp_offset) as usize - ptr as usize },
5967 13usize,
5968 concat!(
5969 "Offset of field: ",
5970 stringify!(StdVideoH265PictureParameterSet),
5971 "::",
5972 stringify!(pps_cr_qp_offset)
5973 )
5974 );
5975 assert_eq!(
5976 unsafe { ::std::ptr::addr_of!((*ptr).pps_beta_offset_div2) as usize - ptr as usize },
5977 14usize,
5978 concat!(
5979 "Offset of field: ",
5980 stringify!(StdVideoH265PictureParameterSet),
5981 "::",
5982 stringify!(pps_beta_offset_div2)
5983 )
5984 );
5985 assert_eq!(
5986 unsafe { ::std::ptr::addr_of!((*ptr).pps_tc_offset_div2) as usize - ptr as usize },
5987 15usize,
5988 concat!(
5989 "Offset of field: ",
5990 stringify!(StdVideoH265PictureParameterSet),
5991 "::",
5992 stringify!(pps_tc_offset_div2)
5993 )
5994 );
5995 assert_eq!(
5996 unsafe {
5997 ::std::ptr::addr_of!((*ptr).log2_parallel_merge_level_minus2) as usize - ptr as usize
5998 },
5999 16usize,
6000 concat!(
6001 "Offset of field: ",
6002 stringify!(StdVideoH265PictureParameterSet),
6003 "::",
6004 stringify!(log2_parallel_merge_level_minus2)
6005 )
6006 );
6007 assert_eq!(
6008 unsafe {
6009 ::std::ptr::addr_of!((*ptr).log2_max_transform_skip_block_size_minus2) as usize
6010 - ptr as usize
6011 },
6012 17usize,
6013 concat!(
6014 "Offset of field: ",
6015 stringify!(StdVideoH265PictureParameterSet),
6016 "::",
6017 stringify!(log2_max_transform_skip_block_size_minus2)
6018 )
6019 );
6020 assert_eq!(
6021 unsafe {
6022 ::std::ptr::addr_of!((*ptr).diff_cu_chroma_qp_offset_depth) as usize - ptr as usize
6023 },
6024 18usize,
6025 concat!(
6026 "Offset of field: ",
6027 stringify!(StdVideoH265PictureParameterSet),
6028 "::",
6029 stringify!(diff_cu_chroma_qp_offset_depth)
6030 )
6031 );
6032 assert_eq!(
6033 unsafe {
6034 ::std::ptr::addr_of!((*ptr).chroma_qp_offset_list_len_minus1) as usize - ptr as usize
6035 },
6036 19usize,
6037 concat!(
6038 "Offset of field: ",
6039 stringify!(StdVideoH265PictureParameterSet),
6040 "::",
6041 stringify!(chroma_qp_offset_list_len_minus1)
6042 )
6043 );
6044 assert_eq!(
6045 unsafe { ::std::ptr::addr_of!((*ptr).cb_qp_offset_list) as usize - ptr as usize },
6046 20usize,
6047 concat!(
6048 "Offset of field: ",
6049 stringify!(StdVideoH265PictureParameterSet),
6050 "::",
6051 stringify!(cb_qp_offset_list)
6052 )
6053 );
6054 assert_eq!(
6055 unsafe { ::std::ptr::addr_of!((*ptr).cr_qp_offset_list) as usize - ptr as usize },
6056 26usize,
6057 concat!(
6058 "Offset of field: ",
6059 stringify!(StdVideoH265PictureParameterSet),
6060 "::",
6061 stringify!(cr_qp_offset_list)
6062 )
6063 );
6064 assert_eq!(
6065 unsafe { ::std::ptr::addr_of!((*ptr).log2_sao_offset_scale_luma) as usize - ptr as usize },
6066 32usize,
6067 concat!(
6068 "Offset of field: ",
6069 stringify!(StdVideoH265PictureParameterSet),
6070 "::",
6071 stringify!(log2_sao_offset_scale_luma)
6072 )
6073 );
6074 assert_eq!(
6075 unsafe {
6076 ::std::ptr::addr_of!((*ptr).log2_sao_offset_scale_chroma) as usize - ptr as usize
6077 },
6078 33usize,
6079 concat!(
6080 "Offset of field: ",
6081 stringify!(StdVideoH265PictureParameterSet),
6082 "::",
6083 stringify!(log2_sao_offset_scale_chroma)
6084 )
6085 );
6086 assert_eq!(
6087 unsafe { ::std::ptr::addr_of!((*ptr).pps_act_y_qp_offset_plus5) as usize - ptr as usize },
6088 34usize,
6089 concat!(
6090 "Offset of field: ",
6091 stringify!(StdVideoH265PictureParameterSet),
6092 "::",
6093 stringify!(pps_act_y_qp_offset_plus5)
6094 )
6095 );
6096 assert_eq!(
6097 unsafe { ::std::ptr::addr_of!((*ptr).pps_act_cb_qp_offset_plus5) as usize - ptr as usize },
6098 35usize,
6099 concat!(
6100 "Offset of field: ",
6101 stringify!(StdVideoH265PictureParameterSet),
6102 "::",
6103 stringify!(pps_act_cb_qp_offset_plus5)
6104 )
6105 );
6106 assert_eq!(
6107 unsafe { ::std::ptr::addr_of!((*ptr).pps_act_cr_qp_offset_plus3) as usize - ptr as usize },
6108 36usize,
6109 concat!(
6110 "Offset of field: ",
6111 stringify!(StdVideoH265PictureParameterSet),
6112 "::",
6113 stringify!(pps_act_cr_qp_offset_plus3)
6114 )
6115 );
6116 assert_eq!(
6117 unsafe {
6118 ::std::ptr::addr_of!((*ptr).pps_num_palette_predictor_initializers) as usize
6119 - ptr as usize
6120 },
6121 37usize,
6122 concat!(
6123 "Offset of field: ",
6124 stringify!(StdVideoH265PictureParameterSet),
6125 "::",
6126 stringify!(pps_num_palette_predictor_initializers)
6127 )
6128 );
6129 assert_eq!(
6130 unsafe { ::std::ptr::addr_of!((*ptr).luma_bit_depth_entry_minus8) as usize - ptr as usize },
6131 38usize,
6132 concat!(
6133 "Offset of field: ",
6134 stringify!(StdVideoH265PictureParameterSet),
6135 "::",
6136 stringify!(luma_bit_depth_entry_minus8)
6137 )
6138 );
6139 assert_eq!(
6140 unsafe {
6141 ::std::ptr::addr_of!((*ptr).chroma_bit_depth_entry_minus8) as usize - ptr as usize
6142 },
6143 39usize,
6144 concat!(
6145 "Offset of field: ",
6146 stringify!(StdVideoH265PictureParameterSet),
6147 "::",
6148 stringify!(chroma_bit_depth_entry_minus8)
6149 )
6150 );
6151 assert_eq!(
6152 unsafe { ::std::ptr::addr_of!((*ptr).num_tile_columns_minus1) as usize - ptr as usize },
6153 40usize,
6154 concat!(
6155 "Offset of field: ",
6156 stringify!(StdVideoH265PictureParameterSet),
6157 "::",
6158 stringify!(num_tile_columns_minus1)
6159 )
6160 );
6161 assert_eq!(
6162 unsafe { ::std::ptr::addr_of!((*ptr).num_tile_rows_minus1) as usize - ptr as usize },
6163 41usize,
6164 concat!(
6165 "Offset of field: ",
6166 stringify!(StdVideoH265PictureParameterSet),
6167 "::",
6168 stringify!(num_tile_rows_minus1)
6169 )
6170 );
6171 assert_eq!(
6172 unsafe { ::std::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize },
6173 42usize,
6174 concat!(
6175 "Offset of field: ",
6176 stringify!(StdVideoH265PictureParameterSet),
6177 "::",
6178 stringify!(reserved1)
6179 )
6180 );
6181 assert_eq!(
6182 unsafe { ::std::ptr::addr_of!((*ptr).reserved2) as usize - ptr as usize },
6183 43usize,
6184 concat!(
6185 "Offset of field: ",
6186 stringify!(StdVideoH265PictureParameterSet),
6187 "::",
6188 stringify!(reserved2)
6189 )
6190 );
6191 assert_eq!(
6192 unsafe { ::std::ptr::addr_of!((*ptr).column_width_minus1) as usize - ptr as usize },
6193 44usize,
6194 concat!(
6195 "Offset of field: ",
6196 stringify!(StdVideoH265PictureParameterSet),
6197 "::",
6198 stringify!(column_width_minus1)
6199 )
6200 );
6201 assert_eq!(
6202 unsafe { ::std::ptr::addr_of!((*ptr).row_height_minus1) as usize - ptr as usize },
6203 82usize,
6204 concat!(
6205 "Offset of field: ",
6206 stringify!(StdVideoH265PictureParameterSet),
6207 "::",
6208 stringify!(row_height_minus1)
6209 )
6210 );
6211 assert_eq!(
6212 unsafe { ::std::ptr::addr_of!((*ptr).reserved3) as usize - ptr as usize },
6213 124usize,
6214 concat!(
6215 "Offset of field: ",
6216 stringify!(StdVideoH265PictureParameterSet),
6217 "::",
6218 stringify!(reserved3)
6219 )
6220 );
6221 assert_eq!(
6222 unsafe { ::std::ptr::addr_of!((*ptr).pScalingLists) as usize - ptr as usize },
6223 128usize,
6224 concat!(
6225 "Offset of field: ",
6226 stringify!(StdVideoH265PictureParameterSet),
6227 "::",
6228 stringify!(pScalingLists)
6229 )
6230 );
6231 assert_eq!(
6232 unsafe { ::std::ptr::addr_of!((*ptr).pPredictorPaletteEntries) as usize - ptr as usize },
6233 136usize,
6234 concat!(
6235 "Offset of field: ",
6236 stringify!(StdVideoH265PictureParameterSet),
6237 "::",
6238 stringify!(pPredictorPaletteEntries)
6239 )
6240 );
6241}
6242#[repr(C)]
6243#[repr(align(4))]
6244#[derive(Debug, Copy, Clone)]
6245pub struct StdVideoDecodeH265PictureInfoFlags {
6246 pub _bitfield_align_1: [u8; 0],
6247 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
6248 pub __bindgen_padding_0: [u8; 3usize],
6249}
6250#[test]
6251fn bindgen_test_layout_StdVideoDecodeH265PictureInfoFlags() {
6252 assert_eq!(
6253 ::std::mem::size_of::<StdVideoDecodeH265PictureInfoFlags>(),
6254 4usize,
6255 concat!("Size of: ", stringify!(StdVideoDecodeH265PictureInfoFlags))
6256 );
6257 assert_eq!(
6258 ::std::mem::align_of::<StdVideoDecodeH265PictureInfoFlags>(),
6259 4usize,
6260 concat!(
6261 "Alignment of ",
6262 stringify!(StdVideoDecodeH265PictureInfoFlags)
6263 )
6264 );
6265}
6266impl StdVideoDecodeH265PictureInfoFlags {
6267 #[inline]
6268 pub fn IrapPicFlag(&self) -> u32 {
6269 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
6270 }
6271 #[inline]
6272 pub fn set_IrapPicFlag(&mut self, val: u32) {
6273 unsafe {
6274 let val: u32 = ::std::mem::transmute(val);
6275 self._bitfield_1.set(0usize, 1u8, val as u64)
6276 }
6277 }
6278 #[inline]
6279 pub fn IdrPicFlag(&self) -> u32 {
6280 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
6281 }
6282 #[inline]
6283 pub fn set_IdrPicFlag(&mut self, val: u32) {
6284 unsafe {
6285 let val: u32 = ::std::mem::transmute(val);
6286 self._bitfield_1.set(1usize, 1u8, val as u64)
6287 }
6288 }
6289 #[inline]
6290 pub fn IsReference(&self) -> u32 {
6291 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
6292 }
6293 #[inline]
6294 pub fn set_IsReference(&mut self, val: u32) {
6295 unsafe {
6296 let val: u32 = ::std::mem::transmute(val);
6297 self._bitfield_1.set(2usize, 1u8, val as u64)
6298 }
6299 }
6300 #[inline]
6301 pub fn short_term_ref_pic_set_sps_flag(&self) -> u32 {
6302 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
6303 }
6304 #[inline]
6305 pub fn set_short_term_ref_pic_set_sps_flag(&mut self, val: u32) {
6306 unsafe {
6307 let val: u32 = ::std::mem::transmute(val);
6308 self._bitfield_1.set(3usize, 1u8, val as u64)
6309 }
6310 }
6311 #[inline]
6312 pub fn new_bitfield_1(
6313 IrapPicFlag: u32,
6314 IdrPicFlag: u32,
6315 IsReference: u32,
6316 short_term_ref_pic_set_sps_flag: u32,
6317 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
6318 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
6319 __bindgen_bitfield_unit.set(0usize, 1u8, {
6320 let IrapPicFlag: u32 = unsafe { ::std::mem::transmute(IrapPicFlag) };
6321 IrapPicFlag as u64
6322 });
6323 __bindgen_bitfield_unit.set(1usize, 1u8, {
6324 let IdrPicFlag: u32 = unsafe { ::std::mem::transmute(IdrPicFlag) };
6325 IdrPicFlag as u64
6326 });
6327 __bindgen_bitfield_unit.set(2usize, 1u8, {
6328 let IsReference: u32 = unsafe { ::std::mem::transmute(IsReference) };
6329 IsReference as u64
6330 });
6331 __bindgen_bitfield_unit.set(3usize, 1u8, {
6332 let short_term_ref_pic_set_sps_flag: u32 =
6333 unsafe { ::std::mem::transmute(short_term_ref_pic_set_sps_flag) };
6334 short_term_ref_pic_set_sps_flag as u64
6335 });
6336 __bindgen_bitfield_unit
6337 }
6338}
6339#[repr(C)]
6340#[derive(Debug, Copy, Clone)]
6341pub struct StdVideoDecodeH265PictureInfo {
6342 pub flags: StdVideoDecodeH265PictureInfoFlags,
6343 pub sps_video_parameter_set_id: u8,
6344 pub pps_seq_parameter_set_id: u8,
6345 pub pps_pic_parameter_set_id: u8,
6346 pub NumDeltaPocsOfRefRpsIdx: u8,
6347 pub PicOrderCntVal: i32,
6348 pub NumBitsForSTRefPicSetInSlice: u16,
6349 pub reserved: u16,
6350 pub RefPicSetStCurrBefore: [u8; 8usize],
6351 pub RefPicSetStCurrAfter: [u8; 8usize],
6352 pub RefPicSetLtCurr: [u8; 8usize],
6353}
6354#[test]
6355fn bindgen_test_layout_StdVideoDecodeH265PictureInfo() {
6356 const UNINIT: ::std::mem::MaybeUninit<StdVideoDecodeH265PictureInfo> =
6357 ::std::mem::MaybeUninit::uninit();
6358 let ptr = UNINIT.as_ptr();
6359 assert_eq!(
6360 ::std::mem::size_of::<StdVideoDecodeH265PictureInfo>(),
6361 40usize,
6362 concat!("Size of: ", stringify!(StdVideoDecodeH265PictureInfo))
6363 );
6364 assert_eq!(
6365 ::std::mem::align_of::<StdVideoDecodeH265PictureInfo>(),
6366 4usize,
6367 concat!("Alignment of ", stringify!(StdVideoDecodeH265PictureInfo))
6368 );
6369 assert_eq!(
6370 unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
6371 0usize,
6372 concat!(
6373 "Offset of field: ",
6374 stringify!(StdVideoDecodeH265PictureInfo),
6375 "::",
6376 stringify!(flags)
6377 )
6378 );
6379 assert_eq!(
6380 unsafe { ::std::ptr::addr_of!((*ptr).sps_video_parameter_set_id) as usize - ptr as usize },
6381 4usize,
6382 concat!(
6383 "Offset of field: ",
6384 stringify!(StdVideoDecodeH265PictureInfo),
6385 "::",
6386 stringify!(sps_video_parameter_set_id)
6387 )
6388 );
6389 assert_eq!(
6390 unsafe { ::std::ptr::addr_of!((*ptr).pps_seq_parameter_set_id) as usize - ptr as usize },
6391 5usize,
6392 concat!(
6393 "Offset of field: ",
6394 stringify!(StdVideoDecodeH265PictureInfo),
6395 "::",
6396 stringify!(pps_seq_parameter_set_id)
6397 )
6398 );
6399 assert_eq!(
6400 unsafe { ::std::ptr::addr_of!((*ptr).pps_pic_parameter_set_id) as usize - ptr as usize },
6401 6usize,
6402 concat!(
6403 "Offset of field: ",
6404 stringify!(StdVideoDecodeH265PictureInfo),
6405 "::",
6406 stringify!(pps_pic_parameter_set_id)
6407 )
6408 );
6409 assert_eq!(
6410 unsafe { ::std::ptr::addr_of!((*ptr).NumDeltaPocsOfRefRpsIdx) as usize - ptr as usize },
6411 7usize,
6412 concat!(
6413 "Offset of field: ",
6414 stringify!(StdVideoDecodeH265PictureInfo),
6415 "::",
6416 stringify!(NumDeltaPocsOfRefRpsIdx)
6417 )
6418 );
6419 assert_eq!(
6420 unsafe { ::std::ptr::addr_of!((*ptr).PicOrderCntVal) as usize - ptr as usize },
6421 8usize,
6422 concat!(
6423 "Offset of field: ",
6424 stringify!(StdVideoDecodeH265PictureInfo),
6425 "::",
6426 stringify!(PicOrderCntVal)
6427 )
6428 );
6429 assert_eq!(
6430 unsafe {
6431 ::std::ptr::addr_of!((*ptr).NumBitsForSTRefPicSetInSlice) as usize - ptr as usize
6432 },
6433 12usize,
6434 concat!(
6435 "Offset of field: ",
6436 stringify!(StdVideoDecodeH265PictureInfo),
6437 "::",
6438 stringify!(NumBitsForSTRefPicSetInSlice)
6439 )
6440 );
6441 assert_eq!(
6442 unsafe { ::std::ptr::addr_of!((*ptr).reserved) as usize - ptr as usize },
6443 14usize,
6444 concat!(
6445 "Offset of field: ",
6446 stringify!(StdVideoDecodeH265PictureInfo),
6447 "::",
6448 stringify!(reserved)
6449 )
6450 );
6451 assert_eq!(
6452 unsafe { ::std::ptr::addr_of!((*ptr).RefPicSetStCurrBefore) as usize - ptr as usize },
6453 16usize,
6454 concat!(
6455 "Offset of field: ",
6456 stringify!(StdVideoDecodeH265PictureInfo),
6457 "::",
6458 stringify!(RefPicSetStCurrBefore)
6459 )
6460 );
6461 assert_eq!(
6462 unsafe { ::std::ptr::addr_of!((*ptr).RefPicSetStCurrAfter) as usize - ptr as usize },
6463 24usize,
6464 concat!(
6465 "Offset of field: ",
6466 stringify!(StdVideoDecodeH265PictureInfo),
6467 "::",
6468 stringify!(RefPicSetStCurrAfter)
6469 )
6470 );
6471 assert_eq!(
6472 unsafe { ::std::ptr::addr_of!((*ptr).RefPicSetLtCurr) as usize - ptr as usize },
6473 32usize,
6474 concat!(
6475 "Offset of field: ",
6476 stringify!(StdVideoDecodeH265PictureInfo),
6477 "::",
6478 stringify!(RefPicSetLtCurr)
6479 )
6480 );
6481}
6482#[repr(C)]
6483#[repr(align(4))]
6484#[derive(Debug, Copy, Clone)]
6485pub struct StdVideoDecodeH265ReferenceInfoFlags {
6486 pub _bitfield_align_1: [u8; 0],
6487 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
6488 pub __bindgen_padding_0: [u8; 3usize],
6489}
6490#[test]
6491fn bindgen_test_layout_StdVideoDecodeH265ReferenceInfoFlags() {
6492 assert_eq!(
6493 ::std::mem::size_of::<StdVideoDecodeH265ReferenceInfoFlags>(),
6494 4usize,
6495 concat!(
6496 "Size of: ",
6497 stringify!(StdVideoDecodeH265ReferenceInfoFlags)
6498 )
6499 );
6500 assert_eq!(
6501 ::std::mem::align_of::<StdVideoDecodeH265ReferenceInfoFlags>(),
6502 4usize,
6503 concat!(
6504 "Alignment of ",
6505 stringify!(StdVideoDecodeH265ReferenceInfoFlags)
6506 )
6507 );
6508}
6509impl StdVideoDecodeH265ReferenceInfoFlags {
6510 #[inline]
6511 pub fn used_for_long_term_reference(&self) -> u32 {
6512 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
6513 }
6514 #[inline]
6515 pub fn set_used_for_long_term_reference(&mut self, val: u32) {
6516 unsafe {
6517 let val: u32 = ::std::mem::transmute(val);
6518 self._bitfield_1.set(0usize, 1u8, val as u64)
6519 }
6520 }
6521 #[inline]
6522 pub fn unused_for_reference(&self) -> u32 {
6523 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
6524 }
6525 #[inline]
6526 pub fn set_unused_for_reference(&mut self, val: u32) {
6527 unsafe {
6528 let val: u32 = ::std::mem::transmute(val);
6529 self._bitfield_1.set(1usize, 1u8, val as u64)
6530 }
6531 }
6532 #[inline]
6533 pub fn new_bitfield_1(
6534 used_for_long_term_reference: u32,
6535 unused_for_reference: u32,
6536 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
6537 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
6538 __bindgen_bitfield_unit.set(0usize, 1u8, {
6539 let used_for_long_term_reference: u32 =
6540 unsafe { ::std::mem::transmute(used_for_long_term_reference) };
6541 used_for_long_term_reference as u64
6542 });
6543 __bindgen_bitfield_unit.set(1usize, 1u8, {
6544 let unused_for_reference: u32 = unsafe { ::std::mem::transmute(unused_for_reference) };
6545 unused_for_reference as u64
6546 });
6547 __bindgen_bitfield_unit
6548 }
6549}
6550#[repr(C)]
6551#[derive(Debug, Copy, Clone)]
6552pub struct StdVideoDecodeH265ReferenceInfo {
6553 pub flags: StdVideoDecodeH265ReferenceInfoFlags,
6554 pub PicOrderCntVal: i32,
6555}
6556#[test]
6557fn bindgen_test_layout_StdVideoDecodeH265ReferenceInfo() {
6558 const UNINIT: ::std::mem::MaybeUninit<StdVideoDecodeH265ReferenceInfo> =
6559 ::std::mem::MaybeUninit::uninit();
6560 let ptr = UNINIT.as_ptr();
6561 assert_eq!(
6562 ::std::mem::size_of::<StdVideoDecodeH265ReferenceInfo>(),
6563 8usize,
6564 concat!("Size of: ", stringify!(StdVideoDecodeH265ReferenceInfo))
6565 );
6566 assert_eq!(
6567 ::std::mem::align_of::<StdVideoDecodeH265ReferenceInfo>(),
6568 4usize,
6569 concat!("Alignment of ", stringify!(StdVideoDecodeH265ReferenceInfo))
6570 );
6571 assert_eq!(
6572 unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
6573 0usize,
6574 concat!(
6575 "Offset of field: ",
6576 stringify!(StdVideoDecodeH265ReferenceInfo),
6577 "::",
6578 stringify!(flags)
6579 )
6580 );
6581 assert_eq!(
6582 unsafe { ::std::ptr::addr_of!((*ptr).PicOrderCntVal) as usize - ptr as usize },
6583 4usize,
6584 concat!(
6585 "Offset of field: ",
6586 stringify!(StdVideoDecodeH265ReferenceInfo),
6587 "::",
6588 stringify!(PicOrderCntVal)
6589 )
6590 );
6591}
6592#[repr(C)]
6593#[derive(Debug, Copy, Clone)]
6594pub struct StdVideoEncodeH264WeightTableFlags {
6595 pub luma_weight_l0_flag: u32,
6596 pub chroma_weight_l0_flag: u32,
6597 pub luma_weight_l1_flag: u32,
6598 pub chroma_weight_l1_flag: u32,
6599}
6600#[test]
6601fn bindgen_test_layout_StdVideoEncodeH264WeightTableFlags() {
6602 const UNINIT: ::std::mem::MaybeUninit<StdVideoEncodeH264WeightTableFlags> =
6603 ::std::mem::MaybeUninit::uninit();
6604 let ptr = UNINIT.as_ptr();
6605 assert_eq!(
6606 ::std::mem::size_of::<StdVideoEncodeH264WeightTableFlags>(),
6607 16usize,
6608 concat!("Size of: ", stringify!(StdVideoEncodeH264WeightTableFlags))
6609 );
6610 assert_eq!(
6611 ::std::mem::align_of::<StdVideoEncodeH264WeightTableFlags>(),
6612 4usize,
6613 concat!(
6614 "Alignment of ",
6615 stringify!(StdVideoEncodeH264WeightTableFlags)
6616 )
6617 );
6618 assert_eq!(
6619 unsafe { ::std::ptr::addr_of!((*ptr).luma_weight_l0_flag) as usize - ptr as usize },
6620 0usize,
6621 concat!(
6622 "Offset of field: ",
6623 stringify!(StdVideoEncodeH264WeightTableFlags),
6624 "::",
6625 stringify!(luma_weight_l0_flag)
6626 )
6627 );
6628 assert_eq!(
6629 unsafe { ::std::ptr::addr_of!((*ptr).chroma_weight_l0_flag) as usize - ptr as usize },
6630 4usize,
6631 concat!(
6632 "Offset of field: ",
6633 stringify!(StdVideoEncodeH264WeightTableFlags),
6634 "::",
6635 stringify!(chroma_weight_l0_flag)
6636 )
6637 );
6638 assert_eq!(
6639 unsafe { ::std::ptr::addr_of!((*ptr).luma_weight_l1_flag) as usize - ptr as usize },
6640 8usize,
6641 concat!(
6642 "Offset of field: ",
6643 stringify!(StdVideoEncodeH264WeightTableFlags),
6644 "::",
6645 stringify!(luma_weight_l1_flag)
6646 )
6647 );
6648 assert_eq!(
6649 unsafe { ::std::ptr::addr_of!((*ptr).chroma_weight_l1_flag) as usize - ptr as usize },
6650 12usize,
6651 concat!(
6652 "Offset of field: ",
6653 stringify!(StdVideoEncodeH264WeightTableFlags),
6654 "::",
6655 stringify!(chroma_weight_l1_flag)
6656 )
6657 );
6658}
6659#[repr(C)]
6660#[derive(Debug, Copy, Clone)]
6661pub struct StdVideoEncodeH264WeightTable {
6662 pub flags: StdVideoEncodeH264WeightTableFlags,
6663 pub luma_log2_weight_denom: u8,
6664 pub chroma_log2_weight_denom: u8,
6665 pub luma_weight_l0: [i8; 32usize],
6666 pub luma_offset_l0: [i8; 32usize],
6667 pub chroma_weight_l0: [[i8; 2usize]; 32usize],
6668 pub chroma_offset_l0: [[i8; 2usize]; 32usize],
6669 pub luma_weight_l1: [i8; 32usize],
6670 pub luma_offset_l1: [i8; 32usize],
6671 pub chroma_weight_l1: [[i8; 2usize]; 32usize],
6672 pub chroma_offset_l1: [[i8; 2usize]; 32usize],
6673}
6674#[test]
6675fn bindgen_test_layout_StdVideoEncodeH264WeightTable() {
6676 const UNINIT: ::std::mem::MaybeUninit<StdVideoEncodeH264WeightTable> =
6677 ::std::mem::MaybeUninit::uninit();
6678 let ptr = UNINIT.as_ptr();
6679 assert_eq!(
6680 ::std::mem::size_of::<StdVideoEncodeH264WeightTable>(),
6681 404usize,
6682 concat!("Size of: ", stringify!(StdVideoEncodeH264WeightTable))
6683 );
6684 assert_eq!(
6685 ::std::mem::align_of::<StdVideoEncodeH264WeightTable>(),
6686 4usize,
6687 concat!("Alignment of ", stringify!(StdVideoEncodeH264WeightTable))
6688 );
6689 assert_eq!(
6690 unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
6691 0usize,
6692 concat!(
6693 "Offset of field: ",
6694 stringify!(StdVideoEncodeH264WeightTable),
6695 "::",
6696 stringify!(flags)
6697 )
6698 );
6699 assert_eq!(
6700 unsafe { ::std::ptr::addr_of!((*ptr).luma_log2_weight_denom) as usize - ptr as usize },
6701 16usize,
6702 concat!(
6703 "Offset of field: ",
6704 stringify!(StdVideoEncodeH264WeightTable),
6705 "::",
6706 stringify!(luma_log2_weight_denom)
6707 )
6708 );
6709 assert_eq!(
6710 unsafe { ::std::ptr::addr_of!((*ptr).chroma_log2_weight_denom) as usize - ptr as usize },
6711 17usize,
6712 concat!(
6713 "Offset of field: ",
6714 stringify!(StdVideoEncodeH264WeightTable),
6715 "::",
6716 stringify!(chroma_log2_weight_denom)
6717 )
6718 );
6719 assert_eq!(
6720 unsafe { ::std::ptr::addr_of!((*ptr).luma_weight_l0) as usize - ptr as usize },
6721 18usize,
6722 concat!(
6723 "Offset of field: ",
6724 stringify!(StdVideoEncodeH264WeightTable),
6725 "::",
6726 stringify!(luma_weight_l0)
6727 )
6728 );
6729 assert_eq!(
6730 unsafe { ::std::ptr::addr_of!((*ptr).luma_offset_l0) as usize - ptr as usize },
6731 50usize,
6732 concat!(
6733 "Offset of field: ",
6734 stringify!(StdVideoEncodeH264WeightTable),
6735 "::",
6736 stringify!(luma_offset_l0)
6737 )
6738 );
6739 assert_eq!(
6740 unsafe { ::std::ptr::addr_of!((*ptr).chroma_weight_l0) as usize - ptr as usize },
6741 82usize,
6742 concat!(
6743 "Offset of field: ",
6744 stringify!(StdVideoEncodeH264WeightTable),
6745 "::",
6746 stringify!(chroma_weight_l0)
6747 )
6748 );
6749 assert_eq!(
6750 unsafe { ::std::ptr::addr_of!((*ptr).chroma_offset_l0) as usize - ptr as usize },
6751 146usize,
6752 concat!(
6753 "Offset of field: ",
6754 stringify!(StdVideoEncodeH264WeightTable),
6755 "::",
6756 stringify!(chroma_offset_l0)
6757 )
6758 );
6759 assert_eq!(
6760 unsafe { ::std::ptr::addr_of!((*ptr).luma_weight_l1) as usize - ptr as usize },
6761 210usize,
6762 concat!(
6763 "Offset of field: ",
6764 stringify!(StdVideoEncodeH264WeightTable),
6765 "::",
6766 stringify!(luma_weight_l1)
6767 )
6768 );
6769 assert_eq!(
6770 unsafe { ::std::ptr::addr_of!((*ptr).luma_offset_l1) as usize - ptr as usize },
6771 242usize,
6772 concat!(
6773 "Offset of field: ",
6774 stringify!(StdVideoEncodeH264WeightTable),
6775 "::",
6776 stringify!(luma_offset_l1)
6777 )
6778 );
6779 assert_eq!(
6780 unsafe { ::std::ptr::addr_of!((*ptr).chroma_weight_l1) as usize - ptr as usize },
6781 274usize,
6782 concat!(
6783 "Offset of field: ",
6784 stringify!(StdVideoEncodeH264WeightTable),
6785 "::",
6786 stringify!(chroma_weight_l1)
6787 )
6788 );
6789 assert_eq!(
6790 unsafe { ::std::ptr::addr_of!((*ptr).chroma_offset_l1) as usize - ptr as usize },
6791 338usize,
6792 concat!(
6793 "Offset of field: ",
6794 stringify!(StdVideoEncodeH264WeightTable),
6795 "::",
6796 stringify!(chroma_offset_l1)
6797 )
6798 );
6799}
6800#[repr(C)]
6801#[repr(align(4))]
6802#[derive(Debug, Copy, Clone)]
6803pub struct StdVideoEncodeH264SliceHeaderFlags {
6804 pub _bitfield_align_1: [u8; 0],
6805 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
6806 pub __bindgen_padding_0: [u8; 3usize],
6807}
6808#[test]
6809fn bindgen_test_layout_StdVideoEncodeH264SliceHeaderFlags() {
6810 assert_eq!(
6811 ::std::mem::size_of::<StdVideoEncodeH264SliceHeaderFlags>(),
6812 4usize,
6813 concat!("Size of: ", stringify!(StdVideoEncodeH264SliceHeaderFlags))
6814 );
6815 assert_eq!(
6816 ::std::mem::align_of::<StdVideoEncodeH264SliceHeaderFlags>(),
6817 4usize,
6818 concat!(
6819 "Alignment of ",
6820 stringify!(StdVideoEncodeH264SliceHeaderFlags)
6821 )
6822 );
6823}
6824impl StdVideoEncodeH264SliceHeaderFlags {
6825 #[inline]
6826 pub fn direct_spatial_mv_pred_flag(&self) -> u32 {
6827 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
6828 }
6829 #[inline]
6830 pub fn set_direct_spatial_mv_pred_flag(&mut self, val: u32) {
6831 unsafe {
6832 let val: u32 = ::std::mem::transmute(val);
6833 self._bitfield_1.set(0usize, 1u8, val as u64)
6834 }
6835 }
6836 #[inline]
6837 pub fn num_ref_idx_active_override_flag(&self) -> u32 {
6838 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
6839 }
6840 #[inline]
6841 pub fn set_num_ref_idx_active_override_flag(&mut self, val: u32) {
6842 unsafe {
6843 let val: u32 = ::std::mem::transmute(val);
6844 self._bitfield_1.set(1usize, 1u8, val as u64)
6845 }
6846 }
6847 #[inline]
6848 pub fn no_output_of_prior_pics_flag(&self) -> u32 {
6849 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
6850 }
6851 #[inline]
6852 pub fn set_no_output_of_prior_pics_flag(&mut self, val: u32) {
6853 unsafe {
6854 let val: u32 = ::std::mem::transmute(val);
6855 self._bitfield_1.set(2usize, 1u8, val as u64)
6856 }
6857 }
6858 #[inline]
6859 pub fn adaptive_ref_pic_marking_mode_flag(&self) -> u32 {
6860 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
6861 }
6862 #[inline]
6863 pub fn set_adaptive_ref_pic_marking_mode_flag(&mut self, val: u32) {
6864 unsafe {
6865 let val: u32 = ::std::mem::transmute(val);
6866 self._bitfield_1.set(3usize, 1u8, val as u64)
6867 }
6868 }
6869 #[inline]
6870 pub fn no_prior_references_available_flag(&self) -> u32 {
6871 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
6872 }
6873 #[inline]
6874 pub fn set_no_prior_references_available_flag(&mut self, val: u32) {
6875 unsafe {
6876 let val: u32 = ::std::mem::transmute(val);
6877 self._bitfield_1.set(4usize, 1u8, val as u64)
6878 }
6879 }
6880 #[inline]
6881 pub fn new_bitfield_1(
6882 direct_spatial_mv_pred_flag: u32,
6883 num_ref_idx_active_override_flag: u32,
6884 no_output_of_prior_pics_flag: u32,
6885 adaptive_ref_pic_marking_mode_flag: u32,
6886 no_prior_references_available_flag: u32,
6887 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
6888 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
6889 __bindgen_bitfield_unit.set(0usize, 1u8, {
6890 let direct_spatial_mv_pred_flag: u32 =
6891 unsafe { ::std::mem::transmute(direct_spatial_mv_pred_flag) };
6892 direct_spatial_mv_pred_flag as u64
6893 });
6894 __bindgen_bitfield_unit.set(1usize, 1u8, {
6895 let num_ref_idx_active_override_flag: u32 =
6896 unsafe { ::std::mem::transmute(num_ref_idx_active_override_flag) };
6897 num_ref_idx_active_override_flag as u64
6898 });
6899 __bindgen_bitfield_unit.set(2usize, 1u8, {
6900 let no_output_of_prior_pics_flag: u32 =
6901 unsafe { ::std::mem::transmute(no_output_of_prior_pics_flag) };
6902 no_output_of_prior_pics_flag as u64
6903 });
6904 __bindgen_bitfield_unit.set(3usize, 1u8, {
6905 let adaptive_ref_pic_marking_mode_flag: u32 =
6906 unsafe { ::std::mem::transmute(adaptive_ref_pic_marking_mode_flag) };
6907 adaptive_ref_pic_marking_mode_flag as u64
6908 });
6909 __bindgen_bitfield_unit.set(4usize, 1u8, {
6910 let no_prior_references_available_flag: u32 =
6911 unsafe { ::std::mem::transmute(no_prior_references_available_flag) };
6912 no_prior_references_available_flag as u64
6913 });
6914 __bindgen_bitfield_unit
6915 }
6916}
6917#[repr(C)]
6918#[repr(align(4))]
6919#[derive(Debug, Copy, Clone)]
6920pub struct StdVideoEncodeH264PictureInfoFlags {
6921 pub _bitfield_align_1: [u8; 0],
6922 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
6923 pub __bindgen_padding_0: [u8; 3usize],
6924}
6925#[test]
6926fn bindgen_test_layout_StdVideoEncodeH264PictureInfoFlags() {
6927 assert_eq!(
6928 ::std::mem::size_of::<StdVideoEncodeH264PictureInfoFlags>(),
6929 4usize,
6930 concat!("Size of: ", stringify!(StdVideoEncodeH264PictureInfoFlags))
6931 );
6932 assert_eq!(
6933 ::std::mem::align_of::<StdVideoEncodeH264PictureInfoFlags>(),
6934 4usize,
6935 concat!(
6936 "Alignment of ",
6937 stringify!(StdVideoEncodeH264PictureInfoFlags)
6938 )
6939 );
6940}
6941impl StdVideoEncodeH264PictureInfoFlags {
6942 #[inline]
6943 pub fn idr_flag(&self) -> u32 {
6944 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
6945 }
6946 #[inline]
6947 pub fn set_idr_flag(&mut self, val: u32) {
6948 unsafe {
6949 let val: u32 = ::std::mem::transmute(val);
6950 self._bitfield_1.set(0usize, 1u8, val as u64)
6951 }
6952 }
6953 #[inline]
6954 pub fn is_reference_flag(&self) -> u32 {
6955 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
6956 }
6957 #[inline]
6958 pub fn set_is_reference_flag(&mut self, val: u32) {
6959 unsafe {
6960 let val: u32 = ::std::mem::transmute(val);
6961 self._bitfield_1.set(1usize, 1u8, val as u64)
6962 }
6963 }
6964 #[inline]
6965 pub fn used_for_long_term_reference(&self) -> u32 {
6966 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
6967 }
6968 #[inline]
6969 pub fn set_used_for_long_term_reference(&mut self, val: u32) {
6970 unsafe {
6971 let val: u32 = ::std::mem::transmute(val);
6972 self._bitfield_1.set(2usize, 1u8, val as u64)
6973 }
6974 }
6975 #[inline]
6976 pub fn new_bitfield_1(
6977 idr_flag: u32,
6978 is_reference_flag: u32,
6979 used_for_long_term_reference: u32,
6980 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
6981 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
6982 __bindgen_bitfield_unit.set(0usize, 1u8, {
6983 let idr_flag: u32 = unsafe { ::std::mem::transmute(idr_flag) };
6984 idr_flag as u64
6985 });
6986 __bindgen_bitfield_unit.set(1usize, 1u8, {
6987 let is_reference_flag: u32 = unsafe { ::std::mem::transmute(is_reference_flag) };
6988 is_reference_flag as u64
6989 });
6990 __bindgen_bitfield_unit.set(2usize, 1u8, {
6991 let used_for_long_term_reference: u32 =
6992 unsafe { ::std::mem::transmute(used_for_long_term_reference) };
6993 used_for_long_term_reference as u64
6994 });
6995 __bindgen_bitfield_unit
6996 }
6997}
6998#[repr(C)]
6999#[repr(align(4))]
7000#[derive(Debug, Copy, Clone)]
7001pub struct StdVideoEncodeH264ReferenceInfoFlags {
7002 pub _bitfield_align_1: [u8; 0],
7003 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
7004 pub __bindgen_padding_0: [u8; 3usize],
7005}
7006#[test]
7007fn bindgen_test_layout_StdVideoEncodeH264ReferenceInfoFlags() {
7008 assert_eq!(
7009 ::std::mem::size_of::<StdVideoEncodeH264ReferenceInfoFlags>(),
7010 4usize,
7011 concat!(
7012 "Size of: ",
7013 stringify!(StdVideoEncodeH264ReferenceInfoFlags)
7014 )
7015 );
7016 assert_eq!(
7017 ::std::mem::align_of::<StdVideoEncodeH264ReferenceInfoFlags>(),
7018 4usize,
7019 concat!(
7020 "Alignment of ",
7021 stringify!(StdVideoEncodeH264ReferenceInfoFlags)
7022 )
7023 );
7024}
7025impl StdVideoEncodeH264ReferenceInfoFlags {
7026 #[inline]
7027 pub fn used_for_long_term_reference(&self) -> u32 {
7028 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
7029 }
7030 #[inline]
7031 pub fn set_used_for_long_term_reference(&mut self, val: u32) {
7032 unsafe {
7033 let val: u32 = ::std::mem::transmute(val);
7034 self._bitfield_1.set(0usize, 1u8, val as u64)
7035 }
7036 }
7037 #[inline]
7038 pub fn new_bitfield_1(
7039 used_for_long_term_reference: u32,
7040 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
7041 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
7042 __bindgen_bitfield_unit.set(0usize, 1u8, {
7043 let used_for_long_term_reference: u32 =
7044 unsafe { ::std::mem::transmute(used_for_long_term_reference) };
7045 used_for_long_term_reference as u64
7046 });
7047 __bindgen_bitfield_unit
7048 }
7049}
7050#[repr(C)]
7051#[repr(align(4))]
7052#[derive(Debug, Copy, Clone)]
7053pub struct StdVideoEncodeH264ReferenceListsInfoFlags {
7054 pub _bitfield_align_1: [u8; 0],
7055 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
7056 pub __bindgen_padding_0: [u8; 3usize],
7057}
7058#[test]
7059fn bindgen_test_layout_StdVideoEncodeH264ReferenceListsInfoFlags() {
7060 assert_eq!(
7061 ::std::mem::size_of::<StdVideoEncodeH264ReferenceListsInfoFlags>(),
7062 4usize,
7063 concat!(
7064 "Size of: ",
7065 stringify!(StdVideoEncodeH264ReferenceListsInfoFlags)
7066 )
7067 );
7068 assert_eq!(
7069 ::std::mem::align_of::<StdVideoEncodeH264ReferenceListsInfoFlags>(),
7070 4usize,
7071 concat!(
7072 "Alignment of ",
7073 stringify!(StdVideoEncodeH264ReferenceListsInfoFlags)
7074 )
7075 );
7076}
7077impl StdVideoEncodeH264ReferenceListsInfoFlags {
7078 #[inline]
7079 pub fn ref_pic_list_modification_flag_l0(&self) -> u32 {
7080 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
7081 }
7082 #[inline]
7083 pub fn set_ref_pic_list_modification_flag_l0(&mut self, val: u32) {
7084 unsafe {
7085 let val: u32 = ::std::mem::transmute(val);
7086 self._bitfield_1.set(0usize, 1u8, val as u64)
7087 }
7088 }
7089 #[inline]
7090 pub fn ref_pic_list_modification_flag_l1(&self) -> u32 {
7091 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
7092 }
7093 #[inline]
7094 pub fn set_ref_pic_list_modification_flag_l1(&mut self, val: u32) {
7095 unsafe {
7096 let val: u32 = ::std::mem::transmute(val);
7097 self._bitfield_1.set(1usize, 1u8, val as u64)
7098 }
7099 }
7100 #[inline]
7101 pub fn new_bitfield_1(
7102 ref_pic_list_modification_flag_l0: u32,
7103 ref_pic_list_modification_flag_l1: u32,
7104 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
7105 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
7106 __bindgen_bitfield_unit.set(0usize, 1u8, {
7107 let ref_pic_list_modification_flag_l0: u32 =
7108 unsafe { ::std::mem::transmute(ref_pic_list_modification_flag_l0) };
7109 ref_pic_list_modification_flag_l0 as u64
7110 });
7111 __bindgen_bitfield_unit.set(1usize, 1u8, {
7112 let ref_pic_list_modification_flag_l1: u32 =
7113 unsafe { ::std::mem::transmute(ref_pic_list_modification_flag_l1) };
7114 ref_pic_list_modification_flag_l1 as u64
7115 });
7116 __bindgen_bitfield_unit
7117 }
7118}
7119#[repr(C)]
7120#[derive(Debug, Copy, Clone)]
7121pub struct StdVideoEncodeH264RefListModEntry {
7122 pub modification_of_pic_nums_idc: StdVideoH264ModificationOfPicNumsIdc,
7123 pub abs_diff_pic_num_minus1: u16,
7124 pub long_term_pic_num: u16,
7125}
7126#[test]
7127fn bindgen_test_layout_StdVideoEncodeH264RefListModEntry() {
7128 const UNINIT: ::std::mem::MaybeUninit<StdVideoEncodeH264RefListModEntry> =
7129 ::std::mem::MaybeUninit::uninit();
7130 let ptr = UNINIT.as_ptr();
7131 assert_eq!(
7132 ::std::mem::size_of::<StdVideoEncodeH264RefListModEntry>(),
7133 8usize,
7134 concat!("Size of: ", stringify!(StdVideoEncodeH264RefListModEntry))
7135 );
7136 assert_eq!(
7137 ::std::mem::align_of::<StdVideoEncodeH264RefListModEntry>(),
7138 4usize,
7139 concat!(
7140 "Alignment of ",
7141 stringify!(StdVideoEncodeH264RefListModEntry)
7142 )
7143 );
7144 assert_eq!(
7145 unsafe {
7146 ::std::ptr::addr_of!((*ptr).modification_of_pic_nums_idc) as usize - ptr as usize
7147 },
7148 0usize,
7149 concat!(
7150 "Offset of field: ",
7151 stringify!(StdVideoEncodeH264RefListModEntry),
7152 "::",
7153 stringify!(modification_of_pic_nums_idc)
7154 )
7155 );
7156 assert_eq!(
7157 unsafe { ::std::ptr::addr_of!((*ptr).abs_diff_pic_num_minus1) as usize - ptr as usize },
7158 4usize,
7159 concat!(
7160 "Offset of field: ",
7161 stringify!(StdVideoEncodeH264RefListModEntry),
7162 "::",
7163 stringify!(abs_diff_pic_num_minus1)
7164 )
7165 );
7166 assert_eq!(
7167 unsafe { ::std::ptr::addr_of!((*ptr).long_term_pic_num) as usize - ptr as usize },
7168 6usize,
7169 concat!(
7170 "Offset of field: ",
7171 stringify!(StdVideoEncodeH264RefListModEntry),
7172 "::",
7173 stringify!(long_term_pic_num)
7174 )
7175 );
7176}
7177#[repr(C)]
7178#[derive(Debug, Copy, Clone)]
7179pub struct StdVideoEncodeH264RefPicMarkingEntry {
7180 pub operation: StdVideoH264MemMgmtControlOp,
7181 pub difference_of_pic_nums_minus1: u16,
7182 pub long_term_pic_num: u16,
7183 pub long_term_frame_idx: u16,
7184 pub max_long_term_frame_idx_plus1: u16,
7185}
7186#[test]
7187fn bindgen_test_layout_StdVideoEncodeH264RefPicMarkingEntry() {
7188 const UNINIT: ::std::mem::MaybeUninit<StdVideoEncodeH264RefPicMarkingEntry> =
7189 ::std::mem::MaybeUninit::uninit();
7190 let ptr = UNINIT.as_ptr();
7191 assert_eq!(
7192 ::std::mem::size_of::<StdVideoEncodeH264RefPicMarkingEntry>(),
7193 12usize,
7194 concat!(
7195 "Size of: ",
7196 stringify!(StdVideoEncodeH264RefPicMarkingEntry)
7197 )
7198 );
7199 assert_eq!(
7200 ::std::mem::align_of::<StdVideoEncodeH264RefPicMarkingEntry>(),
7201 4usize,
7202 concat!(
7203 "Alignment of ",
7204 stringify!(StdVideoEncodeH264RefPicMarkingEntry)
7205 )
7206 );
7207 assert_eq!(
7208 unsafe { ::std::ptr::addr_of!((*ptr).operation) as usize - ptr as usize },
7209 0usize,
7210 concat!(
7211 "Offset of field: ",
7212 stringify!(StdVideoEncodeH264RefPicMarkingEntry),
7213 "::",
7214 stringify!(operation)
7215 )
7216 );
7217 assert_eq!(
7218 unsafe {
7219 ::std::ptr::addr_of!((*ptr).difference_of_pic_nums_minus1) as usize - ptr as usize
7220 },
7221 4usize,
7222 concat!(
7223 "Offset of field: ",
7224 stringify!(StdVideoEncodeH264RefPicMarkingEntry),
7225 "::",
7226 stringify!(difference_of_pic_nums_minus1)
7227 )
7228 );
7229 assert_eq!(
7230 unsafe { ::std::ptr::addr_of!((*ptr).long_term_pic_num) as usize - ptr as usize },
7231 6usize,
7232 concat!(
7233 "Offset of field: ",
7234 stringify!(StdVideoEncodeH264RefPicMarkingEntry),
7235 "::",
7236 stringify!(long_term_pic_num)
7237 )
7238 );
7239 assert_eq!(
7240 unsafe { ::std::ptr::addr_of!((*ptr).long_term_frame_idx) as usize - ptr as usize },
7241 8usize,
7242 concat!(
7243 "Offset of field: ",
7244 stringify!(StdVideoEncodeH264RefPicMarkingEntry),
7245 "::",
7246 stringify!(long_term_frame_idx)
7247 )
7248 );
7249 assert_eq!(
7250 unsafe {
7251 ::std::ptr::addr_of!((*ptr).max_long_term_frame_idx_plus1) as usize - ptr as usize
7252 },
7253 10usize,
7254 concat!(
7255 "Offset of field: ",
7256 stringify!(StdVideoEncodeH264RefPicMarkingEntry),
7257 "::",
7258 stringify!(max_long_term_frame_idx_plus1)
7259 )
7260 );
7261}
7262#[repr(C)]
7263#[derive(Debug, Copy, Clone)]
7264pub struct StdVideoEncodeH264ReferenceListsInfo {
7265 pub flags: StdVideoEncodeH264ReferenceListsInfoFlags,
7266 pub refPicList0EntryCount: u8,
7267 pub refPicList1EntryCount: u8,
7268 pub refList0ModOpCount: u8,
7269 pub refList1ModOpCount: u8,
7270 pub refPicMarkingOpCount: u8,
7271 pub reserved1: [u8; 7usize],
7272 pub pRefPicList0Entries: *const u8,
7273 pub pRefPicList1Entries: *const u8,
7274 pub pRefList0ModOperations: *const StdVideoEncodeH264RefListModEntry,
7275 pub pRefList1ModOperations: *const StdVideoEncodeH264RefListModEntry,
7276 pub pRefPicMarkingOperations: *const StdVideoEncodeH264RefPicMarkingEntry,
7277}
7278#[test]
7279fn bindgen_test_layout_StdVideoEncodeH264ReferenceListsInfo() {
7280 const UNINIT: ::std::mem::MaybeUninit<StdVideoEncodeH264ReferenceListsInfo> =
7281 ::std::mem::MaybeUninit::uninit();
7282 let ptr = UNINIT.as_ptr();
7283 assert_eq!(
7284 ::std::mem::size_of::<StdVideoEncodeH264ReferenceListsInfo>(),
7285 56usize,
7286 concat!(
7287 "Size of: ",
7288 stringify!(StdVideoEncodeH264ReferenceListsInfo)
7289 )
7290 );
7291 assert_eq!(
7292 ::std::mem::align_of::<StdVideoEncodeH264ReferenceListsInfo>(),
7293 8usize,
7294 concat!(
7295 "Alignment of ",
7296 stringify!(StdVideoEncodeH264ReferenceListsInfo)
7297 )
7298 );
7299 assert_eq!(
7300 unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
7301 0usize,
7302 concat!(
7303 "Offset of field: ",
7304 stringify!(StdVideoEncodeH264ReferenceListsInfo),
7305 "::",
7306 stringify!(flags)
7307 )
7308 );
7309 assert_eq!(
7310 unsafe { ::std::ptr::addr_of!((*ptr).refPicList0EntryCount) as usize - ptr as usize },
7311 4usize,
7312 concat!(
7313 "Offset of field: ",
7314 stringify!(StdVideoEncodeH264ReferenceListsInfo),
7315 "::",
7316 stringify!(refPicList0EntryCount)
7317 )
7318 );
7319 assert_eq!(
7320 unsafe { ::std::ptr::addr_of!((*ptr).refPicList1EntryCount) as usize - ptr as usize },
7321 5usize,
7322 concat!(
7323 "Offset of field: ",
7324 stringify!(StdVideoEncodeH264ReferenceListsInfo),
7325 "::",
7326 stringify!(refPicList1EntryCount)
7327 )
7328 );
7329 assert_eq!(
7330 unsafe { ::std::ptr::addr_of!((*ptr).refList0ModOpCount) as usize - ptr as usize },
7331 6usize,
7332 concat!(
7333 "Offset of field: ",
7334 stringify!(StdVideoEncodeH264ReferenceListsInfo),
7335 "::",
7336 stringify!(refList0ModOpCount)
7337 )
7338 );
7339 assert_eq!(
7340 unsafe { ::std::ptr::addr_of!((*ptr).refList1ModOpCount) as usize - ptr as usize },
7341 7usize,
7342 concat!(
7343 "Offset of field: ",
7344 stringify!(StdVideoEncodeH264ReferenceListsInfo),
7345 "::",
7346 stringify!(refList1ModOpCount)
7347 )
7348 );
7349 assert_eq!(
7350 unsafe { ::std::ptr::addr_of!((*ptr).refPicMarkingOpCount) as usize - ptr as usize },
7351 8usize,
7352 concat!(
7353 "Offset of field: ",
7354 stringify!(StdVideoEncodeH264ReferenceListsInfo),
7355 "::",
7356 stringify!(refPicMarkingOpCount)
7357 )
7358 );
7359 assert_eq!(
7360 unsafe { ::std::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize },
7361 9usize,
7362 concat!(
7363 "Offset of field: ",
7364 stringify!(StdVideoEncodeH264ReferenceListsInfo),
7365 "::",
7366 stringify!(reserved1)
7367 )
7368 );
7369 assert_eq!(
7370 unsafe { ::std::ptr::addr_of!((*ptr).pRefPicList0Entries) as usize - ptr as usize },
7371 16usize,
7372 concat!(
7373 "Offset of field: ",
7374 stringify!(StdVideoEncodeH264ReferenceListsInfo),
7375 "::",
7376 stringify!(pRefPicList0Entries)
7377 )
7378 );
7379 assert_eq!(
7380 unsafe { ::std::ptr::addr_of!((*ptr).pRefPicList1Entries) as usize - ptr as usize },
7381 24usize,
7382 concat!(
7383 "Offset of field: ",
7384 stringify!(StdVideoEncodeH264ReferenceListsInfo),
7385 "::",
7386 stringify!(pRefPicList1Entries)
7387 )
7388 );
7389 assert_eq!(
7390 unsafe { ::std::ptr::addr_of!((*ptr).pRefList0ModOperations) as usize - ptr as usize },
7391 32usize,
7392 concat!(
7393 "Offset of field: ",
7394 stringify!(StdVideoEncodeH264ReferenceListsInfo),
7395 "::",
7396 stringify!(pRefList0ModOperations)
7397 )
7398 );
7399 assert_eq!(
7400 unsafe { ::std::ptr::addr_of!((*ptr).pRefList1ModOperations) as usize - ptr as usize },
7401 40usize,
7402 concat!(
7403 "Offset of field: ",
7404 stringify!(StdVideoEncodeH264ReferenceListsInfo),
7405 "::",
7406 stringify!(pRefList1ModOperations)
7407 )
7408 );
7409 assert_eq!(
7410 unsafe { ::std::ptr::addr_of!((*ptr).pRefPicMarkingOperations) as usize - ptr as usize },
7411 48usize,
7412 concat!(
7413 "Offset of field: ",
7414 stringify!(StdVideoEncodeH264ReferenceListsInfo),
7415 "::",
7416 stringify!(pRefPicMarkingOperations)
7417 )
7418 );
7419}
7420#[repr(C)]
7421#[derive(Debug, Copy, Clone)]
7422pub struct StdVideoEncodeH264PictureInfo {
7423 pub flags: StdVideoEncodeH264PictureInfoFlags,
7424 pub seq_parameter_set_id: u8,
7425 pub pic_parameter_set_id: u8,
7426 pub reserved1: u16,
7427 pub pictureType: StdVideoH264PictureType,
7428 pub frame_num: u32,
7429 pub PicOrderCnt: i32,
7430}
7431#[test]
7432fn bindgen_test_layout_StdVideoEncodeH264PictureInfo() {
7433 const UNINIT: ::std::mem::MaybeUninit<StdVideoEncodeH264PictureInfo> =
7434 ::std::mem::MaybeUninit::uninit();
7435 let ptr = UNINIT.as_ptr();
7436 assert_eq!(
7437 ::std::mem::size_of::<StdVideoEncodeH264PictureInfo>(),
7438 20usize,
7439 concat!("Size of: ", stringify!(StdVideoEncodeH264PictureInfo))
7440 );
7441 assert_eq!(
7442 ::std::mem::align_of::<StdVideoEncodeH264PictureInfo>(),
7443 4usize,
7444 concat!("Alignment of ", stringify!(StdVideoEncodeH264PictureInfo))
7445 );
7446 assert_eq!(
7447 unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
7448 0usize,
7449 concat!(
7450 "Offset of field: ",
7451 stringify!(StdVideoEncodeH264PictureInfo),
7452 "::",
7453 stringify!(flags)
7454 )
7455 );
7456 assert_eq!(
7457 unsafe { ::std::ptr::addr_of!((*ptr).seq_parameter_set_id) as usize - ptr as usize },
7458 4usize,
7459 concat!(
7460 "Offset of field: ",
7461 stringify!(StdVideoEncodeH264PictureInfo),
7462 "::",
7463 stringify!(seq_parameter_set_id)
7464 )
7465 );
7466 assert_eq!(
7467 unsafe { ::std::ptr::addr_of!((*ptr).pic_parameter_set_id) as usize - ptr as usize },
7468 5usize,
7469 concat!(
7470 "Offset of field: ",
7471 stringify!(StdVideoEncodeH264PictureInfo),
7472 "::",
7473 stringify!(pic_parameter_set_id)
7474 )
7475 );
7476 assert_eq!(
7477 unsafe { ::std::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize },
7478 6usize,
7479 concat!(
7480 "Offset of field: ",
7481 stringify!(StdVideoEncodeH264PictureInfo),
7482 "::",
7483 stringify!(reserved1)
7484 )
7485 );
7486 assert_eq!(
7487 unsafe { ::std::ptr::addr_of!((*ptr).pictureType) as usize - ptr as usize },
7488 8usize,
7489 concat!(
7490 "Offset of field: ",
7491 stringify!(StdVideoEncodeH264PictureInfo),
7492 "::",
7493 stringify!(pictureType)
7494 )
7495 );
7496 assert_eq!(
7497 unsafe { ::std::ptr::addr_of!((*ptr).frame_num) as usize - ptr as usize },
7498 12usize,
7499 concat!(
7500 "Offset of field: ",
7501 stringify!(StdVideoEncodeH264PictureInfo),
7502 "::",
7503 stringify!(frame_num)
7504 )
7505 );
7506 assert_eq!(
7507 unsafe { ::std::ptr::addr_of!((*ptr).PicOrderCnt) as usize - ptr as usize },
7508 16usize,
7509 concat!(
7510 "Offset of field: ",
7511 stringify!(StdVideoEncodeH264PictureInfo),
7512 "::",
7513 stringify!(PicOrderCnt)
7514 )
7515 );
7516}
7517#[repr(C)]
7518#[derive(Debug, Copy, Clone)]
7519pub struct StdVideoEncodeH264ReferenceInfo {
7520 pub flags: StdVideoEncodeH264ReferenceInfoFlags,
7521 pub pictureType: StdVideoH264PictureType,
7522 pub FrameNum: u32,
7523 pub PicOrderCnt: i32,
7524 pub long_term_pic_num: u16,
7525 pub long_term_frame_idx: u16,
7526}
7527#[test]
7528fn bindgen_test_layout_StdVideoEncodeH264ReferenceInfo() {
7529 const UNINIT: ::std::mem::MaybeUninit<StdVideoEncodeH264ReferenceInfo> =
7530 ::std::mem::MaybeUninit::uninit();
7531 let ptr = UNINIT.as_ptr();
7532 assert_eq!(
7533 ::std::mem::size_of::<StdVideoEncodeH264ReferenceInfo>(),
7534 20usize,
7535 concat!("Size of: ", stringify!(StdVideoEncodeH264ReferenceInfo))
7536 );
7537 assert_eq!(
7538 ::std::mem::align_of::<StdVideoEncodeH264ReferenceInfo>(),
7539 4usize,
7540 concat!("Alignment of ", stringify!(StdVideoEncodeH264ReferenceInfo))
7541 );
7542 assert_eq!(
7543 unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
7544 0usize,
7545 concat!(
7546 "Offset of field: ",
7547 stringify!(StdVideoEncodeH264ReferenceInfo),
7548 "::",
7549 stringify!(flags)
7550 )
7551 );
7552 assert_eq!(
7553 unsafe { ::std::ptr::addr_of!((*ptr).pictureType) as usize - ptr as usize },
7554 4usize,
7555 concat!(
7556 "Offset of field: ",
7557 stringify!(StdVideoEncodeH264ReferenceInfo),
7558 "::",
7559 stringify!(pictureType)
7560 )
7561 );
7562 assert_eq!(
7563 unsafe { ::std::ptr::addr_of!((*ptr).FrameNum) as usize - ptr as usize },
7564 8usize,
7565 concat!(
7566 "Offset of field: ",
7567 stringify!(StdVideoEncodeH264ReferenceInfo),
7568 "::",
7569 stringify!(FrameNum)
7570 )
7571 );
7572 assert_eq!(
7573 unsafe { ::std::ptr::addr_of!((*ptr).PicOrderCnt) as usize - ptr as usize },
7574 12usize,
7575 concat!(
7576 "Offset of field: ",
7577 stringify!(StdVideoEncodeH264ReferenceInfo),
7578 "::",
7579 stringify!(PicOrderCnt)
7580 )
7581 );
7582 assert_eq!(
7583 unsafe { ::std::ptr::addr_of!((*ptr).long_term_pic_num) as usize - ptr as usize },
7584 16usize,
7585 concat!(
7586 "Offset of field: ",
7587 stringify!(StdVideoEncodeH264ReferenceInfo),
7588 "::",
7589 stringify!(long_term_pic_num)
7590 )
7591 );
7592 assert_eq!(
7593 unsafe { ::std::ptr::addr_of!((*ptr).long_term_frame_idx) as usize - ptr as usize },
7594 18usize,
7595 concat!(
7596 "Offset of field: ",
7597 stringify!(StdVideoEncodeH264ReferenceInfo),
7598 "::",
7599 stringify!(long_term_frame_idx)
7600 )
7601 );
7602}
7603#[repr(C)]
7604#[derive(Debug, Copy, Clone)]
7605pub struct StdVideoEncodeH264SliceHeader {
7606 pub flags: StdVideoEncodeH264SliceHeaderFlags,
7607 pub first_mb_in_slice: u32,
7608 pub slice_type: StdVideoH264SliceType,
7609 pub idr_pic_id: u16,
7610 pub num_ref_idx_l0_active_minus1: u8,
7611 pub num_ref_idx_l1_active_minus1: u8,
7612 pub cabac_init_idc: StdVideoH264CabacInitIdc,
7613 pub disable_deblocking_filter_idc: StdVideoH264DisableDeblockingFilterIdc,
7614 pub slice_alpha_c0_offset_div2: i8,
7615 pub slice_beta_offset_div2: i8,
7616 pub reserved1: u16,
7617 pub reserved2: u32,
7618 pub pWeightTable: *const StdVideoEncodeH264WeightTable,
7619}
7620#[test]
7621fn bindgen_test_layout_StdVideoEncodeH264SliceHeader() {
7622 const UNINIT: ::std::mem::MaybeUninit<StdVideoEncodeH264SliceHeader> =
7623 ::std::mem::MaybeUninit::uninit();
7624 let ptr = UNINIT.as_ptr();
7625 assert_eq!(
7626 ::std::mem::size_of::<StdVideoEncodeH264SliceHeader>(),
7627 40usize,
7628 concat!("Size of: ", stringify!(StdVideoEncodeH264SliceHeader))
7629 );
7630 assert_eq!(
7631 ::std::mem::align_of::<StdVideoEncodeH264SliceHeader>(),
7632 8usize,
7633 concat!("Alignment of ", stringify!(StdVideoEncodeH264SliceHeader))
7634 );
7635 assert_eq!(
7636 unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
7637 0usize,
7638 concat!(
7639 "Offset of field: ",
7640 stringify!(StdVideoEncodeH264SliceHeader),
7641 "::",
7642 stringify!(flags)
7643 )
7644 );
7645 assert_eq!(
7646 unsafe { ::std::ptr::addr_of!((*ptr).first_mb_in_slice) as usize - ptr as usize },
7647 4usize,
7648 concat!(
7649 "Offset of field: ",
7650 stringify!(StdVideoEncodeH264SliceHeader),
7651 "::",
7652 stringify!(first_mb_in_slice)
7653 )
7654 );
7655 assert_eq!(
7656 unsafe { ::std::ptr::addr_of!((*ptr).slice_type) as usize - ptr as usize },
7657 8usize,
7658 concat!(
7659 "Offset of field: ",
7660 stringify!(StdVideoEncodeH264SliceHeader),
7661 "::",
7662 stringify!(slice_type)
7663 )
7664 );
7665 assert_eq!(
7666 unsafe { ::std::ptr::addr_of!((*ptr).idr_pic_id) as usize - ptr as usize },
7667 12usize,
7668 concat!(
7669 "Offset of field: ",
7670 stringify!(StdVideoEncodeH264SliceHeader),
7671 "::",
7672 stringify!(idr_pic_id)
7673 )
7674 );
7675 assert_eq!(
7676 unsafe {
7677 ::std::ptr::addr_of!((*ptr).num_ref_idx_l0_active_minus1) as usize - ptr as usize
7678 },
7679 14usize,
7680 concat!(
7681 "Offset of field: ",
7682 stringify!(StdVideoEncodeH264SliceHeader),
7683 "::",
7684 stringify!(num_ref_idx_l0_active_minus1)
7685 )
7686 );
7687 assert_eq!(
7688 unsafe {
7689 ::std::ptr::addr_of!((*ptr).num_ref_idx_l1_active_minus1) as usize - ptr as usize
7690 },
7691 15usize,
7692 concat!(
7693 "Offset of field: ",
7694 stringify!(StdVideoEncodeH264SliceHeader),
7695 "::",
7696 stringify!(num_ref_idx_l1_active_minus1)
7697 )
7698 );
7699 assert_eq!(
7700 unsafe { ::std::ptr::addr_of!((*ptr).cabac_init_idc) as usize - ptr as usize },
7701 16usize,
7702 concat!(
7703 "Offset of field: ",
7704 stringify!(StdVideoEncodeH264SliceHeader),
7705 "::",
7706 stringify!(cabac_init_idc)
7707 )
7708 );
7709 assert_eq!(
7710 unsafe {
7711 ::std::ptr::addr_of!((*ptr).disable_deblocking_filter_idc) as usize - ptr as usize
7712 },
7713 20usize,
7714 concat!(
7715 "Offset of field: ",
7716 stringify!(StdVideoEncodeH264SliceHeader),
7717 "::",
7718 stringify!(disable_deblocking_filter_idc)
7719 )
7720 );
7721 assert_eq!(
7722 unsafe { ::std::ptr::addr_of!((*ptr).slice_alpha_c0_offset_div2) as usize - ptr as usize },
7723 24usize,
7724 concat!(
7725 "Offset of field: ",
7726 stringify!(StdVideoEncodeH264SliceHeader),
7727 "::",
7728 stringify!(slice_alpha_c0_offset_div2)
7729 )
7730 );
7731 assert_eq!(
7732 unsafe { ::std::ptr::addr_of!((*ptr).slice_beta_offset_div2) as usize - ptr as usize },
7733 25usize,
7734 concat!(
7735 "Offset of field: ",
7736 stringify!(StdVideoEncodeH264SliceHeader),
7737 "::",
7738 stringify!(slice_beta_offset_div2)
7739 )
7740 );
7741 assert_eq!(
7742 unsafe { ::std::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize },
7743 26usize,
7744 concat!(
7745 "Offset of field: ",
7746 stringify!(StdVideoEncodeH264SliceHeader),
7747 "::",
7748 stringify!(reserved1)
7749 )
7750 );
7751 assert_eq!(
7752 unsafe { ::std::ptr::addr_of!((*ptr).reserved2) as usize - ptr as usize },
7753 28usize,
7754 concat!(
7755 "Offset of field: ",
7756 stringify!(StdVideoEncodeH264SliceHeader),
7757 "::",
7758 stringify!(reserved2)
7759 )
7760 );
7761 assert_eq!(
7762 unsafe { ::std::ptr::addr_of!((*ptr).pWeightTable) as usize - ptr as usize },
7763 32usize,
7764 concat!(
7765 "Offset of field: ",
7766 stringify!(StdVideoEncodeH264SliceHeader),
7767 "::",
7768 stringify!(pWeightTable)
7769 )
7770 );
7771}
7772#[repr(C)]
7773#[derive(Debug, Copy, Clone)]
7774pub struct StdVideoEncodeH265WeightTableFlags {
7775 pub luma_weight_l0_flag: u16,
7776 pub chroma_weight_l0_flag: u16,
7777 pub luma_weight_l1_flag: u16,
7778 pub chroma_weight_l1_flag: u16,
7779}
7780#[test]
7781fn bindgen_test_layout_StdVideoEncodeH265WeightTableFlags() {
7782 const UNINIT: ::std::mem::MaybeUninit<StdVideoEncodeH265WeightTableFlags> =
7783 ::std::mem::MaybeUninit::uninit();
7784 let ptr = UNINIT.as_ptr();
7785 assert_eq!(
7786 ::std::mem::size_of::<StdVideoEncodeH265WeightTableFlags>(),
7787 8usize,
7788 concat!("Size of: ", stringify!(StdVideoEncodeH265WeightTableFlags))
7789 );
7790 assert_eq!(
7791 ::std::mem::align_of::<StdVideoEncodeH265WeightTableFlags>(),
7792 2usize,
7793 concat!(
7794 "Alignment of ",
7795 stringify!(StdVideoEncodeH265WeightTableFlags)
7796 )
7797 );
7798 assert_eq!(
7799 unsafe { ::std::ptr::addr_of!((*ptr).luma_weight_l0_flag) as usize - ptr as usize },
7800 0usize,
7801 concat!(
7802 "Offset of field: ",
7803 stringify!(StdVideoEncodeH265WeightTableFlags),
7804 "::",
7805 stringify!(luma_weight_l0_flag)
7806 )
7807 );
7808 assert_eq!(
7809 unsafe { ::std::ptr::addr_of!((*ptr).chroma_weight_l0_flag) as usize - ptr as usize },
7810 2usize,
7811 concat!(
7812 "Offset of field: ",
7813 stringify!(StdVideoEncodeH265WeightTableFlags),
7814 "::",
7815 stringify!(chroma_weight_l0_flag)
7816 )
7817 );
7818 assert_eq!(
7819 unsafe { ::std::ptr::addr_of!((*ptr).luma_weight_l1_flag) as usize - ptr as usize },
7820 4usize,
7821 concat!(
7822 "Offset of field: ",
7823 stringify!(StdVideoEncodeH265WeightTableFlags),
7824 "::",
7825 stringify!(luma_weight_l1_flag)
7826 )
7827 );
7828 assert_eq!(
7829 unsafe { ::std::ptr::addr_of!((*ptr).chroma_weight_l1_flag) as usize - ptr as usize },
7830 6usize,
7831 concat!(
7832 "Offset of field: ",
7833 stringify!(StdVideoEncodeH265WeightTableFlags),
7834 "::",
7835 stringify!(chroma_weight_l1_flag)
7836 )
7837 );
7838}
7839#[repr(C)]
7840#[derive(Debug, Copy, Clone)]
7841pub struct StdVideoEncodeH265WeightTable {
7842 pub flags: StdVideoEncodeH265WeightTableFlags,
7843 pub luma_log2_weight_denom: u8,
7844 pub delta_chroma_log2_weight_denom: i8,
7845 pub delta_luma_weight_l0: [i8; 15usize],
7846 pub luma_offset_l0: [i8; 15usize],
7847 pub delta_chroma_weight_l0: [[i8; 2usize]; 15usize],
7848 pub delta_chroma_offset_l0: [[i8; 2usize]; 15usize],
7849 pub delta_luma_weight_l1: [i8; 15usize],
7850 pub luma_offset_l1: [i8; 15usize],
7851 pub delta_chroma_weight_l1: [[i8; 2usize]; 15usize],
7852 pub delta_chroma_offset_l1: [[i8; 2usize]; 15usize],
7853}
7854#[test]
7855fn bindgen_test_layout_StdVideoEncodeH265WeightTable() {
7856 const UNINIT: ::std::mem::MaybeUninit<StdVideoEncodeH265WeightTable> =
7857 ::std::mem::MaybeUninit::uninit();
7858 let ptr = UNINIT.as_ptr();
7859 assert_eq!(
7860 ::std::mem::size_of::<StdVideoEncodeH265WeightTable>(),
7861 190usize,
7862 concat!("Size of: ", stringify!(StdVideoEncodeH265WeightTable))
7863 );
7864 assert_eq!(
7865 ::std::mem::align_of::<StdVideoEncodeH265WeightTable>(),
7866 2usize,
7867 concat!("Alignment of ", stringify!(StdVideoEncodeH265WeightTable))
7868 );
7869 assert_eq!(
7870 unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
7871 0usize,
7872 concat!(
7873 "Offset of field: ",
7874 stringify!(StdVideoEncodeH265WeightTable),
7875 "::",
7876 stringify!(flags)
7877 )
7878 );
7879 assert_eq!(
7880 unsafe { ::std::ptr::addr_of!((*ptr).luma_log2_weight_denom) as usize - ptr as usize },
7881 8usize,
7882 concat!(
7883 "Offset of field: ",
7884 stringify!(StdVideoEncodeH265WeightTable),
7885 "::",
7886 stringify!(luma_log2_weight_denom)
7887 )
7888 );
7889 assert_eq!(
7890 unsafe {
7891 ::std::ptr::addr_of!((*ptr).delta_chroma_log2_weight_denom) as usize - ptr as usize
7892 },
7893 9usize,
7894 concat!(
7895 "Offset of field: ",
7896 stringify!(StdVideoEncodeH265WeightTable),
7897 "::",
7898 stringify!(delta_chroma_log2_weight_denom)
7899 )
7900 );
7901 assert_eq!(
7902 unsafe { ::std::ptr::addr_of!((*ptr).delta_luma_weight_l0) as usize - ptr as usize },
7903 10usize,
7904 concat!(
7905 "Offset of field: ",
7906 stringify!(StdVideoEncodeH265WeightTable),
7907 "::",
7908 stringify!(delta_luma_weight_l0)
7909 )
7910 );
7911 assert_eq!(
7912 unsafe { ::std::ptr::addr_of!((*ptr).luma_offset_l0) as usize - ptr as usize },
7913 25usize,
7914 concat!(
7915 "Offset of field: ",
7916 stringify!(StdVideoEncodeH265WeightTable),
7917 "::",
7918 stringify!(luma_offset_l0)
7919 )
7920 );
7921 assert_eq!(
7922 unsafe { ::std::ptr::addr_of!((*ptr).delta_chroma_weight_l0) as usize - ptr as usize },
7923 40usize,
7924 concat!(
7925 "Offset of field: ",
7926 stringify!(StdVideoEncodeH265WeightTable),
7927 "::",
7928 stringify!(delta_chroma_weight_l0)
7929 )
7930 );
7931 assert_eq!(
7932 unsafe { ::std::ptr::addr_of!((*ptr).delta_chroma_offset_l0) as usize - ptr as usize },
7933 70usize,
7934 concat!(
7935 "Offset of field: ",
7936 stringify!(StdVideoEncodeH265WeightTable),
7937 "::",
7938 stringify!(delta_chroma_offset_l0)
7939 )
7940 );
7941 assert_eq!(
7942 unsafe { ::std::ptr::addr_of!((*ptr).delta_luma_weight_l1) as usize - ptr as usize },
7943 100usize,
7944 concat!(
7945 "Offset of field: ",
7946 stringify!(StdVideoEncodeH265WeightTable),
7947 "::",
7948 stringify!(delta_luma_weight_l1)
7949 )
7950 );
7951 assert_eq!(
7952 unsafe { ::std::ptr::addr_of!((*ptr).luma_offset_l1) as usize - ptr as usize },
7953 115usize,
7954 concat!(
7955 "Offset of field: ",
7956 stringify!(StdVideoEncodeH265WeightTable),
7957 "::",
7958 stringify!(luma_offset_l1)
7959 )
7960 );
7961 assert_eq!(
7962 unsafe { ::std::ptr::addr_of!((*ptr).delta_chroma_weight_l1) as usize - ptr as usize },
7963 130usize,
7964 concat!(
7965 "Offset of field: ",
7966 stringify!(StdVideoEncodeH265WeightTable),
7967 "::",
7968 stringify!(delta_chroma_weight_l1)
7969 )
7970 );
7971 assert_eq!(
7972 unsafe { ::std::ptr::addr_of!((*ptr).delta_chroma_offset_l1) as usize - ptr as usize },
7973 160usize,
7974 concat!(
7975 "Offset of field: ",
7976 stringify!(StdVideoEncodeH265WeightTable),
7977 "::",
7978 stringify!(delta_chroma_offset_l1)
7979 )
7980 );
7981}
7982#[repr(C)]
7983#[repr(align(4))]
7984#[derive(Debug, Copy, Clone)]
7985pub struct StdVideoEncodeH265SliceSegmentHeaderFlags {
7986 pub _bitfield_align_1: [u8; 0],
7987 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
7988 pub __bindgen_padding_0: u16,
7989}
7990#[test]
7991fn bindgen_test_layout_StdVideoEncodeH265SliceSegmentHeaderFlags() {
7992 assert_eq!(
7993 ::std::mem::size_of::<StdVideoEncodeH265SliceSegmentHeaderFlags>(),
7994 4usize,
7995 concat!(
7996 "Size of: ",
7997 stringify!(StdVideoEncodeH265SliceSegmentHeaderFlags)
7998 )
7999 );
8000 assert_eq!(
8001 ::std::mem::align_of::<StdVideoEncodeH265SliceSegmentHeaderFlags>(),
8002 4usize,
8003 concat!(
8004 "Alignment of ",
8005 stringify!(StdVideoEncodeH265SliceSegmentHeaderFlags)
8006 )
8007 );
8008}
8009impl StdVideoEncodeH265SliceSegmentHeaderFlags {
8010 #[inline]
8011 pub fn first_slice_segment_in_pic_flag(&self) -> u32 {
8012 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
8013 }
8014 #[inline]
8015 pub fn set_first_slice_segment_in_pic_flag(&mut self, val: u32) {
8016 unsafe {
8017 let val: u32 = ::std::mem::transmute(val);
8018 self._bitfield_1.set(0usize, 1u8, val as u64)
8019 }
8020 }
8021 #[inline]
8022 pub fn no_output_of_prior_pics_flag(&self) -> u32 {
8023 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
8024 }
8025 #[inline]
8026 pub fn set_no_output_of_prior_pics_flag(&mut self, val: u32) {
8027 unsafe {
8028 let val: u32 = ::std::mem::transmute(val);
8029 self._bitfield_1.set(1usize, 1u8, val as u64)
8030 }
8031 }
8032 #[inline]
8033 pub fn dependent_slice_segment_flag(&self) -> u32 {
8034 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
8035 }
8036 #[inline]
8037 pub fn set_dependent_slice_segment_flag(&mut self, val: u32) {
8038 unsafe {
8039 let val: u32 = ::std::mem::transmute(val);
8040 self._bitfield_1.set(2usize, 1u8, val as u64)
8041 }
8042 }
8043 #[inline]
8044 pub fn pic_output_flag(&self) -> u32 {
8045 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
8046 }
8047 #[inline]
8048 pub fn set_pic_output_flag(&mut self, val: u32) {
8049 unsafe {
8050 let val: u32 = ::std::mem::transmute(val);
8051 self._bitfield_1.set(3usize, 1u8, val as u64)
8052 }
8053 }
8054 #[inline]
8055 pub fn short_term_ref_pic_set_sps_flag(&self) -> u32 {
8056 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
8057 }
8058 #[inline]
8059 pub fn set_short_term_ref_pic_set_sps_flag(&mut self, val: u32) {
8060 unsafe {
8061 let val: u32 = ::std::mem::transmute(val);
8062 self._bitfield_1.set(4usize, 1u8, val as u64)
8063 }
8064 }
8065 #[inline]
8066 pub fn slice_temporal_mvp_enable_flag(&self) -> u32 {
8067 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
8068 }
8069 #[inline]
8070 pub fn set_slice_temporal_mvp_enable_flag(&mut self, val: u32) {
8071 unsafe {
8072 let val: u32 = ::std::mem::transmute(val);
8073 self._bitfield_1.set(5usize, 1u8, val as u64)
8074 }
8075 }
8076 #[inline]
8077 pub fn slice_sao_luma_flag(&self) -> u32 {
8078 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) }
8079 }
8080 #[inline]
8081 pub fn set_slice_sao_luma_flag(&mut self, val: u32) {
8082 unsafe {
8083 let val: u32 = ::std::mem::transmute(val);
8084 self._bitfield_1.set(6usize, 1u8, val as u64)
8085 }
8086 }
8087 #[inline]
8088 pub fn slice_sao_chroma_flag(&self) -> u32 {
8089 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) }
8090 }
8091 #[inline]
8092 pub fn set_slice_sao_chroma_flag(&mut self, val: u32) {
8093 unsafe {
8094 let val: u32 = ::std::mem::transmute(val);
8095 self._bitfield_1.set(7usize, 1u8, val as u64)
8096 }
8097 }
8098 #[inline]
8099 pub fn num_ref_idx_active_override_flag(&self) -> u32 {
8100 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) }
8101 }
8102 #[inline]
8103 pub fn set_num_ref_idx_active_override_flag(&mut self, val: u32) {
8104 unsafe {
8105 let val: u32 = ::std::mem::transmute(val);
8106 self._bitfield_1.set(8usize, 1u8, val as u64)
8107 }
8108 }
8109 #[inline]
8110 pub fn mvd_l1_zero_flag(&self) -> u32 {
8111 unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) }
8112 }
8113 #[inline]
8114 pub fn set_mvd_l1_zero_flag(&mut self, val: u32) {
8115 unsafe {
8116 let val: u32 = ::std::mem::transmute(val);
8117 self._bitfield_1.set(9usize, 1u8, val as u64)
8118 }
8119 }
8120 #[inline]
8121 pub fn cabac_init_flag(&self) -> u32 {
8122 unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) }
8123 }
8124 #[inline]
8125 pub fn set_cabac_init_flag(&mut self, val: u32) {
8126 unsafe {
8127 let val: u32 = ::std::mem::transmute(val);
8128 self._bitfield_1.set(10usize, 1u8, val as u64)
8129 }
8130 }
8131 #[inline]
8132 pub fn cu_chroma_qp_offset_enabled_flag(&self) -> u32 {
8133 unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) }
8134 }
8135 #[inline]
8136 pub fn set_cu_chroma_qp_offset_enabled_flag(&mut self, val: u32) {
8137 unsafe {
8138 let val: u32 = ::std::mem::transmute(val);
8139 self._bitfield_1.set(11usize, 1u8, val as u64)
8140 }
8141 }
8142 #[inline]
8143 pub fn deblocking_filter_override_flag(&self) -> u32 {
8144 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u32) }
8145 }
8146 #[inline]
8147 pub fn set_deblocking_filter_override_flag(&mut self, val: u32) {
8148 unsafe {
8149 let val: u32 = ::std::mem::transmute(val);
8150 self._bitfield_1.set(12usize, 1u8, val as u64)
8151 }
8152 }
8153 #[inline]
8154 pub fn slice_deblocking_filter_disabled_flag(&self) -> u32 {
8155 unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) }
8156 }
8157 #[inline]
8158 pub fn set_slice_deblocking_filter_disabled_flag(&mut self, val: u32) {
8159 unsafe {
8160 let val: u32 = ::std::mem::transmute(val);
8161 self._bitfield_1.set(13usize, 1u8, val as u64)
8162 }
8163 }
8164 #[inline]
8165 pub fn collocated_from_l0_flag(&self) -> u32 {
8166 unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) }
8167 }
8168 #[inline]
8169 pub fn set_collocated_from_l0_flag(&mut self, val: u32) {
8170 unsafe {
8171 let val: u32 = ::std::mem::transmute(val);
8172 self._bitfield_1.set(14usize, 1u8, val as u64)
8173 }
8174 }
8175 #[inline]
8176 pub fn slice_loop_filter_across_slices_enabled_flag(&self) -> u32 {
8177 unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u32) }
8178 }
8179 #[inline]
8180 pub fn set_slice_loop_filter_across_slices_enabled_flag(&mut self, val: u32) {
8181 unsafe {
8182 let val: u32 = ::std::mem::transmute(val);
8183 self._bitfield_1.set(15usize, 1u8, val as u64)
8184 }
8185 }
8186 #[inline]
8187 pub fn new_bitfield_1(
8188 first_slice_segment_in_pic_flag: u32,
8189 no_output_of_prior_pics_flag: u32,
8190 dependent_slice_segment_flag: u32,
8191 pic_output_flag: u32,
8192 short_term_ref_pic_set_sps_flag: u32,
8193 slice_temporal_mvp_enable_flag: u32,
8194 slice_sao_luma_flag: u32,
8195 slice_sao_chroma_flag: u32,
8196 num_ref_idx_active_override_flag: u32,
8197 mvd_l1_zero_flag: u32,
8198 cabac_init_flag: u32,
8199 cu_chroma_qp_offset_enabled_flag: u32,
8200 deblocking_filter_override_flag: u32,
8201 slice_deblocking_filter_disabled_flag: u32,
8202 collocated_from_l0_flag: u32,
8203 slice_loop_filter_across_slices_enabled_flag: u32,
8204 ) -> __BindgenBitfieldUnit<[u8; 2usize]> {
8205 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default();
8206 __bindgen_bitfield_unit.set(0usize, 1u8, {
8207 let first_slice_segment_in_pic_flag: u32 =
8208 unsafe { ::std::mem::transmute(first_slice_segment_in_pic_flag) };
8209 first_slice_segment_in_pic_flag as u64
8210 });
8211 __bindgen_bitfield_unit.set(1usize, 1u8, {
8212 let no_output_of_prior_pics_flag: u32 =
8213 unsafe { ::std::mem::transmute(no_output_of_prior_pics_flag) };
8214 no_output_of_prior_pics_flag as u64
8215 });
8216 __bindgen_bitfield_unit.set(2usize, 1u8, {
8217 let dependent_slice_segment_flag: u32 =
8218 unsafe { ::std::mem::transmute(dependent_slice_segment_flag) };
8219 dependent_slice_segment_flag as u64
8220 });
8221 __bindgen_bitfield_unit.set(3usize, 1u8, {
8222 let pic_output_flag: u32 = unsafe { ::std::mem::transmute(pic_output_flag) };
8223 pic_output_flag as u64
8224 });
8225 __bindgen_bitfield_unit.set(4usize, 1u8, {
8226 let short_term_ref_pic_set_sps_flag: u32 =
8227 unsafe { ::std::mem::transmute(short_term_ref_pic_set_sps_flag) };
8228 short_term_ref_pic_set_sps_flag as u64
8229 });
8230 __bindgen_bitfield_unit.set(5usize, 1u8, {
8231 let slice_temporal_mvp_enable_flag: u32 =
8232 unsafe { ::std::mem::transmute(slice_temporal_mvp_enable_flag) };
8233 slice_temporal_mvp_enable_flag as u64
8234 });
8235 __bindgen_bitfield_unit.set(6usize, 1u8, {
8236 let slice_sao_luma_flag: u32 = unsafe { ::std::mem::transmute(slice_sao_luma_flag) };
8237 slice_sao_luma_flag as u64
8238 });
8239 __bindgen_bitfield_unit.set(7usize, 1u8, {
8240 let slice_sao_chroma_flag: u32 =
8241 unsafe { ::std::mem::transmute(slice_sao_chroma_flag) };
8242 slice_sao_chroma_flag as u64
8243 });
8244 __bindgen_bitfield_unit.set(8usize, 1u8, {
8245 let num_ref_idx_active_override_flag: u32 =
8246 unsafe { ::std::mem::transmute(num_ref_idx_active_override_flag) };
8247 num_ref_idx_active_override_flag as u64
8248 });
8249 __bindgen_bitfield_unit.set(9usize, 1u8, {
8250 let mvd_l1_zero_flag: u32 = unsafe { ::std::mem::transmute(mvd_l1_zero_flag) };
8251 mvd_l1_zero_flag as u64
8252 });
8253 __bindgen_bitfield_unit.set(10usize, 1u8, {
8254 let cabac_init_flag: u32 = unsafe { ::std::mem::transmute(cabac_init_flag) };
8255 cabac_init_flag as u64
8256 });
8257 __bindgen_bitfield_unit.set(11usize, 1u8, {
8258 let cu_chroma_qp_offset_enabled_flag: u32 =
8259 unsafe { ::std::mem::transmute(cu_chroma_qp_offset_enabled_flag) };
8260 cu_chroma_qp_offset_enabled_flag as u64
8261 });
8262 __bindgen_bitfield_unit.set(12usize, 1u8, {
8263 let deblocking_filter_override_flag: u32 =
8264 unsafe { ::std::mem::transmute(deblocking_filter_override_flag) };
8265 deblocking_filter_override_flag as u64
8266 });
8267 __bindgen_bitfield_unit.set(13usize, 1u8, {
8268 let slice_deblocking_filter_disabled_flag: u32 =
8269 unsafe { ::std::mem::transmute(slice_deblocking_filter_disabled_flag) };
8270 slice_deblocking_filter_disabled_flag as u64
8271 });
8272 __bindgen_bitfield_unit.set(14usize, 1u8, {
8273 let collocated_from_l0_flag: u32 =
8274 unsafe { ::std::mem::transmute(collocated_from_l0_flag) };
8275 collocated_from_l0_flag as u64
8276 });
8277 __bindgen_bitfield_unit.set(15usize, 1u8, {
8278 let slice_loop_filter_across_slices_enabled_flag: u32 =
8279 unsafe { ::std::mem::transmute(slice_loop_filter_across_slices_enabled_flag) };
8280 slice_loop_filter_across_slices_enabled_flag as u64
8281 });
8282 __bindgen_bitfield_unit
8283 }
8284}
8285#[repr(C)]
8286#[derive(Debug, Copy, Clone)]
8287pub struct StdVideoEncodeH265SliceSegmentLongTermRefPics {
8288 pub num_long_term_sps: u8,
8289 pub num_long_term_pics: u8,
8290 pub lt_idx_sps: [u8; 32usize],
8291 pub poc_lsb_lt: [u8; 16usize],
8292 pub used_by_curr_pic_lt_flag: u16,
8293 pub delta_poc_msb_present_flag: [u8; 48usize],
8294 pub delta_poc_msb_cycle_lt: [u8; 48usize],
8295}
8296#[test]
8297fn bindgen_test_layout_StdVideoEncodeH265SliceSegmentLongTermRefPics() {
8298 const UNINIT: ::std::mem::MaybeUninit<StdVideoEncodeH265SliceSegmentLongTermRefPics> =
8299 ::std::mem::MaybeUninit::uninit();
8300 let ptr = UNINIT.as_ptr();
8301 assert_eq!(
8302 ::std::mem::size_of::<StdVideoEncodeH265SliceSegmentLongTermRefPics>(),
8303 148usize,
8304 concat!(
8305 "Size of: ",
8306 stringify!(StdVideoEncodeH265SliceSegmentLongTermRefPics)
8307 )
8308 );
8309 assert_eq!(
8310 ::std::mem::align_of::<StdVideoEncodeH265SliceSegmentLongTermRefPics>(),
8311 2usize,
8312 concat!(
8313 "Alignment of ",
8314 stringify!(StdVideoEncodeH265SliceSegmentLongTermRefPics)
8315 )
8316 );
8317 assert_eq!(
8318 unsafe { ::std::ptr::addr_of!((*ptr).num_long_term_sps) as usize - ptr as usize },
8319 0usize,
8320 concat!(
8321 "Offset of field: ",
8322 stringify!(StdVideoEncodeH265SliceSegmentLongTermRefPics),
8323 "::",
8324 stringify!(num_long_term_sps)
8325 )
8326 );
8327 assert_eq!(
8328 unsafe { ::std::ptr::addr_of!((*ptr).num_long_term_pics) as usize - ptr as usize },
8329 1usize,
8330 concat!(
8331 "Offset of field: ",
8332 stringify!(StdVideoEncodeH265SliceSegmentLongTermRefPics),
8333 "::",
8334 stringify!(num_long_term_pics)
8335 )
8336 );
8337 assert_eq!(
8338 unsafe { ::std::ptr::addr_of!((*ptr).lt_idx_sps) as usize - ptr as usize },
8339 2usize,
8340 concat!(
8341 "Offset of field: ",
8342 stringify!(StdVideoEncodeH265SliceSegmentLongTermRefPics),
8343 "::",
8344 stringify!(lt_idx_sps)
8345 )
8346 );
8347 assert_eq!(
8348 unsafe { ::std::ptr::addr_of!((*ptr).poc_lsb_lt) as usize - ptr as usize },
8349 34usize,
8350 concat!(
8351 "Offset of field: ",
8352 stringify!(StdVideoEncodeH265SliceSegmentLongTermRefPics),
8353 "::",
8354 stringify!(poc_lsb_lt)
8355 )
8356 );
8357 assert_eq!(
8358 unsafe { ::std::ptr::addr_of!((*ptr).used_by_curr_pic_lt_flag) as usize - ptr as usize },
8359 50usize,
8360 concat!(
8361 "Offset of field: ",
8362 stringify!(StdVideoEncodeH265SliceSegmentLongTermRefPics),
8363 "::",
8364 stringify!(used_by_curr_pic_lt_flag)
8365 )
8366 );
8367 assert_eq!(
8368 unsafe { ::std::ptr::addr_of!((*ptr).delta_poc_msb_present_flag) as usize - ptr as usize },
8369 52usize,
8370 concat!(
8371 "Offset of field: ",
8372 stringify!(StdVideoEncodeH265SliceSegmentLongTermRefPics),
8373 "::",
8374 stringify!(delta_poc_msb_present_flag)
8375 )
8376 );
8377 assert_eq!(
8378 unsafe { ::std::ptr::addr_of!((*ptr).delta_poc_msb_cycle_lt) as usize - ptr as usize },
8379 100usize,
8380 concat!(
8381 "Offset of field: ",
8382 stringify!(StdVideoEncodeH265SliceSegmentLongTermRefPics),
8383 "::",
8384 stringify!(delta_poc_msb_cycle_lt)
8385 )
8386 );
8387}
8388#[repr(C)]
8389#[derive(Debug, Copy, Clone)]
8390pub struct StdVideoEncodeH265SliceSegmentHeader {
8391 pub flags: StdVideoEncodeH265SliceSegmentHeaderFlags,
8392 pub slice_type: StdVideoH265SliceType,
8393 pub slice_segment_address: u32,
8394 pub short_term_ref_pic_set_idx: u8,
8395 pub collocated_ref_idx: u8,
8396 pub num_ref_idx_l0_active_minus1: u8,
8397 pub num_ref_idx_l1_active_minus1: u8,
8398 pub MaxNumMergeCand: u8,
8399 pub slice_cb_qp_offset: i8,
8400 pub slice_cr_qp_offset: i8,
8401 pub slice_beta_offset_div2: i8,
8402 pub slice_tc_offset_div2: i8,
8403 pub slice_act_y_qp_offset: i8,
8404 pub slice_act_cb_qp_offset: i8,
8405 pub slice_act_cr_qp_offset: i8,
8406 pub pShortTermRefPicSet: *const StdVideoH265ShortTermRefPicSet,
8407 pub pLongTermRefPics: *const StdVideoEncodeH265SliceSegmentLongTermRefPics,
8408 pub pWeightTable: *const StdVideoEncodeH265WeightTable,
8409}
8410#[test]
8411fn bindgen_test_layout_StdVideoEncodeH265SliceSegmentHeader() {
8412 const UNINIT: ::std::mem::MaybeUninit<StdVideoEncodeH265SliceSegmentHeader> =
8413 ::std::mem::MaybeUninit::uninit();
8414 let ptr = UNINIT.as_ptr();
8415 assert_eq!(
8416 ::std::mem::size_of::<StdVideoEncodeH265SliceSegmentHeader>(),
8417 48usize,
8418 concat!(
8419 "Size of: ",
8420 stringify!(StdVideoEncodeH265SliceSegmentHeader)
8421 )
8422 );
8423 assert_eq!(
8424 ::std::mem::align_of::<StdVideoEncodeH265SliceSegmentHeader>(),
8425 8usize,
8426 concat!(
8427 "Alignment of ",
8428 stringify!(StdVideoEncodeH265SliceSegmentHeader)
8429 )
8430 );
8431 assert_eq!(
8432 unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
8433 0usize,
8434 concat!(
8435 "Offset of field: ",
8436 stringify!(StdVideoEncodeH265SliceSegmentHeader),
8437 "::",
8438 stringify!(flags)
8439 )
8440 );
8441 assert_eq!(
8442 unsafe { ::std::ptr::addr_of!((*ptr).slice_type) as usize - ptr as usize },
8443 4usize,
8444 concat!(
8445 "Offset of field: ",
8446 stringify!(StdVideoEncodeH265SliceSegmentHeader),
8447 "::",
8448 stringify!(slice_type)
8449 )
8450 );
8451 assert_eq!(
8452 unsafe { ::std::ptr::addr_of!((*ptr).slice_segment_address) as usize - ptr as usize },
8453 8usize,
8454 concat!(
8455 "Offset of field: ",
8456 stringify!(StdVideoEncodeH265SliceSegmentHeader),
8457 "::",
8458 stringify!(slice_segment_address)
8459 )
8460 );
8461 assert_eq!(
8462 unsafe { ::std::ptr::addr_of!((*ptr).short_term_ref_pic_set_idx) as usize - ptr as usize },
8463 12usize,
8464 concat!(
8465 "Offset of field: ",
8466 stringify!(StdVideoEncodeH265SliceSegmentHeader),
8467 "::",
8468 stringify!(short_term_ref_pic_set_idx)
8469 )
8470 );
8471 assert_eq!(
8472 unsafe { ::std::ptr::addr_of!((*ptr).collocated_ref_idx) as usize - ptr as usize },
8473 13usize,
8474 concat!(
8475 "Offset of field: ",
8476 stringify!(StdVideoEncodeH265SliceSegmentHeader),
8477 "::",
8478 stringify!(collocated_ref_idx)
8479 )
8480 );
8481 assert_eq!(
8482 unsafe {
8483 ::std::ptr::addr_of!((*ptr).num_ref_idx_l0_active_minus1) as usize - ptr as usize
8484 },
8485 14usize,
8486 concat!(
8487 "Offset of field: ",
8488 stringify!(StdVideoEncodeH265SliceSegmentHeader),
8489 "::",
8490 stringify!(num_ref_idx_l0_active_minus1)
8491 )
8492 );
8493 assert_eq!(
8494 unsafe {
8495 ::std::ptr::addr_of!((*ptr).num_ref_idx_l1_active_minus1) as usize - ptr as usize
8496 },
8497 15usize,
8498 concat!(
8499 "Offset of field: ",
8500 stringify!(StdVideoEncodeH265SliceSegmentHeader),
8501 "::",
8502 stringify!(num_ref_idx_l1_active_minus1)
8503 )
8504 );
8505 assert_eq!(
8506 unsafe { ::std::ptr::addr_of!((*ptr).MaxNumMergeCand) as usize - ptr as usize },
8507 16usize,
8508 concat!(
8509 "Offset of field: ",
8510 stringify!(StdVideoEncodeH265SliceSegmentHeader),
8511 "::",
8512 stringify!(MaxNumMergeCand)
8513 )
8514 );
8515 assert_eq!(
8516 unsafe { ::std::ptr::addr_of!((*ptr).slice_cb_qp_offset) as usize - ptr as usize },
8517 17usize,
8518 concat!(
8519 "Offset of field: ",
8520 stringify!(StdVideoEncodeH265SliceSegmentHeader),
8521 "::",
8522 stringify!(slice_cb_qp_offset)
8523 )
8524 );
8525 assert_eq!(
8526 unsafe { ::std::ptr::addr_of!((*ptr).slice_cr_qp_offset) as usize - ptr as usize },
8527 18usize,
8528 concat!(
8529 "Offset of field: ",
8530 stringify!(StdVideoEncodeH265SliceSegmentHeader),
8531 "::",
8532 stringify!(slice_cr_qp_offset)
8533 )
8534 );
8535 assert_eq!(
8536 unsafe { ::std::ptr::addr_of!((*ptr).slice_beta_offset_div2) as usize - ptr as usize },
8537 19usize,
8538 concat!(
8539 "Offset of field: ",
8540 stringify!(StdVideoEncodeH265SliceSegmentHeader),
8541 "::",
8542 stringify!(slice_beta_offset_div2)
8543 )
8544 );
8545 assert_eq!(
8546 unsafe { ::std::ptr::addr_of!((*ptr).slice_tc_offset_div2) as usize - ptr as usize },
8547 20usize,
8548 concat!(
8549 "Offset of field: ",
8550 stringify!(StdVideoEncodeH265SliceSegmentHeader),
8551 "::",
8552 stringify!(slice_tc_offset_div2)
8553 )
8554 );
8555 assert_eq!(
8556 unsafe { ::std::ptr::addr_of!((*ptr).slice_act_y_qp_offset) as usize - ptr as usize },
8557 21usize,
8558 concat!(
8559 "Offset of field: ",
8560 stringify!(StdVideoEncodeH265SliceSegmentHeader),
8561 "::",
8562 stringify!(slice_act_y_qp_offset)
8563 )
8564 );
8565 assert_eq!(
8566 unsafe { ::std::ptr::addr_of!((*ptr).slice_act_cb_qp_offset) as usize - ptr as usize },
8567 22usize,
8568 concat!(
8569 "Offset of field: ",
8570 stringify!(StdVideoEncodeH265SliceSegmentHeader),
8571 "::",
8572 stringify!(slice_act_cb_qp_offset)
8573 )
8574 );
8575 assert_eq!(
8576 unsafe { ::std::ptr::addr_of!((*ptr).slice_act_cr_qp_offset) as usize - ptr as usize },
8577 23usize,
8578 concat!(
8579 "Offset of field: ",
8580 stringify!(StdVideoEncodeH265SliceSegmentHeader),
8581 "::",
8582 stringify!(slice_act_cr_qp_offset)
8583 )
8584 );
8585 assert_eq!(
8586 unsafe { ::std::ptr::addr_of!((*ptr).pShortTermRefPicSet) as usize - ptr as usize },
8587 24usize,
8588 concat!(
8589 "Offset of field: ",
8590 stringify!(StdVideoEncodeH265SliceSegmentHeader),
8591 "::",
8592 stringify!(pShortTermRefPicSet)
8593 )
8594 );
8595 assert_eq!(
8596 unsafe { ::std::ptr::addr_of!((*ptr).pLongTermRefPics) as usize - ptr as usize },
8597 32usize,
8598 concat!(
8599 "Offset of field: ",
8600 stringify!(StdVideoEncodeH265SliceSegmentHeader),
8601 "::",
8602 stringify!(pLongTermRefPics)
8603 )
8604 );
8605 assert_eq!(
8606 unsafe { ::std::ptr::addr_of!((*ptr).pWeightTable) as usize - ptr as usize },
8607 40usize,
8608 concat!(
8609 "Offset of field: ",
8610 stringify!(StdVideoEncodeH265SliceSegmentHeader),
8611 "::",
8612 stringify!(pWeightTable)
8613 )
8614 );
8615}
8616#[repr(C)]
8617#[repr(align(4))]
8618#[derive(Debug, Copy, Clone)]
8619pub struct StdVideoEncodeH265ReferenceListsInfoFlags {
8620 pub _bitfield_align_1: [u8; 0],
8621 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
8622 pub __bindgen_padding_0: [u8; 3usize],
8623}
8624#[test]
8625fn bindgen_test_layout_StdVideoEncodeH265ReferenceListsInfoFlags() {
8626 assert_eq!(
8627 ::std::mem::size_of::<StdVideoEncodeH265ReferenceListsInfoFlags>(),
8628 4usize,
8629 concat!(
8630 "Size of: ",
8631 stringify!(StdVideoEncodeH265ReferenceListsInfoFlags)
8632 )
8633 );
8634 assert_eq!(
8635 ::std::mem::align_of::<StdVideoEncodeH265ReferenceListsInfoFlags>(),
8636 4usize,
8637 concat!(
8638 "Alignment of ",
8639 stringify!(StdVideoEncodeH265ReferenceListsInfoFlags)
8640 )
8641 );
8642}
8643impl StdVideoEncodeH265ReferenceListsInfoFlags {
8644 #[inline]
8645 pub fn ref_pic_list_modification_flag_l0(&self) -> u32 {
8646 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
8647 }
8648 #[inline]
8649 pub fn set_ref_pic_list_modification_flag_l0(&mut self, val: u32) {
8650 unsafe {
8651 let val: u32 = ::std::mem::transmute(val);
8652 self._bitfield_1.set(0usize, 1u8, val as u64)
8653 }
8654 }
8655 #[inline]
8656 pub fn ref_pic_list_modification_flag_l1(&self) -> u32 {
8657 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
8658 }
8659 #[inline]
8660 pub fn set_ref_pic_list_modification_flag_l1(&mut self, val: u32) {
8661 unsafe {
8662 let val: u32 = ::std::mem::transmute(val);
8663 self._bitfield_1.set(1usize, 1u8, val as u64)
8664 }
8665 }
8666 #[inline]
8667 pub fn new_bitfield_1(
8668 ref_pic_list_modification_flag_l0: u32,
8669 ref_pic_list_modification_flag_l1: u32,
8670 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
8671 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
8672 __bindgen_bitfield_unit.set(0usize, 1u8, {
8673 let ref_pic_list_modification_flag_l0: u32 =
8674 unsafe { ::std::mem::transmute(ref_pic_list_modification_flag_l0) };
8675 ref_pic_list_modification_flag_l0 as u64
8676 });
8677 __bindgen_bitfield_unit.set(1usize, 1u8, {
8678 let ref_pic_list_modification_flag_l1: u32 =
8679 unsafe { ::std::mem::transmute(ref_pic_list_modification_flag_l1) };
8680 ref_pic_list_modification_flag_l1 as u64
8681 });
8682 __bindgen_bitfield_unit
8683 }
8684}
8685#[repr(C)]
8686#[derive(Debug, Copy, Clone)]
8687pub struct StdVideoEncodeH265ReferenceListsInfo {
8688 pub flags: StdVideoEncodeH265ReferenceListsInfoFlags,
8689 pub num_ref_idx_l0_active_minus1: u8,
8690 pub num_ref_idx_l1_active_minus1: u8,
8691 pub reserved1: u16,
8692 pub pRefPicList0Entries: *const u8,
8693 pub pRefPicList1Entries: *const u8,
8694 pub pRefList0Modifications: *const u8,
8695 pub pRefList1Modifications: *const u8,
8696}
8697#[test]
8698fn bindgen_test_layout_StdVideoEncodeH265ReferenceListsInfo() {
8699 const UNINIT: ::std::mem::MaybeUninit<StdVideoEncodeH265ReferenceListsInfo> =
8700 ::std::mem::MaybeUninit::uninit();
8701 let ptr = UNINIT.as_ptr();
8702 assert_eq!(
8703 ::std::mem::size_of::<StdVideoEncodeH265ReferenceListsInfo>(),
8704 40usize,
8705 concat!(
8706 "Size of: ",
8707 stringify!(StdVideoEncodeH265ReferenceListsInfo)
8708 )
8709 );
8710 assert_eq!(
8711 ::std::mem::align_of::<StdVideoEncodeH265ReferenceListsInfo>(),
8712 8usize,
8713 concat!(
8714 "Alignment of ",
8715 stringify!(StdVideoEncodeH265ReferenceListsInfo)
8716 )
8717 );
8718 assert_eq!(
8719 unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
8720 0usize,
8721 concat!(
8722 "Offset of field: ",
8723 stringify!(StdVideoEncodeH265ReferenceListsInfo),
8724 "::",
8725 stringify!(flags)
8726 )
8727 );
8728 assert_eq!(
8729 unsafe {
8730 ::std::ptr::addr_of!((*ptr).num_ref_idx_l0_active_minus1) as usize - ptr as usize
8731 },
8732 4usize,
8733 concat!(
8734 "Offset of field: ",
8735 stringify!(StdVideoEncodeH265ReferenceListsInfo),
8736 "::",
8737 stringify!(num_ref_idx_l0_active_minus1)
8738 )
8739 );
8740 assert_eq!(
8741 unsafe {
8742 ::std::ptr::addr_of!((*ptr).num_ref_idx_l1_active_minus1) as usize - ptr as usize
8743 },
8744 5usize,
8745 concat!(
8746 "Offset of field: ",
8747 stringify!(StdVideoEncodeH265ReferenceListsInfo),
8748 "::",
8749 stringify!(num_ref_idx_l1_active_minus1)
8750 )
8751 );
8752 assert_eq!(
8753 unsafe { ::std::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize },
8754 6usize,
8755 concat!(
8756 "Offset of field: ",
8757 stringify!(StdVideoEncodeH265ReferenceListsInfo),
8758 "::",
8759 stringify!(reserved1)
8760 )
8761 );
8762 assert_eq!(
8763 unsafe { ::std::ptr::addr_of!((*ptr).pRefPicList0Entries) as usize - ptr as usize },
8764 8usize,
8765 concat!(
8766 "Offset of field: ",
8767 stringify!(StdVideoEncodeH265ReferenceListsInfo),
8768 "::",
8769 stringify!(pRefPicList0Entries)
8770 )
8771 );
8772 assert_eq!(
8773 unsafe { ::std::ptr::addr_of!((*ptr).pRefPicList1Entries) as usize - ptr as usize },
8774 16usize,
8775 concat!(
8776 "Offset of field: ",
8777 stringify!(StdVideoEncodeH265ReferenceListsInfo),
8778 "::",
8779 stringify!(pRefPicList1Entries)
8780 )
8781 );
8782 assert_eq!(
8783 unsafe { ::std::ptr::addr_of!((*ptr).pRefList0Modifications) as usize - ptr as usize },
8784 24usize,
8785 concat!(
8786 "Offset of field: ",
8787 stringify!(StdVideoEncodeH265ReferenceListsInfo),
8788 "::",
8789 stringify!(pRefList0Modifications)
8790 )
8791 );
8792 assert_eq!(
8793 unsafe { ::std::ptr::addr_of!((*ptr).pRefList1Modifications) as usize - ptr as usize },
8794 32usize,
8795 concat!(
8796 "Offset of field: ",
8797 stringify!(StdVideoEncodeH265ReferenceListsInfo),
8798 "::",
8799 stringify!(pRefList1Modifications)
8800 )
8801 );
8802}
8803#[repr(C)]
8804#[repr(align(4))]
8805#[derive(Debug, Copy, Clone)]
8806pub struct StdVideoEncodeH265PictureInfoFlags {
8807 pub _bitfield_align_1: [u8; 0],
8808 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
8809 pub __bindgen_padding_0: [u8; 3usize],
8810}
8811#[test]
8812fn bindgen_test_layout_StdVideoEncodeH265PictureInfoFlags() {
8813 assert_eq!(
8814 ::std::mem::size_of::<StdVideoEncodeH265PictureInfoFlags>(),
8815 4usize,
8816 concat!("Size of: ", stringify!(StdVideoEncodeH265PictureInfoFlags))
8817 );
8818 assert_eq!(
8819 ::std::mem::align_of::<StdVideoEncodeH265PictureInfoFlags>(),
8820 4usize,
8821 concat!(
8822 "Alignment of ",
8823 stringify!(StdVideoEncodeH265PictureInfoFlags)
8824 )
8825 );
8826}
8827impl StdVideoEncodeH265PictureInfoFlags {
8828 #[inline]
8829 pub fn is_reference_flag(&self) -> u32 {
8830 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
8831 }
8832 #[inline]
8833 pub fn set_is_reference_flag(&mut self, val: u32) {
8834 unsafe {
8835 let val: u32 = ::std::mem::transmute(val);
8836 self._bitfield_1.set(0usize, 1u8, val as u64)
8837 }
8838 }
8839 #[inline]
8840 pub fn IrapPicFlag(&self) -> u32 {
8841 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
8842 }
8843 #[inline]
8844 pub fn set_IrapPicFlag(&mut self, val: u32) {
8845 unsafe {
8846 let val: u32 = ::std::mem::transmute(val);
8847 self._bitfield_1.set(1usize, 1u8, val as u64)
8848 }
8849 }
8850 #[inline]
8851 pub fn long_term_flag(&self) -> u32 {
8852 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
8853 }
8854 #[inline]
8855 pub fn set_long_term_flag(&mut self, val: u32) {
8856 unsafe {
8857 let val: u32 = ::std::mem::transmute(val);
8858 self._bitfield_1.set(2usize, 1u8, val as u64)
8859 }
8860 }
8861 #[inline]
8862 pub fn discardable_flag(&self) -> u32 {
8863 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
8864 }
8865 #[inline]
8866 pub fn set_discardable_flag(&mut self, val: u32) {
8867 unsafe {
8868 let val: u32 = ::std::mem::transmute(val);
8869 self._bitfield_1.set(3usize, 1u8, val as u64)
8870 }
8871 }
8872 #[inline]
8873 pub fn cross_layer_bla_flag(&self) -> u32 {
8874 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
8875 }
8876 #[inline]
8877 pub fn set_cross_layer_bla_flag(&mut self, val: u32) {
8878 unsafe {
8879 let val: u32 = ::std::mem::transmute(val);
8880 self._bitfield_1.set(4usize, 1u8, val as u64)
8881 }
8882 }
8883 #[inline]
8884 pub fn new_bitfield_1(
8885 is_reference_flag: u32,
8886 IrapPicFlag: u32,
8887 long_term_flag: u32,
8888 discardable_flag: u32,
8889 cross_layer_bla_flag: u32,
8890 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
8891 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
8892 __bindgen_bitfield_unit.set(0usize, 1u8, {
8893 let is_reference_flag: u32 = unsafe { ::std::mem::transmute(is_reference_flag) };
8894 is_reference_flag as u64
8895 });
8896 __bindgen_bitfield_unit.set(1usize, 1u8, {
8897 let IrapPicFlag: u32 = unsafe { ::std::mem::transmute(IrapPicFlag) };
8898 IrapPicFlag as u64
8899 });
8900 __bindgen_bitfield_unit.set(2usize, 1u8, {
8901 let long_term_flag: u32 = unsafe { ::std::mem::transmute(long_term_flag) };
8902 long_term_flag as u64
8903 });
8904 __bindgen_bitfield_unit.set(3usize, 1u8, {
8905 let discardable_flag: u32 = unsafe { ::std::mem::transmute(discardable_flag) };
8906 discardable_flag as u64
8907 });
8908 __bindgen_bitfield_unit.set(4usize, 1u8, {
8909 let cross_layer_bla_flag: u32 = unsafe { ::std::mem::transmute(cross_layer_bla_flag) };
8910 cross_layer_bla_flag as u64
8911 });
8912 __bindgen_bitfield_unit
8913 }
8914}
8915#[repr(C)]
8916#[derive(Debug, Copy, Clone)]
8917pub struct StdVideoEncodeH265PictureInfo {
8918 pub flags: StdVideoEncodeH265PictureInfoFlags,
8919 pub PictureType: StdVideoH265PictureType,
8920 pub sps_video_parameter_set_id: u8,
8921 pub pps_seq_parameter_set_id: u8,
8922 pub pps_pic_parameter_set_id: u8,
8923 pub TemporalId: u8,
8924 pub PicOrderCntVal: i32,
8925}
8926#[test]
8927fn bindgen_test_layout_StdVideoEncodeH265PictureInfo() {
8928 const UNINIT: ::std::mem::MaybeUninit<StdVideoEncodeH265PictureInfo> =
8929 ::std::mem::MaybeUninit::uninit();
8930 let ptr = UNINIT.as_ptr();
8931 assert_eq!(
8932 ::std::mem::size_of::<StdVideoEncodeH265PictureInfo>(),
8933 16usize,
8934 concat!("Size of: ", stringify!(StdVideoEncodeH265PictureInfo))
8935 );
8936 assert_eq!(
8937 ::std::mem::align_of::<StdVideoEncodeH265PictureInfo>(),
8938 4usize,
8939 concat!("Alignment of ", stringify!(StdVideoEncodeH265PictureInfo))
8940 );
8941 assert_eq!(
8942 unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
8943 0usize,
8944 concat!(
8945 "Offset of field: ",
8946 stringify!(StdVideoEncodeH265PictureInfo),
8947 "::",
8948 stringify!(flags)
8949 )
8950 );
8951 assert_eq!(
8952 unsafe { ::std::ptr::addr_of!((*ptr).PictureType) as usize - ptr as usize },
8953 4usize,
8954 concat!(
8955 "Offset of field: ",
8956 stringify!(StdVideoEncodeH265PictureInfo),
8957 "::",
8958 stringify!(PictureType)
8959 )
8960 );
8961 assert_eq!(
8962 unsafe { ::std::ptr::addr_of!((*ptr).sps_video_parameter_set_id) as usize - ptr as usize },
8963 8usize,
8964 concat!(
8965 "Offset of field: ",
8966 stringify!(StdVideoEncodeH265PictureInfo),
8967 "::",
8968 stringify!(sps_video_parameter_set_id)
8969 )
8970 );
8971 assert_eq!(
8972 unsafe { ::std::ptr::addr_of!((*ptr).pps_seq_parameter_set_id) as usize - ptr as usize },
8973 9usize,
8974 concat!(
8975 "Offset of field: ",
8976 stringify!(StdVideoEncodeH265PictureInfo),
8977 "::",
8978 stringify!(pps_seq_parameter_set_id)
8979 )
8980 );
8981 assert_eq!(
8982 unsafe { ::std::ptr::addr_of!((*ptr).pps_pic_parameter_set_id) as usize - ptr as usize },
8983 10usize,
8984 concat!(
8985 "Offset of field: ",
8986 stringify!(StdVideoEncodeH265PictureInfo),
8987 "::",
8988 stringify!(pps_pic_parameter_set_id)
8989 )
8990 );
8991 assert_eq!(
8992 unsafe { ::std::ptr::addr_of!((*ptr).TemporalId) as usize - ptr as usize },
8993 11usize,
8994 concat!(
8995 "Offset of field: ",
8996 stringify!(StdVideoEncodeH265PictureInfo),
8997 "::",
8998 stringify!(TemporalId)
8999 )
9000 );
9001 assert_eq!(
9002 unsafe { ::std::ptr::addr_of!((*ptr).PicOrderCntVal) as usize - ptr as usize },
9003 12usize,
9004 concat!(
9005 "Offset of field: ",
9006 stringify!(StdVideoEncodeH265PictureInfo),
9007 "::",
9008 stringify!(PicOrderCntVal)
9009 )
9010 );
9011}
9012#[repr(C)]
9013#[repr(align(4))]
9014#[derive(Debug, Copy, Clone)]
9015pub struct StdVideoEncodeH265ReferenceInfoFlags {
9016 pub _bitfield_align_1: [u8; 0],
9017 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
9018 pub __bindgen_padding_0: [u8; 3usize],
9019}
9020#[test]
9021fn bindgen_test_layout_StdVideoEncodeH265ReferenceInfoFlags() {
9022 assert_eq!(
9023 ::std::mem::size_of::<StdVideoEncodeH265ReferenceInfoFlags>(),
9024 4usize,
9025 concat!(
9026 "Size of: ",
9027 stringify!(StdVideoEncodeH265ReferenceInfoFlags)
9028 )
9029 );
9030 assert_eq!(
9031 ::std::mem::align_of::<StdVideoEncodeH265ReferenceInfoFlags>(),
9032 4usize,
9033 concat!(
9034 "Alignment of ",
9035 stringify!(StdVideoEncodeH265ReferenceInfoFlags)
9036 )
9037 );
9038}
9039impl StdVideoEncodeH265ReferenceInfoFlags {
9040 #[inline]
9041 pub fn used_for_long_term_reference(&self) -> u32 {
9042 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
9043 }
9044 #[inline]
9045 pub fn set_used_for_long_term_reference(&mut self, val: u32) {
9046 unsafe {
9047 let val: u32 = ::std::mem::transmute(val);
9048 self._bitfield_1.set(0usize, 1u8, val as u64)
9049 }
9050 }
9051 #[inline]
9052 pub fn unused_for_reference(&self) -> u32 {
9053 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
9054 }
9055 #[inline]
9056 pub fn set_unused_for_reference(&mut self, val: u32) {
9057 unsafe {
9058 let val: u32 = ::std::mem::transmute(val);
9059 self._bitfield_1.set(1usize, 1u8, val as u64)
9060 }
9061 }
9062 #[inline]
9063 pub fn new_bitfield_1(
9064 used_for_long_term_reference: u32,
9065 unused_for_reference: u32,
9066 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
9067 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
9068 __bindgen_bitfield_unit.set(0usize, 1u8, {
9069 let used_for_long_term_reference: u32 =
9070 unsafe { ::std::mem::transmute(used_for_long_term_reference) };
9071 used_for_long_term_reference as u64
9072 });
9073 __bindgen_bitfield_unit.set(1usize, 1u8, {
9074 let unused_for_reference: u32 = unsafe { ::std::mem::transmute(unused_for_reference) };
9075 unused_for_reference as u64
9076 });
9077 __bindgen_bitfield_unit
9078 }
9079}
9080#[repr(C)]
9081#[derive(Debug, Copy, Clone)]
9082pub struct StdVideoEncodeH265ReferenceInfo {
9083 pub flags: StdVideoEncodeH265ReferenceInfoFlags,
9084 pub PictureType: StdVideoH265PictureType,
9085 pub PicOrderCntVal: i32,
9086 pub TemporalId: u8,
9087}
9088#[test]
9089fn bindgen_test_layout_StdVideoEncodeH265ReferenceInfo() {
9090 const UNINIT: ::std::mem::MaybeUninit<StdVideoEncodeH265ReferenceInfo> =
9091 ::std::mem::MaybeUninit::uninit();
9092 let ptr = UNINIT.as_ptr();
9093 assert_eq!(
9094 ::std::mem::size_of::<StdVideoEncodeH265ReferenceInfo>(),
9095 16usize,
9096 concat!("Size of: ", stringify!(StdVideoEncodeH265ReferenceInfo))
9097 );
9098 assert_eq!(
9099 ::std::mem::align_of::<StdVideoEncodeH265ReferenceInfo>(),
9100 4usize,
9101 concat!("Alignment of ", stringify!(StdVideoEncodeH265ReferenceInfo))
9102 );
9103 assert_eq!(
9104 unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
9105 0usize,
9106 concat!(
9107 "Offset of field: ",
9108 stringify!(StdVideoEncodeH265ReferenceInfo),
9109 "::",
9110 stringify!(flags)
9111 )
9112 );
9113 assert_eq!(
9114 unsafe { ::std::ptr::addr_of!((*ptr).PictureType) as usize - ptr as usize },
9115 4usize,
9116 concat!(
9117 "Offset of field: ",
9118 stringify!(StdVideoEncodeH265ReferenceInfo),
9119 "::",
9120 stringify!(PictureType)
9121 )
9122 );
9123 assert_eq!(
9124 unsafe { ::std::ptr::addr_of!((*ptr).PicOrderCntVal) as usize - ptr as usize },
9125 8usize,
9126 concat!(
9127 "Offset of field: ",
9128 stringify!(StdVideoEncodeH265ReferenceInfo),
9129 "::",
9130 stringify!(PicOrderCntVal)
9131 )
9132 );
9133 assert_eq!(
9134 unsafe { ::std::ptr::addr_of!((*ptr).TemporalId) as usize - ptr as usize },
9135 12usize,
9136 concat!(
9137 "Offset of field: ",
9138 stringify!(StdVideoEncodeH265ReferenceInfo),
9139 "::",
9140 stringify!(TemporalId)
9141 )
9142 );
9143}