nvidia_video_codec_sdk/sys/linux_sys/
nvcuvid.rs

1use super::cuviddec::*;
2use cudarc::driver::sys::*;
3type wchar_t = i32;
4/* automatically generated by rust-bindgen 0.65.1 */
5
6pub 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}