First attempt at interpolation

audio_engine/src/main.rs

@@ -51,6 +51,9 @@ use track::Track;
 use track::TrackState;
 use track_matrix::TrackMatrix;
 
+const COLS: usize = 5;
+const ROWS: usize = 5;
+
 pub struct JackPorts {
     pub audio_in: jack::Port<jack::AudioIn>,
     pub audio_out: jack::Port<jack::AudioOut>,
@@ -66,10 +69,6 @@ async fn main() {
         .init()
         .expect("Could not initialize logger");
 
-    let (mut osc, osc_controller) = Osc::new(&args.socket)
-        .await
-        .expect("Could not create OSC server");
-
     let (jack_client, ports) = setup_jack();
 
     let mut allocator = Allocator::spawn(jack_client.sample_rate(), 3);
@@ -84,11 +83,19 @@ async fn main() {
         PersistenceManager::new(&args, notification_handler.subscribe());
     let state = persistence_manager.state();
 
+    // Calculate tempo from state and jack client
+    let tempo_bpm = (jack_client.sample_rate() as f32 * 60.0) 
+                    / state.borrow().metronome.frames_per_beat as f32;
+
+    let (mut osc, osc_controller) = Osc::new(&args.socket, COLS, ROWS, tempo_bpm)
+        .await
+        .expect("Could not create OSC server");
+
     // Create post-record handler and get controller for ProcessHandler
     let (mut post_record_handler, post_record_controller) =
         PostRecordHandler::new(&args).expect("Could not create post-record handler");
 
-    let process_handler = ProcessHandler::new(
+    let process_handler = ProcessHandler::<_, COLS, ROWS>::new(
         &jack_client,
         ports,
         allocator,
@@ -183,4 +190,4 @@ fn setup_jack() -> (jack::Client, JackPorts) {
     };
 
     (jack_client, ports)
-}
+}

audio_engine/src/midi.rs

@@ -1,8 +1,8 @@
 use crate::*;
 
 /// Process MIDI events
-pub fn process_events<F: ChunkFactory>(
-    process_handler: &mut ProcessHandler<F>,
+pub fn process_events<F: ChunkFactory, const COLS: usize, const ROWS: usize>(
+    process_handler: &mut ProcessHandler<F, COLS, ROWS>,
     ps: &jack::ProcessScope,
 ) -> Result<()> {
     // First, collect all MIDI events into a fixed-size array

audio_engine/src/osc_server/server.rs

@@ -11,8 +11,13 @@ pub struct Osc {
 }
 
 impl Osc {
-    /// Create new OSC server and controller with same interface as before
-    pub async fn new(socket_path: &str) -> Result<(Self, OscController)> {
+    /// Create new OSC server and controller with configurable matrix size and tempo
+    pub async fn new(
+        socket_path: &str,
+        columns: usize,
+        rows: usize,
+        tempo: f32,
+    ) -> Result<(Self, OscController)> {
         // Create platform listener (server)
         let listener = osc_server::platform::create_listener(socket_path).await?;
 
@@ -27,7 +32,7 @@ impl Osc {
             receiver,
             listener,
             broadcaster,
-            shadow_state: osc::State::new(5, 5), // Default 5x5 matrix
+            shadow_state: osc::State::new(columns, rows, tempo),
         };
 
         Ok((server, controller))
@@ -105,4 +110,4 @@ impl Osc {
 
         Ok(())
     }
-}
+}

audio_engine/src/process_handler.rs

@@ -1,9 +1,6 @@
 use crate::*;
 
-const COLS: usize = 5;
-const ROWS: usize = 5;
-
-pub struct ProcessHandler<F: ChunkFactory> {
+pub struct ProcessHandler<F: ChunkFactory, const COLS: usize, const ROWS: usize> {
     post_record_controller: PostRecordController,
     osc: OscController,
     persistence: PersistenceManagerController,
@@ -16,7 +13,7 @@ pub struct ProcessHandler<F: ChunkFactory> {
     sample_rate: usize,
 }
 
-impl<F: ChunkFactory> ProcessHandler<F> {
+impl<F: ChunkFactory, const COLS: usize, const ROWS: usize> ProcessHandler<F, COLS, ROWS> {
     pub fn new(
         client: &jack::Client,
         ports: JackPorts,
@@ -153,7 +150,7 @@ impl<F: ChunkFactory> ProcessHandler<F> {
     }
 }
 
-impl<F: ChunkFactory> jack::ProcessHandler for ProcessHandler<F> {
+impl<F: ChunkFactory, const COLS: usize, const ROWS: usize> jack::ProcessHandler for ProcessHandler<F, COLS, ROWS> {
     fn process(&mut self, _client: &jack::Client, ps: &jack::ProcessScope) -> jack::Control {
         if let Err(e) = self.process_with_error_handling(ps) {
             log::error!("Error processing audio: {}", e);
@@ -164,7 +161,7 @@ impl<F: ChunkFactory> jack::ProcessHandler for ProcessHandler<F> {
     }
 }
 
-impl<F: ChunkFactory> ProcessHandler<F> {
+impl<F: ChunkFactory, const COLS: usize, const ROWS: usize> ProcessHandler<F, COLS, ROWS> {
     fn process_with_error_handling(&mut self, ps: &jack::ProcessScope) -> Result<()> {
         // Process metronome and get beat timing information
         let timing = self.metronome.process(ps, &mut self.ports, &self.osc)?;
@@ -184,4 +181,4 @@ impl<F: ChunkFactory> ProcessHandler<F> {
 
         Ok(())
     }
-}
+}