gstreamer/
segment_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,
5    de::{Deserialize, Deserializer},
6    ser::{Serialize, Serializer},
7};
8
9use crate::{
10    format::{FormattedValue, FormattedValueIntrinsic, SpecificFormattedValueIntrinsic},
11    Format, FormattedSegment, GenericFormattedValue, Segment, SegmentFlags,
12};
13
14#[derive(serde::Serialize, serde::Deserialize)]
15struct FormattedSegmentSerde {
16    flags: SegmentFlags,
17    rate: f64,
18    applied_rate: f64,
19    format: Format,
20    base: i64,
21    offset: i64,
22    start: i64,
23    stop: i64,
24    time: i64,
25    position: i64,
26    duration: i64,
27}
28
29impl<T: FormattedValueIntrinsic> Serialize for FormattedSegment<T> {
30    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
31        let fmt_seg = unsafe {
32            FormattedSegmentSerde {
33                flags: self.flags(),
34                rate: self.rate(),
35                applied_rate: self.applied_rate(),
36                format: self.format(),
37                base: self.base().into_raw_value(),
38                offset: self.offset().into_raw_value(),
39                start: self.start().into_raw_value(),
40                stop: self.stop().into_raw_value(),
41                time: self.time().into_raw_value(),
42                position: self.position().into_raw_value(),
43                duration: self.duration().into_raw_value(),
44            }
45        };
46        fmt_seg.serialize(serializer)
47    }
48}
49
50impl<'de> Deserialize<'de> for Segment {
51    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
52        skip_assert_initialized!();
53        FormattedSegmentSerde::deserialize(deserializer).map(|fmt_seg_de| {
54            let mut segment = Self::new();
55            segment.set_flags(fmt_seg_de.flags);
56            segment.set_rate(fmt_seg_de.rate);
57            segment.set_applied_rate(fmt_seg_de.applied_rate);
58            segment.set_format(fmt_seg_de.format);
59            segment.set_base(GenericFormattedValue::new(
60                fmt_seg_de.format,
61                fmt_seg_de.base,
62            ));
63            segment.set_offset(GenericFormattedValue::new(
64                fmt_seg_de.format,
65                fmt_seg_de.offset,
66            ));
67            segment.set_start(GenericFormattedValue::new(
68                fmt_seg_de.format,
69                fmt_seg_de.start,
70            ));
71            segment.set_stop(GenericFormattedValue::new(
72                fmt_seg_de.format,
73                fmt_seg_de.stop,
74            ));
75            segment.set_time(GenericFormattedValue::new(
76                fmt_seg_de.format,
77                fmt_seg_de.time,
78            ));
79            segment.set_position(GenericFormattedValue::new(
80                fmt_seg_de.format,
81                fmt_seg_de.position,
82            ));
83            segment.set_duration(GenericFormattedValue::new(
84                fmt_seg_de.format,
85                fmt_seg_de.duration,
86            ));
87
88            segment
89        })
90    }
91}
92
93impl<'de, T: SpecificFormattedValueIntrinsic> Deserialize<'de> for FormattedSegment<T> {
94    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
95        skip_assert_initialized!();
96        Segment::deserialize(deserializer).and_then(|segment| {
97            segment.downcast::<T>().map_err(|segment| {
98                de::Error::custom(format!(
99                    "failed to convert segment with format {:?} to {:?}",
100                    segment.format(),
101                    T::default_format(),
102                ))
103            })
104        })
105    }
106}
107
108#[cfg(test)]
109mod tests {
110    use crate::{ClockTime, Format, GenericFormattedValue, Segment, SegmentFlags};
111
112    #[test]
113    fn test_serialize() {
114        crate::init().unwrap();
115
116        let mut segment = Segment::new();
117        segment.set_flags(SegmentFlags::RESET | SegmentFlags::SEGMENT);
118        segment.set_rate(1f64);
119        segment.set_applied_rate(0.9f64);
120        segment.set_format(Format::Time);
121        segment.set_base(GenericFormattedValue::from(ClockTime::from_nseconds(123)));
122        segment.set_offset(GenericFormattedValue::from(ClockTime::from_nseconds(42)));
123        segment.set_start(GenericFormattedValue::from(ClockTime::from_nseconds(1024)));
124        segment.set_stop(GenericFormattedValue::from(ClockTime::from_nseconds(2048)));
125        segment.set_time(GenericFormattedValue::from(ClockTime::from_nseconds(1042)));
126        segment.set_position(GenericFormattedValue::from(ClockTime::from_nseconds(256)));
127        segment.set_duration(GenericFormattedValue::from(ClockTime::NONE));
128
129        let pretty_config = ron::ser::PrettyConfig::new().new_line("".to_string());
130
131        let res = ron::ser::to_string_pretty(&segment, pretty_config);
132        assert_eq!(
133            Ok(concat!(
134                "(",
135                "    flags: \"reset+segment\",",
136                "    rate: 1.0,",
137                "    applied_rate: 0.9,",
138                "    format: Time,",
139                "    base: 123,",
140                "    offset: 42,",
141                "    start: 1024,",
142                "    stop: 2048,",
143                "    time: 1042,",
144                "    position: 256,",
145                "    duration: -1,",
146                ")"
147            )
148            .to_owned()),
149            res,
150        );
151    }
152
153    #[test]
154    fn test_deserialize_segment() {
155        crate::init().unwrap();
156
157        let segment_ron = r#"
158            (
159                flags: "reset+segment",
160                rate: 1,
161                applied_rate: 0.9,
162                format: Time,
163                base: 123,
164                offset: 42,
165                start: 1024,
166                stop: 2048,
167                time: 1042,
168                position: 256,
169                duration: -1,
170            )
171        "#;
172
173        let segment: Segment = ron::de::from_str(segment_ron).unwrap();
174        assert_eq!(segment.flags(), SegmentFlags::RESET | SegmentFlags::SEGMENT);
175        assert!((segment.rate() - 1f64).abs() < f64::EPSILON);
176        assert!((segment.applied_rate() - 0.9f64).abs() < f64::EPSILON);
177        assert_eq!(segment.format(), Format::Time);
178        assert_eq!(segment.flags(), SegmentFlags::RESET | SegmentFlags::SEGMENT);
179        assert!((segment.rate() - 1f64).abs() < f64::EPSILON);
180        assert!((segment.applied_rate() - 0.9f64).abs() < f64::EPSILON);
181        assert_eq!(segment.format(), Format::Time);
182        assert_eq!(
183            segment.base(),
184            GenericFormattedValue::from(ClockTime::from_nseconds(123)),
185        );
186        assert_eq!(
187            segment.offset(),
188            GenericFormattedValue::from(ClockTime::from_nseconds(42)),
189        );
190        assert_eq!(
191            segment.start(),
192            GenericFormattedValue::from(ClockTime::from_nseconds(1024)),
193        );
194        assert_eq!(
195            segment.stop(),
196            GenericFormattedValue::from(ClockTime::from_nseconds(2048)),
197        );
198        assert_eq!(
199            segment.time(),
200            GenericFormattedValue::from(ClockTime::from_nseconds(1042)),
201        );
202        assert_eq!(
203            segment.position(),
204            GenericFormattedValue::from(ClockTime::from_nseconds(256)),
205        );
206        assert_eq!(
207            segment.duration(),
208            GenericFormattedValue::from(ClockTime::NONE),
209        );
210    }
211
212    #[test]
213    fn test_deserialize_formatted() {
214        use crate::{format::Time, FormattedSegment};
215
216        crate::init().unwrap();
217
218        let segment_ron = r#"
219            (
220                flags: "reset+segment",
221                rate: 1,
222                applied_rate: 0.9,
223                format: Time,
224                base: 123,
225                offset: 42,
226                start: 1024,
227                stop: 2048,
228                time: 1042,
229                position: 256,
230                duration: -1,
231            )
232        "#;
233
234        let fmt_seg: FormattedSegment<Time> = ron::de::from_str(segment_ron).unwrap();
235        assert_eq!(fmt_seg.flags(), SegmentFlags::RESET | SegmentFlags::SEGMENT);
236        assert!((fmt_seg.rate() - 1f64).abs() < f64::EPSILON);
237        assert!((fmt_seg.applied_rate() - 0.9f64).abs() < f64::EPSILON);
238        assert_eq!(fmt_seg.format(), Format::Time);
239        assert_eq!(fmt_seg.base(), Some(ClockTime::from_nseconds(123)));
240        assert_eq!(fmt_seg.offset(), Some(ClockTime::from_nseconds(42)));
241        assert_eq!(fmt_seg.start(), Some(ClockTime::from_nseconds(1024)));
242        assert_eq!(fmt_seg.stop(), Some(ClockTime::from_nseconds(2048)));
243        assert_eq!(fmt_seg.time(), Some(ClockTime::from_nseconds(1042)));
244        assert_eq!(fmt_seg.position(), Some(ClockTime::from_nseconds(256)));
245        assert_eq!(fmt_seg.duration(), ClockTime::NONE);
246    }
247
248    #[test]
249    fn test_serde_roundtrip() {
250        crate::init().unwrap();
251
252        let mut segment = Segment::new();
253        segment.set_flags(SegmentFlags::RESET | SegmentFlags::SEGMENT);
254        segment.set_rate(1f64);
255        segment.set_applied_rate(0.9f64);
256        segment.set_format(Format::Time);
257        segment.set_base(GenericFormattedValue::from(ClockTime::from_nseconds(123)));
258        segment.set_offset(GenericFormattedValue::from(ClockTime::from_nseconds(42)));
259        segment.set_start(GenericFormattedValue::from(ClockTime::from_nseconds(1024)));
260        segment.set_stop(GenericFormattedValue::from(ClockTime::from_nseconds(2048)));
261        segment.set_time(GenericFormattedValue::from(ClockTime::from_nseconds(1042)));
262        segment.set_position(GenericFormattedValue::from(ClockTime::from_nseconds(256)));
263        segment.set_duration(GenericFormattedValue::from(ClockTime::NONE));
264        let segment_se = ron::ser::to_string(&segment).unwrap();
265
266        let segment_de: Segment = ron::de::from_str(segment_se.as_str()).unwrap();
267        assert_eq!(segment_de.flags(), segment.flags());
268        assert!((segment_de.rate() - segment.rate()).abs() < f64::EPSILON);
269        assert!((segment_de.applied_rate() - segment.applied_rate()).abs() < f64::EPSILON);
270        assert_eq!(segment_de.format(), segment.format());
271        assert_eq!(segment_de.base(), segment.base());
272        assert_eq!(segment_de.offset(), segment.offset());
273        assert_eq!(segment_de.start(), segment.start());
274        assert_eq!(segment_de.stop(), segment.stop());
275        assert_eq!(segment_de.time(), segment.time());
276        assert_eq!(segment_de.position(), segment.position());
277        assert_eq!(segment_de.duration(), segment.duration());
278    }
279}
gstreamer/segment_serde.rs

gstreamer/
segment_serde.rs
