surge-biquad 0.2.12-alpha.0

biquad filters from the surge synthesizer
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
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

/*!
  | Here are some examples of how you could
  | improve the interface for these traits:
  |
  | 1. **Use Rust slices instead of raw
  | pointers.** Rather than using raw pointers for
  | the data inputs and outputs, you could use
  | Rust slices. Slices are a safe and ergonomic
  | way to pass around arrays in Rust, and would
  | make it easier for users to work with the
  | audio data.
  |
  | 2. **Add more safety guarantees.** You could
  | add more safety guarantees to the functions by
  | specifying the size of the data inputs and
  | outputs, and ensuring that the input and
  | output slices have the same length. You could
  | also add documentation specifying any other
  | safety requirements, such as ensuring that the
  | input slices are not null.
  |
  | With these changes, users could call the
  | functions like this:
  |
  | ```
  | let mut processor = MyProcessor::new();
  | let mut input = vec![0.0; BLOCK_SIZE];
  | let mut output = vec![0.0; BLOCK_SIZE];
  | processor.process_mono_block(&input, Some(&mut output));
  | ```
  |
  */

crate::ix!();

/// Trait for processing a block of mono audio
/// samples.
///
pub trait ProcessBlockMono {

     /// # Safety
     ///
     /// `data` must point to `BLOCK_SIZE` valid
     /// contiguous data elements.
     ///
     /// If `out` is not `None`, `out.unwrap()`
     /// must also point to `BLOCK_SIZE` valid
     /// contiguous data elements.
     ///
    unsafe fn process_block_mono(
        &mut self, 
        data: *mut f32, 
        out: Option<*mut f32>);

    fn process_mono_block(
        &mut self,
        _input: &[f32],
        _output: Option<&mut [f32]>
    ) {
        unimplemented!();
    }
}

/// Trait for processing a block of stereo audio
/// samples.
///
pub trait ProcessBlockStereo {

    /// # Safety
    ///
    /// `data_l` and `data_r` must each point to
    /// `BLOCK_SIZE` valid contiguous data
    /// elements.
    ///
    /// If `out` is not `None`, `out.unwrap()`
    /// must be a tuple of two pointers each
    /// pointing to `BLOCK_SIZE` valid contiguous
    /// data elements.
    ///
    unsafe fn process_block_stereo(
        &mut self, 
        data_l: *mut f32, 
        data_r: *mut f32, 
        out: Option<(*mut f32, *mut f32)>
    );

    fn process_stereo_block(
        &mut self,
        _input_left: &[f32],
        _input_right: &[f32],
        _output_left: Option<&mut [f32]>,
        _output_right: Option<&mut [f32]>
    ) {
        unimplemented!();
    }
}

/// Trait for processing a block of stereo audio
/// samples with a slower lag.
///
pub trait ProcessBlockSlowlag {

    /// # Safety
    ///
    /// `data_l` and `data_r` must each point to
    /// `BLOCK_SIZE` valid contiguous data
    /// elements.
    ///
    unsafe fn process_block_slowlag(
        &mut self, 
        data_l: *mut f32, 
        data_r: *mut f32);

    fn process_slowlag_block(
        &mut self,
        _input_left: &[f32],
        _input_right: &[f32]
    ) {
        unimplemented!();
    }
}

/// Includes a method for setting the buffer size
/// before processing the audio block. 
///
pub trait CustomBufferSize {

    /// allows the user to choose the buffer size
    /// that best suits their needs
    ///
    fn set_buffer_size(&mut self, buffer_size: usize);
}