use std::io;
use std::time::{Duration, Instant};
use crate::codec::{self, Walk};
use crate::{io_err, stream_regs, Device, Error, Kind, Stream, USB3_READ_ALIGNMENT};
const READ_BYTES: usize = 64 * 1024;
const MAX_CARRY: usize = READ_BYTES;
const POLL: Duration = Duration::from_millis(2);
const PROBE_WAIT: Duration = Duration::from_millis(100);
#[derive(Clone, Debug)]
pub struct Acquisition {
pub lanes: u32,
pub burst: Option<u16>,
}
impl Default for Acquisition {
fn default() -> Self {
Self {
lanes: !0,
burst: None,
}
}
}
impl Device {
pub fn start(&mut self, s: Stream, a: &Acquisition) -> Result<StreamReader<'_>, Error> {
if s == Stream::Samples && self.caps().has(crate::Cap::RateControl) && !self.rate_ready()? {
return Err(io_err(
io::ErrorKind::InvalidInput,
"the acquisition rate is not configured, so rhd_matrix emits nothing: call Device::set_rate first (contract 0.5, rate_control)",
));
}
let (run, burst, _, lanes) = stream_regs(s);
let bound = match a.burst {
Some(want) => codec::aligned_burst_at_least(
s.max_frame_bytes() as u32,
u32::from(want),
USB3_READ_ALIGNMENT as u32,
)
.and_then(|n| u16::try_from(n).ok())
.ok_or_else(|| {
io_err(
io::ErrorKind::InvalidInput,
format!("burst {want} cannot be represented after alignment"),
)
})?,
None => 0,
};
self.write_field(run, 0)?;
self.write_field(burst, u32::from(bound))?;
if let Some(lanes_reg) = lanes {
self.write_field(lanes_reg, a.lanes)?;
}
std::thread::sleep(Duration::from_millis(10));
self.write_field(run, 1)?;
Ok(StreamReader {
dev: self,
stream: s,
buf: Vec::new(),
pos: 0,
dec: Decoder::default(),
})
}
pub fn live_lanes(&mut self, s: Stream, records: u16) -> Result<u32, Error> {
let mut live = 0u32;
let mut rd = self.start(
s,
&Acquisition {
lanes: !0,
burst: Some(records.max(1)),
},
)?;
let mut idle = 0;
while idle < i32::from(records.max(1)) {
match rd.next(PROBE_WAIT)? {
None => idle += 1,
Some(rec) => {
for b in rec.blocks() {
if b.kind() != Kind::RhdMatrix {
continue;
}
let rows = b.rows();
let nlanes = b.lanes().len().min(32) as u16;
for l in 0..nlanes {
for r in 0..rows {
match b.value(r, l) {
Some(v) if v != 0xffff && v != 0 => {
live |= 1u32 << l;
break;
}
_ => {}
}
}
}
}
}
}
}
rd.stop()?;
Ok(live)
}
pub fn start_multi(
&mut self,
want: &[(Stream, Acquisition)],
) -> Result<MultiReader<'_>, Error> {
if want.is_empty() {
return Err(io_err(
io::ErrorKind::InvalidInput,
"start_multi needs at least one stream",
));
}
for (i, (s, _)) in want.iter().enumerate() {
if want[..i].iter().any(|(o, _)| o == s) {
return Err(io_err(
io::ErrorKind::InvalidInput,
format!("stream {s:?} requested twice"),
));
}
}
for (s, a) in want {
let (run, burst, _, lanes) = stream_regs(*s);
let bound = match a.burst {
Some(w) => codec::aligned_burst_at_least(
s.max_frame_bytes() as u32,
u32::from(w),
USB3_READ_ALIGNMENT as u32,
)
.and_then(|n| u16::try_from(n).ok())
.ok_or_else(|| {
io_err(
io::ErrorKind::InvalidInput,
format!("burst {w} cannot be represented after alignment"),
)
})?,
None => 0,
};
self.write_field(run, 0)?;
self.write_field(burst, u32::from(bound))?;
if let Some(lanes_reg) = lanes {
self.write_field(lanes_reg, a.lanes)?;
}
}
std::thread::sleep(Duration::from_millis(10));
for (s, _) in want {
self.write_field(stream_regs(*s).0, 1)?;
}
Ok(MultiReader {
dev: self,
lanes: want
.iter()
.map(|(s, _)| Lane {
stream: *s,
buf: Vec::new(),
pos: 0,
dec: Decoder::default(),
})
.collect(),
})
}
}
pub(crate) fn run_reg(s: Stream) -> &'static str {
stream_regs(s).0
}
struct Lane {
stream: Stream,
buf: Vec<u8>,
pos: usize,
dec: Decoder,
}
pub struct MultiReader<'d> {
dev: &'d mut Device,
lanes: Vec<Lane>,
}
impl MultiReader<'_> {
pub fn next(&mut self, timeout: Duration) -> Result<Option<(Stream, Record<'_>)>, Error> {
let deadline = Instant::now() + timeout;
let dev = &mut *self.dev;
let found = pump_multi(&mut self.lanes, deadline, |lane| {
let stream = lane.stream;
refill_into(&mut lane.buf, &mut lane.pos, |dst| {
dev.link.stream_read(stream, dst)
})
})?;
let Some((i, d)) = found else {
return Ok(None);
};
let lane = &self.lanes[i];
let frame = codec::Frame::parse(&lane.buf[d.start..d.end])
.expect("advance() validated these exact bytes and nothing has moved them since");
Ok(Some((
lane.stream,
Record {
frame,
lost: d.lost,
},
)))
}
pub fn health(&mut self, s: Stream) -> Result<Health, Error> {
let v = self.dev.read_reg(stream_regs(s).2)?;
Ok(Health {
readable_bytes: (v & 0xFFFF) as usize * 4,
overrun: v & (1 << 16) != 0,
})
}
pub fn stats(&self, s: Stream) -> Option<Stats> {
self.lanes
.iter()
.find(|l| l.stream == s)
.map(|l| l.dec.stats)
}
pub fn stop(self) -> Result<(), Error> {
let mut first = Ok(());
for lane in &self.lanes {
let r = self.dev.write_field(stream_regs(lane.stream).0, 0);
if first.is_ok() {
first = r;
}
}
first
}
}
pub struct StreamReader<'d> {
dev: &'d mut Device,
stream: Stream,
buf: Vec<u8>,
pos: usize,
dec: Decoder,
}
#[derive(Default)]
struct Decoder {
stats: Stats,
frame_bytes: Option<u32>,
prev: Option<(u16, u64)>,
}
impl StreamReader<'_> {
pub fn next(&mut self, timeout: Duration) -> Result<Option<Record<'_>>, Error> {
let deadline = Instant::now() + timeout;
let dev = &mut *self.dev;
let stream = self.stream;
let found = pump(
&mut self.dec,
&mut self.buf,
&mut self.pos,
deadline,
|dst| dev.link.stream_read(stream, dst),
)?;
let Some(d) = found else {
return Ok(None);
};
let frame = codec::Frame::parse(&self.buf[d.start..d.end])
.expect("advance() validated these exact bytes and nothing has moved them since");
Ok(Some(Record {
frame,
lost: d.lost,
}))
}
pub fn health(&mut self) -> Result<Health, Error> {
let v = self.dev.read_reg(stream_regs(self.stream).2)?;
Ok(Health {
readable_bytes: (v & 0xFFFF) as usize * 4,
overrun: (v >> 16) & 1 != 0,
})
}
pub fn stats(&self) -> Stats {
self.dec.stats
}
pub fn frame_bytes(&self) -> Option<u32> {
self.dec.frame_bytes
}
pub fn aligned_burst(&self, want: u16) -> Option<u16> {
let n = codec::aligned_burst(
self.dec.frame_bytes?,
u32::from(want),
USB3_READ_ALIGNMENT as u32,
)?;
u16::try_from(n).ok()
}
pub fn stop(self) -> Result<(), Error> {
self.dev.write_field(stream_regs(self.stream).0, 0)
}
}
fn refill_into(
buf: &mut Vec<u8>,
pos: &mut usize,
read: impl FnOnce(&mut [u8]) -> Result<usize, Error>,
) -> Result<usize, Error> {
if *pos > 0 {
buf.drain(..*pos);
*pos = 0;
}
let at = buf.len();
buf.resize(at + READ_BYTES, 0);
let got = match read(&mut buf[at..]) {
Ok(n) => n,
Err(e) => {
buf.truncate(at);
return Err(e);
}
};
buf.truncate(at + got);
Ok(got)
}
fn pump(
dec: &mut Decoder,
buf: &mut Vec<u8>,
pos: &mut usize,
deadline: Instant,
mut read: impl FnMut(&mut [u8]) -> Result<usize, Error>,
) -> Result<Option<Decoded>, Error> {
loop {
let (next, hit) = dec.advance(buf, *pos);
*pos = next;
if hit.is_some() {
return Ok(hit);
}
let got = refill_into(buf, pos, &mut read)?;
if got > 0 {
let (next, hit) = dec.advance(buf, *pos);
*pos = next;
if hit.is_some() {
return Ok(hit);
}
}
if Instant::now() >= deadline {
return Ok(None);
}
if got == 0 {
std::thread::sleep(POLL);
}
}
}
fn pump_multi(
lanes: &mut [Lane],
deadline: Instant,
mut refill: impl FnMut(&mut Lane) -> Result<usize, Error>,
) -> Result<Option<(usize, Decoded)>, Error> {
fn scan(lanes: &mut [Lane]) -> Option<(usize, Decoded)> {
for (i, lane) in lanes.iter_mut().enumerate() {
let (pos, d) = lane.dec.advance(&lane.buf, lane.pos);
lane.pos = pos;
if let Some(d) = d {
return Some((i, d));
}
}
None
}
loop {
if let Some(h) = scan(lanes) {
return Ok(Some(h));
}
let mut got = 0usize;
for lane in lanes.iter_mut() {
got += refill(lane)?;
}
if got > 0 {
if let Some(h) = scan(lanes) {
return Ok(Some(h));
}
}
if Instant::now() >= deadline {
return Ok(None);
}
if got == 0 {
std::thread::sleep(POLL);
}
}
}
#[derive(Copy, Clone)]
struct Decoded {
start: usize,
end: usize,
lost: u64,
}
impl Decoder {
fn advance(&mut self, buf: &[u8], from: usize) -> (usize, Option<Decoded>) {
let mut walk = Walk::new(&buf[from..]);
let mut hit = None;
let mut bad = 0u64;
for f in walk.by_ref() {
match f {
Ok(frame) => {
let h = frame.header();
hit = Some((
h.timestamp,
h.run_id,
h.flags.first_of_run(),
h.frame_words,
frame.bytes().len(),
frame.section_at(0).map(|s| s.cadence()),
));
break;
}
Err(_) => bad += 1,
}
}
let pos = buf.len() - walk.tail().len();
let c = walk.counters();
self.stats.bad_frames += bad;
self.stats.resync_bytes += c.resync_bytes as u64;
self.stats.skipped_unknown_format += c.format_skipped as u64;
self.stats.skipped_unknown_kind += c.unknown_kind as u64;
let Some((ts, run_id, first, frame_words, len, cadence)) = hit else {
if buf.len() - pos > MAX_CARRY {
self.stats.bad_frames += 1;
self.stats.resync_bytes += 1;
return (pos + 1, None);
}
return (pos, None);
};
self.frame_bytes.get_or_insert(frame_words * 2);
let lost = self.lost_before(ts, run_id, first, cadence);
self.prev = Some((run_id, ts));
self.stats.records += 1;
self.stats.lost_records += lost;
(
pos,
Some(Decoded {
start: pos - len,
end: pos,
lost,
}),
)
}
fn lost_before(&self, ts: u64, run_id: u16, first: bool, cadence: Option<(u32, u16)>) -> u64 {
if first {
return 0;
}
let (Some((prev_run, prev_ts)), Some((num, den))) = (self.prev, cadence) else {
return 0;
};
if prev_run != run_id {
return 0;
}
codec::lost_frames(ts.saturating_sub(prev_ts), num, den)
.unwrap_or(0)
.max(0) as u64
}
}
pub struct Record<'a> {
frame: codec::Frame<'a>,
lost: u64,
}
impl<'a> Record<'a> {
pub fn timestamp(&self) -> u64 {
self.frame.header().timestamp
}
pub fn run_id(&self) -> u16 {
self.frame.header().run_id
}
pub fn first_of_run(&self) -> bool {
self.frame.header().flags.first_of_run()
}
pub fn lost_before(&self) -> u64 {
self.lost
}
pub fn blocks(&self) -> impl Iterator<Item = Block<'a>> + 'a {
let f = self.frame;
(0..f.header().n_sections).filter_map(move |i| {
let sec = f.section_at(i)?;
Kind::from_code(sec.desc().kind).map(|kind| Block { sec, kind })
})
}
pub fn block(&self, kind: Kind) -> Result<Option<Block<'a>>, Error> {
match self.frame.section(kind.code()) {
Ok(sec) => Ok(sec.map(|sec| Block { sec, kind })),
Err(a) => Err(io_err(
io::ErrorKind::InvalidInput,
format!(
"{}: {} sections of kind {} in one frame - use blocks()",
a.token(),
a.count,
kind.token()
),
)),
}
}
}
#[derive(Copy, Clone)]
pub struct Block<'a> {
sec: codec::Section<'a>,
kind: Kind,
}
impl<'a> Block<'a> {
pub fn kind(&self) -> Kind {
self.kind
}
pub fn lanes(&self) -> impl ExactSizeIterator<Item = u16> + 'a {
self.sec.lane_ids()
}
pub fn rows(&self) -> u16 {
self.sec.desc().rows
}
pub fn cadence(&self) -> (u32, u16) {
self.sec.cadence()
}
pub fn value(&self, row: u16, lane: u16) -> Option<u64> {
self.sec.element(row, self.lane_index(lane)?)
}
pub fn row(&self, row: u16) -> Option<impl ExactSizeIterator<Item = u64> + 'a> {
self.sec.row(row)
}
fn lane_index(&self, id: u16) -> Option<u16> {
self.sec.lane_ids().position(|x| x == id).map(|i| i as u16)
}
pub fn amplifier(&self, channel: u8, lane: u16) -> Option<u16> {
if self.kind != Kind::RhdMatrix || channel > 31 {
return None;
}
self.sec
.element(u16::from(channel) + 1, self.lane_index(lane)?)
.map(|v| v as u16)
}
pub fn aux(&self, which: Aux, lane: u16) -> Option<u16> {
if self.kind != Kind::RhdMatrix {
return None;
}
let row = match which {
Aux::AuxAdc => 0,
Aux::Temp => 33,
Aux::Supply => 34,
};
self.sec
.element(row, self.lane_index(lane)?)
.map(|v| v as u16)
}
pub fn level(&self, row: u16, lane: u16) -> Option<bool> {
if self.sec.desc().element_bits != 1 {
return None;
}
self.sec
.element(row, self.lane_index(lane)?)
.map(|v| v != 0)
}
}
#[derive(Copy, Clone, PartialEq, Eq, Debug)]
#[non_exhaustive]
pub enum Aux {
Temp,
Supply,
AuxAdc,
}
#[derive(Copy, Clone, Debug)]
pub struct Health {
pub readable_bytes: usize,
pub overrun: bool,
}
#[derive(Copy, Clone, Default, Debug)]
pub struct Stats {
pub records: u64,
pub bad_frames: u64,
pub resync_bytes: u64,
pub skipped_unknown_format: u64,
pub skipped_unknown_kind: u64,
pub lost_records: u64,
}
#[cfg(test)]
mod tests {
use super::*;
use crate::codec as c;
fn frame(ts: u64, run_id: u16, first: bool, sample: u16) -> Vec<u8> {
let mut f = vec![0u8; 64]; let put16 = |f: &mut Vec<u8>, at: usize, v: u16| {
f[at..at + 2].copy_from_slice(&v.to_le_bytes());
};
let put32 = |f: &mut Vec<u8>, at: usize, v: u32| {
f[at..at + 4].copy_from_slice(&v.to_le_bytes());
};
put32(&mut f, c::OFF_MAGIC, c::MAGIC);
put16(&mut f, c::OFF_FORMAT, c::FORMAT);
put16(
&mut f,
c::OFF_FLAGS,
if first { c::FLAG_FIRST_OF_RUN } else { 0 },
);
f[c::OFF_TIMESTAMP..c::OFF_TIMESTAMP + 8].copy_from_slice(&ts.to_le_bytes());
put32(&mut f, c::OFF_FRAME_WORDS, 32);
put16(&mut f, c::OFF_LAYOUT, 1);
put16(&mut f, c::OFF_HDR_WORDS, 28);
put16(&mut f, c::OFF_N_SECTIONS, 1);
put16(&mut f, c::OFF_RUN_ID, run_id);
put16(&mut f, c::OFF_CONTRACT_REV, c::CONTRACT_REV);
put16(&mut f, c::OFF_DESC_WORDS, c::DESC_WORDS_MIN);
let d = c::DESCRIPTORS_AT;
f[d + c::DOFF_KIND] = Kind::RhdMatrix.code();
put16(&mut f, d + c::DOFF_N_LANES, 1);
put16(&mut f, d + c::DOFF_WORDS_PER_LANE, 1);
put16(&mut f, d + c::DOFF_SECTION_WORDS, 1);
put32(&mut f, d + c::DOFF_TICK_NUM, 100);
put16(&mut f, d + c::DOFF_TICK_DEN, 1);
put16(
&mut f,
c::DESCRIPTORS_AT + c::DESC_WORDS_MIN as usize * 2,
7,
); put16(&mut f, 56, sample);
let crc = c::crc32(&f[..60]);
put32(&mut f, 60, crc);
f
}
fn drain(dec: &mut Decoder, buf: &[u8]) -> (usize, Vec<(u16, u64)>) {
let mut pos = 0;
let mut out = Vec::new();
loop {
let (next, hit) = dec.advance(buf, pos);
pos = next;
match hit {
Some(d) => {
let f = c::Frame::parse(&buf[d.start..d.end]).expect("advance accepted it");
let s = f.section_at(0).unwrap().element(0, 0).unwrap() as u16;
out.push((s, d.lost));
}
None => return (pos, out),
}
}
}
#[test]
fn a_corrupt_length_cannot_wedge_the_reader() {
let mut wire = frame(1000, 1, true, 0x1111);
let mut bad = frame(1100, 1, false, 0x2222);
let at = c::OFF_FRAME_WORDS;
let words = u32::from_le_bytes(bad[at..at + 4].try_into().unwrap()) | (1 << 28);
bad[at..at + 4].copy_from_slice(&words.to_le_bytes());
wire.extend_from_slice(&bad);
let after = (READ_BYTES / 64) + 200;
for i in 0..after {
wire.extend_from_slice(&frame(1200 + i as u64 * 100, 1, false, 0x3000 + i as u16));
}
let mut dec = Decoder::default();
let (mut buf, mut pos, mut fed, mut records) = (Vec::new(), 0usize, 0usize, 0usize);
for _ in 0..(after * 3) {
let (p, hit) = dec.advance(&buf, pos);
pos = p;
if hit.is_some() {
records += 1;
continue;
}
if fed >= wire.len() {
break;
}
let take = (wire.len() - fed).min(512);
let at = buf.len();
buf.extend_from_slice(&wire[fed..fed + take]);
fed += take;
let _ = at;
if pos > 0 {
buf.drain(..pos);
pos = 0;
}
}
assert!(
records >= 100,
"only {records} records past a corrupt length - the reader wedged"
);
assert!(
buf.len() <= READ_BYTES,
"buffer grew to {} bytes: the carry is unbounded",
buf.len()
);
}
#[test]
fn a_corrupt_frame_is_counted_and_the_stream_survives_it() {
let mut blob = frame(1000, 1, true, 0x1111);
let mut bad = frame(1100, 1, false, 0x2222);
bad[57] ^= 0xFF; blob.extend_from_slice(&bad);
blob.extend_from_slice(&frame(1400, 1, false, 0x3333));
let mut dec = Decoder::default();
let (pos, got) = drain(&mut dec, &blob);
assert_eq!(pos, blob.len(), "nothing is left over");
assert_eq!(
got.iter().map(|g| g.0).collect::<Vec<_>>(),
[0x1111, 0x3333]
);
assert_eq!(dec.stats.bad_frames, 1);
assert!(dec.stats.resync_bytes > 0, "crc_err resyncs, never steps");
assert_eq!(got[1].1, 3);
assert_eq!(dec.stats.lost_records, 3);
assert_eq!(dec.stats.records, 2);
}
#[test]
fn a_frame_split_across_two_reads_is_carried_not_lost() {
let a = frame(1000, 1, true, 0x1111);
let b = frame(1100, 1, false, 0x2222);
let whole: Vec<u8> = a.iter().chain(&b).copied().collect();
let cut = a.len() + 30;
let mut dec = Decoder::default();
let (pos, got) = drain(&mut dec, &whole[..cut]);
assert_eq!(got.iter().map(|g| g.0).collect::<Vec<_>>(), [0x1111]);
assert_eq!(pos, a.len(), "the partial frame stays in the buffer");
assert_eq!(dec.stats.bad_frames, 0, "a partial frame is not a bad one");
let rest = &whole[pos..];
let (pos, got) = drain(&mut dec, rest);
assert_eq!(got, [(0x2222, 0)], "contiguous: no loss across the split");
assert_eq!(pos, rest.len());
assert_eq!(dec.stats.records, 2, "and neither frame came back twice");
assert_eq!(dec.frame_bytes, Some(64));
}
#[test]
fn refill_compacts_only_what_was_decoded() {
let a = frame(1000, 1, true, 0x1111);
let b = frame(1100, 1, false, 0x2222);
let whole: Vec<u8> = a.iter().chain(&b).copied().collect();
let cut = a.len() + 30;
let (mut buf, mut pos) = (Vec::new(), 0usize);
let mut dec = Decoder::default();
let n = refill_into(&mut buf, &mut pos, |dst| {
dst[..cut].copy_from_slice(&whole[..cut]);
Ok(cut)
})
.expect("read 1");
assert_eq!(n, cut);
let (next, hit) = dec.advance(&buf, pos);
pos = next;
assert!(hit.is_some() && pos == a.len());
let rest = &whole[cut..];
refill_into(&mut buf, &mut pos, |dst| {
dst[..rest.len()].copy_from_slice(rest);
Ok(rest.len())
})
.expect("read 2");
assert_eq!(
buf.len(),
b.len(),
"the returned frame is compacted away, the carry is not"
);
let (_, hit) = dec.advance(&buf, pos);
let d = hit.expect("the split frame completes across the two reads");
let f = c::Frame::parse(&buf[d.start..d.end]).expect("advance accepted it");
assert_eq!(
f.section_at(0).unwrap().element(0, 0).unwrap() as u16,
0x2222
);
assert_eq!(dec.stats.bad_frames, 0);
assert_eq!(dec.stats.records, 2);
}
#[test]
fn a_zero_timeout_still_decodes_what_the_refill_returned() {
let a = frame(2000, 1, true, 0xAAAA);
let b = frame(2100, 1, false, 0xBBBB);
let whole: Vec<u8> = a.iter().chain(&b).copied().collect();
let (mut buf, mut pos) = (Vec::new(), 0usize);
let mut dec = Decoder::default();
let mut served = false;
let deadline = Instant::now();
let mut read = |dst: &mut [u8]| {
if served {
return Ok(0);
}
served = true;
dst[..whole.len()].copy_from_slice(&whole);
Ok(whole.len())
};
let first = pump(&mut dec, &mut buf, &mut pos, deadline, &mut read)
.expect("read 1")
.expect("the refill returned two whole frames; one of them is due now");
let f = c::Frame::parse(&buf[first.start..first.end]).expect("pump validated it");
assert_eq!(
f.section_at(0).unwrap().element(0, 0).unwrap() as u16,
0xAAAA
);
let second = pump(&mut dec, &mut buf, &mut pos, deadline, &mut read)
.expect("read 2")
.expect("the second frame was resident before the call");
let f = c::Frame::parse(&buf[second.start..second.end]).expect("pump validated it");
assert_eq!(
f.section_at(0).unwrap().element(0, 0).unwrap() as u16,
0xBBBB
);
assert!(pump(&mut dec, &mut buf, &mut pos, deadline, &mut read)
.expect("read 3")
.is_none());
}
#[test]
fn the_multi_stream_loop_also_decodes_what_the_refill_returned() {
let payloads = [0xC0DEu16, 0xF00D];
let mut lanes: Vec<Lane> = [Stream::Samples, Stream::Digital]
.iter()
.map(|&stream| Lane {
stream,
buf: Vec::new(),
pos: 0,
dec: Decoder::default(),
})
.collect();
let frames: Vec<Vec<u8>> = payloads
.iter()
.enumerate()
.map(|(i, &p)| frame(3000 + i as u64, 1, true, p))
.collect();
let mut served = [false, false];
let deadline = Instant::now(); let hit = pump_multi(&mut lanes, deadline, |lane| {
let i = usize::from(lane.stream != Stream::Samples);
if served[i] {
return Ok(0);
}
served[i] = true;
let f = &frames[i];
lane.buf.extend_from_slice(f);
Ok(f.len())
})
.expect("read")
.expect("a refill that produced whole frames must not be reported as no-data");
let (i, d) = hit;
let f = c::Frame::parse(&lanes[i].buf[d.start..d.end]).expect("validated");
assert_eq!(
f.section_at(0).unwrap().element(0, 0).unwrap() as u16,
payloads[i]
);
}
#[test]
fn a_restart_is_not_a_gap() {
let mut dec = Decoder::default();
let blob: Vec<u8> = frame(1000, 1, true, 0x1111)
.into_iter()
.chain(frame(9_000_000, 2, true, 0x2222))
.collect();
let (_, got) = drain(&mut dec, &blob);
assert_eq!(got, [(0x1111, 0), (0x2222, 0)]);
assert_eq!(dec.stats.lost_records, 0);
}
#[test]
fn aligned_from_max_frame_bytes_covers_known_actual_sizes() {
for actual in [88u32, 136, 2408] {
for s in [Stream::Digital, Stream::Samples] {
let max = s.max_frame_bytes() as u32;
for want in [1u32, 6, 20] {
let n = codec::aligned_burst_at_least(max, want, USB3_READ_ALIGNMENT as u32)
.expect("alignment is 16");
assert!(n >= want, "n={n} did not cover want={want}");
assert_eq!(
(n * actual) % 16,
0,
"n={n} from max={max} want={want} vs actual={actual}"
);
}
}
}
}
}