pub const SRT_VERSION_MAJOR: u32 = 1;
pub const SRT_VERSION_MINOR: u32 = 4;
pub const SRT_VERSION_PATCH: u32 = 2;
pub const SRT_VERSION_STRING: &'static [u8; 6usize] = b"1.4.2\0";
pub const SRT_LOG_LEVEL_MIN: u32 = 2;
pub const SRT_LOG_LEVEL_MAX: u32 = 7;
pub const SRT_LOGF_DISABLE_TIME: u32 = 1;
pub const SRT_LOGF_DISABLE_THREADNAME: u32 = 2;
pub const SRT_LOGF_DISABLE_SEVERITY: u32 = 4;
pub const SRT_LOGF_DISABLE_EOL: u32 = 8;
pub const SRT_VERSION_FEAT_HSv5: u32 = 66304;
pub const SRT_HAVE_CXX17: u32 = 0;
pub const SRT_REJC_INTERNAL: u32 = 0;
pub const SRT_REJC_PREDEFINED: u32 = 1000;
pub const SRT_REJC_USERDEFINED: u32 = 2000;
pub const SRT_LOGFA_GENERAL: u32 = 0;
pub const SRT_LOGFA_SOCKMGMT: u32 = 1;
pub const SRT_LOGFA_CONN: u32 = 2;
pub const SRT_LOGFA_XTIMER: u32 = 3;
pub const SRT_LOGFA_TSBPD: u32 = 4;
pub const SRT_LOGFA_RSRC: u32 = 5;
pub const SRT_LOGFA_CONGEST: u32 = 7;
pub const SRT_LOGFA_PFILTER: u32 = 8;
pub const SRT_LOGFA_API_CTRL: u32 = 11;
pub const SRT_LOGFA_QUE_CTRL: u32 = 13;
pub const SRT_LOGFA_EPOLL_UPD: u32 = 16;
pub const SRT_LOGFA_API_RECV: u32 = 21;
pub const SRT_LOGFA_BUF_RECV: u32 = 22;
pub const SRT_LOGFA_QUE_RECV: u32 = 23;
pub const SRT_LOGFA_CHN_RECV: u32 = 24;
pub const SRT_LOGFA_GRP_RECV: u32 = 25;
pub const SRT_LOGFA_API_SEND: u32 = 31;
pub const SRT_LOGFA_BUF_SEND: u32 = 32;
pub const SRT_LOGFA_QUE_SEND: u32 = 33;
pub const SRT_LOGFA_CHN_SEND: u32 = 34;
pub const SRT_LOGFA_GRP_SEND: u32 = 35;
pub const SRT_LOGFA_INTERNAL: u32 = 41;
pub const SRT_LOGFA_QUE_MGMT: u32 = 43;
pub const SRT_LOGFA_CHN_MGMT: u32 = 44;
pub const SRT_LOGFA_GRP_MGMT: u32 = 45;
pub const SRT_LOGFA_EPOLL_API: u32 = 46;
pub const SRT_LOGFA_HAICRYPT: u32 = 6;
pub const SRT_LOGFA_APPLOG: u32 = 10;
pub const SRT_LOGFA_LASTNONE: u32 = 63;
pub const SRT_DEFAULT_SENDFILE_BLOCK: u32 = 364000;
pub const SRT_DEFAULT_RECVFILE_BLOCK: u32 = 7280000;
pub type __int32_t = ::std::os::raw::c_int;
pub type __uint32_t = ::std::os::raw::c_uint;
pub type __int64_t = ::std::os::raw::c_long;
pub type __uint64_t = ::std::os::raw::c_ulong;
pub type sa_family_t = ::std::os::raw::c_ushort;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct sockaddr {
pub sa_family: sa_family_t,
pub sa_data: [::std::os::raw::c_char; 14usize],
}
#[test]
fn bindgen_test_layout_sockaddr() {
assert_eq!(
::std::mem::size_of::<sockaddr>(),
16usize,
concat!("Size of: ", stringify!(sockaddr))
);
assert_eq!(
::std::mem::align_of::<sockaddr>(),
2usize,
concat!("Alignment of ", stringify!(sockaddr))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sockaddr>())).sa_family as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(sockaddr),
"::",
stringify!(sa_family)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sockaddr>())).sa_data as *const _ as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(sockaddr),
"::",
stringify!(sa_data)
)
);
}
pub type SRT_LOG_HANDLER_FN = ::std::option::Option<
unsafe extern "C" fn(
opaque: *mut ::std::os::raw::c_void,
level: ::std::os::raw::c_int,
file: *const ::std::os::raw::c_char,
line: ::std::os::raw::c_int,
area: *const ::std::os::raw::c_char,
message: *const ::std::os::raw::c_char,
),
>;
pub type SRTSOCKET = i32;
pub const SRTGROUP_MASK: i32 = 1073741824;
pub type SYSSOCKET = ::std::os::raw::c_int;
pub type UDPSOCKET = SYSSOCKET;
impl SRT_SOCKSTATUS {
pub const SRTS_INIT: SRT_SOCKSTATUS = SRT_SOCKSTATUS(1);
}
impl SRT_SOCKSTATUS {
pub const SRTS_OPENED: SRT_SOCKSTATUS = SRT_SOCKSTATUS(2);
}
impl SRT_SOCKSTATUS {
pub const SRTS_LISTENING: SRT_SOCKSTATUS = SRT_SOCKSTATUS(3);
}
impl SRT_SOCKSTATUS {
pub const SRTS_CONNECTING: SRT_SOCKSTATUS = SRT_SOCKSTATUS(4);
}
impl SRT_SOCKSTATUS {
pub const SRTS_CONNECTED: SRT_SOCKSTATUS = SRT_SOCKSTATUS(5);
}
impl SRT_SOCKSTATUS {
pub const SRTS_BROKEN: SRT_SOCKSTATUS = SRT_SOCKSTATUS(6);
}
impl SRT_SOCKSTATUS {
pub const SRTS_CLOSING: SRT_SOCKSTATUS = SRT_SOCKSTATUS(7);
}
impl SRT_SOCKSTATUS {
pub const SRTS_CLOSED: SRT_SOCKSTATUS = SRT_SOCKSTATUS(8);
}
impl SRT_SOCKSTATUS {
pub const SRTS_NONEXIST: SRT_SOCKSTATUS = SRT_SOCKSTATUS(9);
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct SRT_SOCKSTATUS(pub ::std::os::raw::c_uint);
impl SRT_SOCKOPT {
pub const SRTO_MSS: SRT_SOCKOPT = SRT_SOCKOPT(0);
}
impl SRT_SOCKOPT {
pub const SRTO_SNDSYN: SRT_SOCKOPT = SRT_SOCKOPT(1);
}
impl SRT_SOCKOPT {
pub const SRTO_RCVSYN: SRT_SOCKOPT = SRT_SOCKOPT(2);
}
impl SRT_SOCKOPT {
pub const SRTO_ISN: SRT_SOCKOPT = SRT_SOCKOPT(3);
}
impl SRT_SOCKOPT {
pub const SRTO_FC: SRT_SOCKOPT = SRT_SOCKOPT(4);
}
impl SRT_SOCKOPT {
pub const SRTO_SNDBUF: SRT_SOCKOPT = SRT_SOCKOPT(5);
}
impl SRT_SOCKOPT {
pub const SRTO_RCVBUF: SRT_SOCKOPT = SRT_SOCKOPT(6);
}
impl SRT_SOCKOPT {
pub const SRTO_LINGER: SRT_SOCKOPT = SRT_SOCKOPT(7);
}
impl SRT_SOCKOPT {
pub const SRTO_UDP_SNDBUF: SRT_SOCKOPT = SRT_SOCKOPT(8);
}
impl SRT_SOCKOPT {
pub const SRTO_UDP_RCVBUF: SRT_SOCKOPT = SRT_SOCKOPT(9);
}
impl SRT_SOCKOPT {
pub const SRTO_RENDEZVOUS: SRT_SOCKOPT = SRT_SOCKOPT(12);
}
impl SRT_SOCKOPT {
pub const SRTO_SNDTIMEO: SRT_SOCKOPT = SRT_SOCKOPT(13);
}
impl SRT_SOCKOPT {
pub const SRTO_RCVTIMEO: SRT_SOCKOPT = SRT_SOCKOPT(14);
}
impl SRT_SOCKOPT {
pub const SRTO_REUSEADDR: SRT_SOCKOPT = SRT_SOCKOPT(15);
}
impl SRT_SOCKOPT {
pub const SRTO_MAXBW: SRT_SOCKOPT = SRT_SOCKOPT(16);
}
impl SRT_SOCKOPT {
pub const SRTO_STATE: SRT_SOCKOPT = SRT_SOCKOPT(17);
}
impl SRT_SOCKOPT {
pub const SRTO_EVENT: SRT_SOCKOPT = SRT_SOCKOPT(18);
}
impl SRT_SOCKOPT {
pub const SRTO_SNDDATA: SRT_SOCKOPT = SRT_SOCKOPT(19);
}
impl SRT_SOCKOPT {
pub const SRTO_RCVDATA: SRT_SOCKOPT = SRT_SOCKOPT(20);
}
impl SRT_SOCKOPT {
pub const SRTO_SENDER: SRT_SOCKOPT = SRT_SOCKOPT(21);
}
impl SRT_SOCKOPT {
pub const SRTO_TSBPDMODE: SRT_SOCKOPT = SRT_SOCKOPT(22);
}
impl SRT_SOCKOPT {
pub const SRTO_LATENCY: SRT_SOCKOPT = SRT_SOCKOPT(23);
}
impl SRT_SOCKOPT {
pub const SRTO_INPUTBW: SRT_SOCKOPT = SRT_SOCKOPT(24);
}
impl SRT_SOCKOPT {
pub const SRTO_OHEADBW: SRT_SOCKOPT = SRT_SOCKOPT(25);
}
impl SRT_SOCKOPT {
pub const SRTO_PASSPHRASE: SRT_SOCKOPT = SRT_SOCKOPT(26);
}
impl SRT_SOCKOPT {
pub const SRTO_PBKEYLEN: SRT_SOCKOPT = SRT_SOCKOPT(27);
}
impl SRT_SOCKOPT {
pub const SRTO_KMSTATE: SRT_SOCKOPT = SRT_SOCKOPT(28);
}
impl SRT_SOCKOPT {
pub const SRTO_IPTTL: SRT_SOCKOPT = SRT_SOCKOPT(29);
}
impl SRT_SOCKOPT {
pub const SRTO_IPTOS: SRT_SOCKOPT = SRT_SOCKOPT(30);
}
impl SRT_SOCKOPT {
pub const SRTO_TLPKTDROP: SRT_SOCKOPT = SRT_SOCKOPT(31);
}
impl SRT_SOCKOPT {
pub const SRTO_SNDDROPDELAY: SRT_SOCKOPT = SRT_SOCKOPT(32);
}
impl SRT_SOCKOPT {
pub const SRTO_NAKREPORT: SRT_SOCKOPT = SRT_SOCKOPT(33);
}
impl SRT_SOCKOPT {
pub const SRTO_VERSION: SRT_SOCKOPT = SRT_SOCKOPT(34);
}
impl SRT_SOCKOPT {
pub const SRTO_PEERVERSION: SRT_SOCKOPT = SRT_SOCKOPT(35);
}
impl SRT_SOCKOPT {
pub const SRTO_CONNTIMEO: SRT_SOCKOPT = SRT_SOCKOPT(36);
}
impl SRT_SOCKOPT {
pub const SRTO_DRIFTTRACER: SRT_SOCKOPT = SRT_SOCKOPT(37);
}
impl SRT_SOCKOPT {
pub const SRTO_SNDKMSTATE: SRT_SOCKOPT = SRT_SOCKOPT(40);
}
impl SRT_SOCKOPT {
pub const SRTO_RCVKMSTATE: SRT_SOCKOPT = SRT_SOCKOPT(41);
}
impl SRT_SOCKOPT {
pub const SRTO_LOSSMAXTTL: SRT_SOCKOPT = SRT_SOCKOPT(42);
}
impl SRT_SOCKOPT {
pub const SRTO_RCVLATENCY: SRT_SOCKOPT = SRT_SOCKOPT(43);
}
impl SRT_SOCKOPT {
pub const SRTO_PEERLATENCY: SRT_SOCKOPT = SRT_SOCKOPT(44);
}
impl SRT_SOCKOPT {
pub const SRTO_MINVERSION: SRT_SOCKOPT = SRT_SOCKOPT(45);
}
impl SRT_SOCKOPT {
pub const SRTO_STREAMID: SRT_SOCKOPT = SRT_SOCKOPT(46);
}
impl SRT_SOCKOPT {
pub const SRTO_CONGESTION: SRT_SOCKOPT = SRT_SOCKOPT(47);
}
impl SRT_SOCKOPT {
pub const SRTO_MESSAGEAPI: SRT_SOCKOPT = SRT_SOCKOPT(48);
}
impl SRT_SOCKOPT {
pub const SRTO_PAYLOADSIZE: SRT_SOCKOPT = SRT_SOCKOPT(49);
}
impl SRT_SOCKOPT {
pub const SRTO_TRANSTYPE: SRT_SOCKOPT = SRT_SOCKOPT(50);
}
impl SRT_SOCKOPT {
pub const SRTO_KMREFRESHRATE: SRT_SOCKOPT = SRT_SOCKOPT(51);
}
impl SRT_SOCKOPT {
pub const SRTO_KMPREANNOUNCE: SRT_SOCKOPT = SRT_SOCKOPT(52);
}
impl SRT_SOCKOPT {
pub const SRTO_ENFORCEDENCRYPTION: SRT_SOCKOPT = SRT_SOCKOPT(53);
}
impl SRT_SOCKOPT {
pub const SRTO_IPV6ONLY: SRT_SOCKOPT = SRT_SOCKOPT(54);
}
impl SRT_SOCKOPT {
pub const SRTO_PEERIDLETIMEO: SRT_SOCKOPT = SRT_SOCKOPT(55);
}
impl SRT_SOCKOPT {
pub const SRTO_BINDTODEVICE: SRT_SOCKOPT = SRT_SOCKOPT(56);
}
impl SRT_SOCKOPT {
pub const SRTO_PACKETFILTER: SRT_SOCKOPT = SRT_SOCKOPT(60);
}
impl SRT_SOCKOPT {
pub const SRTO_RETRANSMITALGO: SRT_SOCKOPT = SRT_SOCKOPT(61);
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct SRT_SOCKOPT(pub ::std::os::raw::c_uint);
impl SRT_SOCKOPT_DEPRECATED {
pub const SRTO_DEPRECATED_END: SRT_SOCKOPT_DEPRECATED = SRT_SOCKOPT_DEPRECATED(0);
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct SRT_SOCKOPT_DEPRECATED(pub ::std::os::raw::c_uint);
impl SRT_TRANSTYPE {
pub const SRTT_LIVE: SRT_TRANSTYPE = SRT_TRANSTYPE(0);
}
impl SRT_TRANSTYPE {
pub const SRTT_FILE: SRT_TRANSTYPE = SRT_TRANSTYPE(1);
}
impl SRT_TRANSTYPE {
pub const SRTT_INVALID: SRT_TRANSTYPE = SRT_TRANSTYPE(2);
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct SRT_TRANSTYPE(pub ::std::os::raw::c_uint);
pub const SRT_LIVE_DEF_PLSIZE: ::std::os::raw::c_int = 1316;
pub const SRT_LIVE_MAX_PLSIZE: ::std::os::raw::c_int = 1456;
pub const SRT_LIVE_DEF_LATENCY_MS: ::std::os::raw::c_int = 120;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct CBytePerfMon {
pub msTimeStamp: i64,
pub pktSentTotal: i64,
pub pktRecvTotal: i64,
pub pktSndLossTotal: ::std::os::raw::c_int,
pub pktRcvLossTotal: ::std::os::raw::c_int,
pub pktRetransTotal: ::std::os::raw::c_int,
pub pktSentACKTotal: ::std::os::raw::c_int,
pub pktRecvACKTotal: ::std::os::raw::c_int,
pub pktSentNAKTotal: ::std::os::raw::c_int,
pub pktRecvNAKTotal: ::std::os::raw::c_int,
pub usSndDurationTotal: i64,
pub pktSndDropTotal: ::std::os::raw::c_int,
pub pktRcvDropTotal: ::std::os::raw::c_int,
pub pktRcvUndecryptTotal: ::std::os::raw::c_int,
pub byteSentTotal: u64,
pub byteRecvTotal: u64,
pub byteRcvLossTotal: u64,
pub byteRetransTotal: u64,
pub byteSndDropTotal: u64,
pub byteRcvDropTotal: u64,
pub byteRcvUndecryptTotal: u64,
pub pktSent: i64,
pub pktRecv: i64,
pub pktSndLoss: ::std::os::raw::c_int,
pub pktRcvLoss: ::std::os::raw::c_int,
pub pktRetrans: ::std::os::raw::c_int,
pub pktRcvRetrans: ::std::os::raw::c_int,
pub pktSentACK: ::std::os::raw::c_int,
pub pktRecvACK: ::std::os::raw::c_int,
pub pktSentNAK: ::std::os::raw::c_int,
pub pktRecvNAK: ::std::os::raw::c_int,
pub mbpsSendRate: f64,
pub mbpsRecvRate: f64,
pub usSndDuration: i64,
pub pktReorderDistance: ::std::os::raw::c_int,
pub pktRcvAvgBelatedTime: f64,
pub pktRcvBelated: i64,
pub pktSndDrop: ::std::os::raw::c_int,
pub pktRcvDrop: ::std::os::raw::c_int,
pub pktRcvUndecrypt: ::std::os::raw::c_int,
pub byteSent: u64,
pub byteRecv: u64,
pub byteRcvLoss: u64,
pub byteRetrans: u64,
pub byteSndDrop: u64,
pub byteRcvDrop: u64,
pub byteRcvUndecrypt: u64,
pub usPktSndPeriod: f64,
pub pktFlowWindow: ::std::os::raw::c_int,
pub pktCongestionWindow: ::std::os::raw::c_int,
pub pktFlightSize: ::std::os::raw::c_int,
pub msRTT: f64,
pub mbpsBandwidth: f64,
pub byteAvailSndBuf: ::std::os::raw::c_int,
pub byteAvailRcvBuf: ::std::os::raw::c_int,
pub mbpsMaxBW: f64,
pub byteMSS: ::std::os::raw::c_int,
pub pktSndBuf: ::std::os::raw::c_int,
pub byteSndBuf: ::std::os::raw::c_int,
pub msSndBuf: ::std::os::raw::c_int,
pub msSndTsbPdDelay: ::std::os::raw::c_int,
pub pktRcvBuf: ::std::os::raw::c_int,
pub byteRcvBuf: ::std::os::raw::c_int,
pub msRcvBuf: ::std::os::raw::c_int,
pub msRcvTsbPdDelay: ::std::os::raw::c_int,
pub pktSndFilterExtraTotal: ::std::os::raw::c_int,
pub pktRcvFilterExtraTotal: ::std::os::raw::c_int,
pub pktRcvFilterSupplyTotal: ::std::os::raw::c_int,
pub pktRcvFilterLossTotal: ::std::os::raw::c_int,
pub pktSndFilterExtra: ::std::os::raw::c_int,
pub pktRcvFilterExtra: ::std::os::raw::c_int,
pub pktRcvFilterSupply: ::std::os::raw::c_int,
pub pktRcvFilterLoss: ::std::os::raw::c_int,
pub pktReorderTolerance: ::std::os::raw::c_int,
pub pktSentUniqueTotal: i64,
pub pktRecvUniqueTotal: i64,
pub byteSentUniqueTotal: u64,
pub byteRecvUniqueTotal: u64,
pub pktSentUnique: i64,
pub pktRecvUnique: i64,
pub byteSentUnique: u64,
pub byteRecvUnique: u64,
}
#[test]
fn bindgen_test_layout_CBytePerfMon() {
assert_eq!(
::std::mem::size_of::<CBytePerfMon>(),
496usize,
concat!("Size of: ", stringify!(CBytePerfMon))
);
assert_eq!(
::std::mem::align_of::<CBytePerfMon>(),
8usize,
concat!("Alignment of ", stringify!(CBytePerfMon))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<CBytePerfMon>())).msTimeStamp as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(CBytePerfMon),
"::",
stringify!(msTimeStamp)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<CBytePerfMon>())).pktSentTotal as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(CBytePerfMon),
"::",
stringify!(pktSentTotal)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<CBytePerfMon>())).pktRecvTotal as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(CBytePerfMon),
"::",
stringify!(pktRecvTotal)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<CBytePerfMon>())).pktSndLossTotal as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(CBytePerfMon),
"::",
stringify!(pktSndLossTotal)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<CBytePerfMon>())).pktRcvLossTotal as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(CBytePerfMon),
"::",
stringify!(pktRcvLossTotal)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<CBytePerfMon>())).pktRetransTotal as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(CBytePerfMon),
"::",
stringify!(pktRetransTotal)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<CBytePerfMon>())).pktSentACKTotal as *const _ as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(CBytePerfMon),
"::",
stringify!(pktSentACKTotal)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<CBytePerfMon>())).pktRecvACKTotal as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(CBytePerfMon),
"::",
stringify!(pktRecvACKTotal)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<CBytePerfMon>())).pktSentNAKTotal as *const _ as usize },
44usize,
concat!(
"Offset of field: ",
stringify!(CBytePerfMon),
"::",
stringify!(pktSentNAKTotal)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<CBytePerfMon>())).pktRecvNAKTotal as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(CBytePerfMon),
"::",
stringify!(pktRecvNAKTotal)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<CBytePerfMon>())).usSndDurationTotal as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(CBytePerfMon),
"::",
stringify!(usSndDurationTotal)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<CBytePerfMon>())).pktSndDropTotal as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(CBytePerfMon),
"::",
stringify!(pktSndDropTotal)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<CBytePerfMon>())).pktRcvDropTotal as *const _ as usize },
68usize,
concat!(
"Offset of field: ",
stringify!(CBytePerfMon),
"::",
stringify!(pktRcvDropTotal)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<CBytePerfMon>())).pktRcvUndecryptTotal as *const _ as usize
},
72usize,
concat!(
"Offset of field: ",
stringify!(CBytePerfMon),
"::",
stringify!(pktRcvUndecryptTotal)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<CBytePerfMon>())).byteSentTotal as *const _ as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(CBytePerfMon),
"::",
stringify!(byteSentTotal)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<CBytePerfMon>())).byteRecvTotal as *const _ as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(CBytePerfMon),
"::",
stringify!(byteRecvTotal)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<CBytePerfMon>())).byteRcvLossTotal as *const _ as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(CBytePerfMon),
"::",
stringify!(byteRcvLossTotal)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<CBytePerfMon>())).byteRetransTotal as *const _ as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(CBytePerfMon),
"::",
stringify!(byteRetransTotal)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<CBytePerfMon>())).byteSndDropTotal as *const _ as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(CBytePerfMon),
"::",
stringify!(byteSndDropTotal)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<CBytePerfMon>())).byteRcvDropTotal as *const _ as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(CBytePerfMon),
"::",
stringify!(byteRcvDropTotal)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<CBytePerfMon>())).byteRcvUndecryptTotal as *const _ as usize
},
128usize,
concat!(
"Offset of field: ",
stringify!(CBytePerfMon),
"::",
stringify!(byteRcvUndecryptTotal)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<CBytePerfMon>())).pktSent as *const _ as usize },
136usize,
concat!(
"Offset of field: ",
stringify!(CBytePerfMon),
"::",
stringify!(pktSent)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<CBytePerfMon>())).pktRecv as *const _ as usize },
144usize,
concat!(
"Offset of field: ",
stringify!(CBytePerfMon),
"::",
stringify!(pktRecv)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<CBytePerfMon>())).pktSndLoss as *const _ as usize },
152usize,
concat!(
"Offset of field: ",
stringify!(CBytePerfMon),
"::",
stringify!(pktSndLoss)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<CBytePerfMon>())).pktRcvLoss as *const _ as usize },
156usize,
concat!(
"Offset of field: ",
stringify!(CBytePerfMon),
"::",
stringify!(pktRcvLoss)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<CBytePerfMon>())).pktRetrans as *const _ as usize },
160usize,
concat!(
"Offset of field: ",
stringify!(CBytePerfMon),
"::",
stringify!(pktRetrans)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<CBytePerfMon>())).pktRcvRetrans as *const _ as usize },
164usize,
concat!(
"Offset of field: ",
stringify!(CBytePerfMon),
"::",
stringify!(pktRcvRetrans)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<CBytePerfMon>())).pktSentACK as *const _ as usize },
168usize,
concat!(
"Offset of field: ",
stringify!(CBytePerfMon),
"::",
stringify!(pktSentACK)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<CBytePerfMon>())).pktRecvACK as *const _ as usize },
172usize,
concat!(
"Offset of field: ",
stringify!(CBytePerfMon),
"::",
stringify!(pktRecvACK)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<CBytePerfMon>())).pktSentNAK as *const _ as usize },
176usize,
concat!(
"Offset of field: ",
stringify!(CBytePerfMon),
"::",
stringify!(pktSentNAK)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<CBytePerfMon>())).pktRecvNAK as *const _ as usize },
180usize,
concat!(
"Offset of field: ",
stringify!(CBytePerfMon),
"::",
stringify!(pktRecvNAK)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<CBytePerfMon>())).mbpsSendRate as *const _ as usize },
184usize,
concat!(
"Offset of field: ",
stringify!(CBytePerfMon),
"::",
stringify!(mbpsSendRate)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<CBytePerfMon>())).mbpsRecvRate as *const _ as usize },
192usize,
concat!(
"Offset of field: ",
stringify!(CBytePerfMon),
"::",
stringify!(mbpsRecvRate)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<CBytePerfMon>())).usSndDuration as *const _ as usize },
200usize,
concat!(
"Offset of field: ",
stringify!(CBytePerfMon),
"::",
stringify!(usSndDuration)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<CBytePerfMon>())).pktReorderDistance as *const _ as usize },
208usize,
concat!(
"Offset of field: ",
stringify!(CBytePerfMon),
"::",
stringify!(pktReorderDistance)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<CBytePerfMon>())).pktRcvAvgBelatedTime as *const _ as usize
},
216usize,
concat!(
"Offset of field: ",
stringify!(CBytePerfMon),
"::",
stringify!(pktRcvAvgBelatedTime)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<CBytePerfMon>())).pktRcvBelated as *const _ as usize },
224usize,
concat!(
"Offset of field: ",
stringify!(CBytePerfMon),
"::",
stringify!(pktRcvBelated)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<CBytePerfMon>())).pktSndDrop as *const _ as usize },
232usize,
concat!(
"Offset of field: ",
stringify!(CBytePerfMon),
"::",
stringify!(pktSndDrop)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<CBytePerfMon>())).pktRcvDrop as *const _ as usize },
236usize,
concat!(
"Offset of field: ",
stringify!(CBytePerfMon),
"::",
stringify!(pktRcvDrop)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<CBytePerfMon>())).pktRcvUndecrypt as *const _ as usize },
240usize,
concat!(
"Offset of field: ",
stringify!(CBytePerfMon),
"::",
stringify!(pktRcvUndecrypt)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<CBytePerfMon>())).byteSent as *const _ as usize },
248usize,
concat!(
"Offset of field: ",
stringify!(CBytePerfMon),
"::",
stringify!(byteSent)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<CBytePerfMon>())).byteRecv as *const _ as usize },
256usize,
concat!(
"Offset of field: ",
stringify!(CBytePerfMon),
"::",
stringify!(byteRecv)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<CBytePerfMon>())).byteRcvLoss as *const _ as usize },
264usize,
concat!(
"Offset of field: ",
stringify!(CBytePerfMon),
"::",
stringify!(byteRcvLoss)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<CBytePerfMon>())).byteRetrans as *const _ as usize },
272usize,
concat!(
"Offset of field: ",
stringify!(CBytePerfMon),
"::",
stringify!(byteRetrans)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<CBytePerfMon>())).byteSndDrop as *const _ as usize },
280usize,
concat!(
"Offset of field: ",
stringify!(CBytePerfMon),
"::",
stringify!(byteSndDrop)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<CBytePerfMon>())).byteRcvDrop as *const _ as usize },
288usize,
concat!(
"Offset of field: ",
stringify!(CBytePerfMon),
"::",
stringify!(byteRcvDrop)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<CBytePerfMon>())).byteRcvUndecrypt as *const _ as usize },
296usize,
concat!(
"Offset of field: ",
stringify!(CBytePerfMon),
"::",
stringify!(byteRcvUndecrypt)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<CBytePerfMon>())).usPktSndPeriod as *const _ as usize },
304usize,
concat!(
"Offset of field: ",
stringify!(CBytePerfMon),
"::",
stringify!(usPktSndPeriod)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<CBytePerfMon>())).pktFlowWindow as *const _ as usize },
312usize,
concat!(
"Offset of field: ",
stringify!(CBytePerfMon),
"::",
stringify!(pktFlowWindow)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<CBytePerfMon>())).pktCongestionWindow as *const _ as usize
},
316usize,
concat!(
"Offset of field: ",
stringify!(CBytePerfMon),
"::",
stringify!(pktCongestionWindow)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<CBytePerfMon>())).pktFlightSize as *const _ as usize },
320usize,
concat!(
"Offset of field: ",
stringify!(CBytePerfMon),
"::",
stringify!(pktFlightSize)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<CBytePerfMon>())).msRTT as *const _ as usize },
328usize,
concat!(
"Offset of field: ",
stringify!(CBytePerfMon),
"::",
stringify!(msRTT)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<CBytePerfMon>())).mbpsBandwidth as *const _ as usize },
336usize,
concat!(
"Offset of field: ",
stringify!(CBytePerfMon),
"::",
stringify!(mbpsBandwidth)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<CBytePerfMon>())).byteAvailSndBuf as *const _ as usize },
344usize,
concat!(
"Offset of field: ",
stringify!(CBytePerfMon),
"::",
stringify!(byteAvailSndBuf)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<CBytePerfMon>())).byteAvailRcvBuf as *const _ as usize },
348usize,
concat!(
"Offset of field: ",
stringify!(CBytePerfMon),
"::",
stringify!(byteAvailRcvBuf)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<CBytePerfMon>())).mbpsMaxBW as *const _ as usize },
352usize,
concat!(
"Offset of field: ",
stringify!(CBytePerfMon),
"::",
stringify!(mbpsMaxBW)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<CBytePerfMon>())).byteMSS as *const _ as usize },
360usize,
concat!(
"Offset of field: ",
stringify!(CBytePerfMon),
"::",
stringify!(byteMSS)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<CBytePerfMon>())).pktSndBuf as *const _ as usize },
364usize,
concat!(
"Offset of field: ",
stringify!(CBytePerfMon),
"::",
stringify!(pktSndBuf)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<CBytePerfMon>())).byteSndBuf as *const _ as usize },
368usize,
concat!(
"Offset of field: ",
stringify!(CBytePerfMon),
"::",
stringify!(byteSndBuf)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<CBytePerfMon>())).msSndBuf as *const _ as usize },
372usize,
concat!(
"Offset of field: ",
stringify!(CBytePerfMon),
"::",
stringify!(msSndBuf)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<CBytePerfMon>())).msSndTsbPdDelay as *const _ as usize },
376usize,
concat!(
"Offset of field: ",
stringify!(CBytePerfMon),
"::",
stringify!(msSndTsbPdDelay)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<CBytePerfMon>())).pktRcvBuf as *const _ as usize },
380usize,
concat!(
"Offset of field: ",
stringify!(CBytePerfMon),
"::",
stringify!(pktRcvBuf)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<CBytePerfMon>())).byteRcvBuf as *const _ as usize },
384usize,
concat!(
"Offset of field: ",
stringify!(CBytePerfMon),
"::",
stringify!(byteRcvBuf)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<CBytePerfMon>())).msRcvBuf as *const _ as usize },
388usize,
concat!(
"Offset of field: ",
stringify!(CBytePerfMon),
"::",
stringify!(msRcvBuf)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<CBytePerfMon>())).msRcvTsbPdDelay as *const _ as usize },
392usize,
concat!(
"Offset of field: ",
stringify!(CBytePerfMon),
"::",
stringify!(msRcvTsbPdDelay)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<CBytePerfMon>())).pktSndFilterExtraTotal as *const _ as usize
},
396usize,
concat!(
"Offset of field: ",
stringify!(CBytePerfMon),
"::",
stringify!(pktSndFilterExtraTotal)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<CBytePerfMon>())).pktRcvFilterExtraTotal as *const _ as usize
},
400usize,
concat!(
"Offset of field: ",
stringify!(CBytePerfMon),
"::",
stringify!(pktRcvFilterExtraTotal)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<CBytePerfMon>())).pktRcvFilterSupplyTotal as *const _ as usize
},
404usize,
concat!(
"Offset of field: ",
stringify!(CBytePerfMon),
"::",
stringify!(pktRcvFilterSupplyTotal)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<CBytePerfMon>())).pktRcvFilterLossTotal as *const _ as usize
},
408usize,
concat!(
"Offset of field: ",
stringify!(CBytePerfMon),
"::",
stringify!(pktRcvFilterLossTotal)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<CBytePerfMon>())).pktSndFilterExtra as *const _ as usize },
412usize,
concat!(
"Offset of field: ",
stringify!(CBytePerfMon),
"::",
stringify!(pktSndFilterExtra)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<CBytePerfMon>())).pktRcvFilterExtra as *const _ as usize },
416usize,
concat!(
"Offset of field: ",
stringify!(CBytePerfMon),
"::",
stringify!(pktRcvFilterExtra)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<CBytePerfMon>())).pktRcvFilterSupply as *const _ as usize },
420usize,
concat!(
"Offset of field: ",
stringify!(CBytePerfMon),
"::",
stringify!(pktRcvFilterSupply)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<CBytePerfMon>())).pktRcvFilterLoss as *const _ as usize },
424usize,
concat!(
"Offset of field: ",
stringify!(CBytePerfMon),
"::",
stringify!(pktRcvFilterLoss)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<CBytePerfMon>())).pktReorderTolerance as *const _ as usize
},
428usize,
concat!(
"Offset of field: ",
stringify!(CBytePerfMon),
"::",
stringify!(pktReorderTolerance)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<CBytePerfMon>())).pktSentUniqueTotal as *const _ as usize },
432usize,
concat!(
"Offset of field: ",
stringify!(CBytePerfMon),
"::",
stringify!(pktSentUniqueTotal)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<CBytePerfMon>())).pktRecvUniqueTotal as *const _ as usize },
440usize,
concat!(
"Offset of field: ",
stringify!(CBytePerfMon),
"::",
stringify!(pktRecvUniqueTotal)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<CBytePerfMon>())).byteSentUniqueTotal as *const _ as usize
},
448usize,
concat!(
"Offset of field: ",
stringify!(CBytePerfMon),
"::",
stringify!(byteSentUniqueTotal)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<CBytePerfMon>())).byteRecvUniqueTotal as *const _ as usize
},
456usize,
concat!(
"Offset of field: ",
stringify!(CBytePerfMon),
"::",
stringify!(byteRecvUniqueTotal)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<CBytePerfMon>())).pktSentUnique as *const _ as usize },
464usize,
concat!(
"Offset of field: ",
stringify!(CBytePerfMon),
"::",
stringify!(pktSentUnique)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<CBytePerfMon>())).pktRecvUnique as *const _ as usize },
472usize,
concat!(
"Offset of field: ",
stringify!(CBytePerfMon),
"::",
stringify!(pktRecvUnique)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<CBytePerfMon>())).byteSentUnique as *const _ as usize },
480usize,
concat!(
"Offset of field: ",
stringify!(CBytePerfMon),
"::",
stringify!(byteSentUnique)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<CBytePerfMon>())).byteRecvUnique as *const _ as usize },
488usize,
concat!(
"Offset of field: ",
stringify!(CBytePerfMon),
"::",
stringify!(byteRecvUnique)
)
);
}
impl SRT_ERRNO {
pub const SRT_EUNKNOWN: SRT_ERRNO = SRT_ERRNO(-1);
}
impl SRT_ERRNO {
pub const SRT_SUCCESS: SRT_ERRNO = SRT_ERRNO(0);
}
impl SRT_ERRNO {
pub const SRT_ECONNSETUP: SRT_ERRNO = SRT_ERRNO(1000);
}
impl SRT_ERRNO {
pub const SRT_ENOSERVER: SRT_ERRNO = SRT_ERRNO(1001);
}
impl SRT_ERRNO {
pub const SRT_ECONNREJ: SRT_ERRNO = SRT_ERRNO(1002);
}
impl SRT_ERRNO {
pub const SRT_ESOCKFAIL: SRT_ERRNO = SRT_ERRNO(1003);
}
impl SRT_ERRNO {
pub const SRT_ESECFAIL: SRT_ERRNO = SRT_ERRNO(1004);
}
impl SRT_ERRNO {
pub const SRT_ESCLOSED: SRT_ERRNO = SRT_ERRNO(1005);
}
impl SRT_ERRNO {
pub const SRT_ECONNFAIL: SRT_ERRNO = SRT_ERRNO(2000);
}
impl SRT_ERRNO {
pub const SRT_ECONNLOST: SRT_ERRNO = SRT_ERRNO(2001);
}
impl SRT_ERRNO {
pub const SRT_ENOCONN: SRT_ERRNO = SRT_ERRNO(2002);
}
impl SRT_ERRNO {
pub const SRT_ERESOURCE: SRT_ERRNO = SRT_ERRNO(3000);
}
impl SRT_ERRNO {
pub const SRT_ETHREAD: SRT_ERRNO = SRT_ERRNO(3001);
}
impl SRT_ERRNO {
pub const SRT_ENOBUF: SRT_ERRNO = SRT_ERRNO(3002);
}
impl SRT_ERRNO {
pub const SRT_ESYSOBJ: SRT_ERRNO = SRT_ERRNO(3003);
}
impl SRT_ERRNO {
pub const SRT_EFILE: SRT_ERRNO = SRT_ERRNO(4000);
}
impl SRT_ERRNO {
pub const SRT_EINVRDOFF: SRT_ERRNO = SRT_ERRNO(4001);
}
impl SRT_ERRNO {
pub const SRT_ERDPERM: SRT_ERRNO = SRT_ERRNO(4002);
}
impl SRT_ERRNO {
pub const SRT_EINVWROFF: SRT_ERRNO = SRT_ERRNO(4003);
}
impl SRT_ERRNO {
pub const SRT_EWRPERM: SRT_ERRNO = SRT_ERRNO(4004);
}
impl SRT_ERRNO {
pub const SRT_EINVOP: SRT_ERRNO = SRT_ERRNO(5000);
}
impl SRT_ERRNO {
pub const SRT_EBOUNDSOCK: SRT_ERRNO = SRT_ERRNO(5001);
}
impl SRT_ERRNO {
pub const SRT_ECONNSOCK: SRT_ERRNO = SRT_ERRNO(5002);
}
impl SRT_ERRNO {
pub const SRT_EINVPARAM: SRT_ERRNO = SRT_ERRNO(5003);
}
impl SRT_ERRNO {
pub const SRT_EINVSOCK: SRT_ERRNO = SRT_ERRNO(5004);
}
impl SRT_ERRNO {
pub const SRT_EUNBOUNDSOCK: SRT_ERRNO = SRT_ERRNO(5005);
}
impl SRT_ERRNO {
pub const SRT_ENOLISTEN: SRT_ERRNO = SRT_ERRNO(5006);
}
impl SRT_ERRNO {
pub const SRT_ERDVNOSERV: SRT_ERRNO = SRT_ERRNO(5007);
}
impl SRT_ERRNO {
pub const SRT_ERDVUNBOUND: SRT_ERRNO = SRT_ERRNO(5008);
}
impl SRT_ERRNO {
pub const SRT_EINVALMSGAPI: SRT_ERRNO = SRT_ERRNO(5009);
}
impl SRT_ERRNO {
pub const SRT_EINVALBUFFERAPI: SRT_ERRNO = SRT_ERRNO(5010);
}
impl SRT_ERRNO {
pub const SRT_EDUPLISTEN: SRT_ERRNO = SRT_ERRNO(5011);
}
impl SRT_ERRNO {
pub const SRT_ELARGEMSG: SRT_ERRNO = SRT_ERRNO(5012);
}
impl SRT_ERRNO {
pub const SRT_EINVPOLLID: SRT_ERRNO = SRT_ERRNO(5013);
}
impl SRT_ERRNO {
pub const SRT_EPOLLEMPTY: SRT_ERRNO = SRT_ERRNO(5014);
}
impl SRT_ERRNO {
pub const SRT_EASYNCFAIL: SRT_ERRNO = SRT_ERRNO(6000);
}
impl SRT_ERRNO {
pub const SRT_EASYNCSND: SRT_ERRNO = SRT_ERRNO(6001);
}
impl SRT_ERRNO {
pub const SRT_EASYNCRCV: SRT_ERRNO = SRT_ERRNO(6002);
}
impl SRT_ERRNO {
pub const SRT_ETIMEOUT: SRT_ERRNO = SRT_ERRNO(6003);
}
impl SRT_ERRNO {
pub const SRT_ECONGEST: SRT_ERRNO = SRT_ERRNO(6004);
}
impl SRT_ERRNO {
pub const SRT_EPEERERR: SRT_ERRNO = SRT_ERRNO(7000);
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct SRT_ERRNO(pub ::std::os::raw::c_int);
impl SRT_REJECT_REASON {
pub const SRT_REJ_UNKNOWN: SRT_REJECT_REASON = SRT_REJECT_REASON(0);
}
impl SRT_REJECT_REASON {
pub const SRT_REJ_SYSTEM: SRT_REJECT_REASON = SRT_REJECT_REASON(1);
}
impl SRT_REJECT_REASON {
pub const SRT_REJ_PEER: SRT_REJECT_REASON = SRT_REJECT_REASON(2);
}
impl SRT_REJECT_REASON {
pub const SRT_REJ_RESOURCE: SRT_REJECT_REASON = SRT_REJECT_REASON(3);
}
impl SRT_REJECT_REASON {
pub const SRT_REJ_ROGUE: SRT_REJECT_REASON = SRT_REJECT_REASON(4);
}
impl SRT_REJECT_REASON {
pub const SRT_REJ_BACKLOG: SRT_REJECT_REASON = SRT_REJECT_REASON(5);
}
impl SRT_REJECT_REASON {
pub const SRT_REJ_IPE: SRT_REJECT_REASON = SRT_REJECT_REASON(6);
}
impl SRT_REJECT_REASON {
pub const SRT_REJ_CLOSE: SRT_REJECT_REASON = SRT_REJECT_REASON(7);
}
impl SRT_REJECT_REASON {
pub const SRT_REJ_VERSION: SRT_REJECT_REASON = SRT_REJECT_REASON(8);
}
impl SRT_REJECT_REASON {
pub const SRT_REJ_RDVCOOKIE: SRT_REJECT_REASON = SRT_REJECT_REASON(9);
}
impl SRT_REJECT_REASON {
pub const SRT_REJ_BADSECRET: SRT_REJECT_REASON = SRT_REJECT_REASON(10);
}
impl SRT_REJECT_REASON {
pub const SRT_REJ_UNSECURE: SRT_REJECT_REASON = SRT_REJECT_REASON(11);
}
impl SRT_REJECT_REASON {
pub const SRT_REJ_MESSAGEAPI: SRT_REJECT_REASON = SRT_REJECT_REASON(12);
}
impl SRT_REJECT_REASON {
pub const SRT_REJ_CONGESTION: SRT_REJECT_REASON = SRT_REJECT_REASON(13);
}
impl SRT_REJECT_REASON {
pub const SRT_REJ_FILTER: SRT_REJECT_REASON = SRT_REJECT_REASON(14);
}
impl SRT_REJECT_REASON {
pub const SRT_REJ_GROUP: SRT_REJECT_REASON = SRT_REJECT_REASON(15);
}
impl SRT_REJECT_REASON {
pub const SRT_REJ_TIMEOUT: SRT_REJECT_REASON = SRT_REJECT_REASON(16);
}
impl SRT_REJECT_REASON {
pub const SRT_REJ_E_SIZE: SRT_REJECT_REASON = SRT_REJECT_REASON(17);
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct SRT_REJECT_REASON(pub ::std::os::raw::c_uint);
impl SRT_KM_STATE {
pub const SRT_KM_S_UNSECURED: SRT_KM_STATE = SRT_KM_STATE(0);
}
impl SRT_KM_STATE {
pub const SRT_KM_S_SECURING: SRT_KM_STATE = SRT_KM_STATE(1);
}
impl SRT_KM_STATE {
pub const SRT_KM_S_SECURED: SRT_KM_STATE = SRT_KM_STATE(2);
}
impl SRT_KM_STATE {
pub const SRT_KM_S_NOSECRET: SRT_KM_STATE = SRT_KM_STATE(3);
}
impl SRT_KM_STATE {
pub const SRT_KM_S_BADSECRET: SRT_KM_STATE = SRT_KM_STATE(4);
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct SRT_KM_STATE(pub ::std::os::raw::c_uint);
impl SRT_EPOLL_OPT {
pub const SRT_EPOLL_OPT_NONE: SRT_EPOLL_OPT = SRT_EPOLL_OPT(0);
}
impl SRT_EPOLL_OPT {
#[doc = " Ready for 'recv' operation:"]
#[doc = ""]
#[doc = " - For stream mode it means that at least 1 byte is available."]
#[doc = " In this mode the buffer may extract only a part of the packet,"]
#[doc = " leaving next data possible for extraction later."]
#[doc = ""]
#[doc = " - For message mode it means that there is at least one packet"]
#[doc = " available (this may change in future, as it is desired that"]
#[doc = " one full message should only wake up, not single packet of a"]
#[doc = " not yet extractable message)."]
#[doc = ""]
#[doc = " - For live mode it means that there's at least one packet"]
#[doc = " ready to play."]
#[doc = ""]
#[doc = " - For listener sockets, this means that there is a new connection"]
#[doc = " waiting for pickup through the `srt_accept()` call, that is,"]
#[doc = " the next call to `srt_accept()` will succeed without blocking"]
#[doc = " (see an alias SRT_EPOLL_ACCEPT below)."]
pub const SRT_EPOLL_IN: SRT_EPOLL_OPT = SRT_EPOLL_OPT(1);
}
impl SRT_EPOLL_OPT {
#[doc = " Ready for 'send' operation."]
#[doc = ""]
#[doc = " - For stream mode it means that there's a free space in the"]
#[doc = " sender buffer for at least 1 byte of data. The next send"]
#[doc = " operation will only allow to send as much data as it is free"]
#[doc = " space in the buffer."]
#[doc = ""]
#[doc = " - For message mode it means that there's a free space for at"]
#[doc = " least one UDP packet. The edge-triggered mode can be used to"]
#[doc = " pick up updates as the free space in the sender buffer grows."]
#[doc = ""]
#[doc = " - For live mode it means that there's a free space for at least"]
#[doc = " one UDP packet. On the other hand, no readiness for OUT usually"]
#[doc = " means an extraordinary congestion on the link, meaning also that"]
#[doc = " you should immediately slow down the sending rate or you may get"]
#[doc = " a connection break soon."]
#[doc = ""]
#[doc = " - For non-blocking sockets used with `srt_connect*` operation,"]
#[doc = " this flag simply means that the connection was established."]
pub const SRT_EPOLL_OUT: SRT_EPOLL_OPT = SRT_EPOLL_OPT(4);
}
impl SRT_EPOLL_OPT {
#[doc = " The socket has encountered an error in the last operation"]
#[doc = " and the next operation on that socket will end up with error."]
#[doc = " You can retry the operation, but getting the error from it"]
#[doc = " is certain, so you may as well close the socket."]
pub const SRT_EPOLL_ERR: SRT_EPOLL_OPT = SRT_EPOLL_OPT(8);
}
impl SRT_EPOLL_OPT {
#[doc = " The socket has encountered an error in the last operation"]
#[doc = " and the next operation on that socket will end up with error."]
#[doc = " You can retry the operation, but getting the error from it"]
#[doc = " is certain, so you may as well close the socket."]
pub const SRT_EPOLL_CONNECT: SRT_EPOLL_OPT = SRT_EPOLL_OPT(4);
}
impl SRT_EPOLL_OPT {
#[doc = " The socket has encountered an error in the last operation"]
#[doc = " and the next operation on that socket will end up with error."]
#[doc = " You can retry the operation, but getting the error from it"]
#[doc = " is certain, so you may as well close the socket."]
pub const SRT_EPOLL_ACCEPT: SRT_EPOLL_OPT = SRT_EPOLL_OPT(1);
}
impl SRT_EPOLL_OPT {
#[doc = " The socket has encountered an error in the last operation"]
#[doc = " and the next operation on that socket will end up with error."]
#[doc = " You can retry the operation, but getting the error from it"]
#[doc = " is certain, so you may as well close the socket."]
pub const SRT_EPOLL_UPDATE: SRT_EPOLL_OPT = SRT_EPOLL_OPT(16);
}
impl SRT_EPOLL_OPT {
#[doc = " The socket has encountered an error in the last operation"]
#[doc = " and the next operation on that socket will end up with error."]
#[doc = " You can retry the operation, but getting the error from it"]
#[doc = " is certain, so you may as well close the socket."]
pub const SRT_EPOLL_ET: SRT_EPOLL_OPT = SRT_EPOLL_OPT(2147483648);
}
impl ::std::ops::BitOr<SRT_EPOLL_OPT> for SRT_EPOLL_OPT {
type Output = Self;
#[inline]
fn bitor(self, other: Self) -> Self {
SRT_EPOLL_OPT(self.0 | other.0)
}
}
impl ::std::ops::BitOrAssign for SRT_EPOLL_OPT {
#[inline]
fn bitor_assign(&mut self, rhs: SRT_EPOLL_OPT) {
self.0 |= rhs.0;
}
}
impl ::std::ops::BitAnd<SRT_EPOLL_OPT> for SRT_EPOLL_OPT {
type Output = Self;
#[inline]
fn bitand(self, other: Self) -> Self {
SRT_EPOLL_OPT(self.0 & other.0)
}
}
impl ::std::ops::BitAndAssign for SRT_EPOLL_OPT {
#[inline]
fn bitand_assign(&mut self, rhs: SRT_EPOLL_OPT) {
self.0 &= rhs.0;
}
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct SRT_EPOLL_OPT(pub ::std::os::raw::c_uint);
pub type SRT_EPOLL_T = i32;
impl SRT_EPOLL_FLAGS {
#[doc = " This allows the EID container to be empty when calling the waiting"]
#[doc = " function with infinite time. This means an infinite hangup, although"]
#[doc = " a socket can be added to this EID from a separate thread."]
pub const SRT_EPOLL_ENABLE_EMPTY: SRT_EPOLL_FLAGS = SRT_EPOLL_FLAGS(1);
}
impl SRT_EPOLL_FLAGS {
#[doc = " This makes the waiting function check if there is output container"]
#[doc = " passed to it, and report an error if it isn't. By default it is allowed"]
#[doc = " that the output container is 0 size or NULL and therefore the readiness"]
#[doc = " state is reported only as a number of ready sockets from return value."]
pub const SRT_EPOLL_ENABLE_OUTPUTCHECK: SRT_EPOLL_FLAGS = SRT_EPOLL_FLAGS(2);
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct SRT_EPOLL_FLAGS(pub ::std::os::raw::c_uint);
pub type SRT_TRACEBSTATS = CBytePerfMon;
pub const SRT_INVALID_SOCK: SRTSOCKET = -1;
pub const SRT_ERROR: ::std::os::raw::c_int = -1;
extern "C" {
pub fn srt_startup() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn srt_cleanup() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn srt_socket(
arg1: ::std::os::raw::c_int,
arg2: ::std::os::raw::c_int,
arg3: ::std::os::raw::c_int,
) -> SRTSOCKET;
}
extern "C" {
pub fn srt_create_socket() -> SRTSOCKET;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SRT_SocketGroupData_ {
_unused: [u8; 0],
}
pub type SRT_SOCKGROUPDATA = SRT_SocketGroupData_;
extern "C" {
pub fn srt_bind(
u: SRTSOCKET,
name: *const sockaddr,
namelen: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn srt_bind_acquire(u: SRTSOCKET, sys_udp_sock: UDPSOCKET) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn srt_listen(u: SRTSOCKET, backlog: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn srt_accept(
u: SRTSOCKET,
addr: *mut sockaddr,
addrlen: *mut ::std::os::raw::c_int,
) -> SRTSOCKET;
}
extern "C" {
pub fn srt_accept_bond(
listeners: *const SRTSOCKET,
lsize: ::std::os::raw::c_int,
msTimeOut: i64,
) -> SRTSOCKET;
}
pub type srt_listen_callback_fn = ::std::option::Option<
unsafe extern "C" fn(
opaq: *mut ::std::os::raw::c_void,
ns: SRTSOCKET,
hsversion: ::std::os::raw::c_int,
peeraddr: *const sockaddr,
streamid: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int,
>;
extern "C" {
pub fn srt_listen_callback(
lsn: SRTSOCKET,
hook_fn: srt_listen_callback_fn,
hook_opaque: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int;
}
pub type srt_connect_callback_fn = ::std::option::Option<
unsafe extern "C" fn(
opaq: *mut ::std::os::raw::c_void,
ns: SRTSOCKET,
errorcode: ::std::os::raw::c_int,
peeraddr: *const sockaddr,
token: ::std::os::raw::c_int,
),
>;
extern "C" {
pub fn srt_connect_callback(
clr: SRTSOCKET,
hook_fn: srt_connect_callback_fn,
hook_opaque: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn srt_connect(
u: SRTSOCKET,
name: *const sockaddr,
namelen: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn srt_connect_debug(
u: SRTSOCKET,
name: *const sockaddr,
namelen: ::std::os::raw::c_int,
forced_isn: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn srt_connect_bind(
u: SRTSOCKET,
source: *const sockaddr,
target: *const sockaddr,
len: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn srt_rendezvous(
u: SRTSOCKET,
local_name: *const sockaddr,
local_namelen: ::std::os::raw::c_int,
remote_name: *const sockaddr,
remote_namelen: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn srt_close(u: SRTSOCKET) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn srt_getpeername(
u: SRTSOCKET,
name: *mut sockaddr,
namelen: *mut ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn srt_getsockname(
u: SRTSOCKET,
name: *mut sockaddr,
namelen: *mut ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn srt_getsockopt(
u: SRTSOCKET,
level: ::std::os::raw::c_int,
optname: SRT_SOCKOPT,
optval: *mut ::std::os::raw::c_void,
optlen: *mut ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn srt_setsockopt(
u: SRTSOCKET,
level: ::std::os::raw::c_int,
optname: SRT_SOCKOPT,
optval: *const ::std::os::raw::c_void,
optlen: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn srt_getsockflag(
u: SRTSOCKET,
opt: SRT_SOCKOPT,
optval: *mut ::std::os::raw::c_void,
optlen: *mut ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn srt_setsockflag(
u: SRTSOCKET,
opt: SRT_SOCKOPT,
optval: *const ::std::os::raw::c_void,
optlen: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SRT_MsgCtrl_ {
pub flags: ::std::os::raw::c_int,
pub msgttl: ::std::os::raw::c_int,
pub inorder: ::std::os::raw::c_int,
pub boundary: ::std::os::raw::c_int,
pub srctime: i64,
pub pktseq: i32,
pub msgno: i32,
pub grpdata: *mut SRT_SOCKGROUPDATA,
pub grpdata_size: usize,
}
#[test]
fn bindgen_test_layout_SRT_MsgCtrl_() {
assert_eq!(
::std::mem::size_of::<SRT_MsgCtrl_>(),
48usize,
concat!("Size of: ", stringify!(SRT_MsgCtrl_))
);
assert_eq!(
::std::mem::align_of::<SRT_MsgCtrl_>(),
8usize,
concat!("Alignment of ", stringify!(SRT_MsgCtrl_))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<SRT_MsgCtrl_>())).flags as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(SRT_MsgCtrl_),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<SRT_MsgCtrl_>())).msgttl as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(SRT_MsgCtrl_),
"::",
stringify!(msgttl)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<SRT_MsgCtrl_>())).inorder as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(SRT_MsgCtrl_),
"::",
stringify!(inorder)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<SRT_MsgCtrl_>())).boundary as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(SRT_MsgCtrl_),
"::",
stringify!(boundary)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<SRT_MsgCtrl_>())).srctime as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(SRT_MsgCtrl_),
"::",
stringify!(srctime)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<SRT_MsgCtrl_>())).pktseq as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(SRT_MsgCtrl_),
"::",
stringify!(pktseq)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<SRT_MsgCtrl_>())).msgno as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(SRT_MsgCtrl_),
"::",
stringify!(msgno)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<SRT_MsgCtrl_>())).grpdata as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(SRT_MsgCtrl_),
"::",
stringify!(grpdata)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<SRT_MsgCtrl_>())).grpdata_size as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(SRT_MsgCtrl_),
"::",
stringify!(grpdata_size)
)
);
}
pub type SRT_MSGCTRL = SRT_MsgCtrl_;
pub const SRT_SEQNO_NONE: i32 = -1;
pub const SRT_MSGNO_NONE: i32 = -1;
pub const SRT_MSGNO_CONTROL: i32 = 0;
pub const SRT_MSGTTL_INF: ::std::os::raw::c_int = -1;
extern "C" {
pub fn srt_msgctrl_init(mctrl: *mut SRT_MSGCTRL);
}
extern "C" {
pub fn srt_send(
u: SRTSOCKET,
buf: *const ::std::os::raw::c_char,
len: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn srt_sendmsg(
u: SRTSOCKET,
buf: *const ::std::os::raw::c_char,
len: ::std::os::raw::c_int,
ttl: ::std::os::raw::c_int,
inorder: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn srt_sendmsg2(
u: SRTSOCKET,
buf: *const ::std::os::raw::c_char,
len: ::std::os::raw::c_int,
mctrl: *mut SRT_MSGCTRL,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn srt_recv(
u: SRTSOCKET,
buf: *mut ::std::os::raw::c_char,
len: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn srt_recvmsg(
u: SRTSOCKET,
buf: *mut ::std::os::raw::c_char,
len: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn srt_recvmsg2(
u: SRTSOCKET,
buf: *mut ::std::os::raw::c_char,
len: ::std::os::raw::c_int,
mctrl: *mut SRT_MSGCTRL,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn srt_sendfile(
u: SRTSOCKET,
path: *const ::std::os::raw::c_char,
offset: *mut i64,
size: i64,
block: ::std::os::raw::c_int,
) -> i64;
}
extern "C" {
pub fn srt_recvfile(
u: SRTSOCKET,
path: *const ::std::os::raw::c_char,
offset: *mut i64,
size: i64,
block: ::std::os::raw::c_int,
) -> i64;
}
extern "C" {
pub fn srt_getlasterror_str() -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn srt_getlasterror(errno_loc: *mut ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn srt_strerror(
code: ::std::os::raw::c_int,
errnoval: ::std::os::raw::c_int,
) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn srt_clearlasterror();
}
extern "C" {
pub fn srt_bstats(
u: SRTSOCKET,
perf: *mut SRT_TRACEBSTATS,
clear: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn srt_bistats(
u: SRTSOCKET,
perf: *mut SRT_TRACEBSTATS,
clear: ::std::os::raw::c_int,
instantaneous: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn srt_getsockstate(u: SRTSOCKET) -> SRT_SOCKSTATUS;
}
extern "C" {
pub fn srt_epoll_create() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn srt_epoll_clear_usocks(eid: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn srt_epoll_add_usock(
eid: ::std::os::raw::c_int,
u: SRTSOCKET,
events: *const ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn srt_epoll_add_ssock(
eid: ::std::os::raw::c_int,
s: SYSSOCKET,
events: *const ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn srt_epoll_remove_usock(
eid: ::std::os::raw::c_int,
u: SRTSOCKET,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn srt_epoll_remove_ssock(
eid: ::std::os::raw::c_int,
s: SYSSOCKET,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn srt_epoll_update_usock(
eid: ::std::os::raw::c_int,
u: SRTSOCKET,
events: *const ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn srt_epoll_update_ssock(
eid: ::std::os::raw::c_int,
s: SYSSOCKET,
events: *const ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn srt_epoll_wait(
eid: ::std::os::raw::c_int,
readfds: *mut SRTSOCKET,
rnum: *mut ::std::os::raw::c_int,
writefds: *mut SRTSOCKET,
wnum: *mut ::std::os::raw::c_int,
msTimeOut: i64,
lrfds: *mut SYSSOCKET,
lrnum: *mut ::std::os::raw::c_int,
lwfds: *mut SYSSOCKET,
lwnum: *mut ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SRT_EPOLL_EVENT_STR {
pub fd: SRTSOCKET,
pub events: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_SRT_EPOLL_EVENT_STR() {
assert_eq!(
::std::mem::size_of::<SRT_EPOLL_EVENT_STR>(),
8usize,
concat!("Size of: ", stringify!(SRT_EPOLL_EVENT_STR))
);
assert_eq!(
::std::mem::align_of::<SRT_EPOLL_EVENT_STR>(),
4usize,
concat!("Alignment of ", stringify!(SRT_EPOLL_EVENT_STR))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<SRT_EPOLL_EVENT_STR>())).fd as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(SRT_EPOLL_EVENT_STR),
"::",
stringify!(fd)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<SRT_EPOLL_EVENT_STR>())).events as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(SRT_EPOLL_EVENT_STR),
"::",
stringify!(events)
)
);
}
pub type SRT_EPOLL_EVENT = SRT_EPOLL_EVENT_STR;
extern "C" {
pub fn srt_epoll_uwait(
eid: ::std::os::raw::c_int,
fdsSet: *mut SRT_EPOLL_EVENT,
fdsSize: ::std::os::raw::c_int,
msTimeOut: i64,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn srt_epoll_set(eid: ::std::os::raw::c_int, flags: i32) -> i32;
}
extern "C" {
pub fn srt_epoll_release(eid: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn srt_setloglevel(ll: ::std::os::raw::c_int);
}
extern "C" {
pub fn srt_addlogfa(fa: ::std::os::raw::c_int);
}
extern "C" {
pub fn srt_dellogfa(fa: ::std::os::raw::c_int);
}
extern "C" {
pub fn srt_resetlogfa(fara: *const ::std::os::raw::c_int, fara_size: usize);
}
extern "C" {
pub fn srt_setloghandler(opaque: *mut ::std::os::raw::c_void, handler: SRT_LOG_HANDLER_FN);
}
extern "C" {
pub fn srt_setlogflags(flags: ::std::os::raw::c_int);
}
extern "C" {
pub fn srt_getsndbuffer(
sock: SRTSOCKET,
blocks: *mut usize,
bytes: *mut usize,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn srt_getrejectreason(sock: SRTSOCKET) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn srt_setrejectreason(
sock: SRTSOCKET,
value: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn srt_rejectreason_str(id: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn srt_getversion() -> u32;
}
extern "C" {
pub fn srt_time_now() -> i64;
}
extern "C" {
pub fn srt_connection_time(sock: SRTSOCKET) -> i64;
}