1use std::fmt;
4
5use serde::{
6 de::{Deserialize, Deserializer, SeqAccess, Visitor},
7 ser::{Serialize, SerializeSeq, Serializer},
8};
9
10use crate::{Buffer, BufferList, BufferListRef};
11
12impl Serialize for BufferListRef {
13 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
14 let iter = self.iter();
15 let (remaining, _) = iter.size_hint();
16 if remaining > 0 {
17 let mut seq = serializer.serialize_seq(Some(remaining))?;
18 for buffer in iter {
19 seq.serialize_element(buffer)?;
20 }
21 seq.end()
22 } else {
23 let seq = serializer.serialize_seq(None)?;
24 seq.end()
25 }
26 }
27}
28
29impl Serialize for BufferList {
30 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
31 self.as_ref().serialize(serializer)
32 }
33}
34
35struct BufferListVisitor;
36impl<'de> Visitor<'de> for BufferListVisitor {
37 type Value = BufferList;
38
39 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
40 formatter.write_str("a sequence of Buffers")
41 }
42
43 fn visit_seq<A: SeqAccess<'de>>(self, mut seq: A) -> Result<Self::Value, A::Error> {
44 let mut buffer_list = BufferList::new();
45 {
46 let buffer_list = buffer_list.get_mut().unwrap();
47 while let Some(buffer) = seq.next_element::<Buffer>()? {
48 buffer_list.add(buffer);
49 }
50 }
51 Ok(buffer_list)
52 }
53}
54
55impl<'de> Deserialize<'de> for BufferList {
56 fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
57 skip_assert_initialized!();
58 deserializer.deserialize_seq(BufferListVisitor)
59 }
60}
61
62#[cfg(test)]
63mod tests {
64 use crate::{BufferList, ClockTime};
65
66 #[test]
67 fn test_serialize() {
68 use crate::Buffer;
69
70 crate::init().unwrap();
71
72 let mut buffer_list = BufferList::new();
73 {
74 let buffer_list = buffer_list.get_mut().unwrap();
75
76 let mut buffer = Buffer::from_slice(vec![1, 2, 3, 4]);
77 {
78 let buffer = buffer.get_mut().unwrap();
79 buffer.set_pts(ClockTime::NSECOND);
80 buffer.set_offset(0);
81 buffer.set_offset_end(4);
82 buffer.set_duration(4 * ClockTime::NSECOND);
83 }
84 buffer_list.add(buffer);
85
86 let mut buffer = Buffer::from_slice(vec![5, 6]);
87 {
88 let buffer = buffer.get_mut().unwrap();
89 buffer.set_pts(5 * ClockTime::NSECOND);
90 buffer.set_offset(4);
91 buffer.set_offset_end(6);
92 buffer.set_duration(2 * ClockTime::NSECOND);
93 }
94 buffer_list.add(buffer);
95 }
96
97 let pretty_config = ron::ser::PrettyConfig::new().new_line("".to_string());
98
99 let res = ron::ser::to_string_pretty(&buffer_list, pretty_config);
100 assert_eq!(
101 Ok(concat!(
102 "[",
103 " (",
104 " pts: Some(1),",
105 " dts: None,",
106 " duration: Some(4),",
107 " offset: 0,",
108 " offset_end: 4,",
109 " flags: \"\",",
110 " buffer: b\"\\x01\\x02\\x03\\x04\",",
111 " ),",
112 " (",
113 " pts: Some(5),",
114 " dts: None,",
115 " duration: Some(2),",
116 " offset: 4,",
117 " offset_end: 6,",
118 " flags: \"\",",
119 " buffer: b\"\\x05\\x06\",",
120 " ),",
121 "]"
122 )
123 .to_owned()),
124 res,
125 );
126 }
127
128 #[test]
129 fn test_deserialize() {
130 crate::init().unwrap();
131
132 let buffer_list_ron = r#"
133 [
134 (
135 pts: Some(1),
136 dts: None,
137 duration: Some(4),
138 offset: 0,
139 offset_end: 4,
140 flags: "",
141 buffer: b"\x01\x02\x03\x04",
142 ),
143 (
144 pts: Some(5),
145 dts: None,
146 duration: Some(2),
147 offset: 4,
148 offset_end: 6,
149 flags: "",
150 buffer: b"\x05\x06",
151 ),
152 ]
153 "#;
154
155 let buffer_list: BufferList = ron::de::from_str(buffer_list_ron).unwrap();
156 let mut iter = buffer_list.iter();
157 let buffer = iter.next().unwrap();
158 assert_eq!(buffer.pts(), Some(ClockTime::NSECOND));
159 assert_eq!(buffer.dts(), None);
160 {
161 let data = buffer.map_readable().unwrap();
162 assert_eq!(data.as_slice(), vec![1, 2, 3, 4].as_slice());
163 }
164
165 let buffer = iter.next().unwrap();
166 assert_eq!(buffer.pts(), Some(5 * ClockTime::NSECOND));
167 {
168 let data = buffer.map_readable().unwrap();
169 assert_eq!(data.as_slice(), vec![5, 6].as_slice());
170 }
171 }
172
173 #[test]
174 fn test_serde_roundtrip() {
175 use crate::Buffer;
176
177 crate::init().unwrap();
178
179 let mut buffer_list = BufferList::new();
180 {
181 let buffer_list = buffer_list.get_mut().unwrap();
182
183 let mut buffer = Buffer::from_slice(vec![1, 2, 3, 4]);
184 {
185 let buffer = buffer.get_mut().unwrap();
186 buffer.set_pts(ClockTime::NSECOND);
187 buffer.set_offset(0);
188 buffer.set_offset_end(4);
189 buffer.set_duration(4 * ClockTime::NSECOND);
190 }
191 buffer_list.add(buffer);
192
193 let mut buffer = Buffer::from_slice(vec![5, 6]);
194 {
195 let buffer = buffer.get_mut().unwrap();
196 buffer.set_pts(5 * ClockTime::NSECOND);
197 buffer.set_offset(4);
198 buffer.set_offset_end(6);
199 buffer.set_duration(2 * ClockTime::NSECOND);
200 }
201 buffer_list.add(buffer);
202 }
203 let buffer_list_ser = ron::ser::to_string(&buffer_list).unwrap();
204
205 let buffer_list: BufferList = ron::de::from_str(buffer_list_ser.as_str()).unwrap();
206 let mut iter = buffer_list.iter();
207 let buffer = iter.next().unwrap();
208 assert_eq!(buffer.pts(), Some(ClockTime::NSECOND));
209 assert_eq!(buffer.dts(), None);
210 {
211 let data = buffer.map_readable().unwrap();
212 assert_eq!(data.as_slice(), vec![1, 2, 3, 4].as_slice());
213 }
214
215 let buffer = iter.next().unwrap();
216 assert_eq!(buffer.pts(), Some(5 * ClockTime::NSECOND));
217 {
218 let data = buffer.map_readable().unwrap();
219 assert_eq!(data.as_slice(), vec![5, 6].as_slice());
220 }
221 }
222}