dvb_si/descriptors/
content.rs

1//! Content Descriptor — ETSI EN 300 468 §6.2.9 (tag 0x54).
2//!
3//! Carried inside EIT. Classifies the event's genre via a two-nibble
4//! content type plus an 8-bit broadcaster-specific user byte.
5
6use super::descriptor_body;
7use crate::error::{Error, Result};
8use dvb_common::{Parse, Serialize};
9
10/// Descriptor tag for content_descriptor.
11pub const TAG: u8 = 0x54;
12const HEADER_LEN: usize = 2;
13const ENTRY_LEN: usize = 2;
14
15/// One content classification entry.
16#[derive(Debug, Clone, Copy, PartialEq, Eq)]
17#[cfg_attr(feature = "serde", derive(serde::Serialize))]
18pub struct ContentEntry {
19    /// content_nibble_level_1 (4 bits) — broad genre (ETSI Table 29).
20    pub nibble_1: u8,
21    /// content_nibble_level_2 (4 bits) — sub-genre.
22    pub nibble_2: u8,
23    /// Broadcaster-specific user byte.
24    pub user_byte: u8,
25}
26
27/// Content Descriptor.
28#[derive(Debug, Clone, PartialEq, Eq)]
29#[cfg_attr(feature = "serde", derive(serde::Serialize))]
30pub struct ContentDescriptor {
31    /// Entries in wire order. EIT events can carry multiple genre entries.
32    pub entries: Vec<ContentEntry>,
33}
34
35impl<'a> Parse<'a> for ContentDescriptor {
36    type Error = crate::error::Error;
37    fn parse(bytes: &'a [u8]) -> Result<Self> {
38        let body = descriptor_body(
39            bytes,
40            TAG,
41            "ContentDescriptor",
42            "unexpected tag for ContentDescriptor",
43        )?;
44
45        if body.len() % 2 != 0 {
46            return Err(Error::InvalidDescriptor {
47                tag: TAG,
48                reason: "descriptor_length must be a multiple of 2",
49            });
50        }
51
52        let mut entries = Vec::with_capacity(body.len() / ENTRY_LEN);
53
54        for chunk in body.chunks_exact(ENTRY_LEN) {
55            entries.push(ContentEntry {
56                nibble_1: chunk[0] >> 4,
57                nibble_2: chunk[0] & 0x0F,
58                user_byte: chunk[1],
59            });
60        }
61
62        Ok(Self { entries })
63    }
64}
65
66impl Serialize for ContentDescriptor {
67    type Error = crate::error::Error;
68    fn serialized_len(&self) -> usize {
69        HEADER_LEN + self.entries.len() * ENTRY_LEN
70    }
71
72    fn serialize_into(&self, buf: &mut [u8]) -> Result<usize> {
73        let len = self.serialized_len();
74        if buf.len() < len {
75            return Err(Error::OutputBufferTooSmall {
76                need: len,
77                have: buf.len(),
78            });
79        }
80        buf[0] = TAG;
81        buf[1] = (len - HEADER_LEN) as u8;
82        let mut pos = HEADER_LEN;
83        for entry in &self.entries {
84            buf[pos] = (entry.nibble_1 << 4) | entry.nibble_2;
85            buf[pos + 1] = entry.user_byte;
86            pos += ENTRY_LEN;
87        }
88        Ok(len)
89    }
90}
91impl<'a> crate::traits::DescriptorDef<'a> for ContentDescriptor {
92    const TAG: u8 = TAG;
93    const NAME: &'static str = "CONTENT";
94}
95
96#[cfg(test)]
97mod tests {
98    use super::*;
99
100    #[test]
101    fn parse_single_entry_extracts_nibbles_and_user_byte() {
102        let result = ContentDescriptor::parse(&[TAG, 2, 0x31, 0xFF]).unwrap();
103        assert_eq!(result.entries.len(), 1);
104        let e = result.entries[0];
105        assert_eq!(e.nibble_1, 3);
106        assert_eq!(e.nibble_2, 1);
107        assert_eq!(e.user_byte, 0xFF);
108    }
109
110    #[test]
111    fn parse_multiple_entries_preserves_order() {
112        let bytes = [TAG, 6, 0x31, 0xAA, 0x42, 0xBB, 0x53, 0xCC];
113        let result = ContentDescriptor::parse(&bytes).unwrap();
114        assert_eq!(result.entries.len(), 3);
115        assert_eq!(result.entries[0].nibble_1, 3);
116        assert_eq!(result.entries[0].nibble_2, 1);
117        assert_eq!(result.entries[0].user_byte, 0xAA);
118        assert_eq!(result.entries[1].nibble_1, 4);
119        assert_eq!(result.entries[1].nibble_2, 2);
120        assert_eq!(result.entries[1].user_byte, 0xBB);
121        assert_eq!(result.entries[2].nibble_1, 5);
122        assert_eq!(result.entries[2].nibble_2, 3);
123        assert_eq!(result.entries[2].user_byte, 0xCC);
124    }
125
126    #[test]
127    fn parse_rejects_wrong_tag() {
128        assert!(matches!(
129            ContentDescriptor::parse(&[0x55, 2, 0x00, 0x00]).unwrap_err(),
130            Error::InvalidDescriptor { tag: 0x55, .. }
131        ));
132    }
133
134    #[test]
135    fn parse_rejects_short_header() {
136        assert!(matches!(
137            ContentDescriptor::parse(&[TAG]).unwrap_err(),
138            Error::BufferTooShort { .. }
139        ));
140    }
141
142    #[test]
143    fn parse_rejects_body_truncation() {
144        // length=4 means body is 4 bytes, but only 1 byte follows header
145        assert!(matches!(
146            ContentDescriptor::parse(&[TAG, 4, 0x01]).unwrap_err(),
147            Error::BufferTooShort { .. }
148        ));
149    }
150
151    #[test]
152    fn parse_rejects_length_not_multiple_of_2() {
153        // length=3 is odd, can't form complete entries
154        assert!(matches!(
155            ContentDescriptor::parse(&[TAG, 3, 0x01, 0x02, 0x03]).unwrap_err(),
156            Error::InvalidDescriptor { .. }
157        ));
158    }
159
160    #[test]
161    fn serialize_round_trip() {
162        let original = ContentDescriptor {
163            entries: vec![
164                ContentEntry {
165                    nibble_1: 3,
166                    nibble_2: 1,
167                    user_byte: 0xAA,
168                },
169                ContentEntry {
170                    nibble_1: 4,
171                    nibble_2: 2,
172                    user_byte: 0xBB,
173                },
174            ],
175        };
176        let mut buf = vec![0u8; original.serialized_len()];
177        original.serialize_into(&mut buf).unwrap();
178        let parsed = ContentDescriptor::parse(&buf).unwrap();
179        assert_eq!(parsed, original);
180    }
181
182    #[test]
183    fn empty_descriptor_valid() {
184        let bytes = [TAG, 0];
185        let result = ContentDescriptor::parse(&bytes).unwrap();
186        assert!(result.entries.is_empty());
187    }
188}
dvb_si/descriptors/content.rs

dvb_si/descriptors/
content.rs
