dvb_t2mi/payload/
l1_current.rs

1//! T2-MI payload type 0x10: L1-current signalling — §5.2.4.
2//!
3//! L1-current carries the complete L1 signalling for the current T2 frame:
4//! L1PRE + L1CONF + L1DYN_CURR + optionally L1EXT.
5
6use num_enum::TryFromPrimitive;
7
8use dvb_common::{Parse, Serialize};
9
10/// Frequency source per §5.2.4 Table 2.
11#[derive(Debug, Clone, Copy, PartialEq, Eq, TryFromPrimitive)]
12#[cfg_attr(feature = "serde", derive(serde::Serialize))]
13#[repr(u8)]
14pub enum FrequencySource {
15    /// Use L1-current data field.
16    UseL1CurrentData = 0b00,
17    /// Use individual addressing frequency function.
18    UseIndividualAddressing = 0b01,
19    /// Manually set per modulator.
20    ManualPerModulator = 0b10,
21}
22
23impl From<FrequencySource> for u8 {
24    fn from(fs: FrequencySource) -> Self {
25        fs as u8
26    }
27}
28
29impl From<num_enum::TryFromPrimitiveError<FrequencySource>> for crate::error::Error {
30    fn from(_: num_enum::TryFromPrimitiveError<FrequencySource>) -> Self {
31        crate::error::Error::ReservedBitsViolation {
32            field: "freq_source",
33            reason: "Must be 0b00, 0b01, or 0b10 (ETSI TS 102 773 §5.2.4)",
34        }
35    }
36}
37
38/// L1-current payload (type 0x10) per ETSI TS 102 773 §5.2.4.
39///
40/// Layout:
41/// - byte 0: frame_idx (8 bits) — T2 frame where L1 is carried
42/// - byte 1 `[7:6]`: freq_source (2 bits) — Table 2
43/// - byte 1 `[5:0]`: rfu (6 bits) — must be 0
44/// - bytes 2..: l1_current_data (variable bytes)
45#[derive(Debug, Clone, PartialEq, Eq)]
46#[cfg_attr(feature = "serde", derive(serde::Serialize))]
47pub struct L1CurrentPayload<'a> {
48    /// FRAME_IDX of T2 frame where L1 is carried.
49    pub frame_idx: u8,
50    /// Frequency source per §5.2.4 Table 2.
51    pub freq_source: FrequencySource,
52    /// L1-current data: L1PRE + L1CONF + L1DYN_CURR + L1EXT (all per EN 302 755).
53    pub l1_current_data: &'a [u8],
54}
55
56const L1_CURRENT_HEADER_LEN: usize = 2;
57
58impl<'a> Parse<'a> for L1CurrentPayload<'a> {
59    type Error = crate::error::Error;
60
61    fn parse(bytes: &'a [u8]) -> Result<Self, crate::error::Error> {
62        if bytes.len() < L1_CURRENT_HEADER_LEN {
63            return Err(crate::Error::BufferTooShort {
64                need: L1_CURRENT_HEADER_LEN,
65                have: bytes.len(),
66                what: "L1CurrentPayload header",
67            });
68        }
69
70        let frame_idx = bytes[0];
71        let freq_source = FrequencySource::try_from(bytes[1] >> 6)?;
72
73        // RFU: byte 1 bottom 6 bits — must be 0
74        let rfu = bytes[1] & 0x3F;
75        if rfu != 0 {
76            return Err(crate::Error::ReservedBitsViolation {
77                field: "6-bit RFU after freq_source",
78                reason: "Must be zero (ETSI TS 102 773 §5.2.4)",
79            });
80        }
81
82        Ok(L1CurrentPayload {
83            frame_idx,
84            freq_source,
85            l1_current_data: &bytes[L1_CURRENT_HEADER_LEN..],
86        })
87    }
88}
89
90impl<'a> crate::traits::PayloadDef<'a> for L1CurrentPayload<'a> {
91    const PACKET_TYPE: u8 = 0x10;
92    const NAME: &'static str = "L1_CURRENT";
93}
94
95impl Serialize for L1CurrentPayload<'_> {
96    type Error = crate::error::Error;
97
98    fn serialized_len(&self) -> usize {
99        L1_CURRENT_HEADER_LEN + self.l1_current_data.len()
100    }
101
102    fn serialize_into(&self, buf: &mut [u8]) -> Result<usize, crate::error::Error> {
103        if buf.len() < self.serialized_len() {
104            return Err(crate::Error::OutputBufferTooSmall {
105                need: self.serialized_len(),
106                have: buf.len(),
107            });
108        }
109
110        buf[0] = self.frame_idx;
111        buf[1] = (u8::from(self.freq_source) << 6) & 0xC0; // freq_source in top 2 bits, RFU = 0
112
113        if !self.l1_current_data.is_empty() {
114            buf[L1_CURRENT_HEADER_LEN..L1_CURRENT_HEADER_LEN + self.l1_current_data.len()]
115                .copy_from_slice(self.l1_current_data);
116        }
117
118        Ok(self.serialized_len())
119    }
120}
121
122#[cfg(test)]
123mod tests {
124    use super::*;
125
126    #[test]
127    fn frequency_source_try_from_valid() {
128        assert_eq!(
129            FrequencySource::try_from(0b00),
130            Ok(FrequencySource::UseL1CurrentData)
131        );
132        assert_eq!(
133            FrequencySource::try_from(0b01),
134            Ok(FrequencySource::UseIndividualAddressing)
135        );
136        assert_eq!(
137            FrequencySource::try_from(0b10),
138            Ok(FrequencySource::ManualPerModulator)
139        );
140    }
141
142    #[test]
143    fn frequency_source_try_from_rejects_11() {
144        assert!(FrequencySource::try_from(0b11).is_err());
145    }
146
147    #[test]
148    fn exhaustive_byte_sweep() {
149        let mut matched = 0u16;
150        for byte in 0u8..=0xFF {
151            if let Ok(v) = FrequencySource::try_from(byte) {
152                assert_eq!(v as u8, byte, "round-trip failed for {byte:#04x}");
153                matched += 1;
154            }
155        }
156        assert_eq!(matched, 3, "expected 3 matched variants");
157    }
158
159    #[test]
160    fn parse_extracts_frame_idx_and_freq_source() {
161        let buf = [0x42u8, 0x80, 0xDE, 0xAD]; // frame=0x42, freq_src=0b10 (Manual), rfu=0
162        let result = L1CurrentPayload::parse(&buf).unwrap();
163        assert_eq!(result.frame_idx, 0x42);
164        assert_eq!(result.freq_source, FrequencySource::ManualPerModulator);
165        assert_eq!(result.l1_current_data, &[0xDE, 0xAD]);
166    }
167
168    #[test]
169    fn parse_rejects_nonzero_rfu() {
170        let buf = [0x00u8, 0x01, 0x00]; // freq_source=00, bottom 6 RFU bits nonzero
171        assert!(L1CurrentPayload::parse(&buf).is_err());
172    }
173
174    #[test]
175    fn serialize_round_trip() {
176        let orig = L1CurrentPayload {
177            frame_idx: 0xAB,
178            freq_source: FrequencySource::UseL1CurrentData,
179            l1_current_data: &[0x12, 0x34, 0x56],
180        };
181        let mut buf = vec![0u8; orig.serialized_len()];
182        orig.serialize_into(&mut buf).unwrap();
183        let parsed = L1CurrentPayload::parse(&buf).unwrap();
184        assert_eq!(orig, parsed);
185    }
186
187    #[test]
188    fn serialize_zeros_rfu_bits() {
189        let payload = L1CurrentPayload {
190            frame_idx: 0x10,
191            freq_source: FrequencySource::UseIndividualAddressing,
192            l1_current_data: &[],
193        };
194        let mut buf = [0xFFu8; 2];
195        payload.serialize_into(&mut buf).unwrap();
196        assert_eq!(buf[1] & 0x3F, 0x00);
197    }
198}
dvb_t2mi/payload/l1_current.rs

dvb_t2mi/payload/
l1_current.rs
