pub(crate) mod processing;
mod queue;
mod receiver;
use crate::{
Complex32,
config::{F32Iq, RawIq, SampleMode},
errors::Result,
session::RxStreamClaim,
usb::NusbTransport,
};
use nusb::MaybeFuture;
pub use queue::MAX_F32_IQ_SAMPLES_PER_TRANSFER;
use receiver::Receiver;
use std::time::Duration;
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub struct StreamingStats {
pub buffers_received: u64,
pub buffers_processed: u64,
pub buffers_dropped: u64,
pub buffers_discarded_on_restart: u64,
}
impl StreamingStats {
pub(crate) fn accumulate(&mut self, other: Self) {
self.buffers_received += other.buffers_received;
self.buffers_processed += other.buffers_processed;
self.buffers_dropped += other.buffers_dropped;
self.buffers_discarded_on_restart += other.buffers_discarded_on_restart;
}
pub(crate) fn combined(mut self, other: Self) -> Self {
self.accumulate(other);
self
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct SampleBlock<'a> {
raw: &'a [u8],
sample_count: usize,
dropped_samples: u64,
}
impl<'a> SampleBlock<'a> {
pub(crate) const fn new(raw: &'a [u8], sample_count: usize, dropped_samples: u64) -> Self {
Self {
raw,
sample_count,
dropped_samples,
}
}
pub const fn raw_bytes(&self) -> &'a [u8] {
self.raw
}
pub const fn sample_count(&self) -> usize {
self.sample_count
}
pub const fn dropped_samples(&self) -> u64 {
self.dropped_samples
}
}
#[must_use = "RX streams retain the device's exclusive stream claim until closed or dropped"]
pub struct RxStream<M: SampleMode = F32Iq> {
inner: Receiver<NusbTransport, M>,
}
impl<M: SampleMode> RxStream<M> {
pub(crate) fn new(claim: RxStreamClaim<NusbTransport>) -> Self {
Self {
inner: Receiver::new(claim),
}
}
pub fn stats(&self) -> StreamingStats {
self.inner.current_stats()
}
pub fn start(&mut self) -> impl MaybeFuture<Output = Result<()>> + '_ {
self.inner.start()
}
pub fn stop(&mut self) -> impl MaybeFuture<Output = Result<StreamingStats>> + '_ {
self.inner.stop()
}
pub fn close(self) -> impl MaybeFuture<Output = Result<StreamingStats>> + 'static {
self.inner.close()
}
}
impl RxStream<RawIq> {
pub fn next_block(
&mut self,
timeout: Option<Duration>,
) -> impl MaybeFuture<Output = Result<Option<SampleBlock<'_>>>> + '_ {
self.inner.next_block(timeout)
}
}
impl RxStream<F32Iq> {
pub fn read<'a>(
&'a mut self,
out: &'a mut [Complex32],
timeout: Option<Duration>,
) -> impl MaybeFuture<Output = Result<usize>> + 'a {
self.inner.read(out, timeout)
}
}
#[cfg(all(test, not(target_arch = "wasm32")))]
mod tests;