1#[repr(C)]
4#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
5pub struct __BindgenBitfieldUnit<Storage, Align> {
6 storage: Storage,
7 align: [Align; 0],
8}
9impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align> {
10 #[inline]
11 pub const fn new(storage: Storage) -> Self {
12 Self { storage, align: [] }
13 }
14}
15impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align>
16where
17 Storage: AsRef<[u8]> + AsMut<[u8]>,
18{
19 #[inline]
20 pub fn get_bit(&self, index: usize) -> bool {
21 debug_assert!(index / 8 < self.storage.as_ref().len());
22 let byte_index = index / 8;
23 let byte = self.storage.as_ref()[byte_index];
24 let bit_index = if cfg!(target_endian = "big") {
25 7 - (index % 8)
26 } else {
27 index % 8
28 };
29 let mask = 1 << bit_index;
30 byte & mask == mask
31 }
32 #[inline]
33 pub fn set_bit(&mut self, index: usize, val: bool) {
34 debug_assert!(index / 8 < self.storage.as_ref().len());
35 let byte_index = index / 8;
36 let byte = &mut self.storage.as_mut()[byte_index];
37 let bit_index = if cfg!(target_endian = "big") {
38 7 - (index % 8)
39 } else {
40 index % 8
41 };
42 let mask = 1 << bit_index;
43 if val {
44 *byte |= mask;
45 } else {
46 *byte &= !mask;
47 }
48 }
49 #[inline]
50 pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
51 debug_assert!(bit_width <= 64);
52 debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
53 debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
54 let mut val = 0;
55 for i in 0..(bit_width as usize) {
56 if self.get_bit(i + bit_offset) {
57 let index = if cfg!(target_endian = "big") {
58 bit_width as usize - 1 - i
59 } else {
60 i
61 };
62 val |= 1 << index;
63 }
64 }
65 val
66 }
67 #[inline]
68 pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
69 debug_assert!(bit_width <= 64);
70 debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
71 debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
72 for i in 0..(bit_width as usize) {
73 let mask = 1 << i;
74 let val_bit_is_set = val & mask == mask;
75 let index = if cfg!(target_endian = "big") {
76 bit_width as usize - 1 - i
77 } else {
78 i
79 };
80 self.set_bit(index + bit_offset, val_bit_is_set);
81 }
82 }
83}
84#[repr(C)]
85#[derive(Default)]
86pub struct __IncompleteArrayField<T>(::std::marker::PhantomData<T>, [T; 0]);
87impl<T> __IncompleteArrayField<T> {
88 #[inline]
89 pub const fn new() -> Self {
90 __IncompleteArrayField(::std::marker::PhantomData, [])
91 }
92 #[inline]
93 pub fn as_ptr(&self) -> *const T {
94 self as *const _ as *const T
95 }
96 #[inline]
97 pub fn as_mut_ptr(&mut self) -> *mut T {
98 self as *mut _ as *mut T
99 }
100 #[inline]
101 pub unsafe fn as_slice(&self, len: usize) -> &[T] {
102 ::std::slice::from_raw_parts(self.as_ptr(), len)
103 }
104 #[inline]
105 pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] {
106 ::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len)
107 }
108}
109impl<T> ::std::fmt::Debug for __IncompleteArrayField<T> {
110 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
111 fmt.write_str("__IncompleteArrayField")
112 }
113}
114pub const ATSC_BASE_PID: u32 = 8187;
115pub const ATSC_TABLE_EIT: u32 = 203;
116pub const DVB_TABLE_CAT: u32 = 1;
117pub const DVB_TABLE_CAT_PID: u32 = 1;
118pub const DVB_MAX_PAYLOAD_PACKET_SIZE: u32 = 4096;
119pub const DVB_CRC_SIZE: u32 = 4;
120pub const DMX_FILTER_SIZE: u32 = 16;
121pub const DMX_CHECK_CRC: u32 = 1;
122pub const DMX_ONESHOT: u32 = 2;
123pub const DMX_IMMEDIATE_START: u32 = 4;
124pub const DTV_UNDEFINED: u32 = 0;
125pub const DTV_TUNE: u32 = 1;
126pub const DTV_CLEAR: u32 = 2;
127pub const DTV_FREQUENCY: u32 = 3;
128pub const DTV_MODULATION: u32 = 4;
129pub const DTV_BANDWIDTH_HZ: u32 = 5;
130pub const DTV_INVERSION: u32 = 6;
131pub const DTV_DISEQC_MASTER: u32 = 7;
132pub const DTV_SYMBOL_RATE: u32 = 8;
133pub const DTV_INNER_FEC: u32 = 9;
134pub const DTV_VOLTAGE: u32 = 10;
135pub const DTV_TONE: u32 = 11;
136pub const DTV_PILOT: u32 = 12;
137pub const DTV_ROLLOFF: u32 = 13;
138pub const DTV_DISEQC_SLAVE_REPLY: u32 = 14;
139pub const DTV_FE_CAPABILITY_COUNT: u32 = 15;
140pub const DTV_FE_CAPABILITY: u32 = 16;
141pub const DTV_DELIVERY_SYSTEM: u32 = 17;
142pub const DTV_ISDBT_PARTIAL_RECEPTION: u32 = 18;
143pub const DTV_ISDBT_SOUND_BROADCASTING: u32 = 19;
144pub const DTV_ISDBT_SB_SUBCHANNEL_ID: u32 = 20;
145pub const DTV_ISDBT_SB_SEGMENT_IDX: u32 = 21;
146pub const DTV_ISDBT_SB_SEGMENT_COUNT: u32 = 22;
147pub const DTV_ISDBT_LAYERA_FEC: u32 = 23;
148pub const DTV_ISDBT_LAYERA_MODULATION: u32 = 24;
149pub const DTV_ISDBT_LAYERA_SEGMENT_COUNT: u32 = 25;
150pub const DTV_ISDBT_LAYERA_TIME_INTERLEAVING: u32 = 26;
151pub const DTV_ISDBT_LAYERB_FEC: u32 = 27;
152pub const DTV_ISDBT_LAYERB_MODULATION: u32 = 28;
153pub const DTV_ISDBT_LAYERB_SEGMENT_COUNT: u32 = 29;
154pub const DTV_ISDBT_LAYERB_TIME_INTERLEAVING: u32 = 30;
155pub const DTV_ISDBT_LAYERC_FEC: u32 = 31;
156pub const DTV_ISDBT_LAYERC_MODULATION: u32 = 32;
157pub const DTV_ISDBT_LAYERC_SEGMENT_COUNT: u32 = 33;
158pub const DTV_ISDBT_LAYERC_TIME_INTERLEAVING: u32 = 34;
159pub const DTV_API_VERSION: u32 = 35;
160pub const DTV_CODE_RATE_HP: u32 = 36;
161pub const DTV_CODE_RATE_LP: u32 = 37;
162pub const DTV_GUARD_INTERVAL: u32 = 38;
163pub const DTV_TRANSMISSION_MODE: u32 = 39;
164pub const DTV_HIERARCHY: u32 = 40;
165pub const DTV_ISDBT_LAYER_ENABLED: u32 = 41;
166pub const DTV_STREAM_ID: u32 = 42;
167pub const DTV_ISDBS_TS_ID_LEGACY: u32 = 42;
168pub const DTV_DVBT2_PLP_ID_LEGACY: u32 = 43;
169pub const DTV_ENUM_DELSYS: u32 = 44;
170pub const DTV_ATSCMH_FIC_VER: u32 = 45;
171pub const DTV_ATSCMH_PARADE_ID: u32 = 46;
172pub const DTV_ATSCMH_NOG: u32 = 47;
173pub const DTV_ATSCMH_TNOG: u32 = 48;
174pub const DTV_ATSCMH_SGN: u32 = 49;
175pub const DTV_ATSCMH_PRC: u32 = 50;
176pub const DTV_ATSCMH_RS_FRAME_MODE: u32 = 51;
177pub const DTV_ATSCMH_RS_FRAME_ENSEMBLE: u32 = 52;
178pub const DTV_ATSCMH_RS_CODE_MODE_PRI: u32 = 53;
179pub const DTV_ATSCMH_RS_CODE_MODE_SEC: u32 = 54;
180pub const DTV_ATSCMH_SCCC_BLOCK_MODE: u32 = 55;
181pub const DTV_ATSCMH_SCCC_CODE_MODE_A: u32 = 56;
182pub const DTV_ATSCMH_SCCC_CODE_MODE_B: u32 = 57;
183pub const DTV_ATSCMH_SCCC_CODE_MODE_C: u32 = 58;
184pub const DTV_ATSCMH_SCCC_CODE_MODE_D: u32 = 59;
185pub const DTV_INTERLEAVING: u32 = 60;
186pub const DTV_LNA: u32 = 61;
187pub const DTV_STAT_SIGNAL_STRENGTH: u32 = 62;
188pub const DTV_STAT_CNR: u32 = 63;
189pub const DTV_STAT_PRE_ERROR_BIT_COUNT: u32 = 64;
190pub const DTV_STAT_PRE_TOTAL_BIT_COUNT: u32 = 65;
191pub const DTV_STAT_POST_ERROR_BIT_COUNT: u32 = 66;
192pub const DTV_STAT_POST_TOTAL_BIT_COUNT: u32 = 67;
193pub const DTV_STAT_ERROR_BLOCK_COUNT: u32 = 68;
194pub const DTV_STAT_TOTAL_BLOCK_COUNT: u32 = 69;
195pub const DTV_SCRAMBLING_SEQUENCE_INDEX: u32 = 70;
196pub const DTV_MAX_COMMAND: u32 = 70;
197pub const NO_STREAM_ID_FILTER: i32 = -1;
198pub const LNA_AUTO: i32 = -1;
199pub const MAX_DTV_STATS: u32 = 4;
200pub const DTV_IOCTL_MAX_MSGS: u32 = 64;
201pub const FE_TUNE_MODE_ONESHOT: u32 = 1;
202pub const DTV_USER_COMMAND_START: u32 = 256;
203pub const DTV_POLARIZATION: u32 = 256;
204pub const DTV_VIDEO_PID: u32 = 257;
205pub const DTV_AUDIO_PID: u32 = 258;
206pub const DTV_SERVICE_ID: u32 = 259;
207pub const DTV_CH_NAME: u32 = 260;
208pub const DTV_VCHANNEL: u32 = 261;
209pub const DTV_SAT_NUMBER: u32 = 262;
210pub const DTV_DISEQC_WAIT: u32 = 263;
211pub const DTV_DISEQC_LNB: u32 = 264;
212pub const DTV_FREQ_BPF: u32 = 265;
213pub const DTV_PLS_CODE: u32 = 266;
214pub const DTV_PLS_MODE: u32 = 267;
215pub const DTV_COUNTRY_CODE: u32 = 268;
216pub const DTV_MAX_USER_COMMAND: u32 = 268;
217pub const DTV_USER_NAME_SIZE: u32 = 13;
218pub const DTV_STAT_COMMAND_START: u32 = 512;
219pub const DTV_STATUS: u32 = 512;
220pub const DTV_BER: u32 = 513;
221pub const DTV_PER: u32 = 514;
222pub const DTV_QUALITY: u32 = 515;
223pub const DTV_PRE_BER: u32 = 516;
224pub const DTV_MAX_STAT_COMMAND: u32 = 516;
225pub const DTV_STAT_NAME_SIZE: u32 = 5;
226pub const DTV_NUM_KERNEL_STATS: u32 = 8;
227pub const DTV_NUM_STATS_PROPS: u32 = 13;
228pub const LOG_EMERG: u32 = 0;
229pub const LOG_ALERT: u32 = 1;
230pub const LOG_CRIT: u32 = 2;
231pub const LOG_ERR: u32 = 3;
232pub const LOG_WARNING: u32 = 4;
233pub const LOG_NOTICE: u32 = 5;
234pub const LOG_INFO: u32 = 6;
235pub const LOG_DEBUG: u32 = 7;
236pub const LOG_PRIMASK: u32 = 7;
237pub const LOG_KERN: u32 = 0;
238pub const LOG_USER: u32 = 8;
239pub const LOG_MAIL: u32 = 16;
240pub const LOG_DAEMON: u32 = 24;
241pub const LOG_AUTH: u32 = 32;
242pub const LOG_SYSLOG: u32 = 40;
243pub const LOG_LPR: u32 = 48;
244pub const LOG_NEWS: u32 = 56;
245pub const LOG_UUCP: u32 = 64;
246pub const LOG_CRON: u32 = 72;
247pub const LOG_AUTHPRIV: u32 = 80;
248pub const LOG_FTP: u32 = 88;
249pub const LOG_LOCAL0: u32 = 128;
250pub const LOG_LOCAL1: u32 = 136;
251pub const LOG_LOCAL2: u32 = 144;
252pub const LOG_LOCAL3: u32 = 152;
253pub const LOG_LOCAL4: u32 = 160;
254pub const LOG_LOCAL5: u32 = 168;
255pub const LOG_LOCAL6: u32 = 176;
256pub const LOG_LOCAL7: u32 = 184;
257pub const LOG_NFACILITIES: u32 = 24;
258pub const LOG_FACMASK: u32 = 1016;
259pub const LOG_PID: u32 = 1;
260pub const LOG_CONS: u32 = 2;
261pub const LOG_ODELAY: u32 = 4;
262pub const LOG_NDELAY: u32 = 8;
263pub const LOG_NOWAIT: u32 = 16;
264pub const LOG_PERROR: u32 = 32;
265pub const MAX_DELIVERY_SYSTEMS: u32 = 20;
266pub const DTV_MAX_STATS: u32 = 13;
267pub const DTV_SIGNAL_STRENGTH: u32 = 62;
268pub const DTV_SNR: u32 = 63;
269pub const DTV_UNCORRECTED_BLOCKS: u32 = 68;
270pub const MAX_TABLE_SIZE: u32 = 1048576;
271pub const DVB_TABLE_EIT: u32 = 78;
272pub const DVB_TABLE_EIT_OTHER: u32 = 79;
273pub const DVB_TABLE_EIT_PID: u32 = 18;
274pub const DVB_TABLE_EIT_SCHEDULE: u32 = 80;
275pub const DVB_TABLE_EIT_SCHEDULE_OTHER: u32 = 96;
276pub const LIBDVBV5_VERSION_MAJOR: u32 = 1;
277pub const LIBDVBV5_VERSION_MINOR: u32 = 20;
278pub const LIBDVBV5_VERSION_PATCH: u32 = 0;
279pub const LIBDVBV5_VERSION: &'static [u8; 7usize] = b"1.20.0\0";
280pub const ATSC_TABLE_MGT: u32 = 199;
281pub const DVB_MPEG_ES_PIC_START: u32 = 0;
282pub const DVB_MPEG_ES_USER_DATA: u32 = 178;
283pub const DVB_MPEG_ES_SEQ_START: u32 = 179;
284pub const DVB_MPEG_ES_SEQ_EXT: u32 = 181;
285pub const DVB_MPEG_ES_GOP: u32 = 184;
286pub const DVB_MPEG_PES: u32 = 1;
287pub const DVB_MPEG_STREAM_MAP: u32 = 188;
288pub const DVB_MPEG_STREAM_PADDING: u32 = 190;
289pub const DVB_MPEG_STREAM_PRIVATE_2: u32 = 95;
290pub const DVB_MPEG_STREAM_ECM: u32 = 112;
291pub const DVB_MPEG_STREAM_EMM: u32 = 113;
292pub const DVB_MPEG_STREAM_DIRECTORY: u32 = 255;
293pub const DVB_MPEG_STREAM_DSMCC: u32 = 122;
294pub const DVB_MPEG_STREAM_H222E: u32 = 248;
295pub const DVB_MPEG_TS: u32 = 71;
296pub const DVB_MPEG_TS_PACKET_SIZE: u32 = 188;
297pub const DVB_TABLE_NIT: u32 = 64;
298pub const DVB_TABLE_NIT2: u32 = 65;
299pub const DVB_TABLE_NIT_PID: u32 = 16;
300pub const DVB_TABLE_PAT: u32 = 0;
301pub const DVB_TABLE_PAT_PID: u32 = 0;
302pub const DVB_TABLE_PMT: u32 = 2;
303pub const DVB_TABLE_SDT: u32 = 66;
304pub const DVB_TABLE_SDT2: u32 = 70;
305pub const DVB_TABLE_SDT_PID: u32 = 17;
306pub const ATSC_TABLE_TVCT: u32 = 200;
307pub const ATSC_TABLE_CVCT: u32 = 201;
308pub const ATSC_TABLE_VCT_PID: u32 = 8187;
309pub type __uint8_t = ::std::os::raw::c_uchar;
310pub type __uint16_t = ::std::os::raw::c_ushort;
311pub type __uint32_t = ::std::os::raw::c_uint;
312pub type __uint64_t = ::std::os::raw::c_ulong;
313pub type __ssize_t = ::std::os::raw::c_long;
314pub type ssize_t = __ssize_t;
315pub type size_t = ::std::os::raw::c_ulong;
316#[repr(C)]
317#[derive(Debug, Copy, Clone)]
318pub struct tm {
319 pub tm_sec: ::std::os::raw::c_int,
320 pub tm_min: ::std::os::raw::c_int,
321 pub tm_hour: ::std::os::raw::c_int,
322 pub tm_mday: ::std::os::raw::c_int,
323 pub tm_mon: ::std::os::raw::c_int,
324 pub tm_year: ::std::os::raw::c_int,
325 pub tm_wday: ::std::os::raw::c_int,
326 pub tm_yday: ::std::os::raw::c_int,
327 pub tm_isdst: ::std::os::raw::c_int,
328 pub tm_gmtoff: ::std::os::raw::c_long,
329 pub tm_zone: *const ::std::os::raw::c_char,
330}
331#[test]
332fn bindgen_test_layout_tm() {
333 assert_eq!(
334 ::std::mem::size_of::<tm>(),
335 56usize,
336 concat!("Size of: ", stringify!(tm))
337 );
338 assert_eq!(
339 ::std::mem::align_of::<tm>(),
340 8usize,
341 concat!("Alignment of ", stringify!(tm))
342 );
343 assert_eq!(
344 unsafe { &(*(::std::ptr::null::<tm>())).tm_sec as *const _ as usize },
345 0usize,
346 concat!(
347 "Offset of field: ",
348 stringify!(tm),
349 "::",
350 stringify!(tm_sec)
351 )
352 );
353 assert_eq!(
354 unsafe { &(*(::std::ptr::null::<tm>())).tm_min as *const _ as usize },
355 4usize,
356 concat!(
357 "Offset of field: ",
358 stringify!(tm),
359 "::",
360 stringify!(tm_min)
361 )
362 );
363 assert_eq!(
364 unsafe { &(*(::std::ptr::null::<tm>())).tm_hour as *const _ as usize },
365 8usize,
366 concat!(
367 "Offset of field: ",
368 stringify!(tm),
369 "::",
370 stringify!(tm_hour)
371 )
372 );
373 assert_eq!(
374 unsafe { &(*(::std::ptr::null::<tm>())).tm_mday as *const _ as usize },
375 12usize,
376 concat!(
377 "Offset of field: ",
378 stringify!(tm),
379 "::",
380 stringify!(tm_mday)
381 )
382 );
383 assert_eq!(
384 unsafe { &(*(::std::ptr::null::<tm>())).tm_mon as *const _ as usize },
385 16usize,
386 concat!(
387 "Offset of field: ",
388 stringify!(tm),
389 "::",
390 stringify!(tm_mon)
391 )
392 );
393 assert_eq!(
394 unsafe { &(*(::std::ptr::null::<tm>())).tm_year as *const _ as usize },
395 20usize,
396 concat!(
397 "Offset of field: ",
398 stringify!(tm),
399 "::",
400 stringify!(tm_year)
401 )
402 );
403 assert_eq!(
404 unsafe { &(*(::std::ptr::null::<tm>())).tm_wday as *const _ as usize },
405 24usize,
406 concat!(
407 "Offset of field: ",
408 stringify!(tm),
409 "::",
410 stringify!(tm_wday)
411 )
412 );
413 assert_eq!(
414 unsafe { &(*(::std::ptr::null::<tm>())).tm_yday as *const _ as usize },
415 28usize,
416 concat!(
417 "Offset of field: ",
418 stringify!(tm),
419 "::",
420 stringify!(tm_yday)
421 )
422 );
423 assert_eq!(
424 unsafe { &(*(::std::ptr::null::<tm>())).tm_isdst as *const _ as usize },
425 32usize,
426 concat!(
427 "Offset of field: ",
428 stringify!(tm),
429 "::",
430 stringify!(tm_isdst)
431 )
432 );
433 assert_eq!(
434 unsafe { &(*(::std::ptr::null::<tm>())).tm_gmtoff as *const _ as usize },
435 40usize,
436 concat!(
437 "Offset of field: ",
438 stringify!(tm),
439 "::",
440 stringify!(tm_gmtoff)
441 )
442 );
443 assert_eq!(
444 unsafe { &(*(::std::ptr::null::<tm>())).tm_zone as *const _ as usize },
445 48usize,
446 concat!(
447 "Offset of field: ",
448 stringify!(tm),
449 "::",
450 stringify!(tm_zone)
451 )
452 );
453}
454#[repr(C, packed)]
455#[derive(Copy, Clone)]
456pub struct dvb_ts_packet_header {
457 pub sync_byte: u8,
458 pub __bindgen_anon_1: dvb_ts_packet_header__bindgen_ty_1,
459 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize], u8>,
460 pub adaptation_field_length: u8,
461 pub __bindgen_anon_2: dvb_ts_packet_header__bindgen_ty_2,
462}
463#[repr(C, packed)]
464#[derive(Copy, Clone)]
465pub union dvb_ts_packet_header__bindgen_ty_1 {
466 pub bitfield: u16,
467 pub __bindgen_anon_1: dvb_ts_packet_header__bindgen_ty_1__bindgen_ty_1,
468 _bindgen_union_align: [u8; 2usize],
469}
470#[repr(C, packed)]
471#[derive(Debug, Copy, Clone)]
472pub struct dvb_ts_packet_header__bindgen_ty_1__bindgen_ty_1 {
473 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize], u8>,
474}
475#[test]
476fn bindgen_test_layout_dvb_ts_packet_header__bindgen_ty_1__bindgen_ty_1() {
477 assert_eq!(
478 ::std::mem::size_of::<dvb_ts_packet_header__bindgen_ty_1__bindgen_ty_1>(),
479 2usize,
480 concat!(
481 "Size of: ",
482 stringify!(dvb_ts_packet_header__bindgen_ty_1__bindgen_ty_1)
483 )
484 );
485 assert_eq!(
486 ::std::mem::align_of::<dvb_ts_packet_header__bindgen_ty_1__bindgen_ty_1>(),
487 1usize,
488 concat!(
489 "Alignment of ",
490 stringify!(dvb_ts_packet_header__bindgen_ty_1__bindgen_ty_1)
491 )
492 );
493}
494impl dvb_ts_packet_header__bindgen_ty_1__bindgen_ty_1 {
495 #[inline]
496 pub fn pid(&self) -> u16 {
497 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 13u8) as u16) }
498 }
499 #[inline]
500 pub fn set_pid(&mut self, val: u16) {
501 unsafe {
502 let val: u16 = ::std::mem::transmute(val);
503 self._bitfield_1.set(0usize, 13u8, val as u64)
504 }
505 }
506 #[inline]
507 pub fn transport_priority(&self) -> u16 {
508 unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u16) }
509 }
510 #[inline]
511 pub fn set_transport_priority(&mut self, val: u16) {
512 unsafe {
513 let val: u16 = ::std::mem::transmute(val);
514 self._bitfield_1.set(13usize, 1u8, val as u64)
515 }
516 }
517 #[inline]
518 pub fn payload_unit_start_indicator(&self) -> u16 {
519 unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u16) }
520 }
521 #[inline]
522 pub fn set_payload_unit_start_indicator(&mut self, val: u16) {
523 unsafe {
524 let val: u16 = ::std::mem::transmute(val);
525 self._bitfield_1.set(14usize, 1u8, val as u64)
526 }
527 }
528 #[inline]
529 pub fn transport_error_indicator(&self) -> u16 {
530 unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u16) }
531 }
532 #[inline]
533 pub fn set_transport_error_indicator(&mut self, val: u16) {
534 unsafe {
535 let val: u16 = ::std::mem::transmute(val);
536 self._bitfield_1.set(15usize, 1u8, val as u64)
537 }
538 }
539 #[inline]
540 pub fn new_bitfield_1(
541 pid: u16,
542 transport_priority: u16,
543 payload_unit_start_indicator: u16,
544 transport_error_indicator: u16,
545 ) -> __BindgenBitfieldUnit<[u8; 2usize], u8> {
546 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize], u8> =
547 Default::default();
548 __bindgen_bitfield_unit.set(0usize, 13u8, {
549 let pid: u16 = unsafe { ::std::mem::transmute(pid) };
550 pid as u64
551 });
552 __bindgen_bitfield_unit.set(13usize, 1u8, {
553 let transport_priority: u16 = unsafe { ::std::mem::transmute(transport_priority) };
554 transport_priority as u64
555 });
556 __bindgen_bitfield_unit.set(14usize, 1u8, {
557 let payload_unit_start_indicator: u16 =
558 unsafe { ::std::mem::transmute(payload_unit_start_indicator) };
559 payload_unit_start_indicator as u64
560 });
561 __bindgen_bitfield_unit.set(15usize, 1u8, {
562 let transport_error_indicator: u16 =
563 unsafe { ::std::mem::transmute(transport_error_indicator) };
564 transport_error_indicator as u64
565 });
566 __bindgen_bitfield_unit
567 }
568}
569#[test]
570fn bindgen_test_layout_dvb_ts_packet_header__bindgen_ty_1() {
571 assert_eq!(
572 ::std::mem::size_of::<dvb_ts_packet_header__bindgen_ty_1>(),
573 2usize,
574 concat!("Size of: ", stringify!(dvb_ts_packet_header__bindgen_ty_1))
575 );
576 assert_eq!(
577 ::std::mem::align_of::<dvb_ts_packet_header__bindgen_ty_1>(),
578 1usize,
579 concat!(
580 "Alignment of ",
581 stringify!(dvb_ts_packet_header__bindgen_ty_1)
582 )
583 );
584 assert_eq!(
585 unsafe {
586 &(*(::std::ptr::null::<dvb_ts_packet_header__bindgen_ty_1>())).bitfield as *const _
587 as usize
588 },
589 0usize,
590 concat!(
591 "Offset of field: ",
592 stringify!(dvb_ts_packet_header__bindgen_ty_1),
593 "::",
594 stringify!(bitfield)
595 )
596 );
597}
598#[repr(C, packed)]
599#[derive(Debug, Copy, Clone)]
600pub struct dvb_ts_packet_header__bindgen_ty_2 {
601 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize], u8>,
602}
603#[test]
604fn bindgen_test_layout_dvb_ts_packet_header__bindgen_ty_2() {
605 assert_eq!(
606 ::std::mem::size_of::<dvb_ts_packet_header__bindgen_ty_2>(),
607 1usize,
608 concat!("Size of: ", stringify!(dvb_ts_packet_header__bindgen_ty_2))
609 );
610 assert_eq!(
611 ::std::mem::align_of::<dvb_ts_packet_header__bindgen_ty_2>(),
612 1usize,
613 concat!(
614 "Alignment of ",
615 stringify!(dvb_ts_packet_header__bindgen_ty_2)
616 )
617 );
618}
619impl dvb_ts_packet_header__bindgen_ty_2 {
620 #[inline]
621 pub fn extension(&self) -> u8 {
622 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
623 }
624 #[inline]
625 pub fn set_extension(&mut self, val: u8) {
626 unsafe {
627 let val: u8 = ::std::mem::transmute(val);
628 self._bitfield_1.set(0usize, 1u8, val as u64)
629 }
630 }
631 #[inline]
632 pub fn private_data(&self) -> u8 {
633 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
634 }
635 #[inline]
636 pub fn set_private_data(&mut self, val: u8) {
637 unsafe {
638 let val: u8 = ::std::mem::transmute(val);
639 self._bitfield_1.set(1usize, 1u8, val as u64)
640 }
641 }
642 #[inline]
643 pub fn splicing_point(&self) -> u8 {
644 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) }
645 }
646 #[inline]
647 pub fn set_splicing_point(&mut self, val: u8) {
648 unsafe {
649 let val: u8 = ::std::mem::transmute(val);
650 self._bitfield_1.set(2usize, 1u8, val as u64)
651 }
652 }
653 #[inline]
654 pub fn OPCR(&self) -> u8 {
655 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8) }
656 }
657 #[inline]
658 pub fn set_OPCR(&mut self, val: u8) {
659 unsafe {
660 let val: u8 = ::std::mem::transmute(val);
661 self._bitfield_1.set(3usize, 1u8, val as u64)
662 }
663 }
664 #[inline]
665 pub fn PCR(&self) -> u8 {
666 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u8) }
667 }
668 #[inline]
669 pub fn set_PCR(&mut self, val: u8) {
670 unsafe {
671 let val: u8 = ::std::mem::transmute(val);
672 self._bitfield_1.set(4usize, 1u8, val as u64)
673 }
674 }
675 #[inline]
676 pub fn priority(&self) -> u8 {
677 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u8) }
678 }
679 #[inline]
680 pub fn set_priority(&mut self, val: u8) {
681 unsafe {
682 let val: u8 = ::std::mem::transmute(val);
683 self._bitfield_1.set(5usize, 1u8, val as u64)
684 }
685 }
686 #[inline]
687 pub fn random_access(&self) -> u8 {
688 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u8) }
689 }
690 #[inline]
691 pub fn set_random_access(&mut self, val: u8) {
692 unsafe {
693 let val: u8 = ::std::mem::transmute(val);
694 self._bitfield_1.set(6usize, 1u8, val as u64)
695 }
696 }
697 #[inline]
698 pub fn discontinued(&self) -> u8 {
699 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u8) }
700 }
701 #[inline]
702 pub fn set_discontinued(&mut self, val: u8) {
703 unsafe {
704 let val: u8 = ::std::mem::transmute(val);
705 self._bitfield_1.set(7usize, 1u8, val as u64)
706 }
707 }
708 #[inline]
709 pub fn new_bitfield_1(
710 extension: u8,
711 private_data: u8,
712 splicing_point: u8,
713 OPCR: u8,
714 PCR: u8,
715 priority: u8,
716 random_access: u8,
717 discontinued: u8,
718 ) -> __BindgenBitfieldUnit<[u8; 1usize], u8> {
719 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize], u8> =
720 Default::default();
721 __bindgen_bitfield_unit.set(0usize, 1u8, {
722 let extension: u8 = unsafe { ::std::mem::transmute(extension) };
723 extension as u64
724 });
725 __bindgen_bitfield_unit.set(1usize, 1u8, {
726 let private_data: u8 = unsafe { ::std::mem::transmute(private_data) };
727 private_data as u64
728 });
729 __bindgen_bitfield_unit.set(2usize, 1u8, {
730 let splicing_point: u8 = unsafe { ::std::mem::transmute(splicing_point) };
731 splicing_point as u64
732 });
733 __bindgen_bitfield_unit.set(3usize, 1u8, {
734 let OPCR: u8 = unsafe { ::std::mem::transmute(OPCR) };
735 OPCR as u64
736 });
737 __bindgen_bitfield_unit.set(4usize, 1u8, {
738 let PCR: u8 = unsafe { ::std::mem::transmute(PCR) };
739 PCR as u64
740 });
741 __bindgen_bitfield_unit.set(5usize, 1u8, {
742 let priority: u8 = unsafe { ::std::mem::transmute(priority) };
743 priority as u64
744 });
745 __bindgen_bitfield_unit.set(6usize, 1u8, {
746 let random_access: u8 = unsafe { ::std::mem::transmute(random_access) };
747 random_access as u64
748 });
749 __bindgen_bitfield_unit.set(7usize, 1u8, {
750 let discontinued: u8 = unsafe { ::std::mem::transmute(discontinued) };
751 discontinued as u64
752 });
753 __bindgen_bitfield_unit
754 }
755}
756#[test]
757fn bindgen_test_layout_dvb_ts_packet_header() {
758 assert_eq!(
759 ::std::mem::size_of::<dvb_ts_packet_header>(),
760 6usize,
761 concat!("Size of: ", stringify!(dvb_ts_packet_header))
762 );
763 assert_eq!(
764 ::std::mem::align_of::<dvb_ts_packet_header>(),
765 1usize,
766 concat!("Alignment of ", stringify!(dvb_ts_packet_header))
767 );
768 assert_eq!(
769 unsafe { &(*(::std::ptr::null::<dvb_ts_packet_header>())).sync_byte as *const _ as usize },
770 0usize,
771 concat!(
772 "Offset of field: ",
773 stringify!(dvb_ts_packet_header),
774 "::",
775 stringify!(sync_byte)
776 )
777 );
778 assert_eq!(
779 unsafe {
780 &(*(::std::ptr::null::<dvb_ts_packet_header>())).adaptation_field_length as *const _
781 as usize
782 },
783 4usize,
784 concat!(
785 "Offset of field: ",
786 stringify!(dvb_ts_packet_header),
787 "::",
788 stringify!(adaptation_field_length)
789 )
790 );
791}
792impl dvb_ts_packet_header {
793 #[inline]
794 pub fn continuity_counter(&self) -> u8 {
795 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u8) }
796 }
797 #[inline]
798 pub fn set_continuity_counter(&mut self, val: u8) {
799 unsafe {
800 let val: u8 = ::std::mem::transmute(val);
801 self._bitfield_1.set(0usize, 4u8, val as u64)
802 }
803 }
804 #[inline]
805 pub fn adaptation_field_control(&self) -> u8 {
806 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 2u8) as u8) }
807 }
808 #[inline]
809 pub fn set_adaptation_field_control(&mut self, val: u8) {
810 unsafe {
811 let val: u8 = ::std::mem::transmute(val);
812 self._bitfield_1.set(4usize, 2u8, val as u64)
813 }
814 }
815 #[inline]
816 pub fn transport_scrambling_control(&self) -> u8 {
817 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 2u8) as u8) }
818 }
819 #[inline]
820 pub fn set_transport_scrambling_control(&mut self, val: u8) {
821 unsafe {
822 let val: u8 = ::std::mem::transmute(val);
823 self._bitfield_1.set(6usize, 2u8, val as u64)
824 }
825 }
826 #[inline]
827 pub fn new_bitfield_1(
828 continuity_counter: u8,
829 adaptation_field_control: u8,
830 transport_scrambling_control: u8,
831 ) -> __BindgenBitfieldUnit<[u8; 1usize], u8> {
832 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize], u8> =
833 Default::default();
834 __bindgen_bitfield_unit.set(0usize, 4u8, {
835 let continuity_counter: u8 = unsafe { ::std::mem::transmute(continuity_counter) };
836 continuity_counter as u64
837 });
838 __bindgen_bitfield_unit.set(4usize, 2u8, {
839 let adaptation_field_control: u8 =
840 unsafe { ::std::mem::transmute(adaptation_field_control) };
841 adaptation_field_control as u64
842 });
843 __bindgen_bitfield_unit.set(6usize, 2u8, {
844 let transport_scrambling_control: u8 =
845 unsafe { ::std::mem::transmute(transport_scrambling_control) };
846 transport_scrambling_control as u64
847 });
848 __bindgen_bitfield_unit
849 }
850}
851#[repr(C, packed)]
852#[derive(Copy, Clone)]
853pub struct dvb_table_header {
854 pub table_id: u8,
855 pub __bindgen_anon_1: dvb_table_header__bindgen_ty_1,
856 pub id: u16,
857 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize], u8>,
858 pub section_id: u8,
859 pub last_section: u8,
860}
861#[repr(C, packed)]
862#[derive(Copy, Clone)]
863pub union dvb_table_header__bindgen_ty_1 {
864 pub bitfield: u16,
865 pub __bindgen_anon_1: dvb_table_header__bindgen_ty_1__bindgen_ty_1,
866 _bindgen_union_align: [u8; 2usize],
867}
868#[repr(C, packed)]
869#[derive(Debug, Copy, Clone)]
870pub struct dvb_table_header__bindgen_ty_1__bindgen_ty_1 {
871 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize], u8>,
872}
873#[test]
874fn bindgen_test_layout_dvb_table_header__bindgen_ty_1__bindgen_ty_1() {
875 assert_eq!(
876 ::std::mem::size_of::<dvb_table_header__bindgen_ty_1__bindgen_ty_1>(),
877 2usize,
878 concat!(
879 "Size of: ",
880 stringify!(dvb_table_header__bindgen_ty_1__bindgen_ty_1)
881 )
882 );
883 assert_eq!(
884 ::std::mem::align_of::<dvb_table_header__bindgen_ty_1__bindgen_ty_1>(),
885 1usize,
886 concat!(
887 "Alignment of ",
888 stringify!(dvb_table_header__bindgen_ty_1__bindgen_ty_1)
889 )
890 );
891}
892impl dvb_table_header__bindgen_ty_1__bindgen_ty_1 {
893 #[inline]
894 pub fn section_length(&self) -> u16 {
895 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 12u8) as u16) }
896 }
897 #[inline]
898 pub fn set_section_length(&mut self, val: u16) {
899 unsafe {
900 let val: u16 = ::std::mem::transmute(val);
901 self._bitfield_1.set(0usize, 12u8, val as u64)
902 }
903 }
904 #[inline]
905 pub fn one(&self) -> u8 {
906 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 2u8) as u8) }
907 }
908 #[inline]
909 pub fn set_one(&mut self, val: u8) {
910 unsafe {
911 let val: u8 = ::std::mem::transmute(val);
912 self._bitfield_1.set(12usize, 2u8, val as u64)
913 }
914 }
915 #[inline]
916 pub fn zero(&self) -> u8 {
917 unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u8) }
918 }
919 #[inline]
920 pub fn set_zero(&mut self, val: u8) {
921 unsafe {
922 let val: u8 = ::std::mem::transmute(val);
923 self._bitfield_1.set(14usize, 1u8, val as u64)
924 }
925 }
926 #[inline]
927 pub fn syntax(&self) -> u8 {
928 unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u8) }
929 }
930 #[inline]
931 pub fn set_syntax(&mut self, val: u8) {
932 unsafe {
933 let val: u8 = ::std::mem::transmute(val);
934 self._bitfield_1.set(15usize, 1u8, val as u64)
935 }
936 }
937 #[inline]
938 pub fn new_bitfield_1(
939 section_length: u16,
940 one: u8,
941 zero: u8,
942 syntax: u8,
943 ) -> __BindgenBitfieldUnit<[u8; 2usize], u8> {
944 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize], u8> =
945 Default::default();
946 __bindgen_bitfield_unit.set(0usize, 12u8, {
947 let section_length: u16 = unsafe { ::std::mem::transmute(section_length) };
948 section_length as u64
949 });
950 __bindgen_bitfield_unit.set(12usize, 2u8, {
951 let one: u8 = unsafe { ::std::mem::transmute(one) };
952 one as u64
953 });
954 __bindgen_bitfield_unit.set(14usize, 1u8, {
955 let zero: u8 = unsafe { ::std::mem::transmute(zero) };
956 zero as u64
957 });
958 __bindgen_bitfield_unit.set(15usize, 1u8, {
959 let syntax: u8 = unsafe { ::std::mem::transmute(syntax) };
960 syntax as u64
961 });
962 __bindgen_bitfield_unit
963 }
964}
965#[test]
966fn bindgen_test_layout_dvb_table_header__bindgen_ty_1() {
967 assert_eq!(
968 ::std::mem::size_of::<dvb_table_header__bindgen_ty_1>(),
969 2usize,
970 concat!("Size of: ", stringify!(dvb_table_header__bindgen_ty_1))
971 );
972 assert_eq!(
973 ::std::mem::align_of::<dvb_table_header__bindgen_ty_1>(),
974 1usize,
975 concat!("Alignment of ", stringify!(dvb_table_header__bindgen_ty_1))
976 );
977 assert_eq!(
978 unsafe {
979 &(*(::std::ptr::null::<dvb_table_header__bindgen_ty_1>())).bitfield as *const _ as usize
980 },
981 0usize,
982 concat!(
983 "Offset of field: ",
984 stringify!(dvb_table_header__bindgen_ty_1),
985 "::",
986 stringify!(bitfield)
987 )
988 );
989}
990#[test]
991fn bindgen_test_layout_dvb_table_header() {
992 assert_eq!(
993 ::std::mem::size_of::<dvb_table_header>(),
994 8usize,
995 concat!("Size of: ", stringify!(dvb_table_header))
996 );
997 assert_eq!(
998 ::std::mem::align_of::<dvb_table_header>(),
999 1usize,
1000 concat!("Alignment of ", stringify!(dvb_table_header))
1001 );
1002 assert_eq!(
1003 unsafe { &(*(::std::ptr::null::<dvb_table_header>())).table_id as *const _ as usize },
1004 0usize,
1005 concat!(
1006 "Offset of field: ",
1007 stringify!(dvb_table_header),
1008 "::",
1009 stringify!(table_id)
1010 )
1011 );
1012 assert_eq!(
1013 unsafe { &(*(::std::ptr::null::<dvb_table_header>())).id as *const _ as usize },
1014 3usize,
1015 concat!(
1016 "Offset of field: ",
1017 stringify!(dvb_table_header),
1018 "::",
1019 stringify!(id)
1020 )
1021 );
1022 assert_eq!(
1023 unsafe { &(*(::std::ptr::null::<dvb_table_header>())).section_id as *const _ as usize },
1024 6usize,
1025 concat!(
1026 "Offset of field: ",
1027 stringify!(dvb_table_header),
1028 "::",
1029 stringify!(section_id)
1030 )
1031 );
1032 assert_eq!(
1033 unsafe { &(*(::std::ptr::null::<dvb_table_header>())).last_section as *const _ as usize },
1034 7usize,
1035 concat!(
1036 "Offset of field: ",
1037 stringify!(dvb_table_header),
1038 "::",
1039 stringify!(last_section)
1040 )
1041 );
1042}
1043impl dvb_table_header {
1044 #[inline]
1045 pub fn current_next(&self) -> u8 {
1046 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
1047 }
1048 #[inline]
1049 pub fn set_current_next(&mut self, val: u8) {
1050 unsafe {
1051 let val: u8 = ::std::mem::transmute(val);
1052 self._bitfield_1.set(0usize, 1u8, val as u64)
1053 }
1054 }
1055 #[inline]
1056 pub fn version(&self) -> u8 {
1057 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 5u8) as u8) }
1058 }
1059 #[inline]
1060 pub fn set_version(&mut self, val: u8) {
1061 unsafe {
1062 let val: u8 = ::std::mem::transmute(val);
1063 self._bitfield_1.set(1usize, 5u8, val as u64)
1064 }
1065 }
1066 #[inline]
1067 pub fn one2(&self) -> u8 {
1068 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 2u8) as u8) }
1069 }
1070 #[inline]
1071 pub fn set_one2(&mut self, val: u8) {
1072 unsafe {
1073 let val: u8 = ::std::mem::transmute(val);
1074 self._bitfield_1.set(6usize, 2u8, val as u64)
1075 }
1076 }
1077 #[inline]
1078 pub fn new_bitfield_1(
1079 current_next: u8,
1080 version: u8,
1081 one2: u8,
1082 ) -> __BindgenBitfieldUnit<[u8; 1usize], u8> {
1083 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize], u8> =
1084 Default::default();
1085 __bindgen_bitfield_unit.set(0usize, 1u8, {
1086 let current_next: u8 = unsafe { ::std::mem::transmute(current_next) };
1087 current_next as u64
1088 });
1089 __bindgen_bitfield_unit.set(1usize, 5u8, {
1090 let version: u8 = unsafe { ::std::mem::transmute(version) };
1091 version as u64
1092 });
1093 __bindgen_bitfield_unit.set(6usize, 2u8, {
1094 let one2: u8 = unsafe { ::std::mem::transmute(one2) };
1095 one2 as u64
1096 });
1097 __bindgen_bitfield_unit
1098 }
1099}
1100extern "C" {
1101 pub fn dvb_table_header_init(header: *mut dvb_table_header);
1102}
1103extern "C" {
1104 pub fn dvb_table_header_print(parms: *mut dvb_v5_fe_parms, header: *const dvb_table_header);
1105}
1106#[repr(C, packed)]
1107#[derive(Copy, Clone)]
1108pub struct atsc_table_eit_event {
1109 pub __bindgen_anon_1: atsc_table_eit_event__bindgen_ty_1,
1110 pub start_time: u32,
1111 pub __bindgen_anon_2: atsc_table_eit_event__bindgen_ty_2,
1112 pub descriptor: *mut dvb_desc,
1113 pub next: *mut atsc_table_eit_event,
1114 pub start: tm,
1115 pub source_id: u16,
1116}
1117#[repr(C, packed)]
1118#[derive(Copy, Clone)]
1119pub union atsc_table_eit_event__bindgen_ty_1 {
1120 pub bitfield: u16,
1121 pub __bindgen_anon_1: atsc_table_eit_event__bindgen_ty_1__bindgen_ty_1,
1122 _bindgen_union_align: [u8; 2usize],
1123}
1124#[repr(C, packed)]
1125#[derive(Debug, Copy, Clone)]
1126pub struct atsc_table_eit_event__bindgen_ty_1__bindgen_ty_1 {
1127 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize], u8>,
1128}
1129#[test]
1130fn bindgen_test_layout_atsc_table_eit_event__bindgen_ty_1__bindgen_ty_1() {
1131 assert_eq!(
1132 ::std::mem::size_of::<atsc_table_eit_event__bindgen_ty_1__bindgen_ty_1>(),
1133 2usize,
1134 concat!(
1135 "Size of: ",
1136 stringify!(atsc_table_eit_event__bindgen_ty_1__bindgen_ty_1)
1137 )
1138 );
1139 assert_eq!(
1140 ::std::mem::align_of::<atsc_table_eit_event__bindgen_ty_1__bindgen_ty_1>(),
1141 1usize,
1142 concat!(
1143 "Alignment of ",
1144 stringify!(atsc_table_eit_event__bindgen_ty_1__bindgen_ty_1)
1145 )
1146 );
1147}
1148impl atsc_table_eit_event__bindgen_ty_1__bindgen_ty_1 {
1149 #[inline]
1150 pub fn event_id(&self) -> u16 {
1151 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 14u8) as u16) }
1152 }
1153 #[inline]
1154 pub fn set_event_id(&mut self, val: u16) {
1155 unsafe {
1156 let val: u16 = ::std::mem::transmute(val);
1157 self._bitfield_1.set(0usize, 14u8, val as u64)
1158 }
1159 }
1160 #[inline]
1161 pub fn one(&self) -> u16 {
1162 unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 2u8) as u16) }
1163 }
1164 #[inline]
1165 pub fn set_one(&mut self, val: u16) {
1166 unsafe {
1167 let val: u16 = ::std::mem::transmute(val);
1168 self._bitfield_1.set(14usize, 2u8, val as u64)
1169 }
1170 }
1171 #[inline]
1172 pub fn new_bitfield_1(event_id: u16, one: u16) -> __BindgenBitfieldUnit<[u8; 2usize], u8> {
1173 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize], u8> =
1174 Default::default();
1175 __bindgen_bitfield_unit.set(0usize, 14u8, {
1176 let event_id: u16 = unsafe { ::std::mem::transmute(event_id) };
1177 event_id as u64
1178 });
1179 __bindgen_bitfield_unit.set(14usize, 2u8, {
1180 let one: u16 = unsafe { ::std::mem::transmute(one) };
1181 one as u64
1182 });
1183 __bindgen_bitfield_unit
1184 }
1185}
1186#[test]
1187fn bindgen_test_layout_atsc_table_eit_event__bindgen_ty_1() {
1188 assert_eq!(
1189 ::std::mem::size_of::<atsc_table_eit_event__bindgen_ty_1>(),
1190 2usize,
1191 concat!("Size of: ", stringify!(atsc_table_eit_event__bindgen_ty_1))
1192 );
1193 assert_eq!(
1194 ::std::mem::align_of::<atsc_table_eit_event__bindgen_ty_1>(),
1195 1usize,
1196 concat!(
1197 "Alignment of ",
1198 stringify!(atsc_table_eit_event__bindgen_ty_1)
1199 )
1200 );
1201 assert_eq!(
1202 unsafe {
1203 &(*(::std::ptr::null::<atsc_table_eit_event__bindgen_ty_1>())).bitfield as *const _
1204 as usize
1205 },
1206 0usize,
1207 concat!(
1208 "Offset of field: ",
1209 stringify!(atsc_table_eit_event__bindgen_ty_1),
1210 "::",
1211 stringify!(bitfield)
1212 )
1213 );
1214}
1215#[repr(C, packed)]
1216#[derive(Copy, Clone)]
1217pub union atsc_table_eit_event__bindgen_ty_2 {
1218 pub bitfield2: u32,
1219 pub __bindgen_anon_1: atsc_table_eit_event__bindgen_ty_2__bindgen_ty_1,
1220 _bindgen_union_align: [u8; 5usize],
1221}
1222#[repr(C, packed)]
1223#[derive(Debug, Copy, Clone)]
1224pub struct atsc_table_eit_event__bindgen_ty_2__bindgen_ty_1 {
1225 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 5usize], u8>,
1226}
1227#[test]
1228fn bindgen_test_layout_atsc_table_eit_event__bindgen_ty_2__bindgen_ty_1() {
1229 assert_eq!(
1230 ::std::mem::size_of::<atsc_table_eit_event__bindgen_ty_2__bindgen_ty_1>(),
1231 5usize,
1232 concat!(
1233 "Size of: ",
1234 stringify!(atsc_table_eit_event__bindgen_ty_2__bindgen_ty_1)
1235 )
1236 );
1237 assert_eq!(
1238 ::std::mem::align_of::<atsc_table_eit_event__bindgen_ty_2__bindgen_ty_1>(),
1239 1usize,
1240 concat!(
1241 "Alignment of ",
1242 stringify!(atsc_table_eit_event__bindgen_ty_2__bindgen_ty_1)
1243 )
1244 );
1245}
1246impl atsc_table_eit_event__bindgen_ty_2__bindgen_ty_1 {
1247 #[inline]
1248 pub fn title_length(&self) -> u32 {
1249 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 8u8) as u32) }
1250 }
1251 #[inline]
1252 pub fn set_title_length(&mut self, val: u32) {
1253 unsafe {
1254 let val: u32 = ::std::mem::transmute(val);
1255 self._bitfield_1.set(0usize, 8u8, val as u64)
1256 }
1257 }
1258 #[inline]
1259 pub fn duration(&self) -> u32 {
1260 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 20u8) as u32) }
1261 }
1262 #[inline]
1263 pub fn set_duration(&mut self, val: u32) {
1264 unsafe {
1265 let val: u32 = ::std::mem::transmute(val);
1266 self._bitfield_1.set(8usize, 20u8, val as u64)
1267 }
1268 }
1269 #[inline]
1270 pub fn etm(&self) -> u32 {
1271 unsafe { ::std::mem::transmute(self._bitfield_1.get(28usize, 2u8) as u32) }
1272 }
1273 #[inline]
1274 pub fn set_etm(&mut self, val: u32) {
1275 unsafe {
1276 let val: u32 = ::std::mem::transmute(val);
1277 self._bitfield_1.set(28usize, 2u8, val as u64)
1278 }
1279 }
1280 #[inline]
1281 pub fn one2(&self) -> u32 {
1282 unsafe { ::std::mem::transmute(self._bitfield_1.get(30usize, 2u8) as u32) }
1283 }
1284 #[inline]
1285 pub fn set_one2(&mut self, val: u32) {
1286 unsafe {
1287 let val: u32 = ::std::mem::transmute(val);
1288 self._bitfield_1.set(30usize, 2u8, val as u64)
1289 }
1290 }
1291 #[inline]
1292 pub fn new_bitfield_1(
1293 title_length: u32,
1294 duration: u32,
1295 etm: u32,
1296 one2: u32,
1297 ) -> __BindgenBitfieldUnit<[u8; 5usize], u8> {
1298 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 5usize], u8> =
1299 Default::default();
1300 __bindgen_bitfield_unit.set(0usize, 8u8, {
1301 let title_length: u32 = unsafe { ::std::mem::transmute(title_length) };
1302 title_length as u64
1303 });
1304 __bindgen_bitfield_unit.set(8usize, 20u8, {
1305 let duration: u32 = unsafe { ::std::mem::transmute(duration) };
1306 duration as u64
1307 });
1308 __bindgen_bitfield_unit.set(28usize, 2u8, {
1309 let etm: u32 = unsafe { ::std::mem::transmute(etm) };
1310 etm as u64
1311 });
1312 __bindgen_bitfield_unit.set(30usize, 2u8, {
1313 let one2: u32 = unsafe { ::std::mem::transmute(one2) };
1314 one2 as u64
1315 });
1316 __bindgen_bitfield_unit
1317 }
1318}
1319#[test]
1320fn bindgen_test_layout_atsc_table_eit_event__bindgen_ty_2() {
1321 assert_eq!(
1322 ::std::mem::size_of::<atsc_table_eit_event__bindgen_ty_2>(),
1323 5usize,
1324 concat!("Size of: ", stringify!(atsc_table_eit_event__bindgen_ty_2))
1325 );
1326 assert_eq!(
1327 ::std::mem::align_of::<atsc_table_eit_event__bindgen_ty_2>(),
1328 1usize,
1329 concat!(
1330 "Alignment of ",
1331 stringify!(atsc_table_eit_event__bindgen_ty_2)
1332 )
1333 );
1334 assert_eq!(
1335 unsafe {
1336 &(*(::std::ptr::null::<atsc_table_eit_event__bindgen_ty_2>())).bitfield2 as *const _
1337 as usize
1338 },
1339 0usize,
1340 concat!(
1341 "Offset of field: ",
1342 stringify!(atsc_table_eit_event__bindgen_ty_2),
1343 "::",
1344 stringify!(bitfield2)
1345 )
1346 );
1347}
1348#[test]
1349fn bindgen_test_layout_atsc_table_eit_event() {
1350 assert_eq!(
1351 ::std::mem::size_of::<atsc_table_eit_event>(),
1352 85usize,
1353 concat!("Size of: ", stringify!(atsc_table_eit_event))
1354 );
1355 assert_eq!(
1356 ::std::mem::align_of::<atsc_table_eit_event>(),
1357 1usize,
1358 concat!("Alignment of ", stringify!(atsc_table_eit_event))
1359 );
1360 assert_eq!(
1361 unsafe { &(*(::std::ptr::null::<atsc_table_eit_event>())).start_time as *const _ as usize },
1362 2usize,
1363 concat!(
1364 "Offset of field: ",
1365 stringify!(atsc_table_eit_event),
1366 "::",
1367 stringify!(start_time)
1368 )
1369 );
1370 assert_eq!(
1371 unsafe { &(*(::std::ptr::null::<atsc_table_eit_event>())).descriptor as *const _ as usize },
1372 11usize,
1373 concat!(
1374 "Offset of field: ",
1375 stringify!(atsc_table_eit_event),
1376 "::",
1377 stringify!(descriptor)
1378 )
1379 );
1380 assert_eq!(
1381 unsafe { &(*(::std::ptr::null::<atsc_table_eit_event>())).next as *const _ as usize },
1382 19usize,
1383 concat!(
1384 "Offset of field: ",
1385 stringify!(atsc_table_eit_event),
1386 "::",
1387 stringify!(next)
1388 )
1389 );
1390 assert_eq!(
1391 unsafe { &(*(::std::ptr::null::<atsc_table_eit_event>())).start as *const _ as usize },
1392 27usize,
1393 concat!(
1394 "Offset of field: ",
1395 stringify!(atsc_table_eit_event),
1396 "::",
1397 stringify!(start)
1398 )
1399 );
1400 assert_eq!(
1401 unsafe { &(*(::std::ptr::null::<atsc_table_eit_event>())).source_id as *const _ as usize },
1402 83usize,
1403 concat!(
1404 "Offset of field: ",
1405 stringify!(atsc_table_eit_event),
1406 "::",
1407 stringify!(source_id)
1408 )
1409 );
1410}
1411#[repr(C, packed)]
1412#[derive(Copy, Clone)]
1413pub union atsc_table_eit_desc_length {
1414 pub bitfield: u16,
1415 pub __bindgen_anon_1: atsc_table_eit_desc_length__bindgen_ty_1,
1416 _bindgen_union_align: [u8; 2usize],
1417}
1418#[repr(C, packed)]
1419#[derive(Debug, Copy, Clone)]
1420pub struct atsc_table_eit_desc_length__bindgen_ty_1 {
1421 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize], u8>,
1422}
1423#[test]
1424fn bindgen_test_layout_atsc_table_eit_desc_length__bindgen_ty_1() {
1425 assert_eq!(
1426 ::std::mem::size_of::<atsc_table_eit_desc_length__bindgen_ty_1>(),
1427 2usize,
1428 concat!(
1429 "Size of: ",
1430 stringify!(atsc_table_eit_desc_length__bindgen_ty_1)
1431 )
1432 );
1433 assert_eq!(
1434 ::std::mem::align_of::<atsc_table_eit_desc_length__bindgen_ty_1>(),
1435 1usize,
1436 concat!(
1437 "Alignment of ",
1438 stringify!(atsc_table_eit_desc_length__bindgen_ty_1)
1439 )
1440 );
1441}
1442impl atsc_table_eit_desc_length__bindgen_ty_1 {
1443 #[inline]
1444 pub fn desc_length(&self) -> u16 {
1445 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 12u8) as u16) }
1446 }
1447 #[inline]
1448 pub fn set_desc_length(&mut self, val: u16) {
1449 unsafe {
1450 let val: u16 = ::std::mem::transmute(val);
1451 self._bitfield_1.set(0usize, 12u8, val as u64)
1452 }
1453 }
1454 #[inline]
1455 pub fn reserved(&self) -> u16 {
1456 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 4u8) as u16) }
1457 }
1458 #[inline]
1459 pub fn set_reserved(&mut self, val: u16) {
1460 unsafe {
1461 let val: u16 = ::std::mem::transmute(val);
1462 self._bitfield_1.set(12usize, 4u8, val as u64)
1463 }
1464 }
1465 #[inline]
1466 pub fn new_bitfield_1(
1467 desc_length: u16,
1468 reserved: u16,
1469 ) -> __BindgenBitfieldUnit<[u8; 2usize], u8> {
1470 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize], u8> =
1471 Default::default();
1472 __bindgen_bitfield_unit.set(0usize, 12u8, {
1473 let desc_length: u16 = unsafe { ::std::mem::transmute(desc_length) };
1474 desc_length as u64
1475 });
1476 __bindgen_bitfield_unit.set(12usize, 4u8, {
1477 let reserved: u16 = unsafe { ::std::mem::transmute(reserved) };
1478 reserved as u64
1479 });
1480 __bindgen_bitfield_unit
1481 }
1482}
1483#[test]
1484fn bindgen_test_layout_atsc_table_eit_desc_length() {
1485 assert_eq!(
1486 ::std::mem::size_of::<atsc_table_eit_desc_length>(),
1487 2usize,
1488 concat!("Size of: ", stringify!(atsc_table_eit_desc_length))
1489 );
1490 assert_eq!(
1491 ::std::mem::align_of::<atsc_table_eit_desc_length>(),
1492 1usize,
1493 concat!("Alignment of ", stringify!(atsc_table_eit_desc_length))
1494 );
1495 assert_eq!(
1496 unsafe {
1497 &(*(::std::ptr::null::<atsc_table_eit_desc_length>())).bitfield as *const _ as usize
1498 },
1499 0usize,
1500 concat!(
1501 "Offset of field: ",
1502 stringify!(atsc_table_eit_desc_length),
1503 "::",
1504 stringify!(bitfield)
1505 )
1506 );
1507}
1508#[repr(C, packed)]
1509#[derive(Copy, Clone)]
1510pub struct atsc_table_eit {
1511 pub header: dvb_table_header,
1512 pub protocol_version: u8,
1513 pub events: u8,
1514 pub event: *mut atsc_table_eit_event,
1515}
1516#[test]
1517fn bindgen_test_layout_atsc_table_eit() {
1518 assert_eq!(
1519 ::std::mem::size_of::<atsc_table_eit>(),
1520 18usize,
1521 concat!("Size of: ", stringify!(atsc_table_eit))
1522 );
1523 assert_eq!(
1524 ::std::mem::align_of::<atsc_table_eit>(),
1525 1usize,
1526 concat!("Alignment of ", stringify!(atsc_table_eit))
1527 );
1528 assert_eq!(
1529 unsafe { &(*(::std::ptr::null::<atsc_table_eit>())).header as *const _ as usize },
1530 0usize,
1531 concat!(
1532 "Offset of field: ",
1533 stringify!(atsc_table_eit),
1534 "::",
1535 stringify!(header)
1536 )
1537 );
1538 assert_eq!(
1539 unsafe { &(*(::std::ptr::null::<atsc_table_eit>())).protocol_version as *const _ as usize },
1540 8usize,
1541 concat!(
1542 "Offset of field: ",
1543 stringify!(atsc_table_eit),
1544 "::",
1545 stringify!(protocol_version)
1546 )
1547 );
1548 assert_eq!(
1549 unsafe { &(*(::std::ptr::null::<atsc_table_eit>())).events as *const _ as usize },
1550 9usize,
1551 concat!(
1552 "Offset of field: ",
1553 stringify!(atsc_table_eit),
1554 "::",
1555 stringify!(events)
1556 )
1557 );
1558 assert_eq!(
1559 unsafe { &(*(::std::ptr::null::<atsc_table_eit>())).event as *const _ as usize },
1560 10usize,
1561 concat!(
1562 "Offset of field: ",
1563 stringify!(atsc_table_eit),
1564 "::",
1565 stringify!(event)
1566 )
1567 );
1568}
1569extern "C" {
1570 pub fn atsc_table_eit_init(
1571 parms: *mut dvb_v5_fe_parms,
1572 buf: *const u8,
1573 buflen: ssize_t,
1574 table: *mut *mut atsc_table_eit,
1575 ) -> ssize_t;
1576}
1577extern "C" {
1578 pub fn atsc_table_eit_free(table: *mut atsc_table_eit);
1579}
1580extern "C" {
1581 pub fn atsc_table_eit_print(parms: *mut dvb_v5_fe_parms, table: *mut atsc_table_eit);
1582}
1583extern "C" {
1584 pub fn atsc_time(start_time: u32, tm: *mut tm);
1585}
1586#[repr(C, packed)]
1587#[derive(Copy, Clone)]
1588pub struct dvb_table_cat {
1589 pub header: dvb_table_header,
1590 pub descriptor: *mut dvb_desc,
1591}
1592#[test]
1593fn bindgen_test_layout_dvb_table_cat() {
1594 assert_eq!(
1595 ::std::mem::size_of::<dvb_table_cat>(),
1596 16usize,
1597 concat!("Size of: ", stringify!(dvb_table_cat))
1598 );
1599 assert_eq!(
1600 ::std::mem::align_of::<dvb_table_cat>(),
1601 1usize,
1602 concat!("Alignment of ", stringify!(dvb_table_cat))
1603 );
1604 assert_eq!(
1605 unsafe { &(*(::std::ptr::null::<dvb_table_cat>())).header as *const _ as usize },
1606 0usize,
1607 concat!(
1608 "Offset of field: ",
1609 stringify!(dvb_table_cat),
1610 "::",
1611 stringify!(header)
1612 )
1613 );
1614 assert_eq!(
1615 unsafe { &(*(::std::ptr::null::<dvb_table_cat>())).descriptor as *const _ as usize },
1616 8usize,
1617 concat!(
1618 "Offset of field: ",
1619 stringify!(dvb_table_cat),
1620 "::",
1621 stringify!(descriptor)
1622 )
1623 );
1624}
1625extern "C" {
1626 pub fn dvb_table_cat_init(
1627 parms: *mut dvb_v5_fe_parms,
1628 buf: *const u8,
1629 buflen: ssize_t,
1630 table: *mut *mut dvb_table_cat,
1631 ) -> ssize_t;
1632}
1633extern "C" {
1634 pub fn dvb_table_cat_free(table: *mut dvb_table_cat);
1635}
1636extern "C" {
1637 pub fn dvb_table_cat_print(parms: *mut dvb_v5_fe_parms, table: *mut dvb_table_cat);
1638}
1639#[repr(u32)]
1640#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
1641pub enum dvb_country_t {
1642 COUNTRY_UNKNOWN = 0,
1643 AD = 1,
1644 AE = 2,
1645 AF = 3,
1646 AG = 4,
1647 AI = 5,
1648 AL = 6,
1649 AM = 7,
1650 AO = 8,
1651 AQ = 9,
1652 AR = 10,
1653 AS = 11,
1654 AT = 12,
1655 AU = 13,
1656 AW = 14,
1657 AX = 15,
1658 AZ = 16,
1659 BA = 17,
1660 BB = 18,
1661 BD = 19,
1662 BE = 20,
1663 BF = 21,
1664 BG = 22,
1665 BH = 23,
1666 BI = 24,
1667 BJ = 25,
1668 BL = 26,
1669 BM = 27,
1670 BN = 28,
1671 BO = 29,
1672 BQ = 30,
1673 BR = 31,
1674 BS = 32,
1675 BT = 33,
1676 BV = 34,
1677 BW = 35,
1678 BY = 36,
1679 BZ = 37,
1680 CA = 38,
1681 CC = 39,
1682 CD = 40,
1683 CF = 41,
1684 CG = 42,
1685 CH = 43,
1686 CI = 44,
1687 CK = 45,
1688 CL = 46,
1689 CM = 47,
1690 CN = 48,
1691 CO = 49,
1692 CR = 50,
1693 CU = 51,
1694 CV = 52,
1695 CW = 53,
1696 CX = 54,
1697 CY = 55,
1698 CZ = 56,
1699 DE = 57,
1700 DJ = 58,
1701 DK = 59,
1702 DM = 60,
1703 DO = 61,
1704 DZ = 62,
1705 EC = 63,
1706 EE = 64,
1707 EG = 65,
1708 EH = 66,
1709 ER = 67,
1710 ES = 68,
1711 ET = 69,
1712 FI = 70,
1713 FJ = 71,
1714 FK = 72,
1715 FM = 73,
1716 FO = 74,
1717 FR = 75,
1718 GA = 76,
1719 GB = 77,
1720 GD = 78,
1721 GE = 79,
1722 GF = 80,
1723 GG = 81,
1724 GH = 82,
1725 GI = 83,
1726 GL = 84,
1727 GM = 85,
1728 GN = 86,
1729 GP = 87,
1730 GQ = 88,
1731 GR = 89,
1732 GS = 90,
1733 GT = 91,
1734 GU = 92,
1735 GW = 93,
1736 GY = 94,
1737 HK = 95,
1738 HM = 96,
1739 HN = 97,
1740 HR = 98,
1741 HT = 99,
1742 HU = 100,
1743 ID = 101,
1744 IE = 102,
1745 IL = 103,
1746 IM = 104,
1747 IN = 105,
1748 IO = 106,
1749 IQ = 107,
1750 IR = 108,
1751 IS = 109,
1752 IT = 110,
1753 JE = 111,
1754 JM = 112,
1755 JO = 113,
1756 JP = 114,
1757 KE = 115,
1758 KG = 116,
1759 KH = 117,
1760 KI = 118,
1761 KM = 119,
1762 KN = 120,
1763 KP = 121,
1764 KR = 122,
1765 KW = 123,
1766 KY = 124,
1767 KZ = 125,
1768 LA = 126,
1769 LB = 127,
1770 LC = 128,
1771 LI = 129,
1772 LK = 130,
1773 LR = 131,
1774 LS = 132,
1775 LT = 133,
1776 LU = 134,
1777 LV = 135,
1778 LY = 136,
1779 MA = 137,
1780 MC = 138,
1781 MD = 139,
1782 ME = 140,
1783 MF = 141,
1784 MG = 142,
1785 MH = 143,
1786 MK = 144,
1787 ML = 145,
1788 MM = 146,
1789 MN = 147,
1790 MO = 148,
1791 MP = 149,
1792 MQ = 150,
1793 MR = 151,
1794 MS = 152,
1795 MT = 153,
1796 MU = 154,
1797 MV = 155,
1798 MW = 156,
1799 MX = 157,
1800 MY = 158,
1801 MZ = 159,
1802 NA = 160,
1803 NC = 161,
1804 NE = 162,
1805 NF = 163,
1806 NG = 164,
1807 NI = 165,
1808 NL = 166,
1809 NO = 167,
1810 NP = 168,
1811 NR = 169,
1812 NU = 170,
1813 NZ = 171,
1814 OM = 172,
1815 PA = 173,
1816 PE = 174,
1817 PF = 175,
1818 PG = 176,
1819 PH = 177,
1820 PK = 178,
1821 PL = 179,
1822 PM = 180,
1823 PN = 181,
1824 PR = 182,
1825 PS = 183,
1826 PT = 184,
1827 PW = 185,
1828 PY = 186,
1829 QA = 187,
1830 RE = 188,
1831 RO = 189,
1832 RS = 190,
1833 RU = 191,
1834 RW = 192,
1835 SA = 193,
1836 SB = 194,
1837 SC = 195,
1838 SD = 196,
1839 SE = 197,
1840 SG = 198,
1841 SH = 199,
1842 SI = 200,
1843 SJ = 201,
1844 SK = 202,
1845 SL = 203,
1846 SM = 204,
1847 SN = 205,
1848 SO = 206,
1849 SR = 207,
1850 SS = 208,
1851 ST = 209,
1852 SV = 210,
1853 SX = 211,
1854 SY = 212,
1855 SZ = 213,
1856 TC = 214,
1857 TD = 215,
1858 TF = 216,
1859 TG = 217,
1860 TH = 218,
1861 TJ = 219,
1862 TK = 220,
1863 TL = 221,
1864 TM = 222,
1865 TN = 223,
1866 TO = 224,
1867 TR = 225,
1868 TT = 226,
1869 TV = 227,
1870 TW = 228,
1871 TZ = 229,
1872 UA = 230,
1873 UG = 231,
1874 UM = 232,
1875 US = 233,
1876 UY = 234,
1877 UZ = 235,
1878 VA = 236,
1879 VC = 237,
1880 VE = 238,
1881 VG = 239,
1882 VI = 240,
1883 VN = 241,
1884 VU = 242,
1885 WF = 243,
1886 WS = 244,
1887 YE = 245,
1888 YT = 246,
1889 ZA = 247,
1890 ZM = 248,
1891 ZW = 249,
1892}
1893extern "C" {
1894 pub fn dvb_country_a2_to_id(name: *const ::std::os::raw::c_char) -> dvb_country_t;
1895}
1896extern "C" {
1897 pub fn dvb_country_a3_to_id(name: *const ::std::os::raw::c_char) -> dvb_country_t;
1898}
1899extern "C" {
1900 pub fn dvb_country_to_2letters(id: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char;
1901}
1902extern "C" {
1903 pub fn dvb_country_to_3letters(id: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char;
1904}
1905extern "C" {
1906 pub fn dvb_country_to_name(id: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char;
1907}
1908extern "C" {
1909 pub fn dvb_guess_user_country() -> dvb_country_t;
1910}
1911extern "C" {
1912 pub fn dvb_crc32(data: *mut u8, datalen: size_t, crc: u32) -> u32;
1913}
1914pub type dvb_table_init_func = ::std::option::Option<
1915 unsafe extern "C" fn(
1916 parms: *mut dvb_v5_fe_parms,
1917 buf: *const u8,
1918 buflen: ssize_t,
1919 table: *mut *mut ::std::os::raw::c_void,
1920 ),
1921>;
1922extern "C" {
1923 pub static dvb_table_initializers: [dvb_table_init_func; 256usize];
1924}
1925#[repr(C, packed)]
1926#[derive(Debug)]
1927pub struct dvb_desc {
1928 pub type_: u8,
1929 pub length: u8,
1930 pub next: *mut dvb_desc,
1931 pub data: __IncompleteArrayField<u8>,
1932}
1933#[test]
1934fn bindgen_test_layout_dvb_desc() {
1935 assert_eq!(
1936 ::std::mem::size_of::<dvb_desc>(),
1937 10usize,
1938 concat!("Size of: ", stringify!(dvb_desc))
1939 );
1940 assert_eq!(
1941 ::std::mem::align_of::<dvb_desc>(),
1942 1usize,
1943 concat!("Alignment of ", stringify!(dvb_desc))
1944 );
1945 assert_eq!(
1946 unsafe { &(*(::std::ptr::null::<dvb_desc>())).type_ as *const _ as usize },
1947 0usize,
1948 concat!(
1949 "Offset of field: ",
1950 stringify!(dvb_desc),
1951 "::",
1952 stringify!(type_)
1953 )
1954 );
1955 assert_eq!(
1956 unsafe { &(*(::std::ptr::null::<dvb_desc>())).length as *const _ as usize },
1957 1usize,
1958 concat!(
1959 "Offset of field: ",
1960 stringify!(dvb_desc),
1961 "::",
1962 stringify!(length)
1963 )
1964 );
1965 assert_eq!(
1966 unsafe { &(*(::std::ptr::null::<dvb_desc>())).next as *const _ as usize },
1967 2usize,
1968 concat!(
1969 "Offset of field: ",
1970 stringify!(dvb_desc),
1971 "::",
1972 stringify!(next)
1973 )
1974 );
1975 assert_eq!(
1976 unsafe { &(*(::std::ptr::null::<dvb_desc>())).data as *const _ as usize },
1977 10usize,
1978 concat!(
1979 "Offset of field: ",
1980 stringify!(dvb_desc),
1981 "::",
1982 stringify!(data)
1983 )
1984 );
1985}
1986extern "C" {
1987 pub fn dvb_bcd(bcd: u32) -> u32;
1988}
1989extern "C" {
1990 pub fn dvb_hexdump(
1991 parms: *mut dvb_v5_fe_parms,
1992 prefix: *const ::std::os::raw::c_char,
1993 buf: *const ::std::os::raw::c_uchar,
1994 len: ::std::os::raw::c_int,
1995 );
1996}
1997extern "C" {
1998 pub fn dvb_desc_parse(
1999 parms: *mut dvb_v5_fe_parms,
2000 buf: *const u8,
2001 buflen: u16,
2002 head_desc: *mut *mut dvb_desc,
2003 ) -> ::std::os::raw::c_int;
2004}
2005extern "C" {
2006 pub fn dvb_desc_free(list: *mut *mut dvb_desc);
2007}
2008extern "C" {
2009 pub fn dvb_desc_print(parms: *mut dvb_v5_fe_parms, desc: *mut dvb_desc);
2010}
2011pub type dvb_desc_init_func = ::std::option::Option<
2012 unsafe extern "C" fn(
2013 parms: *mut dvb_v5_fe_parms,
2014 buf: *const u8,
2015 desc: *mut dvb_desc,
2016 ) -> ::std::os::raw::c_int,
2017>;
2018pub type dvb_desc_print_func =
2019 ::std::option::Option<unsafe extern "C" fn(parms: *mut dvb_v5_fe_parms, desc: *const dvb_desc)>;
2020pub type dvb_desc_free_func = ::std::option::Option<unsafe extern "C" fn(desc: *mut dvb_desc)>;
2021#[repr(C)]
2022#[derive(Debug, Copy, Clone)]
2023pub struct dvb_descriptor {
2024 pub name: *const ::std::os::raw::c_char,
2025 pub init: dvb_desc_init_func,
2026 pub print: dvb_desc_print_func,
2027 pub free: dvb_desc_free_func,
2028 pub size: ssize_t,
2029}
2030#[test]
2031fn bindgen_test_layout_dvb_descriptor() {
2032 assert_eq!(
2033 ::std::mem::size_of::<dvb_descriptor>(),
2034 40usize,
2035 concat!("Size of: ", stringify!(dvb_descriptor))
2036 );
2037 assert_eq!(
2038 ::std::mem::align_of::<dvb_descriptor>(),
2039 8usize,
2040 concat!("Alignment of ", stringify!(dvb_descriptor))
2041 );
2042 assert_eq!(
2043 unsafe { &(*(::std::ptr::null::<dvb_descriptor>())).name as *const _ as usize },
2044 0usize,
2045 concat!(
2046 "Offset of field: ",
2047 stringify!(dvb_descriptor),
2048 "::",
2049 stringify!(name)
2050 )
2051 );
2052 assert_eq!(
2053 unsafe { &(*(::std::ptr::null::<dvb_descriptor>())).init as *const _ as usize },
2054 8usize,
2055 concat!(
2056 "Offset of field: ",
2057 stringify!(dvb_descriptor),
2058 "::",
2059 stringify!(init)
2060 )
2061 );
2062 assert_eq!(
2063 unsafe { &(*(::std::ptr::null::<dvb_descriptor>())).print as *const _ as usize },
2064 16usize,
2065 concat!(
2066 "Offset of field: ",
2067 stringify!(dvb_descriptor),
2068 "::",
2069 stringify!(print)
2070 )
2071 );
2072 assert_eq!(
2073 unsafe { &(*(::std::ptr::null::<dvb_descriptor>())).free as *const _ as usize },
2074 24usize,
2075 concat!(
2076 "Offset of field: ",
2077 stringify!(dvb_descriptor),
2078 "::",
2079 stringify!(free)
2080 )
2081 );
2082 assert_eq!(
2083 unsafe { &(*(::std::ptr::null::<dvb_descriptor>())).size as *const _ as usize },
2084 32usize,
2085 concat!(
2086 "Offset of field: ",
2087 stringify!(dvb_descriptor),
2088 "::",
2089 stringify!(size)
2090 )
2091 );
2092}
2093extern "C" {
2094 pub static mut dvb_descriptors: [dvb_descriptor; 0usize];
2095}
2096impl descriptors {
2097 pub const atsc_extended_channel_descriptor: descriptors = descriptors::extended_channel_name;
2098}
2099impl descriptors {
2100 pub const atsc_service_location_descriptor: descriptors = descriptors::service_location;
2101}
2102impl descriptors {
2103 pub const atsc_component_name_descriptor: descriptors = descriptors::component_name_descriptor;
2104}
2105#[repr(u32)]
2106#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
2107pub enum descriptors {
2108 video_stream_descriptor = 2,
2109 audio_stream_descriptor = 3,
2110 hierarchy_descriptor = 4,
2111 registration_descriptor = 5,
2112 ds_alignment_descriptor = 6,
2113 target_background_grid_descriptor = 7,
2114 video_window_descriptor = 8,
2115 conditional_access_descriptor = 9,
2116 iso639_language_descriptor = 10,
2117 system_clock_descriptor = 11,
2118 multiplex_buffer_utilization_descriptor = 12,
2119 copyright_descriptor = 13,
2120 maximum_bitrate_descriptor = 14,
2121 private_data_indicator_descriptor = 15,
2122 smoothing_buffer_descriptor = 16,
2123 std_descriptor = 17,
2124 ibp_descriptor = 18,
2125 mpeg4_video_descriptor = 27,
2126 mpeg4_audio_descriptor = 28,
2127 iod_descriptor = 29,
2128 sl_descriptor = 30,
2129 fmc_descriptor = 31,
2130 external_es_id_descriptor = 32,
2131 muxcode_descriptor = 33,
2132 fmxbuffersize_descriptor = 34,
2133 multiplexbuffer_descriptor = 35,
2134 content_labeling_descriptor = 36,
2135 metadata_pointer_descriptor = 37,
2136 metadata_descriptor = 38,
2137 metadata_std_descriptor = 39,
2138 AVC_video_descriptor = 40,
2139 ipmp_descriptor = 41,
2140 AVC_timing_and_HRD_descriptor = 42,
2141 mpeg2_aac_audio_descriptor = 43,
2142 flexmux_timing_descriptor = 44,
2143 network_name_descriptor = 64,
2144 service_list_descriptor = 65,
2145 stuffing_descriptor = 66,
2146 satellite_delivery_system_descriptor = 67,
2147 cable_delivery_system_descriptor = 68,
2148 VBI_data_descriptor = 69,
2149 VBI_teletext_descriptor = 70,
2150 bouquet_name_descriptor = 71,
2151 service_descriptor = 72,
2152 country_availability_descriptor = 73,
2153 linkage_descriptor = 74,
2154 NVOD_reference_descriptor = 75,
2155 time_shifted_service_descriptor = 76,
2156 short_event_descriptor = 77,
2157 extended_event_descriptor = 78,
2158 time_shifted_event_descriptor = 79,
2159 component_descriptor = 80,
2160 mosaic_descriptor = 81,
2161 stream_identifier_descriptor = 82,
2162 CA_identifier_descriptor = 83,
2163 content_descriptor = 84,
2164 parental_rating_descriptor = 85,
2165 teletext_descriptor = 86,
2166 telephone_descriptor = 87,
2167 local_time_offset_descriptor = 88,
2168 subtitling_descriptor = 89,
2169 terrestrial_delivery_system_descriptor = 90,
2170 multilingual_network_name_descriptor = 91,
2171 multilingual_bouquet_name_descriptor = 92,
2172 multilingual_service_name_descriptor = 93,
2173 multilingual_component_descriptor = 94,
2174 private_data_specifier_descriptor = 95,
2175 service_move_descriptor = 96,
2176 short_smoothing_buffer_descriptor = 97,
2177 frequency_list_descriptor = 98,
2178 partial_transport_stream_descriptor = 99,
2179 data_broadcast_descriptor = 100,
2180 scrambling_descriptor = 101,
2181 data_broadcast_id_descriptor = 102,
2182 transport_stream_descriptor = 103,
2183 DSNG_descriptor = 104,
2184 PDC_descriptor = 105,
2185 AC_3_descriptor = 106,
2186 ancillary_data_descriptor = 107,
2187 cell_list_descriptor = 108,
2188 cell_frequency_link_descriptor = 109,
2189 announcement_support_descriptor = 110,
2190 application_signalling_descriptor = 111,
2191 adaptation_field_data_descriptor = 112,
2192 service_identifier_descriptor = 113,
2193 service_availability_descriptor = 114,
2194 default_authority_descriptor = 115,
2195 related_content_descriptor = 116,
2196 TVA_id_descriptor = 117,
2197 content_identifier_descriptor = 118,
2198 time_slice_fec_identifier_descriptor = 119,
2199 ECM_repetition_rate_descriptor = 120,
2200 S2_satellite_delivery_system_descriptor = 121,
2201 enhanced_AC_3_descriptor = 122,
2202 DTS_descriptor = 123,
2203 AAC_descriptor = 124,
2204 XAIT_location_descriptor = 125,
2205 FTA_content_management_descriptor = 126,
2206 extension_descriptor = 127,
2207 CUE_identifier_descriptor = 138,
2208 extended_channel_name = 160,
2209 service_location = 161,
2210 component_name_descriptor = 163,
2211 logical_channel_number_descriptor = 131,
2212 carousel_id_descriptor = 19,
2213 association_tag_descriptor = 20,
2214 deferred_association_tags_descriptor = 21,
2215 hierarchical_transmission_descriptor = 192,
2216 digital_copy_control_descriptor = 193,
2217 network_identifier_descriptor = 194,
2218 partial_transport_stream_time_descriptor = 195,
2219 audio_component_descriptor = 196,
2220 hyperlink_descriptor = 197,
2221 target_area_descriptor = 198,
2222 data_contents_descriptor = 199,
2223 video_decode_control_descriptor = 200,
2224 download_content_descriptor = 201,
2225 CA_EMM_TS_descriptor = 202,
2226 CA_contract_information_descriptor = 203,
2227 CA_service_descriptor = 204,
2228 TS_Information_descriptior = 205,
2229 extended_broadcaster_descriptor = 206,
2230 logo_transmission_descriptor = 207,
2231 basic_local_event_descriptor = 208,
2232 reference_descriptor = 209,
2233 node_relation_descriptor = 210,
2234 short_node_information_descriptor = 211,
2235 STC_reference_descriptor = 212,
2236 series_descriptor = 213,
2237 event_group_descriptor = 214,
2238 SI_parameter_descriptor = 215,
2239 broadcaster_Name_Descriptor = 216,
2240 component_group_descriptor = 217,
2241 SI_prime_TS_descriptor = 218,
2242 board_information_descriptor = 219,
2243 LDT_linkage_descriptor = 220,
2244 connected_transmission_descriptor = 221,
2245 content_availability_descriptor = 222,
2246 service_group_descriptor = 224,
2247 carousel_compatible_composite_descriptor = 247,
2248 conditional_playback_descriptor = 248,
2249 ISDBT_delivery_system_descriptor = 250,
2250 partial_reception_descriptor = 251,
2251 emergency_information_descriptor = 252,
2252 data_component_descriptor = 253,
2253 system_management_descriptor = 254,
2254 atsc_stuffing_descriptor = 128,
2255 atsc_ac3_audio_descriptor = 129,
2256 atsc_caption_service_descriptor = 134,
2257 atsc_content_advisory_descriptor = 135,
2258 atsc_time_shifted_service_descriptor = 162,
2259 atsc_DCC_departing_request_descriptor = 168,
2260 atsc_DCC_arriving_request_descriptor = 169,
2261 atsc_redistribution_control_descriptor = 170,
2262 atsc_ATSC_private_information_descriptor = 173,
2263 atsc_genre_descriptor = 171,
2264}
2265#[repr(C, packed)]
2266#[derive(Copy, Clone)]
2267pub struct atsc_desc_service_location_elementary {
2268 pub stream_type: u8,
2269 pub __bindgen_anon_1: atsc_desc_service_location_elementary__bindgen_ty_1,
2270 pub ISO_639_language_code: [::std::os::raw::c_char; 3usize],
2271}
2272#[repr(C, packed)]
2273#[derive(Copy, Clone)]
2274pub union atsc_desc_service_location_elementary__bindgen_ty_1 {
2275 pub bitfield: u16,
2276 pub __bindgen_anon_1: atsc_desc_service_location_elementary__bindgen_ty_1__bindgen_ty_1,
2277 _bindgen_union_align: [u8; 2usize],
2278}
2279#[repr(C, packed)]
2280#[derive(Debug, Copy, Clone)]
2281pub struct atsc_desc_service_location_elementary__bindgen_ty_1__bindgen_ty_1 {
2282 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize], u8>,
2283}
2284#[test]
2285fn bindgen_test_layout_atsc_desc_service_location_elementary__bindgen_ty_1__bindgen_ty_1() {
2286 assert_eq!(
2287 ::std::mem::size_of::<atsc_desc_service_location_elementary__bindgen_ty_1__bindgen_ty_1>(),
2288 2usize,
2289 concat!(
2290 "Size of: ",
2291 stringify!(atsc_desc_service_location_elementary__bindgen_ty_1__bindgen_ty_1)
2292 )
2293 );
2294 assert_eq!(
2295 ::std::mem::align_of::<atsc_desc_service_location_elementary__bindgen_ty_1__bindgen_ty_1>(),
2296 1usize,
2297 concat!(
2298 "Alignment of ",
2299 stringify!(atsc_desc_service_location_elementary__bindgen_ty_1__bindgen_ty_1)
2300 )
2301 );
2302}
2303impl atsc_desc_service_location_elementary__bindgen_ty_1__bindgen_ty_1 {
2304 #[inline]
2305 pub fn elementary_pid(&self) -> u16 {
2306 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 13u8) as u16) }
2307 }
2308 #[inline]
2309 pub fn set_elementary_pid(&mut self, val: u16) {
2310 unsafe {
2311 let val: u16 = ::std::mem::transmute(val);
2312 self._bitfield_1.set(0usize, 13u8, val as u64)
2313 }
2314 }
2315 #[inline]
2316 pub fn reserved(&self) -> u16 {
2317 unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 3u8) as u16) }
2318 }
2319 #[inline]
2320 pub fn set_reserved(&mut self, val: u16) {
2321 unsafe {
2322 let val: u16 = ::std::mem::transmute(val);
2323 self._bitfield_1.set(13usize, 3u8, val as u64)
2324 }
2325 }
2326 #[inline]
2327 pub fn new_bitfield_1(
2328 elementary_pid: u16,
2329 reserved: u16,
2330 ) -> __BindgenBitfieldUnit<[u8; 2usize], u8> {
2331 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize], u8> =
2332 Default::default();
2333 __bindgen_bitfield_unit.set(0usize, 13u8, {
2334 let elementary_pid: u16 = unsafe { ::std::mem::transmute(elementary_pid) };
2335 elementary_pid as u64
2336 });
2337 __bindgen_bitfield_unit.set(13usize, 3u8, {
2338 let reserved: u16 = unsafe { ::std::mem::transmute(reserved) };
2339 reserved as u64
2340 });
2341 __bindgen_bitfield_unit
2342 }
2343}
2344#[test]
2345fn bindgen_test_layout_atsc_desc_service_location_elementary__bindgen_ty_1() {
2346 assert_eq!(
2347 ::std::mem::size_of::<atsc_desc_service_location_elementary__bindgen_ty_1>(),
2348 2usize,
2349 concat!(
2350 "Size of: ",
2351 stringify!(atsc_desc_service_location_elementary__bindgen_ty_1)
2352 )
2353 );
2354 assert_eq!(
2355 ::std::mem::align_of::<atsc_desc_service_location_elementary__bindgen_ty_1>(),
2356 1usize,
2357 concat!(
2358 "Alignment of ",
2359 stringify!(atsc_desc_service_location_elementary__bindgen_ty_1)
2360 )
2361 );
2362 assert_eq!(
2363 unsafe {
2364 &(*(::std::ptr::null::<atsc_desc_service_location_elementary__bindgen_ty_1>())).bitfield
2365 as *const _ as usize
2366 },
2367 0usize,
2368 concat!(
2369 "Offset of field: ",
2370 stringify!(atsc_desc_service_location_elementary__bindgen_ty_1),
2371 "::",
2372 stringify!(bitfield)
2373 )
2374 );
2375}
2376#[test]
2377fn bindgen_test_layout_atsc_desc_service_location_elementary() {
2378 assert_eq!(
2379 ::std::mem::size_of::<atsc_desc_service_location_elementary>(),
2380 6usize,
2381 concat!(
2382 "Size of: ",
2383 stringify!(atsc_desc_service_location_elementary)
2384 )
2385 );
2386 assert_eq!(
2387 ::std::mem::align_of::<atsc_desc_service_location_elementary>(),
2388 1usize,
2389 concat!(
2390 "Alignment of ",
2391 stringify!(atsc_desc_service_location_elementary)
2392 )
2393 );
2394 assert_eq!(
2395 unsafe {
2396 &(*(::std::ptr::null::<atsc_desc_service_location_elementary>())).stream_type
2397 as *const _ as usize
2398 },
2399 0usize,
2400 concat!(
2401 "Offset of field: ",
2402 stringify!(atsc_desc_service_location_elementary),
2403 "::",
2404 stringify!(stream_type)
2405 )
2406 );
2407 assert_eq!(
2408 unsafe {
2409 &(*(::std::ptr::null::<atsc_desc_service_location_elementary>())).ISO_639_language_code
2410 as *const _ as usize
2411 },
2412 3usize,
2413 concat!(
2414 "Offset of field: ",
2415 stringify!(atsc_desc_service_location_elementary),
2416 "::",
2417 stringify!(ISO_639_language_code)
2418 )
2419 );
2420}
2421#[repr(C, packed)]
2422#[derive(Copy, Clone)]
2423pub struct atsc_desc_service_location {
2424 pub type_: u8,
2425 pub length: u8,
2426 pub next: *mut dvb_desc,
2427 pub elementary: *mut atsc_desc_service_location_elementary,
2428 pub __bindgen_anon_1: atsc_desc_service_location__bindgen_ty_1,
2429 pub number_elements: u8,
2430}
2431#[repr(C, packed)]
2432#[derive(Copy, Clone)]
2433pub union atsc_desc_service_location__bindgen_ty_1 {
2434 pub bitfield: u16,
2435 pub __bindgen_anon_1: atsc_desc_service_location__bindgen_ty_1__bindgen_ty_1,
2436 _bindgen_union_align: [u8; 2usize],
2437}
2438#[repr(C, packed)]
2439#[derive(Debug, Copy, Clone)]
2440pub struct atsc_desc_service_location__bindgen_ty_1__bindgen_ty_1 {
2441 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize], u8>,
2442}
2443#[test]
2444fn bindgen_test_layout_atsc_desc_service_location__bindgen_ty_1__bindgen_ty_1() {
2445 assert_eq!(
2446 ::std::mem::size_of::<atsc_desc_service_location__bindgen_ty_1__bindgen_ty_1>(),
2447 2usize,
2448 concat!(
2449 "Size of: ",
2450 stringify!(atsc_desc_service_location__bindgen_ty_1__bindgen_ty_1)
2451 )
2452 );
2453 assert_eq!(
2454 ::std::mem::align_of::<atsc_desc_service_location__bindgen_ty_1__bindgen_ty_1>(),
2455 1usize,
2456 concat!(
2457 "Alignment of ",
2458 stringify!(atsc_desc_service_location__bindgen_ty_1__bindgen_ty_1)
2459 )
2460 );
2461}
2462impl atsc_desc_service_location__bindgen_ty_1__bindgen_ty_1 {
2463 #[inline]
2464 pub fn pcr_pid(&self) -> u16 {
2465 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 13u8) as u16) }
2466 }
2467 #[inline]
2468 pub fn set_pcr_pid(&mut self, val: u16) {
2469 unsafe {
2470 let val: u16 = ::std::mem::transmute(val);
2471 self._bitfield_1.set(0usize, 13u8, val as u64)
2472 }
2473 }
2474 #[inline]
2475 pub fn reserved(&self) -> u16 {
2476 unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 3u8) as u16) }
2477 }
2478 #[inline]
2479 pub fn set_reserved(&mut self, val: u16) {
2480 unsafe {
2481 let val: u16 = ::std::mem::transmute(val);
2482 self._bitfield_1.set(13usize, 3u8, val as u64)
2483 }
2484 }
2485 #[inline]
2486 pub fn new_bitfield_1(pcr_pid: u16, reserved: u16) -> __BindgenBitfieldUnit<[u8; 2usize], u8> {
2487 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize], u8> =
2488 Default::default();
2489 __bindgen_bitfield_unit.set(0usize, 13u8, {
2490 let pcr_pid: u16 = unsafe { ::std::mem::transmute(pcr_pid) };
2491 pcr_pid as u64
2492 });
2493 __bindgen_bitfield_unit.set(13usize, 3u8, {
2494 let reserved: u16 = unsafe { ::std::mem::transmute(reserved) };
2495 reserved as u64
2496 });
2497 __bindgen_bitfield_unit
2498 }
2499}
2500#[test]
2501fn bindgen_test_layout_atsc_desc_service_location__bindgen_ty_1() {
2502 assert_eq!(
2503 ::std::mem::size_of::<atsc_desc_service_location__bindgen_ty_1>(),
2504 2usize,
2505 concat!(
2506 "Size of: ",
2507 stringify!(atsc_desc_service_location__bindgen_ty_1)
2508 )
2509 );
2510 assert_eq!(
2511 ::std::mem::align_of::<atsc_desc_service_location__bindgen_ty_1>(),
2512 1usize,
2513 concat!(
2514 "Alignment of ",
2515 stringify!(atsc_desc_service_location__bindgen_ty_1)
2516 )
2517 );
2518 assert_eq!(
2519 unsafe {
2520 &(*(::std::ptr::null::<atsc_desc_service_location__bindgen_ty_1>())).bitfield
2521 as *const _ as usize
2522 },
2523 0usize,
2524 concat!(
2525 "Offset of field: ",
2526 stringify!(atsc_desc_service_location__bindgen_ty_1),
2527 "::",
2528 stringify!(bitfield)
2529 )
2530 );
2531}
2532#[test]
2533fn bindgen_test_layout_atsc_desc_service_location() {
2534 assert_eq!(
2535 ::std::mem::size_of::<atsc_desc_service_location>(),
2536 21usize,
2537 concat!("Size of: ", stringify!(atsc_desc_service_location))
2538 );
2539 assert_eq!(
2540 ::std::mem::align_of::<atsc_desc_service_location>(),
2541 1usize,
2542 concat!("Alignment of ", stringify!(atsc_desc_service_location))
2543 );
2544 assert_eq!(
2545 unsafe {
2546 &(*(::std::ptr::null::<atsc_desc_service_location>())).type_ as *const _ as usize
2547 },
2548 0usize,
2549 concat!(
2550 "Offset of field: ",
2551 stringify!(atsc_desc_service_location),
2552 "::",
2553 stringify!(type_)
2554 )
2555 );
2556 assert_eq!(
2557 unsafe {
2558 &(*(::std::ptr::null::<atsc_desc_service_location>())).length as *const _ as usize
2559 },
2560 1usize,
2561 concat!(
2562 "Offset of field: ",
2563 stringify!(atsc_desc_service_location),
2564 "::",
2565 stringify!(length)
2566 )
2567 );
2568 assert_eq!(
2569 unsafe { &(*(::std::ptr::null::<atsc_desc_service_location>())).next as *const _ as usize },
2570 2usize,
2571 concat!(
2572 "Offset of field: ",
2573 stringify!(atsc_desc_service_location),
2574 "::",
2575 stringify!(next)
2576 )
2577 );
2578 assert_eq!(
2579 unsafe {
2580 &(*(::std::ptr::null::<atsc_desc_service_location>())).elementary as *const _ as usize
2581 },
2582 10usize,
2583 concat!(
2584 "Offset of field: ",
2585 stringify!(atsc_desc_service_location),
2586 "::",
2587 stringify!(elementary)
2588 )
2589 );
2590 assert_eq!(
2591 unsafe {
2592 &(*(::std::ptr::null::<atsc_desc_service_location>())).number_elements as *const _
2593 as usize
2594 },
2595 20usize,
2596 concat!(
2597 "Offset of field: ",
2598 stringify!(atsc_desc_service_location),
2599 "::",
2600 stringify!(number_elements)
2601 )
2602 );
2603}
2604extern "C" {
2605 pub fn atsc_desc_service_location_init(
2606 parms: *mut dvb_v5_fe_parms,
2607 buf: *const u8,
2608 desc: *mut dvb_desc,
2609 ) -> ::std::os::raw::c_int;
2610}
2611extern "C" {
2612 pub fn atsc_desc_service_location_print(parms: *mut dvb_v5_fe_parms, desc: *const dvb_desc);
2613}
2614extern "C" {
2615 pub fn atsc_desc_service_location_free(desc: *mut dvb_desc);
2616}
2617#[repr(C, packed)]
2618#[derive(Copy, Clone)]
2619pub struct dvb_desc_cable_delivery {
2620 pub type_: u8,
2621 pub length: u8,
2622 pub next: *mut dvb_desc,
2623 pub frequency: u32,
2624 pub __bindgen_anon_1: dvb_desc_cable_delivery__bindgen_ty_1,
2625 pub modulation: u8,
2626 pub __bindgen_anon_2: dvb_desc_cable_delivery__bindgen_ty_2,
2627}
2628#[repr(C, packed)]
2629#[derive(Copy, Clone)]
2630pub union dvb_desc_cable_delivery__bindgen_ty_1 {
2631 pub bitfield1: u16,
2632 pub __bindgen_anon_1: dvb_desc_cable_delivery__bindgen_ty_1__bindgen_ty_1,
2633 _bindgen_union_align: [u8; 2usize],
2634}
2635#[repr(C, packed)]
2636#[derive(Debug, Copy, Clone)]
2637pub struct dvb_desc_cable_delivery__bindgen_ty_1__bindgen_ty_1 {
2638 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize], u8>,
2639}
2640#[test]
2641fn bindgen_test_layout_dvb_desc_cable_delivery__bindgen_ty_1__bindgen_ty_1() {
2642 assert_eq!(
2643 ::std::mem::size_of::<dvb_desc_cable_delivery__bindgen_ty_1__bindgen_ty_1>(),
2644 2usize,
2645 concat!(
2646 "Size of: ",
2647 stringify!(dvb_desc_cable_delivery__bindgen_ty_1__bindgen_ty_1)
2648 )
2649 );
2650 assert_eq!(
2651 ::std::mem::align_of::<dvb_desc_cable_delivery__bindgen_ty_1__bindgen_ty_1>(),
2652 1usize,
2653 concat!(
2654 "Alignment of ",
2655 stringify!(dvb_desc_cable_delivery__bindgen_ty_1__bindgen_ty_1)
2656 )
2657 );
2658}
2659impl dvb_desc_cable_delivery__bindgen_ty_1__bindgen_ty_1 {
2660 #[inline]
2661 pub fn fec_outer(&self) -> u16 {
2662 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u16) }
2663 }
2664 #[inline]
2665 pub fn set_fec_outer(&mut self, val: u16) {
2666 unsafe {
2667 let val: u16 = ::std::mem::transmute(val);
2668 self._bitfield_1.set(0usize, 4u8, val as u64)
2669 }
2670 }
2671 #[inline]
2672 pub fn reserved_future_use(&self) -> u16 {
2673 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 12u8) as u16) }
2674 }
2675 #[inline]
2676 pub fn set_reserved_future_use(&mut self, val: u16) {
2677 unsafe {
2678 let val: u16 = ::std::mem::transmute(val);
2679 self._bitfield_1.set(4usize, 12u8, val as u64)
2680 }
2681 }
2682 #[inline]
2683 pub fn new_bitfield_1(
2684 fec_outer: u16,
2685 reserved_future_use: u16,
2686 ) -> __BindgenBitfieldUnit<[u8; 2usize], u8> {
2687 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize], u8> =
2688 Default::default();
2689 __bindgen_bitfield_unit.set(0usize, 4u8, {
2690 let fec_outer: u16 = unsafe { ::std::mem::transmute(fec_outer) };
2691 fec_outer as u64
2692 });
2693 __bindgen_bitfield_unit.set(4usize, 12u8, {
2694 let reserved_future_use: u16 = unsafe { ::std::mem::transmute(reserved_future_use) };
2695 reserved_future_use as u64
2696 });
2697 __bindgen_bitfield_unit
2698 }
2699}
2700#[test]
2701fn bindgen_test_layout_dvb_desc_cable_delivery__bindgen_ty_1() {
2702 assert_eq!(
2703 ::std::mem::size_of::<dvb_desc_cable_delivery__bindgen_ty_1>(),
2704 2usize,
2705 concat!(
2706 "Size of: ",
2707 stringify!(dvb_desc_cable_delivery__bindgen_ty_1)
2708 )
2709 );
2710 assert_eq!(
2711 ::std::mem::align_of::<dvb_desc_cable_delivery__bindgen_ty_1>(),
2712 1usize,
2713 concat!(
2714 "Alignment of ",
2715 stringify!(dvb_desc_cable_delivery__bindgen_ty_1)
2716 )
2717 );
2718 assert_eq!(
2719 unsafe {
2720 &(*(::std::ptr::null::<dvb_desc_cable_delivery__bindgen_ty_1>())).bitfield1 as *const _
2721 as usize
2722 },
2723 0usize,
2724 concat!(
2725 "Offset of field: ",
2726 stringify!(dvb_desc_cable_delivery__bindgen_ty_1),
2727 "::",
2728 stringify!(bitfield1)
2729 )
2730 );
2731}
2732#[repr(C, packed)]
2733#[derive(Copy, Clone)]
2734pub union dvb_desc_cable_delivery__bindgen_ty_2 {
2735 pub bitfield2: u32,
2736 pub __bindgen_anon_1: dvb_desc_cable_delivery__bindgen_ty_2__bindgen_ty_1,
2737 _bindgen_union_align: [u8; 4usize],
2738}
2739#[repr(C, packed)]
2740#[derive(Debug, Copy, Clone)]
2741pub struct dvb_desc_cable_delivery__bindgen_ty_2__bindgen_ty_1 {
2742 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize], u8>,
2743}
2744#[test]
2745fn bindgen_test_layout_dvb_desc_cable_delivery__bindgen_ty_2__bindgen_ty_1() {
2746 assert_eq!(
2747 ::std::mem::size_of::<dvb_desc_cable_delivery__bindgen_ty_2__bindgen_ty_1>(),
2748 4usize,
2749 concat!(
2750 "Size of: ",
2751 stringify!(dvb_desc_cable_delivery__bindgen_ty_2__bindgen_ty_1)
2752 )
2753 );
2754 assert_eq!(
2755 ::std::mem::align_of::<dvb_desc_cable_delivery__bindgen_ty_2__bindgen_ty_1>(),
2756 1usize,
2757 concat!(
2758 "Alignment of ",
2759 stringify!(dvb_desc_cable_delivery__bindgen_ty_2__bindgen_ty_1)
2760 )
2761 );
2762}
2763impl dvb_desc_cable_delivery__bindgen_ty_2__bindgen_ty_1 {
2764 #[inline]
2765 pub fn fec_inner(&self) -> u32 {
2766 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u32) }
2767 }
2768 #[inline]
2769 pub fn set_fec_inner(&mut self, val: u32) {
2770 unsafe {
2771 let val: u32 = ::std::mem::transmute(val);
2772 self._bitfield_1.set(0usize, 4u8, val as u64)
2773 }
2774 }
2775 #[inline]
2776 pub fn symbol_rate(&self) -> u32 {
2777 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 28u8) as u32) }
2778 }
2779 #[inline]
2780 pub fn set_symbol_rate(&mut self, val: u32) {
2781 unsafe {
2782 let val: u32 = ::std::mem::transmute(val);
2783 self._bitfield_1.set(4usize, 28u8, val as u64)
2784 }
2785 }
2786 #[inline]
2787 pub fn new_bitfield_1(
2788 fec_inner: u32,
2789 symbol_rate: u32,
2790 ) -> __BindgenBitfieldUnit<[u8; 4usize], u8> {
2791 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize], u8> =
2792 Default::default();
2793 __bindgen_bitfield_unit.set(0usize, 4u8, {
2794 let fec_inner: u32 = unsafe { ::std::mem::transmute(fec_inner) };
2795 fec_inner as u64
2796 });
2797 __bindgen_bitfield_unit.set(4usize, 28u8, {
2798 let symbol_rate: u32 = unsafe { ::std::mem::transmute(symbol_rate) };
2799 symbol_rate as u64
2800 });
2801 __bindgen_bitfield_unit
2802 }
2803}
2804#[test]
2805fn bindgen_test_layout_dvb_desc_cable_delivery__bindgen_ty_2() {
2806 assert_eq!(
2807 ::std::mem::size_of::<dvb_desc_cable_delivery__bindgen_ty_2>(),
2808 4usize,
2809 concat!(
2810 "Size of: ",
2811 stringify!(dvb_desc_cable_delivery__bindgen_ty_2)
2812 )
2813 );
2814 assert_eq!(
2815 ::std::mem::align_of::<dvb_desc_cable_delivery__bindgen_ty_2>(),
2816 1usize,
2817 concat!(
2818 "Alignment of ",
2819 stringify!(dvb_desc_cable_delivery__bindgen_ty_2)
2820 )
2821 );
2822 assert_eq!(
2823 unsafe {
2824 &(*(::std::ptr::null::<dvb_desc_cable_delivery__bindgen_ty_2>())).bitfield2 as *const _
2825 as usize
2826 },
2827 0usize,
2828 concat!(
2829 "Offset of field: ",
2830 stringify!(dvb_desc_cable_delivery__bindgen_ty_2),
2831 "::",
2832 stringify!(bitfield2)
2833 )
2834 );
2835}
2836#[test]
2837fn bindgen_test_layout_dvb_desc_cable_delivery() {
2838 assert_eq!(
2839 ::std::mem::size_of::<dvb_desc_cable_delivery>(),
2840 21usize,
2841 concat!("Size of: ", stringify!(dvb_desc_cable_delivery))
2842 );
2843 assert_eq!(
2844 ::std::mem::align_of::<dvb_desc_cable_delivery>(),
2845 1usize,
2846 concat!("Alignment of ", stringify!(dvb_desc_cable_delivery))
2847 );
2848 assert_eq!(
2849 unsafe { &(*(::std::ptr::null::<dvb_desc_cable_delivery>())).type_ as *const _ as usize },
2850 0usize,
2851 concat!(
2852 "Offset of field: ",
2853 stringify!(dvb_desc_cable_delivery),
2854 "::",
2855 stringify!(type_)
2856 )
2857 );
2858 assert_eq!(
2859 unsafe { &(*(::std::ptr::null::<dvb_desc_cable_delivery>())).length as *const _ as usize },
2860 1usize,
2861 concat!(
2862 "Offset of field: ",
2863 stringify!(dvb_desc_cable_delivery),
2864 "::",
2865 stringify!(length)
2866 )
2867 );
2868 assert_eq!(
2869 unsafe { &(*(::std::ptr::null::<dvb_desc_cable_delivery>())).next as *const _ as usize },
2870 2usize,
2871 concat!(
2872 "Offset of field: ",
2873 stringify!(dvb_desc_cable_delivery),
2874 "::",
2875 stringify!(next)
2876 )
2877 );
2878 assert_eq!(
2879 unsafe {
2880 &(*(::std::ptr::null::<dvb_desc_cable_delivery>())).frequency as *const _ as usize
2881 },
2882 10usize,
2883 concat!(
2884 "Offset of field: ",
2885 stringify!(dvb_desc_cable_delivery),
2886 "::",
2887 stringify!(frequency)
2888 )
2889 );
2890 assert_eq!(
2891 unsafe {
2892 &(*(::std::ptr::null::<dvb_desc_cable_delivery>())).modulation as *const _ as usize
2893 },
2894 16usize,
2895 concat!(
2896 "Offset of field: ",
2897 stringify!(dvb_desc_cable_delivery),
2898 "::",
2899 stringify!(modulation)
2900 )
2901 );
2902}
2903extern "C" {
2904 pub fn dvb_desc_cable_delivery_init(
2905 parms: *mut dvb_v5_fe_parms,
2906 buf: *const u8,
2907 desc: *mut dvb_desc,
2908 ) -> ::std::os::raw::c_int;
2909}
2910extern "C" {
2911 pub fn dvb_desc_cable_delivery_print(parms: *mut dvb_v5_fe_parms, desc: *const dvb_desc);
2912}
2913extern "C" {
2914 pub static mut dvbc_modulation_table: [::std::os::raw::c_uint; 0usize];
2915}
2916extern "C" {
2917 pub static mut dvbc_fec_table: [::std::os::raw::c_uint; 0usize];
2918}
2919#[repr(C, packed)]
2920#[derive(Copy, Clone)]
2921pub struct dvb_desc_ca {
2922 pub type_: u8,
2923 pub length: u8,
2924 pub next: *mut dvb_desc,
2925 pub ca_id: u16,
2926 pub __bindgen_anon_1: dvb_desc_ca__bindgen_ty_1,
2927 pub privdata: *mut u8,
2928 pub privdata_len: u8,
2929}
2930#[repr(C, packed)]
2931#[derive(Copy, Clone)]
2932pub union dvb_desc_ca__bindgen_ty_1 {
2933 pub bitfield1: u16,
2934 pub __bindgen_anon_1: dvb_desc_ca__bindgen_ty_1__bindgen_ty_1,
2935 _bindgen_union_align: [u8; 2usize],
2936}
2937#[repr(C, packed)]
2938#[derive(Debug, Copy, Clone)]
2939pub struct dvb_desc_ca__bindgen_ty_1__bindgen_ty_1 {
2940 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize], u8>,
2941}
2942#[test]
2943fn bindgen_test_layout_dvb_desc_ca__bindgen_ty_1__bindgen_ty_1() {
2944 assert_eq!(
2945 ::std::mem::size_of::<dvb_desc_ca__bindgen_ty_1__bindgen_ty_1>(),
2946 2usize,
2947 concat!(
2948 "Size of: ",
2949 stringify!(dvb_desc_ca__bindgen_ty_1__bindgen_ty_1)
2950 )
2951 );
2952 assert_eq!(
2953 ::std::mem::align_of::<dvb_desc_ca__bindgen_ty_1__bindgen_ty_1>(),
2954 1usize,
2955 concat!(
2956 "Alignment of ",
2957 stringify!(dvb_desc_ca__bindgen_ty_1__bindgen_ty_1)
2958 )
2959 );
2960}
2961impl dvb_desc_ca__bindgen_ty_1__bindgen_ty_1 {
2962 #[inline]
2963 pub fn ca_pid(&self) -> u16 {
2964 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 13u8) as u16) }
2965 }
2966 #[inline]
2967 pub fn set_ca_pid(&mut self, val: u16) {
2968 unsafe {
2969 let val: u16 = ::std::mem::transmute(val);
2970 self._bitfield_1.set(0usize, 13u8, val as u64)
2971 }
2972 }
2973 #[inline]
2974 pub fn reserved(&self) -> u16 {
2975 unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 3u8) as u16) }
2976 }
2977 #[inline]
2978 pub fn set_reserved(&mut self, val: u16) {
2979 unsafe {
2980 let val: u16 = ::std::mem::transmute(val);
2981 self._bitfield_1.set(13usize, 3u8, val as u64)
2982 }
2983 }
2984 #[inline]
2985 pub fn new_bitfield_1(ca_pid: u16, reserved: u16) -> __BindgenBitfieldUnit<[u8; 2usize], u8> {
2986 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize], u8> =
2987 Default::default();
2988 __bindgen_bitfield_unit.set(0usize, 13u8, {
2989 let ca_pid: u16 = unsafe { ::std::mem::transmute(ca_pid) };
2990 ca_pid as u64
2991 });
2992 __bindgen_bitfield_unit.set(13usize, 3u8, {
2993 let reserved: u16 = unsafe { ::std::mem::transmute(reserved) };
2994 reserved as u64
2995 });
2996 __bindgen_bitfield_unit
2997 }
2998}
2999#[test]
3000fn bindgen_test_layout_dvb_desc_ca__bindgen_ty_1() {
3001 assert_eq!(
3002 ::std::mem::size_of::<dvb_desc_ca__bindgen_ty_1>(),
3003 2usize,
3004 concat!("Size of: ", stringify!(dvb_desc_ca__bindgen_ty_1))
3005 );
3006 assert_eq!(
3007 ::std::mem::align_of::<dvb_desc_ca__bindgen_ty_1>(),
3008 1usize,
3009 concat!("Alignment of ", stringify!(dvb_desc_ca__bindgen_ty_1))
3010 );
3011 assert_eq!(
3012 unsafe {
3013 &(*(::std::ptr::null::<dvb_desc_ca__bindgen_ty_1>())).bitfield1 as *const _ as usize
3014 },
3015 0usize,
3016 concat!(
3017 "Offset of field: ",
3018 stringify!(dvb_desc_ca__bindgen_ty_1),
3019 "::",
3020 stringify!(bitfield1)
3021 )
3022 );
3023}
3024#[test]
3025fn bindgen_test_layout_dvb_desc_ca() {
3026 assert_eq!(
3027 ::std::mem::size_of::<dvb_desc_ca>(),
3028 23usize,
3029 concat!("Size of: ", stringify!(dvb_desc_ca))
3030 );
3031 assert_eq!(
3032 ::std::mem::align_of::<dvb_desc_ca>(),
3033 1usize,
3034 concat!("Alignment of ", stringify!(dvb_desc_ca))
3035 );
3036 assert_eq!(
3037 unsafe { &(*(::std::ptr::null::<dvb_desc_ca>())).type_ as *const _ as usize },
3038 0usize,
3039 concat!(
3040 "Offset of field: ",
3041 stringify!(dvb_desc_ca),
3042 "::",
3043 stringify!(type_)
3044 )
3045 );
3046 assert_eq!(
3047 unsafe { &(*(::std::ptr::null::<dvb_desc_ca>())).length as *const _ as usize },
3048 1usize,
3049 concat!(
3050 "Offset of field: ",
3051 stringify!(dvb_desc_ca),
3052 "::",
3053 stringify!(length)
3054 )
3055 );
3056 assert_eq!(
3057 unsafe { &(*(::std::ptr::null::<dvb_desc_ca>())).next as *const _ as usize },
3058 2usize,
3059 concat!(
3060 "Offset of field: ",
3061 stringify!(dvb_desc_ca),
3062 "::",
3063 stringify!(next)
3064 )
3065 );
3066 assert_eq!(
3067 unsafe { &(*(::std::ptr::null::<dvb_desc_ca>())).ca_id as *const _ as usize },
3068 10usize,
3069 concat!(
3070 "Offset of field: ",
3071 stringify!(dvb_desc_ca),
3072 "::",
3073 stringify!(ca_id)
3074 )
3075 );
3076 assert_eq!(
3077 unsafe { &(*(::std::ptr::null::<dvb_desc_ca>())).privdata as *const _ as usize },
3078 14usize,
3079 concat!(
3080 "Offset of field: ",
3081 stringify!(dvb_desc_ca),
3082 "::",
3083 stringify!(privdata)
3084 )
3085 );
3086 assert_eq!(
3087 unsafe { &(*(::std::ptr::null::<dvb_desc_ca>())).privdata_len as *const _ as usize },
3088 22usize,
3089 concat!(
3090 "Offset of field: ",
3091 stringify!(dvb_desc_ca),
3092 "::",
3093 stringify!(privdata_len)
3094 )
3095 );
3096}
3097extern "C" {
3098 pub fn dvb_desc_ca_init(
3099 parms: *mut dvb_v5_fe_parms,
3100 buf: *const u8,
3101 desc: *mut dvb_desc,
3102 ) -> ::std::os::raw::c_int;
3103}
3104extern "C" {
3105 pub fn dvb_desc_ca_print(parms: *mut dvb_v5_fe_parms, desc: *const dvb_desc);
3106}
3107extern "C" {
3108 pub fn dvb_desc_ca_free(desc: *mut dvb_desc);
3109}
3110#[repr(C, packed)]
3111#[derive(Debug, Copy, Clone)]
3112pub struct dvb_desc_ca_identifier {
3113 pub type_: u8,
3114 pub length: u8,
3115 pub next: *mut dvb_desc,
3116 pub caid_count: u8,
3117 pub caids: *mut u16,
3118}
3119#[test]
3120fn bindgen_test_layout_dvb_desc_ca_identifier() {
3121 assert_eq!(
3122 ::std::mem::size_of::<dvb_desc_ca_identifier>(),
3123 19usize,
3124 concat!("Size of: ", stringify!(dvb_desc_ca_identifier))
3125 );
3126 assert_eq!(
3127 ::std::mem::align_of::<dvb_desc_ca_identifier>(),
3128 1usize,
3129 concat!("Alignment of ", stringify!(dvb_desc_ca_identifier))
3130 );
3131 assert_eq!(
3132 unsafe { &(*(::std::ptr::null::<dvb_desc_ca_identifier>())).type_ as *const _ as usize },
3133 0usize,
3134 concat!(
3135 "Offset of field: ",
3136 stringify!(dvb_desc_ca_identifier),
3137 "::",
3138 stringify!(type_)
3139 )
3140 );
3141 assert_eq!(
3142 unsafe { &(*(::std::ptr::null::<dvb_desc_ca_identifier>())).length as *const _ as usize },
3143 1usize,
3144 concat!(
3145 "Offset of field: ",
3146 stringify!(dvb_desc_ca_identifier),
3147 "::",
3148 stringify!(length)
3149 )
3150 );
3151 assert_eq!(
3152 unsafe { &(*(::std::ptr::null::<dvb_desc_ca_identifier>())).next as *const _ as usize },
3153 2usize,
3154 concat!(
3155 "Offset of field: ",
3156 stringify!(dvb_desc_ca_identifier),
3157 "::",
3158 stringify!(next)
3159 )
3160 );
3161 assert_eq!(
3162 unsafe {
3163 &(*(::std::ptr::null::<dvb_desc_ca_identifier>())).caid_count as *const _ as usize
3164 },
3165 10usize,
3166 concat!(
3167 "Offset of field: ",
3168 stringify!(dvb_desc_ca_identifier),
3169 "::",
3170 stringify!(caid_count)
3171 )
3172 );
3173 assert_eq!(
3174 unsafe { &(*(::std::ptr::null::<dvb_desc_ca_identifier>())).caids as *const _ as usize },
3175 11usize,
3176 concat!(
3177 "Offset of field: ",
3178 stringify!(dvb_desc_ca_identifier),
3179 "::",
3180 stringify!(caids)
3181 )
3182 );
3183}
3184extern "C" {
3185 pub fn dvb_desc_ca_identifier_init(
3186 parms: *mut dvb_v5_fe_parms,
3187 buf: *const u8,
3188 desc: *mut dvb_desc,
3189 ) -> ::std::os::raw::c_int;
3190}
3191extern "C" {
3192 pub fn dvb_desc_ca_identifier_print(parms: *mut dvb_v5_fe_parms, desc: *const dvb_desc);
3193}
3194extern "C" {
3195 pub fn dvb_desc_ca_identifier_free(desc: *mut dvb_desc);
3196}
3197#[repr(C)]
3198#[derive(Debug, Copy, Clone)]
3199pub struct dvb_desc_event_extended_item {
3200 pub description: *mut ::std::os::raw::c_char,
3201 pub description_emph: *mut ::std::os::raw::c_char,
3202 pub item: *mut ::std::os::raw::c_char,
3203 pub item_emph: *mut ::std::os::raw::c_char,
3204}
3205#[test]
3206fn bindgen_test_layout_dvb_desc_event_extended_item() {
3207 assert_eq!(
3208 ::std::mem::size_of::<dvb_desc_event_extended_item>(),
3209 32usize,
3210 concat!("Size of: ", stringify!(dvb_desc_event_extended_item))
3211 );
3212 assert_eq!(
3213 ::std::mem::align_of::<dvb_desc_event_extended_item>(),
3214 8usize,
3215 concat!("Alignment of ", stringify!(dvb_desc_event_extended_item))
3216 );
3217 assert_eq!(
3218 unsafe {
3219 &(*(::std::ptr::null::<dvb_desc_event_extended_item>())).description as *const _
3220 as usize
3221 },
3222 0usize,
3223 concat!(
3224 "Offset of field: ",
3225 stringify!(dvb_desc_event_extended_item),
3226 "::",
3227 stringify!(description)
3228 )
3229 );
3230 assert_eq!(
3231 unsafe {
3232 &(*(::std::ptr::null::<dvb_desc_event_extended_item>())).description_emph as *const _
3233 as usize
3234 },
3235 8usize,
3236 concat!(
3237 "Offset of field: ",
3238 stringify!(dvb_desc_event_extended_item),
3239 "::",
3240 stringify!(description_emph)
3241 )
3242 );
3243 assert_eq!(
3244 unsafe {
3245 &(*(::std::ptr::null::<dvb_desc_event_extended_item>())).item as *const _ as usize
3246 },
3247 16usize,
3248 concat!(
3249 "Offset of field: ",
3250 stringify!(dvb_desc_event_extended_item),
3251 "::",
3252 stringify!(item)
3253 )
3254 );
3255 assert_eq!(
3256 unsafe {
3257 &(*(::std::ptr::null::<dvb_desc_event_extended_item>())).item_emph as *const _ as usize
3258 },
3259 24usize,
3260 concat!(
3261 "Offset of field: ",
3262 stringify!(dvb_desc_event_extended_item),
3263 "::",
3264 stringify!(item_emph)
3265 )
3266 );
3267}
3268#[repr(C, packed)]
3269#[derive(Copy, Clone)]
3270pub struct dvb_desc_event_extended {
3271 pub type_: u8,
3272 pub length: u8,
3273 pub next: *mut dvb_desc,
3274 pub __bindgen_anon_1: dvb_desc_event_extended__bindgen_ty_1,
3275 pub language: [::std::os::raw::c_uchar; 4usize],
3276 pub text: *mut ::std::os::raw::c_char,
3277 pub text_emph: *mut ::std::os::raw::c_char,
3278 pub items: *mut dvb_desc_event_extended_item,
3279 pub num_items: ::std::os::raw::c_int,
3280}
3281#[repr(C, packed)]
3282#[derive(Copy, Clone)]
3283pub union dvb_desc_event_extended__bindgen_ty_1 {
3284 pub __bindgen_anon_1: dvb_desc_event_extended__bindgen_ty_1__bindgen_ty_1,
3285 pub ids: u8,
3286 _bindgen_union_align: u8,
3287}
3288#[repr(C, packed)]
3289#[derive(Debug, Copy, Clone)]
3290pub struct dvb_desc_event_extended__bindgen_ty_1__bindgen_ty_1 {
3291 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize], u8>,
3292}
3293#[test]
3294fn bindgen_test_layout_dvb_desc_event_extended__bindgen_ty_1__bindgen_ty_1() {
3295 assert_eq!(
3296 ::std::mem::size_of::<dvb_desc_event_extended__bindgen_ty_1__bindgen_ty_1>(),
3297 1usize,
3298 concat!(
3299 "Size of: ",
3300 stringify!(dvb_desc_event_extended__bindgen_ty_1__bindgen_ty_1)
3301 )
3302 );
3303 assert_eq!(
3304 ::std::mem::align_of::<dvb_desc_event_extended__bindgen_ty_1__bindgen_ty_1>(),
3305 1usize,
3306 concat!(
3307 "Alignment of ",
3308 stringify!(dvb_desc_event_extended__bindgen_ty_1__bindgen_ty_1)
3309 )
3310 );
3311}
3312impl dvb_desc_event_extended__bindgen_ty_1__bindgen_ty_1 {
3313 #[inline]
3314 pub fn last_id(&self) -> u8 {
3315 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u8) }
3316 }
3317 #[inline]
3318 pub fn set_last_id(&mut self, val: u8) {
3319 unsafe {
3320 let val: u8 = ::std::mem::transmute(val);
3321 self._bitfield_1.set(0usize, 4u8, val as u64)
3322 }
3323 }
3324 #[inline]
3325 pub fn id(&self) -> u8 {
3326 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 4u8) as u8) }
3327 }
3328 #[inline]
3329 pub fn set_id(&mut self, val: u8) {
3330 unsafe {
3331 let val: u8 = ::std::mem::transmute(val);
3332 self._bitfield_1.set(4usize, 4u8, val as u64)
3333 }
3334 }
3335 #[inline]
3336 pub fn new_bitfield_1(last_id: u8, id: u8) -> __BindgenBitfieldUnit<[u8; 1usize], u8> {
3337 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize], u8> =
3338 Default::default();
3339 __bindgen_bitfield_unit.set(0usize, 4u8, {
3340 let last_id: u8 = unsafe { ::std::mem::transmute(last_id) };
3341 last_id as u64
3342 });
3343 __bindgen_bitfield_unit.set(4usize, 4u8, {
3344 let id: u8 = unsafe { ::std::mem::transmute(id) };
3345 id as u64
3346 });
3347 __bindgen_bitfield_unit
3348 }
3349}
3350#[test]
3351fn bindgen_test_layout_dvb_desc_event_extended__bindgen_ty_1() {
3352 assert_eq!(
3353 ::std::mem::size_of::<dvb_desc_event_extended__bindgen_ty_1>(),
3354 1usize,
3355 concat!(
3356 "Size of: ",
3357 stringify!(dvb_desc_event_extended__bindgen_ty_1)
3358 )
3359 );
3360 assert_eq!(
3361 ::std::mem::align_of::<dvb_desc_event_extended__bindgen_ty_1>(),
3362 1usize,
3363 concat!(
3364 "Alignment of ",
3365 stringify!(dvb_desc_event_extended__bindgen_ty_1)
3366 )
3367 );
3368 assert_eq!(
3369 unsafe {
3370 &(*(::std::ptr::null::<dvb_desc_event_extended__bindgen_ty_1>())).ids as *const _
3371 as usize
3372 },
3373 0usize,
3374 concat!(
3375 "Offset of field: ",
3376 stringify!(dvb_desc_event_extended__bindgen_ty_1),
3377 "::",
3378 stringify!(ids)
3379 )
3380 );
3381}
3382#[test]
3383fn bindgen_test_layout_dvb_desc_event_extended() {
3384 assert_eq!(
3385 ::std::mem::size_of::<dvb_desc_event_extended>(),
3386 43usize,
3387 concat!("Size of: ", stringify!(dvb_desc_event_extended))
3388 );
3389 assert_eq!(
3390 ::std::mem::align_of::<dvb_desc_event_extended>(),
3391 1usize,
3392 concat!("Alignment of ", stringify!(dvb_desc_event_extended))
3393 );
3394 assert_eq!(
3395 unsafe { &(*(::std::ptr::null::<dvb_desc_event_extended>())).type_ as *const _ as usize },
3396 0usize,
3397 concat!(
3398 "Offset of field: ",
3399 stringify!(dvb_desc_event_extended),
3400 "::",
3401 stringify!(type_)
3402 )
3403 );
3404 assert_eq!(
3405 unsafe { &(*(::std::ptr::null::<dvb_desc_event_extended>())).length as *const _ as usize },
3406 1usize,
3407 concat!(
3408 "Offset of field: ",
3409 stringify!(dvb_desc_event_extended),
3410 "::",
3411 stringify!(length)
3412 )
3413 );
3414 assert_eq!(
3415 unsafe { &(*(::std::ptr::null::<dvb_desc_event_extended>())).next as *const _ as usize },
3416 2usize,
3417 concat!(
3418 "Offset of field: ",
3419 stringify!(dvb_desc_event_extended),
3420 "::",
3421 stringify!(next)
3422 )
3423 );
3424 assert_eq!(
3425 unsafe {
3426 &(*(::std::ptr::null::<dvb_desc_event_extended>())).language as *const _ as usize
3427 },
3428 11usize,
3429 concat!(
3430 "Offset of field: ",
3431 stringify!(dvb_desc_event_extended),
3432 "::",
3433 stringify!(language)
3434 )
3435 );
3436 assert_eq!(
3437 unsafe { &(*(::std::ptr::null::<dvb_desc_event_extended>())).text as *const _ as usize },
3438 15usize,
3439 concat!(
3440 "Offset of field: ",
3441 stringify!(dvb_desc_event_extended),
3442 "::",
3443 stringify!(text)
3444 )
3445 );
3446 assert_eq!(
3447 unsafe {
3448 &(*(::std::ptr::null::<dvb_desc_event_extended>())).text_emph as *const _ as usize
3449 },
3450 23usize,
3451 concat!(
3452 "Offset of field: ",
3453 stringify!(dvb_desc_event_extended),
3454 "::",
3455 stringify!(text_emph)
3456 )
3457 );
3458 assert_eq!(
3459 unsafe { &(*(::std::ptr::null::<dvb_desc_event_extended>())).items as *const _ as usize },
3460 31usize,
3461 concat!(
3462 "Offset of field: ",
3463 stringify!(dvb_desc_event_extended),
3464 "::",
3465 stringify!(items)
3466 )
3467 );
3468 assert_eq!(
3469 unsafe {
3470 &(*(::std::ptr::null::<dvb_desc_event_extended>())).num_items as *const _ as usize
3471 },
3472 39usize,
3473 concat!(
3474 "Offset of field: ",
3475 stringify!(dvb_desc_event_extended),
3476 "::",
3477 stringify!(num_items)
3478 )
3479 );
3480}
3481extern "C" {
3482 pub fn dvb_desc_event_extended_init(
3483 parms: *mut dvb_v5_fe_parms,
3484 buf: *const u8,
3485 desc: *mut dvb_desc,
3486 ) -> ::std::os::raw::c_int;
3487}
3488extern "C" {
3489 pub fn dvb_desc_event_extended_print(parms: *mut dvb_v5_fe_parms, desc: *const dvb_desc);
3490}
3491extern "C" {
3492 pub fn dvb_desc_event_extended_free(desc: *mut dvb_desc);
3493}
3494#[repr(C, packed)]
3495#[derive(Debug, Copy, Clone)]
3496pub struct dvb_desc_event_short {
3497 pub type_: u8,
3498 pub length: u8,
3499 pub next: *mut dvb_desc,
3500 pub language: [::std::os::raw::c_uchar; 4usize],
3501 pub name: *mut ::std::os::raw::c_char,
3502 pub name_emph: *mut ::std::os::raw::c_char,
3503 pub text: *mut ::std::os::raw::c_char,
3504 pub text_emph: *mut ::std::os::raw::c_char,
3505}
3506#[test]
3507fn bindgen_test_layout_dvb_desc_event_short() {
3508 assert_eq!(
3509 ::std::mem::size_of::<dvb_desc_event_short>(),
3510 46usize,
3511 concat!("Size of: ", stringify!(dvb_desc_event_short))
3512 );
3513 assert_eq!(
3514 ::std::mem::align_of::<dvb_desc_event_short>(),
3515 1usize,
3516 concat!("Alignment of ", stringify!(dvb_desc_event_short))
3517 );
3518 assert_eq!(
3519 unsafe { &(*(::std::ptr::null::<dvb_desc_event_short>())).type_ as *const _ as usize },
3520 0usize,
3521 concat!(
3522 "Offset of field: ",
3523 stringify!(dvb_desc_event_short),
3524 "::",
3525 stringify!(type_)
3526 )
3527 );
3528 assert_eq!(
3529 unsafe { &(*(::std::ptr::null::<dvb_desc_event_short>())).length as *const _ as usize },
3530 1usize,
3531 concat!(
3532 "Offset of field: ",
3533 stringify!(dvb_desc_event_short),
3534 "::",
3535 stringify!(length)
3536 )
3537 );
3538 assert_eq!(
3539 unsafe { &(*(::std::ptr::null::<dvb_desc_event_short>())).next as *const _ as usize },
3540 2usize,
3541 concat!(
3542 "Offset of field: ",
3543 stringify!(dvb_desc_event_short),
3544 "::",
3545 stringify!(next)
3546 )
3547 );
3548 assert_eq!(
3549 unsafe { &(*(::std::ptr::null::<dvb_desc_event_short>())).language as *const _ as usize },
3550 10usize,
3551 concat!(
3552 "Offset of field: ",
3553 stringify!(dvb_desc_event_short),
3554 "::",
3555 stringify!(language)
3556 )
3557 );
3558 assert_eq!(
3559 unsafe { &(*(::std::ptr::null::<dvb_desc_event_short>())).name as *const _ as usize },
3560 14usize,
3561 concat!(
3562 "Offset of field: ",
3563 stringify!(dvb_desc_event_short),
3564 "::",
3565 stringify!(name)
3566 )
3567 );
3568 assert_eq!(
3569 unsafe { &(*(::std::ptr::null::<dvb_desc_event_short>())).name_emph as *const _ as usize },
3570 22usize,
3571 concat!(
3572 "Offset of field: ",
3573 stringify!(dvb_desc_event_short),
3574 "::",
3575 stringify!(name_emph)
3576 )
3577 );
3578 assert_eq!(
3579 unsafe { &(*(::std::ptr::null::<dvb_desc_event_short>())).text as *const _ as usize },
3580 30usize,
3581 concat!(
3582 "Offset of field: ",
3583 stringify!(dvb_desc_event_short),
3584 "::",
3585 stringify!(text)
3586 )
3587 );
3588 assert_eq!(
3589 unsafe { &(*(::std::ptr::null::<dvb_desc_event_short>())).text_emph as *const _ as usize },
3590 38usize,
3591 concat!(
3592 "Offset of field: ",
3593 stringify!(dvb_desc_event_short),
3594 "::",
3595 stringify!(text_emph)
3596 )
3597 );
3598}
3599extern "C" {
3600 pub fn dvb_desc_event_short_init(
3601 parms: *mut dvb_v5_fe_parms,
3602 buf: *const u8,
3603 desc: *mut dvb_desc,
3604 ) -> ::std::os::raw::c_int;
3605}
3606extern "C" {
3607 pub fn dvb_desc_event_short_print(parms: *mut dvb_v5_fe_parms, desc: *const dvb_desc);
3608}
3609extern "C" {
3610 pub fn dvb_desc_event_short_free(desc: *mut dvb_desc);
3611}
3612#[repr(C, packed)]
3613#[derive(Debug, Copy, Clone)]
3614pub struct dvb_extension_descriptor {
3615 pub type_: u8,
3616 pub length: u8,
3617 pub next: *mut dvb_desc,
3618 pub extension_code: u8,
3619 pub descriptor: *mut dvb_desc,
3620}
3621#[test]
3622fn bindgen_test_layout_dvb_extension_descriptor() {
3623 assert_eq!(
3624 ::std::mem::size_of::<dvb_extension_descriptor>(),
3625 19usize,
3626 concat!("Size of: ", stringify!(dvb_extension_descriptor))
3627 );
3628 assert_eq!(
3629 ::std::mem::align_of::<dvb_extension_descriptor>(),
3630 1usize,
3631 concat!("Alignment of ", stringify!(dvb_extension_descriptor))
3632 );
3633 assert_eq!(
3634 unsafe { &(*(::std::ptr::null::<dvb_extension_descriptor>())).type_ as *const _ as usize },
3635 0usize,
3636 concat!(
3637 "Offset of field: ",
3638 stringify!(dvb_extension_descriptor),
3639 "::",
3640 stringify!(type_)
3641 )
3642 );
3643 assert_eq!(
3644 unsafe { &(*(::std::ptr::null::<dvb_extension_descriptor>())).length as *const _ as usize },
3645 1usize,
3646 concat!(
3647 "Offset of field: ",
3648 stringify!(dvb_extension_descriptor),
3649 "::",
3650 stringify!(length)
3651 )
3652 );
3653 assert_eq!(
3654 unsafe { &(*(::std::ptr::null::<dvb_extension_descriptor>())).next as *const _ as usize },
3655 2usize,
3656 concat!(
3657 "Offset of field: ",
3658 stringify!(dvb_extension_descriptor),
3659 "::",
3660 stringify!(next)
3661 )
3662 );
3663 assert_eq!(
3664 unsafe {
3665 &(*(::std::ptr::null::<dvb_extension_descriptor>())).extension_code as *const _ as usize
3666 },
3667 10usize,
3668 concat!(
3669 "Offset of field: ",
3670 stringify!(dvb_extension_descriptor),
3671 "::",
3672 stringify!(extension_code)
3673 )
3674 );
3675 assert_eq!(
3676 unsafe {
3677 &(*(::std::ptr::null::<dvb_extension_descriptor>())).descriptor as *const _ as usize
3678 },
3679 11usize,
3680 concat!(
3681 "Offset of field: ",
3682 stringify!(dvb_extension_descriptor),
3683 "::",
3684 stringify!(descriptor)
3685 )
3686 );
3687}
3688pub type dvb_desc_ext_init_func = ::std::option::Option<
3689 unsafe extern "C" fn(
3690 parms: *mut dvb_v5_fe_parms,
3691 buf: *const u8,
3692 ext: *mut dvb_extension_descriptor,
3693 desc: *mut ::std::os::raw::c_void,
3694 ) -> ::std::os::raw::c_int,
3695>;
3696pub type dvb_desc_ext_print_func = ::std::option::Option<
3697 unsafe extern "C" fn(
3698 parms: *mut dvb_v5_fe_parms,
3699 ext: *const dvb_extension_descriptor,
3700 desc: *const ::std::os::raw::c_void,
3701 ),
3702>;
3703pub type dvb_desc_ext_free_func =
3704 ::std::option::Option<unsafe extern "C" fn(desc: *const ::std::os::raw::c_void)>;
3705#[repr(C)]
3706#[derive(Debug, Copy, Clone)]
3707pub struct dvb_ext_descriptor {
3708 pub name: *const ::std::os::raw::c_char,
3709 pub init: dvb_desc_ext_init_func,
3710 pub print: dvb_desc_ext_print_func,
3711 pub free: dvb_desc_ext_free_func,
3712 pub size: ssize_t,
3713}
3714#[test]
3715fn bindgen_test_layout_dvb_ext_descriptor() {
3716 assert_eq!(
3717 ::std::mem::size_of::<dvb_ext_descriptor>(),
3718 40usize,
3719 concat!("Size of: ", stringify!(dvb_ext_descriptor))
3720 );
3721 assert_eq!(
3722 ::std::mem::align_of::<dvb_ext_descriptor>(),
3723 8usize,
3724 concat!("Alignment of ", stringify!(dvb_ext_descriptor))
3725 );
3726 assert_eq!(
3727 unsafe { &(*(::std::ptr::null::<dvb_ext_descriptor>())).name as *const _ as usize },
3728 0usize,
3729 concat!(
3730 "Offset of field: ",
3731 stringify!(dvb_ext_descriptor),
3732 "::",
3733 stringify!(name)
3734 )
3735 );
3736 assert_eq!(
3737 unsafe { &(*(::std::ptr::null::<dvb_ext_descriptor>())).init as *const _ as usize },
3738 8usize,
3739 concat!(
3740 "Offset of field: ",
3741 stringify!(dvb_ext_descriptor),
3742 "::",
3743 stringify!(init)
3744 )
3745 );
3746 assert_eq!(
3747 unsafe { &(*(::std::ptr::null::<dvb_ext_descriptor>())).print as *const _ as usize },
3748 16usize,
3749 concat!(
3750 "Offset of field: ",
3751 stringify!(dvb_ext_descriptor),
3752 "::",
3753 stringify!(print)
3754 )
3755 );
3756 assert_eq!(
3757 unsafe { &(*(::std::ptr::null::<dvb_ext_descriptor>())).free as *const _ as usize },
3758 24usize,
3759 concat!(
3760 "Offset of field: ",
3761 stringify!(dvb_ext_descriptor),
3762 "::",
3763 stringify!(free)
3764 )
3765 );
3766 assert_eq!(
3767 unsafe { &(*(::std::ptr::null::<dvb_ext_descriptor>())).size as *const _ as usize },
3768 32usize,
3769 concat!(
3770 "Offset of field: ",
3771 stringify!(dvb_ext_descriptor),
3772 "::",
3773 stringify!(size)
3774 )
3775 );
3776}
3777extern "C" {
3778 pub fn dvb_extension_descriptor_init(
3779 parms: *mut dvb_v5_fe_parms,
3780 buf: *const u8,
3781 desc: *mut dvb_desc,
3782 ) -> ::std::os::raw::c_int;
3783}
3784extern "C" {
3785 pub fn dvb_extension_descriptor_print(parms: *mut dvb_v5_fe_parms, desc: *const dvb_desc);
3786}
3787extern "C" {
3788 pub fn dvb_extension_descriptor_free(desc: *mut dvb_desc);
3789}
3790#[repr(C, packed)]
3791#[derive(Copy, Clone)]
3792pub struct dvb_desc_frequency_list {
3793 pub type_: u8,
3794 pub length: u8,
3795 pub next: *mut dvb_desc,
3796 pub frequencies: u8,
3797 pub frequency: *mut u32,
3798 pub __bindgen_anon_1: dvb_desc_frequency_list__bindgen_ty_1,
3799}
3800#[repr(C, packed)]
3801#[derive(Copy, Clone)]
3802pub union dvb_desc_frequency_list__bindgen_ty_1 {
3803 pub bitfield: u8,
3804 pub __bindgen_anon_1: dvb_desc_frequency_list__bindgen_ty_1__bindgen_ty_1,
3805 _bindgen_union_align: u8,
3806}
3807#[repr(C, packed)]
3808#[derive(Debug, Copy, Clone)]
3809pub struct dvb_desc_frequency_list__bindgen_ty_1__bindgen_ty_1 {
3810 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize], u8>,
3811}
3812#[test]
3813fn bindgen_test_layout_dvb_desc_frequency_list__bindgen_ty_1__bindgen_ty_1() {
3814 assert_eq!(
3815 ::std::mem::size_of::<dvb_desc_frequency_list__bindgen_ty_1__bindgen_ty_1>(),
3816 1usize,
3817 concat!(
3818 "Size of: ",
3819 stringify!(dvb_desc_frequency_list__bindgen_ty_1__bindgen_ty_1)
3820 )
3821 );
3822 assert_eq!(
3823 ::std::mem::align_of::<dvb_desc_frequency_list__bindgen_ty_1__bindgen_ty_1>(),
3824 1usize,
3825 concat!(
3826 "Alignment of ",
3827 stringify!(dvb_desc_frequency_list__bindgen_ty_1__bindgen_ty_1)
3828 )
3829 );
3830}
3831impl dvb_desc_frequency_list__bindgen_ty_1__bindgen_ty_1 {
3832 #[inline]
3833 pub fn freq_type(&self) -> u8 {
3834 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u8) }
3835 }
3836 #[inline]
3837 pub fn set_freq_type(&mut self, val: u8) {
3838 unsafe {
3839 let val: u8 = ::std::mem::transmute(val);
3840 self._bitfield_1.set(0usize, 2u8, val as u64)
3841 }
3842 }
3843 #[inline]
3844 pub fn reserved(&self) -> u8 {
3845 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 6u8) as u8) }
3846 }
3847 #[inline]
3848 pub fn set_reserved(&mut self, val: u8) {
3849 unsafe {
3850 let val: u8 = ::std::mem::transmute(val);
3851 self._bitfield_1.set(2usize, 6u8, val as u64)
3852 }
3853 }
3854 #[inline]
3855 pub fn new_bitfield_1(freq_type: u8, reserved: u8) -> __BindgenBitfieldUnit<[u8; 1usize], u8> {
3856 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize], u8> =
3857 Default::default();
3858 __bindgen_bitfield_unit.set(0usize, 2u8, {
3859 let freq_type: u8 = unsafe { ::std::mem::transmute(freq_type) };
3860 freq_type as u64
3861 });
3862 __bindgen_bitfield_unit.set(2usize, 6u8, {
3863 let reserved: u8 = unsafe { ::std::mem::transmute(reserved) };
3864 reserved as u64
3865 });
3866 __bindgen_bitfield_unit
3867 }
3868}
3869#[test]
3870fn bindgen_test_layout_dvb_desc_frequency_list__bindgen_ty_1() {
3871 assert_eq!(
3872 ::std::mem::size_of::<dvb_desc_frequency_list__bindgen_ty_1>(),
3873 1usize,
3874 concat!(
3875 "Size of: ",
3876 stringify!(dvb_desc_frequency_list__bindgen_ty_1)
3877 )
3878 );
3879 assert_eq!(
3880 ::std::mem::align_of::<dvb_desc_frequency_list__bindgen_ty_1>(),
3881 1usize,
3882 concat!(
3883 "Alignment of ",
3884 stringify!(dvb_desc_frequency_list__bindgen_ty_1)
3885 )
3886 );
3887 assert_eq!(
3888 unsafe {
3889 &(*(::std::ptr::null::<dvb_desc_frequency_list__bindgen_ty_1>())).bitfield as *const _
3890 as usize
3891 },
3892 0usize,
3893 concat!(
3894 "Offset of field: ",
3895 stringify!(dvb_desc_frequency_list__bindgen_ty_1),
3896 "::",
3897 stringify!(bitfield)
3898 )
3899 );
3900}
3901#[test]
3902fn bindgen_test_layout_dvb_desc_frequency_list() {
3903 assert_eq!(
3904 ::std::mem::size_of::<dvb_desc_frequency_list>(),
3905 20usize,
3906 concat!("Size of: ", stringify!(dvb_desc_frequency_list))
3907 );
3908 assert_eq!(
3909 ::std::mem::align_of::<dvb_desc_frequency_list>(),
3910 1usize,
3911 concat!("Alignment of ", stringify!(dvb_desc_frequency_list))
3912 );
3913 assert_eq!(
3914 unsafe { &(*(::std::ptr::null::<dvb_desc_frequency_list>())).type_ as *const _ as usize },
3915 0usize,
3916 concat!(
3917 "Offset of field: ",
3918 stringify!(dvb_desc_frequency_list),
3919 "::",
3920 stringify!(type_)
3921 )
3922 );
3923 assert_eq!(
3924 unsafe { &(*(::std::ptr::null::<dvb_desc_frequency_list>())).length as *const _ as usize },
3925 1usize,
3926 concat!(
3927 "Offset of field: ",
3928 stringify!(dvb_desc_frequency_list),
3929 "::",
3930 stringify!(length)
3931 )
3932 );
3933 assert_eq!(
3934 unsafe { &(*(::std::ptr::null::<dvb_desc_frequency_list>())).next as *const _ as usize },
3935 2usize,
3936 concat!(
3937 "Offset of field: ",
3938 stringify!(dvb_desc_frequency_list),
3939 "::",
3940 stringify!(next)
3941 )
3942 );
3943 assert_eq!(
3944 unsafe {
3945 &(*(::std::ptr::null::<dvb_desc_frequency_list>())).frequencies as *const _ as usize
3946 },
3947 10usize,
3948 concat!(
3949 "Offset of field: ",
3950 stringify!(dvb_desc_frequency_list),
3951 "::",
3952 stringify!(frequencies)
3953 )
3954 );
3955 assert_eq!(
3956 unsafe {
3957 &(*(::std::ptr::null::<dvb_desc_frequency_list>())).frequency as *const _ as usize
3958 },
3959 11usize,
3960 concat!(
3961 "Offset of field: ",
3962 stringify!(dvb_desc_frequency_list),
3963 "::",
3964 stringify!(frequency)
3965 )
3966 );
3967}
3968extern "C" {
3969 pub fn dvb_desc_frequency_list_init(
3970 parms: *mut dvb_v5_fe_parms,
3971 buf: *const u8,
3972 desc: *mut dvb_desc,
3973 ) -> ::std::os::raw::c_int;
3974}
3975extern "C" {
3976 pub fn dvb_desc_frequency_list_print(parms: *mut dvb_v5_fe_parms, desc: *const dvb_desc);
3977}
3978#[repr(C, packed)]
3979#[derive(Debug, Copy, Clone)]
3980pub struct dvb_desc_hierarchy {
3981 pub type_: u8,
3982 pub length: u8,
3983 pub next: *mut dvb_desc,
3984 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize], u8>,
3985}
3986#[test]
3987fn bindgen_test_layout_dvb_desc_hierarchy() {
3988 assert_eq!(
3989 ::std::mem::size_of::<dvb_desc_hierarchy>(),
3990 14usize,
3991 concat!("Size of: ", stringify!(dvb_desc_hierarchy))
3992 );
3993 assert_eq!(
3994 ::std::mem::align_of::<dvb_desc_hierarchy>(),
3995 1usize,
3996 concat!("Alignment of ", stringify!(dvb_desc_hierarchy))
3997 );
3998 assert_eq!(
3999 unsafe { &(*(::std::ptr::null::<dvb_desc_hierarchy>())).type_ as *const _ as usize },
4000 0usize,
4001 concat!(
4002 "Offset of field: ",
4003 stringify!(dvb_desc_hierarchy),
4004 "::",
4005 stringify!(type_)
4006 )
4007 );
4008 assert_eq!(
4009 unsafe { &(*(::std::ptr::null::<dvb_desc_hierarchy>())).length as *const _ as usize },
4010 1usize,
4011 concat!(
4012 "Offset of field: ",
4013 stringify!(dvb_desc_hierarchy),
4014 "::",
4015 stringify!(length)
4016 )
4017 );
4018 assert_eq!(
4019 unsafe { &(*(::std::ptr::null::<dvb_desc_hierarchy>())).next as *const _ as usize },
4020 2usize,
4021 concat!(
4022 "Offset of field: ",
4023 stringify!(dvb_desc_hierarchy),
4024 "::",
4025 stringify!(next)
4026 )
4027 );
4028}
4029impl dvb_desc_hierarchy {
4030 #[inline]
4031 pub fn hierarchy_type(&self) -> u8 {
4032 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u8) }
4033 }
4034 #[inline]
4035 pub fn set_hierarchy_type(&mut self, val: u8) {
4036 unsafe {
4037 let val: u8 = ::std::mem::transmute(val);
4038 self._bitfield_1.set(0usize, 4u8, val as u64)
4039 }
4040 }
4041 #[inline]
4042 pub fn reserved(&self) -> u8 {
4043 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 4u8) as u8) }
4044 }
4045 #[inline]
4046 pub fn set_reserved(&mut self, val: u8) {
4047 unsafe {
4048 let val: u8 = ::std::mem::transmute(val);
4049 self._bitfield_1.set(4usize, 4u8, val as u64)
4050 }
4051 }
4052 #[inline]
4053 pub fn layer(&self) -> u8 {
4054 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 6u8) as u8) }
4055 }
4056 #[inline]
4057 pub fn set_layer(&mut self, val: u8) {
4058 unsafe {
4059 let val: u8 = ::std::mem::transmute(val);
4060 self._bitfield_1.set(8usize, 6u8, val as u64)
4061 }
4062 }
4063 #[inline]
4064 pub fn reserved2(&self) -> u8 {
4065 unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 2u8) as u8) }
4066 }
4067 #[inline]
4068 pub fn set_reserved2(&mut self, val: u8) {
4069 unsafe {
4070 let val: u8 = ::std::mem::transmute(val);
4071 self._bitfield_1.set(14usize, 2u8, val as u64)
4072 }
4073 }
4074 #[inline]
4075 pub fn embedded_layer(&self) -> u8 {
4076 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 6u8) as u8) }
4077 }
4078 #[inline]
4079 pub fn set_embedded_layer(&mut self, val: u8) {
4080 unsafe {
4081 let val: u8 = ::std::mem::transmute(val);
4082 self._bitfield_1.set(16usize, 6u8, val as u64)
4083 }
4084 }
4085 #[inline]
4086 pub fn reserved3(&self) -> u8 {
4087 unsafe { ::std::mem::transmute(self._bitfield_1.get(22usize, 2u8) as u8) }
4088 }
4089 #[inline]
4090 pub fn set_reserved3(&mut self, val: u8) {
4091 unsafe {
4092 let val: u8 = ::std::mem::transmute(val);
4093 self._bitfield_1.set(22usize, 2u8, val as u64)
4094 }
4095 }
4096 #[inline]
4097 pub fn channel(&self) -> u8 {
4098 unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 6u8) as u8) }
4099 }
4100 #[inline]
4101 pub fn set_channel(&mut self, val: u8) {
4102 unsafe {
4103 let val: u8 = ::std::mem::transmute(val);
4104 self._bitfield_1.set(24usize, 6u8, val as u64)
4105 }
4106 }
4107 #[inline]
4108 pub fn reserved4(&self) -> u8 {
4109 unsafe { ::std::mem::transmute(self._bitfield_1.get(30usize, 2u8) as u8) }
4110 }
4111 #[inline]
4112 pub fn set_reserved4(&mut self, val: u8) {
4113 unsafe {
4114 let val: u8 = ::std::mem::transmute(val);
4115 self._bitfield_1.set(30usize, 2u8, val as u64)
4116 }
4117 }
4118 #[inline]
4119 pub fn new_bitfield_1(
4120 hierarchy_type: u8,
4121 reserved: u8,
4122 layer: u8,
4123 reserved2: u8,
4124 embedded_layer: u8,
4125 reserved3: u8,
4126 channel: u8,
4127 reserved4: u8,
4128 ) -> __BindgenBitfieldUnit<[u8; 4usize], u8> {
4129 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize], u8> =
4130 Default::default();
4131 __bindgen_bitfield_unit.set(0usize, 4u8, {
4132 let hierarchy_type: u8 = unsafe { ::std::mem::transmute(hierarchy_type) };
4133 hierarchy_type as u64
4134 });
4135 __bindgen_bitfield_unit.set(4usize, 4u8, {
4136 let reserved: u8 = unsafe { ::std::mem::transmute(reserved) };
4137 reserved as u64
4138 });
4139 __bindgen_bitfield_unit.set(8usize, 6u8, {
4140 let layer: u8 = unsafe { ::std::mem::transmute(layer) };
4141 layer as u64
4142 });
4143 __bindgen_bitfield_unit.set(14usize, 2u8, {
4144 let reserved2: u8 = unsafe { ::std::mem::transmute(reserved2) };
4145 reserved2 as u64
4146 });
4147 __bindgen_bitfield_unit.set(16usize, 6u8, {
4148 let embedded_layer: u8 = unsafe { ::std::mem::transmute(embedded_layer) };
4149 embedded_layer as u64
4150 });
4151 __bindgen_bitfield_unit.set(22usize, 2u8, {
4152 let reserved3: u8 = unsafe { ::std::mem::transmute(reserved3) };
4153 reserved3 as u64
4154 });
4155 __bindgen_bitfield_unit.set(24usize, 6u8, {
4156 let channel: u8 = unsafe { ::std::mem::transmute(channel) };
4157 channel as u64
4158 });
4159 __bindgen_bitfield_unit.set(30usize, 2u8, {
4160 let reserved4: u8 = unsafe { ::std::mem::transmute(reserved4) };
4161 reserved4 as u64
4162 });
4163 __bindgen_bitfield_unit
4164 }
4165}
4166extern "C" {
4167 pub fn dvb_desc_hierarchy_init(
4168 parms: *mut dvb_v5_fe_parms,
4169 buf: *const u8,
4170 desc: *mut dvb_desc,
4171 ) -> ::std::os::raw::c_int;
4172}
4173extern "C" {
4174 pub fn dvb_desc_hierarchy_print(parms: *mut dvb_v5_fe_parms, desc: *const dvb_desc);
4175}
4176#[repr(C, packed)]
4177#[derive(Copy, Clone)]
4178pub struct isdbt_desc_terrestrial_delivery_system {
4179 pub type_: u8,
4180 pub length: u8,
4181 pub next: *mut dvb_desc,
4182 pub frequency: *mut u32,
4183 pub num_freqs: ::std::os::raw::c_uint,
4184 pub __bindgen_anon_1: isdbt_desc_terrestrial_delivery_system__bindgen_ty_1,
4185}
4186#[repr(C, packed)]
4187#[derive(Copy, Clone)]
4188pub union isdbt_desc_terrestrial_delivery_system__bindgen_ty_1 {
4189 pub bitfield: u16,
4190 pub __bindgen_anon_1: isdbt_desc_terrestrial_delivery_system__bindgen_ty_1__bindgen_ty_1,
4191 _bindgen_union_align: [u8; 2usize],
4192}
4193#[repr(C, packed)]
4194#[derive(Debug, Copy, Clone)]
4195pub struct isdbt_desc_terrestrial_delivery_system__bindgen_ty_1__bindgen_ty_1 {
4196 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize], u8>,
4197}
4198#[test]
4199fn bindgen_test_layout_isdbt_desc_terrestrial_delivery_system__bindgen_ty_1__bindgen_ty_1() {
4200 assert_eq!(
4201 ::std::mem::size_of::<isdbt_desc_terrestrial_delivery_system__bindgen_ty_1__bindgen_ty_1>(),
4202 2usize,
4203 concat!(
4204 "Size of: ",
4205 stringify!(isdbt_desc_terrestrial_delivery_system__bindgen_ty_1__bindgen_ty_1)
4206 )
4207 );
4208 assert_eq!(
4209 ::std::mem::align_of::<isdbt_desc_terrestrial_delivery_system__bindgen_ty_1__bindgen_ty_1>(
4210 ),
4211 1usize,
4212 concat!(
4213 "Alignment of ",
4214 stringify!(isdbt_desc_terrestrial_delivery_system__bindgen_ty_1__bindgen_ty_1)
4215 )
4216 );
4217}
4218impl isdbt_desc_terrestrial_delivery_system__bindgen_ty_1__bindgen_ty_1 {
4219 #[inline]
4220 pub fn transmission_mode(&self) -> u16 {
4221 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u16) }
4222 }
4223 #[inline]
4224 pub fn set_transmission_mode(&mut self, val: u16) {
4225 unsafe {
4226 let val: u16 = ::std::mem::transmute(val);
4227 self._bitfield_1.set(0usize, 2u8, val as u64)
4228 }
4229 }
4230 #[inline]
4231 pub fn guard_interval(&self) -> u16 {
4232 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 2u8) as u16) }
4233 }
4234 #[inline]
4235 pub fn set_guard_interval(&mut self, val: u16) {
4236 unsafe {
4237 let val: u16 = ::std::mem::transmute(val);
4238 self._bitfield_1.set(2usize, 2u8, val as u64)
4239 }
4240 }
4241 #[inline]
4242 pub fn area_code(&self) -> u16 {
4243 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 12u8) as u16) }
4244 }
4245 #[inline]
4246 pub fn set_area_code(&mut self, val: u16) {
4247 unsafe {
4248 let val: u16 = ::std::mem::transmute(val);
4249 self._bitfield_1.set(4usize, 12u8, val as u64)
4250 }
4251 }
4252 #[inline]
4253 pub fn new_bitfield_1(
4254 transmission_mode: u16,
4255 guard_interval: u16,
4256 area_code: u16,
4257 ) -> __BindgenBitfieldUnit<[u8; 2usize], u8> {
4258 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize], u8> =
4259 Default::default();
4260 __bindgen_bitfield_unit.set(0usize, 2u8, {
4261 let transmission_mode: u16 = unsafe { ::std::mem::transmute(transmission_mode) };
4262 transmission_mode as u64
4263 });
4264 __bindgen_bitfield_unit.set(2usize, 2u8, {
4265 let guard_interval: u16 = unsafe { ::std::mem::transmute(guard_interval) };
4266 guard_interval as u64
4267 });
4268 __bindgen_bitfield_unit.set(4usize, 12u8, {
4269 let area_code: u16 = unsafe { ::std::mem::transmute(area_code) };
4270 area_code as u64
4271 });
4272 __bindgen_bitfield_unit
4273 }
4274}
4275#[test]
4276fn bindgen_test_layout_isdbt_desc_terrestrial_delivery_system__bindgen_ty_1() {
4277 assert_eq!(
4278 ::std::mem::size_of::<isdbt_desc_terrestrial_delivery_system__bindgen_ty_1>(),
4279 2usize,
4280 concat!(
4281 "Size of: ",
4282 stringify!(isdbt_desc_terrestrial_delivery_system__bindgen_ty_1)
4283 )
4284 );
4285 assert_eq!(
4286 ::std::mem::align_of::<isdbt_desc_terrestrial_delivery_system__bindgen_ty_1>(),
4287 1usize,
4288 concat!(
4289 "Alignment of ",
4290 stringify!(isdbt_desc_terrestrial_delivery_system__bindgen_ty_1)
4291 )
4292 );
4293 assert_eq!(
4294 unsafe {
4295 &(*(::std::ptr::null::<isdbt_desc_terrestrial_delivery_system__bindgen_ty_1>()))
4296 .bitfield as *const _ as usize
4297 },
4298 0usize,
4299 concat!(
4300 "Offset of field: ",
4301 stringify!(isdbt_desc_terrestrial_delivery_system__bindgen_ty_1),
4302 "::",
4303 stringify!(bitfield)
4304 )
4305 );
4306}
4307#[test]
4308fn bindgen_test_layout_isdbt_desc_terrestrial_delivery_system() {
4309 assert_eq!(
4310 ::std::mem::size_of::<isdbt_desc_terrestrial_delivery_system>(),
4311 24usize,
4312 concat!(
4313 "Size of: ",
4314 stringify!(isdbt_desc_terrestrial_delivery_system)
4315 )
4316 );
4317 assert_eq!(
4318 ::std::mem::align_of::<isdbt_desc_terrestrial_delivery_system>(),
4319 1usize,
4320 concat!(
4321 "Alignment of ",
4322 stringify!(isdbt_desc_terrestrial_delivery_system)
4323 )
4324 );
4325 assert_eq!(
4326 unsafe {
4327 &(*(::std::ptr::null::<isdbt_desc_terrestrial_delivery_system>())).type_ as *const _
4328 as usize
4329 },
4330 0usize,
4331 concat!(
4332 "Offset of field: ",
4333 stringify!(isdbt_desc_terrestrial_delivery_system),
4334 "::",
4335 stringify!(type_)
4336 )
4337 );
4338 assert_eq!(
4339 unsafe {
4340 &(*(::std::ptr::null::<isdbt_desc_terrestrial_delivery_system>())).length as *const _
4341 as usize
4342 },
4343 1usize,
4344 concat!(
4345 "Offset of field: ",
4346 stringify!(isdbt_desc_terrestrial_delivery_system),
4347 "::",
4348 stringify!(length)
4349 )
4350 );
4351 assert_eq!(
4352 unsafe {
4353 &(*(::std::ptr::null::<isdbt_desc_terrestrial_delivery_system>())).next as *const _
4354 as usize
4355 },
4356 2usize,
4357 concat!(
4358 "Offset of field: ",
4359 stringify!(isdbt_desc_terrestrial_delivery_system),
4360 "::",
4361 stringify!(next)
4362 )
4363 );
4364 assert_eq!(
4365 unsafe {
4366 &(*(::std::ptr::null::<isdbt_desc_terrestrial_delivery_system>())).frequency as *const _
4367 as usize
4368 },
4369 10usize,
4370 concat!(
4371 "Offset of field: ",
4372 stringify!(isdbt_desc_terrestrial_delivery_system),
4373 "::",
4374 stringify!(frequency)
4375 )
4376 );
4377 assert_eq!(
4378 unsafe {
4379 &(*(::std::ptr::null::<isdbt_desc_terrestrial_delivery_system>())).num_freqs as *const _
4380 as usize
4381 },
4382 18usize,
4383 concat!(
4384 "Offset of field: ",
4385 stringify!(isdbt_desc_terrestrial_delivery_system),
4386 "::",
4387 stringify!(num_freqs)
4388 )
4389 );
4390}
4391extern "C" {
4392 pub fn isdbt_desc_delivery_init(
4393 parms: *mut dvb_v5_fe_parms,
4394 buf: *const u8,
4395 desc: *mut dvb_desc,
4396 ) -> ::std::os::raw::c_int;
4397}
4398extern "C" {
4399 pub fn isdbt_desc_delivery_print(parms: *mut dvb_v5_fe_parms, desc: *const dvb_desc);
4400}
4401extern "C" {
4402 pub fn isdbt_desc_delivery_free(desc: *mut dvb_desc);
4403}
4404extern "C" {
4405 pub static mut isdbt_interval: [u32; 0usize];
4406}
4407extern "C" {
4408 pub static mut isdbt_mode: [u32; 0usize];
4409}
4410#[repr(C, packed)]
4411#[derive(Debug, Copy, Clone)]
4412pub struct dvb_desc_language {
4413 pub type_: u8,
4414 pub length: u8,
4415 pub next: *mut dvb_desc,
4416 pub language: [::std::os::raw::c_uchar; 4usize],
4417 pub audio_type: u8,
4418}
4419#[test]
4420fn bindgen_test_layout_dvb_desc_language() {
4421 assert_eq!(
4422 ::std::mem::size_of::<dvb_desc_language>(),
4423 15usize,
4424 concat!("Size of: ", stringify!(dvb_desc_language))
4425 );
4426 assert_eq!(
4427 ::std::mem::align_of::<dvb_desc_language>(),
4428 1usize,
4429 concat!("Alignment of ", stringify!(dvb_desc_language))
4430 );
4431 assert_eq!(
4432 unsafe { &(*(::std::ptr::null::<dvb_desc_language>())).type_ as *const _ as usize },
4433 0usize,
4434 concat!(
4435 "Offset of field: ",
4436 stringify!(dvb_desc_language),
4437 "::",
4438 stringify!(type_)
4439 )
4440 );
4441 assert_eq!(
4442 unsafe { &(*(::std::ptr::null::<dvb_desc_language>())).length as *const _ as usize },
4443 1usize,
4444 concat!(
4445 "Offset of field: ",
4446 stringify!(dvb_desc_language),
4447 "::",
4448 stringify!(length)
4449 )
4450 );
4451 assert_eq!(
4452 unsafe { &(*(::std::ptr::null::<dvb_desc_language>())).next as *const _ as usize },
4453 2usize,
4454 concat!(
4455 "Offset of field: ",
4456 stringify!(dvb_desc_language),
4457 "::",
4458 stringify!(next)
4459 )
4460 );
4461 assert_eq!(
4462 unsafe { &(*(::std::ptr::null::<dvb_desc_language>())).language as *const _ as usize },
4463 10usize,
4464 concat!(
4465 "Offset of field: ",
4466 stringify!(dvb_desc_language),
4467 "::",
4468 stringify!(language)
4469 )
4470 );
4471 assert_eq!(
4472 unsafe { &(*(::std::ptr::null::<dvb_desc_language>())).audio_type as *const _ as usize },
4473 14usize,
4474 concat!(
4475 "Offset of field: ",
4476 stringify!(dvb_desc_language),
4477 "::",
4478 stringify!(audio_type)
4479 )
4480 );
4481}
4482extern "C" {
4483 pub fn dvb_desc_language_init(
4484 parms: *mut dvb_v5_fe_parms,
4485 buf: *const u8,
4486 desc: *mut dvb_desc,
4487 ) -> ::std::os::raw::c_int;
4488}
4489extern "C" {
4490 pub fn dvb_desc_language_print(parms: *mut dvb_v5_fe_parms, desc: *const dvb_desc);
4491}
4492#[repr(C, packed)]
4493#[derive(Copy, Clone)]
4494pub struct dvb_desc_logical_channel_number {
4495 pub service_id: u16,
4496 pub __bindgen_anon_1: dvb_desc_logical_channel_number__bindgen_ty_1,
4497}
4498#[repr(C, packed)]
4499#[derive(Copy, Clone)]
4500pub union dvb_desc_logical_channel_number__bindgen_ty_1 {
4501 pub bitfield: u16,
4502 pub __bindgen_anon_1: dvb_desc_logical_channel_number__bindgen_ty_1__bindgen_ty_1,
4503 _bindgen_union_align: [u8; 2usize],
4504}
4505#[repr(C, packed)]
4506#[derive(Debug, Copy, Clone)]
4507pub struct dvb_desc_logical_channel_number__bindgen_ty_1__bindgen_ty_1 {
4508 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize], u8>,
4509}
4510#[test]
4511fn bindgen_test_layout_dvb_desc_logical_channel_number__bindgen_ty_1__bindgen_ty_1() {
4512 assert_eq!(
4513 ::std::mem::size_of::<dvb_desc_logical_channel_number__bindgen_ty_1__bindgen_ty_1>(),
4514 2usize,
4515 concat!(
4516 "Size of: ",
4517 stringify!(dvb_desc_logical_channel_number__bindgen_ty_1__bindgen_ty_1)
4518 )
4519 );
4520 assert_eq!(
4521 ::std::mem::align_of::<dvb_desc_logical_channel_number__bindgen_ty_1__bindgen_ty_1>(),
4522 1usize,
4523 concat!(
4524 "Alignment of ",
4525 stringify!(dvb_desc_logical_channel_number__bindgen_ty_1__bindgen_ty_1)
4526 )
4527 );
4528}
4529impl dvb_desc_logical_channel_number__bindgen_ty_1__bindgen_ty_1 {
4530 #[inline]
4531 pub fn logical_channel_number(&self) -> u16 {
4532 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 10u8) as u16) }
4533 }
4534 #[inline]
4535 pub fn set_logical_channel_number(&mut self, val: u16) {
4536 unsafe {
4537 let val: u16 = ::std::mem::transmute(val);
4538 self._bitfield_1.set(0usize, 10u8, val as u64)
4539 }
4540 }
4541 #[inline]
4542 pub fn reserved(&self) -> u16 {
4543 unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 5u8) as u16) }
4544 }
4545 #[inline]
4546 pub fn set_reserved(&mut self, val: u16) {
4547 unsafe {
4548 let val: u16 = ::std::mem::transmute(val);
4549 self._bitfield_1.set(10usize, 5u8, val as u64)
4550 }
4551 }
4552 #[inline]
4553 pub fn visible_service_flag(&self) -> u16 {
4554 unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u16) }
4555 }
4556 #[inline]
4557 pub fn set_visible_service_flag(&mut self, val: u16) {
4558 unsafe {
4559 let val: u16 = ::std::mem::transmute(val);
4560 self._bitfield_1.set(15usize, 1u8, val as u64)
4561 }
4562 }
4563 #[inline]
4564 pub fn new_bitfield_1(
4565 logical_channel_number: u16,
4566 reserved: u16,
4567 visible_service_flag: u16,
4568 ) -> __BindgenBitfieldUnit<[u8; 2usize], u8> {
4569 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize], u8> =
4570 Default::default();
4571 __bindgen_bitfield_unit.set(0usize, 10u8, {
4572 let logical_channel_number: u16 =
4573 unsafe { ::std::mem::transmute(logical_channel_number) };
4574 logical_channel_number as u64
4575 });
4576 __bindgen_bitfield_unit.set(10usize, 5u8, {
4577 let reserved: u16 = unsafe { ::std::mem::transmute(reserved) };
4578 reserved as u64
4579 });
4580 __bindgen_bitfield_unit.set(15usize, 1u8, {
4581 let visible_service_flag: u16 = unsafe { ::std::mem::transmute(visible_service_flag) };
4582 visible_service_flag as u64
4583 });
4584 __bindgen_bitfield_unit
4585 }
4586}
4587#[test]
4588fn bindgen_test_layout_dvb_desc_logical_channel_number__bindgen_ty_1() {
4589 assert_eq!(
4590 ::std::mem::size_of::<dvb_desc_logical_channel_number__bindgen_ty_1>(),
4591 2usize,
4592 concat!(
4593 "Size of: ",
4594 stringify!(dvb_desc_logical_channel_number__bindgen_ty_1)
4595 )
4596 );
4597 assert_eq!(
4598 ::std::mem::align_of::<dvb_desc_logical_channel_number__bindgen_ty_1>(),
4599 1usize,
4600 concat!(
4601 "Alignment of ",
4602 stringify!(dvb_desc_logical_channel_number__bindgen_ty_1)
4603 )
4604 );
4605 assert_eq!(
4606 unsafe {
4607 &(*(::std::ptr::null::<dvb_desc_logical_channel_number__bindgen_ty_1>())).bitfield
4608 as *const _ as usize
4609 },
4610 0usize,
4611 concat!(
4612 "Offset of field: ",
4613 stringify!(dvb_desc_logical_channel_number__bindgen_ty_1),
4614 "::",
4615 stringify!(bitfield)
4616 )
4617 );
4618}
4619#[test]
4620fn bindgen_test_layout_dvb_desc_logical_channel_number() {
4621 assert_eq!(
4622 ::std::mem::size_of::<dvb_desc_logical_channel_number>(),
4623 4usize,
4624 concat!("Size of: ", stringify!(dvb_desc_logical_channel_number))
4625 );
4626 assert_eq!(
4627 ::std::mem::align_of::<dvb_desc_logical_channel_number>(),
4628 1usize,
4629 concat!("Alignment of ", stringify!(dvb_desc_logical_channel_number))
4630 );
4631 assert_eq!(
4632 unsafe {
4633 &(*(::std::ptr::null::<dvb_desc_logical_channel_number>())).service_id as *const _
4634 as usize
4635 },
4636 0usize,
4637 concat!(
4638 "Offset of field: ",
4639 stringify!(dvb_desc_logical_channel_number),
4640 "::",
4641 stringify!(service_id)
4642 )
4643 );
4644}
4645#[repr(C, packed)]
4646#[derive(Debug, Copy, Clone)]
4647pub struct dvb_desc_logical_channel {
4648 pub type_: u8,
4649 pub length: u8,
4650 pub next: *mut dvb_desc,
4651 pub lcn: *mut dvb_desc_logical_channel_number,
4652}
4653#[test]
4654fn bindgen_test_layout_dvb_desc_logical_channel() {
4655 assert_eq!(
4656 ::std::mem::size_of::<dvb_desc_logical_channel>(),
4657 18usize,
4658 concat!("Size of: ", stringify!(dvb_desc_logical_channel))
4659 );
4660 assert_eq!(
4661 ::std::mem::align_of::<dvb_desc_logical_channel>(),
4662 1usize,
4663 concat!("Alignment of ", stringify!(dvb_desc_logical_channel))
4664 );
4665 assert_eq!(
4666 unsafe { &(*(::std::ptr::null::<dvb_desc_logical_channel>())).type_ as *const _ as usize },
4667 0usize,
4668 concat!(
4669 "Offset of field: ",
4670 stringify!(dvb_desc_logical_channel),
4671 "::",
4672 stringify!(type_)
4673 )
4674 );
4675 assert_eq!(
4676 unsafe { &(*(::std::ptr::null::<dvb_desc_logical_channel>())).length as *const _ as usize },
4677 1usize,
4678 concat!(
4679 "Offset of field: ",
4680 stringify!(dvb_desc_logical_channel),
4681 "::",
4682 stringify!(length)
4683 )
4684 );
4685 assert_eq!(
4686 unsafe { &(*(::std::ptr::null::<dvb_desc_logical_channel>())).next as *const _ as usize },
4687 2usize,
4688 concat!(
4689 "Offset of field: ",
4690 stringify!(dvb_desc_logical_channel),
4691 "::",
4692 stringify!(next)
4693 )
4694 );
4695 assert_eq!(
4696 unsafe { &(*(::std::ptr::null::<dvb_desc_logical_channel>())).lcn as *const _ as usize },
4697 10usize,
4698 concat!(
4699 "Offset of field: ",
4700 stringify!(dvb_desc_logical_channel),
4701 "::",
4702 stringify!(lcn)
4703 )
4704 );
4705}
4706extern "C" {
4707 pub fn dvb_desc_logical_channel_init(
4708 parms: *mut dvb_v5_fe_parms,
4709 buf: *const u8,
4710 desc: *mut dvb_desc,
4711 ) -> ::std::os::raw::c_int;
4712}
4713extern "C" {
4714 pub fn dvb_desc_logical_channel_print(parms: *mut dvb_v5_fe_parms, desc: *const dvb_desc);
4715}
4716extern "C" {
4717 pub fn dvb_desc_logical_channel_free(desc: *mut dvb_desc);
4718}
4719#[repr(C, packed)]
4720#[derive(Debug, Copy, Clone)]
4721pub struct dvb_desc_network_name {
4722 pub type_: u8,
4723 pub length: u8,
4724 pub next: *mut dvb_desc,
4725 pub network_name: *mut ::std::os::raw::c_char,
4726 pub network_name_emph: *mut ::std::os::raw::c_char,
4727}
4728#[test]
4729fn bindgen_test_layout_dvb_desc_network_name() {
4730 assert_eq!(
4731 ::std::mem::size_of::<dvb_desc_network_name>(),
4732 26usize,
4733 concat!("Size of: ", stringify!(dvb_desc_network_name))
4734 );
4735 assert_eq!(
4736 ::std::mem::align_of::<dvb_desc_network_name>(),
4737 1usize,
4738 concat!("Alignment of ", stringify!(dvb_desc_network_name))
4739 );
4740 assert_eq!(
4741 unsafe { &(*(::std::ptr::null::<dvb_desc_network_name>())).type_ as *const _ as usize },
4742 0usize,
4743 concat!(
4744 "Offset of field: ",
4745 stringify!(dvb_desc_network_name),
4746 "::",
4747 stringify!(type_)
4748 )
4749 );
4750 assert_eq!(
4751 unsafe { &(*(::std::ptr::null::<dvb_desc_network_name>())).length as *const _ as usize },
4752 1usize,
4753 concat!(
4754 "Offset of field: ",
4755 stringify!(dvb_desc_network_name),
4756 "::",
4757 stringify!(length)
4758 )
4759 );
4760 assert_eq!(
4761 unsafe { &(*(::std::ptr::null::<dvb_desc_network_name>())).next as *const _ as usize },
4762 2usize,
4763 concat!(
4764 "Offset of field: ",
4765 stringify!(dvb_desc_network_name),
4766 "::",
4767 stringify!(next)
4768 )
4769 );
4770 assert_eq!(
4771 unsafe {
4772 &(*(::std::ptr::null::<dvb_desc_network_name>())).network_name as *const _ as usize
4773 },
4774 10usize,
4775 concat!(
4776 "Offset of field: ",
4777 stringify!(dvb_desc_network_name),
4778 "::",
4779 stringify!(network_name)
4780 )
4781 );
4782 assert_eq!(
4783 unsafe {
4784 &(*(::std::ptr::null::<dvb_desc_network_name>())).network_name_emph as *const _ as usize
4785 },
4786 18usize,
4787 concat!(
4788 "Offset of field: ",
4789 stringify!(dvb_desc_network_name),
4790 "::",
4791 stringify!(network_name_emph)
4792 )
4793 );
4794}
4795extern "C" {
4796 pub fn dvb_desc_network_name_init(
4797 parms: *mut dvb_v5_fe_parms,
4798 buf: *const u8,
4799 desc: *mut dvb_desc,
4800 ) -> ::std::os::raw::c_int;
4801}
4802extern "C" {
4803 pub fn dvb_desc_network_name_print(parms: *mut dvb_v5_fe_parms, desc: *const dvb_desc);
4804}
4805extern "C" {
4806 pub fn dvb_desc_network_name_free(desc: *mut dvb_desc);
4807}
4808#[repr(C, packed)]
4809#[derive(Debug, Copy, Clone)]
4810pub struct isdb_partial_reception_service_id {
4811 pub service_id: u16,
4812}
4813#[test]
4814fn bindgen_test_layout_isdb_partial_reception_service_id() {
4815 assert_eq!(
4816 ::std::mem::size_of::<isdb_partial_reception_service_id>(),
4817 2usize,
4818 concat!("Size of: ", stringify!(isdb_partial_reception_service_id))
4819 );
4820 assert_eq!(
4821 ::std::mem::align_of::<isdb_partial_reception_service_id>(),
4822 1usize,
4823 concat!(
4824 "Alignment of ",
4825 stringify!(isdb_partial_reception_service_id)
4826 )
4827 );
4828 assert_eq!(
4829 unsafe {
4830 &(*(::std::ptr::null::<isdb_partial_reception_service_id>())).service_id as *const _
4831 as usize
4832 },
4833 0usize,
4834 concat!(
4835 "Offset of field: ",
4836 stringify!(isdb_partial_reception_service_id),
4837 "::",
4838 stringify!(service_id)
4839 )
4840 );
4841}
4842#[repr(C, packed)]
4843#[derive(Debug, Copy, Clone)]
4844pub struct isdb_desc_partial_reception {
4845 pub type_: u8,
4846 pub length: u8,
4847 pub next: *mut dvb_desc,
4848 pub partial_reception: *mut isdb_partial_reception_service_id,
4849}
4850#[test]
4851fn bindgen_test_layout_isdb_desc_partial_reception() {
4852 assert_eq!(
4853 ::std::mem::size_of::<isdb_desc_partial_reception>(),
4854 18usize,
4855 concat!("Size of: ", stringify!(isdb_desc_partial_reception))
4856 );
4857 assert_eq!(
4858 ::std::mem::align_of::<isdb_desc_partial_reception>(),
4859 1usize,
4860 concat!("Alignment of ", stringify!(isdb_desc_partial_reception))
4861 );
4862 assert_eq!(
4863 unsafe {
4864 &(*(::std::ptr::null::<isdb_desc_partial_reception>())).type_ as *const _ as usize
4865 },
4866 0usize,
4867 concat!(
4868 "Offset of field: ",
4869 stringify!(isdb_desc_partial_reception),
4870 "::",
4871 stringify!(type_)
4872 )
4873 );
4874 assert_eq!(
4875 unsafe {
4876 &(*(::std::ptr::null::<isdb_desc_partial_reception>())).length as *const _ as usize
4877 },
4878 1usize,
4879 concat!(
4880 "Offset of field: ",
4881 stringify!(isdb_desc_partial_reception),
4882 "::",
4883 stringify!(length)
4884 )
4885 );
4886 assert_eq!(
4887 unsafe {
4888 &(*(::std::ptr::null::<isdb_desc_partial_reception>())).next as *const _ as usize
4889 },
4890 2usize,
4891 concat!(
4892 "Offset of field: ",
4893 stringify!(isdb_desc_partial_reception),
4894 "::",
4895 stringify!(next)
4896 )
4897 );
4898 assert_eq!(
4899 unsafe {
4900 &(*(::std::ptr::null::<isdb_desc_partial_reception>())).partial_reception as *const _
4901 as usize
4902 },
4903 10usize,
4904 concat!(
4905 "Offset of field: ",
4906 stringify!(isdb_desc_partial_reception),
4907 "::",
4908 stringify!(partial_reception)
4909 )
4910 );
4911}
4912extern "C" {
4913 pub fn isdb_desc_partial_reception_init(
4914 parms: *mut dvb_v5_fe_parms,
4915 buf: *const u8,
4916 desc: *mut dvb_desc,
4917 ) -> ::std::os::raw::c_int;
4918}
4919extern "C" {
4920 pub fn isdb_desc_partial_reception_print(parms: *mut dvb_v5_fe_parms, desc: *const dvb_desc);
4921}
4922extern "C" {
4923 pub fn isdb_desc_partial_reception_free(desc: *mut dvb_desc);
4924}
4925#[repr(C, packed)]
4926#[derive(Copy, Clone)]
4927pub struct dvb_desc_sat {
4928 pub type_: u8,
4929 pub length: u8,
4930 pub next: *mut dvb_desc,
4931 pub frequency: u32,
4932 pub orbit: u16,
4933 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize], u8>,
4934 pub __bindgen_anon_1: dvb_desc_sat__bindgen_ty_1,
4935}
4936#[repr(C, packed)]
4937#[derive(Copy, Clone)]
4938pub union dvb_desc_sat__bindgen_ty_1 {
4939 pub bitfield: u32,
4940 pub __bindgen_anon_1: dvb_desc_sat__bindgen_ty_1__bindgen_ty_1,
4941 _bindgen_union_align: [u8; 4usize],
4942}
4943#[repr(C, packed)]
4944#[derive(Debug, Copy, Clone)]
4945pub struct dvb_desc_sat__bindgen_ty_1__bindgen_ty_1 {
4946 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize], u8>,
4947}
4948#[test]
4949fn bindgen_test_layout_dvb_desc_sat__bindgen_ty_1__bindgen_ty_1() {
4950 assert_eq!(
4951 ::std::mem::size_of::<dvb_desc_sat__bindgen_ty_1__bindgen_ty_1>(),
4952 4usize,
4953 concat!(
4954 "Size of: ",
4955 stringify!(dvb_desc_sat__bindgen_ty_1__bindgen_ty_1)
4956 )
4957 );
4958 assert_eq!(
4959 ::std::mem::align_of::<dvb_desc_sat__bindgen_ty_1__bindgen_ty_1>(),
4960 1usize,
4961 concat!(
4962 "Alignment of ",
4963 stringify!(dvb_desc_sat__bindgen_ty_1__bindgen_ty_1)
4964 )
4965 );
4966}
4967impl dvb_desc_sat__bindgen_ty_1__bindgen_ty_1 {
4968 #[inline]
4969 pub fn fec(&self) -> u32 {
4970 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u32) }
4971 }
4972 #[inline]
4973 pub fn set_fec(&mut self, val: u32) {
4974 unsafe {
4975 let val: u32 = ::std::mem::transmute(val);
4976 self._bitfield_1.set(0usize, 4u8, val as u64)
4977 }
4978 }
4979 #[inline]
4980 pub fn symbol_rate(&self) -> u32 {
4981 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 28u8) as u32) }
4982 }
4983 #[inline]
4984 pub fn set_symbol_rate(&mut self, val: u32) {
4985 unsafe {
4986 let val: u32 = ::std::mem::transmute(val);
4987 self._bitfield_1.set(4usize, 28u8, val as u64)
4988 }
4989 }
4990 #[inline]
4991 pub fn new_bitfield_1(fec: u32, symbol_rate: u32) -> __BindgenBitfieldUnit<[u8; 4usize], u8> {
4992 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize], u8> =
4993 Default::default();
4994 __bindgen_bitfield_unit.set(0usize, 4u8, {
4995 let fec: u32 = unsafe { ::std::mem::transmute(fec) };
4996 fec as u64
4997 });
4998 __bindgen_bitfield_unit.set(4usize, 28u8, {
4999 let symbol_rate: u32 = unsafe { ::std::mem::transmute(symbol_rate) };
5000 symbol_rate as u64
5001 });
5002 __bindgen_bitfield_unit
5003 }
5004}
5005#[test]
5006fn bindgen_test_layout_dvb_desc_sat__bindgen_ty_1() {
5007 assert_eq!(
5008 ::std::mem::size_of::<dvb_desc_sat__bindgen_ty_1>(),
5009 4usize,
5010 concat!("Size of: ", stringify!(dvb_desc_sat__bindgen_ty_1))
5011 );
5012 assert_eq!(
5013 ::std::mem::align_of::<dvb_desc_sat__bindgen_ty_1>(),
5014 1usize,
5015 concat!("Alignment of ", stringify!(dvb_desc_sat__bindgen_ty_1))
5016 );
5017 assert_eq!(
5018 unsafe {
5019 &(*(::std::ptr::null::<dvb_desc_sat__bindgen_ty_1>())).bitfield as *const _ as usize
5020 },
5021 0usize,
5022 concat!(
5023 "Offset of field: ",
5024 stringify!(dvb_desc_sat__bindgen_ty_1),
5025 "::",
5026 stringify!(bitfield)
5027 )
5028 );
5029}
5030#[test]
5031fn bindgen_test_layout_dvb_desc_sat() {
5032 assert_eq!(
5033 ::std::mem::size_of::<dvb_desc_sat>(),
5034 21usize,
5035 concat!("Size of: ", stringify!(dvb_desc_sat))
5036 );
5037 assert_eq!(
5038 ::std::mem::align_of::<dvb_desc_sat>(),
5039 1usize,
5040 concat!("Alignment of ", stringify!(dvb_desc_sat))
5041 );
5042 assert_eq!(
5043 unsafe { &(*(::std::ptr::null::<dvb_desc_sat>())).type_ as *const _ as usize },
5044 0usize,
5045 concat!(
5046 "Offset of field: ",
5047 stringify!(dvb_desc_sat),
5048 "::",
5049 stringify!(type_)
5050 )
5051 );
5052 assert_eq!(
5053 unsafe { &(*(::std::ptr::null::<dvb_desc_sat>())).length as *const _ as usize },
5054 1usize,
5055 concat!(
5056 "Offset of field: ",
5057 stringify!(dvb_desc_sat),
5058 "::",
5059 stringify!(length)
5060 )
5061 );
5062 assert_eq!(
5063 unsafe { &(*(::std::ptr::null::<dvb_desc_sat>())).next as *const _ as usize },
5064 2usize,
5065 concat!(
5066 "Offset of field: ",
5067 stringify!(dvb_desc_sat),
5068 "::",
5069 stringify!(next)
5070 )
5071 );
5072 assert_eq!(
5073 unsafe { &(*(::std::ptr::null::<dvb_desc_sat>())).frequency as *const _ as usize },
5074 10usize,
5075 concat!(
5076 "Offset of field: ",
5077 stringify!(dvb_desc_sat),
5078 "::",
5079 stringify!(frequency)
5080 )
5081 );
5082 assert_eq!(
5083 unsafe { &(*(::std::ptr::null::<dvb_desc_sat>())).orbit as *const _ as usize },
5084 14usize,
5085 concat!(
5086 "Offset of field: ",
5087 stringify!(dvb_desc_sat),
5088 "::",
5089 stringify!(orbit)
5090 )
5091 );
5092}
5093impl dvb_desc_sat {
5094 #[inline]
5095 pub fn modulation_type(&self) -> u8 {
5096 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u8) }
5097 }
5098 #[inline]
5099 pub fn set_modulation_type(&mut self, val: u8) {
5100 unsafe {
5101 let val: u8 = ::std::mem::transmute(val);
5102 self._bitfield_1.set(0usize, 2u8, val as u64)
5103 }
5104 }
5105 #[inline]
5106 pub fn modulation_system(&self) -> u8 {
5107 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) }
5108 }
5109 #[inline]
5110 pub fn set_modulation_system(&mut self, val: u8) {
5111 unsafe {
5112 let val: u8 = ::std::mem::transmute(val);
5113 self._bitfield_1.set(2usize, 1u8, val as u64)
5114 }
5115 }
5116 #[inline]
5117 pub fn roll_off(&self) -> u8 {
5118 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 2u8) as u8) }
5119 }
5120 #[inline]
5121 pub fn set_roll_off(&mut self, val: u8) {
5122 unsafe {
5123 let val: u8 = ::std::mem::transmute(val);
5124 self._bitfield_1.set(3usize, 2u8, val as u64)
5125 }
5126 }
5127 #[inline]
5128 pub fn polarization(&self) -> u8 {
5129 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 2u8) as u8) }
5130 }
5131 #[inline]
5132 pub fn set_polarization(&mut self, val: u8) {
5133 unsafe {
5134 let val: u8 = ::std::mem::transmute(val);
5135 self._bitfield_1.set(5usize, 2u8, val as u64)
5136 }
5137 }
5138 #[inline]
5139 pub fn west_east(&self) -> u8 {
5140 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u8) }
5141 }
5142 #[inline]
5143 pub fn set_west_east(&mut self, val: u8) {
5144 unsafe {
5145 let val: u8 = ::std::mem::transmute(val);
5146 self._bitfield_1.set(7usize, 1u8, val as u64)
5147 }
5148 }
5149 #[inline]
5150 pub fn new_bitfield_1(
5151 modulation_type: u8,
5152 modulation_system: u8,
5153 roll_off: u8,
5154 polarization: u8,
5155 west_east: u8,
5156 ) -> __BindgenBitfieldUnit<[u8; 1usize], u8> {
5157 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize], u8> =
5158 Default::default();
5159 __bindgen_bitfield_unit.set(0usize, 2u8, {
5160 let modulation_type: u8 = unsafe { ::std::mem::transmute(modulation_type) };
5161 modulation_type as u64
5162 });
5163 __bindgen_bitfield_unit.set(2usize, 1u8, {
5164 let modulation_system: u8 = unsafe { ::std::mem::transmute(modulation_system) };
5165 modulation_system as u64
5166 });
5167 __bindgen_bitfield_unit.set(3usize, 2u8, {
5168 let roll_off: u8 = unsafe { ::std::mem::transmute(roll_off) };
5169 roll_off as u64
5170 });
5171 __bindgen_bitfield_unit.set(5usize, 2u8, {
5172 let polarization: u8 = unsafe { ::std::mem::transmute(polarization) };
5173 polarization as u64
5174 });
5175 __bindgen_bitfield_unit.set(7usize, 1u8, {
5176 let west_east: u8 = unsafe { ::std::mem::transmute(west_east) };
5177 west_east as u64
5178 });
5179 __bindgen_bitfield_unit
5180 }
5181}
5182extern "C" {
5183 pub fn dvb_desc_sat_init(
5184 parms: *mut dvb_v5_fe_parms,
5185 buf: *const u8,
5186 desc: *mut dvb_desc,
5187 ) -> ::std::os::raw::c_int;
5188}
5189extern "C" {
5190 pub fn dvb_desc_sat_print(parms: *mut dvb_v5_fe_parms, desc: *const dvb_desc);
5191}
5192extern "C" {
5193 pub static mut dvbs_dvbc_dvbs_freq_inner: [::std::os::raw::c_uint; 0usize];
5194}
5195extern "C" {
5196 pub static mut dvbs_polarization: [::std::os::raw::c_uint; 0usize];
5197}
5198extern "C" {
5199 pub static mut dvbs_rolloff: [::std::os::raw::c_uint; 0usize];
5200}
5201extern "C" {
5202 pub static mut dvbs_modulation: [::std::os::raw::c_uint; 0usize];
5203}
5204#[repr(C, packed)]
5205#[derive(Debug, Copy, Clone)]
5206pub struct dvb_desc_service {
5207 pub type_: u8,
5208 pub length: u8,
5209 pub next: *mut dvb_desc,
5210 pub service_type: u8,
5211 pub name: *mut ::std::os::raw::c_char,
5212 pub name_emph: *mut ::std::os::raw::c_char,
5213 pub provider: *mut ::std::os::raw::c_char,
5214 pub provider_emph: *mut ::std::os::raw::c_char,
5215}
5216#[test]
5217fn bindgen_test_layout_dvb_desc_service() {
5218 assert_eq!(
5219 ::std::mem::size_of::<dvb_desc_service>(),
5220 43usize,
5221 concat!("Size of: ", stringify!(dvb_desc_service))
5222 );
5223 assert_eq!(
5224 ::std::mem::align_of::<dvb_desc_service>(),
5225 1usize,
5226 concat!("Alignment of ", stringify!(dvb_desc_service))
5227 );
5228 assert_eq!(
5229 unsafe { &(*(::std::ptr::null::<dvb_desc_service>())).type_ as *const _ as usize },
5230 0usize,
5231 concat!(
5232 "Offset of field: ",
5233 stringify!(dvb_desc_service),
5234 "::",
5235 stringify!(type_)
5236 )
5237 );
5238 assert_eq!(
5239 unsafe { &(*(::std::ptr::null::<dvb_desc_service>())).length as *const _ as usize },
5240 1usize,
5241 concat!(
5242 "Offset of field: ",
5243 stringify!(dvb_desc_service),
5244 "::",
5245 stringify!(length)
5246 )
5247 );
5248 assert_eq!(
5249 unsafe { &(*(::std::ptr::null::<dvb_desc_service>())).next as *const _ as usize },
5250 2usize,
5251 concat!(
5252 "Offset of field: ",
5253 stringify!(dvb_desc_service),
5254 "::",
5255 stringify!(next)
5256 )
5257 );
5258 assert_eq!(
5259 unsafe { &(*(::std::ptr::null::<dvb_desc_service>())).service_type as *const _ as usize },
5260 10usize,
5261 concat!(
5262 "Offset of field: ",
5263 stringify!(dvb_desc_service),
5264 "::",
5265 stringify!(service_type)
5266 )
5267 );
5268 assert_eq!(
5269 unsafe { &(*(::std::ptr::null::<dvb_desc_service>())).name as *const _ as usize },
5270 11usize,
5271 concat!(
5272 "Offset of field: ",
5273 stringify!(dvb_desc_service),
5274 "::",
5275 stringify!(name)
5276 )
5277 );
5278 assert_eq!(
5279 unsafe { &(*(::std::ptr::null::<dvb_desc_service>())).name_emph as *const _ as usize },
5280 19usize,
5281 concat!(
5282 "Offset of field: ",
5283 stringify!(dvb_desc_service),
5284 "::",
5285 stringify!(name_emph)
5286 )
5287 );
5288 assert_eq!(
5289 unsafe { &(*(::std::ptr::null::<dvb_desc_service>())).provider as *const _ as usize },
5290 27usize,
5291 concat!(
5292 "Offset of field: ",
5293 stringify!(dvb_desc_service),
5294 "::",
5295 stringify!(provider)
5296 )
5297 );
5298 assert_eq!(
5299 unsafe { &(*(::std::ptr::null::<dvb_desc_service>())).provider_emph as *const _ as usize },
5300 35usize,
5301 concat!(
5302 "Offset of field: ",
5303 stringify!(dvb_desc_service),
5304 "::",
5305 stringify!(provider_emph)
5306 )
5307 );
5308}
5309extern "C" {
5310 pub fn dvb_desc_service_init(
5311 parms: *mut dvb_v5_fe_parms,
5312 buf: *const u8,
5313 desc: *mut dvb_desc,
5314 ) -> ::std::os::raw::c_int;
5315}
5316extern "C" {
5317 pub fn dvb_desc_service_print(parms: *mut dvb_v5_fe_parms, desc: *const dvb_desc);
5318}
5319extern "C" {
5320 pub fn dvb_desc_service_free(desc: *mut dvb_desc);
5321}
5322#[repr(C, packed)]
5323#[derive(Debug, Copy, Clone)]
5324pub struct dvb_desc_t2_delivery_subcell_old {
5325 pub cell_id_extension: u8,
5326 pub transposer_frequency: u16,
5327}
5328#[test]
5329fn bindgen_test_layout_dvb_desc_t2_delivery_subcell_old() {
5330 assert_eq!(
5331 ::std::mem::size_of::<dvb_desc_t2_delivery_subcell_old>(),
5332 3usize,
5333 concat!("Size of: ", stringify!(dvb_desc_t2_delivery_subcell_old))
5334 );
5335 assert_eq!(
5336 ::std::mem::align_of::<dvb_desc_t2_delivery_subcell_old>(),
5337 1usize,
5338 concat!(
5339 "Alignment of ",
5340 stringify!(dvb_desc_t2_delivery_subcell_old)
5341 )
5342 );
5343 assert_eq!(
5344 unsafe {
5345 &(*(::std::ptr::null::<dvb_desc_t2_delivery_subcell_old>())).cell_id_extension
5346 as *const _ as usize
5347 },
5348 0usize,
5349 concat!(
5350 "Offset of field: ",
5351 stringify!(dvb_desc_t2_delivery_subcell_old),
5352 "::",
5353 stringify!(cell_id_extension)
5354 )
5355 );
5356 assert_eq!(
5357 unsafe {
5358 &(*(::std::ptr::null::<dvb_desc_t2_delivery_subcell_old>())).transposer_frequency
5359 as *const _ as usize
5360 },
5361 1usize,
5362 concat!(
5363 "Offset of field: ",
5364 stringify!(dvb_desc_t2_delivery_subcell_old),
5365 "::",
5366 stringify!(transposer_frequency)
5367 )
5368 );
5369}
5370#[repr(C, packed)]
5371#[derive(Debug, Copy, Clone)]
5372pub struct dvb_desc_t2_delivery_subcell {
5373 pub cell_id_extension: u8,
5374 pub transposer_frequency: u32,
5375}
5376#[test]
5377fn bindgen_test_layout_dvb_desc_t2_delivery_subcell() {
5378 assert_eq!(
5379 ::std::mem::size_of::<dvb_desc_t2_delivery_subcell>(),
5380 5usize,
5381 concat!("Size of: ", stringify!(dvb_desc_t2_delivery_subcell))
5382 );
5383 assert_eq!(
5384 ::std::mem::align_of::<dvb_desc_t2_delivery_subcell>(),
5385 1usize,
5386 concat!("Alignment of ", stringify!(dvb_desc_t2_delivery_subcell))
5387 );
5388 assert_eq!(
5389 unsafe {
5390 &(*(::std::ptr::null::<dvb_desc_t2_delivery_subcell>())).cell_id_extension as *const _
5391 as usize
5392 },
5393 0usize,
5394 concat!(
5395 "Offset of field: ",
5396 stringify!(dvb_desc_t2_delivery_subcell),
5397 "::",
5398 stringify!(cell_id_extension)
5399 )
5400 );
5401 assert_eq!(
5402 unsafe {
5403 &(*(::std::ptr::null::<dvb_desc_t2_delivery_subcell>())).transposer_frequency
5404 as *const _ as usize
5405 },
5406 1usize,
5407 concat!(
5408 "Offset of field: ",
5409 stringify!(dvb_desc_t2_delivery_subcell),
5410 "::",
5411 stringify!(transposer_frequency)
5412 )
5413 );
5414}
5415#[repr(C, packed)]
5416#[derive(Debug, Copy, Clone)]
5417pub struct dvb_desc_t2_delivery_cell {
5418 pub cell_id: u16,
5419 pub num_freqs: ::std::os::raw::c_int,
5420 pub centre_frequency: *mut u32,
5421 pub subcel_length: u8,
5422 pub subcel: *mut dvb_desc_t2_delivery_subcell,
5423}
5424#[test]
5425fn bindgen_test_layout_dvb_desc_t2_delivery_cell() {
5426 assert_eq!(
5427 ::std::mem::size_of::<dvb_desc_t2_delivery_cell>(),
5428 23usize,
5429 concat!("Size of: ", stringify!(dvb_desc_t2_delivery_cell))
5430 );
5431 assert_eq!(
5432 ::std::mem::align_of::<dvb_desc_t2_delivery_cell>(),
5433 1usize,
5434 concat!("Alignment of ", stringify!(dvb_desc_t2_delivery_cell))
5435 );
5436 assert_eq!(
5437 unsafe {
5438 &(*(::std::ptr::null::<dvb_desc_t2_delivery_cell>())).cell_id as *const _ as usize
5439 },
5440 0usize,
5441 concat!(
5442 "Offset of field: ",
5443 stringify!(dvb_desc_t2_delivery_cell),
5444 "::",
5445 stringify!(cell_id)
5446 )
5447 );
5448 assert_eq!(
5449 unsafe {
5450 &(*(::std::ptr::null::<dvb_desc_t2_delivery_cell>())).num_freqs as *const _ as usize
5451 },
5452 2usize,
5453 concat!(
5454 "Offset of field: ",
5455 stringify!(dvb_desc_t2_delivery_cell),
5456 "::",
5457 stringify!(num_freqs)
5458 )
5459 );
5460 assert_eq!(
5461 unsafe {
5462 &(*(::std::ptr::null::<dvb_desc_t2_delivery_cell>())).centre_frequency as *const _
5463 as usize
5464 },
5465 6usize,
5466 concat!(
5467 "Offset of field: ",
5468 stringify!(dvb_desc_t2_delivery_cell),
5469 "::",
5470 stringify!(centre_frequency)
5471 )
5472 );
5473 assert_eq!(
5474 unsafe {
5475 &(*(::std::ptr::null::<dvb_desc_t2_delivery_cell>())).subcel_length as *const _ as usize
5476 },
5477 14usize,
5478 concat!(
5479 "Offset of field: ",
5480 stringify!(dvb_desc_t2_delivery_cell),
5481 "::",
5482 stringify!(subcel_length)
5483 )
5484 );
5485 assert_eq!(
5486 unsafe {
5487 &(*(::std::ptr::null::<dvb_desc_t2_delivery_cell>())).subcel as *const _ as usize
5488 },
5489 15usize,
5490 concat!(
5491 "Offset of field: ",
5492 stringify!(dvb_desc_t2_delivery_cell),
5493 "::",
5494 stringify!(subcel)
5495 )
5496 );
5497}
5498#[repr(C, packed)]
5499#[derive(Copy, Clone)]
5500pub struct dvb_desc_t2_delivery {
5501 pub plp_id: u8,
5502 pub system_id: u16,
5503 pub __bindgen_anon_1: dvb_desc_t2_delivery__bindgen_ty_1,
5504 pub centre_frequency: *mut u32,
5505 pub frequency_loop_length: u8,
5506 pub subcel_info_loop_length: u8,
5507 pub subcell: *mut dvb_desc_t2_delivery_subcell_old,
5508 pub num_cell: ::std::os::raw::c_uint,
5509 pub cell: *mut dvb_desc_t2_delivery_cell,
5510}
5511#[repr(C, packed)]
5512#[derive(Copy, Clone)]
5513pub union dvb_desc_t2_delivery__bindgen_ty_1 {
5514 pub bitfield: u16,
5515 pub __bindgen_anon_1: dvb_desc_t2_delivery__bindgen_ty_1__bindgen_ty_1,
5516 _bindgen_union_align: [u8; 2usize],
5517}
5518#[repr(C, packed)]
5519#[derive(Debug, Copy, Clone)]
5520pub struct dvb_desc_t2_delivery__bindgen_ty_1__bindgen_ty_1 {
5521 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize], u8>,
5522}
5523#[test]
5524fn bindgen_test_layout_dvb_desc_t2_delivery__bindgen_ty_1__bindgen_ty_1() {
5525 assert_eq!(
5526 ::std::mem::size_of::<dvb_desc_t2_delivery__bindgen_ty_1__bindgen_ty_1>(),
5527 2usize,
5528 concat!(
5529 "Size of: ",
5530 stringify!(dvb_desc_t2_delivery__bindgen_ty_1__bindgen_ty_1)
5531 )
5532 );
5533 assert_eq!(
5534 ::std::mem::align_of::<dvb_desc_t2_delivery__bindgen_ty_1__bindgen_ty_1>(),
5535 1usize,
5536 concat!(
5537 "Alignment of ",
5538 stringify!(dvb_desc_t2_delivery__bindgen_ty_1__bindgen_ty_1)
5539 )
5540 );
5541}
5542impl dvb_desc_t2_delivery__bindgen_ty_1__bindgen_ty_1 {
5543 #[inline]
5544 pub fn tfs_flag(&self) -> u16 {
5545 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u16) }
5546 }
5547 #[inline]
5548 pub fn set_tfs_flag(&mut self, val: u16) {
5549 unsafe {
5550 let val: u16 = ::std::mem::transmute(val);
5551 self._bitfield_1.set(0usize, 1u8, val as u64)
5552 }
5553 }
5554 #[inline]
5555 pub fn other_frequency_flag(&self) -> u16 {
5556 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u16) }
5557 }
5558 #[inline]
5559 pub fn set_other_frequency_flag(&mut self, val: u16) {
5560 unsafe {
5561 let val: u16 = ::std::mem::transmute(val);
5562 self._bitfield_1.set(1usize, 1u8, val as u64)
5563 }
5564 }
5565 #[inline]
5566 pub fn transmission_mode(&self) -> u16 {
5567 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 3u8) as u16) }
5568 }
5569 #[inline]
5570 pub fn set_transmission_mode(&mut self, val: u16) {
5571 unsafe {
5572 let val: u16 = ::std::mem::transmute(val);
5573 self._bitfield_1.set(2usize, 3u8, val as u64)
5574 }
5575 }
5576 #[inline]
5577 pub fn guard_interval(&self) -> u16 {
5578 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 3u8) as u16) }
5579 }
5580 #[inline]
5581 pub fn set_guard_interval(&mut self, val: u16) {
5582 unsafe {
5583 let val: u16 = ::std::mem::transmute(val);
5584 self._bitfield_1.set(5usize, 3u8, val as u64)
5585 }
5586 }
5587 #[inline]
5588 pub fn reserved(&self) -> u16 {
5589 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 2u8) as u16) }
5590 }
5591 #[inline]
5592 pub fn set_reserved(&mut self, val: u16) {
5593 unsafe {
5594 let val: u16 = ::std::mem::transmute(val);
5595 self._bitfield_1.set(8usize, 2u8, val as u64)
5596 }
5597 }
5598 #[inline]
5599 pub fn bandwidth(&self) -> u16 {
5600 unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 4u8) as u16) }
5601 }
5602 #[inline]
5603 pub fn set_bandwidth(&mut self, val: u16) {
5604 unsafe {
5605 let val: u16 = ::std::mem::transmute(val);
5606 self._bitfield_1.set(10usize, 4u8, val as u64)
5607 }
5608 }
5609 #[inline]
5610 pub fn SISO_MISO(&self) -> u16 {
5611 unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 2u8) as u16) }
5612 }
5613 #[inline]
5614 pub fn set_SISO_MISO(&mut self, val: u16) {
5615 unsafe {
5616 let val: u16 = ::std::mem::transmute(val);
5617 self._bitfield_1.set(14usize, 2u8, val as u64)
5618 }
5619 }
5620 #[inline]
5621 pub fn new_bitfield_1(
5622 tfs_flag: u16,
5623 other_frequency_flag: u16,
5624 transmission_mode: u16,
5625 guard_interval: u16,
5626 reserved: u16,
5627 bandwidth: u16,
5628 SISO_MISO: u16,
5629 ) -> __BindgenBitfieldUnit<[u8; 2usize], u8> {
5630 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize], u8> =
5631 Default::default();
5632 __bindgen_bitfield_unit.set(0usize, 1u8, {
5633 let tfs_flag: u16 = unsafe { ::std::mem::transmute(tfs_flag) };
5634 tfs_flag as u64
5635 });
5636 __bindgen_bitfield_unit.set(1usize, 1u8, {
5637 let other_frequency_flag: u16 = unsafe { ::std::mem::transmute(other_frequency_flag) };
5638 other_frequency_flag as u64
5639 });
5640 __bindgen_bitfield_unit.set(2usize, 3u8, {
5641 let transmission_mode: u16 = unsafe { ::std::mem::transmute(transmission_mode) };
5642 transmission_mode as u64
5643 });
5644 __bindgen_bitfield_unit.set(5usize, 3u8, {
5645 let guard_interval: u16 = unsafe { ::std::mem::transmute(guard_interval) };
5646 guard_interval as u64
5647 });
5648 __bindgen_bitfield_unit.set(8usize, 2u8, {
5649 let reserved: u16 = unsafe { ::std::mem::transmute(reserved) };
5650 reserved as u64
5651 });
5652 __bindgen_bitfield_unit.set(10usize, 4u8, {
5653 let bandwidth: u16 = unsafe { ::std::mem::transmute(bandwidth) };
5654 bandwidth as u64
5655 });
5656 __bindgen_bitfield_unit.set(14usize, 2u8, {
5657 let SISO_MISO: u16 = unsafe { ::std::mem::transmute(SISO_MISO) };
5658 SISO_MISO as u64
5659 });
5660 __bindgen_bitfield_unit
5661 }
5662}
5663#[test]
5664fn bindgen_test_layout_dvb_desc_t2_delivery__bindgen_ty_1() {
5665 assert_eq!(
5666 ::std::mem::size_of::<dvb_desc_t2_delivery__bindgen_ty_1>(),
5667 2usize,
5668 concat!("Size of: ", stringify!(dvb_desc_t2_delivery__bindgen_ty_1))
5669 );
5670 assert_eq!(
5671 ::std::mem::align_of::<dvb_desc_t2_delivery__bindgen_ty_1>(),
5672 1usize,
5673 concat!(
5674 "Alignment of ",
5675 stringify!(dvb_desc_t2_delivery__bindgen_ty_1)
5676 )
5677 );
5678 assert_eq!(
5679 unsafe {
5680 &(*(::std::ptr::null::<dvb_desc_t2_delivery__bindgen_ty_1>())).bitfield as *const _
5681 as usize
5682 },
5683 0usize,
5684 concat!(
5685 "Offset of field: ",
5686 stringify!(dvb_desc_t2_delivery__bindgen_ty_1),
5687 "::",
5688 stringify!(bitfield)
5689 )
5690 );
5691}
5692#[test]
5693fn bindgen_test_layout_dvb_desc_t2_delivery() {
5694 assert_eq!(
5695 ::std::mem::size_of::<dvb_desc_t2_delivery>(),
5696 35usize,
5697 concat!("Size of: ", stringify!(dvb_desc_t2_delivery))
5698 );
5699 assert_eq!(
5700 ::std::mem::align_of::<dvb_desc_t2_delivery>(),
5701 1usize,
5702 concat!("Alignment of ", stringify!(dvb_desc_t2_delivery))
5703 );
5704 assert_eq!(
5705 unsafe { &(*(::std::ptr::null::<dvb_desc_t2_delivery>())).plp_id as *const _ as usize },
5706 0usize,
5707 concat!(
5708 "Offset of field: ",
5709 stringify!(dvb_desc_t2_delivery),
5710 "::",
5711 stringify!(plp_id)
5712 )
5713 );
5714 assert_eq!(
5715 unsafe { &(*(::std::ptr::null::<dvb_desc_t2_delivery>())).system_id as *const _ as usize },
5716 1usize,
5717 concat!(
5718 "Offset of field: ",
5719 stringify!(dvb_desc_t2_delivery),
5720 "::",
5721 stringify!(system_id)
5722 )
5723 );
5724 assert_eq!(
5725 unsafe {
5726 &(*(::std::ptr::null::<dvb_desc_t2_delivery>())).centre_frequency as *const _ as usize
5727 },
5728 5usize,
5729 concat!(
5730 "Offset of field: ",
5731 stringify!(dvb_desc_t2_delivery),
5732 "::",
5733 stringify!(centre_frequency)
5734 )
5735 );
5736 assert_eq!(
5737 unsafe {
5738 &(*(::std::ptr::null::<dvb_desc_t2_delivery>())).frequency_loop_length as *const _
5739 as usize
5740 },
5741 13usize,
5742 concat!(
5743 "Offset of field: ",
5744 stringify!(dvb_desc_t2_delivery),
5745 "::",
5746 stringify!(frequency_loop_length)
5747 )
5748 );
5749 assert_eq!(
5750 unsafe {
5751 &(*(::std::ptr::null::<dvb_desc_t2_delivery>())).subcel_info_loop_length as *const _
5752 as usize
5753 },
5754 14usize,
5755 concat!(
5756 "Offset of field: ",
5757 stringify!(dvb_desc_t2_delivery),
5758 "::",
5759 stringify!(subcel_info_loop_length)
5760 )
5761 );
5762 assert_eq!(
5763 unsafe { &(*(::std::ptr::null::<dvb_desc_t2_delivery>())).subcell as *const _ as usize },
5764 15usize,
5765 concat!(
5766 "Offset of field: ",
5767 stringify!(dvb_desc_t2_delivery),
5768 "::",
5769 stringify!(subcell)
5770 )
5771 );
5772 assert_eq!(
5773 unsafe { &(*(::std::ptr::null::<dvb_desc_t2_delivery>())).num_cell as *const _ as usize },
5774 23usize,
5775 concat!(
5776 "Offset of field: ",
5777 stringify!(dvb_desc_t2_delivery),
5778 "::",
5779 stringify!(num_cell)
5780 )
5781 );
5782 assert_eq!(
5783 unsafe { &(*(::std::ptr::null::<dvb_desc_t2_delivery>())).cell as *const _ as usize },
5784 27usize,
5785 concat!(
5786 "Offset of field: ",
5787 stringify!(dvb_desc_t2_delivery),
5788 "::",
5789 stringify!(cell)
5790 )
5791 );
5792}
5793extern "C" {
5794 pub fn dvb_desc_t2_delivery_init(
5795 parms: *mut dvb_v5_fe_parms,
5796 buf: *const u8,
5797 ext: *mut dvb_extension_descriptor,
5798 desc: *mut ::std::os::raw::c_void,
5799 ) -> ::std::os::raw::c_int;
5800}
5801extern "C" {
5802 pub fn dvb_desc_t2_delivery_print(
5803 parms: *mut dvb_v5_fe_parms,
5804 ext: *const dvb_extension_descriptor,
5805 desc: *const ::std::os::raw::c_void,
5806 );
5807}
5808extern "C" {
5809 pub fn dvb_desc_t2_delivery_free(desc: *const ::std::os::raw::c_void);
5810}
5811extern "C" {
5812 pub static mut dvbt2_bw: [::std::os::raw::c_uint; 0usize];
5813}
5814extern "C" {
5815 pub static mut dvbt2_interval: [u32; 0usize];
5816}
5817extern "C" {
5818 pub static mut dvbt2_transmission_mode: [::std::os::raw::c_uint; 0usize];
5819}
5820#[repr(C, packed)]
5821#[derive(Debug, Copy, Clone)]
5822pub struct dvb_desc_terrestrial_delivery {
5823 pub type_: u8,
5824 pub length: u8,
5825 pub next: *mut dvb_desc,
5826 pub centre_frequency: u32,
5827 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 3usize], u8>,
5828 pub reserved_future_use2: u32,
5829}
5830#[test]
5831fn bindgen_test_layout_dvb_desc_terrestrial_delivery() {
5832 assert_eq!(
5833 ::std::mem::size_of::<dvb_desc_terrestrial_delivery>(),
5834 21usize,
5835 concat!("Size of: ", stringify!(dvb_desc_terrestrial_delivery))
5836 );
5837 assert_eq!(
5838 ::std::mem::align_of::<dvb_desc_terrestrial_delivery>(),
5839 1usize,
5840 concat!("Alignment of ", stringify!(dvb_desc_terrestrial_delivery))
5841 );
5842 assert_eq!(
5843 unsafe {
5844 &(*(::std::ptr::null::<dvb_desc_terrestrial_delivery>())).type_ as *const _ as usize
5845 },
5846 0usize,
5847 concat!(
5848 "Offset of field: ",
5849 stringify!(dvb_desc_terrestrial_delivery),
5850 "::",
5851 stringify!(type_)
5852 )
5853 );
5854 assert_eq!(
5855 unsafe {
5856 &(*(::std::ptr::null::<dvb_desc_terrestrial_delivery>())).length as *const _ as usize
5857 },
5858 1usize,
5859 concat!(
5860 "Offset of field: ",
5861 stringify!(dvb_desc_terrestrial_delivery),
5862 "::",
5863 stringify!(length)
5864 )
5865 );
5866 assert_eq!(
5867 unsafe {
5868 &(*(::std::ptr::null::<dvb_desc_terrestrial_delivery>())).next as *const _ as usize
5869 },
5870 2usize,
5871 concat!(
5872 "Offset of field: ",
5873 stringify!(dvb_desc_terrestrial_delivery),
5874 "::",
5875 stringify!(next)
5876 )
5877 );
5878 assert_eq!(
5879 unsafe {
5880 &(*(::std::ptr::null::<dvb_desc_terrestrial_delivery>())).centre_frequency as *const _
5881 as usize
5882 },
5883 10usize,
5884 concat!(
5885 "Offset of field: ",
5886 stringify!(dvb_desc_terrestrial_delivery),
5887 "::",
5888 stringify!(centre_frequency)
5889 )
5890 );
5891 assert_eq!(
5892 unsafe {
5893 &(*(::std::ptr::null::<dvb_desc_terrestrial_delivery>())).reserved_future_use2
5894 as *const _ as usize
5895 },
5896 17usize,
5897 concat!(
5898 "Offset of field: ",
5899 stringify!(dvb_desc_terrestrial_delivery),
5900 "::",
5901 stringify!(reserved_future_use2)
5902 )
5903 );
5904}
5905impl dvb_desc_terrestrial_delivery {
5906 #[inline]
5907 pub fn reserved_future_use1(&self) -> u8 {
5908 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u8) }
5909 }
5910 #[inline]
5911 pub fn set_reserved_future_use1(&mut self, val: u8) {
5912 unsafe {
5913 let val: u8 = ::std::mem::transmute(val);
5914 self._bitfield_1.set(0usize, 2u8, val as u64)
5915 }
5916 }
5917 #[inline]
5918 pub fn mpe_fec_indicator(&self) -> u8 {
5919 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) }
5920 }
5921 #[inline]
5922 pub fn set_mpe_fec_indicator(&mut self, val: u8) {
5923 unsafe {
5924 let val: u8 = ::std::mem::transmute(val);
5925 self._bitfield_1.set(2usize, 1u8, val as u64)
5926 }
5927 }
5928 #[inline]
5929 pub fn time_slice_indicator(&self) -> u8 {
5930 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8) }
5931 }
5932 #[inline]
5933 pub fn set_time_slice_indicator(&mut self, val: u8) {
5934 unsafe {
5935 let val: u8 = ::std::mem::transmute(val);
5936 self._bitfield_1.set(3usize, 1u8, val as u64)
5937 }
5938 }
5939 #[inline]
5940 pub fn priority(&self) -> u8 {
5941 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u8) }
5942 }
5943 #[inline]
5944 pub fn set_priority(&mut self, val: u8) {
5945 unsafe {
5946 let val: u8 = ::std::mem::transmute(val);
5947 self._bitfield_1.set(4usize, 1u8, val as u64)
5948 }
5949 }
5950 #[inline]
5951 pub fn bandwidth(&self) -> u8 {
5952 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 3u8) as u8) }
5953 }
5954 #[inline]
5955 pub fn set_bandwidth(&mut self, val: u8) {
5956 unsafe {
5957 let val: u8 = ::std::mem::transmute(val);
5958 self._bitfield_1.set(5usize, 3u8, val as u64)
5959 }
5960 }
5961 #[inline]
5962 pub fn code_rate_hp_stream(&self) -> u8 {
5963 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 3u8) as u8) }
5964 }
5965 #[inline]
5966 pub fn set_code_rate_hp_stream(&mut self, val: u8) {
5967 unsafe {
5968 let val: u8 = ::std::mem::transmute(val);
5969 self._bitfield_1.set(8usize, 3u8, val as u64)
5970 }
5971 }
5972 #[inline]
5973 pub fn hierarchy_information(&self) -> u8 {
5974 unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 3u8) as u8) }
5975 }
5976 #[inline]
5977 pub fn set_hierarchy_information(&mut self, val: u8) {
5978 unsafe {
5979 let val: u8 = ::std::mem::transmute(val);
5980 self._bitfield_1.set(11usize, 3u8, val as u64)
5981 }
5982 }
5983 #[inline]
5984 pub fn constellation(&self) -> u8 {
5985 unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 2u8) as u8) }
5986 }
5987 #[inline]
5988 pub fn set_constellation(&mut self, val: u8) {
5989 unsafe {
5990 let val: u8 = ::std::mem::transmute(val);
5991 self._bitfield_1.set(14usize, 2u8, val as u64)
5992 }
5993 }
5994 #[inline]
5995 pub fn other_frequency_flag(&self) -> u8 {
5996 unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u8) }
5997 }
5998 #[inline]
5999 pub fn set_other_frequency_flag(&mut self, val: u8) {
6000 unsafe {
6001 let val: u8 = ::std::mem::transmute(val);
6002 self._bitfield_1.set(16usize, 1u8, val as u64)
6003 }
6004 }
6005 #[inline]
6006 pub fn transmission_mode(&self) -> u8 {
6007 unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 2u8) as u8) }
6008 }
6009 #[inline]
6010 pub fn set_transmission_mode(&mut self, val: u8) {
6011 unsafe {
6012 let val: u8 = ::std::mem::transmute(val);
6013 self._bitfield_1.set(17usize, 2u8, val as u64)
6014 }
6015 }
6016 #[inline]
6017 pub fn guard_interval(&self) -> u8 {
6018 unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 2u8) as u8) }
6019 }
6020 #[inline]
6021 pub fn set_guard_interval(&mut self, val: u8) {
6022 unsafe {
6023 let val: u8 = ::std::mem::transmute(val);
6024 self._bitfield_1.set(19usize, 2u8, val as u64)
6025 }
6026 }
6027 #[inline]
6028 pub fn code_rate_lp_stream(&self) -> u8 {
6029 unsafe { ::std::mem::transmute(self._bitfield_1.get(21usize, 3u8) as u8) }
6030 }
6031 #[inline]
6032 pub fn set_code_rate_lp_stream(&mut self, val: u8) {
6033 unsafe {
6034 let val: u8 = ::std::mem::transmute(val);
6035 self._bitfield_1.set(21usize, 3u8, val as u64)
6036 }
6037 }
6038 #[inline]
6039 pub fn new_bitfield_1(
6040 reserved_future_use1: u8,
6041 mpe_fec_indicator: u8,
6042 time_slice_indicator: u8,
6043 priority: u8,
6044 bandwidth: u8,
6045 code_rate_hp_stream: u8,
6046 hierarchy_information: u8,
6047 constellation: u8,
6048 other_frequency_flag: u8,
6049 transmission_mode: u8,
6050 guard_interval: u8,
6051 code_rate_lp_stream: u8,
6052 ) -> __BindgenBitfieldUnit<[u8; 3usize], u8> {
6053 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 3usize], u8> =
6054 Default::default();
6055 __bindgen_bitfield_unit.set(0usize, 2u8, {
6056 let reserved_future_use1: u8 = unsafe { ::std::mem::transmute(reserved_future_use1) };
6057 reserved_future_use1 as u64
6058 });
6059 __bindgen_bitfield_unit.set(2usize, 1u8, {
6060 let mpe_fec_indicator: u8 = unsafe { ::std::mem::transmute(mpe_fec_indicator) };
6061 mpe_fec_indicator as u64
6062 });
6063 __bindgen_bitfield_unit.set(3usize, 1u8, {
6064 let time_slice_indicator: u8 = unsafe { ::std::mem::transmute(time_slice_indicator) };
6065 time_slice_indicator as u64
6066 });
6067 __bindgen_bitfield_unit.set(4usize, 1u8, {
6068 let priority: u8 = unsafe { ::std::mem::transmute(priority) };
6069 priority as u64
6070 });
6071 __bindgen_bitfield_unit.set(5usize, 3u8, {
6072 let bandwidth: u8 = unsafe { ::std::mem::transmute(bandwidth) };
6073 bandwidth as u64
6074 });
6075 __bindgen_bitfield_unit.set(8usize, 3u8, {
6076 let code_rate_hp_stream: u8 = unsafe { ::std::mem::transmute(code_rate_hp_stream) };
6077 code_rate_hp_stream as u64
6078 });
6079 __bindgen_bitfield_unit.set(11usize, 3u8, {
6080 let hierarchy_information: u8 = unsafe { ::std::mem::transmute(hierarchy_information) };
6081 hierarchy_information as u64
6082 });
6083 __bindgen_bitfield_unit.set(14usize, 2u8, {
6084 let constellation: u8 = unsafe { ::std::mem::transmute(constellation) };
6085 constellation as u64
6086 });
6087 __bindgen_bitfield_unit.set(16usize, 1u8, {
6088 let other_frequency_flag: u8 = unsafe { ::std::mem::transmute(other_frequency_flag) };
6089 other_frequency_flag as u64
6090 });
6091 __bindgen_bitfield_unit.set(17usize, 2u8, {
6092 let transmission_mode: u8 = unsafe { ::std::mem::transmute(transmission_mode) };
6093 transmission_mode as u64
6094 });
6095 __bindgen_bitfield_unit.set(19usize, 2u8, {
6096 let guard_interval: u8 = unsafe { ::std::mem::transmute(guard_interval) };
6097 guard_interval as u64
6098 });
6099 __bindgen_bitfield_unit.set(21usize, 3u8, {
6100 let code_rate_lp_stream: u8 = unsafe { ::std::mem::transmute(code_rate_lp_stream) };
6101 code_rate_lp_stream as u64
6102 });
6103 __bindgen_bitfield_unit
6104 }
6105}
6106extern "C" {
6107 pub fn dvb_desc_terrestrial_delivery_init(
6108 parms: *mut dvb_v5_fe_parms,
6109 buf: *const u8,
6110 desc: *mut dvb_desc,
6111 ) -> ::std::os::raw::c_int;
6112}
6113extern "C" {
6114 pub fn dvb_desc_terrestrial_delivery_print(parms: *mut dvb_v5_fe_parms, desc: *const dvb_desc);
6115}
6116extern "C" {
6117 pub static mut dvbt_bw: [::std::os::raw::c_uint; 0usize];
6118}
6119extern "C" {
6120 pub static mut dvbt_modulation: [::std::os::raw::c_uint; 0usize];
6121}
6122extern "C" {
6123 pub static mut dvbt_hierarchy: [::std::os::raw::c_uint; 0usize];
6124}
6125extern "C" {
6126 pub static mut dvbt_code_rate: [::std::os::raw::c_uint; 0usize];
6127}
6128extern "C" {
6129 pub static mut dvbt_interval: [u32; 0usize];
6130}
6131extern "C" {
6132 pub static mut dvbt_transmission_mode: [::std::os::raw::c_uint; 0usize];
6133}
6134#[repr(C, packed)]
6135#[derive(Debug, Copy, Clone)]
6136pub struct dvb_desc_ts_info_transmission_type {
6137 pub transmission_type_info: u8,
6138 pub num_of_service: u8,
6139}
6140#[test]
6141fn bindgen_test_layout_dvb_desc_ts_info_transmission_type() {
6142 assert_eq!(
6143 ::std::mem::size_of::<dvb_desc_ts_info_transmission_type>(),
6144 2usize,
6145 concat!("Size of: ", stringify!(dvb_desc_ts_info_transmission_type))
6146 );
6147 assert_eq!(
6148 ::std::mem::align_of::<dvb_desc_ts_info_transmission_type>(),
6149 1usize,
6150 concat!(
6151 "Alignment of ",
6152 stringify!(dvb_desc_ts_info_transmission_type)
6153 )
6154 );
6155 assert_eq!(
6156 unsafe {
6157 &(*(::std::ptr::null::<dvb_desc_ts_info_transmission_type>())).transmission_type_info
6158 as *const _ as usize
6159 },
6160 0usize,
6161 concat!(
6162 "Offset of field: ",
6163 stringify!(dvb_desc_ts_info_transmission_type),
6164 "::",
6165 stringify!(transmission_type_info)
6166 )
6167 );
6168 assert_eq!(
6169 unsafe {
6170 &(*(::std::ptr::null::<dvb_desc_ts_info_transmission_type>())).num_of_service
6171 as *const _ as usize
6172 },
6173 1usize,
6174 concat!(
6175 "Offset of field: ",
6176 stringify!(dvb_desc_ts_info_transmission_type),
6177 "::",
6178 stringify!(num_of_service)
6179 )
6180 );
6181}
6182#[repr(C, packed)]
6183#[derive(Copy, Clone)]
6184pub struct dvb_desc_ts_info {
6185 pub type_: u8,
6186 pub length: u8,
6187 pub next: *mut dvb_desc,
6188 pub ts_name: *mut ::std::os::raw::c_char,
6189 pub ts_name_emph: *mut ::std::os::raw::c_char,
6190 pub transmission_type: dvb_desc_ts_info_transmission_type,
6191 pub service_id: *mut u16,
6192 pub __bindgen_anon_1: dvb_desc_ts_info__bindgen_ty_1,
6193}
6194#[repr(C)]
6195#[derive(Copy, Clone)]
6196pub union dvb_desc_ts_info__bindgen_ty_1 {
6197 pub bitfield: u16,
6198 pub __bindgen_anon_1: dvb_desc_ts_info__bindgen_ty_1__bindgen_ty_1,
6199 _bindgen_union_align: u16,
6200}
6201#[repr(C, packed)]
6202#[derive(Debug, Copy, Clone)]
6203pub struct dvb_desc_ts_info__bindgen_ty_1__bindgen_ty_1 {
6204 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize], u8>,
6205}
6206#[test]
6207fn bindgen_test_layout_dvb_desc_ts_info__bindgen_ty_1__bindgen_ty_1() {
6208 assert_eq!(
6209 ::std::mem::size_of::<dvb_desc_ts_info__bindgen_ty_1__bindgen_ty_1>(),
6210 2usize,
6211 concat!(
6212 "Size of: ",
6213 stringify!(dvb_desc_ts_info__bindgen_ty_1__bindgen_ty_1)
6214 )
6215 );
6216 assert_eq!(
6217 ::std::mem::align_of::<dvb_desc_ts_info__bindgen_ty_1__bindgen_ty_1>(),
6218 1usize,
6219 concat!(
6220 "Alignment of ",
6221 stringify!(dvb_desc_ts_info__bindgen_ty_1__bindgen_ty_1)
6222 )
6223 );
6224}
6225impl dvb_desc_ts_info__bindgen_ty_1__bindgen_ty_1 {
6226 #[inline]
6227 pub fn transmission_type_count(&self) -> u8 {
6228 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u8) }
6229 }
6230 #[inline]
6231 pub fn set_transmission_type_count(&mut self, val: u8) {
6232 unsafe {
6233 let val: u8 = ::std::mem::transmute(val);
6234 self._bitfield_1.set(0usize, 2u8, val as u64)
6235 }
6236 }
6237 #[inline]
6238 pub fn length_of_ts_name(&self) -> u8 {
6239 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 6u8) as u8) }
6240 }
6241 #[inline]
6242 pub fn set_length_of_ts_name(&mut self, val: u8) {
6243 unsafe {
6244 let val: u8 = ::std::mem::transmute(val);
6245 self._bitfield_1.set(2usize, 6u8, val as u64)
6246 }
6247 }
6248 #[inline]
6249 pub fn remote_control_key_id(&self) -> u8 {
6250 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 8u8) as u8) }
6251 }
6252 #[inline]
6253 pub fn set_remote_control_key_id(&mut self, val: u8) {
6254 unsafe {
6255 let val: u8 = ::std::mem::transmute(val);
6256 self._bitfield_1.set(8usize, 8u8, val as u64)
6257 }
6258 }
6259 #[inline]
6260 pub fn new_bitfield_1(
6261 transmission_type_count: u8,
6262 length_of_ts_name: u8,
6263 remote_control_key_id: u8,
6264 ) -> __BindgenBitfieldUnit<[u8; 2usize], u8> {
6265 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize], u8> =
6266 Default::default();
6267 __bindgen_bitfield_unit.set(0usize, 2u8, {
6268 let transmission_type_count: u8 =
6269 unsafe { ::std::mem::transmute(transmission_type_count) };
6270 transmission_type_count as u64
6271 });
6272 __bindgen_bitfield_unit.set(2usize, 6u8, {
6273 let length_of_ts_name: u8 = unsafe { ::std::mem::transmute(length_of_ts_name) };
6274 length_of_ts_name as u64
6275 });
6276 __bindgen_bitfield_unit.set(8usize, 8u8, {
6277 let remote_control_key_id: u8 = unsafe { ::std::mem::transmute(remote_control_key_id) };
6278 remote_control_key_id as u64
6279 });
6280 __bindgen_bitfield_unit
6281 }
6282}
6283#[test]
6284fn bindgen_test_layout_dvb_desc_ts_info__bindgen_ty_1() {
6285 assert_eq!(
6286 ::std::mem::size_of::<dvb_desc_ts_info__bindgen_ty_1>(),
6287 2usize,
6288 concat!("Size of: ", stringify!(dvb_desc_ts_info__bindgen_ty_1))
6289 );
6290 assert_eq!(
6291 ::std::mem::align_of::<dvb_desc_ts_info__bindgen_ty_1>(),
6292 2usize,
6293 concat!("Alignment of ", stringify!(dvb_desc_ts_info__bindgen_ty_1))
6294 );
6295 assert_eq!(
6296 unsafe {
6297 &(*(::std::ptr::null::<dvb_desc_ts_info__bindgen_ty_1>())).bitfield as *const _ as usize
6298 },
6299 0usize,
6300 concat!(
6301 "Offset of field: ",
6302 stringify!(dvb_desc_ts_info__bindgen_ty_1),
6303 "::",
6304 stringify!(bitfield)
6305 )
6306 );
6307}
6308#[test]
6309fn bindgen_test_layout_dvb_desc_ts_info() {
6310 assert_eq!(
6311 ::std::mem::size_of::<dvb_desc_ts_info>(),
6312 38usize,
6313 concat!("Size of: ", stringify!(dvb_desc_ts_info))
6314 );
6315 assert_eq!(
6316 ::std::mem::align_of::<dvb_desc_ts_info>(),
6317 1usize,
6318 concat!("Alignment of ", stringify!(dvb_desc_ts_info))
6319 );
6320 assert_eq!(
6321 unsafe { &(*(::std::ptr::null::<dvb_desc_ts_info>())).type_ as *const _ as usize },
6322 0usize,
6323 concat!(
6324 "Offset of field: ",
6325 stringify!(dvb_desc_ts_info),
6326 "::",
6327 stringify!(type_)
6328 )
6329 );
6330 assert_eq!(
6331 unsafe { &(*(::std::ptr::null::<dvb_desc_ts_info>())).length as *const _ as usize },
6332 1usize,
6333 concat!(
6334 "Offset of field: ",
6335 stringify!(dvb_desc_ts_info),
6336 "::",
6337 stringify!(length)
6338 )
6339 );
6340 assert_eq!(
6341 unsafe { &(*(::std::ptr::null::<dvb_desc_ts_info>())).next as *const _ as usize },
6342 2usize,
6343 concat!(
6344 "Offset of field: ",
6345 stringify!(dvb_desc_ts_info),
6346 "::",
6347 stringify!(next)
6348 )
6349 );
6350 assert_eq!(
6351 unsafe { &(*(::std::ptr::null::<dvb_desc_ts_info>())).ts_name as *const _ as usize },
6352 10usize,
6353 concat!(
6354 "Offset of field: ",
6355 stringify!(dvb_desc_ts_info),
6356 "::",
6357 stringify!(ts_name)
6358 )
6359 );
6360 assert_eq!(
6361 unsafe { &(*(::std::ptr::null::<dvb_desc_ts_info>())).ts_name_emph as *const _ as usize },
6362 18usize,
6363 concat!(
6364 "Offset of field: ",
6365 stringify!(dvb_desc_ts_info),
6366 "::",
6367 stringify!(ts_name_emph)
6368 )
6369 );
6370 assert_eq!(
6371 unsafe {
6372 &(*(::std::ptr::null::<dvb_desc_ts_info>())).transmission_type as *const _ as usize
6373 },
6374 26usize,
6375 concat!(
6376 "Offset of field: ",
6377 stringify!(dvb_desc_ts_info),
6378 "::",
6379 stringify!(transmission_type)
6380 )
6381 );
6382 assert_eq!(
6383 unsafe { &(*(::std::ptr::null::<dvb_desc_ts_info>())).service_id as *const _ as usize },
6384 28usize,
6385 concat!(
6386 "Offset of field: ",
6387 stringify!(dvb_desc_ts_info),
6388 "::",
6389 stringify!(service_id)
6390 )
6391 );
6392}
6393extern "C" {
6394 pub fn dvb_desc_ts_info_init(
6395 parms: *mut dvb_v5_fe_parms,
6396 buf: *const u8,
6397 desc: *mut dvb_desc,
6398 ) -> ::std::os::raw::c_int;
6399}
6400extern "C" {
6401 pub fn dvb_desc_ts_info_print(parms: *mut dvb_v5_fe_parms, desc: *const dvb_desc);
6402}
6403extern "C" {
6404 pub fn dvb_desc_ts_info_free(desc: *mut dvb_desc);
6405}
6406pub type __u8 = ::std::os::raw::c_uchar;
6407pub type __u16 = ::std::os::raw::c_ushort;
6408pub type __s32 = ::std::os::raw::c_int;
6409pub type __u32 = ::std::os::raw::c_uint;
6410pub type __s64 = ::std::os::raw::c_longlong;
6411pub type __u64 = ::std::os::raw::c_ulonglong;
6412#[repr(u32)]
6413#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
6414pub enum dmx_output {
6415 DMX_OUT_DECODER = 0,
6416 DMX_OUT_TAP = 1,
6417 DMX_OUT_TS_TAP = 2,
6418 DMX_OUT_TSDEMUX_TAP = 3,
6419}
6420#[repr(u32)]
6421#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
6422pub enum dmx_input {
6423 DMX_IN_FRONTEND = 0,
6424 DMX_IN_DVR = 1,
6425}
6426#[repr(u32)]
6427#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
6428pub enum dmx_ts_pes {
6429 DMX_PES_AUDIO0 = 0,
6430 DMX_PES_VIDEO0 = 1,
6431 DMX_PES_TELETEXT0 = 2,
6432 DMX_PES_SUBTITLE0 = 3,
6433 DMX_PES_PCR0 = 4,
6434 DMX_PES_AUDIO1 = 5,
6435 DMX_PES_VIDEO1 = 6,
6436 DMX_PES_TELETEXT1 = 7,
6437 DMX_PES_SUBTITLE1 = 8,
6438 DMX_PES_PCR1 = 9,
6439 DMX_PES_AUDIO2 = 10,
6440 DMX_PES_VIDEO2 = 11,
6441 DMX_PES_TELETEXT2 = 12,
6442 DMX_PES_SUBTITLE2 = 13,
6443 DMX_PES_PCR2 = 14,
6444 DMX_PES_AUDIO3 = 15,
6445 DMX_PES_VIDEO3 = 16,
6446 DMX_PES_TELETEXT3 = 17,
6447 DMX_PES_SUBTITLE3 = 18,
6448 DMX_PES_PCR3 = 19,
6449 DMX_PES_OTHER = 20,
6450}
6451#[repr(C)]
6452#[derive(Debug, Copy, Clone)]
6453pub struct dmx_filter {
6454 pub filter: [__u8; 16usize],
6455 pub mask: [__u8; 16usize],
6456 pub mode: [__u8; 16usize],
6457}
6458#[test]
6459fn bindgen_test_layout_dmx_filter() {
6460 assert_eq!(
6461 ::std::mem::size_of::<dmx_filter>(),
6462 48usize,
6463 concat!("Size of: ", stringify!(dmx_filter))
6464 );
6465 assert_eq!(
6466 ::std::mem::align_of::<dmx_filter>(),
6467 1usize,
6468 concat!("Alignment of ", stringify!(dmx_filter))
6469 );
6470 assert_eq!(
6471 unsafe { &(*(::std::ptr::null::<dmx_filter>())).filter as *const _ as usize },
6472 0usize,
6473 concat!(
6474 "Offset of field: ",
6475 stringify!(dmx_filter),
6476 "::",
6477 stringify!(filter)
6478 )
6479 );
6480 assert_eq!(
6481 unsafe { &(*(::std::ptr::null::<dmx_filter>())).mask as *const _ as usize },
6482 16usize,
6483 concat!(
6484 "Offset of field: ",
6485 stringify!(dmx_filter),
6486 "::",
6487 stringify!(mask)
6488 )
6489 );
6490 assert_eq!(
6491 unsafe { &(*(::std::ptr::null::<dmx_filter>())).mode as *const _ as usize },
6492 32usize,
6493 concat!(
6494 "Offset of field: ",
6495 stringify!(dmx_filter),
6496 "::",
6497 stringify!(mode)
6498 )
6499 );
6500}
6501#[repr(C)]
6502#[derive(Debug, Copy, Clone)]
6503pub struct dmx_sct_filter_params {
6504 pub pid: __u16,
6505 pub filter: dmx_filter,
6506 pub timeout: __u32,
6507 pub flags: __u32,
6508}
6509#[test]
6510fn bindgen_test_layout_dmx_sct_filter_params() {
6511 assert_eq!(
6512 ::std::mem::size_of::<dmx_sct_filter_params>(),
6513 60usize,
6514 concat!("Size of: ", stringify!(dmx_sct_filter_params))
6515 );
6516 assert_eq!(
6517 ::std::mem::align_of::<dmx_sct_filter_params>(),
6518 4usize,
6519 concat!("Alignment of ", stringify!(dmx_sct_filter_params))
6520 );
6521 assert_eq!(
6522 unsafe { &(*(::std::ptr::null::<dmx_sct_filter_params>())).pid as *const _ as usize },
6523 0usize,
6524 concat!(
6525 "Offset of field: ",
6526 stringify!(dmx_sct_filter_params),
6527 "::",
6528 stringify!(pid)
6529 )
6530 );
6531 assert_eq!(
6532 unsafe { &(*(::std::ptr::null::<dmx_sct_filter_params>())).filter as *const _ as usize },
6533 2usize,
6534 concat!(
6535 "Offset of field: ",
6536 stringify!(dmx_sct_filter_params),
6537 "::",
6538 stringify!(filter)
6539 )
6540 );
6541 assert_eq!(
6542 unsafe { &(*(::std::ptr::null::<dmx_sct_filter_params>())).timeout as *const _ as usize },
6543 52usize,
6544 concat!(
6545 "Offset of field: ",
6546 stringify!(dmx_sct_filter_params),
6547 "::",
6548 stringify!(timeout)
6549 )
6550 );
6551 assert_eq!(
6552 unsafe { &(*(::std::ptr::null::<dmx_sct_filter_params>())).flags as *const _ as usize },
6553 56usize,
6554 concat!(
6555 "Offset of field: ",
6556 stringify!(dmx_sct_filter_params),
6557 "::",
6558 stringify!(flags)
6559 )
6560 );
6561}
6562#[repr(C)]
6563#[derive(Debug, Copy, Clone)]
6564pub struct dmx_pes_filter_params {
6565 pub pid: __u16,
6566 pub input: dmx_input,
6567 pub output: dmx_output,
6568 pub pes_type: dmx_ts_pes,
6569 pub flags: __u32,
6570}
6571#[test]
6572fn bindgen_test_layout_dmx_pes_filter_params() {
6573 assert_eq!(
6574 ::std::mem::size_of::<dmx_pes_filter_params>(),
6575 20usize,
6576 concat!("Size of: ", stringify!(dmx_pes_filter_params))
6577 );
6578 assert_eq!(
6579 ::std::mem::align_of::<dmx_pes_filter_params>(),
6580 4usize,
6581 concat!("Alignment of ", stringify!(dmx_pes_filter_params))
6582 );
6583 assert_eq!(
6584 unsafe { &(*(::std::ptr::null::<dmx_pes_filter_params>())).pid as *const _ as usize },
6585 0usize,
6586 concat!(
6587 "Offset of field: ",
6588 stringify!(dmx_pes_filter_params),
6589 "::",
6590 stringify!(pid)
6591 )
6592 );
6593 assert_eq!(
6594 unsafe { &(*(::std::ptr::null::<dmx_pes_filter_params>())).input as *const _ as usize },
6595 4usize,
6596 concat!(
6597 "Offset of field: ",
6598 stringify!(dmx_pes_filter_params),
6599 "::",
6600 stringify!(input)
6601 )
6602 );
6603 assert_eq!(
6604 unsafe { &(*(::std::ptr::null::<dmx_pes_filter_params>())).output as *const _ as usize },
6605 8usize,
6606 concat!(
6607 "Offset of field: ",
6608 stringify!(dmx_pes_filter_params),
6609 "::",
6610 stringify!(output)
6611 )
6612 );
6613 assert_eq!(
6614 unsafe { &(*(::std::ptr::null::<dmx_pes_filter_params>())).pes_type as *const _ as usize },
6615 12usize,
6616 concat!(
6617 "Offset of field: ",
6618 stringify!(dmx_pes_filter_params),
6619 "::",
6620 stringify!(pes_type)
6621 )
6622 );
6623 assert_eq!(
6624 unsafe { &(*(::std::ptr::null::<dmx_pes_filter_params>())).flags as *const _ as usize },
6625 16usize,
6626 concat!(
6627 "Offset of field: ",
6628 stringify!(dmx_pes_filter_params),
6629 "::",
6630 stringify!(flags)
6631 )
6632 );
6633}
6634#[repr(C)]
6635#[derive(Debug, Copy, Clone)]
6636pub struct dmx_stc {
6637 pub num: ::std::os::raw::c_uint,
6638 pub base: ::std::os::raw::c_uint,
6639 pub stc: __u64,
6640}
6641#[test]
6642fn bindgen_test_layout_dmx_stc() {
6643 assert_eq!(
6644 ::std::mem::size_of::<dmx_stc>(),
6645 16usize,
6646 concat!("Size of: ", stringify!(dmx_stc))
6647 );
6648 assert_eq!(
6649 ::std::mem::align_of::<dmx_stc>(),
6650 8usize,
6651 concat!("Alignment of ", stringify!(dmx_stc))
6652 );
6653 assert_eq!(
6654 unsafe { &(*(::std::ptr::null::<dmx_stc>())).num as *const _ as usize },
6655 0usize,
6656 concat!(
6657 "Offset of field: ",
6658 stringify!(dmx_stc),
6659 "::",
6660 stringify!(num)
6661 )
6662 );
6663 assert_eq!(
6664 unsafe { &(*(::std::ptr::null::<dmx_stc>())).base as *const _ as usize },
6665 4usize,
6666 concat!(
6667 "Offset of field: ",
6668 stringify!(dmx_stc),
6669 "::",
6670 stringify!(base)
6671 )
6672 );
6673 assert_eq!(
6674 unsafe { &(*(::std::ptr::null::<dmx_stc>())).stc as *const _ as usize },
6675 8usize,
6676 concat!(
6677 "Offset of field: ",
6678 stringify!(dmx_stc),
6679 "::",
6680 stringify!(stc)
6681 )
6682 );
6683}
6684#[repr(u32)]
6685#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
6686pub enum dmx_buffer_flags {
6687 DMX_BUFFER_FLAG_HAD_CRC32_DISCARD = 1,
6688 DMX_BUFFER_FLAG_TEI = 2,
6689 DMX_BUFFER_PKT_COUNTER_MISMATCH = 4,
6690 DMX_BUFFER_FLAG_DISCONTINUITY_DETECTED = 8,
6691 DMX_BUFFER_FLAG_DISCONTINUITY_INDICATOR = 16,
6692}
6693#[repr(C)]
6694#[derive(Debug, Copy, Clone)]
6695pub struct dmx_buffer {
6696 pub index: __u32,
6697 pub bytesused: __u32,
6698 pub offset: __u32,
6699 pub length: __u32,
6700 pub flags: __u32,
6701 pub count: __u32,
6702}
6703#[test]
6704fn bindgen_test_layout_dmx_buffer() {
6705 assert_eq!(
6706 ::std::mem::size_of::<dmx_buffer>(),
6707 24usize,
6708 concat!("Size of: ", stringify!(dmx_buffer))
6709 );
6710 assert_eq!(
6711 ::std::mem::align_of::<dmx_buffer>(),
6712 4usize,
6713 concat!("Alignment of ", stringify!(dmx_buffer))
6714 );
6715 assert_eq!(
6716 unsafe { &(*(::std::ptr::null::<dmx_buffer>())).index as *const _ as usize },
6717 0usize,
6718 concat!(
6719 "Offset of field: ",
6720 stringify!(dmx_buffer),
6721 "::",
6722 stringify!(index)
6723 )
6724 );
6725 assert_eq!(
6726 unsafe { &(*(::std::ptr::null::<dmx_buffer>())).bytesused as *const _ as usize },
6727 4usize,
6728 concat!(
6729 "Offset of field: ",
6730 stringify!(dmx_buffer),
6731 "::",
6732 stringify!(bytesused)
6733 )
6734 );
6735 assert_eq!(
6736 unsafe { &(*(::std::ptr::null::<dmx_buffer>())).offset as *const _ as usize },
6737 8usize,
6738 concat!(
6739 "Offset of field: ",
6740 stringify!(dmx_buffer),
6741 "::",
6742 stringify!(offset)
6743 )
6744 );
6745 assert_eq!(
6746 unsafe { &(*(::std::ptr::null::<dmx_buffer>())).length as *const _ as usize },
6747 12usize,
6748 concat!(
6749 "Offset of field: ",
6750 stringify!(dmx_buffer),
6751 "::",
6752 stringify!(length)
6753 )
6754 );
6755 assert_eq!(
6756 unsafe { &(*(::std::ptr::null::<dmx_buffer>())).flags as *const _ as usize },
6757 16usize,
6758 concat!(
6759 "Offset of field: ",
6760 stringify!(dmx_buffer),
6761 "::",
6762 stringify!(flags)
6763 )
6764 );
6765 assert_eq!(
6766 unsafe { &(*(::std::ptr::null::<dmx_buffer>())).count as *const _ as usize },
6767 20usize,
6768 concat!(
6769 "Offset of field: ",
6770 stringify!(dmx_buffer),
6771 "::",
6772 stringify!(count)
6773 )
6774 );
6775}
6776#[repr(C)]
6777#[derive(Debug, Copy, Clone)]
6778pub struct dmx_requestbuffers {
6779 pub count: __u32,
6780 pub size: __u32,
6781}
6782#[test]
6783fn bindgen_test_layout_dmx_requestbuffers() {
6784 assert_eq!(
6785 ::std::mem::size_of::<dmx_requestbuffers>(),
6786 8usize,
6787 concat!("Size of: ", stringify!(dmx_requestbuffers))
6788 );
6789 assert_eq!(
6790 ::std::mem::align_of::<dmx_requestbuffers>(),
6791 4usize,
6792 concat!("Alignment of ", stringify!(dmx_requestbuffers))
6793 );
6794 assert_eq!(
6795 unsafe { &(*(::std::ptr::null::<dmx_requestbuffers>())).count as *const _ as usize },
6796 0usize,
6797 concat!(
6798 "Offset of field: ",
6799 stringify!(dmx_requestbuffers),
6800 "::",
6801 stringify!(count)
6802 )
6803 );
6804 assert_eq!(
6805 unsafe { &(*(::std::ptr::null::<dmx_requestbuffers>())).size as *const _ as usize },
6806 4usize,
6807 concat!(
6808 "Offset of field: ",
6809 stringify!(dmx_requestbuffers),
6810 "::",
6811 stringify!(size)
6812 )
6813 );
6814}
6815#[repr(C)]
6816#[derive(Debug, Copy, Clone)]
6817pub struct dmx_exportbuffer {
6818 pub index: __u32,
6819 pub flags: __u32,
6820 pub fd: __s32,
6821}
6822#[test]
6823fn bindgen_test_layout_dmx_exportbuffer() {
6824 assert_eq!(
6825 ::std::mem::size_of::<dmx_exportbuffer>(),
6826 12usize,
6827 concat!("Size of: ", stringify!(dmx_exportbuffer))
6828 );
6829 assert_eq!(
6830 ::std::mem::align_of::<dmx_exportbuffer>(),
6831 4usize,
6832 concat!("Alignment of ", stringify!(dmx_exportbuffer))
6833 );
6834 assert_eq!(
6835 unsafe { &(*(::std::ptr::null::<dmx_exportbuffer>())).index as *const _ as usize },
6836 0usize,
6837 concat!(
6838 "Offset of field: ",
6839 stringify!(dmx_exportbuffer),
6840 "::",
6841 stringify!(index)
6842 )
6843 );
6844 assert_eq!(
6845 unsafe { &(*(::std::ptr::null::<dmx_exportbuffer>())).flags as *const _ as usize },
6846 4usize,
6847 concat!(
6848 "Offset of field: ",
6849 stringify!(dmx_exportbuffer),
6850 "::",
6851 stringify!(flags)
6852 )
6853 );
6854 assert_eq!(
6855 unsafe { &(*(::std::ptr::null::<dmx_exportbuffer>())).fd as *const _ as usize },
6856 8usize,
6857 concat!(
6858 "Offset of field: ",
6859 stringify!(dmx_exportbuffer),
6860 "::",
6861 stringify!(fd)
6862 )
6863 );
6864}
6865pub use self::dmx_input as dmx_input_t;
6866pub use self::dmx_output as dmx_output_t;
6867pub use self::dmx_ts_pes as dmx_pes_type_t;
6868pub type dmx_filter_t = dmx_filter;
6869extern "C" {
6870 pub fn dvb_dmx_open(
6871 adapter: ::std::os::raw::c_int,
6872 demux: ::std::os::raw::c_int,
6873 ) -> ::std::os::raw::c_int;
6874}
6875extern "C" {
6876 pub fn dvb_dmx_close(dmx_fd: ::std::os::raw::c_int);
6877}
6878extern "C" {
6879 pub fn dvb_dmx_stop(dmx_fd: ::std::os::raw::c_int);
6880}
6881extern "C" {
6882 pub fn dvb_set_pesfilter(
6883 dmxfd: ::std::os::raw::c_int,
6884 pid: ::std::os::raw::c_int,
6885 type_: dmx_pes_type_t,
6886 output: dmx_output_t,
6887 buffersize: ::std::os::raw::c_int,
6888 ) -> ::std::os::raw::c_int;
6889}
6890extern "C" {
6891 pub fn dvb_set_section_filter(
6892 dmxfd: ::std::os::raw::c_int,
6893 pid: ::std::os::raw::c_int,
6894 filtsize: ::std::os::raw::c_uint,
6895 filter: *mut ::std::os::raw::c_uchar,
6896 mask: *mut ::std::os::raw::c_uchar,
6897 mode: *mut ::std::os::raw::c_uchar,
6898 flags: ::std::os::raw::c_uint,
6899 ) -> ::std::os::raw::c_int;
6900}
6901extern "C" {
6902 pub fn dvb_get_pmt_pid(
6903 dmxfd: ::std::os::raw::c_int,
6904 sid: ::std::os::raw::c_int,
6905 ) -> ::std::os::raw::c_int;
6906}
6907extern "C" {
6908 pub static mut sys_nerr: ::std::os::raw::c_int;
6909}
6910extern "C" {
6911 pub static mut sys_errlist: [*const ::std::os::raw::c_char; 0usize];
6912}
6913#[repr(u32)]
6914#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
6915pub enum fe_caps {
6916 FE_IS_STUPID = 0,
6917 FE_CAN_INVERSION_AUTO = 1,
6918 FE_CAN_FEC_1_2 = 2,
6919 FE_CAN_FEC_2_3 = 4,
6920 FE_CAN_FEC_3_4 = 8,
6921 FE_CAN_FEC_4_5 = 16,
6922 FE_CAN_FEC_5_6 = 32,
6923 FE_CAN_FEC_6_7 = 64,
6924 FE_CAN_FEC_7_8 = 128,
6925 FE_CAN_FEC_8_9 = 256,
6926 FE_CAN_FEC_AUTO = 512,
6927 FE_CAN_QPSK = 1024,
6928 FE_CAN_QAM_16 = 2048,
6929 FE_CAN_QAM_32 = 4096,
6930 FE_CAN_QAM_64 = 8192,
6931 FE_CAN_QAM_128 = 16384,
6932 FE_CAN_QAM_256 = 32768,
6933 FE_CAN_QAM_AUTO = 65536,
6934 FE_CAN_TRANSMISSION_MODE_AUTO = 131072,
6935 FE_CAN_BANDWIDTH_AUTO = 262144,
6936 FE_CAN_GUARD_INTERVAL_AUTO = 524288,
6937 FE_CAN_HIERARCHY_AUTO = 1048576,
6938 FE_CAN_8VSB = 2097152,
6939 FE_CAN_16VSB = 4194304,
6940 FE_HAS_EXTENDED_CAPS = 8388608,
6941 FE_CAN_MULTISTREAM = 67108864,
6942 FE_CAN_TURBO_FEC = 134217728,
6943 FE_CAN_2G_MODULATION = 268435456,
6944 FE_NEEDS_BENDING = 536870912,
6945 FE_CAN_RECOVER = 1073741824,
6946 FE_CAN_MUTE_TS = 2147483648,
6947}
6948#[repr(u32)]
6949#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
6950pub enum fe_type {
6951 FE_QPSK = 0,
6952 FE_QAM = 1,
6953 FE_OFDM = 2,
6954 FE_ATSC = 3,
6955}
6956#[repr(C)]
6957#[derive(Copy, Clone)]
6958pub struct dvb_frontend_info {
6959 pub name: [::std::os::raw::c_char; 128usize],
6960 pub type_: fe_type,
6961 pub frequency_min: __u32,
6962 pub frequency_max: __u32,
6963 pub frequency_stepsize: __u32,
6964 pub frequency_tolerance: __u32,
6965 pub symbol_rate_min: __u32,
6966 pub symbol_rate_max: __u32,
6967 pub symbol_rate_tolerance: __u32,
6968 pub notifier_delay: __u32,
6969 pub caps: fe_caps,
6970}
6971#[test]
6972fn bindgen_test_layout_dvb_frontend_info() {
6973 assert_eq!(
6974 ::std::mem::size_of::<dvb_frontend_info>(),
6975 168usize,
6976 concat!("Size of: ", stringify!(dvb_frontend_info))
6977 );
6978 assert_eq!(
6979 ::std::mem::align_of::<dvb_frontend_info>(),
6980 4usize,
6981 concat!("Alignment of ", stringify!(dvb_frontend_info))
6982 );
6983 assert_eq!(
6984 unsafe { &(*(::std::ptr::null::<dvb_frontend_info>())).name as *const _ as usize },
6985 0usize,
6986 concat!(
6987 "Offset of field: ",
6988 stringify!(dvb_frontend_info),
6989 "::",
6990 stringify!(name)
6991 )
6992 );
6993 assert_eq!(
6994 unsafe { &(*(::std::ptr::null::<dvb_frontend_info>())).type_ as *const _ as usize },
6995 128usize,
6996 concat!(
6997 "Offset of field: ",
6998 stringify!(dvb_frontend_info),
6999 "::",
7000 stringify!(type_)
7001 )
7002 );
7003 assert_eq!(
7004 unsafe { &(*(::std::ptr::null::<dvb_frontend_info>())).frequency_min as *const _ as usize },
7005 132usize,
7006 concat!(
7007 "Offset of field: ",
7008 stringify!(dvb_frontend_info),
7009 "::",
7010 stringify!(frequency_min)
7011 )
7012 );
7013 assert_eq!(
7014 unsafe { &(*(::std::ptr::null::<dvb_frontend_info>())).frequency_max as *const _ as usize },
7015 136usize,
7016 concat!(
7017 "Offset of field: ",
7018 stringify!(dvb_frontend_info),
7019 "::",
7020 stringify!(frequency_max)
7021 )
7022 );
7023 assert_eq!(
7024 unsafe {
7025 &(*(::std::ptr::null::<dvb_frontend_info>())).frequency_stepsize as *const _ as usize
7026 },
7027 140usize,
7028 concat!(
7029 "Offset of field: ",
7030 stringify!(dvb_frontend_info),
7031 "::",
7032 stringify!(frequency_stepsize)
7033 )
7034 );
7035 assert_eq!(
7036 unsafe {
7037 &(*(::std::ptr::null::<dvb_frontend_info>())).frequency_tolerance as *const _ as usize
7038 },
7039 144usize,
7040 concat!(
7041 "Offset of field: ",
7042 stringify!(dvb_frontend_info),
7043 "::",
7044 stringify!(frequency_tolerance)
7045 )
7046 );
7047 assert_eq!(
7048 unsafe {
7049 &(*(::std::ptr::null::<dvb_frontend_info>())).symbol_rate_min as *const _ as usize
7050 },
7051 148usize,
7052 concat!(
7053 "Offset of field: ",
7054 stringify!(dvb_frontend_info),
7055 "::",
7056 stringify!(symbol_rate_min)
7057 )
7058 );
7059 assert_eq!(
7060 unsafe {
7061 &(*(::std::ptr::null::<dvb_frontend_info>())).symbol_rate_max as *const _ as usize
7062 },
7063 152usize,
7064 concat!(
7065 "Offset of field: ",
7066 stringify!(dvb_frontend_info),
7067 "::",
7068 stringify!(symbol_rate_max)
7069 )
7070 );
7071 assert_eq!(
7072 unsafe {
7073 &(*(::std::ptr::null::<dvb_frontend_info>())).symbol_rate_tolerance as *const _ as usize
7074 },
7075 156usize,
7076 concat!(
7077 "Offset of field: ",
7078 stringify!(dvb_frontend_info),
7079 "::",
7080 stringify!(symbol_rate_tolerance)
7081 )
7082 );
7083 assert_eq!(
7084 unsafe {
7085 &(*(::std::ptr::null::<dvb_frontend_info>())).notifier_delay as *const _ as usize
7086 },
7087 160usize,
7088 concat!(
7089 "Offset of field: ",
7090 stringify!(dvb_frontend_info),
7091 "::",
7092 stringify!(notifier_delay)
7093 )
7094 );
7095 assert_eq!(
7096 unsafe { &(*(::std::ptr::null::<dvb_frontend_info>())).caps as *const _ as usize },
7097 164usize,
7098 concat!(
7099 "Offset of field: ",
7100 stringify!(dvb_frontend_info),
7101 "::",
7102 stringify!(caps)
7103 )
7104 );
7105}
7106#[repr(C)]
7107#[derive(Debug, Copy, Clone)]
7108pub struct dvb_diseqc_master_cmd {
7109 pub msg: [__u8; 6usize],
7110 pub msg_len: __u8,
7111}
7112#[test]
7113fn bindgen_test_layout_dvb_diseqc_master_cmd() {
7114 assert_eq!(
7115 ::std::mem::size_of::<dvb_diseqc_master_cmd>(),
7116 7usize,
7117 concat!("Size of: ", stringify!(dvb_diseqc_master_cmd))
7118 );
7119 assert_eq!(
7120 ::std::mem::align_of::<dvb_diseqc_master_cmd>(),
7121 1usize,
7122 concat!("Alignment of ", stringify!(dvb_diseqc_master_cmd))
7123 );
7124 assert_eq!(
7125 unsafe { &(*(::std::ptr::null::<dvb_diseqc_master_cmd>())).msg as *const _ as usize },
7126 0usize,
7127 concat!(
7128 "Offset of field: ",
7129 stringify!(dvb_diseqc_master_cmd),
7130 "::",
7131 stringify!(msg)
7132 )
7133 );
7134 assert_eq!(
7135 unsafe { &(*(::std::ptr::null::<dvb_diseqc_master_cmd>())).msg_len as *const _ as usize },
7136 6usize,
7137 concat!(
7138 "Offset of field: ",
7139 stringify!(dvb_diseqc_master_cmd),
7140 "::",
7141 stringify!(msg_len)
7142 )
7143 );
7144}
7145#[repr(C)]
7146#[derive(Debug, Copy, Clone)]
7147pub struct dvb_diseqc_slave_reply {
7148 pub msg: [__u8; 4usize],
7149 pub msg_len: __u8,
7150 pub timeout: ::std::os::raw::c_int,
7151}
7152#[test]
7153fn bindgen_test_layout_dvb_diseqc_slave_reply() {
7154 assert_eq!(
7155 ::std::mem::size_of::<dvb_diseqc_slave_reply>(),
7156 12usize,
7157 concat!("Size of: ", stringify!(dvb_diseqc_slave_reply))
7158 );
7159 assert_eq!(
7160 ::std::mem::align_of::<dvb_diseqc_slave_reply>(),
7161 4usize,
7162 concat!("Alignment of ", stringify!(dvb_diseqc_slave_reply))
7163 );
7164 assert_eq!(
7165 unsafe { &(*(::std::ptr::null::<dvb_diseqc_slave_reply>())).msg as *const _ as usize },
7166 0usize,
7167 concat!(
7168 "Offset of field: ",
7169 stringify!(dvb_diseqc_slave_reply),
7170 "::",
7171 stringify!(msg)
7172 )
7173 );
7174 assert_eq!(
7175 unsafe { &(*(::std::ptr::null::<dvb_diseqc_slave_reply>())).msg_len as *const _ as usize },
7176 4usize,
7177 concat!(
7178 "Offset of field: ",
7179 stringify!(dvb_diseqc_slave_reply),
7180 "::",
7181 stringify!(msg_len)
7182 )
7183 );
7184 assert_eq!(
7185 unsafe { &(*(::std::ptr::null::<dvb_diseqc_slave_reply>())).timeout as *const _ as usize },
7186 8usize,
7187 concat!(
7188 "Offset of field: ",
7189 stringify!(dvb_diseqc_slave_reply),
7190 "::",
7191 stringify!(timeout)
7192 )
7193 );
7194}
7195#[repr(u32)]
7196#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
7197pub enum fe_sec_voltage {
7198 SEC_VOLTAGE_13 = 0,
7199 SEC_VOLTAGE_18 = 1,
7200 SEC_VOLTAGE_OFF = 2,
7201}
7202#[repr(u32)]
7203#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
7204pub enum fe_sec_tone_mode {
7205 SEC_TONE_ON = 0,
7206 SEC_TONE_OFF = 1,
7207}
7208#[repr(u32)]
7209#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
7210pub enum fe_sec_mini_cmd {
7211 SEC_MINI_A = 0,
7212 SEC_MINI_B = 1,
7213}
7214#[repr(u32)]
7215#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
7216pub enum fe_status {
7217 FE_NONE = 0,
7218 FE_HAS_SIGNAL = 1,
7219 FE_HAS_CARRIER = 2,
7220 FE_HAS_VITERBI = 4,
7221 FE_HAS_SYNC = 8,
7222 FE_HAS_LOCK = 16,
7223 FE_TIMEDOUT = 32,
7224 FE_REINIT = 64,
7225}
7226#[repr(u32)]
7227#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
7228pub enum fe_spectral_inversion {
7229 INVERSION_OFF = 0,
7230 INVERSION_ON = 1,
7231 INVERSION_AUTO = 2,
7232}
7233#[repr(u32)]
7234#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
7235pub enum fe_code_rate {
7236 FEC_NONE = 0,
7237 FEC_1_2 = 1,
7238 FEC_2_3 = 2,
7239 FEC_3_4 = 3,
7240 FEC_4_5 = 4,
7241 FEC_5_6 = 5,
7242 FEC_6_7 = 6,
7243 FEC_7_8 = 7,
7244 FEC_8_9 = 8,
7245 FEC_AUTO = 9,
7246 FEC_3_5 = 10,
7247 FEC_9_10 = 11,
7248 FEC_2_5 = 12,
7249}
7250#[repr(u32)]
7251#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
7252pub enum fe_modulation {
7253 QPSK = 0,
7254 QAM_16 = 1,
7255 QAM_32 = 2,
7256 QAM_64 = 3,
7257 QAM_128 = 4,
7258 QAM_256 = 5,
7259 QAM_AUTO = 6,
7260 VSB_8 = 7,
7261 VSB_16 = 8,
7262 PSK_8 = 9,
7263 APSK_16 = 10,
7264 APSK_32 = 11,
7265 DQPSK = 12,
7266 QAM_4_NR = 13,
7267}
7268#[repr(u32)]
7269#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
7270pub enum fe_transmit_mode {
7271 TRANSMISSION_MODE_2K = 0,
7272 TRANSMISSION_MODE_8K = 1,
7273 TRANSMISSION_MODE_AUTO = 2,
7274 TRANSMISSION_MODE_4K = 3,
7275 TRANSMISSION_MODE_1K = 4,
7276 TRANSMISSION_MODE_16K = 5,
7277 TRANSMISSION_MODE_32K = 6,
7278 TRANSMISSION_MODE_C1 = 7,
7279 TRANSMISSION_MODE_C3780 = 8,
7280}
7281#[repr(u32)]
7282#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
7283pub enum fe_guard_interval {
7284 GUARD_INTERVAL_1_32 = 0,
7285 GUARD_INTERVAL_1_16 = 1,
7286 GUARD_INTERVAL_1_8 = 2,
7287 GUARD_INTERVAL_1_4 = 3,
7288 GUARD_INTERVAL_AUTO = 4,
7289 GUARD_INTERVAL_1_128 = 5,
7290 GUARD_INTERVAL_19_128 = 6,
7291 GUARD_INTERVAL_19_256 = 7,
7292 GUARD_INTERVAL_PN420 = 8,
7293 GUARD_INTERVAL_PN595 = 9,
7294 GUARD_INTERVAL_PN945 = 10,
7295}
7296#[repr(u32)]
7297#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
7298pub enum fe_hierarchy {
7299 HIERARCHY_NONE = 0,
7300 HIERARCHY_1 = 1,
7301 HIERARCHY_2 = 2,
7302 HIERARCHY_4 = 3,
7303 HIERARCHY_AUTO = 4,
7304}
7305#[repr(u32)]
7306#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
7307pub enum fe_interleaving {
7308 INTERLEAVING_NONE = 0,
7309 INTERLEAVING_AUTO = 1,
7310 INTERLEAVING_240 = 2,
7311 INTERLEAVING_720 = 3,
7312}
7313#[repr(u32)]
7314#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
7315pub enum fe_pilot {
7316 PILOT_ON = 0,
7317 PILOT_OFF = 1,
7318 PILOT_AUTO = 2,
7319}
7320#[repr(u32)]
7321#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
7322pub enum fe_rolloff {
7323 ROLLOFF_35 = 0,
7324 ROLLOFF_20 = 1,
7325 ROLLOFF_25 = 2,
7326 ROLLOFF_AUTO = 3,
7327}
7328#[repr(u32)]
7329#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
7330pub enum fe_delivery_system {
7331 SYS_UNDEFINED = 0,
7332 SYS_DVBC_ANNEX_A = 1,
7333 SYS_DVBC_ANNEX_B = 2,
7334 SYS_DVBT = 3,
7335 SYS_DSS = 4,
7336 SYS_DVBS = 5,
7337 SYS_DVBS2 = 6,
7338 SYS_DVBH = 7,
7339 SYS_ISDBT = 8,
7340 SYS_ISDBS = 9,
7341 SYS_ISDBC = 10,
7342 SYS_ATSC = 11,
7343 SYS_ATSCMH = 12,
7344 SYS_DTMB = 13,
7345 SYS_CMMB = 14,
7346 SYS_DAB = 15,
7347 SYS_DVBT2 = 16,
7348 SYS_TURBO = 17,
7349 SYS_DVBC_ANNEX_C = 18,
7350}
7351#[repr(u32)]
7352#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
7353pub enum fecap_scale_params {
7354 FE_SCALE_NOT_AVAILABLE = 0,
7355 FE_SCALE_DECIBEL = 1,
7356 FE_SCALE_RELATIVE = 2,
7357 FE_SCALE_COUNTER = 3,
7358}
7359#[repr(C, packed)]
7360#[derive(Copy, Clone)]
7361pub struct dtv_stats {
7362 pub scale: __u8,
7363 pub __bindgen_anon_1: dtv_stats__bindgen_ty_1,
7364}
7365#[repr(C)]
7366#[derive(Copy, Clone)]
7367pub union dtv_stats__bindgen_ty_1 {
7368 pub uvalue: __u64,
7369 pub svalue: __s64,
7370 _bindgen_union_align: u64,
7371}
7372#[test]
7373fn bindgen_test_layout_dtv_stats__bindgen_ty_1() {
7374 assert_eq!(
7375 ::std::mem::size_of::<dtv_stats__bindgen_ty_1>(),
7376 8usize,
7377 concat!("Size of: ", stringify!(dtv_stats__bindgen_ty_1))
7378 );
7379 assert_eq!(
7380 ::std::mem::align_of::<dtv_stats__bindgen_ty_1>(),
7381 8usize,
7382 concat!("Alignment of ", stringify!(dtv_stats__bindgen_ty_1))
7383 );
7384 assert_eq!(
7385 unsafe { &(*(::std::ptr::null::<dtv_stats__bindgen_ty_1>())).uvalue as *const _ as usize },
7386 0usize,
7387 concat!(
7388 "Offset of field: ",
7389 stringify!(dtv_stats__bindgen_ty_1),
7390 "::",
7391 stringify!(uvalue)
7392 )
7393 );
7394 assert_eq!(
7395 unsafe { &(*(::std::ptr::null::<dtv_stats__bindgen_ty_1>())).svalue as *const _ as usize },
7396 0usize,
7397 concat!(
7398 "Offset of field: ",
7399 stringify!(dtv_stats__bindgen_ty_1),
7400 "::",
7401 stringify!(svalue)
7402 )
7403 );
7404}
7405#[test]
7406fn bindgen_test_layout_dtv_stats() {
7407 assert_eq!(
7408 ::std::mem::size_of::<dtv_stats>(),
7409 9usize,
7410 concat!("Size of: ", stringify!(dtv_stats))
7411 );
7412 assert_eq!(
7413 ::std::mem::align_of::<dtv_stats>(),
7414 1usize,
7415 concat!("Alignment of ", stringify!(dtv_stats))
7416 );
7417 assert_eq!(
7418 unsafe { &(*(::std::ptr::null::<dtv_stats>())).scale as *const _ as usize },
7419 0usize,
7420 concat!(
7421 "Offset of field: ",
7422 stringify!(dtv_stats),
7423 "::",
7424 stringify!(scale)
7425 )
7426 );
7427}
7428#[repr(C, packed)]
7429#[derive(Copy, Clone)]
7430pub struct dtv_fe_stats {
7431 pub len: __u8,
7432 pub stat: [dtv_stats; 4usize],
7433}
7434#[test]
7435fn bindgen_test_layout_dtv_fe_stats() {
7436 assert_eq!(
7437 ::std::mem::size_of::<dtv_fe_stats>(),
7438 37usize,
7439 concat!("Size of: ", stringify!(dtv_fe_stats))
7440 );
7441 assert_eq!(
7442 ::std::mem::align_of::<dtv_fe_stats>(),
7443 1usize,
7444 concat!("Alignment of ", stringify!(dtv_fe_stats))
7445 );
7446 assert_eq!(
7447 unsafe { &(*(::std::ptr::null::<dtv_fe_stats>())).len as *const _ as usize },
7448 0usize,
7449 concat!(
7450 "Offset of field: ",
7451 stringify!(dtv_fe_stats),
7452 "::",
7453 stringify!(len)
7454 )
7455 );
7456 assert_eq!(
7457 unsafe { &(*(::std::ptr::null::<dtv_fe_stats>())).stat as *const _ as usize },
7458 1usize,
7459 concat!(
7460 "Offset of field: ",
7461 stringify!(dtv_fe_stats),
7462 "::",
7463 stringify!(stat)
7464 )
7465 );
7466}
7467#[repr(C, packed)]
7468#[derive(Copy, Clone)]
7469pub struct dtv_property {
7470 pub cmd: __u32,
7471 pub reserved: [__u32; 3usize],
7472 pub u: dtv_property__bindgen_ty_1,
7473 pub result: ::std::os::raw::c_int,
7474}
7475#[repr(C)]
7476#[derive(Copy, Clone)]
7477pub union dtv_property__bindgen_ty_1 {
7478 pub data: __u32,
7479 pub st: dtv_fe_stats,
7480 pub buffer: dtv_property__bindgen_ty_1__bindgen_ty_1,
7481 _bindgen_union_align: [u64; 7usize],
7482}
7483#[repr(C)]
7484#[derive(Debug, Copy, Clone)]
7485pub struct dtv_property__bindgen_ty_1__bindgen_ty_1 {
7486 pub data: [__u8; 32usize],
7487 pub len: __u32,
7488 pub reserved1: [__u32; 3usize],
7489 pub reserved2: *mut ::std::os::raw::c_void,
7490}
7491#[test]
7492fn bindgen_test_layout_dtv_property__bindgen_ty_1__bindgen_ty_1() {
7493 assert_eq!(
7494 ::std::mem::size_of::<dtv_property__bindgen_ty_1__bindgen_ty_1>(),
7495 56usize,
7496 concat!(
7497 "Size of: ",
7498 stringify!(dtv_property__bindgen_ty_1__bindgen_ty_1)
7499 )
7500 );
7501 assert_eq!(
7502 ::std::mem::align_of::<dtv_property__bindgen_ty_1__bindgen_ty_1>(),
7503 8usize,
7504 concat!(
7505 "Alignment of ",
7506 stringify!(dtv_property__bindgen_ty_1__bindgen_ty_1)
7507 )
7508 );
7509 assert_eq!(
7510 unsafe {
7511 &(*(::std::ptr::null::<dtv_property__bindgen_ty_1__bindgen_ty_1>())).data as *const _
7512 as usize
7513 },
7514 0usize,
7515 concat!(
7516 "Offset of field: ",
7517 stringify!(dtv_property__bindgen_ty_1__bindgen_ty_1),
7518 "::",
7519 stringify!(data)
7520 )
7521 );
7522 assert_eq!(
7523 unsafe {
7524 &(*(::std::ptr::null::<dtv_property__bindgen_ty_1__bindgen_ty_1>())).len as *const _
7525 as usize
7526 },
7527 32usize,
7528 concat!(
7529 "Offset of field: ",
7530 stringify!(dtv_property__bindgen_ty_1__bindgen_ty_1),
7531 "::",
7532 stringify!(len)
7533 )
7534 );
7535 assert_eq!(
7536 unsafe {
7537 &(*(::std::ptr::null::<dtv_property__bindgen_ty_1__bindgen_ty_1>())).reserved1
7538 as *const _ as usize
7539 },
7540 36usize,
7541 concat!(
7542 "Offset of field: ",
7543 stringify!(dtv_property__bindgen_ty_1__bindgen_ty_1),
7544 "::",
7545 stringify!(reserved1)
7546 )
7547 );
7548 assert_eq!(
7549 unsafe {
7550 &(*(::std::ptr::null::<dtv_property__bindgen_ty_1__bindgen_ty_1>())).reserved2
7551 as *const _ as usize
7552 },
7553 48usize,
7554 concat!(
7555 "Offset of field: ",
7556 stringify!(dtv_property__bindgen_ty_1__bindgen_ty_1),
7557 "::",
7558 stringify!(reserved2)
7559 )
7560 );
7561}
7562#[test]
7563fn bindgen_test_layout_dtv_property__bindgen_ty_1() {
7564 assert_eq!(
7565 ::std::mem::size_of::<dtv_property__bindgen_ty_1>(),
7566 56usize,
7567 concat!("Size of: ", stringify!(dtv_property__bindgen_ty_1))
7568 );
7569 assert_eq!(
7570 ::std::mem::align_of::<dtv_property__bindgen_ty_1>(),
7571 8usize,
7572 concat!("Alignment of ", stringify!(dtv_property__bindgen_ty_1))
7573 );
7574 assert_eq!(
7575 unsafe { &(*(::std::ptr::null::<dtv_property__bindgen_ty_1>())).data as *const _ as usize },
7576 0usize,
7577 concat!(
7578 "Offset of field: ",
7579 stringify!(dtv_property__bindgen_ty_1),
7580 "::",
7581 stringify!(data)
7582 )
7583 );
7584 assert_eq!(
7585 unsafe { &(*(::std::ptr::null::<dtv_property__bindgen_ty_1>())).st as *const _ as usize },
7586 0usize,
7587 concat!(
7588 "Offset of field: ",
7589 stringify!(dtv_property__bindgen_ty_1),
7590 "::",
7591 stringify!(st)
7592 )
7593 );
7594 assert_eq!(
7595 unsafe {
7596 &(*(::std::ptr::null::<dtv_property__bindgen_ty_1>())).buffer as *const _ as usize
7597 },
7598 0usize,
7599 concat!(
7600 "Offset of field: ",
7601 stringify!(dtv_property__bindgen_ty_1),
7602 "::",
7603 stringify!(buffer)
7604 )
7605 );
7606}
7607#[test]
7608fn bindgen_test_layout_dtv_property() {
7609 assert_eq!(
7610 ::std::mem::size_of::<dtv_property>(),
7611 76usize,
7612 concat!("Size of: ", stringify!(dtv_property))
7613 );
7614 assert_eq!(
7615 ::std::mem::align_of::<dtv_property>(),
7616 1usize,
7617 concat!("Alignment of ", stringify!(dtv_property))
7618 );
7619 assert_eq!(
7620 unsafe { &(*(::std::ptr::null::<dtv_property>())).cmd as *const _ as usize },
7621 0usize,
7622 concat!(
7623 "Offset of field: ",
7624 stringify!(dtv_property),
7625 "::",
7626 stringify!(cmd)
7627 )
7628 );
7629 assert_eq!(
7630 unsafe { &(*(::std::ptr::null::<dtv_property>())).reserved as *const _ as usize },
7631 4usize,
7632 concat!(
7633 "Offset of field: ",
7634 stringify!(dtv_property),
7635 "::",
7636 stringify!(reserved)
7637 )
7638 );
7639 assert_eq!(
7640 unsafe { &(*(::std::ptr::null::<dtv_property>())).u as *const _ as usize },
7641 16usize,
7642 concat!(
7643 "Offset of field: ",
7644 stringify!(dtv_property),
7645 "::",
7646 stringify!(u)
7647 )
7648 );
7649 assert_eq!(
7650 unsafe { &(*(::std::ptr::null::<dtv_property>())).result as *const _ as usize },
7651 72usize,
7652 concat!(
7653 "Offset of field: ",
7654 stringify!(dtv_property),
7655 "::",
7656 stringify!(result)
7657 )
7658 );
7659}
7660#[repr(C)]
7661#[derive(Debug, Copy, Clone)]
7662pub struct dtv_properties {
7663 pub num: __u32,
7664 pub props: *mut dtv_property,
7665}
7666#[test]
7667fn bindgen_test_layout_dtv_properties() {
7668 assert_eq!(
7669 ::std::mem::size_of::<dtv_properties>(),
7670 16usize,
7671 concat!("Size of: ", stringify!(dtv_properties))
7672 );
7673 assert_eq!(
7674 ::std::mem::align_of::<dtv_properties>(),
7675 8usize,
7676 concat!("Alignment of ", stringify!(dtv_properties))
7677 );
7678 assert_eq!(
7679 unsafe { &(*(::std::ptr::null::<dtv_properties>())).num as *const _ as usize },
7680 0usize,
7681 concat!(
7682 "Offset of field: ",
7683 stringify!(dtv_properties),
7684 "::",
7685 stringify!(num)
7686 )
7687 );
7688 assert_eq!(
7689 unsafe { &(*(::std::ptr::null::<dtv_properties>())).props as *const _ as usize },
7690 8usize,
7691 concat!(
7692 "Offset of field: ",
7693 stringify!(dtv_properties),
7694 "::",
7695 stringify!(props)
7696 )
7697 );
7698}
7699#[repr(u32)]
7700#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
7701pub enum fe_bandwidth {
7702 BANDWIDTH_8_MHZ = 0,
7703 BANDWIDTH_7_MHZ = 1,
7704 BANDWIDTH_6_MHZ = 2,
7705 BANDWIDTH_AUTO = 3,
7706 BANDWIDTH_5_MHZ = 4,
7707 BANDWIDTH_10_MHZ = 5,
7708 BANDWIDTH_1_712_MHZ = 6,
7709}
7710pub use self::fe_bandwidth as fe_bandwidth_t;
7711pub use self::fe_caps as fe_caps_t;
7712pub use self::fe_code_rate as fe_code_rate_t;
7713pub use self::fe_delivery_system as fe_delivery_system_t;
7714pub use self::fe_guard_interval as fe_guard_interval_t;
7715pub use self::fe_hierarchy as fe_hierarchy_t;
7716pub use self::fe_modulation as fe_modulation_t;
7717pub use self::fe_pilot as fe_pilot_t;
7718pub use self::fe_rolloff as fe_rolloff_t;
7719pub use self::fe_sec_mini_cmd as fe_sec_mini_cmd_t;
7720pub use self::fe_sec_tone_mode as fe_sec_tone_mode_t;
7721pub use self::fe_sec_voltage as fe_sec_voltage_t;
7722pub use self::fe_spectral_inversion as fe_spectral_inversion_t;
7723pub use self::fe_status as fe_status_t;
7724pub use self::fe_transmit_mode as fe_transmit_mode_t;
7725pub use self::fe_type as fe_type_t;
7726#[repr(C)]
7727#[derive(Debug, Copy, Clone)]
7728pub struct dvb_qpsk_parameters {
7729 pub symbol_rate: __u32,
7730 pub fec_inner: fe_code_rate_t,
7731}
7732#[test]
7733fn bindgen_test_layout_dvb_qpsk_parameters() {
7734 assert_eq!(
7735 ::std::mem::size_of::<dvb_qpsk_parameters>(),
7736 8usize,
7737 concat!("Size of: ", stringify!(dvb_qpsk_parameters))
7738 );
7739 assert_eq!(
7740 ::std::mem::align_of::<dvb_qpsk_parameters>(),
7741 4usize,
7742 concat!("Alignment of ", stringify!(dvb_qpsk_parameters))
7743 );
7744 assert_eq!(
7745 unsafe { &(*(::std::ptr::null::<dvb_qpsk_parameters>())).symbol_rate as *const _ as usize },
7746 0usize,
7747 concat!(
7748 "Offset of field: ",
7749 stringify!(dvb_qpsk_parameters),
7750 "::",
7751 stringify!(symbol_rate)
7752 )
7753 );
7754 assert_eq!(
7755 unsafe { &(*(::std::ptr::null::<dvb_qpsk_parameters>())).fec_inner as *const _ as usize },
7756 4usize,
7757 concat!(
7758 "Offset of field: ",
7759 stringify!(dvb_qpsk_parameters),
7760 "::",
7761 stringify!(fec_inner)
7762 )
7763 );
7764}
7765#[repr(C)]
7766#[derive(Debug, Copy, Clone)]
7767pub struct dvb_qam_parameters {
7768 pub symbol_rate: __u32,
7769 pub fec_inner: fe_code_rate_t,
7770 pub modulation: fe_modulation_t,
7771}
7772#[test]
7773fn bindgen_test_layout_dvb_qam_parameters() {
7774 assert_eq!(
7775 ::std::mem::size_of::<dvb_qam_parameters>(),
7776 12usize,
7777 concat!("Size of: ", stringify!(dvb_qam_parameters))
7778 );
7779 assert_eq!(
7780 ::std::mem::align_of::<dvb_qam_parameters>(),
7781 4usize,
7782 concat!("Alignment of ", stringify!(dvb_qam_parameters))
7783 );
7784 assert_eq!(
7785 unsafe { &(*(::std::ptr::null::<dvb_qam_parameters>())).symbol_rate as *const _ as usize },
7786 0usize,
7787 concat!(
7788 "Offset of field: ",
7789 stringify!(dvb_qam_parameters),
7790 "::",
7791 stringify!(symbol_rate)
7792 )
7793 );
7794 assert_eq!(
7795 unsafe { &(*(::std::ptr::null::<dvb_qam_parameters>())).fec_inner as *const _ as usize },
7796 4usize,
7797 concat!(
7798 "Offset of field: ",
7799 stringify!(dvb_qam_parameters),
7800 "::",
7801 stringify!(fec_inner)
7802 )
7803 );
7804 assert_eq!(
7805 unsafe { &(*(::std::ptr::null::<dvb_qam_parameters>())).modulation as *const _ as usize },
7806 8usize,
7807 concat!(
7808 "Offset of field: ",
7809 stringify!(dvb_qam_parameters),
7810 "::",
7811 stringify!(modulation)
7812 )
7813 );
7814}
7815#[repr(C)]
7816#[derive(Debug, Copy, Clone)]
7817pub struct dvb_vsb_parameters {
7818 pub modulation: fe_modulation_t,
7819}
7820#[test]
7821fn bindgen_test_layout_dvb_vsb_parameters() {
7822 assert_eq!(
7823 ::std::mem::size_of::<dvb_vsb_parameters>(),
7824 4usize,
7825 concat!("Size of: ", stringify!(dvb_vsb_parameters))
7826 );
7827 assert_eq!(
7828 ::std::mem::align_of::<dvb_vsb_parameters>(),
7829 4usize,
7830 concat!("Alignment of ", stringify!(dvb_vsb_parameters))
7831 );
7832 assert_eq!(
7833 unsafe { &(*(::std::ptr::null::<dvb_vsb_parameters>())).modulation as *const _ as usize },
7834 0usize,
7835 concat!(
7836 "Offset of field: ",
7837 stringify!(dvb_vsb_parameters),
7838 "::",
7839 stringify!(modulation)
7840 )
7841 );
7842}
7843#[repr(C)]
7844#[derive(Debug, Copy, Clone)]
7845pub struct dvb_ofdm_parameters {
7846 pub bandwidth: fe_bandwidth_t,
7847 pub code_rate_HP: fe_code_rate_t,
7848 pub code_rate_LP: fe_code_rate_t,
7849 pub constellation: fe_modulation_t,
7850 pub transmission_mode: fe_transmit_mode_t,
7851 pub guard_interval: fe_guard_interval_t,
7852 pub hierarchy_information: fe_hierarchy_t,
7853}
7854#[test]
7855fn bindgen_test_layout_dvb_ofdm_parameters() {
7856 assert_eq!(
7857 ::std::mem::size_of::<dvb_ofdm_parameters>(),
7858 28usize,
7859 concat!("Size of: ", stringify!(dvb_ofdm_parameters))
7860 );
7861 assert_eq!(
7862 ::std::mem::align_of::<dvb_ofdm_parameters>(),
7863 4usize,
7864 concat!("Alignment of ", stringify!(dvb_ofdm_parameters))
7865 );
7866 assert_eq!(
7867 unsafe { &(*(::std::ptr::null::<dvb_ofdm_parameters>())).bandwidth as *const _ as usize },
7868 0usize,
7869 concat!(
7870 "Offset of field: ",
7871 stringify!(dvb_ofdm_parameters),
7872 "::",
7873 stringify!(bandwidth)
7874 )
7875 );
7876 assert_eq!(
7877 unsafe {
7878 &(*(::std::ptr::null::<dvb_ofdm_parameters>())).code_rate_HP as *const _ as usize
7879 },
7880 4usize,
7881 concat!(
7882 "Offset of field: ",
7883 stringify!(dvb_ofdm_parameters),
7884 "::",
7885 stringify!(code_rate_HP)
7886 )
7887 );
7888 assert_eq!(
7889 unsafe {
7890 &(*(::std::ptr::null::<dvb_ofdm_parameters>())).code_rate_LP as *const _ as usize
7891 },
7892 8usize,
7893 concat!(
7894 "Offset of field: ",
7895 stringify!(dvb_ofdm_parameters),
7896 "::",
7897 stringify!(code_rate_LP)
7898 )
7899 );
7900 assert_eq!(
7901 unsafe {
7902 &(*(::std::ptr::null::<dvb_ofdm_parameters>())).constellation as *const _ as usize
7903 },
7904 12usize,
7905 concat!(
7906 "Offset of field: ",
7907 stringify!(dvb_ofdm_parameters),
7908 "::",
7909 stringify!(constellation)
7910 )
7911 );
7912 assert_eq!(
7913 unsafe {
7914 &(*(::std::ptr::null::<dvb_ofdm_parameters>())).transmission_mode as *const _ as usize
7915 },
7916 16usize,
7917 concat!(
7918 "Offset of field: ",
7919 stringify!(dvb_ofdm_parameters),
7920 "::",
7921 stringify!(transmission_mode)
7922 )
7923 );
7924 assert_eq!(
7925 unsafe {
7926 &(*(::std::ptr::null::<dvb_ofdm_parameters>())).guard_interval as *const _ as usize
7927 },
7928 20usize,
7929 concat!(
7930 "Offset of field: ",
7931 stringify!(dvb_ofdm_parameters),
7932 "::",
7933 stringify!(guard_interval)
7934 )
7935 );
7936 assert_eq!(
7937 unsafe {
7938 &(*(::std::ptr::null::<dvb_ofdm_parameters>())).hierarchy_information as *const _
7939 as usize
7940 },
7941 24usize,
7942 concat!(
7943 "Offset of field: ",
7944 stringify!(dvb_ofdm_parameters),
7945 "::",
7946 stringify!(hierarchy_information)
7947 )
7948 );
7949}
7950#[repr(C)]
7951#[derive(Copy, Clone)]
7952pub struct dvb_frontend_parameters {
7953 pub frequency: __u32,
7954 pub inversion: fe_spectral_inversion_t,
7955 pub u: dvb_frontend_parameters__bindgen_ty_1,
7956}
7957#[repr(C)]
7958#[derive(Copy, Clone)]
7959pub union dvb_frontend_parameters__bindgen_ty_1 {
7960 pub qpsk: dvb_qpsk_parameters,
7961 pub qam: dvb_qam_parameters,
7962 pub ofdm: dvb_ofdm_parameters,
7963 pub vsb: dvb_vsb_parameters,
7964 _bindgen_union_align: [u32; 7usize],
7965}
7966#[test]
7967fn bindgen_test_layout_dvb_frontend_parameters__bindgen_ty_1() {
7968 assert_eq!(
7969 ::std::mem::size_of::<dvb_frontend_parameters__bindgen_ty_1>(),
7970 28usize,
7971 concat!(
7972 "Size of: ",
7973 stringify!(dvb_frontend_parameters__bindgen_ty_1)
7974 )
7975 );
7976 assert_eq!(
7977 ::std::mem::align_of::<dvb_frontend_parameters__bindgen_ty_1>(),
7978 4usize,
7979 concat!(
7980 "Alignment of ",
7981 stringify!(dvb_frontend_parameters__bindgen_ty_1)
7982 )
7983 );
7984 assert_eq!(
7985 unsafe {
7986 &(*(::std::ptr::null::<dvb_frontend_parameters__bindgen_ty_1>())).qpsk as *const _
7987 as usize
7988 },
7989 0usize,
7990 concat!(
7991 "Offset of field: ",
7992 stringify!(dvb_frontend_parameters__bindgen_ty_1),
7993 "::",
7994 stringify!(qpsk)
7995 )
7996 );
7997 assert_eq!(
7998 unsafe {
7999 &(*(::std::ptr::null::<dvb_frontend_parameters__bindgen_ty_1>())).qam as *const _
8000 as usize
8001 },
8002 0usize,
8003 concat!(
8004 "Offset of field: ",
8005 stringify!(dvb_frontend_parameters__bindgen_ty_1),
8006 "::",
8007 stringify!(qam)
8008 )
8009 );
8010 assert_eq!(
8011 unsafe {
8012 &(*(::std::ptr::null::<dvb_frontend_parameters__bindgen_ty_1>())).ofdm as *const _
8013 as usize
8014 },
8015 0usize,
8016 concat!(
8017 "Offset of field: ",
8018 stringify!(dvb_frontend_parameters__bindgen_ty_1),
8019 "::",
8020 stringify!(ofdm)
8021 )
8022 );
8023 assert_eq!(
8024 unsafe {
8025 &(*(::std::ptr::null::<dvb_frontend_parameters__bindgen_ty_1>())).vsb as *const _
8026 as usize
8027 },
8028 0usize,
8029 concat!(
8030 "Offset of field: ",
8031 stringify!(dvb_frontend_parameters__bindgen_ty_1),
8032 "::",
8033 stringify!(vsb)
8034 )
8035 );
8036}
8037#[test]
8038fn bindgen_test_layout_dvb_frontend_parameters() {
8039 assert_eq!(
8040 ::std::mem::size_of::<dvb_frontend_parameters>(),
8041 36usize,
8042 concat!("Size of: ", stringify!(dvb_frontend_parameters))
8043 );
8044 assert_eq!(
8045 ::std::mem::align_of::<dvb_frontend_parameters>(),
8046 4usize,
8047 concat!("Alignment of ", stringify!(dvb_frontend_parameters))
8048 );
8049 assert_eq!(
8050 unsafe {
8051 &(*(::std::ptr::null::<dvb_frontend_parameters>())).frequency as *const _ as usize
8052 },
8053 0usize,
8054 concat!(
8055 "Offset of field: ",
8056 stringify!(dvb_frontend_parameters),
8057 "::",
8058 stringify!(frequency)
8059 )
8060 );
8061 assert_eq!(
8062 unsafe {
8063 &(*(::std::ptr::null::<dvb_frontend_parameters>())).inversion as *const _ as usize
8064 },
8065 4usize,
8066 concat!(
8067 "Offset of field: ",
8068 stringify!(dvb_frontend_parameters),
8069 "::",
8070 stringify!(inversion)
8071 )
8072 );
8073 assert_eq!(
8074 unsafe { &(*(::std::ptr::null::<dvb_frontend_parameters>())).u as *const _ as usize },
8075 8usize,
8076 concat!(
8077 "Offset of field: ",
8078 stringify!(dvb_frontend_parameters),
8079 "::",
8080 stringify!(u)
8081 )
8082 );
8083}
8084#[repr(C)]
8085#[derive(Copy, Clone)]
8086pub struct dvb_frontend_event {
8087 pub status: fe_status_t,
8088 pub parameters: dvb_frontend_parameters,
8089}
8090#[test]
8091fn bindgen_test_layout_dvb_frontend_event() {
8092 assert_eq!(
8093 ::std::mem::size_of::<dvb_frontend_event>(),
8094 40usize,
8095 concat!("Size of: ", stringify!(dvb_frontend_event))
8096 );
8097 assert_eq!(
8098 ::std::mem::align_of::<dvb_frontend_event>(),
8099 4usize,
8100 concat!("Alignment of ", stringify!(dvb_frontend_event))
8101 );
8102 assert_eq!(
8103 unsafe { &(*(::std::ptr::null::<dvb_frontend_event>())).status as *const _ as usize },
8104 0usize,
8105 concat!(
8106 "Offset of field: ",
8107 stringify!(dvb_frontend_event),
8108 "::",
8109 stringify!(status)
8110 )
8111 );
8112 assert_eq!(
8113 unsafe { &(*(::std::ptr::null::<dvb_frontend_event>())).parameters as *const _ as usize },
8114 4usize,
8115 concat!(
8116 "Offset of field: ",
8117 stringify!(dvb_frontend_event),
8118 "::",
8119 stringify!(parameters)
8120 )
8121 );
8122}
8123#[repr(u32)]
8124#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
8125pub enum dvb_sat_polarization {
8126 POLARIZATION_OFF = 0,
8127 POLARIZATION_H = 1,
8128 POLARIZATION_V = 2,
8129 POLARIZATION_L = 3,
8130 POLARIZATION_R = 4,
8131}
8132#[repr(u32)]
8133#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
8134pub enum dvb_quality {
8135 DVB_QUAL_UNKNOWN = 0,
8136 DVB_QUAL_POOR = 1,
8137 DVB_QUAL_OK = 2,
8138 DVB_QUAL_GOOD = 3,
8139}
8140extern "C" {
8141 pub static mut sys_dvbt_props: [::std::os::raw::c_uint; 0usize];
8142}
8143extern "C" {
8144 pub static mut sys_dvbt2_props: [::std::os::raw::c_uint; 0usize];
8145}
8146extern "C" {
8147 pub static mut sys_isdbt_props: [::std::os::raw::c_uint; 0usize];
8148}
8149extern "C" {
8150 pub static mut sys_atsc_props: [::std::os::raw::c_uint; 0usize];
8151}
8152extern "C" {
8153 pub static mut sys_atscmh_props: [::std::os::raw::c_uint; 0usize];
8154}
8155extern "C" {
8156 pub static mut sys_dvbc_annex_ac_props: [::std::os::raw::c_uint; 0usize];
8157}
8158extern "C" {
8159 pub static mut sys_dvbc_annex_b_props: [::std::os::raw::c_uint; 0usize];
8160}
8161extern "C" {
8162 pub static mut sys_dvbs_props: [::std::os::raw::c_uint; 0usize];
8163}
8164extern "C" {
8165 pub static mut sys_dvbs2_props: [::std::os::raw::c_uint; 0usize];
8166}
8167extern "C" {
8168 pub static mut sys_turbo_props: [::std::os::raw::c_uint; 0usize];
8169}
8170extern "C" {
8171 pub static mut sys_isdbs_props: [::std::os::raw::c_uint; 0usize];
8172}
8173extern "C" {
8174 pub static mut dvb_v5_delivery_system: [*const ::std::os::raw::c_uint; 0usize];
8175}
8176extern "C" {
8177 pub static mut dvb_sat_pol_name: [*const ::std::os::raw::c_char; 6usize];
8178}
8179extern "C" {
8180 pub static mut dvb_user_name: [*const ::std::os::raw::c_char; 14usize];
8181}
8182extern "C" {
8183 pub static mut dvb_stat_name: [*const ::std::os::raw::c_char; 6usize];
8184}
8185extern "C" {
8186 pub static mut dvb_user_attr_names: [*const ::std::os::raw::c_void; 0usize];
8187}
8188#[repr(C)]
8189#[derive(Debug, Copy, Clone)]
8190pub struct dvb_sat_lnb {
8191 pub name: *const ::std::os::raw::c_char,
8192 pub alias: *const ::std::os::raw::c_char,
8193 pub lowfreq: ::std::os::raw::c_uint,
8194 pub highfreq: ::std::os::raw::c_uint,
8195 pub rangeswitch: ::std::os::raw::c_uint,
8196 pub freqrange: [dvb_sat_lnb_dvbsat_freqrange; 2usize],
8197}
8198#[repr(C)]
8199#[derive(Debug, Copy, Clone)]
8200pub struct dvb_sat_lnb_dvbsat_freqrange {
8201 pub low: ::std::os::raw::c_uint,
8202 pub high: ::std::os::raw::c_uint,
8203}
8204#[test]
8205fn bindgen_test_layout_dvb_sat_lnb_dvbsat_freqrange() {
8206 assert_eq!(
8207 ::std::mem::size_of::<dvb_sat_lnb_dvbsat_freqrange>(),
8208 8usize,
8209 concat!("Size of: ", stringify!(dvb_sat_lnb_dvbsat_freqrange))
8210 );
8211 assert_eq!(
8212 ::std::mem::align_of::<dvb_sat_lnb_dvbsat_freqrange>(),
8213 4usize,
8214 concat!("Alignment of ", stringify!(dvb_sat_lnb_dvbsat_freqrange))
8215 );
8216 assert_eq!(
8217 unsafe {
8218 &(*(::std::ptr::null::<dvb_sat_lnb_dvbsat_freqrange>())).low as *const _ as usize
8219 },
8220 0usize,
8221 concat!(
8222 "Offset of field: ",
8223 stringify!(dvb_sat_lnb_dvbsat_freqrange),
8224 "::",
8225 stringify!(low)
8226 )
8227 );
8228 assert_eq!(
8229 unsafe {
8230 &(*(::std::ptr::null::<dvb_sat_lnb_dvbsat_freqrange>())).high as *const _ as usize
8231 },
8232 4usize,
8233 concat!(
8234 "Offset of field: ",
8235 stringify!(dvb_sat_lnb_dvbsat_freqrange),
8236 "::",
8237 stringify!(high)
8238 )
8239 );
8240}
8241#[test]
8242fn bindgen_test_layout_dvb_sat_lnb() {
8243 assert_eq!(
8244 ::std::mem::size_of::<dvb_sat_lnb>(),
8245 48usize,
8246 concat!("Size of: ", stringify!(dvb_sat_lnb))
8247 );
8248 assert_eq!(
8249 ::std::mem::align_of::<dvb_sat_lnb>(),
8250 8usize,
8251 concat!("Alignment of ", stringify!(dvb_sat_lnb))
8252 );
8253 assert_eq!(
8254 unsafe { &(*(::std::ptr::null::<dvb_sat_lnb>())).name as *const _ as usize },
8255 0usize,
8256 concat!(
8257 "Offset of field: ",
8258 stringify!(dvb_sat_lnb),
8259 "::",
8260 stringify!(name)
8261 )
8262 );
8263 assert_eq!(
8264 unsafe { &(*(::std::ptr::null::<dvb_sat_lnb>())).alias as *const _ as usize },
8265 8usize,
8266 concat!(
8267 "Offset of field: ",
8268 stringify!(dvb_sat_lnb),
8269 "::",
8270 stringify!(alias)
8271 )
8272 );
8273 assert_eq!(
8274 unsafe { &(*(::std::ptr::null::<dvb_sat_lnb>())).lowfreq as *const _ as usize },
8275 16usize,
8276 concat!(
8277 "Offset of field: ",
8278 stringify!(dvb_sat_lnb),
8279 "::",
8280 stringify!(lowfreq)
8281 )
8282 );
8283 assert_eq!(
8284 unsafe { &(*(::std::ptr::null::<dvb_sat_lnb>())).highfreq as *const _ as usize },
8285 20usize,
8286 concat!(
8287 "Offset of field: ",
8288 stringify!(dvb_sat_lnb),
8289 "::",
8290 stringify!(highfreq)
8291 )
8292 );
8293 assert_eq!(
8294 unsafe { &(*(::std::ptr::null::<dvb_sat_lnb>())).rangeswitch as *const _ as usize },
8295 24usize,
8296 concat!(
8297 "Offset of field: ",
8298 stringify!(dvb_sat_lnb),
8299 "::",
8300 stringify!(rangeswitch)
8301 )
8302 );
8303 assert_eq!(
8304 unsafe { &(*(::std::ptr::null::<dvb_sat_lnb>())).freqrange as *const _ as usize },
8305 28usize,
8306 concat!(
8307 "Offset of field: ",
8308 stringify!(dvb_sat_lnb),
8309 "::",
8310 stringify!(freqrange)
8311 )
8312 );
8313}
8314extern "C" {
8315 pub fn dvb_sat_search_lnb(name: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
8316}
8317extern "C" {
8318 pub fn dvb_print_lnb(index: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
8319}
8320extern "C" {
8321 pub fn dvb_print_all_lnb();
8322}
8323extern "C" {
8324 pub fn dvb_sat_get_lnb(index: ::std::os::raw::c_int) -> *const dvb_sat_lnb;
8325}
8326extern "C" {
8327 pub fn dvb_sat_get_lnb_name(index: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char;
8328}
8329extern "C" {
8330 pub fn dvb_sat_set_parms(parms: *mut dvb_v5_fe_parms) -> ::std::os::raw::c_int;
8331}
8332extern "C" {
8333 pub fn dvb_sat_real_freq(
8334 p: *mut dvb_v5_fe_parms,
8335 freq: ::std::os::raw::c_int,
8336 ) -> ::std::os::raw::c_int;
8337}
8338pub type dvb_logfunc = ::std::option::Option<
8339 unsafe extern "C" fn(level: ::std::os::raw::c_int, fmt: *const ::std::os::raw::c_char, ...),
8340>;
8341pub type dvb_logfunc_priv = ::std::option::Option<
8342 unsafe extern "C" fn(
8343 logpriv: *mut ::std::os::raw::c_void,
8344 level: ::std::os::raw::c_int,
8345 fmt: *const ::std::os::raw::c_char,
8346 ...
8347 ),
8348>;
8349extern "C" {
8350 pub fn dvb_get_log_priv(
8351 arg1: *mut dvb_v5_fe_parms,
8352 arg2: *mut *mut ::std::os::raw::c_void,
8353 ) -> dvb_logfunc_priv;
8354}
8355extern "C" {
8356 pub fn dvb_default_log(level: ::std::os::raw::c_int, fmt: *const ::std::os::raw::c_char, ...);
8357}
8358#[repr(C)]
8359#[derive(Copy, Clone)]
8360pub struct dvb_v5_fe_parms {
8361 pub info: dvb_frontend_info,
8362 pub version: u32,
8363 pub has_v5_stats: ::std::os::raw::c_int,
8364 pub current_sys: fe_delivery_system_t,
8365 pub num_systems: ::std::os::raw::c_int,
8366 pub systems: [fe_delivery_system_t; 20usize],
8367 pub legacy_fe: ::std::os::raw::c_int,
8368 pub abort: ::std::os::raw::c_int,
8369 pub lna: ::std::os::raw::c_int,
8370 pub lnb: *const dvb_sat_lnb,
8371 pub sat_number: ::std::os::raw::c_int,
8372 pub freq_bpf: ::std::os::raw::c_uint,
8373 pub diseqc_wait: ::std::os::raw::c_uint,
8374 pub verbose: ::std::os::raw::c_uint,
8375 pub logfunc: dvb_logfunc,
8376 pub default_charset: *mut ::std::os::raw::c_char,
8377 pub output_charset: *mut ::std::os::raw::c_char,
8378}
8379#[test]
8380fn bindgen_test_layout_dvb_v5_fe_parms() {
8381 assert_eq!(
8382 ::std::mem::size_of::<dvb_v5_fe_parms>(),
8383 328usize,
8384 concat!("Size of: ", stringify!(dvb_v5_fe_parms))
8385 );
8386 assert_eq!(
8387 ::std::mem::align_of::<dvb_v5_fe_parms>(),
8388 8usize,
8389 concat!("Alignment of ", stringify!(dvb_v5_fe_parms))
8390 );
8391 assert_eq!(
8392 unsafe { &(*(::std::ptr::null::<dvb_v5_fe_parms>())).info as *const _ as usize },
8393 0usize,
8394 concat!(
8395 "Offset of field: ",
8396 stringify!(dvb_v5_fe_parms),
8397 "::",
8398 stringify!(info)
8399 )
8400 );
8401 assert_eq!(
8402 unsafe { &(*(::std::ptr::null::<dvb_v5_fe_parms>())).version as *const _ as usize },
8403 168usize,
8404 concat!(
8405 "Offset of field: ",
8406 stringify!(dvb_v5_fe_parms),
8407 "::",
8408 stringify!(version)
8409 )
8410 );
8411 assert_eq!(
8412 unsafe { &(*(::std::ptr::null::<dvb_v5_fe_parms>())).has_v5_stats as *const _ as usize },
8413 172usize,
8414 concat!(
8415 "Offset of field: ",
8416 stringify!(dvb_v5_fe_parms),
8417 "::",
8418 stringify!(has_v5_stats)
8419 )
8420 );
8421 assert_eq!(
8422 unsafe { &(*(::std::ptr::null::<dvb_v5_fe_parms>())).current_sys as *const _ as usize },
8423 176usize,
8424 concat!(
8425 "Offset of field: ",
8426 stringify!(dvb_v5_fe_parms),
8427 "::",
8428 stringify!(current_sys)
8429 )
8430 );
8431 assert_eq!(
8432 unsafe { &(*(::std::ptr::null::<dvb_v5_fe_parms>())).num_systems as *const _ as usize },
8433 180usize,
8434 concat!(
8435 "Offset of field: ",
8436 stringify!(dvb_v5_fe_parms),
8437 "::",
8438 stringify!(num_systems)
8439 )
8440 );
8441 assert_eq!(
8442 unsafe { &(*(::std::ptr::null::<dvb_v5_fe_parms>())).systems as *const _ as usize },
8443 184usize,
8444 concat!(
8445 "Offset of field: ",
8446 stringify!(dvb_v5_fe_parms),
8447 "::",
8448 stringify!(systems)
8449 )
8450 );
8451 assert_eq!(
8452 unsafe { &(*(::std::ptr::null::<dvb_v5_fe_parms>())).legacy_fe as *const _ as usize },
8453 264usize,
8454 concat!(
8455 "Offset of field: ",
8456 stringify!(dvb_v5_fe_parms),
8457 "::",
8458 stringify!(legacy_fe)
8459 )
8460 );
8461 assert_eq!(
8462 unsafe { &(*(::std::ptr::null::<dvb_v5_fe_parms>())).abort as *const _ as usize },
8463 268usize,
8464 concat!(
8465 "Offset of field: ",
8466 stringify!(dvb_v5_fe_parms),
8467 "::",
8468 stringify!(abort)
8469 )
8470 );
8471 assert_eq!(
8472 unsafe { &(*(::std::ptr::null::<dvb_v5_fe_parms>())).lna as *const _ as usize },
8473 272usize,
8474 concat!(
8475 "Offset of field: ",
8476 stringify!(dvb_v5_fe_parms),
8477 "::",
8478 stringify!(lna)
8479 )
8480 );
8481 assert_eq!(
8482 unsafe { &(*(::std::ptr::null::<dvb_v5_fe_parms>())).lnb as *const _ as usize },
8483 280usize,
8484 concat!(
8485 "Offset of field: ",
8486 stringify!(dvb_v5_fe_parms),
8487 "::",
8488 stringify!(lnb)
8489 )
8490 );
8491 assert_eq!(
8492 unsafe { &(*(::std::ptr::null::<dvb_v5_fe_parms>())).sat_number as *const _ as usize },
8493 288usize,
8494 concat!(
8495 "Offset of field: ",
8496 stringify!(dvb_v5_fe_parms),
8497 "::",
8498 stringify!(sat_number)
8499 )
8500 );
8501 assert_eq!(
8502 unsafe { &(*(::std::ptr::null::<dvb_v5_fe_parms>())).freq_bpf as *const _ as usize },
8503 292usize,
8504 concat!(
8505 "Offset of field: ",
8506 stringify!(dvb_v5_fe_parms),
8507 "::",
8508 stringify!(freq_bpf)
8509 )
8510 );
8511 assert_eq!(
8512 unsafe { &(*(::std::ptr::null::<dvb_v5_fe_parms>())).diseqc_wait as *const _ as usize },
8513 296usize,
8514 concat!(
8515 "Offset of field: ",
8516 stringify!(dvb_v5_fe_parms),
8517 "::",
8518 stringify!(diseqc_wait)
8519 )
8520 );
8521 assert_eq!(
8522 unsafe { &(*(::std::ptr::null::<dvb_v5_fe_parms>())).verbose as *const _ as usize },
8523 300usize,
8524 concat!(
8525 "Offset of field: ",
8526 stringify!(dvb_v5_fe_parms),
8527 "::",
8528 stringify!(verbose)
8529 )
8530 );
8531 assert_eq!(
8532 unsafe { &(*(::std::ptr::null::<dvb_v5_fe_parms>())).logfunc as *const _ as usize },
8533 304usize,
8534 concat!(
8535 "Offset of field: ",
8536 stringify!(dvb_v5_fe_parms),
8537 "::",
8538 stringify!(logfunc)
8539 )
8540 );
8541 assert_eq!(
8542 unsafe { &(*(::std::ptr::null::<dvb_v5_fe_parms>())).default_charset as *const _ as usize },
8543 312usize,
8544 concat!(
8545 "Offset of field: ",
8546 stringify!(dvb_v5_fe_parms),
8547 "::",
8548 stringify!(default_charset)
8549 )
8550 );
8551 assert_eq!(
8552 unsafe { &(*(::std::ptr::null::<dvb_v5_fe_parms>())).output_charset as *const _ as usize },
8553 320usize,
8554 concat!(
8555 "Offset of field: ",
8556 stringify!(dvb_v5_fe_parms),
8557 "::",
8558 stringify!(output_charset)
8559 )
8560 );
8561}
8562extern "C" {
8563 pub fn dvb_fe_dummy() -> *mut dvb_v5_fe_parms;
8564}
8565extern "C" {
8566 pub fn dvb_fe_open_flags(
8567 adapter: ::std::os::raw::c_int,
8568 frontend: ::std::os::raw::c_int,
8569 verbose: ::std::os::raw::c_uint,
8570 use_legacy_call: ::std::os::raw::c_uint,
8571 logfunc: dvb_logfunc,
8572 flags: ::std::os::raw::c_int,
8573 ) -> *mut dvb_v5_fe_parms;
8574}
8575extern "C" {
8576 pub fn dvb_fe_open(
8577 adapter: ::std::os::raw::c_int,
8578 frontend: ::std::os::raw::c_int,
8579 verbose: ::std::os::raw::c_uint,
8580 use_legacy_call: ::std::os::raw::c_uint,
8581 ) -> *mut dvb_v5_fe_parms;
8582}
8583extern "C" {
8584 pub fn dvb_fe_open2(
8585 adapter: ::std::os::raw::c_int,
8586 frontend: ::std::os::raw::c_int,
8587 verbose: ::std::os::raw::c_uint,
8588 use_legacy_call: ::std::os::raw::c_uint,
8589 logfunc: dvb_logfunc,
8590 ) -> *mut dvb_v5_fe_parms;
8591}
8592extern "C" {
8593 pub fn dvb_fe_close(parms: *mut dvb_v5_fe_parms);
8594}
8595extern "C" {
8596 pub fn dvb_cmd_name(cmd: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char;
8597}
8598extern "C" {
8599 pub fn dvb_attr_names(cmd: ::std::os::raw::c_int) -> *const *const ::std::os::raw::c_char;
8600}
8601extern "C" {
8602 pub fn dvb_fe_retrieve_parm(
8603 parms: *const dvb_v5_fe_parms,
8604 cmd: ::std::os::raw::c_uint,
8605 value: *mut u32,
8606 ) -> ::std::os::raw::c_int;
8607}
8608extern "C" {
8609 pub fn dvb_fe_store_parm(
8610 parms: *mut dvb_v5_fe_parms,
8611 cmd: ::std::os::raw::c_uint,
8612 value: u32,
8613 ) -> ::std::os::raw::c_int;
8614}
8615extern "C" {
8616 pub fn dvb_set_sys(
8617 parms: *mut dvb_v5_fe_parms,
8618 sys: fe_delivery_system_t,
8619 ) -> ::std::os::raw::c_int;
8620}
8621extern "C" {
8622 pub fn dvb_add_parms_for_sys(
8623 parms: *mut dvb_v5_fe_parms,
8624 sys: fe_delivery_system_t,
8625 ) -> ::std::os::raw::c_int;
8626}
8627extern "C" {
8628 pub fn dvb_set_compat_delivery_system(
8629 parms: *mut dvb_v5_fe_parms,
8630 desired_system: u32,
8631 ) -> ::std::os::raw::c_int;
8632}
8633extern "C" {
8634 pub fn dvb_fe_prt_parms(parms: *const dvb_v5_fe_parms);
8635}
8636extern "C" {
8637 pub fn dvb_fe_set_parms(parms: *mut dvb_v5_fe_parms) -> ::std::os::raw::c_int;
8638}
8639extern "C" {
8640 pub fn dvb_fe_get_parms(parms: *mut dvb_v5_fe_parms) -> ::std::os::raw::c_int;
8641}
8642extern "C" {
8643 pub fn dvb_fe_retrieve_stats_layer(
8644 parms: *mut dvb_v5_fe_parms,
8645 cmd: ::std::os::raw::c_uint,
8646 layer: ::std::os::raw::c_uint,
8647 ) -> *mut dtv_stats;
8648}
8649extern "C" {
8650 pub fn dvb_fe_retrieve_stats(
8651 parms: *mut dvb_v5_fe_parms,
8652 cmd: ::std::os::raw::c_uint,
8653 value: *mut u32,
8654 ) -> ::std::os::raw::c_int;
8655}
8656extern "C" {
8657 pub fn dvb_fe_get_stats(parms: *mut dvb_v5_fe_parms) -> ::std::os::raw::c_int;
8658}
8659extern "C" {
8660 pub fn dvb_fe_retrieve_ber(
8661 parms: *mut dvb_v5_fe_parms,
8662 layer: ::std::os::raw::c_uint,
8663 scale: *mut fecap_scale_params,
8664 ) -> f32;
8665}
8666extern "C" {
8667 pub fn dvb_fe_retrieve_per(parms: *mut dvb_v5_fe_parms, layer: ::std::os::raw::c_uint) -> f32;
8668}
8669extern "C" {
8670 pub fn dvb_fe_retrieve_quality(
8671 parms: *mut dvb_v5_fe_parms,
8672 layer: ::std::os::raw::c_uint,
8673 ) -> dvb_quality;
8674}
8675extern "C" {
8676 pub fn dvb_fe_snprintf_eng(
8677 buf: *mut ::std::os::raw::c_char,
8678 len: ::std::os::raw::c_int,
8679 val: f32,
8680 ) -> ::std::os::raw::c_int;
8681}
8682extern "C" {
8683 pub fn dvb_fe_snprintf_stat(
8684 parms: *mut dvb_v5_fe_parms,
8685 cmd: u32,
8686 display_name: *mut ::std::os::raw::c_char,
8687 layer: ::std::os::raw::c_int,
8688 buf: *mut *mut ::std::os::raw::c_char,
8689 len: *mut ::std::os::raw::c_int,
8690 show_layer_name: *mut ::std::os::raw::c_int,
8691 ) -> ::std::os::raw::c_int;
8692}
8693extern "C" {
8694 pub fn dvb_fe_get_event(parms: *mut dvb_v5_fe_parms) -> ::std::os::raw::c_int;
8695}
8696extern "C" {
8697 pub fn dvb_fe_sec_voltage(
8698 parms: *mut dvb_v5_fe_parms,
8699 on: ::std::os::raw::c_int,
8700 v18: ::std::os::raw::c_int,
8701 ) -> ::std::os::raw::c_int;
8702}
8703extern "C" {
8704 pub fn dvb_fe_sec_tone(
8705 parms: *mut dvb_v5_fe_parms,
8706 tone: fe_sec_tone_mode_t,
8707 ) -> ::std::os::raw::c_int;
8708}
8709extern "C" {
8710 pub fn dvb_fe_lnb_high_voltage(
8711 parms: *mut dvb_v5_fe_parms,
8712 on: ::std::os::raw::c_int,
8713 ) -> ::std::os::raw::c_int;
8714}
8715extern "C" {
8716 pub fn dvb_fe_diseqc_burst(
8717 parms: *mut dvb_v5_fe_parms,
8718 mini_b: ::std::os::raw::c_int,
8719 ) -> ::std::os::raw::c_int;
8720}
8721extern "C" {
8722 pub fn dvb_fe_diseqc_cmd(
8723 parms: *mut dvb_v5_fe_parms,
8724 len: ::std::os::raw::c_uint,
8725 buf: *const ::std::os::raw::c_uchar,
8726 ) -> ::std::os::raw::c_int;
8727}
8728extern "C" {
8729 pub fn dvb_fe_diseqc_reply(
8730 parms: *mut dvb_v5_fe_parms,
8731 len: *mut ::std::os::raw::c_uint,
8732 buf: *mut ::std::os::raw::c_char,
8733 timeout: ::std::os::raw::c_int,
8734 ) -> ::std::os::raw::c_int;
8735}
8736extern "C" {
8737 pub fn dvb_fe_is_satellite(delivery_system: u32) -> ::std::os::raw::c_int;
8738}
8739extern "C" {
8740 pub fn dvb_fe_set_default_country(
8741 parms: *mut dvb_v5_fe_parms,
8742 country: *const ::std::os::raw::c_char,
8743 ) -> ::std::os::raw::c_int;
8744}
8745extern "C" {
8746 pub static fe_bandwidth_name: [::std::os::raw::c_uint; 8usize];
8747}
8748extern "C" {
8749 pub static mut dvb_v5_name: [*const ::std::os::raw::c_char; 72usize];
8750}
8751extern "C" {
8752 pub static mut dvb_v5_attr_names: [*const ::std::os::raw::c_void; 0usize];
8753}
8754extern "C" {
8755 pub static mut fe_code_rate_name: [*const ::std::os::raw::c_char; 14usize];
8756}
8757extern "C" {
8758 pub static mut fe_modulation_name: [*const ::std::os::raw::c_char; 15usize];
8759}
8760extern "C" {
8761 pub static mut fe_transmission_mode_name: [*const ::std::os::raw::c_char; 10usize];
8762}
8763extern "C" {
8764 pub static mut fe_guard_interval_name: [*const ::std::os::raw::c_char; 12usize];
8765}
8766extern "C" {
8767 pub static mut fe_hierarchy_name: [*const ::std::os::raw::c_char; 6usize];
8768}
8769extern "C" {
8770 pub static mut fe_voltage_name: [*const ::std::os::raw::c_char; 4usize];
8771}
8772extern "C" {
8773 pub static mut fe_tone_name: [*const ::std::os::raw::c_char; 3usize];
8774}
8775extern "C" {
8776 pub static mut fe_inversion_name: [*const ::std::os::raw::c_char; 4usize];
8777}
8778extern "C" {
8779 pub static mut fe_pilot_name: [*const ::std::os::raw::c_char; 4usize];
8780}
8781extern "C" {
8782 pub static mut fe_rolloff_name: [*const ::std::os::raw::c_char; 5usize];
8783}
8784#[repr(C)]
8785#[derive(Debug, Copy, Clone)]
8786pub struct dvb_v5_descriptors_program {
8787 pub pat_pgm: *mut dvb_table_pat_program,
8788 pub pmt: *mut dvb_table_pmt,
8789}
8790#[test]
8791fn bindgen_test_layout_dvb_v5_descriptors_program() {
8792 assert_eq!(
8793 ::std::mem::size_of::<dvb_v5_descriptors_program>(),
8794 16usize,
8795 concat!("Size of: ", stringify!(dvb_v5_descriptors_program))
8796 );
8797 assert_eq!(
8798 ::std::mem::align_of::<dvb_v5_descriptors_program>(),
8799 8usize,
8800 concat!("Alignment of ", stringify!(dvb_v5_descriptors_program))
8801 );
8802 assert_eq!(
8803 unsafe {
8804 &(*(::std::ptr::null::<dvb_v5_descriptors_program>())).pat_pgm as *const _ as usize
8805 },
8806 0usize,
8807 concat!(
8808 "Offset of field: ",
8809 stringify!(dvb_v5_descriptors_program),
8810 "::",
8811 stringify!(pat_pgm)
8812 )
8813 );
8814 assert_eq!(
8815 unsafe { &(*(::std::ptr::null::<dvb_v5_descriptors_program>())).pmt as *const _ as usize },
8816 8usize,
8817 concat!(
8818 "Offset of field: ",
8819 stringify!(dvb_v5_descriptors_program),
8820 "::",
8821 stringify!(pmt)
8822 )
8823 );
8824}
8825#[repr(C)]
8826#[derive(Debug, Copy, Clone)]
8827pub struct dvb_v5_descriptors {
8828 pub delivery_system: u32,
8829 pub entry: *mut dvb_entry,
8830 pub num_entry: ::std::os::raw::c_uint,
8831 pub pat: *mut dvb_table_pat,
8832 pub vct: *mut atsc_table_vct,
8833 pub program: *mut dvb_v5_descriptors_program,
8834 pub nit: *mut dvb_table_nit,
8835 pub sdt: *mut dvb_table_sdt,
8836 pub num_program: ::std::os::raw::c_uint,
8837 pub other_nits: *mut *mut dvb_table_nit,
8838 pub num_other_nits: ::std::os::raw::c_uint,
8839 pub other_sdts: *mut *mut dvb_table_sdt,
8840 pub num_other_sdts: ::std::os::raw::c_uint,
8841}
8842#[test]
8843fn bindgen_test_layout_dvb_v5_descriptors() {
8844 assert_eq!(
8845 ::std::mem::size_of::<dvb_v5_descriptors>(),
8846 104usize,
8847 concat!("Size of: ", stringify!(dvb_v5_descriptors))
8848 );
8849 assert_eq!(
8850 ::std::mem::align_of::<dvb_v5_descriptors>(),
8851 8usize,
8852 concat!("Alignment of ", stringify!(dvb_v5_descriptors))
8853 );
8854 assert_eq!(
8855 unsafe {
8856 &(*(::std::ptr::null::<dvb_v5_descriptors>())).delivery_system as *const _ as usize
8857 },
8858 0usize,
8859 concat!(
8860 "Offset of field: ",
8861 stringify!(dvb_v5_descriptors),
8862 "::",
8863 stringify!(delivery_system)
8864 )
8865 );
8866 assert_eq!(
8867 unsafe { &(*(::std::ptr::null::<dvb_v5_descriptors>())).entry as *const _ as usize },
8868 8usize,
8869 concat!(
8870 "Offset of field: ",
8871 stringify!(dvb_v5_descriptors),
8872 "::",
8873 stringify!(entry)
8874 )
8875 );
8876 assert_eq!(
8877 unsafe { &(*(::std::ptr::null::<dvb_v5_descriptors>())).num_entry as *const _ as usize },
8878 16usize,
8879 concat!(
8880 "Offset of field: ",
8881 stringify!(dvb_v5_descriptors),
8882 "::",
8883 stringify!(num_entry)
8884 )
8885 );
8886 assert_eq!(
8887 unsafe { &(*(::std::ptr::null::<dvb_v5_descriptors>())).pat as *const _ as usize },
8888 24usize,
8889 concat!(
8890 "Offset of field: ",
8891 stringify!(dvb_v5_descriptors),
8892 "::",
8893 stringify!(pat)
8894 )
8895 );
8896 assert_eq!(
8897 unsafe { &(*(::std::ptr::null::<dvb_v5_descriptors>())).vct as *const _ as usize },
8898 32usize,
8899 concat!(
8900 "Offset of field: ",
8901 stringify!(dvb_v5_descriptors),
8902 "::",
8903 stringify!(vct)
8904 )
8905 );
8906 assert_eq!(
8907 unsafe { &(*(::std::ptr::null::<dvb_v5_descriptors>())).program as *const _ as usize },
8908 40usize,
8909 concat!(
8910 "Offset of field: ",
8911 stringify!(dvb_v5_descriptors),
8912 "::",
8913 stringify!(program)
8914 )
8915 );
8916 assert_eq!(
8917 unsafe { &(*(::std::ptr::null::<dvb_v5_descriptors>())).nit as *const _ as usize },
8918 48usize,
8919 concat!(
8920 "Offset of field: ",
8921 stringify!(dvb_v5_descriptors),
8922 "::",
8923 stringify!(nit)
8924 )
8925 );
8926 assert_eq!(
8927 unsafe { &(*(::std::ptr::null::<dvb_v5_descriptors>())).sdt as *const _ as usize },
8928 56usize,
8929 concat!(
8930 "Offset of field: ",
8931 stringify!(dvb_v5_descriptors),
8932 "::",
8933 stringify!(sdt)
8934 )
8935 );
8936 assert_eq!(
8937 unsafe { &(*(::std::ptr::null::<dvb_v5_descriptors>())).num_program as *const _ as usize },
8938 64usize,
8939 concat!(
8940 "Offset of field: ",
8941 stringify!(dvb_v5_descriptors),
8942 "::",
8943 stringify!(num_program)
8944 )
8945 );
8946 assert_eq!(
8947 unsafe { &(*(::std::ptr::null::<dvb_v5_descriptors>())).other_nits as *const _ as usize },
8948 72usize,
8949 concat!(
8950 "Offset of field: ",
8951 stringify!(dvb_v5_descriptors),
8952 "::",
8953 stringify!(other_nits)
8954 )
8955 );
8956 assert_eq!(
8957 unsafe {
8958 &(*(::std::ptr::null::<dvb_v5_descriptors>())).num_other_nits as *const _ as usize
8959 },
8960 80usize,
8961 concat!(
8962 "Offset of field: ",
8963 stringify!(dvb_v5_descriptors),
8964 "::",
8965 stringify!(num_other_nits)
8966 )
8967 );
8968 assert_eq!(
8969 unsafe { &(*(::std::ptr::null::<dvb_v5_descriptors>())).other_sdts as *const _ as usize },
8970 88usize,
8971 concat!(
8972 "Offset of field: ",
8973 stringify!(dvb_v5_descriptors),
8974 "::",
8975 stringify!(other_sdts)
8976 )
8977 );
8978 assert_eq!(
8979 unsafe {
8980 &(*(::std::ptr::null::<dvb_v5_descriptors>())).num_other_sdts as *const _ as usize
8981 },
8982 96usize,
8983 concat!(
8984 "Offset of field: ",
8985 stringify!(dvb_v5_descriptors),
8986 "::",
8987 stringify!(num_other_sdts)
8988 )
8989 );
8990}
8991#[repr(C)]
8992#[derive(Debug, Copy, Clone)]
8993pub struct dvb_table_filter {
8994 pub tid: ::std::os::raw::c_uchar,
8995 pub pid: u16,
8996 pub ts_id: ::std::os::raw::c_int,
8997 pub table: *mut *mut ::std::os::raw::c_void,
8998 pub allow_section_gaps: ::std::os::raw::c_int,
8999 pub priv_: *mut ::std::os::raw::c_void,
9000}
9001#[test]
9002fn bindgen_test_layout_dvb_table_filter() {
9003 assert_eq!(
9004 ::std::mem::size_of::<dvb_table_filter>(),
9005 32usize,
9006 concat!("Size of: ", stringify!(dvb_table_filter))
9007 );
9008 assert_eq!(
9009 ::std::mem::align_of::<dvb_table_filter>(),
9010 8usize,
9011 concat!("Alignment of ", stringify!(dvb_table_filter))
9012 );
9013 assert_eq!(
9014 unsafe { &(*(::std::ptr::null::<dvb_table_filter>())).tid as *const _ as usize },
9015 0usize,
9016 concat!(
9017 "Offset of field: ",
9018 stringify!(dvb_table_filter),
9019 "::",
9020 stringify!(tid)
9021 )
9022 );
9023 assert_eq!(
9024 unsafe { &(*(::std::ptr::null::<dvb_table_filter>())).pid as *const _ as usize },
9025 2usize,
9026 concat!(
9027 "Offset of field: ",
9028 stringify!(dvb_table_filter),
9029 "::",
9030 stringify!(pid)
9031 )
9032 );
9033 assert_eq!(
9034 unsafe { &(*(::std::ptr::null::<dvb_table_filter>())).ts_id as *const _ as usize },
9035 4usize,
9036 concat!(
9037 "Offset of field: ",
9038 stringify!(dvb_table_filter),
9039 "::",
9040 stringify!(ts_id)
9041 )
9042 );
9043 assert_eq!(
9044 unsafe { &(*(::std::ptr::null::<dvb_table_filter>())).table as *const _ as usize },
9045 8usize,
9046 concat!(
9047 "Offset of field: ",
9048 stringify!(dvb_table_filter),
9049 "::",
9050 stringify!(table)
9051 )
9052 );
9053 assert_eq!(
9054 unsafe {
9055 &(*(::std::ptr::null::<dvb_table_filter>())).allow_section_gaps as *const _ as usize
9056 },
9057 16usize,
9058 concat!(
9059 "Offset of field: ",
9060 stringify!(dvb_table_filter),
9061 "::",
9062 stringify!(allow_section_gaps)
9063 )
9064 );
9065 assert_eq!(
9066 unsafe { &(*(::std::ptr::null::<dvb_table_filter>())).priv_ as *const _ as usize },
9067 24usize,
9068 concat!(
9069 "Offset of field: ",
9070 stringify!(dvb_table_filter),
9071 "::",
9072 stringify!(priv_)
9073 )
9074 );
9075}
9076extern "C" {
9077 pub fn dvb_table_filter_free(sect: *mut dvb_table_filter);
9078}
9079extern "C" {
9080 pub fn dvb_read_section(
9081 parms: *mut dvb_v5_fe_parms,
9082 dmx_fd: ::std::os::raw::c_int,
9083 tid: ::std::os::raw::c_uchar,
9084 pid: u16,
9085 table: *mut *mut ::std::os::raw::c_void,
9086 timeout: ::std::os::raw::c_uint,
9087 ) -> ::std::os::raw::c_int;
9088}
9089extern "C" {
9090 pub fn dvb_read_section_with_id(
9091 parms: *mut dvb_v5_fe_parms,
9092 dmx_fd: ::std::os::raw::c_int,
9093 tid: ::std::os::raw::c_uchar,
9094 pid: u16,
9095 ts_id: ::std::os::raw::c_int,
9096 table: *mut *mut ::std::os::raw::c_void,
9097 timeout: ::std::os::raw::c_uint,
9098 ) -> ::std::os::raw::c_int;
9099}
9100extern "C" {
9101 pub fn dvb_read_sections(
9102 parms: *mut dvb_v5_fe_parms,
9103 dmx_fd: ::std::os::raw::c_int,
9104 sect: *mut dvb_table_filter,
9105 timeout: ::std::os::raw::c_uint,
9106 ) -> ::std::os::raw::c_int;
9107}
9108extern "C" {
9109 pub fn dvb_scan_alloc_handler_table(delivery_system: u32) -> *mut dvb_v5_descriptors;
9110}
9111extern "C" {
9112 pub fn dvb_scan_free_handler_table(dvb_scan_handler: *mut dvb_v5_descriptors);
9113}
9114extern "C" {
9115 pub fn dvb_get_ts_tables(
9116 parms: *mut dvb_v5_fe_parms,
9117 dmx_fd: ::std::os::raw::c_int,
9118 delivery_system: u32,
9119 other_nit: ::std::os::raw::c_uint,
9120 timeout_multiply: ::std::os::raw::c_uint,
9121 ) -> *mut dvb_v5_descriptors;
9122}
9123extern "C" {
9124 pub fn dvb_free_ts_tables(dvb_desc: *mut dvb_v5_descriptors);
9125}
9126pub type check_frontend_t = ::std::option::Option<
9127 unsafe extern "C" fn(
9128 args: *mut ::std::os::raw::c_void,
9129 parms: *mut dvb_v5_fe_parms,
9130 ) -> ::std::os::raw::c_int,
9131>;
9132extern "C" {
9133 pub fn dvb_scan_transponder(
9134 parms: *mut dvb_v5_fe_parms,
9135 entry: *mut dvb_entry,
9136 dmx_fd: ::std::os::raw::c_int,
9137 check_frontend: check_frontend_t,
9138 args: *mut ::std::os::raw::c_void,
9139 other_nit: ::std::os::raw::c_uint,
9140 timeout_multiply: ::std::os::raw::c_uint,
9141 ) -> *mut dvb_v5_descriptors;
9142}
9143extern "C" {
9144 pub fn dvb_add_scaned_transponders(
9145 parms: *mut dvb_v5_fe_parms,
9146 dvb_scan_handler: *mut dvb_v5_descriptors,
9147 first_entry: *mut dvb_entry,
9148 entry: *mut dvb_entry,
9149 );
9150}
9151extern "C" {
9152 pub fn dvb_estimate_freq_shift(parms: *mut dvb_v5_fe_parms) -> ::std::os::raw::c_int;
9153}
9154extern "C" {
9155 pub fn dvb_new_freq_is_needed(
9156 entry: *mut dvb_entry,
9157 last_entry: *mut dvb_entry,
9158 freq: u32,
9159 pol: dvb_sat_polarization,
9160 shift: ::std::os::raw::c_int,
9161 ) -> ::std::os::raw::c_int;
9162}
9163extern "C" {
9164 pub fn dvb_scan_add_entry(
9165 parms: *mut dvb_v5_fe_parms,
9166 first_entry: *mut dvb_entry,
9167 entry: *mut dvb_entry,
9168 freq: u32,
9169 shift: u32,
9170 pol: dvb_sat_polarization,
9171 ) -> *mut dvb_entry;
9172}
9173extern "C" {
9174 pub fn dvb_new_entry_is_needed(
9175 entry: *mut dvb_entry,
9176 last_entry: *mut dvb_entry,
9177 freq: u32,
9178 shift: ::std::os::raw::c_int,
9179 pol: dvb_sat_polarization,
9180 stream_id: u32,
9181 ) -> ::std::os::raw::c_int;
9182}
9183extern "C" {
9184 pub fn dvb_scan_add_entry_ex(
9185 parms: *mut dvb_v5_fe_parms,
9186 first_entry: *mut dvb_entry,
9187 entry: *mut dvb_entry,
9188 freq: u32,
9189 shift: u32,
9190 pol: dvb_sat_polarization,
9191 stream_id: u32,
9192 ) -> *mut dvb_entry;
9193}
9194extern "C" {
9195 pub fn dvb_update_transponders(
9196 parms: *mut dvb_v5_fe_parms,
9197 dvb_scan_handler: *mut dvb_v5_descriptors,
9198 first_entry: *mut dvb_entry,
9199 entry: *mut dvb_entry,
9200 );
9201}
9202#[repr(u32)]
9203#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
9204pub enum dvb_dev_type {
9205 DVB_DEVICE_FRONTEND = 0,
9206 DVB_DEVICE_DEMUX = 1,
9207 DVB_DEVICE_DVR = 2,
9208 DVB_DEVICE_NET = 3,
9209 DVB_DEVICE_CA = 4,
9210 DVB_DEVICE_CA_SEC = 5,
9211 DVB_DEVICE_VIDEO = 6,
9212 DVB_DEVICE_AUDIO = 7,
9213}
9214#[repr(C)]
9215#[derive(Debug, Copy, Clone)]
9216pub struct dvb_dev_list {
9217 pub syspath: *mut ::std::os::raw::c_char,
9218 pub path: *mut ::std::os::raw::c_char,
9219 pub sysname: *mut ::std::os::raw::c_char,
9220 pub dvb_type: dvb_dev_type,
9221 pub bus_addr: *mut ::std::os::raw::c_char,
9222 pub bus_id: *mut ::std::os::raw::c_char,
9223 pub manufacturer: *mut ::std::os::raw::c_char,
9224 pub product: *mut ::std::os::raw::c_char,
9225 pub serial: *mut ::std::os::raw::c_char,
9226}
9227#[test]
9228fn bindgen_test_layout_dvb_dev_list() {
9229 assert_eq!(
9230 ::std::mem::size_of::<dvb_dev_list>(),
9231 72usize,
9232 concat!("Size of: ", stringify!(dvb_dev_list))
9233 );
9234 assert_eq!(
9235 ::std::mem::align_of::<dvb_dev_list>(),
9236 8usize,
9237 concat!("Alignment of ", stringify!(dvb_dev_list))
9238 );
9239 assert_eq!(
9240 unsafe { &(*(::std::ptr::null::<dvb_dev_list>())).syspath as *const _ as usize },
9241 0usize,
9242 concat!(
9243 "Offset of field: ",
9244 stringify!(dvb_dev_list),
9245 "::",
9246 stringify!(syspath)
9247 )
9248 );
9249 assert_eq!(
9250 unsafe { &(*(::std::ptr::null::<dvb_dev_list>())).path as *const _ as usize },
9251 8usize,
9252 concat!(
9253 "Offset of field: ",
9254 stringify!(dvb_dev_list),
9255 "::",
9256 stringify!(path)
9257 )
9258 );
9259 assert_eq!(
9260 unsafe { &(*(::std::ptr::null::<dvb_dev_list>())).sysname as *const _ as usize },
9261 16usize,
9262 concat!(
9263 "Offset of field: ",
9264 stringify!(dvb_dev_list),
9265 "::",
9266 stringify!(sysname)
9267 )
9268 );
9269 assert_eq!(
9270 unsafe { &(*(::std::ptr::null::<dvb_dev_list>())).dvb_type as *const _ as usize },
9271 24usize,
9272 concat!(
9273 "Offset of field: ",
9274 stringify!(dvb_dev_list),
9275 "::",
9276 stringify!(dvb_type)
9277 )
9278 );
9279 assert_eq!(
9280 unsafe { &(*(::std::ptr::null::<dvb_dev_list>())).bus_addr as *const _ as usize },
9281 32usize,
9282 concat!(
9283 "Offset of field: ",
9284 stringify!(dvb_dev_list),
9285 "::",
9286 stringify!(bus_addr)
9287 )
9288 );
9289 assert_eq!(
9290 unsafe { &(*(::std::ptr::null::<dvb_dev_list>())).bus_id as *const _ as usize },
9291 40usize,
9292 concat!(
9293 "Offset of field: ",
9294 stringify!(dvb_dev_list),
9295 "::",
9296 stringify!(bus_id)
9297 )
9298 );
9299 assert_eq!(
9300 unsafe { &(*(::std::ptr::null::<dvb_dev_list>())).manufacturer as *const _ as usize },
9301 48usize,
9302 concat!(
9303 "Offset of field: ",
9304 stringify!(dvb_dev_list),
9305 "::",
9306 stringify!(manufacturer)
9307 )
9308 );
9309 assert_eq!(
9310 unsafe { &(*(::std::ptr::null::<dvb_dev_list>())).product as *const _ as usize },
9311 56usize,
9312 concat!(
9313 "Offset of field: ",
9314 stringify!(dvb_dev_list),
9315 "::",
9316 stringify!(product)
9317 )
9318 );
9319 assert_eq!(
9320 unsafe { &(*(::std::ptr::null::<dvb_dev_list>())).serial as *const _ as usize },
9321 64usize,
9322 concat!(
9323 "Offset of field: ",
9324 stringify!(dvb_dev_list),
9325 "::",
9326 stringify!(serial)
9327 )
9328 );
9329}
9330#[repr(u32)]
9331#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
9332pub enum dvb_dev_change_type {
9333 DVB_DEV_ADD = 0,
9334 DVB_DEV_CHANGE = 1,
9335 DVB_DEV_REMOVE = 2,
9336}
9337pub type dvb_dev_change_t = ::std::option::Option<
9338 unsafe extern "C" fn(
9339 sysname: *mut ::std::os::raw::c_char,
9340 type_: dvb_dev_change_type,
9341 priv_: *mut ::std::os::raw::c_void,
9342 ) -> ::std::os::raw::c_int,
9343>;
9344#[repr(C)]
9345#[derive(Debug, Copy, Clone)]
9346pub struct dvb_open_descriptor {
9347 _unused: [u8; 0],
9348}
9349#[repr(C)]
9350#[derive(Debug, Copy, Clone)]
9351pub struct dvb_device {
9352 pub devices: *mut dvb_dev_list,
9353 pub num_devices: ::std::os::raw::c_int,
9354 pub fe_parms: *mut dvb_v5_fe_parms,
9355}
9356#[test]
9357fn bindgen_test_layout_dvb_device() {
9358 assert_eq!(
9359 ::std::mem::size_of::<dvb_device>(),
9360 24usize,
9361 concat!("Size of: ", stringify!(dvb_device))
9362 );
9363 assert_eq!(
9364 ::std::mem::align_of::<dvb_device>(),
9365 8usize,
9366 concat!("Alignment of ", stringify!(dvb_device))
9367 );
9368 assert_eq!(
9369 unsafe { &(*(::std::ptr::null::<dvb_device>())).devices as *const _ as usize },
9370 0usize,
9371 concat!(
9372 "Offset of field: ",
9373 stringify!(dvb_device),
9374 "::",
9375 stringify!(devices)
9376 )
9377 );
9378 assert_eq!(
9379 unsafe { &(*(::std::ptr::null::<dvb_device>())).num_devices as *const _ as usize },
9380 8usize,
9381 concat!(
9382 "Offset of field: ",
9383 stringify!(dvb_device),
9384 "::",
9385 stringify!(num_devices)
9386 )
9387 );
9388 assert_eq!(
9389 unsafe { &(*(::std::ptr::null::<dvb_device>())).fe_parms as *const _ as usize },
9390 16usize,
9391 concat!(
9392 "Offset of field: ",
9393 stringify!(dvb_device),
9394 "::",
9395 stringify!(fe_parms)
9396 )
9397 );
9398}
9399extern "C" {
9400 pub fn dvb_dev_alloc() -> *mut dvb_device;
9401}
9402extern "C" {
9403 pub fn dvb_dev_free(dvb: *mut dvb_device);
9404}
9405extern "C" {
9406 pub fn dvb_dev_find(
9407 dvb: *mut dvb_device,
9408 handler: dvb_dev_change_t,
9409 user_priv: *mut ::std::os::raw::c_void,
9410 ) -> ::std::os::raw::c_int;
9411}
9412extern "C" {
9413 pub fn dvb_dev_seek_by_adapter(
9414 dvb: *mut dvb_device,
9415 adapter: ::std::os::raw::c_uint,
9416 num: ::std::os::raw::c_uint,
9417 type_: dvb_dev_type,
9418 ) -> *mut dvb_dev_list;
9419}
9420extern "C" {
9421 pub fn dvb_get_dev_info(
9422 dvb: *mut dvb_device,
9423 sysname: *const ::std::os::raw::c_char,
9424 ) -> *mut dvb_dev_list;
9425}
9426extern "C" {
9427 pub fn dvb_dev_stop_monitor(dvb: *mut dvb_device);
9428}
9429extern "C" {
9430 pub fn dvb_dev_set_logpriv(
9431 dvb: *mut dvb_device,
9432 verbose: ::std::os::raw::c_uint,
9433 logfunc: dvb_logfunc_priv,
9434 logpriv: *mut ::std::os::raw::c_void,
9435 );
9436}
9437extern "C" {
9438 pub fn dvb_dev_set_log(
9439 dvb: *mut dvb_device,
9440 verbose: ::std::os::raw::c_uint,
9441 logfunc: dvb_logfunc,
9442 );
9443}
9444extern "C" {
9445 pub fn dvb_dev_open(
9446 dvb: *mut dvb_device,
9447 sysname: *const ::std::os::raw::c_char,
9448 flags: ::std::os::raw::c_int,
9449 ) -> *mut dvb_open_descriptor;
9450}
9451extern "C" {
9452 pub fn dvb_dev_close(open_dev: *mut dvb_open_descriptor);
9453}
9454extern "C" {
9455 pub fn dvb_dev_get_fd(open_dev: *mut dvb_open_descriptor) -> ::std::os::raw::c_int;
9456}
9457extern "C" {
9458 pub fn dvb_dev_read(
9459 open_dev: *mut dvb_open_descriptor,
9460 buf: *mut ::std::os::raw::c_void,
9461 count: size_t,
9462 ) -> ssize_t;
9463}
9464extern "C" {
9465 pub fn dvb_dev_dmx_stop(open_dev: *mut dvb_open_descriptor);
9466}
9467extern "C" {
9468 pub fn dvb_dev_set_bufsize(
9469 open_dev: *mut dvb_open_descriptor,
9470 buffersize: ::std::os::raw::c_int,
9471 ) -> ::std::os::raw::c_int;
9472}
9473extern "C" {
9474 pub fn dvb_dev_dmx_set_pesfilter(
9475 open_dev: *mut dvb_open_descriptor,
9476 pid: ::std::os::raw::c_int,
9477 type_: dmx_pes_type_t,
9478 output: dmx_output_t,
9479 buffersize: ::std::os::raw::c_int,
9480 ) -> ::std::os::raw::c_int;
9481}
9482extern "C" {
9483 pub fn dvb_dev_dmx_set_section_filter(
9484 open_dev: *mut dvb_open_descriptor,
9485 pid: ::std::os::raw::c_int,
9486 filtsize: ::std::os::raw::c_uint,
9487 filter: *mut ::std::os::raw::c_uchar,
9488 mask: *mut ::std::os::raw::c_uchar,
9489 mode: *mut ::std::os::raw::c_uchar,
9490 flags: ::std::os::raw::c_uint,
9491 ) -> ::std::os::raw::c_int;
9492}
9493extern "C" {
9494 pub fn dvb_dev_dmx_get_pmt_pid(
9495 open_dev: *mut dvb_open_descriptor,
9496 sid: ::std::os::raw::c_int,
9497 ) -> ::std::os::raw::c_int;
9498}
9499extern "C" {
9500 pub fn dvb_dev_scan(
9501 open_dev: *mut dvb_open_descriptor,
9502 entry: *mut dvb_entry,
9503 check_frontend: check_frontend_t,
9504 args: *mut ::std::os::raw::c_void,
9505 other_nit: ::std::os::raw::c_uint,
9506 timeout_multiply: ::std::os::raw::c_uint,
9507 ) -> *mut dvb_v5_descriptors;
9508}
9509#[repr(C)]
9510#[derive(Debug, Copy, Clone)]
9511pub struct dvb_elementary_pid {
9512 pub type_: u8,
9513 pub pid: u16,
9514}
9515#[test]
9516fn bindgen_test_layout_dvb_elementary_pid() {
9517 assert_eq!(
9518 ::std::mem::size_of::<dvb_elementary_pid>(),
9519 4usize,
9520 concat!("Size of: ", stringify!(dvb_elementary_pid))
9521 );
9522 assert_eq!(
9523 ::std::mem::align_of::<dvb_elementary_pid>(),
9524 2usize,
9525 concat!("Alignment of ", stringify!(dvb_elementary_pid))
9526 );
9527 assert_eq!(
9528 unsafe { &(*(::std::ptr::null::<dvb_elementary_pid>())).type_ as *const _ as usize },
9529 0usize,
9530 concat!(
9531 "Offset of field: ",
9532 stringify!(dvb_elementary_pid),
9533 "::",
9534 stringify!(type_)
9535 )
9536 );
9537 assert_eq!(
9538 unsafe { &(*(::std::ptr::null::<dvb_elementary_pid>())).pid as *const _ as usize },
9539 2usize,
9540 concat!(
9541 "Offset of field: ",
9542 stringify!(dvb_elementary_pid),
9543 "::",
9544 stringify!(pid)
9545 )
9546 );
9547}
9548#[repr(C)]
9549#[derive(Copy, Clone)]
9550pub struct dvb_entry {
9551 pub props: [dtv_property; 70usize],
9552 pub n_props: ::std::os::raw::c_uint,
9553 pub next: *mut dvb_entry,
9554 pub service_id: u16,
9555 pub video_pid: *mut u16,
9556 pub audio_pid: *mut u16,
9557 pub other_el_pid: *mut dvb_elementary_pid,
9558 pub video_pid_len: ::std::os::raw::c_uint,
9559 pub audio_pid_len: ::std::os::raw::c_uint,
9560 pub other_el_pid_len: ::std::os::raw::c_uint,
9561 pub channel: *mut ::std::os::raw::c_char,
9562 pub vchannel: *mut ::std::os::raw::c_char,
9563 pub location: *mut ::std::os::raw::c_char,
9564 pub sat_number: ::std::os::raw::c_int,
9565 pub freq_bpf: ::std::os::raw::c_uint,
9566 pub diseqc_wait: ::std::os::raw::c_uint,
9567 pub lnb: *mut ::std::os::raw::c_char,
9568 pub network_id: u16,
9569 pub transport_id: u16,
9570}
9571#[test]
9572fn bindgen_test_layout_dvb_entry() {
9573 assert_eq!(
9574 ::std::mem::size_of::<dvb_entry>(),
9575 5440usize,
9576 concat!("Size of: ", stringify!(dvb_entry))
9577 );
9578 assert_eq!(
9579 ::std::mem::align_of::<dvb_entry>(),
9580 8usize,
9581 concat!("Alignment of ", stringify!(dvb_entry))
9582 );
9583 assert_eq!(
9584 unsafe { &(*(::std::ptr::null::<dvb_entry>())).props as *const _ as usize },
9585 0usize,
9586 concat!(
9587 "Offset of field: ",
9588 stringify!(dvb_entry),
9589 "::",
9590 stringify!(props)
9591 )
9592 );
9593 assert_eq!(
9594 unsafe { &(*(::std::ptr::null::<dvb_entry>())).n_props as *const _ as usize },
9595 5320usize,
9596 concat!(
9597 "Offset of field: ",
9598 stringify!(dvb_entry),
9599 "::",
9600 stringify!(n_props)
9601 )
9602 );
9603 assert_eq!(
9604 unsafe { &(*(::std::ptr::null::<dvb_entry>())).next as *const _ as usize },
9605 5328usize,
9606 concat!(
9607 "Offset of field: ",
9608 stringify!(dvb_entry),
9609 "::",
9610 stringify!(next)
9611 )
9612 );
9613 assert_eq!(
9614 unsafe { &(*(::std::ptr::null::<dvb_entry>())).service_id as *const _ as usize },
9615 5336usize,
9616 concat!(
9617 "Offset of field: ",
9618 stringify!(dvb_entry),
9619 "::",
9620 stringify!(service_id)
9621 )
9622 );
9623 assert_eq!(
9624 unsafe { &(*(::std::ptr::null::<dvb_entry>())).video_pid as *const _ as usize },
9625 5344usize,
9626 concat!(
9627 "Offset of field: ",
9628 stringify!(dvb_entry),
9629 "::",
9630 stringify!(video_pid)
9631 )
9632 );
9633 assert_eq!(
9634 unsafe { &(*(::std::ptr::null::<dvb_entry>())).audio_pid as *const _ as usize },
9635 5352usize,
9636 concat!(
9637 "Offset of field: ",
9638 stringify!(dvb_entry),
9639 "::",
9640 stringify!(audio_pid)
9641 )
9642 );
9643 assert_eq!(
9644 unsafe { &(*(::std::ptr::null::<dvb_entry>())).other_el_pid as *const _ as usize },
9645 5360usize,
9646 concat!(
9647 "Offset of field: ",
9648 stringify!(dvb_entry),
9649 "::",
9650 stringify!(other_el_pid)
9651 )
9652 );
9653 assert_eq!(
9654 unsafe { &(*(::std::ptr::null::<dvb_entry>())).video_pid_len as *const _ as usize },
9655 5368usize,
9656 concat!(
9657 "Offset of field: ",
9658 stringify!(dvb_entry),
9659 "::",
9660 stringify!(video_pid_len)
9661 )
9662 );
9663 assert_eq!(
9664 unsafe { &(*(::std::ptr::null::<dvb_entry>())).audio_pid_len as *const _ as usize },
9665 5372usize,
9666 concat!(
9667 "Offset of field: ",
9668 stringify!(dvb_entry),
9669 "::",
9670 stringify!(audio_pid_len)
9671 )
9672 );
9673 assert_eq!(
9674 unsafe { &(*(::std::ptr::null::<dvb_entry>())).other_el_pid_len as *const _ as usize },
9675 5376usize,
9676 concat!(
9677 "Offset of field: ",
9678 stringify!(dvb_entry),
9679 "::",
9680 stringify!(other_el_pid_len)
9681 )
9682 );
9683 assert_eq!(
9684 unsafe { &(*(::std::ptr::null::<dvb_entry>())).channel as *const _ as usize },
9685 5384usize,
9686 concat!(
9687 "Offset of field: ",
9688 stringify!(dvb_entry),
9689 "::",
9690 stringify!(channel)
9691 )
9692 );
9693 assert_eq!(
9694 unsafe { &(*(::std::ptr::null::<dvb_entry>())).vchannel as *const _ as usize },
9695 5392usize,
9696 concat!(
9697 "Offset of field: ",
9698 stringify!(dvb_entry),
9699 "::",
9700 stringify!(vchannel)
9701 )
9702 );
9703 assert_eq!(
9704 unsafe { &(*(::std::ptr::null::<dvb_entry>())).location as *const _ as usize },
9705 5400usize,
9706 concat!(
9707 "Offset of field: ",
9708 stringify!(dvb_entry),
9709 "::",
9710 stringify!(location)
9711 )
9712 );
9713 assert_eq!(
9714 unsafe { &(*(::std::ptr::null::<dvb_entry>())).sat_number as *const _ as usize },
9715 5408usize,
9716 concat!(
9717 "Offset of field: ",
9718 stringify!(dvb_entry),
9719 "::",
9720 stringify!(sat_number)
9721 )
9722 );
9723 assert_eq!(
9724 unsafe { &(*(::std::ptr::null::<dvb_entry>())).freq_bpf as *const _ as usize },
9725 5412usize,
9726 concat!(
9727 "Offset of field: ",
9728 stringify!(dvb_entry),
9729 "::",
9730 stringify!(freq_bpf)
9731 )
9732 );
9733 assert_eq!(
9734 unsafe { &(*(::std::ptr::null::<dvb_entry>())).diseqc_wait as *const _ as usize },
9735 5416usize,
9736 concat!(
9737 "Offset of field: ",
9738 stringify!(dvb_entry),
9739 "::",
9740 stringify!(diseqc_wait)
9741 )
9742 );
9743 assert_eq!(
9744 unsafe { &(*(::std::ptr::null::<dvb_entry>())).lnb as *const _ as usize },
9745 5424usize,
9746 concat!(
9747 "Offset of field: ",
9748 stringify!(dvb_entry),
9749 "::",
9750 stringify!(lnb)
9751 )
9752 );
9753 assert_eq!(
9754 unsafe { &(*(::std::ptr::null::<dvb_entry>())).network_id as *const _ as usize },
9755 5432usize,
9756 concat!(
9757 "Offset of field: ",
9758 stringify!(dvb_entry),
9759 "::",
9760 stringify!(network_id)
9761 )
9762 );
9763 assert_eq!(
9764 unsafe { &(*(::std::ptr::null::<dvb_entry>())).transport_id as *const _ as usize },
9765 5434usize,
9766 concat!(
9767 "Offset of field: ",
9768 stringify!(dvb_entry),
9769 "::",
9770 stringify!(transport_id)
9771 )
9772 );
9773}
9774#[repr(C)]
9775#[derive(Debug, Copy, Clone)]
9776pub struct dvb_file {
9777 pub fname: *mut ::std::os::raw::c_char,
9778 pub n_entries: ::std::os::raw::c_int,
9779 pub first_entry: *mut dvb_entry,
9780}
9781#[test]
9782fn bindgen_test_layout_dvb_file() {
9783 assert_eq!(
9784 ::std::mem::size_of::<dvb_file>(),
9785 24usize,
9786 concat!("Size of: ", stringify!(dvb_file))
9787 );
9788 assert_eq!(
9789 ::std::mem::align_of::<dvb_file>(),
9790 8usize,
9791 concat!("Alignment of ", stringify!(dvb_file))
9792 );
9793 assert_eq!(
9794 unsafe { &(*(::std::ptr::null::<dvb_file>())).fname as *const _ as usize },
9795 0usize,
9796 concat!(
9797 "Offset of field: ",
9798 stringify!(dvb_file),
9799 "::",
9800 stringify!(fname)
9801 )
9802 );
9803 assert_eq!(
9804 unsafe { &(*(::std::ptr::null::<dvb_file>())).n_entries as *const _ as usize },
9805 8usize,
9806 concat!(
9807 "Offset of field: ",
9808 stringify!(dvb_file),
9809 "::",
9810 stringify!(n_entries)
9811 )
9812 );
9813 assert_eq!(
9814 unsafe { &(*(::std::ptr::null::<dvb_file>())).first_entry as *const _ as usize },
9815 16usize,
9816 concat!(
9817 "Offset of field: ",
9818 stringify!(dvb_file),
9819 "::",
9820 stringify!(first_entry)
9821 )
9822 );
9823}
9824#[repr(C)]
9825#[derive(Debug, Copy, Clone)]
9826pub struct dvb_parse_table {
9827 pub prop: ::std::os::raw::c_uint,
9828 pub table: *mut *const ::std::os::raw::c_char,
9829 pub size: ::std::os::raw::c_uint,
9830 pub mult_factor: ::std::os::raw::c_int,
9831 pub has_default_value: ::std::os::raw::c_int,
9832 pub default_value: ::std::os::raw::c_int,
9833}
9834#[test]
9835fn bindgen_test_layout_dvb_parse_table() {
9836 assert_eq!(
9837 ::std::mem::size_of::<dvb_parse_table>(),
9838 32usize,
9839 concat!("Size of: ", stringify!(dvb_parse_table))
9840 );
9841 assert_eq!(
9842 ::std::mem::align_of::<dvb_parse_table>(),
9843 8usize,
9844 concat!("Alignment of ", stringify!(dvb_parse_table))
9845 );
9846 assert_eq!(
9847 unsafe { &(*(::std::ptr::null::<dvb_parse_table>())).prop as *const _ as usize },
9848 0usize,
9849 concat!(
9850 "Offset of field: ",
9851 stringify!(dvb_parse_table),
9852 "::",
9853 stringify!(prop)
9854 )
9855 );
9856 assert_eq!(
9857 unsafe { &(*(::std::ptr::null::<dvb_parse_table>())).table as *const _ as usize },
9858 8usize,
9859 concat!(
9860 "Offset of field: ",
9861 stringify!(dvb_parse_table),
9862 "::",
9863 stringify!(table)
9864 )
9865 );
9866 assert_eq!(
9867 unsafe { &(*(::std::ptr::null::<dvb_parse_table>())).size as *const _ as usize },
9868 16usize,
9869 concat!(
9870 "Offset of field: ",
9871 stringify!(dvb_parse_table),
9872 "::",
9873 stringify!(size)
9874 )
9875 );
9876 assert_eq!(
9877 unsafe { &(*(::std::ptr::null::<dvb_parse_table>())).mult_factor as *const _ as usize },
9878 20usize,
9879 concat!(
9880 "Offset of field: ",
9881 stringify!(dvb_parse_table),
9882 "::",
9883 stringify!(mult_factor)
9884 )
9885 );
9886 assert_eq!(
9887 unsafe {
9888 &(*(::std::ptr::null::<dvb_parse_table>())).has_default_value as *const _ as usize
9889 },
9890 24usize,
9891 concat!(
9892 "Offset of field: ",
9893 stringify!(dvb_parse_table),
9894 "::",
9895 stringify!(has_default_value)
9896 )
9897 );
9898 assert_eq!(
9899 unsafe { &(*(::std::ptr::null::<dvb_parse_table>())).default_value as *const _ as usize },
9900 28usize,
9901 concat!(
9902 "Offset of field: ",
9903 stringify!(dvb_parse_table),
9904 "::",
9905 stringify!(default_value)
9906 )
9907 );
9908}
9909#[repr(C)]
9910#[derive(Debug, Copy, Clone)]
9911pub struct dvb_parse_struct {
9912 pub id: *mut ::std::os::raw::c_char,
9913 pub delsys: u32,
9914 pub table: *const dvb_parse_table,
9915 pub size: ::std::os::raw::c_uint,
9916}
9917#[test]
9918fn bindgen_test_layout_dvb_parse_struct() {
9919 assert_eq!(
9920 ::std::mem::size_of::<dvb_parse_struct>(),
9921 32usize,
9922 concat!("Size of: ", stringify!(dvb_parse_struct))
9923 );
9924 assert_eq!(
9925 ::std::mem::align_of::<dvb_parse_struct>(),
9926 8usize,
9927 concat!("Alignment of ", stringify!(dvb_parse_struct))
9928 );
9929 assert_eq!(
9930 unsafe { &(*(::std::ptr::null::<dvb_parse_struct>())).id as *const _ as usize },
9931 0usize,
9932 concat!(
9933 "Offset of field: ",
9934 stringify!(dvb_parse_struct),
9935 "::",
9936 stringify!(id)
9937 )
9938 );
9939 assert_eq!(
9940 unsafe { &(*(::std::ptr::null::<dvb_parse_struct>())).delsys as *const _ as usize },
9941 8usize,
9942 concat!(
9943 "Offset of field: ",
9944 stringify!(dvb_parse_struct),
9945 "::",
9946 stringify!(delsys)
9947 )
9948 );
9949 assert_eq!(
9950 unsafe { &(*(::std::ptr::null::<dvb_parse_struct>())).table as *const _ as usize },
9951 16usize,
9952 concat!(
9953 "Offset of field: ",
9954 stringify!(dvb_parse_struct),
9955 "::",
9956 stringify!(table)
9957 )
9958 );
9959 assert_eq!(
9960 unsafe { &(*(::std::ptr::null::<dvb_parse_struct>())).size as *const _ as usize },
9961 24usize,
9962 concat!(
9963 "Offset of field: ",
9964 stringify!(dvb_parse_struct),
9965 "::",
9966 stringify!(size)
9967 )
9968 );
9969}
9970#[repr(C)]
9971#[derive(Debug)]
9972pub struct dvb_parse_file {
9973 pub has_delsys_id: ::std::os::raw::c_int,
9974 pub delimiter: *mut ::std::os::raw::c_char,
9975 pub formats: __IncompleteArrayField<dvb_parse_struct>,
9976}
9977#[test]
9978fn bindgen_test_layout_dvb_parse_file() {
9979 assert_eq!(
9980 ::std::mem::size_of::<dvb_parse_file>(),
9981 16usize,
9982 concat!("Size of: ", stringify!(dvb_parse_file))
9983 );
9984 assert_eq!(
9985 ::std::mem::align_of::<dvb_parse_file>(),
9986 8usize,
9987 concat!("Alignment of ", stringify!(dvb_parse_file))
9988 );
9989 assert_eq!(
9990 unsafe { &(*(::std::ptr::null::<dvb_parse_file>())).has_delsys_id as *const _ as usize },
9991 0usize,
9992 concat!(
9993 "Offset of field: ",
9994 stringify!(dvb_parse_file),
9995 "::",
9996 stringify!(has_delsys_id)
9997 )
9998 );
9999 assert_eq!(
10000 unsafe { &(*(::std::ptr::null::<dvb_parse_file>())).delimiter as *const _ as usize },
10001 8usize,
10002 concat!(
10003 "Offset of field: ",
10004 stringify!(dvb_parse_file),
10005 "::",
10006 stringify!(delimiter)
10007 )
10008 );
10009 assert_eq!(
10010 unsafe { &(*(::std::ptr::null::<dvb_parse_file>())).formats as *const _ as usize },
10011 16usize,
10012 concat!(
10013 "Offset of field: ",
10014 stringify!(dvb_parse_file),
10015 "::",
10016 stringify!(formats)
10017 )
10018 );
10019}
10020#[repr(u32)]
10021#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
10022pub enum dvb_file_formats {
10023 FILE_UNKNOWN = 0,
10024 FILE_ZAP = 1,
10025 FILE_CHANNEL = 2,
10026 FILE_DVBV5 = 3,
10027 FILE_VDR = 4,
10028}
10029extern "C" {
10030 pub static channel_file_format: dvb_parse_file;
10031}
10032extern "C" {
10033 pub static channel_file_zap_format: dvb_parse_file;
10034}
10035extern "C" {
10036 pub fn dvb_read_file(fname: *const ::std::os::raw::c_char) -> *mut dvb_file;
10037}
10038extern "C" {
10039 pub fn dvb_write_file(
10040 fname: *const ::std::os::raw::c_char,
10041 dvb_file: *mut dvb_file,
10042 ) -> ::std::os::raw::c_int;
10043}
10044extern "C" {
10045 pub fn dvb_read_file_format(
10046 fname: *const ::std::os::raw::c_char,
10047 delsys: u32,
10048 format: dvb_file_formats,
10049 ) -> *mut dvb_file;
10050}
10051extern "C" {
10052 pub fn dvb_write_file_format(
10053 fname: *const ::std::os::raw::c_char,
10054 dvb_file: *mut dvb_file,
10055 delsys: u32,
10056 format: dvb_file_formats,
10057 ) -> ::std::os::raw::c_int;
10058}
10059extern "C" {
10060 pub fn dvb_store_entry_prop(
10061 entry: *mut dvb_entry,
10062 cmd: u32,
10063 value: u32,
10064 ) -> ::std::os::raw::c_int;
10065}
10066extern "C" {
10067 pub fn dvb_retrieve_entry_prop(
10068 entry: *mut dvb_entry,
10069 cmd: u32,
10070 value: *mut u32,
10071 ) -> ::std::os::raw::c_int;
10072}
10073extern "C" {
10074 pub fn dvb_store_channel(
10075 dvb_file: *mut *mut dvb_file,
10076 parms: *mut dvb_v5_fe_parms,
10077 dvb_desc: *mut dvb_v5_descriptors,
10078 get_detected: ::std::os::raw::c_int,
10079 get_nit: ::std::os::raw::c_int,
10080 ) -> ::std::os::raw::c_int;
10081}
10082extern "C" {
10083 pub fn dvb_parse_delsys(name: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
10084}
10085extern "C" {
10086 pub fn dvb_parse_format(name: *const ::std::os::raw::c_char) -> dvb_file_formats;
10087}
10088extern "C" {
10089 pub fn dvb_parse_format_oneline(
10090 fname: *const ::std::os::raw::c_char,
10091 delsys: u32,
10092 parse_file: *const dvb_parse_file,
10093 ) -> *mut dvb_file;
10094}
10095extern "C" {
10096 pub fn dvb_write_format_oneline(
10097 fname: *const ::std::os::raw::c_char,
10098 dvb_file: *mut dvb_file,
10099 delsys: u32,
10100 parse_file: *const dvb_parse_file,
10101 ) -> ::std::os::raw::c_int;
10102}
10103extern "C" {
10104 pub fn dvb_write_format_vdr(
10105 fname: *const ::std::os::raw::c_char,
10106 dvb_file: *mut dvb_file,
10107 ) -> ::std::os::raw::c_int;
10108}
10109#[repr(C, packed)]
10110#[derive(Copy, Clone)]
10111pub struct dvb_table_eit_event {
10112 pub event_id: u16,
10113 pub __bindgen_anon_1: dvb_table_eit_event__bindgen_ty_1,
10114 pub dvbduration: [u8; 3usize],
10115 pub __bindgen_anon_2: dvb_table_eit_event__bindgen_ty_2,
10116 pub descriptor: *mut dvb_desc,
10117 pub next: *mut dvb_table_eit_event,
10118 pub start: tm,
10119 pub duration: u32,
10120 pub service_id: u16,
10121}
10122#[repr(C, packed)]
10123#[derive(Copy, Clone)]
10124pub union dvb_table_eit_event__bindgen_ty_1 {
10125 pub bitfield1: u16,
10126 pub dvbstart: [u8; 5usize],
10127 _bindgen_union_align: [u8; 5usize],
10128}
10129#[test]
10130fn bindgen_test_layout_dvb_table_eit_event__bindgen_ty_1() {
10131 assert_eq!(
10132 ::std::mem::size_of::<dvb_table_eit_event__bindgen_ty_1>(),
10133 5usize,
10134 concat!("Size of: ", stringify!(dvb_table_eit_event__bindgen_ty_1))
10135 );
10136 assert_eq!(
10137 ::std::mem::align_of::<dvb_table_eit_event__bindgen_ty_1>(),
10138 1usize,
10139 concat!(
10140 "Alignment of ",
10141 stringify!(dvb_table_eit_event__bindgen_ty_1)
10142 )
10143 );
10144 assert_eq!(
10145 unsafe {
10146 &(*(::std::ptr::null::<dvb_table_eit_event__bindgen_ty_1>())).bitfield1 as *const _
10147 as usize
10148 },
10149 0usize,
10150 concat!(
10151 "Offset of field: ",
10152 stringify!(dvb_table_eit_event__bindgen_ty_1),
10153 "::",
10154 stringify!(bitfield1)
10155 )
10156 );
10157 assert_eq!(
10158 unsafe {
10159 &(*(::std::ptr::null::<dvb_table_eit_event__bindgen_ty_1>())).dvbstart as *const _
10160 as usize
10161 },
10162 0usize,
10163 concat!(
10164 "Offset of field: ",
10165 stringify!(dvb_table_eit_event__bindgen_ty_1),
10166 "::",
10167 stringify!(dvbstart)
10168 )
10169 );
10170}
10171#[repr(C, packed)]
10172#[derive(Copy, Clone)]
10173pub union dvb_table_eit_event__bindgen_ty_2 {
10174 pub bitfield2: u16,
10175 pub __bindgen_anon_1: dvb_table_eit_event__bindgen_ty_2__bindgen_ty_1,
10176 _bindgen_union_align: [u8; 2usize],
10177}
10178#[repr(C, packed)]
10179#[derive(Debug, Copy, Clone)]
10180pub struct dvb_table_eit_event__bindgen_ty_2__bindgen_ty_1 {
10181 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize], u8>,
10182}
10183#[test]
10184fn bindgen_test_layout_dvb_table_eit_event__bindgen_ty_2__bindgen_ty_1() {
10185 assert_eq!(
10186 ::std::mem::size_of::<dvb_table_eit_event__bindgen_ty_2__bindgen_ty_1>(),
10187 2usize,
10188 concat!(
10189 "Size of: ",
10190 stringify!(dvb_table_eit_event__bindgen_ty_2__bindgen_ty_1)
10191 )
10192 );
10193 assert_eq!(
10194 ::std::mem::align_of::<dvb_table_eit_event__bindgen_ty_2__bindgen_ty_1>(),
10195 1usize,
10196 concat!(
10197 "Alignment of ",
10198 stringify!(dvb_table_eit_event__bindgen_ty_2__bindgen_ty_1)
10199 )
10200 );
10201}
10202impl dvb_table_eit_event__bindgen_ty_2__bindgen_ty_1 {
10203 #[inline]
10204 pub fn desc_length(&self) -> u16 {
10205 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 12u8) as u16) }
10206 }
10207 #[inline]
10208 pub fn set_desc_length(&mut self, val: u16) {
10209 unsafe {
10210 let val: u16 = ::std::mem::transmute(val);
10211 self._bitfield_1.set(0usize, 12u8, val as u64)
10212 }
10213 }
10214 #[inline]
10215 pub fn free_CA_mode(&self) -> u16 {
10216 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u16) }
10217 }
10218 #[inline]
10219 pub fn set_free_CA_mode(&mut self, val: u16) {
10220 unsafe {
10221 let val: u16 = ::std::mem::transmute(val);
10222 self._bitfield_1.set(12usize, 1u8, val as u64)
10223 }
10224 }
10225 #[inline]
10226 pub fn running_status(&self) -> u16 {
10227 unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 3u8) as u16) }
10228 }
10229 #[inline]
10230 pub fn set_running_status(&mut self, val: u16) {
10231 unsafe {
10232 let val: u16 = ::std::mem::transmute(val);
10233 self._bitfield_1.set(13usize, 3u8, val as u64)
10234 }
10235 }
10236 #[inline]
10237 pub fn new_bitfield_1(
10238 desc_length: u16,
10239 free_CA_mode: u16,
10240 running_status: u16,
10241 ) -> __BindgenBitfieldUnit<[u8; 2usize], u8> {
10242 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize], u8> =
10243 Default::default();
10244 __bindgen_bitfield_unit.set(0usize, 12u8, {
10245 let desc_length: u16 = unsafe { ::std::mem::transmute(desc_length) };
10246 desc_length as u64
10247 });
10248 __bindgen_bitfield_unit.set(12usize, 1u8, {
10249 let free_CA_mode: u16 = unsafe { ::std::mem::transmute(free_CA_mode) };
10250 free_CA_mode as u64
10251 });
10252 __bindgen_bitfield_unit.set(13usize, 3u8, {
10253 let running_status: u16 = unsafe { ::std::mem::transmute(running_status) };
10254 running_status as u64
10255 });
10256 __bindgen_bitfield_unit
10257 }
10258}
10259#[test]
10260fn bindgen_test_layout_dvb_table_eit_event__bindgen_ty_2() {
10261 assert_eq!(
10262 ::std::mem::size_of::<dvb_table_eit_event__bindgen_ty_2>(),
10263 2usize,
10264 concat!("Size of: ", stringify!(dvb_table_eit_event__bindgen_ty_2))
10265 );
10266 assert_eq!(
10267 ::std::mem::align_of::<dvb_table_eit_event__bindgen_ty_2>(),
10268 1usize,
10269 concat!(
10270 "Alignment of ",
10271 stringify!(dvb_table_eit_event__bindgen_ty_2)
10272 )
10273 );
10274 assert_eq!(
10275 unsafe {
10276 &(*(::std::ptr::null::<dvb_table_eit_event__bindgen_ty_2>())).bitfield2 as *const _
10277 as usize
10278 },
10279 0usize,
10280 concat!(
10281 "Offset of field: ",
10282 stringify!(dvb_table_eit_event__bindgen_ty_2),
10283 "::",
10284 stringify!(bitfield2)
10285 )
10286 );
10287}
10288#[test]
10289fn bindgen_test_layout_dvb_table_eit_event() {
10290 assert_eq!(
10291 ::std::mem::size_of::<dvb_table_eit_event>(),
10292 90usize,
10293 concat!("Size of: ", stringify!(dvb_table_eit_event))
10294 );
10295 assert_eq!(
10296 ::std::mem::align_of::<dvb_table_eit_event>(),
10297 1usize,
10298 concat!("Alignment of ", stringify!(dvb_table_eit_event))
10299 );
10300 assert_eq!(
10301 unsafe { &(*(::std::ptr::null::<dvb_table_eit_event>())).event_id as *const _ as usize },
10302 0usize,
10303 concat!(
10304 "Offset of field: ",
10305 stringify!(dvb_table_eit_event),
10306 "::",
10307 stringify!(event_id)
10308 )
10309 );
10310 assert_eq!(
10311 unsafe { &(*(::std::ptr::null::<dvb_table_eit_event>())).dvbduration as *const _ as usize },
10312 7usize,
10313 concat!(
10314 "Offset of field: ",
10315 stringify!(dvb_table_eit_event),
10316 "::",
10317 stringify!(dvbduration)
10318 )
10319 );
10320 assert_eq!(
10321 unsafe { &(*(::std::ptr::null::<dvb_table_eit_event>())).descriptor as *const _ as usize },
10322 12usize,
10323 concat!(
10324 "Offset of field: ",
10325 stringify!(dvb_table_eit_event),
10326 "::",
10327 stringify!(descriptor)
10328 )
10329 );
10330 assert_eq!(
10331 unsafe { &(*(::std::ptr::null::<dvb_table_eit_event>())).next as *const _ as usize },
10332 20usize,
10333 concat!(
10334 "Offset of field: ",
10335 stringify!(dvb_table_eit_event),
10336 "::",
10337 stringify!(next)
10338 )
10339 );
10340 assert_eq!(
10341 unsafe { &(*(::std::ptr::null::<dvb_table_eit_event>())).start as *const _ as usize },
10342 28usize,
10343 concat!(
10344 "Offset of field: ",
10345 stringify!(dvb_table_eit_event),
10346 "::",
10347 stringify!(start)
10348 )
10349 );
10350 assert_eq!(
10351 unsafe { &(*(::std::ptr::null::<dvb_table_eit_event>())).duration as *const _ as usize },
10352 84usize,
10353 concat!(
10354 "Offset of field: ",
10355 stringify!(dvb_table_eit_event),
10356 "::",
10357 stringify!(duration)
10358 )
10359 );
10360 assert_eq!(
10361 unsafe { &(*(::std::ptr::null::<dvb_table_eit_event>())).service_id as *const _ as usize },
10362 88usize,
10363 concat!(
10364 "Offset of field: ",
10365 stringify!(dvb_table_eit_event),
10366 "::",
10367 stringify!(service_id)
10368 )
10369 );
10370}
10371#[repr(C, packed)]
10372#[derive(Copy, Clone)]
10373pub struct dvb_table_eit {
10374 pub header: dvb_table_header,
10375 pub transport_id: u16,
10376 pub network_id: u16,
10377 pub last_segment: u8,
10378 pub last_table_id: u8,
10379 pub event: *mut dvb_table_eit_event,
10380}
10381#[test]
10382fn bindgen_test_layout_dvb_table_eit() {
10383 assert_eq!(
10384 ::std::mem::size_of::<dvb_table_eit>(),
10385 22usize,
10386 concat!("Size of: ", stringify!(dvb_table_eit))
10387 );
10388 assert_eq!(
10389 ::std::mem::align_of::<dvb_table_eit>(),
10390 1usize,
10391 concat!("Alignment of ", stringify!(dvb_table_eit))
10392 );
10393 assert_eq!(
10394 unsafe { &(*(::std::ptr::null::<dvb_table_eit>())).header as *const _ as usize },
10395 0usize,
10396 concat!(
10397 "Offset of field: ",
10398 stringify!(dvb_table_eit),
10399 "::",
10400 stringify!(header)
10401 )
10402 );
10403 assert_eq!(
10404 unsafe { &(*(::std::ptr::null::<dvb_table_eit>())).transport_id as *const _ as usize },
10405 8usize,
10406 concat!(
10407 "Offset of field: ",
10408 stringify!(dvb_table_eit),
10409 "::",
10410 stringify!(transport_id)
10411 )
10412 );
10413 assert_eq!(
10414 unsafe { &(*(::std::ptr::null::<dvb_table_eit>())).network_id as *const _ as usize },
10415 10usize,
10416 concat!(
10417 "Offset of field: ",
10418 stringify!(dvb_table_eit),
10419 "::",
10420 stringify!(network_id)
10421 )
10422 );
10423 assert_eq!(
10424 unsafe { &(*(::std::ptr::null::<dvb_table_eit>())).last_segment as *const _ as usize },
10425 12usize,
10426 concat!(
10427 "Offset of field: ",
10428 stringify!(dvb_table_eit),
10429 "::",
10430 stringify!(last_segment)
10431 )
10432 );
10433 assert_eq!(
10434 unsafe { &(*(::std::ptr::null::<dvb_table_eit>())).last_table_id as *const _ as usize },
10435 13usize,
10436 concat!(
10437 "Offset of field: ",
10438 stringify!(dvb_table_eit),
10439 "::",
10440 stringify!(last_table_id)
10441 )
10442 );
10443 assert_eq!(
10444 unsafe { &(*(::std::ptr::null::<dvb_table_eit>())).event as *const _ as usize },
10445 14usize,
10446 concat!(
10447 "Offset of field: ",
10448 stringify!(dvb_table_eit),
10449 "::",
10450 stringify!(event)
10451 )
10452 );
10453}
10454extern "C" {
10455 pub static mut dvb_eit_running_status_name: [*const ::std::os::raw::c_char; 8usize];
10456}
10457extern "C" {
10458 pub fn dvb_table_eit_init(
10459 parms: *mut dvb_v5_fe_parms,
10460 buf: *const u8,
10461 buflen: ssize_t,
10462 table: *mut *mut dvb_table_eit,
10463 ) -> ssize_t;
10464}
10465extern "C" {
10466 pub fn dvb_table_eit_free(table: *mut dvb_table_eit);
10467}
10468extern "C" {
10469 pub fn dvb_table_eit_print(parms: *mut dvb_v5_fe_parms, table: *mut dvb_table_eit);
10470}
10471extern "C" {
10472 pub fn dvb_time(data: *const u8, tm: *mut tm);
10473}
10474#[repr(C, packed)]
10475#[derive(Copy, Clone)]
10476pub struct atsc_table_mgt_table {
10477 pub type_: u16,
10478 pub __bindgen_anon_1: atsc_table_mgt_table__bindgen_ty_1,
10479 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize], u8>,
10480 pub size: u32,
10481 pub __bindgen_anon_2: atsc_table_mgt_table__bindgen_ty_2,
10482 pub descriptor: *mut dvb_desc,
10483 pub next: *mut atsc_table_mgt_table,
10484}
10485#[repr(C, packed)]
10486#[derive(Copy, Clone)]
10487pub union atsc_table_mgt_table__bindgen_ty_1 {
10488 pub bitfield: u16,
10489 pub __bindgen_anon_1: atsc_table_mgt_table__bindgen_ty_1__bindgen_ty_1,
10490 _bindgen_union_align: [u8; 2usize],
10491}
10492#[repr(C, packed)]
10493#[derive(Debug, Copy, Clone)]
10494pub struct atsc_table_mgt_table__bindgen_ty_1__bindgen_ty_1 {
10495 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize], u8>,
10496}
10497#[test]
10498fn bindgen_test_layout_atsc_table_mgt_table__bindgen_ty_1__bindgen_ty_1() {
10499 assert_eq!(
10500 ::std::mem::size_of::<atsc_table_mgt_table__bindgen_ty_1__bindgen_ty_1>(),
10501 2usize,
10502 concat!(
10503 "Size of: ",
10504 stringify!(atsc_table_mgt_table__bindgen_ty_1__bindgen_ty_1)
10505 )
10506 );
10507 assert_eq!(
10508 ::std::mem::align_of::<atsc_table_mgt_table__bindgen_ty_1__bindgen_ty_1>(),
10509 1usize,
10510 concat!(
10511 "Alignment of ",
10512 stringify!(atsc_table_mgt_table__bindgen_ty_1__bindgen_ty_1)
10513 )
10514 );
10515}
10516impl atsc_table_mgt_table__bindgen_ty_1__bindgen_ty_1 {
10517 #[inline]
10518 pub fn pid(&self) -> u16 {
10519 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 13u8) as u16) }
10520 }
10521 #[inline]
10522 pub fn set_pid(&mut self, val: u16) {
10523 unsafe {
10524 let val: u16 = ::std::mem::transmute(val);
10525 self._bitfield_1.set(0usize, 13u8, val as u64)
10526 }
10527 }
10528 #[inline]
10529 pub fn one(&self) -> u16 {
10530 unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 3u8) as u16) }
10531 }
10532 #[inline]
10533 pub fn set_one(&mut self, val: u16) {
10534 unsafe {
10535 let val: u16 = ::std::mem::transmute(val);
10536 self._bitfield_1.set(13usize, 3u8, val as u64)
10537 }
10538 }
10539 #[inline]
10540 pub fn new_bitfield_1(pid: u16, one: u16) -> __BindgenBitfieldUnit<[u8; 2usize], u8> {
10541 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize], u8> =
10542 Default::default();
10543 __bindgen_bitfield_unit.set(0usize, 13u8, {
10544 let pid: u16 = unsafe { ::std::mem::transmute(pid) };
10545 pid as u64
10546 });
10547 __bindgen_bitfield_unit.set(13usize, 3u8, {
10548 let one: u16 = unsafe { ::std::mem::transmute(one) };
10549 one as u64
10550 });
10551 __bindgen_bitfield_unit
10552 }
10553}
10554#[test]
10555fn bindgen_test_layout_atsc_table_mgt_table__bindgen_ty_1() {
10556 assert_eq!(
10557 ::std::mem::size_of::<atsc_table_mgt_table__bindgen_ty_1>(),
10558 2usize,
10559 concat!("Size of: ", stringify!(atsc_table_mgt_table__bindgen_ty_1))
10560 );
10561 assert_eq!(
10562 ::std::mem::align_of::<atsc_table_mgt_table__bindgen_ty_1>(),
10563 1usize,
10564 concat!(
10565 "Alignment of ",
10566 stringify!(atsc_table_mgt_table__bindgen_ty_1)
10567 )
10568 );
10569 assert_eq!(
10570 unsafe {
10571 &(*(::std::ptr::null::<atsc_table_mgt_table__bindgen_ty_1>())).bitfield as *const _
10572 as usize
10573 },
10574 0usize,
10575 concat!(
10576 "Offset of field: ",
10577 stringify!(atsc_table_mgt_table__bindgen_ty_1),
10578 "::",
10579 stringify!(bitfield)
10580 )
10581 );
10582}
10583#[repr(C, packed)]
10584#[derive(Copy, Clone)]
10585pub union atsc_table_mgt_table__bindgen_ty_2 {
10586 pub bitfield2: u16,
10587 pub __bindgen_anon_1: atsc_table_mgt_table__bindgen_ty_2__bindgen_ty_1,
10588 _bindgen_union_align: [u8; 2usize],
10589}
10590#[repr(C, packed)]
10591#[derive(Debug, Copy, Clone)]
10592pub struct atsc_table_mgt_table__bindgen_ty_2__bindgen_ty_1 {
10593 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize], u8>,
10594}
10595#[test]
10596fn bindgen_test_layout_atsc_table_mgt_table__bindgen_ty_2__bindgen_ty_1() {
10597 assert_eq!(
10598 ::std::mem::size_of::<atsc_table_mgt_table__bindgen_ty_2__bindgen_ty_1>(),
10599 2usize,
10600 concat!(
10601 "Size of: ",
10602 stringify!(atsc_table_mgt_table__bindgen_ty_2__bindgen_ty_1)
10603 )
10604 );
10605 assert_eq!(
10606 ::std::mem::align_of::<atsc_table_mgt_table__bindgen_ty_2__bindgen_ty_1>(),
10607 1usize,
10608 concat!(
10609 "Alignment of ",
10610 stringify!(atsc_table_mgt_table__bindgen_ty_2__bindgen_ty_1)
10611 )
10612 );
10613}
10614impl atsc_table_mgt_table__bindgen_ty_2__bindgen_ty_1 {
10615 #[inline]
10616 pub fn desc_length(&self) -> u16 {
10617 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 12u8) as u16) }
10618 }
10619 #[inline]
10620 pub fn set_desc_length(&mut self, val: u16) {
10621 unsafe {
10622 let val: u16 = ::std::mem::transmute(val);
10623 self._bitfield_1.set(0usize, 12u8, val as u64)
10624 }
10625 }
10626 #[inline]
10627 pub fn one3(&self) -> u16 {
10628 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 4u8) as u16) }
10629 }
10630 #[inline]
10631 pub fn set_one3(&mut self, val: u16) {
10632 unsafe {
10633 let val: u16 = ::std::mem::transmute(val);
10634 self._bitfield_1.set(12usize, 4u8, val as u64)
10635 }
10636 }
10637 #[inline]
10638 pub fn new_bitfield_1(desc_length: u16, one3: u16) -> __BindgenBitfieldUnit<[u8; 2usize], u8> {
10639 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize], u8> =
10640 Default::default();
10641 __bindgen_bitfield_unit.set(0usize, 12u8, {
10642 let desc_length: u16 = unsafe { ::std::mem::transmute(desc_length) };
10643 desc_length as u64
10644 });
10645 __bindgen_bitfield_unit.set(12usize, 4u8, {
10646 let one3: u16 = unsafe { ::std::mem::transmute(one3) };
10647 one3 as u64
10648 });
10649 __bindgen_bitfield_unit
10650 }
10651}
10652#[test]
10653fn bindgen_test_layout_atsc_table_mgt_table__bindgen_ty_2() {
10654 assert_eq!(
10655 ::std::mem::size_of::<atsc_table_mgt_table__bindgen_ty_2>(),
10656 2usize,
10657 concat!("Size of: ", stringify!(atsc_table_mgt_table__bindgen_ty_2))
10658 );
10659 assert_eq!(
10660 ::std::mem::align_of::<atsc_table_mgt_table__bindgen_ty_2>(),
10661 1usize,
10662 concat!(
10663 "Alignment of ",
10664 stringify!(atsc_table_mgt_table__bindgen_ty_2)
10665 )
10666 );
10667 assert_eq!(
10668 unsafe {
10669 &(*(::std::ptr::null::<atsc_table_mgt_table__bindgen_ty_2>())).bitfield2 as *const _
10670 as usize
10671 },
10672 0usize,
10673 concat!(
10674 "Offset of field: ",
10675 stringify!(atsc_table_mgt_table__bindgen_ty_2),
10676 "::",
10677 stringify!(bitfield2)
10678 )
10679 );
10680}
10681#[test]
10682fn bindgen_test_layout_atsc_table_mgt_table() {
10683 assert_eq!(
10684 ::std::mem::size_of::<atsc_table_mgt_table>(),
10685 27usize,
10686 concat!("Size of: ", stringify!(atsc_table_mgt_table))
10687 );
10688 assert_eq!(
10689 ::std::mem::align_of::<atsc_table_mgt_table>(),
10690 1usize,
10691 concat!("Alignment of ", stringify!(atsc_table_mgt_table))
10692 );
10693 assert_eq!(
10694 unsafe { &(*(::std::ptr::null::<atsc_table_mgt_table>())).type_ as *const _ as usize },
10695 0usize,
10696 concat!(
10697 "Offset of field: ",
10698 stringify!(atsc_table_mgt_table),
10699 "::",
10700 stringify!(type_)
10701 )
10702 );
10703 assert_eq!(
10704 unsafe { &(*(::std::ptr::null::<atsc_table_mgt_table>())).size as *const _ as usize },
10705 5usize,
10706 concat!(
10707 "Offset of field: ",
10708 stringify!(atsc_table_mgt_table),
10709 "::",
10710 stringify!(size)
10711 )
10712 );
10713 assert_eq!(
10714 unsafe { &(*(::std::ptr::null::<atsc_table_mgt_table>())).descriptor as *const _ as usize },
10715 11usize,
10716 concat!(
10717 "Offset of field: ",
10718 stringify!(atsc_table_mgt_table),
10719 "::",
10720 stringify!(descriptor)
10721 )
10722 );
10723 assert_eq!(
10724 unsafe { &(*(::std::ptr::null::<atsc_table_mgt_table>())).next as *const _ as usize },
10725 19usize,
10726 concat!(
10727 "Offset of field: ",
10728 stringify!(atsc_table_mgt_table),
10729 "::",
10730 stringify!(next)
10731 )
10732 );
10733}
10734impl atsc_table_mgt_table {
10735 #[inline]
10736 pub fn type_version(&self) -> u8 {
10737 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 5u8) as u8) }
10738 }
10739 #[inline]
10740 pub fn set_type_version(&mut self, val: u8) {
10741 unsafe {
10742 let val: u8 = ::std::mem::transmute(val);
10743 self._bitfield_1.set(0usize, 5u8, val as u64)
10744 }
10745 }
10746 #[inline]
10747 pub fn one2(&self) -> u8 {
10748 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 3u8) as u8) }
10749 }
10750 #[inline]
10751 pub fn set_one2(&mut self, val: u8) {
10752 unsafe {
10753 let val: u8 = ::std::mem::transmute(val);
10754 self._bitfield_1.set(5usize, 3u8, val as u64)
10755 }
10756 }
10757 #[inline]
10758 pub fn new_bitfield_1(type_version: u8, one2: u8) -> __BindgenBitfieldUnit<[u8; 1usize], u8> {
10759 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize], u8> =
10760 Default::default();
10761 __bindgen_bitfield_unit.set(0usize, 5u8, {
10762 let type_version: u8 = unsafe { ::std::mem::transmute(type_version) };
10763 type_version as u64
10764 });
10765 __bindgen_bitfield_unit.set(5usize, 3u8, {
10766 let one2: u8 = unsafe { ::std::mem::transmute(one2) };
10767 one2 as u64
10768 });
10769 __bindgen_bitfield_unit
10770 }
10771}
10772#[repr(C, packed)]
10773#[derive(Copy, Clone)]
10774pub struct atsc_table_mgt {
10775 pub header: dvb_table_header,
10776 pub protocol_version: u8,
10777 pub tables: u16,
10778 pub table: *mut atsc_table_mgt_table,
10779 pub descriptor: *mut dvb_desc,
10780}
10781#[test]
10782fn bindgen_test_layout_atsc_table_mgt() {
10783 assert_eq!(
10784 ::std::mem::size_of::<atsc_table_mgt>(),
10785 27usize,
10786 concat!("Size of: ", stringify!(atsc_table_mgt))
10787 );
10788 assert_eq!(
10789 ::std::mem::align_of::<atsc_table_mgt>(),
10790 1usize,
10791 concat!("Alignment of ", stringify!(atsc_table_mgt))
10792 );
10793 assert_eq!(
10794 unsafe { &(*(::std::ptr::null::<atsc_table_mgt>())).header as *const _ as usize },
10795 0usize,
10796 concat!(
10797 "Offset of field: ",
10798 stringify!(atsc_table_mgt),
10799 "::",
10800 stringify!(header)
10801 )
10802 );
10803 assert_eq!(
10804 unsafe { &(*(::std::ptr::null::<atsc_table_mgt>())).protocol_version as *const _ as usize },
10805 8usize,
10806 concat!(
10807 "Offset of field: ",
10808 stringify!(atsc_table_mgt),
10809 "::",
10810 stringify!(protocol_version)
10811 )
10812 );
10813 assert_eq!(
10814 unsafe { &(*(::std::ptr::null::<atsc_table_mgt>())).tables as *const _ as usize },
10815 9usize,
10816 concat!(
10817 "Offset of field: ",
10818 stringify!(atsc_table_mgt),
10819 "::",
10820 stringify!(tables)
10821 )
10822 );
10823 assert_eq!(
10824 unsafe { &(*(::std::ptr::null::<atsc_table_mgt>())).table as *const _ as usize },
10825 11usize,
10826 concat!(
10827 "Offset of field: ",
10828 stringify!(atsc_table_mgt),
10829 "::",
10830 stringify!(table)
10831 )
10832 );
10833 assert_eq!(
10834 unsafe { &(*(::std::ptr::null::<atsc_table_mgt>())).descriptor as *const _ as usize },
10835 19usize,
10836 concat!(
10837 "Offset of field: ",
10838 stringify!(atsc_table_mgt),
10839 "::",
10840 stringify!(descriptor)
10841 )
10842 );
10843}
10844extern "C" {
10845 pub fn atsc_table_mgt_init(
10846 parms: *mut dvb_v5_fe_parms,
10847 buf: *const u8,
10848 buflen: ssize_t,
10849 table: *mut *mut atsc_table_mgt,
10850 ) -> ssize_t;
10851}
10852extern "C" {
10853 pub fn atsc_table_mgt_free(table: *mut atsc_table_mgt);
10854}
10855extern "C" {
10856 pub fn atsc_table_mgt_print(parms: *mut dvb_v5_fe_parms, table: *mut atsc_table_mgt);
10857}
10858#[repr(C, packed)]
10859#[derive(Copy, Clone)]
10860pub struct dvb_mpeg_es_seq_start {
10861 pub __bindgen_anon_1: dvb_mpeg_es_seq_start__bindgen_ty_1,
10862 pub __bindgen_anon_2: dvb_mpeg_es_seq_start__bindgen_ty_2,
10863 pub __bindgen_anon_3: dvb_mpeg_es_seq_start__bindgen_ty_3,
10864}
10865#[repr(C, packed)]
10866#[derive(Copy, Clone)]
10867pub union dvb_mpeg_es_seq_start__bindgen_ty_1 {
10868 pub bitfield: u32,
10869 pub __bindgen_anon_1: dvb_mpeg_es_seq_start__bindgen_ty_1__bindgen_ty_1,
10870 _bindgen_union_align: [u8; 4usize],
10871}
10872#[repr(C, packed)]
10873#[derive(Debug, Copy, Clone)]
10874pub struct dvb_mpeg_es_seq_start__bindgen_ty_1__bindgen_ty_1 {
10875 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize], u8>,
10876}
10877#[test]
10878fn bindgen_test_layout_dvb_mpeg_es_seq_start__bindgen_ty_1__bindgen_ty_1() {
10879 assert_eq!(
10880 ::std::mem::size_of::<dvb_mpeg_es_seq_start__bindgen_ty_1__bindgen_ty_1>(),
10881 4usize,
10882 concat!(
10883 "Size of: ",
10884 stringify!(dvb_mpeg_es_seq_start__bindgen_ty_1__bindgen_ty_1)
10885 )
10886 );
10887 assert_eq!(
10888 ::std::mem::align_of::<dvb_mpeg_es_seq_start__bindgen_ty_1__bindgen_ty_1>(),
10889 1usize,
10890 concat!(
10891 "Alignment of ",
10892 stringify!(dvb_mpeg_es_seq_start__bindgen_ty_1__bindgen_ty_1)
10893 )
10894 );
10895}
10896impl dvb_mpeg_es_seq_start__bindgen_ty_1__bindgen_ty_1 {
10897 #[inline]
10898 pub fn type_(&self) -> u32 {
10899 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 8u8) as u32) }
10900 }
10901 #[inline]
10902 pub fn set_type(&mut self, val: u32) {
10903 unsafe {
10904 let val: u32 = ::std::mem::transmute(val);
10905 self._bitfield_1.set(0usize, 8u8, val as u64)
10906 }
10907 }
10908 #[inline]
10909 pub fn sync(&self) -> u32 {
10910 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 24u8) as u32) }
10911 }
10912 #[inline]
10913 pub fn set_sync(&mut self, val: u32) {
10914 unsafe {
10915 let val: u32 = ::std::mem::transmute(val);
10916 self._bitfield_1.set(8usize, 24u8, val as u64)
10917 }
10918 }
10919 #[inline]
10920 pub fn new_bitfield_1(type_: u32, sync: u32) -> __BindgenBitfieldUnit<[u8; 4usize], u8> {
10921 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize], u8> =
10922 Default::default();
10923 __bindgen_bitfield_unit.set(0usize, 8u8, {
10924 let type_: u32 = unsafe { ::std::mem::transmute(type_) };
10925 type_ as u64
10926 });
10927 __bindgen_bitfield_unit.set(8usize, 24u8, {
10928 let sync: u32 = unsafe { ::std::mem::transmute(sync) };
10929 sync as u64
10930 });
10931 __bindgen_bitfield_unit
10932 }
10933}
10934#[test]
10935fn bindgen_test_layout_dvb_mpeg_es_seq_start__bindgen_ty_1() {
10936 assert_eq!(
10937 ::std::mem::size_of::<dvb_mpeg_es_seq_start__bindgen_ty_1>(),
10938 4usize,
10939 concat!("Size of: ", stringify!(dvb_mpeg_es_seq_start__bindgen_ty_1))
10940 );
10941 assert_eq!(
10942 ::std::mem::align_of::<dvb_mpeg_es_seq_start__bindgen_ty_1>(),
10943 1usize,
10944 concat!(
10945 "Alignment of ",
10946 stringify!(dvb_mpeg_es_seq_start__bindgen_ty_1)
10947 )
10948 );
10949 assert_eq!(
10950 unsafe {
10951 &(*(::std::ptr::null::<dvb_mpeg_es_seq_start__bindgen_ty_1>())).bitfield as *const _
10952 as usize
10953 },
10954 0usize,
10955 concat!(
10956 "Offset of field: ",
10957 stringify!(dvb_mpeg_es_seq_start__bindgen_ty_1),
10958 "::",
10959 stringify!(bitfield)
10960 )
10961 );
10962}
10963#[repr(C, packed)]
10964#[derive(Copy, Clone)]
10965pub union dvb_mpeg_es_seq_start__bindgen_ty_2 {
10966 pub bitfield2: u32,
10967 pub __bindgen_anon_1: dvb_mpeg_es_seq_start__bindgen_ty_2__bindgen_ty_1,
10968 _bindgen_union_align: [u8; 4usize],
10969}
10970#[repr(C, packed)]
10971#[derive(Debug, Copy, Clone)]
10972pub struct dvb_mpeg_es_seq_start__bindgen_ty_2__bindgen_ty_1 {
10973 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize], u8>,
10974}
10975#[test]
10976fn bindgen_test_layout_dvb_mpeg_es_seq_start__bindgen_ty_2__bindgen_ty_1() {
10977 assert_eq!(
10978 ::std::mem::size_of::<dvb_mpeg_es_seq_start__bindgen_ty_2__bindgen_ty_1>(),
10979 4usize,
10980 concat!(
10981 "Size of: ",
10982 stringify!(dvb_mpeg_es_seq_start__bindgen_ty_2__bindgen_ty_1)
10983 )
10984 );
10985 assert_eq!(
10986 ::std::mem::align_of::<dvb_mpeg_es_seq_start__bindgen_ty_2__bindgen_ty_1>(),
10987 1usize,
10988 concat!(
10989 "Alignment of ",
10990 stringify!(dvb_mpeg_es_seq_start__bindgen_ty_2__bindgen_ty_1)
10991 )
10992 );
10993}
10994impl dvb_mpeg_es_seq_start__bindgen_ty_2__bindgen_ty_1 {
10995 #[inline]
10996 pub fn framerate(&self) -> u32 {
10997 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u32) }
10998 }
10999 #[inline]
11000 pub fn set_framerate(&mut self, val: u32) {
11001 unsafe {
11002 let val: u32 = ::std::mem::transmute(val);
11003 self._bitfield_1.set(0usize, 4u8, val as u64)
11004 }
11005 }
11006 #[inline]
11007 pub fn aspect(&self) -> u32 {
11008 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 4u8) as u32) }
11009 }
11010 #[inline]
11011 pub fn set_aspect(&mut self, val: u32) {
11012 unsafe {
11013 let val: u32 = ::std::mem::transmute(val);
11014 self._bitfield_1.set(4usize, 4u8, val as u64)
11015 }
11016 }
11017 #[inline]
11018 pub fn height(&self) -> u32 {
11019 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 12u8) as u32) }
11020 }
11021 #[inline]
11022 pub fn set_height(&mut self, val: u32) {
11023 unsafe {
11024 let val: u32 = ::std::mem::transmute(val);
11025 self._bitfield_1.set(8usize, 12u8, val as u64)
11026 }
11027 }
11028 #[inline]
11029 pub fn width(&self) -> u32 {
11030 unsafe { ::std::mem::transmute(self._bitfield_1.get(20usize, 12u8) as u32) }
11031 }
11032 #[inline]
11033 pub fn set_width(&mut self, val: u32) {
11034 unsafe {
11035 let val: u32 = ::std::mem::transmute(val);
11036 self._bitfield_1.set(20usize, 12u8, val as u64)
11037 }
11038 }
11039 #[inline]
11040 pub fn new_bitfield_1(
11041 framerate: u32,
11042 aspect: u32,
11043 height: u32,
11044 width: u32,
11045 ) -> __BindgenBitfieldUnit<[u8; 4usize], u8> {
11046 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize], u8> =
11047 Default::default();
11048 __bindgen_bitfield_unit.set(0usize, 4u8, {
11049 let framerate: u32 = unsafe { ::std::mem::transmute(framerate) };
11050 framerate as u64
11051 });
11052 __bindgen_bitfield_unit.set(4usize, 4u8, {
11053 let aspect: u32 = unsafe { ::std::mem::transmute(aspect) };
11054 aspect as u64
11055 });
11056 __bindgen_bitfield_unit.set(8usize, 12u8, {
11057 let height: u32 = unsafe { ::std::mem::transmute(height) };
11058 height as u64
11059 });
11060 __bindgen_bitfield_unit.set(20usize, 12u8, {
11061 let width: u32 = unsafe { ::std::mem::transmute(width) };
11062 width as u64
11063 });
11064 __bindgen_bitfield_unit
11065 }
11066}
11067#[test]
11068fn bindgen_test_layout_dvb_mpeg_es_seq_start__bindgen_ty_2() {
11069 assert_eq!(
11070 ::std::mem::size_of::<dvb_mpeg_es_seq_start__bindgen_ty_2>(),
11071 4usize,
11072 concat!("Size of: ", stringify!(dvb_mpeg_es_seq_start__bindgen_ty_2))
11073 );
11074 assert_eq!(
11075 ::std::mem::align_of::<dvb_mpeg_es_seq_start__bindgen_ty_2>(),
11076 1usize,
11077 concat!(
11078 "Alignment of ",
11079 stringify!(dvb_mpeg_es_seq_start__bindgen_ty_2)
11080 )
11081 );
11082 assert_eq!(
11083 unsafe {
11084 &(*(::std::ptr::null::<dvb_mpeg_es_seq_start__bindgen_ty_2>())).bitfield2 as *const _
11085 as usize
11086 },
11087 0usize,
11088 concat!(
11089 "Offset of field: ",
11090 stringify!(dvb_mpeg_es_seq_start__bindgen_ty_2),
11091 "::",
11092 stringify!(bitfield2)
11093 )
11094 );
11095}
11096#[repr(C, packed)]
11097#[derive(Copy, Clone)]
11098pub union dvb_mpeg_es_seq_start__bindgen_ty_3 {
11099 pub bitfield3: u32,
11100 pub __bindgen_anon_1: dvb_mpeg_es_seq_start__bindgen_ty_3__bindgen_ty_1,
11101 _bindgen_union_align: [u8; 4usize],
11102}
11103#[repr(C, packed)]
11104#[derive(Debug, Copy, Clone)]
11105pub struct dvb_mpeg_es_seq_start__bindgen_ty_3__bindgen_ty_1 {
11106 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize], u8>,
11107}
11108#[test]
11109fn bindgen_test_layout_dvb_mpeg_es_seq_start__bindgen_ty_3__bindgen_ty_1() {
11110 assert_eq!(
11111 ::std::mem::size_of::<dvb_mpeg_es_seq_start__bindgen_ty_3__bindgen_ty_1>(),
11112 4usize,
11113 concat!(
11114 "Size of: ",
11115 stringify!(dvb_mpeg_es_seq_start__bindgen_ty_3__bindgen_ty_1)
11116 )
11117 );
11118 assert_eq!(
11119 ::std::mem::align_of::<dvb_mpeg_es_seq_start__bindgen_ty_3__bindgen_ty_1>(),
11120 1usize,
11121 concat!(
11122 "Alignment of ",
11123 stringify!(dvb_mpeg_es_seq_start__bindgen_ty_3__bindgen_ty_1)
11124 )
11125 );
11126}
11127impl dvb_mpeg_es_seq_start__bindgen_ty_3__bindgen_ty_1 {
11128 #[inline]
11129 pub fn qm_nonintra(&self) -> u32 {
11130 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
11131 }
11132 #[inline]
11133 pub fn set_qm_nonintra(&mut self, val: u32) {
11134 unsafe {
11135 let val: u32 = ::std::mem::transmute(val);
11136 self._bitfield_1.set(0usize, 1u8, val as u64)
11137 }
11138 }
11139 #[inline]
11140 pub fn qm_intra(&self) -> u32 {
11141 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
11142 }
11143 #[inline]
11144 pub fn set_qm_intra(&mut self, val: u32) {
11145 unsafe {
11146 let val: u32 = ::std::mem::transmute(val);
11147 self._bitfield_1.set(1usize, 1u8, val as u64)
11148 }
11149 }
11150 #[inline]
11151 pub fn constrained(&self) -> u32 {
11152 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
11153 }
11154 #[inline]
11155 pub fn set_constrained(&mut self, val: u32) {
11156 unsafe {
11157 let val: u32 = ::std::mem::transmute(val);
11158 self._bitfield_1.set(2usize, 1u8, val as u64)
11159 }
11160 }
11161 #[inline]
11162 pub fn vbv(&self) -> u32 {
11163 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 10u8) as u32) }
11164 }
11165 #[inline]
11166 pub fn set_vbv(&mut self, val: u32) {
11167 unsafe {
11168 let val: u32 = ::std::mem::transmute(val);
11169 self._bitfield_1.set(3usize, 10u8, val as u64)
11170 }
11171 }
11172 #[inline]
11173 pub fn one(&self) -> u32 {
11174 unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) }
11175 }
11176 #[inline]
11177 pub fn set_one(&mut self, val: u32) {
11178 unsafe {
11179 let val: u32 = ::std::mem::transmute(val);
11180 self._bitfield_1.set(13usize, 1u8, val as u64)
11181 }
11182 }
11183 #[inline]
11184 pub fn bitrate(&self) -> u32 {
11185 unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 18u8) as u32) }
11186 }
11187 #[inline]
11188 pub fn set_bitrate(&mut self, val: u32) {
11189 unsafe {
11190 let val: u32 = ::std::mem::transmute(val);
11191 self._bitfield_1.set(14usize, 18u8, val as u64)
11192 }
11193 }
11194 #[inline]
11195 pub fn new_bitfield_1(
11196 qm_nonintra: u32,
11197 qm_intra: u32,
11198 constrained: u32,
11199 vbv: u32,
11200 one: u32,
11201 bitrate: u32,
11202 ) -> __BindgenBitfieldUnit<[u8; 4usize], u8> {
11203 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize], u8> =
11204 Default::default();
11205 __bindgen_bitfield_unit.set(0usize, 1u8, {
11206 let qm_nonintra: u32 = unsafe { ::std::mem::transmute(qm_nonintra) };
11207 qm_nonintra as u64
11208 });
11209 __bindgen_bitfield_unit.set(1usize, 1u8, {
11210 let qm_intra: u32 = unsafe { ::std::mem::transmute(qm_intra) };
11211 qm_intra as u64
11212 });
11213 __bindgen_bitfield_unit.set(2usize, 1u8, {
11214 let constrained: u32 = unsafe { ::std::mem::transmute(constrained) };
11215 constrained as u64
11216 });
11217 __bindgen_bitfield_unit.set(3usize, 10u8, {
11218 let vbv: u32 = unsafe { ::std::mem::transmute(vbv) };
11219 vbv as u64
11220 });
11221 __bindgen_bitfield_unit.set(13usize, 1u8, {
11222 let one: u32 = unsafe { ::std::mem::transmute(one) };
11223 one as u64
11224 });
11225 __bindgen_bitfield_unit.set(14usize, 18u8, {
11226 let bitrate: u32 = unsafe { ::std::mem::transmute(bitrate) };
11227 bitrate as u64
11228 });
11229 __bindgen_bitfield_unit
11230 }
11231}
11232#[test]
11233fn bindgen_test_layout_dvb_mpeg_es_seq_start__bindgen_ty_3() {
11234 assert_eq!(
11235 ::std::mem::size_of::<dvb_mpeg_es_seq_start__bindgen_ty_3>(),
11236 4usize,
11237 concat!("Size of: ", stringify!(dvb_mpeg_es_seq_start__bindgen_ty_3))
11238 );
11239 assert_eq!(
11240 ::std::mem::align_of::<dvb_mpeg_es_seq_start__bindgen_ty_3>(),
11241 1usize,
11242 concat!(
11243 "Alignment of ",
11244 stringify!(dvb_mpeg_es_seq_start__bindgen_ty_3)
11245 )
11246 );
11247 assert_eq!(
11248 unsafe {
11249 &(*(::std::ptr::null::<dvb_mpeg_es_seq_start__bindgen_ty_3>())).bitfield3 as *const _
11250 as usize
11251 },
11252 0usize,
11253 concat!(
11254 "Offset of field: ",
11255 stringify!(dvb_mpeg_es_seq_start__bindgen_ty_3),
11256 "::",
11257 stringify!(bitfield3)
11258 )
11259 );
11260}
11261#[test]
11262fn bindgen_test_layout_dvb_mpeg_es_seq_start() {
11263 assert_eq!(
11264 ::std::mem::size_of::<dvb_mpeg_es_seq_start>(),
11265 12usize,
11266 concat!("Size of: ", stringify!(dvb_mpeg_es_seq_start))
11267 );
11268 assert_eq!(
11269 ::std::mem::align_of::<dvb_mpeg_es_seq_start>(),
11270 1usize,
11271 concat!("Alignment of ", stringify!(dvb_mpeg_es_seq_start))
11272 );
11273}
11274#[repr(C, packed)]
11275#[derive(Copy, Clone)]
11276pub struct dvb_mpeg_es_pic_start {
11277 pub __bindgen_anon_1: dvb_mpeg_es_pic_start__bindgen_ty_1,
11278 pub __bindgen_anon_2: dvb_mpeg_es_pic_start__bindgen_ty_2,
11279}
11280#[repr(C, packed)]
11281#[derive(Copy, Clone)]
11282pub union dvb_mpeg_es_pic_start__bindgen_ty_1 {
11283 pub bitfield: u32,
11284 pub __bindgen_anon_1: dvb_mpeg_es_pic_start__bindgen_ty_1__bindgen_ty_1,
11285 _bindgen_union_align: [u8; 4usize],
11286}
11287#[repr(C, packed)]
11288#[derive(Debug, Copy, Clone)]
11289pub struct dvb_mpeg_es_pic_start__bindgen_ty_1__bindgen_ty_1 {
11290 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize], u8>,
11291}
11292#[test]
11293fn bindgen_test_layout_dvb_mpeg_es_pic_start__bindgen_ty_1__bindgen_ty_1() {
11294 assert_eq!(
11295 ::std::mem::size_of::<dvb_mpeg_es_pic_start__bindgen_ty_1__bindgen_ty_1>(),
11296 4usize,
11297 concat!(
11298 "Size of: ",
11299 stringify!(dvb_mpeg_es_pic_start__bindgen_ty_1__bindgen_ty_1)
11300 )
11301 );
11302 assert_eq!(
11303 ::std::mem::align_of::<dvb_mpeg_es_pic_start__bindgen_ty_1__bindgen_ty_1>(),
11304 1usize,
11305 concat!(
11306 "Alignment of ",
11307 stringify!(dvb_mpeg_es_pic_start__bindgen_ty_1__bindgen_ty_1)
11308 )
11309 );
11310}
11311impl dvb_mpeg_es_pic_start__bindgen_ty_1__bindgen_ty_1 {
11312 #[inline]
11313 pub fn type_(&self) -> u32 {
11314 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 8u8) as u32) }
11315 }
11316 #[inline]
11317 pub fn set_type(&mut self, val: u32) {
11318 unsafe {
11319 let val: u32 = ::std::mem::transmute(val);
11320 self._bitfield_1.set(0usize, 8u8, val as u64)
11321 }
11322 }
11323 #[inline]
11324 pub fn sync(&self) -> u32 {
11325 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 24u8) as u32) }
11326 }
11327 #[inline]
11328 pub fn set_sync(&mut self, val: u32) {
11329 unsafe {
11330 let val: u32 = ::std::mem::transmute(val);
11331 self._bitfield_1.set(8usize, 24u8, val as u64)
11332 }
11333 }
11334 #[inline]
11335 pub fn new_bitfield_1(type_: u32, sync: u32) -> __BindgenBitfieldUnit<[u8; 4usize], u8> {
11336 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize], u8> =
11337 Default::default();
11338 __bindgen_bitfield_unit.set(0usize, 8u8, {
11339 let type_: u32 = unsafe { ::std::mem::transmute(type_) };
11340 type_ as u64
11341 });
11342 __bindgen_bitfield_unit.set(8usize, 24u8, {
11343 let sync: u32 = unsafe { ::std::mem::transmute(sync) };
11344 sync as u64
11345 });
11346 __bindgen_bitfield_unit
11347 }
11348}
11349#[test]
11350fn bindgen_test_layout_dvb_mpeg_es_pic_start__bindgen_ty_1() {
11351 assert_eq!(
11352 ::std::mem::size_of::<dvb_mpeg_es_pic_start__bindgen_ty_1>(),
11353 4usize,
11354 concat!("Size of: ", stringify!(dvb_mpeg_es_pic_start__bindgen_ty_1))
11355 );
11356 assert_eq!(
11357 ::std::mem::align_of::<dvb_mpeg_es_pic_start__bindgen_ty_1>(),
11358 1usize,
11359 concat!(
11360 "Alignment of ",
11361 stringify!(dvb_mpeg_es_pic_start__bindgen_ty_1)
11362 )
11363 );
11364 assert_eq!(
11365 unsafe {
11366 &(*(::std::ptr::null::<dvb_mpeg_es_pic_start__bindgen_ty_1>())).bitfield as *const _
11367 as usize
11368 },
11369 0usize,
11370 concat!(
11371 "Offset of field: ",
11372 stringify!(dvb_mpeg_es_pic_start__bindgen_ty_1),
11373 "::",
11374 stringify!(bitfield)
11375 )
11376 );
11377}
11378#[repr(C, packed)]
11379#[derive(Copy, Clone)]
11380pub union dvb_mpeg_es_pic_start__bindgen_ty_2 {
11381 pub bitfield2: u32,
11382 pub __bindgen_anon_1: dvb_mpeg_es_pic_start__bindgen_ty_2__bindgen_ty_1,
11383 _bindgen_union_align: [u8; 4usize],
11384}
11385#[repr(C, packed)]
11386#[derive(Debug, Copy, Clone)]
11387pub struct dvb_mpeg_es_pic_start__bindgen_ty_2__bindgen_ty_1 {
11388 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize], u8>,
11389}
11390#[test]
11391fn bindgen_test_layout_dvb_mpeg_es_pic_start__bindgen_ty_2__bindgen_ty_1() {
11392 assert_eq!(
11393 ::std::mem::size_of::<dvb_mpeg_es_pic_start__bindgen_ty_2__bindgen_ty_1>(),
11394 4usize,
11395 concat!(
11396 "Size of: ",
11397 stringify!(dvb_mpeg_es_pic_start__bindgen_ty_2__bindgen_ty_1)
11398 )
11399 );
11400 assert_eq!(
11401 ::std::mem::align_of::<dvb_mpeg_es_pic_start__bindgen_ty_2__bindgen_ty_1>(),
11402 1usize,
11403 concat!(
11404 "Alignment of ",
11405 stringify!(dvb_mpeg_es_pic_start__bindgen_ty_2__bindgen_ty_1)
11406 )
11407 );
11408}
11409impl dvb_mpeg_es_pic_start__bindgen_ty_2__bindgen_ty_1 {
11410 #[inline]
11411 pub fn dummy(&self) -> u32 {
11412 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 3u8) as u32) }
11413 }
11414 #[inline]
11415 pub fn set_dummy(&mut self, val: u32) {
11416 unsafe {
11417 let val: u32 = ::std::mem::transmute(val);
11418 self._bitfield_1.set(0usize, 3u8, val as u64)
11419 }
11420 }
11421 #[inline]
11422 pub fn vbv_delay(&self) -> u32 {
11423 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 16u8) as u32) }
11424 }
11425 #[inline]
11426 pub fn set_vbv_delay(&mut self, val: u32) {
11427 unsafe {
11428 let val: u32 = ::std::mem::transmute(val);
11429 self._bitfield_1.set(3usize, 16u8, val as u64)
11430 }
11431 }
11432 #[inline]
11433 pub fn coding_type(&self) -> u32 {
11434 unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 3u8) as u32) }
11435 }
11436 #[inline]
11437 pub fn set_coding_type(&mut self, val: u32) {
11438 unsafe {
11439 let val: u32 = ::std::mem::transmute(val);
11440 self._bitfield_1.set(19usize, 3u8, val as u64)
11441 }
11442 }
11443 #[inline]
11444 pub fn temporal_ref(&self) -> u32 {
11445 unsafe { ::std::mem::transmute(self._bitfield_1.get(22usize, 10u8) as u32) }
11446 }
11447 #[inline]
11448 pub fn set_temporal_ref(&mut self, val: u32) {
11449 unsafe {
11450 let val: u32 = ::std::mem::transmute(val);
11451 self._bitfield_1.set(22usize, 10u8, val as u64)
11452 }
11453 }
11454 #[inline]
11455 pub fn new_bitfield_1(
11456 dummy: u32,
11457 vbv_delay: u32,
11458 coding_type: u32,
11459 temporal_ref: u32,
11460 ) -> __BindgenBitfieldUnit<[u8; 4usize], u8> {
11461 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize], u8> =
11462 Default::default();
11463 __bindgen_bitfield_unit.set(0usize, 3u8, {
11464 let dummy: u32 = unsafe { ::std::mem::transmute(dummy) };
11465 dummy as u64
11466 });
11467 __bindgen_bitfield_unit.set(3usize, 16u8, {
11468 let vbv_delay: u32 = unsafe { ::std::mem::transmute(vbv_delay) };
11469 vbv_delay as u64
11470 });
11471 __bindgen_bitfield_unit.set(19usize, 3u8, {
11472 let coding_type: u32 = unsafe { ::std::mem::transmute(coding_type) };
11473 coding_type as u64
11474 });
11475 __bindgen_bitfield_unit.set(22usize, 10u8, {
11476 let temporal_ref: u32 = unsafe { ::std::mem::transmute(temporal_ref) };
11477 temporal_ref as u64
11478 });
11479 __bindgen_bitfield_unit
11480 }
11481}
11482#[test]
11483fn bindgen_test_layout_dvb_mpeg_es_pic_start__bindgen_ty_2() {
11484 assert_eq!(
11485 ::std::mem::size_of::<dvb_mpeg_es_pic_start__bindgen_ty_2>(),
11486 4usize,
11487 concat!("Size of: ", stringify!(dvb_mpeg_es_pic_start__bindgen_ty_2))
11488 );
11489 assert_eq!(
11490 ::std::mem::align_of::<dvb_mpeg_es_pic_start__bindgen_ty_2>(),
11491 1usize,
11492 concat!(
11493 "Alignment of ",
11494 stringify!(dvb_mpeg_es_pic_start__bindgen_ty_2)
11495 )
11496 );
11497 assert_eq!(
11498 unsafe {
11499 &(*(::std::ptr::null::<dvb_mpeg_es_pic_start__bindgen_ty_2>())).bitfield2 as *const _
11500 as usize
11501 },
11502 0usize,
11503 concat!(
11504 "Offset of field: ",
11505 stringify!(dvb_mpeg_es_pic_start__bindgen_ty_2),
11506 "::",
11507 stringify!(bitfield2)
11508 )
11509 );
11510}
11511#[test]
11512fn bindgen_test_layout_dvb_mpeg_es_pic_start() {
11513 assert_eq!(
11514 ::std::mem::size_of::<dvb_mpeg_es_pic_start>(),
11515 8usize,
11516 concat!("Size of: ", stringify!(dvb_mpeg_es_pic_start))
11517 );
11518 assert_eq!(
11519 ::std::mem::align_of::<dvb_mpeg_es_pic_start>(),
11520 1usize,
11521 concat!("Alignment of ", stringify!(dvb_mpeg_es_pic_start))
11522 );
11523}
11524#[repr(u32)]
11525#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
11526pub enum dvb_mpeg_es_frame_t {
11527 DVB_MPEG_ES_FRAME_UNKNOWN = 0,
11528 DVB_MPEG_ES_FRAME_I = 1,
11529 DVB_MPEG_ES_FRAME_P = 2,
11530 DVB_MPEG_ES_FRAME_B = 3,
11531 DVB_MPEG_ES_FRAME_D = 4,
11532}
11533extern "C" {
11534 pub static mut dvb_mpeg_es_frame_names: [*const ::std::os::raw::c_char; 5usize];
11535}
11536extern "C" {
11537 pub fn dvb_mpeg_es_seq_start_init(
11538 buf: *const u8,
11539 buflen: ssize_t,
11540 seq_start: *mut dvb_mpeg_es_seq_start,
11541 ) -> ::std::os::raw::c_int;
11542}
11543extern "C" {
11544 pub fn dvb_mpeg_es_seq_start_print(
11545 parms: *mut dvb_v5_fe_parms,
11546 seq_start: *mut dvb_mpeg_es_seq_start,
11547 );
11548}
11549extern "C" {
11550 pub fn dvb_mpeg_es_pic_start_init(
11551 buf: *const u8,
11552 buflen: ssize_t,
11553 pic_start: *mut dvb_mpeg_es_pic_start,
11554 ) -> ::std::os::raw::c_int;
11555}
11556extern "C" {
11557 pub fn dvb_mpeg_es_pic_start_print(
11558 parms: *mut dvb_v5_fe_parms,
11559 pic_start: *mut dvb_mpeg_es_pic_start,
11560 );
11561}
11562#[repr(C, packed)]
11563#[derive(Copy, Clone)]
11564pub struct ts_t {
11565 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize], u8>,
11566 pub __bindgen_anon_1: ts_t__bindgen_ty_1,
11567 pub __bindgen_anon_2: ts_t__bindgen_ty_2,
11568}
11569#[repr(C, packed)]
11570#[derive(Copy, Clone)]
11571pub union ts_t__bindgen_ty_1 {
11572 pub bitfield: u16,
11573 pub __bindgen_anon_1: ts_t__bindgen_ty_1__bindgen_ty_1,
11574 _bindgen_union_align: [u8; 2usize],
11575}
11576#[repr(C, packed)]
11577#[derive(Debug, Copy, Clone)]
11578pub struct ts_t__bindgen_ty_1__bindgen_ty_1 {
11579 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize], u8>,
11580}
11581#[test]
11582fn bindgen_test_layout_ts_t__bindgen_ty_1__bindgen_ty_1() {
11583 assert_eq!(
11584 ::std::mem::size_of::<ts_t__bindgen_ty_1__bindgen_ty_1>(),
11585 2usize,
11586 concat!("Size of: ", stringify!(ts_t__bindgen_ty_1__bindgen_ty_1))
11587 );
11588 assert_eq!(
11589 ::std::mem::align_of::<ts_t__bindgen_ty_1__bindgen_ty_1>(),
11590 1usize,
11591 concat!(
11592 "Alignment of ",
11593 stringify!(ts_t__bindgen_ty_1__bindgen_ty_1)
11594 )
11595 );
11596}
11597impl ts_t__bindgen_ty_1__bindgen_ty_1 {
11598 #[inline]
11599 pub fn one1(&self) -> u16 {
11600 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u16) }
11601 }
11602 #[inline]
11603 pub fn set_one1(&mut self, val: u16) {
11604 unsafe {
11605 let val: u16 = ::std::mem::transmute(val);
11606 self._bitfield_1.set(0usize, 1u8, val as u64)
11607 }
11608 }
11609 #[inline]
11610 pub fn bits15(&self) -> u16 {
11611 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 15u8) as u16) }
11612 }
11613 #[inline]
11614 pub fn set_bits15(&mut self, val: u16) {
11615 unsafe {
11616 let val: u16 = ::std::mem::transmute(val);
11617 self._bitfield_1.set(1usize, 15u8, val as u64)
11618 }
11619 }
11620 #[inline]
11621 pub fn new_bitfield_1(one1: u16, bits15: u16) -> __BindgenBitfieldUnit<[u8; 2usize], u8> {
11622 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize], u8> =
11623 Default::default();
11624 __bindgen_bitfield_unit.set(0usize, 1u8, {
11625 let one1: u16 = unsafe { ::std::mem::transmute(one1) };
11626 one1 as u64
11627 });
11628 __bindgen_bitfield_unit.set(1usize, 15u8, {
11629 let bits15: u16 = unsafe { ::std::mem::transmute(bits15) };
11630 bits15 as u64
11631 });
11632 __bindgen_bitfield_unit
11633 }
11634}
11635#[test]
11636fn bindgen_test_layout_ts_t__bindgen_ty_1() {
11637 assert_eq!(
11638 ::std::mem::size_of::<ts_t__bindgen_ty_1>(),
11639 2usize,
11640 concat!("Size of: ", stringify!(ts_t__bindgen_ty_1))
11641 );
11642 assert_eq!(
11643 ::std::mem::align_of::<ts_t__bindgen_ty_1>(),
11644 1usize,
11645 concat!("Alignment of ", stringify!(ts_t__bindgen_ty_1))
11646 );
11647 assert_eq!(
11648 unsafe { &(*(::std::ptr::null::<ts_t__bindgen_ty_1>())).bitfield as *const _ as usize },
11649 0usize,
11650 concat!(
11651 "Offset of field: ",
11652 stringify!(ts_t__bindgen_ty_1),
11653 "::",
11654 stringify!(bitfield)
11655 )
11656 );
11657}
11658#[repr(C, packed)]
11659#[derive(Copy, Clone)]
11660pub union ts_t__bindgen_ty_2 {
11661 pub bitfield2: u16,
11662 pub __bindgen_anon_1: ts_t__bindgen_ty_2__bindgen_ty_1,
11663 _bindgen_union_align: [u8; 2usize],
11664}
11665#[repr(C, packed)]
11666#[derive(Debug, Copy, Clone)]
11667pub struct ts_t__bindgen_ty_2__bindgen_ty_1 {
11668 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize], u8>,
11669}
11670#[test]
11671fn bindgen_test_layout_ts_t__bindgen_ty_2__bindgen_ty_1() {
11672 assert_eq!(
11673 ::std::mem::size_of::<ts_t__bindgen_ty_2__bindgen_ty_1>(),
11674 2usize,
11675 concat!("Size of: ", stringify!(ts_t__bindgen_ty_2__bindgen_ty_1))
11676 );
11677 assert_eq!(
11678 ::std::mem::align_of::<ts_t__bindgen_ty_2__bindgen_ty_1>(),
11679 1usize,
11680 concat!(
11681 "Alignment of ",
11682 stringify!(ts_t__bindgen_ty_2__bindgen_ty_1)
11683 )
11684 );
11685}
11686impl ts_t__bindgen_ty_2__bindgen_ty_1 {
11687 #[inline]
11688 pub fn one2(&self) -> u16 {
11689 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u16) }
11690 }
11691 #[inline]
11692 pub fn set_one2(&mut self, val: u16) {
11693 unsafe {
11694 let val: u16 = ::std::mem::transmute(val);
11695 self._bitfield_1.set(0usize, 1u8, val as u64)
11696 }
11697 }
11698 #[inline]
11699 pub fn bits00(&self) -> u16 {
11700 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 15u8) as u16) }
11701 }
11702 #[inline]
11703 pub fn set_bits00(&mut self, val: u16) {
11704 unsafe {
11705 let val: u16 = ::std::mem::transmute(val);
11706 self._bitfield_1.set(1usize, 15u8, val as u64)
11707 }
11708 }
11709 #[inline]
11710 pub fn new_bitfield_1(one2: u16, bits00: u16) -> __BindgenBitfieldUnit<[u8; 2usize], u8> {
11711 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize], u8> =
11712 Default::default();
11713 __bindgen_bitfield_unit.set(0usize, 1u8, {
11714 let one2: u16 = unsafe { ::std::mem::transmute(one2) };
11715 one2 as u64
11716 });
11717 __bindgen_bitfield_unit.set(1usize, 15u8, {
11718 let bits00: u16 = unsafe { ::std::mem::transmute(bits00) };
11719 bits00 as u64
11720 });
11721 __bindgen_bitfield_unit
11722 }
11723}
11724#[test]
11725fn bindgen_test_layout_ts_t__bindgen_ty_2() {
11726 assert_eq!(
11727 ::std::mem::size_of::<ts_t__bindgen_ty_2>(),
11728 2usize,
11729 concat!("Size of: ", stringify!(ts_t__bindgen_ty_2))
11730 );
11731 assert_eq!(
11732 ::std::mem::align_of::<ts_t__bindgen_ty_2>(),
11733 1usize,
11734 concat!("Alignment of ", stringify!(ts_t__bindgen_ty_2))
11735 );
11736 assert_eq!(
11737 unsafe { &(*(::std::ptr::null::<ts_t__bindgen_ty_2>())).bitfield2 as *const _ as usize },
11738 0usize,
11739 concat!(
11740 "Offset of field: ",
11741 stringify!(ts_t__bindgen_ty_2),
11742 "::",
11743 stringify!(bitfield2)
11744 )
11745 );
11746}
11747#[test]
11748fn bindgen_test_layout_ts_t() {
11749 assert_eq!(
11750 ::std::mem::size_of::<ts_t>(),
11751 5usize,
11752 concat!("Size of: ", stringify!(ts_t))
11753 );
11754 assert_eq!(
11755 ::std::mem::align_of::<ts_t>(),
11756 1usize,
11757 concat!("Alignment of ", stringify!(ts_t))
11758 );
11759}
11760impl ts_t {
11761 #[inline]
11762 pub fn one(&self) -> u8 {
11763 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
11764 }
11765 #[inline]
11766 pub fn set_one(&mut self, val: u8) {
11767 unsafe {
11768 let val: u8 = ::std::mem::transmute(val);
11769 self._bitfield_1.set(0usize, 1u8, val as u64)
11770 }
11771 }
11772 #[inline]
11773 pub fn bits30(&self) -> u8 {
11774 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 3u8) as u8) }
11775 }
11776 #[inline]
11777 pub fn set_bits30(&mut self, val: u8) {
11778 unsafe {
11779 let val: u8 = ::std::mem::transmute(val);
11780 self._bitfield_1.set(1usize, 3u8, val as u64)
11781 }
11782 }
11783 #[inline]
11784 pub fn tag(&self) -> u8 {
11785 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 4u8) as u8) }
11786 }
11787 #[inline]
11788 pub fn set_tag(&mut self, val: u8) {
11789 unsafe {
11790 let val: u8 = ::std::mem::transmute(val);
11791 self._bitfield_1.set(4usize, 4u8, val as u64)
11792 }
11793 }
11794 #[inline]
11795 pub fn new_bitfield_1(one: u8, bits30: u8, tag: u8) -> __BindgenBitfieldUnit<[u8; 1usize], u8> {
11796 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize], u8> =
11797 Default::default();
11798 __bindgen_bitfield_unit.set(0usize, 1u8, {
11799 let one: u8 = unsafe { ::std::mem::transmute(one) };
11800 one as u64
11801 });
11802 __bindgen_bitfield_unit.set(1usize, 3u8, {
11803 let bits30: u8 = unsafe { ::std::mem::transmute(bits30) };
11804 bits30 as u64
11805 });
11806 __bindgen_bitfield_unit.set(4usize, 4u8, {
11807 let tag: u8 = unsafe { ::std::mem::transmute(tag) };
11808 tag as u64
11809 });
11810 __bindgen_bitfield_unit
11811 }
11812}
11813#[repr(C, packed)]
11814#[derive(Copy, Clone)]
11815pub struct dvb_mpeg_pes_optional {
11816 pub __bindgen_anon_1: dvb_mpeg_pes_optional__bindgen_ty_1,
11817 pub length: u8,
11818 pub pts: u64,
11819 pub dts: u64,
11820}
11821#[repr(C, packed)]
11822#[derive(Copy, Clone)]
11823pub union dvb_mpeg_pes_optional__bindgen_ty_1 {
11824 pub bitfield: u16,
11825 pub __bindgen_anon_1: dvb_mpeg_pes_optional__bindgen_ty_1__bindgen_ty_1,
11826 _bindgen_union_align: [u8; 2usize],
11827}
11828#[repr(C, packed)]
11829#[derive(Debug, Copy, Clone)]
11830pub struct dvb_mpeg_pes_optional__bindgen_ty_1__bindgen_ty_1 {
11831 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize], u8>,
11832}
11833#[test]
11834fn bindgen_test_layout_dvb_mpeg_pes_optional__bindgen_ty_1__bindgen_ty_1() {
11835 assert_eq!(
11836 ::std::mem::size_of::<dvb_mpeg_pes_optional__bindgen_ty_1__bindgen_ty_1>(),
11837 2usize,
11838 concat!(
11839 "Size of: ",
11840 stringify!(dvb_mpeg_pes_optional__bindgen_ty_1__bindgen_ty_1)
11841 )
11842 );
11843 assert_eq!(
11844 ::std::mem::align_of::<dvb_mpeg_pes_optional__bindgen_ty_1__bindgen_ty_1>(),
11845 1usize,
11846 concat!(
11847 "Alignment of ",
11848 stringify!(dvb_mpeg_pes_optional__bindgen_ty_1__bindgen_ty_1)
11849 )
11850 );
11851}
11852impl dvb_mpeg_pes_optional__bindgen_ty_1__bindgen_ty_1 {
11853 #[inline]
11854 pub fn PES_extension(&self) -> u16 {
11855 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u16) }
11856 }
11857 #[inline]
11858 pub fn set_PES_extension(&mut self, val: u16) {
11859 unsafe {
11860 let val: u16 = ::std::mem::transmute(val);
11861 self._bitfield_1.set(0usize, 1u8, val as u64)
11862 }
11863 }
11864 #[inline]
11865 pub fn PES_CRC(&self) -> u16 {
11866 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u16) }
11867 }
11868 #[inline]
11869 pub fn set_PES_CRC(&mut self, val: u16) {
11870 unsafe {
11871 let val: u16 = ::std::mem::transmute(val);
11872 self._bitfield_1.set(1usize, 1u8, val as u64)
11873 }
11874 }
11875 #[inline]
11876 pub fn additional_copy_info(&self) -> u16 {
11877 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u16) }
11878 }
11879 #[inline]
11880 pub fn set_additional_copy_info(&mut self, val: u16) {
11881 unsafe {
11882 let val: u16 = ::std::mem::transmute(val);
11883 self._bitfield_1.set(2usize, 1u8, val as u64)
11884 }
11885 }
11886 #[inline]
11887 pub fn DSM_trick_mode(&self) -> u16 {
11888 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u16) }
11889 }
11890 #[inline]
11891 pub fn set_DSM_trick_mode(&mut self, val: u16) {
11892 unsafe {
11893 let val: u16 = ::std::mem::transmute(val);
11894 self._bitfield_1.set(3usize, 1u8, val as u64)
11895 }
11896 }
11897 #[inline]
11898 pub fn ES_rate(&self) -> u16 {
11899 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u16) }
11900 }
11901 #[inline]
11902 pub fn set_ES_rate(&mut self, val: u16) {
11903 unsafe {
11904 let val: u16 = ::std::mem::transmute(val);
11905 self._bitfield_1.set(4usize, 1u8, val as u64)
11906 }
11907 }
11908 #[inline]
11909 pub fn ESCR(&self) -> u16 {
11910 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u16) }
11911 }
11912 #[inline]
11913 pub fn set_ESCR(&mut self, val: u16) {
11914 unsafe {
11915 let val: u16 = ::std::mem::transmute(val);
11916 self._bitfield_1.set(5usize, 1u8, val as u64)
11917 }
11918 }
11919 #[inline]
11920 pub fn PTS_DTS(&self) -> u16 {
11921 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 2u8) as u16) }
11922 }
11923 #[inline]
11924 pub fn set_PTS_DTS(&mut self, val: u16) {
11925 unsafe {
11926 let val: u16 = ::std::mem::transmute(val);
11927 self._bitfield_1.set(6usize, 2u8, val as u64)
11928 }
11929 }
11930 #[inline]
11931 pub fn original_or_copy(&self) -> u16 {
11932 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u16) }
11933 }
11934 #[inline]
11935 pub fn set_original_or_copy(&mut self, val: u16) {
11936 unsafe {
11937 let val: u16 = ::std::mem::transmute(val);
11938 self._bitfield_1.set(8usize, 1u8, val as u64)
11939 }
11940 }
11941 #[inline]
11942 pub fn copyright(&self) -> u16 {
11943 unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u16) }
11944 }
11945 #[inline]
11946 pub fn set_copyright(&mut self, val: u16) {
11947 unsafe {
11948 let val: u16 = ::std::mem::transmute(val);
11949 self._bitfield_1.set(9usize, 1u8, val as u64)
11950 }
11951 }
11952 #[inline]
11953 pub fn data_alignment_indicator(&self) -> u16 {
11954 unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u16) }
11955 }
11956 #[inline]
11957 pub fn set_data_alignment_indicator(&mut self, val: u16) {
11958 unsafe {
11959 let val: u16 = ::std::mem::transmute(val);
11960 self._bitfield_1.set(10usize, 1u8, val as u64)
11961 }
11962 }
11963 #[inline]
11964 pub fn PES_priority(&self) -> u16 {
11965 unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u16) }
11966 }
11967 #[inline]
11968 pub fn set_PES_priority(&mut self, val: u16) {
11969 unsafe {
11970 let val: u16 = ::std::mem::transmute(val);
11971 self._bitfield_1.set(11usize, 1u8, val as u64)
11972 }
11973 }
11974 #[inline]
11975 pub fn PES_scrambling_control(&self) -> u16 {
11976 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 2u8) as u16) }
11977 }
11978 #[inline]
11979 pub fn set_PES_scrambling_control(&mut self, val: u16) {
11980 unsafe {
11981 let val: u16 = ::std::mem::transmute(val);
11982 self._bitfield_1.set(12usize, 2u8, val as u64)
11983 }
11984 }
11985 #[inline]
11986 pub fn two(&self) -> u16 {
11987 unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 2u8) as u16) }
11988 }
11989 #[inline]
11990 pub fn set_two(&mut self, val: u16) {
11991 unsafe {
11992 let val: u16 = ::std::mem::transmute(val);
11993 self._bitfield_1.set(14usize, 2u8, val as u64)
11994 }
11995 }
11996 #[inline]
11997 pub fn new_bitfield_1(
11998 PES_extension: u16,
11999 PES_CRC: u16,
12000 additional_copy_info: u16,
12001 DSM_trick_mode: u16,
12002 ES_rate: u16,
12003 ESCR: u16,
12004 PTS_DTS: u16,
12005 original_or_copy: u16,
12006 copyright: u16,
12007 data_alignment_indicator: u16,
12008 PES_priority: u16,
12009 PES_scrambling_control: u16,
12010 two: u16,
12011 ) -> __BindgenBitfieldUnit<[u8; 2usize], u8> {
12012 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize], u8> =
12013 Default::default();
12014 __bindgen_bitfield_unit.set(0usize, 1u8, {
12015 let PES_extension: u16 = unsafe { ::std::mem::transmute(PES_extension) };
12016 PES_extension as u64
12017 });
12018 __bindgen_bitfield_unit.set(1usize, 1u8, {
12019 let PES_CRC: u16 = unsafe { ::std::mem::transmute(PES_CRC) };
12020 PES_CRC as u64
12021 });
12022 __bindgen_bitfield_unit.set(2usize, 1u8, {
12023 let additional_copy_info: u16 = unsafe { ::std::mem::transmute(additional_copy_info) };
12024 additional_copy_info as u64
12025 });
12026 __bindgen_bitfield_unit.set(3usize, 1u8, {
12027 let DSM_trick_mode: u16 = unsafe { ::std::mem::transmute(DSM_trick_mode) };
12028 DSM_trick_mode as u64
12029 });
12030 __bindgen_bitfield_unit.set(4usize, 1u8, {
12031 let ES_rate: u16 = unsafe { ::std::mem::transmute(ES_rate) };
12032 ES_rate as u64
12033 });
12034 __bindgen_bitfield_unit.set(5usize, 1u8, {
12035 let ESCR: u16 = unsafe { ::std::mem::transmute(ESCR) };
12036 ESCR as u64
12037 });
12038 __bindgen_bitfield_unit.set(6usize, 2u8, {
12039 let PTS_DTS: u16 = unsafe { ::std::mem::transmute(PTS_DTS) };
12040 PTS_DTS as u64
12041 });
12042 __bindgen_bitfield_unit.set(8usize, 1u8, {
12043 let original_or_copy: u16 = unsafe { ::std::mem::transmute(original_or_copy) };
12044 original_or_copy as u64
12045 });
12046 __bindgen_bitfield_unit.set(9usize, 1u8, {
12047 let copyright: u16 = unsafe { ::std::mem::transmute(copyright) };
12048 copyright as u64
12049 });
12050 __bindgen_bitfield_unit.set(10usize, 1u8, {
12051 let data_alignment_indicator: u16 =
12052 unsafe { ::std::mem::transmute(data_alignment_indicator) };
12053 data_alignment_indicator as u64
12054 });
12055 __bindgen_bitfield_unit.set(11usize, 1u8, {
12056 let PES_priority: u16 = unsafe { ::std::mem::transmute(PES_priority) };
12057 PES_priority as u64
12058 });
12059 __bindgen_bitfield_unit.set(12usize, 2u8, {
12060 let PES_scrambling_control: u16 =
12061 unsafe { ::std::mem::transmute(PES_scrambling_control) };
12062 PES_scrambling_control as u64
12063 });
12064 __bindgen_bitfield_unit.set(14usize, 2u8, {
12065 let two: u16 = unsafe { ::std::mem::transmute(two) };
12066 two as u64
12067 });
12068 __bindgen_bitfield_unit
12069 }
12070}
12071#[test]
12072fn bindgen_test_layout_dvb_mpeg_pes_optional__bindgen_ty_1() {
12073 assert_eq!(
12074 ::std::mem::size_of::<dvb_mpeg_pes_optional__bindgen_ty_1>(),
12075 2usize,
12076 concat!("Size of: ", stringify!(dvb_mpeg_pes_optional__bindgen_ty_1))
12077 );
12078 assert_eq!(
12079 ::std::mem::align_of::<dvb_mpeg_pes_optional__bindgen_ty_1>(),
12080 1usize,
12081 concat!(
12082 "Alignment of ",
12083 stringify!(dvb_mpeg_pes_optional__bindgen_ty_1)
12084 )
12085 );
12086 assert_eq!(
12087 unsafe {
12088 &(*(::std::ptr::null::<dvb_mpeg_pes_optional__bindgen_ty_1>())).bitfield as *const _
12089 as usize
12090 },
12091 0usize,
12092 concat!(
12093 "Offset of field: ",
12094 stringify!(dvb_mpeg_pes_optional__bindgen_ty_1),
12095 "::",
12096 stringify!(bitfield)
12097 )
12098 );
12099}
12100#[test]
12101fn bindgen_test_layout_dvb_mpeg_pes_optional() {
12102 assert_eq!(
12103 ::std::mem::size_of::<dvb_mpeg_pes_optional>(),
12104 19usize,
12105 concat!("Size of: ", stringify!(dvb_mpeg_pes_optional))
12106 );
12107 assert_eq!(
12108 ::std::mem::align_of::<dvb_mpeg_pes_optional>(),
12109 1usize,
12110 concat!("Alignment of ", stringify!(dvb_mpeg_pes_optional))
12111 );
12112 assert_eq!(
12113 unsafe { &(*(::std::ptr::null::<dvb_mpeg_pes_optional>())).length as *const _ as usize },
12114 2usize,
12115 concat!(
12116 "Offset of field: ",
12117 stringify!(dvb_mpeg_pes_optional),
12118 "::",
12119 stringify!(length)
12120 )
12121 );
12122 assert_eq!(
12123 unsafe { &(*(::std::ptr::null::<dvb_mpeg_pes_optional>())).pts as *const _ as usize },
12124 3usize,
12125 concat!(
12126 "Offset of field: ",
12127 stringify!(dvb_mpeg_pes_optional),
12128 "::",
12129 stringify!(pts)
12130 )
12131 );
12132 assert_eq!(
12133 unsafe { &(*(::std::ptr::null::<dvb_mpeg_pes_optional>())).dts as *const _ as usize },
12134 11usize,
12135 concat!(
12136 "Offset of field: ",
12137 stringify!(dvb_mpeg_pes_optional),
12138 "::",
12139 stringify!(dts)
12140 )
12141 );
12142}
12143#[repr(C, packed)]
12144pub struct dvb_mpeg_pes {
12145 pub __bindgen_anon_1: dvb_mpeg_pes__bindgen_ty_1,
12146 pub length: u16,
12147 pub optional: __IncompleteArrayField<dvb_mpeg_pes_optional>,
12148}
12149#[repr(C, packed)]
12150#[derive(Copy, Clone)]
12151pub union dvb_mpeg_pes__bindgen_ty_1 {
12152 pub bitfield: u32,
12153 pub __bindgen_anon_1: dvb_mpeg_pes__bindgen_ty_1__bindgen_ty_1,
12154 _bindgen_union_align: [u8; 4usize],
12155}
12156#[repr(C, packed)]
12157#[derive(Debug, Copy, Clone)]
12158pub struct dvb_mpeg_pes__bindgen_ty_1__bindgen_ty_1 {
12159 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize], u8>,
12160}
12161#[test]
12162fn bindgen_test_layout_dvb_mpeg_pes__bindgen_ty_1__bindgen_ty_1() {
12163 assert_eq!(
12164 ::std::mem::size_of::<dvb_mpeg_pes__bindgen_ty_1__bindgen_ty_1>(),
12165 4usize,
12166 concat!(
12167 "Size of: ",
12168 stringify!(dvb_mpeg_pes__bindgen_ty_1__bindgen_ty_1)
12169 )
12170 );
12171 assert_eq!(
12172 ::std::mem::align_of::<dvb_mpeg_pes__bindgen_ty_1__bindgen_ty_1>(),
12173 1usize,
12174 concat!(
12175 "Alignment of ",
12176 stringify!(dvb_mpeg_pes__bindgen_ty_1__bindgen_ty_1)
12177 )
12178 );
12179}
12180impl dvb_mpeg_pes__bindgen_ty_1__bindgen_ty_1 {
12181 #[inline]
12182 pub fn stream_id(&self) -> u32 {
12183 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 8u8) as u32) }
12184 }
12185 #[inline]
12186 pub fn set_stream_id(&mut self, val: u32) {
12187 unsafe {
12188 let val: u32 = ::std::mem::transmute(val);
12189 self._bitfield_1.set(0usize, 8u8, val as u64)
12190 }
12191 }
12192 #[inline]
12193 pub fn sync(&self) -> u32 {
12194 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 24u8) as u32) }
12195 }
12196 #[inline]
12197 pub fn set_sync(&mut self, val: u32) {
12198 unsafe {
12199 let val: u32 = ::std::mem::transmute(val);
12200 self._bitfield_1.set(8usize, 24u8, val as u64)
12201 }
12202 }
12203 #[inline]
12204 pub fn new_bitfield_1(stream_id: u32, sync: u32) -> __BindgenBitfieldUnit<[u8; 4usize], u8> {
12205 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize], u8> =
12206 Default::default();
12207 __bindgen_bitfield_unit.set(0usize, 8u8, {
12208 let stream_id: u32 = unsafe { ::std::mem::transmute(stream_id) };
12209 stream_id as u64
12210 });
12211 __bindgen_bitfield_unit.set(8usize, 24u8, {
12212 let sync: u32 = unsafe { ::std::mem::transmute(sync) };
12213 sync as u64
12214 });
12215 __bindgen_bitfield_unit
12216 }
12217}
12218#[test]
12219fn bindgen_test_layout_dvb_mpeg_pes__bindgen_ty_1() {
12220 assert_eq!(
12221 ::std::mem::size_of::<dvb_mpeg_pes__bindgen_ty_1>(),
12222 4usize,
12223 concat!("Size of: ", stringify!(dvb_mpeg_pes__bindgen_ty_1))
12224 );
12225 assert_eq!(
12226 ::std::mem::align_of::<dvb_mpeg_pes__bindgen_ty_1>(),
12227 1usize,
12228 concat!("Alignment of ", stringify!(dvb_mpeg_pes__bindgen_ty_1))
12229 );
12230 assert_eq!(
12231 unsafe {
12232 &(*(::std::ptr::null::<dvb_mpeg_pes__bindgen_ty_1>())).bitfield as *const _ as usize
12233 },
12234 0usize,
12235 concat!(
12236 "Offset of field: ",
12237 stringify!(dvb_mpeg_pes__bindgen_ty_1),
12238 "::",
12239 stringify!(bitfield)
12240 )
12241 );
12242}
12243#[test]
12244fn bindgen_test_layout_dvb_mpeg_pes() {
12245 assert_eq!(
12246 ::std::mem::size_of::<dvb_mpeg_pes>(),
12247 6usize,
12248 concat!("Size of: ", stringify!(dvb_mpeg_pes))
12249 );
12250 assert_eq!(
12251 ::std::mem::align_of::<dvb_mpeg_pes>(),
12252 1usize,
12253 concat!("Alignment of ", stringify!(dvb_mpeg_pes))
12254 );
12255 assert_eq!(
12256 unsafe { &(*(::std::ptr::null::<dvb_mpeg_pes>())).length as *const _ as usize },
12257 4usize,
12258 concat!(
12259 "Offset of field: ",
12260 stringify!(dvb_mpeg_pes),
12261 "::",
12262 stringify!(length)
12263 )
12264 );
12265 assert_eq!(
12266 unsafe { &(*(::std::ptr::null::<dvb_mpeg_pes>())).optional as *const _ as usize },
12267 6usize,
12268 concat!(
12269 "Offset of field: ",
12270 stringify!(dvb_mpeg_pes),
12271 "::",
12272 stringify!(optional)
12273 )
12274 );
12275}
12276extern "C" {
12277 pub fn dvb_mpeg_pes_init(
12278 parms: *mut dvb_v5_fe_parms,
12279 buf: *const u8,
12280 buflen: ssize_t,
12281 table: *mut u8,
12282 ) -> ssize_t;
12283}
12284extern "C" {
12285 pub fn dvb_mpeg_pes_free(pes: *mut dvb_mpeg_pes);
12286}
12287extern "C" {
12288 pub fn dvb_mpeg_pes_print(parms: *mut dvb_v5_fe_parms, pes: *mut dvb_mpeg_pes);
12289}
12290#[repr(C, packed)]
12291#[derive(Debug)]
12292pub struct dvb_mpeg_ts_adaption {
12293 pub length: u8,
12294 pub __bindgen_anon_1: dvb_mpeg_ts_adaption__bindgen_ty_1,
12295 pub data: __IncompleteArrayField<u8>,
12296}
12297#[repr(C, packed)]
12298#[derive(Debug, Copy, Clone)]
12299pub struct dvb_mpeg_ts_adaption__bindgen_ty_1 {
12300 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize], u8>,
12301}
12302#[test]
12303fn bindgen_test_layout_dvb_mpeg_ts_adaption__bindgen_ty_1() {
12304 assert_eq!(
12305 ::std::mem::size_of::<dvb_mpeg_ts_adaption__bindgen_ty_1>(),
12306 1usize,
12307 concat!("Size of: ", stringify!(dvb_mpeg_ts_adaption__bindgen_ty_1))
12308 );
12309 assert_eq!(
12310 ::std::mem::align_of::<dvb_mpeg_ts_adaption__bindgen_ty_1>(),
12311 1usize,
12312 concat!(
12313 "Alignment of ",
12314 stringify!(dvb_mpeg_ts_adaption__bindgen_ty_1)
12315 )
12316 );
12317}
12318impl dvb_mpeg_ts_adaption__bindgen_ty_1 {
12319 #[inline]
12320 pub fn extension(&self) -> u8 {
12321 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
12322 }
12323 #[inline]
12324 pub fn set_extension(&mut self, val: u8) {
12325 unsafe {
12326 let val: u8 = ::std::mem::transmute(val);
12327 self._bitfield_1.set(0usize, 1u8, val as u64)
12328 }
12329 }
12330 #[inline]
12331 pub fn private_data(&self) -> u8 {
12332 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
12333 }
12334 #[inline]
12335 pub fn set_private_data(&mut self, val: u8) {
12336 unsafe {
12337 let val: u8 = ::std::mem::transmute(val);
12338 self._bitfield_1.set(1usize, 1u8, val as u64)
12339 }
12340 }
12341 #[inline]
12342 pub fn splicing_point(&self) -> u8 {
12343 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) }
12344 }
12345 #[inline]
12346 pub fn set_splicing_point(&mut self, val: u8) {
12347 unsafe {
12348 let val: u8 = ::std::mem::transmute(val);
12349 self._bitfield_1.set(2usize, 1u8, val as u64)
12350 }
12351 }
12352 #[inline]
12353 pub fn OPCR(&self) -> u8 {
12354 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8) }
12355 }
12356 #[inline]
12357 pub fn set_OPCR(&mut self, val: u8) {
12358 unsafe {
12359 let val: u8 = ::std::mem::transmute(val);
12360 self._bitfield_1.set(3usize, 1u8, val as u64)
12361 }
12362 }
12363 #[inline]
12364 pub fn PCR(&self) -> u8 {
12365 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u8) }
12366 }
12367 #[inline]
12368 pub fn set_PCR(&mut self, val: u8) {
12369 unsafe {
12370 let val: u8 = ::std::mem::transmute(val);
12371 self._bitfield_1.set(4usize, 1u8, val as u64)
12372 }
12373 }
12374 #[inline]
12375 pub fn priority(&self) -> u8 {
12376 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u8) }
12377 }
12378 #[inline]
12379 pub fn set_priority(&mut self, val: u8) {
12380 unsafe {
12381 let val: u8 = ::std::mem::transmute(val);
12382 self._bitfield_1.set(5usize, 1u8, val as u64)
12383 }
12384 }
12385 #[inline]
12386 pub fn random_access(&self) -> u8 {
12387 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u8) }
12388 }
12389 #[inline]
12390 pub fn set_random_access(&mut self, val: u8) {
12391 unsafe {
12392 let val: u8 = ::std::mem::transmute(val);
12393 self._bitfield_1.set(6usize, 1u8, val as u64)
12394 }
12395 }
12396 #[inline]
12397 pub fn discontinued(&self) -> u8 {
12398 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u8) }
12399 }
12400 #[inline]
12401 pub fn set_discontinued(&mut self, val: u8) {
12402 unsafe {
12403 let val: u8 = ::std::mem::transmute(val);
12404 self._bitfield_1.set(7usize, 1u8, val as u64)
12405 }
12406 }
12407 #[inline]
12408 pub fn new_bitfield_1(
12409 extension: u8,
12410 private_data: u8,
12411 splicing_point: u8,
12412 OPCR: u8,
12413 PCR: u8,
12414 priority: u8,
12415 random_access: u8,
12416 discontinued: u8,
12417 ) -> __BindgenBitfieldUnit<[u8; 1usize], u8> {
12418 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize], u8> =
12419 Default::default();
12420 __bindgen_bitfield_unit.set(0usize, 1u8, {
12421 let extension: u8 = unsafe { ::std::mem::transmute(extension) };
12422 extension as u64
12423 });
12424 __bindgen_bitfield_unit.set(1usize, 1u8, {
12425 let private_data: u8 = unsafe { ::std::mem::transmute(private_data) };
12426 private_data as u64
12427 });
12428 __bindgen_bitfield_unit.set(2usize, 1u8, {
12429 let splicing_point: u8 = unsafe { ::std::mem::transmute(splicing_point) };
12430 splicing_point as u64
12431 });
12432 __bindgen_bitfield_unit.set(3usize, 1u8, {
12433 let OPCR: u8 = unsafe { ::std::mem::transmute(OPCR) };
12434 OPCR as u64
12435 });
12436 __bindgen_bitfield_unit.set(4usize, 1u8, {
12437 let PCR: u8 = unsafe { ::std::mem::transmute(PCR) };
12438 PCR as u64
12439 });
12440 __bindgen_bitfield_unit.set(5usize, 1u8, {
12441 let priority: u8 = unsafe { ::std::mem::transmute(priority) };
12442 priority as u64
12443 });
12444 __bindgen_bitfield_unit.set(6usize, 1u8, {
12445 let random_access: u8 = unsafe { ::std::mem::transmute(random_access) };
12446 random_access as u64
12447 });
12448 __bindgen_bitfield_unit.set(7usize, 1u8, {
12449 let discontinued: u8 = unsafe { ::std::mem::transmute(discontinued) };
12450 discontinued as u64
12451 });
12452 __bindgen_bitfield_unit
12453 }
12454}
12455#[test]
12456fn bindgen_test_layout_dvb_mpeg_ts_adaption() {
12457 assert_eq!(
12458 ::std::mem::size_of::<dvb_mpeg_ts_adaption>(),
12459 2usize,
12460 concat!("Size of: ", stringify!(dvb_mpeg_ts_adaption))
12461 );
12462 assert_eq!(
12463 ::std::mem::align_of::<dvb_mpeg_ts_adaption>(),
12464 1usize,
12465 concat!("Alignment of ", stringify!(dvb_mpeg_ts_adaption))
12466 );
12467 assert_eq!(
12468 unsafe { &(*(::std::ptr::null::<dvb_mpeg_ts_adaption>())).length as *const _ as usize },
12469 0usize,
12470 concat!(
12471 "Offset of field: ",
12472 stringify!(dvb_mpeg_ts_adaption),
12473 "::",
12474 stringify!(length)
12475 )
12476 );
12477 assert_eq!(
12478 unsafe { &(*(::std::ptr::null::<dvb_mpeg_ts_adaption>())).data as *const _ as usize },
12479 2usize,
12480 concat!(
12481 "Offset of field: ",
12482 stringify!(dvb_mpeg_ts_adaption),
12483 "::",
12484 stringify!(data)
12485 )
12486 );
12487}
12488#[repr(C, packed)]
12489pub struct dvb_mpeg_ts {
12490 pub sync_byte: u8,
12491 pub __bindgen_anon_1: dvb_mpeg_ts__bindgen_ty_1,
12492 pub __bindgen_anon_2: dvb_mpeg_ts__bindgen_ty_2,
12493 pub adaption: __IncompleteArrayField<dvb_mpeg_ts_adaption>,
12494}
12495#[repr(C, packed)]
12496#[derive(Copy, Clone)]
12497pub union dvb_mpeg_ts__bindgen_ty_1 {
12498 pub bitfield: u16,
12499 pub __bindgen_anon_1: dvb_mpeg_ts__bindgen_ty_1__bindgen_ty_1,
12500 _bindgen_union_align: [u8; 2usize],
12501}
12502#[repr(C, packed)]
12503#[derive(Debug, Copy, Clone)]
12504pub struct dvb_mpeg_ts__bindgen_ty_1__bindgen_ty_1 {
12505 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize], u8>,
12506}
12507#[test]
12508fn bindgen_test_layout_dvb_mpeg_ts__bindgen_ty_1__bindgen_ty_1() {
12509 assert_eq!(
12510 ::std::mem::size_of::<dvb_mpeg_ts__bindgen_ty_1__bindgen_ty_1>(),
12511 2usize,
12512 concat!(
12513 "Size of: ",
12514 stringify!(dvb_mpeg_ts__bindgen_ty_1__bindgen_ty_1)
12515 )
12516 );
12517 assert_eq!(
12518 ::std::mem::align_of::<dvb_mpeg_ts__bindgen_ty_1__bindgen_ty_1>(),
12519 1usize,
12520 concat!(
12521 "Alignment of ",
12522 stringify!(dvb_mpeg_ts__bindgen_ty_1__bindgen_ty_1)
12523 )
12524 );
12525}
12526impl dvb_mpeg_ts__bindgen_ty_1__bindgen_ty_1 {
12527 #[inline]
12528 pub fn pid(&self) -> u16 {
12529 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 13u8) as u16) }
12530 }
12531 #[inline]
12532 pub fn set_pid(&mut self, val: u16) {
12533 unsafe {
12534 let val: u16 = ::std::mem::transmute(val);
12535 self._bitfield_1.set(0usize, 13u8, val as u64)
12536 }
12537 }
12538 #[inline]
12539 pub fn priority(&self) -> u16 {
12540 unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u16) }
12541 }
12542 #[inline]
12543 pub fn set_priority(&mut self, val: u16) {
12544 unsafe {
12545 let val: u16 = ::std::mem::transmute(val);
12546 self._bitfield_1.set(13usize, 1u8, val as u64)
12547 }
12548 }
12549 #[inline]
12550 pub fn payload_start(&self) -> u16 {
12551 unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u16) }
12552 }
12553 #[inline]
12554 pub fn set_payload_start(&mut self, val: u16) {
12555 unsafe {
12556 let val: u16 = ::std::mem::transmute(val);
12557 self._bitfield_1.set(14usize, 1u8, val as u64)
12558 }
12559 }
12560 #[inline]
12561 pub fn tei(&self) -> u16 {
12562 unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u16) }
12563 }
12564 #[inline]
12565 pub fn set_tei(&mut self, val: u16) {
12566 unsafe {
12567 let val: u16 = ::std::mem::transmute(val);
12568 self._bitfield_1.set(15usize, 1u8, val as u64)
12569 }
12570 }
12571 #[inline]
12572 pub fn new_bitfield_1(
12573 pid: u16,
12574 priority: u16,
12575 payload_start: u16,
12576 tei: u16,
12577 ) -> __BindgenBitfieldUnit<[u8; 2usize], u8> {
12578 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize], u8> =
12579 Default::default();
12580 __bindgen_bitfield_unit.set(0usize, 13u8, {
12581 let pid: u16 = unsafe { ::std::mem::transmute(pid) };
12582 pid as u64
12583 });
12584 __bindgen_bitfield_unit.set(13usize, 1u8, {
12585 let priority: u16 = unsafe { ::std::mem::transmute(priority) };
12586 priority as u64
12587 });
12588 __bindgen_bitfield_unit.set(14usize, 1u8, {
12589 let payload_start: u16 = unsafe { ::std::mem::transmute(payload_start) };
12590 payload_start as u64
12591 });
12592 __bindgen_bitfield_unit.set(15usize, 1u8, {
12593 let tei: u16 = unsafe { ::std::mem::transmute(tei) };
12594 tei as u64
12595 });
12596 __bindgen_bitfield_unit
12597 }
12598}
12599#[test]
12600fn bindgen_test_layout_dvb_mpeg_ts__bindgen_ty_1() {
12601 assert_eq!(
12602 ::std::mem::size_of::<dvb_mpeg_ts__bindgen_ty_1>(),
12603 2usize,
12604 concat!("Size of: ", stringify!(dvb_mpeg_ts__bindgen_ty_1))
12605 );
12606 assert_eq!(
12607 ::std::mem::align_of::<dvb_mpeg_ts__bindgen_ty_1>(),
12608 1usize,
12609 concat!("Alignment of ", stringify!(dvb_mpeg_ts__bindgen_ty_1))
12610 );
12611 assert_eq!(
12612 unsafe {
12613 &(*(::std::ptr::null::<dvb_mpeg_ts__bindgen_ty_1>())).bitfield as *const _ as usize
12614 },
12615 0usize,
12616 concat!(
12617 "Offset of field: ",
12618 stringify!(dvb_mpeg_ts__bindgen_ty_1),
12619 "::",
12620 stringify!(bitfield)
12621 )
12622 );
12623}
12624#[repr(C, packed)]
12625#[derive(Debug, Copy, Clone)]
12626pub struct dvb_mpeg_ts__bindgen_ty_2 {
12627 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize], u8>,
12628}
12629#[test]
12630fn bindgen_test_layout_dvb_mpeg_ts__bindgen_ty_2() {
12631 assert_eq!(
12632 ::std::mem::size_of::<dvb_mpeg_ts__bindgen_ty_2>(),
12633 1usize,
12634 concat!("Size of: ", stringify!(dvb_mpeg_ts__bindgen_ty_2))
12635 );
12636 assert_eq!(
12637 ::std::mem::align_of::<dvb_mpeg_ts__bindgen_ty_2>(),
12638 1usize,
12639 concat!("Alignment of ", stringify!(dvb_mpeg_ts__bindgen_ty_2))
12640 );
12641}
12642impl dvb_mpeg_ts__bindgen_ty_2 {
12643 #[inline]
12644 pub fn continuity_counter(&self) -> u8 {
12645 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u8) }
12646 }
12647 #[inline]
12648 pub fn set_continuity_counter(&mut self, val: u8) {
12649 unsafe {
12650 let val: u8 = ::std::mem::transmute(val);
12651 self._bitfield_1.set(0usize, 4u8, val as u64)
12652 }
12653 }
12654 #[inline]
12655 pub fn payload(&self) -> u8 {
12656 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u8) }
12657 }
12658 #[inline]
12659 pub fn set_payload(&mut self, val: u8) {
12660 unsafe {
12661 let val: u8 = ::std::mem::transmute(val);
12662 self._bitfield_1.set(4usize, 1u8, val as u64)
12663 }
12664 }
12665 #[inline]
12666 pub fn adaptation_field(&self) -> u8 {
12667 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u8) }
12668 }
12669 #[inline]
12670 pub fn set_adaptation_field(&mut self, val: u8) {
12671 unsafe {
12672 let val: u8 = ::std::mem::transmute(val);
12673 self._bitfield_1.set(5usize, 1u8, val as u64)
12674 }
12675 }
12676 #[inline]
12677 pub fn scrambling(&self) -> u8 {
12678 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 2u8) as u8) }
12679 }
12680 #[inline]
12681 pub fn set_scrambling(&mut self, val: u8) {
12682 unsafe {
12683 let val: u8 = ::std::mem::transmute(val);
12684 self._bitfield_1.set(6usize, 2u8, val as u64)
12685 }
12686 }
12687 #[inline]
12688 pub fn new_bitfield_1(
12689 continuity_counter: u8,
12690 payload: u8,
12691 adaptation_field: u8,
12692 scrambling: u8,
12693 ) -> __BindgenBitfieldUnit<[u8; 1usize], u8> {
12694 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize], u8> =
12695 Default::default();
12696 __bindgen_bitfield_unit.set(0usize, 4u8, {
12697 let continuity_counter: u8 = unsafe { ::std::mem::transmute(continuity_counter) };
12698 continuity_counter as u64
12699 });
12700 __bindgen_bitfield_unit.set(4usize, 1u8, {
12701 let payload: u8 = unsafe { ::std::mem::transmute(payload) };
12702 payload as u64
12703 });
12704 __bindgen_bitfield_unit.set(5usize, 1u8, {
12705 let adaptation_field: u8 = unsafe { ::std::mem::transmute(adaptation_field) };
12706 adaptation_field as u64
12707 });
12708 __bindgen_bitfield_unit.set(6usize, 2u8, {
12709 let scrambling: u8 = unsafe { ::std::mem::transmute(scrambling) };
12710 scrambling as u64
12711 });
12712 __bindgen_bitfield_unit
12713 }
12714}
12715#[test]
12716fn bindgen_test_layout_dvb_mpeg_ts() {
12717 assert_eq!(
12718 ::std::mem::size_of::<dvb_mpeg_ts>(),
12719 4usize,
12720 concat!("Size of: ", stringify!(dvb_mpeg_ts))
12721 );
12722 assert_eq!(
12723 ::std::mem::align_of::<dvb_mpeg_ts>(),
12724 1usize,
12725 concat!("Alignment of ", stringify!(dvb_mpeg_ts))
12726 );
12727 assert_eq!(
12728 unsafe { &(*(::std::ptr::null::<dvb_mpeg_ts>())).sync_byte as *const _ as usize },
12729 0usize,
12730 concat!(
12731 "Offset of field: ",
12732 stringify!(dvb_mpeg_ts),
12733 "::",
12734 stringify!(sync_byte)
12735 )
12736 );
12737 assert_eq!(
12738 unsafe { &(*(::std::ptr::null::<dvb_mpeg_ts>())).adaption as *const _ as usize },
12739 4usize,
12740 concat!(
12741 "Offset of field: ",
12742 stringify!(dvb_mpeg_ts),
12743 "::",
12744 stringify!(adaption)
12745 )
12746 );
12747}
12748extern "C" {
12749 pub fn dvb_mpeg_ts_init(
12750 parms: *mut dvb_v5_fe_parms,
12751 buf: *const u8,
12752 buflen: ssize_t,
12753 table: *mut u8,
12754 table_length: *mut ssize_t,
12755 ) -> ssize_t;
12756}
12757extern "C" {
12758 pub fn dvb_mpeg_ts_free(ts: *mut dvb_mpeg_ts);
12759}
12760extern "C" {
12761 pub fn dvb_mpeg_ts_print(parms: *mut dvb_v5_fe_parms, ts: *mut dvb_mpeg_ts);
12762}
12763#[repr(C, packed)]
12764#[derive(Copy, Clone)]
12765pub union dvb_table_nit_transport_header {
12766 pub bitfield: u16,
12767 pub __bindgen_anon_1: dvb_table_nit_transport_header__bindgen_ty_1,
12768 _bindgen_union_align: [u8; 2usize],
12769}
12770#[repr(C, packed)]
12771#[derive(Debug, Copy, Clone)]
12772pub struct dvb_table_nit_transport_header__bindgen_ty_1 {
12773 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize], u8>,
12774}
12775#[test]
12776fn bindgen_test_layout_dvb_table_nit_transport_header__bindgen_ty_1() {
12777 assert_eq!(
12778 ::std::mem::size_of::<dvb_table_nit_transport_header__bindgen_ty_1>(),
12779 2usize,
12780 concat!(
12781 "Size of: ",
12782 stringify!(dvb_table_nit_transport_header__bindgen_ty_1)
12783 )
12784 );
12785 assert_eq!(
12786 ::std::mem::align_of::<dvb_table_nit_transport_header__bindgen_ty_1>(),
12787 1usize,
12788 concat!(
12789 "Alignment of ",
12790 stringify!(dvb_table_nit_transport_header__bindgen_ty_1)
12791 )
12792 );
12793}
12794impl dvb_table_nit_transport_header__bindgen_ty_1 {
12795 #[inline]
12796 pub fn transport_length(&self) -> u16 {
12797 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 12u8) as u16) }
12798 }
12799 #[inline]
12800 pub fn set_transport_length(&mut self, val: u16) {
12801 unsafe {
12802 let val: u16 = ::std::mem::transmute(val);
12803 self._bitfield_1.set(0usize, 12u8, val as u64)
12804 }
12805 }
12806 #[inline]
12807 pub fn reserved(&self) -> u16 {
12808 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 4u8) as u16) }
12809 }
12810 #[inline]
12811 pub fn set_reserved(&mut self, val: u16) {
12812 unsafe {
12813 let val: u16 = ::std::mem::transmute(val);
12814 self._bitfield_1.set(12usize, 4u8, val as u64)
12815 }
12816 }
12817 #[inline]
12818 pub fn new_bitfield_1(
12819 transport_length: u16,
12820 reserved: u16,
12821 ) -> __BindgenBitfieldUnit<[u8; 2usize], u8> {
12822 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize], u8> =
12823 Default::default();
12824 __bindgen_bitfield_unit.set(0usize, 12u8, {
12825 let transport_length: u16 = unsafe { ::std::mem::transmute(transport_length) };
12826 transport_length as u64
12827 });
12828 __bindgen_bitfield_unit.set(12usize, 4u8, {
12829 let reserved: u16 = unsafe { ::std::mem::transmute(reserved) };
12830 reserved as u64
12831 });
12832 __bindgen_bitfield_unit
12833 }
12834}
12835#[test]
12836fn bindgen_test_layout_dvb_table_nit_transport_header() {
12837 assert_eq!(
12838 ::std::mem::size_of::<dvb_table_nit_transport_header>(),
12839 2usize,
12840 concat!("Size of: ", stringify!(dvb_table_nit_transport_header))
12841 );
12842 assert_eq!(
12843 ::std::mem::align_of::<dvb_table_nit_transport_header>(),
12844 1usize,
12845 concat!("Alignment of ", stringify!(dvb_table_nit_transport_header))
12846 );
12847 assert_eq!(
12848 unsafe {
12849 &(*(::std::ptr::null::<dvb_table_nit_transport_header>())).bitfield as *const _ as usize
12850 },
12851 0usize,
12852 concat!(
12853 "Offset of field: ",
12854 stringify!(dvb_table_nit_transport_header),
12855 "::",
12856 stringify!(bitfield)
12857 )
12858 );
12859}
12860#[repr(C, packed)]
12861#[derive(Copy, Clone)]
12862pub struct dvb_table_nit_transport {
12863 pub transport_id: u16,
12864 pub network_id: u16,
12865 pub __bindgen_anon_1: dvb_table_nit_transport__bindgen_ty_1,
12866 pub descriptor: *mut dvb_desc,
12867 pub next: *mut dvb_table_nit_transport,
12868}
12869#[repr(C, packed)]
12870#[derive(Copy, Clone)]
12871pub union dvb_table_nit_transport__bindgen_ty_1 {
12872 pub bitfield: u16,
12873 pub __bindgen_anon_1: dvb_table_nit_transport__bindgen_ty_1__bindgen_ty_1,
12874 _bindgen_union_align: [u8; 2usize],
12875}
12876#[repr(C, packed)]
12877#[derive(Debug, Copy, Clone)]
12878pub struct dvb_table_nit_transport__bindgen_ty_1__bindgen_ty_1 {
12879 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize], u8>,
12880}
12881#[test]
12882fn bindgen_test_layout_dvb_table_nit_transport__bindgen_ty_1__bindgen_ty_1() {
12883 assert_eq!(
12884 ::std::mem::size_of::<dvb_table_nit_transport__bindgen_ty_1__bindgen_ty_1>(),
12885 2usize,
12886 concat!(
12887 "Size of: ",
12888 stringify!(dvb_table_nit_transport__bindgen_ty_1__bindgen_ty_1)
12889 )
12890 );
12891 assert_eq!(
12892 ::std::mem::align_of::<dvb_table_nit_transport__bindgen_ty_1__bindgen_ty_1>(),
12893 1usize,
12894 concat!(
12895 "Alignment of ",
12896 stringify!(dvb_table_nit_transport__bindgen_ty_1__bindgen_ty_1)
12897 )
12898 );
12899}
12900impl dvb_table_nit_transport__bindgen_ty_1__bindgen_ty_1 {
12901 #[inline]
12902 pub fn desc_length(&self) -> u16 {
12903 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 12u8) as u16) }
12904 }
12905 #[inline]
12906 pub fn set_desc_length(&mut self, val: u16) {
12907 unsafe {
12908 let val: u16 = ::std::mem::transmute(val);
12909 self._bitfield_1.set(0usize, 12u8, val as u64)
12910 }
12911 }
12912 #[inline]
12913 pub fn reserved(&self) -> u16 {
12914 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 4u8) as u16) }
12915 }
12916 #[inline]
12917 pub fn set_reserved(&mut self, val: u16) {
12918 unsafe {
12919 let val: u16 = ::std::mem::transmute(val);
12920 self._bitfield_1.set(12usize, 4u8, val as u64)
12921 }
12922 }
12923 #[inline]
12924 pub fn new_bitfield_1(
12925 desc_length: u16,
12926 reserved: u16,
12927 ) -> __BindgenBitfieldUnit<[u8; 2usize], u8> {
12928 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize], u8> =
12929 Default::default();
12930 __bindgen_bitfield_unit.set(0usize, 12u8, {
12931 let desc_length: u16 = unsafe { ::std::mem::transmute(desc_length) };
12932 desc_length as u64
12933 });
12934 __bindgen_bitfield_unit.set(12usize, 4u8, {
12935 let reserved: u16 = unsafe { ::std::mem::transmute(reserved) };
12936 reserved as u64
12937 });
12938 __bindgen_bitfield_unit
12939 }
12940}
12941#[test]
12942fn bindgen_test_layout_dvb_table_nit_transport__bindgen_ty_1() {
12943 assert_eq!(
12944 ::std::mem::size_of::<dvb_table_nit_transport__bindgen_ty_1>(),
12945 2usize,
12946 concat!(
12947 "Size of: ",
12948 stringify!(dvb_table_nit_transport__bindgen_ty_1)
12949 )
12950 );
12951 assert_eq!(
12952 ::std::mem::align_of::<dvb_table_nit_transport__bindgen_ty_1>(),
12953 1usize,
12954 concat!(
12955 "Alignment of ",
12956 stringify!(dvb_table_nit_transport__bindgen_ty_1)
12957 )
12958 );
12959 assert_eq!(
12960 unsafe {
12961 &(*(::std::ptr::null::<dvb_table_nit_transport__bindgen_ty_1>())).bitfield as *const _
12962 as usize
12963 },
12964 0usize,
12965 concat!(
12966 "Offset of field: ",
12967 stringify!(dvb_table_nit_transport__bindgen_ty_1),
12968 "::",
12969 stringify!(bitfield)
12970 )
12971 );
12972}
12973#[test]
12974fn bindgen_test_layout_dvb_table_nit_transport() {
12975 assert_eq!(
12976 ::std::mem::size_of::<dvb_table_nit_transport>(),
12977 22usize,
12978 concat!("Size of: ", stringify!(dvb_table_nit_transport))
12979 );
12980 assert_eq!(
12981 ::std::mem::align_of::<dvb_table_nit_transport>(),
12982 1usize,
12983 concat!("Alignment of ", stringify!(dvb_table_nit_transport))
12984 );
12985 assert_eq!(
12986 unsafe {
12987 &(*(::std::ptr::null::<dvb_table_nit_transport>())).transport_id as *const _ as usize
12988 },
12989 0usize,
12990 concat!(
12991 "Offset of field: ",
12992 stringify!(dvb_table_nit_transport),
12993 "::",
12994 stringify!(transport_id)
12995 )
12996 );
12997 assert_eq!(
12998 unsafe {
12999 &(*(::std::ptr::null::<dvb_table_nit_transport>())).network_id as *const _ as usize
13000 },
13001 2usize,
13002 concat!(
13003 "Offset of field: ",
13004 stringify!(dvb_table_nit_transport),
13005 "::",
13006 stringify!(network_id)
13007 )
13008 );
13009 assert_eq!(
13010 unsafe {
13011 &(*(::std::ptr::null::<dvb_table_nit_transport>())).descriptor as *const _ as usize
13012 },
13013 6usize,
13014 concat!(
13015 "Offset of field: ",
13016 stringify!(dvb_table_nit_transport),
13017 "::",
13018 stringify!(descriptor)
13019 )
13020 );
13021 assert_eq!(
13022 unsafe { &(*(::std::ptr::null::<dvb_table_nit_transport>())).next as *const _ as usize },
13023 14usize,
13024 concat!(
13025 "Offset of field: ",
13026 stringify!(dvb_table_nit_transport),
13027 "::",
13028 stringify!(next)
13029 )
13030 );
13031}
13032#[repr(C, packed)]
13033#[derive(Copy, Clone)]
13034pub struct dvb_table_nit {
13035 pub header: dvb_table_header,
13036 pub __bindgen_anon_1: dvb_table_nit__bindgen_ty_1,
13037 pub descriptor: *mut dvb_desc,
13038 pub transport: *mut dvb_table_nit_transport,
13039}
13040#[repr(C, packed)]
13041#[derive(Copy, Clone)]
13042pub union dvb_table_nit__bindgen_ty_1 {
13043 pub bitfield: u16,
13044 pub __bindgen_anon_1: dvb_table_nit__bindgen_ty_1__bindgen_ty_1,
13045 _bindgen_union_align: [u8; 2usize],
13046}
13047#[repr(C, packed)]
13048#[derive(Debug, Copy, Clone)]
13049pub struct dvb_table_nit__bindgen_ty_1__bindgen_ty_1 {
13050 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize], u8>,
13051}
13052#[test]
13053fn bindgen_test_layout_dvb_table_nit__bindgen_ty_1__bindgen_ty_1() {
13054 assert_eq!(
13055 ::std::mem::size_of::<dvb_table_nit__bindgen_ty_1__bindgen_ty_1>(),
13056 2usize,
13057 concat!(
13058 "Size of: ",
13059 stringify!(dvb_table_nit__bindgen_ty_1__bindgen_ty_1)
13060 )
13061 );
13062 assert_eq!(
13063 ::std::mem::align_of::<dvb_table_nit__bindgen_ty_1__bindgen_ty_1>(),
13064 1usize,
13065 concat!(
13066 "Alignment of ",
13067 stringify!(dvb_table_nit__bindgen_ty_1__bindgen_ty_1)
13068 )
13069 );
13070}
13071impl dvb_table_nit__bindgen_ty_1__bindgen_ty_1 {
13072 #[inline]
13073 pub fn desc_length(&self) -> u16 {
13074 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 12u8) as u16) }
13075 }
13076 #[inline]
13077 pub fn set_desc_length(&mut self, val: u16) {
13078 unsafe {
13079 let val: u16 = ::std::mem::transmute(val);
13080 self._bitfield_1.set(0usize, 12u8, val as u64)
13081 }
13082 }
13083 #[inline]
13084 pub fn reserved(&self) -> u16 {
13085 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 4u8) as u16) }
13086 }
13087 #[inline]
13088 pub fn set_reserved(&mut self, val: u16) {
13089 unsafe {
13090 let val: u16 = ::std::mem::transmute(val);
13091 self._bitfield_1.set(12usize, 4u8, val as u64)
13092 }
13093 }
13094 #[inline]
13095 pub fn new_bitfield_1(
13096 desc_length: u16,
13097 reserved: u16,
13098 ) -> __BindgenBitfieldUnit<[u8; 2usize], u8> {
13099 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize], u8> =
13100 Default::default();
13101 __bindgen_bitfield_unit.set(0usize, 12u8, {
13102 let desc_length: u16 = unsafe { ::std::mem::transmute(desc_length) };
13103 desc_length as u64
13104 });
13105 __bindgen_bitfield_unit.set(12usize, 4u8, {
13106 let reserved: u16 = unsafe { ::std::mem::transmute(reserved) };
13107 reserved as u64
13108 });
13109 __bindgen_bitfield_unit
13110 }
13111}
13112#[test]
13113fn bindgen_test_layout_dvb_table_nit__bindgen_ty_1() {
13114 assert_eq!(
13115 ::std::mem::size_of::<dvb_table_nit__bindgen_ty_1>(),
13116 2usize,
13117 concat!("Size of: ", stringify!(dvb_table_nit__bindgen_ty_1))
13118 );
13119 assert_eq!(
13120 ::std::mem::align_of::<dvb_table_nit__bindgen_ty_1>(),
13121 1usize,
13122 concat!("Alignment of ", stringify!(dvb_table_nit__bindgen_ty_1))
13123 );
13124 assert_eq!(
13125 unsafe {
13126 &(*(::std::ptr::null::<dvb_table_nit__bindgen_ty_1>())).bitfield as *const _ as usize
13127 },
13128 0usize,
13129 concat!(
13130 "Offset of field: ",
13131 stringify!(dvb_table_nit__bindgen_ty_1),
13132 "::",
13133 stringify!(bitfield)
13134 )
13135 );
13136}
13137#[test]
13138fn bindgen_test_layout_dvb_table_nit() {
13139 assert_eq!(
13140 ::std::mem::size_of::<dvb_table_nit>(),
13141 26usize,
13142 concat!("Size of: ", stringify!(dvb_table_nit))
13143 );
13144 assert_eq!(
13145 ::std::mem::align_of::<dvb_table_nit>(),
13146 1usize,
13147 concat!("Alignment of ", stringify!(dvb_table_nit))
13148 );
13149 assert_eq!(
13150 unsafe { &(*(::std::ptr::null::<dvb_table_nit>())).header as *const _ as usize },
13151 0usize,
13152 concat!(
13153 "Offset of field: ",
13154 stringify!(dvb_table_nit),
13155 "::",
13156 stringify!(header)
13157 )
13158 );
13159 assert_eq!(
13160 unsafe { &(*(::std::ptr::null::<dvb_table_nit>())).descriptor as *const _ as usize },
13161 10usize,
13162 concat!(
13163 "Offset of field: ",
13164 stringify!(dvb_table_nit),
13165 "::",
13166 stringify!(descriptor)
13167 )
13168 );
13169 assert_eq!(
13170 unsafe { &(*(::std::ptr::null::<dvb_table_nit>())).transport as *const _ as usize },
13171 18usize,
13172 concat!(
13173 "Offset of field: ",
13174 stringify!(dvb_table_nit),
13175 "::",
13176 stringify!(transport)
13177 )
13178 );
13179}
13180pub type nit_handler_callback_t = ::std::option::Option<
13181 unsafe extern "C" fn(
13182 nit: *mut dvb_table_nit,
13183 desc: *mut dvb_desc,
13184 priv_: *mut ::std::os::raw::c_void,
13185 ),
13186>;
13187pub type nit_tran_handler_callback_t = ::std::option::Option<
13188 unsafe extern "C" fn(
13189 nit: *mut dvb_table_nit,
13190 tran: *mut dvb_table_nit_transport,
13191 desc: *mut dvb_desc,
13192 priv_: *mut ::std::os::raw::c_void,
13193 ),
13194>;
13195extern "C" {
13196 pub fn dvb_table_nit_init(
13197 parms: *mut dvb_v5_fe_parms,
13198 buf: *const u8,
13199 buflen: ssize_t,
13200 table: *mut *mut dvb_table_nit,
13201 ) -> ssize_t;
13202}
13203extern "C" {
13204 pub fn dvb_table_nit_free(table: *mut dvb_table_nit);
13205}
13206extern "C" {
13207 pub fn dvb_table_nit_print(parms: *mut dvb_v5_fe_parms, table: *mut dvb_table_nit);
13208}
13209extern "C" {
13210 pub fn dvb_table_nit_descriptor_handler(
13211 parms: *mut dvb_v5_fe_parms,
13212 table: *mut dvb_table_nit,
13213 descriptor: descriptors,
13214 call_nit: nit_handler_callback_t,
13215 call_tran: nit_tran_handler_callback_t,
13216 priv_: *mut ::std::os::raw::c_void,
13217 );
13218}
13219#[repr(C, packed)]
13220#[derive(Copy, Clone)]
13221pub struct dvb_table_pat_program {
13222 pub service_id: u16,
13223 pub __bindgen_anon_1: dvb_table_pat_program__bindgen_ty_1,
13224 pub next: *mut dvb_table_pat_program,
13225}
13226#[repr(C, packed)]
13227#[derive(Copy, Clone)]
13228pub union dvb_table_pat_program__bindgen_ty_1 {
13229 pub bitfield: u16,
13230 pub __bindgen_anon_1: dvb_table_pat_program__bindgen_ty_1__bindgen_ty_1,
13231 _bindgen_union_align: [u8; 2usize],
13232}
13233#[repr(C, packed)]
13234#[derive(Debug, Copy, Clone)]
13235pub struct dvb_table_pat_program__bindgen_ty_1__bindgen_ty_1 {
13236 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize], u8>,
13237}
13238#[test]
13239fn bindgen_test_layout_dvb_table_pat_program__bindgen_ty_1__bindgen_ty_1() {
13240 assert_eq!(
13241 ::std::mem::size_of::<dvb_table_pat_program__bindgen_ty_1__bindgen_ty_1>(),
13242 2usize,
13243 concat!(
13244 "Size of: ",
13245 stringify!(dvb_table_pat_program__bindgen_ty_1__bindgen_ty_1)
13246 )
13247 );
13248 assert_eq!(
13249 ::std::mem::align_of::<dvb_table_pat_program__bindgen_ty_1__bindgen_ty_1>(),
13250 1usize,
13251 concat!(
13252 "Alignment of ",
13253 stringify!(dvb_table_pat_program__bindgen_ty_1__bindgen_ty_1)
13254 )
13255 );
13256}
13257impl dvb_table_pat_program__bindgen_ty_1__bindgen_ty_1 {
13258 #[inline]
13259 pub fn pid(&self) -> u16 {
13260 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 13u8) as u16) }
13261 }
13262 #[inline]
13263 pub fn set_pid(&mut self, val: u16) {
13264 unsafe {
13265 let val: u16 = ::std::mem::transmute(val);
13266 self._bitfield_1.set(0usize, 13u8, val as u64)
13267 }
13268 }
13269 #[inline]
13270 pub fn reserved(&self) -> u8 {
13271 unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 3u8) as u8) }
13272 }
13273 #[inline]
13274 pub fn set_reserved(&mut self, val: u8) {
13275 unsafe {
13276 let val: u8 = ::std::mem::transmute(val);
13277 self._bitfield_1.set(13usize, 3u8, val as u64)
13278 }
13279 }
13280 #[inline]
13281 pub fn new_bitfield_1(pid: u16, reserved: u8) -> __BindgenBitfieldUnit<[u8; 2usize], u8> {
13282 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize], u8> =
13283 Default::default();
13284 __bindgen_bitfield_unit.set(0usize, 13u8, {
13285 let pid: u16 = unsafe { ::std::mem::transmute(pid) };
13286 pid as u64
13287 });
13288 __bindgen_bitfield_unit.set(13usize, 3u8, {
13289 let reserved: u8 = unsafe { ::std::mem::transmute(reserved) };
13290 reserved as u64
13291 });
13292 __bindgen_bitfield_unit
13293 }
13294}
13295#[test]
13296fn bindgen_test_layout_dvb_table_pat_program__bindgen_ty_1() {
13297 assert_eq!(
13298 ::std::mem::size_of::<dvb_table_pat_program__bindgen_ty_1>(),
13299 2usize,
13300 concat!("Size of: ", stringify!(dvb_table_pat_program__bindgen_ty_1))
13301 );
13302 assert_eq!(
13303 ::std::mem::align_of::<dvb_table_pat_program__bindgen_ty_1>(),
13304 1usize,
13305 concat!(
13306 "Alignment of ",
13307 stringify!(dvb_table_pat_program__bindgen_ty_1)
13308 )
13309 );
13310 assert_eq!(
13311 unsafe {
13312 &(*(::std::ptr::null::<dvb_table_pat_program__bindgen_ty_1>())).bitfield as *const _
13313 as usize
13314 },
13315 0usize,
13316 concat!(
13317 "Offset of field: ",
13318 stringify!(dvb_table_pat_program__bindgen_ty_1),
13319 "::",
13320 stringify!(bitfield)
13321 )
13322 );
13323}
13324#[test]
13325fn bindgen_test_layout_dvb_table_pat_program() {
13326 assert_eq!(
13327 ::std::mem::size_of::<dvb_table_pat_program>(),
13328 12usize,
13329 concat!("Size of: ", stringify!(dvb_table_pat_program))
13330 );
13331 assert_eq!(
13332 ::std::mem::align_of::<dvb_table_pat_program>(),
13333 1usize,
13334 concat!("Alignment of ", stringify!(dvb_table_pat_program))
13335 );
13336 assert_eq!(
13337 unsafe {
13338 &(*(::std::ptr::null::<dvb_table_pat_program>())).service_id as *const _ as usize
13339 },
13340 0usize,
13341 concat!(
13342 "Offset of field: ",
13343 stringify!(dvb_table_pat_program),
13344 "::",
13345 stringify!(service_id)
13346 )
13347 );
13348 assert_eq!(
13349 unsafe { &(*(::std::ptr::null::<dvb_table_pat_program>())).next as *const _ as usize },
13350 4usize,
13351 concat!(
13352 "Offset of field: ",
13353 stringify!(dvb_table_pat_program),
13354 "::",
13355 stringify!(next)
13356 )
13357 );
13358}
13359#[repr(C, packed)]
13360#[derive(Copy, Clone)]
13361pub struct dvb_table_pat {
13362 pub header: dvb_table_header,
13363 pub programs: u16,
13364 pub program: *mut dvb_table_pat_program,
13365}
13366#[test]
13367fn bindgen_test_layout_dvb_table_pat() {
13368 assert_eq!(
13369 ::std::mem::size_of::<dvb_table_pat>(),
13370 18usize,
13371 concat!("Size of: ", stringify!(dvb_table_pat))
13372 );
13373 assert_eq!(
13374 ::std::mem::align_of::<dvb_table_pat>(),
13375 1usize,
13376 concat!("Alignment of ", stringify!(dvb_table_pat))
13377 );
13378 assert_eq!(
13379 unsafe { &(*(::std::ptr::null::<dvb_table_pat>())).header as *const _ as usize },
13380 0usize,
13381 concat!(
13382 "Offset of field: ",
13383 stringify!(dvb_table_pat),
13384 "::",
13385 stringify!(header)
13386 )
13387 );
13388 assert_eq!(
13389 unsafe { &(*(::std::ptr::null::<dvb_table_pat>())).programs as *const _ as usize },
13390 8usize,
13391 concat!(
13392 "Offset of field: ",
13393 stringify!(dvb_table_pat),
13394 "::",
13395 stringify!(programs)
13396 )
13397 );
13398 assert_eq!(
13399 unsafe { &(*(::std::ptr::null::<dvb_table_pat>())).program as *const _ as usize },
13400 10usize,
13401 concat!(
13402 "Offset of field: ",
13403 stringify!(dvb_table_pat),
13404 "::",
13405 stringify!(program)
13406 )
13407 );
13408}
13409extern "C" {
13410 pub fn dvb_table_pat_init(
13411 parms: *mut dvb_v5_fe_parms,
13412 buf: *const u8,
13413 buflen: ssize_t,
13414 table: *mut *mut dvb_table_pat,
13415 ) -> ssize_t;
13416}
13417extern "C" {
13418 pub fn dvb_table_pat_free(table: *mut dvb_table_pat);
13419}
13420extern "C" {
13421 pub fn dvb_table_pat_print(parms: *mut dvb_v5_fe_parms, table: *mut dvb_table_pat);
13422}
13423#[repr(u32)]
13424#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
13425pub enum dvb_streams {
13426 stream_video = 1,
13427 stream_video_h262 = 2,
13428 stream_audio = 3,
13429 stream_audio_13818_3 = 4,
13430 stream_private_sections = 5,
13431 stream_private_data = 6,
13432 stream_mheg = 7,
13433 stream_h222 = 8,
13434 stream_h222_1 = 9,
13435 stream_13818_6_A = 10,
13436 stream_13818_6_B = 11,
13437 stream_13818_6_C = 12,
13438 stream_13818_6_D = 13,
13439 stream_h222_aux = 14,
13440 stream_audio_adts = 15,
13441 stream_video_14496_2 = 16,
13442 stream_audio_latm = 17,
13443 stream_14496_1_pes = 18,
13444 stream_14496_1_iso = 19,
13445 stream_download = 20,
13446 stream_video_h264 = 27,
13447 stream_audio_14496_3 = 28,
13448 stream_video_hevc = 36,
13449 stream_video_cavs = 66,
13450 stream_video_moto = 128,
13451 stream_audio_a52 = 129,
13452 stream_scte_27 = 130,
13453 stream_audio_sdds = 132,
13454 stream_audio_dts_hdmv = 133,
13455 stream_audio_e_ac3 = 135,
13456 stream_audio_dts = 138,
13457 stream_audio_a52_vls = 145,
13458 stream_spu_vls = 146,
13459 stream_audio_sdds2 = 148,
13460}
13461extern "C" {
13462 pub static mut pmt_stream_name: [*const ::std::os::raw::c_char; 0usize];
13463}
13464#[repr(C, packed)]
13465#[derive(Copy, Clone)]
13466pub struct dvb_table_pmt_stream {
13467 pub type_: u8,
13468 pub __bindgen_anon_1: dvb_table_pmt_stream__bindgen_ty_1,
13469 pub __bindgen_anon_2: dvb_table_pmt_stream__bindgen_ty_2,
13470 pub descriptor: *mut dvb_desc,
13471 pub next: *mut dvb_table_pmt_stream,
13472}
13473#[repr(C, packed)]
13474#[derive(Copy, Clone)]
13475pub union dvb_table_pmt_stream__bindgen_ty_1 {
13476 pub bitfield: u16,
13477 pub __bindgen_anon_1: dvb_table_pmt_stream__bindgen_ty_1__bindgen_ty_1,
13478 _bindgen_union_align: [u8; 2usize],
13479}
13480#[repr(C, packed)]
13481#[derive(Debug, Copy, Clone)]
13482pub struct dvb_table_pmt_stream__bindgen_ty_1__bindgen_ty_1 {
13483 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize], u8>,
13484}
13485#[test]
13486fn bindgen_test_layout_dvb_table_pmt_stream__bindgen_ty_1__bindgen_ty_1() {
13487 assert_eq!(
13488 ::std::mem::size_of::<dvb_table_pmt_stream__bindgen_ty_1__bindgen_ty_1>(),
13489 2usize,
13490 concat!(
13491 "Size of: ",
13492 stringify!(dvb_table_pmt_stream__bindgen_ty_1__bindgen_ty_1)
13493 )
13494 );
13495 assert_eq!(
13496 ::std::mem::align_of::<dvb_table_pmt_stream__bindgen_ty_1__bindgen_ty_1>(),
13497 1usize,
13498 concat!(
13499 "Alignment of ",
13500 stringify!(dvb_table_pmt_stream__bindgen_ty_1__bindgen_ty_1)
13501 )
13502 );
13503}
13504impl dvb_table_pmt_stream__bindgen_ty_1__bindgen_ty_1 {
13505 #[inline]
13506 pub fn elementary_pid(&self) -> u16 {
13507 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 13u8) as u16) }
13508 }
13509 #[inline]
13510 pub fn set_elementary_pid(&mut self, val: u16) {
13511 unsafe {
13512 let val: u16 = ::std::mem::transmute(val);
13513 self._bitfield_1.set(0usize, 13u8, val as u64)
13514 }
13515 }
13516 #[inline]
13517 pub fn reserved(&self) -> u16 {
13518 unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 3u8) as u16) }
13519 }
13520 #[inline]
13521 pub fn set_reserved(&mut self, val: u16) {
13522 unsafe {
13523 let val: u16 = ::std::mem::transmute(val);
13524 self._bitfield_1.set(13usize, 3u8, val as u64)
13525 }
13526 }
13527 #[inline]
13528 pub fn new_bitfield_1(
13529 elementary_pid: u16,
13530 reserved: u16,
13531 ) -> __BindgenBitfieldUnit<[u8; 2usize], u8> {
13532 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize], u8> =
13533 Default::default();
13534 __bindgen_bitfield_unit.set(0usize, 13u8, {
13535 let elementary_pid: u16 = unsafe { ::std::mem::transmute(elementary_pid) };
13536 elementary_pid as u64
13537 });
13538 __bindgen_bitfield_unit.set(13usize, 3u8, {
13539 let reserved: u16 = unsafe { ::std::mem::transmute(reserved) };
13540 reserved as u64
13541 });
13542 __bindgen_bitfield_unit
13543 }
13544}
13545#[test]
13546fn bindgen_test_layout_dvb_table_pmt_stream__bindgen_ty_1() {
13547 assert_eq!(
13548 ::std::mem::size_of::<dvb_table_pmt_stream__bindgen_ty_1>(),
13549 2usize,
13550 concat!("Size of: ", stringify!(dvb_table_pmt_stream__bindgen_ty_1))
13551 );
13552 assert_eq!(
13553 ::std::mem::align_of::<dvb_table_pmt_stream__bindgen_ty_1>(),
13554 1usize,
13555 concat!(
13556 "Alignment of ",
13557 stringify!(dvb_table_pmt_stream__bindgen_ty_1)
13558 )
13559 );
13560 assert_eq!(
13561 unsafe {
13562 &(*(::std::ptr::null::<dvb_table_pmt_stream__bindgen_ty_1>())).bitfield as *const _
13563 as usize
13564 },
13565 0usize,
13566 concat!(
13567 "Offset of field: ",
13568 stringify!(dvb_table_pmt_stream__bindgen_ty_1),
13569 "::",
13570 stringify!(bitfield)
13571 )
13572 );
13573}
13574#[repr(C, packed)]
13575#[derive(Copy, Clone)]
13576pub union dvb_table_pmt_stream__bindgen_ty_2 {
13577 pub bitfield2: u16,
13578 pub __bindgen_anon_1: dvb_table_pmt_stream__bindgen_ty_2__bindgen_ty_1,
13579 _bindgen_union_align: [u8; 2usize],
13580}
13581#[repr(C, packed)]
13582#[derive(Debug, Copy, Clone)]
13583pub struct dvb_table_pmt_stream__bindgen_ty_2__bindgen_ty_1 {
13584 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize], u8>,
13585}
13586#[test]
13587fn bindgen_test_layout_dvb_table_pmt_stream__bindgen_ty_2__bindgen_ty_1() {
13588 assert_eq!(
13589 ::std::mem::size_of::<dvb_table_pmt_stream__bindgen_ty_2__bindgen_ty_1>(),
13590 2usize,
13591 concat!(
13592 "Size of: ",
13593 stringify!(dvb_table_pmt_stream__bindgen_ty_2__bindgen_ty_1)
13594 )
13595 );
13596 assert_eq!(
13597 ::std::mem::align_of::<dvb_table_pmt_stream__bindgen_ty_2__bindgen_ty_1>(),
13598 1usize,
13599 concat!(
13600 "Alignment of ",
13601 stringify!(dvb_table_pmt_stream__bindgen_ty_2__bindgen_ty_1)
13602 )
13603 );
13604}
13605impl dvb_table_pmt_stream__bindgen_ty_2__bindgen_ty_1 {
13606 #[inline]
13607 pub fn desc_length(&self) -> u16 {
13608 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 10u8) as u16) }
13609 }
13610 #[inline]
13611 pub fn set_desc_length(&mut self, val: u16) {
13612 unsafe {
13613 let val: u16 = ::std::mem::transmute(val);
13614 self._bitfield_1.set(0usize, 10u8, val as u64)
13615 }
13616 }
13617 #[inline]
13618 pub fn zero(&self) -> u16 {
13619 unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 2u8) as u16) }
13620 }
13621 #[inline]
13622 pub fn set_zero(&mut self, val: u16) {
13623 unsafe {
13624 let val: u16 = ::std::mem::transmute(val);
13625 self._bitfield_1.set(10usize, 2u8, val as u64)
13626 }
13627 }
13628 #[inline]
13629 pub fn reserved2(&self) -> u16 {
13630 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 4u8) as u16) }
13631 }
13632 #[inline]
13633 pub fn set_reserved2(&mut self, val: u16) {
13634 unsafe {
13635 let val: u16 = ::std::mem::transmute(val);
13636 self._bitfield_1.set(12usize, 4u8, val as u64)
13637 }
13638 }
13639 #[inline]
13640 pub fn new_bitfield_1(
13641 desc_length: u16,
13642 zero: u16,
13643 reserved2: u16,
13644 ) -> __BindgenBitfieldUnit<[u8; 2usize], u8> {
13645 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize], u8> =
13646 Default::default();
13647 __bindgen_bitfield_unit.set(0usize, 10u8, {
13648 let desc_length: u16 = unsafe { ::std::mem::transmute(desc_length) };
13649 desc_length as u64
13650 });
13651 __bindgen_bitfield_unit.set(10usize, 2u8, {
13652 let zero: u16 = unsafe { ::std::mem::transmute(zero) };
13653 zero as u64
13654 });
13655 __bindgen_bitfield_unit.set(12usize, 4u8, {
13656 let reserved2: u16 = unsafe { ::std::mem::transmute(reserved2) };
13657 reserved2 as u64
13658 });
13659 __bindgen_bitfield_unit
13660 }
13661}
13662#[test]
13663fn bindgen_test_layout_dvb_table_pmt_stream__bindgen_ty_2() {
13664 assert_eq!(
13665 ::std::mem::size_of::<dvb_table_pmt_stream__bindgen_ty_2>(),
13666 2usize,
13667 concat!("Size of: ", stringify!(dvb_table_pmt_stream__bindgen_ty_2))
13668 );
13669 assert_eq!(
13670 ::std::mem::align_of::<dvb_table_pmt_stream__bindgen_ty_2>(),
13671 1usize,
13672 concat!(
13673 "Alignment of ",
13674 stringify!(dvb_table_pmt_stream__bindgen_ty_2)
13675 )
13676 );
13677 assert_eq!(
13678 unsafe {
13679 &(*(::std::ptr::null::<dvb_table_pmt_stream__bindgen_ty_2>())).bitfield2 as *const _
13680 as usize
13681 },
13682 0usize,
13683 concat!(
13684 "Offset of field: ",
13685 stringify!(dvb_table_pmt_stream__bindgen_ty_2),
13686 "::",
13687 stringify!(bitfield2)
13688 )
13689 );
13690}
13691#[test]
13692fn bindgen_test_layout_dvb_table_pmt_stream() {
13693 assert_eq!(
13694 ::std::mem::size_of::<dvb_table_pmt_stream>(),
13695 21usize,
13696 concat!("Size of: ", stringify!(dvb_table_pmt_stream))
13697 );
13698 assert_eq!(
13699 ::std::mem::align_of::<dvb_table_pmt_stream>(),
13700 1usize,
13701 concat!("Alignment of ", stringify!(dvb_table_pmt_stream))
13702 );
13703 assert_eq!(
13704 unsafe { &(*(::std::ptr::null::<dvb_table_pmt_stream>())).type_ as *const _ as usize },
13705 0usize,
13706 concat!(
13707 "Offset of field: ",
13708 stringify!(dvb_table_pmt_stream),
13709 "::",
13710 stringify!(type_)
13711 )
13712 );
13713 assert_eq!(
13714 unsafe { &(*(::std::ptr::null::<dvb_table_pmt_stream>())).descriptor as *const _ as usize },
13715 5usize,
13716 concat!(
13717 "Offset of field: ",
13718 stringify!(dvb_table_pmt_stream),
13719 "::",
13720 stringify!(descriptor)
13721 )
13722 );
13723 assert_eq!(
13724 unsafe { &(*(::std::ptr::null::<dvb_table_pmt_stream>())).next as *const _ as usize },
13725 13usize,
13726 concat!(
13727 "Offset of field: ",
13728 stringify!(dvb_table_pmt_stream),
13729 "::",
13730 stringify!(next)
13731 )
13732 );
13733}
13734#[repr(C, packed)]
13735#[derive(Copy, Clone)]
13736pub struct dvb_table_pmt {
13737 pub header: dvb_table_header,
13738 pub __bindgen_anon_1: dvb_table_pmt__bindgen_ty_1,
13739 pub __bindgen_anon_2: dvb_table_pmt__bindgen_ty_2,
13740 pub descriptor: *mut dvb_desc,
13741 pub stream: *mut dvb_table_pmt_stream,
13742}
13743#[repr(C, packed)]
13744#[derive(Copy, Clone)]
13745pub union dvb_table_pmt__bindgen_ty_1 {
13746 pub bitfield: u16,
13747 pub __bindgen_anon_1: dvb_table_pmt__bindgen_ty_1__bindgen_ty_1,
13748 _bindgen_union_align: [u8; 2usize],
13749}
13750#[repr(C, packed)]
13751#[derive(Debug, Copy, Clone)]
13752pub struct dvb_table_pmt__bindgen_ty_1__bindgen_ty_1 {
13753 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize], u8>,
13754}
13755#[test]
13756fn bindgen_test_layout_dvb_table_pmt__bindgen_ty_1__bindgen_ty_1() {
13757 assert_eq!(
13758 ::std::mem::size_of::<dvb_table_pmt__bindgen_ty_1__bindgen_ty_1>(),
13759 2usize,
13760 concat!(
13761 "Size of: ",
13762 stringify!(dvb_table_pmt__bindgen_ty_1__bindgen_ty_1)
13763 )
13764 );
13765 assert_eq!(
13766 ::std::mem::align_of::<dvb_table_pmt__bindgen_ty_1__bindgen_ty_1>(),
13767 1usize,
13768 concat!(
13769 "Alignment of ",
13770 stringify!(dvb_table_pmt__bindgen_ty_1__bindgen_ty_1)
13771 )
13772 );
13773}
13774impl dvb_table_pmt__bindgen_ty_1__bindgen_ty_1 {
13775 #[inline]
13776 pub fn pcr_pid(&self) -> u16 {
13777 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 13u8) as u16) }
13778 }
13779 #[inline]
13780 pub fn set_pcr_pid(&mut self, val: u16) {
13781 unsafe {
13782 let val: u16 = ::std::mem::transmute(val);
13783 self._bitfield_1.set(0usize, 13u8, val as u64)
13784 }
13785 }
13786 #[inline]
13787 pub fn reserved2(&self) -> u16 {
13788 unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 3u8) as u16) }
13789 }
13790 #[inline]
13791 pub fn set_reserved2(&mut self, val: u16) {
13792 unsafe {
13793 let val: u16 = ::std::mem::transmute(val);
13794 self._bitfield_1.set(13usize, 3u8, val as u64)
13795 }
13796 }
13797 #[inline]
13798 pub fn new_bitfield_1(pcr_pid: u16, reserved2: u16) -> __BindgenBitfieldUnit<[u8; 2usize], u8> {
13799 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize], u8> =
13800 Default::default();
13801 __bindgen_bitfield_unit.set(0usize, 13u8, {
13802 let pcr_pid: u16 = unsafe { ::std::mem::transmute(pcr_pid) };
13803 pcr_pid as u64
13804 });
13805 __bindgen_bitfield_unit.set(13usize, 3u8, {
13806 let reserved2: u16 = unsafe { ::std::mem::transmute(reserved2) };
13807 reserved2 as u64
13808 });
13809 __bindgen_bitfield_unit
13810 }
13811}
13812#[test]
13813fn bindgen_test_layout_dvb_table_pmt__bindgen_ty_1() {
13814 assert_eq!(
13815 ::std::mem::size_of::<dvb_table_pmt__bindgen_ty_1>(),
13816 2usize,
13817 concat!("Size of: ", stringify!(dvb_table_pmt__bindgen_ty_1))
13818 );
13819 assert_eq!(
13820 ::std::mem::align_of::<dvb_table_pmt__bindgen_ty_1>(),
13821 1usize,
13822 concat!("Alignment of ", stringify!(dvb_table_pmt__bindgen_ty_1))
13823 );
13824 assert_eq!(
13825 unsafe {
13826 &(*(::std::ptr::null::<dvb_table_pmt__bindgen_ty_1>())).bitfield as *const _ as usize
13827 },
13828 0usize,
13829 concat!(
13830 "Offset of field: ",
13831 stringify!(dvb_table_pmt__bindgen_ty_1),
13832 "::",
13833 stringify!(bitfield)
13834 )
13835 );
13836}
13837#[repr(C, packed)]
13838#[derive(Copy, Clone)]
13839pub union dvb_table_pmt__bindgen_ty_2 {
13840 pub bitfield2: u16,
13841 pub __bindgen_anon_1: dvb_table_pmt__bindgen_ty_2__bindgen_ty_1,
13842 _bindgen_union_align: [u8; 2usize],
13843}
13844#[repr(C, packed)]
13845#[derive(Debug, Copy, Clone)]
13846pub struct dvb_table_pmt__bindgen_ty_2__bindgen_ty_1 {
13847 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize], u8>,
13848}
13849#[test]
13850fn bindgen_test_layout_dvb_table_pmt__bindgen_ty_2__bindgen_ty_1() {
13851 assert_eq!(
13852 ::std::mem::size_of::<dvb_table_pmt__bindgen_ty_2__bindgen_ty_1>(),
13853 2usize,
13854 concat!(
13855 "Size of: ",
13856 stringify!(dvb_table_pmt__bindgen_ty_2__bindgen_ty_1)
13857 )
13858 );
13859 assert_eq!(
13860 ::std::mem::align_of::<dvb_table_pmt__bindgen_ty_2__bindgen_ty_1>(),
13861 1usize,
13862 concat!(
13863 "Alignment of ",
13864 stringify!(dvb_table_pmt__bindgen_ty_2__bindgen_ty_1)
13865 )
13866 );
13867}
13868impl dvb_table_pmt__bindgen_ty_2__bindgen_ty_1 {
13869 #[inline]
13870 pub fn desc_length(&self) -> u16 {
13871 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 10u8) as u16) }
13872 }
13873 #[inline]
13874 pub fn set_desc_length(&mut self, val: u16) {
13875 unsafe {
13876 let val: u16 = ::std::mem::transmute(val);
13877 self._bitfield_1.set(0usize, 10u8, val as u64)
13878 }
13879 }
13880 #[inline]
13881 pub fn zero3(&self) -> u16 {
13882 unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 2u8) as u16) }
13883 }
13884 #[inline]
13885 pub fn set_zero3(&mut self, val: u16) {
13886 unsafe {
13887 let val: u16 = ::std::mem::transmute(val);
13888 self._bitfield_1.set(10usize, 2u8, val as u64)
13889 }
13890 }
13891 #[inline]
13892 pub fn reserved3(&self) -> u16 {
13893 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 4u8) as u16) }
13894 }
13895 #[inline]
13896 pub fn set_reserved3(&mut self, val: u16) {
13897 unsafe {
13898 let val: u16 = ::std::mem::transmute(val);
13899 self._bitfield_1.set(12usize, 4u8, val as u64)
13900 }
13901 }
13902 #[inline]
13903 pub fn new_bitfield_1(
13904 desc_length: u16,
13905 zero3: u16,
13906 reserved3: u16,
13907 ) -> __BindgenBitfieldUnit<[u8; 2usize], u8> {
13908 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize], u8> =
13909 Default::default();
13910 __bindgen_bitfield_unit.set(0usize, 10u8, {
13911 let desc_length: u16 = unsafe { ::std::mem::transmute(desc_length) };
13912 desc_length as u64
13913 });
13914 __bindgen_bitfield_unit.set(10usize, 2u8, {
13915 let zero3: u16 = unsafe { ::std::mem::transmute(zero3) };
13916 zero3 as u64
13917 });
13918 __bindgen_bitfield_unit.set(12usize, 4u8, {
13919 let reserved3: u16 = unsafe { ::std::mem::transmute(reserved3) };
13920 reserved3 as u64
13921 });
13922 __bindgen_bitfield_unit
13923 }
13924}
13925#[test]
13926fn bindgen_test_layout_dvb_table_pmt__bindgen_ty_2() {
13927 assert_eq!(
13928 ::std::mem::size_of::<dvb_table_pmt__bindgen_ty_2>(),
13929 2usize,
13930 concat!("Size of: ", stringify!(dvb_table_pmt__bindgen_ty_2))
13931 );
13932 assert_eq!(
13933 ::std::mem::align_of::<dvb_table_pmt__bindgen_ty_2>(),
13934 1usize,
13935 concat!("Alignment of ", stringify!(dvb_table_pmt__bindgen_ty_2))
13936 );
13937 assert_eq!(
13938 unsafe {
13939 &(*(::std::ptr::null::<dvb_table_pmt__bindgen_ty_2>())).bitfield2 as *const _ as usize
13940 },
13941 0usize,
13942 concat!(
13943 "Offset of field: ",
13944 stringify!(dvb_table_pmt__bindgen_ty_2),
13945 "::",
13946 stringify!(bitfield2)
13947 )
13948 );
13949}
13950#[test]
13951fn bindgen_test_layout_dvb_table_pmt() {
13952 assert_eq!(
13953 ::std::mem::size_of::<dvb_table_pmt>(),
13954 28usize,
13955 concat!("Size of: ", stringify!(dvb_table_pmt))
13956 );
13957 assert_eq!(
13958 ::std::mem::align_of::<dvb_table_pmt>(),
13959 1usize,
13960 concat!("Alignment of ", stringify!(dvb_table_pmt))
13961 );
13962 assert_eq!(
13963 unsafe { &(*(::std::ptr::null::<dvb_table_pmt>())).header as *const _ as usize },
13964 0usize,
13965 concat!(
13966 "Offset of field: ",
13967 stringify!(dvb_table_pmt),
13968 "::",
13969 stringify!(header)
13970 )
13971 );
13972 assert_eq!(
13973 unsafe { &(*(::std::ptr::null::<dvb_table_pmt>())).descriptor as *const _ as usize },
13974 12usize,
13975 concat!(
13976 "Offset of field: ",
13977 stringify!(dvb_table_pmt),
13978 "::",
13979 stringify!(descriptor)
13980 )
13981 );
13982 assert_eq!(
13983 unsafe { &(*(::std::ptr::null::<dvb_table_pmt>())).stream as *const _ as usize },
13984 20usize,
13985 concat!(
13986 "Offset of field: ",
13987 stringify!(dvb_table_pmt),
13988 "::",
13989 stringify!(stream)
13990 )
13991 );
13992}
13993extern "C" {
13994 pub fn dvb_table_pmt_init(
13995 parms: *mut dvb_v5_fe_parms,
13996 buf: *const u8,
13997 buflen: ssize_t,
13998 table: *mut *mut dvb_table_pmt,
13999 ) -> ssize_t;
14000}
14001extern "C" {
14002 pub fn dvb_table_pmt_free(table: *mut dvb_table_pmt);
14003}
14004extern "C" {
14005 pub fn dvb_table_pmt_print(parms: *mut dvb_v5_fe_parms, table: *const dvb_table_pmt);
14006}
14007#[repr(C, packed)]
14008#[derive(Copy, Clone)]
14009pub struct dvb_table_sdt_service {
14010 pub service_id: u16,
14011 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize], u8>,
14012 pub __bindgen_anon_1: dvb_table_sdt_service__bindgen_ty_1,
14013 pub descriptor: *mut dvb_desc,
14014 pub next: *mut dvb_table_sdt_service,
14015}
14016#[repr(C, packed)]
14017#[derive(Copy, Clone)]
14018pub union dvb_table_sdt_service__bindgen_ty_1 {
14019 pub bitfield: u16,
14020 pub __bindgen_anon_1: dvb_table_sdt_service__bindgen_ty_1__bindgen_ty_1,
14021 _bindgen_union_align: [u8; 2usize],
14022}
14023#[repr(C, packed)]
14024#[derive(Debug, Copy, Clone)]
14025pub struct dvb_table_sdt_service__bindgen_ty_1__bindgen_ty_1 {
14026 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize], u8>,
14027}
14028#[test]
14029fn bindgen_test_layout_dvb_table_sdt_service__bindgen_ty_1__bindgen_ty_1() {
14030 assert_eq!(
14031 ::std::mem::size_of::<dvb_table_sdt_service__bindgen_ty_1__bindgen_ty_1>(),
14032 2usize,
14033 concat!(
14034 "Size of: ",
14035 stringify!(dvb_table_sdt_service__bindgen_ty_1__bindgen_ty_1)
14036 )
14037 );
14038 assert_eq!(
14039 ::std::mem::align_of::<dvb_table_sdt_service__bindgen_ty_1__bindgen_ty_1>(),
14040 1usize,
14041 concat!(
14042 "Alignment of ",
14043 stringify!(dvb_table_sdt_service__bindgen_ty_1__bindgen_ty_1)
14044 )
14045 );
14046}
14047impl dvb_table_sdt_service__bindgen_ty_1__bindgen_ty_1 {
14048 #[inline]
14049 pub fn desc_length(&self) -> u16 {
14050 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 12u8) as u16) }
14051 }
14052 #[inline]
14053 pub fn set_desc_length(&mut self, val: u16) {
14054 unsafe {
14055 let val: u16 = ::std::mem::transmute(val);
14056 self._bitfield_1.set(0usize, 12u8, val as u64)
14057 }
14058 }
14059 #[inline]
14060 pub fn free_CA_mode(&self) -> u16 {
14061 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u16) }
14062 }
14063 #[inline]
14064 pub fn set_free_CA_mode(&mut self, val: u16) {
14065 unsafe {
14066 let val: u16 = ::std::mem::transmute(val);
14067 self._bitfield_1.set(12usize, 1u8, val as u64)
14068 }
14069 }
14070 #[inline]
14071 pub fn running_status(&self) -> u16 {
14072 unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 3u8) as u16) }
14073 }
14074 #[inline]
14075 pub fn set_running_status(&mut self, val: u16) {
14076 unsafe {
14077 let val: u16 = ::std::mem::transmute(val);
14078 self._bitfield_1.set(13usize, 3u8, val as u64)
14079 }
14080 }
14081 #[inline]
14082 pub fn new_bitfield_1(
14083 desc_length: u16,
14084 free_CA_mode: u16,
14085 running_status: u16,
14086 ) -> __BindgenBitfieldUnit<[u8; 2usize], u8> {
14087 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize], u8> =
14088 Default::default();
14089 __bindgen_bitfield_unit.set(0usize, 12u8, {
14090 let desc_length: u16 = unsafe { ::std::mem::transmute(desc_length) };
14091 desc_length as u64
14092 });
14093 __bindgen_bitfield_unit.set(12usize, 1u8, {
14094 let free_CA_mode: u16 = unsafe { ::std::mem::transmute(free_CA_mode) };
14095 free_CA_mode as u64
14096 });
14097 __bindgen_bitfield_unit.set(13usize, 3u8, {
14098 let running_status: u16 = unsafe { ::std::mem::transmute(running_status) };
14099 running_status as u64
14100 });
14101 __bindgen_bitfield_unit
14102 }
14103}
14104#[test]
14105fn bindgen_test_layout_dvb_table_sdt_service__bindgen_ty_1() {
14106 assert_eq!(
14107 ::std::mem::size_of::<dvb_table_sdt_service__bindgen_ty_1>(),
14108 2usize,
14109 concat!("Size of: ", stringify!(dvb_table_sdt_service__bindgen_ty_1))
14110 );
14111 assert_eq!(
14112 ::std::mem::align_of::<dvb_table_sdt_service__bindgen_ty_1>(),
14113 1usize,
14114 concat!(
14115 "Alignment of ",
14116 stringify!(dvb_table_sdt_service__bindgen_ty_1)
14117 )
14118 );
14119 assert_eq!(
14120 unsafe {
14121 &(*(::std::ptr::null::<dvb_table_sdt_service__bindgen_ty_1>())).bitfield as *const _
14122 as usize
14123 },
14124 0usize,
14125 concat!(
14126 "Offset of field: ",
14127 stringify!(dvb_table_sdt_service__bindgen_ty_1),
14128 "::",
14129 stringify!(bitfield)
14130 )
14131 );
14132}
14133#[test]
14134fn bindgen_test_layout_dvb_table_sdt_service() {
14135 assert_eq!(
14136 ::std::mem::size_of::<dvb_table_sdt_service>(),
14137 21usize,
14138 concat!("Size of: ", stringify!(dvb_table_sdt_service))
14139 );
14140 assert_eq!(
14141 ::std::mem::align_of::<dvb_table_sdt_service>(),
14142 1usize,
14143 concat!("Alignment of ", stringify!(dvb_table_sdt_service))
14144 );
14145 assert_eq!(
14146 unsafe {
14147 &(*(::std::ptr::null::<dvb_table_sdt_service>())).service_id as *const _ as usize
14148 },
14149 0usize,
14150 concat!(
14151 "Offset of field: ",
14152 stringify!(dvb_table_sdt_service),
14153 "::",
14154 stringify!(service_id)
14155 )
14156 );
14157 assert_eq!(
14158 unsafe {
14159 &(*(::std::ptr::null::<dvb_table_sdt_service>())).descriptor as *const _ as usize
14160 },
14161 5usize,
14162 concat!(
14163 "Offset of field: ",
14164 stringify!(dvb_table_sdt_service),
14165 "::",
14166 stringify!(descriptor)
14167 )
14168 );
14169 assert_eq!(
14170 unsafe { &(*(::std::ptr::null::<dvb_table_sdt_service>())).next as *const _ as usize },
14171 13usize,
14172 concat!(
14173 "Offset of field: ",
14174 stringify!(dvb_table_sdt_service),
14175 "::",
14176 stringify!(next)
14177 )
14178 );
14179}
14180impl dvb_table_sdt_service {
14181 #[inline]
14182 pub fn EIT_present_following(&self) -> u8 {
14183 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
14184 }
14185 #[inline]
14186 pub fn set_EIT_present_following(&mut self, val: u8) {
14187 unsafe {
14188 let val: u8 = ::std::mem::transmute(val);
14189 self._bitfield_1.set(0usize, 1u8, val as u64)
14190 }
14191 }
14192 #[inline]
14193 pub fn EIT_schedule(&self) -> u8 {
14194 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
14195 }
14196 #[inline]
14197 pub fn set_EIT_schedule(&mut self, val: u8) {
14198 unsafe {
14199 let val: u8 = ::std::mem::transmute(val);
14200 self._bitfield_1.set(1usize, 1u8, val as u64)
14201 }
14202 }
14203 #[inline]
14204 pub fn reserved(&self) -> u8 {
14205 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 6u8) as u8) }
14206 }
14207 #[inline]
14208 pub fn set_reserved(&mut self, val: u8) {
14209 unsafe {
14210 let val: u8 = ::std::mem::transmute(val);
14211 self._bitfield_1.set(2usize, 6u8, val as u64)
14212 }
14213 }
14214 #[inline]
14215 pub fn new_bitfield_1(
14216 EIT_present_following: u8,
14217 EIT_schedule: u8,
14218 reserved: u8,
14219 ) -> __BindgenBitfieldUnit<[u8; 1usize], u8> {
14220 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize], u8> =
14221 Default::default();
14222 __bindgen_bitfield_unit.set(0usize, 1u8, {
14223 let EIT_present_following: u8 = unsafe { ::std::mem::transmute(EIT_present_following) };
14224 EIT_present_following as u64
14225 });
14226 __bindgen_bitfield_unit.set(1usize, 1u8, {
14227 let EIT_schedule: u8 = unsafe { ::std::mem::transmute(EIT_schedule) };
14228 EIT_schedule as u64
14229 });
14230 __bindgen_bitfield_unit.set(2usize, 6u8, {
14231 let reserved: u8 = unsafe { ::std::mem::transmute(reserved) };
14232 reserved as u64
14233 });
14234 __bindgen_bitfield_unit
14235 }
14236}
14237#[repr(C, packed)]
14238#[derive(Copy, Clone)]
14239pub struct dvb_table_sdt {
14240 pub header: dvb_table_header,
14241 pub network_id: u16,
14242 pub reserved: u8,
14243 pub service: *mut dvb_table_sdt_service,
14244}
14245#[test]
14246fn bindgen_test_layout_dvb_table_sdt() {
14247 assert_eq!(
14248 ::std::mem::size_of::<dvb_table_sdt>(),
14249 19usize,
14250 concat!("Size of: ", stringify!(dvb_table_sdt))
14251 );
14252 assert_eq!(
14253 ::std::mem::align_of::<dvb_table_sdt>(),
14254 1usize,
14255 concat!("Alignment of ", stringify!(dvb_table_sdt))
14256 );
14257 assert_eq!(
14258 unsafe { &(*(::std::ptr::null::<dvb_table_sdt>())).header as *const _ as usize },
14259 0usize,
14260 concat!(
14261 "Offset of field: ",
14262 stringify!(dvb_table_sdt),
14263 "::",
14264 stringify!(header)
14265 )
14266 );
14267 assert_eq!(
14268 unsafe { &(*(::std::ptr::null::<dvb_table_sdt>())).network_id as *const _ as usize },
14269 8usize,
14270 concat!(
14271 "Offset of field: ",
14272 stringify!(dvb_table_sdt),
14273 "::",
14274 stringify!(network_id)
14275 )
14276 );
14277 assert_eq!(
14278 unsafe { &(*(::std::ptr::null::<dvb_table_sdt>())).reserved as *const _ as usize },
14279 10usize,
14280 concat!(
14281 "Offset of field: ",
14282 stringify!(dvb_table_sdt),
14283 "::",
14284 stringify!(reserved)
14285 )
14286 );
14287 assert_eq!(
14288 unsafe { &(*(::std::ptr::null::<dvb_table_sdt>())).service as *const _ as usize },
14289 11usize,
14290 concat!(
14291 "Offset of field: ",
14292 stringify!(dvb_table_sdt),
14293 "::",
14294 stringify!(service)
14295 )
14296 );
14297}
14298extern "C" {
14299 pub fn dvb_table_sdt_init(
14300 parms: *mut dvb_v5_fe_parms,
14301 buf: *const u8,
14302 buflen: ssize_t,
14303 table: *mut *mut dvb_table_sdt,
14304 ) -> ssize_t;
14305}
14306extern "C" {
14307 pub fn dvb_table_sdt_free(table: *mut dvb_table_sdt);
14308}
14309extern "C" {
14310 pub fn dvb_table_sdt_print(parms: *mut dvb_v5_fe_parms, table: *mut dvb_table_sdt);
14311}
14312#[repr(C, packed)]
14313#[derive(Copy, Clone)]
14314pub struct atsc_table_vct_channel {
14315 pub __short_name: [u16; 7usize],
14316 pub __bindgen_anon_1: atsc_table_vct_channel__bindgen_ty_1,
14317 pub carrier_frequency: u32,
14318 pub channel_tsid: u16,
14319 pub program_number: u16,
14320 pub __bindgen_anon_2: atsc_table_vct_channel__bindgen_ty_2,
14321 pub source_id: u16,
14322 pub __bindgen_anon_3: atsc_table_vct_channel__bindgen_ty_3,
14323 pub descriptor: *mut dvb_desc,
14324 pub next: *mut atsc_table_vct_channel,
14325 pub short_name: [::std::os::raw::c_char; 32usize],
14326}
14327#[repr(C, packed)]
14328#[derive(Copy, Clone)]
14329pub union atsc_table_vct_channel__bindgen_ty_1 {
14330 pub bitfield1: u32,
14331 pub __bindgen_anon_1: atsc_table_vct_channel__bindgen_ty_1__bindgen_ty_1,
14332 _bindgen_union_align: [u8; 4usize],
14333}
14334#[repr(C, packed)]
14335#[derive(Debug, Copy, Clone)]
14336pub struct atsc_table_vct_channel__bindgen_ty_1__bindgen_ty_1 {
14337 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize], u8>,
14338}
14339#[test]
14340fn bindgen_test_layout_atsc_table_vct_channel__bindgen_ty_1__bindgen_ty_1() {
14341 assert_eq!(
14342 ::std::mem::size_of::<atsc_table_vct_channel__bindgen_ty_1__bindgen_ty_1>(),
14343 4usize,
14344 concat!(
14345 "Size of: ",
14346 stringify!(atsc_table_vct_channel__bindgen_ty_1__bindgen_ty_1)
14347 )
14348 );
14349 assert_eq!(
14350 ::std::mem::align_of::<atsc_table_vct_channel__bindgen_ty_1__bindgen_ty_1>(),
14351 1usize,
14352 concat!(
14353 "Alignment of ",
14354 stringify!(atsc_table_vct_channel__bindgen_ty_1__bindgen_ty_1)
14355 )
14356 );
14357}
14358impl atsc_table_vct_channel__bindgen_ty_1__bindgen_ty_1 {
14359 #[inline]
14360 pub fn modulation_mode(&self) -> u32 {
14361 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 8u8) as u32) }
14362 }
14363 #[inline]
14364 pub fn set_modulation_mode(&mut self, val: u32) {
14365 unsafe {
14366 let val: u32 = ::std::mem::transmute(val);
14367 self._bitfield_1.set(0usize, 8u8, val as u64)
14368 }
14369 }
14370 #[inline]
14371 pub fn minor_channel_number(&self) -> u32 {
14372 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 10u8) as u32) }
14373 }
14374 #[inline]
14375 pub fn set_minor_channel_number(&mut self, val: u32) {
14376 unsafe {
14377 let val: u32 = ::std::mem::transmute(val);
14378 self._bitfield_1.set(8usize, 10u8, val as u64)
14379 }
14380 }
14381 #[inline]
14382 pub fn major_channel_number(&self) -> u32 {
14383 unsafe { ::std::mem::transmute(self._bitfield_1.get(18usize, 10u8) as u32) }
14384 }
14385 #[inline]
14386 pub fn set_major_channel_number(&mut self, val: u32) {
14387 unsafe {
14388 let val: u32 = ::std::mem::transmute(val);
14389 self._bitfield_1.set(18usize, 10u8, val as u64)
14390 }
14391 }
14392 #[inline]
14393 pub fn reserved1(&self) -> u32 {
14394 unsafe { ::std::mem::transmute(self._bitfield_1.get(28usize, 4u8) as u32) }
14395 }
14396 #[inline]
14397 pub fn set_reserved1(&mut self, val: u32) {
14398 unsafe {
14399 let val: u32 = ::std::mem::transmute(val);
14400 self._bitfield_1.set(28usize, 4u8, val as u64)
14401 }
14402 }
14403 #[inline]
14404 pub fn new_bitfield_1(
14405 modulation_mode: u32,
14406 minor_channel_number: u32,
14407 major_channel_number: u32,
14408 reserved1: u32,
14409 ) -> __BindgenBitfieldUnit<[u8; 4usize], u8> {
14410 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize], u8> =
14411 Default::default();
14412 __bindgen_bitfield_unit.set(0usize, 8u8, {
14413 let modulation_mode: u32 = unsafe { ::std::mem::transmute(modulation_mode) };
14414 modulation_mode as u64
14415 });
14416 __bindgen_bitfield_unit.set(8usize, 10u8, {
14417 let minor_channel_number: u32 = unsafe { ::std::mem::transmute(minor_channel_number) };
14418 minor_channel_number as u64
14419 });
14420 __bindgen_bitfield_unit.set(18usize, 10u8, {
14421 let major_channel_number: u32 = unsafe { ::std::mem::transmute(major_channel_number) };
14422 major_channel_number as u64
14423 });
14424 __bindgen_bitfield_unit.set(28usize, 4u8, {
14425 let reserved1: u32 = unsafe { ::std::mem::transmute(reserved1) };
14426 reserved1 as u64
14427 });
14428 __bindgen_bitfield_unit
14429 }
14430}
14431#[test]
14432fn bindgen_test_layout_atsc_table_vct_channel__bindgen_ty_1() {
14433 assert_eq!(
14434 ::std::mem::size_of::<atsc_table_vct_channel__bindgen_ty_1>(),
14435 4usize,
14436 concat!(
14437 "Size of: ",
14438 stringify!(atsc_table_vct_channel__bindgen_ty_1)
14439 )
14440 );
14441 assert_eq!(
14442 ::std::mem::align_of::<atsc_table_vct_channel__bindgen_ty_1>(),
14443 1usize,
14444 concat!(
14445 "Alignment of ",
14446 stringify!(atsc_table_vct_channel__bindgen_ty_1)
14447 )
14448 );
14449 assert_eq!(
14450 unsafe {
14451 &(*(::std::ptr::null::<atsc_table_vct_channel__bindgen_ty_1>())).bitfield1 as *const _
14452 as usize
14453 },
14454 0usize,
14455 concat!(
14456 "Offset of field: ",
14457 stringify!(atsc_table_vct_channel__bindgen_ty_1),
14458 "::",
14459 stringify!(bitfield1)
14460 )
14461 );
14462}
14463#[repr(C, packed)]
14464#[derive(Copy, Clone)]
14465pub union atsc_table_vct_channel__bindgen_ty_2 {
14466 pub bitfield2: u16,
14467 pub __bindgen_anon_1: atsc_table_vct_channel__bindgen_ty_2__bindgen_ty_1,
14468 _bindgen_union_align: [u8; 2usize],
14469}
14470#[repr(C, packed)]
14471#[derive(Debug, Copy, Clone)]
14472pub struct atsc_table_vct_channel__bindgen_ty_2__bindgen_ty_1 {
14473 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize], u8>,
14474}
14475#[test]
14476fn bindgen_test_layout_atsc_table_vct_channel__bindgen_ty_2__bindgen_ty_1() {
14477 assert_eq!(
14478 ::std::mem::size_of::<atsc_table_vct_channel__bindgen_ty_2__bindgen_ty_1>(),
14479 2usize,
14480 concat!(
14481 "Size of: ",
14482 stringify!(atsc_table_vct_channel__bindgen_ty_2__bindgen_ty_1)
14483 )
14484 );
14485 assert_eq!(
14486 ::std::mem::align_of::<atsc_table_vct_channel__bindgen_ty_2__bindgen_ty_1>(),
14487 1usize,
14488 concat!(
14489 "Alignment of ",
14490 stringify!(atsc_table_vct_channel__bindgen_ty_2__bindgen_ty_1)
14491 )
14492 );
14493}
14494impl atsc_table_vct_channel__bindgen_ty_2__bindgen_ty_1 {
14495 #[inline]
14496 pub fn service_type(&self) -> u16 {
14497 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 6u8) as u16) }
14498 }
14499 #[inline]
14500 pub fn set_service_type(&mut self, val: u16) {
14501 unsafe {
14502 let val: u16 = ::std::mem::transmute(val);
14503 self._bitfield_1.set(0usize, 6u8, val as u64)
14504 }
14505 }
14506 #[inline]
14507 pub fn reserved2(&self) -> u16 {
14508 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 3u8) as u16) }
14509 }
14510 #[inline]
14511 pub fn set_reserved2(&mut self, val: u16) {
14512 unsafe {
14513 let val: u16 = ::std::mem::transmute(val);
14514 self._bitfield_1.set(6usize, 3u8, val as u64)
14515 }
14516 }
14517 #[inline]
14518 pub fn hide_guide(&self) -> u16 {
14519 unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u16) }
14520 }
14521 #[inline]
14522 pub fn set_hide_guide(&mut self, val: u16) {
14523 unsafe {
14524 let val: u16 = ::std::mem::transmute(val);
14525 self._bitfield_1.set(9usize, 1u8, val as u64)
14526 }
14527 }
14528 #[inline]
14529 pub fn out_of_band(&self) -> u16 {
14530 unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u16) }
14531 }
14532 #[inline]
14533 pub fn set_out_of_band(&mut self, val: u16) {
14534 unsafe {
14535 let val: u16 = ::std::mem::transmute(val);
14536 self._bitfield_1.set(10usize, 1u8, val as u64)
14537 }
14538 }
14539 #[inline]
14540 pub fn path_select(&self) -> u16 {
14541 unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u16) }
14542 }
14543 #[inline]
14544 pub fn set_path_select(&mut self, val: u16) {
14545 unsafe {
14546 let val: u16 = ::std::mem::transmute(val);
14547 self._bitfield_1.set(11usize, 1u8, val as u64)
14548 }
14549 }
14550 #[inline]
14551 pub fn hidden(&self) -> u16 {
14552 unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u16) }
14553 }
14554 #[inline]
14555 pub fn set_hidden(&mut self, val: u16) {
14556 unsafe {
14557 let val: u16 = ::std::mem::transmute(val);
14558 self._bitfield_1.set(12usize, 1u8, val as u64)
14559 }
14560 }
14561 #[inline]
14562 pub fn access_controlled(&self) -> u16 {
14563 unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u16) }
14564 }
14565 #[inline]
14566 pub fn set_access_controlled(&mut self, val: u16) {
14567 unsafe {
14568 let val: u16 = ::std::mem::transmute(val);
14569 self._bitfield_1.set(13usize, 1u8, val as u64)
14570 }
14571 }
14572 #[inline]
14573 pub fn ETM_location(&self) -> u16 {
14574 unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 2u8) as u16) }
14575 }
14576 #[inline]
14577 pub fn set_ETM_location(&mut self, val: u16) {
14578 unsafe {
14579 let val: u16 = ::std::mem::transmute(val);
14580 self._bitfield_1.set(14usize, 2u8, val as u64)
14581 }
14582 }
14583 #[inline]
14584 pub fn new_bitfield_1(
14585 service_type: u16,
14586 reserved2: u16,
14587 hide_guide: u16,
14588 out_of_band: u16,
14589 path_select: u16,
14590 hidden: u16,
14591 access_controlled: u16,
14592 ETM_location: u16,
14593 ) -> __BindgenBitfieldUnit<[u8; 2usize], u8> {
14594 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize], u8> =
14595 Default::default();
14596 __bindgen_bitfield_unit.set(0usize, 6u8, {
14597 let service_type: u16 = unsafe { ::std::mem::transmute(service_type) };
14598 service_type as u64
14599 });
14600 __bindgen_bitfield_unit.set(6usize, 3u8, {
14601 let reserved2: u16 = unsafe { ::std::mem::transmute(reserved2) };
14602 reserved2 as u64
14603 });
14604 __bindgen_bitfield_unit.set(9usize, 1u8, {
14605 let hide_guide: u16 = unsafe { ::std::mem::transmute(hide_guide) };
14606 hide_guide as u64
14607 });
14608 __bindgen_bitfield_unit.set(10usize, 1u8, {
14609 let out_of_band: u16 = unsafe { ::std::mem::transmute(out_of_band) };
14610 out_of_band as u64
14611 });
14612 __bindgen_bitfield_unit.set(11usize, 1u8, {
14613 let path_select: u16 = unsafe { ::std::mem::transmute(path_select) };
14614 path_select as u64
14615 });
14616 __bindgen_bitfield_unit.set(12usize, 1u8, {
14617 let hidden: u16 = unsafe { ::std::mem::transmute(hidden) };
14618 hidden as u64
14619 });
14620 __bindgen_bitfield_unit.set(13usize, 1u8, {
14621 let access_controlled: u16 = unsafe { ::std::mem::transmute(access_controlled) };
14622 access_controlled as u64
14623 });
14624 __bindgen_bitfield_unit.set(14usize, 2u8, {
14625 let ETM_location: u16 = unsafe { ::std::mem::transmute(ETM_location) };
14626 ETM_location as u64
14627 });
14628 __bindgen_bitfield_unit
14629 }
14630}
14631#[test]
14632fn bindgen_test_layout_atsc_table_vct_channel__bindgen_ty_2() {
14633 assert_eq!(
14634 ::std::mem::size_of::<atsc_table_vct_channel__bindgen_ty_2>(),
14635 2usize,
14636 concat!(
14637 "Size of: ",
14638 stringify!(atsc_table_vct_channel__bindgen_ty_2)
14639 )
14640 );
14641 assert_eq!(
14642 ::std::mem::align_of::<atsc_table_vct_channel__bindgen_ty_2>(),
14643 1usize,
14644 concat!(
14645 "Alignment of ",
14646 stringify!(atsc_table_vct_channel__bindgen_ty_2)
14647 )
14648 );
14649 assert_eq!(
14650 unsafe {
14651 &(*(::std::ptr::null::<atsc_table_vct_channel__bindgen_ty_2>())).bitfield2 as *const _
14652 as usize
14653 },
14654 0usize,
14655 concat!(
14656 "Offset of field: ",
14657 stringify!(atsc_table_vct_channel__bindgen_ty_2),
14658 "::",
14659 stringify!(bitfield2)
14660 )
14661 );
14662}
14663#[repr(C, packed)]
14664#[derive(Copy, Clone)]
14665pub union atsc_table_vct_channel__bindgen_ty_3 {
14666 pub bitfield3: u16,
14667 pub __bindgen_anon_1: atsc_table_vct_channel__bindgen_ty_3__bindgen_ty_1,
14668 _bindgen_union_align: [u8; 2usize],
14669}
14670#[repr(C, packed)]
14671#[derive(Debug, Copy, Clone)]
14672pub struct atsc_table_vct_channel__bindgen_ty_3__bindgen_ty_1 {
14673 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize], u8>,
14674}
14675#[test]
14676fn bindgen_test_layout_atsc_table_vct_channel__bindgen_ty_3__bindgen_ty_1() {
14677 assert_eq!(
14678 ::std::mem::size_of::<atsc_table_vct_channel__bindgen_ty_3__bindgen_ty_1>(),
14679 2usize,
14680 concat!(
14681 "Size of: ",
14682 stringify!(atsc_table_vct_channel__bindgen_ty_3__bindgen_ty_1)
14683 )
14684 );
14685 assert_eq!(
14686 ::std::mem::align_of::<atsc_table_vct_channel__bindgen_ty_3__bindgen_ty_1>(),
14687 1usize,
14688 concat!(
14689 "Alignment of ",
14690 stringify!(atsc_table_vct_channel__bindgen_ty_3__bindgen_ty_1)
14691 )
14692 );
14693}
14694impl atsc_table_vct_channel__bindgen_ty_3__bindgen_ty_1 {
14695 #[inline]
14696 pub fn descriptors_length(&self) -> u16 {
14697 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 10u8) as u16) }
14698 }
14699 #[inline]
14700 pub fn set_descriptors_length(&mut self, val: u16) {
14701 unsafe {
14702 let val: u16 = ::std::mem::transmute(val);
14703 self._bitfield_1.set(0usize, 10u8, val as u64)
14704 }
14705 }
14706 #[inline]
14707 pub fn reserved3(&self) -> u16 {
14708 unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 6u8) as u16) }
14709 }
14710 #[inline]
14711 pub fn set_reserved3(&mut self, val: u16) {
14712 unsafe {
14713 let val: u16 = ::std::mem::transmute(val);
14714 self._bitfield_1.set(10usize, 6u8, val as u64)
14715 }
14716 }
14717 #[inline]
14718 pub fn new_bitfield_1(
14719 descriptors_length: u16,
14720 reserved3: u16,
14721 ) -> __BindgenBitfieldUnit<[u8; 2usize], u8> {
14722 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize], u8> =
14723 Default::default();
14724 __bindgen_bitfield_unit.set(0usize, 10u8, {
14725 let descriptors_length: u16 = unsafe { ::std::mem::transmute(descriptors_length) };
14726 descriptors_length as u64
14727 });
14728 __bindgen_bitfield_unit.set(10usize, 6u8, {
14729 let reserved3: u16 = unsafe { ::std::mem::transmute(reserved3) };
14730 reserved3 as u64
14731 });
14732 __bindgen_bitfield_unit
14733 }
14734}
14735#[test]
14736fn bindgen_test_layout_atsc_table_vct_channel__bindgen_ty_3() {
14737 assert_eq!(
14738 ::std::mem::size_of::<atsc_table_vct_channel__bindgen_ty_3>(),
14739 2usize,
14740 concat!(
14741 "Size of: ",
14742 stringify!(atsc_table_vct_channel__bindgen_ty_3)
14743 )
14744 );
14745 assert_eq!(
14746 ::std::mem::align_of::<atsc_table_vct_channel__bindgen_ty_3>(),
14747 1usize,
14748 concat!(
14749 "Alignment of ",
14750 stringify!(atsc_table_vct_channel__bindgen_ty_3)
14751 )
14752 );
14753 assert_eq!(
14754 unsafe {
14755 &(*(::std::ptr::null::<atsc_table_vct_channel__bindgen_ty_3>())).bitfield3 as *const _
14756 as usize
14757 },
14758 0usize,
14759 concat!(
14760 "Offset of field: ",
14761 stringify!(atsc_table_vct_channel__bindgen_ty_3),
14762 "::",
14763 stringify!(bitfield3)
14764 )
14765 );
14766}
14767#[test]
14768fn bindgen_test_layout_atsc_table_vct_channel() {
14769 assert_eq!(
14770 ::std::mem::size_of::<atsc_table_vct_channel>(),
14771 80usize,
14772 concat!("Size of: ", stringify!(atsc_table_vct_channel))
14773 );
14774 assert_eq!(
14775 ::std::mem::align_of::<atsc_table_vct_channel>(),
14776 1usize,
14777 concat!("Alignment of ", stringify!(atsc_table_vct_channel))
14778 );
14779 assert_eq!(
14780 unsafe {
14781 &(*(::std::ptr::null::<atsc_table_vct_channel>())).__short_name as *const _ as usize
14782 },
14783 0usize,
14784 concat!(
14785 "Offset of field: ",
14786 stringify!(atsc_table_vct_channel),
14787 "::",
14788 stringify!(__short_name)
14789 )
14790 );
14791 assert_eq!(
14792 unsafe {
14793 &(*(::std::ptr::null::<atsc_table_vct_channel>())).carrier_frequency as *const _
14794 as usize
14795 },
14796 18usize,
14797 concat!(
14798 "Offset of field: ",
14799 stringify!(atsc_table_vct_channel),
14800 "::",
14801 stringify!(carrier_frequency)
14802 )
14803 );
14804 assert_eq!(
14805 unsafe {
14806 &(*(::std::ptr::null::<atsc_table_vct_channel>())).channel_tsid as *const _ as usize
14807 },
14808 22usize,
14809 concat!(
14810 "Offset of field: ",
14811 stringify!(atsc_table_vct_channel),
14812 "::",
14813 stringify!(channel_tsid)
14814 )
14815 );
14816 assert_eq!(
14817 unsafe {
14818 &(*(::std::ptr::null::<atsc_table_vct_channel>())).program_number as *const _ as usize
14819 },
14820 24usize,
14821 concat!(
14822 "Offset of field: ",
14823 stringify!(atsc_table_vct_channel),
14824 "::",
14825 stringify!(program_number)
14826 )
14827 );
14828 assert_eq!(
14829 unsafe {
14830 &(*(::std::ptr::null::<atsc_table_vct_channel>())).source_id as *const _ as usize
14831 },
14832 28usize,
14833 concat!(
14834 "Offset of field: ",
14835 stringify!(atsc_table_vct_channel),
14836 "::",
14837 stringify!(source_id)
14838 )
14839 );
14840 assert_eq!(
14841 unsafe {
14842 &(*(::std::ptr::null::<atsc_table_vct_channel>())).descriptor as *const _ as usize
14843 },
14844 32usize,
14845 concat!(
14846 "Offset of field: ",
14847 stringify!(atsc_table_vct_channel),
14848 "::",
14849 stringify!(descriptor)
14850 )
14851 );
14852 assert_eq!(
14853 unsafe { &(*(::std::ptr::null::<atsc_table_vct_channel>())).next as *const _ as usize },
14854 40usize,
14855 concat!(
14856 "Offset of field: ",
14857 stringify!(atsc_table_vct_channel),
14858 "::",
14859 stringify!(next)
14860 )
14861 );
14862 assert_eq!(
14863 unsafe {
14864 &(*(::std::ptr::null::<atsc_table_vct_channel>())).short_name as *const _ as usize
14865 },
14866 48usize,
14867 concat!(
14868 "Offset of field: ",
14869 stringify!(atsc_table_vct_channel),
14870 "::",
14871 stringify!(short_name)
14872 )
14873 );
14874}
14875#[repr(C, packed)]
14876#[derive(Copy, Clone)]
14877pub struct atsc_table_vct {
14878 pub header: dvb_table_header,
14879 pub protocol_version: u8,
14880 pub num_channels_in_section: u8,
14881 pub channel: *mut atsc_table_vct_channel,
14882 pub descriptor: *mut dvb_desc,
14883}
14884#[test]
14885fn bindgen_test_layout_atsc_table_vct() {
14886 assert_eq!(
14887 ::std::mem::size_of::<atsc_table_vct>(),
14888 26usize,
14889 concat!("Size of: ", stringify!(atsc_table_vct))
14890 );
14891 assert_eq!(
14892 ::std::mem::align_of::<atsc_table_vct>(),
14893 1usize,
14894 concat!("Alignment of ", stringify!(atsc_table_vct))
14895 );
14896 assert_eq!(
14897 unsafe { &(*(::std::ptr::null::<atsc_table_vct>())).header as *const _ as usize },
14898 0usize,
14899 concat!(
14900 "Offset of field: ",
14901 stringify!(atsc_table_vct),
14902 "::",
14903 stringify!(header)
14904 )
14905 );
14906 assert_eq!(
14907 unsafe { &(*(::std::ptr::null::<atsc_table_vct>())).protocol_version as *const _ as usize },
14908 8usize,
14909 concat!(
14910 "Offset of field: ",
14911 stringify!(atsc_table_vct),
14912 "::",
14913 stringify!(protocol_version)
14914 )
14915 );
14916 assert_eq!(
14917 unsafe {
14918 &(*(::std::ptr::null::<atsc_table_vct>())).num_channels_in_section as *const _ as usize
14919 },
14920 9usize,
14921 concat!(
14922 "Offset of field: ",
14923 stringify!(atsc_table_vct),
14924 "::",
14925 stringify!(num_channels_in_section)
14926 )
14927 );
14928 assert_eq!(
14929 unsafe { &(*(::std::ptr::null::<atsc_table_vct>())).channel as *const _ as usize },
14930 10usize,
14931 concat!(
14932 "Offset of field: ",
14933 stringify!(atsc_table_vct),
14934 "::",
14935 stringify!(channel)
14936 )
14937 );
14938 assert_eq!(
14939 unsafe { &(*(::std::ptr::null::<atsc_table_vct>())).descriptor as *const _ as usize },
14940 18usize,
14941 concat!(
14942 "Offset of field: ",
14943 stringify!(atsc_table_vct),
14944 "::",
14945 stringify!(descriptor)
14946 )
14947 );
14948}
14949#[repr(C, packed)]
14950#[derive(Copy, Clone)]
14951pub union atsc_table_vct_descriptor_length {
14952 pub bitfield: u16,
14953 pub __bindgen_anon_1: atsc_table_vct_descriptor_length__bindgen_ty_1,
14954 _bindgen_union_align: [u8; 2usize],
14955}
14956#[repr(C, packed)]
14957#[derive(Debug, Copy, Clone)]
14958pub struct atsc_table_vct_descriptor_length__bindgen_ty_1 {
14959 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize], u8>,
14960}
14961#[test]
14962fn bindgen_test_layout_atsc_table_vct_descriptor_length__bindgen_ty_1() {
14963 assert_eq!(
14964 ::std::mem::size_of::<atsc_table_vct_descriptor_length__bindgen_ty_1>(),
14965 2usize,
14966 concat!(
14967 "Size of: ",
14968 stringify!(atsc_table_vct_descriptor_length__bindgen_ty_1)
14969 )
14970 );
14971 assert_eq!(
14972 ::std::mem::align_of::<atsc_table_vct_descriptor_length__bindgen_ty_1>(),
14973 1usize,
14974 concat!(
14975 "Alignment of ",
14976 stringify!(atsc_table_vct_descriptor_length__bindgen_ty_1)
14977 )
14978 );
14979}
14980impl atsc_table_vct_descriptor_length__bindgen_ty_1 {
14981 #[inline]
14982 pub fn descriptor_length(&self) -> u16 {
14983 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 10u8) as u16) }
14984 }
14985 #[inline]
14986 pub fn set_descriptor_length(&mut self, val: u16) {
14987 unsafe {
14988 let val: u16 = ::std::mem::transmute(val);
14989 self._bitfield_1.set(0usize, 10u8, val as u64)
14990 }
14991 }
14992 #[inline]
14993 pub fn reserved(&self) -> u16 {
14994 unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 6u8) as u16) }
14995 }
14996 #[inline]
14997 pub fn set_reserved(&mut self, val: u16) {
14998 unsafe {
14999 let val: u16 = ::std::mem::transmute(val);
15000 self._bitfield_1.set(10usize, 6u8, val as u64)
15001 }
15002 }
15003 #[inline]
15004 pub fn new_bitfield_1(
15005 descriptor_length: u16,
15006 reserved: u16,
15007 ) -> __BindgenBitfieldUnit<[u8; 2usize], u8> {
15008 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize], u8> =
15009 Default::default();
15010 __bindgen_bitfield_unit.set(0usize, 10u8, {
15011 let descriptor_length: u16 = unsafe { ::std::mem::transmute(descriptor_length) };
15012 descriptor_length as u64
15013 });
15014 __bindgen_bitfield_unit.set(10usize, 6u8, {
15015 let reserved: u16 = unsafe { ::std::mem::transmute(reserved) };
15016 reserved as u64
15017 });
15018 __bindgen_bitfield_unit
15019 }
15020}
15021#[test]
15022fn bindgen_test_layout_atsc_table_vct_descriptor_length() {
15023 assert_eq!(
15024 ::std::mem::size_of::<atsc_table_vct_descriptor_length>(),
15025 2usize,
15026 concat!("Size of: ", stringify!(atsc_table_vct_descriptor_length))
15027 );
15028 assert_eq!(
15029 ::std::mem::align_of::<atsc_table_vct_descriptor_length>(),
15030 1usize,
15031 concat!(
15032 "Alignment of ",
15033 stringify!(atsc_table_vct_descriptor_length)
15034 )
15035 );
15036 assert_eq!(
15037 unsafe {
15038 &(*(::std::ptr::null::<atsc_table_vct_descriptor_length>())).bitfield as *const _
15039 as usize
15040 },
15041 0usize,
15042 concat!(
15043 "Offset of field: ",
15044 stringify!(atsc_table_vct_descriptor_length),
15045 "::",
15046 stringify!(bitfield)
15047 )
15048 );
15049}
15050extern "C" {
15051 pub fn atsc_table_vct_init(
15052 parms: *mut dvb_v5_fe_parms,
15053 buf: *const u8,
15054 buflen: ssize_t,
15055 table: *mut *mut atsc_table_vct,
15056 ) -> ssize_t;
15057}
15058extern "C" {
15059 pub fn atsc_table_vct_free(table: *mut atsc_table_vct);
15060}
15061extern "C" {
15062 pub fn atsc_table_vct_print(parms: *mut dvb_v5_fe_parms, table: *mut atsc_table_vct);
15063}