hvirtual/plugins/synthesizer/synthesizer.h

   1 #ifndef SYNTHESIZER_H
   2 #define SYNTHESIZER_H
   3
   4
   5
   6 #include "filexml.inc"
   7 #include "guicast.h"
   8 #include "mutex.h"
   9 #include "pluginaclient.h"
  10 #include "vframe.inc"
  11
  12
  13 class Synth;
  14 class SynthWindow;
  15
  16 #define TOTALOSCILLATORS 1
  17 #define OSCILLATORHEIGHT 40
  18
  19 #define SINE 0
  20 #define SAWTOOTH 1
  21 #define SQUARE 2
  22 #define TRIANGLE 3
  23 #define PULSE 4
  24 #define NOISE 5
  25 #define DC    6
  26
  27
  28 class SynthCanvas;
  29 class SynthWaveForm;
  30 class SynthBaseFreq;
  31 class SynthFreqPot;
  32 class SynthOscGUI;
  33 class SynthScroll;
  34 class SynthSubWindow;
  35 class SynthWetness;
  36
  37 class SynthWindow : public BC_Window
  38 {
  39 public:
  40         SynthWindow(Synth *synth, int x, int y);
  41         ~SynthWindow();
  42
  43         int create_objects();
  44         int close_event();
  45         int resize_event(int w, int h);
  46         void update_gui();
  47         int waveform_to_text(char *text, int waveform);
  48         void update_scrollbar();
  49         void update_oscillators();
  50
  51
  52         Synth *synth;
  53         SynthCanvas *canvas;
  54         SynthWetness *wetness;
  55         SynthWaveForm *waveform;
  56         SynthBaseFreq *base_freq;
  57         SynthFreqPot *freqpot;
  58         SynthSubWindow *subwindow;
  59         SynthScroll *scroll;
  60         ArrayList<SynthOscGUI*> oscillators;
  61 };
  62
  63
  64 class SynthOscGUILevel;
  65 class SynthOscGUIPhase;
  66 class SynthOscGUIFreq;
  67
  68 class SynthOscGUI
  69 {
  70 public:
  71         SynthOscGUI(SynthWindow *window, int number);
  72         ~SynthOscGUI();
  73
  74         int create_objects(int view_y);
  75
  76         SynthOscGUILevel *level;
  77         SynthOscGUIPhase *phase;
  78         SynthOscGUIFreq *freq;
  79         BC_Title *title;
  80
  81         int number;
  82         SynthWindow *window;
  83 };
  84
  85 class SynthOscGUILevel : public BC_FPot
  86 {
  87 public:
  88         SynthOscGUILevel(Synth *synth, SynthOscGUI *gui, int y);
  89         ~SynthOscGUILevel();
  90
  91         int handle_event();
  92
  93         Synth *synth;
  94         SynthOscGUI *gui;
  95 };
  96
  97 class SynthOscGUIPhase : public BC_IPot
  98 {
  99 public:
 100         SynthOscGUIPhase(Synth *synth, SynthOscGUI *gui, int y);
 101         ~SynthOscGUIPhase();
 102
 103         int handle_event();
 104
 105         Synth *synth;
 106         SynthOscGUI *gui;
 107 };
 108
 109 class SynthOscGUIFreq : public BC_IPot
 110 {
 111 public:
 112         SynthOscGUIFreq(Synth *synth, SynthOscGUI *gui, int y);
 113         ~SynthOscGUIFreq();
 114
 115         int handle_event();
 116
 117         Synth *synth;
 118         SynthOscGUI *gui;
 119 };
 120
 121 class SynthScroll : public BC_ScrollBar
 122 {
 123 public:
 124         SynthScroll(Synth *synth, SynthWindow *window, int x, int y, int h);
 125         ~SynthScroll();
 126
 127         int handle_event();
 128
 129         Synth *synth;
 130         SynthWindow *window;
 131 };
 132
 133 class SynthAddOsc : public BC_GenericButton
 134 {
 135 public:
 136         SynthAddOsc(Synth *synth, SynthWindow *window, int x, int y);
 137         ~SynthAddOsc();
 138
 139         int handle_event();
 140
 141         Synth *synth;
 142         SynthWindow *window;
 143 };
 144
 145
 146 class SynthDelOsc : public BC_GenericButton
 147 {
 148 public:
 149         SynthDelOsc(Synth *synth, SynthWindow *window, int x, int y);
 150         ~SynthDelOsc();
 151
 152         int handle_event();
 153
 154         Synth *synth;
 155         SynthWindow *window;
 156 };
 157
 158 class SynthSubWindow : public BC_SubWindow
 159 {
 160 public:
 161         SynthSubWindow(Synth *synth, int x, int y, int w, int h);
 162         ~SynthSubWindow();
 163
 164         Synth *synth;
 165 };
 166
 167 class SynthClear : public BC_GenericButton
 168 {
 169 public:
 170         SynthClear(Synth *synth, int x, int y);
 171         ~SynthClear();
 172         int handle_event();
 173         Synth *synth;
 174 };
 175
 176 class SynthWaveForm : public BC_PopupMenu
 177 {
 178 public:
 179         SynthWaveForm(Synth *synth, int x, int y, char *text);
 180         ~SynthWaveForm();
 181
 182         int create_objects();
 183         Synth *synth;
 184 };
 185
 186 class SynthWaveFormItem : public BC_MenuItem
 187 {
 188 public:
 189         SynthWaveFormItem(Synth *synth, char *text, int value);
 190         ~SynthWaveFormItem();
 191
 192         int handle_event();
 193
 194         int value;
 195         Synth *synth;
 196 };
 197
 198 class SynthBaseFreq : public BC_TextBox
 199 {
 200 public:
 201         SynthBaseFreq(Synth *synth, int x, int y);
 202         ~SynthBaseFreq();
 203         int handle_event();
 204         Synth *synth;
 205         SynthFreqPot *freq_pot;
 206 };
 207
 208 class SynthFreqPot : public BC_QPot
 209 {
 210 public:
 211         SynthFreqPot(Synth *synth, SynthWindow *window, int x, int y);
 212         ~SynthFreqPot();
 213         int handle_event();
 214         SynthWindow *window;
 215         Synth *synth;
 216         SynthBaseFreq *freq_text;
 217 };
 218
 219 class SynthWetness : public BC_FPot
 220 {
 221 public:
 222         SynthWetness(Synth *synth, int x, int y);
 223         int handle_event();
 224         Synth *synth;
 225 };
 226
 227
 228 class SynthCanvas : public BC_SubWindow
 229 {
 230 public:
 231         SynthCanvas(Synth *synth,
 232                 SynthWindow *window,
 233                 int x,
 234                 int y,
 235                 int w,
 236                 int h);
 237         ~SynthCanvas();
 238
 239         int update();
 240         Synth *synth;
 241         SynthWindow *window;
 242 };
 243
 244 // ======================= level calculations
 245 class SynthLevelZero : public BC_MenuItem
 246 {
 247 public:
 248         SynthLevelZero(Synth *synth);
 249         ~SynthLevelZero();
 250         int handle_event();
 251         Synth *synth;
 252 };
 253
 254 class SynthLevelMax : public BC_MenuItem
 255 {
 256 public:
 257         SynthLevelMax(Synth *synth);
 258         ~SynthLevelMax();
 259         int handle_event();
 260         Synth *synth;
 261 };
 262
 263 class SynthLevelNormalize : public BC_MenuItem
 264 {
 265 public:
 266         SynthLevelNormalize(Synth *synth);
 267         ~SynthLevelNormalize();
 268         int handle_event();
 269         Synth *synth;
 270 };
 271
 272 class SynthLevelSlope : public BC_MenuItem
 273 {
 274 public:
 275         SynthLevelSlope(Synth *synth);
 276         ~SynthLevelSlope();
 277         int handle_event();
 278         Synth *synth;
 279 };
 280
 281 class SynthLevelRandom : public BC_MenuItem
 282 {
 283 public:
 284         SynthLevelRandom(Synth *synth);
 285         ~SynthLevelRandom();
 286         int handle_event();
 287         Synth *synth;
 288 };
 289
 290 class SynthLevelInvert : public BC_MenuItem
 291 {
 292 public:
 293         SynthLevelInvert(Synth *synth);
 294         ~SynthLevelInvert();
 295         int handle_event();
 296         Synth *synth;
 297 };
 298
 299 class SynthLevelSine : public BC_MenuItem
 300 {
 301 public:
 302         SynthLevelSine(Synth *synth);
 303         ~SynthLevelSine();
 304         int handle_event();
 305         Synth *synth;
 306 };
 307
 308 // ============================ phase calculations
 309
 310 class SynthPhaseInvert : public BC_MenuItem
 311 {
 312 public:
 313         SynthPhaseInvert(Synth *synth);
 314         ~SynthPhaseInvert();
 315         int handle_event();
 316         Synth *synth;
 317 };
 318
 319 class SynthPhaseZero : public BC_MenuItem
 320 {
 321 public:
 322         SynthPhaseZero(Synth *synth);
 323         ~SynthPhaseZero();
 324         int handle_event();
 325         Synth *synth;
 326 };
 327
 328 class SynthPhaseSine : public BC_MenuItem
 329 {
 330 public:
 331         SynthPhaseSine(Synth *synth);
 332         ~SynthPhaseSine();
 333         int handle_event();
 334         Synth *synth;
 335 };
 336
 337 class SynthPhaseRandom : public BC_MenuItem
 338 {
 339 public:
 340         SynthPhaseRandom(Synth *synth);
 341         ~SynthPhaseRandom();
 342         int handle_event();
 343         Synth *synth;
 344 };
 345
 346
 347 // ============================ freq calculations
 348
 349 class SynthFreqRandom : public BC_MenuItem
 350 {
 351 public:
 352         SynthFreqRandom(Synth *synth);
 353         ~SynthFreqRandom();
 354         int handle_event();
 355         Synth *synth;
 356 };
 357
 358 class SynthFreqEnum : public BC_MenuItem
 359 {
 360 public:
 361         SynthFreqEnum(Synth *synth);
 362         ~SynthFreqEnum();
 363         int handle_event();
 364         Synth *synth;
 365 };
 366
 367 class SynthFreqEven : public BC_MenuItem
 368 {
 369 public:
 370         SynthFreqEven(Synth *synth);
 371         ~SynthFreqEven();
 372         int handle_event();
 373         Synth *synth;
 374 };
 375
 376 class SynthFreqOdd : public BC_MenuItem
 377 {
 378 public:
 379         SynthFreqOdd(Synth *synth);
 380         ~SynthFreqOdd();
 381         int handle_event();
 382         Synth *synth;
 383 };
 384
 385 class SynthFreqFibonacci : public BC_MenuItem
 386 {
 387 public:
 388         SynthFreqFibonacci(Synth *synth);
 389         ~SynthFreqFibonacci();
 390         int handle_event();
 391         Synth *synth;
 392 };
 393
 394 class SynthFreqPrime : public BC_MenuItem
 395 {
 396 public:
 397         SynthFreqPrime(Synth *synth);
 398         ~SynthFreqPrime();
 399         int handle_event();
 400         Synth *synth;
 401 private:
 402         float get_next_prime(float number);
 403 };
 404
 405
 406 class SynthThread : public Thread
 407 {
 408 public:
 409         SynthThread(Synth *synth);
 410         ~SynthThread();
 411
 412         void run();
 413
 414         Mutex completion;
 415         Synth *synth;
 416         SynthWindow *window;
 417 };
 418
 419 class SynthOscillatorConfig
 420 {
 421 public:
 422         SynthOscillatorConfig(int number);
 423         ~SynthOscillatorConfig();
 424
 425         int equivalent(SynthOscillatorConfig &that);
 426         void copy_from(SynthOscillatorConfig& that);
 427         void reset();
 428         void load_defaults(Defaults *defaults);
 429         void save_defaults(Defaults *defaults);
 430         void read_data(FileXML *file);
 431         void save_data(FileXML *file);
 432         int is_realtime();
 433
 434         float level;
 435         float phase;
 436         float freq_factor;
 437         int number;
 438 };
 439
 440
 441
 442 class SynthConfig
 443 {
 444 public:
 445         SynthConfig();
 446         ~SynthConfig();
 447
 448         int equivalent(SynthConfig &that);
 449         void copy_from(SynthConfig &that);
 450         void interpolate(SynthConfig &prev,
 451                 SynthConfig &next,
 452                 int64_t prev_frame,
 453                 int64_t next_frame,
 454                 int64_t current_frame);
 455         void reset();
 456
 457         float wetness;
 458         int64_t base_freq;         // base frequency for oscillators
 459         int wavefunction;        // SINE, SAWTOOTH, etc
 460         ArrayList<SynthOscillatorConfig*> oscillator_config;
 461 };
 462
 463
 464 class Synth : public PluginAClient
 465 {
 466 public:
 467         Synth(PluginServer *server);
 468         ~Synth();
 469
 470
 471
 472         int is_realtime();
 473         int is_synthesis();
 474         int load_configuration();
 475         int load_defaults();
 476         VFrame* new_picon();
 477         char* plugin_title();
 478         void read_data(KeyFrame *keyframe);
 479         void save_data(KeyFrame *keyframe);
 480         int save_defaults();
 481         int show_gui();
 482         void raise_window();
 483         int set_string();
 484         int process_realtime(int64_t size, double *input_ptr, double *output_ptr);
 485
 486
 487
 488
 489
 490
 491
 492         void add_oscillator();
 493         void delete_oscillator();
 494         double get_total_power();
 495         double get_oscillator_point(float x,
 496                 double normalize_constant,
 497                 int oscillator);
 498         double solve_eqn(double *output,
 499                 double x1,
 500                 double x2,
 501                 double normalize_constant,
 502                 int oscillator);
 503         double get_point(float x, double normalize_constant);
 504         double function_square(double x);
 505         double function_pulse(double x);
 506         double function_noise();
 507         double function_sawtooth(double x);
 508         double function_triangle(double x);
 509         void reconfigure();
 510         int overlay_synth(int64_t start, int64_t length, double *input, double *output);
 511         void update_gui();
 512         void reset();
 513
 514
 515
 516         double *dsp_buffer;
 517         int need_reconfigure;
 518         Defaults *defaults;
 519         SynthThread *thread;
 520         SynthConfig config;
 521         int w, h;
 522         DB db;
 523         int64_t waveform_length;           // length of loop buffer
 524         int64_t waveform_sample;           // current sample in waveform of loop
 525         int64_t samples_rendered;          // samples of the dsp_buffer rendered since last buffer redo
 526         float period;            // number of samples in a period for this frequency
 527 };
 528
 529
 530
 531
 532
 533
 534
 535
 536 #endif