Even smarter. No stream meta stored but just the ranges for each channel.

src/rt/simpleclip.rs

@@ -43,41 +43,43 @@ impl SimpleClipDetector {
         smgr.addInQueue(tx);
         rayon::spawn(
             move || {
-                let mut streammeta: Option<Arc<StreamMetaData>> = None;
+                let mut mins = vec![];
+                let mut maxs = vec![];
+                let mut ranges = vec![];
                 loop {
                     if let Ok(msg) = rx.recv_timeout(Duration::from_millis(1500)) {
                         match msg {
                             InStreamMsg::StreamStarted(meta) => {
-                                streammeta = Some(meta);
+                                mins.resize(meta.nchannels(), 0.);
+                                maxs.resize(meta.nchannels(), 0.);
+                                ranges = meta.channelInfo.iter().map(|ch| ch.range).collect();
                             }
                             InStreamMsg::InStreamData(dat) => {
-                                let meta = streammeta
-                                    .as_ref()
-                                    .expect("If we are here, stream metadata should be available");
                                 let flt = dat.getFloatData();
-                                let maxs = flt
+                                // Update channel maximum values
-                                    .columns()
+                                flt.columns()
                                     .into_iter()
-                                    .map(|col| max(col))
+                                    .zip(maxs.iter_mut())
-                                    .collect::<Vec<_>>();
+                                    .for_each(|(coli, maxi)| *maxi = max(coli));
-                                let mins = flt
+                                // Update channel minimum values
-                                    .columns()
+                                flt.columns()
                                     .into_iter()
-                                    .map(|col| min(col))
+                                    .zip(mins.iter_mut())
-                                    .collect::<Vec<_>>();
+                                    .for_each(|(coli, mini)| *mini = min(coli));
 
-                                maxs.into_iter().zip(mins).zip(&meta.channelInfo).for_each(
+                                // Compare minima and maxima against clip limits
-                                    |((max, min), ch)| {
+                                maxs.iter().zip(mins.iter()).zip(ranges.iter()).for_each(
-                                        let min_for_clip = CLIP_REL_LIMIT * ch.range.0;
+                                    |((max, min), range)| {
-                                        let max_for_clip = CLIP_REL_LIMIT * ch.range.1;
+                                        let min_for_clip = CLIP_REL_LIMIT * range.0;
-                                        if max >= max_for_clip {
+                                        let max_for_clip = CLIP_REL_LIMIT * range.1;
+                                        if *max >= max_for_clip {
                                             clipstate.store(true, Relaxed);
                                             // We do not have to do anything anymore. The signal
                                             // has clipped so we do not have to check any new
                                             // blocks anymore.
                                             return;
                                         }
-                                        if min <= min_for_clip {
+                                        if *min <= min_for_clip {
                                             clipstate.store(true, Relaxed);
                                             // We do not have to do anything anymore. The signal
                                             // has clipped so we do not have to check any new