projects / nihav-player.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
nihed-cros-libva: make VAImage export VAFourcc for convenience
[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}
2b4c8e97
KS		 1628
1629impl VAImageFormat {
1630 pub fn fourcc(&self) -> crate::status::VAResult<crate::formats::VAFourcc> {
1631 self.fourcc.try_into().map_err(|_| crate::status::VAError::InvalidImage)
1632 }
1633}
1634
68362724
KS		 1635pub type VAImageID = VAGenericID;
1636#[repr(C)]
1637#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
8006218d 1638pub struct VAImage {
68362724
KS		 1639 pub image_id: VAImageID,
1640 pub format: VAImageFormat,
1641 pub buf: VABufferID,
1642 pub width: u16,
1643 pub height: u16,
1644 pub data_size: u32,
1645 pub num_planes: u32,
1646 pub pitches: [u32; 3usize],
1647 pub offsets: [u32; 3usize],
1648 pub num_palette_entries: i32,
1649 pub entry_bytes: i32,
1650 pub component_order: [i8; 4usize],
1651 pub va_reserved: [u32; 4usize],
1652}
68362724
KS		 1653extern "C" {
1654 pub fn vaMaxNumImageFormats(dpy: VADisplay) -> ::std::os::raw::c_int;
1655}
1656extern "C" {
1657 pub fn vaQueryImageFormats(
1658 dpy: VADisplay,
1659 format_list: *mut VAImageFormat,
1660 num_formats: *mut ::std::os::raw::c_int,
1661 ) -> VAStatus;
1662}
1663extern "C" {
1664 pub fn vaCreateImage(
1665 dpy: VADisplay,
1666 format: *mut VAImageFormat,
1667 width: ::std::os::raw::c_int,
1668 height: ::std::os::raw::c_int,
1669 image: *mut VAImage,
1670 ) -> VAStatus;
1671}
1672extern "C" {
1673 pub fn vaDestroyImage(dpy: VADisplay, image: VAImageID) -> VAStatus;
1674}
1675extern "C" {
1676 pub fn vaSetImagePalette(
1677 dpy: VADisplay,
1678 image: VAImageID,
1679 palette: *mut ::std::os::raw::c_uchar,
1680 ) -> VAStatus;
1681}
1682extern "C" {
1683 pub fn vaGetImage(
1684 dpy: VADisplay,
1685 surface: VASurfaceID,
1686 x: ::std::os::raw::c_int,
1687 y: ::std::os::raw::c_int,
1688 width: ::std::os::raw::c_uint,
1689 height: ::std::os::raw::c_uint,
1690 image: VAImageID,
1691 ) -> VAStatus;
1692}
1693extern "C" {
1694 pub fn vaPutImage(
1695 dpy: VADisplay,
1696 surface: VASurfaceID,
1697 image: VAImageID,
1698 src_x: ::std::os::raw::c_int,
1699 src_y: ::std::os::raw::c_int,
1700 src_width: ::std::os::raw::c_uint,
1701 src_height: ::std::os::raw::c_uint,
1702 dest_x: ::std::os::raw::c_int,
1703 dest_y: ::std::os::raw::c_int,
1704 dest_width: ::std::os::raw::c_uint,
1705 dest_height: ::std::os::raw::c_uint,
1706 ) -> VAStatus;
1707}
1708extern "C" {
1709 pub fn vaDeriveImage(dpy: VADisplay, surface: VASurfaceID, image: *mut VAImage) -> VAStatus;
1710}
1711pub type VASubpictureID = VAGenericID;
1712extern "C" {
1713 pub fn vaMaxNumSubpictureFormats(dpy: VADisplay) -> ::std::os::raw::c_int;
1714}
1715extern "C" {
1716 pub fn vaQuerySubpictureFormats(
1717 dpy: VADisplay,
1718 format_list: *mut VAImageFormat,
1719 flags: *mut ::std::os::raw::c_uint,
1720 num_formats: *mut ::std::os::raw::c_uint,
1721 ) -> VAStatus;
1722}
1723extern "C" {
1724 pub fn vaCreateSubpicture(
1725 dpy: VADisplay,
1726 image: VAImageID,
1727 subpicture: *mut VASubpictureID,
1728 ) -> VAStatus;
1729}
1730extern "C" {
1731 pub fn vaDestroySubpicture(dpy: VADisplay, subpicture: VASubpictureID) -> VAStatus;
1732}
1733extern "C" {
1734 pub fn vaSetSubpictureImage(
1735 dpy: VADisplay,
1736 subpicture: VASubpictureID,
1737 image: VAImageID,
1738 ) -> VAStatus;
1739}
1740extern "C" {
1741 pub fn vaSetSubpictureChromakey(
1742 dpy: VADisplay,
1743 subpicture: VASubpictureID,
1744 chromakey_min: ::std::os::raw::c_uint,
1745 chromakey_max: ::std::os::raw::c_uint,
1746 chromakey_mask: ::std::os::raw::c_uint,
1747 ) -> VAStatus;
1748}
1749extern "C" {
1750 pub fn vaSetSubpictureGlobalAlpha(
1751 dpy: VADisplay,
1752 subpicture: VASubpictureID,
1753 global_alpha: f32,
1754 ) -> VAStatus;
1755}
1756extern "C" {
1757 pub fn vaAssociateSubpicture(
1758 dpy: VADisplay,
1759 subpicture: VASubpictureID,
1760 target_surfaces: *mut VASurfaceID,
1761 num_surfaces: ::std::os::raw::c_int,
1762 src_x: i16,
1763 src_y: i16,
1764 src_width: u16,
1765 src_height: u16,
1766 dest_x: i16,
1767 dest_y: i16,
1768 dest_width: u16,
1769 dest_height: u16,
1770 flags: u32,
1771 ) -> VAStatus;
1772}
1773extern "C" {
1774 pub fn vaDeassociateSubpicture(
1775 dpy: VADisplay,
1776 subpicture: VASubpictureID,
1777 target_surfaces: *mut VASurfaceID,
1778 num_surfaces: ::std::os::raw::c_int,
1779 ) -> VAStatus;
1780}
1781pub mod VADisplayAttribType {
1782 pub type Type = ::std::os::raw::c_uint;
1783 pub const VADisplayAttribBrightness: Type = 0;
1784 pub const VADisplayAttribContrast: Type = 1;
1785 pub const VADisplayAttribHue: Type = 2;
1786 pub const VADisplayAttribSaturation: Type = 3;
1787 pub const VADisplayAttribBackgroundColor: Type = 4;
1788 pub const VADisplayAttribDirectSurface: Type = 5;
1789 pub const VADisplayAttribRotation: Type = 6;
1790 pub const VADisplayAttribOutofLoopDeblock: Type = 7;
1791 pub const VADisplayAttribBLEBlackMode: Type = 8;
1792 pub const VADisplayAttribBLEWhiteMode: Type = 9;
1793 pub const VADisplayAttribBlueStretch: Type = 10;
1794 pub const VADisplayAttribSkinColorCorrection: Type = 11;
1795 pub const VADisplayAttribCSCMatrix: Type = 12;
1796 pub const VADisplayAttribBlendColor: Type = 13;
1797 pub const VADisplayAttribOverlayAutoPaintColorKey: Type = 14;
1798 pub const VADisplayAttribOverlayColorKey: Type = 15;
1799 pub const VADisplayAttribRenderMode: Type = 16;
1800 pub const VADisplayAttribRenderDevice: Type = 17;
1801 pub const VADisplayAttribRenderRect: Type = 18;
1802 pub const VADisplayAttribSubDevice: Type = 19;
1803 pub const VADisplayAttribCopy: Type = 20;
1804 pub const VADisplayPCIID: Type = 21;
1805}
1806#[repr(C)]
1807#[derive(Debug, Copy, Clone, PartialEq, Eq)]
1808pub struct _VADisplayAttribute {
1809 pub type_: VADisplayAttribType::Type,
1810 pub min_value: i32,
1811 pub max_value: i32,
1812 pub value: i32,
1813 pub flags: u32,
1814 pub va_reserved: [u32; 4usize],
1815}
1816impl Default for _VADisplayAttribute {
1817 fn default() -> Self {
1818 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1819 unsafe {
1820 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1821 s.assume_init()
1822 }
1823 }
1824}
1825pub type VADisplayAttribute = _VADisplayAttribute;
1826extern "C" {
1827 pub fn vaMaxNumDisplayAttributes(dpy: VADisplay) -> ::std::os::raw::c_int;
1828}
1829extern "C" {
1830 pub fn vaQueryDisplayAttributes(
1831 dpy: VADisplay,
1832 attr_list: *mut VADisplayAttribute,
1833 num_attributes: *mut ::std::os::raw::c_int,
1834 ) -> VAStatus;
1835}
1836extern "C" {
1837 pub fn vaGetDisplayAttributes(
1838 dpy: VADisplay,
1839 attr_list: *mut VADisplayAttribute,
1840 num_attributes: ::std::os::raw::c_int,
1841 ) -> VAStatus;
1842}
1843extern "C" {
1844 pub fn vaSetDisplayAttributes(
1845 dpy: VADisplay,
1846 attr_list: *mut VADisplayAttribute,
1847 num_attributes: ::std::os::raw::c_int,
1848 ) -> VAStatus;
1849}
1850pub mod VACopyObjectType {
1851 pub type Type = ::std::os::raw::c_uint;
1852 pub const VACopyObjectSurface: Type = 0;
1853 pub const VACopyObjectBuffer: Type = 1;
1854}
1855#[repr(C)]
1856#[derive(Copy, Clone)]
1857pub struct _VACopyObject {
1858 pub obj_type: VACopyObjectType::Type,
1859 pub object: _VACopyObject__bindgen_ty_1,
1860 pub va_reserved: [u32; 8usize],
1861}
1862#[repr(C)]
1863#[derive(Copy, Clone)]
1864pub union _VACopyObject__bindgen_ty_1 {
1865 pub surface_id: VASurfaceID,
1866 pub buffer_id: VABufferID,
1867}
1868impl Default for _VACopyObject__bindgen_ty_1 {
1869 fn default() -> Self {
1870 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1871 unsafe {
1872 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1873 s.assume_init()
1874 }
1875 }
1876}
1877impl Default for _VACopyObject {
1878 fn default() -> Self {
1879 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1880 unsafe {
1881 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1882 s.assume_init()
1883 }
1884 }
1885}
1886pub type VACopyObject = _VACopyObject;
1887#[repr(C)]
1888#[derive(Copy, Clone)]
1889pub union _VACopyOption {
1890 pub bits: _VACopyOption__bindgen_ty_1,
1891 pub value: u32,
1892}
1893#[repr(C)]
1894#[repr(align(4))]
1895#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
1896pub struct _VACopyOption__bindgen_ty_1 {
1897 pub _bitfield_align_1: [u32; 0],
1898 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
1899}
1900impl _VACopyOption__bindgen_ty_1 {
1901 #[inline]
1902 pub fn va_copy_sync(&self) -> u32 {
1903 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u32) }
1904 }
1905 #[inline]
1906 pub fn set_va_copy_sync(&mut self, val: u32) {
1907 unsafe {
1908 let val: u32 = ::std::mem::transmute(val);
1909 self._bitfield_1.set(0usize, 2u8, val as u64)
1910 }
1911 }
1912 #[inline]
1913 pub fn va_copy_mode(&self) -> u32 {
1914 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 4u8) as u32) }
1915 }
1916 #[inline]
1917 pub fn set_va_copy_mode(&mut self, val: u32) {
1918 unsafe {
1919 let val: u32 = ::std::mem::transmute(val);
1920 self._bitfield_1.set(2usize, 4u8, val as u64)
1921 }
1922 }
1923 #[inline]
1924 pub fn reserved(&self) -> u32 {
1925 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 26u8) as u32) }
1926 }
1927 #[inline]
1928 pub fn set_reserved(&mut self, val: u32) {
1929 unsafe {
1930 let val: u32 = ::std::mem::transmute(val);
1931 self._bitfield_1.set(6usize, 26u8, val as u64)
1932 }
1933 }
1934 #[inline]
1935 pub fn new_bitfield_1(
1936 va_copy_sync: u32,
1937 va_copy_mode: u32,
1938 reserved: u32,
1939 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
1940 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
1941 __bindgen_bitfield_unit.set(0usize, 2u8, {
1942 let va_copy_sync: u32 = unsafe { ::std::mem::transmute(va_copy_sync) };
1943 va_copy_sync as u64
1944 });
1945 __bindgen_bitfield_unit.set(2usize, 4u8, {
1946 let va_copy_mode: u32 = unsafe { ::std::mem::transmute(va_copy_mode) };
1947 va_copy_mode as u64
1948 });
1949 __bindgen_bitfield_unit.set(6usize, 26u8, {
1950 let reserved: u32 = unsafe { ::std::mem::transmute(reserved) };
1951 reserved as u64
1952 });
1953 __bindgen_bitfield_unit
1954 }
1955}
1956impl Default for _VACopyOption {
1957 fn default() -> Self {
1958 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1959 unsafe {
1960 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1961 s.assume_init()
1962 }
1963 }
1964}
1965pub type VACopyOption = _VACopyOption;
1966extern "C" {
1967 pub fn vaCopy(
1968 dpy: VADisplay,
1969 dst: *mut VACopyObject,
1970 src: *mut VACopyObject,
1971 option: VACopyOption,
1972 ) -> VAStatus;
1973}
1974#[repr(C)]
1975#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
1976pub struct _VABoolCoderContextVPX {
1977 pub range: u8,
1978 pub value: u8,
1979 pub count: u8,
1980}
1981pub type VABoolCoderContextVPX = _VABoolCoderContextVPX;
1982#[repr(C)]
1983#[derive(Copy, Clone)]
1984pub struct _VAPictureParameterBufferVP8 {
1985 pub frame_width: u32,
1986 pub frame_height: u32,
1987 pub last_ref_frame: VASurfaceID,
1988 pub golden_ref_frame: VASurfaceID,
1989 pub alt_ref_frame: VASurfaceID,
1990 pub out_of_loop_frame: VASurfaceID,
1991 pub pic_fields: _VAPictureParameterBufferVP8__bindgen_ty_1,
1992 pub mb_segment_tree_probs: [u8; 3usize],
1993 pub loop_filter_level: [u8; 4usize],
1994 pub loop_filter_deltas_ref_frame: [i8; 4usize],
1995 pub loop_filter_deltas_mode: [i8; 4usize],
1996 pub prob_skip_false: u8,
1997 pub prob_intra: u8,
1998 pub prob_last: u8,
1999 pub prob_gf: u8,
2000 pub y_mode_probs: [u8; 4usize],
2001 pub uv_mode_probs: [u8; 3usize],
2002 pub mv_probs: [[u8; 19usize]; 2usize],
2003 pub bool_coder_ctx: VABoolCoderContextVPX,
2004 pub va_reserved: [u32; 4usize],
2005}
2006#[repr(C)]
2007#[derive(Copy, Clone)]
2008pub union _VAPictureParameterBufferVP8__bindgen_ty_1 {
2009 pub bits: _VAPictureParameterBufferVP8__bindgen_ty_1__bindgen_ty_1,
2010 pub value: u32,
2011}
2012#[repr(C)]
2013#[repr(align(4))]
2014#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
2015pub struct _VAPictureParameterBufferVP8__bindgen_ty_1__bindgen_ty_1 {
2016 pub _bitfield_align_1: [u8; 0],
2017 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 3usize]>,
2018 pub __bindgen_padding_0: u8,
2019}
2020impl _VAPictureParameterBufferVP8__bindgen_ty_1__bindgen_ty_1 {
2021 #[inline]
2022 pub fn key_frame(&self) -> u32 {
2023 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
2024 }
2025 #[inline]
2026 pub fn set_key_frame(&mut self, val: u32) {
2027 unsafe {
2028 let val: u32 = ::std::mem::transmute(val);
2029 self._bitfield_1.set(0usize, 1u8, val as u64)
2030 }
2031 }
2032 #[inline]
2033 pub fn version(&self) -> u32 {
2034 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 3u8) as u32) }
2035 }
2036 #[inline]
2037 pub fn set_version(&mut self, val: u32) {
2038 unsafe {
2039 let val: u32 = ::std::mem::transmute(val);
2040 self._bitfield_1.set(1usize, 3u8, val as u64)
2041 }
2042 }
2043 #[inline]
2044 pub fn segmentation_enabled(&self) -> u32 {
2045 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
2046 }
2047 #[inline]
2048 pub fn set_segmentation_enabled(&mut self, val: u32) {
2049 unsafe {
2050 let val: u32 = ::std::mem::transmute(val);
2051 self._bitfield_1.set(4usize, 1u8, val as u64)
2052 }
2053 }
2054 #[inline]
2055 pub fn update_mb_segmentation_map(&self) -> u32 {
2056 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
2057 }
2058 #[inline]
2059 pub fn set_update_mb_segmentation_map(&mut self, val: u32) {
2060 unsafe {
2061 let val: u32 = ::std::mem::transmute(val);
2062 self._bitfield_1.set(5usize, 1u8, val as u64)
2063 }
2064 }
2065 #[inline]
2066 pub fn update_segment_feature_data(&self) -> u32 {
2067 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) }
2068 }
2069 #[inline]
2070 pub fn set_update_segment_feature_data(&mut self, val: u32) {
2071 unsafe {
2072 let val: u32 = ::std::mem::transmute(val);
2073 self._bitfield_1.set(6usize, 1u8, val as u64)
2074 }
2075 }
2076 #[inline]
2077 pub fn filter_type(&self) -> u32 {
2078 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) }
2079 }
2080 #[inline]
2081 pub fn set_filter_type(&mut self, val: u32) {
2082 unsafe {
2083 let val: u32 = ::std::mem::transmute(val);
2084 self._bitfield_1.set(7usize, 1u8, val as u64)
2085 }
2086 }
2087 #[inline]
2088 pub fn sharpness_level(&self) -> u32 {
2089 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 3u8) as u32) }
2090 }
2091 #[inline]
2092 pub fn set_sharpness_level(&mut self, val: u32) {
2093 unsafe {
2094 let val: u32 = ::std::mem::transmute(val);
2095 self._bitfield_1.set(8usize, 3u8, val as u64)
2096 }
2097 }
2098 #[inline]
2099 pub fn loop_filter_adj_enable(&self) -> u32 {
2100 unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) }
2101 }
2102 #[inline]
2103 pub fn set_loop_filter_adj_enable(&mut self, val: u32) {
2104 unsafe {
2105 let val: u32 = ::std::mem::transmute(val);
2106 self._bitfield_1.set(11usize, 1u8, val as u64)
2107 }
2108 }
2109 #[inline]
2110 pub fn mode_ref_lf_delta_update(&self) -> u32 {
2111 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u32) }
2112 }
2113 #[inline]
2114 pub fn set_mode_ref_lf_delta_update(&mut self, val: u32) {
2115 unsafe {
2116 let val: u32 = ::std::mem::transmute(val);
2117 self._bitfield_1.set(12usize, 1u8, val as u64)
2118 }
2119 }
2120 #[inline]
2121 pub fn sign_bias_golden(&self) -> u32 {
2122 unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) }
2123 }
2124 #[inline]
2125 pub fn set_sign_bias_golden(&mut self, val: u32) {
2126 unsafe {
2127 let val: u32 = ::std::mem::transmute(val);
2128 self._bitfield_1.set(13usize, 1u8, val as u64)
2129 }
2130 }
2131 #[inline]
2132 pub fn sign_bias_alternate(&self) -> u32 {
2133 unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) }
2134 }
2135 #[inline]
2136 pub fn set_sign_bias_alternate(&mut self, val: u32) {
2137 unsafe {
2138 let val: u32 = ::std::mem::transmute(val);
2139 self._bitfield_1.set(14usize, 1u8, val as u64)
2140 }
2141 }
2142 #[inline]
2143 pub fn mb_no_coeff_skip(&self) -> u32 {
2144 unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u32) }
2145 }
2146 #[inline]
2147 pub fn set_mb_no_coeff_skip(&mut self, val: u32) {
2148 unsafe {
2149 let val: u32 = ::std::mem::transmute(val);
2150 self._bitfield_1.set(15usize, 1u8, val as u64)
2151 }
2152 }
2153 #[inline]
2154 pub fn loop_filter_disable(&self) -> u32 {
2155 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u32) }
2156 }
2157 #[inline]
2158 pub fn set_loop_filter_disable(&mut self, val: u32) {
2159 unsafe {
2160 let val: u32 = ::std::mem::transmute(val);
2161 self._bitfield_1.set(16usize, 1u8, val as u64)
2162 }
2163 }
2164 #[inline]
2165 pub fn new_bitfield_1(
2166 key_frame: u32,
2167 version: u32,
2168 segmentation_enabled: u32,
2169 update_mb_segmentation_map: u32,
2170 update_segment_feature_data: u32,
2171 filter_type: u32,
2172 sharpness_level: u32,
2173 loop_filter_adj_enable: u32,
2174 mode_ref_lf_delta_update: u32,
2175 sign_bias_golden: u32,
2176 sign_bias_alternate: u32,
2177 mb_no_coeff_skip: u32,
2178 loop_filter_disable: u32,
2179 ) -> __BindgenBitfieldUnit<[u8; 3usize]> {
2180 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 3usize]> = Default::default();
2181 __bindgen_bitfield_unit.set(0usize, 1u8, {
2182 let key_frame: u32 = unsafe { ::std::mem::transmute(key_frame) };
2183 key_frame as u64
2184 });
2185 __bindgen_bitfield_unit.set(1usize, 3u8, {
2186 let version: u32 = unsafe { ::std::mem::transmute(version) };
2187 version as u64
2188 });
2189 __bindgen_bitfield_unit.set(4usize, 1u8, {
2190 let segmentation_enabled: u32 = unsafe { ::std::mem::transmute(segmentation_enabled) };
2191 segmentation_enabled as u64
2192 });
2193 __bindgen_bitfield_unit.set(5usize, 1u8, {
2194 let update_mb_segmentation_map: u32 =
2195 unsafe { ::std::mem::transmute(update_mb_segmentation_map) };
2196 update_mb_segmentation_map as u64
2197 });
2198 __bindgen_bitfield_unit.set(6usize, 1u8, {
2199 let update_segment_feature_data: u32 =
2200 unsafe { ::std::mem::transmute(update_segment_feature_data) };
2201 update_segment_feature_data as u64
2202 });
2203 __bindgen_bitfield_unit.set(7usize, 1u8, {
2204 let filter_type: u32 = unsafe { ::std::mem::transmute(filter_type) };
2205 filter_type as u64
2206 });
2207 __bindgen_bitfield_unit.set(8usize, 3u8, {
2208 let sharpness_level: u32 = unsafe { ::std::mem::transmute(sharpness_level) };
2209 sharpness_level as u64
2210 });
2211 __bindgen_bitfield_unit.set(11usize, 1u8, {
2212 let loop_filter_adj_enable: u32 =
2213 unsafe { ::std::mem::transmute(loop_filter_adj_enable) };
2214 loop_filter_adj_enable as u64
2215 });
2216 __bindgen_bitfield_unit.set(12usize, 1u8, {
2217 let mode_ref_lf_delta_update: u32 =
2218 unsafe { ::std::mem::transmute(mode_ref_lf_delta_update) };
2219 mode_ref_lf_delta_update as u64
2220 });
2221 __bindgen_bitfield_unit.set(13usize, 1u8, {
2222 let sign_bias_golden: u32 = unsafe { ::std::mem::transmute(sign_bias_golden) };
2223 sign_bias_golden as u64
2224 });
2225 __bindgen_bitfield_unit.set(14usize, 1u8, {
2226 let sign_bias_alternate: u32 = unsafe { ::std::mem::transmute(sign_bias_alternate) };
2227 sign_bias_alternate as u64
2228 });
2229 __bindgen_bitfield_unit.set(15usize, 1u8, {
2230 let mb_no_coeff_skip: u32 = unsafe { ::std::mem::transmute(mb_no_coeff_skip) };
2231 mb_no_coeff_skip as u64
2232 });
2233 __bindgen_bitfield_unit.set(16usize, 1u8, {
2234 let loop_filter_disable: u32 = unsafe { ::std::mem::transmute(loop_filter_disable) };
2235 loop_filter_disable as u64
2236 });
2237 __bindgen_bitfield_unit
2238 }
2239}
2240impl Default for _VAPictureParameterBufferVP8__bindgen_ty_1 {
2241 fn default() -> Self {
2242 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2243 unsafe {
2244 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2245 s.assume_init()
2246 }
2247 }
2248}
2249impl Default for _VAPictureParameterBufferVP8 {
2250 fn default() -> Self {
2251 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2252 unsafe {
2253 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2254 s.assume_init()
2255 }
2256 }
2257}
2258pub type VAPictureParameterBufferVP8 = _VAPictureParameterBufferVP8;
2259#[repr(C)]
2260#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
2261pub struct _VASliceParameterBufferVP8 {
2262 pub slice_data_size: u32,
2263 pub slice_data_offset: u32,
2264 pub slice_data_flag: u32,
2265 pub macroblock_offset: u32,
2266 pub num_of_partitions: u8,
2267 pub partition_size: [u32; 9usize],
2268 pub va_reserved: [u32; 4usize],
2269}
2270pub type VASliceParameterBufferVP8 = _VASliceParameterBufferVP8;
2271#[repr(C)]
2272#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
2273pub struct _VAProbabilityDataBufferVP8 {
2274 pub dct_coeff_probs: [[[[u8; 11usize]; 3usize]; 8usize]; 4usize],
2275 pub va_reserved: [u32; 4usize],
2276}
2277pub type VAProbabilityDataBufferVP8 = _VAProbabilityDataBufferVP8;
2278#[repr(C)]
2279#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
2280pub struct _VAIQMatrixBufferVP8 {
2281 pub quantization_index: [[u16; 6usize]; 4usize],
2282 pub va_reserved: [u32; 4usize],
2283}
2284pub type VAIQMatrixBufferVP8 = _VAIQMatrixBufferVP8;
2285#[repr(C)]
2286#[derive(Copy, Clone)]
2287pub struct _VADecPictureParameterBufferVP9 {
2288 pub frame_width: u16,
2289 pub frame_height: u16,
2290 pub reference_frames: [VASurfaceID; 8usize],
2291 pub pic_fields: _VADecPictureParameterBufferVP9__bindgen_ty_1,
2292 pub filter_level: u8,
2293 pub sharpness_level: u8,
2294 pub log2_tile_rows: u8,
2295 pub log2_tile_columns: u8,
2296 pub frame_header_length_in_bytes: u8,
2297 pub first_partition_size: u16,
2298 pub mb_segment_tree_probs: [u8; 7usize],
2299 pub segment_pred_probs: [u8; 3usize],
2300 pub profile: u8,
2301 pub bit_depth: u8,
2302 pub va_reserved: [u32; 8usize],
2303}
2304#[repr(C)]
2305#[derive(Copy, Clone)]
2306pub union _VADecPictureParameterBufferVP9__bindgen_ty_1 {
2307 pub bits: _VADecPictureParameterBufferVP9__bindgen_ty_1__bindgen_ty_1,
2308 pub value: u32,
2309}
2310#[repr(C)]
2311#[repr(align(4))]
2312#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
2313pub struct _VADecPictureParameterBufferVP9__bindgen_ty_1__bindgen_ty_1 {
2314 pub _bitfield_align_1: [u8; 0],
2315 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
2316}
2317impl _VADecPictureParameterBufferVP9__bindgen_ty_1__bindgen_ty_1 {
2318 #[inline]
2319 pub fn subsampling_x(&self) -> u32 {
2320 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
2321 }
2322 #[inline]
2323 pub fn set_subsampling_x(&mut self, val: u32) {
2324 unsafe {
2325 let val: u32 = ::std::mem::transmute(val);
2326 self._bitfield_1.set(0usize, 1u8, val as u64)
2327 }
2328 }
2329 #[inline]
2330 pub fn subsampling_y(&self) -> u32 {
2331 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
2332 }
2333 #[inline]
2334 pub fn set_subsampling_y(&mut self, val: u32) {
2335 unsafe {
2336 let val: u32 = ::std::mem::transmute(val);
2337 self._bitfield_1.set(1usize, 1u8, val as u64)
2338 }
2339 }
2340 #[inline]
2341 pub fn frame_type(&self) -> u32 {
2342 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
2343 }
2344 #[inline]
2345 pub fn set_frame_type(&mut self, val: u32) {
2346 unsafe {
2347 let val: u32 = ::std::mem::transmute(val);
2348 self._bitfield_1.set(2usize, 1u8, val as u64)
2349 }
2350 }
2351 #[inline]
2352 pub fn show_frame(&self) -> u32 {
2353 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
2354 }
2355 #[inline]
2356 pub fn set_show_frame(&mut self, val: u32) {
2357 unsafe {
2358 let val: u32 = ::std::mem::transmute(val);
2359 self._bitfield_1.set(3usize, 1u8, val as u64)
2360 }
2361 }
2362 #[inline]
2363 pub fn error_resilient_mode(&self) -> u32 {
2364 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
2365 }
2366 #[inline]
2367 pub fn set_error_resilient_mode(&mut self, val: u32) {
2368 unsafe {
2369 let val: u32 = ::std::mem::transmute(val);
2370 self._bitfield_1.set(4usize, 1u8, val as u64)
2371 }
2372 }
2373 #[inline]
2374 pub fn intra_only(&self) -> u32 {
2375 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
2376 }
2377 #[inline]
2378 pub fn set_intra_only(&mut self, val: u32) {
2379 unsafe {
2380 let val: u32 = ::std::mem::transmute(val);
2381 self._bitfield_1.set(5usize, 1u8, val as u64)
2382 }
2383 }
2384 #[inline]
2385 pub fn allow_high_precision_mv(&self) -> u32 {
2386 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) }
2387 }
2388 #[inline]
2389 pub fn set_allow_high_precision_mv(&mut self, val: u32) {
2390 unsafe {
2391 let val: u32 = ::std::mem::transmute(val);
2392 self._bitfield_1.set(6usize, 1u8, val as u64)
2393 }
2394 }
2395 #[inline]
2396 pub fn mcomp_filter_type(&self) -> u32 {
2397 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 3u8) as u32) }
2398 }
2399 #[inline]
2400 pub fn set_mcomp_filter_type(&mut self, val: u32) {
2401 unsafe {
2402 let val: u32 = ::std::mem::transmute(val);
2403 self._bitfield_1.set(7usize, 3u8, val as u64)
2404 }
2405 }
2406 #[inline]
2407 pub fn frame_parallel_decoding_mode(&self) -> u32 {
2408 unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) }
2409 }
2410 #[inline]
2411 pub fn set_frame_parallel_decoding_mode(&mut self, val: u32) {
2412 unsafe {
2413 let val: u32 = ::std::mem::transmute(val);
2414 self._bitfield_1.set(10usize, 1u8, val as u64)
2415 }
2416 }
2417 #[inline]
2418 pub fn reset_frame_context(&self) -> u32 {
2419 unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 2u8) as u32) }
2420 }
2421 #[inline]
2422 pub fn set_reset_frame_context(&mut self, val: u32) {
2423 unsafe {
2424 let val: u32 = ::std::mem::transmute(val);
2425 self._bitfield_1.set(11usize, 2u8, val as u64)
2426 }
2427 }
2428 #[inline]
2429 pub fn refresh_frame_context(&self) -> u32 {
2430 unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) }
2431 }
2432 #[inline]
2433 pub fn set_refresh_frame_context(&mut self, val: u32) {
2434 unsafe {
2435 let val: u32 = ::std::mem::transmute(val);
2436 self._bitfield_1.set(13usize, 1u8, val as u64)
2437 }
2438 }
2439 #[inline]
2440 pub fn frame_context_idx(&self) -> u32 {
2441 unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 2u8) as u32) }
2442 }
2443 #[inline]
2444 pub fn set_frame_context_idx(&mut self, val: u32) {
2445 unsafe {
2446 let val: u32 = ::std::mem::transmute(val);
2447 self._bitfield_1.set(14usize, 2u8, val as u64)
2448 }
2449 }
2450 #[inline]
2451 pub fn segmentation_enabled(&self) -> u32 {
2452 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u32) }
2453 }
2454 #[inline]
2455 pub fn set_segmentation_enabled(&mut self, val: u32) {
2456 unsafe {
2457 let val: u32 = ::std::mem::transmute(val);
2458 self._bitfield_1.set(16usize, 1u8, val as u64)
2459 }
2460 }
2461 #[inline]
2462 pub fn segmentation_temporal_update(&self) -> u32 {
2463 unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 1u8) as u32) }
2464 }
2465 #[inline]
2466 pub fn set_segmentation_temporal_update(&mut self, val: u32) {
2467 unsafe {
2468 let val: u32 = ::std::mem::transmute(val);
2469 self._bitfield_1.set(17usize, 1u8, val as u64)
2470 }
2471 }
2472 #[inline]
2473 pub fn segmentation_update_map(&self) -> u32 {
2474 unsafe { ::std::mem::transmute(self._bitfield_1.get(18usize, 1u8) as u32) }
2475 }
2476 #[inline]
2477 pub fn set_segmentation_update_map(&mut self, val: u32) {
2478 unsafe {
2479 let val: u32 = ::std::mem::transmute(val);
2480 self._bitfield_1.set(18usize, 1u8, val as u64)
2481 }
2482 }
2483 #[inline]
2484 pub fn last_ref_frame(&self) -> u32 {
2485 unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 3u8) as u32) }
2486 }
2487 #[inline]
2488 pub fn set_last_ref_frame(&mut self, val: u32) {
2489 unsafe {
2490 let val: u32 = ::std::mem::transmute(val);
2491 self._bitfield_1.set(19usize, 3u8, val as u64)
2492 }
2493 }
2494 #[inline]
2495 pub fn last_ref_frame_sign_bias(&self) -> u32 {
2496 unsafe { ::std::mem::transmute(self._bitfield_1.get(22usize, 1u8) as u32) }
2497 }
2498 #[inline]
2499 pub fn set_last_ref_frame_sign_bias(&mut self, val: u32) {
2500 unsafe {
2501 let val: u32 = ::std::mem::transmute(val);
2502 self._bitfield_1.set(22usize, 1u8, val as u64)
2503 }
2504 }
2505 #[inline]
2506 pub fn golden_ref_frame(&self) -> u32 {
2507 unsafe { ::std::mem::transmute(self._bitfield_1.get(23usize, 3u8) as u32) }
2508 }
2509 #[inline]
2510 pub fn set_golden_ref_frame(&mut self, val: u32) {
2511 unsafe {
2512 let val: u32 = ::std::mem::transmute(val);
2513 self._bitfield_1.set(23usize, 3u8, val as u64)
2514 }
2515 }
2516 #[inline]
2517 pub fn golden_ref_frame_sign_bias(&self) -> u32 {
2518 unsafe { ::std::mem::transmute(self._bitfield_1.get(26usize, 1u8) as u32) }
2519 }
2520 #[inline]
2521 pub fn set_golden_ref_frame_sign_bias(&mut self, val: u32) {
2522 unsafe {
2523 let val: u32 = ::std::mem::transmute(val);
2524 self._bitfield_1.set(26usize, 1u8, val as u64)
2525 }
2526 }
2527 #[inline]
2528 pub fn alt_ref_frame(&self) -> u32 {
2529 unsafe { ::std::mem::transmute(self._bitfield_1.get(27usize, 3u8) as u32) }
2530 }
2531 #[inline]
2532 pub fn set_alt_ref_frame(&mut self, val: u32) {
2533 unsafe {
2534 let val: u32 = ::std::mem::transmute(val);
2535 self._bitfield_1.set(27usize, 3u8, val as u64)
2536 }
2537 }
2538 #[inline]
2539 pub fn alt_ref_frame_sign_bias(&self) -> u32 {
2540 unsafe { ::std::mem::transmute(self._bitfield_1.get(30usize, 1u8) as u32) }
2541 }
2542 #[inline]
2543 pub fn set_alt_ref_frame_sign_bias(&mut self, val: u32) {
2544 unsafe {
2545 let val: u32 = ::std::mem::transmute(val);
2546 self._bitfield_1.set(30usize, 1u8, val as u64)
2547 }
2548 }
2549 #[inline]
2550 pub fn lossless_flag(&self) -> u32 {
2551 unsafe { ::std::mem::transmute(self._bitfield_1.get(31usize, 1u8) as u32) }
2552 }
2553 #[inline]
2554 pub fn set_lossless_flag(&mut self, val: u32) {
2555 unsafe {
2556 let val: u32 = ::std::mem::transmute(val);
2557 self._bitfield_1.set(31usize, 1u8, val as u64)
2558 }
2559 }
2560 #[inline]
2561 pub fn new_bitfield_1(
2562 subsampling_x: u32,
2563 subsampling_y: u32,
2564 frame_type: u32,
2565 show_frame: u32,
2566 error_resilient_mode: u32,
2567 intra_only: u32,
2568 allow_high_precision_mv: u32,
2569 mcomp_filter_type: u32,
2570 frame_parallel_decoding_mode: u32,
2571 reset_frame_context: u32,
2572 refresh_frame_context: u32,
2573 frame_context_idx: u32,
2574 segmentation_enabled: u32,
2575 segmentation_temporal_update: u32,
2576 segmentation_update_map: u32,
2577 last_ref_frame: u32,
2578 last_ref_frame_sign_bias: u32,
2579 golden_ref_frame: u32,
2580 golden_ref_frame_sign_bias: u32,
2581 alt_ref_frame: u32,
2582 alt_ref_frame_sign_bias: u32,
2583 lossless_flag: u32,
2584 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
2585 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
2586 __bindgen_bitfield_unit.set(0usize, 1u8, {
2587 let subsampling_x: u32 = unsafe { ::std::mem::transmute(subsampling_x) };
2588 subsampling_x as u64
2589 });
2590 __bindgen_bitfield_unit.set(1usize, 1u8, {
2591 let subsampling_y: u32 = unsafe { ::std::mem::transmute(subsampling_y) };
2592 subsampling_y as u64
2593 });
2594 __bindgen_bitfield_unit.set(2usize, 1u8, {
2595 let frame_type: u32 = unsafe { ::std::mem::transmute(frame_type) };
2596 frame_type as u64
2597 });
2598 __bindgen_bitfield_unit.set(3usize, 1u8, {
2599 let show_frame: u32 = unsafe { ::std::mem::transmute(show_frame) };
2600 show_frame as u64
2601 });
2602 __bindgen_bitfield_unit.set(4usize, 1u8, {
2603 let error_resilient_mode: u32 = unsafe { ::std::mem::transmute(error_resilient_mode) };
2604 error_resilient_mode as u64
2605 });
2606 __bindgen_bitfield_unit.set(5usize, 1u8, {
2607 let intra_only: u32 = unsafe { ::std::mem::transmute(intra_only) };
2608 intra_only as u64
2609 });
2610 __bindgen_bitfield_unit.set(6usize, 1u8, {
2611 let allow_high_precision_mv: u32 =
2612 unsafe { ::std::mem::transmute(allow_high_precision_mv) };
2613 allow_high_precision_mv as u64
2614 });
2615 __bindgen_bitfield_unit.set(7usize, 3u8, {
2616 let mcomp_filter_type: u32 = unsafe { ::std::mem::transmute(mcomp_filter_type) };
2617 mcomp_filter_type as u64
2618 });
2619 __bindgen_bitfield_unit.set(10usize, 1u8, {
2620 let frame_parallel_decoding_mode: u32 =
2621 unsafe { ::std::mem::transmute(frame_parallel_decoding_mode) };
2622 frame_parallel_decoding_mode as u64
2623 });
2624 __bindgen_bitfield_unit.set(11usize, 2u8, {
2625 let reset_frame_context: u32 = unsafe { ::std::mem::transmute(reset_frame_context) };
2626 reset_frame_context as u64
2627 });
2628 __bindgen_bitfield_unit.set(13usize, 1u8, {
2629 let refresh_frame_context: u32 =
2630 unsafe { ::std::mem::transmute(refresh_frame_context) };
2631 refresh_frame_context as u64
2632 });
2633 __bindgen_bitfield_unit.set(14usize, 2u8, {
2634 let frame_context_idx: u32 = unsafe { ::std::mem::transmute(frame_context_idx) };
2635 frame_context_idx as u64
2636 });
2637 __bindgen_bitfield_unit.set(16usize, 1u8, {
2638 let segmentation_enabled: u32 = unsafe { ::std::mem::transmute(segmentation_enabled) };
2639 segmentation_enabled as u64
2640 });
2641 __bindgen_bitfield_unit.set(17usize, 1u8, {
2642 let segmentation_temporal_update: u32 =
2643 unsafe { ::std::mem::transmute(segmentation_temporal_update) };
2644 segmentation_temporal_update as u64
2645 });
2646 __bindgen_bitfield_unit.set(18usize, 1u8, {
2647 let segmentation_update_map: u32 =
2648 unsafe { ::std::mem::transmute(segmentation_update_map) };
2649 segmentation_update_map as u64
2650 });
2651 __bindgen_bitfield_unit.set(19usize, 3u8, {
2652 let last_ref_frame: u32 = unsafe { ::std::mem::transmute(last_ref_frame) };
2653 last_ref_frame as u64
2654 });
2655 __bindgen_bitfield_unit.set(22usize, 1u8, {
2656 let last_ref_frame_sign_bias: u32 =
2657 unsafe { ::std::mem::transmute(last_ref_frame_sign_bias) };
2658 last_ref_frame_sign_bias as u64
2659 });
2660 __bindgen_bitfield_unit.set(23usize, 3u8, {
2661 let golden_ref_frame: u32 = unsafe { ::std::mem::transmute(golden_ref_frame) };
2662 golden_ref_frame as u64
2663 });
2664 __bindgen_bitfield_unit.set(26usize, 1u8, {
2665 let golden_ref_frame_sign_bias: u32 =
2666 unsafe { ::std::mem::transmute(golden_ref_frame_sign_bias) };
2667 golden_ref_frame_sign_bias as u64
2668 });
2669 __bindgen_bitfield_unit.set(27usize, 3u8, {
2670 let alt_ref_frame: u32 = unsafe { ::std::mem::transmute(alt_ref_frame) };
2671 alt_ref_frame as u64
2672 });
2673 __bindgen_bitfield_unit.set(30usize, 1u8, {
2674 let alt_ref_frame_sign_bias: u32 =
2675 unsafe { ::std::mem::transmute(alt_ref_frame_sign_bias) };
2676 alt_ref_frame_sign_bias as u64
2677 });
2678 __bindgen_bitfield_unit.set(31usize, 1u8, {
2679 let lossless_flag: u32 = unsafe { ::std::mem::transmute(lossless_flag) };
2680 lossless_flag as u64
2681 });
2682 __bindgen_bitfield_unit
2683 }
2684}
2685impl Default for _VADecPictureParameterBufferVP9__bindgen_ty_1 {
2686 fn default() -> Self {
2687 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2688 unsafe {
2689 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2690 s.assume_init()
2691 }
2692 }
2693}
2694impl Default for _VADecPictureParameterBufferVP9 {
2695 fn default() -> Self {
2696 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2697 unsafe {
2698 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2699 s.assume_init()
2700 }
2701 }
2702}
2703pub type VADecPictureParameterBufferVP9 = _VADecPictureParameterBufferVP9;
2704#[repr(C)]
2705#[derive(Copy, Clone)]
2706pub struct _VASegmentParameterVP9 {
2707 pub segment_flags: _VASegmentParameterVP9__bindgen_ty_1,
2708 pub filter_level: [[u8; 2usize]; 4usize],
2709 pub luma_ac_quant_scale: i16,
2710 pub luma_dc_quant_scale: i16,
2711 pub chroma_ac_quant_scale: i16,
2712 pub chroma_dc_quant_scale: i16,
2713 pub va_reserved: [u32; 4usize],
2714}
2715#[repr(C)]
2716#[derive(Copy, Clone)]
2717pub union _VASegmentParameterVP9__bindgen_ty_1 {
2718 pub fields: _VASegmentParameterVP9__bindgen_ty_1__bindgen_ty_1,
2719 pub value: u16,
2720}
2721#[repr(C)]
2722#[repr(align(2))]
2723#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
2724pub struct _VASegmentParameterVP9__bindgen_ty_1__bindgen_ty_1 {
2725 pub _bitfield_align_1: [u8; 0],
2726 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
2727 pub __bindgen_padding_0: u8,
2728}
2729impl _VASegmentParameterVP9__bindgen_ty_1__bindgen_ty_1 {
2730 #[inline]
2731 pub fn segment_reference_enabled(&self) -> u16 {
2732 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u16) }
2733 }
2734 #[inline]
2735 pub fn set_segment_reference_enabled(&mut self, val: u16) {
2736 unsafe {
2737 let val: u16 = ::std::mem::transmute(val);
2738 self._bitfield_1.set(0usize, 1u8, val as u64)
2739 }
2740 }
2741 #[inline]
2742 pub fn segment_reference(&self) -> u16 {
2743 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 2u8) as u16) }
2744 }
2745 #[inline]
2746 pub fn set_segment_reference(&mut self, val: u16) {
2747 unsafe {
2748 let val: u16 = ::std::mem::transmute(val);
2749 self._bitfield_1.set(1usize, 2u8, val as u64)
2750 }
2751 }
2752 #[inline]
2753 pub fn segment_reference_skipped(&self) -> u16 {
2754 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u16) }
2755 }
2756 #[inline]
2757 pub fn set_segment_reference_skipped(&mut self, val: u16) {
2758 unsafe {
2759 let val: u16 = ::std::mem::transmute(val);
2760 self._bitfield_1.set(3usize, 1u8, val as u64)
2761 }
2762 }
2763 #[inline]
2764 pub fn new_bitfield_1(
2765 segment_reference_enabled: u16,
2766 segment_reference: u16,
2767 segment_reference_skipped: u16,
2768 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
2769 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
2770 __bindgen_bitfield_unit.set(0usize, 1u8, {
2771 let segment_reference_enabled: u16 =
2772 unsafe { ::std::mem::transmute(segment_reference_enabled) };
2773 segment_reference_enabled as u64
2774 });
2775 __bindgen_bitfield_unit.set(1usize, 2u8, {
2776 let segment_reference: u16 = unsafe { ::std::mem::transmute(segment_reference) };
2777 segment_reference as u64
2778 });
2779 __bindgen_bitfield_unit.set(3usize, 1u8, {
2780 let segment_reference_skipped: u16 =
2781 unsafe { ::std::mem::transmute(segment_reference_skipped) };
2782 segment_reference_skipped as u64
2783 });
2784 __bindgen_bitfield_unit
2785 }
2786}
2787impl Default for _VASegmentParameterVP9__bindgen_ty_1 {
2788 fn default() -> Self {
2789 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2790 unsafe {
2791 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2792 s.assume_init()
2793 }
2794 }
2795}
2796impl Default for _VASegmentParameterVP9 {
2797 fn default() -> Self {
2798 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2799 unsafe {
2800 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2801 s.assume_init()
2802 }
2803 }
2804}
2805pub type VASegmentParameterVP9 = _VASegmentParameterVP9;
2806#[repr(C)]
2807#[derive(Copy, Clone)]
2808pub struct _VASliceParameterBufferVP9 {
2809 pub slice_data_size: u32,
2810 pub slice_data_offset: u32,
2811 pub slice_data_flag: u32,
2812 pub seg_param: [VASegmentParameterVP9; 8usize],
2813 pub va_reserved: [u32; 4usize],
2814}
2815impl Default for _VASliceParameterBufferVP9 {
2816 fn default() -> Self {
2817 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2818 unsafe {
2819 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2820 s.assume_init()
2821 }
2822 }
2823}
2824pub type VASliceParameterBufferVP9 = _VASliceParameterBufferVP9;
2825#[repr(C)]
2826#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
2827pub struct _VAPictureStats {
2828 pub picture_id: VASurfaceID,
2829 pub flags: u32,
2830}
2831pub type VAPictureStats = _VAPictureStats;
2832#[repr(C)]
2833#[derive(Debug, Copy, Clone, PartialEq, Eq)]
2834pub struct _VAStatsStatisticsParameter {
2835 pub input: VAPictureStats,
2836 pub past_references: *mut VAPictureStats,
2837 pub num_past_references: u32,
2838 pub past_ref_stat_buf: *mut VABufferID,
2839 pub future_references: *mut VAPictureStats,
2840 pub num_future_references: u32,
2841 pub future_ref_stat_buf: *mut VABufferID,
2842 pub outputs: *mut VABufferID,
2843 pub mv_predictor: VABufferID,
2844 pub qp: VABufferID,
2845}
2846impl Default for _VAStatsStatisticsParameter {
2847 fn default() -> Self {
2848 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2849 unsafe {
2850 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2851 s.assume_init()
2852 }
2853 }
2854}
2855pub type VAStatsStatisticsParameter = _VAStatsStatisticsParameter;
2856pub mod VAEncPackedHeaderTypeH264 {
2857 pub type Type = ::std::os::raw::c_uint;
2858 pub const VAEncPackedHeaderH264_SPS: Type = 1;
2859 pub const VAEncPackedHeaderH264_PPS: Type = 2;
2860 pub const VAEncPackedHeaderH264_Slice: Type = 3;
2861 pub const VAEncPackedHeaderH264_SEI: Type = 2147483649;
2862}
2863#[repr(C)]
2864#[derive(Copy, Clone)]
2865pub struct _VAEncSequenceParameterBufferH264 {
2866 pub seq_parameter_set_id: u8,
2867 pub level_idc: u8,
2868 pub intra_period: u32,
2869 pub intra_idr_period: u32,
2870 pub ip_period: u32,
2871 pub bits_per_second: u32,
2872 pub max_num_ref_frames: u32,
2873 pub picture_width_in_mbs: u16,
2874 pub picture_height_in_mbs: u16,
2875 pub seq_fields: _VAEncSequenceParameterBufferH264__bindgen_ty_1,
2876 pub bit_depth_luma_minus8: u8,
2877 pub bit_depth_chroma_minus8: u8,
2878 pub num_ref_frames_in_pic_order_cnt_cycle: u8,
2879 pub offset_for_non_ref_pic: i32,
2880 pub offset_for_top_to_bottom_field: i32,
2881 pub offset_for_ref_frame: [i32; 256usize],
2882 pub frame_cropping_flag: u8,
2883 pub frame_crop_left_offset: u32,
2884 pub frame_crop_right_offset: u32,
2885 pub frame_crop_top_offset: u32,
2886 pub frame_crop_bottom_offset: u32,
2887 pub vui_parameters_present_flag: u8,
2888 pub vui_fields: _VAEncSequenceParameterBufferH264__bindgen_ty_2,
2889 pub aspect_ratio_idc: u8,
2890 pub sar_width: u32,
2891 pub sar_height: u32,
2892 pub num_units_in_tick: u32,
2893 pub time_scale: u32,
2894 pub va_reserved: [u32; 4usize],
2895}
2896#[repr(C)]
2897#[derive(Copy, Clone)]
2898pub union _VAEncSequenceParameterBufferH264__bindgen_ty_1 {
2899 pub bits: _VAEncSequenceParameterBufferH264__bindgen_ty_1__bindgen_ty_1,
2900 pub value: u32,
2901}
2902#[repr(C)]
2903#[repr(align(4))]
2904#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
2905pub struct _VAEncSequenceParameterBufferH264__bindgen_ty_1__bindgen_ty_1 {
2906 pub _bitfield_align_1: [u8; 0],
2907 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 3usize]>,
2908 pub __bindgen_padding_0: u8,
2909}
2910impl _VAEncSequenceParameterBufferH264__bindgen_ty_1__bindgen_ty_1 {
2911 #[inline]
2912 pub fn chroma_format_idc(&self) -> u32 {
2913 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u32) }
2914 }
2915 #[inline]
2916 pub fn set_chroma_format_idc(&mut self, val: u32) {
2917 unsafe {
2918 let val: u32 = ::std::mem::transmute(val);
2919 self._bitfield_1.set(0usize, 2u8, val as u64)
2920 }
2921 }
2922 #[inline]
2923 pub fn frame_mbs_only_flag(&self) -> u32 {
2924 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
2925 }
2926 #[inline]
2927 pub fn set_frame_mbs_only_flag(&mut self, val: u32) {
2928 unsafe {
2929 let val: u32 = ::std::mem::transmute(val);
2930 self._bitfield_1.set(2usize, 1u8, val as u64)
2931 }
2932 }
2933 #[inline]
2934 pub fn mb_adaptive_frame_field_flag(&self) -> u32 {
2935 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
2936 }
2937 #[inline]
2938 pub fn set_mb_adaptive_frame_field_flag(&mut self, val: u32) {
2939 unsafe {
2940 let val: u32 = ::std::mem::transmute(val);
2941 self._bitfield_1.set(3usize, 1u8, val as u64)
2942 }
2943 }
2944 #[inline]
2945 pub fn seq_scaling_matrix_present_flag(&self) -> u32 {
2946 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
2947 }
2948 #[inline]
2949 pub fn set_seq_scaling_matrix_present_flag(&mut self, val: u32) {
2950 unsafe {
2951 let val: u32 = ::std::mem::transmute(val);
2952 self._bitfield_1.set(4usize, 1u8, val as u64)
2953 }
2954 }
2955 #[inline]
2956 pub fn direct_8x8_inference_flag(&self) -> u32 {
2957 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
2958 }
2959 #[inline]
2960 pub fn set_direct_8x8_inference_flag(&mut self, val: u32) {
2961 unsafe {
2962 let val: u32 = ::std::mem::transmute(val);
2963 self._bitfield_1.set(5usize, 1u8, val as u64)
2964 }
2965 }
2966 #[inline]
2967 pub fn log2_max_frame_num_minus4(&self) -> u32 {
2968 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 4u8) as u32) }
2969 }
2970 #[inline]
2971 pub fn set_log2_max_frame_num_minus4(&mut self, val: u32) {
2972 unsafe {
2973 let val: u32 = ::std::mem::transmute(val);
2974 self._bitfield_1.set(6usize, 4u8, val as u64)
2975 }
2976 }
2977 #[inline]
2978 pub fn pic_order_cnt_type(&self) -> u32 {
2979 unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 2u8) as u32) }
2980 }
2981 #[inline]
2982 pub fn set_pic_order_cnt_type(&mut self, val: u32) {
2983 unsafe {
2984 let val: u32 = ::std::mem::transmute(val);
2985 self._bitfield_1.set(10usize, 2u8, val as u64)
2986 }
2987 }
2988 #[inline]
2989 pub fn log2_max_pic_order_cnt_lsb_minus4(&self) -> u32 {
2990 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 4u8) as u32) }
2991 }
2992 #[inline]
2993 pub fn set_log2_max_pic_order_cnt_lsb_minus4(&mut self, val: u32) {
2994 unsafe {
2995 let val: u32 = ::std::mem::transmute(val);
2996 self._bitfield_1.set(12usize, 4u8, val as u64)
2997 }
2998 }
2999 #[inline]
3000 pub fn delta_pic_order_always_zero_flag(&self) -> u32 {
3001 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u32) }
3002 }
3003 #[inline]
3004 pub fn set_delta_pic_order_always_zero_flag(&mut self, val: u32) {
3005 unsafe {
3006 let val: u32 = ::std::mem::transmute(val);
3007 self._bitfield_1.set(16usize, 1u8, val as u64)
3008 }
3009 }
3010 #[inline]
3011 pub fn new_bitfield_1(
3012 chroma_format_idc: u32,
3013 frame_mbs_only_flag: u32,
3014 mb_adaptive_frame_field_flag: u32,
3015 seq_scaling_matrix_present_flag: u32,
3016 direct_8x8_inference_flag: u32,
3017 log2_max_frame_num_minus4: u32,
3018 pic_order_cnt_type: u32,
3019 log2_max_pic_order_cnt_lsb_minus4: u32,
3020 delta_pic_order_always_zero_flag: u32,
3021 ) -> __BindgenBitfieldUnit<[u8; 3usize]> {
3022 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 3usize]> = Default::default();
3023 __bindgen_bitfield_unit.set(0usize, 2u8, {
3024 let chroma_format_idc: u32 = unsafe { ::std::mem::transmute(chroma_format_idc) };
3025 chroma_format_idc as u64
3026 });
3027 __bindgen_bitfield_unit.set(2usize, 1u8, {
3028 let frame_mbs_only_flag: u32 = unsafe { ::std::mem::transmute(frame_mbs_only_flag) };
3029 frame_mbs_only_flag as u64
3030 });
3031 __bindgen_bitfield_unit.set(3usize, 1u8, {
3032 let mb_adaptive_frame_field_flag: u32 =
3033 unsafe { ::std::mem::transmute(mb_adaptive_frame_field_flag) };
3034 mb_adaptive_frame_field_flag as u64
3035 });
3036 __bindgen_bitfield_unit.set(4usize, 1u8, {
3037 let seq_scaling_matrix_present_flag: u32 =
3038 unsafe { ::std::mem::transmute(seq_scaling_matrix_present_flag) };
3039 seq_scaling_matrix_present_flag as u64
3040 });
3041 __bindgen_bitfield_unit.set(5usize, 1u8, {
3042 let direct_8x8_inference_flag: u32 =
3043 unsafe { ::std::mem::transmute(direct_8x8_inference_flag) };
3044 direct_8x8_inference_flag as u64
3045 });
3046 __bindgen_bitfield_unit.set(6usize, 4u8, {
3047 let log2_max_frame_num_minus4: u32 =
3048 unsafe { ::std::mem::transmute(log2_max_frame_num_minus4) };
3049 log2_max_frame_num_minus4 as u64
3050 });
3051 __bindgen_bitfield_unit.set(10usize, 2u8, {
3052 let pic_order_cnt_type: u32 = unsafe { ::std::mem::transmute(pic_order_cnt_type) };
3053 pic_order_cnt_type as u64
3054 });
3055 __bindgen_bitfield_unit.set(12usize, 4u8, {
3056 let log2_max_pic_order_cnt_lsb_minus4: u32 =
3057 unsafe { ::std::mem::transmute(log2_max_pic_order_cnt_lsb_minus4) };
3058 log2_max_pic_order_cnt_lsb_minus4 as u64
3059 });
3060 __bindgen_bitfield_unit.set(16usize, 1u8, {
3061 let delta_pic_order_always_zero_flag: u32 =
3062 unsafe { ::std::mem::transmute(delta_pic_order_always_zero_flag) };
3063 delta_pic_order_always_zero_flag as u64
3064 });
3065 __bindgen_bitfield_unit
3066 }
3067}
3068impl Default for _VAEncSequenceParameterBufferH264__bindgen_ty_1 {
3069 fn default() -> Self {
3070 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3071 unsafe {
3072 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3073 s.assume_init()
3074 }
3075 }
3076}
3077#[repr(C)]
3078#[derive(Copy, Clone)]
3079pub union _VAEncSequenceParameterBufferH264__bindgen_ty_2 {
3080 pub bits: _VAEncSequenceParameterBufferH264__bindgen_ty_2__bindgen_ty_1,
3081 pub value: u32,
3082}
3083#[repr(C)]
3084#[repr(align(4))]
3085#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
3086pub struct _VAEncSequenceParameterBufferH264__bindgen_ty_2__bindgen_ty_1 {
3087 pub _bitfield_align_1: [u16; 0],
3088 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
3089}
3090impl _VAEncSequenceParameterBufferH264__bindgen_ty_2__bindgen_ty_1 {
3091 #[inline]
3092 pub fn aspect_ratio_info_present_flag(&self) -> u32 {
3093 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
3094 }
3095 #[inline]
3096 pub fn set_aspect_ratio_info_present_flag(&mut self, val: u32) {
3097 unsafe {
3098 let val: u32 = ::std::mem::transmute(val);
3099 self._bitfield_1.set(0usize, 1u8, val as u64)
3100 }
3101 }
3102 #[inline]
3103 pub fn timing_info_present_flag(&self) -> u32 {
3104 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
3105 }
3106 #[inline]
3107 pub fn set_timing_info_present_flag(&mut self, val: u32) {
3108 unsafe {
3109 let val: u32 = ::std::mem::transmute(val);
3110 self._bitfield_1.set(1usize, 1u8, val as u64)
3111 }
3112 }
3113 #[inline]
3114 pub fn bitstream_restriction_flag(&self) -> u32 {
3115 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
3116 }
3117 #[inline]
3118 pub fn set_bitstream_restriction_flag(&mut self, val: u32) {
3119 unsafe {
3120 let val: u32 = ::std::mem::transmute(val);
3121 self._bitfield_1.set(2usize, 1u8, val as u64)
3122 }
3123 }
3124 #[inline]
3125 pub fn log2_max_mv_length_horizontal(&self) -> u32 {
3126 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 5u8) as u32) }
3127 }
3128 #[inline]
3129 pub fn set_log2_max_mv_length_horizontal(&mut self, val: u32) {
3130 unsafe {
3131 let val: u32 = ::std::mem::transmute(val);
3132 self._bitfield_1.set(3usize, 5u8, val as u64)
3133 }
3134 }
3135 #[inline]
3136 pub fn log2_max_mv_length_vertical(&self) -> u32 {
3137 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 5u8) as u32) }
3138 }
3139 #[inline]
3140 pub fn set_log2_max_mv_length_vertical(&mut self, val: u32) {
3141 unsafe {
3142 let val: u32 = ::std::mem::transmute(val);
3143 self._bitfield_1.set(8usize, 5u8, val as u64)
3144 }
3145 }
3146 #[inline]
3147 pub fn fixed_frame_rate_flag(&self) -> u32 {
3148 unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) }
3149 }
3150 #[inline]
3151 pub fn set_fixed_frame_rate_flag(&mut self, val: u32) {
3152 unsafe {
3153 let val: u32 = ::std::mem::transmute(val);
3154 self._bitfield_1.set(13usize, 1u8, val as u64)
3155 }
3156 }
3157 #[inline]
3158 pub fn low_delay_hrd_flag(&self) -> u32 {
3159 unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) }
3160 }
3161 #[inline]
3162 pub fn set_low_delay_hrd_flag(&mut self, val: u32) {
3163 unsafe {
3164 let val: u32 = ::std::mem::transmute(val);
3165 self._bitfield_1.set(14usize, 1u8, val as u64)
3166 }
3167 }
3168 #[inline]
3169 pub fn motion_vectors_over_pic_boundaries_flag(&self) -> u32 {
3170 unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u32) }
3171 }
3172 #[inline]
3173 pub fn set_motion_vectors_over_pic_boundaries_flag(&mut self, val: u32) {
3174 unsafe {
3175 let val: u32 = ::std::mem::transmute(val);
3176 self._bitfield_1.set(15usize, 1u8, val as u64)
3177 }
3178 }
3179 #[inline]
3180 pub fn reserved(&self) -> u32 {
3181 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 16u8) as u32) }
3182 }
3183 #[inline]
3184 pub fn set_reserved(&mut self, val: u32) {
3185 unsafe {
3186 let val: u32 = ::std::mem::transmute(val);
3187 self._bitfield_1.set(16usize, 16u8, val as u64)
3188 }
3189 }
3190 #[inline]
3191 pub fn new_bitfield_1(
3192 aspect_ratio_info_present_flag: u32,
3193 timing_info_present_flag: u32,
3194 bitstream_restriction_flag: u32,
3195 log2_max_mv_length_horizontal: u32,
3196 log2_max_mv_length_vertical: u32,
3197 fixed_frame_rate_flag: u32,
3198 low_delay_hrd_flag: u32,
3199 motion_vectors_over_pic_boundaries_flag: u32,
3200 reserved: u32,
3201 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
3202 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
3203 __bindgen_bitfield_unit.set(0usize, 1u8, {
3204 let aspect_ratio_info_present_flag: u32 =
3205 unsafe { ::std::mem::transmute(aspect_ratio_info_present_flag) };
3206 aspect_ratio_info_present_flag as u64
3207 });
3208 __bindgen_bitfield_unit.set(1usize, 1u8, {
3209 let timing_info_present_flag: u32 =
3210 unsafe { ::std::mem::transmute(timing_info_present_flag) };
3211 timing_info_present_flag as u64
3212 });
3213 __bindgen_bitfield_unit.set(2usize, 1u8, {
3214 let bitstream_restriction_flag: u32 =
3215 unsafe { ::std::mem::transmute(bitstream_restriction_flag) };
3216 bitstream_restriction_flag as u64
3217 });
3218 __bindgen_bitfield_unit.set(3usize, 5u8, {
3219 let log2_max_mv_length_horizontal: u32 =
3220 unsafe { ::std::mem::transmute(log2_max_mv_length_horizontal) };
3221 log2_max_mv_length_horizontal as u64
3222 });
3223 __bindgen_bitfield_unit.set(8usize, 5u8, {
3224 let log2_max_mv_length_vertical: u32 =
3225 unsafe { ::std::mem::transmute(log2_max_mv_length_vertical) };
3226 log2_max_mv_length_vertical as u64
3227 });
3228 __bindgen_bitfield_unit.set(13usize, 1u8, {
3229 let fixed_frame_rate_flag: u32 =
3230 unsafe { ::std::mem::transmute(fixed_frame_rate_flag) };
3231 fixed_frame_rate_flag as u64
3232 });
3233 __bindgen_bitfield_unit.set(14usize, 1u8, {
3234 let low_delay_hrd_flag: u32 = unsafe { ::std::mem::transmute(low_delay_hrd_flag) };
3235 low_delay_hrd_flag as u64
3236 });
3237 __bindgen_bitfield_unit.set(15usize, 1u8, {
3238 let motion_vectors_over_pic_boundaries_flag: u32 =
3239 unsafe { ::std::mem::transmute(motion_vectors_over_pic_boundaries_flag) };
3240 motion_vectors_over_pic_boundaries_flag as u64
3241 });
3242 __bindgen_bitfield_unit.set(16usize, 16u8, {
3243 let reserved: u32 = unsafe { ::std::mem::transmute(reserved) };
3244 reserved as u64
3245 });
3246 __bindgen_bitfield_unit
3247 }
3248}
3249impl Default for _VAEncSequenceParameterBufferH264__bindgen_ty_2 {
3250 fn default() -> Self {
3251 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3252 unsafe {
3253 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3254 s.assume_init()
3255 }
3256 }
3257}
3258impl Default for _VAEncSequenceParameterBufferH264 {
3259 fn default() -> Self {
3260 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3261 unsafe {
3262 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3263 s.assume_init()
3264 }
3265 }
3266}
3267pub type VAEncSequenceParameterBufferH264 = _VAEncSequenceParameterBufferH264;
3268#[repr(C)]
3269#[derive(Copy, Clone)]
3270pub struct _VAEncPictureParameterBufferH264 {
3271 pub CurrPic: VAPictureH264,
3272 pub ReferenceFrames: [VAPictureH264; 16usize],
3273 pub coded_buf: VABufferID,
3274 pub pic_parameter_set_id: u8,
3275 pub seq_parameter_set_id: u8,
3276 pub last_picture: u8,
3277 pub frame_num: u16,
3278 pub pic_init_qp: u8,
3279 pub num_ref_idx_l0_active_minus1: u8,
3280 pub num_ref_idx_l1_active_minus1: u8,
3281 pub chroma_qp_index_offset: i8,
3282 pub second_chroma_qp_index_offset: i8,
3283 pub pic_fields: _VAEncPictureParameterBufferH264__bindgen_ty_1,
3284 pub va_reserved: [u32; 4usize],
3285}
3286#[repr(C)]
3287#[derive(Copy, Clone)]
3288pub union _VAEncPictureParameterBufferH264__bindgen_ty_1 {
3289 pub bits: _VAEncPictureParameterBufferH264__bindgen_ty_1__bindgen_ty_1,
3290 pub value: u32,
3291}
3292#[repr(C)]
3293#[repr(align(4))]
3294#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
3295pub struct _VAEncPictureParameterBufferH264__bindgen_ty_1__bindgen_ty_1 {
3296 pub _bitfield_align_1: [u8; 0],
3297 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
3298 pub __bindgen_padding_0: u16,
3299}
3300impl _VAEncPictureParameterBufferH264__bindgen_ty_1__bindgen_ty_1 {
3301 #[inline]
3302 pub fn idr_pic_flag(&self) -> u32 {
3303 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
3304 }
3305 #[inline]
3306 pub fn set_idr_pic_flag(&mut self, val: u32) {
3307 unsafe {
3308 let val: u32 = ::std::mem::transmute(val);
3309 self._bitfield_1.set(0usize, 1u8, val as u64)
3310 }
3311 }
3312 #[inline]
3313 pub fn reference_pic_flag(&self) -> u32 {
3314 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 2u8) as u32) }
3315 }
3316 #[inline]
3317 pub fn set_reference_pic_flag(&mut self, val: u32) {
3318 unsafe {
3319 let val: u32 = ::std::mem::transmute(val);
3320 self._bitfield_1.set(1usize, 2u8, val as u64)
3321 }
3322 }
3323 #[inline]
3324 pub fn entropy_coding_mode_flag(&self) -> u32 {
3325 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
3326 }
3327 #[inline]
3328 pub fn set_entropy_coding_mode_flag(&mut self, val: u32) {
3329 unsafe {
3330 let val: u32 = ::std::mem::transmute(val);
3331 self._bitfield_1.set(3usize, 1u8, val as u64)
3332 }
3333 }
3334 #[inline]
3335 pub fn weighted_pred_flag(&self) -> u32 {
3336 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
3337 }
3338 #[inline]
3339 pub fn set_weighted_pred_flag(&mut self, val: u32) {
3340 unsafe {
3341 let val: u32 = ::std::mem::transmute(val);
3342 self._bitfield_1.set(4usize, 1u8, val as u64)
3343 }
3344 }
3345 #[inline]
3346 pub fn weighted_bipred_idc(&self) -> u32 {
3347 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 2u8) as u32) }
3348 }
3349 #[inline]
3350 pub fn set_weighted_bipred_idc(&mut self, val: u32) {
3351 unsafe {
3352 let val: u32 = ::std::mem::transmute(val);
3353 self._bitfield_1.set(5usize, 2u8, val as u64)
3354 }
3355 }
3356 #[inline]
3357 pub fn constrained_intra_pred_flag(&self) -> u32 {
3358 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) }
3359 }
3360 #[inline]
3361 pub fn set_constrained_intra_pred_flag(&mut self, val: u32) {
3362 unsafe {
3363 let val: u32 = ::std::mem::transmute(val);
3364 self._bitfield_1.set(7usize, 1u8, val as u64)
3365 }
3366 }
3367 #[inline]
3368 pub fn transform_8x8_mode_flag(&self) -> u32 {
3369 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) }
3370 }
3371 #[inline]
3372 pub fn set_transform_8x8_mode_flag(&mut self, val: u32) {
3373 unsafe {
3374 let val: u32 = ::std::mem::transmute(val);
3375 self._bitfield_1.set(8usize, 1u8, val as u64)
3376 }
3377 }
3378 #[inline]
3379 pub fn deblocking_filter_control_present_flag(&self) -> u32 {
3380 unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) }
3381 }
3382 #[inline]
3383 pub fn set_deblocking_filter_control_present_flag(&mut self, val: u32) {
3384 unsafe {
3385 let val: u32 = ::std::mem::transmute(val);
3386 self._bitfield_1.set(9usize, 1u8, val as u64)
3387 }
3388 }
3389 #[inline]
3390 pub fn redundant_pic_cnt_present_flag(&self) -> u32 {
3391 unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) }
3392 }
3393 #[inline]
3394 pub fn set_redundant_pic_cnt_present_flag(&mut self, val: u32) {
3395 unsafe {
3396 let val: u32 = ::std::mem::transmute(val);
3397 self._bitfield_1.set(10usize, 1u8, val as u64)
3398 }
3399 }
3400 #[inline]
3401 pub fn pic_order_present_flag(&self) -> u32 {
3402 unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) }
3403 }
3404 #[inline]
3405 pub fn set_pic_order_present_flag(&mut self, val: u32) {
3406 unsafe {
3407 let val: u32 = ::std::mem::transmute(val);
3408 self._bitfield_1.set(11usize, 1u8, val as u64)
3409 }
3410 }
3411 #[inline]
3412 pub fn pic_scaling_matrix_present_flag(&self) -> u32 {
3413 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u32) }
3414 }
3415 #[inline]
3416 pub fn set_pic_scaling_matrix_present_flag(&mut self, val: u32) {
3417 unsafe {
3418 let val: u32 = ::std::mem::transmute(val);
3419 self._bitfield_1.set(12usize, 1u8, val as u64)
3420 }
3421 }
3422 #[inline]
3423 pub fn new_bitfield_1(
3424 idr_pic_flag: u32,
3425 reference_pic_flag: u32,
3426 entropy_coding_mode_flag: u32,
3427 weighted_pred_flag: u32,
3428 weighted_bipred_idc: u32,
3429 constrained_intra_pred_flag: u32,
3430 transform_8x8_mode_flag: u32,
3431 deblocking_filter_control_present_flag: u32,
3432 redundant_pic_cnt_present_flag: u32,
3433 pic_order_present_flag: u32,
3434 pic_scaling_matrix_present_flag: u32,
3435 ) -> __BindgenBitfieldUnit<[u8; 2usize]> {
3436 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default();
3437 __bindgen_bitfield_unit.set(0usize, 1u8, {
3438 let idr_pic_flag: u32 = unsafe { ::std::mem::transmute(idr_pic_flag) };
3439 idr_pic_flag as u64
3440 });
3441 __bindgen_bitfield_unit.set(1usize, 2u8, {
3442 let reference_pic_flag: u32 = unsafe { ::std::mem::transmute(reference_pic_flag) };
3443 reference_pic_flag as u64
3444 });
3445 __bindgen_bitfield_unit.set(3usize, 1u8, {
3446 let entropy_coding_mode_flag: u32 =
3447 unsafe { ::std::mem::transmute(entropy_coding_mode_flag) };
3448 entropy_coding_mode_flag as u64
3449 });
3450 __bindgen_bitfield_unit.set(4usize, 1u8, {
3451 let weighted_pred_flag: u32 = unsafe { ::std::mem::transmute(weighted_pred_flag) };
3452 weighted_pred_flag as u64
3453 });
3454 __bindgen_bitfield_unit.set(5usize, 2u8, {
3455 let weighted_bipred_idc: u32 = unsafe { ::std::mem::transmute(weighted_bipred_idc) };
3456 weighted_bipred_idc as u64
3457 });
3458 __bindgen_bitfield_unit.set(7usize, 1u8, {
3459 let constrained_intra_pred_flag: u32 =
3460 unsafe { ::std::mem::transmute(constrained_intra_pred_flag) };
3461 constrained_intra_pred_flag as u64
3462 });
3463 __bindgen_bitfield_unit.set(8usize, 1u8, {
3464 let transform_8x8_mode_flag: u32 =
3465 unsafe { ::std::mem::transmute(transform_8x8_mode_flag) };
3466 transform_8x8_mode_flag as u64
3467 });
3468 __bindgen_bitfield_unit.set(9usize, 1u8, {
3469 let deblocking_filter_control_present_flag: u32 =
3470 unsafe { ::std::mem::transmute(deblocking_filter_control_present_flag) };
3471 deblocking_filter_control_present_flag as u64
3472 });
3473 __bindgen_bitfield_unit.set(10usize, 1u8, {
3474 let redundant_pic_cnt_present_flag: u32 =
3475 unsafe { ::std::mem::transmute(redundant_pic_cnt_present_flag) };
3476 redundant_pic_cnt_present_flag as u64
3477 });
3478 __bindgen_bitfield_unit.set(11usize, 1u8, {
3479 let pic_order_present_flag: u32 =
3480 unsafe { ::std::mem::transmute(pic_order_present_flag) };
3481 pic_order_present_flag as u64
3482 });
3483 __bindgen_bitfield_unit.set(12usize, 1u8, {
3484 let pic_scaling_matrix_present_flag: u32 =
3485 unsafe { ::std::mem::transmute(pic_scaling_matrix_present_flag) };
3486 pic_scaling_matrix_present_flag as u64
3487 });
3488 __bindgen_bitfield_unit
3489 }
3490}
3491impl Default for _VAEncPictureParameterBufferH264__bindgen_ty_1 {
3492 fn default() -> Self {
3493 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3494 unsafe {
3495 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3496 s.assume_init()
3497 }
3498 }
3499}
3500impl Default for _VAEncPictureParameterBufferH264 {
3501 fn default() -> Self {
3502 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3503 unsafe {
3504 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3505 s.assume_init()
3506 }
3507 }
3508}
3509pub type VAEncPictureParameterBufferH264 = _VAEncPictureParameterBufferH264;
3510#[repr(C)]
3511#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
3512pub struct _VAEncQPBufferH264 {
3513 pub qp: u8,
3514}
3515pub type VAEncQPBufferH264 = _VAEncQPBufferH264;
3516#[repr(C)]
3517#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
3518pub struct _VAEncSliceParameterBufferH264 {
3519 pub macroblock_address: u32,
3520 pub num_macroblocks: u32,
3521 pub macroblock_info: VABufferID,
3522 pub slice_type: u8,
3523 pub pic_parameter_set_id: u8,
3524 pub idr_pic_id: u16,
3525 pub pic_order_cnt_lsb: u16,
3526 pub delta_pic_order_cnt_bottom: i32,
3527 pub delta_pic_order_cnt: [i32; 2usize],
3528 pub direct_spatial_mv_pred_flag: u8,
3529 pub num_ref_idx_active_override_flag: u8,
3530 pub num_ref_idx_l0_active_minus1: u8,
3531 pub num_ref_idx_l1_active_minus1: u8,
3532 pub RefPicList0: [VAPictureH264; 32usize],
3533 pub RefPicList1: [VAPictureH264; 32usize],
3534 pub luma_log2_weight_denom: u8,
3535 pub chroma_log2_weight_denom: u8,
3536 pub luma_weight_l0_flag: u8,
3537 pub luma_weight_l0: [::std::os::raw::c_short; 32usize],
3538 pub luma_offset_l0: [::std::os::raw::c_short; 32usize],
3539 pub chroma_weight_l0_flag: u8,
3540 pub chroma_weight_l0: [[::std::os::raw::c_short; 2usize]; 32usize],
3541 pub chroma_offset_l0: [[::std::os::raw::c_short; 2usize]; 32usize],
3542 pub luma_weight_l1_flag: u8,
3543 pub luma_weight_l1: [::std::os::raw::c_short; 32usize],
3544 pub luma_offset_l1: [::std::os::raw::c_short; 32usize],
3545 pub chroma_weight_l1_flag: u8,
3546 pub chroma_weight_l1: [[::std::os::raw::c_short; 2usize]; 32usize],
3547 pub chroma_offset_l1: [[::std::os::raw::c_short; 2usize]; 32usize],
3548 pub cabac_init_idc: u8,
3549 pub slice_qp_delta: i8,
3550 pub disable_deblocking_filter_idc: u8,
3551 pub slice_alpha_c0_offset_div2: i8,
3552 pub slice_beta_offset_div2: i8,
3553 pub va_reserved: [u32; 4usize],
3554}
3555pub type VAEncSliceParameterBufferH264 = _VAEncSliceParameterBufferH264;
3556#[repr(C)]
3557#[derive(Copy, Clone)]
3558pub struct _VAEncMacroblockParameterBufferH264 {
3559 pub qp: u8,
3560 pub info: _VAEncMacroblockParameterBufferH264__bindgen_ty_1,
3561 pub va_reserved: [u32; 4usize],
3562}
3563#[repr(C)]
3564#[derive(Copy, Clone)]
3565pub union _VAEncMacroblockParameterBufferH264__bindgen_ty_1 {
3566 pub intra_fields: _VAEncMacroblockParameterBufferH264__bindgen_ty_1__bindgen_ty_1,
3567 pub inter_fields: _VAEncMacroblockParameterBufferH264__bindgen_ty_1__bindgen_ty_2,
3568}
3569#[repr(C)]
3570#[derive(Copy, Clone)]
3571pub union _VAEncMacroblockParameterBufferH264__bindgen_ty_1__bindgen_ty_1 {
3572 pub bits: _VAEncMacroblockParameterBufferH264__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
3573 pub value: u32,
3574}
3575#[repr(C)]
3576#[repr(align(4))]
3577#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
3578pub struct _VAEncMacroblockParameterBufferH264__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 {
3579 pub _bitfield_align_1: [u8; 0],
3580 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
3581 pub __bindgen_padding_0: u16,
3582}
3583impl _VAEncMacroblockParameterBufferH264__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 {
3584 #[inline]
3585 pub fn pred_avail_override_flag(&self) -> u32 {
3586 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
3587 }
3588 #[inline]
3589 pub fn set_pred_avail_override_flag(&mut self, val: u32) {
3590 unsafe {
3591 let val: u32 = ::std::mem::transmute(val);
3592 self._bitfield_1.set(0usize, 1u8, val as u64)
3593 }
3594 }
3595 #[inline]
3596 pub fn pred_avail_flags(&self) -> u32 {
3597 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 8u8) as u32) }
3598 }
3599 #[inline]
3600 pub fn set_pred_avail_flags(&mut self, val: u32) {
3601 unsafe {
3602 let val: u32 = ::std::mem::transmute(val);
3603 self._bitfield_1.set(1usize, 8u8, val as u64)
3604 }
3605 }
3606 #[inline]
3607 pub fn new_bitfield_1(
3608 pred_avail_override_flag: u32,
3609 pred_avail_flags: u32,
3610 ) -> __BindgenBitfieldUnit<[u8; 2usize]> {
3611 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default();
3612 __bindgen_bitfield_unit.set(0usize, 1u8, {
3613 let pred_avail_override_flag: u32 =
3614 unsafe { ::std::mem::transmute(pred_avail_override_flag) };
3615 pred_avail_override_flag as u64
3616 });
3617 __bindgen_bitfield_unit.set(1usize, 8u8, {
3618 let pred_avail_flags: u32 = unsafe { ::std::mem::transmute(pred_avail_flags) };
3619 pred_avail_flags as u64
3620 });
3621 __bindgen_bitfield_unit
3622 }
3623}
3624impl Default for _VAEncMacroblockParameterBufferH264__bindgen_ty_1__bindgen_ty_1 {
3625 fn default() -> Self {
3626 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3627 unsafe {
3628 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3629 s.assume_init()
3630 }
3631 }
3632}
3633#[repr(C)]
3634#[derive(Copy, Clone)]
3635pub union _VAEncMacroblockParameterBufferH264__bindgen_ty_1__bindgen_ty_2 {
3636 pub bits: _VAEncMacroblockParameterBufferH264__bindgen_ty_1__bindgen_ty_2__bindgen_ty_1,
3637 pub value: u32,
3638}
3639#[repr(C)]
3640#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
3641pub struct _VAEncMacroblockParameterBufferH264__bindgen_ty_1__bindgen_ty_2__bindgen_ty_1 {
3642 pub reserved: u32,
3643}
3644impl Default for _VAEncMacroblockParameterBufferH264__bindgen_ty_1__bindgen_ty_2 {
3645 fn default() -> Self {
3646 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3647 unsafe {
3648 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3649 s.assume_init()
3650 }
3651 }
3652}
3653impl Default for _VAEncMacroblockParameterBufferH264__bindgen_ty_1 {
3654 fn default() -> Self {
3655 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3656 unsafe {
3657 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3658 s.assume_init()
3659 }
3660 }
3661}
3662impl Default for _VAEncMacroblockParameterBufferH264 {
3663 fn default() -> Self {
3664 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3665 unsafe {
3666 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3667 s.assume_init()
3668 }
3669 }
3670}
3671pub type VAEncMacroblockParameterBufferH264 = _VAEncMacroblockParameterBufferH264;
3672#[repr(C)]
3673#[derive(Copy, Clone)]
3674pub struct _VAEncMiscParameterSubMbPartPelH264 {
3675 pub disable_inter_sub_mb_partition: u32,
3676 pub inter_sub_mb_partition_mask: _VAEncMiscParameterSubMbPartPelH264__bindgen_ty_1,
3677 pub enable_sub_pel_mode: u32,
3678 pub sub_pel_mode: u8,
3679 pub reserved: [u8; 3usize],
3680}
3681#[repr(C)]
3682#[derive(Copy, Clone)]
3683pub union _VAEncMiscParameterSubMbPartPelH264__bindgen_ty_1 {
3684 pub bits: _VAEncMiscParameterSubMbPartPelH264__bindgen_ty_1__bindgen_ty_1,
3685 pub value: u8,
3686}
3687#[repr(C)]
3688#[repr(align(4))]
3689#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
3690pub struct _VAEncMiscParameterSubMbPartPelH264__bindgen_ty_1__bindgen_ty_1 {
3691 pub _bitfield_align_1: [u8; 0],
3692 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
3693 pub __bindgen_padding_0: [u8; 3usize],
3694}
3695impl _VAEncMiscParameterSubMbPartPelH264__bindgen_ty_1__bindgen_ty_1 {
3696 #[inline]
3697 pub fn disable_16x16_inter_mb_partition(&self) -> u32 {
3698 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
3699 }
3700 #[inline]
3701 pub fn set_disable_16x16_inter_mb_partition(&mut self, val: u32) {
3702 unsafe {
3703 let val: u32 = ::std::mem::transmute(val);
3704 self._bitfield_1.set(0usize, 1u8, val as u64)
3705 }
3706 }
3707 #[inline]
3708 pub fn disable_16x8_inter_mb_partition(&self) -> u32 {
3709 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
3710 }
3711 #[inline]
3712 pub fn set_disable_16x8_inter_mb_partition(&mut self, val: u32) {
3713 unsafe {
3714 let val: u32 = ::std::mem::transmute(val);
3715 self._bitfield_1.set(1usize, 1u8, val as u64)
3716 }
3717 }
3718 #[inline]
3719 pub fn disable_8x16_inter_mb_partition(&self) -> u32 {
3720 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
3721 }
3722 #[inline]
3723 pub fn set_disable_8x16_inter_mb_partition(&mut self, val: u32) {
3724 unsafe {
3725 let val: u32 = ::std::mem::transmute(val);
3726 self._bitfield_1.set(2usize, 1u8, val as u64)
3727 }
3728 }
3729 #[inline]
3730 pub fn disable_8x8_inter_mb_partition(&self) -> u32 {
3731 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
3732 }
3733 #[inline]
3734 pub fn set_disable_8x8_inter_mb_partition(&mut self, val: u32) {
3735 unsafe {
3736 let val: u32 = ::std::mem::transmute(val);
3737 self._bitfield_1.set(3usize, 1u8, val as u64)
3738 }
3739 }
3740 #[inline]
3741 pub fn disable_8x4_inter_mb_partition(&self) -> u32 {
3742 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
3743 }
3744 #[inline]
3745 pub fn set_disable_8x4_inter_mb_partition(&mut self, val: u32) {
3746 unsafe {
3747 let val: u32 = ::std::mem::transmute(val);
3748 self._bitfield_1.set(4usize, 1u8, val as u64)
3749 }
3750 }
3751 #[inline]
3752 pub fn disable_4x8_inter_mb_partition(&self) -> u32 {
3753 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
3754 }
3755 #[inline]
3756 pub fn set_disable_4x8_inter_mb_partition(&mut self, val: u32) {
3757 unsafe {
3758 let val: u32 = ::std::mem::transmute(val);
3759 self._bitfield_1.set(5usize, 1u8, val as u64)
3760 }
3761 }
3762 #[inline]
3763 pub fn disable_4x4_inter_mb_partition(&self) -> u32 {
3764 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) }
3765 }
3766 #[inline]
3767 pub fn set_disable_4x4_inter_mb_partition(&mut self, val: u32) {
3768 unsafe {
3769 let val: u32 = ::std::mem::transmute(val);
3770 self._bitfield_1.set(6usize, 1u8, val as u64)
3771 }
3772 }
3773 #[inline]
3774 pub fn reserved(&self) -> u32 {
3775 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) }
3776 }
3777 #[inline]
3778 pub fn set_reserved(&mut self, val: u32) {
3779 unsafe {
3780 let val: u32 = ::std::mem::transmute(val);
3781 self._bitfield_1.set(7usize, 1u8, val as u64)
3782 }
3783 }
3784 #[inline]
3785 pub fn new_bitfield_1(
3786 disable_16x16_inter_mb_partition: u32,
3787 disable_16x8_inter_mb_partition: u32,
3788 disable_8x16_inter_mb_partition: u32,
3789 disable_8x8_inter_mb_partition: u32,
3790 disable_8x4_inter_mb_partition: u32,
3791 disable_4x8_inter_mb_partition: u32,
3792 disable_4x4_inter_mb_partition: u32,
3793 reserved: u32,
3794 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
3795 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
3796 __bindgen_bitfield_unit.set(0usize, 1u8, {
3797 let disable_16x16_inter_mb_partition: u32 =
3798 unsafe { ::std::mem::transmute(disable_16x16_inter_mb_partition) };
3799 disable_16x16_inter_mb_partition as u64
3800 });
3801 __bindgen_bitfield_unit.set(1usize, 1u8, {
3802 let disable_16x8_inter_mb_partition: u32 =
3803 unsafe { ::std::mem::transmute(disable_16x8_inter_mb_partition) };
3804 disable_16x8_inter_mb_partition as u64
3805 });
3806 __bindgen_bitfield_unit.set(2usize, 1u8, {
3807 let disable_8x16_inter_mb_partition: u32 =
3808 unsafe { ::std::mem::transmute(disable_8x16_inter_mb_partition) };
3809 disable_8x16_inter_mb_partition as u64
3810 });
3811 __bindgen_bitfield_unit.set(3usize, 1u8, {
3812 let disable_8x8_inter_mb_partition: u32 =
3813 unsafe { ::std::mem::transmute(disable_8x8_inter_mb_partition) };
3814 disable_8x8_inter_mb_partition as u64
3815 });
3816 __bindgen_bitfield_unit.set(4usize, 1u8, {
3817 let disable_8x4_inter_mb_partition: u32 =
3818 unsafe { ::std::mem::transmute(disable_8x4_inter_mb_partition) };
3819 disable_8x4_inter_mb_partition as u64
3820 });
3821 __bindgen_bitfield_unit.set(5usize, 1u8, {
3822 let disable_4x8_inter_mb_partition: u32 =
3823 unsafe { ::std::mem::transmute(disable_4x8_inter_mb_partition) };
3824 disable_4x8_inter_mb_partition as u64
3825 });
3826 __bindgen_bitfield_unit.set(6usize, 1u8, {
3827 let disable_4x4_inter_mb_partition: u32 =
3828 unsafe { ::std::mem::transmute(disable_4x4_inter_mb_partition) };
3829 disable_4x4_inter_mb_partition as u64
3830 });
3831 __bindgen_bitfield_unit.set(7usize, 1u8, {
3832 let reserved: u32 = unsafe { ::std::mem::transmute(reserved) };
3833 reserved as u64
3834 });
3835 __bindgen_bitfield_unit
3836 }
3837}
3838impl Default for _VAEncMiscParameterSubMbPartPelH264__bindgen_ty_1 {
3839 fn default() -> Self {
3840 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3841 unsafe {
3842 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3843 s.assume_init()
3844 }
3845 }
3846}
3847impl Default for _VAEncMiscParameterSubMbPartPelH264 {
3848 fn default() -> Self {
3849 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3850 unsafe {
3851 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3852 s.assume_init()
3853 }
3854 }
3855}
3856pub type VAEncMiscParameterSubMbPartPelH264 = _VAEncMiscParameterSubMbPartPelH264;
3857pub type VAQMatrixBufferMPEG2 = VAIQMatrixBufferMPEG2;
3858pub mod VAEncPackedHeaderTypeMPEG2 {
3859 pub type Type = ::std::os::raw::c_uint;
3860 pub const VAEncPackedHeaderMPEG2_SPS: Type = 1;
3861 pub const VAEncPackedHeaderMPEG2_PPS: Type = 2;
3862 pub const VAEncPackedHeaderMPEG2_Slice: Type = 3;
3863}
3864#[repr(C)]
3865#[derive(Copy, Clone)]
3866pub struct _VAEncSequenceParameterBufferMPEG2 {
3867 pub intra_period: u32,
3868 pub ip_period: u32,
3869 pub picture_width: u16,
3870 pub picture_height: u16,
3871 pub bits_per_second: u32,
3872 pub frame_rate: f32,
3873 pub aspect_ratio_information: u16,
3874 pub vbv_buffer_size: u32,
3875 pub sequence_extension: _VAEncSequenceParameterBufferMPEG2__bindgen_ty_1,
3876 pub new_gop_header: u32,
3877 pub gop_header: _VAEncSequenceParameterBufferMPEG2__bindgen_ty_2,
3878 pub va_reserved: [u32; 4usize],
3879}
3880#[repr(C)]
3881#[derive(Copy, Clone)]
3882pub union _VAEncSequenceParameterBufferMPEG2__bindgen_ty_1 {
3883 pub bits: _VAEncSequenceParameterBufferMPEG2__bindgen_ty_1__bindgen_ty_1,
3884 pub value: u32,
3885}
3886#[repr(C)]
3887#[repr(align(4))]
3888#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
3889pub struct _VAEncSequenceParameterBufferMPEG2__bindgen_ty_1__bindgen_ty_1 {
3890 pub _bitfield_align_1: [u8; 0],
3891 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 3usize]>,
3892 pub __bindgen_padding_0: u8,
3893}
3894impl _VAEncSequenceParameterBufferMPEG2__bindgen_ty_1__bindgen_ty_1 {
3895 #[inline]
3896 pub fn profile_and_level_indication(&self) -> u32 {
3897 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 8u8) as u32) }
3898 }
3899 #[inline]
3900 pub fn set_profile_and_level_indication(&mut self, val: u32) {
3901 unsafe {
3902 let val: u32 = ::std::mem::transmute(val);
3903 self._bitfield_1.set(0usize, 8u8, val as u64)
3904 }
3905 }
3906 #[inline]
3907 pub fn progressive_sequence(&self) -> u32 {
3908 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) }
3909 }
3910 #[inline]
3911 pub fn set_progressive_sequence(&mut self, val: u32) {
3912 unsafe {
3913 let val: u32 = ::std::mem::transmute(val);
3914 self._bitfield_1.set(8usize, 1u8, val as u64)
3915 }
3916 }
3917 #[inline]
3918 pub fn chroma_format(&self) -> u32 {
3919 unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 2u8) as u32) }
3920 }
3921 #[inline]
3922 pub fn set_chroma_format(&mut self, val: u32) {
3923 unsafe {
3924 let val: u32 = ::std::mem::transmute(val);
3925 self._bitfield_1.set(9usize, 2u8, val as u64)
3926 }
3927 }
3928 #[inline]
3929 pub fn low_delay(&self) -> u32 {
3930 unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) }
3931 }
3932 #[inline]
3933 pub fn set_low_delay(&mut self, val: u32) {
3934 unsafe {
3935 let val: u32 = ::std::mem::transmute(val);
3936 self._bitfield_1.set(11usize, 1u8, val as u64)
3937 }
3938 }
3939 #[inline]
3940 pub fn frame_rate_extension_n(&self) -> u32 {
3941 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 2u8) as u32) }
3942 }
3943 #[inline]
3944 pub fn set_frame_rate_extension_n(&mut self, val: u32) {
3945 unsafe {
3946 let val: u32 = ::std::mem::transmute(val);
3947 self._bitfield_1.set(12usize, 2u8, val as u64)
3948 }
3949 }
3950 #[inline]
3951 pub fn frame_rate_extension_d(&self) -> u32 {
3952 unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 5u8) as u32) }
3953 }
3954 #[inline]
3955 pub fn set_frame_rate_extension_d(&mut self, val: u32) {
3956 unsafe {
3957 let val: u32 = ::std::mem::transmute(val);
3958 self._bitfield_1.set(14usize, 5u8, val as u64)
3959 }
3960 }
3961 #[inline]
3962 pub fn new_bitfield_1(
3963 profile_and_level_indication: u32,
3964 progressive_sequence: u32,
3965 chroma_format: u32,
3966 low_delay: u32,
3967 frame_rate_extension_n: u32,
3968 frame_rate_extension_d: u32,
3969 ) -> __BindgenBitfieldUnit<[u8; 3usize]> {
3970 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 3usize]> = Default::default();
3971 __bindgen_bitfield_unit.set(0usize, 8u8, {
3972 let profile_and_level_indication: u32 =
3973 unsafe { ::std::mem::transmute(profile_and_level_indication) };
3974 profile_and_level_indication as u64
3975 });
3976 __bindgen_bitfield_unit.set(8usize, 1u8, {
3977 let progressive_sequence: u32 = unsafe { ::std::mem::transmute(progressive_sequence) };
3978 progressive_sequence as u64
3979 });
3980 __bindgen_bitfield_unit.set(9usize, 2u8, {
3981 let chroma_format: u32 = unsafe { ::std::mem::transmute(chroma_format) };
3982 chroma_format as u64
3983 });
3984 __bindgen_bitfield_unit.set(11usize, 1u8, {
3985 let low_delay: u32 = unsafe { ::std::mem::transmute(low_delay) };
3986 low_delay as u64
3987 });
3988 __bindgen_bitfield_unit.set(12usize, 2u8, {
3989 let frame_rate_extension_n: u32 =
3990 unsafe { ::std::mem::transmute(frame_rate_extension_n) };
3991 frame_rate_extension_n as u64
3992 });
3993 __bindgen_bitfield_unit.set(14usize, 5u8, {
3994 let frame_rate_extension_d: u32 =
3995 unsafe { ::std::mem::transmute(frame_rate_extension_d) };
3996 frame_rate_extension_d as u64
3997 });
3998 __bindgen_bitfield_unit
3999 }
4000}
4001impl Default for _VAEncSequenceParameterBufferMPEG2__bindgen_ty_1 {
4002 fn default() -> Self {
4003 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4004 unsafe {
4005 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4006 s.assume_init()
4007 }
4008 }
4009}
4010#[repr(C)]
4011#[derive(Copy, Clone)]
4012pub union _VAEncSequenceParameterBufferMPEG2__bindgen_ty_2 {
4013 pub bits: _VAEncSequenceParameterBufferMPEG2__bindgen_ty_2__bindgen_ty_1,
4014 pub value: u32,
4015}
4016#[repr(C)]
4017#[repr(align(4))]
4018#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
4019pub struct _VAEncSequenceParameterBufferMPEG2__bindgen_ty_2__bindgen_ty_1 {
4020 pub _bitfield_align_1: [u32; 0],
4021 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
4022}
4023impl _VAEncSequenceParameterBufferMPEG2__bindgen_ty_2__bindgen_ty_1 {
4024 #[inline]
4025 pub fn time_code(&self) -> u32 {
4026 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 25u8) as u32) }
4027 }
4028 #[inline]
4029 pub fn set_time_code(&mut self, val: u32) {
4030 unsafe {
4031 let val: u32 = ::std::mem::transmute(val);
4032 self._bitfield_1.set(0usize, 25u8, val as u64)
4033 }
4034 }
4035 #[inline]
4036 pub fn closed_gop(&self) -> u32 {
4037 unsafe { ::std::mem::transmute(self._bitfield_1.get(25usize, 1u8) as u32) }
4038 }
4039 #[inline]
4040 pub fn set_closed_gop(&mut self, val: u32) {
4041 unsafe {
4042 let val: u32 = ::std::mem::transmute(val);
4043 self._bitfield_1.set(25usize, 1u8, val as u64)
4044 }
4045 }
4046 #[inline]
4047 pub fn broken_link(&self) -> u32 {
4048 unsafe { ::std::mem::transmute(self._bitfield_1.get(26usize, 1u8) as u32) }
4049 }
4050 #[inline]
4051 pub fn set_broken_link(&mut self, val: u32) {
4052 unsafe {
4053 let val: u32 = ::std::mem::transmute(val);
4054 self._bitfield_1.set(26usize, 1u8, val as u64)
4055 }
4056 }
4057 #[inline]
4058 pub fn new_bitfield_1(
4059 time_code: u32,
4060 closed_gop: u32,
4061 broken_link: u32,
4062 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
4063 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
4064 __bindgen_bitfield_unit.set(0usize, 25u8, {
4065 let time_code: u32 = unsafe { ::std::mem::transmute(time_code) };
4066 time_code as u64
4067 });
4068 __bindgen_bitfield_unit.set(25usize, 1u8, {
4069 let closed_gop: u32 = unsafe { ::std::mem::transmute(closed_gop) };
4070 closed_gop as u64
4071 });
4072 __bindgen_bitfield_unit.set(26usize, 1u8, {
4073 let broken_link: u32 = unsafe { ::std::mem::transmute(broken_link) };
4074 broken_link as u64
4075 });
4076 __bindgen_bitfield_unit
4077 }
4078}
4079impl Default for _VAEncSequenceParameterBufferMPEG2__bindgen_ty_2 {
4080 fn default() -> Self {
4081 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4082 unsafe {
4083 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4084 s.assume_init()
4085 }
4086 }
4087}
4088impl Default for _VAEncSequenceParameterBufferMPEG2 {
4089 fn default() -> Self {
4090 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4091 unsafe {
4092 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4093 s.assume_init()
4094 }
4095 }
4096}
4097pub type VAEncSequenceParameterBufferMPEG2 = _VAEncSequenceParameterBufferMPEG2;
4098#[repr(C)]
4099#[derive(Copy, Clone)]
4100pub struct _VAEncPictureParameterBufferMPEG2 {
4101 pub forward_reference_picture: VASurfaceID,
4102 pub backward_reference_picture: VASurfaceID,
4103 pub reconstructed_picture: VASurfaceID,
4104 pub coded_buf: VABufferID,
4105 pub last_picture: u8,
4106 pub picture_type: VAEncPictureType::Type,
4107 pub temporal_reference: u32,
4108 pub vbv_delay: u32,
4109 pub f_code: [[u8; 2usize]; 2usize],
4110 pub picture_coding_extension: _VAEncPictureParameterBufferMPEG2__bindgen_ty_1,
4111 pub composite_display: _VAEncPictureParameterBufferMPEG2__bindgen_ty_2,
4112 pub va_reserved: [u32; 4usize],
4113}
4114#[repr(C)]
4115#[derive(Copy, Clone)]
4116pub union _VAEncPictureParameterBufferMPEG2__bindgen_ty_1 {
4117 pub bits: _VAEncPictureParameterBufferMPEG2__bindgen_ty_1__bindgen_ty_1,
4118 pub value: u32,
4119}
4120#[repr(C)]
4121#[repr(align(4))]
4122#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
4123pub struct _VAEncPictureParameterBufferMPEG2__bindgen_ty_1__bindgen_ty_1 {
4124 pub _bitfield_align_1: [u8; 0],
4125 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
4126 pub __bindgen_padding_0: u16,
4127}
4128impl _VAEncPictureParameterBufferMPEG2__bindgen_ty_1__bindgen_ty_1 {
4129 #[inline]
4130 pub fn intra_dc_precision(&self) -> u32 {
4131 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u32) }
4132 }
4133 #[inline]
4134 pub fn set_intra_dc_precision(&mut self, val: u32) {
4135 unsafe {
4136 let val: u32 = ::std::mem::transmute(val);
4137 self._bitfield_1.set(0usize, 2u8, val as u64)
4138 }
4139 }
4140 #[inline]
4141 pub fn picture_structure(&self) -> u32 {
4142 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 2u8) as u32) }
4143 }
4144 #[inline]
4145 pub fn set_picture_structure(&mut self, val: u32) {
4146 unsafe {
4147 let val: u32 = ::std::mem::transmute(val);
4148 self._bitfield_1.set(2usize, 2u8, val as u64)
4149 }
4150 }
4151 #[inline]
4152 pub fn top_field_first(&self) -> u32 {
4153 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
4154 }
4155 #[inline]
4156 pub fn set_top_field_first(&mut self, val: u32) {
4157 unsafe {
4158 let val: u32 = ::std::mem::transmute(val);
4159 self._bitfield_1.set(4usize, 1u8, val as u64)
4160 }
4161 }
4162 #[inline]
4163 pub fn frame_pred_frame_dct(&self) -> u32 {
4164 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
4165 }
4166 #[inline]
4167 pub fn set_frame_pred_frame_dct(&mut self, val: u32) {
4168 unsafe {
4169 let val: u32 = ::std::mem::transmute(val);
4170 self._bitfield_1.set(5usize, 1u8, val as u64)
4171 }
4172 }
4173 #[inline]
4174 pub fn concealment_motion_vectors(&self) -> u32 {
4175 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) }
4176 }
4177 #[inline]
4178 pub fn set_concealment_motion_vectors(&mut self, val: u32) {
4179 unsafe {
4180 let val: u32 = ::std::mem::transmute(val);
4181 self._bitfield_1.set(6usize, 1u8, val as u64)
4182 }
4183 }
4184 #[inline]
4185 pub fn q_scale_type(&self) -> u32 {
4186 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) }
4187 }
4188 #[inline]
4189 pub fn set_q_scale_type(&mut self, val: u32) {
4190 unsafe {
4191 let val: u32 = ::std::mem::transmute(val);
4192 self._bitfield_1.set(7usize, 1u8, val as u64)
4193 }
4194 }
4195 #[inline]
4196 pub fn intra_vlc_format(&self) -> u32 {
4197 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) }
4198 }
4199 #[inline]
4200 pub fn set_intra_vlc_format(&mut self, val: u32) {
4201 unsafe {
4202 let val: u32 = ::std::mem::transmute(val);
4203 self._bitfield_1.set(8usize, 1u8, val as u64)
4204 }
4205 }
4206 #[inline]
4207 pub fn alternate_scan(&self) -> u32 {
4208 unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) }
4209 }
4210 #[inline]
4211 pub fn set_alternate_scan(&mut self, val: u32) {
4212 unsafe {
4213 let val: u32 = ::std::mem::transmute(val);
4214 self._bitfield_1.set(9usize, 1u8, val as u64)
4215 }
4216 }
4217 #[inline]
4218 pub fn repeat_first_field(&self) -> u32 {
4219 unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) }
4220 }
4221 #[inline]
4222 pub fn set_repeat_first_field(&mut self, val: u32) {
4223 unsafe {
4224 let val: u32 = ::std::mem::transmute(val);
4225 self._bitfield_1.set(10usize, 1u8, val as u64)
4226 }
4227 }
4228 #[inline]
4229 pub fn progressive_frame(&self) -> u32 {
4230 unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) }
4231 }
4232 #[inline]
4233 pub fn set_progressive_frame(&mut self, val: u32) {
4234 unsafe {
4235 let val: u32 = ::std::mem::transmute(val);
4236 self._bitfield_1.set(11usize, 1u8, val as u64)
4237 }
4238 }
4239 #[inline]
4240 pub fn composite_display_flag(&self) -> u32 {
4241 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u32) }
4242 }
4243 #[inline]
4244 pub fn set_composite_display_flag(&mut self, val: u32) {
4245 unsafe {
4246 let val: u32 = ::std::mem::transmute(val);
4247 self._bitfield_1.set(12usize, 1u8, val as u64)
4248 }
4249 }
4250 #[inline]
4251 pub fn new_bitfield_1(
4252 intra_dc_precision: u32,
4253 picture_structure: u32,
4254 top_field_first: u32,
4255 frame_pred_frame_dct: u32,
4256 concealment_motion_vectors: u32,
4257 q_scale_type: u32,
4258 intra_vlc_format: u32,
4259 alternate_scan: u32,
4260 repeat_first_field: u32,
4261 progressive_frame: u32,
4262 composite_display_flag: u32,
4263 ) -> __BindgenBitfieldUnit<[u8; 2usize]> {
4264 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default();
4265 __bindgen_bitfield_unit.set(0usize, 2u8, {
4266 let intra_dc_precision: u32 = unsafe { ::std::mem::transmute(intra_dc_precision) };
4267 intra_dc_precision as u64
4268 });
4269 __bindgen_bitfield_unit.set(2usize, 2u8, {
4270 let picture_structure: u32 = unsafe { ::std::mem::transmute(picture_structure) };
4271 picture_structure as u64
4272 });
4273 __bindgen_bitfield_unit.set(4usize, 1u8, {
4274 let top_field_first: u32 = unsafe { ::std::mem::transmute(top_field_first) };
4275 top_field_first as u64
4276 });
4277 __bindgen_bitfield_unit.set(5usize, 1u8, {
4278 let frame_pred_frame_dct: u32 = unsafe { ::std::mem::transmute(frame_pred_frame_dct) };
4279 frame_pred_frame_dct as u64
4280 });
4281 __bindgen_bitfield_unit.set(6usize, 1u8, {
4282 let concealment_motion_vectors: u32 =
4283 unsafe { ::std::mem::transmute(concealment_motion_vectors) };
4284 concealment_motion_vectors as u64
4285 });
4286 __bindgen_bitfield_unit.set(7usize, 1u8, {
4287 let q_scale_type: u32 = unsafe { ::std::mem::transmute(q_scale_type) };
4288 q_scale_type as u64
4289 });
4290 __bindgen_bitfield_unit.set(8usize, 1u8, {
4291 let intra_vlc_format: u32 = unsafe { ::std::mem::transmute(intra_vlc_format) };
4292 intra_vlc_format as u64
4293 });
4294 __bindgen_bitfield_unit.set(9usize, 1u8, {
4295 let alternate_scan: u32 = unsafe { ::std::mem::transmute(alternate_scan) };
4296 alternate_scan as u64
4297 });
4298 __bindgen_bitfield_unit.set(10usize, 1u8, {
4299 let repeat_first_field: u32 = unsafe { ::std::mem::transmute(repeat_first_field) };
4300 repeat_first_field as u64
4301 });
4302 __bindgen_bitfield_unit.set(11usize, 1u8, {
4303 let progressive_frame: u32 = unsafe { ::std::mem::transmute(progressive_frame) };
4304 progressive_frame as u64
4305 });
4306 __bindgen_bitfield_unit.set(12usize, 1u8, {
4307 let composite_display_flag: u32 =
4308 unsafe { ::std::mem::transmute(composite_display_flag) };
4309 composite_display_flag as u64
4310 });
4311 __bindgen_bitfield_unit
4312 }
4313}
4314impl Default for _VAEncPictureParameterBufferMPEG2__bindgen_ty_1 {
4315 fn default() -> Self {
4316 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4317 unsafe {
4318 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4319 s.assume_init()
4320 }
4321 }
4322}
4323#[repr(C)]
4324#[derive(Copy, Clone)]
4325pub union _VAEncPictureParameterBufferMPEG2__bindgen_ty_2 {
4326 pub bits: _VAEncPictureParameterBufferMPEG2__bindgen_ty_2__bindgen_ty_1,
4327 pub value: u32,
4328}
4329#[repr(C)]
4330#[repr(align(4))]
4331#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
4332pub struct _VAEncPictureParameterBufferMPEG2__bindgen_ty_2__bindgen_ty_1 {
4333 pub _bitfield_align_1: [u8; 0],
4334 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 3usize]>,
4335 pub __bindgen_padding_0: u8,
4336}
4337impl _VAEncPictureParameterBufferMPEG2__bindgen_ty_2__bindgen_ty_1 {
4338 #[inline]
4339 pub fn v_axis(&self) -> u32 {
4340 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
4341 }
4342 #[inline]
4343 pub fn set_v_axis(&mut self, val: u32) {
4344 unsafe {
4345 let val: u32 = ::std::mem::transmute(val);
4346 self._bitfield_1.set(0usize, 1u8, val as u64)
4347 }
4348 }
4349 #[inline]
4350 pub fn field_sequence(&self) -> u32 {
4351 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 3u8) as u32) }
4352 }
4353 #[inline]
4354 pub fn set_field_sequence(&mut self, val: u32) {
4355 unsafe {
4356 let val: u32 = ::std::mem::transmute(val);
4357 self._bitfield_1.set(1usize, 3u8, val as u64)
4358 }
4359 }
4360 #[inline]
4361 pub fn sub_carrier(&self) -> u32 {
4362 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
4363 }
4364 #[inline]
4365 pub fn set_sub_carrier(&mut self, val: u32) {
4366 unsafe {
4367 let val: u32 = ::std::mem::transmute(val);
4368 self._bitfield_1.set(4usize, 1u8, val as u64)
4369 }
4370 }
4371 #[inline]
4372 pub fn burst_amplitude(&self) -> u32 {
4373 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 7u8) as u32) }
4374 }
4375 #[inline]
4376 pub fn set_burst_amplitude(&mut self, val: u32) {
4377 unsafe {
4378 let val: u32 = ::std::mem::transmute(val);
4379 self._bitfield_1.set(5usize, 7u8, val as u64)
4380 }
4381 }
4382 #[inline]
4383 pub fn sub_carrier_phase(&self) -> u32 {
4384 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 8u8) as u32) }
4385 }
4386 #[inline]
4387 pub fn set_sub_carrier_phase(&mut self, val: u32) {
4388 unsafe {
4389 let val: u32 = ::std::mem::transmute(val);
4390 self._bitfield_1.set(12usize, 8u8, val as u64)
4391 }
4392 }
4393 #[inline]
4394 pub fn new_bitfield_1(
4395 v_axis: u32,
4396 field_sequence: u32,
4397 sub_carrier: u32,
4398 burst_amplitude: u32,
4399 sub_carrier_phase: u32,
4400 ) -> __BindgenBitfieldUnit<[u8; 3usize]> {
4401 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 3usize]> = Default::default();
4402 __bindgen_bitfield_unit.set(0usize, 1u8, {
4403 let v_axis: u32 = unsafe { ::std::mem::transmute(v_axis) };
4404 v_axis as u64
4405 });
4406 __bindgen_bitfield_unit.set(1usize, 3u8, {
4407 let field_sequence: u32 = unsafe { ::std::mem::transmute(field_sequence) };
4408 field_sequence as u64
4409 });
4410 __bindgen_bitfield_unit.set(4usize, 1u8, {
4411 let sub_carrier: u32 = unsafe { ::std::mem::transmute(sub_carrier) };
4412 sub_carrier as u64
4413 });
4414 __bindgen_bitfield_unit.set(5usize, 7u8, {
4415 let burst_amplitude: u32 = unsafe { ::std::mem::transmute(burst_amplitude) };
4416 burst_amplitude as u64
4417 });
4418 __bindgen_bitfield_unit.set(12usize, 8u8, {
4419 let sub_carrier_phase: u32 = unsafe { ::std::mem::transmute(sub_carrier_phase) };
4420 sub_carrier_phase as u64
4421 });
4422 __bindgen_bitfield_unit
4423 }
4424}
4425impl Default for _VAEncPictureParameterBufferMPEG2__bindgen_ty_2 {
4426 fn default() -> Self {
4427 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4428 unsafe {
4429 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4430 s.assume_init()
4431 }
4432 }
4433}
4434impl Default for _VAEncPictureParameterBufferMPEG2 {
4435 fn default() -> Self {
4436 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4437 unsafe {
4438 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4439 s.assume_init()
4440 }
4441 }
4442}
4443pub type VAEncPictureParameterBufferMPEG2 = _VAEncPictureParameterBufferMPEG2;
4444#[repr(C)]
4445#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
4446pub struct _VAEncSliceParameterBufferMPEG2 {
4447 pub macroblock_address: u32,
4448 pub num_macroblocks: u32,
4449 pub quantiser_scale_code: i32,
4450 pub is_intra_slice: i32,
4451 pub va_reserved: [u32; 4usize],
4452}
4453pub type VAEncSliceParameterBufferMPEG2 = _VAEncSliceParameterBufferMPEG2;
4454#[repr(C)]
4455#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
4456pub struct _VAEncMiscParameterExtensionDataSeqDisplayMPEG2 {
4457 pub extension_start_code_identifier: u8,
4458 pub video_format: u8,
4459 pub colour_description: u8,
4460 pub colour_primaries: u8,
4461 pub transfer_characteristics: u8,
4462 pub matrix_coefficients: u8,
4463 pub display_horizontal_size: u16,
4464 pub display_vertical_size: u16,
4465}
4466pub type VAEncMiscParameterExtensionDataSeqDisplayMPEG2 =
4467 _VAEncMiscParameterExtensionDataSeqDisplayMPEG2;
4468#[repr(C)]
4469#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
4470pub struct _VAEncSequenceParameterBufferVP8 {
4471 pub frame_width: u32,
4472 pub frame_height: u32,
4473 pub frame_width_scale: u32,
4474 pub frame_height_scale: u32,
4475 pub error_resilient: u32,
4476 pub kf_auto: u32,
4477 pub kf_min_dist: u32,
4478 pub kf_max_dist: u32,
4479 pub bits_per_second: u32,
4480 pub intra_period: u32,
4481 pub reference_frames: [VASurfaceID; 4usize],
4482 pub va_reserved: [u32; 4usize],
4483}
4484pub type VAEncSequenceParameterBufferVP8 = _VAEncSequenceParameterBufferVP8;
4485#[repr(C)]
4486#[derive(Copy, Clone)]
4487pub struct _VAEncPictureParameterBufferVP8 {
4488 pub reconstructed_frame: VASurfaceID,
4489 pub ref_last_frame: VASurfaceID,
4490 pub ref_gf_frame: VASurfaceID,
4491 pub ref_arf_frame: VASurfaceID,
4492 pub coded_buf: VABufferID,
4493 pub ref_flags: _VAEncPictureParameterBufferVP8__bindgen_ty_1,
4494 pub pic_flags: _VAEncPictureParameterBufferVP8__bindgen_ty_2,
4495 pub loop_filter_level: [i8; 4usize],
4496 pub ref_lf_delta: [i8; 4usize],
4497 pub mode_lf_delta: [i8; 4usize],
4498 pub sharpness_level: u8,
4499 pub clamp_qindex_high: u8,
4500 pub clamp_qindex_low: u8,
4501 pub va_reserved: [u32; 4usize],
4502}
4503#[repr(C)]
4504#[derive(Copy, Clone)]
4505pub union _VAEncPictureParameterBufferVP8__bindgen_ty_1 {
4506 pub bits: _VAEncPictureParameterBufferVP8__bindgen_ty_1__bindgen_ty_1,
4507 pub value: u32,
4508}
4509#[repr(C)]
4510#[repr(align(4))]
4511#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
4512pub struct _VAEncPictureParameterBufferVP8__bindgen_ty_1__bindgen_ty_1 {
4513 pub _bitfield_align_1: [u16; 0],
4514 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
4515}
4516impl _VAEncPictureParameterBufferVP8__bindgen_ty_1__bindgen_ty_1 {
4517 #[inline]
4518 pub fn force_kf(&self) -> u32 {
4519 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
4520 }
4521 #[inline]
4522 pub fn set_force_kf(&mut self, val: u32) {
4523 unsafe {
4524 let val: u32 = ::std::mem::transmute(val);
4525 self._bitfield_1.set(0usize, 1u8, val as u64)
4526 }
4527 }
4528 #[inline]
4529 pub fn no_ref_last(&self) -> u32 {
4530 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
4531 }
4532 #[inline]
4533 pub fn set_no_ref_last(&mut self, val: u32) {
4534 unsafe {
4535 let val: u32 = ::std::mem::transmute(val);
4536 self._bitfield_1.set(1usize, 1u8, val as u64)
4537 }
4538 }
4539 #[inline]
4540 pub fn no_ref_gf(&self) -> u32 {
4541 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
4542 }
4543 #[inline]
4544 pub fn set_no_ref_gf(&mut self, val: u32) {
4545 unsafe {
4546 let val: u32 = ::std::mem::transmute(val);
4547 self._bitfield_1.set(2usize, 1u8, val as u64)
4548 }
4549 }
4550 #[inline]
4551 pub fn no_ref_arf(&self) -> u32 {
4552 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
4553 }
4554 #[inline]
4555 pub fn set_no_ref_arf(&mut self, val: u32) {
4556 unsafe {
4557 let val: u32 = ::std::mem::transmute(val);
4558 self._bitfield_1.set(3usize, 1u8, val as u64)
4559 }
4560 }
4561 #[inline]
4562 pub fn temporal_id(&self) -> u32 {
4563 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 8u8) as u32) }
4564 }
4565 #[inline]
4566 pub fn set_temporal_id(&mut self, val: u32) {
4567 unsafe {
4568 let val: u32 = ::std::mem::transmute(val);
4569 self._bitfield_1.set(4usize, 8u8, val as u64)
4570 }
4571 }
4572 #[inline]
4573 pub fn first_ref(&self) -> u32 {
4574 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 2u8) as u32) }
4575 }
4576 #[inline]
4577 pub fn set_first_ref(&mut self, val: u32) {
4578 unsafe {
4579 let val: u32 = ::std::mem::transmute(val);
4580 self._bitfield_1.set(12usize, 2u8, val as u64)
4581 }
4582 }
4583 #[inline]
4584 pub fn second_ref(&self) -> u32 {
4585 unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 2u8) as u32) }
4586 }
4587 #[inline]
4588 pub fn set_second_ref(&mut self, val: u32) {
4589 unsafe {
4590 let val: u32 = ::std::mem::transmute(val);
4591 self._bitfield_1.set(14usize, 2u8, val as u64)
4592 }
4593 }
4594 #[inline]
4595 pub fn reserved(&self) -> u32 {
4596 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 16u8) as u32) }
4597 }
4598 #[inline]
4599 pub fn set_reserved(&mut self, val: u32) {
4600 unsafe {
4601 let val: u32 = ::std::mem::transmute(val);
4602 self._bitfield_1.set(16usize, 16u8, val as u64)
4603 }
4604 }
4605 #[inline]
4606 pub fn new_bitfield_1(
4607 force_kf: u32,
4608 no_ref_last: u32,
4609 no_ref_gf: u32,
4610 no_ref_arf: u32,
4611 temporal_id: u32,
4612 first_ref: u32,
4613 second_ref: u32,
4614 reserved: u32,
4615 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
4616 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
4617 __bindgen_bitfield_unit.set(0usize, 1u8, {
4618 let force_kf: u32 = unsafe { ::std::mem::transmute(force_kf) };
4619 force_kf as u64
4620 });
4621 __bindgen_bitfield_unit.set(1usize, 1u8, {
4622 let no_ref_last: u32 = unsafe { ::std::mem::transmute(no_ref_last) };
4623 no_ref_last as u64
4624 });
4625 __bindgen_bitfield_unit.set(2usize, 1u8, {
4626 let no_ref_gf: u32 = unsafe { ::std::mem::transmute(no_ref_gf) };
4627 no_ref_gf as u64
4628 });
4629 __bindgen_bitfield_unit.set(3usize, 1u8, {
4630 let no_ref_arf: u32 = unsafe { ::std::mem::transmute(no_ref_arf) };
4631 no_ref_arf as u64
4632 });
4633 __bindgen_bitfield_unit.set(4usize, 8u8, {
4634 let temporal_id: u32 = unsafe { ::std::mem::transmute(temporal_id) };
4635 temporal_id as u64
4636 });
4637 __bindgen_bitfield_unit.set(12usize, 2u8, {
4638 let first_ref: u32 = unsafe { ::std::mem::transmute(first_ref) };
4639 first_ref as u64
4640 });
4641 __bindgen_bitfield_unit.set(14usize, 2u8, {
4642 let second_ref: u32 = unsafe { ::std::mem::transmute(second_ref) };
4643 second_ref as u64
4644 });
4645 __bindgen_bitfield_unit.set(16usize, 16u8, {
4646 let reserved: u32 = unsafe { ::std::mem::transmute(reserved) };
4647 reserved as u64
4648 });
4649 __bindgen_bitfield_unit
4650 }
4651}
4652impl Default for _VAEncPictureParameterBufferVP8__bindgen_ty_1 {
4653 fn default() -> Self {
4654 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4655 unsafe {
4656 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4657 s.assume_init()
4658 }
4659 }
4660}
4661#[repr(C)]
4662#[derive(Copy, Clone)]
4663pub union _VAEncPictureParameterBufferVP8__bindgen_ty_2 {
4664 pub bits: _VAEncPictureParameterBufferVP8__bindgen_ty_2__bindgen_ty_1,
4665 pub value: u32,
4666}
4667#[repr(C)]
4668#[repr(align(4))]
4669#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
4670pub struct _VAEncPictureParameterBufferVP8__bindgen_ty_2__bindgen_ty_1 {
4671 pub _bitfield_align_1: [u8; 0],
4672 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
4673}
4674impl _VAEncPictureParameterBufferVP8__bindgen_ty_2__bindgen_ty_1 {
4675 #[inline]
4676 pub fn frame_type(&self) -> u32 {
4677 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
4678 }
4679 #[inline]
4680 pub fn set_frame_type(&mut self, val: u32) {
4681 unsafe {
4682 let val: u32 = ::std::mem::transmute(val);
4683 self._bitfield_1.set(0usize, 1u8, val as u64)
4684 }
4685 }
4686 #[inline]
4687 pub fn version(&self) -> u32 {
4688 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 3u8) as u32) }
4689 }
4690 #[inline]
4691 pub fn set_version(&mut self, val: u32) {
4692 unsafe {
4693 let val: u32 = ::std::mem::transmute(val);
4694 self._bitfield_1.set(1usize, 3u8, val as u64)
4695 }
4696 }
4697 #[inline]
4698 pub fn show_frame(&self) -> u32 {
4699 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
4700 }
4701 #[inline]
4702 pub fn set_show_frame(&mut self, val: u32) {
4703 unsafe {
4704 let val: u32 = ::std::mem::transmute(val);
4705 self._bitfield_1.set(4usize, 1u8, val as u64)
4706 }
4707 }
4708 #[inline]
4709 pub fn color_space(&self) -> u32 {
4710 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
4711 }
4712 #[inline]
4713 pub fn set_color_space(&mut self, val: u32) {
4714 unsafe {
4715 let val: u32 = ::std::mem::transmute(val);
4716 self._bitfield_1.set(5usize, 1u8, val as u64)
4717 }
4718 }
4719 #[inline]
4720 pub fn recon_filter_type(&self) -> u32 {
4721 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 2u8) as u32) }
4722 }
4723 #[inline]
4724 pub fn set_recon_filter_type(&mut self, val: u32) {
4725 unsafe {
4726 let val: u32 = ::std::mem::transmute(val);
4727 self._bitfield_1.set(6usize, 2u8, val as u64)
4728 }
4729 }
4730 #[inline]
4731 pub fn loop_filter_type(&self) -> u32 {
4732 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 2u8) as u32) }
4733 }
4734 #[inline]
4735 pub fn set_loop_filter_type(&mut self, val: u32) {
4736 unsafe {
4737 let val: u32 = ::std::mem::transmute(val);
4738 self._bitfield_1.set(8usize, 2u8, val as u64)
4739 }
4740 }
4741 #[inline]
4742 pub fn auto_partitions(&self) -> u32 {
4743 unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) }
4744 }
4745 #[inline]
4746 pub fn set_auto_partitions(&mut self, val: u32) {
4747 unsafe {
4748 let val: u32 = ::std::mem::transmute(val);
4749 self._bitfield_1.set(10usize, 1u8, val as u64)
4750 }
4751 }
4752 #[inline]
4753 pub fn num_token_partitions(&self) -> u32 {
4754 unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 2u8) as u32) }
4755 }
4756 #[inline]
4757 pub fn set_num_token_partitions(&mut self, val: u32) {
4758 unsafe {
4759 let val: u32 = ::std::mem::transmute(val);
4760 self._bitfield_1.set(11usize, 2u8, val as u64)
4761 }
4762 }
4763 #[inline]
4764 pub fn clamping_type(&self) -> u32 {
4765 unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) }
4766 }
4767 #[inline]
4768 pub fn set_clamping_type(&mut self, val: u32) {
4769 unsafe {
4770 let val: u32 = ::std::mem::transmute(val);
4771 self._bitfield_1.set(13usize, 1u8, val as u64)
4772 }
4773 }
4774 #[inline]
4775 pub fn segmentation_enabled(&self) -> u32 {
4776 unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) }
4777 }
4778 #[inline]
4779 pub fn set_segmentation_enabled(&mut self, val: u32) {
4780 unsafe {
4781 let val: u32 = ::std::mem::transmute(val);
4782 self._bitfield_1.set(14usize, 1u8, val as u64)
4783 }
4784 }
4785 #[inline]
4786 pub fn update_mb_segmentation_map(&self) -> u32 {
4787 unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u32) }
4788 }
4789 #[inline]
4790 pub fn set_update_mb_segmentation_map(&mut self, val: u32) {
4791 unsafe {
4792 let val: u32 = ::std::mem::transmute(val);
4793 self._bitfield_1.set(15usize, 1u8, val as u64)
4794 }
4795 }
4796 #[inline]
4797 pub fn update_segment_feature_data(&self) -> u32 {
4798 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u32) }
4799 }
4800 #[inline]
4801 pub fn set_update_segment_feature_data(&mut self, val: u32) {
4802 unsafe {
4803 let val: u32 = ::std::mem::transmute(val);
4804 self._bitfield_1.set(16usize, 1u8, val as u64)
4805 }
4806 }
4807 #[inline]
4808 pub fn loop_filter_adj_enable(&self) -> u32 {
4809 unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 1u8) as u32) }
4810 }
4811 #[inline]
4812 pub fn set_loop_filter_adj_enable(&mut self, val: u32) {
4813 unsafe {
4814 let val: u32 = ::std::mem::transmute(val);
4815 self._bitfield_1.set(17usize, 1u8, val as u64)
4816 }
4817 }
4818 #[inline]
4819 pub fn refresh_entropy_probs(&self) -> u32 {
4820 unsafe { ::std::mem::transmute(self._bitfield_1.get(18usize, 1u8) as u32) }
4821 }
4822 #[inline]
4823 pub fn set_refresh_entropy_probs(&mut self, val: u32) {
4824 unsafe {
4825 let val: u32 = ::std::mem::transmute(val);
4826 self._bitfield_1.set(18usize, 1u8, val as u64)
4827 }
4828 }
4829 #[inline]
4830 pub fn refresh_golden_frame(&self) -> u32 {
4831 unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 1u8) as u32) }
4832 }
4833 #[inline]
4834 pub fn set_refresh_golden_frame(&mut self, val: u32) {
4835 unsafe {
4836 let val: u32 = ::std::mem::transmute(val);
4837 self._bitfield_1.set(19usize, 1u8, val as u64)
4838 }
4839 }
4840 #[inline]
4841 pub fn refresh_alternate_frame(&self) -> u32 {
4842 unsafe { ::std::mem::transmute(self._bitfield_1.get(20usize, 1u8) as u32) }
4843 }
4844 #[inline]
4845 pub fn set_refresh_alternate_frame(&mut self, val: u32) {
4846 unsafe {
4847 let val: u32 = ::std::mem::transmute(val);
4848 self._bitfield_1.set(20usize, 1u8, val as u64)
4849 }
4850 }
4851 #[inline]
4852 pub fn refresh_last(&self) -> u32 {
4853 unsafe { ::std::mem::transmute(self._bitfield_1.get(21usize, 1u8) as u32) }
4854 }
4855 #[inline]
4856 pub fn set_refresh_last(&mut self, val: u32) {
4857 unsafe {
4858 let val: u32 = ::std::mem::transmute(val);
4859 self._bitfield_1.set(21usize, 1u8, val as u64)
4860 }
4861 }
4862 #[inline]
4863 pub fn copy_buffer_to_golden(&self) -> u32 {
4864 unsafe { ::std::mem::transmute(self._bitfield_1.get(22usize, 2u8) as u32) }
4865 }
4866 #[inline]
4867 pub fn set_copy_buffer_to_golden(&mut self, val: u32) {
4868 unsafe {
4869 let val: u32 = ::std::mem::transmute(val);
4870 self._bitfield_1.set(22usize, 2u8, val as u64)
4871 }
4872 }
4873 #[inline]
4874 pub fn copy_buffer_to_alternate(&self) -> u32 {
4875 unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 2u8) as u32) }
4876 }
4877 #[inline]
4878 pub fn set_copy_buffer_to_alternate(&mut self, val: u32) {
4879 unsafe {
4880 let val: u32 = ::std::mem::transmute(val);
4881 self._bitfield_1.set(24usize, 2u8, val as u64)
4882 }
4883 }
4884 #[inline]
4885 pub fn sign_bias_golden(&self) -> u32 {
4886 unsafe { ::std::mem::transmute(self._bitfield_1.get(26usize, 1u8) as u32) }
4887 }
4888 #[inline]
4889 pub fn set_sign_bias_golden(&mut self, val: u32) {
4890 unsafe {
4891 let val: u32 = ::std::mem::transmute(val);
4892 self._bitfield_1.set(26usize, 1u8, val as u64)
4893 }
4894 }
4895 #[inline]
4896 pub fn sign_bias_alternate(&self) -> u32 {
4897 unsafe { ::std::mem::transmute(self._bitfield_1.get(27usize, 1u8) as u32) }
4898 }
4899 #[inline]
4900 pub fn set_sign_bias_alternate(&mut self, val: u32) {
4901 unsafe {
4902 let val: u32 = ::std::mem::transmute(val);
4903 self._bitfield_1.set(27usize, 1u8, val as u64)
4904 }
4905 }
4906 #[inline]
4907 pub fn mb_no_coeff_skip(&self) -> u32 {
4908 unsafe { ::std::mem::transmute(self._bitfield_1.get(28usize, 1u8) as u32) }
4909 }
4910 #[inline]
4911 pub fn set_mb_no_coeff_skip(&mut self, val: u32) {
4912 unsafe {
4913 let val: u32 = ::std::mem::transmute(val);
4914 self._bitfield_1.set(28usize, 1u8, val as u64)
4915 }
4916 }
4917 #[inline]
4918 pub fn forced_lf_adjustment(&self) -> u32 {
4919 unsafe { ::std::mem::transmute(self._bitfield_1.get(29usize, 1u8) as u32) }
4920 }
4921 #[inline]
4922 pub fn set_forced_lf_adjustment(&mut self, val: u32) {
4923 unsafe {
4924 let val: u32 = ::std::mem::transmute(val);
4925 self._bitfield_1.set(29usize, 1u8, val as u64)
4926 }
4927 }
4928 #[inline]
4929 pub fn reserved(&self) -> u32 {
4930 unsafe { ::std::mem::transmute(self._bitfield_1.get(30usize, 2u8) as u32) }
4931 }
4932 #[inline]
4933 pub fn set_reserved(&mut self, val: u32) {
4934 unsafe {
4935 let val: u32 = ::std::mem::transmute(val);
4936 self._bitfield_1.set(30usize, 2u8, val as u64)
4937 }
4938 }
4939 #[inline]
4940 pub fn new_bitfield_1(
4941 frame_type: u32,
4942 version: u32,
4943 show_frame: u32,
4944 color_space: u32,
4945 recon_filter_type: u32,
4946 loop_filter_type: u32,
4947 auto_partitions: u32,
4948 num_token_partitions: u32,
4949 clamping_type: u32,
4950 segmentation_enabled: u32,
4951 update_mb_segmentation_map: u32,
4952 update_segment_feature_data: u32,
4953 loop_filter_adj_enable: u32,
4954 refresh_entropy_probs: u32,
4955 refresh_golden_frame: u32,
4956 refresh_alternate_frame: u32,
4957 refresh_last: u32,
4958 copy_buffer_to_golden: u32,
4959 copy_buffer_to_alternate: u32,
4960 sign_bias_golden: u32,
4961 sign_bias_alternate: u32,
4962 mb_no_coeff_skip: u32,
4963 forced_lf_adjustment: u32,
4964 reserved: u32,
4965 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
4966 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
4967 __bindgen_bitfield_unit.set(0usize, 1u8, {
4968 let frame_type: u32 = unsafe { ::std::mem::transmute(frame_type) };
4969 frame_type as u64
4970 });
4971 __bindgen_bitfield_unit.set(1usize, 3u8, {
4972 let version: u32 = unsafe { ::std::mem::transmute(version) };
4973 version as u64
4974 });
4975 __bindgen_bitfield_unit.set(4usize, 1u8, {
4976 let show_frame: u32 = unsafe { ::std::mem::transmute(show_frame) };
4977 show_frame as u64
4978 });
4979 __bindgen_bitfield_unit.set(5usize, 1u8, {
4980 let color_space: u32 = unsafe { ::std::mem::transmute(color_space) };
4981 color_space as u64
4982 });
4983 __bindgen_bitfield_unit.set(6usize, 2u8, {
4984 let recon_filter_type: u32 = unsafe { ::std::mem::transmute(recon_filter_type) };
4985 recon_filter_type as u64
4986 });
4987 __bindgen_bitfield_unit.set(8usize, 2u8, {
4988 let loop_filter_type: u32 = unsafe { ::std::mem::transmute(loop_filter_type) };
4989 loop_filter_type as u64
4990 });
4991 __bindgen_bitfield_unit.set(10usize, 1u8, {
4992 let auto_partitions: u32 = unsafe { ::std::mem::transmute(auto_partitions) };
4993 auto_partitions as u64
4994 });
4995 __bindgen_bitfield_unit.set(11usize, 2u8, {
4996 let num_token_partitions: u32 = unsafe { ::std::mem::transmute(num_token_partitions) };
4997 num_token_partitions as u64
4998 });
4999 __bindgen_bitfield_unit.set(13usize, 1u8, {
5000 let clamping_type: u32 = unsafe { ::std::mem::transmute(clamping_type) };
5001 clamping_type as u64
5002 });
5003 __bindgen_bitfield_unit.set(14usize, 1u8, {
5004 let segmentation_enabled: u32 = unsafe { ::std::mem::transmute(segmentation_enabled) };
5005 segmentation_enabled as u64
5006 });
5007 __bindgen_bitfield_unit.set(15usize, 1u8, {
5008 let update_mb_segmentation_map: u32 =
5009 unsafe { ::std::mem::transmute(update_mb_segmentation_map) };
5010 update_mb_segmentation_map as u64
5011 });
5012 __bindgen_bitfield_unit.set(16usize, 1u8, {
5013 let update_segment_feature_data: u32 =
5014 unsafe { ::std::mem::transmute(update_segment_feature_data) };
5015 update_segment_feature_data as u64
5016 });
5017 __bindgen_bitfield_unit.set(17usize, 1u8, {
5018 let loop_filter_adj_enable: u32 =
5019 unsafe { ::std::mem::transmute(loop_filter_adj_enable) };
5020 loop_filter_adj_enable as u64
5021 });
5022 __bindgen_bitfield_unit.set(18usize, 1u8, {
5023 let refresh_entropy_probs: u32 =
5024 unsafe { ::std::mem::transmute(refresh_entropy_probs) };
5025 refresh_entropy_probs as u64
5026 });
5027 __bindgen_bitfield_unit.set(19usize, 1u8, {
5028 let refresh_golden_frame: u32 = unsafe { ::std::mem::transmute(refresh_golden_frame) };
5029 refresh_golden_frame as u64
5030 });
5031 __bindgen_bitfield_unit.set(20usize, 1u8, {
5032 let refresh_alternate_frame: u32 =
5033 unsafe { ::std::mem::transmute(refresh_alternate_frame) };
5034 refresh_alternate_frame as u64
5035 });
5036 __bindgen_bitfield_unit.set(21usize, 1u8, {
5037 let refresh_last: u32 = unsafe { ::std::mem::transmute(refresh_last) };
5038 refresh_last as u64
5039 });
5040 __bindgen_bitfield_unit.set(22usize, 2u8, {
5041 let copy_buffer_to_golden: u32 =
5042 unsafe { ::std::mem::transmute(copy_buffer_to_golden) };
5043 copy_buffer_to_golden as u64
5044 });
5045 __bindgen_bitfield_unit.set(24usize, 2u8, {
5046 let copy_buffer_to_alternate: u32 =
5047 unsafe { ::std::mem::transmute(copy_buffer_to_alternate) };
5048 copy_buffer_to_alternate as u64
5049 });
5050 __bindgen_bitfield_unit.set(26usize, 1u8, {
5051 let sign_bias_golden: u32 = unsafe { ::std::mem::transmute(sign_bias_golden) };
5052 sign_bias_golden as u64
5053 });
5054 __bindgen_bitfield_unit.set(27usize, 1u8, {
5055 let sign_bias_alternate: u32 = unsafe { ::std::mem::transmute(sign_bias_alternate) };
5056 sign_bias_alternate as u64
5057 });
5058 __bindgen_bitfield_unit.set(28usize, 1u8, {
5059 let mb_no_coeff_skip: u32 = unsafe { ::std::mem::transmute(mb_no_coeff_skip) };
5060 mb_no_coeff_skip as u64
5061 });
5062 __bindgen_bitfield_unit.set(29usize, 1u8, {
5063 let forced_lf_adjustment: u32 = unsafe { ::std::mem::transmute(forced_lf_adjustment) };
5064 forced_lf_adjustment as u64
5065 });
5066 __bindgen_bitfield_unit.set(30usize, 2u8, {
5067 let reserved: u32 = unsafe { ::std::mem::transmute(reserved) };
5068 reserved as u64
5069 });
5070 __bindgen_bitfield_unit
5071 }
5072}
5073impl Default for _VAEncPictureParameterBufferVP8__bindgen_ty_2 {
5074 fn default() -> Self {
5075 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5076 unsafe {
5077 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5078 s.assume_init()
5079 }
5080 }
5081}
5082impl Default for _VAEncPictureParameterBufferVP8 {
5083 fn default() -> Self {
5084 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5085 unsafe {
5086 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5087 s.assume_init()
5088 }
5089 }
5090}
5091pub type VAEncPictureParameterBufferVP8 = _VAEncPictureParameterBufferVP8;
5092#[repr(C)]
5093#[derive(Debug, Copy, Clone, PartialEq, Eq)]
5094pub struct _VAEncMBMapBufferVP8 {
5095 pub num_mbs: u32,
5096 pub mb_segment_id: *mut u8,
5097 pub va_reserved: [u32; 4usize],
5098}
5099impl Default for _VAEncMBMapBufferVP8 {
5100 fn default() -> Self {
5101 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5102 unsafe {
5103 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5104 s.assume_init()
5105 }
5106 }
5107}
5108pub type VAEncMBMapBufferVP8 = _VAEncMBMapBufferVP8;
5109#[repr(C)]
5110#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
5111pub struct _VAQMatrixBufferVP8 {
5112 pub quantization_index: [u16; 4usize],
5113 pub quantization_index_delta: [i16; 5usize],
5114 pub va_reserved: [u32; 4usize],
5115}
5116pub type VAQMatrixBufferVP8 = _VAQMatrixBufferVP8;
5117#[repr(C)]
5118#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
5119pub struct _VACodedBufferVP9Status {
5120 pub base_qp_index: u16,
5121 pub loop_filter_level: u8,
5122 pub long_term_indication: u8,
5123 pub next_frame_width: u16,
5124 pub next_frame_height: u16,
5125 pub va_reserved: [u32; 4usize],
5126}
5127pub type VACodedBufferVP9Status = _VACodedBufferVP9Status;
5128#[repr(C)]
5129#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
5130pub struct _VAEncSequenceParameterBufferVP9 {
5131 pub max_frame_width: u32,
5132 pub max_frame_height: u32,
5133 pub kf_auto: u32,
5134 pub kf_min_dist: u32,
5135 pub kf_max_dist: u32,
5136 pub bits_per_second: u32,
5137 pub intra_period: u32,
5138 pub va_reserved: [u32; 4usize],
5139}
5140pub type VAEncSequenceParameterBufferVP9 = _VAEncSequenceParameterBufferVP9;
5141#[repr(C)]
5142#[derive(Copy, Clone)]
5143pub struct _VAEncPictureParameterBufferVP9 {
5144 pub frame_width_src: u32,
5145 pub frame_height_src: u32,
5146 pub frame_width_dst: u32,
5147 pub frame_height_dst: u32,
5148 pub reconstructed_frame: VASurfaceID,
5149 pub reference_frames: [VASurfaceID; 8usize],
5150 pub coded_buf: VABufferID,
5151 pub ref_flags: _VAEncPictureParameterBufferVP9__bindgen_ty_1,
5152 pub pic_flags: _VAEncPictureParameterBufferVP9__bindgen_ty_2,
5153 pub refresh_frame_flags: u8,
5154 pub luma_ac_qindex: u8,
5155 pub luma_dc_qindex_delta: i8,
5156 pub chroma_ac_qindex_delta: i8,
5157 pub chroma_dc_qindex_delta: i8,
5158 pub filter_level: u8,
5159 pub sharpness_level: u8,
5160 pub ref_lf_delta: [i8; 4usize],
5161 pub mode_lf_delta: [i8; 2usize],
5162 pub bit_offset_ref_lf_delta: u16,
5163 pub bit_offset_mode_lf_delta: u16,
5164 pub bit_offset_lf_level: u16,
5165 pub bit_offset_qindex: u16,
5166 pub bit_offset_first_partition_size: u16,
5167 pub bit_offset_segmentation: u16,
5168 pub bit_size_segmentation: u16,
5169 pub log2_tile_rows: u8,
5170 pub log2_tile_columns: u8,
5171 pub skip_frame_flag: u8,
5172 pub number_skip_frames: u8,
5173 pub skip_frames_size: u32,
5174 pub va_reserved: [u32; 8usize],
5175}
5176#[repr(C)]
5177#[derive(Copy, Clone)]
5178pub union _VAEncPictureParameterBufferVP9__bindgen_ty_1 {
5179 pub bits: _VAEncPictureParameterBufferVP9__bindgen_ty_1__bindgen_ty_1,
5180 pub value: u32,
5181}
5182#[repr(C)]
5183#[repr(align(4))]
5184#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
5185pub struct _VAEncPictureParameterBufferVP9__bindgen_ty_1__bindgen_ty_1 {
5186 pub _bitfield_align_1: [u8; 0],
5187 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
5188}
5189impl _VAEncPictureParameterBufferVP9__bindgen_ty_1__bindgen_ty_1 {
5190 #[inline]
5191 pub fn force_kf(&self) -> u32 {
5192 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
5193 }
5194 #[inline]
5195 pub fn set_force_kf(&mut self, val: u32) {
5196 unsafe {
5197 let val: u32 = ::std::mem::transmute(val);
5198 self._bitfield_1.set(0usize, 1u8, val as u64)
5199 }
5200 }
5201 #[inline]
5202 pub fn ref_frame_ctrl_l0(&self) -> u32 {
5203 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 3u8) as u32) }
5204 }
5205 #[inline]
5206 pub fn set_ref_frame_ctrl_l0(&mut self, val: u32) {
5207 unsafe {
5208 let val: u32 = ::std::mem::transmute(val);
5209 self._bitfield_1.set(1usize, 3u8, val as u64)
5210 }
5211 }
5212 #[inline]
5213 pub fn ref_frame_ctrl_l1(&self) -> u32 {
5214 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 3u8) as u32) }
5215 }
5216 #[inline]
5217 pub fn set_ref_frame_ctrl_l1(&mut self, val: u32) {
5218 unsafe {
5219 let val: u32 = ::std::mem::transmute(val);
5220 self._bitfield_1.set(4usize, 3u8, val as u64)
5221 }
5222 }
5223 #[inline]
5224 pub fn ref_last_idx(&self) -> u32 {
5225 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 3u8) as u32) }
5226 }
5227 #[inline]
5228 pub fn set_ref_last_idx(&mut self, val: u32) {
5229 unsafe {
5230 let val: u32 = ::std::mem::transmute(val);
5231 self._bitfield_1.set(7usize, 3u8, val as u64)
5232 }
5233 }
5234 #[inline]
5235 pub fn ref_last_sign_bias(&self) -> u32 {
5236 unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) }
5237 }
5238 #[inline]
5239 pub fn set_ref_last_sign_bias(&mut self, val: u32) {
5240 unsafe {
5241 let val: u32 = ::std::mem::transmute(val);
5242 self._bitfield_1.set(10usize, 1u8, val as u64)
5243 }
5244 }
5245 #[inline]
5246 pub fn ref_gf_idx(&self) -> u32 {
5247 unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 3u8) as u32) }
5248 }
5249 #[inline]
5250 pub fn set_ref_gf_idx(&mut self, val: u32) {
5251 unsafe {
5252 let val: u32 = ::std::mem::transmute(val);
5253 self._bitfield_1.set(11usize, 3u8, val as u64)
5254 }
5255 }
5256 #[inline]
5257 pub fn ref_gf_sign_bias(&self) -> u32 {
5258 unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) }
5259 }
5260 #[inline]
5261 pub fn set_ref_gf_sign_bias(&mut self, val: u32) {
5262 unsafe {
5263 let val: u32 = ::std::mem::transmute(val);
5264 self._bitfield_1.set(14usize, 1u8, val as u64)
5265 }
5266 }
5267 #[inline]
5268 pub fn ref_arf_idx(&self) -> u32 {
5269 unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 3u8) as u32) }
5270 }
5271 #[inline]
5272 pub fn set_ref_arf_idx(&mut self, val: u32) {
5273 unsafe {
5274 let val: u32 = ::std::mem::transmute(val);
5275 self._bitfield_1.set(15usize, 3u8, val as u64)
5276 }
5277 }
5278 #[inline]
5279 pub fn ref_arf_sign_bias(&self) -> u32 {
5280 unsafe { ::std::mem::transmute(self._bitfield_1.get(18usize, 1u8) as u32) }
5281 }
5282 #[inline]
5283 pub fn set_ref_arf_sign_bias(&mut self, val: u32) {
5284 unsafe {
5285 let val: u32 = ::std::mem::transmute(val);
5286 self._bitfield_1.set(18usize, 1u8, val as u64)
5287 }
5288 }
5289 #[inline]
5290 pub fn temporal_id(&self) -> u32 {
5291 unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 8u8) as u32) }
5292 }
5293 #[inline]
5294 pub fn set_temporal_id(&mut self, val: u32) {
5295 unsafe {
5296 let val: u32 = ::std::mem::transmute(val);
5297 self._bitfield_1.set(19usize, 8u8, val as u64)
5298 }
5299 }
5300 #[inline]
5301 pub fn reserved(&self) -> u32 {
5302 unsafe { ::std::mem::transmute(self._bitfield_1.get(27usize, 5u8) as u32) }
5303 }
5304 #[inline]
5305 pub fn set_reserved(&mut self, val: u32) {
5306 unsafe {
5307 let val: u32 = ::std::mem::transmute(val);
5308 self._bitfield_1.set(27usize, 5u8, val as u64)
5309 }
5310 }
5311 #[inline]
5312 pub fn new_bitfield_1(
5313 force_kf: u32,
5314 ref_frame_ctrl_l0: u32,
5315 ref_frame_ctrl_l1: u32,
5316 ref_last_idx: u32,
5317 ref_last_sign_bias: u32,
5318 ref_gf_idx: u32,
5319 ref_gf_sign_bias: u32,
5320 ref_arf_idx: u32,
5321 ref_arf_sign_bias: u32,
5322 temporal_id: u32,
5323 reserved: u32,
5324 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
5325 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
5326 __bindgen_bitfield_unit.set(0usize, 1u8, {
5327 let force_kf: u32 = unsafe { ::std::mem::transmute(force_kf) };
5328 force_kf as u64
5329 });
5330 __bindgen_bitfield_unit.set(1usize, 3u8, {
5331 let ref_frame_ctrl_l0: u32 = unsafe { ::std::mem::transmute(ref_frame_ctrl_l0) };
5332 ref_frame_ctrl_l0 as u64
5333 });
5334 __bindgen_bitfield_unit.set(4usize, 3u8, {
5335 let ref_frame_ctrl_l1: u32 = unsafe { ::std::mem::transmute(ref_frame_ctrl_l1) };
5336 ref_frame_ctrl_l1 as u64
5337 });
5338 __bindgen_bitfield_unit.set(7usize, 3u8, {
5339 let ref_last_idx: u32 = unsafe { ::std::mem::transmute(ref_last_idx) };
5340 ref_last_idx as u64
5341 });
5342 __bindgen_bitfield_unit.set(10usize, 1u8, {
5343 let ref_last_sign_bias: u32 = unsafe { ::std::mem::transmute(ref_last_sign_bias) };
5344 ref_last_sign_bias as u64
5345 });
5346 __bindgen_bitfield_unit.set(11usize, 3u8, {
5347 let ref_gf_idx: u32 = unsafe { ::std::mem::transmute(ref_gf_idx) };
5348 ref_gf_idx as u64
5349 });
5350 __bindgen_bitfield_unit.set(14usize, 1u8, {
5351 let ref_gf_sign_bias: u32 = unsafe { ::std::mem::transmute(ref_gf_sign_bias) };
5352 ref_gf_sign_bias as u64
5353 });
5354 __bindgen_bitfield_unit.set(15usize, 3u8, {
5355 let ref_arf_idx: u32 = unsafe { ::std::mem::transmute(ref_arf_idx) };
5356 ref_arf_idx as u64
5357 });
5358 __bindgen_bitfield_unit.set(18usize, 1u8, {
5359 let ref_arf_sign_bias: u32 = unsafe { ::std::mem::transmute(ref_arf_sign_bias) };
5360 ref_arf_sign_bias as u64
5361 });
5362 __bindgen_bitfield_unit.set(19usize, 8u8, {
5363 let temporal_id: u32 = unsafe { ::std::mem::transmute(temporal_id) };
5364 temporal_id as u64
5365 });
5366 __bindgen_bitfield_unit.set(27usize, 5u8, {
5367 let reserved: u32 = unsafe { ::std::mem::transmute(reserved) };
5368 reserved as u64
5369 });
5370 __bindgen_bitfield_unit
5371 }
5372}
5373impl Default for _VAEncPictureParameterBufferVP9__bindgen_ty_1 {
5374 fn default() -> Self {
5375 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5376 unsafe {
5377 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5378 s.assume_init()
5379 }
5380 }
5381}
5382#[repr(C)]
5383#[derive(Copy, Clone)]
5384pub union _VAEncPictureParameterBufferVP9__bindgen_ty_2 {
5385 pub bits: _VAEncPictureParameterBufferVP9__bindgen_ty_2__bindgen_ty_1,
5386 pub value: u32,
5387}
5388#[repr(C)]
5389#[repr(align(4))]
5390#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
5391pub struct _VAEncPictureParameterBufferVP9__bindgen_ty_2__bindgen_ty_1 {
5392 pub _bitfield_align_1: [u16; 0],
5393 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
5394}
5395impl _VAEncPictureParameterBufferVP9__bindgen_ty_2__bindgen_ty_1 {
5396 #[inline]
5397 pub fn frame_type(&self) -> u32 {
5398 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
5399 }
5400 #[inline]
5401 pub fn set_frame_type(&mut self, val: u32) {
5402 unsafe {
5403 let val: u32 = ::std::mem::transmute(val);
5404 self._bitfield_1.set(0usize, 1u8, val as u64)
5405 }
5406 }
5407 #[inline]
5408 pub fn show_frame(&self) -> u32 {
5409 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
5410 }
5411 #[inline]
5412 pub fn set_show_frame(&mut self, val: u32) {
5413 unsafe {
5414 let val: u32 = ::std::mem::transmute(val);
5415 self._bitfield_1.set(1usize, 1u8, val as u64)
5416 }
5417 }
5418 #[inline]
5419 pub fn error_resilient_mode(&self) -> u32 {
5420 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
5421 }
5422 #[inline]
5423 pub fn set_error_resilient_mode(&mut self, val: u32) {
5424 unsafe {
5425 let val: u32 = ::std::mem::transmute(val);
5426 self._bitfield_1.set(2usize, 1u8, val as u64)
5427 }
5428 }
5429 #[inline]
5430 pub fn intra_only(&self) -> u32 {
5431 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
5432 }
5433 #[inline]
5434 pub fn set_intra_only(&mut self, val: u32) {
5435 unsafe {
5436 let val: u32 = ::std::mem::transmute(val);
5437 self._bitfield_1.set(3usize, 1u8, val as u64)
5438 }
5439 }
5440 #[inline]
5441 pub fn allow_high_precision_mv(&self) -> u32 {
5442 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
5443 }
5444 #[inline]
5445 pub fn set_allow_high_precision_mv(&mut self, val: u32) {
5446 unsafe {
5447 let val: u32 = ::std::mem::transmute(val);
5448 self._bitfield_1.set(4usize, 1u8, val as u64)
5449 }
5450 }
5451 #[inline]
5452 pub fn mcomp_filter_type(&self) -> u32 {
5453 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 3u8) as u32) }
5454 }
5455 #[inline]
5456 pub fn set_mcomp_filter_type(&mut self, val: u32) {
5457 unsafe {
5458 let val: u32 = ::std::mem::transmute(val);
5459 self._bitfield_1.set(5usize, 3u8, val as u64)
5460 }
5461 }
5462 #[inline]
5463 pub fn frame_parallel_decoding_mode(&self) -> u32 {
5464 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) }
5465 }
5466 #[inline]
5467 pub fn set_frame_parallel_decoding_mode(&mut self, val: u32) {
5468 unsafe {
5469 let val: u32 = ::std::mem::transmute(val);
5470 self._bitfield_1.set(8usize, 1u8, val as u64)
5471 }
5472 }
5473 #[inline]
5474 pub fn reset_frame_context(&self) -> u32 {
5475 unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 2u8) as u32) }
5476 }
5477 #[inline]
5478 pub fn set_reset_frame_context(&mut self, val: u32) {
5479 unsafe {
5480 let val: u32 = ::std::mem::transmute(val);
5481 self._bitfield_1.set(9usize, 2u8, val as u64)
5482 }
5483 }
5484 #[inline]
5485 pub fn refresh_frame_context(&self) -> u32 {
5486 unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) }
5487 }
5488 #[inline]
5489 pub fn set_refresh_frame_context(&mut self, val: u32) {
5490 unsafe {
5491 let val: u32 = ::std::mem::transmute(val);
5492 self._bitfield_1.set(11usize, 1u8, val as u64)
5493 }
5494 }
5495 #[inline]
5496 pub fn frame_context_idx(&self) -> u32 {
5497 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 2u8) as u32) }
5498 }
5499 #[inline]
5500 pub fn set_frame_context_idx(&mut self, val: u32) {
5501 unsafe {
5502 let val: u32 = ::std::mem::transmute(val);
5503 self._bitfield_1.set(12usize, 2u8, val as u64)
5504 }
5505 }
5506 #[inline]
5507 pub fn segmentation_enabled(&self) -> u32 {
5508 unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) }
5509 }
5510 #[inline]
5511 pub fn set_segmentation_enabled(&mut self, val: u32) {
5512 unsafe {
5513 let val: u32 = ::std::mem::transmute(val);
5514 self._bitfield_1.set(14usize, 1u8, val as u64)
5515 }
5516 }
5517 #[inline]
5518 pub fn segmentation_temporal_update(&self) -> u32 {
5519 unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u32) }
5520 }
5521 #[inline]
5522 pub fn set_segmentation_temporal_update(&mut self, val: u32) {
5523 unsafe {
5524 let val: u32 = ::std::mem::transmute(val);
5525 self._bitfield_1.set(15usize, 1u8, val as u64)
5526 }
5527 }
5528 #[inline]
5529 pub fn segmentation_update_map(&self) -> u32 {
5530 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u32) }
5531 }
5532 #[inline]
5533 pub fn set_segmentation_update_map(&mut self, val: u32) {
5534 unsafe {
5535 let val: u32 = ::std::mem::transmute(val);
5536 self._bitfield_1.set(16usize, 1u8, val as u64)
5537 }
5538 }
5539 #[inline]
5540 pub fn lossless_mode(&self) -> u32 {
5541 unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 1u8) as u32) }
5542 }
5543 #[inline]
5544 pub fn set_lossless_mode(&mut self, val: u32) {
5545 unsafe {
5546 let val: u32 = ::std::mem::transmute(val);
5547 self._bitfield_1.set(17usize, 1u8, val as u64)
5548 }
5549 }
5550 #[inline]
5551 pub fn comp_prediction_mode(&self) -> u32 {
5552 unsafe { ::std::mem::transmute(self._bitfield_1.get(18usize, 2u8) as u32) }
5553 }
5554 #[inline]
5555 pub fn set_comp_prediction_mode(&mut self, val: u32) {
5556 unsafe {
5557 let val: u32 = ::std::mem::transmute(val);
5558 self._bitfield_1.set(18usize, 2u8, val as u64)
5559 }
5560 }
5561 #[inline]
5562 pub fn auto_segmentation(&self) -> u32 {
5563 unsafe { ::std::mem::transmute(self._bitfield_1.get(20usize, 1u8) as u32) }
5564 }
5565 #[inline]
5566 pub fn set_auto_segmentation(&mut self, val: u32) {
5567 unsafe {
5568 let val: u32 = ::std::mem::transmute(val);
5569 self._bitfield_1.set(20usize, 1u8, val as u64)
5570 }
5571 }
5572 #[inline]
5573 pub fn super_frame_flag(&self) -> u32 {
5574 unsafe { ::std::mem::transmute(self._bitfield_1.get(21usize, 1u8) as u32) }
5575 }
5576 #[inline]
5577 pub fn set_super_frame_flag(&mut self, val: u32) {
5578 unsafe {
5579 let val: u32 = ::std::mem::transmute(val);
5580 self._bitfield_1.set(21usize, 1u8, val as u64)
5581 }
5582 }
5583 #[inline]
5584 pub fn reserved(&self) -> u32 {
5585 unsafe { ::std::mem::transmute(self._bitfield_1.get(22usize, 10u8) as u32) }
5586 }
5587 #[inline]
5588 pub fn set_reserved(&mut self, val: u32) {
5589 unsafe {
5590 let val: u32 = ::std::mem::transmute(val);
5591 self._bitfield_1.set(22usize, 10u8, val as u64)
5592 }
5593 }
5594 #[inline]
5595 pub fn new_bitfield_1(
5596 frame_type: u32,
5597 show_frame: u32,
5598 error_resilient_mode: u32,
5599 intra_only: u32,
5600 allow_high_precision_mv: u32,
5601 mcomp_filter_type: u32,
5602 frame_parallel_decoding_mode: u32,
5603 reset_frame_context: u32,
5604 refresh_frame_context: u32,
5605 frame_context_idx: u32,
5606 segmentation_enabled: u32,
5607 segmentation_temporal_update: u32,
5608 segmentation_update_map: u32,
5609 lossless_mode: u32,
5610 comp_prediction_mode: u32,
5611 auto_segmentation: u32,
5612 super_frame_flag: u32,
5613 reserved: u32,
5614 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
5615 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
5616 __bindgen_bitfield_unit.set(0usize, 1u8, {
5617 let frame_type: u32 = unsafe { ::std::mem::transmute(frame_type) };
5618 frame_type as u64
5619 });
5620 __bindgen_bitfield_unit.set(1usize, 1u8, {
5621 let show_frame: u32 = unsafe { ::std::mem::transmute(show_frame) };
5622 show_frame as u64
5623 });
5624 __bindgen_bitfield_unit.set(2usize, 1u8, {
5625 let error_resilient_mode: u32 = unsafe { ::std::mem::transmute(error_resilient_mode) };
5626 error_resilient_mode as u64
5627 });
5628 __bindgen_bitfield_unit.set(3usize, 1u8, {
5629 let intra_only: u32 = unsafe { ::std::mem::transmute(intra_only) };
5630 intra_only as u64
5631 });
5632 __bindgen_bitfield_unit.set(4usize, 1u8, {
5633 let allow_high_precision_mv: u32 =
5634 unsafe { ::std::mem::transmute(allow_high_precision_mv) };
5635 allow_high_precision_mv as u64
5636 });
5637 __bindgen_bitfield_unit.set(5usize, 3u8, {
5638 let mcomp_filter_type: u32 = unsafe { ::std::mem::transmute(mcomp_filter_type) };
5639 mcomp_filter_type as u64
5640 });
5641 __bindgen_bitfield_unit.set(8usize, 1u8, {
5642 let frame_parallel_decoding_mode: u32 =
5643 unsafe { ::std::mem::transmute(frame_parallel_decoding_mode) };
5644 frame_parallel_decoding_mode as u64
5645 });
5646 __bindgen_bitfield_unit.set(9usize, 2u8, {
5647 let reset_frame_context: u32 = unsafe { ::std::mem::transmute(reset_frame_context) };
5648 reset_frame_context as u64
5649 });
5650 __bindgen_bitfield_unit.set(11usize, 1u8, {
5651 let refresh_frame_context: u32 =
5652 unsafe { ::std::mem::transmute(refresh_frame_context) };
5653 refresh_frame_context as u64
5654 });
5655 __bindgen_bitfield_unit.set(12usize, 2u8, {
5656 let frame_context_idx: u32 = unsafe { ::std::mem::transmute(frame_context_idx) };
5657 frame_context_idx as u64
5658 });
5659 __bindgen_bitfield_unit.set(14usize, 1u8, {
5660 let segmentation_enabled: u32 = unsafe { ::std::mem::transmute(segmentation_enabled) };
5661 segmentation_enabled as u64
5662 });
5663 __bindgen_bitfield_unit.set(15usize, 1u8, {
5664 let segmentation_temporal_update: u32 =
5665 unsafe { ::std::mem::transmute(segmentation_temporal_update) };
5666 segmentation_temporal_update as u64
5667 });
5668 __bindgen_bitfield_unit.set(16usize, 1u8, {
5669 let segmentation_update_map: u32 =
5670 unsafe { ::std::mem::transmute(segmentation_update_map) };
5671 segmentation_update_map as u64
5672 });
5673 __bindgen_bitfield_unit.set(17usize, 1u8, {
5674 let lossless_mode: u32 = unsafe { ::std::mem::transmute(lossless_mode) };
5675 lossless_mode as u64
5676 });
5677 __bindgen_bitfield_unit.set(18usize, 2u8, {
5678 let comp_prediction_mode: u32 = unsafe { ::std::mem::transmute(comp_prediction_mode) };
5679 comp_prediction_mode as u64
5680 });
5681 __bindgen_bitfield_unit.set(20usize, 1u8, {
5682 let auto_segmentation: u32 = unsafe { ::std::mem::transmute(auto_segmentation) };
5683 auto_segmentation as u64
5684 });
5685 __bindgen_bitfield_unit.set(21usize, 1u8, {
5686 let super_frame_flag: u32 = unsafe { ::std::mem::transmute(super_frame_flag) };
5687 super_frame_flag as u64
5688 });
5689 __bindgen_bitfield_unit.set(22usize, 10u8, {
5690 let reserved: u32 = unsafe { ::std::mem::transmute(reserved) };
5691 reserved as u64
5692 });
5693 __bindgen_bitfield_unit
5694 }
5695}
5696impl Default for _VAEncPictureParameterBufferVP9__bindgen_ty_2 {
5697 fn default() -> Self {
5698 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5699 unsafe {
5700 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5701 s.assume_init()
5702 }
5703 }
5704}
5705impl Default for _VAEncPictureParameterBufferVP9 {
5706 fn default() -> Self {
5707 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5708 unsafe {
5709 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5710 s.assume_init()
5711 }
5712 }
5713}
5714pub type VAEncPictureParameterBufferVP9 = _VAEncPictureParameterBufferVP9;
5715#[repr(C)]
5716#[derive(Copy, Clone)]
5717pub struct _VAEncSegParamVP9 {
5718 pub seg_flags: _VAEncSegParamVP9__bindgen_ty_1,
5719 pub segment_lf_level_delta: i8,
5720 pub segment_qindex_delta: i16,
5721 pub va_reserved: [u32; 4usize],
5722}
5723#[repr(C)]
5724#[derive(Copy, Clone)]
5725pub union _VAEncSegParamVP9__bindgen_ty_1 {
5726 pub bits: _VAEncSegParamVP9__bindgen_ty_1__bindgen_ty_1,
5727 pub value: u8,
5728}
5729#[repr(C, packed)]
5730#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
5731pub struct _VAEncSegParamVP9__bindgen_ty_1__bindgen_ty_1 {
5732 pub _bitfield_align_1: [u8; 0],
5733 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
5734}
5735impl _VAEncSegParamVP9__bindgen_ty_1__bindgen_ty_1 {
5736 #[inline]
5737 pub fn segment_reference_enabled(&self) -> u8 {
5738 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
5739 }
5740 #[inline]
5741 pub fn set_segment_reference_enabled(&mut self, val: u8) {
5742 unsafe {
5743 let val: u8 = ::std::mem::transmute(val);
5744 self._bitfield_1.set(0usize, 1u8, val as u64)
5745 }
5746 }
5747 #[inline]
5748 pub fn segment_reference(&self) -> u8 {
5749 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 2u8) as u8) }
5750 }
5751 #[inline]
5752 pub fn set_segment_reference(&mut self, val: u8) {
5753 unsafe {
5754 let val: u8 = ::std::mem::transmute(val);
5755 self._bitfield_1.set(1usize, 2u8, val as u64)
5756 }
5757 }
5758 #[inline]
5759 pub fn segment_reference_skipped(&self) -> u8 {
5760 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8) }
5761 }
5762 #[inline]
5763 pub fn set_segment_reference_skipped(&mut self, val: u8) {
5764 unsafe {
5765 let val: u8 = ::std::mem::transmute(val);
5766 self._bitfield_1.set(3usize, 1u8, val as u64)
5767 }
5768 }
5769 #[inline]
5770 pub fn reserved(&self) -> u8 {
5771 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 4u8) as u8) }
5772 }
5773 #[inline]
5774 pub fn set_reserved(&mut self, val: u8) {
5775 unsafe {
5776 let val: u8 = ::std::mem::transmute(val);
5777 self._bitfield_1.set(4usize, 4u8, val as u64)
5778 }
5779 }
5780 #[inline]
5781 pub fn new_bitfield_1(
5782 segment_reference_enabled: u8,
5783 segment_reference: u8,
5784 segment_reference_skipped: u8,
5785 reserved: u8,
5786 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
5787 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
5788 __bindgen_bitfield_unit.set(0usize, 1u8, {
5789 let segment_reference_enabled: u8 =
5790 unsafe { ::std::mem::transmute(segment_reference_enabled) };
5791 segment_reference_enabled as u64
5792 });
5793 __bindgen_bitfield_unit.set(1usize, 2u8, {
5794 let segment_reference: u8 = unsafe { ::std::mem::transmute(segment_reference) };
5795 segment_reference as u64
5796 });
5797 __bindgen_bitfield_unit.set(3usize, 1u8, {
5798 let segment_reference_skipped: u8 =
5799 unsafe { ::std::mem::transmute(segment_reference_skipped) };
5800 segment_reference_skipped as u64
5801 });
5802 __bindgen_bitfield_unit.set(4usize, 4u8, {
5803 let reserved: u8 = unsafe { ::std::mem::transmute(reserved) };
5804 reserved as u64
5805 });
5806 __bindgen_bitfield_unit
5807 }
5808}
5809impl Default for _VAEncSegParamVP9__bindgen_ty_1 {
5810 fn default() -> Self {
5811 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5812 unsafe {
5813 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5814 s.assume_init()
5815 }
5816 }
5817}
5818impl Default for _VAEncSegParamVP9 {
5819 fn default() -> Self {
5820 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5821 unsafe {
5822 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5823 s.assume_init()
5824 }
5825 }
5826}
5827pub type VAEncSegParamVP9 = _VAEncSegParamVP9;
5828#[repr(C)]
5829#[derive(Copy, Clone)]
5830pub struct _VAEncMiscParameterTypeVP9PerSegmantParam {
5831 pub seg_data: [VAEncSegParamVP9; 8usize],
5832 pub va_reserved: [u32; 4usize],
5833}
5834impl Default for _VAEncMiscParameterTypeVP9PerSegmantParam {
5835 fn default() -> Self {
5836 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5837 unsafe {
5838 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5839 s.assume_init()
5840 }
5841 }
5842}
5843pub type VAEncMiscParameterTypeVP9PerSegmantParam = _VAEncMiscParameterTypeVP9PerSegmantParam;
5844#[repr(C)]
5845#[derive(Debug, Copy, Clone, PartialEq, Eq)]
5846pub struct _VAEncMiscParameterFEIFrameControlH264 {
5847 pub function: u32,
5848 pub mb_ctrl: VABufferID,
5849 pub distortion: VABufferID,
5850 pub mv_data: VABufferID,
5851 pub mb_code_data: VABufferID,
5852 pub qp: VABufferID,
5853 pub mv_predictor: VABufferID,
5854 pub _bitfield_align_1: [u16; 0],
5855 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 16usize]>,
5856 pub max_frame_size: u32,
5857 pub num_passes: u32,
5858 pub delta_qp: *mut u8,
5859 pub reserved3: [u32; 4usize],
5860}
5861impl Default for _VAEncMiscParameterFEIFrameControlH264 {
5862 fn default() -> Self {
5863 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5864 unsafe {
5865 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5866 s.assume_init()
5867 }
5868 }
5869}
5870impl _VAEncMiscParameterFEIFrameControlH264 {
5871 #[inline]
5872 pub fn num_mv_predictors_l0(&self) -> u32 {
5873 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 16u8) as u32) }
5874 }
5875 #[inline]
5876 pub fn set_num_mv_predictors_l0(&mut self, val: u32) {
5877 unsafe {
5878 let val: u32 = ::std::mem::transmute(val);
5879 self._bitfield_1.set(0usize, 16u8, val as u64)
5880 }
5881 }
5882 #[inline]
5883 pub fn num_mv_predictors_l1(&self) -> u32 {
5884 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 16u8) as u32) }
5885 }
5886 #[inline]
5887 pub fn set_num_mv_predictors_l1(&mut self, val: u32) {
5888 unsafe {
5889 let val: u32 = ::std::mem::transmute(val);
5890 self._bitfield_1.set(16usize, 16u8, val as u64)
5891 }
5892 }
5893 #[inline]
5894 pub fn search_path(&self) -> u32 {
5895 unsafe { ::std::mem::transmute(self._bitfield_1.get(32usize, 8u8) as u32) }
5896 }
5897 #[inline]
5898 pub fn set_search_path(&mut self, val: u32) {
5899 unsafe {
5900 let val: u32 = ::std::mem::transmute(val);
5901 self._bitfield_1.set(32usize, 8u8, val as u64)
5902 }
5903 }
5904 #[inline]
5905 pub fn len_sp(&self) -> u32 {
5906 unsafe { ::std::mem::transmute(self._bitfield_1.get(40usize, 8u8) as u32) }
5907 }
5908 #[inline]
5909 pub fn set_len_sp(&mut self, val: u32) {
5910 unsafe {
5911 let val: u32 = ::std::mem::transmute(val);
5912 self._bitfield_1.set(40usize, 8u8, val as u64)
5913 }
5914 }
5915 #[inline]
5916 pub fn reserved0(&self) -> u32 {
5917 unsafe { ::std::mem::transmute(self._bitfield_1.get(48usize, 16u8) as u32) }
5918 }
5919 #[inline]
5920 pub fn set_reserved0(&mut self, val: u32) {
5921 unsafe {
5922 let val: u32 = ::std::mem::transmute(val);
5923 self._bitfield_1.set(48usize, 16u8, val as u64)
5924 }
5925 }
5926 #[inline]
5927 pub fn sub_mb_part_mask(&self) -> u32 {
5928 unsafe { ::std::mem::transmute(self._bitfield_1.get(64usize, 7u8) as u32) }
5929 }
5930 #[inline]
5931 pub fn set_sub_mb_part_mask(&mut self, val: u32) {
5932 unsafe {
5933 let val: u32 = ::std::mem::transmute(val);
5934 self._bitfield_1.set(64usize, 7u8, val as u64)
5935 }
5936 }
5937 #[inline]
5938 pub fn intra_part_mask(&self) -> u32 {
5939 unsafe { ::std::mem::transmute(self._bitfield_1.get(71usize, 5u8) as u32) }
5940 }
5941 #[inline]
5942 pub fn set_intra_part_mask(&mut self, val: u32) {
5943 unsafe {
5944 let val: u32 = ::std::mem::transmute(val);
5945 self._bitfield_1.set(71usize, 5u8, val as u64)
5946 }
5947 }
5948 #[inline]
5949 pub fn multi_pred_l0(&self) -> u32 {
5950 unsafe { ::std::mem::transmute(self._bitfield_1.get(76usize, 1u8) as u32) }
5951 }
5952 #[inline]
5953 pub fn set_multi_pred_l0(&mut self, val: u32) {
5954 unsafe {
5955 let val: u32 = ::std::mem::transmute(val);
5956 self._bitfield_1.set(76usize, 1u8, val as u64)
5957 }
5958 }
5959 #[inline]
5960 pub fn multi_pred_l1(&self) -> u32 {
5961 unsafe { ::std::mem::transmute(self._bitfield_1.get(77usize, 1u8) as u32) }
5962 }
5963 #[inline]
5964 pub fn set_multi_pred_l1(&mut self, val: u32) {
5965 unsafe {
5966 let val: u32 = ::std::mem::transmute(val);
5967 self._bitfield_1.set(77usize, 1u8, val as u64)
5968 }
5969 }
5970 #[inline]
5971 pub fn sub_pel_mode(&self) -> u32 {
5972 unsafe { ::std::mem::transmute(self._bitfield_1.get(78usize, 2u8) as u32) }
5973 }
5974 #[inline]
5975 pub fn set_sub_pel_mode(&mut self, val: u32) {
5976 unsafe {
5977 let val: u32 = ::std::mem::transmute(val);
5978 self._bitfield_1.set(78usize, 2u8, val as u64)
5979 }
5980 }
5981 #[inline]
5982 pub fn inter_sad(&self) -> u32 {
5983 unsafe { ::std::mem::transmute(self._bitfield_1.get(80usize, 2u8) as u32) }
5984 }
5985 #[inline]
5986 pub fn set_inter_sad(&mut self, val: u32) {
5987 unsafe {
5988 let val: u32 = ::std::mem::transmute(val);
5989 self._bitfield_1.set(80usize, 2u8, val as u64)
5990 }
5991 }
5992 #[inline]
5993 pub fn intra_sad(&self) -> u32 {
5994 unsafe { ::std::mem::transmute(self._bitfield_1.get(82usize, 2u8) as u32) }
5995 }
5996 #[inline]
5997 pub fn set_intra_sad(&mut self, val: u32) {
5998 unsafe {
5999 let val: u32 = ::std::mem::transmute(val);
6000 self._bitfield_1.set(82usize, 2u8, val as u64)
6001 }
6002 }
6003 #[inline]
6004 pub fn distortion_type(&self) -> u32 {
6005 unsafe { ::std::mem::transmute(self._bitfield_1.get(84usize, 1u8) as u32) }
6006 }
6007 #[inline]
6008 pub fn set_distortion_type(&mut self, val: u32) {
6009 unsafe {
6010 let val: u32 = ::std::mem::transmute(val);
6011 self._bitfield_1.set(84usize, 1u8, val as u64)
6012 }
6013 }
6014 #[inline]
6015 pub fn repartition_check_enable(&self) -> u32 {
6016 unsafe { ::std::mem::transmute(self._bitfield_1.get(85usize, 1u8) as u32) }
6017 }
6018 #[inline]
6019 pub fn set_repartition_check_enable(&mut self, val: u32) {
6020 unsafe {
6021 let val: u32 = ::std::mem::transmute(val);
6022 self._bitfield_1.set(85usize, 1u8, val as u64)
6023 }
6024 }
6025 #[inline]
6026 pub fn adaptive_search(&self) -> u32 {
6027 unsafe { ::std::mem::transmute(self._bitfield_1.get(86usize, 1u8) as u32) }
6028 }
6029 #[inline]
6030 pub fn set_adaptive_search(&mut self, val: u32) {
6031 unsafe {
6032 let val: u32 = ::std::mem::transmute(val);
6033 self._bitfield_1.set(86usize, 1u8, val as u64)
6034 }
6035 }
6036 #[inline]
6037 pub fn mv_predictor_enable(&self) -> u32 {
6038 unsafe { ::std::mem::transmute(self._bitfield_1.get(87usize, 1u8) as u32) }
6039 }
6040 #[inline]
6041 pub fn set_mv_predictor_enable(&mut self, val: u32) {
6042 unsafe {
6043 let val: u32 = ::std::mem::transmute(val);
6044 self._bitfield_1.set(87usize, 1u8, val as u64)
6045 }
6046 }
6047 #[inline]
6048 pub fn mb_qp(&self) -> u32 {
6049 unsafe { ::std::mem::transmute(self._bitfield_1.get(88usize, 1u8) as u32) }
6050 }
6051 #[inline]
6052 pub fn set_mb_qp(&mut self, val: u32) {
6053 unsafe {
6054 let val: u32 = ::std::mem::transmute(val);
6055 self._bitfield_1.set(88usize, 1u8, val as u64)
6056 }
6057 }
6058 #[inline]
6059 pub fn mb_input(&self) -> u32 {
6060 unsafe { ::std::mem::transmute(self._bitfield_1.get(89usize, 1u8) as u32) }
6061 }
6062 #[inline]
6063 pub fn set_mb_input(&mut self, val: u32) {
6064 unsafe {
6065 let val: u32 = ::std::mem::transmute(val);
6066 self._bitfield_1.set(89usize, 1u8, val as u64)
6067 }
6068 }
6069 #[inline]
6070 pub fn mb_size_ctrl(&self) -> u32 {
6071 unsafe { ::std::mem::transmute(self._bitfield_1.get(90usize, 1u8) as u32) }
6072 }
6073 #[inline]
6074 pub fn set_mb_size_ctrl(&mut self, val: u32) {
6075 unsafe {
6076 let val: u32 = ::std::mem::transmute(val);
6077 self._bitfield_1.set(90usize, 1u8, val as u64)
6078 }
6079 }
6080 #[inline]
6081 pub fn colocated_mb_distortion(&self) -> u32 {
6082 unsafe { ::std::mem::transmute(self._bitfield_1.get(91usize, 1u8) as u32) }
6083 }
6084 #[inline]
6085 pub fn set_colocated_mb_distortion(&mut self, val: u32) {
6086 unsafe {
6087 let val: u32 = ::std::mem::transmute(val);
6088 self._bitfield_1.set(91usize, 1u8, val as u64)
6089 }
6090 }
6091 #[inline]
6092 pub fn reserved1(&self) -> u32 {
6093 unsafe { ::std::mem::transmute(self._bitfield_1.get(92usize, 4u8) as u32) }
6094 }
6095 #[inline]
6096 pub fn set_reserved1(&mut self, val: u32) {
6097 unsafe {
6098 let val: u32 = ::std::mem::transmute(val);
6099 self._bitfield_1.set(92usize, 4u8, val as u64)
6100 }
6101 }
6102 #[inline]
6103 pub fn ref_width(&self) -> u32 {
6104 unsafe { ::std::mem::transmute(self._bitfield_1.get(96usize, 8u8) as u32) }
6105 }
6106 #[inline]
6107 pub fn set_ref_width(&mut self, val: u32) {
6108 unsafe {
6109 let val: u32 = ::std::mem::transmute(val);
6110 self._bitfield_1.set(96usize, 8u8, val as u64)
6111 }
6112 }
6113 #[inline]
6114 pub fn ref_height(&self) -> u32 {
6115 unsafe { ::std::mem::transmute(self._bitfield_1.get(104usize, 8u8) as u32) }
6116 }
6117 #[inline]
6118 pub fn set_ref_height(&mut self, val: u32) {
6119 unsafe {
6120 let val: u32 = ::std::mem::transmute(val);
6121 self._bitfield_1.set(104usize, 8u8, val as u64)
6122 }
6123 }
6124 #[inline]
6125 pub fn search_window(&self) -> u32 {
6126 unsafe { ::std::mem::transmute(self._bitfield_1.get(112usize, 4u8) as u32) }
6127 }
6128 #[inline]
6129 pub fn set_search_window(&mut self, val: u32) {
6130 unsafe {
6131 let val: u32 = ::std::mem::transmute(val);
6132 self._bitfield_1.set(112usize, 4u8, val as u64)
6133 }
6134 }
6135 #[inline]
6136 pub fn reserved2(&self) -> u32 {
6137 unsafe { ::std::mem::transmute(self._bitfield_1.get(116usize, 12u8) as u32) }
6138 }
6139 #[inline]
6140 pub fn set_reserved2(&mut self, val: u32) {
6141 unsafe {
6142 let val: u32 = ::std::mem::transmute(val);
6143 self._bitfield_1.set(116usize, 12u8, val as u64)
6144 }
6145 }
6146 #[inline]
6147 pub fn new_bitfield_1(
6148 num_mv_predictors_l0: u32,
6149 num_mv_predictors_l1: u32,
6150 search_path: u32,
6151 len_sp: u32,
6152 reserved0: u32,
6153 sub_mb_part_mask: u32,
6154 intra_part_mask: u32,
6155 multi_pred_l0: u32,
6156 multi_pred_l1: u32,
6157 sub_pel_mode: u32,
6158 inter_sad: u32,
6159 intra_sad: u32,
6160 distortion_type: u32,
6161 repartition_check_enable: u32,
6162 adaptive_search: u32,
6163 mv_predictor_enable: u32,
6164 mb_qp: u32,
6165 mb_input: u32,
6166 mb_size_ctrl: u32,
6167 colocated_mb_distortion: u32,
6168 reserved1: u32,
6169 ref_width: u32,
6170 ref_height: u32,
6171 search_window: u32,
6172 reserved2: u32,
6173 ) -> __BindgenBitfieldUnit<[u8; 16usize]> {
6174 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 16usize]> = Default::default();
6175 __bindgen_bitfield_unit.set(0usize, 16u8, {
6176 let num_mv_predictors_l0: u32 = unsafe { ::std::mem::transmute(num_mv_predictors_l0) };
6177 num_mv_predictors_l0 as u64
6178 });
6179 __bindgen_bitfield_unit.set(16usize, 16u8, {
6180 let num_mv_predictors_l1: u32 = unsafe { ::std::mem::transmute(num_mv_predictors_l1) };
6181 num_mv_predictors_l1 as u64
6182 });
6183 __bindgen_bitfield_unit.set(32usize, 8u8, {
6184 let search_path: u32 = unsafe { ::std::mem::transmute(search_path) };
6185 search_path as u64
6186 });
6187 __bindgen_bitfield_unit.set(40usize, 8u8, {
6188 let len_sp: u32 = unsafe { ::std::mem::transmute(len_sp) };
6189 len_sp as u64
6190 });
6191 __bindgen_bitfield_unit.set(48usize, 16u8, {
6192 let reserved0: u32 = unsafe { ::std::mem::transmute(reserved0) };
6193 reserved0 as u64
6194 });
6195 __bindgen_bitfield_unit.set(64usize, 7u8, {
6196 let sub_mb_part_mask: u32 = unsafe { ::std::mem::transmute(sub_mb_part_mask) };
6197 sub_mb_part_mask as u64
6198 });
6199 __bindgen_bitfield_unit.set(71usize, 5u8, {
6200 let intra_part_mask: u32 = unsafe { ::std::mem::transmute(intra_part_mask) };
6201 intra_part_mask as u64
6202 });
6203 __bindgen_bitfield_unit.set(76usize, 1u8, {
6204 let multi_pred_l0: u32 = unsafe { ::std::mem::transmute(multi_pred_l0) };
6205 multi_pred_l0 as u64
6206 });
6207 __bindgen_bitfield_unit.set(77usize, 1u8, {
6208 let multi_pred_l1: u32 = unsafe { ::std::mem::transmute(multi_pred_l1) };
6209 multi_pred_l1 as u64
6210 });
6211 __bindgen_bitfield_unit.set(78usize, 2u8, {
6212 let sub_pel_mode: u32 = unsafe { ::std::mem::transmute(sub_pel_mode) };
6213 sub_pel_mode as u64
6214 });
6215 __bindgen_bitfield_unit.set(80usize, 2u8, {
6216 let inter_sad: u32 = unsafe { ::std::mem::transmute(inter_sad) };
6217 inter_sad as u64
6218 });
6219 __bindgen_bitfield_unit.set(82usize, 2u8, {
6220 let intra_sad: u32 = unsafe { ::std::mem::transmute(intra_sad) };
6221 intra_sad as u64
6222 });
6223 __bindgen_bitfield_unit.set(84usize, 1u8, {
6224 let distortion_type: u32 = unsafe { ::std::mem::transmute(distortion_type) };
6225 distortion_type as u64
6226 });
6227 __bindgen_bitfield_unit.set(85usize, 1u8, {
6228 let repartition_check_enable: u32 =
6229 unsafe { ::std::mem::transmute(repartition_check_enable) };
6230 repartition_check_enable as u64
6231 });
6232 __bindgen_bitfield_unit.set(86usize, 1u8, {
6233 let adaptive_search: u32 = unsafe { ::std::mem::transmute(adaptive_search) };
6234 adaptive_search as u64
6235 });
6236 __bindgen_bitfield_unit.set(87usize, 1u8, {
6237 let mv_predictor_enable: u32 = unsafe { ::std::mem::transmute(mv_predictor_enable) };
6238 mv_predictor_enable as u64
6239 });
6240 __bindgen_bitfield_unit.set(88usize, 1u8, {
6241 let mb_qp: u32 = unsafe { ::std::mem::transmute(mb_qp) };
6242 mb_qp as u64
6243 });
6244 __bindgen_bitfield_unit.set(89usize, 1u8, {
6245 let mb_input: u32 = unsafe { ::std::mem::transmute(mb_input) };
6246 mb_input as u64
6247 });
6248 __bindgen_bitfield_unit.set(90usize, 1u8, {
6249 let mb_size_ctrl: u32 = unsafe { ::std::mem::transmute(mb_size_ctrl) };
6250 mb_size_ctrl as u64
6251 });
6252 __bindgen_bitfield_unit.set(91usize, 1u8, {
6253 let colocated_mb_distortion: u32 =
6254 unsafe { ::std::mem::transmute(colocated_mb_distortion) };
6255 colocated_mb_distortion as u64
6256 });
6257 __bindgen_bitfield_unit.set(92usize, 4u8, {
6258 let reserved1: u32 = unsafe { ::std::mem::transmute(reserved1) };
6259 reserved1 as u64
6260 });
6261 __bindgen_bitfield_unit.set(96usize, 8u8, {
6262 let ref_width: u32 = unsafe { ::std::mem::transmute(ref_width) };
6263 ref_width as u64
6264 });
6265 __bindgen_bitfield_unit.set(104usize, 8u8, {
6266 let ref_height: u32 = unsafe { ::std::mem::transmute(ref_height) };
6267 ref_height as u64
6268 });
6269 __bindgen_bitfield_unit.set(112usize, 4u8, {
6270 let search_window: u32 = unsafe { ::std::mem::transmute(search_window) };
6271 search_window as u64
6272 });
6273 __bindgen_bitfield_unit.set(116usize, 12u8, {
6274 let reserved2: u32 = unsafe { ::std::mem::transmute(reserved2) };
6275 reserved2 as u64
6276 });
6277 __bindgen_bitfield_unit
6278 }
6279}
6280pub type VAEncMiscParameterFEIFrameControlH264 = _VAEncMiscParameterFEIFrameControlH264;
6281#[repr(C)]
6282#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
6283pub struct _VAEncFEIMBControlH264 {
6284 pub _bitfield_align_1: [u32; 0],
6285 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
6286 pub reserved1: u32,
6287 pub reserved2: u32,
6288 pub _bitfield_align_2: [u16; 0],
6289 pub _bitfield_2: __BindgenBitfieldUnit<[u8; 4usize]>,
6290}
6291impl _VAEncFEIMBControlH264 {
6292 #[inline]
6293 pub fn force_to_intra(&self) -> u32 {
6294 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
6295 }
6296 #[inline]
6297 pub fn set_force_to_intra(&mut self, val: u32) {
6298 unsafe {
6299 let val: u32 = ::std::mem::transmute(val);
6300 self._bitfield_1.set(0usize, 1u8, val as u64)
6301 }
6302 }
6303 #[inline]
6304 pub fn force_to_skip(&self) -> u32 {
6305 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
6306 }
6307 #[inline]
6308 pub fn set_force_to_skip(&mut self, val: u32) {
6309 unsafe {
6310 let val: u32 = ::std::mem::transmute(val);
6311 self._bitfield_1.set(1usize, 1u8, val as u64)
6312 }
6313 }
6314 #[inline]
6315 pub fn force_to_nonskip(&self) -> u32 {
6316 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
6317 }
6318 #[inline]
6319 pub fn set_force_to_nonskip(&mut self, val: u32) {
6320 unsafe {
6321 let val: u32 = ::std::mem::transmute(val);
6322 self._bitfield_1.set(2usize, 1u8, val as u64)
6323 }
6324 }
6325 #[inline]
6326 pub fn enable_direct_bias_adjustment(&self) -> u32 {
6327 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
6328 }
6329 #[inline]
6330 pub fn set_enable_direct_bias_adjustment(&mut self, val: u32) {
6331 unsafe {
6332 let val: u32 = ::std::mem::transmute(val);
6333 self._bitfield_1.set(3usize, 1u8, val as u64)
6334 }
6335 }
6336 #[inline]
6337 pub fn enable_motion_bias_adjustment(&self) -> u32 {
6338 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
6339 }
6340 #[inline]
6341 pub fn set_enable_motion_bias_adjustment(&mut self, val: u32) {
6342 unsafe {
6343 let val: u32 = ::std::mem::transmute(val);
6344 self._bitfield_1.set(4usize, 1u8, val as u64)
6345 }
6346 }
6347 #[inline]
6348 pub fn ext_mv_cost_scaling_factor(&self) -> u32 {
6349 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 3u8) as u32) }
6350 }
6351 #[inline]
6352 pub fn set_ext_mv_cost_scaling_factor(&mut self, val: u32) {
6353 unsafe {
6354 let val: u32 = ::std::mem::transmute(val);
6355 self._bitfield_1.set(5usize, 3u8, val as u64)
6356 }
6357 }
6358 #[inline]
6359 pub fn reserved0(&self) -> u32 {
6360 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 24u8) as u32) }
6361 }
6362 #[inline]
6363 pub fn set_reserved0(&mut self, val: u32) {
6364 unsafe {
6365 let val: u32 = ::std::mem::transmute(val);
6366 self._bitfield_1.set(8usize, 24u8, val as u64)
6367 }
6368 }
6369 #[inline]
6370 pub fn new_bitfield_1(
6371 force_to_intra: u32,
6372 force_to_skip: u32,
6373 force_to_nonskip: u32,
6374 enable_direct_bias_adjustment: u32,
6375 enable_motion_bias_adjustment: u32,
6376 ext_mv_cost_scaling_factor: u32,
6377 reserved0: u32,
6378 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
6379 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
6380 __bindgen_bitfield_unit.set(0usize, 1u8, {
6381 let force_to_intra: u32 = unsafe { ::std::mem::transmute(force_to_intra) };
6382 force_to_intra as u64
6383 });
6384 __bindgen_bitfield_unit.set(1usize, 1u8, {
6385 let force_to_skip: u32 = unsafe { ::std::mem::transmute(force_to_skip) };
6386 force_to_skip as u64
6387 });
6388 __bindgen_bitfield_unit.set(2usize, 1u8, {
6389 let force_to_nonskip: u32 = unsafe { ::std::mem::transmute(force_to_nonskip) };
6390 force_to_nonskip as u64
6391 });
6392 __bindgen_bitfield_unit.set(3usize, 1u8, {
6393 let enable_direct_bias_adjustment: u32 =
6394 unsafe { ::std::mem::transmute(enable_direct_bias_adjustment) };
6395 enable_direct_bias_adjustment as u64
6396 });
6397 __bindgen_bitfield_unit.set(4usize, 1u8, {
6398 let enable_motion_bias_adjustment: u32 =
6399 unsafe { ::std::mem::transmute(enable_motion_bias_adjustment) };
6400 enable_motion_bias_adjustment as u64
6401 });
6402 __bindgen_bitfield_unit.set(5usize, 3u8, {
6403 let ext_mv_cost_scaling_factor: u32 =
6404 unsafe { ::std::mem::transmute(ext_mv_cost_scaling_factor) };
6405 ext_mv_cost_scaling_factor as u64
6406 });
6407 __bindgen_bitfield_unit.set(8usize, 24u8, {
6408 let reserved0: u32 = unsafe { ::std::mem::transmute(reserved0) };
6409 reserved0 as u64
6410 });
6411 __bindgen_bitfield_unit
6412 }
6413 #[inline]
6414 pub fn reserved3(&self) -> u32 {
6415 unsafe { ::std::mem::transmute(self._bitfield_2.get(0usize, 16u8) as u32) }
6416 }
6417 #[inline]
6418 pub fn set_reserved3(&mut self, val: u32) {
6419 unsafe {
6420 let val: u32 = ::std::mem::transmute(val);
6421 self._bitfield_2.set(0usize, 16u8, val as u64)
6422 }
6423 }
6424 #[inline]
6425 pub fn target_size_in_word(&self) -> u32 {
6426 unsafe { ::std::mem::transmute(self._bitfield_2.get(16usize, 8u8) as u32) }
6427 }
6428 #[inline]
6429 pub fn set_target_size_in_word(&mut self, val: u32) {
6430 unsafe {
6431 let val: u32 = ::std::mem::transmute(val);
6432 self._bitfield_2.set(16usize, 8u8, val as u64)
6433 }
6434 }
6435 #[inline]
6436 pub fn max_size_in_word(&self) -> u32 {
6437 unsafe { ::std::mem::transmute(self._bitfield_2.get(24usize, 8u8) as u32) }
6438 }
6439 #[inline]
6440 pub fn set_max_size_in_word(&mut self, val: u32) {
6441 unsafe {
6442 let val: u32 = ::std::mem::transmute(val);
6443 self._bitfield_2.set(24usize, 8u8, val as u64)
6444 }
6445 }
6446 #[inline]
6447 pub fn new_bitfield_2(
6448 reserved3: u32,
6449 target_size_in_word: u32,
6450 max_size_in_word: u32,
6451 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
6452 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
6453 __bindgen_bitfield_unit.set(0usize, 16u8, {
6454 let reserved3: u32 = unsafe { ::std::mem::transmute(reserved3) };
6455 reserved3 as u64
6456 });
6457 __bindgen_bitfield_unit.set(16usize, 8u8, {
6458 let target_size_in_word: u32 = unsafe { ::std::mem::transmute(target_size_in_word) };
6459 target_size_in_word as u64
6460 });
6461 __bindgen_bitfield_unit.set(24usize, 8u8, {
6462 let max_size_in_word: u32 = unsafe { ::std::mem::transmute(max_size_in_word) };
6463 max_size_in_word as u64
6464 });
6465 __bindgen_bitfield_unit
6466 }
6467}
6468pub type VAEncFEIMBControlH264 = _VAEncFEIMBControlH264;
6469#[repr(C)]
6470#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
6471pub struct _VAEncFEIMVPredictorH264 {
6472 pub ref_idx: [_VAEncFEIMVPredictorH264__bindgen_ty_1; 4usize],
6473 pub reserved: u32,
6474 pub mv: [VAMotionVector; 4usize],
6475}
6476#[repr(C, packed)]
6477#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
6478pub struct _VAEncFEIMVPredictorH264__bindgen_ty_1 {
6479 pub _bitfield_align_1: [u8; 0],
6480 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
6481}
6482impl _VAEncFEIMVPredictorH264__bindgen_ty_1 {
6483 #[inline]
6484 pub fn ref_idx_l0(&self) -> u8 {
6485 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u8) }
6486 }
6487 #[inline]
6488 pub fn set_ref_idx_l0(&mut self, val: u8) {
6489 unsafe {
6490 let val: u8 = ::std::mem::transmute(val);
6491 self._bitfield_1.set(0usize, 4u8, val as u64)
6492 }
6493 }
6494 #[inline]
6495 pub fn ref_idx_l1(&self) -> u8 {
6496 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 4u8) as u8) }
6497 }
6498 #[inline]
6499 pub fn set_ref_idx_l1(&mut self, val: u8) {
6500 unsafe {
6501 let val: u8 = ::std::mem::transmute(val);
6502 self._bitfield_1.set(4usize, 4u8, val as u64)
6503 }
6504 }
6505 #[inline]
6506 pub fn new_bitfield_1(ref_idx_l0: u8, ref_idx_l1: u8) -> __BindgenBitfieldUnit<[u8; 1usize]> {
6507 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
6508 __bindgen_bitfield_unit.set(0usize, 4u8, {
6509 let ref_idx_l0: u8 = unsafe { ::std::mem::transmute(ref_idx_l0) };
6510 ref_idx_l0 as u64
6511 });
6512 __bindgen_bitfield_unit.set(4usize, 4u8, {
6513 let ref_idx_l1: u8 = unsafe { ::std::mem::transmute(ref_idx_l1) };
6514 ref_idx_l1 as u64
6515 });
6516 __bindgen_bitfield_unit
6517 }
6518}
6519pub type VAEncFEIMVPredictorH264 = _VAEncFEIMVPredictorH264;
6520#[repr(C)]
6521#[derive(Copy, Clone)]
6522pub struct _VAEncFEIMBCodeH264 {
6523 pub reserved0: [u32; 3usize],
6524 pub _bitfield_align_1: [u32; 0],
6525 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 16usize]>,
6526 pub mb_mode: _VAEncFEIMBCodeH264__bindgen_ty_1,
6527 pub _bitfield_align_2: [u16; 0],
6528 pub _bitfield_2: __BindgenBitfieldUnit<[u8; 4usize]>,
6529 pub reserved9: [u32; 4usize],
6530 pub reserved10: u32,
6531}
6532#[repr(C)]
6533#[derive(Copy, Clone)]
6534pub union _VAEncFEIMBCodeH264__bindgen_ty_1 {
6535 pub intra_mb: _VAEncFEIMBCodeH264__bindgen_ty_1__bindgen_ty_1,
6536 pub inter_mb: _VAEncFEIMBCodeH264__bindgen_ty_1__bindgen_ty_2,
6537}
6538#[repr(C)]
6539#[repr(align(4))]
6540#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
6541pub struct _VAEncFEIMBCodeH264__bindgen_ty_1__bindgen_ty_1 {
6542 pub _bitfield_align_1: [u32; 0],
6543 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 12usize]>,
6544}
6545impl _VAEncFEIMBCodeH264__bindgen_ty_1__bindgen_ty_1 {
6546 #[inline]
6547 pub fn luma_intra_pred_modes0(&self) -> u32 {
6548 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 16u8) as u32) }
6549 }
6550 #[inline]
6551 pub fn set_luma_intra_pred_modes0(&mut self, val: u32) {
6552 unsafe {
6553 let val: u32 = ::std::mem::transmute(val);
6554 self._bitfield_1.set(0usize, 16u8, val as u64)
6555 }
6556 }
6557 #[inline]
6558 pub fn luma_intra_pred_modes1(&self) -> u32 {
6559 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 16u8) as u32) }
6560 }
6561 #[inline]
6562 pub fn set_luma_intra_pred_modes1(&mut self, val: u32) {
6563 unsafe {
6564 let val: u32 = ::std::mem::transmute(val);
6565 self._bitfield_1.set(16usize, 16u8, val as u64)
6566 }
6567 }
6568 #[inline]
6569 pub fn luma_intra_pred_modes2(&self) -> u32 {
6570 unsafe { ::std::mem::transmute(self._bitfield_1.get(32usize, 16u8) as u32) }
6571 }
6572 #[inline]
6573 pub fn set_luma_intra_pred_modes2(&mut self, val: u32) {
6574 unsafe {
6575 let val: u32 = ::std::mem::transmute(val);
6576 self._bitfield_1.set(32usize, 16u8, val as u64)
6577 }
6578 }
6579 #[inline]
6580 pub fn luma_intra_pred_modes3(&self) -> u32 {
6581 unsafe { ::std::mem::transmute(self._bitfield_1.get(48usize, 16u8) as u32) }
6582 }
6583 #[inline]
6584 pub fn set_luma_intra_pred_modes3(&mut self, val: u32) {
6585 unsafe {
6586 let val: u32 = ::std::mem::transmute(val);
6587 self._bitfield_1.set(48usize, 16u8, val as u64)
6588 }
6589 }
6590 #[inline]
6591 pub fn chroma_intra_pred_mode(&self) -> u32 {
6592 unsafe { ::std::mem::transmute(self._bitfield_1.get(64usize, 2u8) as u32) }
6593 }
6594 #[inline]
6595 pub fn set_chroma_intra_pred_mode(&mut self, val: u32) {
6596 unsafe {
6597 let val: u32 = ::std::mem::transmute(val);
6598 self._bitfield_1.set(64usize, 2u8, val as u64)
6599 }
6600 }
6601 #[inline]
6602 pub fn intra_pred_avail_flag(&self) -> u32 {
6603 unsafe { ::std::mem::transmute(self._bitfield_1.get(66usize, 5u8) as u32) }
6604 }
6605 #[inline]
6606 pub fn set_intra_pred_avail_flag(&mut self, val: u32) {
6607 unsafe {
6608 let val: u32 = ::std::mem::transmute(val);
6609 self._bitfield_1.set(66usize, 5u8, val as u64)
6610 }
6611 }
6612 #[inline]
6613 pub fn intra_pred_avail_flagF(&self) -> u32 {
6614 unsafe { ::std::mem::transmute(self._bitfield_1.get(71usize, 1u8) as u32) }
6615 }
6616 #[inline]
6617 pub fn set_intra_pred_avail_flagF(&mut self, val: u32) {
6618 unsafe {
6619 let val: u32 = ::std::mem::transmute(val);
6620 self._bitfield_1.set(71usize, 1u8, val as u64)
6621 }
6622 }
6623 #[inline]
6624 pub fn reserved6(&self) -> u32 {
6625 unsafe { ::std::mem::transmute(self._bitfield_1.get(72usize, 24u8) as u32) }
6626 }
6627 #[inline]
6628 pub fn set_reserved6(&mut self, val: u32) {
6629 unsafe {
6630 let val: u32 = ::std::mem::transmute(val);
6631 self._bitfield_1.set(72usize, 24u8, val as u64)
6632 }
6633 }
6634 #[inline]
6635 pub fn new_bitfield_1(
6636 luma_intra_pred_modes0: u32,
6637 luma_intra_pred_modes1: u32,
6638 luma_intra_pred_modes2: u32,
6639 luma_intra_pred_modes3: u32,
6640 chroma_intra_pred_mode: u32,
6641 intra_pred_avail_flag: u32,
6642 intra_pred_avail_flagF: u32,
6643 reserved6: u32,
6644 ) -> __BindgenBitfieldUnit<[u8; 12usize]> {
6645 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 12usize]> = Default::default();
6646 __bindgen_bitfield_unit.set(0usize, 16u8, {
6647 let luma_intra_pred_modes0: u32 =
6648 unsafe { ::std::mem::transmute(luma_intra_pred_modes0) };
6649 luma_intra_pred_modes0 as u64
6650 });
6651 __bindgen_bitfield_unit.set(16usize, 16u8, {
6652 let luma_intra_pred_modes1: u32 =
6653 unsafe { ::std::mem::transmute(luma_intra_pred_modes1) };
6654 luma_intra_pred_modes1 as u64
6655 });
6656 __bindgen_bitfield_unit.set(32usize, 16u8, {
6657 let luma_intra_pred_modes2: u32 =
6658 unsafe { ::std::mem::transmute(luma_intra_pred_modes2) };
6659 luma_intra_pred_modes2 as u64
6660 });
6661 __bindgen_bitfield_unit.set(48usize, 16u8, {
6662 let luma_intra_pred_modes3: u32 =
6663 unsafe { ::std::mem::transmute(luma_intra_pred_modes3) };
6664 luma_intra_pred_modes3 as u64
6665 });
6666 __bindgen_bitfield_unit.set(64usize, 2u8, {
6667 let chroma_intra_pred_mode: u32 =
6668 unsafe { ::std::mem::transmute(chroma_intra_pred_mode) };
6669 chroma_intra_pred_mode as u64
6670 });
6671 __bindgen_bitfield_unit.set(66usize, 5u8, {
6672 let intra_pred_avail_flag: u32 =
6673 unsafe { ::std::mem::transmute(intra_pred_avail_flag) };
6674 intra_pred_avail_flag as u64
6675 });
6676 __bindgen_bitfield_unit.set(71usize, 1u8, {
6677 let intra_pred_avail_flagF: u32 =
6678 unsafe { ::std::mem::transmute(intra_pred_avail_flagF) };
6679 intra_pred_avail_flagF as u64
6680 });
6681 __bindgen_bitfield_unit.set(72usize, 24u8, {
6682 let reserved6: u32 = unsafe { ::std::mem::transmute(reserved6) };
6683 reserved6 as u64
6684 });
6685 __bindgen_bitfield_unit
6686 }
6687}
6688#[repr(C)]
6689#[repr(align(4))]
6690#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
6691pub struct _VAEncFEIMBCodeH264__bindgen_ty_1__bindgen_ty_2 {
6692 pub _bitfield_align_1: [u16; 0],
6693 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 12usize]>,
6694}
6695impl _VAEncFEIMBCodeH264__bindgen_ty_1__bindgen_ty_2 {
6696 #[inline]
6697 pub fn sub_mb_shapes(&self) -> u32 {
6698 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 8u8) as u32) }
6699 }
6700 #[inline]
6701 pub fn set_sub_mb_shapes(&mut self, val: u32) {
6702 unsafe {
6703 let val: u32 = ::std::mem::transmute(val);
6704 self._bitfield_1.set(0usize, 8u8, val as u64)
6705 }
6706 }
6707 #[inline]
6708 pub fn sub_mb_pred_modes(&self) -> u32 {
6709 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 8u8) as u32) }
6710 }
6711 #[inline]
6712 pub fn set_sub_mb_pred_modes(&mut self, val: u32) {
6713 unsafe {
6714 let val: u32 = ::std::mem::transmute(val);
6715 self._bitfield_1.set(8usize, 8u8, val as u64)
6716 }
6717 }
6718 #[inline]
6719 pub fn reserved7(&self) -> u32 {
6720 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 16u8) as u32) }
6721 }
6722 #[inline]
6723 pub fn set_reserved7(&mut self, val: u32) {
6724 unsafe {
6725 let val: u32 = ::std::mem::transmute(val);
6726 self._bitfield_1.set(16usize, 16u8, val as u64)
6727 }
6728 }
6729 #[inline]
6730 pub fn ref_idx_l0_0(&self) -> u32 {
6731 unsafe { ::std::mem::transmute(self._bitfield_1.get(32usize, 8u8) as u32) }
6732 }
6733 #[inline]
6734 pub fn set_ref_idx_l0_0(&mut self, val: u32) {
6735 unsafe {
6736 let val: u32 = ::std::mem::transmute(val);
6737 self._bitfield_1.set(32usize, 8u8, val as u64)
6738 }
6739 }
6740 #[inline]
6741 pub fn ref_idx_l0_1(&self) -> u32 {
6742 unsafe { ::std::mem::transmute(self._bitfield_1.get(40usize, 8u8) as u32) }
6743 }
6744 #[inline]
6745 pub fn set_ref_idx_l0_1(&mut self, val: u32) {
6746 unsafe {
6747 let val: u32 = ::std::mem::transmute(val);
6748 self._bitfield_1.set(40usize, 8u8, val as u64)
6749 }
6750 }
6751 #[inline]
6752 pub fn ref_idx_l0_2(&self) -> u32 {
6753 unsafe { ::std::mem::transmute(self._bitfield_1.get(48usize, 8u8) as u32) }
6754 }
6755 #[inline]
6756 pub fn set_ref_idx_l0_2(&mut self, val: u32) {
6757 unsafe {
6758 let val: u32 = ::std::mem::transmute(val);
6759 self._bitfield_1.set(48usize, 8u8, val as u64)
6760 }
6761 }
6762 #[inline]
6763 pub fn ref_idx_l0_3(&self) -> u32 {
6764 unsafe { ::std::mem::transmute(self._bitfield_1.get(56usize, 8u8) as u32) }
6765 }
6766 #[inline]
6767 pub fn set_ref_idx_l0_3(&mut self, val: u32) {
6768 unsafe {
6769 let val: u32 = ::std::mem::transmute(val);
6770 self._bitfield_1.set(56usize, 8u8, val as u64)
6771 }
6772 }
6773 #[inline]
6774 pub fn ref_idx_l1_0(&self) -> u32 {
6775 unsafe { ::std::mem::transmute(self._bitfield_1.get(64usize, 8u8) as u32) }
6776 }
6777 #[inline]
6778 pub fn set_ref_idx_l1_0(&mut self, val: u32) {
6779 unsafe {
6780 let val: u32 = ::std::mem::transmute(val);
6781 self._bitfield_1.set(64usize, 8u8, val as u64)
6782 }
6783 }
6784 #[inline]
6785 pub fn ref_idx_l1_1(&self) -> u32 {
6786 unsafe { ::std::mem::transmute(self._bitfield_1.get(72usize, 8u8) as u32) }
6787 }
6788 #[inline]
6789 pub fn set_ref_idx_l1_1(&mut self, val: u32) {
6790 unsafe {
6791 let val: u32 = ::std::mem::transmute(val);
6792 self._bitfield_1.set(72usize, 8u8, val as u64)
6793 }
6794 }
6795 #[inline]
6796 pub fn ref_idx_l1_2(&self) -> u32 {
6797 unsafe { ::std::mem::transmute(self._bitfield_1.get(80usize, 8u8) as u32) }
6798 }
6799 #[inline]
6800 pub fn set_ref_idx_l1_2(&mut self, val: u32) {
6801 unsafe {
6802 let val: u32 = ::std::mem::transmute(val);
6803 self._bitfield_1.set(80usize, 8u8, val as u64)
6804 }
6805 }
6806 #[inline]
6807 pub fn ref_idx_l1_3(&self) -> u32 {
6808 unsafe { ::std::mem::transmute(self._bitfield_1.get(88usize, 8u8) as u32) }
6809 }
6810 #[inline]
6811 pub fn set_ref_idx_l1_3(&mut self, val: u32) {
6812 unsafe {
6813 let val: u32 = ::std::mem::transmute(val);
6814 self._bitfield_1.set(88usize, 8u8, val as u64)
6815 }
6816 }
6817 #[inline]
6818 pub fn new_bitfield_1(
6819 sub_mb_shapes: u32,
6820 sub_mb_pred_modes: u32,
6821 reserved7: u32,
6822 ref_idx_l0_0: u32,
6823 ref_idx_l0_1: u32,
6824 ref_idx_l0_2: u32,
6825 ref_idx_l0_3: u32,
6826 ref_idx_l1_0: u32,
6827 ref_idx_l1_1: u32,
6828 ref_idx_l1_2: u32,
6829 ref_idx_l1_3: u32,
6830 ) -> __BindgenBitfieldUnit<[u8; 12usize]> {
6831 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 12usize]> = Default::default();
6832 __bindgen_bitfield_unit.set(0usize, 8u8, {
6833 let sub_mb_shapes: u32 = unsafe { ::std::mem::transmute(sub_mb_shapes) };
6834 sub_mb_shapes as u64
6835 });
6836 __bindgen_bitfield_unit.set(8usize, 8u8, {
6837 let sub_mb_pred_modes: u32 = unsafe { ::std::mem::transmute(sub_mb_pred_modes) };
6838 sub_mb_pred_modes as u64
6839 });
6840 __bindgen_bitfield_unit.set(16usize, 16u8, {
6841 let reserved7: u32 = unsafe { ::std::mem::transmute(reserved7) };
6842 reserved7 as u64
6843 });
6844 __bindgen_bitfield_unit.set(32usize, 8u8, {
6845 let ref_idx_l0_0: u32 = unsafe { ::std::mem::transmute(ref_idx_l0_0) };
6846 ref_idx_l0_0 as u64
6847 });
6848 __bindgen_bitfield_unit.set(40usize, 8u8, {
6849 let ref_idx_l0_1: u32 = unsafe { ::std::mem::transmute(ref_idx_l0_1) };
6850 ref_idx_l0_1 as u64
6851 });
6852 __bindgen_bitfield_unit.set(48usize, 8u8, {
6853 let ref_idx_l0_2: u32 = unsafe { ::std::mem::transmute(ref_idx_l0_2) };
6854 ref_idx_l0_2 as u64
6855 });
6856 __bindgen_bitfield_unit.set(56usize, 8u8, {
6857 let ref_idx_l0_3: u32 = unsafe { ::std::mem::transmute(ref_idx_l0_3) };
6858 ref_idx_l0_3 as u64
6859 });
6860 __bindgen_bitfield_unit.set(64usize, 8u8, {
6861 let ref_idx_l1_0: u32 = unsafe { ::std::mem::transmute(ref_idx_l1_0) };
6862 ref_idx_l1_0 as u64
6863 });
6864 __bindgen_bitfield_unit.set(72usize, 8u8, {
6865 let ref_idx_l1_1: u32 = unsafe { ::std::mem::transmute(ref_idx_l1_1) };
6866 ref_idx_l1_1 as u64
6867 });
6868 __bindgen_bitfield_unit.set(80usize, 8u8, {
6869 let ref_idx_l1_2: u32 = unsafe { ::std::mem::transmute(ref_idx_l1_2) };
6870 ref_idx_l1_2 as u64
6871 });
6872 __bindgen_bitfield_unit.set(88usize, 8u8, {
6873 let ref_idx_l1_3: u32 = unsafe { ::std::mem::transmute(ref_idx_l1_3) };
6874 ref_idx_l1_3 as u64
6875 });
6876 __bindgen_bitfield_unit
6877 }
6878}
6879impl Default for _VAEncFEIMBCodeH264__bindgen_ty_1 {
6880 fn default() -> Self {
6881 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6882 unsafe {
6883 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6884 s.assume_init()
6885 }
6886 }
6887}
6888impl Default for _VAEncFEIMBCodeH264 {
6889 fn default() -> Self {
6890 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6891 unsafe {
6892 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6893 s.assume_init()
6894 }
6895 }
6896}
6897impl _VAEncFEIMBCodeH264 {
6898 #[inline]
6899 pub fn inter_mb_mode(&self) -> u32 {
6900 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u32) }
6901 }
6902 #[inline]
6903 pub fn set_inter_mb_mode(&mut self, val: u32) {
6904 unsafe {
6905 let val: u32 = ::std::mem::transmute(val);
6906 self._bitfield_1.set(0usize, 2u8, val as u64)
6907 }
6908 }
6909 #[inline]
6910 pub fn mb_skip_flag(&self) -> u32 {
6911 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
6912 }
6913 #[inline]
6914 pub fn set_mb_skip_flag(&mut self, val: u32) {
6915 unsafe {
6916 let val: u32 = ::std::mem::transmute(val);
6917 self._bitfield_1.set(2usize, 1u8, val as u64)
6918 }
6919 }
6920 #[inline]
6921 pub fn reserved1(&self) -> u32 {
6922 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
6923 }
6924 #[inline]
6925 pub fn set_reserved1(&mut self, val: u32) {
6926 unsafe {
6927 let val: u32 = ::std::mem::transmute(val);
6928 self._bitfield_1.set(3usize, 1u8, val as u64)
6929 }
6930 }
6931 #[inline]
6932 pub fn intra_mb_mode(&self) -> u32 {
6933 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 2u8) as u32) }
6934 }
6935 #[inline]
6936 pub fn set_intra_mb_mode(&mut self, val: u32) {
6937 unsafe {
6938 let val: u32 = ::std::mem::transmute(val);
6939 self._bitfield_1.set(4usize, 2u8, val as u64)
6940 }
6941 }
6942 #[inline]
6943 pub fn reserved2(&self) -> u32 {
6944 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) }
6945 }
6946 #[inline]
6947 pub fn set_reserved2(&mut self, val: u32) {
6948 unsafe {
6949 let val: u32 = ::std::mem::transmute(val);
6950 self._bitfield_1.set(6usize, 1u8, val as u64)
6951 }
6952 }
6953 #[inline]
6954 pub fn field_mb_polarity_flag(&self) -> u32 {
6955 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) }
6956 }
6957 #[inline]
6958 pub fn set_field_mb_polarity_flag(&mut self, val: u32) {
6959 unsafe {
6960 let val: u32 = ::std::mem::transmute(val);
6961 self._bitfield_1.set(7usize, 1u8, val as u64)
6962 }
6963 }
6964 #[inline]
6965 pub fn mb_type(&self) -> u32 {
6966 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 5u8) as u32) }
6967 }
6968 #[inline]
6969 pub fn set_mb_type(&mut self, val: u32) {
6970 unsafe {
6971 let val: u32 = ::std::mem::transmute(val);
6972 self._bitfield_1.set(8usize, 5u8, val as u64)
6973 }
6974 }
6975 #[inline]
6976 pub fn intra_mb_flag(&self) -> u32 {
6977 unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) }
6978 }
6979 #[inline]
6980 pub fn set_intra_mb_flag(&mut self, val: u32) {
6981 unsafe {
6982 let val: u32 = ::std::mem::transmute(val);
6983 self._bitfield_1.set(13usize, 1u8, val as u64)
6984 }
6985 }
6986 #[inline]
6987 pub fn field_mb_flag(&self) -> u32 {
6988 unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) }
6989 }
6990 #[inline]
6991 pub fn set_field_mb_flag(&mut self, val: u32) {
6992 unsafe {
6993 let val: u32 = ::std::mem::transmute(val);
6994 self._bitfield_1.set(14usize, 1u8, val as u64)
6995 }
6996 }
6997 #[inline]
6998 pub fn transform8x8_flag(&self) -> u32 {
6999 unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u32) }
7000 }
7001 #[inline]
7002 pub fn set_transform8x8_flag(&mut self, val: u32) {
7003 unsafe {
7004 let val: u32 = ::std::mem::transmute(val);
7005 self._bitfield_1.set(15usize, 1u8, val as u64)
7006 }
7007 }
7008 #[inline]
7009 pub fn reserved3(&self) -> u32 {
7010 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u32) }
7011 }
7012 #[inline]
7013 pub fn set_reserved3(&mut self, val: u32) {
7014 unsafe {
7015 let val: u32 = ::std::mem::transmute(val);
7016 self._bitfield_1.set(16usize, 1u8, val as u64)
7017 }
7018 }
7019 #[inline]
7020 pub fn dc_block_coded_cr_flag(&self) -> u32 {
7021 unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 1u8) as u32) }
7022 }
7023 #[inline]
7024 pub fn set_dc_block_coded_cr_flag(&mut self, val: u32) {
7025 unsafe {
7026 let val: u32 = ::std::mem::transmute(val);
7027 self._bitfield_1.set(17usize, 1u8, val as u64)
7028 }
7029 }
7030 #[inline]
7031 pub fn dc_block_coded_cb_flag(&self) -> u32 {
7032 unsafe { ::std::mem::transmute(self._bitfield_1.get(18usize, 1u8) as u32) }
7033 }
7034 #[inline]
7035 pub fn set_dc_block_coded_cb_flag(&mut self, val: u32) {
7036 unsafe {
7037 let val: u32 = ::std::mem::transmute(val);
7038 self._bitfield_1.set(18usize, 1u8, val as u64)
7039 }
7040 }
7041 #[inline]
7042 pub fn dc_block_coded_y_flag(&self) -> u32 {
7043 unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 1u8) as u32) }
7044 }
7045 #[inline]
7046 pub fn set_dc_block_coded_y_flag(&mut self, val: u32) {
7047 unsafe {
7048 let val: u32 = ::std::mem::transmute(val);
7049 self._bitfield_1.set(19usize, 1u8, val as u64)
7050 }
7051 }
7052 #[inline]
7053 pub fn reserved4(&self) -> u32 {
7054 unsafe { ::std::mem::transmute(self._bitfield_1.get(20usize, 12u8) as u32) }
7055 }
7056 #[inline]
7057 pub fn set_reserved4(&mut self, val: u32) {
7058 unsafe {
7059 let val: u32 = ::std::mem::transmute(val);
7060 self._bitfield_1.set(20usize, 12u8, val as u64)
7061 }
7062 }
7063 #[inline]
7064 pub fn horz_origin(&self) -> u32 {
7065 unsafe { ::std::mem::transmute(self._bitfield_1.get(32usize, 8u8) as u32) }
7066 }
7067 #[inline]
7068 pub fn set_horz_origin(&mut self, val: u32) {
7069 unsafe {
7070 let val: u32 = ::std::mem::transmute(val);
7071 self._bitfield_1.set(32usize, 8u8, val as u64)
7072 }
7073 }
7074 #[inline]
7075 pub fn vert_origin(&self) -> u32 {
7076 unsafe { ::std::mem::transmute(self._bitfield_1.get(40usize, 8u8) as u32) }
7077 }
7078 #[inline]
7079 pub fn set_vert_origin(&mut self, val: u32) {
7080 unsafe {
7081 let val: u32 = ::std::mem::transmute(val);
7082 self._bitfield_1.set(40usize, 8u8, val as u64)
7083 }
7084 }
7085 #[inline]
7086 pub fn cbp_y(&self) -> u32 {
7087 unsafe { ::std::mem::transmute(self._bitfield_1.get(48usize, 16u8) as u32) }
7088 }
7089 #[inline]
7090 pub fn set_cbp_y(&mut self, val: u32) {
7091 unsafe {
7092 let val: u32 = ::std::mem::transmute(val);
7093 self._bitfield_1.set(48usize, 16u8, val as u64)
7094 }
7095 }
7096 #[inline]
7097 pub fn cbp_cb(&self) -> u32 {
7098 unsafe { ::std::mem::transmute(self._bitfield_1.get(64usize, 16u8) as u32) }
7099 }
7100 #[inline]
7101 pub fn set_cbp_cb(&mut self, val: u32) {
7102 unsafe {
7103 let val: u32 = ::std::mem::transmute(val);
7104 self._bitfield_1.set(64usize, 16u8, val as u64)
7105 }
7106 }
7107 #[inline]
7108 pub fn cbp_cr(&self) -> u32 {
7109 unsafe { ::std::mem::transmute(self._bitfield_1.get(80usize, 16u8) as u32) }
7110 }
7111 #[inline]
7112 pub fn set_cbp_cr(&mut self, val: u32) {
7113 unsafe {
7114 let val: u32 = ::std::mem::transmute(val);
7115 self._bitfield_1.set(80usize, 16u8, val as u64)
7116 }
7117 }
7118 #[inline]
7119 pub fn qp_prime_y(&self) -> u32 {
7120 unsafe { ::std::mem::transmute(self._bitfield_1.get(96usize, 8u8) as u32) }
7121 }
7122 #[inline]
7123 pub fn set_qp_prime_y(&mut self, val: u32) {
7124 unsafe {
7125 let val: u32 = ::std::mem::transmute(val);
7126 self._bitfield_1.set(96usize, 8u8, val as u64)
7127 }
7128 }
7129 #[inline]
7130 pub fn reserved5(&self) -> u32 {
7131 unsafe { ::std::mem::transmute(self._bitfield_1.get(104usize, 17u8) as u32) }
7132 }
7133 #[inline]
7134 pub fn set_reserved5(&mut self, val: u32) {
7135 unsafe {
7136 let val: u32 = ::std::mem::transmute(val);
7137 self._bitfield_1.set(104usize, 17u8, val as u64)
7138 }
7139 }
7140 #[inline]
7141 pub fn mb_skip_conv_disable(&self) -> u32 {
7142 unsafe { ::std::mem::transmute(self._bitfield_1.get(121usize, 1u8) as u32) }
7143 }
7144 #[inline]
7145 pub fn set_mb_skip_conv_disable(&mut self, val: u32) {
7146 unsafe {
7147 let val: u32 = ::std::mem::transmute(val);
7148 self._bitfield_1.set(121usize, 1u8, val as u64)
7149 }
7150 }
7151 #[inline]
7152 pub fn is_last_mb(&self) -> u32 {
7153 unsafe { ::std::mem::transmute(self._bitfield_1.get(122usize, 1u8) as u32) }
7154 }
7155 #[inline]
7156 pub fn set_is_last_mb(&mut self, val: u32) {
7157 unsafe {
7158 let val: u32 = ::std::mem::transmute(val);
7159 self._bitfield_1.set(122usize, 1u8, val as u64)
7160 }
7161 }
7162 #[inline]
7163 pub fn enable_coefficient_clamp(&self) -> u32 {
7164 unsafe { ::std::mem::transmute(self._bitfield_1.get(123usize, 1u8) as u32) }
7165 }
7166 #[inline]
7167 pub fn set_enable_coefficient_clamp(&mut self, val: u32) {
7168 unsafe {
7169 let val: u32 = ::std::mem::transmute(val);
7170 self._bitfield_1.set(123usize, 1u8, val as u64)
7171 }
7172 }
7173 #[inline]
7174 pub fn direct8x8_pattern(&self) -> u32 {
7175 unsafe { ::std::mem::transmute(self._bitfield_1.get(124usize, 4u8) as u32) }
7176 }
7177 #[inline]
7178 pub fn set_direct8x8_pattern(&mut self, val: u32) {
7179 unsafe {
7180 let val: u32 = ::std::mem::transmute(val);
7181 self._bitfield_1.set(124usize, 4u8, val as u64)
7182 }
7183 }
7184 #[inline]
7185 pub fn new_bitfield_1(
7186 inter_mb_mode: u32,
7187 mb_skip_flag: u32,
7188 reserved1: u32,
7189 intra_mb_mode: u32,
7190 reserved2: u32,
7191 field_mb_polarity_flag: u32,
7192 mb_type: u32,
7193 intra_mb_flag: u32,
7194 field_mb_flag: u32,
7195 transform8x8_flag: u32,
7196 reserved3: u32,
7197 dc_block_coded_cr_flag: u32,
7198 dc_block_coded_cb_flag: u32,
7199 dc_block_coded_y_flag: u32,
7200 reserved4: u32,
7201 horz_origin: u32,
7202 vert_origin: u32,
7203 cbp_y: u32,
7204 cbp_cb: u32,
7205 cbp_cr: u32,
7206 qp_prime_y: u32,
7207 reserved5: u32,
7208 mb_skip_conv_disable: u32,
7209 is_last_mb: u32,
7210 enable_coefficient_clamp: u32,
7211 direct8x8_pattern: u32,
7212 ) -> __BindgenBitfieldUnit<[u8; 16usize]> {
7213 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 16usize]> = Default::default();
7214 __bindgen_bitfield_unit.set(0usize, 2u8, {
7215 let inter_mb_mode: u32 = unsafe { ::std::mem::transmute(inter_mb_mode) };
7216 inter_mb_mode as u64
7217 });
7218 __bindgen_bitfield_unit.set(2usize, 1u8, {
7219 let mb_skip_flag: u32 = unsafe { ::std::mem::transmute(mb_skip_flag) };
7220 mb_skip_flag as u64
7221 });
7222 __bindgen_bitfield_unit.set(3usize, 1u8, {
7223 let reserved1: u32 = unsafe { ::std::mem::transmute(reserved1) };
7224 reserved1 as u64
7225 });
7226 __bindgen_bitfield_unit.set(4usize, 2u8, {
7227 let intra_mb_mode: u32 = unsafe { ::std::mem::transmute(intra_mb_mode) };
7228 intra_mb_mode as u64
7229 });
7230 __bindgen_bitfield_unit.set(6usize, 1u8, {
7231 let reserved2: u32 = unsafe { ::std::mem::transmute(reserved2) };
7232 reserved2 as u64
7233 });
7234 __bindgen_bitfield_unit.set(7usize, 1u8, {
7235 let field_mb_polarity_flag: u32 =
7236 unsafe { ::std::mem::transmute(field_mb_polarity_flag) };
7237 field_mb_polarity_flag as u64
7238 });
7239 __bindgen_bitfield_unit.set(8usize, 5u8, {
7240 let mb_type: u32 = unsafe { ::std::mem::transmute(mb_type) };
7241 mb_type as u64
7242 });
7243 __bindgen_bitfield_unit.set(13usize, 1u8, {
7244 let intra_mb_flag: u32 = unsafe { ::std::mem::transmute(intra_mb_flag) };
7245 intra_mb_flag as u64
7246 });
7247 __bindgen_bitfield_unit.set(14usize, 1u8, {
7248 let field_mb_flag: u32 = unsafe { ::std::mem::transmute(field_mb_flag) };
7249 field_mb_flag as u64
7250 });
7251 __bindgen_bitfield_unit.set(15usize, 1u8, {
7252 let transform8x8_flag: u32 = unsafe { ::std::mem::transmute(transform8x8_flag) };
7253 transform8x8_flag as u64
7254 });
7255 __bindgen_bitfield_unit.set(16usize, 1u8, {
7256 let reserved3: u32 = unsafe { ::std::mem::transmute(reserved3) };
7257 reserved3 as u64
7258 });
7259 __bindgen_bitfield_unit.set(17usize, 1u8, {
7260 let dc_block_coded_cr_flag: u32 =
7261 unsafe { ::std::mem::transmute(dc_block_coded_cr_flag) };
7262 dc_block_coded_cr_flag as u64
7263 });
7264 __bindgen_bitfield_unit.set(18usize, 1u8, {
7265 let dc_block_coded_cb_flag: u32 =
7266 unsafe { ::std::mem::transmute(dc_block_coded_cb_flag) };
7267 dc_block_coded_cb_flag as u64
7268 });
7269 __bindgen_bitfield_unit.set(19usize, 1u8, {
7270 let dc_block_coded_y_flag: u32 =
7271 unsafe { ::std::mem::transmute(dc_block_coded_y_flag) };
7272 dc_block_coded_y_flag as u64
7273 });
7274 __bindgen_bitfield_unit.set(20usize, 12u8, {
7275 let reserved4: u32 = unsafe { ::std::mem::transmute(reserved4) };
7276 reserved4 as u64
7277 });
7278 __bindgen_bitfield_unit.set(32usize, 8u8, {
7279 let horz_origin: u32 = unsafe { ::std::mem::transmute(horz_origin) };
7280 horz_origin as u64
7281 });
7282 __bindgen_bitfield_unit.set(40usize, 8u8, {
7283 let vert_origin: u32 = unsafe { ::std::mem::transmute(vert_origin) };
7284 vert_origin as u64
7285 });
7286 __bindgen_bitfield_unit.set(48usize, 16u8, {
7287 let cbp_y: u32 = unsafe { ::std::mem::transmute(cbp_y) };
7288 cbp_y as u64
7289 });
7290 __bindgen_bitfield_unit.set(64usize, 16u8, {
7291 let cbp_cb: u32 = unsafe { ::std::mem::transmute(cbp_cb) };
7292 cbp_cb as u64
7293 });
7294 __bindgen_bitfield_unit.set(80usize, 16u8, {
7295 let cbp_cr: u32 = unsafe { ::std::mem::transmute(cbp_cr) };
7296 cbp_cr as u64
7297 });
7298 __bindgen_bitfield_unit.set(96usize, 8u8, {
7299 let qp_prime_y: u32 = unsafe { ::std::mem::transmute(qp_prime_y) };
7300 qp_prime_y as u64
7301 });
7302 __bindgen_bitfield_unit.set(104usize, 17u8, {
7303 let reserved5: u32 = unsafe { ::std::mem::transmute(reserved5) };
7304 reserved5 as u64
7305 });
7306 __bindgen_bitfield_unit.set(121usize, 1u8, {
7307 let mb_skip_conv_disable: u32 = unsafe { ::std::mem::transmute(mb_skip_conv_disable) };
7308 mb_skip_conv_disable as u64
7309 });
7310 __bindgen_bitfield_unit.set(122usize, 1u8, {
7311 let is_last_mb: u32 = unsafe { ::std::mem::transmute(is_last_mb) };
7312 is_last_mb as u64
7313 });
7314 __bindgen_bitfield_unit.set(123usize, 1u8, {
7315 let enable_coefficient_clamp: u32 =
7316 unsafe { ::std::mem::transmute(enable_coefficient_clamp) };
7317 enable_coefficient_clamp as u64
7318 });
7319 __bindgen_bitfield_unit.set(124usize, 4u8, {
7320 let direct8x8_pattern: u32 = unsafe { ::std::mem::transmute(direct8x8_pattern) };
7321 direct8x8_pattern as u64
7322 });
7323 __bindgen_bitfield_unit
7324 }
7325 #[inline]
7326 pub fn reserved8(&self) -> u32 {
7327 unsafe { ::std::mem::transmute(self._bitfield_2.get(0usize, 16u8) as u32) }
7328 }
7329 #[inline]
7330 pub fn set_reserved8(&mut self, val: u32) {
7331 unsafe {
7332 let val: u32 = ::std::mem::transmute(val);
7333 self._bitfield_2.set(0usize, 16u8, val as u64)
7334 }
7335 }
7336 #[inline]
7337 pub fn target_size_in_word(&self) -> u32 {
7338 unsafe { ::std::mem::transmute(self._bitfield_2.get(16usize, 8u8) as u32) }
7339 }
7340 #[inline]
7341 pub fn set_target_size_in_word(&mut self, val: u32) {
7342 unsafe {
7343 let val: u32 = ::std::mem::transmute(val);
7344 self._bitfield_2.set(16usize, 8u8, val as u64)
7345 }
7346 }
7347 #[inline]
7348 pub fn max_size_in_word(&self) -> u32 {
7349 unsafe { ::std::mem::transmute(self._bitfield_2.get(24usize, 8u8) as u32) }
7350 }
7351 #[inline]
7352 pub fn set_max_size_in_word(&mut self, val: u32) {
7353 unsafe {
7354 let val: u32 = ::std::mem::transmute(val);
7355 self._bitfield_2.set(24usize, 8u8, val as u64)
7356 }
7357 }
7358 #[inline]
7359 pub fn new_bitfield_2(
7360 reserved8: u32,
7361 target_size_in_word: u32,
7362 max_size_in_word: u32,
7363 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
7364 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
7365 __bindgen_bitfield_unit.set(0usize, 16u8, {
7366 let reserved8: u32 = unsafe { ::std::mem::transmute(reserved8) };
7367 reserved8 as u64
7368 });
7369 __bindgen_bitfield_unit.set(16usize, 8u8, {
7370 let target_size_in_word: u32 = unsafe { ::std::mem::transmute(target_size_in_word) };
7371 target_size_in_word as u64
7372 });
7373 __bindgen_bitfield_unit.set(24usize, 8u8, {
7374 let max_size_in_word: u32 = unsafe { ::std::mem::transmute(max_size_in_word) };
7375 max_size_in_word as u64
7376 });
7377 __bindgen_bitfield_unit
7378 }
7379}
7380pub type VAEncFEIMBCodeH264 = _VAEncFEIMBCodeH264;
7381#[repr(C)]
7382#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
7383pub struct _VAEncFEIDistortionH264 {
7384 pub inter_distortion: [u16; 16usize],
7385 pub _bitfield_align_1: [u16; 0],
7386 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
7387 pub reserved1: [u32; 2usize],
7388}
7389impl _VAEncFEIDistortionH264 {
7390 #[inline]
7391 pub fn best_inter_distortion(&self) -> u32 {
7392 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 16u8) as u32) }
7393 }
7394 #[inline]
7395 pub fn set_best_inter_distortion(&mut self, val: u32) {
7396 unsafe {
7397 let val: u32 = ::std::mem::transmute(val);
7398 self._bitfield_1.set(0usize, 16u8, val as u64)
7399 }
7400 }
7401 #[inline]
7402 pub fn best_intra_distortion(&self) -> u32 {
7403 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 16u8) as u32) }
7404 }
7405 #[inline]
7406 pub fn set_best_intra_distortion(&mut self, val: u32) {
7407 unsafe {
7408 let val: u32 = ::std::mem::transmute(val);
7409 self._bitfield_1.set(16usize, 16u8, val as u64)
7410 }
7411 }
7412 #[inline]
7413 pub fn colocated_mb_distortion(&self) -> u32 {
7414 unsafe { ::std::mem::transmute(self._bitfield_1.get(32usize, 16u8) as u32) }
7415 }
7416 #[inline]
7417 pub fn set_colocated_mb_distortion(&mut self, val: u32) {
7418 unsafe {
7419 let val: u32 = ::std::mem::transmute(val);
7420 self._bitfield_1.set(32usize, 16u8, val as u64)
7421 }
7422 }
7423 #[inline]
7424 pub fn reserved0(&self) -> u32 {
7425 unsafe { ::std::mem::transmute(self._bitfield_1.get(48usize, 16u8) as u32) }
7426 }
7427 #[inline]
7428 pub fn set_reserved0(&mut self, val: u32) {
7429 unsafe {
7430 let val: u32 = ::std::mem::transmute(val);
7431 self._bitfield_1.set(48usize, 16u8, val as u64)
7432 }
7433 }
7434 #[inline]
7435 pub fn new_bitfield_1(
7436 best_inter_distortion: u32,
7437 best_intra_distortion: u32,
7438 colocated_mb_distortion: u32,
7439 reserved0: u32,
7440 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
7441 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
7442 __bindgen_bitfield_unit.set(0usize, 16u8, {
7443 let best_inter_distortion: u32 =
7444 unsafe { ::std::mem::transmute(best_inter_distortion) };
7445 best_inter_distortion as u64
7446 });
7447 __bindgen_bitfield_unit.set(16usize, 16u8, {
7448 let best_intra_distortion: u32 =
7449 unsafe { ::std::mem::transmute(best_intra_distortion) };
7450 best_intra_distortion as u64
7451 });
7452 __bindgen_bitfield_unit.set(32usize, 16u8, {
7453 let colocated_mb_distortion: u32 =
7454 unsafe { ::std::mem::transmute(colocated_mb_distortion) };
7455 colocated_mb_distortion as u64
7456 });
7457 __bindgen_bitfield_unit.set(48usize, 16u8, {
7458 let reserved0: u32 = unsafe { ::std::mem::transmute(reserved0) };
7459 reserved0 as u64
7460 });
7461 __bindgen_bitfield_unit
7462 }
7463}
7464pub type VAEncFEIDistortionH264 = _VAEncFEIDistortionH264;
7465#[repr(C)]
7466#[derive(Debug, Copy, Clone, PartialEq, Eq)]
7467pub struct _VAStatsStatisticsParameterH264 {
7468 pub stats_params: VAStatsStatisticsParameter,
7469 pub _bitfield_align_1: [u32; 0],
7470 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 16usize]>,
7471 pub reserved4: [u32; 2usize],
7472}
7473impl Default for _VAStatsStatisticsParameterH264 {
7474 fn default() -> Self {
7475 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7476 unsafe {
7477 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7478 s.assume_init()
7479 }
7480 }
7481}
7482impl _VAStatsStatisticsParameterH264 {
7483 #[inline]
7484 pub fn frame_qp(&self) -> u32 {
7485 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 8u8) as u32) }
7486 }
7487 #[inline]
7488 pub fn set_frame_qp(&mut self, val: u32) {
7489 unsafe {
7490 let val: u32 = ::std::mem::transmute(val);
7491 self._bitfield_1.set(0usize, 8u8, val as u64)
7492 }
7493 }
7494 #[inline]
7495 pub fn len_sp(&self) -> u32 {
7496 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 8u8) as u32) }
7497 }
7498 #[inline]
7499 pub fn set_len_sp(&mut self, val: u32) {
7500 unsafe {
7501 let val: u32 = ::std::mem::transmute(val);
7502 self._bitfield_1.set(8usize, 8u8, val as u64)
7503 }
7504 }
7505 #[inline]
7506 pub fn search_path(&self) -> u32 {
7507 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 8u8) as u32) }
7508 }
7509 #[inline]
7510 pub fn set_search_path(&mut self, val: u32) {
7511 unsafe {
7512 let val: u32 = ::std::mem::transmute(val);
7513 self._bitfield_1.set(16usize, 8u8, val as u64)
7514 }
7515 }
7516 #[inline]
7517 pub fn reserved0(&self) -> u32 {
7518 unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 8u8) as u32) }
7519 }
7520 #[inline]
7521 pub fn set_reserved0(&mut self, val: u32) {
7522 unsafe {
7523 let val: u32 = ::std::mem::transmute(val);
7524 self._bitfield_1.set(24usize, 8u8, val as u64)
7525 }
7526 }
7527 #[inline]
7528 pub fn sub_mb_part_mask(&self) -> u32 {
7529 unsafe { ::std::mem::transmute(self._bitfield_1.get(32usize, 7u8) as u32) }
7530 }
7531 #[inline]
7532 pub fn set_sub_mb_part_mask(&mut self, val: u32) {
7533 unsafe {
7534 let val: u32 = ::std::mem::transmute(val);
7535 self._bitfield_1.set(32usize, 7u8, val as u64)
7536 }
7537 }
7538 #[inline]
7539 pub fn sub_pel_mode(&self) -> u32 {
7540 unsafe { ::std::mem::transmute(self._bitfield_1.get(39usize, 2u8) as u32) }
7541 }
7542 #[inline]
7543 pub fn set_sub_pel_mode(&mut self, val: u32) {
7544 unsafe {
7545 let val: u32 = ::std::mem::transmute(val);
7546 self._bitfield_1.set(39usize, 2u8, val as u64)
7547 }
7548 }
7549 #[inline]
7550 pub fn inter_sad(&self) -> u32 {
7551 unsafe { ::std::mem::transmute(self._bitfield_1.get(41usize, 2u8) as u32) }
7552 }
7553 #[inline]
7554 pub fn set_inter_sad(&mut self, val: u32) {
7555 unsafe {
7556 let val: u32 = ::std::mem::transmute(val);
7557 self._bitfield_1.set(41usize, 2u8, val as u64)
7558 }
7559 }
7560 #[inline]
7561 pub fn intra_sad(&self) -> u32 {
7562 unsafe { ::std::mem::transmute(self._bitfield_1.get(43usize, 2u8) as u32) }
7563 }
7564 #[inline]
7565 pub fn set_intra_sad(&mut self, val: u32) {
7566 unsafe {
7567 let val: u32 = ::std::mem::transmute(val);
7568 self._bitfield_1.set(43usize, 2u8, val as u64)
7569 }
7570 }
7571 #[inline]
7572 pub fn adaptive_search(&self) -> u32 {
7573 unsafe { ::std::mem::transmute(self._bitfield_1.get(45usize, 1u8) as u32) }
7574 }
7575 #[inline]
7576 pub fn set_adaptive_search(&mut self, val: u32) {
7577 unsafe {
7578 let val: u32 = ::std::mem::transmute(val);
7579 self._bitfield_1.set(45usize, 1u8, val as u64)
7580 }
7581 }
7582 #[inline]
7583 pub fn mv_predictor_ctrl(&self) -> u32 {
7584 unsafe { ::std::mem::transmute(self._bitfield_1.get(46usize, 3u8) as u32) }
7585 }
7586 #[inline]
7587 pub fn set_mv_predictor_ctrl(&mut self, val: u32) {
7588 unsafe {
7589 let val: u32 = ::std::mem::transmute(val);
7590 self._bitfield_1.set(46usize, 3u8, val as u64)
7591 }
7592 }
7593 #[inline]
7594 pub fn mb_qp(&self) -> u32 {
7595 unsafe { ::std::mem::transmute(self._bitfield_1.get(49usize, 1u8) as u32) }
7596 }
7597 #[inline]
7598 pub fn set_mb_qp(&mut self, val: u32) {
7599 unsafe {
7600 let val: u32 = ::std::mem::transmute(val);
7601 self._bitfield_1.set(49usize, 1u8, val as u64)
7602 }
7603 }
7604 #[inline]
7605 pub fn ft_enable(&self) -> u32 {
7606 unsafe { ::std::mem::transmute(self._bitfield_1.get(50usize, 1u8) as u32) }
7607 }
7608 #[inline]
7609 pub fn set_ft_enable(&mut self, val: u32) {
7610 unsafe {
7611 let val: u32 = ::std::mem::transmute(val);
7612 self._bitfield_1.set(50usize, 1u8, val as u64)
7613 }
7614 }
7615 #[inline]
7616 pub fn intra_part_mask(&self) -> u32 {
7617 unsafe { ::std::mem::transmute(self._bitfield_1.get(51usize, 5u8) as u32) }
7618 }
7619 #[inline]
7620 pub fn set_intra_part_mask(&mut self, val: u32) {
7621 unsafe {
7622 let val: u32 = ::std::mem::transmute(val);
7623 self._bitfield_1.set(51usize, 5u8, val as u64)
7624 }
7625 }
7626 #[inline]
7627 pub fn reserved1(&self) -> u32 {
7628 unsafe { ::std::mem::transmute(self._bitfield_1.get(56usize, 8u8) as u32) }
7629 }
7630 #[inline]
7631 pub fn set_reserved1(&mut self, val: u32) {
7632 unsafe {
7633 let val: u32 = ::std::mem::transmute(val);
7634 self._bitfield_1.set(56usize, 8u8, val as u64)
7635 }
7636 }
7637 #[inline]
7638 pub fn ref_width(&self) -> u32 {
7639 unsafe { ::std::mem::transmute(self._bitfield_1.get(64usize, 8u8) as u32) }
7640 }
7641 #[inline]
7642 pub fn set_ref_width(&mut self, val: u32) {
7643 unsafe {
7644 let val: u32 = ::std::mem::transmute(val);
7645 self._bitfield_1.set(64usize, 8u8, val as u64)
7646 }
7647 }
7648 #[inline]
7649 pub fn ref_height(&self) -> u32 {
7650 unsafe { ::std::mem::transmute(self._bitfield_1.get(72usize, 8u8) as u32) }
7651 }
7652 #[inline]
7653 pub fn set_ref_height(&mut self, val: u32) {
7654 unsafe {
7655 let val: u32 = ::std::mem::transmute(val);
7656 self._bitfield_1.set(72usize, 8u8, val as u64)
7657 }
7658 }
7659 #[inline]
7660 pub fn search_window(&self) -> u32 {
7661 unsafe { ::std::mem::transmute(self._bitfield_1.get(80usize, 4u8) as u32) }
7662 }
7663 #[inline]
7664 pub fn set_search_window(&mut self, val: u32) {
7665 unsafe {
7666 let val: u32 = ::std::mem::transmute(val);
7667 self._bitfield_1.set(80usize, 4u8, val as u64)
7668 }
7669 }
7670 #[inline]
7671 pub fn reserved2(&self) -> u32 {
7672 unsafe { ::std::mem::transmute(self._bitfield_1.get(84usize, 12u8) as u32) }
7673 }
7674 #[inline]
7675 pub fn set_reserved2(&mut self, val: u32) {
7676 unsafe {
7677 let val: u32 = ::std::mem::transmute(val);
7678 self._bitfield_1.set(84usize, 12u8, val as u64)
7679 }
7680 }
7681 #[inline]
7682 pub fn disable_mv_output(&self) -> u32 {
7683 unsafe { ::std::mem::transmute(self._bitfield_1.get(96usize, 1u8) as u32) }
7684 }
7685 #[inline]
7686 pub fn set_disable_mv_output(&mut self, val: u32) {
7687 unsafe {
7688 let val: u32 = ::std::mem::transmute(val);
7689 self._bitfield_1.set(96usize, 1u8, val as u64)
7690 }
7691 }
7692 #[inline]
7693 pub fn disable_statistics_output(&self) -> u32 {
7694 unsafe { ::std::mem::transmute(self._bitfield_1.get(97usize, 1u8) as u32) }
7695 }
7696 #[inline]
7697 pub fn set_disable_statistics_output(&mut self, val: u32) {
7698 unsafe {
7699 let val: u32 = ::std::mem::transmute(val);
7700 self._bitfield_1.set(97usize, 1u8, val as u64)
7701 }
7702 }
7703 #[inline]
7704 pub fn enable_8x8_statistics(&self) -> u32 {
7705 unsafe { ::std::mem::transmute(self._bitfield_1.get(98usize, 1u8) as u32) }
7706 }
7707 #[inline]
7708 pub fn set_enable_8x8_statistics(&mut self, val: u32) {
7709 unsafe {
7710 let val: u32 = ::std::mem::transmute(val);
7711 self._bitfield_1.set(98usize, 1u8, val as u64)
7712 }
7713 }
7714 #[inline]
7715 pub fn reserved3(&self) -> u32 {
7716 unsafe { ::std::mem::transmute(self._bitfield_1.get(99usize, 29u8) as u32) }
7717 }
7718 #[inline]
7719 pub fn set_reserved3(&mut self, val: u32) {
7720 unsafe {
7721 let val: u32 = ::std::mem::transmute(val);
7722 self._bitfield_1.set(99usize, 29u8, val as u64)
7723 }
7724 }
7725 #[inline]
7726 pub fn new_bitfield_1(
7727 frame_qp: u32,
7728 len_sp: u32,
7729 search_path: u32,
7730 reserved0: u32,
7731 sub_mb_part_mask: u32,
7732 sub_pel_mode: u32,
7733 inter_sad: u32,
7734 intra_sad: u32,
7735 adaptive_search: u32,
7736 mv_predictor_ctrl: u32,
7737 mb_qp: u32,
7738 ft_enable: u32,
7739 intra_part_mask: u32,
7740 reserved1: u32,
7741 ref_width: u32,
7742 ref_height: u32,
7743 search_window: u32,
7744 reserved2: u32,
7745 disable_mv_output: u32,
7746 disable_statistics_output: u32,
7747 enable_8x8_statistics: u32,
7748 reserved3: u32,
7749 ) -> __BindgenBitfieldUnit<[u8; 16usize]> {
7750 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 16usize]> = Default::default();
7751 __bindgen_bitfield_unit.set(0usize, 8u8, {
7752 let frame_qp: u32 = unsafe { ::std::mem::transmute(frame_qp) };
7753 frame_qp as u64
7754 });
7755 __bindgen_bitfield_unit.set(8usize, 8u8, {
7756 let len_sp: u32 = unsafe { ::std::mem::transmute(len_sp) };
7757 len_sp as u64
7758 });
7759 __bindgen_bitfield_unit.set(16usize, 8u8, {
7760 let search_path: u32 = unsafe { ::std::mem::transmute(search_path) };
7761 search_path as u64
7762 });
7763 __bindgen_bitfield_unit.set(24usize, 8u8, {
7764 let reserved0: u32 = unsafe { ::std::mem::transmute(reserved0) };
7765 reserved0 as u64
7766 });
7767 __bindgen_bitfield_unit.set(32usize, 7u8, {
7768 let sub_mb_part_mask: u32 = unsafe { ::std::mem::transmute(sub_mb_part_mask) };
7769 sub_mb_part_mask as u64
7770 });
7771 __bindgen_bitfield_unit.set(39usize, 2u8, {
7772 let sub_pel_mode: u32 = unsafe { ::std::mem::transmute(sub_pel_mode) };
7773 sub_pel_mode as u64
7774 });
7775 __bindgen_bitfield_unit.set(41usize, 2u8, {
7776 let inter_sad: u32 = unsafe { ::std::mem::transmute(inter_sad) };
7777 inter_sad as u64
7778 });
7779 __bindgen_bitfield_unit.set(43usize, 2u8, {
7780 let intra_sad: u32 = unsafe { ::std::mem::transmute(intra_sad) };
7781 intra_sad as u64
7782 });
7783 __bindgen_bitfield_unit.set(45usize, 1u8, {
7784 let adaptive_search: u32 = unsafe { ::std::mem::transmute(adaptive_search) };
7785 adaptive_search as u64
7786 });
7787 __bindgen_bitfield_unit.set(46usize, 3u8, {
7788 let mv_predictor_ctrl: u32 = unsafe { ::std::mem::transmute(mv_predictor_ctrl) };
7789 mv_predictor_ctrl as u64
7790 });
7791 __bindgen_bitfield_unit.set(49usize, 1u8, {
7792 let mb_qp: u32 = unsafe { ::std::mem::transmute(mb_qp) };
7793 mb_qp as u64
7794 });
7795 __bindgen_bitfield_unit.set(50usize, 1u8, {
7796 let ft_enable: u32 = unsafe { ::std::mem::transmute(ft_enable) };
7797 ft_enable as u64
7798 });
7799 __bindgen_bitfield_unit.set(51usize, 5u8, {
7800 let intra_part_mask: u32 = unsafe { ::std::mem::transmute(intra_part_mask) };
7801 intra_part_mask as u64
7802 });
7803 __bindgen_bitfield_unit.set(56usize, 8u8, {
7804 let reserved1: u32 = unsafe { ::std::mem::transmute(reserved1) };
7805 reserved1 as u64
7806 });
7807 __bindgen_bitfield_unit.set(64usize, 8u8, {
7808 let ref_width: u32 = unsafe { ::std::mem::transmute(ref_width) };
7809 ref_width as u64
7810 });
7811 __bindgen_bitfield_unit.set(72usize, 8u8, {
7812 let ref_height: u32 = unsafe { ::std::mem::transmute(ref_height) };
7813 ref_height as u64
7814 });
7815 __bindgen_bitfield_unit.set(80usize, 4u8, {
7816 let search_window: u32 = unsafe { ::std::mem::transmute(search_window) };
7817 search_window as u64
7818 });
7819 __bindgen_bitfield_unit.set(84usize, 12u8, {
7820 let reserved2: u32 = unsafe { ::std::mem::transmute(reserved2) };
7821 reserved2 as u64
7822 });
7823 __bindgen_bitfield_unit.set(96usize, 1u8, {
7824 let disable_mv_output: u32 = unsafe { ::std::mem::transmute(disable_mv_output) };
7825 disable_mv_output as u64
7826 });
7827 __bindgen_bitfield_unit.set(97usize, 1u8, {
7828 let disable_statistics_output: u32 =
7829 unsafe { ::std::mem::transmute(disable_statistics_output) };
7830 disable_statistics_output as u64
7831 });
7832 __bindgen_bitfield_unit.set(98usize, 1u8, {
7833 let enable_8x8_statistics: u32 =
7834 unsafe { ::std::mem::transmute(enable_8x8_statistics) };
7835 enable_8x8_statistics as u64
7836 });
7837 __bindgen_bitfield_unit.set(99usize, 29u8, {
7838 let reserved3: u32 = unsafe { ::std::mem::transmute(reserved3) };
7839 reserved3 as u64
7840 });
7841 __bindgen_bitfield_unit
7842 }
7843}
7844pub type VAStatsStatisticsParameterH264 = _VAStatsStatisticsParameterH264;
7845#[repr(C)]
7846#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
7847pub struct _VAStatsStatisticsH264 {
7848 pub _bitfield_align_1: [u16; 0],
7849 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 16usize]>,
7850 pub sum_coef: u32,
7851 pub _bitfield_align_2: [u32; 0],
7852 pub _bitfield_2: __BindgenBitfieldUnit<[u8; 4usize]>,
7853 pub variance_16x16: u32,
7854 pub variance_8x8: [u32; 4usize],
7855 pub pixel_average_16x16: u32,
7856 pub pixel_average_8x8: [u32; 4usize],
7857}
7858impl _VAStatsStatisticsH264 {
7859 #[inline]
7860 pub fn best_inter_distortion0(&self) -> u32 {
7861 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 16u8) as u32) }
7862 }
7863 #[inline]
7864 pub fn set_best_inter_distortion0(&mut self, val: u32) {
7865 unsafe {
7866 let val: u32 = ::std::mem::transmute(val);
7867 self._bitfield_1.set(0usize, 16u8, val as u64)
7868 }
7869 }
7870 #[inline]
7871 pub fn inter_mode0(&self) -> u32 {
7872 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 16u8) as u32) }
7873 }
7874 #[inline]
7875 pub fn set_inter_mode0(&mut self, val: u32) {
7876 unsafe {
7877 let val: u32 = ::std::mem::transmute(val);
7878 self._bitfield_1.set(16usize, 16u8, val as u64)
7879 }
7880 }
7881 #[inline]
7882 pub fn best_inter_distortion1(&self) -> u32 {
7883 unsafe { ::std::mem::transmute(self._bitfield_1.get(32usize, 16u8) as u32) }
7884 }
7885 #[inline]
7886 pub fn set_best_inter_distortion1(&mut self, val: u32) {
7887 unsafe {
7888 let val: u32 = ::std::mem::transmute(val);
7889 self._bitfield_1.set(32usize, 16u8, val as u64)
7890 }
7891 }
7892 #[inline]
7893 pub fn inter_mode1(&self) -> u32 {
7894 unsafe { ::std::mem::transmute(self._bitfield_1.get(48usize, 16u8) as u32) }
7895 }
7896 #[inline]
7897 pub fn set_inter_mode1(&mut self, val: u32) {
7898 unsafe {
7899 let val: u32 = ::std::mem::transmute(val);
7900 self._bitfield_1.set(48usize, 16u8, val as u64)
7901 }
7902 }
7903 #[inline]
7904 pub fn best_intra_distortion(&self) -> u32 {
7905 unsafe { ::std::mem::transmute(self._bitfield_1.get(64usize, 16u8) as u32) }
7906 }
7907 #[inline]
7908 pub fn set_best_intra_distortion(&mut self, val: u32) {
7909 unsafe {
7910 let val: u32 = ::std::mem::transmute(val);
7911 self._bitfield_1.set(64usize, 16u8, val as u64)
7912 }
7913 }
7914 #[inline]
7915 pub fn intra_mode(&self) -> u32 {
7916 unsafe { ::std::mem::transmute(self._bitfield_1.get(80usize, 16u8) as u32) }
7917 }
7918 #[inline]
7919 pub fn set_intra_mode(&mut self, val: u32) {
7920 unsafe {
7921 let val: u32 = ::std::mem::transmute(val);
7922 self._bitfield_1.set(80usize, 16u8, val as u64)
7923 }
7924 }
7925 #[inline]
7926 pub fn num_non_zero_coef(&self) -> u32 {
7927 unsafe { ::std::mem::transmute(self._bitfield_1.get(96usize, 16u8) as u32) }
7928 }
7929 #[inline]
7930 pub fn set_num_non_zero_coef(&mut self, val: u32) {
7931 unsafe {
7932 let val: u32 = ::std::mem::transmute(val);
7933 self._bitfield_1.set(96usize, 16u8, val as u64)
7934 }
7935 }
7936 #[inline]
7937 pub fn reserved0(&self) -> u32 {
7938 unsafe { ::std::mem::transmute(self._bitfield_1.get(112usize, 16u8) as u32) }
7939 }
7940 #[inline]
7941 pub fn set_reserved0(&mut self, val: u32) {
7942 unsafe {
7943 let val: u32 = ::std::mem::transmute(val);
7944 self._bitfield_1.set(112usize, 16u8, val as u64)
7945 }
7946 }
7947 #[inline]
7948 pub fn new_bitfield_1(
7949 best_inter_distortion0: u32,
7950 inter_mode0: u32,
7951 best_inter_distortion1: u32,
7952 inter_mode1: u32,
7953 best_intra_distortion: u32,
7954 intra_mode: u32,
7955 num_non_zero_coef: u32,
7956 reserved0: u32,
7957 ) -> __BindgenBitfieldUnit<[u8; 16usize]> {
7958 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 16usize]> = Default::default();
7959 __bindgen_bitfield_unit.set(0usize, 16u8, {
7960 let best_inter_distortion0: u32 =
7961 unsafe { ::std::mem::transmute(best_inter_distortion0) };
7962 best_inter_distortion0 as u64
7963 });
7964 __bindgen_bitfield_unit.set(16usize, 16u8, {
7965 let inter_mode0: u32 = unsafe { ::std::mem::transmute(inter_mode0) };
7966 inter_mode0 as u64
7967 });
7968 __bindgen_bitfield_unit.set(32usize, 16u8, {
7969 let best_inter_distortion1: u32 =
7970 unsafe { ::std::mem::transmute(best_inter_distortion1) };
7971 best_inter_distortion1 as u64
7972 });
7973 __bindgen_bitfield_unit.set(48usize, 16u8, {
7974 let inter_mode1: u32 = unsafe { ::std::mem::transmute(inter_mode1) };
7975 inter_mode1 as u64
7976 });
7977 __bindgen_bitfield_unit.set(64usize, 16u8, {
7978 let best_intra_distortion: u32 =
7979 unsafe { ::std::mem::transmute(best_intra_distortion) };
7980 best_intra_distortion as u64
7981 });
7982 __bindgen_bitfield_unit.set(80usize, 16u8, {
7983 let intra_mode: u32 = unsafe { ::std::mem::transmute(intra_mode) };
7984 intra_mode as u64
7985 });
7986 __bindgen_bitfield_unit.set(96usize, 16u8, {
7987 let num_non_zero_coef: u32 = unsafe { ::std::mem::transmute(num_non_zero_coef) };
7988 num_non_zero_coef as u64
7989 });
7990 __bindgen_bitfield_unit.set(112usize, 16u8, {
7991 let reserved0: u32 = unsafe { ::std::mem::transmute(reserved0) };
7992 reserved0 as u64
7993 });
7994 __bindgen_bitfield_unit
7995 }
7996 #[inline]
7997 pub fn mb_is_flat(&self) -> u32 {
7998 unsafe { ::std::mem::transmute(self._bitfield_2.get(0usize, 1u8) as u32) }
7999 }
8000 #[inline]
8001 pub fn set_mb_is_flat(&mut self, val: u32) {
8002 unsafe {
8003 let val: u32 = ::std::mem::transmute(val);
8004 self._bitfield_2.set(0usize, 1u8, val as u64)
8005 }
8006 }
8007 #[inline]
8008 pub fn reserved1(&self) -> u32 {
8009 unsafe { ::std::mem::transmute(self._bitfield_2.get(1usize, 31u8) as u32) }
8010 }
8011 #[inline]
8012 pub fn set_reserved1(&mut self, val: u32) {
8013 unsafe {
8014 let val: u32 = ::std::mem::transmute(val);
8015 self._bitfield_2.set(1usize, 31u8, val as u64)
8016 }
8017 }
8018 #[inline]
8019 pub fn new_bitfield_2(mb_is_flat: u32, reserved1: u32) -> __BindgenBitfieldUnit<[u8; 4usize]> {
8020 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
8021 __bindgen_bitfield_unit.set(0usize, 1u8, {
8022 let mb_is_flat: u32 = unsafe { ::std::mem::transmute(mb_is_flat) };
8023 mb_is_flat as u64
8024 });
8025 __bindgen_bitfield_unit.set(1usize, 31u8, {
8026 let reserved1: u32 = unsafe { ::std::mem::transmute(reserved1) };
8027 reserved1 as u64
8028 });
8029 __bindgen_bitfield_unit
8030 }
8031}
8032pub type VAStatsStatisticsH264 = _VAStatsStatisticsH264;
8033pub const _VAProcFilterType_VAProcFilterNone: _VAProcFilterType = 0;
8034pub const _VAProcFilterType_VAProcFilterNoiseReduction: _VAProcFilterType = 1;
8035pub const _VAProcFilterType_VAProcFilterDeinterlacing: _VAProcFilterType = 2;
8036pub const _VAProcFilterType_VAProcFilterSharpening: _VAProcFilterType = 3;
8037pub const _VAProcFilterType_VAProcFilterColorBalance: _VAProcFilterType = 4;
8038pub const _VAProcFilterType_VAProcFilterSkinToneEnhancement: _VAProcFilterType = 5;
8039pub const _VAProcFilterType_VAProcFilterTotalColorCorrection: _VAProcFilterType = 6;
8040pub const _VAProcFilterType_VAProcFilterHVSNoiseReduction: _VAProcFilterType = 7;
8041pub const _VAProcFilterType_VAProcFilterHighDynamicRangeToneMapping: _VAProcFilterType = 8;
8042pub const _VAProcFilterType_VAProcFilter3DLUT: _VAProcFilterType = 9;
8043pub const _VAProcFilterType_VAProcFilterCount: _VAProcFilterType = 10;
8044pub type _VAProcFilterType = ::std::os::raw::c_uint;
8045pub use self::_VAProcFilterType as VAProcFilterType;
8046pub const _VAProcColorStandardType_VAProcColorStandardNone: _VAProcColorStandardType = 0;
8047pub const _VAProcColorStandardType_VAProcColorStandardBT601: _VAProcColorStandardType = 1;
8048pub const _VAProcColorStandardType_VAProcColorStandardBT709: _VAProcColorStandardType = 2;
8049pub const _VAProcColorStandardType_VAProcColorStandardBT470M: _VAProcColorStandardType = 3;
8050pub const _VAProcColorStandardType_VAProcColorStandardBT470BG: _VAProcColorStandardType = 4;
8051pub const _VAProcColorStandardType_VAProcColorStandardSMPTE170M: _VAProcColorStandardType = 5;
8052pub const _VAProcColorStandardType_VAProcColorStandardSMPTE240M: _VAProcColorStandardType = 6;
8053pub const _VAProcColorStandardType_VAProcColorStandardGenericFilm: _VAProcColorStandardType = 7;
8054pub const _VAProcColorStandardType_VAProcColorStandardSRGB: _VAProcColorStandardType = 8;
8055pub const _VAProcColorStandardType_VAProcColorStandardSTRGB: _VAProcColorStandardType = 9;
8056pub const _VAProcColorStandardType_VAProcColorStandardXVYCC601: _VAProcColorStandardType = 10;
8057pub const _VAProcColorStandardType_VAProcColorStandardXVYCC709: _VAProcColorStandardType = 11;
8058pub const _VAProcColorStandardType_VAProcColorStandardBT2020: _VAProcColorStandardType = 12;
8059pub const _VAProcColorStandardType_VAProcColorStandardExplicit: _VAProcColorStandardType = 13;
8060pub const _VAProcColorStandardType_VAProcColorStandardCount: _VAProcColorStandardType = 14;
8061pub type _VAProcColorStandardType = ::std::os::raw::c_uint;
8062pub use self::_VAProcColorStandardType as VAProcColorStandardType;
8063#[repr(C)]
8064#[derive(Debug, Copy, Clone, PartialEq, Eq)]
8065pub struct _VAProcPipelineCaps {
8066 pub pipeline_flags: u32,
8067 pub filter_flags: u32,
8068 pub num_forward_references: u32,
8069 pub num_backward_references: u32,
8070 pub input_color_standards: *mut VAProcColorStandardType,
8071 pub num_input_color_standards: u32,
8072 pub output_color_standards: *mut VAProcColorStandardType,
8073 pub num_output_color_standards: u32,
8074 pub rotation_flags: u32,
8075 pub blend_flags: u32,
8076 pub mirror_flags: u32,
8077 pub num_additional_outputs: u32,
8078 pub num_input_pixel_formats: u32,
8079 pub input_pixel_format: *mut u32,
8080 pub num_output_pixel_formats: u32,
8081 pub output_pixel_format: *mut u32,
8082 pub max_input_width: u32,
8083 pub max_input_height: u32,
8084 pub min_input_width: u32,
8085 pub min_input_height: u32,
8086 pub max_output_width: u32,
8087 pub max_output_height: u32,
8088 pub min_output_width: u32,
8089 pub min_output_height: u32,
8090 pub va_reserved: [u32; 14usize],
8091}
8092impl Default for _VAProcPipelineCaps {
8093 fn default() -> Self {
8094 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
8095 unsafe {
8096 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
8097 s.assume_init()
8098 }
8099 }
8100}
8101pub type VAProcPipelineCaps = _VAProcPipelineCaps;
8102extern "C" {
8103 pub fn vaQueryVideoProcFilters(
8104 dpy: VADisplay,
8105 context: VAContextID,
8106 filters: *mut VAProcFilterType,
8107 num_filters: *mut ::std::os::raw::c_uint,
8108 ) -> VAStatus;
8109}
8110extern "C" {
8111 pub fn vaQueryVideoProcFilterCaps(
8112 dpy: VADisplay,
8113 context: VAContextID,
8114 type_: VAProcFilterType,
8115 filter_caps: *mut ::std::os::raw::c_void,
8116 num_filter_caps: *mut ::std::os::raw::c_uint,
8117 ) -> VAStatus;
8118}
8119extern "C" {
8120 pub fn vaQueryVideoProcPipelineCaps(
8121 dpy: VADisplay,
8122 context: VAContextID,
8123 filters: *mut VABufferID,
8124 num_filters: ::std::os::raw::c_uint,
8125 pipeline_caps: *mut VAProcPipelineCaps,
8126 ) -> VAStatus;
8127}
8128pub type VAProtectedSessionID = VAGenericID;
8129extern "C" {
8130 pub fn vaCreateProtectedSession(
8131 dpy: VADisplay,
8132 config_id: VAConfigID,
8133 protected_session: *mut VAProtectedSessionID,
8134 ) -> VAStatus;
8135}
8136extern "C" {
8137 pub fn vaDestroyProtectedSession(
8138 dpy: VADisplay,
8139 protected_session: VAProtectedSessionID,
8140 ) -> VAStatus;
8141}
8142extern "C" {
8143 pub fn vaAttachProtectedSession(
8144 dpy: VADisplay,
8145 id: VAGenericID,
8146 protected_session: VAProtectedSessionID,
8147 ) -> VAStatus;
8148}
8149extern "C" {
8150 pub fn vaDetachProtectedSession(dpy: VADisplay, id: VAGenericID) -> VAStatus;
8151}
8152extern "C" {
8153 pub fn vaProtectedSessionExecute(
8154 dpy: VADisplay,
8155 protected_session: VAProtectedSessionID,
8156 buf_id: VABufferID,
8157 ) -> VAStatus;
8158}
8159extern "C" {
8160 pub fn vaGetDisplayDRM(fd: ::std::os::raw::c_int) -> VADisplay;
8161}
extremely simple tool to test decoding functionality of NihAV