1 /* automatically generated by tools/bindgen-all-the-things */
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)]
13 #[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
14 pub struct __BindgenBitfieldUnit<Storage> {
17 impl<Storage> __BindgenBitfieldUnit<Storage> {
19 pub const fn new(storage: Storage) -> Self {
23 impl<Storage> __BindgenBitfieldUnit<Storage>
25 Storage: AsRef<[u8]> + AsMut<[u8]>,
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") {
37 let mask = 1 << bit_index;
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") {
50 let mask = 1 << bit_index;
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());
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
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) {
82 let val_bit_is_set = val & mask == mask;
83 let index = if cfg!(target_endian = "big") {
84 bit_width as usize - 1 - i
88 self.set_bit(index + bit_offset, val_bit_is_set);
92 pub type __int8_t = ::std::os::raw::c_schar;
93 pub type __uint8_t = ::std::os::raw::c_uchar;
94 pub type __int16_t = ::std::os::raw::c_short;
95 pub type __uint16_t = ::std::os::raw::c_ushort;
96 pub type __int32_t = ::std::os::raw::c_int;
97 pub type __uint32_t = ::std::os::raw::c_uint;
98 pub type __uint64_t = ::std::os::raw::c_ulong;
99 pub type VADisplay = *mut ::std::os::raw::c_void;
100 pub type VAStatus = ::std::os::raw::c_int;
102 pub fn vaErrorStr(error_status: VAStatus) -> *const ::std::os::raw::c_char;
105 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
106 pub struct _VAMotionVector {
107 pub mv0: [i16; 2usize],
108 pub mv1: [i16; 2usize],
110 pub type VAMotionVector = _VAMotionVector;
111 pub 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,
118 pub fn vaSetErrorCallback(
120 callback: VAMessageCallback,
121 user_context: *mut ::std::os::raw::c_void,
122 ) -> VAMessageCallback;
125 pub fn vaSetInfoCallback(
127 callback: VAMessageCallback,
128 user_context: *mut ::std::os::raw::c_void,
129 ) -> VAMessageCallback;
132 pub fn vaDisplayIsValid(dpy: VADisplay) -> ::std::os::raw::c_int;
135 pub fn vaSetDriverName(dpy: VADisplay, driver_name: *mut ::std::os::raw::c_char) -> VAStatus;
140 major_version: *mut ::std::os::raw::c_int,
141 minor_version: *mut ::std::os::raw::c_int,
145 pub fn vaTerminate(dpy: VADisplay) -> VAStatus;
148 pub fn vaQueryVendorString(dpy: VADisplay) -> *const ::std::os::raw::c_char;
150 pub type VAPrivFunc = ::std::option::Option<unsafe extern "C" fn() -> ::std::os::raw::c_int>;
152 pub fn vaGetLibFunc(dpy: VADisplay, func: *const ::std::os::raw::c_char) -> VAPrivFunc;
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;
194 pub 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;
210 pub 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;
268 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
269 pub struct _VAConfigAttrib {
270 pub type_: VAConfigAttribType::Type,
273 impl Default for _VAConfigAttrib {
274 fn default() -> Self {
275 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
277 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
282 pub type VAConfigAttrib = _VAConfigAttrib;
284 pub fn vaMaxNumProfiles(dpy: VADisplay) -> ::std::os::raw::c_int;
287 pub fn vaMaxNumEntrypoints(dpy: VADisplay) -> ::std::os::raw::c_int;
290 pub fn vaMaxNumConfigAttributes(dpy: VADisplay) -> ::std::os::raw::c_int;
293 pub fn vaQueryConfigProfiles(
295 profile_list: *mut VAProfile::Type,
296 num_profiles: *mut ::std::os::raw::c_int,
300 pub fn vaQueryConfigEntrypoints(
302 profile: VAProfile::Type,
303 entrypoint_list: *mut VAEntrypoint::Type,
304 num_entrypoints: *mut ::std::os::raw::c_int,
308 pub fn vaGetConfigAttributes(
310 profile: VAProfile::Type,
311 entrypoint: VAEntrypoint::Type,
312 attrib_list: *mut VAConfigAttrib,
313 num_attribs: ::std::os::raw::c_int,
316 pub type VAGenericID = ::std::os::raw::c_uint;
317 pub type VAConfigID = VAGenericID;
319 pub fn vaCreateConfig(
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,
329 pub fn vaDestroyConfig(dpy: VADisplay, config_id: VAConfigID) -> VAStatus;
332 pub fn vaQueryConfigAttributes(
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,
341 pub type VAContextID = VAGenericID;
342 pub type VASurfaceID = VAGenericID;
343 pub 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;
350 pub type VAGenericFunc = ::std::option::Option<unsafe extern "C" fn()>;
352 #[derive(Copy, Clone)]
353 pub struct _VAGenericValue {
354 pub type_: VAGenericValueType::Type,
355 pub value: _VAGenericValue__bindgen_ty_1,
358 #[derive(Copy, Clone)]
359 pub union _VAGenericValue__bindgen_ty_1 {
362 pub p: *mut ::std::os::raw::c_void,
363 pub fn_: VAGenericFunc,
365 impl Default for _VAGenericValue__bindgen_ty_1 {
366 fn default() -> Self {
367 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
369 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
374 impl Default for _VAGenericValue {
375 fn default() -> Self {
376 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
378 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
383 pub type VAGenericValue = _VAGenericValue;
384 pub 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;
399 #[derive(Copy, Clone)]
400 pub struct _VASurfaceAttrib {
401 pub type_: VASurfaceAttribType::Type,
403 pub value: VAGenericValue,
405 impl Default for _VASurfaceAttrib {
406 fn default() -> Self {
407 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
409 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
414 pub type VASurfaceAttrib = _VASurfaceAttrib;
416 pub fn vaQuerySurfaceAttributes(
419 attrib_list: *mut VASurfaceAttrib,
420 num_attribs: *mut ::std::os::raw::c_uint,
424 pub fn vaCreateSurfaces(
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,
436 pub fn vaDestroySurfaces(
438 surfaces: *mut VASurfaceID,
439 num_surfaces: ::std::os::raw::c_int,
443 pub fn vaCreateContext(
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,
455 pub fn vaDestroyContext(dpy: VADisplay, context: VAContextID) -> VAStatus;
457 pub type VAMFContextID = VAGenericID;
459 pub fn vaCreateMFContext(dpy: VADisplay, mf_context: *mut VAMFContextID) -> VAStatus;
462 pub fn vaMFAddContext(
464 mf_context: VAMFContextID,
465 context: VAContextID,
469 pub fn vaMFReleaseContext(
471 mf_context: VAMFContextID,
472 context: VAContextID,
475 pub type VABufferID = VAGenericID;
476 pub 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;
526 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
527 pub struct _VAProcessingRateParameterEnc {
529 pub reserved: [u8; 3usize],
530 pub quality_level: u32,
531 pub intra_period: u32,
534 pub type VAProcessingRateParameterEnc = _VAProcessingRateParameterEnc;
536 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
537 pub struct _VAProcessingRateParameterDec {
539 pub reserved0: [u8; 3usize],
542 pub type VAProcessingRateParameterDec = _VAProcessingRateParameterDec;
544 #[derive(Copy, Clone)]
545 pub struct _VAProcessingRateParameter {
546 pub __bindgen_anon_1: _VAProcessingRateParameter__bindgen_ty_1,
549 #[derive(Copy, Clone)]
550 pub union _VAProcessingRateParameter__bindgen_ty_1 {
551 pub proc_buf_enc: VAProcessingRateParameterEnc,
552 pub proc_buf_dec: VAProcessingRateParameterDec,
554 impl Default for _VAProcessingRateParameter__bindgen_ty_1 {
555 fn default() -> Self {
556 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
558 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
563 impl Default for _VAProcessingRateParameter {
564 fn default() -> Self {
565 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
567 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
572 pub type VAProcessingRateParameter = _VAProcessingRateParameter;
574 pub fn vaQueryProcessingRate(
577 proc_buf: *mut VAProcessingRateParameter,
578 processing_rate: *mut ::std::os::raw::c_uint,
582 #[derive(Copy, Clone)]
583 pub 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,
590 pub picture_coding_extension: _VAPictureParameterBufferMPEG2__bindgen_ty_1,
591 pub va_reserved: [u32; 4usize],
594 #[derive(Copy, Clone)]
595 pub union _VAPictureParameterBufferMPEG2__bindgen_ty_1 {
596 pub bits: _VAPictureParameterBufferMPEG2__bindgen_ty_1__bindgen_ty_1,
601 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
602 pub 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,
607 impl _VAPictureParameterBufferMPEG2__bindgen_ty_1__bindgen_ty_1 {
609 pub fn intra_dc_precision(&self) -> u32 {
610 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u32) }
613 pub fn set_intra_dc_precision(&mut self, val: u32) {
615 let val: u32 = ::std::mem::transmute(val);
616 self._bitfield_1.set(0usize, 2u8, val as u64)
620 pub fn picture_structure(&self) -> u32 {
621 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 2u8) as u32) }
624 pub fn set_picture_structure(&mut self, val: u32) {
626 let val: u32 = ::std::mem::transmute(val);
627 self._bitfield_1.set(2usize, 2u8, val as u64)
631 pub fn top_field_first(&self) -> u32 {
632 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
635 pub fn set_top_field_first(&mut self, val: u32) {
637 let val: u32 = ::std::mem::transmute(val);
638 self._bitfield_1.set(4usize, 1u8, val as u64)
642 pub fn frame_pred_frame_dct(&self) -> u32 {
643 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
646 pub fn set_frame_pred_frame_dct(&mut self, val: u32) {
648 let val: u32 = ::std::mem::transmute(val);
649 self._bitfield_1.set(5usize, 1u8, val as u64)
653 pub fn concealment_motion_vectors(&self) -> u32 {
654 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) }
657 pub fn set_concealment_motion_vectors(&mut self, val: u32) {
659 let val: u32 = ::std::mem::transmute(val);
660 self._bitfield_1.set(6usize, 1u8, val as u64)
664 pub fn q_scale_type(&self) -> u32 {
665 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) }
668 pub fn set_q_scale_type(&mut self, val: u32) {
670 let val: u32 = ::std::mem::transmute(val);
671 self._bitfield_1.set(7usize, 1u8, val as u64)
675 pub fn intra_vlc_format(&self) -> u32 {
676 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) }
679 pub fn set_intra_vlc_format(&mut self, val: u32) {
681 let val: u32 = ::std::mem::transmute(val);
682 self._bitfield_1.set(8usize, 1u8, val as u64)
686 pub fn alternate_scan(&self) -> u32 {
687 unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) }
690 pub fn set_alternate_scan(&mut self, val: u32) {
692 let val: u32 = ::std::mem::transmute(val);
693 self._bitfield_1.set(9usize, 1u8, val as u64)
697 pub fn repeat_first_field(&self) -> u32 {
698 unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) }
701 pub fn set_repeat_first_field(&mut self, val: u32) {
703 let val: u32 = ::std::mem::transmute(val);
704 self._bitfield_1.set(10usize, 1u8, val as u64)
708 pub fn progressive_frame(&self) -> u32 {
709 unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) }
712 pub fn set_progressive_frame(&mut self, val: u32) {
714 let val: u32 = ::std::mem::transmute(val);
715 self._bitfield_1.set(11usize, 1u8, val as u64)
719 pub fn is_first_field(&self) -> u32 {
720 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u32) }
723 pub fn set_is_first_field(&mut self, val: u32) {
725 let val: u32 = ::std::mem::transmute(val);
726 self._bitfield_1.set(12usize, 1u8, val as u64)
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,
737 intra_vlc_format: u32,
739 repeat_first_field: u32,
740 progressive_frame: 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
748 __bindgen_bitfield_unit.set(2usize, 2u8, {
749 let picture_structure: u32 = unsafe { ::std::mem::transmute(picture_structure) };
750 picture_structure as u64
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
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
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
765 __bindgen_bitfield_unit.set(7usize, 1u8, {
766 let q_scale_type: u32 = unsafe { ::std::mem::transmute(q_scale_type) };
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
773 __bindgen_bitfield_unit.set(9usize, 1u8, {
774 let alternate_scan: u32 = unsafe { ::std::mem::transmute(alternate_scan) };
775 alternate_scan as u64
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
781 __bindgen_bitfield_unit.set(11usize, 1u8, {
782 let progressive_frame: u32 = unsafe { ::std::mem::transmute(progressive_frame) };
783 progressive_frame as u64
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
789 __bindgen_bitfield_unit
792 impl Default for _VAPictureParameterBufferMPEG2__bindgen_ty_1 {
793 fn default() -> Self {
794 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
796 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
801 impl Default for _VAPictureParameterBufferMPEG2 {
802 fn default() -> Self {
803 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
805 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
810 pub type VAPictureParameterBufferMPEG2 = _VAPictureParameterBufferMPEG2;
812 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
813 pub 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],
824 impl Default for _VAIQMatrixBufferMPEG2 {
825 fn default() -> Self {
826 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
828 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
833 pub type VAIQMatrixBufferMPEG2 = _VAIQMatrixBufferMPEG2;
835 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
836 pub 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],
847 pub type VASliceParameterBufferMPEG2 = _VASliceParameterBufferMPEG2;
849 #[derive(Copy, Clone)]
850 pub 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],
861 #[derive(Copy, Clone)]
862 pub union _VAMacroblockParameterBufferMPEG2__bindgen_ty_1 {
863 pub bits: _VAMacroblockParameterBufferMPEG2__bindgen_ty_1__bindgen_ty_1,
868 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
869 pub 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],
874 impl _VAMacroblockParameterBufferMPEG2__bindgen_ty_1__bindgen_ty_1 {
876 pub fn frame_motion_type(&self) -> u32 {
877 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u32) }
880 pub fn set_frame_motion_type(&mut self, val: u32) {
882 let val: u32 = ::std::mem::transmute(val);
883 self._bitfield_1.set(0usize, 2u8, val as u64)
887 pub fn field_motion_type(&self) -> u32 {
888 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 2u8) as u32) }
891 pub fn set_field_motion_type(&mut self, val: u32) {
893 let val: u32 = ::std::mem::transmute(val);
894 self._bitfield_1.set(2usize, 2u8, val as u64)
898 pub fn dct_type(&self) -> u32 {
899 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
902 pub fn set_dct_type(&mut self, val: u32) {
904 let val: u32 = ::std::mem::transmute(val);
905 self._bitfield_1.set(4usize, 1u8, val as u64)
909 pub fn new_bitfield_1(
910 frame_motion_type: u32,
911 field_motion_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
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
923 __bindgen_bitfield_unit.set(4usize, 1u8, {
924 let dct_type: u32 = unsafe { ::std::mem::transmute(dct_type) };
927 __bindgen_bitfield_unit
930 impl Default for _VAMacroblockParameterBufferMPEG2__bindgen_ty_1 {
931 fn default() -> Self {
932 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
934 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
939 impl Default for _VAMacroblockParameterBufferMPEG2 {
940 fn default() -> Self {
941 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
943 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
948 pub type VAMacroblockParameterBufferMPEG2 = _VAMacroblockParameterBufferMPEG2;
950 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
951 pub struct VAPictureH264 {
952 pub picture_id: VASurfaceID,
955 pub TopFieldOrderCnt: i32,
956 pub BottomFieldOrderCnt: i32,
957 pub va_reserved: [u32; 4usize],
960 /// H.264 Picture Parameter Buffer
962 /// For each picture, and before any slice data, a single
963 /// picture parameter buffer must be send.
965 #[derive(Copy, Clone)]
966 pub struct VAPictureParameterBufferH264 {
967 pub CurrPic: VAPictureH264,
968 pub ReferenceFrames: [VAPictureH264; 16usize],
969 pub picture_width_in_mbs_minus1: u16,
970 pub picture_height_in_mbs_minus1: u16,
971 pub bit_depth_luma_minus8: u8,
972 pub bit_depth_chroma_minus8: u8,
973 pub num_ref_frames: u8,
974 pub seq_fields: _VAPictureParameterBufferH264__bindgen_ty_1,
975 pub num_slice_groups_minus1: u8,
976 pub slice_group_map_type: u8,
977 pub slice_group_change_rate_minus1: u16,
978 pub pic_init_qp_minus26: i8,
979 pub pic_init_qs_minus26: i8,
980 pub chroma_qp_index_offset: i8,
981 pub second_chroma_qp_index_offset: i8,
982 pub pic_fields: _VAPictureParameterBufferH264__bindgen_ty_2,
984 pub va_reserved: [u32; 8usize],
987 #[derive(Copy, Clone)]
988 pub union _VAPictureParameterBufferH264__bindgen_ty_1 {
989 pub bits: _VAPictureParameterBufferH264__bindgen_ty_1__bindgen_ty_1,
994 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
995 pub struct _VAPictureParameterBufferH264__bindgen_ty_1__bindgen_ty_1 {
996 pub _bitfield_align_1: [u8; 0],
997 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 3usize]>,
998 pub __bindgen_padding_0: u8,
1000 impl _VAPictureParameterBufferH264__bindgen_ty_1__bindgen_ty_1 {
1002 pub fn chroma_format_idc(&self) -> u32 {
1003 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u32) }
1006 pub fn set_chroma_format_idc(&mut self, val: u32) {
1008 let val: u32 = ::std::mem::transmute(val);
1009 self._bitfield_1.set(0usize, 2u8, val as u64)
1013 pub fn residual_colour_transform_flag(&self) -> u32 {
1014 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
1017 pub fn set_residual_colour_transform_flag(&mut self, val: u32) {
1019 let val: u32 = ::std::mem::transmute(val);
1020 self._bitfield_1.set(2usize, 1u8, val as u64)
1024 pub fn gaps_in_frame_num_value_allowed_flag(&self) -> u32 {
1025 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
1028 pub fn set_gaps_in_frame_num_value_allowed_flag(&mut self, val: u32) {
1030 let val: u32 = ::std::mem::transmute(val);
1031 self._bitfield_1.set(3usize, 1u8, val as u64)
1035 pub fn frame_mbs_only_flag(&self) -> u32 {
1036 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
1039 pub fn set_frame_mbs_only_flag(&mut self, val: u32) {
1041 let val: u32 = ::std::mem::transmute(val);
1042 self._bitfield_1.set(4usize, 1u8, val as u64)
1046 pub fn mb_adaptive_frame_field_flag(&self) -> u32 {
1047 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
1050 pub fn set_mb_adaptive_frame_field_flag(&mut self, val: u32) {
1052 let val: u32 = ::std::mem::transmute(val);
1053 self._bitfield_1.set(5usize, 1u8, val as u64)
1057 pub fn direct_8x8_inference_flag(&self) -> u32 {
1058 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) }
1061 pub fn set_direct_8x8_inference_flag(&mut self, val: u32) {
1063 let val: u32 = ::std::mem::transmute(val);
1064 self._bitfield_1.set(6usize, 1u8, val as u64)
1068 pub fn MinLumaBiPredSize8x8(&self) -> u32 {
1069 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) }
1072 pub fn set_MinLumaBiPredSize8x8(&mut self, val: u32) {
1074 let val: u32 = ::std::mem::transmute(val);
1075 self._bitfield_1.set(7usize, 1u8, val as u64)
1079 pub fn log2_max_frame_num_minus4(&self) -> u32 {
1080 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 4u8) as u32) }
1083 pub fn set_log2_max_frame_num_minus4(&mut self, val: u32) {
1085 let val: u32 = ::std::mem::transmute(val);
1086 self._bitfield_1.set(8usize, 4u8, val as u64)
1090 pub fn pic_order_cnt_type(&self) -> u32 {
1091 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 2u8) as u32) }
1094 pub fn set_pic_order_cnt_type(&mut self, val: u32) {
1096 let val: u32 = ::std::mem::transmute(val);
1097 self._bitfield_1.set(12usize, 2u8, val as u64)
1101 pub fn log2_max_pic_order_cnt_lsb_minus4(&self) -> u32 {
1102 unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 4u8) as u32) }
1105 pub fn set_log2_max_pic_order_cnt_lsb_minus4(&mut self, val: u32) {
1107 let val: u32 = ::std::mem::transmute(val);
1108 self._bitfield_1.set(14usize, 4u8, val as u64)
1112 pub fn delta_pic_order_always_zero_flag(&self) -> u32 {
1113 unsafe { ::std::mem::transmute(self._bitfield_1.get(18usize, 1u8) as u32) }
1116 pub fn set_delta_pic_order_always_zero_flag(&mut self, val: u32) {
1118 let val: u32 = ::std::mem::transmute(val);
1119 self._bitfield_1.set(18usize, 1u8, val as u64)
1123 pub fn new_bitfield_1(
1124 chroma_format_idc: u32,
1125 residual_colour_transform_flag: u32,
1126 gaps_in_frame_num_value_allowed_flag: u32,
1127 frame_mbs_only_flag: u32,
1128 mb_adaptive_frame_field_flag: u32,
1129 direct_8x8_inference_flag: u32,
1130 MinLumaBiPredSize8x8: u32,
1131 log2_max_frame_num_minus4: u32,
1132 pic_order_cnt_type: u32,
1133 log2_max_pic_order_cnt_lsb_minus4: u32,
1134 delta_pic_order_always_zero_flag: u32,
1135 ) -> __BindgenBitfieldUnit<[u8; 3usize]> {
1136 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 3usize]> = Default::default();
1137 __bindgen_bitfield_unit.set(0usize, 2u8, {
1138 let chroma_format_idc: u32 = unsafe { ::std::mem::transmute(chroma_format_idc) };
1139 chroma_format_idc as u64
1141 __bindgen_bitfield_unit.set(2usize, 1u8, {
1142 let residual_colour_transform_flag: u32 =
1143 unsafe { ::std::mem::transmute(residual_colour_transform_flag) };
1144 residual_colour_transform_flag as u64
1146 __bindgen_bitfield_unit.set(3usize, 1u8, {
1147 let gaps_in_frame_num_value_allowed_flag: u32 =
1148 unsafe { ::std::mem::transmute(gaps_in_frame_num_value_allowed_flag) };
1149 gaps_in_frame_num_value_allowed_flag as u64
1151 __bindgen_bitfield_unit.set(4usize, 1u8, {
1152 let frame_mbs_only_flag: u32 = unsafe { ::std::mem::transmute(frame_mbs_only_flag) };
1153 frame_mbs_only_flag as u64
1155 __bindgen_bitfield_unit.set(5usize, 1u8, {
1156 let mb_adaptive_frame_field_flag: u32 =
1157 unsafe { ::std::mem::transmute(mb_adaptive_frame_field_flag) };
1158 mb_adaptive_frame_field_flag as u64
1160 __bindgen_bitfield_unit.set(6usize, 1u8, {
1161 let direct_8x8_inference_flag: u32 =
1162 unsafe { ::std::mem::transmute(direct_8x8_inference_flag) };
1163 direct_8x8_inference_flag as u64
1165 __bindgen_bitfield_unit.set(7usize, 1u8, {
1166 let MinLumaBiPredSize8x8: u32 = unsafe { ::std::mem::transmute(MinLumaBiPredSize8x8) };
1167 MinLumaBiPredSize8x8 as u64
1169 __bindgen_bitfield_unit.set(8usize, 4u8, {
1170 let log2_max_frame_num_minus4: u32 =
1171 unsafe { ::std::mem::transmute(log2_max_frame_num_minus4) };
1172 log2_max_frame_num_minus4 as u64
1174 __bindgen_bitfield_unit.set(12usize, 2u8, {
1175 let pic_order_cnt_type: u32 = unsafe { ::std::mem::transmute(pic_order_cnt_type) };
1176 pic_order_cnt_type as u64
1178 __bindgen_bitfield_unit.set(14usize, 4u8, {
1179 let log2_max_pic_order_cnt_lsb_minus4: u32 =
1180 unsafe { ::std::mem::transmute(log2_max_pic_order_cnt_lsb_minus4) };
1181 log2_max_pic_order_cnt_lsb_minus4 as u64
1183 __bindgen_bitfield_unit.set(18usize, 1u8, {
1184 let delta_pic_order_always_zero_flag: u32 =
1185 unsafe { ::std::mem::transmute(delta_pic_order_always_zero_flag) };
1186 delta_pic_order_always_zero_flag as u64
1188 __bindgen_bitfield_unit
1191 impl Default for _VAPictureParameterBufferH264__bindgen_ty_1 {
1192 fn default() -> Self {
1193 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1195 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1201 #[derive(Copy, Clone)]
1202 pub union _VAPictureParameterBufferH264__bindgen_ty_2 {
1203 pub bits: _VAPictureParameterBufferH264__bindgen_ty_2__bindgen_ty_1,
1208 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
1209 pub struct _VAPictureParameterBufferH264__bindgen_ty_2__bindgen_ty_1 {
1210 pub _bitfield_align_1: [u8; 0],
1211 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
1212 pub __bindgen_padding_0: u16,
1214 impl _VAPictureParameterBufferH264__bindgen_ty_2__bindgen_ty_1 {
1216 pub fn entropy_coding_mode_flag(&self) -> u32 {
1217 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
1220 pub fn set_entropy_coding_mode_flag(&mut self, val: u32) {
1222 let val: u32 = ::std::mem::transmute(val);
1223 self._bitfield_1.set(0usize, 1u8, val as u64)
1227 pub fn weighted_pred_flag(&self) -> u32 {
1228 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
1231 pub fn set_weighted_pred_flag(&mut self, val: u32) {
1233 let val: u32 = ::std::mem::transmute(val);
1234 self._bitfield_1.set(1usize, 1u8, val as u64)
1238 pub fn weighted_bipred_idc(&self) -> u32 {
1239 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 2u8) as u32) }
1242 pub fn set_weighted_bipred_idc(&mut self, val: u32) {
1244 let val: u32 = ::std::mem::transmute(val);
1245 self._bitfield_1.set(2usize, 2u8, val as u64)
1249 pub fn transform_8x8_mode_flag(&self) -> u32 {
1250 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
1253 pub fn set_transform_8x8_mode_flag(&mut self, val: u32) {
1255 let val: u32 = ::std::mem::transmute(val);
1256 self._bitfield_1.set(4usize, 1u8, val as u64)
1260 pub fn field_pic_flag(&self) -> u32 {
1261 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
1264 pub fn set_field_pic_flag(&mut self, val: u32) {
1266 let val: u32 = ::std::mem::transmute(val);
1267 self._bitfield_1.set(5usize, 1u8, val as u64)
1271 pub fn constrained_intra_pred_flag(&self) -> u32 {
1272 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) }
1275 pub fn set_constrained_intra_pred_flag(&mut self, val: u32) {
1277 let val: u32 = ::std::mem::transmute(val);
1278 self._bitfield_1.set(6usize, 1u8, val as u64)
1282 pub fn pic_order_present_flag(&self) -> u32 {
1283 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) }
1286 pub fn set_pic_order_present_flag(&mut self, val: u32) {
1288 let val: u32 = ::std::mem::transmute(val);
1289 self._bitfield_1.set(7usize, 1u8, val as u64)
1293 pub fn deblocking_filter_control_present_flag(&self) -> u32 {
1294 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) }
1297 pub fn set_deblocking_filter_control_present_flag(&mut self, val: u32) {
1299 let val: u32 = ::std::mem::transmute(val);
1300 self._bitfield_1.set(8usize, 1u8, val as u64)
1304 pub fn redundant_pic_cnt_present_flag(&self) -> u32 {
1305 unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) }
1308 pub fn set_redundant_pic_cnt_present_flag(&mut self, val: u32) {
1310 let val: u32 = ::std::mem::transmute(val);
1311 self._bitfield_1.set(9usize, 1u8, val as u64)
1315 pub fn reference_pic_flag(&self) -> u32 {
1316 unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) }
1319 pub fn set_reference_pic_flag(&mut self, val: u32) {
1321 let val: u32 = ::std::mem::transmute(val);
1322 self._bitfield_1.set(10usize, 1u8, val as u64)
1326 pub fn new_bitfield_1(
1327 entropy_coding_mode_flag: u32,
1328 weighted_pred_flag: u32,
1329 weighted_bipred_idc: u32,
1330 transform_8x8_mode_flag: u32,
1331 field_pic_flag: u32,
1332 constrained_intra_pred_flag: u32,
1333 pic_order_present_flag: u32,
1334 deblocking_filter_control_present_flag: u32,
1335 redundant_pic_cnt_present_flag: u32,
1336 reference_pic_flag: u32,
1337 ) -> __BindgenBitfieldUnit<[u8; 2usize]> {
1338 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default();
1339 __bindgen_bitfield_unit.set(0usize, 1u8, {
1340 let entropy_coding_mode_flag: u32 =
1341 unsafe { ::std::mem::transmute(entropy_coding_mode_flag) };
1342 entropy_coding_mode_flag as u64
1344 __bindgen_bitfield_unit.set(1usize, 1u8, {
1345 let weighted_pred_flag: u32 = unsafe { ::std::mem::transmute(weighted_pred_flag) };
1346 weighted_pred_flag as u64
1348 __bindgen_bitfield_unit.set(2usize, 2u8, {
1349 let weighted_bipred_idc: u32 = unsafe { ::std::mem::transmute(weighted_bipred_idc) };
1350 weighted_bipred_idc as u64
1352 __bindgen_bitfield_unit.set(4usize, 1u8, {
1353 let transform_8x8_mode_flag: u32 =
1354 unsafe { ::std::mem::transmute(transform_8x8_mode_flag) };
1355 transform_8x8_mode_flag as u64
1357 __bindgen_bitfield_unit.set(5usize, 1u8, {
1358 let field_pic_flag: u32 = unsafe { ::std::mem::transmute(field_pic_flag) };
1359 field_pic_flag as u64
1361 __bindgen_bitfield_unit.set(6usize, 1u8, {
1362 let constrained_intra_pred_flag: u32 =
1363 unsafe { ::std::mem::transmute(constrained_intra_pred_flag) };
1364 constrained_intra_pred_flag as u64
1366 __bindgen_bitfield_unit.set(7usize, 1u8, {
1367 let pic_order_present_flag: u32 =
1368 unsafe { ::std::mem::transmute(pic_order_present_flag) };
1369 pic_order_present_flag as u64
1371 __bindgen_bitfield_unit.set(8usize, 1u8, {
1372 let deblocking_filter_control_present_flag: u32 =
1373 unsafe { ::std::mem::transmute(deblocking_filter_control_present_flag) };
1374 deblocking_filter_control_present_flag as u64
1376 __bindgen_bitfield_unit.set(9usize, 1u8, {
1377 let redundant_pic_cnt_present_flag: u32 =
1378 unsafe { ::std::mem::transmute(redundant_pic_cnt_present_flag) };
1379 redundant_pic_cnt_present_flag as u64
1381 __bindgen_bitfield_unit.set(10usize, 1u8, {
1382 let reference_pic_flag: u32 = unsafe { ::std::mem::transmute(reference_pic_flag) };
1383 reference_pic_flag as u64
1385 __bindgen_bitfield_unit
1388 impl Default for _VAPictureParameterBufferH264__bindgen_ty_2 {
1389 fn default() -> Self {
1390 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1392 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1397 impl Default for VAPictureParameterBufferH264 {
1398 fn default() -> Self {
1399 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1401 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1406 /// H.264 Inverse Quantization Matrix Buffer
1408 /// Fill scaling lists with the default value (16) if they are not available.
1410 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
1411 pub struct VAIQMatrixBufferH264 {
1412 pub ScalingList4x4: [[u8; 16usize]; 6usize],
1413 pub ScalingList8x8: [[u8; 64usize]; 2usize],
1414 pub va_reserved: [u32; 4usize],
1416 impl Default for VAIQMatrixBufferH264 {
1417 fn default() -> Self {
1418 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1420 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1425 /// H.264 Slice Parameter Buffer
1427 /// For each picture before each slice data buffer, a single
1428 /// slice parameter buffer must be send.
1430 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
1431 pub struct VASliceParameterBufferH264 {
1432 /// Number of bytes in the slice data buffer for this slice
1433 pub slice_data_size: u32,
1434 pub slice_data_offset: u32,
1435 pub slice_data_flag: u32,
1436 /// Bit offset from NAL Header Unit to the begining of slice_data().
1438 /// This bit offset is relative to and includes the NAL unit byte
1439 /// and represents the number of bits parsed in the slice_header()
1440 /// after the removal of any emulation prevention bytes in
1441 /// there. However, the slice data buffer passed to the hardware is
1442 /// the original bitstream, thus including any emulation prevention
1444 pub slice_data_bit_offset: u16,
1445 pub first_mb_in_slice: u16,
1447 pub direct_spatial_mv_pred_flag: u8,
1448 /// H264/AVC syntax element
1450 /// if num_ref_idx_active_override_flag equals 0, host decoder should
1451 /// set its value to num_ref_idx_l0_default_active_minus1.
1452 pub num_ref_idx_l0_active_minus1: u8,
1453 /// H264/AVC syntax element
1455 /// if num_ref_idx_active_override_flag equals 0, host decoder should
1456 /// set its value to num_ref_idx_l1_default_active_minus1.
1457 pub num_ref_idx_l1_active_minus1: u8,
1458 pub cabac_init_idc: u8,
1459 pub slice_qp_delta: i8,
1460 pub disable_deblocking_filter_idc: u8,
1461 pub slice_alpha_c0_offset_div2: i8,
1462 pub slice_beta_offset_div2: i8,
1463 pub RefPicList0: [VAPictureH264; 32usize],
1464 pub RefPicList1: [VAPictureH264; 32usize],
1465 pub luma_log2_weight_denom: u8,
1466 pub chroma_log2_weight_denom: u8,
1467 pub luma_weight_l0_flag: u8,
1468 pub luma_weight_l0: [i16; 32usize],
1469 pub luma_offset_l0: [i16; 32usize],
1470 pub chroma_weight_l0_flag: u8,
1471 pub chroma_weight_l0: [[i16; 2usize]; 32usize],
1472 pub chroma_offset_l0: [[i16; 2usize]; 32usize],
1473 pub luma_weight_l1_flag: u8,
1474 pub luma_weight_l1: [i16; 32usize],
1475 pub luma_offset_l1: [i16; 32usize],
1476 pub chroma_weight_l1_flag: u8,
1477 pub chroma_weight_l1: [[i16; 2usize]; 32usize],
1478 pub chroma_offset_l1: [[i16; 2usize]; 32usize],
1479 pub va_reserved: [u32; 4usize],
1481 pub mod VAEncPictureType {
1482 pub type Type = ::std::os::raw::c_uint;
1483 pub const VAEncPictureTypeIntra: Type = 0;
1484 pub const VAEncPictureTypePredictive: Type = 1;
1485 pub const VAEncPictureTypeBidirectional: Type = 2;
1488 pub fn vaCreateBuffer(
1490 context: VAContextID,
1491 type_: VABufferType::Type,
1492 size: ::std::os::raw::c_uint,
1493 num_elements: ::std::os::raw::c_uint,
1494 data: *mut ::std::os::raw::c_void,
1495 buf_id: *mut VABufferID,
1499 pub fn vaCreateBuffer2(
1501 context: VAContextID,
1502 type_: VABufferType::Type,
1503 width: ::std::os::raw::c_uint,
1504 height: ::std::os::raw::c_uint,
1505 unit_size: *mut ::std::os::raw::c_uint,
1506 pitch: *mut ::std::os::raw::c_uint,
1507 buf_id: *mut VABufferID,
1511 pub fn vaBufferSetNumElements(
1514 num_elements: ::std::os::raw::c_uint,
1521 pbuf: *mut *mut ::std::os::raw::c_void,
1525 pub fn vaUnmapBuffer(dpy: VADisplay, buf_id: VABufferID) -> VAStatus;
1528 pub fn vaDestroyBuffer(dpy: VADisplay, buffer_id: VABufferID) -> VAStatus;
1531 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
1532 pub struct VABufferInfo {
1536 pub mem_size: usize,
1537 pub va_reserved: [u32; 4usize],
1540 pub fn vaAcquireBufferHandle(
1543 buf_info: *mut VABufferInfo,
1547 pub fn vaReleaseBufferHandle(dpy: VADisplay, buf_id: VABufferID) -> VAStatus;
1550 pub fn vaExportSurfaceHandle(
1552 surface_id: VASurfaceID,
1555 descriptor: *mut ::std::os::raw::c_void,
1559 pub fn vaBeginPicture(
1561 context: VAContextID,
1562 render_target: VASurfaceID,
1566 pub fn vaRenderPicture(
1568 context: VAContextID,
1569 buffers: *mut VABufferID,
1570 num_buffers: ::std::os::raw::c_int,
1574 pub fn vaEndPicture(dpy: VADisplay, context: VAContextID) -> VAStatus;
1579 mf_context: VAMFContextID,
1580 contexts: *mut VAContextID,
1581 num_contexts: ::std::os::raw::c_int,
1585 pub fn vaSyncSurface(dpy: VADisplay, render_target: VASurfaceID) -> VAStatus;
1588 pub fn vaSyncSurface2(dpy: VADisplay, surface: VASurfaceID, timeout_ns: u64) -> VAStatus;
1590 pub mod VASurfaceStatus {
1591 pub type Type = ::std::os::raw::c_uint;
1592 pub const VASurfaceRendering: Type = 1;
1593 pub const VASurfaceDisplaying: Type = 2;
1594 pub const VASurfaceReady: Type = 4;
1595 pub const VASurfaceSkipped: Type = 8;
1598 pub fn vaQuerySurfaceStatus(
1600 render_target: VASurfaceID,
1601 status: *mut VASurfaceStatus::Type,
1605 pub fn vaQuerySurfaceError(
1607 surface: VASurfaceID,
1608 error_status: VAStatus,
1609 error_info: *mut *mut ::std::os::raw::c_void,
1613 pub fn vaSyncBuffer(dpy: VADisplay, buf_id: VABufferID, timeout_ns: u64) -> VAStatus;
1616 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
1617 pub struct VAImageFormat {
1619 pub byte_order: u32,
1620 pub bits_per_pixel: u32,
1623 pub green_mask: u32,
1625 pub alpha_mask: u32,
1626 pub va_reserved: [u32; 4usize],
1629 impl VAImageFormat {
1630 pub fn fourcc(&self) -> crate::status::VAResult<crate::formats::VAFourcc> {
1631 self.fourcc.try_into().map_err(|_| crate::status::VAError::InvalidImage)
1635 pub type VAImageID = VAGenericID;
1637 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
1638 pub struct VAImage {
1639 pub image_id: VAImageID,
1640 pub format: VAImageFormat,
1641 pub buf: VABufferID,
1645 pub num_planes: u32,
1646 pub pitches: [u32; 3usize],
1647 pub offsets: [u32; 3usize],
1648 pub num_palette_entries: i32,
1649 pub entry_bytes: i32,
1650 pub component_order: [i8; 4usize],
1651 pub va_reserved: [u32; 4usize],
1654 pub fn vaMaxNumImageFormats(dpy: VADisplay) -> ::std::os::raw::c_int;
1657 pub fn vaQueryImageFormats(
1659 format_list: *mut VAImageFormat,
1660 num_formats: *mut ::std::os::raw::c_int,
1664 pub fn vaCreateImage(
1666 format: *mut VAImageFormat,
1667 width: ::std::os::raw::c_int,
1668 height: ::std::os::raw::c_int,
1669 image: *mut VAImage,
1673 pub fn vaDestroyImage(dpy: VADisplay, image: VAImageID) -> VAStatus;
1676 pub fn vaSetImagePalette(
1679 palette: *mut ::std::os::raw::c_uchar,
1685 surface: VASurfaceID,
1686 x: ::std::os::raw::c_int,
1687 y: ::std::os::raw::c_int,
1688 width: ::std::os::raw::c_uint,
1689 height: ::std::os::raw::c_uint,
1696 surface: VASurfaceID,
1698 src_x: ::std::os::raw::c_int,
1699 src_y: ::std::os::raw::c_int,
1700 src_width: ::std::os::raw::c_uint,
1701 src_height: ::std::os::raw::c_uint,
1702 dest_x: ::std::os::raw::c_int,
1703 dest_y: ::std::os::raw::c_int,
1704 dest_width: ::std::os::raw::c_uint,
1705 dest_height: ::std::os::raw::c_uint,
1709 pub fn vaDeriveImage(dpy: VADisplay, surface: VASurfaceID, image: *mut VAImage) -> VAStatus;
1711 pub type VASubpictureID = VAGenericID;
1713 pub fn vaMaxNumSubpictureFormats(dpy: VADisplay) -> ::std::os::raw::c_int;
1716 pub fn vaQuerySubpictureFormats(
1718 format_list: *mut VAImageFormat,
1719 flags: *mut ::std::os::raw::c_uint,
1720 num_formats: *mut ::std::os::raw::c_uint,
1724 pub fn vaCreateSubpicture(
1727 subpicture: *mut VASubpictureID,
1731 pub fn vaDestroySubpicture(dpy: VADisplay, subpicture: VASubpictureID) -> VAStatus;
1734 pub fn vaSetSubpictureImage(
1736 subpicture: VASubpictureID,
1741 pub fn vaSetSubpictureChromakey(
1743 subpicture: VASubpictureID,
1744 chromakey_min: ::std::os::raw::c_uint,
1745 chromakey_max: ::std::os::raw::c_uint,
1746 chromakey_mask: ::std::os::raw::c_uint,
1750 pub fn vaSetSubpictureGlobalAlpha(
1752 subpicture: VASubpictureID,
1757 pub fn vaAssociateSubpicture(
1759 subpicture: VASubpictureID,
1760 target_surfaces: *mut VASurfaceID,
1761 num_surfaces: ::std::os::raw::c_int,
1774 pub fn vaDeassociateSubpicture(
1776 subpicture: VASubpictureID,
1777 target_surfaces: *mut VASurfaceID,
1778 num_surfaces: ::std::os::raw::c_int,
1781 pub mod VADisplayAttribType {
1782 pub type Type = ::std::os::raw::c_uint;
1783 pub const VADisplayAttribBrightness: Type = 0;
1784 pub const VADisplayAttribContrast: Type = 1;
1785 pub const VADisplayAttribHue: Type = 2;
1786 pub const VADisplayAttribSaturation: Type = 3;
1787 pub const VADisplayAttribBackgroundColor: Type = 4;
1788 pub const VADisplayAttribDirectSurface: Type = 5;
1789 pub const VADisplayAttribRotation: Type = 6;
1790 pub const VADisplayAttribOutofLoopDeblock: Type = 7;
1791 pub const VADisplayAttribBLEBlackMode: Type = 8;
1792 pub const VADisplayAttribBLEWhiteMode: Type = 9;
1793 pub const VADisplayAttribBlueStretch: Type = 10;
1794 pub const VADisplayAttribSkinColorCorrection: Type = 11;
1795 pub const VADisplayAttribCSCMatrix: Type = 12;
1796 pub const VADisplayAttribBlendColor: Type = 13;
1797 pub const VADisplayAttribOverlayAutoPaintColorKey: Type = 14;
1798 pub const VADisplayAttribOverlayColorKey: Type = 15;
1799 pub const VADisplayAttribRenderMode: Type = 16;
1800 pub const VADisplayAttribRenderDevice: Type = 17;
1801 pub const VADisplayAttribRenderRect: Type = 18;
1802 pub const VADisplayAttribSubDevice: Type = 19;
1803 pub const VADisplayAttribCopy: Type = 20;
1804 pub const VADisplayPCIID: Type = 21;
1807 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
1808 pub struct _VADisplayAttribute {
1809 pub type_: VADisplayAttribType::Type,
1814 pub va_reserved: [u32; 4usize],
1816 impl Default for _VADisplayAttribute {
1817 fn default() -> Self {
1818 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1820 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1825 pub type VADisplayAttribute = _VADisplayAttribute;
1827 pub fn vaMaxNumDisplayAttributes(dpy: VADisplay) -> ::std::os::raw::c_int;
1830 pub fn vaQueryDisplayAttributes(
1832 attr_list: *mut VADisplayAttribute,
1833 num_attributes: *mut ::std::os::raw::c_int,
1837 pub fn vaGetDisplayAttributes(
1839 attr_list: *mut VADisplayAttribute,
1840 num_attributes: ::std::os::raw::c_int,
1844 pub fn vaSetDisplayAttributes(
1846 attr_list: *mut VADisplayAttribute,
1847 num_attributes: ::std::os::raw::c_int,
1850 pub mod VACopyObjectType {
1851 pub type Type = ::std::os::raw::c_uint;
1852 pub const VACopyObjectSurface: Type = 0;
1853 pub const VACopyObjectBuffer: Type = 1;
1856 #[derive(Copy, Clone)]
1857 pub struct _VACopyObject {
1858 pub obj_type: VACopyObjectType::Type,
1859 pub object: _VACopyObject__bindgen_ty_1,
1860 pub va_reserved: [u32; 8usize],
1863 #[derive(Copy, Clone)]
1864 pub union _VACopyObject__bindgen_ty_1 {
1865 pub surface_id: VASurfaceID,
1866 pub buffer_id: VABufferID,
1868 impl Default for _VACopyObject__bindgen_ty_1 {
1869 fn default() -> Self {
1870 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1872 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1877 impl Default for _VACopyObject {
1878 fn default() -> Self {
1879 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1881 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1886 pub type VACopyObject = _VACopyObject;
1888 #[derive(Copy, Clone)]
1889 pub union _VACopyOption {
1890 pub bits: _VACopyOption__bindgen_ty_1,
1895 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
1896 pub struct _VACopyOption__bindgen_ty_1 {
1897 pub _bitfield_align_1: [u32; 0],
1898 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
1900 impl _VACopyOption__bindgen_ty_1 {
1902 pub fn va_copy_sync(&self) -> u32 {
1903 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u32) }
1906 pub fn set_va_copy_sync(&mut self, val: u32) {
1908 let val: u32 = ::std::mem::transmute(val);
1909 self._bitfield_1.set(0usize, 2u8, val as u64)
1913 pub fn va_copy_mode(&self) -> u32 {
1914 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 4u8) as u32) }
1917 pub fn set_va_copy_mode(&mut self, val: u32) {
1919 let val: u32 = ::std::mem::transmute(val);
1920 self._bitfield_1.set(2usize, 4u8, val as u64)
1924 pub fn reserved(&self) -> u32 {
1925 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 26u8) as u32) }
1928 pub fn set_reserved(&mut self, val: u32) {
1930 let val: u32 = ::std::mem::transmute(val);
1931 self._bitfield_1.set(6usize, 26u8, val as u64)
1935 pub fn new_bitfield_1(
1939 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
1940 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
1941 __bindgen_bitfield_unit.set(0usize, 2u8, {
1942 let va_copy_sync: u32 = unsafe { ::std::mem::transmute(va_copy_sync) };
1945 __bindgen_bitfield_unit.set(2usize, 4u8, {
1946 let va_copy_mode: u32 = unsafe { ::std::mem::transmute(va_copy_mode) };
1949 __bindgen_bitfield_unit.set(6usize, 26u8, {
1950 let reserved: u32 = unsafe { ::std::mem::transmute(reserved) };
1953 __bindgen_bitfield_unit
1956 impl Default for _VACopyOption {
1957 fn default() -> Self {
1958 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1960 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1965 pub type VACopyOption = _VACopyOption;
1969 dst: *mut VACopyObject,
1970 src: *mut VACopyObject,
1971 option: VACopyOption,
1975 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
1976 pub struct _VABoolCoderContextVPX {
1981 pub type VABoolCoderContextVPX = _VABoolCoderContextVPX;
1983 #[derive(Copy, Clone)]
1984 pub struct _VAPictureParameterBufferVP8 {
1985 pub frame_width: u32,
1986 pub frame_height: u32,
1987 pub last_ref_frame: VASurfaceID,
1988 pub golden_ref_frame: VASurfaceID,
1989 pub alt_ref_frame: VASurfaceID,
1990 pub out_of_loop_frame: VASurfaceID,
1991 pub pic_fields: _VAPictureParameterBufferVP8__bindgen_ty_1,
1992 pub mb_segment_tree_probs: [u8; 3usize],
1993 pub loop_filter_level: [u8; 4usize],
1994 pub loop_filter_deltas_ref_frame: [i8; 4usize],
1995 pub loop_filter_deltas_mode: [i8; 4usize],
1996 pub prob_skip_false: u8,
2000 pub y_mode_probs: [u8; 4usize],
2001 pub uv_mode_probs: [u8; 3usize],
2002 pub mv_probs: [[u8; 19usize]; 2usize],
2003 pub bool_coder_ctx: VABoolCoderContextVPX,
2004 pub va_reserved: [u32; 4usize],
2007 #[derive(Copy, Clone)]
2008 pub union _VAPictureParameterBufferVP8__bindgen_ty_1 {
2009 pub bits: _VAPictureParameterBufferVP8__bindgen_ty_1__bindgen_ty_1,
2014 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
2015 pub struct _VAPictureParameterBufferVP8__bindgen_ty_1__bindgen_ty_1 {
2016 pub _bitfield_align_1: [u8; 0],
2017 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 3usize]>,
2018 pub __bindgen_padding_0: u8,
2020 impl _VAPictureParameterBufferVP8__bindgen_ty_1__bindgen_ty_1 {
2022 pub fn key_frame(&self) -> u32 {
2023 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
2026 pub fn set_key_frame(&mut self, val: u32) {
2028 let val: u32 = ::std::mem::transmute(val);
2029 self._bitfield_1.set(0usize, 1u8, val as u64)
2033 pub fn version(&self) -> u32 {
2034 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 3u8) as u32) }
2037 pub fn set_version(&mut self, val: u32) {
2039 let val: u32 = ::std::mem::transmute(val);
2040 self._bitfield_1.set(1usize, 3u8, val as u64)
2044 pub fn segmentation_enabled(&self) -> u32 {
2045 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
2048 pub fn set_segmentation_enabled(&mut self, val: u32) {
2050 let val: u32 = ::std::mem::transmute(val);
2051 self._bitfield_1.set(4usize, 1u8, val as u64)
2055 pub fn update_mb_segmentation_map(&self) -> u32 {
2056 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
2059 pub fn set_update_mb_segmentation_map(&mut self, val: u32) {
2061 let val: u32 = ::std::mem::transmute(val);
2062 self._bitfield_1.set(5usize, 1u8, val as u64)
2066 pub fn update_segment_feature_data(&self) -> u32 {
2067 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) }
2070 pub fn set_update_segment_feature_data(&mut self, val: u32) {
2072 let val: u32 = ::std::mem::transmute(val);
2073 self._bitfield_1.set(6usize, 1u8, val as u64)
2077 pub fn filter_type(&self) -> u32 {
2078 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) }
2081 pub fn set_filter_type(&mut self, val: u32) {
2083 let val: u32 = ::std::mem::transmute(val);
2084 self._bitfield_1.set(7usize, 1u8, val as u64)
2088 pub fn sharpness_level(&self) -> u32 {
2089 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 3u8) as u32) }
2092 pub fn set_sharpness_level(&mut self, val: u32) {
2094 let val: u32 = ::std::mem::transmute(val);
2095 self._bitfield_1.set(8usize, 3u8, val as u64)
2099 pub fn loop_filter_adj_enable(&self) -> u32 {
2100 unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) }
2103 pub fn set_loop_filter_adj_enable(&mut self, val: u32) {
2105 let val: u32 = ::std::mem::transmute(val);
2106 self._bitfield_1.set(11usize, 1u8, val as u64)
2110 pub fn mode_ref_lf_delta_update(&self) -> u32 {
2111 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u32) }
2114 pub fn set_mode_ref_lf_delta_update(&mut self, val: u32) {
2116 let val: u32 = ::std::mem::transmute(val);
2117 self._bitfield_1.set(12usize, 1u8, val as u64)
2121 pub fn sign_bias_golden(&self) -> u32 {
2122 unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) }
2125 pub fn set_sign_bias_golden(&mut self, val: u32) {
2127 let val: u32 = ::std::mem::transmute(val);
2128 self._bitfield_1.set(13usize, 1u8, val as u64)
2132 pub fn sign_bias_alternate(&self) -> u32 {
2133 unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) }
2136 pub fn set_sign_bias_alternate(&mut self, val: u32) {
2138 let val: u32 = ::std::mem::transmute(val);
2139 self._bitfield_1.set(14usize, 1u8, val as u64)
2143 pub fn mb_no_coeff_skip(&self) -> u32 {
2144 unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u32) }
2147 pub fn set_mb_no_coeff_skip(&mut self, val: u32) {
2149 let val: u32 = ::std::mem::transmute(val);
2150 self._bitfield_1.set(15usize, 1u8, val as u64)
2154 pub fn loop_filter_disable(&self) -> u32 {
2155 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u32) }
2158 pub fn set_loop_filter_disable(&mut self, val: u32) {
2160 let val: u32 = ::std::mem::transmute(val);
2161 self._bitfield_1.set(16usize, 1u8, val as u64)
2165 pub fn new_bitfield_1(
2168 segmentation_enabled: u32,
2169 update_mb_segmentation_map: u32,
2170 update_segment_feature_data: u32,
2172 sharpness_level: u32,
2173 loop_filter_adj_enable: u32,
2174 mode_ref_lf_delta_update: u32,
2175 sign_bias_golden: u32,
2176 sign_bias_alternate: u32,
2177 mb_no_coeff_skip: u32,
2178 loop_filter_disable: u32,
2179 ) -> __BindgenBitfieldUnit<[u8; 3usize]> {
2180 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 3usize]> = Default::default();
2181 __bindgen_bitfield_unit.set(0usize, 1u8, {
2182 let key_frame: u32 = unsafe { ::std::mem::transmute(key_frame) };
2185 __bindgen_bitfield_unit.set(1usize, 3u8, {
2186 let version: u32 = unsafe { ::std::mem::transmute(version) };
2189 __bindgen_bitfield_unit.set(4usize, 1u8, {
2190 let segmentation_enabled: u32 = unsafe { ::std::mem::transmute(segmentation_enabled) };
2191 segmentation_enabled as u64
2193 __bindgen_bitfield_unit.set(5usize, 1u8, {
2194 let update_mb_segmentation_map: u32 =
2195 unsafe { ::std::mem::transmute(update_mb_segmentation_map) };
2196 update_mb_segmentation_map as u64
2198 __bindgen_bitfield_unit.set(6usize, 1u8, {
2199 let update_segment_feature_data: u32 =
2200 unsafe { ::std::mem::transmute(update_segment_feature_data) };
2201 update_segment_feature_data as u64
2203 __bindgen_bitfield_unit.set(7usize, 1u8, {
2204 let filter_type: u32 = unsafe { ::std::mem::transmute(filter_type) };
2207 __bindgen_bitfield_unit.set(8usize, 3u8, {
2208 let sharpness_level: u32 = unsafe { ::std::mem::transmute(sharpness_level) };
2209 sharpness_level as u64
2211 __bindgen_bitfield_unit.set(11usize, 1u8, {
2212 let loop_filter_adj_enable: u32 =
2213 unsafe { ::std::mem::transmute(loop_filter_adj_enable) };
2214 loop_filter_adj_enable as u64
2216 __bindgen_bitfield_unit.set(12usize, 1u8, {
2217 let mode_ref_lf_delta_update: u32 =
2218 unsafe { ::std::mem::transmute(mode_ref_lf_delta_update) };
2219 mode_ref_lf_delta_update as u64
2221 __bindgen_bitfield_unit.set(13usize, 1u8, {
2222 let sign_bias_golden: u32 = unsafe { ::std::mem::transmute(sign_bias_golden) };
2223 sign_bias_golden as u64
2225 __bindgen_bitfield_unit.set(14usize, 1u8, {
2226 let sign_bias_alternate: u32 = unsafe { ::std::mem::transmute(sign_bias_alternate) };
2227 sign_bias_alternate as u64
2229 __bindgen_bitfield_unit.set(15usize, 1u8, {
2230 let mb_no_coeff_skip: u32 = unsafe { ::std::mem::transmute(mb_no_coeff_skip) };
2231 mb_no_coeff_skip as u64
2233 __bindgen_bitfield_unit.set(16usize, 1u8, {
2234 let loop_filter_disable: u32 = unsafe { ::std::mem::transmute(loop_filter_disable) };
2235 loop_filter_disable as u64
2237 __bindgen_bitfield_unit
2240 impl Default for _VAPictureParameterBufferVP8__bindgen_ty_1 {
2241 fn default() -> Self {
2242 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2244 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2249 impl Default for _VAPictureParameterBufferVP8 {
2250 fn default() -> Self {
2251 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2253 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2258 pub type VAPictureParameterBufferVP8 = _VAPictureParameterBufferVP8;
2260 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
2261 pub struct _VASliceParameterBufferVP8 {
2262 pub slice_data_size: u32,
2263 pub slice_data_offset: u32,
2264 pub slice_data_flag: u32,
2265 pub macroblock_offset: u32,
2266 pub num_of_partitions: u8,
2267 pub partition_size: [u32; 9usize],
2268 pub va_reserved: [u32; 4usize],
2270 pub type VASliceParameterBufferVP8 = _VASliceParameterBufferVP8;
2272 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
2273 pub struct _VAProbabilityDataBufferVP8 {
2274 pub dct_coeff_probs: [[[[u8; 11usize]; 3usize]; 8usize]; 4usize],
2275 pub va_reserved: [u32; 4usize],
2277 pub type VAProbabilityDataBufferVP8 = _VAProbabilityDataBufferVP8;
2279 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
2280 pub struct _VAIQMatrixBufferVP8 {
2281 pub quantization_index: [[u16; 6usize]; 4usize],
2282 pub va_reserved: [u32; 4usize],
2284 pub type VAIQMatrixBufferVP8 = _VAIQMatrixBufferVP8;
2286 #[derive(Copy, Clone)]
2287 pub struct _VADecPictureParameterBufferVP9 {
2288 pub frame_width: u16,
2289 pub frame_height: u16,
2290 pub reference_frames: [VASurfaceID; 8usize],
2291 pub pic_fields: _VADecPictureParameterBufferVP9__bindgen_ty_1,
2292 pub filter_level: u8,
2293 pub sharpness_level: u8,
2294 pub log2_tile_rows: u8,
2295 pub log2_tile_columns: u8,
2296 pub frame_header_length_in_bytes: u8,
2297 pub first_partition_size: u16,
2298 pub mb_segment_tree_probs: [u8; 7usize],
2299 pub segment_pred_probs: [u8; 3usize],
2302 pub va_reserved: [u32; 8usize],
2305 #[derive(Copy, Clone)]
2306 pub union _VADecPictureParameterBufferVP9__bindgen_ty_1 {
2307 pub bits: _VADecPictureParameterBufferVP9__bindgen_ty_1__bindgen_ty_1,
2312 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
2313 pub struct _VADecPictureParameterBufferVP9__bindgen_ty_1__bindgen_ty_1 {
2314 pub _bitfield_align_1: [u8; 0],
2315 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
2317 impl _VADecPictureParameterBufferVP9__bindgen_ty_1__bindgen_ty_1 {
2319 pub fn subsampling_x(&self) -> u32 {
2320 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
2323 pub fn set_subsampling_x(&mut self, val: u32) {
2325 let val: u32 = ::std::mem::transmute(val);
2326 self._bitfield_1.set(0usize, 1u8, val as u64)
2330 pub fn subsampling_y(&self) -> u32 {
2331 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
2334 pub fn set_subsampling_y(&mut self, val: u32) {
2336 let val: u32 = ::std::mem::transmute(val);
2337 self._bitfield_1.set(1usize, 1u8, val as u64)
2341 pub fn frame_type(&self) -> u32 {
2342 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
2345 pub fn set_frame_type(&mut self, val: u32) {
2347 let val: u32 = ::std::mem::transmute(val);
2348 self._bitfield_1.set(2usize, 1u8, val as u64)
2352 pub fn show_frame(&self) -> u32 {
2353 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
2356 pub fn set_show_frame(&mut self, val: u32) {
2358 let val: u32 = ::std::mem::transmute(val);
2359 self._bitfield_1.set(3usize, 1u8, val as u64)
2363 pub fn error_resilient_mode(&self) -> u32 {
2364 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
2367 pub fn set_error_resilient_mode(&mut self, val: u32) {
2369 let val: u32 = ::std::mem::transmute(val);
2370 self._bitfield_1.set(4usize, 1u8, val as u64)
2374 pub fn intra_only(&self) -> u32 {
2375 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
2378 pub fn set_intra_only(&mut self, val: u32) {
2380 let val: u32 = ::std::mem::transmute(val);
2381 self._bitfield_1.set(5usize, 1u8, val as u64)
2385 pub fn allow_high_precision_mv(&self) -> u32 {
2386 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) }
2389 pub fn set_allow_high_precision_mv(&mut self, val: u32) {
2391 let val: u32 = ::std::mem::transmute(val);
2392 self._bitfield_1.set(6usize, 1u8, val as u64)
2396 pub fn mcomp_filter_type(&self) -> u32 {
2397 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 3u8) as u32) }
2400 pub fn set_mcomp_filter_type(&mut self, val: u32) {
2402 let val: u32 = ::std::mem::transmute(val);
2403 self._bitfield_1.set(7usize, 3u8, val as u64)
2407 pub fn frame_parallel_decoding_mode(&self) -> u32 {
2408 unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) }
2411 pub fn set_frame_parallel_decoding_mode(&mut self, val: u32) {
2413 let val: u32 = ::std::mem::transmute(val);
2414 self._bitfield_1.set(10usize, 1u8, val as u64)
2418 pub fn reset_frame_context(&self) -> u32 {
2419 unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 2u8) as u32) }
2422 pub fn set_reset_frame_context(&mut self, val: u32) {
2424 let val: u32 = ::std::mem::transmute(val);
2425 self._bitfield_1.set(11usize, 2u8, val as u64)
2429 pub fn refresh_frame_context(&self) -> u32 {
2430 unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) }
2433 pub fn set_refresh_frame_context(&mut self, val: u32) {
2435 let val: u32 = ::std::mem::transmute(val);
2436 self._bitfield_1.set(13usize, 1u8, val as u64)
2440 pub fn frame_context_idx(&self) -> u32 {
2441 unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 2u8) as u32) }
2444 pub fn set_frame_context_idx(&mut self, val: u32) {
2446 let val: u32 = ::std::mem::transmute(val);
2447 self._bitfield_1.set(14usize, 2u8, val as u64)
2451 pub fn segmentation_enabled(&self) -> u32 {
2452 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u32) }
2455 pub fn set_segmentation_enabled(&mut self, val: u32) {
2457 let val: u32 = ::std::mem::transmute(val);
2458 self._bitfield_1.set(16usize, 1u8, val as u64)
2462 pub fn segmentation_temporal_update(&self) -> u32 {
2463 unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 1u8) as u32) }
2466 pub fn set_segmentation_temporal_update(&mut self, val: u32) {
2468 let val: u32 = ::std::mem::transmute(val);
2469 self._bitfield_1.set(17usize, 1u8, val as u64)
2473 pub fn segmentation_update_map(&self) -> u32 {
2474 unsafe { ::std::mem::transmute(self._bitfield_1.get(18usize, 1u8) as u32) }
2477 pub fn set_segmentation_update_map(&mut self, val: u32) {
2479 let val: u32 = ::std::mem::transmute(val);
2480 self._bitfield_1.set(18usize, 1u8, val as u64)
2484 pub fn last_ref_frame(&self) -> u32 {
2485 unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 3u8) as u32) }
2488 pub fn set_last_ref_frame(&mut self, val: u32) {
2490 let val: u32 = ::std::mem::transmute(val);
2491 self._bitfield_1.set(19usize, 3u8, val as u64)
2495 pub fn last_ref_frame_sign_bias(&self) -> u32 {
2496 unsafe { ::std::mem::transmute(self._bitfield_1.get(22usize, 1u8) as u32) }
2499 pub fn set_last_ref_frame_sign_bias(&mut self, val: u32) {
2501 let val: u32 = ::std::mem::transmute(val);
2502 self._bitfield_1.set(22usize, 1u8, val as u64)
2506 pub fn golden_ref_frame(&self) -> u32 {
2507 unsafe { ::std::mem::transmute(self._bitfield_1.get(23usize, 3u8) as u32) }
2510 pub fn set_golden_ref_frame(&mut self, val: u32) {
2512 let val: u32 = ::std::mem::transmute(val);
2513 self._bitfield_1.set(23usize, 3u8, val as u64)
2517 pub fn golden_ref_frame_sign_bias(&self) -> u32 {
2518 unsafe { ::std::mem::transmute(self._bitfield_1.get(26usize, 1u8) as u32) }
2521 pub fn set_golden_ref_frame_sign_bias(&mut self, val: u32) {
2523 let val: u32 = ::std::mem::transmute(val);
2524 self._bitfield_1.set(26usize, 1u8, val as u64)
2528 pub fn alt_ref_frame(&self) -> u32 {
2529 unsafe { ::std::mem::transmute(self._bitfield_1.get(27usize, 3u8) as u32) }
2532 pub fn set_alt_ref_frame(&mut self, val: u32) {
2534 let val: u32 = ::std::mem::transmute(val);
2535 self._bitfield_1.set(27usize, 3u8, val as u64)
2539 pub fn alt_ref_frame_sign_bias(&self) -> u32 {
2540 unsafe { ::std::mem::transmute(self._bitfield_1.get(30usize, 1u8) as u32) }
2543 pub fn set_alt_ref_frame_sign_bias(&mut self, val: u32) {
2545 let val: u32 = ::std::mem::transmute(val);
2546 self._bitfield_1.set(30usize, 1u8, val as u64)
2550 pub fn lossless_flag(&self) -> u32 {
2551 unsafe { ::std::mem::transmute(self._bitfield_1.get(31usize, 1u8) as u32) }
2554 pub fn set_lossless_flag(&mut self, val: u32) {
2556 let val: u32 = ::std::mem::transmute(val);
2557 self._bitfield_1.set(31usize, 1u8, val as u64)
2561 pub fn new_bitfield_1(
2566 error_resilient_mode: u32,
2568 allow_high_precision_mv: u32,
2569 mcomp_filter_type: u32,
2570 frame_parallel_decoding_mode: u32,
2571 reset_frame_context: u32,
2572 refresh_frame_context: u32,
2573 frame_context_idx: u32,
2574 segmentation_enabled: u32,
2575 segmentation_temporal_update: u32,
2576 segmentation_update_map: u32,
2577 last_ref_frame: u32,
2578 last_ref_frame_sign_bias: u32,
2579 golden_ref_frame: u32,
2580 golden_ref_frame_sign_bias: u32,
2582 alt_ref_frame_sign_bias: u32,
2584 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
2585 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
2586 __bindgen_bitfield_unit.set(0usize, 1u8, {
2587 let subsampling_x: u32 = unsafe { ::std::mem::transmute(subsampling_x) };
2588 subsampling_x as u64
2590 __bindgen_bitfield_unit.set(1usize, 1u8, {
2591 let subsampling_y: u32 = unsafe { ::std::mem::transmute(subsampling_y) };
2592 subsampling_y as u64
2594 __bindgen_bitfield_unit.set(2usize, 1u8, {
2595 let frame_type: u32 = unsafe { ::std::mem::transmute(frame_type) };
2598 __bindgen_bitfield_unit.set(3usize, 1u8, {
2599 let show_frame: u32 = unsafe { ::std::mem::transmute(show_frame) };
2602 __bindgen_bitfield_unit.set(4usize, 1u8, {
2603 let error_resilient_mode: u32 = unsafe { ::std::mem::transmute(error_resilient_mode) };
2604 error_resilient_mode as u64
2606 __bindgen_bitfield_unit.set(5usize, 1u8, {
2607 let intra_only: u32 = unsafe { ::std::mem::transmute(intra_only) };
2610 __bindgen_bitfield_unit.set(6usize, 1u8, {
2611 let allow_high_precision_mv: u32 =
2612 unsafe { ::std::mem::transmute(allow_high_precision_mv) };
2613 allow_high_precision_mv as u64
2615 __bindgen_bitfield_unit.set(7usize, 3u8, {
2616 let mcomp_filter_type: u32 = unsafe { ::std::mem::transmute(mcomp_filter_type) };
2617 mcomp_filter_type as u64
2619 __bindgen_bitfield_unit.set(10usize, 1u8, {
2620 let frame_parallel_decoding_mode: u32 =
2621 unsafe { ::std::mem::transmute(frame_parallel_decoding_mode) };
2622 frame_parallel_decoding_mode as u64
2624 __bindgen_bitfield_unit.set(11usize, 2u8, {
2625 let reset_frame_context: u32 = unsafe { ::std::mem::transmute(reset_frame_context) };
2626 reset_frame_context as u64
2628 __bindgen_bitfield_unit.set(13usize, 1u8, {
2629 let refresh_frame_context: u32 =
2630 unsafe { ::std::mem::transmute(refresh_frame_context) };
2631 refresh_frame_context as u64
2633 __bindgen_bitfield_unit.set(14usize, 2u8, {
2634 let frame_context_idx: u32 = unsafe { ::std::mem::transmute(frame_context_idx) };
2635 frame_context_idx as u64
2637 __bindgen_bitfield_unit.set(16usize, 1u8, {
2638 let segmentation_enabled: u32 = unsafe { ::std::mem::transmute(segmentation_enabled) };
2639 segmentation_enabled as u64
2641 __bindgen_bitfield_unit.set(17usize, 1u8, {
2642 let segmentation_temporal_update: u32 =
2643 unsafe { ::std::mem::transmute(segmentation_temporal_update) };
2644 segmentation_temporal_update as u64
2646 __bindgen_bitfield_unit.set(18usize, 1u8, {
2647 let segmentation_update_map: u32 =
2648 unsafe { ::std::mem::transmute(segmentation_update_map) };
2649 segmentation_update_map as u64
2651 __bindgen_bitfield_unit.set(19usize, 3u8, {
2652 let last_ref_frame: u32 = unsafe { ::std::mem::transmute(last_ref_frame) };
2653 last_ref_frame as u64
2655 __bindgen_bitfield_unit.set(22usize, 1u8, {
2656 let last_ref_frame_sign_bias: u32 =
2657 unsafe { ::std::mem::transmute(last_ref_frame_sign_bias) };
2658 last_ref_frame_sign_bias as u64
2660 __bindgen_bitfield_unit.set(23usize, 3u8, {
2661 let golden_ref_frame: u32 = unsafe { ::std::mem::transmute(golden_ref_frame) };
2662 golden_ref_frame as u64
2664 __bindgen_bitfield_unit.set(26usize, 1u8, {
2665 let golden_ref_frame_sign_bias: u32 =
2666 unsafe { ::std::mem::transmute(golden_ref_frame_sign_bias) };
2667 golden_ref_frame_sign_bias as u64
2669 __bindgen_bitfield_unit.set(27usize, 3u8, {
2670 let alt_ref_frame: u32 = unsafe { ::std::mem::transmute(alt_ref_frame) };
2671 alt_ref_frame as u64
2673 __bindgen_bitfield_unit.set(30usize, 1u8, {
2674 let alt_ref_frame_sign_bias: u32 =
2675 unsafe { ::std::mem::transmute(alt_ref_frame_sign_bias) };
2676 alt_ref_frame_sign_bias as u64
2678 __bindgen_bitfield_unit.set(31usize, 1u8, {
2679 let lossless_flag: u32 = unsafe { ::std::mem::transmute(lossless_flag) };
2680 lossless_flag as u64
2682 __bindgen_bitfield_unit
2685 impl Default for _VADecPictureParameterBufferVP9__bindgen_ty_1 {
2686 fn default() -> Self {
2687 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2689 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2694 impl Default for _VADecPictureParameterBufferVP9 {
2695 fn default() -> Self {
2696 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2698 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2703 pub type VADecPictureParameterBufferVP9 = _VADecPictureParameterBufferVP9;
2705 #[derive(Copy, Clone)]
2706 pub struct _VASegmentParameterVP9 {
2707 pub segment_flags: _VASegmentParameterVP9__bindgen_ty_1,
2708 pub filter_level: [[u8; 2usize]; 4usize],
2709 pub luma_ac_quant_scale: i16,
2710 pub luma_dc_quant_scale: i16,
2711 pub chroma_ac_quant_scale: i16,
2712 pub chroma_dc_quant_scale: i16,
2713 pub va_reserved: [u32; 4usize],
2716 #[derive(Copy, Clone)]
2717 pub union _VASegmentParameterVP9__bindgen_ty_1 {
2718 pub fields: _VASegmentParameterVP9__bindgen_ty_1__bindgen_ty_1,
2723 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
2724 pub struct _VASegmentParameterVP9__bindgen_ty_1__bindgen_ty_1 {
2725 pub _bitfield_align_1: [u8; 0],
2726 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
2727 pub __bindgen_padding_0: u8,
2729 impl _VASegmentParameterVP9__bindgen_ty_1__bindgen_ty_1 {
2731 pub fn segment_reference_enabled(&self) -> u16 {
2732 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u16) }
2735 pub fn set_segment_reference_enabled(&mut self, val: u16) {
2737 let val: u16 = ::std::mem::transmute(val);
2738 self._bitfield_1.set(0usize, 1u8, val as u64)
2742 pub fn segment_reference(&self) -> u16 {
2743 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 2u8) as u16) }
2746 pub fn set_segment_reference(&mut self, val: u16) {
2748 let val: u16 = ::std::mem::transmute(val);
2749 self._bitfield_1.set(1usize, 2u8, val as u64)
2753 pub fn segment_reference_skipped(&self) -> u16 {
2754 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u16) }
2757 pub fn set_segment_reference_skipped(&mut self, val: u16) {
2759 let val: u16 = ::std::mem::transmute(val);
2760 self._bitfield_1.set(3usize, 1u8, val as u64)
2764 pub fn new_bitfield_1(
2765 segment_reference_enabled: u16,
2766 segment_reference: u16,
2767 segment_reference_skipped: u16,
2768 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
2769 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
2770 __bindgen_bitfield_unit.set(0usize, 1u8, {
2771 let segment_reference_enabled: u16 =
2772 unsafe { ::std::mem::transmute(segment_reference_enabled) };
2773 segment_reference_enabled as u64
2775 __bindgen_bitfield_unit.set(1usize, 2u8, {
2776 let segment_reference: u16 = unsafe { ::std::mem::transmute(segment_reference) };
2777 segment_reference as u64
2779 __bindgen_bitfield_unit.set(3usize, 1u8, {
2780 let segment_reference_skipped: u16 =
2781 unsafe { ::std::mem::transmute(segment_reference_skipped) };
2782 segment_reference_skipped as u64
2784 __bindgen_bitfield_unit
2787 impl Default for _VASegmentParameterVP9__bindgen_ty_1 {
2788 fn default() -> Self {
2789 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2791 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2796 impl Default for _VASegmentParameterVP9 {
2797 fn default() -> Self {
2798 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2800 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2805 pub type VASegmentParameterVP9 = _VASegmentParameterVP9;
2807 #[derive(Copy, Clone)]
2808 pub struct _VASliceParameterBufferVP9 {
2809 pub slice_data_size: u32,
2810 pub slice_data_offset: u32,
2811 pub slice_data_flag: u32,
2812 pub seg_param: [VASegmentParameterVP9; 8usize],
2813 pub va_reserved: [u32; 4usize],
2815 impl Default for _VASliceParameterBufferVP9 {
2816 fn default() -> Self {
2817 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2819 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2824 pub type VASliceParameterBufferVP9 = _VASliceParameterBufferVP9;
2826 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
2827 pub struct _VAPictureStats {
2828 pub picture_id: VASurfaceID,
2831 pub type VAPictureStats = _VAPictureStats;
2833 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
2834 pub struct _VAStatsStatisticsParameter {
2835 pub input: VAPictureStats,
2836 pub past_references: *mut VAPictureStats,
2837 pub num_past_references: u32,
2838 pub past_ref_stat_buf: *mut VABufferID,
2839 pub future_references: *mut VAPictureStats,
2840 pub num_future_references: u32,
2841 pub future_ref_stat_buf: *mut VABufferID,
2842 pub outputs: *mut VABufferID,
2843 pub mv_predictor: VABufferID,
2846 impl Default for _VAStatsStatisticsParameter {
2847 fn default() -> Self {
2848 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2850 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2855 pub type VAStatsStatisticsParameter = _VAStatsStatisticsParameter;
2856 pub mod VAEncPackedHeaderTypeH264 {
2857 pub type Type = ::std::os::raw::c_uint;
2858 pub const VAEncPackedHeaderH264_SPS: Type = 1;
2859 pub const VAEncPackedHeaderH264_PPS: Type = 2;
2860 pub const VAEncPackedHeaderH264_Slice: Type = 3;
2861 pub const VAEncPackedHeaderH264_SEI: Type = 2147483649;
2864 #[derive(Copy, Clone)]
2865 pub struct _VAEncSequenceParameterBufferH264 {
2866 pub seq_parameter_set_id: u8,
2868 pub intra_period: u32,
2869 pub intra_idr_period: u32,
2871 pub bits_per_second: u32,
2872 pub max_num_ref_frames: u32,
2873 pub picture_width_in_mbs: u16,
2874 pub picture_height_in_mbs: u16,
2875 pub seq_fields: _VAEncSequenceParameterBufferH264__bindgen_ty_1,
2876 pub bit_depth_luma_minus8: u8,
2877 pub bit_depth_chroma_minus8: u8,
2878 pub num_ref_frames_in_pic_order_cnt_cycle: u8,
2879 pub offset_for_non_ref_pic: i32,
2880 pub offset_for_top_to_bottom_field: i32,
2881 pub offset_for_ref_frame: [i32; 256usize],
2882 pub frame_cropping_flag: u8,
2883 pub frame_crop_left_offset: u32,
2884 pub frame_crop_right_offset: u32,
2885 pub frame_crop_top_offset: u32,
2886 pub frame_crop_bottom_offset: u32,
2887 pub vui_parameters_present_flag: u8,
2888 pub vui_fields: _VAEncSequenceParameterBufferH264__bindgen_ty_2,
2889 pub aspect_ratio_idc: u8,
2891 pub sar_height: u32,
2892 pub num_units_in_tick: u32,
2893 pub time_scale: u32,
2894 pub va_reserved: [u32; 4usize],
2897 #[derive(Copy, Clone)]
2898 pub union _VAEncSequenceParameterBufferH264__bindgen_ty_1 {
2899 pub bits: _VAEncSequenceParameterBufferH264__bindgen_ty_1__bindgen_ty_1,
2904 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
2905 pub struct _VAEncSequenceParameterBufferH264__bindgen_ty_1__bindgen_ty_1 {
2906 pub _bitfield_align_1: [u8; 0],
2907 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 3usize]>,
2908 pub __bindgen_padding_0: u8,
2910 impl _VAEncSequenceParameterBufferH264__bindgen_ty_1__bindgen_ty_1 {
2912 pub fn chroma_format_idc(&self) -> u32 {
2913 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u32) }
2916 pub fn set_chroma_format_idc(&mut self, val: u32) {
2918 let val: u32 = ::std::mem::transmute(val);
2919 self._bitfield_1.set(0usize, 2u8, val as u64)
2923 pub fn frame_mbs_only_flag(&self) -> u32 {
2924 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
2927 pub fn set_frame_mbs_only_flag(&mut self, val: u32) {
2929 let val: u32 = ::std::mem::transmute(val);
2930 self._bitfield_1.set(2usize, 1u8, val as u64)
2934 pub fn mb_adaptive_frame_field_flag(&self) -> u32 {
2935 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
2938 pub fn set_mb_adaptive_frame_field_flag(&mut self, val: u32) {
2940 let val: u32 = ::std::mem::transmute(val);
2941 self._bitfield_1.set(3usize, 1u8, val as u64)
2945 pub fn seq_scaling_matrix_present_flag(&self) -> u32 {
2946 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
2949 pub fn set_seq_scaling_matrix_present_flag(&mut self, val: u32) {
2951 let val: u32 = ::std::mem::transmute(val);
2952 self._bitfield_1.set(4usize, 1u8, val as u64)
2956 pub fn direct_8x8_inference_flag(&self) -> u32 {
2957 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
2960 pub fn set_direct_8x8_inference_flag(&mut self, val: u32) {
2962 let val: u32 = ::std::mem::transmute(val);
2963 self._bitfield_1.set(5usize, 1u8, val as u64)
2967 pub fn log2_max_frame_num_minus4(&self) -> u32 {
2968 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 4u8) as u32) }
2971 pub fn set_log2_max_frame_num_minus4(&mut self, val: u32) {
2973 let val: u32 = ::std::mem::transmute(val);
2974 self._bitfield_1.set(6usize, 4u8, val as u64)
2978 pub fn pic_order_cnt_type(&self) -> u32 {
2979 unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 2u8) as u32) }
2982 pub fn set_pic_order_cnt_type(&mut self, val: u32) {
2984 let val: u32 = ::std::mem::transmute(val);
2985 self._bitfield_1.set(10usize, 2u8, val as u64)
2989 pub fn log2_max_pic_order_cnt_lsb_minus4(&self) -> u32 {
2990 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 4u8) as u32) }
2993 pub fn set_log2_max_pic_order_cnt_lsb_minus4(&mut self, val: u32) {
2995 let val: u32 = ::std::mem::transmute(val);
2996 self._bitfield_1.set(12usize, 4u8, val as u64)
3000 pub fn delta_pic_order_always_zero_flag(&self) -> u32 {
3001 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u32) }
3004 pub fn set_delta_pic_order_always_zero_flag(&mut self, val: u32) {
3006 let val: u32 = ::std::mem::transmute(val);
3007 self._bitfield_1.set(16usize, 1u8, val as u64)
3011 pub fn new_bitfield_1(
3012 chroma_format_idc: u32,
3013 frame_mbs_only_flag: u32,
3014 mb_adaptive_frame_field_flag: u32,
3015 seq_scaling_matrix_present_flag: u32,
3016 direct_8x8_inference_flag: u32,
3017 log2_max_frame_num_minus4: u32,
3018 pic_order_cnt_type: u32,
3019 log2_max_pic_order_cnt_lsb_minus4: u32,
3020 delta_pic_order_always_zero_flag: u32,
3021 ) -> __BindgenBitfieldUnit<[u8; 3usize]> {
3022 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 3usize]> = Default::default();
3023 __bindgen_bitfield_unit.set(0usize, 2u8, {
3024 let chroma_format_idc: u32 = unsafe { ::std::mem::transmute(chroma_format_idc) };
3025 chroma_format_idc as u64
3027 __bindgen_bitfield_unit.set(2usize, 1u8, {
3028 let frame_mbs_only_flag: u32 = unsafe { ::std::mem::transmute(frame_mbs_only_flag) };
3029 frame_mbs_only_flag as u64
3031 __bindgen_bitfield_unit.set(3usize, 1u8, {
3032 let mb_adaptive_frame_field_flag: u32 =
3033 unsafe { ::std::mem::transmute(mb_adaptive_frame_field_flag) };
3034 mb_adaptive_frame_field_flag as u64
3036 __bindgen_bitfield_unit.set(4usize, 1u8, {
3037 let seq_scaling_matrix_present_flag: u32 =
3038 unsafe { ::std::mem::transmute(seq_scaling_matrix_present_flag) };
3039 seq_scaling_matrix_present_flag as u64
3041 __bindgen_bitfield_unit.set(5usize, 1u8, {
3042 let direct_8x8_inference_flag: u32 =
3043 unsafe { ::std::mem::transmute(direct_8x8_inference_flag) };
3044 direct_8x8_inference_flag as u64
3046 __bindgen_bitfield_unit.set(6usize, 4u8, {
3047 let log2_max_frame_num_minus4: u32 =
3048 unsafe { ::std::mem::transmute(log2_max_frame_num_minus4) };
3049 log2_max_frame_num_minus4 as u64
3051 __bindgen_bitfield_unit.set(10usize, 2u8, {
3052 let pic_order_cnt_type: u32 = unsafe { ::std::mem::transmute(pic_order_cnt_type) };
3053 pic_order_cnt_type as u64
3055 __bindgen_bitfield_unit.set(12usize, 4u8, {
3056 let log2_max_pic_order_cnt_lsb_minus4: u32 =
3057 unsafe { ::std::mem::transmute(log2_max_pic_order_cnt_lsb_minus4) };
3058 log2_max_pic_order_cnt_lsb_minus4 as u64
3060 __bindgen_bitfield_unit.set(16usize, 1u8, {
3061 let delta_pic_order_always_zero_flag: u32 =
3062 unsafe { ::std::mem::transmute(delta_pic_order_always_zero_flag) };
3063 delta_pic_order_always_zero_flag as u64
3065 __bindgen_bitfield_unit
3068 impl Default for _VAEncSequenceParameterBufferH264__bindgen_ty_1 {
3069 fn default() -> Self {
3070 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3072 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3078 #[derive(Copy, Clone)]
3079 pub union _VAEncSequenceParameterBufferH264__bindgen_ty_2 {
3080 pub bits: _VAEncSequenceParameterBufferH264__bindgen_ty_2__bindgen_ty_1,
3085 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
3086 pub struct _VAEncSequenceParameterBufferH264__bindgen_ty_2__bindgen_ty_1 {
3087 pub _bitfield_align_1: [u16; 0],
3088 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
3090 impl _VAEncSequenceParameterBufferH264__bindgen_ty_2__bindgen_ty_1 {
3092 pub fn aspect_ratio_info_present_flag(&self) -> u32 {
3093 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
3096 pub fn set_aspect_ratio_info_present_flag(&mut self, val: u32) {
3098 let val: u32 = ::std::mem::transmute(val);
3099 self._bitfield_1.set(0usize, 1u8, val as u64)
3103 pub fn timing_info_present_flag(&self) -> u32 {
3104 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
3107 pub fn set_timing_info_present_flag(&mut self, val: u32) {
3109 let val: u32 = ::std::mem::transmute(val);
3110 self._bitfield_1.set(1usize, 1u8, val as u64)
3114 pub fn bitstream_restriction_flag(&self) -> u32 {
3115 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
3118 pub fn set_bitstream_restriction_flag(&mut self, val: u32) {
3120 let val: u32 = ::std::mem::transmute(val);
3121 self._bitfield_1.set(2usize, 1u8, val as u64)
3125 pub fn log2_max_mv_length_horizontal(&self) -> u32 {
3126 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 5u8) as u32) }
3129 pub fn set_log2_max_mv_length_horizontal(&mut self, val: u32) {
3131 let val: u32 = ::std::mem::transmute(val);
3132 self._bitfield_1.set(3usize, 5u8, val as u64)
3136 pub fn log2_max_mv_length_vertical(&self) -> u32 {
3137 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 5u8) as u32) }
3140 pub fn set_log2_max_mv_length_vertical(&mut self, val: u32) {
3142 let val: u32 = ::std::mem::transmute(val);
3143 self._bitfield_1.set(8usize, 5u8, val as u64)
3147 pub fn fixed_frame_rate_flag(&self) -> u32 {
3148 unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) }
3151 pub fn set_fixed_frame_rate_flag(&mut self, val: u32) {
3153 let val: u32 = ::std::mem::transmute(val);
3154 self._bitfield_1.set(13usize, 1u8, val as u64)
3158 pub fn low_delay_hrd_flag(&self) -> u32 {
3159 unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) }
3162 pub fn set_low_delay_hrd_flag(&mut self, val: u32) {
3164 let val: u32 = ::std::mem::transmute(val);
3165 self._bitfield_1.set(14usize, 1u8, val as u64)
3169 pub fn motion_vectors_over_pic_boundaries_flag(&self) -> u32 {
3170 unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u32) }
3173 pub fn set_motion_vectors_over_pic_boundaries_flag(&mut self, val: u32) {
3175 let val: u32 = ::std::mem::transmute(val);
3176 self._bitfield_1.set(15usize, 1u8, val as u64)
3180 pub fn reserved(&self) -> u32 {
3181 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 16u8) as u32) }
3184 pub fn set_reserved(&mut self, val: u32) {
3186 let val: u32 = ::std::mem::transmute(val);
3187 self._bitfield_1.set(16usize, 16u8, val as u64)
3191 pub fn new_bitfield_1(
3192 aspect_ratio_info_present_flag: u32,
3193 timing_info_present_flag: u32,
3194 bitstream_restriction_flag: u32,
3195 log2_max_mv_length_horizontal: u32,
3196 log2_max_mv_length_vertical: u32,
3197 fixed_frame_rate_flag: u32,
3198 low_delay_hrd_flag: u32,
3199 motion_vectors_over_pic_boundaries_flag: u32,
3201 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
3202 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
3203 __bindgen_bitfield_unit.set(0usize, 1u8, {
3204 let aspect_ratio_info_present_flag: u32 =
3205 unsafe { ::std::mem::transmute(aspect_ratio_info_present_flag) };
3206 aspect_ratio_info_present_flag as u64
3208 __bindgen_bitfield_unit.set(1usize, 1u8, {
3209 let timing_info_present_flag: u32 =
3210 unsafe { ::std::mem::transmute(timing_info_present_flag) };
3211 timing_info_present_flag as u64
3213 __bindgen_bitfield_unit.set(2usize, 1u8, {
3214 let bitstream_restriction_flag: u32 =
3215 unsafe { ::std::mem::transmute(bitstream_restriction_flag) };
3216 bitstream_restriction_flag as u64
3218 __bindgen_bitfield_unit.set(3usize, 5u8, {
3219 let log2_max_mv_length_horizontal: u32 =
3220 unsafe { ::std::mem::transmute(log2_max_mv_length_horizontal) };
3221 log2_max_mv_length_horizontal as u64
3223 __bindgen_bitfield_unit.set(8usize, 5u8, {
3224 let log2_max_mv_length_vertical: u32 =
3225 unsafe { ::std::mem::transmute(log2_max_mv_length_vertical) };
3226 log2_max_mv_length_vertical as u64
3228 __bindgen_bitfield_unit.set(13usize, 1u8, {
3229 let fixed_frame_rate_flag: u32 =
3230 unsafe { ::std::mem::transmute(fixed_frame_rate_flag) };
3231 fixed_frame_rate_flag as u64
3233 __bindgen_bitfield_unit.set(14usize, 1u8, {
3234 let low_delay_hrd_flag: u32 = unsafe { ::std::mem::transmute(low_delay_hrd_flag) };
3235 low_delay_hrd_flag as u64
3237 __bindgen_bitfield_unit.set(15usize, 1u8, {
3238 let motion_vectors_over_pic_boundaries_flag: u32 =
3239 unsafe { ::std::mem::transmute(motion_vectors_over_pic_boundaries_flag) };
3240 motion_vectors_over_pic_boundaries_flag as u64
3242 __bindgen_bitfield_unit.set(16usize, 16u8, {
3243 let reserved: u32 = unsafe { ::std::mem::transmute(reserved) };
3246 __bindgen_bitfield_unit
3249 impl Default for _VAEncSequenceParameterBufferH264__bindgen_ty_2 {
3250 fn default() -> Self {
3251 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3253 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3258 impl Default for _VAEncSequenceParameterBufferH264 {
3259 fn default() -> Self {
3260 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3262 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3267 pub type VAEncSequenceParameterBufferH264 = _VAEncSequenceParameterBufferH264;
3269 #[derive(Copy, Clone)]
3270 pub struct _VAEncPictureParameterBufferH264 {
3271 pub CurrPic: VAPictureH264,
3272 pub ReferenceFrames: [VAPictureH264; 16usize],
3273 pub coded_buf: VABufferID,
3274 pub pic_parameter_set_id: u8,
3275 pub seq_parameter_set_id: u8,
3276 pub last_picture: u8,
3278 pub pic_init_qp: u8,
3279 pub num_ref_idx_l0_active_minus1: u8,
3280 pub num_ref_idx_l1_active_minus1: u8,
3281 pub chroma_qp_index_offset: i8,
3282 pub second_chroma_qp_index_offset: i8,
3283 pub pic_fields: _VAEncPictureParameterBufferH264__bindgen_ty_1,
3284 pub va_reserved: [u32; 4usize],
3287 #[derive(Copy, Clone)]
3288 pub union _VAEncPictureParameterBufferH264__bindgen_ty_1 {
3289 pub bits: _VAEncPictureParameterBufferH264__bindgen_ty_1__bindgen_ty_1,
3294 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
3295 pub struct _VAEncPictureParameterBufferH264__bindgen_ty_1__bindgen_ty_1 {
3296 pub _bitfield_align_1: [u8; 0],
3297 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
3298 pub __bindgen_padding_0: u16,
3300 impl _VAEncPictureParameterBufferH264__bindgen_ty_1__bindgen_ty_1 {
3302 pub fn idr_pic_flag(&self) -> u32 {
3303 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
3306 pub fn set_idr_pic_flag(&mut self, val: u32) {
3308 let val: u32 = ::std::mem::transmute(val);
3309 self._bitfield_1.set(0usize, 1u8, val as u64)
3313 pub fn reference_pic_flag(&self) -> u32 {
3314 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 2u8) as u32) }
3317 pub fn set_reference_pic_flag(&mut self, val: u32) {
3319 let val: u32 = ::std::mem::transmute(val);
3320 self._bitfield_1.set(1usize, 2u8, val as u64)
3324 pub fn entropy_coding_mode_flag(&self) -> u32 {
3325 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
3328 pub fn set_entropy_coding_mode_flag(&mut self, val: u32) {
3330 let val: u32 = ::std::mem::transmute(val);
3331 self._bitfield_1.set(3usize, 1u8, val as u64)
3335 pub fn weighted_pred_flag(&self) -> u32 {
3336 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
3339 pub fn set_weighted_pred_flag(&mut self, val: u32) {
3341 let val: u32 = ::std::mem::transmute(val);
3342 self._bitfield_1.set(4usize, 1u8, val as u64)
3346 pub fn weighted_bipred_idc(&self) -> u32 {
3347 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 2u8) as u32) }
3350 pub fn set_weighted_bipred_idc(&mut self, val: u32) {
3352 let val: u32 = ::std::mem::transmute(val);
3353 self._bitfield_1.set(5usize, 2u8, val as u64)
3357 pub fn constrained_intra_pred_flag(&self) -> u32 {
3358 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) }
3361 pub fn set_constrained_intra_pred_flag(&mut self, val: u32) {
3363 let val: u32 = ::std::mem::transmute(val);
3364 self._bitfield_1.set(7usize, 1u8, val as u64)
3368 pub fn transform_8x8_mode_flag(&self) -> u32 {
3369 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) }
3372 pub fn set_transform_8x8_mode_flag(&mut self, val: u32) {
3374 let val: u32 = ::std::mem::transmute(val);
3375 self._bitfield_1.set(8usize, 1u8, val as u64)
3379 pub fn deblocking_filter_control_present_flag(&self) -> u32 {
3380 unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) }
3383 pub fn set_deblocking_filter_control_present_flag(&mut self, val: u32) {
3385 let val: u32 = ::std::mem::transmute(val);
3386 self._bitfield_1.set(9usize, 1u8, val as u64)
3390 pub fn redundant_pic_cnt_present_flag(&self) -> u32 {
3391 unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) }
3394 pub fn set_redundant_pic_cnt_present_flag(&mut self, val: u32) {
3396 let val: u32 = ::std::mem::transmute(val);
3397 self._bitfield_1.set(10usize, 1u8, val as u64)
3401 pub fn pic_order_present_flag(&self) -> u32 {
3402 unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) }
3405 pub fn set_pic_order_present_flag(&mut self, val: u32) {
3407 let val: u32 = ::std::mem::transmute(val);
3408 self._bitfield_1.set(11usize, 1u8, val as u64)
3412 pub fn pic_scaling_matrix_present_flag(&self) -> u32 {
3413 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u32) }
3416 pub fn set_pic_scaling_matrix_present_flag(&mut self, val: u32) {
3418 let val: u32 = ::std::mem::transmute(val);
3419 self._bitfield_1.set(12usize, 1u8, val as u64)
3423 pub fn new_bitfield_1(
3425 reference_pic_flag: u32,
3426 entropy_coding_mode_flag: u32,
3427 weighted_pred_flag: u32,
3428 weighted_bipred_idc: u32,
3429 constrained_intra_pred_flag: u32,
3430 transform_8x8_mode_flag: u32,
3431 deblocking_filter_control_present_flag: u32,
3432 redundant_pic_cnt_present_flag: u32,
3433 pic_order_present_flag: u32,
3434 pic_scaling_matrix_present_flag: u32,
3435 ) -> __BindgenBitfieldUnit<[u8; 2usize]> {
3436 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default();
3437 __bindgen_bitfield_unit.set(0usize, 1u8, {
3438 let idr_pic_flag: u32 = unsafe { ::std::mem::transmute(idr_pic_flag) };
3441 __bindgen_bitfield_unit.set(1usize, 2u8, {
3442 let reference_pic_flag: u32 = unsafe { ::std::mem::transmute(reference_pic_flag) };
3443 reference_pic_flag as u64
3445 __bindgen_bitfield_unit.set(3usize, 1u8, {
3446 let entropy_coding_mode_flag: u32 =
3447 unsafe { ::std::mem::transmute(entropy_coding_mode_flag) };
3448 entropy_coding_mode_flag as u64
3450 __bindgen_bitfield_unit.set(4usize, 1u8, {
3451 let weighted_pred_flag: u32 = unsafe { ::std::mem::transmute(weighted_pred_flag) };
3452 weighted_pred_flag as u64
3454 __bindgen_bitfield_unit.set(5usize, 2u8, {
3455 let weighted_bipred_idc: u32 = unsafe { ::std::mem::transmute(weighted_bipred_idc) };
3456 weighted_bipred_idc as u64
3458 __bindgen_bitfield_unit.set(7usize, 1u8, {
3459 let constrained_intra_pred_flag: u32 =
3460 unsafe { ::std::mem::transmute(constrained_intra_pred_flag) };
3461 constrained_intra_pred_flag as u64
3463 __bindgen_bitfield_unit.set(8usize, 1u8, {
3464 let transform_8x8_mode_flag: u32 =
3465 unsafe { ::std::mem::transmute(transform_8x8_mode_flag) };
3466 transform_8x8_mode_flag as u64
3468 __bindgen_bitfield_unit.set(9usize, 1u8, {
3469 let deblocking_filter_control_present_flag: u32 =
3470 unsafe { ::std::mem::transmute(deblocking_filter_control_present_flag) };
3471 deblocking_filter_control_present_flag as u64
3473 __bindgen_bitfield_unit.set(10usize, 1u8, {
3474 let redundant_pic_cnt_present_flag: u32 =
3475 unsafe { ::std::mem::transmute(redundant_pic_cnt_present_flag) };
3476 redundant_pic_cnt_present_flag as u64
3478 __bindgen_bitfield_unit.set(11usize, 1u8, {
3479 let pic_order_present_flag: u32 =
3480 unsafe { ::std::mem::transmute(pic_order_present_flag) };
3481 pic_order_present_flag as u64
3483 __bindgen_bitfield_unit.set(12usize, 1u8, {
3484 let pic_scaling_matrix_present_flag: u32 =
3485 unsafe { ::std::mem::transmute(pic_scaling_matrix_present_flag) };
3486 pic_scaling_matrix_present_flag as u64
3488 __bindgen_bitfield_unit
3491 impl Default for _VAEncPictureParameterBufferH264__bindgen_ty_1 {
3492 fn default() -> Self {
3493 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3495 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3500 impl Default for _VAEncPictureParameterBufferH264 {
3501 fn default() -> Self {
3502 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3504 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3509 pub type VAEncPictureParameterBufferH264 = _VAEncPictureParameterBufferH264;
3511 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
3512 pub struct _VAEncQPBufferH264 {
3515 pub type VAEncQPBufferH264 = _VAEncQPBufferH264;
3517 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
3518 pub struct _VAEncSliceParameterBufferH264 {
3519 pub macroblock_address: u32,
3520 pub num_macroblocks: u32,
3521 pub macroblock_info: VABufferID,
3523 pub pic_parameter_set_id: u8,
3524 pub idr_pic_id: u16,
3525 pub pic_order_cnt_lsb: u16,
3526 pub delta_pic_order_cnt_bottom: i32,
3527 pub delta_pic_order_cnt: [i32; 2usize],
3528 pub direct_spatial_mv_pred_flag: u8,
3529 pub num_ref_idx_active_override_flag: u8,
3530 pub num_ref_idx_l0_active_minus1: u8,
3531 pub num_ref_idx_l1_active_minus1: u8,
3532 pub RefPicList0: [VAPictureH264; 32usize],
3533 pub RefPicList1: [VAPictureH264; 32usize],
3534 pub luma_log2_weight_denom: u8,
3535 pub chroma_log2_weight_denom: u8,
3536 pub luma_weight_l0_flag: u8,
3537 pub luma_weight_l0: [::std::os::raw::c_short; 32usize],
3538 pub luma_offset_l0: [::std::os::raw::c_short; 32usize],
3539 pub chroma_weight_l0_flag: u8,
3540 pub chroma_weight_l0: [[::std::os::raw::c_short; 2usize]; 32usize],
3541 pub chroma_offset_l0: [[::std::os::raw::c_short; 2usize]; 32usize],
3542 pub luma_weight_l1_flag: u8,
3543 pub luma_weight_l1: [::std::os::raw::c_short; 32usize],
3544 pub luma_offset_l1: [::std::os::raw::c_short; 32usize],
3545 pub chroma_weight_l1_flag: u8,
3546 pub chroma_weight_l1: [[::std::os::raw::c_short; 2usize]; 32usize],
3547 pub chroma_offset_l1: [[::std::os::raw::c_short; 2usize]; 32usize],
3548 pub cabac_init_idc: u8,
3549 pub slice_qp_delta: i8,
3550 pub disable_deblocking_filter_idc: u8,
3551 pub slice_alpha_c0_offset_div2: i8,
3552 pub slice_beta_offset_div2: i8,
3553 pub va_reserved: [u32; 4usize],
3555 pub type VAEncSliceParameterBufferH264 = _VAEncSliceParameterBufferH264;
3557 #[derive(Copy, Clone)]
3558 pub struct _VAEncMacroblockParameterBufferH264 {
3560 pub info: _VAEncMacroblockParameterBufferH264__bindgen_ty_1,
3561 pub va_reserved: [u32; 4usize],
3564 #[derive(Copy, Clone)]
3565 pub union _VAEncMacroblockParameterBufferH264__bindgen_ty_1 {
3566 pub intra_fields: _VAEncMacroblockParameterBufferH264__bindgen_ty_1__bindgen_ty_1,
3567 pub inter_fields: _VAEncMacroblockParameterBufferH264__bindgen_ty_1__bindgen_ty_2,
3570 #[derive(Copy, Clone)]
3571 pub union _VAEncMacroblockParameterBufferH264__bindgen_ty_1__bindgen_ty_1 {
3572 pub bits: _VAEncMacroblockParameterBufferH264__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
3577 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
3578 pub struct _VAEncMacroblockParameterBufferH264__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 {
3579 pub _bitfield_align_1: [u8; 0],
3580 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
3581 pub __bindgen_padding_0: u16,
3583 impl _VAEncMacroblockParameterBufferH264__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 {
3585 pub fn pred_avail_override_flag(&self) -> u32 {
3586 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
3589 pub fn set_pred_avail_override_flag(&mut self, val: u32) {
3591 let val: u32 = ::std::mem::transmute(val);
3592 self._bitfield_1.set(0usize, 1u8, val as u64)
3596 pub fn pred_avail_flags(&self) -> u32 {
3597 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 8u8) as u32) }
3600 pub fn set_pred_avail_flags(&mut self, val: u32) {
3602 let val: u32 = ::std::mem::transmute(val);
3603 self._bitfield_1.set(1usize, 8u8, val as u64)
3607 pub fn new_bitfield_1(
3608 pred_avail_override_flag: u32,
3609 pred_avail_flags: u32,
3610 ) -> __BindgenBitfieldUnit<[u8; 2usize]> {
3611 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default();
3612 __bindgen_bitfield_unit.set(0usize, 1u8, {
3613 let pred_avail_override_flag: u32 =
3614 unsafe { ::std::mem::transmute(pred_avail_override_flag) };
3615 pred_avail_override_flag as u64
3617 __bindgen_bitfield_unit.set(1usize, 8u8, {
3618 let pred_avail_flags: u32 = unsafe { ::std::mem::transmute(pred_avail_flags) };
3619 pred_avail_flags as u64
3621 __bindgen_bitfield_unit
3624 impl Default for _VAEncMacroblockParameterBufferH264__bindgen_ty_1__bindgen_ty_1 {
3625 fn default() -> Self {
3626 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3628 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3634 #[derive(Copy, Clone)]
3635 pub union _VAEncMacroblockParameterBufferH264__bindgen_ty_1__bindgen_ty_2 {
3636 pub bits: _VAEncMacroblockParameterBufferH264__bindgen_ty_1__bindgen_ty_2__bindgen_ty_1,
3640 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
3641 pub struct _VAEncMacroblockParameterBufferH264__bindgen_ty_1__bindgen_ty_2__bindgen_ty_1 {
3644 impl Default for _VAEncMacroblockParameterBufferH264__bindgen_ty_1__bindgen_ty_2 {
3645 fn default() -> Self {
3646 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3648 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3653 impl Default for _VAEncMacroblockParameterBufferH264__bindgen_ty_1 {
3654 fn default() -> Self {
3655 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3657 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3662 impl Default for _VAEncMacroblockParameterBufferH264 {
3663 fn default() -> Self {
3664 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3666 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3671 pub type VAEncMacroblockParameterBufferH264 = _VAEncMacroblockParameterBufferH264;
3673 #[derive(Copy, Clone)]
3674 pub struct _VAEncMiscParameterSubMbPartPelH264 {
3675 pub disable_inter_sub_mb_partition: u32,
3676 pub inter_sub_mb_partition_mask: _VAEncMiscParameterSubMbPartPelH264__bindgen_ty_1,
3677 pub enable_sub_pel_mode: u32,
3678 pub sub_pel_mode: u8,
3679 pub reserved: [u8; 3usize],
3682 #[derive(Copy, Clone)]
3683 pub union _VAEncMiscParameterSubMbPartPelH264__bindgen_ty_1 {
3684 pub bits: _VAEncMiscParameterSubMbPartPelH264__bindgen_ty_1__bindgen_ty_1,
3689 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
3690 pub struct _VAEncMiscParameterSubMbPartPelH264__bindgen_ty_1__bindgen_ty_1 {
3691 pub _bitfield_align_1: [u8; 0],
3692 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
3693 pub __bindgen_padding_0: [u8; 3usize],
3695 impl _VAEncMiscParameterSubMbPartPelH264__bindgen_ty_1__bindgen_ty_1 {
3697 pub fn disable_16x16_inter_mb_partition(&self) -> u32 {
3698 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
3701 pub fn set_disable_16x16_inter_mb_partition(&mut self, val: u32) {
3703 let val: u32 = ::std::mem::transmute(val);
3704 self._bitfield_1.set(0usize, 1u8, val as u64)
3708 pub fn disable_16x8_inter_mb_partition(&self) -> u32 {
3709 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
3712 pub fn set_disable_16x8_inter_mb_partition(&mut self, val: u32) {
3714 let val: u32 = ::std::mem::transmute(val);
3715 self._bitfield_1.set(1usize, 1u8, val as u64)
3719 pub fn disable_8x16_inter_mb_partition(&self) -> u32 {
3720 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
3723 pub fn set_disable_8x16_inter_mb_partition(&mut self, val: u32) {
3725 let val: u32 = ::std::mem::transmute(val);
3726 self._bitfield_1.set(2usize, 1u8, val as u64)
3730 pub fn disable_8x8_inter_mb_partition(&self) -> u32 {
3731 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
3734 pub fn set_disable_8x8_inter_mb_partition(&mut self, val: u32) {
3736 let val: u32 = ::std::mem::transmute(val);
3737 self._bitfield_1.set(3usize, 1u8, val as u64)
3741 pub fn disable_8x4_inter_mb_partition(&self) -> u32 {
3742 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
3745 pub fn set_disable_8x4_inter_mb_partition(&mut self, val: u32) {
3747 let val: u32 = ::std::mem::transmute(val);
3748 self._bitfield_1.set(4usize, 1u8, val as u64)
3752 pub fn disable_4x8_inter_mb_partition(&self) -> u32 {
3753 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
3756 pub fn set_disable_4x8_inter_mb_partition(&mut self, val: u32) {
3758 let val: u32 = ::std::mem::transmute(val);
3759 self._bitfield_1.set(5usize, 1u8, val as u64)
3763 pub fn disable_4x4_inter_mb_partition(&self) -> u32 {
3764 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) }
3767 pub fn set_disable_4x4_inter_mb_partition(&mut self, val: u32) {
3769 let val: u32 = ::std::mem::transmute(val);
3770 self._bitfield_1.set(6usize, 1u8, val as u64)
3774 pub fn reserved(&self) -> u32 {
3775 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) }
3778 pub fn set_reserved(&mut self, val: u32) {
3780 let val: u32 = ::std::mem::transmute(val);
3781 self._bitfield_1.set(7usize, 1u8, val as u64)
3785 pub fn new_bitfield_1(
3786 disable_16x16_inter_mb_partition: u32,
3787 disable_16x8_inter_mb_partition: u32,
3788 disable_8x16_inter_mb_partition: u32,
3789 disable_8x8_inter_mb_partition: u32,
3790 disable_8x4_inter_mb_partition: u32,
3791 disable_4x8_inter_mb_partition: u32,
3792 disable_4x4_inter_mb_partition: u32,
3794 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
3795 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
3796 __bindgen_bitfield_unit.set(0usize, 1u8, {
3797 let disable_16x16_inter_mb_partition: u32 =
3798 unsafe { ::std::mem::transmute(disable_16x16_inter_mb_partition) };
3799 disable_16x16_inter_mb_partition as u64
3801 __bindgen_bitfield_unit.set(1usize, 1u8, {
3802 let disable_16x8_inter_mb_partition: u32 =
3803 unsafe { ::std::mem::transmute(disable_16x8_inter_mb_partition) };
3804 disable_16x8_inter_mb_partition as u64
3806 __bindgen_bitfield_unit.set(2usize, 1u8, {
3807 let disable_8x16_inter_mb_partition: u32 =
3808 unsafe { ::std::mem::transmute(disable_8x16_inter_mb_partition) };
3809 disable_8x16_inter_mb_partition as u64
3811 __bindgen_bitfield_unit.set(3usize, 1u8, {
3812 let disable_8x8_inter_mb_partition: u32 =
3813 unsafe { ::std::mem::transmute(disable_8x8_inter_mb_partition) };
3814 disable_8x8_inter_mb_partition as u64
3816 __bindgen_bitfield_unit.set(4usize, 1u8, {
3817 let disable_8x4_inter_mb_partition: u32 =
3818 unsafe { ::std::mem::transmute(disable_8x4_inter_mb_partition) };
3819 disable_8x4_inter_mb_partition as u64
3821 __bindgen_bitfield_unit.set(5usize, 1u8, {
3822 let disable_4x8_inter_mb_partition: u32 =
3823 unsafe { ::std::mem::transmute(disable_4x8_inter_mb_partition) };
3824 disable_4x8_inter_mb_partition as u64
3826 __bindgen_bitfield_unit.set(6usize, 1u8, {
3827 let disable_4x4_inter_mb_partition: u32 =
3828 unsafe { ::std::mem::transmute(disable_4x4_inter_mb_partition) };
3829 disable_4x4_inter_mb_partition as u64
3831 __bindgen_bitfield_unit.set(7usize, 1u8, {
3832 let reserved: u32 = unsafe { ::std::mem::transmute(reserved) };
3835 __bindgen_bitfield_unit
3838 impl Default for _VAEncMiscParameterSubMbPartPelH264__bindgen_ty_1 {
3839 fn default() -> Self {
3840 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3842 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3847 impl Default for _VAEncMiscParameterSubMbPartPelH264 {
3848 fn default() -> Self {
3849 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3851 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3856 pub type VAEncMiscParameterSubMbPartPelH264 = _VAEncMiscParameterSubMbPartPelH264;
3857 pub type VAQMatrixBufferMPEG2 = VAIQMatrixBufferMPEG2;
3858 pub mod VAEncPackedHeaderTypeMPEG2 {
3859 pub type Type = ::std::os::raw::c_uint;
3860 pub const VAEncPackedHeaderMPEG2_SPS: Type = 1;
3861 pub const VAEncPackedHeaderMPEG2_PPS: Type = 2;
3862 pub const VAEncPackedHeaderMPEG2_Slice: Type = 3;
3865 #[derive(Copy, Clone)]
3866 pub struct _VAEncSequenceParameterBufferMPEG2 {
3867 pub intra_period: u32,
3869 pub picture_width: u16,
3870 pub picture_height: u16,
3871 pub bits_per_second: u32,
3872 pub frame_rate: f32,
3873 pub aspect_ratio_information: u16,
3874 pub vbv_buffer_size: u32,
3875 pub sequence_extension: _VAEncSequenceParameterBufferMPEG2__bindgen_ty_1,
3876 pub new_gop_header: u32,
3877 pub gop_header: _VAEncSequenceParameterBufferMPEG2__bindgen_ty_2,
3878 pub va_reserved: [u32; 4usize],
3881 #[derive(Copy, Clone)]
3882 pub union _VAEncSequenceParameterBufferMPEG2__bindgen_ty_1 {
3883 pub bits: _VAEncSequenceParameterBufferMPEG2__bindgen_ty_1__bindgen_ty_1,
3888 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
3889 pub struct _VAEncSequenceParameterBufferMPEG2__bindgen_ty_1__bindgen_ty_1 {
3890 pub _bitfield_align_1: [u8; 0],
3891 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 3usize]>,
3892 pub __bindgen_padding_0: u8,
3894 impl _VAEncSequenceParameterBufferMPEG2__bindgen_ty_1__bindgen_ty_1 {
3896 pub fn profile_and_level_indication(&self) -> u32 {
3897 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 8u8) as u32) }
3900 pub fn set_profile_and_level_indication(&mut self, val: u32) {
3902 let val: u32 = ::std::mem::transmute(val);
3903 self._bitfield_1.set(0usize, 8u8, val as u64)
3907 pub fn progressive_sequence(&self) -> u32 {
3908 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) }
3911 pub fn set_progressive_sequence(&mut self, val: u32) {
3913 let val: u32 = ::std::mem::transmute(val);
3914 self._bitfield_1.set(8usize, 1u8, val as u64)
3918 pub fn chroma_format(&self) -> u32 {
3919 unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 2u8) as u32) }
3922 pub fn set_chroma_format(&mut self, val: u32) {
3924 let val: u32 = ::std::mem::transmute(val);
3925 self._bitfield_1.set(9usize, 2u8, val as u64)
3929 pub fn low_delay(&self) -> u32 {
3930 unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) }
3933 pub fn set_low_delay(&mut self, val: u32) {
3935 let val: u32 = ::std::mem::transmute(val);
3936 self._bitfield_1.set(11usize, 1u8, val as u64)
3940 pub fn frame_rate_extension_n(&self) -> u32 {
3941 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 2u8) as u32) }
3944 pub fn set_frame_rate_extension_n(&mut self, val: u32) {
3946 let val: u32 = ::std::mem::transmute(val);
3947 self._bitfield_1.set(12usize, 2u8, val as u64)
3951 pub fn frame_rate_extension_d(&self) -> u32 {
3952 unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 5u8) as u32) }
3955 pub fn set_frame_rate_extension_d(&mut self, val: u32) {
3957 let val: u32 = ::std::mem::transmute(val);
3958 self._bitfield_1.set(14usize, 5u8, val as u64)
3962 pub fn new_bitfield_1(
3963 profile_and_level_indication: u32,
3964 progressive_sequence: u32,
3967 frame_rate_extension_n: u32,
3968 frame_rate_extension_d: u32,
3969 ) -> __BindgenBitfieldUnit<[u8; 3usize]> {
3970 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 3usize]> = Default::default();
3971 __bindgen_bitfield_unit.set(0usize, 8u8, {
3972 let profile_and_level_indication: u32 =
3973 unsafe { ::std::mem::transmute(profile_and_level_indication) };
3974 profile_and_level_indication as u64
3976 __bindgen_bitfield_unit.set(8usize, 1u8, {
3977 let progressive_sequence: u32 = unsafe { ::std::mem::transmute(progressive_sequence) };
3978 progressive_sequence as u64
3980 __bindgen_bitfield_unit.set(9usize, 2u8, {
3981 let chroma_format: u32 = unsafe { ::std::mem::transmute(chroma_format) };
3982 chroma_format as u64
3984 __bindgen_bitfield_unit.set(11usize, 1u8, {
3985 let low_delay: u32 = unsafe { ::std::mem::transmute(low_delay) };
3988 __bindgen_bitfield_unit.set(12usize, 2u8, {
3989 let frame_rate_extension_n: u32 =
3990 unsafe { ::std::mem::transmute(frame_rate_extension_n) };
3991 frame_rate_extension_n as u64
3993 __bindgen_bitfield_unit.set(14usize, 5u8, {
3994 let frame_rate_extension_d: u32 =
3995 unsafe { ::std::mem::transmute(frame_rate_extension_d) };
3996 frame_rate_extension_d as u64
3998 __bindgen_bitfield_unit
4001 impl Default for _VAEncSequenceParameterBufferMPEG2__bindgen_ty_1 {
4002 fn default() -> Self {
4003 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4005 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4011 #[derive(Copy, Clone)]
4012 pub union _VAEncSequenceParameterBufferMPEG2__bindgen_ty_2 {
4013 pub bits: _VAEncSequenceParameterBufferMPEG2__bindgen_ty_2__bindgen_ty_1,
4018 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
4019 pub struct _VAEncSequenceParameterBufferMPEG2__bindgen_ty_2__bindgen_ty_1 {
4020 pub _bitfield_align_1: [u32; 0],
4021 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
4023 impl _VAEncSequenceParameterBufferMPEG2__bindgen_ty_2__bindgen_ty_1 {
4025 pub fn time_code(&self) -> u32 {
4026 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 25u8) as u32) }
4029 pub fn set_time_code(&mut self, val: u32) {
4031 let val: u32 = ::std::mem::transmute(val);
4032 self._bitfield_1.set(0usize, 25u8, val as u64)
4036 pub fn closed_gop(&self) -> u32 {
4037 unsafe { ::std::mem::transmute(self._bitfield_1.get(25usize, 1u8) as u32) }
4040 pub fn set_closed_gop(&mut self, val: u32) {
4042 let val: u32 = ::std::mem::transmute(val);
4043 self._bitfield_1.set(25usize, 1u8, val as u64)
4047 pub fn broken_link(&self) -> u32 {
4048 unsafe { ::std::mem::transmute(self._bitfield_1.get(26usize, 1u8) as u32) }
4051 pub fn set_broken_link(&mut self, val: u32) {
4053 let val: u32 = ::std::mem::transmute(val);
4054 self._bitfield_1.set(26usize, 1u8, val as u64)
4058 pub fn new_bitfield_1(
4062 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
4063 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
4064 __bindgen_bitfield_unit.set(0usize, 25u8, {
4065 let time_code: u32 = unsafe { ::std::mem::transmute(time_code) };
4068 __bindgen_bitfield_unit.set(25usize, 1u8, {
4069 let closed_gop: u32 = unsafe { ::std::mem::transmute(closed_gop) };
4072 __bindgen_bitfield_unit.set(26usize, 1u8, {
4073 let broken_link: u32 = unsafe { ::std::mem::transmute(broken_link) };
4076 __bindgen_bitfield_unit
4079 impl Default for _VAEncSequenceParameterBufferMPEG2__bindgen_ty_2 {
4080 fn default() -> Self {
4081 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4083 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4088 impl Default for _VAEncSequenceParameterBufferMPEG2 {
4089 fn default() -> Self {
4090 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4092 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4097 pub type VAEncSequenceParameterBufferMPEG2 = _VAEncSequenceParameterBufferMPEG2;
4099 #[derive(Copy, Clone)]
4100 pub struct _VAEncPictureParameterBufferMPEG2 {
4101 pub forward_reference_picture: VASurfaceID,
4102 pub backward_reference_picture: VASurfaceID,
4103 pub reconstructed_picture: VASurfaceID,
4104 pub coded_buf: VABufferID,
4105 pub last_picture: u8,
4106 pub picture_type: VAEncPictureType::Type,
4107 pub temporal_reference: u32,
4109 pub f_code: [[u8; 2usize]; 2usize],
4110 pub picture_coding_extension: _VAEncPictureParameterBufferMPEG2__bindgen_ty_1,
4111 pub composite_display: _VAEncPictureParameterBufferMPEG2__bindgen_ty_2,
4112 pub va_reserved: [u32; 4usize],
4115 #[derive(Copy, Clone)]
4116 pub union _VAEncPictureParameterBufferMPEG2__bindgen_ty_1 {
4117 pub bits: _VAEncPictureParameterBufferMPEG2__bindgen_ty_1__bindgen_ty_1,
4122 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
4123 pub struct _VAEncPictureParameterBufferMPEG2__bindgen_ty_1__bindgen_ty_1 {
4124 pub _bitfield_align_1: [u8; 0],
4125 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
4126 pub __bindgen_padding_0: u16,
4128 impl _VAEncPictureParameterBufferMPEG2__bindgen_ty_1__bindgen_ty_1 {
4130 pub fn intra_dc_precision(&self) -> u32 {
4131 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u32) }
4134 pub fn set_intra_dc_precision(&mut self, val: u32) {
4136 let val: u32 = ::std::mem::transmute(val);
4137 self._bitfield_1.set(0usize, 2u8, val as u64)
4141 pub fn picture_structure(&self) -> u32 {
4142 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 2u8) as u32) }
4145 pub fn set_picture_structure(&mut self, val: u32) {
4147 let val: u32 = ::std::mem::transmute(val);
4148 self._bitfield_1.set(2usize, 2u8, val as u64)
4152 pub fn top_field_first(&self) -> u32 {
4153 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
4156 pub fn set_top_field_first(&mut self, val: u32) {
4158 let val: u32 = ::std::mem::transmute(val);
4159 self._bitfield_1.set(4usize, 1u8, val as u64)
4163 pub fn frame_pred_frame_dct(&self) -> u32 {
4164 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
4167 pub fn set_frame_pred_frame_dct(&mut self, val: u32) {
4169 let val: u32 = ::std::mem::transmute(val);
4170 self._bitfield_1.set(5usize, 1u8, val as u64)
4174 pub fn concealment_motion_vectors(&self) -> u32 {
4175 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) }
4178 pub fn set_concealment_motion_vectors(&mut self, val: u32) {
4180 let val: u32 = ::std::mem::transmute(val);
4181 self._bitfield_1.set(6usize, 1u8, val as u64)
4185 pub fn q_scale_type(&self) -> u32 {
4186 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) }
4189 pub fn set_q_scale_type(&mut self, val: u32) {
4191 let val: u32 = ::std::mem::transmute(val);
4192 self._bitfield_1.set(7usize, 1u8, val as u64)
4196 pub fn intra_vlc_format(&self) -> u32 {
4197 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) }
4200 pub fn set_intra_vlc_format(&mut self, val: u32) {
4202 let val: u32 = ::std::mem::transmute(val);
4203 self._bitfield_1.set(8usize, 1u8, val as u64)
4207 pub fn alternate_scan(&self) -> u32 {
4208 unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) }
4211 pub fn set_alternate_scan(&mut self, val: u32) {
4213 let val: u32 = ::std::mem::transmute(val);
4214 self._bitfield_1.set(9usize, 1u8, val as u64)
4218 pub fn repeat_first_field(&self) -> u32 {
4219 unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) }
4222 pub fn set_repeat_first_field(&mut self, val: u32) {
4224 let val: u32 = ::std::mem::transmute(val);
4225 self._bitfield_1.set(10usize, 1u8, val as u64)
4229 pub fn progressive_frame(&self) -> u32 {
4230 unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) }
4233 pub fn set_progressive_frame(&mut self, val: u32) {
4235 let val: u32 = ::std::mem::transmute(val);
4236 self._bitfield_1.set(11usize, 1u8, val as u64)
4240 pub fn composite_display_flag(&self) -> u32 {
4241 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u32) }
4244 pub fn set_composite_display_flag(&mut self, val: u32) {
4246 let val: u32 = ::std::mem::transmute(val);
4247 self._bitfield_1.set(12usize, 1u8, val as u64)
4251 pub fn new_bitfield_1(
4252 intra_dc_precision: u32,
4253 picture_structure: u32,
4254 top_field_first: u32,
4255 frame_pred_frame_dct: u32,
4256 concealment_motion_vectors: u32,
4258 intra_vlc_format: u32,
4259 alternate_scan: u32,
4260 repeat_first_field: u32,
4261 progressive_frame: u32,
4262 composite_display_flag: u32,
4263 ) -> __BindgenBitfieldUnit<[u8; 2usize]> {
4264 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default();
4265 __bindgen_bitfield_unit.set(0usize, 2u8, {
4266 let intra_dc_precision: u32 = unsafe { ::std::mem::transmute(intra_dc_precision) };
4267 intra_dc_precision as u64
4269 __bindgen_bitfield_unit.set(2usize, 2u8, {
4270 let picture_structure: u32 = unsafe { ::std::mem::transmute(picture_structure) };
4271 picture_structure as u64
4273 __bindgen_bitfield_unit.set(4usize, 1u8, {
4274 let top_field_first: u32 = unsafe { ::std::mem::transmute(top_field_first) };
4275 top_field_first as u64
4277 __bindgen_bitfield_unit.set(5usize, 1u8, {
4278 let frame_pred_frame_dct: u32 = unsafe { ::std::mem::transmute(frame_pred_frame_dct) };
4279 frame_pred_frame_dct as u64
4281 __bindgen_bitfield_unit.set(6usize, 1u8, {
4282 let concealment_motion_vectors: u32 =
4283 unsafe { ::std::mem::transmute(concealment_motion_vectors) };
4284 concealment_motion_vectors as u64
4286 __bindgen_bitfield_unit.set(7usize, 1u8, {
4287 let q_scale_type: u32 = unsafe { ::std::mem::transmute(q_scale_type) };
4290 __bindgen_bitfield_unit.set(8usize, 1u8, {
4291 let intra_vlc_format: u32 = unsafe { ::std::mem::transmute(intra_vlc_format) };
4292 intra_vlc_format as u64
4294 __bindgen_bitfield_unit.set(9usize, 1u8, {
4295 let alternate_scan: u32 = unsafe { ::std::mem::transmute(alternate_scan) };
4296 alternate_scan as u64
4298 __bindgen_bitfield_unit.set(10usize, 1u8, {
4299 let repeat_first_field: u32 = unsafe { ::std::mem::transmute(repeat_first_field) };
4300 repeat_first_field as u64
4302 __bindgen_bitfield_unit.set(11usize, 1u8, {
4303 let progressive_frame: u32 = unsafe { ::std::mem::transmute(progressive_frame) };
4304 progressive_frame as u64
4306 __bindgen_bitfield_unit.set(12usize, 1u8, {
4307 let composite_display_flag: u32 =
4308 unsafe { ::std::mem::transmute(composite_display_flag) };
4309 composite_display_flag as u64
4311 __bindgen_bitfield_unit
4314 impl Default for _VAEncPictureParameterBufferMPEG2__bindgen_ty_1 {
4315 fn default() -> Self {
4316 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4318 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4324 #[derive(Copy, Clone)]
4325 pub union _VAEncPictureParameterBufferMPEG2__bindgen_ty_2 {
4326 pub bits: _VAEncPictureParameterBufferMPEG2__bindgen_ty_2__bindgen_ty_1,
4331 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
4332 pub struct _VAEncPictureParameterBufferMPEG2__bindgen_ty_2__bindgen_ty_1 {
4333 pub _bitfield_align_1: [u8; 0],
4334 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 3usize]>,
4335 pub __bindgen_padding_0: u8,
4337 impl _VAEncPictureParameterBufferMPEG2__bindgen_ty_2__bindgen_ty_1 {
4339 pub fn v_axis(&self) -> u32 {
4340 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
4343 pub fn set_v_axis(&mut self, val: u32) {
4345 let val: u32 = ::std::mem::transmute(val);
4346 self._bitfield_1.set(0usize, 1u8, val as u64)
4350 pub fn field_sequence(&self) -> u32 {
4351 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 3u8) as u32) }
4354 pub fn set_field_sequence(&mut self, val: u32) {
4356 let val: u32 = ::std::mem::transmute(val);
4357 self._bitfield_1.set(1usize, 3u8, val as u64)
4361 pub fn sub_carrier(&self) -> u32 {
4362 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
4365 pub fn set_sub_carrier(&mut self, val: u32) {
4367 let val: u32 = ::std::mem::transmute(val);
4368 self._bitfield_1.set(4usize, 1u8, val as u64)
4372 pub fn burst_amplitude(&self) -> u32 {
4373 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 7u8) as u32) }
4376 pub fn set_burst_amplitude(&mut self, val: u32) {
4378 let val: u32 = ::std::mem::transmute(val);
4379 self._bitfield_1.set(5usize, 7u8, val as u64)
4383 pub fn sub_carrier_phase(&self) -> u32 {
4384 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 8u8) as u32) }
4387 pub fn set_sub_carrier_phase(&mut self, val: u32) {
4389 let val: u32 = ::std::mem::transmute(val);
4390 self._bitfield_1.set(12usize, 8u8, val as u64)
4394 pub fn new_bitfield_1(
4396 field_sequence: u32,
4398 burst_amplitude: u32,
4399 sub_carrier_phase: u32,
4400 ) -> __BindgenBitfieldUnit<[u8; 3usize]> {
4401 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 3usize]> = Default::default();
4402 __bindgen_bitfield_unit.set(0usize, 1u8, {
4403 let v_axis: u32 = unsafe { ::std::mem::transmute(v_axis) };
4406 __bindgen_bitfield_unit.set(1usize, 3u8, {
4407 let field_sequence: u32 = unsafe { ::std::mem::transmute(field_sequence) };
4408 field_sequence as u64
4410 __bindgen_bitfield_unit.set(4usize, 1u8, {
4411 let sub_carrier: u32 = unsafe { ::std::mem::transmute(sub_carrier) };
4414 __bindgen_bitfield_unit.set(5usize, 7u8, {
4415 let burst_amplitude: u32 = unsafe { ::std::mem::transmute(burst_amplitude) };
4416 burst_amplitude as u64
4418 __bindgen_bitfield_unit.set(12usize, 8u8, {
4419 let sub_carrier_phase: u32 = unsafe { ::std::mem::transmute(sub_carrier_phase) };
4420 sub_carrier_phase as u64
4422 __bindgen_bitfield_unit
4425 impl Default for _VAEncPictureParameterBufferMPEG2__bindgen_ty_2 {
4426 fn default() -> Self {
4427 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4429 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4434 impl Default for _VAEncPictureParameterBufferMPEG2 {
4435 fn default() -> Self {
4436 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4438 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4443 pub type VAEncPictureParameterBufferMPEG2 = _VAEncPictureParameterBufferMPEG2;
4445 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
4446 pub struct _VAEncSliceParameterBufferMPEG2 {
4447 pub macroblock_address: u32,
4448 pub num_macroblocks: u32,
4449 pub quantiser_scale_code: i32,
4450 pub is_intra_slice: i32,
4451 pub va_reserved: [u32; 4usize],
4453 pub type VAEncSliceParameterBufferMPEG2 = _VAEncSliceParameterBufferMPEG2;
4455 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
4456 pub struct _VAEncMiscParameterExtensionDataSeqDisplayMPEG2 {
4457 pub extension_start_code_identifier: u8,
4458 pub video_format: u8,
4459 pub colour_description: u8,
4460 pub colour_primaries: u8,
4461 pub transfer_characteristics: u8,
4462 pub matrix_coefficients: u8,
4463 pub display_horizontal_size: u16,
4464 pub display_vertical_size: u16,
4466 pub type VAEncMiscParameterExtensionDataSeqDisplayMPEG2 =
4467 _VAEncMiscParameterExtensionDataSeqDisplayMPEG2;
4469 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
4470 pub struct _VAEncSequenceParameterBufferVP8 {
4471 pub frame_width: u32,
4472 pub frame_height: u32,
4473 pub frame_width_scale: u32,
4474 pub frame_height_scale: u32,
4475 pub error_resilient: u32,
4477 pub kf_min_dist: u32,
4478 pub kf_max_dist: u32,
4479 pub bits_per_second: u32,
4480 pub intra_period: u32,
4481 pub reference_frames: [VASurfaceID; 4usize],
4482 pub va_reserved: [u32; 4usize],
4484 pub type VAEncSequenceParameterBufferVP8 = _VAEncSequenceParameterBufferVP8;
4486 #[derive(Copy, Clone)]
4487 pub struct _VAEncPictureParameterBufferVP8 {
4488 pub reconstructed_frame: VASurfaceID,
4489 pub ref_last_frame: VASurfaceID,
4490 pub ref_gf_frame: VASurfaceID,
4491 pub ref_arf_frame: VASurfaceID,
4492 pub coded_buf: VABufferID,
4493 pub ref_flags: _VAEncPictureParameterBufferVP8__bindgen_ty_1,
4494 pub pic_flags: _VAEncPictureParameterBufferVP8__bindgen_ty_2,
4495 pub loop_filter_level: [i8; 4usize],
4496 pub ref_lf_delta: [i8; 4usize],
4497 pub mode_lf_delta: [i8; 4usize],
4498 pub sharpness_level: u8,
4499 pub clamp_qindex_high: u8,
4500 pub clamp_qindex_low: u8,
4501 pub va_reserved: [u32; 4usize],
4504 #[derive(Copy, Clone)]
4505 pub union _VAEncPictureParameterBufferVP8__bindgen_ty_1 {
4506 pub bits: _VAEncPictureParameterBufferVP8__bindgen_ty_1__bindgen_ty_1,
4511 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
4512 pub struct _VAEncPictureParameterBufferVP8__bindgen_ty_1__bindgen_ty_1 {
4513 pub _bitfield_align_1: [u16; 0],
4514 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
4516 impl _VAEncPictureParameterBufferVP8__bindgen_ty_1__bindgen_ty_1 {
4518 pub fn force_kf(&self) -> u32 {
4519 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
4522 pub fn set_force_kf(&mut self, val: u32) {
4524 let val: u32 = ::std::mem::transmute(val);
4525 self._bitfield_1.set(0usize, 1u8, val as u64)
4529 pub fn no_ref_last(&self) -> u32 {
4530 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
4533 pub fn set_no_ref_last(&mut self, val: u32) {
4535 let val: u32 = ::std::mem::transmute(val);
4536 self._bitfield_1.set(1usize, 1u8, val as u64)
4540 pub fn no_ref_gf(&self) -> u32 {
4541 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
4544 pub fn set_no_ref_gf(&mut self, val: u32) {
4546 let val: u32 = ::std::mem::transmute(val);
4547 self._bitfield_1.set(2usize, 1u8, val as u64)
4551 pub fn no_ref_arf(&self) -> u32 {
4552 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
4555 pub fn set_no_ref_arf(&mut self, val: u32) {
4557 let val: u32 = ::std::mem::transmute(val);
4558 self._bitfield_1.set(3usize, 1u8, val as u64)
4562 pub fn temporal_id(&self) -> u32 {
4563 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 8u8) as u32) }
4566 pub fn set_temporal_id(&mut self, val: u32) {
4568 let val: u32 = ::std::mem::transmute(val);
4569 self._bitfield_1.set(4usize, 8u8, val as u64)
4573 pub fn first_ref(&self) -> u32 {
4574 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 2u8) as u32) }
4577 pub fn set_first_ref(&mut self, val: u32) {
4579 let val: u32 = ::std::mem::transmute(val);
4580 self._bitfield_1.set(12usize, 2u8, val as u64)
4584 pub fn second_ref(&self) -> u32 {
4585 unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 2u8) as u32) }
4588 pub fn set_second_ref(&mut self, val: u32) {
4590 let val: u32 = ::std::mem::transmute(val);
4591 self._bitfield_1.set(14usize, 2u8, val as u64)
4595 pub fn reserved(&self) -> u32 {
4596 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 16u8) as u32) }
4599 pub fn set_reserved(&mut self, val: u32) {
4601 let val: u32 = ::std::mem::transmute(val);
4602 self._bitfield_1.set(16usize, 16u8, val as u64)
4606 pub fn new_bitfield_1(
4615 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
4616 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
4617 __bindgen_bitfield_unit.set(0usize, 1u8, {
4618 let force_kf: u32 = unsafe { ::std::mem::transmute(force_kf) };
4621 __bindgen_bitfield_unit.set(1usize, 1u8, {
4622 let no_ref_last: u32 = unsafe { ::std::mem::transmute(no_ref_last) };
4625 __bindgen_bitfield_unit.set(2usize, 1u8, {
4626 let no_ref_gf: u32 = unsafe { ::std::mem::transmute(no_ref_gf) };
4629 __bindgen_bitfield_unit.set(3usize, 1u8, {
4630 let no_ref_arf: u32 = unsafe { ::std::mem::transmute(no_ref_arf) };
4633 __bindgen_bitfield_unit.set(4usize, 8u8, {
4634 let temporal_id: u32 = unsafe { ::std::mem::transmute(temporal_id) };
4637 __bindgen_bitfield_unit.set(12usize, 2u8, {
4638 let first_ref: u32 = unsafe { ::std::mem::transmute(first_ref) };
4641 __bindgen_bitfield_unit.set(14usize, 2u8, {
4642 let second_ref: u32 = unsafe { ::std::mem::transmute(second_ref) };
4645 __bindgen_bitfield_unit.set(16usize, 16u8, {
4646 let reserved: u32 = unsafe { ::std::mem::transmute(reserved) };
4649 __bindgen_bitfield_unit
4652 impl Default for _VAEncPictureParameterBufferVP8__bindgen_ty_1 {
4653 fn default() -> Self {
4654 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4656 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4662 #[derive(Copy, Clone)]
4663 pub union _VAEncPictureParameterBufferVP8__bindgen_ty_2 {
4664 pub bits: _VAEncPictureParameterBufferVP8__bindgen_ty_2__bindgen_ty_1,
4669 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
4670 pub struct _VAEncPictureParameterBufferVP8__bindgen_ty_2__bindgen_ty_1 {
4671 pub _bitfield_align_1: [u8; 0],
4672 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
4674 impl _VAEncPictureParameterBufferVP8__bindgen_ty_2__bindgen_ty_1 {
4676 pub fn frame_type(&self) -> u32 {
4677 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
4680 pub fn set_frame_type(&mut self, val: u32) {
4682 let val: u32 = ::std::mem::transmute(val);
4683 self._bitfield_1.set(0usize, 1u8, val as u64)
4687 pub fn version(&self) -> u32 {
4688 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 3u8) as u32) }
4691 pub fn set_version(&mut self, val: u32) {
4693 let val: u32 = ::std::mem::transmute(val);
4694 self._bitfield_1.set(1usize, 3u8, val as u64)
4698 pub fn show_frame(&self) -> u32 {
4699 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
4702 pub fn set_show_frame(&mut self, val: u32) {
4704 let val: u32 = ::std::mem::transmute(val);
4705 self._bitfield_1.set(4usize, 1u8, val as u64)
4709 pub fn color_space(&self) -> u32 {
4710 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
4713 pub fn set_color_space(&mut self, val: u32) {
4715 let val: u32 = ::std::mem::transmute(val);
4716 self._bitfield_1.set(5usize, 1u8, val as u64)
4720 pub fn recon_filter_type(&self) -> u32 {
4721 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 2u8) as u32) }
4724 pub fn set_recon_filter_type(&mut self, val: u32) {
4726 let val: u32 = ::std::mem::transmute(val);
4727 self._bitfield_1.set(6usize, 2u8, val as u64)
4731 pub fn loop_filter_type(&self) -> u32 {
4732 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 2u8) as u32) }
4735 pub fn set_loop_filter_type(&mut self, val: u32) {
4737 let val: u32 = ::std::mem::transmute(val);
4738 self._bitfield_1.set(8usize, 2u8, val as u64)
4742 pub fn auto_partitions(&self) -> u32 {
4743 unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) }
4746 pub fn set_auto_partitions(&mut self, val: u32) {
4748 let val: u32 = ::std::mem::transmute(val);
4749 self._bitfield_1.set(10usize, 1u8, val as u64)
4753 pub fn num_token_partitions(&self) -> u32 {
4754 unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 2u8) as u32) }
4757 pub fn set_num_token_partitions(&mut self, val: u32) {
4759 let val: u32 = ::std::mem::transmute(val);
4760 self._bitfield_1.set(11usize, 2u8, val as u64)
4764 pub fn clamping_type(&self) -> u32 {
4765 unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) }
4768 pub fn set_clamping_type(&mut self, val: u32) {
4770 let val: u32 = ::std::mem::transmute(val);
4771 self._bitfield_1.set(13usize, 1u8, val as u64)
4775 pub fn segmentation_enabled(&self) -> u32 {
4776 unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) }
4779 pub fn set_segmentation_enabled(&mut self, val: u32) {
4781 let val: u32 = ::std::mem::transmute(val);
4782 self._bitfield_1.set(14usize, 1u8, val as u64)
4786 pub fn update_mb_segmentation_map(&self) -> u32 {
4787 unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u32) }
4790 pub fn set_update_mb_segmentation_map(&mut self, val: u32) {
4792 let val: u32 = ::std::mem::transmute(val);
4793 self._bitfield_1.set(15usize, 1u8, val as u64)
4797 pub fn update_segment_feature_data(&self) -> u32 {
4798 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u32) }
4801 pub fn set_update_segment_feature_data(&mut self, val: u32) {
4803 let val: u32 = ::std::mem::transmute(val);
4804 self._bitfield_1.set(16usize, 1u8, val as u64)
4808 pub fn loop_filter_adj_enable(&self) -> u32 {
4809 unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 1u8) as u32) }
4812 pub fn set_loop_filter_adj_enable(&mut self, val: u32) {
4814 let val: u32 = ::std::mem::transmute(val);
4815 self._bitfield_1.set(17usize, 1u8, val as u64)
4819 pub fn refresh_entropy_probs(&self) -> u32 {
4820 unsafe { ::std::mem::transmute(self._bitfield_1.get(18usize, 1u8) as u32) }
4823 pub fn set_refresh_entropy_probs(&mut self, val: u32) {
4825 let val: u32 = ::std::mem::transmute(val);
4826 self._bitfield_1.set(18usize, 1u8, val as u64)
4830 pub fn refresh_golden_frame(&self) -> u32 {
4831 unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 1u8) as u32) }
4834 pub fn set_refresh_golden_frame(&mut self, val: u32) {
4836 let val: u32 = ::std::mem::transmute(val);
4837 self._bitfield_1.set(19usize, 1u8, val as u64)
4841 pub fn refresh_alternate_frame(&self) -> u32 {
4842 unsafe { ::std::mem::transmute(self._bitfield_1.get(20usize, 1u8) as u32) }
4845 pub fn set_refresh_alternate_frame(&mut self, val: u32) {
4847 let val: u32 = ::std::mem::transmute(val);
4848 self._bitfield_1.set(20usize, 1u8, val as u64)
4852 pub fn refresh_last(&self) -> u32 {
4853 unsafe { ::std::mem::transmute(self._bitfield_1.get(21usize, 1u8) as u32) }
4856 pub fn set_refresh_last(&mut self, val: u32) {
4858 let val: u32 = ::std::mem::transmute(val);
4859 self._bitfield_1.set(21usize, 1u8, val as u64)
4863 pub fn copy_buffer_to_golden(&self) -> u32 {
4864 unsafe { ::std::mem::transmute(self._bitfield_1.get(22usize, 2u8) as u32) }
4867 pub fn set_copy_buffer_to_golden(&mut self, val: u32) {
4869 let val: u32 = ::std::mem::transmute(val);
4870 self._bitfield_1.set(22usize, 2u8, val as u64)
4874 pub fn copy_buffer_to_alternate(&self) -> u32 {
4875 unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 2u8) as u32) }
4878 pub fn set_copy_buffer_to_alternate(&mut self, val: u32) {
4880 let val: u32 = ::std::mem::transmute(val);
4881 self._bitfield_1.set(24usize, 2u8, val as u64)
4885 pub fn sign_bias_golden(&self) -> u32 {
4886 unsafe { ::std::mem::transmute(self._bitfield_1.get(26usize, 1u8) as u32) }
4889 pub fn set_sign_bias_golden(&mut self, val: u32) {
4891 let val: u32 = ::std::mem::transmute(val);
4892 self._bitfield_1.set(26usize, 1u8, val as u64)
4896 pub fn sign_bias_alternate(&self) -> u32 {
4897 unsafe { ::std::mem::transmute(self._bitfield_1.get(27usize, 1u8) as u32) }
4900 pub fn set_sign_bias_alternate(&mut self, val: u32) {
4902 let val: u32 = ::std::mem::transmute(val);
4903 self._bitfield_1.set(27usize, 1u8, val as u64)
4907 pub fn mb_no_coeff_skip(&self) -> u32 {
4908 unsafe { ::std::mem::transmute(self._bitfield_1.get(28usize, 1u8) as u32) }
4911 pub fn set_mb_no_coeff_skip(&mut self, val: u32) {
4913 let val: u32 = ::std::mem::transmute(val);
4914 self._bitfield_1.set(28usize, 1u8, val as u64)
4918 pub fn forced_lf_adjustment(&self) -> u32 {
4919 unsafe { ::std::mem::transmute(self._bitfield_1.get(29usize, 1u8) as u32) }
4922 pub fn set_forced_lf_adjustment(&mut self, val: u32) {
4924 let val: u32 = ::std::mem::transmute(val);
4925 self._bitfield_1.set(29usize, 1u8, val as u64)
4929 pub fn reserved(&self) -> u32 {
4930 unsafe { ::std::mem::transmute(self._bitfield_1.get(30usize, 2u8) as u32) }
4933 pub fn set_reserved(&mut self, val: u32) {
4935 let val: u32 = ::std::mem::transmute(val);
4936 self._bitfield_1.set(30usize, 2u8, val as u64)
4940 pub fn new_bitfield_1(
4945 recon_filter_type: u32,
4946 loop_filter_type: u32,
4947 auto_partitions: u32,
4948 num_token_partitions: u32,
4950 segmentation_enabled: u32,
4951 update_mb_segmentation_map: u32,
4952 update_segment_feature_data: u32,
4953 loop_filter_adj_enable: u32,
4954 refresh_entropy_probs: u32,
4955 refresh_golden_frame: u32,
4956 refresh_alternate_frame: u32,
4958 copy_buffer_to_golden: u32,
4959 copy_buffer_to_alternate: u32,
4960 sign_bias_golden: u32,
4961 sign_bias_alternate: u32,
4962 mb_no_coeff_skip: u32,
4963 forced_lf_adjustment: u32,
4965 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
4966 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
4967 __bindgen_bitfield_unit.set(0usize, 1u8, {
4968 let frame_type: u32 = unsafe { ::std::mem::transmute(frame_type) };
4971 __bindgen_bitfield_unit.set(1usize, 3u8, {
4972 let version: u32 = unsafe { ::std::mem::transmute(version) };
4975 __bindgen_bitfield_unit.set(4usize, 1u8, {
4976 let show_frame: u32 = unsafe { ::std::mem::transmute(show_frame) };
4979 __bindgen_bitfield_unit.set(5usize, 1u8, {
4980 let color_space: u32 = unsafe { ::std::mem::transmute(color_space) };
4983 __bindgen_bitfield_unit.set(6usize, 2u8, {
4984 let recon_filter_type: u32 = unsafe { ::std::mem::transmute(recon_filter_type) };
4985 recon_filter_type as u64
4987 __bindgen_bitfield_unit.set(8usize, 2u8, {
4988 let loop_filter_type: u32 = unsafe { ::std::mem::transmute(loop_filter_type) };
4989 loop_filter_type as u64
4991 __bindgen_bitfield_unit.set(10usize, 1u8, {
4992 let auto_partitions: u32 = unsafe { ::std::mem::transmute(auto_partitions) };
4993 auto_partitions as u64
4995 __bindgen_bitfield_unit.set(11usize, 2u8, {
4996 let num_token_partitions: u32 = unsafe { ::std::mem::transmute(num_token_partitions) };
4997 num_token_partitions as u64
4999 __bindgen_bitfield_unit.set(13usize, 1u8, {
5000 let clamping_type: u32 = unsafe { ::std::mem::transmute(clamping_type) };
5001 clamping_type as u64
5003 __bindgen_bitfield_unit.set(14usize, 1u8, {
5004 let segmentation_enabled: u32 = unsafe { ::std::mem::transmute(segmentation_enabled) };
5005 segmentation_enabled as u64
5007 __bindgen_bitfield_unit.set(15usize, 1u8, {
5008 let update_mb_segmentation_map: u32 =
5009 unsafe { ::std::mem::transmute(update_mb_segmentation_map) };
5010 update_mb_segmentation_map as u64
5012 __bindgen_bitfield_unit.set(16usize, 1u8, {
5013 let update_segment_feature_data: u32 =
5014 unsafe { ::std::mem::transmute(update_segment_feature_data) };
5015 update_segment_feature_data as u64
5017 __bindgen_bitfield_unit.set(17usize, 1u8, {
5018 let loop_filter_adj_enable: u32 =
5019 unsafe { ::std::mem::transmute(loop_filter_adj_enable) };
5020 loop_filter_adj_enable as u64
5022 __bindgen_bitfield_unit.set(18usize, 1u8, {
5023 let refresh_entropy_probs: u32 =
5024 unsafe { ::std::mem::transmute(refresh_entropy_probs) };
5025 refresh_entropy_probs as u64
5027 __bindgen_bitfield_unit.set(19usize, 1u8, {
5028 let refresh_golden_frame: u32 = unsafe { ::std::mem::transmute(refresh_golden_frame) };
5029 refresh_golden_frame as u64
5031 __bindgen_bitfield_unit.set(20usize, 1u8, {
5032 let refresh_alternate_frame: u32 =
5033 unsafe { ::std::mem::transmute(refresh_alternate_frame) };
5034 refresh_alternate_frame as u64
5036 __bindgen_bitfield_unit.set(21usize, 1u8, {
5037 let refresh_last: u32 = unsafe { ::std::mem::transmute(refresh_last) };
5040 __bindgen_bitfield_unit.set(22usize, 2u8, {
5041 let copy_buffer_to_golden: u32 =
5042 unsafe { ::std::mem::transmute(copy_buffer_to_golden) };
5043 copy_buffer_to_golden as u64
5045 __bindgen_bitfield_unit.set(24usize, 2u8, {
5046 let copy_buffer_to_alternate: u32 =
5047 unsafe { ::std::mem::transmute(copy_buffer_to_alternate) };
5048 copy_buffer_to_alternate as u64
5050 __bindgen_bitfield_unit.set(26usize, 1u8, {
5051 let sign_bias_golden: u32 = unsafe { ::std::mem::transmute(sign_bias_golden) };
5052 sign_bias_golden as u64
5054 __bindgen_bitfield_unit.set(27usize, 1u8, {
5055 let sign_bias_alternate: u32 = unsafe { ::std::mem::transmute(sign_bias_alternate) };
5056 sign_bias_alternate as u64
5058 __bindgen_bitfield_unit.set(28usize, 1u8, {
5059 let mb_no_coeff_skip: u32 = unsafe { ::std::mem::transmute(mb_no_coeff_skip) };
5060 mb_no_coeff_skip as u64
5062 __bindgen_bitfield_unit.set(29usize, 1u8, {
5063 let forced_lf_adjustment: u32 = unsafe { ::std::mem::transmute(forced_lf_adjustment) };
5064 forced_lf_adjustment as u64
5066 __bindgen_bitfield_unit.set(30usize, 2u8, {
5067 let reserved: u32 = unsafe { ::std::mem::transmute(reserved) };
5070 __bindgen_bitfield_unit
5073 impl Default for _VAEncPictureParameterBufferVP8__bindgen_ty_2 {
5074 fn default() -> Self {
5075 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5077 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5082 impl Default for _VAEncPictureParameterBufferVP8 {
5083 fn default() -> Self {
5084 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5086 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5091 pub type VAEncPictureParameterBufferVP8 = _VAEncPictureParameterBufferVP8;
5093 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
5094 pub struct _VAEncMBMapBufferVP8 {
5096 pub mb_segment_id: *mut u8,
5097 pub va_reserved: [u32; 4usize],
5099 impl Default for _VAEncMBMapBufferVP8 {
5100 fn default() -> Self {
5101 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5103 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5108 pub type VAEncMBMapBufferVP8 = _VAEncMBMapBufferVP8;
5110 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
5111 pub struct _VAQMatrixBufferVP8 {
5112 pub quantization_index: [u16; 4usize],
5113 pub quantization_index_delta: [i16; 5usize],
5114 pub va_reserved: [u32; 4usize],
5116 pub type VAQMatrixBufferVP8 = _VAQMatrixBufferVP8;
5118 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
5119 pub struct _VACodedBufferVP9Status {
5120 pub base_qp_index: u16,
5121 pub loop_filter_level: u8,
5122 pub long_term_indication: u8,
5123 pub next_frame_width: u16,
5124 pub next_frame_height: u16,
5125 pub va_reserved: [u32; 4usize],
5127 pub type VACodedBufferVP9Status = _VACodedBufferVP9Status;
5129 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
5130 pub struct _VAEncSequenceParameterBufferVP9 {
5131 pub max_frame_width: u32,
5132 pub max_frame_height: u32,
5134 pub kf_min_dist: u32,
5135 pub kf_max_dist: u32,
5136 pub bits_per_second: u32,
5137 pub intra_period: u32,
5138 pub va_reserved: [u32; 4usize],
5140 pub type VAEncSequenceParameterBufferVP9 = _VAEncSequenceParameterBufferVP9;
5142 #[derive(Copy, Clone)]
5143 pub struct _VAEncPictureParameterBufferVP9 {
5144 pub frame_width_src: u32,
5145 pub frame_height_src: u32,
5146 pub frame_width_dst: u32,
5147 pub frame_height_dst: u32,
5148 pub reconstructed_frame: VASurfaceID,
5149 pub reference_frames: [VASurfaceID; 8usize],
5150 pub coded_buf: VABufferID,
5151 pub ref_flags: _VAEncPictureParameterBufferVP9__bindgen_ty_1,
5152 pub pic_flags: _VAEncPictureParameterBufferVP9__bindgen_ty_2,
5153 pub refresh_frame_flags: u8,
5154 pub luma_ac_qindex: u8,
5155 pub luma_dc_qindex_delta: i8,
5156 pub chroma_ac_qindex_delta: i8,
5157 pub chroma_dc_qindex_delta: i8,
5158 pub filter_level: u8,
5159 pub sharpness_level: u8,
5160 pub ref_lf_delta: [i8; 4usize],
5161 pub mode_lf_delta: [i8; 2usize],
5162 pub bit_offset_ref_lf_delta: u16,
5163 pub bit_offset_mode_lf_delta: u16,
5164 pub bit_offset_lf_level: u16,
5165 pub bit_offset_qindex: u16,
5166 pub bit_offset_first_partition_size: u16,
5167 pub bit_offset_segmentation: u16,
5168 pub bit_size_segmentation: u16,
5169 pub log2_tile_rows: u8,
5170 pub log2_tile_columns: u8,
5171 pub skip_frame_flag: u8,
5172 pub number_skip_frames: u8,
5173 pub skip_frames_size: u32,
5174 pub va_reserved: [u32; 8usize],
5177 #[derive(Copy, Clone)]
5178 pub union _VAEncPictureParameterBufferVP9__bindgen_ty_1 {
5179 pub bits: _VAEncPictureParameterBufferVP9__bindgen_ty_1__bindgen_ty_1,
5184 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
5185 pub struct _VAEncPictureParameterBufferVP9__bindgen_ty_1__bindgen_ty_1 {
5186 pub _bitfield_align_1: [u8; 0],
5187 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
5189 impl _VAEncPictureParameterBufferVP9__bindgen_ty_1__bindgen_ty_1 {
5191 pub fn force_kf(&self) -> u32 {
5192 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
5195 pub fn set_force_kf(&mut self, val: u32) {
5197 let val: u32 = ::std::mem::transmute(val);
5198 self._bitfield_1.set(0usize, 1u8, val as u64)
5202 pub fn ref_frame_ctrl_l0(&self) -> u32 {
5203 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 3u8) as u32) }
5206 pub fn set_ref_frame_ctrl_l0(&mut self, val: u32) {
5208 let val: u32 = ::std::mem::transmute(val);
5209 self._bitfield_1.set(1usize, 3u8, val as u64)
5213 pub fn ref_frame_ctrl_l1(&self) -> u32 {
5214 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 3u8) as u32) }
5217 pub fn set_ref_frame_ctrl_l1(&mut self, val: u32) {
5219 let val: u32 = ::std::mem::transmute(val);
5220 self._bitfield_1.set(4usize, 3u8, val as u64)
5224 pub fn ref_last_idx(&self) -> u32 {
5225 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 3u8) as u32) }
5228 pub fn set_ref_last_idx(&mut self, val: u32) {
5230 let val: u32 = ::std::mem::transmute(val);
5231 self._bitfield_1.set(7usize, 3u8, val as u64)
5235 pub fn ref_last_sign_bias(&self) -> u32 {
5236 unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) }
5239 pub fn set_ref_last_sign_bias(&mut self, val: u32) {
5241 let val: u32 = ::std::mem::transmute(val);
5242 self._bitfield_1.set(10usize, 1u8, val as u64)
5246 pub fn ref_gf_idx(&self) -> u32 {
5247 unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 3u8) as u32) }
5250 pub fn set_ref_gf_idx(&mut self, val: u32) {
5252 let val: u32 = ::std::mem::transmute(val);
5253 self._bitfield_1.set(11usize, 3u8, val as u64)
5257 pub fn ref_gf_sign_bias(&self) -> u32 {
5258 unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) }
5261 pub fn set_ref_gf_sign_bias(&mut self, val: u32) {
5263 let val: u32 = ::std::mem::transmute(val);
5264 self._bitfield_1.set(14usize, 1u8, val as u64)
5268 pub fn ref_arf_idx(&self) -> u32 {
5269 unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 3u8) as u32) }
5272 pub fn set_ref_arf_idx(&mut self, val: u32) {
5274 let val: u32 = ::std::mem::transmute(val);
5275 self._bitfield_1.set(15usize, 3u8, val as u64)
5279 pub fn ref_arf_sign_bias(&self) -> u32 {
5280 unsafe { ::std::mem::transmute(self._bitfield_1.get(18usize, 1u8) as u32) }
5283 pub fn set_ref_arf_sign_bias(&mut self, val: u32) {
5285 let val: u32 = ::std::mem::transmute(val);
5286 self._bitfield_1.set(18usize, 1u8, val as u64)
5290 pub fn temporal_id(&self) -> u32 {
5291 unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 8u8) as u32) }
5294 pub fn set_temporal_id(&mut self, val: u32) {
5296 let val: u32 = ::std::mem::transmute(val);
5297 self._bitfield_1.set(19usize, 8u8, val as u64)
5301 pub fn reserved(&self) -> u32 {
5302 unsafe { ::std::mem::transmute(self._bitfield_1.get(27usize, 5u8) as u32) }
5305 pub fn set_reserved(&mut self, val: u32) {
5307 let val: u32 = ::std::mem::transmute(val);
5308 self._bitfield_1.set(27usize, 5u8, val as u64)
5312 pub fn new_bitfield_1(
5314 ref_frame_ctrl_l0: u32,
5315 ref_frame_ctrl_l1: u32,
5317 ref_last_sign_bias: u32,
5319 ref_gf_sign_bias: u32,
5321 ref_arf_sign_bias: u32,
5324 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
5325 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
5326 __bindgen_bitfield_unit.set(0usize, 1u8, {
5327 let force_kf: u32 = unsafe { ::std::mem::transmute(force_kf) };
5330 __bindgen_bitfield_unit.set(1usize, 3u8, {
5331 let ref_frame_ctrl_l0: u32 = unsafe { ::std::mem::transmute(ref_frame_ctrl_l0) };
5332 ref_frame_ctrl_l0 as u64
5334 __bindgen_bitfield_unit.set(4usize, 3u8, {
5335 let ref_frame_ctrl_l1: u32 = unsafe { ::std::mem::transmute(ref_frame_ctrl_l1) };
5336 ref_frame_ctrl_l1 as u64
5338 __bindgen_bitfield_unit.set(7usize, 3u8, {
5339 let ref_last_idx: u32 = unsafe { ::std::mem::transmute(ref_last_idx) };
5342 __bindgen_bitfield_unit.set(10usize, 1u8, {
5343 let ref_last_sign_bias: u32 = unsafe { ::std::mem::transmute(ref_last_sign_bias) };
5344 ref_last_sign_bias as u64
5346 __bindgen_bitfield_unit.set(11usize, 3u8, {
5347 let ref_gf_idx: u32 = unsafe { ::std::mem::transmute(ref_gf_idx) };
5350 __bindgen_bitfield_unit.set(14usize, 1u8, {
5351 let ref_gf_sign_bias: u32 = unsafe { ::std::mem::transmute(ref_gf_sign_bias) };
5352 ref_gf_sign_bias as u64
5354 __bindgen_bitfield_unit.set(15usize, 3u8, {
5355 let ref_arf_idx: u32 = unsafe { ::std::mem::transmute(ref_arf_idx) };
5358 __bindgen_bitfield_unit.set(18usize, 1u8, {
5359 let ref_arf_sign_bias: u32 = unsafe { ::std::mem::transmute(ref_arf_sign_bias) };
5360 ref_arf_sign_bias as u64
5362 __bindgen_bitfield_unit.set(19usize, 8u8, {
5363 let temporal_id: u32 = unsafe { ::std::mem::transmute(temporal_id) };
5366 __bindgen_bitfield_unit.set(27usize, 5u8, {
5367 let reserved: u32 = unsafe { ::std::mem::transmute(reserved) };
5370 __bindgen_bitfield_unit
5373 impl Default for _VAEncPictureParameterBufferVP9__bindgen_ty_1 {
5374 fn default() -> Self {
5375 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5377 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5383 #[derive(Copy, Clone)]
5384 pub union _VAEncPictureParameterBufferVP9__bindgen_ty_2 {
5385 pub bits: _VAEncPictureParameterBufferVP9__bindgen_ty_2__bindgen_ty_1,
5390 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
5391 pub struct _VAEncPictureParameterBufferVP9__bindgen_ty_2__bindgen_ty_1 {
5392 pub _bitfield_align_1: [u16; 0],
5393 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
5395 impl _VAEncPictureParameterBufferVP9__bindgen_ty_2__bindgen_ty_1 {
5397 pub fn frame_type(&self) -> u32 {
5398 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
5401 pub fn set_frame_type(&mut self, val: u32) {
5403 let val: u32 = ::std::mem::transmute(val);
5404 self._bitfield_1.set(0usize, 1u8, val as u64)
5408 pub fn show_frame(&self) -> u32 {
5409 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
5412 pub fn set_show_frame(&mut self, val: u32) {
5414 let val: u32 = ::std::mem::transmute(val);
5415 self._bitfield_1.set(1usize, 1u8, val as u64)
5419 pub fn error_resilient_mode(&self) -> u32 {
5420 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
5423 pub fn set_error_resilient_mode(&mut self, val: u32) {
5425 let val: u32 = ::std::mem::transmute(val);
5426 self._bitfield_1.set(2usize, 1u8, val as u64)
5430 pub fn intra_only(&self) -> u32 {
5431 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
5434 pub fn set_intra_only(&mut self, val: u32) {
5436 let val: u32 = ::std::mem::transmute(val);
5437 self._bitfield_1.set(3usize, 1u8, val as u64)
5441 pub fn allow_high_precision_mv(&self) -> u32 {
5442 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
5445 pub fn set_allow_high_precision_mv(&mut self, val: u32) {
5447 let val: u32 = ::std::mem::transmute(val);
5448 self._bitfield_1.set(4usize, 1u8, val as u64)
5452 pub fn mcomp_filter_type(&self) -> u32 {
5453 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 3u8) as u32) }
5456 pub fn set_mcomp_filter_type(&mut self, val: u32) {
5458 let val: u32 = ::std::mem::transmute(val);
5459 self._bitfield_1.set(5usize, 3u8, val as u64)
5463 pub fn frame_parallel_decoding_mode(&self) -> u32 {
5464 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) }
5467 pub fn set_frame_parallel_decoding_mode(&mut self, val: u32) {
5469 let val: u32 = ::std::mem::transmute(val);
5470 self._bitfield_1.set(8usize, 1u8, val as u64)
5474 pub fn reset_frame_context(&self) -> u32 {
5475 unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 2u8) as u32) }
5478 pub fn set_reset_frame_context(&mut self, val: u32) {
5480 let val: u32 = ::std::mem::transmute(val);
5481 self._bitfield_1.set(9usize, 2u8, val as u64)
5485 pub fn refresh_frame_context(&self) -> u32 {
5486 unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) }
5489 pub fn set_refresh_frame_context(&mut self, val: u32) {
5491 let val: u32 = ::std::mem::transmute(val);
5492 self._bitfield_1.set(11usize, 1u8, val as u64)
5496 pub fn frame_context_idx(&self) -> u32 {
5497 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 2u8) as u32) }
5500 pub fn set_frame_context_idx(&mut self, val: u32) {
5502 let val: u32 = ::std::mem::transmute(val);
5503 self._bitfield_1.set(12usize, 2u8, val as u64)
5507 pub fn segmentation_enabled(&self) -> u32 {
5508 unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) }
5511 pub fn set_segmentation_enabled(&mut self, val: u32) {
5513 let val: u32 = ::std::mem::transmute(val);
5514 self._bitfield_1.set(14usize, 1u8, val as u64)
5518 pub fn segmentation_temporal_update(&self) -> u32 {
5519 unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u32) }
5522 pub fn set_segmentation_temporal_update(&mut self, val: u32) {
5524 let val: u32 = ::std::mem::transmute(val);
5525 self._bitfield_1.set(15usize, 1u8, val as u64)
5529 pub fn segmentation_update_map(&self) -> u32 {
5530 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u32) }
5533 pub fn set_segmentation_update_map(&mut self, val: u32) {
5535 let val: u32 = ::std::mem::transmute(val);
5536 self._bitfield_1.set(16usize, 1u8, val as u64)
5540 pub fn lossless_mode(&self) -> u32 {
5541 unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 1u8) as u32) }
5544 pub fn set_lossless_mode(&mut self, val: u32) {
5546 let val: u32 = ::std::mem::transmute(val);
5547 self._bitfield_1.set(17usize, 1u8, val as u64)
5551 pub fn comp_prediction_mode(&self) -> u32 {
5552 unsafe { ::std::mem::transmute(self._bitfield_1.get(18usize, 2u8) as u32) }
5555 pub fn set_comp_prediction_mode(&mut self, val: u32) {
5557 let val: u32 = ::std::mem::transmute(val);
5558 self._bitfield_1.set(18usize, 2u8, val as u64)
5562 pub fn auto_segmentation(&self) -> u32 {
5563 unsafe { ::std::mem::transmute(self._bitfield_1.get(20usize, 1u8) as u32) }
5566 pub fn set_auto_segmentation(&mut self, val: u32) {
5568 let val: u32 = ::std::mem::transmute(val);
5569 self._bitfield_1.set(20usize, 1u8, val as u64)
5573 pub fn super_frame_flag(&self) -> u32 {
5574 unsafe { ::std::mem::transmute(self._bitfield_1.get(21usize, 1u8) as u32) }
5577 pub fn set_super_frame_flag(&mut self, val: u32) {
5579 let val: u32 = ::std::mem::transmute(val);
5580 self._bitfield_1.set(21usize, 1u8, val as u64)
5584 pub fn reserved(&self) -> u32 {
5585 unsafe { ::std::mem::transmute(self._bitfield_1.get(22usize, 10u8) as u32) }
5588 pub fn set_reserved(&mut self, val: u32) {
5590 let val: u32 = ::std::mem::transmute(val);
5591 self._bitfield_1.set(22usize, 10u8, val as u64)
5595 pub fn new_bitfield_1(
5598 error_resilient_mode: u32,
5600 allow_high_precision_mv: u32,
5601 mcomp_filter_type: u32,
5602 frame_parallel_decoding_mode: u32,
5603 reset_frame_context: u32,
5604 refresh_frame_context: u32,
5605 frame_context_idx: u32,
5606 segmentation_enabled: u32,
5607 segmentation_temporal_update: u32,
5608 segmentation_update_map: u32,
5610 comp_prediction_mode: u32,
5611 auto_segmentation: u32,
5612 super_frame_flag: u32,
5614 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
5615 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
5616 __bindgen_bitfield_unit.set(0usize, 1u8, {
5617 let frame_type: u32 = unsafe { ::std::mem::transmute(frame_type) };
5620 __bindgen_bitfield_unit.set(1usize, 1u8, {
5621 let show_frame: u32 = unsafe { ::std::mem::transmute(show_frame) };
5624 __bindgen_bitfield_unit.set(2usize, 1u8, {
5625 let error_resilient_mode: u32 = unsafe { ::std::mem::transmute(error_resilient_mode) };
5626 error_resilient_mode as u64
5628 __bindgen_bitfield_unit.set(3usize, 1u8, {
5629 let intra_only: u32 = unsafe { ::std::mem::transmute(intra_only) };
5632 __bindgen_bitfield_unit.set(4usize, 1u8, {
5633 let allow_high_precision_mv: u32 =
5634 unsafe { ::std::mem::transmute(allow_high_precision_mv) };
5635 allow_high_precision_mv as u64
5637 __bindgen_bitfield_unit.set(5usize, 3u8, {
5638 let mcomp_filter_type: u32 = unsafe { ::std::mem::transmute(mcomp_filter_type) };
5639 mcomp_filter_type as u64
5641 __bindgen_bitfield_unit.set(8usize, 1u8, {
5642 let frame_parallel_decoding_mode: u32 =
5643 unsafe { ::std::mem::transmute(frame_parallel_decoding_mode) };
5644 frame_parallel_decoding_mode as u64
5646 __bindgen_bitfield_unit.set(9usize, 2u8, {
5647 let reset_frame_context: u32 = unsafe { ::std::mem::transmute(reset_frame_context) };
5648 reset_frame_context as u64
5650 __bindgen_bitfield_unit.set(11usize, 1u8, {
5651 let refresh_frame_context: u32 =
5652 unsafe { ::std::mem::transmute(refresh_frame_context) };
5653 refresh_frame_context as u64
5655 __bindgen_bitfield_unit.set(12usize, 2u8, {
5656 let frame_context_idx: u32 = unsafe { ::std::mem::transmute(frame_context_idx) };
5657 frame_context_idx as u64
5659 __bindgen_bitfield_unit.set(14usize, 1u8, {
5660 let segmentation_enabled: u32 = unsafe { ::std::mem::transmute(segmentation_enabled) };
5661 segmentation_enabled as u64
5663 __bindgen_bitfield_unit.set(15usize, 1u8, {
5664 let segmentation_temporal_update: u32 =
5665 unsafe { ::std::mem::transmute(segmentation_temporal_update) };
5666 segmentation_temporal_update as u64
5668 __bindgen_bitfield_unit.set(16usize, 1u8, {
5669 let segmentation_update_map: u32 =
5670 unsafe { ::std::mem::transmute(segmentation_update_map) };
5671 segmentation_update_map as u64
5673 __bindgen_bitfield_unit.set(17usize, 1u8, {
5674 let lossless_mode: u32 = unsafe { ::std::mem::transmute(lossless_mode) };
5675 lossless_mode as u64
5677 __bindgen_bitfield_unit.set(18usize, 2u8, {
5678 let comp_prediction_mode: u32 = unsafe { ::std::mem::transmute(comp_prediction_mode) };
5679 comp_prediction_mode as u64
5681 __bindgen_bitfield_unit.set(20usize, 1u8, {
5682 let auto_segmentation: u32 = unsafe { ::std::mem::transmute(auto_segmentation) };
5683 auto_segmentation as u64
5685 __bindgen_bitfield_unit.set(21usize, 1u8, {
5686 let super_frame_flag: u32 = unsafe { ::std::mem::transmute(super_frame_flag) };
5687 super_frame_flag as u64
5689 __bindgen_bitfield_unit.set(22usize, 10u8, {
5690 let reserved: u32 = unsafe { ::std::mem::transmute(reserved) };
5693 __bindgen_bitfield_unit
5696 impl Default for _VAEncPictureParameterBufferVP9__bindgen_ty_2 {
5697 fn default() -> Self {
5698 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5700 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5705 impl Default for _VAEncPictureParameterBufferVP9 {
5706 fn default() -> Self {
5707 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5709 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5714 pub type VAEncPictureParameterBufferVP9 = _VAEncPictureParameterBufferVP9;
5716 #[derive(Copy, Clone)]
5717 pub struct _VAEncSegParamVP9 {
5718 pub seg_flags: _VAEncSegParamVP9__bindgen_ty_1,
5719 pub segment_lf_level_delta: i8,
5720 pub segment_qindex_delta: i16,
5721 pub va_reserved: [u32; 4usize],
5724 #[derive(Copy, Clone)]
5725 pub union _VAEncSegParamVP9__bindgen_ty_1 {
5726 pub bits: _VAEncSegParamVP9__bindgen_ty_1__bindgen_ty_1,
5730 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
5731 pub struct _VAEncSegParamVP9__bindgen_ty_1__bindgen_ty_1 {
5732 pub _bitfield_align_1: [u8; 0],
5733 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
5735 impl _VAEncSegParamVP9__bindgen_ty_1__bindgen_ty_1 {
5737 pub fn segment_reference_enabled(&self) -> u8 {
5738 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
5741 pub fn set_segment_reference_enabled(&mut self, val: u8) {
5743 let val: u8 = ::std::mem::transmute(val);
5744 self._bitfield_1.set(0usize, 1u8, val as u64)
5748 pub fn segment_reference(&self) -> u8 {
5749 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 2u8) as u8) }
5752 pub fn set_segment_reference(&mut self, val: u8) {
5754 let val: u8 = ::std::mem::transmute(val);
5755 self._bitfield_1.set(1usize, 2u8, val as u64)
5759 pub fn segment_reference_skipped(&self) -> u8 {
5760 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8) }
5763 pub fn set_segment_reference_skipped(&mut self, val: u8) {
5765 let val: u8 = ::std::mem::transmute(val);
5766 self._bitfield_1.set(3usize, 1u8, val as u64)
5770 pub fn reserved(&self) -> u8 {
5771 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 4u8) as u8) }
5774 pub fn set_reserved(&mut self, val: u8) {
5776 let val: u8 = ::std::mem::transmute(val);
5777 self._bitfield_1.set(4usize, 4u8, val as u64)
5781 pub fn new_bitfield_1(
5782 segment_reference_enabled: u8,
5783 segment_reference: u8,
5784 segment_reference_skipped: u8,
5786 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
5787 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
5788 __bindgen_bitfield_unit.set(0usize, 1u8, {
5789 let segment_reference_enabled: u8 =
5790 unsafe { ::std::mem::transmute(segment_reference_enabled) };
5791 segment_reference_enabled as u64
5793 __bindgen_bitfield_unit.set(1usize, 2u8, {
5794 let segment_reference: u8 = unsafe { ::std::mem::transmute(segment_reference) };
5795 segment_reference as u64
5797 __bindgen_bitfield_unit.set(3usize, 1u8, {
5798 let segment_reference_skipped: u8 =
5799 unsafe { ::std::mem::transmute(segment_reference_skipped) };
5800 segment_reference_skipped as u64
5802 __bindgen_bitfield_unit.set(4usize, 4u8, {
5803 let reserved: u8 = unsafe { ::std::mem::transmute(reserved) };
5806 __bindgen_bitfield_unit
5809 impl Default for _VAEncSegParamVP9__bindgen_ty_1 {
5810 fn default() -> Self {
5811 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5813 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5818 impl Default for _VAEncSegParamVP9 {
5819 fn default() -> Self {
5820 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5822 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5827 pub type VAEncSegParamVP9 = _VAEncSegParamVP9;
5829 #[derive(Copy, Clone)]
5830 pub struct _VAEncMiscParameterTypeVP9PerSegmantParam {
5831 pub seg_data: [VAEncSegParamVP9; 8usize],
5832 pub va_reserved: [u32; 4usize],
5834 impl Default for _VAEncMiscParameterTypeVP9PerSegmantParam {
5835 fn default() -> Self {
5836 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5838 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5843 pub type VAEncMiscParameterTypeVP9PerSegmantParam = _VAEncMiscParameterTypeVP9PerSegmantParam;
5845 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
5846 pub struct _VAEncMiscParameterFEIFrameControlH264 {
5848 pub mb_ctrl: VABufferID,
5849 pub distortion: VABufferID,
5850 pub mv_data: VABufferID,
5851 pub mb_code_data: VABufferID,
5853 pub mv_predictor: VABufferID,
5854 pub _bitfield_align_1: [u16; 0],
5855 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 16usize]>,
5856 pub max_frame_size: u32,
5857 pub num_passes: u32,
5858 pub delta_qp: *mut u8,
5859 pub reserved3: [u32; 4usize],
5861 impl Default for _VAEncMiscParameterFEIFrameControlH264 {
5862 fn default() -> Self {
5863 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5865 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5870 impl _VAEncMiscParameterFEIFrameControlH264 {
5872 pub fn num_mv_predictors_l0(&self) -> u32 {
5873 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 16u8) as u32) }
5876 pub fn set_num_mv_predictors_l0(&mut self, val: u32) {
5878 let val: u32 = ::std::mem::transmute(val);
5879 self._bitfield_1.set(0usize, 16u8, val as u64)
5883 pub fn num_mv_predictors_l1(&self) -> u32 {
5884 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 16u8) as u32) }
5887 pub fn set_num_mv_predictors_l1(&mut self, val: u32) {
5889 let val: u32 = ::std::mem::transmute(val);
5890 self._bitfield_1.set(16usize, 16u8, val as u64)
5894 pub fn search_path(&self) -> u32 {
5895 unsafe { ::std::mem::transmute(self._bitfield_1.get(32usize, 8u8) as u32) }
5898 pub fn set_search_path(&mut self, val: u32) {
5900 let val: u32 = ::std::mem::transmute(val);
5901 self._bitfield_1.set(32usize, 8u8, val as u64)
5905 pub fn len_sp(&self) -> u32 {
5906 unsafe { ::std::mem::transmute(self._bitfield_1.get(40usize, 8u8) as u32) }
5909 pub fn set_len_sp(&mut self, val: u32) {
5911 let val: u32 = ::std::mem::transmute(val);
5912 self._bitfield_1.set(40usize, 8u8, val as u64)
5916 pub fn reserved0(&self) -> u32 {
5917 unsafe { ::std::mem::transmute(self._bitfield_1.get(48usize, 16u8) as u32) }
5920 pub fn set_reserved0(&mut self, val: u32) {
5922 let val: u32 = ::std::mem::transmute(val);
5923 self._bitfield_1.set(48usize, 16u8, val as u64)
5927 pub fn sub_mb_part_mask(&self) -> u32 {
5928 unsafe { ::std::mem::transmute(self._bitfield_1.get(64usize, 7u8) as u32) }
5931 pub fn set_sub_mb_part_mask(&mut self, val: u32) {
5933 let val: u32 = ::std::mem::transmute(val);
5934 self._bitfield_1.set(64usize, 7u8, val as u64)
5938 pub fn intra_part_mask(&self) -> u32 {
5939 unsafe { ::std::mem::transmute(self._bitfield_1.get(71usize, 5u8) as u32) }
5942 pub fn set_intra_part_mask(&mut self, val: u32) {
5944 let val: u32 = ::std::mem::transmute(val);
5945 self._bitfield_1.set(71usize, 5u8, val as u64)
5949 pub fn multi_pred_l0(&self) -> u32 {
5950 unsafe { ::std::mem::transmute(self._bitfield_1.get(76usize, 1u8) as u32) }
5953 pub fn set_multi_pred_l0(&mut self, val: u32) {
5955 let val: u32 = ::std::mem::transmute(val);
5956 self._bitfield_1.set(76usize, 1u8, val as u64)
5960 pub fn multi_pred_l1(&self) -> u32 {
5961 unsafe { ::std::mem::transmute(self._bitfield_1.get(77usize, 1u8) as u32) }
5964 pub fn set_multi_pred_l1(&mut self, val: u32) {
5966 let val: u32 = ::std::mem::transmute(val);
5967 self._bitfield_1.set(77usize, 1u8, val as u64)
5971 pub fn sub_pel_mode(&self) -> u32 {
5972 unsafe { ::std::mem::transmute(self._bitfield_1.get(78usize, 2u8) as u32) }
5975 pub fn set_sub_pel_mode(&mut self, val: u32) {
5977 let val: u32 = ::std::mem::transmute(val);
5978 self._bitfield_1.set(78usize, 2u8, val as u64)
5982 pub fn inter_sad(&self) -> u32 {
5983 unsafe { ::std::mem::transmute(self._bitfield_1.get(80usize, 2u8) as u32) }
5986 pub fn set_inter_sad(&mut self, val: u32) {
5988 let val: u32 = ::std::mem::transmute(val);
5989 self._bitfield_1.set(80usize, 2u8, val as u64)
5993 pub fn intra_sad(&self) -> u32 {
5994 unsafe { ::std::mem::transmute(self._bitfield_1.get(82usize, 2u8) as u32) }
5997 pub fn set_intra_sad(&mut self, val: u32) {
5999 let val: u32 = ::std::mem::transmute(val);
6000 self._bitfield_1.set(82usize, 2u8, val as u64)
6004 pub fn distortion_type(&self) -> u32 {
6005 unsafe { ::std::mem::transmute(self._bitfield_1.get(84usize, 1u8) as u32) }
6008 pub fn set_distortion_type(&mut self, val: u32) {
6010 let val: u32 = ::std::mem::transmute(val);
6011 self._bitfield_1.set(84usize, 1u8, val as u64)
6015 pub fn repartition_check_enable(&self) -> u32 {
6016 unsafe { ::std::mem::transmute(self._bitfield_1.get(85usize, 1u8) as u32) }
6019 pub fn set_repartition_check_enable(&mut self, val: u32) {
6021 let val: u32 = ::std::mem::transmute(val);
6022 self._bitfield_1.set(85usize, 1u8, val as u64)
6026 pub fn adaptive_search(&self) -> u32 {
6027 unsafe { ::std::mem::transmute(self._bitfield_1.get(86usize, 1u8) as u32) }
6030 pub fn set_adaptive_search(&mut self, val: u32) {
6032 let val: u32 = ::std::mem::transmute(val);
6033 self._bitfield_1.set(86usize, 1u8, val as u64)
6037 pub fn mv_predictor_enable(&self) -> u32 {
6038 unsafe { ::std::mem::transmute(self._bitfield_1.get(87usize, 1u8) as u32) }
6041 pub fn set_mv_predictor_enable(&mut self, val: u32) {
6043 let val: u32 = ::std::mem::transmute(val);
6044 self._bitfield_1.set(87usize, 1u8, val as u64)
6048 pub fn mb_qp(&self) -> u32 {
6049 unsafe { ::std::mem::transmute(self._bitfield_1.get(88usize, 1u8) as u32) }
6052 pub fn set_mb_qp(&mut self, val: u32) {
6054 let val: u32 = ::std::mem::transmute(val);
6055 self._bitfield_1.set(88usize, 1u8, val as u64)
6059 pub fn mb_input(&self) -> u32 {
6060 unsafe { ::std::mem::transmute(self._bitfield_1.get(89usize, 1u8) as u32) }
6063 pub fn set_mb_input(&mut self, val: u32) {
6065 let val: u32 = ::std::mem::transmute(val);
6066 self._bitfield_1.set(89usize, 1u8, val as u64)
6070 pub fn mb_size_ctrl(&self) -> u32 {
6071 unsafe { ::std::mem::transmute(self._bitfield_1.get(90usize, 1u8) as u32) }
6074 pub fn set_mb_size_ctrl(&mut self, val: u32) {
6076 let val: u32 = ::std::mem::transmute(val);
6077 self._bitfield_1.set(90usize, 1u8, val as u64)
6081 pub fn colocated_mb_distortion(&self) -> u32 {
6082 unsafe { ::std::mem::transmute(self._bitfield_1.get(91usize, 1u8) as u32) }
6085 pub fn set_colocated_mb_distortion(&mut self, val: u32) {
6087 let val: u32 = ::std::mem::transmute(val);
6088 self._bitfield_1.set(91usize, 1u8, val as u64)
6092 pub fn reserved1(&self) -> u32 {
6093 unsafe { ::std::mem::transmute(self._bitfield_1.get(92usize, 4u8) as u32) }
6096 pub fn set_reserved1(&mut self, val: u32) {
6098 let val: u32 = ::std::mem::transmute(val);
6099 self._bitfield_1.set(92usize, 4u8, val as u64)
6103 pub fn ref_width(&self) -> u32 {
6104 unsafe { ::std::mem::transmute(self._bitfield_1.get(96usize, 8u8) as u32) }
6107 pub fn set_ref_width(&mut self, val: u32) {
6109 let val: u32 = ::std::mem::transmute(val);
6110 self._bitfield_1.set(96usize, 8u8, val as u64)
6114 pub fn ref_height(&self) -> u32 {
6115 unsafe { ::std::mem::transmute(self._bitfield_1.get(104usize, 8u8) as u32) }
6118 pub fn set_ref_height(&mut self, val: u32) {
6120 let val: u32 = ::std::mem::transmute(val);
6121 self._bitfield_1.set(104usize, 8u8, val as u64)
6125 pub fn search_window(&self) -> u32 {
6126 unsafe { ::std::mem::transmute(self._bitfield_1.get(112usize, 4u8) as u32) }
6129 pub fn set_search_window(&mut self, val: u32) {
6131 let val: u32 = ::std::mem::transmute(val);
6132 self._bitfield_1.set(112usize, 4u8, val as u64)
6136 pub fn reserved2(&self) -> u32 {
6137 unsafe { ::std::mem::transmute(self._bitfield_1.get(116usize, 12u8) as u32) }
6140 pub fn set_reserved2(&mut self, val: u32) {
6142 let val: u32 = ::std::mem::transmute(val);
6143 self._bitfield_1.set(116usize, 12u8, val as u64)
6147 pub fn new_bitfield_1(
6148 num_mv_predictors_l0: u32,
6149 num_mv_predictors_l1: u32,
6153 sub_mb_part_mask: u32,
6154 intra_part_mask: u32,
6160 distortion_type: u32,
6161 repartition_check_enable: u32,
6162 adaptive_search: u32,
6163 mv_predictor_enable: u32,
6167 colocated_mb_distortion: u32,
6173 ) -> __BindgenBitfieldUnit<[u8; 16usize]> {
6174 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 16usize]> = Default::default();
6175 __bindgen_bitfield_unit.set(0usize, 16u8, {
6176 let num_mv_predictors_l0: u32 = unsafe { ::std::mem::transmute(num_mv_predictors_l0) };
6177 num_mv_predictors_l0 as u64
6179 __bindgen_bitfield_unit.set(16usize, 16u8, {
6180 let num_mv_predictors_l1: u32 = unsafe { ::std::mem::transmute(num_mv_predictors_l1) };
6181 num_mv_predictors_l1 as u64
6183 __bindgen_bitfield_unit.set(32usize, 8u8, {
6184 let search_path: u32 = unsafe { ::std::mem::transmute(search_path) };
6187 __bindgen_bitfield_unit.set(40usize, 8u8, {
6188 let len_sp: u32 = unsafe { ::std::mem::transmute(len_sp) };
6191 __bindgen_bitfield_unit.set(48usize, 16u8, {
6192 let reserved0: u32 = unsafe { ::std::mem::transmute(reserved0) };
6195 __bindgen_bitfield_unit.set(64usize, 7u8, {
6196 let sub_mb_part_mask: u32 = unsafe { ::std::mem::transmute(sub_mb_part_mask) };
6197 sub_mb_part_mask as u64
6199 __bindgen_bitfield_unit.set(71usize, 5u8, {
6200 let intra_part_mask: u32 = unsafe { ::std::mem::transmute(intra_part_mask) };
6201 intra_part_mask as u64
6203 __bindgen_bitfield_unit.set(76usize, 1u8, {
6204 let multi_pred_l0: u32 = unsafe { ::std::mem::transmute(multi_pred_l0) };
6205 multi_pred_l0 as u64
6207 __bindgen_bitfield_unit.set(77usize, 1u8, {
6208 let multi_pred_l1: u32 = unsafe { ::std::mem::transmute(multi_pred_l1) };
6209 multi_pred_l1 as u64
6211 __bindgen_bitfield_unit.set(78usize, 2u8, {
6212 let sub_pel_mode: u32 = unsafe { ::std::mem::transmute(sub_pel_mode) };
6215 __bindgen_bitfield_unit.set(80usize, 2u8, {
6216 let inter_sad: u32 = unsafe { ::std::mem::transmute(inter_sad) };
6219 __bindgen_bitfield_unit.set(82usize, 2u8, {
6220 let intra_sad: u32 = unsafe { ::std::mem::transmute(intra_sad) };
6223 __bindgen_bitfield_unit.set(84usize, 1u8, {
6224 let distortion_type: u32 = unsafe { ::std::mem::transmute(distortion_type) };
6225 distortion_type as u64
6227 __bindgen_bitfield_unit.set(85usize, 1u8, {
6228 let repartition_check_enable: u32 =
6229 unsafe { ::std::mem::transmute(repartition_check_enable) };
6230 repartition_check_enable as u64
6232 __bindgen_bitfield_unit.set(86usize, 1u8, {
6233 let adaptive_search: u32 = unsafe { ::std::mem::transmute(adaptive_search) };
6234 adaptive_search as u64
6236 __bindgen_bitfield_unit.set(87usize, 1u8, {
6237 let mv_predictor_enable: u32 = unsafe { ::std::mem::transmute(mv_predictor_enable) };
6238 mv_predictor_enable as u64
6240 __bindgen_bitfield_unit.set(88usize, 1u8, {
6241 let mb_qp: u32 = unsafe { ::std::mem::transmute(mb_qp) };
6244 __bindgen_bitfield_unit.set(89usize, 1u8, {
6245 let mb_input: u32 = unsafe { ::std::mem::transmute(mb_input) };
6248 __bindgen_bitfield_unit.set(90usize, 1u8, {
6249 let mb_size_ctrl: u32 = unsafe { ::std::mem::transmute(mb_size_ctrl) };
6252 __bindgen_bitfield_unit.set(91usize, 1u8, {
6253 let colocated_mb_distortion: u32 =
6254 unsafe { ::std::mem::transmute(colocated_mb_distortion) };
6255 colocated_mb_distortion as u64
6257 __bindgen_bitfield_unit.set(92usize, 4u8, {
6258 let reserved1: u32 = unsafe { ::std::mem::transmute(reserved1) };
6261 __bindgen_bitfield_unit.set(96usize, 8u8, {
6262 let ref_width: u32 = unsafe { ::std::mem::transmute(ref_width) };
6265 __bindgen_bitfield_unit.set(104usize, 8u8, {
6266 let ref_height: u32 = unsafe { ::std::mem::transmute(ref_height) };
6269 __bindgen_bitfield_unit.set(112usize, 4u8, {
6270 let search_window: u32 = unsafe { ::std::mem::transmute(search_window) };
6271 search_window as u64
6273 __bindgen_bitfield_unit.set(116usize, 12u8, {
6274 let reserved2: u32 = unsafe { ::std::mem::transmute(reserved2) };
6277 __bindgen_bitfield_unit
6280 pub type VAEncMiscParameterFEIFrameControlH264 = _VAEncMiscParameterFEIFrameControlH264;
6282 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
6283 pub struct _VAEncFEIMBControlH264 {
6284 pub _bitfield_align_1: [u32; 0],
6285 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
6288 pub _bitfield_align_2: [u16; 0],
6289 pub _bitfield_2: __BindgenBitfieldUnit<[u8; 4usize]>,
6291 impl _VAEncFEIMBControlH264 {
6293 pub fn force_to_intra(&self) -> u32 {
6294 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
6297 pub fn set_force_to_intra(&mut self, val: u32) {
6299 let val: u32 = ::std::mem::transmute(val);
6300 self._bitfield_1.set(0usize, 1u8, val as u64)
6304 pub fn force_to_skip(&self) -> u32 {
6305 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
6308 pub fn set_force_to_skip(&mut self, val: u32) {
6310 let val: u32 = ::std::mem::transmute(val);
6311 self._bitfield_1.set(1usize, 1u8, val as u64)
6315 pub fn force_to_nonskip(&self) -> u32 {
6316 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
6319 pub fn set_force_to_nonskip(&mut self, val: u32) {
6321 let val: u32 = ::std::mem::transmute(val);
6322 self._bitfield_1.set(2usize, 1u8, val as u64)
6326 pub fn enable_direct_bias_adjustment(&self) -> u32 {
6327 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
6330 pub fn set_enable_direct_bias_adjustment(&mut self, val: u32) {
6332 let val: u32 = ::std::mem::transmute(val);
6333 self._bitfield_1.set(3usize, 1u8, val as u64)
6337 pub fn enable_motion_bias_adjustment(&self) -> u32 {
6338 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
6341 pub fn set_enable_motion_bias_adjustment(&mut self, val: u32) {
6343 let val: u32 = ::std::mem::transmute(val);
6344 self._bitfield_1.set(4usize, 1u8, val as u64)
6348 pub fn ext_mv_cost_scaling_factor(&self) -> u32 {
6349 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 3u8) as u32) }
6352 pub fn set_ext_mv_cost_scaling_factor(&mut self, val: u32) {
6354 let val: u32 = ::std::mem::transmute(val);
6355 self._bitfield_1.set(5usize, 3u8, val as u64)
6359 pub fn reserved0(&self) -> u32 {
6360 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 24u8) as u32) }
6363 pub fn set_reserved0(&mut self, val: u32) {
6365 let val: u32 = ::std::mem::transmute(val);
6366 self._bitfield_1.set(8usize, 24u8, val as u64)
6370 pub fn new_bitfield_1(
6371 force_to_intra: u32,
6373 force_to_nonskip: u32,
6374 enable_direct_bias_adjustment: u32,
6375 enable_motion_bias_adjustment: u32,
6376 ext_mv_cost_scaling_factor: u32,
6378 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
6379 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
6380 __bindgen_bitfield_unit.set(0usize, 1u8, {
6381 let force_to_intra: u32 = unsafe { ::std::mem::transmute(force_to_intra) };
6382 force_to_intra as u64
6384 __bindgen_bitfield_unit.set(1usize, 1u8, {
6385 let force_to_skip: u32 = unsafe { ::std::mem::transmute(force_to_skip) };
6386 force_to_skip as u64
6388 __bindgen_bitfield_unit.set(2usize, 1u8, {
6389 let force_to_nonskip: u32 = unsafe { ::std::mem::transmute(force_to_nonskip) };
6390 force_to_nonskip as u64
6392 __bindgen_bitfield_unit.set(3usize, 1u8, {
6393 let enable_direct_bias_adjustment: u32 =
6394 unsafe { ::std::mem::transmute(enable_direct_bias_adjustment) };
6395 enable_direct_bias_adjustment as u64
6397 __bindgen_bitfield_unit.set(4usize, 1u8, {
6398 let enable_motion_bias_adjustment: u32 =
6399 unsafe { ::std::mem::transmute(enable_motion_bias_adjustment) };
6400 enable_motion_bias_adjustment as u64
6402 __bindgen_bitfield_unit.set(5usize, 3u8, {
6403 let ext_mv_cost_scaling_factor: u32 =
6404 unsafe { ::std::mem::transmute(ext_mv_cost_scaling_factor) };
6405 ext_mv_cost_scaling_factor as u64
6407 __bindgen_bitfield_unit.set(8usize, 24u8, {
6408 let reserved0: u32 = unsafe { ::std::mem::transmute(reserved0) };
6411 __bindgen_bitfield_unit
6414 pub fn reserved3(&self) -> u32 {
6415 unsafe { ::std::mem::transmute(self._bitfield_2.get(0usize, 16u8) as u32) }
6418 pub fn set_reserved3(&mut self, val: u32) {
6420 let val: u32 = ::std::mem::transmute(val);
6421 self._bitfield_2.set(0usize, 16u8, val as u64)
6425 pub fn target_size_in_word(&self) -> u32 {
6426 unsafe { ::std::mem::transmute(self._bitfield_2.get(16usize, 8u8) as u32) }
6429 pub fn set_target_size_in_word(&mut self, val: u32) {
6431 let val: u32 = ::std::mem::transmute(val);
6432 self._bitfield_2.set(16usize, 8u8, val as u64)
6436 pub fn max_size_in_word(&self) -> u32 {
6437 unsafe { ::std::mem::transmute(self._bitfield_2.get(24usize, 8u8) as u32) }
6440 pub fn set_max_size_in_word(&mut self, val: u32) {
6442 let val: u32 = ::std::mem::transmute(val);
6443 self._bitfield_2.set(24usize, 8u8, val as u64)
6447 pub fn new_bitfield_2(
6449 target_size_in_word: u32,
6450 max_size_in_word: u32,
6451 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
6452 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
6453 __bindgen_bitfield_unit.set(0usize, 16u8, {
6454 let reserved3: u32 = unsafe { ::std::mem::transmute(reserved3) };
6457 __bindgen_bitfield_unit.set(16usize, 8u8, {
6458 let target_size_in_word: u32 = unsafe { ::std::mem::transmute(target_size_in_word) };
6459 target_size_in_word as u64
6461 __bindgen_bitfield_unit.set(24usize, 8u8, {
6462 let max_size_in_word: u32 = unsafe { ::std::mem::transmute(max_size_in_word) };
6463 max_size_in_word as u64
6465 __bindgen_bitfield_unit
6468 pub type VAEncFEIMBControlH264 = _VAEncFEIMBControlH264;
6470 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
6471 pub struct _VAEncFEIMVPredictorH264 {
6472 pub ref_idx: [_VAEncFEIMVPredictorH264__bindgen_ty_1; 4usize],
6474 pub mv: [VAMotionVector; 4usize],
6477 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
6478 pub struct _VAEncFEIMVPredictorH264__bindgen_ty_1 {
6479 pub _bitfield_align_1: [u8; 0],
6480 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
6482 impl _VAEncFEIMVPredictorH264__bindgen_ty_1 {
6484 pub fn ref_idx_l0(&self) -> u8 {
6485 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u8) }
6488 pub fn set_ref_idx_l0(&mut self, val: u8) {
6490 let val: u8 = ::std::mem::transmute(val);
6491 self._bitfield_1.set(0usize, 4u8, val as u64)
6495 pub fn ref_idx_l1(&self) -> u8 {
6496 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 4u8) as u8) }
6499 pub fn set_ref_idx_l1(&mut self, val: u8) {
6501 let val: u8 = ::std::mem::transmute(val);
6502 self._bitfield_1.set(4usize, 4u8, val as u64)
6506 pub fn new_bitfield_1(ref_idx_l0: u8, ref_idx_l1: u8) -> __BindgenBitfieldUnit<[u8; 1usize]> {
6507 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
6508 __bindgen_bitfield_unit.set(0usize, 4u8, {
6509 let ref_idx_l0: u8 = unsafe { ::std::mem::transmute(ref_idx_l0) };
6512 __bindgen_bitfield_unit.set(4usize, 4u8, {
6513 let ref_idx_l1: u8 = unsafe { ::std::mem::transmute(ref_idx_l1) };
6516 __bindgen_bitfield_unit
6519 pub type VAEncFEIMVPredictorH264 = _VAEncFEIMVPredictorH264;
6521 #[derive(Copy, Clone)]
6522 pub struct _VAEncFEIMBCodeH264 {
6523 pub reserved0: [u32; 3usize],
6524 pub _bitfield_align_1: [u32; 0],
6525 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 16usize]>,
6526 pub mb_mode: _VAEncFEIMBCodeH264__bindgen_ty_1,
6527 pub _bitfield_align_2: [u16; 0],
6528 pub _bitfield_2: __BindgenBitfieldUnit<[u8; 4usize]>,
6529 pub reserved9: [u32; 4usize],
6530 pub reserved10: u32,
6533 #[derive(Copy, Clone)]
6534 pub union _VAEncFEIMBCodeH264__bindgen_ty_1 {
6535 pub intra_mb: _VAEncFEIMBCodeH264__bindgen_ty_1__bindgen_ty_1,
6536 pub inter_mb: _VAEncFEIMBCodeH264__bindgen_ty_1__bindgen_ty_2,
6540 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
6541 pub struct _VAEncFEIMBCodeH264__bindgen_ty_1__bindgen_ty_1 {
6542 pub _bitfield_align_1: [u32; 0],
6543 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 12usize]>,
6545 impl _VAEncFEIMBCodeH264__bindgen_ty_1__bindgen_ty_1 {
6547 pub fn luma_intra_pred_modes0(&self) -> u32 {
6548 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 16u8) as u32) }
6551 pub fn set_luma_intra_pred_modes0(&mut self, val: u32) {
6553 let val: u32 = ::std::mem::transmute(val);
6554 self._bitfield_1.set(0usize, 16u8, val as u64)
6558 pub fn luma_intra_pred_modes1(&self) -> u32 {
6559 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 16u8) as u32) }
6562 pub fn set_luma_intra_pred_modes1(&mut self, val: u32) {
6564 let val: u32 = ::std::mem::transmute(val);
6565 self._bitfield_1.set(16usize, 16u8, val as u64)
6569 pub fn luma_intra_pred_modes2(&self) -> u32 {
6570 unsafe { ::std::mem::transmute(self._bitfield_1.get(32usize, 16u8) as u32) }
6573 pub fn set_luma_intra_pred_modes2(&mut self, val: u32) {
6575 let val: u32 = ::std::mem::transmute(val);
6576 self._bitfield_1.set(32usize, 16u8, val as u64)
6580 pub fn luma_intra_pred_modes3(&self) -> u32 {
6581 unsafe { ::std::mem::transmute(self._bitfield_1.get(48usize, 16u8) as u32) }
6584 pub fn set_luma_intra_pred_modes3(&mut self, val: u32) {
6586 let val: u32 = ::std::mem::transmute(val);
6587 self._bitfield_1.set(48usize, 16u8, val as u64)
6591 pub fn chroma_intra_pred_mode(&self) -> u32 {
6592 unsafe { ::std::mem::transmute(self._bitfield_1.get(64usize, 2u8) as u32) }
6595 pub fn set_chroma_intra_pred_mode(&mut self, val: u32) {
6597 let val: u32 = ::std::mem::transmute(val);
6598 self._bitfield_1.set(64usize, 2u8, val as u64)
6602 pub fn intra_pred_avail_flag(&self) -> u32 {
6603 unsafe { ::std::mem::transmute(self._bitfield_1.get(66usize, 5u8) as u32) }
6606 pub fn set_intra_pred_avail_flag(&mut self, val: u32) {
6608 let val: u32 = ::std::mem::transmute(val);
6609 self._bitfield_1.set(66usize, 5u8, val as u64)
6613 pub fn intra_pred_avail_flagF(&self) -> u32 {
6614 unsafe { ::std::mem::transmute(self._bitfield_1.get(71usize, 1u8) as u32) }
6617 pub fn set_intra_pred_avail_flagF(&mut self, val: u32) {
6619 let val: u32 = ::std::mem::transmute(val);
6620 self._bitfield_1.set(71usize, 1u8, val as u64)
6624 pub fn reserved6(&self) -> u32 {
6625 unsafe { ::std::mem::transmute(self._bitfield_1.get(72usize, 24u8) as u32) }
6628 pub fn set_reserved6(&mut self, val: u32) {
6630 let val: u32 = ::std::mem::transmute(val);
6631 self._bitfield_1.set(72usize, 24u8, val as u64)
6635 pub fn new_bitfield_1(
6636 luma_intra_pred_modes0: u32,
6637 luma_intra_pred_modes1: u32,
6638 luma_intra_pred_modes2: u32,
6639 luma_intra_pred_modes3: u32,
6640 chroma_intra_pred_mode: u32,
6641 intra_pred_avail_flag: u32,
6642 intra_pred_avail_flagF: u32,
6644 ) -> __BindgenBitfieldUnit<[u8; 12usize]> {
6645 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 12usize]> = Default::default();
6646 __bindgen_bitfield_unit.set(0usize, 16u8, {
6647 let luma_intra_pred_modes0: u32 =
6648 unsafe { ::std::mem::transmute(luma_intra_pred_modes0) };
6649 luma_intra_pred_modes0 as u64
6651 __bindgen_bitfield_unit.set(16usize, 16u8, {
6652 let luma_intra_pred_modes1: u32 =
6653 unsafe { ::std::mem::transmute(luma_intra_pred_modes1) };
6654 luma_intra_pred_modes1 as u64
6656 __bindgen_bitfield_unit.set(32usize, 16u8, {
6657 let luma_intra_pred_modes2: u32 =
6658 unsafe { ::std::mem::transmute(luma_intra_pred_modes2) };
6659 luma_intra_pred_modes2 as u64
6661 __bindgen_bitfield_unit.set(48usize, 16u8, {
6662 let luma_intra_pred_modes3: u32 =
6663 unsafe { ::std::mem::transmute(luma_intra_pred_modes3) };
6664 luma_intra_pred_modes3 as u64
6666 __bindgen_bitfield_unit.set(64usize, 2u8, {
6667 let chroma_intra_pred_mode: u32 =
6668 unsafe { ::std::mem::transmute(chroma_intra_pred_mode) };
6669 chroma_intra_pred_mode as u64
6671 __bindgen_bitfield_unit.set(66usize, 5u8, {
6672 let intra_pred_avail_flag: u32 =
6673 unsafe { ::std::mem::transmute(intra_pred_avail_flag) };
6674 intra_pred_avail_flag as u64
6676 __bindgen_bitfield_unit.set(71usize, 1u8, {
6677 let intra_pred_avail_flagF: u32 =
6678 unsafe { ::std::mem::transmute(intra_pred_avail_flagF) };
6679 intra_pred_avail_flagF as u64
6681 __bindgen_bitfield_unit.set(72usize, 24u8, {
6682 let reserved6: u32 = unsafe { ::std::mem::transmute(reserved6) };
6685 __bindgen_bitfield_unit
6690 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
6691 pub struct _VAEncFEIMBCodeH264__bindgen_ty_1__bindgen_ty_2 {
6692 pub _bitfield_align_1: [u16; 0],
6693 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 12usize]>,
6695 impl _VAEncFEIMBCodeH264__bindgen_ty_1__bindgen_ty_2 {
6697 pub fn sub_mb_shapes(&self) -> u32 {
6698 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 8u8) as u32) }
6701 pub fn set_sub_mb_shapes(&mut self, val: u32) {
6703 let val: u32 = ::std::mem::transmute(val);
6704 self._bitfield_1.set(0usize, 8u8, val as u64)
6708 pub fn sub_mb_pred_modes(&self) -> u32 {
6709 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 8u8) as u32) }
6712 pub fn set_sub_mb_pred_modes(&mut self, val: u32) {
6714 let val: u32 = ::std::mem::transmute(val);
6715 self._bitfield_1.set(8usize, 8u8, val as u64)
6719 pub fn reserved7(&self) -> u32 {
6720 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 16u8) as u32) }
6723 pub fn set_reserved7(&mut self, val: u32) {
6725 let val: u32 = ::std::mem::transmute(val);
6726 self._bitfield_1.set(16usize, 16u8, val as u64)
6730 pub fn ref_idx_l0_0(&self) -> u32 {
6731 unsafe { ::std::mem::transmute(self._bitfield_1.get(32usize, 8u8) as u32) }
6734 pub fn set_ref_idx_l0_0(&mut self, val: u32) {
6736 let val: u32 = ::std::mem::transmute(val);
6737 self._bitfield_1.set(32usize, 8u8, val as u64)
6741 pub fn ref_idx_l0_1(&self) -> u32 {
6742 unsafe { ::std::mem::transmute(self._bitfield_1.get(40usize, 8u8) as u32) }
6745 pub fn set_ref_idx_l0_1(&mut self, val: u32) {
6747 let val: u32 = ::std::mem::transmute(val);
6748 self._bitfield_1.set(40usize, 8u8, val as u64)
6752 pub fn ref_idx_l0_2(&self) -> u32 {
6753 unsafe { ::std::mem::transmute(self._bitfield_1.get(48usize, 8u8) as u32) }
6756 pub fn set_ref_idx_l0_2(&mut self, val: u32) {
6758 let val: u32 = ::std::mem::transmute(val);
6759 self._bitfield_1.set(48usize, 8u8, val as u64)
6763 pub fn ref_idx_l0_3(&self) -> u32 {
6764 unsafe { ::std::mem::transmute(self._bitfield_1.get(56usize, 8u8) as u32) }
6767 pub fn set_ref_idx_l0_3(&mut self, val: u32) {
6769 let val: u32 = ::std::mem::transmute(val);
6770 self._bitfield_1.set(56usize, 8u8, val as u64)
6774 pub fn ref_idx_l1_0(&self) -> u32 {
6775 unsafe { ::std::mem::transmute(self._bitfield_1.get(64usize, 8u8) as u32) }
6778 pub fn set_ref_idx_l1_0(&mut self, val: u32) {
6780 let val: u32 = ::std::mem::transmute(val);
6781 self._bitfield_1.set(64usize, 8u8, val as u64)
6785 pub fn ref_idx_l1_1(&self) -> u32 {
6786 unsafe { ::std::mem::transmute(self._bitfield_1.get(72usize, 8u8) as u32) }
6789 pub fn set_ref_idx_l1_1(&mut self, val: u32) {
6791 let val: u32 = ::std::mem::transmute(val);
6792 self._bitfield_1.set(72usize, 8u8, val as u64)
6796 pub fn ref_idx_l1_2(&self) -> u32 {
6797 unsafe { ::std::mem::transmute(self._bitfield_1.get(80usize, 8u8) as u32) }
6800 pub fn set_ref_idx_l1_2(&mut self, val: u32) {
6802 let val: u32 = ::std::mem::transmute(val);
6803 self._bitfield_1.set(80usize, 8u8, val as u64)
6807 pub fn ref_idx_l1_3(&self) -> u32 {
6808 unsafe { ::std::mem::transmute(self._bitfield_1.get(88usize, 8u8) as u32) }
6811 pub fn set_ref_idx_l1_3(&mut self, val: u32) {
6813 let val: u32 = ::std::mem::transmute(val);
6814 self._bitfield_1.set(88usize, 8u8, val as u64)
6818 pub fn new_bitfield_1(
6820 sub_mb_pred_modes: u32,
6830 ) -> __BindgenBitfieldUnit<[u8; 12usize]> {
6831 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 12usize]> = Default::default();
6832 __bindgen_bitfield_unit.set(0usize, 8u8, {
6833 let sub_mb_shapes: u32 = unsafe { ::std::mem::transmute(sub_mb_shapes) };
6834 sub_mb_shapes as u64
6836 __bindgen_bitfield_unit.set(8usize, 8u8, {
6837 let sub_mb_pred_modes: u32 = unsafe { ::std::mem::transmute(sub_mb_pred_modes) };
6838 sub_mb_pred_modes as u64
6840 __bindgen_bitfield_unit.set(16usize, 16u8, {
6841 let reserved7: u32 = unsafe { ::std::mem::transmute(reserved7) };
6844 __bindgen_bitfield_unit.set(32usize, 8u8, {
6845 let ref_idx_l0_0: u32 = unsafe { ::std::mem::transmute(ref_idx_l0_0) };
6848 __bindgen_bitfield_unit.set(40usize, 8u8, {
6849 let ref_idx_l0_1: u32 = unsafe { ::std::mem::transmute(ref_idx_l0_1) };
6852 __bindgen_bitfield_unit.set(48usize, 8u8, {
6853 let ref_idx_l0_2: u32 = unsafe { ::std::mem::transmute(ref_idx_l0_2) };
6856 __bindgen_bitfield_unit.set(56usize, 8u8, {
6857 let ref_idx_l0_3: u32 = unsafe { ::std::mem::transmute(ref_idx_l0_3) };
6860 __bindgen_bitfield_unit.set(64usize, 8u8, {
6861 let ref_idx_l1_0: u32 = unsafe { ::std::mem::transmute(ref_idx_l1_0) };
6864 __bindgen_bitfield_unit.set(72usize, 8u8, {
6865 let ref_idx_l1_1: u32 = unsafe { ::std::mem::transmute(ref_idx_l1_1) };
6868 __bindgen_bitfield_unit.set(80usize, 8u8, {
6869 let ref_idx_l1_2: u32 = unsafe { ::std::mem::transmute(ref_idx_l1_2) };
6872 __bindgen_bitfield_unit.set(88usize, 8u8, {
6873 let ref_idx_l1_3: u32 = unsafe { ::std::mem::transmute(ref_idx_l1_3) };
6876 __bindgen_bitfield_unit
6879 impl Default for _VAEncFEIMBCodeH264__bindgen_ty_1 {
6880 fn default() -> Self {
6881 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6883 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6888 impl Default for _VAEncFEIMBCodeH264 {
6889 fn default() -> Self {
6890 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6892 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6897 impl _VAEncFEIMBCodeH264 {
6899 pub fn inter_mb_mode(&self) -> u32 {
6900 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u32) }
6903 pub fn set_inter_mb_mode(&mut self, val: u32) {
6905 let val: u32 = ::std::mem::transmute(val);
6906 self._bitfield_1.set(0usize, 2u8, val as u64)
6910 pub fn mb_skip_flag(&self) -> u32 {
6911 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
6914 pub fn set_mb_skip_flag(&mut self, val: u32) {
6916 let val: u32 = ::std::mem::transmute(val);
6917 self._bitfield_1.set(2usize, 1u8, val as u64)
6921 pub fn reserved1(&self) -> u32 {
6922 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
6925 pub fn set_reserved1(&mut self, val: u32) {
6927 let val: u32 = ::std::mem::transmute(val);
6928 self._bitfield_1.set(3usize, 1u8, val as u64)
6932 pub fn intra_mb_mode(&self) -> u32 {
6933 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 2u8) as u32) }
6936 pub fn set_intra_mb_mode(&mut self, val: u32) {
6938 let val: u32 = ::std::mem::transmute(val);
6939 self._bitfield_1.set(4usize, 2u8, val as u64)
6943 pub fn reserved2(&self) -> u32 {
6944 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) }
6947 pub fn set_reserved2(&mut self, val: u32) {
6949 let val: u32 = ::std::mem::transmute(val);
6950 self._bitfield_1.set(6usize, 1u8, val as u64)
6954 pub fn field_mb_polarity_flag(&self) -> u32 {
6955 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) }
6958 pub fn set_field_mb_polarity_flag(&mut self, val: u32) {
6960 let val: u32 = ::std::mem::transmute(val);
6961 self._bitfield_1.set(7usize, 1u8, val as u64)
6965 pub fn mb_type(&self) -> u32 {
6966 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 5u8) as u32) }
6969 pub fn set_mb_type(&mut self, val: u32) {
6971 let val: u32 = ::std::mem::transmute(val);
6972 self._bitfield_1.set(8usize, 5u8, val as u64)
6976 pub fn intra_mb_flag(&self) -> u32 {
6977 unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) }
6980 pub fn set_intra_mb_flag(&mut self, val: u32) {
6982 let val: u32 = ::std::mem::transmute(val);
6983 self._bitfield_1.set(13usize, 1u8, val as u64)
6987 pub fn field_mb_flag(&self) -> u32 {
6988 unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) }
6991 pub fn set_field_mb_flag(&mut self, val: u32) {
6993 let val: u32 = ::std::mem::transmute(val);
6994 self._bitfield_1.set(14usize, 1u8, val as u64)
6998 pub fn transform8x8_flag(&self) -> u32 {
6999 unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u32) }
7002 pub fn set_transform8x8_flag(&mut self, val: u32) {
7004 let val: u32 = ::std::mem::transmute(val);
7005 self._bitfield_1.set(15usize, 1u8, val as u64)
7009 pub fn reserved3(&self) -> u32 {
7010 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u32) }
7013 pub fn set_reserved3(&mut self, val: u32) {
7015 let val: u32 = ::std::mem::transmute(val);
7016 self._bitfield_1.set(16usize, 1u8, val as u64)
7020 pub fn dc_block_coded_cr_flag(&self) -> u32 {
7021 unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 1u8) as u32) }
7024 pub fn set_dc_block_coded_cr_flag(&mut self, val: u32) {
7026 let val: u32 = ::std::mem::transmute(val);
7027 self._bitfield_1.set(17usize, 1u8, val as u64)
7031 pub fn dc_block_coded_cb_flag(&self) -> u32 {
7032 unsafe { ::std::mem::transmute(self._bitfield_1.get(18usize, 1u8) as u32) }
7035 pub fn set_dc_block_coded_cb_flag(&mut self, val: u32) {
7037 let val: u32 = ::std::mem::transmute(val);
7038 self._bitfield_1.set(18usize, 1u8, val as u64)
7042 pub fn dc_block_coded_y_flag(&self) -> u32 {
7043 unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 1u8) as u32) }
7046 pub fn set_dc_block_coded_y_flag(&mut self, val: u32) {
7048 let val: u32 = ::std::mem::transmute(val);
7049 self._bitfield_1.set(19usize, 1u8, val as u64)
7053 pub fn reserved4(&self) -> u32 {
7054 unsafe { ::std::mem::transmute(self._bitfield_1.get(20usize, 12u8) as u32) }
7057 pub fn set_reserved4(&mut self, val: u32) {
7059 let val: u32 = ::std::mem::transmute(val);
7060 self._bitfield_1.set(20usize, 12u8, val as u64)
7064 pub fn horz_origin(&self) -> u32 {
7065 unsafe { ::std::mem::transmute(self._bitfield_1.get(32usize, 8u8) as u32) }
7068 pub fn set_horz_origin(&mut self, val: u32) {
7070 let val: u32 = ::std::mem::transmute(val);
7071 self._bitfield_1.set(32usize, 8u8, val as u64)
7075 pub fn vert_origin(&self) -> u32 {
7076 unsafe { ::std::mem::transmute(self._bitfield_1.get(40usize, 8u8) as u32) }
7079 pub fn set_vert_origin(&mut self, val: u32) {
7081 let val: u32 = ::std::mem::transmute(val);
7082 self._bitfield_1.set(40usize, 8u8, val as u64)
7086 pub fn cbp_y(&self) -> u32 {
7087 unsafe { ::std::mem::transmute(self._bitfield_1.get(48usize, 16u8) as u32) }
7090 pub fn set_cbp_y(&mut self, val: u32) {
7092 let val: u32 = ::std::mem::transmute(val);
7093 self._bitfield_1.set(48usize, 16u8, val as u64)
7097 pub fn cbp_cb(&self) -> u32 {
7098 unsafe { ::std::mem::transmute(self._bitfield_1.get(64usize, 16u8) as u32) }
7101 pub fn set_cbp_cb(&mut self, val: u32) {
7103 let val: u32 = ::std::mem::transmute(val);
7104 self._bitfield_1.set(64usize, 16u8, val as u64)
7108 pub fn cbp_cr(&self) -> u32 {
7109 unsafe { ::std::mem::transmute(self._bitfield_1.get(80usize, 16u8) as u32) }
7112 pub fn set_cbp_cr(&mut self, val: u32) {
7114 let val: u32 = ::std::mem::transmute(val);
7115 self._bitfield_1.set(80usize, 16u8, val as u64)
7119 pub fn qp_prime_y(&self) -> u32 {
7120 unsafe { ::std::mem::transmute(self._bitfield_1.get(96usize, 8u8) as u32) }
7123 pub fn set_qp_prime_y(&mut self, val: u32) {
7125 let val: u32 = ::std::mem::transmute(val);
7126 self._bitfield_1.set(96usize, 8u8, val as u64)
7130 pub fn reserved5(&self) -> u32 {
7131 unsafe { ::std::mem::transmute(self._bitfield_1.get(104usize, 17u8) as u32) }
7134 pub fn set_reserved5(&mut self, val: u32) {
7136 let val: u32 = ::std::mem::transmute(val);
7137 self._bitfield_1.set(104usize, 17u8, val as u64)
7141 pub fn mb_skip_conv_disable(&self) -> u32 {
7142 unsafe { ::std::mem::transmute(self._bitfield_1.get(121usize, 1u8) as u32) }
7145 pub fn set_mb_skip_conv_disable(&mut self, val: u32) {
7147 let val: u32 = ::std::mem::transmute(val);
7148 self._bitfield_1.set(121usize, 1u8, val as u64)
7152 pub fn is_last_mb(&self) -> u32 {
7153 unsafe { ::std::mem::transmute(self._bitfield_1.get(122usize, 1u8) as u32) }
7156 pub fn set_is_last_mb(&mut self, val: u32) {
7158 let val: u32 = ::std::mem::transmute(val);
7159 self._bitfield_1.set(122usize, 1u8, val as u64)
7163 pub fn enable_coefficient_clamp(&self) -> u32 {
7164 unsafe { ::std::mem::transmute(self._bitfield_1.get(123usize, 1u8) as u32) }
7167 pub fn set_enable_coefficient_clamp(&mut self, val: u32) {
7169 let val: u32 = ::std::mem::transmute(val);
7170 self._bitfield_1.set(123usize, 1u8, val as u64)
7174 pub fn direct8x8_pattern(&self) -> u32 {
7175 unsafe { ::std::mem::transmute(self._bitfield_1.get(124usize, 4u8) as u32) }
7178 pub fn set_direct8x8_pattern(&mut self, val: u32) {
7180 let val: u32 = ::std::mem::transmute(val);
7181 self._bitfield_1.set(124usize, 4u8, val as u64)
7185 pub fn new_bitfield_1(
7191 field_mb_polarity_flag: u32,
7195 transform8x8_flag: u32,
7197 dc_block_coded_cr_flag: u32,
7198 dc_block_coded_cb_flag: u32,
7199 dc_block_coded_y_flag: u32,
7208 mb_skip_conv_disable: u32,
7210 enable_coefficient_clamp: u32,
7211 direct8x8_pattern: u32,
7212 ) -> __BindgenBitfieldUnit<[u8; 16usize]> {
7213 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 16usize]> = Default::default();
7214 __bindgen_bitfield_unit.set(0usize, 2u8, {
7215 let inter_mb_mode: u32 = unsafe { ::std::mem::transmute(inter_mb_mode) };
7216 inter_mb_mode as u64
7218 __bindgen_bitfield_unit.set(2usize, 1u8, {
7219 let mb_skip_flag: u32 = unsafe { ::std::mem::transmute(mb_skip_flag) };
7222 __bindgen_bitfield_unit.set(3usize, 1u8, {
7223 let reserved1: u32 = unsafe { ::std::mem::transmute(reserved1) };
7226 __bindgen_bitfield_unit.set(4usize, 2u8, {
7227 let intra_mb_mode: u32 = unsafe { ::std::mem::transmute(intra_mb_mode) };
7228 intra_mb_mode as u64
7230 __bindgen_bitfield_unit.set(6usize, 1u8, {
7231 let reserved2: u32 = unsafe { ::std::mem::transmute(reserved2) };
7234 __bindgen_bitfield_unit.set(7usize, 1u8, {
7235 let field_mb_polarity_flag: u32 =
7236 unsafe { ::std::mem::transmute(field_mb_polarity_flag) };
7237 field_mb_polarity_flag as u64
7239 __bindgen_bitfield_unit.set(8usize, 5u8, {
7240 let mb_type: u32 = unsafe { ::std::mem::transmute(mb_type) };
7243 __bindgen_bitfield_unit.set(13usize, 1u8, {
7244 let intra_mb_flag: u32 = unsafe { ::std::mem::transmute(intra_mb_flag) };
7245 intra_mb_flag as u64
7247 __bindgen_bitfield_unit.set(14usize, 1u8, {
7248 let field_mb_flag: u32 = unsafe { ::std::mem::transmute(field_mb_flag) };
7249 field_mb_flag as u64
7251 __bindgen_bitfield_unit.set(15usize, 1u8, {
7252 let transform8x8_flag: u32 = unsafe { ::std::mem::transmute(transform8x8_flag) };
7253 transform8x8_flag as u64
7255 __bindgen_bitfield_unit.set(16usize, 1u8, {
7256 let reserved3: u32 = unsafe { ::std::mem::transmute(reserved3) };
7259 __bindgen_bitfield_unit.set(17usize, 1u8, {
7260 let dc_block_coded_cr_flag: u32 =
7261 unsafe { ::std::mem::transmute(dc_block_coded_cr_flag) };
7262 dc_block_coded_cr_flag as u64
7264 __bindgen_bitfield_unit.set(18usize, 1u8, {
7265 let dc_block_coded_cb_flag: u32 =
7266 unsafe { ::std::mem::transmute(dc_block_coded_cb_flag) };
7267 dc_block_coded_cb_flag as u64
7269 __bindgen_bitfield_unit.set(19usize, 1u8, {
7270 let dc_block_coded_y_flag: u32 =
7271 unsafe { ::std::mem::transmute(dc_block_coded_y_flag) };
7272 dc_block_coded_y_flag as u64
7274 __bindgen_bitfield_unit.set(20usize, 12u8, {
7275 let reserved4: u32 = unsafe { ::std::mem::transmute(reserved4) };
7278 __bindgen_bitfield_unit.set(32usize, 8u8, {
7279 let horz_origin: u32 = unsafe { ::std::mem::transmute(horz_origin) };
7282 __bindgen_bitfield_unit.set(40usize, 8u8, {
7283 let vert_origin: u32 = unsafe { ::std::mem::transmute(vert_origin) };
7286 __bindgen_bitfield_unit.set(48usize, 16u8, {
7287 let cbp_y: u32 = unsafe { ::std::mem::transmute(cbp_y) };
7290 __bindgen_bitfield_unit.set(64usize, 16u8, {
7291 let cbp_cb: u32 = unsafe { ::std::mem::transmute(cbp_cb) };
7294 __bindgen_bitfield_unit.set(80usize, 16u8, {
7295 let cbp_cr: u32 = unsafe { ::std::mem::transmute(cbp_cr) };
7298 __bindgen_bitfield_unit.set(96usize, 8u8, {
7299 let qp_prime_y: u32 = unsafe { ::std::mem::transmute(qp_prime_y) };
7302 __bindgen_bitfield_unit.set(104usize, 17u8, {
7303 let reserved5: u32 = unsafe { ::std::mem::transmute(reserved5) };
7306 __bindgen_bitfield_unit.set(121usize, 1u8, {
7307 let mb_skip_conv_disable: u32 = unsafe { ::std::mem::transmute(mb_skip_conv_disable) };
7308 mb_skip_conv_disable as u64
7310 __bindgen_bitfield_unit.set(122usize, 1u8, {
7311 let is_last_mb: u32 = unsafe { ::std::mem::transmute(is_last_mb) };
7314 __bindgen_bitfield_unit.set(123usize, 1u8, {
7315 let enable_coefficient_clamp: u32 =
7316 unsafe { ::std::mem::transmute(enable_coefficient_clamp) };
7317 enable_coefficient_clamp as u64
7319 __bindgen_bitfield_unit.set(124usize, 4u8, {
7320 let direct8x8_pattern: u32 = unsafe { ::std::mem::transmute(direct8x8_pattern) };
7321 direct8x8_pattern as u64
7323 __bindgen_bitfield_unit
7326 pub fn reserved8(&self) -> u32 {
7327 unsafe { ::std::mem::transmute(self._bitfield_2.get(0usize, 16u8) as u32) }
7330 pub fn set_reserved8(&mut self, val: u32) {
7332 let val: u32 = ::std::mem::transmute(val);
7333 self._bitfield_2.set(0usize, 16u8, val as u64)
7337 pub fn target_size_in_word(&self) -> u32 {
7338 unsafe { ::std::mem::transmute(self._bitfield_2.get(16usize, 8u8) as u32) }
7341 pub fn set_target_size_in_word(&mut self, val: u32) {
7343 let val: u32 = ::std::mem::transmute(val);
7344 self._bitfield_2.set(16usize, 8u8, val as u64)
7348 pub fn max_size_in_word(&self) -> u32 {
7349 unsafe { ::std::mem::transmute(self._bitfield_2.get(24usize, 8u8) as u32) }
7352 pub fn set_max_size_in_word(&mut self, val: u32) {
7354 let val: u32 = ::std::mem::transmute(val);
7355 self._bitfield_2.set(24usize, 8u8, val as u64)
7359 pub fn new_bitfield_2(
7361 target_size_in_word: u32,
7362 max_size_in_word: u32,
7363 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
7364 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
7365 __bindgen_bitfield_unit.set(0usize, 16u8, {
7366 let reserved8: u32 = unsafe { ::std::mem::transmute(reserved8) };
7369 __bindgen_bitfield_unit.set(16usize, 8u8, {
7370 let target_size_in_word: u32 = unsafe { ::std::mem::transmute(target_size_in_word) };
7371 target_size_in_word as u64
7373 __bindgen_bitfield_unit.set(24usize, 8u8, {
7374 let max_size_in_word: u32 = unsafe { ::std::mem::transmute(max_size_in_word) };
7375 max_size_in_word as u64
7377 __bindgen_bitfield_unit
7380 pub type VAEncFEIMBCodeH264 = _VAEncFEIMBCodeH264;
7382 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
7383 pub struct _VAEncFEIDistortionH264 {
7384 pub inter_distortion: [u16; 16usize],
7385 pub _bitfield_align_1: [u16; 0],
7386 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
7387 pub reserved1: [u32; 2usize],
7389 impl _VAEncFEIDistortionH264 {
7391 pub fn best_inter_distortion(&self) -> u32 {
7392 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 16u8) as u32) }
7395 pub fn set_best_inter_distortion(&mut self, val: u32) {
7397 let val: u32 = ::std::mem::transmute(val);
7398 self._bitfield_1.set(0usize, 16u8, val as u64)
7402 pub fn best_intra_distortion(&self) -> u32 {
7403 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 16u8) as u32) }
7406 pub fn set_best_intra_distortion(&mut self, val: u32) {
7408 let val: u32 = ::std::mem::transmute(val);
7409 self._bitfield_1.set(16usize, 16u8, val as u64)
7413 pub fn colocated_mb_distortion(&self) -> u32 {
7414 unsafe { ::std::mem::transmute(self._bitfield_1.get(32usize, 16u8) as u32) }
7417 pub fn set_colocated_mb_distortion(&mut self, val: u32) {
7419 let val: u32 = ::std::mem::transmute(val);
7420 self._bitfield_1.set(32usize, 16u8, val as u64)
7424 pub fn reserved0(&self) -> u32 {
7425 unsafe { ::std::mem::transmute(self._bitfield_1.get(48usize, 16u8) as u32) }
7428 pub fn set_reserved0(&mut self, val: u32) {
7430 let val: u32 = ::std::mem::transmute(val);
7431 self._bitfield_1.set(48usize, 16u8, val as u64)
7435 pub fn new_bitfield_1(
7436 best_inter_distortion: u32,
7437 best_intra_distortion: u32,
7438 colocated_mb_distortion: u32,
7440 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
7441 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
7442 __bindgen_bitfield_unit.set(0usize, 16u8, {
7443 let best_inter_distortion: u32 =
7444 unsafe { ::std::mem::transmute(best_inter_distortion) };
7445 best_inter_distortion as u64
7447 __bindgen_bitfield_unit.set(16usize, 16u8, {
7448 let best_intra_distortion: u32 =
7449 unsafe { ::std::mem::transmute(best_intra_distortion) };
7450 best_intra_distortion as u64
7452 __bindgen_bitfield_unit.set(32usize, 16u8, {
7453 let colocated_mb_distortion: u32 =
7454 unsafe { ::std::mem::transmute(colocated_mb_distortion) };
7455 colocated_mb_distortion as u64
7457 __bindgen_bitfield_unit.set(48usize, 16u8, {
7458 let reserved0: u32 = unsafe { ::std::mem::transmute(reserved0) };
7461 __bindgen_bitfield_unit
7464 pub type VAEncFEIDistortionH264 = _VAEncFEIDistortionH264;
7466 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
7467 pub struct _VAStatsStatisticsParameterH264 {
7468 pub stats_params: VAStatsStatisticsParameter,
7469 pub _bitfield_align_1: [u32; 0],
7470 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 16usize]>,
7471 pub reserved4: [u32; 2usize],
7473 impl Default for _VAStatsStatisticsParameterH264 {
7474 fn default() -> Self {
7475 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7477 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7482 impl _VAStatsStatisticsParameterH264 {
7484 pub fn frame_qp(&self) -> u32 {
7485 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 8u8) as u32) }
7488 pub fn set_frame_qp(&mut self, val: u32) {
7490 let val: u32 = ::std::mem::transmute(val);
7491 self._bitfield_1.set(0usize, 8u8, val as u64)
7495 pub fn len_sp(&self) -> u32 {
7496 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 8u8) as u32) }
7499 pub fn set_len_sp(&mut self, val: u32) {
7501 let val: u32 = ::std::mem::transmute(val);
7502 self._bitfield_1.set(8usize, 8u8, val as u64)
7506 pub fn search_path(&self) -> u32 {
7507 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 8u8) as u32) }
7510 pub fn set_search_path(&mut self, val: u32) {
7512 let val: u32 = ::std::mem::transmute(val);
7513 self._bitfield_1.set(16usize, 8u8, val as u64)
7517 pub fn reserved0(&self) -> u32 {
7518 unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 8u8) as u32) }
7521 pub fn set_reserved0(&mut self, val: u32) {
7523 let val: u32 = ::std::mem::transmute(val);
7524 self._bitfield_1.set(24usize, 8u8, val as u64)
7528 pub fn sub_mb_part_mask(&self) -> u32 {
7529 unsafe { ::std::mem::transmute(self._bitfield_1.get(32usize, 7u8) as u32) }
7532 pub fn set_sub_mb_part_mask(&mut self, val: u32) {
7534 let val: u32 = ::std::mem::transmute(val);
7535 self._bitfield_1.set(32usize, 7u8, val as u64)
7539 pub fn sub_pel_mode(&self) -> u32 {
7540 unsafe { ::std::mem::transmute(self._bitfield_1.get(39usize, 2u8) as u32) }
7543 pub fn set_sub_pel_mode(&mut self, val: u32) {
7545 let val: u32 = ::std::mem::transmute(val);
7546 self._bitfield_1.set(39usize, 2u8, val as u64)
7550 pub fn inter_sad(&self) -> u32 {
7551 unsafe { ::std::mem::transmute(self._bitfield_1.get(41usize, 2u8) as u32) }
7554 pub fn set_inter_sad(&mut self, val: u32) {
7556 let val: u32 = ::std::mem::transmute(val);
7557 self._bitfield_1.set(41usize, 2u8, val as u64)
7561 pub fn intra_sad(&self) -> u32 {
7562 unsafe { ::std::mem::transmute(self._bitfield_1.get(43usize, 2u8) as u32) }
7565 pub fn set_intra_sad(&mut self, val: u32) {
7567 let val: u32 = ::std::mem::transmute(val);
7568 self._bitfield_1.set(43usize, 2u8, val as u64)
7572 pub fn adaptive_search(&self) -> u32 {
7573 unsafe { ::std::mem::transmute(self._bitfield_1.get(45usize, 1u8) as u32) }
7576 pub fn set_adaptive_search(&mut self, val: u32) {
7578 let val: u32 = ::std::mem::transmute(val);
7579 self._bitfield_1.set(45usize, 1u8, val as u64)
7583 pub fn mv_predictor_ctrl(&self) -> u32 {
7584 unsafe { ::std::mem::transmute(self._bitfield_1.get(46usize, 3u8) as u32) }
7587 pub fn set_mv_predictor_ctrl(&mut self, val: u32) {
7589 let val: u32 = ::std::mem::transmute(val);
7590 self._bitfield_1.set(46usize, 3u8, val as u64)
7594 pub fn mb_qp(&self) -> u32 {
7595 unsafe { ::std::mem::transmute(self._bitfield_1.get(49usize, 1u8) as u32) }
7598 pub fn set_mb_qp(&mut self, val: u32) {
7600 let val: u32 = ::std::mem::transmute(val);
7601 self._bitfield_1.set(49usize, 1u8, val as u64)
7605 pub fn ft_enable(&self) -> u32 {
7606 unsafe { ::std::mem::transmute(self._bitfield_1.get(50usize, 1u8) as u32) }
7609 pub fn set_ft_enable(&mut self, val: u32) {
7611 let val: u32 = ::std::mem::transmute(val);
7612 self._bitfield_1.set(50usize, 1u8, val as u64)
7616 pub fn intra_part_mask(&self) -> u32 {
7617 unsafe { ::std::mem::transmute(self._bitfield_1.get(51usize, 5u8) as u32) }
7620 pub fn set_intra_part_mask(&mut self, val: u32) {
7622 let val: u32 = ::std::mem::transmute(val);
7623 self._bitfield_1.set(51usize, 5u8, val as u64)
7627 pub fn reserved1(&self) -> u32 {
7628 unsafe { ::std::mem::transmute(self._bitfield_1.get(56usize, 8u8) as u32) }
7631 pub fn set_reserved1(&mut self, val: u32) {
7633 let val: u32 = ::std::mem::transmute(val);
7634 self._bitfield_1.set(56usize, 8u8, val as u64)
7638 pub fn ref_width(&self) -> u32 {
7639 unsafe { ::std::mem::transmute(self._bitfield_1.get(64usize, 8u8) as u32) }
7642 pub fn set_ref_width(&mut self, val: u32) {
7644 let val: u32 = ::std::mem::transmute(val);
7645 self._bitfield_1.set(64usize, 8u8, val as u64)
7649 pub fn ref_height(&self) -> u32 {
7650 unsafe { ::std::mem::transmute(self._bitfield_1.get(72usize, 8u8) as u32) }
7653 pub fn set_ref_height(&mut self, val: u32) {
7655 let val: u32 = ::std::mem::transmute(val);
7656 self._bitfield_1.set(72usize, 8u8, val as u64)
7660 pub fn search_window(&self) -> u32 {
7661 unsafe { ::std::mem::transmute(self._bitfield_1.get(80usize, 4u8) as u32) }
7664 pub fn set_search_window(&mut self, val: u32) {
7666 let val: u32 = ::std::mem::transmute(val);
7667 self._bitfield_1.set(80usize, 4u8, val as u64)
7671 pub fn reserved2(&self) -> u32 {
7672 unsafe { ::std::mem::transmute(self._bitfield_1.get(84usize, 12u8) as u32) }
7675 pub fn set_reserved2(&mut self, val: u32) {
7677 let val: u32 = ::std::mem::transmute(val);
7678 self._bitfield_1.set(84usize, 12u8, val as u64)
7682 pub fn disable_mv_output(&self) -> u32 {
7683 unsafe { ::std::mem::transmute(self._bitfield_1.get(96usize, 1u8) as u32) }
7686 pub fn set_disable_mv_output(&mut self, val: u32) {
7688 let val: u32 = ::std::mem::transmute(val);
7689 self._bitfield_1.set(96usize, 1u8, val as u64)
7693 pub fn disable_statistics_output(&self) -> u32 {
7694 unsafe { ::std::mem::transmute(self._bitfield_1.get(97usize, 1u8) as u32) }
7697 pub fn set_disable_statistics_output(&mut self, val: u32) {
7699 let val: u32 = ::std::mem::transmute(val);
7700 self._bitfield_1.set(97usize, 1u8, val as u64)
7704 pub fn enable_8x8_statistics(&self) -> u32 {
7705 unsafe { ::std::mem::transmute(self._bitfield_1.get(98usize, 1u8) as u32) }
7708 pub fn set_enable_8x8_statistics(&mut self, val: u32) {
7710 let val: u32 = ::std::mem::transmute(val);
7711 self._bitfield_1.set(98usize, 1u8, val as u64)
7715 pub fn reserved3(&self) -> u32 {
7716 unsafe { ::std::mem::transmute(self._bitfield_1.get(99usize, 29u8) as u32) }
7719 pub fn set_reserved3(&mut self, val: u32) {
7721 let val: u32 = ::std::mem::transmute(val);
7722 self._bitfield_1.set(99usize, 29u8, val as u64)
7726 pub fn new_bitfield_1(
7731 sub_mb_part_mask: u32,
7735 adaptive_search: u32,
7736 mv_predictor_ctrl: u32,
7739 intra_part_mask: u32,
7745 disable_mv_output: u32,
7746 disable_statistics_output: u32,
7747 enable_8x8_statistics: u32,
7749 ) -> __BindgenBitfieldUnit<[u8; 16usize]> {
7750 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 16usize]> = Default::default();
7751 __bindgen_bitfield_unit.set(0usize, 8u8, {
7752 let frame_qp: u32 = unsafe { ::std::mem::transmute(frame_qp) };
7755 __bindgen_bitfield_unit.set(8usize, 8u8, {
7756 let len_sp: u32 = unsafe { ::std::mem::transmute(len_sp) };
7759 __bindgen_bitfield_unit.set(16usize, 8u8, {
7760 let search_path: u32 = unsafe { ::std::mem::transmute(search_path) };
7763 __bindgen_bitfield_unit.set(24usize, 8u8, {
7764 let reserved0: u32 = unsafe { ::std::mem::transmute(reserved0) };
7767 __bindgen_bitfield_unit.set(32usize, 7u8, {
7768 let sub_mb_part_mask: u32 = unsafe { ::std::mem::transmute(sub_mb_part_mask) };
7769 sub_mb_part_mask as u64
7771 __bindgen_bitfield_unit.set(39usize, 2u8, {
7772 let sub_pel_mode: u32 = unsafe { ::std::mem::transmute(sub_pel_mode) };
7775 __bindgen_bitfield_unit.set(41usize, 2u8, {
7776 let inter_sad: u32 = unsafe { ::std::mem::transmute(inter_sad) };
7779 __bindgen_bitfield_unit.set(43usize, 2u8, {
7780 let intra_sad: u32 = unsafe { ::std::mem::transmute(intra_sad) };
7783 __bindgen_bitfield_unit.set(45usize, 1u8, {
7784 let adaptive_search: u32 = unsafe { ::std::mem::transmute(adaptive_search) };
7785 adaptive_search as u64
7787 __bindgen_bitfield_unit.set(46usize, 3u8, {
7788 let mv_predictor_ctrl: u32 = unsafe { ::std::mem::transmute(mv_predictor_ctrl) };
7789 mv_predictor_ctrl as u64
7791 __bindgen_bitfield_unit.set(49usize, 1u8, {
7792 let mb_qp: u32 = unsafe { ::std::mem::transmute(mb_qp) };
7795 __bindgen_bitfield_unit.set(50usize, 1u8, {
7796 let ft_enable: u32 = unsafe { ::std::mem::transmute(ft_enable) };
7799 __bindgen_bitfield_unit.set(51usize, 5u8, {
7800 let intra_part_mask: u32 = unsafe { ::std::mem::transmute(intra_part_mask) };
7801 intra_part_mask as u64
7803 __bindgen_bitfield_unit.set(56usize, 8u8, {
7804 let reserved1: u32 = unsafe { ::std::mem::transmute(reserved1) };
7807 __bindgen_bitfield_unit.set(64usize, 8u8, {
7808 let ref_width: u32 = unsafe { ::std::mem::transmute(ref_width) };
7811 __bindgen_bitfield_unit.set(72usize, 8u8, {
7812 let ref_height: u32 = unsafe { ::std::mem::transmute(ref_height) };
7815 __bindgen_bitfield_unit.set(80usize, 4u8, {
7816 let search_window: u32 = unsafe { ::std::mem::transmute(search_window) };
7817 search_window as u64
7819 __bindgen_bitfield_unit.set(84usize, 12u8, {
7820 let reserved2: u32 = unsafe { ::std::mem::transmute(reserved2) };
7823 __bindgen_bitfield_unit.set(96usize, 1u8, {
7824 let disable_mv_output: u32 = unsafe { ::std::mem::transmute(disable_mv_output) };
7825 disable_mv_output as u64
7827 __bindgen_bitfield_unit.set(97usize, 1u8, {
7828 let disable_statistics_output: u32 =
7829 unsafe { ::std::mem::transmute(disable_statistics_output) };
7830 disable_statistics_output as u64
7832 __bindgen_bitfield_unit.set(98usize, 1u8, {
7833 let enable_8x8_statistics: u32 =
7834 unsafe { ::std::mem::transmute(enable_8x8_statistics) };
7835 enable_8x8_statistics as u64
7837 __bindgen_bitfield_unit.set(99usize, 29u8, {
7838 let reserved3: u32 = unsafe { ::std::mem::transmute(reserved3) };
7841 __bindgen_bitfield_unit
7844 pub type VAStatsStatisticsParameterH264 = _VAStatsStatisticsParameterH264;
7846 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
7847 pub struct _VAStatsStatisticsH264 {
7848 pub _bitfield_align_1: [u16; 0],
7849 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 16usize]>,
7851 pub _bitfield_align_2: [u32; 0],
7852 pub _bitfield_2: __BindgenBitfieldUnit<[u8; 4usize]>,
7853 pub variance_16x16: u32,
7854 pub variance_8x8: [u32; 4usize],
7855 pub pixel_average_16x16: u32,
7856 pub pixel_average_8x8: [u32; 4usize],
7858 impl _VAStatsStatisticsH264 {
7860 pub fn best_inter_distortion0(&self) -> u32 {
7861 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 16u8) as u32) }
7864 pub fn set_best_inter_distortion0(&mut self, val: u32) {
7866 let val: u32 = ::std::mem::transmute(val);
7867 self._bitfield_1.set(0usize, 16u8, val as u64)
7871 pub fn inter_mode0(&self) -> u32 {
7872 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 16u8) as u32) }
7875 pub fn set_inter_mode0(&mut self, val: u32) {
7877 let val: u32 = ::std::mem::transmute(val);
7878 self._bitfield_1.set(16usize, 16u8, val as u64)
7882 pub fn best_inter_distortion1(&self) -> u32 {
7883 unsafe { ::std::mem::transmute(self._bitfield_1.get(32usize, 16u8) as u32) }
7886 pub fn set_best_inter_distortion1(&mut self, val: u32) {
7888 let val: u32 = ::std::mem::transmute(val);
7889 self._bitfield_1.set(32usize, 16u8, val as u64)
7893 pub fn inter_mode1(&self) -> u32 {
7894 unsafe { ::std::mem::transmute(self._bitfield_1.get(48usize, 16u8) as u32) }
7897 pub fn set_inter_mode1(&mut self, val: u32) {
7899 let val: u32 = ::std::mem::transmute(val);
7900 self._bitfield_1.set(48usize, 16u8, val as u64)
7904 pub fn best_intra_distortion(&self) -> u32 {
7905 unsafe { ::std::mem::transmute(self._bitfield_1.get(64usize, 16u8) as u32) }
7908 pub fn set_best_intra_distortion(&mut self, val: u32) {
7910 let val: u32 = ::std::mem::transmute(val);
7911 self._bitfield_1.set(64usize, 16u8, val as u64)
7915 pub fn intra_mode(&self) -> u32 {
7916 unsafe { ::std::mem::transmute(self._bitfield_1.get(80usize, 16u8) as u32) }
7919 pub fn set_intra_mode(&mut self, val: u32) {
7921 let val: u32 = ::std::mem::transmute(val);
7922 self._bitfield_1.set(80usize, 16u8, val as u64)
7926 pub fn num_non_zero_coef(&self) -> u32 {
7927 unsafe { ::std::mem::transmute(self._bitfield_1.get(96usize, 16u8) as u32) }
7930 pub fn set_num_non_zero_coef(&mut self, val: u32) {
7932 let val: u32 = ::std::mem::transmute(val);
7933 self._bitfield_1.set(96usize, 16u8, val as u64)
7937 pub fn reserved0(&self) -> u32 {
7938 unsafe { ::std::mem::transmute(self._bitfield_1.get(112usize, 16u8) as u32) }
7941 pub fn set_reserved0(&mut self, val: u32) {
7943 let val: u32 = ::std::mem::transmute(val);
7944 self._bitfield_1.set(112usize, 16u8, val as u64)
7948 pub fn new_bitfield_1(
7949 best_inter_distortion0: u32,
7951 best_inter_distortion1: u32,
7953 best_intra_distortion: u32,
7955 num_non_zero_coef: u32,
7957 ) -> __BindgenBitfieldUnit<[u8; 16usize]> {
7958 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 16usize]> = Default::default();
7959 __bindgen_bitfield_unit.set(0usize, 16u8, {
7960 let best_inter_distortion0: u32 =
7961 unsafe { ::std::mem::transmute(best_inter_distortion0) };
7962 best_inter_distortion0 as u64
7964 __bindgen_bitfield_unit.set(16usize, 16u8, {
7965 let inter_mode0: u32 = unsafe { ::std::mem::transmute(inter_mode0) };
7968 __bindgen_bitfield_unit.set(32usize, 16u8, {
7969 let best_inter_distortion1: u32 =
7970 unsafe { ::std::mem::transmute(best_inter_distortion1) };
7971 best_inter_distortion1 as u64
7973 __bindgen_bitfield_unit.set(48usize, 16u8, {
7974 let inter_mode1: u32 = unsafe { ::std::mem::transmute(inter_mode1) };
7977 __bindgen_bitfield_unit.set(64usize, 16u8, {
7978 let best_intra_distortion: u32 =
7979 unsafe { ::std::mem::transmute(best_intra_distortion) };
7980 best_intra_distortion as u64
7982 __bindgen_bitfield_unit.set(80usize, 16u8, {
7983 let intra_mode: u32 = unsafe { ::std::mem::transmute(intra_mode) };
7986 __bindgen_bitfield_unit.set(96usize, 16u8, {
7987 let num_non_zero_coef: u32 = unsafe { ::std::mem::transmute(num_non_zero_coef) };
7988 num_non_zero_coef as u64
7990 __bindgen_bitfield_unit.set(112usize, 16u8, {
7991 let reserved0: u32 = unsafe { ::std::mem::transmute(reserved0) };
7994 __bindgen_bitfield_unit
7997 pub fn mb_is_flat(&self) -> u32 {
7998 unsafe { ::std::mem::transmute(self._bitfield_2.get(0usize, 1u8) as u32) }
8001 pub fn set_mb_is_flat(&mut self, val: u32) {
8003 let val: u32 = ::std::mem::transmute(val);
8004 self._bitfield_2.set(0usize, 1u8, val as u64)
8008 pub fn reserved1(&self) -> u32 {
8009 unsafe { ::std::mem::transmute(self._bitfield_2.get(1usize, 31u8) as u32) }
8012 pub fn set_reserved1(&mut self, val: u32) {
8014 let val: u32 = ::std::mem::transmute(val);
8015 self._bitfield_2.set(1usize, 31u8, val as u64)
8019 pub fn new_bitfield_2(mb_is_flat: u32, reserved1: u32) -> __BindgenBitfieldUnit<[u8; 4usize]> {
8020 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
8021 __bindgen_bitfield_unit.set(0usize, 1u8, {
8022 let mb_is_flat: u32 = unsafe { ::std::mem::transmute(mb_is_flat) };
8025 __bindgen_bitfield_unit.set(1usize, 31u8, {
8026 let reserved1: u32 = unsafe { ::std::mem::transmute(reserved1) };
8029 __bindgen_bitfield_unit
8032 pub type VAStatsStatisticsH264 = _VAStatsStatisticsH264;
8033 pub const _VAProcFilterType_VAProcFilterNone: _VAProcFilterType = 0;
8034 pub const _VAProcFilterType_VAProcFilterNoiseReduction: _VAProcFilterType = 1;
8035 pub const _VAProcFilterType_VAProcFilterDeinterlacing: _VAProcFilterType = 2;
8036 pub const _VAProcFilterType_VAProcFilterSharpening: _VAProcFilterType = 3;
8037 pub const _VAProcFilterType_VAProcFilterColorBalance: _VAProcFilterType = 4;
8038 pub const _VAProcFilterType_VAProcFilterSkinToneEnhancement: _VAProcFilterType = 5;
8039 pub const _VAProcFilterType_VAProcFilterTotalColorCorrection: _VAProcFilterType = 6;
8040 pub const _VAProcFilterType_VAProcFilterHVSNoiseReduction: _VAProcFilterType = 7;
8041 pub const _VAProcFilterType_VAProcFilterHighDynamicRangeToneMapping: _VAProcFilterType = 8;
8042 pub const _VAProcFilterType_VAProcFilter3DLUT: _VAProcFilterType = 9;
8043 pub const _VAProcFilterType_VAProcFilterCount: _VAProcFilterType = 10;
8044 pub type _VAProcFilterType = ::std::os::raw::c_uint;
8045 pub use self::_VAProcFilterType as VAProcFilterType;
8046 pub const _VAProcColorStandardType_VAProcColorStandardNone: _VAProcColorStandardType = 0;
8047 pub const _VAProcColorStandardType_VAProcColorStandardBT601: _VAProcColorStandardType = 1;
8048 pub const _VAProcColorStandardType_VAProcColorStandardBT709: _VAProcColorStandardType = 2;
8049 pub const _VAProcColorStandardType_VAProcColorStandardBT470M: _VAProcColorStandardType = 3;
8050 pub const _VAProcColorStandardType_VAProcColorStandardBT470BG: _VAProcColorStandardType = 4;
8051 pub const _VAProcColorStandardType_VAProcColorStandardSMPTE170M: _VAProcColorStandardType = 5;
8052 pub const _VAProcColorStandardType_VAProcColorStandardSMPTE240M: _VAProcColorStandardType = 6;
8053 pub const _VAProcColorStandardType_VAProcColorStandardGenericFilm: _VAProcColorStandardType = 7;
8054 pub const _VAProcColorStandardType_VAProcColorStandardSRGB: _VAProcColorStandardType = 8;
8055 pub const _VAProcColorStandardType_VAProcColorStandardSTRGB: _VAProcColorStandardType = 9;
8056 pub const _VAProcColorStandardType_VAProcColorStandardXVYCC601: _VAProcColorStandardType = 10;
8057 pub const _VAProcColorStandardType_VAProcColorStandardXVYCC709: _VAProcColorStandardType = 11;
8058 pub const _VAProcColorStandardType_VAProcColorStandardBT2020: _VAProcColorStandardType = 12;
8059 pub const _VAProcColorStandardType_VAProcColorStandardExplicit: _VAProcColorStandardType = 13;
8060 pub const _VAProcColorStandardType_VAProcColorStandardCount: _VAProcColorStandardType = 14;
8061 pub type _VAProcColorStandardType = ::std::os::raw::c_uint;
8062 pub use self::_VAProcColorStandardType as VAProcColorStandardType;
8064 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
8065 pub struct _VAProcPipelineCaps {
8066 pub pipeline_flags: u32,
8067 pub filter_flags: u32,
8068 pub num_forward_references: u32,
8069 pub num_backward_references: u32,
8070 pub input_color_standards: *mut VAProcColorStandardType,
8071 pub num_input_color_standards: u32,
8072 pub output_color_standards: *mut VAProcColorStandardType,
8073 pub num_output_color_standards: u32,
8074 pub rotation_flags: u32,
8075 pub blend_flags: u32,
8076 pub mirror_flags: u32,
8077 pub num_additional_outputs: u32,
8078 pub num_input_pixel_formats: u32,
8079 pub input_pixel_format: *mut u32,
8080 pub num_output_pixel_formats: u32,
8081 pub output_pixel_format: *mut u32,
8082 pub max_input_width: u32,
8083 pub max_input_height: u32,
8084 pub min_input_width: u32,
8085 pub min_input_height: u32,
8086 pub max_output_width: u32,
8087 pub max_output_height: u32,
8088 pub min_output_width: u32,
8089 pub min_output_height: u32,
8090 pub va_reserved: [u32; 14usize],
8092 impl Default for _VAProcPipelineCaps {
8093 fn default() -> Self {
8094 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
8096 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
8101 pub type VAProcPipelineCaps = _VAProcPipelineCaps;
8103 pub fn vaQueryVideoProcFilters(
8105 context: VAContextID,
8106 filters: *mut VAProcFilterType,
8107 num_filters: *mut ::std::os::raw::c_uint,
8111 pub fn vaQueryVideoProcFilterCaps(
8113 context: VAContextID,
8114 type_: VAProcFilterType,
8115 filter_caps: *mut ::std::os::raw::c_void,
8116 num_filter_caps: *mut ::std::os::raw::c_uint,
8120 pub fn vaQueryVideoProcPipelineCaps(
8122 context: VAContextID,
8123 filters: *mut VABufferID,
8124 num_filters: ::std::os::raw::c_uint,
8125 pipeline_caps: *mut VAProcPipelineCaps,
8128 pub type VAProtectedSessionID = VAGenericID;
8130 pub fn vaCreateProtectedSession(
8132 config_id: VAConfigID,
8133 protected_session: *mut VAProtectedSessionID,
8137 pub fn vaDestroyProtectedSession(
8139 protected_session: VAProtectedSessionID,
8143 pub fn vaAttachProtectedSession(
8146 protected_session: VAProtectedSessionID,
8150 pub fn vaDetachProtectedSession(dpy: VADisplay, id: VAGenericID) -> VAStatus;
8153 pub fn vaProtectedSessionExecute(
8155 protected_session: VAProtectedSessionID,
8160 pub fn vaGetDisplayDRM(fd: ::std::os::raw::c_int) -> VADisplay;