snapcast-proto 0.3.0

Snapcast binary protocol implementation
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

//! Shared types used across the protocol.

use std::io::{self, Read, Write};

use byteorder::{LittleEndian, ReadBytesExt, WriteBytesExt};

/// Timestamp with second and microsecond components.
///
/// Matches the C++ `tv` struct used throughout the Snapcast protocol.
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
pub struct Timeval {
    /// Seconds component.
    pub sec: i32,
    /// Microseconds component.
    pub usec: i32,
}

impl Timeval {
    /// Create from microseconds since epoch.
    pub fn from_usec(usec: i64) -> Self {
        Self {
            sec: (usec / 1_000_000) as i32,
            usec: (usec % 1_000_000) as i32,
        }
    }

    /// Convert to microseconds since epoch.
    pub fn to_usec(self) -> i64 {
        self.sec as i64 * 1_000_000 + self.usec as i64
    }

    /// Read a Timeval (8 bytes, little-endian) from a reader.
    pub fn read_from<R: Read>(r: &mut R) -> io::Result<Self> {
        Ok(Self {
            sec: r.read_i32::<LittleEndian>()?,
            usec: r.read_i32::<LittleEndian>()?,
        })
    }

    /// Write a Timeval (8 bytes, little-endian) to a writer.
    pub fn write_to<W: Write>(&self, w: &mut W) -> io::Result<()> {
        w.write_i32::<LittleEndian>(self.sec)?;
        w.write_i32::<LittleEndian>(self.usec)?;
        Ok(())
    }
}

impl std::ops::Add for Timeval {
    type Output = Self;

    fn add(self, rhs: Self) -> Self {
        let mut sec = self.sec + rhs.sec;
        let mut usec = self.usec + rhs.usec;
        if usec >= 1_000_000 {
            sec += usec / 1_000_000;
            usec %= 1_000_000;
        }
        Self { sec, usec }
    }
}

impl std::ops::Sub for Timeval {
    type Output = Self;

    fn sub(self, rhs: Self) -> Self {
        let mut sec = self.sec - rhs.sec;
        let mut usec = self.usec - rhs.usec;
        while usec < 0 {
            sec -= 1;
            usec += 1_000_000;
        }
        Self { sec, usec }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn timeval_add() {
        let a = Timeval {
            sec: 1,
            usec: 900_000,
        };
        let b = Timeval {
            sec: 0,
            usec: 200_000,
        };
        let result = a + b;
        assert_eq!(
            result,
            Timeval {
                sec: 2,
                usec: 100_000
            }
        );
    }

    #[test]
    fn timeval_sub() {
        let a = Timeval {
            sec: 2,
            usec: 100_000,
        };
        let b = Timeval {
            sec: 1,
            usec: 900_000,
        };
        let result = a - b;
        assert_eq!(
            result,
            Timeval {
                sec: 0,
                usec: 200_000
            }
        );
    }

    #[test]
    fn timeval_round_trip() {
        let tv = Timeval {
            sec: 1000,
            usec: 500_000,
        };
        let mut buf = Vec::new();
        tv.write_to(&mut buf).unwrap();
        assert_eq!(buf.len(), 8);
        let mut cursor = io::Cursor::new(&buf);
        let decoded = Timeval::read_from(&mut cursor).unwrap();
        assert_eq!(tv, decoded);
    }

    #[test]
    fn timeval_known_bytes() {
        // sec=1000 (0x000003E8), usec=500000 (0x0007A120), little-endian
        let expected: [u8; 8] = [0xE8, 0x03, 0x00, 0x00, 0x20, 0xA1, 0x07, 0x00];
        let tv = Timeval {
            sec: 1000,
            usec: 500_000,
        };
        let mut buf = Vec::new();
        tv.write_to(&mut buf).unwrap();
        assert_eq!(buf.as_slice(), &expected);
    }
}