gstreamer/
buffer_serde.rs

Help
1// Take a look at the license at the top of the repository in the LICENSE file.
2
3use serde::{
4    de::{Deserialize, Deserializer},
5    ser,
6    ser::{Serialize, SerializeStruct, Serializer},
7};
8use serde_bytes::{ByteBuf, Bytes};
9
10use crate::{Buffer, BufferFlags, BufferRef, ClockTime};
11
12// TODO: try `Either<ByteBuf, Bytes>` to merge the base representations for ser and de
13// while avoiding unneeded copy
14
15impl Serialize for BufferRef {
16    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
17        let mut buffer = serializer.serialize_struct("Buffer", 7)?;
18        buffer.serialize_field("pts", &self.pts())?;
19        buffer.serialize_field("dts", &self.dts())?;
20        buffer.serialize_field("duration", &self.duration())?;
21        buffer.serialize_field("offset", &self.offset())?;
22        buffer.serialize_field("offset_end", &self.offset_end())?;
23        buffer.serialize_field("flags", &self.flags())?;
24        {
25            let data = self
26                .map_readable()
27                .map_err(|_| ser::Error::custom("Couldn't map `buffer` as readable"))?;
28            buffer.serialize_field("buffer", &Bytes::new(data.as_slice()))?;
29        }
30        buffer.end()
31    }
32}
33
34impl Serialize for Buffer {
35    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
36        self.as_ref().serialize(serializer)
37    }
38}
39
40#[derive(serde::Deserialize)]
41struct BufferDe {
42    pts: Option<ClockTime>,
43    dts: Option<ClockTime>,
44    duration: Option<ClockTime>,
45    offset: u64,
46    offset_end: u64,
47    flags: BufferFlags,
48    buffer: ByteBuf,
49}
50
51impl From<BufferDe> for Buffer {
52    fn from(buf_de: BufferDe) -> Self {
53        skip_assert_initialized!();
54        let mut buffer = Buffer::from_mut_slice(buf_de.buffer.to_vec());
55        {
56            let buffer = buffer.get_mut().unwrap();
57            buffer.set_pts(buf_de.pts);
58            buffer.set_dts(buf_de.dts);
59            buffer.set_duration(buf_de.duration);
60            buffer.set_offset(buf_de.offset);
61            buffer.set_offset_end(buf_de.offset_end);
62            buffer.set_flags(buf_de.flags);
63        }
64        buffer
65    }
66}
67
68impl<'de> Deserialize<'de> for Buffer {
69    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
70        skip_assert_initialized!();
71        BufferDe::deserialize(deserializer).map(|buffer_de| buffer_de.into())
72    }
73}
74
75#[cfg(test)]
76mod tests {
77    use crate::{Buffer, BufferFlags, ClockTime};
78
79    #[test]
80    fn test_serialize() {
81        crate::init().unwrap();
82
83        let mut buffer = Buffer::from_slice(vec![1, 2, 3, 4]);
84        {
85            let buffer = buffer.get_mut().unwrap();
86            buffer.set_pts(Some(ClockTime::NSECOND));
87            buffer.set_offset(3);
88            buffer.set_offset_end(4);
89            buffer.set_duration(5 * ClockTime::NSECOND);
90            buffer.set_flags(BufferFlags::LIVE | BufferFlags::DISCONT);
91        }
92
93        let pretty_config = ron::ser::PrettyConfig::new().new_line("".to_string());
94
95        let res = ron::ser::to_string_pretty(&buffer, pretty_config);
96        assert_eq!(
97            Ok(concat!(
98                "(",
99                "    pts: Some(1),",
100                "    dts: None,",
101                "    duration: Some(5),",
102                "    offset: 3,",
103                "    offset_end: 4,",
104                "    flags: \"live+discont\",",
105                "    buffer: b\"\\x01\\x02\\x03\\x04\",",
106                ")"
107            )
108            .to_owned()),
109            res
110        );
111
112        let res = serde_json::to_string(&buffer).unwrap();
113        assert_eq!(
114            concat!(
115                "{",
116                "\"pts\":1,",
117                "\"dts\":null,",
118                "\"duration\":5,",
119                "\"offset\":3,",
120                "\"offset_end\":4,",
121                "\"flags\":\"live+discont\",",
122                "\"buffer\":[1,2,3,4]",
123                "}"
124            )
125            .to_owned(),
126            res
127        );
128    }
129
130    #[test]
131    fn test_deserialize() {
132        crate::init().unwrap();
133
134        let buffer_ron = r#"
135            (
136                pts: Some(1),
137                dts: None,
138                duration: Some(5),
139                offset: 3,
140                offset_end: 4,
141                flags: "live+discont",
142                buffer: b"\x01\x02\x03\x04",
143            )
144        "#;
145        let buffer: Buffer = ron::de::from_str(buffer_ron).unwrap();
146        assert_eq!(buffer.pts(), Some(ClockTime::NSECOND));
147        assert_eq!(buffer.dts(), crate::ClockTime::NONE);
148        assert_eq!(buffer.offset(), 3);
149        assert_eq!(buffer.offset_end(), 4);
150        assert_eq!(buffer.duration(), Some(5 * ClockTime::NSECOND));
151        assert_eq!(buffer.flags(), BufferFlags::LIVE | BufferFlags::DISCONT);
152        {
153            let data = buffer.map_readable().unwrap();
154            assert_eq!(data.as_slice(), vec![1, 2, 3, 4].as_slice());
155        }
156
157        let buffer_json = r#"
158            {
159                "pts":1,
160                "dts":null,
161                "duration":5,
162                "offset":3,
163                "offset_end":4,
164                "flags":"live+discont",
165                "buffer":[1,2,3,4]
166            }
167        "#;
168        let buffer: Buffer = serde_json::from_str(buffer_json).unwrap();
169        assert_eq!(buffer.pts(), Some(ClockTime::NSECOND));
170        assert_eq!(buffer.dts(), crate::ClockTime::NONE);
171        assert_eq!(buffer.offset(), 3);
172        assert_eq!(buffer.offset_end(), 4);
173        assert_eq!(buffer.duration(), Some(5 * ClockTime::NSECOND));
174        assert_eq!(buffer.flags(), BufferFlags::LIVE | BufferFlags::DISCONT);
175        {
176            let data = buffer.map_readable().unwrap();
177            assert_eq!(data.as_slice(), vec![1, 2, 3, 4].as_slice());
178        }
179    }
180
181    #[test]
182    fn test_serde_roundtrip() {
183        crate::init().unwrap();
184
185        let mut buffer = Buffer::from_slice(vec![1, 2, 3, 4]);
186        {
187            let buffer = buffer.get_mut().unwrap();
188            buffer.set_pts(Some(ClockTime::NSECOND));
189            buffer.set_offset(3);
190            buffer.set_offset_end(4);
191            buffer.set_duration(5 * ClockTime::NSECOND);
192            buffer.set_flags(BufferFlags::LIVE | BufferFlags::DISCONT);
193        }
194
195        // Ron
196        let buffer_ser = ron::ser::to_string(&buffer).unwrap();
197        let buffer_de: Buffer = ron::de::from_str(buffer_ser.as_str()).unwrap();
198        assert_eq!(buffer_de.pts(), buffer.pts());
199        assert_eq!(buffer_de.dts(), buffer.dts());
200        assert_eq!(buffer_de.offset(), buffer.offset());
201        assert_eq!(buffer_de.offset_end(), buffer.offset_end());
202        assert_eq!(buffer_de.duration(), buffer.duration());
203        assert_eq!(buffer_de.flags(), buffer.flags());
204        {
205            let data = buffer_de.map_readable().unwrap();
206            assert_eq!(data.as_slice(), vec![1, 2, 3, 4].as_slice());
207        }
208    }
209}
gstreamer/buffer_serde.rs

gstreamer/
buffer_serde.rs
