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
|
use anyhow::{anyhow, Result};
use crate::v4l2;
use chrono::{DateTime, Local};
use std::io::{Read, Write};
pub struct Frame<'a>{
pub format: v4l2::ImageFormat,
pub width: usize,
pub height: usize,
pub stride: usize,
pub buf: &'a [u8],
pub timestamp: DateTime<Local>,
}
impl<'a> Frame<'a>{
pub fn serialize(&self, dst: &mut impl Write) -> Result<()>{
dst.write_all(&u32::to_be_bytes(self.format.into()))?;
dst.write_all(&self.timestamp.timestamp_subsec_nanos().to_be_bytes())?;
dst.write_all(&self.timestamp.timestamp().to_be_bytes())?;
dst.write_all(&(self.width as u64).to_be_bytes())?;
dst.write_all(&(self.height as u64).to_be_bytes())?;
dst.write_all(&(self.stride as u64).to_be_bytes())?;
dst.write_all(&(self.buf.len() as u64).to_be_bytes())?;
dst.write_all(self.buf)?;
Ok(())
}
pub fn clone_in<'b, 'c>(&'b self, buf: &'c mut Vec<u8>)
-> Frame<'c>{
*buf = self.buf.into();
Frame{
format: self.format,
width: self.width,
height: self.height,
stride: self.stride,
buf,
timestamp: self.timestamp,
}
}
pub fn deserialize<'b>(src: &'b mut impl Read, buf: &'a mut Vec<u8>)
-> Result<Self>{
struct Rh<'c>(&'c mut dyn Read);
impl<'c> Rh<'c>{
fn u32(&mut self) -> Result<u32>{
let mut tmp: [u8; 4] = Default::default();
self.0.read_exact(&mut tmp)?;
Ok(u32::from_be_bytes(tmp))
}
fn i64(&mut self) -> Result<i64>{
let mut tmp: [u8; 8] = Default::default();
self.0.read_exact(&mut tmp)?;
Ok(i64::from_be_bytes(tmp))
}
fn usize(&mut self) -> Result<usize>{
let mut tmp: [u8; 8] = Default::default();
self.0.read_exact(&mut tmp)?;
Ok(u64::from_be_bytes(tmp) as usize)
}
}
// XXX: limit allocation length?
let mut src = Rh(src);
let format = src.u32()?.into();
let (ns, s) = (src.u32()?, src.i64()?);
let timestamp = DateTime::from_timestamp(s, ns)
.ok_or(anyhow!("Invalid DateTime"))?.into();
let width = src.usize()?;
let height = src.usize()?;
let stride = src.usize()?;
let len = src.usize()?;
buf.resize(len, 0);
src.0.read_exact(buf)?;
Ok(Frame{ format, width, height, stride, buf, timestamp })
}
}
pub trait CaptStream{
fn next<R>(&mut self, cb: impl FnOnce(Frame) -> R) -> Result<R>;
}
impl CaptStream for v4l2::CaptStream{
fn next<R>(&mut self, cb: impl FnOnce(Frame) -> R) -> Result<R>{
let (width, height) = (self.width(), self.height());
let stride = self.bytesperline();
let format = self.pixelformat();
let mut cb = Some(cb);
loop{
if let Some(ret) = v4l2::CaptStream::next(self, |buf, attr|{
if attr.flags.error{
return None;
}
let timestamp = attr.get_datetime().unwrap();
Some(cb.take().unwrap()(Frame{
format, width, height, stride, buf, timestamp
}))
})?{
return Ok(ret);
}
}
}
}
pub struct RemoteCam<I: Read + Write>(I);
impl<I: Read + Write> RemoteCam<I>{
pub fn new(inner: I) -> Self{
Self(inner)
}
}
impl<I: Read + Write> CaptStream for RemoteCam<I>{
fn next<R>(&mut self, cb: impl FnOnce(Frame) -> R) -> Result<R>{
let ack: [u8; 1] = [0x2e];
let mut buf = Vec::new();
let frame = Frame::deserialize(&mut self.0, &mut buf)?;
self.0.write_all(&ack)?;
self.0.flush()?;
Ok(cb(frame))
}
}
|
