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 = ::core::ffi::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 = ::core::ffi::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 = ::core::ffi::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 = ::core::ffi::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 = ::core::ffi::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 = ::core::ffi::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 = ::core::ffi::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 = ::core::ffi::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 = ::core::ffi::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 = ::core::ffi::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 = ::core::ffi::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 = ::core::ffi::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 ::core::mem::size_of::<StdVideoH264SpsVuiFlags>(),
234 4usize,
235 concat!("Size of: ", stringify!(StdVideoH264SpsVuiFlags))
236 );
237 assert_eq!(
238 ::core::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 { ::core::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 = ::core::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 { ::core::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 = ::core::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 { ::core::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 = ::core::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 { ::core::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 = ::core::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 { ::core::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 = ::core::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 { ::core::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 = ::core::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 { ::core::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 = ::core::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 { ::core::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 = ::core::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 { ::core::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 = ::core::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 { ::core::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 = ::core::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 { ::core::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 = ::core::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 { ::core::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 = ::core::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 { ::core::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 { ::core::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 { ::core::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 { ::core::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 { ::core::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 { ::core::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 { ::core::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 { ::core::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 { ::core::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 { ::core::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 { ::core::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 { ::core::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: ::core::mem::MaybeUninit<StdVideoH264HrdParameters> =
473 ::core::mem::MaybeUninit::uninit();
474 let ptr = UNINIT.as_ptr();
475 assert_eq!(
476 ::core::mem::size_of::<StdVideoH264HrdParameters>(),
477 308usize,
478 concat!("Size of: ", stringify!(StdVideoH264HrdParameters))
479 );
480 assert_eq!(
481 ::core::mem::align_of::<StdVideoH264HrdParameters>(),
482 4usize,
483 concat!("Alignment of ", stringify!(StdVideoH264HrdParameters))
484 );
485 assert_eq!(
486 unsafe { ::core::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 { ::core::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 { ::core::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 { ::core::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 { ::core::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 { ::core::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 { ::core::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 ::core::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 ::core::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 ::core::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 { ::core::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: ::core::mem::MaybeUninit<StdVideoH264SequenceParameterSetVui> =
626 ::core::mem::MaybeUninit::uninit();
627 let ptr = UNINIT.as_ptr();
628 assert_eq!(
629 ::core::mem::size_of::<StdVideoH264SequenceParameterSetVui>(),
630 40usize,
631 concat!("Size of: ", stringify!(StdVideoH264SequenceParameterSetVui))
632 );
633 assert_eq!(
634 ::core::mem::align_of::<StdVideoH264SequenceParameterSetVui>(),
635 8usize,
636 concat!(
637 "Alignment of ",
638 stringify!(StdVideoH264SequenceParameterSetVui)
639 )
640 );
641 assert_eq!(
642 unsafe { ::core::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 { ::core::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 { ::core::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 { ::core::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 { ::core::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 { ::core::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 { ::core::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 { ::core::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 { ::core::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 { ::core::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 { ::core::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 { ::core::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 ::core::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 ::core::ptr::addr_of!((*ptr).chroma_sample_loc_type_bottom_field) as usize
776 - ptr as usize
777 },
778 27usize,
779 concat!(
780 "Offset of field: ",
781 stringify!(StdVideoH264SequenceParameterSetVui),
782 "::",
783 stringify!(chroma_sample_loc_type_bottom_field)
784 )
785 );
786 assert_eq!(
787 unsafe { ::core::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize },
788 28usize,
789 concat!(
790 "Offset of field: ",
791 stringify!(StdVideoH264SequenceParameterSetVui),
792 "::",
793 stringify!(reserved1)
794 )
795 );
796 assert_eq!(
797 unsafe { ::core::ptr::addr_of!((*ptr).pHrdParameters) as usize - ptr as usize },
798 32usize,
799 concat!(
800 "Offset of field: ",
801 stringify!(StdVideoH264SequenceParameterSetVui),
802 "::",
803 stringify!(pHrdParameters)
804 )
805 );
806}
807#[repr(C)]
808#[repr(align(4))]
809#[derive(Debug, Copy, Clone)]
810pub struct StdVideoH264SpsFlags {
811 pub _bitfield_align_1: [u8; 0],
812 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
813 pub __bindgen_padding_0: u16,
814}
815#[test]
816fn bindgen_test_layout_StdVideoH264SpsFlags() {
817 assert_eq!(
818 ::core::mem::size_of::<StdVideoH264SpsFlags>(),
819 4usize,
820 concat!("Size of: ", stringify!(StdVideoH264SpsFlags))
821 );
822 assert_eq!(
823 ::core::mem::align_of::<StdVideoH264SpsFlags>(),
824 4usize,
825 concat!("Alignment of ", stringify!(StdVideoH264SpsFlags))
826 );
827}
828impl StdVideoH264SpsFlags {
829 #[inline]
830 pub fn constraint_set0_flag(&self) -> u32 {
831 unsafe { ::core::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
832 }
833 #[inline]
834 pub fn set_constraint_set0_flag(&mut self, val: u32) {
835 unsafe {
836 let val: u32 = ::core::mem::transmute(val);
837 self._bitfield_1.set(0usize, 1u8, val as u64)
838 }
839 }
840 #[inline]
841 pub fn constraint_set1_flag(&self) -> u32 {
842 unsafe { ::core::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
843 }
844 #[inline]
845 pub fn set_constraint_set1_flag(&mut self, val: u32) {
846 unsafe {
847 let val: u32 = ::core::mem::transmute(val);
848 self._bitfield_1.set(1usize, 1u8, val as u64)
849 }
850 }
851 #[inline]
852 pub fn constraint_set2_flag(&self) -> u32 {
853 unsafe { ::core::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
854 }
855 #[inline]
856 pub fn set_constraint_set2_flag(&mut self, val: u32) {
857 unsafe {
858 let val: u32 = ::core::mem::transmute(val);
859 self._bitfield_1.set(2usize, 1u8, val as u64)
860 }
861 }
862 #[inline]
863 pub fn constraint_set3_flag(&self) -> u32 {
864 unsafe { ::core::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
865 }
866 #[inline]
867 pub fn set_constraint_set3_flag(&mut self, val: u32) {
868 unsafe {
869 let val: u32 = ::core::mem::transmute(val);
870 self._bitfield_1.set(3usize, 1u8, val as u64)
871 }
872 }
873 #[inline]
874 pub fn constraint_set4_flag(&self) -> u32 {
875 unsafe { ::core::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
876 }
877 #[inline]
878 pub fn set_constraint_set4_flag(&mut self, val: u32) {
879 unsafe {
880 let val: u32 = ::core::mem::transmute(val);
881 self._bitfield_1.set(4usize, 1u8, val as u64)
882 }
883 }
884 #[inline]
885 pub fn constraint_set5_flag(&self) -> u32 {
886 unsafe { ::core::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
887 }
888 #[inline]
889 pub fn set_constraint_set5_flag(&mut self, val: u32) {
890 unsafe {
891 let val: u32 = ::core::mem::transmute(val);
892 self._bitfield_1.set(5usize, 1u8, val as u64)
893 }
894 }
895 #[inline]
896 pub fn direct_8x8_inference_flag(&self) -> u32 {
897 unsafe { ::core::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) }
898 }
899 #[inline]
900 pub fn set_direct_8x8_inference_flag(&mut self, val: u32) {
901 unsafe {
902 let val: u32 = ::core::mem::transmute(val);
903 self._bitfield_1.set(6usize, 1u8, val as u64)
904 }
905 }
906 #[inline]
907 pub fn mb_adaptive_frame_field_flag(&self) -> u32 {
908 unsafe { ::core::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) }
909 }
910 #[inline]
911 pub fn set_mb_adaptive_frame_field_flag(&mut self, val: u32) {
912 unsafe {
913 let val: u32 = ::core::mem::transmute(val);
914 self._bitfield_1.set(7usize, 1u8, val as u64)
915 }
916 }
917 #[inline]
918 pub fn frame_mbs_only_flag(&self) -> u32 {
919 unsafe { ::core::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) }
920 }
921 #[inline]
922 pub fn set_frame_mbs_only_flag(&mut self, val: u32) {
923 unsafe {
924 let val: u32 = ::core::mem::transmute(val);
925 self._bitfield_1.set(8usize, 1u8, val as u64)
926 }
927 }
928 #[inline]
929 pub fn delta_pic_order_always_zero_flag(&self) -> u32 {
930 unsafe { ::core::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) }
931 }
932 #[inline]
933 pub fn set_delta_pic_order_always_zero_flag(&mut self, val: u32) {
934 unsafe {
935 let val: u32 = ::core::mem::transmute(val);
936 self._bitfield_1.set(9usize, 1u8, val as u64)
937 }
938 }
939 #[inline]
940 pub fn separate_colour_plane_flag(&self) -> u32 {
941 unsafe { ::core::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) }
942 }
943 #[inline]
944 pub fn set_separate_colour_plane_flag(&mut self, val: u32) {
945 unsafe {
946 let val: u32 = ::core::mem::transmute(val);
947 self._bitfield_1.set(10usize, 1u8, val as u64)
948 }
949 }
950 #[inline]
951 pub fn gaps_in_frame_num_value_allowed_flag(&self) -> u32 {
952 unsafe { ::core::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) }
953 }
954 #[inline]
955 pub fn set_gaps_in_frame_num_value_allowed_flag(&mut self, val: u32) {
956 unsafe {
957 let val: u32 = ::core::mem::transmute(val);
958 self._bitfield_1.set(11usize, 1u8, val as u64)
959 }
960 }
961 #[inline]
962 pub fn qpprime_y_zero_transform_bypass_flag(&self) -> u32 {
963 unsafe { ::core::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u32) }
964 }
965 #[inline]
966 pub fn set_qpprime_y_zero_transform_bypass_flag(&mut self, val: u32) {
967 unsafe {
968 let val: u32 = ::core::mem::transmute(val);
969 self._bitfield_1.set(12usize, 1u8, val as u64)
970 }
971 }
972 #[inline]
973 pub fn frame_cropping_flag(&self) -> u32 {
974 unsafe { ::core::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) }
975 }
976 #[inline]
977 pub fn set_frame_cropping_flag(&mut self, val: u32) {
978 unsafe {
979 let val: u32 = ::core::mem::transmute(val);
980 self._bitfield_1.set(13usize, 1u8, val as u64)
981 }
982 }
983 #[inline]
984 pub fn seq_scaling_matrix_present_flag(&self) -> u32 {
985 unsafe { ::core::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) }
986 }
987 #[inline]
988 pub fn set_seq_scaling_matrix_present_flag(&mut self, val: u32) {
989 unsafe {
990 let val: u32 = ::core::mem::transmute(val);
991 self._bitfield_1.set(14usize, 1u8, val as u64)
992 }
993 }
994 #[inline]
995 pub fn vui_parameters_present_flag(&self) -> u32 {
996 unsafe { ::core::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u32) }
997 }
998 #[inline]
999 pub fn set_vui_parameters_present_flag(&mut self, val: u32) {
1000 unsafe {
1001 let val: u32 = ::core::mem::transmute(val);
1002 self._bitfield_1.set(15usize, 1u8, val as u64)
1003 }
1004 }
1005 #[inline]
1006 pub fn new_bitfield_1(
1007 constraint_set0_flag: u32,
1008 constraint_set1_flag: u32,
1009 constraint_set2_flag: u32,
1010 constraint_set3_flag: u32,
1011 constraint_set4_flag: u32,
1012 constraint_set5_flag: u32,
1013 direct_8x8_inference_flag: u32,
1014 mb_adaptive_frame_field_flag: u32,
1015 frame_mbs_only_flag: u32,
1016 delta_pic_order_always_zero_flag: u32,
1017 separate_colour_plane_flag: u32,
1018 gaps_in_frame_num_value_allowed_flag: u32,
1019 qpprime_y_zero_transform_bypass_flag: u32,
1020 frame_cropping_flag: u32,
1021 seq_scaling_matrix_present_flag: u32,
1022 vui_parameters_present_flag: u32,
1023 ) -> __BindgenBitfieldUnit<[u8; 2usize]> {
1024 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default();
1025 __bindgen_bitfield_unit.set(0usize, 1u8, {
1026 let constraint_set0_flag: u32 = unsafe { ::core::mem::transmute(constraint_set0_flag) };
1027 constraint_set0_flag as u64
1028 });
1029 __bindgen_bitfield_unit.set(1usize, 1u8, {
1030 let constraint_set1_flag: u32 = unsafe { ::core::mem::transmute(constraint_set1_flag) };
1031 constraint_set1_flag as u64
1032 });
1033 __bindgen_bitfield_unit.set(2usize, 1u8, {
1034 let constraint_set2_flag: u32 = unsafe { ::core::mem::transmute(constraint_set2_flag) };
1035 constraint_set2_flag as u64
1036 });
1037 __bindgen_bitfield_unit.set(3usize, 1u8, {
1038 let constraint_set3_flag: u32 = unsafe { ::core::mem::transmute(constraint_set3_flag) };
1039 constraint_set3_flag as u64
1040 });
1041 __bindgen_bitfield_unit.set(4usize, 1u8, {
1042 let constraint_set4_flag: u32 = unsafe { ::core::mem::transmute(constraint_set4_flag) };
1043 constraint_set4_flag as u64
1044 });
1045 __bindgen_bitfield_unit.set(5usize, 1u8, {
1046 let constraint_set5_flag: u32 = unsafe { ::core::mem::transmute(constraint_set5_flag) };
1047 constraint_set5_flag as u64
1048 });
1049 __bindgen_bitfield_unit.set(6usize, 1u8, {
1050 let direct_8x8_inference_flag: u32 =
1051 unsafe { ::core::mem::transmute(direct_8x8_inference_flag) };
1052 direct_8x8_inference_flag as u64
1053 });
1054 __bindgen_bitfield_unit.set(7usize, 1u8, {
1055 let mb_adaptive_frame_field_flag: u32 =
1056 unsafe { ::core::mem::transmute(mb_adaptive_frame_field_flag) };
1057 mb_adaptive_frame_field_flag as u64
1058 });
1059 __bindgen_bitfield_unit.set(8usize, 1u8, {
1060 let frame_mbs_only_flag: u32 = unsafe { ::core::mem::transmute(frame_mbs_only_flag) };
1061 frame_mbs_only_flag as u64
1062 });
1063 __bindgen_bitfield_unit.set(9usize, 1u8, {
1064 let delta_pic_order_always_zero_flag: u32 =
1065 unsafe { ::core::mem::transmute(delta_pic_order_always_zero_flag) };
1066 delta_pic_order_always_zero_flag as u64
1067 });
1068 __bindgen_bitfield_unit.set(10usize, 1u8, {
1069 let separate_colour_plane_flag: u32 =
1070 unsafe { ::core::mem::transmute(separate_colour_plane_flag) };
1071 separate_colour_plane_flag as u64
1072 });
1073 __bindgen_bitfield_unit.set(11usize, 1u8, {
1074 let gaps_in_frame_num_value_allowed_flag: u32 =
1075 unsafe { ::core::mem::transmute(gaps_in_frame_num_value_allowed_flag) };
1076 gaps_in_frame_num_value_allowed_flag as u64
1077 });
1078 __bindgen_bitfield_unit.set(12usize, 1u8, {
1079 let qpprime_y_zero_transform_bypass_flag: u32 =
1080 unsafe { ::core::mem::transmute(qpprime_y_zero_transform_bypass_flag) };
1081 qpprime_y_zero_transform_bypass_flag as u64
1082 });
1083 __bindgen_bitfield_unit.set(13usize, 1u8, {
1084 let frame_cropping_flag: u32 = unsafe { ::core::mem::transmute(frame_cropping_flag) };
1085 frame_cropping_flag as u64
1086 });
1087 __bindgen_bitfield_unit.set(14usize, 1u8, {
1088 let seq_scaling_matrix_present_flag: u32 =
1089 unsafe { ::core::mem::transmute(seq_scaling_matrix_present_flag) };
1090 seq_scaling_matrix_present_flag as u64
1091 });
1092 __bindgen_bitfield_unit.set(15usize, 1u8, {
1093 let vui_parameters_present_flag: u32 =
1094 unsafe { ::core::mem::transmute(vui_parameters_present_flag) };
1095 vui_parameters_present_flag as u64
1096 });
1097 __bindgen_bitfield_unit
1098 }
1099}
1100#[repr(C)]
1101#[derive(Debug, Copy, Clone)]
1102pub struct StdVideoH264ScalingLists {
1103 pub scaling_list_present_mask: u16,
1104 pub use_default_scaling_matrix_mask: u16,
1105 pub ScalingList4x4: [[u8; 16usize]; 6usize],
1106 pub ScalingList8x8: [[u8; 64usize]; 6usize],
1107}
1108#[test]
1109fn bindgen_test_layout_StdVideoH264ScalingLists() {
1110 const UNINIT: ::core::mem::MaybeUninit<StdVideoH264ScalingLists> =
1111 ::core::mem::MaybeUninit::uninit();
1112 let ptr = UNINIT.as_ptr();
1113 assert_eq!(
1114 ::core::mem::size_of::<StdVideoH264ScalingLists>(),
1115 484usize,
1116 concat!("Size of: ", stringify!(StdVideoH264ScalingLists))
1117 );
1118 assert_eq!(
1119 ::core::mem::align_of::<StdVideoH264ScalingLists>(),
1120 2usize,
1121 concat!("Alignment of ", stringify!(StdVideoH264ScalingLists))
1122 );
1123 assert_eq!(
1124 unsafe { ::core::ptr::addr_of!((*ptr).scaling_list_present_mask) as usize - ptr as usize },
1125 0usize,
1126 concat!(
1127 "Offset of field: ",
1128 stringify!(StdVideoH264ScalingLists),
1129 "::",
1130 stringify!(scaling_list_present_mask)
1131 )
1132 );
1133 assert_eq!(
1134 unsafe {
1135 ::core::ptr::addr_of!((*ptr).use_default_scaling_matrix_mask) as usize - ptr as usize
1136 },
1137 2usize,
1138 concat!(
1139 "Offset of field: ",
1140 stringify!(StdVideoH264ScalingLists),
1141 "::",
1142 stringify!(use_default_scaling_matrix_mask)
1143 )
1144 );
1145 assert_eq!(
1146 unsafe { ::core::ptr::addr_of!((*ptr).ScalingList4x4) as usize - ptr as usize },
1147 4usize,
1148 concat!(
1149 "Offset of field: ",
1150 stringify!(StdVideoH264ScalingLists),
1151 "::",
1152 stringify!(ScalingList4x4)
1153 )
1154 );
1155 assert_eq!(
1156 unsafe { ::core::ptr::addr_of!((*ptr).ScalingList8x8) as usize - ptr as usize },
1157 100usize,
1158 concat!(
1159 "Offset of field: ",
1160 stringify!(StdVideoH264ScalingLists),
1161 "::",
1162 stringify!(ScalingList8x8)
1163 )
1164 );
1165}
1166#[repr(C)]
1167#[derive(Debug, Copy, Clone)]
1168pub struct StdVideoH264SequenceParameterSet {
1169 pub flags: StdVideoH264SpsFlags,
1170 pub profile_idc: StdVideoH264ProfileIdc,
1171 pub level_idc: StdVideoH264LevelIdc,
1172 pub chroma_format_idc: StdVideoH264ChromaFormatIdc,
1173 pub seq_parameter_set_id: u8,
1174 pub bit_depth_luma_minus8: u8,
1175 pub bit_depth_chroma_minus8: u8,
1176 pub log2_max_frame_num_minus4: u8,
1177 pub pic_order_cnt_type: StdVideoH264PocType,
1178 pub offset_for_non_ref_pic: i32,
1179 pub offset_for_top_to_bottom_field: i32,
1180 pub log2_max_pic_order_cnt_lsb_minus4: u8,
1181 pub num_ref_frames_in_pic_order_cnt_cycle: u8,
1182 pub max_num_ref_frames: u8,
1183 pub reserved1: u8,
1184 pub pic_width_in_mbs_minus1: u32,
1185 pub pic_height_in_map_units_minus1: u32,
1186 pub frame_crop_left_offset: u32,
1187 pub frame_crop_right_offset: u32,
1188 pub frame_crop_top_offset: u32,
1189 pub frame_crop_bottom_offset: u32,
1190 pub reserved2: u32,
1191 pub pOffsetForRefFrame: *const i32,
1192 pub pScalingLists: *const StdVideoH264ScalingLists,
1193 pub pSequenceParameterSetVui: *const StdVideoH264SequenceParameterSetVui,
1194}
1195#[test]
1196fn bindgen_test_layout_StdVideoH264SequenceParameterSet() {
1197 const UNINIT: ::core::mem::MaybeUninit<StdVideoH264SequenceParameterSet> =
1198 ::core::mem::MaybeUninit::uninit();
1199 let ptr = UNINIT.as_ptr();
1200 assert_eq!(
1201 ::core::mem::size_of::<StdVideoH264SequenceParameterSet>(),
1202 88usize,
1203 concat!("Size of: ", stringify!(StdVideoH264SequenceParameterSet))
1204 );
1205 assert_eq!(
1206 ::core::mem::align_of::<StdVideoH264SequenceParameterSet>(),
1207 8usize,
1208 concat!(
1209 "Alignment of ",
1210 stringify!(StdVideoH264SequenceParameterSet)
1211 )
1212 );
1213 assert_eq!(
1214 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
1215 0usize,
1216 concat!(
1217 "Offset of field: ",
1218 stringify!(StdVideoH264SequenceParameterSet),
1219 "::",
1220 stringify!(flags)
1221 )
1222 );
1223 assert_eq!(
1224 unsafe { ::core::ptr::addr_of!((*ptr).profile_idc) as usize - ptr as usize },
1225 4usize,
1226 concat!(
1227 "Offset of field: ",
1228 stringify!(StdVideoH264SequenceParameterSet),
1229 "::",
1230 stringify!(profile_idc)
1231 )
1232 );
1233 assert_eq!(
1234 unsafe { ::core::ptr::addr_of!((*ptr).level_idc) as usize - ptr as usize },
1235 8usize,
1236 concat!(
1237 "Offset of field: ",
1238 stringify!(StdVideoH264SequenceParameterSet),
1239 "::",
1240 stringify!(level_idc)
1241 )
1242 );
1243 assert_eq!(
1244 unsafe { ::core::ptr::addr_of!((*ptr).chroma_format_idc) as usize - ptr as usize },
1245 12usize,
1246 concat!(
1247 "Offset of field: ",
1248 stringify!(StdVideoH264SequenceParameterSet),
1249 "::",
1250 stringify!(chroma_format_idc)
1251 )
1252 );
1253 assert_eq!(
1254 unsafe { ::core::ptr::addr_of!((*ptr).seq_parameter_set_id) as usize - ptr as usize },
1255 16usize,
1256 concat!(
1257 "Offset of field: ",
1258 stringify!(StdVideoH264SequenceParameterSet),
1259 "::",
1260 stringify!(seq_parameter_set_id)
1261 )
1262 );
1263 assert_eq!(
1264 unsafe { ::core::ptr::addr_of!((*ptr).bit_depth_luma_minus8) as usize - ptr as usize },
1265 17usize,
1266 concat!(
1267 "Offset of field: ",
1268 stringify!(StdVideoH264SequenceParameterSet),
1269 "::",
1270 stringify!(bit_depth_luma_minus8)
1271 )
1272 );
1273 assert_eq!(
1274 unsafe { ::core::ptr::addr_of!((*ptr).bit_depth_chroma_minus8) as usize - ptr as usize },
1275 18usize,
1276 concat!(
1277 "Offset of field: ",
1278 stringify!(StdVideoH264SequenceParameterSet),
1279 "::",
1280 stringify!(bit_depth_chroma_minus8)
1281 )
1282 );
1283 assert_eq!(
1284 unsafe { ::core::ptr::addr_of!((*ptr).log2_max_frame_num_minus4) as usize - ptr as usize },
1285 19usize,
1286 concat!(
1287 "Offset of field: ",
1288 stringify!(StdVideoH264SequenceParameterSet),
1289 "::",
1290 stringify!(log2_max_frame_num_minus4)
1291 )
1292 );
1293 assert_eq!(
1294 unsafe { ::core::ptr::addr_of!((*ptr).pic_order_cnt_type) as usize - ptr as usize },
1295 20usize,
1296 concat!(
1297 "Offset of field: ",
1298 stringify!(StdVideoH264SequenceParameterSet),
1299 "::",
1300 stringify!(pic_order_cnt_type)
1301 )
1302 );
1303 assert_eq!(
1304 unsafe { ::core::ptr::addr_of!((*ptr).offset_for_non_ref_pic) as usize - ptr as usize },
1305 24usize,
1306 concat!(
1307 "Offset of field: ",
1308 stringify!(StdVideoH264SequenceParameterSet),
1309 "::",
1310 stringify!(offset_for_non_ref_pic)
1311 )
1312 );
1313 assert_eq!(
1314 unsafe {
1315 ::core::ptr::addr_of!((*ptr).offset_for_top_to_bottom_field) as usize - ptr as usize
1316 },
1317 28usize,
1318 concat!(
1319 "Offset of field: ",
1320 stringify!(StdVideoH264SequenceParameterSet),
1321 "::",
1322 stringify!(offset_for_top_to_bottom_field)
1323 )
1324 );
1325 assert_eq!(
1326 unsafe {
1327 ::core::ptr::addr_of!((*ptr).log2_max_pic_order_cnt_lsb_minus4) as usize - ptr as usize
1328 },
1329 32usize,
1330 concat!(
1331 "Offset of field: ",
1332 stringify!(StdVideoH264SequenceParameterSet),
1333 "::",
1334 stringify!(log2_max_pic_order_cnt_lsb_minus4)
1335 )
1336 );
1337 assert_eq!(
1338 unsafe {
1339 ::core::ptr::addr_of!((*ptr).num_ref_frames_in_pic_order_cnt_cycle) as usize
1340 - ptr as usize
1341 },
1342 33usize,
1343 concat!(
1344 "Offset of field: ",
1345 stringify!(StdVideoH264SequenceParameterSet),
1346 "::",
1347 stringify!(num_ref_frames_in_pic_order_cnt_cycle)
1348 )
1349 );
1350 assert_eq!(
1351 unsafe { ::core::ptr::addr_of!((*ptr).max_num_ref_frames) as usize - ptr as usize },
1352 34usize,
1353 concat!(
1354 "Offset of field: ",
1355 stringify!(StdVideoH264SequenceParameterSet),
1356 "::",
1357 stringify!(max_num_ref_frames)
1358 )
1359 );
1360 assert_eq!(
1361 unsafe { ::core::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize },
1362 35usize,
1363 concat!(
1364 "Offset of field: ",
1365 stringify!(StdVideoH264SequenceParameterSet),
1366 "::",
1367 stringify!(reserved1)
1368 )
1369 );
1370 assert_eq!(
1371 unsafe { ::core::ptr::addr_of!((*ptr).pic_width_in_mbs_minus1) as usize - ptr as usize },
1372 36usize,
1373 concat!(
1374 "Offset of field: ",
1375 stringify!(StdVideoH264SequenceParameterSet),
1376 "::",
1377 stringify!(pic_width_in_mbs_minus1)
1378 )
1379 );
1380 assert_eq!(
1381 unsafe {
1382 ::core::ptr::addr_of!((*ptr).pic_height_in_map_units_minus1) as usize - ptr as usize
1383 },
1384 40usize,
1385 concat!(
1386 "Offset of field: ",
1387 stringify!(StdVideoH264SequenceParameterSet),
1388 "::",
1389 stringify!(pic_height_in_map_units_minus1)
1390 )
1391 );
1392 assert_eq!(
1393 unsafe { ::core::ptr::addr_of!((*ptr).frame_crop_left_offset) as usize - ptr as usize },
1394 44usize,
1395 concat!(
1396 "Offset of field: ",
1397 stringify!(StdVideoH264SequenceParameterSet),
1398 "::",
1399 stringify!(frame_crop_left_offset)
1400 )
1401 );
1402 assert_eq!(
1403 unsafe { ::core::ptr::addr_of!((*ptr).frame_crop_right_offset) as usize - ptr as usize },
1404 48usize,
1405 concat!(
1406 "Offset of field: ",
1407 stringify!(StdVideoH264SequenceParameterSet),
1408 "::",
1409 stringify!(frame_crop_right_offset)
1410 )
1411 );
1412 assert_eq!(
1413 unsafe { ::core::ptr::addr_of!((*ptr).frame_crop_top_offset) as usize - ptr as usize },
1414 52usize,
1415 concat!(
1416 "Offset of field: ",
1417 stringify!(StdVideoH264SequenceParameterSet),
1418 "::",
1419 stringify!(frame_crop_top_offset)
1420 )
1421 );
1422 assert_eq!(
1423 unsafe { ::core::ptr::addr_of!((*ptr).frame_crop_bottom_offset) as usize - ptr as usize },
1424 56usize,
1425 concat!(
1426 "Offset of field: ",
1427 stringify!(StdVideoH264SequenceParameterSet),
1428 "::",
1429 stringify!(frame_crop_bottom_offset)
1430 )
1431 );
1432 assert_eq!(
1433 unsafe { ::core::ptr::addr_of!((*ptr).reserved2) as usize - ptr as usize },
1434 60usize,
1435 concat!(
1436 "Offset of field: ",
1437 stringify!(StdVideoH264SequenceParameterSet),
1438 "::",
1439 stringify!(reserved2)
1440 )
1441 );
1442 assert_eq!(
1443 unsafe { ::core::ptr::addr_of!((*ptr).pOffsetForRefFrame) as usize - ptr as usize },
1444 64usize,
1445 concat!(
1446 "Offset of field: ",
1447 stringify!(StdVideoH264SequenceParameterSet),
1448 "::",
1449 stringify!(pOffsetForRefFrame)
1450 )
1451 );
1452 assert_eq!(
1453 unsafe { ::core::ptr::addr_of!((*ptr).pScalingLists) as usize - ptr as usize },
1454 72usize,
1455 concat!(
1456 "Offset of field: ",
1457 stringify!(StdVideoH264SequenceParameterSet),
1458 "::",
1459 stringify!(pScalingLists)
1460 )
1461 );
1462 assert_eq!(
1463 unsafe { ::core::ptr::addr_of!((*ptr).pSequenceParameterSetVui) as usize - ptr as usize },
1464 80usize,
1465 concat!(
1466 "Offset of field: ",
1467 stringify!(StdVideoH264SequenceParameterSet),
1468 "::",
1469 stringify!(pSequenceParameterSetVui)
1470 )
1471 );
1472}
1473#[repr(C)]
1474#[repr(align(4))]
1475#[derive(Debug, Copy, Clone)]
1476pub struct StdVideoH264PpsFlags {
1477 pub _bitfield_align_1: [u8; 0],
1478 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
1479 pub __bindgen_padding_0: [u8; 3usize],
1480}
1481#[test]
1482fn bindgen_test_layout_StdVideoH264PpsFlags() {
1483 assert_eq!(
1484 ::core::mem::size_of::<StdVideoH264PpsFlags>(),
1485 4usize,
1486 concat!("Size of: ", stringify!(StdVideoH264PpsFlags))
1487 );
1488 assert_eq!(
1489 ::core::mem::align_of::<StdVideoH264PpsFlags>(),
1490 4usize,
1491 concat!("Alignment of ", stringify!(StdVideoH264PpsFlags))
1492 );
1493}
1494impl StdVideoH264PpsFlags {
1495 #[inline]
1496 pub fn transform_8x8_mode_flag(&self) -> u32 {
1497 unsafe { ::core::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
1498 }
1499 #[inline]
1500 pub fn set_transform_8x8_mode_flag(&mut self, val: u32) {
1501 unsafe {
1502 let val: u32 = ::core::mem::transmute(val);
1503 self._bitfield_1.set(0usize, 1u8, val as u64)
1504 }
1505 }
1506 #[inline]
1507 pub fn redundant_pic_cnt_present_flag(&self) -> u32 {
1508 unsafe { ::core::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
1509 }
1510 #[inline]
1511 pub fn set_redundant_pic_cnt_present_flag(&mut self, val: u32) {
1512 unsafe {
1513 let val: u32 = ::core::mem::transmute(val);
1514 self._bitfield_1.set(1usize, 1u8, val as u64)
1515 }
1516 }
1517 #[inline]
1518 pub fn constrained_intra_pred_flag(&self) -> u32 {
1519 unsafe { ::core::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
1520 }
1521 #[inline]
1522 pub fn set_constrained_intra_pred_flag(&mut self, val: u32) {
1523 unsafe {
1524 let val: u32 = ::core::mem::transmute(val);
1525 self._bitfield_1.set(2usize, 1u8, val as u64)
1526 }
1527 }
1528 #[inline]
1529 pub fn deblocking_filter_control_present_flag(&self) -> u32 {
1530 unsafe { ::core::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
1531 }
1532 #[inline]
1533 pub fn set_deblocking_filter_control_present_flag(&mut self, val: u32) {
1534 unsafe {
1535 let val: u32 = ::core::mem::transmute(val);
1536 self._bitfield_1.set(3usize, 1u8, val as u64)
1537 }
1538 }
1539 #[inline]
1540 pub fn weighted_pred_flag(&self) -> u32 {
1541 unsafe { ::core::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
1542 }
1543 #[inline]
1544 pub fn set_weighted_pred_flag(&mut self, val: u32) {
1545 unsafe {
1546 let val: u32 = ::core::mem::transmute(val);
1547 self._bitfield_1.set(4usize, 1u8, val as u64)
1548 }
1549 }
1550 #[inline]
1551 pub fn bottom_field_pic_order_in_frame_present_flag(&self) -> u32 {
1552 unsafe { ::core::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
1553 }
1554 #[inline]
1555 pub fn set_bottom_field_pic_order_in_frame_present_flag(&mut self, val: u32) {
1556 unsafe {
1557 let val: u32 = ::core::mem::transmute(val);
1558 self._bitfield_1.set(5usize, 1u8, val as u64)
1559 }
1560 }
1561 #[inline]
1562 pub fn entropy_coding_mode_flag(&self) -> u32 {
1563 unsafe { ::core::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) }
1564 }
1565 #[inline]
1566 pub fn set_entropy_coding_mode_flag(&mut self, val: u32) {
1567 unsafe {
1568 let val: u32 = ::core::mem::transmute(val);
1569 self._bitfield_1.set(6usize, 1u8, val as u64)
1570 }
1571 }
1572 #[inline]
1573 pub fn pic_scaling_matrix_present_flag(&self) -> u32 {
1574 unsafe { ::core::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) }
1575 }
1576 #[inline]
1577 pub fn set_pic_scaling_matrix_present_flag(&mut self, val: u32) {
1578 unsafe {
1579 let val: u32 = ::core::mem::transmute(val);
1580 self._bitfield_1.set(7usize, 1u8, val as u64)
1581 }
1582 }
1583 #[inline]
1584 pub fn new_bitfield_1(
1585 transform_8x8_mode_flag: u32,
1586 redundant_pic_cnt_present_flag: u32,
1587 constrained_intra_pred_flag: u32,
1588 deblocking_filter_control_present_flag: u32,
1589 weighted_pred_flag: u32,
1590 bottom_field_pic_order_in_frame_present_flag: u32,
1591 entropy_coding_mode_flag: u32,
1592 pic_scaling_matrix_present_flag: u32,
1593 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
1594 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
1595 __bindgen_bitfield_unit.set(0usize, 1u8, {
1596 let transform_8x8_mode_flag: u32 =
1597 unsafe { ::core::mem::transmute(transform_8x8_mode_flag) };
1598 transform_8x8_mode_flag as u64
1599 });
1600 __bindgen_bitfield_unit.set(1usize, 1u8, {
1601 let redundant_pic_cnt_present_flag: u32 =
1602 unsafe { ::core::mem::transmute(redundant_pic_cnt_present_flag) };
1603 redundant_pic_cnt_present_flag as u64
1604 });
1605 __bindgen_bitfield_unit.set(2usize, 1u8, {
1606 let constrained_intra_pred_flag: u32 =
1607 unsafe { ::core::mem::transmute(constrained_intra_pred_flag) };
1608 constrained_intra_pred_flag as u64
1609 });
1610 __bindgen_bitfield_unit.set(3usize, 1u8, {
1611 let deblocking_filter_control_present_flag: u32 =
1612 unsafe { ::core::mem::transmute(deblocking_filter_control_present_flag) };
1613 deblocking_filter_control_present_flag as u64
1614 });
1615 __bindgen_bitfield_unit.set(4usize, 1u8, {
1616 let weighted_pred_flag: u32 = unsafe { ::core::mem::transmute(weighted_pred_flag) };
1617 weighted_pred_flag as u64
1618 });
1619 __bindgen_bitfield_unit.set(5usize, 1u8, {
1620 let bottom_field_pic_order_in_frame_present_flag: u32 =
1621 unsafe { ::core::mem::transmute(bottom_field_pic_order_in_frame_present_flag) };
1622 bottom_field_pic_order_in_frame_present_flag as u64
1623 });
1624 __bindgen_bitfield_unit.set(6usize, 1u8, {
1625 let entropy_coding_mode_flag: u32 =
1626 unsafe { ::core::mem::transmute(entropy_coding_mode_flag) };
1627 entropy_coding_mode_flag as u64
1628 });
1629 __bindgen_bitfield_unit.set(7usize, 1u8, {
1630 let pic_scaling_matrix_present_flag: u32 =
1631 unsafe { ::core::mem::transmute(pic_scaling_matrix_present_flag) };
1632 pic_scaling_matrix_present_flag as u64
1633 });
1634 __bindgen_bitfield_unit
1635 }
1636}
1637#[repr(C)]
1638#[derive(Debug, Copy, Clone)]
1639pub struct StdVideoH264PictureParameterSet {
1640 pub flags: StdVideoH264PpsFlags,
1641 pub seq_parameter_set_id: u8,
1642 pub pic_parameter_set_id: u8,
1643 pub num_ref_idx_l0_default_active_minus1: u8,
1644 pub num_ref_idx_l1_default_active_minus1: u8,
1645 pub weighted_bipred_idc: StdVideoH264WeightedBipredIdc,
1646 pub pic_init_qp_minus26: i8,
1647 pub pic_init_qs_minus26: i8,
1648 pub chroma_qp_index_offset: i8,
1649 pub second_chroma_qp_index_offset: i8,
1650 pub pScalingLists: *const StdVideoH264ScalingLists,
1651}
1652#[test]
1653fn bindgen_test_layout_StdVideoH264PictureParameterSet() {
1654 const UNINIT: ::core::mem::MaybeUninit<StdVideoH264PictureParameterSet> =
1655 ::core::mem::MaybeUninit::uninit();
1656 let ptr = UNINIT.as_ptr();
1657 assert_eq!(
1658 ::core::mem::size_of::<StdVideoH264PictureParameterSet>(),
1659 24usize,
1660 concat!("Size of: ", stringify!(StdVideoH264PictureParameterSet))
1661 );
1662 assert_eq!(
1663 ::core::mem::align_of::<StdVideoH264PictureParameterSet>(),
1664 8usize,
1665 concat!("Alignment of ", stringify!(StdVideoH264PictureParameterSet))
1666 );
1667 assert_eq!(
1668 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
1669 0usize,
1670 concat!(
1671 "Offset of field: ",
1672 stringify!(StdVideoH264PictureParameterSet),
1673 "::",
1674 stringify!(flags)
1675 )
1676 );
1677 assert_eq!(
1678 unsafe { ::core::ptr::addr_of!((*ptr).seq_parameter_set_id) as usize - ptr as usize },
1679 4usize,
1680 concat!(
1681 "Offset of field: ",
1682 stringify!(StdVideoH264PictureParameterSet),
1683 "::",
1684 stringify!(seq_parameter_set_id)
1685 )
1686 );
1687 assert_eq!(
1688 unsafe { ::core::ptr::addr_of!((*ptr).pic_parameter_set_id) as usize - ptr as usize },
1689 5usize,
1690 concat!(
1691 "Offset of field: ",
1692 stringify!(StdVideoH264PictureParameterSet),
1693 "::",
1694 stringify!(pic_parameter_set_id)
1695 )
1696 );
1697 assert_eq!(
1698 unsafe {
1699 ::core::ptr::addr_of!((*ptr).num_ref_idx_l0_default_active_minus1) as usize
1700 - ptr as usize
1701 },
1702 6usize,
1703 concat!(
1704 "Offset of field: ",
1705 stringify!(StdVideoH264PictureParameterSet),
1706 "::",
1707 stringify!(num_ref_idx_l0_default_active_minus1)
1708 )
1709 );
1710 assert_eq!(
1711 unsafe {
1712 ::core::ptr::addr_of!((*ptr).num_ref_idx_l1_default_active_minus1) as usize
1713 - ptr as usize
1714 },
1715 7usize,
1716 concat!(
1717 "Offset of field: ",
1718 stringify!(StdVideoH264PictureParameterSet),
1719 "::",
1720 stringify!(num_ref_idx_l1_default_active_minus1)
1721 )
1722 );
1723 assert_eq!(
1724 unsafe { ::core::ptr::addr_of!((*ptr).weighted_bipred_idc) as usize - ptr as usize },
1725 8usize,
1726 concat!(
1727 "Offset of field: ",
1728 stringify!(StdVideoH264PictureParameterSet),
1729 "::",
1730 stringify!(weighted_bipred_idc)
1731 )
1732 );
1733 assert_eq!(
1734 unsafe { ::core::ptr::addr_of!((*ptr).pic_init_qp_minus26) as usize - ptr as usize },
1735 12usize,
1736 concat!(
1737 "Offset of field: ",
1738 stringify!(StdVideoH264PictureParameterSet),
1739 "::",
1740 stringify!(pic_init_qp_minus26)
1741 )
1742 );
1743 assert_eq!(
1744 unsafe { ::core::ptr::addr_of!((*ptr).pic_init_qs_minus26) as usize - ptr as usize },
1745 13usize,
1746 concat!(
1747 "Offset of field: ",
1748 stringify!(StdVideoH264PictureParameterSet),
1749 "::",
1750 stringify!(pic_init_qs_minus26)
1751 )
1752 );
1753 assert_eq!(
1754 unsafe { ::core::ptr::addr_of!((*ptr).chroma_qp_index_offset) as usize - ptr as usize },
1755 14usize,
1756 concat!(
1757 "Offset of field: ",
1758 stringify!(StdVideoH264PictureParameterSet),
1759 "::",
1760 stringify!(chroma_qp_index_offset)
1761 )
1762 );
1763 assert_eq!(
1764 unsafe {
1765 ::core::ptr::addr_of!((*ptr).second_chroma_qp_index_offset) as usize - ptr as usize
1766 },
1767 15usize,
1768 concat!(
1769 "Offset of field: ",
1770 stringify!(StdVideoH264PictureParameterSet),
1771 "::",
1772 stringify!(second_chroma_qp_index_offset)
1773 )
1774 );
1775 assert_eq!(
1776 unsafe { ::core::ptr::addr_of!((*ptr).pScalingLists) as usize - ptr as usize },
1777 16usize,
1778 concat!(
1779 "Offset of field: ",
1780 stringify!(StdVideoH264PictureParameterSet),
1781 "::",
1782 stringify!(pScalingLists)
1783 )
1784 );
1785}
1786#[repr(C)]
1787#[repr(align(4))]
1788#[derive(Debug, Copy, Clone)]
1789pub struct StdVideoDecodeH264PictureInfoFlags {
1790 pub _bitfield_align_1: [u8; 0],
1791 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
1792 pub __bindgen_padding_0: [u8; 3usize],
1793}
1794#[test]
1795fn bindgen_test_layout_StdVideoDecodeH264PictureInfoFlags() {
1796 assert_eq!(
1797 ::core::mem::size_of::<StdVideoDecodeH264PictureInfoFlags>(),
1798 4usize,
1799 concat!("Size of: ", stringify!(StdVideoDecodeH264PictureInfoFlags))
1800 );
1801 assert_eq!(
1802 ::core::mem::align_of::<StdVideoDecodeH264PictureInfoFlags>(),
1803 4usize,
1804 concat!(
1805 "Alignment of ",
1806 stringify!(StdVideoDecodeH264PictureInfoFlags)
1807 )
1808 );
1809}
1810impl StdVideoDecodeH264PictureInfoFlags {
1811 #[inline]
1812 pub fn field_pic_flag(&self) -> u32 {
1813 unsafe { ::core::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
1814 }
1815 #[inline]
1816 pub fn set_field_pic_flag(&mut self, val: u32) {
1817 unsafe {
1818 let val: u32 = ::core::mem::transmute(val);
1819 self._bitfield_1.set(0usize, 1u8, val as u64)
1820 }
1821 }
1822 #[inline]
1823 pub fn is_intra(&self) -> u32 {
1824 unsafe { ::core::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
1825 }
1826 #[inline]
1827 pub fn set_is_intra(&mut self, val: u32) {
1828 unsafe {
1829 let val: u32 = ::core::mem::transmute(val);
1830 self._bitfield_1.set(1usize, 1u8, val as u64)
1831 }
1832 }
1833 #[inline]
1834 pub fn IdrPicFlag(&self) -> u32 {
1835 unsafe { ::core::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
1836 }
1837 #[inline]
1838 pub fn set_IdrPicFlag(&mut self, val: u32) {
1839 unsafe {
1840 let val: u32 = ::core::mem::transmute(val);
1841 self._bitfield_1.set(2usize, 1u8, val as u64)
1842 }
1843 }
1844 #[inline]
1845 pub fn bottom_field_flag(&self) -> u32 {
1846 unsafe { ::core::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
1847 }
1848 #[inline]
1849 pub fn set_bottom_field_flag(&mut self, val: u32) {
1850 unsafe {
1851 let val: u32 = ::core::mem::transmute(val);
1852 self._bitfield_1.set(3usize, 1u8, val as u64)
1853 }
1854 }
1855 #[inline]
1856 pub fn is_reference(&self) -> u32 {
1857 unsafe { ::core::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
1858 }
1859 #[inline]
1860 pub fn set_is_reference(&mut self, val: u32) {
1861 unsafe {
1862 let val: u32 = ::core::mem::transmute(val);
1863 self._bitfield_1.set(4usize, 1u8, val as u64)
1864 }
1865 }
1866 #[inline]
1867 pub fn complementary_field_pair(&self) -> u32 {
1868 unsafe { ::core::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
1869 }
1870 #[inline]
1871 pub fn set_complementary_field_pair(&mut self, val: u32) {
1872 unsafe {
1873 let val: u32 = ::core::mem::transmute(val);
1874 self._bitfield_1.set(5usize, 1u8, val as u64)
1875 }
1876 }
1877 #[inline]
1878 pub fn new_bitfield_1(
1879 field_pic_flag: u32,
1880 is_intra: u32,
1881 IdrPicFlag: u32,
1882 bottom_field_flag: u32,
1883 is_reference: u32,
1884 complementary_field_pair: u32,
1885 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
1886 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
1887 __bindgen_bitfield_unit.set(0usize, 1u8, {
1888 let field_pic_flag: u32 = unsafe { ::core::mem::transmute(field_pic_flag) };
1889 field_pic_flag as u64
1890 });
1891 __bindgen_bitfield_unit.set(1usize, 1u8, {
1892 let is_intra: u32 = unsafe { ::core::mem::transmute(is_intra) };
1893 is_intra as u64
1894 });
1895 __bindgen_bitfield_unit.set(2usize, 1u8, {
1896 let IdrPicFlag: u32 = unsafe { ::core::mem::transmute(IdrPicFlag) };
1897 IdrPicFlag as u64
1898 });
1899 __bindgen_bitfield_unit.set(3usize, 1u8, {
1900 let bottom_field_flag: u32 = unsafe { ::core::mem::transmute(bottom_field_flag) };
1901 bottom_field_flag as u64
1902 });
1903 __bindgen_bitfield_unit.set(4usize, 1u8, {
1904 let is_reference: u32 = unsafe { ::core::mem::transmute(is_reference) };
1905 is_reference as u64
1906 });
1907 __bindgen_bitfield_unit.set(5usize, 1u8, {
1908 let complementary_field_pair: u32 =
1909 unsafe { ::core::mem::transmute(complementary_field_pair) };
1910 complementary_field_pair as u64
1911 });
1912 __bindgen_bitfield_unit
1913 }
1914}
1915#[repr(C)]
1916#[derive(Debug, Copy, Clone)]
1917pub struct StdVideoDecodeH264PictureInfo {
1918 pub flags: StdVideoDecodeH264PictureInfoFlags,
1919 pub seq_parameter_set_id: u8,
1920 pub pic_parameter_set_id: u8,
1921 pub reserved1: u8,
1922 pub reserved2: u8,
1923 pub frame_num: u16,
1924 pub idr_pic_id: u16,
1925 pub PicOrderCnt: [i32; 2usize],
1926}
1927#[test]
1928fn bindgen_test_layout_StdVideoDecodeH264PictureInfo() {
1929 const UNINIT: ::core::mem::MaybeUninit<StdVideoDecodeH264PictureInfo> =
1930 ::core::mem::MaybeUninit::uninit();
1931 let ptr = UNINIT.as_ptr();
1932 assert_eq!(
1933 ::core::mem::size_of::<StdVideoDecodeH264PictureInfo>(),
1934 20usize,
1935 concat!("Size of: ", stringify!(StdVideoDecodeH264PictureInfo))
1936 );
1937 assert_eq!(
1938 ::core::mem::align_of::<StdVideoDecodeH264PictureInfo>(),
1939 4usize,
1940 concat!("Alignment of ", stringify!(StdVideoDecodeH264PictureInfo))
1941 );
1942 assert_eq!(
1943 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
1944 0usize,
1945 concat!(
1946 "Offset of field: ",
1947 stringify!(StdVideoDecodeH264PictureInfo),
1948 "::",
1949 stringify!(flags)
1950 )
1951 );
1952 assert_eq!(
1953 unsafe { ::core::ptr::addr_of!((*ptr).seq_parameter_set_id) as usize - ptr as usize },
1954 4usize,
1955 concat!(
1956 "Offset of field: ",
1957 stringify!(StdVideoDecodeH264PictureInfo),
1958 "::",
1959 stringify!(seq_parameter_set_id)
1960 )
1961 );
1962 assert_eq!(
1963 unsafe { ::core::ptr::addr_of!((*ptr).pic_parameter_set_id) as usize - ptr as usize },
1964 5usize,
1965 concat!(
1966 "Offset of field: ",
1967 stringify!(StdVideoDecodeH264PictureInfo),
1968 "::",
1969 stringify!(pic_parameter_set_id)
1970 )
1971 );
1972 assert_eq!(
1973 unsafe { ::core::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize },
1974 6usize,
1975 concat!(
1976 "Offset of field: ",
1977 stringify!(StdVideoDecodeH264PictureInfo),
1978 "::",
1979 stringify!(reserved1)
1980 )
1981 );
1982 assert_eq!(
1983 unsafe { ::core::ptr::addr_of!((*ptr).reserved2) as usize - ptr as usize },
1984 7usize,
1985 concat!(
1986 "Offset of field: ",
1987 stringify!(StdVideoDecodeH264PictureInfo),
1988 "::",
1989 stringify!(reserved2)
1990 )
1991 );
1992 assert_eq!(
1993 unsafe { ::core::ptr::addr_of!((*ptr).frame_num) as usize - ptr as usize },
1994 8usize,
1995 concat!(
1996 "Offset of field: ",
1997 stringify!(StdVideoDecodeH264PictureInfo),
1998 "::",
1999 stringify!(frame_num)
2000 )
2001 );
2002 assert_eq!(
2003 unsafe { ::core::ptr::addr_of!((*ptr).idr_pic_id) as usize - ptr as usize },
2004 10usize,
2005 concat!(
2006 "Offset of field: ",
2007 stringify!(StdVideoDecodeH264PictureInfo),
2008 "::",
2009 stringify!(idr_pic_id)
2010 )
2011 );
2012 assert_eq!(
2013 unsafe { ::core::ptr::addr_of!((*ptr).PicOrderCnt) as usize - ptr as usize },
2014 12usize,
2015 concat!(
2016 "Offset of field: ",
2017 stringify!(StdVideoDecodeH264PictureInfo),
2018 "::",
2019 stringify!(PicOrderCnt)
2020 )
2021 );
2022}
2023#[repr(C)]
2024#[repr(align(4))]
2025#[derive(Debug, Copy, Clone)]
2026pub struct StdVideoDecodeH264ReferenceInfoFlags {
2027 pub _bitfield_align_1: [u8; 0],
2028 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
2029 pub __bindgen_padding_0: [u8; 3usize],
2030}
2031#[test]
2032fn bindgen_test_layout_StdVideoDecodeH264ReferenceInfoFlags() {
2033 assert_eq!(
2034 ::core::mem::size_of::<StdVideoDecodeH264ReferenceInfoFlags>(),
2035 4usize,
2036 concat!(
2037 "Size of: ",
2038 stringify!(StdVideoDecodeH264ReferenceInfoFlags)
2039 )
2040 );
2041 assert_eq!(
2042 ::core::mem::align_of::<StdVideoDecodeH264ReferenceInfoFlags>(),
2043 4usize,
2044 concat!(
2045 "Alignment of ",
2046 stringify!(StdVideoDecodeH264ReferenceInfoFlags)
2047 )
2048 );
2049}
2050impl StdVideoDecodeH264ReferenceInfoFlags {
2051 #[inline]
2052 pub fn top_field_flag(&self) -> u32 {
2053 unsafe { ::core::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
2054 }
2055 #[inline]
2056 pub fn set_top_field_flag(&mut self, val: u32) {
2057 unsafe {
2058 let val: u32 = ::core::mem::transmute(val);
2059 self._bitfield_1.set(0usize, 1u8, val as u64)
2060 }
2061 }
2062 #[inline]
2063 pub fn bottom_field_flag(&self) -> u32 {
2064 unsafe { ::core::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
2065 }
2066 #[inline]
2067 pub fn set_bottom_field_flag(&mut self, val: u32) {
2068 unsafe {
2069 let val: u32 = ::core::mem::transmute(val);
2070 self._bitfield_1.set(1usize, 1u8, val as u64)
2071 }
2072 }
2073 #[inline]
2074 pub fn used_for_long_term_reference(&self) -> u32 {
2075 unsafe { ::core::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
2076 }
2077 #[inline]
2078 pub fn set_used_for_long_term_reference(&mut self, val: u32) {
2079 unsafe {
2080 let val: u32 = ::core::mem::transmute(val);
2081 self._bitfield_1.set(2usize, 1u8, val as u64)
2082 }
2083 }
2084 #[inline]
2085 pub fn is_non_existing(&self) -> u32 {
2086 unsafe { ::core::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
2087 }
2088 #[inline]
2089 pub fn set_is_non_existing(&mut self, val: u32) {
2090 unsafe {
2091 let val: u32 = ::core::mem::transmute(val);
2092 self._bitfield_1.set(3usize, 1u8, val as u64)
2093 }
2094 }
2095 #[inline]
2096 pub fn new_bitfield_1(
2097 top_field_flag: u32,
2098 bottom_field_flag: u32,
2099 used_for_long_term_reference: u32,
2100 is_non_existing: u32,
2101 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
2102 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
2103 __bindgen_bitfield_unit.set(0usize, 1u8, {
2104 let top_field_flag: u32 = unsafe { ::core::mem::transmute(top_field_flag) };
2105 top_field_flag as u64
2106 });
2107 __bindgen_bitfield_unit.set(1usize, 1u8, {
2108 let bottom_field_flag: u32 = unsafe { ::core::mem::transmute(bottom_field_flag) };
2109 bottom_field_flag as u64
2110 });
2111 __bindgen_bitfield_unit.set(2usize, 1u8, {
2112 let used_for_long_term_reference: u32 =
2113 unsafe { ::core::mem::transmute(used_for_long_term_reference) };
2114 used_for_long_term_reference as u64
2115 });
2116 __bindgen_bitfield_unit.set(3usize, 1u8, {
2117 let is_non_existing: u32 = unsafe { ::core::mem::transmute(is_non_existing) };
2118 is_non_existing as u64
2119 });
2120 __bindgen_bitfield_unit
2121 }
2122}
2123#[repr(C)]
2124#[derive(Debug, Copy, Clone)]
2125pub struct StdVideoDecodeH264ReferenceInfo {
2126 pub flags: StdVideoDecodeH264ReferenceInfoFlags,
2127 pub FrameNum: u16,
2128 pub reserved: u16,
2129 pub PicOrderCnt: [i32; 2usize],
2130}
2131#[test]
2132fn bindgen_test_layout_StdVideoDecodeH264ReferenceInfo() {
2133 const UNINIT: ::core::mem::MaybeUninit<StdVideoDecodeH264ReferenceInfo> =
2134 ::core::mem::MaybeUninit::uninit();
2135 let ptr = UNINIT.as_ptr();
2136 assert_eq!(
2137 ::core::mem::size_of::<StdVideoDecodeH264ReferenceInfo>(),
2138 16usize,
2139 concat!("Size of: ", stringify!(StdVideoDecodeH264ReferenceInfo))
2140 );
2141 assert_eq!(
2142 ::core::mem::align_of::<StdVideoDecodeH264ReferenceInfo>(),
2143 4usize,
2144 concat!("Alignment of ", stringify!(StdVideoDecodeH264ReferenceInfo))
2145 );
2146 assert_eq!(
2147 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
2148 0usize,
2149 concat!(
2150 "Offset of field: ",
2151 stringify!(StdVideoDecodeH264ReferenceInfo),
2152 "::",
2153 stringify!(flags)
2154 )
2155 );
2156 assert_eq!(
2157 unsafe { ::core::ptr::addr_of!((*ptr).FrameNum) as usize - ptr as usize },
2158 4usize,
2159 concat!(
2160 "Offset of field: ",
2161 stringify!(StdVideoDecodeH264ReferenceInfo),
2162 "::",
2163 stringify!(FrameNum)
2164 )
2165 );
2166 assert_eq!(
2167 unsafe { ::core::ptr::addr_of!((*ptr).reserved) as usize - ptr as usize },
2168 6usize,
2169 concat!(
2170 "Offset of field: ",
2171 stringify!(StdVideoDecodeH264ReferenceInfo),
2172 "::",
2173 stringify!(reserved)
2174 )
2175 );
2176 assert_eq!(
2177 unsafe { ::core::ptr::addr_of!((*ptr).PicOrderCnt) as usize - ptr as usize },
2178 8usize,
2179 concat!(
2180 "Offset of field: ",
2181 stringify!(StdVideoDecodeH264ReferenceInfo),
2182 "::",
2183 stringify!(PicOrderCnt)
2184 )
2185 );
2186}
2187pub const StdVideoH265ChromaFormatIdc_STD_VIDEO_H265_CHROMA_FORMAT_IDC_MONOCHROME:
2188 StdVideoH265ChromaFormatIdc = 0;
2189pub const StdVideoH265ChromaFormatIdc_STD_VIDEO_H265_CHROMA_FORMAT_IDC_420:
2190 StdVideoH265ChromaFormatIdc = 1;
2191pub const StdVideoH265ChromaFormatIdc_STD_VIDEO_H265_CHROMA_FORMAT_IDC_422:
2192 StdVideoH265ChromaFormatIdc = 2;
2193pub const StdVideoH265ChromaFormatIdc_STD_VIDEO_H265_CHROMA_FORMAT_IDC_444:
2194 StdVideoH265ChromaFormatIdc = 3;
2195pub const StdVideoH265ChromaFormatIdc_STD_VIDEO_H265_CHROMA_FORMAT_IDC_INVALID:
2196 StdVideoH265ChromaFormatIdc = 2147483647;
2197pub type StdVideoH265ChromaFormatIdc = ::core::ffi::c_uint;
2198pub const StdVideoH265ProfileIdc_STD_VIDEO_H265_PROFILE_IDC_MAIN: StdVideoH265ProfileIdc = 1;
2199pub const StdVideoH265ProfileIdc_STD_VIDEO_H265_PROFILE_IDC_MAIN_10: StdVideoH265ProfileIdc = 2;
2200pub const StdVideoH265ProfileIdc_STD_VIDEO_H265_PROFILE_IDC_MAIN_STILL_PICTURE:
2201 StdVideoH265ProfileIdc = 3;
2202pub const StdVideoH265ProfileIdc_STD_VIDEO_H265_PROFILE_IDC_FORMAT_RANGE_EXTENSIONS:
2203 StdVideoH265ProfileIdc = 4;
2204pub const StdVideoH265ProfileIdc_STD_VIDEO_H265_PROFILE_IDC_SCC_EXTENSIONS: StdVideoH265ProfileIdc =
2205 9;
2206pub const StdVideoH265ProfileIdc_STD_VIDEO_H265_PROFILE_IDC_INVALID: StdVideoH265ProfileIdc =
2207 2147483647;
2208pub type StdVideoH265ProfileIdc = ::core::ffi::c_uint;
2209pub const StdVideoH265LevelIdc_STD_VIDEO_H265_LEVEL_IDC_1_0: StdVideoH265LevelIdc = 0;
2210pub const StdVideoH265LevelIdc_STD_VIDEO_H265_LEVEL_IDC_2_0: StdVideoH265LevelIdc = 1;
2211pub const StdVideoH265LevelIdc_STD_VIDEO_H265_LEVEL_IDC_2_1: StdVideoH265LevelIdc = 2;
2212pub const StdVideoH265LevelIdc_STD_VIDEO_H265_LEVEL_IDC_3_0: StdVideoH265LevelIdc = 3;
2213pub const StdVideoH265LevelIdc_STD_VIDEO_H265_LEVEL_IDC_3_1: StdVideoH265LevelIdc = 4;
2214pub const StdVideoH265LevelIdc_STD_VIDEO_H265_LEVEL_IDC_4_0: StdVideoH265LevelIdc = 5;
2215pub const StdVideoH265LevelIdc_STD_VIDEO_H265_LEVEL_IDC_4_1: StdVideoH265LevelIdc = 6;
2216pub const StdVideoH265LevelIdc_STD_VIDEO_H265_LEVEL_IDC_5_0: StdVideoH265LevelIdc = 7;
2217pub const StdVideoH265LevelIdc_STD_VIDEO_H265_LEVEL_IDC_5_1: StdVideoH265LevelIdc = 8;
2218pub const StdVideoH265LevelIdc_STD_VIDEO_H265_LEVEL_IDC_5_2: StdVideoH265LevelIdc = 9;
2219pub const StdVideoH265LevelIdc_STD_VIDEO_H265_LEVEL_IDC_6_0: StdVideoH265LevelIdc = 10;
2220pub const StdVideoH265LevelIdc_STD_VIDEO_H265_LEVEL_IDC_6_1: StdVideoH265LevelIdc = 11;
2221pub const StdVideoH265LevelIdc_STD_VIDEO_H265_LEVEL_IDC_6_2: StdVideoH265LevelIdc = 12;
2222pub const StdVideoH265LevelIdc_STD_VIDEO_H265_LEVEL_IDC_INVALID: StdVideoH265LevelIdc = 2147483647;
2223pub type StdVideoH265LevelIdc = ::core::ffi::c_uint;
2224pub const StdVideoH265SliceType_STD_VIDEO_H265_SLICE_TYPE_B: StdVideoH265SliceType = 0;
2225pub const StdVideoH265SliceType_STD_VIDEO_H265_SLICE_TYPE_P: StdVideoH265SliceType = 1;
2226pub const StdVideoH265SliceType_STD_VIDEO_H265_SLICE_TYPE_I: StdVideoH265SliceType = 2;
2227pub const StdVideoH265SliceType_STD_VIDEO_H265_SLICE_TYPE_INVALID: StdVideoH265SliceType =
2228 2147483647;
2229pub type StdVideoH265SliceType = ::core::ffi::c_uint;
2230pub const StdVideoH265PictureType_STD_VIDEO_H265_PICTURE_TYPE_P: StdVideoH265PictureType = 0;
2231pub const StdVideoH265PictureType_STD_VIDEO_H265_PICTURE_TYPE_B: StdVideoH265PictureType = 1;
2232pub const StdVideoH265PictureType_STD_VIDEO_H265_PICTURE_TYPE_I: StdVideoH265PictureType = 2;
2233pub const StdVideoH265PictureType_STD_VIDEO_H265_PICTURE_TYPE_IDR: StdVideoH265PictureType = 3;
2234pub const StdVideoH265PictureType_STD_VIDEO_H265_PICTURE_TYPE_INVALID: StdVideoH265PictureType =
2235 2147483647;
2236pub type StdVideoH265PictureType = ::core::ffi::c_uint;
2237pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_UNSPECIFIED:
2238 StdVideoH265AspectRatioIdc = 0;
2239pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_SQUARE:
2240 StdVideoH265AspectRatioIdc = 1;
2241pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_12_11:
2242 StdVideoH265AspectRatioIdc = 2;
2243pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_10_11:
2244 StdVideoH265AspectRatioIdc = 3;
2245pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_16_11:
2246 StdVideoH265AspectRatioIdc = 4;
2247pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_40_33:
2248 StdVideoH265AspectRatioIdc = 5;
2249pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_24_11:
2250 StdVideoH265AspectRatioIdc = 6;
2251pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_20_11:
2252 StdVideoH265AspectRatioIdc = 7;
2253pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_32_11:
2254 StdVideoH265AspectRatioIdc = 8;
2255pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_80_33:
2256 StdVideoH265AspectRatioIdc = 9;
2257pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_18_11:
2258 StdVideoH265AspectRatioIdc = 10;
2259pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_15_11:
2260 StdVideoH265AspectRatioIdc = 11;
2261pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_64_33:
2262 StdVideoH265AspectRatioIdc = 12;
2263pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_160_99:
2264 StdVideoH265AspectRatioIdc = 13;
2265pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_4_3:
2266 StdVideoH265AspectRatioIdc = 14;
2267pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_3_2:
2268 StdVideoH265AspectRatioIdc = 15;
2269pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_2_1:
2270 StdVideoH265AspectRatioIdc = 16;
2271pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_EXTENDED_SAR:
2272 StdVideoH265AspectRatioIdc = 255;
2273pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_INVALID:
2274 StdVideoH265AspectRatioIdc = 2147483647;
2275pub type StdVideoH265AspectRatioIdc = ::core::ffi::c_uint;
2276#[repr(C)]
2277#[derive(Debug, Copy, Clone)]
2278pub struct StdVideoH265DecPicBufMgr {
2279 pub max_latency_increase_plus1: [u32; 7usize],
2280 pub max_dec_pic_buffering_minus1: [u8; 7usize],
2281 pub max_num_reorder_pics: [u8; 7usize],
2282}
2283#[test]
2284fn bindgen_test_layout_StdVideoH265DecPicBufMgr() {
2285 const UNINIT: ::core::mem::MaybeUninit<StdVideoH265DecPicBufMgr> =
2286 ::core::mem::MaybeUninit::uninit();
2287 let ptr = UNINIT.as_ptr();
2288 assert_eq!(
2289 ::core::mem::size_of::<StdVideoH265DecPicBufMgr>(),
2290 44usize,
2291 concat!("Size of: ", stringify!(StdVideoH265DecPicBufMgr))
2292 );
2293 assert_eq!(
2294 ::core::mem::align_of::<StdVideoH265DecPicBufMgr>(),
2295 4usize,
2296 concat!("Alignment of ", stringify!(StdVideoH265DecPicBufMgr))
2297 );
2298 assert_eq!(
2299 unsafe { ::core::ptr::addr_of!((*ptr).max_latency_increase_plus1) as usize - ptr as usize },
2300 0usize,
2301 concat!(
2302 "Offset of field: ",
2303 stringify!(StdVideoH265DecPicBufMgr),
2304 "::",
2305 stringify!(max_latency_increase_plus1)
2306 )
2307 );
2308 assert_eq!(
2309 unsafe {
2310 ::core::ptr::addr_of!((*ptr).max_dec_pic_buffering_minus1) as usize - ptr as usize
2311 },
2312 28usize,
2313 concat!(
2314 "Offset of field: ",
2315 stringify!(StdVideoH265DecPicBufMgr),
2316 "::",
2317 stringify!(max_dec_pic_buffering_minus1)
2318 )
2319 );
2320 assert_eq!(
2321 unsafe { ::core::ptr::addr_of!((*ptr).max_num_reorder_pics) as usize - ptr as usize },
2322 35usize,
2323 concat!(
2324 "Offset of field: ",
2325 stringify!(StdVideoH265DecPicBufMgr),
2326 "::",
2327 stringify!(max_num_reorder_pics)
2328 )
2329 );
2330}
2331#[repr(C)]
2332#[derive(Debug, Copy, Clone)]
2333pub struct StdVideoH265SubLayerHrdParameters {
2334 pub bit_rate_value_minus1: [u32; 32usize],
2335 pub cpb_size_value_minus1: [u32; 32usize],
2336 pub cpb_size_du_value_minus1: [u32; 32usize],
2337 pub bit_rate_du_value_minus1: [u32; 32usize],
2338 pub cbr_flag: u32,
2339}
2340#[test]
2341fn bindgen_test_layout_StdVideoH265SubLayerHrdParameters() {
2342 const UNINIT: ::core::mem::MaybeUninit<StdVideoH265SubLayerHrdParameters> =
2343 ::core::mem::MaybeUninit::uninit();
2344 let ptr = UNINIT.as_ptr();
2345 assert_eq!(
2346 ::core::mem::size_of::<StdVideoH265SubLayerHrdParameters>(),
2347 516usize,
2348 concat!("Size of: ", stringify!(StdVideoH265SubLayerHrdParameters))
2349 );
2350 assert_eq!(
2351 ::core::mem::align_of::<StdVideoH265SubLayerHrdParameters>(),
2352 4usize,
2353 concat!(
2354 "Alignment of ",
2355 stringify!(StdVideoH265SubLayerHrdParameters)
2356 )
2357 );
2358 assert_eq!(
2359 unsafe { ::core::ptr::addr_of!((*ptr).bit_rate_value_minus1) as usize - ptr as usize },
2360 0usize,
2361 concat!(
2362 "Offset of field: ",
2363 stringify!(StdVideoH265SubLayerHrdParameters),
2364 "::",
2365 stringify!(bit_rate_value_minus1)
2366 )
2367 );
2368 assert_eq!(
2369 unsafe { ::core::ptr::addr_of!((*ptr).cpb_size_value_minus1) as usize - ptr as usize },
2370 128usize,
2371 concat!(
2372 "Offset of field: ",
2373 stringify!(StdVideoH265SubLayerHrdParameters),
2374 "::",
2375 stringify!(cpb_size_value_minus1)
2376 )
2377 );
2378 assert_eq!(
2379 unsafe { ::core::ptr::addr_of!((*ptr).cpb_size_du_value_minus1) as usize - ptr as usize },
2380 256usize,
2381 concat!(
2382 "Offset of field: ",
2383 stringify!(StdVideoH265SubLayerHrdParameters),
2384 "::",
2385 stringify!(cpb_size_du_value_minus1)
2386 )
2387 );
2388 assert_eq!(
2389 unsafe { ::core::ptr::addr_of!((*ptr).bit_rate_du_value_minus1) as usize - ptr as usize },
2390 384usize,
2391 concat!(
2392 "Offset of field: ",
2393 stringify!(StdVideoH265SubLayerHrdParameters),
2394 "::",
2395 stringify!(bit_rate_du_value_minus1)
2396 )
2397 );
2398 assert_eq!(
2399 unsafe { ::core::ptr::addr_of!((*ptr).cbr_flag) as usize - ptr as usize },
2400 512usize,
2401 concat!(
2402 "Offset of field: ",
2403 stringify!(StdVideoH265SubLayerHrdParameters),
2404 "::",
2405 stringify!(cbr_flag)
2406 )
2407 );
2408}
2409#[repr(C)]
2410#[repr(align(4))]
2411#[derive(Debug, Copy, Clone)]
2412pub struct StdVideoH265HrdFlags {
2413 pub _bitfield_align_1: [u8; 0],
2414 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
2415}
2416#[test]
2417fn bindgen_test_layout_StdVideoH265HrdFlags() {
2418 assert_eq!(
2419 ::core::mem::size_of::<StdVideoH265HrdFlags>(),
2420 4usize,
2421 concat!("Size of: ", stringify!(StdVideoH265HrdFlags))
2422 );
2423 assert_eq!(
2424 ::core::mem::align_of::<StdVideoH265HrdFlags>(),
2425 4usize,
2426 concat!("Alignment of ", stringify!(StdVideoH265HrdFlags))
2427 );
2428}
2429impl StdVideoH265HrdFlags {
2430 #[inline]
2431 pub fn nal_hrd_parameters_present_flag(&self) -> u32 {
2432 unsafe { ::core::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
2433 }
2434 #[inline]
2435 pub fn set_nal_hrd_parameters_present_flag(&mut self, val: u32) {
2436 unsafe {
2437 let val: u32 = ::core::mem::transmute(val);
2438 self._bitfield_1.set(0usize, 1u8, val as u64)
2439 }
2440 }
2441 #[inline]
2442 pub fn vcl_hrd_parameters_present_flag(&self) -> u32 {
2443 unsafe { ::core::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
2444 }
2445 #[inline]
2446 pub fn set_vcl_hrd_parameters_present_flag(&mut self, val: u32) {
2447 unsafe {
2448 let val: u32 = ::core::mem::transmute(val);
2449 self._bitfield_1.set(1usize, 1u8, val as u64)
2450 }
2451 }
2452 #[inline]
2453 pub fn sub_pic_hrd_params_present_flag(&self) -> u32 {
2454 unsafe { ::core::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
2455 }
2456 #[inline]
2457 pub fn set_sub_pic_hrd_params_present_flag(&mut self, val: u32) {
2458 unsafe {
2459 let val: u32 = ::core::mem::transmute(val);
2460 self._bitfield_1.set(2usize, 1u8, val as u64)
2461 }
2462 }
2463 #[inline]
2464 pub fn sub_pic_cpb_params_in_pic_timing_sei_flag(&self) -> u32 {
2465 unsafe { ::core::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
2466 }
2467 #[inline]
2468 pub fn set_sub_pic_cpb_params_in_pic_timing_sei_flag(&mut self, val: u32) {
2469 unsafe {
2470 let val: u32 = ::core::mem::transmute(val);
2471 self._bitfield_1.set(3usize, 1u8, val as u64)
2472 }
2473 }
2474 #[inline]
2475 pub fn fixed_pic_rate_general_flag(&self) -> u32 {
2476 unsafe { ::core::mem::transmute(self._bitfield_1.get(4usize, 8u8) as u32) }
2477 }
2478 #[inline]
2479 pub fn set_fixed_pic_rate_general_flag(&mut self, val: u32) {
2480 unsafe {
2481 let val: u32 = ::core::mem::transmute(val);
2482 self._bitfield_1.set(4usize, 8u8, val as u64)
2483 }
2484 }
2485 #[inline]
2486 pub fn fixed_pic_rate_within_cvs_flag(&self) -> u32 {
2487 unsafe { ::core::mem::transmute(self._bitfield_1.get(12usize, 8u8) as u32) }
2488 }
2489 #[inline]
2490 pub fn set_fixed_pic_rate_within_cvs_flag(&mut self, val: u32) {
2491 unsafe {
2492 let val: u32 = ::core::mem::transmute(val);
2493 self._bitfield_1.set(12usize, 8u8, val as u64)
2494 }
2495 }
2496 #[inline]
2497 pub fn low_delay_hrd_flag(&self) -> u32 {
2498 unsafe { ::core::mem::transmute(self._bitfield_1.get(20usize, 8u8) as u32) }
2499 }
2500 #[inline]
2501 pub fn set_low_delay_hrd_flag(&mut self, val: u32) {
2502 unsafe {
2503 let val: u32 = ::core::mem::transmute(val);
2504 self._bitfield_1.set(20usize, 8u8, val as u64)
2505 }
2506 }
2507 #[inline]
2508 pub fn new_bitfield_1(
2509 nal_hrd_parameters_present_flag: u32,
2510 vcl_hrd_parameters_present_flag: u32,
2511 sub_pic_hrd_params_present_flag: u32,
2512 sub_pic_cpb_params_in_pic_timing_sei_flag: u32,
2513 fixed_pic_rate_general_flag: u32,
2514 fixed_pic_rate_within_cvs_flag: u32,
2515 low_delay_hrd_flag: u32,
2516 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
2517 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
2518 __bindgen_bitfield_unit.set(0usize, 1u8, {
2519 let nal_hrd_parameters_present_flag: u32 =
2520 unsafe { ::core::mem::transmute(nal_hrd_parameters_present_flag) };
2521 nal_hrd_parameters_present_flag as u64
2522 });
2523 __bindgen_bitfield_unit.set(1usize, 1u8, {
2524 let vcl_hrd_parameters_present_flag: u32 =
2525 unsafe { ::core::mem::transmute(vcl_hrd_parameters_present_flag) };
2526 vcl_hrd_parameters_present_flag as u64
2527 });
2528 __bindgen_bitfield_unit.set(2usize, 1u8, {
2529 let sub_pic_hrd_params_present_flag: u32 =
2530 unsafe { ::core::mem::transmute(sub_pic_hrd_params_present_flag) };
2531 sub_pic_hrd_params_present_flag as u64
2532 });
2533 __bindgen_bitfield_unit.set(3usize, 1u8, {
2534 let sub_pic_cpb_params_in_pic_timing_sei_flag: u32 =
2535 unsafe { ::core::mem::transmute(sub_pic_cpb_params_in_pic_timing_sei_flag) };
2536 sub_pic_cpb_params_in_pic_timing_sei_flag as u64
2537 });
2538 __bindgen_bitfield_unit.set(4usize, 8u8, {
2539 let fixed_pic_rate_general_flag: u32 =
2540 unsafe { ::core::mem::transmute(fixed_pic_rate_general_flag) };
2541 fixed_pic_rate_general_flag as u64
2542 });
2543 __bindgen_bitfield_unit.set(12usize, 8u8, {
2544 let fixed_pic_rate_within_cvs_flag: u32 =
2545 unsafe { ::core::mem::transmute(fixed_pic_rate_within_cvs_flag) };
2546 fixed_pic_rate_within_cvs_flag as u64
2547 });
2548 __bindgen_bitfield_unit.set(20usize, 8u8, {
2549 let low_delay_hrd_flag: u32 = unsafe { ::core::mem::transmute(low_delay_hrd_flag) };
2550 low_delay_hrd_flag as u64
2551 });
2552 __bindgen_bitfield_unit
2553 }
2554}
2555#[repr(C)]
2556#[derive(Debug, Copy, Clone)]
2557pub struct StdVideoH265HrdParameters {
2558 pub flags: StdVideoH265HrdFlags,
2559 pub tick_divisor_minus2: u8,
2560 pub du_cpb_removal_delay_increment_length_minus1: u8,
2561 pub dpb_output_delay_du_length_minus1: u8,
2562 pub bit_rate_scale: u8,
2563 pub cpb_size_scale: u8,
2564 pub cpb_size_du_scale: u8,
2565 pub initial_cpb_removal_delay_length_minus1: u8,
2566 pub au_cpb_removal_delay_length_minus1: u8,
2567 pub dpb_output_delay_length_minus1: u8,
2568 pub cpb_cnt_minus1: [u8; 7usize],
2569 pub elemental_duration_in_tc_minus1: [u16; 7usize],
2570 pub reserved: [u16; 3usize],
2571 pub pSubLayerHrdParametersNal: *const StdVideoH265SubLayerHrdParameters,
2572 pub pSubLayerHrdParametersVcl: *const StdVideoH265SubLayerHrdParameters,
2573}
2574#[test]
2575fn bindgen_test_layout_StdVideoH265HrdParameters() {
2576 const UNINIT: ::core::mem::MaybeUninit<StdVideoH265HrdParameters> =
2577 ::core::mem::MaybeUninit::uninit();
2578 let ptr = UNINIT.as_ptr();
2579 assert_eq!(
2580 ::core::mem::size_of::<StdVideoH265HrdParameters>(),
2581 56usize,
2582 concat!("Size of: ", stringify!(StdVideoH265HrdParameters))
2583 );
2584 assert_eq!(
2585 ::core::mem::align_of::<StdVideoH265HrdParameters>(),
2586 8usize,
2587 concat!("Alignment of ", stringify!(StdVideoH265HrdParameters))
2588 );
2589 assert_eq!(
2590 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
2591 0usize,
2592 concat!(
2593 "Offset of field: ",
2594 stringify!(StdVideoH265HrdParameters),
2595 "::",
2596 stringify!(flags)
2597 )
2598 );
2599 assert_eq!(
2600 unsafe { ::core::ptr::addr_of!((*ptr).tick_divisor_minus2) as usize - ptr as usize },
2601 4usize,
2602 concat!(
2603 "Offset of field: ",
2604 stringify!(StdVideoH265HrdParameters),
2605 "::",
2606 stringify!(tick_divisor_minus2)
2607 )
2608 );
2609 assert_eq!(
2610 unsafe {
2611 ::core::ptr::addr_of!((*ptr).du_cpb_removal_delay_increment_length_minus1) as usize
2612 - ptr as usize
2613 },
2614 5usize,
2615 concat!(
2616 "Offset of field: ",
2617 stringify!(StdVideoH265HrdParameters),
2618 "::",
2619 stringify!(du_cpb_removal_delay_increment_length_minus1)
2620 )
2621 );
2622 assert_eq!(
2623 unsafe {
2624 ::core::ptr::addr_of!((*ptr).dpb_output_delay_du_length_minus1) as usize - ptr as usize
2625 },
2626 6usize,
2627 concat!(
2628 "Offset of field: ",
2629 stringify!(StdVideoH265HrdParameters),
2630 "::",
2631 stringify!(dpb_output_delay_du_length_minus1)
2632 )
2633 );
2634 assert_eq!(
2635 unsafe { ::core::ptr::addr_of!((*ptr).bit_rate_scale) as usize - ptr as usize },
2636 7usize,
2637 concat!(
2638 "Offset of field: ",
2639 stringify!(StdVideoH265HrdParameters),
2640 "::",
2641 stringify!(bit_rate_scale)
2642 )
2643 );
2644 assert_eq!(
2645 unsafe { ::core::ptr::addr_of!((*ptr).cpb_size_scale) as usize - ptr as usize },
2646 8usize,
2647 concat!(
2648 "Offset of field: ",
2649 stringify!(StdVideoH265HrdParameters),
2650 "::",
2651 stringify!(cpb_size_scale)
2652 )
2653 );
2654 assert_eq!(
2655 unsafe { ::core::ptr::addr_of!((*ptr).cpb_size_du_scale) as usize - ptr as usize },
2656 9usize,
2657 concat!(
2658 "Offset of field: ",
2659 stringify!(StdVideoH265HrdParameters),
2660 "::",
2661 stringify!(cpb_size_du_scale)
2662 )
2663 );
2664 assert_eq!(
2665 unsafe {
2666 ::core::ptr::addr_of!((*ptr).initial_cpb_removal_delay_length_minus1) as usize
2667 - ptr as usize
2668 },
2669 10usize,
2670 concat!(
2671 "Offset of field: ",
2672 stringify!(StdVideoH265HrdParameters),
2673 "::",
2674 stringify!(initial_cpb_removal_delay_length_minus1)
2675 )
2676 );
2677 assert_eq!(
2678 unsafe {
2679 ::core::ptr::addr_of!((*ptr).au_cpb_removal_delay_length_minus1) as usize - ptr as usize
2680 },
2681 11usize,
2682 concat!(
2683 "Offset of field: ",
2684 stringify!(StdVideoH265HrdParameters),
2685 "::",
2686 stringify!(au_cpb_removal_delay_length_minus1)
2687 )
2688 );
2689 assert_eq!(
2690 unsafe {
2691 ::core::ptr::addr_of!((*ptr).dpb_output_delay_length_minus1) as usize - ptr as usize
2692 },
2693 12usize,
2694 concat!(
2695 "Offset of field: ",
2696 stringify!(StdVideoH265HrdParameters),
2697 "::",
2698 stringify!(dpb_output_delay_length_minus1)
2699 )
2700 );
2701 assert_eq!(
2702 unsafe { ::core::ptr::addr_of!((*ptr).cpb_cnt_minus1) as usize - ptr as usize },
2703 13usize,
2704 concat!(
2705 "Offset of field: ",
2706 stringify!(StdVideoH265HrdParameters),
2707 "::",
2708 stringify!(cpb_cnt_minus1)
2709 )
2710 );
2711 assert_eq!(
2712 unsafe {
2713 ::core::ptr::addr_of!((*ptr).elemental_duration_in_tc_minus1) as usize - ptr as usize
2714 },
2715 20usize,
2716 concat!(
2717 "Offset of field: ",
2718 stringify!(StdVideoH265HrdParameters),
2719 "::",
2720 stringify!(elemental_duration_in_tc_minus1)
2721 )
2722 );
2723 assert_eq!(
2724 unsafe { ::core::ptr::addr_of!((*ptr).reserved) as usize - ptr as usize },
2725 34usize,
2726 concat!(
2727 "Offset of field: ",
2728 stringify!(StdVideoH265HrdParameters),
2729 "::",
2730 stringify!(reserved)
2731 )
2732 );
2733 assert_eq!(
2734 unsafe { ::core::ptr::addr_of!((*ptr).pSubLayerHrdParametersNal) as usize - ptr as usize },
2735 40usize,
2736 concat!(
2737 "Offset of field: ",
2738 stringify!(StdVideoH265HrdParameters),
2739 "::",
2740 stringify!(pSubLayerHrdParametersNal)
2741 )
2742 );
2743 assert_eq!(
2744 unsafe { ::core::ptr::addr_of!((*ptr).pSubLayerHrdParametersVcl) as usize - ptr as usize },
2745 48usize,
2746 concat!(
2747 "Offset of field: ",
2748 stringify!(StdVideoH265HrdParameters),
2749 "::",
2750 stringify!(pSubLayerHrdParametersVcl)
2751 )
2752 );
2753}
2754#[repr(C)]
2755#[repr(align(4))]
2756#[derive(Debug, Copy, Clone)]
2757pub struct StdVideoH265VpsFlags {
2758 pub _bitfield_align_1: [u8; 0],
2759 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
2760 pub __bindgen_padding_0: [u8; 3usize],
2761}
2762#[test]
2763fn bindgen_test_layout_StdVideoH265VpsFlags() {
2764 assert_eq!(
2765 ::core::mem::size_of::<StdVideoH265VpsFlags>(),
2766 4usize,
2767 concat!("Size of: ", stringify!(StdVideoH265VpsFlags))
2768 );
2769 assert_eq!(
2770 ::core::mem::align_of::<StdVideoH265VpsFlags>(),
2771 4usize,
2772 concat!("Alignment of ", stringify!(StdVideoH265VpsFlags))
2773 );
2774}
2775impl StdVideoH265VpsFlags {
2776 #[inline]
2777 pub fn vps_temporal_id_nesting_flag(&self) -> u32 {
2778 unsafe { ::core::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
2779 }
2780 #[inline]
2781 pub fn set_vps_temporal_id_nesting_flag(&mut self, val: u32) {
2782 unsafe {
2783 let val: u32 = ::core::mem::transmute(val);
2784 self._bitfield_1.set(0usize, 1u8, val as u64)
2785 }
2786 }
2787 #[inline]
2788 pub fn vps_sub_layer_ordering_info_present_flag(&self) -> u32 {
2789 unsafe { ::core::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
2790 }
2791 #[inline]
2792 pub fn set_vps_sub_layer_ordering_info_present_flag(&mut self, val: u32) {
2793 unsafe {
2794 let val: u32 = ::core::mem::transmute(val);
2795 self._bitfield_1.set(1usize, 1u8, val as u64)
2796 }
2797 }
2798 #[inline]
2799 pub fn vps_timing_info_present_flag(&self) -> u32 {
2800 unsafe { ::core::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
2801 }
2802 #[inline]
2803 pub fn set_vps_timing_info_present_flag(&mut self, val: u32) {
2804 unsafe {
2805 let val: u32 = ::core::mem::transmute(val);
2806 self._bitfield_1.set(2usize, 1u8, val as u64)
2807 }
2808 }
2809 #[inline]
2810 pub fn vps_poc_proportional_to_timing_flag(&self) -> u32 {
2811 unsafe { ::core::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
2812 }
2813 #[inline]
2814 pub fn set_vps_poc_proportional_to_timing_flag(&mut self, val: u32) {
2815 unsafe {
2816 let val: u32 = ::core::mem::transmute(val);
2817 self._bitfield_1.set(3usize, 1u8, val as u64)
2818 }
2819 }
2820 #[inline]
2821 pub fn new_bitfield_1(
2822 vps_temporal_id_nesting_flag: u32,
2823 vps_sub_layer_ordering_info_present_flag: u32,
2824 vps_timing_info_present_flag: u32,
2825 vps_poc_proportional_to_timing_flag: u32,
2826 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
2827 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
2828 __bindgen_bitfield_unit.set(0usize, 1u8, {
2829 let vps_temporal_id_nesting_flag: u32 =
2830 unsafe { ::core::mem::transmute(vps_temporal_id_nesting_flag) };
2831 vps_temporal_id_nesting_flag as u64
2832 });
2833 __bindgen_bitfield_unit.set(1usize, 1u8, {
2834 let vps_sub_layer_ordering_info_present_flag: u32 =
2835 unsafe { ::core::mem::transmute(vps_sub_layer_ordering_info_present_flag) };
2836 vps_sub_layer_ordering_info_present_flag as u64
2837 });
2838 __bindgen_bitfield_unit.set(2usize, 1u8, {
2839 let vps_timing_info_present_flag: u32 =
2840 unsafe { ::core::mem::transmute(vps_timing_info_present_flag) };
2841 vps_timing_info_present_flag as u64
2842 });
2843 __bindgen_bitfield_unit.set(3usize, 1u8, {
2844 let vps_poc_proportional_to_timing_flag: u32 =
2845 unsafe { ::core::mem::transmute(vps_poc_proportional_to_timing_flag) };
2846 vps_poc_proportional_to_timing_flag as u64
2847 });
2848 __bindgen_bitfield_unit
2849 }
2850}
2851#[repr(C)]
2852#[repr(align(4))]
2853#[derive(Debug, Copy, Clone)]
2854pub struct StdVideoH265ProfileTierLevelFlags {
2855 pub _bitfield_align_1: [u8; 0],
2856 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
2857 pub __bindgen_padding_0: [u8; 3usize],
2858}
2859#[test]
2860fn bindgen_test_layout_StdVideoH265ProfileTierLevelFlags() {
2861 assert_eq!(
2862 ::core::mem::size_of::<StdVideoH265ProfileTierLevelFlags>(),
2863 4usize,
2864 concat!("Size of: ", stringify!(StdVideoH265ProfileTierLevelFlags))
2865 );
2866 assert_eq!(
2867 ::core::mem::align_of::<StdVideoH265ProfileTierLevelFlags>(),
2868 4usize,
2869 concat!(
2870 "Alignment of ",
2871 stringify!(StdVideoH265ProfileTierLevelFlags)
2872 )
2873 );
2874}
2875impl StdVideoH265ProfileTierLevelFlags {
2876 #[inline]
2877 pub fn general_tier_flag(&self) -> u32 {
2878 unsafe { ::core::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
2879 }
2880 #[inline]
2881 pub fn set_general_tier_flag(&mut self, val: u32) {
2882 unsafe {
2883 let val: u32 = ::core::mem::transmute(val);
2884 self._bitfield_1.set(0usize, 1u8, val as u64)
2885 }
2886 }
2887 #[inline]
2888 pub fn general_progressive_source_flag(&self) -> u32 {
2889 unsafe { ::core::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
2890 }
2891 #[inline]
2892 pub fn set_general_progressive_source_flag(&mut self, val: u32) {
2893 unsafe {
2894 let val: u32 = ::core::mem::transmute(val);
2895 self._bitfield_1.set(1usize, 1u8, val as u64)
2896 }
2897 }
2898 #[inline]
2899 pub fn general_interlaced_source_flag(&self) -> u32 {
2900 unsafe { ::core::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
2901 }
2902 #[inline]
2903 pub fn set_general_interlaced_source_flag(&mut self, val: u32) {
2904 unsafe {
2905 let val: u32 = ::core::mem::transmute(val);
2906 self._bitfield_1.set(2usize, 1u8, val as u64)
2907 }
2908 }
2909 #[inline]
2910 pub fn general_non_packed_constraint_flag(&self) -> u32 {
2911 unsafe { ::core::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
2912 }
2913 #[inline]
2914 pub fn set_general_non_packed_constraint_flag(&mut self, val: u32) {
2915 unsafe {
2916 let val: u32 = ::core::mem::transmute(val);
2917 self._bitfield_1.set(3usize, 1u8, val as u64)
2918 }
2919 }
2920 #[inline]
2921 pub fn general_frame_only_constraint_flag(&self) -> u32 {
2922 unsafe { ::core::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
2923 }
2924 #[inline]
2925 pub fn set_general_frame_only_constraint_flag(&mut self, val: u32) {
2926 unsafe {
2927 let val: u32 = ::core::mem::transmute(val);
2928 self._bitfield_1.set(4usize, 1u8, val as u64)
2929 }
2930 }
2931 #[inline]
2932 pub fn new_bitfield_1(
2933 general_tier_flag: u32,
2934 general_progressive_source_flag: u32,
2935 general_interlaced_source_flag: u32,
2936 general_non_packed_constraint_flag: u32,
2937 general_frame_only_constraint_flag: u32,
2938 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
2939 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
2940 __bindgen_bitfield_unit.set(0usize, 1u8, {
2941 let general_tier_flag: u32 = unsafe { ::core::mem::transmute(general_tier_flag) };
2942 general_tier_flag as u64
2943 });
2944 __bindgen_bitfield_unit.set(1usize, 1u8, {
2945 let general_progressive_source_flag: u32 =
2946 unsafe { ::core::mem::transmute(general_progressive_source_flag) };
2947 general_progressive_source_flag as u64
2948 });
2949 __bindgen_bitfield_unit.set(2usize, 1u8, {
2950 let general_interlaced_source_flag: u32 =
2951 unsafe { ::core::mem::transmute(general_interlaced_source_flag) };
2952 general_interlaced_source_flag as u64
2953 });
2954 __bindgen_bitfield_unit.set(3usize, 1u8, {
2955 let general_non_packed_constraint_flag: u32 =
2956 unsafe { ::core::mem::transmute(general_non_packed_constraint_flag) };
2957 general_non_packed_constraint_flag as u64
2958 });
2959 __bindgen_bitfield_unit.set(4usize, 1u8, {
2960 let general_frame_only_constraint_flag: u32 =
2961 unsafe { ::core::mem::transmute(general_frame_only_constraint_flag) };
2962 general_frame_only_constraint_flag as u64
2963 });
2964 __bindgen_bitfield_unit
2965 }
2966}
2967#[repr(C)]
2968#[derive(Debug, Copy, Clone)]
2969pub struct StdVideoH265ProfileTierLevel {
2970 pub flags: StdVideoH265ProfileTierLevelFlags,
2971 pub general_profile_idc: StdVideoH265ProfileIdc,
2972 pub general_level_idc: StdVideoH265LevelIdc,
2973}
2974#[test]
2975fn bindgen_test_layout_StdVideoH265ProfileTierLevel() {
2976 const UNINIT: ::core::mem::MaybeUninit<StdVideoH265ProfileTierLevel> =
2977 ::core::mem::MaybeUninit::uninit();
2978 let ptr = UNINIT.as_ptr();
2979 assert_eq!(
2980 ::core::mem::size_of::<StdVideoH265ProfileTierLevel>(),
2981 12usize,
2982 concat!("Size of: ", stringify!(StdVideoH265ProfileTierLevel))
2983 );
2984 assert_eq!(
2985 ::core::mem::align_of::<StdVideoH265ProfileTierLevel>(),
2986 4usize,
2987 concat!("Alignment of ", stringify!(StdVideoH265ProfileTierLevel))
2988 );
2989 assert_eq!(
2990 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
2991 0usize,
2992 concat!(
2993 "Offset of field: ",
2994 stringify!(StdVideoH265ProfileTierLevel),
2995 "::",
2996 stringify!(flags)
2997 )
2998 );
2999 assert_eq!(
3000 unsafe { ::core::ptr::addr_of!((*ptr).general_profile_idc) as usize - ptr as usize },
3001 4usize,
3002 concat!(
3003 "Offset of field: ",
3004 stringify!(StdVideoH265ProfileTierLevel),
3005 "::",
3006 stringify!(general_profile_idc)
3007 )
3008 );
3009 assert_eq!(
3010 unsafe { ::core::ptr::addr_of!((*ptr).general_level_idc) as usize - ptr as usize },
3011 8usize,
3012 concat!(
3013 "Offset of field: ",
3014 stringify!(StdVideoH265ProfileTierLevel),
3015 "::",
3016 stringify!(general_level_idc)
3017 )
3018 );
3019}
3020#[repr(C)]
3021#[derive(Debug, Copy, Clone)]
3022pub struct StdVideoH265VideoParameterSet {
3023 pub flags: StdVideoH265VpsFlags,
3024 pub vps_video_parameter_set_id: u8,
3025 pub vps_max_sub_layers_minus1: u8,
3026 pub reserved1: u8,
3027 pub reserved2: u8,
3028 pub vps_num_units_in_tick: u32,
3029 pub vps_time_scale: u32,
3030 pub vps_num_ticks_poc_diff_one_minus1: u32,
3031 pub reserved3: u32,
3032 pub pDecPicBufMgr: *const StdVideoH265DecPicBufMgr,
3033 pub pHrdParameters: *const StdVideoH265HrdParameters,
3034 pub pProfileTierLevel: *const StdVideoH265ProfileTierLevel,
3035}
3036#[test]
3037fn bindgen_test_layout_StdVideoH265VideoParameterSet() {
3038 const UNINIT: ::core::mem::MaybeUninit<StdVideoH265VideoParameterSet> =
3039 ::core::mem::MaybeUninit::uninit();
3040 let ptr = UNINIT.as_ptr();
3041 assert_eq!(
3042 ::core::mem::size_of::<StdVideoH265VideoParameterSet>(),
3043 48usize,
3044 concat!("Size of: ", stringify!(StdVideoH265VideoParameterSet))
3045 );
3046 assert_eq!(
3047 ::core::mem::align_of::<StdVideoH265VideoParameterSet>(),
3048 8usize,
3049 concat!("Alignment of ", stringify!(StdVideoH265VideoParameterSet))
3050 );
3051 assert_eq!(
3052 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
3053 0usize,
3054 concat!(
3055 "Offset of field: ",
3056 stringify!(StdVideoH265VideoParameterSet),
3057 "::",
3058 stringify!(flags)
3059 )
3060 );
3061 assert_eq!(
3062 unsafe { ::core::ptr::addr_of!((*ptr).vps_video_parameter_set_id) as usize - ptr as usize },
3063 4usize,
3064 concat!(
3065 "Offset of field: ",
3066 stringify!(StdVideoH265VideoParameterSet),
3067 "::",
3068 stringify!(vps_video_parameter_set_id)
3069 )
3070 );
3071 assert_eq!(
3072 unsafe { ::core::ptr::addr_of!((*ptr).vps_max_sub_layers_minus1) as usize - ptr as usize },
3073 5usize,
3074 concat!(
3075 "Offset of field: ",
3076 stringify!(StdVideoH265VideoParameterSet),
3077 "::",
3078 stringify!(vps_max_sub_layers_minus1)
3079 )
3080 );
3081 assert_eq!(
3082 unsafe { ::core::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize },
3083 6usize,
3084 concat!(
3085 "Offset of field: ",
3086 stringify!(StdVideoH265VideoParameterSet),
3087 "::",
3088 stringify!(reserved1)
3089 )
3090 );
3091 assert_eq!(
3092 unsafe { ::core::ptr::addr_of!((*ptr).reserved2) as usize - ptr as usize },
3093 7usize,
3094 concat!(
3095 "Offset of field: ",
3096 stringify!(StdVideoH265VideoParameterSet),
3097 "::",
3098 stringify!(reserved2)
3099 )
3100 );
3101 assert_eq!(
3102 unsafe { ::core::ptr::addr_of!((*ptr).vps_num_units_in_tick) as usize - ptr as usize },
3103 8usize,
3104 concat!(
3105 "Offset of field: ",
3106 stringify!(StdVideoH265VideoParameterSet),
3107 "::",
3108 stringify!(vps_num_units_in_tick)
3109 )
3110 );
3111 assert_eq!(
3112 unsafe { ::core::ptr::addr_of!((*ptr).vps_time_scale) as usize - ptr as usize },
3113 12usize,
3114 concat!(
3115 "Offset of field: ",
3116 stringify!(StdVideoH265VideoParameterSet),
3117 "::",
3118 stringify!(vps_time_scale)
3119 )
3120 );
3121 assert_eq!(
3122 unsafe {
3123 ::core::ptr::addr_of!((*ptr).vps_num_ticks_poc_diff_one_minus1) as usize - ptr as usize
3124 },
3125 16usize,
3126 concat!(
3127 "Offset of field: ",
3128 stringify!(StdVideoH265VideoParameterSet),
3129 "::",
3130 stringify!(vps_num_ticks_poc_diff_one_minus1)
3131 )
3132 );
3133 assert_eq!(
3134 unsafe { ::core::ptr::addr_of!((*ptr).reserved3) as usize - ptr as usize },
3135 20usize,
3136 concat!(
3137 "Offset of field: ",
3138 stringify!(StdVideoH265VideoParameterSet),
3139 "::",
3140 stringify!(reserved3)
3141 )
3142 );
3143 assert_eq!(
3144 unsafe { ::core::ptr::addr_of!((*ptr).pDecPicBufMgr) as usize - ptr as usize },
3145 24usize,
3146 concat!(
3147 "Offset of field: ",
3148 stringify!(StdVideoH265VideoParameterSet),
3149 "::",
3150 stringify!(pDecPicBufMgr)
3151 )
3152 );
3153 assert_eq!(
3154 unsafe { ::core::ptr::addr_of!((*ptr).pHrdParameters) as usize - ptr as usize },
3155 32usize,
3156 concat!(
3157 "Offset of field: ",
3158 stringify!(StdVideoH265VideoParameterSet),
3159 "::",
3160 stringify!(pHrdParameters)
3161 )
3162 );
3163 assert_eq!(
3164 unsafe { ::core::ptr::addr_of!((*ptr).pProfileTierLevel) as usize - ptr as usize },
3165 40usize,
3166 concat!(
3167 "Offset of field: ",
3168 stringify!(StdVideoH265VideoParameterSet),
3169 "::",
3170 stringify!(pProfileTierLevel)
3171 )
3172 );
3173}
3174#[repr(C)]
3175#[derive(Debug, Copy, Clone)]
3176pub struct StdVideoH265ScalingLists {
3177 pub ScalingList4x4: [[u8; 16usize]; 6usize],
3178 pub ScalingList8x8: [[u8; 64usize]; 6usize],
3179 pub ScalingList16x16: [[u8; 64usize]; 6usize],
3180 pub ScalingList32x32: [[u8; 64usize]; 2usize],
3181 pub ScalingListDCCoef16x16: [u8; 6usize],
3182 pub ScalingListDCCoef32x32: [u8; 2usize],
3183}
3184#[test]
3185fn bindgen_test_layout_StdVideoH265ScalingLists() {
3186 const UNINIT: ::core::mem::MaybeUninit<StdVideoH265ScalingLists> =
3187 ::core::mem::MaybeUninit::uninit();
3188 let ptr = UNINIT.as_ptr();
3189 assert_eq!(
3190 ::core::mem::size_of::<StdVideoH265ScalingLists>(),
3191 1000usize,
3192 concat!("Size of: ", stringify!(StdVideoH265ScalingLists))
3193 );
3194 assert_eq!(
3195 ::core::mem::align_of::<StdVideoH265ScalingLists>(),
3196 1usize,
3197 concat!("Alignment of ", stringify!(StdVideoH265ScalingLists))
3198 );
3199 assert_eq!(
3200 unsafe { ::core::ptr::addr_of!((*ptr).ScalingList4x4) as usize - ptr as usize },
3201 0usize,
3202 concat!(
3203 "Offset of field: ",
3204 stringify!(StdVideoH265ScalingLists),
3205 "::",
3206 stringify!(ScalingList4x4)
3207 )
3208 );
3209 assert_eq!(
3210 unsafe { ::core::ptr::addr_of!((*ptr).ScalingList8x8) as usize - ptr as usize },
3211 96usize,
3212 concat!(
3213 "Offset of field: ",
3214 stringify!(StdVideoH265ScalingLists),
3215 "::",
3216 stringify!(ScalingList8x8)
3217 )
3218 );
3219 assert_eq!(
3220 unsafe { ::core::ptr::addr_of!((*ptr).ScalingList16x16) as usize - ptr as usize },
3221 480usize,
3222 concat!(
3223 "Offset of field: ",
3224 stringify!(StdVideoH265ScalingLists),
3225 "::",
3226 stringify!(ScalingList16x16)
3227 )
3228 );
3229 assert_eq!(
3230 unsafe { ::core::ptr::addr_of!((*ptr).ScalingList32x32) as usize - ptr as usize },
3231 864usize,
3232 concat!(
3233 "Offset of field: ",
3234 stringify!(StdVideoH265ScalingLists),
3235 "::",
3236 stringify!(ScalingList32x32)
3237 )
3238 );
3239 assert_eq!(
3240 unsafe { ::core::ptr::addr_of!((*ptr).ScalingListDCCoef16x16) as usize - ptr as usize },
3241 992usize,
3242 concat!(
3243 "Offset of field: ",
3244 stringify!(StdVideoH265ScalingLists),
3245 "::",
3246 stringify!(ScalingListDCCoef16x16)
3247 )
3248 );
3249 assert_eq!(
3250 unsafe { ::core::ptr::addr_of!((*ptr).ScalingListDCCoef32x32) as usize - ptr as usize },
3251 998usize,
3252 concat!(
3253 "Offset of field: ",
3254 stringify!(StdVideoH265ScalingLists),
3255 "::",
3256 stringify!(ScalingListDCCoef32x32)
3257 )
3258 );
3259}
3260#[repr(C)]
3261#[repr(align(4))]
3262#[derive(Debug, Copy, Clone)]
3263pub struct StdVideoH265SpsVuiFlags {
3264 pub _bitfield_align_1: [u8; 0],
3265 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 3usize]>,
3266 pub __bindgen_padding_0: u8,
3267}
3268#[test]
3269fn bindgen_test_layout_StdVideoH265SpsVuiFlags() {
3270 assert_eq!(
3271 ::core::mem::size_of::<StdVideoH265SpsVuiFlags>(),
3272 4usize,
3273 concat!("Size of: ", stringify!(StdVideoH265SpsVuiFlags))
3274 );
3275 assert_eq!(
3276 ::core::mem::align_of::<StdVideoH265SpsVuiFlags>(),
3277 4usize,
3278 concat!("Alignment of ", stringify!(StdVideoH265SpsVuiFlags))
3279 );
3280}
3281impl StdVideoH265SpsVuiFlags {
3282 #[inline]
3283 pub fn aspect_ratio_info_present_flag(&self) -> u32 {
3284 unsafe { ::core::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
3285 }
3286 #[inline]
3287 pub fn set_aspect_ratio_info_present_flag(&mut self, val: u32) {
3288 unsafe {
3289 let val: u32 = ::core::mem::transmute(val);
3290 self._bitfield_1.set(0usize, 1u8, val as u64)
3291 }
3292 }
3293 #[inline]
3294 pub fn overscan_info_present_flag(&self) -> u32 {
3295 unsafe { ::core::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
3296 }
3297 #[inline]
3298 pub fn set_overscan_info_present_flag(&mut self, val: u32) {
3299 unsafe {
3300 let val: u32 = ::core::mem::transmute(val);
3301 self._bitfield_1.set(1usize, 1u8, val as u64)
3302 }
3303 }
3304 #[inline]
3305 pub fn overscan_appropriate_flag(&self) -> u32 {
3306 unsafe { ::core::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
3307 }
3308 #[inline]
3309 pub fn set_overscan_appropriate_flag(&mut self, val: u32) {
3310 unsafe {
3311 let val: u32 = ::core::mem::transmute(val);
3312 self._bitfield_1.set(2usize, 1u8, val as u64)
3313 }
3314 }
3315 #[inline]
3316 pub fn video_signal_type_present_flag(&self) -> u32 {
3317 unsafe { ::core::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
3318 }
3319 #[inline]
3320 pub fn set_video_signal_type_present_flag(&mut self, val: u32) {
3321 unsafe {
3322 let val: u32 = ::core::mem::transmute(val);
3323 self._bitfield_1.set(3usize, 1u8, val as u64)
3324 }
3325 }
3326 #[inline]
3327 pub fn video_full_range_flag(&self) -> u32 {
3328 unsafe { ::core::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
3329 }
3330 #[inline]
3331 pub fn set_video_full_range_flag(&mut self, val: u32) {
3332 unsafe {
3333 let val: u32 = ::core::mem::transmute(val);
3334 self._bitfield_1.set(4usize, 1u8, val as u64)
3335 }
3336 }
3337 #[inline]
3338 pub fn colour_description_present_flag(&self) -> u32 {
3339 unsafe { ::core::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
3340 }
3341 #[inline]
3342 pub fn set_colour_description_present_flag(&mut self, val: u32) {
3343 unsafe {
3344 let val: u32 = ::core::mem::transmute(val);
3345 self._bitfield_1.set(5usize, 1u8, val as u64)
3346 }
3347 }
3348 #[inline]
3349 pub fn chroma_loc_info_present_flag(&self) -> u32 {
3350 unsafe { ::core::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) }
3351 }
3352 #[inline]
3353 pub fn set_chroma_loc_info_present_flag(&mut self, val: u32) {
3354 unsafe {
3355 let val: u32 = ::core::mem::transmute(val);
3356 self._bitfield_1.set(6usize, 1u8, val as u64)
3357 }
3358 }
3359 #[inline]
3360 pub fn neutral_chroma_indication_flag(&self) -> u32 {
3361 unsafe { ::core::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) }
3362 }
3363 #[inline]
3364 pub fn set_neutral_chroma_indication_flag(&mut self, val: u32) {
3365 unsafe {
3366 let val: u32 = ::core::mem::transmute(val);
3367 self._bitfield_1.set(7usize, 1u8, val as u64)
3368 }
3369 }
3370 #[inline]
3371 pub fn field_seq_flag(&self) -> u32 {
3372 unsafe { ::core::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) }
3373 }
3374 #[inline]
3375 pub fn set_field_seq_flag(&mut self, val: u32) {
3376 unsafe {
3377 let val: u32 = ::core::mem::transmute(val);
3378 self._bitfield_1.set(8usize, 1u8, val as u64)
3379 }
3380 }
3381 #[inline]
3382 pub fn frame_field_info_present_flag(&self) -> u32 {
3383 unsafe { ::core::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) }
3384 }
3385 #[inline]
3386 pub fn set_frame_field_info_present_flag(&mut self, val: u32) {
3387 unsafe {
3388 let val: u32 = ::core::mem::transmute(val);
3389 self._bitfield_1.set(9usize, 1u8, val as u64)
3390 }
3391 }
3392 #[inline]
3393 pub fn default_display_window_flag(&self) -> u32 {
3394 unsafe { ::core::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) }
3395 }
3396 #[inline]
3397 pub fn set_default_display_window_flag(&mut self, val: u32) {
3398 unsafe {
3399 let val: u32 = ::core::mem::transmute(val);
3400 self._bitfield_1.set(10usize, 1u8, val as u64)
3401 }
3402 }
3403 #[inline]
3404 pub fn vui_timing_info_present_flag(&self) -> u32 {
3405 unsafe { ::core::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) }
3406 }
3407 #[inline]
3408 pub fn set_vui_timing_info_present_flag(&mut self, val: u32) {
3409 unsafe {
3410 let val: u32 = ::core::mem::transmute(val);
3411 self._bitfield_1.set(11usize, 1u8, val as u64)
3412 }
3413 }
3414 #[inline]
3415 pub fn vui_poc_proportional_to_timing_flag(&self) -> u32 {
3416 unsafe { ::core::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u32) }
3417 }
3418 #[inline]
3419 pub fn set_vui_poc_proportional_to_timing_flag(&mut self, val: u32) {
3420 unsafe {
3421 let val: u32 = ::core::mem::transmute(val);
3422 self._bitfield_1.set(12usize, 1u8, val as u64)
3423 }
3424 }
3425 #[inline]
3426 pub fn vui_hrd_parameters_present_flag(&self) -> u32 {
3427 unsafe { ::core::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) }
3428 }
3429 #[inline]
3430 pub fn set_vui_hrd_parameters_present_flag(&mut self, val: u32) {
3431 unsafe {
3432 let val: u32 = ::core::mem::transmute(val);
3433 self._bitfield_1.set(13usize, 1u8, val as u64)
3434 }
3435 }
3436 #[inline]
3437 pub fn bitstream_restriction_flag(&self) -> u32 {
3438 unsafe { ::core::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) }
3439 }
3440 #[inline]
3441 pub fn set_bitstream_restriction_flag(&mut self, val: u32) {
3442 unsafe {
3443 let val: u32 = ::core::mem::transmute(val);
3444 self._bitfield_1.set(14usize, 1u8, val as u64)
3445 }
3446 }
3447 #[inline]
3448 pub fn tiles_fixed_structure_flag(&self) -> u32 {
3449 unsafe { ::core::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u32) }
3450 }
3451 #[inline]
3452 pub fn set_tiles_fixed_structure_flag(&mut self, val: u32) {
3453 unsafe {
3454 let val: u32 = ::core::mem::transmute(val);
3455 self._bitfield_1.set(15usize, 1u8, val as u64)
3456 }
3457 }
3458 #[inline]
3459 pub fn motion_vectors_over_pic_boundaries_flag(&self) -> u32 {
3460 unsafe { ::core::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u32) }
3461 }
3462 #[inline]
3463 pub fn set_motion_vectors_over_pic_boundaries_flag(&mut self, val: u32) {
3464 unsafe {
3465 let val: u32 = ::core::mem::transmute(val);
3466 self._bitfield_1.set(16usize, 1u8, val as u64)
3467 }
3468 }
3469 #[inline]
3470 pub fn restricted_ref_pic_lists_flag(&self) -> u32 {
3471 unsafe { ::core::mem::transmute(self._bitfield_1.get(17usize, 1u8) as u32) }
3472 }
3473 #[inline]
3474 pub fn set_restricted_ref_pic_lists_flag(&mut self, val: u32) {
3475 unsafe {
3476 let val: u32 = ::core::mem::transmute(val);
3477 self._bitfield_1.set(17usize, 1u8, val as u64)
3478 }
3479 }
3480 #[inline]
3481 pub fn new_bitfield_1(
3482 aspect_ratio_info_present_flag: u32,
3483 overscan_info_present_flag: u32,
3484 overscan_appropriate_flag: u32,
3485 video_signal_type_present_flag: u32,
3486 video_full_range_flag: u32,
3487 colour_description_present_flag: u32,
3488 chroma_loc_info_present_flag: u32,
3489 neutral_chroma_indication_flag: u32,
3490 field_seq_flag: u32,
3491 frame_field_info_present_flag: u32,
3492 default_display_window_flag: u32,
3493 vui_timing_info_present_flag: u32,
3494 vui_poc_proportional_to_timing_flag: u32,
3495 vui_hrd_parameters_present_flag: u32,
3496 bitstream_restriction_flag: u32,
3497 tiles_fixed_structure_flag: u32,
3498 motion_vectors_over_pic_boundaries_flag: u32,
3499 restricted_ref_pic_lists_flag: u32,
3500 ) -> __BindgenBitfieldUnit<[u8; 3usize]> {
3501 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 3usize]> = Default::default();
3502 __bindgen_bitfield_unit.set(0usize, 1u8, {
3503 let aspect_ratio_info_present_flag: u32 =
3504 unsafe { ::core::mem::transmute(aspect_ratio_info_present_flag) };
3505 aspect_ratio_info_present_flag as u64
3506 });
3507 __bindgen_bitfield_unit.set(1usize, 1u8, {
3508 let overscan_info_present_flag: u32 =
3509 unsafe { ::core::mem::transmute(overscan_info_present_flag) };
3510 overscan_info_present_flag as u64
3511 });
3512 __bindgen_bitfield_unit.set(2usize, 1u8, {
3513 let overscan_appropriate_flag: u32 =
3514 unsafe { ::core::mem::transmute(overscan_appropriate_flag) };
3515 overscan_appropriate_flag as u64
3516 });
3517 __bindgen_bitfield_unit.set(3usize, 1u8, {
3518 let video_signal_type_present_flag: u32 =
3519 unsafe { ::core::mem::transmute(video_signal_type_present_flag) };
3520 video_signal_type_present_flag as u64
3521 });
3522 __bindgen_bitfield_unit.set(4usize, 1u8, {
3523 let video_full_range_flag: u32 =
3524 unsafe { ::core::mem::transmute(video_full_range_flag) };
3525 video_full_range_flag as u64
3526 });
3527 __bindgen_bitfield_unit.set(5usize, 1u8, {
3528 let colour_description_present_flag: u32 =
3529 unsafe { ::core::mem::transmute(colour_description_present_flag) };
3530 colour_description_present_flag as u64
3531 });
3532 __bindgen_bitfield_unit.set(6usize, 1u8, {
3533 let chroma_loc_info_present_flag: u32 =
3534 unsafe { ::core::mem::transmute(chroma_loc_info_present_flag) };
3535 chroma_loc_info_present_flag as u64
3536 });
3537 __bindgen_bitfield_unit.set(7usize, 1u8, {
3538 let neutral_chroma_indication_flag: u32 =
3539 unsafe { ::core::mem::transmute(neutral_chroma_indication_flag) };
3540 neutral_chroma_indication_flag as u64
3541 });
3542 __bindgen_bitfield_unit.set(8usize, 1u8, {
3543 let field_seq_flag: u32 = unsafe { ::core::mem::transmute(field_seq_flag) };
3544 field_seq_flag as u64
3545 });
3546 __bindgen_bitfield_unit.set(9usize, 1u8, {
3547 let frame_field_info_present_flag: u32 =
3548 unsafe { ::core::mem::transmute(frame_field_info_present_flag) };
3549 frame_field_info_present_flag as u64
3550 });
3551 __bindgen_bitfield_unit.set(10usize, 1u8, {
3552 let default_display_window_flag: u32 =
3553 unsafe { ::core::mem::transmute(default_display_window_flag) };
3554 default_display_window_flag as u64
3555 });
3556 __bindgen_bitfield_unit.set(11usize, 1u8, {
3557 let vui_timing_info_present_flag: u32 =
3558 unsafe { ::core::mem::transmute(vui_timing_info_present_flag) };
3559 vui_timing_info_present_flag as u64
3560 });
3561 __bindgen_bitfield_unit.set(12usize, 1u8, {
3562 let vui_poc_proportional_to_timing_flag: u32 =
3563 unsafe { ::core::mem::transmute(vui_poc_proportional_to_timing_flag) };
3564 vui_poc_proportional_to_timing_flag as u64
3565 });
3566 __bindgen_bitfield_unit.set(13usize, 1u8, {
3567 let vui_hrd_parameters_present_flag: u32 =
3568 unsafe { ::core::mem::transmute(vui_hrd_parameters_present_flag) };
3569 vui_hrd_parameters_present_flag as u64
3570 });
3571 __bindgen_bitfield_unit.set(14usize, 1u8, {
3572 let bitstream_restriction_flag: u32 =
3573 unsafe { ::core::mem::transmute(bitstream_restriction_flag) };
3574 bitstream_restriction_flag as u64
3575 });
3576 __bindgen_bitfield_unit.set(15usize, 1u8, {
3577 let tiles_fixed_structure_flag: u32 =
3578 unsafe { ::core::mem::transmute(tiles_fixed_structure_flag) };
3579 tiles_fixed_structure_flag as u64
3580 });
3581 __bindgen_bitfield_unit.set(16usize, 1u8, {
3582 let motion_vectors_over_pic_boundaries_flag: u32 =
3583 unsafe { ::core::mem::transmute(motion_vectors_over_pic_boundaries_flag) };
3584 motion_vectors_over_pic_boundaries_flag as u64
3585 });
3586 __bindgen_bitfield_unit.set(17usize, 1u8, {
3587 let restricted_ref_pic_lists_flag: u32 =
3588 unsafe { ::core::mem::transmute(restricted_ref_pic_lists_flag) };
3589 restricted_ref_pic_lists_flag as u64
3590 });
3591 __bindgen_bitfield_unit
3592 }
3593}
3594#[repr(C)]
3595#[derive(Debug, Copy, Clone)]
3596pub struct StdVideoH265SequenceParameterSetVui {
3597 pub flags: StdVideoH265SpsVuiFlags,
3598 pub aspect_ratio_idc: StdVideoH265AspectRatioIdc,
3599 pub sar_width: u16,
3600 pub sar_height: u16,
3601 pub video_format: u8,
3602 pub colour_primaries: u8,
3603 pub transfer_characteristics: u8,
3604 pub matrix_coeffs: u8,
3605 pub chroma_sample_loc_type_top_field: u8,
3606 pub chroma_sample_loc_type_bottom_field: u8,
3607 pub reserved1: u8,
3608 pub reserved2: u8,
3609 pub def_disp_win_left_offset: u16,
3610 pub def_disp_win_right_offset: u16,
3611 pub def_disp_win_top_offset: u16,
3612 pub def_disp_win_bottom_offset: u16,
3613 pub vui_num_units_in_tick: u32,
3614 pub vui_time_scale: u32,
3615 pub vui_num_ticks_poc_diff_one_minus1: u32,
3616 pub min_spatial_segmentation_idc: u16,
3617 pub reserved3: u16,
3618 pub max_bytes_per_pic_denom: u8,
3619 pub max_bits_per_min_cu_denom: u8,
3620 pub log2_max_mv_length_horizontal: u8,
3621 pub log2_max_mv_length_vertical: u8,
3622 pub pHrdParameters: *const StdVideoH265HrdParameters,
3623}
3624#[test]
3625fn bindgen_test_layout_StdVideoH265SequenceParameterSetVui() {
3626 const UNINIT: ::core::mem::MaybeUninit<StdVideoH265SequenceParameterSetVui> =
3627 ::core::mem::MaybeUninit::uninit();
3628 let ptr = UNINIT.as_ptr();
3629 assert_eq!(
3630 ::core::mem::size_of::<StdVideoH265SequenceParameterSetVui>(),
3631 56usize,
3632 concat!("Size of: ", stringify!(StdVideoH265SequenceParameterSetVui))
3633 );
3634 assert_eq!(
3635 ::core::mem::align_of::<StdVideoH265SequenceParameterSetVui>(),
3636 8usize,
3637 concat!(
3638 "Alignment of ",
3639 stringify!(StdVideoH265SequenceParameterSetVui)
3640 )
3641 );
3642 assert_eq!(
3643 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
3644 0usize,
3645 concat!(
3646 "Offset of field: ",
3647 stringify!(StdVideoH265SequenceParameterSetVui),
3648 "::",
3649 stringify!(flags)
3650 )
3651 );
3652 assert_eq!(
3653 unsafe { ::core::ptr::addr_of!((*ptr).aspect_ratio_idc) as usize - ptr as usize },
3654 4usize,
3655 concat!(
3656 "Offset of field: ",
3657 stringify!(StdVideoH265SequenceParameterSetVui),
3658 "::",
3659 stringify!(aspect_ratio_idc)
3660 )
3661 );
3662 assert_eq!(
3663 unsafe { ::core::ptr::addr_of!((*ptr).sar_width) as usize - ptr as usize },
3664 8usize,
3665 concat!(
3666 "Offset of field: ",
3667 stringify!(StdVideoH265SequenceParameterSetVui),
3668 "::",
3669 stringify!(sar_width)
3670 )
3671 );
3672 assert_eq!(
3673 unsafe { ::core::ptr::addr_of!((*ptr).sar_height) as usize - ptr as usize },
3674 10usize,
3675 concat!(
3676 "Offset of field: ",
3677 stringify!(StdVideoH265SequenceParameterSetVui),
3678 "::",
3679 stringify!(sar_height)
3680 )
3681 );
3682 assert_eq!(
3683 unsafe { ::core::ptr::addr_of!((*ptr).video_format) as usize - ptr as usize },
3684 12usize,
3685 concat!(
3686 "Offset of field: ",
3687 stringify!(StdVideoH265SequenceParameterSetVui),
3688 "::",
3689 stringify!(video_format)
3690 )
3691 );
3692 assert_eq!(
3693 unsafe { ::core::ptr::addr_of!((*ptr).colour_primaries) as usize - ptr as usize },
3694 13usize,
3695 concat!(
3696 "Offset of field: ",
3697 stringify!(StdVideoH265SequenceParameterSetVui),
3698 "::",
3699 stringify!(colour_primaries)
3700 )
3701 );
3702 assert_eq!(
3703 unsafe { ::core::ptr::addr_of!((*ptr).transfer_characteristics) as usize - ptr as usize },
3704 14usize,
3705 concat!(
3706 "Offset of field: ",
3707 stringify!(StdVideoH265SequenceParameterSetVui),
3708 "::",
3709 stringify!(transfer_characteristics)
3710 )
3711 );
3712 assert_eq!(
3713 unsafe { ::core::ptr::addr_of!((*ptr).matrix_coeffs) as usize - ptr as usize },
3714 15usize,
3715 concat!(
3716 "Offset of field: ",
3717 stringify!(StdVideoH265SequenceParameterSetVui),
3718 "::",
3719 stringify!(matrix_coeffs)
3720 )
3721 );
3722 assert_eq!(
3723 unsafe {
3724 ::core::ptr::addr_of!((*ptr).chroma_sample_loc_type_top_field) as usize - ptr as usize
3725 },
3726 16usize,
3727 concat!(
3728 "Offset of field: ",
3729 stringify!(StdVideoH265SequenceParameterSetVui),
3730 "::",
3731 stringify!(chroma_sample_loc_type_top_field)
3732 )
3733 );
3734 assert_eq!(
3735 unsafe {
3736 ::core::ptr::addr_of!((*ptr).chroma_sample_loc_type_bottom_field) as usize
3737 - ptr as usize
3738 },
3739 17usize,
3740 concat!(
3741 "Offset of field: ",
3742 stringify!(StdVideoH265SequenceParameterSetVui),
3743 "::",
3744 stringify!(chroma_sample_loc_type_bottom_field)
3745 )
3746 );
3747 assert_eq!(
3748 unsafe { ::core::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize },
3749 18usize,
3750 concat!(
3751 "Offset of field: ",
3752 stringify!(StdVideoH265SequenceParameterSetVui),
3753 "::",
3754 stringify!(reserved1)
3755 )
3756 );
3757 assert_eq!(
3758 unsafe { ::core::ptr::addr_of!((*ptr).reserved2) as usize - ptr as usize },
3759 19usize,
3760 concat!(
3761 "Offset of field: ",
3762 stringify!(StdVideoH265SequenceParameterSetVui),
3763 "::",
3764 stringify!(reserved2)
3765 )
3766 );
3767 assert_eq!(
3768 unsafe { ::core::ptr::addr_of!((*ptr).def_disp_win_left_offset) as usize - ptr as usize },
3769 20usize,
3770 concat!(
3771 "Offset of field: ",
3772 stringify!(StdVideoH265SequenceParameterSetVui),
3773 "::",
3774 stringify!(def_disp_win_left_offset)
3775 )
3776 );
3777 assert_eq!(
3778 unsafe { ::core::ptr::addr_of!((*ptr).def_disp_win_right_offset) as usize - ptr as usize },
3779 22usize,
3780 concat!(
3781 "Offset of field: ",
3782 stringify!(StdVideoH265SequenceParameterSetVui),
3783 "::",
3784 stringify!(def_disp_win_right_offset)
3785 )
3786 );
3787 assert_eq!(
3788 unsafe { ::core::ptr::addr_of!((*ptr).def_disp_win_top_offset) as usize - ptr as usize },
3789 24usize,
3790 concat!(
3791 "Offset of field: ",
3792 stringify!(StdVideoH265SequenceParameterSetVui),
3793 "::",
3794 stringify!(def_disp_win_top_offset)
3795 )
3796 );
3797 assert_eq!(
3798 unsafe { ::core::ptr::addr_of!((*ptr).def_disp_win_bottom_offset) as usize - ptr as usize },
3799 26usize,
3800 concat!(
3801 "Offset of field: ",
3802 stringify!(StdVideoH265SequenceParameterSetVui),
3803 "::",
3804 stringify!(def_disp_win_bottom_offset)
3805 )
3806 );
3807 assert_eq!(
3808 unsafe { ::core::ptr::addr_of!((*ptr).vui_num_units_in_tick) as usize - ptr as usize },
3809 28usize,
3810 concat!(
3811 "Offset of field: ",
3812 stringify!(StdVideoH265SequenceParameterSetVui),
3813 "::",
3814 stringify!(vui_num_units_in_tick)
3815 )
3816 );
3817 assert_eq!(
3818 unsafe { ::core::ptr::addr_of!((*ptr).vui_time_scale) as usize - ptr as usize },
3819 32usize,
3820 concat!(
3821 "Offset of field: ",
3822 stringify!(StdVideoH265SequenceParameterSetVui),
3823 "::",
3824 stringify!(vui_time_scale)
3825 )
3826 );
3827 assert_eq!(
3828 unsafe {
3829 ::core::ptr::addr_of!((*ptr).vui_num_ticks_poc_diff_one_minus1) as usize - ptr as usize
3830 },
3831 36usize,
3832 concat!(
3833 "Offset of field: ",
3834 stringify!(StdVideoH265SequenceParameterSetVui),
3835 "::",
3836 stringify!(vui_num_ticks_poc_diff_one_minus1)
3837 )
3838 );
3839 assert_eq!(
3840 unsafe {
3841 ::core::ptr::addr_of!((*ptr).min_spatial_segmentation_idc) as usize - ptr as usize
3842 },
3843 40usize,
3844 concat!(
3845 "Offset of field: ",
3846 stringify!(StdVideoH265SequenceParameterSetVui),
3847 "::",
3848 stringify!(min_spatial_segmentation_idc)
3849 )
3850 );
3851 assert_eq!(
3852 unsafe { ::core::ptr::addr_of!((*ptr).reserved3) as usize - ptr as usize },
3853 42usize,
3854 concat!(
3855 "Offset of field: ",
3856 stringify!(StdVideoH265SequenceParameterSetVui),
3857 "::",
3858 stringify!(reserved3)
3859 )
3860 );
3861 assert_eq!(
3862 unsafe { ::core::ptr::addr_of!((*ptr).max_bytes_per_pic_denom) as usize - ptr as usize },
3863 44usize,
3864 concat!(
3865 "Offset of field: ",
3866 stringify!(StdVideoH265SequenceParameterSetVui),
3867 "::",
3868 stringify!(max_bytes_per_pic_denom)
3869 )
3870 );
3871 assert_eq!(
3872 unsafe { ::core::ptr::addr_of!((*ptr).max_bits_per_min_cu_denom) as usize - ptr as usize },
3873 45usize,
3874 concat!(
3875 "Offset of field: ",
3876 stringify!(StdVideoH265SequenceParameterSetVui),
3877 "::",
3878 stringify!(max_bits_per_min_cu_denom)
3879 )
3880 );
3881 assert_eq!(
3882 unsafe {
3883 ::core::ptr::addr_of!((*ptr).log2_max_mv_length_horizontal) as usize - ptr as usize
3884 },
3885 46usize,
3886 concat!(
3887 "Offset of field: ",
3888 stringify!(StdVideoH265SequenceParameterSetVui),
3889 "::",
3890 stringify!(log2_max_mv_length_horizontal)
3891 )
3892 );
3893 assert_eq!(
3894 unsafe {
3895 ::core::ptr::addr_of!((*ptr).log2_max_mv_length_vertical) as usize - ptr as usize
3896 },
3897 47usize,
3898 concat!(
3899 "Offset of field: ",
3900 stringify!(StdVideoH265SequenceParameterSetVui),
3901 "::",
3902 stringify!(log2_max_mv_length_vertical)
3903 )
3904 );
3905 assert_eq!(
3906 unsafe { ::core::ptr::addr_of!((*ptr).pHrdParameters) as usize - ptr as usize },
3907 48usize,
3908 concat!(
3909 "Offset of field: ",
3910 stringify!(StdVideoH265SequenceParameterSetVui),
3911 "::",
3912 stringify!(pHrdParameters)
3913 )
3914 );
3915}
3916#[repr(C)]
3917#[derive(Debug, Copy, Clone)]
3918pub struct StdVideoH265PredictorPaletteEntries {
3919 pub PredictorPaletteEntries: [[u16; 128usize]; 3usize],
3920}
3921#[test]
3922fn bindgen_test_layout_StdVideoH265PredictorPaletteEntries() {
3923 const UNINIT: ::core::mem::MaybeUninit<StdVideoH265PredictorPaletteEntries> =
3924 ::core::mem::MaybeUninit::uninit();
3925 let ptr = UNINIT.as_ptr();
3926 assert_eq!(
3927 ::core::mem::size_of::<StdVideoH265PredictorPaletteEntries>(),
3928 768usize,
3929 concat!("Size of: ", stringify!(StdVideoH265PredictorPaletteEntries))
3930 );
3931 assert_eq!(
3932 ::core::mem::align_of::<StdVideoH265PredictorPaletteEntries>(),
3933 2usize,
3934 concat!(
3935 "Alignment of ",
3936 stringify!(StdVideoH265PredictorPaletteEntries)
3937 )
3938 );
3939 assert_eq!(
3940 unsafe { ::core::ptr::addr_of!((*ptr).PredictorPaletteEntries) as usize - ptr as usize },
3941 0usize,
3942 concat!(
3943 "Offset of field: ",
3944 stringify!(StdVideoH265PredictorPaletteEntries),
3945 "::",
3946 stringify!(PredictorPaletteEntries)
3947 )
3948 );
3949}
3950#[repr(C)]
3951#[repr(align(4))]
3952#[derive(Debug, Copy, Clone)]
3953pub struct StdVideoH265SpsFlags {
3954 pub _bitfield_align_1: [u8; 0],
3955 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
3956}
3957#[test]
3958fn bindgen_test_layout_StdVideoH265SpsFlags() {
3959 assert_eq!(
3960 ::core::mem::size_of::<StdVideoH265SpsFlags>(),
3961 4usize,
3962 concat!("Size of: ", stringify!(StdVideoH265SpsFlags))
3963 );
3964 assert_eq!(
3965 ::core::mem::align_of::<StdVideoH265SpsFlags>(),
3966 4usize,
3967 concat!("Alignment of ", stringify!(StdVideoH265SpsFlags))
3968 );
3969}
3970impl StdVideoH265SpsFlags {
3971 #[inline]
3972 pub fn sps_temporal_id_nesting_flag(&self) -> u32 {
3973 unsafe { ::core::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
3974 }
3975 #[inline]
3976 pub fn set_sps_temporal_id_nesting_flag(&mut self, val: u32) {
3977 unsafe {
3978 let val: u32 = ::core::mem::transmute(val);
3979 self._bitfield_1.set(0usize, 1u8, val as u64)
3980 }
3981 }
3982 #[inline]
3983 pub fn separate_colour_plane_flag(&self) -> u32 {
3984 unsafe { ::core::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
3985 }
3986 #[inline]
3987 pub fn set_separate_colour_plane_flag(&mut self, val: u32) {
3988 unsafe {
3989 let val: u32 = ::core::mem::transmute(val);
3990 self._bitfield_1.set(1usize, 1u8, val as u64)
3991 }
3992 }
3993 #[inline]
3994 pub fn conformance_window_flag(&self) -> u32 {
3995 unsafe { ::core::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
3996 }
3997 #[inline]
3998 pub fn set_conformance_window_flag(&mut self, val: u32) {
3999 unsafe {
4000 let val: u32 = ::core::mem::transmute(val);
4001 self._bitfield_1.set(2usize, 1u8, val as u64)
4002 }
4003 }
4004 #[inline]
4005 pub fn sps_sub_layer_ordering_info_present_flag(&self) -> u32 {
4006 unsafe { ::core::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
4007 }
4008 #[inline]
4009 pub fn set_sps_sub_layer_ordering_info_present_flag(&mut self, val: u32) {
4010 unsafe {
4011 let val: u32 = ::core::mem::transmute(val);
4012 self._bitfield_1.set(3usize, 1u8, val as u64)
4013 }
4014 }
4015 #[inline]
4016 pub fn scaling_list_enabled_flag(&self) -> u32 {
4017 unsafe { ::core::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
4018 }
4019 #[inline]
4020 pub fn set_scaling_list_enabled_flag(&mut self, val: u32) {
4021 unsafe {
4022 let val: u32 = ::core::mem::transmute(val);
4023 self._bitfield_1.set(4usize, 1u8, val as u64)
4024 }
4025 }
4026 #[inline]
4027 pub fn sps_scaling_list_data_present_flag(&self) -> u32 {
4028 unsafe { ::core::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
4029 }
4030 #[inline]
4031 pub fn set_sps_scaling_list_data_present_flag(&mut self, val: u32) {
4032 unsafe {
4033 let val: u32 = ::core::mem::transmute(val);
4034 self._bitfield_1.set(5usize, 1u8, val as u64)
4035 }
4036 }
4037 #[inline]
4038 pub fn amp_enabled_flag(&self) -> u32 {
4039 unsafe { ::core::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) }
4040 }
4041 #[inline]
4042 pub fn set_amp_enabled_flag(&mut self, val: u32) {
4043 unsafe {
4044 let val: u32 = ::core::mem::transmute(val);
4045 self._bitfield_1.set(6usize, 1u8, val as u64)
4046 }
4047 }
4048 #[inline]
4049 pub fn sample_adaptive_offset_enabled_flag(&self) -> u32 {
4050 unsafe { ::core::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) }
4051 }
4052 #[inline]
4053 pub fn set_sample_adaptive_offset_enabled_flag(&mut self, val: u32) {
4054 unsafe {
4055 let val: u32 = ::core::mem::transmute(val);
4056 self._bitfield_1.set(7usize, 1u8, val as u64)
4057 }
4058 }
4059 #[inline]
4060 pub fn pcm_enabled_flag(&self) -> u32 {
4061 unsafe { ::core::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) }
4062 }
4063 #[inline]
4064 pub fn set_pcm_enabled_flag(&mut self, val: u32) {
4065 unsafe {
4066 let val: u32 = ::core::mem::transmute(val);
4067 self._bitfield_1.set(8usize, 1u8, val as u64)
4068 }
4069 }
4070 #[inline]
4071 pub fn pcm_loop_filter_disabled_flag(&self) -> u32 {
4072 unsafe { ::core::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) }
4073 }
4074 #[inline]
4075 pub fn set_pcm_loop_filter_disabled_flag(&mut self, val: u32) {
4076 unsafe {
4077 let val: u32 = ::core::mem::transmute(val);
4078 self._bitfield_1.set(9usize, 1u8, val as u64)
4079 }
4080 }
4081 #[inline]
4082 pub fn long_term_ref_pics_present_flag(&self) -> u32 {
4083 unsafe { ::core::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) }
4084 }
4085 #[inline]
4086 pub fn set_long_term_ref_pics_present_flag(&mut self, val: u32) {
4087 unsafe {
4088 let val: u32 = ::core::mem::transmute(val);
4089 self._bitfield_1.set(10usize, 1u8, val as u64)
4090 }
4091 }
4092 #[inline]
4093 pub fn sps_temporal_mvp_enabled_flag(&self) -> u32 {
4094 unsafe { ::core::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) }
4095 }
4096 #[inline]
4097 pub fn set_sps_temporal_mvp_enabled_flag(&mut self, val: u32) {
4098 unsafe {
4099 let val: u32 = ::core::mem::transmute(val);
4100 self._bitfield_1.set(11usize, 1u8, val as u64)
4101 }
4102 }
4103 #[inline]
4104 pub fn strong_intra_smoothing_enabled_flag(&self) -> u32 {
4105 unsafe { ::core::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u32) }
4106 }
4107 #[inline]
4108 pub fn set_strong_intra_smoothing_enabled_flag(&mut self, val: u32) {
4109 unsafe {
4110 let val: u32 = ::core::mem::transmute(val);
4111 self._bitfield_1.set(12usize, 1u8, val as u64)
4112 }
4113 }
4114 #[inline]
4115 pub fn vui_parameters_present_flag(&self) -> u32 {
4116 unsafe { ::core::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) }
4117 }
4118 #[inline]
4119 pub fn set_vui_parameters_present_flag(&mut self, val: u32) {
4120 unsafe {
4121 let val: u32 = ::core::mem::transmute(val);
4122 self._bitfield_1.set(13usize, 1u8, val as u64)
4123 }
4124 }
4125 #[inline]
4126 pub fn sps_extension_present_flag(&self) -> u32 {
4127 unsafe { ::core::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) }
4128 }
4129 #[inline]
4130 pub fn set_sps_extension_present_flag(&mut self, val: u32) {
4131 unsafe {
4132 let val: u32 = ::core::mem::transmute(val);
4133 self._bitfield_1.set(14usize, 1u8, val as u64)
4134 }
4135 }
4136 #[inline]
4137 pub fn sps_range_extension_flag(&self) -> u32 {
4138 unsafe { ::core::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u32) }
4139 }
4140 #[inline]
4141 pub fn set_sps_range_extension_flag(&mut self, val: u32) {
4142 unsafe {
4143 let val: u32 = ::core::mem::transmute(val);
4144 self._bitfield_1.set(15usize, 1u8, val as u64)
4145 }
4146 }
4147 #[inline]
4148 pub fn transform_skip_rotation_enabled_flag(&self) -> u32 {
4149 unsafe { ::core::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u32) }
4150 }
4151 #[inline]
4152 pub fn set_transform_skip_rotation_enabled_flag(&mut self, val: u32) {
4153 unsafe {
4154 let val: u32 = ::core::mem::transmute(val);
4155 self._bitfield_1.set(16usize, 1u8, val as u64)
4156 }
4157 }
4158 #[inline]
4159 pub fn transform_skip_context_enabled_flag(&self) -> u32 {
4160 unsafe { ::core::mem::transmute(self._bitfield_1.get(17usize, 1u8) as u32) }
4161 }
4162 #[inline]
4163 pub fn set_transform_skip_context_enabled_flag(&mut self, val: u32) {
4164 unsafe {
4165 let val: u32 = ::core::mem::transmute(val);
4166 self._bitfield_1.set(17usize, 1u8, val as u64)
4167 }
4168 }
4169 #[inline]
4170 pub fn implicit_rdpcm_enabled_flag(&self) -> u32 {
4171 unsafe { ::core::mem::transmute(self._bitfield_1.get(18usize, 1u8) as u32) }
4172 }
4173 #[inline]
4174 pub fn set_implicit_rdpcm_enabled_flag(&mut self, val: u32) {
4175 unsafe {
4176 let val: u32 = ::core::mem::transmute(val);
4177 self._bitfield_1.set(18usize, 1u8, val as u64)
4178 }
4179 }
4180 #[inline]
4181 pub fn explicit_rdpcm_enabled_flag(&self) -> u32 {
4182 unsafe { ::core::mem::transmute(self._bitfield_1.get(19usize, 1u8) as u32) }
4183 }
4184 #[inline]
4185 pub fn set_explicit_rdpcm_enabled_flag(&mut self, val: u32) {
4186 unsafe {
4187 let val: u32 = ::core::mem::transmute(val);
4188 self._bitfield_1.set(19usize, 1u8, val as u64)
4189 }
4190 }
4191 #[inline]
4192 pub fn extended_precision_processing_flag(&self) -> u32 {
4193 unsafe { ::core::mem::transmute(self._bitfield_1.get(20usize, 1u8) as u32) }
4194 }
4195 #[inline]
4196 pub fn set_extended_precision_processing_flag(&mut self, val: u32) {
4197 unsafe {
4198 let val: u32 = ::core::mem::transmute(val);
4199 self._bitfield_1.set(20usize, 1u8, val as u64)
4200 }
4201 }
4202 #[inline]
4203 pub fn intra_smoothing_disabled_flag(&self) -> u32 {
4204 unsafe { ::core::mem::transmute(self._bitfield_1.get(21usize, 1u8) as u32) }
4205 }
4206 #[inline]
4207 pub fn set_intra_smoothing_disabled_flag(&mut self, val: u32) {
4208 unsafe {
4209 let val: u32 = ::core::mem::transmute(val);
4210 self._bitfield_1.set(21usize, 1u8, val as u64)
4211 }
4212 }
4213 #[inline]
4214 pub fn high_precision_offsets_enabled_flag(&self) -> u32 {
4215 unsafe { ::core::mem::transmute(self._bitfield_1.get(22usize, 1u8) as u32) }
4216 }
4217 #[inline]
4218 pub fn set_high_precision_offsets_enabled_flag(&mut self, val: u32) {
4219 unsafe {
4220 let val: u32 = ::core::mem::transmute(val);
4221 self._bitfield_1.set(22usize, 1u8, val as u64)
4222 }
4223 }
4224 #[inline]
4225 pub fn persistent_rice_adaptation_enabled_flag(&self) -> u32 {
4226 unsafe { ::core::mem::transmute(self._bitfield_1.get(23usize, 1u8) as u32) }
4227 }
4228 #[inline]
4229 pub fn set_persistent_rice_adaptation_enabled_flag(&mut self, val: u32) {
4230 unsafe {
4231 let val: u32 = ::core::mem::transmute(val);
4232 self._bitfield_1.set(23usize, 1u8, val as u64)
4233 }
4234 }
4235 #[inline]
4236 pub fn cabac_bypass_alignment_enabled_flag(&self) -> u32 {
4237 unsafe { ::core::mem::transmute(self._bitfield_1.get(24usize, 1u8) as u32) }
4238 }
4239 #[inline]
4240 pub fn set_cabac_bypass_alignment_enabled_flag(&mut self, val: u32) {
4241 unsafe {
4242 let val: u32 = ::core::mem::transmute(val);
4243 self._bitfield_1.set(24usize, 1u8, val as u64)
4244 }
4245 }
4246 #[inline]
4247 pub fn sps_scc_extension_flag(&self) -> u32 {
4248 unsafe { ::core::mem::transmute(self._bitfield_1.get(25usize, 1u8) as u32) }
4249 }
4250 #[inline]
4251 pub fn set_sps_scc_extension_flag(&mut self, val: u32) {
4252 unsafe {
4253 let val: u32 = ::core::mem::transmute(val);
4254 self._bitfield_1.set(25usize, 1u8, val as u64)
4255 }
4256 }
4257 #[inline]
4258 pub fn sps_curr_pic_ref_enabled_flag(&self) -> u32 {
4259 unsafe { ::core::mem::transmute(self._bitfield_1.get(26usize, 1u8) as u32) }
4260 }
4261 #[inline]
4262 pub fn set_sps_curr_pic_ref_enabled_flag(&mut self, val: u32) {
4263 unsafe {
4264 let val: u32 = ::core::mem::transmute(val);
4265 self._bitfield_1.set(26usize, 1u8, val as u64)
4266 }
4267 }
4268 #[inline]
4269 pub fn palette_mode_enabled_flag(&self) -> u32 {
4270 unsafe { ::core::mem::transmute(self._bitfield_1.get(27usize, 1u8) as u32) }
4271 }
4272 #[inline]
4273 pub fn set_palette_mode_enabled_flag(&mut self, val: u32) {
4274 unsafe {
4275 let val: u32 = ::core::mem::transmute(val);
4276 self._bitfield_1.set(27usize, 1u8, val as u64)
4277 }
4278 }
4279 #[inline]
4280 pub fn sps_palette_predictor_initializers_present_flag(&self) -> u32 {
4281 unsafe { ::core::mem::transmute(self._bitfield_1.get(28usize, 1u8) as u32) }
4282 }
4283 #[inline]
4284 pub fn set_sps_palette_predictor_initializers_present_flag(&mut self, val: u32) {
4285 unsafe {
4286 let val: u32 = ::core::mem::transmute(val);
4287 self._bitfield_1.set(28usize, 1u8, val as u64)
4288 }
4289 }
4290 #[inline]
4291 pub fn intra_boundary_filtering_disabled_flag(&self) -> u32 {
4292 unsafe { ::core::mem::transmute(self._bitfield_1.get(29usize, 1u8) as u32) }
4293 }
4294 #[inline]
4295 pub fn set_intra_boundary_filtering_disabled_flag(&mut self, val: u32) {
4296 unsafe {
4297 let val: u32 = ::core::mem::transmute(val);
4298 self._bitfield_1.set(29usize, 1u8, val as u64)
4299 }
4300 }
4301 #[inline]
4302 pub fn new_bitfield_1(
4303 sps_temporal_id_nesting_flag: u32,
4304 separate_colour_plane_flag: u32,
4305 conformance_window_flag: u32,
4306 sps_sub_layer_ordering_info_present_flag: u32,
4307 scaling_list_enabled_flag: u32,
4308 sps_scaling_list_data_present_flag: u32,
4309 amp_enabled_flag: u32,
4310 sample_adaptive_offset_enabled_flag: u32,
4311 pcm_enabled_flag: u32,
4312 pcm_loop_filter_disabled_flag: u32,
4313 long_term_ref_pics_present_flag: u32,
4314 sps_temporal_mvp_enabled_flag: u32,
4315 strong_intra_smoothing_enabled_flag: u32,
4316 vui_parameters_present_flag: u32,
4317 sps_extension_present_flag: u32,
4318 sps_range_extension_flag: u32,
4319 transform_skip_rotation_enabled_flag: u32,
4320 transform_skip_context_enabled_flag: u32,
4321 implicit_rdpcm_enabled_flag: u32,
4322 explicit_rdpcm_enabled_flag: u32,
4323 extended_precision_processing_flag: u32,
4324 intra_smoothing_disabled_flag: u32,
4325 high_precision_offsets_enabled_flag: u32,
4326 persistent_rice_adaptation_enabled_flag: u32,
4327 cabac_bypass_alignment_enabled_flag: u32,
4328 sps_scc_extension_flag: u32,
4329 sps_curr_pic_ref_enabled_flag: u32,
4330 palette_mode_enabled_flag: u32,
4331 sps_palette_predictor_initializers_present_flag: u32,
4332 intra_boundary_filtering_disabled_flag: u32,
4333 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
4334 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
4335 __bindgen_bitfield_unit.set(0usize, 1u8, {
4336 let sps_temporal_id_nesting_flag: u32 =
4337 unsafe { ::core::mem::transmute(sps_temporal_id_nesting_flag) };
4338 sps_temporal_id_nesting_flag as u64
4339 });
4340 __bindgen_bitfield_unit.set(1usize, 1u8, {
4341 let separate_colour_plane_flag: u32 =
4342 unsafe { ::core::mem::transmute(separate_colour_plane_flag) };
4343 separate_colour_plane_flag as u64
4344 });
4345 __bindgen_bitfield_unit.set(2usize, 1u8, {
4346 let conformance_window_flag: u32 =
4347 unsafe { ::core::mem::transmute(conformance_window_flag) };
4348 conformance_window_flag as u64
4349 });
4350 __bindgen_bitfield_unit.set(3usize, 1u8, {
4351 let sps_sub_layer_ordering_info_present_flag: u32 =
4352 unsafe { ::core::mem::transmute(sps_sub_layer_ordering_info_present_flag) };
4353 sps_sub_layer_ordering_info_present_flag as u64
4354 });
4355 __bindgen_bitfield_unit.set(4usize, 1u8, {
4356 let scaling_list_enabled_flag: u32 =
4357 unsafe { ::core::mem::transmute(scaling_list_enabled_flag) };
4358 scaling_list_enabled_flag as u64
4359 });
4360 __bindgen_bitfield_unit.set(5usize, 1u8, {
4361 let sps_scaling_list_data_present_flag: u32 =
4362 unsafe { ::core::mem::transmute(sps_scaling_list_data_present_flag) };
4363 sps_scaling_list_data_present_flag as u64
4364 });
4365 __bindgen_bitfield_unit.set(6usize, 1u8, {
4366 let amp_enabled_flag: u32 = unsafe { ::core::mem::transmute(amp_enabled_flag) };
4367 amp_enabled_flag as u64
4368 });
4369 __bindgen_bitfield_unit.set(7usize, 1u8, {
4370 let sample_adaptive_offset_enabled_flag: u32 =
4371 unsafe { ::core::mem::transmute(sample_adaptive_offset_enabled_flag) };
4372 sample_adaptive_offset_enabled_flag as u64
4373 });
4374 __bindgen_bitfield_unit.set(8usize, 1u8, {
4375 let pcm_enabled_flag: u32 = unsafe { ::core::mem::transmute(pcm_enabled_flag) };
4376 pcm_enabled_flag as u64
4377 });
4378 __bindgen_bitfield_unit.set(9usize, 1u8, {
4379 let pcm_loop_filter_disabled_flag: u32 =
4380 unsafe { ::core::mem::transmute(pcm_loop_filter_disabled_flag) };
4381 pcm_loop_filter_disabled_flag as u64
4382 });
4383 __bindgen_bitfield_unit.set(10usize, 1u8, {
4384 let long_term_ref_pics_present_flag: u32 =
4385 unsafe { ::core::mem::transmute(long_term_ref_pics_present_flag) };
4386 long_term_ref_pics_present_flag as u64
4387 });
4388 __bindgen_bitfield_unit.set(11usize, 1u8, {
4389 let sps_temporal_mvp_enabled_flag: u32 =
4390 unsafe { ::core::mem::transmute(sps_temporal_mvp_enabled_flag) };
4391 sps_temporal_mvp_enabled_flag as u64
4392 });
4393 __bindgen_bitfield_unit.set(12usize, 1u8, {
4394 let strong_intra_smoothing_enabled_flag: u32 =
4395 unsafe { ::core::mem::transmute(strong_intra_smoothing_enabled_flag) };
4396 strong_intra_smoothing_enabled_flag as u64
4397 });
4398 __bindgen_bitfield_unit.set(13usize, 1u8, {
4399 let vui_parameters_present_flag: u32 =
4400 unsafe { ::core::mem::transmute(vui_parameters_present_flag) };
4401 vui_parameters_present_flag as u64
4402 });
4403 __bindgen_bitfield_unit.set(14usize, 1u8, {
4404 let sps_extension_present_flag: u32 =
4405 unsafe { ::core::mem::transmute(sps_extension_present_flag) };
4406 sps_extension_present_flag as u64
4407 });
4408 __bindgen_bitfield_unit.set(15usize, 1u8, {
4409 let sps_range_extension_flag: u32 =
4410 unsafe { ::core::mem::transmute(sps_range_extension_flag) };
4411 sps_range_extension_flag as u64
4412 });
4413 __bindgen_bitfield_unit.set(16usize, 1u8, {
4414 let transform_skip_rotation_enabled_flag: u32 =
4415 unsafe { ::core::mem::transmute(transform_skip_rotation_enabled_flag) };
4416 transform_skip_rotation_enabled_flag as u64
4417 });
4418 __bindgen_bitfield_unit.set(17usize, 1u8, {
4419 let transform_skip_context_enabled_flag: u32 =
4420 unsafe { ::core::mem::transmute(transform_skip_context_enabled_flag) };
4421 transform_skip_context_enabled_flag as u64
4422 });
4423 __bindgen_bitfield_unit.set(18usize, 1u8, {
4424 let implicit_rdpcm_enabled_flag: u32 =
4425 unsafe { ::core::mem::transmute(implicit_rdpcm_enabled_flag) };
4426 implicit_rdpcm_enabled_flag as u64
4427 });
4428 __bindgen_bitfield_unit.set(19usize, 1u8, {
4429 let explicit_rdpcm_enabled_flag: u32 =
4430 unsafe { ::core::mem::transmute(explicit_rdpcm_enabled_flag) };
4431 explicit_rdpcm_enabled_flag as u64
4432 });
4433 __bindgen_bitfield_unit.set(20usize, 1u8, {
4434 let extended_precision_processing_flag: u32 =
4435 unsafe { ::core::mem::transmute(extended_precision_processing_flag) };
4436 extended_precision_processing_flag as u64
4437 });
4438 __bindgen_bitfield_unit.set(21usize, 1u8, {
4439 let intra_smoothing_disabled_flag: u32 =
4440 unsafe { ::core::mem::transmute(intra_smoothing_disabled_flag) };
4441 intra_smoothing_disabled_flag as u64
4442 });
4443 __bindgen_bitfield_unit.set(22usize, 1u8, {
4444 let high_precision_offsets_enabled_flag: u32 =
4445 unsafe { ::core::mem::transmute(high_precision_offsets_enabled_flag) };
4446 high_precision_offsets_enabled_flag as u64
4447 });
4448 __bindgen_bitfield_unit.set(23usize, 1u8, {
4449 let persistent_rice_adaptation_enabled_flag: u32 =
4450 unsafe { ::core::mem::transmute(persistent_rice_adaptation_enabled_flag) };
4451 persistent_rice_adaptation_enabled_flag as u64
4452 });
4453 __bindgen_bitfield_unit.set(24usize, 1u8, {
4454 let cabac_bypass_alignment_enabled_flag: u32 =
4455 unsafe { ::core::mem::transmute(cabac_bypass_alignment_enabled_flag) };
4456 cabac_bypass_alignment_enabled_flag as u64
4457 });
4458 __bindgen_bitfield_unit.set(25usize, 1u8, {
4459 let sps_scc_extension_flag: u32 =
4460 unsafe { ::core::mem::transmute(sps_scc_extension_flag) };
4461 sps_scc_extension_flag as u64
4462 });
4463 __bindgen_bitfield_unit.set(26usize, 1u8, {
4464 let sps_curr_pic_ref_enabled_flag: u32 =
4465 unsafe { ::core::mem::transmute(sps_curr_pic_ref_enabled_flag) };
4466 sps_curr_pic_ref_enabled_flag as u64
4467 });
4468 __bindgen_bitfield_unit.set(27usize, 1u8, {
4469 let palette_mode_enabled_flag: u32 =
4470 unsafe { ::core::mem::transmute(palette_mode_enabled_flag) };
4471 palette_mode_enabled_flag as u64
4472 });
4473 __bindgen_bitfield_unit.set(28usize, 1u8, {
4474 let sps_palette_predictor_initializers_present_flag: u32 =
4475 unsafe { ::core::mem::transmute(sps_palette_predictor_initializers_present_flag) };
4476 sps_palette_predictor_initializers_present_flag as u64
4477 });
4478 __bindgen_bitfield_unit.set(29usize, 1u8, {
4479 let intra_boundary_filtering_disabled_flag: u32 =
4480 unsafe { ::core::mem::transmute(intra_boundary_filtering_disabled_flag) };
4481 intra_boundary_filtering_disabled_flag as u64
4482 });
4483 __bindgen_bitfield_unit
4484 }
4485}
4486#[repr(C)]
4487#[repr(align(4))]
4488#[derive(Debug, Copy, Clone)]
4489pub struct StdVideoH265ShortTermRefPicSetFlags {
4490 pub _bitfield_align_1: [u8; 0],
4491 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
4492 pub __bindgen_padding_0: [u8; 3usize],
4493}
4494#[test]
4495fn bindgen_test_layout_StdVideoH265ShortTermRefPicSetFlags() {
4496 assert_eq!(
4497 ::core::mem::size_of::<StdVideoH265ShortTermRefPicSetFlags>(),
4498 4usize,
4499 concat!("Size of: ", stringify!(StdVideoH265ShortTermRefPicSetFlags))
4500 );
4501 assert_eq!(
4502 ::core::mem::align_of::<StdVideoH265ShortTermRefPicSetFlags>(),
4503 4usize,
4504 concat!(
4505 "Alignment of ",
4506 stringify!(StdVideoH265ShortTermRefPicSetFlags)
4507 )
4508 );
4509}
4510impl StdVideoH265ShortTermRefPicSetFlags {
4511 #[inline]
4512 pub fn inter_ref_pic_set_prediction_flag(&self) -> u32 {
4513 unsafe { ::core::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
4514 }
4515 #[inline]
4516 pub fn set_inter_ref_pic_set_prediction_flag(&mut self, val: u32) {
4517 unsafe {
4518 let val: u32 = ::core::mem::transmute(val);
4519 self._bitfield_1.set(0usize, 1u8, val as u64)
4520 }
4521 }
4522 #[inline]
4523 pub fn delta_rps_sign(&self) -> u32 {
4524 unsafe { ::core::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
4525 }
4526 #[inline]
4527 pub fn set_delta_rps_sign(&mut self, val: u32) {
4528 unsafe {
4529 let val: u32 = ::core::mem::transmute(val);
4530 self._bitfield_1.set(1usize, 1u8, val as u64)
4531 }
4532 }
4533 #[inline]
4534 pub fn new_bitfield_1(
4535 inter_ref_pic_set_prediction_flag: u32,
4536 delta_rps_sign: u32,
4537 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
4538 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
4539 __bindgen_bitfield_unit.set(0usize, 1u8, {
4540 let inter_ref_pic_set_prediction_flag: u32 =
4541 unsafe { ::core::mem::transmute(inter_ref_pic_set_prediction_flag) };
4542 inter_ref_pic_set_prediction_flag as u64
4543 });
4544 __bindgen_bitfield_unit.set(1usize, 1u8, {
4545 let delta_rps_sign: u32 = unsafe { ::core::mem::transmute(delta_rps_sign) };
4546 delta_rps_sign as u64
4547 });
4548 __bindgen_bitfield_unit
4549 }
4550}
4551#[repr(C)]
4552#[derive(Debug, Copy, Clone)]
4553pub struct StdVideoH265ShortTermRefPicSet {
4554 pub flags: StdVideoH265ShortTermRefPicSetFlags,
4555 pub delta_idx_minus1: u32,
4556 pub use_delta_flag: u16,
4557 pub abs_delta_rps_minus1: u16,
4558 pub used_by_curr_pic_flag: u16,
4559 pub used_by_curr_pic_s0_flag: u16,
4560 pub used_by_curr_pic_s1_flag: u16,
4561 pub reserved1: u16,
4562 pub reserved2: u8,
4563 pub reserved3: u8,
4564 pub num_negative_pics: u8,
4565 pub num_positive_pics: u8,
4566 pub delta_poc_s0_minus1: [u16; 16usize],
4567 pub delta_poc_s1_minus1: [u16; 16usize],
4568}
4569#[test]
4570fn bindgen_test_layout_StdVideoH265ShortTermRefPicSet() {
4571 const UNINIT: ::core::mem::MaybeUninit<StdVideoH265ShortTermRefPicSet> =
4572 ::core::mem::MaybeUninit::uninit();
4573 let ptr = UNINIT.as_ptr();
4574 assert_eq!(
4575 ::core::mem::size_of::<StdVideoH265ShortTermRefPicSet>(),
4576 88usize,
4577 concat!("Size of: ", stringify!(StdVideoH265ShortTermRefPicSet))
4578 );
4579 assert_eq!(
4580 ::core::mem::align_of::<StdVideoH265ShortTermRefPicSet>(),
4581 4usize,
4582 concat!("Alignment of ", stringify!(StdVideoH265ShortTermRefPicSet))
4583 );
4584 assert_eq!(
4585 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
4586 0usize,
4587 concat!(
4588 "Offset of field: ",
4589 stringify!(StdVideoH265ShortTermRefPicSet),
4590 "::",
4591 stringify!(flags)
4592 )
4593 );
4594 assert_eq!(
4595 unsafe { ::core::ptr::addr_of!((*ptr).delta_idx_minus1) as usize - ptr as usize },
4596 4usize,
4597 concat!(
4598 "Offset of field: ",
4599 stringify!(StdVideoH265ShortTermRefPicSet),
4600 "::",
4601 stringify!(delta_idx_minus1)
4602 )
4603 );
4604 assert_eq!(
4605 unsafe { ::core::ptr::addr_of!((*ptr).use_delta_flag) as usize - ptr as usize },
4606 8usize,
4607 concat!(
4608 "Offset of field: ",
4609 stringify!(StdVideoH265ShortTermRefPicSet),
4610 "::",
4611 stringify!(use_delta_flag)
4612 )
4613 );
4614 assert_eq!(
4615 unsafe { ::core::ptr::addr_of!((*ptr).abs_delta_rps_minus1) as usize - ptr as usize },
4616 10usize,
4617 concat!(
4618 "Offset of field: ",
4619 stringify!(StdVideoH265ShortTermRefPicSet),
4620 "::",
4621 stringify!(abs_delta_rps_minus1)
4622 )
4623 );
4624 assert_eq!(
4625 unsafe { ::core::ptr::addr_of!((*ptr).used_by_curr_pic_flag) as usize - ptr as usize },
4626 12usize,
4627 concat!(
4628 "Offset of field: ",
4629 stringify!(StdVideoH265ShortTermRefPicSet),
4630 "::",
4631 stringify!(used_by_curr_pic_flag)
4632 )
4633 );
4634 assert_eq!(
4635 unsafe { ::core::ptr::addr_of!((*ptr).used_by_curr_pic_s0_flag) as usize - ptr as usize },
4636 14usize,
4637 concat!(
4638 "Offset of field: ",
4639 stringify!(StdVideoH265ShortTermRefPicSet),
4640 "::",
4641 stringify!(used_by_curr_pic_s0_flag)
4642 )
4643 );
4644 assert_eq!(
4645 unsafe { ::core::ptr::addr_of!((*ptr).used_by_curr_pic_s1_flag) as usize - ptr as usize },
4646 16usize,
4647 concat!(
4648 "Offset of field: ",
4649 stringify!(StdVideoH265ShortTermRefPicSet),
4650 "::",
4651 stringify!(used_by_curr_pic_s1_flag)
4652 )
4653 );
4654 assert_eq!(
4655 unsafe { ::core::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize },
4656 18usize,
4657 concat!(
4658 "Offset of field: ",
4659 stringify!(StdVideoH265ShortTermRefPicSet),
4660 "::",
4661 stringify!(reserved1)
4662 )
4663 );
4664 assert_eq!(
4665 unsafe { ::core::ptr::addr_of!((*ptr).reserved2) as usize - ptr as usize },
4666 20usize,
4667 concat!(
4668 "Offset of field: ",
4669 stringify!(StdVideoH265ShortTermRefPicSet),
4670 "::",
4671 stringify!(reserved2)
4672 )
4673 );
4674 assert_eq!(
4675 unsafe { ::core::ptr::addr_of!((*ptr).reserved3) as usize - ptr as usize },
4676 21usize,
4677 concat!(
4678 "Offset of field: ",
4679 stringify!(StdVideoH265ShortTermRefPicSet),
4680 "::",
4681 stringify!(reserved3)
4682 )
4683 );
4684 assert_eq!(
4685 unsafe { ::core::ptr::addr_of!((*ptr).num_negative_pics) as usize - ptr as usize },
4686 22usize,
4687 concat!(
4688 "Offset of field: ",
4689 stringify!(StdVideoH265ShortTermRefPicSet),
4690 "::",
4691 stringify!(num_negative_pics)
4692 )
4693 );
4694 assert_eq!(
4695 unsafe { ::core::ptr::addr_of!((*ptr).num_positive_pics) as usize - ptr as usize },
4696 23usize,
4697 concat!(
4698 "Offset of field: ",
4699 stringify!(StdVideoH265ShortTermRefPicSet),
4700 "::",
4701 stringify!(num_positive_pics)
4702 )
4703 );
4704 assert_eq!(
4705 unsafe { ::core::ptr::addr_of!((*ptr).delta_poc_s0_minus1) as usize - ptr as usize },
4706 24usize,
4707 concat!(
4708 "Offset of field: ",
4709 stringify!(StdVideoH265ShortTermRefPicSet),
4710 "::",
4711 stringify!(delta_poc_s0_minus1)
4712 )
4713 );
4714 assert_eq!(
4715 unsafe { ::core::ptr::addr_of!((*ptr).delta_poc_s1_minus1) as usize - ptr as usize },
4716 56usize,
4717 concat!(
4718 "Offset of field: ",
4719 stringify!(StdVideoH265ShortTermRefPicSet),
4720 "::",
4721 stringify!(delta_poc_s1_minus1)
4722 )
4723 );
4724}
4725#[repr(C)]
4726#[derive(Debug, Copy, Clone)]
4727pub struct StdVideoH265LongTermRefPicsSps {
4728 pub used_by_curr_pic_lt_sps_flag: u32,
4729 pub lt_ref_pic_poc_lsb_sps: [u32; 32usize],
4730}
4731#[test]
4732fn bindgen_test_layout_StdVideoH265LongTermRefPicsSps() {
4733 const UNINIT: ::core::mem::MaybeUninit<StdVideoH265LongTermRefPicsSps> =
4734 ::core::mem::MaybeUninit::uninit();
4735 let ptr = UNINIT.as_ptr();
4736 assert_eq!(
4737 ::core::mem::size_of::<StdVideoH265LongTermRefPicsSps>(),
4738 132usize,
4739 concat!("Size of: ", stringify!(StdVideoH265LongTermRefPicsSps))
4740 );
4741 assert_eq!(
4742 ::core::mem::align_of::<StdVideoH265LongTermRefPicsSps>(),
4743 4usize,
4744 concat!("Alignment of ", stringify!(StdVideoH265LongTermRefPicsSps))
4745 );
4746 assert_eq!(
4747 unsafe {
4748 ::core::ptr::addr_of!((*ptr).used_by_curr_pic_lt_sps_flag) as usize - ptr as usize
4749 },
4750 0usize,
4751 concat!(
4752 "Offset of field: ",
4753 stringify!(StdVideoH265LongTermRefPicsSps),
4754 "::",
4755 stringify!(used_by_curr_pic_lt_sps_flag)
4756 )
4757 );
4758 assert_eq!(
4759 unsafe { ::core::ptr::addr_of!((*ptr).lt_ref_pic_poc_lsb_sps) as usize - ptr as usize },
4760 4usize,
4761 concat!(
4762 "Offset of field: ",
4763 stringify!(StdVideoH265LongTermRefPicsSps),
4764 "::",
4765 stringify!(lt_ref_pic_poc_lsb_sps)
4766 )
4767 );
4768}
4769#[repr(C)]
4770#[derive(Debug, Copy, Clone)]
4771pub struct StdVideoH265SequenceParameterSet {
4772 pub flags: StdVideoH265SpsFlags,
4773 pub chroma_format_idc: StdVideoH265ChromaFormatIdc,
4774 pub pic_width_in_luma_samples: u32,
4775 pub pic_height_in_luma_samples: u32,
4776 pub sps_video_parameter_set_id: u8,
4777 pub sps_max_sub_layers_minus1: u8,
4778 pub sps_seq_parameter_set_id: u8,
4779 pub bit_depth_luma_minus8: u8,
4780 pub bit_depth_chroma_minus8: u8,
4781 pub log2_max_pic_order_cnt_lsb_minus4: u8,
4782 pub log2_min_luma_coding_block_size_minus3: u8,
4783 pub log2_diff_max_min_luma_coding_block_size: u8,
4784 pub log2_min_luma_transform_block_size_minus2: u8,
4785 pub log2_diff_max_min_luma_transform_block_size: u8,
4786 pub max_transform_hierarchy_depth_inter: u8,
4787 pub max_transform_hierarchy_depth_intra: u8,
4788 pub num_short_term_ref_pic_sets: u8,
4789 pub num_long_term_ref_pics_sps: u8,
4790 pub pcm_sample_bit_depth_luma_minus1: u8,
4791 pub pcm_sample_bit_depth_chroma_minus1: u8,
4792 pub log2_min_pcm_luma_coding_block_size_minus3: u8,
4793 pub log2_diff_max_min_pcm_luma_coding_block_size: u8,
4794 pub reserved1: u8,
4795 pub reserved2: u8,
4796 pub palette_max_size: u8,
4797 pub delta_palette_max_predictor_size: u8,
4798 pub motion_vector_resolution_control_idc: u8,
4799 pub sps_num_palette_predictor_initializers_minus1: u8,
4800 pub conf_win_left_offset: u32,
4801 pub conf_win_right_offset: u32,
4802 pub conf_win_top_offset: u32,
4803 pub conf_win_bottom_offset: u32,
4804 pub pProfileTierLevel: *const StdVideoH265ProfileTierLevel,
4805 pub pDecPicBufMgr: *const StdVideoH265DecPicBufMgr,
4806 pub pScalingLists: *const StdVideoH265ScalingLists,
4807 pub pShortTermRefPicSet: *const StdVideoH265ShortTermRefPicSet,
4808 pub pLongTermRefPicsSps: *const StdVideoH265LongTermRefPicsSps,
4809 pub pSequenceParameterSetVui: *const StdVideoH265SequenceParameterSetVui,
4810 pub pPredictorPaletteEntries: *const StdVideoH265PredictorPaletteEntries,
4811}
4812#[test]
4813fn bindgen_test_layout_StdVideoH265SequenceParameterSet() {
4814 const UNINIT: ::core::mem::MaybeUninit<StdVideoH265SequenceParameterSet> =
4815 ::core::mem::MaybeUninit::uninit();
4816 let ptr = UNINIT.as_ptr();
4817 assert_eq!(
4818 ::core::mem::size_of::<StdVideoH265SequenceParameterSet>(),
4819 112usize,
4820 concat!("Size of: ", stringify!(StdVideoH265SequenceParameterSet))
4821 );
4822 assert_eq!(
4823 ::core::mem::align_of::<StdVideoH265SequenceParameterSet>(),
4824 8usize,
4825 concat!(
4826 "Alignment of ",
4827 stringify!(StdVideoH265SequenceParameterSet)
4828 )
4829 );
4830 assert_eq!(
4831 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
4832 0usize,
4833 concat!(
4834 "Offset of field: ",
4835 stringify!(StdVideoH265SequenceParameterSet),
4836 "::",
4837 stringify!(flags)
4838 )
4839 );
4840 assert_eq!(
4841 unsafe { ::core::ptr::addr_of!((*ptr).chroma_format_idc) as usize - ptr as usize },
4842 4usize,
4843 concat!(
4844 "Offset of field: ",
4845 stringify!(StdVideoH265SequenceParameterSet),
4846 "::",
4847 stringify!(chroma_format_idc)
4848 )
4849 );
4850 assert_eq!(
4851 unsafe { ::core::ptr::addr_of!((*ptr).pic_width_in_luma_samples) as usize - ptr as usize },
4852 8usize,
4853 concat!(
4854 "Offset of field: ",
4855 stringify!(StdVideoH265SequenceParameterSet),
4856 "::",
4857 stringify!(pic_width_in_luma_samples)
4858 )
4859 );
4860 assert_eq!(
4861 unsafe { ::core::ptr::addr_of!((*ptr).pic_height_in_luma_samples) as usize - ptr as usize },
4862 12usize,
4863 concat!(
4864 "Offset of field: ",
4865 stringify!(StdVideoH265SequenceParameterSet),
4866 "::",
4867 stringify!(pic_height_in_luma_samples)
4868 )
4869 );
4870 assert_eq!(
4871 unsafe { ::core::ptr::addr_of!((*ptr).sps_video_parameter_set_id) as usize - ptr as usize },
4872 16usize,
4873 concat!(
4874 "Offset of field: ",
4875 stringify!(StdVideoH265SequenceParameterSet),
4876 "::",
4877 stringify!(sps_video_parameter_set_id)
4878 )
4879 );
4880 assert_eq!(
4881 unsafe { ::core::ptr::addr_of!((*ptr).sps_max_sub_layers_minus1) as usize - ptr as usize },
4882 17usize,
4883 concat!(
4884 "Offset of field: ",
4885 stringify!(StdVideoH265SequenceParameterSet),
4886 "::",
4887 stringify!(sps_max_sub_layers_minus1)
4888 )
4889 );
4890 assert_eq!(
4891 unsafe { ::core::ptr::addr_of!((*ptr).sps_seq_parameter_set_id) as usize - ptr as usize },
4892 18usize,
4893 concat!(
4894 "Offset of field: ",
4895 stringify!(StdVideoH265SequenceParameterSet),
4896 "::",
4897 stringify!(sps_seq_parameter_set_id)
4898 )
4899 );
4900 assert_eq!(
4901 unsafe { ::core::ptr::addr_of!((*ptr).bit_depth_luma_minus8) as usize - ptr as usize },
4902 19usize,
4903 concat!(
4904 "Offset of field: ",
4905 stringify!(StdVideoH265SequenceParameterSet),
4906 "::",
4907 stringify!(bit_depth_luma_minus8)
4908 )
4909 );
4910 assert_eq!(
4911 unsafe { ::core::ptr::addr_of!((*ptr).bit_depth_chroma_minus8) as usize - ptr as usize },
4912 20usize,
4913 concat!(
4914 "Offset of field: ",
4915 stringify!(StdVideoH265SequenceParameterSet),
4916 "::",
4917 stringify!(bit_depth_chroma_minus8)
4918 )
4919 );
4920 assert_eq!(
4921 unsafe {
4922 ::core::ptr::addr_of!((*ptr).log2_max_pic_order_cnt_lsb_minus4) as usize - ptr as usize
4923 },
4924 21usize,
4925 concat!(
4926 "Offset of field: ",
4927 stringify!(StdVideoH265SequenceParameterSet),
4928 "::",
4929 stringify!(log2_max_pic_order_cnt_lsb_minus4)
4930 )
4931 );
4932 assert_eq!(
4933 unsafe {
4934 ::core::ptr::addr_of!((*ptr).log2_min_luma_coding_block_size_minus3) as usize
4935 - ptr as usize
4936 },
4937 22usize,
4938 concat!(
4939 "Offset of field: ",
4940 stringify!(StdVideoH265SequenceParameterSet),
4941 "::",
4942 stringify!(log2_min_luma_coding_block_size_minus3)
4943 )
4944 );
4945 assert_eq!(
4946 unsafe {
4947 ::core::ptr::addr_of!((*ptr).log2_diff_max_min_luma_coding_block_size) as usize
4948 - ptr as usize
4949 },
4950 23usize,
4951 concat!(
4952 "Offset of field: ",
4953 stringify!(StdVideoH265SequenceParameterSet),
4954 "::",
4955 stringify!(log2_diff_max_min_luma_coding_block_size)
4956 )
4957 );
4958 assert_eq!(
4959 unsafe {
4960 ::core::ptr::addr_of!((*ptr).log2_min_luma_transform_block_size_minus2) as usize
4961 - ptr as usize
4962 },
4963 24usize,
4964 concat!(
4965 "Offset of field: ",
4966 stringify!(StdVideoH265SequenceParameterSet),
4967 "::",
4968 stringify!(log2_min_luma_transform_block_size_minus2)
4969 )
4970 );
4971 assert_eq!(
4972 unsafe {
4973 ::core::ptr::addr_of!((*ptr).log2_diff_max_min_luma_transform_block_size) as usize
4974 - ptr as usize
4975 },
4976 25usize,
4977 concat!(
4978 "Offset of field: ",
4979 stringify!(StdVideoH265SequenceParameterSet),
4980 "::",
4981 stringify!(log2_diff_max_min_luma_transform_block_size)
4982 )
4983 );
4984 assert_eq!(
4985 unsafe {
4986 ::core::ptr::addr_of!((*ptr).max_transform_hierarchy_depth_inter) as usize
4987 - ptr as usize
4988 },
4989 26usize,
4990 concat!(
4991 "Offset of field: ",
4992 stringify!(StdVideoH265SequenceParameterSet),
4993 "::",
4994 stringify!(max_transform_hierarchy_depth_inter)
4995 )
4996 );
4997 assert_eq!(
4998 unsafe {
4999 ::core::ptr::addr_of!((*ptr).max_transform_hierarchy_depth_intra) as usize
5000 - ptr as usize
5001 },
5002 27usize,
5003 concat!(
5004 "Offset of field: ",
5005 stringify!(StdVideoH265SequenceParameterSet),
5006 "::",
5007 stringify!(max_transform_hierarchy_depth_intra)
5008 )
5009 );
5010 assert_eq!(
5011 unsafe {
5012 ::core::ptr::addr_of!((*ptr).num_short_term_ref_pic_sets) as usize - ptr as usize
5013 },
5014 28usize,
5015 concat!(
5016 "Offset of field: ",
5017 stringify!(StdVideoH265SequenceParameterSet),
5018 "::",
5019 stringify!(num_short_term_ref_pic_sets)
5020 )
5021 );
5022 assert_eq!(
5023 unsafe { ::core::ptr::addr_of!((*ptr).num_long_term_ref_pics_sps) as usize - ptr as usize },
5024 29usize,
5025 concat!(
5026 "Offset of field: ",
5027 stringify!(StdVideoH265SequenceParameterSet),
5028 "::",
5029 stringify!(num_long_term_ref_pics_sps)
5030 )
5031 );
5032 assert_eq!(
5033 unsafe {
5034 ::core::ptr::addr_of!((*ptr).pcm_sample_bit_depth_luma_minus1) as usize - ptr as usize
5035 },
5036 30usize,
5037 concat!(
5038 "Offset of field: ",
5039 stringify!(StdVideoH265SequenceParameterSet),
5040 "::",
5041 stringify!(pcm_sample_bit_depth_luma_minus1)
5042 )
5043 );
5044 assert_eq!(
5045 unsafe {
5046 ::core::ptr::addr_of!((*ptr).pcm_sample_bit_depth_chroma_minus1) as usize - ptr as usize
5047 },
5048 31usize,
5049 concat!(
5050 "Offset of field: ",
5051 stringify!(StdVideoH265SequenceParameterSet),
5052 "::",
5053 stringify!(pcm_sample_bit_depth_chroma_minus1)
5054 )
5055 );
5056 assert_eq!(
5057 unsafe {
5058 ::core::ptr::addr_of!((*ptr).log2_min_pcm_luma_coding_block_size_minus3) as usize
5059 - ptr as usize
5060 },
5061 32usize,
5062 concat!(
5063 "Offset of field: ",
5064 stringify!(StdVideoH265SequenceParameterSet),
5065 "::",
5066 stringify!(log2_min_pcm_luma_coding_block_size_minus3)
5067 )
5068 );
5069 assert_eq!(
5070 unsafe {
5071 ::core::ptr::addr_of!((*ptr).log2_diff_max_min_pcm_luma_coding_block_size) as usize
5072 - ptr as usize
5073 },
5074 33usize,
5075 concat!(
5076 "Offset of field: ",
5077 stringify!(StdVideoH265SequenceParameterSet),
5078 "::",
5079 stringify!(log2_diff_max_min_pcm_luma_coding_block_size)
5080 )
5081 );
5082 assert_eq!(
5083 unsafe { ::core::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize },
5084 34usize,
5085 concat!(
5086 "Offset of field: ",
5087 stringify!(StdVideoH265SequenceParameterSet),
5088 "::",
5089 stringify!(reserved1)
5090 )
5091 );
5092 assert_eq!(
5093 unsafe { ::core::ptr::addr_of!((*ptr).reserved2) as usize - ptr as usize },
5094 35usize,
5095 concat!(
5096 "Offset of field: ",
5097 stringify!(StdVideoH265SequenceParameterSet),
5098 "::",
5099 stringify!(reserved2)
5100 )
5101 );
5102 assert_eq!(
5103 unsafe { ::core::ptr::addr_of!((*ptr).palette_max_size) as usize - ptr as usize },
5104 36usize,
5105 concat!(
5106 "Offset of field: ",
5107 stringify!(StdVideoH265SequenceParameterSet),
5108 "::",
5109 stringify!(palette_max_size)
5110 )
5111 );
5112 assert_eq!(
5113 unsafe {
5114 ::core::ptr::addr_of!((*ptr).delta_palette_max_predictor_size) as usize - ptr as usize
5115 },
5116 37usize,
5117 concat!(
5118 "Offset of field: ",
5119 stringify!(StdVideoH265SequenceParameterSet),
5120 "::",
5121 stringify!(delta_palette_max_predictor_size)
5122 )
5123 );
5124 assert_eq!(
5125 unsafe {
5126 ::core::ptr::addr_of!((*ptr).motion_vector_resolution_control_idc) as usize
5127 - ptr as usize
5128 },
5129 38usize,
5130 concat!(
5131 "Offset of field: ",
5132 stringify!(StdVideoH265SequenceParameterSet),
5133 "::",
5134 stringify!(motion_vector_resolution_control_idc)
5135 )
5136 );
5137 assert_eq!(
5138 unsafe {
5139 ::core::ptr::addr_of!((*ptr).sps_num_palette_predictor_initializers_minus1) as usize
5140 - ptr as usize
5141 },
5142 39usize,
5143 concat!(
5144 "Offset of field: ",
5145 stringify!(StdVideoH265SequenceParameterSet),
5146 "::",
5147 stringify!(sps_num_palette_predictor_initializers_minus1)
5148 )
5149 );
5150 assert_eq!(
5151 unsafe { ::core::ptr::addr_of!((*ptr).conf_win_left_offset) as usize - ptr as usize },
5152 40usize,
5153 concat!(
5154 "Offset of field: ",
5155 stringify!(StdVideoH265SequenceParameterSet),
5156 "::",
5157 stringify!(conf_win_left_offset)
5158 )
5159 );
5160 assert_eq!(
5161 unsafe { ::core::ptr::addr_of!((*ptr).conf_win_right_offset) as usize - ptr as usize },
5162 44usize,
5163 concat!(
5164 "Offset of field: ",
5165 stringify!(StdVideoH265SequenceParameterSet),
5166 "::",
5167 stringify!(conf_win_right_offset)
5168 )
5169 );
5170 assert_eq!(
5171 unsafe { ::core::ptr::addr_of!((*ptr).conf_win_top_offset) as usize - ptr as usize },
5172 48usize,
5173 concat!(
5174 "Offset of field: ",
5175 stringify!(StdVideoH265SequenceParameterSet),
5176 "::",
5177 stringify!(conf_win_top_offset)
5178 )
5179 );
5180 assert_eq!(
5181 unsafe { ::core::ptr::addr_of!((*ptr).conf_win_bottom_offset) as usize - ptr as usize },
5182 52usize,
5183 concat!(
5184 "Offset of field: ",
5185 stringify!(StdVideoH265SequenceParameterSet),
5186 "::",
5187 stringify!(conf_win_bottom_offset)
5188 )
5189 );
5190 assert_eq!(
5191 unsafe { ::core::ptr::addr_of!((*ptr).pProfileTierLevel) as usize - ptr as usize },
5192 56usize,
5193 concat!(
5194 "Offset of field: ",
5195 stringify!(StdVideoH265SequenceParameterSet),
5196 "::",
5197 stringify!(pProfileTierLevel)
5198 )
5199 );
5200 assert_eq!(
5201 unsafe { ::core::ptr::addr_of!((*ptr).pDecPicBufMgr) as usize - ptr as usize },
5202 64usize,
5203 concat!(
5204 "Offset of field: ",
5205 stringify!(StdVideoH265SequenceParameterSet),
5206 "::",
5207 stringify!(pDecPicBufMgr)
5208 )
5209 );
5210 assert_eq!(
5211 unsafe { ::core::ptr::addr_of!((*ptr).pScalingLists) as usize - ptr as usize },
5212 72usize,
5213 concat!(
5214 "Offset of field: ",
5215 stringify!(StdVideoH265SequenceParameterSet),
5216 "::",
5217 stringify!(pScalingLists)
5218 )
5219 );
5220 assert_eq!(
5221 unsafe { ::core::ptr::addr_of!((*ptr).pShortTermRefPicSet) as usize - ptr as usize },
5222 80usize,
5223 concat!(
5224 "Offset of field: ",
5225 stringify!(StdVideoH265SequenceParameterSet),
5226 "::",
5227 stringify!(pShortTermRefPicSet)
5228 )
5229 );
5230 assert_eq!(
5231 unsafe { ::core::ptr::addr_of!((*ptr).pLongTermRefPicsSps) as usize - ptr as usize },
5232 88usize,
5233 concat!(
5234 "Offset of field: ",
5235 stringify!(StdVideoH265SequenceParameterSet),
5236 "::",
5237 stringify!(pLongTermRefPicsSps)
5238 )
5239 );
5240 assert_eq!(
5241 unsafe { ::core::ptr::addr_of!((*ptr).pSequenceParameterSetVui) as usize - ptr as usize },
5242 96usize,
5243 concat!(
5244 "Offset of field: ",
5245 stringify!(StdVideoH265SequenceParameterSet),
5246 "::",
5247 stringify!(pSequenceParameterSetVui)
5248 )
5249 );
5250 assert_eq!(
5251 unsafe { ::core::ptr::addr_of!((*ptr).pPredictorPaletteEntries) as usize - ptr as usize },
5252 104usize,
5253 concat!(
5254 "Offset of field: ",
5255 stringify!(StdVideoH265SequenceParameterSet),
5256 "::",
5257 stringify!(pPredictorPaletteEntries)
5258 )
5259 );
5260}
5261#[repr(C)]
5262#[repr(align(4))]
5263#[derive(Debug, Copy, Clone)]
5264pub struct StdVideoH265PpsFlags {
5265 pub _bitfield_align_1: [u8; 0],
5266 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
5267}
5268#[test]
5269fn bindgen_test_layout_StdVideoH265PpsFlags() {
5270 assert_eq!(
5271 ::core::mem::size_of::<StdVideoH265PpsFlags>(),
5272 4usize,
5273 concat!("Size of: ", stringify!(StdVideoH265PpsFlags))
5274 );
5275 assert_eq!(
5276 ::core::mem::align_of::<StdVideoH265PpsFlags>(),
5277 4usize,
5278 concat!("Alignment of ", stringify!(StdVideoH265PpsFlags))
5279 );
5280}
5281impl StdVideoH265PpsFlags {
5282 #[inline]
5283 pub fn dependent_slice_segments_enabled_flag(&self) -> u32 {
5284 unsafe { ::core::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
5285 }
5286 #[inline]
5287 pub fn set_dependent_slice_segments_enabled_flag(&mut self, val: u32) {
5288 unsafe {
5289 let val: u32 = ::core::mem::transmute(val);
5290 self._bitfield_1.set(0usize, 1u8, val as u64)
5291 }
5292 }
5293 #[inline]
5294 pub fn output_flag_present_flag(&self) -> u32 {
5295 unsafe { ::core::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
5296 }
5297 #[inline]
5298 pub fn set_output_flag_present_flag(&mut self, val: u32) {
5299 unsafe {
5300 let val: u32 = ::core::mem::transmute(val);
5301 self._bitfield_1.set(1usize, 1u8, val as u64)
5302 }
5303 }
5304 #[inline]
5305 pub fn sign_data_hiding_enabled_flag(&self) -> u32 {
5306 unsafe { ::core::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
5307 }
5308 #[inline]
5309 pub fn set_sign_data_hiding_enabled_flag(&mut self, val: u32) {
5310 unsafe {
5311 let val: u32 = ::core::mem::transmute(val);
5312 self._bitfield_1.set(2usize, 1u8, val as u64)
5313 }
5314 }
5315 #[inline]
5316 pub fn cabac_init_present_flag(&self) -> u32 {
5317 unsafe { ::core::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
5318 }
5319 #[inline]
5320 pub fn set_cabac_init_present_flag(&mut self, val: u32) {
5321 unsafe {
5322 let val: u32 = ::core::mem::transmute(val);
5323 self._bitfield_1.set(3usize, 1u8, val as u64)
5324 }
5325 }
5326 #[inline]
5327 pub fn constrained_intra_pred_flag(&self) -> u32 {
5328 unsafe { ::core::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
5329 }
5330 #[inline]
5331 pub fn set_constrained_intra_pred_flag(&mut self, val: u32) {
5332 unsafe {
5333 let val: u32 = ::core::mem::transmute(val);
5334 self._bitfield_1.set(4usize, 1u8, val as u64)
5335 }
5336 }
5337 #[inline]
5338 pub fn transform_skip_enabled_flag(&self) -> u32 {
5339 unsafe { ::core::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
5340 }
5341 #[inline]
5342 pub fn set_transform_skip_enabled_flag(&mut self, val: u32) {
5343 unsafe {
5344 let val: u32 = ::core::mem::transmute(val);
5345 self._bitfield_1.set(5usize, 1u8, val as u64)
5346 }
5347 }
5348 #[inline]
5349 pub fn cu_qp_delta_enabled_flag(&self) -> u32 {
5350 unsafe { ::core::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) }
5351 }
5352 #[inline]
5353 pub fn set_cu_qp_delta_enabled_flag(&mut self, val: u32) {
5354 unsafe {
5355 let val: u32 = ::core::mem::transmute(val);
5356 self._bitfield_1.set(6usize, 1u8, val as u64)
5357 }
5358 }
5359 #[inline]
5360 pub fn pps_slice_chroma_qp_offsets_present_flag(&self) -> u32 {
5361 unsafe { ::core::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) }
5362 }
5363 #[inline]
5364 pub fn set_pps_slice_chroma_qp_offsets_present_flag(&mut self, val: u32) {
5365 unsafe {
5366 let val: u32 = ::core::mem::transmute(val);
5367 self._bitfield_1.set(7usize, 1u8, val as u64)
5368 }
5369 }
5370 #[inline]
5371 pub fn weighted_pred_flag(&self) -> u32 {
5372 unsafe { ::core::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) }
5373 }
5374 #[inline]
5375 pub fn set_weighted_pred_flag(&mut self, val: u32) {
5376 unsafe {
5377 let val: u32 = ::core::mem::transmute(val);
5378 self._bitfield_1.set(8usize, 1u8, val as u64)
5379 }
5380 }
5381 #[inline]
5382 pub fn weighted_bipred_flag(&self) -> u32 {
5383 unsafe { ::core::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) }
5384 }
5385 #[inline]
5386 pub fn set_weighted_bipred_flag(&mut self, val: u32) {
5387 unsafe {
5388 let val: u32 = ::core::mem::transmute(val);
5389 self._bitfield_1.set(9usize, 1u8, val as u64)
5390 }
5391 }
5392 #[inline]
5393 pub fn transquant_bypass_enabled_flag(&self) -> u32 {
5394 unsafe { ::core::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) }
5395 }
5396 #[inline]
5397 pub fn set_transquant_bypass_enabled_flag(&mut self, val: u32) {
5398 unsafe {
5399 let val: u32 = ::core::mem::transmute(val);
5400 self._bitfield_1.set(10usize, 1u8, val as u64)
5401 }
5402 }
5403 #[inline]
5404 pub fn tiles_enabled_flag(&self) -> u32 {
5405 unsafe { ::core::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) }
5406 }
5407 #[inline]
5408 pub fn set_tiles_enabled_flag(&mut self, val: u32) {
5409 unsafe {
5410 let val: u32 = ::core::mem::transmute(val);
5411 self._bitfield_1.set(11usize, 1u8, val as u64)
5412 }
5413 }
5414 #[inline]
5415 pub fn entropy_coding_sync_enabled_flag(&self) -> u32 {
5416 unsafe { ::core::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u32) }
5417 }
5418 #[inline]
5419 pub fn set_entropy_coding_sync_enabled_flag(&mut self, val: u32) {
5420 unsafe {
5421 let val: u32 = ::core::mem::transmute(val);
5422 self._bitfield_1.set(12usize, 1u8, val as u64)
5423 }
5424 }
5425 #[inline]
5426 pub fn uniform_spacing_flag(&self) -> u32 {
5427 unsafe { ::core::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) }
5428 }
5429 #[inline]
5430 pub fn set_uniform_spacing_flag(&mut self, val: u32) {
5431 unsafe {
5432 let val: u32 = ::core::mem::transmute(val);
5433 self._bitfield_1.set(13usize, 1u8, val as u64)
5434 }
5435 }
5436 #[inline]
5437 pub fn loop_filter_across_tiles_enabled_flag(&self) -> u32 {
5438 unsafe { ::core::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) }
5439 }
5440 #[inline]
5441 pub fn set_loop_filter_across_tiles_enabled_flag(&mut self, val: u32) {
5442 unsafe {
5443 let val: u32 = ::core::mem::transmute(val);
5444 self._bitfield_1.set(14usize, 1u8, val as u64)
5445 }
5446 }
5447 #[inline]
5448 pub fn pps_loop_filter_across_slices_enabled_flag(&self) -> u32 {
5449 unsafe { ::core::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u32) }
5450 }
5451 #[inline]
5452 pub fn set_pps_loop_filter_across_slices_enabled_flag(&mut self, val: u32) {
5453 unsafe {
5454 let val: u32 = ::core::mem::transmute(val);
5455 self._bitfield_1.set(15usize, 1u8, val as u64)
5456 }
5457 }
5458 #[inline]
5459 pub fn deblocking_filter_control_present_flag(&self) -> u32 {
5460 unsafe { ::core::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u32) }
5461 }
5462 #[inline]
5463 pub fn set_deblocking_filter_control_present_flag(&mut self, val: u32) {
5464 unsafe {
5465 let val: u32 = ::core::mem::transmute(val);
5466 self._bitfield_1.set(16usize, 1u8, val as u64)
5467 }
5468 }
5469 #[inline]
5470 pub fn deblocking_filter_override_enabled_flag(&self) -> u32 {
5471 unsafe { ::core::mem::transmute(self._bitfield_1.get(17usize, 1u8) as u32) }
5472 }
5473 #[inline]
5474 pub fn set_deblocking_filter_override_enabled_flag(&mut self, val: u32) {
5475 unsafe {
5476 let val: u32 = ::core::mem::transmute(val);
5477 self._bitfield_1.set(17usize, 1u8, val as u64)
5478 }
5479 }
5480 #[inline]
5481 pub fn pps_deblocking_filter_disabled_flag(&self) -> u32 {
5482 unsafe { ::core::mem::transmute(self._bitfield_1.get(18usize, 1u8) as u32) }
5483 }
5484 #[inline]
5485 pub fn set_pps_deblocking_filter_disabled_flag(&mut self, val: u32) {
5486 unsafe {
5487 let val: u32 = ::core::mem::transmute(val);
5488 self._bitfield_1.set(18usize, 1u8, val as u64)
5489 }
5490 }
5491 #[inline]
5492 pub fn pps_scaling_list_data_present_flag(&self) -> u32 {
5493 unsafe { ::core::mem::transmute(self._bitfield_1.get(19usize, 1u8) as u32) }
5494 }
5495 #[inline]
5496 pub fn set_pps_scaling_list_data_present_flag(&mut self, val: u32) {
5497 unsafe {
5498 let val: u32 = ::core::mem::transmute(val);
5499 self._bitfield_1.set(19usize, 1u8, val as u64)
5500 }
5501 }
5502 #[inline]
5503 pub fn lists_modification_present_flag(&self) -> u32 {
5504 unsafe { ::core::mem::transmute(self._bitfield_1.get(20usize, 1u8) as u32) }
5505 }
5506 #[inline]
5507 pub fn set_lists_modification_present_flag(&mut self, val: u32) {
5508 unsafe {
5509 let val: u32 = ::core::mem::transmute(val);
5510 self._bitfield_1.set(20usize, 1u8, val as u64)
5511 }
5512 }
5513 #[inline]
5514 pub fn slice_segment_header_extension_present_flag(&self) -> u32 {
5515 unsafe { ::core::mem::transmute(self._bitfield_1.get(21usize, 1u8) as u32) }
5516 }
5517 #[inline]
5518 pub fn set_slice_segment_header_extension_present_flag(&mut self, val: u32) {
5519 unsafe {
5520 let val: u32 = ::core::mem::transmute(val);
5521 self._bitfield_1.set(21usize, 1u8, val as u64)
5522 }
5523 }
5524 #[inline]
5525 pub fn pps_extension_present_flag(&self) -> u32 {
5526 unsafe { ::core::mem::transmute(self._bitfield_1.get(22usize, 1u8) as u32) }
5527 }
5528 #[inline]
5529 pub fn set_pps_extension_present_flag(&mut self, val: u32) {
5530 unsafe {
5531 let val: u32 = ::core::mem::transmute(val);
5532 self._bitfield_1.set(22usize, 1u8, val as u64)
5533 }
5534 }
5535 #[inline]
5536 pub fn cross_component_prediction_enabled_flag(&self) -> u32 {
5537 unsafe { ::core::mem::transmute(self._bitfield_1.get(23usize, 1u8) as u32) }
5538 }
5539 #[inline]
5540 pub fn set_cross_component_prediction_enabled_flag(&mut self, val: u32) {
5541 unsafe {
5542 let val: u32 = ::core::mem::transmute(val);
5543 self._bitfield_1.set(23usize, 1u8, val as u64)
5544 }
5545 }
5546 #[inline]
5547 pub fn chroma_qp_offset_list_enabled_flag(&self) -> u32 {
5548 unsafe { ::core::mem::transmute(self._bitfield_1.get(24usize, 1u8) as u32) }
5549 }
5550 #[inline]
5551 pub fn set_chroma_qp_offset_list_enabled_flag(&mut self, val: u32) {
5552 unsafe {
5553 let val: u32 = ::core::mem::transmute(val);
5554 self._bitfield_1.set(24usize, 1u8, val as u64)
5555 }
5556 }
5557 #[inline]
5558 pub fn pps_curr_pic_ref_enabled_flag(&self) -> u32 {
5559 unsafe { ::core::mem::transmute(self._bitfield_1.get(25usize, 1u8) as u32) }
5560 }
5561 #[inline]
5562 pub fn set_pps_curr_pic_ref_enabled_flag(&mut self, val: u32) {
5563 unsafe {
5564 let val: u32 = ::core::mem::transmute(val);
5565 self._bitfield_1.set(25usize, 1u8, val as u64)
5566 }
5567 }
5568 #[inline]
5569 pub fn residual_adaptive_colour_transform_enabled_flag(&self) -> u32 {
5570 unsafe { ::core::mem::transmute(self._bitfield_1.get(26usize, 1u8) as u32) }
5571 }
5572 #[inline]
5573 pub fn set_residual_adaptive_colour_transform_enabled_flag(&mut self, val: u32) {
5574 unsafe {
5575 let val: u32 = ::core::mem::transmute(val);
5576 self._bitfield_1.set(26usize, 1u8, val as u64)
5577 }
5578 }
5579 #[inline]
5580 pub fn pps_slice_act_qp_offsets_present_flag(&self) -> u32 {
5581 unsafe { ::core::mem::transmute(self._bitfield_1.get(27usize, 1u8) as u32) }
5582 }
5583 #[inline]
5584 pub fn set_pps_slice_act_qp_offsets_present_flag(&mut self, val: u32) {
5585 unsafe {
5586 let val: u32 = ::core::mem::transmute(val);
5587 self._bitfield_1.set(27usize, 1u8, val as u64)
5588 }
5589 }
5590 #[inline]
5591 pub fn pps_palette_predictor_initializers_present_flag(&self) -> u32 {
5592 unsafe { ::core::mem::transmute(self._bitfield_1.get(28usize, 1u8) as u32) }
5593 }
5594 #[inline]
5595 pub fn set_pps_palette_predictor_initializers_present_flag(&mut self, val: u32) {
5596 unsafe {
5597 let val: u32 = ::core::mem::transmute(val);
5598 self._bitfield_1.set(28usize, 1u8, val as u64)
5599 }
5600 }
5601 #[inline]
5602 pub fn monochrome_palette_flag(&self) -> u32 {
5603 unsafe { ::core::mem::transmute(self._bitfield_1.get(29usize, 1u8) as u32) }
5604 }
5605 #[inline]
5606 pub fn set_monochrome_palette_flag(&mut self, val: u32) {
5607 unsafe {
5608 let val: u32 = ::core::mem::transmute(val);
5609 self._bitfield_1.set(29usize, 1u8, val as u64)
5610 }
5611 }
5612 #[inline]
5613 pub fn pps_range_extension_flag(&self) -> u32 {
5614 unsafe { ::core::mem::transmute(self._bitfield_1.get(30usize, 1u8) as u32) }
5615 }
5616 #[inline]
5617 pub fn set_pps_range_extension_flag(&mut self, val: u32) {
5618 unsafe {
5619 let val: u32 = ::core::mem::transmute(val);
5620 self._bitfield_1.set(30usize, 1u8, val as u64)
5621 }
5622 }
5623 #[inline]
5624 pub fn new_bitfield_1(
5625 dependent_slice_segments_enabled_flag: u32,
5626 output_flag_present_flag: u32,
5627 sign_data_hiding_enabled_flag: u32,
5628 cabac_init_present_flag: u32,
5629 constrained_intra_pred_flag: u32,
5630 transform_skip_enabled_flag: u32,
5631 cu_qp_delta_enabled_flag: u32,
5632 pps_slice_chroma_qp_offsets_present_flag: u32,
5633 weighted_pred_flag: u32,
5634 weighted_bipred_flag: u32,
5635 transquant_bypass_enabled_flag: u32,
5636 tiles_enabled_flag: u32,
5637 entropy_coding_sync_enabled_flag: u32,
5638 uniform_spacing_flag: u32,
5639 loop_filter_across_tiles_enabled_flag: u32,
5640 pps_loop_filter_across_slices_enabled_flag: u32,
5641 deblocking_filter_control_present_flag: u32,
5642 deblocking_filter_override_enabled_flag: u32,
5643 pps_deblocking_filter_disabled_flag: u32,
5644 pps_scaling_list_data_present_flag: u32,
5645 lists_modification_present_flag: u32,
5646 slice_segment_header_extension_present_flag: u32,
5647 pps_extension_present_flag: u32,
5648 cross_component_prediction_enabled_flag: u32,
5649 chroma_qp_offset_list_enabled_flag: u32,
5650 pps_curr_pic_ref_enabled_flag: u32,
5651 residual_adaptive_colour_transform_enabled_flag: u32,
5652 pps_slice_act_qp_offsets_present_flag: u32,
5653 pps_palette_predictor_initializers_present_flag: u32,
5654 monochrome_palette_flag: u32,
5655 pps_range_extension_flag: u32,
5656 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
5657 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
5658 __bindgen_bitfield_unit.set(0usize, 1u8, {
5659 let dependent_slice_segments_enabled_flag: u32 =
5660 unsafe { ::core::mem::transmute(dependent_slice_segments_enabled_flag) };
5661 dependent_slice_segments_enabled_flag as u64
5662 });
5663 __bindgen_bitfield_unit.set(1usize, 1u8, {
5664 let output_flag_present_flag: u32 =
5665 unsafe { ::core::mem::transmute(output_flag_present_flag) };
5666 output_flag_present_flag as u64
5667 });
5668 __bindgen_bitfield_unit.set(2usize, 1u8, {
5669 let sign_data_hiding_enabled_flag: u32 =
5670 unsafe { ::core::mem::transmute(sign_data_hiding_enabled_flag) };
5671 sign_data_hiding_enabled_flag as u64
5672 });
5673 __bindgen_bitfield_unit.set(3usize, 1u8, {
5674 let cabac_init_present_flag: u32 =
5675 unsafe { ::core::mem::transmute(cabac_init_present_flag) };
5676 cabac_init_present_flag as u64
5677 });
5678 __bindgen_bitfield_unit.set(4usize, 1u8, {
5679 let constrained_intra_pred_flag: u32 =
5680 unsafe { ::core::mem::transmute(constrained_intra_pred_flag) };
5681 constrained_intra_pred_flag as u64
5682 });
5683 __bindgen_bitfield_unit.set(5usize, 1u8, {
5684 let transform_skip_enabled_flag: u32 =
5685 unsafe { ::core::mem::transmute(transform_skip_enabled_flag) };
5686 transform_skip_enabled_flag as u64
5687 });
5688 __bindgen_bitfield_unit.set(6usize, 1u8, {
5689 let cu_qp_delta_enabled_flag: u32 =
5690 unsafe { ::core::mem::transmute(cu_qp_delta_enabled_flag) };
5691 cu_qp_delta_enabled_flag as u64
5692 });
5693 __bindgen_bitfield_unit.set(7usize, 1u8, {
5694 let pps_slice_chroma_qp_offsets_present_flag: u32 =
5695 unsafe { ::core::mem::transmute(pps_slice_chroma_qp_offsets_present_flag) };
5696 pps_slice_chroma_qp_offsets_present_flag as u64
5697 });
5698 __bindgen_bitfield_unit.set(8usize, 1u8, {
5699 let weighted_pred_flag: u32 = unsafe { ::core::mem::transmute(weighted_pred_flag) };
5700 weighted_pred_flag as u64
5701 });
5702 __bindgen_bitfield_unit.set(9usize, 1u8, {
5703 let weighted_bipred_flag: u32 = unsafe { ::core::mem::transmute(weighted_bipred_flag) };
5704 weighted_bipred_flag as u64
5705 });
5706 __bindgen_bitfield_unit.set(10usize, 1u8, {
5707 let transquant_bypass_enabled_flag: u32 =
5708 unsafe { ::core::mem::transmute(transquant_bypass_enabled_flag) };
5709 transquant_bypass_enabled_flag as u64
5710 });
5711 __bindgen_bitfield_unit.set(11usize, 1u8, {
5712 let tiles_enabled_flag: u32 = unsafe { ::core::mem::transmute(tiles_enabled_flag) };
5713 tiles_enabled_flag as u64
5714 });
5715 __bindgen_bitfield_unit.set(12usize, 1u8, {
5716 let entropy_coding_sync_enabled_flag: u32 =
5717 unsafe { ::core::mem::transmute(entropy_coding_sync_enabled_flag) };
5718 entropy_coding_sync_enabled_flag as u64
5719 });
5720 __bindgen_bitfield_unit.set(13usize, 1u8, {
5721 let uniform_spacing_flag: u32 = unsafe { ::core::mem::transmute(uniform_spacing_flag) };
5722 uniform_spacing_flag as u64
5723 });
5724 __bindgen_bitfield_unit.set(14usize, 1u8, {
5725 let loop_filter_across_tiles_enabled_flag: u32 =
5726 unsafe { ::core::mem::transmute(loop_filter_across_tiles_enabled_flag) };
5727 loop_filter_across_tiles_enabled_flag as u64
5728 });
5729 __bindgen_bitfield_unit.set(15usize, 1u8, {
5730 let pps_loop_filter_across_slices_enabled_flag: u32 =
5731 unsafe { ::core::mem::transmute(pps_loop_filter_across_slices_enabled_flag) };
5732 pps_loop_filter_across_slices_enabled_flag as u64
5733 });
5734 __bindgen_bitfield_unit.set(16usize, 1u8, {
5735 let deblocking_filter_control_present_flag: u32 =
5736 unsafe { ::core::mem::transmute(deblocking_filter_control_present_flag) };
5737 deblocking_filter_control_present_flag as u64
5738 });
5739 __bindgen_bitfield_unit.set(17usize, 1u8, {
5740 let deblocking_filter_override_enabled_flag: u32 =
5741 unsafe { ::core::mem::transmute(deblocking_filter_override_enabled_flag) };
5742 deblocking_filter_override_enabled_flag as u64
5743 });
5744 __bindgen_bitfield_unit.set(18usize, 1u8, {
5745 let pps_deblocking_filter_disabled_flag: u32 =
5746 unsafe { ::core::mem::transmute(pps_deblocking_filter_disabled_flag) };
5747 pps_deblocking_filter_disabled_flag as u64
5748 });
5749 __bindgen_bitfield_unit.set(19usize, 1u8, {
5750 let pps_scaling_list_data_present_flag: u32 =
5751 unsafe { ::core::mem::transmute(pps_scaling_list_data_present_flag) };
5752 pps_scaling_list_data_present_flag as u64
5753 });
5754 __bindgen_bitfield_unit.set(20usize, 1u8, {
5755 let lists_modification_present_flag: u32 =
5756 unsafe { ::core::mem::transmute(lists_modification_present_flag) };
5757 lists_modification_present_flag as u64
5758 });
5759 __bindgen_bitfield_unit.set(21usize, 1u8, {
5760 let slice_segment_header_extension_present_flag: u32 =
5761 unsafe { ::core::mem::transmute(slice_segment_header_extension_present_flag) };
5762 slice_segment_header_extension_present_flag as u64
5763 });
5764 __bindgen_bitfield_unit.set(22usize, 1u8, {
5765 let pps_extension_present_flag: u32 =
5766 unsafe { ::core::mem::transmute(pps_extension_present_flag) };
5767 pps_extension_present_flag as u64
5768 });
5769 __bindgen_bitfield_unit.set(23usize, 1u8, {
5770 let cross_component_prediction_enabled_flag: u32 =
5771 unsafe { ::core::mem::transmute(cross_component_prediction_enabled_flag) };
5772 cross_component_prediction_enabled_flag as u64
5773 });
5774 __bindgen_bitfield_unit.set(24usize, 1u8, {
5775 let chroma_qp_offset_list_enabled_flag: u32 =
5776 unsafe { ::core::mem::transmute(chroma_qp_offset_list_enabled_flag) };
5777 chroma_qp_offset_list_enabled_flag as u64
5778 });
5779 __bindgen_bitfield_unit.set(25usize, 1u8, {
5780 let pps_curr_pic_ref_enabled_flag: u32 =
5781 unsafe { ::core::mem::transmute(pps_curr_pic_ref_enabled_flag) };
5782 pps_curr_pic_ref_enabled_flag as u64
5783 });
5784 __bindgen_bitfield_unit.set(26usize, 1u8, {
5785 let residual_adaptive_colour_transform_enabled_flag: u32 =
5786 unsafe { ::core::mem::transmute(residual_adaptive_colour_transform_enabled_flag) };
5787 residual_adaptive_colour_transform_enabled_flag as u64
5788 });
5789 __bindgen_bitfield_unit.set(27usize, 1u8, {
5790 let pps_slice_act_qp_offsets_present_flag: u32 =
5791 unsafe { ::core::mem::transmute(pps_slice_act_qp_offsets_present_flag) };
5792 pps_slice_act_qp_offsets_present_flag as u64
5793 });
5794 __bindgen_bitfield_unit.set(28usize, 1u8, {
5795 let pps_palette_predictor_initializers_present_flag: u32 =
5796 unsafe { ::core::mem::transmute(pps_palette_predictor_initializers_present_flag) };
5797 pps_palette_predictor_initializers_present_flag as u64
5798 });
5799 __bindgen_bitfield_unit.set(29usize, 1u8, {
5800 let monochrome_palette_flag: u32 =
5801 unsafe { ::core::mem::transmute(monochrome_palette_flag) };
5802 monochrome_palette_flag as u64
5803 });
5804 __bindgen_bitfield_unit.set(30usize, 1u8, {
5805 let pps_range_extension_flag: u32 =
5806 unsafe { ::core::mem::transmute(pps_range_extension_flag) };
5807 pps_range_extension_flag as u64
5808 });
5809 __bindgen_bitfield_unit
5810 }
5811}
5812#[repr(C)]
5813#[derive(Debug, Copy, Clone)]
5814pub struct StdVideoH265PictureParameterSet {
5815 pub flags: StdVideoH265PpsFlags,
5816 pub pps_pic_parameter_set_id: u8,
5817 pub pps_seq_parameter_set_id: u8,
5818 pub sps_video_parameter_set_id: u8,
5819 pub num_extra_slice_header_bits: u8,
5820 pub num_ref_idx_l0_default_active_minus1: u8,
5821 pub num_ref_idx_l1_default_active_minus1: u8,
5822 pub init_qp_minus26: i8,
5823 pub diff_cu_qp_delta_depth: u8,
5824 pub pps_cb_qp_offset: i8,
5825 pub pps_cr_qp_offset: i8,
5826 pub pps_beta_offset_div2: i8,
5827 pub pps_tc_offset_div2: i8,
5828 pub log2_parallel_merge_level_minus2: u8,
5829 pub log2_max_transform_skip_block_size_minus2: u8,
5830 pub diff_cu_chroma_qp_offset_depth: u8,
5831 pub chroma_qp_offset_list_len_minus1: u8,
5832 pub cb_qp_offset_list: [i8; 6usize],
5833 pub cr_qp_offset_list: [i8; 6usize],
5834 pub log2_sao_offset_scale_luma: u8,
5835 pub log2_sao_offset_scale_chroma: u8,
5836 pub pps_act_y_qp_offset_plus5: i8,
5837 pub pps_act_cb_qp_offset_plus5: i8,
5838 pub pps_act_cr_qp_offset_plus3: i8,
5839 pub pps_num_palette_predictor_initializers: u8,
5840 pub luma_bit_depth_entry_minus8: u8,
5841 pub chroma_bit_depth_entry_minus8: u8,
5842 pub num_tile_columns_minus1: u8,
5843 pub num_tile_rows_minus1: u8,
5844 pub reserved1: u8,
5845 pub reserved2: u8,
5846 pub column_width_minus1: [u16; 19usize],
5847 pub row_height_minus1: [u16; 21usize],
5848 pub reserved3: u32,
5849 pub pScalingLists: *const StdVideoH265ScalingLists,
5850 pub pPredictorPaletteEntries: *const StdVideoH265PredictorPaletteEntries,
5851}
5852#[test]
5853fn bindgen_test_layout_StdVideoH265PictureParameterSet() {
5854 const UNINIT: ::core::mem::MaybeUninit<StdVideoH265PictureParameterSet> =
5855 ::core::mem::MaybeUninit::uninit();
5856 let ptr = UNINIT.as_ptr();
5857 assert_eq!(
5858 ::core::mem::size_of::<StdVideoH265PictureParameterSet>(),
5859 144usize,
5860 concat!("Size of: ", stringify!(StdVideoH265PictureParameterSet))
5861 );
5862 assert_eq!(
5863 ::core::mem::align_of::<StdVideoH265PictureParameterSet>(),
5864 8usize,
5865 concat!("Alignment of ", stringify!(StdVideoH265PictureParameterSet))
5866 );
5867 assert_eq!(
5868 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
5869 0usize,
5870 concat!(
5871 "Offset of field: ",
5872 stringify!(StdVideoH265PictureParameterSet),
5873 "::",
5874 stringify!(flags)
5875 )
5876 );
5877 assert_eq!(
5878 unsafe { ::core::ptr::addr_of!((*ptr).pps_pic_parameter_set_id) as usize - ptr as usize },
5879 4usize,
5880 concat!(
5881 "Offset of field: ",
5882 stringify!(StdVideoH265PictureParameterSet),
5883 "::",
5884 stringify!(pps_pic_parameter_set_id)
5885 )
5886 );
5887 assert_eq!(
5888 unsafe { ::core::ptr::addr_of!((*ptr).pps_seq_parameter_set_id) as usize - ptr as usize },
5889 5usize,
5890 concat!(
5891 "Offset of field: ",
5892 stringify!(StdVideoH265PictureParameterSet),
5893 "::",
5894 stringify!(pps_seq_parameter_set_id)
5895 )
5896 );
5897 assert_eq!(
5898 unsafe { ::core::ptr::addr_of!((*ptr).sps_video_parameter_set_id) as usize - ptr as usize },
5899 6usize,
5900 concat!(
5901 "Offset of field: ",
5902 stringify!(StdVideoH265PictureParameterSet),
5903 "::",
5904 stringify!(sps_video_parameter_set_id)
5905 )
5906 );
5907 assert_eq!(
5908 unsafe {
5909 ::core::ptr::addr_of!((*ptr).num_extra_slice_header_bits) as usize - ptr as usize
5910 },
5911 7usize,
5912 concat!(
5913 "Offset of field: ",
5914 stringify!(StdVideoH265PictureParameterSet),
5915 "::",
5916 stringify!(num_extra_slice_header_bits)
5917 )
5918 );
5919 assert_eq!(
5920 unsafe {
5921 ::core::ptr::addr_of!((*ptr).num_ref_idx_l0_default_active_minus1) as usize
5922 - ptr as usize
5923 },
5924 8usize,
5925 concat!(
5926 "Offset of field: ",
5927 stringify!(StdVideoH265PictureParameterSet),
5928 "::",
5929 stringify!(num_ref_idx_l0_default_active_minus1)
5930 )
5931 );
5932 assert_eq!(
5933 unsafe {
5934 ::core::ptr::addr_of!((*ptr).num_ref_idx_l1_default_active_minus1) as usize
5935 - ptr as usize
5936 },
5937 9usize,
5938 concat!(
5939 "Offset of field: ",
5940 stringify!(StdVideoH265PictureParameterSet),
5941 "::",
5942 stringify!(num_ref_idx_l1_default_active_minus1)
5943 )
5944 );
5945 assert_eq!(
5946 unsafe { ::core::ptr::addr_of!((*ptr).init_qp_minus26) as usize - ptr as usize },
5947 10usize,
5948 concat!(
5949 "Offset of field: ",
5950 stringify!(StdVideoH265PictureParameterSet),
5951 "::",
5952 stringify!(init_qp_minus26)
5953 )
5954 );
5955 assert_eq!(
5956 unsafe { ::core::ptr::addr_of!((*ptr).diff_cu_qp_delta_depth) as usize - ptr as usize },
5957 11usize,
5958 concat!(
5959 "Offset of field: ",
5960 stringify!(StdVideoH265PictureParameterSet),
5961 "::",
5962 stringify!(diff_cu_qp_delta_depth)
5963 )
5964 );
5965 assert_eq!(
5966 unsafe { ::core::ptr::addr_of!((*ptr).pps_cb_qp_offset) as usize - ptr as usize },
5967 12usize,
5968 concat!(
5969 "Offset of field: ",
5970 stringify!(StdVideoH265PictureParameterSet),
5971 "::",
5972 stringify!(pps_cb_qp_offset)
5973 )
5974 );
5975 assert_eq!(
5976 unsafe { ::core::ptr::addr_of!((*ptr).pps_cr_qp_offset) as usize - ptr as usize },
5977 13usize,
5978 concat!(
5979 "Offset of field: ",
5980 stringify!(StdVideoH265PictureParameterSet),
5981 "::",
5982 stringify!(pps_cr_qp_offset)
5983 )
5984 );
5985 assert_eq!(
5986 unsafe { ::core::ptr::addr_of!((*ptr).pps_beta_offset_div2) as usize - ptr as usize },
5987 14usize,
5988 concat!(
5989 "Offset of field: ",
5990 stringify!(StdVideoH265PictureParameterSet),
5991 "::",
5992 stringify!(pps_beta_offset_div2)
5993 )
5994 );
5995 assert_eq!(
5996 unsafe { ::core::ptr::addr_of!((*ptr).pps_tc_offset_div2) as usize - ptr as usize },
5997 15usize,
5998 concat!(
5999 "Offset of field: ",
6000 stringify!(StdVideoH265PictureParameterSet),
6001 "::",
6002 stringify!(pps_tc_offset_div2)
6003 )
6004 );
6005 assert_eq!(
6006 unsafe {
6007 ::core::ptr::addr_of!((*ptr).log2_parallel_merge_level_minus2) as usize - ptr as usize
6008 },
6009 16usize,
6010 concat!(
6011 "Offset of field: ",
6012 stringify!(StdVideoH265PictureParameterSet),
6013 "::",
6014 stringify!(log2_parallel_merge_level_minus2)
6015 )
6016 );
6017 assert_eq!(
6018 unsafe {
6019 ::core::ptr::addr_of!((*ptr).log2_max_transform_skip_block_size_minus2) as usize
6020 - ptr as usize
6021 },
6022 17usize,
6023 concat!(
6024 "Offset of field: ",
6025 stringify!(StdVideoH265PictureParameterSet),
6026 "::",
6027 stringify!(log2_max_transform_skip_block_size_minus2)
6028 )
6029 );
6030 assert_eq!(
6031 unsafe {
6032 ::core::ptr::addr_of!((*ptr).diff_cu_chroma_qp_offset_depth) as usize - ptr as usize
6033 },
6034 18usize,
6035 concat!(
6036 "Offset of field: ",
6037 stringify!(StdVideoH265PictureParameterSet),
6038 "::",
6039 stringify!(diff_cu_chroma_qp_offset_depth)
6040 )
6041 );
6042 assert_eq!(
6043 unsafe {
6044 ::core::ptr::addr_of!((*ptr).chroma_qp_offset_list_len_minus1) as usize - ptr as usize
6045 },
6046 19usize,
6047 concat!(
6048 "Offset of field: ",
6049 stringify!(StdVideoH265PictureParameterSet),
6050 "::",
6051 stringify!(chroma_qp_offset_list_len_minus1)
6052 )
6053 );
6054 assert_eq!(
6055 unsafe { ::core::ptr::addr_of!((*ptr).cb_qp_offset_list) as usize - ptr as usize },
6056 20usize,
6057 concat!(
6058 "Offset of field: ",
6059 stringify!(StdVideoH265PictureParameterSet),
6060 "::",
6061 stringify!(cb_qp_offset_list)
6062 )
6063 );
6064 assert_eq!(
6065 unsafe { ::core::ptr::addr_of!((*ptr).cr_qp_offset_list) as usize - ptr as usize },
6066 26usize,
6067 concat!(
6068 "Offset of field: ",
6069 stringify!(StdVideoH265PictureParameterSet),
6070 "::",
6071 stringify!(cr_qp_offset_list)
6072 )
6073 );
6074 assert_eq!(
6075 unsafe { ::core::ptr::addr_of!((*ptr).log2_sao_offset_scale_luma) as usize - ptr as usize },
6076 32usize,
6077 concat!(
6078 "Offset of field: ",
6079 stringify!(StdVideoH265PictureParameterSet),
6080 "::",
6081 stringify!(log2_sao_offset_scale_luma)
6082 )
6083 );
6084 assert_eq!(
6085 unsafe {
6086 ::core::ptr::addr_of!((*ptr).log2_sao_offset_scale_chroma) as usize - ptr as usize
6087 },
6088 33usize,
6089 concat!(
6090 "Offset of field: ",
6091 stringify!(StdVideoH265PictureParameterSet),
6092 "::",
6093 stringify!(log2_sao_offset_scale_chroma)
6094 )
6095 );
6096 assert_eq!(
6097 unsafe { ::core::ptr::addr_of!((*ptr).pps_act_y_qp_offset_plus5) as usize - ptr as usize },
6098 34usize,
6099 concat!(
6100 "Offset of field: ",
6101 stringify!(StdVideoH265PictureParameterSet),
6102 "::",
6103 stringify!(pps_act_y_qp_offset_plus5)
6104 )
6105 );
6106 assert_eq!(
6107 unsafe { ::core::ptr::addr_of!((*ptr).pps_act_cb_qp_offset_plus5) as usize - ptr as usize },
6108 35usize,
6109 concat!(
6110 "Offset of field: ",
6111 stringify!(StdVideoH265PictureParameterSet),
6112 "::",
6113 stringify!(pps_act_cb_qp_offset_plus5)
6114 )
6115 );
6116 assert_eq!(
6117 unsafe { ::core::ptr::addr_of!((*ptr).pps_act_cr_qp_offset_plus3) as usize - ptr as usize },
6118 36usize,
6119 concat!(
6120 "Offset of field: ",
6121 stringify!(StdVideoH265PictureParameterSet),
6122 "::",
6123 stringify!(pps_act_cr_qp_offset_plus3)
6124 )
6125 );
6126 assert_eq!(
6127 unsafe {
6128 ::core::ptr::addr_of!((*ptr).pps_num_palette_predictor_initializers) as usize
6129 - ptr as usize
6130 },
6131 37usize,
6132 concat!(
6133 "Offset of field: ",
6134 stringify!(StdVideoH265PictureParameterSet),
6135 "::",
6136 stringify!(pps_num_palette_predictor_initializers)
6137 )
6138 );
6139 assert_eq!(
6140 unsafe {
6141 ::core::ptr::addr_of!((*ptr).luma_bit_depth_entry_minus8) as usize - ptr as usize
6142 },
6143 38usize,
6144 concat!(
6145 "Offset of field: ",
6146 stringify!(StdVideoH265PictureParameterSet),
6147 "::",
6148 stringify!(luma_bit_depth_entry_minus8)
6149 )
6150 );
6151 assert_eq!(
6152 unsafe {
6153 ::core::ptr::addr_of!((*ptr).chroma_bit_depth_entry_minus8) as usize - ptr as usize
6154 },
6155 39usize,
6156 concat!(
6157 "Offset of field: ",
6158 stringify!(StdVideoH265PictureParameterSet),
6159 "::",
6160 stringify!(chroma_bit_depth_entry_minus8)
6161 )
6162 );
6163 assert_eq!(
6164 unsafe { ::core::ptr::addr_of!((*ptr).num_tile_columns_minus1) as usize - ptr as usize },
6165 40usize,
6166 concat!(
6167 "Offset of field: ",
6168 stringify!(StdVideoH265PictureParameterSet),
6169 "::",
6170 stringify!(num_tile_columns_minus1)
6171 )
6172 );
6173 assert_eq!(
6174 unsafe { ::core::ptr::addr_of!((*ptr).num_tile_rows_minus1) as usize - ptr as usize },
6175 41usize,
6176 concat!(
6177 "Offset of field: ",
6178 stringify!(StdVideoH265PictureParameterSet),
6179 "::",
6180 stringify!(num_tile_rows_minus1)
6181 )
6182 );
6183 assert_eq!(
6184 unsafe { ::core::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize },
6185 42usize,
6186 concat!(
6187 "Offset of field: ",
6188 stringify!(StdVideoH265PictureParameterSet),
6189 "::",
6190 stringify!(reserved1)
6191 )
6192 );
6193 assert_eq!(
6194 unsafe { ::core::ptr::addr_of!((*ptr).reserved2) as usize - ptr as usize },
6195 43usize,
6196 concat!(
6197 "Offset of field: ",
6198 stringify!(StdVideoH265PictureParameterSet),
6199 "::",
6200 stringify!(reserved2)
6201 )
6202 );
6203 assert_eq!(
6204 unsafe { ::core::ptr::addr_of!((*ptr).column_width_minus1) as usize - ptr as usize },
6205 44usize,
6206 concat!(
6207 "Offset of field: ",
6208 stringify!(StdVideoH265PictureParameterSet),
6209 "::",
6210 stringify!(column_width_minus1)
6211 )
6212 );
6213 assert_eq!(
6214 unsafe { ::core::ptr::addr_of!((*ptr).row_height_minus1) as usize - ptr as usize },
6215 82usize,
6216 concat!(
6217 "Offset of field: ",
6218 stringify!(StdVideoH265PictureParameterSet),
6219 "::",
6220 stringify!(row_height_minus1)
6221 )
6222 );
6223 assert_eq!(
6224 unsafe { ::core::ptr::addr_of!((*ptr).reserved3) as usize - ptr as usize },
6225 124usize,
6226 concat!(
6227 "Offset of field: ",
6228 stringify!(StdVideoH265PictureParameterSet),
6229 "::",
6230 stringify!(reserved3)
6231 )
6232 );
6233 assert_eq!(
6234 unsafe { ::core::ptr::addr_of!((*ptr).pScalingLists) as usize - ptr as usize },
6235 128usize,
6236 concat!(
6237 "Offset of field: ",
6238 stringify!(StdVideoH265PictureParameterSet),
6239 "::",
6240 stringify!(pScalingLists)
6241 )
6242 );
6243 assert_eq!(
6244 unsafe { ::core::ptr::addr_of!((*ptr).pPredictorPaletteEntries) as usize - ptr as usize },
6245 136usize,
6246 concat!(
6247 "Offset of field: ",
6248 stringify!(StdVideoH265PictureParameterSet),
6249 "::",
6250 stringify!(pPredictorPaletteEntries)
6251 )
6252 );
6253}
6254#[repr(C)]
6255#[repr(align(4))]
6256#[derive(Debug, Copy, Clone)]
6257pub struct StdVideoDecodeH265PictureInfoFlags {
6258 pub _bitfield_align_1: [u8; 0],
6259 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
6260 pub __bindgen_padding_0: [u8; 3usize],
6261}
6262#[test]
6263fn bindgen_test_layout_StdVideoDecodeH265PictureInfoFlags() {
6264 assert_eq!(
6265 ::core::mem::size_of::<StdVideoDecodeH265PictureInfoFlags>(),
6266 4usize,
6267 concat!("Size of: ", stringify!(StdVideoDecodeH265PictureInfoFlags))
6268 );
6269 assert_eq!(
6270 ::core::mem::align_of::<StdVideoDecodeH265PictureInfoFlags>(),
6271 4usize,
6272 concat!(
6273 "Alignment of ",
6274 stringify!(StdVideoDecodeH265PictureInfoFlags)
6275 )
6276 );
6277}
6278impl StdVideoDecodeH265PictureInfoFlags {
6279 #[inline]
6280 pub fn IrapPicFlag(&self) -> u32 {
6281 unsafe { ::core::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
6282 }
6283 #[inline]
6284 pub fn set_IrapPicFlag(&mut self, val: u32) {
6285 unsafe {
6286 let val: u32 = ::core::mem::transmute(val);
6287 self._bitfield_1.set(0usize, 1u8, val as u64)
6288 }
6289 }
6290 #[inline]
6291 pub fn IdrPicFlag(&self) -> u32 {
6292 unsafe { ::core::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
6293 }
6294 #[inline]
6295 pub fn set_IdrPicFlag(&mut self, val: u32) {
6296 unsafe {
6297 let val: u32 = ::core::mem::transmute(val);
6298 self._bitfield_1.set(1usize, 1u8, val as u64)
6299 }
6300 }
6301 #[inline]
6302 pub fn IsReference(&self) -> u32 {
6303 unsafe { ::core::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
6304 }
6305 #[inline]
6306 pub fn set_IsReference(&mut self, val: u32) {
6307 unsafe {
6308 let val: u32 = ::core::mem::transmute(val);
6309 self._bitfield_1.set(2usize, 1u8, val as u64)
6310 }
6311 }
6312 #[inline]
6313 pub fn short_term_ref_pic_set_sps_flag(&self) -> u32 {
6314 unsafe { ::core::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
6315 }
6316 #[inline]
6317 pub fn set_short_term_ref_pic_set_sps_flag(&mut self, val: u32) {
6318 unsafe {
6319 let val: u32 = ::core::mem::transmute(val);
6320 self._bitfield_1.set(3usize, 1u8, val as u64)
6321 }
6322 }
6323 #[inline]
6324 pub fn new_bitfield_1(
6325 IrapPicFlag: u32,
6326 IdrPicFlag: u32,
6327 IsReference: u32,
6328 short_term_ref_pic_set_sps_flag: u32,
6329 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
6330 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
6331 __bindgen_bitfield_unit.set(0usize, 1u8, {
6332 let IrapPicFlag: u32 = unsafe { ::core::mem::transmute(IrapPicFlag) };
6333 IrapPicFlag as u64
6334 });
6335 __bindgen_bitfield_unit.set(1usize, 1u8, {
6336 let IdrPicFlag: u32 = unsafe { ::core::mem::transmute(IdrPicFlag) };
6337 IdrPicFlag as u64
6338 });
6339 __bindgen_bitfield_unit.set(2usize, 1u8, {
6340 let IsReference: u32 = unsafe { ::core::mem::transmute(IsReference) };
6341 IsReference as u64
6342 });
6343 __bindgen_bitfield_unit.set(3usize, 1u8, {
6344 let short_term_ref_pic_set_sps_flag: u32 =
6345 unsafe { ::core::mem::transmute(short_term_ref_pic_set_sps_flag) };
6346 short_term_ref_pic_set_sps_flag as u64
6347 });
6348 __bindgen_bitfield_unit
6349 }
6350}
6351#[repr(C)]
6352#[derive(Debug, Copy, Clone)]
6353pub struct StdVideoDecodeH265PictureInfo {
6354 pub flags: StdVideoDecodeH265PictureInfoFlags,
6355 pub sps_video_parameter_set_id: u8,
6356 pub pps_seq_parameter_set_id: u8,
6357 pub pps_pic_parameter_set_id: u8,
6358 pub NumDeltaPocsOfRefRpsIdx: u8,
6359 pub PicOrderCntVal: i32,
6360 pub NumBitsForSTRefPicSetInSlice: u16,
6361 pub reserved: u16,
6362 pub RefPicSetStCurrBefore: [u8; 8usize],
6363 pub RefPicSetStCurrAfter: [u8; 8usize],
6364 pub RefPicSetLtCurr: [u8; 8usize],
6365}
6366#[test]
6367fn bindgen_test_layout_StdVideoDecodeH265PictureInfo() {
6368 const UNINIT: ::core::mem::MaybeUninit<StdVideoDecodeH265PictureInfo> =
6369 ::core::mem::MaybeUninit::uninit();
6370 let ptr = UNINIT.as_ptr();
6371 assert_eq!(
6372 ::core::mem::size_of::<StdVideoDecodeH265PictureInfo>(),
6373 40usize,
6374 concat!("Size of: ", stringify!(StdVideoDecodeH265PictureInfo))
6375 );
6376 assert_eq!(
6377 ::core::mem::align_of::<StdVideoDecodeH265PictureInfo>(),
6378 4usize,
6379 concat!("Alignment of ", stringify!(StdVideoDecodeH265PictureInfo))
6380 );
6381 assert_eq!(
6382 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
6383 0usize,
6384 concat!(
6385 "Offset of field: ",
6386 stringify!(StdVideoDecodeH265PictureInfo),
6387 "::",
6388 stringify!(flags)
6389 )
6390 );
6391 assert_eq!(
6392 unsafe { ::core::ptr::addr_of!((*ptr).sps_video_parameter_set_id) as usize - ptr as usize },
6393 4usize,
6394 concat!(
6395 "Offset of field: ",
6396 stringify!(StdVideoDecodeH265PictureInfo),
6397 "::",
6398 stringify!(sps_video_parameter_set_id)
6399 )
6400 );
6401 assert_eq!(
6402 unsafe { ::core::ptr::addr_of!((*ptr).pps_seq_parameter_set_id) as usize - ptr as usize },
6403 5usize,
6404 concat!(
6405 "Offset of field: ",
6406 stringify!(StdVideoDecodeH265PictureInfo),
6407 "::",
6408 stringify!(pps_seq_parameter_set_id)
6409 )
6410 );
6411 assert_eq!(
6412 unsafe { ::core::ptr::addr_of!((*ptr).pps_pic_parameter_set_id) as usize - ptr as usize },
6413 6usize,
6414 concat!(
6415 "Offset of field: ",
6416 stringify!(StdVideoDecodeH265PictureInfo),
6417 "::",
6418 stringify!(pps_pic_parameter_set_id)
6419 )
6420 );
6421 assert_eq!(
6422 unsafe { ::core::ptr::addr_of!((*ptr).NumDeltaPocsOfRefRpsIdx) as usize - ptr as usize },
6423 7usize,
6424 concat!(
6425 "Offset of field: ",
6426 stringify!(StdVideoDecodeH265PictureInfo),
6427 "::",
6428 stringify!(NumDeltaPocsOfRefRpsIdx)
6429 )
6430 );
6431 assert_eq!(
6432 unsafe { ::core::ptr::addr_of!((*ptr).PicOrderCntVal) as usize - ptr as usize },
6433 8usize,
6434 concat!(
6435 "Offset of field: ",
6436 stringify!(StdVideoDecodeH265PictureInfo),
6437 "::",
6438 stringify!(PicOrderCntVal)
6439 )
6440 );
6441 assert_eq!(
6442 unsafe {
6443 ::core::ptr::addr_of!((*ptr).NumBitsForSTRefPicSetInSlice) as usize - ptr as usize
6444 },
6445 12usize,
6446 concat!(
6447 "Offset of field: ",
6448 stringify!(StdVideoDecodeH265PictureInfo),
6449 "::",
6450 stringify!(NumBitsForSTRefPicSetInSlice)
6451 )
6452 );
6453 assert_eq!(
6454 unsafe { ::core::ptr::addr_of!((*ptr).reserved) as usize - ptr as usize },
6455 14usize,
6456 concat!(
6457 "Offset of field: ",
6458 stringify!(StdVideoDecodeH265PictureInfo),
6459 "::",
6460 stringify!(reserved)
6461 )
6462 );
6463 assert_eq!(
6464 unsafe { ::core::ptr::addr_of!((*ptr).RefPicSetStCurrBefore) as usize - ptr as usize },
6465 16usize,
6466 concat!(
6467 "Offset of field: ",
6468 stringify!(StdVideoDecodeH265PictureInfo),
6469 "::",
6470 stringify!(RefPicSetStCurrBefore)
6471 )
6472 );
6473 assert_eq!(
6474 unsafe { ::core::ptr::addr_of!((*ptr).RefPicSetStCurrAfter) as usize - ptr as usize },
6475 24usize,
6476 concat!(
6477 "Offset of field: ",
6478 stringify!(StdVideoDecodeH265PictureInfo),
6479 "::",
6480 stringify!(RefPicSetStCurrAfter)
6481 )
6482 );
6483 assert_eq!(
6484 unsafe { ::core::ptr::addr_of!((*ptr).RefPicSetLtCurr) as usize - ptr as usize },
6485 32usize,
6486 concat!(
6487 "Offset of field: ",
6488 stringify!(StdVideoDecodeH265PictureInfo),
6489 "::",
6490 stringify!(RefPicSetLtCurr)
6491 )
6492 );
6493}
6494#[repr(C)]
6495#[repr(align(4))]
6496#[derive(Debug, Copy, Clone)]
6497pub struct StdVideoDecodeH265ReferenceInfoFlags {
6498 pub _bitfield_align_1: [u8; 0],
6499 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
6500 pub __bindgen_padding_0: [u8; 3usize],
6501}
6502#[test]
6503fn bindgen_test_layout_StdVideoDecodeH265ReferenceInfoFlags() {
6504 assert_eq!(
6505 ::core::mem::size_of::<StdVideoDecodeH265ReferenceInfoFlags>(),
6506 4usize,
6507 concat!(
6508 "Size of: ",
6509 stringify!(StdVideoDecodeH265ReferenceInfoFlags)
6510 )
6511 );
6512 assert_eq!(
6513 ::core::mem::align_of::<StdVideoDecodeH265ReferenceInfoFlags>(),
6514 4usize,
6515 concat!(
6516 "Alignment of ",
6517 stringify!(StdVideoDecodeH265ReferenceInfoFlags)
6518 )
6519 );
6520}
6521impl StdVideoDecodeH265ReferenceInfoFlags {
6522 #[inline]
6523 pub fn used_for_long_term_reference(&self) -> u32 {
6524 unsafe { ::core::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
6525 }
6526 #[inline]
6527 pub fn set_used_for_long_term_reference(&mut self, val: u32) {
6528 unsafe {
6529 let val: u32 = ::core::mem::transmute(val);
6530 self._bitfield_1.set(0usize, 1u8, val as u64)
6531 }
6532 }
6533 #[inline]
6534 pub fn unused_for_reference(&self) -> u32 {
6535 unsafe { ::core::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
6536 }
6537 #[inline]
6538 pub fn set_unused_for_reference(&mut self, val: u32) {
6539 unsafe {
6540 let val: u32 = ::core::mem::transmute(val);
6541 self._bitfield_1.set(1usize, 1u8, val as u64)
6542 }
6543 }
6544 #[inline]
6545 pub fn new_bitfield_1(
6546 used_for_long_term_reference: u32,
6547 unused_for_reference: u32,
6548 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
6549 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
6550 __bindgen_bitfield_unit.set(0usize, 1u8, {
6551 let used_for_long_term_reference: u32 =
6552 unsafe { ::core::mem::transmute(used_for_long_term_reference) };
6553 used_for_long_term_reference as u64
6554 });
6555 __bindgen_bitfield_unit.set(1usize, 1u8, {
6556 let unused_for_reference: u32 = unsafe { ::core::mem::transmute(unused_for_reference) };
6557 unused_for_reference as u64
6558 });
6559 __bindgen_bitfield_unit
6560 }
6561}
6562#[repr(C)]
6563#[derive(Debug, Copy, Clone)]
6564pub struct StdVideoDecodeH265ReferenceInfo {
6565 pub flags: StdVideoDecodeH265ReferenceInfoFlags,
6566 pub PicOrderCntVal: i32,
6567}
6568#[test]
6569fn bindgen_test_layout_StdVideoDecodeH265ReferenceInfo() {
6570 const UNINIT: ::core::mem::MaybeUninit<StdVideoDecodeH265ReferenceInfo> =
6571 ::core::mem::MaybeUninit::uninit();
6572 let ptr = UNINIT.as_ptr();
6573 assert_eq!(
6574 ::core::mem::size_of::<StdVideoDecodeH265ReferenceInfo>(),
6575 8usize,
6576 concat!("Size of: ", stringify!(StdVideoDecodeH265ReferenceInfo))
6577 );
6578 assert_eq!(
6579 ::core::mem::align_of::<StdVideoDecodeH265ReferenceInfo>(),
6580 4usize,
6581 concat!("Alignment of ", stringify!(StdVideoDecodeH265ReferenceInfo))
6582 );
6583 assert_eq!(
6584 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
6585 0usize,
6586 concat!(
6587 "Offset of field: ",
6588 stringify!(StdVideoDecodeH265ReferenceInfo),
6589 "::",
6590 stringify!(flags)
6591 )
6592 );
6593 assert_eq!(
6594 unsafe { ::core::ptr::addr_of!((*ptr).PicOrderCntVal) as usize - ptr as usize },
6595 4usize,
6596 concat!(
6597 "Offset of field: ",
6598 stringify!(StdVideoDecodeH265ReferenceInfo),
6599 "::",
6600 stringify!(PicOrderCntVal)
6601 )
6602 );
6603}
6604pub const StdVideoAV1Profile_STD_VIDEO_AV1_PROFILE_MAIN: StdVideoAV1Profile = 0;
6605pub const StdVideoAV1Profile_STD_VIDEO_AV1_PROFILE_HIGH: StdVideoAV1Profile = 1;
6606pub const StdVideoAV1Profile_STD_VIDEO_AV1_PROFILE_PROFESSIONAL: StdVideoAV1Profile = 2;
6607pub const StdVideoAV1Profile_STD_VIDEO_AV1_PROFILE_INVALID: StdVideoAV1Profile = 2147483647;
6608pub type StdVideoAV1Profile = ::core::ffi::c_uint;
6609pub const StdVideoAV1Level_STD_VIDEO_AV1_LEVEL_2_0: StdVideoAV1Level = 0;
6610pub const StdVideoAV1Level_STD_VIDEO_AV1_LEVEL_2_1: StdVideoAV1Level = 1;
6611pub const StdVideoAV1Level_STD_VIDEO_AV1_LEVEL_2_2: StdVideoAV1Level = 2;
6612pub const StdVideoAV1Level_STD_VIDEO_AV1_LEVEL_2_3: StdVideoAV1Level = 3;
6613pub const StdVideoAV1Level_STD_VIDEO_AV1_LEVEL_3_0: StdVideoAV1Level = 4;
6614pub const StdVideoAV1Level_STD_VIDEO_AV1_LEVEL_3_1: StdVideoAV1Level = 5;
6615pub const StdVideoAV1Level_STD_VIDEO_AV1_LEVEL_3_2: StdVideoAV1Level = 6;
6616pub const StdVideoAV1Level_STD_VIDEO_AV1_LEVEL_3_3: StdVideoAV1Level = 7;
6617pub const StdVideoAV1Level_STD_VIDEO_AV1_LEVEL_4_0: StdVideoAV1Level = 8;
6618pub const StdVideoAV1Level_STD_VIDEO_AV1_LEVEL_4_1: StdVideoAV1Level = 9;
6619pub const StdVideoAV1Level_STD_VIDEO_AV1_LEVEL_4_2: StdVideoAV1Level = 10;
6620pub const StdVideoAV1Level_STD_VIDEO_AV1_LEVEL_4_3: StdVideoAV1Level = 11;
6621pub const StdVideoAV1Level_STD_VIDEO_AV1_LEVEL_5_0: StdVideoAV1Level = 12;
6622pub const StdVideoAV1Level_STD_VIDEO_AV1_LEVEL_5_1: StdVideoAV1Level = 13;
6623pub const StdVideoAV1Level_STD_VIDEO_AV1_LEVEL_5_2: StdVideoAV1Level = 14;
6624pub const StdVideoAV1Level_STD_VIDEO_AV1_LEVEL_5_3: StdVideoAV1Level = 15;
6625pub const StdVideoAV1Level_STD_VIDEO_AV1_LEVEL_6_0: StdVideoAV1Level = 16;
6626pub const StdVideoAV1Level_STD_VIDEO_AV1_LEVEL_6_1: StdVideoAV1Level = 17;
6627pub const StdVideoAV1Level_STD_VIDEO_AV1_LEVEL_6_2: StdVideoAV1Level = 18;
6628pub const StdVideoAV1Level_STD_VIDEO_AV1_LEVEL_6_3: StdVideoAV1Level = 19;
6629pub const StdVideoAV1Level_STD_VIDEO_AV1_LEVEL_7_0: StdVideoAV1Level = 20;
6630pub const StdVideoAV1Level_STD_VIDEO_AV1_LEVEL_7_1: StdVideoAV1Level = 21;
6631pub const StdVideoAV1Level_STD_VIDEO_AV1_LEVEL_7_2: StdVideoAV1Level = 22;
6632pub const StdVideoAV1Level_STD_VIDEO_AV1_LEVEL_7_3: StdVideoAV1Level = 23;
6633pub const StdVideoAV1Level_STD_VIDEO_AV1_LEVEL_INVALID: StdVideoAV1Level = 2147483647;
6634pub type StdVideoAV1Level = ::core::ffi::c_uint;
6635pub const StdVideoAV1FrameType_STD_VIDEO_AV1_FRAME_TYPE_KEY: StdVideoAV1FrameType = 0;
6636pub const StdVideoAV1FrameType_STD_VIDEO_AV1_FRAME_TYPE_INTER: StdVideoAV1FrameType = 1;
6637pub const StdVideoAV1FrameType_STD_VIDEO_AV1_FRAME_TYPE_INTRA_ONLY: StdVideoAV1FrameType = 2;
6638pub const StdVideoAV1FrameType_STD_VIDEO_AV1_FRAME_TYPE_SWITCH: StdVideoAV1FrameType = 3;
6639pub const StdVideoAV1FrameType_STD_VIDEO_AV1_FRAME_TYPE_INVALID: StdVideoAV1FrameType = 2147483647;
6640pub type StdVideoAV1FrameType = ::core::ffi::c_uint;
6641pub const StdVideoAV1InterpolationFilter_STD_VIDEO_AV1_INTERPOLATION_FILTER_EIGHTTAP:
6642 StdVideoAV1InterpolationFilter = 0;
6643pub const StdVideoAV1InterpolationFilter_STD_VIDEO_AV1_INTERPOLATION_FILTER_EIGHTTAP_SMOOTH:
6644 StdVideoAV1InterpolationFilter = 1;
6645pub const StdVideoAV1InterpolationFilter_STD_VIDEO_AV1_INTERPOLATION_FILTER_EIGHTTAP_SHARP:
6646 StdVideoAV1InterpolationFilter = 2;
6647pub const StdVideoAV1InterpolationFilter_STD_VIDEO_AV1_INTERPOLATION_FILTER_BILINEAR:
6648 StdVideoAV1InterpolationFilter = 3;
6649pub const StdVideoAV1InterpolationFilter_STD_VIDEO_AV1_INTERPOLATION_FILTER_SWITCHABLE:
6650 StdVideoAV1InterpolationFilter = 4;
6651pub const StdVideoAV1InterpolationFilter_STD_VIDEO_AV1_INTERPOLATION_FILTER_INVALID:
6652 StdVideoAV1InterpolationFilter = 2147483647;
6653pub type StdVideoAV1InterpolationFilter = ::core::ffi::c_uint;
6654pub const StdVideoAV1TxMode_STD_VIDEO_AV1_TX_MODE_ONLY_4X4: StdVideoAV1TxMode = 0;
6655pub const StdVideoAV1TxMode_STD_VIDEO_AV1_TX_MODE_LARGEST: StdVideoAV1TxMode = 1;
6656pub const StdVideoAV1TxMode_STD_VIDEO_AV1_TX_MODE_SELECT: StdVideoAV1TxMode = 2;
6657pub const StdVideoAV1TxMode_STD_VIDEO_AV1_TX_MODE_INVALID: StdVideoAV1TxMode = 2147483647;
6658pub type StdVideoAV1TxMode = ::core::ffi::c_uint;
6659pub const StdVideoAV1FrameRestorationType_STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_NONE:
6660 StdVideoAV1FrameRestorationType = 0;
6661pub const StdVideoAV1FrameRestorationType_STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_WIENER:
6662 StdVideoAV1FrameRestorationType = 1;
6663pub const StdVideoAV1FrameRestorationType_STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_SGRPROJ:
6664 StdVideoAV1FrameRestorationType = 2;
6665pub const StdVideoAV1FrameRestorationType_STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_SWITCHABLE:
6666 StdVideoAV1FrameRestorationType = 3;
6667pub const StdVideoAV1FrameRestorationType_STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_INVALID:
6668 StdVideoAV1FrameRestorationType = 2147483647;
6669pub type StdVideoAV1FrameRestorationType = ::core::ffi::c_uint;
6670pub const StdVideoAV1ColorPrimaries_STD_VIDEO_AV1_COLOR_PRIMARIES_BT_709:
6671 StdVideoAV1ColorPrimaries = 1;
6672pub const StdVideoAV1ColorPrimaries_STD_VIDEO_AV1_COLOR_PRIMARIES_BT_UNSPECIFIED:
6673 StdVideoAV1ColorPrimaries = 2;
6674pub const StdVideoAV1ColorPrimaries_STD_VIDEO_AV1_COLOR_PRIMARIES_BT_470_M:
6675 StdVideoAV1ColorPrimaries = 4;
6676pub const StdVideoAV1ColorPrimaries_STD_VIDEO_AV1_COLOR_PRIMARIES_BT_470_B_G:
6677 StdVideoAV1ColorPrimaries = 5;
6678pub const StdVideoAV1ColorPrimaries_STD_VIDEO_AV1_COLOR_PRIMARIES_BT_601:
6679 StdVideoAV1ColorPrimaries = 6;
6680pub const StdVideoAV1ColorPrimaries_STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_240:
6681 StdVideoAV1ColorPrimaries = 7;
6682pub const StdVideoAV1ColorPrimaries_STD_VIDEO_AV1_COLOR_PRIMARIES_GENERIC_FILM:
6683 StdVideoAV1ColorPrimaries = 8;
6684pub const StdVideoAV1ColorPrimaries_STD_VIDEO_AV1_COLOR_PRIMARIES_BT_2020:
6685 StdVideoAV1ColorPrimaries = 9;
6686pub const StdVideoAV1ColorPrimaries_STD_VIDEO_AV1_COLOR_PRIMARIES_XYZ: StdVideoAV1ColorPrimaries =
6687 10;
6688pub const StdVideoAV1ColorPrimaries_STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_431:
6689 StdVideoAV1ColorPrimaries = 11;
6690pub const StdVideoAV1ColorPrimaries_STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_432:
6691 StdVideoAV1ColorPrimaries = 12;
6692pub const StdVideoAV1ColorPrimaries_STD_VIDEO_AV1_COLOR_PRIMARIES_EBU_3213:
6693 StdVideoAV1ColorPrimaries = 22;
6694pub const StdVideoAV1ColorPrimaries_STD_VIDEO_AV1_COLOR_PRIMARIES_INVALID:
6695 StdVideoAV1ColorPrimaries = 2147483647;
6696pub type StdVideoAV1ColorPrimaries = ::core::ffi::c_uint;
6697pub const StdVideoAV1TransferCharacteristics_STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_RESERVED_0:
6698 StdVideoAV1TransferCharacteristics = 0;
6699pub const StdVideoAV1TransferCharacteristics_STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_709:
6700 StdVideoAV1TransferCharacteristics = 1;
6701pub const StdVideoAV1TransferCharacteristics_STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_UNSPECIFIED:
6702 StdVideoAV1TransferCharacteristics = 2;
6703pub const StdVideoAV1TransferCharacteristics_STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_RESERVED_3:
6704 StdVideoAV1TransferCharacteristics = 3;
6705pub const StdVideoAV1TransferCharacteristics_STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_470_M:
6706 StdVideoAV1TransferCharacteristics = 4;
6707pub const StdVideoAV1TransferCharacteristics_STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_470_B_G:
6708 StdVideoAV1TransferCharacteristics = 5;
6709pub const StdVideoAV1TransferCharacteristics_STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_601:
6710 StdVideoAV1TransferCharacteristics = 6;
6711pub const StdVideoAV1TransferCharacteristics_STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SMPTE_240:
6712 StdVideoAV1TransferCharacteristics = 7;
6713pub const StdVideoAV1TransferCharacteristics_STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_LINEAR:
6714 StdVideoAV1TransferCharacteristics = 8;
6715pub const StdVideoAV1TransferCharacteristics_STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_LOG_100:
6716 StdVideoAV1TransferCharacteristics = 9;
6717pub const StdVideoAV1TransferCharacteristics_STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_LOG_100_SQRT10 : StdVideoAV1TransferCharacteristics = 10 ;
6718pub const StdVideoAV1TransferCharacteristics_STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_IEC_61966:
6719 StdVideoAV1TransferCharacteristics = 11;
6720pub const StdVideoAV1TransferCharacteristics_STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_1361:
6721 StdVideoAV1TransferCharacteristics = 12;
6722pub const StdVideoAV1TransferCharacteristics_STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SRGB:
6723 StdVideoAV1TransferCharacteristics = 13;
6724pub const StdVideoAV1TransferCharacteristics_STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_2020_10_BIT : StdVideoAV1TransferCharacteristics = 14 ;
6725pub const StdVideoAV1TransferCharacteristics_STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_2020_12_BIT : StdVideoAV1TransferCharacteristics = 15 ;
6726pub const StdVideoAV1TransferCharacteristics_STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SMPTE_2084:
6727 StdVideoAV1TransferCharacteristics = 16;
6728pub const StdVideoAV1TransferCharacteristics_STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SMPTE_428:
6729 StdVideoAV1TransferCharacteristics = 17;
6730pub const StdVideoAV1TransferCharacteristics_STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_HLG:
6731 StdVideoAV1TransferCharacteristics = 18;
6732pub const StdVideoAV1TransferCharacteristics_STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_INVALID:
6733 StdVideoAV1TransferCharacteristics = 2147483647;
6734pub type StdVideoAV1TransferCharacteristics = ::core::ffi::c_uint;
6735pub const StdVideoAV1MatrixCoefficients_STD_VIDEO_AV1_MATRIX_COEFFICIENTS_IDENTITY:
6736 StdVideoAV1MatrixCoefficients = 0;
6737pub const StdVideoAV1MatrixCoefficients_STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_709:
6738 StdVideoAV1MatrixCoefficients = 1;
6739pub const StdVideoAV1MatrixCoefficients_STD_VIDEO_AV1_MATRIX_COEFFICIENTS_UNSPECIFIED:
6740 StdVideoAV1MatrixCoefficients = 2;
6741pub const StdVideoAV1MatrixCoefficients_STD_VIDEO_AV1_MATRIX_COEFFICIENTS_RESERVED_3:
6742 StdVideoAV1MatrixCoefficients = 3;
6743pub const StdVideoAV1MatrixCoefficients_STD_VIDEO_AV1_MATRIX_COEFFICIENTS_FCC:
6744 StdVideoAV1MatrixCoefficients = 4;
6745pub const StdVideoAV1MatrixCoefficients_STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_470_B_G:
6746 StdVideoAV1MatrixCoefficients = 5;
6747pub const StdVideoAV1MatrixCoefficients_STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_601:
6748 StdVideoAV1MatrixCoefficients = 6;
6749pub const StdVideoAV1MatrixCoefficients_STD_VIDEO_AV1_MATRIX_COEFFICIENTS_SMPTE_240:
6750 StdVideoAV1MatrixCoefficients = 7;
6751pub const StdVideoAV1MatrixCoefficients_STD_VIDEO_AV1_MATRIX_COEFFICIENTS_SMPTE_YCGCO:
6752 StdVideoAV1MatrixCoefficients = 8;
6753pub const StdVideoAV1MatrixCoefficients_STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_2020_NCL:
6754 StdVideoAV1MatrixCoefficients = 9;
6755pub const StdVideoAV1MatrixCoefficients_STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_2020_CL:
6756 StdVideoAV1MatrixCoefficients = 10;
6757pub const StdVideoAV1MatrixCoefficients_STD_VIDEO_AV1_MATRIX_COEFFICIENTS_SMPTE_2085:
6758 StdVideoAV1MatrixCoefficients = 11;
6759pub const StdVideoAV1MatrixCoefficients_STD_VIDEO_AV1_MATRIX_COEFFICIENTS_CHROMAT_NCL:
6760 StdVideoAV1MatrixCoefficients = 12;
6761pub const StdVideoAV1MatrixCoefficients_STD_VIDEO_AV1_MATRIX_COEFFICIENTS_CHROMAT_CL:
6762 StdVideoAV1MatrixCoefficients = 13;
6763pub const StdVideoAV1MatrixCoefficients_STD_VIDEO_AV1_MATRIX_COEFFICIENTS_ICTCP:
6764 StdVideoAV1MatrixCoefficients = 14;
6765pub const StdVideoAV1MatrixCoefficients_STD_VIDEO_AV1_MATRIX_COEFFICIENTS_INVALID:
6766 StdVideoAV1MatrixCoefficients = 2147483647;
6767pub type StdVideoAV1MatrixCoefficients = ::core::ffi::c_uint;
6768pub const StdVideoAV1ChromaSamplePosition_STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_UNKNOWN:
6769 StdVideoAV1ChromaSamplePosition = 0;
6770pub const StdVideoAV1ChromaSamplePosition_STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_VERTICAL:
6771 StdVideoAV1ChromaSamplePosition = 1;
6772pub const StdVideoAV1ChromaSamplePosition_STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_COLOCATED:
6773 StdVideoAV1ChromaSamplePosition = 2;
6774pub const StdVideoAV1ChromaSamplePosition_STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_RESERVED:
6775 StdVideoAV1ChromaSamplePosition = 3;
6776pub const StdVideoAV1ChromaSamplePosition_STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_INVALID:
6777 StdVideoAV1ChromaSamplePosition = 2147483647;
6778pub type StdVideoAV1ChromaSamplePosition = ::core::ffi::c_uint;
6779#[repr(C)]
6780#[derive(Debug, Copy, Clone)]
6781pub struct StdVideoAV1ColorConfigFlags {
6782 pub _bitfield_align_1: [u32; 0],
6783 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
6784}
6785#[test]
6786fn bindgen_test_layout_StdVideoAV1ColorConfigFlags() {
6787 assert_eq!(
6788 ::core::mem::size_of::<StdVideoAV1ColorConfigFlags>(),
6789 4usize,
6790 concat!("Size of: ", stringify!(StdVideoAV1ColorConfigFlags))
6791 );
6792 assert_eq!(
6793 ::core::mem::align_of::<StdVideoAV1ColorConfigFlags>(),
6794 4usize,
6795 concat!("Alignment of ", stringify!(StdVideoAV1ColorConfigFlags))
6796 );
6797}
6798impl StdVideoAV1ColorConfigFlags {
6799 #[inline]
6800 pub fn mono_chrome(&self) -> u32 {
6801 unsafe { ::core::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
6802 }
6803 #[inline]
6804 pub fn set_mono_chrome(&mut self, val: u32) {
6805 unsafe {
6806 let val: u32 = ::core::mem::transmute(val);
6807 self._bitfield_1.set(0usize, 1u8, val as u64)
6808 }
6809 }
6810 #[inline]
6811 pub fn color_range(&self) -> u32 {
6812 unsafe { ::core::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
6813 }
6814 #[inline]
6815 pub fn set_color_range(&mut self, val: u32) {
6816 unsafe {
6817 let val: u32 = ::core::mem::transmute(val);
6818 self._bitfield_1.set(1usize, 1u8, val as u64)
6819 }
6820 }
6821 #[inline]
6822 pub fn separate_uv_delta_q(&self) -> u32 {
6823 unsafe { ::core::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
6824 }
6825 #[inline]
6826 pub fn set_separate_uv_delta_q(&mut self, val: u32) {
6827 unsafe {
6828 let val: u32 = ::core::mem::transmute(val);
6829 self._bitfield_1.set(2usize, 1u8, val as u64)
6830 }
6831 }
6832 #[inline]
6833 pub fn color_description_present_flag(&self) -> u32 {
6834 unsafe { ::core::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
6835 }
6836 #[inline]
6837 pub fn set_color_description_present_flag(&mut self, val: u32) {
6838 unsafe {
6839 let val: u32 = ::core::mem::transmute(val);
6840 self._bitfield_1.set(3usize, 1u8, val as u64)
6841 }
6842 }
6843 #[inline]
6844 pub fn reserved(&self) -> u32 {
6845 unsafe { ::core::mem::transmute(self._bitfield_1.get(4usize, 28u8) as u32) }
6846 }
6847 #[inline]
6848 pub fn set_reserved(&mut self, val: u32) {
6849 unsafe {
6850 let val: u32 = ::core::mem::transmute(val);
6851 self._bitfield_1.set(4usize, 28u8, val as u64)
6852 }
6853 }
6854 #[inline]
6855 pub fn new_bitfield_1(
6856 mono_chrome: u32,
6857 color_range: u32,
6858 separate_uv_delta_q: u32,
6859 color_description_present_flag: u32,
6860 reserved: u32,
6861 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
6862 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
6863 __bindgen_bitfield_unit.set(0usize, 1u8, {
6864 let mono_chrome: u32 = unsafe { ::core::mem::transmute(mono_chrome) };
6865 mono_chrome as u64
6866 });
6867 __bindgen_bitfield_unit.set(1usize, 1u8, {
6868 let color_range: u32 = unsafe { ::core::mem::transmute(color_range) };
6869 color_range as u64
6870 });
6871 __bindgen_bitfield_unit.set(2usize, 1u8, {
6872 let separate_uv_delta_q: u32 = unsafe { ::core::mem::transmute(separate_uv_delta_q) };
6873 separate_uv_delta_q as u64
6874 });
6875 __bindgen_bitfield_unit.set(3usize, 1u8, {
6876 let color_description_present_flag: u32 =
6877 unsafe { ::core::mem::transmute(color_description_present_flag) };
6878 color_description_present_flag as u64
6879 });
6880 __bindgen_bitfield_unit.set(4usize, 28u8, {
6881 let reserved: u32 = unsafe { ::core::mem::transmute(reserved) };
6882 reserved as u64
6883 });
6884 __bindgen_bitfield_unit
6885 }
6886}
6887#[repr(C)]
6888#[derive(Debug, Copy, Clone)]
6889pub struct StdVideoAV1ColorConfig {
6890 pub flags: StdVideoAV1ColorConfigFlags,
6891 pub BitDepth: u8,
6892 pub subsampling_x: u8,
6893 pub subsampling_y: u8,
6894 pub reserved1: u8,
6895 pub color_primaries: StdVideoAV1ColorPrimaries,
6896 pub transfer_characteristics: StdVideoAV1TransferCharacteristics,
6897 pub matrix_coefficients: StdVideoAV1MatrixCoefficients,
6898 pub chroma_sample_position: StdVideoAV1ChromaSamplePosition,
6899}
6900#[test]
6901fn bindgen_test_layout_StdVideoAV1ColorConfig() {
6902 const UNINIT: ::core::mem::MaybeUninit<StdVideoAV1ColorConfig> =
6903 ::core::mem::MaybeUninit::uninit();
6904 let ptr = UNINIT.as_ptr();
6905 assert_eq!(
6906 ::core::mem::size_of::<StdVideoAV1ColorConfig>(),
6907 24usize,
6908 concat!("Size of: ", stringify!(StdVideoAV1ColorConfig))
6909 );
6910 assert_eq!(
6911 ::core::mem::align_of::<StdVideoAV1ColorConfig>(),
6912 4usize,
6913 concat!("Alignment of ", stringify!(StdVideoAV1ColorConfig))
6914 );
6915 assert_eq!(
6916 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
6917 0usize,
6918 concat!(
6919 "Offset of field: ",
6920 stringify!(StdVideoAV1ColorConfig),
6921 "::",
6922 stringify!(flags)
6923 )
6924 );
6925 assert_eq!(
6926 unsafe { ::core::ptr::addr_of!((*ptr).BitDepth) as usize - ptr as usize },
6927 4usize,
6928 concat!(
6929 "Offset of field: ",
6930 stringify!(StdVideoAV1ColorConfig),
6931 "::",
6932 stringify!(BitDepth)
6933 )
6934 );
6935 assert_eq!(
6936 unsafe { ::core::ptr::addr_of!((*ptr).subsampling_x) as usize - ptr as usize },
6937 5usize,
6938 concat!(
6939 "Offset of field: ",
6940 stringify!(StdVideoAV1ColorConfig),
6941 "::",
6942 stringify!(subsampling_x)
6943 )
6944 );
6945 assert_eq!(
6946 unsafe { ::core::ptr::addr_of!((*ptr).subsampling_y) as usize - ptr as usize },
6947 6usize,
6948 concat!(
6949 "Offset of field: ",
6950 stringify!(StdVideoAV1ColorConfig),
6951 "::",
6952 stringify!(subsampling_y)
6953 )
6954 );
6955 assert_eq!(
6956 unsafe { ::core::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize },
6957 7usize,
6958 concat!(
6959 "Offset of field: ",
6960 stringify!(StdVideoAV1ColorConfig),
6961 "::",
6962 stringify!(reserved1)
6963 )
6964 );
6965 assert_eq!(
6966 unsafe { ::core::ptr::addr_of!((*ptr).color_primaries) as usize - ptr as usize },
6967 8usize,
6968 concat!(
6969 "Offset of field: ",
6970 stringify!(StdVideoAV1ColorConfig),
6971 "::",
6972 stringify!(color_primaries)
6973 )
6974 );
6975 assert_eq!(
6976 unsafe { ::core::ptr::addr_of!((*ptr).transfer_characteristics) as usize - ptr as usize },
6977 12usize,
6978 concat!(
6979 "Offset of field: ",
6980 stringify!(StdVideoAV1ColorConfig),
6981 "::",
6982 stringify!(transfer_characteristics)
6983 )
6984 );
6985 assert_eq!(
6986 unsafe { ::core::ptr::addr_of!((*ptr).matrix_coefficients) as usize - ptr as usize },
6987 16usize,
6988 concat!(
6989 "Offset of field: ",
6990 stringify!(StdVideoAV1ColorConfig),
6991 "::",
6992 stringify!(matrix_coefficients)
6993 )
6994 );
6995 assert_eq!(
6996 unsafe { ::core::ptr::addr_of!((*ptr).chroma_sample_position) as usize - ptr as usize },
6997 20usize,
6998 concat!(
6999 "Offset of field: ",
7000 stringify!(StdVideoAV1ColorConfig),
7001 "::",
7002 stringify!(chroma_sample_position)
7003 )
7004 );
7005}
7006#[repr(C)]
7007#[derive(Debug, Copy, Clone)]
7008pub struct StdVideoAV1TimingInfoFlags {
7009 pub _bitfield_align_1: [u32; 0],
7010 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
7011}
7012#[test]
7013fn bindgen_test_layout_StdVideoAV1TimingInfoFlags() {
7014 assert_eq!(
7015 ::core::mem::size_of::<StdVideoAV1TimingInfoFlags>(),
7016 4usize,
7017 concat!("Size of: ", stringify!(StdVideoAV1TimingInfoFlags))
7018 );
7019 assert_eq!(
7020 ::core::mem::align_of::<StdVideoAV1TimingInfoFlags>(),
7021 4usize,
7022 concat!("Alignment of ", stringify!(StdVideoAV1TimingInfoFlags))
7023 );
7024}
7025impl StdVideoAV1TimingInfoFlags {
7026 #[inline]
7027 pub fn equal_picture_interval(&self) -> u32 {
7028 unsafe { ::core::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
7029 }
7030 #[inline]
7031 pub fn set_equal_picture_interval(&mut self, val: u32) {
7032 unsafe {
7033 let val: u32 = ::core::mem::transmute(val);
7034 self._bitfield_1.set(0usize, 1u8, val as u64)
7035 }
7036 }
7037 #[inline]
7038 pub fn reserved(&self) -> u32 {
7039 unsafe { ::core::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) }
7040 }
7041 #[inline]
7042 pub fn set_reserved(&mut self, val: u32) {
7043 unsafe {
7044 let val: u32 = ::core::mem::transmute(val);
7045 self._bitfield_1.set(1usize, 31u8, val as u64)
7046 }
7047 }
7048 #[inline]
7049 pub fn new_bitfield_1(
7050 equal_picture_interval: u32,
7051 reserved: u32,
7052 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
7053 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
7054 __bindgen_bitfield_unit.set(0usize, 1u8, {
7055 let equal_picture_interval: u32 =
7056 unsafe { ::core::mem::transmute(equal_picture_interval) };
7057 equal_picture_interval as u64
7058 });
7059 __bindgen_bitfield_unit.set(1usize, 31u8, {
7060 let reserved: u32 = unsafe { ::core::mem::transmute(reserved) };
7061 reserved as u64
7062 });
7063 __bindgen_bitfield_unit
7064 }
7065}
7066#[repr(C)]
7067#[derive(Debug, Copy, Clone)]
7068pub struct StdVideoAV1TimingInfo {
7069 pub flags: StdVideoAV1TimingInfoFlags,
7070 pub num_units_in_display_tick: u32,
7071 pub time_scale: u32,
7072 pub num_ticks_per_picture_minus_1: u32,
7073}
7074#[test]
7075fn bindgen_test_layout_StdVideoAV1TimingInfo() {
7076 const UNINIT: ::core::mem::MaybeUninit<StdVideoAV1TimingInfo> =
7077 ::core::mem::MaybeUninit::uninit();
7078 let ptr = UNINIT.as_ptr();
7079 assert_eq!(
7080 ::core::mem::size_of::<StdVideoAV1TimingInfo>(),
7081 16usize,
7082 concat!("Size of: ", stringify!(StdVideoAV1TimingInfo))
7083 );
7084 assert_eq!(
7085 ::core::mem::align_of::<StdVideoAV1TimingInfo>(),
7086 4usize,
7087 concat!("Alignment of ", stringify!(StdVideoAV1TimingInfo))
7088 );
7089 assert_eq!(
7090 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
7091 0usize,
7092 concat!(
7093 "Offset of field: ",
7094 stringify!(StdVideoAV1TimingInfo),
7095 "::",
7096 stringify!(flags)
7097 )
7098 );
7099 assert_eq!(
7100 unsafe { ::core::ptr::addr_of!((*ptr).num_units_in_display_tick) as usize - ptr as usize },
7101 4usize,
7102 concat!(
7103 "Offset of field: ",
7104 stringify!(StdVideoAV1TimingInfo),
7105 "::",
7106 stringify!(num_units_in_display_tick)
7107 )
7108 );
7109 assert_eq!(
7110 unsafe { ::core::ptr::addr_of!((*ptr).time_scale) as usize - ptr as usize },
7111 8usize,
7112 concat!(
7113 "Offset of field: ",
7114 stringify!(StdVideoAV1TimingInfo),
7115 "::",
7116 stringify!(time_scale)
7117 )
7118 );
7119 assert_eq!(
7120 unsafe {
7121 ::core::ptr::addr_of!((*ptr).num_ticks_per_picture_minus_1) as usize - ptr as usize
7122 },
7123 12usize,
7124 concat!(
7125 "Offset of field: ",
7126 stringify!(StdVideoAV1TimingInfo),
7127 "::",
7128 stringify!(num_ticks_per_picture_minus_1)
7129 )
7130 );
7131}
7132#[repr(C)]
7133#[derive(Debug, Copy, Clone)]
7134pub struct StdVideoAV1LoopFilterFlags {
7135 pub _bitfield_align_1: [u32; 0],
7136 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
7137}
7138#[test]
7139fn bindgen_test_layout_StdVideoAV1LoopFilterFlags() {
7140 assert_eq!(
7141 ::core::mem::size_of::<StdVideoAV1LoopFilterFlags>(),
7142 4usize,
7143 concat!("Size of: ", stringify!(StdVideoAV1LoopFilterFlags))
7144 );
7145 assert_eq!(
7146 ::core::mem::align_of::<StdVideoAV1LoopFilterFlags>(),
7147 4usize,
7148 concat!("Alignment of ", stringify!(StdVideoAV1LoopFilterFlags))
7149 );
7150}
7151impl StdVideoAV1LoopFilterFlags {
7152 #[inline]
7153 pub fn loop_filter_delta_enabled(&self) -> u32 {
7154 unsafe { ::core::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
7155 }
7156 #[inline]
7157 pub fn set_loop_filter_delta_enabled(&mut self, val: u32) {
7158 unsafe {
7159 let val: u32 = ::core::mem::transmute(val);
7160 self._bitfield_1.set(0usize, 1u8, val as u64)
7161 }
7162 }
7163 #[inline]
7164 pub fn loop_filter_delta_update(&self) -> u32 {
7165 unsafe { ::core::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
7166 }
7167 #[inline]
7168 pub fn set_loop_filter_delta_update(&mut self, val: u32) {
7169 unsafe {
7170 let val: u32 = ::core::mem::transmute(val);
7171 self._bitfield_1.set(1usize, 1u8, val as u64)
7172 }
7173 }
7174 #[inline]
7175 pub fn reserved(&self) -> u32 {
7176 unsafe { ::core::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) }
7177 }
7178 #[inline]
7179 pub fn set_reserved(&mut self, val: u32) {
7180 unsafe {
7181 let val: u32 = ::core::mem::transmute(val);
7182 self._bitfield_1.set(2usize, 30u8, val as u64)
7183 }
7184 }
7185 #[inline]
7186 pub fn new_bitfield_1(
7187 loop_filter_delta_enabled: u32,
7188 loop_filter_delta_update: u32,
7189 reserved: u32,
7190 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
7191 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
7192 __bindgen_bitfield_unit.set(0usize, 1u8, {
7193 let loop_filter_delta_enabled: u32 =
7194 unsafe { ::core::mem::transmute(loop_filter_delta_enabled) };
7195 loop_filter_delta_enabled as u64
7196 });
7197 __bindgen_bitfield_unit.set(1usize, 1u8, {
7198 let loop_filter_delta_update: u32 =
7199 unsafe { ::core::mem::transmute(loop_filter_delta_update) };
7200 loop_filter_delta_update as u64
7201 });
7202 __bindgen_bitfield_unit.set(2usize, 30u8, {
7203 let reserved: u32 = unsafe { ::core::mem::transmute(reserved) };
7204 reserved as u64
7205 });
7206 __bindgen_bitfield_unit
7207 }
7208}
7209#[repr(C)]
7210#[derive(Debug, Copy, Clone)]
7211pub struct StdVideoAV1LoopFilter {
7212 pub flags: StdVideoAV1LoopFilterFlags,
7213 pub loop_filter_level: [u8; 4usize],
7214 pub loop_filter_sharpness: u8,
7215 pub update_ref_delta: u8,
7216 pub loop_filter_ref_deltas: [i8; 8usize],
7217 pub update_mode_delta: u8,
7218 pub loop_filter_mode_deltas: [i8; 2usize],
7219}
7220#[test]
7221fn bindgen_test_layout_StdVideoAV1LoopFilter() {
7222 const UNINIT: ::core::mem::MaybeUninit<StdVideoAV1LoopFilter> =
7223 ::core::mem::MaybeUninit::uninit();
7224 let ptr = UNINIT.as_ptr();
7225 assert_eq!(
7226 ::core::mem::size_of::<StdVideoAV1LoopFilter>(),
7227 24usize,
7228 concat!("Size of: ", stringify!(StdVideoAV1LoopFilter))
7229 );
7230 assert_eq!(
7231 ::core::mem::align_of::<StdVideoAV1LoopFilter>(),
7232 4usize,
7233 concat!("Alignment of ", stringify!(StdVideoAV1LoopFilter))
7234 );
7235 assert_eq!(
7236 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
7237 0usize,
7238 concat!(
7239 "Offset of field: ",
7240 stringify!(StdVideoAV1LoopFilter),
7241 "::",
7242 stringify!(flags)
7243 )
7244 );
7245 assert_eq!(
7246 unsafe { ::core::ptr::addr_of!((*ptr).loop_filter_level) as usize - ptr as usize },
7247 4usize,
7248 concat!(
7249 "Offset of field: ",
7250 stringify!(StdVideoAV1LoopFilter),
7251 "::",
7252 stringify!(loop_filter_level)
7253 )
7254 );
7255 assert_eq!(
7256 unsafe { ::core::ptr::addr_of!((*ptr).loop_filter_sharpness) as usize - ptr as usize },
7257 8usize,
7258 concat!(
7259 "Offset of field: ",
7260 stringify!(StdVideoAV1LoopFilter),
7261 "::",
7262 stringify!(loop_filter_sharpness)
7263 )
7264 );
7265 assert_eq!(
7266 unsafe { ::core::ptr::addr_of!((*ptr).update_ref_delta) as usize - ptr as usize },
7267 9usize,
7268 concat!(
7269 "Offset of field: ",
7270 stringify!(StdVideoAV1LoopFilter),
7271 "::",
7272 stringify!(update_ref_delta)
7273 )
7274 );
7275 assert_eq!(
7276 unsafe { ::core::ptr::addr_of!((*ptr).loop_filter_ref_deltas) as usize - ptr as usize },
7277 10usize,
7278 concat!(
7279 "Offset of field: ",
7280 stringify!(StdVideoAV1LoopFilter),
7281 "::",
7282 stringify!(loop_filter_ref_deltas)
7283 )
7284 );
7285 assert_eq!(
7286 unsafe { ::core::ptr::addr_of!((*ptr).update_mode_delta) as usize - ptr as usize },
7287 18usize,
7288 concat!(
7289 "Offset of field: ",
7290 stringify!(StdVideoAV1LoopFilter),
7291 "::",
7292 stringify!(update_mode_delta)
7293 )
7294 );
7295 assert_eq!(
7296 unsafe { ::core::ptr::addr_of!((*ptr).loop_filter_mode_deltas) as usize - ptr as usize },
7297 19usize,
7298 concat!(
7299 "Offset of field: ",
7300 stringify!(StdVideoAV1LoopFilter),
7301 "::",
7302 stringify!(loop_filter_mode_deltas)
7303 )
7304 );
7305}
7306#[repr(C)]
7307#[derive(Debug, Copy, Clone)]
7308pub struct StdVideoAV1QuantizationFlags {
7309 pub _bitfield_align_1: [u32; 0],
7310 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
7311}
7312#[test]
7313fn bindgen_test_layout_StdVideoAV1QuantizationFlags() {
7314 assert_eq!(
7315 ::core::mem::size_of::<StdVideoAV1QuantizationFlags>(),
7316 4usize,
7317 concat!("Size of: ", stringify!(StdVideoAV1QuantizationFlags))
7318 );
7319 assert_eq!(
7320 ::core::mem::align_of::<StdVideoAV1QuantizationFlags>(),
7321 4usize,
7322 concat!("Alignment of ", stringify!(StdVideoAV1QuantizationFlags))
7323 );
7324}
7325impl StdVideoAV1QuantizationFlags {
7326 #[inline]
7327 pub fn using_qmatrix(&self) -> u32 {
7328 unsafe { ::core::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
7329 }
7330 #[inline]
7331 pub fn set_using_qmatrix(&mut self, val: u32) {
7332 unsafe {
7333 let val: u32 = ::core::mem::transmute(val);
7334 self._bitfield_1.set(0usize, 1u8, val as u64)
7335 }
7336 }
7337 #[inline]
7338 pub fn diff_uv_delta(&self) -> u32 {
7339 unsafe { ::core::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
7340 }
7341 #[inline]
7342 pub fn set_diff_uv_delta(&mut self, val: u32) {
7343 unsafe {
7344 let val: u32 = ::core::mem::transmute(val);
7345 self._bitfield_1.set(1usize, 1u8, val as u64)
7346 }
7347 }
7348 #[inline]
7349 pub fn reserved(&self) -> u32 {
7350 unsafe { ::core::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) }
7351 }
7352 #[inline]
7353 pub fn set_reserved(&mut self, val: u32) {
7354 unsafe {
7355 let val: u32 = ::core::mem::transmute(val);
7356 self._bitfield_1.set(2usize, 30u8, val as u64)
7357 }
7358 }
7359 #[inline]
7360 pub fn new_bitfield_1(
7361 using_qmatrix: u32,
7362 diff_uv_delta: u32,
7363 reserved: u32,
7364 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
7365 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
7366 __bindgen_bitfield_unit.set(0usize, 1u8, {
7367 let using_qmatrix: u32 = unsafe { ::core::mem::transmute(using_qmatrix) };
7368 using_qmatrix as u64
7369 });
7370 __bindgen_bitfield_unit.set(1usize, 1u8, {
7371 let diff_uv_delta: u32 = unsafe { ::core::mem::transmute(diff_uv_delta) };
7372 diff_uv_delta as u64
7373 });
7374 __bindgen_bitfield_unit.set(2usize, 30u8, {
7375 let reserved: u32 = unsafe { ::core::mem::transmute(reserved) };
7376 reserved as u64
7377 });
7378 __bindgen_bitfield_unit
7379 }
7380}
7381#[repr(C)]
7382#[derive(Debug, Copy, Clone)]
7383pub struct StdVideoAV1Quantization {
7384 pub flags: StdVideoAV1QuantizationFlags,
7385 pub base_q_idx: u8,
7386 pub DeltaQYDc: i8,
7387 pub DeltaQUDc: i8,
7388 pub DeltaQUAc: i8,
7389 pub DeltaQVDc: i8,
7390 pub DeltaQVAc: i8,
7391 pub qm_y: u8,
7392 pub qm_u: u8,
7393 pub qm_v: u8,
7394}
7395#[test]
7396fn bindgen_test_layout_StdVideoAV1Quantization() {
7397 const UNINIT: ::core::mem::MaybeUninit<StdVideoAV1Quantization> =
7398 ::core::mem::MaybeUninit::uninit();
7399 let ptr = UNINIT.as_ptr();
7400 assert_eq!(
7401 ::core::mem::size_of::<StdVideoAV1Quantization>(),
7402 16usize,
7403 concat!("Size of: ", stringify!(StdVideoAV1Quantization))
7404 );
7405 assert_eq!(
7406 ::core::mem::align_of::<StdVideoAV1Quantization>(),
7407 4usize,
7408 concat!("Alignment of ", stringify!(StdVideoAV1Quantization))
7409 );
7410 assert_eq!(
7411 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
7412 0usize,
7413 concat!(
7414 "Offset of field: ",
7415 stringify!(StdVideoAV1Quantization),
7416 "::",
7417 stringify!(flags)
7418 )
7419 );
7420 assert_eq!(
7421 unsafe { ::core::ptr::addr_of!((*ptr).base_q_idx) as usize - ptr as usize },
7422 4usize,
7423 concat!(
7424 "Offset of field: ",
7425 stringify!(StdVideoAV1Quantization),
7426 "::",
7427 stringify!(base_q_idx)
7428 )
7429 );
7430 assert_eq!(
7431 unsafe { ::core::ptr::addr_of!((*ptr).DeltaQYDc) as usize - ptr as usize },
7432 5usize,
7433 concat!(
7434 "Offset of field: ",
7435 stringify!(StdVideoAV1Quantization),
7436 "::",
7437 stringify!(DeltaQYDc)
7438 )
7439 );
7440 assert_eq!(
7441 unsafe { ::core::ptr::addr_of!((*ptr).DeltaQUDc) as usize - ptr as usize },
7442 6usize,
7443 concat!(
7444 "Offset of field: ",
7445 stringify!(StdVideoAV1Quantization),
7446 "::",
7447 stringify!(DeltaQUDc)
7448 )
7449 );
7450 assert_eq!(
7451 unsafe { ::core::ptr::addr_of!((*ptr).DeltaQUAc) as usize - ptr as usize },
7452 7usize,
7453 concat!(
7454 "Offset of field: ",
7455 stringify!(StdVideoAV1Quantization),
7456 "::",
7457 stringify!(DeltaQUAc)
7458 )
7459 );
7460 assert_eq!(
7461 unsafe { ::core::ptr::addr_of!((*ptr).DeltaQVDc) as usize - ptr as usize },
7462 8usize,
7463 concat!(
7464 "Offset of field: ",
7465 stringify!(StdVideoAV1Quantization),
7466 "::",
7467 stringify!(DeltaQVDc)
7468 )
7469 );
7470 assert_eq!(
7471 unsafe { ::core::ptr::addr_of!((*ptr).DeltaQVAc) as usize - ptr as usize },
7472 9usize,
7473 concat!(
7474 "Offset of field: ",
7475 stringify!(StdVideoAV1Quantization),
7476 "::",
7477 stringify!(DeltaQVAc)
7478 )
7479 );
7480 assert_eq!(
7481 unsafe { ::core::ptr::addr_of!((*ptr).qm_y) as usize - ptr as usize },
7482 10usize,
7483 concat!(
7484 "Offset of field: ",
7485 stringify!(StdVideoAV1Quantization),
7486 "::",
7487 stringify!(qm_y)
7488 )
7489 );
7490 assert_eq!(
7491 unsafe { ::core::ptr::addr_of!((*ptr).qm_u) as usize - ptr as usize },
7492 11usize,
7493 concat!(
7494 "Offset of field: ",
7495 stringify!(StdVideoAV1Quantization),
7496 "::",
7497 stringify!(qm_u)
7498 )
7499 );
7500 assert_eq!(
7501 unsafe { ::core::ptr::addr_of!((*ptr).qm_v) as usize - ptr as usize },
7502 12usize,
7503 concat!(
7504 "Offset of field: ",
7505 stringify!(StdVideoAV1Quantization),
7506 "::",
7507 stringify!(qm_v)
7508 )
7509 );
7510}
7511#[repr(C)]
7512#[derive(Debug, Copy, Clone)]
7513pub struct StdVideoAV1Segmentation {
7514 pub FeatureEnabled: [u8; 8usize],
7515 pub FeatureData: [[i16; 8usize]; 8usize],
7516}
7517#[test]
7518fn bindgen_test_layout_StdVideoAV1Segmentation() {
7519 const UNINIT: ::core::mem::MaybeUninit<StdVideoAV1Segmentation> =
7520 ::core::mem::MaybeUninit::uninit();
7521 let ptr = UNINIT.as_ptr();
7522 assert_eq!(
7523 ::core::mem::size_of::<StdVideoAV1Segmentation>(),
7524 136usize,
7525 concat!("Size of: ", stringify!(StdVideoAV1Segmentation))
7526 );
7527 assert_eq!(
7528 ::core::mem::align_of::<StdVideoAV1Segmentation>(),
7529 2usize,
7530 concat!("Alignment of ", stringify!(StdVideoAV1Segmentation))
7531 );
7532 assert_eq!(
7533 unsafe { ::core::ptr::addr_of!((*ptr).FeatureEnabled) as usize - ptr as usize },
7534 0usize,
7535 concat!(
7536 "Offset of field: ",
7537 stringify!(StdVideoAV1Segmentation),
7538 "::",
7539 stringify!(FeatureEnabled)
7540 )
7541 );
7542 assert_eq!(
7543 unsafe { ::core::ptr::addr_of!((*ptr).FeatureData) as usize - ptr as usize },
7544 8usize,
7545 concat!(
7546 "Offset of field: ",
7547 stringify!(StdVideoAV1Segmentation),
7548 "::",
7549 stringify!(FeatureData)
7550 )
7551 );
7552}
7553#[repr(C)]
7554#[derive(Debug, Copy, Clone)]
7555pub struct StdVideoAV1TileInfoFlags {
7556 pub _bitfield_align_1: [u32; 0],
7557 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
7558}
7559#[test]
7560fn bindgen_test_layout_StdVideoAV1TileInfoFlags() {
7561 assert_eq!(
7562 ::core::mem::size_of::<StdVideoAV1TileInfoFlags>(),
7563 4usize,
7564 concat!("Size of: ", stringify!(StdVideoAV1TileInfoFlags))
7565 );
7566 assert_eq!(
7567 ::core::mem::align_of::<StdVideoAV1TileInfoFlags>(),
7568 4usize,
7569 concat!("Alignment of ", stringify!(StdVideoAV1TileInfoFlags))
7570 );
7571}
7572impl StdVideoAV1TileInfoFlags {
7573 #[inline]
7574 pub fn uniform_tile_spacing_flag(&self) -> u32 {
7575 unsafe { ::core::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
7576 }
7577 #[inline]
7578 pub fn set_uniform_tile_spacing_flag(&mut self, val: u32) {
7579 unsafe {
7580 let val: u32 = ::core::mem::transmute(val);
7581 self._bitfield_1.set(0usize, 1u8, val as u64)
7582 }
7583 }
7584 #[inline]
7585 pub fn reserved(&self) -> u32 {
7586 unsafe { ::core::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) }
7587 }
7588 #[inline]
7589 pub fn set_reserved(&mut self, val: u32) {
7590 unsafe {
7591 let val: u32 = ::core::mem::transmute(val);
7592 self._bitfield_1.set(1usize, 31u8, val as u64)
7593 }
7594 }
7595 #[inline]
7596 pub fn new_bitfield_1(
7597 uniform_tile_spacing_flag: u32,
7598 reserved: u32,
7599 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
7600 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
7601 __bindgen_bitfield_unit.set(0usize, 1u8, {
7602 let uniform_tile_spacing_flag: u32 =
7603 unsafe { ::core::mem::transmute(uniform_tile_spacing_flag) };
7604 uniform_tile_spacing_flag as u64
7605 });
7606 __bindgen_bitfield_unit.set(1usize, 31u8, {
7607 let reserved: u32 = unsafe { ::core::mem::transmute(reserved) };
7608 reserved as u64
7609 });
7610 __bindgen_bitfield_unit
7611 }
7612}
7613#[repr(C)]
7614#[derive(Debug, Copy, Clone)]
7615pub struct StdVideoAV1TileInfo {
7616 pub flags: StdVideoAV1TileInfoFlags,
7617 pub TileCols: u8,
7618 pub TileRows: u8,
7619 pub context_update_tile_id: u16,
7620 pub tile_size_bytes_minus_1: u8,
7621 pub reserved1: [u8; 7usize],
7622 pub pMiColStarts: *const u16,
7623 pub pMiRowStarts: *const u16,
7624 pub pWidthInSbsMinus1: *const u16,
7625 pub pHeightInSbsMinus1: *const u16,
7626}
7627#[test]
7628fn bindgen_test_layout_StdVideoAV1TileInfo() {
7629 const UNINIT: ::core::mem::MaybeUninit<StdVideoAV1TileInfo> =
7630 ::core::mem::MaybeUninit::uninit();
7631 let ptr = UNINIT.as_ptr();
7632 assert_eq!(
7633 ::core::mem::size_of::<StdVideoAV1TileInfo>(),
7634 48usize,
7635 concat!("Size of: ", stringify!(StdVideoAV1TileInfo))
7636 );
7637 assert_eq!(
7638 ::core::mem::align_of::<StdVideoAV1TileInfo>(),
7639 8usize,
7640 concat!("Alignment of ", stringify!(StdVideoAV1TileInfo))
7641 );
7642 assert_eq!(
7643 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
7644 0usize,
7645 concat!(
7646 "Offset of field: ",
7647 stringify!(StdVideoAV1TileInfo),
7648 "::",
7649 stringify!(flags)
7650 )
7651 );
7652 assert_eq!(
7653 unsafe { ::core::ptr::addr_of!((*ptr).TileCols) as usize - ptr as usize },
7654 4usize,
7655 concat!(
7656 "Offset of field: ",
7657 stringify!(StdVideoAV1TileInfo),
7658 "::",
7659 stringify!(TileCols)
7660 )
7661 );
7662 assert_eq!(
7663 unsafe { ::core::ptr::addr_of!((*ptr).TileRows) as usize - ptr as usize },
7664 5usize,
7665 concat!(
7666 "Offset of field: ",
7667 stringify!(StdVideoAV1TileInfo),
7668 "::",
7669 stringify!(TileRows)
7670 )
7671 );
7672 assert_eq!(
7673 unsafe { ::core::ptr::addr_of!((*ptr).context_update_tile_id) as usize - ptr as usize },
7674 6usize,
7675 concat!(
7676 "Offset of field: ",
7677 stringify!(StdVideoAV1TileInfo),
7678 "::",
7679 stringify!(context_update_tile_id)
7680 )
7681 );
7682 assert_eq!(
7683 unsafe { ::core::ptr::addr_of!((*ptr).tile_size_bytes_minus_1) as usize - ptr as usize },
7684 8usize,
7685 concat!(
7686 "Offset of field: ",
7687 stringify!(StdVideoAV1TileInfo),
7688 "::",
7689 stringify!(tile_size_bytes_minus_1)
7690 )
7691 );
7692 assert_eq!(
7693 unsafe { ::core::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize },
7694 9usize,
7695 concat!(
7696 "Offset of field: ",
7697 stringify!(StdVideoAV1TileInfo),
7698 "::",
7699 stringify!(reserved1)
7700 )
7701 );
7702 assert_eq!(
7703 unsafe { ::core::ptr::addr_of!((*ptr).pMiColStarts) as usize - ptr as usize },
7704 16usize,
7705 concat!(
7706 "Offset of field: ",
7707 stringify!(StdVideoAV1TileInfo),
7708 "::",
7709 stringify!(pMiColStarts)
7710 )
7711 );
7712 assert_eq!(
7713 unsafe { ::core::ptr::addr_of!((*ptr).pMiRowStarts) as usize - ptr as usize },
7714 24usize,
7715 concat!(
7716 "Offset of field: ",
7717 stringify!(StdVideoAV1TileInfo),
7718 "::",
7719 stringify!(pMiRowStarts)
7720 )
7721 );
7722 assert_eq!(
7723 unsafe { ::core::ptr::addr_of!((*ptr).pWidthInSbsMinus1) as usize - ptr as usize },
7724 32usize,
7725 concat!(
7726 "Offset of field: ",
7727 stringify!(StdVideoAV1TileInfo),
7728 "::",
7729 stringify!(pWidthInSbsMinus1)
7730 )
7731 );
7732 assert_eq!(
7733 unsafe { ::core::ptr::addr_of!((*ptr).pHeightInSbsMinus1) as usize - ptr as usize },
7734 40usize,
7735 concat!(
7736 "Offset of field: ",
7737 stringify!(StdVideoAV1TileInfo),
7738 "::",
7739 stringify!(pHeightInSbsMinus1)
7740 )
7741 );
7742}
7743#[repr(C)]
7744#[derive(Debug, Copy, Clone)]
7745pub struct StdVideoAV1CDEF {
7746 pub cdef_damping_minus_3: u8,
7747 pub cdef_bits: u8,
7748 pub cdef_y_pri_strength: [u8; 8usize],
7749 pub cdef_y_sec_strength: [u8; 8usize],
7750 pub cdef_uv_pri_strength: [u8; 8usize],
7751 pub cdef_uv_sec_strength: [u8; 8usize],
7752}
7753#[test]
7754fn bindgen_test_layout_StdVideoAV1CDEF() {
7755 const UNINIT: ::core::mem::MaybeUninit<StdVideoAV1CDEF> = ::core::mem::MaybeUninit::uninit();
7756 let ptr = UNINIT.as_ptr();
7757 assert_eq!(
7758 ::core::mem::size_of::<StdVideoAV1CDEF>(),
7759 34usize,
7760 concat!("Size of: ", stringify!(StdVideoAV1CDEF))
7761 );
7762 assert_eq!(
7763 ::core::mem::align_of::<StdVideoAV1CDEF>(),
7764 1usize,
7765 concat!("Alignment of ", stringify!(StdVideoAV1CDEF))
7766 );
7767 assert_eq!(
7768 unsafe { ::core::ptr::addr_of!((*ptr).cdef_damping_minus_3) as usize - ptr as usize },
7769 0usize,
7770 concat!(
7771 "Offset of field: ",
7772 stringify!(StdVideoAV1CDEF),
7773 "::",
7774 stringify!(cdef_damping_minus_3)
7775 )
7776 );
7777 assert_eq!(
7778 unsafe { ::core::ptr::addr_of!((*ptr).cdef_bits) as usize - ptr as usize },
7779 1usize,
7780 concat!(
7781 "Offset of field: ",
7782 stringify!(StdVideoAV1CDEF),
7783 "::",
7784 stringify!(cdef_bits)
7785 )
7786 );
7787 assert_eq!(
7788 unsafe { ::core::ptr::addr_of!((*ptr).cdef_y_pri_strength) as usize - ptr as usize },
7789 2usize,
7790 concat!(
7791 "Offset of field: ",
7792 stringify!(StdVideoAV1CDEF),
7793 "::",
7794 stringify!(cdef_y_pri_strength)
7795 )
7796 );
7797 assert_eq!(
7798 unsafe { ::core::ptr::addr_of!((*ptr).cdef_y_sec_strength) as usize - ptr as usize },
7799 10usize,
7800 concat!(
7801 "Offset of field: ",
7802 stringify!(StdVideoAV1CDEF),
7803 "::",
7804 stringify!(cdef_y_sec_strength)
7805 )
7806 );
7807 assert_eq!(
7808 unsafe { ::core::ptr::addr_of!((*ptr).cdef_uv_pri_strength) as usize - ptr as usize },
7809 18usize,
7810 concat!(
7811 "Offset of field: ",
7812 stringify!(StdVideoAV1CDEF),
7813 "::",
7814 stringify!(cdef_uv_pri_strength)
7815 )
7816 );
7817 assert_eq!(
7818 unsafe { ::core::ptr::addr_of!((*ptr).cdef_uv_sec_strength) as usize - ptr as usize },
7819 26usize,
7820 concat!(
7821 "Offset of field: ",
7822 stringify!(StdVideoAV1CDEF),
7823 "::",
7824 stringify!(cdef_uv_sec_strength)
7825 )
7826 );
7827}
7828#[repr(C)]
7829#[derive(Debug, Copy, Clone)]
7830pub struct StdVideoAV1LoopRestoration {
7831 pub FrameRestorationType: [StdVideoAV1FrameRestorationType; 3usize],
7832 pub LoopRestorationSize: [u16; 3usize],
7833}
7834#[test]
7835fn bindgen_test_layout_StdVideoAV1LoopRestoration() {
7836 const UNINIT: ::core::mem::MaybeUninit<StdVideoAV1LoopRestoration> =
7837 ::core::mem::MaybeUninit::uninit();
7838 let ptr = UNINIT.as_ptr();
7839 assert_eq!(
7840 ::core::mem::size_of::<StdVideoAV1LoopRestoration>(),
7841 20usize,
7842 concat!("Size of: ", stringify!(StdVideoAV1LoopRestoration))
7843 );
7844 assert_eq!(
7845 ::core::mem::align_of::<StdVideoAV1LoopRestoration>(),
7846 4usize,
7847 concat!("Alignment of ", stringify!(StdVideoAV1LoopRestoration))
7848 );
7849 assert_eq!(
7850 unsafe { ::core::ptr::addr_of!((*ptr).FrameRestorationType) as usize - ptr as usize },
7851 0usize,
7852 concat!(
7853 "Offset of field: ",
7854 stringify!(StdVideoAV1LoopRestoration),
7855 "::",
7856 stringify!(FrameRestorationType)
7857 )
7858 );
7859 assert_eq!(
7860 unsafe { ::core::ptr::addr_of!((*ptr).LoopRestorationSize) as usize - ptr as usize },
7861 12usize,
7862 concat!(
7863 "Offset of field: ",
7864 stringify!(StdVideoAV1LoopRestoration),
7865 "::",
7866 stringify!(LoopRestorationSize)
7867 )
7868 );
7869}
7870#[repr(C)]
7871#[derive(Debug, Copy, Clone)]
7872pub struct StdVideoAV1GlobalMotion {
7873 pub GmType: [u8; 8usize],
7874 pub gm_params: [[i32; 6usize]; 8usize],
7875}
7876#[test]
7877fn bindgen_test_layout_StdVideoAV1GlobalMotion() {
7878 const UNINIT: ::core::mem::MaybeUninit<StdVideoAV1GlobalMotion> =
7879 ::core::mem::MaybeUninit::uninit();
7880 let ptr = UNINIT.as_ptr();
7881 assert_eq!(
7882 ::core::mem::size_of::<StdVideoAV1GlobalMotion>(),
7883 200usize,
7884 concat!("Size of: ", stringify!(StdVideoAV1GlobalMotion))
7885 );
7886 assert_eq!(
7887 ::core::mem::align_of::<StdVideoAV1GlobalMotion>(),
7888 4usize,
7889 concat!("Alignment of ", stringify!(StdVideoAV1GlobalMotion))
7890 );
7891 assert_eq!(
7892 unsafe { ::core::ptr::addr_of!((*ptr).GmType) as usize - ptr as usize },
7893 0usize,
7894 concat!(
7895 "Offset of field: ",
7896 stringify!(StdVideoAV1GlobalMotion),
7897 "::",
7898 stringify!(GmType)
7899 )
7900 );
7901 assert_eq!(
7902 unsafe { ::core::ptr::addr_of!((*ptr).gm_params) as usize - ptr as usize },
7903 8usize,
7904 concat!(
7905 "Offset of field: ",
7906 stringify!(StdVideoAV1GlobalMotion),
7907 "::",
7908 stringify!(gm_params)
7909 )
7910 );
7911}
7912#[repr(C)]
7913#[derive(Debug, Copy, Clone)]
7914pub struct StdVideoAV1FilmGrainFlags {
7915 pub _bitfield_align_1: [u32; 0],
7916 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
7917}
7918#[test]
7919fn bindgen_test_layout_StdVideoAV1FilmGrainFlags() {
7920 assert_eq!(
7921 ::core::mem::size_of::<StdVideoAV1FilmGrainFlags>(),
7922 4usize,
7923 concat!("Size of: ", stringify!(StdVideoAV1FilmGrainFlags))
7924 );
7925 assert_eq!(
7926 ::core::mem::align_of::<StdVideoAV1FilmGrainFlags>(),
7927 4usize,
7928 concat!("Alignment of ", stringify!(StdVideoAV1FilmGrainFlags))
7929 );
7930}
7931impl StdVideoAV1FilmGrainFlags {
7932 #[inline]
7933 pub fn chroma_scaling_from_luma(&self) -> u32 {
7934 unsafe { ::core::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
7935 }
7936 #[inline]
7937 pub fn set_chroma_scaling_from_luma(&mut self, val: u32) {
7938 unsafe {
7939 let val: u32 = ::core::mem::transmute(val);
7940 self._bitfield_1.set(0usize, 1u8, val as u64)
7941 }
7942 }
7943 #[inline]
7944 pub fn overlap_flag(&self) -> u32 {
7945 unsafe { ::core::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
7946 }
7947 #[inline]
7948 pub fn set_overlap_flag(&mut self, val: u32) {
7949 unsafe {
7950 let val: u32 = ::core::mem::transmute(val);
7951 self._bitfield_1.set(1usize, 1u8, val as u64)
7952 }
7953 }
7954 #[inline]
7955 pub fn clip_to_restricted_range(&self) -> u32 {
7956 unsafe { ::core::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
7957 }
7958 #[inline]
7959 pub fn set_clip_to_restricted_range(&mut self, val: u32) {
7960 unsafe {
7961 let val: u32 = ::core::mem::transmute(val);
7962 self._bitfield_1.set(2usize, 1u8, val as u64)
7963 }
7964 }
7965 #[inline]
7966 pub fn update_grain(&self) -> u32 {
7967 unsafe { ::core::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
7968 }
7969 #[inline]
7970 pub fn set_update_grain(&mut self, val: u32) {
7971 unsafe {
7972 let val: u32 = ::core::mem::transmute(val);
7973 self._bitfield_1.set(3usize, 1u8, val as u64)
7974 }
7975 }
7976 #[inline]
7977 pub fn reserved(&self) -> u32 {
7978 unsafe { ::core::mem::transmute(self._bitfield_1.get(4usize, 28u8) as u32) }
7979 }
7980 #[inline]
7981 pub fn set_reserved(&mut self, val: u32) {
7982 unsafe {
7983 let val: u32 = ::core::mem::transmute(val);
7984 self._bitfield_1.set(4usize, 28u8, val as u64)
7985 }
7986 }
7987 #[inline]
7988 pub fn new_bitfield_1(
7989 chroma_scaling_from_luma: u32,
7990 overlap_flag: u32,
7991 clip_to_restricted_range: u32,
7992 update_grain: u32,
7993 reserved: u32,
7994 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
7995 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
7996 __bindgen_bitfield_unit.set(0usize, 1u8, {
7997 let chroma_scaling_from_luma: u32 =
7998 unsafe { ::core::mem::transmute(chroma_scaling_from_luma) };
7999 chroma_scaling_from_luma as u64
8000 });
8001 __bindgen_bitfield_unit.set(1usize, 1u8, {
8002 let overlap_flag: u32 = unsafe { ::core::mem::transmute(overlap_flag) };
8003 overlap_flag as u64
8004 });
8005 __bindgen_bitfield_unit.set(2usize, 1u8, {
8006 let clip_to_restricted_range: u32 =
8007 unsafe { ::core::mem::transmute(clip_to_restricted_range) };
8008 clip_to_restricted_range as u64
8009 });
8010 __bindgen_bitfield_unit.set(3usize, 1u8, {
8011 let update_grain: u32 = unsafe { ::core::mem::transmute(update_grain) };
8012 update_grain as u64
8013 });
8014 __bindgen_bitfield_unit.set(4usize, 28u8, {
8015 let reserved: u32 = unsafe { ::core::mem::transmute(reserved) };
8016 reserved as u64
8017 });
8018 __bindgen_bitfield_unit
8019 }
8020}
8021#[repr(C)]
8022#[derive(Debug, Copy, Clone)]
8023pub struct StdVideoAV1FilmGrain {
8024 pub flags: StdVideoAV1FilmGrainFlags,
8025 pub grain_scaling_minus_8: u8,
8026 pub ar_coeff_lag: u8,
8027 pub ar_coeff_shift_minus_6: u8,
8028 pub grain_scale_shift: u8,
8029 pub grain_seed: u16,
8030 pub film_grain_params_ref_idx: u8,
8031 pub num_y_points: u8,
8032 pub point_y_value: [u8; 14usize],
8033 pub point_y_scaling: [u8; 14usize],
8034 pub num_cb_points: u8,
8035 pub point_cb_value: [u8; 10usize],
8036 pub point_cb_scaling: [u8; 10usize],
8037 pub num_cr_points: u8,
8038 pub point_cr_value: [u8; 10usize],
8039 pub point_cr_scaling: [u8; 10usize],
8040 pub ar_coeffs_y_plus_128: [i8; 24usize],
8041 pub ar_coeffs_cb_plus_128: [i8; 25usize],
8042 pub ar_coeffs_cr_plus_128: [i8; 25usize],
8043 pub cb_mult: u8,
8044 pub cb_luma_mult: u8,
8045 pub cb_offset: u16,
8046 pub cr_mult: u8,
8047 pub cr_luma_mult: u8,
8048 pub cr_offset: u16,
8049}
8050#[test]
8051fn bindgen_test_layout_StdVideoAV1FilmGrain() {
8052 const UNINIT: ::core::mem::MaybeUninit<StdVideoAV1FilmGrain> =
8053 ::core::mem::MaybeUninit::uninit();
8054 let ptr = UNINIT.as_ptr();
8055 assert_eq!(
8056 ::core::mem::size_of::<StdVideoAV1FilmGrain>(),
8057 164usize,
8058 concat!("Size of: ", stringify!(StdVideoAV1FilmGrain))
8059 );
8060 assert_eq!(
8061 ::core::mem::align_of::<StdVideoAV1FilmGrain>(),
8062 4usize,
8063 concat!("Alignment of ", stringify!(StdVideoAV1FilmGrain))
8064 );
8065 assert_eq!(
8066 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
8067 0usize,
8068 concat!(
8069 "Offset of field: ",
8070 stringify!(StdVideoAV1FilmGrain),
8071 "::",
8072 stringify!(flags)
8073 )
8074 );
8075 assert_eq!(
8076 unsafe { ::core::ptr::addr_of!((*ptr).grain_scaling_minus_8) as usize - ptr as usize },
8077 4usize,
8078 concat!(
8079 "Offset of field: ",
8080 stringify!(StdVideoAV1FilmGrain),
8081 "::",
8082 stringify!(grain_scaling_minus_8)
8083 )
8084 );
8085 assert_eq!(
8086 unsafe { ::core::ptr::addr_of!((*ptr).ar_coeff_lag) as usize - ptr as usize },
8087 5usize,
8088 concat!(
8089 "Offset of field: ",
8090 stringify!(StdVideoAV1FilmGrain),
8091 "::",
8092 stringify!(ar_coeff_lag)
8093 )
8094 );
8095 assert_eq!(
8096 unsafe { ::core::ptr::addr_of!((*ptr).ar_coeff_shift_minus_6) as usize - ptr as usize },
8097 6usize,
8098 concat!(
8099 "Offset of field: ",
8100 stringify!(StdVideoAV1FilmGrain),
8101 "::",
8102 stringify!(ar_coeff_shift_minus_6)
8103 )
8104 );
8105 assert_eq!(
8106 unsafe { ::core::ptr::addr_of!((*ptr).grain_scale_shift) as usize - ptr as usize },
8107 7usize,
8108 concat!(
8109 "Offset of field: ",
8110 stringify!(StdVideoAV1FilmGrain),
8111 "::",
8112 stringify!(grain_scale_shift)
8113 )
8114 );
8115 assert_eq!(
8116 unsafe { ::core::ptr::addr_of!((*ptr).grain_seed) as usize - ptr as usize },
8117 8usize,
8118 concat!(
8119 "Offset of field: ",
8120 stringify!(StdVideoAV1FilmGrain),
8121 "::",
8122 stringify!(grain_seed)
8123 )
8124 );
8125 assert_eq!(
8126 unsafe { ::core::ptr::addr_of!((*ptr).film_grain_params_ref_idx) as usize - ptr as usize },
8127 10usize,
8128 concat!(
8129 "Offset of field: ",
8130 stringify!(StdVideoAV1FilmGrain),
8131 "::",
8132 stringify!(film_grain_params_ref_idx)
8133 )
8134 );
8135 assert_eq!(
8136 unsafe { ::core::ptr::addr_of!((*ptr).num_y_points) as usize - ptr as usize },
8137 11usize,
8138 concat!(
8139 "Offset of field: ",
8140 stringify!(StdVideoAV1FilmGrain),
8141 "::",
8142 stringify!(num_y_points)
8143 )
8144 );
8145 assert_eq!(
8146 unsafe { ::core::ptr::addr_of!((*ptr).point_y_value) as usize - ptr as usize },
8147 12usize,
8148 concat!(
8149 "Offset of field: ",
8150 stringify!(StdVideoAV1FilmGrain),
8151 "::",
8152 stringify!(point_y_value)
8153 )
8154 );
8155 assert_eq!(
8156 unsafe { ::core::ptr::addr_of!((*ptr).point_y_scaling) as usize - ptr as usize },
8157 26usize,
8158 concat!(
8159 "Offset of field: ",
8160 stringify!(StdVideoAV1FilmGrain),
8161 "::",
8162 stringify!(point_y_scaling)
8163 )
8164 );
8165 assert_eq!(
8166 unsafe { ::core::ptr::addr_of!((*ptr).num_cb_points) as usize - ptr as usize },
8167 40usize,
8168 concat!(
8169 "Offset of field: ",
8170 stringify!(StdVideoAV1FilmGrain),
8171 "::",
8172 stringify!(num_cb_points)
8173 )
8174 );
8175 assert_eq!(
8176 unsafe { ::core::ptr::addr_of!((*ptr).point_cb_value) as usize - ptr as usize },
8177 41usize,
8178 concat!(
8179 "Offset of field: ",
8180 stringify!(StdVideoAV1FilmGrain),
8181 "::",
8182 stringify!(point_cb_value)
8183 )
8184 );
8185 assert_eq!(
8186 unsafe { ::core::ptr::addr_of!((*ptr).point_cb_scaling) as usize - ptr as usize },
8187 51usize,
8188 concat!(
8189 "Offset of field: ",
8190 stringify!(StdVideoAV1FilmGrain),
8191 "::",
8192 stringify!(point_cb_scaling)
8193 )
8194 );
8195 assert_eq!(
8196 unsafe { ::core::ptr::addr_of!((*ptr).num_cr_points) as usize - ptr as usize },
8197 61usize,
8198 concat!(
8199 "Offset of field: ",
8200 stringify!(StdVideoAV1FilmGrain),
8201 "::",
8202 stringify!(num_cr_points)
8203 )
8204 );
8205 assert_eq!(
8206 unsafe { ::core::ptr::addr_of!((*ptr).point_cr_value) as usize - ptr as usize },
8207 62usize,
8208 concat!(
8209 "Offset of field: ",
8210 stringify!(StdVideoAV1FilmGrain),
8211 "::",
8212 stringify!(point_cr_value)
8213 )
8214 );
8215 assert_eq!(
8216 unsafe { ::core::ptr::addr_of!((*ptr).point_cr_scaling) as usize - ptr as usize },
8217 72usize,
8218 concat!(
8219 "Offset of field: ",
8220 stringify!(StdVideoAV1FilmGrain),
8221 "::",
8222 stringify!(point_cr_scaling)
8223 )
8224 );
8225 assert_eq!(
8226 unsafe { ::core::ptr::addr_of!((*ptr).ar_coeffs_y_plus_128) as usize - ptr as usize },
8227 82usize,
8228 concat!(
8229 "Offset of field: ",
8230 stringify!(StdVideoAV1FilmGrain),
8231 "::",
8232 stringify!(ar_coeffs_y_plus_128)
8233 )
8234 );
8235 assert_eq!(
8236 unsafe { ::core::ptr::addr_of!((*ptr).ar_coeffs_cb_plus_128) as usize - ptr as usize },
8237 106usize,
8238 concat!(
8239 "Offset of field: ",
8240 stringify!(StdVideoAV1FilmGrain),
8241 "::",
8242 stringify!(ar_coeffs_cb_plus_128)
8243 )
8244 );
8245 assert_eq!(
8246 unsafe { ::core::ptr::addr_of!((*ptr).ar_coeffs_cr_plus_128) as usize - ptr as usize },
8247 131usize,
8248 concat!(
8249 "Offset of field: ",
8250 stringify!(StdVideoAV1FilmGrain),
8251 "::",
8252 stringify!(ar_coeffs_cr_plus_128)
8253 )
8254 );
8255 assert_eq!(
8256 unsafe { ::core::ptr::addr_of!((*ptr).cb_mult) as usize - ptr as usize },
8257 156usize,
8258 concat!(
8259 "Offset of field: ",
8260 stringify!(StdVideoAV1FilmGrain),
8261 "::",
8262 stringify!(cb_mult)
8263 )
8264 );
8265 assert_eq!(
8266 unsafe { ::core::ptr::addr_of!((*ptr).cb_luma_mult) as usize - ptr as usize },
8267 157usize,
8268 concat!(
8269 "Offset of field: ",
8270 stringify!(StdVideoAV1FilmGrain),
8271 "::",
8272 stringify!(cb_luma_mult)
8273 )
8274 );
8275 assert_eq!(
8276 unsafe { ::core::ptr::addr_of!((*ptr).cb_offset) as usize - ptr as usize },
8277 158usize,
8278 concat!(
8279 "Offset of field: ",
8280 stringify!(StdVideoAV1FilmGrain),
8281 "::",
8282 stringify!(cb_offset)
8283 )
8284 );
8285 assert_eq!(
8286 unsafe { ::core::ptr::addr_of!((*ptr).cr_mult) as usize - ptr as usize },
8287 160usize,
8288 concat!(
8289 "Offset of field: ",
8290 stringify!(StdVideoAV1FilmGrain),
8291 "::",
8292 stringify!(cr_mult)
8293 )
8294 );
8295 assert_eq!(
8296 unsafe { ::core::ptr::addr_of!((*ptr).cr_luma_mult) as usize - ptr as usize },
8297 161usize,
8298 concat!(
8299 "Offset of field: ",
8300 stringify!(StdVideoAV1FilmGrain),
8301 "::",
8302 stringify!(cr_luma_mult)
8303 )
8304 );
8305 assert_eq!(
8306 unsafe { ::core::ptr::addr_of!((*ptr).cr_offset) as usize - ptr as usize },
8307 162usize,
8308 concat!(
8309 "Offset of field: ",
8310 stringify!(StdVideoAV1FilmGrain),
8311 "::",
8312 stringify!(cr_offset)
8313 )
8314 );
8315}
8316#[repr(C)]
8317#[repr(align(4))]
8318#[derive(Debug, Copy, Clone)]
8319pub struct StdVideoAV1SequenceHeaderFlags {
8320 pub _bitfield_align_1: [u16; 0],
8321 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
8322}
8323#[test]
8324fn bindgen_test_layout_StdVideoAV1SequenceHeaderFlags() {
8325 assert_eq!(
8326 ::core::mem::size_of::<StdVideoAV1SequenceHeaderFlags>(),
8327 4usize,
8328 concat!("Size of: ", stringify!(StdVideoAV1SequenceHeaderFlags))
8329 );
8330 assert_eq!(
8331 ::core::mem::align_of::<StdVideoAV1SequenceHeaderFlags>(),
8332 4usize,
8333 concat!("Alignment of ", stringify!(StdVideoAV1SequenceHeaderFlags))
8334 );
8335}
8336impl StdVideoAV1SequenceHeaderFlags {
8337 #[inline]
8338 pub fn still_picture(&self) -> u32 {
8339 unsafe { ::core::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
8340 }
8341 #[inline]
8342 pub fn set_still_picture(&mut self, val: u32) {
8343 unsafe {
8344 let val: u32 = ::core::mem::transmute(val);
8345 self._bitfield_1.set(0usize, 1u8, val as u64)
8346 }
8347 }
8348 #[inline]
8349 pub fn reduced_still_picture_header(&self) -> u32 {
8350 unsafe { ::core::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
8351 }
8352 #[inline]
8353 pub fn set_reduced_still_picture_header(&mut self, val: u32) {
8354 unsafe {
8355 let val: u32 = ::core::mem::transmute(val);
8356 self._bitfield_1.set(1usize, 1u8, val as u64)
8357 }
8358 }
8359 #[inline]
8360 pub fn use_128x128_superblock(&self) -> u32 {
8361 unsafe { ::core::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
8362 }
8363 #[inline]
8364 pub fn set_use_128x128_superblock(&mut self, val: u32) {
8365 unsafe {
8366 let val: u32 = ::core::mem::transmute(val);
8367 self._bitfield_1.set(2usize, 1u8, val as u64)
8368 }
8369 }
8370 #[inline]
8371 pub fn enable_filter_intra(&self) -> u32 {
8372 unsafe { ::core::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
8373 }
8374 #[inline]
8375 pub fn set_enable_filter_intra(&mut self, val: u32) {
8376 unsafe {
8377 let val: u32 = ::core::mem::transmute(val);
8378 self._bitfield_1.set(3usize, 1u8, val as u64)
8379 }
8380 }
8381 #[inline]
8382 pub fn enable_intra_edge_filter(&self) -> u32 {
8383 unsafe { ::core::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
8384 }
8385 #[inline]
8386 pub fn set_enable_intra_edge_filter(&mut self, val: u32) {
8387 unsafe {
8388 let val: u32 = ::core::mem::transmute(val);
8389 self._bitfield_1.set(4usize, 1u8, val as u64)
8390 }
8391 }
8392 #[inline]
8393 pub fn enable_interintra_compound(&self) -> u32 {
8394 unsafe { ::core::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
8395 }
8396 #[inline]
8397 pub fn set_enable_interintra_compound(&mut self, val: u32) {
8398 unsafe {
8399 let val: u32 = ::core::mem::transmute(val);
8400 self._bitfield_1.set(5usize, 1u8, val as u64)
8401 }
8402 }
8403 #[inline]
8404 pub fn enable_masked_compound(&self) -> u32 {
8405 unsafe { ::core::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) }
8406 }
8407 #[inline]
8408 pub fn set_enable_masked_compound(&mut self, val: u32) {
8409 unsafe {
8410 let val: u32 = ::core::mem::transmute(val);
8411 self._bitfield_1.set(6usize, 1u8, val as u64)
8412 }
8413 }
8414 #[inline]
8415 pub fn enable_warped_motion(&self) -> u32 {
8416 unsafe { ::core::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) }
8417 }
8418 #[inline]
8419 pub fn set_enable_warped_motion(&mut self, val: u32) {
8420 unsafe {
8421 let val: u32 = ::core::mem::transmute(val);
8422 self._bitfield_1.set(7usize, 1u8, val as u64)
8423 }
8424 }
8425 #[inline]
8426 pub fn enable_dual_filter(&self) -> u32 {
8427 unsafe { ::core::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) }
8428 }
8429 #[inline]
8430 pub fn set_enable_dual_filter(&mut self, val: u32) {
8431 unsafe {
8432 let val: u32 = ::core::mem::transmute(val);
8433 self._bitfield_1.set(8usize, 1u8, val as u64)
8434 }
8435 }
8436 #[inline]
8437 pub fn enable_order_hint(&self) -> u32 {
8438 unsafe { ::core::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) }
8439 }
8440 #[inline]
8441 pub fn set_enable_order_hint(&mut self, val: u32) {
8442 unsafe {
8443 let val: u32 = ::core::mem::transmute(val);
8444 self._bitfield_1.set(9usize, 1u8, val as u64)
8445 }
8446 }
8447 #[inline]
8448 pub fn enable_jnt_comp(&self) -> u32 {
8449 unsafe { ::core::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) }
8450 }
8451 #[inline]
8452 pub fn set_enable_jnt_comp(&mut self, val: u32) {
8453 unsafe {
8454 let val: u32 = ::core::mem::transmute(val);
8455 self._bitfield_1.set(10usize, 1u8, val as u64)
8456 }
8457 }
8458 #[inline]
8459 pub fn enable_ref_frame_mvs(&self) -> u32 {
8460 unsafe { ::core::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) }
8461 }
8462 #[inline]
8463 pub fn set_enable_ref_frame_mvs(&mut self, val: u32) {
8464 unsafe {
8465 let val: u32 = ::core::mem::transmute(val);
8466 self._bitfield_1.set(11usize, 1u8, val as u64)
8467 }
8468 }
8469 #[inline]
8470 pub fn frame_id_numbers_present_flag(&self) -> u32 {
8471 unsafe { ::core::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u32) }
8472 }
8473 #[inline]
8474 pub fn set_frame_id_numbers_present_flag(&mut self, val: u32) {
8475 unsafe {
8476 let val: u32 = ::core::mem::transmute(val);
8477 self._bitfield_1.set(12usize, 1u8, val as u64)
8478 }
8479 }
8480 #[inline]
8481 pub fn enable_superres(&self) -> u32 {
8482 unsafe { ::core::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) }
8483 }
8484 #[inline]
8485 pub fn set_enable_superres(&mut self, val: u32) {
8486 unsafe {
8487 let val: u32 = ::core::mem::transmute(val);
8488 self._bitfield_1.set(13usize, 1u8, val as u64)
8489 }
8490 }
8491 #[inline]
8492 pub fn enable_cdef(&self) -> u32 {
8493 unsafe { ::core::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) }
8494 }
8495 #[inline]
8496 pub fn set_enable_cdef(&mut self, val: u32) {
8497 unsafe {
8498 let val: u32 = ::core::mem::transmute(val);
8499 self._bitfield_1.set(14usize, 1u8, val as u64)
8500 }
8501 }
8502 #[inline]
8503 pub fn enable_restoration(&self) -> u32 {
8504 unsafe { ::core::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u32) }
8505 }
8506 #[inline]
8507 pub fn set_enable_restoration(&mut self, val: u32) {
8508 unsafe {
8509 let val: u32 = ::core::mem::transmute(val);
8510 self._bitfield_1.set(15usize, 1u8, val as u64)
8511 }
8512 }
8513 #[inline]
8514 pub fn film_grain_params_present(&self) -> u32 {
8515 unsafe { ::core::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u32) }
8516 }
8517 #[inline]
8518 pub fn set_film_grain_params_present(&mut self, val: u32) {
8519 unsafe {
8520 let val: u32 = ::core::mem::transmute(val);
8521 self._bitfield_1.set(16usize, 1u8, val as u64)
8522 }
8523 }
8524 #[inline]
8525 pub fn timing_info_present_flag(&self) -> u32 {
8526 unsafe { ::core::mem::transmute(self._bitfield_1.get(17usize, 1u8) as u32) }
8527 }
8528 #[inline]
8529 pub fn set_timing_info_present_flag(&mut self, val: u32) {
8530 unsafe {
8531 let val: u32 = ::core::mem::transmute(val);
8532 self._bitfield_1.set(17usize, 1u8, val as u64)
8533 }
8534 }
8535 #[inline]
8536 pub fn initial_display_delay_present_flag(&self) -> u32 {
8537 unsafe { ::core::mem::transmute(self._bitfield_1.get(18usize, 1u8) as u32) }
8538 }
8539 #[inline]
8540 pub fn set_initial_display_delay_present_flag(&mut self, val: u32) {
8541 unsafe {
8542 let val: u32 = ::core::mem::transmute(val);
8543 self._bitfield_1.set(18usize, 1u8, val as u64)
8544 }
8545 }
8546 #[inline]
8547 pub fn reserved(&self) -> u32 {
8548 unsafe { ::core::mem::transmute(self._bitfield_1.get(19usize, 13u8) as u32) }
8549 }
8550 #[inline]
8551 pub fn set_reserved(&mut self, val: u32) {
8552 unsafe {
8553 let val: u32 = ::core::mem::transmute(val);
8554 self._bitfield_1.set(19usize, 13u8, val as u64)
8555 }
8556 }
8557 #[inline]
8558 pub fn new_bitfield_1(
8559 still_picture: u32,
8560 reduced_still_picture_header: u32,
8561 use_128x128_superblock: u32,
8562 enable_filter_intra: u32,
8563 enable_intra_edge_filter: u32,
8564 enable_interintra_compound: u32,
8565 enable_masked_compound: u32,
8566 enable_warped_motion: u32,
8567 enable_dual_filter: u32,
8568 enable_order_hint: u32,
8569 enable_jnt_comp: u32,
8570 enable_ref_frame_mvs: u32,
8571 frame_id_numbers_present_flag: u32,
8572 enable_superres: u32,
8573 enable_cdef: u32,
8574 enable_restoration: u32,
8575 film_grain_params_present: u32,
8576 timing_info_present_flag: u32,
8577 initial_display_delay_present_flag: u32,
8578 reserved: u32,
8579 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
8580 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
8581 __bindgen_bitfield_unit.set(0usize, 1u8, {
8582 let still_picture: u32 = unsafe { ::core::mem::transmute(still_picture) };
8583 still_picture as u64
8584 });
8585 __bindgen_bitfield_unit.set(1usize, 1u8, {
8586 let reduced_still_picture_header: u32 =
8587 unsafe { ::core::mem::transmute(reduced_still_picture_header) };
8588 reduced_still_picture_header as u64
8589 });
8590 __bindgen_bitfield_unit.set(2usize, 1u8, {
8591 let use_128x128_superblock: u32 =
8592 unsafe { ::core::mem::transmute(use_128x128_superblock) };
8593 use_128x128_superblock as u64
8594 });
8595 __bindgen_bitfield_unit.set(3usize, 1u8, {
8596 let enable_filter_intra: u32 = unsafe { ::core::mem::transmute(enable_filter_intra) };
8597 enable_filter_intra as u64
8598 });
8599 __bindgen_bitfield_unit.set(4usize, 1u8, {
8600 let enable_intra_edge_filter: u32 =
8601 unsafe { ::core::mem::transmute(enable_intra_edge_filter) };
8602 enable_intra_edge_filter as u64
8603 });
8604 __bindgen_bitfield_unit.set(5usize, 1u8, {
8605 let enable_interintra_compound: u32 =
8606 unsafe { ::core::mem::transmute(enable_interintra_compound) };
8607 enable_interintra_compound as u64
8608 });
8609 __bindgen_bitfield_unit.set(6usize, 1u8, {
8610 let enable_masked_compound: u32 =
8611 unsafe { ::core::mem::transmute(enable_masked_compound) };
8612 enable_masked_compound as u64
8613 });
8614 __bindgen_bitfield_unit.set(7usize, 1u8, {
8615 let enable_warped_motion: u32 = unsafe { ::core::mem::transmute(enable_warped_motion) };
8616 enable_warped_motion as u64
8617 });
8618 __bindgen_bitfield_unit.set(8usize, 1u8, {
8619 let enable_dual_filter: u32 = unsafe { ::core::mem::transmute(enable_dual_filter) };
8620 enable_dual_filter as u64
8621 });
8622 __bindgen_bitfield_unit.set(9usize, 1u8, {
8623 let enable_order_hint: u32 = unsafe { ::core::mem::transmute(enable_order_hint) };
8624 enable_order_hint as u64
8625 });
8626 __bindgen_bitfield_unit.set(10usize, 1u8, {
8627 let enable_jnt_comp: u32 = unsafe { ::core::mem::transmute(enable_jnt_comp) };
8628 enable_jnt_comp as u64
8629 });
8630 __bindgen_bitfield_unit.set(11usize, 1u8, {
8631 let enable_ref_frame_mvs: u32 = unsafe { ::core::mem::transmute(enable_ref_frame_mvs) };
8632 enable_ref_frame_mvs as u64
8633 });
8634 __bindgen_bitfield_unit.set(12usize, 1u8, {
8635 let frame_id_numbers_present_flag: u32 =
8636 unsafe { ::core::mem::transmute(frame_id_numbers_present_flag) };
8637 frame_id_numbers_present_flag as u64
8638 });
8639 __bindgen_bitfield_unit.set(13usize, 1u8, {
8640 let enable_superres: u32 = unsafe { ::core::mem::transmute(enable_superres) };
8641 enable_superres as u64
8642 });
8643 __bindgen_bitfield_unit.set(14usize, 1u8, {
8644 let enable_cdef: u32 = unsafe { ::core::mem::transmute(enable_cdef) };
8645 enable_cdef as u64
8646 });
8647 __bindgen_bitfield_unit.set(15usize, 1u8, {
8648 let enable_restoration: u32 = unsafe { ::core::mem::transmute(enable_restoration) };
8649 enable_restoration as u64
8650 });
8651 __bindgen_bitfield_unit.set(16usize, 1u8, {
8652 let film_grain_params_present: u32 =
8653 unsafe { ::core::mem::transmute(film_grain_params_present) };
8654 film_grain_params_present as u64
8655 });
8656 __bindgen_bitfield_unit.set(17usize, 1u8, {
8657 let timing_info_present_flag: u32 =
8658 unsafe { ::core::mem::transmute(timing_info_present_flag) };
8659 timing_info_present_flag as u64
8660 });
8661 __bindgen_bitfield_unit.set(18usize, 1u8, {
8662 let initial_display_delay_present_flag: u32 =
8663 unsafe { ::core::mem::transmute(initial_display_delay_present_flag) };
8664 initial_display_delay_present_flag as u64
8665 });
8666 __bindgen_bitfield_unit.set(19usize, 13u8, {
8667 let reserved: u32 = unsafe { ::core::mem::transmute(reserved) };
8668 reserved as u64
8669 });
8670 __bindgen_bitfield_unit
8671 }
8672}
8673#[repr(C)]
8674#[derive(Debug, Copy, Clone)]
8675pub struct StdVideoAV1SequenceHeader {
8676 pub flags: StdVideoAV1SequenceHeaderFlags,
8677 pub seq_profile: StdVideoAV1Profile,
8678 pub frame_width_bits_minus_1: u8,
8679 pub frame_height_bits_minus_1: u8,
8680 pub max_frame_width_minus_1: u16,
8681 pub max_frame_height_minus_1: u16,
8682 pub delta_frame_id_length_minus_2: u8,
8683 pub additional_frame_id_length_minus_1: u8,
8684 pub order_hint_bits_minus_1: u8,
8685 pub seq_force_integer_mv: u8,
8686 pub seq_force_screen_content_tools: u8,
8687 pub reserved1: [u8; 5usize],
8688 pub pColorConfig: *const StdVideoAV1ColorConfig,
8689 pub pTimingInfo: *const StdVideoAV1TimingInfo,
8690}
8691#[test]
8692fn bindgen_test_layout_StdVideoAV1SequenceHeader() {
8693 const UNINIT: ::core::mem::MaybeUninit<StdVideoAV1SequenceHeader> =
8694 ::core::mem::MaybeUninit::uninit();
8695 let ptr = UNINIT.as_ptr();
8696 assert_eq!(
8697 ::core::mem::size_of::<StdVideoAV1SequenceHeader>(),
8698 40usize,
8699 concat!("Size of: ", stringify!(StdVideoAV1SequenceHeader))
8700 );
8701 assert_eq!(
8702 ::core::mem::align_of::<StdVideoAV1SequenceHeader>(),
8703 8usize,
8704 concat!("Alignment of ", stringify!(StdVideoAV1SequenceHeader))
8705 );
8706 assert_eq!(
8707 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
8708 0usize,
8709 concat!(
8710 "Offset of field: ",
8711 stringify!(StdVideoAV1SequenceHeader),
8712 "::",
8713 stringify!(flags)
8714 )
8715 );
8716 assert_eq!(
8717 unsafe { ::core::ptr::addr_of!((*ptr).seq_profile) as usize - ptr as usize },
8718 4usize,
8719 concat!(
8720 "Offset of field: ",
8721 stringify!(StdVideoAV1SequenceHeader),
8722 "::",
8723 stringify!(seq_profile)
8724 )
8725 );
8726 assert_eq!(
8727 unsafe { ::core::ptr::addr_of!((*ptr).frame_width_bits_minus_1) as usize - ptr as usize },
8728 8usize,
8729 concat!(
8730 "Offset of field: ",
8731 stringify!(StdVideoAV1SequenceHeader),
8732 "::",
8733 stringify!(frame_width_bits_minus_1)
8734 )
8735 );
8736 assert_eq!(
8737 unsafe { ::core::ptr::addr_of!((*ptr).frame_height_bits_minus_1) as usize - ptr as usize },
8738 9usize,
8739 concat!(
8740 "Offset of field: ",
8741 stringify!(StdVideoAV1SequenceHeader),
8742 "::",
8743 stringify!(frame_height_bits_minus_1)
8744 )
8745 );
8746 assert_eq!(
8747 unsafe { ::core::ptr::addr_of!((*ptr).max_frame_width_minus_1) as usize - ptr as usize },
8748 10usize,
8749 concat!(
8750 "Offset of field: ",
8751 stringify!(StdVideoAV1SequenceHeader),
8752 "::",
8753 stringify!(max_frame_width_minus_1)
8754 )
8755 );
8756 assert_eq!(
8757 unsafe { ::core::ptr::addr_of!((*ptr).max_frame_height_minus_1) as usize - ptr as usize },
8758 12usize,
8759 concat!(
8760 "Offset of field: ",
8761 stringify!(StdVideoAV1SequenceHeader),
8762 "::",
8763 stringify!(max_frame_height_minus_1)
8764 )
8765 );
8766 assert_eq!(
8767 unsafe {
8768 ::core::ptr::addr_of!((*ptr).delta_frame_id_length_minus_2) as usize - ptr as usize
8769 },
8770 14usize,
8771 concat!(
8772 "Offset of field: ",
8773 stringify!(StdVideoAV1SequenceHeader),
8774 "::",
8775 stringify!(delta_frame_id_length_minus_2)
8776 )
8777 );
8778 assert_eq!(
8779 unsafe {
8780 ::core::ptr::addr_of!((*ptr).additional_frame_id_length_minus_1) as usize - ptr as usize
8781 },
8782 15usize,
8783 concat!(
8784 "Offset of field: ",
8785 stringify!(StdVideoAV1SequenceHeader),
8786 "::",
8787 stringify!(additional_frame_id_length_minus_1)
8788 )
8789 );
8790 assert_eq!(
8791 unsafe { ::core::ptr::addr_of!((*ptr).order_hint_bits_minus_1) as usize - ptr as usize },
8792 16usize,
8793 concat!(
8794 "Offset of field: ",
8795 stringify!(StdVideoAV1SequenceHeader),
8796 "::",
8797 stringify!(order_hint_bits_minus_1)
8798 )
8799 );
8800 assert_eq!(
8801 unsafe { ::core::ptr::addr_of!((*ptr).seq_force_integer_mv) as usize - ptr as usize },
8802 17usize,
8803 concat!(
8804 "Offset of field: ",
8805 stringify!(StdVideoAV1SequenceHeader),
8806 "::",
8807 stringify!(seq_force_integer_mv)
8808 )
8809 );
8810 assert_eq!(
8811 unsafe {
8812 ::core::ptr::addr_of!((*ptr).seq_force_screen_content_tools) as usize - ptr as usize
8813 },
8814 18usize,
8815 concat!(
8816 "Offset of field: ",
8817 stringify!(StdVideoAV1SequenceHeader),
8818 "::",
8819 stringify!(seq_force_screen_content_tools)
8820 )
8821 );
8822 assert_eq!(
8823 unsafe { ::core::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize },
8824 19usize,
8825 concat!(
8826 "Offset of field: ",
8827 stringify!(StdVideoAV1SequenceHeader),
8828 "::",
8829 stringify!(reserved1)
8830 )
8831 );
8832 assert_eq!(
8833 unsafe { ::core::ptr::addr_of!((*ptr).pColorConfig) as usize - ptr as usize },
8834 24usize,
8835 concat!(
8836 "Offset of field: ",
8837 stringify!(StdVideoAV1SequenceHeader),
8838 "::",
8839 stringify!(pColorConfig)
8840 )
8841 );
8842 assert_eq!(
8843 unsafe { ::core::ptr::addr_of!((*ptr).pTimingInfo) as usize - ptr as usize },
8844 32usize,
8845 concat!(
8846 "Offset of field: ",
8847 stringify!(StdVideoAV1SequenceHeader),
8848 "::",
8849 stringify!(pTimingInfo)
8850 )
8851 );
8852}
8853#[repr(C)]
8854#[repr(align(4))]
8855#[derive(Debug, Copy, Clone)]
8856pub struct StdVideoDecodeAV1PictureInfoFlags {
8857 pub _bitfield_align_1: [u8; 0],
8858 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
8859}
8860#[test]
8861fn bindgen_test_layout_StdVideoDecodeAV1PictureInfoFlags() {
8862 assert_eq!(
8863 ::core::mem::size_of::<StdVideoDecodeAV1PictureInfoFlags>(),
8864 4usize,
8865 concat!("Size of: ", stringify!(StdVideoDecodeAV1PictureInfoFlags))
8866 );
8867 assert_eq!(
8868 ::core::mem::align_of::<StdVideoDecodeAV1PictureInfoFlags>(),
8869 4usize,
8870 concat!(
8871 "Alignment of ",
8872 stringify!(StdVideoDecodeAV1PictureInfoFlags)
8873 )
8874 );
8875}
8876impl StdVideoDecodeAV1PictureInfoFlags {
8877 #[inline]
8878 pub fn error_resilient_mode(&self) -> u32 {
8879 unsafe { ::core::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
8880 }
8881 #[inline]
8882 pub fn set_error_resilient_mode(&mut self, val: u32) {
8883 unsafe {
8884 let val: u32 = ::core::mem::transmute(val);
8885 self._bitfield_1.set(0usize, 1u8, val as u64)
8886 }
8887 }
8888 #[inline]
8889 pub fn disable_cdf_update(&self) -> u32 {
8890 unsafe { ::core::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
8891 }
8892 #[inline]
8893 pub fn set_disable_cdf_update(&mut self, val: u32) {
8894 unsafe {
8895 let val: u32 = ::core::mem::transmute(val);
8896 self._bitfield_1.set(1usize, 1u8, val as u64)
8897 }
8898 }
8899 #[inline]
8900 pub fn use_superres(&self) -> u32 {
8901 unsafe { ::core::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
8902 }
8903 #[inline]
8904 pub fn set_use_superres(&mut self, val: u32) {
8905 unsafe {
8906 let val: u32 = ::core::mem::transmute(val);
8907 self._bitfield_1.set(2usize, 1u8, val as u64)
8908 }
8909 }
8910 #[inline]
8911 pub fn render_and_frame_size_different(&self) -> u32 {
8912 unsafe { ::core::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
8913 }
8914 #[inline]
8915 pub fn set_render_and_frame_size_different(&mut self, val: u32) {
8916 unsafe {
8917 let val: u32 = ::core::mem::transmute(val);
8918 self._bitfield_1.set(3usize, 1u8, val as u64)
8919 }
8920 }
8921 #[inline]
8922 pub fn allow_screen_content_tools(&self) -> u32 {
8923 unsafe { ::core::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
8924 }
8925 #[inline]
8926 pub fn set_allow_screen_content_tools(&mut self, val: u32) {
8927 unsafe {
8928 let val: u32 = ::core::mem::transmute(val);
8929 self._bitfield_1.set(4usize, 1u8, val as u64)
8930 }
8931 }
8932 #[inline]
8933 pub fn is_filter_switchable(&self) -> u32 {
8934 unsafe { ::core::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
8935 }
8936 #[inline]
8937 pub fn set_is_filter_switchable(&mut self, val: u32) {
8938 unsafe {
8939 let val: u32 = ::core::mem::transmute(val);
8940 self._bitfield_1.set(5usize, 1u8, val as u64)
8941 }
8942 }
8943 #[inline]
8944 pub fn force_integer_mv(&self) -> u32 {
8945 unsafe { ::core::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) }
8946 }
8947 #[inline]
8948 pub fn set_force_integer_mv(&mut self, val: u32) {
8949 unsafe {
8950 let val: u32 = ::core::mem::transmute(val);
8951 self._bitfield_1.set(6usize, 1u8, val as u64)
8952 }
8953 }
8954 #[inline]
8955 pub fn frame_size_override_flag(&self) -> u32 {
8956 unsafe { ::core::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) }
8957 }
8958 #[inline]
8959 pub fn set_frame_size_override_flag(&mut self, val: u32) {
8960 unsafe {
8961 let val: u32 = ::core::mem::transmute(val);
8962 self._bitfield_1.set(7usize, 1u8, val as u64)
8963 }
8964 }
8965 #[inline]
8966 pub fn buffer_removal_time_present_flag(&self) -> u32 {
8967 unsafe { ::core::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) }
8968 }
8969 #[inline]
8970 pub fn set_buffer_removal_time_present_flag(&mut self, val: u32) {
8971 unsafe {
8972 let val: u32 = ::core::mem::transmute(val);
8973 self._bitfield_1.set(8usize, 1u8, val as u64)
8974 }
8975 }
8976 #[inline]
8977 pub fn allow_intrabc(&self) -> u32 {
8978 unsafe { ::core::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) }
8979 }
8980 #[inline]
8981 pub fn set_allow_intrabc(&mut self, val: u32) {
8982 unsafe {
8983 let val: u32 = ::core::mem::transmute(val);
8984 self._bitfield_1.set(9usize, 1u8, val as u64)
8985 }
8986 }
8987 #[inline]
8988 pub fn frame_refs_short_signaling(&self) -> u32 {
8989 unsafe { ::core::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) }
8990 }
8991 #[inline]
8992 pub fn set_frame_refs_short_signaling(&mut self, val: u32) {
8993 unsafe {
8994 let val: u32 = ::core::mem::transmute(val);
8995 self._bitfield_1.set(10usize, 1u8, val as u64)
8996 }
8997 }
8998 #[inline]
8999 pub fn allow_high_precision_mv(&self) -> u32 {
9000 unsafe { ::core::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) }
9001 }
9002 #[inline]
9003 pub fn set_allow_high_precision_mv(&mut self, val: u32) {
9004 unsafe {
9005 let val: u32 = ::core::mem::transmute(val);
9006 self._bitfield_1.set(11usize, 1u8, val as u64)
9007 }
9008 }
9009 #[inline]
9010 pub fn is_motion_mode_switchable(&self) -> u32 {
9011 unsafe { ::core::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u32) }
9012 }
9013 #[inline]
9014 pub fn set_is_motion_mode_switchable(&mut self, val: u32) {
9015 unsafe {
9016 let val: u32 = ::core::mem::transmute(val);
9017 self._bitfield_1.set(12usize, 1u8, val as u64)
9018 }
9019 }
9020 #[inline]
9021 pub fn use_ref_frame_mvs(&self) -> u32 {
9022 unsafe { ::core::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) }
9023 }
9024 #[inline]
9025 pub fn set_use_ref_frame_mvs(&mut self, val: u32) {
9026 unsafe {
9027 let val: u32 = ::core::mem::transmute(val);
9028 self._bitfield_1.set(13usize, 1u8, val as u64)
9029 }
9030 }
9031 #[inline]
9032 pub fn disable_frame_end_update_cdf(&self) -> u32 {
9033 unsafe { ::core::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) }
9034 }
9035 #[inline]
9036 pub fn set_disable_frame_end_update_cdf(&mut self, val: u32) {
9037 unsafe {
9038 let val: u32 = ::core::mem::transmute(val);
9039 self._bitfield_1.set(14usize, 1u8, val as u64)
9040 }
9041 }
9042 #[inline]
9043 pub fn allow_warped_motion(&self) -> u32 {
9044 unsafe { ::core::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u32) }
9045 }
9046 #[inline]
9047 pub fn set_allow_warped_motion(&mut self, val: u32) {
9048 unsafe {
9049 let val: u32 = ::core::mem::transmute(val);
9050 self._bitfield_1.set(15usize, 1u8, val as u64)
9051 }
9052 }
9053 #[inline]
9054 pub fn reduced_tx_set(&self) -> u32 {
9055 unsafe { ::core::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u32) }
9056 }
9057 #[inline]
9058 pub fn set_reduced_tx_set(&mut self, val: u32) {
9059 unsafe {
9060 let val: u32 = ::core::mem::transmute(val);
9061 self._bitfield_1.set(16usize, 1u8, val as u64)
9062 }
9063 }
9064 #[inline]
9065 pub fn reference_select(&self) -> u32 {
9066 unsafe { ::core::mem::transmute(self._bitfield_1.get(17usize, 1u8) as u32) }
9067 }
9068 #[inline]
9069 pub fn set_reference_select(&mut self, val: u32) {
9070 unsafe {
9071 let val: u32 = ::core::mem::transmute(val);
9072 self._bitfield_1.set(17usize, 1u8, val as u64)
9073 }
9074 }
9075 #[inline]
9076 pub fn skip_mode_present(&self) -> u32 {
9077 unsafe { ::core::mem::transmute(self._bitfield_1.get(18usize, 1u8) as u32) }
9078 }
9079 #[inline]
9080 pub fn set_skip_mode_present(&mut self, val: u32) {
9081 unsafe {
9082 let val: u32 = ::core::mem::transmute(val);
9083 self._bitfield_1.set(18usize, 1u8, val as u64)
9084 }
9085 }
9086 #[inline]
9087 pub fn delta_q_present(&self) -> u32 {
9088 unsafe { ::core::mem::transmute(self._bitfield_1.get(19usize, 1u8) as u32) }
9089 }
9090 #[inline]
9091 pub fn set_delta_q_present(&mut self, val: u32) {
9092 unsafe {
9093 let val: u32 = ::core::mem::transmute(val);
9094 self._bitfield_1.set(19usize, 1u8, val as u64)
9095 }
9096 }
9097 #[inline]
9098 pub fn delta_lf_present(&self) -> u32 {
9099 unsafe { ::core::mem::transmute(self._bitfield_1.get(20usize, 1u8) as u32) }
9100 }
9101 #[inline]
9102 pub fn set_delta_lf_present(&mut self, val: u32) {
9103 unsafe {
9104 let val: u32 = ::core::mem::transmute(val);
9105 self._bitfield_1.set(20usize, 1u8, val as u64)
9106 }
9107 }
9108 #[inline]
9109 pub fn delta_lf_multi(&self) -> u32 {
9110 unsafe { ::core::mem::transmute(self._bitfield_1.get(21usize, 1u8) as u32) }
9111 }
9112 #[inline]
9113 pub fn set_delta_lf_multi(&mut self, val: u32) {
9114 unsafe {
9115 let val: u32 = ::core::mem::transmute(val);
9116 self._bitfield_1.set(21usize, 1u8, val as u64)
9117 }
9118 }
9119 #[inline]
9120 pub fn segmentation_enabled(&self) -> u32 {
9121 unsafe { ::core::mem::transmute(self._bitfield_1.get(22usize, 1u8) as u32) }
9122 }
9123 #[inline]
9124 pub fn set_segmentation_enabled(&mut self, val: u32) {
9125 unsafe {
9126 let val: u32 = ::core::mem::transmute(val);
9127 self._bitfield_1.set(22usize, 1u8, val as u64)
9128 }
9129 }
9130 #[inline]
9131 pub fn segmentation_update_map(&self) -> u32 {
9132 unsafe { ::core::mem::transmute(self._bitfield_1.get(23usize, 1u8) as u32) }
9133 }
9134 #[inline]
9135 pub fn set_segmentation_update_map(&mut self, val: u32) {
9136 unsafe {
9137 let val: u32 = ::core::mem::transmute(val);
9138 self._bitfield_1.set(23usize, 1u8, val as u64)
9139 }
9140 }
9141 #[inline]
9142 pub fn segmentation_temporal_update(&self) -> u32 {
9143 unsafe { ::core::mem::transmute(self._bitfield_1.get(24usize, 1u8) as u32) }
9144 }
9145 #[inline]
9146 pub fn set_segmentation_temporal_update(&mut self, val: u32) {
9147 unsafe {
9148 let val: u32 = ::core::mem::transmute(val);
9149 self._bitfield_1.set(24usize, 1u8, val as u64)
9150 }
9151 }
9152 #[inline]
9153 pub fn segmentation_update_data(&self) -> u32 {
9154 unsafe { ::core::mem::transmute(self._bitfield_1.get(25usize, 1u8) as u32) }
9155 }
9156 #[inline]
9157 pub fn set_segmentation_update_data(&mut self, val: u32) {
9158 unsafe {
9159 let val: u32 = ::core::mem::transmute(val);
9160 self._bitfield_1.set(25usize, 1u8, val as u64)
9161 }
9162 }
9163 #[inline]
9164 pub fn UsesLr(&self) -> u32 {
9165 unsafe { ::core::mem::transmute(self._bitfield_1.get(26usize, 1u8) as u32) }
9166 }
9167 #[inline]
9168 pub fn set_UsesLr(&mut self, val: u32) {
9169 unsafe {
9170 let val: u32 = ::core::mem::transmute(val);
9171 self._bitfield_1.set(26usize, 1u8, val as u64)
9172 }
9173 }
9174 #[inline]
9175 pub fn usesChromaLr(&self) -> u32 {
9176 unsafe { ::core::mem::transmute(self._bitfield_1.get(27usize, 1u8) as u32) }
9177 }
9178 #[inline]
9179 pub fn set_usesChromaLr(&mut self, val: u32) {
9180 unsafe {
9181 let val: u32 = ::core::mem::transmute(val);
9182 self._bitfield_1.set(27usize, 1u8, val as u64)
9183 }
9184 }
9185 #[inline]
9186 pub fn apply_grain(&self) -> u32 {
9187 unsafe { ::core::mem::transmute(self._bitfield_1.get(28usize, 1u8) as u32) }
9188 }
9189 #[inline]
9190 pub fn set_apply_grain(&mut self, val: u32) {
9191 unsafe {
9192 let val: u32 = ::core::mem::transmute(val);
9193 self._bitfield_1.set(28usize, 1u8, val as u64)
9194 }
9195 }
9196 #[inline]
9197 pub fn reserved(&self) -> u32 {
9198 unsafe { ::core::mem::transmute(self._bitfield_1.get(29usize, 3u8) as u32) }
9199 }
9200 #[inline]
9201 pub fn set_reserved(&mut self, val: u32) {
9202 unsafe {
9203 let val: u32 = ::core::mem::transmute(val);
9204 self._bitfield_1.set(29usize, 3u8, val as u64)
9205 }
9206 }
9207 #[inline]
9208 pub fn new_bitfield_1(
9209 error_resilient_mode: u32,
9210 disable_cdf_update: u32,
9211 use_superres: u32,
9212 render_and_frame_size_different: u32,
9213 allow_screen_content_tools: u32,
9214 is_filter_switchable: u32,
9215 force_integer_mv: u32,
9216 frame_size_override_flag: u32,
9217 buffer_removal_time_present_flag: u32,
9218 allow_intrabc: u32,
9219 frame_refs_short_signaling: u32,
9220 allow_high_precision_mv: u32,
9221 is_motion_mode_switchable: u32,
9222 use_ref_frame_mvs: u32,
9223 disable_frame_end_update_cdf: u32,
9224 allow_warped_motion: u32,
9225 reduced_tx_set: u32,
9226 reference_select: u32,
9227 skip_mode_present: u32,
9228 delta_q_present: u32,
9229 delta_lf_present: u32,
9230 delta_lf_multi: u32,
9231 segmentation_enabled: u32,
9232 segmentation_update_map: u32,
9233 segmentation_temporal_update: u32,
9234 segmentation_update_data: u32,
9235 UsesLr: u32,
9236 usesChromaLr: u32,
9237 apply_grain: u32,
9238 reserved: u32,
9239 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
9240 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
9241 __bindgen_bitfield_unit.set(0usize, 1u8, {
9242 let error_resilient_mode: u32 = unsafe { ::core::mem::transmute(error_resilient_mode) };
9243 error_resilient_mode as u64
9244 });
9245 __bindgen_bitfield_unit.set(1usize, 1u8, {
9246 let disable_cdf_update: u32 = unsafe { ::core::mem::transmute(disable_cdf_update) };
9247 disable_cdf_update as u64
9248 });
9249 __bindgen_bitfield_unit.set(2usize, 1u8, {
9250 let use_superres: u32 = unsafe { ::core::mem::transmute(use_superres) };
9251 use_superres as u64
9252 });
9253 __bindgen_bitfield_unit.set(3usize, 1u8, {
9254 let render_and_frame_size_different: u32 =
9255 unsafe { ::core::mem::transmute(render_and_frame_size_different) };
9256 render_and_frame_size_different as u64
9257 });
9258 __bindgen_bitfield_unit.set(4usize, 1u8, {
9259 let allow_screen_content_tools: u32 =
9260 unsafe { ::core::mem::transmute(allow_screen_content_tools) };
9261 allow_screen_content_tools as u64
9262 });
9263 __bindgen_bitfield_unit.set(5usize, 1u8, {
9264 let is_filter_switchable: u32 = unsafe { ::core::mem::transmute(is_filter_switchable) };
9265 is_filter_switchable as u64
9266 });
9267 __bindgen_bitfield_unit.set(6usize, 1u8, {
9268 let force_integer_mv: u32 = unsafe { ::core::mem::transmute(force_integer_mv) };
9269 force_integer_mv as u64
9270 });
9271 __bindgen_bitfield_unit.set(7usize, 1u8, {
9272 let frame_size_override_flag: u32 =
9273 unsafe { ::core::mem::transmute(frame_size_override_flag) };
9274 frame_size_override_flag as u64
9275 });
9276 __bindgen_bitfield_unit.set(8usize, 1u8, {
9277 let buffer_removal_time_present_flag: u32 =
9278 unsafe { ::core::mem::transmute(buffer_removal_time_present_flag) };
9279 buffer_removal_time_present_flag as u64
9280 });
9281 __bindgen_bitfield_unit.set(9usize, 1u8, {
9282 let allow_intrabc: u32 = unsafe { ::core::mem::transmute(allow_intrabc) };
9283 allow_intrabc as u64
9284 });
9285 __bindgen_bitfield_unit.set(10usize, 1u8, {
9286 let frame_refs_short_signaling: u32 =
9287 unsafe { ::core::mem::transmute(frame_refs_short_signaling) };
9288 frame_refs_short_signaling as u64
9289 });
9290 __bindgen_bitfield_unit.set(11usize, 1u8, {
9291 let allow_high_precision_mv: u32 =
9292 unsafe { ::core::mem::transmute(allow_high_precision_mv) };
9293 allow_high_precision_mv as u64
9294 });
9295 __bindgen_bitfield_unit.set(12usize, 1u8, {
9296 let is_motion_mode_switchable: u32 =
9297 unsafe { ::core::mem::transmute(is_motion_mode_switchable) };
9298 is_motion_mode_switchable as u64
9299 });
9300 __bindgen_bitfield_unit.set(13usize, 1u8, {
9301 let use_ref_frame_mvs: u32 = unsafe { ::core::mem::transmute(use_ref_frame_mvs) };
9302 use_ref_frame_mvs as u64
9303 });
9304 __bindgen_bitfield_unit.set(14usize, 1u8, {
9305 let disable_frame_end_update_cdf: u32 =
9306 unsafe { ::core::mem::transmute(disable_frame_end_update_cdf) };
9307 disable_frame_end_update_cdf as u64
9308 });
9309 __bindgen_bitfield_unit.set(15usize, 1u8, {
9310 let allow_warped_motion: u32 = unsafe { ::core::mem::transmute(allow_warped_motion) };
9311 allow_warped_motion as u64
9312 });
9313 __bindgen_bitfield_unit.set(16usize, 1u8, {
9314 let reduced_tx_set: u32 = unsafe { ::core::mem::transmute(reduced_tx_set) };
9315 reduced_tx_set as u64
9316 });
9317 __bindgen_bitfield_unit.set(17usize, 1u8, {
9318 let reference_select: u32 = unsafe { ::core::mem::transmute(reference_select) };
9319 reference_select as u64
9320 });
9321 __bindgen_bitfield_unit.set(18usize, 1u8, {
9322 let skip_mode_present: u32 = unsafe { ::core::mem::transmute(skip_mode_present) };
9323 skip_mode_present as u64
9324 });
9325 __bindgen_bitfield_unit.set(19usize, 1u8, {
9326 let delta_q_present: u32 = unsafe { ::core::mem::transmute(delta_q_present) };
9327 delta_q_present as u64
9328 });
9329 __bindgen_bitfield_unit.set(20usize, 1u8, {
9330 let delta_lf_present: u32 = unsafe { ::core::mem::transmute(delta_lf_present) };
9331 delta_lf_present as u64
9332 });
9333 __bindgen_bitfield_unit.set(21usize, 1u8, {
9334 let delta_lf_multi: u32 = unsafe { ::core::mem::transmute(delta_lf_multi) };
9335 delta_lf_multi as u64
9336 });
9337 __bindgen_bitfield_unit.set(22usize, 1u8, {
9338 let segmentation_enabled: u32 = unsafe { ::core::mem::transmute(segmentation_enabled) };
9339 segmentation_enabled as u64
9340 });
9341 __bindgen_bitfield_unit.set(23usize, 1u8, {
9342 let segmentation_update_map: u32 =
9343 unsafe { ::core::mem::transmute(segmentation_update_map) };
9344 segmentation_update_map as u64
9345 });
9346 __bindgen_bitfield_unit.set(24usize, 1u8, {
9347 let segmentation_temporal_update: u32 =
9348 unsafe { ::core::mem::transmute(segmentation_temporal_update) };
9349 segmentation_temporal_update as u64
9350 });
9351 __bindgen_bitfield_unit.set(25usize, 1u8, {
9352 let segmentation_update_data: u32 =
9353 unsafe { ::core::mem::transmute(segmentation_update_data) };
9354 segmentation_update_data as u64
9355 });
9356 __bindgen_bitfield_unit.set(26usize, 1u8, {
9357 let UsesLr: u32 = unsafe { ::core::mem::transmute(UsesLr) };
9358 UsesLr as u64
9359 });
9360 __bindgen_bitfield_unit.set(27usize, 1u8, {
9361 let usesChromaLr: u32 = unsafe { ::core::mem::transmute(usesChromaLr) };
9362 usesChromaLr as u64
9363 });
9364 __bindgen_bitfield_unit.set(28usize, 1u8, {
9365 let apply_grain: u32 = unsafe { ::core::mem::transmute(apply_grain) };
9366 apply_grain as u64
9367 });
9368 __bindgen_bitfield_unit.set(29usize, 3u8, {
9369 let reserved: u32 = unsafe { ::core::mem::transmute(reserved) };
9370 reserved as u64
9371 });
9372 __bindgen_bitfield_unit
9373 }
9374}
9375#[repr(C)]
9376#[derive(Debug, Copy, Clone)]
9377pub struct StdVideoDecodeAV1PictureInfo {
9378 pub flags: StdVideoDecodeAV1PictureInfoFlags,
9379 pub frame_type: StdVideoAV1FrameType,
9380 pub current_frame_id: u32,
9381 pub OrderHint: u8,
9382 pub primary_ref_frame: u8,
9383 pub refresh_frame_flags: u8,
9384 pub reserved1: u8,
9385 pub interpolation_filter: StdVideoAV1InterpolationFilter,
9386 pub TxMode: StdVideoAV1TxMode,
9387 pub delta_q_res: u8,
9388 pub delta_lf_res: u8,
9389 pub SkipModeFrame: [u8; 2usize],
9390 pub coded_denom: u8,
9391 pub reserved2: [u8; 3usize],
9392 pub OrderHints: [u8; 8usize],
9393 pub expectedFrameId: [u32; 8usize],
9394 pub pTileInfo: *const StdVideoAV1TileInfo,
9395 pub pQuantization: *const StdVideoAV1Quantization,
9396 pub pSegmentation: *const StdVideoAV1Segmentation,
9397 pub pLoopFilter: *const StdVideoAV1LoopFilter,
9398 pub pCDEF: *const StdVideoAV1CDEF,
9399 pub pLoopRestoration: *const StdVideoAV1LoopRestoration,
9400 pub pGlobalMotion: *const StdVideoAV1GlobalMotion,
9401 pub pFilmGrain: *const StdVideoAV1FilmGrain,
9402}
9403#[test]
9404fn bindgen_test_layout_StdVideoDecodeAV1PictureInfo() {
9405 const UNINIT: ::core::mem::MaybeUninit<StdVideoDecodeAV1PictureInfo> =
9406 ::core::mem::MaybeUninit::uninit();
9407 let ptr = UNINIT.as_ptr();
9408 assert_eq!(
9409 ::core::mem::size_of::<StdVideoDecodeAV1PictureInfo>(),
9410 136usize,
9411 concat!("Size of: ", stringify!(StdVideoDecodeAV1PictureInfo))
9412 );
9413 assert_eq!(
9414 ::core::mem::align_of::<StdVideoDecodeAV1PictureInfo>(),
9415 8usize,
9416 concat!("Alignment of ", stringify!(StdVideoDecodeAV1PictureInfo))
9417 );
9418 assert_eq!(
9419 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
9420 0usize,
9421 concat!(
9422 "Offset of field: ",
9423 stringify!(StdVideoDecodeAV1PictureInfo),
9424 "::",
9425 stringify!(flags)
9426 )
9427 );
9428 assert_eq!(
9429 unsafe { ::core::ptr::addr_of!((*ptr).frame_type) as usize - ptr as usize },
9430 4usize,
9431 concat!(
9432 "Offset of field: ",
9433 stringify!(StdVideoDecodeAV1PictureInfo),
9434 "::",
9435 stringify!(frame_type)
9436 )
9437 );
9438 assert_eq!(
9439 unsafe { ::core::ptr::addr_of!((*ptr).current_frame_id) as usize - ptr as usize },
9440 8usize,
9441 concat!(
9442 "Offset of field: ",
9443 stringify!(StdVideoDecodeAV1PictureInfo),
9444 "::",
9445 stringify!(current_frame_id)
9446 )
9447 );
9448 assert_eq!(
9449 unsafe { ::core::ptr::addr_of!((*ptr).OrderHint) as usize - ptr as usize },
9450 12usize,
9451 concat!(
9452 "Offset of field: ",
9453 stringify!(StdVideoDecodeAV1PictureInfo),
9454 "::",
9455 stringify!(OrderHint)
9456 )
9457 );
9458 assert_eq!(
9459 unsafe { ::core::ptr::addr_of!((*ptr).primary_ref_frame) as usize - ptr as usize },
9460 13usize,
9461 concat!(
9462 "Offset of field: ",
9463 stringify!(StdVideoDecodeAV1PictureInfo),
9464 "::",
9465 stringify!(primary_ref_frame)
9466 )
9467 );
9468 assert_eq!(
9469 unsafe { ::core::ptr::addr_of!((*ptr).refresh_frame_flags) as usize - ptr as usize },
9470 14usize,
9471 concat!(
9472 "Offset of field: ",
9473 stringify!(StdVideoDecodeAV1PictureInfo),
9474 "::",
9475 stringify!(refresh_frame_flags)
9476 )
9477 );
9478 assert_eq!(
9479 unsafe { ::core::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize },
9480 15usize,
9481 concat!(
9482 "Offset of field: ",
9483 stringify!(StdVideoDecodeAV1PictureInfo),
9484 "::",
9485 stringify!(reserved1)
9486 )
9487 );
9488 assert_eq!(
9489 unsafe { ::core::ptr::addr_of!((*ptr).interpolation_filter) as usize - ptr as usize },
9490 16usize,
9491 concat!(
9492 "Offset of field: ",
9493 stringify!(StdVideoDecodeAV1PictureInfo),
9494 "::",
9495 stringify!(interpolation_filter)
9496 )
9497 );
9498 assert_eq!(
9499 unsafe { ::core::ptr::addr_of!((*ptr).TxMode) as usize - ptr as usize },
9500 20usize,
9501 concat!(
9502 "Offset of field: ",
9503 stringify!(StdVideoDecodeAV1PictureInfo),
9504 "::",
9505 stringify!(TxMode)
9506 )
9507 );
9508 assert_eq!(
9509 unsafe { ::core::ptr::addr_of!((*ptr).delta_q_res) as usize - ptr as usize },
9510 24usize,
9511 concat!(
9512 "Offset of field: ",
9513 stringify!(StdVideoDecodeAV1PictureInfo),
9514 "::",
9515 stringify!(delta_q_res)
9516 )
9517 );
9518 assert_eq!(
9519 unsafe { ::core::ptr::addr_of!((*ptr).delta_lf_res) as usize - ptr as usize },
9520 25usize,
9521 concat!(
9522 "Offset of field: ",
9523 stringify!(StdVideoDecodeAV1PictureInfo),
9524 "::",
9525 stringify!(delta_lf_res)
9526 )
9527 );
9528 assert_eq!(
9529 unsafe { ::core::ptr::addr_of!((*ptr).SkipModeFrame) as usize - ptr as usize },
9530 26usize,
9531 concat!(
9532 "Offset of field: ",
9533 stringify!(StdVideoDecodeAV1PictureInfo),
9534 "::",
9535 stringify!(SkipModeFrame)
9536 )
9537 );
9538 assert_eq!(
9539 unsafe { ::core::ptr::addr_of!((*ptr).coded_denom) as usize - ptr as usize },
9540 28usize,
9541 concat!(
9542 "Offset of field: ",
9543 stringify!(StdVideoDecodeAV1PictureInfo),
9544 "::",
9545 stringify!(coded_denom)
9546 )
9547 );
9548 assert_eq!(
9549 unsafe { ::core::ptr::addr_of!((*ptr).reserved2) as usize - ptr as usize },
9550 29usize,
9551 concat!(
9552 "Offset of field: ",
9553 stringify!(StdVideoDecodeAV1PictureInfo),
9554 "::",
9555 stringify!(reserved2)
9556 )
9557 );
9558 assert_eq!(
9559 unsafe { ::core::ptr::addr_of!((*ptr).OrderHints) as usize - ptr as usize },
9560 32usize,
9561 concat!(
9562 "Offset of field: ",
9563 stringify!(StdVideoDecodeAV1PictureInfo),
9564 "::",
9565 stringify!(OrderHints)
9566 )
9567 );
9568 assert_eq!(
9569 unsafe { ::core::ptr::addr_of!((*ptr).expectedFrameId) as usize - ptr as usize },
9570 40usize,
9571 concat!(
9572 "Offset of field: ",
9573 stringify!(StdVideoDecodeAV1PictureInfo),
9574 "::",
9575 stringify!(expectedFrameId)
9576 )
9577 );
9578 assert_eq!(
9579 unsafe { ::core::ptr::addr_of!((*ptr).pTileInfo) as usize - ptr as usize },
9580 72usize,
9581 concat!(
9582 "Offset of field: ",
9583 stringify!(StdVideoDecodeAV1PictureInfo),
9584 "::",
9585 stringify!(pTileInfo)
9586 )
9587 );
9588 assert_eq!(
9589 unsafe { ::core::ptr::addr_of!((*ptr).pQuantization) as usize - ptr as usize },
9590 80usize,
9591 concat!(
9592 "Offset of field: ",
9593 stringify!(StdVideoDecodeAV1PictureInfo),
9594 "::",
9595 stringify!(pQuantization)
9596 )
9597 );
9598 assert_eq!(
9599 unsafe { ::core::ptr::addr_of!((*ptr).pSegmentation) as usize - ptr as usize },
9600 88usize,
9601 concat!(
9602 "Offset of field: ",
9603 stringify!(StdVideoDecodeAV1PictureInfo),
9604 "::",
9605 stringify!(pSegmentation)
9606 )
9607 );
9608 assert_eq!(
9609 unsafe { ::core::ptr::addr_of!((*ptr).pLoopFilter) as usize - ptr as usize },
9610 96usize,
9611 concat!(
9612 "Offset of field: ",
9613 stringify!(StdVideoDecodeAV1PictureInfo),
9614 "::",
9615 stringify!(pLoopFilter)
9616 )
9617 );
9618 assert_eq!(
9619 unsafe { ::core::ptr::addr_of!((*ptr).pCDEF) as usize - ptr as usize },
9620 104usize,
9621 concat!(
9622 "Offset of field: ",
9623 stringify!(StdVideoDecodeAV1PictureInfo),
9624 "::",
9625 stringify!(pCDEF)
9626 )
9627 );
9628 assert_eq!(
9629 unsafe { ::core::ptr::addr_of!((*ptr).pLoopRestoration) as usize - ptr as usize },
9630 112usize,
9631 concat!(
9632 "Offset of field: ",
9633 stringify!(StdVideoDecodeAV1PictureInfo),
9634 "::",
9635 stringify!(pLoopRestoration)
9636 )
9637 );
9638 assert_eq!(
9639 unsafe { ::core::ptr::addr_of!((*ptr).pGlobalMotion) as usize - ptr as usize },
9640 120usize,
9641 concat!(
9642 "Offset of field: ",
9643 stringify!(StdVideoDecodeAV1PictureInfo),
9644 "::",
9645 stringify!(pGlobalMotion)
9646 )
9647 );
9648 assert_eq!(
9649 unsafe { ::core::ptr::addr_of!((*ptr).pFilmGrain) as usize - ptr as usize },
9650 128usize,
9651 concat!(
9652 "Offset of field: ",
9653 stringify!(StdVideoDecodeAV1PictureInfo),
9654 "::",
9655 stringify!(pFilmGrain)
9656 )
9657 );
9658}
9659#[repr(C)]
9660#[derive(Debug, Copy, Clone)]
9661pub struct StdVideoDecodeAV1ReferenceInfoFlags {
9662 pub _bitfield_align_1: [u32; 0],
9663 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
9664}
9665#[test]
9666fn bindgen_test_layout_StdVideoDecodeAV1ReferenceInfoFlags() {
9667 assert_eq!(
9668 ::core::mem::size_of::<StdVideoDecodeAV1ReferenceInfoFlags>(),
9669 4usize,
9670 concat!("Size of: ", stringify!(StdVideoDecodeAV1ReferenceInfoFlags))
9671 );
9672 assert_eq!(
9673 ::core::mem::align_of::<StdVideoDecodeAV1ReferenceInfoFlags>(),
9674 4usize,
9675 concat!(
9676 "Alignment of ",
9677 stringify!(StdVideoDecodeAV1ReferenceInfoFlags)
9678 )
9679 );
9680}
9681impl StdVideoDecodeAV1ReferenceInfoFlags {
9682 #[inline]
9683 pub fn disable_frame_end_update_cdf(&self) -> u32 {
9684 unsafe { ::core::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
9685 }
9686 #[inline]
9687 pub fn set_disable_frame_end_update_cdf(&mut self, val: u32) {
9688 unsafe {
9689 let val: u32 = ::core::mem::transmute(val);
9690 self._bitfield_1.set(0usize, 1u8, val as u64)
9691 }
9692 }
9693 #[inline]
9694 pub fn segmentation_enabled(&self) -> u32 {
9695 unsafe { ::core::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
9696 }
9697 #[inline]
9698 pub fn set_segmentation_enabled(&mut self, val: u32) {
9699 unsafe {
9700 let val: u32 = ::core::mem::transmute(val);
9701 self._bitfield_1.set(1usize, 1u8, val as u64)
9702 }
9703 }
9704 #[inline]
9705 pub fn reserved(&self) -> u32 {
9706 unsafe { ::core::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) }
9707 }
9708 #[inline]
9709 pub fn set_reserved(&mut self, val: u32) {
9710 unsafe {
9711 let val: u32 = ::core::mem::transmute(val);
9712 self._bitfield_1.set(2usize, 30u8, val as u64)
9713 }
9714 }
9715 #[inline]
9716 pub fn new_bitfield_1(
9717 disable_frame_end_update_cdf: u32,
9718 segmentation_enabled: u32,
9719 reserved: u32,
9720 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
9721 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
9722 __bindgen_bitfield_unit.set(0usize, 1u8, {
9723 let disable_frame_end_update_cdf: u32 =
9724 unsafe { ::core::mem::transmute(disable_frame_end_update_cdf) };
9725 disable_frame_end_update_cdf as u64
9726 });
9727 __bindgen_bitfield_unit.set(1usize, 1u8, {
9728 let segmentation_enabled: u32 = unsafe { ::core::mem::transmute(segmentation_enabled) };
9729 segmentation_enabled as u64
9730 });
9731 __bindgen_bitfield_unit.set(2usize, 30u8, {
9732 let reserved: u32 = unsafe { ::core::mem::transmute(reserved) };
9733 reserved as u64
9734 });
9735 __bindgen_bitfield_unit
9736 }
9737}
9738#[repr(C)]
9739#[derive(Debug, Copy, Clone)]
9740pub struct StdVideoDecodeAV1ReferenceInfo {
9741 pub flags: StdVideoDecodeAV1ReferenceInfoFlags,
9742 pub frame_type: u8,
9743 pub RefFrameSignBias: u8,
9744 pub OrderHint: u8,
9745 pub SavedOrderHints: [u8; 8usize],
9746}
9747#[test]
9748fn bindgen_test_layout_StdVideoDecodeAV1ReferenceInfo() {
9749 const UNINIT: ::core::mem::MaybeUninit<StdVideoDecodeAV1ReferenceInfo> =
9750 ::core::mem::MaybeUninit::uninit();
9751 let ptr = UNINIT.as_ptr();
9752 assert_eq!(
9753 ::core::mem::size_of::<StdVideoDecodeAV1ReferenceInfo>(),
9754 16usize,
9755 concat!("Size of: ", stringify!(StdVideoDecodeAV1ReferenceInfo))
9756 );
9757 assert_eq!(
9758 ::core::mem::align_of::<StdVideoDecodeAV1ReferenceInfo>(),
9759 4usize,
9760 concat!("Alignment of ", stringify!(StdVideoDecodeAV1ReferenceInfo))
9761 );
9762 assert_eq!(
9763 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
9764 0usize,
9765 concat!(
9766 "Offset of field: ",
9767 stringify!(StdVideoDecodeAV1ReferenceInfo),
9768 "::",
9769 stringify!(flags)
9770 )
9771 );
9772 assert_eq!(
9773 unsafe { ::core::ptr::addr_of!((*ptr).frame_type) as usize - ptr as usize },
9774 4usize,
9775 concat!(
9776 "Offset of field: ",
9777 stringify!(StdVideoDecodeAV1ReferenceInfo),
9778 "::",
9779 stringify!(frame_type)
9780 )
9781 );
9782 assert_eq!(
9783 unsafe { ::core::ptr::addr_of!((*ptr).RefFrameSignBias) as usize - ptr as usize },
9784 5usize,
9785 concat!(
9786 "Offset of field: ",
9787 stringify!(StdVideoDecodeAV1ReferenceInfo),
9788 "::",
9789 stringify!(RefFrameSignBias)
9790 )
9791 );
9792 assert_eq!(
9793 unsafe { ::core::ptr::addr_of!((*ptr).OrderHint) as usize - ptr as usize },
9794 6usize,
9795 concat!(
9796 "Offset of field: ",
9797 stringify!(StdVideoDecodeAV1ReferenceInfo),
9798 "::",
9799 stringify!(OrderHint)
9800 )
9801 );
9802 assert_eq!(
9803 unsafe { ::core::ptr::addr_of!((*ptr).SavedOrderHints) as usize - ptr as usize },
9804 7usize,
9805 concat!(
9806 "Offset of field: ",
9807 stringify!(StdVideoDecodeAV1ReferenceInfo),
9808 "::",
9809 stringify!(SavedOrderHints)
9810 )
9811 );
9812}
9813#[repr(C)]
9814#[derive(Debug, Copy, Clone)]
9815pub struct StdVideoEncodeH264WeightTableFlags {
9816 pub luma_weight_l0_flag: u32,
9817 pub chroma_weight_l0_flag: u32,
9818 pub luma_weight_l1_flag: u32,
9819 pub chroma_weight_l1_flag: u32,
9820}
9821#[test]
9822fn bindgen_test_layout_StdVideoEncodeH264WeightTableFlags() {
9823 const UNINIT: ::core::mem::MaybeUninit<StdVideoEncodeH264WeightTableFlags> =
9824 ::core::mem::MaybeUninit::uninit();
9825 let ptr = UNINIT.as_ptr();
9826 assert_eq!(
9827 ::core::mem::size_of::<StdVideoEncodeH264WeightTableFlags>(),
9828 16usize,
9829 concat!("Size of: ", stringify!(StdVideoEncodeH264WeightTableFlags))
9830 );
9831 assert_eq!(
9832 ::core::mem::align_of::<StdVideoEncodeH264WeightTableFlags>(),
9833 4usize,
9834 concat!(
9835 "Alignment of ",
9836 stringify!(StdVideoEncodeH264WeightTableFlags)
9837 )
9838 );
9839 assert_eq!(
9840 unsafe { ::core::ptr::addr_of!((*ptr).luma_weight_l0_flag) as usize - ptr as usize },
9841 0usize,
9842 concat!(
9843 "Offset of field: ",
9844 stringify!(StdVideoEncodeH264WeightTableFlags),
9845 "::",
9846 stringify!(luma_weight_l0_flag)
9847 )
9848 );
9849 assert_eq!(
9850 unsafe { ::core::ptr::addr_of!((*ptr).chroma_weight_l0_flag) as usize - ptr as usize },
9851 4usize,
9852 concat!(
9853 "Offset of field: ",
9854 stringify!(StdVideoEncodeH264WeightTableFlags),
9855 "::",
9856 stringify!(chroma_weight_l0_flag)
9857 )
9858 );
9859 assert_eq!(
9860 unsafe { ::core::ptr::addr_of!((*ptr).luma_weight_l1_flag) as usize - ptr as usize },
9861 8usize,
9862 concat!(
9863 "Offset of field: ",
9864 stringify!(StdVideoEncodeH264WeightTableFlags),
9865 "::",
9866 stringify!(luma_weight_l1_flag)
9867 )
9868 );
9869 assert_eq!(
9870 unsafe { ::core::ptr::addr_of!((*ptr).chroma_weight_l1_flag) as usize - ptr as usize },
9871 12usize,
9872 concat!(
9873 "Offset of field: ",
9874 stringify!(StdVideoEncodeH264WeightTableFlags),
9875 "::",
9876 stringify!(chroma_weight_l1_flag)
9877 )
9878 );
9879}
9880#[repr(C)]
9881#[derive(Debug, Copy, Clone)]
9882pub struct StdVideoEncodeH264WeightTable {
9883 pub flags: StdVideoEncodeH264WeightTableFlags,
9884 pub luma_log2_weight_denom: u8,
9885 pub chroma_log2_weight_denom: u8,
9886 pub luma_weight_l0: [i8; 32usize],
9887 pub luma_offset_l0: [i8; 32usize],
9888 pub chroma_weight_l0: [[i8; 2usize]; 32usize],
9889 pub chroma_offset_l0: [[i8; 2usize]; 32usize],
9890 pub luma_weight_l1: [i8; 32usize],
9891 pub luma_offset_l1: [i8; 32usize],
9892 pub chroma_weight_l1: [[i8; 2usize]; 32usize],
9893 pub chroma_offset_l1: [[i8; 2usize]; 32usize],
9894}
9895#[test]
9896fn bindgen_test_layout_StdVideoEncodeH264WeightTable() {
9897 const UNINIT: ::core::mem::MaybeUninit<StdVideoEncodeH264WeightTable> =
9898 ::core::mem::MaybeUninit::uninit();
9899 let ptr = UNINIT.as_ptr();
9900 assert_eq!(
9901 ::core::mem::size_of::<StdVideoEncodeH264WeightTable>(),
9902 404usize,
9903 concat!("Size of: ", stringify!(StdVideoEncodeH264WeightTable))
9904 );
9905 assert_eq!(
9906 ::core::mem::align_of::<StdVideoEncodeH264WeightTable>(),
9907 4usize,
9908 concat!("Alignment of ", stringify!(StdVideoEncodeH264WeightTable))
9909 );
9910 assert_eq!(
9911 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
9912 0usize,
9913 concat!(
9914 "Offset of field: ",
9915 stringify!(StdVideoEncodeH264WeightTable),
9916 "::",
9917 stringify!(flags)
9918 )
9919 );
9920 assert_eq!(
9921 unsafe { ::core::ptr::addr_of!((*ptr).luma_log2_weight_denom) as usize - ptr as usize },
9922 16usize,
9923 concat!(
9924 "Offset of field: ",
9925 stringify!(StdVideoEncodeH264WeightTable),
9926 "::",
9927 stringify!(luma_log2_weight_denom)
9928 )
9929 );
9930 assert_eq!(
9931 unsafe { ::core::ptr::addr_of!((*ptr).chroma_log2_weight_denom) as usize - ptr as usize },
9932 17usize,
9933 concat!(
9934 "Offset of field: ",
9935 stringify!(StdVideoEncodeH264WeightTable),
9936 "::",
9937 stringify!(chroma_log2_weight_denom)
9938 )
9939 );
9940 assert_eq!(
9941 unsafe { ::core::ptr::addr_of!((*ptr).luma_weight_l0) as usize - ptr as usize },
9942 18usize,
9943 concat!(
9944 "Offset of field: ",
9945 stringify!(StdVideoEncodeH264WeightTable),
9946 "::",
9947 stringify!(luma_weight_l0)
9948 )
9949 );
9950 assert_eq!(
9951 unsafe { ::core::ptr::addr_of!((*ptr).luma_offset_l0) as usize - ptr as usize },
9952 50usize,
9953 concat!(
9954 "Offset of field: ",
9955 stringify!(StdVideoEncodeH264WeightTable),
9956 "::",
9957 stringify!(luma_offset_l0)
9958 )
9959 );
9960 assert_eq!(
9961 unsafe { ::core::ptr::addr_of!((*ptr).chroma_weight_l0) as usize - ptr as usize },
9962 82usize,
9963 concat!(
9964 "Offset of field: ",
9965 stringify!(StdVideoEncodeH264WeightTable),
9966 "::",
9967 stringify!(chroma_weight_l0)
9968 )
9969 );
9970 assert_eq!(
9971 unsafe { ::core::ptr::addr_of!((*ptr).chroma_offset_l0) as usize - ptr as usize },
9972 146usize,
9973 concat!(
9974 "Offset of field: ",
9975 stringify!(StdVideoEncodeH264WeightTable),
9976 "::",
9977 stringify!(chroma_offset_l0)
9978 )
9979 );
9980 assert_eq!(
9981 unsafe { ::core::ptr::addr_of!((*ptr).luma_weight_l1) as usize - ptr as usize },
9982 210usize,
9983 concat!(
9984 "Offset of field: ",
9985 stringify!(StdVideoEncodeH264WeightTable),
9986 "::",
9987 stringify!(luma_weight_l1)
9988 )
9989 );
9990 assert_eq!(
9991 unsafe { ::core::ptr::addr_of!((*ptr).luma_offset_l1) as usize - ptr as usize },
9992 242usize,
9993 concat!(
9994 "Offset of field: ",
9995 stringify!(StdVideoEncodeH264WeightTable),
9996 "::",
9997 stringify!(luma_offset_l1)
9998 )
9999 );
10000 assert_eq!(
10001 unsafe { ::core::ptr::addr_of!((*ptr).chroma_weight_l1) as usize - ptr as usize },
10002 274usize,
10003 concat!(
10004 "Offset of field: ",
10005 stringify!(StdVideoEncodeH264WeightTable),
10006 "::",
10007 stringify!(chroma_weight_l1)
10008 )
10009 );
10010 assert_eq!(
10011 unsafe { ::core::ptr::addr_of!((*ptr).chroma_offset_l1) as usize - ptr as usize },
10012 338usize,
10013 concat!(
10014 "Offset of field: ",
10015 stringify!(StdVideoEncodeH264WeightTable),
10016 "::",
10017 stringify!(chroma_offset_l1)
10018 )
10019 );
10020}
10021#[repr(C)]
10022#[derive(Debug, Copy, Clone)]
10023pub struct StdVideoEncodeH264SliceHeaderFlags {
10024 pub _bitfield_align_1: [u32; 0],
10025 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
10026}
10027#[test]
10028fn bindgen_test_layout_StdVideoEncodeH264SliceHeaderFlags() {
10029 assert_eq!(
10030 ::core::mem::size_of::<StdVideoEncodeH264SliceHeaderFlags>(),
10031 4usize,
10032 concat!("Size of: ", stringify!(StdVideoEncodeH264SliceHeaderFlags))
10033 );
10034 assert_eq!(
10035 ::core::mem::align_of::<StdVideoEncodeH264SliceHeaderFlags>(),
10036 4usize,
10037 concat!(
10038 "Alignment of ",
10039 stringify!(StdVideoEncodeH264SliceHeaderFlags)
10040 )
10041 );
10042}
10043impl StdVideoEncodeH264SliceHeaderFlags {
10044 #[inline]
10045 pub fn direct_spatial_mv_pred_flag(&self) -> u32 {
10046 unsafe { ::core::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
10047 }
10048 #[inline]
10049 pub fn set_direct_spatial_mv_pred_flag(&mut self, val: u32) {
10050 unsafe {
10051 let val: u32 = ::core::mem::transmute(val);
10052 self._bitfield_1.set(0usize, 1u8, val as u64)
10053 }
10054 }
10055 #[inline]
10056 pub fn num_ref_idx_active_override_flag(&self) -> u32 {
10057 unsafe { ::core::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
10058 }
10059 #[inline]
10060 pub fn set_num_ref_idx_active_override_flag(&mut self, val: u32) {
10061 unsafe {
10062 let val: u32 = ::core::mem::transmute(val);
10063 self._bitfield_1.set(1usize, 1u8, val as u64)
10064 }
10065 }
10066 #[inline]
10067 pub fn reserved(&self) -> u32 {
10068 unsafe { ::core::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) }
10069 }
10070 #[inline]
10071 pub fn set_reserved(&mut self, val: u32) {
10072 unsafe {
10073 let val: u32 = ::core::mem::transmute(val);
10074 self._bitfield_1.set(2usize, 30u8, val as u64)
10075 }
10076 }
10077 #[inline]
10078 pub fn new_bitfield_1(
10079 direct_spatial_mv_pred_flag: u32,
10080 num_ref_idx_active_override_flag: u32,
10081 reserved: u32,
10082 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
10083 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
10084 __bindgen_bitfield_unit.set(0usize, 1u8, {
10085 let direct_spatial_mv_pred_flag: u32 =
10086 unsafe { ::core::mem::transmute(direct_spatial_mv_pred_flag) };
10087 direct_spatial_mv_pred_flag as u64
10088 });
10089 __bindgen_bitfield_unit.set(1usize, 1u8, {
10090 let num_ref_idx_active_override_flag: u32 =
10091 unsafe { ::core::mem::transmute(num_ref_idx_active_override_flag) };
10092 num_ref_idx_active_override_flag as u64
10093 });
10094 __bindgen_bitfield_unit.set(2usize, 30u8, {
10095 let reserved: u32 = unsafe { ::core::mem::transmute(reserved) };
10096 reserved as u64
10097 });
10098 __bindgen_bitfield_unit
10099 }
10100}
10101#[repr(C)]
10102#[derive(Debug, Copy, Clone)]
10103pub struct StdVideoEncodeH264PictureInfoFlags {
10104 pub _bitfield_align_1: [u32; 0],
10105 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
10106}
10107#[test]
10108fn bindgen_test_layout_StdVideoEncodeH264PictureInfoFlags() {
10109 assert_eq!(
10110 ::core::mem::size_of::<StdVideoEncodeH264PictureInfoFlags>(),
10111 4usize,
10112 concat!("Size of: ", stringify!(StdVideoEncodeH264PictureInfoFlags))
10113 );
10114 assert_eq!(
10115 ::core::mem::align_of::<StdVideoEncodeH264PictureInfoFlags>(),
10116 4usize,
10117 concat!(
10118 "Alignment of ",
10119 stringify!(StdVideoEncodeH264PictureInfoFlags)
10120 )
10121 );
10122}
10123impl StdVideoEncodeH264PictureInfoFlags {
10124 #[inline]
10125 pub fn IdrPicFlag(&self) -> u32 {
10126 unsafe { ::core::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
10127 }
10128 #[inline]
10129 pub fn set_IdrPicFlag(&mut self, val: u32) {
10130 unsafe {
10131 let val: u32 = ::core::mem::transmute(val);
10132 self._bitfield_1.set(0usize, 1u8, val as u64)
10133 }
10134 }
10135 #[inline]
10136 pub fn is_reference(&self) -> u32 {
10137 unsafe { ::core::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
10138 }
10139 #[inline]
10140 pub fn set_is_reference(&mut self, val: u32) {
10141 unsafe {
10142 let val: u32 = ::core::mem::transmute(val);
10143 self._bitfield_1.set(1usize, 1u8, val as u64)
10144 }
10145 }
10146 #[inline]
10147 pub fn no_output_of_prior_pics_flag(&self) -> u32 {
10148 unsafe { ::core::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
10149 }
10150 #[inline]
10151 pub fn set_no_output_of_prior_pics_flag(&mut self, val: u32) {
10152 unsafe {
10153 let val: u32 = ::core::mem::transmute(val);
10154 self._bitfield_1.set(2usize, 1u8, val as u64)
10155 }
10156 }
10157 #[inline]
10158 pub fn long_term_reference_flag(&self) -> u32 {
10159 unsafe { ::core::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
10160 }
10161 #[inline]
10162 pub fn set_long_term_reference_flag(&mut self, val: u32) {
10163 unsafe {
10164 let val: u32 = ::core::mem::transmute(val);
10165 self._bitfield_1.set(3usize, 1u8, val as u64)
10166 }
10167 }
10168 #[inline]
10169 pub fn adaptive_ref_pic_marking_mode_flag(&self) -> u32 {
10170 unsafe { ::core::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
10171 }
10172 #[inline]
10173 pub fn set_adaptive_ref_pic_marking_mode_flag(&mut self, val: u32) {
10174 unsafe {
10175 let val: u32 = ::core::mem::transmute(val);
10176 self._bitfield_1.set(4usize, 1u8, val as u64)
10177 }
10178 }
10179 #[inline]
10180 pub fn reserved(&self) -> u32 {
10181 unsafe { ::core::mem::transmute(self._bitfield_1.get(5usize, 27u8) as u32) }
10182 }
10183 #[inline]
10184 pub fn set_reserved(&mut self, val: u32) {
10185 unsafe {
10186 let val: u32 = ::core::mem::transmute(val);
10187 self._bitfield_1.set(5usize, 27u8, val as u64)
10188 }
10189 }
10190 #[inline]
10191 pub fn new_bitfield_1(
10192 IdrPicFlag: u32,
10193 is_reference: u32,
10194 no_output_of_prior_pics_flag: u32,
10195 long_term_reference_flag: u32,
10196 adaptive_ref_pic_marking_mode_flag: u32,
10197 reserved: u32,
10198 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
10199 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
10200 __bindgen_bitfield_unit.set(0usize, 1u8, {
10201 let IdrPicFlag: u32 = unsafe { ::core::mem::transmute(IdrPicFlag) };
10202 IdrPicFlag as u64
10203 });
10204 __bindgen_bitfield_unit.set(1usize, 1u8, {
10205 let is_reference: u32 = unsafe { ::core::mem::transmute(is_reference) };
10206 is_reference as u64
10207 });
10208 __bindgen_bitfield_unit.set(2usize, 1u8, {
10209 let no_output_of_prior_pics_flag: u32 =
10210 unsafe { ::core::mem::transmute(no_output_of_prior_pics_flag) };
10211 no_output_of_prior_pics_flag as u64
10212 });
10213 __bindgen_bitfield_unit.set(3usize, 1u8, {
10214 let long_term_reference_flag: u32 =
10215 unsafe { ::core::mem::transmute(long_term_reference_flag) };
10216 long_term_reference_flag as u64
10217 });
10218 __bindgen_bitfield_unit.set(4usize, 1u8, {
10219 let adaptive_ref_pic_marking_mode_flag: u32 =
10220 unsafe { ::core::mem::transmute(adaptive_ref_pic_marking_mode_flag) };
10221 adaptive_ref_pic_marking_mode_flag as u64
10222 });
10223 __bindgen_bitfield_unit.set(5usize, 27u8, {
10224 let reserved: u32 = unsafe { ::core::mem::transmute(reserved) };
10225 reserved as u64
10226 });
10227 __bindgen_bitfield_unit
10228 }
10229}
10230#[repr(C)]
10231#[derive(Debug, Copy, Clone)]
10232pub struct StdVideoEncodeH264ReferenceInfoFlags {
10233 pub _bitfield_align_1: [u32; 0],
10234 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
10235}
10236#[test]
10237fn bindgen_test_layout_StdVideoEncodeH264ReferenceInfoFlags() {
10238 assert_eq!(
10239 ::core::mem::size_of::<StdVideoEncodeH264ReferenceInfoFlags>(),
10240 4usize,
10241 concat!(
10242 "Size of: ",
10243 stringify!(StdVideoEncodeH264ReferenceInfoFlags)
10244 )
10245 );
10246 assert_eq!(
10247 ::core::mem::align_of::<StdVideoEncodeH264ReferenceInfoFlags>(),
10248 4usize,
10249 concat!(
10250 "Alignment of ",
10251 stringify!(StdVideoEncodeH264ReferenceInfoFlags)
10252 )
10253 );
10254}
10255impl StdVideoEncodeH264ReferenceInfoFlags {
10256 #[inline]
10257 pub fn used_for_long_term_reference(&self) -> u32 {
10258 unsafe { ::core::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
10259 }
10260 #[inline]
10261 pub fn set_used_for_long_term_reference(&mut self, val: u32) {
10262 unsafe {
10263 let val: u32 = ::core::mem::transmute(val);
10264 self._bitfield_1.set(0usize, 1u8, val as u64)
10265 }
10266 }
10267 #[inline]
10268 pub fn reserved(&self) -> u32 {
10269 unsafe { ::core::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) }
10270 }
10271 #[inline]
10272 pub fn set_reserved(&mut self, val: u32) {
10273 unsafe {
10274 let val: u32 = ::core::mem::transmute(val);
10275 self._bitfield_1.set(1usize, 31u8, val as u64)
10276 }
10277 }
10278 #[inline]
10279 pub fn new_bitfield_1(
10280 used_for_long_term_reference: u32,
10281 reserved: u32,
10282 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
10283 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
10284 __bindgen_bitfield_unit.set(0usize, 1u8, {
10285 let used_for_long_term_reference: u32 =
10286 unsafe { ::core::mem::transmute(used_for_long_term_reference) };
10287 used_for_long_term_reference as u64
10288 });
10289 __bindgen_bitfield_unit.set(1usize, 31u8, {
10290 let reserved: u32 = unsafe { ::core::mem::transmute(reserved) };
10291 reserved as u64
10292 });
10293 __bindgen_bitfield_unit
10294 }
10295}
10296#[repr(C)]
10297#[derive(Debug, Copy, Clone)]
10298pub struct StdVideoEncodeH264ReferenceListsInfoFlags {
10299 pub _bitfield_align_1: [u32; 0],
10300 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
10301}
10302#[test]
10303fn bindgen_test_layout_StdVideoEncodeH264ReferenceListsInfoFlags() {
10304 assert_eq!(
10305 ::core::mem::size_of::<StdVideoEncodeH264ReferenceListsInfoFlags>(),
10306 4usize,
10307 concat!(
10308 "Size of: ",
10309 stringify!(StdVideoEncodeH264ReferenceListsInfoFlags)
10310 )
10311 );
10312 assert_eq!(
10313 ::core::mem::align_of::<StdVideoEncodeH264ReferenceListsInfoFlags>(),
10314 4usize,
10315 concat!(
10316 "Alignment of ",
10317 stringify!(StdVideoEncodeH264ReferenceListsInfoFlags)
10318 )
10319 );
10320}
10321impl StdVideoEncodeH264ReferenceListsInfoFlags {
10322 #[inline]
10323 pub fn ref_pic_list_modification_flag_l0(&self) -> u32 {
10324 unsafe { ::core::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
10325 }
10326 #[inline]
10327 pub fn set_ref_pic_list_modification_flag_l0(&mut self, val: u32) {
10328 unsafe {
10329 let val: u32 = ::core::mem::transmute(val);
10330 self._bitfield_1.set(0usize, 1u8, val as u64)
10331 }
10332 }
10333 #[inline]
10334 pub fn ref_pic_list_modification_flag_l1(&self) -> u32 {
10335 unsafe { ::core::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
10336 }
10337 #[inline]
10338 pub fn set_ref_pic_list_modification_flag_l1(&mut self, val: u32) {
10339 unsafe {
10340 let val: u32 = ::core::mem::transmute(val);
10341 self._bitfield_1.set(1usize, 1u8, val as u64)
10342 }
10343 }
10344 #[inline]
10345 pub fn reserved(&self) -> u32 {
10346 unsafe { ::core::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) }
10347 }
10348 #[inline]
10349 pub fn set_reserved(&mut self, val: u32) {
10350 unsafe {
10351 let val: u32 = ::core::mem::transmute(val);
10352 self._bitfield_1.set(2usize, 30u8, val as u64)
10353 }
10354 }
10355 #[inline]
10356 pub fn new_bitfield_1(
10357 ref_pic_list_modification_flag_l0: u32,
10358 ref_pic_list_modification_flag_l1: u32,
10359 reserved: u32,
10360 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
10361 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
10362 __bindgen_bitfield_unit.set(0usize, 1u8, {
10363 let ref_pic_list_modification_flag_l0: u32 =
10364 unsafe { ::core::mem::transmute(ref_pic_list_modification_flag_l0) };
10365 ref_pic_list_modification_flag_l0 as u64
10366 });
10367 __bindgen_bitfield_unit.set(1usize, 1u8, {
10368 let ref_pic_list_modification_flag_l1: u32 =
10369 unsafe { ::core::mem::transmute(ref_pic_list_modification_flag_l1) };
10370 ref_pic_list_modification_flag_l1 as u64
10371 });
10372 __bindgen_bitfield_unit.set(2usize, 30u8, {
10373 let reserved: u32 = unsafe { ::core::mem::transmute(reserved) };
10374 reserved as u64
10375 });
10376 __bindgen_bitfield_unit
10377 }
10378}
10379#[repr(C)]
10380#[derive(Debug, Copy, Clone)]
10381pub struct StdVideoEncodeH264RefListModEntry {
10382 pub modification_of_pic_nums_idc: StdVideoH264ModificationOfPicNumsIdc,
10383 pub abs_diff_pic_num_minus1: u16,
10384 pub long_term_pic_num: u16,
10385}
10386#[test]
10387fn bindgen_test_layout_StdVideoEncodeH264RefListModEntry() {
10388 const UNINIT: ::core::mem::MaybeUninit<StdVideoEncodeH264RefListModEntry> =
10389 ::core::mem::MaybeUninit::uninit();
10390 let ptr = UNINIT.as_ptr();
10391 assert_eq!(
10392 ::core::mem::size_of::<StdVideoEncodeH264RefListModEntry>(),
10393 8usize,
10394 concat!("Size of: ", stringify!(StdVideoEncodeH264RefListModEntry))
10395 );
10396 assert_eq!(
10397 ::core::mem::align_of::<StdVideoEncodeH264RefListModEntry>(),
10398 4usize,
10399 concat!(
10400 "Alignment of ",
10401 stringify!(StdVideoEncodeH264RefListModEntry)
10402 )
10403 );
10404 assert_eq!(
10405 unsafe {
10406 ::core::ptr::addr_of!((*ptr).modification_of_pic_nums_idc) as usize - ptr as usize
10407 },
10408 0usize,
10409 concat!(
10410 "Offset of field: ",
10411 stringify!(StdVideoEncodeH264RefListModEntry),
10412 "::",
10413 stringify!(modification_of_pic_nums_idc)
10414 )
10415 );
10416 assert_eq!(
10417 unsafe { ::core::ptr::addr_of!((*ptr).abs_diff_pic_num_minus1) as usize - ptr as usize },
10418 4usize,
10419 concat!(
10420 "Offset of field: ",
10421 stringify!(StdVideoEncodeH264RefListModEntry),
10422 "::",
10423 stringify!(abs_diff_pic_num_minus1)
10424 )
10425 );
10426 assert_eq!(
10427 unsafe { ::core::ptr::addr_of!((*ptr).long_term_pic_num) as usize - ptr as usize },
10428 6usize,
10429 concat!(
10430 "Offset of field: ",
10431 stringify!(StdVideoEncodeH264RefListModEntry),
10432 "::",
10433 stringify!(long_term_pic_num)
10434 )
10435 );
10436}
10437#[repr(C)]
10438#[derive(Debug, Copy, Clone)]
10439pub struct StdVideoEncodeH264RefPicMarkingEntry {
10440 pub memory_management_control_operation: StdVideoH264MemMgmtControlOp,
10441 pub difference_of_pic_nums_minus1: u16,
10442 pub long_term_pic_num: u16,
10443 pub long_term_frame_idx: u16,
10444 pub max_long_term_frame_idx_plus1: u16,
10445}
10446#[test]
10447fn bindgen_test_layout_StdVideoEncodeH264RefPicMarkingEntry() {
10448 const UNINIT: ::core::mem::MaybeUninit<StdVideoEncodeH264RefPicMarkingEntry> =
10449 ::core::mem::MaybeUninit::uninit();
10450 let ptr = UNINIT.as_ptr();
10451 assert_eq!(
10452 ::core::mem::size_of::<StdVideoEncodeH264RefPicMarkingEntry>(),
10453 12usize,
10454 concat!(
10455 "Size of: ",
10456 stringify!(StdVideoEncodeH264RefPicMarkingEntry)
10457 )
10458 );
10459 assert_eq!(
10460 ::core::mem::align_of::<StdVideoEncodeH264RefPicMarkingEntry>(),
10461 4usize,
10462 concat!(
10463 "Alignment of ",
10464 stringify!(StdVideoEncodeH264RefPicMarkingEntry)
10465 )
10466 );
10467 assert_eq!(
10468 unsafe {
10469 ::core::ptr::addr_of!((*ptr).memory_management_control_operation) as usize
10470 - ptr as usize
10471 },
10472 0usize,
10473 concat!(
10474 "Offset of field: ",
10475 stringify!(StdVideoEncodeH264RefPicMarkingEntry),
10476 "::",
10477 stringify!(memory_management_control_operation)
10478 )
10479 );
10480 assert_eq!(
10481 unsafe {
10482 ::core::ptr::addr_of!((*ptr).difference_of_pic_nums_minus1) as usize - ptr as usize
10483 },
10484 4usize,
10485 concat!(
10486 "Offset of field: ",
10487 stringify!(StdVideoEncodeH264RefPicMarkingEntry),
10488 "::",
10489 stringify!(difference_of_pic_nums_minus1)
10490 )
10491 );
10492 assert_eq!(
10493 unsafe { ::core::ptr::addr_of!((*ptr).long_term_pic_num) as usize - ptr as usize },
10494 6usize,
10495 concat!(
10496 "Offset of field: ",
10497 stringify!(StdVideoEncodeH264RefPicMarkingEntry),
10498 "::",
10499 stringify!(long_term_pic_num)
10500 )
10501 );
10502 assert_eq!(
10503 unsafe { ::core::ptr::addr_of!((*ptr).long_term_frame_idx) as usize - ptr as usize },
10504 8usize,
10505 concat!(
10506 "Offset of field: ",
10507 stringify!(StdVideoEncodeH264RefPicMarkingEntry),
10508 "::",
10509 stringify!(long_term_frame_idx)
10510 )
10511 );
10512 assert_eq!(
10513 unsafe {
10514 ::core::ptr::addr_of!((*ptr).max_long_term_frame_idx_plus1) as usize - ptr as usize
10515 },
10516 10usize,
10517 concat!(
10518 "Offset of field: ",
10519 stringify!(StdVideoEncodeH264RefPicMarkingEntry),
10520 "::",
10521 stringify!(max_long_term_frame_idx_plus1)
10522 )
10523 );
10524}
10525#[repr(C)]
10526#[derive(Debug, Copy, Clone)]
10527pub struct StdVideoEncodeH264ReferenceListsInfo {
10528 pub flags: StdVideoEncodeH264ReferenceListsInfoFlags,
10529 pub num_ref_idx_l0_active_minus1: u8,
10530 pub num_ref_idx_l1_active_minus1: u8,
10531 pub RefPicList0: [u8; 32usize],
10532 pub RefPicList1: [u8; 32usize],
10533 pub refList0ModOpCount: u8,
10534 pub refList1ModOpCount: u8,
10535 pub refPicMarkingOpCount: u8,
10536 pub reserved1: [u8; 7usize],
10537 pub pRefList0ModOperations: *const StdVideoEncodeH264RefListModEntry,
10538 pub pRefList1ModOperations: *const StdVideoEncodeH264RefListModEntry,
10539 pub pRefPicMarkingOperations: *const StdVideoEncodeH264RefPicMarkingEntry,
10540}
10541#[test]
10542fn bindgen_test_layout_StdVideoEncodeH264ReferenceListsInfo() {
10543 const UNINIT: ::core::mem::MaybeUninit<StdVideoEncodeH264ReferenceListsInfo> =
10544 ::core::mem::MaybeUninit::uninit();
10545 let ptr = UNINIT.as_ptr();
10546 assert_eq!(
10547 ::core::mem::size_of::<StdVideoEncodeH264ReferenceListsInfo>(),
10548 104usize,
10549 concat!(
10550 "Size of: ",
10551 stringify!(StdVideoEncodeH264ReferenceListsInfo)
10552 )
10553 );
10554 assert_eq!(
10555 ::core::mem::align_of::<StdVideoEncodeH264ReferenceListsInfo>(),
10556 8usize,
10557 concat!(
10558 "Alignment of ",
10559 stringify!(StdVideoEncodeH264ReferenceListsInfo)
10560 )
10561 );
10562 assert_eq!(
10563 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
10564 0usize,
10565 concat!(
10566 "Offset of field: ",
10567 stringify!(StdVideoEncodeH264ReferenceListsInfo),
10568 "::",
10569 stringify!(flags)
10570 )
10571 );
10572 assert_eq!(
10573 unsafe {
10574 ::core::ptr::addr_of!((*ptr).num_ref_idx_l0_active_minus1) as usize - ptr as usize
10575 },
10576 4usize,
10577 concat!(
10578 "Offset of field: ",
10579 stringify!(StdVideoEncodeH264ReferenceListsInfo),
10580 "::",
10581 stringify!(num_ref_idx_l0_active_minus1)
10582 )
10583 );
10584 assert_eq!(
10585 unsafe {
10586 ::core::ptr::addr_of!((*ptr).num_ref_idx_l1_active_minus1) as usize - ptr as usize
10587 },
10588 5usize,
10589 concat!(
10590 "Offset of field: ",
10591 stringify!(StdVideoEncodeH264ReferenceListsInfo),
10592 "::",
10593 stringify!(num_ref_idx_l1_active_minus1)
10594 )
10595 );
10596 assert_eq!(
10597 unsafe { ::core::ptr::addr_of!((*ptr).RefPicList0) as usize - ptr as usize },
10598 6usize,
10599 concat!(
10600 "Offset of field: ",
10601 stringify!(StdVideoEncodeH264ReferenceListsInfo),
10602 "::",
10603 stringify!(RefPicList0)
10604 )
10605 );
10606 assert_eq!(
10607 unsafe { ::core::ptr::addr_of!((*ptr).RefPicList1) as usize - ptr as usize },
10608 38usize,
10609 concat!(
10610 "Offset of field: ",
10611 stringify!(StdVideoEncodeH264ReferenceListsInfo),
10612 "::",
10613 stringify!(RefPicList1)
10614 )
10615 );
10616 assert_eq!(
10617 unsafe { ::core::ptr::addr_of!((*ptr).refList0ModOpCount) as usize - ptr as usize },
10618 70usize,
10619 concat!(
10620 "Offset of field: ",
10621 stringify!(StdVideoEncodeH264ReferenceListsInfo),
10622 "::",
10623 stringify!(refList0ModOpCount)
10624 )
10625 );
10626 assert_eq!(
10627 unsafe { ::core::ptr::addr_of!((*ptr).refList1ModOpCount) as usize - ptr as usize },
10628 71usize,
10629 concat!(
10630 "Offset of field: ",
10631 stringify!(StdVideoEncodeH264ReferenceListsInfo),
10632 "::",
10633 stringify!(refList1ModOpCount)
10634 )
10635 );
10636 assert_eq!(
10637 unsafe { ::core::ptr::addr_of!((*ptr).refPicMarkingOpCount) as usize - ptr as usize },
10638 72usize,
10639 concat!(
10640 "Offset of field: ",
10641 stringify!(StdVideoEncodeH264ReferenceListsInfo),
10642 "::",
10643 stringify!(refPicMarkingOpCount)
10644 )
10645 );
10646 assert_eq!(
10647 unsafe { ::core::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize },
10648 73usize,
10649 concat!(
10650 "Offset of field: ",
10651 stringify!(StdVideoEncodeH264ReferenceListsInfo),
10652 "::",
10653 stringify!(reserved1)
10654 )
10655 );
10656 assert_eq!(
10657 unsafe { ::core::ptr::addr_of!((*ptr).pRefList0ModOperations) as usize - ptr as usize },
10658 80usize,
10659 concat!(
10660 "Offset of field: ",
10661 stringify!(StdVideoEncodeH264ReferenceListsInfo),
10662 "::",
10663 stringify!(pRefList0ModOperations)
10664 )
10665 );
10666 assert_eq!(
10667 unsafe { ::core::ptr::addr_of!((*ptr).pRefList1ModOperations) as usize - ptr as usize },
10668 88usize,
10669 concat!(
10670 "Offset of field: ",
10671 stringify!(StdVideoEncodeH264ReferenceListsInfo),
10672 "::",
10673 stringify!(pRefList1ModOperations)
10674 )
10675 );
10676 assert_eq!(
10677 unsafe { ::core::ptr::addr_of!((*ptr).pRefPicMarkingOperations) as usize - ptr as usize },
10678 96usize,
10679 concat!(
10680 "Offset of field: ",
10681 stringify!(StdVideoEncodeH264ReferenceListsInfo),
10682 "::",
10683 stringify!(pRefPicMarkingOperations)
10684 )
10685 );
10686}
10687#[repr(C)]
10688#[derive(Debug, Copy, Clone)]
10689pub struct StdVideoEncodeH264PictureInfo {
10690 pub flags: StdVideoEncodeH264PictureInfoFlags,
10691 pub seq_parameter_set_id: u8,
10692 pub pic_parameter_set_id: u8,
10693 pub idr_pic_id: u16,
10694 pub primary_pic_type: StdVideoH264PictureType,
10695 pub frame_num: u32,
10696 pub PicOrderCnt: i32,
10697 pub temporal_id: u8,
10698 pub reserved1: [u8; 3usize],
10699 pub pRefLists: *const StdVideoEncodeH264ReferenceListsInfo,
10700}
10701#[test]
10702fn bindgen_test_layout_StdVideoEncodeH264PictureInfo() {
10703 const UNINIT: ::core::mem::MaybeUninit<StdVideoEncodeH264PictureInfo> =
10704 ::core::mem::MaybeUninit::uninit();
10705 let ptr = UNINIT.as_ptr();
10706 assert_eq!(
10707 ::core::mem::size_of::<StdVideoEncodeH264PictureInfo>(),
10708 32usize,
10709 concat!("Size of: ", stringify!(StdVideoEncodeH264PictureInfo))
10710 );
10711 assert_eq!(
10712 ::core::mem::align_of::<StdVideoEncodeH264PictureInfo>(),
10713 8usize,
10714 concat!("Alignment of ", stringify!(StdVideoEncodeH264PictureInfo))
10715 );
10716 assert_eq!(
10717 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
10718 0usize,
10719 concat!(
10720 "Offset of field: ",
10721 stringify!(StdVideoEncodeH264PictureInfo),
10722 "::",
10723 stringify!(flags)
10724 )
10725 );
10726 assert_eq!(
10727 unsafe { ::core::ptr::addr_of!((*ptr).seq_parameter_set_id) as usize - ptr as usize },
10728 4usize,
10729 concat!(
10730 "Offset of field: ",
10731 stringify!(StdVideoEncodeH264PictureInfo),
10732 "::",
10733 stringify!(seq_parameter_set_id)
10734 )
10735 );
10736 assert_eq!(
10737 unsafe { ::core::ptr::addr_of!((*ptr).pic_parameter_set_id) as usize - ptr as usize },
10738 5usize,
10739 concat!(
10740 "Offset of field: ",
10741 stringify!(StdVideoEncodeH264PictureInfo),
10742 "::",
10743 stringify!(pic_parameter_set_id)
10744 )
10745 );
10746 assert_eq!(
10747 unsafe { ::core::ptr::addr_of!((*ptr).idr_pic_id) as usize - ptr as usize },
10748 6usize,
10749 concat!(
10750 "Offset of field: ",
10751 stringify!(StdVideoEncodeH264PictureInfo),
10752 "::",
10753 stringify!(idr_pic_id)
10754 )
10755 );
10756 assert_eq!(
10757 unsafe { ::core::ptr::addr_of!((*ptr).primary_pic_type) as usize - ptr as usize },
10758 8usize,
10759 concat!(
10760 "Offset of field: ",
10761 stringify!(StdVideoEncodeH264PictureInfo),
10762 "::",
10763 stringify!(primary_pic_type)
10764 )
10765 );
10766 assert_eq!(
10767 unsafe { ::core::ptr::addr_of!((*ptr).frame_num) as usize - ptr as usize },
10768 12usize,
10769 concat!(
10770 "Offset of field: ",
10771 stringify!(StdVideoEncodeH264PictureInfo),
10772 "::",
10773 stringify!(frame_num)
10774 )
10775 );
10776 assert_eq!(
10777 unsafe { ::core::ptr::addr_of!((*ptr).PicOrderCnt) as usize - ptr as usize },
10778 16usize,
10779 concat!(
10780 "Offset of field: ",
10781 stringify!(StdVideoEncodeH264PictureInfo),
10782 "::",
10783 stringify!(PicOrderCnt)
10784 )
10785 );
10786 assert_eq!(
10787 unsafe { ::core::ptr::addr_of!((*ptr).temporal_id) as usize - ptr as usize },
10788 20usize,
10789 concat!(
10790 "Offset of field: ",
10791 stringify!(StdVideoEncodeH264PictureInfo),
10792 "::",
10793 stringify!(temporal_id)
10794 )
10795 );
10796 assert_eq!(
10797 unsafe { ::core::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize },
10798 21usize,
10799 concat!(
10800 "Offset of field: ",
10801 stringify!(StdVideoEncodeH264PictureInfo),
10802 "::",
10803 stringify!(reserved1)
10804 )
10805 );
10806 assert_eq!(
10807 unsafe { ::core::ptr::addr_of!((*ptr).pRefLists) as usize - ptr as usize },
10808 24usize,
10809 concat!(
10810 "Offset of field: ",
10811 stringify!(StdVideoEncodeH264PictureInfo),
10812 "::",
10813 stringify!(pRefLists)
10814 )
10815 );
10816}
10817#[repr(C)]
10818#[derive(Debug, Copy, Clone)]
10819pub struct StdVideoEncodeH264ReferenceInfo {
10820 pub flags: StdVideoEncodeH264ReferenceInfoFlags,
10821 pub primary_pic_type: StdVideoH264PictureType,
10822 pub FrameNum: u32,
10823 pub PicOrderCnt: i32,
10824 pub long_term_pic_num: u16,
10825 pub long_term_frame_idx: u16,
10826 pub temporal_id: u8,
10827}
10828#[test]
10829fn bindgen_test_layout_StdVideoEncodeH264ReferenceInfo() {
10830 const UNINIT: ::core::mem::MaybeUninit<StdVideoEncodeH264ReferenceInfo> =
10831 ::core::mem::MaybeUninit::uninit();
10832 let ptr = UNINIT.as_ptr();
10833 assert_eq!(
10834 ::core::mem::size_of::<StdVideoEncodeH264ReferenceInfo>(),
10835 24usize,
10836 concat!("Size of: ", stringify!(StdVideoEncodeH264ReferenceInfo))
10837 );
10838 assert_eq!(
10839 ::core::mem::align_of::<StdVideoEncodeH264ReferenceInfo>(),
10840 4usize,
10841 concat!("Alignment of ", stringify!(StdVideoEncodeH264ReferenceInfo))
10842 );
10843 assert_eq!(
10844 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
10845 0usize,
10846 concat!(
10847 "Offset of field: ",
10848 stringify!(StdVideoEncodeH264ReferenceInfo),
10849 "::",
10850 stringify!(flags)
10851 )
10852 );
10853 assert_eq!(
10854 unsafe { ::core::ptr::addr_of!((*ptr).primary_pic_type) as usize - ptr as usize },
10855 4usize,
10856 concat!(
10857 "Offset of field: ",
10858 stringify!(StdVideoEncodeH264ReferenceInfo),
10859 "::",
10860 stringify!(primary_pic_type)
10861 )
10862 );
10863 assert_eq!(
10864 unsafe { ::core::ptr::addr_of!((*ptr).FrameNum) as usize - ptr as usize },
10865 8usize,
10866 concat!(
10867 "Offset of field: ",
10868 stringify!(StdVideoEncodeH264ReferenceInfo),
10869 "::",
10870 stringify!(FrameNum)
10871 )
10872 );
10873 assert_eq!(
10874 unsafe { ::core::ptr::addr_of!((*ptr).PicOrderCnt) as usize - ptr as usize },
10875 12usize,
10876 concat!(
10877 "Offset of field: ",
10878 stringify!(StdVideoEncodeH264ReferenceInfo),
10879 "::",
10880 stringify!(PicOrderCnt)
10881 )
10882 );
10883 assert_eq!(
10884 unsafe { ::core::ptr::addr_of!((*ptr).long_term_pic_num) as usize - ptr as usize },
10885 16usize,
10886 concat!(
10887 "Offset of field: ",
10888 stringify!(StdVideoEncodeH264ReferenceInfo),
10889 "::",
10890 stringify!(long_term_pic_num)
10891 )
10892 );
10893 assert_eq!(
10894 unsafe { ::core::ptr::addr_of!((*ptr).long_term_frame_idx) as usize - ptr as usize },
10895 18usize,
10896 concat!(
10897 "Offset of field: ",
10898 stringify!(StdVideoEncodeH264ReferenceInfo),
10899 "::",
10900 stringify!(long_term_frame_idx)
10901 )
10902 );
10903 assert_eq!(
10904 unsafe { ::core::ptr::addr_of!((*ptr).temporal_id) as usize - ptr as usize },
10905 20usize,
10906 concat!(
10907 "Offset of field: ",
10908 stringify!(StdVideoEncodeH264ReferenceInfo),
10909 "::",
10910 stringify!(temporal_id)
10911 )
10912 );
10913}
10914#[repr(C)]
10915#[derive(Debug, Copy, Clone)]
10916pub struct StdVideoEncodeH264SliceHeader {
10917 pub flags: StdVideoEncodeH264SliceHeaderFlags,
10918 pub first_mb_in_slice: u32,
10919 pub slice_type: StdVideoH264SliceType,
10920 pub slice_alpha_c0_offset_div2: i8,
10921 pub slice_beta_offset_div2: i8,
10922 pub slice_qp_delta: i8,
10923 pub reserved1: u8,
10924 pub cabac_init_idc: StdVideoH264CabacInitIdc,
10925 pub disable_deblocking_filter_idc: StdVideoH264DisableDeblockingFilterIdc,
10926 pub pWeightTable: *const StdVideoEncodeH264WeightTable,
10927}
10928#[test]
10929fn bindgen_test_layout_StdVideoEncodeH264SliceHeader() {
10930 const UNINIT: ::core::mem::MaybeUninit<StdVideoEncodeH264SliceHeader> =
10931 ::core::mem::MaybeUninit::uninit();
10932 let ptr = UNINIT.as_ptr();
10933 assert_eq!(
10934 ::core::mem::size_of::<StdVideoEncodeH264SliceHeader>(),
10935 32usize,
10936 concat!("Size of: ", stringify!(StdVideoEncodeH264SliceHeader))
10937 );
10938 assert_eq!(
10939 ::core::mem::align_of::<StdVideoEncodeH264SliceHeader>(),
10940 8usize,
10941 concat!("Alignment of ", stringify!(StdVideoEncodeH264SliceHeader))
10942 );
10943 assert_eq!(
10944 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
10945 0usize,
10946 concat!(
10947 "Offset of field: ",
10948 stringify!(StdVideoEncodeH264SliceHeader),
10949 "::",
10950 stringify!(flags)
10951 )
10952 );
10953 assert_eq!(
10954 unsafe { ::core::ptr::addr_of!((*ptr).first_mb_in_slice) as usize - ptr as usize },
10955 4usize,
10956 concat!(
10957 "Offset of field: ",
10958 stringify!(StdVideoEncodeH264SliceHeader),
10959 "::",
10960 stringify!(first_mb_in_slice)
10961 )
10962 );
10963 assert_eq!(
10964 unsafe { ::core::ptr::addr_of!((*ptr).slice_type) as usize - ptr as usize },
10965 8usize,
10966 concat!(
10967 "Offset of field: ",
10968 stringify!(StdVideoEncodeH264SliceHeader),
10969 "::",
10970 stringify!(slice_type)
10971 )
10972 );
10973 assert_eq!(
10974 unsafe { ::core::ptr::addr_of!((*ptr).slice_alpha_c0_offset_div2) as usize - ptr as usize },
10975 12usize,
10976 concat!(
10977 "Offset of field: ",
10978 stringify!(StdVideoEncodeH264SliceHeader),
10979 "::",
10980 stringify!(slice_alpha_c0_offset_div2)
10981 )
10982 );
10983 assert_eq!(
10984 unsafe { ::core::ptr::addr_of!((*ptr).slice_beta_offset_div2) as usize - ptr as usize },
10985 13usize,
10986 concat!(
10987 "Offset of field: ",
10988 stringify!(StdVideoEncodeH264SliceHeader),
10989 "::",
10990 stringify!(slice_beta_offset_div2)
10991 )
10992 );
10993 assert_eq!(
10994 unsafe { ::core::ptr::addr_of!((*ptr).slice_qp_delta) as usize - ptr as usize },
10995 14usize,
10996 concat!(
10997 "Offset of field: ",
10998 stringify!(StdVideoEncodeH264SliceHeader),
10999 "::",
11000 stringify!(slice_qp_delta)
11001 )
11002 );
11003 assert_eq!(
11004 unsafe { ::core::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize },
11005 15usize,
11006 concat!(
11007 "Offset of field: ",
11008 stringify!(StdVideoEncodeH264SliceHeader),
11009 "::",
11010 stringify!(reserved1)
11011 )
11012 );
11013 assert_eq!(
11014 unsafe { ::core::ptr::addr_of!((*ptr).cabac_init_idc) as usize - ptr as usize },
11015 16usize,
11016 concat!(
11017 "Offset of field: ",
11018 stringify!(StdVideoEncodeH264SliceHeader),
11019 "::",
11020 stringify!(cabac_init_idc)
11021 )
11022 );
11023 assert_eq!(
11024 unsafe {
11025 ::core::ptr::addr_of!((*ptr).disable_deblocking_filter_idc) as usize - ptr as usize
11026 },
11027 20usize,
11028 concat!(
11029 "Offset of field: ",
11030 stringify!(StdVideoEncodeH264SliceHeader),
11031 "::",
11032 stringify!(disable_deblocking_filter_idc)
11033 )
11034 );
11035 assert_eq!(
11036 unsafe { ::core::ptr::addr_of!((*ptr).pWeightTable) as usize - ptr as usize },
11037 24usize,
11038 concat!(
11039 "Offset of field: ",
11040 stringify!(StdVideoEncodeH264SliceHeader),
11041 "::",
11042 stringify!(pWeightTable)
11043 )
11044 );
11045}
11046#[repr(C)]
11047#[derive(Debug, Copy, Clone)]
11048pub struct StdVideoEncodeH265WeightTableFlags {
11049 pub luma_weight_l0_flag: u16,
11050 pub chroma_weight_l0_flag: u16,
11051 pub luma_weight_l1_flag: u16,
11052 pub chroma_weight_l1_flag: u16,
11053}
11054#[test]
11055fn bindgen_test_layout_StdVideoEncodeH265WeightTableFlags() {
11056 const UNINIT: ::core::mem::MaybeUninit<StdVideoEncodeH265WeightTableFlags> =
11057 ::core::mem::MaybeUninit::uninit();
11058 let ptr = UNINIT.as_ptr();
11059 assert_eq!(
11060 ::core::mem::size_of::<StdVideoEncodeH265WeightTableFlags>(),
11061 8usize,
11062 concat!("Size of: ", stringify!(StdVideoEncodeH265WeightTableFlags))
11063 );
11064 assert_eq!(
11065 ::core::mem::align_of::<StdVideoEncodeH265WeightTableFlags>(),
11066 2usize,
11067 concat!(
11068 "Alignment of ",
11069 stringify!(StdVideoEncodeH265WeightTableFlags)
11070 )
11071 );
11072 assert_eq!(
11073 unsafe { ::core::ptr::addr_of!((*ptr).luma_weight_l0_flag) as usize - ptr as usize },
11074 0usize,
11075 concat!(
11076 "Offset of field: ",
11077 stringify!(StdVideoEncodeH265WeightTableFlags),
11078 "::",
11079 stringify!(luma_weight_l0_flag)
11080 )
11081 );
11082 assert_eq!(
11083 unsafe { ::core::ptr::addr_of!((*ptr).chroma_weight_l0_flag) as usize - ptr as usize },
11084 2usize,
11085 concat!(
11086 "Offset of field: ",
11087 stringify!(StdVideoEncodeH265WeightTableFlags),
11088 "::",
11089 stringify!(chroma_weight_l0_flag)
11090 )
11091 );
11092 assert_eq!(
11093 unsafe { ::core::ptr::addr_of!((*ptr).luma_weight_l1_flag) as usize - ptr as usize },
11094 4usize,
11095 concat!(
11096 "Offset of field: ",
11097 stringify!(StdVideoEncodeH265WeightTableFlags),
11098 "::",
11099 stringify!(luma_weight_l1_flag)
11100 )
11101 );
11102 assert_eq!(
11103 unsafe { ::core::ptr::addr_of!((*ptr).chroma_weight_l1_flag) as usize - ptr as usize },
11104 6usize,
11105 concat!(
11106 "Offset of field: ",
11107 stringify!(StdVideoEncodeH265WeightTableFlags),
11108 "::",
11109 stringify!(chroma_weight_l1_flag)
11110 )
11111 );
11112}
11113#[repr(C)]
11114#[derive(Debug, Copy, Clone)]
11115pub struct StdVideoEncodeH265WeightTable {
11116 pub flags: StdVideoEncodeH265WeightTableFlags,
11117 pub luma_log2_weight_denom: u8,
11118 pub delta_chroma_log2_weight_denom: i8,
11119 pub delta_luma_weight_l0: [i8; 15usize],
11120 pub luma_offset_l0: [i8; 15usize],
11121 pub delta_chroma_weight_l0: [[i8; 2usize]; 15usize],
11122 pub delta_chroma_offset_l0: [[i8; 2usize]; 15usize],
11123 pub delta_luma_weight_l1: [i8; 15usize],
11124 pub luma_offset_l1: [i8; 15usize],
11125 pub delta_chroma_weight_l1: [[i8; 2usize]; 15usize],
11126 pub delta_chroma_offset_l1: [[i8; 2usize]; 15usize],
11127}
11128#[test]
11129fn bindgen_test_layout_StdVideoEncodeH265WeightTable() {
11130 const UNINIT: ::core::mem::MaybeUninit<StdVideoEncodeH265WeightTable> =
11131 ::core::mem::MaybeUninit::uninit();
11132 let ptr = UNINIT.as_ptr();
11133 assert_eq!(
11134 ::core::mem::size_of::<StdVideoEncodeH265WeightTable>(),
11135 190usize,
11136 concat!("Size of: ", stringify!(StdVideoEncodeH265WeightTable))
11137 );
11138 assert_eq!(
11139 ::core::mem::align_of::<StdVideoEncodeH265WeightTable>(),
11140 2usize,
11141 concat!("Alignment of ", stringify!(StdVideoEncodeH265WeightTable))
11142 );
11143 assert_eq!(
11144 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
11145 0usize,
11146 concat!(
11147 "Offset of field: ",
11148 stringify!(StdVideoEncodeH265WeightTable),
11149 "::",
11150 stringify!(flags)
11151 )
11152 );
11153 assert_eq!(
11154 unsafe { ::core::ptr::addr_of!((*ptr).luma_log2_weight_denom) as usize - ptr as usize },
11155 8usize,
11156 concat!(
11157 "Offset of field: ",
11158 stringify!(StdVideoEncodeH265WeightTable),
11159 "::",
11160 stringify!(luma_log2_weight_denom)
11161 )
11162 );
11163 assert_eq!(
11164 unsafe {
11165 ::core::ptr::addr_of!((*ptr).delta_chroma_log2_weight_denom) as usize - ptr as usize
11166 },
11167 9usize,
11168 concat!(
11169 "Offset of field: ",
11170 stringify!(StdVideoEncodeH265WeightTable),
11171 "::",
11172 stringify!(delta_chroma_log2_weight_denom)
11173 )
11174 );
11175 assert_eq!(
11176 unsafe { ::core::ptr::addr_of!((*ptr).delta_luma_weight_l0) as usize - ptr as usize },
11177 10usize,
11178 concat!(
11179 "Offset of field: ",
11180 stringify!(StdVideoEncodeH265WeightTable),
11181 "::",
11182 stringify!(delta_luma_weight_l0)
11183 )
11184 );
11185 assert_eq!(
11186 unsafe { ::core::ptr::addr_of!((*ptr).luma_offset_l0) as usize - ptr as usize },
11187 25usize,
11188 concat!(
11189 "Offset of field: ",
11190 stringify!(StdVideoEncodeH265WeightTable),
11191 "::",
11192 stringify!(luma_offset_l0)
11193 )
11194 );
11195 assert_eq!(
11196 unsafe { ::core::ptr::addr_of!((*ptr).delta_chroma_weight_l0) as usize - ptr as usize },
11197 40usize,
11198 concat!(
11199 "Offset of field: ",
11200 stringify!(StdVideoEncodeH265WeightTable),
11201 "::",
11202 stringify!(delta_chroma_weight_l0)
11203 )
11204 );
11205 assert_eq!(
11206 unsafe { ::core::ptr::addr_of!((*ptr).delta_chroma_offset_l0) as usize - ptr as usize },
11207 70usize,
11208 concat!(
11209 "Offset of field: ",
11210 stringify!(StdVideoEncodeH265WeightTable),
11211 "::",
11212 stringify!(delta_chroma_offset_l0)
11213 )
11214 );
11215 assert_eq!(
11216 unsafe { ::core::ptr::addr_of!((*ptr).delta_luma_weight_l1) as usize - ptr as usize },
11217 100usize,
11218 concat!(
11219 "Offset of field: ",
11220 stringify!(StdVideoEncodeH265WeightTable),
11221 "::",
11222 stringify!(delta_luma_weight_l1)
11223 )
11224 );
11225 assert_eq!(
11226 unsafe { ::core::ptr::addr_of!((*ptr).luma_offset_l1) as usize - ptr as usize },
11227 115usize,
11228 concat!(
11229 "Offset of field: ",
11230 stringify!(StdVideoEncodeH265WeightTable),
11231 "::",
11232 stringify!(luma_offset_l1)
11233 )
11234 );
11235 assert_eq!(
11236 unsafe { ::core::ptr::addr_of!((*ptr).delta_chroma_weight_l1) as usize - ptr as usize },
11237 130usize,
11238 concat!(
11239 "Offset of field: ",
11240 stringify!(StdVideoEncodeH265WeightTable),
11241 "::",
11242 stringify!(delta_chroma_weight_l1)
11243 )
11244 );
11245 assert_eq!(
11246 unsafe { ::core::ptr::addr_of!((*ptr).delta_chroma_offset_l1) as usize - ptr as usize },
11247 160usize,
11248 concat!(
11249 "Offset of field: ",
11250 stringify!(StdVideoEncodeH265WeightTable),
11251 "::",
11252 stringify!(delta_chroma_offset_l1)
11253 )
11254 );
11255}
11256#[repr(C)]
11257#[derive(Debug, Copy, Clone)]
11258pub struct StdVideoEncodeH265SliceSegmentHeaderFlags {
11259 pub _bitfield_align_1: [u32; 0],
11260 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
11261}
11262#[test]
11263fn bindgen_test_layout_StdVideoEncodeH265SliceSegmentHeaderFlags() {
11264 assert_eq!(
11265 ::core::mem::size_of::<StdVideoEncodeH265SliceSegmentHeaderFlags>(),
11266 4usize,
11267 concat!(
11268 "Size of: ",
11269 stringify!(StdVideoEncodeH265SliceSegmentHeaderFlags)
11270 )
11271 );
11272 assert_eq!(
11273 ::core::mem::align_of::<StdVideoEncodeH265SliceSegmentHeaderFlags>(),
11274 4usize,
11275 concat!(
11276 "Alignment of ",
11277 stringify!(StdVideoEncodeH265SliceSegmentHeaderFlags)
11278 )
11279 );
11280}
11281impl StdVideoEncodeH265SliceSegmentHeaderFlags {
11282 #[inline]
11283 pub fn first_slice_segment_in_pic_flag(&self) -> u32 {
11284 unsafe { ::core::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
11285 }
11286 #[inline]
11287 pub fn set_first_slice_segment_in_pic_flag(&mut self, val: u32) {
11288 unsafe {
11289 let val: u32 = ::core::mem::transmute(val);
11290 self._bitfield_1.set(0usize, 1u8, val as u64)
11291 }
11292 }
11293 #[inline]
11294 pub fn dependent_slice_segment_flag(&self) -> u32 {
11295 unsafe { ::core::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
11296 }
11297 #[inline]
11298 pub fn set_dependent_slice_segment_flag(&mut self, val: u32) {
11299 unsafe {
11300 let val: u32 = ::core::mem::transmute(val);
11301 self._bitfield_1.set(1usize, 1u8, val as u64)
11302 }
11303 }
11304 #[inline]
11305 pub fn slice_sao_luma_flag(&self) -> u32 {
11306 unsafe { ::core::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
11307 }
11308 #[inline]
11309 pub fn set_slice_sao_luma_flag(&mut self, val: u32) {
11310 unsafe {
11311 let val: u32 = ::core::mem::transmute(val);
11312 self._bitfield_1.set(2usize, 1u8, val as u64)
11313 }
11314 }
11315 #[inline]
11316 pub fn slice_sao_chroma_flag(&self) -> u32 {
11317 unsafe { ::core::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
11318 }
11319 #[inline]
11320 pub fn set_slice_sao_chroma_flag(&mut self, val: u32) {
11321 unsafe {
11322 let val: u32 = ::core::mem::transmute(val);
11323 self._bitfield_1.set(3usize, 1u8, val as u64)
11324 }
11325 }
11326 #[inline]
11327 pub fn num_ref_idx_active_override_flag(&self) -> u32 {
11328 unsafe { ::core::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
11329 }
11330 #[inline]
11331 pub fn set_num_ref_idx_active_override_flag(&mut self, val: u32) {
11332 unsafe {
11333 let val: u32 = ::core::mem::transmute(val);
11334 self._bitfield_1.set(4usize, 1u8, val as u64)
11335 }
11336 }
11337 #[inline]
11338 pub fn mvd_l1_zero_flag(&self) -> u32 {
11339 unsafe { ::core::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
11340 }
11341 #[inline]
11342 pub fn set_mvd_l1_zero_flag(&mut self, val: u32) {
11343 unsafe {
11344 let val: u32 = ::core::mem::transmute(val);
11345 self._bitfield_1.set(5usize, 1u8, val as u64)
11346 }
11347 }
11348 #[inline]
11349 pub fn cabac_init_flag(&self) -> u32 {
11350 unsafe { ::core::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) }
11351 }
11352 #[inline]
11353 pub fn set_cabac_init_flag(&mut self, val: u32) {
11354 unsafe {
11355 let val: u32 = ::core::mem::transmute(val);
11356 self._bitfield_1.set(6usize, 1u8, val as u64)
11357 }
11358 }
11359 #[inline]
11360 pub fn cu_chroma_qp_offset_enabled_flag(&self) -> u32 {
11361 unsafe { ::core::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) }
11362 }
11363 #[inline]
11364 pub fn set_cu_chroma_qp_offset_enabled_flag(&mut self, val: u32) {
11365 unsafe {
11366 let val: u32 = ::core::mem::transmute(val);
11367 self._bitfield_1.set(7usize, 1u8, val as u64)
11368 }
11369 }
11370 #[inline]
11371 pub fn deblocking_filter_override_flag(&self) -> u32 {
11372 unsafe { ::core::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) }
11373 }
11374 #[inline]
11375 pub fn set_deblocking_filter_override_flag(&mut self, val: u32) {
11376 unsafe {
11377 let val: u32 = ::core::mem::transmute(val);
11378 self._bitfield_1.set(8usize, 1u8, val as u64)
11379 }
11380 }
11381 #[inline]
11382 pub fn slice_deblocking_filter_disabled_flag(&self) -> u32 {
11383 unsafe { ::core::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) }
11384 }
11385 #[inline]
11386 pub fn set_slice_deblocking_filter_disabled_flag(&mut self, val: u32) {
11387 unsafe {
11388 let val: u32 = ::core::mem::transmute(val);
11389 self._bitfield_1.set(9usize, 1u8, val as u64)
11390 }
11391 }
11392 #[inline]
11393 pub fn collocated_from_l0_flag(&self) -> u32 {
11394 unsafe { ::core::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) }
11395 }
11396 #[inline]
11397 pub fn set_collocated_from_l0_flag(&mut self, val: u32) {
11398 unsafe {
11399 let val: u32 = ::core::mem::transmute(val);
11400 self._bitfield_1.set(10usize, 1u8, val as u64)
11401 }
11402 }
11403 #[inline]
11404 pub fn slice_loop_filter_across_slices_enabled_flag(&self) -> u32 {
11405 unsafe { ::core::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) }
11406 }
11407 #[inline]
11408 pub fn set_slice_loop_filter_across_slices_enabled_flag(&mut self, val: u32) {
11409 unsafe {
11410 let val: u32 = ::core::mem::transmute(val);
11411 self._bitfield_1.set(11usize, 1u8, val as u64)
11412 }
11413 }
11414 #[inline]
11415 pub fn reserved(&self) -> u32 {
11416 unsafe { ::core::mem::transmute(self._bitfield_1.get(12usize, 20u8) as u32) }
11417 }
11418 #[inline]
11419 pub fn set_reserved(&mut self, val: u32) {
11420 unsafe {
11421 let val: u32 = ::core::mem::transmute(val);
11422 self._bitfield_1.set(12usize, 20u8, val as u64)
11423 }
11424 }
11425 #[inline]
11426 pub fn new_bitfield_1(
11427 first_slice_segment_in_pic_flag: u32,
11428 dependent_slice_segment_flag: u32,
11429 slice_sao_luma_flag: u32,
11430 slice_sao_chroma_flag: u32,
11431 num_ref_idx_active_override_flag: u32,
11432 mvd_l1_zero_flag: u32,
11433 cabac_init_flag: u32,
11434 cu_chroma_qp_offset_enabled_flag: u32,
11435 deblocking_filter_override_flag: u32,
11436 slice_deblocking_filter_disabled_flag: u32,
11437 collocated_from_l0_flag: u32,
11438 slice_loop_filter_across_slices_enabled_flag: u32,
11439 reserved: u32,
11440 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
11441 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
11442 __bindgen_bitfield_unit.set(0usize, 1u8, {
11443 let first_slice_segment_in_pic_flag: u32 =
11444 unsafe { ::core::mem::transmute(first_slice_segment_in_pic_flag) };
11445 first_slice_segment_in_pic_flag as u64
11446 });
11447 __bindgen_bitfield_unit.set(1usize, 1u8, {
11448 let dependent_slice_segment_flag: u32 =
11449 unsafe { ::core::mem::transmute(dependent_slice_segment_flag) };
11450 dependent_slice_segment_flag as u64
11451 });
11452 __bindgen_bitfield_unit.set(2usize, 1u8, {
11453 let slice_sao_luma_flag: u32 = unsafe { ::core::mem::transmute(slice_sao_luma_flag) };
11454 slice_sao_luma_flag as u64
11455 });
11456 __bindgen_bitfield_unit.set(3usize, 1u8, {
11457 let slice_sao_chroma_flag: u32 =
11458 unsafe { ::core::mem::transmute(slice_sao_chroma_flag) };
11459 slice_sao_chroma_flag as u64
11460 });
11461 __bindgen_bitfield_unit.set(4usize, 1u8, {
11462 let num_ref_idx_active_override_flag: u32 =
11463 unsafe { ::core::mem::transmute(num_ref_idx_active_override_flag) };
11464 num_ref_idx_active_override_flag as u64
11465 });
11466 __bindgen_bitfield_unit.set(5usize, 1u8, {
11467 let mvd_l1_zero_flag: u32 = unsafe { ::core::mem::transmute(mvd_l1_zero_flag) };
11468 mvd_l1_zero_flag as u64
11469 });
11470 __bindgen_bitfield_unit.set(6usize, 1u8, {
11471 let cabac_init_flag: u32 = unsafe { ::core::mem::transmute(cabac_init_flag) };
11472 cabac_init_flag as u64
11473 });
11474 __bindgen_bitfield_unit.set(7usize, 1u8, {
11475 let cu_chroma_qp_offset_enabled_flag: u32 =
11476 unsafe { ::core::mem::transmute(cu_chroma_qp_offset_enabled_flag) };
11477 cu_chroma_qp_offset_enabled_flag as u64
11478 });
11479 __bindgen_bitfield_unit.set(8usize, 1u8, {
11480 let deblocking_filter_override_flag: u32 =
11481 unsafe { ::core::mem::transmute(deblocking_filter_override_flag) };
11482 deblocking_filter_override_flag as u64
11483 });
11484 __bindgen_bitfield_unit.set(9usize, 1u8, {
11485 let slice_deblocking_filter_disabled_flag: u32 =
11486 unsafe { ::core::mem::transmute(slice_deblocking_filter_disabled_flag) };
11487 slice_deblocking_filter_disabled_flag as u64
11488 });
11489 __bindgen_bitfield_unit.set(10usize, 1u8, {
11490 let collocated_from_l0_flag: u32 =
11491 unsafe { ::core::mem::transmute(collocated_from_l0_flag) };
11492 collocated_from_l0_flag as u64
11493 });
11494 __bindgen_bitfield_unit.set(11usize, 1u8, {
11495 let slice_loop_filter_across_slices_enabled_flag: u32 =
11496 unsafe { ::core::mem::transmute(slice_loop_filter_across_slices_enabled_flag) };
11497 slice_loop_filter_across_slices_enabled_flag as u64
11498 });
11499 __bindgen_bitfield_unit.set(12usize, 20u8, {
11500 let reserved: u32 = unsafe { ::core::mem::transmute(reserved) };
11501 reserved as u64
11502 });
11503 __bindgen_bitfield_unit
11504 }
11505}
11506#[repr(C)]
11507#[derive(Debug, Copy, Clone)]
11508pub struct StdVideoEncodeH265SliceSegmentHeader {
11509 pub flags: StdVideoEncodeH265SliceSegmentHeaderFlags,
11510 pub slice_type: StdVideoH265SliceType,
11511 pub slice_segment_address: u32,
11512 pub collocated_ref_idx: u8,
11513 pub MaxNumMergeCand: u8,
11514 pub slice_cb_qp_offset: i8,
11515 pub slice_cr_qp_offset: i8,
11516 pub slice_beta_offset_div2: i8,
11517 pub slice_tc_offset_div2: i8,
11518 pub slice_act_y_qp_offset: i8,
11519 pub slice_act_cb_qp_offset: i8,
11520 pub slice_act_cr_qp_offset: i8,
11521 pub slice_qp_delta: i8,
11522 pub reserved1: u16,
11523 pub pWeightTable: *const StdVideoEncodeH265WeightTable,
11524}
11525#[test]
11526fn bindgen_test_layout_StdVideoEncodeH265SliceSegmentHeader() {
11527 const UNINIT: ::core::mem::MaybeUninit<StdVideoEncodeH265SliceSegmentHeader> =
11528 ::core::mem::MaybeUninit::uninit();
11529 let ptr = UNINIT.as_ptr();
11530 assert_eq!(
11531 ::core::mem::size_of::<StdVideoEncodeH265SliceSegmentHeader>(),
11532 32usize,
11533 concat!(
11534 "Size of: ",
11535 stringify!(StdVideoEncodeH265SliceSegmentHeader)
11536 )
11537 );
11538 assert_eq!(
11539 ::core::mem::align_of::<StdVideoEncodeH265SliceSegmentHeader>(),
11540 8usize,
11541 concat!(
11542 "Alignment of ",
11543 stringify!(StdVideoEncodeH265SliceSegmentHeader)
11544 )
11545 );
11546 assert_eq!(
11547 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
11548 0usize,
11549 concat!(
11550 "Offset of field: ",
11551 stringify!(StdVideoEncodeH265SliceSegmentHeader),
11552 "::",
11553 stringify!(flags)
11554 )
11555 );
11556 assert_eq!(
11557 unsafe { ::core::ptr::addr_of!((*ptr).slice_type) as usize - ptr as usize },
11558 4usize,
11559 concat!(
11560 "Offset of field: ",
11561 stringify!(StdVideoEncodeH265SliceSegmentHeader),
11562 "::",
11563 stringify!(slice_type)
11564 )
11565 );
11566 assert_eq!(
11567 unsafe { ::core::ptr::addr_of!((*ptr).slice_segment_address) as usize - ptr as usize },
11568 8usize,
11569 concat!(
11570 "Offset of field: ",
11571 stringify!(StdVideoEncodeH265SliceSegmentHeader),
11572 "::",
11573 stringify!(slice_segment_address)
11574 )
11575 );
11576 assert_eq!(
11577 unsafe { ::core::ptr::addr_of!((*ptr).collocated_ref_idx) as usize - ptr as usize },
11578 12usize,
11579 concat!(
11580 "Offset of field: ",
11581 stringify!(StdVideoEncodeH265SliceSegmentHeader),
11582 "::",
11583 stringify!(collocated_ref_idx)
11584 )
11585 );
11586 assert_eq!(
11587 unsafe { ::core::ptr::addr_of!((*ptr).MaxNumMergeCand) as usize - ptr as usize },
11588 13usize,
11589 concat!(
11590 "Offset of field: ",
11591 stringify!(StdVideoEncodeH265SliceSegmentHeader),
11592 "::",
11593 stringify!(MaxNumMergeCand)
11594 )
11595 );
11596 assert_eq!(
11597 unsafe { ::core::ptr::addr_of!((*ptr).slice_cb_qp_offset) as usize - ptr as usize },
11598 14usize,
11599 concat!(
11600 "Offset of field: ",
11601 stringify!(StdVideoEncodeH265SliceSegmentHeader),
11602 "::",
11603 stringify!(slice_cb_qp_offset)
11604 )
11605 );
11606 assert_eq!(
11607 unsafe { ::core::ptr::addr_of!((*ptr).slice_cr_qp_offset) as usize - ptr as usize },
11608 15usize,
11609 concat!(
11610 "Offset of field: ",
11611 stringify!(StdVideoEncodeH265SliceSegmentHeader),
11612 "::",
11613 stringify!(slice_cr_qp_offset)
11614 )
11615 );
11616 assert_eq!(
11617 unsafe { ::core::ptr::addr_of!((*ptr).slice_beta_offset_div2) as usize - ptr as usize },
11618 16usize,
11619 concat!(
11620 "Offset of field: ",
11621 stringify!(StdVideoEncodeH265SliceSegmentHeader),
11622 "::",
11623 stringify!(slice_beta_offset_div2)
11624 )
11625 );
11626 assert_eq!(
11627 unsafe { ::core::ptr::addr_of!((*ptr).slice_tc_offset_div2) as usize - ptr as usize },
11628 17usize,
11629 concat!(
11630 "Offset of field: ",
11631 stringify!(StdVideoEncodeH265SliceSegmentHeader),
11632 "::",
11633 stringify!(slice_tc_offset_div2)
11634 )
11635 );
11636 assert_eq!(
11637 unsafe { ::core::ptr::addr_of!((*ptr).slice_act_y_qp_offset) as usize - ptr as usize },
11638 18usize,
11639 concat!(
11640 "Offset of field: ",
11641 stringify!(StdVideoEncodeH265SliceSegmentHeader),
11642 "::",
11643 stringify!(slice_act_y_qp_offset)
11644 )
11645 );
11646 assert_eq!(
11647 unsafe { ::core::ptr::addr_of!((*ptr).slice_act_cb_qp_offset) as usize - ptr as usize },
11648 19usize,
11649 concat!(
11650 "Offset of field: ",
11651 stringify!(StdVideoEncodeH265SliceSegmentHeader),
11652 "::",
11653 stringify!(slice_act_cb_qp_offset)
11654 )
11655 );
11656 assert_eq!(
11657 unsafe { ::core::ptr::addr_of!((*ptr).slice_act_cr_qp_offset) as usize - ptr as usize },
11658 20usize,
11659 concat!(
11660 "Offset of field: ",
11661 stringify!(StdVideoEncodeH265SliceSegmentHeader),
11662 "::",
11663 stringify!(slice_act_cr_qp_offset)
11664 )
11665 );
11666 assert_eq!(
11667 unsafe { ::core::ptr::addr_of!((*ptr).slice_qp_delta) as usize - ptr as usize },
11668 21usize,
11669 concat!(
11670 "Offset of field: ",
11671 stringify!(StdVideoEncodeH265SliceSegmentHeader),
11672 "::",
11673 stringify!(slice_qp_delta)
11674 )
11675 );
11676 assert_eq!(
11677 unsafe { ::core::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize },
11678 22usize,
11679 concat!(
11680 "Offset of field: ",
11681 stringify!(StdVideoEncodeH265SliceSegmentHeader),
11682 "::",
11683 stringify!(reserved1)
11684 )
11685 );
11686 assert_eq!(
11687 unsafe { ::core::ptr::addr_of!((*ptr).pWeightTable) as usize - ptr as usize },
11688 24usize,
11689 concat!(
11690 "Offset of field: ",
11691 stringify!(StdVideoEncodeH265SliceSegmentHeader),
11692 "::",
11693 stringify!(pWeightTable)
11694 )
11695 );
11696}
11697#[repr(C)]
11698#[derive(Debug, Copy, Clone)]
11699pub struct StdVideoEncodeH265ReferenceListsInfoFlags {
11700 pub _bitfield_align_1: [u32; 0],
11701 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
11702}
11703#[test]
11704fn bindgen_test_layout_StdVideoEncodeH265ReferenceListsInfoFlags() {
11705 assert_eq!(
11706 ::core::mem::size_of::<StdVideoEncodeH265ReferenceListsInfoFlags>(),
11707 4usize,
11708 concat!(
11709 "Size of: ",
11710 stringify!(StdVideoEncodeH265ReferenceListsInfoFlags)
11711 )
11712 );
11713 assert_eq!(
11714 ::core::mem::align_of::<StdVideoEncodeH265ReferenceListsInfoFlags>(),
11715 4usize,
11716 concat!(
11717 "Alignment of ",
11718 stringify!(StdVideoEncodeH265ReferenceListsInfoFlags)
11719 )
11720 );
11721}
11722impl StdVideoEncodeH265ReferenceListsInfoFlags {
11723 #[inline]
11724 pub fn ref_pic_list_modification_flag_l0(&self) -> u32 {
11725 unsafe { ::core::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
11726 }
11727 #[inline]
11728 pub fn set_ref_pic_list_modification_flag_l0(&mut self, val: u32) {
11729 unsafe {
11730 let val: u32 = ::core::mem::transmute(val);
11731 self._bitfield_1.set(0usize, 1u8, val as u64)
11732 }
11733 }
11734 #[inline]
11735 pub fn ref_pic_list_modification_flag_l1(&self) -> u32 {
11736 unsafe { ::core::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
11737 }
11738 #[inline]
11739 pub fn set_ref_pic_list_modification_flag_l1(&mut self, val: u32) {
11740 unsafe {
11741 let val: u32 = ::core::mem::transmute(val);
11742 self._bitfield_1.set(1usize, 1u8, val as u64)
11743 }
11744 }
11745 #[inline]
11746 pub fn reserved(&self) -> u32 {
11747 unsafe { ::core::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) }
11748 }
11749 #[inline]
11750 pub fn set_reserved(&mut self, val: u32) {
11751 unsafe {
11752 let val: u32 = ::core::mem::transmute(val);
11753 self._bitfield_1.set(2usize, 30u8, val as u64)
11754 }
11755 }
11756 #[inline]
11757 pub fn new_bitfield_1(
11758 ref_pic_list_modification_flag_l0: u32,
11759 ref_pic_list_modification_flag_l1: u32,
11760 reserved: u32,
11761 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
11762 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
11763 __bindgen_bitfield_unit.set(0usize, 1u8, {
11764 let ref_pic_list_modification_flag_l0: u32 =
11765 unsafe { ::core::mem::transmute(ref_pic_list_modification_flag_l0) };
11766 ref_pic_list_modification_flag_l0 as u64
11767 });
11768 __bindgen_bitfield_unit.set(1usize, 1u8, {
11769 let ref_pic_list_modification_flag_l1: u32 =
11770 unsafe { ::core::mem::transmute(ref_pic_list_modification_flag_l1) };
11771 ref_pic_list_modification_flag_l1 as u64
11772 });
11773 __bindgen_bitfield_unit.set(2usize, 30u8, {
11774 let reserved: u32 = unsafe { ::core::mem::transmute(reserved) };
11775 reserved as u64
11776 });
11777 __bindgen_bitfield_unit
11778 }
11779}
11780#[repr(C)]
11781#[derive(Debug, Copy, Clone)]
11782pub struct StdVideoEncodeH265ReferenceListsInfo {
11783 pub flags: StdVideoEncodeH265ReferenceListsInfoFlags,
11784 pub num_ref_idx_l0_active_minus1: u8,
11785 pub num_ref_idx_l1_active_minus1: u8,
11786 pub RefPicList0: [u8; 15usize],
11787 pub RefPicList1: [u8; 15usize],
11788 pub list_entry_l0: [u8; 15usize],
11789 pub list_entry_l1: [u8; 15usize],
11790}
11791#[test]
11792fn bindgen_test_layout_StdVideoEncodeH265ReferenceListsInfo() {
11793 const UNINIT: ::core::mem::MaybeUninit<StdVideoEncodeH265ReferenceListsInfo> =
11794 ::core::mem::MaybeUninit::uninit();
11795 let ptr = UNINIT.as_ptr();
11796 assert_eq!(
11797 ::core::mem::size_of::<StdVideoEncodeH265ReferenceListsInfo>(),
11798 68usize,
11799 concat!(
11800 "Size of: ",
11801 stringify!(StdVideoEncodeH265ReferenceListsInfo)
11802 )
11803 );
11804 assert_eq!(
11805 ::core::mem::align_of::<StdVideoEncodeH265ReferenceListsInfo>(),
11806 4usize,
11807 concat!(
11808 "Alignment of ",
11809 stringify!(StdVideoEncodeH265ReferenceListsInfo)
11810 )
11811 );
11812 assert_eq!(
11813 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
11814 0usize,
11815 concat!(
11816 "Offset of field: ",
11817 stringify!(StdVideoEncodeH265ReferenceListsInfo),
11818 "::",
11819 stringify!(flags)
11820 )
11821 );
11822 assert_eq!(
11823 unsafe {
11824 ::core::ptr::addr_of!((*ptr).num_ref_idx_l0_active_minus1) as usize - ptr as usize
11825 },
11826 4usize,
11827 concat!(
11828 "Offset of field: ",
11829 stringify!(StdVideoEncodeH265ReferenceListsInfo),
11830 "::",
11831 stringify!(num_ref_idx_l0_active_minus1)
11832 )
11833 );
11834 assert_eq!(
11835 unsafe {
11836 ::core::ptr::addr_of!((*ptr).num_ref_idx_l1_active_minus1) as usize - ptr as usize
11837 },
11838 5usize,
11839 concat!(
11840 "Offset of field: ",
11841 stringify!(StdVideoEncodeH265ReferenceListsInfo),
11842 "::",
11843 stringify!(num_ref_idx_l1_active_minus1)
11844 )
11845 );
11846 assert_eq!(
11847 unsafe { ::core::ptr::addr_of!((*ptr).RefPicList0) as usize - ptr as usize },
11848 6usize,
11849 concat!(
11850 "Offset of field: ",
11851 stringify!(StdVideoEncodeH265ReferenceListsInfo),
11852 "::",
11853 stringify!(RefPicList0)
11854 )
11855 );
11856 assert_eq!(
11857 unsafe { ::core::ptr::addr_of!((*ptr).RefPicList1) as usize - ptr as usize },
11858 21usize,
11859 concat!(
11860 "Offset of field: ",
11861 stringify!(StdVideoEncodeH265ReferenceListsInfo),
11862 "::",
11863 stringify!(RefPicList1)
11864 )
11865 );
11866 assert_eq!(
11867 unsafe { ::core::ptr::addr_of!((*ptr).list_entry_l0) as usize - ptr as usize },
11868 36usize,
11869 concat!(
11870 "Offset of field: ",
11871 stringify!(StdVideoEncodeH265ReferenceListsInfo),
11872 "::",
11873 stringify!(list_entry_l0)
11874 )
11875 );
11876 assert_eq!(
11877 unsafe { ::core::ptr::addr_of!((*ptr).list_entry_l1) as usize - ptr as usize },
11878 51usize,
11879 concat!(
11880 "Offset of field: ",
11881 stringify!(StdVideoEncodeH265ReferenceListsInfo),
11882 "::",
11883 stringify!(list_entry_l1)
11884 )
11885 );
11886}
11887#[repr(C)]
11888#[derive(Debug, Copy, Clone)]
11889pub struct StdVideoEncodeH265PictureInfoFlags {
11890 pub _bitfield_align_1: [u32; 0],
11891 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
11892}
11893#[test]
11894fn bindgen_test_layout_StdVideoEncodeH265PictureInfoFlags() {
11895 assert_eq!(
11896 ::core::mem::size_of::<StdVideoEncodeH265PictureInfoFlags>(),
11897 4usize,
11898 concat!("Size of: ", stringify!(StdVideoEncodeH265PictureInfoFlags))
11899 );
11900 assert_eq!(
11901 ::core::mem::align_of::<StdVideoEncodeH265PictureInfoFlags>(),
11902 4usize,
11903 concat!(
11904 "Alignment of ",
11905 stringify!(StdVideoEncodeH265PictureInfoFlags)
11906 )
11907 );
11908}
11909impl StdVideoEncodeH265PictureInfoFlags {
11910 #[inline]
11911 pub fn is_reference(&self) -> u32 {
11912 unsafe { ::core::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
11913 }
11914 #[inline]
11915 pub fn set_is_reference(&mut self, val: u32) {
11916 unsafe {
11917 let val: u32 = ::core::mem::transmute(val);
11918 self._bitfield_1.set(0usize, 1u8, val as u64)
11919 }
11920 }
11921 #[inline]
11922 pub fn IrapPicFlag(&self) -> u32 {
11923 unsafe { ::core::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
11924 }
11925 #[inline]
11926 pub fn set_IrapPicFlag(&mut self, val: u32) {
11927 unsafe {
11928 let val: u32 = ::core::mem::transmute(val);
11929 self._bitfield_1.set(1usize, 1u8, val as u64)
11930 }
11931 }
11932 #[inline]
11933 pub fn used_for_long_term_reference(&self) -> u32 {
11934 unsafe { ::core::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
11935 }
11936 #[inline]
11937 pub fn set_used_for_long_term_reference(&mut self, val: u32) {
11938 unsafe {
11939 let val: u32 = ::core::mem::transmute(val);
11940 self._bitfield_1.set(2usize, 1u8, val as u64)
11941 }
11942 }
11943 #[inline]
11944 pub fn discardable_flag(&self) -> u32 {
11945 unsafe { ::core::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
11946 }
11947 #[inline]
11948 pub fn set_discardable_flag(&mut self, val: u32) {
11949 unsafe {
11950 let val: u32 = ::core::mem::transmute(val);
11951 self._bitfield_1.set(3usize, 1u8, val as u64)
11952 }
11953 }
11954 #[inline]
11955 pub fn cross_layer_bla_flag(&self) -> u32 {
11956 unsafe { ::core::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
11957 }
11958 #[inline]
11959 pub fn set_cross_layer_bla_flag(&mut self, val: u32) {
11960 unsafe {
11961 let val: u32 = ::core::mem::transmute(val);
11962 self._bitfield_1.set(4usize, 1u8, val as u64)
11963 }
11964 }
11965 #[inline]
11966 pub fn pic_output_flag(&self) -> u32 {
11967 unsafe { ::core::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
11968 }
11969 #[inline]
11970 pub fn set_pic_output_flag(&mut self, val: u32) {
11971 unsafe {
11972 let val: u32 = ::core::mem::transmute(val);
11973 self._bitfield_1.set(5usize, 1u8, val as u64)
11974 }
11975 }
11976 #[inline]
11977 pub fn no_output_of_prior_pics_flag(&self) -> u32 {
11978 unsafe { ::core::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) }
11979 }
11980 #[inline]
11981 pub fn set_no_output_of_prior_pics_flag(&mut self, val: u32) {
11982 unsafe {
11983 let val: u32 = ::core::mem::transmute(val);
11984 self._bitfield_1.set(6usize, 1u8, val as u64)
11985 }
11986 }
11987 #[inline]
11988 pub fn short_term_ref_pic_set_sps_flag(&self) -> u32 {
11989 unsafe { ::core::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) }
11990 }
11991 #[inline]
11992 pub fn set_short_term_ref_pic_set_sps_flag(&mut self, val: u32) {
11993 unsafe {
11994 let val: u32 = ::core::mem::transmute(val);
11995 self._bitfield_1.set(7usize, 1u8, val as u64)
11996 }
11997 }
11998 #[inline]
11999 pub fn slice_temporal_mvp_enabled_flag(&self) -> u32 {
12000 unsafe { ::core::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) }
12001 }
12002 #[inline]
12003 pub fn set_slice_temporal_mvp_enabled_flag(&mut self, val: u32) {
12004 unsafe {
12005 let val: u32 = ::core::mem::transmute(val);
12006 self._bitfield_1.set(8usize, 1u8, val as u64)
12007 }
12008 }
12009 #[inline]
12010 pub fn reserved(&self) -> u32 {
12011 unsafe { ::core::mem::transmute(self._bitfield_1.get(9usize, 23u8) as u32) }
12012 }
12013 #[inline]
12014 pub fn set_reserved(&mut self, val: u32) {
12015 unsafe {
12016 let val: u32 = ::core::mem::transmute(val);
12017 self._bitfield_1.set(9usize, 23u8, val as u64)
12018 }
12019 }
12020 #[inline]
12021 pub fn new_bitfield_1(
12022 is_reference: u32,
12023 IrapPicFlag: u32,
12024 used_for_long_term_reference: u32,
12025 discardable_flag: u32,
12026 cross_layer_bla_flag: u32,
12027 pic_output_flag: u32,
12028 no_output_of_prior_pics_flag: u32,
12029 short_term_ref_pic_set_sps_flag: u32,
12030 slice_temporal_mvp_enabled_flag: u32,
12031 reserved: u32,
12032 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
12033 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
12034 __bindgen_bitfield_unit.set(0usize, 1u8, {
12035 let is_reference: u32 = unsafe { ::core::mem::transmute(is_reference) };
12036 is_reference as u64
12037 });
12038 __bindgen_bitfield_unit.set(1usize, 1u8, {
12039 let IrapPicFlag: u32 = unsafe { ::core::mem::transmute(IrapPicFlag) };
12040 IrapPicFlag as u64
12041 });
12042 __bindgen_bitfield_unit.set(2usize, 1u8, {
12043 let used_for_long_term_reference: u32 =
12044 unsafe { ::core::mem::transmute(used_for_long_term_reference) };
12045 used_for_long_term_reference as u64
12046 });
12047 __bindgen_bitfield_unit.set(3usize, 1u8, {
12048 let discardable_flag: u32 = unsafe { ::core::mem::transmute(discardable_flag) };
12049 discardable_flag as u64
12050 });
12051 __bindgen_bitfield_unit.set(4usize, 1u8, {
12052 let cross_layer_bla_flag: u32 = unsafe { ::core::mem::transmute(cross_layer_bla_flag) };
12053 cross_layer_bla_flag as u64
12054 });
12055 __bindgen_bitfield_unit.set(5usize, 1u8, {
12056 let pic_output_flag: u32 = unsafe { ::core::mem::transmute(pic_output_flag) };
12057 pic_output_flag as u64
12058 });
12059 __bindgen_bitfield_unit.set(6usize, 1u8, {
12060 let no_output_of_prior_pics_flag: u32 =
12061 unsafe { ::core::mem::transmute(no_output_of_prior_pics_flag) };
12062 no_output_of_prior_pics_flag as u64
12063 });
12064 __bindgen_bitfield_unit.set(7usize, 1u8, {
12065 let short_term_ref_pic_set_sps_flag: u32 =
12066 unsafe { ::core::mem::transmute(short_term_ref_pic_set_sps_flag) };
12067 short_term_ref_pic_set_sps_flag as u64
12068 });
12069 __bindgen_bitfield_unit.set(8usize, 1u8, {
12070 let slice_temporal_mvp_enabled_flag: u32 =
12071 unsafe { ::core::mem::transmute(slice_temporal_mvp_enabled_flag) };
12072 slice_temporal_mvp_enabled_flag as u64
12073 });
12074 __bindgen_bitfield_unit.set(9usize, 23u8, {
12075 let reserved: u32 = unsafe { ::core::mem::transmute(reserved) };
12076 reserved as u64
12077 });
12078 __bindgen_bitfield_unit
12079 }
12080}
12081#[repr(C)]
12082#[derive(Debug, Copy, Clone)]
12083pub struct StdVideoEncodeH265LongTermRefPics {
12084 pub num_long_term_sps: u8,
12085 pub num_long_term_pics: u8,
12086 pub lt_idx_sps: [u8; 32usize],
12087 pub poc_lsb_lt: [u8; 16usize],
12088 pub used_by_curr_pic_lt_flag: u16,
12089 pub delta_poc_msb_present_flag: [u8; 48usize],
12090 pub delta_poc_msb_cycle_lt: [u8; 48usize],
12091}
12092#[test]
12093fn bindgen_test_layout_StdVideoEncodeH265LongTermRefPics() {
12094 const UNINIT: ::core::mem::MaybeUninit<StdVideoEncodeH265LongTermRefPics> =
12095 ::core::mem::MaybeUninit::uninit();
12096 let ptr = UNINIT.as_ptr();
12097 assert_eq!(
12098 ::core::mem::size_of::<StdVideoEncodeH265LongTermRefPics>(),
12099 148usize,
12100 concat!("Size of: ", stringify!(StdVideoEncodeH265LongTermRefPics))
12101 );
12102 assert_eq!(
12103 ::core::mem::align_of::<StdVideoEncodeH265LongTermRefPics>(),
12104 2usize,
12105 concat!(
12106 "Alignment of ",
12107 stringify!(StdVideoEncodeH265LongTermRefPics)
12108 )
12109 );
12110 assert_eq!(
12111 unsafe { ::core::ptr::addr_of!((*ptr).num_long_term_sps) as usize - ptr as usize },
12112 0usize,
12113 concat!(
12114 "Offset of field: ",
12115 stringify!(StdVideoEncodeH265LongTermRefPics),
12116 "::",
12117 stringify!(num_long_term_sps)
12118 )
12119 );
12120 assert_eq!(
12121 unsafe { ::core::ptr::addr_of!((*ptr).num_long_term_pics) as usize - ptr as usize },
12122 1usize,
12123 concat!(
12124 "Offset of field: ",
12125 stringify!(StdVideoEncodeH265LongTermRefPics),
12126 "::",
12127 stringify!(num_long_term_pics)
12128 )
12129 );
12130 assert_eq!(
12131 unsafe { ::core::ptr::addr_of!((*ptr).lt_idx_sps) as usize - ptr as usize },
12132 2usize,
12133 concat!(
12134 "Offset of field: ",
12135 stringify!(StdVideoEncodeH265LongTermRefPics),
12136 "::",
12137 stringify!(lt_idx_sps)
12138 )
12139 );
12140 assert_eq!(
12141 unsafe { ::core::ptr::addr_of!((*ptr).poc_lsb_lt) as usize - ptr as usize },
12142 34usize,
12143 concat!(
12144 "Offset of field: ",
12145 stringify!(StdVideoEncodeH265LongTermRefPics),
12146 "::",
12147 stringify!(poc_lsb_lt)
12148 )
12149 );
12150 assert_eq!(
12151 unsafe { ::core::ptr::addr_of!((*ptr).used_by_curr_pic_lt_flag) as usize - ptr as usize },
12152 50usize,
12153 concat!(
12154 "Offset of field: ",
12155 stringify!(StdVideoEncodeH265LongTermRefPics),
12156 "::",
12157 stringify!(used_by_curr_pic_lt_flag)
12158 )
12159 );
12160 assert_eq!(
12161 unsafe { ::core::ptr::addr_of!((*ptr).delta_poc_msb_present_flag) as usize - ptr as usize },
12162 52usize,
12163 concat!(
12164 "Offset of field: ",
12165 stringify!(StdVideoEncodeH265LongTermRefPics),
12166 "::",
12167 stringify!(delta_poc_msb_present_flag)
12168 )
12169 );
12170 assert_eq!(
12171 unsafe { ::core::ptr::addr_of!((*ptr).delta_poc_msb_cycle_lt) as usize - ptr as usize },
12172 100usize,
12173 concat!(
12174 "Offset of field: ",
12175 stringify!(StdVideoEncodeH265LongTermRefPics),
12176 "::",
12177 stringify!(delta_poc_msb_cycle_lt)
12178 )
12179 );
12180}
12181#[repr(C)]
12182#[derive(Debug, Copy, Clone)]
12183pub struct StdVideoEncodeH265PictureInfo {
12184 pub flags: StdVideoEncodeH265PictureInfoFlags,
12185 pub pic_type: StdVideoH265PictureType,
12186 pub sps_video_parameter_set_id: u8,
12187 pub pps_seq_parameter_set_id: u8,
12188 pub pps_pic_parameter_set_id: u8,
12189 pub short_term_ref_pic_set_idx: u8,
12190 pub PicOrderCntVal: i32,
12191 pub TemporalId: u8,
12192 pub reserved1: [u8; 7usize],
12193 pub pRefLists: *const StdVideoEncodeH265ReferenceListsInfo,
12194 pub pShortTermRefPicSet: *const StdVideoH265ShortTermRefPicSet,
12195 pub pLongTermRefPics: *const StdVideoEncodeH265LongTermRefPics,
12196}
12197#[test]
12198fn bindgen_test_layout_StdVideoEncodeH265PictureInfo() {
12199 const UNINIT: ::core::mem::MaybeUninit<StdVideoEncodeH265PictureInfo> =
12200 ::core::mem::MaybeUninit::uninit();
12201 let ptr = UNINIT.as_ptr();
12202 assert_eq!(
12203 ::core::mem::size_of::<StdVideoEncodeH265PictureInfo>(),
12204 48usize,
12205 concat!("Size of: ", stringify!(StdVideoEncodeH265PictureInfo))
12206 );
12207 assert_eq!(
12208 ::core::mem::align_of::<StdVideoEncodeH265PictureInfo>(),
12209 8usize,
12210 concat!("Alignment of ", stringify!(StdVideoEncodeH265PictureInfo))
12211 );
12212 assert_eq!(
12213 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
12214 0usize,
12215 concat!(
12216 "Offset of field: ",
12217 stringify!(StdVideoEncodeH265PictureInfo),
12218 "::",
12219 stringify!(flags)
12220 )
12221 );
12222 assert_eq!(
12223 unsafe { ::core::ptr::addr_of!((*ptr).pic_type) as usize - ptr as usize },
12224 4usize,
12225 concat!(
12226 "Offset of field: ",
12227 stringify!(StdVideoEncodeH265PictureInfo),
12228 "::",
12229 stringify!(pic_type)
12230 )
12231 );
12232 assert_eq!(
12233 unsafe { ::core::ptr::addr_of!((*ptr).sps_video_parameter_set_id) as usize - ptr as usize },
12234 8usize,
12235 concat!(
12236 "Offset of field: ",
12237 stringify!(StdVideoEncodeH265PictureInfo),
12238 "::",
12239 stringify!(sps_video_parameter_set_id)
12240 )
12241 );
12242 assert_eq!(
12243 unsafe { ::core::ptr::addr_of!((*ptr).pps_seq_parameter_set_id) as usize - ptr as usize },
12244 9usize,
12245 concat!(
12246 "Offset of field: ",
12247 stringify!(StdVideoEncodeH265PictureInfo),
12248 "::",
12249 stringify!(pps_seq_parameter_set_id)
12250 )
12251 );
12252 assert_eq!(
12253 unsafe { ::core::ptr::addr_of!((*ptr).pps_pic_parameter_set_id) as usize - ptr as usize },
12254 10usize,
12255 concat!(
12256 "Offset of field: ",
12257 stringify!(StdVideoEncodeH265PictureInfo),
12258 "::",
12259 stringify!(pps_pic_parameter_set_id)
12260 )
12261 );
12262 assert_eq!(
12263 unsafe { ::core::ptr::addr_of!((*ptr).short_term_ref_pic_set_idx) as usize - ptr as usize },
12264 11usize,
12265 concat!(
12266 "Offset of field: ",
12267 stringify!(StdVideoEncodeH265PictureInfo),
12268 "::",
12269 stringify!(short_term_ref_pic_set_idx)
12270 )
12271 );
12272 assert_eq!(
12273 unsafe { ::core::ptr::addr_of!((*ptr).PicOrderCntVal) as usize - ptr as usize },
12274 12usize,
12275 concat!(
12276 "Offset of field: ",
12277 stringify!(StdVideoEncodeH265PictureInfo),
12278 "::",
12279 stringify!(PicOrderCntVal)
12280 )
12281 );
12282 assert_eq!(
12283 unsafe { ::core::ptr::addr_of!((*ptr).TemporalId) as usize - ptr as usize },
12284 16usize,
12285 concat!(
12286 "Offset of field: ",
12287 stringify!(StdVideoEncodeH265PictureInfo),
12288 "::",
12289 stringify!(TemporalId)
12290 )
12291 );
12292 assert_eq!(
12293 unsafe { ::core::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize },
12294 17usize,
12295 concat!(
12296 "Offset of field: ",
12297 stringify!(StdVideoEncodeH265PictureInfo),
12298 "::",
12299 stringify!(reserved1)
12300 )
12301 );
12302 assert_eq!(
12303 unsafe { ::core::ptr::addr_of!((*ptr).pRefLists) as usize - ptr as usize },
12304 24usize,
12305 concat!(
12306 "Offset of field: ",
12307 stringify!(StdVideoEncodeH265PictureInfo),
12308 "::",
12309 stringify!(pRefLists)
12310 )
12311 );
12312 assert_eq!(
12313 unsafe { ::core::ptr::addr_of!((*ptr).pShortTermRefPicSet) as usize - ptr as usize },
12314 32usize,
12315 concat!(
12316 "Offset of field: ",
12317 stringify!(StdVideoEncodeH265PictureInfo),
12318 "::",
12319 stringify!(pShortTermRefPicSet)
12320 )
12321 );
12322 assert_eq!(
12323 unsafe { ::core::ptr::addr_of!((*ptr).pLongTermRefPics) as usize - ptr as usize },
12324 40usize,
12325 concat!(
12326 "Offset of field: ",
12327 stringify!(StdVideoEncodeH265PictureInfo),
12328 "::",
12329 stringify!(pLongTermRefPics)
12330 )
12331 );
12332}
12333#[repr(C)]
12334#[derive(Debug, Copy, Clone)]
12335pub struct StdVideoEncodeH265ReferenceInfoFlags {
12336 pub _bitfield_align_1: [u32; 0],
12337 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
12338}
12339#[test]
12340fn bindgen_test_layout_StdVideoEncodeH265ReferenceInfoFlags() {
12341 assert_eq!(
12342 ::core::mem::size_of::<StdVideoEncodeH265ReferenceInfoFlags>(),
12343 4usize,
12344 concat!(
12345 "Size of: ",
12346 stringify!(StdVideoEncodeH265ReferenceInfoFlags)
12347 )
12348 );
12349 assert_eq!(
12350 ::core::mem::align_of::<StdVideoEncodeH265ReferenceInfoFlags>(),
12351 4usize,
12352 concat!(
12353 "Alignment of ",
12354 stringify!(StdVideoEncodeH265ReferenceInfoFlags)
12355 )
12356 );
12357}
12358impl StdVideoEncodeH265ReferenceInfoFlags {
12359 #[inline]
12360 pub fn used_for_long_term_reference(&self) -> u32 {
12361 unsafe { ::core::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
12362 }
12363 #[inline]
12364 pub fn set_used_for_long_term_reference(&mut self, val: u32) {
12365 unsafe {
12366 let val: u32 = ::core::mem::transmute(val);
12367 self._bitfield_1.set(0usize, 1u8, val as u64)
12368 }
12369 }
12370 #[inline]
12371 pub fn unused_for_reference(&self) -> u32 {
12372 unsafe { ::core::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
12373 }
12374 #[inline]
12375 pub fn set_unused_for_reference(&mut self, val: u32) {
12376 unsafe {
12377 let val: u32 = ::core::mem::transmute(val);
12378 self._bitfield_1.set(1usize, 1u8, val as u64)
12379 }
12380 }
12381 #[inline]
12382 pub fn reserved(&self) -> u32 {
12383 unsafe { ::core::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) }
12384 }
12385 #[inline]
12386 pub fn set_reserved(&mut self, val: u32) {
12387 unsafe {
12388 let val: u32 = ::core::mem::transmute(val);
12389 self._bitfield_1.set(2usize, 30u8, val as u64)
12390 }
12391 }
12392 #[inline]
12393 pub fn new_bitfield_1(
12394 used_for_long_term_reference: u32,
12395 unused_for_reference: u32,
12396 reserved: u32,
12397 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
12398 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
12399 __bindgen_bitfield_unit.set(0usize, 1u8, {
12400 let used_for_long_term_reference: u32 =
12401 unsafe { ::core::mem::transmute(used_for_long_term_reference) };
12402 used_for_long_term_reference as u64
12403 });
12404 __bindgen_bitfield_unit.set(1usize, 1u8, {
12405 let unused_for_reference: u32 = unsafe { ::core::mem::transmute(unused_for_reference) };
12406 unused_for_reference as u64
12407 });
12408 __bindgen_bitfield_unit.set(2usize, 30u8, {
12409 let reserved: u32 = unsafe { ::core::mem::transmute(reserved) };
12410 reserved as u64
12411 });
12412 __bindgen_bitfield_unit
12413 }
12414}
12415#[repr(C)]
12416#[derive(Debug, Copy, Clone)]
12417pub struct StdVideoEncodeH265ReferenceInfo {
12418 pub flags: StdVideoEncodeH265ReferenceInfoFlags,
12419 pub pic_type: StdVideoH265PictureType,
12420 pub PicOrderCntVal: i32,
12421 pub TemporalId: u8,
12422}
12423#[test]
12424fn bindgen_test_layout_StdVideoEncodeH265ReferenceInfo() {
12425 const UNINIT: ::core::mem::MaybeUninit<StdVideoEncodeH265ReferenceInfo> =
12426 ::core::mem::MaybeUninit::uninit();
12427 let ptr = UNINIT.as_ptr();
12428 assert_eq!(
12429 ::core::mem::size_of::<StdVideoEncodeH265ReferenceInfo>(),
12430 16usize,
12431 concat!("Size of: ", stringify!(StdVideoEncodeH265ReferenceInfo))
12432 );
12433 assert_eq!(
12434 ::core::mem::align_of::<StdVideoEncodeH265ReferenceInfo>(),
12435 4usize,
12436 concat!("Alignment of ", stringify!(StdVideoEncodeH265ReferenceInfo))
12437 );
12438 assert_eq!(
12439 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
12440 0usize,
12441 concat!(
12442 "Offset of field: ",
12443 stringify!(StdVideoEncodeH265ReferenceInfo),
12444 "::",
12445 stringify!(flags)
12446 )
12447 );
12448 assert_eq!(
12449 unsafe { ::core::ptr::addr_of!((*ptr).pic_type) as usize - ptr as usize },
12450 4usize,
12451 concat!(
12452 "Offset of field: ",
12453 stringify!(StdVideoEncodeH265ReferenceInfo),
12454 "::",
12455 stringify!(pic_type)
12456 )
12457 );
12458 assert_eq!(
12459 unsafe { ::core::ptr::addr_of!((*ptr).PicOrderCntVal) as usize - ptr as usize },
12460 8usize,
12461 concat!(
12462 "Offset of field: ",
12463 stringify!(StdVideoEncodeH265ReferenceInfo),
12464 "::",
12465 stringify!(PicOrderCntVal)
12466 )
12467 );
12468 assert_eq!(
12469 unsafe { ::core::ptr::addr_of!((*ptr).TemporalId) as usize - ptr as usize },
12470 12usize,
12471 concat!(
12472 "Offset of field: ",
12473 stringify!(StdVideoEncodeH265ReferenceInfo),
12474 "::",
12475 stringify!(TemporalId)
12476 )
12477 );
12478}