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