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],
1628 pub type VAImageID = VAGenericID;
1630 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
1631 pub struct VAImage {
1632 pub image_id: VAImageID,
1633 pub format: VAImageFormat,
1634 pub buf: VABufferID,
1638 pub num_planes: u32,
1639 pub pitches: [u32; 3usize],
1640 pub offsets: [u32; 3usize],
1641 pub num_palette_entries: i32,
1642 pub entry_bytes: i32,
1643 pub component_order: [i8; 4usize],
1644 pub va_reserved: [u32; 4usize],
1647 pub fn vaMaxNumImageFormats(dpy: VADisplay) -> ::std::os::raw::c_int;
1650 pub fn vaQueryImageFormats(
1652 format_list: *mut VAImageFormat,
1653 num_formats: *mut ::std::os::raw::c_int,
1657 pub fn vaCreateImage(
1659 format: *mut VAImageFormat,
1660 width: ::std::os::raw::c_int,
1661 height: ::std::os::raw::c_int,
1662 image: *mut VAImage,
1666 pub fn vaDestroyImage(dpy: VADisplay, image: VAImageID) -> VAStatus;
1669 pub fn vaSetImagePalette(
1672 palette: *mut ::std::os::raw::c_uchar,
1678 surface: VASurfaceID,
1679 x: ::std::os::raw::c_int,
1680 y: ::std::os::raw::c_int,
1681 width: ::std::os::raw::c_uint,
1682 height: ::std::os::raw::c_uint,
1689 surface: VASurfaceID,
1691 src_x: ::std::os::raw::c_int,
1692 src_y: ::std::os::raw::c_int,
1693 src_width: ::std::os::raw::c_uint,
1694 src_height: ::std::os::raw::c_uint,
1695 dest_x: ::std::os::raw::c_int,
1696 dest_y: ::std::os::raw::c_int,
1697 dest_width: ::std::os::raw::c_uint,
1698 dest_height: ::std::os::raw::c_uint,
1702 pub fn vaDeriveImage(dpy: VADisplay, surface: VASurfaceID, image: *mut VAImage) -> VAStatus;
1704 pub type VASubpictureID = VAGenericID;
1706 pub fn vaMaxNumSubpictureFormats(dpy: VADisplay) -> ::std::os::raw::c_int;
1709 pub fn vaQuerySubpictureFormats(
1711 format_list: *mut VAImageFormat,
1712 flags: *mut ::std::os::raw::c_uint,
1713 num_formats: *mut ::std::os::raw::c_uint,
1717 pub fn vaCreateSubpicture(
1720 subpicture: *mut VASubpictureID,
1724 pub fn vaDestroySubpicture(dpy: VADisplay, subpicture: VASubpictureID) -> VAStatus;
1727 pub fn vaSetSubpictureImage(
1729 subpicture: VASubpictureID,
1734 pub fn vaSetSubpictureChromakey(
1736 subpicture: VASubpictureID,
1737 chromakey_min: ::std::os::raw::c_uint,
1738 chromakey_max: ::std::os::raw::c_uint,
1739 chromakey_mask: ::std::os::raw::c_uint,
1743 pub fn vaSetSubpictureGlobalAlpha(
1745 subpicture: VASubpictureID,
1750 pub fn vaAssociateSubpicture(
1752 subpicture: VASubpictureID,
1753 target_surfaces: *mut VASurfaceID,
1754 num_surfaces: ::std::os::raw::c_int,
1767 pub fn vaDeassociateSubpicture(
1769 subpicture: VASubpictureID,
1770 target_surfaces: *mut VASurfaceID,
1771 num_surfaces: ::std::os::raw::c_int,
1774 pub mod VADisplayAttribType {
1775 pub type Type = ::std::os::raw::c_uint;
1776 pub const VADisplayAttribBrightness: Type = 0;
1777 pub const VADisplayAttribContrast: Type = 1;
1778 pub const VADisplayAttribHue: Type = 2;
1779 pub const VADisplayAttribSaturation: Type = 3;
1780 pub const VADisplayAttribBackgroundColor: Type = 4;
1781 pub const VADisplayAttribDirectSurface: Type = 5;
1782 pub const VADisplayAttribRotation: Type = 6;
1783 pub const VADisplayAttribOutofLoopDeblock: Type = 7;
1784 pub const VADisplayAttribBLEBlackMode: Type = 8;
1785 pub const VADisplayAttribBLEWhiteMode: Type = 9;
1786 pub const VADisplayAttribBlueStretch: Type = 10;
1787 pub const VADisplayAttribSkinColorCorrection: Type = 11;
1788 pub const VADisplayAttribCSCMatrix: Type = 12;
1789 pub const VADisplayAttribBlendColor: Type = 13;
1790 pub const VADisplayAttribOverlayAutoPaintColorKey: Type = 14;
1791 pub const VADisplayAttribOverlayColorKey: Type = 15;
1792 pub const VADisplayAttribRenderMode: Type = 16;
1793 pub const VADisplayAttribRenderDevice: Type = 17;
1794 pub const VADisplayAttribRenderRect: Type = 18;
1795 pub const VADisplayAttribSubDevice: Type = 19;
1796 pub const VADisplayAttribCopy: Type = 20;
1797 pub const VADisplayPCIID: Type = 21;
1800 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
1801 pub struct _VADisplayAttribute {
1802 pub type_: VADisplayAttribType::Type,
1807 pub va_reserved: [u32; 4usize],
1809 impl Default for _VADisplayAttribute {
1810 fn default() -> Self {
1811 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1813 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1818 pub type VADisplayAttribute = _VADisplayAttribute;
1820 pub fn vaMaxNumDisplayAttributes(dpy: VADisplay) -> ::std::os::raw::c_int;
1823 pub fn vaQueryDisplayAttributes(
1825 attr_list: *mut VADisplayAttribute,
1826 num_attributes: *mut ::std::os::raw::c_int,
1830 pub fn vaGetDisplayAttributes(
1832 attr_list: *mut VADisplayAttribute,
1833 num_attributes: ::std::os::raw::c_int,
1837 pub fn vaSetDisplayAttributes(
1839 attr_list: *mut VADisplayAttribute,
1840 num_attributes: ::std::os::raw::c_int,
1843 pub mod VACopyObjectType {
1844 pub type Type = ::std::os::raw::c_uint;
1845 pub const VACopyObjectSurface: Type = 0;
1846 pub const VACopyObjectBuffer: Type = 1;
1849 #[derive(Copy, Clone)]
1850 pub struct _VACopyObject {
1851 pub obj_type: VACopyObjectType::Type,
1852 pub object: _VACopyObject__bindgen_ty_1,
1853 pub va_reserved: [u32; 8usize],
1856 #[derive(Copy, Clone)]
1857 pub union _VACopyObject__bindgen_ty_1 {
1858 pub surface_id: VASurfaceID,
1859 pub buffer_id: VABufferID,
1861 impl Default for _VACopyObject__bindgen_ty_1 {
1862 fn default() -> Self {
1863 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1865 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1870 impl Default for _VACopyObject {
1871 fn default() -> Self {
1872 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1874 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1879 pub type VACopyObject = _VACopyObject;
1881 #[derive(Copy, Clone)]
1882 pub union _VACopyOption {
1883 pub bits: _VACopyOption__bindgen_ty_1,
1888 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
1889 pub struct _VACopyOption__bindgen_ty_1 {
1890 pub _bitfield_align_1: [u32; 0],
1891 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
1893 impl _VACopyOption__bindgen_ty_1 {
1895 pub fn va_copy_sync(&self) -> u32 {
1896 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u32) }
1899 pub fn set_va_copy_sync(&mut self, val: u32) {
1901 let val: u32 = ::std::mem::transmute(val);
1902 self._bitfield_1.set(0usize, 2u8, val as u64)
1906 pub fn va_copy_mode(&self) -> u32 {
1907 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 4u8) as u32) }
1910 pub fn set_va_copy_mode(&mut self, val: u32) {
1912 let val: u32 = ::std::mem::transmute(val);
1913 self._bitfield_1.set(2usize, 4u8, val as u64)
1917 pub fn reserved(&self) -> u32 {
1918 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 26u8) as u32) }
1921 pub fn set_reserved(&mut self, val: u32) {
1923 let val: u32 = ::std::mem::transmute(val);
1924 self._bitfield_1.set(6usize, 26u8, val as u64)
1928 pub fn new_bitfield_1(
1932 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
1933 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
1934 __bindgen_bitfield_unit.set(0usize, 2u8, {
1935 let va_copy_sync: u32 = unsafe { ::std::mem::transmute(va_copy_sync) };
1938 __bindgen_bitfield_unit.set(2usize, 4u8, {
1939 let va_copy_mode: u32 = unsafe { ::std::mem::transmute(va_copy_mode) };
1942 __bindgen_bitfield_unit.set(6usize, 26u8, {
1943 let reserved: u32 = unsafe { ::std::mem::transmute(reserved) };
1946 __bindgen_bitfield_unit
1949 impl Default for _VACopyOption {
1950 fn default() -> Self {
1951 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1953 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1958 pub type VACopyOption = _VACopyOption;
1962 dst: *mut VACopyObject,
1963 src: *mut VACopyObject,
1964 option: VACopyOption,
1968 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
1969 pub struct _VABoolCoderContextVPX {
1974 pub type VABoolCoderContextVPX = _VABoolCoderContextVPX;
1976 #[derive(Copy, Clone)]
1977 pub struct _VAPictureParameterBufferVP8 {
1978 pub frame_width: u32,
1979 pub frame_height: u32,
1980 pub last_ref_frame: VASurfaceID,
1981 pub golden_ref_frame: VASurfaceID,
1982 pub alt_ref_frame: VASurfaceID,
1983 pub out_of_loop_frame: VASurfaceID,
1984 pub pic_fields: _VAPictureParameterBufferVP8__bindgen_ty_1,
1985 pub mb_segment_tree_probs: [u8; 3usize],
1986 pub loop_filter_level: [u8; 4usize],
1987 pub loop_filter_deltas_ref_frame: [i8; 4usize],
1988 pub loop_filter_deltas_mode: [i8; 4usize],
1989 pub prob_skip_false: u8,
1993 pub y_mode_probs: [u8; 4usize],
1994 pub uv_mode_probs: [u8; 3usize],
1995 pub mv_probs: [[u8; 19usize]; 2usize],
1996 pub bool_coder_ctx: VABoolCoderContextVPX,
1997 pub va_reserved: [u32; 4usize],
2000 #[derive(Copy, Clone)]
2001 pub union _VAPictureParameterBufferVP8__bindgen_ty_1 {
2002 pub bits: _VAPictureParameterBufferVP8__bindgen_ty_1__bindgen_ty_1,
2007 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
2008 pub struct _VAPictureParameterBufferVP8__bindgen_ty_1__bindgen_ty_1 {
2009 pub _bitfield_align_1: [u8; 0],
2010 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 3usize]>,
2011 pub __bindgen_padding_0: u8,
2013 impl _VAPictureParameterBufferVP8__bindgen_ty_1__bindgen_ty_1 {
2015 pub fn key_frame(&self) -> u32 {
2016 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
2019 pub fn set_key_frame(&mut self, val: u32) {
2021 let val: u32 = ::std::mem::transmute(val);
2022 self._bitfield_1.set(0usize, 1u8, val as u64)
2026 pub fn version(&self) -> u32 {
2027 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 3u8) as u32) }
2030 pub fn set_version(&mut self, val: u32) {
2032 let val: u32 = ::std::mem::transmute(val);
2033 self._bitfield_1.set(1usize, 3u8, val as u64)
2037 pub fn segmentation_enabled(&self) -> u32 {
2038 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
2041 pub fn set_segmentation_enabled(&mut self, val: u32) {
2043 let val: u32 = ::std::mem::transmute(val);
2044 self._bitfield_1.set(4usize, 1u8, val as u64)
2048 pub fn update_mb_segmentation_map(&self) -> u32 {
2049 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
2052 pub fn set_update_mb_segmentation_map(&mut self, val: u32) {
2054 let val: u32 = ::std::mem::transmute(val);
2055 self._bitfield_1.set(5usize, 1u8, val as u64)
2059 pub fn update_segment_feature_data(&self) -> u32 {
2060 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) }
2063 pub fn set_update_segment_feature_data(&mut self, val: u32) {
2065 let val: u32 = ::std::mem::transmute(val);
2066 self._bitfield_1.set(6usize, 1u8, val as u64)
2070 pub fn filter_type(&self) -> u32 {
2071 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) }
2074 pub fn set_filter_type(&mut self, val: u32) {
2076 let val: u32 = ::std::mem::transmute(val);
2077 self._bitfield_1.set(7usize, 1u8, val as u64)
2081 pub fn sharpness_level(&self) -> u32 {
2082 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 3u8) as u32) }
2085 pub fn set_sharpness_level(&mut self, val: u32) {
2087 let val: u32 = ::std::mem::transmute(val);
2088 self._bitfield_1.set(8usize, 3u8, val as u64)
2092 pub fn loop_filter_adj_enable(&self) -> u32 {
2093 unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) }
2096 pub fn set_loop_filter_adj_enable(&mut self, val: u32) {
2098 let val: u32 = ::std::mem::transmute(val);
2099 self._bitfield_1.set(11usize, 1u8, val as u64)
2103 pub fn mode_ref_lf_delta_update(&self) -> u32 {
2104 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u32) }
2107 pub fn set_mode_ref_lf_delta_update(&mut self, val: u32) {
2109 let val: u32 = ::std::mem::transmute(val);
2110 self._bitfield_1.set(12usize, 1u8, val as u64)
2114 pub fn sign_bias_golden(&self) -> u32 {
2115 unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) }
2118 pub fn set_sign_bias_golden(&mut self, val: u32) {
2120 let val: u32 = ::std::mem::transmute(val);
2121 self._bitfield_1.set(13usize, 1u8, val as u64)
2125 pub fn sign_bias_alternate(&self) -> u32 {
2126 unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) }
2129 pub fn set_sign_bias_alternate(&mut self, val: u32) {
2131 let val: u32 = ::std::mem::transmute(val);
2132 self._bitfield_1.set(14usize, 1u8, val as u64)
2136 pub fn mb_no_coeff_skip(&self) -> u32 {
2137 unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u32) }
2140 pub fn set_mb_no_coeff_skip(&mut self, val: u32) {
2142 let val: u32 = ::std::mem::transmute(val);
2143 self._bitfield_1.set(15usize, 1u8, val as u64)
2147 pub fn loop_filter_disable(&self) -> u32 {
2148 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u32) }
2151 pub fn set_loop_filter_disable(&mut self, val: u32) {
2153 let val: u32 = ::std::mem::transmute(val);
2154 self._bitfield_1.set(16usize, 1u8, val as u64)
2158 pub fn new_bitfield_1(
2161 segmentation_enabled: u32,
2162 update_mb_segmentation_map: u32,
2163 update_segment_feature_data: u32,
2165 sharpness_level: u32,
2166 loop_filter_adj_enable: u32,
2167 mode_ref_lf_delta_update: u32,
2168 sign_bias_golden: u32,
2169 sign_bias_alternate: u32,
2170 mb_no_coeff_skip: u32,
2171 loop_filter_disable: u32,
2172 ) -> __BindgenBitfieldUnit<[u8; 3usize]> {
2173 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 3usize]> = Default::default();
2174 __bindgen_bitfield_unit.set(0usize, 1u8, {
2175 let key_frame: u32 = unsafe { ::std::mem::transmute(key_frame) };
2178 __bindgen_bitfield_unit.set(1usize, 3u8, {
2179 let version: u32 = unsafe { ::std::mem::transmute(version) };
2182 __bindgen_bitfield_unit.set(4usize, 1u8, {
2183 let segmentation_enabled: u32 = unsafe { ::std::mem::transmute(segmentation_enabled) };
2184 segmentation_enabled as u64
2186 __bindgen_bitfield_unit.set(5usize, 1u8, {
2187 let update_mb_segmentation_map: u32 =
2188 unsafe { ::std::mem::transmute(update_mb_segmentation_map) };
2189 update_mb_segmentation_map as u64
2191 __bindgen_bitfield_unit.set(6usize, 1u8, {
2192 let update_segment_feature_data: u32 =
2193 unsafe { ::std::mem::transmute(update_segment_feature_data) };
2194 update_segment_feature_data as u64
2196 __bindgen_bitfield_unit.set(7usize, 1u8, {
2197 let filter_type: u32 = unsafe { ::std::mem::transmute(filter_type) };
2200 __bindgen_bitfield_unit.set(8usize, 3u8, {
2201 let sharpness_level: u32 = unsafe { ::std::mem::transmute(sharpness_level) };
2202 sharpness_level as u64
2204 __bindgen_bitfield_unit.set(11usize, 1u8, {
2205 let loop_filter_adj_enable: u32 =
2206 unsafe { ::std::mem::transmute(loop_filter_adj_enable) };
2207 loop_filter_adj_enable as u64
2209 __bindgen_bitfield_unit.set(12usize, 1u8, {
2210 let mode_ref_lf_delta_update: u32 =
2211 unsafe { ::std::mem::transmute(mode_ref_lf_delta_update) };
2212 mode_ref_lf_delta_update as u64
2214 __bindgen_bitfield_unit.set(13usize, 1u8, {
2215 let sign_bias_golden: u32 = unsafe { ::std::mem::transmute(sign_bias_golden) };
2216 sign_bias_golden as u64
2218 __bindgen_bitfield_unit.set(14usize, 1u8, {
2219 let sign_bias_alternate: u32 = unsafe { ::std::mem::transmute(sign_bias_alternate) };
2220 sign_bias_alternate as u64
2222 __bindgen_bitfield_unit.set(15usize, 1u8, {
2223 let mb_no_coeff_skip: u32 = unsafe { ::std::mem::transmute(mb_no_coeff_skip) };
2224 mb_no_coeff_skip as u64
2226 __bindgen_bitfield_unit.set(16usize, 1u8, {
2227 let loop_filter_disable: u32 = unsafe { ::std::mem::transmute(loop_filter_disable) };
2228 loop_filter_disable as u64
2230 __bindgen_bitfield_unit
2233 impl Default for _VAPictureParameterBufferVP8__bindgen_ty_1 {
2234 fn default() -> Self {
2235 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2237 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2242 impl Default for _VAPictureParameterBufferVP8 {
2243 fn default() -> Self {
2244 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2246 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2251 pub type VAPictureParameterBufferVP8 = _VAPictureParameterBufferVP8;
2253 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
2254 pub struct _VASliceParameterBufferVP8 {
2255 pub slice_data_size: u32,
2256 pub slice_data_offset: u32,
2257 pub slice_data_flag: u32,
2258 pub macroblock_offset: u32,
2259 pub num_of_partitions: u8,
2260 pub partition_size: [u32; 9usize],
2261 pub va_reserved: [u32; 4usize],
2263 pub type VASliceParameterBufferVP8 = _VASliceParameterBufferVP8;
2265 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
2266 pub struct _VAProbabilityDataBufferVP8 {
2267 pub dct_coeff_probs: [[[[u8; 11usize]; 3usize]; 8usize]; 4usize],
2268 pub va_reserved: [u32; 4usize],
2270 pub type VAProbabilityDataBufferVP8 = _VAProbabilityDataBufferVP8;
2272 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
2273 pub struct _VAIQMatrixBufferVP8 {
2274 pub quantization_index: [[u16; 6usize]; 4usize],
2275 pub va_reserved: [u32; 4usize],
2277 pub type VAIQMatrixBufferVP8 = _VAIQMatrixBufferVP8;
2279 #[derive(Copy, Clone)]
2280 pub struct _VADecPictureParameterBufferVP9 {
2281 pub frame_width: u16,
2282 pub frame_height: u16,
2283 pub reference_frames: [VASurfaceID; 8usize],
2284 pub pic_fields: _VADecPictureParameterBufferVP9__bindgen_ty_1,
2285 pub filter_level: u8,
2286 pub sharpness_level: u8,
2287 pub log2_tile_rows: u8,
2288 pub log2_tile_columns: u8,
2289 pub frame_header_length_in_bytes: u8,
2290 pub first_partition_size: u16,
2291 pub mb_segment_tree_probs: [u8; 7usize],
2292 pub segment_pred_probs: [u8; 3usize],
2295 pub va_reserved: [u32; 8usize],
2298 #[derive(Copy, Clone)]
2299 pub union _VADecPictureParameterBufferVP9__bindgen_ty_1 {
2300 pub bits: _VADecPictureParameterBufferVP9__bindgen_ty_1__bindgen_ty_1,
2305 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
2306 pub struct _VADecPictureParameterBufferVP9__bindgen_ty_1__bindgen_ty_1 {
2307 pub _bitfield_align_1: [u8; 0],
2308 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
2310 impl _VADecPictureParameterBufferVP9__bindgen_ty_1__bindgen_ty_1 {
2312 pub fn subsampling_x(&self) -> u32 {
2313 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
2316 pub fn set_subsampling_x(&mut self, val: u32) {
2318 let val: u32 = ::std::mem::transmute(val);
2319 self._bitfield_1.set(0usize, 1u8, val as u64)
2323 pub fn subsampling_y(&self) -> u32 {
2324 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
2327 pub fn set_subsampling_y(&mut self, val: u32) {
2329 let val: u32 = ::std::mem::transmute(val);
2330 self._bitfield_1.set(1usize, 1u8, val as u64)
2334 pub fn frame_type(&self) -> u32 {
2335 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
2338 pub fn set_frame_type(&mut self, val: u32) {
2340 let val: u32 = ::std::mem::transmute(val);
2341 self._bitfield_1.set(2usize, 1u8, val as u64)
2345 pub fn show_frame(&self) -> u32 {
2346 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
2349 pub fn set_show_frame(&mut self, val: u32) {
2351 let val: u32 = ::std::mem::transmute(val);
2352 self._bitfield_1.set(3usize, 1u8, val as u64)
2356 pub fn error_resilient_mode(&self) -> u32 {
2357 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
2360 pub fn set_error_resilient_mode(&mut self, val: u32) {
2362 let val: u32 = ::std::mem::transmute(val);
2363 self._bitfield_1.set(4usize, 1u8, val as u64)
2367 pub fn intra_only(&self) -> u32 {
2368 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
2371 pub fn set_intra_only(&mut self, val: u32) {
2373 let val: u32 = ::std::mem::transmute(val);
2374 self._bitfield_1.set(5usize, 1u8, val as u64)
2378 pub fn allow_high_precision_mv(&self) -> u32 {
2379 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) }
2382 pub fn set_allow_high_precision_mv(&mut self, val: u32) {
2384 let val: u32 = ::std::mem::transmute(val);
2385 self._bitfield_1.set(6usize, 1u8, val as u64)
2389 pub fn mcomp_filter_type(&self) -> u32 {
2390 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 3u8) as u32) }
2393 pub fn set_mcomp_filter_type(&mut self, val: u32) {
2395 let val: u32 = ::std::mem::transmute(val);
2396 self._bitfield_1.set(7usize, 3u8, val as u64)
2400 pub fn frame_parallel_decoding_mode(&self) -> u32 {
2401 unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) }
2404 pub fn set_frame_parallel_decoding_mode(&mut self, val: u32) {
2406 let val: u32 = ::std::mem::transmute(val);
2407 self._bitfield_1.set(10usize, 1u8, val as u64)
2411 pub fn reset_frame_context(&self) -> u32 {
2412 unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 2u8) as u32) }
2415 pub fn set_reset_frame_context(&mut self, val: u32) {
2417 let val: u32 = ::std::mem::transmute(val);
2418 self._bitfield_1.set(11usize, 2u8, val as u64)
2422 pub fn refresh_frame_context(&self) -> u32 {
2423 unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) }
2426 pub fn set_refresh_frame_context(&mut self, val: u32) {
2428 let val: u32 = ::std::mem::transmute(val);
2429 self._bitfield_1.set(13usize, 1u8, val as u64)
2433 pub fn frame_context_idx(&self) -> u32 {
2434 unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 2u8) as u32) }
2437 pub fn set_frame_context_idx(&mut self, val: u32) {
2439 let val: u32 = ::std::mem::transmute(val);
2440 self._bitfield_1.set(14usize, 2u8, val as u64)
2444 pub fn segmentation_enabled(&self) -> u32 {
2445 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u32) }
2448 pub fn set_segmentation_enabled(&mut self, val: u32) {
2450 let val: u32 = ::std::mem::transmute(val);
2451 self._bitfield_1.set(16usize, 1u8, val as u64)
2455 pub fn segmentation_temporal_update(&self) -> u32 {
2456 unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 1u8) as u32) }
2459 pub fn set_segmentation_temporal_update(&mut self, val: u32) {
2461 let val: u32 = ::std::mem::transmute(val);
2462 self._bitfield_1.set(17usize, 1u8, val as u64)
2466 pub fn segmentation_update_map(&self) -> u32 {
2467 unsafe { ::std::mem::transmute(self._bitfield_1.get(18usize, 1u8) as u32) }
2470 pub fn set_segmentation_update_map(&mut self, val: u32) {
2472 let val: u32 = ::std::mem::transmute(val);
2473 self._bitfield_1.set(18usize, 1u8, val as u64)
2477 pub fn last_ref_frame(&self) -> u32 {
2478 unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 3u8) as u32) }
2481 pub fn set_last_ref_frame(&mut self, val: u32) {
2483 let val: u32 = ::std::mem::transmute(val);
2484 self._bitfield_1.set(19usize, 3u8, val as u64)
2488 pub fn last_ref_frame_sign_bias(&self) -> u32 {
2489 unsafe { ::std::mem::transmute(self._bitfield_1.get(22usize, 1u8) as u32) }
2492 pub fn set_last_ref_frame_sign_bias(&mut self, val: u32) {
2494 let val: u32 = ::std::mem::transmute(val);
2495 self._bitfield_1.set(22usize, 1u8, val as u64)
2499 pub fn golden_ref_frame(&self) -> u32 {
2500 unsafe { ::std::mem::transmute(self._bitfield_1.get(23usize, 3u8) as u32) }
2503 pub fn set_golden_ref_frame(&mut self, val: u32) {
2505 let val: u32 = ::std::mem::transmute(val);
2506 self._bitfield_1.set(23usize, 3u8, val as u64)
2510 pub fn golden_ref_frame_sign_bias(&self) -> u32 {
2511 unsafe { ::std::mem::transmute(self._bitfield_1.get(26usize, 1u8) as u32) }
2514 pub fn set_golden_ref_frame_sign_bias(&mut self, val: u32) {
2516 let val: u32 = ::std::mem::transmute(val);
2517 self._bitfield_1.set(26usize, 1u8, val as u64)
2521 pub fn alt_ref_frame(&self) -> u32 {
2522 unsafe { ::std::mem::transmute(self._bitfield_1.get(27usize, 3u8) as u32) }
2525 pub fn set_alt_ref_frame(&mut self, val: u32) {
2527 let val: u32 = ::std::mem::transmute(val);
2528 self._bitfield_1.set(27usize, 3u8, val as u64)
2532 pub fn alt_ref_frame_sign_bias(&self) -> u32 {
2533 unsafe { ::std::mem::transmute(self._bitfield_1.get(30usize, 1u8) as u32) }
2536 pub fn set_alt_ref_frame_sign_bias(&mut self, val: u32) {
2538 let val: u32 = ::std::mem::transmute(val);
2539 self._bitfield_1.set(30usize, 1u8, val as u64)
2543 pub fn lossless_flag(&self) -> u32 {
2544 unsafe { ::std::mem::transmute(self._bitfield_1.get(31usize, 1u8) as u32) }
2547 pub fn set_lossless_flag(&mut self, val: u32) {
2549 let val: u32 = ::std::mem::transmute(val);
2550 self._bitfield_1.set(31usize, 1u8, val as u64)
2554 pub fn new_bitfield_1(
2559 error_resilient_mode: u32,
2561 allow_high_precision_mv: u32,
2562 mcomp_filter_type: u32,
2563 frame_parallel_decoding_mode: u32,
2564 reset_frame_context: u32,
2565 refresh_frame_context: u32,
2566 frame_context_idx: u32,
2567 segmentation_enabled: u32,
2568 segmentation_temporal_update: u32,
2569 segmentation_update_map: u32,
2570 last_ref_frame: u32,
2571 last_ref_frame_sign_bias: u32,
2572 golden_ref_frame: u32,
2573 golden_ref_frame_sign_bias: u32,
2575 alt_ref_frame_sign_bias: u32,
2577 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
2578 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
2579 __bindgen_bitfield_unit.set(0usize, 1u8, {
2580 let subsampling_x: u32 = unsafe { ::std::mem::transmute(subsampling_x) };
2581 subsampling_x as u64
2583 __bindgen_bitfield_unit.set(1usize, 1u8, {
2584 let subsampling_y: u32 = unsafe { ::std::mem::transmute(subsampling_y) };
2585 subsampling_y as u64
2587 __bindgen_bitfield_unit.set(2usize, 1u8, {
2588 let frame_type: u32 = unsafe { ::std::mem::transmute(frame_type) };
2591 __bindgen_bitfield_unit.set(3usize, 1u8, {
2592 let show_frame: u32 = unsafe { ::std::mem::transmute(show_frame) };
2595 __bindgen_bitfield_unit.set(4usize, 1u8, {
2596 let error_resilient_mode: u32 = unsafe { ::std::mem::transmute(error_resilient_mode) };
2597 error_resilient_mode as u64
2599 __bindgen_bitfield_unit.set(5usize, 1u8, {
2600 let intra_only: u32 = unsafe { ::std::mem::transmute(intra_only) };
2603 __bindgen_bitfield_unit.set(6usize, 1u8, {
2604 let allow_high_precision_mv: u32 =
2605 unsafe { ::std::mem::transmute(allow_high_precision_mv) };
2606 allow_high_precision_mv as u64
2608 __bindgen_bitfield_unit.set(7usize, 3u8, {
2609 let mcomp_filter_type: u32 = unsafe { ::std::mem::transmute(mcomp_filter_type) };
2610 mcomp_filter_type as u64
2612 __bindgen_bitfield_unit.set(10usize, 1u8, {
2613 let frame_parallel_decoding_mode: u32 =
2614 unsafe { ::std::mem::transmute(frame_parallel_decoding_mode) };
2615 frame_parallel_decoding_mode as u64
2617 __bindgen_bitfield_unit.set(11usize, 2u8, {
2618 let reset_frame_context: u32 = unsafe { ::std::mem::transmute(reset_frame_context) };
2619 reset_frame_context as u64
2621 __bindgen_bitfield_unit.set(13usize, 1u8, {
2622 let refresh_frame_context: u32 =
2623 unsafe { ::std::mem::transmute(refresh_frame_context) };
2624 refresh_frame_context as u64
2626 __bindgen_bitfield_unit.set(14usize, 2u8, {
2627 let frame_context_idx: u32 = unsafe { ::std::mem::transmute(frame_context_idx) };
2628 frame_context_idx as u64
2630 __bindgen_bitfield_unit.set(16usize, 1u8, {
2631 let segmentation_enabled: u32 = unsafe { ::std::mem::transmute(segmentation_enabled) };
2632 segmentation_enabled as u64
2634 __bindgen_bitfield_unit.set(17usize, 1u8, {
2635 let segmentation_temporal_update: u32 =
2636 unsafe { ::std::mem::transmute(segmentation_temporal_update) };
2637 segmentation_temporal_update as u64
2639 __bindgen_bitfield_unit.set(18usize, 1u8, {
2640 let segmentation_update_map: u32 =
2641 unsafe { ::std::mem::transmute(segmentation_update_map) };
2642 segmentation_update_map as u64
2644 __bindgen_bitfield_unit.set(19usize, 3u8, {
2645 let last_ref_frame: u32 = unsafe { ::std::mem::transmute(last_ref_frame) };
2646 last_ref_frame as u64
2648 __bindgen_bitfield_unit.set(22usize, 1u8, {
2649 let last_ref_frame_sign_bias: u32 =
2650 unsafe { ::std::mem::transmute(last_ref_frame_sign_bias) };
2651 last_ref_frame_sign_bias as u64
2653 __bindgen_bitfield_unit.set(23usize, 3u8, {
2654 let golden_ref_frame: u32 = unsafe { ::std::mem::transmute(golden_ref_frame) };
2655 golden_ref_frame as u64
2657 __bindgen_bitfield_unit.set(26usize, 1u8, {
2658 let golden_ref_frame_sign_bias: u32 =
2659 unsafe { ::std::mem::transmute(golden_ref_frame_sign_bias) };
2660 golden_ref_frame_sign_bias as u64
2662 __bindgen_bitfield_unit.set(27usize, 3u8, {
2663 let alt_ref_frame: u32 = unsafe { ::std::mem::transmute(alt_ref_frame) };
2664 alt_ref_frame as u64
2666 __bindgen_bitfield_unit.set(30usize, 1u8, {
2667 let alt_ref_frame_sign_bias: u32 =
2668 unsafe { ::std::mem::transmute(alt_ref_frame_sign_bias) };
2669 alt_ref_frame_sign_bias as u64
2671 __bindgen_bitfield_unit.set(31usize, 1u8, {
2672 let lossless_flag: u32 = unsafe { ::std::mem::transmute(lossless_flag) };
2673 lossless_flag as u64
2675 __bindgen_bitfield_unit
2678 impl Default for _VADecPictureParameterBufferVP9__bindgen_ty_1 {
2679 fn default() -> Self {
2680 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2682 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2687 impl Default for _VADecPictureParameterBufferVP9 {
2688 fn default() -> Self {
2689 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2691 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2696 pub type VADecPictureParameterBufferVP9 = _VADecPictureParameterBufferVP9;
2698 #[derive(Copy, Clone)]
2699 pub struct _VASegmentParameterVP9 {
2700 pub segment_flags: _VASegmentParameterVP9__bindgen_ty_1,
2701 pub filter_level: [[u8; 2usize]; 4usize],
2702 pub luma_ac_quant_scale: i16,
2703 pub luma_dc_quant_scale: i16,
2704 pub chroma_ac_quant_scale: i16,
2705 pub chroma_dc_quant_scale: i16,
2706 pub va_reserved: [u32; 4usize],
2709 #[derive(Copy, Clone)]
2710 pub union _VASegmentParameterVP9__bindgen_ty_1 {
2711 pub fields: _VASegmentParameterVP9__bindgen_ty_1__bindgen_ty_1,
2716 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
2717 pub struct _VASegmentParameterVP9__bindgen_ty_1__bindgen_ty_1 {
2718 pub _bitfield_align_1: [u8; 0],
2719 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
2720 pub __bindgen_padding_0: u8,
2722 impl _VASegmentParameterVP9__bindgen_ty_1__bindgen_ty_1 {
2724 pub fn segment_reference_enabled(&self) -> u16 {
2725 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u16) }
2728 pub fn set_segment_reference_enabled(&mut self, val: u16) {
2730 let val: u16 = ::std::mem::transmute(val);
2731 self._bitfield_1.set(0usize, 1u8, val as u64)
2735 pub fn segment_reference(&self) -> u16 {
2736 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 2u8) as u16) }
2739 pub fn set_segment_reference(&mut self, val: u16) {
2741 let val: u16 = ::std::mem::transmute(val);
2742 self._bitfield_1.set(1usize, 2u8, val as u64)
2746 pub fn segment_reference_skipped(&self) -> u16 {
2747 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u16) }
2750 pub fn set_segment_reference_skipped(&mut self, val: u16) {
2752 let val: u16 = ::std::mem::transmute(val);
2753 self._bitfield_1.set(3usize, 1u8, val as u64)
2757 pub fn new_bitfield_1(
2758 segment_reference_enabled: u16,
2759 segment_reference: u16,
2760 segment_reference_skipped: u16,
2761 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
2762 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
2763 __bindgen_bitfield_unit.set(0usize, 1u8, {
2764 let segment_reference_enabled: u16 =
2765 unsafe { ::std::mem::transmute(segment_reference_enabled) };
2766 segment_reference_enabled as u64
2768 __bindgen_bitfield_unit.set(1usize, 2u8, {
2769 let segment_reference: u16 = unsafe { ::std::mem::transmute(segment_reference) };
2770 segment_reference as u64
2772 __bindgen_bitfield_unit.set(3usize, 1u8, {
2773 let segment_reference_skipped: u16 =
2774 unsafe { ::std::mem::transmute(segment_reference_skipped) };
2775 segment_reference_skipped as u64
2777 __bindgen_bitfield_unit
2780 impl Default for _VASegmentParameterVP9__bindgen_ty_1 {
2781 fn default() -> Self {
2782 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2784 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2789 impl Default for _VASegmentParameterVP9 {
2790 fn default() -> Self {
2791 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2793 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2798 pub type VASegmentParameterVP9 = _VASegmentParameterVP9;
2800 #[derive(Copy, Clone)]
2801 pub struct _VASliceParameterBufferVP9 {
2802 pub slice_data_size: u32,
2803 pub slice_data_offset: u32,
2804 pub slice_data_flag: u32,
2805 pub seg_param: [VASegmentParameterVP9; 8usize],
2806 pub va_reserved: [u32; 4usize],
2808 impl Default for _VASliceParameterBufferVP9 {
2809 fn default() -> Self {
2810 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2812 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2817 pub type VASliceParameterBufferVP9 = _VASliceParameterBufferVP9;
2819 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
2820 pub struct _VAPictureStats {
2821 pub picture_id: VASurfaceID,
2824 pub type VAPictureStats = _VAPictureStats;
2826 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
2827 pub struct _VAStatsStatisticsParameter {
2828 pub input: VAPictureStats,
2829 pub past_references: *mut VAPictureStats,
2830 pub num_past_references: u32,
2831 pub past_ref_stat_buf: *mut VABufferID,
2832 pub future_references: *mut VAPictureStats,
2833 pub num_future_references: u32,
2834 pub future_ref_stat_buf: *mut VABufferID,
2835 pub outputs: *mut VABufferID,
2836 pub mv_predictor: VABufferID,
2839 impl Default for _VAStatsStatisticsParameter {
2840 fn default() -> Self {
2841 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2843 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2848 pub type VAStatsStatisticsParameter = _VAStatsStatisticsParameter;
2849 pub mod VAEncPackedHeaderTypeH264 {
2850 pub type Type = ::std::os::raw::c_uint;
2851 pub const VAEncPackedHeaderH264_SPS: Type = 1;
2852 pub const VAEncPackedHeaderH264_PPS: Type = 2;
2853 pub const VAEncPackedHeaderH264_Slice: Type = 3;
2854 pub const VAEncPackedHeaderH264_SEI: Type = 2147483649;
2857 #[derive(Copy, Clone)]
2858 pub struct _VAEncSequenceParameterBufferH264 {
2859 pub seq_parameter_set_id: u8,
2861 pub intra_period: u32,
2862 pub intra_idr_period: u32,
2864 pub bits_per_second: u32,
2865 pub max_num_ref_frames: u32,
2866 pub picture_width_in_mbs: u16,
2867 pub picture_height_in_mbs: u16,
2868 pub seq_fields: _VAEncSequenceParameterBufferH264__bindgen_ty_1,
2869 pub bit_depth_luma_minus8: u8,
2870 pub bit_depth_chroma_minus8: u8,
2871 pub num_ref_frames_in_pic_order_cnt_cycle: u8,
2872 pub offset_for_non_ref_pic: i32,
2873 pub offset_for_top_to_bottom_field: i32,
2874 pub offset_for_ref_frame: [i32; 256usize],
2875 pub frame_cropping_flag: u8,
2876 pub frame_crop_left_offset: u32,
2877 pub frame_crop_right_offset: u32,
2878 pub frame_crop_top_offset: u32,
2879 pub frame_crop_bottom_offset: u32,
2880 pub vui_parameters_present_flag: u8,
2881 pub vui_fields: _VAEncSequenceParameterBufferH264__bindgen_ty_2,
2882 pub aspect_ratio_idc: u8,
2884 pub sar_height: u32,
2885 pub num_units_in_tick: u32,
2886 pub time_scale: u32,
2887 pub va_reserved: [u32; 4usize],
2890 #[derive(Copy, Clone)]
2891 pub union _VAEncSequenceParameterBufferH264__bindgen_ty_1 {
2892 pub bits: _VAEncSequenceParameterBufferH264__bindgen_ty_1__bindgen_ty_1,
2897 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
2898 pub struct _VAEncSequenceParameterBufferH264__bindgen_ty_1__bindgen_ty_1 {
2899 pub _bitfield_align_1: [u8; 0],
2900 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 3usize]>,
2901 pub __bindgen_padding_0: u8,
2903 impl _VAEncSequenceParameterBufferH264__bindgen_ty_1__bindgen_ty_1 {
2905 pub fn chroma_format_idc(&self) -> u32 {
2906 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u32) }
2909 pub fn set_chroma_format_idc(&mut self, val: u32) {
2911 let val: u32 = ::std::mem::transmute(val);
2912 self._bitfield_1.set(0usize, 2u8, val as u64)
2916 pub fn frame_mbs_only_flag(&self) -> u32 {
2917 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
2920 pub fn set_frame_mbs_only_flag(&mut self, val: u32) {
2922 let val: u32 = ::std::mem::transmute(val);
2923 self._bitfield_1.set(2usize, 1u8, val as u64)
2927 pub fn mb_adaptive_frame_field_flag(&self) -> u32 {
2928 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
2931 pub fn set_mb_adaptive_frame_field_flag(&mut self, val: u32) {
2933 let val: u32 = ::std::mem::transmute(val);
2934 self._bitfield_1.set(3usize, 1u8, val as u64)
2938 pub fn seq_scaling_matrix_present_flag(&self) -> u32 {
2939 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
2942 pub fn set_seq_scaling_matrix_present_flag(&mut self, val: u32) {
2944 let val: u32 = ::std::mem::transmute(val);
2945 self._bitfield_1.set(4usize, 1u8, val as u64)
2949 pub fn direct_8x8_inference_flag(&self) -> u32 {
2950 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
2953 pub fn set_direct_8x8_inference_flag(&mut self, val: u32) {
2955 let val: u32 = ::std::mem::transmute(val);
2956 self._bitfield_1.set(5usize, 1u8, val as u64)
2960 pub fn log2_max_frame_num_minus4(&self) -> u32 {
2961 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 4u8) as u32) }
2964 pub fn set_log2_max_frame_num_minus4(&mut self, val: u32) {
2966 let val: u32 = ::std::mem::transmute(val);
2967 self._bitfield_1.set(6usize, 4u8, val as u64)
2971 pub fn pic_order_cnt_type(&self) -> u32 {
2972 unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 2u8) as u32) }
2975 pub fn set_pic_order_cnt_type(&mut self, val: u32) {
2977 let val: u32 = ::std::mem::transmute(val);
2978 self._bitfield_1.set(10usize, 2u8, val as u64)
2982 pub fn log2_max_pic_order_cnt_lsb_minus4(&self) -> u32 {
2983 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 4u8) as u32) }
2986 pub fn set_log2_max_pic_order_cnt_lsb_minus4(&mut self, val: u32) {
2988 let val: u32 = ::std::mem::transmute(val);
2989 self._bitfield_1.set(12usize, 4u8, val as u64)
2993 pub fn delta_pic_order_always_zero_flag(&self) -> u32 {
2994 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u32) }
2997 pub fn set_delta_pic_order_always_zero_flag(&mut self, val: u32) {
2999 let val: u32 = ::std::mem::transmute(val);
3000 self._bitfield_1.set(16usize, 1u8, val as u64)
3004 pub fn new_bitfield_1(
3005 chroma_format_idc: u32,
3006 frame_mbs_only_flag: u32,
3007 mb_adaptive_frame_field_flag: u32,
3008 seq_scaling_matrix_present_flag: u32,
3009 direct_8x8_inference_flag: u32,
3010 log2_max_frame_num_minus4: u32,
3011 pic_order_cnt_type: u32,
3012 log2_max_pic_order_cnt_lsb_minus4: u32,
3013 delta_pic_order_always_zero_flag: u32,
3014 ) -> __BindgenBitfieldUnit<[u8; 3usize]> {
3015 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 3usize]> = Default::default();
3016 __bindgen_bitfield_unit.set(0usize, 2u8, {
3017 let chroma_format_idc: u32 = unsafe { ::std::mem::transmute(chroma_format_idc) };
3018 chroma_format_idc as u64
3020 __bindgen_bitfield_unit.set(2usize, 1u8, {
3021 let frame_mbs_only_flag: u32 = unsafe { ::std::mem::transmute(frame_mbs_only_flag) };
3022 frame_mbs_only_flag as u64
3024 __bindgen_bitfield_unit.set(3usize, 1u8, {
3025 let mb_adaptive_frame_field_flag: u32 =
3026 unsafe { ::std::mem::transmute(mb_adaptive_frame_field_flag) };
3027 mb_adaptive_frame_field_flag as u64
3029 __bindgen_bitfield_unit.set(4usize, 1u8, {
3030 let seq_scaling_matrix_present_flag: u32 =
3031 unsafe { ::std::mem::transmute(seq_scaling_matrix_present_flag) };
3032 seq_scaling_matrix_present_flag as u64
3034 __bindgen_bitfield_unit.set(5usize, 1u8, {
3035 let direct_8x8_inference_flag: u32 =
3036 unsafe { ::std::mem::transmute(direct_8x8_inference_flag) };
3037 direct_8x8_inference_flag as u64
3039 __bindgen_bitfield_unit.set(6usize, 4u8, {
3040 let log2_max_frame_num_minus4: u32 =
3041 unsafe { ::std::mem::transmute(log2_max_frame_num_minus4) };
3042 log2_max_frame_num_minus4 as u64
3044 __bindgen_bitfield_unit.set(10usize, 2u8, {
3045 let pic_order_cnt_type: u32 = unsafe { ::std::mem::transmute(pic_order_cnt_type) };
3046 pic_order_cnt_type as u64
3048 __bindgen_bitfield_unit.set(12usize, 4u8, {
3049 let log2_max_pic_order_cnt_lsb_minus4: u32 =
3050 unsafe { ::std::mem::transmute(log2_max_pic_order_cnt_lsb_minus4) };
3051 log2_max_pic_order_cnt_lsb_minus4 as u64
3053 __bindgen_bitfield_unit.set(16usize, 1u8, {
3054 let delta_pic_order_always_zero_flag: u32 =
3055 unsafe { ::std::mem::transmute(delta_pic_order_always_zero_flag) };
3056 delta_pic_order_always_zero_flag as u64
3058 __bindgen_bitfield_unit
3061 impl Default for _VAEncSequenceParameterBufferH264__bindgen_ty_1 {
3062 fn default() -> Self {
3063 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3065 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3071 #[derive(Copy, Clone)]
3072 pub union _VAEncSequenceParameterBufferH264__bindgen_ty_2 {
3073 pub bits: _VAEncSequenceParameterBufferH264__bindgen_ty_2__bindgen_ty_1,
3078 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
3079 pub struct _VAEncSequenceParameterBufferH264__bindgen_ty_2__bindgen_ty_1 {
3080 pub _bitfield_align_1: [u16; 0],
3081 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
3083 impl _VAEncSequenceParameterBufferH264__bindgen_ty_2__bindgen_ty_1 {
3085 pub fn aspect_ratio_info_present_flag(&self) -> u32 {
3086 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
3089 pub fn set_aspect_ratio_info_present_flag(&mut self, val: u32) {
3091 let val: u32 = ::std::mem::transmute(val);
3092 self._bitfield_1.set(0usize, 1u8, val as u64)
3096 pub fn timing_info_present_flag(&self) -> u32 {
3097 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
3100 pub fn set_timing_info_present_flag(&mut self, val: u32) {
3102 let val: u32 = ::std::mem::transmute(val);
3103 self._bitfield_1.set(1usize, 1u8, val as u64)
3107 pub fn bitstream_restriction_flag(&self) -> u32 {
3108 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
3111 pub fn set_bitstream_restriction_flag(&mut self, val: u32) {
3113 let val: u32 = ::std::mem::transmute(val);
3114 self._bitfield_1.set(2usize, 1u8, val as u64)
3118 pub fn log2_max_mv_length_horizontal(&self) -> u32 {
3119 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 5u8) as u32) }
3122 pub fn set_log2_max_mv_length_horizontal(&mut self, val: u32) {
3124 let val: u32 = ::std::mem::transmute(val);
3125 self._bitfield_1.set(3usize, 5u8, val as u64)
3129 pub fn log2_max_mv_length_vertical(&self) -> u32 {
3130 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 5u8) as u32) }
3133 pub fn set_log2_max_mv_length_vertical(&mut self, val: u32) {
3135 let val: u32 = ::std::mem::transmute(val);
3136 self._bitfield_1.set(8usize, 5u8, val as u64)
3140 pub fn fixed_frame_rate_flag(&self) -> u32 {
3141 unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) }
3144 pub fn set_fixed_frame_rate_flag(&mut self, val: u32) {
3146 let val: u32 = ::std::mem::transmute(val);
3147 self._bitfield_1.set(13usize, 1u8, val as u64)
3151 pub fn low_delay_hrd_flag(&self) -> u32 {
3152 unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) }
3155 pub fn set_low_delay_hrd_flag(&mut self, val: u32) {
3157 let val: u32 = ::std::mem::transmute(val);
3158 self._bitfield_1.set(14usize, 1u8, val as u64)
3162 pub fn motion_vectors_over_pic_boundaries_flag(&self) -> u32 {
3163 unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u32) }
3166 pub fn set_motion_vectors_over_pic_boundaries_flag(&mut self, val: u32) {
3168 let val: u32 = ::std::mem::transmute(val);
3169 self._bitfield_1.set(15usize, 1u8, val as u64)
3173 pub fn reserved(&self) -> u32 {
3174 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 16u8) as u32) }
3177 pub fn set_reserved(&mut self, val: u32) {
3179 let val: u32 = ::std::mem::transmute(val);
3180 self._bitfield_1.set(16usize, 16u8, val as u64)
3184 pub fn new_bitfield_1(
3185 aspect_ratio_info_present_flag: u32,
3186 timing_info_present_flag: u32,
3187 bitstream_restriction_flag: u32,
3188 log2_max_mv_length_horizontal: u32,
3189 log2_max_mv_length_vertical: u32,
3190 fixed_frame_rate_flag: u32,
3191 low_delay_hrd_flag: u32,
3192 motion_vectors_over_pic_boundaries_flag: u32,
3194 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
3195 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
3196 __bindgen_bitfield_unit.set(0usize, 1u8, {
3197 let aspect_ratio_info_present_flag: u32 =
3198 unsafe { ::std::mem::transmute(aspect_ratio_info_present_flag) };
3199 aspect_ratio_info_present_flag as u64
3201 __bindgen_bitfield_unit.set(1usize, 1u8, {
3202 let timing_info_present_flag: u32 =
3203 unsafe { ::std::mem::transmute(timing_info_present_flag) };
3204 timing_info_present_flag as u64
3206 __bindgen_bitfield_unit.set(2usize, 1u8, {
3207 let bitstream_restriction_flag: u32 =
3208 unsafe { ::std::mem::transmute(bitstream_restriction_flag) };
3209 bitstream_restriction_flag as u64
3211 __bindgen_bitfield_unit.set(3usize, 5u8, {
3212 let log2_max_mv_length_horizontal: u32 =
3213 unsafe { ::std::mem::transmute(log2_max_mv_length_horizontal) };
3214 log2_max_mv_length_horizontal as u64
3216 __bindgen_bitfield_unit.set(8usize, 5u8, {
3217 let log2_max_mv_length_vertical: u32 =
3218 unsafe { ::std::mem::transmute(log2_max_mv_length_vertical) };
3219 log2_max_mv_length_vertical as u64
3221 __bindgen_bitfield_unit.set(13usize, 1u8, {
3222 let fixed_frame_rate_flag: u32 =
3223 unsafe { ::std::mem::transmute(fixed_frame_rate_flag) };
3224 fixed_frame_rate_flag as u64
3226 __bindgen_bitfield_unit.set(14usize, 1u8, {
3227 let low_delay_hrd_flag: u32 = unsafe { ::std::mem::transmute(low_delay_hrd_flag) };
3228 low_delay_hrd_flag as u64
3230 __bindgen_bitfield_unit.set(15usize, 1u8, {
3231 let motion_vectors_over_pic_boundaries_flag: u32 =
3232 unsafe { ::std::mem::transmute(motion_vectors_over_pic_boundaries_flag) };
3233 motion_vectors_over_pic_boundaries_flag as u64
3235 __bindgen_bitfield_unit.set(16usize, 16u8, {
3236 let reserved: u32 = unsafe { ::std::mem::transmute(reserved) };
3239 __bindgen_bitfield_unit
3242 impl Default for _VAEncSequenceParameterBufferH264__bindgen_ty_2 {
3243 fn default() -> Self {
3244 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3246 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3251 impl Default for _VAEncSequenceParameterBufferH264 {
3252 fn default() -> Self {
3253 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3255 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3260 pub type VAEncSequenceParameterBufferH264 = _VAEncSequenceParameterBufferH264;
3262 #[derive(Copy, Clone)]
3263 pub struct _VAEncPictureParameterBufferH264 {
3264 pub CurrPic: VAPictureH264,
3265 pub ReferenceFrames: [VAPictureH264; 16usize],
3266 pub coded_buf: VABufferID,
3267 pub pic_parameter_set_id: u8,
3268 pub seq_parameter_set_id: u8,
3269 pub last_picture: u8,
3271 pub pic_init_qp: u8,
3272 pub num_ref_idx_l0_active_minus1: u8,
3273 pub num_ref_idx_l1_active_minus1: u8,
3274 pub chroma_qp_index_offset: i8,
3275 pub second_chroma_qp_index_offset: i8,
3276 pub pic_fields: _VAEncPictureParameterBufferH264__bindgen_ty_1,
3277 pub va_reserved: [u32; 4usize],
3280 #[derive(Copy, Clone)]
3281 pub union _VAEncPictureParameterBufferH264__bindgen_ty_1 {
3282 pub bits: _VAEncPictureParameterBufferH264__bindgen_ty_1__bindgen_ty_1,
3287 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
3288 pub struct _VAEncPictureParameterBufferH264__bindgen_ty_1__bindgen_ty_1 {
3289 pub _bitfield_align_1: [u8; 0],
3290 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
3291 pub __bindgen_padding_0: u16,
3293 impl _VAEncPictureParameterBufferH264__bindgen_ty_1__bindgen_ty_1 {
3295 pub fn idr_pic_flag(&self) -> u32 {
3296 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
3299 pub fn set_idr_pic_flag(&mut self, val: u32) {
3301 let val: u32 = ::std::mem::transmute(val);
3302 self._bitfield_1.set(0usize, 1u8, val as u64)
3306 pub fn reference_pic_flag(&self) -> u32 {
3307 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 2u8) as u32) }
3310 pub fn set_reference_pic_flag(&mut self, val: u32) {
3312 let val: u32 = ::std::mem::transmute(val);
3313 self._bitfield_1.set(1usize, 2u8, val as u64)
3317 pub fn entropy_coding_mode_flag(&self) -> u32 {
3318 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
3321 pub fn set_entropy_coding_mode_flag(&mut self, val: u32) {
3323 let val: u32 = ::std::mem::transmute(val);
3324 self._bitfield_1.set(3usize, 1u8, val as u64)
3328 pub fn weighted_pred_flag(&self) -> u32 {
3329 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
3332 pub fn set_weighted_pred_flag(&mut self, val: u32) {
3334 let val: u32 = ::std::mem::transmute(val);
3335 self._bitfield_1.set(4usize, 1u8, val as u64)
3339 pub fn weighted_bipred_idc(&self) -> u32 {
3340 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 2u8) as u32) }
3343 pub fn set_weighted_bipred_idc(&mut self, val: u32) {
3345 let val: u32 = ::std::mem::transmute(val);
3346 self._bitfield_1.set(5usize, 2u8, val as u64)
3350 pub fn constrained_intra_pred_flag(&self) -> u32 {
3351 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) }
3354 pub fn set_constrained_intra_pred_flag(&mut self, val: u32) {
3356 let val: u32 = ::std::mem::transmute(val);
3357 self._bitfield_1.set(7usize, 1u8, val as u64)
3361 pub fn transform_8x8_mode_flag(&self) -> u32 {
3362 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) }
3365 pub fn set_transform_8x8_mode_flag(&mut self, val: u32) {
3367 let val: u32 = ::std::mem::transmute(val);
3368 self._bitfield_1.set(8usize, 1u8, val as u64)
3372 pub fn deblocking_filter_control_present_flag(&self) -> u32 {
3373 unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) }
3376 pub fn set_deblocking_filter_control_present_flag(&mut self, val: u32) {
3378 let val: u32 = ::std::mem::transmute(val);
3379 self._bitfield_1.set(9usize, 1u8, val as u64)
3383 pub fn redundant_pic_cnt_present_flag(&self) -> u32 {
3384 unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) }
3387 pub fn set_redundant_pic_cnt_present_flag(&mut self, val: u32) {
3389 let val: u32 = ::std::mem::transmute(val);
3390 self._bitfield_1.set(10usize, 1u8, val as u64)
3394 pub fn pic_order_present_flag(&self) -> u32 {
3395 unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) }
3398 pub fn set_pic_order_present_flag(&mut self, val: u32) {
3400 let val: u32 = ::std::mem::transmute(val);
3401 self._bitfield_1.set(11usize, 1u8, val as u64)
3405 pub fn pic_scaling_matrix_present_flag(&self) -> u32 {
3406 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u32) }
3409 pub fn set_pic_scaling_matrix_present_flag(&mut self, val: u32) {
3411 let val: u32 = ::std::mem::transmute(val);
3412 self._bitfield_1.set(12usize, 1u8, val as u64)
3416 pub fn new_bitfield_1(
3418 reference_pic_flag: u32,
3419 entropy_coding_mode_flag: u32,
3420 weighted_pred_flag: u32,
3421 weighted_bipred_idc: u32,
3422 constrained_intra_pred_flag: u32,
3423 transform_8x8_mode_flag: u32,
3424 deblocking_filter_control_present_flag: u32,
3425 redundant_pic_cnt_present_flag: u32,
3426 pic_order_present_flag: u32,
3427 pic_scaling_matrix_present_flag: u32,
3428 ) -> __BindgenBitfieldUnit<[u8; 2usize]> {
3429 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default();
3430 __bindgen_bitfield_unit.set(0usize, 1u8, {
3431 let idr_pic_flag: u32 = unsafe { ::std::mem::transmute(idr_pic_flag) };
3434 __bindgen_bitfield_unit.set(1usize, 2u8, {
3435 let reference_pic_flag: u32 = unsafe { ::std::mem::transmute(reference_pic_flag) };
3436 reference_pic_flag as u64
3438 __bindgen_bitfield_unit.set(3usize, 1u8, {
3439 let entropy_coding_mode_flag: u32 =
3440 unsafe { ::std::mem::transmute(entropy_coding_mode_flag) };
3441 entropy_coding_mode_flag as u64
3443 __bindgen_bitfield_unit.set(4usize, 1u8, {
3444 let weighted_pred_flag: u32 = unsafe { ::std::mem::transmute(weighted_pred_flag) };
3445 weighted_pred_flag as u64
3447 __bindgen_bitfield_unit.set(5usize, 2u8, {
3448 let weighted_bipred_idc: u32 = unsafe { ::std::mem::transmute(weighted_bipred_idc) };
3449 weighted_bipred_idc as u64
3451 __bindgen_bitfield_unit.set(7usize, 1u8, {
3452 let constrained_intra_pred_flag: u32 =
3453 unsafe { ::std::mem::transmute(constrained_intra_pred_flag) };
3454 constrained_intra_pred_flag as u64
3456 __bindgen_bitfield_unit.set(8usize, 1u8, {
3457 let transform_8x8_mode_flag: u32 =
3458 unsafe { ::std::mem::transmute(transform_8x8_mode_flag) };
3459 transform_8x8_mode_flag as u64
3461 __bindgen_bitfield_unit.set(9usize, 1u8, {
3462 let deblocking_filter_control_present_flag: u32 =
3463 unsafe { ::std::mem::transmute(deblocking_filter_control_present_flag) };
3464 deblocking_filter_control_present_flag as u64
3466 __bindgen_bitfield_unit.set(10usize, 1u8, {
3467 let redundant_pic_cnt_present_flag: u32 =
3468 unsafe { ::std::mem::transmute(redundant_pic_cnt_present_flag) };
3469 redundant_pic_cnt_present_flag as u64
3471 __bindgen_bitfield_unit.set(11usize, 1u8, {
3472 let pic_order_present_flag: u32 =
3473 unsafe { ::std::mem::transmute(pic_order_present_flag) };
3474 pic_order_present_flag as u64
3476 __bindgen_bitfield_unit.set(12usize, 1u8, {
3477 let pic_scaling_matrix_present_flag: u32 =
3478 unsafe { ::std::mem::transmute(pic_scaling_matrix_present_flag) };
3479 pic_scaling_matrix_present_flag as u64
3481 __bindgen_bitfield_unit
3484 impl Default for _VAEncPictureParameterBufferH264__bindgen_ty_1 {
3485 fn default() -> Self {
3486 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3488 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3493 impl Default for _VAEncPictureParameterBufferH264 {
3494 fn default() -> Self {
3495 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3497 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3502 pub type VAEncPictureParameterBufferH264 = _VAEncPictureParameterBufferH264;
3504 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
3505 pub struct _VAEncQPBufferH264 {
3508 pub type VAEncQPBufferH264 = _VAEncQPBufferH264;
3510 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
3511 pub struct _VAEncSliceParameterBufferH264 {
3512 pub macroblock_address: u32,
3513 pub num_macroblocks: u32,
3514 pub macroblock_info: VABufferID,
3516 pub pic_parameter_set_id: u8,
3517 pub idr_pic_id: u16,
3518 pub pic_order_cnt_lsb: u16,
3519 pub delta_pic_order_cnt_bottom: i32,
3520 pub delta_pic_order_cnt: [i32; 2usize],
3521 pub direct_spatial_mv_pred_flag: u8,
3522 pub num_ref_idx_active_override_flag: u8,
3523 pub num_ref_idx_l0_active_minus1: u8,
3524 pub num_ref_idx_l1_active_minus1: u8,
3525 pub RefPicList0: [VAPictureH264; 32usize],
3526 pub RefPicList1: [VAPictureH264; 32usize],
3527 pub luma_log2_weight_denom: u8,
3528 pub chroma_log2_weight_denom: u8,
3529 pub luma_weight_l0_flag: u8,
3530 pub luma_weight_l0: [::std::os::raw::c_short; 32usize],
3531 pub luma_offset_l0: [::std::os::raw::c_short; 32usize],
3532 pub chroma_weight_l0_flag: u8,
3533 pub chroma_weight_l0: [[::std::os::raw::c_short; 2usize]; 32usize],
3534 pub chroma_offset_l0: [[::std::os::raw::c_short; 2usize]; 32usize],
3535 pub luma_weight_l1_flag: u8,
3536 pub luma_weight_l1: [::std::os::raw::c_short; 32usize],
3537 pub luma_offset_l1: [::std::os::raw::c_short; 32usize],
3538 pub chroma_weight_l1_flag: u8,
3539 pub chroma_weight_l1: [[::std::os::raw::c_short; 2usize]; 32usize],
3540 pub chroma_offset_l1: [[::std::os::raw::c_short; 2usize]; 32usize],
3541 pub cabac_init_idc: u8,
3542 pub slice_qp_delta: i8,
3543 pub disable_deblocking_filter_idc: u8,
3544 pub slice_alpha_c0_offset_div2: i8,
3545 pub slice_beta_offset_div2: i8,
3546 pub va_reserved: [u32; 4usize],
3548 pub type VAEncSliceParameterBufferH264 = _VAEncSliceParameterBufferH264;
3550 #[derive(Copy, Clone)]
3551 pub struct _VAEncMacroblockParameterBufferH264 {
3553 pub info: _VAEncMacroblockParameterBufferH264__bindgen_ty_1,
3554 pub va_reserved: [u32; 4usize],
3557 #[derive(Copy, Clone)]
3558 pub union _VAEncMacroblockParameterBufferH264__bindgen_ty_1 {
3559 pub intra_fields: _VAEncMacroblockParameterBufferH264__bindgen_ty_1__bindgen_ty_1,
3560 pub inter_fields: _VAEncMacroblockParameterBufferH264__bindgen_ty_1__bindgen_ty_2,
3563 #[derive(Copy, Clone)]
3564 pub union _VAEncMacroblockParameterBufferH264__bindgen_ty_1__bindgen_ty_1 {
3565 pub bits: _VAEncMacroblockParameterBufferH264__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1,
3570 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
3571 pub struct _VAEncMacroblockParameterBufferH264__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 {
3572 pub _bitfield_align_1: [u8; 0],
3573 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
3574 pub __bindgen_padding_0: u16,
3576 impl _VAEncMacroblockParameterBufferH264__bindgen_ty_1__bindgen_ty_1__bindgen_ty_1 {
3578 pub fn pred_avail_override_flag(&self) -> u32 {
3579 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
3582 pub fn set_pred_avail_override_flag(&mut self, val: u32) {
3584 let val: u32 = ::std::mem::transmute(val);
3585 self._bitfield_1.set(0usize, 1u8, val as u64)
3589 pub fn pred_avail_flags(&self) -> u32 {
3590 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 8u8) as u32) }
3593 pub fn set_pred_avail_flags(&mut self, val: u32) {
3595 let val: u32 = ::std::mem::transmute(val);
3596 self._bitfield_1.set(1usize, 8u8, val as u64)
3600 pub fn new_bitfield_1(
3601 pred_avail_override_flag: u32,
3602 pred_avail_flags: u32,
3603 ) -> __BindgenBitfieldUnit<[u8; 2usize]> {
3604 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default();
3605 __bindgen_bitfield_unit.set(0usize, 1u8, {
3606 let pred_avail_override_flag: u32 =
3607 unsafe { ::std::mem::transmute(pred_avail_override_flag) };
3608 pred_avail_override_flag as u64
3610 __bindgen_bitfield_unit.set(1usize, 8u8, {
3611 let pred_avail_flags: u32 = unsafe { ::std::mem::transmute(pred_avail_flags) };
3612 pred_avail_flags as u64
3614 __bindgen_bitfield_unit
3617 impl Default for _VAEncMacroblockParameterBufferH264__bindgen_ty_1__bindgen_ty_1 {
3618 fn default() -> Self {
3619 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3621 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3627 #[derive(Copy, Clone)]
3628 pub union _VAEncMacroblockParameterBufferH264__bindgen_ty_1__bindgen_ty_2 {
3629 pub bits: _VAEncMacroblockParameterBufferH264__bindgen_ty_1__bindgen_ty_2__bindgen_ty_1,
3633 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
3634 pub struct _VAEncMacroblockParameterBufferH264__bindgen_ty_1__bindgen_ty_2__bindgen_ty_1 {
3637 impl Default for _VAEncMacroblockParameterBufferH264__bindgen_ty_1__bindgen_ty_2 {
3638 fn default() -> Self {
3639 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3641 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3646 impl Default for _VAEncMacroblockParameterBufferH264__bindgen_ty_1 {
3647 fn default() -> Self {
3648 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3650 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3655 impl Default for _VAEncMacroblockParameterBufferH264 {
3656 fn default() -> Self {
3657 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3659 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3664 pub type VAEncMacroblockParameterBufferH264 = _VAEncMacroblockParameterBufferH264;
3666 #[derive(Copy, Clone)]
3667 pub struct _VAEncMiscParameterSubMbPartPelH264 {
3668 pub disable_inter_sub_mb_partition: u32,
3669 pub inter_sub_mb_partition_mask: _VAEncMiscParameterSubMbPartPelH264__bindgen_ty_1,
3670 pub enable_sub_pel_mode: u32,
3671 pub sub_pel_mode: u8,
3672 pub reserved: [u8; 3usize],
3675 #[derive(Copy, Clone)]
3676 pub union _VAEncMiscParameterSubMbPartPelH264__bindgen_ty_1 {
3677 pub bits: _VAEncMiscParameterSubMbPartPelH264__bindgen_ty_1__bindgen_ty_1,
3682 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
3683 pub struct _VAEncMiscParameterSubMbPartPelH264__bindgen_ty_1__bindgen_ty_1 {
3684 pub _bitfield_align_1: [u8; 0],
3685 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
3686 pub __bindgen_padding_0: [u8; 3usize],
3688 impl _VAEncMiscParameterSubMbPartPelH264__bindgen_ty_1__bindgen_ty_1 {
3690 pub fn disable_16x16_inter_mb_partition(&self) -> u32 {
3691 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
3694 pub fn set_disable_16x16_inter_mb_partition(&mut self, val: u32) {
3696 let val: u32 = ::std::mem::transmute(val);
3697 self._bitfield_1.set(0usize, 1u8, val as u64)
3701 pub fn disable_16x8_inter_mb_partition(&self) -> u32 {
3702 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
3705 pub fn set_disable_16x8_inter_mb_partition(&mut self, val: u32) {
3707 let val: u32 = ::std::mem::transmute(val);
3708 self._bitfield_1.set(1usize, 1u8, val as u64)
3712 pub fn disable_8x16_inter_mb_partition(&self) -> u32 {
3713 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
3716 pub fn set_disable_8x16_inter_mb_partition(&mut self, val: u32) {
3718 let val: u32 = ::std::mem::transmute(val);
3719 self._bitfield_1.set(2usize, 1u8, val as u64)
3723 pub fn disable_8x8_inter_mb_partition(&self) -> u32 {
3724 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
3727 pub fn set_disable_8x8_inter_mb_partition(&mut self, val: u32) {
3729 let val: u32 = ::std::mem::transmute(val);
3730 self._bitfield_1.set(3usize, 1u8, val as u64)
3734 pub fn disable_8x4_inter_mb_partition(&self) -> u32 {
3735 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
3738 pub fn set_disable_8x4_inter_mb_partition(&mut self, val: u32) {
3740 let val: u32 = ::std::mem::transmute(val);
3741 self._bitfield_1.set(4usize, 1u8, val as u64)
3745 pub fn disable_4x8_inter_mb_partition(&self) -> u32 {
3746 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
3749 pub fn set_disable_4x8_inter_mb_partition(&mut self, val: u32) {
3751 let val: u32 = ::std::mem::transmute(val);
3752 self._bitfield_1.set(5usize, 1u8, val as u64)
3756 pub fn disable_4x4_inter_mb_partition(&self) -> u32 {
3757 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) }
3760 pub fn set_disable_4x4_inter_mb_partition(&mut self, val: u32) {
3762 let val: u32 = ::std::mem::transmute(val);
3763 self._bitfield_1.set(6usize, 1u8, val as u64)
3767 pub fn reserved(&self) -> u32 {
3768 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) }
3771 pub fn set_reserved(&mut self, val: u32) {
3773 let val: u32 = ::std::mem::transmute(val);
3774 self._bitfield_1.set(7usize, 1u8, val as u64)
3778 pub fn new_bitfield_1(
3779 disable_16x16_inter_mb_partition: u32,
3780 disable_16x8_inter_mb_partition: u32,
3781 disable_8x16_inter_mb_partition: u32,
3782 disable_8x8_inter_mb_partition: u32,
3783 disable_8x4_inter_mb_partition: u32,
3784 disable_4x8_inter_mb_partition: u32,
3785 disable_4x4_inter_mb_partition: u32,
3787 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
3788 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
3789 __bindgen_bitfield_unit.set(0usize, 1u8, {
3790 let disable_16x16_inter_mb_partition: u32 =
3791 unsafe { ::std::mem::transmute(disable_16x16_inter_mb_partition) };
3792 disable_16x16_inter_mb_partition as u64
3794 __bindgen_bitfield_unit.set(1usize, 1u8, {
3795 let disable_16x8_inter_mb_partition: u32 =
3796 unsafe { ::std::mem::transmute(disable_16x8_inter_mb_partition) };
3797 disable_16x8_inter_mb_partition as u64
3799 __bindgen_bitfield_unit.set(2usize, 1u8, {
3800 let disable_8x16_inter_mb_partition: u32 =
3801 unsafe { ::std::mem::transmute(disable_8x16_inter_mb_partition) };
3802 disable_8x16_inter_mb_partition as u64
3804 __bindgen_bitfield_unit.set(3usize, 1u8, {
3805 let disable_8x8_inter_mb_partition: u32 =
3806 unsafe { ::std::mem::transmute(disable_8x8_inter_mb_partition) };
3807 disable_8x8_inter_mb_partition as u64
3809 __bindgen_bitfield_unit.set(4usize, 1u8, {
3810 let disable_8x4_inter_mb_partition: u32 =
3811 unsafe { ::std::mem::transmute(disable_8x4_inter_mb_partition) };
3812 disable_8x4_inter_mb_partition as u64
3814 __bindgen_bitfield_unit.set(5usize, 1u8, {
3815 let disable_4x8_inter_mb_partition: u32 =
3816 unsafe { ::std::mem::transmute(disable_4x8_inter_mb_partition) };
3817 disable_4x8_inter_mb_partition as u64
3819 __bindgen_bitfield_unit.set(6usize, 1u8, {
3820 let disable_4x4_inter_mb_partition: u32 =
3821 unsafe { ::std::mem::transmute(disable_4x4_inter_mb_partition) };
3822 disable_4x4_inter_mb_partition as u64
3824 __bindgen_bitfield_unit.set(7usize, 1u8, {
3825 let reserved: u32 = unsafe { ::std::mem::transmute(reserved) };
3828 __bindgen_bitfield_unit
3831 impl Default for _VAEncMiscParameterSubMbPartPelH264__bindgen_ty_1 {
3832 fn default() -> Self {
3833 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3835 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3840 impl Default for _VAEncMiscParameterSubMbPartPelH264 {
3841 fn default() -> Self {
3842 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3844 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3849 pub type VAEncMiscParameterSubMbPartPelH264 = _VAEncMiscParameterSubMbPartPelH264;
3850 pub type VAQMatrixBufferMPEG2 = VAIQMatrixBufferMPEG2;
3851 pub mod VAEncPackedHeaderTypeMPEG2 {
3852 pub type Type = ::std::os::raw::c_uint;
3853 pub const VAEncPackedHeaderMPEG2_SPS: Type = 1;
3854 pub const VAEncPackedHeaderMPEG2_PPS: Type = 2;
3855 pub const VAEncPackedHeaderMPEG2_Slice: Type = 3;
3858 #[derive(Copy, Clone)]
3859 pub struct _VAEncSequenceParameterBufferMPEG2 {
3860 pub intra_period: u32,
3862 pub picture_width: u16,
3863 pub picture_height: u16,
3864 pub bits_per_second: u32,
3865 pub frame_rate: f32,
3866 pub aspect_ratio_information: u16,
3867 pub vbv_buffer_size: u32,
3868 pub sequence_extension: _VAEncSequenceParameterBufferMPEG2__bindgen_ty_1,
3869 pub new_gop_header: u32,
3870 pub gop_header: _VAEncSequenceParameterBufferMPEG2__bindgen_ty_2,
3871 pub va_reserved: [u32; 4usize],
3874 #[derive(Copy, Clone)]
3875 pub union _VAEncSequenceParameterBufferMPEG2__bindgen_ty_1 {
3876 pub bits: _VAEncSequenceParameterBufferMPEG2__bindgen_ty_1__bindgen_ty_1,
3881 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
3882 pub struct _VAEncSequenceParameterBufferMPEG2__bindgen_ty_1__bindgen_ty_1 {
3883 pub _bitfield_align_1: [u8; 0],
3884 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 3usize]>,
3885 pub __bindgen_padding_0: u8,
3887 impl _VAEncSequenceParameterBufferMPEG2__bindgen_ty_1__bindgen_ty_1 {
3889 pub fn profile_and_level_indication(&self) -> u32 {
3890 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 8u8) as u32) }
3893 pub fn set_profile_and_level_indication(&mut self, val: u32) {
3895 let val: u32 = ::std::mem::transmute(val);
3896 self._bitfield_1.set(0usize, 8u8, val as u64)
3900 pub fn progressive_sequence(&self) -> u32 {
3901 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) }
3904 pub fn set_progressive_sequence(&mut self, val: u32) {
3906 let val: u32 = ::std::mem::transmute(val);
3907 self._bitfield_1.set(8usize, 1u8, val as u64)
3911 pub fn chroma_format(&self) -> u32 {
3912 unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 2u8) as u32) }
3915 pub fn set_chroma_format(&mut self, val: u32) {
3917 let val: u32 = ::std::mem::transmute(val);
3918 self._bitfield_1.set(9usize, 2u8, val as u64)
3922 pub fn low_delay(&self) -> u32 {
3923 unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) }
3926 pub fn set_low_delay(&mut self, val: u32) {
3928 let val: u32 = ::std::mem::transmute(val);
3929 self._bitfield_1.set(11usize, 1u8, val as u64)
3933 pub fn frame_rate_extension_n(&self) -> u32 {
3934 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 2u8) as u32) }
3937 pub fn set_frame_rate_extension_n(&mut self, val: u32) {
3939 let val: u32 = ::std::mem::transmute(val);
3940 self._bitfield_1.set(12usize, 2u8, val as u64)
3944 pub fn frame_rate_extension_d(&self) -> u32 {
3945 unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 5u8) as u32) }
3948 pub fn set_frame_rate_extension_d(&mut self, val: u32) {
3950 let val: u32 = ::std::mem::transmute(val);
3951 self._bitfield_1.set(14usize, 5u8, val as u64)
3955 pub fn new_bitfield_1(
3956 profile_and_level_indication: u32,
3957 progressive_sequence: u32,
3960 frame_rate_extension_n: u32,
3961 frame_rate_extension_d: u32,
3962 ) -> __BindgenBitfieldUnit<[u8; 3usize]> {
3963 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 3usize]> = Default::default();
3964 __bindgen_bitfield_unit.set(0usize, 8u8, {
3965 let profile_and_level_indication: u32 =
3966 unsafe { ::std::mem::transmute(profile_and_level_indication) };
3967 profile_and_level_indication as u64
3969 __bindgen_bitfield_unit.set(8usize, 1u8, {
3970 let progressive_sequence: u32 = unsafe { ::std::mem::transmute(progressive_sequence) };
3971 progressive_sequence as u64
3973 __bindgen_bitfield_unit.set(9usize, 2u8, {
3974 let chroma_format: u32 = unsafe { ::std::mem::transmute(chroma_format) };
3975 chroma_format as u64
3977 __bindgen_bitfield_unit.set(11usize, 1u8, {
3978 let low_delay: u32 = unsafe { ::std::mem::transmute(low_delay) };
3981 __bindgen_bitfield_unit.set(12usize, 2u8, {
3982 let frame_rate_extension_n: u32 =
3983 unsafe { ::std::mem::transmute(frame_rate_extension_n) };
3984 frame_rate_extension_n as u64
3986 __bindgen_bitfield_unit.set(14usize, 5u8, {
3987 let frame_rate_extension_d: u32 =
3988 unsafe { ::std::mem::transmute(frame_rate_extension_d) };
3989 frame_rate_extension_d as u64
3991 __bindgen_bitfield_unit
3994 impl Default for _VAEncSequenceParameterBufferMPEG2__bindgen_ty_1 {
3995 fn default() -> Self {
3996 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3998 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4004 #[derive(Copy, Clone)]
4005 pub union _VAEncSequenceParameterBufferMPEG2__bindgen_ty_2 {
4006 pub bits: _VAEncSequenceParameterBufferMPEG2__bindgen_ty_2__bindgen_ty_1,
4011 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
4012 pub struct _VAEncSequenceParameterBufferMPEG2__bindgen_ty_2__bindgen_ty_1 {
4013 pub _bitfield_align_1: [u32; 0],
4014 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
4016 impl _VAEncSequenceParameterBufferMPEG2__bindgen_ty_2__bindgen_ty_1 {
4018 pub fn time_code(&self) -> u32 {
4019 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 25u8) as u32) }
4022 pub fn set_time_code(&mut self, val: u32) {
4024 let val: u32 = ::std::mem::transmute(val);
4025 self._bitfield_1.set(0usize, 25u8, val as u64)
4029 pub fn closed_gop(&self) -> u32 {
4030 unsafe { ::std::mem::transmute(self._bitfield_1.get(25usize, 1u8) as u32) }
4033 pub fn set_closed_gop(&mut self, val: u32) {
4035 let val: u32 = ::std::mem::transmute(val);
4036 self._bitfield_1.set(25usize, 1u8, val as u64)
4040 pub fn broken_link(&self) -> u32 {
4041 unsafe { ::std::mem::transmute(self._bitfield_1.get(26usize, 1u8) as u32) }
4044 pub fn set_broken_link(&mut self, val: u32) {
4046 let val: u32 = ::std::mem::transmute(val);
4047 self._bitfield_1.set(26usize, 1u8, val as u64)
4051 pub fn new_bitfield_1(
4055 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
4056 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
4057 __bindgen_bitfield_unit.set(0usize, 25u8, {
4058 let time_code: u32 = unsafe { ::std::mem::transmute(time_code) };
4061 __bindgen_bitfield_unit.set(25usize, 1u8, {
4062 let closed_gop: u32 = unsafe { ::std::mem::transmute(closed_gop) };
4065 __bindgen_bitfield_unit.set(26usize, 1u8, {
4066 let broken_link: u32 = unsafe { ::std::mem::transmute(broken_link) };
4069 __bindgen_bitfield_unit
4072 impl Default for _VAEncSequenceParameterBufferMPEG2__bindgen_ty_2 {
4073 fn default() -> Self {
4074 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4076 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4081 impl Default for _VAEncSequenceParameterBufferMPEG2 {
4082 fn default() -> Self {
4083 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4085 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4090 pub type VAEncSequenceParameterBufferMPEG2 = _VAEncSequenceParameterBufferMPEG2;
4092 #[derive(Copy, Clone)]
4093 pub struct _VAEncPictureParameterBufferMPEG2 {
4094 pub forward_reference_picture: VASurfaceID,
4095 pub backward_reference_picture: VASurfaceID,
4096 pub reconstructed_picture: VASurfaceID,
4097 pub coded_buf: VABufferID,
4098 pub last_picture: u8,
4099 pub picture_type: VAEncPictureType::Type,
4100 pub temporal_reference: u32,
4102 pub f_code: [[u8; 2usize]; 2usize],
4103 pub picture_coding_extension: _VAEncPictureParameterBufferMPEG2__bindgen_ty_1,
4104 pub composite_display: _VAEncPictureParameterBufferMPEG2__bindgen_ty_2,
4105 pub va_reserved: [u32; 4usize],
4108 #[derive(Copy, Clone)]
4109 pub union _VAEncPictureParameterBufferMPEG2__bindgen_ty_1 {
4110 pub bits: _VAEncPictureParameterBufferMPEG2__bindgen_ty_1__bindgen_ty_1,
4115 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
4116 pub struct _VAEncPictureParameterBufferMPEG2__bindgen_ty_1__bindgen_ty_1 {
4117 pub _bitfield_align_1: [u8; 0],
4118 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
4119 pub __bindgen_padding_0: u16,
4121 impl _VAEncPictureParameterBufferMPEG2__bindgen_ty_1__bindgen_ty_1 {
4123 pub fn intra_dc_precision(&self) -> u32 {
4124 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u32) }
4127 pub fn set_intra_dc_precision(&mut self, val: u32) {
4129 let val: u32 = ::std::mem::transmute(val);
4130 self._bitfield_1.set(0usize, 2u8, val as u64)
4134 pub fn picture_structure(&self) -> u32 {
4135 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 2u8) as u32) }
4138 pub fn set_picture_structure(&mut self, val: u32) {
4140 let val: u32 = ::std::mem::transmute(val);
4141 self._bitfield_1.set(2usize, 2u8, val as u64)
4145 pub fn top_field_first(&self) -> u32 {
4146 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
4149 pub fn set_top_field_first(&mut self, val: u32) {
4151 let val: u32 = ::std::mem::transmute(val);
4152 self._bitfield_1.set(4usize, 1u8, val as u64)
4156 pub fn frame_pred_frame_dct(&self) -> u32 {
4157 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
4160 pub fn set_frame_pred_frame_dct(&mut self, val: u32) {
4162 let val: u32 = ::std::mem::transmute(val);
4163 self._bitfield_1.set(5usize, 1u8, val as u64)
4167 pub fn concealment_motion_vectors(&self) -> u32 {
4168 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) }
4171 pub fn set_concealment_motion_vectors(&mut self, val: u32) {
4173 let val: u32 = ::std::mem::transmute(val);
4174 self._bitfield_1.set(6usize, 1u8, val as u64)
4178 pub fn q_scale_type(&self) -> u32 {
4179 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) }
4182 pub fn set_q_scale_type(&mut self, val: u32) {
4184 let val: u32 = ::std::mem::transmute(val);
4185 self._bitfield_1.set(7usize, 1u8, val as u64)
4189 pub fn intra_vlc_format(&self) -> u32 {
4190 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) }
4193 pub fn set_intra_vlc_format(&mut self, val: u32) {
4195 let val: u32 = ::std::mem::transmute(val);
4196 self._bitfield_1.set(8usize, 1u8, val as u64)
4200 pub fn alternate_scan(&self) -> u32 {
4201 unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) }
4204 pub fn set_alternate_scan(&mut self, val: u32) {
4206 let val: u32 = ::std::mem::transmute(val);
4207 self._bitfield_1.set(9usize, 1u8, val as u64)
4211 pub fn repeat_first_field(&self) -> u32 {
4212 unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) }
4215 pub fn set_repeat_first_field(&mut self, val: u32) {
4217 let val: u32 = ::std::mem::transmute(val);
4218 self._bitfield_1.set(10usize, 1u8, val as u64)
4222 pub fn progressive_frame(&self) -> u32 {
4223 unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) }
4226 pub fn set_progressive_frame(&mut self, val: u32) {
4228 let val: u32 = ::std::mem::transmute(val);
4229 self._bitfield_1.set(11usize, 1u8, val as u64)
4233 pub fn composite_display_flag(&self) -> u32 {
4234 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u32) }
4237 pub fn set_composite_display_flag(&mut self, val: u32) {
4239 let val: u32 = ::std::mem::transmute(val);
4240 self._bitfield_1.set(12usize, 1u8, val as u64)
4244 pub fn new_bitfield_1(
4245 intra_dc_precision: u32,
4246 picture_structure: u32,
4247 top_field_first: u32,
4248 frame_pred_frame_dct: u32,
4249 concealment_motion_vectors: u32,
4251 intra_vlc_format: u32,
4252 alternate_scan: u32,
4253 repeat_first_field: u32,
4254 progressive_frame: u32,
4255 composite_display_flag: u32,
4256 ) -> __BindgenBitfieldUnit<[u8; 2usize]> {
4257 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default();
4258 __bindgen_bitfield_unit.set(0usize, 2u8, {
4259 let intra_dc_precision: u32 = unsafe { ::std::mem::transmute(intra_dc_precision) };
4260 intra_dc_precision as u64
4262 __bindgen_bitfield_unit.set(2usize, 2u8, {
4263 let picture_structure: u32 = unsafe { ::std::mem::transmute(picture_structure) };
4264 picture_structure as u64
4266 __bindgen_bitfield_unit.set(4usize, 1u8, {
4267 let top_field_first: u32 = unsafe { ::std::mem::transmute(top_field_first) };
4268 top_field_first as u64
4270 __bindgen_bitfield_unit.set(5usize, 1u8, {
4271 let frame_pred_frame_dct: u32 = unsafe { ::std::mem::transmute(frame_pred_frame_dct) };
4272 frame_pred_frame_dct as u64
4274 __bindgen_bitfield_unit.set(6usize, 1u8, {
4275 let concealment_motion_vectors: u32 =
4276 unsafe { ::std::mem::transmute(concealment_motion_vectors) };
4277 concealment_motion_vectors as u64
4279 __bindgen_bitfield_unit.set(7usize, 1u8, {
4280 let q_scale_type: u32 = unsafe { ::std::mem::transmute(q_scale_type) };
4283 __bindgen_bitfield_unit.set(8usize, 1u8, {
4284 let intra_vlc_format: u32 = unsafe { ::std::mem::transmute(intra_vlc_format) };
4285 intra_vlc_format as u64
4287 __bindgen_bitfield_unit.set(9usize, 1u8, {
4288 let alternate_scan: u32 = unsafe { ::std::mem::transmute(alternate_scan) };
4289 alternate_scan as u64
4291 __bindgen_bitfield_unit.set(10usize, 1u8, {
4292 let repeat_first_field: u32 = unsafe { ::std::mem::transmute(repeat_first_field) };
4293 repeat_first_field as u64
4295 __bindgen_bitfield_unit.set(11usize, 1u8, {
4296 let progressive_frame: u32 = unsafe { ::std::mem::transmute(progressive_frame) };
4297 progressive_frame as u64
4299 __bindgen_bitfield_unit.set(12usize, 1u8, {
4300 let composite_display_flag: u32 =
4301 unsafe { ::std::mem::transmute(composite_display_flag) };
4302 composite_display_flag as u64
4304 __bindgen_bitfield_unit
4307 impl Default for _VAEncPictureParameterBufferMPEG2__bindgen_ty_1 {
4308 fn default() -> Self {
4309 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4311 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4317 #[derive(Copy, Clone)]
4318 pub union _VAEncPictureParameterBufferMPEG2__bindgen_ty_2 {
4319 pub bits: _VAEncPictureParameterBufferMPEG2__bindgen_ty_2__bindgen_ty_1,
4324 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
4325 pub struct _VAEncPictureParameterBufferMPEG2__bindgen_ty_2__bindgen_ty_1 {
4326 pub _bitfield_align_1: [u8; 0],
4327 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 3usize]>,
4328 pub __bindgen_padding_0: u8,
4330 impl _VAEncPictureParameterBufferMPEG2__bindgen_ty_2__bindgen_ty_1 {
4332 pub fn v_axis(&self) -> u32 {
4333 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
4336 pub fn set_v_axis(&mut self, val: u32) {
4338 let val: u32 = ::std::mem::transmute(val);
4339 self._bitfield_1.set(0usize, 1u8, val as u64)
4343 pub fn field_sequence(&self) -> u32 {
4344 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 3u8) as u32) }
4347 pub fn set_field_sequence(&mut self, val: u32) {
4349 let val: u32 = ::std::mem::transmute(val);
4350 self._bitfield_1.set(1usize, 3u8, val as u64)
4354 pub fn sub_carrier(&self) -> u32 {
4355 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
4358 pub fn set_sub_carrier(&mut self, val: u32) {
4360 let val: u32 = ::std::mem::transmute(val);
4361 self._bitfield_1.set(4usize, 1u8, val as u64)
4365 pub fn burst_amplitude(&self) -> u32 {
4366 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 7u8) as u32) }
4369 pub fn set_burst_amplitude(&mut self, val: u32) {
4371 let val: u32 = ::std::mem::transmute(val);
4372 self._bitfield_1.set(5usize, 7u8, val as u64)
4376 pub fn sub_carrier_phase(&self) -> u32 {
4377 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 8u8) as u32) }
4380 pub fn set_sub_carrier_phase(&mut self, val: u32) {
4382 let val: u32 = ::std::mem::transmute(val);
4383 self._bitfield_1.set(12usize, 8u8, val as u64)
4387 pub fn new_bitfield_1(
4389 field_sequence: u32,
4391 burst_amplitude: u32,
4392 sub_carrier_phase: u32,
4393 ) -> __BindgenBitfieldUnit<[u8; 3usize]> {
4394 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 3usize]> = Default::default();
4395 __bindgen_bitfield_unit.set(0usize, 1u8, {
4396 let v_axis: u32 = unsafe { ::std::mem::transmute(v_axis) };
4399 __bindgen_bitfield_unit.set(1usize, 3u8, {
4400 let field_sequence: u32 = unsafe { ::std::mem::transmute(field_sequence) };
4401 field_sequence as u64
4403 __bindgen_bitfield_unit.set(4usize, 1u8, {
4404 let sub_carrier: u32 = unsafe { ::std::mem::transmute(sub_carrier) };
4407 __bindgen_bitfield_unit.set(5usize, 7u8, {
4408 let burst_amplitude: u32 = unsafe { ::std::mem::transmute(burst_amplitude) };
4409 burst_amplitude as u64
4411 __bindgen_bitfield_unit.set(12usize, 8u8, {
4412 let sub_carrier_phase: u32 = unsafe { ::std::mem::transmute(sub_carrier_phase) };
4413 sub_carrier_phase as u64
4415 __bindgen_bitfield_unit
4418 impl Default for _VAEncPictureParameterBufferMPEG2__bindgen_ty_2 {
4419 fn default() -> Self {
4420 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4422 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4427 impl Default for _VAEncPictureParameterBufferMPEG2 {
4428 fn default() -> Self {
4429 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4431 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4436 pub type VAEncPictureParameterBufferMPEG2 = _VAEncPictureParameterBufferMPEG2;
4438 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
4439 pub struct _VAEncSliceParameterBufferMPEG2 {
4440 pub macroblock_address: u32,
4441 pub num_macroblocks: u32,
4442 pub quantiser_scale_code: i32,
4443 pub is_intra_slice: i32,
4444 pub va_reserved: [u32; 4usize],
4446 pub type VAEncSliceParameterBufferMPEG2 = _VAEncSliceParameterBufferMPEG2;
4448 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
4449 pub struct _VAEncMiscParameterExtensionDataSeqDisplayMPEG2 {
4450 pub extension_start_code_identifier: u8,
4451 pub video_format: u8,
4452 pub colour_description: u8,
4453 pub colour_primaries: u8,
4454 pub transfer_characteristics: u8,
4455 pub matrix_coefficients: u8,
4456 pub display_horizontal_size: u16,
4457 pub display_vertical_size: u16,
4459 pub type VAEncMiscParameterExtensionDataSeqDisplayMPEG2 =
4460 _VAEncMiscParameterExtensionDataSeqDisplayMPEG2;
4462 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
4463 pub struct _VAEncSequenceParameterBufferVP8 {
4464 pub frame_width: u32,
4465 pub frame_height: u32,
4466 pub frame_width_scale: u32,
4467 pub frame_height_scale: u32,
4468 pub error_resilient: u32,
4470 pub kf_min_dist: u32,
4471 pub kf_max_dist: u32,
4472 pub bits_per_second: u32,
4473 pub intra_period: u32,
4474 pub reference_frames: [VASurfaceID; 4usize],
4475 pub va_reserved: [u32; 4usize],
4477 pub type VAEncSequenceParameterBufferVP8 = _VAEncSequenceParameterBufferVP8;
4479 #[derive(Copy, Clone)]
4480 pub struct _VAEncPictureParameterBufferVP8 {
4481 pub reconstructed_frame: VASurfaceID,
4482 pub ref_last_frame: VASurfaceID,
4483 pub ref_gf_frame: VASurfaceID,
4484 pub ref_arf_frame: VASurfaceID,
4485 pub coded_buf: VABufferID,
4486 pub ref_flags: _VAEncPictureParameterBufferVP8__bindgen_ty_1,
4487 pub pic_flags: _VAEncPictureParameterBufferVP8__bindgen_ty_2,
4488 pub loop_filter_level: [i8; 4usize],
4489 pub ref_lf_delta: [i8; 4usize],
4490 pub mode_lf_delta: [i8; 4usize],
4491 pub sharpness_level: u8,
4492 pub clamp_qindex_high: u8,
4493 pub clamp_qindex_low: u8,
4494 pub va_reserved: [u32; 4usize],
4497 #[derive(Copy, Clone)]
4498 pub union _VAEncPictureParameterBufferVP8__bindgen_ty_1 {
4499 pub bits: _VAEncPictureParameterBufferVP8__bindgen_ty_1__bindgen_ty_1,
4504 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
4505 pub struct _VAEncPictureParameterBufferVP8__bindgen_ty_1__bindgen_ty_1 {
4506 pub _bitfield_align_1: [u16; 0],
4507 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
4509 impl _VAEncPictureParameterBufferVP8__bindgen_ty_1__bindgen_ty_1 {
4511 pub fn force_kf(&self) -> u32 {
4512 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
4515 pub fn set_force_kf(&mut self, val: u32) {
4517 let val: u32 = ::std::mem::transmute(val);
4518 self._bitfield_1.set(0usize, 1u8, val as u64)
4522 pub fn no_ref_last(&self) -> u32 {
4523 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
4526 pub fn set_no_ref_last(&mut self, val: u32) {
4528 let val: u32 = ::std::mem::transmute(val);
4529 self._bitfield_1.set(1usize, 1u8, val as u64)
4533 pub fn no_ref_gf(&self) -> u32 {
4534 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
4537 pub fn set_no_ref_gf(&mut self, val: u32) {
4539 let val: u32 = ::std::mem::transmute(val);
4540 self._bitfield_1.set(2usize, 1u8, val as u64)
4544 pub fn no_ref_arf(&self) -> u32 {
4545 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
4548 pub fn set_no_ref_arf(&mut self, val: u32) {
4550 let val: u32 = ::std::mem::transmute(val);
4551 self._bitfield_1.set(3usize, 1u8, val as u64)
4555 pub fn temporal_id(&self) -> u32 {
4556 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 8u8) as u32) }
4559 pub fn set_temporal_id(&mut self, val: u32) {
4561 let val: u32 = ::std::mem::transmute(val);
4562 self._bitfield_1.set(4usize, 8u8, val as u64)
4566 pub fn first_ref(&self) -> u32 {
4567 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 2u8) as u32) }
4570 pub fn set_first_ref(&mut self, val: u32) {
4572 let val: u32 = ::std::mem::transmute(val);
4573 self._bitfield_1.set(12usize, 2u8, val as u64)
4577 pub fn second_ref(&self) -> u32 {
4578 unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 2u8) as u32) }
4581 pub fn set_second_ref(&mut self, val: u32) {
4583 let val: u32 = ::std::mem::transmute(val);
4584 self._bitfield_1.set(14usize, 2u8, val as u64)
4588 pub fn reserved(&self) -> u32 {
4589 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 16u8) as u32) }
4592 pub fn set_reserved(&mut self, val: u32) {
4594 let val: u32 = ::std::mem::transmute(val);
4595 self._bitfield_1.set(16usize, 16u8, val as u64)
4599 pub fn new_bitfield_1(
4608 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
4609 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
4610 __bindgen_bitfield_unit.set(0usize, 1u8, {
4611 let force_kf: u32 = unsafe { ::std::mem::transmute(force_kf) };
4614 __bindgen_bitfield_unit.set(1usize, 1u8, {
4615 let no_ref_last: u32 = unsafe { ::std::mem::transmute(no_ref_last) };
4618 __bindgen_bitfield_unit.set(2usize, 1u8, {
4619 let no_ref_gf: u32 = unsafe { ::std::mem::transmute(no_ref_gf) };
4622 __bindgen_bitfield_unit.set(3usize, 1u8, {
4623 let no_ref_arf: u32 = unsafe { ::std::mem::transmute(no_ref_arf) };
4626 __bindgen_bitfield_unit.set(4usize, 8u8, {
4627 let temporal_id: u32 = unsafe { ::std::mem::transmute(temporal_id) };
4630 __bindgen_bitfield_unit.set(12usize, 2u8, {
4631 let first_ref: u32 = unsafe { ::std::mem::transmute(first_ref) };
4634 __bindgen_bitfield_unit.set(14usize, 2u8, {
4635 let second_ref: u32 = unsafe { ::std::mem::transmute(second_ref) };
4638 __bindgen_bitfield_unit.set(16usize, 16u8, {
4639 let reserved: u32 = unsafe { ::std::mem::transmute(reserved) };
4642 __bindgen_bitfield_unit
4645 impl Default for _VAEncPictureParameterBufferVP8__bindgen_ty_1 {
4646 fn default() -> Self {
4647 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4649 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4655 #[derive(Copy, Clone)]
4656 pub union _VAEncPictureParameterBufferVP8__bindgen_ty_2 {
4657 pub bits: _VAEncPictureParameterBufferVP8__bindgen_ty_2__bindgen_ty_1,
4662 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
4663 pub struct _VAEncPictureParameterBufferVP8__bindgen_ty_2__bindgen_ty_1 {
4664 pub _bitfield_align_1: [u8; 0],
4665 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
4667 impl _VAEncPictureParameterBufferVP8__bindgen_ty_2__bindgen_ty_1 {
4669 pub fn frame_type(&self) -> u32 {
4670 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
4673 pub fn set_frame_type(&mut self, val: u32) {
4675 let val: u32 = ::std::mem::transmute(val);
4676 self._bitfield_1.set(0usize, 1u8, val as u64)
4680 pub fn version(&self) -> u32 {
4681 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 3u8) as u32) }
4684 pub fn set_version(&mut self, val: u32) {
4686 let val: u32 = ::std::mem::transmute(val);
4687 self._bitfield_1.set(1usize, 3u8, val as u64)
4691 pub fn show_frame(&self) -> u32 {
4692 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
4695 pub fn set_show_frame(&mut self, val: u32) {
4697 let val: u32 = ::std::mem::transmute(val);
4698 self._bitfield_1.set(4usize, 1u8, val as u64)
4702 pub fn color_space(&self) -> u32 {
4703 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
4706 pub fn set_color_space(&mut self, val: u32) {
4708 let val: u32 = ::std::mem::transmute(val);
4709 self._bitfield_1.set(5usize, 1u8, val as u64)
4713 pub fn recon_filter_type(&self) -> u32 {
4714 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 2u8) as u32) }
4717 pub fn set_recon_filter_type(&mut self, val: u32) {
4719 let val: u32 = ::std::mem::transmute(val);
4720 self._bitfield_1.set(6usize, 2u8, val as u64)
4724 pub fn loop_filter_type(&self) -> u32 {
4725 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 2u8) as u32) }
4728 pub fn set_loop_filter_type(&mut self, val: u32) {
4730 let val: u32 = ::std::mem::transmute(val);
4731 self._bitfield_1.set(8usize, 2u8, val as u64)
4735 pub fn auto_partitions(&self) -> u32 {
4736 unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) }
4739 pub fn set_auto_partitions(&mut self, val: u32) {
4741 let val: u32 = ::std::mem::transmute(val);
4742 self._bitfield_1.set(10usize, 1u8, val as u64)
4746 pub fn num_token_partitions(&self) -> u32 {
4747 unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 2u8) as u32) }
4750 pub fn set_num_token_partitions(&mut self, val: u32) {
4752 let val: u32 = ::std::mem::transmute(val);
4753 self._bitfield_1.set(11usize, 2u8, val as u64)
4757 pub fn clamping_type(&self) -> u32 {
4758 unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) }
4761 pub fn set_clamping_type(&mut self, val: u32) {
4763 let val: u32 = ::std::mem::transmute(val);
4764 self._bitfield_1.set(13usize, 1u8, val as u64)
4768 pub fn segmentation_enabled(&self) -> u32 {
4769 unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) }
4772 pub fn set_segmentation_enabled(&mut self, val: u32) {
4774 let val: u32 = ::std::mem::transmute(val);
4775 self._bitfield_1.set(14usize, 1u8, val as u64)
4779 pub fn update_mb_segmentation_map(&self) -> u32 {
4780 unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u32) }
4783 pub fn set_update_mb_segmentation_map(&mut self, val: u32) {
4785 let val: u32 = ::std::mem::transmute(val);
4786 self._bitfield_1.set(15usize, 1u8, val as u64)
4790 pub fn update_segment_feature_data(&self) -> u32 {
4791 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u32) }
4794 pub fn set_update_segment_feature_data(&mut self, val: u32) {
4796 let val: u32 = ::std::mem::transmute(val);
4797 self._bitfield_1.set(16usize, 1u8, val as u64)
4801 pub fn loop_filter_adj_enable(&self) -> u32 {
4802 unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 1u8) as u32) }
4805 pub fn set_loop_filter_adj_enable(&mut self, val: u32) {
4807 let val: u32 = ::std::mem::transmute(val);
4808 self._bitfield_1.set(17usize, 1u8, val as u64)
4812 pub fn refresh_entropy_probs(&self) -> u32 {
4813 unsafe { ::std::mem::transmute(self._bitfield_1.get(18usize, 1u8) as u32) }
4816 pub fn set_refresh_entropy_probs(&mut self, val: u32) {
4818 let val: u32 = ::std::mem::transmute(val);
4819 self._bitfield_1.set(18usize, 1u8, val as u64)
4823 pub fn refresh_golden_frame(&self) -> u32 {
4824 unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 1u8) as u32) }
4827 pub fn set_refresh_golden_frame(&mut self, val: u32) {
4829 let val: u32 = ::std::mem::transmute(val);
4830 self._bitfield_1.set(19usize, 1u8, val as u64)
4834 pub fn refresh_alternate_frame(&self) -> u32 {
4835 unsafe { ::std::mem::transmute(self._bitfield_1.get(20usize, 1u8) as u32) }
4838 pub fn set_refresh_alternate_frame(&mut self, val: u32) {
4840 let val: u32 = ::std::mem::transmute(val);
4841 self._bitfield_1.set(20usize, 1u8, val as u64)
4845 pub fn refresh_last(&self) -> u32 {
4846 unsafe { ::std::mem::transmute(self._bitfield_1.get(21usize, 1u8) as u32) }
4849 pub fn set_refresh_last(&mut self, val: u32) {
4851 let val: u32 = ::std::mem::transmute(val);
4852 self._bitfield_1.set(21usize, 1u8, val as u64)
4856 pub fn copy_buffer_to_golden(&self) -> u32 {
4857 unsafe { ::std::mem::transmute(self._bitfield_1.get(22usize, 2u8) as u32) }
4860 pub fn set_copy_buffer_to_golden(&mut self, val: u32) {
4862 let val: u32 = ::std::mem::transmute(val);
4863 self._bitfield_1.set(22usize, 2u8, val as u64)
4867 pub fn copy_buffer_to_alternate(&self) -> u32 {
4868 unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 2u8) as u32) }
4871 pub fn set_copy_buffer_to_alternate(&mut self, val: u32) {
4873 let val: u32 = ::std::mem::transmute(val);
4874 self._bitfield_1.set(24usize, 2u8, val as u64)
4878 pub fn sign_bias_golden(&self) -> u32 {
4879 unsafe { ::std::mem::transmute(self._bitfield_1.get(26usize, 1u8) as u32) }
4882 pub fn set_sign_bias_golden(&mut self, val: u32) {
4884 let val: u32 = ::std::mem::transmute(val);
4885 self._bitfield_1.set(26usize, 1u8, val as u64)
4889 pub fn sign_bias_alternate(&self) -> u32 {
4890 unsafe { ::std::mem::transmute(self._bitfield_1.get(27usize, 1u8) as u32) }
4893 pub fn set_sign_bias_alternate(&mut self, val: u32) {
4895 let val: u32 = ::std::mem::transmute(val);
4896 self._bitfield_1.set(27usize, 1u8, val as u64)
4900 pub fn mb_no_coeff_skip(&self) -> u32 {
4901 unsafe { ::std::mem::transmute(self._bitfield_1.get(28usize, 1u8) as u32) }
4904 pub fn set_mb_no_coeff_skip(&mut self, val: u32) {
4906 let val: u32 = ::std::mem::transmute(val);
4907 self._bitfield_1.set(28usize, 1u8, val as u64)
4911 pub fn forced_lf_adjustment(&self) -> u32 {
4912 unsafe { ::std::mem::transmute(self._bitfield_1.get(29usize, 1u8) as u32) }
4915 pub fn set_forced_lf_adjustment(&mut self, val: u32) {
4917 let val: u32 = ::std::mem::transmute(val);
4918 self._bitfield_1.set(29usize, 1u8, val as u64)
4922 pub fn reserved(&self) -> u32 {
4923 unsafe { ::std::mem::transmute(self._bitfield_1.get(30usize, 2u8) as u32) }
4926 pub fn set_reserved(&mut self, val: u32) {
4928 let val: u32 = ::std::mem::transmute(val);
4929 self._bitfield_1.set(30usize, 2u8, val as u64)
4933 pub fn new_bitfield_1(
4938 recon_filter_type: u32,
4939 loop_filter_type: u32,
4940 auto_partitions: u32,
4941 num_token_partitions: u32,
4943 segmentation_enabled: u32,
4944 update_mb_segmentation_map: u32,
4945 update_segment_feature_data: u32,
4946 loop_filter_adj_enable: u32,
4947 refresh_entropy_probs: u32,
4948 refresh_golden_frame: u32,
4949 refresh_alternate_frame: u32,
4951 copy_buffer_to_golden: u32,
4952 copy_buffer_to_alternate: u32,
4953 sign_bias_golden: u32,
4954 sign_bias_alternate: u32,
4955 mb_no_coeff_skip: u32,
4956 forced_lf_adjustment: u32,
4958 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
4959 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
4960 __bindgen_bitfield_unit.set(0usize, 1u8, {
4961 let frame_type: u32 = unsafe { ::std::mem::transmute(frame_type) };
4964 __bindgen_bitfield_unit.set(1usize, 3u8, {
4965 let version: u32 = unsafe { ::std::mem::transmute(version) };
4968 __bindgen_bitfield_unit.set(4usize, 1u8, {
4969 let show_frame: u32 = unsafe { ::std::mem::transmute(show_frame) };
4972 __bindgen_bitfield_unit.set(5usize, 1u8, {
4973 let color_space: u32 = unsafe { ::std::mem::transmute(color_space) };
4976 __bindgen_bitfield_unit.set(6usize, 2u8, {
4977 let recon_filter_type: u32 = unsafe { ::std::mem::transmute(recon_filter_type) };
4978 recon_filter_type as u64
4980 __bindgen_bitfield_unit.set(8usize, 2u8, {
4981 let loop_filter_type: u32 = unsafe { ::std::mem::transmute(loop_filter_type) };
4982 loop_filter_type as u64
4984 __bindgen_bitfield_unit.set(10usize, 1u8, {
4985 let auto_partitions: u32 = unsafe { ::std::mem::transmute(auto_partitions) };
4986 auto_partitions as u64
4988 __bindgen_bitfield_unit.set(11usize, 2u8, {
4989 let num_token_partitions: u32 = unsafe { ::std::mem::transmute(num_token_partitions) };
4990 num_token_partitions as u64
4992 __bindgen_bitfield_unit.set(13usize, 1u8, {
4993 let clamping_type: u32 = unsafe { ::std::mem::transmute(clamping_type) };
4994 clamping_type as u64
4996 __bindgen_bitfield_unit.set(14usize, 1u8, {
4997 let segmentation_enabled: u32 = unsafe { ::std::mem::transmute(segmentation_enabled) };
4998 segmentation_enabled as u64
5000 __bindgen_bitfield_unit.set(15usize, 1u8, {
5001 let update_mb_segmentation_map: u32 =
5002 unsafe { ::std::mem::transmute(update_mb_segmentation_map) };
5003 update_mb_segmentation_map as u64
5005 __bindgen_bitfield_unit.set(16usize, 1u8, {
5006 let update_segment_feature_data: u32 =
5007 unsafe { ::std::mem::transmute(update_segment_feature_data) };
5008 update_segment_feature_data as u64
5010 __bindgen_bitfield_unit.set(17usize, 1u8, {
5011 let loop_filter_adj_enable: u32 =
5012 unsafe { ::std::mem::transmute(loop_filter_adj_enable) };
5013 loop_filter_adj_enable as u64
5015 __bindgen_bitfield_unit.set(18usize, 1u8, {
5016 let refresh_entropy_probs: u32 =
5017 unsafe { ::std::mem::transmute(refresh_entropy_probs) };
5018 refresh_entropy_probs as u64
5020 __bindgen_bitfield_unit.set(19usize, 1u8, {
5021 let refresh_golden_frame: u32 = unsafe { ::std::mem::transmute(refresh_golden_frame) };
5022 refresh_golden_frame as u64
5024 __bindgen_bitfield_unit.set(20usize, 1u8, {
5025 let refresh_alternate_frame: u32 =
5026 unsafe { ::std::mem::transmute(refresh_alternate_frame) };
5027 refresh_alternate_frame as u64
5029 __bindgen_bitfield_unit.set(21usize, 1u8, {
5030 let refresh_last: u32 = unsafe { ::std::mem::transmute(refresh_last) };
5033 __bindgen_bitfield_unit.set(22usize, 2u8, {
5034 let copy_buffer_to_golden: u32 =
5035 unsafe { ::std::mem::transmute(copy_buffer_to_golden) };
5036 copy_buffer_to_golden as u64
5038 __bindgen_bitfield_unit.set(24usize, 2u8, {
5039 let copy_buffer_to_alternate: u32 =
5040 unsafe { ::std::mem::transmute(copy_buffer_to_alternate) };
5041 copy_buffer_to_alternate as u64
5043 __bindgen_bitfield_unit.set(26usize, 1u8, {
5044 let sign_bias_golden: u32 = unsafe { ::std::mem::transmute(sign_bias_golden) };
5045 sign_bias_golden as u64
5047 __bindgen_bitfield_unit.set(27usize, 1u8, {
5048 let sign_bias_alternate: u32 = unsafe { ::std::mem::transmute(sign_bias_alternate) };
5049 sign_bias_alternate as u64
5051 __bindgen_bitfield_unit.set(28usize, 1u8, {
5052 let mb_no_coeff_skip: u32 = unsafe { ::std::mem::transmute(mb_no_coeff_skip) };
5053 mb_no_coeff_skip as u64
5055 __bindgen_bitfield_unit.set(29usize, 1u8, {
5056 let forced_lf_adjustment: u32 = unsafe { ::std::mem::transmute(forced_lf_adjustment) };
5057 forced_lf_adjustment as u64
5059 __bindgen_bitfield_unit.set(30usize, 2u8, {
5060 let reserved: u32 = unsafe { ::std::mem::transmute(reserved) };
5063 __bindgen_bitfield_unit
5066 impl Default for _VAEncPictureParameterBufferVP8__bindgen_ty_2 {
5067 fn default() -> Self {
5068 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5070 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5075 impl Default for _VAEncPictureParameterBufferVP8 {
5076 fn default() -> Self {
5077 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5079 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5084 pub type VAEncPictureParameterBufferVP8 = _VAEncPictureParameterBufferVP8;
5086 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
5087 pub struct _VAEncMBMapBufferVP8 {
5089 pub mb_segment_id: *mut u8,
5090 pub va_reserved: [u32; 4usize],
5092 impl Default for _VAEncMBMapBufferVP8 {
5093 fn default() -> Self {
5094 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5096 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5101 pub type VAEncMBMapBufferVP8 = _VAEncMBMapBufferVP8;
5103 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
5104 pub struct _VAQMatrixBufferVP8 {
5105 pub quantization_index: [u16; 4usize],
5106 pub quantization_index_delta: [i16; 5usize],
5107 pub va_reserved: [u32; 4usize],
5109 pub type VAQMatrixBufferVP8 = _VAQMatrixBufferVP8;
5111 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
5112 pub struct _VACodedBufferVP9Status {
5113 pub base_qp_index: u16,
5114 pub loop_filter_level: u8,
5115 pub long_term_indication: u8,
5116 pub next_frame_width: u16,
5117 pub next_frame_height: u16,
5118 pub va_reserved: [u32; 4usize],
5120 pub type VACodedBufferVP9Status = _VACodedBufferVP9Status;
5122 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
5123 pub struct _VAEncSequenceParameterBufferVP9 {
5124 pub max_frame_width: u32,
5125 pub max_frame_height: u32,
5127 pub kf_min_dist: u32,
5128 pub kf_max_dist: u32,
5129 pub bits_per_second: u32,
5130 pub intra_period: u32,
5131 pub va_reserved: [u32; 4usize],
5133 pub type VAEncSequenceParameterBufferVP9 = _VAEncSequenceParameterBufferVP9;
5135 #[derive(Copy, Clone)]
5136 pub struct _VAEncPictureParameterBufferVP9 {
5137 pub frame_width_src: u32,
5138 pub frame_height_src: u32,
5139 pub frame_width_dst: u32,
5140 pub frame_height_dst: u32,
5141 pub reconstructed_frame: VASurfaceID,
5142 pub reference_frames: [VASurfaceID; 8usize],
5143 pub coded_buf: VABufferID,
5144 pub ref_flags: _VAEncPictureParameterBufferVP9__bindgen_ty_1,
5145 pub pic_flags: _VAEncPictureParameterBufferVP9__bindgen_ty_2,
5146 pub refresh_frame_flags: u8,
5147 pub luma_ac_qindex: u8,
5148 pub luma_dc_qindex_delta: i8,
5149 pub chroma_ac_qindex_delta: i8,
5150 pub chroma_dc_qindex_delta: i8,
5151 pub filter_level: u8,
5152 pub sharpness_level: u8,
5153 pub ref_lf_delta: [i8; 4usize],
5154 pub mode_lf_delta: [i8; 2usize],
5155 pub bit_offset_ref_lf_delta: u16,
5156 pub bit_offset_mode_lf_delta: u16,
5157 pub bit_offset_lf_level: u16,
5158 pub bit_offset_qindex: u16,
5159 pub bit_offset_first_partition_size: u16,
5160 pub bit_offset_segmentation: u16,
5161 pub bit_size_segmentation: u16,
5162 pub log2_tile_rows: u8,
5163 pub log2_tile_columns: u8,
5164 pub skip_frame_flag: u8,
5165 pub number_skip_frames: u8,
5166 pub skip_frames_size: u32,
5167 pub va_reserved: [u32; 8usize],
5170 #[derive(Copy, Clone)]
5171 pub union _VAEncPictureParameterBufferVP9__bindgen_ty_1 {
5172 pub bits: _VAEncPictureParameterBufferVP9__bindgen_ty_1__bindgen_ty_1,
5177 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
5178 pub struct _VAEncPictureParameterBufferVP9__bindgen_ty_1__bindgen_ty_1 {
5179 pub _bitfield_align_1: [u8; 0],
5180 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
5182 impl _VAEncPictureParameterBufferVP9__bindgen_ty_1__bindgen_ty_1 {
5184 pub fn force_kf(&self) -> u32 {
5185 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
5188 pub fn set_force_kf(&mut self, val: u32) {
5190 let val: u32 = ::std::mem::transmute(val);
5191 self._bitfield_1.set(0usize, 1u8, val as u64)
5195 pub fn ref_frame_ctrl_l0(&self) -> u32 {
5196 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 3u8) as u32) }
5199 pub fn set_ref_frame_ctrl_l0(&mut self, val: u32) {
5201 let val: u32 = ::std::mem::transmute(val);
5202 self._bitfield_1.set(1usize, 3u8, val as u64)
5206 pub fn ref_frame_ctrl_l1(&self) -> u32 {
5207 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 3u8) as u32) }
5210 pub fn set_ref_frame_ctrl_l1(&mut self, val: u32) {
5212 let val: u32 = ::std::mem::transmute(val);
5213 self._bitfield_1.set(4usize, 3u8, val as u64)
5217 pub fn ref_last_idx(&self) -> u32 {
5218 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 3u8) as u32) }
5221 pub fn set_ref_last_idx(&mut self, val: u32) {
5223 let val: u32 = ::std::mem::transmute(val);
5224 self._bitfield_1.set(7usize, 3u8, val as u64)
5228 pub fn ref_last_sign_bias(&self) -> u32 {
5229 unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) }
5232 pub fn set_ref_last_sign_bias(&mut self, val: u32) {
5234 let val: u32 = ::std::mem::transmute(val);
5235 self._bitfield_1.set(10usize, 1u8, val as u64)
5239 pub fn ref_gf_idx(&self) -> u32 {
5240 unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 3u8) as u32) }
5243 pub fn set_ref_gf_idx(&mut self, val: u32) {
5245 let val: u32 = ::std::mem::transmute(val);
5246 self._bitfield_1.set(11usize, 3u8, val as u64)
5250 pub fn ref_gf_sign_bias(&self) -> u32 {
5251 unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) }
5254 pub fn set_ref_gf_sign_bias(&mut self, val: u32) {
5256 let val: u32 = ::std::mem::transmute(val);
5257 self._bitfield_1.set(14usize, 1u8, val as u64)
5261 pub fn ref_arf_idx(&self) -> u32 {
5262 unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 3u8) as u32) }
5265 pub fn set_ref_arf_idx(&mut self, val: u32) {
5267 let val: u32 = ::std::mem::transmute(val);
5268 self._bitfield_1.set(15usize, 3u8, val as u64)
5272 pub fn ref_arf_sign_bias(&self) -> u32 {
5273 unsafe { ::std::mem::transmute(self._bitfield_1.get(18usize, 1u8) as u32) }
5276 pub fn set_ref_arf_sign_bias(&mut self, val: u32) {
5278 let val: u32 = ::std::mem::transmute(val);
5279 self._bitfield_1.set(18usize, 1u8, val as u64)
5283 pub fn temporal_id(&self) -> u32 {
5284 unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 8u8) as u32) }
5287 pub fn set_temporal_id(&mut self, val: u32) {
5289 let val: u32 = ::std::mem::transmute(val);
5290 self._bitfield_1.set(19usize, 8u8, val as u64)
5294 pub fn reserved(&self) -> u32 {
5295 unsafe { ::std::mem::transmute(self._bitfield_1.get(27usize, 5u8) as u32) }
5298 pub fn set_reserved(&mut self, val: u32) {
5300 let val: u32 = ::std::mem::transmute(val);
5301 self._bitfield_1.set(27usize, 5u8, val as u64)
5305 pub fn new_bitfield_1(
5307 ref_frame_ctrl_l0: u32,
5308 ref_frame_ctrl_l1: u32,
5310 ref_last_sign_bias: u32,
5312 ref_gf_sign_bias: u32,
5314 ref_arf_sign_bias: u32,
5317 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
5318 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
5319 __bindgen_bitfield_unit.set(0usize, 1u8, {
5320 let force_kf: u32 = unsafe { ::std::mem::transmute(force_kf) };
5323 __bindgen_bitfield_unit.set(1usize, 3u8, {
5324 let ref_frame_ctrl_l0: u32 = unsafe { ::std::mem::transmute(ref_frame_ctrl_l0) };
5325 ref_frame_ctrl_l0 as u64
5327 __bindgen_bitfield_unit.set(4usize, 3u8, {
5328 let ref_frame_ctrl_l1: u32 = unsafe { ::std::mem::transmute(ref_frame_ctrl_l1) };
5329 ref_frame_ctrl_l1 as u64
5331 __bindgen_bitfield_unit.set(7usize, 3u8, {
5332 let ref_last_idx: u32 = unsafe { ::std::mem::transmute(ref_last_idx) };
5335 __bindgen_bitfield_unit.set(10usize, 1u8, {
5336 let ref_last_sign_bias: u32 = unsafe { ::std::mem::transmute(ref_last_sign_bias) };
5337 ref_last_sign_bias as u64
5339 __bindgen_bitfield_unit.set(11usize, 3u8, {
5340 let ref_gf_idx: u32 = unsafe { ::std::mem::transmute(ref_gf_idx) };
5343 __bindgen_bitfield_unit.set(14usize, 1u8, {
5344 let ref_gf_sign_bias: u32 = unsafe { ::std::mem::transmute(ref_gf_sign_bias) };
5345 ref_gf_sign_bias as u64
5347 __bindgen_bitfield_unit.set(15usize, 3u8, {
5348 let ref_arf_idx: u32 = unsafe { ::std::mem::transmute(ref_arf_idx) };
5351 __bindgen_bitfield_unit.set(18usize, 1u8, {
5352 let ref_arf_sign_bias: u32 = unsafe { ::std::mem::transmute(ref_arf_sign_bias) };
5353 ref_arf_sign_bias as u64
5355 __bindgen_bitfield_unit.set(19usize, 8u8, {
5356 let temporal_id: u32 = unsafe { ::std::mem::transmute(temporal_id) };
5359 __bindgen_bitfield_unit.set(27usize, 5u8, {
5360 let reserved: u32 = unsafe { ::std::mem::transmute(reserved) };
5363 __bindgen_bitfield_unit
5366 impl Default for _VAEncPictureParameterBufferVP9__bindgen_ty_1 {
5367 fn default() -> Self {
5368 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5370 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5376 #[derive(Copy, Clone)]
5377 pub union _VAEncPictureParameterBufferVP9__bindgen_ty_2 {
5378 pub bits: _VAEncPictureParameterBufferVP9__bindgen_ty_2__bindgen_ty_1,
5383 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
5384 pub struct _VAEncPictureParameterBufferVP9__bindgen_ty_2__bindgen_ty_1 {
5385 pub _bitfield_align_1: [u16; 0],
5386 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
5388 impl _VAEncPictureParameterBufferVP9__bindgen_ty_2__bindgen_ty_1 {
5390 pub fn frame_type(&self) -> u32 {
5391 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
5394 pub fn set_frame_type(&mut self, val: u32) {
5396 let val: u32 = ::std::mem::transmute(val);
5397 self._bitfield_1.set(0usize, 1u8, val as u64)
5401 pub fn show_frame(&self) -> u32 {
5402 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
5405 pub fn set_show_frame(&mut self, val: u32) {
5407 let val: u32 = ::std::mem::transmute(val);
5408 self._bitfield_1.set(1usize, 1u8, val as u64)
5412 pub fn error_resilient_mode(&self) -> u32 {
5413 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
5416 pub fn set_error_resilient_mode(&mut self, val: u32) {
5418 let val: u32 = ::std::mem::transmute(val);
5419 self._bitfield_1.set(2usize, 1u8, val as u64)
5423 pub fn intra_only(&self) -> u32 {
5424 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
5427 pub fn set_intra_only(&mut self, val: u32) {
5429 let val: u32 = ::std::mem::transmute(val);
5430 self._bitfield_1.set(3usize, 1u8, val as u64)
5434 pub fn allow_high_precision_mv(&self) -> u32 {
5435 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
5438 pub fn set_allow_high_precision_mv(&mut self, val: u32) {
5440 let val: u32 = ::std::mem::transmute(val);
5441 self._bitfield_1.set(4usize, 1u8, val as u64)
5445 pub fn mcomp_filter_type(&self) -> u32 {
5446 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 3u8) as u32) }
5449 pub fn set_mcomp_filter_type(&mut self, val: u32) {
5451 let val: u32 = ::std::mem::transmute(val);
5452 self._bitfield_1.set(5usize, 3u8, val as u64)
5456 pub fn frame_parallel_decoding_mode(&self) -> u32 {
5457 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) }
5460 pub fn set_frame_parallel_decoding_mode(&mut self, val: u32) {
5462 let val: u32 = ::std::mem::transmute(val);
5463 self._bitfield_1.set(8usize, 1u8, val as u64)
5467 pub fn reset_frame_context(&self) -> u32 {
5468 unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 2u8) as u32) }
5471 pub fn set_reset_frame_context(&mut self, val: u32) {
5473 let val: u32 = ::std::mem::transmute(val);
5474 self._bitfield_1.set(9usize, 2u8, val as u64)
5478 pub fn refresh_frame_context(&self) -> u32 {
5479 unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) }
5482 pub fn set_refresh_frame_context(&mut self, val: u32) {
5484 let val: u32 = ::std::mem::transmute(val);
5485 self._bitfield_1.set(11usize, 1u8, val as u64)
5489 pub fn frame_context_idx(&self) -> u32 {
5490 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 2u8) as u32) }
5493 pub fn set_frame_context_idx(&mut self, val: u32) {
5495 let val: u32 = ::std::mem::transmute(val);
5496 self._bitfield_1.set(12usize, 2u8, val as u64)
5500 pub fn segmentation_enabled(&self) -> u32 {
5501 unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) }
5504 pub fn set_segmentation_enabled(&mut self, val: u32) {
5506 let val: u32 = ::std::mem::transmute(val);
5507 self._bitfield_1.set(14usize, 1u8, val as u64)
5511 pub fn segmentation_temporal_update(&self) -> u32 {
5512 unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u32) }
5515 pub fn set_segmentation_temporal_update(&mut self, val: u32) {
5517 let val: u32 = ::std::mem::transmute(val);
5518 self._bitfield_1.set(15usize, 1u8, val as u64)
5522 pub fn segmentation_update_map(&self) -> u32 {
5523 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u32) }
5526 pub fn set_segmentation_update_map(&mut self, val: u32) {
5528 let val: u32 = ::std::mem::transmute(val);
5529 self._bitfield_1.set(16usize, 1u8, val as u64)
5533 pub fn lossless_mode(&self) -> u32 {
5534 unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 1u8) as u32) }
5537 pub fn set_lossless_mode(&mut self, val: u32) {
5539 let val: u32 = ::std::mem::transmute(val);
5540 self._bitfield_1.set(17usize, 1u8, val as u64)
5544 pub fn comp_prediction_mode(&self) -> u32 {
5545 unsafe { ::std::mem::transmute(self._bitfield_1.get(18usize, 2u8) as u32) }
5548 pub fn set_comp_prediction_mode(&mut self, val: u32) {
5550 let val: u32 = ::std::mem::transmute(val);
5551 self._bitfield_1.set(18usize, 2u8, val as u64)
5555 pub fn auto_segmentation(&self) -> u32 {
5556 unsafe { ::std::mem::transmute(self._bitfield_1.get(20usize, 1u8) as u32) }
5559 pub fn set_auto_segmentation(&mut self, val: u32) {
5561 let val: u32 = ::std::mem::transmute(val);
5562 self._bitfield_1.set(20usize, 1u8, val as u64)
5566 pub fn super_frame_flag(&self) -> u32 {
5567 unsafe { ::std::mem::transmute(self._bitfield_1.get(21usize, 1u8) as u32) }
5570 pub fn set_super_frame_flag(&mut self, val: u32) {
5572 let val: u32 = ::std::mem::transmute(val);
5573 self._bitfield_1.set(21usize, 1u8, val as u64)
5577 pub fn reserved(&self) -> u32 {
5578 unsafe { ::std::mem::transmute(self._bitfield_1.get(22usize, 10u8) as u32) }
5581 pub fn set_reserved(&mut self, val: u32) {
5583 let val: u32 = ::std::mem::transmute(val);
5584 self._bitfield_1.set(22usize, 10u8, val as u64)
5588 pub fn new_bitfield_1(
5591 error_resilient_mode: u32,
5593 allow_high_precision_mv: u32,
5594 mcomp_filter_type: u32,
5595 frame_parallel_decoding_mode: u32,
5596 reset_frame_context: u32,
5597 refresh_frame_context: u32,
5598 frame_context_idx: u32,
5599 segmentation_enabled: u32,
5600 segmentation_temporal_update: u32,
5601 segmentation_update_map: u32,
5603 comp_prediction_mode: u32,
5604 auto_segmentation: u32,
5605 super_frame_flag: u32,
5607 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
5608 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
5609 __bindgen_bitfield_unit.set(0usize, 1u8, {
5610 let frame_type: u32 = unsafe { ::std::mem::transmute(frame_type) };
5613 __bindgen_bitfield_unit.set(1usize, 1u8, {
5614 let show_frame: u32 = unsafe { ::std::mem::transmute(show_frame) };
5617 __bindgen_bitfield_unit.set(2usize, 1u8, {
5618 let error_resilient_mode: u32 = unsafe { ::std::mem::transmute(error_resilient_mode) };
5619 error_resilient_mode as u64
5621 __bindgen_bitfield_unit.set(3usize, 1u8, {
5622 let intra_only: u32 = unsafe { ::std::mem::transmute(intra_only) };
5625 __bindgen_bitfield_unit.set(4usize, 1u8, {
5626 let allow_high_precision_mv: u32 =
5627 unsafe { ::std::mem::transmute(allow_high_precision_mv) };
5628 allow_high_precision_mv as u64
5630 __bindgen_bitfield_unit.set(5usize, 3u8, {
5631 let mcomp_filter_type: u32 = unsafe { ::std::mem::transmute(mcomp_filter_type) };
5632 mcomp_filter_type as u64
5634 __bindgen_bitfield_unit.set(8usize, 1u8, {
5635 let frame_parallel_decoding_mode: u32 =
5636 unsafe { ::std::mem::transmute(frame_parallel_decoding_mode) };
5637 frame_parallel_decoding_mode as u64
5639 __bindgen_bitfield_unit.set(9usize, 2u8, {
5640 let reset_frame_context: u32 = unsafe { ::std::mem::transmute(reset_frame_context) };
5641 reset_frame_context as u64
5643 __bindgen_bitfield_unit.set(11usize, 1u8, {
5644 let refresh_frame_context: u32 =
5645 unsafe { ::std::mem::transmute(refresh_frame_context) };
5646 refresh_frame_context as u64
5648 __bindgen_bitfield_unit.set(12usize, 2u8, {
5649 let frame_context_idx: u32 = unsafe { ::std::mem::transmute(frame_context_idx) };
5650 frame_context_idx as u64
5652 __bindgen_bitfield_unit.set(14usize, 1u8, {
5653 let segmentation_enabled: u32 = unsafe { ::std::mem::transmute(segmentation_enabled) };
5654 segmentation_enabled as u64
5656 __bindgen_bitfield_unit.set(15usize, 1u8, {
5657 let segmentation_temporal_update: u32 =
5658 unsafe { ::std::mem::transmute(segmentation_temporal_update) };
5659 segmentation_temporal_update as u64
5661 __bindgen_bitfield_unit.set(16usize, 1u8, {
5662 let segmentation_update_map: u32 =
5663 unsafe { ::std::mem::transmute(segmentation_update_map) };
5664 segmentation_update_map as u64
5666 __bindgen_bitfield_unit.set(17usize, 1u8, {
5667 let lossless_mode: u32 = unsafe { ::std::mem::transmute(lossless_mode) };
5668 lossless_mode as u64
5670 __bindgen_bitfield_unit.set(18usize, 2u8, {
5671 let comp_prediction_mode: u32 = unsafe { ::std::mem::transmute(comp_prediction_mode) };
5672 comp_prediction_mode as u64
5674 __bindgen_bitfield_unit.set(20usize, 1u8, {
5675 let auto_segmentation: u32 = unsafe { ::std::mem::transmute(auto_segmentation) };
5676 auto_segmentation as u64
5678 __bindgen_bitfield_unit.set(21usize, 1u8, {
5679 let super_frame_flag: u32 = unsafe { ::std::mem::transmute(super_frame_flag) };
5680 super_frame_flag as u64
5682 __bindgen_bitfield_unit.set(22usize, 10u8, {
5683 let reserved: u32 = unsafe { ::std::mem::transmute(reserved) };
5686 __bindgen_bitfield_unit
5689 impl Default for _VAEncPictureParameterBufferVP9__bindgen_ty_2 {
5690 fn default() -> Self {
5691 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5693 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5698 impl Default for _VAEncPictureParameterBufferVP9 {
5699 fn default() -> Self {
5700 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5702 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5707 pub type VAEncPictureParameterBufferVP9 = _VAEncPictureParameterBufferVP9;
5709 #[derive(Copy, Clone)]
5710 pub struct _VAEncSegParamVP9 {
5711 pub seg_flags: _VAEncSegParamVP9__bindgen_ty_1,
5712 pub segment_lf_level_delta: i8,
5713 pub segment_qindex_delta: i16,
5714 pub va_reserved: [u32; 4usize],
5717 #[derive(Copy, Clone)]
5718 pub union _VAEncSegParamVP9__bindgen_ty_1 {
5719 pub bits: _VAEncSegParamVP9__bindgen_ty_1__bindgen_ty_1,
5723 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
5724 pub struct _VAEncSegParamVP9__bindgen_ty_1__bindgen_ty_1 {
5725 pub _bitfield_align_1: [u8; 0],
5726 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
5728 impl _VAEncSegParamVP9__bindgen_ty_1__bindgen_ty_1 {
5730 pub fn segment_reference_enabled(&self) -> u8 {
5731 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
5734 pub fn set_segment_reference_enabled(&mut self, val: u8) {
5736 let val: u8 = ::std::mem::transmute(val);
5737 self._bitfield_1.set(0usize, 1u8, val as u64)
5741 pub fn segment_reference(&self) -> u8 {
5742 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 2u8) as u8) }
5745 pub fn set_segment_reference(&mut self, val: u8) {
5747 let val: u8 = ::std::mem::transmute(val);
5748 self._bitfield_1.set(1usize, 2u8, val as u64)
5752 pub fn segment_reference_skipped(&self) -> u8 {
5753 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8) }
5756 pub fn set_segment_reference_skipped(&mut self, val: u8) {
5758 let val: u8 = ::std::mem::transmute(val);
5759 self._bitfield_1.set(3usize, 1u8, val as u64)
5763 pub fn reserved(&self) -> u8 {
5764 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 4u8) as u8) }
5767 pub fn set_reserved(&mut self, val: u8) {
5769 let val: u8 = ::std::mem::transmute(val);
5770 self._bitfield_1.set(4usize, 4u8, val as u64)
5774 pub fn new_bitfield_1(
5775 segment_reference_enabled: u8,
5776 segment_reference: u8,
5777 segment_reference_skipped: u8,
5779 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
5780 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
5781 __bindgen_bitfield_unit.set(0usize, 1u8, {
5782 let segment_reference_enabled: u8 =
5783 unsafe { ::std::mem::transmute(segment_reference_enabled) };
5784 segment_reference_enabled as u64
5786 __bindgen_bitfield_unit.set(1usize, 2u8, {
5787 let segment_reference: u8 = unsafe { ::std::mem::transmute(segment_reference) };
5788 segment_reference as u64
5790 __bindgen_bitfield_unit.set(3usize, 1u8, {
5791 let segment_reference_skipped: u8 =
5792 unsafe { ::std::mem::transmute(segment_reference_skipped) };
5793 segment_reference_skipped as u64
5795 __bindgen_bitfield_unit.set(4usize, 4u8, {
5796 let reserved: u8 = unsafe { ::std::mem::transmute(reserved) };
5799 __bindgen_bitfield_unit
5802 impl Default for _VAEncSegParamVP9__bindgen_ty_1 {
5803 fn default() -> Self {
5804 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5806 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5811 impl Default for _VAEncSegParamVP9 {
5812 fn default() -> Self {
5813 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5815 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5820 pub type VAEncSegParamVP9 = _VAEncSegParamVP9;
5822 #[derive(Copy, Clone)]
5823 pub struct _VAEncMiscParameterTypeVP9PerSegmantParam {
5824 pub seg_data: [VAEncSegParamVP9; 8usize],
5825 pub va_reserved: [u32; 4usize],
5827 impl Default for _VAEncMiscParameterTypeVP9PerSegmantParam {
5828 fn default() -> Self {
5829 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5831 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5836 pub type VAEncMiscParameterTypeVP9PerSegmantParam = _VAEncMiscParameterTypeVP9PerSegmantParam;
5838 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
5839 pub struct _VAEncMiscParameterFEIFrameControlH264 {
5841 pub mb_ctrl: VABufferID,
5842 pub distortion: VABufferID,
5843 pub mv_data: VABufferID,
5844 pub mb_code_data: VABufferID,
5846 pub mv_predictor: VABufferID,
5847 pub _bitfield_align_1: [u16; 0],
5848 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 16usize]>,
5849 pub max_frame_size: u32,
5850 pub num_passes: u32,
5851 pub delta_qp: *mut u8,
5852 pub reserved3: [u32; 4usize],
5854 impl Default for _VAEncMiscParameterFEIFrameControlH264 {
5855 fn default() -> Self {
5856 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5858 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5863 impl _VAEncMiscParameterFEIFrameControlH264 {
5865 pub fn num_mv_predictors_l0(&self) -> u32 {
5866 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 16u8) as u32) }
5869 pub fn set_num_mv_predictors_l0(&mut self, val: u32) {
5871 let val: u32 = ::std::mem::transmute(val);
5872 self._bitfield_1.set(0usize, 16u8, val as u64)
5876 pub fn num_mv_predictors_l1(&self) -> u32 {
5877 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 16u8) as u32) }
5880 pub fn set_num_mv_predictors_l1(&mut self, val: u32) {
5882 let val: u32 = ::std::mem::transmute(val);
5883 self._bitfield_1.set(16usize, 16u8, val as u64)
5887 pub fn search_path(&self) -> u32 {
5888 unsafe { ::std::mem::transmute(self._bitfield_1.get(32usize, 8u8) as u32) }
5891 pub fn set_search_path(&mut self, val: u32) {
5893 let val: u32 = ::std::mem::transmute(val);
5894 self._bitfield_1.set(32usize, 8u8, val as u64)
5898 pub fn len_sp(&self) -> u32 {
5899 unsafe { ::std::mem::transmute(self._bitfield_1.get(40usize, 8u8) as u32) }
5902 pub fn set_len_sp(&mut self, val: u32) {
5904 let val: u32 = ::std::mem::transmute(val);
5905 self._bitfield_1.set(40usize, 8u8, val as u64)
5909 pub fn reserved0(&self) -> u32 {
5910 unsafe { ::std::mem::transmute(self._bitfield_1.get(48usize, 16u8) as u32) }
5913 pub fn set_reserved0(&mut self, val: u32) {
5915 let val: u32 = ::std::mem::transmute(val);
5916 self._bitfield_1.set(48usize, 16u8, val as u64)
5920 pub fn sub_mb_part_mask(&self) -> u32 {
5921 unsafe { ::std::mem::transmute(self._bitfield_1.get(64usize, 7u8) as u32) }
5924 pub fn set_sub_mb_part_mask(&mut self, val: u32) {
5926 let val: u32 = ::std::mem::transmute(val);
5927 self._bitfield_1.set(64usize, 7u8, val as u64)
5931 pub fn intra_part_mask(&self) -> u32 {
5932 unsafe { ::std::mem::transmute(self._bitfield_1.get(71usize, 5u8) as u32) }
5935 pub fn set_intra_part_mask(&mut self, val: u32) {
5937 let val: u32 = ::std::mem::transmute(val);
5938 self._bitfield_1.set(71usize, 5u8, val as u64)
5942 pub fn multi_pred_l0(&self) -> u32 {
5943 unsafe { ::std::mem::transmute(self._bitfield_1.get(76usize, 1u8) as u32) }
5946 pub fn set_multi_pred_l0(&mut self, val: u32) {
5948 let val: u32 = ::std::mem::transmute(val);
5949 self._bitfield_1.set(76usize, 1u8, val as u64)
5953 pub fn multi_pred_l1(&self) -> u32 {
5954 unsafe { ::std::mem::transmute(self._bitfield_1.get(77usize, 1u8) as u32) }
5957 pub fn set_multi_pred_l1(&mut self, val: u32) {
5959 let val: u32 = ::std::mem::transmute(val);
5960 self._bitfield_1.set(77usize, 1u8, val as u64)
5964 pub fn sub_pel_mode(&self) -> u32 {
5965 unsafe { ::std::mem::transmute(self._bitfield_1.get(78usize, 2u8) as u32) }
5968 pub fn set_sub_pel_mode(&mut self, val: u32) {
5970 let val: u32 = ::std::mem::transmute(val);
5971 self._bitfield_1.set(78usize, 2u8, val as u64)
5975 pub fn inter_sad(&self) -> u32 {
5976 unsafe { ::std::mem::transmute(self._bitfield_1.get(80usize, 2u8) as u32) }
5979 pub fn set_inter_sad(&mut self, val: u32) {
5981 let val: u32 = ::std::mem::transmute(val);
5982 self._bitfield_1.set(80usize, 2u8, val as u64)
5986 pub fn intra_sad(&self) -> u32 {
5987 unsafe { ::std::mem::transmute(self._bitfield_1.get(82usize, 2u8) as u32) }
5990 pub fn set_intra_sad(&mut self, val: u32) {
5992 let val: u32 = ::std::mem::transmute(val);
5993 self._bitfield_1.set(82usize, 2u8, val as u64)
5997 pub fn distortion_type(&self) -> u32 {
5998 unsafe { ::std::mem::transmute(self._bitfield_1.get(84usize, 1u8) as u32) }
6001 pub fn set_distortion_type(&mut self, val: u32) {
6003 let val: u32 = ::std::mem::transmute(val);
6004 self._bitfield_1.set(84usize, 1u8, val as u64)
6008 pub fn repartition_check_enable(&self) -> u32 {
6009 unsafe { ::std::mem::transmute(self._bitfield_1.get(85usize, 1u8) as u32) }
6012 pub fn set_repartition_check_enable(&mut self, val: u32) {
6014 let val: u32 = ::std::mem::transmute(val);
6015 self._bitfield_1.set(85usize, 1u8, val as u64)
6019 pub fn adaptive_search(&self) -> u32 {
6020 unsafe { ::std::mem::transmute(self._bitfield_1.get(86usize, 1u8) as u32) }
6023 pub fn set_adaptive_search(&mut self, val: u32) {
6025 let val: u32 = ::std::mem::transmute(val);
6026 self._bitfield_1.set(86usize, 1u8, val as u64)
6030 pub fn mv_predictor_enable(&self) -> u32 {
6031 unsafe { ::std::mem::transmute(self._bitfield_1.get(87usize, 1u8) as u32) }
6034 pub fn set_mv_predictor_enable(&mut self, val: u32) {
6036 let val: u32 = ::std::mem::transmute(val);
6037 self._bitfield_1.set(87usize, 1u8, val as u64)
6041 pub fn mb_qp(&self) -> u32 {
6042 unsafe { ::std::mem::transmute(self._bitfield_1.get(88usize, 1u8) as u32) }
6045 pub fn set_mb_qp(&mut self, val: u32) {
6047 let val: u32 = ::std::mem::transmute(val);
6048 self._bitfield_1.set(88usize, 1u8, val as u64)
6052 pub fn mb_input(&self) -> u32 {
6053 unsafe { ::std::mem::transmute(self._bitfield_1.get(89usize, 1u8) as u32) }
6056 pub fn set_mb_input(&mut self, val: u32) {
6058 let val: u32 = ::std::mem::transmute(val);
6059 self._bitfield_1.set(89usize, 1u8, val as u64)
6063 pub fn mb_size_ctrl(&self) -> u32 {
6064 unsafe { ::std::mem::transmute(self._bitfield_1.get(90usize, 1u8) as u32) }
6067 pub fn set_mb_size_ctrl(&mut self, val: u32) {
6069 let val: u32 = ::std::mem::transmute(val);
6070 self._bitfield_1.set(90usize, 1u8, val as u64)
6074 pub fn colocated_mb_distortion(&self) -> u32 {
6075 unsafe { ::std::mem::transmute(self._bitfield_1.get(91usize, 1u8) as u32) }
6078 pub fn set_colocated_mb_distortion(&mut self, val: u32) {
6080 let val: u32 = ::std::mem::transmute(val);
6081 self._bitfield_1.set(91usize, 1u8, val as u64)
6085 pub fn reserved1(&self) -> u32 {
6086 unsafe { ::std::mem::transmute(self._bitfield_1.get(92usize, 4u8) as u32) }
6089 pub fn set_reserved1(&mut self, val: u32) {
6091 let val: u32 = ::std::mem::transmute(val);
6092 self._bitfield_1.set(92usize, 4u8, val as u64)
6096 pub fn ref_width(&self) -> u32 {
6097 unsafe { ::std::mem::transmute(self._bitfield_1.get(96usize, 8u8) as u32) }
6100 pub fn set_ref_width(&mut self, val: u32) {
6102 let val: u32 = ::std::mem::transmute(val);
6103 self._bitfield_1.set(96usize, 8u8, val as u64)
6107 pub fn ref_height(&self) -> u32 {
6108 unsafe { ::std::mem::transmute(self._bitfield_1.get(104usize, 8u8) as u32) }
6111 pub fn set_ref_height(&mut self, val: u32) {
6113 let val: u32 = ::std::mem::transmute(val);
6114 self._bitfield_1.set(104usize, 8u8, val as u64)
6118 pub fn search_window(&self) -> u32 {
6119 unsafe { ::std::mem::transmute(self._bitfield_1.get(112usize, 4u8) as u32) }
6122 pub fn set_search_window(&mut self, val: u32) {
6124 let val: u32 = ::std::mem::transmute(val);
6125 self._bitfield_1.set(112usize, 4u8, val as u64)
6129 pub fn reserved2(&self) -> u32 {
6130 unsafe { ::std::mem::transmute(self._bitfield_1.get(116usize, 12u8) as u32) }
6133 pub fn set_reserved2(&mut self, val: u32) {
6135 let val: u32 = ::std::mem::transmute(val);
6136 self._bitfield_1.set(116usize, 12u8, val as u64)
6140 pub fn new_bitfield_1(
6141 num_mv_predictors_l0: u32,
6142 num_mv_predictors_l1: u32,
6146 sub_mb_part_mask: u32,
6147 intra_part_mask: u32,
6153 distortion_type: u32,
6154 repartition_check_enable: u32,
6155 adaptive_search: u32,
6156 mv_predictor_enable: u32,
6160 colocated_mb_distortion: u32,
6166 ) -> __BindgenBitfieldUnit<[u8; 16usize]> {
6167 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 16usize]> = Default::default();
6168 __bindgen_bitfield_unit.set(0usize, 16u8, {
6169 let num_mv_predictors_l0: u32 = unsafe { ::std::mem::transmute(num_mv_predictors_l0) };
6170 num_mv_predictors_l0 as u64
6172 __bindgen_bitfield_unit.set(16usize, 16u8, {
6173 let num_mv_predictors_l1: u32 = unsafe { ::std::mem::transmute(num_mv_predictors_l1) };
6174 num_mv_predictors_l1 as u64
6176 __bindgen_bitfield_unit.set(32usize, 8u8, {
6177 let search_path: u32 = unsafe { ::std::mem::transmute(search_path) };
6180 __bindgen_bitfield_unit.set(40usize, 8u8, {
6181 let len_sp: u32 = unsafe { ::std::mem::transmute(len_sp) };
6184 __bindgen_bitfield_unit.set(48usize, 16u8, {
6185 let reserved0: u32 = unsafe { ::std::mem::transmute(reserved0) };
6188 __bindgen_bitfield_unit.set(64usize, 7u8, {
6189 let sub_mb_part_mask: u32 = unsafe { ::std::mem::transmute(sub_mb_part_mask) };
6190 sub_mb_part_mask as u64
6192 __bindgen_bitfield_unit.set(71usize, 5u8, {
6193 let intra_part_mask: u32 = unsafe { ::std::mem::transmute(intra_part_mask) };
6194 intra_part_mask as u64
6196 __bindgen_bitfield_unit.set(76usize, 1u8, {
6197 let multi_pred_l0: u32 = unsafe { ::std::mem::transmute(multi_pred_l0) };
6198 multi_pred_l0 as u64
6200 __bindgen_bitfield_unit.set(77usize, 1u8, {
6201 let multi_pred_l1: u32 = unsafe { ::std::mem::transmute(multi_pred_l1) };
6202 multi_pred_l1 as u64
6204 __bindgen_bitfield_unit.set(78usize, 2u8, {
6205 let sub_pel_mode: u32 = unsafe { ::std::mem::transmute(sub_pel_mode) };
6208 __bindgen_bitfield_unit.set(80usize, 2u8, {
6209 let inter_sad: u32 = unsafe { ::std::mem::transmute(inter_sad) };
6212 __bindgen_bitfield_unit.set(82usize, 2u8, {
6213 let intra_sad: u32 = unsafe { ::std::mem::transmute(intra_sad) };
6216 __bindgen_bitfield_unit.set(84usize, 1u8, {
6217 let distortion_type: u32 = unsafe { ::std::mem::transmute(distortion_type) };
6218 distortion_type as u64
6220 __bindgen_bitfield_unit.set(85usize, 1u8, {
6221 let repartition_check_enable: u32 =
6222 unsafe { ::std::mem::transmute(repartition_check_enable) };
6223 repartition_check_enable as u64
6225 __bindgen_bitfield_unit.set(86usize, 1u8, {
6226 let adaptive_search: u32 = unsafe { ::std::mem::transmute(adaptive_search) };
6227 adaptive_search as u64
6229 __bindgen_bitfield_unit.set(87usize, 1u8, {
6230 let mv_predictor_enable: u32 = unsafe { ::std::mem::transmute(mv_predictor_enable) };
6231 mv_predictor_enable as u64
6233 __bindgen_bitfield_unit.set(88usize, 1u8, {
6234 let mb_qp: u32 = unsafe { ::std::mem::transmute(mb_qp) };
6237 __bindgen_bitfield_unit.set(89usize, 1u8, {
6238 let mb_input: u32 = unsafe { ::std::mem::transmute(mb_input) };
6241 __bindgen_bitfield_unit.set(90usize, 1u8, {
6242 let mb_size_ctrl: u32 = unsafe { ::std::mem::transmute(mb_size_ctrl) };
6245 __bindgen_bitfield_unit.set(91usize, 1u8, {
6246 let colocated_mb_distortion: u32 =
6247 unsafe { ::std::mem::transmute(colocated_mb_distortion) };
6248 colocated_mb_distortion as u64
6250 __bindgen_bitfield_unit.set(92usize, 4u8, {
6251 let reserved1: u32 = unsafe { ::std::mem::transmute(reserved1) };
6254 __bindgen_bitfield_unit.set(96usize, 8u8, {
6255 let ref_width: u32 = unsafe { ::std::mem::transmute(ref_width) };
6258 __bindgen_bitfield_unit.set(104usize, 8u8, {
6259 let ref_height: u32 = unsafe { ::std::mem::transmute(ref_height) };
6262 __bindgen_bitfield_unit.set(112usize, 4u8, {
6263 let search_window: u32 = unsafe { ::std::mem::transmute(search_window) };
6264 search_window as u64
6266 __bindgen_bitfield_unit.set(116usize, 12u8, {
6267 let reserved2: u32 = unsafe { ::std::mem::transmute(reserved2) };
6270 __bindgen_bitfield_unit
6273 pub type VAEncMiscParameterFEIFrameControlH264 = _VAEncMiscParameterFEIFrameControlH264;
6275 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
6276 pub struct _VAEncFEIMBControlH264 {
6277 pub _bitfield_align_1: [u32; 0],
6278 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
6281 pub _bitfield_align_2: [u16; 0],
6282 pub _bitfield_2: __BindgenBitfieldUnit<[u8; 4usize]>,
6284 impl _VAEncFEIMBControlH264 {
6286 pub fn force_to_intra(&self) -> u32 {
6287 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
6290 pub fn set_force_to_intra(&mut self, val: u32) {
6292 let val: u32 = ::std::mem::transmute(val);
6293 self._bitfield_1.set(0usize, 1u8, val as u64)
6297 pub fn force_to_skip(&self) -> u32 {
6298 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
6301 pub fn set_force_to_skip(&mut self, val: u32) {
6303 let val: u32 = ::std::mem::transmute(val);
6304 self._bitfield_1.set(1usize, 1u8, val as u64)
6308 pub fn force_to_nonskip(&self) -> u32 {
6309 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
6312 pub fn set_force_to_nonskip(&mut self, val: u32) {
6314 let val: u32 = ::std::mem::transmute(val);
6315 self._bitfield_1.set(2usize, 1u8, val as u64)
6319 pub fn enable_direct_bias_adjustment(&self) -> u32 {
6320 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
6323 pub fn set_enable_direct_bias_adjustment(&mut self, val: u32) {
6325 let val: u32 = ::std::mem::transmute(val);
6326 self._bitfield_1.set(3usize, 1u8, val as u64)
6330 pub fn enable_motion_bias_adjustment(&self) -> u32 {
6331 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
6334 pub fn set_enable_motion_bias_adjustment(&mut self, val: u32) {
6336 let val: u32 = ::std::mem::transmute(val);
6337 self._bitfield_1.set(4usize, 1u8, val as u64)
6341 pub fn ext_mv_cost_scaling_factor(&self) -> u32 {
6342 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 3u8) as u32) }
6345 pub fn set_ext_mv_cost_scaling_factor(&mut self, val: u32) {
6347 let val: u32 = ::std::mem::transmute(val);
6348 self._bitfield_1.set(5usize, 3u8, val as u64)
6352 pub fn reserved0(&self) -> u32 {
6353 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 24u8) as u32) }
6356 pub fn set_reserved0(&mut self, val: u32) {
6358 let val: u32 = ::std::mem::transmute(val);
6359 self._bitfield_1.set(8usize, 24u8, val as u64)
6363 pub fn new_bitfield_1(
6364 force_to_intra: u32,
6366 force_to_nonskip: u32,
6367 enable_direct_bias_adjustment: u32,
6368 enable_motion_bias_adjustment: u32,
6369 ext_mv_cost_scaling_factor: u32,
6371 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
6372 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
6373 __bindgen_bitfield_unit.set(0usize, 1u8, {
6374 let force_to_intra: u32 = unsafe { ::std::mem::transmute(force_to_intra) };
6375 force_to_intra as u64
6377 __bindgen_bitfield_unit.set(1usize, 1u8, {
6378 let force_to_skip: u32 = unsafe { ::std::mem::transmute(force_to_skip) };
6379 force_to_skip as u64
6381 __bindgen_bitfield_unit.set(2usize, 1u8, {
6382 let force_to_nonskip: u32 = unsafe { ::std::mem::transmute(force_to_nonskip) };
6383 force_to_nonskip as u64
6385 __bindgen_bitfield_unit.set(3usize, 1u8, {
6386 let enable_direct_bias_adjustment: u32 =
6387 unsafe { ::std::mem::transmute(enable_direct_bias_adjustment) };
6388 enable_direct_bias_adjustment as u64
6390 __bindgen_bitfield_unit.set(4usize, 1u8, {
6391 let enable_motion_bias_adjustment: u32 =
6392 unsafe { ::std::mem::transmute(enable_motion_bias_adjustment) };
6393 enable_motion_bias_adjustment as u64
6395 __bindgen_bitfield_unit.set(5usize, 3u8, {
6396 let ext_mv_cost_scaling_factor: u32 =
6397 unsafe { ::std::mem::transmute(ext_mv_cost_scaling_factor) };
6398 ext_mv_cost_scaling_factor as u64
6400 __bindgen_bitfield_unit.set(8usize, 24u8, {
6401 let reserved0: u32 = unsafe { ::std::mem::transmute(reserved0) };
6404 __bindgen_bitfield_unit
6407 pub fn reserved3(&self) -> u32 {
6408 unsafe { ::std::mem::transmute(self._bitfield_2.get(0usize, 16u8) as u32) }
6411 pub fn set_reserved3(&mut self, val: u32) {
6413 let val: u32 = ::std::mem::transmute(val);
6414 self._bitfield_2.set(0usize, 16u8, val as u64)
6418 pub fn target_size_in_word(&self) -> u32 {
6419 unsafe { ::std::mem::transmute(self._bitfield_2.get(16usize, 8u8) as u32) }
6422 pub fn set_target_size_in_word(&mut self, val: u32) {
6424 let val: u32 = ::std::mem::transmute(val);
6425 self._bitfield_2.set(16usize, 8u8, val as u64)
6429 pub fn max_size_in_word(&self) -> u32 {
6430 unsafe { ::std::mem::transmute(self._bitfield_2.get(24usize, 8u8) as u32) }
6433 pub fn set_max_size_in_word(&mut self, val: u32) {
6435 let val: u32 = ::std::mem::transmute(val);
6436 self._bitfield_2.set(24usize, 8u8, val as u64)
6440 pub fn new_bitfield_2(
6442 target_size_in_word: u32,
6443 max_size_in_word: u32,
6444 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
6445 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
6446 __bindgen_bitfield_unit.set(0usize, 16u8, {
6447 let reserved3: u32 = unsafe { ::std::mem::transmute(reserved3) };
6450 __bindgen_bitfield_unit.set(16usize, 8u8, {
6451 let target_size_in_word: u32 = unsafe { ::std::mem::transmute(target_size_in_word) };
6452 target_size_in_word as u64
6454 __bindgen_bitfield_unit.set(24usize, 8u8, {
6455 let max_size_in_word: u32 = unsafe { ::std::mem::transmute(max_size_in_word) };
6456 max_size_in_word as u64
6458 __bindgen_bitfield_unit
6461 pub type VAEncFEIMBControlH264 = _VAEncFEIMBControlH264;
6463 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
6464 pub struct _VAEncFEIMVPredictorH264 {
6465 pub ref_idx: [_VAEncFEIMVPredictorH264__bindgen_ty_1; 4usize],
6467 pub mv: [VAMotionVector; 4usize],
6470 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
6471 pub struct _VAEncFEIMVPredictorH264__bindgen_ty_1 {
6472 pub _bitfield_align_1: [u8; 0],
6473 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
6475 impl _VAEncFEIMVPredictorH264__bindgen_ty_1 {
6477 pub fn ref_idx_l0(&self) -> u8 {
6478 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u8) }
6481 pub fn set_ref_idx_l0(&mut self, val: u8) {
6483 let val: u8 = ::std::mem::transmute(val);
6484 self._bitfield_1.set(0usize, 4u8, val as u64)
6488 pub fn ref_idx_l1(&self) -> u8 {
6489 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 4u8) as u8) }
6492 pub fn set_ref_idx_l1(&mut self, val: u8) {
6494 let val: u8 = ::std::mem::transmute(val);
6495 self._bitfield_1.set(4usize, 4u8, val as u64)
6499 pub fn new_bitfield_1(ref_idx_l0: u8, ref_idx_l1: u8) -> __BindgenBitfieldUnit<[u8; 1usize]> {
6500 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
6501 __bindgen_bitfield_unit.set(0usize, 4u8, {
6502 let ref_idx_l0: u8 = unsafe { ::std::mem::transmute(ref_idx_l0) };
6505 __bindgen_bitfield_unit.set(4usize, 4u8, {
6506 let ref_idx_l1: u8 = unsafe { ::std::mem::transmute(ref_idx_l1) };
6509 __bindgen_bitfield_unit
6512 pub type VAEncFEIMVPredictorH264 = _VAEncFEIMVPredictorH264;
6514 #[derive(Copy, Clone)]
6515 pub struct _VAEncFEIMBCodeH264 {
6516 pub reserved0: [u32; 3usize],
6517 pub _bitfield_align_1: [u32; 0],
6518 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 16usize]>,
6519 pub mb_mode: _VAEncFEIMBCodeH264__bindgen_ty_1,
6520 pub _bitfield_align_2: [u16; 0],
6521 pub _bitfield_2: __BindgenBitfieldUnit<[u8; 4usize]>,
6522 pub reserved9: [u32; 4usize],
6523 pub reserved10: u32,
6526 #[derive(Copy, Clone)]
6527 pub union _VAEncFEIMBCodeH264__bindgen_ty_1 {
6528 pub intra_mb: _VAEncFEIMBCodeH264__bindgen_ty_1__bindgen_ty_1,
6529 pub inter_mb: _VAEncFEIMBCodeH264__bindgen_ty_1__bindgen_ty_2,
6533 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
6534 pub struct _VAEncFEIMBCodeH264__bindgen_ty_1__bindgen_ty_1 {
6535 pub _bitfield_align_1: [u32; 0],
6536 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 12usize]>,
6538 impl _VAEncFEIMBCodeH264__bindgen_ty_1__bindgen_ty_1 {
6540 pub fn luma_intra_pred_modes0(&self) -> u32 {
6541 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 16u8) as u32) }
6544 pub fn set_luma_intra_pred_modes0(&mut self, val: u32) {
6546 let val: u32 = ::std::mem::transmute(val);
6547 self._bitfield_1.set(0usize, 16u8, val as u64)
6551 pub fn luma_intra_pred_modes1(&self) -> u32 {
6552 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 16u8) as u32) }
6555 pub fn set_luma_intra_pred_modes1(&mut self, val: u32) {
6557 let val: u32 = ::std::mem::transmute(val);
6558 self._bitfield_1.set(16usize, 16u8, val as u64)
6562 pub fn luma_intra_pred_modes2(&self) -> u32 {
6563 unsafe { ::std::mem::transmute(self._bitfield_1.get(32usize, 16u8) as u32) }
6566 pub fn set_luma_intra_pred_modes2(&mut self, val: u32) {
6568 let val: u32 = ::std::mem::transmute(val);
6569 self._bitfield_1.set(32usize, 16u8, val as u64)
6573 pub fn luma_intra_pred_modes3(&self) -> u32 {
6574 unsafe { ::std::mem::transmute(self._bitfield_1.get(48usize, 16u8) as u32) }
6577 pub fn set_luma_intra_pred_modes3(&mut self, val: u32) {
6579 let val: u32 = ::std::mem::transmute(val);
6580 self._bitfield_1.set(48usize, 16u8, val as u64)
6584 pub fn chroma_intra_pred_mode(&self) -> u32 {
6585 unsafe { ::std::mem::transmute(self._bitfield_1.get(64usize, 2u8) as u32) }
6588 pub fn set_chroma_intra_pred_mode(&mut self, val: u32) {
6590 let val: u32 = ::std::mem::transmute(val);
6591 self._bitfield_1.set(64usize, 2u8, val as u64)
6595 pub fn intra_pred_avail_flag(&self) -> u32 {
6596 unsafe { ::std::mem::transmute(self._bitfield_1.get(66usize, 5u8) as u32) }
6599 pub fn set_intra_pred_avail_flag(&mut self, val: u32) {
6601 let val: u32 = ::std::mem::transmute(val);
6602 self._bitfield_1.set(66usize, 5u8, val as u64)
6606 pub fn intra_pred_avail_flagF(&self) -> u32 {
6607 unsafe { ::std::mem::transmute(self._bitfield_1.get(71usize, 1u8) as u32) }
6610 pub fn set_intra_pred_avail_flagF(&mut self, val: u32) {
6612 let val: u32 = ::std::mem::transmute(val);
6613 self._bitfield_1.set(71usize, 1u8, val as u64)
6617 pub fn reserved6(&self) -> u32 {
6618 unsafe { ::std::mem::transmute(self._bitfield_1.get(72usize, 24u8) as u32) }
6621 pub fn set_reserved6(&mut self, val: u32) {
6623 let val: u32 = ::std::mem::transmute(val);
6624 self._bitfield_1.set(72usize, 24u8, val as u64)
6628 pub fn new_bitfield_1(
6629 luma_intra_pred_modes0: u32,
6630 luma_intra_pred_modes1: u32,
6631 luma_intra_pred_modes2: u32,
6632 luma_intra_pred_modes3: u32,
6633 chroma_intra_pred_mode: u32,
6634 intra_pred_avail_flag: u32,
6635 intra_pred_avail_flagF: u32,
6637 ) -> __BindgenBitfieldUnit<[u8; 12usize]> {
6638 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 12usize]> = Default::default();
6639 __bindgen_bitfield_unit.set(0usize, 16u8, {
6640 let luma_intra_pred_modes0: u32 =
6641 unsafe { ::std::mem::transmute(luma_intra_pred_modes0) };
6642 luma_intra_pred_modes0 as u64
6644 __bindgen_bitfield_unit.set(16usize, 16u8, {
6645 let luma_intra_pred_modes1: u32 =
6646 unsafe { ::std::mem::transmute(luma_intra_pred_modes1) };
6647 luma_intra_pred_modes1 as u64
6649 __bindgen_bitfield_unit.set(32usize, 16u8, {
6650 let luma_intra_pred_modes2: u32 =
6651 unsafe { ::std::mem::transmute(luma_intra_pred_modes2) };
6652 luma_intra_pred_modes2 as u64
6654 __bindgen_bitfield_unit.set(48usize, 16u8, {
6655 let luma_intra_pred_modes3: u32 =
6656 unsafe { ::std::mem::transmute(luma_intra_pred_modes3) };
6657 luma_intra_pred_modes3 as u64
6659 __bindgen_bitfield_unit.set(64usize, 2u8, {
6660 let chroma_intra_pred_mode: u32 =
6661 unsafe { ::std::mem::transmute(chroma_intra_pred_mode) };
6662 chroma_intra_pred_mode as u64
6664 __bindgen_bitfield_unit.set(66usize, 5u8, {
6665 let intra_pred_avail_flag: u32 =
6666 unsafe { ::std::mem::transmute(intra_pred_avail_flag) };
6667 intra_pred_avail_flag as u64
6669 __bindgen_bitfield_unit.set(71usize, 1u8, {
6670 let intra_pred_avail_flagF: u32 =
6671 unsafe { ::std::mem::transmute(intra_pred_avail_flagF) };
6672 intra_pred_avail_flagF as u64
6674 __bindgen_bitfield_unit.set(72usize, 24u8, {
6675 let reserved6: u32 = unsafe { ::std::mem::transmute(reserved6) };
6678 __bindgen_bitfield_unit
6683 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
6684 pub struct _VAEncFEIMBCodeH264__bindgen_ty_1__bindgen_ty_2 {
6685 pub _bitfield_align_1: [u16; 0],
6686 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 12usize]>,
6688 impl _VAEncFEIMBCodeH264__bindgen_ty_1__bindgen_ty_2 {
6690 pub fn sub_mb_shapes(&self) -> u32 {
6691 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 8u8) as u32) }
6694 pub fn set_sub_mb_shapes(&mut self, val: u32) {
6696 let val: u32 = ::std::mem::transmute(val);
6697 self._bitfield_1.set(0usize, 8u8, val as u64)
6701 pub fn sub_mb_pred_modes(&self) -> u32 {
6702 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 8u8) as u32) }
6705 pub fn set_sub_mb_pred_modes(&mut self, val: u32) {
6707 let val: u32 = ::std::mem::transmute(val);
6708 self._bitfield_1.set(8usize, 8u8, val as u64)
6712 pub fn reserved7(&self) -> u32 {
6713 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 16u8) as u32) }
6716 pub fn set_reserved7(&mut self, val: u32) {
6718 let val: u32 = ::std::mem::transmute(val);
6719 self._bitfield_1.set(16usize, 16u8, val as u64)
6723 pub fn ref_idx_l0_0(&self) -> u32 {
6724 unsafe { ::std::mem::transmute(self._bitfield_1.get(32usize, 8u8) as u32) }
6727 pub fn set_ref_idx_l0_0(&mut self, val: u32) {
6729 let val: u32 = ::std::mem::transmute(val);
6730 self._bitfield_1.set(32usize, 8u8, val as u64)
6734 pub fn ref_idx_l0_1(&self) -> u32 {
6735 unsafe { ::std::mem::transmute(self._bitfield_1.get(40usize, 8u8) as u32) }
6738 pub fn set_ref_idx_l0_1(&mut self, val: u32) {
6740 let val: u32 = ::std::mem::transmute(val);
6741 self._bitfield_1.set(40usize, 8u8, val as u64)
6745 pub fn ref_idx_l0_2(&self) -> u32 {
6746 unsafe { ::std::mem::transmute(self._bitfield_1.get(48usize, 8u8) as u32) }
6749 pub fn set_ref_idx_l0_2(&mut self, val: u32) {
6751 let val: u32 = ::std::mem::transmute(val);
6752 self._bitfield_1.set(48usize, 8u8, val as u64)
6756 pub fn ref_idx_l0_3(&self) -> u32 {
6757 unsafe { ::std::mem::transmute(self._bitfield_1.get(56usize, 8u8) as u32) }
6760 pub fn set_ref_idx_l0_3(&mut self, val: u32) {
6762 let val: u32 = ::std::mem::transmute(val);
6763 self._bitfield_1.set(56usize, 8u8, val as u64)
6767 pub fn ref_idx_l1_0(&self) -> u32 {
6768 unsafe { ::std::mem::transmute(self._bitfield_1.get(64usize, 8u8) as u32) }
6771 pub fn set_ref_idx_l1_0(&mut self, val: u32) {
6773 let val: u32 = ::std::mem::transmute(val);
6774 self._bitfield_1.set(64usize, 8u8, val as u64)
6778 pub fn ref_idx_l1_1(&self) -> u32 {
6779 unsafe { ::std::mem::transmute(self._bitfield_1.get(72usize, 8u8) as u32) }
6782 pub fn set_ref_idx_l1_1(&mut self, val: u32) {
6784 let val: u32 = ::std::mem::transmute(val);
6785 self._bitfield_1.set(72usize, 8u8, val as u64)
6789 pub fn ref_idx_l1_2(&self) -> u32 {
6790 unsafe { ::std::mem::transmute(self._bitfield_1.get(80usize, 8u8) as u32) }
6793 pub fn set_ref_idx_l1_2(&mut self, val: u32) {
6795 let val: u32 = ::std::mem::transmute(val);
6796 self._bitfield_1.set(80usize, 8u8, val as u64)
6800 pub fn ref_idx_l1_3(&self) -> u32 {
6801 unsafe { ::std::mem::transmute(self._bitfield_1.get(88usize, 8u8) as u32) }
6804 pub fn set_ref_idx_l1_3(&mut self, val: u32) {
6806 let val: u32 = ::std::mem::transmute(val);
6807 self._bitfield_1.set(88usize, 8u8, val as u64)
6811 pub fn new_bitfield_1(
6813 sub_mb_pred_modes: u32,
6823 ) -> __BindgenBitfieldUnit<[u8; 12usize]> {
6824 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 12usize]> = Default::default();
6825 __bindgen_bitfield_unit.set(0usize, 8u8, {
6826 let sub_mb_shapes: u32 = unsafe { ::std::mem::transmute(sub_mb_shapes) };
6827 sub_mb_shapes as u64
6829 __bindgen_bitfield_unit.set(8usize, 8u8, {
6830 let sub_mb_pred_modes: u32 = unsafe { ::std::mem::transmute(sub_mb_pred_modes) };
6831 sub_mb_pred_modes as u64
6833 __bindgen_bitfield_unit.set(16usize, 16u8, {
6834 let reserved7: u32 = unsafe { ::std::mem::transmute(reserved7) };
6837 __bindgen_bitfield_unit.set(32usize, 8u8, {
6838 let ref_idx_l0_0: u32 = unsafe { ::std::mem::transmute(ref_idx_l0_0) };
6841 __bindgen_bitfield_unit.set(40usize, 8u8, {
6842 let ref_idx_l0_1: u32 = unsafe { ::std::mem::transmute(ref_idx_l0_1) };
6845 __bindgen_bitfield_unit.set(48usize, 8u8, {
6846 let ref_idx_l0_2: u32 = unsafe { ::std::mem::transmute(ref_idx_l0_2) };
6849 __bindgen_bitfield_unit.set(56usize, 8u8, {
6850 let ref_idx_l0_3: u32 = unsafe { ::std::mem::transmute(ref_idx_l0_3) };
6853 __bindgen_bitfield_unit.set(64usize, 8u8, {
6854 let ref_idx_l1_0: u32 = unsafe { ::std::mem::transmute(ref_idx_l1_0) };
6857 __bindgen_bitfield_unit.set(72usize, 8u8, {
6858 let ref_idx_l1_1: u32 = unsafe { ::std::mem::transmute(ref_idx_l1_1) };
6861 __bindgen_bitfield_unit.set(80usize, 8u8, {
6862 let ref_idx_l1_2: u32 = unsafe { ::std::mem::transmute(ref_idx_l1_2) };
6865 __bindgen_bitfield_unit.set(88usize, 8u8, {
6866 let ref_idx_l1_3: u32 = unsafe { ::std::mem::transmute(ref_idx_l1_3) };
6869 __bindgen_bitfield_unit
6872 impl Default for _VAEncFEIMBCodeH264__bindgen_ty_1 {
6873 fn default() -> Self {
6874 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6876 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6881 impl Default for _VAEncFEIMBCodeH264 {
6882 fn default() -> Self {
6883 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6885 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6890 impl _VAEncFEIMBCodeH264 {
6892 pub fn inter_mb_mode(&self) -> u32 {
6893 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u32) }
6896 pub fn set_inter_mb_mode(&mut self, val: u32) {
6898 let val: u32 = ::std::mem::transmute(val);
6899 self._bitfield_1.set(0usize, 2u8, val as u64)
6903 pub fn mb_skip_flag(&self) -> u32 {
6904 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
6907 pub fn set_mb_skip_flag(&mut self, val: u32) {
6909 let val: u32 = ::std::mem::transmute(val);
6910 self._bitfield_1.set(2usize, 1u8, val as u64)
6914 pub fn reserved1(&self) -> u32 {
6915 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
6918 pub fn set_reserved1(&mut self, val: u32) {
6920 let val: u32 = ::std::mem::transmute(val);
6921 self._bitfield_1.set(3usize, 1u8, val as u64)
6925 pub fn intra_mb_mode(&self) -> u32 {
6926 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 2u8) as u32) }
6929 pub fn set_intra_mb_mode(&mut self, val: u32) {
6931 let val: u32 = ::std::mem::transmute(val);
6932 self._bitfield_1.set(4usize, 2u8, val as u64)
6936 pub fn reserved2(&self) -> u32 {
6937 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) }
6940 pub fn set_reserved2(&mut self, val: u32) {
6942 let val: u32 = ::std::mem::transmute(val);
6943 self._bitfield_1.set(6usize, 1u8, val as u64)
6947 pub fn field_mb_polarity_flag(&self) -> u32 {
6948 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) }
6951 pub fn set_field_mb_polarity_flag(&mut self, val: u32) {
6953 let val: u32 = ::std::mem::transmute(val);
6954 self._bitfield_1.set(7usize, 1u8, val as u64)
6958 pub fn mb_type(&self) -> u32 {
6959 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 5u8) as u32) }
6962 pub fn set_mb_type(&mut self, val: u32) {
6964 let val: u32 = ::std::mem::transmute(val);
6965 self._bitfield_1.set(8usize, 5u8, val as u64)
6969 pub fn intra_mb_flag(&self) -> u32 {
6970 unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) }
6973 pub fn set_intra_mb_flag(&mut self, val: u32) {
6975 let val: u32 = ::std::mem::transmute(val);
6976 self._bitfield_1.set(13usize, 1u8, val as u64)
6980 pub fn field_mb_flag(&self) -> u32 {
6981 unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) }
6984 pub fn set_field_mb_flag(&mut self, val: u32) {
6986 let val: u32 = ::std::mem::transmute(val);
6987 self._bitfield_1.set(14usize, 1u8, val as u64)
6991 pub fn transform8x8_flag(&self) -> u32 {
6992 unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u32) }
6995 pub fn set_transform8x8_flag(&mut self, val: u32) {
6997 let val: u32 = ::std::mem::transmute(val);
6998 self._bitfield_1.set(15usize, 1u8, val as u64)
7002 pub fn reserved3(&self) -> u32 {
7003 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u32) }
7006 pub fn set_reserved3(&mut self, val: u32) {
7008 let val: u32 = ::std::mem::transmute(val);
7009 self._bitfield_1.set(16usize, 1u8, val as u64)
7013 pub fn dc_block_coded_cr_flag(&self) -> u32 {
7014 unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 1u8) as u32) }
7017 pub fn set_dc_block_coded_cr_flag(&mut self, val: u32) {
7019 let val: u32 = ::std::mem::transmute(val);
7020 self._bitfield_1.set(17usize, 1u8, val as u64)
7024 pub fn dc_block_coded_cb_flag(&self) -> u32 {
7025 unsafe { ::std::mem::transmute(self._bitfield_1.get(18usize, 1u8) as u32) }
7028 pub fn set_dc_block_coded_cb_flag(&mut self, val: u32) {
7030 let val: u32 = ::std::mem::transmute(val);
7031 self._bitfield_1.set(18usize, 1u8, val as u64)
7035 pub fn dc_block_coded_y_flag(&self) -> u32 {
7036 unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 1u8) as u32) }
7039 pub fn set_dc_block_coded_y_flag(&mut self, val: u32) {
7041 let val: u32 = ::std::mem::transmute(val);
7042 self._bitfield_1.set(19usize, 1u8, val as u64)
7046 pub fn reserved4(&self) -> u32 {
7047 unsafe { ::std::mem::transmute(self._bitfield_1.get(20usize, 12u8) as u32) }
7050 pub fn set_reserved4(&mut self, val: u32) {
7052 let val: u32 = ::std::mem::transmute(val);
7053 self._bitfield_1.set(20usize, 12u8, val as u64)
7057 pub fn horz_origin(&self) -> u32 {
7058 unsafe { ::std::mem::transmute(self._bitfield_1.get(32usize, 8u8) as u32) }
7061 pub fn set_horz_origin(&mut self, val: u32) {
7063 let val: u32 = ::std::mem::transmute(val);
7064 self._bitfield_1.set(32usize, 8u8, val as u64)
7068 pub fn vert_origin(&self) -> u32 {
7069 unsafe { ::std::mem::transmute(self._bitfield_1.get(40usize, 8u8) as u32) }
7072 pub fn set_vert_origin(&mut self, val: u32) {
7074 let val: u32 = ::std::mem::transmute(val);
7075 self._bitfield_1.set(40usize, 8u8, val as u64)
7079 pub fn cbp_y(&self) -> u32 {
7080 unsafe { ::std::mem::transmute(self._bitfield_1.get(48usize, 16u8) as u32) }
7083 pub fn set_cbp_y(&mut self, val: u32) {
7085 let val: u32 = ::std::mem::transmute(val);
7086 self._bitfield_1.set(48usize, 16u8, val as u64)
7090 pub fn cbp_cb(&self) -> u32 {
7091 unsafe { ::std::mem::transmute(self._bitfield_1.get(64usize, 16u8) as u32) }
7094 pub fn set_cbp_cb(&mut self, val: u32) {
7096 let val: u32 = ::std::mem::transmute(val);
7097 self._bitfield_1.set(64usize, 16u8, val as u64)
7101 pub fn cbp_cr(&self) -> u32 {
7102 unsafe { ::std::mem::transmute(self._bitfield_1.get(80usize, 16u8) as u32) }
7105 pub fn set_cbp_cr(&mut self, val: u32) {
7107 let val: u32 = ::std::mem::transmute(val);
7108 self._bitfield_1.set(80usize, 16u8, val as u64)
7112 pub fn qp_prime_y(&self) -> u32 {
7113 unsafe { ::std::mem::transmute(self._bitfield_1.get(96usize, 8u8) as u32) }
7116 pub fn set_qp_prime_y(&mut self, val: u32) {
7118 let val: u32 = ::std::mem::transmute(val);
7119 self._bitfield_1.set(96usize, 8u8, val as u64)
7123 pub fn reserved5(&self) -> u32 {
7124 unsafe { ::std::mem::transmute(self._bitfield_1.get(104usize, 17u8) as u32) }
7127 pub fn set_reserved5(&mut self, val: u32) {
7129 let val: u32 = ::std::mem::transmute(val);
7130 self._bitfield_1.set(104usize, 17u8, val as u64)
7134 pub fn mb_skip_conv_disable(&self) -> u32 {
7135 unsafe { ::std::mem::transmute(self._bitfield_1.get(121usize, 1u8) as u32) }
7138 pub fn set_mb_skip_conv_disable(&mut self, val: u32) {
7140 let val: u32 = ::std::mem::transmute(val);
7141 self._bitfield_1.set(121usize, 1u8, val as u64)
7145 pub fn is_last_mb(&self) -> u32 {
7146 unsafe { ::std::mem::transmute(self._bitfield_1.get(122usize, 1u8) as u32) }
7149 pub fn set_is_last_mb(&mut self, val: u32) {
7151 let val: u32 = ::std::mem::transmute(val);
7152 self._bitfield_1.set(122usize, 1u8, val as u64)
7156 pub fn enable_coefficient_clamp(&self) -> u32 {
7157 unsafe { ::std::mem::transmute(self._bitfield_1.get(123usize, 1u8) as u32) }
7160 pub fn set_enable_coefficient_clamp(&mut self, val: u32) {
7162 let val: u32 = ::std::mem::transmute(val);
7163 self._bitfield_1.set(123usize, 1u8, val as u64)
7167 pub fn direct8x8_pattern(&self) -> u32 {
7168 unsafe { ::std::mem::transmute(self._bitfield_1.get(124usize, 4u8) as u32) }
7171 pub fn set_direct8x8_pattern(&mut self, val: u32) {
7173 let val: u32 = ::std::mem::transmute(val);
7174 self._bitfield_1.set(124usize, 4u8, val as u64)
7178 pub fn new_bitfield_1(
7184 field_mb_polarity_flag: u32,
7188 transform8x8_flag: u32,
7190 dc_block_coded_cr_flag: u32,
7191 dc_block_coded_cb_flag: u32,
7192 dc_block_coded_y_flag: u32,
7201 mb_skip_conv_disable: u32,
7203 enable_coefficient_clamp: u32,
7204 direct8x8_pattern: u32,
7205 ) -> __BindgenBitfieldUnit<[u8; 16usize]> {
7206 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 16usize]> = Default::default();
7207 __bindgen_bitfield_unit.set(0usize, 2u8, {
7208 let inter_mb_mode: u32 = unsafe { ::std::mem::transmute(inter_mb_mode) };
7209 inter_mb_mode as u64
7211 __bindgen_bitfield_unit.set(2usize, 1u8, {
7212 let mb_skip_flag: u32 = unsafe { ::std::mem::transmute(mb_skip_flag) };
7215 __bindgen_bitfield_unit.set(3usize, 1u8, {
7216 let reserved1: u32 = unsafe { ::std::mem::transmute(reserved1) };
7219 __bindgen_bitfield_unit.set(4usize, 2u8, {
7220 let intra_mb_mode: u32 = unsafe { ::std::mem::transmute(intra_mb_mode) };
7221 intra_mb_mode as u64
7223 __bindgen_bitfield_unit.set(6usize, 1u8, {
7224 let reserved2: u32 = unsafe { ::std::mem::transmute(reserved2) };
7227 __bindgen_bitfield_unit.set(7usize, 1u8, {
7228 let field_mb_polarity_flag: u32 =
7229 unsafe { ::std::mem::transmute(field_mb_polarity_flag) };
7230 field_mb_polarity_flag as u64
7232 __bindgen_bitfield_unit.set(8usize, 5u8, {
7233 let mb_type: u32 = unsafe { ::std::mem::transmute(mb_type) };
7236 __bindgen_bitfield_unit.set(13usize, 1u8, {
7237 let intra_mb_flag: u32 = unsafe { ::std::mem::transmute(intra_mb_flag) };
7238 intra_mb_flag as u64
7240 __bindgen_bitfield_unit.set(14usize, 1u8, {
7241 let field_mb_flag: u32 = unsafe { ::std::mem::transmute(field_mb_flag) };
7242 field_mb_flag as u64
7244 __bindgen_bitfield_unit.set(15usize, 1u8, {
7245 let transform8x8_flag: u32 = unsafe { ::std::mem::transmute(transform8x8_flag) };
7246 transform8x8_flag as u64
7248 __bindgen_bitfield_unit.set(16usize, 1u8, {
7249 let reserved3: u32 = unsafe { ::std::mem::transmute(reserved3) };
7252 __bindgen_bitfield_unit.set(17usize, 1u8, {
7253 let dc_block_coded_cr_flag: u32 =
7254 unsafe { ::std::mem::transmute(dc_block_coded_cr_flag) };
7255 dc_block_coded_cr_flag as u64
7257 __bindgen_bitfield_unit.set(18usize, 1u8, {
7258 let dc_block_coded_cb_flag: u32 =
7259 unsafe { ::std::mem::transmute(dc_block_coded_cb_flag) };
7260 dc_block_coded_cb_flag as u64
7262 __bindgen_bitfield_unit.set(19usize, 1u8, {
7263 let dc_block_coded_y_flag: u32 =
7264 unsafe { ::std::mem::transmute(dc_block_coded_y_flag) };
7265 dc_block_coded_y_flag as u64
7267 __bindgen_bitfield_unit.set(20usize, 12u8, {
7268 let reserved4: u32 = unsafe { ::std::mem::transmute(reserved4) };
7271 __bindgen_bitfield_unit.set(32usize, 8u8, {
7272 let horz_origin: u32 = unsafe { ::std::mem::transmute(horz_origin) };
7275 __bindgen_bitfield_unit.set(40usize, 8u8, {
7276 let vert_origin: u32 = unsafe { ::std::mem::transmute(vert_origin) };
7279 __bindgen_bitfield_unit.set(48usize, 16u8, {
7280 let cbp_y: u32 = unsafe { ::std::mem::transmute(cbp_y) };
7283 __bindgen_bitfield_unit.set(64usize, 16u8, {
7284 let cbp_cb: u32 = unsafe { ::std::mem::transmute(cbp_cb) };
7287 __bindgen_bitfield_unit.set(80usize, 16u8, {
7288 let cbp_cr: u32 = unsafe { ::std::mem::transmute(cbp_cr) };
7291 __bindgen_bitfield_unit.set(96usize, 8u8, {
7292 let qp_prime_y: u32 = unsafe { ::std::mem::transmute(qp_prime_y) };
7295 __bindgen_bitfield_unit.set(104usize, 17u8, {
7296 let reserved5: u32 = unsafe { ::std::mem::transmute(reserved5) };
7299 __bindgen_bitfield_unit.set(121usize, 1u8, {
7300 let mb_skip_conv_disable: u32 = unsafe { ::std::mem::transmute(mb_skip_conv_disable) };
7301 mb_skip_conv_disable as u64
7303 __bindgen_bitfield_unit.set(122usize, 1u8, {
7304 let is_last_mb: u32 = unsafe { ::std::mem::transmute(is_last_mb) };
7307 __bindgen_bitfield_unit.set(123usize, 1u8, {
7308 let enable_coefficient_clamp: u32 =
7309 unsafe { ::std::mem::transmute(enable_coefficient_clamp) };
7310 enable_coefficient_clamp as u64
7312 __bindgen_bitfield_unit.set(124usize, 4u8, {
7313 let direct8x8_pattern: u32 = unsafe { ::std::mem::transmute(direct8x8_pattern) };
7314 direct8x8_pattern as u64
7316 __bindgen_bitfield_unit
7319 pub fn reserved8(&self) -> u32 {
7320 unsafe { ::std::mem::transmute(self._bitfield_2.get(0usize, 16u8) as u32) }
7323 pub fn set_reserved8(&mut self, val: u32) {
7325 let val: u32 = ::std::mem::transmute(val);
7326 self._bitfield_2.set(0usize, 16u8, val as u64)
7330 pub fn target_size_in_word(&self) -> u32 {
7331 unsafe { ::std::mem::transmute(self._bitfield_2.get(16usize, 8u8) as u32) }
7334 pub fn set_target_size_in_word(&mut self, val: u32) {
7336 let val: u32 = ::std::mem::transmute(val);
7337 self._bitfield_2.set(16usize, 8u8, val as u64)
7341 pub fn max_size_in_word(&self) -> u32 {
7342 unsafe { ::std::mem::transmute(self._bitfield_2.get(24usize, 8u8) as u32) }
7345 pub fn set_max_size_in_word(&mut self, val: u32) {
7347 let val: u32 = ::std::mem::transmute(val);
7348 self._bitfield_2.set(24usize, 8u8, val as u64)
7352 pub fn new_bitfield_2(
7354 target_size_in_word: u32,
7355 max_size_in_word: u32,
7356 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
7357 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
7358 __bindgen_bitfield_unit.set(0usize, 16u8, {
7359 let reserved8: u32 = unsafe { ::std::mem::transmute(reserved8) };
7362 __bindgen_bitfield_unit.set(16usize, 8u8, {
7363 let target_size_in_word: u32 = unsafe { ::std::mem::transmute(target_size_in_word) };
7364 target_size_in_word as u64
7366 __bindgen_bitfield_unit.set(24usize, 8u8, {
7367 let max_size_in_word: u32 = unsafe { ::std::mem::transmute(max_size_in_word) };
7368 max_size_in_word as u64
7370 __bindgen_bitfield_unit
7373 pub type VAEncFEIMBCodeH264 = _VAEncFEIMBCodeH264;
7375 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
7376 pub struct _VAEncFEIDistortionH264 {
7377 pub inter_distortion: [u16; 16usize],
7378 pub _bitfield_align_1: [u16; 0],
7379 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
7380 pub reserved1: [u32; 2usize],
7382 impl _VAEncFEIDistortionH264 {
7384 pub fn best_inter_distortion(&self) -> u32 {
7385 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 16u8) as u32) }
7388 pub fn set_best_inter_distortion(&mut self, val: u32) {
7390 let val: u32 = ::std::mem::transmute(val);
7391 self._bitfield_1.set(0usize, 16u8, val as u64)
7395 pub fn best_intra_distortion(&self) -> u32 {
7396 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 16u8) as u32) }
7399 pub fn set_best_intra_distortion(&mut self, val: u32) {
7401 let val: u32 = ::std::mem::transmute(val);
7402 self._bitfield_1.set(16usize, 16u8, val as u64)
7406 pub fn colocated_mb_distortion(&self) -> u32 {
7407 unsafe { ::std::mem::transmute(self._bitfield_1.get(32usize, 16u8) as u32) }
7410 pub fn set_colocated_mb_distortion(&mut self, val: u32) {
7412 let val: u32 = ::std::mem::transmute(val);
7413 self._bitfield_1.set(32usize, 16u8, val as u64)
7417 pub fn reserved0(&self) -> u32 {
7418 unsafe { ::std::mem::transmute(self._bitfield_1.get(48usize, 16u8) as u32) }
7421 pub fn set_reserved0(&mut self, val: u32) {
7423 let val: u32 = ::std::mem::transmute(val);
7424 self._bitfield_1.set(48usize, 16u8, val as u64)
7428 pub fn new_bitfield_1(
7429 best_inter_distortion: u32,
7430 best_intra_distortion: u32,
7431 colocated_mb_distortion: u32,
7433 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
7434 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
7435 __bindgen_bitfield_unit.set(0usize, 16u8, {
7436 let best_inter_distortion: u32 =
7437 unsafe { ::std::mem::transmute(best_inter_distortion) };
7438 best_inter_distortion as u64
7440 __bindgen_bitfield_unit.set(16usize, 16u8, {
7441 let best_intra_distortion: u32 =
7442 unsafe { ::std::mem::transmute(best_intra_distortion) };
7443 best_intra_distortion as u64
7445 __bindgen_bitfield_unit.set(32usize, 16u8, {
7446 let colocated_mb_distortion: u32 =
7447 unsafe { ::std::mem::transmute(colocated_mb_distortion) };
7448 colocated_mb_distortion as u64
7450 __bindgen_bitfield_unit.set(48usize, 16u8, {
7451 let reserved0: u32 = unsafe { ::std::mem::transmute(reserved0) };
7454 __bindgen_bitfield_unit
7457 pub type VAEncFEIDistortionH264 = _VAEncFEIDistortionH264;
7459 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
7460 pub struct _VAStatsStatisticsParameterH264 {
7461 pub stats_params: VAStatsStatisticsParameter,
7462 pub _bitfield_align_1: [u32; 0],
7463 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 16usize]>,
7464 pub reserved4: [u32; 2usize],
7466 impl Default for _VAStatsStatisticsParameterH264 {
7467 fn default() -> Self {
7468 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7470 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7475 impl _VAStatsStatisticsParameterH264 {
7477 pub fn frame_qp(&self) -> u32 {
7478 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 8u8) as u32) }
7481 pub fn set_frame_qp(&mut self, val: u32) {
7483 let val: u32 = ::std::mem::transmute(val);
7484 self._bitfield_1.set(0usize, 8u8, val as u64)
7488 pub fn len_sp(&self) -> u32 {
7489 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 8u8) as u32) }
7492 pub fn set_len_sp(&mut self, val: u32) {
7494 let val: u32 = ::std::mem::transmute(val);
7495 self._bitfield_1.set(8usize, 8u8, val as u64)
7499 pub fn search_path(&self) -> u32 {
7500 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 8u8) as u32) }
7503 pub fn set_search_path(&mut self, val: u32) {
7505 let val: u32 = ::std::mem::transmute(val);
7506 self._bitfield_1.set(16usize, 8u8, val as u64)
7510 pub fn reserved0(&self) -> u32 {
7511 unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 8u8) as u32) }
7514 pub fn set_reserved0(&mut self, val: u32) {
7516 let val: u32 = ::std::mem::transmute(val);
7517 self._bitfield_1.set(24usize, 8u8, val as u64)
7521 pub fn sub_mb_part_mask(&self) -> u32 {
7522 unsafe { ::std::mem::transmute(self._bitfield_1.get(32usize, 7u8) as u32) }
7525 pub fn set_sub_mb_part_mask(&mut self, val: u32) {
7527 let val: u32 = ::std::mem::transmute(val);
7528 self._bitfield_1.set(32usize, 7u8, val as u64)
7532 pub fn sub_pel_mode(&self) -> u32 {
7533 unsafe { ::std::mem::transmute(self._bitfield_1.get(39usize, 2u8) as u32) }
7536 pub fn set_sub_pel_mode(&mut self, val: u32) {
7538 let val: u32 = ::std::mem::transmute(val);
7539 self._bitfield_1.set(39usize, 2u8, val as u64)
7543 pub fn inter_sad(&self) -> u32 {
7544 unsafe { ::std::mem::transmute(self._bitfield_1.get(41usize, 2u8) as u32) }
7547 pub fn set_inter_sad(&mut self, val: u32) {
7549 let val: u32 = ::std::mem::transmute(val);
7550 self._bitfield_1.set(41usize, 2u8, val as u64)
7554 pub fn intra_sad(&self) -> u32 {
7555 unsafe { ::std::mem::transmute(self._bitfield_1.get(43usize, 2u8) as u32) }
7558 pub fn set_intra_sad(&mut self, val: u32) {
7560 let val: u32 = ::std::mem::transmute(val);
7561 self._bitfield_1.set(43usize, 2u8, val as u64)
7565 pub fn adaptive_search(&self) -> u32 {
7566 unsafe { ::std::mem::transmute(self._bitfield_1.get(45usize, 1u8) as u32) }
7569 pub fn set_adaptive_search(&mut self, val: u32) {
7571 let val: u32 = ::std::mem::transmute(val);
7572 self._bitfield_1.set(45usize, 1u8, val as u64)
7576 pub fn mv_predictor_ctrl(&self) -> u32 {
7577 unsafe { ::std::mem::transmute(self._bitfield_1.get(46usize, 3u8) as u32) }
7580 pub fn set_mv_predictor_ctrl(&mut self, val: u32) {
7582 let val: u32 = ::std::mem::transmute(val);
7583 self._bitfield_1.set(46usize, 3u8, val as u64)
7587 pub fn mb_qp(&self) -> u32 {
7588 unsafe { ::std::mem::transmute(self._bitfield_1.get(49usize, 1u8) as u32) }
7591 pub fn set_mb_qp(&mut self, val: u32) {
7593 let val: u32 = ::std::mem::transmute(val);
7594 self._bitfield_1.set(49usize, 1u8, val as u64)
7598 pub fn ft_enable(&self) -> u32 {
7599 unsafe { ::std::mem::transmute(self._bitfield_1.get(50usize, 1u8) as u32) }
7602 pub fn set_ft_enable(&mut self, val: u32) {
7604 let val: u32 = ::std::mem::transmute(val);
7605 self._bitfield_1.set(50usize, 1u8, val as u64)
7609 pub fn intra_part_mask(&self) -> u32 {
7610 unsafe { ::std::mem::transmute(self._bitfield_1.get(51usize, 5u8) as u32) }
7613 pub fn set_intra_part_mask(&mut self, val: u32) {
7615 let val: u32 = ::std::mem::transmute(val);
7616 self._bitfield_1.set(51usize, 5u8, val as u64)
7620 pub fn reserved1(&self) -> u32 {
7621 unsafe { ::std::mem::transmute(self._bitfield_1.get(56usize, 8u8) as u32) }
7624 pub fn set_reserved1(&mut self, val: u32) {
7626 let val: u32 = ::std::mem::transmute(val);
7627 self._bitfield_1.set(56usize, 8u8, val as u64)
7631 pub fn ref_width(&self) -> u32 {
7632 unsafe { ::std::mem::transmute(self._bitfield_1.get(64usize, 8u8) as u32) }
7635 pub fn set_ref_width(&mut self, val: u32) {
7637 let val: u32 = ::std::mem::transmute(val);
7638 self._bitfield_1.set(64usize, 8u8, val as u64)
7642 pub fn ref_height(&self) -> u32 {
7643 unsafe { ::std::mem::transmute(self._bitfield_1.get(72usize, 8u8) as u32) }
7646 pub fn set_ref_height(&mut self, val: u32) {
7648 let val: u32 = ::std::mem::transmute(val);
7649 self._bitfield_1.set(72usize, 8u8, val as u64)
7653 pub fn search_window(&self) -> u32 {
7654 unsafe { ::std::mem::transmute(self._bitfield_1.get(80usize, 4u8) as u32) }
7657 pub fn set_search_window(&mut self, val: u32) {
7659 let val: u32 = ::std::mem::transmute(val);
7660 self._bitfield_1.set(80usize, 4u8, val as u64)
7664 pub fn reserved2(&self) -> u32 {
7665 unsafe { ::std::mem::transmute(self._bitfield_1.get(84usize, 12u8) as u32) }
7668 pub fn set_reserved2(&mut self, val: u32) {
7670 let val: u32 = ::std::mem::transmute(val);
7671 self._bitfield_1.set(84usize, 12u8, val as u64)
7675 pub fn disable_mv_output(&self) -> u32 {
7676 unsafe { ::std::mem::transmute(self._bitfield_1.get(96usize, 1u8) as u32) }
7679 pub fn set_disable_mv_output(&mut self, val: u32) {
7681 let val: u32 = ::std::mem::transmute(val);
7682 self._bitfield_1.set(96usize, 1u8, val as u64)
7686 pub fn disable_statistics_output(&self) -> u32 {
7687 unsafe { ::std::mem::transmute(self._bitfield_1.get(97usize, 1u8) as u32) }
7690 pub fn set_disable_statistics_output(&mut self, val: u32) {
7692 let val: u32 = ::std::mem::transmute(val);
7693 self._bitfield_1.set(97usize, 1u8, val as u64)
7697 pub fn enable_8x8_statistics(&self) -> u32 {
7698 unsafe { ::std::mem::transmute(self._bitfield_1.get(98usize, 1u8) as u32) }
7701 pub fn set_enable_8x8_statistics(&mut self, val: u32) {
7703 let val: u32 = ::std::mem::transmute(val);
7704 self._bitfield_1.set(98usize, 1u8, val as u64)
7708 pub fn reserved3(&self) -> u32 {
7709 unsafe { ::std::mem::transmute(self._bitfield_1.get(99usize, 29u8) as u32) }
7712 pub fn set_reserved3(&mut self, val: u32) {
7714 let val: u32 = ::std::mem::transmute(val);
7715 self._bitfield_1.set(99usize, 29u8, val as u64)
7719 pub fn new_bitfield_1(
7724 sub_mb_part_mask: u32,
7728 adaptive_search: u32,
7729 mv_predictor_ctrl: u32,
7732 intra_part_mask: u32,
7738 disable_mv_output: u32,
7739 disable_statistics_output: u32,
7740 enable_8x8_statistics: u32,
7742 ) -> __BindgenBitfieldUnit<[u8; 16usize]> {
7743 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 16usize]> = Default::default();
7744 __bindgen_bitfield_unit.set(0usize, 8u8, {
7745 let frame_qp: u32 = unsafe { ::std::mem::transmute(frame_qp) };
7748 __bindgen_bitfield_unit.set(8usize, 8u8, {
7749 let len_sp: u32 = unsafe { ::std::mem::transmute(len_sp) };
7752 __bindgen_bitfield_unit.set(16usize, 8u8, {
7753 let search_path: u32 = unsafe { ::std::mem::transmute(search_path) };
7756 __bindgen_bitfield_unit.set(24usize, 8u8, {
7757 let reserved0: u32 = unsafe { ::std::mem::transmute(reserved0) };
7760 __bindgen_bitfield_unit.set(32usize, 7u8, {
7761 let sub_mb_part_mask: u32 = unsafe { ::std::mem::transmute(sub_mb_part_mask) };
7762 sub_mb_part_mask as u64
7764 __bindgen_bitfield_unit.set(39usize, 2u8, {
7765 let sub_pel_mode: u32 = unsafe { ::std::mem::transmute(sub_pel_mode) };
7768 __bindgen_bitfield_unit.set(41usize, 2u8, {
7769 let inter_sad: u32 = unsafe { ::std::mem::transmute(inter_sad) };
7772 __bindgen_bitfield_unit.set(43usize, 2u8, {
7773 let intra_sad: u32 = unsafe { ::std::mem::transmute(intra_sad) };
7776 __bindgen_bitfield_unit.set(45usize, 1u8, {
7777 let adaptive_search: u32 = unsafe { ::std::mem::transmute(adaptive_search) };
7778 adaptive_search as u64
7780 __bindgen_bitfield_unit.set(46usize, 3u8, {
7781 let mv_predictor_ctrl: u32 = unsafe { ::std::mem::transmute(mv_predictor_ctrl) };
7782 mv_predictor_ctrl as u64
7784 __bindgen_bitfield_unit.set(49usize, 1u8, {
7785 let mb_qp: u32 = unsafe { ::std::mem::transmute(mb_qp) };
7788 __bindgen_bitfield_unit.set(50usize, 1u8, {
7789 let ft_enable: u32 = unsafe { ::std::mem::transmute(ft_enable) };
7792 __bindgen_bitfield_unit.set(51usize, 5u8, {
7793 let intra_part_mask: u32 = unsafe { ::std::mem::transmute(intra_part_mask) };
7794 intra_part_mask as u64
7796 __bindgen_bitfield_unit.set(56usize, 8u8, {
7797 let reserved1: u32 = unsafe { ::std::mem::transmute(reserved1) };
7800 __bindgen_bitfield_unit.set(64usize, 8u8, {
7801 let ref_width: u32 = unsafe { ::std::mem::transmute(ref_width) };
7804 __bindgen_bitfield_unit.set(72usize, 8u8, {
7805 let ref_height: u32 = unsafe { ::std::mem::transmute(ref_height) };
7808 __bindgen_bitfield_unit.set(80usize, 4u8, {
7809 let search_window: u32 = unsafe { ::std::mem::transmute(search_window) };
7810 search_window as u64
7812 __bindgen_bitfield_unit.set(84usize, 12u8, {
7813 let reserved2: u32 = unsafe { ::std::mem::transmute(reserved2) };
7816 __bindgen_bitfield_unit.set(96usize, 1u8, {
7817 let disable_mv_output: u32 = unsafe { ::std::mem::transmute(disable_mv_output) };
7818 disable_mv_output as u64
7820 __bindgen_bitfield_unit.set(97usize, 1u8, {
7821 let disable_statistics_output: u32 =
7822 unsafe { ::std::mem::transmute(disable_statistics_output) };
7823 disable_statistics_output as u64
7825 __bindgen_bitfield_unit.set(98usize, 1u8, {
7826 let enable_8x8_statistics: u32 =
7827 unsafe { ::std::mem::transmute(enable_8x8_statistics) };
7828 enable_8x8_statistics as u64
7830 __bindgen_bitfield_unit.set(99usize, 29u8, {
7831 let reserved3: u32 = unsafe { ::std::mem::transmute(reserved3) };
7834 __bindgen_bitfield_unit
7837 pub type VAStatsStatisticsParameterH264 = _VAStatsStatisticsParameterH264;
7839 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
7840 pub struct _VAStatsStatisticsH264 {
7841 pub _bitfield_align_1: [u16; 0],
7842 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 16usize]>,
7844 pub _bitfield_align_2: [u32; 0],
7845 pub _bitfield_2: __BindgenBitfieldUnit<[u8; 4usize]>,
7846 pub variance_16x16: u32,
7847 pub variance_8x8: [u32; 4usize],
7848 pub pixel_average_16x16: u32,
7849 pub pixel_average_8x8: [u32; 4usize],
7851 impl _VAStatsStatisticsH264 {
7853 pub fn best_inter_distortion0(&self) -> u32 {
7854 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 16u8) as u32) }
7857 pub fn set_best_inter_distortion0(&mut self, val: u32) {
7859 let val: u32 = ::std::mem::transmute(val);
7860 self._bitfield_1.set(0usize, 16u8, val as u64)
7864 pub fn inter_mode0(&self) -> u32 {
7865 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 16u8) as u32) }
7868 pub fn set_inter_mode0(&mut self, val: u32) {
7870 let val: u32 = ::std::mem::transmute(val);
7871 self._bitfield_1.set(16usize, 16u8, val as u64)
7875 pub fn best_inter_distortion1(&self) -> u32 {
7876 unsafe { ::std::mem::transmute(self._bitfield_1.get(32usize, 16u8) as u32) }
7879 pub fn set_best_inter_distortion1(&mut self, val: u32) {
7881 let val: u32 = ::std::mem::transmute(val);
7882 self._bitfield_1.set(32usize, 16u8, val as u64)
7886 pub fn inter_mode1(&self) -> u32 {
7887 unsafe { ::std::mem::transmute(self._bitfield_1.get(48usize, 16u8) as u32) }
7890 pub fn set_inter_mode1(&mut self, val: u32) {
7892 let val: u32 = ::std::mem::transmute(val);
7893 self._bitfield_1.set(48usize, 16u8, val as u64)
7897 pub fn best_intra_distortion(&self) -> u32 {
7898 unsafe { ::std::mem::transmute(self._bitfield_1.get(64usize, 16u8) as u32) }
7901 pub fn set_best_intra_distortion(&mut self, val: u32) {
7903 let val: u32 = ::std::mem::transmute(val);
7904 self._bitfield_1.set(64usize, 16u8, val as u64)
7908 pub fn intra_mode(&self) -> u32 {
7909 unsafe { ::std::mem::transmute(self._bitfield_1.get(80usize, 16u8) as u32) }
7912 pub fn set_intra_mode(&mut self, val: u32) {
7914 let val: u32 = ::std::mem::transmute(val);
7915 self._bitfield_1.set(80usize, 16u8, val as u64)
7919 pub fn num_non_zero_coef(&self) -> u32 {
7920 unsafe { ::std::mem::transmute(self._bitfield_1.get(96usize, 16u8) as u32) }
7923 pub fn set_num_non_zero_coef(&mut self, val: u32) {
7925 let val: u32 = ::std::mem::transmute(val);
7926 self._bitfield_1.set(96usize, 16u8, val as u64)
7930 pub fn reserved0(&self) -> u32 {
7931 unsafe { ::std::mem::transmute(self._bitfield_1.get(112usize, 16u8) as u32) }
7934 pub fn set_reserved0(&mut self, val: u32) {
7936 let val: u32 = ::std::mem::transmute(val);
7937 self._bitfield_1.set(112usize, 16u8, val as u64)
7941 pub fn new_bitfield_1(
7942 best_inter_distortion0: u32,
7944 best_inter_distortion1: u32,
7946 best_intra_distortion: u32,
7948 num_non_zero_coef: u32,
7950 ) -> __BindgenBitfieldUnit<[u8; 16usize]> {
7951 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 16usize]> = Default::default();
7952 __bindgen_bitfield_unit.set(0usize, 16u8, {
7953 let best_inter_distortion0: u32 =
7954 unsafe { ::std::mem::transmute(best_inter_distortion0) };
7955 best_inter_distortion0 as u64
7957 __bindgen_bitfield_unit.set(16usize, 16u8, {
7958 let inter_mode0: u32 = unsafe { ::std::mem::transmute(inter_mode0) };
7961 __bindgen_bitfield_unit.set(32usize, 16u8, {
7962 let best_inter_distortion1: u32 =
7963 unsafe { ::std::mem::transmute(best_inter_distortion1) };
7964 best_inter_distortion1 as u64
7966 __bindgen_bitfield_unit.set(48usize, 16u8, {
7967 let inter_mode1: u32 = unsafe { ::std::mem::transmute(inter_mode1) };
7970 __bindgen_bitfield_unit.set(64usize, 16u8, {
7971 let best_intra_distortion: u32 =
7972 unsafe { ::std::mem::transmute(best_intra_distortion) };
7973 best_intra_distortion as u64
7975 __bindgen_bitfield_unit.set(80usize, 16u8, {
7976 let intra_mode: u32 = unsafe { ::std::mem::transmute(intra_mode) };
7979 __bindgen_bitfield_unit.set(96usize, 16u8, {
7980 let num_non_zero_coef: u32 = unsafe { ::std::mem::transmute(num_non_zero_coef) };
7981 num_non_zero_coef as u64
7983 __bindgen_bitfield_unit.set(112usize, 16u8, {
7984 let reserved0: u32 = unsafe { ::std::mem::transmute(reserved0) };
7987 __bindgen_bitfield_unit
7990 pub fn mb_is_flat(&self) -> u32 {
7991 unsafe { ::std::mem::transmute(self._bitfield_2.get(0usize, 1u8) as u32) }
7994 pub fn set_mb_is_flat(&mut self, val: u32) {
7996 let val: u32 = ::std::mem::transmute(val);
7997 self._bitfield_2.set(0usize, 1u8, val as u64)
8001 pub fn reserved1(&self) -> u32 {
8002 unsafe { ::std::mem::transmute(self._bitfield_2.get(1usize, 31u8) as u32) }
8005 pub fn set_reserved1(&mut self, val: u32) {
8007 let val: u32 = ::std::mem::transmute(val);
8008 self._bitfield_2.set(1usize, 31u8, val as u64)
8012 pub fn new_bitfield_2(mb_is_flat: u32, reserved1: u32) -> __BindgenBitfieldUnit<[u8; 4usize]> {
8013 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
8014 __bindgen_bitfield_unit.set(0usize, 1u8, {
8015 let mb_is_flat: u32 = unsafe { ::std::mem::transmute(mb_is_flat) };
8018 __bindgen_bitfield_unit.set(1usize, 31u8, {
8019 let reserved1: u32 = unsafe { ::std::mem::transmute(reserved1) };
8022 __bindgen_bitfield_unit
8025 pub type VAStatsStatisticsH264 = _VAStatsStatisticsH264;
8026 pub const _VAProcFilterType_VAProcFilterNone: _VAProcFilterType = 0;
8027 pub const _VAProcFilterType_VAProcFilterNoiseReduction: _VAProcFilterType = 1;
8028 pub const _VAProcFilterType_VAProcFilterDeinterlacing: _VAProcFilterType = 2;
8029 pub const _VAProcFilterType_VAProcFilterSharpening: _VAProcFilterType = 3;
8030 pub const _VAProcFilterType_VAProcFilterColorBalance: _VAProcFilterType = 4;
8031 pub const _VAProcFilterType_VAProcFilterSkinToneEnhancement: _VAProcFilterType = 5;
8032 pub const _VAProcFilterType_VAProcFilterTotalColorCorrection: _VAProcFilterType = 6;
8033 pub const _VAProcFilterType_VAProcFilterHVSNoiseReduction: _VAProcFilterType = 7;
8034 pub const _VAProcFilterType_VAProcFilterHighDynamicRangeToneMapping: _VAProcFilterType = 8;
8035 pub const _VAProcFilterType_VAProcFilter3DLUT: _VAProcFilterType = 9;
8036 pub const _VAProcFilterType_VAProcFilterCount: _VAProcFilterType = 10;
8037 pub type _VAProcFilterType = ::std::os::raw::c_uint;
8038 pub use self::_VAProcFilterType as VAProcFilterType;
8039 pub const _VAProcColorStandardType_VAProcColorStandardNone: _VAProcColorStandardType = 0;
8040 pub const _VAProcColorStandardType_VAProcColorStandardBT601: _VAProcColorStandardType = 1;
8041 pub const _VAProcColorStandardType_VAProcColorStandardBT709: _VAProcColorStandardType = 2;
8042 pub const _VAProcColorStandardType_VAProcColorStandardBT470M: _VAProcColorStandardType = 3;
8043 pub const _VAProcColorStandardType_VAProcColorStandardBT470BG: _VAProcColorStandardType = 4;
8044 pub const _VAProcColorStandardType_VAProcColorStandardSMPTE170M: _VAProcColorStandardType = 5;
8045 pub const _VAProcColorStandardType_VAProcColorStandardSMPTE240M: _VAProcColorStandardType = 6;
8046 pub const _VAProcColorStandardType_VAProcColorStandardGenericFilm: _VAProcColorStandardType = 7;
8047 pub const _VAProcColorStandardType_VAProcColorStandardSRGB: _VAProcColorStandardType = 8;
8048 pub const _VAProcColorStandardType_VAProcColorStandardSTRGB: _VAProcColorStandardType = 9;
8049 pub const _VAProcColorStandardType_VAProcColorStandardXVYCC601: _VAProcColorStandardType = 10;
8050 pub const _VAProcColorStandardType_VAProcColorStandardXVYCC709: _VAProcColorStandardType = 11;
8051 pub const _VAProcColorStandardType_VAProcColorStandardBT2020: _VAProcColorStandardType = 12;
8052 pub const _VAProcColorStandardType_VAProcColorStandardExplicit: _VAProcColorStandardType = 13;
8053 pub const _VAProcColorStandardType_VAProcColorStandardCount: _VAProcColorStandardType = 14;
8054 pub type _VAProcColorStandardType = ::std::os::raw::c_uint;
8055 pub use self::_VAProcColorStandardType as VAProcColorStandardType;
8057 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
8058 pub struct _VAProcPipelineCaps {
8059 pub pipeline_flags: u32,
8060 pub filter_flags: u32,
8061 pub num_forward_references: u32,
8062 pub num_backward_references: u32,
8063 pub input_color_standards: *mut VAProcColorStandardType,
8064 pub num_input_color_standards: u32,
8065 pub output_color_standards: *mut VAProcColorStandardType,
8066 pub num_output_color_standards: u32,
8067 pub rotation_flags: u32,
8068 pub blend_flags: u32,
8069 pub mirror_flags: u32,
8070 pub num_additional_outputs: u32,
8071 pub num_input_pixel_formats: u32,
8072 pub input_pixel_format: *mut u32,
8073 pub num_output_pixel_formats: u32,
8074 pub output_pixel_format: *mut u32,
8075 pub max_input_width: u32,
8076 pub max_input_height: u32,
8077 pub min_input_width: u32,
8078 pub min_input_height: u32,
8079 pub max_output_width: u32,
8080 pub max_output_height: u32,
8081 pub min_output_width: u32,
8082 pub min_output_height: u32,
8083 pub va_reserved: [u32; 14usize],
8085 impl Default for _VAProcPipelineCaps {
8086 fn default() -> Self {
8087 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
8089 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
8094 pub type VAProcPipelineCaps = _VAProcPipelineCaps;
8096 pub fn vaQueryVideoProcFilters(
8098 context: VAContextID,
8099 filters: *mut VAProcFilterType,
8100 num_filters: *mut ::std::os::raw::c_uint,
8104 pub fn vaQueryVideoProcFilterCaps(
8106 context: VAContextID,
8107 type_: VAProcFilterType,
8108 filter_caps: *mut ::std::os::raw::c_void,
8109 num_filter_caps: *mut ::std::os::raw::c_uint,
8113 pub fn vaQueryVideoProcPipelineCaps(
8115 context: VAContextID,
8116 filters: *mut VABufferID,
8117 num_filters: ::std::os::raw::c_uint,
8118 pipeline_caps: *mut VAProcPipelineCaps,
8121 pub type VAProtectedSessionID = VAGenericID;
8123 pub fn vaCreateProtectedSession(
8125 config_id: VAConfigID,
8126 protected_session: *mut VAProtectedSessionID,
8130 pub fn vaDestroyProtectedSession(
8132 protected_session: VAProtectedSessionID,
8136 pub fn vaAttachProtectedSession(
8139 protected_session: VAProtectedSessionID,
8143 pub fn vaDetachProtectedSession(dpy: VADisplay, id: VAGenericID) -> VAStatus;
8146 pub fn vaProtectedSessionExecute(
8148 protected_session: VAProtectedSessionID,
8153 pub fn vaGetDisplayDRM(fd: ::std::os::raw::c_int) -> VADisplay;