dvb_si/descriptors/
multilingual_bouquet_name.rs

1//! Multilingual Bouquet Name Descriptor — ETSI EN 300 468 §6.2.22 (tag 0x5C).
2//!
3//! Table 76 (PDF p. 93). Carried in the BAT. A loop of (ISO 639-2 language
4//! code, bouquet name) pairs, each name length-prefixed by an 8-bit field.
5
6use crate::error::{Error, Result};
7use crate::text::{DvbText, LangCode};
8use crate::traits::Descriptor;
9use dvb_common::{Parse, Serialize};
10
11/// Descriptor tag for multilingual_bouquet_name_descriptor.
12pub const TAG: u8 = 0x5C;
13const HEADER_LEN: usize = 2;
14const LANG_LEN: usize = 3;
15const NAME_LEN_FIELD: usize = 1;
16
17/// One localised bouquet name.
18#[derive(Debug, Clone, PartialEq, Eq)]
19#[cfg_attr(feature = "serde", derive(serde::Serialize))]
20#[cfg_attr(feature = "yoke", derive(yoke::Yokeable))]
21pub struct BouquetNameEntry<'a> {
22    /// ISO 639-2 language code.
23    pub language_code: LangCode,
24    /// DVB Annex-A encoded bouquet name.
25    pub bouquet_name: DvbText<'a>,
26}
27
28/// Multilingual Bouquet Name Descriptor (tag 0x5C).
29#[derive(Debug, Clone, PartialEq, Eq)]
30#[cfg_attr(feature = "serde", derive(serde::Serialize))]
31#[cfg_attr(feature = "yoke", derive(yoke::Yokeable))]
32pub struct MultilingualBouquetNameDescriptor<'a> {
33    /// Localised names in wire order.
34    pub entries: Vec<BouquetNameEntry<'a>>,
35}
36
37impl<'a> Parse<'a> for MultilingualBouquetNameDescriptor<'a> {
38    type Error = crate::error::Error;
39    fn parse(bytes: &'a [u8]) -> Result<Self> {
40        if bytes.len() < HEADER_LEN {
41            return Err(Error::BufferTooShort {
42                need: HEADER_LEN,
43                have: bytes.len(),
44                what: "MultilingualBouquetNameDescriptor header",
45            });
46        }
47        if bytes[0] != TAG {
48            return Err(Error::InvalidDescriptor {
49                tag: bytes[0],
50                reason: "unexpected tag for multilingual_bouquet_name_descriptor",
51            });
52        }
53        let length = bytes[1] as usize;
54        let end = HEADER_LEN + length;
55        if bytes.len() < end {
56            return Err(Error::BufferTooShort {
57                need: end,
58                have: bytes.len(),
59                what: "MultilingualBouquetNameDescriptor body",
60            });
61        }
62        let mut entries = Vec::new();
63        let mut pos = HEADER_LEN;
64        while pos < end {
65            if pos + LANG_LEN + NAME_LEN_FIELD > end {
66                return Err(Error::InvalidDescriptor {
67                    tag: TAG,
68                    reason: "entry header runs past descriptor end",
69                });
70            }
71            let language_code = LangCode([bytes[pos], bytes[pos + 1], bytes[pos + 2]]);
72            let name_len = bytes[pos + LANG_LEN] as usize;
73            let name_start = pos + LANG_LEN + NAME_LEN_FIELD;
74            let name_end = name_start + name_len;
75            if name_end > end {
76                return Err(Error::InvalidDescriptor {
77                    tag: TAG,
78                    reason: "name_length runs past descriptor end",
79                });
80            }
81            entries.push(BouquetNameEntry {
82                language_code,
83                bouquet_name: DvbText::new(&bytes[name_start..name_end]),
84            });
85            pos = name_end;
86        }
87        Ok(Self { entries })
88    }
89}
90
91impl Serialize for MultilingualBouquetNameDescriptor<'_> {
92    type Error = crate::error::Error;
93    fn serialized_len(&self) -> usize {
94        HEADER_LEN
95            + self
96                .entries
97                .iter()
98                .map(|e| LANG_LEN + NAME_LEN_FIELD + e.bouquet_name.len())
99                .sum::<usize>()
100    }
101
102    fn serialize_into(&self, buf: &mut [u8]) -> Result<usize> {
103        for e in &self.entries {
104            if e.bouquet_name.len() > u8::MAX as usize {
105                return Err(Error::InvalidDescriptor {
106                    tag: TAG,
107                    reason: "bouquet_name exceeds 255 bytes (name_length is 8-bit)",
108                });
109            }
110        }
111        let len = self.serialized_len();
112        let body = len - HEADER_LEN;
113        if body > u8::MAX as usize {
114            return Err(Error::InvalidDescriptor {
115                tag: TAG,
116                reason: "multilingual_bouquet_name_descriptor body exceeds 255 bytes",
117            });
118        }
119        if buf.len() < len {
120            return Err(Error::OutputBufferTooSmall {
121                need: len,
122                have: buf.len(),
123            });
124        }
125        buf[0] = TAG;
126        buf[1] = body as u8;
127        let mut pos = HEADER_LEN;
128        for e in &self.entries {
129            buf[pos..pos + LANG_LEN].copy_from_slice(&e.language_code.0);
130            buf[pos + LANG_LEN] = e.bouquet_name.len() as u8;
131            let name_start = pos + LANG_LEN + NAME_LEN_FIELD;
132            buf[name_start..name_start + e.bouquet_name.len()]
133                .copy_from_slice(e.bouquet_name.raw());
134            pos = name_start + e.bouquet_name.len();
135        }
136        Ok(len)
137    }
138}
139
140impl<'a> Descriptor<'a> for MultilingualBouquetNameDescriptor<'a> {
141    const TAG: u8 = TAG;
142    fn descriptor_length(&self) -> u8 {
143        (self.serialized_len() - HEADER_LEN) as u8
144    }
145}
146
147impl<'a> crate::traits::DescriptorDef<'a> for MultilingualBouquetNameDescriptor<'a> {
148    const TAG: u8 = TAG;
149    const NAME: &'static str = "MULTILINGUAL_BOUQUET_NAME";
150}
151
152#[cfg(test)]
153mod tests {
154    use super::*;
155
156    fn build(entries: &[([u8; 3], &[u8])]) -> Vec<u8> {
157        let body: usize = entries.iter().map(|(_, n)| LANG_LEN + 1 + n.len()).sum();
158        let mut v = Vec::with_capacity(HEADER_LEN + body);
159        v.push(TAG);
160        v.push(body as u8);
161        for (lang, name) in entries {
162            v.extend_from_slice(lang);
163            v.push(name.len() as u8);
164            v.extend_from_slice(name);
165        }
166        v
167    }
168
169    #[test]
170    fn parse_single_entry() {
171        let bytes = build(&[(*b"eng", b"Sky")]);
172        let d = MultilingualBouquetNameDescriptor::parse(&bytes).unwrap();
173        assert_eq!(d.entries.len(), 1);
174        assert_eq!(d.entries[0].language_code, LangCode(*b"eng"));
175        assert_eq!(d.entries[0].bouquet_name.raw(), b"Sky");
176    }
177
178    #[test]
179    fn parse_multiple_entries() {
180        let bytes = build(&[(*b"eng", b"Pack"), (*b"fra", b"Bouquet")]);
181        let d = MultilingualBouquetNameDescriptor::parse(&bytes).unwrap();
182        assert_eq!(d.entries.len(), 2);
183        assert_eq!(d.entries[1].bouquet_name.raw(), b"Bouquet");
184    }
185
186    #[test]
187    fn parse_rejects_wrong_tag() {
188        let err = MultilingualBouquetNameDescriptor::parse(&[0x5B, 0]).unwrap_err();
189        assert!(matches!(err, Error::InvalidDescriptor { tag: 0x5B, .. }));
190    }
191
192    #[test]
193    fn parse_rejects_short_buffer() {
194        let err = MultilingualBouquetNameDescriptor::parse(&[TAG]).unwrap_err();
195        assert!(matches!(err, Error::BufferTooShort { .. }));
196    }
197
198    #[test]
199    fn parse_rejects_name_length_overrun() {
200        let bytes = [TAG, 5, b'e', b'n', b'g', 100, 0];
201        let err = MultilingualBouquetNameDescriptor::parse(&bytes).unwrap_err();
202        assert!(matches!(err, Error::InvalidDescriptor { .. }));
203    }
204
205    #[test]
206    fn parse_rejects_truncated_entry_header() {
207        let bytes = [TAG, 2, b'e', b'n'];
208        let err = MultilingualBouquetNameDescriptor::parse(&bytes).unwrap_err();
209        assert!(matches!(err, Error::InvalidDescriptor { .. }));
210    }
211
212    #[test]
213    fn empty_descriptor_valid() {
214        let d = MultilingualBouquetNameDescriptor::parse(&[TAG, 0]).unwrap();
215        assert_eq!(d.entries.len(), 0);
216    }
217
218    #[test]
219    fn serialize_round_trip() {
220        let bytes = build(&[(*b"eng", b"Bouquet"), (*b"deu", b"Paket")]);
221        let parsed = MultilingualBouquetNameDescriptor::parse(&bytes).unwrap();
222        let mut buf = vec![0u8; parsed.serialized_len()];
223        parsed.serialize_into(&mut buf).unwrap();
224        assert_eq!(buf, bytes);
225        let re = MultilingualBouquetNameDescriptor::parse(&buf).unwrap();
226        assert_eq!(parsed, re);
227    }
228
229    #[test]
230    fn serialize_rejects_too_small_buffer() {
231        let d = MultilingualBouquetNameDescriptor {
232            entries: vec![BouquetNameEntry {
233                language_code: LangCode(*b"eng"),
234                bouquet_name: DvbText::new(b"X"),
235            }],
236        };
237        let mut tiny = [0u8; 3];
238        let err = d.serialize_into(&mut tiny).unwrap_err();
239        assert!(matches!(err, Error::OutputBufferTooSmall { .. }));
240    }
241
242    #[test]
243    fn serialize_rejects_over_range_name() {
244        let name = vec![0u8; 256];
245        let d = MultilingualBouquetNameDescriptor {
246            entries: vec![BouquetNameEntry {
247                language_code: LangCode(*b"eng"),
248                bouquet_name: DvbText::new(&name),
249            }],
250        };
251        let mut buf = vec![0u8; d.serialized_len()];
252        let err = d.serialize_into(&mut buf).unwrap_err();
253        assert!(matches!(err, Error::InvalidDescriptor { tag: TAG, .. }));
254    }
255
256    #[cfg(feature = "serde")]
257    #[test]
258    fn serde_serialize_is_stable() {
259        // Borrowed `&[u8]` cannot be deserialized from a JSON array by
260        // serde_json; matching the borrowed-bytes descriptors in this crate we
261        // exercise the serialize path and assert it is deterministic.
262        let d = MultilingualBouquetNameDescriptor {
263            entries: vec![BouquetNameEntry {
264                language_code: LangCode(*b"eng"),
265                bouquet_name: DvbText::new(b"Sky"),
266            }],
267        };
268        let json = serde_json::to_string(&d).unwrap();
269        assert_eq!(json, serde_json::to_string(&d.clone()).unwrap());
270    }
271}
dvb_si/descriptors/multilingual_bouquet_name.rs

dvb_si/descriptors/
multilingual_bouquet_name.rs
