0.0.40 dev

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "fsdr-blocks"
 version = "0.2.0"
-edition = "2021"
+edition = "2024"
 authors = ["FutureSDR Contributors <team@futuresdr.org>"]
 license = "Apache-2.0"
 homepage = "https://www.futuresdr.org"
@@ -16,26 +16,24 @@ readme = "README.md"
 members = [
     ".",
     "crates/*",
-    # "examples/*",
+    "examples/*",
 ]
 
 [dependencies]
-futuresdr = { git = "https://github.com/FutureSDR/FutureSDR", branch = "main", version = "0.0.37"}
-#futuresdr = { path = "../FutureSDR" }
-async-channel = { version = "2.3.1", optional = true }
-async-trait = "0.1.81"
-crossbeam-channel = { version = "0.5.13", optional = true }
-bimap = { version = "0.6.3", optional = true }
-sigmf = { version = "0.1.0", path = "crates/sigmf" }
-async-fs = "2.1.2"
-serde = "1.0.204"
+futuresdr = { git = "https://github.com/FutureSDR/FutureSDR", branch = "main", version = "0.0.40-dev"}
+async-channel = { version = "2.5", optional = true }
+crossbeam-channel = { version = "0.5", optional = true }
+bimap = { version = "0.6", optional = true }
+sigmf = { version = "0.1", path = "crates/sigmf" }
+async-fs = "2.2"
+serde = "1"
 
 [dev-dependencies]
-criterion = { version = "0.5.1", features = ["html_reports"] }
-tokio-test = "0.4.4"
-rand = { version = "0.8.5" }
+criterion = { version = "0.8", features = ["html_reports"] }
 quickcheck_macros = "1"
-serde_json = "1.0.120"
+tokio-test = "0.4"
+rand = { version = "0.10", features=["thread_rng"] }
+serde_json = "1"
 
 [features]
 default = []

benches/channel/crossbeam_sink.rs

@@ -1,17 +1,18 @@
-use criterion::{criterion_group, criterion_main, Criterion};
+use criterion::{Criterion, criterion_group, criterion_main};
 use fsdr_blocks::channel::CrossbeamSink;
-use futuresdr::runtime::Mocker;
-use rand::Rng;
+use futuresdr::runtime::mocker::{Mocker, Reader};
+use rand::RngExt;
 
 /// This benchmark seems to highly depend on the underlying scheduling of polling from the channel
+// cargo bench --profile release --bench crossbeam_sink --features="crossbeam"
 pub fn crossbeam_sink_boxed_slice_u32(c: &mut Criterion) {
     let n_samp = 8192;
-    let input: Vec<u32> = rand::thread_rng()
-        .sample_iter(rand::distributions::Uniform::<u32>::new(0, 1024))
+    let input: Vec<u32> = rand::rng()
+        .sample_iter(rand::distr::Uniform::<u32>::new(0, 1024).unwrap())
         .take(n_samp)
         .collect();
-    let input = input.into_boxed_slice();
-    let input = vec![input];
+    // let input = input.into_boxed_slice();
+    // let input = vec![input];
 
     let (tx, rx) = crossbeam_channel::unbounded::<Box<[u32]>>();
 
@@ -21,10 +22,11 @@ pub fn crossbeam_sink_boxed_slice_u32(c: &mut Criterion) {
 
     group.bench_function("mock-u32-crossbeam-sink", |b| {
         b.iter(|| {
-            let block = CrossbeamSink::new_typed(tx.clone());
+            let block: CrossbeamSink<u32, Reader<u32>> = CrossbeamSink::new(tx.clone());
             let mut mocker = Mocker::new(block);
 
-            mocker.input(0, input.clone());
+            // mocker.input(0, input.clone());
+            mocker.input().set(input.clone());
             mocker.run();
 
             // receive again all samples sent into the crossbeam_sink...

benches/channel/crossbeam_source.rs

@@ -1,13 +1,14 @@
-use criterion::{criterion_group, criterion_main, Criterion};
+use criterion::{Criterion, criterion_group, criterion_main};
 use fsdr_blocks::channel::CrossbeamSource;
-use futuresdr::runtime::Mocker;
-use rand::Rng;
+use futuresdr::runtime::mocker::{Mocker, Writer};
+use rand::RngExt;
 
 /// This benchmark seems to highly depend on the underlying scheduling of polling from the channel
+// cargo bench --profile release --bench crossbeam_source --features="crossbeam"
 pub fn crossbeam_source_boxed_slice_u32(c: &mut Criterion) {
     let n_samp = 8192;
-    let input: Vec<u32> = rand::thread_rng()
-        .sample_iter(rand::distributions::Uniform::<u32>::new(0, 1024))
+    let input: Vec<u32> = rand::rng()
+        .sample_iter(rand::distr::Uniform::<u32>::new(0, 1024).unwrap())
         .take(n_samp)
         .collect();
 
@@ -19,12 +20,12 @@ pub fn crossbeam_source_boxed_slice_u32(c: &mut Criterion) {
 
     group.bench_function("mock-u32-crossbeam-source", |b| {
         b.iter(|| {
-            let block = CrossbeamSource::new_typed(rx.clone());
+            let block: CrossbeamSource<u32, Writer<u32>> = CrossbeamSource::new(rx.clone());
             let mut mocker = Mocker::new(block);
 
             tx.try_send(input.clone().into_boxed_slice()).unwrap();
 
-            mocker.init_output::<u32>(0, n_samp);
+            mocker.output().reserve(n_samp);
             mocker.run();
         });
     });

benches/cw/baseband_to_cw.rs

@@ -1,7 +1,7 @@
-use criterion::{criterion_group, criterion_main, Criterion};
+use criterion::{Criterion, criterion_group, criterion_main};
 use fsdr_blocks::cw::baseband_to_cw::BaseBandToCW;
-use fsdr_blocks::cw::shared::{char_to_baseband, CWAlphabet};
-use futuresdr::runtime::Mocker;
+use fsdr_blocks::cw::shared::{CWAlphabet, char_to_baseband};
+use futuresdr::runtime::mocker::{Mocker, Reader, Writer};
 
 // cargo bench --profile release --bench bb_to_cw --features="cw"
 pub fn bench_baseband_to_cw(c: &mut Criterion) {
@@ -13,19 +13,22 @@ pub fn bench_baseband_to_cw(c: &mut Criterion) {
         .chars()
         .flat_map(|c| char_to_baseband_function(&c))
         .collect::<Vec<f32>>();
-    //println!("BaseBand Vector Length: {}, Content: {:?}", bb.len(), bb);
+    // println!("BaseBand Vector Length: {}, Content: {:?}", bb.len(), bb);
 
     let mut group = c.benchmark_group("baseband_to_cw");
 
     group.throughput(criterion::Throughput::Elements(baseband.len() as u64));
 
     group.bench_function("mock-baseband-to-cw", |b| {
         b.iter(|| {
-            let block = BaseBandToCW::new_typed(100, samples_per_dot);
+            let block: BaseBandToCW<Reader<f32>, Writer<CWAlphabet>> =
+                BaseBandToCW::new(100, samples_per_dot);
             let mut mocker = Mocker::new(block);
 
-            mocker.input(0, baseband.clone());
-            mocker.init_output::<CWAlphabet>(0, baseband.len());
+            // mocker.input(0, baseband.clone());
+            mocker.input().set(baseband.clone());
+            // mocker.init_output::<CWAlphabet>(0, baseband.len());
+            mocker.output().reserve(baseband.len());
             mocker.run();
         });
     });

benches/cw/cw_to_char.rs

@@ -1,7 +1,7 @@
-use criterion::{criterion_group, criterion_main, Criterion};
+use criterion::{Criterion, criterion_group, criterion_main};
 use fsdr_blocks::cw::cw_to_char::CWToChar;
-use fsdr_blocks::cw::shared::{get_alphabet, msg_to_cw};
-use futuresdr::runtime::Mocker;
+use fsdr_blocks::cw::shared::{CWAlphabet, get_alphabet, msg_to_cw};
+use futuresdr::runtime::mocker::{Mocker, Reader, Writer};
 
 // cargo bench --profile release --bench cw_to_char --features="cw"
 pub fn bench_cw_to_char(c: &mut Criterion) {
@@ -18,11 +18,13 @@ pub fn bench_cw_to_char(c: &mut Criterion) {
 
     group.bench_function("mock-cw-to-char", |b| {
         b.iter(|| {
-            let block = CWToChar::new_typed(get_alphabet());
+            let block: CWToChar<Reader<CWAlphabet>, Writer<u32>> = CWToChar::new(get_alphabet());
             let mut mocker = Mocker::new(block);
 
-            mocker.input(0, cw.clone());
-            mocker.init_output::<char>(0, cw.len());
+            // mocker.input(0, cw.clone());
+            mocker.input().set(cw.clone());
+            // mocker.init_output::<char>(0, cw.len());
+            mocker.output().reserve(cw.len());
             mocker.run();
         });
     });

benches/cw/shared.rs

@@ -1,4 +1,4 @@
-use criterion::{criterion_group, criterion_main, Criterion};
+use criterion::{Criterion, criterion_group, criterion_main};
 use fsdr_blocks::cw::shared::{char_to_baseband, msg_to_cw};
 
 // cargo bench --profile release --bench shared --features="cw"

crates/sigmf-utilities/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "sigmf-utilities"
 version = "0.1.0"
-edition = "2021"
+edition = "2024"
 authors = ["FutureSDR Contributors <team@futuresdr.org>", "Loïc Fejoz <loic@fejoz.net>"]
 license = "Apache-2.0 or MIT"
 repository = "https://github.com/futuresdr/fsdr-blocks/"
@@ -13,15 +13,15 @@ readme = "README.md"
 
 [dependencies]
 anyhow = "1.0"
-clap = { version = "4.4.7", features = ["derive"] }
+clap = { version = "4.5", features = ["derive"] }
 fsdr-blocks = {path="../../"}
 futuresdr = { git = "https://github.com/FutureSDR/FutureSDR", branch = "main" }
 serde = "^1.0"
 serde_derive = "^1.0"
 serde_json = "^1.0"
 sigmf = {path="../sigmf"}
-thiserror = "1.0.50"
-walkdir = "2.4.0"
+thiserror = "2.0"
+walkdir = "2.5"
 
 [build-dependencies]
 rustc_version = "0.4.0"

crates/sigmf-utilities/src/sigmf_col.rs

@@ -1,5 +1,5 @@
 use anyhow::{Context, Result};
-use clap::{arg, Parser, Subcommand};
+use clap::{Parser, Subcommand};
 use sigmf::{DescriptionBuilder, RecordingBuilder};
 use std::path::PathBuf;
 

crates/sigmf-utilities/src/sigmf_convert.rs

@@ -1,5 +1,5 @@
 use anyhow::anyhow;
-use clap::{arg, Parser};
+use clap::Parser;
 use fsdr_blocks::sigmf::DatasetFormat;
 use fsdr_blocks::sigmf::DatasetFormat::*;
 use fsdr_blocks::sigmf::{SigMFSinkBuilder, SigMFSourceBuilder};
@@ -27,45 +27,44 @@ impl Cli {
     pub async fn execute(self) -> Result<()> {
         let mut fg = Flowgraph::new();
 
-        let mut src = SigMFSourceBuilder::from(&self.input);
-        let src = src.build::<f32>().await?;
+        let mut src_builder = SigMFSourceBuilder::from(&self.input);
+        let src = fg.add_block(src_builder.build::<f32>().await?);
 
         let snk = SigMFSinkBuilder::from(self.output);
 
-        let (conv, snk) = match self.target {
-            RI8 => (
-                TypeConvertersBuilder::lossy_scale_convert_f32_i8().build(),
-                snk.datatype(self.target).build::<i8>().await?,
-            ),
-            RU8 => (
-                TypeConvertersBuilder::lossy_scale_convert_f32_u8().build(),
-                snk.datatype(self.target).build::<u8>().await?,
-            ),
-            Rf32Be | Rf32Le => (
-                Apply::new(|x: &f32| *x).into(),
-                snk.datatype(self.target).build::<f32>().await?,
-            ),
-            Rf64Be | Rf64Le => (
-                TypeConvertersBuilder::convert::<f32, f64>().build(),
-                snk.datatype(self.target).build::<f64>().await?,
-            ),
-            Ri16Be | Ri16Le => (
-                TypeConvertersBuilder::lossy_scale_convert_f32_i16().build(),
-                snk.datatype(self.target).build::<i16>().await?,
-            ),
-            // Ri32Be | Ri32Le  => (
-            //     fg.add_block(TypeConvertersBuilder::lossy_scale_convert_f32_i32().build()),
-            //     fg.add_block(snk.datatype(self.target).build::<i32>().await?),
-            // ),
-            // Ru16Be | Ru16Le  => {
-            //     fg.add_block(TypeConvertersBuilder::convert::<f32, u16>().build())
-            // }
-            // Ru32Be | Ru32Le  => {
-            //     fg.add_block(TypeConvertersBuilder::convert::<f32, u32>().build())
-            // }
+        match self.target {
+            RI8 => {
+                let conv = TypeConvertersBuilder::lossy_scale_convert_f32_i8().build();
+                let snk = snk.datatype(self.target).build::<i8>().await?;
+                let src_ref = src.clone();
+                connect!(fg, src_ref > conv > snk);
+            }
+            RU8 => {
+                let conv = TypeConvertersBuilder::lossy_scale_convert_f32_u8().build();
+                let snk = snk.datatype(self.target).build::<u8>().await?;
+                let src_ref = src.clone();
+                connect!(fg, src_ref > conv > snk);
+            }
+            Rf32Be | Rf32Le => {
+                let conv: Apply<fn(&f32) -> f32, f32, f32> = Apply::new(|x: &f32| *x);
+                let snk = snk.datatype(self.target).build::<f32>().await?;
+                let src_ref = src.clone();
+                connect!(fg, src_ref > conv > snk);
+            }
+            Rf64Be | Rf64Le => {
+                let conv = TypeConvertersBuilder::convert::<f32, f64>().build();
+                let snk = snk.datatype(self.target).build::<f64>().await?;
+                let src_ref = src.clone();
+                connect!(fg, src_ref > conv > snk);
+            }
+            Ri16Be | Ri16Le => {
+                let conv = TypeConvertersBuilder::lossy_scale_convert_f32_i16().build();
+                let snk = snk.datatype(self.target).build::<i16>().await?;
+                let src_ref = src.clone();
+                connect!(fg, src_ref > conv > snk);
+            }
             _ => return Err(anyhow!("Unsupported target type: {}", self.target)),
         };
-        connect!(fg, src > conv > snk);
         // fg.connect_stream(src, "out", conv, "in")
         //     .with_context(|| "src->conv")?;
         // fg.connect_stream(conv, "out", snk, "in")

crates/sigmf-utilities/src/sigmf_hash.rs

@@ -1,5 +1,5 @@
 use anyhow::{Context, Result};
-use clap::{arg, Parser, Subcommand};
+use clap::{Parser, Subcommand};
 use sigmf::RecordingBuilder;
 use std::path::PathBuf;
 

crates/sigmf/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "sigmf"
 version = "0.1.0"
-edition = "2021"
+edition = "2024"
 authors = ["FutureSDR Contributors <team@futuresdr.org>", "Loïc Fejoz <loic@fejoz.net>"]
 license = "Apache-2.0 or MIT"
 repository = "https://github.com/futuresdr/fsdr-blocks/"
@@ -19,11 +19,11 @@ quickcheck=['dep:quickcheck']
 serde = "^1.0"
 serde_derive = "^1.0"
 serde_json = "^1.0"
-thiserror = "1.0.50"
-quickcheck = {version = "1.0.3", optional = true}
-uuid = {version = "1.5.0", features = ["serde"]}
-sha2 = { version = "0.10.8"}
-hex = { version = "0.4.3"}
+thiserror = "2.0"
+quickcheck = {version = "1.1", optional = true}
+uuid = {version = "1.21", features = ["serde"]}
+sha2 = { version = "0.10"}
+hex = { version = "0.4"}
 
 [build-dependencies]
 rustc_version = "0.4.0"

crates/sigmf/src/capture.rs

@@ -2,7 +2,7 @@ use serde_json::Value;
 use std::collections::HashMap;
 
 #[cfg(feature = "quickcheck")]
-use quickcheck::{empty_shrinker, Arbitrary, Gen};
+use quickcheck::{Arbitrary, Gen, empty_shrinker};
 
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
 pub struct Capture {

crates/sigmf/src/dataset_format.rs

@@ -1,7 +1,7 @@
 use std::{fmt, marker::PhantomData};
 
 #[cfg(feature = "quickcheck")]
-use quickcheck::{empty_shrinker, single_shrinker, Arbitrary, Gen};
+use quickcheck::{Arbitrary, Gen, empty_shrinker, single_shrinker};
 
 use crate::SigMFError;
 

crates/sigmf/src/description.rs

@@ -6,7 +6,7 @@ use std::{
 };
 
 #[cfg(feature = "quickcheck")]
-use quickcheck::{empty_shrinker, Arbitrary, Gen};
+use quickcheck::{Arbitrary, Gen, empty_shrinker};
 
 use crate::{Annotation, Capture, Collection, DatasetFormat, Extension, Global, SigMFError};
 

crates/sigmf/src/global.rs

@@ -1,9 +1,9 @@
-use crate::{errors::SigMFError, AntennaExtension, DatasetFormat, Extension};
+use crate::{AntennaExtension, DatasetFormat, Extension, errors::SigMFError};
 use serde_json::Value;
 use std::collections::HashMap;
 
 #[cfg(feature = "quickcheck")]
-use quickcheck::{empty_shrinker, Arbitrary, Gen};
+use quickcheck::{Arbitrary, Gen, empty_shrinker};
 
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
 pub struct Global {