nsys-signal-utils 0.1.1

Signal processing utilities
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

//! Functions on PCM encoded signal data

pub fn center (samples : &mut [i16]) -> &mut [i16] {
  let Some (max) = samples.iter().max() else { return &mut [] };
  let Some (min) = samples.iter().min() else { return &mut [] };
  let d = -(max + min) / 2;
  for sample in samples.iter_mut() {
    *sample += d;
  }
  samples
}

/// Centers signal before normalizing
pub fn normalize_peak (samples : &mut [i16], to : i16) -> &mut [i16] {
  let safeabs = |i| match i {
    &i16::MIN => i16::MAX,
    i         => i.abs()
  };
  let samples = center (samples);
  let Some (max_abs) = samples.iter().max_by_key (|sample| safeabs (sample)) else {
    debug_assert_eq!(samples.len(), 0);
    return &mut []
  };
  let scale = to.abs() as f64 / *max_abs as f64;
  // TODO: move expect to expression when stabilized
  #[expect(clippy::cast_possible_truncation)]
  for sample in samples.iter_mut() {
    *sample = (scale * *sample as f64) as i16
  }
  samples
}


/// Trim beginning and end of sample values that are zero.
///
/// ```
/// # extern crate signal_utils;
/// # fn main() {
/// # use signal_utils::pcm::trim_silence;
/// let pcm = vec![0, 0, 0, 1, 2, 3, 4, 0, 0];
/// debug_assert_eq!(trim_silence (&pcm[..]), &pcm[3..7]);
/// let pcm = vec![1, 2, 3, 4];
/// debug_assert_eq!(trim_silence (&pcm[..]), &[1, 2, 3, 4]);
/// # }
/// ```
pub fn trim_silence (samples : &[i16]) -> &[i16] {
  let mut start = 0;
  for (i, sample) in samples.iter().enumerate() {
    start = i;
    if *sample != 0 {
      break
    }
  }
  let mut end = samples.len();
  for i in 1..samples.len() {
    let i = samples.len() - i;
    end = i+1;
    if samples[i] != 0 {
      break
    }
  }
  if end <= start {
    start = 0;
    end   = samples.len();
  }
  &(*samples)[start..end]
}

/// Trim beginning and end of samples to first zero crossings.
///
/// ```
/// # extern crate signal_utils;
/// # fn main() {
/// # use signal_utils::pcm::trim_zeros;
/// let pcm = vec![0, 1, 2, -3, -4, 5, 6, 7, -8, 9, -10, -11];
/// debug_assert_eq!(trim_zeros (&pcm[..]), &pcm[0..10]);
/// let pcm = vec![1, 1, 0, 1, 1, 1, 0, 1, 1];
/// debug_assert_eq!(trim_zeros (&pcm[..]), &[0,1,1,1,0]);
/// # }
/// ```
pub fn trim_zeros (samples : &[i16]) -> &[i16] {
  let mut start = 0;
  for i in 0..samples.len()-1 {
    start = i+1;
    if samples[i] == 0 {
      start = i;
      break
    }
    match ((*samples)[i].is_positive(), (*samples)[i+1].is_positive()) {
      (true, false) | (false, true) => break,
      _ => {}
    }
  }
  let mut end = samples.len();
  for i in 1..samples.len() {
    let i = samples.len() - i;
    end = i;
    if samples[i] == 0 {
      break
    }
    match ((*samples)[i].is_positive(), (*samples)[i-1].is_positive()) {
      (true, false) | (false, true) => break,
      _ => {}
    }
  }
  if end <= start {
    start = 0;
    end   = samples.len();
  }
  &(*samples)[start..end]
}