libdvb 0.4.0

Interface for DVB-API v5 devices in Linux
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159

//! ABI layout checks for the hand-ported kernel structs.
//!
//! Expected sizes and offsets are taken from the C struct definitions in the
//! Linux UAPI headers: `linux/dvb/frontend.h`, `dmx.h`, `net.h`, `ca.h`.
//! Pointer-sized fields are computed from the target pointer width, so the
//! checks hold on both 64-bit and 32-bit targets.

use {
    std::{
        ffi::c_void,
        mem::offset_of,
    },

    libdvb::{
        ca::sys::{
            CaCaps,
            CaDescr,
            CaDescrInfo,
            CaMsg,
            CaPid,
            CaSlotInfo,
        },
        dmx::sys::DmxPesFilterParams,
        fe::sys::{
            DiseqcMasterCmd,
            DiseqcSlaveReply,
            DtvFrontendStats,
            DtvPropertyBuffer,
            DtvPropertyData,
            DtvPropertyRaw,
            DtvStats,
            FeEvent,
            FeInfo,
            FeParameters,
        },
        net::sys::DvbNetIf,
    },
};


const PTR_SIZE: usize = size_of::<*mut c_void>();

/// struct dtv_property buffer member: __u8 data[32] + __u32 len + __u32 reserved1[3] + void *reserved2
const DTV_PROPERTY_BUFFER_SIZE: usize = 32 + 4 + 12 + PTR_SIZE;

/// union with `data: u32`, `st` (37 bytes packed) and `buffer`; buffer dominates
const DTV_PROPERTY_DATA_SIZE: usize = DTV_PROPERTY_BUFFER_SIZE;

/// struct dtv_property is packed: __u32 cmd + __u32 reserved[3] + union + int result
const DTV_PROPERTY_SIZE: usize = 4 + 12 + DTV_PROPERTY_DATA_SIZE + 4;


#[test]
fn fe_info() {
    // struct dvb_frontend_info
    assert_eq!(size_of::<FeInfo>(), 168);
    assert_eq!(offset_of!(FeInfo, fe_type), 128);
    assert_eq!(offset_of!(FeInfo, frequency_min), 132);
    assert_eq!(offset_of!(FeInfo, symbol_rate_min), 148);
    assert_eq!(offset_of!(FeInfo, caps), 164);
}


#[test]
fn fe_diseqc() {
    // struct dvb_diseqc_master_cmd
    assert_eq!(size_of::<DiseqcMasterCmd>(), 7);
    assert_eq!(offset_of!(DiseqcMasterCmd, len), 6);

    // struct dvb_diseqc_slave_reply
    assert_eq!(size_of::<DiseqcSlaveReply>(), 12);
    assert_eq!(offset_of!(DiseqcSlaveReply, len), 4);
    assert_eq!(offset_of!(DiseqcSlaveReply, timeout), 8);
}


#[test]
fn fe_stats() {
    // struct dtv_stats (packed)
    assert_eq!(size_of::<DtvStats>(), 9);
    assert_eq!(align_of::<DtvStats>(), 1);
    assert_eq!(offset_of!(DtvStats, value), 1);

    // struct dtv_fe_stats (packed)
    assert_eq!(size_of::<DtvFrontendStats>(), 37);
    assert_eq!(align_of::<DtvFrontendStats>(), 1);
    assert_eq!(offset_of!(DtvFrontendStats, stat), 1);
}


#[test]
fn fe_property() {
    assert_eq!(size_of::<DtvPropertyBuffer>(), DTV_PROPERTY_BUFFER_SIZE);
    assert_eq!(size_of::<DtvPropertyData>(), DTV_PROPERTY_DATA_SIZE);

    // struct dtv_property (packed)
    assert_eq!(size_of::<DtvPropertyRaw>(), DTV_PROPERTY_SIZE);
    assert_eq!(align_of::<DtvPropertyRaw>(), 1);
    assert_eq!(offset_of!(DtvPropertyRaw, cmd), 0);
    assert_eq!(offset_of!(DtvPropertyRaw, u), 16);
    assert_eq!(offset_of!(DtvPropertyRaw, result), 16 + DTV_PROPERTY_DATA_SIZE);
}


#[test]
fn fe_event() {
    // struct dvb_frontend_parameters: frequency + inversion + 28-byte parameters union
    assert_eq!(size_of::<FeParameters>(), 36);

    // struct dvb_frontend_event
    assert_eq!(size_of::<FeEvent>(), 40);
    assert_eq!(offset_of!(FeEvent, parameters), 4);
}


#[test]
fn dmx() {
    // struct dmx_pes_filter_params
    assert_eq!(size_of::<DmxPesFilterParams>(), 20);
    assert_eq!(offset_of!(DmxPesFilterParams, input), 4);
    assert_eq!(offset_of!(DmxPesFilterParams, flags), 16);
}


#[test]
fn net() {
    // struct dvb_net_if
    assert_eq!(size_of::<DvbNetIf>(), 6);
    assert_eq!(offset_of!(DvbNetIf, feedtype), 4);
}


#[test]
fn auto_traits() {
    // The reserved pointer field was changed to `usize` so these stay Send + Sync.
    fn assert_send_sync<T: Send + Sync>() {}
    assert_send_sync::<DtvPropertyRaw>();
    assert_send_sync::<libdvb::FeStatus>();
    assert_send_sync::<libdvb::FeDevice>();
}


#[test]
fn ca() {
    // struct ca_slot_info
    assert_eq!(size_of::<CaSlotInfo>(), 12);
    // struct ca_descr_info
    assert_eq!(size_of::<CaDescrInfo>(), 8);
    // struct ca_caps
    assert_eq!(size_of::<CaCaps>(), 16);
    // struct ca_msg
    assert_eq!(size_of::<CaMsg>(), 268);
    assert_eq!(offset_of!(CaMsg, msg), 12);
    // struct ca_descr
    assert_eq!(size_of::<CaDescr>(), 16);
    assert_eq!(offset_of!(CaDescr, cw), 8);
    // struct ca_pid
    assert_eq!(size_of::<CaPid>(), 8);
}