#[repr(C)]
#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct __BindgenBitfieldUnit<Storage, Align> {
storage: Storage,
align: [Align; 0],
}
impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align> {
#[inline]
pub const fn new(storage: Storage) -> Self {
Self { storage, align: [] }
}
}
impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align>
where
Storage: AsRef<[u8]> + AsMut<[u8]>,
{
#[inline]
pub fn get_bit(&self, index: usize) -> bool {
debug_assert!(index / 8 < self.storage.as_ref().len());
let byte_index = index / 8;
let byte = self.storage.as_ref()[byte_index];
let bit_index = if cfg!(target_endian = "big") {
7 - (index % 8)
} else {
index % 8
};
let mask = 1 << bit_index;
byte & mask == mask
}
#[inline]
pub fn set_bit(&mut self, index: usize, val: bool) {
debug_assert!(index / 8 < self.storage.as_ref().len());
let byte_index = index / 8;
let byte = &mut self.storage.as_mut()[byte_index];
let bit_index = if cfg!(target_endian = "big") {
7 - (index % 8)
} else {
index % 8
};
let mask = 1 << bit_index;
if val {
*byte |= mask;
} else {
*byte &= !mask;
}
}
#[inline]
pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
debug_assert!(bit_width <= 64);
debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
let mut val = 0;
for i in 0..(bit_width as usize) {
if self.get_bit(i + bit_offset) {
let index = if cfg!(target_endian = "big") {
bit_width as usize - 1 - i
} else {
i
};
val |= 1 << index;
}
}
val
}
#[inline]
pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
debug_assert!(bit_width <= 64);
debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
for i in 0..(bit_width as usize) {
let mask = 1 << i;
let val_bit_is_set = val & mask == mask;
let index = if cfg!(target_endian = "big") {
bit_width as usize - 1 - i
} else {
i
};
self.set_bit(index + bit_offset, val_bit_is_set);
}
}
}
#[repr(C)]
#[derive(Default)]
pub struct __IncompleteArrayField<T>(::std::marker::PhantomData<T>, [T; 0]);
impl<T> __IncompleteArrayField<T> {
#[inline]
pub const fn new() -> Self {
__IncompleteArrayField(::std::marker::PhantomData, [])
}
#[inline]
pub fn as_ptr(&self) -> *const T {
self as *const _ as *const T
}
#[inline]
pub fn as_mut_ptr(&mut self) -> *mut T {
self as *mut _ as *mut T
}
#[inline]
pub unsafe fn as_slice(&self, len: usize) -> &[T] {
::std::slice::from_raw_parts(self.as_ptr(), len)
}
#[inline]
pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] {
::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len)
}
}
impl<T> ::std::fmt::Debug for __IncompleteArrayField<T> {
fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
fmt.write_str("__IncompleteArrayField")
}
}
pub const ATSC_BASE_PID: u32 = 8187;
pub const ATSC_TABLE_EIT: u32 = 203;
pub const DVB_TABLE_CAT: u32 = 1;
pub const DVB_TABLE_CAT_PID: u32 = 1;
pub const DVB_MAX_PAYLOAD_PACKET_SIZE: u32 = 4096;
pub const DVB_CRC_SIZE: u32 = 4;
pub const DMX_FILTER_SIZE: u32 = 16;
pub const DMX_CHECK_CRC: u32 = 1;
pub const DMX_ONESHOT: u32 = 2;
pub const DMX_IMMEDIATE_START: u32 = 4;
pub const DTV_UNDEFINED: u32 = 0;
pub const DTV_TUNE: u32 = 1;
pub const DTV_CLEAR: u32 = 2;
pub const DTV_FREQUENCY: u32 = 3;
pub const DTV_MODULATION: u32 = 4;
pub const DTV_BANDWIDTH_HZ: u32 = 5;
pub const DTV_INVERSION: u32 = 6;
pub const DTV_DISEQC_MASTER: u32 = 7;
pub const DTV_SYMBOL_RATE: u32 = 8;
pub const DTV_INNER_FEC: u32 = 9;
pub const DTV_VOLTAGE: u32 = 10;
pub const DTV_TONE: u32 = 11;
pub const DTV_PILOT: u32 = 12;
pub const DTV_ROLLOFF: u32 = 13;
pub const DTV_DISEQC_SLAVE_REPLY: u32 = 14;
pub const DTV_FE_CAPABILITY_COUNT: u32 = 15;
pub const DTV_FE_CAPABILITY: u32 = 16;
pub const DTV_DELIVERY_SYSTEM: u32 = 17;
pub const DTV_ISDBT_PARTIAL_RECEPTION: u32 = 18;
pub const DTV_ISDBT_SOUND_BROADCASTING: u32 = 19;
pub const DTV_ISDBT_SB_SUBCHANNEL_ID: u32 = 20;
pub const DTV_ISDBT_SB_SEGMENT_IDX: u32 = 21;
pub const DTV_ISDBT_SB_SEGMENT_COUNT: u32 = 22;
pub const DTV_ISDBT_LAYERA_FEC: u32 = 23;
pub const DTV_ISDBT_LAYERA_MODULATION: u32 = 24;
pub const DTV_ISDBT_LAYERA_SEGMENT_COUNT: u32 = 25;
pub const DTV_ISDBT_LAYERA_TIME_INTERLEAVING: u32 = 26;
pub const DTV_ISDBT_LAYERB_FEC: u32 = 27;
pub const DTV_ISDBT_LAYERB_MODULATION: u32 = 28;
pub const DTV_ISDBT_LAYERB_SEGMENT_COUNT: u32 = 29;
pub const DTV_ISDBT_LAYERB_TIME_INTERLEAVING: u32 = 30;
pub const DTV_ISDBT_LAYERC_FEC: u32 = 31;
pub const DTV_ISDBT_LAYERC_MODULATION: u32 = 32;
pub const DTV_ISDBT_LAYERC_SEGMENT_COUNT: u32 = 33;
pub const DTV_ISDBT_LAYERC_TIME_INTERLEAVING: u32 = 34;
pub const DTV_API_VERSION: u32 = 35;
pub const DTV_CODE_RATE_HP: u32 = 36;
pub const DTV_CODE_RATE_LP: u32 = 37;
pub const DTV_GUARD_INTERVAL: u32 = 38;
pub const DTV_TRANSMISSION_MODE: u32 = 39;
pub const DTV_HIERARCHY: u32 = 40;
pub const DTV_ISDBT_LAYER_ENABLED: u32 = 41;
pub const DTV_STREAM_ID: u32 = 42;
pub const DTV_ISDBS_TS_ID_LEGACY: u32 = 42;
pub const DTV_DVBT2_PLP_ID_LEGACY: u32 = 43;
pub const DTV_ENUM_DELSYS: u32 = 44;
pub const DTV_ATSCMH_FIC_VER: u32 = 45;
pub const DTV_ATSCMH_PARADE_ID: u32 = 46;
pub const DTV_ATSCMH_NOG: u32 = 47;
pub const DTV_ATSCMH_TNOG: u32 = 48;
pub const DTV_ATSCMH_SGN: u32 = 49;
pub const DTV_ATSCMH_PRC: u32 = 50;
pub const DTV_ATSCMH_RS_FRAME_MODE: u32 = 51;
pub const DTV_ATSCMH_RS_FRAME_ENSEMBLE: u32 = 52;
pub const DTV_ATSCMH_RS_CODE_MODE_PRI: u32 = 53;
pub const DTV_ATSCMH_RS_CODE_MODE_SEC: u32 = 54;
pub const DTV_ATSCMH_SCCC_BLOCK_MODE: u32 = 55;
pub const DTV_ATSCMH_SCCC_CODE_MODE_A: u32 = 56;
pub const DTV_ATSCMH_SCCC_CODE_MODE_B: u32 = 57;
pub const DTV_ATSCMH_SCCC_CODE_MODE_C: u32 = 58;
pub const DTV_ATSCMH_SCCC_CODE_MODE_D: u32 = 59;
pub const DTV_INTERLEAVING: u32 = 60;
pub const DTV_LNA: u32 = 61;
pub const DTV_STAT_SIGNAL_STRENGTH: u32 = 62;
pub const DTV_STAT_CNR: u32 = 63;
pub const DTV_STAT_PRE_ERROR_BIT_COUNT: u32 = 64;
pub const DTV_STAT_PRE_TOTAL_BIT_COUNT: u32 = 65;
pub const DTV_STAT_POST_ERROR_BIT_COUNT: u32 = 66;
pub const DTV_STAT_POST_TOTAL_BIT_COUNT: u32 = 67;
pub const DTV_STAT_ERROR_BLOCK_COUNT: u32 = 68;
pub const DTV_STAT_TOTAL_BLOCK_COUNT: u32 = 69;
pub const DTV_SCRAMBLING_SEQUENCE_INDEX: u32 = 70;
pub const DTV_MAX_COMMAND: u32 = 70;
pub const NO_STREAM_ID_FILTER: i32 = -1;
pub const LNA_AUTO: i32 = -1;
pub const MAX_DTV_STATS: u32 = 4;
pub const DTV_IOCTL_MAX_MSGS: u32 = 64;
pub const FE_TUNE_MODE_ONESHOT: u32 = 1;
pub const DTV_USER_COMMAND_START: u32 = 256;
pub const DTV_POLARIZATION: u32 = 256;
pub const DTV_VIDEO_PID: u32 = 257;
pub const DTV_AUDIO_PID: u32 = 258;
pub const DTV_SERVICE_ID: u32 = 259;
pub const DTV_CH_NAME: u32 = 260;
pub const DTV_VCHANNEL: u32 = 261;
pub const DTV_SAT_NUMBER: u32 = 262;
pub const DTV_DISEQC_WAIT: u32 = 263;
pub const DTV_DISEQC_LNB: u32 = 264;
pub const DTV_FREQ_BPF: u32 = 265;
pub const DTV_PLS_CODE: u32 = 266;
pub const DTV_PLS_MODE: u32 = 267;
pub const DTV_COUNTRY_CODE: u32 = 268;
pub const DTV_MAX_USER_COMMAND: u32 = 268;
pub const DTV_USER_NAME_SIZE: u32 = 13;
pub const DTV_STAT_COMMAND_START: u32 = 512;
pub const DTV_STATUS: u32 = 512;
pub const DTV_BER: u32 = 513;
pub const DTV_PER: u32 = 514;
pub const DTV_QUALITY: u32 = 515;
pub const DTV_PRE_BER: u32 = 516;
pub const DTV_MAX_STAT_COMMAND: u32 = 516;
pub const DTV_STAT_NAME_SIZE: u32 = 5;
pub const DTV_NUM_KERNEL_STATS: u32 = 8;
pub const DTV_NUM_STATS_PROPS: u32 = 13;
pub const LOG_EMERG: u32 = 0;
pub const LOG_ALERT: u32 = 1;
pub const LOG_CRIT: u32 = 2;
pub const LOG_ERR: u32 = 3;
pub const LOG_WARNING: u32 = 4;
pub const LOG_NOTICE: u32 = 5;
pub const LOG_INFO: u32 = 6;
pub const LOG_DEBUG: u32 = 7;
pub const LOG_PRIMASK: u32 = 7;
pub const LOG_KERN: u32 = 0;
pub const LOG_USER: u32 = 8;
pub const LOG_MAIL: u32 = 16;
pub const LOG_DAEMON: u32 = 24;
pub const LOG_AUTH: u32 = 32;
pub const LOG_SYSLOG: u32 = 40;
pub const LOG_LPR: u32 = 48;
pub const LOG_NEWS: u32 = 56;
pub const LOG_UUCP: u32 = 64;
pub const LOG_CRON: u32 = 72;
pub const LOG_AUTHPRIV: u32 = 80;
pub const LOG_FTP: u32 = 88;
pub const LOG_LOCAL0: u32 = 128;
pub const LOG_LOCAL1: u32 = 136;
pub const LOG_LOCAL2: u32 = 144;
pub const LOG_LOCAL3: u32 = 152;
pub const LOG_LOCAL4: u32 = 160;
pub const LOG_LOCAL5: u32 = 168;
pub const LOG_LOCAL6: u32 = 176;
pub const LOG_LOCAL7: u32 = 184;
pub const LOG_NFACILITIES: u32 = 24;
pub const LOG_FACMASK: u32 = 1016;
pub const LOG_PID: u32 = 1;
pub const LOG_CONS: u32 = 2;
pub const LOG_ODELAY: u32 = 4;
pub const LOG_NDELAY: u32 = 8;
pub const LOG_NOWAIT: u32 = 16;
pub const LOG_PERROR: u32 = 32;
pub const MAX_DELIVERY_SYSTEMS: u32 = 20;
pub const DTV_MAX_STATS: u32 = 13;
pub const DTV_SIGNAL_STRENGTH: u32 = 62;
pub const DTV_SNR: u32 = 63;
pub const DTV_UNCORRECTED_BLOCKS: u32 = 68;
pub const MAX_TABLE_SIZE: u32 = 1048576;
pub const DVB_TABLE_EIT: u32 = 78;
pub const DVB_TABLE_EIT_OTHER: u32 = 79;
pub const DVB_TABLE_EIT_PID: u32 = 18;
pub const DVB_TABLE_EIT_SCHEDULE: u32 = 80;
pub const DVB_TABLE_EIT_SCHEDULE_OTHER: u32 = 96;
pub const LIBDVBV5_VERSION_MAJOR: u32 = 1;
pub const LIBDVBV5_VERSION_MINOR: u32 = 20;
pub const LIBDVBV5_VERSION_PATCH: u32 = 0;
pub const LIBDVBV5_VERSION: &'static [u8; 7usize] = b"1.20.0\0";
pub const ATSC_TABLE_MGT: u32 = 199;
pub const DVB_MPEG_ES_PIC_START: u32 = 0;
pub const DVB_MPEG_ES_USER_DATA: u32 = 178;
pub const DVB_MPEG_ES_SEQ_START: u32 = 179;
pub const DVB_MPEG_ES_SEQ_EXT: u32 = 181;
pub const DVB_MPEG_ES_GOP: u32 = 184;
pub const DVB_MPEG_PES: u32 = 1;
pub const DVB_MPEG_STREAM_MAP: u32 = 188;
pub const DVB_MPEG_STREAM_PADDING: u32 = 190;
pub const DVB_MPEG_STREAM_PRIVATE_2: u32 = 95;
pub const DVB_MPEG_STREAM_ECM: u32 = 112;
pub const DVB_MPEG_STREAM_EMM: u32 = 113;
pub const DVB_MPEG_STREAM_DIRECTORY: u32 = 255;
pub const DVB_MPEG_STREAM_DSMCC: u32 = 122;
pub const DVB_MPEG_STREAM_H222E: u32 = 248;
pub const DVB_MPEG_TS: u32 = 71;
pub const DVB_MPEG_TS_PACKET_SIZE: u32 = 188;
pub const DVB_TABLE_NIT: u32 = 64;
pub const DVB_TABLE_NIT2: u32 = 65;
pub const DVB_TABLE_NIT_PID: u32 = 16;
pub const DVB_TABLE_PAT: u32 = 0;
pub const DVB_TABLE_PAT_PID: u32 = 0;
pub const DVB_TABLE_PMT: u32 = 2;
pub const DVB_TABLE_SDT: u32 = 66;
pub const DVB_TABLE_SDT2: u32 = 70;
pub const DVB_TABLE_SDT_PID: u32 = 17;
pub const ATSC_TABLE_TVCT: u32 = 200;
pub const ATSC_TABLE_CVCT: u32 = 201;
pub const ATSC_TABLE_VCT_PID: u32 = 8187;
pub type __uint8_t = ::std::os::raw::c_uchar;
pub type __uint16_t = ::std::os::raw::c_ushort;
pub type __uint32_t = ::std::os::raw::c_uint;
pub type __uint64_t = ::std::os::raw::c_ulong;
pub type __ssize_t = ::std::os::raw::c_long;
pub type ssize_t = __ssize_t;
pub type size_t = ::std::os::raw::c_ulong;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct tm {
pub tm_sec: ::std::os::raw::c_int,
pub tm_min: ::std::os::raw::c_int,
pub tm_hour: ::std::os::raw::c_int,
pub tm_mday: ::std::os::raw::c_int,
pub tm_mon: ::std::os::raw::c_int,
pub tm_year: ::std::os::raw::c_int,
pub tm_wday: ::std::os::raw::c_int,
pub tm_yday: ::std::os::raw::c_int,
pub tm_isdst: ::std::os::raw::c_int,
pub tm_gmtoff: ::std::os::raw::c_long,
pub tm_zone: *const ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout_tm() {
assert_eq!(
::std::mem::size_of::<tm>(),
56usize,
concat!("Size of: ", stringify!(tm))
);
assert_eq!(
::std::mem::align_of::<tm>(),
8usize,
concat!("Alignment of ", stringify!(tm))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<tm>())).tm_sec as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(tm),
"::",
stringify!(tm_sec)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<tm>())).tm_min as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(tm),
"::",
stringify!(tm_min)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<tm>())).tm_hour as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(tm),
"::",
stringify!(tm_hour)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<tm>())).tm_mday as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(tm),
"::",
stringify!(tm_mday)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<tm>())).tm_mon as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(tm),
"::",
stringify!(tm_mon)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<tm>())).tm_year as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(tm),
"::",
stringify!(tm_year)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<tm>())).tm_wday as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(tm),
"::",
stringify!(tm_wday)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<tm>())).tm_yday as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(tm),
"::",
stringify!(tm_yday)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<tm>())).tm_isdst as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(tm),
"::",
stringify!(tm_isdst)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<tm>())).tm_gmtoff as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(tm),
"::",
stringify!(tm_gmtoff)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<tm>())).tm_zone as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(tm),
"::",
stringify!(tm_zone)
)
);
}
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub struct dvb_ts_packet_header {
pub sync_byte: u8,
pub __bindgen_anon_1: dvb_ts_packet_header__bindgen_ty_1,
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize], u8>,
pub adaptation_field_length: u8,
pub __bindgen_anon_2: dvb_ts_packet_header__bindgen_ty_2,
}
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub union dvb_ts_packet_header__bindgen_ty_1 {
pub bitfield: u16,
pub __bindgen_anon_1: dvb_ts_packet_header__bindgen_ty_1__bindgen_ty_1,
_bindgen_union_align: [u8; 2usize],
}
#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct dvb_ts_packet_header__bindgen_ty_1__bindgen_ty_1 {
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize], u8>,
}
#[test]
fn bindgen_test_layout_dvb_ts_packet_header__bindgen_ty_1__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<dvb_ts_packet_header__bindgen_ty_1__bindgen_ty_1>(),
2usize,
concat!(
"Size of: ",
stringify!(dvb_ts_packet_header__bindgen_ty_1__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<dvb_ts_packet_header__bindgen_ty_1__bindgen_ty_1>(),
1usize,
concat!(
"Alignment of ",
stringify!(dvb_ts_packet_header__bindgen_ty_1__bindgen_ty_1)
)
);
}
impl dvb_ts_packet_header__bindgen_ty_1__bindgen_ty_1 {
#[inline]
pub fn pid(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 13u8) as u16) }
}
#[inline]
pub fn set_pid(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 13u8, val as u64)
}
}
#[inline]
pub fn transport_priority(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u16) }
}
#[inline]
pub fn set_transport_priority(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(13usize, 1u8, val as u64)
}
}
#[inline]
pub fn payload_unit_start_indicator(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u16) }
}
#[inline]
pub fn set_payload_unit_start_indicator(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(14usize, 1u8, val as u64)
}
}
#[inline]
pub fn transport_error_indicator(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u16) }
}
#[inline]
pub fn set_transport_error_indicator(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(15usize, 1u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(
pid: u16,
transport_priority: u16,
payload_unit_start_indicator: u16,
transport_error_indicator: u16,
) -> __BindgenBitfieldUnit<[u8; 2usize], u8> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize], u8> =
Default::default();
__bindgen_bitfield_unit.set(0usize, 13u8, {
let pid: u16 = unsafe { ::std::mem::transmute(pid) };
pid as u64
});
__bindgen_bitfield_unit.set(13usize, 1u8, {
let transport_priority: u16 = unsafe { ::std::mem::transmute(transport_priority) };
transport_priority as u64
});
__bindgen_bitfield_unit.set(14usize, 1u8, {
let payload_unit_start_indicator: u16 =
unsafe { ::std::mem::transmute(payload_unit_start_indicator) };
payload_unit_start_indicator as u64
});
__bindgen_bitfield_unit.set(15usize, 1u8, {
let transport_error_indicator: u16 =
unsafe { ::std::mem::transmute(transport_error_indicator) };
transport_error_indicator as u64
});
__bindgen_bitfield_unit
}
}
#[test]
fn bindgen_test_layout_dvb_ts_packet_header__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<dvb_ts_packet_header__bindgen_ty_1>(),
2usize,
concat!("Size of: ", stringify!(dvb_ts_packet_header__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<dvb_ts_packet_header__bindgen_ty_1>(),
1usize,
concat!(
"Alignment of ",
stringify!(dvb_ts_packet_header__bindgen_ty_1)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_ts_packet_header__bindgen_ty_1>())).bitfield as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_ts_packet_header__bindgen_ty_1),
"::",
stringify!(bitfield)
)
);
}
#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct dvb_ts_packet_header__bindgen_ty_2 {
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize], u8>,
}
#[test]
fn bindgen_test_layout_dvb_ts_packet_header__bindgen_ty_2() {
assert_eq!(
::std::mem::size_of::<dvb_ts_packet_header__bindgen_ty_2>(),
1usize,
concat!("Size of: ", stringify!(dvb_ts_packet_header__bindgen_ty_2))
);
assert_eq!(
::std::mem::align_of::<dvb_ts_packet_header__bindgen_ty_2>(),
1usize,
concat!(
"Alignment of ",
stringify!(dvb_ts_packet_header__bindgen_ty_2)
)
);
}
impl dvb_ts_packet_header__bindgen_ty_2 {
#[inline]
pub fn extension(&self) -> u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
}
#[inline]
pub fn set_extension(&mut self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 1u8, val as u64)
}
}
#[inline]
pub fn private_data(&self) -> u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
}
#[inline]
pub fn set_private_data(&mut self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(1usize, 1u8, val as u64)
}
}
#[inline]
pub fn splicing_point(&self) -> u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) }
}
#[inline]
pub fn set_splicing_point(&mut self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(2usize, 1u8, val as u64)
}
}
#[inline]
pub fn OPCR(&self) -> u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8) }
}
#[inline]
pub fn set_OPCR(&mut self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(3usize, 1u8, val as u64)
}
}
#[inline]
pub fn PCR(&self) -> u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u8) }
}
#[inline]
pub fn set_PCR(&mut self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(4usize, 1u8, val as u64)
}
}
#[inline]
pub fn priority(&self) -> u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u8) }
}
#[inline]
pub fn set_priority(&mut self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(5usize, 1u8, val as u64)
}
}
#[inline]
pub fn random_access(&self) -> u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u8) }
}
#[inline]
pub fn set_random_access(&mut self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(6usize, 1u8, val as u64)
}
}
#[inline]
pub fn discontinued(&self) -> u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u8) }
}
#[inline]
pub fn set_discontinued(&mut self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(7usize, 1u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(
extension: u8,
private_data: u8,
splicing_point: u8,
OPCR: u8,
PCR: u8,
priority: u8,
random_access: u8,
discontinued: u8,
) -> __BindgenBitfieldUnit<[u8; 1usize], u8> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize], u8> =
Default::default();
__bindgen_bitfield_unit.set(0usize, 1u8, {
let extension: u8 = unsafe { ::std::mem::transmute(extension) };
extension as u64
});
__bindgen_bitfield_unit.set(1usize, 1u8, {
let private_data: u8 = unsafe { ::std::mem::transmute(private_data) };
private_data as u64
});
__bindgen_bitfield_unit.set(2usize, 1u8, {
let splicing_point: u8 = unsafe { ::std::mem::transmute(splicing_point) };
splicing_point as u64
});
__bindgen_bitfield_unit.set(3usize, 1u8, {
let OPCR: u8 = unsafe { ::std::mem::transmute(OPCR) };
OPCR as u64
});
__bindgen_bitfield_unit.set(4usize, 1u8, {
let PCR: u8 = unsafe { ::std::mem::transmute(PCR) };
PCR as u64
});
__bindgen_bitfield_unit.set(5usize, 1u8, {
let priority: u8 = unsafe { ::std::mem::transmute(priority) };
priority as u64
});
__bindgen_bitfield_unit.set(6usize, 1u8, {
let random_access: u8 = unsafe { ::std::mem::transmute(random_access) };
random_access as u64
});
__bindgen_bitfield_unit.set(7usize, 1u8, {
let discontinued: u8 = unsafe { ::std::mem::transmute(discontinued) };
discontinued as u64
});
__bindgen_bitfield_unit
}
}
#[test]
fn bindgen_test_layout_dvb_ts_packet_header() {
assert_eq!(
::std::mem::size_of::<dvb_ts_packet_header>(),
6usize,
concat!("Size of: ", stringify!(dvb_ts_packet_header))
);
assert_eq!(
::std::mem::align_of::<dvb_ts_packet_header>(),
1usize,
concat!("Alignment of ", stringify!(dvb_ts_packet_header))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_ts_packet_header>())).sync_byte as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_ts_packet_header),
"::",
stringify!(sync_byte)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_ts_packet_header>())).adaptation_field_length as *const _
as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(dvb_ts_packet_header),
"::",
stringify!(adaptation_field_length)
)
);
}
impl dvb_ts_packet_header {
#[inline]
pub fn continuity_counter(&self) -> u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u8) }
}
#[inline]
pub fn set_continuity_counter(&mut self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 4u8, val as u64)
}
}
#[inline]
pub fn adaptation_field_control(&self) -> u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 2u8) as u8) }
}
#[inline]
pub fn set_adaptation_field_control(&mut self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(4usize, 2u8, val as u64)
}
}
#[inline]
pub fn transport_scrambling_control(&self) -> u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 2u8) as u8) }
}
#[inline]
pub fn set_transport_scrambling_control(&mut self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(6usize, 2u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(
continuity_counter: u8,
adaptation_field_control: u8,
transport_scrambling_control: u8,
) -> __BindgenBitfieldUnit<[u8; 1usize], u8> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize], u8> =
Default::default();
__bindgen_bitfield_unit.set(0usize, 4u8, {
let continuity_counter: u8 = unsafe { ::std::mem::transmute(continuity_counter) };
continuity_counter as u64
});
__bindgen_bitfield_unit.set(4usize, 2u8, {
let adaptation_field_control: u8 =
unsafe { ::std::mem::transmute(adaptation_field_control) };
adaptation_field_control as u64
});
__bindgen_bitfield_unit.set(6usize, 2u8, {
let transport_scrambling_control: u8 =
unsafe { ::std::mem::transmute(transport_scrambling_control) };
transport_scrambling_control as u64
});
__bindgen_bitfield_unit
}
}
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub struct dvb_table_header {
pub table_id: u8,
pub __bindgen_anon_1: dvb_table_header__bindgen_ty_1,
pub id: u16,
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize], u8>,
pub section_id: u8,
pub last_section: u8,
}
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub union dvb_table_header__bindgen_ty_1 {
pub bitfield: u16,
pub __bindgen_anon_1: dvb_table_header__bindgen_ty_1__bindgen_ty_1,
_bindgen_union_align: [u8; 2usize],
}
#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct dvb_table_header__bindgen_ty_1__bindgen_ty_1 {
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize], u8>,
}
#[test]
fn bindgen_test_layout_dvb_table_header__bindgen_ty_1__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<dvb_table_header__bindgen_ty_1__bindgen_ty_1>(),
2usize,
concat!(
"Size of: ",
stringify!(dvb_table_header__bindgen_ty_1__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<dvb_table_header__bindgen_ty_1__bindgen_ty_1>(),
1usize,
concat!(
"Alignment of ",
stringify!(dvb_table_header__bindgen_ty_1__bindgen_ty_1)
)
);
}
impl dvb_table_header__bindgen_ty_1__bindgen_ty_1 {
#[inline]
pub fn section_length(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 12u8) as u16) }
}
#[inline]
pub fn set_section_length(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 12u8, val as u64)
}
}
#[inline]
pub fn one(&self) -> u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 2u8) as u8) }
}
#[inline]
pub fn set_one(&mut self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(12usize, 2u8, val as u64)
}
}
#[inline]
pub fn zero(&self) -> u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u8) }
}
#[inline]
pub fn set_zero(&mut self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(14usize, 1u8, val as u64)
}
}
#[inline]
pub fn syntax(&self) -> u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u8) }
}
#[inline]
pub fn set_syntax(&mut self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(15usize, 1u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(
section_length: u16,
one: u8,
zero: u8,
syntax: u8,
) -> __BindgenBitfieldUnit<[u8; 2usize], u8> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize], u8> =
Default::default();
__bindgen_bitfield_unit.set(0usize, 12u8, {
let section_length: u16 = unsafe { ::std::mem::transmute(section_length) };
section_length as u64
});
__bindgen_bitfield_unit.set(12usize, 2u8, {
let one: u8 = unsafe { ::std::mem::transmute(one) };
one as u64
});
__bindgen_bitfield_unit.set(14usize, 1u8, {
let zero: u8 = unsafe { ::std::mem::transmute(zero) };
zero as u64
});
__bindgen_bitfield_unit.set(15usize, 1u8, {
let syntax: u8 = unsafe { ::std::mem::transmute(syntax) };
syntax as u64
});
__bindgen_bitfield_unit
}
}
#[test]
fn bindgen_test_layout_dvb_table_header__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<dvb_table_header__bindgen_ty_1>(),
2usize,
concat!("Size of: ", stringify!(dvb_table_header__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<dvb_table_header__bindgen_ty_1>(),
1usize,
concat!("Alignment of ", stringify!(dvb_table_header__bindgen_ty_1))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_table_header__bindgen_ty_1>())).bitfield as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_table_header__bindgen_ty_1),
"::",
stringify!(bitfield)
)
);
}
#[test]
fn bindgen_test_layout_dvb_table_header() {
assert_eq!(
::std::mem::size_of::<dvb_table_header>(),
8usize,
concat!("Size of: ", stringify!(dvb_table_header))
);
assert_eq!(
::std::mem::align_of::<dvb_table_header>(),
1usize,
concat!("Alignment of ", stringify!(dvb_table_header))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_table_header>())).table_id as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_table_header),
"::",
stringify!(table_id)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_table_header>())).id as *const _ as usize },
3usize,
concat!(
"Offset of field: ",
stringify!(dvb_table_header),
"::",
stringify!(id)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_table_header>())).section_id as *const _ as usize },
6usize,
concat!(
"Offset of field: ",
stringify!(dvb_table_header),
"::",
stringify!(section_id)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_table_header>())).last_section as *const _ as usize },
7usize,
concat!(
"Offset of field: ",
stringify!(dvb_table_header),
"::",
stringify!(last_section)
)
);
}
impl dvb_table_header {
#[inline]
pub fn current_next(&self) -> u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
}
#[inline]
pub fn set_current_next(&mut self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 1u8, val as u64)
}
}
#[inline]
pub fn version(&self) -> u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 5u8) as u8) }
}
#[inline]
pub fn set_version(&mut self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(1usize, 5u8, val as u64)
}
}
#[inline]
pub fn one2(&self) -> u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 2u8) as u8) }
}
#[inline]
pub fn set_one2(&mut self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(6usize, 2u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(
current_next: u8,
version: u8,
one2: u8,
) -> __BindgenBitfieldUnit<[u8; 1usize], u8> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize], u8> =
Default::default();
__bindgen_bitfield_unit.set(0usize, 1u8, {
let current_next: u8 = unsafe { ::std::mem::transmute(current_next) };
current_next as u64
});
__bindgen_bitfield_unit.set(1usize, 5u8, {
let version: u8 = unsafe { ::std::mem::transmute(version) };
version as u64
});
__bindgen_bitfield_unit.set(6usize, 2u8, {
let one2: u8 = unsafe { ::std::mem::transmute(one2) };
one2 as u64
});
__bindgen_bitfield_unit
}
}
extern "C" {
pub fn dvb_table_header_init(header: *mut dvb_table_header);
}
extern "C" {
pub fn dvb_table_header_print(parms: *mut dvb_v5_fe_parms, header: *const dvb_table_header);
}
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub struct atsc_table_eit_event {
pub __bindgen_anon_1: atsc_table_eit_event__bindgen_ty_1,
pub start_time: u32,
pub __bindgen_anon_2: atsc_table_eit_event__bindgen_ty_2,
pub descriptor: *mut dvb_desc,
pub next: *mut atsc_table_eit_event,
pub start: tm,
pub source_id: u16,
}
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub union atsc_table_eit_event__bindgen_ty_1 {
pub bitfield: u16,
pub __bindgen_anon_1: atsc_table_eit_event__bindgen_ty_1__bindgen_ty_1,
_bindgen_union_align: [u8; 2usize],
}
#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct atsc_table_eit_event__bindgen_ty_1__bindgen_ty_1 {
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize], u8>,
}
#[test]
fn bindgen_test_layout_atsc_table_eit_event__bindgen_ty_1__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<atsc_table_eit_event__bindgen_ty_1__bindgen_ty_1>(),
2usize,
concat!(
"Size of: ",
stringify!(atsc_table_eit_event__bindgen_ty_1__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<atsc_table_eit_event__bindgen_ty_1__bindgen_ty_1>(),
1usize,
concat!(
"Alignment of ",
stringify!(atsc_table_eit_event__bindgen_ty_1__bindgen_ty_1)
)
);
}
impl atsc_table_eit_event__bindgen_ty_1__bindgen_ty_1 {
#[inline]
pub fn event_id(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 14u8) as u16) }
}
#[inline]
pub fn set_event_id(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 14u8, val as u64)
}
}
#[inline]
pub fn one(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 2u8) as u16) }
}
#[inline]
pub fn set_one(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(14usize, 2u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(event_id: u16, one: u16) -> __BindgenBitfieldUnit<[u8; 2usize], u8> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize], u8> =
Default::default();
__bindgen_bitfield_unit.set(0usize, 14u8, {
let event_id: u16 = unsafe { ::std::mem::transmute(event_id) };
event_id as u64
});
__bindgen_bitfield_unit.set(14usize, 2u8, {
let one: u16 = unsafe { ::std::mem::transmute(one) };
one as u64
});
__bindgen_bitfield_unit
}
}
#[test]
fn bindgen_test_layout_atsc_table_eit_event__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<atsc_table_eit_event__bindgen_ty_1>(),
2usize,
concat!("Size of: ", stringify!(atsc_table_eit_event__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<atsc_table_eit_event__bindgen_ty_1>(),
1usize,
concat!(
"Alignment of ",
stringify!(atsc_table_eit_event__bindgen_ty_1)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<atsc_table_eit_event__bindgen_ty_1>())).bitfield as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(atsc_table_eit_event__bindgen_ty_1),
"::",
stringify!(bitfield)
)
);
}
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub union atsc_table_eit_event__bindgen_ty_2 {
pub bitfield2: u32,
pub __bindgen_anon_1: atsc_table_eit_event__bindgen_ty_2__bindgen_ty_1,
_bindgen_union_align: [u8; 5usize],
}
#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct atsc_table_eit_event__bindgen_ty_2__bindgen_ty_1 {
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 5usize], u8>,
}
#[test]
fn bindgen_test_layout_atsc_table_eit_event__bindgen_ty_2__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<atsc_table_eit_event__bindgen_ty_2__bindgen_ty_1>(),
5usize,
concat!(
"Size of: ",
stringify!(atsc_table_eit_event__bindgen_ty_2__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<atsc_table_eit_event__bindgen_ty_2__bindgen_ty_1>(),
1usize,
concat!(
"Alignment of ",
stringify!(atsc_table_eit_event__bindgen_ty_2__bindgen_ty_1)
)
);
}
impl atsc_table_eit_event__bindgen_ty_2__bindgen_ty_1 {
#[inline]
pub fn title_length(&self) -> u32 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 8u8) as u32) }
}
#[inline]
pub fn set_title_length(&mut self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 8u8, val as u64)
}
}
#[inline]
pub fn duration(&self) -> u32 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 20u8) as u32) }
}
#[inline]
pub fn set_duration(&mut self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(8usize, 20u8, val as u64)
}
}
#[inline]
pub fn etm(&self) -> u32 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(28usize, 2u8) as u32) }
}
#[inline]
pub fn set_etm(&mut self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(28usize, 2u8, val as u64)
}
}
#[inline]
pub fn one2(&self) -> u32 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(30usize, 2u8) as u32) }
}
#[inline]
pub fn set_one2(&mut self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(30usize, 2u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(
title_length: u32,
duration: u32,
etm: u32,
one2: u32,
) -> __BindgenBitfieldUnit<[u8; 5usize], u8> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 5usize], u8> =
Default::default();
__bindgen_bitfield_unit.set(0usize, 8u8, {
let title_length: u32 = unsafe { ::std::mem::transmute(title_length) };
title_length as u64
});
__bindgen_bitfield_unit.set(8usize, 20u8, {
let duration: u32 = unsafe { ::std::mem::transmute(duration) };
duration as u64
});
__bindgen_bitfield_unit.set(28usize, 2u8, {
let etm: u32 = unsafe { ::std::mem::transmute(etm) };
etm as u64
});
__bindgen_bitfield_unit.set(30usize, 2u8, {
let one2: u32 = unsafe { ::std::mem::transmute(one2) };
one2 as u64
});
__bindgen_bitfield_unit
}
}
#[test]
fn bindgen_test_layout_atsc_table_eit_event__bindgen_ty_2() {
assert_eq!(
::std::mem::size_of::<atsc_table_eit_event__bindgen_ty_2>(),
5usize,
concat!("Size of: ", stringify!(atsc_table_eit_event__bindgen_ty_2))
);
assert_eq!(
::std::mem::align_of::<atsc_table_eit_event__bindgen_ty_2>(),
1usize,
concat!(
"Alignment of ",
stringify!(atsc_table_eit_event__bindgen_ty_2)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<atsc_table_eit_event__bindgen_ty_2>())).bitfield2 as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(atsc_table_eit_event__bindgen_ty_2),
"::",
stringify!(bitfield2)
)
);
}
#[test]
fn bindgen_test_layout_atsc_table_eit_event() {
assert_eq!(
::std::mem::size_of::<atsc_table_eit_event>(),
85usize,
concat!("Size of: ", stringify!(atsc_table_eit_event))
);
assert_eq!(
::std::mem::align_of::<atsc_table_eit_event>(),
1usize,
concat!("Alignment of ", stringify!(atsc_table_eit_event))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<atsc_table_eit_event>())).start_time as *const _ as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(atsc_table_eit_event),
"::",
stringify!(start_time)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<atsc_table_eit_event>())).descriptor as *const _ as usize },
11usize,
concat!(
"Offset of field: ",
stringify!(atsc_table_eit_event),
"::",
stringify!(descriptor)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<atsc_table_eit_event>())).next as *const _ as usize },
19usize,
concat!(
"Offset of field: ",
stringify!(atsc_table_eit_event),
"::",
stringify!(next)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<atsc_table_eit_event>())).start as *const _ as usize },
27usize,
concat!(
"Offset of field: ",
stringify!(atsc_table_eit_event),
"::",
stringify!(start)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<atsc_table_eit_event>())).source_id as *const _ as usize },
83usize,
concat!(
"Offset of field: ",
stringify!(atsc_table_eit_event),
"::",
stringify!(source_id)
)
);
}
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub union atsc_table_eit_desc_length {
pub bitfield: u16,
pub __bindgen_anon_1: atsc_table_eit_desc_length__bindgen_ty_1,
_bindgen_union_align: [u8; 2usize],
}
#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct atsc_table_eit_desc_length__bindgen_ty_1 {
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize], u8>,
}
#[test]
fn bindgen_test_layout_atsc_table_eit_desc_length__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<atsc_table_eit_desc_length__bindgen_ty_1>(),
2usize,
concat!(
"Size of: ",
stringify!(atsc_table_eit_desc_length__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<atsc_table_eit_desc_length__bindgen_ty_1>(),
1usize,
concat!(
"Alignment of ",
stringify!(atsc_table_eit_desc_length__bindgen_ty_1)
)
);
}
impl atsc_table_eit_desc_length__bindgen_ty_1 {
#[inline]
pub fn desc_length(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 12u8) as u16) }
}
#[inline]
pub fn set_desc_length(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 12u8, val as u64)
}
}
#[inline]
pub fn reserved(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 4u8) as u16) }
}
#[inline]
pub fn set_reserved(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(12usize, 4u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(
desc_length: u16,
reserved: u16,
) -> __BindgenBitfieldUnit<[u8; 2usize], u8> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize], u8> =
Default::default();
__bindgen_bitfield_unit.set(0usize, 12u8, {
let desc_length: u16 = unsafe { ::std::mem::transmute(desc_length) };
desc_length as u64
});
__bindgen_bitfield_unit.set(12usize, 4u8, {
let reserved: u16 = unsafe { ::std::mem::transmute(reserved) };
reserved as u64
});
__bindgen_bitfield_unit
}
}
#[test]
fn bindgen_test_layout_atsc_table_eit_desc_length() {
assert_eq!(
::std::mem::size_of::<atsc_table_eit_desc_length>(),
2usize,
concat!("Size of: ", stringify!(atsc_table_eit_desc_length))
);
assert_eq!(
::std::mem::align_of::<atsc_table_eit_desc_length>(),
1usize,
concat!("Alignment of ", stringify!(atsc_table_eit_desc_length))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<atsc_table_eit_desc_length>())).bitfield as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(atsc_table_eit_desc_length),
"::",
stringify!(bitfield)
)
);
}
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub struct atsc_table_eit {
pub header: dvb_table_header,
pub protocol_version: u8,
pub events: u8,
pub event: *mut atsc_table_eit_event,
}
#[test]
fn bindgen_test_layout_atsc_table_eit() {
assert_eq!(
::std::mem::size_of::<atsc_table_eit>(),
18usize,
concat!("Size of: ", stringify!(atsc_table_eit))
);
assert_eq!(
::std::mem::align_of::<atsc_table_eit>(),
1usize,
concat!("Alignment of ", stringify!(atsc_table_eit))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<atsc_table_eit>())).header as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(atsc_table_eit),
"::",
stringify!(header)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<atsc_table_eit>())).protocol_version as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(atsc_table_eit),
"::",
stringify!(protocol_version)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<atsc_table_eit>())).events as *const _ as usize },
9usize,
concat!(
"Offset of field: ",
stringify!(atsc_table_eit),
"::",
stringify!(events)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<atsc_table_eit>())).event as *const _ as usize },
10usize,
concat!(
"Offset of field: ",
stringify!(atsc_table_eit),
"::",
stringify!(event)
)
);
}
extern "C" {
pub fn atsc_table_eit_init(
parms: *mut dvb_v5_fe_parms,
buf: *const u8,
buflen: ssize_t,
table: *mut *mut atsc_table_eit,
) -> ssize_t;
}
extern "C" {
pub fn atsc_table_eit_free(table: *mut atsc_table_eit);
}
extern "C" {
pub fn atsc_table_eit_print(parms: *mut dvb_v5_fe_parms, table: *mut atsc_table_eit);
}
extern "C" {
pub fn atsc_time(start_time: u32, tm: *mut tm);
}
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub struct dvb_table_cat {
pub header: dvb_table_header,
pub descriptor: *mut dvb_desc,
}
#[test]
fn bindgen_test_layout_dvb_table_cat() {
assert_eq!(
::std::mem::size_of::<dvb_table_cat>(),
16usize,
concat!("Size of: ", stringify!(dvb_table_cat))
);
assert_eq!(
::std::mem::align_of::<dvb_table_cat>(),
1usize,
concat!("Alignment of ", stringify!(dvb_table_cat))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_table_cat>())).header as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_table_cat),
"::",
stringify!(header)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_table_cat>())).descriptor as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(dvb_table_cat),
"::",
stringify!(descriptor)
)
);
}
extern "C" {
pub fn dvb_table_cat_init(
parms: *mut dvb_v5_fe_parms,
buf: *const u8,
buflen: ssize_t,
table: *mut *mut dvb_table_cat,
) -> ssize_t;
}
extern "C" {
pub fn dvb_table_cat_free(table: *mut dvb_table_cat);
}
extern "C" {
pub fn dvb_table_cat_print(parms: *mut dvb_v5_fe_parms, table: *mut dvb_table_cat);
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum dvb_country_t {
COUNTRY_UNKNOWN = 0,
AD = 1,
AE = 2,
AF = 3,
AG = 4,
AI = 5,
AL = 6,
AM = 7,
AO = 8,
AQ = 9,
AR = 10,
AS = 11,
AT = 12,
AU = 13,
AW = 14,
AX = 15,
AZ = 16,
BA = 17,
BB = 18,
BD = 19,
BE = 20,
BF = 21,
BG = 22,
BH = 23,
BI = 24,
BJ = 25,
BL = 26,
BM = 27,
BN = 28,
BO = 29,
BQ = 30,
BR = 31,
BS = 32,
BT = 33,
BV = 34,
BW = 35,
BY = 36,
BZ = 37,
CA = 38,
CC = 39,
CD = 40,
CF = 41,
CG = 42,
CH = 43,
CI = 44,
CK = 45,
CL = 46,
CM = 47,
CN = 48,
CO = 49,
CR = 50,
CU = 51,
CV = 52,
CW = 53,
CX = 54,
CY = 55,
CZ = 56,
DE = 57,
DJ = 58,
DK = 59,
DM = 60,
DO = 61,
DZ = 62,
EC = 63,
EE = 64,
EG = 65,
EH = 66,
ER = 67,
ES = 68,
ET = 69,
FI = 70,
FJ = 71,
FK = 72,
FM = 73,
FO = 74,
FR = 75,
GA = 76,
GB = 77,
GD = 78,
GE = 79,
GF = 80,
GG = 81,
GH = 82,
GI = 83,
GL = 84,
GM = 85,
GN = 86,
GP = 87,
GQ = 88,
GR = 89,
GS = 90,
GT = 91,
GU = 92,
GW = 93,
GY = 94,
HK = 95,
HM = 96,
HN = 97,
HR = 98,
HT = 99,
HU = 100,
ID = 101,
IE = 102,
IL = 103,
IM = 104,
IN = 105,
IO = 106,
IQ = 107,
IR = 108,
IS = 109,
IT = 110,
JE = 111,
JM = 112,
JO = 113,
JP = 114,
KE = 115,
KG = 116,
KH = 117,
KI = 118,
KM = 119,
KN = 120,
KP = 121,
KR = 122,
KW = 123,
KY = 124,
KZ = 125,
LA = 126,
LB = 127,
LC = 128,
LI = 129,
LK = 130,
LR = 131,
LS = 132,
LT = 133,
LU = 134,
LV = 135,
LY = 136,
MA = 137,
MC = 138,
MD = 139,
ME = 140,
MF = 141,
MG = 142,
MH = 143,
MK = 144,
ML = 145,
MM = 146,
MN = 147,
MO = 148,
MP = 149,
MQ = 150,
MR = 151,
MS = 152,
MT = 153,
MU = 154,
MV = 155,
MW = 156,
MX = 157,
MY = 158,
MZ = 159,
NA = 160,
NC = 161,
NE = 162,
NF = 163,
NG = 164,
NI = 165,
NL = 166,
NO = 167,
NP = 168,
NR = 169,
NU = 170,
NZ = 171,
OM = 172,
PA = 173,
PE = 174,
PF = 175,
PG = 176,
PH = 177,
PK = 178,
PL = 179,
PM = 180,
PN = 181,
PR = 182,
PS = 183,
PT = 184,
PW = 185,
PY = 186,
QA = 187,
RE = 188,
RO = 189,
RS = 190,
RU = 191,
RW = 192,
SA = 193,
SB = 194,
SC = 195,
SD = 196,
SE = 197,
SG = 198,
SH = 199,
SI = 200,
SJ = 201,
SK = 202,
SL = 203,
SM = 204,
SN = 205,
SO = 206,
SR = 207,
SS = 208,
ST = 209,
SV = 210,
SX = 211,
SY = 212,
SZ = 213,
TC = 214,
TD = 215,
TF = 216,
TG = 217,
TH = 218,
TJ = 219,
TK = 220,
TL = 221,
TM = 222,
TN = 223,
TO = 224,
TR = 225,
TT = 226,
TV = 227,
TW = 228,
TZ = 229,
UA = 230,
UG = 231,
UM = 232,
US = 233,
UY = 234,
UZ = 235,
VA = 236,
VC = 237,
VE = 238,
VG = 239,
VI = 240,
VN = 241,
VU = 242,
WF = 243,
WS = 244,
YE = 245,
YT = 246,
ZA = 247,
ZM = 248,
ZW = 249,
}
extern "C" {
pub fn dvb_country_a2_to_id(name: *const ::std::os::raw::c_char) -> dvb_country_t;
}
extern "C" {
pub fn dvb_country_a3_to_id(name: *const ::std::os::raw::c_char) -> dvb_country_t;
}
extern "C" {
pub fn dvb_country_to_2letters(id: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn dvb_country_to_3letters(id: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn dvb_country_to_name(id: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn dvb_guess_user_country() -> dvb_country_t;
}
extern "C" {
pub fn dvb_crc32(data: *mut u8, datalen: size_t, crc: u32) -> u32;
}
pub type dvb_table_init_func = ::std::option::Option<
unsafe extern "C" fn(
parms: *mut dvb_v5_fe_parms,
buf: *const u8,
buflen: ssize_t,
table: *mut *mut ::std::os::raw::c_void,
),
>;
extern "C" {
pub static dvb_table_initializers: [dvb_table_init_func; 256usize];
}
#[repr(C, packed)]
#[derive(Debug)]
pub struct dvb_desc {
pub type_: u8,
pub length: u8,
pub next: *mut dvb_desc,
pub data: __IncompleteArrayField<u8>,
}
#[test]
fn bindgen_test_layout_dvb_desc() {
assert_eq!(
::std::mem::size_of::<dvb_desc>(),
10usize,
concat!("Size of: ", stringify!(dvb_desc))
);
assert_eq!(
::std::mem::align_of::<dvb_desc>(),
1usize,
concat!("Alignment of ", stringify!(dvb_desc))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_desc>())).type_ as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_desc>())).length as *const _ as usize },
1usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc),
"::",
stringify!(length)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_desc>())).next as *const _ as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc),
"::",
stringify!(next)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_desc>())).data as *const _ as usize },
10usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc),
"::",
stringify!(data)
)
);
}
extern "C" {
pub fn dvb_bcd(bcd: u32) -> u32;
}
extern "C" {
pub fn dvb_hexdump(
parms: *mut dvb_v5_fe_parms,
prefix: *const ::std::os::raw::c_char,
buf: *const ::std::os::raw::c_uchar,
len: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn dvb_desc_parse(
parms: *mut dvb_v5_fe_parms,
buf: *const u8,
buflen: u16,
head_desc: *mut *mut dvb_desc,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dvb_desc_free(list: *mut *mut dvb_desc);
}
extern "C" {
pub fn dvb_desc_print(parms: *mut dvb_v5_fe_parms, desc: *mut dvb_desc);
}
pub type dvb_desc_init_func = ::std::option::Option<
unsafe extern "C" fn(
parms: *mut dvb_v5_fe_parms,
buf: *const u8,
desc: *mut dvb_desc,
) -> ::std::os::raw::c_int,
>;
pub type dvb_desc_print_func =
::std::option::Option<unsafe extern "C" fn(parms: *mut dvb_v5_fe_parms, desc: *const dvb_desc)>;
pub type dvb_desc_free_func = ::std::option::Option<unsafe extern "C" fn(desc: *mut dvb_desc)>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dvb_descriptor {
pub name: *const ::std::os::raw::c_char,
pub init: dvb_desc_init_func,
pub print: dvb_desc_print_func,
pub free: dvb_desc_free_func,
pub size: ssize_t,
}
#[test]
fn bindgen_test_layout_dvb_descriptor() {
assert_eq!(
::std::mem::size_of::<dvb_descriptor>(),
40usize,
concat!("Size of: ", stringify!(dvb_descriptor))
);
assert_eq!(
::std::mem::align_of::<dvb_descriptor>(),
8usize,
concat!("Alignment of ", stringify!(dvb_descriptor))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_descriptor>())).name as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_descriptor),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_descriptor>())).init as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(dvb_descriptor),
"::",
stringify!(init)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_descriptor>())).print as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(dvb_descriptor),
"::",
stringify!(print)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_descriptor>())).free as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(dvb_descriptor),
"::",
stringify!(free)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_descriptor>())).size as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(dvb_descriptor),
"::",
stringify!(size)
)
);
}
extern "C" {
pub static mut dvb_descriptors: [dvb_descriptor; 0usize];
}
impl descriptors {
pub const atsc_extended_channel_descriptor: descriptors = descriptors::extended_channel_name;
}
impl descriptors {
pub const atsc_service_location_descriptor: descriptors = descriptors::service_location;
}
impl descriptors {
pub const atsc_component_name_descriptor: descriptors = descriptors::component_name_descriptor;
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum descriptors {
video_stream_descriptor = 2,
audio_stream_descriptor = 3,
hierarchy_descriptor = 4,
registration_descriptor = 5,
ds_alignment_descriptor = 6,
target_background_grid_descriptor = 7,
video_window_descriptor = 8,
conditional_access_descriptor = 9,
iso639_language_descriptor = 10,
system_clock_descriptor = 11,
multiplex_buffer_utilization_descriptor = 12,
copyright_descriptor = 13,
maximum_bitrate_descriptor = 14,
private_data_indicator_descriptor = 15,
smoothing_buffer_descriptor = 16,
std_descriptor = 17,
ibp_descriptor = 18,
mpeg4_video_descriptor = 27,
mpeg4_audio_descriptor = 28,
iod_descriptor = 29,
sl_descriptor = 30,
fmc_descriptor = 31,
external_es_id_descriptor = 32,
muxcode_descriptor = 33,
fmxbuffersize_descriptor = 34,
multiplexbuffer_descriptor = 35,
content_labeling_descriptor = 36,
metadata_pointer_descriptor = 37,
metadata_descriptor = 38,
metadata_std_descriptor = 39,
AVC_video_descriptor = 40,
ipmp_descriptor = 41,
AVC_timing_and_HRD_descriptor = 42,
mpeg2_aac_audio_descriptor = 43,
flexmux_timing_descriptor = 44,
network_name_descriptor = 64,
service_list_descriptor = 65,
stuffing_descriptor = 66,
satellite_delivery_system_descriptor = 67,
cable_delivery_system_descriptor = 68,
VBI_data_descriptor = 69,
VBI_teletext_descriptor = 70,
bouquet_name_descriptor = 71,
service_descriptor = 72,
country_availability_descriptor = 73,
linkage_descriptor = 74,
NVOD_reference_descriptor = 75,
time_shifted_service_descriptor = 76,
short_event_descriptor = 77,
extended_event_descriptor = 78,
time_shifted_event_descriptor = 79,
component_descriptor = 80,
mosaic_descriptor = 81,
stream_identifier_descriptor = 82,
CA_identifier_descriptor = 83,
content_descriptor = 84,
parental_rating_descriptor = 85,
teletext_descriptor = 86,
telephone_descriptor = 87,
local_time_offset_descriptor = 88,
subtitling_descriptor = 89,
terrestrial_delivery_system_descriptor = 90,
multilingual_network_name_descriptor = 91,
multilingual_bouquet_name_descriptor = 92,
multilingual_service_name_descriptor = 93,
multilingual_component_descriptor = 94,
private_data_specifier_descriptor = 95,
service_move_descriptor = 96,
short_smoothing_buffer_descriptor = 97,
frequency_list_descriptor = 98,
partial_transport_stream_descriptor = 99,
data_broadcast_descriptor = 100,
scrambling_descriptor = 101,
data_broadcast_id_descriptor = 102,
transport_stream_descriptor = 103,
DSNG_descriptor = 104,
PDC_descriptor = 105,
AC_3_descriptor = 106,
ancillary_data_descriptor = 107,
cell_list_descriptor = 108,
cell_frequency_link_descriptor = 109,
announcement_support_descriptor = 110,
application_signalling_descriptor = 111,
adaptation_field_data_descriptor = 112,
service_identifier_descriptor = 113,
service_availability_descriptor = 114,
default_authority_descriptor = 115,
related_content_descriptor = 116,
TVA_id_descriptor = 117,
content_identifier_descriptor = 118,
time_slice_fec_identifier_descriptor = 119,
ECM_repetition_rate_descriptor = 120,
S2_satellite_delivery_system_descriptor = 121,
enhanced_AC_3_descriptor = 122,
DTS_descriptor = 123,
AAC_descriptor = 124,
XAIT_location_descriptor = 125,
FTA_content_management_descriptor = 126,
extension_descriptor = 127,
CUE_identifier_descriptor = 138,
extended_channel_name = 160,
service_location = 161,
component_name_descriptor = 163,
logical_channel_number_descriptor = 131,
carousel_id_descriptor = 19,
association_tag_descriptor = 20,
deferred_association_tags_descriptor = 21,
hierarchical_transmission_descriptor = 192,
digital_copy_control_descriptor = 193,
network_identifier_descriptor = 194,
partial_transport_stream_time_descriptor = 195,
audio_component_descriptor = 196,
hyperlink_descriptor = 197,
target_area_descriptor = 198,
data_contents_descriptor = 199,
video_decode_control_descriptor = 200,
download_content_descriptor = 201,
CA_EMM_TS_descriptor = 202,
CA_contract_information_descriptor = 203,
CA_service_descriptor = 204,
TS_Information_descriptior = 205,
extended_broadcaster_descriptor = 206,
logo_transmission_descriptor = 207,
basic_local_event_descriptor = 208,
reference_descriptor = 209,
node_relation_descriptor = 210,
short_node_information_descriptor = 211,
STC_reference_descriptor = 212,
series_descriptor = 213,
event_group_descriptor = 214,
SI_parameter_descriptor = 215,
broadcaster_Name_Descriptor = 216,
component_group_descriptor = 217,
SI_prime_TS_descriptor = 218,
board_information_descriptor = 219,
LDT_linkage_descriptor = 220,
connected_transmission_descriptor = 221,
content_availability_descriptor = 222,
service_group_descriptor = 224,
carousel_compatible_composite_descriptor = 247,
conditional_playback_descriptor = 248,
ISDBT_delivery_system_descriptor = 250,
partial_reception_descriptor = 251,
emergency_information_descriptor = 252,
data_component_descriptor = 253,
system_management_descriptor = 254,
atsc_stuffing_descriptor = 128,
atsc_ac3_audio_descriptor = 129,
atsc_caption_service_descriptor = 134,
atsc_content_advisory_descriptor = 135,
atsc_time_shifted_service_descriptor = 162,
atsc_DCC_departing_request_descriptor = 168,
atsc_DCC_arriving_request_descriptor = 169,
atsc_redistribution_control_descriptor = 170,
atsc_ATSC_private_information_descriptor = 173,
atsc_genre_descriptor = 171,
}
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub struct atsc_desc_service_location_elementary {
pub stream_type: u8,
pub __bindgen_anon_1: atsc_desc_service_location_elementary__bindgen_ty_1,
pub ISO_639_language_code: [::std::os::raw::c_char; 3usize],
}
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub union atsc_desc_service_location_elementary__bindgen_ty_1 {
pub bitfield: u16,
pub __bindgen_anon_1: atsc_desc_service_location_elementary__bindgen_ty_1__bindgen_ty_1,
_bindgen_union_align: [u8; 2usize],
}
#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct atsc_desc_service_location_elementary__bindgen_ty_1__bindgen_ty_1 {
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize], u8>,
}
#[test]
fn bindgen_test_layout_atsc_desc_service_location_elementary__bindgen_ty_1__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<atsc_desc_service_location_elementary__bindgen_ty_1__bindgen_ty_1>(),
2usize,
concat!(
"Size of: ",
stringify!(atsc_desc_service_location_elementary__bindgen_ty_1__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<atsc_desc_service_location_elementary__bindgen_ty_1__bindgen_ty_1>(),
1usize,
concat!(
"Alignment of ",
stringify!(atsc_desc_service_location_elementary__bindgen_ty_1__bindgen_ty_1)
)
);
}
impl atsc_desc_service_location_elementary__bindgen_ty_1__bindgen_ty_1 {
#[inline]
pub fn elementary_pid(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 13u8) as u16) }
}
#[inline]
pub fn set_elementary_pid(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 13u8, val as u64)
}
}
#[inline]
pub fn reserved(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 3u8) as u16) }
}
#[inline]
pub fn set_reserved(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(13usize, 3u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(
elementary_pid: u16,
reserved: u16,
) -> __BindgenBitfieldUnit<[u8; 2usize], u8> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize], u8> =
Default::default();
__bindgen_bitfield_unit.set(0usize, 13u8, {
let elementary_pid: u16 = unsafe { ::std::mem::transmute(elementary_pid) };
elementary_pid as u64
});
__bindgen_bitfield_unit.set(13usize, 3u8, {
let reserved: u16 = unsafe { ::std::mem::transmute(reserved) };
reserved as u64
});
__bindgen_bitfield_unit
}
}
#[test]
fn bindgen_test_layout_atsc_desc_service_location_elementary__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<atsc_desc_service_location_elementary__bindgen_ty_1>(),
2usize,
concat!(
"Size of: ",
stringify!(atsc_desc_service_location_elementary__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<atsc_desc_service_location_elementary__bindgen_ty_1>(),
1usize,
concat!(
"Alignment of ",
stringify!(atsc_desc_service_location_elementary__bindgen_ty_1)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<atsc_desc_service_location_elementary__bindgen_ty_1>())).bitfield
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(atsc_desc_service_location_elementary__bindgen_ty_1),
"::",
stringify!(bitfield)
)
);
}
#[test]
fn bindgen_test_layout_atsc_desc_service_location_elementary() {
assert_eq!(
::std::mem::size_of::<atsc_desc_service_location_elementary>(),
6usize,
concat!(
"Size of: ",
stringify!(atsc_desc_service_location_elementary)
)
);
assert_eq!(
::std::mem::align_of::<atsc_desc_service_location_elementary>(),
1usize,
concat!(
"Alignment of ",
stringify!(atsc_desc_service_location_elementary)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<atsc_desc_service_location_elementary>())).stream_type
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(atsc_desc_service_location_elementary),
"::",
stringify!(stream_type)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<atsc_desc_service_location_elementary>())).ISO_639_language_code
as *const _ as usize
},
3usize,
concat!(
"Offset of field: ",
stringify!(atsc_desc_service_location_elementary),
"::",
stringify!(ISO_639_language_code)
)
);
}
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub struct atsc_desc_service_location {
pub type_: u8,
pub length: u8,
pub next: *mut dvb_desc,
pub elementary: *mut atsc_desc_service_location_elementary,
pub __bindgen_anon_1: atsc_desc_service_location__bindgen_ty_1,
pub number_elements: u8,
}
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub union atsc_desc_service_location__bindgen_ty_1 {
pub bitfield: u16,
pub __bindgen_anon_1: atsc_desc_service_location__bindgen_ty_1__bindgen_ty_1,
_bindgen_union_align: [u8; 2usize],
}
#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct atsc_desc_service_location__bindgen_ty_1__bindgen_ty_1 {
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize], u8>,
}
#[test]
fn bindgen_test_layout_atsc_desc_service_location__bindgen_ty_1__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<atsc_desc_service_location__bindgen_ty_1__bindgen_ty_1>(),
2usize,
concat!(
"Size of: ",
stringify!(atsc_desc_service_location__bindgen_ty_1__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<atsc_desc_service_location__bindgen_ty_1__bindgen_ty_1>(),
1usize,
concat!(
"Alignment of ",
stringify!(atsc_desc_service_location__bindgen_ty_1__bindgen_ty_1)
)
);
}
impl atsc_desc_service_location__bindgen_ty_1__bindgen_ty_1 {
#[inline]
pub fn pcr_pid(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 13u8) as u16) }
}
#[inline]
pub fn set_pcr_pid(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 13u8, val as u64)
}
}
#[inline]
pub fn reserved(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 3u8) as u16) }
}
#[inline]
pub fn set_reserved(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(13usize, 3u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(pcr_pid: u16, reserved: u16) -> __BindgenBitfieldUnit<[u8; 2usize], u8> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize], u8> =
Default::default();
__bindgen_bitfield_unit.set(0usize, 13u8, {
let pcr_pid: u16 = unsafe { ::std::mem::transmute(pcr_pid) };
pcr_pid as u64
});
__bindgen_bitfield_unit.set(13usize, 3u8, {
let reserved: u16 = unsafe { ::std::mem::transmute(reserved) };
reserved as u64
});
__bindgen_bitfield_unit
}
}
#[test]
fn bindgen_test_layout_atsc_desc_service_location__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<atsc_desc_service_location__bindgen_ty_1>(),
2usize,
concat!(
"Size of: ",
stringify!(atsc_desc_service_location__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<atsc_desc_service_location__bindgen_ty_1>(),
1usize,
concat!(
"Alignment of ",
stringify!(atsc_desc_service_location__bindgen_ty_1)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<atsc_desc_service_location__bindgen_ty_1>())).bitfield
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(atsc_desc_service_location__bindgen_ty_1),
"::",
stringify!(bitfield)
)
);
}
#[test]
fn bindgen_test_layout_atsc_desc_service_location() {
assert_eq!(
::std::mem::size_of::<atsc_desc_service_location>(),
21usize,
concat!("Size of: ", stringify!(atsc_desc_service_location))
);
assert_eq!(
::std::mem::align_of::<atsc_desc_service_location>(),
1usize,
concat!("Alignment of ", stringify!(atsc_desc_service_location))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<atsc_desc_service_location>())).type_ as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(atsc_desc_service_location),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<atsc_desc_service_location>())).length as *const _ as usize
},
1usize,
concat!(
"Offset of field: ",
stringify!(atsc_desc_service_location),
"::",
stringify!(length)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<atsc_desc_service_location>())).next as *const _ as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(atsc_desc_service_location),
"::",
stringify!(next)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<atsc_desc_service_location>())).elementary as *const _ as usize
},
10usize,
concat!(
"Offset of field: ",
stringify!(atsc_desc_service_location),
"::",
stringify!(elementary)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<atsc_desc_service_location>())).number_elements as *const _
as usize
},
20usize,
concat!(
"Offset of field: ",
stringify!(atsc_desc_service_location),
"::",
stringify!(number_elements)
)
);
}
extern "C" {
pub fn atsc_desc_service_location_init(
parms: *mut dvb_v5_fe_parms,
buf: *const u8,
desc: *mut dvb_desc,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn atsc_desc_service_location_print(parms: *mut dvb_v5_fe_parms, desc: *const dvb_desc);
}
extern "C" {
pub fn atsc_desc_service_location_free(desc: *mut dvb_desc);
}
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub struct dvb_desc_cable_delivery {
pub type_: u8,
pub length: u8,
pub next: *mut dvb_desc,
pub frequency: u32,
pub __bindgen_anon_1: dvb_desc_cable_delivery__bindgen_ty_1,
pub modulation: u8,
pub __bindgen_anon_2: dvb_desc_cable_delivery__bindgen_ty_2,
}
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub union dvb_desc_cable_delivery__bindgen_ty_1 {
pub bitfield1: u16,
pub __bindgen_anon_1: dvb_desc_cable_delivery__bindgen_ty_1__bindgen_ty_1,
_bindgen_union_align: [u8; 2usize],
}
#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct dvb_desc_cable_delivery__bindgen_ty_1__bindgen_ty_1 {
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize], u8>,
}
#[test]
fn bindgen_test_layout_dvb_desc_cable_delivery__bindgen_ty_1__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<dvb_desc_cable_delivery__bindgen_ty_1__bindgen_ty_1>(),
2usize,
concat!(
"Size of: ",
stringify!(dvb_desc_cable_delivery__bindgen_ty_1__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<dvb_desc_cable_delivery__bindgen_ty_1__bindgen_ty_1>(),
1usize,
concat!(
"Alignment of ",
stringify!(dvb_desc_cable_delivery__bindgen_ty_1__bindgen_ty_1)
)
);
}
impl dvb_desc_cable_delivery__bindgen_ty_1__bindgen_ty_1 {
#[inline]
pub fn fec_outer(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u16) }
}
#[inline]
pub fn set_fec_outer(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 4u8, val as u64)
}
}
#[inline]
pub fn reserved_future_use(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 12u8) as u16) }
}
#[inline]
pub fn set_reserved_future_use(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(4usize, 12u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(
fec_outer: u16,
reserved_future_use: u16,
) -> __BindgenBitfieldUnit<[u8; 2usize], u8> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize], u8> =
Default::default();
__bindgen_bitfield_unit.set(0usize, 4u8, {
let fec_outer: u16 = unsafe { ::std::mem::transmute(fec_outer) };
fec_outer as u64
});
__bindgen_bitfield_unit.set(4usize, 12u8, {
let reserved_future_use: u16 = unsafe { ::std::mem::transmute(reserved_future_use) };
reserved_future_use as u64
});
__bindgen_bitfield_unit
}
}
#[test]
fn bindgen_test_layout_dvb_desc_cable_delivery__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<dvb_desc_cable_delivery__bindgen_ty_1>(),
2usize,
concat!(
"Size of: ",
stringify!(dvb_desc_cable_delivery__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<dvb_desc_cable_delivery__bindgen_ty_1>(),
1usize,
concat!(
"Alignment of ",
stringify!(dvb_desc_cable_delivery__bindgen_ty_1)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_desc_cable_delivery__bindgen_ty_1>())).bitfield1 as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_cable_delivery__bindgen_ty_1),
"::",
stringify!(bitfield1)
)
);
}
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub union dvb_desc_cable_delivery__bindgen_ty_2 {
pub bitfield2: u32,
pub __bindgen_anon_1: dvb_desc_cable_delivery__bindgen_ty_2__bindgen_ty_1,
_bindgen_union_align: [u8; 4usize],
}
#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct dvb_desc_cable_delivery__bindgen_ty_2__bindgen_ty_1 {
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize], u8>,
}
#[test]
fn bindgen_test_layout_dvb_desc_cable_delivery__bindgen_ty_2__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<dvb_desc_cable_delivery__bindgen_ty_2__bindgen_ty_1>(),
4usize,
concat!(
"Size of: ",
stringify!(dvb_desc_cable_delivery__bindgen_ty_2__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<dvb_desc_cable_delivery__bindgen_ty_2__bindgen_ty_1>(),
1usize,
concat!(
"Alignment of ",
stringify!(dvb_desc_cable_delivery__bindgen_ty_2__bindgen_ty_1)
)
);
}
impl dvb_desc_cable_delivery__bindgen_ty_2__bindgen_ty_1 {
#[inline]
pub fn fec_inner(&self) -> u32 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u32) }
}
#[inline]
pub fn set_fec_inner(&mut self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 4u8, val as u64)
}
}
#[inline]
pub fn symbol_rate(&self) -> u32 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 28u8) as u32) }
}
#[inline]
pub fn set_symbol_rate(&mut self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(4usize, 28u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(
fec_inner: u32,
symbol_rate: u32,
) -> __BindgenBitfieldUnit<[u8; 4usize], u8> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize], u8> =
Default::default();
__bindgen_bitfield_unit.set(0usize, 4u8, {
let fec_inner: u32 = unsafe { ::std::mem::transmute(fec_inner) };
fec_inner as u64
});
__bindgen_bitfield_unit.set(4usize, 28u8, {
let symbol_rate: u32 = unsafe { ::std::mem::transmute(symbol_rate) };
symbol_rate as u64
});
__bindgen_bitfield_unit
}
}
#[test]
fn bindgen_test_layout_dvb_desc_cable_delivery__bindgen_ty_2() {
assert_eq!(
::std::mem::size_of::<dvb_desc_cable_delivery__bindgen_ty_2>(),
4usize,
concat!(
"Size of: ",
stringify!(dvb_desc_cable_delivery__bindgen_ty_2)
)
);
assert_eq!(
::std::mem::align_of::<dvb_desc_cable_delivery__bindgen_ty_2>(),
1usize,
concat!(
"Alignment of ",
stringify!(dvb_desc_cable_delivery__bindgen_ty_2)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_desc_cable_delivery__bindgen_ty_2>())).bitfield2 as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_cable_delivery__bindgen_ty_2),
"::",
stringify!(bitfield2)
)
);
}
#[test]
fn bindgen_test_layout_dvb_desc_cable_delivery() {
assert_eq!(
::std::mem::size_of::<dvb_desc_cable_delivery>(),
21usize,
concat!("Size of: ", stringify!(dvb_desc_cable_delivery))
);
assert_eq!(
::std::mem::align_of::<dvb_desc_cable_delivery>(),
1usize,
concat!("Alignment of ", stringify!(dvb_desc_cable_delivery))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_desc_cable_delivery>())).type_ as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_cable_delivery),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_desc_cable_delivery>())).length as *const _ as usize },
1usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_cable_delivery),
"::",
stringify!(length)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_desc_cable_delivery>())).next as *const _ as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_cable_delivery),
"::",
stringify!(next)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_desc_cable_delivery>())).frequency as *const _ as usize
},
10usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_cable_delivery),
"::",
stringify!(frequency)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_desc_cable_delivery>())).modulation as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_cable_delivery),
"::",
stringify!(modulation)
)
);
}
extern "C" {
pub fn dvb_desc_cable_delivery_init(
parms: *mut dvb_v5_fe_parms,
buf: *const u8,
desc: *mut dvb_desc,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dvb_desc_cable_delivery_print(parms: *mut dvb_v5_fe_parms, desc: *const dvb_desc);
}
extern "C" {
pub static mut dvbc_modulation_table: [::std::os::raw::c_uint; 0usize];
}
extern "C" {
pub static mut dvbc_fec_table: [::std::os::raw::c_uint; 0usize];
}
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub struct dvb_desc_ca {
pub type_: u8,
pub length: u8,
pub next: *mut dvb_desc,
pub ca_id: u16,
pub __bindgen_anon_1: dvb_desc_ca__bindgen_ty_1,
pub privdata: *mut u8,
pub privdata_len: u8,
}
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub union dvb_desc_ca__bindgen_ty_1 {
pub bitfield1: u16,
pub __bindgen_anon_1: dvb_desc_ca__bindgen_ty_1__bindgen_ty_1,
_bindgen_union_align: [u8; 2usize],
}
#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct dvb_desc_ca__bindgen_ty_1__bindgen_ty_1 {
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize], u8>,
}
#[test]
fn bindgen_test_layout_dvb_desc_ca__bindgen_ty_1__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<dvb_desc_ca__bindgen_ty_1__bindgen_ty_1>(),
2usize,
concat!(
"Size of: ",
stringify!(dvb_desc_ca__bindgen_ty_1__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<dvb_desc_ca__bindgen_ty_1__bindgen_ty_1>(),
1usize,
concat!(
"Alignment of ",
stringify!(dvb_desc_ca__bindgen_ty_1__bindgen_ty_1)
)
);
}
impl dvb_desc_ca__bindgen_ty_1__bindgen_ty_1 {
#[inline]
pub fn ca_pid(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 13u8) as u16) }
}
#[inline]
pub fn set_ca_pid(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 13u8, val as u64)
}
}
#[inline]
pub fn reserved(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 3u8) as u16) }
}
#[inline]
pub fn set_reserved(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(13usize, 3u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(ca_pid: u16, reserved: u16) -> __BindgenBitfieldUnit<[u8; 2usize], u8> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize], u8> =
Default::default();
__bindgen_bitfield_unit.set(0usize, 13u8, {
let ca_pid: u16 = unsafe { ::std::mem::transmute(ca_pid) };
ca_pid as u64
});
__bindgen_bitfield_unit.set(13usize, 3u8, {
let reserved: u16 = unsafe { ::std::mem::transmute(reserved) };
reserved as u64
});
__bindgen_bitfield_unit
}
}
#[test]
fn bindgen_test_layout_dvb_desc_ca__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<dvb_desc_ca__bindgen_ty_1>(),
2usize,
concat!("Size of: ", stringify!(dvb_desc_ca__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<dvb_desc_ca__bindgen_ty_1>(),
1usize,
concat!("Alignment of ", stringify!(dvb_desc_ca__bindgen_ty_1))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_desc_ca__bindgen_ty_1>())).bitfield1 as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_ca__bindgen_ty_1),
"::",
stringify!(bitfield1)
)
);
}
#[test]
fn bindgen_test_layout_dvb_desc_ca() {
assert_eq!(
::std::mem::size_of::<dvb_desc_ca>(),
23usize,
concat!("Size of: ", stringify!(dvb_desc_ca))
);
assert_eq!(
::std::mem::align_of::<dvb_desc_ca>(),
1usize,
concat!("Alignment of ", stringify!(dvb_desc_ca))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_desc_ca>())).type_ as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_ca),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_desc_ca>())).length as *const _ as usize },
1usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_ca),
"::",
stringify!(length)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_desc_ca>())).next as *const _ as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_ca),
"::",
stringify!(next)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_desc_ca>())).ca_id as *const _ as usize },
10usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_ca),
"::",
stringify!(ca_id)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_desc_ca>())).privdata as *const _ as usize },
14usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_ca),
"::",
stringify!(privdata)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_desc_ca>())).privdata_len as *const _ as usize },
22usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_ca),
"::",
stringify!(privdata_len)
)
);
}
extern "C" {
pub fn dvb_desc_ca_init(
parms: *mut dvb_v5_fe_parms,
buf: *const u8,
desc: *mut dvb_desc,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dvb_desc_ca_print(parms: *mut dvb_v5_fe_parms, desc: *const dvb_desc);
}
extern "C" {
pub fn dvb_desc_ca_free(desc: *mut dvb_desc);
}
#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct dvb_desc_ca_identifier {
pub type_: u8,
pub length: u8,
pub next: *mut dvb_desc,
pub caid_count: u8,
pub caids: *mut u16,
}
#[test]
fn bindgen_test_layout_dvb_desc_ca_identifier() {
assert_eq!(
::std::mem::size_of::<dvb_desc_ca_identifier>(),
19usize,
concat!("Size of: ", stringify!(dvb_desc_ca_identifier))
);
assert_eq!(
::std::mem::align_of::<dvb_desc_ca_identifier>(),
1usize,
concat!("Alignment of ", stringify!(dvb_desc_ca_identifier))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_desc_ca_identifier>())).type_ as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_ca_identifier),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_desc_ca_identifier>())).length as *const _ as usize },
1usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_ca_identifier),
"::",
stringify!(length)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_desc_ca_identifier>())).next as *const _ as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_ca_identifier),
"::",
stringify!(next)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_desc_ca_identifier>())).caid_count as *const _ as usize
},
10usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_ca_identifier),
"::",
stringify!(caid_count)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_desc_ca_identifier>())).caids as *const _ as usize },
11usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_ca_identifier),
"::",
stringify!(caids)
)
);
}
extern "C" {
pub fn dvb_desc_ca_identifier_init(
parms: *mut dvb_v5_fe_parms,
buf: *const u8,
desc: *mut dvb_desc,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dvb_desc_ca_identifier_print(parms: *mut dvb_v5_fe_parms, desc: *const dvb_desc);
}
extern "C" {
pub fn dvb_desc_ca_identifier_free(desc: *mut dvb_desc);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dvb_desc_event_extended_item {
pub description: *mut ::std::os::raw::c_char,
pub description_emph: *mut ::std::os::raw::c_char,
pub item: *mut ::std::os::raw::c_char,
pub item_emph: *mut ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout_dvb_desc_event_extended_item() {
assert_eq!(
::std::mem::size_of::<dvb_desc_event_extended_item>(),
32usize,
concat!("Size of: ", stringify!(dvb_desc_event_extended_item))
);
assert_eq!(
::std::mem::align_of::<dvb_desc_event_extended_item>(),
8usize,
concat!("Alignment of ", stringify!(dvb_desc_event_extended_item))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_desc_event_extended_item>())).description as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_event_extended_item),
"::",
stringify!(description)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_desc_event_extended_item>())).description_emph as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_event_extended_item),
"::",
stringify!(description_emph)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_desc_event_extended_item>())).item as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_event_extended_item),
"::",
stringify!(item)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_desc_event_extended_item>())).item_emph as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_event_extended_item),
"::",
stringify!(item_emph)
)
);
}
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub struct dvb_desc_event_extended {
pub type_: u8,
pub length: u8,
pub next: *mut dvb_desc,
pub __bindgen_anon_1: dvb_desc_event_extended__bindgen_ty_1,
pub language: [::std::os::raw::c_uchar; 4usize],
pub text: *mut ::std::os::raw::c_char,
pub text_emph: *mut ::std::os::raw::c_char,
pub items: *mut dvb_desc_event_extended_item,
pub num_items: ::std::os::raw::c_int,
}
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub union dvb_desc_event_extended__bindgen_ty_1 {
pub __bindgen_anon_1: dvb_desc_event_extended__bindgen_ty_1__bindgen_ty_1,
pub ids: u8,
_bindgen_union_align: u8,
}
#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct dvb_desc_event_extended__bindgen_ty_1__bindgen_ty_1 {
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize], u8>,
}
#[test]
fn bindgen_test_layout_dvb_desc_event_extended__bindgen_ty_1__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<dvb_desc_event_extended__bindgen_ty_1__bindgen_ty_1>(),
1usize,
concat!(
"Size of: ",
stringify!(dvb_desc_event_extended__bindgen_ty_1__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<dvb_desc_event_extended__bindgen_ty_1__bindgen_ty_1>(),
1usize,
concat!(
"Alignment of ",
stringify!(dvb_desc_event_extended__bindgen_ty_1__bindgen_ty_1)
)
);
}
impl dvb_desc_event_extended__bindgen_ty_1__bindgen_ty_1 {
#[inline]
pub fn last_id(&self) -> u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u8) }
}
#[inline]
pub fn set_last_id(&mut self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 4u8, val as u64)
}
}
#[inline]
pub fn id(&self) -> u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 4u8) as u8) }
}
#[inline]
pub fn set_id(&mut self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(4usize, 4u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(last_id: u8, id: u8) -> __BindgenBitfieldUnit<[u8; 1usize], u8> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize], u8> =
Default::default();
__bindgen_bitfield_unit.set(0usize, 4u8, {
let last_id: u8 = unsafe { ::std::mem::transmute(last_id) };
last_id as u64
});
__bindgen_bitfield_unit.set(4usize, 4u8, {
let id: u8 = unsafe { ::std::mem::transmute(id) };
id as u64
});
__bindgen_bitfield_unit
}
}
#[test]
fn bindgen_test_layout_dvb_desc_event_extended__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<dvb_desc_event_extended__bindgen_ty_1>(),
1usize,
concat!(
"Size of: ",
stringify!(dvb_desc_event_extended__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<dvb_desc_event_extended__bindgen_ty_1>(),
1usize,
concat!(
"Alignment of ",
stringify!(dvb_desc_event_extended__bindgen_ty_1)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_desc_event_extended__bindgen_ty_1>())).ids as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_event_extended__bindgen_ty_1),
"::",
stringify!(ids)
)
);
}
#[test]
fn bindgen_test_layout_dvb_desc_event_extended() {
assert_eq!(
::std::mem::size_of::<dvb_desc_event_extended>(),
43usize,
concat!("Size of: ", stringify!(dvb_desc_event_extended))
);
assert_eq!(
::std::mem::align_of::<dvb_desc_event_extended>(),
1usize,
concat!("Alignment of ", stringify!(dvb_desc_event_extended))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_desc_event_extended>())).type_ as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_event_extended),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_desc_event_extended>())).length as *const _ as usize },
1usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_event_extended),
"::",
stringify!(length)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_desc_event_extended>())).next as *const _ as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_event_extended),
"::",
stringify!(next)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_desc_event_extended>())).language as *const _ as usize
},
11usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_event_extended),
"::",
stringify!(language)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_desc_event_extended>())).text as *const _ as usize },
15usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_event_extended),
"::",
stringify!(text)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_desc_event_extended>())).text_emph as *const _ as usize
},
23usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_event_extended),
"::",
stringify!(text_emph)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_desc_event_extended>())).items as *const _ as usize },
31usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_event_extended),
"::",
stringify!(items)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_desc_event_extended>())).num_items as *const _ as usize
},
39usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_event_extended),
"::",
stringify!(num_items)
)
);
}
extern "C" {
pub fn dvb_desc_event_extended_init(
parms: *mut dvb_v5_fe_parms,
buf: *const u8,
desc: *mut dvb_desc,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dvb_desc_event_extended_print(parms: *mut dvb_v5_fe_parms, desc: *const dvb_desc);
}
extern "C" {
pub fn dvb_desc_event_extended_free(desc: *mut dvb_desc);
}
#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct dvb_desc_event_short {
pub type_: u8,
pub length: u8,
pub next: *mut dvb_desc,
pub language: [::std::os::raw::c_uchar; 4usize],
pub name: *mut ::std::os::raw::c_char,
pub name_emph: *mut ::std::os::raw::c_char,
pub text: *mut ::std::os::raw::c_char,
pub text_emph: *mut ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout_dvb_desc_event_short() {
assert_eq!(
::std::mem::size_of::<dvb_desc_event_short>(),
46usize,
concat!("Size of: ", stringify!(dvb_desc_event_short))
);
assert_eq!(
::std::mem::align_of::<dvb_desc_event_short>(),
1usize,
concat!("Alignment of ", stringify!(dvb_desc_event_short))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_desc_event_short>())).type_ as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_event_short),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_desc_event_short>())).length as *const _ as usize },
1usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_event_short),
"::",
stringify!(length)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_desc_event_short>())).next as *const _ as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_event_short),
"::",
stringify!(next)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_desc_event_short>())).language as *const _ as usize },
10usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_event_short),
"::",
stringify!(language)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_desc_event_short>())).name as *const _ as usize },
14usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_event_short),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_desc_event_short>())).name_emph as *const _ as usize },
22usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_event_short),
"::",
stringify!(name_emph)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_desc_event_short>())).text as *const _ as usize },
30usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_event_short),
"::",
stringify!(text)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_desc_event_short>())).text_emph as *const _ as usize },
38usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_event_short),
"::",
stringify!(text_emph)
)
);
}
extern "C" {
pub fn dvb_desc_event_short_init(
parms: *mut dvb_v5_fe_parms,
buf: *const u8,
desc: *mut dvb_desc,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dvb_desc_event_short_print(parms: *mut dvb_v5_fe_parms, desc: *const dvb_desc);
}
extern "C" {
pub fn dvb_desc_event_short_free(desc: *mut dvb_desc);
}
#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct dvb_extension_descriptor {
pub type_: u8,
pub length: u8,
pub next: *mut dvb_desc,
pub extension_code: u8,
pub descriptor: *mut dvb_desc,
}
#[test]
fn bindgen_test_layout_dvb_extension_descriptor() {
assert_eq!(
::std::mem::size_of::<dvb_extension_descriptor>(),
19usize,
concat!("Size of: ", stringify!(dvb_extension_descriptor))
);
assert_eq!(
::std::mem::align_of::<dvb_extension_descriptor>(),
1usize,
concat!("Alignment of ", stringify!(dvb_extension_descriptor))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_extension_descriptor>())).type_ as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_extension_descriptor),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_extension_descriptor>())).length as *const _ as usize },
1usize,
concat!(
"Offset of field: ",
stringify!(dvb_extension_descriptor),
"::",
stringify!(length)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_extension_descriptor>())).next as *const _ as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(dvb_extension_descriptor),
"::",
stringify!(next)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_extension_descriptor>())).extension_code as *const _ as usize
},
10usize,
concat!(
"Offset of field: ",
stringify!(dvb_extension_descriptor),
"::",
stringify!(extension_code)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_extension_descriptor>())).descriptor as *const _ as usize
},
11usize,
concat!(
"Offset of field: ",
stringify!(dvb_extension_descriptor),
"::",
stringify!(descriptor)
)
);
}
pub type dvb_desc_ext_init_func = ::std::option::Option<
unsafe extern "C" fn(
parms: *mut dvb_v5_fe_parms,
buf: *const u8,
ext: *mut dvb_extension_descriptor,
desc: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int,
>;
pub type dvb_desc_ext_print_func = ::std::option::Option<
unsafe extern "C" fn(
parms: *mut dvb_v5_fe_parms,
ext: *const dvb_extension_descriptor,
desc: *const ::std::os::raw::c_void,
),
>;
pub type dvb_desc_ext_free_func =
::std::option::Option<unsafe extern "C" fn(desc: *const ::std::os::raw::c_void)>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dvb_ext_descriptor {
pub name: *const ::std::os::raw::c_char,
pub init: dvb_desc_ext_init_func,
pub print: dvb_desc_ext_print_func,
pub free: dvb_desc_ext_free_func,
pub size: ssize_t,
}
#[test]
fn bindgen_test_layout_dvb_ext_descriptor() {
assert_eq!(
::std::mem::size_of::<dvb_ext_descriptor>(),
40usize,
concat!("Size of: ", stringify!(dvb_ext_descriptor))
);
assert_eq!(
::std::mem::align_of::<dvb_ext_descriptor>(),
8usize,
concat!("Alignment of ", stringify!(dvb_ext_descriptor))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_ext_descriptor>())).name as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_ext_descriptor),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_ext_descriptor>())).init as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(dvb_ext_descriptor),
"::",
stringify!(init)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_ext_descriptor>())).print as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(dvb_ext_descriptor),
"::",
stringify!(print)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_ext_descriptor>())).free as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(dvb_ext_descriptor),
"::",
stringify!(free)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_ext_descriptor>())).size as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(dvb_ext_descriptor),
"::",
stringify!(size)
)
);
}
extern "C" {
pub fn dvb_extension_descriptor_init(
parms: *mut dvb_v5_fe_parms,
buf: *const u8,
desc: *mut dvb_desc,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dvb_extension_descriptor_print(parms: *mut dvb_v5_fe_parms, desc: *const dvb_desc);
}
extern "C" {
pub fn dvb_extension_descriptor_free(desc: *mut dvb_desc);
}
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub struct dvb_desc_frequency_list {
pub type_: u8,
pub length: u8,
pub next: *mut dvb_desc,
pub frequencies: u8,
pub frequency: *mut u32,
pub __bindgen_anon_1: dvb_desc_frequency_list__bindgen_ty_1,
}
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub union dvb_desc_frequency_list__bindgen_ty_1 {
pub bitfield: u8,
pub __bindgen_anon_1: dvb_desc_frequency_list__bindgen_ty_1__bindgen_ty_1,
_bindgen_union_align: u8,
}
#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct dvb_desc_frequency_list__bindgen_ty_1__bindgen_ty_1 {
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize], u8>,
}
#[test]
fn bindgen_test_layout_dvb_desc_frequency_list__bindgen_ty_1__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<dvb_desc_frequency_list__bindgen_ty_1__bindgen_ty_1>(),
1usize,
concat!(
"Size of: ",
stringify!(dvb_desc_frequency_list__bindgen_ty_1__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<dvb_desc_frequency_list__bindgen_ty_1__bindgen_ty_1>(),
1usize,
concat!(
"Alignment of ",
stringify!(dvb_desc_frequency_list__bindgen_ty_1__bindgen_ty_1)
)
);
}
impl dvb_desc_frequency_list__bindgen_ty_1__bindgen_ty_1 {
#[inline]
pub fn freq_type(&self) -> u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u8) }
}
#[inline]
pub fn set_freq_type(&mut self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 2u8, val as u64)
}
}
#[inline]
pub fn reserved(&self) -> u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 6u8) as u8) }
}
#[inline]
pub fn set_reserved(&mut self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(2usize, 6u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(freq_type: u8, reserved: u8) -> __BindgenBitfieldUnit<[u8; 1usize], u8> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize], u8> =
Default::default();
__bindgen_bitfield_unit.set(0usize, 2u8, {
let freq_type: u8 = unsafe { ::std::mem::transmute(freq_type) };
freq_type as u64
});
__bindgen_bitfield_unit.set(2usize, 6u8, {
let reserved: u8 = unsafe { ::std::mem::transmute(reserved) };
reserved as u64
});
__bindgen_bitfield_unit
}
}
#[test]
fn bindgen_test_layout_dvb_desc_frequency_list__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<dvb_desc_frequency_list__bindgen_ty_1>(),
1usize,
concat!(
"Size of: ",
stringify!(dvb_desc_frequency_list__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<dvb_desc_frequency_list__bindgen_ty_1>(),
1usize,
concat!(
"Alignment of ",
stringify!(dvb_desc_frequency_list__bindgen_ty_1)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_desc_frequency_list__bindgen_ty_1>())).bitfield as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_frequency_list__bindgen_ty_1),
"::",
stringify!(bitfield)
)
);
}
#[test]
fn bindgen_test_layout_dvb_desc_frequency_list() {
assert_eq!(
::std::mem::size_of::<dvb_desc_frequency_list>(),
20usize,
concat!("Size of: ", stringify!(dvb_desc_frequency_list))
);
assert_eq!(
::std::mem::align_of::<dvb_desc_frequency_list>(),
1usize,
concat!("Alignment of ", stringify!(dvb_desc_frequency_list))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_desc_frequency_list>())).type_ as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_frequency_list),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_desc_frequency_list>())).length as *const _ as usize },
1usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_frequency_list),
"::",
stringify!(length)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_desc_frequency_list>())).next as *const _ as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_frequency_list),
"::",
stringify!(next)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_desc_frequency_list>())).frequencies as *const _ as usize
},
10usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_frequency_list),
"::",
stringify!(frequencies)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_desc_frequency_list>())).frequency as *const _ as usize
},
11usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_frequency_list),
"::",
stringify!(frequency)
)
);
}
extern "C" {
pub fn dvb_desc_frequency_list_init(
parms: *mut dvb_v5_fe_parms,
buf: *const u8,
desc: *mut dvb_desc,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dvb_desc_frequency_list_print(parms: *mut dvb_v5_fe_parms, desc: *const dvb_desc);
}
#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct dvb_desc_hierarchy {
pub type_: u8,
pub length: u8,
pub next: *mut dvb_desc,
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize], u8>,
}
#[test]
fn bindgen_test_layout_dvb_desc_hierarchy() {
assert_eq!(
::std::mem::size_of::<dvb_desc_hierarchy>(),
14usize,
concat!("Size of: ", stringify!(dvb_desc_hierarchy))
);
assert_eq!(
::std::mem::align_of::<dvb_desc_hierarchy>(),
1usize,
concat!("Alignment of ", stringify!(dvb_desc_hierarchy))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_desc_hierarchy>())).type_ as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_hierarchy),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_desc_hierarchy>())).length as *const _ as usize },
1usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_hierarchy),
"::",
stringify!(length)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_desc_hierarchy>())).next as *const _ as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_hierarchy),
"::",
stringify!(next)
)
);
}
impl dvb_desc_hierarchy {
#[inline]
pub fn hierarchy_type(&self) -> u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u8) }
}
#[inline]
pub fn set_hierarchy_type(&mut self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 4u8, val as u64)
}
}
#[inline]
pub fn reserved(&self) -> u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 4u8) as u8) }
}
#[inline]
pub fn set_reserved(&mut self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(4usize, 4u8, val as u64)
}
}
#[inline]
pub fn layer(&self) -> u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 6u8) as u8) }
}
#[inline]
pub fn set_layer(&mut self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(8usize, 6u8, val as u64)
}
}
#[inline]
pub fn reserved2(&self) -> u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 2u8) as u8) }
}
#[inline]
pub fn set_reserved2(&mut self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(14usize, 2u8, val as u64)
}
}
#[inline]
pub fn embedded_layer(&self) -> u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 6u8) as u8) }
}
#[inline]
pub fn set_embedded_layer(&mut self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(16usize, 6u8, val as u64)
}
}
#[inline]
pub fn reserved3(&self) -> u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(22usize, 2u8) as u8) }
}
#[inline]
pub fn set_reserved3(&mut self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(22usize, 2u8, val as u64)
}
}
#[inline]
pub fn channel(&self) -> u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 6u8) as u8) }
}
#[inline]
pub fn set_channel(&mut self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(24usize, 6u8, val as u64)
}
}
#[inline]
pub fn reserved4(&self) -> u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(30usize, 2u8) as u8) }
}
#[inline]
pub fn set_reserved4(&mut self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(30usize, 2u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(
hierarchy_type: u8,
reserved: u8,
layer: u8,
reserved2: u8,
embedded_layer: u8,
reserved3: u8,
channel: u8,
reserved4: u8,
) -> __BindgenBitfieldUnit<[u8; 4usize], u8> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize], u8> =
Default::default();
__bindgen_bitfield_unit.set(0usize, 4u8, {
let hierarchy_type: u8 = unsafe { ::std::mem::transmute(hierarchy_type) };
hierarchy_type as u64
});
__bindgen_bitfield_unit.set(4usize, 4u8, {
let reserved: u8 = unsafe { ::std::mem::transmute(reserved) };
reserved as u64
});
__bindgen_bitfield_unit.set(8usize, 6u8, {
let layer: u8 = unsafe { ::std::mem::transmute(layer) };
layer as u64
});
__bindgen_bitfield_unit.set(14usize, 2u8, {
let reserved2: u8 = unsafe { ::std::mem::transmute(reserved2) };
reserved2 as u64
});
__bindgen_bitfield_unit.set(16usize, 6u8, {
let embedded_layer: u8 = unsafe { ::std::mem::transmute(embedded_layer) };
embedded_layer as u64
});
__bindgen_bitfield_unit.set(22usize, 2u8, {
let reserved3: u8 = unsafe { ::std::mem::transmute(reserved3) };
reserved3 as u64
});
__bindgen_bitfield_unit.set(24usize, 6u8, {
let channel: u8 = unsafe { ::std::mem::transmute(channel) };
channel as u64
});
__bindgen_bitfield_unit.set(30usize, 2u8, {
let reserved4: u8 = unsafe { ::std::mem::transmute(reserved4) };
reserved4 as u64
});
__bindgen_bitfield_unit
}
}
extern "C" {
pub fn dvb_desc_hierarchy_init(
parms: *mut dvb_v5_fe_parms,
buf: *const u8,
desc: *mut dvb_desc,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dvb_desc_hierarchy_print(parms: *mut dvb_v5_fe_parms, desc: *const dvb_desc);
}
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub struct isdbt_desc_terrestrial_delivery_system {
pub type_: u8,
pub length: u8,
pub next: *mut dvb_desc,
pub frequency: *mut u32,
pub num_freqs: ::std::os::raw::c_uint,
pub __bindgen_anon_1: isdbt_desc_terrestrial_delivery_system__bindgen_ty_1,
}
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub union isdbt_desc_terrestrial_delivery_system__bindgen_ty_1 {
pub bitfield: u16,
pub __bindgen_anon_1: isdbt_desc_terrestrial_delivery_system__bindgen_ty_1__bindgen_ty_1,
_bindgen_union_align: [u8; 2usize],
}
#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct isdbt_desc_terrestrial_delivery_system__bindgen_ty_1__bindgen_ty_1 {
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize], u8>,
}
#[test]
fn bindgen_test_layout_isdbt_desc_terrestrial_delivery_system__bindgen_ty_1__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<isdbt_desc_terrestrial_delivery_system__bindgen_ty_1__bindgen_ty_1>(),
2usize,
concat!(
"Size of: ",
stringify!(isdbt_desc_terrestrial_delivery_system__bindgen_ty_1__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<isdbt_desc_terrestrial_delivery_system__bindgen_ty_1__bindgen_ty_1>(
),
1usize,
concat!(
"Alignment of ",
stringify!(isdbt_desc_terrestrial_delivery_system__bindgen_ty_1__bindgen_ty_1)
)
);
}
impl isdbt_desc_terrestrial_delivery_system__bindgen_ty_1__bindgen_ty_1 {
#[inline]
pub fn transmission_mode(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u16) }
}
#[inline]
pub fn set_transmission_mode(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 2u8, val as u64)
}
}
#[inline]
pub fn guard_interval(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 2u8) as u16) }
}
#[inline]
pub fn set_guard_interval(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(2usize, 2u8, val as u64)
}
}
#[inline]
pub fn area_code(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 12u8) as u16) }
}
#[inline]
pub fn set_area_code(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(4usize, 12u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(
transmission_mode: u16,
guard_interval: u16,
area_code: u16,
) -> __BindgenBitfieldUnit<[u8; 2usize], u8> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize], u8> =
Default::default();
__bindgen_bitfield_unit.set(0usize, 2u8, {
let transmission_mode: u16 = unsafe { ::std::mem::transmute(transmission_mode) };
transmission_mode as u64
});
__bindgen_bitfield_unit.set(2usize, 2u8, {
let guard_interval: u16 = unsafe { ::std::mem::transmute(guard_interval) };
guard_interval as u64
});
__bindgen_bitfield_unit.set(4usize, 12u8, {
let area_code: u16 = unsafe { ::std::mem::transmute(area_code) };
area_code as u64
});
__bindgen_bitfield_unit
}
}
#[test]
fn bindgen_test_layout_isdbt_desc_terrestrial_delivery_system__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<isdbt_desc_terrestrial_delivery_system__bindgen_ty_1>(),
2usize,
concat!(
"Size of: ",
stringify!(isdbt_desc_terrestrial_delivery_system__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<isdbt_desc_terrestrial_delivery_system__bindgen_ty_1>(),
1usize,
concat!(
"Alignment of ",
stringify!(isdbt_desc_terrestrial_delivery_system__bindgen_ty_1)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<isdbt_desc_terrestrial_delivery_system__bindgen_ty_1>()))
.bitfield as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(isdbt_desc_terrestrial_delivery_system__bindgen_ty_1),
"::",
stringify!(bitfield)
)
);
}
#[test]
fn bindgen_test_layout_isdbt_desc_terrestrial_delivery_system() {
assert_eq!(
::std::mem::size_of::<isdbt_desc_terrestrial_delivery_system>(),
24usize,
concat!(
"Size of: ",
stringify!(isdbt_desc_terrestrial_delivery_system)
)
);
assert_eq!(
::std::mem::align_of::<isdbt_desc_terrestrial_delivery_system>(),
1usize,
concat!(
"Alignment of ",
stringify!(isdbt_desc_terrestrial_delivery_system)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<isdbt_desc_terrestrial_delivery_system>())).type_ as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(isdbt_desc_terrestrial_delivery_system),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<isdbt_desc_terrestrial_delivery_system>())).length as *const _
as usize
},
1usize,
concat!(
"Offset of field: ",
stringify!(isdbt_desc_terrestrial_delivery_system),
"::",
stringify!(length)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<isdbt_desc_terrestrial_delivery_system>())).next as *const _
as usize
},
2usize,
concat!(
"Offset of field: ",
stringify!(isdbt_desc_terrestrial_delivery_system),
"::",
stringify!(next)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<isdbt_desc_terrestrial_delivery_system>())).frequency as *const _
as usize
},
10usize,
concat!(
"Offset of field: ",
stringify!(isdbt_desc_terrestrial_delivery_system),
"::",
stringify!(frequency)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<isdbt_desc_terrestrial_delivery_system>())).num_freqs as *const _
as usize
},
18usize,
concat!(
"Offset of field: ",
stringify!(isdbt_desc_terrestrial_delivery_system),
"::",
stringify!(num_freqs)
)
);
}
extern "C" {
pub fn isdbt_desc_delivery_init(
parms: *mut dvb_v5_fe_parms,
buf: *const u8,
desc: *mut dvb_desc,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn isdbt_desc_delivery_print(parms: *mut dvb_v5_fe_parms, desc: *const dvb_desc);
}
extern "C" {
pub fn isdbt_desc_delivery_free(desc: *mut dvb_desc);
}
extern "C" {
pub static mut isdbt_interval: [u32; 0usize];
}
extern "C" {
pub static mut isdbt_mode: [u32; 0usize];
}
#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct dvb_desc_language {
pub type_: u8,
pub length: u8,
pub next: *mut dvb_desc,
pub language: [::std::os::raw::c_uchar; 4usize],
pub audio_type: u8,
}
#[test]
fn bindgen_test_layout_dvb_desc_language() {
assert_eq!(
::std::mem::size_of::<dvb_desc_language>(),
15usize,
concat!("Size of: ", stringify!(dvb_desc_language))
);
assert_eq!(
::std::mem::align_of::<dvb_desc_language>(),
1usize,
concat!("Alignment of ", stringify!(dvb_desc_language))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_desc_language>())).type_ as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_language),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_desc_language>())).length as *const _ as usize },
1usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_language),
"::",
stringify!(length)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_desc_language>())).next as *const _ as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_language),
"::",
stringify!(next)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_desc_language>())).language as *const _ as usize },
10usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_language),
"::",
stringify!(language)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_desc_language>())).audio_type as *const _ as usize },
14usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_language),
"::",
stringify!(audio_type)
)
);
}
extern "C" {
pub fn dvb_desc_language_init(
parms: *mut dvb_v5_fe_parms,
buf: *const u8,
desc: *mut dvb_desc,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dvb_desc_language_print(parms: *mut dvb_v5_fe_parms, desc: *const dvb_desc);
}
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub struct dvb_desc_logical_channel_number {
pub service_id: u16,
pub __bindgen_anon_1: dvb_desc_logical_channel_number__bindgen_ty_1,
}
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub union dvb_desc_logical_channel_number__bindgen_ty_1 {
pub bitfield: u16,
pub __bindgen_anon_1: dvb_desc_logical_channel_number__bindgen_ty_1__bindgen_ty_1,
_bindgen_union_align: [u8; 2usize],
}
#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct dvb_desc_logical_channel_number__bindgen_ty_1__bindgen_ty_1 {
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize], u8>,
}
#[test]
fn bindgen_test_layout_dvb_desc_logical_channel_number__bindgen_ty_1__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<dvb_desc_logical_channel_number__bindgen_ty_1__bindgen_ty_1>(),
2usize,
concat!(
"Size of: ",
stringify!(dvb_desc_logical_channel_number__bindgen_ty_1__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<dvb_desc_logical_channel_number__bindgen_ty_1__bindgen_ty_1>(),
1usize,
concat!(
"Alignment of ",
stringify!(dvb_desc_logical_channel_number__bindgen_ty_1__bindgen_ty_1)
)
);
}
impl dvb_desc_logical_channel_number__bindgen_ty_1__bindgen_ty_1 {
#[inline]
pub fn logical_channel_number(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 10u8) as u16) }
}
#[inline]
pub fn set_logical_channel_number(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 10u8, val as u64)
}
}
#[inline]
pub fn reserved(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 5u8) as u16) }
}
#[inline]
pub fn set_reserved(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(10usize, 5u8, val as u64)
}
}
#[inline]
pub fn visible_service_flag(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u16) }
}
#[inline]
pub fn set_visible_service_flag(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(15usize, 1u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(
logical_channel_number: u16,
reserved: u16,
visible_service_flag: u16,
) -> __BindgenBitfieldUnit<[u8; 2usize], u8> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize], u8> =
Default::default();
__bindgen_bitfield_unit.set(0usize, 10u8, {
let logical_channel_number: u16 =
unsafe { ::std::mem::transmute(logical_channel_number) };
logical_channel_number as u64
});
__bindgen_bitfield_unit.set(10usize, 5u8, {
let reserved: u16 = unsafe { ::std::mem::transmute(reserved) };
reserved as u64
});
__bindgen_bitfield_unit.set(15usize, 1u8, {
let visible_service_flag: u16 = unsafe { ::std::mem::transmute(visible_service_flag) };
visible_service_flag as u64
});
__bindgen_bitfield_unit
}
}
#[test]
fn bindgen_test_layout_dvb_desc_logical_channel_number__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<dvb_desc_logical_channel_number__bindgen_ty_1>(),
2usize,
concat!(
"Size of: ",
stringify!(dvb_desc_logical_channel_number__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<dvb_desc_logical_channel_number__bindgen_ty_1>(),
1usize,
concat!(
"Alignment of ",
stringify!(dvb_desc_logical_channel_number__bindgen_ty_1)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_desc_logical_channel_number__bindgen_ty_1>())).bitfield
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_logical_channel_number__bindgen_ty_1),
"::",
stringify!(bitfield)
)
);
}
#[test]
fn bindgen_test_layout_dvb_desc_logical_channel_number() {
assert_eq!(
::std::mem::size_of::<dvb_desc_logical_channel_number>(),
4usize,
concat!("Size of: ", stringify!(dvb_desc_logical_channel_number))
);
assert_eq!(
::std::mem::align_of::<dvb_desc_logical_channel_number>(),
1usize,
concat!("Alignment of ", stringify!(dvb_desc_logical_channel_number))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_desc_logical_channel_number>())).service_id as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_logical_channel_number),
"::",
stringify!(service_id)
)
);
}
#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct dvb_desc_logical_channel {
pub type_: u8,
pub length: u8,
pub next: *mut dvb_desc,
pub lcn: *mut dvb_desc_logical_channel_number,
}
#[test]
fn bindgen_test_layout_dvb_desc_logical_channel() {
assert_eq!(
::std::mem::size_of::<dvb_desc_logical_channel>(),
18usize,
concat!("Size of: ", stringify!(dvb_desc_logical_channel))
);
assert_eq!(
::std::mem::align_of::<dvb_desc_logical_channel>(),
1usize,
concat!("Alignment of ", stringify!(dvb_desc_logical_channel))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_desc_logical_channel>())).type_ as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_logical_channel),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_desc_logical_channel>())).length as *const _ as usize },
1usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_logical_channel),
"::",
stringify!(length)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_desc_logical_channel>())).next as *const _ as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_logical_channel),
"::",
stringify!(next)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_desc_logical_channel>())).lcn as *const _ as usize },
10usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_logical_channel),
"::",
stringify!(lcn)
)
);
}
extern "C" {
pub fn dvb_desc_logical_channel_init(
parms: *mut dvb_v5_fe_parms,
buf: *const u8,
desc: *mut dvb_desc,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dvb_desc_logical_channel_print(parms: *mut dvb_v5_fe_parms, desc: *const dvb_desc);
}
extern "C" {
pub fn dvb_desc_logical_channel_free(desc: *mut dvb_desc);
}
#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct dvb_desc_network_name {
pub type_: u8,
pub length: u8,
pub next: *mut dvb_desc,
pub network_name: *mut ::std::os::raw::c_char,
pub network_name_emph: *mut ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout_dvb_desc_network_name() {
assert_eq!(
::std::mem::size_of::<dvb_desc_network_name>(),
26usize,
concat!("Size of: ", stringify!(dvb_desc_network_name))
);
assert_eq!(
::std::mem::align_of::<dvb_desc_network_name>(),
1usize,
concat!("Alignment of ", stringify!(dvb_desc_network_name))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_desc_network_name>())).type_ as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_network_name),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_desc_network_name>())).length as *const _ as usize },
1usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_network_name),
"::",
stringify!(length)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_desc_network_name>())).next as *const _ as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_network_name),
"::",
stringify!(next)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_desc_network_name>())).network_name as *const _ as usize
},
10usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_network_name),
"::",
stringify!(network_name)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_desc_network_name>())).network_name_emph as *const _ as usize
},
18usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_network_name),
"::",
stringify!(network_name_emph)
)
);
}
extern "C" {
pub fn dvb_desc_network_name_init(
parms: *mut dvb_v5_fe_parms,
buf: *const u8,
desc: *mut dvb_desc,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dvb_desc_network_name_print(parms: *mut dvb_v5_fe_parms, desc: *const dvb_desc);
}
extern "C" {
pub fn dvb_desc_network_name_free(desc: *mut dvb_desc);
}
#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct isdb_partial_reception_service_id {
pub service_id: u16,
}
#[test]
fn bindgen_test_layout_isdb_partial_reception_service_id() {
assert_eq!(
::std::mem::size_of::<isdb_partial_reception_service_id>(),
2usize,
concat!("Size of: ", stringify!(isdb_partial_reception_service_id))
);
assert_eq!(
::std::mem::align_of::<isdb_partial_reception_service_id>(),
1usize,
concat!(
"Alignment of ",
stringify!(isdb_partial_reception_service_id)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<isdb_partial_reception_service_id>())).service_id as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(isdb_partial_reception_service_id),
"::",
stringify!(service_id)
)
);
}
#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct isdb_desc_partial_reception {
pub type_: u8,
pub length: u8,
pub next: *mut dvb_desc,
pub partial_reception: *mut isdb_partial_reception_service_id,
}
#[test]
fn bindgen_test_layout_isdb_desc_partial_reception() {
assert_eq!(
::std::mem::size_of::<isdb_desc_partial_reception>(),
18usize,
concat!("Size of: ", stringify!(isdb_desc_partial_reception))
);
assert_eq!(
::std::mem::align_of::<isdb_desc_partial_reception>(),
1usize,
concat!("Alignment of ", stringify!(isdb_desc_partial_reception))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<isdb_desc_partial_reception>())).type_ as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(isdb_desc_partial_reception),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<isdb_desc_partial_reception>())).length as *const _ as usize
},
1usize,
concat!(
"Offset of field: ",
stringify!(isdb_desc_partial_reception),
"::",
stringify!(length)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<isdb_desc_partial_reception>())).next as *const _ as usize
},
2usize,
concat!(
"Offset of field: ",
stringify!(isdb_desc_partial_reception),
"::",
stringify!(next)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<isdb_desc_partial_reception>())).partial_reception as *const _
as usize
},
10usize,
concat!(
"Offset of field: ",
stringify!(isdb_desc_partial_reception),
"::",
stringify!(partial_reception)
)
);
}
extern "C" {
pub fn isdb_desc_partial_reception_init(
parms: *mut dvb_v5_fe_parms,
buf: *const u8,
desc: *mut dvb_desc,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn isdb_desc_partial_reception_print(parms: *mut dvb_v5_fe_parms, desc: *const dvb_desc);
}
extern "C" {
pub fn isdb_desc_partial_reception_free(desc: *mut dvb_desc);
}
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub struct dvb_desc_sat {
pub type_: u8,
pub length: u8,
pub next: *mut dvb_desc,
pub frequency: u32,
pub orbit: u16,
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize], u8>,
pub __bindgen_anon_1: dvb_desc_sat__bindgen_ty_1,
}
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub union dvb_desc_sat__bindgen_ty_1 {
pub bitfield: u32,
pub __bindgen_anon_1: dvb_desc_sat__bindgen_ty_1__bindgen_ty_1,
_bindgen_union_align: [u8; 4usize],
}
#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct dvb_desc_sat__bindgen_ty_1__bindgen_ty_1 {
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize], u8>,
}
#[test]
fn bindgen_test_layout_dvb_desc_sat__bindgen_ty_1__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<dvb_desc_sat__bindgen_ty_1__bindgen_ty_1>(),
4usize,
concat!(
"Size of: ",
stringify!(dvb_desc_sat__bindgen_ty_1__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<dvb_desc_sat__bindgen_ty_1__bindgen_ty_1>(),
1usize,
concat!(
"Alignment of ",
stringify!(dvb_desc_sat__bindgen_ty_1__bindgen_ty_1)
)
);
}
impl dvb_desc_sat__bindgen_ty_1__bindgen_ty_1 {
#[inline]
pub fn fec(&self) -> u32 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u32) }
}
#[inline]
pub fn set_fec(&mut self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 4u8, val as u64)
}
}
#[inline]
pub fn symbol_rate(&self) -> u32 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 28u8) as u32) }
}
#[inline]
pub fn set_symbol_rate(&mut self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(4usize, 28u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(fec: u32, symbol_rate: u32) -> __BindgenBitfieldUnit<[u8; 4usize], u8> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize], u8> =
Default::default();
__bindgen_bitfield_unit.set(0usize, 4u8, {
let fec: u32 = unsafe { ::std::mem::transmute(fec) };
fec as u64
});
__bindgen_bitfield_unit.set(4usize, 28u8, {
let symbol_rate: u32 = unsafe { ::std::mem::transmute(symbol_rate) };
symbol_rate as u64
});
__bindgen_bitfield_unit
}
}
#[test]
fn bindgen_test_layout_dvb_desc_sat__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<dvb_desc_sat__bindgen_ty_1>(),
4usize,
concat!("Size of: ", stringify!(dvb_desc_sat__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<dvb_desc_sat__bindgen_ty_1>(),
1usize,
concat!("Alignment of ", stringify!(dvb_desc_sat__bindgen_ty_1))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_desc_sat__bindgen_ty_1>())).bitfield as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_sat__bindgen_ty_1),
"::",
stringify!(bitfield)
)
);
}
#[test]
fn bindgen_test_layout_dvb_desc_sat() {
assert_eq!(
::std::mem::size_of::<dvb_desc_sat>(),
21usize,
concat!("Size of: ", stringify!(dvb_desc_sat))
);
assert_eq!(
::std::mem::align_of::<dvb_desc_sat>(),
1usize,
concat!("Alignment of ", stringify!(dvb_desc_sat))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_desc_sat>())).type_ as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_sat),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_desc_sat>())).length as *const _ as usize },
1usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_sat),
"::",
stringify!(length)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_desc_sat>())).next as *const _ as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_sat),
"::",
stringify!(next)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_desc_sat>())).frequency as *const _ as usize },
10usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_sat),
"::",
stringify!(frequency)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_desc_sat>())).orbit as *const _ as usize },
14usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_sat),
"::",
stringify!(orbit)
)
);
}
impl dvb_desc_sat {
#[inline]
pub fn modulation_type(&self) -> u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u8) }
}
#[inline]
pub fn set_modulation_type(&mut self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 2u8, val as u64)
}
}
#[inline]
pub fn modulation_system(&self) -> u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) }
}
#[inline]
pub fn set_modulation_system(&mut self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(2usize, 1u8, val as u64)
}
}
#[inline]
pub fn roll_off(&self) -> u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 2u8) as u8) }
}
#[inline]
pub fn set_roll_off(&mut self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(3usize, 2u8, val as u64)
}
}
#[inline]
pub fn polarization(&self) -> u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 2u8) as u8) }
}
#[inline]
pub fn set_polarization(&mut self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(5usize, 2u8, val as u64)
}
}
#[inline]
pub fn west_east(&self) -> u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u8) }
}
#[inline]
pub fn set_west_east(&mut self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(7usize, 1u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(
modulation_type: u8,
modulation_system: u8,
roll_off: u8,
polarization: u8,
west_east: u8,
) -> __BindgenBitfieldUnit<[u8; 1usize], u8> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize], u8> =
Default::default();
__bindgen_bitfield_unit.set(0usize, 2u8, {
let modulation_type: u8 = unsafe { ::std::mem::transmute(modulation_type) };
modulation_type as u64
});
__bindgen_bitfield_unit.set(2usize, 1u8, {
let modulation_system: u8 = unsafe { ::std::mem::transmute(modulation_system) };
modulation_system as u64
});
__bindgen_bitfield_unit.set(3usize, 2u8, {
let roll_off: u8 = unsafe { ::std::mem::transmute(roll_off) };
roll_off as u64
});
__bindgen_bitfield_unit.set(5usize, 2u8, {
let polarization: u8 = unsafe { ::std::mem::transmute(polarization) };
polarization as u64
});
__bindgen_bitfield_unit.set(7usize, 1u8, {
let west_east: u8 = unsafe { ::std::mem::transmute(west_east) };
west_east as u64
});
__bindgen_bitfield_unit
}
}
extern "C" {
pub fn dvb_desc_sat_init(
parms: *mut dvb_v5_fe_parms,
buf: *const u8,
desc: *mut dvb_desc,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dvb_desc_sat_print(parms: *mut dvb_v5_fe_parms, desc: *const dvb_desc);
}
extern "C" {
pub static mut dvbs_dvbc_dvbs_freq_inner: [::std::os::raw::c_uint; 0usize];
}
extern "C" {
pub static mut dvbs_polarization: [::std::os::raw::c_uint; 0usize];
}
extern "C" {
pub static mut dvbs_rolloff: [::std::os::raw::c_uint; 0usize];
}
extern "C" {
pub static mut dvbs_modulation: [::std::os::raw::c_uint; 0usize];
}
#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct dvb_desc_service {
pub type_: u8,
pub length: u8,
pub next: *mut dvb_desc,
pub service_type: u8,
pub name: *mut ::std::os::raw::c_char,
pub name_emph: *mut ::std::os::raw::c_char,
pub provider: *mut ::std::os::raw::c_char,
pub provider_emph: *mut ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout_dvb_desc_service() {
assert_eq!(
::std::mem::size_of::<dvb_desc_service>(),
43usize,
concat!("Size of: ", stringify!(dvb_desc_service))
);
assert_eq!(
::std::mem::align_of::<dvb_desc_service>(),
1usize,
concat!("Alignment of ", stringify!(dvb_desc_service))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_desc_service>())).type_ as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_service),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_desc_service>())).length as *const _ as usize },
1usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_service),
"::",
stringify!(length)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_desc_service>())).next as *const _ as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_service),
"::",
stringify!(next)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_desc_service>())).service_type as *const _ as usize },
10usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_service),
"::",
stringify!(service_type)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_desc_service>())).name as *const _ as usize },
11usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_service),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_desc_service>())).name_emph as *const _ as usize },
19usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_service),
"::",
stringify!(name_emph)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_desc_service>())).provider as *const _ as usize },
27usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_service),
"::",
stringify!(provider)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_desc_service>())).provider_emph as *const _ as usize },
35usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_service),
"::",
stringify!(provider_emph)
)
);
}
extern "C" {
pub fn dvb_desc_service_init(
parms: *mut dvb_v5_fe_parms,
buf: *const u8,
desc: *mut dvb_desc,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dvb_desc_service_print(parms: *mut dvb_v5_fe_parms, desc: *const dvb_desc);
}
extern "C" {
pub fn dvb_desc_service_free(desc: *mut dvb_desc);
}
#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct dvb_desc_t2_delivery_subcell_old {
pub cell_id_extension: u8,
pub transposer_frequency: u16,
}
#[test]
fn bindgen_test_layout_dvb_desc_t2_delivery_subcell_old() {
assert_eq!(
::std::mem::size_of::<dvb_desc_t2_delivery_subcell_old>(),
3usize,
concat!("Size of: ", stringify!(dvb_desc_t2_delivery_subcell_old))
);
assert_eq!(
::std::mem::align_of::<dvb_desc_t2_delivery_subcell_old>(),
1usize,
concat!(
"Alignment of ",
stringify!(dvb_desc_t2_delivery_subcell_old)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_desc_t2_delivery_subcell_old>())).cell_id_extension
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_t2_delivery_subcell_old),
"::",
stringify!(cell_id_extension)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_desc_t2_delivery_subcell_old>())).transposer_frequency
as *const _ as usize
},
1usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_t2_delivery_subcell_old),
"::",
stringify!(transposer_frequency)
)
);
}
#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct dvb_desc_t2_delivery_subcell {
pub cell_id_extension: u8,
pub transposer_frequency: u32,
}
#[test]
fn bindgen_test_layout_dvb_desc_t2_delivery_subcell() {
assert_eq!(
::std::mem::size_of::<dvb_desc_t2_delivery_subcell>(),
5usize,
concat!("Size of: ", stringify!(dvb_desc_t2_delivery_subcell))
);
assert_eq!(
::std::mem::align_of::<dvb_desc_t2_delivery_subcell>(),
1usize,
concat!("Alignment of ", stringify!(dvb_desc_t2_delivery_subcell))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_desc_t2_delivery_subcell>())).cell_id_extension as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_t2_delivery_subcell),
"::",
stringify!(cell_id_extension)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_desc_t2_delivery_subcell>())).transposer_frequency
as *const _ as usize
},
1usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_t2_delivery_subcell),
"::",
stringify!(transposer_frequency)
)
);
}
#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct dvb_desc_t2_delivery_cell {
pub cell_id: u16,
pub num_freqs: ::std::os::raw::c_int,
pub centre_frequency: *mut u32,
pub subcel_length: u8,
pub subcel: *mut dvb_desc_t2_delivery_subcell,
}
#[test]
fn bindgen_test_layout_dvb_desc_t2_delivery_cell() {
assert_eq!(
::std::mem::size_of::<dvb_desc_t2_delivery_cell>(),
23usize,
concat!("Size of: ", stringify!(dvb_desc_t2_delivery_cell))
);
assert_eq!(
::std::mem::align_of::<dvb_desc_t2_delivery_cell>(),
1usize,
concat!("Alignment of ", stringify!(dvb_desc_t2_delivery_cell))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_desc_t2_delivery_cell>())).cell_id as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_t2_delivery_cell),
"::",
stringify!(cell_id)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_desc_t2_delivery_cell>())).num_freqs as *const _ as usize
},
2usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_t2_delivery_cell),
"::",
stringify!(num_freqs)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_desc_t2_delivery_cell>())).centre_frequency as *const _
as usize
},
6usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_t2_delivery_cell),
"::",
stringify!(centre_frequency)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_desc_t2_delivery_cell>())).subcel_length as *const _ as usize
},
14usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_t2_delivery_cell),
"::",
stringify!(subcel_length)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_desc_t2_delivery_cell>())).subcel as *const _ as usize
},
15usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_t2_delivery_cell),
"::",
stringify!(subcel)
)
);
}
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub struct dvb_desc_t2_delivery {
pub plp_id: u8,
pub system_id: u16,
pub __bindgen_anon_1: dvb_desc_t2_delivery__bindgen_ty_1,
pub centre_frequency: *mut u32,
pub frequency_loop_length: u8,
pub subcel_info_loop_length: u8,
pub subcell: *mut dvb_desc_t2_delivery_subcell_old,
pub num_cell: ::std::os::raw::c_uint,
pub cell: *mut dvb_desc_t2_delivery_cell,
}
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub union dvb_desc_t2_delivery__bindgen_ty_1 {
pub bitfield: u16,
pub __bindgen_anon_1: dvb_desc_t2_delivery__bindgen_ty_1__bindgen_ty_1,
_bindgen_union_align: [u8; 2usize],
}
#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct dvb_desc_t2_delivery__bindgen_ty_1__bindgen_ty_1 {
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize], u8>,
}
#[test]
fn bindgen_test_layout_dvb_desc_t2_delivery__bindgen_ty_1__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<dvb_desc_t2_delivery__bindgen_ty_1__bindgen_ty_1>(),
2usize,
concat!(
"Size of: ",
stringify!(dvb_desc_t2_delivery__bindgen_ty_1__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<dvb_desc_t2_delivery__bindgen_ty_1__bindgen_ty_1>(),
1usize,
concat!(
"Alignment of ",
stringify!(dvb_desc_t2_delivery__bindgen_ty_1__bindgen_ty_1)
)
);
}
impl dvb_desc_t2_delivery__bindgen_ty_1__bindgen_ty_1 {
#[inline]
pub fn tfs_flag(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u16) }
}
#[inline]
pub fn set_tfs_flag(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 1u8, val as u64)
}
}
#[inline]
pub fn other_frequency_flag(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u16) }
}
#[inline]
pub fn set_other_frequency_flag(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(1usize, 1u8, val as u64)
}
}
#[inline]
pub fn transmission_mode(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 3u8) as u16) }
}
#[inline]
pub fn set_transmission_mode(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(2usize, 3u8, val as u64)
}
}
#[inline]
pub fn guard_interval(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 3u8) as u16) }
}
#[inline]
pub fn set_guard_interval(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(5usize, 3u8, val as u64)
}
}
#[inline]
pub fn reserved(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 2u8) as u16) }
}
#[inline]
pub fn set_reserved(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(8usize, 2u8, val as u64)
}
}
#[inline]
pub fn bandwidth(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 4u8) as u16) }
}
#[inline]
pub fn set_bandwidth(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(10usize, 4u8, val as u64)
}
}
#[inline]
pub fn SISO_MISO(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 2u8) as u16) }
}
#[inline]
pub fn set_SISO_MISO(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(14usize, 2u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(
tfs_flag: u16,
other_frequency_flag: u16,
transmission_mode: u16,
guard_interval: u16,
reserved: u16,
bandwidth: u16,
SISO_MISO: u16,
) -> __BindgenBitfieldUnit<[u8; 2usize], u8> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize], u8> =
Default::default();
__bindgen_bitfield_unit.set(0usize, 1u8, {
let tfs_flag: u16 = unsafe { ::std::mem::transmute(tfs_flag) };
tfs_flag as u64
});
__bindgen_bitfield_unit.set(1usize, 1u8, {
let other_frequency_flag: u16 = unsafe { ::std::mem::transmute(other_frequency_flag) };
other_frequency_flag as u64
});
__bindgen_bitfield_unit.set(2usize, 3u8, {
let transmission_mode: u16 = unsafe { ::std::mem::transmute(transmission_mode) };
transmission_mode as u64
});
__bindgen_bitfield_unit.set(5usize, 3u8, {
let guard_interval: u16 = unsafe { ::std::mem::transmute(guard_interval) };
guard_interval as u64
});
__bindgen_bitfield_unit.set(8usize, 2u8, {
let reserved: u16 = unsafe { ::std::mem::transmute(reserved) };
reserved as u64
});
__bindgen_bitfield_unit.set(10usize, 4u8, {
let bandwidth: u16 = unsafe { ::std::mem::transmute(bandwidth) };
bandwidth as u64
});
__bindgen_bitfield_unit.set(14usize, 2u8, {
let SISO_MISO: u16 = unsafe { ::std::mem::transmute(SISO_MISO) };
SISO_MISO as u64
});
__bindgen_bitfield_unit
}
}
#[test]
fn bindgen_test_layout_dvb_desc_t2_delivery__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<dvb_desc_t2_delivery__bindgen_ty_1>(),
2usize,
concat!("Size of: ", stringify!(dvb_desc_t2_delivery__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<dvb_desc_t2_delivery__bindgen_ty_1>(),
1usize,
concat!(
"Alignment of ",
stringify!(dvb_desc_t2_delivery__bindgen_ty_1)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_desc_t2_delivery__bindgen_ty_1>())).bitfield as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_t2_delivery__bindgen_ty_1),
"::",
stringify!(bitfield)
)
);
}
#[test]
fn bindgen_test_layout_dvb_desc_t2_delivery() {
assert_eq!(
::std::mem::size_of::<dvb_desc_t2_delivery>(),
35usize,
concat!("Size of: ", stringify!(dvb_desc_t2_delivery))
);
assert_eq!(
::std::mem::align_of::<dvb_desc_t2_delivery>(),
1usize,
concat!("Alignment of ", stringify!(dvb_desc_t2_delivery))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_desc_t2_delivery>())).plp_id as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_t2_delivery),
"::",
stringify!(plp_id)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_desc_t2_delivery>())).system_id as *const _ as usize },
1usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_t2_delivery),
"::",
stringify!(system_id)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_desc_t2_delivery>())).centre_frequency as *const _ as usize
},
5usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_t2_delivery),
"::",
stringify!(centre_frequency)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_desc_t2_delivery>())).frequency_loop_length as *const _
as usize
},
13usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_t2_delivery),
"::",
stringify!(frequency_loop_length)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_desc_t2_delivery>())).subcel_info_loop_length as *const _
as usize
},
14usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_t2_delivery),
"::",
stringify!(subcel_info_loop_length)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_desc_t2_delivery>())).subcell as *const _ as usize },
15usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_t2_delivery),
"::",
stringify!(subcell)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_desc_t2_delivery>())).num_cell as *const _ as usize },
23usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_t2_delivery),
"::",
stringify!(num_cell)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_desc_t2_delivery>())).cell as *const _ as usize },
27usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_t2_delivery),
"::",
stringify!(cell)
)
);
}
extern "C" {
pub fn dvb_desc_t2_delivery_init(
parms: *mut dvb_v5_fe_parms,
buf: *const u8,
ext: *mut dvb_extension_descriptor,
desc: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dvb_desc_t2_delivery_print(
parms: *mut dvb_v5_fe_parms,
ext: *const dvb_extension_descriptor,
desc: *const ::std::os::raw::c_void,
);
}
extern "C" {
pub fn dvb_desc_t2_delivery_free(desc: *const ::std::os::raw::c_void);
}
extern "C" {
pub static mut dvbt2_bw: [::std::os::raw::c_uint; 0usize];
}
extern "C" {
pub static mut dvbt2_interval: [u32; 0usize];
}
extern "C" {
pub static mut dvbt2_transmission_mode: [::std::os::raw::c_uint; 0usize];
}
#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct dvb_desc_terrestrial_delivery {
pub type_: u8,
pub length: u8,
pub next: *mut dvb_desc,
pub centre_frequency: u32,
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 3usize], u8>,
pub reserved_future_use2: u32,
}
#[test]
fn bindgen_test_layout_dvb_desc_terrestrial_delivery() {
assert_eq!(
::std::mem::size_of::<dvb_desc_terrestrial_delivery>(),
21usize,
concat!("Size of: ", stringify!(dvb_desc_terrestrial_delivery))
);
assert_eq!(
::std::mem::align_of::<dvb_desc_terrestrial_delivery>(),
1usize,
concat!("Alignment of ", stringify!(dvb_desc_terrestrial_delivery))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_desc_terrestrial_delivery>())).type_ as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_terrestrial_delivery),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_desc_terrestrial_delivery>())).length as *const _ as usize
},
1usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_terrestrial_delivery),
"::",
stringify!(length)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_desc_terrestrial_delivery>())).next as *const _ as usize
},
2usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_terrestrial_delivery),
"::",
stringify!(next)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_desc_terrestrial_delivery>())).centre_frequency as *const _
as usize
},
10usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_terrestrial_delivery),
"::",
stringify!(centre_frequency)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_desc_terrestrial_delivery>())).reserved_future_use2
as *const _ as usize
},
17usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_terrestrial_delivery),
"::",
stringify!(reserved_future_use2)
)
);
}
impl dvb_desc_terrestrial_delivery {
#[inline]
pub fn reserved_future_use1(&self) -> u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u8) }
}
#[inline]
pub fn set_reserved_future_use1(&mut self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 2u8, val as u64)
}
}
#[inline]
pub fn mpe_fec_indicator(&self) -> u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) }
}
#[inline]
pub fn set_mpe_fec_indicator(&mut self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(2usize, 1u8, val as u64)
}
}
#[inline]
pub fn time_slice_indicator(&self) -> u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8) }
}
#[inline]
pub fn set_time_slice_indicator(&mut self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(3usize, 1u8, val as u64)
}
}
#[inline]
pub fn priority(&self) -> u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u8) }
}
#[inline]
pub fn set_priority(&mut self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(4usize, 1u8, val as u64)
}
}
#[inline]
pub fn bandwidth(&self) -> u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 3u8) as u8) }
}
#[inline]
pub fn set_bandwidth(&mut self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(5usize, 3u8, val as u64)
}
}
#[inline]
pub fn code_rate_hp_stream(&self) -> u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 3u8) as u8) }
}
#[inline]
pub fn set_code_rate_hp_stream(&mut self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(8usize, 3u8, val as u64)
}
}
#[inline]
pub fn hierarchy_information(&self) -> u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 3u8) as u8) }
}
#[inline]
pub fn set_hierarchy_information(&mut self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(11usize, 3u8, val as u64)
}
}
#[inline]
pub fn constellation(&self) -> u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 2u8) as u8) }
}
#[inline]
pub fn set_constellation(&mut self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(14usize, 2u8, val as u64)
}
}
#[inline]
pub fn other_frequency_flag(&self) -> u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u8) }
}
#[inline]
pub fn set_other_frequency_flag(&mut self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(16usize, 1u8, val as u64)
}
}
#[inline]
pub fn transmission_mode(&self) -> u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 2u8) as u8) }
}
#[inline]
pub fn set_transmission_mode(&mut self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(17usize, 2u8, val as u64)
}
}
#[inline]
pub fn guard_interval(&self) -> u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 2u8) as u8) }
}
#[inline]
pub fn set_guard_interval(&mut self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(19usize, 2u8, val as u64)
}
}
#[inline]
pub fn code_rate_lp_stream(&self) -> u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(21usize, 3u8) as u8) }
}
#[inline]
pub fn set_code_rate_lp_stream(&mut self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(21usize, 3u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(
reserved_future_use1: u8,
mpe_fec_indicator: u8,
time_slice_indicator: u8,
priority: u8,
bandwidth: u8,
code_rate_hp_stream: u8,
hierarchy_information: u8,
constellation: u8,
other_frequency_flag: u8,
transmission_mode: u8,
guard_interval: u8,
code_rate_lp_stream: u8,
) -> __BindgenBitfieldUnit<[u8; 3usize], u8> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 3usize], u8> =
Default::default();
__bindgen_bitfield_unit.set(0usize, 2u8, {
let reserved_future_use1: u8 = unsafe { ::std::mem::transmute(reserved_future_use1) };
reserved_future_use1 as u64
});
__bindgen_bitfield_unit.set(2usize, 1u8, {
let mpe_fec_indicator: u8 = unsafe { ::std::mem::transmute(mpe_fec_indicator) };
mpe_fec_indicator as u64
});
__bindgen_bitfield_unit.set(3usize, 1u8, {
let time_slice_indicator: u8 = unsafe { ::std::mem::transmute(time_slice_indicator) };
time_slice_indicator as u64
});
__bindgen_bitfield_unit.set(4usize, 1u8, {
let priority: u8 = unsafe { ::std::mem::transmute(priority) };
priority as u64
});
__bindgen_bitfield_unit.set(5usize, 3u8, {
let bandwidth: u8 = unsafe { ::std::mem::transmute(bandwidth) };
bandwidth as u64
});
__bindgen_bitfield_unit.set(8usize, 3u8, {
let code_rate_hp_stream: u8 = unsafe { ::std::mem::transmute(code_rate_hp_stream) };
code_rate_hp_stream as u64
});
__bindgen_bitfield_unit.set(11usize, 3u8, {
let hierarchy_information: u8 = unsafe { ::std::mem::transmute(hierarchy_information) };
hierarchy_information as u64
});
__bindgen_bitfield_unit.set(14usize, 2u8, {
let constellation: u8 = unsafe { ::std::mem::transmute(constellation) };
constellation as u64
});
__bindgen_bitfield_unit.set(16usize, 1u8, {
let other_frequency_flag: u8 = unsafe { ::std::mem::transmute(other_frequency_flag) };
other_frequency_flag as u64
});
__bindgen_bitfield_unit.set(17usize, 2u8, {
let transmission_mode: u8 = unsafe { ::std::mem::transmute(transmission_mode) };
transmission_mode as u64
});
__bindgen_bitfield_unit.set(19usize, 2u8, {
let guard_interval: u8 = unsafe { ::std::mem::transmute(guard_interval) };
guard_interval as u64
});
__bindgen_bitfield_unit.set(21usize, 3u8, {
let code_rate_lp_stream: u8 = unsafe { ::std::mem::transmute(code_rate_lp_stream) };
code_rate_lp_stream as u64
});
__bindgen_bitfield_unit
}
}
extern "C" {
pub fn dvb_desc_terrestrial_delivery_init(
parms: *mut dvb_v5_fe_parms,
buf: *const u8,
desc: *mut dvb_desc,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dvb_desc_terrestrial_delivery_print(parms: *mut dvb_v5_fe_parms, desc: *const dvb_desc);
}
extern "C" {
pub static mut dvbt_bw: [::std::os::raw::c_uint; 0usize];
}
extern "C" {
pub static mut dvbt_modulation: [::std::os::raw::c_uint; 0usize];
}
extern "C" {
pub static mut dvbt_hierarchy: [::std::os::raw::c_uint; 0usize];
}
extern "C" {
pub static mut dvbt_code_rate: [::std::os::raw::c_uint; 0usize];
}
extern "C" {
pub static mut dvbt_interval: [u32; 0usize];
}
extern "C" {
pub static mut dvbt_transmission_mode: [::std::os::raw::c_uint; 0usize];
}
#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct dvb_desc_ts_info_transmission_type {
pub transmission_type_info: u8,
pub num_of_service: u8,
}
#[test]
fn bindgen_test_layout_dvb_desc_ts_info_transmission_type() {
assert_eq!(
::std::mem::size_of::<dvb_desc_ts_info_transmission_type>(),
2usize,
concat!("Size of: ", stringify!(dvb_desc_ts_info_transmission_type))
);
assert_eq!(
::std::mem::align_of::<dvb_desc_ts_info_transmission_type>(),
1usize,
concat!(
"Alignment of ",
stringify!(dvb_desc_ts_info_transmission_type)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_desc_ts_info_transmission_type>())).transmission_type_info
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_ts_info_transmission_type),
"::",
stringify!(transmission_type_info)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_desc_ts_info_transmission_type>())).num_of_service
as *const _ as usize
},
1usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_ts_info_transmission_type),
"::",
stringify!(num_of_service)
)
);
}
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub struct dvb_desc_ts_info {
pub type_: u8,
pub length: u8,
pub next: *mut dvb_desc,
pub ts_name: *mut ::std::os::raw::c_char,
pub ts_name_emph: *mut ::std::os::raw::c_char,
pub transmission_type: dvb_desc_ts_info_transmission_type,
pub service_id: *mut u16,
pub __bindgen_anon_1: dvb_desc_ts_info__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union dvb_desc_ts_info__bindgen_ty_1 {
pub bitfield: u16,
pub __bindgen_anon_1: dvb_desc_ts_info__bindgen_ty_1__bindgen_ty_1,
_bindgen_union_align: u16,
}
#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct dvb_desc_ts_info__bindgen_ty_1__bindgen_ty_1 {
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize], u8>,
}
#[test]
fn bindgen_test_layout_dvb_desc_ts_info__bindgen_ty_1__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<dvb_desc_ts_info__bindgen_ty_1__bindgen_ty_1>(),
2usize,
concat!(
"Size of: ",
stringify!(dvb_desc_ts_info__bindgen_ty_1__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<dvb_desc_ts_info__bindgen_ty_1__bindgen_ty_1>(),
1usize,
concat!(
"Alignment of ",
stringify!(dvb_desc_ts_info__bindgen_ty_1__bindgen_ty_1)
)
);
}
impl dvb_desc_ts_info__bindgen_ty_1__bindgen_ty_1 {
#[inline]
pub fn transmission_type_count(&self) -> u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u8) }
}
#[inline]
pub fn set_transmission_type_count(&mut self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 2u8, val as u64)
}
}
#[inline]
pub fn length_of_ts_name(&self) -> u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 6u8) as u8) }
}
#[inline]
pub fn set_length_of_ts_name(&mut self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(2usize, 6u8, val as u64)
}
}
#[inline]
pub fn remote_control_key_id(&self) -> u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 8u8) as u8) }
}
#[inline]
pub fn set_remote_control_key_id(&mut self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(8usize, 8u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(
transmission_type_count: u8,
length_of_ts_name: u8,
remote_control_key_id: u8,
) -> __BindgenBitfieldUnit<[u8; 2usize], u8> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize], u8> =
Default::default();
__bindgen_bitfield_unit.set(0usize, 2u8, {
let transmission_type_count: u8 =
unsafe { ::std::mem::transmute(transmission_type_count) };
transmission_type_count as u64
});
__bindgen_bitfield_unit.set(2usize, 6u8, {
let length_of_ts_name: u8 = unsafe { ::std::mem::transmute(length_of_ts_name) };
length_of_ts_name as u64
});
__bindgen_bitfield_unit.set(8usize, 8u8, {
let remote_control_key_id: u8 = unsafe { ::std::mem::transmute(remote_control_key_id) };
remote_control_key_id as u64
});
__bindgen_bitfield_unit
}
}
#[test]
fn bindgen_test_layout_dvb_desc_ts_info__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<dvb_desc_ts_info__bindgen_ty_1>(),
2usize,
concat!("Size of: ", stringify!(dvb_desc_ts_info__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<dvb_desc_ts_info__bindgen_ty_1>(),
2usize,
concat!("Alignment of ", stringify!(dvb_desc_ts_info__bindgen_ty_1))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_desc_ts_info__bindgen_ty_1>())).bitfield as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_ts_info__bindgen_ty_1),
"::",
stringify!(bitfield)
)
);
}
#[test]
fn bindgen_test_layout_dvb_desc_ts_info() {
assert_eq!(
::std::mem::size_of::<dvb_desc_ts_info>(),
38usize,
concat!("Size of: ", stringify!(dvb_desc_ts_info))
);
assert_eq!(
::std::mem::align_of::<dvb_desc_ts_info>(),
1usize,
concat!("Alignment of ", stringify!(dvb_desc_ts_info))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_desc_ts_info>())).type_ as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_ts_info),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_desc_ts_info>())).length as *const _ as usize },
1usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_ts_info),
"::",
stringify!(length)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_desc_ts_info>())).next as *const _ as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_ts_info),
"::",
stringify!(next)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_desc_ts_info>())).ts_name as *const _ as usize },
10usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_ts_info),
"::",
stringify!(ts_name)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_desc_ts_info>())).ts_name_emph as *const _ as usize },
18usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_ts_info),
"::",
stringify!(ts_name_emph)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_desc_ts_info>())).transmission_type as *const _ as usize
},
26usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_ts_info),
"::",
stringify!(transmission_type)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_desc_ts_info>())).service_id as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(dvb_desc_ts_info),
"::",
stringify!(service_id)
)
);
}
extern "C" {
pub fn dvb_desc_ts_info_init(
parms: *mut dvb_v5_fe_parms,
buf: *const u8,
desc: *mut dvb_desc,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dvb_desc_ts_info_print(parms: *mut dvb_v5_fe_parms, desc: *const dvb_desc);
}
extern "C" {
pub fn dvb_desc_ts_info_free(desc: *mut dvb_desc);
}
pub type __u8 = ::std::os::raw::c_uchar;
pub type __u16 = ::std::os::raw::c_ushort;
pub type __s32 = ::std::os::raw::c_int;
pub type __u32 = ::std::os::raw::c_uint;
pub type __s64 = ::std::os::raw::c_longlong;
pub type __u64 = ::std::os::raw::c_ulonglong;
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum dmx_output {
DMX_OUT_DECODER = 0,
DMX_OUT_TAP = 1,
DMX_OUT_TS_TAP = 2,
DMX_OUT_TSDEMUX_TAP = 3,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum dmx_input {
DMX_IN_FRONTEND = 0,
DMX_IN_DVR = 1,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum dmx_ts_pes {
DMX_PES_AUDIO0 = 0,
DMX_PES_VIDEO0 = 1,
DMX_PES_TELETEXT0 = 2,
DMX_PES_SUBTITLE0 = 3,
DMX_PES_PCR0 = 4,
DMX_PES_AUDIO1 = 5,
DMX_PES_VIDEO1 = 6,
DMX_PES_TELETEXT1 = 7,
DMX_PES_SUBTITLE1 = 8,
DMX_PES_PCR1 = 9,
DMX_PES_AUDIO2 = 10,
DMX_PES_VIDEO2 = 11,
DMX_PES_TELETEXT2 = 12,
DMX_PES_SUBTITLE2 = 13,
DMX_PES_PCR2 = 14,
DMX_PES_AUDIO3 = 15,
DMX_PES_VIDEO3 = 16,
DMX_PES_TELETEXT3 = 17,
DMX_PES_SUBTITLE3 = 18,
DMX_PES_PCR3 = 19,
DMX_PES_OTHER = 20,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dmx_filter {
pub filter: [__u8; 16usize],
pub mask: [__u8; 16usize],
pub mode: [__u8; 16usize],
}
#[test]
fn bindgen_test_layout_dmx_filter() {
assert_eq!(
::std::mem::size_of::<dmx_filter>(),
48usize,
concat!("Size of: ", stringify!(dmx_filter))
);
assert_eq!(
::std::mem::align_of::<dmx_filter>(),
1usize,
concat!("Alignment of ", stringify!(dmx_filter))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dmx_filter>())).filter as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(dmx_filter),
"::",
stringify!(filter)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dmx_filter>())).mask as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(dmx_filter),
"::",
stringify!(mask)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dmx_filter>())).mode as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(dmx_filter),
"::",
stringify!(mode)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dmx_sct_filter_params {
pub pid: __u16,
pub filter: dmx_filter,
pub timeout: __u32,
pub flags: __u32,
}
#[test]
fn bindgen_test_layout_dmx_sct_filter_params() {
assert_eq!(
::std::mem::size_of::<dmx_sct_filter_params>(),
60usize,
concat!("Size of: ", stringify!(dmx_sct_filter_params))
);
assert_eq!(
::std::mem::align_of::<dmx_sct_filter_params>(),
4usize,
concat!("Alignment of ", stringify!(dmx_sct_filter_params))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dmx_sct_filter_params>())).pid as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(dmx_sct_filter_params),
"::",
stringify!(pid)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dmx_sct_filter_params>())).filter as *const _ as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(dmx_sct_filter_params),
"::",
stringify!(filter)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dmx_sct_filter_params>())).timeout as *const _ as usize },
52usize,
concat!(
"Offset of field: ",
stringify!(dmx_sct_filter_params),
"::",
stringify!(timeout)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dmx_sct_filter_params>())).flags as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(dmx_sct_filter_params),
"::",
stringify!(flags)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dmx_pes_filter_params {
pub pid: __u16,
pub input: dmx_input,
pub output: dmx_output,
pub pes_type: dmx_ts_pes,
pub flags: __u32,
}
#[test]
fn bindgen_test_layout_dmx_pes_filter_params() {
assert_eq!(
::std::mem::size_of::<dmx_pes_filter_params>(),
20usize,
concat!("Size of: ", stringify!(dmx_pes_filter_params))
);
assert_eq!(
::std::mem::align_of::<dmx_pes_filter_params>(),
4usize,
concat!("Alignment of ", stringify!(dmx_pes_filter_params))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dmx_pes_filter_params>())).pid as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(dmx_pes_filter_params),
"::",
stringify!(pid)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dmx_pes_filter_params>())).input as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(dmx_pes_filter_params),
"::",
stringify!(input)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dmx_pes_filter_params>())).output as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(dmx_pes_filter_params),
"::",
stringify!(output)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dmx_pes_filter_params>())).pes_type as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(dmx_pes_filter_params),
"::",
stringify!(pes_type)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dmx_pes_filter_params>())).flags as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(dmx_pes_filter_params),
"::",
stringify!(flags)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dmx_stc {
pub num: ::std::os::raw::c_uint,
pub base: ::std::os::raw::c_uint,
pub stc: __u64,
}
#[test]
fn bindgen_test_layout_dmx_stc() {
assert_eq!(
::std::mem::size_of::<dmx_stc>(),
16usize,
concat!("Size of: ", stringify!(dmx_stc))
);
assert_eq!(
::std::mem::align_of::<dmx_stc>(),
8usize,
concat!("Alignment of ", stringify!(dmx_stc))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dmx_stc>())).num as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(dmx_stc),
"::",
stringify!(num)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dmx_stc>())).base as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(dmx_stc),
"::",
stringify!(base)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dmx_stc>())).stc as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(dmx_stc),
"::",
stringify!(stc)
)
);
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum dmx_buffer_flags {
DMX_BUFFER_FLAG_HAD_CRC32_DISCARD = 1,
DMX_BUFFER_FLAG_TEI = 2,
DMX_BUFFER_PKT_COUNTER_MISMATCH = 4,
DMX_BUFFER_FLAG_DISCONTINUITY_DETECTED = 8,
DMX_BUFFER_FLAG_DISCONTINUITY_INDICATOR = 16,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dmx_buffer {
pub index: __u32,
pub bytesused: __u32,
pub offset: __u32,
pub length: __u32,
pub flags: __u32,
pub count: __u32,
}
#[test]
fn bindgen_test_layout_dmx_buffer() {
assert_eq!(
::std::mem::size_of::<dmx_buffer>(),
24usize,
concat!("Size of: ", stringify!(dmx_buffer))
);
assert_eq!(
::std::mem::align_of::<dmx_buffer>(),
4usize,
concat!("Alignment of ", stringify!(dmx_buffer))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dmx_buffer>())).index as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(dmx_buffer),
"::",
stringify!(index)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dmx_buffer>())).bytesused as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(dmx_buffer),
"::",
stringify!(bytesused)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dmx_buffer>())).offset as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(dmx_buffer),
"::",
stringify!(offset)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dmx_buffer>())).length as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(dmx_buffer),
"::",
stringify!(length)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dmx_buffer>())).flags as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(dmx_buffer),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dmx_buffer>())).count as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(dmx_buffer),
"::",
stringify!(count)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dmx_requestbuffers {
pub count: __u32,
pub size: __u32,
}
#[test]
fn bindgen_test_layout_dmx_requestbuffers() {
assert_eq!(
::std::mem::size_of::<dmx_requestbuffers>(),
8usize,
concat!("Size of: ", stringify!(dmx_requestbuffers))
);
assert_eq!(
::std::mem::align_of::<dmx_requestbuffers>(),
4usize,
concat!("Alignment of ", stringify!(dmx_requestbuffers))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dmx_requestbuffers>())).count as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(dmx_requestbuffers),
"::",
stringify!(count)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dmx_requestbuffers>())).size as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(dmx_requestbuffers),
"::",
stringify!(size)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dmx_exportbuffer {
pub index: __u32,
pub flags: __u32,
pub fd: __s32,
}
#[test]
fn bindgen_test_layout_dmx_exportbuffer() {
assert_eq!(
::std::mem::size_of::<dmx_exportbuffer>(),
12usize,
concat!("Size of: ", stringify!(dmx_exportbuffer))
);
assert_eq!(
::std::mem::align_of::<dmx_exportbuffer>(),
4usize,
concat!("Alignment of ", stringify!(dmx_exportbuffer))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dmx_exportbuffer>())).index as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(dmx_exportbuffer),
"::",
stringify!(index)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dmx_exportbuffer>())).flags as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(dmx_exportbuffer),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dmx_exportbuffer>())).fd as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(dmx_exportbuffer),
"::",
stringify!(fd)
)
);
}
pub use self::dmx_input as dmx_input_t;
pub use self::dmx_output as dmx_output_t;
pub use self::dmx_ts_pes as dmx_pes_type_t;
pub type dmx_filter_t = dmx_filter;
extern "C" {
pub fn dvb_dmx_open(
adapter: ::std::os::raw::c_int,
demux: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dvb_dmx_close(dmx_fd: ::std::os::raw::c_int);
}
extern "C" {
pub fn dvb_dmx_stop(dmx_fd: ::std::os::raw::c_int);
}
extern "C" {
pub fn dvb_set_pesfilter(
dmxfd: ::std::os::raw::c_int,
pid: ::std::os::raw::c_int,
type_: dmx_pes_type_t,
output: dmx_output_t,
buffersize: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dvb_set_section_filter(
dmxfd: ::std::os::raw::c_int,
pid: ::std::os::raw::c_int,
filtsize: ::std::os::raw::c_uint,
filter: *mut ::std::os::raw::c_uchar,
mask: *mut ::std::os::raw::c_uchar,
mode: *mut ::std::os::raw::c_uchar,
flags: ::std::os::raw::c_uint,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dvb_get_pmt_pid(
dmxfd: ::std::os::raw::c_int,
sid: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub static mut sys_nerr: ::std::os::raw::c_int;
}
extern "C" {
pub static mut sys_errlist: [*const ::std::os::raw::c_char; 0usize];
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum fe_caps {
FE_IS_STUPID = 0,
FE_CAN_INVERSION_AUTO = 1,
FE_CAN_FEC_1_2 = 2,
FE_CAN_FEC_2_3 = 4,
FE_CAN_FEC_3_4 = 8,
FE_CAN_FEC_4_5 = 16,
FE_CAN_FEC_5_6 = 32,
FE_CAN_FEC_6_7 = 64,
FE_CAN_FEC_7_8 = 128,
FE_CAN_FEC_8_9 = 256,
FE_CAN_FEC_AUTO = 512,
FE_CAN_QPSK = 1024,
FE_CAN_QAM_16 = 2048,
FE_CAN_QAM_32 = 4096,
FE_CAN_QAM_64 = 8192,
FE_CAN_QAM_128 = 16384,
FE_CAN_QAM_256 = 32768,
FE_CAN_QAM_AUTO = 65536,
FE_CAN_TRANSMISSION_MODE_AUTO = 131072,
FE_CAN_BANDWIDTH_AUTO = 262144,
FE_CAN_GUARD_INTERVAL_AUTO = 524288,
FE_CAN_HIERARCHY_AUTO = 1048576,
FE_CAN_8VSB = 2097152,
FE_CAN_16VSB = 4194304,
FE_HAS_EXTENDED_CAPS = 8388608,
FE_CAN_MULTISTREAM = 67108864,
FE_CAN_TURBO_FEC = 134217728,
FE_CAN_2G_MODULATION = 268435456,
FE_NEEDS_BENDING = 536870912,
FE_CAN_RECOVER = 1073741824,
FE_CAN_MUTE_TS = 2147483648,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum fe_type {
FE_QPSK = 0,
FE_QAM = 1,
FE_OFDM = 2,
FE_ATSC = 3,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct dvb_frontend_info {
pub name: [::std::os::raw::c_char; 128usize],
pub type_: fe_type,
pub frequency_min: __u32,
pub frequency_max: __u32,
pub frequency_stepsize: __u32,
pub frequency_tolerance: __u32,
pub symbol_rate_min: __u32,
pub symbol_rate_max: __u32,
pub symbol_rate_tolerance: __u32,
pub notifier_delay: __u32,
pub caps: fe_caps,
}
#[test]
fn bindgen_test_layout_dvb_frontend_info() {
assert_eq!(
::std::mem::size_of::<dvb_frontend_info>(),
168usize,
concat!("Size of: ", stringify!(dvb_frontend_info))
);
assert_eq!(
::std::mem::align_of::<dvb_frontend_info>(),
4usize,
concat!("Alignment of ", stringify!(dvb_frontend_info))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_frontend_info>())).name as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_frontend_info),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_frontend_info>())).type_ as *const _ as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(dvb_frontend_info),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_frontend_info>())).frequency_min as *const _ as usize },
132usize,
concat!(
"Offset of field: ",
stringify!(dvb_frontend_info),
"::",
stringify!(frequency_min)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_frontend_info>())).frequency_max as *const _ as usize },
136usize,
concat!(
"Offset of field: ",
stringify!(dvb_frontend_info),
"::",
stringify!(frequency_max)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_frontend_info>())).frequency_stepsize as *const _ as usize
},
140usize,
concat!(
"Offset of field: ",
stringify!(dvb_frontend_info),
"::",
stringify!(frequency_stepsize)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_frontend_info>())).frequency_tolerance as *const _ as usize
},
144usize,
concat!(
"Offset of field: ",
stringify!(dvb_frontend_info),
"::",
stringify!(frequency_tolerance)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_frontend_info>())).symbol_rate_min as *const _ as usize
},
148usize,
concat!(
"Offset of field: ",
stringify!(dvb_frontend_info),
"::",
stringify!(symbol_rate_min)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_frontend_info>())).symbol_rate_max as *const _ as usize
},
152usize,
concat!(
"Offset of field: ",
stringify!(dvb_frontend_info),
"::",
stringify!(symbol_rate_max)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_frontend_info>())).symbol_rate_tolerance as *const _ as usize
},
156usize,
concat!(
"Offset of field: ",
stringify!(dvb_frontend_info),
"::",
stringify!(symbol_rate_tolerance)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_frontend_info>())).notifier_delay as *const _ as usize
},
160usize,
concat!(
"Offset of field: ",
stringify!(dvb_frontend_info),
"::",
stringify!(notifier_delay)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_frontend_info>())).caps as *const _ as usize },
164usize,
concat!(
"Offset of field: ",
stringify!(dvb_frontend_info),
"::",
stringify!(caps)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dvb_diseqc_master_cmd {
pub msg: [__u8; 6usize],
pub msg_len: __u8,
}
#[test]
fn bindgen_test_layout_dvb_diseqc_master_cmd() {
assert_eq!(
::std::mem::size_of::<dvb_diseqc_master_cmd>(),
7usize,
concat!("Size of: ", stringify!(dvb_diseqc_master_cmd))
);
assert_eq!(
::std::mem::align_of::<dvb_diseqc_master_cmd>(),
1usize,
concat!("Alignment of ", stringify!(dvb_diseqc_master_cmd))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_diseqc_master_cmd>())).msg as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_diseqc_master_cmd),
"::",
stringify!(msg)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_diseqc_master_cmd>())).msg_len as *const _ as usize },
6usize,
concat!(
"Offset of field: ",
stringify!(dvb_diseqc_master_cmd),
"::",
stringify!(msg_len)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dvb_diseqc_slave_reply {
pub msg: [__u8; 4usize],
pub msg_len: __u8,
pub timeout: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_dvb_diseqc_slave_reply() {
assert_eq!(
::std::mem::size_of::<dvb_diseqc_slave_reply>(),
12usize,
concat!("Size of: ", stringify!(dvb_diseqc_slave_reply))
);
assert_eq!(
::std::mem::align_of::<dvb_diseqc_slave_reply>(),
4usize,
concat!("Alignment of ", stringify!(dvb_diseqc_slave_reply))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_diseqc_slave_reply>())).msg as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_diseqc_slave_reply),
"::",
stringify!(msg)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_diseqc_slave_reply>())).msg_len as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(dvb_diseqc_slave_reply),
"::",
stringify!(msg_len)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_diseqc_slave_reply>())).timeout as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(dvb_diseqc_slave_reply),
"::",
stringify!(timeout)
)
);
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum fe_sec_voltage {
SEC_VOLTAGE_13 = 0,
SEC_VOLTAGE_18 = 1,
SEC_VOLTAGE_OFF = 2,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum fe_sec_tone_mode {
SEC_TONE_ON = 0,
SEC_TONE_OFF = 1,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum fe_sec_mini_cmd {
SEC_MINI_A = 0,
SEC_MINI_B = 1,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum fe_status {
FE_NONE = 0,
FE_HAS_SIGNAL = 1,
FE_HAS_CARRIER = 2,
FE_HAS_VITERBI = 4,
FE_HAS_SYNC = 8,
FE_HAS_LOCK = 16,
FE_TIMEDOUT = 32,
FE_REINIT = 64,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum fe_spectral_inversion {
INVERSION_OFF = 0,
INVERSION_ON = 1,
INVERSION_AUTO = 2,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum fe_code_rate {
FEC_NONE = 0,
FEC_1_2 = 1,
FEC_2_3 = 2,
FEC_3_4 = 3,
FEC_4_5 = 4,
FEC_5_6 = 5,
FEC_6_7 = 6,
FEC_7_8 = 7,
FEC_8_9 = 8,
FEC_AUTO = 9,
FEC_3_5 = 10,
FEC_9_10 = 11,
FEC_2_5 = 12,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum fe_modulation {
QPSK = 0,
QAM_16 = 1,
QAM_32 = 2,
QAM_64 = 3,
QAM_128 = 4,
QAM_256 = 5,
QAM_AUTO = 6,
VSB_8 = 7,
VSB_16 = 8,
PSK_8 = 9,
APSK_16 = 10,
APSK_32 = 11,
DQPSK = 12,
QAM_4_NR = 13,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum fe_transmit_mode {
TRANSMISSION_MODE_2K = 0,
TRANSMISSION_MODE_8K = 1,
TRANSMISSION_MODE_AUTO = 2,
TRANSMISSION_MODE_4K = 3,
TRANSMISSION_MODE_1K = 4,
TRANSMISSION_MODE_16K = 5,
TRANSMISSION_MODE_32K = 6,
TRANSMISSION_MODE_C1 = 7,
TRANSMISSION_MODE_C3780 = 8,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum fe_guard_interval {
GUARD_INTERVAL_1_32 = 0,
GUARD_INTERVAL_1_16 = 1,
GUARD_INTERVAL_1_8 = 2,
GUARD_INTERVAL_1_4 = 3,
GUARD_INTERVAL_AUTO = 4,
GUARD_INTERVAL_1_128 = 5,
GUARD_INTERVAL_19_128 = 6,
GUARD_INTERVAL_19_256 = 7,
GUARD_INTERVAL_PN420 = 8,
GUARD_INTERVAL_PN595 = 9,
GUARD_INTERVAL_PN945 = 10,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum fe_hierarchy {
HIERARCHY_NONE = 0,
HIERARCHY_1 = 1,
HIERARCHY_2 = 2,
HIERARCHY_4 = 3,
HIERARCHY_AUTO = 4,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum fe_interleaving {
INTERLEAVING_NONE = 0,
INTERLEAVING_AUTO = 1,
INTERLEAVING_240 = 2,
INTERLEAVING_720 = 3,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum fe_pilot {
PILOT_ON = 0,
PILOT_OFF = 1,
PILOT_AUTO = 2,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum fe_rolloff {
ROLLOFF_35 = 0,
ROLLOFF_20 = 1,
ROLLOFF_25 = 2,
ROLLOFF_AUTO = 3,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum fe_delivery_system {
SYS_UNDEFINED = 0,
SYS_DVBC_ANNEX_A = 1,
SYS_DVBC_ANNEX_B = 2,
SYS_DVBT = 3,
SYS_DSS = 4,
SYS_DVBS = 5,
SYS_DVBS2 = 6,
SYS_DVBH = 7,
SYS_ISDBT = 8,
SYS_ISDBS = 9,
SYS_ISDBC = 10,
SYS_ATSC = 11,
SYS_ATSCMH = 12,
SYS_DTMB = 13,
SYS_CMMB = 14,
SYS_DAB = 15,
SYS_DVBT2 = 16,
SYS_TURBO = 17,
SYS_DVBC_ANNEX_C = 18,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum fecap_scale_params {
FE_SCALE_NOT_AVAILABLE = 0,
FE_SCALE_DECIBEL = 1,
FE_SCALE_RELATIVE = 2,
FE_SCALE_COUNTER = 3,
}
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub struct dtv_stats {
pub scale: __u8,
pub __bindgen_anon_1: dtv_stats__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union dtv_stats__bindgen_ty_1 {
pub uvalue: __u64,
pub svalue: __s64,
_bindgen_union_align: u64,
}
#[test]
fn bindgen_test_layout_dtv_stats__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<dtv_stats__bindgen_ty_1>(),
8usize,
concat!("Size of: ", stringify!(dtv_stats__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<dtv_stats__bindgen_ty_1>(),
8usize,
concat!("Alignment of ", stringify!(dtv_stats__bindgen_ty_1))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dtv_stats__bindgen_ty_1>())).uvalue as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(dtv_stats__bindgen_ty_1),
"::",
stringify!(uvalue)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dtv_stats__bindgen_ty_1>())).svalue as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(dtv_stats__bindgen_ty_1),
"::",
stringify!(svalue)
)
);
}
#[test]
fn bindgen_test_layout_dtv_stats() {
assert_eq!(
::std::mem::size_of::<dtv_stats>(),
9usize,
concat!("Size of: ", stringify!(dtv_stats))
);
assert_eq!(
::std::mem::align_of::<dtv_stats>(),
1usize,
concat!("Alignment of ", stringify!(dtv_stats))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dtv_stats>())).scale as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(dtv_stats),
"::",
stringify!(scale)
)
);
}
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub struct dtv_fe_stats {
pub len: __u8,
pub stat: [dtv_stats; 4usize],
}
#[test]
fn bindgen_test_layout_dtv_fe_stats() {
assert_eq!(
::std::mem::size_of::<dtv_fe_stats>(),
37usize,
concat!("Size of: ", stringify!(dtv_fe_stats))
);
assert_eq!(
::std::mem::align_of::<dtv_fe_stats>(),
1usize,
concat!("Alignment of ", stringify!(dtv_fe_stats))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dtv_fe_stats>())).len as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(dtv_fe_stats),
"::",
stringify!(len)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dtv_fe_stats>())).stat as *const _ as usize },
1usize,
concat!(
"Offset of field: ",
stringify!(dtv_fe_stats),
"::",
stringify!(stat)
)
);
}
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub struct dtv_property {
pub cmd: __u32,
pub reserved: [__u32; 3usize],
pub u: dtv_property__bindgen_ty_1,
pub result: ::std::os::raw::c_int,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union dtv_property__bindgen_ty_1 {
pub data: __u32,
pub st: dtv_fe_stats,
pub buffer: dtv_property__bindgen_ty_1__bindgen_ty_1,
_bindgen_union_align: [u64; 7usize],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dtv_property__bindgen_ty_1__bindgen_ty_1 {
pub data: [__u8; 32usize],
pub len: __u32,
pub reserved1: [__u32; 3usize],
pub reserved2: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout_dtv_property__bindgen_ty_1__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<dtv_property__bindgen_ty_1__bindgen_ty_1>(),
56usize,
concat!(
"Size of: ",
stringify!(dtv_property__bindgen_ty_1__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<dtv_property__bindgen_ty_1__bindgen_ty_1>(),
8usize,
concat!(
"Alignment of ",
stringify!(dtv_property__bindgen_ty_1__bindgen_ty_1)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dtv_property__bindgen_ty_1__bindgen_ty_1>())).data as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(dtv_property__bindgen_ty_1__bindgen_ty_1),
"::",
stringify!(data)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dtv_property__bindgen_ty_1__bindgen_ty_1>())).len as *const _
as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(dtv_property__bindgen_ty_1__bindgen_ty_1),
"::",
stringify!(len)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dtv_property__bindgen_ty_1__bindgen_ty_1>())).reserved1
as *const _ as usize
},
36usize,
concat!(
"Offset of field: ",
stringify!(dtv_property__bindgen_ty_1__bindgen_ty_1),
"::",
stringify!(reserved1)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dtv_property__bindgen_ty_1__bindgen_ty_1>())).reserved2
as *const _ as usize
},
48usize,
concat!(
"Offset of field: ",
stringify!(dtv_property__bindgen_ty_1__bindgen_ty_1),
"::",
stringify!(reserved2)
)
);
}
#[test]
fn bindgen_test_layout_dtv_property__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<dtv_property__bindgen_ty_1>(),
56usize,
concat!("Size of: ", stringify!(dtv_property__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<dtv_property__bindgen_ty_1>(),
8usize,
concat!("Alignment of ", stringify!(dtv_property__bindgen_ty_1))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dtv_property__bindgen_ty_1>())).data as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(dtv_property__bindgen_ty_1),
"::",
stringify!(data)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dtv_property__bindgen_ty_1>())).st as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(dtv_property__bindgen_ty_1),
"::",
stringify!(st)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dtv_property__bindgen_ty_1>())).buffer as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(dtv_property__bindgen_ty_1),
"::",
stringify!(buffer)
)
);
}
#[test]
fn bindgen_test_layout_dtv_property() {
assert_eq!(
::std::mem::size_of::<dtv_property>(),
76usize,
concat!("Size of: ", stringify!(dtv_property))
);
assert_eq!(
::std::mem::align_of::<dtv_property>(),
1usize,
concat!("Alignment of ", stringify!(dtv_property))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dtv_property>())).cmd as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(dtv_property),
"::",
stringify!(cmd)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dtv_property>())).reserved as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(dtv_property),
"::",
stringify!(reserved)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dtv_property>())).u as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(dtv_property),
"::",
stringify!(u)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dtv_property>())).result as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(dtv_property),
"::",
stringify!(result)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dtv_properties {
pub num: __u32,
pub props: *mut dtv_property,
}
#[test]
fn bindgen_test_layout_dtv_properties() {
assert_eq!(
::std::mem::size_of::<dtv_properties>(),
16usize,
concat!("Size of: ", stringify!(dtv_properties))
);
assert_eq!(
::std::mem::align_of::<dtv_properties>(),
8usize,
concat!("Alignment of ", stringify!(dtv_properties))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dtv_properties>())).num as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(dtv_properties),
"::",
stringify!(num)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dtv_properties>())).props as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(dtv_properties),
"::",
stringify!(props)
)
);
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum fe_bandwidth {
BANDWIDTH_8_MHZ = 0,
BANDWIDTH_7_MHZ = 1,
BANDWIDTH_6_MHZ = 2,
BANDWIDTH_AUTO = 3,
BANDWIDTH_5_MHZ = 4,
BANDWIDTH_10_MHZ = 5,
BANDWIDTH_1_712_MHZ = 6,
}
pub use self::fe_bandwidth as fe_bandwidth_t;
pub use self::fe_caps as fe_caps_t;
pub use self::fe_code_rate as fe_code_rate_t;
pub use self::fe_delivery_system as fe_delivery_system_t;
pub use self::fe_guard_interval as fe_guard_interval_t;
pub use self::fe_hierarchy as fe_hierarchy_t;
pub use self::fe_modulation as fe_modulation_t;
pub use self::fe_pilot as fe_pilot_t;
pub use self::fe_rolloff as fe_rolloff_t;
pub use self::fe_sec_mini_cmd as fe_sec_mini_cmd_t;
pub use self::fe_sec_tone_mode as fe_sec_tone_mode_t;
pub use self::fe_sec_voltage as fe_sec_voltage_t;
pub use self::fe_spectral_inversion as fe_spectral_inversion_t;
pub use self::fe_status as fe_status_t;
pub use self::fe_transmit_mode as fe_transmit_mode_t;
pub use self::fe_type as fe_type_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dvb_qpsk_parameters {
pub symbol_rate: __u32,
pub fec_inner: fe_code_rate_t,
}
#[test]
fn bindgen_test_layout_dvb_qpsk_parameters() {
assert_eq!(
::std::mem::size_of::<dvb_qpsk_parameters>(),
8usize,
concat!("Size of: ", stringify!(dvb_qpsk_parameters))
);
assert_eq!(
::std::mem::align_of::<dvb_qpsk_parameters>(),
4usize,
concat!("Alignment of ", stringify!(dvb_qpsk_parameters))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_qpsk_parameters>())).symbol_rate as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_qpsk_parameters),
"::",
stringify!(symbol_rate)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_qpsk_parameters>())).fec_inner as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(dvb_qpsk_parameters),
"::",
stringify!(fec_inner)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dvb_qam_parameters {
pub symbol_rate: __u32,
pub fec_inner: fe_code_rate_t,
pub modulation: fe_modulation_t,
}
#[test]
fn bindgen_test_layout_dvb_qam_parameters() {
assert_eq!(
::std::mem::size_of::<dvb_qam_parameters>(),
12usize,
concat!("Size of: ", stringify!(dvb_qam_parameters))
);
assert_eq!(
::std::mem::align_of::<dvb_qam_parameters>(),
4usize,
concat!("Alignment of ", stringify!(dvb_qam_parameters))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_qam_parameters>())).symbol_rate as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_qam_parameters),
"::",
stringify!(symbol_rate)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_qam_parameters>())).fec_inner as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(dvb_qam_parameters),
"::",
stringify!(fec_inner)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_qam_parameters>())).modulation as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(dvb_qam_parameters),
"::",
stringify!(modulation)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dvb_vsb_parameters {
pub modulation: fe_modulation_t,
}
#[test]
fn bindgen_test_layout_dvb_vsb_parameters() {
assert_eq!(
::std::mem::size_of::<dvb_vsb_parameters>(),
4usize,
concat!("Size of: ", stringify!(dvb_vsb_parameters))
);
assert_eq!(
::std::mem::align_of::<dvb_vsb_parameters>(),
4usize,
concat!("Alignment of ", stringify!(dvb_vsb_parameters))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_vsb_parameters>())).modulation as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_vsb_parameters),
"::",
stringify!(modulation)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dvb_ofdm_parameters {
pub bandwidth: fe_bandwidth_t,
pub code_rate_HP: fe_code_rate_t,
pub code_rate_LP: fe_code_rate_t,
pub constellation: fe_modulation_t,
pub transmission_mode: fe_transmit_mode_t,
pub guard_interval: fe_guard_interval_t,
pub hierarchy_information: fe_hierarchy_t,
}
#[test]
fn bindgen_test_layout_dvb_ofdm_parameters() {
assert_eq!(
::std::mem::size_of::<dvb_ofdm_parameters>(),
28usize,
concat!("Size of: ", stringify!(dvb_ofdm_parameters))
);
assert_eq!(
::std::mem::align_of::<dvb_ofdm_parameters>(),
4usize,
concat!("Alignment of ", stringify!(dvb_ofdm_parameters))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_ofdm_parameters>())).bandwidth as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_ofdm_parameters),
"::",
stringify!(bandwidth)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_ofdm_parameters>())).code_rate_HP as *const _ as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(dvb_ofdm_parameters),
"::",
stringify!(code_rate_HP)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_ofdm_parameters>())).code_rate_LP as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(dvb_ofdm_parameters),
"::",
stringify!(code_rate_LP)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_ofdm_parameters>())).constellation as *const _ as usize
},
12usize,
concat!(
"Offset of field: ",
stringify!(dvb_ofdm_parameters),
"::",
stringify!(constellation)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_ofdm_parameters>())).transmission_mode as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(dvb_ofdm_parameters),
"::",
stringify!(transmission_mode)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_ofdm_parameters>())).guard_interval as *const _ as usize
},
20usize,
concat!(
"Offset of field: ",
stringify!(dvb_ofdm_parameters),
"::",
stringify!(guard_interval)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_ofdm_parameters>())).hierarchy_information as *const _
as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(dvb_ofdm_parameters),
"::",
stringify!(hierarchy_information)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct dvb_frontend_parameters {
pub frequency: __u32,
pub inversion: fe_spectral_inversion_t,
pub u: dvb_frontend_parameters__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union dvb_frontend_parameters__bindgen_ty_1 {
pub qpsk: dvb_qpsk_parameters,
pub qam: dvb_qam_parameters,
pub ofdm: dvb_ofdm_parameters,
pub vsb: dvb_vsb_parameters,
_bindgen_union_align: [u32; 7usize],
}
#[test]
fn bindgen_test_layout_dvb_frontend_parameters__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<dvb_frontend_parameters__bindgen_ty_1>(),
28usize,
concat!(
"Size of: ",
stringify!(dvb_frontend_parameters__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<dvb_frontend_parameters__bindgen_ty_1>(),
4usize,
concat!(
"Alignment of ",
stringify!(dvb_frontend_parameters__bindgen_ty_1)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_frontend_parameters__bindgen_ty_1>())).qpsk as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_frontend_parameters__bindgen_ty_1),
"::",
stringify!(qpsk)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_frontend_parameters__bindgen_ty_1>())).qam as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_frontend_parameters__bindgen_ty_1),
"::",
stringify!(qam)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_frontend_parameters__bindgen_ty_1>())).ofdm as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_frontend_parameters__bindgen_ty_1),
"::",
stringify!(ofdm)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_frontend_parameters__bindgen_ty_1>())).vsb as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_frontend_parameters__bindgen_ty_1),
"::",
stringify!(vsb)
)
);
}
#[test]
fn bindgen_test_layout_dvb_frontend_parameters() {
assert_eq!(
::std::mem::size_of::<dvb_frontend_parameters>(),
36usize,
concat!("Size of: ", stringify!(dvb_frontend_parameters))
);
assert_eq!(
::std::mem::align_of::<dvb_frontend_parameters>(),
4usize,
concat!("Alignment of ", stringify!(dvb_frontend_parameters))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_frontend_parameters>())).frequency as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_frontend_parameters),
"::",
stringify!(frequency)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_frontend_parameters>())).inversion as *const _ as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(dvb_frontend_parameters),
"::",
stringify!(inversion)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_frontend_parameters>())).u as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(dvb_frontend_parameters),
"::",
stringify!(u)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct dvb_frontend_event {
pub status: fe_status_t,
pub parameters: dvb_frontend_parameters,
}
#[test]
fn bindgen_test_layout_dvb_frontend_event() {
assert_eq!(
::std::mem::size_of::<dvb_frontend_event>(),
40usize,
concat!("Size of: ", stringify!(dvb_frontend_event))
);
assert_eq!(
::std::mem::align_of::<dvb_frontend_event>(),
4usize,
concat!("Alignment of ", stringify!(dvb_frontend_event))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_frontend_event>())).status as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_frontend_event),
"::",
stringify!(status)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_frontend_event>())).parameters as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(dvb_frontend_event),
"::",
stringify!(parameters)
)
);
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum dvb_sat_polarization {
POLARIZATION_OFF = 0,
POLARIZATION_H = 1,
POLARIZATION_V = 2,
POLARIZATION_L = 3,
POLARIZATION_R = 4,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum dvb_quality {
DVB_QUAL_UNKNOWN = 0,
DVB_QUAL_POOR = 1,
DVB_QUAL_OK = 2,
DVB_QUAL_GOOD = 3,
}
extern "C" {
pub static mut sys_dvbt_props: [::std::os::raw::c_uint; 0usize];
}
extern "C" {
pub static mut sys_dvbt2_props: [::std::os::raw::c_uint; 0usize];
}
extern "C" {
pub static mut sys_isdbt_props: [::std::os::raw::c_uint; 0usize];
}
extern "C" {
pub static mut sys_atsc_props: [::std::os::raw::c_uint; 0usize];
}
extern "C" {
pub static mut sys_atscmh_props: [::std::os::raw::c_uint; 0usize];
}
extern "C" {
pub static mut sys_dvbc_annex_ac_props: [::std::os::raw::c_uint; 0usize];
}
extern "C" {
pub static mut sys_dvbc_annex_b_props: [::std::os::raw::c_uint; 0usize];
}
extern "C" {
pub static mut sys_dvbs_props: [::std::os::raw::c_uint; 0usize];
}
extern "C" {
pub static mut sys_dvbs2_props: [::std::os::raw::c_uint; 0usize];
}
extern "C" {
pub static mut sys_turbo_props: [::std::os::raw::c_uint; 0usize];
}
extern "C" {
pub static mut sys_isdbs_props: [::std::os::raw::c_uint; 0usize];
}
extern "C" {
pub static mut dvb_v5_delivery_system: [*const ::std::os::raw::c_uint; 0usize];
}
extern "C" {
pub static mut dvb_sat_pol_name: [*const ::std::os::raw::c_char; 6usize];
}
extern "C" {
pub static mut dvb_user_name: [*const ::std::os::raw::c_char; 14usize];
}
extern "C" {
pub static mut dvb_stat_name: [*const ::std::os::raw::c_char; 6usize];
}
extern "C" {
pub static mut dvb_user_attr_names: [*const ::std::os::raw::c_void; 0usize];
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dvb_sat_lnb {
pub name: *const ::std::os::raw::c_char,
pub alias: *const ::std::os::raw::c_char,
pub lowfreq: ::std::os::raw::c_uint,
pub highfreq: ::std::os::raw::c_uint,
pub rangeswitch: ::std::os::raw::c_uint,
pub freqrange: [dvb_sat_lnb_dvbsat_freqrange; 2usize],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dvb_sat_lnb_dvbsat_freqrange {
pub low: ::std::os::raw::c_uint,
pub high: ::std::os::raw::c_uint,
}
#[test]
fn bindgen_test_layout_dvb_sat_lnb_dvbsat_freqrange() {
assert_eq!(
::std::mem::size_of::<dvb_sat_lnb_dvbsat_freqrange>(),
8usize,
concat!("Size of: ", stringify!(dvb_sat_lnb_dvbsat_freqrange))
);
assert_eq!(
::std::mem::align_of::<dvb_sat_lnb_dvbsat_freqrange>(),
4usize,
concat!("Alignment of ", stringify!(dvb_sat_lnb_dvbsat_freqrange))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_sat_lnb_dvbsat_freqrange>())).low as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_sat_lnb_dvbsat_freqrange),
"::",
stringify!(low)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_sat_lnb_dvbsat_freqrange>())).high as *const _ as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(dvb_sat_lnb_dvbsat_freqrange),
"::",
stringify!(high)
)
);
}
#[test]
fn bindgen_test_layout_dvb_sat_lnb() {
assert_eq!(
::std::mem::size_of::<dvb_sat_lnb>(),
48usize,
concat!("Size of: ", stringify!(dvb_sat_lnb))
);
assert_eq!(
::std::mem::align_of::<dvb_sat_lnb>(),
8usize,
concat!("Alignment of ", stringify!(dvb_sat_lnb))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_sat_lnb>())).name as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_sat_lnb),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_sat_lnb>())).alias as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(dvb_sat_lnb),
"::",
stringify!(alias)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_sat_lnb>())).lowfreq as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(dvb_sat_lnb),
"::",
stringify!(lowfreq)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_sat_lnb>())).highfreq as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(dvb_sat_lnb),
"::",
stringify!(highfreq)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_sat_lnb>())).rangeswitch as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(dvb_sat_lnb),
"::",
stringify!(rangeswitch)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_sat_lnb>())).freqrange as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(dvb_sat_lnb),
"::",
stringify!(freqrange)
)
);
}
extern "C" {
pub fn dvb_sat_search_lnb(name: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dvb_print_lnb(index: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dvb_print_all_lnb();
}
extern "C" {
pub fn dvb_sat_get_lnb(index: ::std::os::raw::c_int) -> *const dvb_sat_lnb;
}
extern "C" {
pub fn dvb_sat_get_lnb_name(index: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn dvb_sat_set_parms(parms: *mut dvb_v5_fe_parms) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dvb_sat_real_freq(
p: *mut dvb_v5_fe_parms,
freq: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
pub type dvb_logfunc = ::std::option::Option<
unsafe extern "C" fn(level: ::std::os::raw::c_int, fmt: *const ::std::os::raw::c_char, ...),
>;
pub type dvb_logfunc_priv = ::std::option::Option<
unsafe extern "C" fn(
logpriv: *mut ::std::os::raw::c_void,
level: ::std::os::raw::c_int,
fmt: *const ::std::os::raw::c_char,
...
),
>;
extern "C" {
pub fn dvb_get_log_priv(
arg1: *mut dvb_v5_fe_parms,
arg2: *mut *mut ::std::os::raw::c_void,
) -> dvb_logfunc_priv;
}
extern "C" {
pub fn dvb_default_log(level: ::std::os::raw::c_int, fmt: *const ::std::os::raw::c_char, ...);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct dvb_v5_fe_parms {
pub info: dvb_frontend_info,
pub version: u32,
pub has_v5_stats: ::std::os::raw::c_int,
pub current_sys: fe_delivery_system_t,
pub num_systems: ::std::os::raw::c_int,
pub systems: [fe_delivery_system_t; 20usize],
pub legacy_fe: ::std::os::raw::c_int,
pub abort: ::std::os::raw::c_int,
pub lna: ::std::os::raw::c_int,
pub lnb: *const dvb_sat_lnb,
pub sat_number: ::std::os::raw::c_int,
pub freq_bpf: ::std::os::raw::c_uint,
pub diseqc_wait: ::std::os::raw::c_uint,
pub verbose: ::std::os::raw::c_uint,
pub logfunc: dvb_logfunc,
pub default_charset: *mut ::std::os::raw::c_char,
pub output_charset: *mut ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout_dvb_v5_fe_parms() {
assert_eq!(
::std::mem::size_of::<dvb_v5_fe_parms>(),
328usize,
concat!("Size of: ", stringify!(dvb_v5_fe_parms))
);
assert_eq!(
::std::mem::align_of::<dvb_v5_fe_parms>(),
8usize,
concat!("Alignment of ", stringify!(dvb_v5_fe_parms))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_v5_fe_parms>())).info as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_v5_fe_parms),
"::",
stringify!(info)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_v5_fe_parms>())).version as *const _ as usize },
168usize,
concat!(
"Offset of field: ",
stringify!(dvb_v5_fe_parms),
"::",
stringify!(version)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_v5_fe_parms>())).has_v5_stats as *const _ as usize },
172usize,
concat!(
"Offset of field: ",
stringify!(dvb_v5_fe_parms),
"::",
stringify!(has_v5_stats)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_v5_fe_parms>())).current_sys as *const _ as usize },
176usize,
concat!(
"Offset of field: ",
stringify!(dvb_v5_fe_parms),
"::",
stringify!(current_sys)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_v5_fe_parms>())).num_systems as *const _ as usize },
180usize,
concat!(
"Offset of field: ",
stringify!(dvb_v5_fe_parms),
"::",
stringify!(num_systems)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_v5_fe_parms>())).systems as *const _ as usize },
184usize,
concat!(
"Offset of field: ",
stringify!(dvb_v5_fe_parms),
"::",
stringify!(systems)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_v5_fe_parms>())).legacy_fe as *const _ as usize },
264usize,
concat!(
"Offset of field: ",
stringify!(dvb_v5_fe_parms),
"::",
stringify!(legacy_fe)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_v5_fe_parms>())).abort as *const _ as usize },
268usize,
concat!(
"Offset of field: ",
stringify!(dvb_v5_fe_parms),
"::",
stringify!(abort)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_v5_fe_parms>())).lna as *const _ as usize },
272usize,
concat!(
"Offset of field: ",
stringify!(dvb_v5_fe_parms),
"::",
stringify!(lna)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_v5_fe_parms>())).lnb as *const _ as usize },
280usize,
concat!(
"Offset of field: ",
stringify!(dvb_v5_fe_parms),
"::",
stringify!(lnb)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_v5_fe_parms>())).sat_number as *const _ as usize },
288usize,
concat!(
"Offset of field: ",
stringify!(dvb_v5_fe_parms),
"::",
stringify!(sat_number)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_v5_fe_parms>())).freq_bpf as *const _ as usize },
292usize,
concat!(
"Offset of field: ",
stringify!(dvb_v5_fe_parms),
"::",
stringify!(freq_bpf)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_v5_fe_parms>())).diseqc_wait as *const _ as usize },
296usize,
concat!(
"Offset of field: ",
stringify!(dvb_v5_fe_parms),
"::",
stringify!(diseqc_wait)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_v5_fe_parms>())).verbose as *const _ as usize },
300usize,
concat!(
"Offset of field: ",
stringify!(dvb_v5_fe_parms),
"::",
stringify!(verbose)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_v5_fe_parms>())).logfunc as *const _ as usize },
304usize,
concat!(
"Offset of field: ",
stringify!(dvb_v5_fe_parms),
"::",
stringify!(logfunc)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_v5_fe_parms>())).default_charset as *const _ as usize },
312usize,
concat!(
"Offset of field: ",
stringify!(dvb_v5_fe_parms),
"::",
stringify!(default_charset)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_v5_fe_parms>())).output_charset as *const _ as usize },
320usize,
concat!(
"Offset of field: ",
stringify!(dvb_v5_fe_parms),
"::",
stringify!(output_charset)
)
);
}
extern "C" {
pub fn dvb_fe_dummy() -> *mut dvb_v5_fe_parms;
}
extern "C" {
pub fn dvb_fe_open_flags(
adapter: ::std::os::raw::c_int,
frontend: ::std::os::raw::c_int,
verbose: ::std::os::raw::c_uint,
use_legacy_call: ::std::os::raw::c_uint,
logfunc: dvb_logfunc,
flags: ::std::os::raw::c_int,
) -> *mut dvb_v5_fe_parms;
}
extern "C" {
pub fn dvb_fe_open(
adapter: ::std::os::raw::c_int,
frontend: ::std::os::raw::c_int,
verbose: ::std::os::raw::c_uint,
use_legacy_call: ::std::os::raw::c_uint,
) -> *mut dvb_v5_fe_parms;
}
extern "C" {
pub fn dvb_fe_open2(
adapter: ::std::os::raw::c_int,
frontend: ::std::os::raw::c_int,
verbose: ::std::os::raw::c_uint,
use_legacy_call: ::std::os::raw::c_uint,
logfunc: dvb_logfunc,
) -> *mut dvb_v5_fe_parms;
}
extern "C" {
pub fn dvb_fe_close(parms: *mut dvb_v5_fe_parms);
}
extern "C" {
pub fn dvb_cmd_name(cmd: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn dvb_attr_names(cmd: ::std::os::raw::c_int) -> *const *const ::std::os::raw::c_char;
}
extern "C" {
pub fn dvb_fe_retrieve_parm(
parms: *const dvb_v5_fe_parms,
cmd: ::std::os::raw::c_uint,
value: *mut u32,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dvb_fe_store_parm(
parms: *mut dvb_v5_fe_parms,
cmd: ::std::os::raw::c_uint,
value: u32,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dvb_set_sys(
parms: *mut dvb_v5_fe_parms,
sys: fe_delivery_system_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dvb_add_parms_for_sys(
parms: *mut dvb_v5_fe_parms,
sys: fe_delivery_system_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dvb_set_compat_delivery_system(
parms: *mut dvb_v5_fe_parms,
desired_system: u32,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dvb_fe_prt_parms(parms: *const dvb_v5_fe_parms);
}
extern "C" {
pub fn dvb_fe_set_parms(parms: *mut dvb_v5_fe_parms) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dvb_fe_get_parms(parms: *mut dvb_v5_fe_parms) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dvb_fe_retrieve_stats_layer(
parms: *mut dvb_v5_fe_parms,
cmd: ::std::os::raw::c_uint,
layer: ::std::os::raw::c_uint,
) -> *mut dtv_stats;
}
extern "C" {
pub fn dvb_fe_retrieve_stats(
parms: *mut dvb_v5_fe_parms,
cmd: ::std::os::raw::c_uint,
value: *mut u32,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dvb_fe_get_stats(parms: *mut dvb_v5_fe_parms) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dvb_fe_retrieve_ber(
parms: *mut dvb_v5_fe_parms,
layer: ::std::os::raw::c_uint,
scale: *mut fecap_scale_params,
) -> f32;
}
extern "C" {
pub fn dvb_fe_retrieve_per(parms: *mut dvb_v5_fe_parms, layer: ::std::os::raw::c_uint) -> f32;
}
extern "C" {
pub fn dvb_fe_retrieve_quality(
parms: *mut dvb_v5_fe_parms,
layer: ::std::os::raw::c_uint,
) -> dvb_quality;
}
extern "C" {
pub fn dvb_fe_snprintf_eng(
buf: *mut ::std::os::raw::c_char,
len: ::std::os::raw::c_int,
val: f32,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dvb_fe_snprintf_stat(
parms: *mut dvb_v5_fe_parms,
cmd: u32,
display_name: *mut ::std::os::raw::c_char,
layer: ::std::os::raw::c_int,
buf: *mut *mut ::std::os::raw::c_char,
len: *mut ::std::os::raw::c_int,
show_layer_name: *mut ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dvb_fe_get_event(parms: *mut dvb_v5_fe_parms) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dvb_fe_sec_voltage(
parms: *mut dvb_v5_fe_parms,
on: ::std::os::raw::c_int,
v18: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dvb_fe_sec_tone(
parms: *mut dvb_v5_fe_parms,
tone: fe_sec_tone_mode_t,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dvb_fe_lnb_high_voltage(
parms: *mut dvb_v5_fe_parms,
on: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dvb_fe_diseqc_burst(
parms: *mut dvb_v5_fe_parms,
mini_b: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dvb_fe_diseqc_cmd(
parms: *mut dvb_v5_fe_parms,
len: ::std::os::raw::c_uint,
buf: *const ::std::os::raw::c_uchar,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dvb_fe_diseqc_reply(
parms: *mut dvb_v5_fe_parms,
len: *mut ::std::os::raw::c_uint,
buf: *mut ::std::os::raw::c_char,
timeout: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dvb_fe_is_satellite(delivery_system: u32) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dvb_fe_set_default_country(
parms: *mut dvb_v5_fe_parms,
country: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub static fe_bandwidth_name: [::std::os::raw::c_uint; 8usize];
}
extern "C" {
pub static mut dvb_v5_name: [*const ::std::os::raw::c_char; 72usize];
}
extern "C" {
pub static mut dvb_v5_attr_names: [*const ::std::os::raw::c_void; 0usize];
}
extern "C" {
pub static mut fe_code_rate_name: [*const ::std::os::raw::c_char; 14usize];
}
extern "C" {
pub static mut fe_modulation_name: [*const ::std::os::raw::c_char; 15usize];
}
extern "C" {
pub static mut fe_transmission_mode_name: [*const ::std::os::raw::c_char; 10usize];
}
extern "C" {
pub static mut fe_guard_interval_name: [*const ::std::os::raw::c_char; 12usize];
}
extern "C" {
pub static mut fe_hierarchy_name: [*const ::std::os::raw::c_char; 6usize];
}
extern "C" {
pub static mut fe_voltage_name: [*const ::std::os::raw::c_char; 4usize];
}
extern "C" {
pub static mut fe_tone_name: [*const ::std::os::raw::c_char; 3usize];
}
extern "C" {
pub static mut fe_inversion_name: [*const ::std::os::raw::c_char; 4usize];
}
extern "C" {
pub static mut fe_pilot_name: [*const ::std::os::raw::c_char; 4usize];
}
extern "C" {
pub static mut fe_rolloff_name: [*const ::std::os::raw::c_char; 5usize];
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dvb_v5_descriptors_program {
pub pat_pgm: *mut dvb_table_pat_program,
pub pmt: *mut dvb_table_pmt,
}
#[test]
fn bindgen_test_layout_dvb_v5_descriptors_program() {
assert_eq!(
::std::mem::size_of::<dvb_v5_descriptors_program>(),
16usize,
concat!("Size of: ", stringify!(dvb_v5_descriptors_program))
);
assert_eq!(
::std::mem::align_of::<dvb_v5_descriptors_program>(),
8usize,
concat!("Alignment of ", stringify!(dvb_v5_descriptors_program))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_v5_descriptors_program>())).pat_pgm as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_v5_descriptors_program),
"::",
stringify!(pat_pgm)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_v5_descriptors_program>())).pmt as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(dvb_v5_descriptors_program),
"::",
stringify!(pmt)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dvb_v5_descriptors {
pub delivery_system: u32,
pub entry: *mut dvb_entry,
pub num_entry: ::std::os::raw::c_uint,
pub pat: *mut dvb_table_pat,
pub vct: *mut atsc_table_vct,
pub program: *mut dvb_v5_descriptors_program,
pub nit: *mut dvb_table_nit,
pub sdt: *mut dvb_table_sdt,
pub num_program: ::std::os::raw::c_uint,
pub other_nits: *mut *mut dvb_table_nit,
pub num_other_nits: ::std::os::raw::c_uint,
pub other_sdts: *mut *mut dvb_table_sdt,
pub num_other_sdts: ::std::os::raw::c_uint,
}
#[test]
fn bindgen_test_layout_dvb_v5_descriptors() {
assert_eq!(
::std::mem::size_of::<dvb_v5_descriptors>(),
104usize,
concat!("Size of: ", stringify!(dvb_v5_descriptors))
);
assert_eq!(
::std::mem::align_of::<dvb_v5_descriptors>(),
8usize,
concat!("Alignment of ", stringify!(dvb_v5_descriptors))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_v5_descriptors>())).delivery_system as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_v5_descriptors),
"::",
stringify!(delivery_system)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_v5_descriptors>())).entry as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(dvb_v5_descriptors),
"::",
stringify!(entry)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_v5_descriptors>())).num_entry as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(dvb_v5_descriptors),
"::",
stringify!(num_entry)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_v5_descriptors>())).pat as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(dvb_v5_descriptors),
"::",
stringify!(pat)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_v5_descriptors>())).vct as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(dvb_v5_descriptors),
"::",
stringify!(vct)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_v5_descriptors>())).program as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(dvb_v5_descriptors),
"::",
stringify!(program)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_v5_descriptors>())).nit as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(dvb_v5_descriptors),
"::",
stringify!(nit)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_v5_descriptors>())).sdt as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(dvb_v5_descriptors),
"::",
stringify!(sdt)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_v5_descriptors>())).num_program as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(dvb_v5_descriptors),
"::",
stringify!(num_program)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_v5_descriptors>())).other_nits as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(dvb_v5_descriptors),
"::",
stringify!(other_nits)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_v5_descriptors>())).num_other_nits as *const _ as usize
},
80usize,
concat!(
"Offset of field: ",
stringify!(dvb_v5_descriptors),
"::",
stringify!(num_other_nits)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_v5_descriptors>())).other_sdts as *const _ as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(dvb_v5_descriptors),
"::",
stringify!(other_sdts)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_v5_descriptors>())).num_other_sdts as *const _ as usize
},
96usize,
concat!(
"Offset of field: ",
stringify!(dvb_v5_descriptors),
"::",
stringify!(num_other_sdts)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dvb_table_filter {
pub tid: ::std::os::raw::c_uchar,
pub pid: u16,
pub ts_id: ::std::os::raw::c_int,
pub table: *mut *mut ::std::os::raw::c_void,
pub allow_section_gaps: ::std::os::raw::c_int,
pub priv_: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout_dvb_table_filter() {
assert_eq!(
::std::mem::size_of::<dvb_table_filter>(),
32usize,
concat!("Size of: ", stringify!(dvb_table_filter))
);
assert_eq!(
::std::mem::align_of::<dvb_table_filter>(),
8usize,
concat!("Alignment of ", stringify!(dvb_table_filter))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_table_filter>())).tid as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_table_filter),
"::",
stringify!(tid)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_table_filter>())).pid as *const _ as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(dvb_table_filter),
"::",
stringify!(pid)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_table_filter>())).ts_id as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(dvb_table_filter),
"::",
stringify!(ts_id)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_table_filter>())).table as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(dvb_table_filter),
"::",
stringify!(table)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_table_filter>())).allow_section_gaps as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(dvb_table_filter),
"::",
stringify!(allow_section_gaps)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_table_filter>())).priv_ as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(dvb_table_filter),
"::",
stringify!(priv_)
)
);
}
extern "C" {
pub fn dvb_table_filter_free(sect: *mut dvb_table_filter);
}
extern "C" {
pub fn dvb_read_section(
parms: *mut dvb_v5_fe_parms,
dmx_fd: ::std::os::raw::c_int,
tid: ::std::os::raw::c_uchar,
pid: u16,
table: *mut *mut ::std::os::raw::c_void,
timeout: ::std::os::raw::c_uint,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dvb_read_section_with_id(
parms: *mut dvb_v5_fe_parms,
dmx_fd: ::std::os::raw::c_int,
tid: ::std::os::raw::c_uchar,
pid: u16,
ts_id: ::std::os::raw::c_int,
table: *mut *mut ::std::os::raw::c_void,
timeout: ::std::os::raw::c_uint,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dvb_read_sections(
parms: *mut dvb_v5_fe_parms,
dmx_fd: ::std::os::raw::c_int,
sect: *mut dvb_table_filter,
timeout: ::std::os::raw::c_uint,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dvb_scan_alloc_handler_table(delivery_system: u32) -> *mut dvb_v5_descriptors;
}
extern "C" {
pub fn dvb_scan_free_handler_table(dvb_scan_handler: *mut dvb_v5_descriptors);
}
extern "C" {
pub fn dvb_get_ts_tables(
parms: *mut dvb_v5_fe_parms,
dmx_fd: ::std::os::raw::c_int,
delivery_system: u32,
other_nit: ::std::os::raw::c_uint,
timeout_multiply: ::std::os::raw::c_uint,
) -> *mut dvb_v5_descriptors;
}
extern "C" {
pub fn dvb_free_ts_tables(dvb_desc: *mut dvb_v5_descriptors);
}
pub type check_frontend_t = ::std::option::Option<
unsafe extern "C" fn(
args: *mut ::std::os::raw::c_void,
parms: *mut dvb_v5_fe_parms,
) -> ::std::os::raw::c_int,
>;
extern "C" {
pub fn dvb_scan_transponder(
parms: *mut dvb_v5_fe_parms,
entry: *mut dvb_entry,
dmx_fd: ::std::os::raw::c_int,
check_frontend: check_frontend_t,
args: *mut ::std::os::raw::c_void,
other_nit: ::std::os::raw::c_uint,
timeout_multiply: ::std::os::raw::c_uint,
) -> *mut dvb_v5_descriptors;
}
extern "C" {
pub fn dvb_add_scaned_transponders(
parms: *mut dvb_v5_fe_parms,
dvb_scan_handler: *mut dvb_v5_descriptors,
first_entry: *mut dvb_entry,
entry: *mut dvb_entry,
);
}
extern "C" {
pub fn dvb_estimate_freq_shift(parms: *mut dvb_v5_fe_parms) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dvb_new_freq_is_needed(
entry: *mut dvb_entry,
last_entry: *mut dvb_entry,
freq: u32,
pol: dvb_sat_polarization,
shift: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dvb_scan_add_entry(
parms: *mut dvb_v5_fe_parms,
first_entry: *mut dvb_entry,
entry: *mut dvb_entry,
freq: u32,
shift: u32,
pol: dvb_sat_polarization,
) -> *mut dvb_entry;
}
extern "C" {
pub fn dvb_new_entry_is_needed(
entry: *mut dvb_entry,
last_entry: *mut dvb_entry,
freq: u32,
shift: ::std::os::raw::c_int,
pol: dvb_sat_polarization,
stream_id: u32,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dvb_scan_add_entry_ex(
parms: *mut dvb_v5_fe_parms,
first_entry: *mut dvb_entry,
entry: *mut dvb_entry,
freq: u32,
shift: u32,
pol: dvb_sat_polarization,
stream_id: u32,
) -> *mut dvb_entry;
}
extern "C" {
pub fn dvb_update_transponders(
parms: *mut dvb_v5_fe_parms,
dvb_scan_handler: *mut dvb_v5_descriptors,
first_entry: *mut dvb_entry,
entry: *mut dvb_entry,
);
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum dvb_dev_type {
DVB_DEVICE_FRONTEND = 0,
DVB_DEVICE_DEMUX = 1,
DVB_DEVICE_DVR = 2,
DVB_DEVICE_NET = 3,
DVB_DEVICE_CA = 4,
DVB_DEVICE_CA_SEC = 5,
DVB_DEVICE_VIDEO = 6,
DVB_DEVICE_AUDIO = 7,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dvb_dev_list {
pub syspath: *mut ::std::os::raw::c_char,
pub path: *mut ::std::os::raw::c_char,
pub sysname: *mut ::std::os::raw::c_char,
pub dvb_type: dvb_dev_type,
pub bus_addr: *mut ::std::os::raw::c_char,
pub bus_id: *mut ::std::os::raw::c_char,
pub manufacturer: *mut ::std::os::raw::c_char,
pub product: *mut ::std::os::raw::c_char,
pub serial: *mut ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout_dvb_dev_list() {
assert_eq!(
::std::mem::size_of::<dvb_dev_list>(),
72usize,
concat!("Size of: ", stringify!(dvb_dev_list))
);
assert_eq!(
::std::mem::align_of::<dvb_dev_list>(),
8usize,
concat!("Alignment of ", stringify!(dvb_dev_list))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_dev_list>())).syspath as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_dev_list),
"::",
stringify!(syspath)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_dev_list>())).path as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(dvb_dev_list),
"::",
stringify!(path)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_dev_list>())).sysname as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(dvb_dev_list),
"::",
stringify!(sysname)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_dev_list>())).dvb_type as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(dvb_dev_list),
"::",
stringify!(dvb_type)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_dev_list>())).bus_addr as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(dvb_dev_list),
"::",
stringify!(bus_addr)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_dev_list>())).bus_id as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(dvb_dev_list),
"::",
stringify!(bus_id)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_dev_list>())).manufacturer as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(dvb_dev_list),
"::",
stringify!(manufacturer)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_dev_list>())).product as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(dvb_dev_list),
"::",
stringify!(product)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_dev_list>())).serial as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(dvb_dev_list),
"::",
stringify!(serial)
)
);
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum dvb_dev_change_type {
DVB_DEV_ADD = 0,
DVB_DEV_CHANGE = 1,
DVB_DEV_REMOVE = 2,
}
pub type dvb_dev_change_t = ::std::option::Option<
unsafe extern "C" fn(
sysname: *mut ::std::os::raw::c_char,
type_: dvb_dev_change_type,
priv_: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int,
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dvb_open_descriptor {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dvb_device {
pub devices: *mut dvb_dev_list,
pub num_devices: ::std::os::raw::c_int,
pub fe_parms: *mut dvb_v5_fe_parms,
}
#[test]
fn bindgen_test_layout_dvb_device() {
assert_eq!(
::std::mem::size_of::<dvb_device>(),
24usize,
concat!("Size of: ", stringify!(dvb_device))
);
assert_eq!(
::std::mem::align_of::<dvb_device>(),
8usize,
concat!("Alignment of ", stringify!(dvb_device))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_device>())).devices as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_device),
"::",
stringify!(devices)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_device>())).num_devices as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(dvb_device),
"::",
stringify!(num_devices)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_device>())).fe_parms as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(dvb_device),
"::",
stringify!(fe_parms)
)
);
}
extern "C" {
pub fn dvb_dev_alloc() -> *mut dvb_device;
}
extern "C" {
pub fn dvb_dev_free(dvb: *mut dvb_device);
}
extern "C" {
pub fn dvb_dev_find(
dvb: *mut dvb_device,
handler: dvb_dev_change_t,
user_priv: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dvb_dev_seek_by_adapter(
dvb: *mut dvb_device,
adapter: ::std::os::raw::c_uint,
num: ::std::os::raw::c_uint,
type_: dvb_dev_type,
) -> *mut dvb_dev_list;
}
extern "C" {
pub fn dvb_get_dev_info(
dvb: *mut dvb_device,
sysname: *const ::std::os::raw::c_char,
) -> *mut dvb_dev_list;
}
extern "C" {
pub fn dvb_dev_stop_monitor(dvb: *mut dvb_device);
}
extern "C" {
pub fn dvb_dev_set_logpriv(
dvb: *mut dvb_device,
verbose: ::std::os::raw::c_uint,
logfunc: dvb_logfunc_priv,
logpriv: *mut ::std::os::raw::c_void,
);
}
extern "C" {
pub fn dvb_dev_set_log(
dvb: *mut dvb_device,
verbose: ::std::os::raw::c_uint,
logfunc: dvb_logfunc,
);
}
extern "C" {
pub fn dvb_dev_open(
dvb: *mut dvb_device,
sysname: *const ::std::os::raw::c_char,
flags: ::std::os::raw::c_int,
) -> *mut dvb_open_descriptor;
}
extern "C" {
pub fn dvb_dev_close(open_dev: *mut dvb_open_descriptor);
}
extern "C" {
pub fn dvb_dev_get_fd(open_dev: *mut dvb_open_descriptor) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dvb_dev_read(
open_dev: *mut dvb_open_descriptor,
buf: *mut ::std::os::raw::c_void,
count: size_t,
) -> ssize_t;
}
extern "C" {
pub fn dvb_dev_dmx_stop(open_dev: *mut dvb_open_descriptor);
}
extern "C" {
pub fn dvb_dev_set_bufsize(
open_dev: *mut dvb_open_descriptor,
buffersize: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dvb_dev_dmx_set_pesfilter(
open_dev: *mut dvb_open_descriptor,
pid: ::std::os::raw::c_int,
type_: dmx_pes_type_t,
output: dmx_output_t,
buffersize: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dvb_dev_dmx_set_section_filter(
open_dev: *mut dvb_open_descriptor,
pid: ::std::os::raw::c_int,
filtsize: ::std::os::raw::c_uint,
filter: *mut ::std::os::raw::c_uchar,
mask: *mut ::std::os::raw::c_uchar,
mode: *mut ::std::os::raw::c_uchar,
flags: ::std::os::raw::c_uint,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dvb_dev_dmx_get_pmt_pid(
open_dev: *mut dvb_open_descriptor,
sid: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dvb_dev_scan(
open_dev: *mut dvb_open_descriptor,
entry: *mut dvb_entry,
check_frontend: check_frontend_t,
args: *mut ::std::os::raw::c_void,
other_nit: ::std::os::raw::c_uint,
timeout_multiply: ::std::os::raw::c_uint,
) -> *mut dvb_v5_descriptors;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dvb_elementary_pid {
pub type_: u8,
pub pid: u16,
}
#[test]
fn bindgen_test_layout_dvb_elementary_pid() {
assert_eq!(
::std::mem::size_of::<dvb_elementary_pid>(),
4usize,
concat!("Size of: ", stringify!(dvb_elementary_pid))
);
assert_eq!(
::std::mem::align_of::<dvb_elementary_pid>(),
2usize,
concat!("Alignment of ", stringify!(dvb_elementary_pid))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_elementary_pid>())).type_ as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_elementary_pid),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_elementary_pid>())).pid as *const _ as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(dvb_elementary_pid),
"::",
stringify!(pid)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct dvb_entry {
pub props: [dtv_property; 70usize],
pub n_props: ::std::os::raw::c_uint,
pub next: *mut dvb_entry,
pub service_id: u16,
pub video_pid: *mut u16,
pub audio_pid: *mut u16,
pub other_el_pid: *mut dvb_elementary_pid,
pub video_pid_len: ::std::os::raw::c_uint,
pub audio_pid_len: ::std::os::raw::c_uint,
pub other_el_pid_len: ::std::os::raw::c_uint,
pub channel: *mut ::std::os::raw::c_char,
pub vchannel: *mut ::std::os::raw::c_char,
pub location: *mut ::std::os::raw::c_char,
pub sat_number: ::std::os::raw::c_int,
pub freq_bpf: ::std::os::raw::c_uint,
pub diseqc_wait: ::std::os::raw::c_uint,
pub lnb: *mut ::std::os::raw::c_char,
pub network_id: u16,
pub transport_id: u16,
}
#[test]
fn bindgen_test_layout_dvb_entry() {
assert_eq!(
::std::mem::size_of::<dvb_entry>(),
5440usize,
concat!("Size of: ", stringify!(dvb_entry))
);
assert_eq!(
::std::mem::align_of::<dvb_entry>(),
8usize,
concat!("Alignment of ", stringify!(dvb_entry))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_entry>())).props as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_entry),
"::",
stringify!(props)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_entry>())).n_props as *const _ as usize },
5320usize,
concat!(
"Offset of field: ",
stringify!(dvb_entry),
"::",
stringify!(n_props)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_entry>())).next as *const _ as usize },
5328usize,
concat!(
"Offset of field: ",
stringify!(dvb_entry),
"::",
stringify!(next)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_entry>())).service_id as *const _ as usize },
5336usize,
concat!(
"Offset of field: ",
stringify!(dvb_entry),
"::",
stringify!(service_id)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_entry>())).video_pid as *const _ as usize },
5344usize,
concat!(
"Offset of field: ",
stringify!(dvb_entry),
"::",
stringify!(video_pid)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_entry>())).audio_pid as *const _ as usize },
5352usize,
concat!(
"Offset of field: ",
stringify!(dvb_entry),
"::",
stringify!(audio_pid)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_entry>())).other_el_pid as *const _ as usize },
5360usize,
concat!(
"Offset of field: ",
stringify!(dvb_entry),
"::",
stringify!(other_el_pid)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_entry>())).video_pid_len as *const _ as usize },
5368usize,
concat!(
"Offset of field: ",
stringify!(dvb_entry),
"::",
stringify!(video_pid_len)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_entry>())).audio_pid_len as *const _ as usize },
5372usize,
concat!(
"Offset of field: ",
stringify!(dvb_entry),
"::",
stringify!(audio_pid_len)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_entry>())).other_el_pid_len as *const _ as usize },
5376usize,
concat!(
"Offset of field: ",
stringify!(dvb_entry),
"::",
stringify!(other_el_pid_len)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_entry>())).channel as *const _ as usize },
5384usize,
concat!(
"Offset of field: ",
stringify!(dvb_entry),
"::",
stringify!(channel)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_entry>())).vchannel as *const _ as usize },
5392usize,
concat!(
"Offset of field: ",
stringify!(dvb_entry),
"::",
stringify!(vchannel)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_entry>())).location as *const _ as usize },
5400usize,
concat!(
"Offset of field: ",
stringify!(dvb_entry),
"::",
stringify!(location)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_entry>())).sat_number as *const _ as usize },
5408usize,
concat!(
"Offset of field: ",
stringify!(dvb_entry),
"::",
stringify!(sat_number)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_entry>())).freq_bpf as *const _ as usize },
5412usize,
concat!(
"Offset of field: ",
stringify!(dvb_entry),
"::",
stringify!(freq_bpf)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_entry>())).diseqc_wait as *const _ as usize },
5416usize,
concat!(
"Offset of field: ",
stringify!(dvb_entry),
"::",
stringify!(diseqc_wait)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_entry>())).lnb as *const _ as usize },
5424usize,
concat!(
"Offset of field: ",
stringify!(dvb_entry),
"::",
stringify!(lnb)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_entry>())).network_id as *const _ as usize },
5432usize,
concat!(
"Offset of field: ",
stringify!(dvb_entry),
"::",
stringify!(network_id)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_entry>())).transport_id as *const _ as usize },
5434usize,
concat!(
"Offset of field: ",
stringify!(dvb_entry),
"::",
stringify!(transport_id)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dvb_file {
pub fname: *mut ::std::os::raw::c_char,
pub n_entries: ::std::os::raw::c_int,
pub first_entry: *mut dvb_entry,
}
#[test]
fn bindgen_test_layout_dvb_file() {
assert_eq!(
::std::mem::size_of::<dvb_file>(),
24usize,
concat!("Size of: ", stringify!(dvb_file))
);
assert_eq!(
::std::mem::align_of::<dvb_file>(),
8usize,
concat!("Alignment of ", stringify!(dvb_file))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_file>())).fname as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_file),
"::",
stringify!(fname)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_file>())).n_entries as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(dvb_file),
"::",
stringify!(n_entries)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_file>())).first_entry as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(dvb_file),
"::",
stringify!(first_entry)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dvb_parse_table {
pub prop: ::std::os::raw::c_uint,
pub table: *mut *const ::std::os::raw::c_char,
pub size: ::std::os::raw::c_uint,
pub mult_factor: ::std::os::raw::c_int,
pub has_default_value: ::std::os::raw::c_int,
pub default_value: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_dvb_parse_table() {
assert_eq!(
::std::mem::size_of::<dvb_parse_table>(),
32usize,
concat!("Size of: ", stringify!(dvb_parse_table))
);
assert_eq!(
::std::mem::align_of::<dvb_parse_table>(),
8usize,
concat!("Alignment of ", stringify!(dvb_parse_table))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_parse_table>())).prop as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_parse_table),
"::",
stringify!(prop)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_parse_table>())).table as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(dvb_parse_table),
"::",
stringify!(table)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_parse_table>())).size as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(dvb_parse_table),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_parse_table>())).mult_factor as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(dvb_parse_table),
"::",
stringify!(mult_factor)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_parse_table>())).has_default_value as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(dvb_parse_table),
"::",
stringify!(has_default_value)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_parse_table>())).default_value as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(dvb_parse_table),
"::",
stringify!(default_value)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dvb_parse_struct {
pub id: *mut ::std::os::raw::c_char,
pub delsys: u32,
pub table: *const dvb_parse_table,
pub size: ::std::os::raw::c_uint,
}
#[test]
fn bindgen_test_layout_dvb_parse_struct() {
assert_eq!(
::std::mem::size_of::<dvb_parse_struct>(),
32usize,
concat!("Size of: ", stringify!(dvb_parse_struct))
);
assert_eq!(
::std::mem::align_of::<dvb_parse_struct>(),
8usize,
concat!("Alignment of ", stringify!(dvb_parse_struct))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_parse_struct>())).id as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_parse_struct),
"::",
stringify!(id)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_parse_struct>())).delsys as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(dvb_parse_struct),
"::",
stringify!(delsys)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_parse_struct>())).table as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(dvb_parse_struct),
"::",
stringify!(table)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_parse_struct>())).size as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(dvb_parse_struct),
"::",
stringify!(size)
)
);
}
#[repr(C)]
#[derive(Debug)]
pub struct dvb_parse_file {
pub has_delsys_id: ::std::os::raw::c_int,
pub delimiter: *mut ::std::os::raw::c_char,
pub formats: __IncompleteArrayField<dvb_parse_struct>,
}
#[test]
fn bindgen_test_layout_dvb_parse_file() {
assert_eq!(
::std::mem::size_of::<dvb_parse_file>(),
16usize,
concat!("Size of: ", stringify!(dvb_parse_file))
);
assert_eq!(
::std::mem::align_of::<dvb_parse_file>(),
8usize,
concat!("Alignment of ", stringify!(dvb_parse_file))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_parse_file>())).has_delsys_id as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_parse_file),
"::",
stringify!(has_delsys_id)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_parse_file>())).delimiter as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(dvb_parse_file),
"::",
stringify!(delimiter)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_parse_file>())).formats as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(dvb_parse_file),
"::",
stringify!(formats)
)
);
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum dvb_file_formats {
FILE_UNKNOWN = 0,
FILE_ZAP = 1,
FILE_CHANNEL = 2,
FILE_DVBV5 = 3,
FILE_VDR = 4,
}
extern "C" {
pub static channel_file_format: dvb_parse_file;
}
extern "C" {
pub static channel_file_zap_format: dvb_parse_file;
}
extern "C" {
pub fn dvb_read_file(fname: *const ::std::os::raw::c_char) -> *mut dvb_file;
}
extern "C" {
pub fn dvb_write_file(
fname: *const ::std::os::raw::c_char,
dvb_file: *mut dvb_file,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dvb_read_file_format(
fname: *const ::std::os::raw::c_char,
delsys: u32,
format: dvb_file_formats,
) -> *mut dvb_file;
}
extern "C" {
pub fn dvb_write_file_format(
fname: *const ::std::os::raw::c_char,
dvb_file: *mut dvb_file,
delsys: u32,
format: dvb_file_formats,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dvb_store_entry_prop(
entry: *mut dvb_entry,
cmd: u32,
value: u32,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dvb_retrieve_entry_prop(
entry: *mut dvb_entry,
cmd: u32,
value: *mut u32,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dvb_store_channel(
dvb_file: *mut *mut dvb_file,
parms: *mut dvb_v5_fe_parms,
dvb_desc: *mut dvb_v5_descriptors,
get_detected: ::std::os::raw::c_int,
get_nit: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dvb_parse_delsys(name: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dvb_parse_format(name: *const ::std::os::raw::c_char) -> dvb_file_formats;
}
extern "C" {
pub fn dvb_parse_format_oneline(
fname: *const ::std::os::raw::c_char,
delsys: u32,
parse_file: *const dvb_parse_file,
) -> *mut dvb_file;
}
extern "C" {
pub fn dvb_write_format_oneline(
fname: *const ::std::os::raw::c_char,
dvb_file: *mut dvb_file,
delsys: u32,
parse_file: *const dvb_parse_file,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dvb_write_format_vdr(
fname: *const ::std::os::raw::c_char,
dvb_file: *mut dvb_file,
) -> ::std::os::raw::c_int;
}
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub struct dvb_table_eit_event {
pub event_id: u16,
pub __bindgen_anon_1: dvb_table_eit_event__bindgen_ty_1,
pub dvbduration: [u8; 3usize],
pub __bindgen_anon_2: dvb_table_eit_event__bindgen_ty_2,
pub descriptor: *mut dvb_desc,
pub next: *mut dvb_table_eit_event,
pub start: tm,
pub duration: u32,
pub service_id: u16,
}
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub union dvb_table_eit_event__bindgen_ty_1 {
pub bitfield1: u16,
pub dvbstart: [u8; 5usize],
_bindgen_union_align: [u8; 5usize],
}
#[test]
fn bindgen_test_layout_dvb_table_eit_event__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<dvb_table_eit_event__bindgen_ty_1>(),
5usize,
concat!("Size of: ", stringify!(dvb_table_eit_event__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<dvb_table_eit_event__bindgen_ty_1>(),
1usize,
concat!(
"Alignment of ",
stringify!(dvb_table_eit_event__bindgen_ty_1)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_table_eit_event__bindgen_ty_1>())).bitfield1 as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_table_eit_event__bindgen_ty_1),
"::",
stringify!(bitfield1)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_table_eit_event__bindgen_ty_1>())).dvbstart as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_table_eit_event__bindgen_ty_1),
"::",
stringify!(dvbstart)
)
);
}
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub union dvb_table_eit_event__bindgen_ty_2 {
pub bitfield2: u16,
pub __bindgen_anon_1: dvb_table_eit_event__bindgen_ty_2__bindgen_ty_1,
_bindgen_union_align: [u8; 2usize],
}
#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct dvb_table_eit_event__bindgen_ty_2__bindgen_ty_1 {
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize], u8>,
}
#[test]
fn bindgen_test_layout_dvb_table_eit_event__bindgen_ty_2__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<dvb_table_eit_event__bindgen_ty_2__bindgen_ty_1>(),
2usize,
concat!(
"Size of: ",
stringify!(dvb_table_eit_event__bindgen_ty_2__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<dvb_table_eit_event__bindgen_ty_2__bindgen_ty_1>(),
1usize,
concat!(
"Alignment of ",
stringify!(dvb_table_eit_event__bindgen_ty_2__bindgen_ty_1)
)
);
}
impl dvb_table_eit_event__bindgen_ty_2__bindgen_ty_1 {
#[inline]
pub fn desc_length(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 12u8) as u16) }
}
#[inline]
pub fn set_desc_length(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 12u8, val as u64)
}
}
#[inline]
pub fn free_CA_mode(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u16) }
}
#[inline]
pub fn set_free_CA_mode(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(12usize, 1u8, val as u64)
}
}
#[inline]
pub fn running_status(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 3u8) as u16) }
}
#[inline]
pub fn set_running_status(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(13usize, 3u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(
desc_length: u16,
free_CA_mode: u16,
running_status: u16,
) -> __BindgenBitfieldUnit<[u8; 2usize], u8> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize], u8> =
Default::default();
__bindgen_bitfield_unit.set(0usize, 12u8, {
let desc_length: u16 = unsafe { ::std::mem::transmute(desc_length) };
desc_length as u64
});
__bindgen_bitfield_unit.set(12usize, 1u8, {
let free_CA_mode: u16 = unsafe { ::std::mem::transmute(free_CA_mode) };
free_CA_mode as u64
});
__bindgen_bitfield_unit.set(13usize, 3u8, {
let running_status: u16 = unsafe { ::std::mem::transmute(running_status) };
running_status as u64
});
__bindgen_bitfield_unit
}
}
#[test]
fn bindgen_test_layout_dvb_table_eit_event__bindgen_ty_2() {
assert_eq!(
::std::mem::size_of::<dvb_table_eit_event__bindgen_ty_2>(),
2usize,
concat!("Size of: ", stringify!(dvb_table_eit_event__bindgen_ty_2))
);
assert_eq!(
::std::mem::align_of::<dvb_table_eit_event__bindgen_ty_2>(),
1usize,
concat!(
"Alignment of ",
stringify!(dvb_table_eit_event__bindgen_ty_2)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_table_eit_event__bindgen_ty_2>())).bitfield2 as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_table_eit_event__bindgen_ty_2),
"::",
stringify!(bitfield2)
)
);
}
#[test]
fn bindgen_test_layout_dvb_table_eit_event() {
assert_eq!(
::std::mem::size_of::<dvb_table_eit_event>(),
90usize,
concat!("Size of: ", stringify!(dvb_table_eit_event))
);
assert_eq!(
::std::mem::align_of::<dvb_table_eit_event>(),
1usize,
concat!("Alignment of ", stringify!(dvb_table_eit_event))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_table_eit_event>())).event_id as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_table_eit_event),
"::",
stringify!(event_id)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_table_eit_event>())).dvbduration as *const _ as usize },
7usize,
concat!(
"Offset of field: ",
stringify!(dvb_table_eit_event),
"::",
stringify!(dvbduration)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_table_eit_event>())).descriptor as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(dvb_table_eit_event),
"::",
stringify!(descriptor)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_table_eit_event>())).next as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(dvb_table_eit_event),
"::",
stringify!(next)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_table_eit_event>())).start as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(dvb_table_eit_event),
"::",
stringify!(start)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_table_eit_event>())).duration as *const _ as usize },
84usize,
concat!(
"Offset of field: ",
stringify!(dvb_table_eit_event),
"::",
stringify!(duration)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_table_eit_event>())).service_id as *const _ as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(dvb_table_eit_event),
"::",
stringify!(service_id)
)
);
}
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub struct dvb_table_eit {
pub header: dvb_table_header,
pub transport_id: u16,
pub network_id: u16,
pub last_segment: u8,
pub last_table_id: u8,
pub event: *mut dvb_table_eit_event,
}
#[test]
fn bindgen_test_layout_dvb_table_eit() {
assert_eq!(
::std::mem::size_of::<dvb_table_eit>(),
22usize,
concat!("Size of: ", stringify!(dvb_table_eit))
);
assert_eq!(
::std::mem::align_of::<dvb_table_eit>(),
1usize,
concat!("Alignment of ", stringify!(dvb_table_eit))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_table_eit>())).header as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_table_eit),
"::",
stringify!(header)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_table_eit>())).transport_id as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(dvb_table_eit),
"::",
stringify!(transport_id)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_table_eit>())).network_id as *const _ as usize },
10usize,
concat!(
"Offset of field: ",
stringify!(dvb_table_eit),
"::",
stringify!(network_id)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_table_eit>())).last_segment as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(dvb_table_eit),
"::",
stringify!(last_segment)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_table_eit>())).last_table_id as *const _ as usize },
13usize,
concat!(
"Offset of field: ",
stringify!(dvb_table_eit),
"::",
stringify!(last_table_id)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_table_eit>())).event as *const _ as usize },
14usize,
concat!(
"Offset of field: ",
stringify!(dvb_table_eit),
"::",
stringify!(event)
)
);
}
extern "C" {
pub static mut dvb_eit_running_status_name: [*const ::std::os::raw::c_char; 8usize];
}
extern "C" {
pub fn dvb_table_eit_init(
parms: *mut dvb_v5_fe_parms,
buf: *const u8,
buflen: ssize_t,
table: *mut *mut dvb_table_eit,
) -> ssize_t;
}
extern "C" {
pub fn dvb_table_eit_free(table: *mut dvb_table_eit);
}
extern "C" {
pub fn dvb_table_eit_print(parms: *mut dvb_v5_fe_parms, table: *mut dvb_table_eit);
}
extern "C" {
pub fn dvb_time(data: *const u8, tm: *mut tm);
}
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub struct atsc_table_mgt_table {
pub type_: u16,
pub __bindgen_anon_1: atsc_table_mgt_table__bindgen_ty_1,
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize], u8>,
pub size: u32,
pub __bindgen_anon_2: atsc_table_mgt_table__bindgen_ty_2,
pub descriptor: *mut dvb_desc,
pub next: *mut atsc_table_mgt_table,
}
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub union atsc_table_mgt_table__bindgen_ty_1 {
pub bitfield: u16,
pub __bindgen_anon_1: atsc_table_mgt_table__bindgen_ty_1__bindgen_ty_1,
_bindgen_union_align: [u8; 2usize],
}
#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct atsc_table_mgt_table__bindgen_ty_1__bindgen_ty_1 {
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize], u8>,
}
#[test]
fn bindgen_test_layout_atsc_table_mgt_table__bindgen_ty_1__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<atsc_table_mgt_table__bindgen_ty_1__bindgen_ty_1>(),
2usize,
concat!(
"Size of: ",
stringify!(atsc_table_mgt_table__bindgen_ty_1__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<atsc_table_mgt_table__bindgen_ty_1__bindgen_ty_1>(),
1usize,
concat!(
"Alignment of ",
stringify!(atsc_table_mgt_table__bindgen_ty_1__bindgen_ty_1)
)
);
}
impl atsc_table_mgt_table__bindgen_ty_1__bindgen_ty_1 {
#[inline]
pub fn pid(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 13u8) as u16) }
}
#[inline]
pub fn set_pid(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 13u8, val as u64)
}
}
#[inline]
pub fn one(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 3u8) as u16) }
}
#[inline]
pub fn set_one(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(13usize, 3u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(pid: u16, one: u16) -> __BindgenBitfieldUnit<[u8; 2usize], u8> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize], u8> =
Default::default();
__bindgen_bitfield_unit.set(0usize, 13u8, {
let pid: u16 = unsafe { ::std::mem::transmute(pid) };
pid as u64
});
__bindgen_bitfield_unit.set(13usize, 3u8, {
let one: u16 = unsafe { ::std::mem::transmute(one) };
one as u64
});
__bindgen_bitfield_unit
}
}
#[test]
fn bindgen_test_layout_atsc_table_mgt_table__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<atsc_table_mgt_table__bindgen_ty_1>(),
2usize,
concat!("Size of: ", stringify!(atsc_table_mgt_table__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<atsc_table_mgt_table__bindgen_ty_1>(),
1usize,
concat!(
"Alignment of ",
stringify!(atsc_table_mgt_table__bindgen_ty_1)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<atsc_table_mgt_table__bindgen_ty_1>())).bitfield as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(atsc_table_mgt_table__bindgen_ty_1),
"::",
stringify!(bitfield)
)
);
}
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub union atsc_table_mgt_table__bindgen_ty_2 {
pub bitfield2: u16,
pub __bindgen_anon_1: atsc_table_mgt_table__bindgen_ty_2__bindgen_ty_1,
_bindgen_union_align: [u8; 2usize],
}
#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct atsc_table_mgt_table__bindgen_ty_2__bindgen_ty_1 {
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize], u8>,
}
#[test]
fn bindgen_test_layout_atsc_table_mgt_table__bindgen_ty_2__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<atsc_table_mgt_table__bindgen_ty_2__bindgen_ty_1>(),
2usize,
concat!(
"Size of: ",
stringify!(atsc_table_mgt_table__bindgen_ty_2__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<atsc_table_mgt_table__bindgen_ty_2__bindgen_ty_1>(),
1usize,
concat!(
"Alignment of ",
stringify!(atsc_table_mgt_table__bindgen_ty_2__bindgen_ty_1)
)
);
}
impl atsc_table_mgt_table__bindgen_ty_2__bindgen_ty_1 {
#[inline]
pub fn desc_length(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 12u8) as u16) }
}
#[inline]
pub fn set_desc_length(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 12u8, val as u64)
}
}
#[inline]
pub fn one3(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 4u8) as u16) }
}
#[inline]
pub fn set_one3(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(12usize, 4u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(desc_length: u16, one3: u16) -> __BindgenBitfieldUnit<[u8; 2usize], u8> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize], u8> =
Default::default();
__bindgen_bitfield_unit.set(0usize, 12u8, {
let desc_length: u16 = unsafe { ::std::mem::transmute(desc_length) };
desc_length as u64
});
__bindgen_bitfield_unit.set(12usize, 4u8, {
let one3: u16 = unsafe { ::std::mem::transmute(one3) };
one3 as u64
});
__bindgen_bitfield_unit
}
}
#[test]
fn bindgen_test_layout_atsc_table_mgt_table__bindgen_ty_2() {
assert_eq!(
::std::mem::size_of::<atsc_table_mgt_table__bindgen_ty_2>(),
2usize,
concat!("Size of: ", stringify!(atsc_table_mgt_table__bindgen_ty_2))
);
assert_eq!(
::std::mem::align_of::<atsc_table_mgt_table__bindgen_ty_2>(),
1usize,
concat!(
"Alignment of ",
stringify!(atsc_table_mgt_table__bindgen_ty_2)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<atsc_table_mgt_table__bindgen_ty_2>())).bitfield2 as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(atsc_table_mgt_table__bindgen_ty_2),
"::",
stringify!(bitfield2)
)
);
}
#[test]
fn bindgen_test_layout_atsc_table_mgt_table() {
assert_eq!(
::std::mem::size_of::<atsc_table_mgt_table>(),
27usize,
concat!("Size of: ", stringify!(atsc_table_mgt_table))
);
assert_eq!(
::std::mem::align_of::<atsc_table_mgt_table>(),
1usize,
concat!("Alignment of ", stringify!(atsc_table_mgt_table))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<atsc_table_mgt_table>())).type_ as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(atsc_table_mgt_table),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<atsc_table_mgt_table>())).size as *const _ as usize },
5usize,
concat!(
"Offset of field: ",
stringify!(atsc_table_mgt_table),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<atsc_table_mgt_table>())).descriptor as *const _ as usize },
11usize,
concat!(
"Offset of field: ",
stringify!(atsc_table_mgt_table),
"::",
stringify!(descriptor)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<atsc_table_mgt_table>())).next as *const _ as usize },
19usize,
concat!(
"Offset of field: ",
stringify!(atsc_table_mgt_table),
"::",
stringify!(next)
)
);
}
impl atsc_table_mgt_table {
#[inline]
pub fn type_version(&self) -> u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 5u8) as u8) }
}
#[inline]
pub fn set_type_version(&mut self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 5u8, val as u64)
}
}
#[inline]
pub fn one2(&self) -> u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 3u8) as u8) }
}
#[inline]
pub fn set_one2(&mut self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(5usize, 3u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(type_version: u8, one2: u8) -> __BindgenBitfieldUnit<[u8; 1usize], u8> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize], u8> =
Default::default();
__bindgen_bitfield_unit.set(0usize, 5u8, {
let type_version: u8 = unsafe { ::std::mem::transmute(type_version) };
type_version as u64
});
__bindgen_bitfield_unit.set(5usize, 3u8, {
let one2: u8 = unsafe { ::std::mem::transmute(one2) };
one2 as u64
});
__bindgen_bitfield_unit
}
}
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub struct atsc_table_mgt {
pub header: dvb_table_header,
pub protocol_version: u8,
pub tables: u16,
pub table: *mut atsc_table_mgt_table,
pub descriptor: *mut dvb_desc,
}
#[test]
fn bindgen_test_layout_atsc_table_mgt() {
assert_eq!(
::std::mem::size_of::<atsc_table_mgt>(),
27usize,
concat!("Size of: ", stringify!(atsc_table_mgt))
);
assert_eq!(
::std::mem::align_of::<atsc_table_mgt>(),
1usize,
concat!("Alignment of ", stringify!(atsc_table_mgt))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<atsc_table_mgt>())).header as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(atsc_table_mgt),
"::",
stringify!(header)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<atsc_table_mgt>())).protocol_version as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(atsc_table_mgt),
"::",
stringify!(protocol_version)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<atsc_table_mgt>())).tables as *const _ as usize },
9usize,
concat!(
"Offset of field: ",
stringify!(atsc_table_mgt),
"::",
stringify!(tables)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<atsc_table_mgt>())).table as *const _ as usize },
11usize,
concat!(
"Offset of field: ",
stringify!(atsc_table_mgt),
"::",
stringify!(table)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<atsc_table_mgt>())).descriptor as *const _ as usize },
19usize,
concat!(
"Offset of field: ",
stringify!(atsc_table_mgt),
"::",
stringify!(descriptor)
)
);
}
extern "C" {
pub fn atsc_table_mgt_init(
parms: *mut dvb_v5_fe_parms,
buf: *const u8,
buflen: ssize_t,
table: *mut *mut atsc_table_mgt,
) -> ssize_t;
}
extern "C" {
pub fn atsc_table_mgt_free(table: *mut atsc_table_mgt);
}
extern "C" {
pub fn atsc_table_mgt_print(parms: *mut dvb_v5_fe_parms, table: *mut atsc_table_mgt);
}
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub struct dvb_mpeg_es_seq_start {
pub __bindgen_anon_1: dvb_mpeg_es_seq_start__bindgen_ty_1,
pub __bindgen_anon_2: dvb_mpeg_es_seq_start__bindgen_ty_2,
pub __bindgen_anon_3: dvb_mpeg_es_seq_start__bindgen_ty_3,
}
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub union dvb_mpeg_es_seq_start__bindgen_ty_1 {
pub bitfield: u32,
pub __bindgen_anon_1: dvb_mpeg_es_seq_start__bindgen_ty_1__bindgen_ty_1,
_bindgen_union_align: [u8; 4usize],
}
#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct dvb_mpeg_es_seq_start__bindgen_ty_1__bindgen_ty_1 {
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize], u8>,
}
#[test]
fn bindgen_test_layout_dvb_mpeg_es_seq_start__bindgen_ty_1__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<dvb_mpeg_es_seq_start__bindgen_ty_1__bindgen_ty_1>(),
4usize,
concat!(
"Size of: ",
stringify!(dvb_mpeg_es_seq_start__bindgen_ty_1__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<dvb_mpeg_es_seq_start__bindgen_ty_1__bindgen_ty_1>(),
1usize,
concat!(
"Alignment of ",
stringify!(dvb_mpeg_es_seq_start__bindgen_ty_1__bindgen_ty_1)
)
);
}
impl dvb_mpeg_es_seq_start__bindgen_ty_1__bindgen_ty_1 {
#[inline]
pub fn type_(&self) -> u32 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 8u8) as u32) }
}
#[inline]
pub fn set_type(&mut self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 8u8, val as u64)
}
}
#[inline]
pub fn sync(&self) -> u32 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 24u8) as u32) }
}
#[inline]
pub fn set_sync(&mut self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(8usize, 24u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(type_: u32, sync: u32) -> __BindgenBitfieldUnit<[u8; 4usize], u8> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize], u8> =
Default::default();
__bindgen_bitfield_unit.set(0usize, 8u8, {
let type_: u32 = unsafe { ::std::mem::transmute(type_) };
type_ as u64
});
__bindgen_bitfield_unit.set(8usize, 24u8, {
let sync: u32 = unsafe { ::std::mem::transmute(sync) };
sync as u64
});
__bindgen_bitfield_unit
}
}
#[test]
fn bindgen_test_layout_dvb_mpeg_es_seq_start__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<dvb_mpeg_es_seq_start__bindgen_ty_1>(),
4usize,
concat!("Size of: ", stringify!(dvb_mpeg_es_seq_start__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<dvb_mpeg_es_seq_start__bindgen_ty_1>(),
1usize,
concat!(
"Alignment of ",
stringify!(dvb_mpeg_es_seq_start__bindgen_ty_1)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_mpeg_es_seq_start__bindgen_ty_1>())).bitfield as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_mpeg_es_seq_start__bindgen_ty_1),
"::",
stringify!(bitfield)
)
);
}
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub union dvb_mpeg_es_seq_start__bindgen_ty_2 {
pub bitfield2: u32,
pub __bindgen_anon_1: dvb_mpeg_es_seq_start__bindgen_ty_2__bindgen_ty_1,
_bindgen_union_align: [u8; 4usize],
}
#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct dvb_mpeg_es_seq_start__bindgen_ty_2__bindgen_ty_1 {
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize], u8>,
}
#[test]
fn bindgen_test_layout_dvb_mpeg_es_seq_start__bindgen_ty_2__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<dvb_mpeg_es_seq_start__bindgen_ty_2__bindgen_ty_1>(),
4usize,
concat!(
"Size of: ",
stringify!(dvb_mpeg_es_seq_start__bindgen_ty_2__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<dvb_mpeg_es_seq_start__bindgen_ty_2__bindgen_ty_1>(),
1usize,
concat!(
"Alignment of ",
stringify!(dvb_mpeg_es_seq_start__bindgen_ty_2__bindgen_ty_1)
)
);
}
impl dvb_mpeg_es_seq_start__bindgen_ty_2__bindgen_ty_1 {
#[inline]
pub fn framerate(&self) -> u32 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u32) }
}
#[inline]
pub fn set_framerate(&mut self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 4u8, val as u64)
}
}
#[inline]
pub fn aspect(&self) -> u32 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 4u8) as u32) }
}
#[inline]
pub fn set_aspect(&mut self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(4usize, 4u8, val as u64)
}
}
#[inline]
pub fn height(&self) -> u32 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 12u8) as u32) }
}
#[inline]
pub fn set_height(&mut self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(8usize, 12u8, val as u64)
}
}
#[inline]
pub fn width(&self) -> u32 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(20usize, 12u8) as u32) }
}
#[inline]
pub fn set_width(&mut self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(20usize, 12u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(
framerate: u32,
aspect: u32,
height: u32,
width: u32,
) -> __BindgenBitfieldUnit<[u8; 4usize], u8> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize], u8> =
Default::default();
__bindgen_bitfield_unit.set(0usize, 4u8, {
let framerate: u32 = unsafe { ::std::mem::transmute(framerate) };
framerate as u64
});
__bindgen_bitfield_unit.set(4usize, 4u8, {
let aspect: u32 = unsafe { ::std::mem::transmute(aspect) };
aspect as u64
});
__bindgen_bitfield_unit.set(8usize, 12u8, {
let height: u32 = unsafe { ::std::mem::transmute(height) };
height as u64
});
__bindgen_bitfield_unit.set(20usize, 12u8, {
let width: u32 = unsafe { ::std::mem::transmute(width) };
width as u64
});
__bindgen_bitfield_unit
}
}
#[test]
fn bindgen_test_layout_dvb_mpeg_es_seq_start__bindgen_ty_2() {
assert_eq!(
::std::mem::size_of::<dvb_mpeg_es_seq_start__bindgen_ty_2>(),
4usize,
concat!("Size of: ", stringify!(dvb_mpeg_es_seq_start__bindgen_ty_2))
);
assert_eq!(
::std::mem::align_of::<dvb_mpeg_es_seq_start__bindgen_ty_2>(),
1usize,
concat!(
"Alignment of ",
stringify!(dvb_mpeg_es_seq_start__bindgen_ty_2)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_mpeg_es_seq_start__bindgen_ty_2>())).bitfield2 as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_mpeg_es_seq_start__bindgen_ty_2),
"::",
stringify!(bitfield2)
)
);
}
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub union dvb_mpeg_es_seq_start__bindgen_ty_3 {
pub bitfield3: u32,
pub __bindgen_anon_1: dvb_mpeg_es_seq_start__bindgen_ty_3__bindgen_ty_1,
_bindgen_union_align: [u8; 4usize],
}
#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct dvb_mpeg_es_seq_start__bindgen_ty_3__bindgen_ty_1 {
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize], u8>,
}
#[test]
fn bindgen_test_layout_dvb_mpeg_es_seq_start__bindgen_ty_3__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<dvb_mpeg_es_seq_start__bindgen_ty_3__bindgen_ty_1>(),
4usize,
concat!(
"Size of: ",
stringify!(dvb_mpeg_es_seq_start__bindgen_ty_3__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<dvb_mpeg_es_seq_start__bindgen_ty_3__bindgen_ty_1>(),
1usize,
concat!(
"Alignment of ",
stringify!(dvb_mpeg_es_seq_start__bindgen_ty_3__bindgen_ty_1)
)
);
}
impl dvb_mpeg_es_seq_start__bindgen_ty_3__bindgen_ty_1 {
#[inline]
pub fn qm_nonintra(&self) -> u32 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
}
#[inline]
pub fn set_qm_nonintra(&mut self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 1u8, val as u64)
}
}
#[inline]
pub fn qm_intra(&self) -> u32 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
}
#[inline]
pub fn set_qm_intra(&mut self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(1usize, 1u8, val as u64)
}
}
#[inline]
pub fn constrained(&self) -> u32 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
}
#[inline]
pub fn set_constrained(&mut self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(2usize, 1u8, val as u64)
}
}
#[inline]
pub fn vbv(&self) -> u32 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 10u8) as u32) }
}
#[inline]
pub fn set_vbv(&mut self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(3usize, 10u8, val as u64)
}
}
#[inline]
pub fn one(&self) -> u32 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) }
}
#[inline]
pub fn set_one(&mut self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(13usize, 1u8, val as u64)
}
}
#[inline]
pub fn bitrate(&self) -> u32 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 18u8) as u32) }
}
#[inline]
pub fn set_bitrate(&mut self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(14usize, 18u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(
qm_nonintra: u32,
qm_intra: u32,
constrained: u32,
vbv: u32,
one: u32,
bitrate: u32,
) -> __BindgenBitfieldUnit<[u8; 4usize], u8> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize], u8> =
Default::default();
__bindgen_bitfield_unit.set(0usize, 1u8, {
let qm_nonintra: u32 = unsafe { ::std::mem::transmute(qm_nonintra) };
qm_nonintra as u64
});
__bindgen_bitfield_unit.set(1usize, 1u8, {
let qm_intra: u32 = unsafe { ::std::mem::transmute(qm_intra) };
qm_intra as u64
});
__bindgen_bitfield_unit.set(2usize, 1u8, {
let constrained: u32 = unsafe { ::std::mem::transmute(constrained) };
constrained as u64
});
__bindgen_bitfield_unit.set(3usize, 10u8, {
let vbv: u32 = unsafe { ::std::mem::transmute(vbv) };
vbv as u64
});
__bindgen_bitfield_unit.set(13usize, 1u8, {
let one: u32 = unsafe { ::std::mem::transmute(one) };
one as u64
});
__bindgen_bitfield_unit.set(14usize, 18u8, {
let bitrate: u32 = unsafe { ::std::mem::transmute(bitrate) };
bitrate as u64
});
__bindgen_bitfield_unit
}
}
#[test]
fn bindgen_test_layout_dvb_mpeg_es_seq_start__bindgen_ty_3() {
assert_eq!(
::std::mem::size_of::<dvb_mpeg_es_seq_start__bindgen_ty_3>(),
4usize,
concat!("Size of: ", stringify!(dvb_mpeg_es_seq_start__bindgen_ty_3))
);
assert_eq!(
::std::mem::align_of::<dvb_mpeg_es_seq_start__bindgen_ty_3>(),
1usize,
concat!(
"Alignment of ",
stringify!(dvb_mpeg_es_seq_start__bindgen_ty_3)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_mpeg_es_seq_start__bindgen_ty_3>())).bitfield3 as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_mpeg_es_seq_start__bindgen_ty_3),
"::",
stringify!(bitfield3)
)
);
}
#[test]
fn bindgen_test_layout_dvb_mpeg_es_seq_start() {
assert_eq!(
::std::mem::size_of::<dvb_mpeg_es_seq_start>(),
12usize,
concat!("Size of: ", stringify!(dvb_mpeg_es_seq_start))
);
assert_eq!(
::std::mem::align_of::<dvb_mpeg_es_seq_start>(),
1usize,
concat!("Alignment of ", stringify!(dvb_mpeg_es_seq_start))
);
}
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub struct dvb_mpeg_es_pic_start {
pub __bindgen_anon_1: dvb_mpeg_es_pic_start__bindgen_ty_1,
pub __bindgen_anon_2: dvb_mpeg_es_pic_start__bindgen_ty_2,
}
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub union dvb_mpeg_es_pic_start__bindgen_ty_1 {
pub bitfield: u32,
pub __bindgen_anon_1: dvb_mpeg_es_pic_start__bindgen_ty_1__bindgen_ty_1,
_bindgen_union_align: [u8; 4usize],
}
#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct dvb_mpeg_es_pic_start__bindgen_ty_1__bindgen_ty_1 {
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize], u8>,
}
#[test]
fn bindgen_test_layout_dvb_mpeg_es_pic_start__bindgen_ty_1__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<dvb_mpeg_es_pic_start__bindgen_ty_1__bindgen_ty_1>(),
4usize,
concat!(
"Size of: ",
stringify!(dvb_mpeg_es_pic_start__bindgen_ty_1__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<dvb_mpeg_es_pic_start__bindgen_ty_1__bindgen_ty_1>(),
1usize,
concat!(
"Alignment of ",
stringify!(dvb_mpeg_es_pic_start__bindgen_ty_1__bindgen_ty_1)
)
);
}
impl dvb_mpeg_es_pic_start__bindgen_ty_1__bindgen_ty_1 {
#[inline]
pub fn type_(&self) -> u32 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 8u8) as u32) }
}
#[inline]
pub fn set_type(&mut self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 8u8, val as u64)
}
}
#[inline]
pub fn sync(&self) -> u32 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 24u8) as u32) }
}
#[inline]
pub fn set_sync(&mut self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(8usize, 24u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(type_: u32, sync: u32) -> __BindgenBitfieldUnit<[u8; 4usize], u8> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize], u8> =
Default::default();
__bindgen_bitfield_unit.set(0usize, 8u8, {
let type_: u32 = unsafe { ::std::mem::transmute(type_) };
type_ as u64
});
__bindgen_bitfield_unit.set(8usize, 24u8, {
let sync: u32 = unsafe { ::std::mem::transmute(sync) };
sync as u64
});
__bindgen_bitfield_unit
}
}
#[test]
fn bindgen_test_layout_dvb_mpeg_es_pic_start__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<dvb_mpeg_es_pic_start__bindgen_ty_1>(),
4usize,
concat!("Size of: ", stringify!(dvb_mpeg_es_pic_start__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<dvb_mpeg_es_pic_start__bindgen_ty_1>(),
1usize,
concat!(
"Alignment of ",
stringify!(dvb_mpeg_es_pic_start__bindgen_ty_1)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_mpeg_es_pic_start__bindgen_ty_1>())).bitfield as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_mpeg_es_pic_start__bindgen_ty_1),
"::",
stringify!(bitfield)
)
);
}
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub union dvb_mpeg_es_pic_start__bindgen_ty_2 {
pub bitfield2: u32,
pub __bindgen_anon_1: dvb_mpeg_es_pic_start__bindgen_ty_2__bindgen_ty_1,
_bindgen_union_align: [u8; 4usize],
}
#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct dvb_mpeg_es_pic_start__bindgen_ty_2__bindgen_ty_1 {
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize], u8>,
}
#[test]
fn bindgen_test_layout_dvb_mpeg_es_pic_start__bindgen_ty_2__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<dvb_mpeg_es_pic_start__bindgen_ty_2__bindgen_ty_1>(),
4usize,
concat!(
"Size of: ",
stringify!(dvb_mpeg_es_pic_start__bindgen_ty_2__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<dvb_mpeg_es_pic_start__bindgen_ty_2__bindgen_ty_1>(),
1usize,
concat!(
"Alignment of ",
stringify!(dvb_mpeg_es_pic_start__bindgen_ty_2__bindgen_ty_1)
)
);
}
impl dvb_mpeg_es_pic_start__bindgen_ty_2__bindgen_ty_1 {
#[inline]
pub fn dummy(&self) -> u32 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 3u8) as u32) }
}
#[inline]
pub fn set_dummy(&mut self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 3u8, val as u64)
}
}
#[inline]
pub fn vbv_delay(&self) -> u32 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 16u8) as u32) }
}
#[inline]
pub fn set_vbv_delay(&mut self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(3usize, 16u8, val as u64)
}
}
#[inline]
pub fn coding_type(&self) -> u32 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 3u8) as u32) }
}
#[inline]
pub fn set_coding_type(&mut self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(19usize, 3u8, val as u64)
}
}
#[inline]
pub fn temporal_ref(&self) -> u32 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(22usize, 10u8) as u32) }
}
#[inline]
pub fn set_temporal_ref(&mut self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(22usize, 10u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(
dummy: u32,
vbv_delay: u32,
coding_type: u32,
temporal_ref: u32,
) -> __BindgenBitfieldUnit<[u8; 4usize], u8> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize], u8> =
Default::default();
__bindgen_bitfield_unit.set(0usize, 3u8, {
let dummy: u32 = unsafe { ::std::mem::transmute(dummy) };
dummy as u64
});
__bindgen_bitfield_unit.set(3usize, 16u8, {
let vbv_delay: u32 = unsafe { ::std::mem::transmute(vbv_delay) };
vbv_delay as u64
});
__bindgen_bitfield_unit.set(19usize, 3u8, {
let coding_type: u32 = unsafe { ::std::mem::transmute(coding_type) };
coding_type as u64
});
__bindgen_bitfield_unit.set(22usize, 10u8, {
let temporal_ref: u32 = unsafe { ::std::mem::transmute(temporal_ref) };
temporal_ref as u64
});
__bindgen_bitfield_unit
}
}
#[test]
fn bindgen_test_layout_dvb_mpeg_es_pic_start__bindgen_ty_2() {
assert_eq!(
::std::mem::size_of::<dvb_mpeg_es_pic_start__bindgen_ty_2>(),
4usize,
concat!("Size of: ", stringify!(dvb_mpeg_es_pic_start__bindgen_ty_2))
);
assert_eq!(
::std::mem::align_of::<dvb_mpeg_es_pic_start__bindgen_ty_2>(),
1usize,
concat!(
"Alignment of ",
stringify!(dvb_mpeg_es_pic_start__bindgen_ty_2)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_mpeg_es_pic_start__bindgen_ty_2>())).bitfield2 as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_mpeg_es_pic_start__bindgen_ty_2),
"::",
stringify!(bitfield2)
)
);
}
#[test]
fn bindgen_test_layout_dvb_mpeg_es_pic_start() {
assert_eq!(
::std::mem::size_of::<dvb_mpeg_es_pic_start>(),
8usize,
concat!("Size of: ", stringify!(dvb_mpeg_es_pic_start))
);
assert_eq!(
::std::mem::align_of::<dvb_mpeg_es_pic_start>(),
1usize,
concat!("Alignment of ", stringify!(dvb_mpeg_es_pic_start))
);
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum dvb_mpeg_es_frame_t {
DVB_MPEG_ES_FRAME_UNKNOWN = 0,
DVB_MPEG_ES_FRAME_I = 1,
DVB_MPEG_ES_FRAME_P = 2,
DVB_MPEG_ES_FRAME_B = 3,
DVB_MPEG_ES_FRAME_D = 4,
}
extern "C" {
pub static mut dvb_mpeg_es_frame_names: [*const ::std::os::raw::c_char; 5usize];
}
extern "C" {
pub fn dvb_mpeg_es_seq_start_init(
buf: *const u8,
buflen: ssize_t,
seq_start: *mut dvb_mpeg_es_seq_start,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dvb_mpeg_es_seq_start_print(
parms: *mut dvb_v5_fe_parms,
seq_start: *mut dvb_mpeg_es_seq_start,
);
}
extern "C" {
pub fn dvb_mpeg_es_pic_start_init(
buf: *const u8,
buflen: ssize_t,
pic_start: *mut dvb_mpeg_es_pic_start,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn dvb_mpeg_es_pic_start_print(
parms: *mut dvb_v5_fe_parms,
pic_start: *mut dvb_mpeg_es_pic_start,
);
}
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub struct ts_t {
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize], u8>,
pub __bindgen_anon_1: ts_t__bindgen_ty_1,
pub __bindgen_anon_2: ts_t__bindgen_ty_2,
}
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub union ts_t__bindgen_ty_1 {
pub bitfield: u16,
pub __bindgen_anon_1: ts_t__bindgen_ty_1__bindgen_ty_1,
_bindgen_union_align: [u8; 2usize],
}
#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct ts_t__bindgen_ty_1__bindgen_ty_1 {
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize], u8>,
}
#[test]
fn bindgen_test_layout_ts_t__bindgen_ty_1__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<ts_t__bindgen_ty_1__bindgen_ty_1>(),
2usize,
concat!("Size of: ", stringify!(ts_t__bindgen_ty_1__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<ts_t__bindgen_ty_1__bindgen_ty_1>(),
1usize,
concat!(
"Alignment of ",
stringify!(ts_t__bindgen_ty_1__bindgen_ty_1)
)
);
}
impl ts_t__bindgen_ty_1__bindgen_ty_1 {
#[inline]
pub fn one1(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u16) }
}
#[inline]
pub fn set_one1(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 1u8, val as u64)
}
}
#[inline]
pub fn bits15(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 15u8) as u16) }
}
#[inline]
pub fn set_bits15(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(1usize, 15u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(one1: u16, bits15: u16) -> __BindgenBitfieldUnit<[u8; 2usize], u8> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize], u8> =
Default::default();
__bindgen_bitfield_unit.set(0usize, 1u8, {
let one1: u16 = unsafe { ::std::mem::transmute(one1) };
one1 as u64
});
__bindgen_bitfield_unit.set(1usize, 15u8, {
let bits15: u16 = unsafe { ::std::mem::transmute(bits15) };
bits15 as u64
});
__bindgen_bitfield_unit
}
}
#[test]
fn bindgen_test_layout_ts_t__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<ts_t__bindgen_ty_1>(),
2usize,
concat!("Size of: ", stringify!(ts_t__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<ts_t__bindgen_ty_1>(),
1usize,
concat!("Alignment of ", stringify!(ts_t__bindgen_ty_1))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ts_t__bindgen_ty_1>())).bitfield as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ts_t__bindgen_ty_1),
"::",
stringify!(bitfield)
)
);
}
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub union ts_t__bindgen_ty_2 {
pub bitfield2: u16,
pub __bindgen_anon_1: ts_t__bindgen_ty_2__bindgen_ty_1,
_bindgen_union_align: [u8; 2usize],
}
#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct ts_t__bindgen_ty_2__bindgen_ty_1 {
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize], u8>,
}
#[test]
fn bindgen_test_layout_ts_t__bindgen_ty_2__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<ts_t__bindgen_ty_2__bindgen_ty_1>(),
2usize,
concat!("Size of: ", stringify!(ts_t__bindgen_ty_2__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<ts_t__bindgen_ty_2__bindgen_ty_1>(),
1usize,
concat!(
"Alignment of ",
stringify!(ts_t__bindgen_ty_2__bindgen_ty_1)
)
);
}
impl ts_t__bindgen_ty_2__bindgen_ty_1 {
#[inline]
pub fn one2(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u16) }
}
#[inline]
pub fn set_one2(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 1u8, val as u64)
}
}
#[inline]
pub fn bits00(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 15u8) as u16) }
}
#[inline]
pub fn set_bits00(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(1usize, 15u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(one2: u16, bits00: u16) -> __BindgenBitfieldUnit<[u8; 2usize], u8> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize], u8> =
Default::default();
__bindgen_bitfield_unit.set(0usize, 1u8, {
let one2: u16 = unsafe { ::std::mem::transmute(one2) };
one2 as u64
});
__bindgen_bitfield_unit.set(1usize, 15u8, {
let bits00: u16 = unsafe { ::std::mem::transmute(bits00) };
bits00 as u64
});
__bindgen_bitfield_unit
}
}
#[test]
fn bindgen_test_layout_ts_t__bindgen_ty_2() {
assert_eq!(
::std::mem::size_of::<ts_t__bindgen_ty_2>(),
2usize,
concat!("Size of: ", stringify!(ts_t__bindgen_ty_2))
);
assert_eq!(
::std::mem::align_of::<ts_t__bindgen_ty_2>(),
1usize,
concat!("Alignment of ", stringify!(ts_t__bindgen_ty_2))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ts_t__bindgen_ty_2>())).bitfield2 as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ts_t__bindgen_ty_2),
"::",
stringify!(bitfield2)
)
);
}
#[test]
fn bindgen_test_layout_ts_t() {
assert_eq!(
::std::mem::size_of::<ts_t>(),
5usize,
concat!("Size of: ", stringify!(ts_t))
);
assert_eq!(
::std::mem::align_of::<ts_t>(),
1usize,
concat!("Alignment of ", stringify!(ts_t))
);
}
impl ts_t {
#[inline]
pub fn one(&self) -> u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
}
#[inline]
pub fn set_one(&mut self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 1u8, val as u64)
}
}
#[inline]
pub fn bits30(&self) -> u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 3u8) as u8) }
}
#[inline]
pub fn set_bits30(&mut self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(1usize, 3u8, val as u64)
}
}
#[inline]
pub fn tag(&self) -> u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 4u8) as u8) }
}
#[inline]
pub fn set_tag(&mut self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(4usize, 4u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(one: u8, bits30: u8, tag: u8) -> __BindgenBitfieldUnit<[u8; 1usize], u8> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize], u8> =
Default::default();
__bindgen_bitfield_unit.set(0usize, 1u8, {
let one: u8 = unsafe { ::std::mem::transmute(one) };
one as u64
});
__bindgen_bitfield_unit.set(1usize, 3u8, {
let bits30: u8 = unsafe { ::std::mem::transmute(bits30) };
bits30 as u64
});
__bindgen_bitfield_unit.set(4usize, 4u8, {
let tag: u8 = unsafe { ::std::mem::transmute(tag) };
tag as u64
});
__bindgen_bitfield_unit
}
}
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub struct dvb_mpeg_pes_optional {
pub __bindgen_anon_1: dvb_mpeg_pes_optional__bindgen_ty_1,
pub length: u8,
pub pts: u64,
pub dts: u64,
}
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub union dvb_mpeg_pes_optional__bindgen_ty_1 {
pub bitfield: u16,
pub __bindgen_anon_1: dvb_mpeg_pes_optional__bindgen_ty_1__bindgen_ty_1,
_bindgen_union_align: [u8; 2usize],
}
#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct dvb_mpeg_pes_optional__bindgen_ty_1__bindgen_ty_1 {
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize], u8>,
}
#[test]
fn bindgen_test_layout_dvb_mpeg_pes_optional__bindgen_ty_1__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<dvb_mpeg_pes_optional__bindgen_ty_1__bindgen_ty_1>(),
2usize,
concat!(
"Size of: ",
stringify!(dvb_mpeg_pes_optional__bindgen_ty_1__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<dvb_mpeg_pes_optional__bindgen_ty_1__bindgen_ty_1>(),
1usize,
concat!(
"Alignment of ",
stringify!(dvb_mpeg_pes_optional__bindgen_ty_1__bindgen_ty_1)
)
);
}
impl dvb_mpeg_pes_optional__bindgen_ty_1__bindgen_ty_1 {
#[inline]
pub fn PES_extension(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u16) }
}
#[inline]
pub fn set_PES_extension(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 1u8, val as u64)
}
}
#[inline]
pub fn PES_CRC(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u16) }
}
#[inline]
pub fn set_PES_CRC(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(1usize, 1u8, val as u64)
}
}
#[inline]
pub fn additional_copy_info(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u16) }
}
#[inline]
pub fn set_additional_copy_info(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(2usize, 1u8, val as u64)
}
}
#[inline]
pub fn DSM_trick_mode(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u16) }
}
#[inline]
pub fn set_DSM_trick_mode(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(3usize, 1u8, val as u64)
}
}
#[inline]
pub fn ES_rate(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u16) }
}
#[inline]
pub fn set_ES_rate(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(4usize, 1u8, val as u64)
}
}
#[inline]
pub fn ESCR(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u16) }
}
#[inline]
pub fn set_ESCR(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(5usize, 1u8, val as u64)
}
}
#[inline]
pub fn PTS_DTS(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 2u8) as u16) }
}
#[inline]
pub fn set_PTS_DTS(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(6usize, 2u8, val as u64)
}
}
#[inline]
pub fn original_or_copy(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u16) }
}
#[inline]
pub fn set_original_or_copy(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(8usize, 1u8, val as u64)
}
}
#[inline]
pub fn copyright(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u16) }
}
#[inline]
pub fn set_copyright(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(9usize, 1u8, val as u64)
}
}
#[inline]
pub fn data_alignment_indicator(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u16) }
}
#[inline]
pub fn set_data_alignment_indicator(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(10usize, 1u8, val as u64)
}
}
#[inline]
pub fn PES_priority(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u16) }
}
#[inline]
pub fn set_PES_priority(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(11usize, 1u8, val as u64)
}
}
#[inline]
pub fn PES_scrambling_control(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 2u8) as u16) }
}
#[inline]
pub fn set_PES_scrambling_control(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(12usize, 2u8, val as u64)
}
}
#[inline]
pub fn two(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 2u8) as u16) }
}
#[inline]
pub fn set_two(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(14usize, 2u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(
PES_extension: u16,
PES_CRC: u16,
additional_copy_info: u16,
DSM_trick_mode: u16,
ES_rate: u16,
ESCR: u16,
PTS_DTS: u16,
original_or_copy: u16,
copyright: u16,
data_alignment_indicator: u16,
PES_priority: u16,
PES_scrambling_control: u16,
two: u16,
) -> __BindgenBitfieldUnit<[u8; 2usize], u8> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize], u8> =
Default::default();
__bindgen_bitfield_unit.set(0usize, 1u8, {
let PES_extension: u16 = unsafe { ::std::mem::transmute(PES_extension) };
PES_extension as u64
});
__bindgen_bitfield_unit.set(1usize, 1u8, {
let PES_CRC: u16 = unsafe { ::std::mem::transmute(PES_CRC) };
PES_CRC as u64
});
__bindgen_bitfield_unit.set(2usize, 1u8, {
let additional_copy_info: u16 = unsafe { ::std::mem::transmute(additional_copy_info) };
additional_copy_info as u64
});
__bindgen_bitfield_unit.set(3usize, 1u8, {
let DSM_trick_mode: u16 = unsafe { ::std::mem::transmute(DSM_trick_mode) };
DSM_trick_mode as u64
});
__bindgen_bitfield_unit.set(4usize, 1u8, {
let ES_rate: u16 = unsafe { ::std::mem::transmute(ES_rate) };
ES_rate as u64
});
__bindgen_bitfield_unit.set(5usize, 1u8, {
let ESCR: u16 = unsafe { ::std::mem::transmute(ESCR) };
ESCR as u64
});
__bindgen_bitfield_unit.set(6usize, 2u8, {
let PTS_DTS: u16 = unsafe { ::std::mem::transmute(PTS_DTS) };
PTS_DTS as u64
});
__bindgen_bitfield_unit.set(8usize, 1u8, {
let original_or_copy: u16 = unsafe { ::std::mem::transmute(original_or_copy) };
original_or_copy as u64
});
__bindgen_bitfield_unit.set(9usize, 1u8, {
let copyright: u16 = unsafe { ::std::mem::transmute(copyright) };
copyright as u64
});
__bindgen_bitfield_unit.set(10usize, 1u8, {
let data_alignment_indicator: u16 =
unsafe { ::std::mem::transmute(data_alignment_indicator) };
data_alignment_indicator as u64
});
__bindgen_bitfield_unit.set(11usize, 1u8, {
let PES_priority: u16 = unsafe { ::std::mem::transmute(PES_priority) };
PES_priority as u64
});
__bindgen_bitfield_unit.set(12usize, 2u8, {
let PES_scrambling_control: u16 =
unsafe { ::std::mem::transmute(PES_scrambling_control) };
PES_scrambling_control as u64
});
__bindgen_bitfield_unit.set(14usize, 2u8, {
let two: u16 = unsafe { ::std::mem::transmute(two) };
two as u64
});
__bindgen_bitfield_unit
}
}
#[test]
fn bindgen_test_layout_dvb_mpeg_pes_optional__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<dvb_mpeg_pes_optional__bindgen_ty_1>(),
2usize,
concat!("Size of: ", stringify!(dvb_mpeg_pes_optional__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<dvb_mpeg_pes_optional__bindgen_ty_1>(),
1usize,
concat!(
"Alignment of ",
stringify!(dvb_mpeg_pes_optional__bindgen_ty_1)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_mpeg_pes_optional__bindgen_ty_1>())).bitfield as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_mpeg_pes_optional__bindgen_ty_1),
"::",
stringify!(bitfield)
)
);
}
#[test]
fn bindgen_test_layout_dvb_mpeg_pes_optional() {
assert_eq!(
::std::mem::size_of::<dvb_mpeg_pes_optional>(),
19usize,
concat!("Size of: ", stringify!(dvb_mpeg_pes_optional))
);
assert_eq!(
::std::mem::align_of::<dvb_mpeg_pes_optional>(),
1usize,
concat!("Alignment of ", stringify!(dvb_mpeg_pes_optional))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_mpeg_pes_optional>())).length as *const _ as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(dvb_mpeg_pes_optional),
"::",
stringify!(length)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_mpeg_pes_optional>())).pts as *const _ as usize },
3usize,
concat!(
"Offset of field: ",
stringify!(dvb_mpeg_pes_optional),
"::",
stringify!(pts)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_mpeg_pes_optional>())).dts as *const _ as usize },
11usize,
concat!(
"Offset of field: ",
stringify!(dvb_mpeg_pes_optional),
"::",
stringify!(dts)
)
);
}
#[repr(C, packed)]
pub struct dvb_mpeg_pes {
pub __bindgen_anon_1: dvb_mpeg_pes__bindgen_ty_1,
pub length: u16,
pub optional: __IncompleteArrayField<dvb_mpeg_pes_optional>,
}
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub union dvb_mpeg_pes__bindgen_ty_1 {
pub bitfield: u32,
pub __bindgen_anon_1: dvb_mpeg_pes__bindgen_ty_1__bindgen_ty_1,
_bindgen_union_align: [u8; 4usize],
}
#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct dvb_mpeg_pes__bindgen_ty_1__bindgen_ty_1 {
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize], u8>,
}
#[test]
fn bindgen_test_layout_dvb_mpeg_pes__bindgen_ty_1__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<dvb_mpeg_pes__bindgen_ty_1__bindgen_ty_1>(),
4usize,
concat!(
"Size of: ",
stringify!(dvb_mpeg_pes__bindgen_ty_1__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<dvb_mpeg_pes__bindgen_ty_1__bindgen_ty_1>(),
1usize,
concat!(
"Alignment of ",
stringify!(dvb_mpeg_pes__bindgen_ty_1__bindgen_ty_1)
)
);
}
impl dvb_mpeg_pes__bindgen_ty_1__bindgen_ty_1 {
#[inline]
pub fn stream_id(&self) -> u32 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 8u8) as u32) }
}
#[inline]
pub fn set_stream_id(&mut self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 8u8, val as u64)
}
}
#[inline]
pub fn sync(&self) -> u32 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 24u8) as u32) }
}
#[inline]
pub fn set_sync(&mut self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(8usize, 24u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(stream_id: u32, sync: u32) -> __BindgenBitfieldUnit<[u8; 4usize], u8> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize], u8> =
Default::default();
__bindgen_bitfield_unit.set(0usize, 8u8, {
let stream_id: u32 = unsafe { ::std::mem::transmute(stream_id) };
stream_id as u64
});
__bindgen_bitfield_unit.set(8usize, 24u8, {
let sync: u32 = unsafe { ::std::mem::transmute(sync) };
sync as u64
});
__bindgen_bitfield_unit
}
}
#[test]
fn bindgen_test_layout_dvb_mpeg_pes__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<dvb_mpeg_pes__bindgen_ty_1>(),
4usize,
concat!("Size of: ", stringify!(dvb_mpeg_pes__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<dvb_mpeg_pes__bindgen_ty_1>(),
1usize,
concat!("Alignment of ", stringify!(dvb_mpeg_pes__bindgen_ty_1))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_mpeg_pes__bindgen_ty_1>())).bitfield as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_mpeg_pes__bindgen_ty_1),
"::",
stringify!(bitfield)
)
);
}
#[test]
fn bindgen_test_layout_dvb_mpeg_pes() {
assert_eq!(
::std::mem::size_of::<dvb_mpeg_pes>(),
6usize,
concat!("Size of: ", stringify!(dvb_mpeg_pes))
);
assert_eq!(
::std::mem::align_of::<dvb_mpeg_pes>(),
1usize,
concat!("Alignment of ", stringify!(dvb_mpeg_pes))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_mpeg_pes>())).length as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(dvb_mpeg_pes),
"::",
stringify!(length)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_mpeg_pes>())).optional as *const _ as usize },
6usize,
concat!(
"Offset of field: ",
stringify!(dvb_mpeg_pes),
"::",
stringify!(optional)
)
);
}
extern "C" {
pub fn dvb_mpeg_pes_init(
parms: *mut dvb_v5_fe_parms,
buf: *const u8,
buflen: ssize_t,
table: *mut u8,
) -> ssize_t;
}
extern "C" {
pub fn dvb_mpeg_pes_free(pes: *mut dvb_mpeg_pes);
}
extern "C" {
pub fn dvb_mpeg_pes_print(parms: *mut dvb_v5_fe_parms, pes: *mut dvb_mpeg_pes);
}
#[repr(C, packed)]
#[derive(Debug)]
pub struct dvb_mpeg_ts_adaption {
pub length: u8,
pub __bindgen_anon_1: dvb_mpeg_ts_adaption__bindgen_ty_1,
pub data: __IncompleteArrayField<u8>,
}
#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct dvb_mpeg_ts_adaption__bindgen_ty_1 {
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize], u8>,
}
#[test]
fn bindgen_test_layout_dvb_mpeg_ts_adaption__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<dvb_mpeg_ts_adaption__bindgen_ty_1>(),
1usize,
concat!("Size of: ", stringify!(dvb_mpeg_ts_adaption__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<dvb_mpeg_ts_adaption__bindgen_ty_1>(),
1usize,
concat!(
"Alignment of ",
stringify!(dvb_mpeg_ts_adaption__bindgen_ty_1)
)
);
}
impl dvb_mpeg_ts_adaption__bindgen_ty_1 {
#[inline]
pub fn extension(&self) -> u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
}
#[inline]
pub fn set_extension(&mut self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 1u8, val as u64)
}
}
#[inline]
pub fn private_data(&self) -> u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
}
#[inline]
pub fn set_private_data(&mut self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(1usize, 1u8, val as u64)
}
}
#[inline]
pub fn splicing_point(&self) -> u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) }
}
#[inline]
pub fn set_splicing_point(&mut self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(2usize, 1u8, val as u64)
}
}
#[inline]
pub fn OPCR(&self) -> u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8) }
}
#[inline]
pub fn set_OPCR(&mut self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(3usize, 1u8, val as u64)
}
}
#[inline]
pub fn PCR(&self) -> u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u8) }
}
#[inline]
pub fn set_PCR(&mut self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(4usize, 1u8, val as u64)
}
}
#[inline]
pub fn priority(&self) -> u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u8) }
}
#[inline]
pub fn set_priority(&mut self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(5usize, 1u8, val as u64)
}
}
#[inline]
pub fn random_access(&self) -> u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u8) }
}
#[inline]
pub fn set_random_access(&mut self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(6usize, 1u8, val as u64)
}
}
#[inline]
pub fn discontinued(&self) -> u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u8) }
}
#[inline]
pub fn set_discontinued(&mut self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(7usize, 1u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(
extension: u8,
private_data: u8,
splicing_point: u8,
OPCR: u8,
PCR: u8,
priority: u8,
random_access: u8,
discontinued: u8,
) -> __BindgenBitfieldUnit<[u8; 1usize], u8> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize], u8> =
Default::default();
__bindgen_bitfield_unit.set(0usize, 1u8, {
let extension: u8 = unsafe { ::std::mem::transmute(extension) };
extension as u64
});
__bindgen_bitfield_unit.set(1usize, 1u8, {
let private_data: u8 = unsafe { ::std::mem::transmute(private_data) };
private_data as u64
});
__bindgen_bitfield_unit.set(2usize, 1u8, {
let splicing_point: u8 = unsafe { ::std::mem::transmute(splicing_point) };
splicing_point as u64
});
__bindgen_bitfield_unit.set(3usize, 1u8, {
let OPCR: u8 = unsafe { ::std::mem::transmute(OPCR) };
OPCR as u64
});
__bindgen_bitfield_unit.set(4usize, 1u8, {
let PCR: u8 = unsafe { ::std::mem::transmute(PCR) };
PCR as u64
});
__bindgen_bitfield_unit.set(5usize, 1u8, {
let priority: u8 = unsafe { ::std::mem::transmute(priority) };
priority as u64
});
__bindgen_bitfield_unit.set(6usize, 1u8, {
let random_access: u8 = unsafe { ::std::mem::transmute(random_access) };
random_access as u64
});
__bindgen_bitfield_unit.set(7usize, 1u8, {
let discontinued: u8 = unsafe { ::std::mem::transmute(discontinued) };
discontinued as u64
});
__bindgen_bitfield_unit
}
}
#[test]
fn bindgen_test_layout_dvb_mpeg_ts_adaption() {
assert_eq!(
::std::mem::size_of::<dvb_mpeg_ts_adaption>(),
2usize,
concat!("Size of: ", stringify!(dvb_mpeg_ts_adaption))
);
assert_eq!(
::std::mem::align_of::<dvb_mpeg_ts_adaption>(),
1usize,
concat!("Alignment of ", stringify!(dvb_mpeg_ts_adaption))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_mpeg_ts_adaption>())).length as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_mpeg_ts_adaption),
"::",
stringify!(length)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_mpeg_ts_adaption>())).data as *const _ as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(dvb_mpeg_ts_adaption),
"::",
stringify!(data)
)
);
}
#[repr(C, packed)]
pub struct dvb_mpeg_ts {
pub sync_byte: u8,
pub __bindgen_anon_1: dvb_mpeg_ts__bindgen_ty_1,
pub __bindgen_anon_2: dvb_mpeg_ts__bindgen_ty_2,
pub adaption: __IncompleteArrayField<dvb_mpeg_ts_adaption>,
}
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub union dvb_mpeg_ts__bindgen_ty_1 {
pub bitfield: u16,
pub __bindgen_anon_1: dvb_mpeg_ts__bindgen_ty_1__bindgen_ty_1,
_bindgen_union_align: [u8; 2usize],
}
#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct dvb_mpeg_ts__bindgen_ty_1__bindgen_ty_1 {
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize], u8>,
}
#[test]
fn bindgen_test_layout_dvb_mpeg_ts__bindgen_ty_1__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<dvb_mpeg_ts__bindgen_ty_1__bindgen_ty_1>(),
2usize,
concat!(
"Size of: ",
stringify!(dvb_mpeg_ts__bindgen_ty_1__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<dvb_mpeg_ts__bindgen_ty_1__bindgen_ty_1>(),
1usize,
concat!(
"Alignment of ",
stringify!(dvb_mpeg_ts__bindgen_ty_1__bindgen_ty_1)
)
);
}
impl dvb_mpeg_ts__bindgen_ty_1__bindgen_ty_1 {
#[inline]
pub fn pid(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 13u8) as u16) }
}
#[inline]
pub fn set_pid(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 13u8, val as u64)
}
}
#[inline]
pub fn priority(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u16) }
}
#[inline]
pub fn set_priority(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(13usize, 1u8, val as u64)
}
}
#[inline]
pub fn payload_start(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u16) }
}
#[inline]
pub fn set_payload_start(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(14usize, 1u8, val as u64)
}
}
#[inline]
pub fn tei(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u16) }
}
#[inline]
pub fn set_tei(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(15usize, 1u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(
pid: u16,
priority: u16,
payload_start: u16,
tei: u16,
) -> __BindgenBitfieldUnit<[u8; 2usize], u8> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize], u8> =
Default::default();
__bindgen_bitfield_unit.set(0usize, 13u8, {
let pid: u16 = unsafe { ::std::mem::transmute(pid) };
pid as u64
});
__bindgen_bitfield_unit.set(13usize, 1u8, {
let priority: u16 = unsafe { ::std::mem::transmute(priority) };
priority as u64
});
__bindgen_bitfield_unit.set(14usize, 1u8, {
let payload_start: u16 = unsafe { ::std::mem::transmute(payload_start) };
payload_start as u64
});
__bindgen_bitfield_unit.set(15usize, 1u8, {
let tei: u16 = unsafe { ::std::mem::transmute(tei) };
tei as u64
});
__bindgen_bitfield_unit
}
}
#[test]
fn bindgen_test_layout_dvb_mpeg_ts__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<dvb_mpeg_ts__bindgen_ty_1>(),
2usize,
concat!("Size of: ", stringify!(dvb_mpeg_ts__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<dvb_mpeg_ts__bindgen_ty_1>(),
1usize,
concat!("Alignment of ", stringify!(dvb_mpeg_ts__bindgen_ty_1))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_mpeg_ts__bindgen_ty_1>())).bitfield as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_mpeg_ts__bindgen_ty_1),
"::",
stringify!(bitfield)
)
);
}
#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct dvb_mpeg_ts__bindgen_ty_2 {
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize], u8>,
}
#[test]
fn bindgen_test_layout_dvb_mpeg_ts__bindgen_ty_2() {
assert_eq!(
::std::mem::size_of::<dvb_mpeg_ts__bindgen_ty_2>(),
1usize,
concat!("Size of: ", stringify!(dvb_mpeg_ts__bindgen_ty_2))
);
assert_eq!(
::std::mem::align_of::<dvb_mpeg_ts__bindgen_ty_2>(),
1usize,
concat!("Alignment of ", stringify!(dvb_mpeg_ts__bindgen_ty_2))
);
}
impl dvb_mpeg_ts__bindgen_ty_2 {
#[inline]
pub fn continuity_counter(&self) -> u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u8) }
}
#[inline]
pub fn set_continuity_counter(&mut self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 4u8, val as u64)
}
}
#[inline]
pub fn payload(&self) -> u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u8) }
}
#[inline]
pub fn set_payload(&mut self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(4usize, 1u8, val as u64)
}
}
#[inline]
pub fn adaptation_field(&self) -> u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u8) }
}
#[inline]
pub fn set_adaptation_field(&mut self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(5usize, 1u8, val as u64)
}
}
#[inline]
pub fn scrambling(&self) -> u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 2u8) as u8) }
}
#[inline]
pub fn set_scrambling(&mut self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(6usize, 2u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(
continuity_counter: u8,
payload: u8,
adaptation_field: u8,
scrambling: u8,
) -> __BindgenBitfieldUnit<[u8; 1usize], u8> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize], u8> =
Default::default();
__bindgen_bitfield_unit.set(0usize, 4u8, {
let continuity_counter: u8 = unsafe { ::std::mem::transmute(continuity_counter) };
continuity_counter as u64
});
__bindgen_bitfield_unit.set(4usize, 1u8, {
let payload: u8 = unsafe { ::std::mem::transmute(payload) };
payload as u64
});
__bindgen_bitfield_unit.set(5usize, 1u8, {
let adaptation_field: u8 = unsafe { ::std::mem::transmute(adaptation_field) };
adaptation_field as u64
});
__bindgen_bitfield_unit.set(6usize, 2u8, {
let scrambling: u8 = unsafe { ::std::mem::transmute(scrambling) };
scrambling as u64
});
__bindgen_bitfield_unit
}
}
#[test]
fn bindgen_test_layout_dvb_mpeg_ts() {
assert_eq!(
::std::mem::size_of::<dvb_mpeg_ts>(),
4usize,
concat!("Size of: ", stringify!(dvb_mpeg_ts))
);
assert_eq!(
::std::mem::align_of::<dvb_mpeg_ts>(),
1usize,
concat!("Alignment of ", stringify!(dvb_mpeg_ts))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_mpeg_ts>())).sync_byte as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_mpeg_ts),
"::",
stringify!(sync_byte)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_mpeg_ts>())).adaption as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(dvb_mpeg_ts),
"::",
stringify!(adaption)
)
);
}
extern "C" {
pub fn dvb_mpeg_ts_init(
parms: *mut dvb_v5_fe_parms,
buf: *const u8,
buflen: ssize_t,
table: *mut u8,
table_length: *mut ssize_t,
) -> ssize_t;
}
extern "C" {
pub fn dvb_mpeg_ts_free(ts: *mut dvb_mpeg_ts);
}
extern "C" {
pub fn dvb_mpeg_ts_print(parms: *mut dvb_v5_fe_parms, ts: *mut dvb_mpeg_ts);
}
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub union dvb_table_nit_transport_header {
pub bitfield: u16,
pub __bindgen_anon_1: dvb_table_nit_transport_header__bindgen_ty_1,
_bindgen_union_align: [u8; 2usize],
}
#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct dvb_table_nit_transport_header__bindgen_ty_1 {
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize], u8>,
}
#[test]
fn bindgen_test_layout_dvb_table_nit_transport_header__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<dvb_table_nit_transport_header__bindgen_ty_1>(),
2usize,
concat!(
"Size of: ",
stringify!(dvb_table_nit_transport_header__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<dvb_table_nit_transport_header__bindgen_ty_1>(),
1usize,
concat!(
"Alignment of ",
stringify!(dvb_table_nit_transport_header__bindgen_ty_1)
)
);
}
impl dvb_table_nit_transport_header__bindgen_ty_1 {
#[inline]
pub fn transport_length(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 12u8) as u16) }
}
#[inline]
pub fn set_transport_length(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 12u8, val as u64)
}
}
#[inline]
pub fn reserved(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 4u8) as u16) }
}
#[inline]
pub fn set_reserved(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(12usize, 4u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(
transport_length: u16,
reserved: u16,
) -> __BindgenBitfieldUnit<[u8; 2usize], u8> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize], u8> =
Default::default();
__bindgen_bitfield_unit.set(0usize, 12u8, {
let transport_length: u16 = unsafe { ::std::mem::transmute(transport_length) };
transport_length as u64
});
__bindgen_bitfield_unit.set(12usize, 4u8, {
let reserved: u16 = unsafe { ::std::mem::transmute(reserved) };
reserved as u64
});
__bindgen_bitfield_unit
}
}
#[test]
fn bindgen_test_layout_dvb_table_nit_transport_header() {
assert_eq!(
::std::mem::size_of::<dvb_table_nit_transport_header>(),
2usize,
concat!("Size of: ", stringify!(dvb_table_nit_transport_header))
);
assert_eq!(
::std::mem::align_of::<dvb_table_nit_transport_header>(),
1usize,
concat!("Alignment of ", stringify!(dvb_table_nit_transport_header))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_table_nit_transport_header>())).bitfield as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_table_nit_transport_header),
"::",
stringify!(bitfield)
)
);
}
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub struct dvb_table_nit_transport {
pub transport_id: u16,
pub network_id: u16,
pub __bindgen_anon_1: dvb_table_nit_transport__bindgen_ty_1,
pub descriptor: *mut dvb_desc,
pub next: *mut dvb_table_nit_transport,
}
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub union dvb_table_nit_transport__bindgen_ty_1 {
pub bitfield: u16,
pub __bindgen_anon_1: dvb_table_nit_transport__bindgen_ty_1__bindgen_ty_1,
_bindgen_union_align: [u8; 2usize],
}
#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct dvb_table_nit_transport__bindgen_ty_1__bindgen_ty_1 {
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize], u8>,
}
#[test]
fn bindgen_test_layout_dvb_table_nit_transport__bindgen_ty_1__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<dvb_table_nit_transport__bindgen_ty_1__bindgen_ty_1>(),
2usize,
concat!(
"Size of: ",
stringify!(dvb_table_nit_transport__bindgen_ty_1__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<dvb_table_nit_transport__bindgen_ty_1__bindgen_ty_1>(),
1usize,
concat!(
"Alignment of ",
stringify!(dvb_table_nit_transport__bindgen_ty_1__bindgen_ty_1)
)
);
}
impl dvb_table_nit_transport__bindgen_ty_1__bindgen_ty_1 {
#[inline]
pub fn desc_length(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 12u8) as u16) }
}
#[inline]
pub fn set_desc_length(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 12u8, val as u64)
}
}
#[inline]
pub fn reserved(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 4u8) as u16) }
}
#[inline]
pub fn set_reserved(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(12usize, 4u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(
desc_length: u16,
reserved: u16,
) -> __BindgenBitfieldUnit<[u8; 2usize], u8> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize], u8> =
Default::default();
__bindgen_bitfield_unit.set(0usize, 12u8, {
let desc_length: u16 = unsafe { ::std::mem::transmute(desc_length) };
desc_length as u64
});
__bindgen_bitfield_unit.set(12usize, 4u8, {
let reserved: u16 = unsafe { ::std::mem::transmute(reserved) };
reserved as u64
});
__bindgen_bitfield_unit
}
}
#[test]
fn bindgen_test_layout_dvb_table_nit_transport__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<dvb_table_nit_transport__bindgen_ty_1>(),
2usize,
concat!(
"Size of: ",
stringify!(dvb_table_nit_transport__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<dvb_table_nit_transport__bindgen_ty_1>(),
1usize,
concat!(
"Alignment of ",
stringify!(dvb_table_nit_transport__bindgen_ty_1)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_table_nit_transport__bindgen_ty_1>())).bitfield as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_table_nit_transport__bindgen_ty_1),
"::",
stringify!(bitfield)
)
);
}
#[test]
fn bindgen_test_layout_dvb_table_nit_transport() {
assert_eq!(
::std::mem::size_of::<dvb_table_nit_transport>(),
22usize,
concat!("Size of: ", stringify!(dvb_table_nit_transport))
);
assert_eq!(
::std::mem::align_of::<dvb_table_nit_transport>(),
1usize,
concat!("Alignment of ", stringify!(dvb_table_nit_transport))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_table_nit_transport>())).transport_id as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_table_nit_transport),
"::",
stringify!(transport_id)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_table_nit_transport>())).network_id as *const _ as usize
},
2usize,
concat!(
"Offset of field: ",
stringify!(dvb_table_nit_transport),
"::",
stringify!(network_id)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_table_nit_transport>())).descriptor as *const _ as usize
},
6usize,
concat!(
"Offset of field: ",
stringify!(dvb_table_nit_transport),
"::",
stringify!(descriptor)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_table_nit_transport>())).next as *const _ as usize },
14usize,
concat!(
"Offset of field: ",
stringify!(dvb_table_nit_transport),
"::",
stringify!(next)
)
);
}
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub struct dvb_table_nit {
pub header: dvb_table_header,
pub __bindgen_anon_1: dvb_table_nit__bindgen_ty_1,
pub descriptor: *mut dvb_desc,
pub transport: *mut dvb_table_nit_transport,
}
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub union dvb_table_nit__bindgen_ty_1 {
pub bitfield: u16,
pub __bindgen_anon_1: dvb_table_nit__bindgen_ty_1__bindgen_ty_1,
_bindgen_union_align: [u8; 2usize],
}
#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct dvb_table_nit__bindgen_ty_1__bindgen_ty_1 {
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize], u8>,
}
#[test]
fn bindgen_test_layout_dvb_table_nit__bindgen_ty_1__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<dvb_table_nit__bindgen_ty_1__bindgen_ty_1>(),
2usize,
concat!(
"Size of: ",
stringify!(dvb_table_nit__bindgen_ty_1__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<dvb_table_nit__bindgen_ty_1__bindgen_ty_1>(),
1usize,
concat!(
"Alignment of ",
stringify!(dvb_table_nit__bindgen_ty_1__bindgen_ty_1)
)
);
}
impl dvb_table_nit__bindgen_ty_1__bindgen_ty_1 {
#[inline]
pub fn desc_length(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 12u8) as u16) }
}
#[inline]
pub fn set_desc_length(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 12u8, val as u64)
}
}
#[inline]
pub fn reserved(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 4u8) as u16) }
}
#[inline]
pub fn set_reserved(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(12usize, 4u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(
desc_length: u16,
reserved: u16,
) -> __BindgenBitfieldUnit<[u8; 2usize], u8> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize], u8> =
Default::default();
__bindgen_bitfield_unit.set(0usize, 12u8, {
let desc_length: u16 = unsafe { ::std::mem::transmute(desc_length) };
desc_length as u64
});
__bindgen_bitfield_unit.set(12usize, 4u8, {
let reserved: u16 = unsafe { ::std::mem::transmute(reserved) };
reserved as u64
});
__bindgen_bitfield_unit
}
}
#[test]
fn bindgen_test_layout_dvb_table_nit__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<dvb_table_nit__bindgen_ty_1>(),
2usize,
concat!("Size of: ", stringify!(dvb_table_nit__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<dvb_table_nit__bindgen_ty_1>(),
1usize,
concat!("Alignment of ", stringify!(dvb_table_nit__bindgen_ty_1))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_table_nit__bindgen_ty_1>())).bitfield as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_table_nit__bindgen_ty_1),
"::",
stringify!(bitfield)
)
);
}
#[test]
fn bindgen_test_layout_dvb_table_nit() {
assert_eq!(
::std::mem::size_of::<dvb_table_nit>(),
26usize,
concat!("Size of: ", stringify!(dvb_table_nit))
);
assert_eq!(
::std::mem::align_of::<dvb_table_nit>(),
1usize,
concat!("Alignment of ", stringify!(dvb_table_nit))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_table_nit>())).header as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_table_nit),
"::",
stringify!(header)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_table_nit>())).descriptor as *const _ as usize },
10usize,
concat!(
"Offset of field: ",
stringify!(dvb_table_nit),
"::",
stringify!(descriptor)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_table_nit>())).transport as *const _ as usize },
18usize,
concat!(
"Offset of field: ",
stringify!(dvb_table_nit),
"::",
stringify!(transport)
)
);
}
pub type nit_handler_callback_t = ::std::option::Option<
unsafe extern "C" fn(
nit: *mut dvb_table_nit,
desc: *mut dvb_desc,
priv_: *mut ::std::os::raw::c_void,
),
>;
pub type nit_tran_handler_callback_t = ::std::option::Option<
unsafe extern "C" fn(
nit: *mut dvb_table_nit,
tran: *mut dvb_table_nit_transport,
desc: *mut dvb_desc,
priv_: *mut ::std::os::raw::c_void,
),
>;
extern "C" {
pub fn dvb_table_nit_init(
parms: *mut dvb_v5_fe_parms,
buf: *const u8,
buflen: ssize_t,
table: *mut *mut dvb_table_nit,
) -> ssize_t;
}
extern "C" {
pub fn dvb_table_nit_free(table: *mut dvb_table_nit);
}
extern "C" {
pub fn dvb_table_nit_print(parms: *mut dvb_v5_fe_parms, table: *mut dvb_table_nit);
}
extern "C" {
pub fn dvb_table_nit_descriptor_handler(
parms: *mut dvb_v5_fe_parms,
table: *mut dvb_table_nit,
descriptor: descriptors,
call_nit: nit_handler_callback_t,
call_tran: nit_tran_handler_callback_t,
priv_: *mut ::std::os::raw::c_void,
);
}
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub struct dvb_table_pat_program {
pub service_id: u16,
pub __bindgen_anon_1: dvb_table_pat_program__bindgen_ty_1,
pub next: *mut dvb_table_pat_program,
}
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub union dvb_table_pat_program__bindgen_ty_1 {
pub bitfield: u16,
pub __bindgen_anon_1: dvb_table_pat_program__bindgen_ty_1__bindgen_ty_1,
_bindgen_union_align: [u8; 2usize],
}
#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct dvb_table_pat_program__bindgen_ty_1__bindgen_ty_1 {
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize], u8>,
}
#[test]
fn bindgen_test_layout_dvb_table_pat_program__bindgen_ty_1__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<dvb_table_pat_program__bindgen_ty_1__bindgen_ty_1>(),
2usize,
concat!(
"Size of: ",
stringify!(dvb_table_pat_program__bindgen_ty_1__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<dvb_table_pat_program__bindgen_ty_1__bindgen_ty_1>(),
1usize,
concat!(
"Alignment of ",
stringify!(dvb_table_pat_program__bindgen_ty_1__bindgen_ty_1)
)
);
}
impl dvb_table_pat_program__bindgen_ty_1__bindgen_ty_1 {
#[inline]
pub fn pid(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 13u8) as u16) }
}
#[inline]
pub fn set_pid(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 13u8, val as u64)
}
}
#[inline]
pub fn reserved(&self) -> u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 3u8) as u8) }
}
#[inline]
pub fn set_reserved(&mut self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(13usize, 3u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(pid: u16, reserved: u8) -> __BindgenBitfieldUnit<[u8; 2usize], u8> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize], u8> =
Default::default();
__bindgen_bitfield_unit.set(0usize, 13u8, {
let pid: u16 = unsafe { ::std::mem::transmute(pid) };
pid as u64
});
__bindgen_bitfield_unit.set(13usize, 3u8, {
let reserved: u8 = unsafe { ::std::mem::transmute(reserved) };
reserved as u64
});
__bindgen_bitfield_unit
}
}
#[test]
fn bindgen_test_layout_dvb_table_pat_program__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<dvb_table_pat_program__bindgen_ty_1>(),
2usize,
concat!("Size of: ", stringify!(dvb_table_pat_program__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<dvb_table_pat_program__bindgen_ty_1>(),
1usize,
concat!(
"Alignment of ",
stringify!(dvb_table_pat_program__bindgen_ty_1)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_table_pat_program__bindgen_ty_1>())).bitfield as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_table_pat_program__bindgen_ty_1),
"::",
stringify!(bitfield)
)
);
}
#[test]
fn bindgen_test_layout_dvb_table_pat_program() {
assert_eq!(
::std::mem::size_of::<dvb_table_pat_program>(),
12usize,
concat!("Size of: ", stringify!(dvb_table_pat_program))
);
assert_eq!(
::std::mem::align_of::<dvb_table_pat_program>(),
1usize,
concat!("Alignment of ", stringify!(dvb_table_pat_program))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_table_pat_program>())).service_id as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_table_pat_program),
"::",
stringify!(service_id)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_table_pat_program>())).next as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(dvb_table_pat_program),
"::",
stringify!(next)
)
);
}
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub struct dvb_table_pat {
pub header: dvb_table_header,
pub programs: u16,
pub program: *mut dvb_table_pat_program,
}
#[test]
fn bindgen_test_layout_dvb_table_pat() {
assert_eq!(
::std::mem::size_of::<dvb_table_pat>(),
18usize,
concat!("Size of: ", stringify!(dvb_table_pat))
);
assert_eq!(
::std::mem::align_of::<dvb_table_pat>(),
1usize,
concat!("Alignment of ", stringify!(dvb_table_pat))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_table_pat>())).header as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_table_pat),
"::",
stringify!(header)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_table_pat>())).programs as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(dvb_table_pat),
"::",
stringify!(programs)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_table_pat>())).program as *const _ as usize },
10usize,
concat!(
"Offset of field: ",
stringify!(dvb_table_pat),
"::",
stringify!(program)
)
);
}
extern "C" {
pub fn dvb_table_pat_init(
parms: *mut dvb_v5_fe_parms,
buf: *const u8,
buflen: ssize_t,
table: *mut *mut dvb_table_pat,
) -> ssize_t;
}
extern "C" {
pub fn dvb_table_pat_free(table: *mut dvb_table_pat);
}
extern "C" {
pub fn dvb_table_pat_print(parms: *mut dvb_v5_fe_parms, table: *mut dvb_table_pat);
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum dvb_streams {
stream_video = 1,
stream_video_h262 = 2,
stream_audio = 3,
stream_audio_13818_3 = 4,
stream_private_sections = 5,
stream_private_data = 6,
stream_mheg = 7,
stream_h222 = 8,
stream_h222_1 = 9,
stream_13818_6_A = 10,
stream_13818_6_B = 11,
stream_13818_6_C = 12,
stream_13818_6_D = 13,
stream_h222_aux = 14,
stream_audio_adts = 15,
stream_video_14496_2 = 16,
stream_audio_latm = 17,
stream_14496_1_pes = 18,
stream_14496_1_iso = 19,
stream_download = 20,
stream_video_h264 = 27,
stream_audio_14496_3 = 28,
stream_video_hevc = 36,
stream_video_cavs = 66,
stream_video_moto = 128,
stream_audio_a52 = 129,
stream_scte_27 = 130,
stream_audio_sdds = 132,
stream_audio_dts_hdmv = 133,
stream_audio_e_ac3 = 135,
stream_audio_dts = 138,
stream_audio_a52_vls = 145,
stream_spu_vls = 146,
stream_audio_sdds2 = 148,
}
extern "C" {
pub static mut pmt_stream_name: [*const ::std::os::raw::c_char; 0usize];
}
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub struct dvb_table_pmt_stream {
pub type_: u8,
pub __bindgen_anon_1: dvb_table_pmt_stream__bindgen_ty_1,
pub __bindgen_anon_2: dvb_table_pmt_stream__bindgen_ty_2,
pub descriptor: *mut dvb_desc,
pub next: *mut dvb_table_pmt_stream,
}
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub union dvb_table_pmt_stream__bindgen_ty_1 {
pub bitfield: u16,
pub __bindgen_anon_1: dvb_table_pmt_stream__bindgen_ty_1__bindgen_ty_1,
_bindgen_union_align: [u8; 2usize],
}
#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct dvb_table_pmt_stream__bindgen_ty_1__bindgen_ty_1 {
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize], u8>,
}
#[test]
fn bindgen_test_layout_dvb_table_pmt_stream__bindgen_ty_1__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<dvb_table_pmt_stream__bindgen_ty_1__bindgen_ty_1>(),
2usize,
concat!(
"Size of: ",
stringify!(dvb_table_pmt_stream__bindgen_ty_1__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<dvb_table_pmt_stream__bindgen_ty_1__bindgen_ty_1>(),
1usize,
concat!(
"Alignment of ",
stringify!(dvb_table_pmt_stream__bindgen_ty_1__bindgen_ty_1)
)
);
}
impl dvb_table_pmt_stream__bindgen_ty_1__bindgen_ty_1 {
#[inline]
pub fn elementary_pid(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 13u8) as u16) }
}
#[inline]
pub fn set_elementary_pid(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 13u8, val as u64)
}
}
#[inline]
pub fn reserved(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 3u8) as u16) }
}
#[inline]
pub fn set_reserved(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(13usize, 3u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(
elementary_pid: u16,
reserved: u16,
) -> __BindgenBitfieldUnit<[u8; 2usize], u8> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize], u8> =
Default::default();
__bindgen_bitfield_unit.set(0usize, 13u8, {
let elementary_pid: u16 = unsafe { ::std::mem::transmute(elementary_pid) };
elementary_pid as u64
});
__bindgen_bitfield_unit.set(13usize, 3u8, {
let reserved: u16 = unsafe { ::std::mem::transmute(reserved) };
reserved as u64
});
__bindgen_bitfield_unit
}
}
#[test]
fn bindgen_test_layout_dvb_table_pmt_stream__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<dvb_table_pmt_stream__bindgen_ty_1>(),
2usize,
concat!("Size of: ", stringify!(dvb_table_pmt_stream__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<dvb_table_pmt_stream__bindgen_ty_1>(),
1usize,
concat!(
"Alignment of ",
stringify!(dvb_table_pmt_stream__bindgen_ty_1)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_table_pmt_stream__bindgen_ty_1>())).bitfield as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_table_pmt_stream__bindgen_ty_1),
"::",
stringify!(bitfield)
)
);
}
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub union dvb_table_pmt_stream__bindgen_ty_2 {
pub bitfield2: u16,
pub __bindgen_anon_1: dvb_table_pmt_stream__bindgen_ty_2__bindgen_ty_1,
_bindgen_union_align: [u8; 2usize],
}
#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct dvb_table_pmt_stream__bindgen_ty_2__bindgen_ty_1 {
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize], u8>,
}
#[test]
fn bindgen_test_layout_dvb_table_pmt_stream__bindgen_ty_2__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<dvb_table_pmt_stream__bindgen_ty_2__bindgen_ty_1>(),
2usize,
concat!(
"Size of: ",
stringify!(dvb_table_pmt_stream__bindgen_ty_2__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<dvb_table_pmt_stream__bindgen_ty_2__bindgen_ty_1>(),
1usize,
concat!(
"Alignment of ",
stringify!(dvb_table_pmt_stream__bindgen_ty_2__bindgen_ty_1)
)
);
}
impl dvb_table_pmt_stream__bindgen_ty_2__bindgen_ty_1 {
#[inline]
pub fn desc_length(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 10u8) as u16) }
}
#[inline]
pub fn set_desc_length(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 10u8, val as u64)
}
}
#[inline]
pub fn zero(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 2u8) as u16) }
}
#[inline]
pub fn set_zero(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(10usize, 2u8, val as u64)
}
}
#[inline]
pub fn reserved2(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 4u8) as u16) }
}
#[inline]
pub fn set_reserved2(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(12usize, 4u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(
desc_length: u16,
zero: u16,
reserved2: u16,
) -> __BindgenBitfieldUnit<[u8; 2usize], u8> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize], u8> =
Default::default();
__bindgen_bitfield_unit.set(0usize, 10u8, {
let desc_length: u16 = unsafe { ::std::mem::transmute(desc_length) };
desc_length as u64
});
__bindgen_bitfield_unit.set(10usize, 2u8, {
let zero: u16 = unsafe { ::std::mem::transmute(zero) };
zero as u64
});
__bindgen_bitfield_unit.set(12usize, 4u8, {
let reserved2: u16 = unsafe { ::std::mem::transmute(reserved2) };
reserved2 as u64
});
__bindgen_bitfield_unit
}
}
#[test]
fn bindgen_test_layout_dvb_table_pmt_stream__bindgen_ty_2() {
assert_eq!(
::std::mem::size_of::<dvb_table_pmt_stream__bindgen_ty_2>(),
2usize,
concat!("Size of: ", stringify!(dvb_table_pmt_stream__bindgen_ty_2))
);
assert_eq!(
::std::mem::align_of::<dvb_table_pmt_stream__bindgen_ty_2>(),
1usize,
concat!(
"Alignment of ",
stringify!(dvb_table_pmt_stream__bindgen_ty_2)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_table_pmt_stream__bindgen_ty_2>())).bitfield2 as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_table_pmt_stream__bindgen_ty_2),
"::",
stringify!(bitfield2)
)
);
}
#[test]
fn bindgen_test_layout_dvb_table_pmt_stream() {
assert_eq!(
::std::mem::size_of::<dvb_table_pmt_stream>(),
21usize,
concat!("Size of: ", stringify!(dvb_table_pmt_stream))
);
assert_eq!(
::std::mem::align_of::<dvb_table_pmt_stream>(),
1usize,
concat!("Alignment of ", stringify!(dvb_table_pmt_stream))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_table_pmt_stream>())).type_ as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_table_pmt_stream),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_table_pmt_stream>())).descriptor as *const _ as usize },
5usize,
concat!(
"Offset of field: ",
stringify!(dvb_table_pmt_stream),
"::",
stringify!(descriptor)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_table_pmt_stream>())).next as *const _ as usize },
13usize,
concat!(
"Offset of field: ",
stringify!(dvb_table_pmt_stream),
"::",
stringify!(next)
)
);
}
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub struct dvb_table_pmt {
pub header: dvb_table_header,
pub __bindgen_anon_1: dvb_table_pmt__bindgen_ty_1,
pub __bindgen_anon_2: dvb_table_pmt__bindgen_ty_2,
pub descriptor: *mut dvb_desc,
pub stream: *mut dvb_table_pmt_stream,
}
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub union dvb_table_pmt__bindgen_ty_1 {
pub bitfield: u16,
pub __bindgen_anon_1: dvb_table_pmt__bindgen_ty_1__bindgen_ty_1,
_bindgen_union_align: [u8; 2usize],
}
#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct dvb_table_pmt__bindgen_ty_1__bindgen_ty_1 {
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize], u8>,
}
#[test]
fn bindgen_test_layout_dvb_table_pmt__bindgen_ty_1__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<dvb_table_pmt__bindgen_ty_1__bindgen_ty_1>(),
2usize,
concat!(
"Size of: ",
stringify!(dvb_table_pmt__bindgen_ty_1__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<dvb_table_pmt__bindgen_ty_1__bindgen_ty_1>(),
1usize,
concat!(
"Alignment of ",
stringify!(dvb_table_pmt__bindgen_ty_1__bindgen_ty_1)
)
);
}
impl dvb_table_pmt__bindgen_ty_1__bindgen_ty_1 {
#[inline]
pub fn pcr_pid(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 13u8) as u16) }
}
#[inline]
pub fn set_pcr_pid(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 13u8, val as u64)
}
}
#[inline]
pub fn reserved2(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 3u8) as u16) }
}
#[inline]
pub fn set_reserved2(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(13usize, 3u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(pcr_pid: u16, reserved2: u16) -> __BindgenBitfieldUnit<[u8; 2usize], u8> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize], u8> =
Default::default();
__bindgen_bitfield_unit.set(0usize, 13u8, {
let pcr_pid: u16 = unsafe { ::std::mem::transmute(pcr_pid) };
pcr_pid as u64
});
__bindgen_bitfield_unit.set(13usize, 3u8, {
let reserved2: u16 = unsafe { ::std::mem::transmute(reserved2) };
reserved2 as u64
});
__bindgen_bitfield_unit
}
}
#[test]
fn bindgen_test_layout_dvb_table_pmt__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<dvb_table_pmt__bindgen_ty_1>(),
2usize,
concat!("Size of: ", stringify!(dvb_table_pmt__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<dvb_table_pmt__bindgen_ty_1>(),
1usize,
concat!("Alignment of ", stringify!(dvb_table_pmt__bindgen_ty_1))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_table_pmt__bindgen_ty_1>())).bitfield as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_table_pmt__bindgen_ty_1),
"::",
stringify!(bitfield)
)
);
}
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub union dvb_table_pmt__bindgen_ty_2 {
pub bitfield2: u16,
pub __bindgen_anon_1: dvb_table_pmt__bindgen_ty_2__bindgen_ty_1,
_bindgen_union_align: [u8; 2usize],
}
#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct dvb_table_pmt__bindgen_ty_2__bindgen_ty_1 {
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize], u8>,
}
#[test]
fn bindgen_test_layout_dvb_table_pmt__bindgen_ty_2__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<dvb_table_pmt__bindgen_ty_2__bindgen_ty_1>(),
2usize,
concat!(
"Size of: ",
stringify!(dvb_table_pmt__bindgen_ty_2__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<dvb_table_pmt__bindgen_ty_2__bindgen_ty_1>(),
1usize,
concat!(
"Alignment of ",
stringify!(dvb_table_pmt__bindgen_ty_2__bindgen_ty_1)
)
);
}
impl dvb_table_pmt__bindgen_ty_2__bindgen_ty_1 {
#[inline]
pub fn desc_length(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 10u8) as u16) }
}
#[inline]
pub fn set_desc_length(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 10u8, val as u64)
}
}
#[inline]
pub fn zero3(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 2u8) as u16) }
}
#[inline]
pub fn set_zero3(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(10usize, 2u8, val as u64)
}
}
#[inline]
pub fn reserved3(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 4u8) as u16) }
}
#[inline]
pub fn set_reserved3(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(12usize, 4u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(
desc_length: u16,
zero3: u16,
reserved3: u16,
) -> __BindgenBitfieldUnit<[u8; 2usize], u8> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize], u8> =
Default::default();
__bindgen_bitfield_unit.set(0usize, 10u8, {
let desc_length: u16 = unsafe { ::std::mem::transmute(desc_length) };
desc_length as u64
});
__bindgen_bitfield_unit.set(10usize, 2u8, {
let zero3: u16 = unsafe { ::std::mem::transmute(zero3) };
zero3 as u64
});
__bindgen_bitfield_unit.set(12usize, 4u8, {
let reserved3: u16 = unsafe { ::std::mem::transmute(reserved3) };
reserved3 as u64
});
__bindgen_bitfield_unit
}
}
#[test]
fn bindgen_test_layout_dvb_table_pmt__bindgen_ty_2() {
assert_eq!(
::std::mem::size_of::<dvb_table_pmt__bindgen_ty_2>(),
2usize,
concat!("Size of: ", stringify!(dvb_table_pmt__bindgen_ty_2))
);
assert_eq!(
::std::mem::align_of::<dvb_table_pmt__bindgen_ty_2>(),
1usize,
concat!("Alignment of ", stringify!(dvb_table_pmt__bindgen_ty_2))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_table_pmt__bindgen_ty_2>())).bitfield2 as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_table_pmt__bindgen_ty_2),
"::",
stringify!(bitfield2)
)
);
}
#[test]
fn bindgen_test_layout_dvb_table_pmt() {
assert_eq!(
::std::mem::size_of::<dvb_table_pmt>(),
28usize,
concat!("Size of: ", stringify!(dvb_table_pmt))
);
assert_eq!(
::std::mem::align_of::<dvb_table_pmt>(),
1usize,
concat!("Alignment of ", stringify!(dvb_table_pmt))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_table_pmt>())).header as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_table_pmt),
"::",
stringify!(header)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_table_pmt>())).descriptor as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(dvb_table_pmt),
"::",
stringify!(descriptor)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_table_pmt>())).stream as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(dvb_table_pmt),
"::",
stringify!(stream)
)
);
}
extern "C" {
pub fn dvb_table_pmt_init(
parms: *mut dvb_v5_fe_parms,
buf: *const u8,
buflen: ssize_t,
table: *mut *mut dvb_table_pmt,
) -> ssize_t;
}
extern "C" {
pub fn dvb_table_pmt_free(table: *mut dvb_table_pmt);
}
extern "C" {
pub fn dvb_table_pmt_print(parms: *mut dvb_v5_fe_parms, table: *const dvb_table_pmt);
}
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub struct dvb_table_sdt_service {
pub service_id: u16,
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize], u8>,
pub __bindgen_anon_1: dvb_table_sdt_service__bindgen_ty_1,
pub descriptor: *mut dvb_desc,
pub next: *mut dvb_table_sdt_service,
}
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub union dvb_table_sdt_service__bindgen_ty_1 {
pub bitfield: u16,
pub __bindgen_anon_1: dvb_table_sdt_service__bindgen_ty_1__bindgen_ty_1,
_bindgen_union_align: [u8; 2usize],
}
#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct dvb_table_sdt_service__bindgen_ty_1__bindgen_ty_1 {
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize], u8>,
}
#[test]
fn bindgen_test_layout_dvb_table_sdt_service__bindgen_ty_1__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<dvb_table_sdt_service__bindgen_ty_1__bindgen_ty_1>(),
2usize,
concat!(
"Size of: ",
stringify!(dvb_table_sdt_service__bindgen_ty_1__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<dvb_table_sdt_service__bindgen_ty_1__bindgen_ty_1>(),
1usize,
concat!(
"Alignment of ",
stringify!(dvb_table_sdt_service__bindgen_ty_1__bindgen_ty_1)
)
);
}
impl dvb_table_sdt_service__bindgen_ty_1__bindgen_ty_1 {
#[inline]
pub fn desc_length(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 12u8) as u16) }
}
#[inline]
pub fn set_desc_length(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 12u8, val as u64)
}
}
#[inline]
pub fn free_CA_mode(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u16) }
}
#[inline]
pub fn set_free_CA_mode(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(12usize, 1u8, val as u64)
}
}
#[inline]
pub fn running_status(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 3u8) as u16) }
}
#[inline]
pub fn set_running_status(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(13usize, 3u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(
desc_length: u16,
free_CA_mode: u16,
running_status: u16,
) -> __BindgenBitfieldUnit<[u8; 2usize], u8> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize], u8> =
Default::default();
__bindgen_bitfield_unit.set(0usize, 12u8, {
let desc_length: u16 = unsafe { ::std::mem::transmute(desc_length) };
desc_length as u64
});
__bindgen_bitfield_unit.set(12usize, 1u8, {
let free_CA_mode: u16 = unsafe { ::std::mem::transmute(free_CA_mode) };
free_CA_mode as u64
});
__bindgen_bitfield_unit.set(13usize, 3u8, {
let running_status: u16 = unsafe { ::std::mem::transmute(running_status) };
running_status as u64
});
__bindgen_bitfield_unit
}
}
#[test]
fn bindgen_test_layout_dvb_table_sdt_service__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<dvb_table_sdt_service__bindgen_ty_1>(),
2usize,
concat!("Size of: ", stringify!(dvb_table_sdt_service__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<dvb_table_sdt_service__bindgen_ty_1>(),
1usize,
concat!(
"Alignment of ",
stringify!(dvb_table_sdt_service__bindgen_ty_1)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_table_sdt_service__bindgen_ty_1>())).bitfield as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_table_sdt_service__bindgen_ty_1),
"::",
stringify!(bitfield)
)
);
}
#[test]
fn bindgen_test_layout_dvb_table_sdt_service() {
assert_eq!(
::std::mem::size_of::<dvb_table_sdt_service>(),
21usize,
concat!("Size of: ", stringify!(dvb_table_sdt_service))
);
assert_eq!(
::std::mem::align_of::<dvb_table_sdt_service>(),
1usize,
concat!("Alignment of ", stringify!(dvb_table_sdt_service))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_table_sdt_service>())).service_id as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_table_sdt_service),
"::",
stringify!(service_id)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<dvb_table_sdt_service>())).descriptor as *const _ as usize
},
5usize,
concat!(
"Offset of field: ",
stringify!(dvb_table_sdt_service),
"::",
stringify!(descriptor)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_table_sdt_service>())).next as *const _ as usize },
13usize,
concat!(
"Offset of field: ",
stringify!(dvb_table_sdt_service),
"::",
stringify!(next)
)
);
}
impl dvb_table_sdt_service {
#[inline]
pub fn EIT_present_following(&self) -> u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
}
#[inline]
pub fn set_EIT_present_following(&mut self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 1u8, val as u64)
}
}
#[inline]
pub fn EIT_schedule(&self) -> u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
}
#[inline]
pub fn set_EIT_schedule(&mut self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(1usize, 1u8, val as u64)
}
}
#[inline]
pub fn reserved(&self) -> u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 6u8) as u8) }
}
#[inline]
pub fn set_reserved(&mut self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(2usize, 6u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(
EIT_present_following: u8,
EIT_schedule: u8,
reserved: u8,
) -> __BindgenBitfieldUnit<[u8; 1usize], u8> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize], u8> =
Default::default();
__bindgen_bitfield_unit.set(0usize, 1u8, {
let EIT_present_following: u8 = unsafe { ::std::mem::transmute(EIT_present_following) };
EIT_present_following as u64
});
__bindgen_bitfield_unit.set(1usize, 1u8, {
let EIT_schedule: u8 = unsafe { ::std::mem::transmute(EIT_schedule) };
EIT_schedule as u64
});
__bindgen_bitfield_unit.set(2usize, 6u8, {
let reserved: u8 = unsafe { ::std::mem::transmute(reserved) };
reserved as u64
});
__bindgen_bitfield_unit
}
}
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub struct dvb_table_sdt {
pub header: dvb_table_header,
pub network_id: u16,
pub reserved: u8,
pub service: *mut dvb_table_sdt_service,
}
#[test]
fn bindgen_test_layout_dvb_table_sdt() {
assert_eq!(
::std::mem::size_of::<dvb_table_sdt>(),
19usize,
concat!("Size of: ", stringify!(dvb_table_sdt))
);
assert_eq!(
::std::mem::align_of::<dvb_table_sdt>(),
1usize,
concat!("Alignment of ", stringify!(dvb_table_sdt))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_table_sdt>())).header as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(dvb_table_sdt),
"::",
stringify!(header)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_table_sdt>())).network_id as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(dvb_table_sdt),
"::",
stringify!(network_id)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_table_sdt>())).reserved as *const _ as usize },
10usize,
concat!(
"Offset of field: ",
stringify!(dvb_table_sdt),
"::",
stringify!(reserved)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<dvb_table_sdt>())).service as *const _ as usize },
11usize,
concat!(
"Offset of field: ",
stringify!(dvb_table_sdt),
"::",
stringify!(service)
)
);
}
extern "C" {
pub fn dvb_table_sdt_init(
parms: *mut dvb_v5_fe_parms,
buf: *const u8,
buflen: ssize_t,
table: *mut *mut dvb_table_sdt,
) -> ssize_t;
}
extern "C" {
pub fn dvb_table_sdt_free(table: *mut dvb_table_sdt);
}
extern "C" {
pub fn dvb_table_sdt_print(parms: *mut dvb_v5_fe_parms, table: *mut dvb_table_sdt);
}
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub struct atsc_table_vct_channel {
pub __short_name: [u16; 7usize],
pub __bindgen_anon_1: atsc_table_vct_channel__bindgen_ty_1,
pub carrier_frequency: u32,
pub channel_tsid: u16,
pub program_number: u16,
pub __bindgen_anon_2: atsc_table_vct_channel__bindgen_ty_2,
pub source_id: u16,
pub __bindgen_anon_3: atsc_table_vct_channel__bindgen_ty_3,
pub descriptor: *mut dvb_desc,
pub next: *mut atsc_table_vct_channel,
pub short_name: [::std::os::raw::c_char; 32usize],
}
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub union atsc_table_vct_channel__bindgen_ty_1 {
pub bitfield1: u32,
pub __bindgen_anon_1: atsc_table_vct_channel__bindgen_ty_1__bindgen_ty_1,
_bindgen_union_align: [u8; 4usize],
}
#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct atsc_table_vct_channel__bindgen_ty_1__bindgen_ty_1 {
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize], u8>,
}
#[test]
fn bindgen_test_layout_atsc_table_vct_channel__bindgen_ty_1__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<atsc_table_vct_channel__bindgen_ty_1__bindgen_ty_1>(),
4usize,
concat!(
"Size of: ",
stringify!(atsc_table_vct_channel__bindgen_ty_1__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<atsc_table_vct_channel__bindgen_ty_1__bindgen_ty_1>(),
1usize,
concat!(
"Alignment of ",
stringify!(atsc_table_vct_channel__bindgen_ty_1__bindgen_ty_1)
)
);
}
impl atsc_table_vct_channel__bindgen_ty_1__bindgen_ty_1 {
#[inline]
pub fn modulation_mode(&self) -> u32 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 8u8) as u32) }
}
#[inline]
pub fn set_modulation_mode(&mut self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 8u8, val as u64)
}
}
#[inline]
pub fn minor_channel_number(&self) -> u32 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 10u8) as u32) }
}
#[inline]
pub fn set_minor_channel_number(&mut self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(8usize, 10u8, val as u64)
}
}
#[inline]
pub fn major_channel_number(&self) -> u32 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(18usize, 10u8) as u32) }
}
#[inline]
pub fn set_major_channel_number(&mut self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(18usize, 10u8, val as u64)
}
}
#[inline]
pub fn reserved1(&self) -> u32 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(28usize, 4u8) as u32) }
}
#[inline]
pub fn set_reserved1(&mut self, val: u32) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(28usize, 4u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(
modulation_mode: u32,
minor_channel_number: u32,
major_channel_number: u32,
reserved1: u32,
) -> __BindgenBitfieldUnit<[u8; 4usize], u8> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize], u8> =
Default::default();
__bindgen_bitfield_unit.set(0usize, 8u8, {
let modulation_mode: u32 = unsafe { ::std::mem::transmute(modulation_mode) };
modulation_mode as u64
});
__bindgen_bitfield_unit.set(8usize, 10u8, {
let minor_channel_number: u32 = unsafe { ::std::mem::transmute(minor_channel_number) };
minor_channel_number as u64
});
__bindgen_bitfield_unit.set(18usize, 10u8, {
let major_channel_number: u32 = unsafe { ::std::mem::transmute(major_channel_number) };
major_channel_number as u64
});
__bindgen_bitfield_unit.set(28usize, 4u8, {
let reserved1: u32 = unsafe { ::std::mem::transmute(reserved1) };
reserved1 as u64
});
__bindgen_bitfield_unit
}
}
#[test]
fn bindgen_test_layout_atsc_table_vct_channel__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<atsc_table_vct_channel__bindgen_ty_1>(),
4usize,
concat!(
"Size of: ",
stringify!(atsc_table_vct_channel__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<atsc_table_vct_channel__bindgen_ty_1>(),
1usize,
concat!(
"Alignment of ",
stringify!(atsc_table_vct_channel__bindgen_ty_1)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<atsc_table_vct_channel__bindgen_ty_1>())).bitfield1 as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(atsc_table_vct_channel__bindgen_ty_1),
"::",
stringify!(bitfield1)
)
);
}
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub union atsc_table_vct_channel__bindgen_ty_2 {
pub bitfield2: u16,
pub __bindgen_anon_1: atsc_table_vct_channel__bindgen_ty_2__bindgen_ty_1,
_bindgen_union_align: [u8; 2usize],
}
#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct atsc_table_vct_channel__bindgen_ty_2__bindgen_ty_1 {
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize], u8>,
}
#[test]
fn bindgen_test_layout_atsc_table_vct_channel__bindgen_ty_2__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<atsc_table_vct_channel__bindgen_ty_2__bindgen_ty_1>(),
2usize,
concat!(
"Size of: ",
stringify!(atsc_table_vct_channel__bindgen_ty_2__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<atsc_table_vct_channel__bindgen_ty_2__bindgen_ty_1>(),
1usize,
concat!(
"Alignment of ",
stringify!(atsc_table_vct_channel__bindgen_ty_2__bindgen_ty_1)
)
);
}
impl atsc_table_vct_channel__bindgen_ty_2__bindgen_ty_1 {
#[inline]
pub fn service_type(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 6u8) as u16) }
}
#[inline]
pub fn set_service_type(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 6u8, val as u64)
}
}
#[inline]
pub fn reserved2(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 3u8) as u16) }
}
#[inline]
pub fn set_reserved2(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(6usize, 3u8, val as u64)
}
}
#[inline]
pub fn hide_guide(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u16) }
}
#[inline]
pub fn set_hide_guide(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(9usize, 1u8, val as u64)
}
}
#[inline]
pub fn out_of_band(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u16) }
}
#[inline]
pub fn set_out_of_band(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(10usize, 1u8, val as u64)
}
}
#[inline]
pub fn path_select(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u16) }
}
#[inline]
pub fn set_path_select(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(11usize, 1u8, val as u64)
}
}
#[inline]
pub fn hidden(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u16) }
}
#[inline]
pub fn set_hidden(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(12usize, 1u8, val as u64)
}
}
#[inline]
pub fn access_controlled(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u16) }
}
#[inline]
pub fn set_access_controlled(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(13usize, 1u8, val as u64)
}
}
#[inline]
pub fn ETM_location(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 2u8) as u16) }
}
#[inline]
pub fn set_ETM_location(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(14usize, 2u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(
service_type: u16,
reserved2: u16,
hide_guide: u16,
out_of_band: u16,
path_select: u16,
hidden: u16,
access_controlled: u16,
ETM_location: u16,
) -> __BindgenBitfieldUnit<[u8; 2usize], u8> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize], u8> =
Default::default();
__bindgen_bitfield_unit.set(0usize, 6u8, {
let service_type: u16 = unsafe { ::std::mem::transmute(service_type) };
service_type as u64
});
__bindgen_bitfield_unit.set(6usize, 3u8, {
let reserved2: u16 = unsafe { ::std::mem::transmute(reserved2) };
reserved2 as u64
});
__bindgen_bitfield_unit.set(9usize, 1u8, {
let hide_guide: u16 = unsafe { ::std::mem::transmute(hide_guide) };
hide_guide as u64
});
__bindgen_bitfield_unit.set(10usize, 1u8, {
let out_of_band: u16 = unsafe { ::std::mem::transmute(out_of_band) };
out_of_band as u64
});
__bindgen_bitfield_unit.set(11usize, 1u8, {
let path_select: u16 = unsafe { ::std::mem::transmute(path_select) };
path_select as u64
});
__bindgen_bitfield_unit.set(12usize, 1u8, {
let hidden: u16 = unsafe { ::std::mem::transmute(hidden) };
hidden as u64
});
__bindgen_bitfield_unit.set(13usize, 1u8, {
let access_controlled: u16 = unsafe { ::std::mem::transmute(access_controlled) };
access_controlled as u64
});
__bindgen_bitfield_unit.set(14usize, 2u8, {
let ETM_location: u16 = unsafe { ::std::mem::transmute(ETM_location) };
ETM_location as u64
});
__bindgen_bitfield_unit
}
}
#[test]
fn bindgen_test_layout_atsc_table_vct_channel__bindgen_ty_2() {
assert_eq!(
::std::mem::size_of::<atsc_table_vct_channel__bindgen_ty_2>(),
2usize,
concat!(
"Size of: ",
stringify!(atsc_table_vct_channel__bindgen_ty_2)
)
);
assert_eq!(
::std::mem::align_of::<atsc_table_vct_channel__bindgen_ty_2>(),
1usize,
concat!(
"Alignment of ",
stringify!(atsc_table_vct_channel__bindgen_ty_2)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<atsc_table_vct_channel__bindgen_ty_2>())).bitfield2 as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(atsc_table_vct_channel__bindgen_ty_2),
"::",
stringify!(bitfield2)
)
);
}
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub union atsc_table_vct_channel__bindgen_ty_3 {
pub bitfield3: u16,
pub __bindgen_anon_1: atsc_table_vct_channel__bindgen_ty_3__bindgen_ty_1,
_bindgen_union_align: [u8; 2usize],
}
#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct atsc_table_vct_channel__bindgen_ty_3__bindgen_ty_1 {
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize], u8>,
}
#[test]
fn bindgen_test_layout_atsc_table_vct_channel__bindgen_ty_3__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<atsc_table_vct_channel__bindgen_ty_3__bindgen_ty_1>(),
2usize,
concat!(
"Size of: ",
stringify!(atsc_table_vct_channel__bindgen_ty_3__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<atsc_table_vct_channel__bindgen_ty_3__bindgen_ty_1>(),
1usize,
concat!(
"Alignment of ",
stringify!(atsc_table_vct_channel__bindgen_ty_3__bindgen_ty_1)
)
);
}
impl atsc_table_vct_channel__bindgen_ty_3__bindgen_ty_1 {
#[inline]
pub fn descriptors_length(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 10u8) as u16) }
}
#[inline]
pub fn set_descriptors_length(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 10u8, val as u64)
}
}
#[inline]
pub fn reserved3(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 6u8) as u16) }
}
#[inline]
pub fn set_reserved3(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(10usize, 6u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(
descriptors_length: u16,
reserved3: u16,
) -> __BindgenBitfieldUnit<[u8; 2usize], u8> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize], u8> =
Default::default();
__bindgen_bitfield_unit.set(0usize, 10u8, {
let descriptors_length: u16 = unsafe { ::std::mem::transmute(descriptors_length) };
descriptors_length as u64
});
__bindgen_bitfield_unit.set(10usize, 6u8, {
let reserved3: u16 = unsafe { ::std::mem::transmute(reserved3) };
reserved3 as u64
});
__bindgen_bitfield_unit
}
}
#[test]
fn bindgen_test_layout_atsc_table_vct_channel__bindgen_ty_3() {
assert_eq!(
::std::mem::size_of::<atsc_table_vct_channel__bindgen_ty_3>(),
2usize,
concat!(
"Size of: ",
stringify!(atsc_table_vct_channel__bindgen_ty_3)
)
);
assert_eq!(
::std::mem::align_of::<atsc_table_vct_channel__bindgen_ty_3>(),
1usize,
concat!(
"Alignment of ",
stringify!(atsc_table_vct_channel__bindgen_ty_3)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<atsc_table_vct_channel__bindgen_ty_3>())).bitfield3 as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(atsc_table_vct_channel__bindgen_ty_3),
"::",
stringify!(bitfield3)
)
);
}
#[test]
fn bindgen_test_layout_atsc_table_vct_channel() {
assert_eq!(
::std::mem::size_of::<atsc_table_vct_channel>(),
80usize,
concat!("Size of: ", stringify!(atsc_table_vct_channel))
);
assert_eq!(
::std::mem::align_of::<atsc_table_vct_channel>(),
1usize,
concat!("Alignment of ", stringify!(atsc_table_vct_channel))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<atsc_table_vct_channel>())).__short_name as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(atsc_table_vct_channel),
"::",
stringify!(__short_name)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<atsc_table_vct_channel>())).carrier_frequency as *const _
as usize
},
18usize,
concat!(
"Offset of field: ",
stringify!(atsc_table_vct_channel),
"::",
stringify!(carrier_frequency)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<atsc_table_vct_channel>())).channel_tsid as *const _ as usize
},
22usize,
concat!(
"Offset of field: ",
stringify!(atsc_table_vct_channel),
"::",
stringify!(channel_tsid)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<atsc_table_vct_channel>())).program_number as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(atsc_table_vct_channel),
"::",
stringify!(program_number)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<atsc_table_vct_channel>())).source_id as *const _ as usize
},
28usize,
concat!(
"Offset of field: ",
stringify!(atsc_table_vct_channel),
"::",
stringify!(source_id)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<atsc_table_vct_channel>())).descriptor as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(atsc_table_vct_channel),
"::",
stringify!(descriptor)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<atsc_table_vct_channel>())).next as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(atsc_table_vct_channel),
"::",
stringify!(next)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<atsc_table_vct_channel>())).short_name as *const _ as usize
},
48usize,
concat!(
"Offset of field: ",
stringify!(atsc_table_vct_channel),
"::",
stringify!(short_name)
)
);
}
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub struct atsc_table_vct {
pub header: dvb_table_header,
pub protocol_version: u8,
pub num_channels_in_section: u8,
pub channel: *mut atsc_table_vct_channel,
pub descriptor: *mut dvb_desc,
}
#[test]
fn bindgen_test_layout_atsc_table_vct() {
assert_eq!(
::std::mem::size_of::<atsc_table_vct>(),
26usize,
concat!("Size of: ", stringify!(atsc_table_vct))
);
assert_eq!(
::std::mem::align_of::<atsc_table_vct>(),
1usize,
concat!("Alignment of ", stringify!(atsc_table_vct))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<atsc_table_vct>())).header as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(atsc_table_vct),
"::",
stringify!(header)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<atsc_table_vct>())).protocol_version as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(atsc_table_vct),
"::",
stringify!(protocol_version)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<atsc_table_vct>())).num_channels_in_section as *const _ as usize
},
9usize,
concat!(
"Offset of field: ",
stringify!(atsc_table_vct),
"::",
stringify!(num_channels_in_section)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<atsc_table_vct>())).channel as *const _ as usize },
10usize,
concat!(
"Offset of field: ",
stringify!(atsc_table_vct),
"::",
stringify!(channel)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<atsc_table_vct>())).descriptor as *const _ as usize },
18usize,
concat!(
"Offset of field: ",
stringify!(atsc_table_vct),
"::",
stringify!(descriptor)
)
);
}
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub union atsc_table_vct_descriptor_length {
pub bitfield: u16,
pub __bindgen_anon_1: atsc_table_vct_descriptor_length__bindgen_ty_1,
_bindgen_union_align: [u8; 2usize],
}
#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct atsc_table_vct_descriptor_length__bindgen_ty_1 {
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize], u8>,
}
#[test]
fn bindgen_test_layout_atsc_table_vct_descriptor_length__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<atsc_table_vct_descriptor_length__bindgen_ty_1>(),
2usize,
concat!(
"Size of: ",
stringify!(atsc_table_vct_descriptor_length__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<atsc_table_vct_descriptor_length__bindgen_ty_1>(),
1usize,
concat!(
"Alignment of ",
stringify!(atsc_table_vct_descriptor_length__bindgen_ty_1)
)
);
}
impl atsc_table_vct_descriptor_length__bindgen_ty_1 {
#[inline]
pub fn descriptor_length(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 10u8) as u16) }
}
#[inline]
pub fn set_descriptor_length(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 10u8, val as u64)
}
}
#[inline]
pub fn reserved(&self) -> u16 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 6u8) as u16) }
}
#[inline]
pub fn set_reserved(&mut self, val: u16) {
unsafe {
let val: u16 = ::std::mem::transmute(val);
self._bitfield_1.set(10usize, 6u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(
descriptor_length: u16,
reserved: u16,
) -> __BindgenBitfieldUnit<[u8; 2usize], u8> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize], u8> =
Default::default();
__bindgen_bitfield_unit.set(0usize, 10u8, {
let descriptor_length: u16 = unsafe { ::std::mem::transmute(descriptor_length) };
descriptor_length as u64
});
__bindgen_bitfield_unit.set(10usize, 6u8, {
let reserved: u16 = unsafe { ::std::mem::transmute(reserved) };
reserved as u64
});
__bindgen_bitfield_unit
}
}
#[test]
fn bindgen_test_layout_atsc_table_vct_descriptor_length() {
assert_eq!(
::std::mem::size_of::<atsc_table_vct_descriptor_length>(),
2usize,
concat!("Size of: ", stringify!(atsc_table_vct_descriptor_length))
);
assert_eq!(
::std::mem::align_of::<atsc_table_vct_descriptor_length>(),
1usize,
concat!(
"Alignment of ",
stringify!(atsc_table_vct_descriptor_length)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<atsc_table_vct_descriptor_length>())).bitfield as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(atsc_table_vct_descriptor_length),
"::",
stringify!(bitfield)
)
);
}
extern "C" {
pub fn atsc_table_vct_init(
parms: *mut dvb_v5_fe_parms,
buf: *const u8,
buflen: ssize_t,
table: *mut *mut atsc_table_vct,
) -> ssize_t;
}
extern "C" {
pub fn atsc_table_vct_free(table: *mut atsc_table_vct);
}
extern "C" {
pub fn atsc_table_vct_print(parms: *mut dvb_v5_fe_parms, table: *mut atsc_table_vct);
}