chore(release): Merge branch 'release/0.9.0'

Author: BenLeadbetter

.pre-commit-config.yaml

@@ -5,7 +5,7 @@ repos:
   - id: cargo-fmt
     stages: [pre-commit]
 - repo: https://github.com/compilerla/conventional-pre-commit
-  rev: v4.0.0
+  rev: v4.2.0
   hooks:
   - id: conventional-pre-commit
     stages: [commit-msg]

CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## [0.9.0](https://github.com/midi2-dev/bl-midi2-rs/compare/0.8.2..0.9.0) - 2025-05-13
+
+### ✨ Features
+
+- Extend sysex api - ([909c6e1](https://github.com/midi2-dev/bl-midi2-rs/commit/909c6e171f838ccb2c3c16a78ffc94ede44ead70))
+- Payload from sysex packets - ([f196aac](https://github.com/midi2-dev/bl-midi2-rs/commit/f196aac7c91f6951038f710610fffd2b67da78b2))
+
+### 🐛 Fixes
+
+- Sysex7 packet with invalid size passes validation - ([edd5ca2](https://github.com/midi2-dev/bl-midi2-rs/commit/edd5ca278f653e0bdc3f516086dad4ed2502101e))
+- Ignore clippy lint with false positives - ([3f47e53](https://github.com/midi2-dev/bl-midi2-rs/commit/3f47e53529025d3deef5e5d42876375b8e6a5ed2))
+
+### 🧪 Testing
+
+- Adds sysex insert fuzz test - ([e0d5920](https://github.com/midi2-dev/bl-midi2-rs/commit/e0d592055c7fc3902d7c61155afb7368b517e841))
+
+
 ## [0.8.2](https://github.com/midi2-dev/bl-midi2-rs/compare/0.8.1..0.8.2) - 2025-03-02
 
 ### 🐛 Fixes

README.md

@@ -163,7 +163,7 @@ You'll want to setup midi2 without default features to compile
 without the `std` feature.
 
 ```toml
-midi2 = { version = "0.8.2", default-features = false, features = ["channel-voice2", "sysex7"],  }
+midi2 = { version = "0.9.0", default-features = false, features = ["channel-voice2", "sysex7"],  }
 ```
 
 ### Generic Representation

fuzz/Cargo.toml

@@ -9,6 +9,10 @@ cargo-fuzz = true
 
 [dependencies]
 libfuzzer-sys = "0.4"
+arbitrary = { version = "1.0", features = [
+    "derive",
+] }
+rand = "0.9.1"
 
 [dependencies.midi2]
 path = "../midi2"
@@ -32,3 +36,10 @@ path = "./fuzz_targets/sysex7_payload_roundtrip.rs"
 test = false
 doc = false
 bench = false
+
+[[bin]]
+name = "generic_sysex_inserting_payloads"
+path = "./fuzz_targets/generic_sysex_inserting_payloads.rs"
+test = false
+doc = false
+bench = false

fuzz/fuzz_targets/generic_sysex_inserting_payloads.rs

@@ -0,0 +1,126 @@
+#![no_main]
+
+use libfuzzer_sys::fuzz_target;
+use midi2::Sysex;
+use rand::{Rng, SeedableRng};
+
+struct FixedSizeBuffer<U: midi2::buffer::Unit>(Vec<U>);
+
+impl<U: midi2::buffer::Unit> midi2::buffer::Buffer for FixedSizeBuffer<U> {
+    type Unit = U;
+    fn buffer(&self) -> &[Self::Unit] {
+        &self.0
+    }
+}
+
+impl<U: midi2::buffer::Unit> midi2::buffer::BufferMut for FixedSizeBuffer<U> {
+    fn buffer_mut(&mut self) -> &mut [Self::Unit] {
+        &mut self.0
+    }
+}
+
+impl<U: midi2::buffer::Unit> midi2::buffer::BufferTryResize for FixedSizeBuffer<U> {
+    fn try_resize(&mut self, new_size: usize) -> Result<(), midi2::error::BufferOverflow> {
+        if new_size > self.0.len() {
+            return Err(midi2::error::BufferOverflow);
+        }
+        Ok(())
+    }
+}
+
+impl<U: midi2::buffer::Unit> FixedSizeBuffer<U> {
+    fn new(size: usize) -> Self {
+        Self(std::iter::repeat_n(U::zero(), size).collect())
+    }
+}
+
+#[derive(arbitrary::Arbitrary, Debug)]
+struct InputData {
+    seed: u64,
+    initial_data: Vec<u8>,
+    data_to_insert: Vec<u8>,
+}
+
+const MAX_BUFFER_SIZE: usize = 1024;
+
+trait IntoByte<B> {
+    fn byte(&self) -> B;
+}
+
+impl IntoByte<midi2::ux::u7> for u8 {
+    fn byte(&self) -> midi2::ux::u7 {
+        midi2::num::u7::new(self & 0x7F)
+    }
+}
+
+impl IntoByte<u8> for u8 {
+    fn byte(&self) -> u8 {
+        *self
+    }
+}
+
+fn test_case<B, M>(data: &InputData, mut message: M, index: usize)
+where
+    B: midi2::buffer::Buffer + midi2::buffer::BufferTryResize + midi2::buffer::BufferMut,
+    M: midi2::Sysex<B>,
+    <M as Sysex<B>>::Byte: Eq + core::fmt::Debug,
+    u8: IntoByte<<M as Sysex<B>>::Byte>,
+{
+    let Ok(()) = message.try_set_payload(data.initial_data.iter().map(u8::byte)) else {
+        return;
+    };
+
+    {
+        let initial = message.payload().collect::<Vec<_>>();
+        assert_eq!(
+            initial,
+            data.initial_data.iter().map(u8::byte).collect::<Vec<_>>()
+        );
+    }
+
+    let Ok(()) = message.try_insert_payload(data.data_to_insert.iter().map(u8::byte), index) else {
+        return;
+    };
+
+    let actual = message.payload().collect::<Vec<_>>();
+    let expected = {
+        let mut ret = data.initial_data.clone();
+        ret.splice(index..index, data.data_to_insert.clone());
+        ret.iter().map(u8::byte).collect::<Vec<_>>()
+    };
+    assert_eq!(actual, expected);
+}
+
+fuzz_target!(|data: InputData| {
+    let mut rng = rand::rngs::StdRng::seed_from_u64(data.seed);
+    let fized_size_buffer_size = rng.random_range(4..MAX_BUFFER_SIZE);
+    let index = if data.initial_data.is_empty() {
+        0
+    } else {
+        rng.random_range(0..data.initial_data.len())
+    };
+    test_case(
+        &data,
+        midi2::sysex8::Sysex8::<FixedSizeBuffer<u32>>::try_new_with_buffer(
+            FixedSizeBuffer::<u32>::new(fized_size_buffer_size),
+        )
+        .unwrap(),
+        index,
+    );
+    test_case(
+        &data,
+        midi2::sysex7::Sysex7::<FixedSizeBuffer<u32>>::try_new_with_buffer(
+            FixedSizeBuffer::<u32>::new(fized_size_buffer_size),
+        )
+        .unwrap(),
+        index,
+    );
+    test_case(
+        &data,
+        midi2::sysex7::Sysex7::<FixedSizeBuffer<u8>>::try_new_with_buffer(
+            FixedSizeBuffer::<u8>::new(fized_size_buffer_size),
+        )
+        .unwrap(),
+        index,
+    );
+});

midi2/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "midi2"
-version = "0.8.2"
+version = "0.9.0"
 description = "Ergonomic, versatile, strong types wrapping MIDI 2.0 message data."
 edition = "2021"
 readme = "README.md"
@@ -10,10 +10,14 @@ authors = [
 ]
 repository = "https://github.com/midi2-dev/bl-midi2-rs.git"
 
+[lints.clippy]
+# packet indexing causes false positives
+manual_div_ceil = "allow"
+
 [dependencies]
 derive_more = { version = "2.0.1", features = ["from"], default-features = false }
 fixed = "1.28.0"
-midi2_proc = { version = "0.8.2", path = "../midi2_proc" }
+midi2_proc = { version = "0.9.0", path = "../midi2_proc" }
 ux = "0.1.6"
 
 [dev-dependencies]

midi2/src/detail/helpers.rs

@@ -89,15 +89,16 @@ pub fn validate_sysex_group_statuses<
     Ok(())
 }
 
-pub fn try_set_sysex_data<
+pub fn try_insert_sysex_data<
     B: crate::buffer::Buffer + crate::buffer::BufferMut + crate::buffer::BufferTryResize,
     S: SysexInternal<B>,
     D: core::iter::Iterator<Item = <S as crate::traits::Sysex<B>>::Byte>,
 >(
     sysex: &mut S,
     data: D,
+    before: usize,
 ) -> core::result::Result<(), crate::error::BufferOverflow> {
-    match detail::try_set_sysex_data(sysex, data, |s, sz| s.try_resize(sz)) {
+    match detail::try_insert_sysex_data(sysex, data, |s, sz| s.try_resize(sz), before) {
         Err(e) => {
             // if the write failed we reset the message
             // back to zero data
@@ -110,25 +111,33 @@ pub fn try_set_sysex_data<
     }
 }
 
-pub fn set_sysex_data<
+pub fn insert_sysex_data<
     B: crate::buffer::Buffer + crate::buffer::BufferMut + crate::buffer::BufferResize,
     S: SysexInternal<B>,
     D: core::iter::Iterator<Item = <S as crate::traits::Sysex<B>>::Byte>,
 >(
     sysex: &mut S,
     data: D,
+    before: usize,
 ) {
-    detail::try_set_sysex_data(sysex, data, |s, sz| {
-        s.resize(sz);
-        Ok(())
-    })
+    detail::try_insert_sysex_data(
+        sysex,
+        data,
+        |s, sz| {
+            s.resize(sz);
+            Ok(())
+        },
+        before,
+    )
     .expect("Resizable buffers should not fail here")
 }
 
 mod detail {
+    use crate::error::BufferOverflow;
+
     use super::*;
 
-    pub fn try_set_sysex_data<
+    pub fn try_insert_sysex_data<
         B: crate::buffer::Buffer + crate::buffer::BufferMut,
         S: crate::traits::SysexInternal<B>,
         D: core::iter::Iterator<Item = <S as crate::traits::Sysex<B>>::Byte>,
@@ -137,8 +146,14 @@ mod detail {
         sysex: &mut S,
         data: D,
         resize: R,
+        before: usize,
     ) -> core::result::Result<(), crate::error::BufferOverflow> {
+        // reformat first to ensure data is optimally filling the
+        // underlying buffer
+        sysex.compact();
+
         // get an initial estimate for the size of the data
+        let initial_size = sysex.payload_size();
         let mut running_data_size_estimate = match data.size_hint() {
             (_, Some(upper)) => upper,
             // not the optimal case - could lead to additional copying
@@ -149,45 +164,62 @@ mod detail {
         let mut data = data.peekable();
 
         // initial buffer resize
-        if let Err(SysexTryResizeError(sz)) = resize(sysex, running_data_size_estimate) {
+        if let Err(SysexTryResizeError(sz)) =
+            resize(sysex, running_data_size_estimate + initial_size)
+        {
             // failed. we'll work with what we've got
-            running_data_size_estimate = sz;
+            running_data_size_estimate = sz.saturating_sub(initial_size);
         };
 
+        debug_assert_eq!(
+            sysex.payload_size(),
+            running_data_size_estimate + initial_size
+        );
+
+        let mut tail = before + running_data_size_estimate;
+        sysex.move_payload_tail(before, tail);
+
         'main: loop {
             while written < running_data_size_estimate {
                 match data.next() {
                     Some(v) => {
-                        sysex.write_datum(v, written);
+                        sysex.write_datum(v, before + written);
                         written += 1;
                     }
                     None => {
                         break 'main;
                     }
                 }
             }
-            assert_eq!(written, running_data_size_estimate);
+            debug_assert_eq!(written, running_data_size_estimate);
+
+            if data.peek().is_none() {
+                // done
+                break;
+            }
 
             // we underestimated.
             // resize to make more space
             running_data_size_estimate += additional_size_for_overflow;
+            if let Err(SysexTryResizeError(sz)) =
+                resize(sysex, running_data_size_estimate + initial_size)
+            {
+                // failed. we'll work with what we've got
+                running_data_size_estimate = sz.saturating_sub(initial_size);
+            };
+            sysex.move_payload_tail(tail, before + running_data_size_estimate);
+            tail = before + running_data_size_estimate;
             additional_size_for_overflow *= 2;
 
-            if data.peek().is_some() {
-                if let Err(SysexTryResizeError(sz)) = resize(sysex, running_data_size_estimate) {
-                    // failed. we'll work with what we've got
-                    running_data_size_estimate = sz;
-                };
-            }
-
             if written >= running_data_size_estimate {
-                return Err(Default::default());
+                return Err(BufferOverflow);
             }
         }
 
         if written < running_data_size_estimate {
             // we shrink the buffer back down to the correct size
-            resize(sysex, written).map_err(|_| crate::error::BufferOverflow)?;
+            sysex.move_payload_tail(tail, before + written);
+            resize(sysex, written + initial_size).map_err(|_| crate::error::BufferOverflow)?;
         }
 
         Ok(())