use crate::clock::Instant;
use crate::gige::proto::gvsp::PixelFormat;
#[derive(Debug, Clone, Copy, Default)]
pub(crate) struct PacketState {
pub received: bool,
pub resend_requested: bool,
pub resend_deadline: Option<Instant>,
}
#[derive(Debug)]
pub(crate) struct BufSlot {
pub data: Box<[u8]>,
pub packets: Vec<PacketState>,
}
impl BufSlot {
pub fn reset(&mut self, n_packets: usize) {
self.packets.clear();
self.packets.resize(n_packets, PacketState::default());
}
}
pub(crate) struct FramePool {
rx: flume::Receiver<BufSlot>,
tx: flume::Sender<BufSlot>,
}
impl FramePool {
pub fn new(n_buffers: usize, payload_size: usize) -> Self {
let (tx, rx) = flume::bounded(n_buffers);
for _ in 0..n_buffers {
let _ = tx.send(BufSlot {
data: vec![0u8; payload_size].into_boxed_slice(),
packets: Vec::new(),
});
}
Self { rx, tx }
}
pub fn try_claim(&self) -> Option<BufSlot> {
self.rx.try_recv().ok()
}
pub fn returner(&self) -> flume::Sender<BufSlot> {
self.tx.clone()
}
}
#[derive(Debug)]
pub(crate) struct PooledBuf {
slot: Option<BufSlot>,
home: flume::Sender<BufSlot>,
}
impl PooledBuf {
pub fn new(slot: BufSlot, home: flume::Sender<BufSlot>) -> Self {
Self {
slot: Some(slot),
home,
}
}
fn bytes(&self) -> &[u8] {
self.slot.as_ref().map_or(&[], |s| &s.data)
}
}
impl Drop for PooledBuf {
fn drop(&mut self) {
if let Some(slot) = self.slot.take() {
let _ = self.home.try_send(slot);
}
}
}
#[cfg_attr(feature = "valuable", derive(valuable::Valuable))]
#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[cfg_attr(feature = "py", pyo3::pyclass(eq, eq_int, skip_from_py_object))]
pub enum FrameStatus {
Complete,
MissingPackets,
Timeout,
Aborted,
WrongPacketId,
PayloadUnsupported,
}
#[cfg_attr(feature = "valuable", derive(valuable::Valuable))]
#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
pub enum PayloadKind {
Image {
has_chunks: bool,
},
ChunkData,
Unknown(u16),
}
#[derive(Debug)]
pub struct Frame {
pub status: FrameStatus,
pub frame_id: u64,
pub payload: PayloadKind,
pub pixel_format: PixelFormat,
pub width: u32,
pub height: u32,
pub x_offset: u32,
pub y_offset: u32,
pub x_padding: u16,
pub y_padding: u16,
pub timestamp_ticks: u64,
pub timestamp_ns: u64,
pub system_timestamp_ns: u64,
pub received_size: usize,
pub(crate) data_end: usize,
pub(crate) data: PooledBuf,
}
impl Frame {
pub fn data(&self) -> &[u8] {
let bytes = self.data.bytes();
&bytes[..self.data_end.min(bytes.len())]
}
}
impl serde::Serialize for Frame {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut s = serializer.serialize_struct("Frame", 15)?;
s.serialize_field("status", &self.status)?;
s.serialize_field("frame_id", &self.frame_id)?;
s.serialize_field("payload", &self.payload)?;
s.serialize_field("pixel_format", &self.pixel_format)?;
s.serialize_field("width", &self.width)?;
s.serialize_field("height", &self.height)?;
s.serialize_field("x_offset", &self.x_offset)?;
s.serialize_field("y_offset", &self.y_offset)?;
s.serialize_field("x_padding", &self.x_padding)?;
s.serialize_field("y_padding", &self.y_padding)?;
s.serialize_field("timestamp_ticks", &self.timestamp_ticks)?;
s.serialize_field("timestamp_ns", &self.timestamp_ns)?;
s.serialize_field("system_timestamp_ns", &self.system_timestamp_ns)?;
s.serialize_field("received_size", &self.received_size)?;
let data = if self.status == FrameStatus::Complete {
serde_bytes::Bytes::new(self.data())
} else {
serde_bytes::Bytes::new(&[])
};
s.serialize_field("data", data)?;
s.end()
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn pool_claims_and_returns() {
let pool = FramePool::new(2, 64);
let a = pool.try_claim().unwrap();
let _b = pool.try_claim().unwrap();
assert!(pool.try_claim().is_none(), "pool exhausted");
drop(PooledBuf::new(a, pool.returner()));
let again = pool.try_claim();
assert!(again.is_some(), "dropped buf re-pools");
}
#[test]
fn slot_reset_clears_packet_state() {
let pool = FramePool::new(1, 8);
let mut slot = pool.try_claim().unwrap();
slot.reset(4);
slot.packets[2].received = true;
slot.reset(6);
assert_eq!(slot.packets.len(), 6);
assert!(!slot.packets[2].received);
}
}