projects / nihav-player.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
nihed-cros-libva: expose and document some generated data structures
[nihav-player.git] / nihed-cros-libva / src / bindings / va.rs
CommitLineData
68362724
KS		 1/* automatically generated by tools/bindgen-all-the-things */
2
3#![allow(clippy::missing_safety_doc)]
4#![allow(clippy::upper_case_acronyms)]
5#![allow(non_upper_case_globals)]
6#![allow(non_camel_case_types)]
7#![allow(non_snake_case)]
8#![allow(dead_code)]
9
10pub mod constants;
11
12#[repr(C)]
13#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
14pub struct __BindgenBitfieldUnit<Storage> {
15 storage: Storage,
16}
17impl<Storage> __BindgenBitfieldUnit<Storage> {
18 #[inline]
19 pub const fn new(storage: Storage) -> Self {
20 Self { storage }
21 }
22}
23impl<Storage> __BindgenBitfieldUnit<Storage>
24where
25 Storage: AsRef<[u8]> + AsMut<[u8]>,
26{
27 #[inline]
28 pub fn get_bit(&self, index: usize) -> bool {
29 debug_assert!(index / 8 < self.storage.as_ref().len());
30 let byte_index = index / 8;
31 let byte = self.storage.as_ref()[byte_index];
32 let bit_index = if cfg!(target_endian = "big") {
33 7 - (index % 8)
34 } else {
35 index % 8
36 };
37 let mask = 1 << bit_index;
38 byte & mask == mask
39 }
40 #[inline]
41 pub fn set_bit(&mut self, index: usize, val: bool) {
42 debug_assert!(index / 8 < self.storage.as_ref().len());
43 let byte_index = index / 8;
44 let byte = &mut self.storage.as_mut()[byte_index];
45 let bit_index = if cfg!(target_endian = "big") {
46 7 - (index % 8)
47 } else {
48 index % 8
49 };
50 let mask = 1 << bit_index;
51 if val {
52 *byte |= mask;
53 } else {
54 *byte &= !mask;
55 }
56 }
57 #[inline]
58 pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
59 debug_assert!(bit_width <= 64);
60 debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
61 debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
62 let mut val = 0;
63 for i in 0..(bit_width as usize) {
64 if self.get_bit(i + bit_offset) {
65 let index = if cfg!(target_endian = "big") {
66 bit_width as usize - 1 - i
67 } else {
68 i
69 };
70 val |= 1 << index;
71 }
72 }
73 val
74 }
75 #[inline]
76 pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
77 debug_assert!(bit_width <= 64);
78 debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
79 debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
80 for i in 0..(bit_width as usize) {
81 let mask = 1 << i;
82 let val_bit_is_set = val & mask == mask;
83 let index = if cfg!(target_endian = "big") {
84 bit_width as usize - 1 - i
85 } else {
86 i
87 };
88 self.set_bit(index + bit_offset, val_bit_is_set);
89 }
90 }
91}
92pub type __int8_t = ::std::os::raw::c_schar;
93pub type __uint8_t = ::std::os::raw::c_uchar;
94pub type __int16_t = ::std::os::raw::c_short;
95pub type __uint16_t = ::std::os::raw::c_ushort;
96pub type __int32_t = ::std::os::raw::c_int;
97pub type __uint32_t = ::std::os::raw::c_uint;
98pub type __uint64_t = ::std::os::raw::c_ulong;
99pub type VADisplay = *mut ::std::os::raw::c_void;
100pub type VAStatus = ::std::os::raw::c_int;
101extern "C" {
102 pub fn vaErrorStr(error_status: VAStatus) -> *const ::std::os::raw::c_char;
103}
104#[repr(C)]
105#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
106pub struct _VAMotionVector {
107 pub mv0: [i16; 2usize],
108 pub mv1: [i16; 2usize],
109}
110pub type VAMotionVector = _VAMotionVector;
111pub type VAMessageCallback = ::std::option::Option<
112 unsafe extern "C" fn(
113 user_context: *mut ::std::os::raw::c_void,
114 message: *const ::std::os::raw::c_char,
115 ),
116>;
117extern "C" {
118 pub fn vaSetErrorCallback(
119 dpy: VADisplay,
120 callback: VAMessageCallback,
121 user_context: *mut ::std::os::raw::c_void,
122 ) -> VAMessageCallback;
123}
124extern "C" {
125 pub fn vaSetInfoCallback(
126 dpy: VADisplay,
127 callback: VAMessageCallback,
128 user_context: *mut ::std::os::raw::c_void,
129 ) -> VAMessageCallback;
130}
131extern "C" {
132 pub fn vaDisplayIsValid(dpy: VADisplay) -> ::std::os::raw::c_int;
133}
134extern "C" {
135 pub fn vaSetDriverName(dpy: VADisplay, driver_name: *mut ::std::os::raw::c_char) -> VAStatus;
136}
137extern "C" {
138 pub fn vaInitialize(
139 dpy: VADisplay,
140 major_version: *mut ::std::os::raw::c_int,
141 minor_version: *mut ::std::os::raw::c_int,
142 ) -> VAStatus;
143}
144extern "C" {
145 pub fn vaTerminate(dpy: VADisplay) -> VAStatus;
146}
147extern "C" {
148 pub fn vaQueryVendorString(dpy: VADisplay) -> *const ::std::os::raw::c_char;
149}
150pub type VAPrivFunc = ::std::option::Option<unsafe extern "C" fn() -> ::std::os::raw::c_int>;
151extern "C" {
152 pub fn vaGetLibFunc(dpy: VADisplay, func: *const ::std::os::raw::c_char) -> VAPrivFunc;
153}
154pub mod VAProfile {
155 pub type Type = ::std::os::raw::c_int;
156 pub const VAProfileNone: Type = -1;
157 pub const VAProfileMPEG2Simple: Type = 0;
158 pub const VAProfileMPEG2Main: Type = 1;
159 pub const VAProfileMPEG4Simple: Type = 2;
160 pub const VAProfileMPEG4AdvancedSimple: Type = 3;
161 pub const VAProfileMPEG4Main: Type = 4;
162 pub const VAProfileH264Baseline: Type = 5;
163 pub const VAProfileH264Main: Type = 6;
164 pub const VAProfileH264High: Type = 7;
165 pub const VAProfileVC1Simple: Type = 8;
166 pub const VAProfileVC1Main: Type = 9;
167 pub const VAProfileVC1Advanced: Type = 10;
168 pub const VAProfileH263Baseline: Type = 11;
169 pub const VAProfileJPEGBaseline: Type = 12;
170 pub const VAProfileH264ConstrainedBaseline: Type = 13;
171 pub const VAProfileVP8Version0_3: Type = 14;
172 pub const VAProfileH264MultiviewHigh: Type = 15;
173 pub const VAProfileH264StereoHigh: Type = 16;
174 pub const VAProfileHEVCMain: Type = 17;
175 pub const VAProfileHEVCMain10: Type = 18;
176 pub const VAProfileVP9Profile0: Type = 19;
177 pub const VAProfileVP9Profile1: Type = 20;
178 pub const VAProfileVP9Profile2: Type = 21;
179 pub const VAProfileVP9Profile3: Type = 22;
180 pub const VAProfileHEVCMain12: Type = 23;
181 pub const VAProfileHEVCMain422_10: Type = 24;
182 pub const VAProfileHEVCMain422_12: Type = 25;
183 pub const VAProfileHEVCMain444: Type = 26;
184 pub const VAProfileHEVCMain444_10: Type = 27;
185 pub const VAProfileHEVCMain444_12: Type = 28;
186 pub const VAProfileHEVCSccMain: Type = 29;
187 pub const VAProfileHEVCSccMain10: Type = 30;
188 pub const VAProfileHEVCSccMain444: Type = 31;
189 pub const VAProfileAV1Profile0: Type = 32;
190 pub const VAProfileAV1Profile1: Type = 33;
191 pub const VAProfileHEVCSccMain444_10: Type = 34;
192 pub const VAProfileProtected: Type = 35;
193}
194pub mod VAEntrypoint {
195 pub type Type = ::std::os::raw::c_uint;
196 pub const VAEntrypointVLD: Type = 1;
197 pub const VAEntrypointIZZ: Type = 2;
198 pub const VAEntrypointIDCT: Type = 3;
199 pub const VAEntrypointMoComp: Type = 4;
200 pub const VAEntrypointDeblocking: Type = 5;
201 pub const VAEntrypointEncSlice: Type = 6;
202 pub const VAEntrypointEncPicture: Type = 7;
203 pub const VAEntrypointEncSliceLP: Type = 8;
204 pub const VAEntrypointVideoProc: Type = 10;
205 pub const VAEntrypointFEI: Type = 11;
206 pub const VAEntrypointStats: Type = 12;
207 pub const VAEntrypointProtectedTEEComm: Type = 13;
208 pub const VAEntrypointProtectedContent: Type = 14;
209}
210pub mod VAConfigAttribType {
211 pub type Type = ::std::os::raw::c_uint;
212 pub const VAConfigAttribRTFormat: Type = 0;
213 pub const VAConfigAttribSpatialResidual: Type = 1;
214 pub const VAConfigAttribSpatialClipping: Type = 2;
215 pub const VAConfigAttribIntraResidual: Type = 3;
216 pub const VAConfigAttribEncryption: Type = 4;
217 pub const VAConfigAttribRateControl: Type = 5;
218 pub const VAConfigAttribDecSliceMode: Type = 6;
219 pub const VAConfigAttribDecJPEG: Type = 7;
220 pub const VAConfigAttribDecProcessing: Type = 8;
221 pub const VAConfigAttribEncPackedHeaders: Type = 10;
222 pub const VAConfigAttribEncInterlaced: Type = 11;
223 pub const VAConfigAttribEncMaxRefFrames: Type = 13;
224 pub const VAConfigAttribEncMaxSlices: Type = 14;
225 pub const VAConfigAttribEncSliceStructure: Type = 15;
226 pub const VAConfigAttribEncMacroblockInfo: Type = 16;
227 pub const VAConfigAttribMaxPictureWidth: Type = 18;
228 pub const VAConfigAttribMaxPictureHeight: Type = 19;
229 pub const VAConfigAttribEncJPEG: Type = 20;
230 pub const VAConfigAttribEncQualityRange: Type = 21;
231 pub const VAConfigAttribEncQuantization: Type = 22;
232 pub const VAConfigAttribEncIntraRefresh: Type = 23;
233 pub const VAConfigAttribEncSkipFrame: Type = 24;
234 pub const VAConfigAttribEncROI: Type = 25;
235 pub const VAConfigAttribEncRateControlExt: Type = 26;
236 pub const VAConfigAttribProcessingRate: Type = 27;
237 pub const VAConfigAttribEncDirtyRect: Type = 28;
238 pub const VAConfigAttribEncParallelRateControl: Type = 29;
239 pub const VAConfigAttribEncDynamicScaling: Type = 30;
240 pub const VAConfigAttribFrameSizeToleranceSupport: Type = 31;
241 pub const VAConfigAttribFEIFunctionType: Type = 32;
242 pub const VAConfigAttribFEIMVPredictors: Type = 33;
243 pub const VAConfigAttribStats: Type = 34;
244 pub const VAConfigAttribEncTileSupport: Type = 35;
245 pub const VAConfigAttribCustomRoundingControl: Type = 36;
246 pub const VAConfigAttribQPBlockSize: Type = 37;
247 pub const VAConfigAttribMaxFrameSize: Type = 38;
248 pub const VAConfigAttribPredictionDirection: Type = 39;
249 pub const VAConfigAttribMultipleFrame: Type = 40;
250 pub const VAConfigAttribContextPriority: Type = 41;
251 pub const VAConfigAttribDecAV1Features: Type = 42;
252 pub const VAConfigAttribTEEType: Type = 43;
253 pub const VAConfigAttribTEETypeClient: Type = 44;
254 pub const VAConfigAttribProtectedContentCipherAlgorithm: Type = 45;
255 pub const VAConfigAttribProtectedContentCipherBlockSize: Type = 46;
256 pub const VAConfigAttribProtectedContentCipherMode: Type = 47;
257 pub const VAConfigAttribProtectedContentCipherSampleType: Type = 48;
258 pub const VAConfigAttribProtectedContentUsage: Type = 49;
259 pub const VAConfigAttribEncHEVCFeatures: Type = 50;
260 pub const VAConfigAttribEncHEVCBlockSizes: Type = 51;
261 pub const VAConfigAttribEncAV1: Type = 52;
262 pub const VAConfigAttribEncAV1Ext1: Type = 53;
263 pub const VAConfigAttribEncAV1Ext2: Type = 54;
264 pub const VAConfigAttribEncPerBlockControl: Type = 55;
265 pub const VAConfigAttribTypeMax: Type = 56;
266}
267#[repr(C)]
268#[derive(Debug, Copy, Clone, PartialEq, Eq)]
269pub struct _VAConfigAttrib {
270 pub type_: VAConfigAttribType::Type,
271 pub value: u32,
272}
273impl Default for _VAConfigAttrib {
274 fn default() -> Self {
275 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
276 unsafe {
277 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
278 s.assume_init()
279 }
280 }
281}
282pub type VAConfigAttrib = _VAConfigAttrib;
283extern "C" {
284 pub fn vaMaxNumProfiles(dpy: VADisplay) -> ::std::os::raw::c_int;
285}
286extern "C" {
287 pub fn vaMaxNumEntrypoints(dpy: VADisplay) -> ::std::os::raw::c_int;
288}
289extern "C" {
290 pub fn vaMaxNumConfigAttributes(dpy: VADisplay) -> ::std::os::raw::c_int;
291}
292extern "C" {
293 pub fn vaQueryConfigProfiles(
294 dpy: VADisplay,
295 profile_list: *mut VAProfile::Type,
296 num_profiles: *mut ::std::os::raw::c_int,
297 ) -> VAStatus;
298}
299extern "C" {
300 pub fn vaQueryConfigEntrypoints(
301 dpy: VADisplay,
302 profile: VAProfile::Type,
303 entrypoint_list: *mut VAEntrypoint::Type,
304 num_entrypoints: *mut ::std::os::raw::c_int,
305 ) -> VAStatus;
306}
307extern "C" {
308 pub fn vaGetConfigAttributes(
309 dpy: VADisplay,
310 profile: VAProfile::Type,
311 entrypoint: VAEntrypoint::Type,
312 attrib_list: *mut VAConfigAttrib,
313 num_attribs: ::std::os::raw::c_int,
314 ) -> VAStatus;
315}
316pub type VAGenericID = ::std::os::raw::c_uint;
317pub type VAConfigID = VAGenericID;
318extern "C" {
319 pub fn vaCreateConfig(
320 dpy: VADisplay,
321 profile: VAProfile::Type,
322 entrypoint: VAEntrypoint::Type,
323 attrib_list: *mut VAConfigAttrib,
324 num_attribs: ::std::os::raw::c_int,
325 config_id: *mut VAConfigID,
326 ) -> VAStatus;
327}
328extern "C" {
329 pub fn vaDestroyConfig(dpy: VADisplay, config_id: VAConfigID) -> VAStatus;
330}
331extern "C" {
332 pub fn vaQueryConfigAttributes(
333 dpy: VADisplay,
334 config_id: VAConfigID,
335 profile: *mut VAProfile::Type,
336 entrypoint: *mut VAEntrypoint::Type,
337 attrib_list: *mut VAConfigAttrib,
338 num_attribs: *mut ::std::os::raw::c_int,
339 ) -> VAStatus;
340}
341pub type VAContextID = VAGenericID;
342pub type VASurfaceID = VAGenericID;
343pub mod VAGenericValueType {
344 pub type Type = ::std::os::raw::c_uint;
345 pub const VAGenericValueTypeInteger: Type = 1;
346 pub const VAGenericValueTypeFloat: Type = 2;
347 pub const VAGenericValueTypePointer: Type = 3;
348 pub const VAGenericValueTypeFunc: Type = 4;
349}
350pub type VAGenericFunc = ::std::option::Option<unsafe extern "C" fn()>;
351#[repr(C)]
352#[derive(Copy, Clone)]
353pub struct _VAGenericValue {
354 pub type_: VAGenericValueType::Type,
355 pub value: _VAGenericValue__bindgen_ty_1,
356}
357#[repr(C)]
358#[derive(Copy, Clone)]
359pub union _VAGenericValue__bindgen_ty_1 {
360 pub i: i32,
361 pub f: f32,
362 pub p: *mut ::std::os::raw::c_void,
363 pub fn_: VAGenericFunc,
364}
365impl Default for _VAGenericValue__bindgen_ty_1 {
366 fn default() -> Self {
367 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
368 unsafe {
369 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
370 s.assume_init()
371 }
372 }
373}
374impl Default for _VAGenericValue {
375 fn default() -> Self {
376 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
377 unsafe {
378 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
379 s.assume_init()
380 }
381 }
382}
383pub type VAGenericValue = _VAGenericValue;
384pub mod VASurfaceAttribType {
385 pub type Type = ::std::os::raw::c_uint;
386 pub const VASurfaceAttribNone: Type = 0;
387 pub const VASurfaceAttribPixelFormat: Type = 1;
388 pub const VASurfaceAttribMinWidth: Type = 2;
389 pub const VASurfaceAttribMaxWidth: Type = 3;
390 pub const VASurfaceAttribMinHeight: Type = 4;
391 pub const VASurfaceAttribMaxHeight: Type = 5;
392 pub const VASurfaceAttribMemoryType: Type = 6;
393 pub const VASurfaceAttribExternalBufferDescriptor: Type = 7;
394 pub const VASurfaceAttribUsageHint: Type = 8;
395 pub const VASurfaceAttribDRMFormatModifiers: Type = 9;
396 pub const VASurfaceAttribCount: Type = 10;
397}
398#[repr(C)]
399#[derive(Copy, Clone)]
400pub struct _VASurfaceAttrib {
401 pub type_: VASurfaceAttribType::Type,
402 pub flags: u32,
403 pub value: VAGenericValue,
404}
405impl Default for _VASurfaceAttrib {
406 fn default() -> Self {
407 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
408 unsafe {
409 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
410 s.assume_init()
411 }
412 }
413}
414pub type VASurfaceAttrib = _VASurfaceAttrib;
415extern "C" {
416 pub fn vaQuerySurfaceAttributes(
417 dpy: VADisplay,
418 config: VAConfigID,
419 attrib_list: *mut VASurfaceAttrib,
420 num_attribs: *mut ::std::os::raw::c_uint,
421 ) -> VAStatus;
422}
423extern "C" {
424 pub fn vaCreateSurfaces(
425 dpy: VADisplay,
426 format: ::std::os::raw::c_uint,
427 width: ::std::os::raw::c_uint,
428 height: ::std::os::raw::c_uint,
429 surfaces: *mut VASurfaceID,
430 num_surfaces: ::std::os::raw::c_uint,
431 attrib_list: *mut VASurfaceAttrib,
432 num_attribs: ::std::os::raw::c_uint,
433 ) -> VAStatus;
434}
435extern "C" {
436 pub fn vaDestroySurfaces(
437 dpy: VADisplay,
438 surfaces: *mut VASurfaceID,
439 num_surfaces: ::std::os::raw::c_int,
440 ) -> VAStatus;
441}
442extern "C" {
443 pub fn vaCreateContext(
444 dpy: VADisplay,
445 config_id: VAConfigID,
446 picture_width: ::std::os::raw::c_int,
447 picture_height: ::std::os::raw::c_int,
448 flag: ::std::os::raw::c_int,
449 render_targets: *mut VASurfaceID,
450 num_render_targets: ::std::os::raw::c_int,
451 context: *mut VAContextID,
452 ) -> VAStatus;
453}
454extern "C" {
455 pub fn vaDestroyContext(dpy: VADisplay, context: VAContextID) -> VAStatus;
456}
457pub type VAMFContextID = VAGenericID;
458extern "C" {
459 pub fn vaCreateMFContext(dpy: VADisplay, mf_context: *mut VAMFContextID) -> VAStatus;
460}
461extern "C" {
462 pub fn vaMFAddContext(
463 dpy: VADisplay,
464 mf_context: VAMFContextID,
465 context: VAContextID,
466 ) -> VAStatus;
467}
468extern "C" {
469 pub fn vaMFReleaseContext(
470 dpy: VADisplay,
471 mf_context: VAMFContextID,
472 context: VAContextID,
473 ) -> VAStatus;
474}
475pub type VABufferID = VAGenericID;
476pub mod VABufferType {
477 pub type Type = ::std::os::raw::c_uint;
478 pub const VAPictureParameterBufferType: Type = 0;
479 pub const VAIQMatrixBufferType: Type = 1;
480 pub const VABitPlaneBufferType: Type = 2;
481 pub const VASliceGroupMapBufferType: Type = 3;
482 pub const VASliceParameterBufferType: Type = 4;
483 pub const VASliceDataBufferType: Type = 5;
484 pub const VAMacroblockParameterBufferType: Type = 6;
485 pub const VAResidualDataBufferType: Type = 7;
486 pub const VADeblockingParameterBufferType: Type = 8;
487 pub const VAImageBufferType: Type = 9;
488 pub const VAProtectedSliceDataBufferType: Type = 10;
489 pub const VAQMatrixBufferType: Type = 11;
490 pub const VAHuffmanTableBufferType: Type = 12;
491 pub const VAProbabilityBufferType: Type = 13;
492 pub const VAEncCodedBufferType: Type = 21;
493 pub const VAEncSequenceParameterBufferType: Type = 22;
494 pub const VAEncPictureParameterBufferType: Type = 23;
495 pub const VAEncSliceParameterBufferType: Type = 24;
496 pub const VAEncPackedHeaderParameterBufferType: Type = 25;
497 pub const VAEncPackedHeaderDataBufferType: Type = 26;
498 pub const VAEncMiscParameterBufferType: Type = 27;
499 pub const VAEncMacroblockParameterBufferType: Type = 28;
500 pub const VAEncMacroblockMapBufferType: Type = 29;
501 pub const VAEncQPBufferType: Type = 30;
502 pub const VAProcPipelineParameterBufferType: Type = 41;
503 pub const VAProcFilterParameterBufferType: Type = 42;
504 pub const VAEncFEIMVBufferType: Type = 43;
505 pub const VAEncFEIMBCodeBufferType: Type = 44;
506 pub const VAEncFEIDistortionBufferType: Type = 45;
507 pub const VAEncFEIMBControlBufferType: Type = 46;
508 pub const VAEncFEIMVPredictorBufferType: Type = 47;
509 pub const VAStatsStatisticsParameterBufferType: Type = 48;
510 pub const VAStatsStatisticsBufferType: Type = 49;
511 pub const VAStatsStatisticsBottomFieldBufferType: Type = 50;
512 pub const VAStatsMVBufferType: Type = 51;
513 pub const VAStatsMVPredictorBufferType: Type = 52;
514 pub const VAEncMacroblockDisableSkipMapBufferType: Type = 53;
515 pub const VAEncFEICTBCmdBufferType: Type = 54;
516 pub const VAEncFEICURecordBufferType: Type = 55;
517 pub const VADecodeStreamoutBufferType: Type = 56;
518 pub const VASubsetsParameterBufferType: Type = 57;
519 pub const VAContextParameterUpdateBufferType: Type = 58;
520 pub const VAProtectedSessionExecuteBufferType: Type = 59;
521 pub const VAEncryptionParameterBufferType: Type = 60;
522 pub const VAEncDeltaQpPerBlockBufferType: Type = 61;
523 pub const VABufferTypeMax: Type = 62;
524}
525#[repr(C)]
526#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
527pub struct _VAProcessingRateParameterEnc {
528 pub level_idc: u8,
529 pub reserved: [u8; 3usize],
530 pub quality_level: u32,
531 pub intra_period: u32,
532 pub ip_period: u32,
533}
534pub type VAProcessingRateParameterEnc = _VAProcessingRateParameterEnc;
535#[repr(C)]
536#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
537pub struct _VAProcessingRateParameterDec {
538 pub level_idc: u8,
539 pub reserved0: [u8; 3usize],
540 pub reserved: u32,
541}
542pub type VAProcessingRateParameterDec = _VAProcessingRateParameterDec;
543#[repr(C)]
544#[derive(Copy, Clone)]
545pub struct _VAProcessingRateParameter {
546 pub __bindgen_anon_1: _VAProcessingRateParameter__bindgen_ty_1,
547}
548#[repr(C)]
549#[derive(Copy, Clone)]
550pub union _VAProcessingRateParameter__bindgen_ty_1 {
551 pub proc_buf_enc: VAProcessingRateParameterEnc,
552 pub proc_buf_dec: VAProcessingRateParameterDec,
553}
554impl Default for _VAProcessingRateParameter__bindgen_ty_1 {
555 fn default() -> Self {
556 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
557 unsafe {
558 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
559 s.assume_init()
560 }
561 }
562}
563impl Default for _VAProcessingRateParameter {
564 fn default() -> Self {
565 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
566 unsafe {
567 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
568 s.assume_init()
569 }
570 }
571}
572pub type VAProcessingRateParameter = _VAProcessingRateParameter;
573extern "C" {
574 pub fn vaQueryProcessingRate(
575 dpy: VADisplay,
576 config: VAConfigID,
577 proc_buf: *mut VAProcessingRateParameter,
578 processing_rate: *mut ::std::os::raw::c_uint,
579 ) -> VAStatus;
580}
581#[repr(C)]
582#[derive(Copy, Clone)]
583pub struct _VAPictureParameterBufferMPEG2 {
584 pub horizontal_size: u16,
585 pub vertical_size: u16,
586 pub forward_reference_picture: VASurfaceID,
587 pub backward_reference_picture: VASurfaceID,
588 pub picture_coding_type: i32,
589 pub f_code: i32,
590 pub picture_coding_extension: _VAPictureParameterBufferMPEG2__bindgen_ty_1,
591 pub va_reserved: [u32; 4usize],
592}
593#[repr(C)]
594#[derive(Copy, Clone)]
595pub union _VAPictureParameterBufferMPEG2__bindgen_ty_1 {
596 pub bits: _VAPictureParameterBufferMPEG2__bindgen_ty_1__bindgen_ty_1,
597 pub value: u32,
598}
599#[repr(C)]
600#[repr(align(4))]
601#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
602pub struct _VAPictureParameterBufferMPEG2__bindgen_ty_1__bindgen_ty_1 {
603 pub _bitfield_align_1: [u8; 0],
604 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
605 pub __bindgen_padding_0: u16,
606}
607impl _VAPictureParameterBufferMPEG2__bindgen_ty_1__bindgen_ty_1 {
608 #[inline]
609 pub fn intra_dc_precision(&self) -> u32 {
610 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u32) }
611 }
612 #[inline]
613 pub fn set_intra_dc_precision(&mut self, val: u32) {
614 unsafe {
615 let val: u32 = ::std::mem::transmute(val);
616 self._bitfield_1.set(0usize, 2u8, val as u64)
617 }
618 }
619 #[inline]
620 pub fn picture_structure(&self) -> u32 {
621 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 2u8) as u32) }
622 }
623 #[inline]
624 pub fn set_picture_structure(&mut self, val: u32) {
625 unsafe {
626 let val: u32 = ::std::mem::transmute(val);
627 self._bitfield_1.set(2usize, 2u8, val as u64)
628 }
629 }
630 #[inline]
631 pub fn top_field_first(&self) -> u32 {
632 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
633 }
634 #[inline]
635 pub fn set_top_field_first(&mut self, val: u32) {
636 unsafe {
637 let val: u32 = ::std::mem::transmute(val);
638 self._bitfield_1.set(4usize, 1u8, val as u64)
639 }
640 }
641 #[inline]
642 pub fn frame_pred_frame_dct(&self) -> u32 {
643 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
644 }
645 #[inline]
646 pub fn set_frame_pred_frame_dct(&mut self, val: u32) {
647 unsafe {
648 let val: u32 = ::std::mem::transmute(val);
649 self._bitfield_1.set(5usize, 1u8, val as u64)
650 }
651 }
652 #[inline]
653 pub fn concealment_motion_vectors(&self) -> u32 {
654 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) }
655 }
656 #[inline]
657 pub fn set_concealment_motion_vectors(&mut self, val: u32) {
658 unsafe {
659 let val: u32 = ::std::mem::transmute(val);
660 self._bitfield_1.set(6usize, 1u8, val as u64)
661 }
662 }
663 #[inline]
664 pub fn q_scale_type(&self) -> u32 {
665 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) }
666 }
667 #[inline]
668 pub fn set_q_scale_type(&mut self, val: u32) {
669 unsafe {
670 let val: u32 = ::std::mem::transmute(val);
671 self._bitfield_1.set(7usize, 1u8, val as u64)
672 }
673 }
674 #[inline]
675 pub fn intra_vlc_format(&self) -> u32 {
676 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) }
677 }
678 #[inline]
679 pub fn set_intra_vlc_format(&mut self, val: u32) {
680 unsafe {
681 let val: u32 = ::std::mem::transmute(val);
682 self._bitfield_1.set(8usize, 1u8, val as u64)
683 }
684 }
685 #[inline]
686 pub fn alternate_scan(&self) -> u32 {
687 unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) }
688 }
689 #[inline]
690 pub fn set_alternate_scan(&mut self, val: u32) {
691 unsafe {
692 let val: u32 = ::std::mem::transmute(val);
693 self._bitfield_1.set(9usize, 1u8, val as u64)
694 }
695 }
696 #[inline]
697 pub fn repeat_first_field(&self) -> u32 {
698 unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) }
699 }
700 #[inline]
701 pub fn set_repeat_first_field(&mut self, val: u32) {
702 unsafe {
703 let val: u32 = ::std::mem::transmute(val);
704 self._bitfield_1.set(10usize, 1u8, val as u64)
705 }
706 }
707 #[inline]
708 pub fn progressive_frame(&self) -> u32 {
709 unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) }
710 }
711 #[inline]
712 pub fn set_progressive_frame(&mut self, val: u32) {
713 unsafe {
714 let val: u32 = ::std::mem::transmute(val);
715 self._bitfield_1.set(11usize, 1u8, val as u64)
716 }
717 }
718 #[inline]
719 pub fn is_first_field(&self) -> u32 {
720 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u32) }
721 }
722 #[inline]
723 pub fn set_is_first_field(&mut self, val: u32) {
724 unsafe {
725 let val: u32 = ::std::mem::transmute(val);
726 self._bitfield_1.set(12usize, 1u8, val as u64)
727 }
728 }
729 #[inline]
730 pub fn new_bitfield_1(
731 intra_dc_precision: u32,
732 picture_structure: u32,
733 top_field_first: u32,
734 frame_pred_frame_dct: u32,
735 concealment_motion_vectors: u32,
736 q_scale_type: u32,
737 intra_vlc_format: u32,
738 alternate_scan: u32,
739 repeat_first_field: u32,
740 progressive_frame: u32,
741 is_first_field: u32,
742 ) -> __BindgenBitfieldUnit<[u8; 2usize]> {
743 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default();
744 __bindgen_bitfield_unit.set(0usize, 2u8, {
745 let intra_dc_precision: u32 = unsafe { ::std::mem::transmute(intra_dc_precision) };
746 intra_dc_precision as u64
747 });
748 __bindgen_bitfield_unit.set(2usize, 2u8, {
749 let picture_structure: u32 = unsafe { ::std::mem::transmute(picture_structure) };
750 picture_structure as u64
751 });
752 __bindgen_bitfield_unit.set(4usize, 1u8, {
753 let top_field_first: u32 = unsafe { ::std::mem::transmute(top_field_first) };
754 top_field_first as u64
755 });
756 __bindgen_bitfield_unit.set(5usize, 1u8, {
757 let frame_pred_frame_dct: u32 = unsafe { ::std::mem::transmute(frame_pred_frame_dct) };
758 frame_pred_frame_dct as u64
759 });
760 __bindgen_bitfield_unit.set(6usize, 1u8, {
761 let concealment_motion_vectors: u32 =
762 unsafe { ::std::mem::transmute(concealment_motion_vectors) };
763 concealment_motion_vectors as u64
764 });
765 __bindgen_bitfield_unit.set(7usize, 1u8, {
766 let q_scale_type: u32 = unsafe { ::std::mem::transmute(q_scale_type) };
767 q_scale_type as u64
768 });
769 __bindgen_bitfield_unit.set(8usize, 1u8, {
770 let intra_vlc_format: u32 = unsafe { ::std::mem::transmute(intra_vlc_format) };
771 intra_vlc_format as u64
772 });
773 __bindgen_bitfield_unit.set(9usize, 1u8, {
774 let alternate_scan: u32 = unsafe { ::std::mem::transmute(alternate_scan) };
775 alternate_scan as u64
776 });
777 __bindgen_bitfield_unit.set(10usize, 1u8, {
778 let repeat_first_field: u32 = unsafe { ::std::mem::transmute(repeat_first_field) };
779 repeat_first_field as u64
780 });
781 __bindgen_bitfield_unit.set(11usize, 1u8, {
782 let progressive_frame: u32 = unsafe { ::std::mem::transmute(progressive_frame) };
783 progressive_frame as u64
784 });
785 __bindgen_bitfield_unit.set(12usize, 1u8, {
786 let is_first_field: u32 = unsafe { ::std::mem::transmute(is_first_field) };
787 is_first_field as u64
788 });
789 __bindgen_bitfield_unit
790 }
791}
792impl Default for _VAPictureParameterBufferMPEG2__bindgen_ty_1 {
793 fn default() -> Self {
794 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
795 unsafe {
796 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
797 s.assume_init()
798 }
799 }
800}
801impl Default for _VAPictureParameterBufferMPEG2 {
802 fn default() -> Self {
803 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
804 unsafe {
805 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
806 s.assume_init()
807 }
808 }
809}
810pub type VAPictureParameterBufferMPEG2 = _VAPictureParameterBufferMPEG2;
811#[repr(C)]
812#[derive(Debug, Copy, Clone, PartialEq, Eq)]
813pub struct _VAIQMatrixBufferMPEG2 {
814 pub load_intra_quantiser_matrix: i32,
815 pub load_non_intra_quantiser_matrix: i32,
816 pub load_chroma_intra_quantiser_matrix: i32,
817 pub load_chroma_non_intra_quantiser_matrix: i32,
818 pub intra_quantiser_matrix: [u8; 64usize],
819 pub non_intra_quantiser_matrix: [u8; 64usize],
820 pub chroma_intra_quantiser_matrix: [u8; 64usize],
821 pub chroma_non_intra_quantiser_matrix: [u8; 64usize],
822 pub va_reserved: [u32; 4usize],
823}
824impl Default for _VAIQMatrixBufferMPEG2 {
825 fn default() -> Self {
826 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
827 unsafe {
828 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
829 s.assume_init()
830 }
831 }
832}
833pub type VAIQMatrixBufferMPEG2 = _VAIQMatrixBufferMPEG2;
834#[repr(C)]
835#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
836pub struct _VASliceParameterBufferMPEG2 {
837 pub slice_data_size: u32,
838 pub slice_data_offset: u32,
839 pub slice_data_flag: u32,
840 pub macroblock_offset: u32,
841 pub slice_horizontal_position: u32,
842 pub slice_vertical_position: u32,
843 pub quantiser_scale_code: i32,
844 pub intra_slice_flag: i32,
845 pub va_reserved: [u32; 4usize],
846}
847pub type VASliceParameterBufferMPEG2 = _VASliceParameterBufferMPEG2;
848#[repr(C)]
849#[derive(Copy, Clone)]
850pub struct _VAMacroblockParameterBufferMPEG2 {
851 pub macroblock_address: u16,
852 pub macroblock_type: u8,
853 pub macroblock_modes: _VAMacroblockParameterBufferMPEG2__bindgen_ty_1,
854 pub motion_vertical_field_select: u8,
855 pub PMV: [[[i16; 2usize]; 2usize]; 2usize],
856 pub coded_block_pattern: u16,
857 pub num_skipped_macroblocks: u16,
858 pub va_reserved: [u32; 4usize],
859}
860#[repr(C)]
861#[derive(Copy, Clone)]
862pub union _VAMacroblockParameterBufferMPEG2__bindgen_ty_1 {
863 pub bits: _VAMacroblockParameterBufferMPEG2__bindgen_ty_1__bindgen_ty_1,
864 pub value: u32,
865}
866#[repr(C)]
867#[repr(align(4))]
868#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
869pub struct _VAMacroblockParameterBufferMPEG2__bindgen_ty_1__bindgen_ty_1 {
870 pub _bitfield_align_1: [u8; 0],
871 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
872 pub __bindgen_padding_0: [u8; 3usize],
873}
874impl _VAMacroblockParameterBufferMPEG2__bindgen_ty_1__bindgen_ty_1 {
875 #[inline]
876 pub fn frame_motion_type(&self) -> u32 {
877 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u32) }
878 }
879 #[inline]
880 pub fn set_frame_motion_type(&mut self, val: u32) {
881 unsafe {
882 let val: u32 = ::std::mem::transmute(val);
883 self._bitfield_1.set(0usize, 2u8, val as u64)
884 }
885 }
886 #[inline]
887 pub fn field_motion_type(&self) -> u32 {
888 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 2u8) as u32) }
889 }
890 #[inline]
891 pub fn set_field_motion_type(&mut self, val: u32) {
892 unsafe {
893 let val: u32 = ::std::mem::transmute(val);
894 self._bitfield_1.set(2usize, 2u8, val as u64)
895 }
896 }
897 #[inline]
898 pub fn dct_type(&self) -> u32 {
899 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
900 }
901 #[inline]
902 pub fn set_dct_type(&mut self, val: u32) {
903 unsafe {
904 let val: u32 = ::std::mem::transmute(val);
905 self._bitfield_1.set(4usize, 1u8, val as u64)
906 }
907 }
908 #[inline]
909 pub fn new_bitfield_1(
910 frame_motion_type: u32,
911 field_motion_type: u32,
912 dct_type: u32,
913 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
914 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
915 __bindgen_bitfield_unit.set(0usize, 2u8, {
916 let frame_motion_type: u32 = unsafe { ::std::mem::transmute(frame_motion_type) };
917 frame_motion_type as u64
918 });
919 __bindgen_bitfield_unit.set(2usize, 2u8, {
920 let field_motion_type: u32 = unsafe { ::std::mem::transmute(field_motion_type) };
921 field_motion_type as u64
922 });
923 __bindgen_bitfield_unit.set(4usize, 1u8, {
924 let dct_type: u32 = unsafe { ::std::mem::transmute(dct_type) };
925 dct_type as u64
926 });
927 __bindgen_bitfield_unit
928 }
929}
930impl Default for _VAMacroblockParameterBufferMPEG2__bindgen_ty_1 {
931 fn default() -> Self {
932 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
933 unsafe {
934 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
935 s.assume_init()
936 }
937 }
938}
939impl Default for _VAMacroblockParameterBufferMPEG2 {
940 fn default() -> Self {
941 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
942 unsafe {
943 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
944 s.assume_init()
945 }
946 }
947}
948pub type VAMacroblockParameterBufferMPEG2 = _VAMacroblockParameterBufferMPEG2;
949#[repr(C)]
950#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
8006218d 951pub struct VAPictureH264 {
68362724
KS		 952 pub picture_id: VASurfaceID,
953 pub frame_idx: u32,
954 pub flags: u32,
955 pub TopFieldOrderCnt: i32,
956 pub BottomFieldOrderCnt: i32,
957 pub va_reserved: [u32; 4usize],
958}
8006218d
KS		 959
960/// H.264 Picture Parameter Buffer
961///
962/// For each picture, and before any slice data, a single
963/// picture parameter buffer must be send.
68362724
KS		 964#[repr(C)]
965#[derive(Copy, Clone)]
8006218d 966pub struct VAPictureParameterBufferH264 {
68362724
KS		 967 pub CurrPic: VAPictureH264,
968 pub ReferenceFrames: [VAPictureH264; 16usize],
969 pub picture_width_in_mbs_minus1: u16,
970 pub picture_height_in_mbs_minus1: u16,
971 pub bit_depth_luma_minus8: u8,
972 pub bit_depth_chroma_minus8: u8,
973 pub num_ref_frames: u8,
974 pub seq_fields: _VAPictureParameterBufferH264__bindgen_ty_1,
975 pub num_slice_groups_minus1: u8,
976 pub slice_group_map_type: u8,
977 pub slice_group_change_rate_minus1: u16,
978 pub pic_init_qp_minus26: i8,
979 pub pic_init_qs_minus26: i8,
980 pub chroma_qp_index_offset: i8,
981 pub second_chroma_qp_index_offset: i8,
982 pub pic_fields: _VAPictureParameterBufferH264__bindgen_ty_2,
983 pub frame_num: u16,
984 pub va_reserved: [u32; 8usize],
985}
986#[repr(C)]
987#[derive(Copy, Clone)]
988pub union _VAPictureParameterBufferH264__bindgen_ty_1 {
989 pub bits: _VAPictureParameterBufferH264__bindgen_ty_1__bindgen_ty_1,
990 pub value: u32,
991}
992#[repr(C)]
993#[repr(align(4))]
994#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
995pub struct _VAPictureParameterBufferH264__bindgen_ty_1__bindgen_ty_1 {
996 pub _bitfield_align_1: [u8; 0],
997 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 3usize]>,
998 pub __bindgen_padding_0: u8,
999}
1000impl _VAPictureParameterBufferH264__bindgen_ty_1__bindgen_ty_1 {
1001 #[inline]
1002 pub fn chroma_format_idc(&self) -> u32 {
1003 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u32) }
1004 }
1005 #[inline]
1006 pub fn set_chroma_format_idc(&mut self, val: u32) {
1007 unsafe {
1008 let val: u32 = ::std::mem::transmute(val);
1009 self._bitfield_1.set(0usize, 2u8, val as u64)
1010 }
1011 }
1012 #[inline]
1013 pub fn residual_colour_transform_flag(&self) -> u32 {
1014 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
1015 }
1016 #[inline]
1017 pub fn set_residual_colour_transform_flag(&mut self, val: u32) {
1018 unsafe {
1019 let val: u32 = ::std::mem::transmute(val);
1020 self._bitfield_1.set(2usize, 1u8, val as u64)
1021 }
1022 }
1023 #[inline]
1024 pub fn gaps_in_frame_num_value_allowed_flag(&self) -> u32 {
1025 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
1026 }
1027 #[inline]
1028 pub fn set_gaps_in_frame_num_value_allowed_flag(&mut self, val: u32) {
1029 unsafe {
1030 let val: u32 = ::std::mem::transmute(val);
1031 self._bitfield_1.set(3usize, 1u8, val as u64)
1032 }
1033 }
1034 #[inline]
1035 pub fn frame_mbs_only_flag(&self) -> u32 {
1036 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
1037 }
1038 #[inline]
1039 pub fn set_frame_mbs_only_flag(&mut self, val: u32) {
1040 unsafe {
1041 let val: u32 = ::std::mem::transmute(val);
1042 self._bitfield_1.set(4usize, 1u8, val as u64)
1043 }
1044 }
1045 #[inline]
1046 pub fn mb_adaptive_frame_field_flag(&self) -> u32 {
1047 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
1048 }
1049 #[inline]
1050 pub fn set_mb_adaptive_frame_field_flag(&mut self, val: u32) {
1051 unsafe {
1052 let val: u32 = ::std::mem::transmute(val);
1053 self._bitfield_1.set(5usize, 1u8, val as u64)
1054 }
1055 }
1056 #[inline]
1057 pub fn direct_8x8_inference_flag(&self) -> u32 {
1058 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) }
1059 }
1060 #[inline]
1061 pub fn set_direct_8x8_inference_flag(&mut self, val: u32) {
1062 unsafe {
1063 let val: u32 = ::std::mem::transmute(val);
1064 self._bitfield_1.set(6usize, 1u8, val as u64)
1065 }
1066 }
1067 #[inline]
1068 pub fn MinLumaBiPredSize8x8(&self) -> u32 {
1069 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) }
1070 }
1071 #[inline]
1072 pub fn set_MinLumaBiPredSize8x8(&mut self, val: u32) {
1073 unsafe {
1074 let val: u32 = ::std::mem::transmute(val);
1075 self._bitfield_1.set(7usize, 1u8, val as u64)
1076 }
1077 }
1078 #[inline]
1079 pub fn log2_max_frame_num_minus4(&self) -> u32 {
1080 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 4u8) as u32) }
1081 }
1082 #[inline]
1083 pub fn set_log2_max_frame_num_minus4(&mut self, val: u32) {
1084 unsafe {
1085 let val: u32 = ::std::mem::transmute(val);
1086 self._bitfield_1.set(8usize, 4u8, val as u64)
1087 }
1088 }
1089 #[inline]
1090 pub fn pic_order_cnt_type(&self) -> u32 {
1091 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 2u8) as u32) }
1092 }
1093 #[inline]
1094 pub fn set_pic_order_cnt_type(&mut self, val: u32) {
1095 unsafe {
1096 let val: u32 = ::std::mem::transmute(val);
1097 self._bitfield_1.set(12usize, 2u8, val as u64)
1098 }
1099 }
1100 #[inline]
1101 pub fn log2_max_pic_order_cnt_lsb_minus4(&self) -> u32 {
1102 unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 4u8) as u32) }
1103 }
1104 #[inline]
1105 pub fn set_log2_max_pic_order_cnt_lsb_minus4(&mut self, val: u32) {
1106 unsafe {
1107 let val: u32 = ::std::mem::transmute(val);
1108 self._bitfield_1.set(14usize, 4u8, val as u64)
1109 }
1110 }
1111 #[inline]
1112 pub fn delta_pic_order_always_zero_flag(&self) -> u32 {
1113 unsafe { ::std::mem::transmute(self._bitfield_1.get(18usize, 1u8) as u32) }
1114 }
1115 #[inline]
1116 pub fn set_delta_pic_order_always_zero_flag(&mut self, val: u32) {
1117 unsafe {
1118 let val: u32 = ::std::mem::transmute(val);
1119 self._bitfield_1.set(18usize, 1u8, val as u64)
1120 }
1121 }
1122 #[inline]
1123 pub fn new_bitfield_1(
1124 chroma_format_idc: u32,
1125 residual_colour_transform_flag: u32,
1126 gaps_in_frame_num_value_allowed_flag: u32,
1127 frame_mbs_only_flag: u32,
1128 mb_adaptive_frame_field_flag: u32,
1129 direct_8x8_inference_flag: u32,
1130 MinLumaBiPredSize8x8: u32,
1131 log2_max_frame_num_minus4: u32,
1132 pic_order_cnt_type: u32,
1133 log2_max_pic_order_cnt_lsb_minus4: u32,
1134 delta_pic_order_always_zero_flag: u32,
1135 ) -> __BindgenBitfieldUnit<[u8; 3usize]> {
1136 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 3usize]> = Default::default();
1137 __bindgen_bitfield_unit.set(0usize, 2u8, {
1138 let chroma_format_idc: u32 = unsafe { ::std::mem::transmute(chroma_format_idc) };
1139 chroma_format_idc as u64
1140 });
1141 __bindgen_bitfield_unit.set(2usize, 1u8, {
1142 let residual_colour_transform_flag: u32 =
1143 unsafe { ::std::mem::transmute(residual_colour_transform_flag) };
1144 residual_colour_transform_flag as u64
1145 });
1146 __bindgen_bitfield_unit.set(3usize, 1u8, {
1147 let gaps_in_frame_num_value_allowed_flag: u32 =
1148 unsafe { ::std::mem::transmute(gaps_in_frame_num_value_allowed_flag) };
1149 gaps_in_frame_num_value_allowed_flag as u64
1150 });
1151 __bindgen_bitfield_unit.set(4usize, 1u8, {
1152 let frame_mbs_only_flag: u32 = unsafe { ::std::mem::transmute(frame_mbs_only_flag) };
1153 frame_mbs_only_flag as u64
1154 });
1155 __bindgen_bitfield_unit.set(5usize, 1u8, {
1156 let mb_adaptive_frame_field_flag: u32 =
1157 unsafe { ::std::mem::transmute(mb_adaptive_frame_field_flag) };
1158 mb_adaptive_frame_field_flag as u64
1159 });
1160 __bindgen_bitfield_unit.set(6usize, 1u8, {
1161 let direct_8x8_inference_flag: u32 =
1162 unsafe { ::std::mem::transmute(direct_8x8_inference_flag) };
1163 direct_8x8_inference_flag as u64
1164 });
1165 __bindgen_bitfield_unit.set(7usize, 1u8, {
1166 let MinLumaBiPredSize8x8: u32 = unsafe { ::std::mem::transmute(MinLumaBiPredSize8x8) };
1167 MinLumaBiPredSize8x8 as u64
1168 });
1169 __bindgen_bitfield_unit.set(8usize, 4u8, {
1170 let log2_max_frame_num_minus4: u32 =
1171 unsafe { ::std::mem::transmute(log2_max_frame_num_minus4) };
1172 log2_max_frame_num_minus4 as u64
1173 });
1174 __bindgen_bitfield_unit.set(12usize, 2u8, {
1175 let pic_order_cnt_type: u32 = unsafe { ::std::mem::transmute(pic_order_cnt_type) };
1176 pic_order_cnt_type as u64
1177 });
1178 __bindgen_bitfield_unit.set(14usize, 4u8, {
1179 let log2_max_pic_order_cnt_lsb_minus4: u32 =
1180 unsafe { ::std::mem::transmute(log2_max_pic_order_cnt_lsb_minus4) };
1181 log2_max_pic_order_cnt_lsb_minus4 as u64
1182 });
1183 __bindgen_bitfield_unit.set(18usize, 1u8, {
1184 let delta_pic_order_always_zero_flag: u32 =
1185 unsafe { ::std::mem::transmute(delta_pic_order_always_zero_flag) };
1186 delta_pic_order_always_zero_flag as u64
1187 });
1188 __bindgen_bitfield_unit
1189 }
1190}
1191impl Default for _VAPictureParameterBufferH264__bindgen_ty_1 {
1192 fn default() -> Self {
1193 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1194 unsafe {
1195 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1196 s.assume_init()
1197 }
1198 }
1199}
1200#[repr(C)]
1201#[derive(Copy, Clone)]
1202pub union _VAPictureParameterBufferH264__bindgen_ty_2 {
1203 pub bits: _VAPictureParameterBufferH264__bindgen_ty_2__bindgen_ty_1,
1204 pub value: u32,
1205}
1206#[repr(C)]
1207#[repr(align(4))]
1208#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
1209pub struct _VAPictureParameterBufferH264__bindgen_ty_2__bindgen_ty_1 {
1210 pub _bitfield_align_1: [u8; 0],
1211 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
1212 pub __bindgen_padding_0: u16,
1213}
1214impl _VAPictureParameterBufferH264__bindgen_ty_2__bindgen_ty_1 {
1215 #[inline]
1216 pub fn entropy_coding_mode_flag(&self) -> u32 {
1217 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
1218 }
1219 #[inline]
1220 pub fn set_entropy_coding_mode_flag(&mut self, val: u32) {
1221 unsafe {
1222 let val: u32 = ::std::mem::transmute(val);
1223 self._bitfield_1.set(0usize, 1u8, val as u64)
1224 }
1225 }
1226 #[inline]
1227 pub fn weighted_pred_flag(&self) -> u32 {
1228 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
1229 }
1230 #[inline]
1231 pub fn set_weighted_pred_flag(&mut self, val: u32) {
1232 unsafe {
1233 let val: u32 = ::std::mem::transmute(val);
1234 self._bitfield_1.set(1usize, 1u8, val as u64)
1235 }
1236 }
1237 #[inline]
1238 pub fn weighted_bipred_idc(&self) -> u32 {
1239 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 2u8) as u32) }
1240 }
1241 #[inline]
1242 pub fn set_weighted_bipred_idc(&mut self, val: u32) {
1243 unsafe {
1244 let val: u32 = ::std::mem::transmute(val);
1245 self._bitfield_1.set(2usize, 2u8, val as u64)
1246 }
1247 }
1248 #[inline]
1249 pub fn transform_8x8_mode_flag(&self) -> u32 {
1250 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
1251 }
1252 #[inline]
1253 pub fn set_transform_8x8_mode_flag(&mut self, val: u32) {
1254 unsafe {
1255 let val: u32 = ::std::mem::transmute(val);
1256 self._bitfield_1.set(4usize, 1u8, val as u64)
1257 }
1258 }
1259 #[inline]
1260 pub fn field_pic_flag(&self) -> u32 {
1261 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
1262 }
1263 #[inline]
1264 pub fn set_field_pic_flag(&mut self, val: u32) {
1265 unsafe {
1266 let val: u32 = ::std::mem::transmute(val);
1267 self._bitfield_1.set(5usize, 1u8, val as u64)
1268 }
1269 }
1270 #[inline]
1271 pub fn constrained_intra_pred_flag(&self) -> u32 {
1272 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) }
1273 }
1274 #[inline]
1275 pub fn set_constrained_intra_pred_flag(&mut self, val: u32) {
1276 unsafe {
1277 let val: u32 = ::std::mem::transmute(val);
1278 self._bitfield_1.set(6usize, 1u8, val as u64)
1279 }
1280 }
1281 #[inline]
1282 pub fn pic_order_present_flag(&self) -> u32 {
1283 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) }
1284 }
1285 #[inline]
1286 pub fn set_pic_order_present_flag(&mut self, val: u32) {
1287 unsafe {
1288 let val: u32 = ::std::mem::transmute(val);
1289 self._bitfield_1.set(7usize, 1u8, val as u64)
1290 }
1291 }
1292 #[inline]
1293 pub fn deblocking_filter_control_present_flag(&self) -> u32 {
1294 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) }
1295 }
1296 #[inline]
1297 pub fn set_deblocking_filter_control_present_flag(&mut self, val: u32) {
1298 unsafe {
1299 let val: u32 = ::std::mem::transmute(val);
1300 self._bitfield_1.set(8usize, 1u8, val as u64)
1301 }
1302 }
1303 #[inline]
1304 pub fn redundant_pic_cnt_present_flag(&self) -> u32 {
1305 unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) }
1306 }
1307 #[inline]
1308 pub fn set_redundant_pic_cnt_present_flag(&mut self, val: u32) {
1309 unsafe {
1310 let val: u32 = ::std::mem::transmute(val);
1311 self._bitfield_1.set(9usize, 1u8, val as u64)
1312 }
1313 }
1314 #[inline]
1315 pub fn reference_pic_flag(&self) -> u32 {
1316 unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) }
1317 }
1318 #[inline]
1319 pub fn set_reference_pic_flag(&mut self, val: u32) {
1320 unsafe {
1321 let val: u32 = ::std::mem::transmute(val);
1322 self._bitfield_1.set(10usize, 1u8, val as u64)
1323 }
1324 }
1325 #[inline]
1326 pub fn new_bitfield_1(
1327 entropy_coding_mode_flag: u32,
1328 weighted_pred_flag: u32,
1329 weighted_bipred_idc: u32,
1330 transform_8x8_mode_flag: u32,
1331 field_pic_flag: u32,
1332 constrained_intra_pred_flag: u32,
1333 pic_order_present_flag: u32,
1334 deblocking_filter_control_present_flag: u32,
1335 redundant_pic_cnt_present_flag: u32,
1336 reference_pic_flag: u32,
1337 ) -> __BindgenBitfieldUnit<[u8; 2usize]> {
1338 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default();
1339 __bindgen_bitfield_unit.set(0usize, 1u8, {
1340 let entropy_coding_mode_flag: u32 =
1341 unsafe { ::std::mem::transmute(entropy_coding_mode_flag) };
1342 entropy_coding_mode_flag as u64
1343 });
1344 __bindgen_bitfield_unit.set(1usize, 1u8, {
1345 let weighted_pred_flag: u32 = unsafe { ::std::mem::transmute(weighted_pred_flag) };
1346 weighted_pred_flag as u64
1347 });
1348 __bindgen_bitfield_unit.set(2usize, 2u8, {
1349 let weighted_bipred_idc: u32 = unsafe { ::std::mem::transmute(weighted_bipred_idc) };
1350 weighted_bipred_idc as u64
1351 });
1352 __bindgen_bitfield_unit.set(4usize, 1u8, {
1353 let transform_8x8_mode_flag: u32 =
1354 unsafe { ::std::mem::transmute(transform_8x8_mode_flag) };
1355 transform_8x8_mode_flag as u64
1356 });
1357 __bindgen_bitfield_unit.set(5usize, 1u8, {
1358 let field_pic_flag: u32 = unsafe { ::std::mem::transmute(field_pic_flag) };
1359 field_pic_flag as u64
1360 });
1361 __bindgen_bitfield_unit.set(6usize, 1u8, {
1362 let constrained_intra_pred_flag: u32 =
1363 unsafe { ::std::mem::transmute(constrained_intra_pred_flag) };
1364 constrained_intra_pred_flag as u64
1365 });
1366 __bindgen_bitfield_unit.set(7usize, 1u8, {
1367 let pic_order_present_flag: u32 =
1368 unsafe { ::std::mem::transmute(pic_order_present_flag) };
1369 pic_order_present_flag as u64
1370 });
1371 __bindgen_bitfield_unit.set(8usize, 1u8, {
1372 let deblocking_filter_control_present_flag: u32 =
1373 unsafe { ::std::mem::transmute(deblocking_filter_control_present_flag) };
1374 deblocking_filter_control_present_flag as u64
1375 });
1376 __bindgen_bitfield_unit.set(9usize, 1u8, {
1377 let redundant_pic_cnt_present_flag: u32 =
1378 unsafe { ::std::mem::transmute(redundant_pic_cnt_present_flag) };
1379 redundant_pic_cnt_present_flag as u64
1380 });
1381 __bindgen_bitfield_unit.set(10usize, 1u8, {
1382 let reference_pic_flag: u32 = unsafe { ::std::mem::transmute(reference_pic_flag) };
1383 reference_pic_flag as u64
1384 });
1385 __bindgen_bitfield_unit
1386 }
1387}
1388impl Default for _VAPictureParameterBufferH264__bindgen_ty_2 {
1389 fn default() -> Self {
1390 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1391 unsafe {
1392 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1393 s.assume_init()
1394 }
1395 }
1396}
8006218d 1397impl Default for VAPictureParameterBufferH264 {
68362724
KS		 1398 fn default() -> Self {
1399 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1400 unsafe {
1401 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1402 s.assume_init()
1403 }
1404 }
1405}
8006218d
KS		 1406/// H.264 Inverse Quantization Matrix Buffer
1407///
1408/// Fill scaling lists with the default value (16) if they are not available.
68362724
KS		 1409#[repr(C)]
1410#[derive(Debug, Copy, Clone, PartialEq, Eq)]
8006218d 1411pub struct VAIQMatrixBufferH264 {
68362724
KS		 1412 pub ScalingList4x4: [[u8; 16usize]; 6usize],
1413 pub ScalingList8x8: [[u8; 64usize]; 2usize],
1414 pub va_reserved: [u32; 4usize],
1415}
8006218d 1416impl Default for VAIQMatrixBufferH264 {
68362724
KS		 1417 fn default() -> Self {
1418 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1419 unsafe {
1420 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1421 s.assume_init()
1422 }
1423 }
1424}
8006218d
KS		 1425/// H.264 Slice Parameter Buffer
1426///
1427/// For each picture before each slice data buffer, a single
1428/// slice parameter buffer must be send.
68362724
KS		 1429#[repr(C)]
1430#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
8006218d
KS		 1431pub struct VASliceParameterBufferH264 {
1432 /// Number of bytes in the slice data buffer for this slice
68362724
KS		 1433 pub slice_data_size: u32,
1434 pub slice_data_offset: u32,
1435 pub slice_data_flag: u32,
8006218d
KS		 1436 /// Bit offset from NAL Header Unit to the begining of slice_data().
1437 ///
1438 /// This bit offset is relative to and includes the NAL unit byte
1439 /// and represents the number of bits parsed in the slice_header()
1440 /// after the removal of any emulation prevention bytes in
1441 /// there. However, the slice data buffer passed to the hardware is
1442 /// the original bitstream, thus including any emulation prevention
1443 /// bytes.
68362724
KS		 1444 pub slice_data_bit_offset: u16,
1445 pub first_mb_in_slice: u16,
1446 pub slice_type: u8,
1447 pub direct_spatial_mv_pred_flag: u8,
8006218d
KS		 1448 /// H264/AVC syntax element
1449 ///
1450 /// if num_ref_idx_active_override_flag equals 0, host decoder should
1451 /// set its value to num_ref_idx_l0_default_active_minus1.
68362724 1452 pub num_ref_idx_l0_active_minus1: u8,
8006218d
KS		 1453 /// H264/AVC syntax element
1454 ///
1455 /// if num_ref_idx_active_override_flag equals 0, host decoder should
1456 /// set its value to num_ref_idx_l1_default_active_minus1.
68362724
KS		 1457 pub num_ref_idx_l1_active_minus1: u8,
1458 pub cabac_init_idc: u8,
1459 pub slice_qp_delta: i8,
1460 pub disable_deblocking_filter_idc: u8,
1461 pub slice_alpha_c0_offset_div2: i8,
1462 pub slice_beta_offset_div2: i8,
1463 pub RefPicList0: [VAPictureH264; 32usize],
1464 pub RefPicList1: [VAPictureH264; 32usize],
1465 pub luma_log2_weight_denom: u8,
1466 pub chroma_log2_weight_denom: u8,
1467 pub luma_weight_l0_flag: u8,
1468 pub luma_weight_l0: [i16; 32usize],
1469 pub luma_offset_l0: [i16; 32usize],
1470 pub chroma_weight_l0_flag: u8,
1471 pub chroma_weight_l0: [[i16; 2usize]; 32usize],
1472 pub chroma_offset_l0: [[i16; 2usize]; 32usize],
1473 pub luma_weight_l1_flag: u8,
1474 pub luma_weight_l1: [i16; 32usize],
1475 pub luma_offset_l1: [i16; 32usize],
1476 pub chroma_weight_l1_flag: u8,
1477 pub chroma_weight_l1: [[i16; 2usize]; 32usize],
1478 pub chroma_offset_l1: [[i16; 2usize]; 32usize],
1479 pub va_reserved: [u32; 4usize],
1480}
68362724
KS		 1481pub mod VAEncPictureType {
1482 pub type Type = ::std::os::raw::c_uint;
1483 pub const VAEncPictureTypeIntra: Type = 0;
1484 pub const VAEncPictureTypePredictive: Type = 1;
1485 pub const VAEncPictureTypeBidirectional: Type = 2;
1486}
1487extern "C" {
1488 pub fn vaCreateBuffer(
1489 dpy: VADisplay,
1490 context: VAContextID,
1491 type_: VABufferType::Type,
1492 size: ::std::os::raw::c_uint,
1493 num_elements: ::std::os::raw::c_uint,
1494 data: *mut ::std::os::raw::c_void,
1495 buf_id: *mut VABufferID,
1496 ) -> VAStatus;
1497}
1498extern "C" {
1499 pub fn vaCreateBuffer2(
1500 dpy: VADisplay,
1501 context: VAContextID,
1502 type_: VABufferType::Type,
1503 width: ::std::os::raw::c_uint,
1504 height: ::std::os::raw::c_uint,
1505 unit_size: *mut ::std::os::raw::c_uint,
1506 pitch: *mut ::std::os::raw::c_uint,
1507 buf_id: *mut VABufferID,
1508 ) -> VAStatus;
1509}
1510extern "C" {
1511 pub fn vaBufferSetNumElements(
1512 dpy: VADisplay,
1513 buf_id: VABufferID,
1514 num_elements: ::std::os::raw::c_uint,
1515 ) -> VAStatus;
1516}
1517extern "C" {
1518 pub fn vaMapBuffer(
1519 dpy: VADisplay,
1520 buf_id: VABufferID,
1521 pbuf: *mut *mut ::std::os::raw::c_void,
1522 ) -> VAStatus;
1523}
1524extern "C" {
1525 pub fn vaUnmapBuffer(dpy: VADisplay, buf_id: VABufferID) -> VAStatus;
1526}
1527extern "C" {
1528 pub fn vaDestroyBuffer(dpy: VADisplay, buffer_id: VABufferID) -> VAStatus;
1529}
1530#[repr(C)]
1531#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
1532pub struct VABufferInfo {
1533 pub handle: usize,
1534 pub type_: u32,
1535 pub mem_type: u32,
1536 pub mem_size: usize,
1537 pub va_reserved: [u32; 4usize],
1538}
1539extern "C" {
1540 pub fn vaAcquireBufferHandle(
1541 dpy: VADisplay,
1542 buf_id: VABufferID,
1543 buf_info: *mut VABufferInfo,
1544 ) -> VAStatus;
1545}
1546extern "C" {
1547 pub fn vaReleaseBufferHandle(dpy: VADisplay, buf_id: VABufferID) -> VAStatus;
1548}
1549extern "C" {
1550 pub fn vaExportSurfaceHandle(
1551 dpy: VADisplay,
1552 surface_id: VASurfaceID,
1553 mem_type: u32,
1554 flags: u32,
1555 descriptor: *mut ::std::os::raw::c_void,
1556 ) -> VAStatus;
1557}
1558extern "C" {
1559 pub fn vaBeginPicture(
1560 dpy: VADisplay,
1561 context: VAContextID,
1562 render_target: VASurfaceID,
1563 ) -> VAStatus;
1564}
1565extern "C" {
1566 pub fn vaRenderPicture(
1567 dpy: VADisplay,
1568 context: VAContextID,
1569 buffers: *mut VABufferID,
1570 num_buffers: ::std::os::raw::c_int,
1571 ) -> VAStatus;
1572}
1573extern "C" {
1574 pub fn vaEndPicture(dpy: VADisplay, context: VAContextID) -> VAStatus;
1575}
1576extern "C" {
1577 pub fn vaMFSubmit(
1578 dpy: VADisplay,
1579 mf_context: VAMFContextID,
1580 contexts: *mut VAContextID,
1581 num_contexts: ::std::os::raw::c_int,
1582 ) -> VAStatus;
1583}
1584extern "C" {
1585 pub fn vaSyncSurface(dpy: VADisplay, render_target: VASurfaceID) -> VAStatus;
1586}
1587extern "C" {
1588 pub fn vaSyncSurface2(dpy: VADisplay, surface: VASurfaceID, timeout_ns: u64) -> VAStatus;
1589}
1590pub mod VASurfaceStatus {
1591 pub type Type = ::std::os::raw::c_uint;
1592 pub const VASurfaceRendering: Type = 1;
1593 pub const VASurfaceDisplaying: Type = 2;
1594 pub const VASurfaceReady: Type = 4;
1595 pub const VASurfaceSkipped: Type = 8;
1596}
1597extern "C" {
1598 pub fn vaQuerySurfaceStatus(
1599 dpy: VADisplay,
1600 render_target: VASurfaceID,
1601 status: *mut VASurfaceStatus::Type,
1602 ) -> VAStatus;
1603}
1604extern "C" {
1605 pub fn vaQuerySurfaceError(
1606 dpy: VADisplay,
1607 surface: VASurfaceID,
1608 error_status: VAStatus,
1609 error_info: *mut *mut ::std::os::raw::c_void,
1610 ) -> VAStatus;
1611}
1612extern "C" {
1613 pub fn vaSyncBuffer(dpy: VADisplay, buf_id: VABufferID, timeout_ns: u64) -> VAStatus;
1614}
1615#[repr(C)]
1616#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
8006218d 1617pub struct VAImageFormat {
68362724
KS		 1618 pub fourcc: u32,
1619 pub byte_order: u32,
1620 pub bits_per_pixel: u32,
1621 pub depth: u32,
1622 pub red_mask: u32,
1623 pub green_mask: u32,
1624 pub blue_mask: u32,
1625 pub alpha_mask: u32,
1626 pub va_reserved: [u32; 4usize],
1627}
68362724
KS		 1628pub type VAImageID = VAGenericID;
1629#[repr(C)]
1630#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
8006218d 1631pub struct VAImage {
68362724
KS		 1632 pub image_id: VAImageID,
1633 pub format: VAImageFormat,
1634 pub buf: VABufferID,
1635 pub width: u16,
1636 pub height: u16,
1637 pub data_size: u32,
1638 pub num_planes: u32,
1639 pub pitches: [u32; 3usize],
1640 pub offsets: [u32; 3usize],
1641 pub num_palette_entries: i32,
1642 pub entry_bytes: i32,
1643 pub component_order: [i8; 4usize],
1644 pub va_reserved: [u32; 4usize],
1645}
68362724
KS		 1646extern "C" {
1647 pub fn vaMaxNumImageFormats(dpy: VADisplay) -> ::std::os::raw::c_int;
1648}
1649extern "C" {
1650 pub fn vaQueryImageFormats(
1651 dpy: VADisplay,
1652 format_list: *mut VAImageFormat,
1653 num_formats: *mut ::std::os::raw::c_int,
1654 ) -> VAStatus;
1655}
1656extern "C" {
1657 pub fn vaCreateImage(
1658 dpy: VADisplay,
1659 format: *mut VAImageFormat,
1660 width: ::std::os::raw::c_int,
1661 height: ::std::os::raw::c_int,
1662 image: *mut VAImage,
1663 ) -> VAStatus;
1664}
1665extern "C" {
1666 pub fn vaDestroyImage(dpy: VADisplay, image: VAImageID) -> VAStatus;
1667}
1668extern "C" {
1669 pub fn vaSetImagePalette(
1670 dpy: VADisplay,
1671 image: VAImageID,
1672 palette: *mut ::std::os::raw::c_uchar,
1673 ) -> VAStatus;
1674}
1675extern "C" {
1676 pub fn vaGetImage(
1677 dpy: VADisplay,
1678 surface: VASurfaceID,
1679 x: ::std::os::raw::c_int,
1680 y: ::std::os::raw::c_int,
1681 width: ::std::os::raw::c_uint,
1682 height: ::std::os::raw::c_uint,
1683 image: VAImageID,
1684 ) -> VAStatus;
1685}
1686extern "C" {
1687 pub fn vaPutImage(
1688 dpy: VADisplay,
1689 surface: VASurfaceID,
1690 image: VAImageID,
1691 src_x: ::std::os::raw::c_int,
1692 src_y: ::std::os::raw::c_int,
1693 src_width: ::std::os::raw::c_uint,
1694 src_height: ::std::os::raw::c_uint,
1695 dest_x: ::std::os::raw::c_int,
1696 dest_y: ::std::os::raw::c_int,
1697 dest_width: ::std::os::raw::c_uint,
1698 dest_height: ::std::os::raw::c_uint,
1699 ) -> VAStatus;
1700}
1701extern "C" {
1702 pub fn vaDeriveImage(dpy: VADisplay, surface: VASurfaceID, image: *mut VAImage) -> VAStatus;
1703}
1704pub type VASubpictureID = VAGenericID;
1705extern "C" {
1706 pub fn vaMaxNumSubpictureFormats(dpy: VADisplay) -> ::std::os::raw::c_int;
1707}
1708extern "C" {
1709 pub fn vaQuerySubpictureFormats(
1710 dpy: VADisplay,
1711 format_list: *mut VAImageFormat,
1712 flags: *mut ::std::os::raw::c_uint,
1713 num_formats: *mut ::std::os::raw::c_uint,
1714 ) -> VAStatus;
1715}
1716extern "C" {
1717 pub fn vaCreateSubpicture(
1718 dpy: VADisplay,
1719 image: VAImageID,
1720 subpicture: *mut VASubpictureID,
1721 ) -> VAStatus;
1722}
1723extern "C" {
1724 pub fn vaDestroySubpicture(dpy: VADisplay, subpicture: VASubpictureID) -> VAStatus;
1725}
1726extern "C" {
1727 pub fn vaSetSubpictureImage(
1728 dpy: VADisplay,
1729 subpicture: VASubpictureID,
1730 image: VAImageID,
1731 ) -> VAStatus;
1732}
1733extern "C" {
1734 pub fn vaSetSubpictureChromakey(
1735 dpy: VADisplay,
1736 subpicture: VASubpictureID,
1737 chromakey_min: ::std::os::raw::c_uint,
1738 chromakey_max: ::std::os::raw::c_uint,
1739 chromakey_mask: ::std::os::raw::c_uint,
1740 ) -> VAStatus;
1741}
1742extern "C" {
1743 pub fn vaSetSubpictureGlobalAlpha(
1744 dpy: VADisplay,
1745 subpicture: VASubpictureID,
1746 global_alpha: f32,
1747 ) -> VAStatus;
1748}
1749extern "C" {
1750 pub fn vaAssociateSubpicture(
1751 dpy: VADisplay,
1752 subpicture: VASubpictureID,
1753 target_surfaces: *mut VASurfaceID,
1754 num_surfaces: ::std::os::raw::c_int,
1755 src_x: i16,
1756 src_y: i16,
1757 src_width: u16,
1758 src_height: u16,
1759 dest_x: i16,
1760 dest_y: i16,
1761 dest_width: u16,
1762 dest_height: u16,
1763 flags: u32,
1764 ) -> VAStatus;
1765}
1766extern "C" {
1767 pub fn vaDeassociateSubpicture(
1768 dpy: VADisplay,
1769 subpicture: VASubpictureID,
1770 target_surfaces: *mut VASurfaceID,
1771 num_surfaces: ::std::os::raw::c_int,
1772 ) -> VAStatus;
1773}
1774pub mod VADisplayAttribType {
1775 pub type Type = ::std::os::raw::c_uint;
1776 pub const VADisplayAttribBrightness: Type = 0;
1777 pub const VADisplayAttribContrast: Type = 1;
1778 pub const VADisplayAttribHue: Type = 2;
1779 pub const VADisplayAttribSaturation: Type = 3;
1780 pub const VADisplayAttribBackgroundColor: Type = 4;
1781 pub const VADisplayAttribDirectSurface: Type = 5;
1782 pub const VADisplayAttribRotation: Type = 6;
1783 pub const VADisplayAttribOutofLoopDeblock: Type = 7;
1784 pub const VADisplayAttribBLEBlackMode: Type = 8;
1785 pub const VADisplayAttribBLEWhiteMode: Type = 9;
1786 pub const VADisplayAttribBlueStretch: Type = 10;
1787 pub const VADisplayAttribSkinColorCorrection: Type = 11;
1788 pub const VADisplayAttribCSCMatrix: Type = 12;
1789 pub const VADisplayAttribBlendColor: Type = 13;
1790 pub const VADisplayAttribOverlayAutoPaintColorKey: Type = 14;
1791 pub const VADisplayAttribOverlayColorKey: Type = 15;
1792 pub const VADisplayAttribRenderMode: Type = 16;
1793 pub const VADisplayAttribRenderDevice: Type = 17;
1794 pub const VADisplayAttribRenderRect: Type = 18;
1795 pub const VADisplayAttribSubDevice: Type = 19;
1796 pub const VADisplayAttribCopy: Type = 20;
1797 pub const VADisplayPCIID: Type = 21;
1798}
1799#[repr(C)]
1800#[derive(Debug, Copy, Clone, PartialEq, Eq)]
1801pub struct _VADisplayAttribute {
1802 pub type_: VADisplayAttribType::Type,
1803 pub min_value: i32,
1804 pub max_value: i32,
1805 pub value: i32,
1806 pub flags: u32,
1807 pub va_reserved: [u32; 4usize],
1808}
1809impl Default for _VADisplayAttribute {
1810 fn default() -> Self {
1811 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1812 unsafe {
1813 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1814 s.assume_init()
1815 }
1816 }
1817}
1818pub type VADisplayAttribute = _VADisplayAttribute;
1819extern "C" {
1820 pub fn vaMaxNumDisplayAttributes(dpy: VADisplay) -> ::std::os::raw::c_int;
1821}
1822extern "C" {
1823 pub fn vaQueryDisplayAttributes(
1824 dpy: VADisplay,
1825 attr_list: *mut VADisplayAttribute,
1826 num_attributes: *mut ::std::os::raw::c_int,
1827 ) -> VAStatus;
1828}
1829extern "C" {
1830 pub fn vaGetDisplayAttributes(
1831 dpy: VADisplay,
1832 attr_list: *mut VADisplayAttribute,
1833 num_attributes: ::std::os::raw::c_int,
1834 ) -> VAStatus;
1835}
1836extern "C" {
1837 pub fn vaSetDisplayAttributes(
1838 dpy: VADisplay,
1839 attr_list: *mut VADisplayAttribute,
1840 num_attributes: ::std::os::raw::c_int,
1841 ) -> VAStatus;
1842}
1843pub mod VACopyObjectType {
1844 pub type Type = ::std::os::raw::c_uint;
1845 pub const VACopyObjectSurface: Type = 0;
1846 pub const VACopyObjectBuffer: Type = 1;
1847}
1848#[repr(C)]
1849#[derive(Copy, Clone)]
1850pub struct _VACopyObject {
1851 pub obj_type: VACopyObjectType::Type,
1852 pub object: _VACopyObject__bindgen_ty_1,
1853 pub va_reserved: [u32; 8usize],
1854}
1855#[repr(C)]
1856#[derive(Copy, Clone)]
1857pub union _VACopyObject__bindgen_ty_1 {
1858 pub surface_id: VASurfaceID,
1859 pub buffer_id: VABufferID,
1860}
1861impl Default for _VACopyObject__bindgen_ty_1 {
1862 fn default() -> Self {
1863 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1864 unsafe {
1865 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1866 s.assume_init()
1867 }
1868 }
1869}
1870impl Default for _VACopyObject {
1871 fn default() -> Self {
1872 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1873 unsafe {
1874 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1875 s.assume_init()
1876 }
1877 }
1878}
1879pub type VACopyObject = _VACopyObject;
1880#[repr(C)]
1881#[derive(Copy, Clone)]
1882pub union _VACopyOption {
1883 pub bits: _VACopyOption__bindgen_ty_1,
1884 pub value: u32,
1885}
1886#[repr(C)]
1887#[repr(align(4))]
1888#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
1889pub struct _VACopyOption__bindgen_ty_1 {
1890 pub _bitfield_align_1: [u32; 0],
1891 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
1892}
1893impl _VACopyOption__bindgen_ty_1 {
1894 #[inline]
1895 pub fn va_copy_sync(&self) -> u32 {
1896 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u32) }
1897 }
1898 #[inline]
1899 pub fn set_va_copy_sync(&mut self, val: u32) {
1900 unsafe {
1901 let val: u32 = ::std::mem::transmute(val);
1902 self._bitfield_1.set(0usize, 2u8, val as u64)
1903 }
1904 }
1905 #[inline]
1906 pub fn va_copy_mode(&self) -> u32 {
1907 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 4u8) as u32) }
1908 }
1909 #[inline]
1910 pub fn set_va_copy_mode(&mut self, val: u32) {
1911 unsafe {
1912 let val: u32 = ::std::mem::transmute(val);
1913 self._bitfield_1.set(2usize, 4u8, val as u64)
1914 }
1915 }
1916 #[inline]
1917 pub fn reserved(&self) -> u32 {
1918 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 26u8) as u32) }
1919 }
1920 #[inline]
1921 pub fn set_reserved(&mut self, val: u32) {
1922 unsafe {
1923 let val: u32 = ::std::mem::transmute(val);
1924 self._bitfield_1.set(6usize, 26u8, val as u64)
1925 }
1926 }
1927 #[inline]
1928 pub fn new_bitfield_1(
1929 va_copy_sync: u32,
1930 va_copy_mode: u32,
1931 reserved: u32,
1932 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
1933 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
1934 __bindgen_bitfield_unit.set(0usize, 2u8, {
1935 let va_copy_sync: u32 = unsafe { ::std::mem::transmute(va_copy_sync) };
1936 va_copy_sync as u64
1937 });
1938 __bindgen_bitfield_unit.set(2usize, 4u8, {
1939 let va_copy_mode: u32 = unsafe { ::std::mem::transmute(va_copy_mode) };
1940 va_copy_mode as u64
1941 });
1942 __bindgen_bitfield_unit.set(6usize, 26u8, {
1943 let reserved: u32 = unsafe { ::std::mem::transmute(reserved) };
1944 reserved as u64
1945 });
1946 __bindgen_bitfield_unit
1947 }
1948}
1949impl Default for _VACopyOption {
1950 fn default() -> Self {
1951 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1952 unsafe {
1953 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1954 s.assume_init()
1955 }
1956 }
1957}
1958pub type VACopyOption = _VACopyOption;
1959extern "C" {
1960 pub fn vaCopy(
1961 dpy: VADisplay,
1962 dst: *mut VACopyObject,
1963 src: *mut VACopyObject,
1964 option: VACopyOption,
1965 ) -> VAStatus;
1966}
1967#[repr(C)]
1968#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
1969pub struct _VABoolCoderContextVPX {
1970 pub range: u8,
1971 pub value: u8,
1972 pub count: u8,
1973}
1974pub type VABoolCoderContextVPX = _VABoolCoderContextVPX;
1975#[repr(C)]
1976#[derive(Copy, Clone)]
1977pub struct _VAPictureParameterBufferVP8 {
1978 pub frame_width: u32,
1979 pub frame_height: u32,
1980 pub last_ref_frame: VASurfaceID,
1981 pub golden_ref_frame: VASurfaceID,
1982 pub alt_ref_frame: VASurfaceID,
1983 pub out_of_loop_frame: VASurfaceID,
1984 pub pic_fields: _VAPictureParameterBufferVP8__bindgen_ty_1,
1985 pub mb_segment_tree_probs: [u8; 3usize],
1986 pub loop_filter_level: [u8; 4usize],
1987 pub loop_filter_deltas_ref_frame: [i8; 4usize],
1988 pub loop_filter_deltas_mode: [i8; 4usize],
1989 pub prob_skip_false: u8,
1990 pub prob_intra: u8,
1991 pub prob_last: u8,
1992 pub prob_gf: u8,
1993 pub y_mode_probs: [u8; 4usize],
1994 pub uv_mode_probs: [u8; 3usize],
1995 pub mv_probs: [[u8; 19usize]; 2usize],
1996 pub bool_coder_ctx: VABoolCoderContextVPX,
1997 pub va_reserved: [u32; 4usize],
1998}
1999#[repr(C)]
2000#[derive(Copy, Clone)]
2001pub union _VAPictureParameterBufferVP8__bindgen_ty_1 {
2002 pub bits: _VAPictureParameterBufferVP8__bindgen_ty_1__bindgen_ty_1,
2003 pub value: u32,
2004}
2005#[repr(C)]
2006#[repr(align(4))]
2007#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
2008pub struct _VAPictureParameterBufferVP8__bindgen_ty_1__bindgen_ty_1 {
2009 pub _bitfield_align_1: [u8; 0],
2010 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 3usize]>,
2011 pub __bindgen_padding_0: u8,
2012}
2013impl _VAPictureParameterBufferVP8__bindgen_ty_1__bindgen_ty_1 {
2014 #[inline]
2015 pub fn key_frame(&self) -> u32 {
2016 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
2017 }
2018 #[inline]
2019 pub fn set_key_frame(&mut self, val: u32) {
2020 unsafe {
2021 let val: u32 = ::std::mem::transmute(val);
2022 self._bitfield_1.set(0usize, 1u8, val as u64)
2023 }
2024 }
2025 #[inline]
2026 pub fn version(&self) -> u32 {
2027 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 3u8) as u32) }
2028 }
2029 #[inline]
2030 pub fn set_version(&mut self, val: u32) {
2031 unsafe {
2032 let val: u32 = ::std::mem::transmute(val);
2033 self._bitfield_1.set(1usize, 3u8, val as u64)
2034 }
2035 }
2036 #[inline]
2037 pub fn segmentation_enabled(&self) -> u32 {
2038 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
2039 }
2040 #[inline]
2041 pub fn set_segmentation_enabled(&mut self, val: u32) {
2042 unsafe {
2043 let val: u32 = ::std::mem::transmute(val);
2044 self._bitfield_1.set(4usize, 1u8, val as u64)
2045 }
2046 }
2047 #[inline]
2048 pub fn update_mb_segmentation_map(&self) -> u32 {
2049 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
2050 }
2051 #[inline]
2052 pub fn set_update_mb_segmentation_map(&mut self, val: u32) {
2053 unsafe {
2054 let val: u32 = ::std::mem::transmute(val);
2055 self._bitfield_1.set(5usize, 1u8, val as u64)
2056 }
2057 }
2058 #[inline]
2059 pub fn update_segment_feature_data(&self) -> u32 {
2060 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) }
2061 }
2062 #[inline]
2063 pub fn set_update_segment_feature_data(&mut self, val: u32) {
2064 unsafe {
2065 let val: u32 = ::std::mem::transmute(val);
2066 self._bitfield_1.set(6usize, 1u8, val as u64)
2067 }
2068 }
2069 #[inline]
2070 pub fn filter_type(&self) -> u32 {
2071 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) }
2072 }
2073 #[inline]
2074 pub fn set_filter_type(&mut self, val: u32) {
2075 unsafe {
2076 let val: u32 = ::std::mem::transmute(val);
2077 self._bitfield_1.set(7usize, 1u8, val as u64)
2078 }
2079 }
2080 #[inline]
2081 pub fn sharpness_level(&self) -> u32 {
2082 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 3u8) as u32) }
2083 }
2084 #[inline]
2085 pub fn set_sharpness_level(&mut self, val: u32) {
2086 unsafe {
2087 let val: u32 = ::std::mem::transmute(val);
2088 self._bitfield_1.set(8usize, 3u8, val as u64)
2089 }
2090 }
2091 #[inline]
2092 pub fn loop_filter_adj_enable(&self) -> u32 {
2093 unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) }
2094 }
2095 #[inline]
2096 pub fn set_loop_filter_adj_enable(&mut self, val: u32) {
2097 unsafe {
2098 let val: u32 = ::std::mem::transmute(val);
2099 self._bitfield_1.set(11usize, 1u8, val as u64)
2100 }
2101 }
2102 #[inline]
2103 pub fn mode_ref_lf_delta_update(&self) -> u32 {
2104 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u32) }
2105 }
2106 #[inline]
2107 pub fn set_mode_ref_lf_delta_update(&mut self, val: u32) {
2108 unsafe {
2109 let val: u32 = ::std::mem::transmute(val);
2110 self._bitfield_1.set(12usize, 1u8, val as u64)
2111 }
2112 }
2113 #[inline]
2114 pub fn sign_bias_golden(&self) -> u32 {
2115 unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) }
2116 }
2117 #[inline]
2118 pub fn set_sign_bias_golden(&mut self, val: u32) {
2119 unsafe {
2120 let val: u32 = ::std::mem::transmute(val);
2121 self._bitfield_1.set(13usize, 1u8, val as u64)
2122 }
2123 }
2124 #[inline]
2125 pub fn sign_bias_alternate(&self) -> u32 {
2126 unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) }
2127 }
2128 #[inline]
2129 pub fn set_sign_bias_alternate(&mut self, val: u32) {
2130 unsafe {
2131 let val: u32 = ::std::mem::transmute(val);
2132 self._bitfield_1.set(14usize, 1u8, val as u64)
2133 }
2134 }
2135 #[inline]
2136 pub fn mb_no_coeff_skip(&self) -> u32 {
2137 unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u32) }
2138 }
2139 #[inline]
2140 pub fn set_mb_no_coeff_skip(&mut self, val: u32) {
2141 unsafe {
2142 let val: u32 = ::std::mem::transmute(val);
2143 self._bitfield_1.set(15usize, 1u8, val as u64)
2144 }
2145 }
2146 #[inline]
2147 pub fn loop_filter_disable(&self) -> u32 {
2148 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u32) }
2149 }
2150 #[inline]
2151 pub fn set_loop_filter_disable(&mut self, val: u32) {
2152 unsafe {
2153 let val: u32 = ::std::mem::transmute(val);
2154 self._bitfield_1.set(16usize, 1u8, val as u64)
2155 }
2156 }
2157 #[inline]
2158 pub fn new_bitfield_1(
2159 key_frame: u32,
2160 version: u32,
2161 segmentation_enabled: u32,
2162 update_mb_segmentation_map: u32,
2163 update_segment_feature_data: u32,
2164 filter_type: u32,
2165 sharpness_level: u32,
2166 loop_filter_adj_enable: u32,
2167 mode_ref_lf_delta_update: u32,
2168 sign_bias_golden: u32,
2169 sign_bias_alternate: u32,
2170 mb_no_coeff_skip: u32,
2171 loop_filter_disable: u32,
2172 ) -> __BindgenBitfieldUnit<[u8; 3usize]> {
2173 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 3usize]> = Default::default();
2174 __bindgen_bitfield_unit.set(0usize, 1u8, {
2175 let key_frame: u32 = unsafe { ::std::mem::transmute(key_frame) };
2176 key_frame as u64
2177 });
2178 __bindgen_bitfield_unit.set(1usize, 3u8, {
2179 let version: u32 = unsafe { ::std::mem::transmute(version) };
2180 version as u64
2181 });
2182 __bindgen_bitfield_unit.set(4usize, 1u8, {
2183 let segmentation_enabled: u32 = unsafe { ::std::mem::transmute(segmentation_enabled) };
2184 segmentation_enabled as u64
2185 });
2186 __bindgen_bitfield_unit.set(5usize, 1u8, {
2187 let update_mb_segmentation_map: u32 =
2188 unsafe { ::std::mem::transmute(update_mb_segmentation_map) };
2189 update_mb_segmentation_map as u64
2190 });
2191 __bindgen_bitfield_unit.set(6usize, 1u8, {
2192 let update_segment_feature_data: u32 =
2193 unsafe { ::std::mem::transmute(update_segment_feature_data) };
2194 update_segment_feature_data as u64
2195 });
2196 __bindgen_bitfield_unit.set(7usize, 1u8, {
2197 let filter_type: u32 = unsafe { ::std::mem::transmute(filter_type) };
2198 filter_type as u64
2199 });
2200 __bindgen_bitfield_unit.set(8usize, 3u8, {
2201 let sharpness_level: u32 = unsafe { ::std::mem::transmute(sharpness_level) };
2202 sharpness_level as u64
2203 });
2204 __bindgen_bitfield_unit.set(11usize, 1u8, {
2205 let loop_filter_adj_enable: u32 =
2206 unsafe { ::std::mem::transmute(loop_filter_adj_enable) };
2207 loop_filter_adj_enable as u64
2208 });
2209 __bindgen_bitfield_unit.set(12usize, 1u8, {
2210 let mode_ref_lf_delta_update: u32 =
2211 unsafe { ::std::mem::transmute(mode_ref_lf_delta_update) };
2212 mode_ref_lf_delta_update as u64
2213 });
2214 __bindgen_bitfield_unit.set(13usize, 1u8, {
2215 let sign_bias_golden: u32 = unsafe { ::std::mem::transmute(sign_bias_golden) };
2216 sign_bias_golden as u64
2217 });
2218 __bindgen_bitfield_unit.set(14usize, 1u8, {
2219 let sign_bias_alternate: u32 = unsafe { ::std::mem::transmute(sign_bias_alternate) };
2220 sign_bias_alternate as u64
2221 });
2222 __bindgen_bitfield_unit.set(15usize, 1u8, {
2223 let mb_no_coeff_skip: u32 = unsafe { ::std::mem::transmute(mb_no_coeff_skip) };
2224 mb_no_coeff_skip as u64
2225 });
2226 __bindgen_bitfield_unit.set(16usize, 1u8, {
2227 let loop_filter_disable: u32 = unsafe { ::std::mem::transmute(loop_filter_disable) };
2228 loop_filter_disable as u64
2229 });
2230 __bindgen_bitfield_unit
2231 }
2232}
2233impl Default for _VAPictureParameterBufferVP8__bindgen_ty_1 {
2234 fn default() -> Self {
2235 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2236 unsafe {
2237 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2238 s.assume_init()
2239 }
2240 }
2241}
2242impl Default for _VAPictureParameterBufferVP8 {
2243 fn default() -> Self {
2244 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2245 unsafe {
2246 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2247 s.assume_init()
2248 }
2249 }
2250}
2251pub type VAPictureParameterBufferVP8 = _VAPictureParameterBufferVP8;
2252#[repr(C)]
2253#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
2254pub struct _VASliceParameterBufferVP8 {
2255 pub slice_data_size: u32,
2256 pub slice_data_offset: u32,
2257 pub slice_data_flag: u32,
2258 pub macroblock_offset: u32,
2259 pub num_of_partitions: u8,
2260 pub partition_size: [u32; 9usize],
2261 pub va_reserved: [u32; 4usize],
2262}
2263pub type VASliceParameterBufferVP8 = _VASliceParameterBufferVP8;
2264#[repr(C)]
2265#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
2266pub struct _VAProbabilityDataBufferVP8 {
2267 pub dct_coeff_probs: [[[[u8; 11usize]; 3usize]; 8usize]; 4usize],
2268 pub va_reserved: [u32; 4usize],
2269}
2270pub type VAProbabilityDataBufferVP8 = _VAProbabilityDataBufferVP8;
2271#[repr(C)]
2272#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
2273pub struct _VAIQMatrixBufferVP8 {
2274 pub quantization_index: [[u16; 6usize]; 4usize],
2275 pub va_reserved: [u32; 4usize],
2276}
2277pub type VAIQMatrixBufferVP8 = _VAIQMatrixBufferVP8;
2278#[repr(C)]
2279#[derive(Copy, Clone)]
2280pub struct _VADecPictureParameterBufferVP9 {
2281 pub frame_width: u16,
2282 pub frame_height: u16,
2283 pub reference_frames: [VASurfaceID; 8usize],
2284 pub pic_fields: _VADecPictureParameterBufferVP9__bindgen_ty_1,
2285 pub filter_level: u8,
2286 pub sharpness_level: u8,
2287 pub log2_tile_rows: u8,
2288 pub log2_tile_columns: u8,
2289 pub frame_header_length_in_bytes: u8,
2290 pub first_partition_size: u16,
2291 pub mb_segment_tree_probs: [u8; 7usize],
2292 pub segment_pred_probs: [u8; 3usize],
2293 pub profile: u8,
2294 pub bit_depth: u8,
2295 pub va_reserved: [u32; 8usize],
2296}
2297#[repr(C)]
2298#[derive(Copy, Clone)]
2299pub union _VADecPictureParameterBufferVP9__bindgen_ty_1 {
2300 pub bits: _VADecPictureParameterBufferVP9__bindgen_ty_1__bindgen_ty_1,
2301 pub value: u32,
2302}
2303#[repr(C)]
2304#[repr(align(4))]
2305#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
2306pub struct _VADecPictureParameterBufferVP9__bindgen_ty_1__bindgen_ty_1 {
2307 pub _bitfield_align_1: [u8; 0],
2308 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
2309}
2310impl _VADecPictureParameterBufferVP9__bindgen_ty_1__bindgen_ty_1 {
2311 #[inline]
2312 pub fn subsampling_x(&self) -> u32 {
2313 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
2314 }
2315 #[inline]
2316 pub fn set_subsampling_x(&mut self, val: u32) {
2317 unsafe {
2318 let val: u32 = ::std::mem::transmute(val);
2319 self._bitfield_1.set(0usize, 1u8, val as u64)
2320 }
2321 }
2322 #[inline]
2323 pub fn subsampling_y(&self) -> u32 {
2324 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
2325 }
2326 #[inline]
2327 pub fn set_subsampling_y(&mut self, val: u32) {
2328 unsafe {
2329 let val: u32 = ::std::mem::transmute(val);
2330 self._bitfield_1.set(1usize, 1u8, val as u64)
2331 }
2332 }
2333 #[inline]
2334 pub fn frame_type(&self) -> u32 {
2335 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
2336 }
2337 #[inline]
2338 pub fn set_frame_type(&mut self, val: u32) {
2339 unsafe {
2340 let val: u32 = ::std::mem::transmute(val);
2341 self._bitfield_1.set(2usize, 1u8, val as u64)
2342 }
2343 }
2344 #[inline]
2345 pub fn show_frame(&self) -> u32 {
2346 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
2347 }
2348 #[inline]
2349 pub fn set_show_frame(&mut self, val: u32) {
2350 unsafe {
2351 let val: u32 = ::std::mem::transmute(val);
2352 self._bitfield_1.set(3usize, 1u8, val as u64)
2353 }
2354 }
2355 #[inline]
2356 pub fn error_resilient_mode(&self) -> u32 {
2357 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
2358 }
2359 #[inline]
2360 pub fn set_error_resilient_mode(&mut self, val: u32) {
2361 unsafe {
2362 let val: u32 = ::std::mem::transmute(val);
2363 self._bitfield_1.set(4usize, 1u8, val as u64)
2364 }
2365 }
2366 #[inline]
2367 pub fn intra_only(&self) -> u32 {
2368 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
2369 }
2370 #[inline]
2371 pub fn set_intra_only(&mut self, val: u32) {
2372 unsafe {
2373 let val: u32 = ::std::mem::transmute(val);
2374 self._bitfield_1.set(5usize, 1u8, val as u64)
2375 }
2376 }
2377 #[inline]
2378 pub fn allow_high_precision_mv(&self) -> u32 {
2379 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) }
2380 }
2381 #[inline]
2382 pub fn set_allow_high_precision_mv(&mut self, val: u32) {
2383 unsafe {
2384 let val: u32 = ::std::mem::transmute(val);
2385 self._bitfield_1.set(6usize, 1u8, val as u64)
2386 }
2387 }
2388 #[inline]
2389 pub fn mcomp_filter_type(&self) -> u32 {
2390 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 3u8) as u32) }
2391 }
2392 #[inline]
2393 pub fn set_mcomp_filter_type(&mut self, val: u32) {
2394 unsafe {
2395 let val: u32 = ::std::mem::transmute(val);
2396 self._bitfield_1.set(7usize, 3u8, val as u64)
2397 }
2398 }
2399 #[inline]
2400 pub fn frame_parallel_decoding_mode(&self) -> u32 {
2401 unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) }
2402 }
2403 #[inline]
2404 pub fn set_frame_parallel_decoding_mode(&mut self, val: u32) {
2405 unsafe {
2406 let val: u32 = ::std::mem::transmute(val);
2407 self._bitfield_1.set(10usize, 1u8, val as u64)
2408 }
2409 }
2410 #[inline]
2411 pub fn reset_frame_context(&self) -> u32 {
2412 unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 2u8) as u32) }
2413 }
2414 #[inline]
2415 pub fn set_reset_frame_context(&mut self, val: u32) {
2416 unsafe {
2417 let val: u32 = ::std::mem::transmute(val);
2418 self._bitfield_1.set(11usize, 2u8, val as u64)
2419 }
2420 }
2421 #[inline]
2422 pub fn refresh_frame_context(&self) -> u32 {
2423 unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) }
2424 }
2425 #[inline]
2426 pub fn set_refresh_frame_context(&mut self, val: u32) {
2427 unsafe {
2428 let val: u32 = ::std::mem::transmute(val);
2429 self._bitfield_1.set(13usize, 1u8, val as u64)
2430 }
2431 }
2432 #[inline]
2433 pub fn frame_context_idx(&self) -> u32 {
2434 unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 2u8) as u32) }
2435 }
2436 #[inline]
2437 pub fn set_frame_context_idx(&mut self, val: u32) {
2438 unsafe {
2439 let val: u32 = ::std::mem::transmute(val);
2440 self._bitfield_1.set(14usize, 2u8, val as u64)
2441 }
2442 }
2443 #[inline]
2444 pub fn segmentation_enabled(&self) -> u32 {
2445 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u32) }
2446 }
2447 #[inline]
2448 pub fn set_segmentation_enabled(&mut self, val: u32) {
2449 unsafe {
2450 let val: u32 = ::std::mem::transmute(val);
2451 self._bitfield_1.set(16usize, 1u8, val as u64)
2452 }
2453 }
2454 #[inline]
2455 pub fn segmentation_temporal_update(&self) -> u32 {
2456 unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 1u8) as u32) }
2457 }
2458 #[inline]
2459 pub fn set_segmentation_temporal_update(&mut self, val: u32) {
2460 unsafe {
2461 let val: u32 = ::std::mem::transmute(val);
2462 self._bitfield_1.set(17usize, 1u8, val as u64)
2463 }
2464 }
2465 #[inline]
2466 pub fn segmentation_update_map(&self) -> u32 {
2467 unsafe { ::std::mem::transmute(self._bitfield_1.get(18usize, 1u8) as u32) }
2468 }
2469 #[inline]
2470 pub fn set_segmentation_update_map(&mut self, val: u32) {
2471 unsafe {
2472 let val: u32 = ::std::mem::transmute(val);
2473 self._bitfield_1.set(18usize, 1u8, val as u64)
2474 }
2475 }
2476 #[inline]
2477 pub fn last_ref_frame(&self) -> u32 {
2478 unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 3u8) as u32) }
2479 }
2480 #[inline]
2481 pub fn set_last_ref_frame(&mut self, val: u32) {
2482 unsafe {
2483 let val: u32 = ::std::mem::transmute(val);
2484 self._bitfield_1.set(19usize, 3u8, val as u64)
2485 }
2486 }
2487 #[inline]
2488 pub fn last_ref_frame_sign_bias(&self) -> u32 {
2489 unsafe { ::std::mem::transmute(self._bitfield_1.get(22usize, 1u8) as u32) }
2490 }
2491 #[inline]
2492 pub fn set_last_ref_frame_sign_bias(&mut self, val: u32) {
2493 unsafe {
2494 let val: u32 = ::std::mem::transmute(val);
2495 self._bitfield_1.set(22usize, 1u8, val as u64)
2496 }
2497 }
2498 #[inline]
2499 pub fn golden_ref_frame(&self) -> u32 {
2500 unsafe { ::std::mem::transmute(self._bitfield_1.get(23usize, 3u8) as u32) }
2501 }
2502 #[inline]
2503 pub fn set_golden_ref_frame(&mut self, val: u32) {
2504 unsafe {
2505 let val: u32 = ::std::mem::transmute(val);
2506 self._bitfield_1.set(23usize, 3u8, val as u64)
2507 }
2508 }
2509 #[inline]
2510 pub fn golden_ref_frame_sign_bias(&self) -> u32 {
2511 unsafe { ::std::mem::transmute(self._bitfield_1.get(26usize, 1u8) as u32) }
2512 }
2513 #[inline]
2514 pub fn set_golden_ref_frame_sign_bias(&mut self, val: u32) {
2515 unsafe {
2516 let val: u32 = ::std::mem::transmute(val);
2517 self._bitfield_1.set(26usize, 1u8, val as u64)
2518 }
2519 }
2520 #[inline]
2521 pub fn alt_ref_frame(&self) -> u32 {
2522 unsafe { ::std::mem::transmute(self._bitfield_1.get(27usize, 3u8) as u32) }
2523 }
2524 #[inline]
2525 pub fn set_alt_ref_frame(&mut self, val: u32) {
2526 unsafe {
2527 let val: u32 = ::std::mem::transmute(val);
2528 self._bitfield_1.set(27usize, 3u8, val as u64)
2529 }
2530 }
2531 #[inline]
2532 pub fn alt_ref_frame_sign_bias(&self) -> u32 {
2533 unsafe { ::std::mem::transmute(self._bitfield_1.get(30usize, 1u8) as u32) }
2534 }
2535 #[inline]
2536 pub fn set_alt_ref_frame_sign_bias(&mut self, val: u32) {
2537 unsafe {
2538 let val: u32 = ::std::mem::transmute(val);
2539 self._bitfield_1.set(30usize, 1u8, val as u64)
2540 }
2541 }
2542 #[inline]
2543 pub fn lossless_flag(&self) -> u32 {
2544 unsafe { ::std::mem::transmute(self._bitfield_1.get(31usize, 1u8) as u32) }
2545 }
2546 #[inline]
2547 pub fn set_lossless_flag(&mut self, val: u32) {
2548 unsafe {
2549 let val: u32 = ::std::mem::transmute(val);
2550 self._bitfield_1.set(31usize, 1u8, val as u64)
2551 }
2552 }
2553 #[inline]
2554 pub fn new_bitfield_1(
2555 subsampling_x: u32,
2556 subsampling_y: u32,
2557 frame_type: u32,
2558 show_frame: u32,
2559 error_resilient_mode: u32,
2560 intra_only: u32,
2561 allow_high_precision_mv: u32,
2562 mcomp_filter_type: u32,
2563 frame_parallel_decoding_mode: u32,
2564 reset_frame_context: u32,
2565 refresh_frame_context: u32,
2566 frame_context_idx: u32,
2567 segmentation_enabled: u32,
2568 segmentation_temporal_update: u32,
2569 segmentation_update_map: u32,
2570 last_ref_frame: u32,
2571 last_ref_frame_sign_bias: u32,
2572 golden_ref_frame: u32,
2573 golden_ref_frame_sign_bias: u32,
2574 alt_ref_frame: u32,
2575 alt_ref_frame_sign_bias: u32,
2576 lossless_flag: u32,
2577 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
2578 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
2579 __bindgen_bitfield_unit.set(0usize, 1u8, {
2580 let subsampling_x: u32 = unsafe { ::std::mem::transmute(subsampling_x) };
2581 subsampling_x as u64
2582 });
2583 __bindgen_bitfield_unit.set(1usize, 1u8, {
2584 let subsampling_y: u32 = unsafe { ::std::mem::transmute(subsampling_y) };
2585 subsampling_y as u64
2586 });
2587 __bindgen_bitfield_unit.set(2usize, 1u8, {
2588 let frame_type: u32 = unsafe { ::std::mem::transmute(frame_type) };
2589 frame_type as u64
2590 });
2591 __bindgen_bitfield_unit.set(3usize, 1u8, {
2592 let show_frame: u32 = unsafe { ::std::mem::transmute(show_frame) };
2593 show_frame as u64
2594 });
2595 __bindgen_bitfield_unit.set(4usize, 1u8, {
2596 let error_resilient_mode: u32 = unsafe { ::std::mem::transmute(error_resilient_mode) };
2597 error_resilient_mode as u64
2598 });
2599 __bindgen_bitfield_unit.set(5usize, 1u8, {
2600 let intra_only: u32 = unsafe { ::std::mem::transmute(intra_only) };
2601 intra_only as u64
2602 });
2603 __bindgen_bitfield_unit.set(6usize, 1u8, {
2604 let allow_high_precision_mv: u32 =
2605 unsafe { ::std::mem::transmute(allow_high_precision_mv) };
2606 allow_high_precision_mv as u64
2607 });
2608 __bindgen_bitfield_unit.set(7usize, 3u8, {
2609 let mcomp_filter_type: u32 = unsafe { ::std::mem::transmute(mcomp_filter_type) };
2610 mcomp_filter_type as u64
2611 });
2612 __bindgen_bitfield_unit.set(10usize, 1u8, {
2613 let frame_parallel_decoding_mode: u32 =
2614 unsafe { ::std::mem::transmute(frame_parallel_decoding_mode) };
2615 frame_parallel_decoding_mode as u64
2616 });
2617 __bindgen_bitfield_unit.set(11usize, 2u8, {
2618 let reset_frame_context: u32 = unsafe { ::std::mem::transmute(reset_frame_context) };
2619 reset_frame_context as u64
2620 });
2621 __bindgen_bitfield_unit.set(13usize, 1u8, {
2622 let refresh_frame_context: u32 =
2623 unsafe { ::std::mem::transmute(refresh_frame_context) };
2624 refresh_frame_context as u64
2625 });
2626 __bindgen_bitfield_unit.set(14usize, 2u8, {
2627 let frame_context_idx: u32 = unsafe { ::std::mem::transmute(frame_context_idx) };
2628 frame_context_idx as u64
2629 });
2630 __bindgen_bitfield_unit.set(16usize, 1u8, {
2631 let segmentation_enabled: u32 = unsafe { ::std::mem::transmute(segmentation_enabled) };
2632 segmentation_enabled as u64
2633 });
2634 __bindgen_bitfield_unit.set(17usize, 1u8, {
2635 let segmentation_temporal_update: u32 =
2636 unsafe { ::std::mem::transmute(segmentation_temporal_update) };
2637 segmentation_temporal_update as u64
2638 });
2639 __bindgen_bitfield_unit.set(18usize, 1u8, {
2640 let segmentation_update_map: u32 =
2641 unsafe { ::std::mem::transmute(segmentation_update_map) };
2642 segmentation_update_map as u64
2643 });
2644 __bindgen_bitfield_unit.set(19usize, 3u8, {
2645 let last_ref_frame: u32 = unsafe { ::std::mem::transmute(last_ref_frame) };
2646 last_ref_frame as u64
2647 });
2648 __bindgen_bitfield_unit.set(22usize, 1u8, {
2649 let last_ref_frame_sign_bias: u32 =
2650 unsafe { ::std::mem::transmute(last_ref_frame_sign_bias) };
2651 last_ref_frame_sign_bias as u64
2652 });
2653 __bindgen_bitfield_unit.set(23usize, 3u8, {
2654 let golden_ref_frame: u32 = unsafe { ::std::mem::transmute(golden_ref_frame) };
2655 golden_ref_frame as u64
2656 });
2657 __bindgen_bitfield_unit.set(26usize, 1u8, {
2658 let golden_ref_frame_sign_bias: u32 =
2659 unsafe { ::std::mem::transmute(golden_ref_frame_sign_bias) };
2660 golden_ref_frame_sign_bias as u64
2661 });
2662 __bindgen_bitfield_unit.set(27usize, 3u8, {
2663 let alt_ref_frame: u32 = unsafe { ::std::mem::transmute(alt_ref_frame) };
2664 alt_ref_frame as u64
2665 });
2666 __bindgen_bitfield_unit.set(30usize, 1u8, {
2667 let alt_ref_frame_sign_bias: u32 =
2668 unsafe { ::std::mem::transmute(alt_ref_frame_sign_bias) };
2669 alt_ref_frame_sign_bias as u64
2670 });
2671 __bindgen_bitfield_unit.set(31usize, 1u8, {
2672 let lossless_flag: u32 = unsafe { ::std::mem::transmute(lossless_flag) };
2673 lossless_flag as u64
2674 });
2675 __bindgen_bitfield_unit
2676 }
2677}
2678impl Default for _VADecPictureParameterBufferVP9__bindgen_ty_1 {
2679 fn default() -> Self {
2680 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2681 unsafe {
2682 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2683 s.assume_init()
2684 }
2685 }
2686}
2687impl Default for _VADecPictureParameterBufferVP9 {
2688 fn default() -> Self {
2689 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2690 unsafe {
2691 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2692 s.assume_init()
2693 }
2694 }
2695}
2696pub type VADecPictureParameterBufferVP9 = _VADecPictureParameterBufferVP9;
2697#[repr(C)]
2698#[derive(Copy, Clone)]
2699pub struct _VASegmentParameterVP9 {
2700 pub segment_flags: _VASegmentParameterVP9__bindgen_ty_1,
2701 pub filter_level: [[u8; 2usize]; 4usize],
2702 pub luma_ac_quant_scale: i16,
2703 pub luma_dc_quant_scale: i16,
2704 pub chroma_ac_quant_scale: i16,
2705 pub chroma_dc_quant_scale: i16,
2706 pub va_reserved: [u32; 4usize],
2707}
2708#[repr(C)]
2709#[derive(Copy, Clone)]
2710pub union _VASegmentParameterVP9__bindgen_ty_1 {
2711 pub fields: _VASegmentParameterVP9__bindgen_ty_1__bindgen_ty_1,
2712 pub value: u16,
2713}
2714#[repr(C)]
2715#[repr(align(2))]
2716#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
2717pub struct _VASegmentParameterVP9__bindgen_ty_1__bindgen_ty_1 {
2718 pub _bitfield_align_1: [u8; 0],
2719 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
2720 pub __bindgen_padding_0: u8,
2721}
2722impl _VASegmentParameterVP9__bindgen_ty_1__bindgen_ty_1 {
2723 #[inline]
2724 pub fn segment_reference_enabled(&self) -> u16 {
2725 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u16) }
2726 }
2727 #[inline]
2728 pub fn set_segment_reference_enabled(&mut self, val: u16) {
2729 unsafe {
2730 let val: u16 = ::std::mem::transmute(val);
2731 self._bitfield_1.set(0usize, 1u8, val as u64)
2732 }
2733 }
2734 #[inline]
2735 pub fn segment_reference(&self) -> u16 {
2736 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 2u8) as u16) }
2737 }
2738 #[inline]
2739 pub fn set_segment_reference(&mut self, val: u16) {
2740 unsafe {
2741 let val: u16 = ::std::mem::transmute(val);
2742 self._bitfield_1.set(1usize, 2u8, val as u64)
2743 }
2744 }
2745 #[inline]
2746 pub fn segment_reference_skipped(&self) -> u16 {
2747 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u16) }
2748 }
2749 #[inline]
2750 pub fn set_segment_reference_skipped(&mut self, val: u16) {
2751 unsafe {
2752 let val: u16 = ::std::mem::transmute(val);
2753 self._bitfield_1.set(3usize, 1u8, val as u64)
2754 }
2755 }
2756 #[inline]
2757 pub fn new_bitfield_1(
2758 segment_reference_enabled: u16,
2759 segment_reference: u16,
2760 segment_reference_skipped: u16,
2761 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
2762 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
2763 __bindgen_bitfield_unit.set(0usize, 1u8, {
2764 let segment_reference_enabled: u16 =
2765 unsafe { ::std::mem::transmute(segment_reference_enabled) };
2766 segment_reference_enabled as u64
2767 });
2768 __bindgen_bitfield_unit.set(1usize, 2u8, {
2769 let segment_reference: u16 = unsafe { ::std::mem::transmute(segment_reference) };
2770 segment_reference as u64
2771 });
2772 __bindgen_bitfield_unit.set(3usize, 1u8, {
2773 let segment_reference_skipped: u16 =
2774 unsafe { ::std::mem::transmute(segment_reference_skipped) };
2775 segment_reference_skipped as u64
2776 });
2777 __bindgen_bitfield_unit
2778 }
2779}
2780impl Default for _VASegmentParameterVP9__bindgen_ty_1 {
2781 fn default() -> Self {
2782 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2783 unsafe {
2784 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2785 s.assume_init()
2786 }
2787 }
2788}
2789impl Default for _VASegmentParameterVP9 {
2790 fn default() -> Self {
2791 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2792 unsafe {
2793 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2794 s.assume_init()
2795 }
2796 }
2797}
2798pub type VASegmentParameterVP9 = _VASegmentParameterVP9;
2799#[repr(C)]
2800#[derive(Copy, Clone)]
2801pub struct _VASliceParameterBufferVP9 {
2802 pub slice_data_size: u32,
2803 pub slice_data_offset: u32,
2804 pub slice_data_flag: u32,
2805 pub seg_param: [VASegmentParameterVP9; 8usize],
2806 pub va_reserved: [u32; 4usize],
2807}
2808impl Default for _VASliceParameterBufferVP9 {
2809 fn default() -> Self {
2810 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2811 unsafe {
2812 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2813 s.assume_init()
2814 }
2815 }
2816}
2817pub type VASliceParameterBufferVP9 = _VASliceParameterBufferVP9;
2818#[repr(C)]
2819#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
2820pub struct _VAPictureStats {
2821 pub picture_id: VASurfaceID,
2822 pub flags: u32,
2823}
2824pub type VAPictureStats = _VAPictureStats;
2825#[repr(C)]
2826#[derive(Debug, Copy, Clone, PartialEq, Eq)]
2827pub struct _VAStatsStatisticsParameter {
2828 pub input: VAPictureStats,
2829 pub past_references: *mut VAPictureStats,
2830 pub num_past_references: u32,
2831 pub past_ref_stat_buf: *mut VABufferID,
2832 pub future_references: *mut VAPictureStats,
2833 pub num_future_references: u32,
2834 pub future_ref_stat_buf: *mut VABufferID,
2835 pub outputs: *mut VABufferID,
2836 pub mv_predictor: VABufferID,
2837 pub qp: VABufferID,
2838}
2839impl Default for _VAStatsStatisticsParameter {
2840 fn default() -> Self {
2841 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2842 unsafe {
2843 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2844 s.assume_init()
2845 }
2846 }
2847}
2848pub type VAStatsStatisticsParameter = _VAStatsStatisticsParameter;
2849pub mod VAEncPackedHeaderTypeH264 {
2850 pub type Type = ::std::os::raw::c_uint;
2851 pub const VAEncPackedHeaderH264_SPS: Type = 1;
2852 pub const VAEncPackedHeaderH264_PPS: Type = 2;
2853 pub const VAEncPackedHeaderH264_Slice: Type = 3;
2854 pub const VAEncPackedHeaderH264_SEI: Type = 2147483649;
2855}
2856#[repr(C)]
2857#[derive(Copy, Clone)]
2858pub struct _VAEncSequenceParameterBufferH264 {
2859 pub seq_parameter_set_id: u8,
2860 pub level_idc: u8,
2861 pub intra_period: u32,
2862 pub intra_idr_period: u32,
2863 pub ip_period: u32,
2864 pub bits_per_second: u32,
2865 pub max_num_ref_frames: u32,
2866 pub picture_width_in_mbs: u16,
2867 pub picture_height_in_mbs: u16,
2868 pub seq_fields: _VAEncSequenceParameterBufferH264__bindgen_ty_1,
2869 pub bit_depth_luma_minus8: u8,
2870 pub bit_depth_chroma_minus8: u8,
2871 pub num_ref_frames_in_pic_order_cnt_cycle: u8,
2872 pub offset_for_non_ref_pic: i32,
2873 pub offset_for_top_to_bottom_field: i32,
2874 pub offset_for_ref_frame: [i32; 256usize],
2875 pub frame_cropping_flag: u8,
2876 pub frame_crop_left_offset: u32,
2877 pub frame_crop_right_offset: u32,
2878 pub frame_crop_top_offset: u32,
2879 pub frame_crop_bottom_offset: u32,
2880 pub vui_parameters_present_flag: u8,
2881 pub vui_fields: _VAEncSequenceParameterBufferH264__bindgen_ty_2,
2882 pub aspect_ratio_idc: u8,
2883 pub sar_width: u32,
2884 pub sar_height: u32,
2885 pub num_units_in_tick: u32,
2886 pub time_scale: u32,
2887 pub va_reserved: [u32; 4usize],
2888}
2889#[repr(C)]
2890#[derive(Copy, Clone)]
2891pub union _VAEncSequenceParameterBufferH264__bindgen_ty_1 {
2892 pub bits: _VAEncSequenceParameterBufferH264__bindgen_ty_1__bindgen_ty_1,
2893 pub value: u32,
2894}
2895#[repr(C)]
2896#[repr(align(4))]
2897#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
2898pub struct _VAEncSequenceParameterBufferH264__bindgen_ty_1__bindgen_ty_1 {
2899 pub _bitfield_align_1: [u8; 0],
2900 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 3usize]>,
2901 pub __bindgen_padding_0: u8,
2902}
2903impl _VAEncSequenceParameterBufferH264__bindgen_ty_1__bindgen_ty_1 {
2904 #[inline]
2905 pub fn chroma_format_idc(&self) -> u32 {
2906 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u32) }
2907 }
2908 #[inline]
2909 pub fn set_chroma_format_idc(&mut self, val: u32) {
2910 unsafe {
2911 let val: u32 = ::std::mem::transmute(val);
2912 self._bitfield_1.set(0usize, 2u8, val as u64)
2913 }
2914 }
2915 #[inline]
2916 pub fn frame_mbs_only_flag(&self) -> u32 {
2917 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
2918 }
2919 #[inline]
2920 pub fn set_frame_mbs_only_flag(&mut self, val: u32) {
2921 unsafe {
2922 let val: u32 = ::std::mem::transmute(val);
2923 self._bitfield_1.set(2usize, 1u8, val as u64)
2924 }
2925 }
2926 #[inline]
2927 pub fn mb_adaptive_frame_field_flag(&self) -> u32 {
2928 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
2929 }
2930 #[inline]
2931 pub fn set_mb_adaptive_frame_field_flag(&mut self, val: u32) {
2932 unsafe {
2933 let val: u32 = ::std::mem::transmute(val);
2934 self._bitfield_1.set(3usize, 1u8, val as u64)
2935 }
2936 }
2937 #[inline]
2938 pub fn seq_scaling_matrix_present_flag(&self) -> u32 {
2939 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
2940 }
2941 #[inline]
2942 pub fn set_seq_scaling_matrix_present_flag(&mut self, val: u32) {
2943 unsafe {
2944 let val: u32 = ::std::mem::transmute(val);
2945 self._bitfield_1.set(4usize, 1u8, val as u64)
2946 }
2947 }
2948 #[inline]
2949 pub fn direct_8x8_inference_flag(&self) -> u32 {
2950 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
2951 }
2952 #[inline]
2953 pub fn set_direct_8x8_inference_flag(&mut self, val: u32) {
2954 unsafe {
2955 let val: u32 = ::std::mem::transmute(val);
2956 self._bitfield_1.set(5usize, 1u8, val as u64)
2957 }
2958 }
2959 #[inline]
2960 pub fn log2_max_frame_num_minus4(&self) -> u32 {
2961 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 4u8) as u32) }
2962 }
2963 #[inline]
2964 pub fn set_log2_max_frame_num_minus4(&mut self, val: u32) {
2965 unsafe {
2966 let val: u32 = ::std::mem::transmute(val);
2967 self._bitfield_1.set(6usize, 4u8, val as u64)
2968 }
2969 }
2970 #[inline]
2971 pub fn pic_order_cnt_type(&self) -> u32 {
2972 unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 2u8) as u32) }
2973 }
2974 #[inline]
2975 pub fn set_pic_order_cnt_type(&mut self, val: u32) {
2976 unsafe {
2977 let val: u32 = ::std::mem::transmute(val);
2978 self._bitfield_1.set(10usize, 2u8, val as u64)
2979 }
2980 }
2981 #[inline]
2982 pub fn log2_max_pic_order_cnt_lsb_minus4(&self) -> u32 {
2983 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 4u8) as u32) }
2984 }
2985 #[inline]
2986 pub fn set_log2_max_pic_order_cnt_lsb_minus4(&mut self, val: u32) {
2987 unsafe {
2988 let val: u32 = ::std::mem::transmute(val);
2989 self._bitfield_1.set(12usize, 4u8, val as u64)
2990 }
2991 }
2992 #[inline]
2993 pub fn delta_pic_order_always_zero_flag(&self) -> u32 {
2994 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u32) }
2995 }
2996 #[inline]
2997 pub fn set_delta_pic_order_always_zero_flag(&mut self, val: u32) {
2998 unsafe {
2999 let val: u32 = ::std::mem::transmute(val);
3000 self._bitfield_1.set(16usize, 1u8, val as u64)
3001 }
3002 }
3003 #[inline]
3004 pub fn new_bitfield_1(
3005 chroma_format_idc: u32,
3006 frame_mbs_only_flag: u32,
3007 mb_adaptive_frame_field_flag: u32,
3008 seq_scaling_matrix_present_flag: u32,
3009 direct_8x8_inference_flag: u32,
3010 log2_max_frame_num_minus4: u32,
3011 pic_order_cnt_type: u32,
3012 log2_max_pic_order_cnt_lsb_minus4: u32,
3013 delta_pic_order_always_zero_flag: u32,
3014 ) -> __BindgenBitfieldUnit<[u8; 3usize]> {
3015 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 3usize]> = Default::default();
3016 __bindgen_bitfield_unit.set(0usize, 2u8, {
3017 let chroma_format_idc: u32 = unsafe { ::std::mem::transmute(chroma_format_idc) };
3018 chroma_format_idc as u64
3019 });
3020 __bindgen_bitfield_unit.set(2usize, 1u8, {
3021 let frame_mbs_only_flag: u32 = unsafe { ::std::mem::transmute(frame_mbs_only_flag) };
3022 frame_mbs_only_flag as u64
3023 });
3024 __bindgen_bitfield_unit.set(3usize, 1u8, {
3025 let mb_adaptive_frame_field_flag: u32 =
3026 unsafe { ::std::mem::transmute(mb_adaptive_frame_field_flag) };
3027 mb_adaptive_frame_field_flag as u64
3028 });
3029 __bindgen_bitfield_unit.set(4usize, 1u8, {
3030 let seq_scaling_matrix_present_flag: u32 =
3031 unsafe { ::std::mem::transmute(seq_scaling_matrix_present_flag) };
3032 seq_scaling_matrix_present_flag as u64
3033 });
3034 __bindgen_bitfield_unit.set(5usize, 1u8, {
3035 let direct_8x8_inference_flag: u32 =
3036 unsafe { ::std::mem::transmute(direct_8x8_inference_flag) };
3037 direct_8x8_inference_flag as u64
3038 });
3039 __bindgen_bitfield_unit.set(6usize, 4u8, {
3040 let log2_max_frame_num_minus4: u32 =
3041 unsafe { ::std::mem::transmute(log2_max_frame_num_minus4) };
3042 log2_max_frame_num_minus4 as u64
3043 });
3044 __bindgen_bitfield_unit.set(10usize, 2u8, {
3045 let pic_order_cnt_type: u32 = unsafe { ::std::mem::transmute(pic_order_cnt_type) };
3046 pic_order_cnt_type as u64
3047 });
3048 __bindgen_bitfield_unit.set(12usize, 4u8, {
3049 let log2_max_pic_order_cnt_lsb_minus4: u32 =
3050 unsafe { ::std::mem::transmute(log2_max_pic_order_cnt_lsb_minus4) };
3051 log2_max_pic_order_cnt_lsb_minus4 as u64
3052 });
3053 __bindgen_bitfield_unit.set(16usize, 1u8, {
3054 let delta_pic_order_always_zero_flag: u32 =
3055 unsafe { ::std::mem::transmute(delta_pic_order_always_zero_flag) };
3056 delta_pic_order_always_zero_flag as u64
3057 });
3058 __bindgen_bitfield_unit
3059 }
3060}
3061impl Default for _VAEncSequenceParameterBufferH264__bindgen_ty_1 {
3062 fn default() -> Self {
3063 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3064 unsafe {
3065 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3066 s.assume_init()
3067 }
3068 }
3069}
3070#[repr(C)]
3071#[derive(Copy, Clone)]
3072pub union _VAEncSequenceParameterBufferH264__bindgen_ty_2 {
3073 pub bits: _VAEncSequenceParameterBufferH264__bindgen_ty_2__bindgen_ty_1,
3074 pub value: u32,
3075}
3076#[repr(C)]
3077#[repr(align(4))]
3078#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
3079pub struct _VAEncSequenceParameterBufferH264__bindgen_ty_2__bindgen_ty_1 {
3080 pub _bitfield_align_1: [u16; 0],
3081 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
3082}
3083impl _VAEncSequenceParameterBufferH264__bindgen_ty_2__bindgen_ty_1 {
3084 #[inline]
3085 pub fn aspect_ratio_info_present_flag(&self) -> u32 {
3086 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
3087 }
3088 #[inline]
3089 pub fn set_aspect_ratio_info_present_flag(&mut self, val: u32) {
3090 unsafe {
3091 let val: u32 = ::std::mem::transmute(val);
3092 self._bitfield_1.set(0usize, 1u8, val as u64)
3093 }
3094 }
3095 #[inline]
3096 pub fn timing_info_present_flag(&self) -> u32 {
3097 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
3098 }
3099 #[inline]
3100 pub fn set_timing_info_present_flag(&mut self, val: u32) {
3101 unsafe {
3102 let val: u32 = ::std::mem::transmute(val);
3103 self._bitfield_1.set(1usize, 1u8, val as u64)
3104 }
3105 }
3106 #[inline]
3107 pub fn bitstream_restriction_flag(&self) -> u32 {
3108 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
3109 }
3110 #[inline]
3111 pub fn set_bitstream_restriction_flag(&mut self, val: u32) {
3112 unsafe {
3113 let val: u32 = ::std::mem::transmute(val);
3114 self._bitfield_1.set(2usize, 1u8, val as u64)
3115 }
3116 }
3117 #[inline]
3118 pub fn log2_max_mv_length_horizontal(&self) -> u32 {
3119 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 5u8) as u32) }
3120 }
3121 #[inline]
3122 pub fn set_log2_max_mv_length_horizontal(&mut self, val: u32) {
3123 unsafe {
3124 let val: u32 = ::std::mem::transmute(val);
3125 self._bitfield_1.set(3usize, 5u8, val as u64)
3126 }
3127 }
3128 #[inline]
3129 pub fn log2_max_mv_length_vertical(&self) -> u32 {
3130 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 5u8) as u32) }
3131 }
3132 #[inline]
3133 pub fn set_log2_max_mv_length_vertical(&mut self, val: u32) {
3134 unsafe {
3135 let val: u32 = ::std::mem::transmute(val);
3136 self._bitfield_1.set(8usize, 5u8, val as u64)
3137 }
3138 }
3139 #[inline]
3140 pub fn fixed_frame_rate_flag(&self) -> u32 {
3141 unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) }
3142 }
3143 #[inline]
3144 pub fn set_fixed_frame_rate_flag(&mut self, val: u32) {
3145 unsafe {
3146 let val: u32 = ::std::mem::transmute(val);
3147 self._bitfield_1.set(13usize, 1u8, val as u64)
3148 }
3149 }
3150 #[inline]
3151 pub fn low_delay_hrd_flag(&self) -> u32 {
3152 unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) }
3153 }
3154 #[inline]
3155 pub fn set_low_delay_hrd_flag(&mut self, val: u32) {
3156 unsafe {
3157 let val: u32 = ::std::mem::transmute(val);
3158 self._bitfield_1.set(14usize, 1u8, val as u64)
3159 }
3160 }
3161 #[inline]
3162 pub fn motion_vectors_over_pic_boundaries_flag(&self) -> u32 {
3163 unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u32) }
3164 }
3165 #[inline]
3166 pub fn set_motion_vectors_over_pic_boundaries_flag(&mut self, val: u32) {
3167 unsafe {
3168 let val: u32 = ::std::mem::transmute(val);
3169 self._bitfield_1.set(15usize, 1u8, val as u64)
3170 }
3171 }
3172 #[inline]
3173 pub fn reserved(&self) -> u32 {
3174 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 16u8) as u32) }
3175 }
3176 #[inline]
3177 pub fn set_reserved(&mut self, val: u32) {
3178 unsafe {
3179 let val: u32 = ::std::mem::transmute(val);
3180 self._bitfield_1.set(16usize, 16u8, val as u64)
3181 }
3182 }
3183 #[inline]
3184 pub fn new_bitfield_1(
3185 aspect_ratio_info_present_flag: u32,
3186 timing_info_present_flag: u32,
3187 bitstream_restriction_flag: u32,
3188 log2_max_mv_length_horizontal: u32,
3189 log2_max_mv_length_vertical: u32,
3190 fixed_frame_rate_flag: u32,
3191 low_delay_hrd_flag: u32,
3192 motion_vectors_over_pic_boundaries_flag: u32,
3193 reserved: u32,
3194 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
3195 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
3196 __bindgen_bitfield_unit.set(0usize, 1u8, {
3197 let aspect_ratio_info_present_flag: u32 =
3198 unsafe { ::std::mem::transmute(aspect_ratio_info_present_flag) };
3199 aspect_ratio_info_present_flag as u64
3200 });
3201 __bindgen_bitfield_unit.set(1usize, 1u8, {
3202 let timing_info_present_flag: u32 =
3203 unsafe { ::std::mem::transmute(timing_info_present_flag) };
3204 timing_info_present_flag as u64
3205 });
3206 __bindgen_bitfield_unit.set(2usize, 1u8, {
3207 let bitstream_restriction_flag: u32 =
3208 unsafe { ::std::mem::transmute(bitstream_restriction_flag) };
3209 bitstream_restriction_flag as u64
3210 });
3211 __bindgen_bitfield_unit.set(3usize, 5u8, {
3212 let log2_max_mv_length_horizontal: u32 =
3213 unsafe { ::std::mem::transmute(log2_max_mv_length_horizontal) };
3214 log2_max_mv_length_horizontal as u64
3215 });
3216 __bindgen_bitfield_unit.set(8usize, 5u8, {
3217 let log2_max_mv_length_vertical: u32 =
3218 unsafe { ::std::mem::transmute(log2_max_mv_length_vertical) };
3219 log2_max_mv_length_vertical as u64
3220 });
3221 __bindgen_bitfield_unit.set(13usize, 1u8, {
3222 let fixed_frame_rate_flag: u32 =
3223 unsafe { ::std::mem::transmute(fixed_frame_rate_flag) };
3224 fixed_frame_rate_flag as u64
3225 });
3226 __bindgen_bitfield_unit.set(14usize, 1u8, {
3227 let low_delay_hrd_flag: u32 = unsafe { ::std::mem::transmute(low_delay_hrd_flag) };
3228 low_delay_hrd_flag as u64
3229 });
3230 __bindgen_bitfield_unit.set(15usize, 1u8, {
3231 let motion_vectors_over_pic_boundaries_flag: u32 =
3232 unsafe { ::std::mem::transmute(motion_vectors_over_pic_boundaries_flag) };
3233 motion_vectors_over_pic_boundaries_flag as u64
3234 });
3235 __bindgen_bitfield_unit.set(16usize, 16u8, {
3236 let reserved: u32 = unsafe { ::std::mem::transmute(reserved) };
3237 reserved as u64
3238 });
3239 __bindgen_bitfield_unit
3240 }
3241}
3242impl Default for _VAEncSequenceParameterBufferH264__bindgen_ty_2 {
3243 fn default() -> Self {
3244 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3245 unsafe {
3246 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3247 s.assume_init()
3248 }
3249 }
3250}
3251impl Default for _VAEncSequenceParameterBufferH264 {
3252 fn default() -> Self {
3253 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3254 unsafe {
3255 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3256 s.assume_init()
3257 }
3258 }
3259}
3260pub type VAEncSequenceParameterBufferH264 = _VAEncSequenceParameterBufferH264;
3261#[repr(C)]
3262#[derive(Copy, Clone)]
3263pub struct _VAEncPictureParameterBufferH264 {
3264 pub CurrPic: VAPictureH264,
3265 pub ReferenceFrames: [VAPictureH264; 16usize],
3266 pub coded_buf: VABufferID,
3267 pub pic_parameter_set_id: u8,
3268 pub seq_parameter_set_id: u8,
3269 pub last_picture: u8,
3270 pub frame_num: u16,
3271 pub pic_init_qp: u8,
3272 pub num_ref_idx_l0_active_minus1: u8,
3273 pub num_ref_idx_l1_active_minus1: u8,
3274 pub chroma_qp_index_offset: i8,
3275 pub second_chroma_qp_index_offset: i8,
3276 pub pic_fields: _VAEncPictureParameterBufferH264__bindgen_ty_1,
3277 pub va_reserved: [u32; 4usize],
3278}
3279#[repr(C)]
3280#[derive(Copy, Clone)]
3281pub union _VAEncPictureParameterBufferH264__bindgen_ty_1 {
3282 pub bits: _VAEncPictureParameterBufferH264__bindgen_ty_1__bindgen_ty_1,
3283 pub value: u32,
3284}
3285#[repr(C)]
3286#[repr(align(4))]
3287#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
3288pub struct _VAEncPictureParameterBufferH264__bindgen_ty_1__bindgen_ty_1 {
3289 pub _bitfield_align_1: [u8; 0],
3290 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
3291 pub __bindgen_padding_0: u16,
3292}
3293impl _VAEncPictureParameterBufferH264__bindgen_ty_1__bindgen_ty_1 {
3294 #[inline]
3295 pub fn idr_pic_flag(&self) -> u32 {
3296 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
3297 }
3298 #[inline]
3299 pub fn set_idr_pic_flag(&mut self, val: u32) {
3300 unsafe {
3301 let val: u32 = ::std::mem::transmute(val);
3302 self._bitfield_1.set(0usize, 1u8, val as u64)
3303 }
3304 }
3305 #[inline]
3306 pub fn reference_pic_flag(&self) -> u32 {
3307 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 2u8) as u32) }
3308 }
3309 #[inline]
3310 pub fn set_reference_pic_flag(&mut self, val: u32) {
3311 unsafe {
3312 let val: u32 = ::std::mem::transmute(val);
3313 self._bitfield_1.set(1usize, 2u8, val as u64)
3314 }
3315 }
3316 #[inline]
3317 pub fn entropy_coding_mode_flag(&self) -> u32 {
3318 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
3319 }
3320 #[inline]
3321 pub fn set_entropy_coding_mode_flag(&mut self, val: u32) {
3322 unsafe {
3323 let val: u32 = ::std::mem::transmute(val);
3324 self._bitfield_1.set(3usize, 1u8, val as u64)
3325 }
3326 }
3327 #[inline]
3328 pub fn weighted_pred_flag(&self) -> u32 {
3329 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
3330 }
3331 #[inline]
3332 pub fn set_weighted_pred_flag(&mut self, val: u32) {
3333 unsafe {
3334 let val: u32 = ::std::mem::transmute(val);
3335 self._bitfield_1.set(4usize, 1u8, val as u64)
3336 }
3337 }
3338 #[inline]
3339 pub fn weighted_bipred_idc(&self) -> u32 {
3340 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 2u8) as u32) }
3341 }
3342 #[inline]
3343 pub fn set_weighted_bipred_idc(&mut self, val: u32) {
3344 unsafe {
3345 let val: u32 = ::std::mem::transmute(val);
3346 self._bitfield_1.set(5usize, 2u8, val as u64)
3347 }
3348 }
3349 #[inline]
3350 pub fn constrained_intra_pred_flag(&self) -> u32 {
3351 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) }
3352 }
3353 #[inline]
3354 pub fn set_constrained_intra_pred_flag(&mut self, val: u32) {
3355 unsafe {
3356 let val: u32 = ::std::mem::transmute(val);
3357 self._bitfield_1.set(7usize, 1u8, val as u64)
3358 }
3359 }
3360 #[inline]
3361 pub fn transform_8x8_mode_flag(&self) -> u32 {
3362 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) }
3363 }
3364 #[inline]
3365 pub fn set_transform_8x8_mode_flag(&mut self, val: u32) {
3366 unsafe {
3367 let val: u32 = ::std::mem::transmute(val);
3368 self._bitfield_1.set(8usize, 1u8, val as u64)
3369 }
3370 }
3371 #[inline]
3372 pub fn deblocking_filter_control_present_flag(&self) -> u32 {
3373 unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) }
3374 }
3375 #[inline]
3376 pub fn set_deblocking_filter_control_present_flag(&mut self, val: u32) {
3377 unsafe {
3378 let val: u32 = ::std::mem::transmute(val);
3379 self._bitfield_1.set(9usize, 1u8, val as u64)
3380 }
3381 }
3382 #[inline]
3383 pub fn redundant_pic_cnt_present_flag(&self) -> u32 {
3384 unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) }
3385 }
3386 #[inline]
3387 pub fn set_redundant_pic_cnt_present_flag(&mut self, val: u32) {
3388 unsafe {
3389 let val: u32 = ::std::mem::transmute(val);
3390 self._bitfield_1.set(10usize, 1u8, val as u64)
3391 }
3392 }
3393 #[inline]
3394 pub fn pic_order_present_flag(&self) -> u32 {
3395 unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) }
3396 }
3397 #[inline]
3398 pub fn set_pic_order_present_flag(&mut self, val: u32) {
3399 unsafe {
3400 let val: u32 = ::std::mem::transmute(val);
3401 self._bitfield_1.set(11usize, 1u8, val as u64)
3402 }
3403 }
3404 #[inline]
3405 pub fn pic_scaling_matrix_present_flag(&self) -> u32 {
3406 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u32) }
3407 }
3408 #[inline]
3409 pub fn set_pic_scaling_matrix_present_flag(&mut self, val: u32) {
3410 unsafe {
3411 let val: u32 = ::std::mem::transmute(val);
3412 self._bitfield_1.set(12usize, 1u8, val as u64)
3413 }
3414 }
3415 #[inline]
3416 pub fn new_bitfield_1(
3417 idr_pic_flag: u32,
3418 reference_pic_flag: u32,
3419 entropy_coding_mode_flag: u32,
3420 weighted_pred_flag: u32,
3421 weighted_bipred_idc: u32,
3422 constrained_intra_pred_flag: u32,
3423 transform_8x8_mode_flag: u32,
3424 deblocking_filter_control_present_flag: u32,
3425 redundant_pic_cnt_present_flag: u32,
3426 pic_order_present_flag: u32,
3427 pic_scaling_matrix_present_flag: u32,
3428 ) -> __BindgenBitfieldUnit<[u8; 2usize]> {
3429 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default();
3430 __bindgen_bitfield_unit.set(0usize, 1u8, {
3431 let idr_pic_flag: u32 = unsafe { ::std::mem::transmute(idr_pic_flag) };
3432 idr_pic_flag as u64
3433 });
3434 __bindgen_bitfield_unit.set(1usize, 2u8, {
3435 let reference_pic_flag: u32 = unsafe { ::std::mem::transmute(reference_pic_flag) };
3436 reference_pic_flag as u64
3437 });
3438 __bindgen_bitfield_unit.set(3usize, 1u8, {
3439 let entropy_coding_mode_flag: u32 =
3440 unsafe { ::std::mem::transmute(entropy_coding_mode_flag) };
3441 entropy_coding_mode_flag as u64
3442 });
3443 __bindgen_bitfield_unit.set(4usize, 1u8, {
3444 let weighted_pred_flag: u32 = unsafe { ::std::mem::transmute(weighted_pred_flag) };
3445 weighted_pred_flag as u64
3446 });
3447 __bindgen_bitfield_unit.set(5usize, 2u8, {
3448 let weighted_bipred_idc: u32 = unsafe { ::std::mem::transmute(weighted_bipred_idc) };
3449 weighted_bipred_idc as u64
3450 });
3451 __bindgen_bitfield_unit.set(7usize, 1u8, {
3452 let constrained_intra_pred_flag: u32 =
3453 unsafe { ::std::mem::transmute(constrained_intra_pred_flag) };
3454 constrained_intra_pred_flag as u64
3455 });
3456 __bindgen_bitfield_unit.set(8usize, 1u8, {
3457 let transform_8x8_mode_flag: u32 =
3458 unsafe { ::std::mem::transmute(transform_8x8_mode_flag) };
3459 transform_8x8_mode_flag as u64
3460 });
3461 __bindgen_bitfield_unit.set(9usize, 1u8, {
3462 let deblocking_filter_control_present_flag: u32 =
3463 unsafe { ::std::mem::transmute(deblocking_filter_control_present_flag) };
3464 deblocking_filter_control_present_flag as u64
3465 });
3466 __bindgen_bitfield_unit.set(10usize, 1u8, {
3467 let redundant_pic_cnt_present_flag: u32 =
3468 unsafe { ::std::mem::transmute(redundant_pic_cnt_present_flag) };
3469 redundant_pic_cnt_present_flag as u64
3470 });
3471 __bindgen_bitfield_unit.set(11usize, 1u8, {
3472 let pic_order_present_flag: u32 =
3473 unsafe { ::std::mem::transmute(pic_order_present_flag) };
3474 pic_order_present_flag as u64
3475 });
3476 __bindgen_bitfield_unit.set(12usize, 1u8, {
3477 let pic_scaling_matrix_present_flag: u32 =
3478 unsafe { ::std::mem::transmute(pic_scaling_matrix_present_flag) };
3479 pic_scaling_matrix_present_flag as u64
3480 });
3481 __bindgen_bitfield_unit
3482 }
3483}
3484impl Default for _VAEncPictureParameterBufferH264__bindgen_ty_1 {
3485 fn default() -> Self {
3486 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3487 unsafe {
3488 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3489 s.assume_init()
3490 }
3491 }
3492}
3493impl Default for _VAEncPictureParameterBufferH264 {
3494 fn default() -> Self {
3495 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3496 unsafe {
3497 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3498 s.assume_init()
3499 }
3500 }
3501}
3502pub type VAEncPictureParameterBufferH264 = _VAEncPictureParameterBufferH264;
3503#[repr(C)]
3504#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
3505pub struct _VAEncQPBufferH264 {
3506 pub qp: u8,
3507}
3508pub type VAEncQPBufferH264 = _VAEncQPBufferH264;
3509#[repr(C)]
3510#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
3511pub struct _VAEncSliceParameterBufferH264 {
3512 pub macroblock_address: u32,
3513 pub num_macroblocks: u32,
3514 pub macroblock_info: VABufferID,
3515 pub slice_type: u8,
3516 pub pic_parameter_set_id: u8,
3517 pub idr_pic_id: u16,
3518 pub pic_order_cnt_lsb: u16,
3519 pub delta_pic_order_cnt_bottom: i32,
3520 pub delta_pic_order_cnt: [i32; 2usize],
3521 pub direct_spatial_mv_pred_flag: u8,
3522 pub num_ref_idx_active_override_flag: u8,
3523 pub num_ref_idx_l0_active_minus1: u8,
3524 pub num_ref_idx_l1_active_minus1: u8,
3525 pub RefPicList0: [VAPictureH264; 32usize],
3526 pub RefPicList1: [VAPictureH264; 32usize],
3527 pub luma_log2_weight_denom: u8,
3528 pub chroma_log2_weight_denom: u8,
3529 pub luma_weight_l0_flag: u8,
3530 pub luma_weight_l0: [::std::os::raw::c_short; 32usize],
3531 pub luma_offset_l0: [::std::os::raw::c_short; 32usize],
3532 pub chroma_weight_l0_flag: u8,
3533 pub chroma_weight_l0: [[::std::os::raw::c_short; 2usize]; 32usize],
3534 pub chroma_offset_l0: [[::std::os::raw::c_short; 2usize]; 32usize],
3535 pub luma_weight_l1_flag: u8,
3536 pub luma_weight_l1: [::std::os::raw::c_short; 32usize],
3537 pub luma_offset_l1: [::std::os::raw::c_short; 32usize],
3538 pub chroma_weight_l1_flag: u8,
3539 pub chroma_weight_l1: [[::std::os::raw::c_short; 2usize]; 32usize],
3540 pub chroma_offset_l1: [[::std::os::raw::c_short; 2usize]; 32usize],
3541 pub cabac_init_idc: u8,
3542 pub slice_qp_delta: i8,
3543 pub disable_deblocking_filter_idc: u8,
3544 pub slice_alpha_c0_offset_div2: i8,
3545 pub slice_beta_offset_div2: i8,
3546 pub va_reserved: [u32; 4usize],
3547}
3548pub type VAEncSliceParameterBufferH264 = _VAEncSliceParameterBufferH264;
3549#[repr(C)]
3550#[derive(Copy, Clone)]
3551pub struct _VAEncMacroblockParameterBufferH264 {
3552 pub qp: u8,
3553 pub info: _VAEncMacroblockParameterBufferH264__bindgen_ty_1,
3554 pub va_reserved: [u32; 4usize],
3555}
3556#[repr(C)]
3557#[derive(Copy, Clone)]
3558pub union _VAEncMacroblockParameterBufferH264__bindgen_ty_1 {
3559 pub intra_fields: _VAEncMacroblockParameterBufferH264__bindgen_ty_1__bindgen_ty_1,
3560 pub inter_fields: _VAEncMacroblockParameterBufferH264__bindgen_ty_1__bindgen_ty_2,
3561}
3562#[repr(C)]
3563#[derive(Copy, Clone)]
3564pub union _VAEncMacroblockParameterBufferH264__bindgen_ty_1__bindgen_ty_1 {
3565 pub bits: _VAEncMacroblockParameterBufferH264__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
3566 pub value: u32,
3567}
3568#[repr(C)]
3569#[repr(align(4))]
3570#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
3571pub struct _VAEncMacroblockParameterBufferH264__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 {
3572 pub _bitfield_align_1: [u8; 0],
3573 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
3574 pub __bindgen_padding_0: u16,
3575}
3576impl _VAEncMacroblockParameterBufferH264__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 {
3577 #[inline]
3578 pub fn pred_avail_override_flag(&self) -> u32 {
3579 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
3580 }
3581 #[inline]
3582 pub fn set_pred_avail_override_flag(&mut self, val: u32) {
3583 unsafe {
3584 let val: u32 = ::std::mem::transmute(val);
3585 self._bitfield_1.set(0usize, 1u8, val as u64)
3586 }
3587 }
3588 #[inline]
3589 pub fn pred_avail_flags(&self) -> u32 {
3590 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 8u8) as u32) }
3591 }
3592 #[inline]
3593 pub fn set_pred_avail_flags(&mut self, val: u32) {
3594 unsafe {
3595 let val: u32 = ::std::mem::transmute(val);
3596 self._bitfield_1.set(1usize, 8u8, val as u64)
3597 }
3598 }
3599 #[inline]
3600 pub fn new_bitfield_1(
3601 pred_avail_override_flag: u32,
3602 pred_avail_flags: u32,
3603 ) -> __BindgenBitfieldUnit<[u8; 2usize]> {
3604 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default();
3605 __bindgen_bitfield_unit.set(0usize, 1u8, {
3606 let pred_avail_override_flag: u32 =
3607 unsafe { ::std::mem::transmute(pred_avail_override_flag) };
3608 pred_avail_override_flag as u64
3609 });
3610 __bindgen_bitfield_unit.set(1usize, 8u8, {
3611 let pred_avail_flags: u32 = unsafe { ::std::mem::transmute(pred_avail_flags) };
3612 pred_avail_flags as u64
3613 });
3614 __bindgen_bitfield_unit
3615 }
3616}
3617impl Default for _VAEncMacroblockParameterBufferH264__bindgen_ty_1__bindgen_ty_1 {
3618 fn default() -> Self {
3619 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3620 unsafe {
3621 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3622 s.assume_init()
3623 }
3624 }
3625}
3626#[repr(C)]
3627#[derive(Copy, Clone)]
3628pub union _VAEncMacroblockParameterBufferH264__bindgen_ty_1__bindgen_ty_2 {
3629 pub bits: _VAEncMacroblockParameterBufferH264__bindgen_ty_1__bindgen_ty_2__bindgen_ty_1,
3630 pub value: u32,
3631}
3632#[repr(C)]
3633#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
3634pub struct _VAEncMacroblockParameterBufferH264__bindgen_ty_1__bindgen_ty_2__bindgen_ty_1 {
3635 pub reserved: u32,
3636}
3637impl Default for _VAEncMacroblockParameterBufferH264__bindgen_ty_1__bindgen_ty_2 {
3638 fn default() -> Self {
3639 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3640 unsafe {
3641 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3642 s.assume_init()
3643 }
3644 }
3645}
3646impl Default for _VAEncMacroblockParameterBufferH264__bindgen_ty_1 {
3647 fn default() -> Self {
3648 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3649 unsafe {
3650 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3651 s.assume_init()
3652 }
3653 }
3654}
3655impl Default for _VAEncMacroblockParameterBufferH264 {
3656 fn default() -> Self {
3657 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3658 unsafe {
3659 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3660 s.assume_init()
3661 }
3662 }
3663}
3664pub type VAEncMacroblockParameterBufferH264 = _VAEncMacroblockParameterBufferH264;
3665#[repr(C)]
3666#[derive(Copy, Clone)]
3667pub struct _VAEncMiscParameterSubMbPartPelH264 {
3668 pub disable_inter_sub_mb_partition: u32,
3669 pub inter_sub_mb_partition_mask: _VAEncMiscParameterSubMbPartPelH264__bindgen_ty_1,
3670 pub enable_sub_pel_mode: u32,
3671 pub sub_pel_mode: u8,
3672 pub reserved: [u8; 3usize],
3673}
3674#[repr(C)]
3675#[derive(Copy, Clone)]
3676pub union _VAEncMiscParameterSubMbPartPelH264__bindgen_ty_1 {
3677 pub bits: _VAEncMiscParameterSubMbPartPelH264__bindgen_ty_1__bindgen_ty_1,
3678 pub value: u8,
3679}
3680#[repr(C)]
3681#[repr(align(4))]
3682#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
3683pub struct _VAEncMiscParameterSubMbPartPelH264__bindgen_ty_1__bindgen_ty_1 {
3684 pub _bitfield_align_1: [u8; 0],
3685 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
3686 pub __bindgen_padding_0: [u8; 3usize],
3687}
3688impl _VAEncMiscParameterSubMbPartPelH264__bindgen_ty_1__bindgen_ty_1 {
3689 #[inline]
3690 pub fn disable_16x16_inter_mb_partition(&self) -> u32 {
3691 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
3692 }
3693 #[inline]
3694 pub fn set_disable_16x16_inter_mb_partition(&mut self, val: u32) {
3695 unsafe {
3696 let val: u32 = ::std::mem::transmute(val);
3697 self._bitfield_1.set(0usize, 1u8, val as u64)
3698 }
3699 }
3700 #[inline]
3701 pub fn disable_16x8_inter_mb_partition(&self) -> u32 {
3702 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
3703 }
3704 #[inline]
3705 pub fn set_disable_16x8_inter_mb_partition(&mut self, val: u32) {
3706 unsafe {
3707 let val: u32 = ::std::mem::transmute(val);
3708 self._bitfield_1.set(1usize, 1u8, val as u64)
3709 }
3710 }
3711 #[inline]
3712 pub fn disable_8x16_inter_mb_partition(&self) -> u32 {
3713 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
3714 }
3715 #[inline]
3716 pub fn set_disable_8x16_inter_mb_partition(&mut self, val: u32) {
3717 unsafe {
3718 let val: u32 = ::std::mem::transmute(val);
3719 self._bitfield_1.set(2usize, 1u8, val as u64)
3720 }
3721 }
3722 #[inline]
3723 pub fn disable_8x8_inter_mb_partition(&self) -> u32 {
3724 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
3725 }
3726 #[inline]
3727 pub fn set_disable_8x8_inter_mb_partition(&mut self, val: u32) {
3728 unsafe {
3729 let val: u32 = ::std::mem::transmute(val);
3730 self._bitfield_1.set(3usize, 1u8, val as u64)
3731 }
3732 }
3733 #[inline]
3734 pub fn disable_8x4_inter_mb_partition(&self) -> u32 {
3735 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
3736 }
3737 #[inline]
3738 pub fn set_disable_8x4_inter_mb_partition(&mut self, val: u32) {
3739 unsafe {
3740 let val: u32 = ::std::mem::transmute(val);
3741 self._bitfield_1.set(4usize, 1u8, val as u64)
3742 }
3743 }
3744 #[inline]
3745 pub fn disable_4x8_inter_mb_partition(&self) -> u32 {
3746 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
3747 }
3748 #[inline]
3749 pub fn set_disable_4x8_inter_mb_partition(&mut self, val: u32) {
3750 unsafe {
3751 let val: u32 = ::std::mem::transmute(val);
3752 self._bitfield_1.set(5usize, 1u8, val as u64)
3753 }
3754 }
3755 #[inline]
3756 pub fn disable_4x4_inter_mb_partition(&self) -> u32 {
3757 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) }
3758 }
3759 #[inline]
3760 pub fn set_disable_4x4_inter_mb_partition(&mut self, val: u32) {
3761 unsafe {
3762 let val: u32 = ::std::mem::transmute(val);
3763 self._bitfield_1.set(6usize, 1u8, val as u64)
3764 }
3765 }
3766 #[inline]
3767 pub fn reserved(&self) -> u32 {
3768 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) }
3769 }
3770 #[inline]
3771 pub fn set_reserved(&mut self, val: u32) {
3772 unsafe {
3773 let val: u32 = ::std::mem::transmute(val);
3774 self._bitfield_1.set(7usize, 1u8, val as u64)
3775 }
3776 }
3777 #[inline]
3778 pub fn new_bitfield_1(
3779 disable_16x16_inter_mb_partition: u32,
3780 disable_16x8_inter_mb_partition: u32,
3781 disable_8x16_inter_mb_partition: u32,
3782 disable_8x8_inter_mb_partition: u32,
3783 disable_8x4_inter_mb_partition: u32,
3784 disable_4x8_inter_mb_partition: u32,
3785 disable_4x4_inter_mb_partition: u32,
3786 reserved: u32,
3787 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
3788 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
3789 __bindgen_bitfield_unit.set(0usize, 1u8, {
3790 let disable_16x16_inter_mb_partition: u32 =
3791 unsafe { ::std::mem::transmute(disable_16x16_inter_mb_partition) };
3792 disable_16x16_inter_mb_partition as u64
3793 });
3794 __bindgen_bitfield_unit.set(1usize, 1u8, {
3795 let disable_16x8_inter_mb_partition: u32 =
3796 unsafe { ::std::mem::transmute(disable_16x8_inter_mb_partition) };
3797 disable_16x8_inter_mb_partition as u64
3798 });
3799 __bindgen_bitfield_unit.set(2usize, 1u8, {
3800 let disable_8x16_inter_mb_partition: u32 =
3801 unsafe { ::std::mem::transmute(disable_8x16_inter_mb_partition) };
3802 disable_8x16_inter_mb_partition as u64
3803 });
3804 __bindgen_bitfield_unit.set(3usize, 1u8, {
3805 let disable_8x8_inter_mb_partition: u32 =
3806 unsafe { ::std::mem::transmute(disable_8x8_inter_mb_partition) };
3807 disable_8x8_inter_mb_partition as u64
3808 });
3809 __bindgen_bitfield_unit.set(4usize, 1u8, {
3810 let disable_8x4_inter_mb_partition: u32 =
3811 unsafe { ::std::mem::transmute(disable_8x4_inter_mb_partition) };
3812 disable_8x4_inter_mb_partition as u64
3813 });
3814 __bindgen_bitfield_unit.set(5usize, 1u8, {
3815 let disable_4x8_inter_mb_partition: u32 =
3816 unsafe { ::std::mem::transmute(disable_4x8_inter_mb_partition) };
3817 disable_4x8_inter_mb_partition as u64
3818 });
3819 __bindgen_bitfield_unit.set(6usize, 1u8, {
3820 let disable_4x4_inter_mb_partition: u32 =
3821 unsafe { ::std::mem::transmute(disable_4x4_inter_mb_partition) };
3822 disable_4x4_inter_mb_partition as u64
3823 });
3824 __bindgen_bitfield_unit.set(7usize, 1u8, {
3825 let reserved: u32 = unsafe { ::std::mem::transmute(reserved) };
3826 reserved as u64
3827 });
3828 __bindgen_bitfield_unit
3829 }
3830}
3831impl Default for _VAEncMiscParameterSubMbPartPelH264__bindgen_ty_1 {
3832 fn default() -> Self {
3833 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3834 unsafe {
3835 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3836 s.assume_init()
3837 }
3838 }
3839}
3840impl Default for _VAEncMiscParameterSubMbPartPelH264 {
3841 fn default() -> Self {
3842 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3843 unsafe {
3844 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3845 s.assume_init()
3846 }
3847 }
3848}
3849pub type VAEncMiscParameterSubMbPartPelH264 = _VAEncMiscParameterSubMbPartPelH264;
3850pub type VAQMatrixBufferMPEG2 = VAIQMatrixBufferMPEG2;
3851pub mod VAEncPackedHeaderTypeMPEG2 {
3852 pub type Type = ::std::os::raw::c_uint;
3853 pub const VAEncPackedHeaderMPEG2_SPS: Type = 1;
3854 pub const VAEncPackedHeaderMPEG2_PPS: Type = 2;
3855 pub const VAEncPackedHeaderMPEG2_Slice: Type = 3;
3856}
3857#[repr(C)]
3858#[derive(Copy, Clone)]
3859pub struct _VAEncSequenceParameterBufferMPEG2 {
3860 pub intra_period: u32,
3861 pub ip_period: u32,
3862 pub picture_width: u16,
3863 pub picture_height: u16,
3864 pub bits_per_second: u32,
3865 pub frame_rate: f32,
3866 pub aspect_ratio_information: u16,
3867 pub vbv_buffer_size: u32,
3868 pub sequence_extension: _VAEncSequenceParameterBufferMPEG2__bindgen_ty_1,
3869 pub new_gop_header: u32,
3870 pub gop_header: _VAEncSequenceParameterBufferMPEG2__bindgen_ty_2,
3871 pub va_reserved: [u32; 4usize],
3872}
3873#[repr(C)]
3874#[derive(Copy, Clone)]
3875pub union _VAEncSequenceParameterBufferMPEG2__bindgen_ty_1 {
3876 pub bits: _VAEncSequenceParameterBufferMPEG2__bindgen_ty_1__bindgen_ty_1,
3877 pub value: u32,
3878}
3879#[repr(C)]
3880#[repr(align(4))]
3881#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
3882pub struct _VAEncSequenceParameterBufferMPEG2__bindgen_ty_1__bindgen_ty_1 {
3883 pub _bitfield_align_1: [u8; 0],
3884 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 3usize]>,
3885 pub __bindgen_padding_0: u8,
3886}
3887impl _VAEncSequenceParameterBufferMPEG2__bindgen_ty_1__bindgen_ty_1 {
3888 #[inline]
3889 pub fn profile_and_level_indication(&self) -> u32 {
3890 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 8u8) as u32) }
3891 }
3892 #[inline]
3893 pub fn set_profile_and_level_indication(&mut self, val: u32) {
3894 unsafe {
3895 let val: u32 = ::std::mem::transmute(val);
3896 self._bitfield_1.set(0usize, 8u8, val as u64)
3897 }
3898 }
3899 #[inline]
3900 pub fn progressive_sequence(&self) -> u32 {
3901 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) }
3902 }
3903 #[inline]
3904 pub fn set_progressive_sequence(&mut self, val: u32) {
3905 unsafe {
3906 let val: u32 = ::std::mem::transmute(val);
3907 self._bitfield_1.set(8usize, 1u8, val as u64)
3908 }
3909 }
3910 #[inline]
3911 pub fn chroma_format(&self) -> u32 {
3912 unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 2u8) as u32) }
3913 }
3914 #[inline]
3915 pub fn set_chroma_format(&mut self, val: u32) {
3916 unsafe {
3917 let val: u32 = ::std::mem::transmute(val);
3918 self._bitfield_1.set(9usize, 2u8, val as u64)
3919 }
3920 }
3921 #[inline]
3922 pub fn low_delay(&self) -> u32 {
3923 unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) }
3924 }
3925 #[inline]
3926 pub fn set_low_delay(&mut self, val: u32) {
3927 unsafe {
3928 let val: u32 = ::std::mem::transmute(val);
3929 self._bitfield_1.set(11usize, 1u8, val as u64)
3930 }
3931 }
3932 #[inline]
3933 pub fn frame_rate_extension_n(&self) -> u32 {
3934 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 2u8) as u32) }
3935 }
3936 #[inline]
3937 pub fn set_frame_rate_extension_n(&mut self, val: u32) {
3938 unsafe {
3939 let val: u32 = ::std::mem::transmute(val);
3940 self._bitfield_1.set(12usize, 2u8, val as u64)
3941 }
3942 }
3943 #[inline]
3944 pub fn frame_rate_extension_d(&self) -> u32 {
3945 unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 5u8) as u32) }
3946 }
3947 #[inline]
3948 pub fn set_frame_rate_extension_d(&mut self, val: u32) {
3949 unsafe {
3950 let val: u32 = ::std::mem::transmute(val);
3951 self._bitfield_1.set(14usize, 5u8, val as u64)
3952 }
3953 }
3954 #[inline]
3955 pub fn new_bitfield_1(
3956 profile_and_level_indication: u32,
3957 progressive_sequence: u32,
3958 chroma_format: u32,
3959 low_delay: u32,
3960 frame_rate_extension_n: u32,
3961 frame_rate_extension_d: u32,
3962 ) -> __BindgenBitfieldUnit<[u8; 3usize]> {
3963 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 3usize]> = Default::default();
3964 __bindgen_bitfield_unit.set(0usize, 8u8, {
3965 let profile_and_level_indication: u32 =
3966 unsafe { ::std::mem::transmute(profile_and_level_indication) };
3967 profile_and_level_indication as u64
3968 });
3969 __bindgen_bitfield_unit.set(8usize, 1u8, {
3970 let progressive_sequence: u32 = unsafe { ::std::mem::transmute(progressive_sequence) };
3971 progressive_sequence as u64
3972 });
3973 __bindgen_bitfield_unit.set(9usize, 2u8, {
3974 let chroma_format: u32 = unsafe { ::std::mem::transmute(chroma_format) };
3975 chroma_format as u64
3976 });
3977 __bindgen_bitfield_unit.set(11usize, 1u8, {
3978 let low_delay: u32 = unsafe { ::std::mem::transmute(low_delay) };
3979 low_delay as u64
3980 });
3981 __bindgen_bitfield_unit.set(12usize, 2u8, {
3982 let frame_rate_extension_n: u32 =
3983 unsafe { ::std::mem::transmute(frame_rate_extension_n) };
3984 frame_rate_extension_n as u64
3985 });
3986 __bindgen_bitfield_unit.set(14usize, 5u8, {
3987 let frame_rate_extension_d: u32 =
3988 unsafe { ::std::mem::transmute(frame_rate_extension_d) };
3989 frame_rate_extension_d as u64
3990 });
3991 __bindgen_bitfield_unit
3992 }
3993}
3994impl Default for _VAEncSequenceParameterBufferMPEG2__bindgen_ty_1 {
3995 fn default() -> Self {
3996 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3997 unsafe {
3998 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3999 s.assume_init()
4000 }
4001 }
4002}
4003#[repr(C)]
4004#[derive(Copy, Clone)]
4005pub union _VAEncSequenceParameterBufferMPEG2__bindgen_ty_2 {
4006 pub bits: _VAEncSequenceParameterBufferMPEG2__bindgen_ty_2__bindgen_ty_1,
4007 pub value: u32,
4008}
4009#[repr(C)]
4010#[repr(align(4))]
4011#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
4012pub struct _VAEncSequenceParameterBufferMPEG2__bindgen_ty_2__bindgen_ty_1 {
4013 pub _bitfield_align_1: [u32; 0],
4014 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
4015}
4016impl _VAEncSequenceParameterBufferMPEG2__bindgen_ty_2__bindgen_ty_1 {
4017 #[inline]
4018 pub fn time_code(&self) -> u32 {
4019 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 25u8) as u32) }
4020 }
4021 #[inline]
4022 pub fn set_time_code(&mut self, val: u32) {
4023 unsafe {
4024 let val: u32 = ::std::mem::transmute(val);
4025 self._bitfield_1.set(0usize, 25u8, val as u64)
4026 }
4027 }
4028 #[inline]
4029 pub fn closed_gop(&self) -> u32 {
4030 unsafe { ::std::mem::transmute(self._bitfield_1.get(25usize, 1u8) as u32) }
4031 }
4032 #[inline]
4033 pub fn set_closed_gop(&mut self, val: u32) {
4034 unsafe {
4035 let val: u32 = ::std::mem::transmute(val);
4036 self._bitfield_1.set(25usize, 1u8, val as u64)
4037 }
4038 }
4039 #[inline]
4040 pub fn broken_link(&self) -> u32 {
4041 unsafe { ::std::mem::transmute(self._bitfield_1.get(26usize, 1u8) as u32) }
4042 }
4043 #[inline]
4044 pub fn set_broken_link(&mut self, val: u32) {
4045 unsafe {
4046 let val: u32 = ::std::mem::transmute(val);
4047 self._bitfield_1.set(26usize, 1u8, val as u64)
4048 }
4049 }
4050 #[inline]
4051 pub fn new_bitfield_1(
4052 time_code: u32,
4053 closed_gop: u32,
4054 broken_link: u32,
4055 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
4056 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
4057 __bindgen_bitfield_unit.set(0usize, 25u8, {
4058 let time_code: u32 = unsafe { ::std::mem::transmute(time_code) };
4059 time_code as u64
4060 });
4061 __bindgen_bitfield_unit.set(25usize, 1u8, {
4062 let closed_gop: u32 = unsafe { ::std::mem::transmute(closed_gop) };
4063 closed_gop as u64
4064 });
4065 __bindgen_bitfield_unit.set(26usize, 1u8, {
4066 let broken_link: u32 = unsafe { ::std::mem::transmute(broken_link) };
4067 broken_link as u64
4068 });
4069 __bindgen_bitfield_unit
4070 }
4071}
4072impl Default for _VAEncSequenceParameterBufferMPEG2__bindgen_ty_2 {
4073 fn default() -> Self {
4074 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4075 unsafe {
4076 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4077 s.assume_init()
4078 }
4079 }
4080}
4081impl Default for _VAEncSequenceParameterBufferMPEG2 {
4082 fn default() -> Self {
4083 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4084 unsafe {
4085 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4086 s.assume_init()
4087 }
4088 }
4089}
4090pub type VAEncSequenceParameterBufferMPEG2 = _VAEncSequenceParameterBufferMPEG2;
4091#[repr(C)]
4092#[derive(Copy, Clone)]
4093pub struct _VAEncPictureParameterBufferMPEG2 {
4094 pub forward_reference_picture: VASurfaceID,
4095 pub backward_reference_picture: VASurfaceID,
4096 pub reconstructed_picture: VASurfaceID,
4097 pub coded_buf: VABufferID,
4098 pub last_picture: u8,
4099 pub picture_type: VAEncPictureType::Type,
4100 pub temporal_reference: u32,
4101 pub vbv_delay: u32,
4102 pub f_code: [[u8; 2usize]; 2usize],
4103 pub picture_coding_extension: _VAEncPictureParameterBufferMPEG2__bindgen_ty_1,
4104 pub composite_display: _VAEncPictureParameterBufferMPEG2__bindgen_ty_2,
4105 pub va_reserved: [u32; 4usize],
4106}
4107#[repr(C)]
4108#[derive(Copy, Clone)]
4109pub union _VAEncPictureParameterBufferMPEG2__bindgen_ty_1 {
4110 pub bits: _VAEncPictureParameterBufferMPEG2__bindgen_ty_1__bindgen_ty_1,
4111 pub value: u32,
4112}
4113#[repr(C)]
4114#[repr(align(4))]
4115#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
4116pub struct _VAEncPictureParameterBufferMPEG2__bindgen_ty_1__bindgen_ty_1 {
4117 pub _bitfield_align_1: [u8; 0],
4118 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
4119 pub __bindgen_padding_0: u16,
4120}
4121impl _VAEncPictureParameterBufferMPEG2__bindgen_ty_1__bindgen_ty_1 {
4122 #[inline]
4123 pub fn intra_dc_precision(&self) -> u32 {
4124 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u32) }
4125 }
4126 #[inline]
4127 pub fn set_intra_dc_precision(&mut self, val: u32) {
4128 unsafe {
4129 let val: u32 = ::std::mem::transmute(val);
4130 self._bitfield_1.set(0usize, 2u8, val as u64)
4131 }
4132 }
4133 #[inline]
4134 pub fn picture_structure(&self) -> u32 {
4135 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 2u8) as u32) }
4136 }
4137 #[inline]
4138 pub fn set_picture_structure(&mut self, val: u32) {
4139 unsafe {
4140 let val: u32 = ::std::mem::transmute(val);
4141 self._bitfield_1.set(2usize, 2u8, val as u64)
4142 }
4143 }
4144 #[inline]
4145 pub fn top_field_first(&self) -> u32 {
4146 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
4147 }
4148 #[inline]
4149 pub fn set_top_field_first(&mut self, val: u32) {
4150 unsafe {
4151 let val: u32 = ::std::mem::transmute(val);
4152 self._bitfield_1.set(4usize, 1u8, val as u64)
4153 }
4154 }
4155 #[inline]
4156 pub fn frame_pred_frame_dct(&self) -> u32 {
4157 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
4158 }
4159 #[inline]
4160 pub fn set_frame_pred_frame_dct(&mut self, val: u32) {
4161 unsafe {
4162 let val: u32 = ::std::mem::transmute(val);
4163 self._bitfield_1.set(5usize, 1u8, val as u64)
4164 }
4165 }
4166 #[inline]
4167 pub fn concealment_motion_vectors(&self) -> u32 {
4168 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) }
4169 }
4170 #[inline]
4171 pub fn set_concealment_motion_vectors(&mut self, val: u32) {
4172 unsafe {
4173 let val: u32 = ::std::mem::transmute(val);
4174 self._bitfield_1.set(6usize, 1u8, val as u64)
4175 }
4176 }
4177 #[inline]
4178 pub fn q_scale_type(&self) -> u32 {
4179 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) }
4180 }
4181 #[inline]
4182 pub fn set_q_scale_type(&mut self, val: u32) {
4183 unsafe {
4184 let val: u32 = ::std::mem::transmute(val);
4185 self._bitfield_1.set(7usize, 1u8, val as u64)
4186 }
4187 }
4188 #[inline]
4189 pub fn intra_vlc_format(&self) -> u32 {
4190 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) }
4191 }
4192 #[inline]
4193 pub fn set_intra_vlc_format(&mut self, val: u32) {
4194 unsafe {
4195 let val: u32 = ::std::mem::transmute(val);
4196 self._bitfield_1.set(8usize, 1u8, val as u64)
4197 }
4198 }
4199 #[inline]
4200 pub fn alternate_scan(&self) -> u32 {
4201 unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) }
4202 }
4203 #[inline]
4204 pub fn set_alternate_scan(&mut self, val: u32) {
4205 unsafe {
4206 let val: u32 = ::std::mem::transmute(val);
4207 self._bitfield_1.set(9usize, 1u8, val as u64)
4208 }
4209 }
4210 #[inline]
4211 pub fn repeat_first_field(&self) -> u32 {
4212 unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) }
4213 }
4214 #[inline]
4215 pub fn set_repeat_first_field(&mut self, val: u32) {
4216 unsafe {
4217 let val: u32 = ::std::mem::transmute(val);
4218 self._bitfield_1.set(10usize, 1u8, val as u64)
4219 }
4220 }
4221 #[inline]
4222 pub fn progressive_frame(&self) -> u32 {
4223 unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) }
4224 }
4225 #[inline]
4226 pub fn set_progressive_frame(&mut self, val: u32) {
4227 unsafe {
4228 let val: u32 = ::std::mem::transmute(val);
4229 self._bitfield_1.set(11usize, 1u8, val as u64)
4230 }
4231 }
4232 #[inline]
4233 pub fn composite_display_flag(&self) -> u32 {
4234 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u32) }
4235 }
4236 #[inline]
4237 pub fn set_composite_display_flag(&mut self, val: u32) {
4238 unsafe {
4239 let val: u32 = ::std::mem::transmute(val);
4240 self._bitfield_1.set(12usize, 1u8, val as u64)
4241 }
4242 }
4243 #[inline]
4244 pub fn new_bitfield_1(
4245 intra_dc_precision: u32,
4246 picture_structure: u32,
4247 top_field_first: u32,
4248 frame_pred_frame_dct: u32,
4249 concealment_motion_vectors: u32,
4250 q_scale_type: u32,
4251 intra_vlc_format: u32,
4252 alternate_scan: u32,
4253 repeat_first_field: u32,
4254 progressive_frame: u32,
4255 composite_display_flag: u32,
4256 ) -> __BindgenBitfieldUnit<[u8; 2usize]> {
4257 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default();
4258 __bindgen_bitfield_unit.set(0usize, 2u8, {
4259 let intra_dc_precision: u32 = unsafe { ::std::mem::transmute(intra_dc_precision) };
4260 intra_dc_precision as u64
4261 });
4262 __bindgen_bitfield_unit.set(2usize, 2u8, {
4263 let picture_structure: u32 = unsafe { ::std::mem::transmute(picture_structure) };
4264 picture_structure as u64
4265 });
4266 __bindgen_bitfield_unit.set(4usize, 1u8, {
4267 let top_field_first: u32 = unsafe { ::std::mem::transmute(top_field_first) };
4268 top_field_first as u64
4269 });
4270 __bindgen_bitfield_unit.set(5usize, 1u8, {
4271 let frame_pred_frame_dct: u32 = unsafe { ::std::mem::transmute(frame_pred_frame_dct) };
4272 frame_pred_frame_dct as u64
4273 });
4274 __bindgen_bitfield_unit.set(6usize, 1u8, {
4275 let concealment_motion_vectors: u32 =
4276 unsafe { ::std::mem::transmute(concealment_motion_vectors) };
4277 concealment_motion_vectors as u64
4278 });
4279 __bindgen_bitfield_unit.set(7usize, 1u8, {
4280 let q_scale_type: u32 = unsafe { ::std::mem::transmute(q_scale_type) };
4281 q_scale_type as u64
4282 });
4283 __bindgen_bitfield_unit.set(8usize, 1u8, {
4284 let intra_vlc_format: u32 = unsafe { ::std::mem::transmute(intra_vlc_format) };
4285 intra_vlc_format as u64
4286 });
4287 __bindgen_bitfield_unit.set(9usize, 1u8, {
4288 let alternate_scan: u32 = unsafe { ::std::mem::transmute(alternate_scan) };
4289 alternate_scan as u64
4290 });
4291 __bindgen_bitfield_unit.set(10usize, 1u8, {
4292 let repeat_first_field: u32 = unsafe { ::std::mem::transmute(repeat_first_field) };
4293 repeat_first_field as u64
4294 });
4295 __bindgen_bitfield_unit.set(11usize, 1u8, {
4296 let progressive_frame: u32 = unsafe { ::std::mem::transmute(progressive_frame) };
4297 progressive_frame as u64
4298 });
4299 __bindgen_bitfield_unit.set(12usize, 1u8, {
4300 let composite_display_flag: u32 =
4301 unsafe { ::std::mem::transmute(composite_display_flag) };
4302 composite_display_flag as u64
4303 });
4304 __bindgen_bitfield_unit
4305 }
4306}
4307impl Default for _VAEncPictureParameterBufferMPEG2__bindgen_ty_1 {
4308 fn default() -> Self {
4309 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4310 unsafe {
4311 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4312 s.assume_init()
4313 }
4314 }
4315}
4316#[repr(C)]
4317#[derive(Copy, Clone)]
4318pub union _VAEncPictureParameterBufferMPEG2__bindgen_ty_2 {
4319 pub bits: _VAEncPictureParameterBufferMPEG2__bindgen_ty_2__bindgen_ty_1,
4320 pub value: u32,
4321}
4322#[repr(C)]
4323#[repr(align(4))]
4324#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
4325pub struct _VAEncPictureParameterBufferMPEG2__bindgen_ty_2__bindgen_ty_1 {
4326 pub _bitfield_align_1: [u8; 0],
4327 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 3usize]>,
4328 pub __bindgen_padding_0: u8,
4329}
4330impl _VAEncPictureParameterBufferMPEG2__bindgen_ty_2__bindgen_ty_1 {
4331 #[inline]
4332 pub fn v_axis(&self) -> u32 {
4333 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
4334 }
4335 #[inline]
4336 pub fn set_v_axis(&mut self, val: u32) {
4337 unsafe {
4338 let val: u32 = ::std::mem::transmute(val);
4339 self._bitfield_1.set(0usize, 1u8, val as u64)
4340 }
4341 }
4342 #[inline]
4343 pub fn field_sequence(&self) -> u32 {
4344 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 3u8) as u32) }
4345 }
4346 #[inline]
4347 pub fn set_field_sequence(&mut self, val: u32) {
4348 unsafe {
4349 let val: u32 = ::std::mem::transmute(val);
4350 self._bitfield_1.set(1usize, 3u8, val as u64)
4351 }
4352 }
4353 #[inline]
4354 pub fn sub_carrier(&self) -> u32 {
4355 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
4356 }
4357 #[inline]
4358 pub fn set_sub_carrier(&mut self, val: u32) {
4359 unsafe {
4360 let val: u32 = ::std::mem::transmute(val);
4361 self._bitfield_1.set(4usize, 1u8, val as u64)
4362 }
4363 }
4364 #[inline]
4365 pub fn burst_amplitude(&self) -> u32 {
4366 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 7u8) as u32) }
4367 }
4368 #[inline]
4369 pub fn set_burst_amplitude(&mut self, val: u32) {
4370 unsafe {
4371 let val: u32 = ::std::mem::transmute(val);
4372 self._bitfield_1.set(5usize, 7u8, val as u64)
4373 }
4374 }
4375 #[inline]
4376 pub fn sub_carrier_phase(&self) -> u32 {
4377 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 8u8) as u32) }
4378 }
4379 #[inline]
4380 pub fn set_sub_carrier_phase(&mut self, val: u32) {
4381 unsafe {
4382 let val: u32 = ::std::mem::transmute(val);
4383 self._bitfield_1.set(12usize, 8u8, val as u64)
4384 }
4385 }
4386 #[inline]
4387 pub fn new_bitfield_1(
4388 v_axis: u32,
4389 field_sequence: u32,
4390 sub_carrier: u32,
4391 burst_amplitude: u32,
4392 sub_carrier_phase: u32,
4393 ) -> __BindgenBitfieldUnit<[u8; 3usize]> {
4394 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 3usize]> = Default::default();
4395 __bindgen_bitfield_unit.set(0usize, 1u8, {
4396 let v_axis: u32 = unsafe { ::std::mem::transmute(v_axis) };
4397 v_axis as u64
4398 });
4399 __bindgen_bitfield_unit.set(1usize, 3u8, {
4400 let field_sequence: u32 = unsafe { ::std::mem::transmute(field_sequence) };
4401 field_sequence as u64
4402 });
4403 __bindgen_bitfield_unit.set(4usize, 1u8, {
4404 let sub_carrier: u32 = unsafe { ::std::mem::transmute(sub_carrier) };
4405 sub_carrier as u64
4406 });
4407 __bindgen_bitfield_unit.set(5usize, 7u8, {
4408 let burst_amplitude: u32 = unsafe { ::std::mem::transmute(burst_amplitude) };
4409 burst_amplitude as u64
4410 });
4411 __bindgen_bitfield_unit.set(12usize, 8u8, {
4412 let sub_carrier_phase: u32 = unsafe { ::std::mem::transmute(sub_carrier_phase) };
4413 sub_carrier_phase as u64
4414 });
4415 __bindgen_bitfield_unit
4416 }
4417}
4418impl Default for _VAEncPictureParameterBufferMPEG2__bindgen_ty_2 {
4419 fn default() -> Self {
4420 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4421 unsafe {
4422 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4423 s.assume_init()
4424 }
4425 }
4426}
4427impl Default for _VAEncPictureParameterBufferMPEG2 {
4428 fn default() -> Self {
4429 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4430 unsafe {
4431 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4432 s.assume_init()
4433 }
4434 }
4435}
4436pub type VAEncPictureParameterBufferMPEG2 = _VAEncPictureParameterBufferMPEG2;
4437#[repr(C)]
4438#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
4439pub struct _VAEncSliceParameterBufferMPEG2 {
4440 pub macroblock_address: u32,
4441 pub num_macroblocks: u32,
4442 pub quantiser_scale_code: i32,
4443 pub is_intra_slice: i32,
4444 pub va_reserved: [u32; 4usize],
4445}
4446pub type VAEncSliceParameterBufferMPEG2 = _VAEncSliceParameterBufferMPEG2;
4447#[repr(C)]
4448#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
4449pub struct _VAEncMiscParameterExtensionDataSeqDisplayMPEG2 {
4450 pub extension_start_code_identifier: u8,
4451 pub video_format: u8,
4452 pub colour_description: u8,
4453 pub colour_primaries: u8,
4454 pub transfer_characteristics: u8,
4455 pub matrix_coefficients: u8,
4456 pub display_horizontal_size: u16,
4457 pub display_vertical_size: u16,
4458}
4459pub type VAEncMiscParameterExtensionDataSeqDisplayMPEG2 =
4460 _VAEncMiscParameterExtensionDataSeqDisplayMPEG2;
4461#[repr(C)]
4462#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
4463pub struct _VAEncSequenceParameterBufferVP8 {
4464 pub frame_width: u32,
4465 pub frame_height: u32,
4466 pub frame_width_scale: u32,
4467 pub frame_height_scale: u32,
4468 pub error_resilient: u32,
4469 pub kf_auto: u32,
4470 pub kf_min_dist: u32,
4471 pub kf_max_dist: u32,
4472 pub bits_per_second: u32,
4473 pub intra_period: u32,
4474 pub reference_frames: [VASurfaceID; 4usize],
4475 pub va_reserved: [u32; 4usize],
4476}
4477pub type VAEncSequenceParameterBufferVP8 = _VAEncSequenceParameterBufferVP8;
4478#[repr(C)]
4479#[derive(Copy, Clone)]
4480pub struct _VAEncPictureParameterBufferVP8 {
4481 pub reconstructed_frame: VASurfaceID,
4482 pub ref_last_frame: VASurfaceID,
4483 pub ref_gf_frame: VASurfaceID,
4484 pub ref_arf_frame: VASurfaceID,
4485 pub coded_buf: VABufferID,
4486 pub ref_flags: _VAEncPictureParameterBufferVP8__bindgen_ty_1,
4487 pub pic_flags: _VAEncPictureParameterBufferVP8__bindgen_ty_2,
4488 pub loop_filter_level: [i8; 4usize],
4489 pub ref_lf_delta: [i8; 4usize],
4490 pub mode_lf_delta: [i8; 4usize],
4491 pub sharpness_level: u8,
4492 pub clamp_qindex_high: u8,
4493 pub clamp_qindex_low: u8,
4494 pub va_reserved: [u32; 4usize],
4495}
4496#[repr(C)]
4497#[derive(Copy, Clone)]
4498pub union _VAEncPictureParameterBufferVP8__bindgen_ty_1 {
4499 pub bits: _VAEncPictureParameterBufferVP8__bindgen_ty_1__bindgen_ty_1,
4500 pub value: u32,
4501}
4502#[repr(C)]
4503#[repr(align(4))]
4504#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
4505pub struct _VAEncPictureParameterBufferVP8__bindgen_ty_1__bindgen_ty_1 {
4506 pub _bitfield_align_1: [u16; 0],
4507 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
4508}
4509impl _VAEncPictureParameterBufferVP8__bindgen_ty_1__bindgen_ty_1 {
4510 #[inline]
4511 pub fn force_kf(&self) -> u32 {
4512 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
4513 }
4514 #[inline]
4515 pub fn set_force_kf(&mut self, val: u32) {
4516 unsafe {
4517 let val: u32 = ::std::mem::transmute(val);
4518 self._bitfield_1.set(0usize, 1u8, val as u64)
4519 }
4520 }
4521 #[inline]
4522 pub fn no_ref_last(&self) -> u32 {
4523 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
4524 }
4525 #[inline]
4526 pub fn set_no_ref_last(&mut self, val: u32) {
4527 unsafe {
4528 let val: u32 = ::std::mem::transmute(val);
4529 self._bitfield_1.set(1usize, 1u8, val as u64)
4530 }
4531 }
4532 #[inline]
4533 pub fn no_ref_gf(&self) -> u32 {
4534 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
4535 }
4536 #[inline]
4537 pub fn set_no_ref_gf(&mut self, val: u32) {
4538 unsafe {
4539 let val: u32 = ::std::mem::transmute(val);
4540 self._bitfield_1.set(2usize, 1u8, val as u64)
4541 }
4542 }
4543 #[inline]
4544 pub fn no_ref_arf(&self) -> u32 {
4545 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
4546 }
4547 #[inline]
4548 pub fn set_no_ref_arf(&mut self, val: u32) {
4549 unsafe {
4550 let val: u32 = ::std::mem::transmute(val);
4551 self._bitfield_1.set(3usize, 1u8, val as u64)
4552 }
4553 }
4554 #[inline]
4555 pub fn temporal_id(&self) -> u32 {
4556 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 8u8) as u32) }
4557 }
4558 #[inline]
4559 pub fn set_temporal_id(&mut self, val: u32) {
4560 unsafe {
4561 let val: u32 = ::std::mem::transmute(val);
4562 self._bitfield_1.set(4usize, 8u8, val as u64)
4563 }
4564 }
4565 #[inline]
4566 pub fn first_ref(&self) -> u32 {
4567 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 2u8) as u32) }
4568 }
4569 #[inline]
4570 pub fn set_first_ref(&mut self, val: u32) {
4571 unsafe {
4572 let val: u32 = ::std::mem::transmute(val);
4573 self._bitfield_1.set(12usize, 2u8, val as u64)
4574 }
4575 }
4576 #[inline]
4577 pub fn second_ref(&self) -> u32 {
4578 unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 2u8) as u32) }
4579 }
4580 #[inline]
4581 pub fn set_second_ref(&mut self, val: u32) {
4582 unsafe {
4583 let val: u32 = ::std::mem::transmute(val);
4584 self._bitfield_1.set(14usize, 2u8, val as u64)
4585 }
4586 }
4587 #[inline]
4588 pub fn reserved(&self) -> u32 {
4589 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 16u8) as u32) }
4590 }
4591 #[inline]
4592 pub fn set_reserved(&mut self, val: u32) {
4593 unsafe {
4594 let val: u32 = ::std::mem::transmute(val);
4595 self._bitfield_1.set(16usize, 16u8, val as u64)
4596 }
4597 }
4598 #[inline]
4599 pub fn new_bitfield_1(
4600 force_kf: u32,
4601 no_ref_last: u32,
4602 no_ref_gf: u32,
4603 no_ref_arf: u32,
4604 temporal_id: u32,
4605 first_ref: u32,
4606 second_ref: u32,
4607 reserved: u32,
4608 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
4609 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
4610 __bindgen_bitfield_unit.set(0usize, 1u8, {
4611 let force_kf: u32 = unsafe { ::std::mem::transmute(force_kf) };
4612 force_kf as u64
4613 });
4614 __bindgen_bitfield_unit.set(1usize, 1u8, {
4615 let no_ref_last: u32 = unsafe { ::std::mem::transmute(no_ref_last) };
4616 no_ref_last as u64
4617 });
4618 __bindgen_bitfield_unit.set(2usize, 1u8, {
4619 let no_ref_gf: u32 = unsafe { ::std::mem::transmute(no_ref_gf) };
4620 no_ref_gf as u64
4621 });
4622 __bindgen_bitfield_unit.set(3usize, 1u8, {
4623 let no_ref_arf: u32 = unsafe { ::std::mem::transmute(no_ref_arf) };
4624 no_ref_arf as u64
4625 });
4626 __bindgen_bitfield_unit.set(4usize, 8u8, {
4627 let temporal_id: u32 = unsafe { ::std::mem::transmute(temporal_id) };
4628 temporal_id as u64
4629 });
4630 __bindgen_bitfield_unit.set(12usize, 2u8, {
4631 let first_ref: u32 = unsafe { ::std::mem::transmute(first_ref) };
4632 first_ref as u64
4633 });
4634 __bindgen_bitfield_unit.set(14usize, 2u8, {
4635 let second_ref: u32 = unsafe { ::std::mem::transmute(second_ref) };
4636 second_ref as u64
4637 });
4638 __bindgen_bitfield_unit.set(16usize, 16u8, {
4639 let reserved: u32 = unsafe { ::std::mem::transmute(reserved) };
4640 reserved as u64
4641 });
4642 __bindgen_bitfield_unit
4643 }
4644}
4645impl Default for _VAEncPictureParameterBufferVP8__bindgen_ty_1 {
4646 fn default() -> Self {
4647 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4648 unsafe {
4649 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4650 s.assume_init()
4651 }
4652 }
4653}
4654#[repr(C)]
4655#[derive(Copy, Clone)]
4656pub union _VAEncPictureParameterBufferVP8__bindgen_ty_2 {
4657 pub bits: _VAEncPictureParameterBufferVP8__bindgen_ty_2__bindgen_ty_1,
4658 pub value: u32,
4659}
4660#[repr(C)]
4661#[repr(align(4))]
4662#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
4663pub struct _VAEncPictureParameterBufferVP8__bindgen_ty_2__bindgen_ty_1 {
4664 pub _bitfield_align_1: [u8; 0],
4665 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
4666}
4667impl _VAEncPictureParameterBufferVP8__bindgen_ty_2__bindgen_ty_1 {
4668 #[inline]
4669 pub fn frame_type(&self) -> u32 {
4670 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
4671 }
4672 #[inline]
4673 pub fn set_frame_type(&mut self, val: u32) {
4674 unsafe {
4675 let val: u32 = ::std::mem::transmute(val);
4676 self._bitfield_1.set(0usize, 1u8, val as u64)
4677 }
4678 }
4679 #[inline]
4680 pub fn version(&self) -> u32 {
4681 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 3u8) as u32) }
4682 }
4683 #[inline]
4684 pub fn set_version(&mut self, val: u32) {
4685 unsafe {
4686 let val: u32 = ::std::mem::transmute(val);
4687 self._bitfield_1.set(1usize, 3u8, val as u64)
4688 }
4689 }
4690 #[inline]
4691 pub fn show_frame(&self) -> u32 {
4692 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
4693 }
4694 #[inline]
4695 pub fn set_show_frame(&mut self, val: u32) {
4696 unsafe {
4697 let val: u32 = ::std::mem::transmute(val);
4698 self._bitfield_1.set(4usize, 1u8, val as u64)
4699 }
4700 }
4701 #[inline]
4702 pub fn color_space(&self) -> u32 {
4703 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
4704 }
4705 #[inline]
4706 pub fn set_color_space(&mut self, val: u32) {
4707 unsafe {
4708 let val: u32 = ::std::mem::transmute(val);
4709 self._bitfield_1.set(5usize, 1u8, val as u64)
4710 }
4711 }
4712 #[inline]
4713 pub fn recon_filter_type(&self) -> u32 {
4714 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 2u8) as u32) }
4715 }
4716 #[inline]
4717 pub fn set_recon_filter_type(&mut self, val: u32) {
4718 unsafe {
4719 let val: u32 = ::std::mem::transmute(val);
4720 self._bitfield_1.set(6usize, 2u8, val as u64)
4721 }
4722 }
4723 #[inline]
4724 pub fn loop_filter_type(&self) -> u32 {
4725 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 2u8) as u32) }
4726 }
4727 #[inline]
4728 pub fn set_loop_filter_type(&mut self, val: u32) {
4729 unsafe {
4730 let val: u32 = ::std::mem::transmute(val);
4731 self._bitfield_1.set(8usize, 2u8, val as u64)
4732 }
4733 }
4734 #[inline]
4735 pub fn auto_partitions(&self) -> u32 {
4736 unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) }
4737 }
4738 #[inline]
4739 pub fn set_auto_partitions(&mut self, val: u32) {
4740 unsafe {
4741 let val: u32 = ::std::mem::transmute(val);
4742 self._bitfield_1.set(10usize, 1u8, val as u64)
4743 }
4744 }
4745 #[inline]
4746 pub fn num_token_partitions(&self) -> u32 {
4747 unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 2u8) as u32) }
4748 }
4749 #[inline]
4750 pub fn set_num_token_partitions(&mut self, val: u32) {
4751 unsafe {
4752 let val: u32 = ::std::mem::transmute(val);
4753 self._bitfield_1.set(11usize, 2u8, val as u64)
4754 }
4755 }
4756 #[inline]
4757 pub fn clamping_type(&self) -> u32 {
4758 unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) }
4759 }
4760 #[inline]
4761 pub fn set_clamping_type(&mut self, val: u32) {
4762 unsafe {
4763 let val: u32 = ::std::mem::transmute(val);
4764 self._bitfield_1.set(13usize, 1u8, val as u64)
4765 }
4766 }
4767 #[inline]
4768 pub fn segmentation_enabled(&self) -> u32 {
4769 unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) }
4770 }
4771 #[inline]
4772 pub fn set_segmentation_enabled(&mut self, val: u32) {
4773 unsafe {
4774 let val: u32 = ::std::mem::transmute(val);
4775 self._bitfield_1.set(14usize, 1u8, val as u64)
4776 }
4777 }
4778 #[inline]
4779 pub fn update_mb_segmentation_map(&self) -> u32 {
4780 unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u32) }
4781 }
4782 #[inline]
4783 pub fn set_update_mb_segmentation_map(&mut self, val: u32) {
4784 unsafe {
4785 let val: u32 = ::std::mem::transmute(val);
4786 self._bitfield_1.set(15usize, 1u8, val as u64)
4787 }
4788 }
4789 #[inline]
4790 pub fn update_segment_feature_data(&self) -> u32 {
4791 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u32) }
4792 }
4793 #[inline]
4794 pub fn set_update_segment_feature_data(&mut self, val: u32) {
4795 unsafe {
4796 let val: u32 = ::std::mem::transmute(val);
4797 self._bitfield_1.set(16usize, 1u8, val as u64)
4798 }
4799 }
4800 #[inline]
4801 pub fn loop_filter_adj_enable(&self) -> u32 {
4802 unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 1u8) as u32) }
4803 }
4804 #[inline]
4805 pub fn set_loop_filter_adj_enable(&mut self, val: u32) {
4806 unsafe {
4807 let val: u32 = ::std::mem::transmute(val);
4808 self._bitfield_1.set(17usize, 1u8, val as u64)
4809 }
4810 }
4811 #[inline]
4812 pub fn refresh_entropy_probs(&self) -> u32 {
4813 unsafe { ::std::mem::transmute(self._bitfield_1.get(18usize, 1u8) as u32) }
4814 }
4815 #[inline]
4816 pub fn set_refresh_entropy_probs(&mut self, val: u32) {
4817 unsafe {
4818 let val: u32 = ::std::mem::transmute(val);
4819 self._bitfield_1.set(18usize, 1u8, val as u64)
4820 }
4821 }
4822 #[inline]
4823 pub fn refresh_golden_frame(&self) -> u32 {
4824 unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 1u8) as u32) }
4825 }
4826 #[inline]
4827 pub fn set_refresh_golden_frame(&mut self, val: u32) {
4828 unsafe {
4829 let val: u32 = ::std::mem::transmute(val);
4830 self._bitfield_1.set(19usize, 1u8, val as u64)
4831 }
4832 }
4833 #[inline]
4834 pub fn refresh_alternate_frame(&self) -> u32 {
4835 unsafe { ::std::mem::transmute(self._bitfield_1.get(20usize, 1u8) as u32) }
4836 }
4837 #[inline]
4838 pub fn set_refresh_alternate_frame(&mut self, val: u32) {
4839 unsafe {
4840 let val: u32 = ::std::mem::transmute(val);
4841 self._bitfield_1.set(20usize, 1u8, val as u64)
4842 }
4843 }
4844 #[inline]
4845 pub fn refresh_last(&self) -> u32 {
4846 unsafe { ::std::mem::transmute(self._bitfield_1.get(21usize, 1u8) as u32) }
4847 }
4848 #[inline]
4849 pub fn set_refresh_last(&mut self, val: u32) {
4850 unsafe {
4851 let val: u32 = ::std::mem::transmute(val);
4852 self._bitfield_1.set(21usize, 1u8, val as u64)
4853 }
4854 }
4855 #[inline]
4856 pub fn copy_buffer_to_golden(&self) -> u32 {
4857 unsafe { ::std::mem::transmute(self._bitfield_1.get(22usize, 2u8) as u32) }
4858 }
4859 #[inline]
4860 pub fn set_copy_buffer_to_golden(&mut self, val: u32) {
4861 unsafe {
4862 let val: u32 = ::std::mem::transmute(val);
4863 self._bitfield_1.set(22usize, 2u8, val as u64)
4864 }
4865 }
4866 #[inline]
4867 pub fn copy_buffer_to_alternate(&self) -> u32 {
4868 unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 2u8) as u32) }
4869 }
4870 #[inline]
4871 pub fn set_copy_buffer_to_alternate(&mut self, val: u32) {
4872 unsafe {
4873 let val: u32 = ::std::mem::transmute(val);
4874 self._bitfield_1.set(24usize, 2u8, val as u64)
4875 }
4876 }
4877 #[inline]
4878 pub fn sign_bias_golden(&self) -> u32 {
4879 unsafe { ::std::mem::transmute(self._bitfield_1.get(26usize, 1u8) as u32) }
4880 }
4881 #[inline]
4882 pub fn set_sign_bias_golden(&mut self, val: u32) {
4883 unsafe {
4884 let val: u32 = ::std::mem::transmute(val);
4885 self._bitfield_1.set(26usize, 1u8, val as u64)
4886 }
4887 }
4888 #[inline]
4889 pub fn sign_bias_alternate(&self) -> u32 {
4890 unsafe { ::std::mem::transmute(self._bitfield_1.get(27usize, 1u8) as u32) }
4891 }
4892 #[inline]
4893 pub fn set_sign_bias_alternate(&mut self, val: u32) {
4894 unsafe {
4895 let val: u32 = ::std::mem::transmute(val);
4896 self._bitfield_1.set(27usize, 1u8, val as u64)
4897 }
4898 }
4899 #[inline]
4900 pub fn mb_no_coeff_skip(&self) -> u32 {
4901 unsafe { ::std::mem::transmute(self._bitfield_1.get(28usize, 1u8) as u32) }
4902 }
4903 #[inline]
4904 pub fn set_mb_no_coeff_skip(&mut self, val: u32) {
4905 unsafe {
4906 let val: u32 = ::std::mem::transmute(val);
4907 self._bitfield_1.set(28usize, 1u8, val as u64)
4908 }
4909 }
4910 #[inline]
4911 pub fn forced_lf_adjustment(&self) -> u32 {
4912 unsafe { ::std::mem::transmute(self._bitfield_1.get(29usize, 1u8) as u32) }
4913 }
4914 #[inline]
4915 pub fn set_forced_lf_adjustment(&mut self, val: u32) {
4916 unsafe {
4917 let val: u32 = ::std::mem::transmute(val);
4918 self._bitfield_1.set(29usize, 1u8, val as u64)
4919 }
4920 }
4921 #[inline]
4922 pub fn reserved(&self) -> u32 {
4923 unsafe { ::std::mem::transmute(self._bitfield_1.get(30usize, 2u8) as u32) }
4924 }
4925 #[inline]
4926 pub fn set_reserved(&mut self, val: u32) {
4927 unsafe {
4928 let val: u32 = ::std::mem::transmute(val);
4929 self._bitfield_1.set(30usize, 2u8, val as u64)
4930 }
4931 }
4932 #[inline]
4933 pub fn new_bitfield_1(
4934 frame_type: u32,
4935 version: u32,
4936 show_frame: u32,
4937 color_space: u32,
4938 recon_filter_type: u32,
4939 loop_filter_type: u32,
4940 auto_partitions: u32,
4941 num_token_partitions: u32,
4942 clamping_type: u32,
4943 segmentation_enabled: u32,
4944 update_mb_segmentation_map: u32,
4945 update_segment_feature_data: u32,
4946 loop_filter_adj_enable: u32,
4947 refresh_entropy_probs: u32,
4948 refresh_golden_frame: u32,
4949 refresh_alternate_frame: u32,
4950 refresh_last: u32,
4951 copy_buffer_to_golden: u32,
4952 copy_buffer_to_alternate: u32,
4953 sign_bias_golden: u32,
4954 sign_bias_alternate: u32,
4955 mb_no_coeff_skip: u32,
4956 forced_lf_adjustment: u32,
4957 reserved: u32,
4958 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
4959 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
4960 __bindgen_bitfield_unit.set(0usize, 1u8, {
4961 let frame_type: u32 = unsafe { ::std::mem::transmute(frame_type) };
4962 frame_type as u64
4963 });
4964 __bindgen_bitfield_unit.set(1usize, 3u8, {
4965 let version: u32 = unsafe { ::std::mem::transmute(version) };
4966 version as u64
4967 });
4968 __bindgen_bitfield_unit.set(4usize, 1u8, {
4969 let show_frame: u32 = unsafe { ::std::mem::transmute(show_frame) };
4970 show_frame as u64
4971 });
4972 __bindgen_bitfield_unit.set(5usize, 1u8, {
4973 let color_space: u32 = unsafe { ::std::mem::transmute(color_space) };
4974 color_space as u64
4975 });
4976 __bindgen_bitfield_unit.set(6usize, 2u8, {
4977 let recon_filter_type: u32 = unsafe { ::std::mem::transmute(recon_filter_type) };
4978 recon_filter_type as u64
4979 });
4980 __bindgen_bitfield_unit.set(8usize, 2u8, {
4981 let loop_filter_type: u32 = unsafe { ::std::mem::transmute(loop_filter_type) };
4982 loop_filter_type as u64
4983 });
4984 __bindgen_bitfield_unit.set(10usize, 1u8, {
4985 let auto_partitions: u32 = unsafe { ::std::mem::transmute(auto_partitions) };
4986 auto_partitions as u64
4987 });
4988 __bindgen_bitfield_unit.set(11usize, 2u8, {
4989 let num_token_partitions: u32 = unsafe { ::std::mem::transmute(num_token_partitions) };
4990 num_token_partitions as u64
4991 });
4992 __bindgen_bitfield_unit.set(13usize, 1u8, {
4993 let clamping_type: u32 = unsafe { ::std::mem::transmute(clamping_type) };
4994 clamping_type as u64
4995 });
4996 __bindgen_bitfield_unit.set(14usize, 1u8, {
4997 let segmentation_enabled: u32 = unsafe { ::std::mem::transmute(segmentation_enabled) };
4998 segmentation_enabled as u64
4999 });
5000 __bindgen_bitfield_unit.set(15usize, 1u8, {
5001 let update_mb_segmentation_map: u32 =
5002 unsafe { ::std::mem::transmute(update_mb_segmentation_map) };
5003 update_mb_segmentation_map as u64
5004 });
5005 __bindgen_bitfield_unit.set(16usize, 1u8, {
5006 let update_segment_feature_data: u32 =
5007 unsafe { ::std::mem::transmute(update_segment_feature_data) };
5008 update_segment_feature_data as u64
5009 });
5010 __bindgen_bitfield_unit.set(17usize, 1u8, {
5011 let loop_filter_adj_enable: u32 =
5012 unsafe { ::std::mem::transmute(loop_filter_adj_enable) };
5013 loop_filter_adj_enable as u64
5014 });
5015 __bindgen_bitfield_unit.set(18usize, 1u8, {
5016 let refresh_entropy_probs: u32 =
5017 unsafe { ::std::mem::transmute(refresh_entropy_probs) };
5018 refresh_entropy_probs as u64
5019 });
5020 __bindgen_bitfield_unit.set(19usize, 1u8, {
5021 let refresh_golden_frame: u32 = unsafe { ::std::mem::transmute(refresh_golden_frame) };
5022 refresh_golden_frame as u64
5023 });
5024 __bindgen_bitfield_unit.set(20usize, 1u8, {
5025 let refresh_alternate_frame: u32 =
5026 unsafe { ::std::mem::transmute(refresh_alternate_frame) };
5027 refresh_alternate_frame as u64
5028 });
5029 __bindgen_bitfield_unit.set(21usize, 1u8, {
5030 let refresh_last: u32 = unsafe { ::std::mem::transmute(refresh_last) };
5031 refresh_last as u64
5032 });
5033 __bindgen_bitfield_unit.set(22usize, 2u8, {
5034 let copy_buffer_to_golden: u32 =
5035 unsafe { ::std::mem::transmute(copy_buffer_to_golden) };
5036 copy_buffer_to_golden as u64
5037 });
5038 __bindgen_bitfield_unit.set(24usize, 2u8, {
5039 let copy_buffer_to_alternate: u32 =
5040 unsafe { ::std::mem::transmute(copy_buffer_to_alternate) };
5041 copy_buffer_to_alternate as u64
5042 });
5043 __bindgen_bitfield_unit.set(26usize, 1u8, {
5044 let sign_bias_golden: u32 = unsafe { ::std::mem::transmute(sign_bias_golden) };
5045 sign_bias_golden as u64
5046 });
5047 __bindgen_bitfield_unit.set(27usize, 1u8, {
5048 let sign_bias_alternate: u32 = unsafe { ::std::mem::transmute(sign_bias_alternate) };
5049 sign_bias_alternate as u64
5050 });
5051 __bindgen_bitfield_unit.set(28usize, 1u8, {
5052 let mb_no_coeff_skip: u32 = unsafe { ::std::mem::transmute(mb_no_coeff_skip) };
5053 mb_no_coeff_skip as u64
5054 });
5055 __bindgen_bitfield_unit.set(29usize, 1u8, {
5056 let forced_lf_adjustment: u32 = unsafe { ::std::mem::transmute(forced_lf_adjustment) };
5057 forced_lf_adjustment as u64
5058 });
5059 __bindgen_bitfield_unit.set(30usize, 2u8, {
5060 let reserved: u32 = unsafe { ::std::mem::transmute(reserved) };
5061 reserved as u64
5062 });
5063 __bindgen_bitfield_unit
5064 }
5065}
5066impl Default for _VAEncPictureParameterBufferVP8__bindgen_ty_2 {
5067 fn default() -> Self {
5068 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5069 unsafe {
5070 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5071 s.assume_init()
5072 }
5073 }
5074}
5075impl Default for _VAEncPictureParameterBufferVP8 {
5076 fn default() -> Self {
5077 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5078 unsafe {
5079 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5080 s.assume_init()
5081 }
5082 }
5083}
5084pub type VAEncPictureParameterBufferVP8 = _VAEncPictureParameterBufferVP8;
5085#[repr(C)]
5086#[derive(Debug, Copy, Clone, PartialEq, Eq)]
5087pub struct _VAEncMBMapBufferVP8 {
5088 pub num_mbs: u32,
5089 pub mb_segment_id: *mut u8,
5090 pub va_reserved: [u32; 4usize],
5091}
5092impl Default for _VAEncMBMapBufferVP8 {
5093 fn default() -> Self {
5094 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5095 unsafe {
5096 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5097 s.assume_init()
5098 }
5099 }
5100}
5101pub type VAEncMBMapBufferVP8 = _VAEncMBMapBufferVP8;
5102#[repr(C)]
5103#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
5104pub struct _VAQMatrixBufferVP8 {
5105 pub quantization_index: [u16; 4usize],
5106 pub quantization_index_delta: [i16; 5usize],
5107 pub va_reserved: [u32; 4usize],
5108}
5109pub type VAQMatrixBufferVP8 = _VAQMatrixBufferVP8;
5110#[repr(C)]
5111#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
5112pub struct _VACodedBufferVP9Status {
5113 pub base_qp_index: u16,
5114 pub loop_filter_level: u8,
5115 pub long_term_indication: u8,
5116 pub next_frame_width: u16,
5117 pub next_frame_height: u16,
5118 pub va_reserved: [u32; 4usize],
5119}
5120pub type VACodedBufferVP9Status = _VACodedBufferVP9Status;
5121#[repr(C)]
5122#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
5123pub struct _VAEncSequenceParameterBufferVP9 {
5124 pub max_frame_width: u32,
5125 pub max_frame_height: u32,
5126 pub kf_auto: u32,
5127 pub kf_min_dist: u32,
5128 pub kf_max_dist: u32,
5129 pub bits_per_second: u32,
5130 pub intra_period: u32,
5131 pub va_reserved: [u32; 4usize],
5132}
5133pub type VAEncSequenceParameterBufferVP9 = _VAEncSequenceParameterBufferVP9;
5134#[repr(C)]
5135#[derive(Copy, Clone)]
5136pub struct _VAEncPictureParameterBufferVP9 {
5137 pub frame_width_src: u32,
5138 pub frame_height_src: u32,
5139 pub frame_width_dst: u32,
5140 pub frame_height_dst: u32,
5141 pub reconstructed_frame: VASurfaceID,
5142 pub reference_frames: [VASurfaceID; 8usize],
5143 pub coded_buf: VABufferID,
5144 pub ref_flags: _VAEncPictureParameterBufferVP9__bindgen_ty_1,
5145 pub pic_flags: _VAEncPictureParameterBufferVP9__bindgen_ty_2,
5146 pub refresh_frame_flags: u8,
5147 pub luma_ac_qindex: u8,
5148 pub luma_dc_qindex_delta: i8,
5149 pub chroma_ac_qindex_delta: i8,
5150 pub chroma_dc_qindex_delta: i8,
5151 pub filter_level: u8,
5152 pub sharpness_level: u8,
5153 pub ref_lf_delta: [i8; 4usize],
5154 pub mode_lf_delta: [i8; 2usize],
5155 pub bit_offset_ref_lf_delta: u16,
5156 pub bit_offset_mode_lf_delta: u16,
5157 pub bit_offset_lf_level: u16,
5158 pub bit_offset_qindex: u16,
5159 pub bit_offset_first_partition_size: u16,
5160 pub bit_offset_segmentation: u16,
5161 pub bit_size_segmentation: u16,
5162 pub log2_tile_rows: u8,
5163 pub log2_tile_columns: u8,
5164 pub skip_frame_flag: u8,
5165 pub number_skip_frames: u8,
5166 pub skip_frames_size: u32,
5167 pub va_reserved: [u32; 8usize],
5168}
5169#[repr(C)]
5170#[derive(Copy, Clone)]
5171pub union _VAEncPictureParameterBufferVP9__bindgen_ty_1 {
5172 pub bits: _VAEncPictureParameterBufferVP9__bindgen_ty_1__bindgen_ty_1,
5173 pub value: u32,
5174}
5175#[repr(C)]
5176#[repr(align(4))]
5177#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
5178pub struct _VAEncPictureParameterBufferVP9__bindgen_ty_1__bindgen_ty_1 {
5179 pub _bitfield_align_1: [u8; 0],
5180 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
5181}
5182impl _VAEncPictureParameterBufferVP9__bindgen_ty_1__bindgen_ty_1 {
5183 #[inline]
5184 pub fn force_kf(&self) -> u32 {
5185 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
5186 }
5187 #[inline]
5188 pub fn set_force_kf(&mut self, val: u32) {
5189 unsafe {
5190 let val: u32 = ::std::mem::transmute(val);
5191 self._bitfield_1.set(0usize, 1u8, val as u64)
5192 }
5193 }
5194 #[inline]
5195 pub fn ref_frame_ctrl_l0(&self) -> u32 {
5196 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 3u8) as u32) }
5197 }
5198 #[inline]
5199 pub fn set_ref_frame_ctrl_l0(&mut self, val: u32) {
5200 unsafe {
5201 let val: u32 = ::std::mem::transmute(val);
5202 self._bitfield_1.set(1usize, 3u8, val as u64)
5203 }
5204 }
5205 #[inline]
5206 pub fn ref_frame_ctrl_l1(&self) -> u32 {
5207 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 3u8) as u32) }
5208 }
5209 #[inline]
5210 pub fn set_ref_frame_ctrl_l1(&mut self, val: u32) {
5211 unsafe {
5212 let val: u32 = ::std::mem::transmute(val);
5213 self._bitfield_1.set(4usize, 3u8, val as u64)
5214 }
5215 }
5216 #[inline]
5217 pub fn ref_last_idx(&self) -> u32 {
5218 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 3u8) as u32) }
5219 }
5220 #[inline]
5221 pub fn set_ref_last_idx(&mut self, val: u32) {
5222 unsafe {
5223 let val: u32 = ::std::mem::transmute(val);
5224 self._bitfield_1.set(7usize, 3u8, val as u64)
5225 }
5226 }
5227 #[inline]
5228 pub fn ref_last_sign_bias(&self) -> u32 {
5229 unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) }
5230 }
5231 #[inline]
5232 pub fn set_ref_last_sign_bias(&mut self, val: u32) {
5233 unsafe {
5234 let val: u32 = ::std::mem::transmute(val);
5235 self._bitfield_1.set(10usize, 1u8, val as u64)
5236 }
5237 }
5238 #[inline]
5239 pub fn ref_gf_idx(&self) -> u32 {
5240 unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 3u8) as u32) }
5241 }
5242 #[inline]
5243 pub fn set_ref_gf_idx(&mut self, val: u32) {
5244 unsafe {
5245 let val: u32 = ::std::mem::transmute(val);
5246 self._bitfield_1.set(11usize, 3u8, val as u64)
5247 }
5248 }
5249 #[inline]
5250 pub fn ref_gf_sign_bias(&self) -> u32 {
5251 unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) }
5252 }
5253 #[inline]
5254 pub fn set_ref_gf_sign_bias(&mut self, val: u32) {
5255 unsafe {
5256 let val: u32 = ::std::mem::transmute(val);
5257 self._bitfield_1.set(14usize, 1u8, val as u64)
5258 }
5259 }
5260 #[inline]
5261 pub fn ref_arf_idx(&self) -> u32 {
5262 unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 3u8) as u32) }
5263 }
5264 #[inline]
5265 pub fn set_ref_arf_idx(&mut self, val: u32) {
5266 unsafe {
5267 let val: u32 = ::std::mem::transmute(val);
5268 self._bitfield_1.set(15usize, 3u8, val as u64)
5269 }
5270 }
5271 #[inline]
5272 pub fn ref_arf_sign_bias(&self) -> u32 {
5273 unsafe { ::std::mem::transmute(self._bitfield_1.get(18usize, 1u8) as u32) }
5274 }
5275 #[inline]
5276 pub fn set_ref_arf_sign_bias(&mut self, val: u32) {
5277 unsafe {
5278 let val: u32 = ::std::mem::transmute(val);
5279 self._bitfield_1.set(18usize, 1u8, val as u64)
5280 }
5281 }
5282 #[inline]
5283 pub fn temporal_id(&self) -> u32 {
5284 unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 8u8) as u32) }
5285 }
5286 #[inline]
5287 pub fn set_temporal_id(&mut self, val: u32) {
5288 unsafe {
5289 let val: u32 = ::std::mem::transmute(val);
5290 self._bitfield_1.set(19usize, 8u8, val as u64)
5291 }
5292 }
5293 #[inline]
5294 pub fn reserved(&self) -> u32 {
5295 unsafe { ::std::mem::transmute(self._bitfield_1.get(27usize, 5u8) as u32) }
5296 }
5297 #[inline]
5298 pub fn set_reserved(&mut self, val: u32) {
5299 unsafe {
5300 let val: u32 = ::std::mem::transmute(val);
5301 self._bitfield_1.set(27usize, 5u8, val as u64)
5302 }
5303 }
5304 #[inline]
5305 pub fn new_bitfield_1(
5306 force_kf: u32,
5307 ref_frame_ctrl_l0: u32,
5308 ref_frame_ctrl_l1: u32,
5309 ref_last_idx: u32,
5310 ref_last_sign_bias: u32,
5311 ref_gf_idx: u32,
5312 ref_gf_sign_bias: u32,
5313 ref_arf_idx: u32,
5314 ref_arf_sign_bias: u32,
5315 temporal_id: u32,
5316 reserved: u32,
5317 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
5318 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
5319 __bindgen_bitfield_unit.set(0usize, 1u8, {
5320 let force_kf: u32 = unsafe { ::std::mem::transmute(force_kf) };
5321 force_kf as u64
5322 });
5323 __bindgen_bitfield_unit.set(1usize, 3u8, {
5324 let ref_frame_ctrl_l0: u32 = unsafe { ::std::mem::transmute(ref_frame_ctrl_l0) };
5325 ref_frame_ctrl_l0 as u64
5326 });
5327 __bindgen_bitfield_unit.set(4usize, 3u8, {
5328 let ref_frame_ctrl_l1: u32 = unsafe { ::std::mem::transmute(ref_frame_ctrl_l1) };
5329 ref_frame_ctrl_l1 as u64
5330 });
5331 __bindgen_bitfield_unit.set(7usize, 3u8, {
5332 let ref_last_idx: u32 = unsafe { ::std::mem::transmute(ref_last_idx) };
5333 ref_last_idx as u64
5334 });
5335 __bindgen_bitfield_unit.set(10usize, 1u8, {
5336 let ref_last_sign_bias: u32 = unsafe { ::std::mem::transmute(ref_last_sign_bias) };
5337 ref_last_sign_bias as u64
5338 });
5339 __bindgen_bitfield_unit.set(11usize, 3u8, {
5340 let ref_gf_idx: u32 = unsafe { ::std::mem::transmute(ref_gf_idx) };
5341 ref_gf_idx as u64
5342 });
5343 __bindgen_bitfield_unit.set(14usize, 1u8, {
5344 let ref_gf_sign_bias: u32 = unsafe { ::std::mem::transmute(ref_gf_sign_bias) };
5345 ref_gf_sign_bias as u64
5346 });
5347 __bindgen_bitfield_unit.set(15usize, 3u8, {
5348 let ref_arf_idx: u32 = unsafe { ::std::mem::transmute(ref_arf_idx) };
5349 ref_arf_idx as u64
5350 });
5351 __bindgen_bitfield_unit.set(18usize, 1u8, {
5352 let ref_arf_sign_bias: u32 = unsafe { ::std::mem::transmute(ref_arf_sign_bias) };
5353 ref_arf_sign_bias as u64
5354 });
5355 __bindgen_bitfield_unit.set(19usize, 8u8, {
5356 let temporal_id: u32 = unsafe { ::std::mem::transmute(temporal_id) };
5357 temporal_id as u64
5358 });
5359 __bindgen_bitfield_unit.set(27usize, 5u8, {
5360 let reserved: u32 = unsafe { ::std::mem::transmute(reserved) };
5361 reserved as u64
5362 });
5363 __bindgen_bitfield_unit
5364 }
5365}
5366impl Default for _VAEncPictureParameterBufferVP9__bindgen_ty_1 {
5367 fn default() -> Self {
5368 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5369 unsafe {
5370 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5371 s.assume_init()
5372 }
5373 }
5374}
5375#[repr(C)]
5376#[derive(Copy, Clone)]
5377pub union _VAEncPictureParameterBufferVP9__bindgen_ty_2 {
5378 pub bits: _VAEncPictureParameterBufferVP9__bindgen_ty_2__bindgen_ty_1,
5379 pub value: u32,
5380}
5381#[repr(C)]
5382#[repr(align(4))]
5383#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
5384pub struct _VAEncPictureParameterBufferVP9__bindgen_ty_2__bindgen_ty_1 {
5385 pub _bitfield_align_1: [u16; 0],
5386 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
5387}
5388impl _VAEncPictureParameterBufferVP9__bindgen_ty_2__bindgen_ty_1 {
5389 #[inline]
5390 pub fn frame_type(&self) -> u32 {
5391 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
5392 }
5393 #[inline]
5394 pub fn set_frame_type(&mut self, val: u32) {
5395 unsafe {
5396 let val: u32 = ::std::mem::transmute(val);
5397 self._bitfield_1.set(0usize, 1u8, val as u64)
5398 }
5399 }
5400 #[inline]
5401 pub fn show_frame(&self) -> u32 {
5402 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
5403 }
5404 #[inline]
5405 pub fn set_show_frame(&mut self, val: u32) {
5406 unsafe {
5407 let val: u32 = ::std::mem::transmute(val);
5408 self._bitfield_1.set(1usize, 1u8, val as u64)
5409 }
5410 }
5411 #[inline]
5412 pub fn error_resilient_mode(&self) -> u32 {
5413 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
5414 }
5415 #[inline]
5416 pub fn set_error_resilient_mode(&mut self, val: u32) {
5417 unsafe {
5418 let val: u32 = ::std::mem::transmute(val);
5419 self._bitfield_1.set(2usize, 1u8, val as u64)
5420 }
5421 }
5422 #[inline]
5423 pub fn intra_only(&self) -> u32 {
5424 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
5425 }
5426 #[inline]
5427 pub fn set_intra_only(&mut self, val: u32) {
5428 unsafe {
5429 let val: u32 = ::std::mem::transmute(val);
5430 self._bitfield_1.set(3usize, 1u8, val as u64)
5431 }
5432 }
5433 #[inline]
5434 pub fn allow_high_precision_mv(&self) -> u32 {
5435 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
5436 }
5437 #[inline]
5438 pub fn set_allow_high_precision_mv(&mut self, val: u32) {
5439 unsafe {
5440 let val: u32 = ::std::mem::transmute(val);
5441 self._bitfield_1.set(4usize, 1u8, val as u64)
5442 }
5443 }
5444 #[inline]
5445 pub fn mcomp_filter_type(&self) -> u32 {
5446 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 3u8) as u32) }
5447 }
5448 #[inline]
5449 pub fn set_mcomp_filter_type(&mut self, val: u32) {
5450 unsafe {
5451 let val: u32 = ::std::mem::transmute(val);
5452 self._bitfield_1.set(5usize, 3u8, val as u64)
5453 }
5454 }
5455 #[inline]
5456 pub fn frame_parallel_decoding_mode(&self) -> u32 {
5457 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) }
5458 }
5459 #[inline]
5460 pub fn set_frame_parallel_decoding_mode(&mut self, val: u32) {
5461 unsafe {
5462 let val: u32 = ::std::mem::transmute(val);
5463 self._bitfield_1.set(8usize, 1u8, val as u64)
5464 }
5465 }
5466 #[inline]
5467 pub fn reset_frame_context(&self) -> u32 {
5468 unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 2u8) as u32) }
5469 }
5470 #[inline]
5471 pub fn set_reset_frame_context(&mut self, val: u32) {
5472 unsafe {
5473 let val: u32 = ::std::mem::transmute(val);
5474 self._bitfield_1.set(9usize, 2u8, val as u64)
5475 }
5476 }
5477 #[inline]
5478 pub fn refresh_frame_context(&self) -> u32 {
5479 unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) }
5480 }
5481 #[inline]
5482 pub fn set_refresh_frame_context(&mut self, val: u32) {
5483 unsafe {
5484 let val: u32 = ::std::mem::transmute(val);
5485 self._bitfield_1.set(11usize, 1u8, val as u64)
5486 }
5487 }
5488 #[inline]
5489 pub fn frame_context_idx(&self) -> u32 {
5490 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 2u8) as u32) }
5491 }
5492 #[inline]
5493 pub fn set_frame_context_idx(&mut self, val: u32) {
5494 unsafe {
5495 let val: u32 = ::std::mem::transmute(val);
5496 self._bitfield_1.set(12usize, 2u8, val as u64)
5497 }
5498 }
5499 #[inline]
5500 pub fn segmentation_enabled(&self) -> u32 {
5501 unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) }
5502 }
5503 #[inline]
5504 pub fn set_segmentation_enabled(&mut self, val: u32) {
5505 unsafe {
5506 let val: u32 = ::std::mem::transmute(val);
5507 self._bitfield_1.set(14usize, 1u8, val as u64)
5508 }
5509 }
5510 #[inline]
5511 pub fn segmentation_temporal_update(&self) -> u32 {
5512 unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u32) }
5513 }
5514 #[inline]
5515 pub fn set_segmentation_temporal_update(&mut self, val: u32) {
5516 unsafe {
5517 let val: u32 = ::std::mem::transmute(val);
5518 self._bitfield_1.set(15usize, 1u8, val as u64)
5519 }
5520 }
5521 #[inline]
5522 pub fn segmentation_update_map(&self) -> u32 {
5523 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u32) }
5524 }
5525 #[inline]
5526 pub fn set_segmentation_update_map(&mut self, val: u32) {
5527 unsafe {
5528 let val: u32 = ::std::mem::transmute(val);
5529 self._bitfield_1.set(16usize, 1u8, val as u64)
5530 }
5531 }
5532 #[inline]
5533 pub fn lossless_mode(&self) -> u32 {
5534 unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 1u8) as u32) }
5535 }
5536 #[inline]
5537 pub fn set_lossless_mode(&mut self, val: u32) {
5538 unsafe {
5539 let val: u32 = ::std::mem::transmute(val);
5540 self._bitfield_1.set(17usize, 1u8, val as u64)
5541 }
5542 }
5543 #[inline]
5544 pub fn comp_prediction_mode(&self) -> u32 {
5545 unsafe { ::std::mem::transmute(self._bitfield_1.get(18usize, 2u8) as u32) }
5546 }
5547 #[inline]
5548 pub fn set_comp_prediction_mode(&mut self, val: u32) {
5549 unsafe {
5550 let val: u32 = ::std::mem::transmute(val);
5551 self._bitfield_1.set(18usize, 2u8, val as u64)
5552 }
5553 }
5554 #[inline]
5555 pub fn auto_segmentation(&self) -> u32 {
5556 unsafe { ::std::mem::transmute(self._bitfield_1.get(20usize, 1u8) as u32) }
5557 }
5558 #[inline]
5559 pub fn set_auto_segmentation(&mut self, val: u32) {
5560 unsafe {
5561 let val: u32 = ::std::mem::transmute(val);
5562 self._bitfield_1.set(20usize, 1u8, val as u64)
5563 }
5564 }
5565 #[inline]
5566 pub fn super_frame_flag(&self) -> u32 {
5567 unsafe { ::std::mem::transmute(self._bitfield_1.get(21usize, 1u8) as u32) }
5568 }
5569 #[inline]
5570 pub fn set_super_frame_flag(&mut self, val: u32) {
5571 unsafe {
5572 let val: u32 = ::std::mem::transmute(val);
5573 self._bitfield_1.set(21usize, 1u8, val as u64)
5574 }
5575 }
5576 #[inline]
5577 pub fn reserved(&self) -> u32 {
5578 unsafe { ::std::mem::transmute(self._bitfield_1.get(22usize, 10u8) as u32) }
5579 }
5580 #[inline]
5581 pub fn set_reserved(&mut self, val: u32) {
5582 unsafe {
5583 let val: u32 = ::std::mem::transmute(val);
5584 self._bitfield_1.set(22usize, 10u8, val as u64)
5585 }
5586 }
5587 #[inline]
5588 pub fn new_bitfield_1(
5589 frame_type: u32,
5590 show_frame: u32,
5591 error_resilient_mode: u32,
5592 intra_only: u32,
5593 allow_high_precision_mv: u32,
5594 mcomp_filter_type: u32,
5595 frame_parallel_decoding_mode: u32,
5596 reset_frame_context: u32,
5597 refresh_frame_context: u32,
5598 frame_context_idx: u32,
5599 segmentation_enabled: u32,
5600 segmentation_temporal_update: u32,
5601 segmentation_update_map: u32,
5602 lossless_mode: u32,
5603 comp_prediction_mode: u32,
5604 auto_segmentation: u32,
5605 super_frame_flag: u32,
5606 reserved: u32,
5607 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
5608 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
5609 __bindgen_bitfield_unit.set(0usize, 1u8, {
5610 let frame_type: u32 = unsafe { ::std::mem::transmute(frame_type) };
5611 frame_type as u64
5612 });
5613 __bindgen_bitfield_unit.set(1usize, 1u8, {
5614 let show_frame: u32 = unsafe { ::std::mem::transmute(show_frame) };
5615 show_frame as u64
5616 });
5617 __bindgen_bitfield_unit.set(2usize, 1u8, {
5618 let error_resilient_mode: u32 = unsafe { ::std::mem::transmute(error_resilient_mode) };
5619 error_resilient_mode as u64
5620 });
5621 __bindgen_bitfield_unit.set(3usize, 1u8, {
5622 let intra_only: u32 = unsafe { ::std::mem::transmute(intra_only) };
5623 intra_only as u64
5624 });
5625 __bindgen_bitfield_unit.set(4usize, 1u8, {
5626 let allow_high_precision_mv: u32 =
5627 unsafe { ::std::mem::transmute(allow_high_precision_mv) };
5628 allow_high_precision_mv as u64
5629 });
5630 __bindgen_bitfield_unit.set(5usize, 3u8, {
5631 let mcomp_filter_type: u32 = unsafe { ::std::mem::transmute(mcomp_filter_type) };
5632 mcomp_filter_type as u64
5633 });
5634 __bindgen_bitfield_unit.set(8usize, 1u8, {
5635 let frame_parallel_decoding_mode: u32 =
5636 unsafe { ::std::mem::transmute(frame_parallel_decoding_mode) };
5637 frame_parallel_decoding_mode as u64
5638 });
5639 __bindgen_bitfield_unit.set(9usize, 2u8, {
5640 let reset_frame_context: u32 = unsafe { ::std::mem::transmute(reset_frame_context) };
5641 reset_frame_context as u64
5642 });
5643 __bindgen_bitfield_unit.set(11usize, 1u8, {
5644 let refresh_frame_context: u32 =
5645 unsafe { ::std::mem::transmute(refresh_frame_context) };
5646 refresh_frame_context as u64
5647 });
5648 __bindgen_bitfield_unit.set(12usize, 2u8, {
5649 let frame_context_idx: u32 = unsafe { ::std::mem::transmute(frame_context_idx) };
5650 frame_context_idx as u64
5651 });
5652 __bindgen_bitfield_unit.set(14usize, 1u8, {
5653 let segmentation_enabled: u32 = unsafe { ::std::mem::transmute(segmentation_enabled) };
5654 segmentation_enabled as u64
5655 });
5656 __bindgen_bitfield_unit.set(15usize, 1u8, {
5657 let segmentation_temporal_update: u32 =
5658 unsafe { ::std::mem::transmute(segmentation_temporal_update) };
5659 segmentation_temporal_update as u64
5660 });
5661 __bindgen_bitfield_unit.set(16usize, 1u8, {
5662 let segmentation_update_map: u32 =
5663 unsafe { ::std::mem::transmute(segmentation_update_map) };
5664 segmentation_update_map as u64
5665 });
5666 __bindgen_bitfield_unit.set(17usize, 1u8, {
5667 let lossless_mode: u32 = unsafe { ::std::mem::transmute(lossless_mode) };
5668 lossless_mode as u64
5669 });
5670 __bindgen_bitfield_unit.set(18usize, 2u8, {
5671 let comp_prediction_mode: u32 = unsafe { ::std::mem::transmute(comp_prediction_mode) };
5672 comp_prediction_mode as u64
5673 });
5674 __bindgen_bitfield_unit.set(20usize, 1u8, {
5675 let auto_segmentation: u32 = unsafe { ::std::mem::transmute(auto_segmentation) };
5676 auto_segmentation as u64
5677 });
5678 __bindgen_bitfield_unit.set(21usize, 1u8, {
5679 let super_frame_flag: u32 = unsafe { ::std::mem::transmute(super_frame_flag) };
5680 super_frame_flag as u64
5681 });
5682 __bindgen_bitfield_unit.set(22usize, 10u8, {
5683 let reserved: u32 = unsafe { ::std::mem::transmute(reserved) };
5684 reserved as u64
5685 });
5686 __bindgen_bitfield_unit
5687 }
5688}
5689impl Default for _VAEncPictureParameterBufferVP9__bindgen_ty_2 {
5690 fn default() -> Self {
5691 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5692 unsafe {
5693 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5694 s.assume_init()
5695 }
5696 }
5697}
5698impl Default for _VAEncPictureParameterBufferVP9 {
5699 fn default() -> Self {
5700 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5701 unsafe {
5702 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5703 s.assume_init()
5704 }
5705 }
5706}
5707pub type VAEncPictureParameterBufferVP9 = _VAEncPictureParameterBufferVP9;
5708#[repr(C)]
5709#[derive(Copy, Clone)]
5710pub struct _VAEncSegParamVP9 {
5711 pub seg_flags: _VAEncSegParamVP9__bindgen_ty_1,
5712 pub segment_lf_level_delta: i8,
5713 pub segment_qindex_delta: i16,
5714 pub va_reserved: [u32; 4usize],
5715}
5716#[repr(C)]
5717#[derive(Copy, Clone)]
5718pub union _VAEncSegParamVP9__bindgen_ty_1 {
5719 pub bits: _VAEncSegParamVP9__bindgen_ty_1__bindgen_ty_1,
5720 pub value: u8,
5721}
5722#[repr(C, packed)]
5723#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
5724pub struct _VAEncSegParamVP9__bindgen_ty_1__bindgen_ty_1 {
5725 pub _bitfield_align_1: [u8; 0],
5726 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
5727}
5728impl _VAEncSegParamVP9__bindgen_ty_1__bindgen_ty_1 {
5729 #[inline]
5730 pub fn segment_reference_enabled(&self) -> u8 {
5731 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
5732 }
5733 #[inline]
5734 pub fn set_segment_reference_enabled(&mut self, val: u8) {
5735 unsafe {
5736 let val: u8 = ::std::mem::transmute(val);
5737 self._bitfield_1.set(0usize, 1u8, val as u64)
5738 }
5739 }
5740 #[inline]
5741 pub fn segment_reference(&self) -> u8 {
5742 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 2u8) as u8) }
5743 }
5744 #[inline]
5745 pub fn set_segment_reference(&mut self, val: u8) {
5746 unsafe {
5747 let val: u8 = ::std::mem::transmute(val);
5748 self._bitfield_1.set(1usize, 2u8, val as u64)
5749 }
5750 }
5751 #[inline]
5752 pub fn segment_reference_skipped(&self) -> u8 {
5753 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8) }
5754 }
5755 #[inline]
5756 pub fn set_segment_reference_skipped(&mut self, val: u8) {
5757 unsafe {
5758 let val: u8 = ::std::mem::transmute(val);
5759 self._bitfield_1.set(3usize, 1u8, val as u64)
5760 }
5761 }
5762 #[inline]
5763 pub fn reserved(&self) -> u8 {
5764 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 4u8) as u8) }
5765 }
5766 #[inline]
5767 pub fn set_reserved(&mut self, val: u8) {
5768 unsafe {
5769 let val: u8 = ::std::mem::transmute(val);
5770 self._bitfield_1.set(4usize, 4u8, val as u64)
5771 }
5772 }
5773 #[inline]
5774 pub fn new_bitfield_1(
5775 segment_reference_enabled: u8,
5776 segment_reference: u8,
5777 segment_reference_skipped: u8,
5778 reserved: u8,
5779 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
5780 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
5781 __bindgen_bitfield_unit.set(0usize, 1u8, {
5782 let segment_reference_enabled: u8 =
5783 unsafe { ::std::mem::transmute(segment_reference_enabled) };
5784 segment_reference_enabled as u64
5785 });
5786 __bindgen_bitfield_unit.set(1usize, 2u8, {
5787 let segment_reference: u8 = unsafe { ::std::mem::transmute(segment_reference) };
5788 segment_reference as u64
5789 });
5790 __bindgen_bitfield_unit.set(3usize, 1u8, {
5791 let segment_reference_skipped: u8 =
5792 unsafe { ::std::mem::transmute(segment_reference_skipped) };
5793 segment_reference_skipped as u64
5794 });
5795 __bindgen_bitfield_unit.set(4usize, 4u8, {
5796 let reserved: u8 = unsafe { ::std::mem::transmute(reserved) };
5797 reserved as u64
5798 });
5799 __bindgen_bitfield_unit
5800 }
5801}
5802impl Default for _VAEncSegParamVP9__bindgen_ty_1 {
5803 fn default() -> Self {
5804 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5805 unsafe {
5806 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5807 s.assume_init()
5808 }
5809 }
5810}
5811impl Default for _VAEncSegParamVP9 {
5812 fn default() -> Self {
5813 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5814 unsafe {
5815 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5816 s.assume_init()
5817 }
5818 }
5819}
5820pub type VAEncSegParamVP9 = _VAEncSegParamVP9;
5821#[repr(C)]
5822#[derive(Copy, Clone)]
5823pub struct _VAEncMiscParameterTypeVP9PerSegmantParam {
5824 pub seg_data: [VAEncSegParamVP9; 8usize],
5825 pub va_reserved: [u32; 4usize],
5826}
5827impl Default for _VAEncMiscParameterTypeVP9PerSegmantParam {
5828 fn default() -> Self {
5829 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5830 unsafe {
5831 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5832 s.assume_init()
5833 }
5834 }
5835}
5836pub type VAEncMiscParameterTypeVP9PerSegmantParam = _VAEncMiscParameterTypeVP9PerSegmantParam;
5837#[repr(C)]
5838#[derive(Debug, Copy, Clone, PartialEq, Eq)]
5839pub struct _VAEncMiscParameterFEIFrameControlH264 {
5840 pub function: u32,
5841 pub mb_ctrl: VABufferID,
5842 pub distortion: VABufferID,
5843 pub mv_data: VABufferID,
5844 pub mb_code_data: VABufferID,
5845 pub qp: VABufferID,
5846 pub mv_predictor: VABufferID,
5847 pub _bitfield_align_1: [u16; 0],
5848 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 16usize]>,
5849 pub max_frame_size: u32,
5850 pub num_passes: u32,
5851 pub delta_qp: *mut u8,
5852 pub reserved3: [u32; 4usize],
5853}
5854impl Default for _VAEncMiscParameterFEIFrameControlH264 {
5855 fn default() -> Self {
5856 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5857 unsafe {
5858 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5859 s.assume_init()
5860 }
5861 }
5862}
5863impl _VAEncMiscParameterFEIFrameControlH264 {
5864 #[inline]
5865 pub fn num_mv_predictors_l0(&self) -> u32 {
5866 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 16u8) as u32) }
5867 }
5868 #[inline]
5869 pub fn set_num_mv_predictors_l0(&mut self, val: u32) {
5870 unsafe {
5871 let val: u32 = ::std::mem::transmute(val);
5872 self._bitfield_1.set(0usize, 16u8, val as u64)
5873 }
5874 }
5875 #[inline]
5876 pub fn num_mv_predictors_l1(&self) -> u32 {
5877 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 16u8) as u32) }
5878 }
5879 #[inline]
5880 pub fn set_num_mv_predictors_l1(&mut self, val: u32) {
5881 unsafe {
5882 let val: u32 = ::std::mem::transmute(val);
5883 self._bitfield_1.set(16usize, 16u8, val as u64)
5884 }
5885 }
5886 #[inline]
5887 pub fn search_path(&self) -> u32 {
5888 unsafe { ::std::mem::transmute(self._bitfield_1.get(32usize, 8u8) as u32) }
5889 }
5890 #[inline]
5891 pub fn set_search_path(&mut self, val: u32) {
5892 unsafe {
5893 let val: u32 = ::std::mem::transmute(val);
5894 self._bitfield_1.set(32usize, 8u8, val as u64)
5895 }
5896 }
5897 #[inline]
5898 pub fn len_sp(&self) -> u32 {
5899 unsafe { ::std::mem::transmute(self._bitfield_1.get(40usize, 8u8) as u32) }
5900 }
5901 #[inline]
5902 pub fn set_len_sp(&mut self, val: u32) {
5903 unsafe {
5904 let val: u32 = ::std::mem::transmute(val);
5905 self._bitfield_1.set(40usize, 8u8, val as u64)
5906 }
5907 }
5908 #[inline]
5909 pub fn reserved0(&self) -> u32 {
5910 unsafe { ::std::mem::transmute(self._bitfield_1.get(48usize, 16u8) as u32) }
5911 }
5912 #[inline]
5913 pub fn set_reserved0(&mut self, val: u32) {
5914 unsafe {
5915 let val: u32 = ::std::mem::transmute(val);
5916 self._bitfield_1.set(48usize, 16u8, val as u64)
5917 }
5918 }
5919 #[inline]
5920 pub fn sub_mb_part_mask(&self) -> u32 {
5921 unsafe { ::std::mem::transmute(self._bitfield_1.get(64usize, 7u8) as u32) }
5922 }
5923 #[inline]
5924 pub fn set_sub_mb_part_mask(&mut self, val: u32) {
5925 unsafe {
5926 let val: u32 = ::std::mem::transmute(val);
5927 self._bitfield_1.set(64usize, 7u8, val as u64)
5928 }
5929 }
5930 #[inline]
5931 pub fn intra_part_mask(&self) -> u32 {
5932 unsafe { ::std::mem::transmute(self._bitfield_1.get(71usize, 5u8) as u32) }
5933 }
5934 #[inline]
5935 pub fn set_intra_part_mask(&mut self, val: u32) {
5936 unsafe {
5937 let val: u32 = ::std::mem::transmute(val);
5938 self._bitfield_1.set(71usize, 5u8, val as u64)
5939 }
5940 }
5941 #[inline]
5942 pub fn multi_pred_l0(&self) -> u32 {
5943 unsafe { ::std::mem::transmute(self._bitfield_1.get(76usize, 1u8) as u32) }
5944 }
5945 #[inline]
5946 pub fn set_multi_pred_l0(&mut self, val: u32) {
5947 unsafe {
5948 let val: u32 = ::std::mem::transmute(val);
5949 self._bitfield_1.set(76usize, 1u8, val as u64)
5950 }
5951 }
5952 #[inline]
5953 pub fn multi_pred_l1(&self) -> u32 {
5954 unsafe { ::std::mem::transmute(self._bitfield_1.get(77usize, 1u8) as u32) }
5955 }
5956 #[inline]
5957 pub fn set_multi_pred_l1(&mut self, val: u32) {
5958 unsafe {
5959 let val: u32 = ::std::mem::transmute(val);
5960 self._bitfield_1.set(77usize, 1u8, val as u64)
5961 }
5962 }
5963 #[inline]
5964 pub fn sub_pel_mode(&self) -> u32 {
5965 unsafe { ::std::mem::transmute(self._bitfield_1.get(78usize, 2u8) as u32) }
5966 }
5967 #[inline]
5968 pub fn set_sub_pel_mode(&mut self, val: u32) {
5969 unsafe {
5970 let val: u32 = ::std::mem::transmute(val);
5971 self._bitfield_1.set(78usize, 2u8, val as u64)
5972 }
5973 }
5974 #[inline]
5975 pub fn inter_sad(&self) -> u32 {
5976 unsafe { ::std::mem::transmute(self._bitfield_1.get(80usize, 2u8) as u32) }
5977 }
5978 #[inline]
5979 pub fn set_inter_sad(&mut self, val: u32) {
5980 unsafe {
5981 let val: u32 = ::std::mem::transmute(val);
5982 self._bitfield_1.set(80usize, 2u8, val as u64)
5983 }
5984 }
5985 #[inline]
5986 pub fn intra_sad(&self) -> u32 {
5987 unsafe { ::std::mem::transmute(self._bitfield_1.get(82usize, 2u8) as u32) }
5988 }
5989 #[inline]
5990 pub fn set_intra_sad(&mut self, val: u32) {
5991 unsafe {
5992 let val: u32 = ::std::mem::transmute(val);
5993 self._bitfield_1.set(82usize, 2u8, val as u64)
5994 }
5995 }
5996 #[inline]
5997 pub fn distortion_type(&self) -> u32 {
5998 unsafe { ::std::mem::transmute(self._bitfield_1.get(84usize, 1u8) as u32) }
5999 }
6000 #[inline]
6001 pub fn set_distortion_type(&mut self, val: u32) {
6002 unsafe {
6003 let val: u32 = ::std::mem::transmute(val);
6004 self._bitfield_1.set(84usize, 1u8, val as u64)
6005 }
6006 }
6007 #[inline]
6008 pub fn repartition_check_enable(&self) -> u32 {
6009 unsafe { ::std::mem::transmute(self._bitfield_1.get(85usize, 1u8) as u32) }
6010 }
6011 #[inline]
6012 pub fn set_repartition_check_enable(&mut self, val: u32) {
6013 unsafe {
6014 let val: u32 = ::std::mem::transmute(val);
6015 self._bitfield_1.set(85usize, 1u8, val as u64)
6016 }
6017 }
6018 #[inline]
6019 pub fn adaptive_search(&self) -> u32 {
6020 unsafe { ::std::mem::transmute(self._bitfield_1.get(86usize, 1u8) as u32) }
6021 }
6022 #[inline]
6023 pub fn set_adaptive_search(&mut self, val: u32) {
6024 unsafe {
6025 let val: u32 = ::std::mem::transmute(val);
6026 self._bitfield_1.set(86usize, 1u8, val as u64)
6027 }
6028 }
6029 #[inline]
6030 pub fn mv_predictor_enable(&self) -> u32 {
6031 unsafe { ::std::mem::transmute(self._bitfield_1.get(87usize, 1u8) as u32) }
6032 }
6033 #[inline]
6034 pub fn set_mv_predictor_enable(&mut self, val: u32) {
6035 unsafe {
6036 let val: u32 = ::std::mem::transmute(val);
6037 self._bitfield_1.set(87usize, 1u8, val as u64)
6038 }
6039 }
6040 #[inline]
6041 pub fn mb_qp(&self) -> u32 {
6042 unsafe { ::std::mem::transmute(self._bitfield_1.get(88usize, 1u8) as u32) }
6043 }
6044 #[inline]
6045 pub fn set_mb_qp(&mut self, val: u32) {
6046 unsafe {
6047 let val: u32 = ::std::mem::transmute(val);
6048 self._bitfield_1.set(88usize, 1u8, val as u64)
6049 }
6050 }
6051 #[inline]
6052 pub fn mb_input(&self) -> u32 {
6053 unsafe { ::std::mem::transmute(self._bitfield_1.get(89usize, 1u8) as u32) }
6054 }
6055 #[inline]
6056 pub fn set_mb_input(&mut self, val: u32) {
6057 unsafe {
6058 let val: u32 = ::std::mem::transmute(val);
6059 self._bitfield_1.set(89usize, 1u8, val as u64)
6060 }
6061 }
6062 #[inline]
6063 pub fn mb_size_ctrl(&self) -> u32 {
6064 unsafe { ::std::mem::transmute(self._bitfield_1.get(90usize, 1u8) as u32) }
6065 }
6066 #[inline]
6067 pub fn set_mb_size_ctrl(&mut self, val: u32) {
6068 unsafe {
6069 let val: u32 = ::std::mem::transmute(val);
6070 self._bitfield_1.set(90usize, 1u8, val as u64)
6071 }
6072 }
6073 #[inline]
6074 pub fn colocated_mb_distortion(&self) -> u32 {
6075 unsafe { ::std::mem::transmute(self._bitfield_1.get(91usize, 1u8) as u32) }
6076 }
6077 #[inline]
6078 pub fn set_colocated_mb_distortion(&mut self, val: u32) {
6079 unsafe {
6080 let val: u32 = ::std::mem::transmute(val);
6081 self._bitfield_1.set(91usize, 1u8, val as u64)
6082 }
6083 }
6084 #[inline]
6085 pub fn reserved1(&self) -> u32 {
6086 unsafe { ::std::mem::transmute(self._bitfield_1.get(92usize, 4u8) as u32) }
6087 }
6088 #[inline]
6089 pub fn set_reserved1(&mut self, val: u32) {
6090 unsafe {
6091 let val: u32 = ::std::mem::transmute(val);
6092 self._bitfield_1.set(92usize, 4u8, val as u64)
6093 }
6094 }
6095 #[inline]
6096 pub fn ref_width(&self) -> u32 {
6097 unsafe { ::std::mem::transmute(self._bitfield_1.get(96usize, 8u8) as u32) }
6098 }
6099 #[inline]
6100 pub fn set_ref_width(&mut self, val: u32) {
6101 unsafe {
6102 let val: u32 = ::std::mem::transmute(val);
6103 self._bitfield_1.set(96usize, 8u8, val as u64)
6104 }
6105 }
6106 #[inline]
6107 pub fn ref_height(&self) -> u32 {
6108 unsafe { ::std::mem::transmute(self._bitfield_1.get(104usize, 8u8) as u32) }
6109 }
6110 #[inline]
6111 pub fn set_ref_height(&mut self, val: u32) {
6112 unsafe {
6113 let val: u32 = ::std::mem::transmute(val);
6114 self._bitfield_1.set(104usize, 8u8, val as u64)
6115 }
6116 }
6117 #[inline]
6118 pub fn search_window(&self) -> u32 {
6119 unsafe { ::std::mem::transmute(self._bitfield_1.get(112usize, 4u8) as u32) }
6120 }
6121 #[inline]
6122 pub fn set_search_window(&mut self, val: u32) {
6123 unsafe {
6124 let val: u32 = ::std::mem::transmute(val);
6125 self._bitfield_1.set(112usize, 4u8, val as u64)
6126 }
6127 }
6128 #[inline]
6129 pub fn reserved2(&self) -> u32 {
6130 unsafe { ::std::mem::transmute(self._bitfield_1.get(116usize, 12u8) as u32) }
6131 }
6132 #[inline]
6133 pub fn set_reserved2(&mut self, val: u32) {
6134 unsafe {
6135 let val: u32 = ::std::mem::transmute(val);
6136 self._bitfield_1.set(116usize, 12u8, val as u64)
6137 }
6138 }
6139 #[inline]
6140 pub fn new_bitfield_1(
6141 num_mv_predictors_l0: u32,
6142 num_mv_predictors_l1: u32,
6143 search_path: u32,
6144 len_sp: u32,
6145 reserved0: u32,
6146 sub_mb_part_mask: u32,
6147 intra_part_mask: u32,
6148 multi_pred_l0: u32,
6149 multi_pred_l1: u32,
6150 sub_pel_mode: u32,
6151 inter_sad: u32,
6152 intra_sad: u32,
6153 distortion_type: u32,
6154 repartition_check_enable: u32,
6155 adaptive_search: u32,
6156 mv_predictor_enable: u32,
6157 mb_qp: u32,
6158 mb_input: u32,
6159 mb_size_ctrl: u32,
6160 colocated_mb_distortion: u32,
6161 reserved1: u32,
6162 ref_width: u32,
6163 ref_height: u32,
6164 search_window: u32,
6165 reserved2: u32,
6166 ) -> __BindgenBitfieldUnit<[u8; 16usize]> {
6167 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 16usize]> = Default::default();
6168 __bindgen_bitfield_unit.set(0usize, 16u8, {
6169 let num_mv_predictors_l0: u32 = unsafe { ::std::mem::transmute(num_mv_predictors_l0) };
6170 num_mv_predictors_l0 as u64
6171 });
6172 __bindgen_bitfield_unit.set(16usize, 16u8, {
6173 let num_mv_predictors_l1: u32 = unsafe { ::std::mem::transmute(num_mv_predictors_l1) };
6174 num_mv_predictors_l1 as u64
6175 });
6176 __bindgen_bitfield_unit.set(32usize, 8u8, {
6177 let search_path: u32 = unsafe { ::std::mem::transmute(search_path) };
6178 search_path as u64
6179 });
6180 __bindgen_bitfield_unit.set(40usize, 8u8, {
6181 let len_sp: u32 = unsafe { ::std::mem::transmute(len_sp) };
6182 len_sp as u64
6183 });
6184 __bindgen_bitfield_unit.set(48usize, 16u8, {
6185 let reserved0: u32 = unsafe { ::std::mem::transmute(reserved0) };
6186 reserved0 as u64
6187 });
6188 __bindgen_bitfield_unit.set(64usize, 7u8, {
6189 let sub_mb_part_mask: u32 = unsafe { ::std::mem::transmute(sub_mb_part_mask) };
6190 sub_mb_part_mask as u64
6191 });
6192 __bindgen_bitfield_unit.set(71usize, 5u8, {
6193 let intra_part_mask: u32 = unsafe { ::std::mem::transmute(intra_part_mask) };
6194 intra_part_mask as u64
6195 });
6196 __bindgen_bitfield_unit.set(76usize, 1u8, {
6197 let multi_pred_l0: u32 = unsafe { ::std::mem::transmute(multi_pred_l0) };
6198 multi_pred_l0 as u64
6199 });
6200 __bindgen_bitfield_unit.set(77usize, 1u8, {
6201 let multi_pred_l1: u32 = unsafe { ::std::mem::transmute(multi_pred_l1) };
6202 multi_pred_l1 as u64
6203 });
6204 __bindgen_bitfield_unit.set(78usize, 2u8, {
6205 let sub_pel_mode: u32 = unsafe { ::std::mem::transmute(sub_pel_mode) };
6206 sub_pel_mode as u64
6207 });
6208 __bindgen_bitfield_unit.set(80usize, 2u8, {
6209 let inter_sad: u32 = unsafe { ::std::mem::transmute(inter_sad) };
6210 inter_sad as u64
6211 });
6212 __bindgen_bitfield_unit.set(82usize, 2u8, {
6213 let intra_sad: u32 = unsafe { ::std::mem::transmute(intra_sad) };
6214 intra_sad as u64
6215 });
6216 __bindgen_bitfield_unit.set(84usize, 1u8, {
6217 let distortion_type: u32 = unsafe { ::std::mem::transmute(distortion_type) };
6218 distortion_type as u64
6219 });
6220 __bindgen_bitfield_unit.set(85usize, 1u8, {
6221 let repartition_check_enable: u32 =
6222 unsafe { ::std::mem::transmute(repartition_check_enable) };
6223 repartition_check_enable as u64
6224 });
6225 __bindgen_bitfield_unit.set(86usize, 1u8, {
6226 let adaptive_search: u32 = unsafe { ::std::mem::transmute(adaptive_search) };
6227 adaptive_search as u64
6228 });
6229 __bindgen_bitfield_unit.set(87usize, 1u8, {
6230 let mv_predictor_enable: u32 = unsafe { ::std::mem::transmute(mv_predictor_enable) };
6231 mv_predictor_enable as u64
6232 });
6233 __bindgen_bitfield_unit.set(88usize, 1u8, {
6234 let mb_qp: u32 = unsafe { ::std::mem::transmute(mb_qp) };
6235 mb_qp as u64
6236 });
6237 __bindgen_bitfield_unit.set(89usize, 1u8, {
6238 let mb_input: u32 = unsafe { ::std::mem::transmute(mb_input) };
6239 mb_input as u64
6240 });
6241 __bindgen_bitfield_unit.set(90usize, 1u8, {
6242 let mb_size_ctrl: u32 = unsafe { ::std::mem::transmute(mb_size_ctrl) };
6243 mb_size_ctrl as u64
6244 });
6245 __bindgen_bitfield_unit.set(91usize, 1u8, {
6246 let colocated_mb_distortion: u32 =
6247 unsafe { ::std::mem::transmute(colocated_mb_distortion) };
6248 colocated_mb_distortion as u64
6249 });
6250 __bindgen_bitfield_unit.set(92usize, 4u8, {
6251 let reserved1: u32 = unsafe { ::std::mem::transmute(reserved1) };
6252 reserved1 as u64
6253 });
6254 __bindgen_bitfield_unit.set(96usize, 8u8, {
6255 let ref_width: u32 = unsafe { ::std::mem::transmute(ref_width) };
6256 ref_width as u64
6257 });
6258 __bindgen_bitfield_unit.set(104usize, 8u8, {
6259 let ref_height: u32 = unsafe { ::std::mem::transmute(ref_height) };
6260 ref_height as u64
6261 });
6262 __bindgen_bitfield_unit.set(112usize, 4u8, {
6263 let search_window: u32 = unsafe { ::std::mem::transmute(search_window) };
6264 search_window as u64
6265 });
6266 __bindgen_bitfield_unit.set(116usize, 12u8, {
6267 let reserved2: u32 = unsafe { ::std::mem::transmute(reserved2) };
6268 reserved2 as u64
6269 });
6270 __bindgen_bitfield_unit
6271 }
6272}
6273pub type VAEncMiscParameterFEIFrameControlH264 = _VAEncMiscParameterFEIFrameControlH264;
6274#[repr(C)]
6275#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
6276pub struct _VAEncFEIMBControlH264 {
6277 pub _bitfield_align_1: [u32; 0],
6278 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
6279 pub reserved1: u32,
6280 pub reserved2: u32,
6281 pub _bitfield_align_2: [u16; 0],
6282 pub _bitfield_2: __BindgenBitfieldUnit<[u8; 4usize]>,
6283}
6284impl _VAEncFEIMBControlH264 {
6285 #[inline]
6286 pub fn force_to_intra(&self) -> u32 {
6287 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
6288 }
6289 #[inline]
6290 pub fn set_force_to_intra(&mut self, val: u32) {
6291 unsafe {
6292 let val: u32 = ::std::mem::transmute(val);
6293 self._bitfield_1.set(0usize, 1u8, val as u64)
6294 }
6295 }
6296 #[inline]
6297 pub fn force_to_skip(&self) -> u32 {
6298 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
6299 }
6300 #[inline]
6301 pub fn set_force_to_skip(&mut self, val: u32) {
6302 unsafe {
6303 let val: u32 = ::std::mem::transmute(val);
6304 self._bitfield_1.set(1usize, 1u8, val as u64)
6305 }
6306 }
6307 #[inline]
6308 pub fn force_to_nonskip(&self) -> u32 {
6309 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
6310 }
6311 #[inline]
6312 pub fn set_force_to_nonskip(&mut self, val: u32) {
6313 unsafe {
6314 let val: u32 = ::std::mem::transmute(val);
6315 self._bitfield_1.set(2usize, 1u8, val as u64)
6316 }
6317 }
6318 #[inline]
6319 pub fn enable_direct_bias_adjustment(&self) -> u32 {
6320 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
6321 }
6322 #[inline]
6323 pub fn set_enable_direct_bias_adjustment(&mut self, val: u32) {
6324 unsafe {
6325 let val: u32 = ::std::mem::transmute(val);
6326 self._bitfield_1.set(3usize, 1u8, val as u64)
6327 }
6328 }
6329 #[inline]
6330 pub fn enable_motion_bias_adjustment(&self) -> u32 {
6331 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
6332 }
6333 #[inline]
6334 pub fn set_enable_motion_bias_adjustment(&mut self, val: u32) {
6335 unsafe {
6336 let val: u32 = ::std::mem::transmute(val);
6337 self._bitfield_1.set(4usize, 1u8, val as u64)
6338 }
6339 }
6340 #[inline]
6341 pub fn ext_mv_cost_scaling_factor(&self) -> u32 {
6342 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 3u8) as u32) }
6343 }
6344 #[inline]
6345 pub fn set_ext_mv_cost_scaling_factor(&mut self, val: u32) {
6346 unsafe {
6347 let val: u32 = ::std::mem::transmute(val);
6348 self._bitfield_1.set(5usize, 3u8, val as u64)
6349 }
6350 }
6351 #[inline]
6352 pub fn reserved0(&self) -> u32 {
6353 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 24u8) as u32) }
6354 }
6355 #[inline]
6356 pub fn set_reserved0(&mut self, val: u32) {
6357 unsafe {
6358 let val: u32 = ::std::mem::transmute(val);
6359 self._bitfield_1.set(8usize, 24u8, val as u64)
6360 }
6361 }
6362 #[inline]
6363 pub fn new_bitfield_1(
6364 force_to_intra: u32,
6365 force_to_skip: u32,
6366 force_to_nonskip: u32,
6367 enable_direct_bias_adjustment: u32,
6368 enable_motion_bias_adjustment: u32,
6369 ext_mv_cost_scaling_factor: u32,
6370 reserved0: u32,
6371 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
6372 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
6373 __bindgen_bitfield_unit.set(0usize, 1u8, {
6374 let force_to_intra: u32 = unsafe { ::std::mem::transmute(force_to_intra) };
6375 force_to_intra as u64
6376 });
6377 __bindgen_bitfield_unit.set(1usize, 1u8, {
6378 let force_to_skip: u32 = unsafe { ::std::mem::transmute(force_to_skip) };
6379 force_to_skip as u64
6380 });
6381 __bindgen_bitfield_unit.set(2usize, 1u8, {
6382 let force_to_nonskip: u32 = unsafe { ::std::mem::transmute(force_to_nonskip) };
6383 force_to_nonskip as u64
6384 });
6385 __bindgen_bitfield_unit.set(3usize, 1u8, {
6386 let enable_direct_bias_adjustment: u32 =
6387 unsafe { ::std::mem::transmute(enable_direct_bias_adjustment) };
6388 enable_direct_bias_adjustment as u64
6389 });
6390 __bindgen_bitfield_unit.set(4usize, 1u8, {
6391 let enable_motion_bias_adjustment: u32 =
6392 unsafe { ::std::mem::transmute(enable_motion_bias_adjustment) };
6393 enable_motion_bias_adjustment as u64
6394 });
6395 __bindgen_bitfield_unit.set(5usize, 3u8, {
6396 let ext_mv_cost_scaling_factor: u32 =
6397 unsafe { ::std::mem::transmute(ext_mv_cost_scaling_factor) };
6398 ext_mv_cost_scaling_factor as u64
6399 });
6400 __bindgen_bitfield_unit.set(8usize, 24u8, {
6401 let reserved0: u32 = unsafe { ::std::mem::transmute(reserved0) };
6402 reserved0 as u64
6403 });
6404 __bindgen_bitfield_unit
6405 }
6406 #[inline]
6407 pub fn reserved3(&self) -> u32 {
6408 unsafe { ::std::mem::transmute(self._bitfield_2.get(0usize, 16u8) as u32) }
6409 }
6410 #[inline]
6411 pub fn set_reserved3(&mut self, val: u32) {
6412 unsafe {
6413 let val: u32 = ::std::mem::transmute(val);
6414 self._bitfield_2.set(0usize, 16u8, val as u64)
6415 }
6416 }
6417 #[inline]
6418 pub fn target_size_in_word(&self) -> u32 {
6419 unsafe { ::std::mem::transmute(self._bitfield_2.get(16usize, 8u8) as u32) }
6420 }
6421 #[inline]
6422 pub fn set_target_size_in_word(&mut self, val: u32) {
6423 unsafe {
6424 let val: u32 = ::std::mem::transmute(val);
6425 self._bitfield_2.set(16usize, 8u8, val as u64)
6426 }
6427 }
6428 #[inline]
6429 pub fn max_size_in_word(&self) -> u32 {
6430 unsafe { ::std::mem::transmute(self._bitfield_2.get(24usize, 8u8) as u32) }
6431 }
6432 #[inline]
6433 pub fn set_max_size_in_word(&mut self, val: u32) {
6434 unsafe {
6435 let val: u32 = ::std::mem::transmute(val);
6436 self._bitfield_2.set(24usize, 8u8, val as u64)
6437 }
6438 }
6439 #[inline]
6440 pub fn new_bitfield_2(
6441 reserved3: u32,
6442 target_size_in_word: u32,
6443 max_size_in_word: u32,
6444 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
6445 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
6446 __bindgen_bitfield_unit.set(0usize, 16u8, {
6447 let reserved3: u32 = unsafe { ::std::mem::transmute(reserved3) };
6448 reserved3 as u64
6449 });
6450 __bindgen_bitfield_unit.set(16usize, 8u8, {
6451 let target_size_in_word: u32 = unsafe { ::std::mem::transmute(target_size_in_word) };
6452 target_size_in_word as u64
6453 });
6454 __bindgen_bitfield_unit.set(24usize, 8u8, {
6455 let max_size_in_word: u32 = unsafe { ::std::mem::transmute(max_size_in_word) };
6456 max_size_in_word as u64
6457 });
6458 __bindgen_bitfield_unit
6459 }
6460}
6461pub type VAEncFEIMBControlH264 = _VAEncFEIMBControlH264;
6462#[repr(C)]
6463#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
6464pub struct _VAEncFEIMVPredictorH264 {
6465 pub ref_idx: [_VAEncFEIMVPredictorH264__bindgen_ty_1; 4usize],
6466 pub reserved: u32,
6467 pub mv: [VAMotionVector; 4usize],
6468}
6469#[repr(C, packed)]
6470#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
6471pub struct _VAEncFEIMVPredictorH264__bindgen_ty_1 {
6472 pub _bitfield_align_1: [u8; 0],
6473 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
6474}
6475impl _VAEncFEIMVPredictorH264__bindgen_ty_1 {
6476 #[inline]
6477 pub fn ref_idx_l0(&self) -> u8 {
6478 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u8) }
6479 }
6480 #[inline]
6481 pub fn set_ref_idx_l0(&mut self, val: u8) {
6482 unsafe {
6483 let val: u8 = ::std::mem::transmute(val);
6484 self._bitfield_1.set(0usize, 4u8, val as u64)
6485 }
6486 }
6487 #[inline]
6488 pub fn ref_idx_l1(&self) -> u8 {
6489 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 4u8) as u8) }
6490 }
6491 #[inline]
6492 pub fn set_ref_idx_l1(&mut self, val: u8) {
6493 unsafe {
6494 let val: u8 = ::std::mem::transmute(val);
6495 self._bitfield_1.set(4usize, 4u8, val as u64)
6496 }
6497 }
6498 #[inline]
6499 pub fn new_bitfield_1(ref_idx_l0: u8, ref_idx_l1: u8) -> __BindgenBitfieldUnit<[u8; 1usize]> {
6500 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
6501 __bindgen_bitfield_unit.set(0usize, 4u8, {
6502 let ref_idx_l0: u8 = unsafe { ::std::mem::transmute(ref_idx_l0) };
6503 ref_idx_l0 as u64
6504 });
6505 __bindgen_bitfield_unit.set(4usize, 4u8, {
6506 let ref_idx_l1: u8 = unsafe { ::std::mem::transmute(ref_idx_l1) };
6507 ref_idx_l1 as u64
6508 });
6509 __bindgen_bitfield_unit
6510 }
6511}
6512pub type VAEncFEIMVPredictorH264 = _VAEncFEIMVPredictorH264;
6513#[repr(C)]
6514#[derive(Copy, Clone)]
6515pub struct _VAEncFEIMBCodeH264 {
6516 pub reserved0: [u32; 3usize],
6517 pub _bitfield_align_1: [u32; 0],
6518 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 16usize]>,
6519 pub mb_mode: _VAEncFEIMBCodeH264__bindgen_ty_1,
6520 pub _bitfield_align_2: [u16; 0],
6521 pub _bitfield_2: __BindgenBitfieldUnit<[u8; 4usize]>,
6522 pub reserved9: [u32; 4usize],
6523 pub reserved10: u32,
6524}
6525#[repr(C)]
6526#[derive(Copy, Clone)]
6527pub union _VAEncFEIMBCodeH264__bindgen_ty_1 {
6528 pub intra_mb: _VAEncFEIMBCodeH264__bindgen_ty_1__bindgen_ty_1,
6529 pub inter_mb: _VAEncFEIMBCodeH264__bindgen_ty_1__bindgen_ty_2,
6530}
6531#[repr(C)]
6532#[repr(align(4))]
6533#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
6534pub struct _VAEncFEIMBCodeH264__bindgen_ty_1__bindgen_ty_1 {
6535 pub _bitfield_align_1: [u32; 0],
6536 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 12usize]>,
6537}
6538impl _VAEncFEIMBCodeH264__bindgen_ty_1__bindgen_ty_1 {
6539 #[inline]
6540 pub fn luma_intra_pred_modes0(&self) -> u32 {
6541 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 16u8) as u32) }
6542 }
6543 #[inline]
6544 pub fn set_luma_intra_pred_modes0(&mut self, val: u32) {
6545 unsafe {
6546 let val: u32 = ::std::mem::transmute(val);
6547 self._bitfield_1.set(0usize, 16u8, val as u64)
6548 }
6549 }
6550 #[inline]
6551 pub fn luma_intra_pred_modes1(&self) -> u32 {
6552 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 16u8) as u32) }
6553 }
6554 #[inline]
6555 pub fn set_luma_intra_pred_modes1(&mut self, val: u32) {
6556 unsafe {
6557 let val: u32 = ::std::mem::transmute(val);
6558 self._bitfield_1.set(16usize, 16u8, val as u64)
6559 }
6560 }
6561 #[inline]
6562 pub fn luma_intra_pred_modes2(&self) -> u32 {
6563 unsafe { ::std::mem::transmute(self._bitfield_1.get(32usize, 16u8) as u32) }
6564 }
6565 #[inline]
6566 pub fn set_luma_intra_pred_modes2(&mut self, val: u32) {
6567 unsafe {
6568 let val: u32 = ::std::mem::transmute(val);
6569 self._bitfield_1.set(32usize, 16u8, val as u64)
6570 }
6571 }
6572 #[inline]
6573 pub fn luma_intra_pred_modes3(&self) -> u32 {
6574 unsafe { ::std::mem::transmute(self._bitfield_1.get(48usize, 16u8) as u32) }
6575 }
6576 #[inline]
6577 pub fn set_luma_intra_pred_modes3(&mut self, val: u32) {
6578 unsafe {
6579 let val: u32 = ::std::mem::transmute(val);
6580 self._bitfield_1.set(48usize, 16u8, val as u64)
6581 }
6582 }
6583 #[inline]
6584 pub fn chroma_intra_pred_mode(&self) -> u32 {
6585 unsafe { ::std::mem::transmute(self._bitfield_1.get(64usize, 2u8) as u32) }
6586 }
6587 #[inline]
6588 pub fn set_chroma_intra_pred_mode(&mut self, val: u32) {
6589 unsafe {
6590 let val: u32 = ::std::mem::transmute(val);
6591 self._bitfield_1.set(64usize, 2u8, val as u64)
6592 }
6593 }
6594 #[inline]
6595 pub fn intra_pred_avail_flag(&self) -> u32 {
6596 unsafe { ::std::mem::transmute(self._bitfield_1.get(66usize, 5u8) as u32) }
6597 }
6598 #[inline]
6599 pub fn set_intra_pred_avail_flag(&mut self, val: u32) {
6600 unsafe {
6601 let val: u32 = ::std::mem::transmute(val);
6602 self._bitfield_1.set(66usize, 5u8, val as u64)
6603 }
6604 }
6605 #[inline]
6606 pub fn intra_pred_avail_flagF(&self) -> u32 {
6607 unsafe { ::std::mem::transmute(self._bitfield_1.get(71usize, 1u8) as u32) }
6608 }
6609 #[inline]
6610 pub fn set_intra_pred_avail_flagF(&mut self, val: u32) {
6611 unsafe {
6612 let val: u32 = ::std::mem::transmute(val);
6613 self._bitfield_1.set(71usize, 1u8, val as u64)
6614 }
6615 }
6616 #[inline]
6617 pub fn reserved6(&self) -> u32 {
6618 unsafe { ::std::mem::transmute(self._bitfield_1.get(72usize, 24u8) as u32) }
6619 }
6620 #[inline]
6621 pub fn set_reserved6(&mut self, val: u32) {
6622 unsafe {
6623 let val: u32 = ::std::mem::transmute(val);
6624 self._bitfield_1.set(72usize, 24u8, val as u64)
6625 }
6626 }
6627 #[inline]
6628 pub fn new_bitfield_1(
6629 luma_intra_pred_modes0: u32,
6630 luma_intra_pred_modes1: u32,
6631 luma_intra_pred_modes2: u32,
6632 luma_intra_pred_modes3: u32,
6633 chroma_intra_pred_mode: u32,
6634 intra_pred_avail_flag: u32,
6635 intra_pred_avail_flagF: u32,
6636 reserved6: u32,
6637 ) -> __BindgenBitfieldUnit<[u8; 12usize]> {
6638 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 12usize]> = Default::default();
6639 __bindgen_bitfield_unit.set(0usize, 16u8, {
6640 let luma_intra_pred_modes0: u32 =
6641 unsafe { ::std::mem::transmute(luma_intra_pred_modes0) };
6642 luma_intra_pred_modes0 as u64
6643 });
6644 __bindgen_bitfield_unit.set(16usize, 16u8, {
6645 let luma_intra_pred_modes1: u32 =
6646 unsafe { ::std::mem::transmute(luma_intra_pred_modes1) };
6647 luma_intra_pred_modes1 as u64
6648 });
6649 __bindgen_bitfield_unit.set(32usize, 16u8, {
6650 let luma_intra_pred_modes2: u32 =
6651 unsafe { ::std::mem::transmute(luma_intra_pred_modes2) };
6652 luma_intra_pred_modes2 as u64
6653 });
6654 __bindgen_bitfield_unit.set(48usize, 16u8, {
6655 let luma_intra_pred_modes3: u32 =
6656 unsafe { ::std::mem::transmute(luma_intra_pred_modes3) };
6657 luma_intra_pred_modes3 as u64
6658 });
6659 __bindgen_bitfield_unit.set(64usize, 2u8, {
6660 let chroma_intra_pred_mode: u32 =
6661 unsafe { ::std::mem::transmute(chroma_intra_pred_mode) };
6662 chroma_intra_pred_mode as u64
6663 });
6664 __bindgen_bitfield_unit.set(66usize, 5u8, {
6665 let intra_pred_avail_flag: u32 =
6666 unsafe { ::std::mem::transmute(intra_pred_avail_flag) };
6667 intra_pred_avail_flag as u64
6668 });
6669 __bindgen_bitfield_unit.set(71usize, 1u8, {
6670 let intra_pred_avail_flagF: u32 =
6671 unsafe { ::std::mem::transmute(intra_pred_avail_flagF) };
6672 intra_pred_avail_flagF as u64
6673 });
6674 __bindgen_bitfield_unit.set(72usize, 24u8, {
6675 let reserved6: u32 = unsafe { ::std::mem::transmute(reserved6) };
6676 reserved6 as u64
6677 });
6678 __bindgen_bitfield_unit
6679 }
6680}
6681#[repr(C)]
6682#[repr(align(4))]
6683#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
6684pub struct _VAEncFEIMBCodeH264__bindgen_ty_1__bindgen_ty_2 {
6685 pub _bitfield_align_1: [u16; 0],
6686 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 12usize]>,
6687}
6688impl _VAEncFEIMBCodeH264__bindgen_ty_1__bindgen_ty_2 {
6689 #[inline]
6690 pub fn sub_mb_shapes(&self) -> u32 {
6691 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 8u8) as u32) }
6692 }
6693 #[inline]
6694 pub fn set_sub_mb_shapes(&mut self, val: u32) {
6695 unsafe {
6696 let val: u32 = ::std::mem::transmute(val);
6697 self._bitfield_1.set(0usize, 8u8, val as u64)
6698 }
6699 }
6700 #[inline]
6701 pub fn sub_mb_pred_modes(&self) -> u32 {
6702 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 8u8) as u32) }
6703 }
6704 #[inline]
6705 pub fn set_sub_mb_pred_modes(&mut self, val: u32) {
6706 unsafe {
6707 let val: u32 = ::std::mem::transmute(val);
6708 self._bitfield_1.set(8usize, 8u8, val as u64)
6709 }
6710 }
6711 #[inline]
6712 pub fn reserved7(&self) -> u32 {
6713 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 16u8) as u32) }
6714 }
6715 #[inline]
6716 pub fn set_reserved7(&mut self, val: u32) {
6717 unsafe {
6718 let val: u32 = ::std::mem::transmute(val);
6719 self._bitfield_1.set(16usize, 16u8, val as u64)
6720 }
6721 }
6722 #[inline]
6723 pub fn ref_idx_l0_0(&self) -> u32 {
6724 unsafe { ::std::mem::transmute(self._bitfield_1.get(32usize, 8u8) as u32) }
6725 }
6726 #[inline]
6727 pub fn set_ref_idx_l0_0(&mut self, val: u32) {
6728 unsafe {
6729 let val: u32 = ::std::mem::transmute(val);
6730 self._bitfield_1.set(32usize, 8u8, val as u64)
6731 }
6732 }
6733 #[inline]
6734 pub fn ref_idx_l0_1(&self) -> u32 {
6735 unsafe { ::std::mem::transmute(self._bitfield_1.get(40usize, 8u8) as u32) }
6736 }
6737 #[inline]
6738 pub fn set_ref_idx_l0_1(&mut self, val: u32) {
6739 unsafe {
6740 let val: u32 = ::std::mem::transmute(val);
6741 self._bitfield_1.set(40usize, 8u8, val as u64)
6742 }
6743 }
6744 #[inline]
6745 pub fn ref_idx_l0_2(&self) -> u32 {
6746 unsafe { ::std::mem::transmute(self._bitfield_1.get(48usize, 8u8) as u32) }
6747 }
6748 #[inline]
6749 pub fn set_ref_idx_l0_2(&mut self, val: u32) {
6750 unsafe {
6751 let val: u32 = ::std::mem::transmute(val);
6752 self._bitfield_1.set(48usize, 8u8, val as u64)
6753 }
6754 }
6755 #[inline]
6756 pub fn ref_idx_l0_3(&self) -> u32 {
6757 unsafe { ::std::mem::transmute(self._bitfield_1.get(56usize, 8u8) as u32) }
6758 }
6759 #[inline]
6760 pub fn set_ref_idx_l0_3(&mut self, val: u32) {
6761 unsafe {
6762 let val: u32 = ::std::mem::transmute(val);
6763 self._bitfield_1.set(56usize, 8u8, val as u64)
6764 }
6765 }
6766 #[inline]
6767 pub fn ref_idx_l1_0(&self) -> u32 {
6768 unsafe { ::std::mem::transmute(self._bitfield_1.get(64usize, 8u8) as u32) }
6769 }
6770 #[inline]
6771 pub fn set_ref_idx_l1_0(&mut self, val: u32) {
6772 unsafe {
6773 let val: u32 = ::std::mem::transmute(val);
6774 self._bitfield_1.set(64usize, 8u8, val as u64)
6775 }
6776 }
6777 #[inline]
6778 pub fn ref_idx_l1_1(&self) -> u32 {
6779 unsafe { ::std::mem::transmute(self._bitfield_1.get(72usize, 8u8) as u32) }
6780 }
6781 #[inline]
6782 pub fn set_ref_idx_l1_1(&mut self, val: u32) {
6783 unsafe {
6784 let val: u32 = ::std::mem::transmute(val);
6785 self._bitfield_1.set(72usize, 8u8, val as u64)
6786 }
6787 }
6788 #[inline]
6789 pub fn ref_idx_l1_2(&self) -> u32 {
6790 unsafe { ::std::mem::transmute(self._bitfield_1.get(80usize, 8u8) as u32) }
6791 }
6792 #[inline]
6793 pub fn set_ref_idx_l1_2(&mut self, val: u32) {
6794 unsafe {
6795 let val: u32 = ::std::mem::transmute(val);
6796 self._bitfield_1.set(80usize, 8u8, val as u64)
6797 }
6798 }
6799 #[inline]
6800 pub fn ref_idx_l1_3(&self) -> u32 {
6801 unsafe { ::std::mem::transmute(self._bitfield_1.get(88usize, 8u8) as u32) }
6802 }
6803 #[inline]
6804 pub fn set_ref_idx_l1_3(&mut self, val: u32) {
6805 unsafe {
6806 let val: u32 = ::std::mem::transmute(val);
6807 self._bitfield_1.set(88usize, 8u8, val as u64)
6808 }
6809 }
6810 #[inline]
6811 pub fn new_bitfield_1(
6812 sub_mb_shapes: u32,
6813 sub_mb_pred_modes: u32,
6814 reserved7: u32,
6815 ref_idx_l0_0: u32,
6816 ref_idx_l0_1: u32,
6817 ref_idx_l0_2: u32,
6818 ref_idx_l0_3: u32,
6819 ref_idx_l1_0: u32,
6820 ref_idx_l1_1: u32,
6821 ref_idx_l1_2: u32,
6822 ref_idx_l1_3: u32,
6823 ) -> __BindgenBitfieldUnit<[u8; 12usize]> {
6824 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 12usize]> = Default::default();
6825 __bindgen_bitfield_unit.set(0usize, 8u8, {
6826 let sub_mb_shapes: u32 = unsafe { ::std::mem::transmute(sub_mb_shapes) };
6827 sub_mb_shapes as u64
6828 });
6829 __bindgen_bitfield_unit.set(8usize, 8u8, {
6830 let sub_mb_pred_modes: u32 = unsafe { ::std::mem::transmute(sub_mb_pred_modes) };
6831 sub_mb_pred_modes as u64
6832 });
6833 __bindgen_bitfield_unit.set(16usize, 16u8, {
6834 let reserved7: u32 = unsafe { ::std::mem::transmute(reserved7) };
6835 reserved7 as u64
6836 });
6837 __bindgen_bitfield_unit.set(32usize, 8u8, {
6838 let ref_idx_l0_0: u32 = unsafe { ::std::mem::transmute(ref_idx_l0_0) };
6839 ref_idx_l0_0 as u64
6840 });
6841 __bindgen_bitfield_unit.set(40usize, 8u8, {
6842 let ref_idx_l0_1: u32 = unsafe { ::std::mem::transmute(ref_idx_l0_1) };
6843 ref_idx_l0_1 as u64
6844 });
6845 __bindgen_bitfield_unit.set(48usize, 8u8, {
6846 let ref_idx_l0_2: u32 = unsafe { ::std::mem::transmute(ref_idx_l0_2) };
6847 ref_idx_l0_2 as u64
6848 });
6849 __bindgen_bitfield_unit.set(56usize, 8u8, {
6850 let ref_idx_l0_3: u32 = unsafe { ::std::mem::transmute(ref_idx_l0_3) };
6851 ref_idx_l0_3 as u64
6852 });
6853 __bindgen_bitfield_unit.set(64usize, 8u8, {
6854 let ref_idx_l1_0: u32 = unsafe { ::std::mem::transmute(ref_idx_l1_0) };
6855 ref_idx_l1_0 as u64
6856 });
6857 __bindgen_bitfield_unit.set(72usize, 8u8, {
6858 let ref_idx_l1_1: u32 = unsafe { ::std::mem::transmute(ref_idx_l1_1) };
6859 ref_idx_l1_1 as u64
6860 });
6861 __bindgen_bitfield_unit.set(80usize, 8u8, {
6862 let ref_idx_l1_2: u32 = unsafe { ::std::mem::transmute(ref_idx_l1_2) };
6863 ref_idx_l1_2 as u64
6864 });
6865 __bindgen_bitfield_unit.set(88usize, 8u8, {
6866 let ref_idx_l1_3: u32 = unsafe { ::std::mem::transmute(ref_idx_l1_3) };
6867 ref_idx_l1_3 as u64
6868 });
6869 __bindgen_bitfield_unit
6870 }
6871}
6872impl Default for _VAEncFEIMBCodeH264__bindgen_ty_1 {
6873 fn default() -> Self {
6874 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6875 unsafe {
6876 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6877 s.assume_init()
6878 }
6879 }
6880}
6881impl Default for _VAEncFEIMBCodeH264 {
6882 fn default() -> Self {
6883 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6884 unsafe {
6885 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6886 s.assume_init()
6887 }
6888 }
6889}
6890impl _VAEncFEIMBCodeH264 {
6891 #[inline]
6892 pub fn inter_mb_mode(&self) -> u32 {
6893 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u32) }
6894 }
6895 #[inline]
6896 pub fn set_inter_mb_mode(&mut self, val: u32) {
6897 unsafe {
6898 let val: u32 = ::std::mem::transmute(val);
6899 self._bitfield_1.set(0usize, 2u8, val as u64)
6900 }
6901 }
6902 #[inline]
6903 pub fn mb_skip_flag(&self) -> u32 {
6904 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
6905 }
6906 #[inline]
6907 pub fn set_mb_skip_flag(&mut self, val: u32) {
6908 unsafe {
6909 let val: u32 = ::std::mem::transmute(val);
6910 self._bitfield_1.set(2usize, 1u8, val as u64)
6911 }
6912 }
6913 #[inline]
6914 pub fn reserved1(&self) -> u32 {
6915 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
6916 }
6917 #[inline]
6918 pub fn set_reserved1(&mut self, val: u32) {
6919 unsafe {
6920 let val: u32 = ::std::mem::transmute(val);
6921 self._bitfield_1.set(3usize, 1u8, val as u64)
6922 }
6923 }
6924 #[inline]
6925 pub fn intra_mb_mode(&self) -> u32 {
6926 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 2u8) as u32) }
6927 }
6928 #[inline]
6929 pub fn set_intra_mb_mode(&mut self, val: u32) {
6930 unsafe {
6931 let val: u32 = ::std::mem::transmute(val);
6932 self._bitfield_1.set(4usize, 2u8, val as u64)
6933 }
6934 }
6935 #[inline]
6936 pub fn reserved2(&self) -> u32 {
6937 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) }
6938 }
6939 #[inline]
6940 pub fn set_reserved2(&mut self, val: u32) {
6941 unsafe {
6942 let val: u32 = ::std::mem::transmute(val);
6943 self._bitfield_1.set(6usize, 1u8, val as u64)
6944 }
6945 }
6946 #[inline]
6947 pub fn field_mb_polarity_flag(&self) -> u32 {
6948 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) }
6949 }
6950 #[inline]
6951 pub fn set_field_mb_polarity_flag(&mut self, val: u32) {
6952 unsafe {
6953 let val: u32 = ::std::mem::transmute(val);
6954 self._bitfield_1.set(7usize, 1u8, val as u64)
6955 }
6956 }
6957 #[inline]
6958 pub fn mb_type(&self) -> u32 {
6959 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 5u8) as u32) }
6960 }
6961 #[inline]
6962 pub fn set_mb_type(&mut self, val: u32) {
6963 unsafe {
6964 let val: u32 = ::std::mem::transmute(val);
6965 self._bitfield_1.set(8usize, 5u8, val as u64)
6966 }
6967 }
6968 #[inline]
6969 pub fn intra_mb_flag(&self) -> u32 {
6970 unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) }
6971 }
6972 #[inline]
6973 pub fn set_intra_mb_flag(&mut self, val: u32) {
6974 unsafe {
6975 let val: u32 = ::std::mem::transmute(val);
6976 self._bitfield_1.set(13usize, 1u8, val as u64)
6977 }
6978 }
6979 #[inline]
6980 pub fn field_mb_flag(&self) -> u32 {
6981 unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) }
6982 }
6983 #[inline]
6984 pub fn set_field_mb_flag(&mut self, val: u32) {
6985 unsafe {
6986 let val: u32 = ::std::mem::transmute(val);
6987 self._bitfield_1.set(14usize, 1u8, val as u64)
6988 }
6989 }
6990 #[inline]
6991 pub fn transform8x8_flag(&self) -> u32 {
6992 unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u32) }
6993 }
6994 #[inline]
6995 pub fn set_transform8x8_flag(&mut self, val: u32) {
6996 unsafe {
6997 let val: u32 = ::std::mem::transmute(val);
6998 self._bitfield_1.set(15usize, 1u8, val as u64)
6999 }
7000 }
7001 #[inline]
7002 pub fn reserved3(&self) -> u32 {
7003 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u32) }
7004 }
7005 #[inline]
7006 pub fn set_reserved3(&mut self, val: u32) {
7007 unsafe {
7008 let val: u32 = ::std::mem::transmute(val);
7009 self._bitfield_1.set(16usize, 1u8, val as u64)
7010 }
7011 }
7012 #[inline]
7013 pub fn dc_block_coded_cr_flag(&self) -> u32 {
7014 unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 1u8) as u32) }
7015 }
7016 #[inline]
7017 pub fn set_dc_block_coded_cr_flag(&mut self, val: u32) {
7018 unsafe {
7019 let val: u32 = ::std::mem::transmute(val);
7020 self._bitfield_1.set(17usize, 1u8, val as u64)
7021 }
7022 }
7023 #[inline]
7024 pub fn dc_block_coded_cb_flag(&self) -> u32 {
7025 unsafe { ::std::mem::transmute(self._bitfield_1.get(18usize, 1u8) as u32) }
7026 }
7027 #[inline]
7028 pub fn set_dc_block_coded_cb_flag(&mut self, val: u32) {
7029 unsafe {
7030 let val: u32 = ::std::mem::transmute(val);
7031 self._bitfield_1.set(18usize, 1u8, val as u64)
7032 }
7033 }
7034 #[inline]
7035 pub fn dc_block_coded_y_flag(&self) -> u32 {
7036 unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 1u8) as u32) }
7037 }
7038 #[inline]
7039 pub fn set_dc_block_coded_y_flag(&mut self, val: u32) {
7040 unsafe {
7041 let val: u32 = ::std::mem::transmute(val);
7042 self._bitfield_1.set(19usize, 1u8, val as u64)
7043 }
7044 }
7045 #[inline]
7046 pub fn reserved4(&self) -> u32 {
7047 unsafe { ::std::mem::transmute(self._bitfield_1.get(20usize, 12u8) as u32) }
7048 }
7049 #[inline]
7050 pub fn set_reserved4(&mut self, val: u32) {
7051 unsafe {
7052 let val: u32 = ::std::mem::transmute(val);
7053 self._bitfield_1.set(20usize, 12u8, val as u64)
7054 }
7055 }
7056 #[inline]
7057 pub fn horz_origin(&self) -> u32 {
7058 unsafe { ::std::mem::transmute(self._bitfield_1.get(32usize, 8u8) as u32) }
7059 }
7060 #[inline]
7061 pub fn set_horz_origin(&mut self, val: u32) {
7062 unsafe {
7063 let val: u32 = ::std::mem::transmute(val);
7064 self._bitfield_1.set(32usize, 8u8, val as u64)
7065 }
7066 }
7067 #[inline]
7068 pub fn vert_origin(&self) -> u32 {
7069 unsafe { ::std::mem::transmute(self._bitfield_1.get(40usize, 8u8) as u32) }
7070 }
7071 #[inline]
7072 pub fn set_vert_origin(&mut self, val: u32) {
7073 unsafe {
7074 let val: u32 = ::std::mem::transmute(val);
7075 self._bitfield_1.set(40usize, 8u8, val as u64)
7076 }
7077 }
7078 #[inline]
7079 pub fn cbp_y(&self) -> u32 {
7080 unsafe { ::std::mem::transmute(self._bitfield_1.get(48usize, 16u8) as u32) }
7081 }
7082 #[inline]
7083 pub fn set_cbp_y(&mut self, val: u32) {
7084 unsafe {
7085 let val: u32 = ::std::mem::transmute(val);
7086 self._bitfield_1.set(48usize, 16u8, val as u64)
7087 }
7088 }
7089 #[inline]
7090 pub fn cbp_cb(&self) -> u32 {
7091 unsafe { ::std::mem::transmute(self._bitfield_1.get(64usize, 16u8) as u32) }
7092 }
7093 #[inline]
7094 pub fn set_cbp_cb(&mut self, val: u32) {
7095 unsafe {
7096 let val: u32 = ::std::mem::transmute(val);
7097 self._bitfield_1.set(64usize, 16u8, val as u64)
7098 }
7099 }
7100 #[inline]
7101 pub fn cbp_cr(&self) -> u32 {
7102 unsafe { ::std::mem::transmute(self._bitfield_1.get(80usize, 16u8) as u32) }
7103 }
7104 #[inline]
7105 pub fn set_cbp_cr(&mut self, val: u32) {
7106 unsafe {
7107 let val: u32 = ::std::mem::transmute(val);
7108 self._bitfield_1.set(80usize, 16u8, val as u64)
7109 }
7110 }
7111 #[inline]
7112 pub fn qp_prime_y(&self) -> u32 {
7113 unsafe { ::std::mem::transmute(self._bitfield_1.get(96usize, 8u8) as u32) }
7114 }
7115 #[inline]
7116 pub fn set_qp_prime_y(&mut self, val: u32) {
7117 unsafe {
7118 let val: u32 = ::std::mem::transmute(val);
7119 self._bitfield_1.set(96usize, 8u8, val as u64)
7120 }
7121 }
7122 #[inline]
7123 pub fn reserved5(&self) -> u32 {
7124 unsafe { ::std::mem::transmute(self._bitfield_1.get(104usize, 17u8) as u32) }
7125 }
7126 #[inline]
7127 pub fn set_reserved5(&mut self, val: u32) {
7128 unsafe {
7129 let val: u32 = ::std::mem::transmute(val);
7130 self._bitfield_1.set(104usize, 17u8, val as u64)
7131 }
7132 }
7133 #[inline]
7134 pub fn mb_skip_conv_disable(&self) -> u32 {
7135 unsafe { ::std::mem::transmute(self._bitfield_1.get(121usize, 1u8) as u32) }
7136 }
7137 #[inline]
7138 pub fn set_mb_skip_conv_disable(&mut self, val: u32) {
7139 unsafe {
7140 let val: u32 = ::std::mem::transmute(val);
7141 self._bitfield_1.set(121usize, 1u8, val as u64)
7142 }
7143 }
7144 #[inline]
7145 pub fn is_last_mb(&self) -> u32 {
7146 unsafe { ::std::mem::transmute(self._bitfield_1.get(122usize, 1u8) as u32) }
7147 }
7148 #[inline]
7149 pub fn set_is_last_mb(&mut self, val: u32) {
7150 unsafe {
7151 let val: u32 = ::std::mem::transmute(val);
7152 self._bitfield_1.set(122usize, 1u8, val as u64)
7153 }
7154 }
7155 #[inline]
7156 pub fn enable_coefficient_clamp(&self) -> u32 {
7157 unsafe { ::std::mem::transmute(self._bitfield_1.get(123usize, 1u8) as u32) }
7158 }
7159 #[inline]
7160 pub fn set_enable_coefficient_clamp(&mut self, val: u32) {
7161 unsafe {
7162 let val: u32 = ::std::mem::transmute(val);
7163 self._bitfield_1.set(123usize, 1u8, val as u64)
7164 }
7165 }
7166 #[inline]
7167 pub fn direct8x8_pattern(&self) -> u32 {
7168 unsafe { ::std::mem::transmute(self._bitfield_1.get(124usize, 4u8) as u32) }
7169 }
7170 #[inline]
7171 pub fn set_direct8x8_pattern(&mut self, val: u32) {
7172 unsafe {
7173 let val: u32 = ::std::mem::transmute(val);
7174 self._bitfield_1.set(124usize, 4u8, val as u64)
7175 }
7176 }
7177 #[inline]
7178 pub fn new_bitfield_1(
7179 inter_mb_mode: u32,
7180 mb_skip_flag: u32,
7181 reserved1: u32,
7182 intra_mb_mode: u32,
7183 reserved2: u32,
7184 field_mb_polarity_flag: u32,
7185 mb_type: u32,
7186 intra_mb_flag: u32,
7187 field_mb_flag: u32,
7188 transform8x8_flag: u32,
7189 reserved3: u32,
7190 dc_block_coded_cr_flag: u32,
7191 dc_block_coded_cb_flag: u32,
7192 dc_block_coded_y_flag: u32,
7193 reserved4: u32,
7194 horz_origin: u32,
7195 vert_origin: u32,
7196 cbp_y: u32,
7197 cbp_cb: u32,
7198 cbp_cr: u32,
7199 qp_prime_y: u32,
7200 reserved5: u32,
7201 mb_skip_conv_disable: u32,
7202 is_last_mb: u32,
7203 enable_coefficient_clamp: u32,
7204 direct8x8_pattern: u32,
7205 ) -> __BindgenBitfieldUnit<[u8; 16usize]> {
7206 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 16usize]> = Default::default();
7207 __bindgen_bitfield_unit.set(0usize, 2u8, {
7208 let inter_mb_mode: u32 = unsafe { ::std::mem::transmute(inter_mb_mode) };
7209 inter_mb_mode as u64
7210 });
7211 __bindgen_bitfield_unit.set(2usize, 1u8, {
7212 let mb_skip_flag: u32 = unsafe { ::std::mem::transmute(mb_skip_flag) };
7213 mb_skip_flag as u64
7214 });
7215 __bindgen_bitfield_unit.set(3usize, 1u8, {
7216 let reserved1: u32 = unsafe { ::std::mem::transmute(reserved1) };
7217 reserved1 as u64
7218 });
7219 __bindgen_bitfield_unit.set(4usize, 2u8, {
7220 let intra_mb_mode: u32 = unsafe { ::std::mem::transmute(intra_mb_mode) };
7221 intra_mb_mode as u64
7222 });
7223 __bindgen_bitfield_unit.set(6usize, 1u8, {
7224 let reserved2: u32 = unsafe { ::std::mem::transmute(reserved2) };
7225 reserved2 as u64
7226 });
7227 __bindgen_bitfield_unit.set(7usize, 1u8, {
7228 let field_mb_polarity_flag: u32 =
7229 unsafe { ::std::mem::transmute(field_mb_polarity_flag) };
7230 field_mb_polarity_flag as u64
7231 });
7232 __bindgen_bitfield_unit.set(8usize, 5u8, {
7233 let mb_type: u32 = unsafe { ::std::mem::transmute(mb_type) };
7234 mb_type as u64
7235 });
7236 __bindgen_bitfield_unit.set(13usize, 1u8, {
7237 let intra_mb_flag: u32 = unsafe { ::std::mem::transmute(intra_mb_flag) };
7238 intra_mb_flag as u64
7239 });
7240 __bindgen_bitfield_unit.set(14usize, 1u8, {
7241 let field_mb_flag: u32 = unsafe { ::std::mem::transmute(field_mb_flag) };
7242 field_mb_flag as u64
7243 });
7244 __bindgen_bitfield_unit.set(15usize, 1u8, {
7245 let transform8x8_flag: u32 = unsafe { ::std::mem::transmute(transform8x8_flag) };
7246 transform8x8_flag as u64
7247 });
7248 __bindgen_bitfield_unit.set(16usize, 1u8, {
7249 let reserved3: u32 = unsafe { ::std::mem::transmute(reserved3) };
7250 reserved3 as u64
7251 });
7252 __bindgen_bitfield_unit.set(17usize, 1u8, {
7253 let dc_block_coded_cr_flag: u32 =
7254 unsafe { ::std::mem::transmute(dc_block_coded_cr_flag) };
7255 dc_block_coded_cr_flag as u64
7256 });
7257 __bindgen_bitfield_unit.set(18usize, 1u8, {
7258 let dc_block_coded_cb_flag: u32 =
7259 unsafe { ::std::mem::transmute(dc_block_coded_cb_flag) };
7260 dc_block_coded_cb_flag as u64
7261 });
7262 __bindgen_bitfield_unit.set(19usize, 1u8, {
7263 let dc_block_coded_y_flag: u32 =
7264 unsafe { ::std::mem::transmute(dc_block_coded_y_flag) };
7265 dc_block_coded_y_flag as u64
7266 });
7267 __bindgen_bitfield_unit.set(20usize, 12u8, {
7268 let reserved4: u32 = unsafe { ::std::mem::transmute(reserved4) };
7269 reserved4 as u64
7270 });
7271 __bindgen_bitfield_unit.set(32usize, 8u8, {
7272 let horz_origin: u32 = unsafe { ::std::mem::transmute(horz_origin) };
7273 horz_origin as u64
7274 });
7275 __bindgen_bitfield_unit.set(40usize, 8u8, {
7276 let vert_origin: u32 = unsafe { ::std::mem::transmute(vert_origin) };
7277 vert_origin as u64
7278 });
7279 __bindgen_bitfield_unit.set(48usize, 16u8, {
7280 let cbp_y: u32 = unsafe { ::std::mem::transmute(cbp_y) };
7281 cbp_y as u64
7282 });
7283 __bindgen_bitfield_unit.set(64usize, 16u8, {
7284 let cbp_cb: u32 = unsafe { ::std::mem::transmute(cbp_cb) };
7285 cbp_cb as u64
7286 });
7287 __bindgen_bitfield_unit.set(80usize, 16u8, {
7288 let cbp_cr: u32 = unsafe { ::std::mem::transmute(cbp_cr) };
7289 cbp_cr as u64
7290 });
7291 __bindgen_bitfield_unit.set(96usize, 8u8, {
7292 let qp_prime_y: u32 = unsafe { ::std::mem::transmute(qp_prime_y) };
7293 qp_prime_y as u64
7294 });
7295 __bindgen_bitfield_unit.set(104usize, 17u8, {
7296 let reserved5: u32 = unsafe { ::std::mem::transmute(reserved5) };
7297 reserved5 as u64
7298 });
7299 __bindgen_bitfield_unit.set(121usize, 1u8, {
7300 let mb_skip_conv_disable: u32 = unsafe { ::std::mem::transmute(mb_skip_conv_disable) };
7301 mb_skip_conv_disable as u64
7302 });
7303 __bindgen_bitfield_unit.set(122usize, 1u8, {
7304 let is_last_mb: u32 = unsafe { ::std::mem::transmute(is_last_mb) };
7305 is_last_mb as u64
7306 });
7307 __bindgen_bitfield_unit.set(123usize, 1u8, {
7308 let enable_coefficient_clamp: u32 =
7309 unsafe { ::std::mem::transmute(enable_coefficient_clamp) };
7310 enable_coefficient_clamp as u64
7311 });
7312 __bindgen_bitfield_unit.set(124usize, 4u8, {
7313 let direct8x8_pattern: u32 = unsafe { ::std::mem::transmute(direct8x8_pattern) };
7314 direct8x8_pattern as u64
7315 });
7316 __bindgen_bitfield_unit
7317 }
7318 #[inline]
7319 pub fn reserved8(&self) -> u32 {
7320 unsafe { ::std::mem::transmute(self._bitfield_2.get(0usize, 16u8) as u32) }
7321 }
7322 #[inline]
7323 pub fn set_reserved8(&mut self, val: u32) {
7324 unsafe {
7325 let val: u32 = ::std::mem::transmute(val);
7326 self._bitfield_2.set(0usize, 16u8, val as u64)
7327 }
7328 }
7329 #[inline]
7330 pub fn target_size_in_word(&self) -> u32 {
7331 unsafe { ::std::mem::transmute(self._bitfield_2.get(16usize, 8u8) as u32) }
7332 }
7333 #[inline]
7334 pub fn set_target_size_in_word(&mut self, val: u32) {
7335 unsafe {
7336 let val: u32 = ::std::mem::transmute(val);
7337 self._bitfield_2.set(16usize, 8u8, val as u64)
7338 }
7339 }
7340 #[inline]
7341 pub fn max_size_in_word(&self) -> u32 {
7342 unsafe { ::std::mem::transmute(self._bitfield_2.get(24usize, 8u8) as u32) }
7343 }
7344 #[inline]
7345 pub fn set_max_size_in_word(&mut self, val: u32) {
7346 unsafe {
7347 let val: u32 = ::std::mem::transmute(val);
7348 self._bitfield_2.set(24usize, 8u8, val as u64)
7349 }
7350 }
7351 #[inline]
7352 pub fn new_bitfield_2(
7353 reserved8: u32,
7354 target_size_in_word: u32,
7355 max_size_in_word: u32,
7356 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
7357 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
7358 __bindgen_bitfield_unit.set(0usize, 16u8, {
7359 let reserved8: u32 = unsafe { ::std::mem::transmute(reserved8) };
7360 reserved8 as u64
7361 });
7362 __bindgen_bitfield_unit.set(16usize, 8u8, {
7363 let target_size_in_word: u32 = unsafe { ::std::mem::transmute(target_size_in_word) };
7364 target_size_in_word as u64
7365 });
7366 __bindgen_bitfield_unit.set(24usize, 8u8, {
7367 let max_size_in_word: u32 = unsafe { ::std::mem::transmute(max_size_in_word) };
7368 max_size_in_word as u64
7369 });
7370 __bindgen_bitfield_unit
7371 }
7372}
7373pub type VAEncFEIMBCodeH264 = _VAEncFEIMBCodeH264;
7374#[repr(C)]
7375#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
7376pub struct _VAEncFEIDistortionH264 {
7377 pub inter_distortion: [u16; 16usize],
7378 pub _bitfield_align_1: [u16; 0],
7379 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
7380 pub reserved1: [u32; 2usize],
7381}
7382impl _VAEncFEIDistortionH264 {
7383 #[inline]
7384 pub fn best_inter_distortion(&self) -> u32 {
7385 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 16u8) as u32) }
7386 }
7387 #[inline]
7388 pub fn set_best_inter_distortion(&mut self, val: u32) {
7389 unsafe {
7390 let val: u32 = ::std::mem::transmute(val);
7391 self._bitfield_1.set(0usize, 16u8, val as u64)
7392 }
7393 }
7394 #[inline]
7395 pub fn best_intra_distortion(&self) -> u32 {
7396 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 16u8) as u32) }
7397 }
7398 #[inline]
7399 pub fn set_best_intra_distortion(&mut self, val: u32) {
7400 unsafe {
7401 let val: u32 = ::std::mem::transmute(val);
7402 self._bitfield_1.set(16usize, 16u8, val as u64)
7403 }
7404 }
7405 #[inline]
7406 pub fn colocated_mb_distortion(&self) -> u32 {
7407 unsafe { ::std::mem::transmute(self._bitfield_1.get(32usize, 16u8) as u32) }
7408 }
7409 #[inline]
7410 pub fn set_colocated_mb_distortion(&mut self, val: u32) {
7411 unsafe {
7412 let val: u32 = ::std::mem::transmute(val);
7413 self._bitfield_1.set(32usize, 16u8, val as u64)
7414 }
7415 }
7416 #[inline]
7417 pub fn reserved0(&self) -> u32 {
7418 unsafe { ::std::mem::transmute(self._bitfield_1.get(48usize, 16u8) as u32) }
7419 }
7420 #[inline]
7421 pub fn set_reserved0(&mut self, val: u32) {
7422 unsafe {
7423 let val: u32 = ::std::mem::transmute(val);
7424 self._bitfield_1.set(48usize, 16u8, val as u64)
7425 }
7426 }
7427 #[inline]
7428 pub fn new_bitfield_1(
7429 best_inter_distortion: u32,
7430 best_intra_distortion: u32,
7431 colocated_mb_distortion: u32,
7432 reserved0: u32,
7433 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
7434 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
7435 __bindgen_bitfield_unit.set(0usize, 16u8, {
7436 let best_inter_distortion: u32 =
7437 unsafe { ::std::mem::transmute(best_inter_distortion) };
7438 best_inter_distortion as u64
7439 });
7440 __bindgen_bitfield_unit.set(16usize, 16u8, {
7441 let best_intra_distortion: u32 =
7442 unsafe { ::std::mem::transmute(best_intra_distortion) };
7443 best_intra_distortion as u64
7444 });
7445 __bindgen_bitfield_unit.set(32usize, 16u8, {
7446 let colocated_mb_distortion: u32 =
7447 unsafe { ::std::mem::transmute(colocated_mb_distortion) };
7448 colocated_mb_distortion as u64
7449 });
7450 __bindgen_bitfield_unit.set(48usize, 16u8, {
7451 let reserved0: u32 = unsafe { ::std::mem::transmute(reserved0) };
7452 reserved0 as u64
7453 });
7454 __bindgen_bitfield_unit
7455 }
7456}
7457pub type VAEncFEIDistortionH264 = _VAEncFEIDistortionH264;
7458#[repr(C)]
7459#[derive(Debug, Copy, Clone, PartialEq, Eq)]
7460pub struct _VAStatsStatisticsParameterH264 {
7461 pub stats_params: VAStatsStatisticsParameter,
7462 pub _bitfield_align_1: [u32; 0],
7463 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 16usize]>,
7464 pub reserved4: [u32; 2usize],
7465}
7466impl Default for _VAStatsStatisticsParameterH264 {
7467 fn default() -> Self {
7468 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7469 unsafe {
7470 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7471 s.assume_init()
7472 }
7473 }
7474}
7475impl _VAStatsStatisticsParameterH264 {
7476 #[inline]
7477 pub fn frame_qp(&self) -> u32 {
7478 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 8u8) as u32) }
7479 }
7480 #[inline]
7481 pub fn set_frame_qp(&mut self, val: u32) {
7482 unsafe {
7483 let val: u32 = ::std::mem::transmute(val);
7484 self._bitfield_1.set(0usize, 8u8, val as u64)
7485 }
7486 }
7487 #[inline]
7488 pub fn len_sp(&self) -> u32 {
7489 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 8u8) as u32) }
7490 }
7491 #[inline]
7492 pub fn set_len_sp(&mut self, val: u32) {
7493 unsafe {
7494 let val: u32 = ::std::mem::transmute(val);
7495 self._bitfield_1.set(8usize, 8u8, val as u64)
7496 }
7497 }
7498 #[inline]
7499 pub fn search_path(&self) -> u32 {
7500 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 8u8) as u32) }
7501 }
7502 #[inline]
7503 pub fn set_search_path(&mut self, val: u32) {
7504 unsafe {
7505 let val: u32 = ::std::mem::transmute(val);
7506 self._bitfield_1.set(16usize, 8u8, val as u64)
7507 }
7508 }
7509 #[inline]
7510 pub fn reserved0(&self) -> u32 {
7511 unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 8u8) as u32) }
7512 }
7513 #[inline]
7514 pub fn set_reserved0(&mut self, val: u32) {
7515 unsafe {
7516 let val: u32 = ::std::mem::transmute(val);
7517 self._bitfield_1.set(24usize, 8u8, val as u64)
7518 }
7519 }
7520 #[inline]
7521 pub fn sub_mb_part_mask(&self) -> u32 {
7522 unsafe { ::std::mem::transmute(self._bitfield_1.get(32usize, 7u8) as u32) }
7523 }
7524 #[inline]
7525 pub fn set_sub_mb_part_mask(&mut self, val: u32) {
7526 unsafe {
7527 let val: u32 = ::std::mem::transmute(val);
7528 self._bitfield_1.set(32usize, 7u8, val as u64)
7529 }
7530 }
7531 #[inline]
7532 pub fn sub_pel_mode(&self) -> u32 {
7533 unsafe { ::std::mem::transmute(self._bitfield_1.get(39usize, 2u8) as u32) }
7534 }
7535 #[inline]
7536 pub fn set_sub_pel_mode(&mut self, val: u32) {
7537 unsafe {
7538 let val: u32 = ::std::mem::transmute(val);
7539 self._bitfield_1.set(39usize, 2u8, val as u64)
7540 }
7541 }
7542 #[inline]
7543 pub fn inter_sad(&self) -> u32 {
7544 unsafe { ::std::mem::transmute(self._bitfield_1.get(41usize, 2u8) as u32) }
7545 }
7546 #[inline]
7547 pub fn set_inter_sad(&mut self, val: u32) {
7548 unsafe {
7549 let val: u32 = ::std::mem::transmute(val);
7550 self._bitfield_1.set(41usize, 2u8, val as u64)
7551 }
7552 }
7553 #[inline]
7554 pub fn intra_sad(&self) -> u32 {
7555 unsafe { ::std::mem::transmute(self._bitfield_1.get(43usize, 2u8) as u32) }
7556 }
7557 #[inline]
7558 pub fn set_intra_sad(&mut self, val: u32) {
7559 unsafe {
7560 let val: u32 = ::std::mem::transmute(val);
7561 self._bitfield_1.set(43usize, 2u8, val as u64)
7562 }
7563 }
7564 #[inline]
7565 pub fn adaptive_search(&self) -> u32 {
7566 unsafe { ::std::mem::transmute(self._bitfield_1.get(45usize, 1u8) as u32) }
7567 }
7568 #[inline]
7569 pub fn set_adaptive_search(&mut self, val: u32) {
7570 unsafe {
7571 let val: u32 = ::std::mem::transmute(val);
7572 self._bitfield_1.set(45usize, 1u8, val as u64)
7573 }
7574 }
7575 #[inline]
7576 pub fn mv_predictor_ctrl(&self) -> u32 {
7577 unsafe { ::std::mem::transmute(self._bitfield_1.get(46usize, 3u8) as u32) }
7578 }
7579 #[inline]
7580 pub fn set_mv_predictor_ctrl(&mut self, val: u32) {
7581 unsafe {
7582 let val: u32 = ::std::mem::transmute(val);
7583 self._bitfield_1.set(46usize, 3u8, val as u64)
7584 }
7585 }
7586 #[inline]
7587 pub fn mb_qp(&self) -> u32 {
7588 unsafe { ::std::mem::transmute(self._bitfield_1.get(49usize, 1u8) as u32) }
7589 }
7590 #[inline]
7591 pub fn set_mb_qp(&mut self, val: u32) {
7592 unsafe {
7593 let val: u32 = ::std::mem::transmute(val);
7594 self._bitfield_1.set(49usize, 1u8, val as u64)
7595 }
7596 }
7597 #[inline]
7598 pub fn ft_enable(&self) -> u32 {
7599 unsafe { ::std::mem::transmute(self._bitfield_1.get(50usize, 1u8) as u32) }
7600 }
7601 #[inline]
7602 pub fn set_ft_enable(&mut self, val: u32) {
7603 unsafe {
7604 let val: u32 = ::std::mem::transmute(val);
7605 self._bitfield_1.set(50usize, 1u8, val as u64)
7606 }
7607 }
7608 #[inline]
7609 pub fn intra_part_mask(&self) -> u32 {
7610 unsafe { ::std::mem::transmute(self._bitfield_1.get(51usize, 5u8) as u32) }
7611 }
7612 #[inline]
7613 pub fn set_intra_part_mask(&mut self, val: u32) {
7614 unsafe {
7615 let val: u32 = ::std::mem::transmute(val);
7616 self._bitfield_1.set(51usize, 5u8, val as u64)
7617 }
7618 }
7619 #[inline]
7620 pub fn reserved1(&self) -> u32 {
7621 unsafe { ::std::mem::transmute(self._bitfield_1.get(56usize, 8u8) as u32) }
7622 }
7623 #[inline]
7624 pub fn set_reserved1(&mut self, val: u32) {
7625 unsafe {
7626 let val: u32 = ::std::mem::transmute(val);
7627 self._bitfield_1.set(56usize, 8u8, val as u64)
7628 }
7629 }
7630 #[inline]
7631 pub fn ref_width(&self) -> u32 {
7632 unsafe { ::std::mem::transmute(self._bitfield_1.get(64usize, 8u8) as u32) }
7633 }
7634 #[inline]
7635 pub fn set_ref_width(&mut self, val: u32) {
7636 unsafe {
7637 let val: u32 = ::std::mem::transmute(val);
7638 self._bitfield_1.set(64usize, 8u8, val as u64)
7639 }
7640 }
7641 #[inline]
7642 pub fn ref_height(&self) -> u32 {
7643 unsafe { ::std::mem::transmute(self._bitfield_1.get(72usize, 8u8) as u32) }
7644 }
7645 #[inline]
7646 pub fn set_ref_height(&mut self, val: u32) {
7647 unsafe {
7648 let val: u32 = ::std::mem::transmute(val);
7649 self._bitfield_1.set(72usize, 8u8, val as u64)
7650 }
7651 }
7652 #[inline]
7653 pub fn search_window(&self) -> u32 {
7654 unsafe { ::std::mem::transmute(self._bitfield_1.get(80usize, 4u8) as u32) }
7655 }
7656 #[inline]
7657 pub fn set_search_window(&mut self, val: u32) {
7658 unsafe {
7659 let val: u32 = ::std::mem::transmute(val);
7660 self._bitfield_1.set(80usize, 4u8, val as u64)
7661 }
7662 }
7663 #[inline]
7664 pub fn reserved2(&self) -> u32 {
7665 unsafe { ::std::mem::transmute(self._bitfield_1.get(84usize, 12u8) as u32) }
7666 }
7667 #[inline]
7668 pub fn set_reserved2(&mut self, val: u32) {
7669 unsafe {
7670 let val: u32 = ::std::mem::transmute(val);
7671 self._bitfield_1.set(84usize, 12u8, val as u64)
7672 }
7673 }
7674 #[inline]
7675 pub fn disable_mv_output(&self) -> u32 {
7676 unsafe { ::std::mem::transmute(self._bitfield_1.get(96usize, 1u8) as u32) }
7677 }
7678 #[inline]
7679 pub fn set_disable_mv_output(&mut self, val: u32) {
7680 unsafe {
7681 let val: u32 = ::std::mem::transmute(val);
7682 self._bitfield_1.set(96usize, 1u8, val as u64)
7683 }
7684 }
7685 #[inline]
7686 pub fn disable_statistics_output(&self) -> u32 {
7687 unsafe { ::std::mem::transmute(self._bitfield_1.get(97usize, 1u8) as u32) }
7688 }
7689 #[inline]
7690 pub fn set_disable_statistics_output(&mut self, val: u32) {
7691 unsafe {
7692 let val: u32 = ::std::mem::transmute(val);
7693 self._bitfield_1.set(97usize, 1u8, val as u64)
7694 }
7695 }
7696 #[inline]
7697 pub fn enable_8x8_statistics(&self) -> u32 {
7698 unsafe { ::std::mem::transmute(self._bitfield_1.get(98usize, 1u8) as u32) }
7699 }
7700 #[inline]
7701 pub fn set_enable_8x8_statistics(&mut self, val: u32) {
7702 unsafe {
7703 let val: u32 = ::std::mem::transmute(val);
7704 self._bitfield_1.set(98usize, 1u8, val as u64)
7705 }
7706 }
7707 #[inline]
7708 pub fn reserved3(&self) -> u32 {
7709 unsafe { ::std::mem::transmute(self._bitfield_1.get(99usize, 29u8) as u32) }
7710 }
7711 #[inline]
7712 pub fn set_reserved3(&mut self, val: u32) {
7713 unsafe {
7714 let val: u32 = ::std::mem::transmute(val);
7715 self._bitfield_1.set(99usize, 29u8, val as u64)
7716 }
7717 }
7718 #[inline]
7719 pub fn new_bitfield_1(
7720 frame_qp: u32,
7721 len_sp: u32,
7722 search_path: u32,
7723 reserved0: u32,
7724 sub_mb_part_mask: u32,
7725 sub_pel_mode: u32,
7726 inter_sad: u32,
7727 intra_sad: u32,
7728 adaptive_search: u32,
7729 mv_predictor_ctrl: u32,
7730 mb_qp: u32,
7731 ft_enable: u32,
7732 intra_part_mask: u32,
7733 reserved1: u32,
7734 ref_width: u32,
7735 ref_height: u32,
7736 search_window: u32,
7737 reserved2: u32,
7738 disable_mv_output: u32,
7739 disable_statistics_output: u32,
7740 enable_8x8_statistics: u32,
7741 reserved3: u32,
7742 ) -> __BindgenBitfieldUnit<[u8; 16usize]> {
7743 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 16usize]> = Default::default();
7744 __bindgen_bitfield_unit.set(0usize, 8u8, {
7745 let frame_qp: u32 = unsafe { ::std::mem::transmute(frame_qp) };
7746 frame_qp as u64
7747 });
7748 __bindgen_bitfield_unit.set(8usize, 8u8, {
7749 let len_sp: u32 = unsafe { ::std::mem::transmute(len_sp) };
7750 len_sp as u64
7751 });
7752 __bindgen_bitfield_unit.set(16usize, 8u8, {
7753 let search_path: u32 = unsafe { ::std::mem::transmute(search_path) };
7754 search_path as u64
7755 });
7756 __bindgen_bitfield_unit.set(24usize, 8u8, {
7757 let reserved0: u32 = unsafe { ::std::mem::transmute(reserved0) };
7758 reserved0 as u64
7759 });
7760 __bindgen_bitfield_unit.set(32usize, 7u8, {
7761 let sub_mb_part_mask: u32 = unsafe { ::std::mem::transmute(sub_mb_part_mask) };
7762 sub_mb_part_mask as u64
7763 });
7764 __bindgen_bitfield_unit.set(39usize, 2u8, {
7765 let sub_pel_mode: u32 = unsafe { ::std::mem::transmute(sub_pel_mode) };
7766 sub_pel_mode as u64
7767 });
7768 __bindgen_bitfield_unit.set(41usize, 2u8, {
7769 let inter_sad: u32 = unsafe { ::std::mem::transmute(inter_sad) };
7770 inter_sad as u64
7771 });
7772 __bindgen_bitfield_unit.set(43usize, 2u8, {
7773 let intra_sad: u32 = unsafe { ::std::mem::transmute(intra_sad) };
7774 intra_sad as u64
7775 });
7776 __bindgen_bitfield_unit.set(45usize, 1u8, {
7777 let adaptive_search: u32 = unsafe { ::std::mem::transmute(adaptive_search) };
7778 adaptive_search as u64
7779 });
7780 __bindgen_bitfield_unit.set(46usize, 3u8, {
7781 let mv_predictor_ctrl: u32 = unsafe { ::std::mem::transmute(mv_predictor_ctrl) };
7782 mv_predictor_ctrl as u64
7783 });
7784 __bindgen_bitfield_unit.set(49usize, 1u8, {
7785 let mb_qp: u32 = unsafe { ::std::mem::transmute(mb_qp) };
7786 mb_qp as u64
7787 });
7788 __bindgen_bitfield_unit.set(50usize, 1u8, {
7789 let ft_enable: u32 = unsafe { ::std::mem::transmute(ft_enable) };
7790 ft_enable as u64
7791 });
7792 __bindgen_bitfield_unit.set(51usize, 5u8, {
7793 let intra_part_mask: u32 = unsafe { ::std::mem::transmute(intra_part_mask) };
7794 intra_part_mask as u64
7795 });
7796 __bindgen_bitfield_unit.set(56usize, 8u8, {
7797 let reserved1: u32 = unsafe { ::std::mem::transmute(reserved1) };
7798 reserved1 as u64
7799 });
7800 __bindgen_bitfield_unit.set(64usize, 8u8, {
7801 let ref_width: u32 = unsafe { ::std::mem::transmute(ref_width) };
7802 ref_width as u64
7803 });
7804 __bindgen_bitfield_unit.set(72usize, 8u8, {
7805 let ref_height: u32 = unsafe { ::std::mem::transmute(ref_height) };
7806 ref_height as u64
7807 });
7808 __bindgen_bitfield_unit.set(80usize, 4u8, {
7809 let search_window: u32 = unsafe { ::std::mem::transmute(search_window) };
7810 search_window as u64
7811 });
7812 __bindgen_bitfield_unit.set(84usize, 12u8, {
7813 let reserved2: u32 = unsafe { ::std::mem::transmute(reserved2) };
7814 reserved2 as u64
7815 });
7816 __bindgen_bitfield_unit.set(96usize, 1u8, {
7817 let disable_mv_output: u32 = unsafe { ::std::mem::transmute(disable_mv_output) };
7818 disable_mv_output as u64
7819 });
7820 __bindgen_bitfield_unit.set(97usize, 1u8, {
7821 let disable_statistics_output: u32 =
7822 unsafe { ::std::mem::transmute(disable_statistics_output) };
7823 disable_statistics_output as u64
7824 });
7825 __bindgen_bitfield_unit.set(98usize, 1u8, {
7826 let enable_8x8_statistics: u32 =
7827 unsafe { ::std::mem::transmute(enable_8x8_statistics) };
7828 enable_8x8_statistics as u64
7829 });
7830 __bindgen_bitfield_unit.set(99usize, 29u8, {
7831 let reserved3: u32 = unsafe { ::std::mem::transmute(reserved3) };
7832 reserved3 as u64
7833 });
7834 __bindgen_bitfield_unit
7835 }
7836}
7837pub type VAStatsStatisticsParameterH264 = _VAStatsStatisticsParameterH264;
7838#[repr(C)]
7839#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
7840pub struct _VAStatsStatisticsH264 {
7841 pub _bitfield_align_1: [u16; 0],
7842 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 16usize]>,
7843 pub sum_coef: u32,
7844 pub _bitfield_align_2: [u32; 0],
7845 pub _bitfield_2: __BindgenBitfieldUnit<[u8; 4usize]>,
7846 pub variance_16x16: u32,
7847 pub variance_8x8: [u32; 4usize],
7848 pub pixel_average_16x16: u32,
7849 pub pixel_average_8x8: [u32; 4usize],
7850}
7851impl _VAStatsStatisticsH264 {
7852 #[inline]
7853 pub fn best_inter_distortion0(&self) -> u32 {
7854 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 16u8) as u32) }
7855 }
7856 #[inline]
7857 pub fn set_best_inter_distortion0(&mut self, val: u32) {
7858 unsafe {
7859 let val: u32 = ::std::mem::transmute(val);
7860 self._bitfield_1.set(0usize, 16u8, val as u64)
7861 }
7862 }
7863 #[inline]
7864 pub fn inter_mode0(&self) -> u32 {
7865 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 16u8) as u32) }
7866 }
7867 #[inline]
7868 pub fn set_inter_mode0(&mut self, val: u32) {
7869 unsafe {
7870 let val: u32 = ::std::mem::transmute(val);
7871 self._bitfield_1.set(16usize, 16u8, val as u64)
7872 }
7873 }
7874 #[inline]
7875 pub fn best_inter_distortion1(&self) -> u32 {
7876 unsafe { ::std::mem::transmute(self._bitfield_1.get(32usize, 16u8) as u32) }
7877 }
7878 #[inline]
7879 pub fn set_best_inter_distortion1(&mut self, val: u32) {
7880 unsafe {
7881 let val: u32 = ::std::mem::transmute(val);
7882 self._bitfield_1.set(32usize, 16u8, val as u64)
7883 }
7884 }
7885 #[inline]
7886 pub fn inter_mode1(&self) -> u32 {
7887 unsafe { ::std::mem::transmute(self._bitfield_1.get(48usize, 16u8) as u32) }
7888 }
7889 #[inline]
7890 pub fn set_inter_mode1(&mut self, val: u32) {
7891 unsafe {
7892 let val: u32 = ::std::mem::transmute(val);
7893 self._bitfield_1.set(48usize, 16u8, val as u64)
7894 }
7895 }
7896 #[inline]
7897 pub fn best_intra_distortion(&self) -> u32 {
7898 unsafe { ::std::mem::transmute(self._bitfield_1.get(64usize, 16u8) as u32) }
7899 }
7900 #[inline]
7901 pub fn set_best_intra_distortion(&mut self, val: u32) {
7902 unsafe {
7903 let val: u32 = ::std::mem::transmute(val);
7904 self._bitfield_1.set(64usize, 16u8, val as u64)
7905 }
7906 }
7907 #[inline]
7908 pub fn intra_mode(&self) -> u32 {
7909 unsafe { ::std::mem::transmute(self._bitfield_1.get(80usize, 16u8) as u32) }
7910 }
7911 #[inline]
7912 pub fn set_intra_mode(&mut self, val: u32) {
7913 unsafe {
7914 let val: u32 = ::std::mem::transmute(val);
7915 self._bitfield_1.set(80usize, 16u8, val as u64)
7916 }
7917 }
7918 #[inline]
7919 pub fn num_non_zero_coef(&self) -> u32 {
7920 unsafe { ::std::mem::transmute(self._bitfield_1.get(96usize, 16u8) as u32) }
7921 }
7922 #[inline]
7923 pub fn set_num_non_zero_coef(&mut self, val: u32) {
7924 unsafe {
7925 let val: u32 = ::std::mem::transmute(val);
7926 self._bitfield_1.set(96usize, 16u8, val as u64)
7927 }
7928 }
7929 #[inline]
7930 pub fn reserved0(&self) -> u32 {
7931 unsafe { ::std::mem::transmute(self._bitfield_1.get(112usize, 16u8) as u32) }
7932 }
7933 #[inline]
7934 pub fn set_reserved0(&mut self, val: u32) {
7935 unsafe {
7936 let val: u32 = ::std::mem::transmute(val);
7937 self._bitfield_1.set(112usize, 16u8, val as u64)
7938 }
7939 }
7940 #[inline]
7941 pub fn new_bitfield_1(
7942 best_inter_distortion0: u32,
7943 inter_mode0: u32,
7944 best_inter_distortion1: u32,
7945 inter_mode1: u32,
7946 best_intra_distortion: u32,
7947 intra_mode: u32,
7948 num_non_zero_coef: u32,
7949 reserved0: u32,
7950 ) -> __BindgenBitfieldUnit<[u8; 16usize]> {
7951 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 16usize]> = Default::default();
7952 __bindgen_bitfield_unit.set(0usize, 16u8, {
7953 let best_inter_distortion0: u32 =
7954 unsafe { ::std::mem::transmute(best_inter_distortion0) };
7955 best_inter_distortion0 as u64
7956 });
7957 __bindgen_bitfield_unit.set(16usize, 16u8, {
7958 let inter_mode0: u32 = unsafe { ::std::mem::transmute(inter_mode0) };
7959 inter_mode0 as u64
7960 });
7961 __bindgen_bitfield_unit.set(32usize, 16u8, {
7962 let best_inter_distortion1: u32 =
7963 unsafe { ::std::mem::transmute(best_inter_distortion1) };
7964 best_inter_distortion1 as u64
7965 });
7966 __bindgen_bitfield_unit.set(48usize, 16u8, {
7967 let inter_mode1: u32 = unsafe { ::std::mem::transmute(inter_mode1) };
7968 inter_mode1 as u64
7969 });
7970 __bindgen_bitfield_unit.set(64usize, 16u8, {
7971 let best_intra_distortion: u32 =
7972 unsafe { ::std::mem::transmute(best_intra_distortion) };
7973 best_intra_distortion as u64
7974 });
7975 __bindgen_bitfield_unit.set(80usize, 16u8, {
7976 let intra_mode: u32 = unsafe { ::std::mem::transmute(intra_mode) };
7977 intra_mode as u64
7978 });
7979 __bindgen_bitfield_unit.set(96usize, 16u8, {
7980 let num_non_zero_coef: u32 = unsafe { ::std::mem::transmute(num_non_zero_coef) };
7981 num_non_zero_coef as u64
7982 });
7983 __bindgen_bitfield_unit.set(112usize, 16u8, {
7984 let reserved0: u32 = unsafe { ::std::mem::transmute(reserved0) };
7985 reserved0 as u64
7986 });
7987 __bindgen_bitfield_unit
7988 }
7989 #[inline]
7990 pub fn mb_is_flat(&self) -> u32 {
7991 unsafe { ::std::mem::transmute(self._bitfield_2.get(0usize, 1u8) as u32) }
7992 }
7993 #[inline]
7994 pub fn set_mb_is_flat(&mut self, val: u32) {
7995 unsafe {
7996 let val: u32 = ::std::mem::transmute(val);
7997 self._bitfield_2.set(0usize, 1u8, val as u64)
7998 }
7999 }
8000 #[inline]
8001 pub fn reserved1(&self) -> u32 {
8002 unsafe { ::std::mem::transmute(self._bitfield_2.get(1usize, 31u8) as u32) }
8003 }
8004 #[inline]
8005 pub fn set_reserved1(&mut self, val: u32) {
8006 unsafe {
8007 let val: u32 = ::std::mem::transmute(val);
8008 self._bitfield_2.set(1usize, 31u8, val as u64)
8009 }
8010 }
8011 #[inline]
8012 pub fn new_bitfield_2(mb_is_flat: u32, reserved1: u32) -> __BindgenBitfieldUnit<[u8; 4usize]> {
8013 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
8014 __bindgen_bitfield_unit.set(0usize, 1u8, {
8015 let mb_is_flat: u32 = unsafe { ::std::mem::transmute(mb_is_flat) };
8016 mb_is_flat as u64
8017 });
8018 __bindgen_bitfield_unit.set(1usize, 31u8, {
8019 let reserved1: u32 = unsafe { ::std::mem::transmute(reserved1) };
8020 reserved1 as u64
8021 });
8022 __bindgen_bitfield_unit
8023 }
8024}
8025pub type VAStatsStatisticsH264 = _VAStatsStatisticsH264;
8026pub const _VAProcFilterType_VAProcFilterNone: _VAProcFilterType = 0;
8027pub const _VAProcFilterType_VAProcFilterNoiseReduction: _VAProcFilterType = 1;
8028pub const _VAProcFilterType_VAProcFilterDeinterlacing: _VAProcFilterType = 2;
8029pub const _VAProcFilterType_VAProcFilterSharpening: _VAProcFilterType = 3;
8030pub const _VAProcFilterType_VAProcFilterColorBalance: _VAProcFilterType = 4;
8031pub const _VAProcFilterType_VAProcFilterSkinToneEnhancement: _VAProcFilterType = 5;
8032pub const _VAProcFilterType_VAProcFilterTotalColorCorrection: _VAProcFilterType = 6;
8033pub const _VAProcFilterType_VAProcFilterHVSNoiseReduction: _VAProcFilterType = 7;
8034pub const _VAProcFilterType_VAProcFilterHighDynamicRangeToneMapping: _VAProcFilterType = 8;
8035pub const _VAProcFilterType_VAProcFilter3DLUT: _VAProcFilterType = 9;
8036pub const _VAProcFilterType_VAProcFilterCount: _VAProcFilterType = 10;
8037pub type _VAProcFilterType = ::std::os::raw::c_uint;
8038pub use self::_VAProcFilterType as VAProcFilterType;
8039pub const _VAProcColorStandardType_VAProcColorStandardNone: _VAProcColorStandardType = 0;
8040pub const _VAProcColorStandardType_VAProcColorStandardBT601: _VAProcColorStandardType = 1;
8041pub const _VAProcColorStandardType_VAProcColorStandardBT709: _VAProcColorStandardType = 2;
8042pub const _VAProcColorStandardType_VAProcColorStandardBT470M: _VAProcColorStandardType = 3;
8043pub const _VAProcColorStandardType_VAProcColorStandardBT470BG: _VAProcColorStandardType = 4;
8044pub const _VAProcColorStandardType_VAProcColorStandardSMPTE170M: _VAProcColorStandardType = 5;
8045pub const _VAProcColorStandardType_VAProcColorStandardSMPTE240M: _VAProcColorStandardType = 6;
8046pub const _VAProcColorStandardType_VAProcColorStandardGenericFilm: _VAProcColorStandardType = 7;
8047pub const _VAProcColorStandardType_VAProcColorStandardSRGB: _VAProcColorStandardType = 8;
8048pub const _VAProcColorStandardType_VAProcColorStandardSTRGB: _VAProcColorStandardType = 9;
8049pub const _VAProcColorStandardType_VAProcColorStandardXVYCC601: _VAProcColorStandardType = 10;
8050pub const _VAProcColorStandardType_VAProcColorStandardXVYCC709: _VAProcColorStandardType = 11;
8051pub const _VAProcColorStandardType_VAProcColorStandardBT2020: _VAProcColorStandardType = 12;
8052pub const _VAProcColorStandardType_VAProcColorStandardExplicit: _VAProcColorStandardType = 13;
8053pub const _VAProcColorStandardType_VAProcColorStandardCount: _VAProcColorStandardType = 14;
8054pub type _VAProcColorStandardType = ::std::os::raw::c_uint;
8055pub use self::_VAProcColorStandardType as VAProcColorStandardType;
8056#[repr(C)]
8057#[derive(Debug, Copy, Clone, PartialEq, Eq)]
8058pub struct _VAProcPipelineCaps {
8059 pub pipeline_flags: u32,
8060 pub filter_flags: u32,
8061 pub num_forward_references: u32,
8062 pub num_backward_references: u32,
8063 pub input_color_standards: *mut VAProcColorStandardType,
8064 pub num_input_color_standards: u32,
8065 pub output_color_standards: *mut VAProcColorStandardType,
8066 pub num_output_color_standards: u32,
8067 pub rotation_flags: u32,
8068 pub blend_flags: u32,
8069 pub mirror_flags: u32,
8070 pub num_additional_outputs: u32,
8071 pub num_input_pixel_formats: u32,
8072 pub input_pixel_format: *mut u32,
8073 pub num_output_pixel_formats: u32,
8074 pub output_pixel_format: *mut u32,
8075 pub max_input_width: u32,
8076 pub max_input_height: u32,
8077 pub min_input_width: u32,
8078 pub min_input_height: u32,
8079 pub max_output_width: u32,
8080 pub max_output_height: u32,
8081 pub min_output_width: u32,
8082 pub min_output_height: u32,
8083 pub va_reserved: [u32; 14usize],
8084}
8085impl Default for _VAProcPipelineCaps {
8086 fn default() -> Self {
8087 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
8088 unsafe {
8089 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
8090 s.assume_init()
8091 }
8092 }
8093}
8094pub type VAProcPipelineCaps = _VAProcPipelineCaps;
8095extern "C" {
8096 pub fn vaQueryVideoProcFilters(
8097 dpy: VADisplay,
8098 context: VAContextID,
8099 filters: *mut VAProcFilterType,
8100 num_filters: *mut ::std::os::raw::c_uint,
8101 ) -> VAStatus;
8102}
8103extern "C" {
8104 pub fn vaQueryVideoProcFilterCaps(
8105 dpy: VADisplay,
8106 context: VAContextID,
8107 type_: VAProcFilterType,
8108 filter_caps: *mut ::std::os::raw::c_void,
8109 num_filter_caps: *mut ::std::os::raw::c_uint,
8110 ) -> VAStatus;
8111}
8112extern "C" {
8113 pub fn vaQueryVideoProcPipelineCaps(
8114 dpy: VADisplay,
8115 context: VAContextID,
8116 filters: *mut VABufferID,
8117 num_filters: ::std::os::raw::c_uint,
8118 pipeline_caps: *mut VAProcPipelineCaps,
8119 ) -> VAStatus;
8120}
8121pub type VAProtectedSessionID = VAGenericID;
8122extern "C" {
8123 pub fn vaCreateProtectedSession(
8124 dpy: VADisplay,
8125 config_id: VAConfigID,
8126 protected_session: *mut VAProtectedSessionID,
8127 ) -> VAStatus;
8128}
8129extern "C" {
8130 pub fn vaDestroyProtectedSession(
8131 dpy: VADisplay,
8132 protected_session: VAProtectedSessionID,
8133 ) -> VAStatus;
8134}
8135extern "C" {
8136 pub fn vaAttachProtectedSession(
8137 dpy: VADisplay,
8138 id: VAGenericID,
8139 protected_session: VAProtectedSessionID,
8140 ) -> VAStatus;
8141}
8142extern "C" {
8143 pub fn vaDetachProtectedSession(dpy: VADisplay, id: VAGenericID) -> VAStatus;
8144}
8145extern "C" {
8146 pub fn vaProtectedSessionExecute(
8147 dpy: VADisplay,
8148 protected_session: VAProtectedSessionID,
8149 buf_id: VABufferID,
8150 ) -> VAStatus;
8151}
8152extern "C" {
8153 pub fn vaGetDisplayDRM(fd: ::std::os::raw::c_int) -> VADisplay;
8154}
extremely simple tool to test decoding functionality of NihAV