From 8be1d4b0df1804be76e4f9d2b3c6164286103306 Mon Sep 17 00:00:00 2001
From: Michael Sippel <micha@fragmental.art>
Date: Fri, 26 Apr 2024 15:16:28 +0200
Subject: [PATCH] wip jack input

---
 Cargo.toml  |   1 +
 src/jack.rs | 118 ++++++++++++++++++++++++++++++++++++++++++++++++++++
 src/main.rs |   3 +-
 3 files changed, 121 insertions(+), 1 deletion(-)
 create mode 100644 src/jack.rs

diff --git a/Cargo.toml b/Cargo.toml
index 480e780..8eb0917 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -9,6 +9,7 @@ softbuffer = "0.4.2"
 cgmath = "*"
 prisma = "0.1.1"
 angular-units = "*"
+jack = "0.11"
 
 [dependencies.async-std]
 version = "1.9.0"
diff --git a/src/jack.rs b/src/jack.rs
new file mode 100644
index 0000000..73431e7
--- /dev/null
+++ b/src/jack.rs
@@ -0,0 +1,118 @@
+use std::sync::{Arc, RwLock};
+use crate::Inputs;
+
+/*
+
+
+            Arc<
+                dyn Fn(&jack::Client, &jack::ProcessScope) -> jack::Control
+                + Send + Sync
+            >
+    let mut audio_val = Arc::new(RwLock::<f32>::new(0.0));
+
+    // Jack
+    // Create client
+    let (jack_client, _status) =
+        jack::Client::new("ledmatrix_visualizer", jack::ClientOptions::NO_START_SERVER).unwrap();
+
+        // Register ports. They will be used in a callback that will be
+        // called when new data is available.
+        let in_a = jack_client
+            .register_port("in", jack::AudioIn::default())
+            .unwrap();
+
+    let av = audio_val.clone();
+        let process_callback = move |_: &jack::Client, ps: &jack::ProcessScope| -> jack::Control {
+            let in_a_p = in_a.as_slice(ps);
+
+            /* FFT
+            let mut input:  Vec<Complex<f32>> = in_a_p.iter().map(|y| Complex::from(y)).collect::<Vec<Complex<f32>>>();
+            let fft = Radix4::new(input.len(), false);
+            fft.process(&mut input, &mut cur_spectrum.write().unwrap());
+
+             *v.get_mut() = in_a_p.iter().sum::<f32>() / 2048.0;
+             */
+
+            let mut sum = 0.0 as f32;
+            let b = 0.025 as f32;
+            for i in 1 .. in_a_p.len() {
+                sum += (b * in_a_p[i] + (1.0 - b) * in_a_p[i-1]).abs()
+            }
+
+            *av.write().unwrap() = sum / in_a_p.len() as f32;
+
+            jack::Control::Continue
+        };
+
+        let process = jack::ClosureProcessHandler::new(process_callback);
+
+    // Activate the client, which starts the processing.
+    let active_client = jack_client.activate_async((), process).unwrap();
+    
+    let mut stream : Option<TcpStream> = TcpStream::connect("192.168.4.1:6789").ok();
+            
+*/
+
+
+/*
+pub fn init_jack( inputs: Arc<RwLock< Inputs >> )
+-> jack::AsyncClient<
+        (),
+        jack::ClosureProcessHandler<
+            Arc<
+                dyn FnMut(&jack::Client, &jack::ProcessScope) -> jack::Control
+                + Send + Sync
+            >
+        >
+   >
+{
+    // Jack
+    // Create client
+    let (jack_client, _status) =
+        jack::Client::new("FragmentalLightControl", jack::ClientOptions::NO_START_SERVER).unwrap();
+
+        // Register ports. They will be used in a callback that will be
+        // called when new data is available.
+        let in_a = jack_client
+            .register_port("in", jack::AudioIn::default())
+            .unwrap();
+
+    let av = audio_val.clone();
+
+        let process_callback = move |_: &jack::Client, ps: &jack::ProcessScope| -> jack::Control {
+            let in_a_p = in_a.as_slice(ps);
+
+            /* FFT
+            let mut input:  Vec<Complex<f32>> = in_a_p.iter().map(|y| Complex::from(y)).collect::<Vec<Complex<f32>>>();
+            let fft = Radix4::new(input.len(), false);
+            fft.process(&mut input, &mut cur_spectrum.write().unwrap());
+
+             *v.get_mut() = in_a_p.iter().sum::<f32>() / 2048.0;
+             */
+
+            let mut sum = 0.0 as f32;
+            let b = 0.025 as f32;
+            for i in 1 .. in_a_p.len() {
+                sum += (b * in_a_p[i] + (1.0 - b) * in_a_p[i-1]).abs()
+            }
+
+            *av.write().unwrap() = sum / in_a_p.len() as f32;
+
+            jack::Control::Continue
+        };
+
+        let process = jack::ClosureProcessHandler::new(
+        
+            Arc::new(process_callback) as   
+            Arc<
+                dyn FnMut(&jack::Client, &jack::ProcessScope) -> jack::Control
+                + Send + Sync
+            >
+        );
+
+    // Activate the client, which starts the processing.
+    jack_client.activate_async((), process).unwrap()
+}
+
+*/
+
diff --git a/src/main.rs b/src/main.rs
index 12f7da3..adb4d31 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,5 +1,5 @@
 extern crate angular_units as angle;
-   
+
 use {
     std::num::NonZeroU32,
     std::sync::{Arc, RwLock, Mutex},
@@ -18,6 +18,7 @@ mod fixture;
 mod setup;
 mod view;
 mod stripe_driver;
+mod jack;
 
 use crate::{
     view::ColorGrid,