dvb_si/descriptors/
service_list.rs

1//! Service List Descriptor — ETSI EN 300 468 §6.2.36 (tag 0x41).
2//!
3//! Carried inside NIT/BAT transport_stream_loop second descriptor loop.
4//! Enumerates the service_id/service_type pairs available on the TS.
5
6use crate::error::{Error, Result};
7use crate::traits::Descriptor;
8use dvb_common::{Parse, Serialize};
9
10/// Descriptor tag for service_list_descriptor.
11pub const TAG: u8 = 0x41;
12const HEADER_LEN: usize = 2;
13const ENTRY_LEN: usize = 3;
14
15/// One (service_id, service_type) pair.
16#[derive(Debug, Clone, Copy, PartialEq, Eq)]
17#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
18pub struct ServiceListEntry {
19    /// DVB service_id (matches program_number in PAT).
20    pub service_id: u16,
21    /// service_type byte (ETSI Table 87).
22    pub service_type: u8,
23}
24
25/// Service List Descriptor.
26#[derive(Debug, Clone, PartialEq, Eq)]
27#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
28pub struct ServiceListDescriptor {
29    /// Entries in wire order.
30    pub entries: Vec<ServiceListEntry>,
31}
32
33impl<'a> Parse<'a> for ServiceListDescriptor {
34    type Error = crate::error::Error;
35    fn parse(bytes: &'a [u8]) -> Result<Self> {
36        if bytes.len() < HEADER_LEN {
37            return Err(Error::BufferTooShort {
38                need: HEADER_LEN,
39                have: bytes.len(),
40                what: "ServiceListDescriptor header",
41            });
42        }
43        if bytes[0] != TAG {
44            return Err(Error::InvalidDescriptor {
45                tag: bytes[0],
46                reason: "unexpected tag for service_list_descriptor",
47            });
48        }
49        let length = bytes[1] as usize;
50        if length % 3 != 0 {
51            return Err(Error::InvalidDescriptor {
52                tag: TAG,
53                reason: "descriptor_length must be a multiple of 3",
54            });
55        }
56        let body_start = HEADER_LEN;
57        let body_end = body_start + length;
58        if bytes.len() < body_end {
59            return Err(Error::BufferTooShort {
60                need: body_end,
61                have: bytes.len(),
62                what: "ServiceListDescriptor body",
63            });
64        }
65        let mut entries = Vec::with_capacity(length / ENTRY_LEN);
66        let mut offset = body_start;
67        while offset < body_end {
68            let service_id = u16::from_be_bytes([bytes[offset], bytes[offset + 1]]);
69            let service_type = bytes[offset + 2];
70            entries.push(ServiceListEntry {
71                service_id,
72                service_type,
73            });
74            offset += ENTRY_LEN;
75        }
76        Ok(Self { entries })
77    }
78}
79
80impl Serialize for ServiceListDescriptor {
81    type Error = crate::error::Error;
82    fn serialized_len(&self) -> usize {
83        HEADER_LEN + ENTRY_LEN * self.entries.len()
84    }
85
86    fn serialize_into(&self, buf: &mut [u8]) -> Result<usize> {
87        let len = self.serialized_len();
88        if buf.len() < len {
89            return Err(Error::OutputBufferTooSmall {
90                need: len,
91                have: buf.len(),
92            });
93        }
94        buf[0] = TAG;
95        buf[1] = (len - HEADER_LEN) as u8;
96        let mut offset = HEADER_LEN;
97        for entry in &self.entries {
98            buf[offset..offset + 2].copy_from_slice(&entry.service_id.to_be_bytes());
99            buf[offset + 2] = entry.service_type;
100            offset += ENTRY_LEN;
101        }
102        Ok(len)
103    }
104}
105
106impl<'a> Descriptor<'a> for ServiceListDescriptor {
107    const TAG: u8 = TAG;
108    fn descriptor_length(&self) -> u8 {
109        (self.serialized_len() - HEADER_LEN) as u8
110    }
111}
112
113impl<'a> crate::traits::DescriptorDef<'a> for ServiceListDescriptor {
114    const TAG: u8 = TAG;
115    const NAME: &'static str = "SERVICE_LIST";
116}
117
118#[cfg(test)]
119mod tests {
120    use super::*;
121
122    #[test]
123    fn parse_single_entry() {
124        let bytes = [TAG, 3, 0x00, 0x01, 0x01];
125        let d = ServiceListDescriptor::parse(&bytes).unwrap();
126        assert_eq!(d.entries.len(), 1);
127        assert_eq!(d.entries[0].service_id, 1);
128        assert_eq!(d.entries[0].service_type, 0x01);
129    }
130
131    #[test]
132    fn parse_multiple_entries_preserves_order() {
133        let bytes = [TAG, 9, 0x00, 0x01, 0x01, 0x00, 0x02, 0x02, 0x00, 0x03, 0x03];
134        let d = ServiceListDescriptor::parse(&bytes).unwrap();
135        assert_eq!(d.entries.len(), 3);
136        assert_eq!(d.entries[0].service_id, 1);
137        assert_eq!(d.entries[0].service_type, 0x01);
138        assert_eq!(d.entries[1].service_id, 2);
139        assert_eq!(d.entries[1].service_type, 0x02);
140        assert_eq!(d.entries[2].service_id, 3);
141        assert_eq!(d.entries[2].service_type, 0x03);
142    }
143
144    #[test]
145    fn parse_rejects_wrong_tag() {
146        let err = ServiceListDescriptor::parse(&[0x42, 3, 0x00, 0x01, 0x01]).unwrap_err();
147        assert!(matches!(err, Error::InvalidDescriptor { tag: 0x42, .. }));
148    }
149
150    #[test]
151    fn parse_rejects_length_not_multiple_of_3() {
152        let bytes = [TAG, 4, 0x00, 0x01, 0x01, 0xFF];
153        let err = ServiceListDescriptor::parse(&bytes).unwrap_err();
154        assert!(matches!(err, Error::InvalidDescriptor { tag: TAG, .. }));
155    }
156
157    #[test]
158    fn parse_rejects_truncated_body() {
159        let bytes = [TAG, 6, 0x00, 0x01];
160        let err = ServiceListDescriptor::parse(&bytes).unwrap_err();
161        assert!(matches!(err, Error::BufferTooShort { .. }));
162    }
163
164    #[test]
165    fn empty_descriptor_valid() {
166        let bytes = [TAG, 0];
167        let d = ServiceListDescriptor::parse(&bytes).unwrap();
168        assert!(d.entries.is_empty());
169    }
170
171    #[test]
172    fn serialize_round_trip() {
173        let d = ServiceListDescriptor {
174            entries: vec![
175                ServiceListEntry {
176                    service_id: 1,
177                    service_type: 0x01,
178                },
179                ServiceListEntry {
180                    service_id: 0x0102,
181                    service_type: 0x04,
182                },
183            ],
184        };
185        let mut buf = vec![0u8; d.serialized_len()];
186        d.serialize_into(&mut buf).unwrap();
187        let re = ServiceListDescriptor::parse(&buf).unwrap();
188        assert_eq!(d, re);
189    }
190}
dvb_si/descriptors/service_list.rs

dvb_si/descriptors/
service_list.rs
