1 // Copyright 2014 Emilie Gillet.
2 //
3 // Author: Emilie Gillet (emilie.o.gillet@gmail.com)
4 //
5 // This program is free software: you can redistribute it and/or modify
6 // it under the terms of the GNU General Public License as published by
7 // the Free Software Foundation, either version 3 of the License, or
8 // (at your option) any later version.
9 // This program is distributed in the hope that it will be useful,
10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 // GNU General Public License for more details.
13 // You should have received a copy of the GNU General Public License
14 // along with this program. If not, see <http://www.gnu.org/licenses/>.
15
16 #include <cmath>
17 #include <cstdio>
18 #include <cstring>
19 #include <cstdlib>
20 #include <xmmintrin.h>
21
22 #include "elements/dsp/exciter.h"
23 #include "elements/dsp/part.h"
24 #include "elements/dsp/resonator.h"
25 #include "elements/dsp/voice.h"
26
27 using namespace elements;
28 using namespace stmlib;
29
30 const uint32_t kSampleRate = 32000;
31 const uint16_t kAudioBlockSize = 32;
32
write_wav_header(FILE * fp,int num_samples,int num_channels)33 void write_wav_header(FILE* fp, int num_samples, int num_channels) {
34 uint32_t l;
35 uint16_t s;
36
37 fwrite("RIFF", 4, 1, fp);
38 l = 36 + num_samples * 2 * num_channels;
39 fwrite(&l, 4, 1, fp);
40 fwrite("WAVE", 4, 1, fp);
41
42 fwrite("fmt ", 4, 1, fp);
43 l = 16;
44 fwrite(&l, 4, 1, fp);
45 s = 1;
46 fwrite(&s, 2, 1, fp);
47 s = num_channels;
48 fwrite(&s, 2, 1, fp);
49 l = ::kSampleRate;
50 fwrite(&l, 4, 1, fp);
51 l = static_cast<uint32_t>(::kSampleRate) * 2 * num_channels;
52 fwrite(&l, 4, 1, fp);
53 s = 2 * num_channels;
54 fwrite(&s, 2, 1, fp);
55 s = 16;
56 fwrite(&s, 2, 1, fp);
57
58 fwrite("data", 4, 1, fp);
59 l = num_samples * 2 * num_channels;
60 fwrite(&l, 4, 1, fp);
61 }
62
TestResonator()63 void TestResonator() {
64 FILE* fp = fopen("elements_resonator.wav", "wb");
65 write_wav_header(fp, ::kSampleRate * 40, 1);
66
67 Resonator resonator;
68 resonator.Init();
69 resonator.set_frequency(110.0f / ::kSampleRate);
70 resonator.set_geometry(0.2f);
71 resonator.set_brightness(0.4f);
72 resonator.set_damping(0.4f);
73 resonator.set_position(0.5f);
74 // resonator.set_resolution(1);
75
76 float impulse = 1.0f;
77 float noise_level = 0.0f;
78 for (uint32_t i = 0; i < ::kSampleRate * 40; ++i) {
79 uint16_t tri = (i / 2);
80 tri = tri > 32767 ? 65535 - tri : tri;
81 uint16_t tri2 = (i / 25);
82 tri2 = tri2 > 32767 ? 65535 - tri2 : tri2;
83
84 resonator.set_position(tri / 32768.0f);
85
86 if (i % (::kSampleRate / 8) == 0 && (rand() % 8 > 2)) {
87 float frequencies[5] = { 110.0f, 220.0f * powf(2, 3/12.0f), 220.0f, 880.0f, 55.0f };
88 resonator.set_frequency(frequencies[rand() % 5] / ::kSampleRate);
89 resonator.set_geometry((rand() % 32768) / 32768.0f);
90 resonator.set_brightness((rand() % 32768) / 32768.0f);
91 resonator.set_damping((rand() % 32768) / 32768.0f);
92 noise_level = (rand() % 4) == 1 ? 1.0f : 0.0f;
93 if (noise_level) {
94 resonator.set_damping(0.7f);
95 resonator.set_brightness((rand() % 32768) / 65535.0f);
96 } else{
97 impulse = 1.0f;
98 }
99 }
100
101 impulse = impulse * 0.99f;
102
103 float bow_strength = 0.0f;
104 float output;
105 float aux;
106 float input = impulse;
107 input += ((rand() % 32768) - 16384) / 65535.0f * noise_level;
108 resonator.Process(&bow_strength, &input, &output, &aux, 1);
109
110 output = output * 32768.0f;
111 if (output > 32767) output = 32767;
112 if (output < -32767) output = -32767;
113 short output_sample = output;
114 fwrite(&output_sample, sizeof(int16_t), 1, fp);
115 }
116 fclose(fp);
117 }
118
TestExciter()119 void TestExciter() {
120 FILE* fp = fopen("elements_exciter.wav", "wb");
121 write_wav_header(fp, ::kSampleRate * 10, 4);
122
123 float diffuser_buffer[1024];
124
125 Exciter exciter;
126 exciter.Init();
127 exciter.set_model(EXCITER_MODEL_PLECTRUM);
128 exciter.set_parameter(0.7f);
129 exciter.set_timbre(0.5f);
130 exciter.set_signature(0.1f);
131
132 Resonator resonator;
133 resonator.Init();
134 resonator.set_frequency(262.0f / ::kSampleRate / 2);
135 resonator.set_geometry(0.3f);
136 resonator.set_brightness(0.8f);
137 resonator.set_damping(0.3f);
138 resonator.set_position(0.1f);
139 resonator.set_resolution(48);
140
141 bool previous_gate = false;
142 for (uint32_t i = 0; i < ::kSampleRate * 10; ++i) {
143 uint16_t tri = (i / 8);
144 tri = tri > 32767 ? 65535 - tri : tri;
145
146 uint16_t tri2 = (i * 1.5);
147 tri2 = tri2 > 32767 ? 65535 - tri2 : tri2;
148
149 bool gate = (i % (::kSampleRate / 2)) < (::kSampleRate / 4);
150
151 uint8_t flags = 0;
152 if (gate) flags |= EXCITER_FLAG_GATE;
153 if (gate && !previous_gate) flags |= EXCITER_FLAG_RISING_EDGE;
154 if (!gate && previous_gate) flags |= EXCITER_FLAG_FALLING_EDGE;
155 previous_gate = gate;
156
157 exciter.set_parameter(tri / 32768.0f);
158 // exciter.set_timbre(tri / 32768.0f);
159
160 float bow_strength = 0.0f;
161 float output[4];
162 short output_sample[4];
163 exciter.Process(flags, &output[0], 1);
164 // output[0] *= 0.15;
165 output[1] = exciter.damping();
166 resonator.Process(&bow_strength, &output[0], &output[2], &output[3], 1);
167 for (int j = 0; j < 4; ++j) {
168 output[j] *= 32767.0f;
169 if (output[j] > 32767) output[j] = 32767;
170 if (output[j] < -32767) output[j] = -32767;
171 output_sample[j] = output[j];
172 }
173 fwrite(output_sample, sizeof(int16_t), 4, fp);
174 }
175 fclose(fp);
176 }
177
TestVoice()178 void TestVoice() {
179 FILE* fp = fopen("elements_voice.wav", "wb");
180 write_wav_header(fp, ::kSampleRate * 20, 4);
181
182 Voice voice;
183 Patch p;
184 p.exciter_envelope_shape = 0.95f;
185 p.exciter_bow_level = 0.5f;
186 p.exciter_bow_timbre = 0.6f;
187 p.exciter_blow_level = 0.0f;
188 p.exciter_blow_meta = 0.5f;
189 p.exciter_blow_timbre = 0.2f;
190 p.exciter_strike_level = 0.0f;
191 p.exciter_strike_meta = 0.5f;
192 p.exciter_strike_timbre = 0.5f;
193 p.resonator_geometry = 0.2f;
194 p.resonator_brightness = 0.9f;
195 p.resonator_damping = 0.3f;
196 p.resonator_position = 0.3f;
197
198 voice.Init();
199
200 for (uint32_t i = 0; i < ::kSampleRate * 20; ++i) {
201 uint16_t tri = (i / 8);
202 tri = tri > 32767 ? 65535 - tri : tri;
203 p.resonator_damping = tri / 32768.0;
204
205 bool gate = (i % (::kSampleRate * 4)) < (::kSampleRate * 2);
206 float blow_in = 0.0f;
207 float strike_in = 0.0f;
208 float raw_out = 0.0f;
209 float center = 0.0f;
210 float sides = 0.0f;
211
212 voice.Process(
213 p,
214 262.0f / ::kSampleRate / 2.0f,
215 1.0f,
216 gate,
217 &blow_in,
218 &strike_in,
219 &raw_out,
220 ¢er,
221 &sides, 1);
222
223 float output[4];
224 short output_sample[4];
225 output[0] = center + (sides) * 0.5f;
226 output[1] = center - (sides) * 0.5f;
227 output[2] = center;
228 output[3] = raw_out;
229
230 for (int j = 0; j < 4; ++j) {
231 output[j] *= 32767.0f * (j != 3 ? 0.5f : 1.0f);
232 if (output[j] > 32767) output[j] = 32767;
233 if (output[j] < -32767) output[j] = -32767;
234 output_sample[j] = output[j];
235 }
236 fwrite(output_sample, sizeof(int16_t), 4, fp);
237 }
238 fclose(fp);
239 }
240
TestPart()241 void TestPart() {
242 FILE* fp = fopen("elements_part.wav", "wb");
243 write_wav_header(fp, ::kSampleRate * 20, 2);
244
245 uint16_t reverb_buffer[32768];
246 Part part;
247 part.Init(reverb_buffer);
248
249 Patch* p = part.mutable_patch();
250
251 p->exciter_envelope_shape = 0.0f;
252 p->exciter_bow_level = 0.0f;
253 p->exciter_bow_timbre = 0.0f;
254 p->exciter_blow_level = 0.0f;
255 p->exciter_blow_meta = 0.0f;
256 p->exciter_blow_timbre = 0.0f;
257 p->exciter_strike_level = 0.5f;
258 p->exciter_strike_meta = 0.5f;
259 p->exciter_strike_timbre = 0.3f;
260 p->resonator_geometry = 0.4f;
261 p->resonator_brightness = 0.7f;
262 p->resonator_damping = 0.8f;
263 p->resonator_position = 0.3f;
264 p->space = 0.1f;
265
266
267 // p->exciter_envelope_shape = 0.99f;
268 // p->exciter_bow_level = 0.0f;
269 // p->exciter_bow_timbre = 0.6f;
270 // p->exciter_blow_level = 0.0f;
271 // p->exciter_blow_meta = 0.0f;
272 // p->exciter_blow_timbre = 0.0f;
273 // p->exciter_strike_level = 0.6f;
274 // p->exciter_strike_meta = 0.5f;
275 // p->exciter_strike_timbre = 0.5f;
276 // p->resonator_geometry = 0.85f;
277 // p->resonator_brightness = 1.0f;
278 // p->resonator_damping = 0.6f;
279 // p->resonator_position = 0.3f;
280 // p->space = 0.1f;
281
282 // p->exciter_envelope_shape = 0.0f;
283 // p->exciter_bow_level = 0.0f;
284 // p->exciter_bow_timbre = 0.5f;
285 // p->exciter_blow_level = 0.0f;
286 // p->exciter_blow_meta = 0.0f;
287 // p->exciter_blow_timbre = 0.5f;
288 // p->exciter_strike_level = 1.0f;
289 // p->exciter_strike_meta = 0.2f;
290 // p->exciter_strike_timbre = 0.6f;
291 // p->resonator_geometry = 0.25f;
292 // p->resonator_brightness = 0.3f;
293 // p->resonator_damping = 0.5f;
294 // p->resonator_position = 0.4f;
295 // p->space = 1.0;
296
297 // p->exciter_envelope_shape = 0.99f;
298 // p->exciter_bow_level = 0.6f;
299 // p->exciter_bow_timbre = 0.6f;
300 // p->exciter_blow_level = 0.0f;
301 // p->exciter_blow_meta = 0.0f;
302 // p->exciter_blow_timbre = 0.0f;
303 // p->exciter_strike_level = 0.0f;
304 // p->exciter_strike_meta = 0.0f;
305 // p->exciter_strike_timbre = 0.0f;
306 // p->resonator_geometry = 0.25f;
307 // p->resonator_brightness = 0.8f;
308 // p->resonator_damping = 0.3f;
309 // p->resonator_position = 0.3f;
310 // p->space = 0.9f;
311
312 float sequence[] = { 69.0f, 57.0f, 45.0f, 57.0f, 69.0f };
313 // float sequence[] = { 19, 19, 19, 19, 19 };
314 int sequence_counter = -1;
315
316 float silence[16];
317 std::fill(&silence[0], &silence[16], 0.0f);
318
319 for (uint32_t i = 0; i < ::kSampleRate * 20; i += 16) {
320 uint16_t tri = (i * 1);
321 tri = tri > 32767 ? 65535 - tri : tri;
322
323 uint16_t tri2 = (i / 6);
324 tri2 = tri2 > 32767 ? 65535 - tri2 : tri2;
325
326 float main[16];
327 float aux[16];
328
329 // p->resonator_position = int(256.0f * tri / 32768.0f) / 256.0f;
330 // p->resonator_geometry = 0.5f + 0.5f * tri / 32768.0f;
331
332 //p->exciter_strike_meta = 0.0f + 1.0f * tri / 32768.0f;
333
334
335 if (i % (::kSampleRate * 2) == 0) {
336 sequence_counter = (sequence_counter + 1) % 5;
337 }
338
339 PerformanceState performance;
340 performance.note = sequence[sequence_counter] - 12.0f;
341 performance.modulation = 0.0f; /*i & 16 ? 60.0f : -60.0f;
342 if (i > ::kSampleRate * 5) {
343 performance.modulation = 0;
344 }*/
345 performance.strength = 0.5f;
346 performance.gate = (i % (::kSampleRate / 1)) < (::kSampleRate / 2);
347
348 part.Process(performance, silence, silence, main, aux, 16);
349
350 for (size_t j = 0; j < 16; ++j) {
351 float output[2];
352 short output_sample[2];
353 output[0] = main[j];
354 output[1] = aux[j];
355
356 for (int k = 0; k < 2; ++k) {
357 output[k] *= 32767.0f;
358 if (output[k] > 32767) output[k] = 32767;
359 if (output[k] < -32767) output[k] = -32767;
360 output_sample[k] = output[k];
361 }
362 fwrite(output_sample, sizeof(int16_t), 2, fp);
363 }
364 }
365 fclose(fp);
366 }
367
368
TestEasterEgg()369 void TestEasterEgg() {
370 FILE* fp = fopen("elements_easter_egg.wav", "wb");
371 write_wav_header(fp, ::kSampleRate * 20, 2);
372
373 uint16_t reverb_buffer[32768];
374 Part part;
375 part.Init(reverb_buffer);
376
377 Patch* p = part.mutable_patch();
378
379 part.set_easter_egg(true);
380
381 // p->exciter_envelope_shape = 1.0f;
382 // p->exciter_bow_level = 0.0f;
383 // p->exciter_bow_timbre = 1.0f;
384 // p->exciter_blow_level = 0.0f;
385 // p->exciter_blow_meta = 0.27f;
386 // p->exciter_blow_timbre = 0.3f;
387 // p->exciter_strike_level = 1.0f;
388 // p->exciter_strike_meta = 0.5f;
389 // p->exciter_strike_timbre = 0.8f;
390 // p->resonator_geometry = 0.3f;
391 // p->resonator_brightness = 0.2f;
392 // p->resonator_damping = 0.9f;
393 // p->resonator_position = 0.0f;
394 // p->space = 0.5f;
395
396 p->exciter_envelope_shape = 0.2f;
397 p->exciter_bow_level = 0.52f;
398 p->exciter_bow_timbre = 0.8f;
399
400 p->exciter_blow_level = 0.5f;
401 p->exciter_blow_meta = 0.5f;
402 p->exciter_blow_timbre = 0.0f;
403
404 p->exciter_strike_level = 0.0f;
405 p->exciter_strike_meta = 0.83f;
406 p->exciter_strike_timbre = 0.5f;
407
408 p->resonator_geometry = 0.0f;
409 p->resonator_brightness = 1.0f;
410 p->resonator_damping = 0.0f;
411 p->resonator_position = 0.0f;
412 p->space = 0.2f;
413
414 float sequence[] = { 69.0f, 57.0f, 45.0f, 57.0f, 55.0f };
415 int sequence_counter = -1;
416
417 float silence[16];
418 std::fill(&silence[0], &silence[16], 0.0f);
419
420 for (uint32_t i = 0; i < ::kSampleRate * 20; i += 16) {
421 uint16_t tri = (i / 2);
422 tri = tri > 32767 ? 65535 - tri : tri;
423
424 uint16_t tri2 = (i * 3);
425 tri2 = tri2 > 32767 ? 65535 - tri2 : tri2;
426
427 float main[16];
428 float aux[16];
429
430 // p->exciter_blow_meta = 0.5f + 0.5f * (tri / 32768.0f);
431 // p->resonator_brightness = 0.0f + 1.0f * tri2 / 32768.0f;
432 // p->resonator_position = 0.0f + 0.3f * tri / 32768.0f;
433 // p->resonator_brightness = 0.0f + 1.0f * tri2 / 32768.0f;
434
435 if (i % (::kSampleRate / 2) == 0) {
436 sequence_counter = (sequence_counter + 1) % 5;
437 }
438
439 PerformanceState performance;
440 //performance.note = sequence[sequence_counter] - 12;
441 performance.note = 96.0f + (tri / 32768.0f) * 48.0;
442 performance.modulation = 0.0f;
443 performance.strength = 1.0f;
444 performance.gate = true; // (i % (::kSampleRate / 2)) < (::kSampleRate / 4);
445
446 part.Process(performance, silence, silence, main, aux, 16);
447
448 for (size_t j = 0; j < 16; ++j) {
449 float output[2];
450 short output_sample[2];
451 output[0] = main[j];
452 output[1] = aux[j];
453
454 for (int k = 0; k < 2; ++k) {
455 output[k] *= 32767.0f;
456 if (output[k] > 32767) output[k] = 32767;
457 if (output[k] < -32767) output[k] = -32767;
458 output_sample[k] = output[k];
459 }
460 fwrite(output_sample, sizeof(int16_t), 2, fp);
461 }
462 }
463 fclose(fp);
464 }
465
TestFilterAccuracy()466 void TestFilterAccuracy() {
467 Svf f;
468
469 for (int i = 0; i < 128; ++i) {
470 float midi_note = i / 1.0f;
471 float frequency = 440.0f * powf(2.0f, (midi_note - 69.0f) / 12.0f);
472 frequency /= ::kSampleRate;
473
474 float g[4];
475 f.set_f_q<FREQUENCY_EXACT>(frequency, 0.5f);
476 g[0] = f.g();
477 f.set_f_q<FREQUENCY_ACCURATE>(frequency, 0.5f);
478 g[1] = f.g();
479 f.set_f_q<FREQUENCY_FAST>(frequency, 0.5f);
480 g[2] = f.g();
481 f.set_f_q<FREQUENCY_DIRTY>(frequency, 0.5f);
482 g[3] = f.g();
483
484 printf("Frequency: %f", frequency * ::kSampleRate);
485 for (int j = 0; j < 4; ++j) {
486 float error_cts = logf(atanf(g[j]) / M_PI / frequency) / logf(2) * 1200;
487 printf("\t%.2f", error_cts);
488 }
489 printf("\n");
490 }
491 }
492
493
main(void)494 int main(void) {
495 _MM_SET_FLUSH_ZERO_MODE(_MM_FLUSH_ZERO_ON);
496 // TestFilterAccuracy();
497 TestPart();
498 // TestExciter();
499 // TestResonator();
500 // TestEasterEgg();
501 }
502