bg/clr color tweaks, clear borders rework, fc31 depends
[goodguy/cinelerra.git] / cinelerra-5.1 / plugins / synthesizer / synthesizer.h
1
2 /*
3  * CINELERRA
4  * Copyright (C) 2010 Adam Williams <broadcast at earthling dot net>
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19  *
20  */
21
22 #ifndef SYNTHESIZER_H
23 #define SYNTHESIZER_H
24
25
26
27 #include "filexml.inc"
28 #include "guicast.h"
29 #include "mutex.h"
30 #include "pluginaclient.h"
31 #include "synthesizer.inc"
32 #include "vframe.inc"
33
34
35 // Frequency table for piano
36 float keyboard_freqs[] =
37 {
38         65.4064,
39         69.2957,
40         73.4162,
41         77.7817,
42         82.4069,
43         87.3071,
44         92.4986,
45         97.9989,
46         103.826,
47         110.000,
48         116.541,
49         123.471,
50
51         130.81,
52         138.59,
53         146.83,
54         155.56,
55         164.81,
56         174.61,
57         185.00,
58         196.00,
59         207.65,
60         220.00,
61         233.08,
62         246.94,
63
64         261.63,
65         277.18,
66         293.66,
67         311.13,
68         329.63,
69         349.23,
70         369.99,
71         392.00,
72         415.30,
73         440.00,
74         466.16,
75         493.88,
76
77
78
79         523.251,
80         554.365,
81         587.330,
82         622.254,
83         659.255,
84         698.456,
85         739.989,
86         783.991,
87         830.609,
88         880.000,
89         932.328,
90         987.767,
91
92         1046.50,
93         1108.73,
94         1174.66,
95         1244.51,
96         1318.51,
97         1396.91,
98         1479.98,
99         1567.98,
100         1661.22,
101         1760.00,
102         1864.66,
103         1975.53,
104
105         2093.00
106 };
107
108 #define MAX_FREQS 16
109 #define TOTALOSCILLATORS 1
110 #define TOTALNOTES ((int)(sizeof(keyboard_freqs) / sizeof(float)))
111 #define MIDDLE_C 24
112 #define FIRST_TITLE (MIDDLE_C - 12)
113 #define LAST_TITLE (MIDDLE_C + 12)
114 #define MARGIN yS(10)
115
116 #define SINE 0
117 #define SAWTOOTH 1
118 #define SQUARE 2
119 #define TRIANGLE 3
120 #define PULSE 4
121 #define NOISE 5
122 #define DC    6
123
124
125 class SynthCanvas;
126 class SynthWaveForm;
127 class SynthBaseFreq;
128 class SynthFreqPot;
129 class SynthOscGUI;
130 class OscScroll;
131 class NoteScroll;
132 class SynthWetness;
133 class SynthNote;
134 class SynthMomentary;
135
136 class SynthWindow : public PluginClientWindow
137 {
138 public:
139         SynthWindow(Synth *synth);
140         ~SynthWindow();
141
142         void create_objects();
143         int resize_event(int w, int h);
144         void update_gui();
145         int waveform_to_text(char *text, int waveform);
146         void update_scrollbar();
147         void update_oscillators();
148         void update_notes();
149         void update_note_selection();
150         int keypress_event();
151         void update_blackkey(int number, int *current_title, int x, int y);
152         void update_whitekey(int number, int *current_title, int x, int y);
153
154
155         Synth *synth;
156         SynthCanvas *canvas;
157         SynthWetness *wetness;
158         SynthWaveForm *waveform;
159         SynthBaseFreq *base_freq;
160         SynthFreqPot *freqpot;
161         BC_SubWindow *osc_subwindow;
162         OscScroll *osc_scroll;
163         BC_SubWindow *note_subwindow;
164         NoteScroll *note_scroll;
165         ArrayList<SynthOscGUI*> oscillators;
166         SynthNote *notes[TOTALNOTES];
167         BC_Title *note_titles[TOTALNOTES];
168         BC_Title *note_instructions;
169         SynthMomentary *momentary;
170         VFrame *white_key[5];
171         VFrame *black_key[5];
172         int y1;
173         int y2;
174         int y3;
175         int text_white_margin;
176         int text_black_margin;
177 // Button press currently happening if > -1
178         int current_note;
179 // If we are stopping or starting notes in a drag
180         int starting_notes;
181 };
182
183 class SynthMomentary : public BC_CheckBox
184 {
185 public:
186         SynthMomentary(SynthWindow *window, int x, int y, char *text);
187         int handle_event();
188         SynthWindow *window;
189 };
190
191 class SynthNote : public BC_Toggle
192 {
193 public:
194         SynthNote(SynthWindow *window, VFrame **images, int number, int x, int y);
195         void start_note();
196         void stop_note();
197         int keypress_event();
198         int keyrelease_event();
199         int button_press_event();
200         int button_release_event();
201         int cursor_motion_event();
202         int draw_face(int flash, int flush);
203         int number;
204         int note_on;
205         SynthWindow *window;
206 };
207
208
209 class SynthOscGUILevel;
210 class SynthOscGUIPhase;
211 class SynthOscGUIFreq;
212
213 class SynthOscGUI
214 {
215 public:
216         SynthOscGUI(SynthWindow *window, int number);
217         ~SynthOscGUI();
218
219         void create_objects(int view_y);
220
221         SynthOscGUILevel *level;
222         SynthOscGUIPhase *phase;
223         SynthOscGUIFreq *freq;
224         BC_Title *title;
225
226         int number;
227         SynthWindow *window;
228 };
229
230 class SynthOscGUILevel : public BC_FPot
231 {
232 public:
233         SynthOscGUILevel(Synth *synth, SynthOscGUI *gui, int y);
234         ~SynthOscGUILevel();
235
236         int handle_event();
237
238         Synth *synth;
239         SynthOscGUI *gui;
240 };
241
242 class SynthOscGUIPhase : public BC_IPot
243 {
244 public:
245         SynthOscGUIPhase(Synth *synth, SynthOscGUI *gui, int y);
246         ~SynthOscGUIPhase();
247
248         int handle_event();
249
250         Synth *synth;
251         SynthOscGUI *gui;
252 };
253
254 class SynthOscGUIFreq : public BC_IPot
255 {
256 public:
257         SynthOscGUIFreq(Synth *synth, SynthOscGUI *gui, int y);
258         ~SynthOscGUIFreq();
259
260         int handle_event();
261
262         Synth *synth;
263         SynthOscGUI *gui;
264 };
265
266 class OscScroll : public BC_ScrollBar
267 {
268 public:
269         OscScroll(Synth *synth, SynthWindow *window, int x, int y, int h);
270         ~OscScroll();
271
272         int handle_event();
273
274         Synth *synth;
275         SynthWindow *window;
276 };
277
278 class NoteScroll : public BC_ScrollBar
279 {
280 public:
281         NoteScroll(Synth *synth, SynthWindow *window, int x, int y, int w);
282         ~NoteScroll();
283
284         int handle_event();
285
286         Synth *synth;
287         SynthWindow *window;
288 };
289
290 class SynthAddOsc : public BC_GenericButton
291 {
292 public:
293         SynthAddOsc(Synth *synth, SynthWindow *window, int x, int y);
294         ~SynthAddOsc();
295
296         int handle_event();
297
298         Synth *synth;
299         SynthWindow *window;
300 };
301
302
303 class SynthDelOsc : public BC_GenericButton
304 {
305 public:
306         SynthDelOsc(Synth *synth, SynthWindow *window, int x, int y);
307         ~SynthDelOsc();
308
309         int handle_event();
310
311         Synth *synth;
312         SynthWindow *window;
313 };
314
315 class SynthClear : public BC_GenericButton
316 {
317 public:
318         SynthClear(Synth *synth, int x, int y);
319         ~SynthClear();
320         int handle_event();
321         Synth *synth;
322 };
323
324 class SynthWaveForm : public BC_PopupMenu
325 {
326 public:
327         SynthWaveForm(Synth *synth, int x, int y, char *text);
328         ~SynthWaveForm();
329
330         void create_objects();
331         Synth *synth;
332 };
333
334 class SynthWaveFormItem : public BC_MenuItem
335 {
336 public:
337         SynthWaveFormItem(Synth *synth, char *text, int value);
338         ~SynthWaveFormItem();
339
340         int handle_event();
341
342         int value;
343         Synth *synth;
344 };
345
346 class SynthBaseFreq : public BC_TextBox
347 {
348 public:
349         SynthBaseFreq(Synth *synth, SynthWindow *window, int x, int y);
350         ~SynthBaseFreq();
351         int handle_event();
352         Synth *synth;
353         SynthFreqPot *freq_pot;
354         SynthWindow *window;
355 };
356
357 class SynthFreqPot : public BC_QPot
358 {
359 public:
360         SynthFreqPot(Synth *synth, SynthWindow *window, int x, int y);
361         ~SynthFreqPot();
362         int handle_event();
363         SynthWindow *window;
364         Synth *synth;
365         SynthBaseFreq *freq_text;
366 };
367
368 class SynthWetness : public BC_FPot
369 {
370 public:
371         SynthWetness(Synth *synth, int x, int y);
372         int handle_event();
373         Synth *synth;
374 };
375
376
377 class SynthCanvas : public BC_SubWindow
378 {
379 public:
380         SynthCanvas(Synth *synth,
381                 SynthWindow *window,
382                 int x,
383                 int y,
384                 int w,
385                 int h);
386         ~SynthCanvas();
387
388         int update();
389         Synth *synth;
390         SynthWindow *window;
391 };
392
393
394
395
396 // ======================= level calculations
397 class SynthLevelZero : public BC_MenuItem
398 {
399 public:
400         SynthLevelZero(Synth *synth);
401         ~SynthLevelZero();
402         int handle_event();
403         Synth *synth;
404 };
405
406 class SynthLevelMax : public BC_MenuItem
407 {
408 public:
409         SynthLevelMax(Synth *synth);
410         ~SynthLevelMax();
411         int handle_event();
412         Synth *synth;
413 };
414
415 class SynthLevelNormalize : public BC_MenuItem
416 {
417 public:
418         SynthLevelNormalize(Synth *synth);
419         ~SynthLevelNormalize();
420         int handle_event();
421         Synth *synth;
422 };
423
424 class SynthLevelSlope : public BC_MenuItem
425 {
426 public:
427         SynthLevelSlope(Synth *synth);
428         ~SynthLevelSlope();
429         int handle_event();
430         Synth *synth;
431 };
432
433 class SynthLevelRandom : public BC_MenuItem
434 {
435 public:
436         SynthLevelRandom(Synth *synth);
437         ~SynthLevelRandom();
438         int handle_event();
439         Synth *synth;
440 };
441
442 class SynthLevelInvert : public BC_MenuItem
443 {
444 public:
445         SynthLevelInvert(Synth *synth);
446         ~SynthLevelInvert();
447         int handle_event();
448         Synth *synth;
449 };
450
451 class SynthLevelSine : public BC_MenuItem
452 {
453 public:
454         SynthLevelSine(Synth *synth);
455         ~SynthLevelSine();
456         int handle_event();
457         Synth *synth;
458 };
459
460 // ============================ phase calculations
461
462 class SynthPhaseInvert : public BC_MenuItem
463 {
464 public:
465         SynthPhaseInvert(Synth *synth);
466         ~SynthPhaseInvert();
467         int handle_event();
468         Synth *synth;
469 };
470
471 class SynthPhaseZero : public BC_MenuItem
472 {
473 public:
474         SynthPhaseZero(Synth *synth);
475         ~SynthPhaseZero();
476         int handle_event();
477         Synth *synth;
478 };
479
480 class SynthPhaseSine : public BC_MenuItem
481 {
482 public:
483         SynthPhaseSine(Synth *synth);
484         ~SynthPhaseSine();
485         int handle_event();
486         Synth *synth;
487 };
488
489 class SynthPhaseRandom : public BC_MenuItem
490 {
491 public:
492         SynthPhaseRandom(Synth *synth);
493         ~SynthPhaseRandom();
494         int handle_event();
495         Synth *synth;
496 };
497
498
499 // ============================ freq calculations
500
501 class SynthFreqRandom : public BC_MenuItem
502 {
503 public:
504         SynthFreqRandom(Synth *synth);
505         ~SynthFreqRandom();
506         int handle_event();
507         Synth *synth;
508 };
509
510 class SynthFreqEnum : public BC_MenuItem
511 {
512 public:
513         SynthFreqEnum(Synth *synth);
514         ~SynthFreqEnum();
515         int handle_event();
516         Synth *synth;
517 };
518
519 class SynthFreqEven : public BC_MenuItem
520 {
521 public:
522         SynthFreqEven(Synth *synth);
523         ~SynthFreqEven();
524         int handle_event();
525         Synth *synth;
526 };
527
528 class SynthFreqOdd : public BC_MenuItem
529 {
530 public:
531         SynthFreqOdd(Synth *synth);
532         ~SynthFreqOdd();
533         int handle_event();
534         Synth *synth;
535 };
536
537 class SynthFreqFibonacci : public BC_MenuItem
538 {
539 public:
540         SynthFreqFibonacci(Synth *synth);
541         ~SynthFreqFibonacci();
542         int handle_event();
543         Synth *synth;
544 };
545
546 class SynthFreqPrime : public BC_MenuItem
547 {
548 public:
549         SynthFreqPrime(Synth *synth);
550         ~SynthFreqPrime();
551         int handle_event();
552         Synth *synth;
553 private:
554         float get_next_prime(float number);
555 };
556
557
558
559 class SynthOscillatorConfig
560 {
561 public:
562         SynthOscillatorConfig(int number);
563         ~SynthOscillatorConfig();
564
565         int equivalent(SynthOscillatorConfig &that);
566         void copy_from(SynthOscillatorConfig& that);
567         void reset();
568         void read_data(FileXML *file);
569         void save_data(FileXML *file);
570         int is_realtime();
571
572         float level;
573         float phase;
574         float freq_factor;
575         int number;
576 };
577
578
579
580 class SynthConfig
581 {
582 public:
583         SynthConfig();
584         ~SynthConfig();
585
586         int equivalent(SynthConfig &that);
587         void copy_from(SynthConfig &that);
588         void interpolate(SynthConfig &prev,
589                 SynthConfig &next,
590                 int64_t prev_frame,
591                 int64_t next_frame,
592                 int64_t current_frame);
593         void reset();
594
595         double wetness;
596 // base frequency for oscillators
597 // Freqs of 0 are unused.
598         double base_freq[MAX_FREQS];
599         int wavefunction;        // SINE, SAWTOOTH, etc
600         ArrayList<SynthOscillatorConfig*> oscillator_config;
601         int momentary_notes;
602 };
603
604
605 class Synth : public PluginAClient
606 {
607 public:
608         Synth(PluginServer *server);
609         ~Synth();
610
611
612         PLUGIN_CLASS_MEMBERS(SynthConfig)
613         int is_realtime();
614         int is_synthesis();
615         void read_data(KeyFrame *keyframe);
616         void save_data(KeyFrame *keyframe);
617         int process_realtime(int64_t size, Samples *input_ptr, Samples *output_ptr);
618
619
620
621
622 // Frequency is in the table of base_freqs
623         int freq_exists(double freq);
624 // Manage frequency table
625         void new_freq(double freq);
626         void delete_freq(double freq);
627         void delete_freqs();
628
629         void add_oscillator();
630         void delete_oscillator();
631         double get_total_power();
632         double get_oscillator_point(float x,
633                 double normalize_constant,
634                 int oscillator);
635         double solve_eqn(double *output,
636                 int length,
637                 double freq,
638                 double normalize_constant,
639                 int oscillator);
640         double get_point(float x, double normalize_constant);
641         double function_square(double x);
642         double function_pulse(double x);
643         double function_noise();
644         double function_sawtooth(double x);
645         double function_triangle(double x);
646         void reconfigure();
647         int overlay_synth(double freq,
648                 int64_t length,
649                 double *input,
650                 double *output);
651         void update_gui();
652         void reset();
653
654
655
656         int window_w, window_h;
657         int need_reconfigure;
658         DB db;
659 // Samples since last reconfiguration
660         int64_t waveform_sample;
661 };
662
663
664
665
666
667
668
669
670 #endif