gstreamer-rs/gstreamer/src/bufferlist_serde.rs
Vivienne Watermeier 1b22be2e15 Add De/Serialization for most bitflag types
Represents combinations of flags with a '+' separated string of nicks,
or an empty string for no flags set.

Note that most flag types will ignore any flags using multiple bits when
serializing, since in most cases these flags cover all used bits.
2022-05-06 09:05:52 +00:00

223 lines
6.9 KiB
Rust

// Take a look at the license at the top of the repository in the LICENSE file.
use serde::de::{Deserialize, Deserializer, SeqAccess, Visitor};
use serde::ser::{Serialize, SerializeSeq, Serializer};
use std::fmt;
use crate::Buffer;
use crate::BufferList;
use crate::BufferListRef;
impl Serialize for BufferListRef {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
let iter = self.iter();
let (remaining, _) = iter.size_hint();
if remaining > 0 {
let mut seq = serializer.serialize_seq(Some(remaining))?;
for buffer in iter {
seq.serialize_element(buffer)?;
}
seq.end()
} else {
let seq = serializer.serialize_seq(None)?;
seq.end()
}
}
}
impl Serialize for BufferList {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
self.as_ref().serialize(serializer)
}
}
struct BufferListVisitor;
impl<'de> Visitor<'de> for BufferListVisitor {
type Value = BufferList;
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
formatter.write_str("a sequence of Buffers")
}
fn visit_seq<A: SeqAccess<'de>>(self, mut seq: A) -> Result<Self::Value, A::Error> {
let mut buffer_list = BufferList::new();
{
let buffer_list = buffer_list.get_mut().unwrap();
while let Some(buffer) = seq.next_element::<Buffer>()? {
buffer_list.add(buffer);
}
}
Ok(buffer_list)
}
}
impl<'de> Deserialize<'de> for BufferList {
fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
skip_assert_initialized!();
deserializer.deserialize_seq(BufferListVisitor)
}
}
#[cfg(test)]
mod tests {
use crate::BufferList;
use crate::ClockTime;
#[test]
fn test_serialize() {
use crate::Buffer;
crate::init().unwrap();
let mut buffer_list = BufferList::new();
{
let buffer_list = buffer_list.get_mut().unwrap();
let mut buffer = Buffer::from_slice(vec![1, 2, 3, 4]);
{
let buffer = buffer.get_mut().unwrap();
buffer.set_pts(ClockTime::NSECOND);
buffer.set_offset(0);
buffer.set_offset_end(4);
buffer.set_duration(4 * ClockTime::NSECOND);
}
buffer_list.add(buffer);
let mut buffer = Buffer::from_slice(vec![5, 6]);
{
let buffer = buffer.get_mut().unwrap();
buffer.set_pts(5 * ClockTime::NSECOND);
buffer.set_offset(4);
buffer.set_offset_end(6);
buffer.set_duration(2 * ClockTime::NSECOND);
}
buffer_list.add(buffer);
}
let pretty_config = ron::ser::PrettyConfig::new().new_line("".to_string());
let res = ron::ser::to_string_pretty(&buffer_list, pretty_config);
assert_eq!(
Ok(concat!(
"[",
" (",
" pts: Some(1),",
" dts: None,",
" duration: Some(4),",
" offset: 0,",
" offset_end: 4,",
" flags: \"\",",
" buffer: \"AQIDBA==\",",
" ),",
" (",
" pts: Some(5),",
" dts: None,",
" duration: Some(2),",
" offset: 4,",
" offset_end: 6,",
" flags: \"\",",
" buffer: \"BQY=\",",
" ),",
"]"
)
.to_owned()),
res,
);
}
#[test]
fn test_deserialize() {
crate::init().unwrap();
let buffer_list_ron = r#"
[
(
pts: Some(1),
dts: None,
duration: Some(4),
offset: 0,
offset_end: 4,
flags: "",
buffer: "AQIDBA==",
),
(
pts: Some(5),
dts: None,
duration: Some(2),
offset: 4,
offset_end: 6,
flags: "",
buffer: "BQY=",
),
]
"#;
let buffer_list: BufferList = ron::de::from_str(buffer_list_ron).unwrap();
let mut iter = buffer_list.iter();
let buffer = iter.next().unwrap();
assert_eq!(buffer.pts(), Some(ClockTime::NSECOND));
assert_eq!(buffer.dts(), None);
{
let data = buffer.map_readable().unwrap();
assert_eq!(data.as_slice(), vec![1, 2, 3, 4].as_slice());
}
let buffer = iter.next().unwrap();
assert_eq!(buffer.pts(), Some(5 * ClockTime::NSECOND));
{
let data = buffer.map_readable().unwrap();
assert_eq!(data.as_slice(), vec![5, 6].as_slice());
}
}
#[test]
fn test_serde_roundtrip() {
use crate::Buffer;
crate::init().unwrap();
let mut buffer_list = BufferList::new();
{
let buffer_list = buffer_list.get_mut().unwrap();
let mut buffer = Buffer::from_slice(vec![1, 2, 3, 4]);
{
let buffer = buffer.get_mut().unwrap();
buffer.set_pts(ClockTime::NSECOND);
buffer.set_offset(0);
buffer.set_offset_end(4);
buffer.set_duration(4 * ClockTime::NSECOND);
}
buffer_list.add(buffer);
let mut buffer = Buffer::from_slice(vec![5, 6]);
{
let buffer = buffer.get_mut().unwrap();
buffer.set_pts(5 * ClockTime::NSECOND);
buffer.set_offset(4);
buffer.set_offset_end(6);
buffer.set_duration(2 * ClockTime::NSECOND);
}
buffer_list.add(buffer);
}
let buffer_list_ser = ron::ser::to_string(&buffer_list).unwrap();
let buffer_list: BufferList = ron::de::from_str(buffer_list_ser.as_str()).unwrap();
let mut iter = buffer_list.iter();
let buffer = iter.next().unwrap();
assert_eq!(buffer.pts(), Some(ClockTime::NSECOND));
assert_eq!(buffer.dts(), None);
{
let data = buffer.map_readable().unwrap();
assert_eq!(data.as_slice(), vec![1, 2, 3, 4].as_slice());
}
let buffer = iter.next().unwrap();
assert_eq!(buffer.pts(), Some(5 * ClockTime::NSECOND));
{
let data = buffer.map_readable().unwrap();
assert_eq!(data.as_slice(), vec![5, 6].as_slice());
}
}
}