1 /* ========================================
2 * Surge - Surge.h
3 * Copyright (c) 2016 airwindows, All rights reserved
4 * ======================================== */
5
6 #ifndef __Surge_H
7 #include "Surge.h"
8 #endif
9
10 namespace Surge {
11
12
processReplacing(float ** inputs,float ** outputs,VstInt32 sampleFrames)13 void Surge::processReplacing(float **inputs, float **outputs, VstInt32 sampleFrames)
14 {
15 float* in1 = inputs[0];
16 float* in2 = inputs[1];
17 float* out1 = outputs[0];
18 float* out2 = outputs[1];
19
20 double overallscale = 1.0;
21 overallscale /= 44100.0;
22 overallscale *= getSampleRate();
23
24 long double inputSampleL;
25 long double inputSampleR;
26 long double drySampleL;
27 long double drySampleR;
28
29 double chaseMax = 0.0;
30 double intensity = (1.0-(pow((1.0-A),2)))*0.7;
31 double attack = ((intensity+0.1)*0.0005)/overallscale;
32 double decay = ((intensity+0.001)*0.00005)/overallscale;
33 double wet = B;
34 double dry = 1.0 - wet;
35 double inputSense;
36
37
38 while (--sampleFrames >= 0)
39 {
40 inputSampleL = *in1;
41 inputSampleR = *in2;
42 if (inputSampleL<1.2e-38 && -inputSampleL<1.2e-38) {
43 static int noisesource = 0;
44 //this declares a variable before anything else is compiled. It won't keep assigning
45 //it to 0 for every sample, it's as if the declaration doesn't exist in this context,
46 //but it lets me add this denormalization fix in a single place rather than updating
47 //it in three different locations. The variable isn't thread-safe but this is only
48 //a random seed and we can share it with whatever.
49 noisesource = noisesource % 1700021; noisesource++;
50 int residue = noisesource * noisesource;
51 residue = residue % 170003; residue *= residue;
52 residue = residue % 17011; residue *= residue;
53 residue = residue % 1709; residue *= residue;
54 residue = residue % 173; residue *= residue;
55 residue = residue % 17;
56 double applyresidue = residue;
57 applyresidue *= 0.00000001;
58 applyresidue *= 0.00000001;
59 inputSampleL = applyresidue;
60 }
61 if (inputSampleR<1.2e-38 && -inputSampleR<1.2e-38) {
62 static int noisesource = 0;
63 noisesource = noisesource % 1700021; noisesource++;
64 int residue = noisesource * noisesource;
65 residue = residue % 170003; residue *= residue;
66 residue = residue % 17011; residue *= residue;
67 residue = residue % 1709; residue *= residue;
68 residue = residue % 173; residue *= residue;
69 residue = residue % 17;
70 double applyresidue = residue;
71 applyresidue *= 0.00000001;
72 applyresidue *= 0.00000001;
73 inputSampleR = applyresidue;
74 //this denormalization routine produces a white noise at -300 dB which the noise
75 //shaping will interact with to produce a bipolar output, but the noise is actually
76 //all positive. That should stop any variables from going denormal, and the routine
77 //only kicks in if digital black is input. As a final touch, if you save to 24-bit
78 //the silence will return to being digital black again.
79 }
80 drySampleL = inputSampleL;
81 drySampleR = inputSampleR;
82
83 inputSampleL *= 8.0;
84 inputSampleR *= 8.0;
85 inputSampleL *= intensity;
86 inputSampleR *= intensity;
87
88 inputSense = fabs(inputSampleL);
89 if (fabs(inputSampleR) > inputSense)
90 inputSense = fabs(inputSampleR);
91
92 if (chaseMax < inputSense) chaseA += attack;
93 if (chaseMax > inputSense) chaseA -= decay;
94
95 if (chaseA > decay) chaseA = decay;
96 if (chaseA < -attack) chaseA = -attack;
97
98 chaseB += (chaseA/overallscale);
99 if (chaseB > decay) chaseB = decay;
100 if (chaseB < -attack) chaseB = -attack;
101
102 chaseC += (chaseB/overallscale);
103 if (chaseC > decay) chaseC = decay;
104 if (chaseC < -attack) chaseC = -attack;
105
106 chaseD += (chaseC/overallscale);
107 if (chaseD > 1.0) chaseD = 1.0;
108 if (chaseD < 0.0) chaseD = 0.0;
109
110 chaseMax = chaseA;
111 if (chaseMax < chaseB) chaseMax = chaseB;
112 if (chaseMax < chaseC) chaseMax = chaseC;
113 if (chaseMax < chaseD) chaseMax = chaseD;
114
115 inputSampleL *= chaseMax;
116 inputSampleL = drySampleL - (inputSampleL * intensity);
117 inputSampleL = (drySampleL * dry) + (inputSampleL * wet);
118
119 inputSampleR *= chaseMax;
120 inputSampleR = drySampleR - (inputSampleR * intensity);
121 inputSampleR = (drySampleR * dry) + (inputSampleR * wet);
122
123 //stereo 32 bit dither, made small and tidy.
124 int expon; frexpf((float)inputSampleL, &expon);
125 long double dither = (rand()/(RAND_MAX*7.737125245533627e+25))*pow(2,expon+62);
126 inputSampleL += (dither-fpNShapeL); fpNShapeL = dither;
127 frexpf((float)inputSampleR, &expon);
128 dither = (rand()/(RAND_MAX*7.737125245533627e+25))*pow(2,expon+62);
129 inputSampleR += (dither-fpNShapeR); fpNShapeR = dither;
130 //end 32 bit dither
131
132 *out1 = inputSampleL;
133 *out2 = inputSampleR;
134
135 in1++;
136 in2++;
137 out1++;
138 out2++;
139 }
140 }
141
processDoubleReplacing(double ** inputs,double ** outputs,VstInt32 sampleFrames)142 void Surge::processDoubleReplacing(double **inputs, double **outputs, VstInt32 sampleFrames)
143 {
144 double* in1 = inputs[0];
145 double* in2 = inputs[1];
146 double* out1 = outputs[0];
147 double* out2 = outputs[1];
148
149 double overallscale = 1.0;
150 overallscale /= 44100.0;
151 overallscale *= getSampleRate();
152
153 long double inputSampleL;
154 long double inputSampleR;
155 long double drySampleL;
156 long double drySampleR;
157
158 double chaseMax = 0.0;
159 double intensity = (1.0-(pow((1.0-A),2)))*0.7;
160 double attack = ((intensity+0.1)*0.0005)/overallscale;
161 double decay = ((intensity+0.001)*0.00005)/overallscale;
162 double wet = B;
163 double dry = 1.0 - wet;
164 double inputSense;
165
166 while (--sampleFrames >= 0)
167 {
168 inputSampleL = *in1;
169 inputSampleR = *in2;
170 if (inputSampleL<1.2e-38 && -inputSampleL<1.2e-38) {
171 static int noisesource = 0;
172 //this declares a variable before anything else is compiled. It won't keep assigning
173 //it to 0 for every sample, it's as if the declaration doesn't exist in this context,
174 //but it lets me add this denormalization fix in a single place rather than updating
175 //it in three different locations. The variable isn't thread-safe but this is only
176 //a random seed and we can share it with whatever.
177 noisesource = noisesource % 1700021; noisesource++;
178 int residue = noisesource * noisesource;
179 residue = residue % 170003; residue *= residue;
180 residue = residue % 17011; residue *= residue;
181 residue = residue % 1709; residue *= residue;
182 residue = residue % 173; residue *= residue;
183 residue = residue % 17;
184 double applyresidue = residue;
185 applyresidue *= 0.00000001;
186 applyresidue *= 0.00000001;
187 inputSampleL = applyresidue;
188 }
189 if (inputSampleR<1.2e-38 && -inputSampleR<1.2e-38) {
190 static int noisesource = 0;
191 noisesource = noisesource % 1700021; noisesource++;
192 int residue = noisesource * noisesource;
193 residue = residue % 170003; residue *= residue;
194 residue = residue % 17011; residue *= residue;
195 residue = residue % 1709; residue *= residue;
196 residue = residue % 173; residue *= residue;
197 residue = residue % 17;
198 double applyresidue = residue;
199 applyresidue *= 0.00000001;
200 applyresidue *= 0.00000001;
201 inputSampleR = applyresidue;
202 //this denormalization routine produces a white noise at -300 dB which the noise
203 //shaping will interact with to produce a bipolar output, but the noise is actually
204 //all positive. That should stop any variables from going denormal, and the routine
205 //only kicks in if digital black is input. As a final touch, if you save to 24-bit
206 //the silence will return to being digital black again.
207 }
208 drySampleL = inputSampleL;
209 drySampleR = inputSampleR;
210
211 inputSampleL *= 8.0;
212 inputSampleR *= 8.0;
213 inputSampleL *= intensity;
214 inputSampleR *= intensity;
215
216 inputSense = fabs(inputSampleL);
217 if (fabs(inputSampleR) > inputSense)
218 inputSense = fabs(inputSampleR);
219
220 if (chaseMax < inputSense) chaseA += attack;
221 if (chaseMax > inputSense) chaseA -= decay;
222
223 if (chaseA > decay) chaseA = decay;
224 if (chaseA < -attack) chaseA = -attack;
225
226 chaseB += (chaseA/overallscale);
227 if (chaseB > decay) chaseB = decay;
228 if (chaseB < -attack) chaseB = -attack;
229
230 chaseC += (chaseB/overallscale);
231 if (chaseC > decay) chaseC = decay;
232 if (chaseC < -attack) chaseC = -attack;
233
234 chaseD += (chaseC/overallscale);
235 if (chaseD > 1.0) chaseD = 1.0;
236 if (chaseD < 0.0) chaseD = 0.0;
237
238 chaseMax = chaseA;
239 if (chaseMax < chaseB) chaseMax = chaseB;
240 if (chaseMax < chaseC) chaseMax = chaseC;
241 if (chaseMax < chaseD) chaseMax = chaseD;
242
243 inputSampleL *= chaseMax;
244 inputSampleL = drySampleL - (inputSampleL * intensity);
245 inputSampleL = (drySampleL * dry) + (inputSampleL * wet);
246
247 inputSampleR *= chaseMax;
248 inputSampleR = drySampleR - (inputSampleR * intensity);
249 inputSampleR = (drySampleR * dry) + (inputSampleR * wet);
250
251 //stereo 64 bit dither, made small and tidy.
252 int expon; frexp((double)inputSampleL, &expon);
253 long double dither = (rand()/(RAND_MAX*7.737125245533627e+25))*pow(2,expon+62);
254 dither /= 536870912.0; //needs this to scale to 64 bit zone
255 inputSampleL += (dither-fpNShapeL); fpNShapeL = dither;
256 frexp((double)inputSampleR, &expon);
257 dither = (rand()/(RAND_MAX*7.737125245533627e+25))*pow(2,expon+62);
258 dither /= 536870912.0; //needs this to scale to 64 bit zone
259 inputSampleR += (dither-fpNShapeR); fpNShapeR = dither;
260 //end 64 bit dither
261
262 *out1 = inputSampleL;
263 *out2 = inputSampleR;
264
265 in1++;
266 in2++;
267 out1++;
268 out2++;
269 }
270 }
271
272 } // end namespace Surge
273
274