use ArrayRef as much as possible instead of ArrayView, ArrayViewMut

Author: Sytronik

src-tauri/src/core/audio.rs

@@ -53,9 +53,9 @@ impl Audio {
         stat_calculator: &mut StatCalculator,
         guard_clipping_mode: GuardClippingMode,
     ) where
-        F: Fn(ArrayViewMut2<f32>),
+        F: Fn(&mut ArrayRef2<f32>),
     {
-        f(self.wavs.view_mut());
+        f(&mut self.wavs);
         let guard_clip_result = self.guard_clipping(guard_clipping_mode);
         self.guard_clip_stats = (&guard_clip_result).into();
         self.guard_clip_result = guard_clip_result;
@@ -168,7 +168,7 @@ impl GuardClipping<Ix2> for Audio {
         let gain_seq = if peak > 1. {
             let gain_seq = LIMITER_MANAGER.with_borrow_mut(|manager| {
                 let limiter = manager.get_or_insert(self.sr);
-                limiter.process_inplace(self.wavs.view_mut())
+                limiter.process_inplace(&mut self.wavs)
             });
             gain_seq.into_shape_with_order(gain_shape).unwrap()
         } else {

src-tauri/src/core/dynamics/decibel.rs

@@ -27,7 +27,7 @@ where
     A: Float + MaybeNan,
     <A as MaybeNan>::NotNan: Ord,
 {
-    fn into_value<D: Dimension>(self, data_for_max: ArrayView<A, D>) -> A {
+    fn into_value<D: Dimension>(self, data_for_max: &ArrayRef<A, D>) -> A {
         match self {
             DeciBelRef::Value(v) => {
                 debug_assert!(v.is_sign_positive());
@@ -66,7 +66,7 @@ where
     fn log_for_dB(&self, reference: DeciBelRef<Self::A>, amin: Self::A) -> Self {
         debug_assert!(amin.is_sign_positive());
         let temp = [*self];
-        let ref_value = reference.into_value(temp[..].into());
+        let ref_value = reference.into_value(&ArrayView1::from(&temp[..]));
         if ref_value.is_nan() || ref_value.is_sign_negative() {
             return A::nan();
         }
@@ -169,7 +169,7 @@ where
     type A = A;
     fn log_for_dB_inplace(&mut self, reference: DeciBelRef<A>, amin: A) {
         debug_assert!(amin.is_sign_positive());
-        let ref_value = reference.into_value(self.view());
+        let ref_value = reference.into_value(self);
         if ref_value.is_nan() {
             return;
         } else if ref_value.is_sign_negative() {

src-tauri/src/core/dynamics/limiter.rs

@@ -89,10 +89,10 @@ impl PerfectLimiter {
     }
 
     /// process one sample, and returns (delayed_output, gain)
-    pub fn _step(&mut self, frame: ArrayView1<f32>) -> (Array1<f32>, f32) {
+    pub fn _step(&mut self, frame: &ArrayRef1<f32>) -> (Array1<f32>, f32) {
         let mut delayed = self.buffer.slice(s![self.i_buf, ..]).to_owned();
         let gain = self.calc_gain(frame);
-        azip!((y in &mut self.buffer.slice_mut(s![self.i_buf, ..]), x in &frame) *y = *x as f64);
+        azip!((y in &mut self.buffer.slice_mut(s![self.i_buf, ..]), x in frame) *y = *x as f64);
         self.i_buf = (self.i_buf + 1) % self.buffer.shape()[0];
         // println!("i={} d={} g={}", value, delayed, gain);
         delayed *= gain;
@@ -107,7 +107,7 @@ impl PerfectLimiter {
     }
 
     /// apply limiter to wav inplace , return gain array. parallel over channel axis (=Axis(0))
-    pub fn process_inplace(&mut self, mut wavs: ArrayViewMut2<f32>) -> Array1<f32> {
+    pub fn process_inplace(&mut self, wavs: &mut ArrayRef2<f32>) -> Array1<f32> {
         self.reset(0);
 
         let zero = Array1::zeros(wavs.shape()[0]);
@@ -116,7 +116,7 @@ impl PerfectLimiter {
             wavs.lanes(Axis(0)),
             itertools::repeat_n(zero.view(), attack),
         )
-        .map(|x| self.calc_gain(x))
+        .map(|x| self.calc_gain(&x))
         .skip(attack)
         .collect();
 
@@ -136,13 +136,13 @@ impl PerfectLimiter {
 
     /// apply limiter to wav, return (output, gain array)
     #[inline]
-    pub fn _process(&mut self, wavs: ArrayView2<f32>) -> (Array2<f32>, Array1<f32>) {
+    pub fn _process(&mut self, wavs: &ArrayRef2<f32>) -> (Array2<f32>, Array1<f32>) {
         let mut out = wavs.to_owned();
-        let gain_seq = self.process_inplace(out.view_mut());
+        let gain_seq = self.process_inplace(&mut out);
         (out, gain_seq)
     }
 
-    fn calc_gain(&mut self, frame: ArrayView1<f32>) -> f64 {
+    fn calc_gain(&mut self, frame: &ArrayRef1<f32>) -> f64 {
         // max abs over all channels
         let v_abs = frame.iter().map(|x| x.abs()).reduce(f32::max).unwrap() as f64;
         let raw_gain = if v_abs > self.threshold {
@@ -208,7 +208,7 @@ impl SimpleLimiter {
         }
     }
 
-    pub fn process_inplace(&mut self, mut wav: ArrayViewMut1<f32>) {
+    pub fn process_inplace(&mut self, wav: &mut ArrayRef1<f32>) {
         let mut delay_index = 0;
         let mut gain = 1.;
         let mut envelope = 0.;
@@ -236,9 +236,9 @@ impl SimpleLimiter {
         }
     }
 
-    pub fn process(&mut self, wav: ArrayView1<f32>) -> Array1<f32> {
+    pub fn process(&mut self, wav: &ArrayRef1<f32>) -> Array1<f32> {
         let mut out = wav.to_owned();
-        self.process_inplace(out.view_mut());
+        self.process_inplace(&mut out);
         out
     }
 }
@@ -268,7 +268,7 @@ mod tests {
         let (mut wavs, format_info) = open_audio_file(path).unwrap();
         let mut limiter = PerfectLimiter::new(format_info.sr, 1., 5., 15., 40.);
         wavs *= 8.;
-        let gain_seq = limiter.process_inplace(wavs.view_mut());
+        let gain_seq = limiter.process_inplace(&mut wavs);
         assert!(
             gain_seq.iter().all(|x| (0.0..=1.0).contains(x)),
             "cnt of gain>1: {}, cnt of gain<0: {}",

src-tauri/src/core/dynamics/stats.rs

@@ -1,8 +1,8 @@
 use std::fmt::{self, Display};
 
 use ebur128::{EbuR128, Mode as LoudnessMode};
+use ndarray::RemoveAxis;
 use ndarray::prelude::*;
-use ndarray::{Data, RemoveAxis};
 use ndarray_stats::MaybeNan;
 use num_traits::{AsPrimitive, Float};
 use rayon::prelude::*;
@@ -71,9 +71,8 @@ pub trait MaxPeak<A> {
     fn max_peak(&self) -> A;
 }
 
-impl<S, D> MaxPeak<f64> for ArrayBase<S, D>
+impl<D> MaxPeak<f64> for ArrayRef<f64, D>
 where
-    S: Data<Elem = f64>,
     D: Dimension,
 {
     fn max_peak(&self) -> f64 {
@@ -82,9 +81,8 @@ where
     }
 }
 
-impl<S, D> MaxPeak<f32> for ArrayBase<S, D>
+impl<D> MaxPeak<f32> for ArrayRef<f32, D>
 where
-    S: Data<Elem = f32>,
     D: Dimension,
 {
     fn max_peak(&self) -> f32 {
@@ -116,11 +114,11 @@ impl Display for GuardClippingStats {
 }
 
 impl GuardClippingStats {
-    pub fn from_wav_before_clip<'a, A, D>(wav_before_clip: ArrayView<'a, A, D>) -> Self
+    pub fn from_wav_before_clip<A, D>(wav_before_clip: &ArrayRef<A, D>) -> Self
     where
         A: Float + AsPrimitive<f32> + DeciBel,
         D: Dimension,
-        ArrayView<'a, A, D>: MaxPeak<A>,
+        ArrayRef<A, D>: MaxPeak<A>,
     {
         let max_peak = wav_before_clip.max_peak();
         if max_peak > A::one() {
@@ -143,13 +141,12 @@ impl GuardClippingStats {
         }
     }
 
-    pub fn from_gain_seq<'a, A, S, D>(gain_seq: ArrayView<'a, A, D>) -> Self
+    pub fn from_gain_seq<A, D>(gain_seq: &ArrayRef<A, D>) -> Self
     where
         A: Float + MaybeNan + DeciBel + AsPrimitive<f32>,
         <A as MaybeNan>::NotNan: Ord,
-        S: Data<Elem = A>,
         D: Dimension,
-        ArrayView<'a, A, D>: MinSIMD<A, S, D>,
+        ArrayRef<A, D>: MinSIMD<A, D>,
     {
         GuardClippingStats {
             max_reduction_gain_dB: gain_seq.min_simd().dB_from_amp_default().as_(),
@@ -168,7 +165,7 @@ impl<D: Dimension + RemoveAxis> From<&GuardClippingResult<D>>
                 let vec = before_clip
                     .axis_iter(Axis(0))
                     .into_par_iter()
-                    .map(GuardClippingStats::from_wav_before_clip)
+                    .map(|x| GuardClippingStats::from_wav_before_clip(&x))
                     .collect();
                 Array::from_shape_vec(raw_dim.remove_axis(Axis(raw_dim.ndim() - 1)), vec).unwrap()
             }
@@ -181,7 +178,7 @@ impl<D: Dimension + RemoveAxis> From<&GuardClippingResult<D>>
                 let vec = gain_seq
                     .axis_iter(Axis(0))
                     .into_par_iter()
-                    .map(GuardClippingStats::from_gain_seq)
+                    .map(|x| GuardClippingStats::from_gain_seq(&x))
                     .collect();
                 Array::from_shape_vec(raw_dim.remove_axis(Axis(raw_dim.ndim() - 1)), vec).unwrap()
             }

src-tauri/src/core/mod.rs

@@ -152,7 +152,7 @@ impl TrackManager {
             .par_extend(id_ch_tuples.into_par_iter().map(|(id, ch)| {
                 let track = &tracklist[id];
                 let spec = self.spec_analyzer.calc_spec(
-                    track.channel(ch),
+                    &track.channel(ch),
                     track.sr(),
                     &self.setting,
                     parallel,
@@ -211,7 +211,7 @@ impl TrackManager {
                         spec.shape()[1],
                     );
                     let spec_img = visualize::convert_spectrogram_to_img(
-                        spec.view(),
+                        spec,
                         i_freq_range,
                         (self.min_dB, self.max_dB),
                         Some(self.colormap_length),

src-tauri/src/core/simd.rs

@@ -8,7 +8,7 @@ use std::arch::is_x86_feature_detected;
 use std::arch::x86_64::*;
 
 use itertools::Itertools;
-use ndarray::{ArrayBase, Data, DataMut, Dimension};
+use ndarray::{ArrayBase, ArrayRef, DataMut, Dimension};
 use ndarray_stats::QuantileExt;
 
 pub fn find_min_max(slice: &[f32]) -> (f32, f32) {
@@ -55,27 +55,24 @@ pub fn find_min(slice: &[f32]) -> f32 {
     find_min_scalar(slice)
 }
 
-pub trait MinSIMD<A, S, D>
+pub trait MinSIMD<A, D>
 where
-    S: Data<Elem = A>,
     D: Dimension,
 {
     fn min_simd(&self) -> A;
 }
 
-impl<S, D> MinSIMD<f32, S, D> for ArrayBase<S, D>
+impl<D> MinSIMD<f32, D> for ArrayRef<f32, D>
 where
-    S: Data<Elem = f32>,
     D: Dimension,
 {
     fn min_simd(&self) -> f32 {
-        find_min(self.as_slice_memory_order().unwrap())
+        find_min(self.as_slice_memory_order().unwrap_or_default())
     }
 }
 
-impl<S, D> MinSIMD<f64, S, D> for ArrayBase<S, D>
+impl<D> MinSIMD<f64, D> for ArrayRef<f64, D>
 where
-    S: Data<Elem = f64>,
     D: Dimension,
 {
     fn min_simd(&self) -> f64 {

src-tauri/src/core/spectrogram.rs

@@ -186,7 +186,7 @@ impl SpectrogramAnalyzer {
 
     pub fn calc_spec(
         &self,
-        wav: ArrayView1<f32>,
+        wav: &ArrayRef1<f32>,
         sr: u32,
         setting: &SpecSetting,
         parallel: bool,

src-tauri/src/core/spectrogram/stft.rs

@@ -14,7 +14,7 @@ use super::super::windows::{WindowType, calc_normalized_win};
 use realfft::{RealFftPlanner, RealToComplex};
 
 pub fn perform_stft<'a, A>(
-    input: ArrayView1<A>,
+    input: &ArrayRef1<A>,
     win_length: usize,
     hop_length: usize,
     n_fft: usize,
@@ -35,7 +35,7 @@ where
     let to_frames_wrapper = move |x| {
         let n_pad_left = (n_fft - win_length) / 2;
         let n_pad_right = n_fft - win_length - n_pad_left;
-        to_windowed_frames(x, window.view(), hop_length, (n_pad_left, n_pad_right))
+        to_windowed_frames(x, &window, hop_length, (n_pad_left, n_pad_right))
     };
 
     let fft_module = fft_module
@@ -49,7 +49,7 @@ where
 
     if input.len() < win_length {
         let padded = input.pad((win_length / 2, win_length / 2), Axis(0), PadMode::Reflect);
-        let mut frames = to_frames_wrapper(padded.view());
+        let mut frames = to_frames_wrapper(&padded);
 
         let n_frames = frames.len();
         let mut output = Array2::<Complex<A>>::zeros((n_frames, n_fft / 2 + 1));
@@ -78,10 +78,11 @@ where
         input
             .slice(s![..(win_length - 1)])
             .pad((win_length / 2, 0), Axis(0), PadMode::Reflect);
-    let mut front_frames = to_frames_wrapper(front_wav.view());
+    let mut front_frames = to_frames_wrapper(&front_wav);
 
     let mut first_i = front_frames.len() * hop_length - win_length / 2;
-    let mut frames = to_frames_wrapper(input.slice(s![first_i..]));
+    let mid_wav = input.slice(s![first_i..]);
+    let mut frames = to_frames_wrapper(&mid_wav);
 
     first_i += frames.len() * hop_length;
     let i_back_wav_start = first_i.min(input.len() - win_length / 2 - 1);
@@ -91,7 +92,7 @@ where
             .slice(s![i_back_wav_start..])
             .pad((0, win_length / 2), Axis(0), PadMode::Reflect);
     back_wav.slice_collapse(s![(first_i - i_back_wav_start).max(0)..]);
-    let mut back_frames = to_frames_wrapper(back_wav.view());
+    let mut back_frames = to_frames_wrapper(&back_wav);
 
     let n_frames = front_frames.len() + frames.len() + back_frames.len();
     let mut output = Array2::<Complex<A>>::zeros((n_frames, n_fft / 2 + 1));
@@ -124,8 +125,8 @@ where
 
 #[inline]
 fn to_windowed_frames<A: Float>(
-    input: ArrayView1<A>,
-    window: ArrayView1<A>,
+    input: &ArrayRef1<A>,
+    window: &ArrayRef1<A>,
     hop_length: usize,
     (n_pad_left, n_pad_right): (usize, usize),
 ) -> Vec<Array1<A>> {
@@ -173,7 +174,7 @@ mod tests {
     fn stft_works() {
         let impulse = Array1::<f32>::impulse(4, 2);
         assert_eq!(
-            perform_stft(impulse.view(), 4, 2, 4, None, None, false),
+            perform_stft(&impulse, 4, 2, 4, None, None, false),
             arr2(&[
                 [
                     Complex::<f32>::new(0., 0.),
@@ -197,7 +198,7 @@ mod tests {
     #[test]
     fn stft_short_wav() {
         let impulse = Array1::<f32>::impulse(2, 1);
-        let spec = perform_stft(impulse.view(), 8, 6, 8, None, None, false);
+        let spec = perform_stft(&impulse, 8, 6, 8, None, None, false);
         dbg!(spec.shape());
     }
 }

src-tauri/src/core/utils.rs

@@ -5,7 +5,7 @@ use std::path::{self, Path, PathBuf};
 use identity_hash::IntMap;
 use itertools::Itertools;
 use ndarray::prelude::*;
-use ndarray::{Data, OwnedRepr, RemoveAxis};
+use ndarray::{OwnedRepr, RemoveAxis};
 use num_traits::Num;
 
 pub fn unique_filenames(paths: IntMap<usize, PathBuf>) -> IntMap<usize, String> {
@@ -74,10 +74,9 @@ pub trait Pad<A> {
     fn pad(&self, n_pads: (usize, usize), axis: Axis, mode: PadMode<A>) -> Self::WithOwnedA;
 }
 
-impl<A, S, D> Pad<A> for ArrayBase<S, D>
+impl<A, D> Pad<A> for ArrayRef<A, D>
 where
     A: Copy,
-    S: Data<Elem = A>,
     D: Dimension + RemoveAxis,
 {
     type WithOwnedA = ArrayBase<OwnedRepr<A>, D>;
@@ -146,9 +145,8 @@ pub trait Planes<A> {
     fn planes(&self) -> Vec<&[A]>;
 }
 
-impl<A, S, D> Planes<A> for ArrayBase<S, D>
+impl<A, D> Planes<A> for ArrayRef<A, D>
 where
-    S: Data<Elem = A>,
     D: Dimension + RemoveAxis,
 {
     fn planes(&self) -> Vec<&[A]> {

src-tauri/src/core/visualize/drawing.rs

@@ -2,7 +2,7 @@ use ndarray::prelude::*;
 
 #[allow(non_snake_case)]
 pub fn convert_spectrogram_to_img(
-    spec: ArrayView2<f32>,
+    spec: &ArrayRef2<f32>,
     i_freq_range: (usize, usize),
     dB_range: (f32, f32),
     colormap_length: Option<u32>,