-
Notifications
You must be signed in to change notification settings - Fork 1
/
REAPERDenoiser
255 lines (221 loc) · 10.5 KB
/
REAPERDenoiser
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
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
desc:Ratio Denoiser (github.com/nbickford/REAPERDenoiser)
// That's the description of the plugin. This is how it'll show up in the effect
// search dialog, as well as the text at the start of its user interface. We use
// it as the first line of the script per the JSFX documentation's
// recommendation (https://www.reaper.fm/sdk/js/js.php#js_file)
// Define our user interface.
// Our FFT size will always be the same, so we only need controls for
// the noise collection mode and the noise scale (k).
// This defines a combo box that allows the user to select "Denoise Input" or
// "Record Noise Sample". The default value is 0 (Denoise Input). The maximum
// value is 1 (Record Noise Sample), and it increases in steps of 1.
slider1:0<0,1,1{Denoise Input, Record Noise Sample}>Noise Collection Mode
// This defines a slider that can be varied between 0.0 and 10.0 in steps of
// 0.001, with default value 1.0. (If slider2 is equal to 0.0, this plugin
// shouldn't really do anything to the input audio.)
slider2:1<0.0,10.0,0.001>Noise Scale
// Here we can label our input and output pins. This also tells REAPER how many
// channels we can handle. In this case, the plugin is stereo (a monophonic
// plugin would be simpler, but I almost always use this to denoise stereo
// audio), so we define two input and output pins.
in_pin:Noisy Audio 1
in_pin:Noisy Audio 2
out_pin:Denoised Audio 1
out_pin:Denoised Audio 2
@init
// On initialization, initialize all of our variables.
// The FFT size will always be constant.
SIZE = 16384;
// We don't do any allocation in this plugin, since we know we start out with 8M
// words of memory. So all we need to do is construct some pointers to memory,
// where we'll store our data.
// Since we have two channels, we'll have 10 buffers of length SIZE.
bufferI1L = 0; // The left input tile 1 buffer starts at memory address 0.
bufferI2L = SIZE; // The left input tile 2 buffer starts at memory address SIZE.
bufferO1L = 2*SIZE; // The left output tile 1 buffer starts at address 2*SIZE.
bufferO2L = 3*SIZE; // And so on
noiseBufferL = 4*SIZE; // The FFT of the noise sample uses 2*SIZE memory
// but taking the norm reduces this to 1*SIZE, and saves time when processing effect
bufferI1R = 5*SIZE; // Right channels
bufferI2R = 6*SIZE;
bufferO1R = 7*SIZE;
bufferO2R = 8*SIZE;
noiseBufferR = 9*SIZE;
// We also use a temporary buffer of complex numbers in order to store our
// audio signals using complex numbers. REAPER's implementation of JSFX supports
// fft_real, which allows us to avoid this, as of this writing, but ReaPlugs
// doesn't have this yet.
fftBuffer = 10 * SIZE; // length 2*SIZE
freembuf(12*SIZE + 1);
// samplesCollected will be our position in the last of the two tiles.
// As such, it'll range from 0 to (SIZE/2) - 1.
// (In other words, our position in the first tile will be
// samplesCollected + SIZE/2, and our position in the second tile will be
// samplesCollected)
samplesCollected = 0;
// Finally, the algorithm we use outputs modified audio SIZE samples after we
// input it. If we tell REAPER that the plugin has a delay of SIZE samples,
// REAPER can automatically compensate for this and make it appear as if there's
// no delay at all.
pdc_delay = SIZE;
pdc_bot_ch=0;
pdc_top_ch=2;
@slider
// A simple function to zero out the noise buffers when switching mode to "Record Noise Sample"
// previousMode should default to 0 on first initialization, but setting it to 0 in @init will cause
// this code to get run again, and the noise profile lost even when switching to "Denoise Input"
slider1 > 0.5 ? (
previousMode < 0.5 ? (
bandIndex = 0;
memset(noiseBufferL, 0, SIZE);
memset(noiseBufferR, 0, SIZE);
previousMode = 1;
)
) : previousMode = 0;
@sample
// We'll write a function to denoise a single channel, and then we'll call this
// for each of the channels.
// In this case, we'll pass in the channel number, the four input and output
// tiles, and the current sample.
// We also need to specify which variables will be local to the function (i.e.
// which variables have local instead of global scope).
// Note that channels are zero-indexed (so the left channel is channel 0, and
// the right channel is channel 1).
// Functions can return values, but this one won't return anything.
// Swapping tiles and resetting samplesCollected will be managed by the caller.
function denoiseChannel(channel tileI1 tileI2 tileO1 tileO2 noiseBuffer samplesCollected)
local(sample tilePos1 tilePos2 hannWindowTile1 hannWindowTile2 index bandIndex
kSquared yNorm nNorm attenuationFactor)
(
// Read out input audio and write it into the input buffer.
sample = spl(channel); // You can also use spl0 or spl1.
// Compute our positions in tile 1 and tile 2 for conciseness
tilePos1 = samplesCollected + SIZE/2;
tilePos2 = samplesCollected;
// We'll apply each tile's envelope as we write the sample into
// the tile's buffer.
// See https://en.wikipedia.org/wiki/Window_function#Hann_and_Hamming_windows
hannWindowTile1 = 0.5 - 0.5 * cos(2*$pi*tilePos1/SIZE);
hannWindowTile2 = 0.5 - 0.5 * cos(2*$pi*tilePos2/SIZE);
// Write into the input buffers:
tileI1[tilePos1] = sample * hannWindowTile1;
tileI2[tilePos2] = sample * hannWindowTile2;
// For the output audio, read from the two tiles and sum their results.
spl(channel) = tileO1[tilePos1] + tileO2[tilePos2];
// When we finish a tile, samplesCollected is equal to (SIZE/2) - 1
// When that happens, we transform the contents of tile 1 and write them to
// output tile 1. Then we swap tiles 1 and 2 for both the input and output tiles.
// The code outside of this function will take care of setting samplesCollected
// back to 0.
samplesCollected == (SIZE/2) - 1 ? (
// The first thing we need to do is to copy from our tile of audio signals,
// tileI1, into a temporary array that stores the real and imaginary parts
// of SIZE complex numbers, and so has 2*SIZE words. This is necessary because
// JSFX's fft function operates on complex numbers; JSFX also has fft_real,
// but this isn't supported in ReaPlugs yet.
//
// tileI1 looks like
// [audio sample 0, audio sample 1, ..., audio sample SIZE - 1]
// and fftBuffer will look like
// [audio sample 0, 0, audio sample 1, 0, ..., audio sample SIZE - 1, 0]
// (i.e. it'll store the complex numbers (spl0 + 0i, spl1 + 0i, ...).
//
// Loop over each of the audio samples, from index = 0 to SIZE - 1.
index = 0;
loop(SIZE,
fftBuffer[2 * index + 0] = tileI1[index]; // Real part
fftBuffer[2 * index + 1] = 0.0; // Imaginary part
index += 1; // Next index
);
// Now compute the FFT of the buffer in-place:
// Note that SIZE specifies the number of complex numbers.
fft(fftBuffer, SIZE);
// The different frequency bins are now stored in permuted order. We need to
// call fft_permute to get them in order of their frequencies.
// See https://www.reaper.fm/sdk/js/advfunc.php#js_advanced for more info.
fft_permute(fftBuffer, SIZE);
// fftBuffer now looks like
// [band 0 real part, band 0 imaginary part,
// band 1 real part, band 1 imaginary part,
// ...
// band SIZE-1 real part, band SIZE-1 imaginary part].
// Note that we don't get bands SIZE/2 + 1 to SIZE-1 for free - there's no
// real extra data there! Those bands are conjugated, reversed versions
// of bands 1 to SIZE/2 - 1. In other words, since we put in SIZE words of
// information, we get only SIZE words of information out.
// If slider1 is greater than 0.5 (i.e. the user selected "Record Noise
// Sample", we store the FFTs of each of these buffers.
slider1 > 0.5? (
// for each band, compare the norm of the noise in this frame.
// If it is greater than what's already there for this band, then copy
// it into the noiseBuffer
index = 0;
loop(SIZE,
normSquareNew = sqr(fftBuffer[2 * index + 0]) + sqr(fftBuffer[2 * index + 1]);
normSquareOld = noiseBuffer[index];
normSquareNew >= normSquareOld ? (
noiseBuffer[index] = normSquareNew;
);
index += 1;
);
);
// Apply Norbert Weiner's filtering algorithm,
// X(f) = Y(f) * (|Y(f)|^2)/(|Y(f)|^2 + k^2 |N(f)|^2)
// sqr() computes the square of a number, and abs() computes the absolute
// value of a number. We also include a factor of 1/SIZE, to normalize the
// FFT (so that if we don't do any denoising, the input signal is equal to
// the output signal).
kSquared = sqr(slider2); // slider2 is the Noise Scale from above.
// Loop over each band, from bandIndex = 0 to SIZE - 1.
bandIndex = 0;
loop(SIZE,
// Compute |Y(f)|^2 = real(Y(f))^2 + imaginary(Y(f))^2
yNorm = sqr(fftBuffer[2 * bandIndex + 0]) + sqr(fftBuffer[2 * bandIndex + 1]);
// The same for the noise component:
nNorm = noiseBuffer[bandIndex];
attenuationFactor = yNorm / (SIZE * (yNorm + kSquared * nNorm));
fftBuffer[2 * bandIndex + 0] *= attenuationFactor;
fftBuffer[2 * bandIndex + 1] *= attenuationFactor;
bandIndex += 1;
);
// Now, undo the FFT (i.e. convert back from the frequency domain to the
// time domain):
fft_ipermute(fftBuffer, SIZE);
ifft(fftBuffer, SIZE);
// Copy from the complex numbers in fftBuffer to the output tile:
index = 0;
loop(SIZE,
tileO1[index] = fftBuffer[2 * index + 0];
index += 1;
);
)
);
// Now, call denoiseChannel for each of the channels.
denoiseChannel(0, bufferI1L, bufferI2L, bufferO1L, bufferO2L, noiseBufferL, samplesCollected);
denoiseChannel(1, bufferI1R, bufferI2R, bufferO1R, bufferO2R, noiseBufferR, samplesCollected);
// Go to the next sample
samplesCollected += 1;
samplesCollected == SIZE/2 ? (
samplesCollected = 0;
// Finally, swap our tiles:
temp = bufferI1L;
bufferI1L = bufferI2L;
bufferI2L = temp;
temp = bufferO1L;
bufferO1L = bufferO2L;
bufferO2L = temp;
temp = bufferI1R;
bufferI1R = bufferI2R;
bufferI2R = temp;
temp = bufferO1R;
bufferO1R = bufferO2R;
bufferO2R = temp;
)
@serialize
// Sliders are serialized automatically, so all we have to serialize is the two
// noise buffers. JSFX's serialization works in a clever way: when reading the
// state of the plugin from a serialized version, these functions copy data into
// noiseBufferL and noiseBufferR. But when writing out the state of the plugin,
// they work the other way, copying data out of noiseBufferL and noiseBufferR.
file_mem(0, noiseBufferL, SIZE);
file_mem(0, noiseBufferR, SIZE);