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