dvb_si/descriptors/
time_shifted_service.rs

1//! Time Shifted Service Descriptor — ETSI EN 300 468 §6.2.45 (tag 0x4C).
2//!
3//! Table 104 (PDF p. 109). Carried in the SDT for an NVOD time-shifted
4//! service; points at the reference service whose schedule it shifts. Body is
5//! a single 16-bit `reference_service_id`.
6
7use crate::error::{Error, Result};
8use crate::traits::Descriptor;
9use dvb_common::{Parse, Serialize};
10
11/// Descriptor tag for time_shifted_service_descriptor.
12pub const TAG: u8 = 0x4C;
13const HEADER_LEN: usize = 2;
14const BODY_LEN: usize = 2;
15
16/// Time Shifted Service Descriptor.
17#[derive(Debug, Clone, Copy, PartialEq, Eq)]
18#[cfg_attr(feature = "serde", derive(serde::Serialize))]
19pub struct TimeShiftedServiceDescriptor {
20    /// service_id of the reference (NVOD reference) service.
21    pub reference_service_id: u16,
22}
23
24impl<'a> Parse<'a> for TimeShiftedServiceDescriptor {
25    type Error = crate::error::Error;
26    fn parse(bytes: &'a [u8]) -> Result<Self> {
27        if bytes.len() < HEADER_LEN {
28            return Err(Error::BufferTooShort {
29                need: HEADER_LEN,
30                have: bytes.len(),
31                what: "TimeShiftedServiceDescriptor header",
32            });
33        }
34        if bytes[0] != TAG {
35            return Err(Error::InvalidDescriptor {
36                tag: bytes[0],
37                reason: "unexpected tag for time_shifted_service_descriptor",
38            });
39        }
40        let length = bytes[1] as usize;
41        if length != BODY_LEN {
42            return Err(Error::InvalidDescriptor {
43                tag: TAG,
44                reason: "time_shifted_service_descriptor length must be 2",
45            });
46        }
47        let end = HEADER_LEN + BODY_LEN;
48        if bytes.len() < end {
49            return Err(Error::BufferTooShort {
50                need: end,
51                have: bytes.len(),
52                what: "TimeShiftedServiceDescriptor body",
53            });
54        }
55        Ok(Self {
56            reference_service_id: u16::from_be_bytes([bytes[2], bytes[3]]),
57        })
58    }
59}
60
61impl Serialize for TimeShiftedServiceDescriptor {
62    type Error = crate::error::Error;
63    fn serialized_len(&self) -> usize {
64        HEADER_LEN + BODY_LEN
65    }
66
67    fn serialize_into(&self, buf: &mut [u8]) -> Result<usize> {
68        let len = self.serialized_len();
69        if buf.len() < len {
70            return Err(Error::OutputBufferTooSmall {
71                need: len,
72                have: buf.len(),
73            });
74        }
75        buf[0] = TAG;
76        buf[1] = BODY_LEN as u8;
77        buf[2..4].copy_from_slice(&self.reference_service_id.to_be_bytes());
78        Ok(len)
79    }
80}
81
82impl<'a> Descriptor<'a> for TimeShiftedServiceDescriptor {
83    const TAG: u8 = TAG;
84    fn descriptor_length(&self) -> u8 {
85        BODY_LEN as u8
86    }
87}
88
89impl<'a> crate::traits::DescriptorDef<'a> for TimeShiftedServiceDescriptor {
90    const TAG: u8 = TAG;
91    const NAME: &'static str = "TIME_SHIFTED_SERVICE";
92}
93
94#[cfg(test)]
95mod tests {
96    use super::*;
97
98    #[test]
99    fn parse_reference_service_id() {
100        let bytes = [TAG, 2, 0x12, 0x34];
101        let d = TimeShiftedServiceDescriptor::parse(&bytes).unwrap();
102        assert_eq!(d.reference_service_id, 0x1234);
103    }
104
105    #[test]
106    fn parse_rejects_wrong_tag() {
107        assert!(matches!(
108            TimeShiftedServiceDescriptor::parse(&[0x4D, 2, 0x12, 0x34]).unwrap_err(),
109            Error::InvalidDescriptor { tag: 0x4D, .. }
110        ));
111    }
112
113    #[test]
114    fn parse_rejects_short_buffer() {
115        // declares length 2 but only 1 body byte present
116        let bytes = [TAG, 2, 0x12];
117        assert!(matches!(
118            TimeShiftedServiceDescriptor::parse(&bytes).unwrap_err(),
119            Error::BufferTooShort { .. }
120        ));
121    }
122
123    #[test]
124    fn parse_rejects_wrong_length() {
125        let bytes = [TAG, 3, 0x12, 0x34, 0x00];
126        assert!(matches!(
127            TimeShiftedServiceDescriptor::parse(&bytes).unwrap_err(),
128            Error::InvalidDescriptor { tag: TAG, .. }
129        ));
130    }
131
132    #[test]
133    fn serialize_round_trip() {
134        let d = TimeShiftedServiceDescriptor {
135            reference_service_id: 0xABCD,
136        };
137        let mut buf = vec![0u8; d.serialized_len()];
138        d.serialize_into(&mut buf).unwrap();
139        assert_eq!(TimeShiftedServiceDescriptor::parse(&buf).unwrap(), d);
140    }
141
142    #[test]
143    fn serialize_rejects_small_buffer() {
144        let d = TimeShiftedServiceDescriptor {
145            reference_service_id: 1,
146        };
147        let mut tiny = [0u8; 3];
148        assert!(matches!(
149            d.serialize_into(&mut tiny).unwrap_err(),
150            Error::OutputBufferTooSmall { .. }
151        ));
152    }
153
154    #[cfg(feature = "serde")]
155    #[test]
156    fn serde_round_trip() {
157        let d = TimeShiftedServiceDescriptor {
158            reference_service_id: 0x1234,
159        };
160        let json = serde_json::to_string(&d).unwrap();
161        // Serialize-only: assert the emitted JSON re-parses (serialize-stable).
162        let _v: serde_json::Value = serde_json::from_str(&json).unwrap();
163    }
164}
dvb_si/descriptors/time_shifted_service.rs

dvb_si/descriptors/
time_shifted_service.rs
