1use super::cuviddec::*;
2use cudarc::driver::sys::*;
3type wchar_t = i32;
4pub type CUvideosource = *mut ::core::ffi::c_void;
7pub type CUvideoparser = *mut ::core::ffi::c_void;
8pub type CUvideotimestamp = ::core::ffi::c_longlong;
9pub type HEVCTIMECODESET = _HEVCTIMECODESET;
10pub type HEVCSEITIMECODE = _HEVCSEITIMECODE;
11pub type CUSEIMESSAGE = _CUSEIMESSAGE;
12pub type CUVIDSEIMESSAGEINFO = _CUVIDSEIMESSAGEINFO;
13pub type CUVIDSOURCEDATAPACKET = _CUVIDSOURCEDATAPACKET;
14pub type PFNVIDSOURCECALLBACK = ::core::option::Option<
15 unsafe extern "C" fn(
16 arg1: *mut ::core::ffi::c_void,
17 arg2: *mut CUVIDSOURCEDATAPACKET,
18 ) -> ::core::ffi::c_int,
19>;
20pub type CUVIDSOURCEPARAMS = _CUVIDSOURCEPARAMS;
21pub type CUVIDPARSERDISPINFO = _CUVIDPARSERDISPINFO;
22pub type PFNVIDSEQUENCECALLBACK = ::core::option::Option<
23 unsafe extern "C" fn(
24 arg1: *mut ::core::ffi::c_void,
25 arg2: *mut CUVIDEOFORMAT,
26 ) -> ::core::ffi::c_int,
27>;
28pub type PFNVIDDECODECALLBACK = ::core::option::Option<
29 unsafe extern "C" fn(
30 arg1: *mut ::core::ffi::c_void,
31 arg2: *mut CUVIDPICPARAMS,
32 ) -> ::core::ffi::c_int,
33>;
34pub type PFNVIDDISPLAYCALLBACK = ::core::option::Option<
35 unsafe extern "C" fn(
36 arg1: *mut ::core::ffi::c_void,
37 arg2: *mut CUVIDPARSERDISPINFO,
38 ) -> ::core::ffi::c_int,
39>;
40pub type PFNVIDOPPOINTCALLBACK = ::core::option::Option<
41 unsafe extern "C" fn(
42 arg1: *mut ::core::ffi::c_void,
43 arg2: *mut CUVIDOPERATINGPOINTINFO,
44 ) -> ::core::ffi::c_int,
45>;
46pub type PFNVIDSEIMSGCALLBACK = ::core::option::Option<
47 unsafe extern "C" fn(
48 arg1: *mut ::core::ffi::c_void,
49 arg2: *mut CUVIDSEIMESSAGEINFO,
50 ) -> ::core::ffi::c_int,
51>;
52pub type CUVIDPARSERPARAMS = _CUVIDPARSERPARAMS;
53#[repr(C)]
54#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
55pub struct __BindgenBitfieldUnit<Storage> {
56 storage: Storage,
57}
58#[repr(C)]
59#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
60pub struct _HEVCTIMECODESET {
61 pub time_offset_value: ::core::ffi::c_uint,
62 pub n_frames: ::core::ffi::c_ushort,
63 pub clock_timestamp_flag: ::core::ffi::c_uchar,
64 pub units_field_based_flag: ::core::ffi::c_uchar,
65 pub counting_type: ::core::ffi::c_uchar,
66 pub full_timestamp_flag: ::core::ffi::c_uchar,
67 pub discontinuity_flag: ::core::ffi::c_uchar,
68 pub cnt_dropped_flag: ::core::ffi::c_uchar,
69 pub seconds_value: ::core::ffi::c_uchar,
70 pub minutes_value: ::core::ffi::c_uchar,
71 pub hours_value: ::core::ffi::c_uchar,
72 pub seconds_flag: ::core::ffi::c_uchar,
73 pub minutes_flag: ::core::ffi::c_uchar,
74 pub hours_flag: ::core::ffi::c_uchar,
75 pub time_offset_length: ::core::ffi::c_uchar,
76 pub reserved: ::core::ffi::c_uchar,
77}
78#[repr(C)]
79#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
80pub struct _HEVCSEITIMECODE {
81 pub time_code_set: [HEVCTIMECODESET; 3usize],
82 pub num_clock_ts: ::core::ffi::c_uchar,
83}
84#[repr(C)]
85#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
86pub struct _CUSEIMESSAGE {
87 pub sei_message_type: ::core::ffi::c_uchar,
88 pub reserved: [::core::ffi::c_uchar; 3usize],
89 pub sei_message_size: ::core::ffi::c_uint,
90}
91#[repr(C)]
92pub struct CUVIDEOFORMAT {
93 pub codec: cudaVideoCodec,
94 pub frame_rate: CUVIDEOFORMAT__bindgen_ty_1,
95 pub progressive_sequence: ::core::ffi::c_uchar,
96 pub bit_depth_luma_minus8: ::core::ffi::c_uchar,
97 pub bit_depth_chroma_minus8: ::core::ffi::c_uchar,
98 pub min_num_decode_surfaces: ::core::ffi::c_uchar,
99 pub coded_width: ::core::ffi::c_uint,
100 pub coded_height: ::core::ffi::c_uint,
101 pub display_area: CUVIDEOFORMAT__bindgen_ty_2,
102 pub chroma_format: cudaVideoChromaFormat,
103 pub bitrate: ::core::ffi::c_uint,
104 pub display_aspect_ratio: CUVIDEOFORMAT__bindgen_ty_3,
105 pub video_signal_description: CUVIDEOFORMAT__bindgen_ty_4,
106 pub seqhdr_data_length: ::core::ffi::c_uint,
107}
108#[repr(C)]
109#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
110pub struct CUVIDEOFORMAT__bindgen_ty_1 {
111 pub numerator: ::core::ffi::c_uint,
112 pub denominator: ::core::ffi::c_uint,
113}
114#[repr(C)]
115#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
116pub struct CUVIDEOFORMAT__bindgen_ty_2 {
117 pub left: ::core::ffi::c_int,
118 pub top: ::core::ffi::c_int,
119 pub right: ::core::ffi::c_int,
120 pub bottom: ::core::ffi::c_int,
121}
122#[repr(C)]
123#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
124pub struct CUVIDEOFORMAT__bindgen_ty_3 {
125 pub x: ::core::ffi::c_int,
126 pub y: ::core::ffi::c_int,
127}
128#[repr(C)]
129#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
130pub struct CUVIDEOFORMAT__bindgen_ty_4 {
131 pub _bitfield_align_1: [u8; 0],
132 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
133 pub color_primaries: ::core::ffi::c_uchar,
134 pub transfer_characteristics: ::core::ffi::c_uchar,
135 pub matrix_coefficients: ::core::ffi::c_uchar,
136}
137#[repr(C)]
138pub struct CUVIDOPERATINGPOINTINFO {
139 pub codec: cudaVideoCodec,
140 pub __bindgen_anon_1: CUVIDOPERATINGPOINTINFO__bindgen_ty_1,
141}
142#[repr(C)]
143#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
144pub struct CUVIDOPERATINGPOINTINFO__bindgen_ty_1__bindgen_ty_1 {
145 pub operating_points_cnt: ::core::ffi::c_uchar,
146 pub reserved24_bits: [::core::ffi::c_uchar; 3usize],
147 pub operating_points_idc: [::core::ffi::c_ushort; 32usize],
148}
149#[repr(C)]
150#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
151pub struct _CUVIDSEIMESSAGEINFO {
152 pub pSEIData: *mut ::core::ffi::c_void,
153 pub pSEIMessage: *mut CUSEIMESSAGE,
154 pub sei_message_count: ::core::ffi::c_uint,
155 pub picIdx: ::core::ffi::c_uint,
156}
157#[repr(C)]
158#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
159pub struct CUVIDAV1SEQHDR {
160 pub max_width: ::core::ffi::c_uint,
161 pub max_height: ::core::ffi::c_uint,
162 pub reserved: [::core::ffi::c_uchar; 1016usize],
163}
164#[repr(C)]
165pub struct CUVIDEOFORMATEX {
166 pub format: CUVIDEOFORMAT,
167 pub __bindgen_anon_1: CUVIDEOFORMATEX__bindgen_ty_1,
168}
169#[repr(C)]
170#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
171pub struct CUAUDIOFORMAT {
172 pub codec: cudaAudioCodec,
173 pub channels: ::core::ffi::c_uint,
174 pub samplespersec: ::core::ffi::c_uint,
175 pub bitrate: ::core::ffi::c_uint,
176 pub reserved1: ::core::ffi::c_uint,
177 pub reserved2: ::core::ffi::c_uint,
178}
179#[repr(C)]
180#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
181pub struct _CUVIDSOURCEDATAPACKET {
182 pub flags: ::core::ffi::c_ulong,
183 pub payload_size: ::core::ffi::c_ulong,
184 pub payload: *const ::core::ffi::c_uchar,
185 pub timestamp: CUvideotimestamp,
186}
187#[repr(C)]
188#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
189pub struct _CUVIDSOURCEPARAMS {
190 pub ulClockRate: ::core::ffi::c_uint,
191 pub _bitfield_align_1: [u32; 0],
192 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
193 pub uReserved1: [::core::ffi::c_uint; 6usize],
194 pub pUserData: *mut ::core::ffi::c_void,
195 pub pfnVideoDataHandler: PFNVIDSOURCECALLBACK,
196 pub pfnAudioDataHandler: PFNVIDSOURCECALLBACK,
197 pub pvReserved2: [*mut ::core::ffi::c_void; 8usize],
198}
199#[repr(C)]
200#[derive(Debug, Default, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
201pub struct _CUVIDPARSERDISPINFO {
202 pub picture_index: ::core::ffi::c_int,
203 pub progressive_frame: ::core::ffi::c_int,
204 pub top_field_first: ::core::ffi::c_int,
205 pub repeat_first_field: ::core::ffi::c_int,
206 pub timestamp: CUvideotimestamp,
207}
208#[repr(C)]
209pub struct _CUVIDPARSERPARAMS {
210 pub CodecType: cudaVideoCodec,
211 pub ulMaxNumDecodeSurfaces: ::core::ffi::c_uint,
212 pub ulClockRate: ::core::ffi::c_uint,
213 pub ulErrorThreshold: ::core::ffi::c_uint,
214 pub ulMaxDisplayDelay: ::core::ffi::c_uint,
215 pub _bitfield_align_1: [u32; 0],
216 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
217 pub uReserved1: [::core::ffi::c_uint; 4usize],
218 pub pUserData: *mut ::core::ffi::c_void,
219 pub pfnSequenceCallback: PFNVIDSEQUENCECALLBACK,
220 pub pfnDecodePicture: PFNVIDDECODECALLBACK,
221 pub pfnDisplayPicture: PFNVIDDISPLAYCALLBACK,
222 pub pfnGetOperatingPoint: PFNVIDOPPOINTCALLBACK,
223 pub pfnGetSEIMsg: PFNVIDSEIMSGCALLBACK,
224 pub pvReserved2: [*mut ::core::ffi::c_void; 5usize],
225 pub pExtVideoInfo: *mut CUVIDEOFORMATEX,
226}
227pub const MAX_CLOCK_TS: u32 = 3;
228#[test]
229fn bindgen_test_layout__HEVCTIMECODESET() {
230 const UNINIT: ::core::mem::MaybeUninit<_HEVCTIMECODESET> = ::core::mem::MaybeUninit::uninit();
231 let ptr = UNINIT.as_ptr();
232 assert_eq!(
233 ::core::mem::size_of::<_HEVCTIMECODESET>(),
234 20usize,
235 concat!("Size of: ", stringify!(_HEVCTIMECODESET))
236 );
237 assert_eq!(
238 ::core::mem::align_of::<_HEVCTIMECODESET>(),
239 4usize,
240 concat!("Alignment of ", stringify!(_HEVCTIMECODESET))
241 );
242 assert_eq!(
243 unsafe { ::core::ptr::addr_of!((*ptr).time_offset_value) as usize - ptr as usize },
244 0usize,
245 concat!(
246 "Offset of field: ",
247 stringify!(_HEVCTIMECODESET),
248 "::",
249 stringify!(time_offset_value)
250 )
251 );
252 assert_eq!(
253 unsafe { ::core::ptr::addr_of!((*ptr).n_frames) as usize - ptr as usize },
254 4usize,
255 concat!(
256 "Offset of field: ",
257 stringify!(_HEVCTIMECODESET),
258 "::",
259 stringify!(n_frames)
260 )
261 );
262 assert_eq!(
263 unsafe { ::core::ptr::addr_of!((*ptr).clock_timestamp_flag) as usize - ptr as usize },
264 6usize,
265 concat!(
266 "Offset of field: ",
267 stringify!(_HEVCTIMECODESET),
268 "::",
269 stringify!(clock_timestamp_flag)
270 )
271 );
272 assert_eq!(
273 unsafe { ::core::ptr::addr_of!((*ptr).units_field_based_flag) as usize - ptr as usize },
274 7usize,
275 concat!(
276 "Offset of field: ",
277 stringify!(_HEVCTIMECODESET),
278 "::",
279 stringify!(units_field_based_flag)
280 )
281 );
282 assert_eq!(
283 unsafe { ::core::ptr::addr_of!((*ptr).counting_type) as usize - ptr as usize },
284 8usize,
285 concat!(
286 "Offset of field: ",
287 stringify!(_HEVCTIMECODESET),
288 "::",
289 stringify!(counting_type)
290 )
291 );
292 assert_eq!(
293 unsafe { ::core::ptr::addr_of!((*ptr).full_timestamp_flag) as usize - ptr as usize },
294 9usize,
295 concat!(
296 "Offset of field: ",
297 stringify!(_HEVCTIMECODESET),
298 "::",
299 stringify!(full_timestamp_flag)
300 )
301 );
302 assert_eq!(
303 unsafe { ::core::ptr::addr_of!((*ptr).discontinuity_flag) as usize - ptr as usize },
304 10usize,
305 concat!(
306 "Offset of field: ",
307 stringify!(_HEVCTIMECODESET),
308 "::",
309 stringify!(discontinuity_flag)
310 )
311 );
312 assert_eq!(
313 unsafe { ::core::ptr::addr_of!((*ptr).cnt_dropped_flag) as usize - ptr as usize },
314 11usize,
315 concat!(
316 "Offset of field: ",
317 stringify!(_HEVCTIMECODESET),
318 "::",
319 stringify!(cnt_dropped_flag)
320 )
321 );
322 assert_eq!(
323 unsafe { ::core::ptr::addr_of!((*ptr).seconds_value) as usize - ptr as usize },
324 12usize,
325 concat!(
326 "Offset of field: ",
327 stringify!(_HEVCTIMECODESET),
328 "::",
329 stringify!(seconds_value)
330 )
331 );
332 assert_eq!(
333 unsafe { ::core::ptr::addr_of!((*ptr).minutes_value) as usize - ptr as usize },
334 13usize,
335 concat!(
336 "Offset of field: ",
337 stringify!(_HEVCTIMECODESET),
338 "::",
339 stringify!(minutes_value)
340 )
341 );
342 assert_eq!(
343 unsafe { ::core::ptr::addr_of!((*ptr).hours_value) as usize - ptr as usize },
344 14usize,
345 concat!(
346 "Offset of field: ",
347 stringify!(_HEVCTIMECODESET),
348 "::",
349 stringify!(hours_value)
350 )
351 );
352 assert_eq!(
353 unsafe { ::core::ptr::addr_of!((*ptr).seconds_flag) as usize - ptr as usize },
354 15usize,
355 concat!(
356 "Offset of field: ",
357 stringify!(_HEVCTIMECODESET),
358 "::",
359 stringify!(seconds_flag)
360 )
361 );
362 assert_eq!(
363 unsafe { ::core::ptr::addr_of!((*ptr).minutes_flag) as usize - ptr as usize },
364 16usize,
365 concat!(
366 "Offset of field: ",
367 stringify!(_HEVCTIMECODESET),
368 "::",
369 stringify!(minutes_flag)
370 )
371 );
372 assert_eq!(
373 unsafe { ::core::ptr::addr_of!((*ptr).hours_flag) as usize - ptr as usize },
374 17usize,
375 concat!(
376 "Offset of field: ",
377 stringify!(_HEVCTIMECODESET),
378 "::",
379 stringify!(hours_flag)
380 )
381 );
382 assert_eq!(
383 unsafe { ::core::ptr::addr_of!((*ptr).time_offset_length) as usize - ptr as usize },
384 18usize,
385 concat!(
386 "Offset of field: ",
387 stringify!(_HEVCTIMECODESET),
388 "::",
389 stringify!(time_offset_length)
390 )
391 );
392 assert_eq!(
393 unsafe { ::core::ptr::addr_of!((*ptr).reserved) as usize - ptr as usize },
394 19usize,
395 concat!(
396 "Offset of field: ",
397 stringify!(_HEVCTIMECODESET),
398 "::",
399 stringify!(reserved)
400 )
401 );
402}
403#[test]
404fn bindgen_test_layout__HEVCSEITIMECODE() {
405 const UNINIT: ::core::mem::MaybeUninit<_HEVCSEITIMECODE> = ::core::mem::MaybeUninit::uninit();
406 let ptr = UNINIT.as_ptr();
407 assert_eq!(
408 ::core::mem::size_of::<_HEVCSEITIMECODE>(),
409 64usize,
410 concat!("Size of: ", stringify!(_HEVCSEITIMECODE))
411 );
412 assert_eq!(
413 ::core::mem::align_of::<_HEVCSEITIMECODE>(),
414 4usize,
415 concat!("Alignment of ", stringify!(_HEVCSEITIMECODE))
416 );
417 assert_eq!(
418 unsafe { ::core::ptr::addr_of!((*ptr).time_code_set) as usize - ptr as usize },
419 0usize,
420 concat!(
421 "Offset of field: ",
422 stringify!(_HEVCSEITIMECODE),
423 "::",
424 stringify!(time_code_set)
425 )
426 );
427 assert_eq!(
428 unsafe { ::core::ptr::addr_of!((*ptr).num_clock_ts) as usize - ptr as usize },
429 60usize,
430 concat!(
431 "Offset of field: ",
432 stringify!(_HEVCSEITIMECODE),
433 "::",
434 stringify!(num_clock_ts)
435 )
436 );
437}
438#[test]
439fn bindgen_test_layout__CUSEIMESSAGE() {
440 const UNINIT: ::core::mem::MaybeUninit<_CUSEIMESSAGE> = ::core::mem::MaybeUninit::uninit();
441 let ptr = UNINIT.as_ptr();
442 assert_eq!(
443 ::core::mem::size_of::<_CUSEIMESSAGE>(),
444 8usize,
445 concat!("Size of: ", stringify!(_CUSEIMESSAGE))
446 );
447 assert_eq!(
448 ::core::mem::align_of::<_CUSEIMESSAGE>(),
449 4usize,
450 concat!("Alignment of ", stringify!(_CUSEIMESSAGE))
451 );
452 assert_eq!(
453 unsafe { ::core::ptr::addr_of!((*ptr).sei_message_type) as usize - ptr as usize },
454 0usize,
455 concat!(
456 "Offset of field: ",
457 stringify!(_CUSEIMESSAGE),
458 "::",
459 stringify!(sei_message_type)
460 )
461 );
462 assert_eq!(
463 unsafe { ::core::ptr::addr_of!((*ptr).reserved) as usize - ptr as usize },
464 1usize,
465 concat!(
466 "Offset of field: ",
467 stringify!(_CUSEIMESSAGE),
468 "::",
469 stringify!(reserved)
470 )
471 );
472 assert_eq!(
473 unsafe { ::core::ptr::addr_of!((*ptr).sei_message_size) as usize - ptr as usize },
474 4usize,
475 concat!(
476 "Offset of field: ",
477 stringify!(_CUSEIMESSAGE),
478 "::",
479 stringify!(sei_message_size)
480 )
481 );
482}
483#[test]
484fn bindgen_test_layout_CUVIDEOFORMAT__bindgen_ty_1() {
485 const UNINIT: ::core::mem::MaybeUninit<CUVIDEOFORMAT__bindgen_ty_1> =
486 ::core::mem::MaybeUninit::uninit();
487 let ptr = UNINIT.as_ptr();
488 assert_eq!(
489 ::core::mem::size_of::<CUVIDEOFORMAT__bindgen_ty_1>(),
490 8usize,
491 concat!("Size of: ", stringify!(CUVIDEOFORMAT__bindgen_ty_1))
492 );
493 assert_eq!(
494 ::core::mem::align_of::<CUVIDEOFORMAT__bindgen_ty_1>(),
495 4usize,
496 concat!("Alignment of ", stringify!(CUVIDEOFORMAT__bindgen_ty_1))
497 );
498 assert_eq!(
499 unsafe { ::core::ptr::addr_of!((*ptr).numerator) as usize - ptr as usize },
500 0usize,
501 concat!(
502 "Offset of field: ",
503 stringify!(CUVIDEOFORMAT__bindgen_ty_1),
504 "::",
505 stringify!(numerator)
506 )
507 );
508 assert_eq!(
509 unsafe { ::core::ptr::addr_of!((*ptr).denominator) as usize - ptr as usize },
510 4usize,
511 concat!(
512 "Offset of field: ",
513 stringify!(CUVIDEOFORMAT__bindgen_ty_1),
514 "::",
515 stringify!(denominator)
516 )
517 );
518}
519#[test]
520fn bindgen_test_layout_CUVIDEOFORMAT__bindgen_ty_2() {
521 const UNINIT: ::core::mem::MaybeUninit<CUVIDEOFORMAT__bindgen_ty_2> =
522 ::core::mem::MaybeUninit::uninit();
523 let ptr = UNINIT.as_ptr();
524 assert_eq!(
525 ::core::mem::size_of::<CUVIDEOFORMAT__bindgen_ty_2>(),
526 16usize,
527 concat!("Size of: ", stringify!(CUVIDEOFORMAT__bindgen_ty_2))
528 );
529 assert_eq!(
530 ::core::mem::align_of::<CUVIDEOFORMAT__bindgen_ty_2>(),
531 4usize,
532 concat!("Alignment of ", stringify!(CUVIDEOFORMAT__bindgen_ty_2))
533 );
534 assert_eq!(
535 unsafe { ::core::ptr::addr_of!((*ptr).left) as usize - ptr as usize },
536 0usize,
537 concat!(
538 "Offset of field: ",
539 stringify!(CUVIDEOFORMAT__bindgen_ty_2),
540 "::",
541 stringify!(left)
542 )
543 );
544 assert_eq!(
545 unsafe { ::core::ptr::addr_of!((*ptr).top) as usize - ptr as usize },
546 4usize,
547 concat!(
548 "Offset of field: ",
549 stringify!(CUVIDEOFORMAT__bindgen_ty_2),
550 "::",
551 stringify!(top)
552 )
553 );
554 assert_eq!(
555 unsafe { ::core::ptr::addr_of!((*ptr).right) as usize - ptr as usize },
556 8usize,
557 concat!(
558 "Offset of field: ",
559 stringify!(CUVIDEOFORMAT__bindgen_ty_2),
560 "::",
561 stringify!(right)
562 )
563 );
564 assert_eq!(
565 unsafe { ::core::ptr::addr_of!((*ptr).bottom) as usize - ptr as usize },
566 12usize,
567 concat!(
568 "Offset of field: ",
569 stringify!(CUVIDEOFORMAT__bindgen_ty_2),
570 "::",
571 stringify!(bottom)
572 )
573 );
574}
575#[test]
576fn bindgen_test_layout_CUVIDEOFORMAT__bindgen_ty_3() {
577 const UNINIT: ::core::mem::MaybeUninit<CUVIDEOFORMAT__bindgen_ty_3> =
578 ::core::mem::MaybeUninit::uninit();
579 let ptr = UNINIT.as_ptr();
580 assert_eq!(
581 ::core::mem::size_of::<CUVIDEOFORMAT__bindgen_ty_3>(),
582 8usize,
583 concat!("Size of: ", stringify!(CUVIDEOFORMAT__bindgen_ty_3))
584 );
585 assert_eq!(
586 ::core::mem::align_of::<CUVIDEOFORMAT__bindgen_ty_3>(),
587 4usize,
588 concat!("Alignment of ", stringify!(CUVIDEOFORMAT__bindgen_ty_3))
589 );
590 assert_eq!(
591 unsafe { ::core::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
592 0usize,
593 concat!(
594 "Offset of field: ",
595 stringify!(CUVIDEOFORMAT__bindgen_ty_3),
596 "::",
597 stringify!(x)
598 )
599 );
600 assert_eq!(
601 unsafe { ::core::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
602 4usize,
603 concat!(
604 "Offset of field: ",
605 stringify!(CUVIDEOFORMAT__bindgen_ty_3),
606 "::",
607 stringify!(y)
608 )
609 );
610}
611#[test]
612fn bindgen_test_layout_CUVIDEOFORMAT__bindgen_ty_4() {
613 const UNINIT: ::core::mem::MaybeUninit<CUVIDEOFORMAT__bindgen_ty_4> =
614 ::core::mem::MaybeUninit::uninit();
615 let ptr = UNINIT.as_ptr();
616 assert_eq!(
617 ::core::mem::size_of::<CUVIDEOFORMAT__bindgen_ty_4>(),
618 4usize,
619 concat!("Size of: ", stringify!(CUVIDEOFORMAT__bindgen_ty_4))
620 );
621 assert_eq!(
622 ::core::mem::align_of::<CUVIDEOFORMAT__bindgen_ty_4>(),
623 1usize,
624 concat!("Alignment of ", stringify!(CUVIDEOFORMAT__bindgen_ty_4))
625 );
626 assert_eq!(
627 unsafe { ::core::ptr::addr_of!((*ptr).color_primaries) as usize - ptr as usize },
628 1usize,
629 concat!(
630 "Offset of field: ",
631 stringify!(CUVIDEOFORMAT__bindgen_ty_4),
632 "::",
633 stringify!(color_primaries)
634 )
635 );
636 assert_eq!(
637 unsafe { ::core::ptr::addr_of!((*ptr).transfer_characteristics) as usize - ptr as usize },
638 2usize,
639 concat!(
640 "Offset of field: ",
641 stringify!(CUVIDEOFORMAT__bindgen_ty_4),
642 "::",
643 stringify!(transfer_characteristics)
644 )
645 );
646 assert_eq!(
647 unsafe { ::core::ptr::addr_of!((*ptr).matrix_coefficients) as usize - ptr as usize },
648 3usize,
649 concat!(
650 "Offset of field: ",
651 stringify!(CUVIDEOFORMAT__bindgen_ty_4),
652 "::",
653 stringify!(matrix_coefficients)
654 )
655 );
656}
657#[test]
658fn bindgen_test_layout_CUVIDEOFORMAT() {
659 const UNINIT: ::core::mem::MaybeUninit<CUVIDEOFORMAT> = ::core::mem::MaybeUninit::uninit();
660 let ptr = UNINIT.as_ptr();
661 assert_eq!(
662 ::core::mem::size_of::<CUVIDEOFORMAT>(),
663 64usize,
664 concat!("Size of: ", stringify!(CUVIDEOFORMAT))
665 );
666 assert_eq!(
667 ::core::mem::align_of::<CUVIDEOFORMAT>(),
668 4usize,
669 concat!("Alignment of ", stringify!(CUVIDEOFORMAT))
670 );
671 assert_eq!(
672 unsafe { ::core::ptr::addr_of!((*ptr).codec) as usize - ptr as usize },
673 0usize,
674 concat!(
675 "Offset of field: ",
676 stringify!(CUVIDEOFORMAT),
677 "::",
678 stringify!(codec)
679 )
680 );
681 assert_eq!(
682 unsafe { ::core::ptr::addr_of!((*ptr).frame_rate) as usize - ptr as usize },
683 4usize,
684 concat!(
685 "Offset of field: ",
686 stringify!(CUVIDEOFORMAT),
687 "::",
688 stringify!(frame_rate)
689 )
690 );
691 assert_eq!(
692 unsafe { ::core::ptr::addr_of!((*ptr).progressive_sequence) as usize - ptr as usize },
693 12usize,
694 concat!(
695 "Offset of field: ",
696 stringify!(CUVIDEOFORMAT),
697 "::",
698 stringify!(progressive_sequence)
699 )
700 );
701 assert_eq!(
702 unsafe { ::core::ptr::addr_of!((*ptr).bit_depth_luma_minus8) as usize - ptr as usize },
703 13usize,
704 concat!(
705 "Offset of field: ",
706 stringify!(CUVIDEOFORMAT),
707 "::",
708 stringify!(bit_depth_luma_minus8)
709 )
710 );
711 assert_eq!(
712 unsafe { ::core::ptr::addr_of!((*ptr).bit_depth_chroma_minus8) as usize - ptr as usize },
713 14usize,
714 concat!(
715 "Offset of field: ",
716 stringify!(CUVIDEOFORMAT),
717 "::",
718 stringify!(bit_depth_chroma_minus8)
719 )
720 );
721 assert_eq!(
722 unsafe { ::core::ptr::addr_of!((*ptr).min_num_decode_surfaces) as usize - ptr as usize },
723 15usize,
724 concat!(
725 "Offset of field: ",
726 stringify!(CUVIDEOFORMAT),
727 "::",
728 stringify!(min_num_decode_surfaces)
729 )
730 );
731 assert_eq!(
732 unsafe { ::core::ptr::addr_of!((*ptr).coded_width) as usize - ptr as usize },
733 16usize,
734 concat!(
735 "Offset of field: ",
736 stringify!(CUVIDEOFORMAT),
737 "::",
738 stringify!(coded_width)
739 )
740 );
741 assert_eq!(
742 unsafe { ::core::ptr::addr_of!((*ptr).coded_height) as usize - ptr as usize },
743 20usize,
744 concat!(
745 "Offset of field: ",
746 stringify!(CUVIDEOFORMAT),
747 "::",
748 stringify!(coded_height)
749 )
750 );
751 assert_eq!(
752 unsafe { ::core::ptr::addr_of!((*ptr).display_area) as usize - ptr as usize },
753 24usize,
754 concat!(
755 "Offset of field: ",
756 stringify!(CUVIDEOFORMAT),
757 "::",
758 stringify!(display_area)
759 )
760 );
761 assert_eq!(
762 unsafe { ::core::ptr::addr_of!((*ptr).chroma_format) as usize - ptr as usize },
763 40usize,
764 concat!(
765 "Offset of field: ",
766 stringify!(CUVIDEOFORMAT),
767 "::",
768 stringify!(chroma_format)
769 )
770 );
771 assert_eq!(
772 unsafe { ::core::ptr::addr_of!((*ptr).bitrate) as usize - ptr as usize },
773 44usize,
774 concat!(
775 "Offset of field: ",
776 stringify!(CUVIDEOFORMAT),
777 "::",
778 stringify!(bitrate)
779 )
780 );
781 assert_eq!(
782 unsafe { ::core::ptr::addr_of!((*ptr).display_aspect_ratio) as usize - ptr as usize },
783 48usize,
784 concat!(
785 "Offset of field: ",
786 stringify!(CUVIDEOFORMAT),
787 "::",
788 stringify!(display_aspect_ratio)
789 )
790 );
791 assert_eq!(
792 unsafe { ::core::ptr::addr_of!((*ptr).video_signal_description) as usize - ptr as usize },
793 56usize,
794 concat!(
795 "Offset of field: ",
796 stringify!(CUVIDEOFORMAT),
797 "::",
798 stringify!(video_signal_description)
799 )
800 );
801 assert_eq!(
802 unsafe { ::core::ptr::addr_of!((*ptr).seqhdr_data_length) as usize - ptr as usize },
803 60usize,
804 concat!(
805 "Offset of field: ",
806 stringify!(CUVIDEOFORMAT),
807 "::",
808 stringify!(seqhdr_data_length)
809 )
810 );
811}
812#[test]
813fn bindgen_test_layout_CUVIDOPERATINGPOINTINFO__bindgen_ty_1__bindgen_ty_1() {
814 const UNINIT: ::core::mem::MaybeUninit<CUVIDOPERATINGPOINTINFO__bindgen_ty_1__bindgen_ty_1> =
815 ::core::mem::MaybeUninit::uninit();
816 let ptr = UNINIT.as_ptr();
817 assert_eq!(
818 ::core::mem::size_of::<CUVIDOPERATINGPOINTINFO__bindgen_ty_1__bindgen_ty_1>(),
819 68usize,
820 concat!(
821 "Size of: ",
822 stringify!(CUVIDOPERATINGPOINTINFO__bindgen_ty_1__bindgen_ty_1)
823 )
824 );
825 assert_eq!(
826 ::core::mem::align_of::<CUVIDOPERATINGPOINTINFO__bindgen_ty_1__bindgen_ty_1>(),
827 2usize,
828 concat!(
829 "Alignment of ",
830 stringify!(CUVIDOPERATINGPOINTINFO__bindgen_ty_1__bindgen_ty_1)
831 )
832 );
833 assert_eq!(
834 unsafe { ::core::ptr::addr_of!((*ptr).operating_points_cnt) as usize - ptr as usize },
835 0usize,
836 concat!(
837 "Offset of field: ",
838 stringify!(CUVIDOPERATINGPOINTINFO__bindgen_ty_1__bindgen_ty_1),
839 "::",
840 stringify!(operating_points_cnt)
841 )
842 );
843 assert_eq!(
844 unsafe { ::core::ptr::addr_of!((*ptr).reserved24_bits) as usize - ptr as usize },
845 1usize,
846 concat!(
847 "Offset of field: ",
848 stringify!(CUVIDOPERATINGPOINTINFO__bindgen_ty_1__bindgen_ty_1),
849 "::",
850 stringify!(reserved24_bits)
851 )
852 );
853 assert_eq!(
854 unsafe { ::core::ptr::addr_of!((*ptr).operating_points_idc) as usize - ptr as usize },
855 4usize,
856 concat!(
857 "Offset of field: ",
858 stringify!(CUVIDOPERATINGPOINTINFO__bindgen_ty_1__bindgen_ty_1),
859 "::",
860 stringify!(operating_points_idc)
861 )
862 );
863}
864#[test]
865fn bindgen_test_layout_CUVIDOPERATINGPOINTINFO__bindgen_ty_1() {
866 const UNINIT: ::core::mem::MaybeUninit<CUVIDOPERATINGPOINTINFO__bindgen_ty_1> =
867 ::core::mem::MaybeUninit::uninit();
868 let ptr = UNINIT.as_ptr();
869 assert_eq!(
870 ::core::mem::size_of::<CUVIDOPERATINGPOINTINFO__bindgen_ty_1>(),
871 1024usize,
872 concat!(
873 "Size of: ",
874 stringify!(CUVIDOPERATINGPOINTINFO__bindgen_ty_1)
875 )
876 );
877 assert_eq!(
878 ::core::mem::align_of::<CUVIDOPERATINGPOINTINFO__bindgen_ty_1>(),
879 2usize,
880 concat!(
881 "Alignment of ",
882 stringify!(CUVIDOPERATINGPOINTINFO__bindgen_ty_1)
883 )
884 );
885 assert_eq!(
886 unsafe { ::core::ptr::addr_of!((*ptr).av1) as usize - ptr as usize },
887 0usize,
888 concat!(
889 "Offset of field: ",
890 stringify!(CUVIDOPERATINGPOINTINFO__bindgen_ty_1),
891 "::",
892 stringify!(av1)
893 )
894 );
895 assert_eq!(
896 unsafe { ::core::ptr::addr_of!((*ptr).CodecReserved) as usize - ptr as usize },
897 0usize,
898 concat!(
899 "Offset of field: ",
900 stringify!(CUVIDOPERATINGPOINTINFO__bindgen_ty_1),
901 "::",
902 stringify!(CodecReserved)
903 )
904 );
905}
906#[test]
907fn bindgen_test_layout_CUVIDOPERATINGPOINTINFO() {
908 const UNINIT: ::core::mem::MaybeUninit<CUVIDOPERATINGPOINTINFO> =
909 ::core::mem::MaybeUninit::uninit();
910 let ptr = UNINIT.as_ptr();
911 assert_eq!(
912 ::core::mem::size_of::<CUVIDOPERATINGPOINTINFO>(),
913 1028usize,
914 concat!("Size of: ", stringify!(CUVIDOPERATINGPOINTINFO))
915 );
916 assert_eq!(
917 ::core::mem::align_of::<CUVIDOPERATINGPOINTINFO>(),
918 4usize,
919 concat!("Alignment of ", stringify!(CUVIDOPERATINGPOINTINFO))
920 );
921 assert_eq!(
922 unsafe { ::core::ptr::addr_of!((*ptr).codec) as usize - ptr as usize },
923 0usize,
924 concat!(
925 "Offset of field: ",
926 stringify!(CUVIDOPERATINGPOINTINFO),
927 "::",
928 stringify!(codec)
929 )
930 );
931}
932#[test]
933fn bindgen_test_layout__CUVIDSEIMESSAGEINFO() {
934 const UNINIT: ::core::mem::MaybeUninit<_CUVIDSEIMESSAGEINFO> =
935 ::core::mem::MaybeUninit::uninit();
936 let ptr = UNINIT.as_ptr();
937 assert_eq!(
938 ::core::mem::size_of::<_CUVIDSEIMESSAGEINFO>(),
939 24usize,
940 concat!("Size of: ", stringify!(_CUVIDSEIMESSAGEINFO))
941 );
942 assert_eq!(
943 ::core::mem::align_of::<_CUVIDSEIMESSAGEINFO>(),
944 8usize,
945 concat!("Alignment of ", stringify!(_CUVIDSEIMESSAGEINFO))
946 );
947 assert_eq!(
948 unsafe { ::core::ptr::addr_of!((*ptr).pSEIData) as usize - ptr as usize },
949 0usize,
950 concat!(
951 "Offset of field: ",
952 stringify!(_CUVIDSEIMESSAGEINFO),
953 "::",
954 stringify!(pSEIData)
955 )
956 );
957 assert_eq!(
958 unsafe { ::core::ptr::addr_of!((*ptr).pSEIMessage) as usize - ptr as usize },
959 8usize,
960 concat!(
961 "Offset of field: ",
962 stringify!(_CUVIDSEIMESSAGEINFO),
963 "::",
964 stringify!(pSEIMessage)
965 )
966 );
967 assert_eq!(
968 unsafe { ::core::ptr::addr_of!((*ptr).sei_message_count) as usize - ptr as usize },
969 16usize,
970 concat!(
971 "Offset of field: ",
972 stringify!(_CUVIDSEIMESSAGEINFO),
973 "::",
974 stringify!(sei_message_count)
975 )
976 );
977 assert_eq!(
978 unsafe { ::core::ptr::addr_of!((*ptr).picIdx) as usize - ptr as usize },
979 20usize,
980 concat!(
981 "Offset of field: ",
982 stringify!(_CUVIDSEIMESSAGEINFO),
983 "::",
984 stringify!(picIdx)
985 )
986 );
987}
988#[test]
989fn bindgen_test_layout_CUVIDAV1SEQHDR() {
990 const UNINIT: ::core::mem::MaybeUninit<CUVIDAV1SEQHDR> = ::core::mem::MaybeUninit::uninit();
991 let ptr = UNINIT.as_ptr();
992 assert_eq!(
993 ::core::mem::size_of::<CUVIDAV1SEQHDR>(),
994 1024usize,
995 concat!("Size of: ", stringify!(CUVIDAV1SEQHDR))
996 );
997 assert_eq!(
998 ::core::mem::align_of::<CUVIDAV1SEQHDR>(),
999 4usize,
1000 concat!("Alignment of ", stringify!(CUVIDAV1SEQHDR))
1001 );
1002 assert_eq!(
1003 unsafe { ::core::ptr::addr_of!((*ptr).max_width) as usize - ptr as usize },
1004 0usize,
1005 concat!(
1006 "Offset of field: ",
1007 stringify!(CUVIDAV1SEQHDR),
1008 "::",
1009 stringify!(max_width)
1010 )
1011 );
1012 assert_eq!(
1013 unsafe { ::core::ptr::addr_of!((*ptr).max_height) as usize - ptr as usize },
1014 4usize,
1015 concat!(
1016 "Offset of field: ",
1017 stringify!(CUVIDAV1SEQHDR),
1018 "::",
1019 stringify!(max_height)
1020 )
1021 );
1022 assert_eq!(
1023 unsafe { ::core::ptr::addr_of!((*ptr).reserved) as usize - ptr as usize },
1024 8usize,
1025 concat!(
1026 "Offset of field: ",
1027 stringify!(CUVIDAV1SEQHDR),
1028 "::",
1029 stringify!(reserved)
1030 )
1031 );
1032}
1033#[test]
1034fn bindgen_test_layout_CUVIDEOFORMATEX__bindgen_ty_1() {
1035 const UNINIT: ::core::mem::MaybeUninit<CUVIDEOFORMATEX__bindgen_ty_1> =
1036 ::core::mem::MaybeUninit::uninit();
1037 let ptr = UNINIT.as_ptr();
1038 assert_eq!(
1039 ::core::mem::size_of::<CUVIDEOFORMATEX__bindgen_ty_1>(),
1040 1024usize,
1041 concat!("Size of: ", stringify!(CUVIDEOFORMATEX__bindgen_ty_1))
1042 );
1043 assert_eq!(
1044 ::core::mem::align_of::<CUVIDEOFORMATEX__bindgen_ty_1>(),
1045 4usize,
1046 concat!("Alignment of ", stringify!(CUVIDEOFORMATEX__bindgen_ty_1))
1047 );
1048 assert_eq!(
1049 unsafe { ::core::ptr::addr_of!((*ptr).av1) as usize - ptr as usize },
1050 0usize,
1051 concat!(
1052 "Offset of field: ",
1053 stringify!(CUVIDEOFORMATEX__bindgen_ty_1),
1054 "::",
1055 stringify!(av1)
1056 )
1057 );
1058 assert_eq!(
1059 unsafe { ::core::ptr::addr_of!((*ptr).raw_seqhdr_data) as usize - ptr as usize },
1060 0usize,
1061 concat!(
1062 "Offset of field: ",
1063 stringify!(CUVIDEOFORMATEX__bindgen_ty_1),
1064 "::",
1065 stringify!(raw_seqhdr_data)
1066 )
1067 );
1068}
1069#[test]
1070fn bindgen_test_layout_CUVIDEOFORMATEX() {
1071 const UNINIT: ::core::mem::MaybeUninit<CUVIDEOFORMATEX> = ::core::mem::MaybeUninit::uninit();
1072 let ptr = UNINIT.as_ptr();
1073 assert_eq!(
1074 ::core::mem::size_of::<CUVIDEOFORMATEX>(),
1075 1088usize,
1076 concat!("Size of: ", stringify!(CUVIDEOFORMATEX))
1077 );
1078 assert_eq!(
1079 ::core::mem::align_of::<CUVIDEOFORMATEX>(),
1080 4usize,
1081 concat!("Alignment of ", stringify!(CUVIDEOFORMATEX))
1082 );
1083 assert_eq!(
1084 unsafe { ::core::ptr::addr_of!((*ptr).format) as usize - ptr as usize },
1085 0usize,
1086 concat!(
1087 "Offset of field: ",
1088 stringify!(CUVIDEOFORMATEX),
1089 "::",
1090 stringify!(format)
1091 )
1092 );
1093}
1094#[test]
1095fn bindgen_test_layout_CUAUDIOFORMAT() {
1096 const UNINIT: ::core::mem::MaybeUninit<CUAUDIOFORMAT> = ::core::mem::MaybeUninit::uninit();
1097 let ptr = UNINIT.as_ptr();
1098 assert_eq!(
1099 ::core::mem::size_of::<CUAUDIOFORMAT>(),
1100 24usize,
1101 concat!("Size of: ", stringify!(CUAUDIOFORMAT))
1102 );
1103 assert_eq!(
1104 ::core::mem::align_of::<CUAUDIOFORMAT>(),
1105 4usize,
1106 concat!("Alignment of ", stringify!(CUAUDIOFORMAT))
1107 );
1108 assert_eq!(
1109 unsafe { ::core::ptr::addr_of!((*ptr).codec) as usize - ptr as usize },
1110 0usize,
1111 concat!(
1112 "Offset of field: ",
1113 stringify!(CUAUDIOFORMAT),
1114 "::",
1115 stringify!(codec)
1116 )
1117 );
1118 assert_eq!(
1119 unsafe { ::core::ptr::addr_of!((*ptr).channels) as usize - ptr as usize },
1120 4usize,
1121 concat!(
1122 "Offset of field: ",
1123 stringify!(CUAUDIOFORMAT),
1124 "::",
1125 stringify!(channels)
1126 )
1127 );
1128 assert_eq!(
1129 unsafe { ::core::ptr::addr_of!((*ptr).samplespersec) as usize - ptr as usize },
1130 8usize,
1131 concat!(
1132 "Offset of field: ",
1133 stringify!(CUAUDIOFORMAT),
1134 "::",
1135 stringify!(samplespersec)
1136 )
1137 );
1138 assert_eq!(
1139 unsafe { ::core::ptr::addr_of!((*ptr).bitrate) as usize - ptr as usize },
1140 12usize,
1141 concat!(
1142 "Offset of field: ",
1143 stringify!(CUAUDIOFORMAT),
1144 "::",
1145 stringify!(bitrate)
1146 )
1147 );
1148 assert_eq!(
1149 unsafe { ::core::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize },
1150 16usize,
1151 concat!(
1152 "Offset of field: ",
1153 stringify!(CUAUDIOFORMAT),
1154 "::",
1155 stringify!(reserved1)
1156 )
1157 );
1158 assert_eq!(
1159 unsafe { ::core::ptr::addr_of!((*ptr).reserved2) as usize - ptr as usize },
1160 20usize,
1161 concat!(
1162 "Offset of field: ",
1163 stringify!(CUAUDIOFORMAT),
1164 "::",
1165 stringify!(reserved2)
1166 )
1167 );
1168}
1169#[test]
1170fn bindgen_test_layout__CUVIDSOURCEDATAPACKET() {
1171 const UNINIT: ::core::mem::MaybeUninit<_CUVIDSOURCEDATAPACKET> =
1172 ::core::mem::MaybeUninit::uninit();
1173 let ptr = UNINIT.as_ptr();
1174 assert_eq!(
1175 ::core::mem::size_of::<_CUVIDSOURCEDATAPACKET>(),
1176 32usize,
1177 concat!("Size of: ", stringify!(_CUVIDSOURCEDATAPACKET))
1178 );
1179 assert_eq!(
1180 ::core::mem::align_of::<_CUVIDSOURCEDATAPACKET>(),
1181 8usize,
1182 concat!("Alignment of ", stringify!(_CUVIDSOURCEDATAPACKET))
1183 );
1184 assert_eq!(
1185 unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
1186 0usize,
1187 concat!(
1188 "Offset of field: ",
1189 stringify!(_CUVIDSOURCEDATAPACKET),
1190 "::",
1191 stringify!(flags)
1192 )
1193 );
1194 assert_eq!(
1195 unsafe { ::core::ptr::addr_of!((*ptr).payload_size) as usize - ptr as usize },
1196 8usize,
1197 concat!(
1198 "Offset of field: ",
1199 stringify!(_CUVIDSOURCEDATAPACKET),
1200 "::",
1201 stringify!(payload_size)
1202 )
1203 );
1204 assert_eq!(
1205 unsafe { ::core::ptr::addr_of!((*ptr).payload) as usize - ptr as usize },
1206 16usize,
1207 concat!(
1208 "Offset of field: ",
1209 stringify!(_CUVIDSOURCEDATAPACKET),
1210 "::",
1211 stringify!(payload)
1212 )
1213 );
1214 assert_eq!(
1215 unsafe { ::core::ptr::addr_of!((*ptr).timestamp) as usize - ptr as usize },
1216 24usize,
1217 concat!(
1218 "Offset of field: ",
1219 stringify!(_CUVIDSOURCEDATAPACKET),
1220 "::",
1221 stringify!(timestamp)
1222 )
1223 );
1224}
1225#[test]
1226fn bindgen_test_layout__CUVIDSOURCEPARAMS() {
1227 const UNINIT: ::core::mem::MaybeUninit<_CUVIDSOURCEPARAMS> = ::core::mem::MaybeUninit::uninit();
1228 let ptr = UNINIT.as_ptr();
1229 assert_eq!(
1230 ::core::mem::size_of::<_CUVIDSOURCEPARAMS>(),
1231 120usize,
1232 concat!("Size of: ", stringify!(_CUVIDSOURCEPARAMS))
1233 );
1234 assert_eq!(
1235 ::core::mem::align_of::<_CUVIDSOURCEPARAMS>(),
1236 8usize,
1237 concat!("Alignment of ", stringify!(_CUVIDSOURCEPARAMS))
1238 );
1239 assert_eq!(
1240 unsafe { ::core::ptr::addr_of!((*ptr).ulClockRate) as usize - ptr as usize },
1241 0usize,
1242 concat!(
1243 "Offset of field: ",
1244 stringify!(_CUVIDSOURCEPARAMS),
1245 "::",
1246 stringify!(ulClockRate)
1247 )
1248 );
1249 assert_eq!(
1250 unsafe { ::core::ptr::addr_of!((*ptr).uReserved1) as usize - ptr as usize },
1251 8usize,
1252 concat!(
1253 "Offset of field: ",
1254 stringify!(_CUVIDSOURCEPARAMS),
1255 "::",
1256 stringify!(uReserved1)
1257 )
1258 );
1259 assert_eq!(
1260 unsafe { ::core::ptr::addr_of!((*ptr).pUserData) as usize - ptr as usize },
1261 32usize,
1262 concat!(
1263 "Offset of field: ",
1264 stringify!(_CUVIDSOURCEPARAMS),
1265 "::",
1266 stringify!(pUserData)
1267 )
1268 );
1269 assert_eq!(
1270 unsafe { ::core::ptr::addr_of!((*ptr).pfnVideoDataHandler) as usize - ptr as usize },
1271 40usize,
1272 concat!(
1273 "Offset of field: ",
1274 stringify!(_CUVIDSOURCEPARAMS),
1275 "::",
1276 stringify!(pfnVideoDataHandler)
1277 )
1278 );
1279 assert_eq!(
1280 unsafe { ::core::ptr::addr_of!((*ptr).pfnAudioDataHandler) as usize - ptr as usize },
1281 48usize,
1282 concat!(
1283 "Offset of field: ",
1284 stringify!(_CUVIDSOURCEPARAMS),
1285 "::",
1286 stringify!(pfnAudioDataHandler)
1287 )
1288 );
1289 assert_eq!(
1290 unsafe { ::core::ptr::addr_of!((*ptr).pvReserved2) as usize - ptr as usize },
1291 56usize,
1292 concat!(
1293 "Offset of field: ",
1294 stringify!(_CUVIDSOURCEPARAMS),
1295 "::",
1296 stringify!(pvReserved2)
1297 )
1298 );
1299}
1300#[test]
1301fn bindgen_test_layout__CUVIDPARSERDISPINFO() {
1302 const UNINIT: ::core::mem::MaybeUninit<_CUVIDPARSERDISPINFO> =
1303 ::core::mem::MaybeUninit::uninit();
1304 let ptr = UNINIT.as_ptr();
1305 assert_eq!(
1306 ::core::mem::size_of::<_CUVIDPARSERDISPINFO>(),
1307 24usize,
1308 concat!("Size of: ", stringify!(_CUVIDPARSERDISPINFO))
1309 );
1310 assert_eq!(
1311 ::core::mem::align_of::<_CUVIDPARSERDISPINFO>(),
1312 8usize,
1313 concat!("Alignment of ", stringify!(_CUVIDPARSERDISPINFO))
1314 );
1315 assert_eq!(
1316 unsafe { ::core::ptr::addr_of!((*ptr).picture_index) as usize - ptr as usize },
1317 0usize,
1318 concat!(
1319 "Offset of field: ",
1320 stringify!(_CUVIDPARSERDISPINFO),
1321 "::",
1322 stringify!(picture_index)
1323 )
1324 );
1325 assert_eq!(
1326 unsafe { ::core::ptr::addr_of!((*ptr).progressive_frame) as usize - ptr as usize },
1327 4usize,
1328 concat!(
1329 "Offset of field: ",
1330 stringify!(_CUVIDPARSERDISPINFO),
1331 "::",
1332 stringify!(progressive_frame)
1333 )
1334 );
1335 assert_eq!(
1336 unsafe { ::core::ptr::addr_of!((*ptr).top_field_first) as usize - ptr as usize },
1337 8usize,
1338 concat!(
1339 "Offset of field: ",
1340 stringify!(_CUVIDPARSERDISPINFO),
1341 "::",
1342 stringify!(top_field_first)
1343 )
1344 );
1345 assert_eq!(
1346 unsafe { ::core::ptr::addr_of!((*ptr).repeat_first_field) as usize - ptr as usize },
1347 12usize,
1348 concat!(
1349 "Offset of field: ",
1350 stringify!(_CUVIDPARSERDISPINFO),
1351 "::",
1352 stringify!(repeat_first_field)
1353 )
1354 );
1355 assert_eq!(
1356 unsafe { ::core::ptr::addr_of!((*ptr).timestamp) as usize - ptr as usize },
1357 16usize,
1358 concat!(
1359 "Offset of field: ",
1360 stringify!(_CUVIDPARSERDISPINFO),
1361 "::",
1362 stringify!(timestamp)
1363 )
1364 );
1365}
1366#[test]
1367fn bindgen_test_layout__CUVIDPARSERPARAMS() {
1368 const UNINIT: ::core::mem::MaybeUninit<_CUVIDPARSERPARAMS> = ::core::mem::MaybeUninit::uninit();
1369 let ptr = UNINIT.as_ptr();
1370 assert_eq!(
1371 ::core::mem::size_of::<_CUVIDPARSERPARAMS>(),
1372 136usize,
1373 concat!("Size of: ", stringify!(_CUVIDPARSERPARAMS))
1374 );
1375 assert_eq!(
1376 ::core::mem::align_of::<_CUVIDPARSERPARAMS>(),
1377 8usize,
1378 concat!("Alignment of ", stringify!(_CUVIDPARSERPARAMS))
1379 );
1380 assert_eq!(
1381 unsafe { ::core::ptr::addr_of!((*ptr).CodecType) as usize - ptr as usize },
1382 0usize,
1383 concat!(
1384 "Offset of field: ",
1385 stringify!(_CUVIDPARSERPARAMS),
1386 "::",
1387 stringify!(CodecType)
1388 )
1389 );
1390 assert_eq!(
1391 unsafe { ::core::ptr::addr_of!((*ptr).ulMaxNumDecodeSurfaces) as usize - ptr as usize },
1392 4usize,
1393 concat!(
1394 "Offset of field: ",
1395 stringify!(_CUVIDPARSERPARAMS),
1396 "::",
1397 stringify!(ulMaxNumDecodeSurfaces)
1398 )
1399 );
1400 assert_eq!(
1401 unsafe { ::core::ptr::addr_of!((*ptr).ulClockRate) as usize - ptr as usize },
1402 8usize,
1403 concat!(
1404 "Offset of field: ",
1405 stringify!(_CUVIDPARSERPARAMS),
1406 "::",
1407 stringify!(ulClockRate)
1408 )
1409 );
1410 assert_eq!(
1411 unsafe { ::core::ptr::addr_of!((*ptr).ulErrorThreshold) as usize - ptr as usize },
1412 12usize,
1413 concat!(
1414 "Offset of field: ",
1415 stringify!(_CUVIDPARSERPARAMS),
1416 "::",
1417 stringify!(ulErrorThreshold)
1418 )
1419 );
1420 assert_eq!(
1421 unsafe { ::core::ptr::addr_of!((*ptr).ulMaxDisplayDelay) as usize - ptr as usize },
1422 16usize,
1423 concat!(
1424 "Offset of field: ",
1425 stringify!(_CUVIDPARSERPARAMS),
1426 "::",
1427 stringify!(ulMaxDisplayDelay)
1428 )
1429 );
1430 assert_eq!(
1431 unsafe { ::core::ptr::addr_of!((*ptr).uReserved1) as usize - ptr as usize },
1432 24usize,
1433 concat!(
1434 "Offset of field: ",
1435 stringify!(_CUVIDPARSERPARAMS),
1436 "::",
1437 stringify!(uReserved1)
1438 )
1439 );
1440 assert_eq!(
1441 unsafe { ::core::ptr::addr_of!((*ptr).pUserData) as usize - ptr as usize },
1442 40usize,
1443 concat!(
1444 "Offset of field: ",
1445 stringify!(_CUVIDPARSERPARAMS),
1446 "::",
1447 stringify!(pUserData)
1448 )
1449 );
1450 assert_eq!(
1451 unsafe { ::core::ptr::addr_of!((*ptr).pfnSequenceCallback) as usize - ptr as usize },
1452 48usize,
1453 concat!(
1454 "Offset of field: ",
1455 stringify!(_CUVIDPARSERPARAMS),
1456 "::",
1457 stringify!(pfnSequenceCallback)
1458 )
1459 );
1460 assert_eq!(
1461 unsafe { ::core::ptr::addr_of!((*ptr).pfnDecodePicture) as usize - ptr as usize },
1462 56usize,
1463 concat!(
1464 "Offset of field: ",
1465 stringify!(_CUVIDPARSERPARAMS),
1466 "::",
1467 stringify!(pfnDecodePicture)
1468 )
1469 );
1470 assert_eq!(
1471 unsafe { ::core::ptr::addr_of!((*ptr).pfnDisplayPicture) as usize - ptr as usize },
1472 64usize,
1473 concat!(
1474 "Offset of field: ",
1475 stringify!(_CUVIDPARSERPARAMS),
1476 "::",
1477 stringify!(pfnDisplayPicture)
1478 )
1479 );
1480 assert_eq!(
1481 unsafe { ::core::ptr::addr_of!((*ptr).pfnGetOperatingPoint) as usize - ptr as usize },
1482 72usize,
1483 concat!(
1484 "Offset of field: ",
1485 stringify!(_CUVIDPARSERPARAMS),
1486 "::",
1487 stringify!(pfnGetOperatingPoint)
1488 )
1489 );
1490 assert_eq!(
1491 unsafe { ::core::ptr::addr_of!((*ptr).pfnGetSEIMsg) as usize - ptr as usize },
1492 80usize,
1493 concat!(
1494 "Offset of field: ",
1495 stringify!(_CUVIDPARSERPARAMS),
1496 "::",
1497 stringify!(pfnGetSEIMsg)
1498 )
1499 );
1500 assert_eq!(
1501 unsafe { ::core::ptr::addr_of!((*ptr).pvReserved2) as usize - ptr as usize },
1502 88usize,
1503 concat!(
1504 "Offset of field: ",
1505 stringify!(_CUVIDPARSERPARAMS),
1506 "::",
1507 stringify!(pvReserved2)
1508 )
1509 );
1510 assert_eq!(
1511 unsafe { ::core::ptr::addr_of!((*ptr).pExtVideoInfo) as usize - ptr as usize },
1512 128usize,
1513 concat!(
1514 "Offset of field: ",
1515 stringify!(_CUVIDPARSERPARAMS),
1516 "::",
1517 stringify!(pExtVideoInfo)
1518 )
1519 );
1520}
1521#[repr(i32)]
1522#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
1523pub enum cudaVideoState {
1524 cudaVideoState_Error = -1,
1525 cudaVideoState_Stopped = 0,
1526 cudaVideoState_Started = 1,
1527}
1528#[repr(u32)]
1529#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
1530pub enum cudaAudioCodec {
1531 cudaAudioCodec_MPEG1 = 0,
1532 cudaAudioCodec_MPEG2 = 1,
1533 cudaAudioCodec_MP3 = 2,
1534 cudaAudioCodec_AC3 = 3,
1535 cudaAudioCodec_LPCM = 4,
1536 cudaAudioCodec_AAC = 5,
1537}
1538#[repr(u32)]
1539#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
1540pub enum CUvideopacketflags {
1541 CUVID_PKT_ENDOFSTREAM = 1,
1542 CUVID_PKT_TIMESTAMP = 2,
1543 CUVID_PKT_DISCONTINUITY = 4,
1544 CUVID_PKT_ENDOFPICTURE = 8,
1545 CUVID_PKT_NOTIFY_EOS = 16,
1546}
1547#[repr(u32)]
1548#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
1549pub enum CUvideosourceformat_flags {
1550 CUVID_FMT_EXTFORMATINFO = 256,
1551}
1552#[repr(C)]
1553#[derive(Copy, Clone)]
1554pub union CUVIDOPERATINGPOINTINFO__bindgen_ty_1 {
1555 pub av1: CUVIDOPERATINGPOINTINFO__bindgen_ty_1__bindgen_ty_1,
1556 pub CodecReserved: [::core::ffi::c_uchar; 1024usize],
1557}
1558#[repr(C)]
1559#[derive(Copy, Clone)]
1560pub union CUVIDEOFORMATEX__bindgen_ty_1 {
1561 pub av1: CUVIDAV1SEQHDR,
1562 pub raw_seqhdr_data: [::core::ffi::c_uchar; 1024usize],
1563}
1564impl<Storage> __BindgenBitfieldUnit<Storage> {
1565 #[inline]
1566 pub const fn new(storage: Storage) -> Self {
1567 Self { storage }
1568 }
1569}
1570impl<Storage> __BindgenBitfieldUnit<Storage>
1571where
1572 Storage: AsRef<[u8]> + AsMut<[u8]>,
1573{
1574 #[inline]
1575 pub fn get_bit(&self, index: usize) -> bool {
1576 debug_assert!(index / 8 < self.storage.as_ref().len());
1577 let byte_index = index / 8;
1578 let byte = self.storage.as_ref()[byte_index];
1579 let bit_index = if cfg!(target_endian = "big") {
1580 7 - (index % 8)
1581 } else {
1582 index % 8
1583 };
1584 let mask = 1 << bit_index;
1585 byte & mask == mask
1586 }
1587
1588 #[inline]
1589 pub fn set_bit(&mut self, index: usize, val: bool) {
1590 debug_assert!(index / 8 < self.storage.as_ref().len());
1591 let byte_index = index / 8;
1592 let byte = &mut self.storage.as_mut()[byte_index];
1593 let bit_index = if cfg!(target_endian = "big") {
1594 7 - (index % 8)
1595 } else {
1596 index % 8
1597 };
1598 let mask = 1 << bit_index;
1599 if val {
1600 *byte |= mask;
1601 } else {
1602 *byte &= !mask;
1603 }
1604 }
1605
1606 #[inline]
1607 pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
1608 debug_assert!(bit_width <= 64);
1609 debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
1610 debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
1611 let mut val = 0;
1612 for i in 0..(bit_width as usize) {
1613 if self.get_bit(i + bit_offset) {
1614 let index = if cfg!(target_endian = "big") {
1615 bit_width as usize - 1 - i
1616 } else {
1617 i
1618 };
1619 val |= 1 << index;
1620 }
1621 }
1622 val
1623 }
1624
1625 #[inline]
1626 pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
1627 debug_assert!(bit_width <= 64);
1628 debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
1629 debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
1630 for i in 0..(bit_width as usize) {
1631 let mask = 1 << i;
1632 let val_bit_is_set = val & mask == mask;
1633 let index = if cfg!(target_endian = "big") {
1634 bit_width as usize - 1 - i
1635 } else {
1636 i
1637 };
1638 self.set_bit(index + bit_offset, val_bit_is_set);
1639 }
1640 }
1641}
1642impl CUVIDEOFORMAT__bindgen_ty_4 {
1643 #[inline]
1644 pub fn video_format(&self) -> ::core::ffi::c_uchar {
1645 unsafe { ::core::mem::transmute(self._bitfield_1.get(0usize, 3u8) as u8) }
1646 }
1647
1648 #[inline]
1649 pub fn set_video_format(&mut self, val: ::core::ffi::c_uchar) {
1650 unsafe {
1651 let val: u8 = ::core::mem::transmute(val);
1652 self._bitfield_1.set(0usize, 3u8, val as u64)
1653 }
1654 }
1655
1656 #[inline]
1657 pub fn video_full_range_flag(&self) -> ::core::ffi::c_uchar {
1658 unsafe { ::core::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8) }
1659 }
1660
1661 #[inline]
1662 pub fn set_video_full_range_flag(&mut self, val: ::core::ffi::c_uchar) {
1663 unsafe {
1664 let val: u8 = ::core::mem::transmute(val);
1665 self._bitfield_1.set(3usize, 1u8, val as u64)
1666 }
1667 }
1668
1669 #[inline]
1670 pub fn reserved_zero_bits(&self) -> ::core::ffi::c_uchar {
1671 unsafe { ::core::mem::transmute(self._bitfield_1.get(4usize, 4u8) as u8) }
1672 }
1673
1674 #[inline]
1675 pub fn set_reserved_zero_bits(&mut self, val: ::core::ffi::c_uchar) {
1676 unsafe {
1677 let val: u8 = ::core::mem::transmute(val);
1678 self._bitfield_1.set(4usize, 4u8, val as u64)
1679 }
1680 }
1681
1682 #[inline]
1683 pub fn new_bitfield_1(
1684 video_format: ::core::ffi::c_uchar,
1685 video_full_range_flag: ::core::ffi::c_uchar,
1686 reserved_zero_bits: ::core::ffi::c_uchar,
1687 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
1688 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
1689 __bindgen_bitfield_unit.set(0usize, 3u8, {
1690 let video_format: u8 = unsafe { ::core::mem::transmute(video_format) };
1691 video_format as u64
1692 });
1693 __bindgen_bitfield_unit.set(3usize, 1u8, {
1694 let video_full_range_flag: u8 =
1695 unsafe { ::core::mem::transmute(video_full_range_flag) };
1696 video_full_range_flag as u64
1697 });
1698 __bindgen_bitfield_unit.set(4usize, 4u8, {
1699 let reserved_zero_bits: u8 = unsafe { ::core::mem::transmute(reserved_zero_bits) };
1700 reserved_zero_bits as u64
1701 });
1702 __bindgen_bitfield_unit
1703 }
1704}
1705impl Default for CUVIDEOFORMAT {
1706 fn default() -> Self {
1707 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
1708 unsafe {
1709 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1710 s.assume_init()
1711 }
1712 }
1713}
1714impl Default for CUVIDOPERATINGPOINTINFO__bindgen_ty_1 {
1715 fn default() -> Self {
1716 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
1717 unsafe {
1718 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1719 s.assume_init()
1720 }
1721 }
1722}
1723impl Default for CUVIDOPERATINGPOINTINFO {
1724 fn default() -> Self {
1725 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
1726 unsafe {
1727 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1728 s.assume_init()
1729 }
1730 }
1731}
1732impl Default for _CUVIDSEIMESSAGEINFO {
1733 fn default() -> Self {
1734 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
1735 unsafe {
1736 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1737 s.assume_init()
1738 }
1739 }
1740}
1741impl Default for CUVIDAV1SEQHDR {
1742 fn default() -> Self {
1743 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
1744 unsafe {
1745 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1746 s.assume_init()
1747 }
1748 }
1749}
1750impl Default for CUVIDEOFORMATEX__bindgen_ty_1 {
1751 fn default() -> Self {
1752 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
1753 unsafe {
1754 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1755 s.assume_init()
1756 }
1757 }
1758}
1759impl Default for CUVIDEOFORMATEX {
1760 fn default() -> Self {
1761 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
1762 unsafe {
1763 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1764 s.assume_init()
1765 }
1766 }
1767}
1768impl Default for CUAUDIOFORMAT {
1769 fn default() -> Self {
1770 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
1771 unsafe {
1772 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1773 s.assume_init()
1774 }
1775 }
1776}
1777impl Default for _CUVIDSOURCEDATAPACKET {
1778 fn default() -> Self {
1779 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
1780 unsafe {
1781 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1782 s.assume_init()
1783 }
1784 }
1785}
1786impl Default for _CUVIDSOURCEPARAMS {
1787 fn default() -> Self {
1788 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
1789 unsafe {
1790 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1791 s.assume_init()
1792 }
1793 }
1794}
1795impl _CUVIDSOURCEPARAMS {
1796 #[inline]
1797 pub fn bAnnexb(&self) -> ::core::ffi::c_uint {
1798 unsafe { ::core::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
1799 }
1800
1801 #[inline]
1802 pub fn set_bAnnexb(&mut self, val: ::core::ffi::c_uint) {
1803 unsafe {
1804 let val: u32 = ::core::mem::transmute(val);
1805 self._bitfield_1.set(0usize, 1u8, val as u64)
1806 }
1807 }
1808
1809 #[inline]
1810 pub fn uReserved(&self) -> ::core::ffi::c_uint {
1811 unsafe { ::core::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) }
1812 }
1813
1814 #[inline]
1815 pub fn set_uReserved(&mut self, val: ::core::ffi::c_uint) {
1816 unsafe {
1817 let val: u32 = ::core::mem::transmute(val);
1818 self._bitfield_1.set(1usize, 31u8, val as u64)
1819 }
1820 }
1821
1822 #[inline]
1823 pub fn new_bitfield_1(
1824 bAnnexb: ::core::ffi::c_uint,
1825 uReserved: ::core::ffi::c_uint,
1826 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
1827 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
1828 __bindgen_bitfield_unit.set(0usize, 1u8, {
1829 let bAnnexb: u32 = unsafe { ::core::mem::transmute(bAnnexb) };
1830 bAnnexb as u64
1831 });
1832 __bindgen_bitfield_unit.set(1usize, 31u8, {
1833 let uReserved: u32 = unsafe { ::core::mem::transmute(uReserved) };
1834 uReserved as u64
1835 });
1836 __bindgen_bitfield_unit
1837 }
1838}
1839impl Default for _CUVIDPARSERPARAMS {
1840 fn default() -> Self {
1841 let mut s = ::core::mem::MaybeUninit::<Self>::uninit();
1842 unsafe {
1843 ::core::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1844 s.assume_init()
1845 }
1846 }
1847}
1848impl _CUVIDPARSERPARAMS {
1849 #[inline]
1850 pub fn bAnnexb(&self) -> ::core::ffi::c_uint {
1851 unsafe { ::core::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
1852 }
1853
1854 #[inline]
1855 pub fn set_bAnnexb(&mut self, val: ::core::ffi::c_uint) {
1856 unsafe {
1857 let val: u32 = ::core::mem::transmute(val);
1858 self._bitfield_1.set(0usize, 1u8, val as u64)
1859 }
1860 }
1861
1862 #[inline]
1863 pub fn uReserved(&self) -> ::core::ffi::c_uint {
1864 unsafe { ::core::mem::transmute(self._bitfield_1.get(1usize, 31u8) as u32) }
1865 }
1866
1867 #[inline]
1868 pub fn set_uReserved(&mut self, val: ::core::ffi::c_uint) {
1869 unsafe {
1870 let val: u32 = ::core::mem::transmute(val);
1871 self._bitfield_1.set(1usize, 31u8, val as u64)
1872 }
1873 }
1874
1875 #[inline]
1876 pub fn new_bitfield_1(
1877 bAnnexb: ::core::ffi::c_uint,
1878 uReserved: ::core::ffi::c_uint,
1879 ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
1880 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
1881 __bindgen_bitfield_unit.set(0usize, 1u8, {
1882 let bAnnexb: u32 = unsafe { ::core::mem::transmute(bAnnexb) };
1883 bAnnexb as u64
1884 });
1885 __bindgen_bitfield_unit.set(1usize, 31u8, {
1886 let uReserved: u32 = unsafe { ::core::mem::transmute(uReserved) };
1887 uReserved as u64
1888 });
1889 __bindgen_bitfield_unit
1890 }
1891}
1892extern "C" {
1893 #[must_use]
1894 pub fn cuvidCreateVideoSource(
1895 pObj: *mut CUvideosource,
1896 pszFileName: *const ::core::ffi::c_char,
1897 pParams: *mut CUVIDSOURCEPARAMS,
1898 ) -> CUresult;
1899 #[must_use]
1900 pub fn cuvidCreateVideoSourceW(
1901 pObj: *mut CUvideosource,
1902 pwszFileName: *const wchar_t,
1903 pParams: *mut CUVIDSOURCEPARAMS,
1904 ) -> CUresult;
1905 #[must_use]
1906 pub fn cuvidDestroyVideoSource(obj: CUvideosource) -> CUresult;
1907 #[must_use]
1908 pub fn cuvidSetVideoSourceState(obj: CUvideosource, state: cudaVideoState) -> CUresult;
1909 pub fn cuvidGetVideoSourceState(obj: CUvideosource) -> cudaVideoState;
1910 #[must_use]
1911 pub fn cuvidGetSourceVideoFormat(
1912 obj: CUvideosource,
1913 pvidfmt: *mut CUVIDEOFORMAT,
1914 flags: ::core::ffi::c_uint,
1915 ) -> CUresult;
1916 #[must_use]
1917 pub fn cuvidGetSourceAudioFormat(
1918 obj: CUvideosource,
1919 paudfmt: *mut CUAUDIOFORMAT,
1920 flags: ::core::ffi::c_uint,
1921 ) -> CUresult;
1922 #[must_use]
1923 pub fn cuvidCreateVideoParser(
1924 pObj: *mut CUvideoparser,
1925 pParams: *mut CUVIDPARSERPARAMS,
1926 ) -> CUresult;
1927 #[must_use]
1928 pub fn cuvidParseVideoData(obj: CUvideoparser, pPacket: *mut CUVIDSOURCEDATAPACKET)
1929 -> CUresult;
1930 #[must_use]
1931 pub fn cuvidDestroyVideoParser(obj: CUvideoparser) -> CUresult;
1932}