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 StdVideoVP9Profile_STD_VIDEO_VP9_PROFILE_0: StdVideoVP9Profile = 0;
6605pub const StdVideoVP9Profile_STD_VIDEO_VP9_PROFILE_1: StdVideoVP9Profile = 1;
6606pub const StdVideoVP9Profile_STD_VIDEO_VP9_PROFILE_2: StdVideoVP9Profile = 2;
6607pub const StdVideoVP9Profile_STD_VIDEO_VP9_PROFILE_3: StdVideoVP9Profile = 3;
6608pub const StdVideoVP9Profile_STD_VIDEO_VP9_PROFILE_INVALID: StdVideoVP9Profile = 2147483647;
6609pub type StdVideoVP9Profile = ::core::ffi::c_uint;
6610pub const StdVideoVP9Level_STD_VIDEO_VP9_LEVEL_1_0: StdVideoVP9Level = 0;
6611pub const StdVideoVP9Level_STD_VIDEO_VP9_LEVEL_1_1: StdVideoVP9Level = 1;
6612pub const StdVideoVP9Level_STD_VIDEO_VP9_LEVEL_2_0: StdVideoVP9Level = 2;
6613pub const StdVideoVP9Level_STD_VIDEO_VP9_LEVEL_2_1: StdVideoVP9Level = 3;
6614pub const StdVideoVP9Level_STD_VIDEO_VP9_LEVEL_3_0: StdVideoVP9Level = 4;
6615pub const StdVideoVP9Level_STD_VIDEO_VP9_LEVEL_3_1: StdVideoVP9Level = 5;
6616pub const StdVideoVP9Level_STD_VIDEO_VP9_LEVEL_4_0: StdVideoVP9Level = 6;
6617pub const StdVideoVP9Level_STD_VIDEO_VP9_LEVEL_4_1: StdVideoVP9Level = 7;
6618pub const StdVideoVP9Level_STD_VIDEO_VP9_LEVEL_5_0: StdVideoVP9Level = 8;
6619pub const StdVideoVP9Level_STD_VIDEO_VP9_LEVEL_5_1: StdVideoVP9Level = 9;
6620pub const StdVideoVP9Level_STD_VIDEO_VP9_LEVEL_5_2: StdVideoVP9Level = 10;
6621pub const StdVideoVP9Level_STD_VIDEO_VP9_LEVEL_6_0: StdVideoVP9Level = 11;
6622pub const StdVideoVP9Level_STD_VIDEO_VP9_LEVEL_6_1: StdVideoVP9Level = 12;
6623pub const StdVideoVP9Level_STD_VIDEO_VP9_LEVEL_6_2: StdVideoVP9Level = 13;
6624pub const StdVideoVP9Level_STD_VIDEO_VP9_LEVEL_INVALID: StdVideoVP9Level = 2147483647;
6625pub type StdVideoVP9Level = ::core::ffi::c_uint;
6626pub const StdVideoVP9FrameType_STD_VIDEO_VP9_FRAME_TYPE_KEY: StdVideoVP9FrameType = 0;
6627pub const StdVideoVP9FrameType_STD_VIDEO_VP9_FRAME_TYPE_NON_KEY: StdVideoVP9FrameType = 1;
6628pub const StdVideoVP9FrameType_STD_VIDEO_VP9_FRAME_TYPE_INVALID: StdVideoVP9FrameType = 2147483647;
6629pub type StdVideoVP9FrameType = ::core::ffi::c_uint;
6630pub const StdVideoVP9InterpolationFilter_STD_VIDEO_VP9_INTERPOLATION_FILTER_EIGHTTAP:
6631 StdVideoVP9InterpolationFilter = 0;
6632pub const StdVideoVP9InterpolationFilter_STD_VIDEO_VP9_INTERPOLATION_FILTER_EIGHTTAP_SMOOTH:
6633 StdVideoVP9InterpolationFilter = 1;
6634pub const StdVideoVP9InterpolationFilter_STD_VIDEO_VP9_INTERPOLATION_FILTER_EIGHTTAP_SHARP:
6635 StdVideoVP9InterpolationFilter = 2;
6636pub const StdVideoVP9InterpolationFilter_STD_VIDEO_VP9_INTERPOLATION_FILTER_BILINEAR:
6637 StdVideoVP9InterpolationFilter = 3;
6638pub const StdVideoVP9InterpolationFilter_STD_VIDEO_VP9_INTERPOLATION_FILTER_SWITCHABLE:
6639 StdVideoVP9InterpolationFilter = 4;
6640pub const StdVideoVP9InterpolationFilter_STD_VIDEO_VP9_INTERPOLATION_FILTER_INVALID:
6641 StdVideoVP9InterpolationFilter = 2147483647;
6642pub type StdVideoVP9InterpolationFilter = ::core::ffi::c_uint;
6643pub const StdVideoVP9ColorSpace_STD_VIDEO_VP9_COLOR_SPACE_UNKNOWN: StdVideoVP9ColorSpace = 0;
6644pub const StdVideoVP9ColorSpace_STD_VIDEO_VP9_COLOR_SPACE_BT_601: StdVideoVP9ColorSpace = 1;
6645pub const StdVideoVP9ColorSpace_STD_VIDEO_VP9_COLOR_SPACE_BT_709: StdVideoVP9ColorSpace = 2;
6646pub const StdVideoVP9ColorSpace_STD_VIDEO_VP9_COLOR_SPACE_SMPTE_170: StdVideoVP9ColorSpace = 3;
6647pub const StdVideoVP9ColorSpace_STD_VIDEO_VP9_COLOR_SPACE_SMPTE_240: StdVideoVP9ColorSpace = 4;
6648pub const StdVideoVP9ColorSpace_STD_VIDEO_VP9_COLOR_SPACE_BT_2020: StdVideoVP9ColorSpace = 5;
6649pub const StdVideoVP9ColorSpace_STD_VIDEO_VP9_COLOR_SPACE_RESERVED: StdVideoVP9ColorSpace = 6;
6650pub const StdVideoVP9ColorSpace_STD_VIDEO_VP9_COLOR_SPACE_RGB: StdVideoVP9ColorSpace = 7;
6651pub const StdVideoVP9ColorSpace_STD_VIDEO_VP9_COLOR_SPACE_INVALID: StdVideoVP9ColorSpace =
6652 2147483647;
6653pub type StdVideoVP9ColorSpace = ::core::ffi::c_uint;
6654#[repr(C)]
6655#[derive(Debug, Copy, Clone)]
6656pub struct StdVideoVP9ColorConfigFlags {
6657 pub _bitfield_align_1: [u32; 0],
6658 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
6659}
6660#[test]
6661fn bindgen_test_layout_StdVideoVP9ColorConfigFlags() {
6662 assert_eq!(
6663 ::core::mem::size_of::<StdVideoVP9ColorConfigFlags>(),
6664 4usize,
6665 concat!("Size of: ", stringify!(StdVideoVP9ColorConfigFlags))
6666 );
6667 assert_eq!(
6668 ::core::mem::align_of::<StdVideoVP9ColorConfigFlags>(),
6669 4usize,
6670 concat!("Alignment of ", stringify!(StdVideoVP9ColorConfigFlags))
6671 );
6672}
6673impl StdVideoVP9ColorConfigFlags {
6674 #[inline]
6675 pub fn color_range(&self) -> u32 {
6676 unsafe { ::core::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
6677 }
6678 #[inline]
6679 pub fn set_color_range(&mut self, val: u32) {
6680 unsafe {
6681 let val: u32 = ::core::mem::transmute(val);
6682 self._bitfield_1.set(0usize, 1u8, val as u64)
6683 }
6684 }
6685 #[inline]
6686 pub fn reserved(&self) -> u32 {
6687 unsafe { ::core::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) }
6688 }
6689 #[inline]
6690 pub fn set_reserved(&mut self, val: u32) {
6691 unsafe {
6692 let val: u32 = ::core::mem::transmute(val);
6693 self._bitfield_1.set(1usize, 31u8, val as u64)
6694 }
6695 }
6696 #[inline]
6697 pub fn new_bitfield_1(color_range: u32, reserved: u32) -> __BindgenBitfieldUnit<[u8; 4usize]> {
6698 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
6699 __bindgen_bitfield_unit.set(0usize, 1u8, {
6700 let color_range: u32 = unsafe { ::core::mem::transmute(color_range) };
6701 color_range as u64
6702 });
6703 __bindgen_bitfield_unit.set(1usize, 31u8, {
6704 let reserved: u32 = unsafe { ::core::mem::transmute(reserved) };
6705 reserved as u64
6706 });
6707 __bindgen_bitfield_unit
6708 }
6709}
6710#[repr(C)]
6711#[derive(Debug, Copy, Clone)]
6712pub struct StdVideoVP9ColorConfig {
6713 pub flags: StdVideoVP9ColorConfigFlags,
6714 pub BitDepth: u8,
6715 pub subsampling_x: u8,
6716 pub subsampling_y: u8,
6717 pub reserved1: u8,
6718 pub color_space: StdVideoVP9ColorSpace,
6719}
6720#[test]
6721fn bindgen_test_layout_StdVideoVP9ColorConfig() {
6722 const UNINIT: ::core::mem::MaybeUninit<StdVideoVP9ColorConfig> =
6723 ::core::mem::MaybeUninit::uninit();
6724 let ptr = UNINIT.as_ptr();
6725 assert_eq!(
6726 ::core::mem::size_of::<StdVideoVP9ColorConfig>(),
6727 12usize,
6728 concat!("Size of: ", stringify!(StdVideoVP9ColorConfig))
6729 );
6730 assert_eq!(
6731 ::core::mem::align_of::<StdVideoVP9ColorConfig>(),
6732 4usize,
6733 concat!("Alignment of ", stringify!(StdVideoVP9ColorConfig))
6734 );
6735 assert_eq!(
6736 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
6737 0usize,
6738 concat!(
6739 "Offset of field: ",
6740 stringify!(StdVideoVP9ColorConfig),
6741 "::",
6742 stringify!(flags)
6743 )
6744 );
6745 assert_eq!(
6746 unsafe { ::core::ptr::addr_of!((*ptr).BitDepth) as usize - ptr as usize },
6747 4usize,
6748 concat!(
6749 "Offset of field: ",
6750 stringify!(StdVideoVP9ColorConfig),
6751 "::",
6752 stringify!(BitDepth)
6753 )
6754 );
6755 assert_eq!(
6756 unsafe { ::core::ptr::addr_of!((*ptr).subsampling_x) as usize - ptr as usize },
6757 5usize,
6758 concat!(
6759 "Offset of field: ",
6760 stringify!(StdVideoVP9ColorConfig),
6761 "::",
6762 stringify!(subsampling_x)
6763 )
6764 );
6765 assert_eq!(
6766 unsafe { ::core::ptr::addr_of!((*ptr).subsampling_y) as usize - ptr as usize },
6767 6usize,
6768 concat!(
6769 "Offset of field: ",
6770 stringify!(StdVideoVP9ColorConfig),
6771 "::",
6772 stringify!(subsampling_y)
6773 )
6774 );
6775 assert_eq!(
6776 unsafe { ::core::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize },
6777 7usize,
6778 concat!(
6779 "Offset of field: ",
6780 stringify!(StdVideoVP9ColorConfig),
6781 "::",
6782 stringify!(reserved1)
6783 )
6784 );
6785 assert_eq!(
6786 unsafe { ::core::ptr::addr_of!((*ptr).color_space) as usize - ptr as usize },
6787 8usize,
6788 concat!(
6789 "Offset of field: ",
6790 stringify!(StdVideoVP9ColorConfig),
6791 "::",
6792 stringify!(color_space)
6793 )
6794 );
6795}
6796#[repr(C)]
6797#[derive(Debug, Copy, Clone)]
6798pub struct StdVideoVP9LoopFilterFlags {
6799 pub _bitfield_align_1: [u32; 0],
6800 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
6801}
6802#[test]
6803fn bindgen_test_layout_StdVideoVP9LoopFilterFlags() {
6804 assert_eq!(
6805 ::core::mem::size_of::<StdVideoVP9LoopFilterFlags>(),
6806 4usize,
6807 concat!("Size of: ", stringify!(StdVideoVP9LoopFilterFlags))
6808 );
6809 assert_eq!(
6810 ::core::mem::align_of::<StdVideoVP9LoopFilterFlags>(),
6811 4usize,
6812 concat!("Alignment of ", stringify!(StdVideoVP9LoopFilterFlags))
6813 );
6814}
6815impl StdVideoVP9LoopFilterFlags {
6816 #[inline]
6817 pub fn loop_filter_delta_enabled(&self) -> u32 {
6818 unsafe { ::core::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
6819 }
6820 #[inline]
6821 pub fn set_loop_filter_delta_enabled(&mut self, val: u32) {
6822 unsafe {
6823 let val: u32 = ::core::mem::transmute(val);
6824 self._bitfield_1.set(0usize, 1u8, val as u64)
6825 }
6826 }
6827 #[inline]
6828 pub fn loop_filter_delta_update(&self) -> u32 {
6829 unsafe { ::core::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
6830 }
6831 #[inline]
6832 pub fn set_loop_filter_delta_update(&mut self, val: u32) {
6833 unsafe {
6834 let val: u32 = ::core::mem::transmute(val);
6835 self._bitfield_1.set(1usize, 1u8, val as u64)
6836 }
6837 }
6838 #[inline]
6839 pub fn reserved(&self) -> u32 {
6840 unsafe { ::core::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) }
6841 }
6842 #[inline]
6843 pub fn set_reserved(&mut self, val: u32) {
6844 unsafe {
6845 let val: u32 = ::core::mem::transmute(val);
6846 self._bitfield_1.set(2usize, 30u8, val as u64)
6847 }
6848 }
6849 #[inline]
6850 pub fn new_bitfield_1(
6851 loop_filter_delta_enabled: u32,
6852 loop_filter_delta_update: u32,
6853 reserved: u32,
6854 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
6855 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
6856 __bindgen_bitfield_unit.set(0usize, 1u8, {
6857 let loop_filter_delta_enabled: u32 =
6858 unsafe { ::core::mem::transmute(loop_filter_delta_enabled) };
6859 loop_filter_delta_enabled as u64
6860 });
6861 __bindgen_bitfield_unit.set(1usize, 1u8, {
6862 let loop_filter_delta_update: u32 =
6863 unsafe { ::core::mem::transmute(loop_filter_delta_update) };
6864 loop_filter_delta_update as u64
6865 });
6866 __bindgen_bitfield_unit.set(2usize, 30u8, {
6867 let reserved: u32 = unsafe { ::core::mem::transmute(reserved) };
6868 reserved as u64
6869 });
6870 __bindgen_bitfield_unit
6871 }
6872}
6873#[repr(C)]
6874#[derive(Debug, Copy, Clone)]
6875pub struct StdVideoVP9LoopFilter {
6876 pub flags: StdVideoVP9LoopFilterFlags,
6877 pub loop_filter_level: u8,
6878 pub loop_filter_sharpness: u8,
6879 pub update_ref_delta: u8,
6880 pub loop_filter_ref_deltas: [i8; 4usize],
6881 pub update_mode_delta: u8,
6882 pub loop_filter_mode_deltas: [i8; 2usize],
6883}
6884#[test]
6885fn bindgen_test_layout_StdVideoVP9LoopFilter() {
6886 const UNINIT: ::core::mem::MaybeUninit<StdVideoVP9LoopFilter> =
6887 ::core::mem::MaybeUninit::uninit();
6888 let ptr = UNINIT.as_ptr();
6889 assert_eq!(
6890 ::core::mem::size_of::<StdVideoVP9LoopFilter>(),
6891 16usize,
6892 concat!("Size of: ", stringify!(StdVideoVP9LoopFilter))
6893 );
6894 assert_eq!(
6895 ::core::mem::align_of::<StdVideoVP9LoopFilter>(),
6896 4usize,
6897 concat!("Alignment of ", stringify!(StdVideoVP9LoopFilter))
6898 );
6899 assert_eq!(
6900 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
6901 0usize,
6902 concat!(
6903 "Offset of field: ",
6904 stringify!(StdVideoVP9LoopFilter),
6905 "::",
6906 stringify!(flags)
6907 )
6908 );
6909 assert_eq!(
6910 unsafe { ::core::ptr::addr_of!((*ptr).loop_filter_level) as usize - ptr as usize },
6911 4usize,
6912 concat!(
6913 "Offset of field: ",
6914 stringify!(StdVideoVP9LoopFilter),
6915 "::",
6916 stringify!(loop_filter_level)
6917 )
6918 );
6919 assert_eq!(
6920 unsafe { ::core::ptr::addr_of!((*ptr).loop_filter_sharpness) as usize - ptr as usize },
6921 5usize,
6922 concat!(
6923 "Offset of field: ",
6924 stringify!(StdVideoVP9LoopFilter),
6925 "::",
6926 stringify!(loop_filter_sharpness)
6927 )
6928 );
6929 assert_eq!(
6930 unsafe { ::core::ptr::addr_of!((*ptr).update_ref_delta) as usize - ptr as usize },
6931 6usize,
6932 concat!(
6933 "Offset of field: ",
6934 stringify!(StdVideoVP9LoopFilter),
6935 "::",
6936 stringify!(update_ref_delta)
6937 )
6938 );
6939 assert_eq!(
6940 unsafe { ::core::ptr::addr_of!((*ptr).loop_filter_ref_deltas) as usize - ptr as usize },
6941 7usize,
6942 concat!(
6943 "Offset of field: ",
6944 stringify!(StdVideoVP9LoopFilter),
6945 "::",
6946 stringify!(loop_filter_ref_deltas)
6947 )
6948 );
6949 assert_eq!(
6950 unsafe { ::core::ptr::addr_of!((*ptr).update_mode_delta) as usize - ptr as usize },
6951 11usize,
6952 concat!(
6953 "Offset of field: ",
6954 stringify!(StdVideoVP9LoopFilter),
6955 "::",
6956 stringify!(update_mode_delta)
6957 )
6958 );
6959 assert_eq!(
6960 unsafe { ::core::ptr::addr_of!((*ptr).loop_filter_mode_deltas) as usize - ptr as usize },
6961 12usize,
6962 concat!(
6963 "Offset of field: ",
6964 stringify!(StdVideoVP9LoopFilter),
6965 "::",
6966 stringify!(loop_filter_mode_deltas)
6967 )
6968 );
6969}
6970#[repr(C)]
6971#[derive(Debug, Copy, Clone)]
6972pub struct StdVideoVP9SegmentationFlags {
6973 pub _bitfield_align_1: [u32; 0],
6974 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
6975}
6976#[test]
6977fn bindgen_test_layout_StdVideoVP9SegmentationFlags() {
6978 assert_eq!(
6979 ::core::mem::size_of::<StdVideoVP9SegmentationFlags>(),
6980 4usize,
6981 concat!("Size of: ", stringify!(StdVideoVP9SegmentationFlags))
6982 );
6983 assert_eq!(
6984 ::core::mem::align_of::<StdVideoVP9SegmentationFlags>(),
6985 4usize,
6986 concat!("Alignment of ", stringify!(StdVideoVP9SegmentationFlags))
6987 );
6988}
6989impl StdVideoVP9SegmentationFlags {
6990 #[inline]
6991 pub fn segmentation_update_map(&self) -> u32 {
6992 unsafe { ::core::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
6993 }
6994 #[inline]
6995 pub fn set_segmentation_update_map(&mut self, val: u32) {
6996 unsafe {
6997 let val: u32 = ::core::mem::transmute(val);
6998 self._bitfield_1.set(0usize, 1u8, val as u64)
6999 }
7000 }
7001 #[inline]
7002 pub fn segmentation_temporal_update(&self) -> u32 {
7003 unsafe { ::core::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
7004 }
7005 #[inline]
7006 pub fn set_segmentation_temporal_update(&mut self, val: u32) {
7007 unsafe {
7008 let val: u32 = ::core::mem::transmute(val);
7009 self._bitfield_1.set(1usize, 1u8, val as u64)
7010 }
7011 }
7012 #[inline]
7013 pub fn segmentation_update_data(&self) -> u32 {
7014 unsafe { ::core::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
7015 }
7016 #[inline]
7017 pub fn set_segmentation_update_data(&mut self, val: u32) {
7018 unsafe {
7019 let val: u32 = ::core::mem::transmute(val);
7020 self._bitfield_1.set(2usize, 1u8, val as u64)
7021 }
7022 }
7023 #[inline]
7024 pub fn segmentation_abs_or_delta_update(&self) -> u32 {
7025 unsafe { ::core::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
7026 }
7027 #[inline]
7028 pub fn set_segmentation_abs_or_delta_update(&mut self, val: u32) {
7029 unsafe {
7030 let val: u32 = ::core::mem::transmute(val);
7031 self._bitfield_1.set(3usize, 1u8, val as u64)
7032 }
7033 }
7034 #[inline]
7035 pub fn reserved(&self) -> u32 {
7036 unsafe { ::core::mem::transmute(self._bitfield_1.get(4usize, 28u8) as u32) }
7037 }
7038 #[inline]
7039 pub fn set_reserved(&mut self, val: u32) {
7040 unsafe {
7041 let val: u32 = ::core::mem::transmute(val);
7042 self._bitfield_1.set(4usize, 28u8, val as u64)
7043 }
7044 }
7045 #[inline]
7046 pub fn new_bitfield_1(
7047 segmentation_update_map: u32,
7048 segmentation_temporal_update: u32,
7049 segmentation_update_data: u32,
7050 segmentation_abs_or_delta_update: 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 segmentation_update_map: u32 =
7056 unsafe { ::core::mem::transmute(segmentation_update_map) };
7057 segmentation_update_map as u64
7058 });
7059 __bindgen_bitfield_unit.set(1usize, 1u8, {
7060 let segmentation_temporal_update: u32 =
7061 unsafe { ::core::mem::transmute(segmentation_temporal_update) };
7062 segmentation_temporal_update as u64
7063 });
7064 __bindgen_bitfield_unit.set(2usize, 1u8, {
7065 let segmentation_update_data: u32 =
7066 unsafe { ::core::mem::transmute(segmentation_update_data) };
7067 segmentation_update_data as u64
7068 });
7069 __bindgen_bitfield_unit.set(3usize, 1u8, {
7070 let segmentation_abs_or_delta_update: u32 =
7071 unsafe { ::core::mem::transmute(segmentation_abs_or_delta_update) };
7072 segmentation_abs_or_delta_update as u64
7073 });
7074 __bindgen_bitfield_unit.set(4usize, 28u8, {
7075 let reserved: u32 = unsafe { ::core::mem::transmute(reserved) };
7076 reserved as u64
7077 });
7078 __bindgen_bitfield_unit
7079 }
7080}
7081#[repr(C)]
7082#[derive(Debug, Copy, Clone)]
7083pub struct StdVideoVP9Segmentation {
7084 pub flags: StdVideoVP9SegmentationFlags,
7085 pub segmentation_tree_probs: [u8; 7usize],
7086 pub segmentation_pred_prob: [u8; 3usize],
7087 pub FeatureEnabled: [u8; 8usize],
7088 pub FeatureData: [[i16; 4usize]; 8usize],
7089}
7090#[test]
7091fn bindgen_test_layout_StdVideoVP9Segmentation() {
7092 const UNINIT: ::core::mem::MaybeUninit<StdVideoVP9Segmentation> =
7093 ::core::mem::MaybeUninit::uninit();
7094 let ptr = UNINIT.as_ptr();
7095 assert_eq!(
7096 ::core::mem::size_of::<StdVideoVP9Segmentation>(),
7097 88usize,
7098 concat!("Size of: ", stringify!(StdVideoVP9Segmentation))
7099 );
7100 assert_eq!(
7101 ::core::mem::align_of::<StdVideoVP9Segmentation>(),
7102 4usize,
7103 concat!("Alignment of ", stringify!(StdVideoVP9Segmentation))
7104 );
7105 assert_eq!(
7106 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
7107 0usize,
7108 concat!(
7109 "Offset of field: ",
7110 stringify!(StdVideoVP9Segmentation),
7111 "::",
7112 stringify!(flags)
7113 )
7114 );
7115 assert_eq!(
7116 unsafe { ::core::ptr::addr_of!((*ptr).segmentation_tree_probs) as usize - ptr as usize },
7117 4usize,
7118 concat!(
7119 "Offset of field: ",
7120 stringify!(StdVideoVP9Segmentation),
7121 "::",
7122 stringify!(segmentation_tree_probs)
7123 )
7124 );
7125 assert_eq!(
7126 unsafe { ::core::ptr::addr_of!((*ptr).segmentation_pred_prob) as usize - ptr as usize },
7127 11usize,
7128 concat!(
7129 "Offset of field: ",
7130 stringify!(StdVideoVP9Segmentation),
7131 "::",
7132 stringify!(segmentation_pred_prob)
7133 )
7134 );
7135 assert_eq!(
7136 unsafe { ::core::ptr::addr_of!((*ptr).FeatureEnabled) as usize - ptr as usize },
7137 14usize,
7138 concat!(
7139 "Offset of field: ",
7140 stringify!(StdVideoVP9Segmentation),
7141 "::",
7142 stringify!(FeatureEnabled)
7143 )
7144 );
7145 assert_eq!(
7146 unsafe { ::core::ptr::addr_of!((*ptr).FeatureData) as usize - ptr as usize },
7147 22usize,
7148 concat!(
7149 "Offset of field: ",
7150 stringify!(StdVideoVP9Segmentation),
7151 "::",
7152 stringify!(FeatureData)
7153 )
7154 );
7155}
7156#[repr(C)]
7157#[derive(Debug, Copy, Clone)]
7158pub struct StdVideoDecodeVP9PictureInfoFlags {
7159 pub _bitfield_align_1: [u32; 0],
7160 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
7161}
7162#[test]
7163fn bindgen_test_layout_StdVideoDecodeVP9PictureInfoFlags() {
7164 assert_eq!(
7165 ::core::mem::size_of::<StdVideoDecodeVP9PictureInfoFlags>(),
7166 4usize,
7167 concat!("Size of: ", stringify!(StdVideoDecodeVP9PictureInfoFlags))
7168 );
7169 assert_eq!(
7170 ::core::mem::align_of::<StdVideoDecodeVP9PictureInfoFlags>(),
7171 4usize,
7172 concat!(
7173 "Alignment of ",
7174 stringify!(StdVideoDecodeVP9PictureInfoFlags)
7175 )
7176 );
7177}
7178impl StdVideoDecodeVP9PictureInfoFlags {
7179 #[inline]
7180 pub fn error_resilient_mode(&self) -> u32 {
7181 unsafe { ::core::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
7182 }
7183 #[inline]
7184 pub fn set_error_resilient_mode(&mut self, val: u32) {
7185 unsafe {
7186 let val: u32 = ::core::mem::transmute(val);
7187 self._bitfield_1.set(0usize, 1u8, val as u64)
7188 }
7189 }
7190 #[inline]
7191 pub fn intra_only(&self) -> u32 {
7192 unsafe { ::core::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
7193 }
7194 #[inline]
7195 pub fn set_intra_only(&mut self, val: u32) {
7196 unsafe {
7197 let val: u32 = ::core::mem::transmute(val);
7198 self._bitfield_1.set(1usize, 1u8, val as u64)
7199 }
7200 }
7201 #[inline]
7202 pub fn allow_high_precision_mv(&self) -> u32 {
7203 unsafe { ::core::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
7204 }
7205 #[inline]
7206 pub fn set_allow_high_precision_mv(&mut self, val: u32) {
7207 unsafe {
7208 let val: u32 = ::core::mem::transmute(val);
7209 self._bitfield_1.set(2usize, 1u8, val as u64)
7210 }
7211 }
7212 #[inline]
7213 pub fn refresh_frame_context(&self) -> u32 {
7214 unsafe { ::core::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
7215 }
7216 #[inline]
7217 pub fn set_refresh_frame_context(&mut self, val: u32) {
7218 unsafe {
7219 let val: u32 = ::core::mem::transmute(val);
7220 self._bitfield_1.set(3usize, 1u8, val as u64)
7221 }
7222 }
7223 #[inline]
7224 pub fn frame_parallel_decoding_mode(&self) -> u32 {
7225 unsafe { ::core::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
7226 }
7227 #[inline]
7228 pub fn set_frame_parallel_decoding_mode(&mut self, val: u32) {
7229 unsafe {
7230 let val: u32 = ::core::mem::transmute(val);
7231 self._bitfield_1.set(4usize, 1u8, val as u64)
7232 }
7233 }
7234 #[inline]
7235 pub fn segmentation_enabled(&self) -> u32 {
7236 unsafe { ::core::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
7237 }
7238 #[inline]
7239 pub fn set_segmentation_enabled(&mut self, val: u32) {
7240 unsafe {
7241 let val: u32 = ::core::mem::transmute(val);
7242 self._bitfield_1.set(5usize, 1u8, val as u64)
7243 }
7244 }
7245 #[inline]
7246 pub fn show_frame(&self) -> u32 {
7247 unsafe { ::core::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) }
7248 }
7249 #[inline]
7250 pub fn set_show_frame(&mut self, val: u32) {
7251 unsafe {
7252 let val: u32 = ::core::mem::transmute(val);
7253 self._bitfield_1.set(6usize, 1u8, val as u64)
7254 }
7255 }
7256 #[inline]
7257 pub fn UsePrevFrameMvs(&self) -> u32 {
7258 unsafe { ::core::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) }
7259 }
7260 #[inline]
7261 pub fn set_UsePrevFrameMvs(&mut self, val: u32) {
7262 unsafe {
7263 let val: u32 = ::core::mem::transmute(val);
7264 self._bitfield_1.set(7usize, 1u8, val as u64)
7265 }
7266 }
7267 #[inline]
7268 pub fn reserved(&self) -> u32 {
7269 unsafe { ::core::mem::transmute(self._bitfield_1.get(8usize, 24u8) as u32) }
7270 }
7271 #[inline]
7272 pub fn set_reserved(&mut self, val: u32) {
7273 unsafe {
7274 let val: u32 = ::core::mem::transmute(val);
7275 self._bitfield_1.set(8usize, 24u8, val as u64)
7276 }
7277 }
7278 #[inline]
7279 pub fn new_bitfield_1(
7280 error_resilient_mode: u32,
7281 intra_only: u32,
7282 allow_high_precision_mv: u32,
7283 refresh_frame_context: u32,
7284 frame_parallel_decoding_mode: u32,
7285 segmentation_enabled: u32,
7286 show_frame: u32,
7287 UsePrevFrameMvs: u32,
7288 reserved: u32,
7289 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
7290 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
7291 __bindgen_bitfield_unit.set(0usize, 1u8, {
7292 let error_resilient_mode: u32 = unsafe { ::core::mem::transmute(error_resilient_mode) };
7293 error_resilient_mode as u64
7294 });
7295 __bindgen_bitfield_unit.set(1usize, 1u8, {
7296 let intra_only: u32 = unsafe { ::core::mem::transmute(intra_only) };
7297 intra_only as u64
7298 });
7299 __bindgen_bitfield_unit.set(2usize, 1u8, {
7300 let allow_high_precision_mv: u32 =
7301 unsafe { ::core::mem::transmute(allow_high_precision_mv) };
7302 allow_high_precision_mv as u64
7303 });
7304 __bindgen_bitfield_unit.set(3usize, 1u8, {
7305 let refresh_frame_context: u32 =
7306 unsafe { ::core::mem::transmute(refresh_frame_context) };
7307 refresh_frame_context as u64
7308 });
7309 __bindgen_bitfield_unit.set(4usize, 1u8, {
7310 let frame_parallel_decoding_mode: u32 =
7311 unsafe { ::core::mem::transmute(frame_parallel_decoding_mode) };
7312 frame_parallel_decoding_mode as u64
7313 });
7314 __bindgen_bitfield_unit.set(5usize, 1u8, {
7315 let segmentation_enabled: u32 = unsafe { ::core::mem::transmute(segmentation_enabled) };
7316 segmentation_enabled as u64
7317 });
7318 __bindgen_bitfield_unit.set(6usize, 1u8, {
7319 let show_frame: u32 = unsafe { ::core::mem::transmute(show_frame) };
7320 show_frame as u64
7321 });
7322 __bindgen_bitfield_unit.set(7usize, 1u8, {
7323 let UsePrevFrameMvs: u32 = unsafe { ::core::mem::transmute(UsePrevFrameMvs) };
7324 UsePrevFrameMvs as u64
7325 });
7326 __bindgen_bitfield_unit.set(8usize, 24u8, {
7327 let reserved: u32 = unsafe { ::core::mem::transmute(reserved) };
7328 reserved as u64
7329 });
7330 __bindgen_bitfield_unit
7331 }
7332}
7333#[repr(C)]
7334#[derive(Debug, Copy, Clone)]
7335pub struct StdVideoDecodeVP9PictureInfo {
7336 pub flags: StdVideoDecodeVP9PictureInfoFlags,
7337 pub profile: StdVideoVP9Profile,
7338 pub frame_type: StdVideoVP9FrameType,
7339 pub frame_context_idx: u8,
7340 pub reset_frame_context: u8,
7341 pub refresh_frame_flags: u8,
7342 pub ref_frame_sign_bias_mask: u8,
7343 pub interpolation_filter: StdVideoVP9InterpolationFilter,
7344 pub base_q_idx: u8,
7345 pub delta_q_y_dc: i8,
7346 pub delta_q_uv_dc: i8,
7347 pub delta_q_uv_ac: i8,
7348 pub tile_cols_log2: u8,
7349 pub tile_rows_log2: u8,
7350 pub reserved1: [u16; 3usize],
7351 pub pColorConfig: *const StdVideoVP9ColorConfig,
7352 pub pLoopFilter: *const StdVideoVP9LoopFilter,
7353 pub pSegmentation: *const StdVideoVP9Segmentation,
7354}
7355#[test]
7356fn bindgen_test_layout_StdVideoDecodeVP9PictureInfo() {
7357 const UNINIT: ::core::mem::MaybeUninit<StdVideoDecodeVP9PictureInfo> =
7358 ::core::mem::MaybeUninit::uninit();
7359 let ptr = UNINIT.as_ptr();
7360 assert_eq!(
7361 ::core::mem::size_of::<StdVideoDecodeVP9PictureInfo>(),
7362 56usize,
7363 concat!("Size of: ", stringify!(StdVideoDecodeVP9PictureInfo))
7364 );
7365 assert_eq!(
7366 ::core::mem::align_of::<StdVideoDecodeVP9PictureInfo>(),
7367 8usize,
7368 concat!("Alignment of ", stringify!(StdVideoDecodeVP9PictureInfo))
7369 );
7370 assert_eq!(
7371 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
7372 0usize,
7373 concat!(
7374 "Offset of field: ",
7375 stringify!(StdVideoDecodeVP9PictureInfo),
7376 "::",
7377 stringify!(flags)
7378 )
7379 );
7380 assert_eq!(
7381 unsafe { ::core::ptr::addr_of!((*ptr).profile) as usize - ptr as usize },
7382 4usize,
7383 concat!(
7384 "Offset of field: ",
7385 stringify!(StdVideoDecodeVP9PictureInfo),
7386 "::",
7387 stringify!(profile)
7388 )
7389 );
7390 assert_eq!(
7391 unsafe { ::core::ptr::addr_of!((*ptr).frame_type) as usize - ptr as usize },
7392 8usize,
7393 concat!(
7394 "Offset of field: ",
7395 stringify!(StdVideoDecodeVP9PictureInfo),
7396 "::",
7397 stringify!(frame_type)
7398 )
7399 );
7400 assert_eq!(
7401 unsafe { ::core::ptr::addr_of!((*ptr).frame_context_idx) as usize - ptr as usize },
7402 12usize,
7403 concat!(
7404 "Offset of field: ",
7405 stringify!(StdVideoDecodeVP9PictureInfo),
7406 "::",
7407 stringify!(frame_context_idx)
7408 )
7409 );
7410 assert_eq!(
7411 unsafe { ::core::ptr::addr_of!((*ptr).reset_frame_context) as usize - ptr as usize },
7412 13usize,
7413 concat!(
7414 "Offset of field: ",
7415 stringify!(StdVideoDecodeVP9PictureInfo),
7416 "::",
7417 stringify!(reset_frame_context)
7418 )
7419 );
7420 assert_eq!(
7421 unsafe { ::core::ptr::addr_of!((*ptr).refresh_frame_flags) as usize - ptr as usize },
7422 14usize,
7423 concat!(
7424 "Offset of field: ",
7425 stringify!(StdVideoDecodeVP9PictureInfo),
7426 "::",
7427 stringify!(refresh_frame_flags)
7428 )
7429 );
7430 assert_eq!(
7431 unsafe { ::core::ptr::addr_of!((*ptr).ref_frame_sign_bias_mask) as usize - ptr as usize },
7432 15usize,
7433 concat!(
7434 "Offset of field: ",
7435 stringify!(StdVideoDecodeVP9PictureInfo),
7436 "::",
7437 stringify!(ref_frame_sign_bias_mask)
7438 )
7439 );
7440 assert_eq!(
7441 unsafe { ::core::ptr::addr_of!((*ptr).interpolation_filter) as usize - ptr as usize },
7442 16usize,
7443 concat!(
7444 "Offset of field: ",
7445 stringify!(StdVideoDecodeVP9PictureInfo),
7446 "::",
7447 stringify!(interpolation_filter)
7448 )
7449 );
7450 assert_eq!(
7451 unsafe { ::core::ptr::addr_of!((*ptr).base_q_idx) as usize - ptr as usize },
7452 20usize,
7453 concat!(
7454 "Offset of field: ",
7455 stringify!(StdVideoDecodeVP9PictureInfo),
7456 "::",
7457 stringify!(base_q_idx)
7458 )
7459 );
7460 assert_eq!(
7461 unsafe { ::core::ptr::addr_of!((*ptr).delta_q_y_dc) as usize - ptr as usize },
7462 21usize,
7463 concat!(
7464 "Offset of field: ",
7465 stringify!(StdVideoDecodeVP9PictureInfo),
7466 "::",
7467 stringify!(delta_q_y_dc)
7468 )
7469 );
7470 assert_eq!(
7471 unsafe { ::core::ptr::addr_of!((*ptr).delta_q_uv_dc) as usize - ptr as usize },
7472 22usize,
7473 concat!(
7474 "Offset of field: ",
7475 stringify!(StdVideoDecodeVP9PictureInfo),
7476 "::",
7477 stringify!(delta_q_uv_dc)
7478 )
7479 );
7480 assert_eq!(
7481 unsafe { ::core::ptr::addr_of!((*ptr).delta_q_uv_ac) as usize - ptr as usize },
7482 23usize,
7483 concat!(
7484 "Offset of field: ",
7485 stringify!(StdVideoDecodeVP9PictureInfo),
7486 "::",
7487 stringify!(delta_q_uv_ac)
7488 )
7489 );
7490 assert_eq!(
7491 unsafe { ::core::ptr::addr_of!((*ptr).tile_cols_log2) as usize - ptr as usize },
7492 24usize,
7493 concat!(
7494 "Offset of field: ",
7495 stringify!(StdVideoDecodeVP9PictureInfo),
7496 "::",
7497 stringify!(tile_cols_log2)
7498 )
7499 );
7500 assert_eq!(
7501 unsafe { ::core::ptr::addr_of!((*ptr).tile_rows_log2) as usize - ptr as usize },
7502 25usize,
7503 concat!(
7504 "Offset of field: ",
7505 stringify!(StdVideoDecodeVP9PictureInfo),
7506 "::",
7507 stringify!(tile_rows_log2)
7508 )
7509 );
7510 assert_eq!(
7511 unsafe { ::core::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize },
7512 26usize,
7513 concat!(
7514 "Offset of field: ",
7515 stringify!(StdVideoDecodeVP9PictureInfo),
7516 "::",
7517 stringify!(reserved1)
7518 )
7519 );
7520 assert_eq!(
7521 unsafe { ::core::ptr::addr_of!((*ptr).pColorConfig) as usize - ptr as usize },
7522 32usize,
7523 concat!(
7524 "Offset of field: ",
7525 stringify!(StdVideoDecodeVP9PictureInfo),
7526 "::",
7527 stringify!(pColorConfig)
7528 )
7529 );
7530 assert_eq!(
7531 unsafe { ::core::ptr::addr_of!((*ptr).pLoopFilter) as usize - ptr as usize },
7532 40usize,
7533 concat!(
7534 "Offset of field: ",
7535 stringify!(StdVideoDecodeVP9PictureInfo),
7536 "::",
7537 stringify!(pLoopFilter)
7538 )
7539 );
7540 assert_eq!(
7541 unsafe { ::core::ptr::addr_of!((*ptr).pSegmentation) as usize - ptr as usize },
7542 48usize,
7543 concat!(
7544 "Offset of field: ",
7545 stringify!(StdVideoDecodeVP9PictureInfo),
7546 "::",
7547 stringify!(pSegmentation)
7548 )
7549 );
7550}
7551pub const StdVideoAV1Profile_STD_VIDEO_AV1_PROFILE_MAIN: StdVideoAV1Profile = 0;
7552pub const StdVideoAV1Profile_STD_VIDEO_AV1_PROFILE_HIGH: StdVideoAV1Profile = 1;
7553pub const StdVideoAV1Profile_STD_VIDEO_AV1_PROFILE_PROFESSIONAL: StdVideoAV1Profile = 2;
7554pub const StdVideoAV1Profile_STD_VIDEO_AV1_PROFILE_INVALID: StdVideoAV1Profile = 2147483647;
7555pub type StdVideoAV1Profile = ::core::ffi::c_uint;
7556pub const StdVideoAV1Level_STD_VIDEO_AV1_LEVEL_2_0: StdVideoAV1Level = 0;
7557pub const StdVideoAV1Level_STD_VIDEO_AV1_LEVEL_2_1: StdVideoAV1Level = 1;
7558pub const StdVideoAV1Level_STD_VIDEO_AV1_LEVEL_2_2: StdVideoAV1Level = 2;
7559pub const StdVideoAV1Level_STD_VIDEO_AV1_LEVEL_2_3: StdVideoAV1Level = 3;
7560pub const StdVideoAV1Level_STD_VIDEO_AV1_LEVEL_3_0: StdVideoAV1Level = 4;
7561pub const StdVideoAV1Level_STD_VIDEO_AV1_LEVEL_3_1: StdVideoAV1Level = 5;
7562pub const StdVideoAV1Level_STD_VIDEO_AV1_LEVEL_3_2: StdVideoAV1Level = 6;
7563pub const StdVideoAV1Level_STD_VIDEO_AV1_LEVEL_3_3: StdVideoAV1Level = 7;
7564pub const StdVideoAV1Level_STD_VIDEO_AV1_LEVEL_4_0: StdVideoAV1Level = 8;
7565pub const StdVideoAV1Level_STD_VIDEO_AV1_LEVEL_4_1: StdVideoAV1Level = 9;
7566pub const StdVideoAV1Level_STD_VIDEO_AV1_LEVEL_4_2: StdVideoAV1Level = 10;
7567pub const StdVideoAV1Level_STD_VIDEO_AV1_LEVEL_4_3: StdVideoAV1Level = 11;
7568pub const StdVideoAV1Level_STD_VIDEO_AV1_LEVEL_5_0: StdVideoAV1Level = 12;
7569pub const StdVideoAV1Level_STD_VIDEO_AV1_LEVEL_5_1: StdVideoAV1Level = 13;
7570pub const StdVideoAV1Level_STD_VIDEO_AV1_LEVEL_5_2: StdVideoAV1Level = 14;
7571pub const StdVideoAV1Level_STD_VIDEO_AV1_LEVEL_5_3: StdVideoAV1Level = 15;
7572pub const StdVideoAV1Level_STD_VIDEO_AV1_LEVEL_6_0: StdVideoAV1Level = 16;
7573pub const StdVideoAV1Level_STD_VIDEO_AV1_LEVEL_6_1: StdVideoAV1Level = 17;
7574pub const StdVideoAV1Level_STD_VIDEO_AV1_LEVEL_6_2: StdVideoAV1Level = 18;
7575pub const StdVideoAV1Level_STD_VIDEO_AV1_LEVEL_6_3: StdVideoAV1Level = 19;
7576pub const StdVideoAV1Level_STD_VIDEO_AV1_LEVEL_7_0: StdVideoAV1Level = 20;
7577pub const StdVideoAV1Level_STD_VIDEO_AV1_LEVEL_7_1: StdVideoAV1Level = 21;
7578pub const StdVideoAV1Level_STD_VIDEO_AV1_LEVEL_7_2: StdVideoAV1Level = 22;
7579pub const StdVideoAV1Level_STD_VIDEO_AV1_LEVEL_7_3: StdVideoAV1Level = 23;
7580pub const StdVideoAV1Level_STD_VIDEO_AV1_LEVEL_INVALID: StdVideoAV1Level = 2147483647;
7581pub type StdVideoAV1Level = ::core::ffi::c_uint;
7582pub const StdVideoAV1FrameType_STD_VIDEO_AV1_FRAME_TYPE_KEY: StdVideoAV1FrameType = 0;
7583pub const StdVideoAV1FrameType_STD_VIDEO_AV1_FRAME_TYPE_INTER: StdVideoAV1FrameType = 1;
7584pub const StdVideoAV1FrameType_STD_VIDEO_AV1_FRAME_TYPE_INTRA_ONLY: StdVideoAV1FrameType = 2;
7585pub const StdVideoAV1FrameType_STD_VIDEO_AV1_FRAME_TYPE_SWITCH: StdVideoAV1FrameType = 3;
7586pub const StdVideoAV1FrameType_STD_VIDEO_AV1_FRAME_TYPE_INVALID: StdVideoAV1FrameType = 2147483647;
7587pub type StdVideoAV1FrameType = ::core::ffi::c_uint;
7588pub const StdVideoAV1InterpolationFilter_STD_VIDEO_AV1_INTERPOLATION_FILTER_EIGHTTAP:
7589 StdVideoAV1InterpolationFilter = 0;
7590pub const StdVideoAV1InterpolationFilter_STD_VIDEO_AV1_INTERPOLATION_FILTER_EIGHTTAP_SMOOTH:
7591 StdVideoAV1InterpolationFilter = 1;
7592pub const StdVideoAV1InterpolationFilter_STD_VIDEO_AV1_INTERPOLATION_FILTER_EIGHTTAP_SHARP:
7593 StdVideoAV1InterpolationFilter = 2;
7594pub const StdVideoAV1InterpolationFilter_STD_VIDEO_AV1_INTERPOLATION_FILTER_BILINEAR:
7595 StdVideoAV1InterpolationFilter = 3;
7596pub const StdVideoAV1InterpolationFilter_STD_VIDEO_AV1_INTERPOLATION_FILTER_SWITCHABLE:
7597 StdVideoAV1InterpolationFilter = 4;
7598pub const StdVideoAV1InterpolationFilter_STD_VIDEO_AV1_INTERPOLATION_FILTER_INVALID:
7599 StdVideoAV1InterpolationFilter = 2147483647;
7600pub type StdVideoAV1InterpolationFilter = ::core::ffi::c_uint;
7601pub const StdVideoAV1TxMode_STD_VIDEO_AV1_TX_MODE_ONLY_4X4: StdVideoAV1TxMode = 0;
7602pub const StdVideoAV1TxMode_STD_VIDEO_AV1_TX_MODE_LARGEST: StdVideoAV1TxMode = 1;
7603pub const StdVideoAV1TxMode_STD_VIDEO_AV1_TX_MODE_SELECT: StdVideoAV1TxMode = 2;
7604pub const StdVideoAV1TxMode_STD_VIDEO_AV1_TX_MODE_INVALID: StdVideoAV1TxMode = 2147483647;
7605pub type StdVideoAV1TxMode = ::core::ffi::c_uint;
7606pub const StdVideoAV1FrameRestorationType_STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_NONE:
7607 StdVideoAV1FrameRestorationType = 0;
7608pub const StdVideoAV1FrameRestorationType_STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_WIENER:
7609 StdVideoAV1FrameRestorationType = 1;
7610pub const StdVideoAV1FrameRestorationType_STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_SGRPROJ:
7611 StdVideoAV1FrameRestorationType = 2;
7612pub const StdVideoAV1FrameRestorationType_STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_SWITCHABLE:
7613 StdVideoAV1FrameRestorationType = 3;
7614pub const StdVideoAV1FrameRestorationType_STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_INVALID:
7615 StdVideoAV1FrameRestorationType = 2147483647;
7616pub type StdVideoAV1FrameRestorationType = ::core::ffi::c_uint;
7617pub const StdVideoAV1ColorPrimaries_STD_VIDEO_AV1_COLOR_PRIMARIES_BT_709:
7618 StdVideoAV1ColorPrimaries = 1;
7619pub const StdVideoAV1ColorPrimaries_STD_VIDEO_AV1_COLOR_PRIMARIES_UNSPECIFIED:
7620 StdVideoAV1ColorPrimaries = 2;
7621pub const StdVideoAV1ColorPrimaries_STD_VIDEO_AV1_COLOR_PRIMARIES_BT_470_M:
7622 StdVideoAV1ColorPrimaries = 4;
7623pub const StdVideoAV1ColorPrimaries_STD_VIDEO_AV1_COLOR_PRIMARIES_BT_470_B_G:
7624 StdVideoAV1ColorPrimaries = 5;
7625pub const StdVideoAV1ColorPrimaries_STD_VIDEO_AV1_COLOR_PRIMARIES_BT_601:
7626 StdVideoAV1ColorPrimaries = 6;
7627pub const StdVideoAV1ColorPrimaries_STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_240:
7628 StdVideoAV1ColorPrimaries = 7;
7629pub const StdVideoAV1ColorPrimaries_STD_VIDEO_AV1_COLOR_PRIMARIES_GENERIC_FILM:
7630 StdVideoAV1ColorPrimaries = 8;
7631pub const StdVideoAV1ColorPrimaries_STD_VIDEO_AV1_COLOR_PRIMARIES_BT_2020:
7632 StdVideoAV1ColorPrimaries = 9;
7633pub const StdVideoAV1ColorPrimaries_STD_VIDEO_AV1_COLOR_PRIMARIES_XYZ: StdVideoAV1ColorPrimaries =
7634 10;
7635pub const StdVideoAV1ColorPrimaries_STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_431:
7636 StdVideoAV1ColorPrimaries = 11;
7637pub const StdVideoAV1ColorPrimaries_STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_432:
7638 StdVideoAV1ColorPrimaries = 12;
7639pub const StdVideoAV1ColorPrimaries_STD_VIDEO_AV1_COLOR_PRIMARIES_EBU_3213:
7640 StdVideoAV1ColorPrimaries = 22;
7641pub const StdVideoAV1ColorPrimaries_STD_VIDEO_AV1_COLOR_PRIMARIES_INVALID:
7642 StdVideoAV1ColorPrimaries = 2147483647;
7643pub const StdVideoAV1ColorPrimaries_STD_VIDEO_AV1_COLOR_PRIMARIES_BT_UNSPECIFIED:
7644 StdVideoAV1ColorPrimaries = 2;
7645pub type StdVideoAV1ColorPrimaries = ::core::ffi::c_uint;
7646pub const StdVideoAV1TransferCharacteristics_STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_RESERVED_0:
7647 StdVideoAV1TransferCharacteristics = 0;
7648pub const StdVideoAV1TransferCharacteristics_STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_709:
7649 StdVideoAV1TransferCharacteristics = 1;
7650pub const StdVideoAV1TransferCharacteristics_STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_UNSPECIFIED:
7651 StdVideoAV1TransferCharacteristics = 2;
7652pub const StdVideoAV1TransferCharacteristics_STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_RESERVED_3:
7653 StdVideoAV1TransferCharacteristics = 3;
7654pub const StdVideoAV1TransferCharacteristics_STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_470_M:
7655 StdVideoAV1TransferCharacteristics = 4;
7656pub const StdVideoAV1TransferCharacteristics_STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_470_B_G:
7657 StdVideoAV1TransferCharacteristics = 5;
7658pub const StdVideoAV1TransferCharacteristics_STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_601:
7659 StdVideoAV1TransferCharacteristics = 6;
7660pub const StdVideoAV1TransferCharacteristics_STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SMPTE_240:
7661 StdVideoAV1TransferCharacteristics = 7;
7662pub const StdVideoAV1TransferCharacteristics_STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_LINEAR:
7663 StdVideoAV1TransferCharacteristics = 8;
7664pub const StdVideoAV1TransferCharacteristics_STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_LOG_100:
7665 StdVideoAV1TransferCharacteristics = 9;
7666pub const StdVideoAV1TransferCharacteristics_STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_LOG_100_SQRT10 : StdVideoAV1TransferCharacteristics = 10 ;
7667pub const StdVideoAV1TransferCharacteristics_STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_IEC_61966:
7668 StdVideoAV1TransferCharacteristics = 11;
7669pub const StdVideoAV1TransferCharacteristics_STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_1361:
7670 StdVideoAV1TransferCharacteristics = 12;
7671pub const StdVideoAV1TransferCharacteristics_STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SRGB:
7672 StdVideoAV1TransferCharacteristics = 13;
7673pub const StdVideoAV1TransferCharacteristics_STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_2020_10_BIT : StdVideoAV1TransferCharacteristics = 14 ;
7674pub const StdVideoAV1TransferCharacteristics_STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_2020_12_BIT : StdVideoAV1TransferCharacteristics = 15 ;
7675pub const StdVideoAV1TransferCharacteristics_STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SMPTE_2084:
7676 StdVideoAV1TransferCharacteristics = 16;
7677pub const StdVideoAV1TransferCharacteristics_STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SMPTE_428:
7678 StdVideoAV1TransferCharacteristics = 17;
7679pub const StdVideoAV1TransferCharacteristics_STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_HLG:
7680 StdVideoAV1TransferCharacteristics = 18;
7681pub const StdVideoAV1TransferCharacteristics_STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_INVALID:
7682 StdVideoAV1TransferCharacteristics = 2147483647;
7683pub type StdVideoAV1TransferCharacteristics = ::core::ffi::c_uint;
7684pub const StdVideoAV1MatrixCoefficients_STD_VIDEO_AV1_MATRIX_COEFFICIENTS_IDENTITY:
7685 StdVideoAV1MatrixCoefficients = 0;
7686pub const StdVideoAV1MatrixCoefficients_STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_709:
7687 StdVideoAV1MatrixCoefficients = 1;
7688pub const StdVideoAV1MatrixCoefficients_STD_VIDEO_AV1_MATRIX_COEFFICIENTS_UNSPECIFIED:
7689 StdVideoAV1MatrixCoefficients = 2;
7690pub const StdVideoAV1MatrixCoefficients_STD_VIDEO_AV1_MATRIX_COEFFICIENTS_RESERVED_3:
7691 StdVideoAV1MatrixCoefficients = 3;
7692pub const StdVideoAV1MatrixCoefficients_STD_VIDEO_AV1_MATRIX_COEFFICIENTS_FCC:
7693 StdVideoAV1MatrixCoefficients = 4;
7694pub const StdVideoAV1MatrixCoefficients_STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_470_B_G:
7695 StdVideoAV1MatrixCoefficients = 5;
7696pub const StdVideoAV1MatrixCoefficients_STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_601:
7697 StdVideoAV1MatrixCoefficients = 6;
7698pub const StdVideoAV1MatrixCoefficients_STD_VIDEO_AV1_MATRIX_COEFFICIENTS_SMPTE_240:
7699 StdVideoAV1MatrixCoefficients = 7;
7700pub const StdVideoAV1MatrixCoefficients_STD_VIDEO_AV1_MATRIX_COEFFICIENTS_SMPTE_YCGCO:
7701 StdVideoAV1MatrixCoefficients = 8;
7702pub const StdVideoAV1MatrixCoefficients_STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_2020_NCL:
7703 StdVideoAV1MatrixCoefficients = 9;
7704pub const StdVideoAV1MatrixCoefficients_STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_2020_CL:
7705 StdVideoAV1MatrixCoefficients = 10;
7706pub const StdVideoAV1MatrixCoefficients_STD_VIDEO_AV1_MATRIX_COEFFICIENTS_SMPTE_2085:
7707 StdVideoAV1MatrixCoefficients = 11;
7708pub const StdVideoAV1MatrixCoefficients_STD_VIDEO_AV1_MATRIX_COEFFICIENTS_CHROMAT_NCL:
7709 StdVideoAV1MatrixCoefficients = 12;
7710pub const StdVideoAV1MatrixCoefficients_STD_VIDEO_AV1_MATRIX_COEFFICIENTS_CHROMAT_CL:
7711 StdVideoAV1MatrixCoefficients = 13;
7712pub const StdVideoAV1MatrixCoefficients_STD_VIDEO_AV1_MATRIX_COEFFICIENTS_ICTCP:
7713 StdVideoAV1MatrixCoefficients = 14;
7714pub const StdVideoAV1MatrixCoefficients_STD_VIDEO_AV1_MATRIX_COEFFICIENTS_INVALID:
7715 StdVideoAV1MatrixCoefficients = 2147483647;
7716pub type StdVideoAV1MatrixCoefficients = ::core::ffi::c_uint;
7717pub const StdVideoAV1ChromaSamplePosition_STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_UNKNOWN:
7718 StdVideoAV1ChromaSamplePosition = 0;
7719pub const StdVideoAV1ChromaSamplePosition_STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_VERTICAL:
7720 StdVideoAV1ChromaSamplePosition = 1;
7721pub const StdVideoAV1ChromaSamplePosition_STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_COLOCATED:
7722 StdVideoAV1ChromaSamplePosition = 2;
7723pub const StdVideoAV1ChromaSamplePosition_STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_RESERVED:
7724 StdVideoAV1ChromaSamplePosition = 3;
7725pub const StdVideoAV1ChromaSamplePosition_STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_INVALID:
7726 StdVideoAV1ChromaSamplePosition = 2147483647;
7727pub type StdVideoAV1ChromaSamplePosition = ::core::ffi::c_uint;
7728#[repr(C)]
7729#[derive(Debug, Copy, Clone)]
7730pub struct StdVideoAV1ColorConfigFlags {
7731 pub _bitfield_align_1: [u32; 0],
7732 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
7733}
7734#[test]
7735fn bindgen_test_layout_StdVideoAV1ColorConfigFlags() {
7736 assert_eq!(
7737 ::core::mem::size_of::<StdVideoAV1ColorConfigFlags>(),
7738 4usize,
7739 concat!("Size of: ", stringify!(StdVideoAV1ColorConfigFlags))
7740 );
7741 assert_eq!(
7742 ::core::mem::align_of::<StdVideoAV1ColorConfigFlags>(),
7743 4usize,
7744 concat!("Alignment of ", stringify!(StdVideoAV1ColorConfigFlags))
7745 );
7746}
7747impl StdVideoAV1ColorConfigFlags {
7748 #[inline]
7749 pub fn mono_chrome(&self) -> u32 {
7750 unsafe { ::core::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
7751 }
7752 #[inline]
7753 pub fn set_mono_chrome(&mut self, val: u32) {
7754 unsafe {
7755 let val: u32 = ::core::mem::transmute(val);
7756 self._bitfield_1.set(0usize, 1u8, val as u64)
7757 }
7758 }
7759 #[inline]
7760 pub fn color_range(&self) -> u32 {
7761 unsafe { ::core::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
7762 }
7763 #[inline]
7764 pub fn set_color_range(&mut self, val: u32) {
7765 unsafe {
7766 let val: u32 = ::core::mem::transmute(val);
7767 self._bitfield_1.set(1usize, 1u8, val as u64)
7768 }
7769 }
7770 #[inline]
7771 pub fn separate_uv_delta_q(&self) -> u32 {
7772 unsafe { ::core::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
7773 }
7774 #[inline]
7775 pub fn set_separate_uv_delta_q(&mut self, val: u32) {
7776 unsafe {
7777 let val: u32 = ::core::mem::transmute(val);
7778 self._bitfield_1.set(2usize, 1u8, val as u64)
7779 }
7780 }
7781 #[inline]
7782 pub fn color_description_present_flag(&self) -> u32 {
7783 unsafe { ::core::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
7784 }
7785 #[inline]
7786 pub fn set_color_description_present_flag(&mut self, val: u32) {
7787 unsafe {
7788 let val: u32 = ::core::mem::transmute(val);
7789 self._bitfield_1.set(3usize, 1u8, val as u64)
7790 }
7791 }
7792 #[inline]
7793 pub fn reserved(&self) -> u32 {
7794 unsafe { ::core::mem::transmute(self._bitfield_1.get(4usize, 28u8) as u32) }
7795 }
7796 #[inline]
7797 pub fn set_reserved(&mut self, val: u32) {
7798 unsafe {
7799 let val: u32 = ::core::mem::transmute(val);
7800 self._bitfield_1.set(4usize, 28u8, val as u64)
7801 }
7802 }
7803 #[inline]
7804 pub fn new_bitfield_1(
7805 mono_chrome: u32,
7806 color_range: u32,
7807 separate_uv_delta_q: u32,
7808 color_description_present_flag: u32,
7809 reserved: u32,
7810 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
7811 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
7812 __bindgen_bitfield_unit.set(0usize, 1u8, {
7813 let mono_chrome: u32 = unsafe { ::core::mem::transmute(mono_chrome) };
7814 mono_chrome as u64
7815 });
7816 __bindgen_bitfield_unit.set(1usize, 1u8, {
7817 let color_range: u32 = unsafe { ::core::mem::transmute(color_range) };
7818 color_range as u64
7819 });
7820 __bindgen_bitfield_unit.set(2usize, 1u8, {
7821 let separate_uv_delta_q: u32 = unsafe { ::core::mem::transmute(separate_uv_delta_q) };
7822 separate_uv_delta_q as u64
7823 });
7824 __bindgen_bitfield_unit.set(3usize, 1u8, {
7825 let color_description_present_flag: u32 =
7826 unsafe { ::core::mem::transmute(color_description_present_flag) };
7827 color_description_present_flag as u64
7828 });
7829 __bindgen_bitfield_unit.set(4usize, 28u8, {
7830 let reserved: u32 = unsafe { ::core::mem::transmute(reserved) };
7831 reserved as u64
7832 });
7833 __bindgen_bitfield_unit
7834 }
7835}
7836#[repr(C)]
7837#[derive(Debug, Copy, Clone)]
7838pub struct StdVideoAV1ColorConfig {
7839 pub flags: StdVideoAV1ColorConfigFlags,
7840 pub BitDepth: u8,
7841 pub subsampling_x: u8,
7842 pub subsampling_y: u8,
7843 pub reserved1: u8,
7844 pub color_primaries: StdVideoAV1ColorPrimaries,
7845 pub transfer_characteristics: StdVideoAV1TransferCharacteristics,
7846 pub matrix_coefficients: StdVideoAV1MatrixCoefficients,
7847 pub chroma_sample_position: StdVideoAV1ChromaSamplePosition,
7848}
7849#[test]
7850fn bindgen_test_layout_StdVideoAV1ColorConfig() {
7851 const UNINIT: ::core::mem::MaybeUninit<StdVideoAV1ColorConfig> =
7852 ::core::mem::MaybeUninit::uninit();
7853 let ptr = UNINIT.as_ptr();
7854 assert_eq!(
7855 ::core::mem::size_of::<StdVideoAV1ColorConfig>(),
7856 24usize,
7857 concat!("Size of: ", stringify!(StdVideoAV1ColorConfig))
7858 );
7859 assert_eq!(
7860 ::core::mem::align_of::<StdVideoAV1ColorConfig>(),
7861 4usize,
7862 concat!("Alignment of ", stringify!(StdVideoAV1ColorConfig))
7863 );
7864 assert_eq!(
7865 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
7866 0usize,
7867 concat!(
7868 "Offset of field: ",
7869 stringify!(StdVideoAV1ColorConfig),
7870 "::",
7871 stringify!(flags)
7872 )
7873 );
7874 assert_eq!(
7875 unsafe { ::core::ptr::addr_of!((*ptr).BitDepth) as usize - ptr as usize },
7876 4usize,
7877 concat!(
7878 "Offset of field: ",
7879 stringify!(StdVideoAV1ColorConfig),
7880 "::",
7881 stringify!(BitDepth)
7882 )
7883 );
7884 assert_eq!(
7885 unsafe { ::core::ptr::addr_of!((*ptr).subsampling_x) as usize - ptr as usize },
7886 5usize,
7887 concat!(
7888 "Offset of field: ",
7889 stringify!(StdVideoAV1ColorConfig),
7890 "::",
7891 stringify!(subsampling_x)
7892 )
7893 );
7894 assert_eq!(
7895 unsafe { ::core::ptr::addr_of!((*ptr).subsampling_y) as usize - ptr as usize },
7896 6usize,
7897 concat!(
7898 "Offset of field: ",
7899 stringify!(StdVideoAV1ColorConfig),
7900 "::",
7901 stringify!(subsampling_y)
7902 )
7903 );
7904 assert_eq!(
7905 unsafe { ::core::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize },
7906 7usize,
7907 concat!(
7908 "Offset of field: ",
7909 stringify!(StdVideoAV1ColorConfig),
7910 "::",
7911 stringify!(reserved1)
7912 )
7913 );
7914 assert_eq!(
7915 unsafe { ::core::ptr::addr_of!((*ptr).color_primaries) as usize - ptr as usize },
7916 8usize,
7917 concat!(
7918 "Offset of field: ",
7919 stringify!(StdVideoAV1ColorConfig),
7920 "::",
7921 stringify!(color_primaries)
7922 )
7923 );
7924 assert_eq!(
7925 unsafe { ::core::ptr::addr_of!((*ptr).transfer_characteristics) as usize - ptr as usize },
7926 12usize,
7927 concat!(
7928 "Offset of field: ",
7929 stringify!(StdVideoAV1ColorConfig),
7930 "::",
7931 stringify!(transfer_characteristics)
7932 )
7933 );
7934 assert_eq!(
7935 unsafe { ::core::ptr::addr_of!((*ptr).matrix_coefficients) as usize - ptr as usize },
7936 16usize,
7937 concat!(
7938 "Offset of field: ",
7939 stringify!(StdVideoAV1ColorConfig),
7940 "::",
7941 stringify!(matrix_coefficients)
7942 )
7943 );
7944 assert_eq!(
7945 unsafe { ::core::ptr::addr_of!((*ptr).chroma_sample_position) as usize - ptr as usize },
7946 20usize,
7947 concat!(
7948 "Offset of field: ",
7949 stringify!(StdVideoAV1ColorConfig),
7950 "::",
7951 stringify!(chroma_sample_position)
7952 )
7953 );
7954}
7955#[repr(C)]
7956#[derive(Debug, Copy, Clone)]
7957pub struct StdVideoAV1TimingInfoFlags {
7958 pub _bitfield_align_1: [u32; 0],
7959 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
7960}
7961#[test]
7962fn bindgen_test_layout_StdVideoAV1TimingInfoFlags() {
7963 assert_eq!(
7964 ::core::mem::size_of::<StdVideoAV1TimingInfoFlags>(),
7965 4usize,
7966 concat!("Size of: ", stringify!(StdVideoAV1TimingInfoFlags))
7967 );
7968 assert_eq!(
7969 ::core::mem::align_of::<StdVideoAV1TimingInfoFlags>(),
7970 4usize,
7971 concat!("Alignment of ", stringify!(StdVideoAV1TimingInfoFlags))
7972 );
7973}
7974impl StdVideoAV1TimingInfoFlags {
7975 #[inline]
7976 pub fn equal_picture_interval(&self) -> u32 {
7977 unsafe { ::core::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
7978 }
7979 #[inline]
7980 pub fn set_equal_picture_interval(&mut self, val: u32) {
7981 unsafe {
7982 let val: u32 = ::core::mem::transmute(val);
7983 self._bitfield_1.set(0usize, 1u8, val as u64)
7984 }
7985 }
7986 #[inline]
7987 pub fn reserved(&self) -> u32 {
7988 unsafe { ::core::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) }
7989 }
7990 #[inline]
7991 pub fn set_reserved(&mut self, val: u32) {
7992 unsafe {
7993 let val: u32 = ::core::mem::transmute(val);
7994 self._bitfield_1.set(1usize, 31u8, val as u64)
7995 }
7996 }
7997 #[inline]
7998 pub fn new_bitfield_1(
7999 equal_picture_interval: u32,
8000 reserved: u32,
8001 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
8002 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
8003 __bindgen_bitfield_unit.set(0usize, 1u8, {
8004 let equal_picture_interval: u32 =
8005 unsafe { ::core::mem::transmute(equal_picture_interval) };
8006 equal_picture_interval as u64
8007 });
8008 __bindgen_bitfield_unit.set(1usize, 31u8, {
8009 let reserved: u32 = unsafe { ::core::mem::transmute(reserved) };
8010 reserved as u64
8011 });
8012 __bindgen_bitfield_unit
8013 }
8014}
8015#[repr(C)]
8016#[derive(Debug, Copy, Clone)]
8017pub struct StdVideoAV1TimingInfo {
8018 pub flags: StdVideoAV1TimingInfoFlags,
8019 pub num_units_in_display_tick: u32,
8020 pub time_scale: u32,
8021 pub num_ticks_per_picture_minus_1: u32,
8022}
8023#[test]
8024fn bindgen_test_layout_StdVideoAV1TimingInfo() {
8025 const UNINIT: ::core::mem::MaybeUninit<StdVideoAV1TimingInfo> =
8026 ::core::mem::MaybeUninit::uninit();
8027 let ptr = UNINIT.as_ptr();
8028 assert_eq!(
8029 ::core::mem::size_of::<StdVideoAV1TimingInfo>(),
8030 16usize,
8031 concat!("Size of: ", stringify!(StdVideoAV1TimingInfo))
8032 );
8033 assert_eq!(
8034 ::core::mem::align_of::<StdVideoAV1TimingInfo>(),
8035 4usize,
8036 concat!("Alignment of ", stringify!(StdVideoAV1TimingInfo))
8037 );
8038 assert_eq!(
8039 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
8040 0usize,
8041 concat!(
8042 "Offset of field: ",
8043 stringify!(StdVideoAV1TimingInfo),
8044 "::",
8045 stringify!(flags)
8046 )
8047 );
8048 assert_eq!(
8049 unsafe { ::core::ptr::addr_of!((*ptr).num_units_in_display_tick) as usize - ptr as usize },
8050 4usize,
8051 concat!(
8052 "Offset of field: ",
8053 stringify!(StdVideoAV1TimingInfo),
8054 "::",
8055 stringify!(num_units_in_display_tick)
8056 )
8057 );
8058 assert_eq!(
8059 unsafe { ::core::ptr::addr_of!((*ptr).time_scale) as usize - ptr as usize },
8060 8usize,
8061 concat!(
8062 "Offset of field: ",
8063 stringify!(StdVideoAV1TimingInfo),
8064 "::",
8065 stringify!(time_scale)
8066 )
8067 );
8068 assert_eq!(
8069 unsafe {
8070 ::core::ptr::addr_of!((*ptr).num_ticks_per_picture_minus_1) as usize - ptr as usize
8071 },
8072 12usize,
8073 concat!(
8074 "Offset of field: ",
8075 stringify!(StdVideoAV1TimingInfo),
8076 "::",
8077 stringify!(num_ticks_per_picture_minus_1)
8078 )
8079 );
8080}
8081#[repr(C)]
8082#[derive(Debug, Copy, Clone)]
8083pub struct StdVideoAV1LoopFilterFlags {
8084 pub _bitfield_align_1: [u32; 0],
8085 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
8086}
8087#[test]
8088fn bindgen_test_layout_StdVideoAV1LoopFilterFlags() {
8089 assert_eq!(
8090 ::core::mem::size_of::<StdVideoAV1LoopFilterFlags>(),
8091 4usize,
8092 concat!("Size of: ", stringify!(StdVideoAV1LoopFilterFlags))
8093 );
8094 assert_eq!(
8095 ::core::mem::align_of::<StdVideoAV1LoopFilterFlags>(),
8096 4usize,
8097 concat!("Alignment of ", stringify!(StdVideoAV1LoopFilterFlags))
8098 );
8099}
8100impl StdVideoAV1LoopFilterFlags {
8101 #[inline]
8102 pub fn loop_filter_delta_enabled(&self) -> u32 {
8103 unsafe { ::core::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
8104 }
8105 #[inline]
8106 pub fn set_loop_filter_delta_enabled(&mut self, val: u32) {
8107 unsafe {
8108 let val: u32 = ::core::mem::transmute(val);
8109 self._bitfield_1.set(0usize, 1u8, val as u64)
8110 }
8111 }
8112 #[inline]
8113 pub fn loop_filter_delta_update(&self) -> u32 {
8114 unsafe { ::core::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
8115 }
8116 #[inline]
8117 pub fn set_loop_filter_delta_update(&mut self, val: u32) {
8118 unsafe {
8119 let val: u32 = ::core::mem::transmute(val);
8120 self._bitfield_1.set(1usize, 1u8, val as u64)
8121 }
8122 }
8123 #[inline]
8124 pub fn reserved(&self) -> u32 {
8125 unsafe { ::core::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) }
8126 }
8127 #[inline]
8128 pub fn set_reserved(&mut self, val: u32) {
8129 unsafe {
8130 let val: u32 = ::core::mem::transmute(val);
8131 self._bitfield_1.set(2usize, 30u8, val as u64)
8132 }
8133 }
8134 #[inline]
8135 pub fn new_bitfield_1(
8136 loop_filter_delta_enabled: u32,
8137 loop_filter_delta_update: u32,
8138 reserved: u32,
8139 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
8140 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
8141 __bindgen_bitfield_unit.set(0usize, 1u8, {
8142 let loop_filter_delta_enabled: u32 =
8143 unsafe { ::core::mem::transmute(loop_filter_delta_enabled) };
8144 loop_filter_delta_enabled as u64
8145 });
8146 __bindgen_bitfield_unit.set(1usize, 1u8, {
8147 let loop_filter_delta_update: u32 =
8148 unsafe { ::core::mem::transmute(loop_filter_delta_update) };
8149 loop_filter_delta_update as u64
8150 });
8151 __bindgen_bitfield_unit.set(2usize, 30u8, {
8152 let reserved: u32 = unsafe { ::core::mem::transmute(reserved) };
8153 reserved as u64
8154 });
8155 __bindgen_bitfield_unit
8156 }
8157}
8158#[repr(C)]
8159#[derive(Debug, Copy, Clone)]
8160pub struct StdVideoAV1LoopFilter {
8161 pub flags: StdVideoAV1LoopFilterFlags,
8162 pub loop_filter_level: [u8; 4usize],
8163 pub loop_filter_sharpness: u8,
8164 pub update_ref_delta: u8,
8165 pub loop_filter_ref_deltas: [i8; 8usize],
8166 pub update_mode_delta: u8,
8167 pub loop_filter_mode_deltas: [i8; 2usize],
8168}
8169#[test]
8170fn bindgen_test_layout_StdVideoAV1LoopFilter() {
8171 const UNINIT: ::core::mem::MaybeUninit<StdVideoAV1LoopFilter> =
8172 ::core::mem::MaybeUninit::uninit();
8173 let ptr = UNINIT.as_ptr();
8174 assert_eq!(
8175 ::core::mem::size_of::<StdVideoAV1LoopFilter>(),
8176 24usize,
8177 concat!("Size of: ", stringify!(StdVideoAV1LoopFilter))
8178 );
8179 assert_eq!(
8180 ::core::mem::align_of::<StdVideoAV1LoopFilter>(),
8181 4usize,
8182 concat!("Alignment of ", stringify!(StdVideoAV1LoopFilter))
8183 );
8184 assert_eq!(
8185 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
8186 0usize,
8187 concat!(
8188 "Offset of field: ",
8189 stringify!(StdVideoAV1LoopFilter),
8190 "::",
8191 stringify!(flags)
8192 )
8193 );
8194 assert_eq!(
8195 unsafe { ::core::ptr::addr_of!((*ptr).loop_filter_level) as usize - ptr as usize },
8196 4usize,
8197 concat!(
8198 "Offset of field: ",
8199 stringify!(StdVideoAV1LoopFilter),
8200 "::",
8201 stringify!(loop_filter_level)
8202 )
8203 );
8204 assert_eq!(
8205 unsafe { ::core::ptr::addr_of!((*ptr).loop_filter_sharpness) as usize - ptr as usize },
8206 8usize,
8207 concat!(
8208 "Offset of field: ",
8209 stringify!(StdVideoAV1LoopFilter),
8210 "::",
8211 stringify!(loop_filter_sharpness)
8212 )
8213 );
8214 assert_eq!(
8215 unsafe { ::core::ptr::addr_of!((*ptr).update_ref_delta) as usize - ptr as usize },
8216 9usize,
8217 concat!(
8218 "Offset of field: ",
8219 stringify!(StdVideoAV1LoopFilter),
8220 "::",
8221 stringify!(update_ref_delta)
8222 )
8223 );
8224 assert_eq!(
8225 unsafe { ::core::ptr::addr_of!((*ptr).loop_filter_ref_deltas) as usize - ptr as usize },
8226 10usize,
8227 concat!(
8228 "Offset of field: ",
8229 stringify!(StdVideoAV1LoopFilter),
8230 "::",
8231 stringify!(loop_filter_ref_deltas)
8232 )
8233 );
8234 assert_eq!(
8235 unsafe { ::core::ptr::addr_of!((*ptr).update_mode_delta) as usize - ptr as usize },
8236 18usize,
8237 concat!(
8238 "Offset of field: ",
8239 stringify!(StdVideoAV1LoopFilter),
8240 "::",
8241 stringify!(update_mode_delta)
8242 )
8243 );
8244 assert_eq!(
8245 unsafe { ::core::ptr::addr_of!((*ptr).loop_filter_mode_deltas) as usize - ptr as usize },
8246 19usize,
8247 concat!(
8248 "Offset of field: ",
8249 stringify!(StdVideoAV1LoopFilter),
8250 "::",
8251 stringify!(loop_filter_mode_deltas)
8252 )
8253 );
8254}
8255#[repr(C)]
8256#[derive(Debug, Copy, Clone)]
8257pub struct StdVideoAV1QuantizationFlags {
8258 pub _bitfield_align_1: [u32; 0],
8259 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
8260}
8261#[test]
8262fn bindgen_test_layout_StdVideoAV1QuantizationFlags() {
8263 assert_eq!(
8264 ::core::mem::size_of::<StdVideoAV1QuantizationFlags>(),
8265 4usize,
8266 concat!("Size of: ", stringify!(StdVideoAV1QuantizationFlags))
8267 );
8268 assert_eq!(
8269 ::core::mem::align_of::<StdVideoAV1QuantizationFlags>(),
8270 4usize,
8271 concat!("Alignment of ", stringify!(StdVideoAV1QuantizationFlags))
8272 );
8273}
8274impl StdVideoAV1QuantizationFlags {
8275 #[inline]
8276 pub fn using_qmatrix(&self) -> u32 {
8277 unsafe { ::core::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
8278 }
8279 #[inline]
8280 pub fn set_using_qmatrix(&mut self, val: u32) {
8281 unsafe {
8282 let val: u32 = ::core::mem::transmute(val);
8283 self._bitfield_1.set(0usize, 1u8, val as u64)
8284 }
8285 }
8286 #[inline]
8287 pub fn diff_uv_delta(&self) -> u32 {
8288 unsafe { ::core::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
8289 }
8290 #[inline]
8291 pub fn set_diff_uv_delta(&mut self, val: u32) {
8292 unsafe {
8293 let val: u32 = ::core::mem::transmute(val);
8294 self._bitfield_1.set(1usize, 1u8, val as u64)
8295 }
8296 }
8297 #[inline]
8298 pub fn reserved(&self) -> u32 {
8299 unsafe { ::core::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) }
8300 }
8301 #[inline]
8302 pub fn set_reserved(&mut self, val: u32) {
8303 unsafe {
8304 let val: u32 = ::core::mem::transmute(val);
8305 self._bitfield_1.set(2usize, 30u8, val as u64)
8306 }
8307 }
8308 #[inline]
8309 pub fn new_bitfield_1(
8310 using_qmatrix: u32,
8311 diff_uv_delta: u32,
8312 reserved: u32,
8313 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
8314 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
8315 __bindgen_bitfield_unit.set(0usize, 1u8, {
8316 let using_qmatrix: u32 = unsafe { ::core::mem::transmute(using_qmatrix) };
8317 using_qmatrix as u64
8318 });
8319 __bindgen_bitfield_unit.set(1usize, 1u8, {
8320 let diff_uv_delta: u32 = unsafe { ::core::mem::transmute(diff_uv_delta) };
8321 diff_uv_delta as u64
8322 });
8323 __bindgen_bitfield_unit.set(2usize, 30u8, {
8324 let reserved: u32 = unsafe { ::core::mem::transmute(reserved) };
8325 reserved as u64
8326 });
8327 __bindgen_bitfield_unit
8328 }
8329}
8330#[repr(C)]
8331#[derive(Debug, Copy, Clone)]
8332pub struct StdVideoAV1Quantization {
8333 pub flags: StdVideoAV1QuantizationFlags,
8334 pub base_q_idx: u8,
8335 pub DeltaQYDc: i8,
8336 pub DeltaQUDc: i8,
8337 pub DeltaQUAc: i8,
8338 pub DeltaQVDc: i8,
8339 pub DeltaQVAc: i8,
8340 pub qm_y: u8,
8341 pub qm_u: u8,
8342 pub qm_v: u8,
8343}
8344#[test]
8345fn bindgen_test_layout_StdVideoAV1Quantization() {
8346 const UNINIT: ::core::mem::MaybeUninit<StdVideoAV1Quantization> =
8347 ::core::mem::MaybeUninit::uninit();
8348 let ptr = UNINIT.as_ptr();
8349 assert_eq!(
8350 ::core::mem::size_of::<StdVideoAV1Quantization>(),
8351 16usize,
8352 concat!("Size of: ", stringify!(StdVideoAV1Quantization))
8353 );
8354 assert_eq!(
8355 ::core::mem::align_of::<StdVideoAV1Quantization>(),
8356 4usize,
8357 concat!("Alignment of ", stringify!(StdVideoAV1Quantization))
8358 );
8359 assert_eq!(
8360 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
8361 0usize,
8362 concat!(
8363 "Offset of field: ",
8364 stringify!(StdVideoAV1Quantization),
8365 "::",
8366 stringify!(flags)
8367 )
8368 );
8369 assert_eq!(
8370 unsafe { ::core::ptr::addr_of!((*ptr).base_q_idx) as usize - ptr as usize },
8371 4usize,
8372 concat!(
8373 "Offset of field: ",
8374 stringify!(StdVideoAV1Quantization),
8375 "::",
8376 stringify!(base_q_idx)
8377 )
8378 );
8379 assert_eq!(
8380 unsafe { ::core::ptr::addr_of!((*ptr).DeltaQYDc) as usize - ptr as usize },
8381 5usize,
8382 concat!(
8383 "Offset of field: ",
8384 stringify!(StdVideoAV1Quantization),
8385 "::",
8386 stringify!(DeltaQYDc)
8387 )
8388 );
8389 assert_eq!(
8390 unsafe { ::core::ptr::addr_of!((*ptr).DeltaQUDc) as usize - ptr as usize },
8391 6usize,
8392 concat!(
8393 "Offset of field: ",
8394 stringify!(StdVideoAV1Quantization),
8395 "::",
8396 stringify!(DeltaQUDc)
8397 )
8398 );
8399 assert_eq!(
8400 unsafe { ::core::ptr::addr_of!((*ptr).DeltaQUAc) as usize - ptr as usize },
8401 7usize,
8402 concat!(
8403 "Offset of field: ",
8404 stringify!(StdVideoAV1Quantization),
8405 "::",
8406 stringify!(DeltaQUAc)
8407 )
8408 );
8409 assert_eq!(
8410 unsafe { ::core::ptr::addr_of!((*ptr).DeltaQVDc) as usize - ptr as usize },
8411 8usize,
8412 concat!(
8413 "Offset of field: ",
8414 stringify!(StdVideoAV1Quantization),
8415 "::",
8416 stringify!(DeltaQVDc)
8417 )
8418 );
8419 assert_eq!(
8420 unsafe { ::core::ptr::addr_of!((*ptr).DeltaQVAc) as usize - ptr as usize },
8421 9usize,
8422 concat!(
8423 "Offset of field: ",
8424 stringify!(StdVideoAV1Quantization),
8425 "::",
8426 stringify!(DeltaQVAc)
8427 )
8428 );
8429 assert_eq!(
8430 unsafe { ::core::ptr::addr_of!((*ptr).qm_y) as usize - ptr as usize },
8431 10usize,
8432 concat!(
8433 "Offset of field: ",
8434 stringify!(StdVideoAV1Quantization),
8435 "::",
8436 stringify!(qm_y)
8437 )
8438 );
8439 assert_eq!(
8440 unsafe { ::core::ptr::addr_of!((*ptr).qm_u) as usize - ptr as usize },
8441 11usize,
8442 concat!(
8443 "Offset of field: ",
8444 stringify!(StdVideoAV1Quantization),
8445 "::",
8446 stringify!(qm_u)
8447 )
8448 );
8449 assert_eq!(
8450 unsafe { ::core::ptr::addr_of!((*ptr).qm_v) as usize - ptr as usize },
8451 12usize,
8452 concat!(
8453 "Offset of field: ",
8454 stringify!(StdVideoAV1Quantization),
8455 "::",
8456 stringify!(qm_v)
8457 )
8458 );
8459}
8460#[repr(C)]
8461#[derive(Debug, Copy, Clone)]
8462pub struct StdVideoAV1Segmentation {
8463 pub FeatureEnabled: [u8; 8usize],
8464 pub FeatureData: [[i16; 8usize]; 8usize],
8465}
8466#[test]
8467fn bindgen_test_layout_StdVideoAV1Segmentation() {
8468 const UNINIT: ::core::mem::MaybeUninit<StdVideoAV1Segmentation> =
8469 ::core::mem::MaybeUninit::uninit();
8470 let ptr = UNINIT.as_ptr();
8471 assert_eq!(
8472 ::core::mem::size_of::<StdVideoAV1Segmentation>(),
8473 136usize,
8474 concat!("Size of: ", stringify!(StdVideoAV1Segmentation))
8475 );
8476 assert_eq!(
8477 ::core::mem::align_of::<StdVideoAV1Segmentation>(),
8478 2usize,
8479 concat!("Alignment of ", stringify!(StdVideoAV1Segmentation))
8480 );
8481 assert_eq!(
8482 unsafe { ::core::ptr::addr_of!((*ptr).FeatureEnabled) as usize - ptr as usize },
8483 0usize,
8484 concat!(
8485 "Offset of field: ",
8486 stringify!(StdVideoAV1Segmentation),
8487 "::",
8488 stringify!(FeatureEnabled)
8489 )
8490 );
8491 assert_eq!(
8492 unsafe { ::core::ptr::addr_of!((*ptr).FeatureData) as usize - ptr as usize },
8493 8usize,
8494 concat!(
8495 "Offset of field: ",
8496 stringify!(StdVideoAV1Segmentation),
8497 "::",
8498 stringify!(FeatureData)
8499 )
8500 );
8501}
8502#[repr(C)]
8503#[derive(Debug, Copy, Clone)]
8504pub struct StdVideoAV1TileInfoFlags {
8505 pub _bitfield_align_1: [u32; 0],
8506 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
8507}
8508#[test]
8509fn bindgen_test_layout_StdVideoAV1TileInfoFlags() {
8510 assert_eq!(
8511 ::core::mem::size_of::<StdVideoAV1TileInfoFlags>(),
8512 4usize,
8513 concat!("Size of: ", stringify!(StdVideoAV1TileInfoFlags))
8514 );
8515 assert_eq!(
8516 ::core::mem::align_of::<StdVideoAV1TileInfoFlags>(),
8517 4usize,
8518 concat!("Alignment of ", stringify!(StdVideoAV1TileInfoFlags))
8519 );
8520}
8521impl StdVideoAV1TileInfoFlags {
8522 #[inline]
8523 pub fn uniform_tile_spacing_flag(&self) -> u32 {
8524 unsafe { ::core::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
8525 }
8526 #[inline]
8527 pub fn set_uniform_tile_spacing_flag(&mut self, val: u32) {
8528 unsafe {
8529 let val: u32 = ::core::mem::transmute(val);
8530 self._bitfield_1.set(0usize, 1u8, val as u64)
8531 }
8532 }
8533 #[inline]
8534 pub fn reserved(&self) -> u32 {
8535 unsafe { ::core::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) }
8536 }
8537 #[inline]
8538 pub fn set_reserved(&mut self, val: u32) {
8539 unsafe {
8540 let val: u32 = ::core::mem::transmute(val);
8541 self._bitfield_1.set(1usize, 31u8, val as u64)
8542 }
8543 }
8544 #[inline]
8545 pub fn new_bitfield_1(
8546 uniform_tile_spacing_flag: u32,
8547 reserved: u32,
8548 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
8549 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
8550 __bindgen_bitfield_unit.set(0usize, 1u8, {
8551 let uniform_tile_spacing_flag: u32 =
8552 unsafe { ::core::mem::transmute(uniform_tile_spacing_flag) };
8553 uniform_tile_spacing_flag as u64
8554 });
8555 __bindgen_bitfield_unit.set(1usize, 31u8, {
8556 let reserved: u32 = unsafe { ::core::mem::transmute(reserved) };
8557 reserved as u64
8558 });
8559 __bindgen_bitfield_unit
8560 }
8561}
8562#[repr(C)]
8563#[derive(Debug, Copy, Clone)]
8564pub struct StdVideoAV1TileInfo {
8565 pub flags: StdVideoAV1TileInfoFlags,
8566 pub TileCols: u8,
8567 pub TileRows: u8,
8568 pub context_update_tile_id: u16,
8569 pub tile_size_bytes_minus_1: u8,
8570 pub reserved1: [u8; 7usize],
8571 pub pMiColStarts: *const u16,
8572 pub pMiRowStarts: *const u16,
8573 pub pWidthInSbsMinus1: *const u16,
8574 pub pHeightInSbsMinus1: *const u16,
8575}
8576#[test]
8577fn bindgen_test_layout_StdVideoAV1TileInfo() {
8578 const UNINIT: ::core::mem::MaybeUninit<StdVideoAV1TileInfo> =
8579 ::core::mem::MaybeUninit::uninit();
8580 let ptr = UNINIT.as_ptr();
8581 assert_eq!(
8582 ::core::mem::size_of::<StdVideoAV1TileInfo>(),
8583 48usize,
8584 concat!("Size of: ", stringify!(StdVideoAV1TileInfo))
8585 );
8586 assert_eq!(
8587 ::core::mem::align_of::<StdVideoAV1TileInfo>(),
8588 8usize,
8589 concat!("Alignment of ", stringify!(StdVideoAV1TileInfo))
8590 );
8591 assert_eq!(
8592 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
8593 0usize,
8594 concat!(
8595 "Offset of field: ",
8596 stringify!(StdVideoAV1TileInfo),
8597 "::",
8598 stringify!(flags)
8599 )
8600 );
8601 assert_eq!(
8602 unsafe { ::core::ptr::addr_of!((*ptr).TileCols) as usize - ptr as usize },
8603 4usize,
8604 concat!(
8605 "Offset of field: ",
8606 stringify!(StdVideoAV1TileInfo),
8607 "::",
8608 stringify!(TileCols)
8609 )
8610 );
8611 assert_eq!(
8612 unsafe { ::core::ptr::addr_of!((*ptr).TileRows) as usize - ptr as usize },
8613 5usize,
8614 concat!(
8615 "Offset of field: ",
8616 stringify!(StdVideoAV1TileInfo),
8617 "::",
8618 stringify!(TileRows)
8619 )
8620 );
8621 assert_eq!(
8622 unsafe { ::core::ptr::addr_of!((*ptr).context_update_tile_id) as usize - ptr as usize },
8623 6usize,
8624 concat!(
8625 "Offset of field: ",
8626 stringify!(StdVideoAV1TileInfo),
8627 "::",
8628 stringify!(context_update_tile_id)
8629 )
8630 );
8631 assert_eq!(
8632 unsafe { ::core::ptr::addr_of!((*ptr).tile_size_bytes_minus_1) as usize - ptr as usize },
8633 8usize,
8634 concat!(
8635 "Offset of field: ",
8636 stringify!(StdVideoAV1TileInfo),
8637 "::",
8638 stringify!(tile_size_bytes_minus_1)
8639 )
8640 );
8641 assert_eq!(
8642 unsafe { ::core::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize },
8643 9usize,
8644 concat!(
8645 "Offset of field: ",
8646 stringify!(StdVideoAV1TileInfo),
8647 "::",
8648 stringify!(reserved1)
8649 )
8650 );
8651 assert_eq!(
8652 unsafe { ::core::ptr::addr_of!((*ptr).pMiColStarts) as usize - ptr as usize },
8653 16usize,
8654 concat!(
8655 "Offset of field: ",
8656 stringify!(StdVideoAV1TileInfo),
8657 "::",
8658 stringify!(pMiColStarts)
8659 )
8660 );
8661 assert_eq!(
8662 unsafe { ::core::ptr::addr_of!((*ptr).pMiRowStarts) as usize - ptr as usize },
8663 24usize,
8664 concat!(
8665 "Offset of field: ",
8666 stringify!(StdVideoAV1TileInfo),
8667 "::",
8668 stringify!(pMiRowStarts)
8669 )
8670 );
8671 assert_eq!(
8672 unsafe { ::core::ptr::addr_of!((*ptr).pWidthInSbsMinus1) as usize - ptr as usize },
8673 32usize,
8674 concat!(
8675 "Offset of field: ",
8676 stringify!(StdVideoAV1TileInfo),
8677 "::",
8678 stringify!(pWidthInSbsMinus1)
8679 )
8680 );
8681 assert_eq!(
8682 unsafe { ::core::ptr::addr_of!((*ptr).pHeightInSbsMinus1) as usize - ptr as usize },
8683 40usize,
8684 concat!(
8685 "Offset of field: ",
8686 stringify!(StdVideoAV1TileInfo),
8687 "::",
8688 stringify!(pHeightInSbsMinus1)
8689 )
8690 );
8691}
8692#[repr(C)]
8693#[derive(Debug, Copy, Clone)]
8694pub struct StdVideoAV1CDEF {
8695 pub cdef_damping_minus_3: u8,
8696 pub cdef_bits: u8,
8697 pub cdef_y_pri_strength: [u8; 8usize],
8698 pub cdef_y_sec_strength: [u8; 8usize],
8699 pub cdef_uv_pri_strength: [u8; 8usize],
8700 pub cdef_uv_sec_strength: [u8; 8usize],
8701}
8702#[test]
8703fn bindgen_test_layout_StdVideoAV1CDEF() {
8704 const UNINIT: ::core::mem::MaybeUninit<StdVideoAV1CDEF> = ::core::mem::MaybeUninit::uninit();
8705 let ptr = UNINIT.as_ptr();
8706 assert_eq!(
8707 ::core::mem::size_of::<StdVideoAV1CDEF>(),
8708 34usize,
8709 concat!("Size of: ", stringify!(StdVideoAV1CDEF))
8710 );
8711 assert_eq!(
8712 ::core::mem::align_of::<StdVideoAV1CDEF>(),
8713 1usize,
8714 concat!("Alignment of ", stringify!(StdVideoAV1CDEF))
8715 );
8716 assert_eq!(
8717 unsafe { ::core::ptr::addr_of!((*ptr).cdef_damping_minus_3) as usize - ptr as usize },
8718 0usize,
8719 concat!(
8720 "Offset of field: ",
8721 stringify!(StdVideoAV1CDEF),
8722 "::",
8723 stringify!(cdef_damping_minus_3)
8724 )
8725 );
8726 assert_eq!(
8727 unsafe { ::core::ptr::addr_of!((*ptr).cdef_bits) as usize - ptr as usize },
8728 1usize,
8729 concat!(
8730 "Offset of field: ",
8731 stringify!(StdVideoAV1CDEF),
8732 "::",
8733 stringify!(cdef_bits)
8734 )
8735 );
8736 assert_eq!(
8737 unsafe { ::core::ptr::addr_of!((*ptr).cdef_y_pri_strength) as usize - ptr as usize },
8738 2usize,
8739 concat!(
8740 "Offset of field: ",
8741 stringify!(StdVideoAV1CDEF),
8742 "::",
8743 stringify!(cdef_y_pri_strength)
8744 )
8745 );
8746 assert_eq!(
8747 unsafe { ::core::ptr::addr_of!((*ptr).cdef_y_sec_strength) as usize - ptr as usize },
8748 10usize,
8749 concat!(
8750 "Offset of field: ",
8751 stringify!(StdVideoAV1CDEF),
8752 "::",
8753 stringify!(cdef_y_sec_strength)
8754 )
8755 );
8756 assert_eq!(
8757 unsafe { ::core::ptr::addr_of!((*ptr).cdef_uv_pri_strength) as usize - ptr as usize },
8758 18usize,
8759 concat!(
8760 "Offset of field: ",
8761 stringify!(StdVideoAV1CDEF),
8762 "::",
8763 stringify!(cdef_uv_pri_strength)
8764 )
8765 );
8766 assert_eq!(
8767 unsafe { ::core::ptr::addr_of!((*ptr).cdef_uv_sec_strength) as usize - ptr as usize },
8768 26usize,
8769 concat!(
8770 "Offset of field: ",
8771 stringify!(StdVideoAV1CDEF),
8772 "::",
8773 stringify!(cdef_uv_sec_strength)
8774 )
8775 );
8776}
8777#[repr(C)]
8778#[derive(Debug, Copy, Clone)]
8779pub struct StdVideoAV1LoopRestoration {
8780 pub FrameRestorationType: [StdVideoAV1FrameRestorationType; 3usize],
8781 pub LoopRestorationSize: [u16; 3usize],
8782}
8783#[test]
8784fn bindgen_test_layout_StdVideoAV1LoopRestoration() {
8785 const UNINIT: ::core::mem::MaybeUninit<StdVideoAV1LoopRestoration> =
8786 ::core::mem::MaybeUninit::uninit();
8787 let ptr = UNINIT.as_ptr();
8788 assert_eq!(
8789 ::core::mem::size_of::<StdVideoAV1LoopRestoration>(),
8790 20usize,
8791 concat!("Size of: ", stringify!(StdVideoAV1LoopRestoration))
8792 );
8793 assert_eq!(
8794 ::core::mem::align_of::<StdVideoAV1LoopRestoration>(),
8795 4usize,
8796 concat!("Alignment of ", stringify!(StdVideoAV1LoopRestoration))
8797 );
8798 assert_eq!(
8799 unsafe { ::core::ptr::addr_of!((*ptr).FrameRestorationType) as usize - ptr as usize },
8800 0usize,
8801 concat!(
8802 "Offset of field: ",
8803 stringify!(StdVideoAV1LoopRestoration),
8804 "::",
8805 stringify!(FrameRestorationType)
8806 )
8807 );
8808 assert_eq!(
8809 unsafe { ::core::ptr::addr_of!((*ptr).LoopRestorationSize) as usize - ptr as usize },
8810 12usize,
8811 concat!(
8812 "Offset of field: ",
8813 stringify!(StdVideoAV1LoopRestoration),
8814 "::",
8815 stringify!(LoopRestorationSize)
8816 )
8817 );
8818}
8819#[repr(C)]
8820#[derive(Debug, Copy, Clone)]
8821pub struct StdVideoAV1GlobalMotion {
8822 pub GmType: [u8; 8usize],
8823 pub gm_params: [[i32; 6usize]; 8usize],
8824}
8825#[test]
8826fn bindgen_test_layout_StdVideoAV1GlobalMotion() {
8827 const UNINIT: ::core::mem::MaybeUninit<StdVideoAV1GlobalMotion> =
8828 ::core::mem::MaybeUninit::uninit();
8829 let ptr = UNINIT.as_ptr();
8830 assert_eq!(
8831 ::core::mem::size_of::<StdVideoAV1GlobalMotion>(),
8832 200usize,
8833 concat!("Size of: ", stringify!(StdVideoAV1GlobalMotion))
8834 );
8835 assert_eq!(
8836 ::core::mem::align_of::<StdVideoAV1GlobalMotion>(),
8837 4usize,
8838 concat!("Alignment of ", stringify!(StdVideoAV1GlobalMotion))
8839 );
8840 assert_eq!(
8841 unsafe { ::core::ptr::addr_of!((*ptr).GmType) as usize - ptr as usize },
8842 0usize,
8843 concat!(
8844 "Offset of field: ",
8845 stringify!(StdVideoAV1GlobalMotion),
8846 "::",
8847 stringify!(GmType)
8848 )
8849 );
8850 assert_eq!(
8851 unsafe { ::core::ptr::addr_of!((*ptr).gm_params) as usize - ptr as usize },
8852 8usize,
8853 concat!(
8854 "Offset of field: ",
8855 stringify!(StdVideoAV1GlobalMotion),
8856 "::",
8857 stringify!(gm_params)
8858 )
8859 );
8860}
8861#[repr(C)]
8862#[derive(Debug, Copy, Clone)]
8863pub struct StdVideoAV1FilmGrainFlags {
8864 pub _bitfield_align_1: [u32; 0],
8865 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
8866}
8867#[test]
8868fn bindgen_test_layout_StdVideoAV1FilmGrainFlags() {
8869 assert_eq!(
8870 ::core::mem::size_of::<StdVideoAV1FilmGrainFlags>(),
8871 4usize,
8872 concat!("Size of: ", stringify!(StdVideoAV1FilmGrainFlags))
8873 );
8874 assert_eq!(
8875 ::core::mem::align_of::<StdVideoAV1FilmGrainFlags>(),
8876 4usize,
8877 concat!("Alignment of ", stringify!(StdVideoAV1FilmGrainFlags))
8878 );
8879}
8880impl StdVideoAV1FilmGrainFlags {
8881 #[inline]
8882 pub fn chroma_scaling_from_luma(&self) -> u32 {
8883 unsafe { ::core::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
8884 }
8885 #[inline]
8886 pub fn set_chroma_scaling_from_luma(&mut self, val: u32) {
8887 unsafe {
8888 let val: u32 = ::core::mem::transmute(val);
8889 self._bitfield_1.set(0usize, 1u8, val as u64)
8890 }
8891 }
8892 #[inline]
8893 pub fn overlap_flag(&self) -> u32 {
8894 unsafe { ::core::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
8895 }
8896 #[inline]
8897 pub fn set_overlap_flag(&mut self, val: u32) {
8898 unsafe {
8899 let val: u32 = ::core::mem::transmute(val);
8900 self._bitfield_1.set(1usize, 1u8, val as u64)
8901 }
8902 }
8903 #[inline]
8904 pub fn clip_to_restricted_range(&self) -> u32 {
8905 unsafe { ::core::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
8906 }
8907 #[inline]
8908 pub fn set_clip_to_restricted_range(&mut self, val: u32) {
8909 unsafe {
8910 let val: u32 = ::core::mem::transmute(val);
8911 self._bitfield_1.set(2usize, 1u8, val as u64)
8912 }
8913 }
8914 #[inline]
8915 pub fn update_grain(&self) -> u32 {
8916 unsafe { ::core::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
8917 }
8918 #[inline]
8919 pub fn set_update_grain(&mut self, val: u32) {
8920 unsafe {
8921 let val: u32 = ::core::mem::transmute(val);
8922 self._bitfield_1.set(3usize, 1u8, val as u64)
8923 }
8924 }
8925 #[inline]
8926 pub fn reserved(&self) -> u32 {
8927 unsafe { ::core::mem::transmute(self._bitfield_1.get(4usize, 28u8) as u32) }
8928 }
8929 #[inline]
8930 pub fn set_reserved(&mut self, val: u32) {
8931 unsafe {
8932 let val: u32 = ::core::mem::transmute(val);
8933 self._bitfield_1.set(4usize, 28u8, val as u64)
8934 }
8935 }
8936 #[inline]
8937 pub fn new_bitfield_1(
8938 chroma_scaling_from_luma: u32,
8939 overlap_flag: u32,
8940 clip_to_restricted_range: u32,
8941 update_grain: u32,
8942 reserved: u32,
8943 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
8944 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
8945 __bindgen_bitfield_unit.set(0usize, 1u8, {
8946 let chroma_scaling_from_luma: u32 =
8947 unsafe { ::core::mem::transmute(chroma_scaling_from_luma) };
8948 chroma_scaling_from_luma as u64
8949 });
8950 __bindgen_bitfield_unit.set(1usize, 1u8, {
8951 let overlap_flag: u32 = unsafe { ::core::mem::transmute(overlap_flag) };
8952 overlap_flag as u64
8953 });
8954 __bindgen_bitfield_unit.set(2usize, 1u8, {
8955 let clip_to_restricted_range: u32 =
8956 unsafe { ::core::mem::transmute(clip_to_restricted_range) };
8957 clip_to_restricted_range as u64
8958 });
8959 __bindgen_bitfield_unit.set(3usize, 1u8, {
8960 let update_grain: u32 = unsafe { ::core::mem::transmute(update_grain) };
8961 update_grain as u64
8962 });
8963 __bindgen_bitfield_unit.set(4usize, 28u8, {
8964 let reserved: u32 = unsafe { ::core::mem::transmute(reserved) };
8965 reserved as u64
8966 });
8967 __bindgen_bitfield_unit
8968 }
8969}
8970#[repr(C)]
8971#[derive(Debug, Copy, Clone)]
8972pub struct StdVideoAV1FilmGrain {
8973 pub flags: StdVideoAV1FilmGrainFlags,
8974 pub grain_scaling_minus_8: u8,
8975 pub ar_coeff_lag: u8,
8976 pub ar_coeff_shift_minus_6: u8,
8977 pub grain_scale_shift: u8,
8978 pub grain_seed: u16,
8979 pub film_grain_params_ref_idx: u8,
8980 pub num_y_points: u8,
8981 pub point_y_value: [u8; 14usize],
8982 pub point_y_scaling: [u8; 14usize],
8983 pub num_cb_points: u8,
8984 pub point_cb_value: [u8; 10usize],
8985 pub point_cb_scaling: [u8; 10usize],
8986 pub num_cr_points: u8,
8987 pub point_cr_value: [u8; 10usize],
8988 pub point_cr_scaling: [u8; 10usize],
8989 pub ar_coeffs_y_plus_128: [i8; 24usize],
8990 pub ar_coeffs_cb_plus_128: [i8; 25usize],
8991 pub ar_coeffs_cr_plus_128: [i8; 25usize],
8992 pub cb_mult: u8,
8993 pub cb_luma_mult: u8,
8994 pub cb_offset: u16,
8995 pub cr_mult: u8,
8996 pub cr_luma_mult: u8,
8997 pub cr_offset: u16,
8998}
8999#[test]
9000fn bindgen_test_layout_StdVideoAV1FilmGrain() {
9001 const UNINIT: ::core::mem::MaybeUninit<StdVideoAV1FilmGrain> =
9002 ::core::mem::MaybeUninit::uninit();
9003 let ptr = UNINIT.as_ptr();
9004 assert_eq!(
9005 ::core::mem::size_of::<StdVideoAV1FilmGrain>(),
9006 164usize,
9007 concat!("Size of: ", stringify!(StdVideoAV1FilmGrain))
9008 );
9009 assert_eq!(
9010 ::core::mem::align_of::<StdVideoAV1FilmGrain>(),
9011 4usize,
9012 concat!("Alignment of ", stringify!(StdVideoAV1FilmGrain))
9013 );
9014 assert_eq!(
9015 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
9016 0usize,
9017 concat!(
9018 "Offset of field: ",
9019 stringify!(StdVideoAV1FilmGrain),
9020 "::",
9021 stringify!(flags)
9022 )
9023 );
9024 assert_eq!(
9025 unsafe { ::core::ptr::addr_of!((*ptr).grain_scaling_minus_8) as usize - ptr as usize },
9026 4usize,
9027 concat!(
9028 "Offset of field: ",
9029 stringify!(StdVideoAV1FilmGrain),
9030 "::",
9031 stringify!(grain_scaling_minus_8)
9032 )
9033 );
9034 assert_eq!(
9035 unsafe { ::core::ptr::addr_of!((*ptr).ar_coeff_lag) as usize - ptr as usize },
9036 5usize,
9037 concat!(
9038 "Offset of field: ",
9039 stringify!(StdVideoAV1FilmGrain),
9040 "::",
9041 stringify!(ar_coeff_lag)
9042 )
9043 );
9044 assert_eq!(
9045 unsafe { ::core::ptr::addr_of!((*ptr).ar_coeff_shift_minus_6) as usize - ptr as usize },
9046 6usize,
9047 concat!(
9048 "Offset of field: ",
9049 stringify!(StdVideoAV1FilmGrain),
9050 "::",
9051 stringify!(ar_coeff_shift_minus_6)
9052 )
9053 );
9054 assert_eq!(
9055 unsafe { ::core::ptr::addr_of!((*ptr).grain_scale_shift) as usize - ptr as usize },
9056 7usize,
9057 concat!(
9058 "Offset of field: ",
9059 stringify!(StdVideoAV1FilmGrain),
9060 "::",
9061 stringify!(grain_scale_shift)
9062 )
9063 );
9064 assert_eq!(
9065 unsafe { ::core::ptr::addr_of!((*ptr).grain_seed) as usize - ptr as usize },
9066 8usize,
9067 concat!(
9068 "Offset of field: ",
9069 stringify!(StdVideoAV1FilmGrain),
9070 "::",
9071 stringify!(grain_seed)
9072 )
9073 );
9074 assert_eq!(
9075 unsafe { ::core::ptr::addr_of!((*ptr).film_grain_params_ref_idx) as usize - ptr as usize },
9076 10usize,
9077 concat!(
9078 "Offset of field: ",
9079 stringify!(StdVideoAV1FilmGrain),
9080 "::",
9081 stringify!(film_grain_params_ref_idx)
9082 )
9083 );
9084 assert_eq!(
9085 unsafe { ::core::ptr::addr_of!((*ptr).num_y_points) as usize - ptr as usize },
9086 11usize,
9087 concat!(
9088 "Offset of field: ",
9089 stringify!(StdVideoAV1FilmGrain),
9090 "::",
9091 stringify!(num_y_points)
9092 )
9093 );
9094 assert_eq!(
9095 unsafe { ::core::ptr::addr_of!((*ptr).point_y_value) as usize - ptr as usize },
9096 12usize,
9097 concat!(
9098 "Offset of field: ",
9099 stringify!(StdVideoAV1FilmGrain),
9100 "::",
9101 stringify!(point_y_value)
9102 )
9103 );
9104 assert_eq!(
9105 unsafe { ::core::ptr::addr_of!((*ptr).point_y_scaling) as usize - ptr as usize },
9106 26usize,
9107 concat!(
9108 "Offset of field: ",
9109 stringify!(StdVideoAV1FilmGrain),
9110 "::",
9111 stringify!(point_y_scaling)
9112 )
9113 );
9114 assert_eq!(
9115 unsafe { ::core::ptr::addr_of!((*ptr).num_cb_points) as usize - ptr as usize },
9116 40usize,
9117 concat!(
9118 "Offset of field: ",
9119 stringify!(StdVideoAV1FilmGrain),
9120 "::",
9121 stringify!(num_cb_points)
9122 )
9123 );
9124 assert_eq!(
9125 unsafe { ::core::ptr::addr_of!((*ptr).point_cb_value) as usize - ptr as usize },
9126 41usize,
9127 concat!(
9128 "Offset of field: ",
9129 stringify!(StdVideoAV1FilmGrain),
9130 "::",
9131 stringify!(point_cb_value)
9132 )
9133 );
9134 assert_eq!(
9135 unsafe { ::core::ptr::addr_of!((*ptr).point_cb_scaling) as usize - ptr as usize },
9136 51usize,
9137 concat!(
9138 "Offset of field: ",
9139 stringify!(StdVideoAV1FilmGrain),
9140 "::",
9141 stringify!(point_cb_scaling)
9142 )
9143 );
9144 assert_eq!(
9145 unsafe { ::core::ptr::addr_of!((*ptr).num_cr_points) as usize - ptr as usize },
9146 61usize,
9147 concat!(
9148 "Offset of field: ",
9149 stringify!(StdVideoAV1FilmGrain),
9150 "::",
9151 stringify!(num_cr_points)
9152 )
9153 );
9154 assert_eq!(
9155 unsafe { ::core::ptr::addr_of!((*ptr).point_cr_value) as usize - ptr as usize },
9156 62usize,
9157 concat!(
9158 "Offset of field: ",
9159 stringify!(StdVideoAV1FilmGrain),
9160 "::",
9161 stringify!(point_cr_value)
9162 )
9163 );
9164 assert_eq!(
9165 unsafe { ::core::ptr::addr_of!((*ptr).point_cr_scaling) as usize - ptr as usize },
9166 72usize,
9167 concat!(
9168 "Offset of field: ",
9169 stringify!(StdVideoAV1FilmGrain),
9170 "::",
9171 stringify!(point_cr_scaling)
9172 )
9173 );
9174 assert_eq!(
9175 unsafe { ::core::ptr::addr_of!((*ptr).ar_coeffs_y_plus_128) as usize - ptr as usize },
9176 82usize,
9177 concat!(
9178 "Offset of field: ",
9179 stringify!(StdVideoAV1FilmGrain),
9180 "::",
9181 stringify!(ar_coeffs_y_plus_128)
9182 )
9183 );
9184 assert_eq!(
9185 unsafe { ::core::ptr::addr_of!((*ptr).ar_coeffs_cb_plus_128) as usize - ptr as usize },
9186 106usize,
9187 concat!(
9188 "Offset of field: ",
9189 stringify!(StdVideoAV1FilmGrain),
9190 "::",
9191 stringify!(ar_coeffs_cb_plus_128)
9192 )
9193 );
9194 assert_eq!(
9195 unsafe { ::core::ptr::addr_of!((*ptr).ar_coeffs_cr_plus_128) as usize - ptr as usize },
9196 131usize,
9197 concat!(
9198 "Offset of field: ",
9199 stringify!(StdVideoAV1FilmGrain),
9200 "::",
9201 stringify!(ar_coeffs_cr_plus_128)
9202 )
9203 );
9204 assert_eq!(
9205 unsafe { ::core::ptr::addr_of!((*ptr).cb_mult) as usize - ptr as usize },
9206 156usize,
9207 concat!(
9208 "Offset of field: ",
9209 stringify!(StdVideoAV1FilmGrain),
9210 "::",
9211 stringify!(cb_mult)
9212 )
9213 );
9214 assert_eq!(
9215 unsafe { ::core::ptr::addr_of!((*ptr).cb_luma_mult) as usize - ptr as usize },
9216 157usize,
9217 concat!(
9218 "Offset of field: ",
9219 stringify!(StdVideoAV1FilmGrain),
9220 "::",
9221 stringify!(cb_luma_mult)
9222 )
9223 );
9224 assert_eq!(
9225 unsafe { ::core::ptr::addr_of!((*ptr).cb_offset) as usize - ptr as usize },
9226 158usize,
9227 concat!(
9228 "Offset of field: ",
9229 stringify!(StdVideoAV1FilmGrain),
9230 "::",
9231 stringify!(cb_offset)
9232 )
9233 );
9234 assert_eq!(
9235 unsafe { ::core::ptr::addr_of!((*ptr).cr_mult) as usize - ptr as usize },
9236 160usize,
9237 concat!(
9238 "Offset of field: ",
9239 stringify!(StdVideoAV1FilmGrain),
9240 "::",
9241 stringify!(cr_mult)
9242 )
9243 );
9244 assert_eq!(
9245 unsafe { ::core::ptr::addr_of!((*ptr).cr_luma_mult) as usize - ptr as usize },
9246 161usize,
9247 concat!(
9248 "Offset of field: ",
9249 stringify!(StdVideoAV1FilmGrain),
9250 "::",
9251 stringify!(cr_luma_mult)
9252 )
9253 );
9254 assert_eq!(
9255 unsafe { ::core::ptr::addr_of!((*ptr).cr_offset) as usize - ptr as usize },
9256 162usize,
9257 concat!(
9258 "Offset of field: ",
9259 stringify!(StdVideoAV1FilmGrain),
9260 "::",
9261 stringify!(cr_offset)
9262 )
9263 );
9264}
9265#[repr(C)]
9266#[repr(align(4))]
9267#[derive(Debug, Copy, Clone)]
9268pub struct StdVideoAV1SequenceHeaderFlags {
9269 pub _bitfield_align_1: [u16; 0],
9270 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
9271}
9272#[test]
9273fn bindgen_test_layout_StdVideoAV1SequenceHeaderFlags() {
9274 assert_eq!(
9275 ::core::mem::size_of::<StdVideoAV1SequenceHeaderFlags>(),
9276 4usize,
9277 concat!("Size of: ", stringify!(StdVideoAV1SequenceHeaderFlags))
9278 );
9279 assert_eq!(
9280 ::core::mem::align_of::<StdVideoAV1SequenceHeaderFlags>(),
9281 4usize,
9282 concat!("Alignment of ", stringify!(StdVideoAV1SequenceHeaderFlags))
9283 );
9284}
9285impl StdVideoAV1SequenceHeaderFlags {
9286 #[inline]
9287 pub fn still_picture(&self) -> u32 {
9288 unsafe { ::core::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
9289 }
9290 #[inline]
9291 pub fn set_still_picture(&mut self, val: u32) {
9292 unsafe {
9293 let val: u32 = ::core::mem::transmute(val);
9294 self._bitfield_1.set(0usize, 1u8, val as u64)
9295 }
9296 }
9297 #[inline]
9298 pub fn reduced_still_picture_header(&self) -> u32 {
9299 unsafe { ::core::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
9300 }
9301 #[inline]
9302 pub fn set_reduced_still_picture_header(&mut self, val: u32) {
9303 unsafe {
9304 let val: u32 = ::core::mem::transmute(val);
9305 self._bitfield_1.set(1usize, 1u8, val as u64)
9306 }
9307 }
9308 #[inline]
9309 pub fn use_128x128_superblock(&self) -> u32 {
9310 unsafe { ::core::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
9311 }
9312 #[inline]
9313 pub fn set_use_128x128_superblock(&mut self, val: u32) {
9314 unsafe {
9315 let val: u32 = ::core::mem::transmute(val);
9316 self._bitfield_1.set(2usize, 1u8, val as u64)
9317 }
9318 }
9319 #[inline]
9320 pub fn enable_filter_intra(&self) -> u32 {
9321 unsafe { ::core::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
9322 }
9323 #[inline]
9324 pub fn set_enable_filter_intra(&mut self, val: u32) {
9325 unsafe {
9326 let val: u32 = ::core::mem::transmute(val);
9327 self._bitfield_1.set(3usize, 1u8, val as u64)
9328 }
9329 }
9330 #[inline]
9331 pub fn enable_intra_edge_filter(&self) -> u32 {
9332 unsafe { ::core::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
9333 }
9334 #[inline]
9335 pub fn set_enable_intra_edge_filter(&mut self, val: u32) {
9336 unsafe {
9337 let val: u32 = ::core::mem::transmute(val);
9338 self._bitfield_1.set(4usize, 1u8, val as u64)
9339 }
9340 }
9341 #[inline]
9342 pub fn enable_interintra_compound(&self) -> u32 {
9343 unsafe { ::core::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
9344 }
9345 #[inline]
9346 pub fn set_enable_interintra_compound(&mut self, val: u32) {
9347 unsafe {
9348 let val: u32 = ::core::mem::transmute(val);
9349 self._bitfield_1.set(5usize, 1u8, val as u64)
9350 }
9351 }
9352 #[inline]
9353 pub fn enable_masked_compound(&self) -> u32 {
9354 unsafe { ::core::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) }
9355 }
9356 #[inline]
9357 pub fn set_enable_masked_compound(&mut self, val: u32) {
9358 unsafe {
9359 let val: u32 = ::core::mem::transmute(val);
9360 self._bitfield_1.set(6usize, 1u8, val as u64)
9361 }
9362 }
9363 #[inline]
9364 pub fn enable_warped_motion(&self) -> u32 {
9365 unsafe { ::core::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) }
9366 }
9367 #[inline]
9368 pub fn set_enable_warped_motion(&mut self, val: u32) {
9369 unsafe {
9370 let val: u32 = ::core::mem::transmute(val);
9371 self._bitfield_1.set(7usize, 1u8, val as u64)
9372 }
9373 }
9374 #[inline]
9375 pub fn enable_dual_filter(&self) -> u32 {
9376 unsafe { ::core::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) }
9377 }
9378 #[inline]
9379 pub fn set_enable_dual_filter(&mut self, val: u32) {
9380 unsafe {
9381 let val: u32 = ::core::mem::transmute(val);
9382 self._bitfield_1.set(8usize, 1u8, val as u64)
9383 }
9384 }
9385 #[inline]
9386 pub fn enable_order_hint(&self) -> u32 {
9387 unsafe { ::core::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) }
9388 }
9389 #[inline]
9390 pub fn set_enable_order_hint(&mut self, val: u32) {
9391 unsafe {
9392 let val: u32 = ::core::mem::transmute(val);
9393 self._bitfield_1.set(9usize, 1u8, val as u64)
9394 }
9395 }
9396 #[inline]
9397 pub fn enable_jnt_comp(&self) -> u32 {
9398 unsafe { ::core::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) }
9399 }
9400 #[inline]
9401 pub fn set_enable_jnt_comp(&mut self, val: u32) {
9402 unsafe {
9403 let val: u32 = ::core::mem::transmute(val);
9404 self._bitfield_1.set(10usize, 1u8, val as u64)
9405 }
9406 }
9407 #[inline]
9408 pub fn enable_ref_frame_mvs(&self) -> u32 {
9409 unsafe { ::core::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) }
9410 }
9411 #[inline]
9412 pub fn set_enable_ref_frame_mvs(&mut self, val: u32) {
9413 unsafe {
9414 let val: u32 = ::core::mem::transmute(val);
9415 self._bitfield_1.set(11usize, 1u8, val as u64)
9416 }
9417 }
9418 #[inline]
9419 pub fn frame_id_numbers_present_flag(&self) -> u32 {
9420 unsafe { ::core::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u32) }
9421 }
9422 #[inline]
9423 pub fn set_frame_id_numbers_present_flag(&mut self, val: u32) {
9424 unsafe {
9425 let val: u32 = ::core::mem::transmute(val);
9426 self._bitfield_1.set(12usize, 1u8, val as u64)
9427 }
9428 }
9429 #[inline]
9430 pub fn enable_superres(&self) -> u32 {
9431 unsafe { ::core::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) }
9432 }
9433 #[inline]
9434 pub fn set_enable_superres(&mut self, val: u32) {
9435 unsafe {
9436 let val: u32 = ::core::mem::transmute(val);
9437 self._bitfield_1.set(13usize, 1u8, val as u64)
9438 }
9439 }
9440 #[inline]
9441 pub fn enable_cdef(&self) -> u32 {
9442 unsafe { ::core::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) }
9443 }
9444 #[inline]
9445 pub fn set_enable_cdef(&mut self, val: u32) {
9446 unsafe {
9447 let val: u32 = ::core::mem::transmute(val);
9448 self._bitfield_1.set(14usize, 1u8, val as u64)
9449 }
9450 }
9451 #[inline]
9452 pub fn enable_restoration(&self) -> u32 {
9453 unsafe { ::core::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u32) }
9454 }
9455 #[inline]
9456 pub fn set_enable_restoration(&mut self, val: u32) {
9457 unsafe {
9458 let val: u32 = ::core::mem::transmute(val);
9459 self._bitfield_1.set(15usize, 1u8, val as u64)
9460 }
9461 }
9462 #[inline]
9463 pub fn film_grain_params_present(&self) -> u32 {
9464 unsafe { ::core::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u32) }
9465 }
9466 #[inline]
9467 pub fn set_film_grain_params_present(&mut self, val: u32) {
9468 unsafe {
9469 let val: u32 = ::core::mem::transmute(val);
9470 self._bitfield_1.set(16usize, 1u8, val as u64)
9471 }
9472 }
9473 #[inline]
9474 pub fn timing_info_present_flag(&self) -> u32 {
9475 unsafe { ::core::mem::transmute(self._bitfield_1.get(17usize, 1u8) as u32) }
9476 }
9477 #[inline]
9478 pub fn set_timing_info_present_flag(&mut self, val: u32) {
9479 unsafe {
9480 let val: u32 = ::core::mem::transmute(val);
9481 self._bitfield_1.set(17usize, 1u8, val as u64)
9482 }
9483 }
9484 #[inline]
9485 pub fn initial_display_delay_present_flag(&self) -> u32 {
9486 unsafe { ::core::mem::transmute(self._bitfield_1.get(18usize, 1u8) as u32) }
9487 }
9488 #[inline]
9489 pub fn set_initial_display_delay_present_flag(&mut self, val: u32) {
9490 unsafe {
9491 let val: u32 = ::core::mem::transmute(val);
9492 self._bitfield_1.set(18usize, 1u8, val as u64)
9493 }
9494 }
9495 #[inline]
9496 pub fn reserved(&self) -> u32 {
9497 unsafe { ::core::mem::transmute(self._bitfield_1.get(19usize, 13u8) as u32) }
9498 }
9499 #[inline]
9500 pub fn set_reserved(&mut self, val: u32) {
9501 unsafe {
9502 let val: u32 = ::core::mem::transmute(val);
9503 self._bitfield_1.set(19usize, 13u8, val as u64)
9504 }
9505 }
9506 #[inline]
9507 pub fn new_bitfield_1(
9508 still_picture: u32,
9509 reduced_still_picture_header: u32,
9510 use_128x128_superblock: u32,
9511 enable_filter_intra: u32,
9512 enable_intra_edge_filter: u32,
9513 enable_interintra_compound: u32,
9514 enable_masked_compound: u32,
9515 enable_warped_motion: u32,
9516 enable_dual_filter: u32,
9517 enable_order_hint: u32,
9518 enable_jnt_comp: u32,
9519 enable_ref_frame_mvs: u32,
9520 frame_id_numbers_present_flag: u32,
9521 enable_superres: u32,
9522 enable_cdef: u32,
9523 enable_restoration: u32,
9524 film_grain_params_present: u32,
9525 timing_info_present_flag: u32,
9526 initial_display_delay_present_flag: u32,
9527 reserved: u32,
9528 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
9529 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
9530 __bindgen_bitfield_unit.set(0usize, 1u8, {
9531 let still_picture: u32 = unsafe { ::core::mem::transmute(still_picture) };
9532 still_picture as u64
9533 });
9534 __bindgen_bitfield_unit.set(1usize, 1u8, {
9535 let reduced_still_picture_header: u32 =
9536 unsafe { ::core::mem::transmute(reduced_still_picture_header) };
9537 reduced_still_picture_header as u64
9538 });
9539 __bindgen_bitfield_unit.set(2usize, 1u8, {
9540 let use_128x128_superblock: u32 =
9541 unsafe { ::core::mem::transmute(use_128x128_superblock) };
9542 use_128x128_superblock as u64
9543 });
9544 __bindgen_bitfield_unit.set(3usize, 1u8, {
9545 let enable_filter_intra: u32 = unsafe { ::core::mem::transmute(enable_filter_intra) };
9546 enable_filter_intra as u64
9547 });
9548 __bindgen_bitfield_unit.set(4usize, 1u8, {
9549 let enable_intra_edge_filter: u32 =
9550 unsafe { ::core::mem::transmute(enable_intra_edge_filter) };
9551 enable_intra_edge_filter as u64
9552 });
9553 __bindgen_bitfield_unit.set(5usize, 1u8, {
9554 let enable_interintra_compound: u32 =
9555 unsafe { ::core::mem::transmute(enable_interintra_compound) };
9556 enable_interintra_compound as u64
9557 });
9558 __bindgen_bitfield_unit.set(6usize, 1u8, {
9559 let enable_masked_compound: u32 =
9560 unsafe { ::core::mem::transmute(enable_masked_compound) };
9561 enable_masked_compound as u64
9562 });
9563 __bindgen_bitfield_unit.set(7usize, 1u8, {
9564 let enable_warped_motion: u32 = unsafe { ::core::mem::transmute(enable_warped_motion) };
9565 enable_warped_motion as u64
9566 });
9567 __bindgen_bitfield_unit.set(8usize, 1u8, {
9568 let enable_dual_filter: u32 = unsafe { ::core::mem::transmute(enable_dual_filter) };
9569 enable_dual_filter as u64
9570 });
9571 __bindgen_bitfield_unit.set(9usize, 1u8, {
9572 let enable_order_hint: u32 = unsafe { ::core::mem::transmute(enable_order_hint) };
9573 enable_order_hint as u64
9574 });
9575 __bindgen_bitfield_unit.set(10usize, 1u8, {
9576 let enable_jnt_comp: u32 = unsafe { ::core::mem::transmute(enable_jnt_comp) };
9577 enable_jnt_comp as u64
9578 });
9579 __bindgen_bitfield_unit.set(11usize, 1u8, {
9580 let enable_ref_frame_mvs: u32 = unsafe { ::core::mem::transmute(enable_ref_frame_mvs) };
9581 enable_ref_frame_mvs as u64
9582 });
9583 __bindgen_bitfield_unit.set(12usize, 1u8, {
9584 let frame_id_numbers_present_flag: u32 =
9585 unsafe { ::core::mem::transmute(frame_id_numbers_present_flag) };
9586 frame_id_numbers_present_flag as u64
9587 });
9588 __bindgen_bitfield_unit.set(13usize, 1u8, {
9589 let enable_superres: u32 = unsafe { ::core::mem::transmute(enable_superres) };
9590 enable_superres as u64
9591 });
9592 __bindgen_bitfield_unit.set(14usize, 1u8, {
9593 let enable_cdef: u32 = unsafe { ::core::mem::transmute(enable_cdef) };
9594 enable_cdef as u64
9595 });
9596 __bindgen_bitfield_unit.set(15usize, 1u8, {
9597 let enable_restoration: u32 = unsafe { ::core::mem::transmute(enable_restoration) };
9598 enable_restoration as u64
9599 });
9600 __bindgen_bitfield_unit.set(16usize, 1u8, {
9601 let film_grain_params_present: u32 =
9602 unsafe { ::core::mem::transmute(film_grain_params_present) };
9603 film_grain_params_present as u64
9604 });
9605 __bindgen_bitfield_unit.set(17usize, 1u8, {
9606 let timing_info_present_flag: u32 =
9607 unsafe { ::core::mem::transmute(timing_info_present_flag) };
9608 timing_info_present_flag as u64
9609 });
9610 __bindgen_bitfield_unit.set(18usize, 1u8, {
9611 let initial_display_delay_present_flag: u32 =
9612 unsafe { ::core::mem::transmute(initial_display_delay_present_flag) };
9613 initial_display_delay_present_flag as u64
9614 });
9615 __bindgen_bitfield_unit.set(19usize, 13u8, {
9616 let reserved: u32 = unsafe { ::core::mem::transmute(reserved) };
9617 reserved as u64
9618 });
9619 __bindgen_bitfield_unit
9620 }
9621}
9622#[repr(C)]
9623#[derive(Debug, Copy, Clone)]
9624pub struct StdVideoAV1SequenceHeader {
9625 pub flags: StdVideoAV1SequenceHeaderFlags,
9626 pub seq_profile: StdVideoAV1Profile,
9627 pub frame_width_bits_minus_1: u8,
9628 pub frame_height_bits_minus_1: u8,
9629 pub max_frame_width_minus_1: u16,
9630 pub max_frame_height_minus_1: u16,
9631 pub delta_frame_id_length_minus_2: u8,
9632 pub additional_frame_id_length_minus_1: u8,
9633 pub order_hint_bits_minus_1: u8,
9634 pub seq_force_integer_mv: u8,
9635 pub seq_force_screen_content_tools: u8,
9636 pub reserved1: [u8; 5usize],
9637 pub pColorConfig: *const StdVideoAV1ColorConfig,
9638 pub pTimingInfo: *const StdVideoAV1TimingInfo,
9639}
9640#[test]
9641fn bindgen_test_layout_StdVideoAV1SequenceHeader() {
9642 const UNINIT: ::core::mem::MaybeUninit<StdVideoAV1SequenceHeader> =
9643 ::core::mem::MaybeUninit::uninit();
9644 let ptr = UNINIT.as_ptr();
9645 assert_eq!(
9646 ::core::mem::size_of::<StdVideoAV1SequenceHeader>(),
9647 40usize,
9648 concat!("Size of: ", stringify!(StdVideoAV1SequenceHeader))
9649 );
9650 assert_eq!(
9651 ::core::mem::align_of::<StdVideoAV1SequenceHeader>(),
9652 8usize,
9653 concat!("Alignment of ", stringify!(StdVideoAV1SequenceHeader))
9654 );
9655 assert_eq!(
9656 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
9657 0usize,
9658 concat!(
9659 "Offset of field: ",
9660 stringify!(StdVideoAV1SequenceHeader),
9661 "::",
9662 stringify!(flags)
9663 )
9664 );
9665 assert_eq!(
9666 unsafe { ::core::ptr::addr_of!((*ptr).seq_profile) as usize - ptr as usize },
9667 4usize,
9668 concat!(
9669 "Offset of field: ",
9670 stringify!(StdVideoAV1SequenceHeader),
9671 "::",
9672 stringify!(seq_profile)
9673 )
9674 );
9675 assert_eq!(
9676 unsafe { ::core::ptr::addr_of!((*ptr).frame_width_bits_minus_1) as usize - ptr as usize },
9677 8usize,
9678 concat!(
9679 "Offset of field: ",
9680 stringify!(StdVideoAV1SequenceHeader),
9681 "::",
9682 stringify!(frame_width_bits_minus_1)
9683 )
9684 );
9685 assert_eq!(
9686 unsafe { ::core::ptr::addr_of!((*ptr).frame_height_bits_minus_1) as usize - ptr as usize },
9687 9usize,
9688 concat!(
9689 "Offset of field: ",
9690 stringify!(StdVideoAV1SequenceHeader),
9691 "::",
9692 stringify!(frame_height_bits_minus_1)
9693 )
9694 );
9695 assert_eq!(
9696 unsafe { ::core::ptr::addr_of!((*ptr).max_frame_width_minus_1) as usize - ptr as usize },
9697 10usize,
9698 concat!(
9699 "Offset of field: ",
9700 stringify!(StdVideoAV1SequenceHeader),
9701 "::",
9702 stringify!(max_frame_width_minus_1)
9703 )
9704 );
9705 assert_eq!(
9706 unsafe { ::core::ptr::addr_of!((*ptr).max_frame_height_minus_1) as usize - ptr as usize },
9707 12usize,
9708 concat!(
9709 "Offset of field: ",
9710 stringify!(StdVideoAV1SequenceHeader),
9711 "::",
9712 stringify!(max_frame_height_minus_1)
9713 )
9714 );
9715 assert_eq!(
9716 unsafe {
9717 ::core::ptr::addr_of!((*ptr).delta_frame_id_length_minus_2) as usize - ptr as usize
9718 },
9719 14usize,
9720 concat!(
9721 "Offset of field: ",
9722 stringify!(StdVideoAV1SequenceHeader),
9723 "::",
9724 stringify!(delta_frame_id_length_minus_2)
9725 )
9726 );
9727 assert_eq!(
9728 unsafe {
9729 ::core::ptr::addr_of!((*ptr).additional_frame_id_length_minus_1) as usize - ptr as usize
9730 },
9731 15usize,
9732 concat!(
9733 "Offset of field: ",
9734 stringify!(StdVideoAV1SequenceHeader),
9735 "::",
9736 stringify!(additional_frame_id_length_minus_1)
9737 )
9738 );
9739 assert_eq!(
9740 unsafe { ::core::ptr::addr_of!((*ptr).order_hint_bits_minus_1) as usize - ptr as usize },
9741 16usize,
9742 concat!(
9743 "Offset of field: ",
9744 stringify!(StdVideoAV1SequenceHeader),
9745 "::",
9746 stringify!(order_hint_bits_minus_1)
9747 )
9748 );
9749 assert_eq!(
9750 unsafe { ::core::ptr::addr_of!((*ptr).seq_force_integer_mv) as usize - ptr as usize },
9751 17usize,
9752 concat!(
9753 "Offset of field: ",
9754 stringify!(StdVideoAV1SequenceHeader),
9755 "::",
9756 stringify!(seq_force_integer_mv)
9757 )
9758 );
9759 assert_eq!(
9760 unsafe {
9761 ::core::ptr::addr_of!((*ptr).seq_force_screen_content_tools) as usize - ptr as usize
9762 },
9763 18usize,
9764 concat!(
9765 "Offset of field: ",
9766 stringify!(StdVideoAV1SequenceHeader),
9767 "::",
9768 stringify!(seq_force_screen_content_tools)
9769 )
9770 );
9771 assert_eq!(
9772 unsafe { ::core::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize },
9773 19usize,
9774 concat!(
9775 "Offset of field: ",
9776 stringify!(StdVideoAV1SequenceHeader),
9777 "::",
9778 stringify!(reserved1)
9779 )
9780 );
9781 assert_eq!(
9782 unsafe { ::core::ptr::addr_of!((*ptr).pColorConfig) as usize - ptr as usize },
9783 24usize,
9784 concat!(
9785 "Offset of field: ",
9786 stringify!(StdVideoAV1SequenceHeader),
9787 "::",
9788 stringify!(pColorConfig)
9789 )
9790 );
9791 assert_eq!(
9792 unsafe { ::core::ptr::addr_of!((*ptr).pTimingInfo) as usize - ptr as usize },
9793 32usize,
9794 concat!(
9795 "Offset of field: ",
9796 stringify!(StdVideoAV1SequenceHeader),
9797 "::",
9798 stringify!(pTimingInfo)
9799 )
9800 );
9801}
9802#[repr(C)]
9803#[repr(align(4))]
9804#[derive(Debug, Copy, Clone)]
9805pub struct StdVideoDecodeAV1PictureInfoFlags {
9806 pub _bitfield_align_1: [u8; 0],
9807 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
9808}
9809#[test]
9810fn bindgen_test_layout_StdVideoDecodeAV1PictureInfoFlags() {
9811 assert_eq!(
9812 ::core::mem::size_of::<StdVideoDecodeAV1PictureInfoFlags>(),
9813 4usize,
9814 concat!("Size of: ", stringify!(StdVideoDecodeAV1PictureInfoFlags))
9815 );
9816 assert_eq!(
9817 ::core::mem::align_of::<StdVideoDecodeAV1PictureInfoFlags>(),
9818 4usize,
9819 concat!(
9820 "Alignment of ",
9821 stringify!(StdVideoDecodeAV1PictureInfoFlags)
9822 )
9823 );
9824}
9825impl StdVideoDecodeAV1PictureInfoFlags {
9826 #[inline]
9827 pub fn error_resilient_mode(&self) -> u32 {
9828 unsafe { ::core::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
9829 }
9830 #[inline]
9831 pub fn set_error_resilient_mode(&mut self, val: u32) {
9832 unsafe {
9833 let val: u32 = ::core::mem::transmute(val);
9834 self._bitfield_1.set(0usize, 1u8, val as u64)
9835 }
9836 }
9837 #[inline]
9838 pub fn disable_cdf_update(&self) -> u32 {
9839 unsafe { ::core::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
9840 }
9841 #[inline]
9842 pub fn set_disable_cdf_update(&mut self, val: u32) {
9843 unsafe {
9844 let val: u32 = ::core::mem::transmute(val);
9845 self._bitfield_1.set(1usize, 1u8, val as u64)
9846 }
9847 }
9848 #[inline]
9849 pub fn use_superres(&self) -> u32 {
9850 unsafe { ::core::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
9851 }
9852 #[inline]
9853 pub fn set_use_superres(&mut self, val: u32) {
9854 unsafe {
9855 let val: u32 = ::core::mem::transmute(val);
9856 self._bitfield_1.set(2usize, 1u8, val as u64)
9857 }
9858 }
9859 #[inline]
9860 pub fn render_and_frame_size_different(&self) -> u32 {
9861 unsafe { ::core::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
9862 }
9863 #[inline]
9864 pub fn set_render_and_frame_size_different(&mut self, val: u32) {
9865 unsafe {
9866 let val: u32 = ::core::mem::transmute(val);
9867 self._bitfield_1.set(3usize, 1u8, val as u64)
9868 }
9869 }
9870 #[inline]
9871 pub fn allow_screen_content_tools(&self) -> u32 {
9872 unsafe { ::core::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
9873 }
9874 #[inline]
9875 pub fn set_allow_screen_content_tools(&mut self, val: u32) {
9876 unsafe {
9877 let val: u32 = ::core::mem::transmute(val);
9878 self._bitfield_1.set(4usize, 1u8, val as u64)
9879 }
9880 }
9881 #[inline]
9882 pub fn is_filter_switchable(&self) -> u32 {
9883 unsafe { ::core::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
9884 }
9885 #[inline]
9886 pub fn set_is_filter_switchable(&mut self, val: u32) {
9887 unsafe {
9888 let val: u32 = ::core::mem::transmute(val);
9889 self._bitfield_1.set(5usize, 1u8, val as u64)
9890 }
9891 }
9892 #[inline]
9893 pub fn force_integer_mv(&self) -> u32 {
9894 unsafe { ::core::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) }
9895 }
9896 #[inline]
9897 pub fn set_force_integer_mv(&mut self, val: u32) {
9898 unsafe {
9899 let val: u32 = ::core::mem::transmute(val);
9900 self._bitfield_1.set(6usize, 1u8, val as u64)
9901 }
9902 }
9903 #[inline]
9904 pub fn frame_size_override_flag(&self) -> u32 {
9905 unsafe { ::core::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) }
9906 }
9907 #[inline]
9908 pub fn set_frame_size_override_flag(&mut self, val: u32) {
9909 unsafe {
9910 let val: u32 = ::core::mem::transmute(val);
9911 self._bitfield_1.set(7usize, 1u8, val as u64)
9912 }
9913 }
9914 #[inline]
9915 pub fn buffer_removal_time_present_flag(&self) -> u32 {
9916 unsafe { ::core::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) }
9917 }
9918 #[inline]
9919 pub fn set_buffer_removal_time_present_flag(&mut self, val: u32) {
9920 unsafe {
9921 let val: u32 = ::core::mem::transmute(val);
9922 self._bitfield_1.set(8usize, 1u8, val as u64)
9923 }
9924 }
9925 #[inline]
9926 pub fn allow_intrabc(&self) -> u32 {
9927 unsafe { ::core::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) }
9928 }
9929 #[inline]
9930 pub fn set_allow_intrabc(&mut self, val: u32) {
9931 unsafe {
9932 let val: u32 = ::core::mem::transmute(val);
9933 self._bitfield_1.set(9usize, 1u8, val as u64)
9934 }
9935 }
9936 #[inline]
9937 pub fn frame_refs_short_signaling(&self) -> u32 {
9938 unsafe { ::core::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) }
9939 }
9940 #[inline]
9941 pub fn set_frame_refs_short_signaling(&mut self, val: u32) {
9942 unsafe {
9943 let val: u32 = ::core::mem::transmute(val);
9944 self._bitfield_1.set(10usize, 1u8, val as u64)
9945 }
9946 }
9947 #[inline]
9948 pub fn allow_high_precision_mv(&self) -> u32 {
9949 unsafe { ::core::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) }
9950 }
9951 #[inline]
9952 pub fn set_allow_high_precision_mv(&mut self, val: u32) {
9953 unsafe {
9954 let val: u32 = ::core::mem::transmute(val);
9955 self._bitfield_1.set(11usize, 1u8, val as u64)
9956 }
9957 }
9958 #[inline]
9959 pub fn is_motion_mode_switchable(&self) -> u32 {
9960 unsafe { ::core::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u32) }
9961 }
9962 #[inline]
9963 pub fn set_is_motion_mode_switchable(&mut self, val: u32) {
9964 unsafe {
9965 let val: u32 = ::core::mem::transmute(val);
9966 self._bitfield_1.set(12usize, 1u8, val as u64)
9967 }
9968 }
9969 #[inline]
9970 pub fn use_ref_frame_mvs(&self) -> u32 {
9971 unsafe { ::core::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) }
9972 }
9973 #[inline]
9974 pub fn set_use_ref_frame_mvs(&mut self, val: u32) {
9975 unsafe {
9976 let val: u32 = ::core::mem::transmute(val);
9977 self._bitfield_1.set(13usize, 1u8, val as u64)
9978 }
9979 }
9980 #[inline]
9981 pub fn disable_frame_end_update_cdf(&self) -> u32 {
9982 unsafe { ::core::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) }
9983 }
9984 #[inline]
9985 pub fn set_disable_frame_end_update_cdf(&mut self, val: u32) {
9986 unsafe {
9987 let val: u32 = ::core::mem::transmute(val);
9988 self._bitfield_1.set(14usize, 1u8, val as u64)
9989 }
9990 }
9991 #[inline]
9992 pub fn allow_warped_motion(&self) -> u32 {
9993 unsafe { ::core::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u32) }
9994 }
9995 #[inline]
9996 pub fn set_allow_warped_motion(&mut self, val: u32) {
9997 unsafe {
9998 let val: u32 = ::core::mem::transmute(val);
9999 self._bitfield_1.set(15usize, 1u8, val as u64)
10000 }
10001 }
10002 #[inline]
10003 pub fn reduced_tx_set(&self) -> u32 {
10004 unsafe { ::core::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u32) }
10005 }
10006 #[inline]
10007 pub fn set_reduced_tx_set(&mut self, val: u32) {
10008 unsafe {
10009 let val: u32 = ::core::mem::transmute(val);
10010 self._bitfield_1.set(16usize, 1u8, val as u64)
10011 }
10012 }
10013 #[inline]
10014 pub fn reference_select(&self) -> u32 {
10015 unsafe { ::core::mem::transmute(self._bitfield_1.get(17usize, 1u8) as u32) }
10016 }
10017 #[inline]
10018 pub fn set_reference_select(&mut self, val: u32) {
10019 unsafe {
10020 let val: u32 = ::core::mem::transmute(val);
10021 self._bitfield_1.set(17usize, 1u8, val as u64)
10022 }
10023 }
10024 #[inline]
10025 pub fn skip_mode_present(&self) -> u32 {
10026 unsafe { ::core::mem::transmute(self._bitfield_1.get(18usize, 1u8) as u32) }
10027 }
10028 #[inline]
10029 pub fn set_skip_mode_present(&mut self, val: u32) {
10030 unsafe {
10031 let val: u32 = ::core::mem::transmute(val);
10032 self._bitfield_1.set(18usize, 1u8, val as u64)
10033 }
10034 }
10035 #[inline]
10036 pub fn delta_q_present(&self) -> u32 {
10037 unsafe { ::core::mem::transmute(self._bitfield_1.get(19usize, 1u8) as u32) }
10038 }
10039 #[inline]
10040 pub fn set_delta_q_present(&mut self, val: u32) {
10041 unsafe {
10042 let val: u32 = ::core::mem::transmute(val);
10043 self._bitfield_1.set(19usize, 1u8, val as u64)
10044 }
10045 }
10046 #[inline]
10047 pub fn delta_lf_present(&self) -> u32 {
10048 unsafe { ::core::mem::transmute(self._bitfield_1.get(20usize, 1u8) as u32) }
10049 }
10050 #[inline]
10051 pub fn set_delta_lf_present(&mut self, val: u32) {
10052 unsafe {
10053 let val: u32 = ::core::mem::transmute(val);
10054 self._bitfield_1.set(20usize, 1u8, val as u64)
10055 }
10056 }
10057 #[inline]
10058 pub fn delta_lf_multi(&self) -> u32 {
10059 unsafe { ::core::mem::transmute(self._bitfield_1.get(21usize, 1u8) as u32) }
10060 }
10061 #[inline]
10062 pub fn set_delta_lf_multi(&mut self, val: u32) {
10063 unsafe {
10064 let val: u32 = ::core::mem::transmute(val);
10065 self._bitfield_1.set(21usize, 1u8, val as u64)
10066 }
10067 }
10068 #[inline]
10069 pub fn segmentation_enabled(&self) -> u32 {
10070 unsafe { ::core::mem::transmute(self._bitfield_1.get(22usize, 1u8) as u32) }
10071 }
10072 #[inline]
10073 pub fn set_segmentation_enabled(&mut self, val: u32) {
10074 unsafe {
10075 let val: u32 = ::core::mem::transmute(val);
10076 self._bitfield_1.set(22usize, 1u8, val as u64)
10077 }
10078 }
10079 #[inline]
10080 pub fn segmentation_update_map(&self) -> u32 {
10081 unsafe { ::core::mem::transmute(self._bitfield_1.get(23usize, 1u8) as u32) }
10082 }
10083 #[inline]
10084 pub fn set_segmentation_update_map(&mut self, val: u32) {
10085 unsafe {
10086 let val: u32 = ::core::mem::transmute(val);
10087 self._bitfield_1.set(23usize, 1u8, val as u64)
10088 }
10089 }
10090 #[inline]
10091 pub fn segmentation_temporal_update(&self) -> u32 {
10092 unsafe { ::core::mem::transmute(self._bitfield_1.get(24usize, 1u8) as u32) }
10093 }
10094 #[inline]
10095 pub fn set_segmentation_temporal_update(&mut self, val: u32) {
10096 unsafe {
10097 let val: u32 = ::core::mem::transmute(val);
10098 self._bitfield_1.set(24usize, 1u8, val as u64)
10099 }
10100 }
10101 #[inline]
10102 pub fn segmentation_update_data(&self) -> u32 {
10103 unsafe { ::core::mem::transmute(self._bitfield_1.get(25usize, 1u8) as u32) }
10104 }
10105 #[inline]
10106 pub fn set_segmentation_update_data(&mut self, val: u32) {
10107 unsafe {
10108 let val: u32 = ::core::mem::transmute(val);
10109 self._bitfield_1.set(25usize, 1u8, val as u64)
10110 }
10111 }
10112 #[inline]
10113 pub fn UsesLr(&self) -> u32 {
10114 unsafe { ::core::mem::transmute(self._bitfield_1.get(26usize, 1u8) as u32) }
10115 }
10116 #[inline]
10117 pub fn set_UsesLr(&mut self, val: u32) {
10118 unsafe {
10119 let val: u32 = ::core::mem::transmute(val);
10120 self._bitfield_1.set(26usize, 1u8, val as u64)
10121 }
10122 }
10123 #[inline]
10124 pub fn usesChromaLr(&self) -> u32 {
10125 unsafe { ::core::mem::transmute(self._bitfield_1.get(27usize, 1u8) as u32) }
10126 }
10127 #[inline]
10128 pub fn set_usesChromaLr(&mut self, val: u32) {
10129 unsafe {
10130 let val: u32 = ::core::mem::transmute(val);
10131 self._bitfield_1.set(27usize, 1u8, val as u64)
10132 }
10133 }
10134 #[inline]
10135 pub fn apply_grain(&self) -> u32 {
10136 unsafe { ::core::mem::transmute(self._bitfield_1.get(28usize, 1u8) as u32) }
10137 }
10138 #[inline]
10139 pub fn set_apply_grain(&mut self, val: u32) {
10140 unsafe {
10141 let val: u32 = ::core::mem::transmute(val);
10142 self._bitfield_1.set(28usize, 1u8, val as u64)
10143 }
10144 }
10145 #[inline]
10146 pub fn reserved(&self) -> u32 {
10147 unsafe { ::core::mem::transmute(self._bitfield_1.get(29usize, 3u8) as u32) }
10148 }
10149 #[inline]
10150 pub fn set_reserved(&mut self, val: u32) {
10151 unsafe {
10152 let val: u32 = ::core::mem::transmute(val);
10153 self._bitfield_1.set(29usize, 3u8, val as u64)
10154 }
10155 }
10156 #[inline]
10157 pub fn new_bitfield_1(
10158 error_resilient_mode: u32,
10159 disable_cdf_update: u32,
10160 use_superres: u32,
10161 render_and_frame_size_different: u32,
10162 allow_screen_content_tools: u32,
10163 is_filter_switchable: u32,
10164 force_integer_mv: u32,
10165 frame_size_override_flag: u32,
10166 buffer_removal_time_present_flag: u32,
10167 allow_intrabc: u32,
10168 frame_refs_short_signaling: u32,
10169 allow_high_precision_mv: u32,
10170 is_motion_mode_switchable: u32,
10171 use_ref_frame_mvs: u32,
10172 disable_frame_end_update_cdf: u32,
10173 allow_warped_motion: u32,
10174 reduced_tx_set: u32,
10175 reference_select: u32,
10176 skip_mode_present: u32,
10177 delta_q_present: u32,
10178 delta_lf_present: u32,
10179 delta_lf_multi: u32,
10180 segmentation_enabled: u32,
10181 segmentation_update_map: u32,
10182 segmentation_temporal_update: u32,
10183 segmentation_update_data: u32,
10184 UsesLr: u32,
10185 usesChromaLr: u32,
10186 apply_grain: u32,
10187 reserved: u32,
10188 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
10189 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
10190 __bindgen_bitfield_unit.set(0usize, 1u8, {
10191 let error_resilient_mode: u32 = unsafe { ::core::mem::transmute(error_resilient_mode) };
10192 error_resilient_mode as u64
10193 });
10194 __bindgen_bitfield_unit.set(1usize, 1u8, {
10195 let disable_cdf_update: u32 = unsafe { ::core::mem::transmute(disable_cdf_update) };
10196 disable_cdf_update as u64
10197 });
10198 __bindgen_bitfield_unit.set(2usize, 1u8, {
10199 let use_superres: u32 = unsafe { ::core::mem::transmute(use_superres) };
10200 use_superres as u64
10201 });
10202 __bindgen_bitfield_unit.set(3usize, 1u8, {
10203 let render_and_frame_size_different: u32 =
10204 unsafe { ::core::mem::transmute(render_and_frame_size_different) };
10205 render_and_frame_size_different as u64
10206 });
10207 __bindgen_bitfield_unit.set(4usize, 1u8, {
10208 let allow_screen_content_tools: u32 =
10209 unsafe { ::core::mem::transmute(allow_screen_content_tools) };
10210 allow_screen_content_tools as u64
10211 });
10212 __bindgen_bitfield_unit.set(5usize, 1u8, {
10213 let is_filter_switchable: u32 = unsafe { ::core::mem::transmute(is_filter_switchable) };
10214 is_filter_switchable as u64
10215 });
10216 __bindgen_bitfield_unit.set(6usize, 1u8, {
10217 let force_integer_mv: u32 = unsafe { ::core::mem::transmute(force_integer_mv) };
10218 force_integer_mv as u64
10219 });
10220 __bindgen_bitfield_unit.set(7usize, 1u8, {
10221 let frame_size_override_flag: u32 =
10222 unsafe { ::core::mem::transmute(frame_size_override_flag) };
10223 frame_size_override_flag as u64
10224 });
10225 __bindgen_bitfield_unit.set(8usize, 1u8, {
10226 let buffer_removal_time_present_flag: u32 =
10227 unsafe { ::core::mem::transmute(buffer_removal_time_present_flag) };
10228 buffer_removal_time_present_flag as u64
10229 });
10230 __bindgen_bitfield_unit.set(9usize, 1u8, {
10231 let allow_intrabc: u32 = unsafe { ::core::mem::transmute(allow_intrabc) };
10232 allow_intrabc as u64
10233 });
10234 __bindgen_bitfield_unit.set(10usize, 1u8, {
10235 let frame_refs_short_signaling: u32 =
10236 unsafe { ::core::mem::transmute(frame_refs_short_signaling) };
10237 frame_refs_short_signaling as u64
10238 });
10239 __bindgen_bitfield_unit.set(11usize, 1u8, {
10240 let allow_high_precision_mv: u32 =
10241 unsafe { ::core::mem::transmute(allow_high_precision_mv) };
10242 allow_high_precision_mv as u64
10243 });
10244 __bindgen_bitfield_unit.set(12usize, 1u8, {
10245 let is_motion_mode_switchable: u32 =
10246 unsafe { ::core::mem::transmute(is_motion_mode_switchable) };
10247 is_motion_mode_switchable as u64
10248 });
10249 __bindgen_bitfield_unit.set(13usize, 1u8, {
10250 let use_ref_frame_mvs: u32 = unsafe { ::core::mem::transmute(use_ref_frame_mvs) };
10251 use_ref_frame_mvs as u64
10252 });
10253 __bindgen_bitfield_unit.set(14usize, 1u8, {
10254 let disable_frame_end_update_cdf: u32 =
10255 unsafe { ::core::mem::transmute(disable_frame_end_update_cdf) };
10256 disable_frame_end_update_cdf as u64
10257 });
10258 __bindgen_bitfield_unit.set(15usize, 1u8, {
10259 let allow_warped_motion: u32 = unsafe { ::core::mem::transmute(allow_warped_motion) };
10260 allow_warped_motion as u64
10261 });
10262 __bindgen_bitfield_unit.set(16usize, 1u8, {
10263 let reduced_tx_set: u32 = unsafe { ::core::mem::transmute(reduced_tx_set) };
10264 reduced_tx_set as u64
10265 });
10266 __bindgen_bitfield_unit.set(17usize, 1u8, {
10267 let reference_select: u32 = unsafe { ::core::mem::transmute(reference_select) };
10268 reference_select as u64
10269 });
10270 __bindgen_bitfield_unit.set(18usize, 1u8, {
10271 let skip_mode_present: u32 = unsafe { ::core::mem::transmute(skip_mode_present) };
10272 skip_mode_present as u64
10273 });
10274 __bindgen_bitfield_unit.set(19usize, 1u8, {
10275 let delta_q_present: u32 = unsafe { ::core::mem::transmute(delta_q_present) };
10276 delta_q_present as u64
10277 });
10278 __bindgen_bitfield_unit.set(20usize, 1u8, {
10279 let delta_lf_present: u32 = unsafe { ::core::mem::transmute(delta_lf_present) };
10280 delta_lf_present as u64
10281 });
10282 __bindgen_bitfield_unit.set(21usize, 1u8, {
10283 let delta_lf_multi: u32 = unsafe { ::core::mem::transmute(delta_lf_multi) };
10284 delta_lf_multi as u64
10285 });
10286 __bindgen_bitfield_unit.set(22usize, 1u8, {
10287 let segmentation_enabled: u32 = unsafe { ::core::mem::transmute(segmentation_enabled) };
10288 segmentation_enabled as u64
10289 });
10290 __bindgen_bitfield_unit.set(23usize, 1u8, {
10291 let segmentation_update_map: u32 =
10292 unsafe { ::core::mem::transmute(segmentation_update_map) };
10293 segmentation_update_map as u64
10294 });
10295 __bindgen_bitfield_unit.set(24usize, 1u8, {
10296 let segmentation_temporal_update: u32 =
10297 unsafe { ::core::mem::transmute(segmentation_temporal_update) };
10298 segmentation_temporal_update as u64
10299 });
10300 __bindgen_bitfield_unit.set(25usize, 1u8, {
10301 let segmentation_update_data: u32 =
10302 unsafe { ::core::mem::transmute(segmentation_update_data) };
10303 segmentation_update_data as u64
10304 });
10305 __bindgen_bitfield_unit.set(26usize, 1u8, {
10306 let UsesLr: u32 = unsafe { ::core::mem::transmute(UsesLr) };
10307 UsesLr as u64
10308 });
10309 __bindgen_bitfield_unit.set(27usize, 1u8, {
10310 let usesChromaLr: u32 = unsafe { ::core::mem::transmute(usesChromaLr) };
10311 usesChromaLr as u64
10312 });
10313 __bindgen_bitfield_unit.set(28usize, 1u8, {
10314 let apply_grain: u32 = unsafe { ::core::mem::transmute(apply_grain) };
10315 apply_grain as u64
10316 });
10317 __bindgen_bitfield_unit.set(29usize, 3u8, {
10318 let reserved: u32 = unsafe { ::core::mem::transmute(reserved) };
10319 reserved as u64
10320 });
10321 __bindgen_bitfield_unit
10322 }
10323}
10324#[repr(C)]
10325#[derive(Debug, Copy, Clone)]
10326pub struct StdVideoDecodeAV1PictureInfo {
10327 pub flags: StdVideoDecodeAV1PictureInfoFlags,
10328 pub frame_type: StdVideoAV1FrameType,
10329 pub current_frame_id: u32,
10330 pub OrderHint: u8,
10331 pub primary_ref_frame: u8,
10332 pub refresh_frame_flags: u8,
10333 pub reserved1: u8,
10334 pub interpolation_filter: StdVideoAV1InterpolationFilter,
10335 pub TxMode: StdVideoAV1TxMode,
10336 pub delta_q_res: u8,
10337 pub delta_lf_res: u8,
10338 pub SkipModeFrame: [u8; 2usize],
10339 pub coded_denom: u8,
10340 pub reserved2: [u8; 3usize],
10341 pub OrderHints: [u8; 8usize],
10342 pub expectedFrameId: [u32; 8usize],
10343 pub pTileInfo: *const StdVideoAV1TileInfo,
10344 pub pQuantization: *const StdVideoAV1Quantization,
10345 pub pSegmentation: *const StdVideoAV1Segmentation,
10346 pub pLoopFilter: *const StdVideoAV1LoopFilter,
10347 pub pCDEF: *const StdVideoAV1CDEF,
10348 pub pLoopRestoration: *const StdVideoAV1LoopRestoration,
10349 pub pGlobalMotion: *const StdVideoAV1GlobalMotion,
10350 pub pFilmGrain: *const StdVideoAV1FilmGrain,
10351}
10352#[test]
10353fn bindgen_test_layout_StdVideoDecodeAV1PictureInfo() {
10354 const UNINIT: ::core::mem::MaybeUninit<StdVideoDecodeAV1PictureInfo> =
10355 ::core::mem::MaybeUninit::uninit();
10356 let ptr = UNINIT.as_ptr();
10357 assert_eq!(
10358 ::core::mem::size_of::<StdVideoDecodeAV1PictureInfo>(),
10359 136usize,
10360 concat!("Size of: ", stringify!(StdVideoDecodeAV1PictureInfo))
10361 );
10362 assert_eq!(
10363 ::core::mem::align_of::<StdVideoDecodeAV1PictureInfo>(),
10364 8usize,
10365 concat!("Alignment of ", stringify!(StdVideoDecodeAV1PictureInfo))
10366 );
10367 assert_eq!(
10368 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
10369 0usize,
10370 concat!(
10371 "Offset of field: ",
10372 stringify!(StdVideoDecodeAV1PictureInfo),
10373 "::",
10374 stringify!(flags)
10375 )
10376 );
10377 assert_eq!(
10378 unsafe { ::core::ptr::addr_of!((*ptr).frame_type) as usize - ptr as usize },
10379 4usize,
10380 concat!(
10381 "Offset of field: ",
10382 stringify!(StdVideoDecodeAV1PictureInfo),
10383 "::",
10384 stringify!(frame_type)
10385 )
10386 );
10387 assert_eq!(
10388 unsafe { ::core::ptr::addr_of!((*ptr).current_frame_id) as usize - ptr as usize },
10389 8usize,
10390 concat!(
10391 "Offset of field: ",
10392 stringify!(StdVideoDecodeAV1PictureInfo),
10393 "::",
10394 stringify!(current_frame_id)
10395 )
10396 );
10397 assert_eq!(
10398 unsafe { ::core::ptr::addr_of!((*ptr).OrderHint) as usize - ptr as usize },
10399 12usize,
10400 concat!(
10401 "Offset of field: ",
10402 stringify!(StdVideoDecodeAV1PictureInfo),
10403 "::",
10404 stringify!(OrderHint)
10405 )
10406 );
10407 assert_eq!(
10408 unsafe { ::core::ptr::addr_of!((*ptr).primary_ref_frame) as usize - ptr as usize },
10409 13usize,
10410 concat!(
10411 "Offset of field: ",
10412 stringify!(StdVideoDecodeAV1PictureInfo),
10413 "::",
10414 stringify!(primary_ref_frame)
10415 )
10416 );
10417 assert_eq!(
10418 unsafe { ::core::ptr::addr_of!((*ptr).refresh_frame_flags) as usize - ptr as usize },
10419 14usize,
10420 concat!(
10421 "Offset of field: ",
10422 stringify!(StdVideoDecodeAV1PictureInfo),
10423 "::",
10424 stringify!(refresh_frame_flags)
10425 )
10426 );
10427 assert_eq!(
10428 unsafe { ::core::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize },
10429 15usize,
10430 concat!(
10431 "Offset of field: ",
10432 stringify!(StdVideoDecodeAV1PictureInfo),
10433 "::",
10434 stringify!(reserved1)
10435 )
10436 );
10437 assert_eq!(
10438 unsafe { ::core::ptr::addr_of!((*ptr).interpolation_filter) as usize - ptr as usize },
10439 16usize,
10440 concat!(
10441 "Offset of field: ",
10442 stringify!(StdVideoDecodeAV1PictureInfo),
10443 "::",
10444 stringify!(interpolation_filter)
10445 )
10446 );
10447 assert_eq!(
10448 unsafe { ::core::ptr::addr_of!((*ptr).TxMode) as usize - ptr as usize },
10449 20usize,
10450 concat!(
10451 "Offset of field: ",
10452 stringify!(StdVideoDecodeAV1PictureInfo),
10453 "::",
10454 stringify!(TxMode)
10455 )
10456 );
10457 assert_eq!(
10458 unsafe { ::core::ptr::addr_of!((*ptr).delta_q_res) as usize - ptr as usize },
10459 24usize,
10460 concat!(
10461 "Offset of field: ",
10462 stringify!(StdVideoDecodeAV1PictureInfo),
10463 "::",
10464 stringify!(delta_q_res)
10465 )
10466 );
10467 assert_eq!(
10468 unsafe { ::core::ptr::addr_of!((*ptr).delta_lf_res) as usize - ptr as usize },
10469 25usize,
10470 concat!(
10471 "Offset of field: ",
10472 stringify!(StdVideoDecodeAV1PictureInfo),
10473 "::",
10474 stringify!(delta_lf_res)
10475 )
10476 );
10477 assert_eq!(
10478 unsafe { ::core::ptr::addr_of!((*ptr).SkipModeFrame) as usize - ptr as usize },
10479 26usize,
10480 concat!(
10481 "Offset of field: ",
10482 stringify!(StdVideoDecodeAV1PictureInfo),
10483 "::",
10484 stringify!(SkipModeFrame)
10485 )
10486 );
10487 assert_eq!(
10488 unsafe { ::core::ptr::addr_of!((*ptr).coded_denom) as usize - ptr as usize },
10489 28usize,
10490 concat!(
10491 "Offset of field: ",
10492 stringify!(StdVideoDecodeAV1PictureInfo),
10493 "::",
10494 stringify!(coded_denom)
10495 )
10496 );
10497 assert_eq!(
10498 unsafe { ::core::ptr::addr_of!((*ptr).reserved2) as usize - ptr as usize },
10499 29usize,
10500 concat!(
10501 "Offset of field: ",
10502 stringify!(StdVideoDecodeAV1PictureInfo),
10503 "::",
10504 stringify!(reserved2)
10505 )
10506 );
10507 assert_eq!(
10508 unsafe { ::core::ptr::addr_of!((*ptr).OrderHints) as usize - ptr as usize },
10509 32usize,
10510 concat!(
10511 "Offset of field: ",
10512 stringify!(StdVideoDecodeAV1PictureInfo),
10513 "::",
10514 stringify!(OrderHints)
10515 )
10516 );
10517 assert_eq!(
10518 unsafe { ::core::ptr::addr_of!((*ptr).expectedFrameId) as usize - ptr as usize },
10519 40usize,
10520 concat!(
10521 "Offset of field: ",
10522 stringify!(StdVideoDecodeAV1PictureInfo),
10523 "::",
10524 stringify!(expectedFrameId)
10525 )
10526 );
10527 assert_eq!(
10528 unsafe { ::core::ptr::addr_of!((*ptr).pTileInfo) as usize - ptr as usize },
10529 72usize,
10530 concat!(
10531 "Offset of field: ",
10532 stringify!(StdVideoDecodeAV1PictureInfo),
10533 "::",
10534 stringify!(pTileInfo)
10535 )
10536 );
10537 assert_eq!(
10538 unsafe { ::core::ptr::addr_of!((*ptr).pQuantization) as usize - ptr as usize },
10539 80usize,
10540 concat!(
10541 "Offset of field: ",
10542 stringify!(StdVideoDecodeAV1PictureInfo),
10543 "::",
10544 stringify!(pQuantization)
10545 )
10546 );
10547 assert_eq!(
10548 unsafe { ::core::ptr::addr_of!((*ptr).pSegmentation) as usize - ptr as usize },
10549 88usize,
10550 concat!(
10551 "Offset of field: ",
10552 stringify!(StdVideoDecodeAV1PictureInfo),
10553 "::",
10554 stringify!(pSegmentation)
10555 )
10556 );
10557 assert_eq!(
10558 unsafe { ::core::ptr::addr_of!((*ptr).pLoopFilter) as usize - ptr as usize },
10559 96usize,
10560 concat!(
10561 "Offset of field: ",
10562 stringify!(StdVideoDecodeAV1PictureInfo),
10563 "::",
10564 stringify!(pLoopFilter)
10565 )
10566 );
10567 assert_eq!(
10568 unsafe { ::core::ptr::addr_of!((*ptr).pCDEF) as usize - ptr as usize },
10569 104usize,
10570 concat!(
10571 "Offset of field: ",
10572 stringify!(StdVideoDecodeAV1PictureInfo),
10573 "::",
10574 stringify!(pCDEF)
10575 )
10576 );
10577 assert_eq!(
10578 unsafe { ::core::ptr::addr_of!((*ptr).pLoopRestoration) as usize - ptr as usize },
10579 112usize,
10580 concat!(
10581 "Offset of field: ",
10582 stringify!(StdVideoDecodeAV1PictureInfo),
10583 "::",
10584 stringify!(pLoopRestoration)
10585 )
10586 );
10587 assert_eq!(
10588 unsafe { ::core::ptr::addr_of!((*ptr).pGlobalMotion) as usize - ptr as usize },
10589 120usize,
10590 concat!(
10591 "Offset of field: ",
10592 stringify!(StdVideoDecodeAV1PictureInfo),
10593 "::",
10594 stringify!(pGlobalMotion)
10595 )
10596 );
10597 assert_eq!(
10598 unsafe { ::core::ptr::addr_of!((*ptr).pFilmGrain) as usize - ptr as usize },
10599 128usize,
10600 concat!(
10601 "Offset of field: ",
10602 stringify!(StdVideoDecodeAV1PictureInfo),
10603 "::",
10604 stringify!(pFilmGrain)
10605 )
10606 );
10607}
10608#[repr(C)]
10609#[derive(Debug, Copy, Clone)]
10610pub struct StdVideoDecodeAV1ReferenceInfoFlags {
10611 pub _bitfield_align_1: [u32; 0],
10612 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
10613}
10614#[test]
10615fn bindgen_test_layout_StdVideoDecodeAV1ReferenceInfoFlags() {
10616 assert_eq!(
10617 ::core::mem::size_of::<StdVideoDecodeAV1ReferenceInfoFlags>(),
10618 4usize,
10619 concat!("Size of: ", stringify!(StdVideoDecodeAV1ReferenceInfoFlags))
10620 );
10621 assert_eq!(
10622 ::core::mem::align_of::<StdVideoDecodeAV1ReferenceInfoFlags>(),
10623 4usize,
10624 concat!(
10625 "Alignment of ",
10626 stringify!(StdVideoDecodeAV1ReferenceInfoFlags)
10627 )
10628 );
10629}
10630impl StdVideoDecodeAV1ReferenceInfoFlags {
10631 #[inline]
10632 pub fn disable_frame_end_update_cdf(&self) -> u32 {
10633 unsafe { ::core::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
10634 }
10635 #[inline]
10636 pub fn set_disable_frame_end_update_cdf(&mut self, val: u32) {
10637 unsafe {
10638 let val: u32 = ::core::mem::transmute(val);
10639 self._bitfield_1.set(0usize, 1u8, val as u64)
10640 }
10641 }
10642 #[inline]
10643 pub fn segmentation_enabled(&self) -> u32 {
10644 unsafe { ::core::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
10645 }
10646 #[inline]
10647 pub fn set_segmentation_enabled(&mut self, val: u32) {
10648 unsafe {
10649 let val: u32 = ::core::mem::transmute(val);
10650 self._bitfield_1.set(1usize, 1u8, val as u64)
10651 }
10652 }
10653 #[inline]
10654 pub fn reserved(&self) -> u32 {
10655 unsafe { ::core::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) }
10656 }
10657 #[inline]
10658 pub fn set_reserved(&mut self, val: u32) {
10659 unsafe {
10660 let val: u32 = ::core::mem::transmute(val);
10661 self._bitfield_1.set(2usize, 30u8, val as u64)
10662 }
10663 }
10664 #[inline]
10665 pub fn new_bitfield_1(
10666 disable_frame_end_update_cdf: u32,
10667 segmentation_enabled: u32,
10668 reserved: u32,
10669 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
10670 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
10671 __bindgen_bitfield_unit.set(0usize, 1u8, {
10672 let disable_frame_end_update_cdf: u32 =
10673 unsafe { ::core::mem::transmute(disable_frame_end_update_cdf) };
10674 disable_frame_end_update_cdf as u64
10675 });
10676 __bindgen_bitfield_unit.set(1usize, 1u8, {
10677 let segmentation_enabled: u32 = unsafe { ::core::mem::transmute(segmentation_enabled) };
10678 segmentation_enabled as u64
10679 });
10680 __bindgen_bitfield_unit.set(2usize, 30u8, {
10681 let reserved: u32 = unsafe { ::core::mem::transmute(reserved) };
10682 reserved as u64
10683 });
10684 __bindgen_bitfield_unit
10685 }
10686}
10687#[repr(C)]
10688#[derive(Debug, Copy, Clone)]
10689pub struct StdVideoDecodeAV1ReferenceInfo {
10690 pub flags: StdVideoDecodeAV1ReferenceInfoFlags,
10691 pub frame_type: u8,
10692 pub RefFrameSignBias: u8,
10693 pub OrderHint: u8,
10694 pub SavedOrderHints: [u8; 8usize],
10695}
10696#[test]
10697fn bindgen_test_layout_StdVideoDecodeAV1ReferenceInfo() {
10698 const UNINIT: ::core::mem::MaybeUninit<StdVideoDecodeAV1ReferenceInfo> =
10699 ::core::mem::MaybeUninit::uninit();
10700 let ptr = UNINIT.as_ptr();
10701 assert_eq!(
10702 ::core::mem::size_of::<StdVideoDecodeAV1ReferenceInfo>(),
10703 16usize,
10704 concat!("Size of: ", stringify!(StdVideoDecodeAV1ReferenceInfo))
10705 );
10706 assert_eq!(
10707 ::core::mem::align_of::<StdVideoDecodeAV1ReferenceInfo>(),
10708 4usize,
10709 concat!("Alignment of ", stringify!(StdVideoDecodeAV1ReferenceInfo))
10710 );
10711 assert_eq!(
10712 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
10713 0usize,
10714 concat!(
10715 "Offset of field: ",
10716 stringify!(StdVideoDecodeAV1ReferenceInfo),
10717 "::",
10718 stringify!(flags)
10719 )
10720 );
10721 assert_eq!(
10722 unsafe { ::core::ptr::addr_of!((*ptr).frame_type) as usize - ptr as usize },
10723 4usize,
10724 concat!(
10725 "Offset of field: ",
10726 stringify!(StdVideoDecodeAV1ReferenceInfo),
10727 "::",
10728 stringify!(frame_type)
10729 )
10730 );
10731 assert_eq!(
10732 unsafe { ::core::ptr::addr_of!((*ptr).RefFrameSignBias) as usize - ptr as usize },
10733 5usize,
10734 concat!(
10735 "Offset of field: ",
10736 stringify!(StdVideoDecodeAV1ReferenceInfo),
10737 "::",
10738 stringify!(RefFrameSignBias)
10739 )
10740 );
10741 assert_eq!(
10742 unsafe { ::core::ptr::addr_of!((*ptr).OrderHint) as usize - ptr as usize },
10743 6usize,
10744 concat!(
10745 "Offset of field: ",
10746 stringify!(StdVideoDecodeAV1ReferenceInfo),
10747 "::",
10748 stringify!(OrderHint)
10749 )
10750 );
10751 assert_eq!(
10752 unsafe { ::core::ptr::addr_of!((*ptr).SavedOrderHints) as usize - ptr as usize },
10753 7usize,
10754 concat!(
10755 "Offset of field: ",
10756 stringify!(StdVideoDecodeAV1ReferenceInfo),
10757 "::",
10758 stringify!(SavedOrderHints)
10759 )
10760 );
10761}
10762#[repr(C)]
10763#[derive(Debug, Copy, Clone)]
10764pub struct StdVideoEncodeH264WeightTableFlags {
10765 pub luma_weight_l0_flag: u32,
10766 pub chroma_weight_l0_flag: u32,
10767 pub luma_weight_l1_flag: u32,
10768 pub chroma_weight_l1_flag: u32,
10769}
10770#[test]
10771fn bindgen_test_layout_StdVideoEncodeH264WeightTableFlags() {
10772 const UNINIT: ::core::mem::MaybeUninit<StdVideoEncodeH264WeightTableFlags> =
10773 ::core::mem::MaybeUninit::uninit();
10774 let ptr = UNINIT.as_ptr();
10775 assert_eq!(
10776 ::core::mem::size_of::<StdVideoEncodeH264WeightTableFlags>(),
10777 16usize,
10778 concat!("Size of: ", stringify!(StdVideoEncodeH264WeightTableFlags))
10779 );
10780 assert_eq!(
10781 ::core::mem::align_of::<StdVideoEncodeH264WeightTableFlags>(),
10782 4usize,
10783 concat!(
10784 "Alignment of ",
10785 stringify!(StdVideoEncodeH264WeightTableFlags)
10786 )
10787 );
10788 assert_eq!(
10789 unsafe { ::core::ptr::addr_of!((*ptr).luma_weight_l0_flag) as usize - ptr as usize },
10790 0usize,
10791 concat!(
10792 "Offset of field: ",
10793 stringify!(StdVideoEncodeH264WeightTableFlags),
10794 "::",
10795 stringify!(luma_weight_l0_flag)
10796 )
10797 );
10798 assert_eq!(
10799 unsafe { ::core::ptr::addr_of!((*ptr).chroma_weight_l0_flag) as usize - ptr as usize },
10800 4usize,
10801 concat!(
10802 "Offset of field: ",
10803 stringify!(StdVideoEncodeH264WeightTableFlags),
10804 "::",
10805 stringify!(chroma_weight_l0_flag)
10806 )
10807 );
10808 assert_eq!(
10809 unsafe { ::core::ptr::addr_of!((*ptr).luma_weight_l1_flag) as usize - ptr as usize },
10810 8usize,
10811 concat!(
10812 "Offset of field: ",
10813 stringify!(StdVideoEncodeH264WeightTableFlags),
10814 "::",
10815 stringify!(luma_weight_l1_flag)
10816 )
10817 );
10818 assert_eq!(
10819 unsafe { ::core::ptr::addr_of!((*ptr).chroma_weight_l1_flag) as usize - ptr as usize },
10820 12usize,
10821 concat!(
10822 "Offset of field: ",
10823 stringify!(StdVideoEncodeH264WeightTableFlags),
10824 "::",
10825 stringify!(chroma_weight_l1_flag)
10826 )
10827 );
10828}
10829#[repr(C)]
10830#[derive(Debug, Copy, Clone)]
10831pub struct StdVideoEncodeH264WeightTable {
10832 pub flags: StdVideoEncodeH264WeightTableFlags,
10833 pub luma_log2_weight_denom: u8,
10834 pub chroma_log2_weight_denom: u8,
10835 pub luma_weight_l0: [i8; 32usize],
10836 pub luma_offset_l0: [i8; 32usize],
10837 pub chroma_weight_l0: [[i8; 2usize]; 32usize],
10838 pub chroma_offset_l0: [[i8; 2usize]; 32usize],
10839 pub luma_weight_l1: [i8; 32usize],
10840 pub luma_offset_l1: [i8; 32usize],
10841 pub chroma_weight_l1: [[i8; 2usize]; 32usize],
10842 pub chroma_offset_l1: [[i8; 2usize]; 32usize],
10843}
10844#[test]
10845fn bindgen_test_layout_StdVideoEncodeH264WeightTable() {
10846 const UNINIT: ::core::mem::MaybeUninit<StdVideoEncodeH264WeightTable> =
10847 ::core::mem::MaybeUninit::uninit();
10848 let ptr = UNINIT.as_ptr();
10849 assert_eq!(
10850 ::core::mem::size_of::<StdVideoEncodeH264WeightTable>(),
10851 404usize,
10852 concat!("Size of: ", stringify!(StdVideoEncodeH264WeightTable))
10853 );
10854 assert_eq!(
10855 ::core::mem::align_of::<StdVideoEncodeH264WeightTable>(),
10856 4usize,
10857 concat!("Alignment of ", stringify!(StdVideoEncodeH264WeightTable))
10858 );
10859 assert_eq!(
10860 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
10861 0usize,
10862 concat!(
10863 "Offset of field: ",
10864 stringify!(StdVideoEncodeH264WeightTable),
10865 "::",
10866 stringify!(flags)
10867 )
10868 );
10869 assert_eq!(
10870 unsafe { ::core::ptr::addr_of!((*ptr).luma_log2_weight_denom) as usize - ptr as usize },
10871 16usize,
10872 concat!(
10873 "Offset of field: ",
10874 stringify!(StdVideoEncodeH264WeightTable),
10875 "::",
10876 stringify!(luma_log2_weight_denom)
10877 )
10878 );
10879 assert_eq!(
10880 unsafe { ::core::ptr::addr_of!((*ptr).chroma_log2_weight_denom) as usize - ptr as usize },
10881 17usize,
10882 concat!(
10883 "Offset of field: ",
10884 stringify!(StdVideoEncodeH264WeightTable),
10885 "::",
10886 stringify!(chroma_log2_weight_denom)
10887 )
10888 );
10889 assert_eq!(
10890 unsafe { ::core::ptr::addr_of!((*ptr).luma_weight_l0) as usize - ptr as usize },
10891 18usize,
10892 concat!(
10893 "Offset of field: ",
10894 stringify!(StdVideoEncodeH264WeightTable),
10895 "::",
10896 stringify!(luma_weight_l0)
10897 )
10898 );
10899 assert_eq!(
10900 unsafe { ::core::ptr::addr_of!((*ptr).luma_offset_l0) as usize - ptr as usize },
10901 50usize,
10902 concat!(
10903 "Offset of field: ",
10904 stringify!(StdVideoEncodeH264WeightTable),
10905 "::",
10906 stringify!(luma_offset_l0)
10907 )
10908 );
10909 assert_eq!(
10910 unsafe { ::core::ptr::addr_of!((*ptr).chroma_weight_l0) as usize - ptr as usize },
10911 82usize,
10912 concat!(
10913 "Offset of field: ",
10914 stringify!(StdVideoEncodeH264WeightTable),
10915 "::",
10916 stringify!(chroma_weight_l0)
10917 )
10918 );
10919 assert_eq!(
10920 unsafe { ::core::ptr::addr_of!((*ptr).chroma_offset_l0) as usize - ptr as usize },
10921 146usize,
10922 concat!(
10923 "Offset of field: ",
10924 stringify!(StdVideoEncodeH264WeightTable),
10925 "::",
10926 stringify!(chroma_offset_l0)
10927 )
10928 );
10929 assert_eq!(
10930 unsafe { ::core::ptr::addr_of!((*ptr).luma_weight_l1) as usize - ptr as usize },
10931 210usize,
10932 concat!(
10933 "Offset of field: ",
10934 stringify!(StdVideoEncodeH264WeightTable),
10935 "::",
10936 stringify!(luma_weight_l1)
10937 )
10938 );
10939 assert_eq!(
10940 unsafe { ::core::ptr::addr_of!((*ptr).luma_offset_l1) as usize - ptr as usize },
10941 242usize,
10942 concat!(
10943 "Offset of field: ",
10944 stringify!(StdVideoEncodeH264WeightTable),
10945 "::",
10946 stringify!(luma_offset_l1)
10947 )
10948 );
10949 assert_eq!(
10950 unsafe { ::core::ptr::addr_of!((*ptr).chroma_weight_l1) as usize - ptr as usize },
10951 274usize,
10952 concat!(
10953 "Offset of field: ",
10954 stringify!(StdVideoEncodeH264WeightTable),
10955 "::",
10956 stringify!(chroma_weight_l1)
10957 )
10958 );
10959 assert_eq!(
10960 unsafe { ::core::ptr::addr_of!((*ptr).chroma_offset_l1) as usize - ptr as usize },
10961 338usize,
10962 concat!(
10963 "Offset of field: ",
10964 stringify!(StdVideoEncodeH264WeightTable),
10965 "::",
10966 stringify!(chroma_offset_l1)
10967 )
10968 );
10969}
10970#[repr(C)]
10971#[derive(Debug, Copy, Clone)]
10972pub struct StdVideoEncodeH264SliceHeaderFlags {
10973 pub _bitfield_align_1: [u32; 0],
10974 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
10975}
10976#[test]
10977fn bindgen_test_layout_StdVideoEncodeH264SliceHeaderFlags() {
10978 assert_eq!(
10979 ::core::mem::size_of::<StdVideoEncodeH264SliceHeaderFlags>(),
10980 4usize,
10981 concat!("Size of: ", stringify!(StdVideoEncodeH264SliceHeaderFlags))
10982 );
10983 assert_eq!(
10984 ::core::mem::align_of::<StdVideoEncodeH264SliceHeaderFlags>(),
10985 4usize,
10986 concat!(
10987 "Alignment of ",
10988 stringify!(StdVideoEncodeH264SliceHeaderFlags)
10989 )
10990 );
10991}
10992impl StdVideoEncodeH264SliceHeaderFlags {
10993 #[inline]
10994 pub fn direct_spatial_mv_pred_flag(&self) -> u32 {
10995 unsafe { ::core::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
10996 }
10997 #[inline]
10998 pub fn set_direct_spatial_mv_pred_flag(&mut self, val: u32) {
10999 unsafe {
11000 let val: u32 = ::core::mem::transmute(val);
11001 self._bitfield_1.set(0usize, 1u8, val as u64)
11002 }
11003 }
11004 #[inline]
11005 pub fn num_ref_idx_active_override_flag(&self) -> u32 {
11006 unsafe { ::core::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
11007 }
11008 #[inline]
11009 pub fn set_num_ref_idx_active_override_flag(&mut self, val: u32) {
11010 unsafe {
11011 let val: u32 = ::core::mem::transmute(val);
11012 self._bitfield_1.set(1usize, 1u8, val as u64)
11013 }
11014 }
11015 #[inline]
11016 pub fn reserved(&self) -> u32 {
11017 unsafe { ::core::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) }
11018 }
11019 #[inline]
11020 pub fn set_reserved(&mut self, val: u32) {
11021 unsafe {
11022 let val: u32 = ::core::mem::transmute(val);
11023 self._bitfield_1.set(2usize, 30u8, val as u64)
11024 }
11025 }
11026 #[inline]
11027 pub fn new_bitfield_1(
11028 direct_spatial_mv_pred_flag: u32,
11029 num_ref_idx_active_override_flag: u32,
11030 reserved: u32,
11031 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
11032 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
11033 __bindgen_bitfield_unit.set(0usize, 1u8, {
11034 let direct_spatial_mv_pred_flag: u32 =
11035 unsafe { ::core::mem::transmute(direct_spatial_mv_pred_flag) };
11036 direct_spatial_mv_pred_flag as u64
11037 });
11038 __bindgen_bitfield_unit.set(1usize, 1u8, {
11039 let num_ref_idx_active_override_flag: u32 =
11040 unsafe { ::core::mem::transmute(num_ref_idx_active_override_flag) };
11041 num_ref_idx_active_override_flag as u64
11042 });
11043 __bindgen_bitfield_unit.set(2usize, 30u8, {
11044 let reserved: u32 = unsafe { ::core::mem::transmute(reserved) };
11045 reserved as u64
11046 });
11047 __bindgen_bitfield_unit
11048 }
11049}
11050#[repr(C)]
11051#[derive(Debug, Copy, Clone)]
11052pub struct StdVideoEncodeH264PictureInfoFlags {
11053 pub _bitfield_align_1: [u32; 0],
11054 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
11055}
11056#[test]
11057fn bindgen_test_layout_StdVideoEncodeH264PictureInfoFlags() {
11058 assert_eq!(
11059 ::core::mem::size_of::<StdVideoEncodeH264PictureInfoFlags>(),
11060 4usize,
11061 concat!("Size of: ", stringify!(StdVideoEncodeH264PictureInfoFlags))
11062 );
11063 assert_eq!(
11064 ::core::mem::align_of::<StdVideoEncodeH264PictureInfoFlags>(),
11065 4usize,
11066 concat!(
11067 "Alignment of ",
11068 stringify!(StdVideoEncodeH264PictureInfoFlags)
11069 )
11070 );
11071}
11072impl StdVideoEncodeH264PictureInfoFlags {
11073 #[inline]
11074 pub fn IdrPicFlag(&self) -> u32 {
11075 unsafe { ::core::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
11076 }
11077 #[inline]
11078 pub fn set_IdrPicFlag(&mut self, val: u32) {
11079 unsafe {
11080 let val: u32 = ::core::mem::transmute(val);
11081 self._bitfield_1.set(0usize, 1u8, val as u64)
11082 }
11083 }
11084 #[inline]
11085 pub fn is_reference(&self) -> u32 {
11086 unsafe { ::core::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
11087 }
11088 #[inline]
11089 pub fn set_is_reference(&mut self, val: u32) {
11090 unsafe {
11091 let val: u32 = ::core::mem::transmute(val);
11092 self._bitfield_1.set(1usize, 1u8, val as u64)
11093 }
11094 }
11095 #[inline]
11096 pub fn no_output_of_prior_pics_flag(&self) -> u32 {
11097 unsafe { ::core::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
11098 }
11099 #[inline]
11100 pub fn set_no_output_of_prior_pics_flag(&mut self, val: u32) {
11101 unsafe {
11102 let val: u32 = ::core::mem::transmute(val);
11103 self._bitfield_1.set(2usize, 1u8, val as u64)
11104 }
11105 }
11106 #[inline]
11107 pub fn long_term_reference_flag(&self) -> u32 {
11108 unsafe { ::core::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
11109 }
11110 #[inline]
11111 pub fn set_long_term_reference_flag(&mut self, val: u32) {
11112 unsafe {
11113 let val: u32 = ::core::mem::transmute(val);
11114 self._bitfield_1.set(3usize, 1u8, val as u64)
11115 }
11116 }
11117 #[inline]
11118 pub fn adaptive_ref_pic_marking_mode_flag(&self) -> u32 {
11119 unsafe { ::core::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
11120 }
11121 #[inline]
11122 pub fn set_adaptive_ref_pic_marking_mode_flag(&mut self, val: u32) {
11123 unsafe {
11124 let val: u32 = ::core::mem::transmute(val);
11125 self._bitfield_1.set(4usize, 1u8, val as u64)
11126 }
11127 }
11128 #[inline]
11129 pub fn reserved(&self) -> u32 {
11130 unsafe { ::core::mem::transmute(self._bitfield_1.get(5usize, 27u8) as u32) }
11131 }
11132 #[inline]
11133 pub fn set_reserved(&mut self, val: u32) {
11134 unsafe {
11135 let val: u32 = ::core::mem::transmute(val);
11136 self._bitfield_1.set(5usize, 27u8, val as u64)
11137 }
11138 }
11139 #[inline]
11140 pub fn new_bitfield_1(
11141 IdrPicFlag: u32,
11142 is_reference: u32,
11143 no_output_of_prior_pics_flag: u32,
11144 long_term_reference_flag: u32,
11145 adaptive_ref_pic_marking_mode_flag: u32,
11146 reserved: u32,
11147 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
11148 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
11149 __bindgen_bitfield_unit.set(0usize, 1u8, {
11150 let IdrPicFlag: u32 = unsafe { ::core::mem::transmute(IdrPicFlag) };
11151 IdrPicFlag as u64
11152 });
11153 __bindgen_bitfield_unit.set(1usize, 1u8, {
11154 let is_reference: u32 = unsafe { ::core::mem::transmute(is_reference) };
11155 is_reference as u64
11156 });
11157 __bindgen_bitfield_unit.set(2usize, 1u8, {
11158 let no_output_of_prior_pics_flag: u32 =
11159 unsafe { ::core::mem::transmute(no_output_of_prior_pics_flag) };
11160 no_output_of_prior_pics_flag as u64
11161 });
11162 __bindgen_bitfield_unit.set(3usize, 1u8, {
11163 let long_term_reference_flag: u32 =
11164 unsafe { ::core::mem::transmute(long_term_reference_flag) };
11165 long_term_reference_flag as u64
11166 });
11167 __bindgen_bitfield_unit.set(4usize, 1u8, {
11168 let adaptive_ref_pic_marking_mode_flag: u32 =
11169 unsafe { ::core::mem::transmute(adaptive_ref_pic_marking_mode_flag) };
11170 adaptive_ref_pic_marking_mode_flag as u64
11171 });
11172 __bindgen_bitfield_unit.set(5usize, 27u8, {
11173 let reserved: u32 = unsafe { ::core::mem::transmute(reserved) };
11174 reserved as u64
11175 });
11176 __bindgen_bitfield_unit
11177 }
11178}
11179#[repr(C)]
11180#[derive(Debug, Copy, Clone)]
11181pub struct StdVideoEncodeH264ReferenceInfoFlags {
11182 pub _bitfield_align_1: [u32; 0],
11183 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
11184}
11185#[test]
11186fn bindgen_test_layout_StdVideoEncodeH264ReferenceInfoFlags() {
11187 assert_eq!(
11188 ::core::mem::size_of::<StdVideoEncodeH264ReferenceInfoFlags>(),
11189 4usize,
11190 concat!(
11191 "Size of: ",
11192 stringify!(StdVideoEncodeH264ReferenceInfoFlags)
11193 )
11194 );
11195 assert_eq!(
11196 ::core::mem::align_of::<StdVideoEncodeH264ReferenceInfoFlags>(),
11197 4usize,
11198 concat!(
11199 "Alignment of ",
11200 stringify!(StdVideoEncodeH264ReferenceInfoFlags)
11201 )
11202 );
11203}
11204impl StdVideoEncodeH264ReferenceInfoFlags {
11205 #[inline]
11206 pub fn used_for_long_term_reference(&self) -> u32 {
11207 unsafe { ::core::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
11208 }
11209 #[inline]
11210 pub fn set_used_for_long_term_reference(&mut self, val: u32) {
11211 unsafe {
11212 let val: u32 = ::core::mem::transmute(val);
11213 self._bitfield_1.set(0usize, 1u8, val as u64)
11214 }
11215 }
11216 #[inline]
11217 pub fn reserved(&self) -> u32 {
11218 unsafe { ::core::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) }
11219 }
11220 #[inline]
11221 pub fn set_reserved(&mut self, val: u32) {
11222 unsafe {
11223 let val: u32 = ::core::mem::transmute(val);
11224 self._bitfield_1.set(1usize, 31u8, val as u64)
11225 }
11226 }
11227 #[inline]
11228 pub fn new_bitfield_1(
11229 used_for_long_term_reference: u32,
11230 reserved: u32,
11231 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
11232 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
11233 __bindgen_bitfield_unit.set(0usize, 1u8, {
11234 let used_for_long_term_reference: u32 =
11235 unsafe { ::core::mem::transmute(used_for_long_term_reference) };
11236 used_for_long_term_reference as u64
11237 });
11238 __bindgen_bitfield_unit.set(1usize, 31u8, {
11239 let reserved: u32 = unsafe { ::core::mem::transmute(reserved) };
11240 reserved as u64
11241 });
11242 __bindgen_bitfield_unit
11243 }
11244}
11245#[repr(C)]
11246#[derive(Debug, Copy, Clone)]
11247pub struct StdVideoEncodeH264ReferenceListsInfoFlags {
11248 pub _bitfield_align_1: [u32; 0],
11249 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
11250}
11251#[test]
11252fn bindgen_test_layout_StdVideoEncodeH264ReferenceListsInfoFlags() {
11253 assert_eq!(
11254 ::core::mem::size_of::<StdVideoEncodeH264ReferenceListsInfoFlags>(),
11255 4usize,
11256 concat!(
11257 "Size of: ",
11258 stringify!(StdVideoEncodeH264ReferenceListsInfoFlags)
11259 )
11260 );
11261 assert_eq!(
11262 ::core::mem::align_of::<StdVideoEncodeH264ReferenceListsInfoFlags>(),
11263 4usize,
11264 concat!(
11265 "Alignment of ",
11266 stringify!(StdVideoEncodeH264ReferenceListsInfoFlags)
11267 )
11268 );
11269}
11270impl StdVideoEncodeH264ReferenceListsInfoFlags {
11271 #[inline]
11272 pub fn ref_pic_list_modification_flag_l0(&self) -> u32 {
11273 unsafe { ::core::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
11274 }
11275 #[inline]
11276 pub fn set_ref_pic_list_modification_flag_l0(&mut self, val: u32) {
11277 unsafe {
11278 let val: u32 = ::core::mem::transmute(val);
11279 self._bitfield_1.set(0usize, 1u8, val as u64)
11280 }
11281 }
11282 #[inline]
11283 pub fn ref_pic_list_modification_flag_l1(&self) -> u32 {
11284 unsafe { ::core::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
11285 }
11286 #[inline]
11287 pub fn set_ref_pic_list_modification_flag_l1(&mut self, val: u32) {
11288 unsafe {
11289 let val: u32 = ::core::mem::transmute(val);
11290 self._bitfield_1.set(1usize, 1u8, val as u64)
11291 }
11292 }
11293 #[inline]
11294 pub fn reserved(&self) -> u32 {
11295 unsafe { ::core::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) }
11296 }
11297 #[inline]
11298 pub fn set_reserved(&mut self, val: u32) {
11299 unsafe {
11300 let val: u32 = ::core::mem::transmute(val);
11301 self._bitfield_1.set(2usize, 30u8, val as u64)
11302 }
11303 }
11304 #[inline]
11305 pub fn new_bitfield_1(
11306 ref_pic_list_modification_flag_l0: u32,
11307 ref_pic_list_modification_flag_l1: u32,
11308 reserved: u32,
11309 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
11310 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
11311 __bindgen_bitfield_unit.set(0usize, 1u8, {
11312 let ref_pic_list_modification_flag_l0: u32 =
11313 unsafe { ::core::mem::transmute(ref_pic_list_modification_flag_l0) };
11314 ref_pic_list_modification_flag_l0 as u64
11315 });
11316 __bindgen_bitfield_unit.set(1usize, 1u8, {
11317 let ref_pic_list_modification_flag_l1: u32 =
11318 unsafe { ::core::mem::transmute(ref_pic_list_modification_flag_l1) };
11319 ref_pic_list_modification_flag_l1 as u64
11320 });
11321 __bindgen_bitfield_unit.set(2usize, 30u8, {
11322 let reserved: u32 = unsafe { ::core::mem::transmute(reserved) };
11323 reserved as u64
11324 });
11325 __bindgen_bitfield_unit
11326 }
11327}
11328#[repr(C)]
11329#[derive(Debug, Copy, Clone)]
11330pub struct StdVideoEncodeH264RefListModEntry {
11331 pub modification_of_pic_nums_idc: StdVideoH264ModificationOfPicNumsIdc,
11332 pub abs_diff_pic_num_minus1: u16,
11333 pub long_term_pic_num: u16,
11334}
11335#[test]
11336fn bindgen_test_layout_StdVideoEncodeH264RefListModEntry() {
11337 const UNINIT: ::core::mem::MaybeUninit<StdVideoEncodeH264RefListModEntry> =
11338 ::core::mem::MaybeUninit::uninit();
11339 let ptr = UNINIT.as_ptr();
11340 assert_eq!(
11341 ::core::mem::size_of::<StdVideoEncodeH264RefListModEntry>(),
11342 8usize,
11343 concat!("Size of: ", stringify!(StdVideoEncodeH264RefListModEntry))
11344 );
11345 assert_eq!(
11346 ::core::mem::align_of::<StdVideoEncodeH264RefListModEntry>(),
11347 4usize,
11348 concat!(
11349 "Alignment of ",
11350 stringify!(StdVideoEncodeH264RefListModEntry)
11351 )
11352 );
11353 assert_eq!(
11354 unsafe {
11355 ::core::ptr::addr_of!((*ptr).modification_of_pic_nums_idc) as usize - ptr as usize
11356 },
11357 0usize,
11358 concat!(
11359 "Offset of field: ",
11360 stringify!(StdVideoEncodeH264RefListModEntry),
11361 "::",
11362 stringify!(modification_of_pic_nums_idc)
11363 )
11364 );
11365 assert_eq!(
11366 unsafe { ::core::ptr::addr_of!((*ptr).abs_diff_pic_num_minus1) as usize - ptr as usize },
11367 4usize,
11368 concat!(
11369 "Offset of field: ",
11370 stringify!(StdVideoEncodeH264RefListModEntry),
11371 "::",
11372 stringify!(abs_diff_pic_num_minus1)
11373 )
11374 );
11375 assert_eq!(
11376 unsafe { ::core::ptr::addr_of!((*ptr).long_term_pic_num) as usize - ptr as usize },
11377 6usize,
11378 concat!(
11379 "Offset of field: ",
11380 stringify!(StdVideoEncodeH264RefListModEntry),
11381 "::",
11382 stringify!(long_term_pic_num)
11383 )
11384 );
11385}
11386#[repr(C)]
11387#[derive(Debug, Copy, Clone)]
11388pub struct StdVideoEncodeH264RefPicMarkingEntry {
11389 pub memory_management_control_operation: StdVideoH264MemMgmtControlOp,
11390 pub difference_of_pic_nums_minus1: u16,
11391 pub long_term_pic_num: u16,
11392 pub long_term_frame_idx: u16,
11393 pub max_long_term_frame_idx_plus1: u16,
11394}
11395#[test]
11396fn bindgen_test_layout_StdVideoEncodeH264RefPicMarkingEntry() {
11397 const UNINIT: ::core::mem::MaybeUninit<StdVideoEncodeH264RefPicMarkingEntry> =
11398 ::core::mem::MaybeUninit::uninit();
11399 let ptr = UNINIT.as_ptr();
11400 assert_eq!(
11401 ::core::mem::size_of::<StdVideoEncodeH264RefPicMarkingEntry>(),
11402 12usize,
11403 concat!(
11404 "Size of: ",
11405 stringify!(StdVideoEncodeH264RefPicMarkingEntry)
11406 )
11407 );
11408 assert_eq!(
11409 ::core::mem::align_of::<StdVideoEncodeH264RefPicMarkingEntry>(),
11410 4usize,
11411 concat!(
11412 "Alignment of ",
11413 stringify!(StdVideoEncodeH264RefPicMarkingEntry)
11414 )
11415 );
11416 assert_eq!(
11417 unsafe {
11418 ::core::ptr::addr_of!((*ptr).memory_management_control_operation) as usize
11419 - ptr as usize
11420 },
11421 0usize,
11422 concat!(
11423 "Offset of field: ",
11424 stringify!(StdVideoEncodeH264RefPicMarkingEntry),
11425 "::",
11426 stringify!(memory_management_control_operation)
11427 )
11428 );
11429 assert_eq!(
11430 unsafe {
11431 ::core::ptr::addr_of!((*ptr).difference_of_pic_nums_minus1) as usize - ptr as usize
11432 },
11433 4usize,
11434 concat!(
11435 "Offset of field: ",
11436 stringify!(StdVideoEncodeH264RefPicMarkingEntry),
11437 "::",
11438 stringify!(difference_of_pic_nums_minus1)
11439 )
11440 );
11441 assert_eq!(
11442 unsafe { ::core::ptr::addr_of!((*ptr).long_term_pic_num) as usize - ptr as usize },
11443 6usize,
11444 concat!(
11445 "Offset of field: ",
11446 stringify!(StdVideoEncodeH264RefPicMarkingEntry),
11447 "::",
11448 stringify!(long_term_pic_num)
11449 )
11450 );
11451 assert_eq!(
11452 unsafe { ::core::ptr::addr_of!((*ptr).long_term_frame_idx) as usize - ptr as usize },
11453 8usize,
11454 concat!(
11455 "Offset of field: ",
11456 stringify!(StdVideoEncodeH264RefPicMarkingEntry),
11457 "::",
11458 stringify!(long_term_frame_idx)
11459 )
11460 );
11461 assert_eq!(
11462 unsafe {
11463 ::core::ptr::addr_of!((*ptr).max_long_term_frame_idx_plus1) as usize - ptr as usize
11464 },
11465 10usize,
11466 concat!(
11467 "Offset of field: ",
11468 stringify!(StdVideoEncodeH264RefPicMarkingEntry),
11469 "::",
11470 stringify!(max_long_term_frame_idx_plus1)
11471 )
11472 );
11473}
11474#[repr(C)]
11475#[derive(Debug, Copy, Clone)]
11476pub struct StdVideoEncodeH264ReferenceListsInfo {
11477 pub flags: StdVideoEncodeH264ReferenceListsInfoFlags,
11478 pub num_ref_idx_l0_active_minus1: u8,
11479 pub num_ref_idx_l1_active_minus1: u8,
11480 pub RefPicList0: [u8; 32usize],
11481 pub RefPicList1: [u8; 32usize],
11482 pub refList0ModOpCount: u8,
11483 pub refList1ModOpCount: u8,
11484 pub refPicMarkingOpCount: u8,
11485 pub reserved1: [u8; 7usize],
11486 pub pRefList0ModOperations: *const StdVideoEncodeH264RefListModEntry,
11487 pub pRefList1ModOperations: *const StdVideoEncodeH264RefListModEntry,
11488 pub pRefPicMarkingOperations: *const StdVideoEncodeH264RefPicMarkingEntry,
11489}
11490#[test]
11491fn bindgen_test_layout_StdVideoEncodeH264ReferenceListsInfo() {
11492 const UNINIT: ::core::mem::MaybeUninit<StdVideoEncodeH264ReferenceListsInfo> =
11493 ::core::mem::MaybeUninit::uninit();
11494 let ptr = UNINIT.as_ptr();
11495 assert_eq!(
11496 ::core::mem::size_of::<StdVideoEncodeH264ReferenceListsInfo>(),
11497 104usize,
11498 concat!(
11499 "Size of: ",
11500 stringify!(StdVideoEncodeH264ReferenceListsInfo)
11501 )
11502 );
11503 assert_eq!(
11504 ::core::mem::align_of::<StdVideoEncodeH264ReferenceListsInfo>(),
11505 8usize,
11506 concat!(
11507 "Alignment of ",
11508 stringify!(StdVideoEncodeH264ReferenceListsInfo)
11509 )
11510 );
11511 assert_eq!(
11512 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
11513 0usize,
11514 concat!(
11515 "Offset of field: ",
11516 stringify!(StdVideoEncodeH264ReferenceListsInfo),
11517 "::",
11518 stringify!(flags)
11519 )
11520 );
11521 assert_eq!(
11522 unsafe {
11523 ::core::ptr::addr_of!((*ptr).num_ref_idx_l0_active_minus1) as usize - ptr as usize
11524 },
11525 4usize,
11526 concat!(
11527 "Offset of field: ",
11528 stringify!(StdVideoEncodeH264ReferenceListsInfo),
11529 "::",
11530 stringify!(num_ref_idx_l0_active_minus1)
11531 )
11532 );
11533 assert_eq!(
11534 unsafe {
11535 ::core::ptr::addr_of!((*ptr).num_ref_idx_l1_active_minus1) as usize - ptr as usize
11536 },
11537 5usize,
11538 concat!(
11539 "Offset of field: ",
11540 stringify!(StdVideoEncodeH264ReferenceListsInfo),
11541 "::",
11542 stringify!(num_ref_idx_l1_active_minus1)
11543 )
11544 );
11545 assert_eq!(
11546 unsafe { ::core::ptr::addr_of!((*ptr).RefPicList0) as usize - ptr as usize },
11547 6usize,
11548 concat!(
11549 "Offset of field: ",
11550 stringify!(StdVideoEncodeH264ReferenceListsInfo),
11551 "::",
11552 stringify!(RefPicList0)
11553 )
11554 );
11555 assert_eq!(
11556 unsafe { ::core::ptr::addr_of!((*ptr).RefPicList1) as usize - ptr as usize },
11557 38usize,
11558 concat!(
11559 "Offset of field: ",
11560 stringify!(StdVideoEncodeH264ReferenceListsInfo),
11561 "::",
11562 stringify!(RefPicList1)
11563 )
11564 );
11565 assert_eq!(
11566 unsafe { ::core::ptr::addr_of!((*ptr).refList0ModOpCount) as usize - ptr as usize },
11567 70usize,
11568 concat!(
11569 "Offset of field: ",
11570 stringify!(StdVideoEncodeH264ReferenceListsInfo),
11571 "::",
11572 stringify!(refList0ModOpCount)
11573 )
11574 );
11575 assert_eq!(
11576 unsafe { ::core::ptr::addr_of!((*ptr).refList1ModOpCount) as usize - ptr as usize },
11577 71usize,
11578 concat!(
11579 "Offset of field: ",
11580 stringify!(StdVideoEncodeH264ReferenceListsInfo),
11581 "::",
11582 stringify!(refList1ModOpCount)
11583 )
11584 );
11585 assert_eq!(
11586 unsafe { ::core::ptr::addr_of!((*ptr).refPicMarkingOpCount) as usize - ptr as usize },
11587 72usize,
11588 concat!(
11589 "Offset of field: ",
11590 stringify!(StdVideoEncodeH264ReferenceListsInfo),
11591 "::",
11592 stringify!(refPicMarkingOpCount)
11593 )
11594 );
11595 assert_eq!(
11596 unsafe { ::core::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize },
11597 73usize,
11598 concat!(
11599 "Offset of field: ",
11600 stringify!(StdVideoEncodeH264ReferenceListsInfo),
11601 "::",
11602 stringify!(reserved1)
11603 )
11604 );
11605 assert_eq!(
11606 unsafe { ::core::ptr::addr_of!((*ptr).pRefList0ModOperations) as usize - ptr as usize },
11607 80usize,
11608 concat!(
11609 "Offset of field: ",
11610 stringify!(StdVideoEncodeH264ReferenceListsInfo),
11611 "::",
11612 stringify!(pRefList0ModOperations)
11613 )
11614 );
11615 assert_eq!(
11616 unsafe { ::core::ptr::addr_of!((*ptr).pRefList1ModOperations) as usize - ptr as usize },
11617 88usize,
11618 concat!(
11619 "Offset of field: ",
11620 stringify!(StdVideoEncodeH264ReferenceListsInfo),
11621 "::",
11622 stringify!(pRefList1ModOperations)
11623 )
11624 );
11625 assert_eq!(
11626 unsafe { ::core::ptr::addr_of!((*ptr).pRefPicMarkingOperations) as usize - ptr as usize },
11627 96usize,
11628 concat!(
11629 "Offset of field: ",
11630 stringify!(StdVideoEncodeH264ReferenceListsInfo),
11631 "::",
11632 stringify!(pRefPicMarkingOperations)
11633 )
11634 );
11635}
11636#[repr(C)]
11637#[derive(Debug, Copy, Clone)]
11638pub struct StdVideoEncodeH264PictureInfo {
11639 pub flags: StdVideoEncodeH264PictureInfoFlags,
11640 pub seq_parameter_set_id: u8,
11641 pub pic_parameter_set_id: u8,
11642 pub idr_pic_id: u16,
11643 pub primary_pic_type: StdVideoH264PictureType,
11644 pub frame_num: u32,
11645 pub PicOrderCnt: i32,
11646 pub temporal_id: u8,
11647 pub reserved1: [u8; 3usize],
11648 pub pRefLists: *const StdVideoEncodeH264ReferenceListsInfo,
11649}
11650#[test]
11651fn bindgen_test_layout_StdVideoEncodeH264PictureInfo() {
11652 const UNINIT: ::core::mem::MaybeUninit<StdVideoEncodeH264PictureInfo> =
11653 ::core::mem::MaybeUninit::uninit();
11654 let ptr = UNINIT.as_ptr();
11655 assert_eq!(
11656 ::core::mem::size_of::<StdVideoEncodeH264PictureInfo>(),
11657 32usize,
11658 concat!("Size of: ", stringify!(StdVideoEncodeH264PictureInfo))
11659 );
11660 assert_eq!(
11661 ::core::mem::align_of::<StdVideoEncodeH264PictureInfo>(),
11662 8usize,
11663 concat!("Alignment of ", stringify!(StdVideoEncodeH264PictureInfo))
11664 );
11665 assert_eq!(
11666 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
11667 0usize,
11668 concat!(
11669 "Offset of field: ",
11670 stringify!(StdVideoEncodeH264PictureInfo),
11671 "::",
11672 stringify!(flags)
11673 )
11674 );
11675 assert_eq!(
11676 unsafe { ::core::ptr::addr_of!((*ptr).seq_parameter_set_id) as usize - ptr as usize },
11677 4usize,
11678 concat!(
11679 "Offset of field: ",
11680 stringify!(StdVideoEncodeH264PictureInfo),
11681 "::",
11682 stringify!(seq_parameter_set_id)
11683 )
11684 );
11685 assert_eq!(
11686 unsafe { ::core::ptr::addr_of!((*ptr).pic_parameter_set_id) as usize - ptr as usize },
11687 5usize,
11688 concat!(
11689 "Offset of field: ",
11690 stringify!(StdVideoEncodeH264PictureInfo),
11691 "::",
11692 stringify!(pic_parameter_set_id)
11693 )
11694 );
11695 assert_eq!(
11696 unsafe { ::core::ptr::addr_of!((*ptr).idr_pic_id) as usize - ptr as usize },
11697 6usize,
11698 concat!(
11699 "Offset of field: ",
11700 stringify!(StdVideoEncodeH264PictureInfo),
11701 "::",
11702 stringify!(idr_pic_id)
11703 )
11704 );
11705 assert_eq!(
11706 unsafe { ::core::ptr::addr_of!((*ptr).primary_pic_type) as usize - ptr as usize },
11707 8usize,
11708 concat!(
11709 "Offset of field: ",
11710 stringify!(StdVideoEncodeH264PictureInfo),
11711 "::",
11712 stringify!(primary_pic_type)
11713 )
11714 );
11715 assert_eq!(
11716 unsafe { ::core::ptr::addr_of!((*ptr).frame_num) as usize - ptr as usize },
11717 12usize,
11718 concat!(
11719 "Offset of field: ",
11720 stringify!(StdVideoEncodeH264PictureInfo),
11721 "::",
11722 stringify!(frame_num)
11723 )
11724 );
11725 assert_eq!(
11726 unsafe { ::core::ptr::addr_of!((*ptr).PicOrderCnt) as usize - ptr as usize },
11727 16usize,
11728 concat!(
11729 "Offset of field: ",
11730 stringify!(StdVideoEncodeH264PictureInfo),
11731 "::",
11732 stringify!(PicOrderCnt)
11733 )
11734 );
11735 assert_eq!(
11736 unsafe { ::core::ptr::addr_of!((*ptr).temporal_id) as usize - ptr as usize },
11737 20usize,
11738 concat!(
11739 "Offset of field: ",
11740 stringify!(StdVideoEncodeH264PictureInfo),
11741 "::",
11742 stringify!(temporal_id)
11743 )
11744 );
11745 assert_eq!(
11746 unsafe { ::core::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize },
11747 21usize,
11748 concat!(
11749 "Offset of field: ",
11750 stringify!(StdVideoEncodeH264PictureInfo),
11751 "::",
11752 stringify!(reserved1)
11753 )
11754 );
11755 assert_eq!(
11756 unsafe { ::core::ptr::addr_of!((*ptr).pRefLists) as usize - ptr as usize },
11757 24usize,
11758 concat!(
11759 "Offset of field: ",
11760 stringify!(StdVideoEncodeH264PictureInfo),
11761 "::",
11762 stringify!(pRefLists)
11763 )
11764 );
11765}
11766#[repr(C)]
11767#[derive(Debug, Copy, Clone)]
11768pub struct StdVideoEncodeH264ReferenceInfo {
11769 pub flags: StdVideoEncodeH264ReferenceInfoFlags,
11770 pub primary_pic_type: StdVideoH264PictureType,
11771 pub FrameNum: u32,
11772 pub PicOrderCnt: i32,
11773 pub long_term_pic_num: u16,
11774 pub long_term_frame_idx: u16,
11775 pub temporal_id: u8,
11776}
11777#[test]
11778fn bindgen_test_layout_StdVideoEncodeH264ReferenceInfo() {
11779 const UNINIT: ::core::mem::MaybeUninit<StdVideoEncodeH264ReferenceInfo> =
11780 ::core::mem::MaybeUninit::uninit();
11781 let ptr = UNINIT.as_ptr();
11782 assert_eq!(
11783 ::core::mem::size_of::<StdVideoEncodeH264ReferenceInfo>(),
11784 24usize,
11785 concat!("Size of: ", stringify!(StdVideoEncodeH264ReferenceInfo))
11786 );
11787 assert_eq!(
11788 ::core::mem::align_of::<StdVideoEncodeH264ReferenceInfo>(),
11789 4usize,
11790 concat!("Alignment of ", stringify!(StdVideoEncodeH264ReferenceInfo))
11791 );
11792 assert_eq!(
11793 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
11794 0usize,
11795 concat!(
11796 "Offset of field: ",
11797 stringify!(StdVideoEncodeH264ReferenceInfo),
11798 "::",
11799 stringify!(flags)
11800 )
11801 );
11802 assert_eq!(
11803 unsafe { ::core::ptr::addr_of!((*ptr).primary_pic_type) as usize - ptr as usize },
11804 4usize,
11805 concat!(
11806 "Offset of field: ",
11807 stringify!(StdVideoEncodeH264ReferenceInfo),
11808 "::",
11809 stringify!(primary_pic_type)
11810 )
11811 );
11812 assert_eq!(
11813 unsafe { ::core::ptr::addr_of!((*ptr).FrameNum) as usize - ptr as usize },
11814 8usize,
11815 concat!(
11816 "Offset of field: ",
11817 stringify!(StdVideoEncodeH264ReferenceInfo),
11818 "::",
11819 stringify!(FrameNum)
11820 )
11821 );
11822 assert_eq!(
11823 unsafe { ::core::ptr::addr_of!((*ptr).PicOrderCnt) as usize - ptr as usize },
11824 12usize,
11825 concat!(
11826 "Offset of field: ",
11827 stringify!(StdVideoEncodeH264ReferenceInfo),
11828 "::",
11829 stringify!(PicOrderCnt)
11830 )
11831 );
11832 assert_eq!(
11833 unsafe { ::core::ptr::addr_of!((*ptr).long_term_pic_num) as usize - ptr as usize },
11834 16usize,
11835 concat!(
11836 "Offset of field: ",
11837 stringify!(StdVideoEncodeH264ReferenceInfo),
11838 "::",
11839 stringify!(long_term_pic_num)
11840 )
11841 );
11842 assert_eq!(
11843 unsafe { ::core::ptr::addr_of!((*ptr).long_term_frame_idx) as usize - ptr as usize },
11844 18usize,
11845 concat!(
11846 "Offset of field: ",
11847 stringify!(StdVideoEncodeH264ReferenceInfo),
11848 "::",
11849 stringify!(long_term_frame_idx)
11850 )
11851 );
11852 assert_eq!(
11853 unsafe { ::core::ptr::addr_of!((*ptr).temporal_id) as usize - ptr as usize },
11854 20usize,
11855 concat!(
11856 "Offset of field: ",
11857 stringify!(StdVideoEncodeH264ReferenceInfo),
11858 "::",
11859 stringify!(temporal_id)
11860 )
11861 );
11862}
11863#[repr(C)]
11864#[derive(Debug, Copy, Clone)]
11865pub struct StdVideoEncodeH264SliceHeader {
11866 pub flags: StdVideoEncodeH264SliceHeaderFlags,
11867 pub first_mb_in_slice: u32,
11868 pub slice_type: StdVideoH264SliceType,
11869 pub slice_alpha_c0_offset_div2: i8,
11870 pub slice_beta_offset_div2: i8,
11871 pub slice_qp_delta: i8,
11872 pub reserved1: u8,
11873 pub cabac_init_idc: StdVideoH264CabacInitIdc,
11874 pub disable_deblocking_filter_idc: StdVideoH264DisableDeblockingFilterIdc,
11875 pub pWeightTable: *const StdVideoEncodeH264WeightTable,
11876}
11877#[test]
11878fn bindgen_test_layout_StdVideoEncodeH264SliceHeader() {
11879 const UNINIT: ::core::mem::MaybeUninit<StdVideoEncodeH264SliceHeader> =
11880 ::core::mem::MaybeUninit::uninit();
11881 let ptr = UNINIT.as_ptr();
11882 assert_eq!(
11883 ::core::mem::size_of::<StdVideoEncodeH264SliceHeader>(),
11884 32usize,
11885 concat!("Size of: ", stringify!(StdVideoEncodeH264SliceHeader))
11886 );
11887 assert_eq!(
11888 ::core::mem::align_of::<StdVideoEncodeH264SliceHeader>(),
11889 8usize,
11890 concat!("Alignment of ", stringify!(StdVideoEncodeH264SliceHeader))
11891 );
11892 assert_eq!(
11893 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
11894 0usize,
11895 concat!(
11896 "Offset of field: ",
11897 stringify!(StdVideoEncodeH264SliceHeader),
11898 "::",
11899 stringify!(flags)
11900 )
11901 );
11902 assert_eq!(
11903 unsafe { ::core::ptr::addr_of!((*ptr).first_mb_in_slice) as usize - ptr as usize },
11904 4usize,
11905 concat!(
11906 "Offset of field: ",
11907 stringify!(StdVideoEncodeH264SliceHeader),
11908 "::",
11909 stringify!(first_mb_in_slice)
11910 )
11911 );
11912 assert_eq!(
11913 unsafe { ::core::ptr::addr_of!((*ptr).slice_type) as usize - ptr as usize },
11914 8usize,
11915 concat!(
11916 "Offset of field: ",
11917 stringify!(StdVideoEncodeH264SliceHeader),
11918 "::",
11919 stringify!(slice_type)
11920 )
11921 );
11922 assert_eq!(
11923 unsafe { ::core::ptr::addr_of!((*ptr).slice_alpha_c0_offset_div2) as usize - ptr as usize },
11924 12usize,
11925 concat!(
11926 "Offset of field: ",
11927 stringify!(StdVideoEncodeH264SliceHeader),
11928 "::",
11929 stringify!(slice_alpha_c0_offset_div2)
11930 )
11931 );
11932 assert_eq!(
11933 unsafe { ::core::ptr::addr_of!((*ptr).slice_beta_offset_div2) as usize - ptr as usize },
11934 13usize,
11935 concat!(
11936 "Offset of field: ",
11937 stringify!(StdVideoEncodeH264SliceHeader),
11938 "::",
11939 stringify!(slice_beta_offset_div2)
11940 )
11941 );
11942 assert_eq!(
11943 unsafe { ::core::ptr::addr_of!((*ptr).slice_qp_delta) as usize - ptr as usize },
11944 14usize,
11945 concat!(
11946 "Offset of field: ",
11947 stringify!(StdVideoEncodeH264SliceHeader),
11948 "::",
11949 stringify!(slice_qp_delta)
11950 )
11951 );
11952 assert_eq!(
11953 unsafe { ::core::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize },
11954 15usize,
11955 concat!(
11956 "Offset of field: ",
11957 stringify!(StdVideoEncodeH264SliceHeader),
11958 "::",
11959 stringify!(reserved1)
11960 )
11961 );
11962 assert_eq!(
11963 unsafe { ::core::ptr::addr_of!((*ptr).cabac_init_idc) as usize - ptr as usize },
11964 16usize,
11965 concat!(
11966 "Offset of field: ",
11967 stringify!(StdVideoEncodeH264SliceHeader),
11968 "::",
11969 stringify!(cabac_init_idc)
11970 )
11971 );
11972 assert_eq!(
11973 unsafe {
11974 ::core::ptr::addr_of!((*ptr).disable_deblocking_filter_idc) as usize - ptr as usize
11975 },
11976 20usize,
11977 concat!(
11978 "Offset of field: ",
11979 stringify!(StdVideoEncodeH264SliceHeader),
11980 "::",
11981 stringify!(disable_deblocking_filter_idc)
11982 )
11983 );
11984 assert_eq!(
11985 unsafe { ::core::ptr::addr_of!((*ptr).pWeightTable) as usize - ptr as usize },
11986 24usize,
11987 concat!(
11988 "Offset of field: ",
11989 stringify!(StdVideoEncodeH264SliceHeader),
11990 "::",
11991 stringify!(pWeightTable)
11992 )
11993 );
11994}
11995#[repr(C)]
11996#[derive(Debug, Copy, Clone)]
11997pub struct StdVideoEncodeH265WeightTableFlags {
11998 pub luma_weight_l0_flag: u16,
11999 pub chroma_weight_l0_flag: u16,
12000 pub luma_weight_l1_flag: u16,
12001 pub chroma_weight_l1_flag: u16,
12002}
12003#[test]
12004fn bindgen_test_layout_StdVideoEncodeH265WeightTableFlags() {
12005 const UNINIT: ::core::mem::MaybeUninit<StdVideoEncodeH265WeightTableFlags> =
12006 ::core::mem::MaybeUninit::uninit();
12007 let ptr = UNINIT.as_ptr();
12008 assert_eq!(
12009 ::core::mem::size_of::<StdVideoEncodeH265WeightTableFlags>(),
12010 8usize,
12011 concat!("Size of: ", stringify!(StdVideoEncodeH265WeightTableFlags))
12012 );
12013 assert_eq!(
12014 ::core::mem::align_of::<StdVideoEncodeH265WeightTableFlags>(),
12015 2usize,
12016 concat!(
12017 "Alignment of ",
12018 stringify!(StdVideoEncodeH265WeightTableFlags)
12019 )
12020 );
12021 assert_eq!(
12022 unsafe { ::core::ptr::addr_of!((*ptr).luma_weight_l0_flag) as usize - ptr as usize },
12023 0usize,
12024 concat!(
12025 "Offset of field: ",
12026 stringify!(StdVideoEncodeH265WeightTableFlags),
12027 "::",
12028 stringify!(luma_weight_l0_flag)
12029 )
12030 );
12031 assert_eq!(
12032 unsafe { ::core::ptr::addr_of!((*ptr).chroma_weight_l0_flag) as usize - ptr as usize },
12033 2usize,
12034 concat!(
12035 "Offset of field: ",
12036 stringify!(StdVideoEncodeH265WeightTableFlags),
12037 "::",
12038 stringify!(chroma_weight_l0_flag)
12039 )
12040 );
12041 assert_eq!(
12042 unsafe { ::core::ptr::addr_of!((*ptr).luma_weight_l1_flag) as usize - ptr as usize },
12043 4usize,
12044 concat!(
12045 "Offset of field: ",
12046 stringify!(StdVideoEncodeH265WeightTableFlags),
12047 "::",
12048 stringify!(luma_weight_l1_flag)
12049 )
12050 );
12051 assert_eq!(
12052 unsafe { ::core::ptr::addr_of!((*ptr).chroma_weight_l1_flag) as usize - ptr as usize },
12053 6usize,
12054 concat!(
12055 "Offset of field: ",
12056 stringify!(StdVideoEncodeH265WeightTableFlags),
12057 "::",
12058 stringify!(chroma_weight_l1_flag)
12059 )
12060 );
12061}
12062#[repr(C)]
12063#[derive(Debug, Copy, Clone)]
12064pub struct StdVideoEncodeH265WeightTable {
12065 pub flags: StdVideoEncodeH265WeightTableFlags,
12066 pub luma_log2_weight_denom: u8,
12067 pub delta_chroma_log2_weight_denom: i8,
12068 pub delta_luma_weight_l0: [i8; 15usize],
12069 pub luma_offset_l0: [i8; 15usize],
12070 pub delta_chroma_weight_l0: [[i8; 2usize]; 15usize],
12071 pub delta_chroma_offset_l0: [[i8; 2usize]; 15usize],
12072 pub delta_luma_weight_l1: [i8; 15usize],
12073 pub luma_offset_l1: [i8; 15usize],
12074 pub delta_chroma_weight_l1: [[i8; 2usize]; 15usize],
12075 pub delta_chroma_offset_l1: [[i8; 2usize]; 15usize],
12076}
12077#[test]
12078fn bindgen_test_layout_StdVideoEncodeH265WeightTable() {
12079 const UNINIT: ::core::mem::MaybeUninit<StdVideoEncodeH265WeightTable> =
12080 ::core::mem::MaybeUninit::uninit();
12081 let ptr = UNINIT.as_ptr();
12082 assert_eq!(
12083 ::core::mem::size_of::<StdVideoEncodeH265WeightTable>(),
12084 190usize,
12085 concat!("Size of: ", stringify!(StdVideoEncodeH265WeightTable))
12086 );
12087 assert_eq!(
12088 ::core::mem::align_of::<StdVideoEncodeH265WeightTable>(),
12089 2usize,
12090 concat!("Alignment of ", stringify!(StdVideoEncodeH265WeightTable))
12091 );
12092 assert_eq!(
12093 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
12094 0usize,
12095 concat!(
12096 "Offset of field: ",
12097 stringify!(StdVideoEncodeH265WeightTable),
12098 "::",
12099 stringify!(flags)
12100 )
12101 );
12102 assert_eq!(
12103 unsafe { ::core::ptr::addr_of!((*ptr).luma_log2_weight_denom) as usize - ptr as usize },
12104 8usize,
12105 concat!(
12106 "Offset of field: ",
12107 stringify!(StdVideoEncodeH265WeightTable),
12108 "::",
12109 stringify!(luma_log2_weight_denom)
12110 )
12111 );
12112 assert_eq!(
12113 unsafe {
12114 ::core::ptr::addr_of!((*ptr).delta_chroma_log2_weight_denom) as usize - ptr as usize
12115 },
12116 9usize,
12117 concat!(
12118 "Offset of field: ",
12119 stringify!(StdVideoEncodeH265WeightTable),
12120 "::",
12121 stringify!(delta_chroma_log2_weight_denom)
12122 )
12123 );
12124 assert_eq!(
12125 unsafe { ::core::ptr::addr_of!((*ptr).delta_luma_weight_l0) as usize - ptr as usize },
12126 10usize,
12127 concat!(
12128 "Offset of field: ",
12129 stringify!(StdVideoEncodeH265WeightTable),
12130 "::",
12131 stringify!(delta_luma_weight_l0)
12132 )
12133 );
12134 assert_eq!(
12135 unsafe { ::core::ptr::addr_of!((*ptr).luma_offset_l0) as usize - ptr as usize },
12136 25usize,
12137 concat!(
12138 "Offset of field: ",
12139 stringify!(StdVideoEncodeH265WeightTable),
12140 "::",
12141 stringify!(luma_offset_l0)
12142 )
12143 );
12144 assert_eq!(
12145 unsafe { ::core::ptr::addr_of!((*ptr).delta_chroma_weight_l0) as usize - ptr as usize },
12146 40usize,
12147 concat!(
12148 "Offset of field: ",
12149 stringify!(StdVideoEncodeH265WeightTable),
12150 "::",
12151 stringify!(delta_chroma_weight_l0)
12152 )
12153 );
12154 assert_eq!(
12155 unsafe { ::core::ptr::addr_of!((*ptr).delta_chroma_offset_l0) as usize - ptr as usize },
12156 70usize,
12157 concat!(
12158 "Offset of field: ",
12159 stringify!(StdVideoEncodeH265WeightTable),
12160 "::",
12161 stringify!(delta_chroma_offset_l0)
12162 )
12163 );
12164 assert_eq!(
12165 unsafe { ::core::ptr::addr_of!((*ptr).delta_luma_weight_l1) as usize - ptr as usize },
12166 100usize,
12167 concat!(
12168 "Offset of field: ",
12169 stringify!(StdVideoEncodeH265WeightTable),
12170 "::",
12171 stringify!(delta_luma_weight_l1)
12172 )
12173 );
12174 assert_eq!(
12175 unsafe { ::core::ptr::addr_of!((*ptr).luma_offset_l1) as usize - ptr as usize },
12176 115usize,
12177 concat!(
12178 "Offset of field: ",
12179 stringify!(StdVideoEncodeH265WeightTable),
12180 "::",
12181 stringify!(luma_offset_l1)
12182 )
12183 );
12184 assert_eq!(
12185 unsafe { ::core::ptr::addr_of!((*ptr).delta_chroma_weight_l1) as usize - ptr as usize },
12186 130usize,
12187 concat!(
12188 "Offset of field: ",
12189 stringify!(StdVideoEncodeH265WeightTable),
12190 "::",
12191 stringify!(delta_chroma_weight_l1)
12192 )
12193 );
12194 assert_eq!(
12195 unsafe { ::core::ptr::addr_of!((*ptr).delta_chroma_offset_l1) as usize - ptr as usize },
12196 160usize,
12197 concat!(
12198 "Offset of field: ",
12199 stringify!(StdVideoEncodeH265WeightTable),
12200 "::",
12201 stringify!(delta_chroma_offset_l1)
12202 )
12203 );
12204}
12205#[repr(C)]
12206#[derive(Debug, Copy, Clone)]
12207pub struct StdVideoEncodeH265SliceSegmentHeaderFlags {
12208 pub _bitfield_align_1: [u32; 0],
12209 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
12210}
12211#[test]
12212fn bindgen_test_layout_StdVideoEncodeH265SliceSegmentHeaderFlags() {
12213 assert_eq!(
12214 ::core::mem::size_of::<StdVideoEncodeH265SliceSegmentHeaderFlags>(),
12215 4usize,
12216 concat!(
12217 "Size of: ",
12218 stringify!(StdVideoEncodeH265SliceSegmentHeaderFlags)
12219 )
12220 );
12221 assert_eq!(
12222 ::core::mem::align_of::<StdVideoEncodeH265SliceSegmentHeaderFlags>(),
12223 4usize,
12224 concat!(
12225 "Alignment of ",
12226 stringify!(StdVideoEncodeH265SliceSegmentHeaderFlags)
12227 )
12228 );
12229}
12230impl StdVideoEncodeH265SliceSegmentHeaderFlags {
12231 #[inline]
12232 pub fn first_slice_segment_in_pic_flag(&self) -> u32 {
12233 unsafe { ::core::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
12234 }
12235 #[inline]
12236 pub fn set_first_slice_segment_in_pic_flag(&mut self, val: u32) {
12237 unsafe {
12238 let val: u32 = ::core::mem::transmute(val);
12239 self._bitfield_1.set(0usize, 1u8, val as u64)
12240 }
12241 }
12242 #[inline]
12243 pub fn dependent_slice_segment_flag(&self) -> u32 {
12244 unsafe { ::core::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
12245 }
12246 #[inline]
12247 pub fn set_dependent_slice_segment_flag(&mut self, val: u32) {
12248 unsafe {
12249 let val: u32 = ::core::mem::transmute(val);
12250 self._bitfield_1.set(1usize, 1u8, val as u64)
12251 }
12252 }
12253 #[inline]
12254 pub fn slice_sao_luma_flag(&self) -> u32 {
12255 unsafe { ::core::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
12256 }
12257 #[inline]
12258 pub fn set_slice_sao_luma_flag(&mut self, val: u32) {
12259 unsafe {
12260 let val: u32 = ::core::mem::transmute(val);
12261 self._bitfield_1.set(2usize, 1u8, val as u64)
12262 }
12263 }
12264 #[inline]
12265 pub fn slice_sao_chroma_flag(&self) -> u32 {
12266 unsafe { ::core::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
12267 }
12268 #[inline]
12269 pub fn set_slice_sao_chroma_flag(&mut self, val: u32) {
12270 unsafe {
12271 let val: u32 = ::core::mem::transmute(val);
12272 self._bitfield_1.set(3usize, 1u8, val as u64)
12273 }
12274 }
12275 #[inline]
12276 pub fn num_ref_idx_active_override_flag(&self) -> u32 {
12277 unsafe { ::core::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
12278 }
12279 #[inline]
12280 pub fn set_num_ref_idx_active_override_flag(&mut self, val: u32) {
12281 unsafe {
12282 let val: u32 = ::core::mem::transmute(val);
12283 self._bitfield_1.set(4usize, 1u8, val as u64)
12284 }
12285 }
12286 #[inline]
12287 pub fn mvd_l1_zero_flag(&self) -> u32 {
12288 unsafe { ::core::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
12289 }
12290 #[inline]
12291 pub fn set_mvd_l1_zero_flag(&mut self, val: u32) {
12292 unsafe {
12293 let val: u32 = ::core::mem::transmute(val);
12294 self._bitfield_1.set(5usize, 1u8, val as u64)
12295 }
12296 }
12297 #[inline]
12298 pub fn cabac_init_flag(&self) -> u32 {
12299 unsafe { ::core::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) }
12300 }
12301 #[inline]
12302 pub fn set_cabac_init_flag(&mut self, val: u32) {
12303 unsafe {
12304 let val: u32 = ::core::mem::transmute(val);
12305 self._bitfield_1.set(6usize, 1u8, val as u64)
12306 }
12307 }
12308 #[inline]
12309 pub fn cu_chroma_qp_offset_enabled_flag(&self) -> u32 {
12310 unsafe { ::core::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) }
12311 }
12312 #[inline]
12313 pub fn set_cu_chroma_qp_offset_enabled_flag(&mut self, val: u32) {
12314 unsafe {
12315 let val: u32 = ::core::mem::transmute(val);
12316 self._bitfield_1.set(7usize, 1u8, val as u64)
12317 }
12318 }
12319 #[inline]
12320 pub fn deblocking_filter_override_flag(&self) -> u32 {
12321 unsafe { ::core::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) }
12322 }
12323 #[inline]
12324 pub fn set_deblocking_filter_override_flag(&mut self, val: u32) {
12325 unsafe {
12326 let val: u32 = ::core::mem::transmute(val);
12327 self._bitfield_1.set(8usize, 1u8, val as u64)
12328 }
12329 }
12330 #[inline]
12331 pub fn slice_deblocking_filter_disabled_flag(&self) -> u32 {
12332 unsafe { ::core::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) }
12333 }
12334 #[inline]
12335 pub fn set_slice_deblocking_filter_disabled_flag(&mut self, val: u32) {
12336 unsafe {
12337 let val: u32 = ::core::mem::transmute(val);
12338 self._bitfield_1.set(9usize, 1u8, val as u64)
12339 }
12340 }
12341 #[inline]
12342 pub fn collocated_from_l0_flag(&self) -> u32 {
12343 unsafe { ::core::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) }
12344 }
12345 #[inline]
12346 pub fn set_collocated_from_l0_flag(&mut self, val: u32) {
12347 unsafe {
12348 let val: u32 = ::core::mem::transmute(val);
12349 self._bitfield_1.set(10usize, 1u8, val as u64)
12350 }
12351 }
12352 #[inline]
12353 pub fn slice_loop_filter_across_slices_enabled_flag(&self) -> u32 {
12354 unsafe { ::core::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) }
12355 }
12356 #[inline]
12357 pub fn set_slice_loop_filter_across_slices_enabled_flag(&mut self, val: u32) {
12358 unsafe {
12359 let val: u32 = ::core::mem::transmute(val);
12360 self._bitfield_1.set(11usize, 1u8, val as u64)
12361 }
12362 }
12363 #[inline]
12364 pub fn reserved(&self) -> u32 {
12365 unsafe { ::core::mem::transmute(self._bitfield_1.get(12usize, 20u8) as u32) }
12366 }
12367 #[inline]
12368 pub fn set_reserved(&mut self, val: u32) {
12369 unsafe {
12370 let val: u32 = ::core::mem::transmute(val);
12371 self._bitfield_1.set(12usize, 20u8, val as u64)
12372 }
12373 }
12374 #[inline]
12375 pub fn new_bitfield_1(
12376 first_slice_segment_in_pic_flag: u32,
12377 dependent_slice_segment_flag: u32,
12378 slice_sao_luma_flag: u32,
12379 slice_sao_chroma_flag: u32,
12380 num_ref_idx_active_override_flag: u32,
12381 mvd_l1_zero_flag: u32,
12382 cabac_init_flag: u32,
12383 cu_chroma_qp_offset_enabled_flag: u32,
12384 deblocking_filter_override_flag: u32,
12385 slice_deblocking_filter_disabled_flag: u32,
12386 collocated_from_l0_flag: u32,
12387 slice_loop_filter_across_slices_enabled_flag: u32,
12388 reserved: u32,
12389 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
12390 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
12391 __bindgen_bitfield_unit.set(0usize, 1u8, {
12392 let first_slice_segment_in_pic_flag: u32 =
12393 unsafe { ::core::mem::transmute(first_slice_segment_in_pic_flag) };
12394 first_slice_segment_in_pic_flag as u64
12395 });
12396 __bindgen_bitfield_unit.set(1usize, 1u8, {
12397 let dependent_slice_segment_flag: u32 =
12398 unsafe { ::core::mem::transmute(dependent_slice_segment_flag) };
12399 dependent_slice_segment_flag as u64
12400 });
12401 __bindgen_bitfield_unit.set(2usize, 1u8, {
12402 let slice_sao_luma_flag: u32 = unsafe { ::core::mem::transmute(slice_sao_luma_flag) };
12403 slice_sao_luma_flag as u64
12404 });
12405 __bindgen_bitfield_unit.set(3usize, 1u8, {
12406 let slice_sao_chroma_flag: u32 =
12407 unsafe { ::core::mem::transmute(slice_sao_chroma_flag) };
12408 slice_sao_chroma_flag as u64
12409 });
12410 __bindgen_bitfield_unit.set(4usize, 1u8, {
12411 let num_ref_idx_active_override_flag: u32 =
12412 unsafe { ::core::mem::transmute(num_ref_idx_active_override_flag) };
12413 num_ref_idx_active_override_flag as u64
12414 });
12415 __bindgen_bitfield_unit.set(5usize, 1u8, {
12416 let mvd_l1_zero_flag: u32 = unsafe { ::core::mem::transmute(mvd_l1_zero_flag) };
12417 mvd_l1_zero_flag as u64
12418 });
12419 __bindgen_bitfield_unit.set(6usize, 1u8, {
12420 let cabac_init_flag: u32 = unsafe { ::core::mem::transmute(cabac_init_flag) };
12421 cabac_init_flag as u64
12422 });
12423 __bindgen_bitfield_unit.set(7usize, 1u8, {
12424 let cu_chroma_qp_offset_enabled_flag: u32 =
12425 unsafe { ::core::mem::transmute(cu_chroma_qp_offset_enabled_flag) };
12426 cu_chroma_qp_offset_enabled_flag as u64
12427 });
12428 __bindgen_bitfield_unit.set(8usize, 1u8, {
12429 let deblocking_filter_override_flag: u32 =
12430 unsafe { ::core::mem::transmute(deblocking_filter_override_flag) };
12431 deblocking_filter_override_flag as u64
12432 });
12433 __bindgen_bitfield_unit.set(9usize, 1u8, {
12434 let slice_deblocking_filter_disabled_flag: u32 =
12435 unsafe { ::core::mem::transmute(slice_deblocking_filter_disabled_flag) };
12436 slice_deblocking_filter_disabled_flag as u64
12437 });
12438 __bindgen_bitfield_unit.set(10usize, 1u8, {
12439 let collocated_from_l0_flag: u32 =
12440 unsafe { ::core::mem::transmute(collocated_from_l0_flag) };
12441 collocated_from_l0_flag as u64
12442 });
12443 __bindgen_bitfield_unit.set(11usize, 1u8, {
12444 let slice_loop_filter_across_slices_enabled_flag: u32 =
12445 unsafe { ::core::mem::transmute(slice_loop_filter_across_slices_enabled_flag) };
12446 slice_loop_filter_across_slices_enabled_flag as u64
12447 });
12448 __bindgen_bitfield_unit.set(12usize, 20u8, {
12449 let reserved: u32 = unsafe { ::core::mem::transmute(reserved) };
12450 reserved as u64
12451 });
12452 __bindgen_bitfield_unit
12453 }
12454}
12455#[repr(C)]
12456#[derive(Debug, Copy, Clone)]
12457pub struct StdVideoEncodeH265SliceSegmentHeader {
12458 pub flags: StdVideoEncodeH265SliceSegmentHeaderFlags,
12459 pub slice_type: StdVideoH265SliceType,
12460 pub slice_segment_address: u32,
12461 pub collocated_ref_idx: u8,
12462 pub MaxNumMergeCand: u8,
12463 pub slice_cb_qp_offset: i8,
12464 pub slice_cr_qp_offset: i8,
12465 pub slice_beta_offset_div2: i8,
12466 pub slice_tc_offset_div2: i8,
12467 pub slice_act_y_qp_offset: i8,
12468 pub slice_act_cb_qp_offset: i8,
12469 pub slice_act_cr_qp_offset: i8,
12470 pub slice_qp_delta: i8,
12471 pub reserved1: u16,
12472 pub pWeightTable: *const StdVideoEncodeH265WeightTable,
12473}
12474#[test]
12475fn bindgen_test_layout_StdVideoEncodeH265SliceSegmentHeader() {
12476 const UNINIT: ::core::mem::MaybeUninit<StdVideoEncodeH265SliceSegmentHeader> =
12477 ::core::mem::MaybeUninit::uninit();
12478 let ptr = UNINIT.as_ptr();
12479 assert_eq!(
12480 ::core::mem::size_of::<StdVideoEncodeH265SliceSegmentHeader>(),
12481 32usize,
12482 concat!(
12483 "Size of: ",
12484 stringify!(StdVideoEncodeH265SliceSegmentHeader)
12485 )
12486 );
12487 assert_eq!(
12488 ::core::mem::align_of::<StdVideoEncodeH265SliceSegmentHeader>(),
12489 8usize,
12490 concat!(
12491 "Alignment of ",
12492 stringify!(StdVideoEncodeH265SliceSegmentHeader)
12493 )
12494 );
12495 assert_eq!(
12496 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
12497 0usize,
12498 concat!(
12499 "Offset of field: ",
12500 stringify!(StdVideoEncodeH265SliceSegmentHeader),
12501 "::",
12502 stringify!(flags)
12503 )
12504 );
12505 assert_eq!(
12506 unsafe { ::core::ptr::addr_of!((*ptr).slice_type) as usize - ptr as usize },
12507 4usize,
12508 concat!(
12509 "Offset of field: ",
12510 stringify!(StdVideoEncodeH265SliceSegmentHeader),
12511 "::",
12512 stringify!(slice_type)
12513 )
12514 );
12515 assert_eq!(
12516 unsafe { ::core::ptr::addr_of!((*ptr).slice_segment_address) as usize - ptr as usize },
12517 8usize,
12518 concat!(
12519 "Offset of field: ",
12520 stringify!(StdVideoEncodeH265SliceSegmentHeader),
12521 "::",
12522 stringify!(slice_segment_address)
12523 )
12524 );
12525 assert_eq!(
12526 unsafe { ::core::ptr::addr_of!((*ptr).collocated_ref_idx) as usize - ptr as usize },
12527 12usize,
12528 concat!(
12529 "Offset of field: ",
12530 stringify!(StdVideoEncodeH265SliceSegmentHeader),
12531 "::",
12532 stringify!(collocated_ref_idx)
12533 )
12534 );
12535 assert_eq!(
12536 unsafe { ::core::ptr::addr_of!((*ptr).MaxNumMergeCand) as usize - ptr as usize },
12537 13usize,
12538 concat!(
12539 "Offset of field: ",
12540 stringify!(StdVideoEncodeH265SliceSegmentHeader),
12541 "::",
12542 stringify!(MaxNumMergeCand)
12543 )
12544 );
12545 assert_eq!(
12546 unsafe { ::core::ptr::addr_of!((*ptr).slice_cb_qp_offset) as usize - ptr as usize },
12547 14usize,
12548 concat!(
12549 "Offset of field: ",
12550 stringify!(StdVideoEncodeH265SliceSegmentHeader),
12551 "::",
12552 stringify!(slice_cb_qp_offset)
12553 )
12554 );
12555 assert_eq!(
12556 unsafe { ::core::ptr::addr_of!((*ptr).slice_cr_qp_offset) as usize - ptr as usize },
12557 15usize,
12558 concat!(
12559 "Offset of field: ",
12560 stringify!(StdVideoEncodeH265SliceSegmentHeader),
12561 "::",
12562 stringify!(slice_cr_qp_offset)
12563 )
12564 );
12565 assert_eq!(
12566 unsafe { ::core::ptr::addr_of!((*ptr).slice_beta_offset_div2) as usize - ptr as usize },
12567 16usize,
12568 concat!(
12569 "Offset of field: ",
12570 stringify!(StdVideoEncodeH265SliceSegmentHeader),
12571 "::",
12572 stringify!(slice_beta_offset_div2)
12573 )
12574 );
12575 assert_eq!(
12576 unsafe { ::core::ptr::addr_of!((*ptr).slice_tc_offset_div2) as usize - ptr as usize },
12577 17usize,
12578 concat!(
12579 "Offset of field: ",
12580 stringify!(StdVideoEncodeH265SliceSegmentHeader),
12581 "::",
12582 stringify!(slice_tc_offset_div2)
12583 )
12584 );
12585 assert_eq!(
12586 unsafe { ::core::ptr::addr_of!((*ptr).slice_act_y_qp_offset) as usize - ptr as usize },
12587 18usize,
12588 concat!(
12589 "Offset of field: ",
12590 stringify!(StdVideoEncodeH265SliceSegmentHeader),
12591 "::",
12592 stringify!(slice_act_y_qp_offset)
12593 )
12594 );
12595 assert_eq!(
12596 unsafe { ::core::ptr::addr_of!((*ptr).slice_act_cb_qp_offset) as usize - ptr as usize },
12597 19usize,
12598 concat!(
12599 "Offset of field: ",
12600 stringify!(StdVideoEncodeH265SliceSegmentHeader),
12601 "::",
12602 stringify!(slice_act_cb_qp_offset)
12603 )
12604 );
12605 assert_eq!(
12606 unsafe { ::core::ptr::addr_of!((*ptr).slice_act_cr_qp_offset) as usize - ptr as usize },
12607 20usize,
12608 concat!(
12609 "Offset of field: ",
12610 stringify!(StdVideoEncodeH265SliceSegmentHeader),
12611 "::",
12612 stringify!(slice_act_cr_qp_offset)
12613 )
12614 );
12615 assert_eq!(
12616 unsafe { ::core::ptr::addr_of!((*ptr).slice_qp_delta) as usize - ptr as usize },
12617 21usize,
12618 concat!(
12619 "Offset of field: ",
12620 stringify!(StdVideoEncodeH265SliceSegmentHeader),
12621 "::",
12622 stringify!(slice_qp_delta)
12623 )
12624 );
12625 assert_eq!(
12626 unsafe { ::core::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize },
12627 22usize,
12628 concat!(
12629 "Offset of field: ",
12630 stringify!(StdVideoEncodeH265SliceSegmentHeader),
12631 "::",
12632 stringify!(reserved1)
12633 )
12634 );
12635 assert_eq!(
12636 unsafe { ::core::ptr::addr_of!((*ptr).pWeightTable) as usize - ptr as usize },
12637 24usize,
12638 concat!(
12639 "Offset of field: ",
12640 stringify!(StdVideoEncodeH265SliceSegmentHeader),
12641 "::",
12642 stringify!(pWeightTable)
12643 )
12644 );
12645}
12646#[repr(C)]
12647#[derive(Debug, Copy, Clone)]
12648pub struct StdVideoEncodeH265ReferenceListsInfoFlags {
12649 pub _bitfield_align_1: [u32; 0],
12650 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
12651}
12652#[test]
12653fn bindgen_test_layout_StdVideoEncodeH265ReferenceListsInfoFlags() {
12654 assert_eq!(
12655 ::core::mem::size_of::<StdVideoEncodeH265ReferenceListsInfoFlags>(),
12656 4usize,
12657 concat!(
12658 "Size of: ",
12659 stringify!(StdVideoEncodeH265ReferenceListsInfoFlags)
12660 )
12661 );
12662 assert_eq!(
12663 ::core::mem::align_of::<StdVideoEncodeH265ReferenceListsInfoFlags>(),
12664 4usize,
12665 concat!(
12666 "Alignment of ",
12667 stringify!(StdVideoEncodeH265ReferenceListsInfoFlags)
12668 )
12669 );
12670}
12671impl StdVideoEncodeH265ReferenceListsInfoFlags {
12672 #[inline]
12673 pub fn ref_pic_list_modification_flag_l0(&self) -> u32 {
12674 unsafe { ::core::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
12675 }
12676 #[inline]
12677 pub fn set_ref_pic_list_modification_flag_l0(&mut self, val: u32) {
12678 unsafe {
12679 let val: u32 = ::core::mem::transmute(val);
12680 self._bitfield_1.set(0usize, 1u8, val as u64)
12681 }
12682 }
12683 #[inline]
12684 pub fn ref_pic_list_modification_flag_l1(&self) -> u32 {
12685 unsafe { ::core::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
12686 }
12687 #[inline]
12688 pub fn set_ref_pic_list_modification_flag_l1(&mut self, val: u32) {
12689 unsafe {
12690 let val: u32 = ::core::mem::transmute(val);
12691 self._bitfield_1.set(1usize, 1u8, val as u64)
12692 }
12693 }
12694 #[inline]
12695 pub fn reserved(&self) -> u32 {
12696 unsafe { ::core::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) }
12697 }
12698 #[inline]
12699 pub fn set_reserved(&mut self, val: u32) {
12700 unsafe {
12701 let val: u32 = ::core::mem::transmute(val);
12702 self._bitfield_1.set(2usize, 30u8, val as u64)
12703 }
12704 }
12705 #[inline]
12706 pub fn new_bitfield_1(
12707 ref_pic_list_modification_flag_l0: u32,
12708 ref_pic_list_modification_flag_l1: u32,
12709 reserved: u32,
12710 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
12711 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
12712 __bindgen_bitfield_unit.set(0usize, 1u8, {
12713 let ref_pic_list_modification_flag_l0: u32 =
12714 unsafe { ::core::mem::transmute(ref_pic_list_modification_flag_l0) };
12715 ref_pic_list_modification_flag_l0 as u64
12716 });
12717 __bindgen_bitfield_unit.set(1usize, 1u8, {
12718 let ref_pic_list_modification_flag_l1: u32 =
12719 unsafe { ::core::mem::transmute(ref_pic_list_modification_flag_l1) };
12720 ref_pic_list_modification_flag_l1 as u64
12721 });
12722 __bindgen_bitfield_unit.set(2usize, 30u8, {
12723 let reserved: u32 = unsafe { ::core::mem::transmute(reserved) };
12724 reserved as u64
12725 });
12726 __bindgen_bitfield_unit
12727 }
12728}
12729#[repr(C)]
12730#[derive(Debug, Copy, Clone)]
12731pub struct StdVideoEncodeH265ReferenceListsInfo {
12732 pub flags: StdVideoEncodeH265ReferenceListsInfoFlags,
12733 pub num_ref_idx_l0_active_minus1: u8,
12734 pub num_ref_idx_l1_active_minus1: u8,
12735 pub RefPicList0: [u8; 15usize],
12736 pub RefPicList1: [u8; 15usize],
12737 pub list_entry_l0: [u8; 15usize],
12738 pub list_entry_l1: [u8; 15usize],
12739}
12740#[test]
12741fn bindgen_test_layout_StdVideoEncodeH265ReferenceListsInfo() {
12742 const UNINIT: ::core::mem::MaybeUninit<StdVideoEncodeH265ReferenceListsInfo> =
12743 ::core::mem::MaybeUninit::uninit();
12744 let ptr = UNINIT.as_ptr();
12745 assert_eq!(
12746 ::core::mem::size_of::<StdVideoEncodeH265ReferenceListsInfo>(),
12747 68usize,
12748 concat!(
12749 "Size of: ",
12750 stringify!(StdVideoEncodeH265ReferenceListsInfo)
12751 )
12752 );
12753 assert_eq!(
12754 ::core::mem::align_of::<StdVideoEncodeH265ReferenceListsInfo>(),
12755 4usize,
12756 concat!(
12757 "Alignment of ",
12758 stringify!(StdVideoEncodeH265ReferenceListsInfo)
12759 )
12760 );
12761 assert_eq!(
12762 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
12763 0usize,
12764 concat!(
12765 "Offset of field: ",
12766 stringify!(StdVideoEncodeH265ReferenceListsInfo),
12767 "::",
12768 stringify!(flags)
12769 )
12770 );
12771 assert_eq!(
12772 unsafe {
12773 ::core::ptr::addr_of!((*ptr).num_ref_idx_l0_active_minus1) as usize - ptr as usize
12774 },
12775 4usize,
12776 concat!(
12777 "Offset of field: ",
12778 stringify!(StdVideoEncodeH265ReferenceListsInfo),
12779 "::",
12780 stringify!(num_ref_idx_l0_active_minus1)
12781 )
12782 );
12783 assert_eq!(
12784 unsafe {
12785 ::core::ptr::addr_of!((*ptr).num_ref_idx_l1_active_minus1) as usize - ptr as usize
12786 },
12787 5usize,
12788 concat!(
12789 "Offset of field: ",
12790 stringify!(StdVideoEncodeH265ReferenceListsInfo),
12791 "::",
12792 stringify!(num_ref_idx_l1_active_minus1)
12793 )
12794 );
12795 assert_eq!(
12796 unsafe { ::core::ptr::addr_of!((*ptr).RefPicList0) as usize - ptr as usize },
12797 6usize,
12798 concat!(
12799 "Offset of field: ",
12800 stringify!(StdVideoEncodeH265ReferenceListsInfo),
12801 "::",
12802 stringify!(RefPicList0)
12803 )
12804 );
12805 assert_eq!(
12806 unsafe { ::core::ptr::addr_of!((*ptr).RefPicList1) as usize - ptr as usize },
12807 21usize,
12808 concat!(
12809 "Offset of field: ",
12810 stringify!(StdVideoEncodeH265ReferenceListsInfo),
12811 "::",
12812 stringify!(RefPicList1)
12813 )
12814 );
12815 assert_eq!(
12816 unsafe { ::core::ptr::addr_of!((*ptr).list_entry_l0) as usize - ptr as usize },
12817 36usize,
12818 concat!(
12819 "Offset of field: ",
12820 stringify!(StdVideoEncodeH265ReferenceListsInfo),
12821 "::",
12822 stringify!(list_entry_l0)
12823 )
12824 );
12825 assert_eq!(
12826 unsafe { ::core::ptr::addr_of!((*ptr).list_entry_l1) as usize - ptr as usize },
12827 51usize,
12828 concat!(
12829 "Offset of field: ",
12830 stringify!(StdVideoEncodeH265ReferenceListsInfo),
12831 "::",
12832 stringify!(list_entry_l1)
12833 )
12834 );
12835}
12836#[repr(C)]
12837#[derive(Debug, Copy, Clone)]
12838pub struct StdVideoEncodeH265PictureInfoFlags {
12839 pub _bitfield_align_1: [u32; 0],
12840 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
12841}
12842#[test]
12843fn bindgen_test_layout_StdVideoEncodeH265PictureInfoFlags() {
12844 assert_eq!(
12845 ::core::mem::size_of::<StdVideoEncodeH265PictureInfoFlags>(),
12846 4usize,
12847 concat!("Size of: ", stringify!(StdVideoEncodeH265PictureInfoFlags))
12848 );
12849 assert_eq!(
12850 ::core::mem::align_of::<StdVideoEncodeH265PictureInfoFlags>(),
12851 4usize,
12852 concat!(
12853 "Alignment of ",
12854 stringify!(StdVideoEncodeH265PictureInfoFlags)
12855 )
12856 );
12857}
12858impl StdVideoEncodeH265PictureInfoFlags {
12859 #[inline]
12860 pub fn is_reference(&self) -> u32 {
12861 unsafe { ::core::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
12862 }
12863 #[inline]
12864 pub fn set_is_reference(&mut self, val: u32) {
12865 unsafe {
12866 let val: u32 = ::core::mem::transmute(val);
12867 self._bitfield_1.set(0usize, 1u8, val as u64)
12868 }
12869 }
12870 #[inline]
12871 pub fn IrapPicFlag(&self) -> u32 {
12872 unsafe { ::core::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
12873 }
12874 #[inline]
12875 pub fn set_IrapPicFlag(&mut self, val: u32) {
12876 unsafe {
12877 let val: u32 = ::core::mem::transmute(val);
12878 self._bitfield_1.set(1usize, 1u8, val as u64)
12879 }
12880 }
12881 #[inline]
12882 pub fn used_for_long_term_reference(&self) -> u32 {
12883 unsafe { ::core::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
12884 }
12885 #[inline]
12886 pub fn set_used_for_long_term_reference(&mut self, val: u32) {
12887 unsafe {
12888 let val: u32 = ::core::mem::transmute(val);
12889 self._bitfield_1.set(2usize, 1u8, val as u64)
12890 }
12891 }
12892 #[inline]
12893 pub fn discardable_flag(&self) -> u32 {
12894 unsafe { ::core::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
12895 }
12896 #[inline]
12897 pub fn set_discardable_flag(&mut self, val: u32) {
12898 unsafe {
12899 let val: u32 = ::core::mem::transmute(val);
12900 self._bitfield_1.set(3usize, 1u8, val as u64)
12901 }
12902 }
12903 #[inline]
12904 pub fn cross_layer_bla_flag(&self) -> u32 {
12905 unsafe { ::core::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
12906 }
12907 #[inline]
12908 pub fn set_cross_layer_bla_flag(&mut self, val: u32) {
12909 unsafe {
12910 let val: u32 = ::core::mem::transmute(val);
12911 self._bitfield_1.set(4usize, 1u8, val as u64)
12912 }
12913 }
12914 #[inline]
12915 pub fn pic_output_flag(&self) -> u32 {
12916 unsafe { ::core::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
12917 }
12918 #[inline]
12919 pub fn set_pic_output_flag(&mut self, val: u32) {
12920 unsafe {
12921 let val: u32 = ::core::mem::transmute(val);
12922 self._bitfield_1.set(5usize, 1u8, val as u64)
12923 }
12924 }
12925 #[inline]
12926 pub fn no_output_of_prior_pics_flag(&self) -> u32 {
12927 unsafe { ::core::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) }
12928 }
12929 #[inline]
12930 pub fn set_no_output_of_prior_pics_flag(&mut self, val: u32) {
12931 unsafe {
12932 let val: u32 = ::core::mem::transmute(val);
12933 self._bitfield_1.set(6usize, 1u8, val as u64)
12934 }
12935 }
12936 #[inline]
12937 pub fn short_term_ref_pic_set_sps_flag(&self) -> u32 {
12938 unsafe { ::core::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) }
12939 }
12940 #[inline]
12941 pub fn set_short_term_ref_pic_set_sps_flag(&mut self, val: u32) {
12942 unsafe {
12943 let val: u32 = ::core::mem::transmute(val);
12944 self._bitfield_1.set(7usize, 1u8, val as u64)
12945 }
12946 }
12947 #[inline]
12948 pub fn slice_temporal_mvp_enabled_flag(&self) -> u32 {
12949 unsafe { ::core::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) }
12950 }
12951 #[inline]
12952 pub fn set_slice_temporal_mvp_enabled_flag(&mut self, val: u32) {
12953 unsafe {
12954 let val: u32 = ::core::mem::transmute(val);
12955 self._bitfield_1.set(8usize, 1u8, val as u64)
12956 }
12957 }
12958 #[inline]
12959 pub fn reserved(&self) -> u32 {
12960 unsafe { ::core::mem::transmute(self._bitfield_1.get(9usize, 23u8) as u32) }
12961 }
12962 #[inline]
12963 pub fn set_reserved(&mut self, val: u32) {
12964 unsafe {
12965 let val: u32 = ::core::mem::transmute(val);
12966 self._bitfield_1.set(9usize, 23u8, val as u64)
12967 }
12968 }
12969 #[inline]
12970 pub fn new_bitfield_1(
12971 is_reference: u32,
12972 IrapPicFlag: u32,
12973 used_for_long_term_reference: u32,
12974 discardable_flag: u32,
12975 cross_layer_bla_flag: u32,
12976 pic_output_flag: u32,
12977 no_output_of_prior_pics_flag: u32,
12978 short_term_ref_pic_set_sps_flag: u32,
12979 slice_temporal_mvp_enabled_flag: u32,
12980 reserved: u32,
12981 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
12982 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
12983 __bindgen_bitfield_unit.set(0usize, 1u8, {
12984 let is_reference: u32 = unsafe { ::core::mem::transmute(is_reference) };
12985 is_reference as u64
12986 });
12987 __bindgen_bitfield_unit.set(1usize, 1u8, {
12988 let IrapPicFlag: u32 = unsafe { ::core::mem::transmute(IrapPicFlag) };
12989 IrapPicFlag as u64
12990 });
12991 __bindgen_bitfield_unit.set(2usize, 1u8, {
12992 let used_for_long_term_reference: u32 =
12993 unsafe { ::core::mem::transmute(used_for_long_term_reference) };
12994 used_for_long_term_reference as u64
12995 });
12996 __bindgen_bitfield_unit.set(3usize, 1u8, {
12997 let discardable_flag: u32 = unsafe { ::core::mem::transmute(discardable_flag) };
12998 discardable_flag as u64
12999 });
13000 __bindgen_bitfield_unit.set(4usize, 1u8, {
13001 let cross_layer_bla_flag: u32 = unsafe { ::core::mem::transmute(cross_layer_bla_flag) };
13002 cross_layer_bla_flag as u64
13003 });
13004 __bindgen_bitfield_unit.set(5usize, 1u8, {
13005 let pic_output_flag: u32 = unsafe { ::core::mem::transmute(pic_output_flag) };
13006 pic_output_flag as u64
13007 });
13008 __bindgen_bitfield_unit.set(6usize, 1u8, {
13009 let no_output_of_prior_pics_flag: u32 =
13010 unsafe { ::core::mem::transmute(no_output_of_prior_pics_flag) };
13011 no_output_of_prior_pics_flag as u64
13012 });
13013 __bindgen_bitfield_unit.set(7usize, 1u8, {
13014 let short_term_ref_pic_set_sps_flag: u32 =
13015 unsafe { ::core::mem::transmute(short_term_ref_pic_set_sps_flag) };
13016 short_term_ref_pic_set_sps_flag as u64
13017 });
13018 __bindgen_bitfield_unit.set(8usize, 1u8, {
13019 let slice_temporal_mvp_enabled_flag: u32 =
13020 unsafe { ::core::mem::transmute(slice_temporal_mvp_enabled_flag) };
13021 slice_temporal_mvp_enabled_flag as u64
13022 });
13023 __bindgen_bitfield_unit.set(9usize, 23u8, {
13024 let reserved: u32 = unsafe { ::core::mem::transmute(reserved) };
13025 reserved as u64
13026 });
13027 __bindgen_bitfield_unit
13028 }
13029}
13030#[repr(C)]
13031#[derive(Debug, Copy, Clone)]
13032pub struct StdVideoEncodeH265LongTermRefPics {
13033 pub num_long_term_sps: u8,
13034 pub num_long_term_pics: u8,
13035 pub lt_idx_sps: [u8; 32usize],
13036 pub poc_lsb_lt: [u8; 16usize],
13037 pub used_by_curr_pic_lt_flag: u16,
13038 pub delta_poc_msb_present_flag: [u8; 48usize],
13039 pub delta_poc_msb_cycle_lt: [u8; 48usize],
13040}
13041#[test]
13042fn bindgen_test_layout_StdVideoEncodeH265LongTermRefPics() {
13043 const UNINIT: ::core::mem::MaybeUninit<StdVideoEncodeH265LongTermRefPics> =
13044 ::core::mem::MaybeUninit::uninit();
13045 let ptr = UNINIT.as_ptr();
13046 assert_eq!(
13047 ::core::mem::size_of::<StdVideoEncodeH265LongTermRefPics>(),
13048 148usize,
13049 concat!("Size of: ", stringify!(StdVideoEncodeH265LongTermRefPics))
13050 );
13051 assert_eq!(
13052 ::core::mem::align_of::<StdVideoEncodeH265LongTermRefPics>(),
13053 2usize,
13054 concat!(
13055 "Alignment of ",
13056 stringify!(StdVideoEncodeH265LongTermRefPics)
13057 )
13058 );
13059 assert_eq!(
13060 unsafe { ::core::ptr::addr_of!((*ptr).num_long_term_sps) as usize - ptr as usize },
13061 0usize,
13062 concat!(
13063 "Offset of field: ",
13064 stringify!(StdVideoEncodeH265LongTermRefPics),
13065 "::",
13066 stringify!(num_long_term_sps)
13067 )
13068 );
13069 assert_eq!(
13070 unsafe { ::core::ptr::addr_of!((*ptr).num_long_term_pics) as usize - ptr as usize },
13071 1usize,
13072 concat!(
13073 "Offset of field: ",
13074 stringify!(StdVideoEncodeH265LongTermRefPics),
13075 "::",
13076 stringify!(num_long_term_pics)
13077 )
13078 );
13079 assert_eq!(
13080 unsafe { ::core::ptr::addr_of!((*ptr).lt_idx_sps) as usize - ptr as usize },
13081 2usize,
13082 concat!(
13083 "Offset of field: ",
13084 stringify!(StdVideoEncodeH265LongTermRefPics),
13085 "::",
13086 stringify!(lt_idx_sps)
13087 )
13088 );
13089 assert_eq!(
13090 unsafe { ::core::ptr::addr_of!((*ptr).poc_lsb_lt) as usize - ptr as usize },
13091 34usize,
13092 concat!(
13093 "Offset of field: ",
13094 stringify!(StdVideoEncodeH265LongTermRefPics),
13095 "::",
13096 stringify!(poc_lsb_lt)
13097 )
13098 );
13099 assert_eq!(
13100 unsafe { ::core::ptr::addr_of!((*ptr).used_by_curr_pic_lt_flag) as usize - ptr as usize },
13101 50usize,
13102 concat!(
13103 "Offset of field: ",
13104 stringify!(StdVideoEncodeH265LongTermRefPics),
13105 "::",
13106 stringify!(used_by_curr_pic_lt_flag)
13107 )
13108 );
13109 assert_eq!(
13110 unsafe { ::core::ptr::addr_of!((*ptr).delta_poc_msb_present_flag) as usize - ptr as usize },
13111 52usize,
13112 concat!(
13113 "Offset of field: ",
13114 stringify!(StdVideoEncodeH265LongTermRefPics),
13115 "::",
13116 stringify!(delta_poc_msb_present_flag)
13117 )
13118 );
13119 assert_eq!(
13120 unsafe { ::core::ptr::addr_of!((*ptr).delta_poc_msb_cycle_lt) as usize - ptr as usize },
13121 100usize,
13122 concat!(
13123 "Offset of field: ",
13124 stringify!(StdVideoEncodeH265LongTermRefPics),
13125 "::",
13126 stringify!(delta_poc_msb_cycle_lt)
13127 )
13128 );
13129}
13130#[repr(C)]
13131#[derive(Debug, Copy, Clone)]
13132pub struct StdVideoEncodeH265PictureInfo {
13133 pub flags: StdVideoEncodeH265PictureInfoFlags,
13134 pub pic_type: StdVideoH265PictureType,
13135 pub sps_video_parameter_set_id: u8,
13136 pub pps_seq_parameter_set_id: u8,
13137 pub pps_pic_parameter_set_id: u8,
13138 pub short_term_ref_pic_set_idx: u8,
13139 pub PicOrderCntVal: i32,
13140 pub TemporalId: u8,
13141 pub reserved1: [u8; 7usize],
13142 pub pRefLists: *const StdVideoEncodeH265ReferenceListsInfo,
13143 pub pShortTermRefPicSet: *const StdVideoH265ShortTermRefPicSet,
13144 pub pLongTermRefPics: *const StdVideoEncodeH265LongTermRefPics,
13145}
13146#[test]
13147fn bindgen_test_layout_StdVideoEncodeH265PictureInfo() {
13148 const UNINIT: ::core::mem::MaybeUninit<StdVideoEncodeH265PictureInfo> =
13149 ::core::mem::MaybeUninit::uninit();
13150 let ptr = UNINIT.as_ptr();
13151 assert_eq!(
13152 ::core::mem::size_of::<StdVideoEncodeH265PictureInfo>(),
13153 48usize,
13154 concat!("Size of: ", stringify!(StdVideoEncodeH265PictureInfo))
13155 );
13156 assert_eq!(
13157 ::core::mem::align_of::<StdVideoEncodeH265PictureInfo>(),
13158 8usize,
13159 concat!("Alignment of ", stringify!(StdVideoEncodeH265PictureInfo))
13160 );
13161 assert_eq!(
13162 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
13163 0usize,
13164 concat!(
13165 "Offset of field: ",
13166 stringify!(StdVideoEncodeH265PictureInfo),
13167 "::",
13168 stringify!(flags)
13169 )
13170 );
13171 assert_eq!(
13172 unsafe { ::core::ptr::addr_of!((*ptr).pic_type) as usize - ptr as usize },
13173 4usize,
13174 concat!(
13175 "Offset of field: ",
13176 stringify!(StdVideoEncodeH265PictureInfo),
13177 "::",
13178 stringify!(pic_type)
13179 )
13180 );
13181 assert_eq!(
13182 unsafe { ::core::ptr::addr_of!((*ptr).sps_video_parameter_set_id) as usize - ptr as usize },
13183 8usize,
13184 concat!(
13185 "Offset of field: ",
13186 stringify!(StdVideoEncodeH265PictureInfo),
13187 "::",
13188 stringify!(sps_video_parameter_set_id)
13189 )
13190 );
13191 assert_eq!(
13192 unsafe { ::core::ptr::addr_of!((*ptr).pps_seq_parameter_set_id) as usize - ptr as usize },
13193 9usize,
13194 concat!(
13195 "Offset of field: ",
13196 stringify!(StdVideoEncodeH265PictureInfo),
13197 "::",
13198 stringify!(pps_seq_parameter_set_id)
13199 )
13200 );
13201 assert_eq!(
13202 unsafe { ::core::ptr::addr_of!((*ptr).pps_pic_parameter_set_id) as usize - ptr as usize },
13203 10usize,
13204 concat!(
13205 "Offset of field: ",
13206 stringify!(StdVideoEncodeH265PictureInfo),
13207 "::",
13208 stringify!(pps_pic_parameter_set_id)
13209 )
13210 );
13211 assert_eq!(
13212 unsafe { ::core::ptr::addr_of!((*ptr).short_term_ref_pic_set_idx) as usize - ptr as usize },
13213 11usize,
13214 concat!(
13215 "Offset of field: ",
13216 stringify!(StdVideoEncodeH265PictureInfo),
13217 "::",
13218 stringify!(short_term_ref_pic_set_idx)
13219 )
13220 );
13221 assert_eq!(
13222 unsafe { ::core::ptr::addr_of!((*ptr).PicOrderCntVal) as usize - ptr as usize },
13223 12usize,
13224 concat!(
13225 "Offset of field: ",
13226 stringify!(StdVideoEncodeH265PictureInfo),
13227 "::",
13228 stringify!(PicOrderCntVal)
13229 )
13230 );
13231 assert_eq!(
13232 unsafe { ::core::ptr::addr_of!((*ptr).TemporalId) as usize - ptr as usize },
13233 16usize,
13234 concat!(
13235 "Offset of field: ",
13236 stringify!(StdVideoEncodeH265PictureInfo),
13237 "::",
13238 stringify!(TemporalId)
13239 )
13240 );
13241 assert_eq!(
13242 unsafe { ::core::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize },
13243 17usize,
13244 concat!(
13245 "Offset of field: ",
13246 stringify!(StdVideoEncodeH265PictureInfo),
13247 "::",
13248 stringify!(reserved1)
13249 )
13250 );
13251 assert_eq!(
13252 unsafe { ::core::ptr::addr_of!((*ptr).pRefLists) as usize - ptr as usize },
13253 24usize,
13254 concat!(
13255 "Offset of field: ",
13256 stringify!(StdVideoEncodeH265PictureInfo),
13257 "::",
13258 stringify!(pRefLists)
13259 )
13260 );
13261 assert_eq!(
13262 unsafe { ::core::ptr::addr_of!((*ptr).pShortTermRefPicSet) as usize - ptr as usize },
13263 32usize,
13264 concat!(
13265 "Offset of field: ",
13266 stringify!(StdVideoEncodeH265PictureInfo),
13267 "::",
13268 stringify!(pShortTermRefPicSet)
13269 )
13270 );
13271 assert_eq!(
13272 unsafe { ::core::ptr::addr_of!((*ptr).pLongTermRefPics) as usize - ptr as usize },
13273 40usize,
13274 concat!(
13275 "Offset of field: ",
13276 stringify!(StdVideoEncodeH265PictureInfo),
13277 "::",
13278 stringify!(pLongTermRefPics)
13279 )
13280 );
13281}
13282#[repr(C)]
13283#[derive(Debug, Copy, Clone)]
13284pub struct StdVideoEncodeH265ReferenceInfoFlags {
13285 pub _bitfield_align_1: [u32; 0],
13286 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
13287}
13288#[test]
13289fn bindgen_test_layout_StdVideoEncodeH265ReferenceInfoFlags() {
13290 assert_eq!(
13291 ::core::mem::size_of::<StdVideoEncodeH265ReferenceInfoFlags>(),
13292 4usize,
13293 concat!(
13294 "Size of: ",
13295 stringify!(StdVideoEncodeH265ReferenceInfoFlags)
13296 )
13297 );
13298 assert_eq!(
13299 ::core::mem::align_of::<StdVideoEncodeH265ReferenceInfoFlags>(),
13300 4usize,
13301 concat!(
13302 "Alignment of ",
13303 stringify!(StdVideoEncodeH265ReferenceInfoFlags)
13304 )
13305 );
13306}
13307impl StdVideoEncodeH265ReferenceInfoFlags {
13308 #[inline]
13309 pub fn used_for_long_term_reference(&self) -> u32 {
13310 unsafe { ::core::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
13311 }
13312 #[inline]
13313 pub fn set_used_for_long_term_reference(&mut self, val: u32) {
13314 unsafe {
13315 let val: u32 = ::core::mem::transmute(val);
13316 self._bitfield_1.set(0usize, 1u8, val as u64)
13317 }
13318 }
13319 #[inline]
13320 pub fn unused_for_reference(&self) -> u32 {
13321 unsafe { ::core::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
13322 }
13323 #[inline]
13324 pub fn set_unused_for_reference(&mut self, val: u32) {
13325 unsafe {
13326 let val: u32 = ::core::mem::transmute(val);
13327 self._bitfield_1.set(1usize, 1u8, val as u64)
13328 }
13329 }
13330 #[inline]
13331 pub fn reserved(&self) -> u32 {
13332 unsafe { ::core::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) }
13333 }
13334 #[inline]
13335 pub fn set_reserved(&mut self, val: u32) {
13336 unsafe {
13337 let val: u32 = ::core::mem::transmute(val);
13338 self._bitfield_1.set(2usize, 30u8, val as u64)
13339 }
13340 }
13341 #[inline]
13342 pub fn new_bitfield_1(
13343 used_for_long_term_reference: u32,
13344 unused_for_reference: u32,
13345 reserved: u32,
13346 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
13347 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
13348 __bindgen_bitfield_unit.set(0usize, 1u8, {
13349 let used_for_long_term_reference: u32 =
13350 unsafe { ::core::mem::transmute(used_for_long_term_reference) };
13351 used_for_long_term_reference as u64
13352 });
13353 __bindgen_bitfield_unit.set(1usize, 1u8, {
13354 let unused_for_reference: u32 = unsafe { ::core::mem::transmute(unused_for_reference) };
13355 unused_for_reference as u64
13356 });
13357 __bindgen_bitfield_unit.set(2usize, 30u8, {
13358 let reserved: u32 = unsafe { ::core::mem::transmute(reserved) };
13359 reserved as u64
13360 });
13361 __bindgen_bitfield_unit
13362 }
13363}
13364#[repr(C)]
13365#[derive(Debug, Copy, Clone)]
13366pub struct StdVideoEncodeH265ReferenceInfo {
13367 pub flags: StdVideoEncodeH265ReferenceInfoFlags,
13368 pub pic_type: StdVideoH265PictureType,
13369 pub PicOrderCntVal: i32,
13370 pub TemporalId: u8,
13371}
13372#[test]
13373fn bindgen_test_layout_StdVideoEncodeH265ReferenceInfo() {
13374 const UNINIT: ::core::mem::MaybeUninit<StdVideoEncodeH265ReferenceInfo> =
13375 ::core::mem::MaybeUninit::uninit();
13376 let ptr = UNINIT.as_ptr();
13377 assert_eq!(
13378 ::core::mem::size_of::<StdVideoEncodeH265ReferenceInfo>(),
13379 16usize,
13380 concat!("Size of: ", stringify!(StdVideoEncodeH265ReferenceInfo))
13381 );
13382 assert_eq!(
13383 ::core::mem::align_of::<StdVideoEncodeH265ReferenceInfo>(),
13384 4usize,
13385 concat!("Alignment of ", stringify!(StdVideoEncodeH265ReferenceInfo))
13386 );
13387 assert_eq!(
13388 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
13389 0usize,
13390 concat!(
13391 "Offset of field: ",
13392 stringify!(StdVideoEncodeH265ReferenceInfo),
13393 "::",
13394 stringify!(flags)
13395 )
13396 );
13397 assert_eq!(
13398 unsafe { ::core::ptr::addr_of!((*ptr).pic_type) as usize - ptr as usize },
13399 4usize,
13400 concat!(
13401 "Offset of field: ",
13402 stringify!(StdVideoEncodeH265ReferenceInfo),
13403 "::",
13404 stringify!(pic_type)
13405 )
13406 );
13407 assert_eq!(
13408 unsafe { ::core::ptr::addr_of!((*ptr).PicOrderCntVal) as usize - ptr as usize },
13409 8usize,
13410 concat!(
13411 "Offset of field: ",
13412 stringify!(StdVideoEncodeH265ReferenceInfo),
13413 "::",
13414 stringify!(PicOrderCntVal)
13415 )
13416 );
13417 assert_eq!(
13418 unsafe { ::core::ptr::addr_of!((*ptr).TemporalId) as usize - ptr as usize },
13419 12usize,
13420 concat!(
13421 "Offset of field: ",
13422 stringify!(StdVideoEncodeH265ReferenceInfo),
13423 "::",
13424 stringify!(TemporalId)
13425 )
13426 );
13427}
13428#[repr(C)]
13429#[derive(Debug, Copy, Clone)]
13430pub struct StdVideoEncodeAV1DecoderModelInfo {
13431 pub buffer_delay_length_minus_1: u8,
13432 pub buffer_removal_time_length_minus_1: u8,
13433 pub frame_presentation_time_length_minus_1: u8,
13434 pub reserved1: u8,
13435 pub num_units_in_decoding_tick: u32,
13436}
13437#[test]
13438fn bindgen_test_layout_StdVideoEncodeAV1DecoderModelInfo() {
13439 const UNINIT: ::core::mem::MaybeUninit<StdVideoEncodeAV1DecoderModelInfo> =
13440 ::core::mem::MaybeUninit::uninit();
13441 let ptr = UNINIT.as_ptr();
13442 assert_eq!(
13443 ::core::mem::size_of::<StdVideoEncodeAV1DecoderModelInfo>(),
13444 8usize,
13445 concat!("Size of: ", stringify!(StdVideoEncodeAV1DecoderModelInfo))
13446 );
13447 assert_eq!(
13448 ::core::mem::align_of::<StdVideoEncodeAV1DecoderModelInfo>(),
13449 4usize,
13450 concat!(
13451 "Alignment of ",
13452 stringify!(StdVideoEncodeAV1DecoderModelInfo)
13453 )
13454 );
13455 assert_eq!(
13456 unsafe {
13457 ::core::ptr::addr_of!((*ptr).buffer_delay_length_minus_1) as usize - ptr as usize
13458 },
13459 0usize,
13460 concat!(
13461 "Offset of field: ",
13462 stringify!(StdVideoEncodeAV1DecoderModelInfo),
13463 "::",
13464 stringify!(buffer_delay_length_minus_1)
13465 )
13466 );
13467 assert_eq!(
13468 unsafe {
13469 ::core::ptr::addr_of!((*ptr).buffer_removal_time_length_minus_1) as usize - ptr as usize
13470 },
13471 1usize,
13472 concat!(
13473 "Offset of field: ",
13474 stringify!(StdVideoEncodeAV1DecoderModelInfo),
13475 "::",
13476 stringify!(buffer_removal_time_length_minus_1)
13477 )
13478 );
13479 assert_eq!(
13480 unsafe {
13481 ::core::ptr::addr_of!((*ptr).frame_presentation_time_length_minus_1) as usize
13482 - ptr as usize
13483 },
13484 2usize,
13485 concat!(
13486 "Offset of field: ",
13487 stringify!(StdVideoEncodeAV1DecoderModelInfo),
13488 "::",
13489 stringify!(frame_presentation_time_length_minus_1)
13490 )
13491 );
13492 assert_eq!(
13493 unsafe { ::core::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize },
13494 3usize,
13495 concat!(
13496 "Offset of field: ",
13497 stringify!(StdVideoEncodeAV1DecoderModelInfo),
13498 "::",
13499 stringify!(reserved1)
13500 )
13501 );
13502 assert_eq!(
13503 unsafe { ::core::ptr::addr_of!((*ptr).num_units_in_decoding_tick) as usize - ptr as usize },
13504 4usize,
13505 concat!(
13506 "Offset of field: ",
13507 stringify!(StdVideoEncodeAV1DecoderModelInfo),
13508 "::",
13509 stringify!(num_units_in_decoding_tick)
13510 )
13511 );
13512}
13513#[repr(C)]
13514#[derive(Debug, Copy, Clone)]
13515pub struct StdVideoEncodeAV1ExtensionHeader {
13516 pub temporal_id: u8,
13517 pub spatial_id: u8,
13518}
13519#[test]
13520fn bindgen_test_layout_StdVideoEncodeAV1ExtensionHeader() {
13521 const UNINIT: ::core::mem::MaybeUninit<StdVideoEncodeAV1ExtensionHeader> =
13522 ::core::mem::MaybeUninit::uninit();
13523 let ptr = UNINIT.as_ptr();
13524 assert_eq!(
13525 ::core::mem::size_of::<StdVideoEncodeAV1ExtensionHeader>(),
13526 2usize,
13527 concat!("Size of: ", stringify!(StdVideoEncodeAV1ExtensionHeader))
13528 );
13529 assert_eq!(
13530 ::core::mem::align_of::<StdVideoEncodeAV1ExtensionHeader>(),
13531 1usize,
13532 concat!(
13533 "Alignment of ",
13534 stringify!(StdVideoEncodeAV1ExtensionHeader)
13535 )
13536 );
13537 assert_eq!(
13538 unsafe { ::core::ptr::addr_of!((*ptr).temporal_id) as usize - ptr as usize },
13539 0usize,
13540 concat!(
13541 "Offset of field: ",
13542 stringify!(StdVideoEncodeAV1ExtensionHeader),
13543 "::",
13544 stringify!(temporal_id)
13545 )
13546 );
13547 assert_eq!(
13548 unsafe { ::core::ptr::addr_of!((*ptr).spatial_id) as usize - ptr as usize },
13549 1usize,
13550 concat!(
13551 "Offset of field: ",
13552 stringify!(StdVideoEncodeAV1ExtensionHeader),
13553 "::",
13554 stringify!(spatial_id)
13555 )
13556 );
13557}
13558#[repr(C)]
13559#[derive(Debug, Copy, Clone)]
13560pub struct StdVideoEncodeAV1OperatingPointInfoFlags {
13561 pub _bitfield_align_1: [u32; 0],
13562 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
13563}
13564#[test]
13565fn bindgen_test_layout_StdVideoEncodeAV1OperatingPointInfoFlags() {
13566 assert_eq!(
13567 ::core::mem::size_of::<StdVideoEncodeAV1OperatingPointInfoFlags>(),
13568 4usize,
13569 concat!(
13570 "Size of: ",
13571 stringify!(StdVideoEncodeAV1OperatingPointInfoFlags)
13572 )
13573 );
13574 assert_eq!(
13575 ::core::mem::align_of::<StdVideoEncodeAV1OperatingPointInfoFlags>(),
13576 4usize,
13577 concat!(
13578 "Alignment of ",
13579 stringify!(StdVideoEncodeAV1OperatingPointInfoFlags)
13580 )
13581 );
13582}
13583impl StdVideoEncodeAV1OperatingPointInfoFlags {
13584 #[inline]
13585 pub fn decoder_model_present_for_this_op(&self) -> u32 {
13586 unsafe { ::core::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
13587 }
13588 #[inline]
13589 pub fn set_decoder_model_present_for_this_op(&mut self, val: u32) {
13590 unsafe {
13591 let val: u32 = ::core::mem::transmute(val);
13592 self._bitfield_1.set(0usize, 1u8, val as u64)
13593 }
13594 }
13595 #[inline]
13596 pub fn low_delay_mode_flag(&self) -> u32 {
13597 unsafe { ::core::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
13598 }
13599 #[inline]
13600 pub fn set_low_delay_mode_flag(&mut self, val: u32) {
13601 unsafe {
13602 let val: u32 = ::core::mem::transmute(val);
13603 self._bitfield_1.set(1usize, 1u8, val as u64)
13604 }
13605 }
13606 #[inline]
13607 pub fn initial_display_delay_present_for_this_op(&self) -> u32 {
13608 unsafe { ::core::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
13609 }
13610 #[inline]
13611 pub fn set_initial_display_delay_present_for_this_op(&mut self, val: u32) {
13612 unsafe {
13613 let val: u32 = ::core::mem::transmute(val);
13614 self._bitfield_1.set(2usize, 1u8, val as u64)
13615 }
13616 }
13617 #[inline]
13618 pub fn reserved(&self) -> u32 {
13619 unsafe { ::core::mem::transmute(self._bitfield_1.get(3usize, 29u8) as u32) }
13620 }
13621 #[inline]
13622 pub fn set_reserved(&mut self, val: u32) {
13623 unsafe {
13624 let val: u32 = ::core::mem::transmute(val);
13625 self._bitfield_1.set(3usize, 29u8, val as u64)
13626 }
13627 }
13628 #[inline]
13629 pub fn new_bitfield_1(
13630 decoder_model_present_for_this_op: u32,
13631 low_delay_mode_flag: u32,
13632 initial_display_delay_present_for_this_op: u32,
13633 reserved: u32,
13634 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
13635 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
13636 __bindgen_bitfield_unit.set(0usize, 1u8, {
13637 let decoder_model_present_for_this_op: u32 =
13638 unsafe { ::core::mem::transmute(decoder_model_present_for_this_op) };
13639 decoder_model_present_for_this_op as u64
13640 });
13641 __bindgen_bitfield_unit.set(1usize, 1u8, {
13642 let low_delay_mode_flag: u32 = unsafe { ::core::mem::transmute(low_delay_mode_flag) };
13643 low_delay_mode_flag as u64
13644 });
13645 __bindgen_bitfield_unit.set(2usize, 1u8, {
13646 let initial_display_delay_present_for_this_op: u32 =
13647 unsafe { ::core::mem::transmute(initial_display_delay_present_for_this_op) };
13648 initial_display_delay_present_for_this_op as u64
13649 });
13650 __bindgen_bitfield_unit.set(3usize, 29u8, {
13651 let reserved: u32 = unsafe { ::core::mem::transmute(reserved) };
13652 reserved as u64
13653 });
13654 __bindgen_bitfield_unit
13655 }
13656}
13657#[repr(C)]
13658#[derive(Debug, Copy, Clone)]
13659pub struct StdVideoEncodeAV1OperatingPointInfo {
13660 pub flags: StdVideoEncodeAV1OperatingPointInfoFlags,
13661 pub operating_point_idc: u16,
13662 pub seq_level_idx: u8,
13663 pub seq_tier: u8,
13664 pub decoder_buffer_delay: u32,
13665 pub encoder_buffer_delay: u32,
13666 pub initial_display_delay_minus_1: u8,
13667}
13668#[test]
13669fn bindgen_test_layout_StdVideoEncodeAV1OperatingPointInfo() {
13670 const UNINIT: ::core::mem::MaybeUninit<StdVideoEncodeAV1OperatingPointInfo> =
13671 ::core::mem::MaybeUninit::uninit();
13672 let ptr = UNINIT.as_ptr();
13673 assert_eq!(
13674 ::core::mem::size_of::<StdVideoEncodeAV1OperatingPointInfo>(),
13675 20usize,
13676 concat!("Size of: ", stringify!(StdVideoEncodeAV1OperatingPointInfo))
13677 );
13678 assert_eq!(
13679 ::core::mem::align_of::<StdVideoEncodeAV1OperatingPointInfo>(),
13680 4usize,
13681 concat!(
13682 "Alignment of ",
13683 stringify!(StdVideoEncodeAV1OperatingPointInfo)
13684 )
13685 );
13686 assert_eq!(
13687 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
13688 0usize,
13689 concat!(
13690 "Offset of field: ",
13691 stringify!(StdVideoEncodeAV1OperatingPointInfo),
13692 "::",
13693 stringify!(flags)
13694 )
13695 );
13696 assert_eq!(
13697 unsafe { ::core::ptr::addr_of!((*ptr).operating_point_idc) as usize - ptr as usize },
13698 4usize,
13699 concat!(
13700 "Offset of field: ",
13701 stringify!(StdVideoEncodeAV1OperatingPointInfo),
13702 "::",
13703 stringify!(operating_point_idc)
13704 )
13705 );
13706 assert_eq!(
13707 unsafe { ::core::ptr::addr_of!((*ptr).seq_level_idx) as usize - ptr as usize },
13708 6usize,
13709 concat!(
13710 "Offset of field: ",
13711 stringify!(StdVideoEncodeAV1OperatingPointInfo),
13712 "::",
13713 stringify!(seq_level_idx)
13714 )
13715 );
13716 assert_eq!(
13717 unsafe { ::core::ptr::addr_of!((*ptr).seq_tier) as usize - ptr as usize },
13718 7usize,
13719 concat!(
13720 "Offset of field: ",
13721 stringify!(StdVideoEncodeAV1OperatingPointInfo),
13722 "::",
13723 stringify!(seq_tier)
13724 )
13725 );
13726 assert_eq!(
13727 unsafe { ::core::ptr::addr_of!((*ptr).decoder_buffer_delay) as usize - ptr as usize },
13728 8usize,
13729 concat!(
13730 "Offset of field: ",
13731 stringify!(StdVideoEncodeAV1OperatingPointInfo),
13732 "::",
13733 stringify!(decoder_buffer_delay)
13734 )
13735 );
13736 assert_eq!(
13737 unsafe { ::core::ptr::addr_of!((*ptr).encoder_buffer_delay) as usize - ptr as usize },
13738 12usize,
13739 concat!(
13740 "Offset of field: ",
13741 stringify!(StdVideoEncodeAV1OperatingPointInfo),
13742 "::",
13743 stringify!(encoder_buffer_delay)
13744 )
13745 );
13746 assert_eq!(
13747 unsafe {
13748 ::core::ptr::addr_of!((*ptr).initial_display_delay_minus_1) as usize - ptr as usize
13749 },
13750 16usize,
13751 concat!(
13752 "Offset of field: ",
13753 stringify!(StdVideoEncodeAV1OperatingPointInfo),
13754 "::",
13755 stringify!(initial_display_delay_minus_1)
13756 )
13757 );
13758}
13759#[repr(C)]
13760#[repr(align(4))]
13761#[derive(Debug, Copy, Clone)]
13762pub struct StdVideoEncodeAV1PictureInfoFlags {
13763 pub _bitfield_align_1: [u8; 0],
13764 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
13765}
13766#[test]
13767fn bindgen_test_layout_StdVideoEncodeAV1PictureInfoFlags() {
13768 assert_eq!(
13769 ::core::mem::size_of::<StdVideoEncodeAV1PictureInfoFlags>(),
13770 4usize,
13771 concat!("Size of: ", stringify!(StdVideoEncodeAV1PictureInfoFlags))
13772 );
13773 assert_eq!(
13774 ::core::mem::align_of::<StdVideoEncodeAV1PictureInfoFlags>(),
13775 4usize,
13776 concat!(
13777 "Alignment of ",
13778 stringify!(StdVideoEncodeAV1PictureInfoFlags)
13779 )
13780 );
13781}
13782impl StdVideoEncodeAV1PictureInfoFlags {
13783 #[inline]
13784 pub fn error_resilient_mode(&self) -> u32 {
13785 unsafe { ::core::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
13786 }
13787 #[inline]
13788 pub fn set_error_resilient_mode(&mut self, val: u32) {
13789 unsafe {
13790 let val: u32 = ::core::mem::transmute(val);
13791 self._bitfield_1.set(0usize, 1u8, val as u64)
13792 }
13793 }
13794 #[inline]
13795 pub fn disable_cdf_update(&self) -> u32 {
13796 unsafe { ::core::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
13797 }
13798 #[inline]
13799 pub fn set_disable_cdf_update(&mut self, val: u32) {
13800 unsafe {
13801 let val: u32 = ::core::mem::transmute(val);
13802 self._bitfield_1.set(1usize, 1u8, val as u64)
13803 }
13804 }
13805 #[inline]
13806 pub fn use_superres(&self) -> u32 {
13807 unsafe { ::core::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
13808 }
13809 #[inline]
13810 pub fn set_use_superres(&mut self, val: u32) {
13811 unsafe {
13812 let val: u32 = ::core::mem::transmute(val);
13813 self._bitfield_1.set(2usize, 1u8, val as u64)
13814 }
13815 }
13816 #[inline]
13817 pub fn render_and_frame_size_different(&self) -> u32 {
13818 unsafe { ::core::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
13819 }
13820 #[inline]
13821 pub fn set_render_and_frame_size_different(&mut self, val: u32) {
13822 unsafe {
13823 let val: u32 = ::core::mem::transmute(val);
13824 self._bitfield_1.set(3usize, 1u8, val as u64)
13825 }
13826 }
13827 #[inline]
13828 pub fn allow_screen_content_tools(&self) -> u32 {
13829 unsafe { ::core::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
13830 }
13831 #[inline]
13832 pub fn set_allow_screen_content_tools(&mut self, val: u32) {
13833 unsafe {
13834 let val: u32 = ::core::mem::transmute(val);
13835 self._bitfield_1.set(4usize, 1u8, val as u64)
13836 }
13837 }
13838 #[inline]
13839 pub fn is_filter_switchable(&self) -> u32 {
13840 unsafe { ::core::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
13841 }
13842 #[inline]
13843 pub fn set_is_filter_switchable(&mut self, val: u32) {
13844 unsafe {
13845 let val: u32 = ::core::mem::transmute(val);
13846 self._bitfield_1.set(5usize, 1u8, val as u64)
13847 }
13848 }
13849 #[inline]
13850 pub fn force_integer_mv(&self) -> u32 {
13851 unsafe { ::core::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) }
13852 }
13853 #[inline]
13854 pub fn set_force_integer_mv(&mut self, val: u32) {
13855 unsafe {
13856 let val: u32 = ::core::mem::transmute(val);
13857 self._bitfield_1.set(6usize, 1u8, val as u64)
13858 }
13859 }
13860 #[inline]
13861 pub fn frame_size_override_flag(&self) -> u32 {
13862 unsafe { ::core::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) }
13863 }
13864 #[inline]
13865 pub fn set_frame_size_override_flag(&mut self, val: u32) {
13866 unsafe {
13867 let val: u32 = ::core::mem::transmute(val);
13868 self._bitfield_1.set(7usize, 1u8, val as u64)
13869 }
13870 }
13871 #[inline]
13872 pub fn buffer_removal_time_present_flag(&self) -> u32 {
13873 unsafe { ::core::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) }
13874 }
13875 #[inline]
13876 pub fn set_buffer_removal_time_present_flag(&mut self, val: u32) {
13877 unsafe {
13878 let val: u32 = ::core::mem::transmute(val);
13879 self._bitfield_1.set(8usize, 1u8, val as u64)
13880 }
13881 }
13882 #[inline]
13883 pub fn allow_intrabc(&self) -> u32 {
13884 unsafe { ::core::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) }
13885 }
13886 #[inline]
13887 pub fn set_allow_intrabc(&mut self, val: u32) {
13888 unsafe {
13889 let val: u32 = ::core::mem::transmute(val);
13890 self._bitfield_1.set(9usize, 1u8, val as u64)
13891 }
13892 }
13893 #[inline]
13894 pub fn frame_refs_short_signaling(&self) -> u32 {
13895 unsafe { ::core::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) }
13896 }
13897 #[inline]
13898 pub fn set_frame_refs_short_signaling(&mut self, val: u32) {
13899 unsafe {
13900 let val: u32 = ::core::mem::transmute(val);
13901 self._bitfield_1.set(10usize, 1u8, val as u64)
13902 }
13903 }
13904 #[inline]
13905 pub fn allow_high_precision_mv(&self) -> u32 {
13906 unsafe { ::core::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) }
13907 }
13908 #[inline]
13909 pub fn set_allow_high_precision_mv(&mut self, val: u32) {
13910 unsafe {
13911 let val: u32 = ::core::mem::transmute(val);
13912 self._bitfield_1.set(11usize, 1u8, val as u64)
13913 }
13914 }
13915 #[inline]
13916 pub fn is_motion_mode_switchable(&self) -> u32 {
13917 unsafe { ::core::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u32) }
13918 }
13919 #[inline]
13920 pub fn set_is_motion_mode_switchable(&mut self, val: u32) {
13921 unsafe {
13922 let val: u32 = ::core::mem::transmute(val);
13923 self._bitfield_1.set(12usize, 1u8, val as u64)
13924 }
13925 }
13926 #[inline]
13927 pub fn use_ref_frame_mvs(&self) -> u32 {
13928 unsafe { ::core::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) }
13929 }
13930 #[inline]
13931 pub fn set_use_ref_frame_mvs(&mut self, val: u32) {
13932 unsafe {
13933 let val: u32 = ::core::mem::transmute(val);
13934 self._bitfield_1.set(13usize, 1u8, val as u64)
13935 }
13936 }
13937 #[inline]
13938 pub fn disable_frame_end_update_cdf(&self) -> u32 {
13939 unsafe { ::core::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) }
13940 }
13941 #[inline]
13942 pub fn set_disable_frame_end_update_cdf(&mut self, val: u32) {
13943 unsafe {
13944 let val: u32 = ::core::mem::transmute(val);
13945 self._bitfield_1.set(14usize, 1u8, val as u64)
13946 }
13947 }
13948 #[inline]
13949 pub fn allow_warped_motion(&self) -> u32 {
13950 unsafe { ::core::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u32) }
13951 }
13952 #[inline]
13953 pub fn set_allow_warped_motion(&mut self, val: u32) {
13954 unsafe {
13955 let val: u32 = ::core::mem::transmute(val);
13956 self._bitfield_1.set(15usize, 1u8, val as u64)
13957 }
13958 }
13959 #[inline]
13960 pub fn reduced_tx_set(&self) -> u32 {
13961 unsafe { ::core::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u32) }
13962 }
13963 #[inline]
13964 pub fn set_reduced_tx_set(&mut self, val: u32) {
13965 unsafe {
13966 let val: u32 = ::core::mem::transmute(val);
13967 self._bitfield_1.set(16usize, 1u8, val as u64)
13968 }
13969 }
13970 #[inline]
13971 pub fn skip_mode_present(&self) -> u32 {
13972 unsafe { ::core::mem::transmute(self._bitfield_1.get(17usize, 1u8) as u32) }
13973 }
13974 #[inline]
13975 pub fn set_skip_mode_present(&mut self, val: u32) {
13976 unsafe {
13977 let val: u32 = ::core::mem::transmute(val);
13978 self._bitfield_1.set(17usize, 1u8, val as u64)
13979 }
13980 }
13981 #[inline]
13982 pub fn delta_q_present(&self) -> u32 {
13983 unsafe { ::core::mem::transmute(self._bitfield_1.get(18usize, 1u8) as u32) }
13984 }
13985 #[inline]
13986 pub fn set_delta_q_present(&mut self, val: u32) {
13987 unsafe {
13988 let val: u32 = ::core::mem::transmute(val);
13989 self._bitfield_1.set(18usize, 1u8, val as u64)
13990 }
13991 }
13992 #[inline]
13993 pub fn delta_lf_present(&self) -> u32 {
13994 unsafe { ::core::mem::transmute(self._bitfield_1.get(19usize, 1u8) as u32) }
13995 }
13996 #[inline]
13997 pub fn set_delta_lf_present(&mut self, val: u32) {
13998 unsafe {
13999 let val: u32 = ::core::mem::transmute(val);
14000 self._bitfield_1.set(19usize, 1u8, val as u64)
14001 }
14002 }
14003 #[inline]
14004 pub fn delta_lf_multi(&self) -> u32 {
14005 unsafe { ::core::mem::transmute(self._bitfield_1.get(20usize, 1u8) as u32) }
14006 }
14007 #[inline]
14008 pub fn set_delta_lf_multi(&mut self, val: u32) {
14009 unsafe {
14010 let val: u32 = ::core::mem::transmute(val);
14011 self._bitfield_1.set(20usize, 1u8, val as u64)
14012 }
14013 }
14014 #[inline]
14015 pub fn segmentation_enabled(&self) -> u32 {
14016 unsafe { ::core::mem::transmute(self._bitfield_1.get(21usize, 1u8) as u32) }
14017 }
14018 #[inline]
14019 pub fn set_segmentation_enabled(&mut self, val: u32) {
14020 unsafe {
14021 let val: u32 = ::core::mem::transmute(val);
14022 self._bitfield_1.set(21usize, 1u8, val as u64)
14023 }
14024 }
14025 #[inline]
14026 pub fn segmentation_update_map(&self) -> u32 {
14027 unsafe { ::core::mem::transmute(self._bitfield_1.get(22usize, 1u8) as u32) }
14028 }
14029 #[inline]
14030 pub fn set_segmentation_update_map(&mut self, val: u32) {
14031 unsafe {
14032 let val: u32 = ::core::mem::transmute(val);
14033 self._bitfield_1.set(22usize, 1u8, val as u64)
14034 }
14035 }
14036 #[inline]
14037 pub fn segmentation_temporal_update(&self) -> u32 {
14038 unsafe { ::core::mem::transmute(self._bitfield_1.get(23usize, 1u8) as u32) }
14039 }
14040 #[inline]
14041 pub fn set_segmentation_temporal_update(&mut self, val: u32) {
14042 unsafe {
14043 let val: u32 = ::core::mem::transmute(val);
14044 self._bitfield_1.set(23usize, 1u8, val as u64)
14045 }
14046 }
14047 #[inline]
14048 pub fn segmentation_update_data(&self) -> u32 {
14049 unsafe { ::core::mem::transmute(self._bitfield_1.get(24usize, 1u8) as u32) }
14050 }
14051 #[inline]
14052 pub fn set_segmentation_update_data(&mut self, val: u32) {
14053 unsafe {
14054 let val: u32 = ::core::mem::transmute(val);
14055 self._bitfield_1.set(24usize, 1u8, val as u64)
14056 }
14057 }
14058 #[inline]
14059 pub fn UsesLr(&self) -> u32 {
14060 unsafe { ::core::mem::transmute(self._bitfield_1.get(25usize, 1u8) as u32) }
14061 }
14062 #[inline]
14063 pub fn set_UsesLr(&mut self, val: u32) {
14064 unsafe {
14065 let val: u32 = ::core::mem::transmute(val);
14066 self._bitfield_1.set(25usize, 1u8, val as u64)
14067 }
14068 }
14069 #[inline]
14070 pub fn usesChromaLr(&self) -> u32 {
14071 unsafe { ::core::mem::transmute(self._bitfield_1.get(26usize, 1u8) as u32) }
14072 }
14073 #[inline]
14074 pub fn set_usesChromaLr(&mut self, val: u32) {
14075 unsafe {
14076 let val: u32 = ::core::mem::transmute(val);
14077 self._bitfield_1.set(26usize, 1u8, val as u64)
14078 }
14079 }
14080 #[inline]
14081 pub fn show_frame(&self) -> u32 {
14082 unsafe { ::core::mem::transmute(self._bitfield_1.get(27usize, 1u8) as u32) }
14083 }
14084 #[inline]
14085 pub fn set_show_frame(&mut self, val: u32) {
14086 unsafe {
14087 let val: u32 = ::core::mem::transmute(val);
14088 self._bitfield_1.set(27usize, 1u8, val as u64)
14089 }
14090 }
14091 #[inline]
14092 pub fn showable_frame(&self) -> u32 {
14093 unsafe { ::core::mem::transmute(self._bitfield_1.get(28usize, 1u8) as u32) }
14094 }
14095 #[inline]
14096 pub fn set_showable_frame(&mut self, val: u32) {
14097 unsafe {
14098 let val: u32 = ::core::mem::transmute(val);
14099 self._bitfield_1.set(28usize, 1u8, val as u64)
14100 }
14101 }
14102 #[inline]
14103 pub fn reserved(&self) -> u32 {
14104 unsafe { ::core::mem::transmute(self._bitfield_1.get(29usize, 3u8) as u32) }
14105 }
14106 #[inline]
14107 pub fn set_reserved(&mut self, val: u32) {
14108 unsafe {
14109 let val: u32 = ::core::mem::transmute(val);
14110 self._bitfield_1.set(29usize, 3u8, val as u64)
14111 }
14112 }
14113 #[inline]
14114 pub fn new_bitfield_1(
14115 error_resilient_mode: u32,
14116 disable_cdf_update: u32,
14117 use_superres: u32,
14118 render_and_frame_size_different: u32,
14119 allow_screen_content_tools: u32,
14120 is_filter_switchable: u32,
14121 force_integer_mv: u32,
14122 frame_size_override_flag: u32,
14123 buffer_removal_time_present_flag: u32,
14124 allow_intrabc: u32,
14125 frame_refs_short_signaling: u32,
14126 allow_high_precision_mv: u32,
14127 is_motion_mode_switchable: u32,
14128 use_ref_frame_mvs: u32,
14129 disable_frame_end_update_cdf: u32,
14130 allow_warped_motion: u32,
14131 reduced_tx_set: u32,
14132 skip_mode_present: u32,
14133 delta_q_present: u32,
14134 delta_lf_present: u32,
14135 delta_lf_multi: u32,
14136 segmentation_enabled: u32,
14137 segmentation_update_map: u32,
14138 segmentation_temporal_update: u32,
14139 segmentation_update_data: u32,
14140 UsesLr: u32,
14141 usesChromaLr: u32,
14142 show_frame: u32,
14143 showable_frame: u32,
14144 reserved: u32,
14145 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
14146 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
14147 __bindgen_bitfield_unit.set(0usize, 1u8, {
14148 let error_resilient_mode: u32 = unsafe { ::core::mem::transmute(error_resilient_mode) };
14149 error_resilient_mode as u64
14150 });
14151 __bindgen_bitfield_unit.set(1usize, 1u8, {
14152 let disable_cdf_update: u32 = unsafe { ::core::mem::transmute(disable_cdf_update) };
14153 disable_cdf_update as u64
14154 });
14155 __bindgen_bitfield_unit.set(2usize, 1u8, {
14156 let use_superres: u32 = unsafe { ::core::mem::transmute(use_superres) };
14157 use_superres as u64
14158 });
14159 __bindgen_bitfield_unit.set(3usize, 1u8, {
14160 let render_and_frame_size_different: u32 =
14161 unsafe { ::core::mem::transmute(render_and_frame_size_different) };
14162 render_and_frame_size_different as u64
14163 });
14164 __bindgen_bitfield_unit.set(4usize, 1u8, {
14165 let allow_screen_content_tools: u32 =
14166 unsafe { ::core::mem::transmute(allow_screen_content_tools) };
14167 allow_screen_content_tools as u64
14168 });
14169 __bindgen_bitfield_unit.set(5usize, 1u8, {
14170 let is_filter_switchable: u32 = unsafe { ::core::mem::transmute(is_filter_switchable) };
14171 is_filter_switchable as u64
14172 });
14173 __bindgen_bitfield_unit.set(6usize, 1u8, {
14174 let force_integer_mv: u32 = unsafe { ::core::mem::transmute(force_integer_mv) };
14175 force_integer_mv as u64
14176 });
14177 __bindgen_bitfield_unit.set(7usize, 1u8, {
14178 let frame_size_override_flag: u32 =
14179 unsafe { ::core::mem::transmute(frame_size_override_flag) };
14180 frame_size_override_flag as u64
14181 });
14182 __bindgen_bitfield_unit.set(8usize, 1u8, {
14183 let buffer_removal_time_present_flag: u32 =
14184 unsafe { ::core::mem::transmute(buffer_removal_time_present_flag) };
14185 buffer_removal_time_present_flag as u64
14186 });
14187 __bindgen_bitfield_unit.set(9usize, 1u8, {
14188 let allow_intrabc: u32 = unsafe { ::core::mem::transmute(allow_intrabc) };
14189 allow_intrabc as u64
14190 });
14191 __bindgen_bitfield_unit.set(10usize, 1u8, {
14192 let frame_refs_short_signaling: u32 =
14193 unsafe { ::core::mem::transmute(frame_refs_short_signaling) };
14194 frame_refs_short_signaling as u64
14195 });
14196 __bindgen_bitfield_unit.set(11usize, 1u8, {
14197 let allow_high_precision_mv: u32 =
14198 unsafe { ::core::mem::transmute(allow_high_precision_mv) };
14199 allow_high_precision_mv as u64
14200 });
14201 __bindgen_bitfield_unit.set(12usize, 1u8, {
14202 let is_motion_mode_switchable: u32 =
14203 unsafe { ::core::mem::transmute(is_motion_mode_switchable) };
14204 is_motion_mode_switchable as u64
14205 });
14206 __bindgen_bitfield_unit.set(13usize, 1u8, {
14207 let use_ref_frame_mvs: u32 = unsafe { ::core::mem::transmute(use_ref_frame_mvs) };
14208 use_ref_frame_mvs as u64
14209 });
14210 __bindgen_bitfield_unit.set(14usize, 1u8, {
14211 let disable_frame_end_update_cdf: u32 =
14212 unsafe { ::core::mem::transmute(disable_frame_end_update_cdf) };
14213 disable_frame_end_update_cdf as u64
14214 });
14215 __bindgen_bitfield_unit.set(15usize, 1u8, {
14216 let allow_warped_motion: u32 = unsafe { ::core::mem::transmute(allow_warped_motion) };
14217 allow_warped_motion as u64
14218 });
14219 __bindgen_bitfield_unit.set(16usize, 1u8, {
14220 let reduced_tx_set: u32 = unsafe { ::core::mem::transmute(reduced_tx_set) };
14221 reduced_tx_set as u64
14222 });
14223 __bindgen_bitfield_unit.set(17usize, 1u8, {
14224 let skip_mode_present: u32 = unsafe { ::core::mem::transmute(skip_mode_present) };
14225 skip_mode_present as u64
14226 });
14227 __bindgen_bitfield_unit.set(18usize, 1u8, {
14228 let delta_q_present: u32 = unsafe { ::core::mem::transmute(delta_q_present) };
14229 delta_q_present as u64
14230 });
14231 __bindgen_bitfield_unit.set(19usize, 1u8, {
14232 let delta_lf_present: u32 = unsafe { ::core::mem::transmute(delta_lf_present) };
14233 delta_lf_present as u64
14234 });
14235 __bindgen_bitfield_unit.set(20usize, 1u8, {
14236 let delta_lf_multi: u32 = unsafe { ::core::mem::transmute(delta_lf_multi) };
14237 delta_lf_multi as u64
14238 });
14239 __bindgen_bitfield_unit.set(21usize, 1u8, {
14240 let segmentation_enabled: u32 = unsafe { ::core::mem::transmute(segmentation_enabled) };
14241 segmentation_enabled as u64
14242 });
14243 __bindgen_bitfield_unit.set(22usize, 1u8, {
14244 let segmentation_update_map: u32 =
14245 unsafe { ::core::mem::transmute(segmentation_update_map) };
14246 segmentation_update_map as u64
14247 });
14248 __bindgen_bitfield_unit.set(23usize, 1u8, {
14249 let segmentation_temporal_update: u32 =
14250 unsafe { ::core::mem::transmute(segmentation_temporal_update) };
14251 segmentation_temporal_update as u64
14252 });
14253 __bindgen_bitfield_unit.set(24usize, 1u8, {
14254 let segmentation_update_data: u32 =
14255 unsafe { ::core::mem::transmute(segmentation_update_data) };
14256 segmentation_update_data as u64
14257 });
14258 __bindgen_bitfield_unit.set(25usize, 1u8, {
14259 let UsesLr: u32 = unsafe { ::core::mem::transmute(UsesLr) };
14260 UsesLr as u64
14261 });
14262 __bindgen_bitfield_unit.set(26usize, 1u8, {
14263 let usesChromaLr: u32 = unsafe { ::core::mem::transmute(usesChromaLr) };
14264 usesChromaLr as u64
14265 });
14266 __bindgen_bitfield_unit.set(27usize, 1u8, {
14267 let show_frame: u32 = unsafe { ::core::mem::transmute(show_frame) };
14268 show_frame as u64
14269 });
14270 __bindgen_bitfield_unit.set(28usize, 1u8, {
14271 let showable_frame: u32 = unsafe { ::core::mem::transmute(showable_frame) };
14272 showable_frame as u64
14273 });
14274 __bindgen_bitfield_unit.set(29usize, 3u8, {
14275 let reserved: u32 = unsafe { ::core::mem::transmute(reserved) };
14276 reserved as u64
14277 });
14278 __bindgen_bitfield_unit
14279 }
14280}
14281#[repr(C)]
14282#[derive(Debug, Copy, Clone)]
14283pub struct StdVideoEncodeAV1PictureInfo {
14284 pub flags: StdVideoEncodeAV1PictureInfoFlags,
14285 pub frame_type: StdVideoAV1FrameType,
14286 pub frame_presentation_time: u32,
14287 pub current_frame_id: u32,
14288 pub order_hint: u8,
14289 pub primary_ref_frame: u8,
14290 pub refresh_frame_flags: u8,
14291 pub coded_denom: u8,
14292 pub render_width_minus_1: u16,
14293 pub render_height_minus_1: u16,
14294 pub interpolation_filter: StdVideoAV1InterpolationFilter,
14295 pub TxMode: StdVideoAV1TxMode,
14296 pub delta_q_res: u8,
14297 pub delta_lf_res: u8,
14298 pub ref_order_hint: [u8; 8usize],
14299 pub ref_frame_idx: [i8; 7usize],
14300 pub reserved1: [u8; 3usize],
14301 pub delta_frame_id_minus_1: [u32; 7usize],
14302 pub pTileInfo: *const StdVideoAV1TileInfo,
14303 pub pQuantization: *const StdVideoAV1Quantization,
14304 pub pSegmentation: *const StdVideoAV1Segmentation,
14305 pub pLoopFilter: *const StdVideoAV1LoopFilter,
14306 pub pCDEF: *const StdVideoAV1CDEF,
14307 pub pLoopRestoration: *const StdVideoAV1LoopRestoration,
14308 pub pGlobalMotion: *const StdVideoAV1GlobalMotion,
14309 pub pExtensionHeader: *const StdVideoEncodeAV1ExtensionHeader,
14310 pub pBufferRemovalTimes: *const u32,
14311}
14312#[test]
14313fn bindgen_test_layout_StdVideoEncodeAV1PictureInfo() {
14314 const UNINIT: ::core::mem::MaybeUninit<StdVideoEncodeAV1PictureInfo> =
14315 ::core::mem::MaybeUninit::uninit();
14316 let ptr = UNINIT.as_ptr();
14317 assert_eq!(
14318 ::core::mem::size_of::<StdVideoEncodeAV1PictureInfo>(),
14319 152usize,
14320 concat!("Size of: ", stringify!(StdVideoEncodeAV1PictureInfo))
14321 );
14322 assert_eq!(
14323 ::core::mem::align_of::<StdVideoEncodeAV1PictureInfo>(),
14324 8usize,
14325 concat!("Alignment of ", stringify!(StdVideoEncodeAV1PictureInfo))
14326 );
14327 assert_eq!(
14328 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
14329 0usize,
14330 concat!(
14331 "Offset of field: ",
14332 stringify!(StdVideoEncodeAV1PictureInfo),
14333 "::",
14334 stringify!(flags)
14335 )
14336 );
14337 assert_eq!(
14338 unsafe { ::core::ptr::addr_of!((*ptr).frame_type) as usize - ptr as usize },
14339 4usize,
14340 concat!(
14341 "Offset of field: ",
14342 stringify!(StdVideoEncodeAV1PictureInfo),
14343 "::",
14344 stringify!(frame_type)
14345 )
14346 );
14347 assert_eq!(
14348 unsafe { ::core::ptr::addr_of!((*ptr).frame_presentation_time) as usize - ptr as usize },
14349 8usize,
14350 concat!(
14351 "Offset of field: ",
14352 stringify!(StdVideoEncodeAV1PictureInfo),
14353 "::",
14354 stringify!(frame_presentation_time)
14355 )
14356 );
14357 assert_eq!(
14358 unsafe { ::core::ptr::addr_of!((*ptr).current_frame_id) as usize - ptr as usize },
14359 12usize,
14360 concat!(
14361 "Offset of field: ",
14362 stringify!(StdVideoEncodeAV1PictureInfo),
14363 "::",
14364 stringify!(current_frame_id)
14365 )
14366 );
14367 assert_eq!(
14368 unsafe { ::core::ptr::addr_of!((*ptr).order_hint) as usize - ptr as usize },
14369 16usize,
14370 concat!(
14371 "Offset of field: ",
14372 stringify!(StdVideoEncodeAV1PictureInfo),
14373 "::",
14374 stringify!(order_hint)
14375 )
14376 );
14377 assert_eq!(
14378 unsafe { ::core::ptr::addr_of!((*ptr).primary_ref_frame) as usize - ptr as usize },
14379 17usize,
14380 concat!(
14381 "Offset of field: ",
14382 stringify!(StdVideoEncodeAV1PictureInfo),
14383 "::",
14384 stringify!(primary_ref_frame)
14385 )
14386 );
14387 assert_eq!(
14388 unsafe { ::core::ptr::addr_of!((*ptr).refresh_frame_flags) as usize - ptr as usize },
14389 18usize,
14390 concat!(
14391 "Offset of field: ",
14392 stringify!(StdVideoEncodeAV1PictureInfo),
14393 "::",
14394 stringify!(refresh_frame_flags)
14395 )
14396 );
14397 assert_eq!(
14398 unsafe { ::core::ptr::addr_of!((*ptr).coded_denom) as usize - ptr as usize },
14399 19usize,
14400 concat!(
14401 "Offset of field: ",
14402 stringify!(StdVideoEncodeAV1PictureInfo),
14403 "::",
14404 stringify!(coded_denom)
14405 )
14406 );
14407 assert_eq!(
14408 unsafe { ::core::ptr::addr_of!((*ptr).render_width_minus_1) as usize - ptr as usize },
14409 20usize,
14410 concat!(
14411 "Offset of field: ",
14412 stringify!(StdVideoEncodeAV1PictureInfo),
14413 "::",
14414 stringify!(render_width_minus_1)
14415 )
14416 );
14417 assert_eq!(
14418 unsafe { ::core::ptr::addr_of!((*ptr).render_height_minus_1) as usize - ptr as usize },
14419 22usize,
14420 concat!(
14421 "Offset of field: ",
14422 stringify!(StdVideoEncodeAV1PictureInfo),
14423 "::",
14424 stringify!(render_height_minus_1)
14425 )
14426 );
14427 assert_eq!(
14428 unsafe { ::core::ptr::addr_of!((*ptr).interpolation_filter) as usize - ptr as usize },
14429 24usize,
14430 concat!(
14431 "Offset of field: ",
14432 stringify!(StdVideoEncodeAV1PictureInfo),
14433 "::",
14434 stringify!(interpolation_filter)
14435 )
14436 );
14437 assert_eq!(
14438 unsafe { ::core::ptr::addr_of!((*ptr).TxMode) as usize - ptr as usize },
14439 28usize,
14440 concat!(
14441 "Offset of field: ",
14442 stringify!(StdVideoEncodeAV1PictureInfo),
14443 "::",
14444 stringify!(TxMode)
14445 )
14446 );
14447 assert_eq!(
14448 unsafe { ::core::ptr::addr_of!((*ptr).delta_q_res) as usize - ptr as usize },
14449 32usize,
14450 concat!(
14451 "Offset of field: ",
14452 stringify!(StdVideoEncodeAV1PictureInfo),
14453 "::",
14454 stringify!(delta_q_res)
14455 )
14456 );
14457 assert_eq!(
14458 unsafe { ::core::ptr::addr_of!((*ptr).delta_lf_res) as usize - ptr as usize },
14459 33usize,
14460 concat!(
14461 "Offset of field: ",
14462 stringify!(StdVideoEncodeAV1PictureInfo),
14463 "::",
14464 stringify!(delta_lf_res)
14465 )
14466 );
14467 assert_eq!(
14468 unsafe { ::core::ptr::addr_of!((*ptr).ref_order_hint) as usize - ptr as usize },
14469 34usize,
14470 concat!(
14471 "Offset of field: ",
14472 stringify!(StdVideoEncodeAV1PictureInfo),
14473 "::",
14474 stringify!(ref_order_hint)
14475 )
14476 );
14477 assert_eq!(
14478 unsafe { ::core::ptr::addr_of!((*ptr).ref_frame_idx) as usize - ptr as usize },
14479 42usize,
14480 concat!(
14481 "Offset of field: ",
14482 stringify!(StdVideoEncodeAV1PictureInfo),
14483 "::",
14484 stringify!(ref_frame_idx)
14485 )
14486 );
14487 assert_eq!(
14488 unsafe { ::core::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize },
14489 49usize,
14490 concat!(
14491 "Offset of field: ",
14492 stringify!(StdVideoEncodeAV1PictureInfo),
14493 "::",
14494 stringify!(reserved1)
14495 )
14496 );
14497 assert_eq!(
14498 unsafe { ::core::ptr::addr_of!((*ptr).delta_frame_id_minus_1) as usize - ptr as usize },
14499 52usize,
14500 concat!(
14501 "Offset of field: ",
14502 stringify!(StdVideoEncodeAV1PictureInfo),
14503 "::",
14504 stringify!(delta_frame_id_minus_1)
14505 )
14506 );
14507 assert_eq!(
14508 unsafe { ::core::ptr::addr_of!((*ptr).pTileInfo) as usize - ptr as usize },
14509 80usize,
14510 concat!(
14511 "Offset of field: ",
14512 stringify!(StdVideoEncodeAV1PictureInfo),
14513 "::",
14514 stringify!(pTileInfo)
14515 )
14516 );
14517 assert_eq!(
14518 unsafe { ::core::ptr::addr_of!((*ptr).pQuantization) as usize - ptr as usize },
14519 88usize,
14520 concat!(
14521 "Offset of field: ",
14522 stringify!(StdVideoEncodeAV1PictureInfo),
14523 "::",
14524 stringify!(pQuantization)
14525 )
14526 );
14527 assert_eq!(
14528 unsafe { ::core::ptr::addr_of!((*ptr).pSegmentation) as usize - ptr as usize },
14529 96usize,
14530 concat!(
14531 "Offset of field: ",
14532 stringify!(StdVideoEncodeAV1PictureInfo),
14533 "::",
14534 stringify!(pSegmentation)
14535 )
14536 );
14537 assert_eq!(
14538 unsafe { ::core::ptr::addr_of!((*ptr).pLoopFilter) as usize - ptr as usize },
14539 104usize,
14540 concat!(
14541 "Offset of field: ",
14542 stringify!(StdVideoEncodeAV1PictureInfo),
14543 "::",
14544 stringify!(pLoopFilter)
14545 )
14546 );
14547 assert_eq!(
14548 unsafe { ::core::ptr::addr_of!((*ptr).pCDEF) as usize - ptr as usize },
14549 112usize,
14550 concat!(
14551 "Offset of field: ",
14552 stringify!(StdVideoEncodeAV1PictureInfo),
14553 "::",
14554 stringify!(pCDEF)
14555 )
14556 );
14557 assert_eq!(
14558 unsafe { ::core::ptr::addr_of!((*ptr).pLoopRestoration) as usize - ptr as usize },
14559 120usize,
14560 concat!(
14561 "Offset of field: ",
14562 stringify!(StdVideoEncodeAV1PictureInfo),
14563 "::",
14564 stringify!(pLoopRestoration)
14565 )
14566 );
14567 assert_eq!(
14568 unsafe { ::core::ptr::addr_of!((*ptr).pGlobalMotion) as usize - ptr as usize },
14569 128usize,
14570 concat!(
14571 "Offset of field: ",
14572 stringify!(StdVideoEncodeAV1PictureInfo),
14573 "::",
14574 stringify!(pGlobalMotion)
14575 )
14576 );
14577 assert_eq!(
14578 unsafe { ::core::ptr::addr_of!((*ptr).pExtensionHeader) as usize - ptr as usize },
14579 136usize,
14580 concat!(
14581 "Offset of field: ",
14582 stringify!(StdVideoEncodeAV1PictureInfo),
14583 "::",
14584 stringify!(pExtensionHeader)
14585 )
14586 );
14587 assert_eq!(
14588 unsafe { ::core::ptr::addr_of!((*ptr).pBufferRemovalTimes) as usize - ptr as usize },
14589 144usize,
14590 concat!(
14591 "Offset of field: ",
14592 stringify!(StdVideoEncodeAV1PictureInfo),
14593 "::",
14594 stringify!(pBufferRemovalTimes)
14595 )
14596 );
14597}
14598#[repr(C)]
14599#[derive(Debug, Copy, Clone)]
14600pub struct StdVideoEncodeAV1ReferenceInfoFlags {
14601 pub _bitfield_align_1: [u32; 0],
14602 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
14603}
14604#[test]
14605fn bindgen_test_layout_StdVideoEncodeAV1ReferenceInfoFlags() {
14606 assert_eq!(
14607 ::core::mem::size_of::<StdVideoEncodeAV1ReferenceInfoFlags>(),
14608 4usize,
14609 concat!("Size of: ", stringify!(StdVideoEncodeAV1ReferenceInfoFlags))
14610 );
14611 assert_eq!(
14612 ::core::mem::align_of::<StdVideoEncodeAV1ReferenceInfoFlags>(),
14613 4usize,
14614 concat!(
14615 "Alignment of ",
14616 stringify!(StdVideoEncodeAV1ReferenceInfoFlags)
14617 )
14618 );
14619}
14620impl StdVideoEncodeAV1ReferenceInfoFlags {
14621 #[inline]
14622 pub fn disable_frame_end_update_cdf(&self) -> u32 {
14623 unsafe { ::core::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
14624 }
14625 #[inline]
14626 pub fn set_disable_frame_end_update_cdf(&mut self, val: u32) {
14627 unsafe {
14628 let val: u32 = ::core::mem::transmute(val);
14629 self._bitfield_1.set(0usize, 1u8, val as u64)
14630 }
14631 }
14632 #[inline]
14633 pub fn segmentation_enabled(&self) -> u32 {
14634 unsafe { ::core::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
14635 }
14636 #[inline]
14637 pub fn set_segmentation_enabled(&mut self, val: u32) {
14638 unsafe {
14639 let val: u32 = ::core::mem::transmute(val);
14640 self._bitfield_1.set(1usize, 1u8, val as u64)
14641 }
14642 }
14643 #[inline]
14644 pub fn reserved(&self) -> u32 {
14645 unsafe { ::core::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) }
14646 }
14647 #[inline]
14648 pub fn set_reserved(&mut self, val: u32) {
14649 unsafe {
14650 let val: u32 = ::core::mem::transmute(val);
14651 self._bitfield_1.set(2usize, 30u8, val as u64)
14652 }
14653 }
14654 #[inline]
14655 pub fn new_bitfield_1(
14656 disable_frame_end_update_cdf: u32,
14657 segmentation_enabled: u32,
14658 reserved: u32,
14659 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
14660 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
14661 __bindgen_bitfield_unit.set(0usize, 1u8, {
14662 let disable_frame_end_update_cdf: u32 =
14663 unsafe { ::core::mem::transmute(disable_frame_end_update_cdf) };
14664 disable_frame_end_update_cdf as u64
14665 });
14666 __bindgen_bitfield_unit.set(1usize, 1u8, {
14667 let segmentation_enabled: u32 = unsafe { ::core::mem::transmute(segmentation_enabled) };
14668 segmentation_enabled as u64
14669 });
14670 __bindgen_bitfield_unit.set(2usize, 30u8, {
14671 let reserved: u32 = unsafe { ::core::mem::transmute(reserved) };
14672 reserved as u64
14673 });
14674 __bindgen_bitfield_unit
14675 }
14676}
14677#[repr(C)]
14678#[derive(Debug, Copy, Clone)]
14679pub struct StdVideoEncodeAV1ReferenceInfo {
14680 pub flags: StdVideoEncodeAV1ReferenceInfoFlags,
14681 pub RefFrameId: u32,
14682 pub frame_type: StdVideoAV1FrameType,
14683 pub OrderHint: u8,
14684 pub reserved1: [u8; 3usize],
14685 pub pExtensionHeader: *const StdVideoEncodeAV1ExtensionHeader,
14686}
14687#[test]
14688fn bindgen_test_layout_StdVideoEncodeAV1ReferenceInfo() {
14689 const UNINIT: ::core::mem::MaybeUninit<StdVideoEncodeAV1ReferenceInfo> =
14690 ::core::mem::MaybeUninit::uninit();
14691 let ptr = UNINIT.as_ptr();
14692 assert_eq!(
14693 ::core::mem::size_of::<StdVideoEncodeAV1ReferenceInfo>(),
14694 24usize,
14695 concat!("Size of: ", stringify!(StdVideoEncodeAV1ReferenceInfo))
14696 );
14697 assert_eq!(
14698 ::core::mem::align_of::<StdVideoEncodeAV1ReferenceInfo>(),
14699 8usize,
14700 concat!("Alignment of ", stringify!(StdVideoEncodeAV1ReferenceInfo))
14701 );
14702 assert_eq!(
14703 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
14704 0usize,
14705 concat!(
14706 "Offset of field: ",
14707 stringify!(StdVideoEncodeAV1ReferenceInfo),
14708 "::",
14709 stringify!(flags)
14710 )
14711 );
14712 assert_eq!(
14713 unsafe { ::core::ptr::addr_of!((*ptr).RefFrameId) as usize - ptr as usize },
14714 4usize,
14715 concat!(
14716 "Offset of field: ",
14717 stringify!(StdVideoEncodeAV1ReferenceInfo),
14718 "::",
14719 stringify!(RefFrameId)
14720 )
14721 );
14722 assert_eq!(
14723 unsafe { ::core::ptr::addr_of!((*ptr).frame_type) as usize - ptr as usize },
14724 8usize,
14725 concat!(
14726 "Offset of field: ",
14727 stringify!(StdVideoEncodeAV1ReferenceInfo),
14728 "::",
14729 stringify!(frame_type)
14730 )
14731 );
14732 assert_eq!(
14733 unsafe { ::core::ptr::addr_of!((*ptr).OrderHint) as usize - ptr as usize },
14734 12usize,
14735 concat!(
14736 "Offset of field: ",
14737 stringify!(StdVideoEncodeAV1ReferenceInfo),
14738 "::",
14739 stringify!(OrderHint)
14740 )
14741 );
14742 assert_eq!(
14743 unsafe { ::core::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize },
14744 13usize,
14745 concat!(
14746 "Offset of field: ",
14747 stringify!(StdVideoEncodeAV1ReferenceInfo),
14748 "::",
14749 stringify!(reserved1)
14750 )
14751 );
14752 assert_eq!(
14753 unsafe { ::core::ptr::addr_of!((*ptr).pExtensionHeader) as usize - ptr as usize },
14754 16usize,
14755 concat!(
14756 "Offset of field: ",
14757 stringify!(StdVideoEncodeAV1ReferenceInfo),
14758 "::",
14759 stringify!(pExtensionHeader)
14760 )
14761 );
14762}