hvirtual/plugins/synthesizer/synthesizer.C

   1 #include "bcdisplayinfo.h"
   2 #include "clip.h"
   3 #include "defaults.h"
   4 #include "filexml.h"
   5 #include "picon_png.h"
   6 #include "synthesizer.h"
   7 #include "vframe.h"
   8
   9 #include <string.h>
  10
  11
  12 #include <libintl.h>
  13 #define _(String) gettext(String)
  14 #define gettext_noop(String) String
  15 #define N_(String) gettext_noop (String)
  16
  17
  18
  19 PluginClient* new_plugin(PluginServer *server)
  20 {
  21         return new Synth(server);
  22 }
  23
  24
  25
  26
  27
  28 Synth::Synth(PluginServer *server)
  29  : PluginAClient(server)
  30 {
  31         reset();
  32         load_defaults();
  33 }
  34
  35
  36
  37 Synth::~Synth()
  38 {
  39         if(thread)
  40         {
  41                 thread->window->set_done(0);
  42                 thread->completion.lock();
  43                 delete thread;
  44         }
  45
  46         save_defaults();
  47         delete defaults;
  48
  49         if(dsp_buffer) delete [] dsp_buffer;
  50 }
  51
  52 VFrame* Synth::new_picon()
  53 {
  54         return new VFrame(picon_png);
  55 }
  56
  57
  58 char* Synth::plugin_title() { return N_("Synthesizer"); }
  59 int Synth::is_realtime() { return 1; }
  60 int Synth::is_synthesis() { return 1; }
  61
  62
  63 void Synth::reset()
  64 {
  65         thread = 0;
  66         need_reconfigure = 1;
  67         dsp_buffer = 0;
  68 }
  69
  70
  71
  72
  73 LOAD_CONFIGURATION_MACRO(Synth, SynthConfig)
  74
  75
  76
  77
  78 int Synth::load_defaults()
  79 {
  80         char directory[BCTEXTLEN], string[BCTEXTLEN];
  81
  82         sprintf(directory, "%ssynthesizer.rc", BCASTDIR);
  83         defaults = new Defaults(directory);
  84         defaults->load();
  85         w = defaults->get("WIDTH", 380);
  86         h = defaults->get("HEIGHT", 400);
  87
  88         config.wetness = defaults->get("WETNESS", 0);
  89         config.base_freq = defaults->get("BASEFREQ", 440);
  90         config.wavefunction = defaults->get("WAVEFUNCTION", 0);
  91
  92         int total_oscillators = defaults->get("OSCILLATORS", TOTALOSCILLATORS);
  93         config.oscillator_config.remove_all_objects();
  94         for(int i = 0; i < total_oscillators; i++)
  95         {
  96                 config.oscillator_config.append(new SynthOscillatorConfig(i));
  97                 config.oscillator_config.values[i]->load_defaults(defaults);
  98         }
  99
 100         return 0;
 101 }
 102
 103
 104 void Synth::read_data(KeyFrame *keyframe)
 105 {
 106         FileXML input;
 107 // cause htal file to read directly from text
 108         input.set_shared_string(keyframe->data, strlen(keyframe->data));
 109
 110 //printf("Synth::read_data %s\n", keyframe->data);
 111         int result = 0, current_osc = 0, total_oscillators = 0;
 112         while(!result)
 113         {
 114                 result = input.read_tag();
 115
 116                 if(!result)
 117                 {
 118                         if(input.tag.title_is("SYNTH"))
 119                         {
 120                                 config.wetness = input.tag.get_property("WETNESS", config.wetness);
 121                                 config.base_freq = input.tag.get_property("BASEFREQ", config.base_freq);
 122                                 config.wavefunction = input.tag.get_property("WAVEFUNCTION", config.wavefunction);
 123                                 total_oscillators = input.tag.get_property("OSCILLATORS", 0);
 124                         }
 125                         else
 126                         if(input.tag.title_is("OSCILLATOR"))
 127                         {
 128                                 if(current_osc >= config.oscillator_config.total)
 129                                         config.oscillator_config.append(new SynthOscillatorConfig(current_osc));
 130
 131                                 config.oscillator_config.values[current_osc]->read_data(&input);
 132                                 current_osc++;
 133                         }
 134                 }
 135         }
 136
 137         while(config.oscillator_config.total > current_osc)
 138                 config.oscillator_config.remove_object();
 139 }
 140
 141 void Synth::save_data(KeyFrame *keyframe)
 142 {
 143         FileXML output;
 144 // cause htal file to store data directly in text
 145         output.set_shared_string(keyframe->data, MESSAGESIZE);
 146
 147         output.tag.set_title("SYNTH");
 148         output.tag.set_property("WETNESS", config.wetness);
 149         output.tag.set_property("BASEFREQ", config.base_freq);
 150         output.tag.set_property("WAVEFUNCTION", config.wavefunction);
 151         output.tag.set_property("OSCILLATORS", config.oscillator_config.total);
 152         output.append_tag();
 153         output.append_newline();
 154
 155         for(int i = 0; i < config.oscillator_config.total; i++)
 156         {
 157                 config.oscillator_config.values[i]->save_data(&output);
 158         }
 159
 160         output.terminate_string();
 161 // data is now in *text
 162 }
 163
 164 int Synth::save_defaults()
 165 {
 166         char string[BCTEXTLEN];
 167
 168         defaults->update("WIDTH", w);
 169         defaults->update("HEIGHT", h);
 170         defaults->update("WETNESS", config.wetness);
 171         defaults->update("BASEFREQ", config.base_freq);
 172         defaults->update("WAVEFUNCTION", config.wavefunction);
 173         defaults->update("OSCILLATORS", config.oscillator_config.total);
 174
 175         for(int i = 0; i < config.oscillator_config.total; i++)
 176         {
 177                 config.oscillator_config.values[i]->save_defaults(defaults);
 178         }
 179         defaults->save();
 180
 181         return 0;
 182 }
 183
 184 int Synth::show_gui()
 185 {
 186         load_configuration();
 187
 188         thread = new SynthThread(this);
 189         thread->start();
 190         return 0;
 191 }
 192
 193 int Synth::set_string()
 194 {
 195         if(thread) thread->window->set_title(gui_string);
 196         return 0;
 197 }
 198
 199 void Synth::raise_window()
 200 {
 201         if(thread)
 202         {
 203                 thread->window->raise_window();
 204                 thread->window->flush();
 205         }
 206 }
 207
 208 void Synth::update_gui()
 209 {
 210         if(thread)
 211         {
 212                 load_configuration();
 213                 thread->window->lock_window();
 214                 thread->window->update_gui();
 215                 thread->window->unlock_window();
 216         }
 217 }
 218
 219
 220 void Synth::add_oscillator()
 221 {
 222         if(config.oscillator_config.total > 20) return;
 223
 224         config.oscillator_config.append(new SynthOscillatorConfig(config.oscillator_config.total - 1));
 225 }
 226
 227 void Synth::delete_oscillator()
 228 {
 229         if(config.oscillator_config.total)
 230         {
 231                 config.oscillator_config.remove_object();
 232         }
 233 }
 234
 235
 236 double Synth::get_total_power()
 237 {
 238         double result = 0;
 239
 240         if(config.wavefunction == DC) return 1.0;
 241
 242         for(int i = 0; i < config.oscillator_config.total; i++)
 243         {
 244                 result += db.fromdb(config.oscillator_config.values[i]->level);
 245         }
 246
 247         if(result == 0) result = 1;  // prevent division by 0
 248         return result;
 249 }
 250
 251
 252 double Synth::solve_eqn(double *output,
 253         double x1,
 254         double x2,
 255         double normalize_constant,
 256         int oscillator)
 257 {
 258         SynthOscillatorConfig *config = this->config.oscillator_config.values[oscillator];
 259         if(config->level <= INFINITYGAIN) return 0;
 260
 261         double result;
 262         register double x;
 263         double power = this->db.fromdb(config->level) * normalize_constant;
 264         double phase_offset = config->phase * this->period;
 265         double x3 = x1 + phase_offset;
 266         double x4 = x2 + phase_offset;
 267         double period = this->period / config->freq_factor;
 268         int sample;
 269
 270         switch(this->config.wavefunction)
 271         {
 272                 case DC:
 273                         for(sample = (int)x1, x = x3; x < x4; x++, sample++)
 274                         {
 275                                 output[sample] += power;
 276                         }
 277                         break;
 278                 case SINE:
 279                         for(sample = (int)x1, x = x3; x < x4; x++, sample++)
 280                         {
 281                                 output[sample] += sin(x / period * 2 * M_PI) * power;
 282                         }
 283                         break;
 284                 case SAWTOOTH:
 285                         for(sample = (int)x1, x = x3; x < x4; x++, sample++)
 286                         {
 287                                 output[sample] += function_sawtooth(x / period) * power;
 288                         }
 289                         break;
 290                 case SQUARE:
 291                         for(sample = (int)x1, x = x3; x < x4; x++, sample++)
 292                         {
 293                                 output[sample] += function_square(x / period) * power;
 294                         }
 295                         break;
 296                 case TRIANGLE:
 297                         for(sample = (int)x1, x = x3; x < x4; x++, sample++)
 298                         {
 299                                 output[sample] += function_triangle(x / period) * power;
 300                         }
 301                         break;
 302                 case PULSE:
 303                         for(sample = (int)x1, x = x3; x < x4; x++, sample++)
 304                         {
 305                                 output[sample] += function_pulse(x / period) * power;
 306                         }
 307                         break;
 308                 case NOISE:
 309                         for(sample = (int)x1, x = x3; x < x4; x++, sample++)
 310                         {
 311                                 output[sample] += function_noise() * power;
 312                         }
 313                         break;
 314         }
 315 }
 316
 317 double Synth::get_point(float x, double normalize_constant)
 318 {
 319         double result = 0;
 320         for(int i = 0; i < config.oscillator_config.total; i++)
 321                 result += get_oscillator_point(x, normalize_constant, i);
 322
 323         return result;
 324 }
 325
 326 double Synth::get_oscillator_point(float x,
 327                 double normalize_constant,
 328                 int oscillator)
 329 {
 330         SynthOscillatorConfig *config = this->config.oscillator_config.values[oscillator];
 331         double power = db.fromdb(config->level) * normalize_constant;
 332         switch(this->config.wavefunction)
 333         {
 334                 case DC:
 335                         return power;
 336                         break;
 337                 case SINE:
 338                         return sin((x + config->phase) * config->freq_factor * 2 * M_PI) * power;
 339                         break;
 340                 case SAWTOOTH:
 341                         return function_sawtooth((x + config->phase) * config->freq_factor) * power;
 342                         break;
 343                 case SQUARE:
 344                         return function_square((x + config->phase) * config->freq_factor) * power;
 345                         break;
 346                 case TRIANGLE:
 347                         return function_triangle((x + config->phase) * config->freq_factor) * power;
 348                         break;
 349                 case PULSE:
 350                         return function_pulse((x + config->phase) * config->freq_factor) * power;
 351                         break;
 352                 case NOISE:
 353                         return function_noise() * power;
 354                         break;
 355         }
 356 }
 357
 358 double Synth::function_square(double x)
 359 {
 360         x -= (int)x; // only fraction counts
 361         return (x < .5) ? -1 : 1;
 362 }
 363
 364 double Synth::function_pulse(double x)
 365 {
 366         x -= (int)x; // only fraction counts
 367         return (x < .5) ? 0 : 1;
 368 }
 369
 370 double Synth::function_noise()
 371 {
 372         return (double)(rand() % 65536 - 32768) / 32768;
 373 }
 374
 375 double Synth::function_sawtooth(double x)
 376 {
 377         x -= (int)x;
 378         return 1 - x * 2;
 379 }
 380
 381 double Synth::function_triangle(double x)
 382 {
 383         x -= (int)x;
 384         return (x < .5) ? 1 - x * 4 : -3 + x * 4;
 385 }
 386
 387 int Synth::process_realtime(int64_t size, double *input_ptr, double *output_ptr)
 388 {
 389
 390
 391         need_reconfigure |= load_configuration();
 392         if(need_reconfigure) reconfigure();
 393
 394         double wetness = DB::fromdb(config.wetness);
 395         if(EQUIV(config.wetness, INFINITYGAIN)) wetness = 0;
 396
 397         for(int j = 0; j < size; j++)
 398                 output_ptr[j] = input_ptr[j] * wetness;
 399
 400         int64_t fragment_len;
 401         for(int64_t i = 0; i < size; i += fragment_len)
 402         {
 403                 fragment_len = size;
 404                 if(i + fragment_len > size) fragment_len = size - i;
 405
 406 //printf("Synth::process_realtime 1 %d %d %d\n", i, fragment_len, size);
 407                 fragment_len = overlay_synth(i, fragment_len, input_ptr, output_ptr);
 408 //printf("Synth::process_realtime 2\n");
 409         }
 410
 411
 412         return 0;
 413 }
 414
 415 int Synth::overlay_synth(int64_t start, int64_t length, double *input, double *output)
 416 {
 417         if(waveform_sample + length > waveform_length)
 418                 length = waveform_length - waveform_sample;
 419
 420 //printf("Synth::overlay_synth 1 %d %d\n", length, waveform_length);
 421
 422 // calculate some more data
 423 // only calculate what's needed to speed it up
 424         if(waveform_sample + length > samples_rendered)
 425         {
 426                 int64_t start = waveform_sample, end = waveform_sample + length;
 427                 for(int i = start; i < end; i++) dsp_buffer[i] = 0;
 428
 429                 double normalize_constant = 1 / get_total_power();
 430                 for(int i = 0; i < config.oscillator_config.total; i++)
 431                         solve_eqn(dsp_buffer,
 432                                 start,
 433                                 end,
 434                                 normalize_constant,
 435                                 i);
 436
 437
 438                 samples_rendered = end;
 439         }
 440 //printf("Synth::overlay_synth 2\n");
 441
 442
 443         double *buffer_in = &input[start];
 444         double *buffer_out = &output[start];
 445
 446         for(int i = 0; i < length; i++)
 447         {
 448                 buffer_out[i] += dsp_buffer[waveform_sample++];
 449         }
 450 //printf("Synth::overlay_synth 3\n");
 451
 452         if(waveform_sample >= waveform_length) waveform_sample = 0;
 453
 454         return length;
 455 }
 456
 457 void Synth::reconfigure()
 458 {
 459         need_reconfigure = 0;
 460
 461         if(dsp_buffer)
 462         {
 463                 delete [] dsp_buffer;
 464         }
 465
 466 //printf("Synth::reconfigure 1 %d\n", PluginAClient::project_sample_rate);
 467         waveform_length = PluginAClient::project_sample_rate;
 468         period = (float)PluginAClient::project_sample_rate / config.base_freq;
 469         dsp_buffer = new double[waveform_length + 1];
 470
 471         samples_rendered = 0;     // do some calculations on the next process_realtime
 472         waveform_sample = 0;
 473 }
 474
 475
 476
 477
 478
 479
 480
 481
 482
 483
 484
 485
 486
 487
 488
 489
 490
 491
 492
 493
 494
 495 SynthThread::SynthThread(Synth *synth)
 496  : Thread()
 497 {
 498         this->synth = synth;
 499         set_synchronous(0);
 500         completion.lock();
 501 }
 502
 503 SynthThread::~SynthThread()
 504 {
 505         delete window;
 506 }
 507
 508 void SynthThread::run()
 509 {
 510         BC_DisplayInfo info;
 511         window = new SynthWindow(synth,
 512                 info.get_abs_cursor_x() - 125,
 513                 info.get_abs_cursor_y() - 115);
 514         window->create_objects();
 515         int result = window->run_window();
 516         completion.unlock();
 517 // Last command executed in thread
 518         if(result) synth->client_side_close();
 519 }
 520
 521
 522
 523
 524
 525
 526
 527
 528
 529
 530
 531 SynthWindow::SynthWindow(Synth *synth, int x, int y)
 532  : BC_Window(synth->gui_string,
 533         x,
 534         y,
 535         380,
 536         synth->h,
 537         380,
 538         10,
 539         1,
 540         0,
 541         1)
 542 {
 543         this->synth = synth;
 544 }
 545
 546 SynthWindow::~SynthWindow()
 547 {
 548 }
 549
 550 int SynthWindow::create_objects()
 551 {
 552         BC_MenuBar *menu;
 553         add_subwindow(menu = new BC_MenuBar(0, 0, get_w()));
 554
 555         BC_Menu *levelmenu, *phasemenu, *harmonicmenu;
 556         menu->add_menu(levelmenu = new BC_Menu(_("Level")));
 557         menu->add_menu(phasemenu = new BC_Menu(_("Phase")));
 558         menu->add_menu(harmonicmenu = new BC_Menu(_("Harmonic")));
 559
 560         levelmenu->add_item(new SynthLevelInvert(synth));
 561         levelmenu->add_item(new SynthLevelMax(synth));
 562         levelmenu->add_item(new SynthLevelRandom(synth));
 563         levelmenu->add_item(new SynthLevelSine(synth));
 564         levelmenu->add_item(new SynthLevelSlope(synth));
 565         levelmenu->add_item(new SynthLevelZero(synth));
 566
 567         phasemenu->add_item(new SynthPhaseInvert(synth));
 568         phasemenu->add_item(new SynthPhaseRandom(synth));
 569         phasemenu->add_item(new SynthPhaseSine(synth));
 570         phasemenu->add_item(new SynthPhaseZero(synth));
 571
 572         harmonicmenu->add_item(new SynthFreqEnum(synth));
 573         harmonicmenu->add_item(new SynthFreqEven(synth));
 574         harmonicmenu->add_item(new SynthFreqFibonacci(synth));
 575         harmonicmenu->add_item(new SynthFreqOdd(synth));
 576         harmonicmenu->add_item(new SynthFreqPrime(synth));
 577
 578         int x = 10, y = 30, i;
 579         add_subwindow(new BC_Title(x, y, _("Waveform")));
 580         x += 240;
 581         add_subwindow(new BC_Title(x, y, _("Wave Function")));
 582         y += 20;
 583         x = 10;
 584         add_subwindow(canvas = new SynthCanvas(synth, this, x, y, 230, 160));
 585         canvas->update();
 586
 587         x += 240;
 588         char string[BCTEXTLEN];
 589         waveform_to_text(string, synth->config.wavefunction);
 590
 591         add_subwindow(waveform = new SynthWaveForm(synth, x, y, string));
 592         waveform->create_objects();
 593         y += 30;
 594
 595
 596         add_subwindow(new BC_Title(x, y, _("Base Frequency:")));
 597         y += 30;
 598         add_subwindow(base_freq = new SynthBaseFreq(synth, x, y));
 599         x += 80;
 600         add_subwindow(freqpot = new SynthFreqPot(synth, this, x, y - 10));
 601         base_freq->freq_pot = freqpot;
 602         freqpot->freq_text = base_freq;
 603         x -= 80;
 604         y += 40;
 605         add_subwindow(new BC_Title(x, y, _("Wetness:")));
 606         add_subwindow(wetness = new SynthWetness(synth, x + 70, y - 10));
 607
 608         y += 40;
 609         add_subwindow(new SynthClear(synth, x, y));
 610
 611
 612         x = 50;
 613         y = 220;
 614         add_subwindow(new BC_Title(x, y, _("Level")));
 615         x += 75;
 616         add_subwindow(new BC_Title(x, y, _("Phase")));
 617         x += 75;
 618         add_subwindow(new BC_Title(x, y, _("Harmonic")));
 619
 620
 621
 622         y += 20; x = 10;
 623         add_subwindow(subwindow = new SynthSubWindow(synth, x, y, 265, get_h() - y));
 624         x += 265;
 625         add_subwindow(scroll = new SynthScroll(synth, this, x, y, get_h() - y));
 626
 627
 628         x += 20;
 629         add_subwindow(new SynthAddOsc(synth, this, x, y));
 630         y += 30;
 631         add_subwindow(new SynthDelOsc(synth, this, x, y));
 632
 633         update_scrollbar();
 634         update_oscillators();
 635
 636         show_window();
 637         flush();
 638         return 0;
 639 }
 640
 641 int SynthWindow::close_event()
 642 {
 643 // Set result to 1 to indicate a client side close
 644         set_done(1);
 645         return 1;
 646 }
 647
 648 int SynthWindow::resize_event(int w, int h)
 649 {
 650         clear_box(0, 0, w, h);
 651         subwindow->reposition_window(subwindow->get_x(),
 652                 subwindow->get_y(),
 653                 subwindow->get_w(),
 654                 h - subwindow->get_y());
 655         subwindow->clear_box(0, 0, subwindow->get_w(), subwindow->get_h());
 656         scroll->reposition_window(scroll->get_x(),
 657                 scroll->get_y(),
 658                 h - scroll->get_y());
 659         update_scrollbar();
 660         update_oscillators();
 661         synth->w = w;
 662         synth->h = h;
 663         return 1;
 664 }
 665
 666 void SynthWindow::update_gui()
 667 {
 668         char string[BCTEXTLEN];
 669         freqpot->update(synth->config.base_freq);
 670         base_freq->update((int64_t)synth->config.base_freq);
 671         wetness->update(synth->config.wetness);
 672         waveform_to_text(string, synth->config.wavefunction);
 673         waveform->set_text(string);
 674
 675         update_scrollbar();
 676         update_oscillators();
 677         canvas->update();
 678 }
 679
 680 void SynthWindow::update_scrollbar()
 681 {
 682         scroll->update_length(synth->config.oscillator_config.total * OSCILLATORHEIGHT,
 683                 scroll->get_position(),
 684                 subwindow->get_h());
 685 }
 686
 687 void SynthWindow::update_oscillators()
 688 {
 689         int i, y = -scroll->get_position();
 690
 691
 692
 693 // Add new oscillators
 694         for(i = 0;
 695                 i < synth->config.oscillator_config.total;
 696                 i++)
 697         {
 698                 SynthOscGUI *gui;
 699                 SynthOscillatorConfig *config = synth->config.oscillator_config.values[i];
 700
 701                 if(oscillators.total <= i)
 702                 {
 703                         oscillators.append(gui = new SynthOscGUI(this, i));
 704                         gui->create_objects(y);
 705                 }
 706                 else
 707                 {
 708                         gui = oscillators.values[i];
 709
 710                         gui->title->reposition_window(gui->title->get_x(), y + 15);
 711
 712                         gui->level->reposition_window(gui->level->get_x(), y);
 713                         gui->level->update(config->level);
 714
 715                         gui->phase->reposition_window(gui->phase->get_x(), y);
 716                         gui->phase->update((int64_t)(config->phase * 360));
 717
 718                         gui->freq->reposition_window(gui->freq->get_x(), y);
 719                         gui->freq->update((int64_t)(config->freq_factor));
 720                 }
 721                 y += OSCILLATORHEIGHT;
 722         }
 723
 724 // Delete old oscillators
 725         for( ;
 726                 i < oscillators.total;
 727                 i++)
 728                 oscillators.remove_object();
 729 }
 730
 731
 732 int SynthWindow::waveform_to_text(char *text, int waveform)
 733 {
 734         switch(waveform)
 735         {
 736                 case DC:              sprintf(text, _("DC"));           break;
 737                 case SINE:            sprintf(text, _("Sine"));           break;
 738                 case SAWTOOTH:        sprintf(text, _("Sawtooth"));       break;
 739                 case SQUARE:          sprintf(text, _("Square"));         break;
 740                 case TRIANGLE:        sprintf(text, _("Triangle"));       break;
 741                 case PULSE:           sprintf(text, _("Pulse"));       break;
 742                 case NOISE:           sprintf(text, _("Noise"));       break;
 743         }
 744         return 0;
 745 }
 746
 747
 748
 749
 750
 751
 752
 753 SynthOscGUI::SynthOscGUI(SynthWindow *window, int number)
 754 {
 755         this->window = window;
 756         this->number = number;
 757 }
 758
 759 SynthOscGUI::~SynthOscGUI()
 760 {
 761         delete title;
 762         delete level;
 763         delete phase;
 764         delete freq;
 765 }
 766
 767 int SynthOscGUI::create_objects(int y)
 768 {
 769         char text[BCTEXTLEN];
 770         sprintf(text, "%d:", number + 1);
 771         window->subwindow->add_subwindow(title = new BC_Title(10, y + 15, text));
 772
 773         window->subwindow->add_subwindow(level = new SynthOscGUILevel(window->synth, this, y));
 774         window->subwindow->add_subwindow(phase = new SynthOscGUIPhase(window->synth, this, y));
 775         window->subwindow->add_subwindow(freq = new SynthOscGUIFreq(window->synth, this, y));
 776         return 1;
 777 }
 778
 779
 780
 781
 782 SynthOscGUILevel::SynthOscGUILevel(Synth *synth, SynthOscGUI *gui, int y)
 783  : BC_FPot(50,
 784         y,
 785         synth->config.oscillator_config.values[gui->number]->level,
 786         INFINITYGAIN,
 787         0)
 788 {
 789         this->synth = synth;
 790         this->gui = gui;
 791 }
 792
 793 SynthOscGUILevel::~SynthOscGUILevel()
 794 {
 795 }
 796
 797 int SynthOscGUILevel::handle_event()
 798 {
 799         SynthOscillatorConfig *config = synth->config.oscillator_config.values[gui->number];
 800         config->level = get_value();
 801         gui->window->canvas->update();
 802         synth->send_configure_change();
 803         return 1;
 804 }
 805
 806
 807
 808 SynthOscGUIPhase::SynthOscGUIPhase(Synth *synth, SynthOscGUI *gui, int y)
 809  : BC_IPot(125,
 810         y,
 811         (int64_t)(synth->config.oscillator_config.values[gui->number]->phase * 360),
 812         0,
 813         360)
 814 {
 815         this->synth = synth;
 816         this->gui = gui;
 817 }
 818
 819 SynthOscGUIPhase::~SynthOscGUIPhase()
 820 {
 821 }
 822
 823 int SynthOscGUIPhase::handle_event()
 824 {
 825         SynthOscillatorConfig *config = synth->config.oscillator_config.values[gui->number];
 826         config->phase = (float)get_value() / 360;
 827         gui->window->canvas->update();
 828         synth->send_configure_change();
 829         return 1;
 830 }
 831
 832
 833
 834 SynthOscGUIFreq::SynthOscGUIFreq(Synth *synth, SynthOscGUI *gui, int y)
 835  : BC_IPot(200,
 836         y,
 837         (int64_t)(synth->config.oscillator_config.values[gui->number]->freq_factor),
 838         1,
 839         100)
 840 {
 841         this->synth = synth;
 842         this->gui = gui;
 843 }
 844
 845 SynthOscGUIFreq::~SynthOscGUIFreq()
 846 {
 847 }
 848
 849 int SynthOscGUIFreq::handle_event()
 850 {
 851         SynthOscillatorConfig *config = synth->config.oscillator_config.values[gui->number];
 852         config->freq_factor = get_value();
 853         gui->window->canvas->update();
 854         synth->send_configure_change();
 855         return 1;
 856 }
 857
 858
 859
 860
 861
 862
 863
 864 SynthAddOsc::SynthAddOsc(Synth *synth, SynthWindow *window, int x, int y)
 865  : BC_GenericButton(x, y, _("Add"))
 866 {
 867         this->synth = synth;
 868         this->window = window;
 869 }
 870
 871 SynthAddOsc::~SynthAddOsc()
 872 {
 873 }
 874
 875 int SynthAddOsc::handle_event()
 876 {
 877         synth->add_oscillator();
 878         synth->send_configure_change();
 879         window->update_gui();
 880         return 1;
 881 }
 882
 883
 884
 885 SynthDelOsc::SynthDelOsc(Synth *synth, SynthWindow *window, int x, int y)
 886  : BC_GenericButton(x, y, _("Delete"))
 887 {
 888         this->synth = synth;
 889         this->window = window;
 890 }
 891
 892 SynthDelOsc::~SynthDelOsc()
 893 {
 894 }
 895
 896 int SynthDelOsc::handle_event()
 897 {
 898         synth->delete_oscillator();
 899         synth->send_configure_change();
 900         window->update_gui();
 901         return 1;
 902 }
 903
 904
 905 SynthScroll::SynthScroll(Synth *synth,
 906         SynthWindow *window,
 907         int x,
 908         int y,
 909         int h)
 910  : BC_ScrollBar(x,
 911         y,
 912         SCROLL_VERT,
 913         h,
 914         synth->config.oscillator_config.total * OSCILLATORHEIGHT,
 915         0,
 916         window->subwindow->get_h())
 917 {
 918         this->synth = synth;
 919         this->window = window;
 920 }
 921
 922 SynthScroll::~SynthScroll()
 923 {
 924 }
 925
 926 int SynthScroll::handle_event()
 927 {
 928         window->update_gui();
 929         return 1;
 930 }
 931
 932
 933
 934
 935
 936
 937
 938
 939 SynthSubWindow::SynthSubWindow(Synth *synth, int x, int y, int w, int h)
 940  : BC_SubWindow(x, y, w, h)
 941 {
 942         this->synth = synth;
 943 }
 944 SynthSubWindow::~SynthSubWindow()
 945 {
 946 }
 947
 948
 949
 950
 951
 952
 953
 954
 955
 956 SynthClear::SynthClear(Synth *synth, int x, int y)
 957  : BC_GenericButton(x, y, _("Clear"))
 958 {
 959         this->synth = synth;
 960 }
 961 SynthClear::~SynthClear()
 962 {
 963 }
 964 int SynthClear::handle_event()
 965 {
 966         synth->config.reset();
 967         synth->send_configure_change();
 968         synth->update_gui();
 969         return 1;
 970 }
 971
 972
 973
 974
 975
 976
 977 SynthWaveForm::SynthWaveForm(Synth *synth, int x, int y, char *text)
 978  : BC_PopupMenu(x, y, 120, text)
 979 {
 980         this->synth = synth;
 981 }
 982
 983 SynthWaveForm::~SynthWaveForm()
 984 {
 985 }
 986
 987 int SynthWaveForm::create_objects()
 988 {
 989 //      add_item(new SynthWaveFormItem(synth, _("DC"), DC));
 990         add_item(new SynthWaveFormItem(synth, _("Sine"), SINE));
 991         add_item(new SynthWaveFormItem(synth, _("Sawtooth"), SAWTOOTH));
 992         add_item(new SynthWaveFormItem(synth, _("Square"), SQUARE));
 993         add_item(new SynthWaveFormItem(synth, _("Triangle"), TRIANGLE));
 994         add_item(new SynthWaveFormItem(synth, _("Pulse"), PULSE));
 995         add_item(new SynthWaveFormItem(synth, _("Noise"), NOISE));
 996         return 0;
 997 }
 998
 999 SynthWaveFormItem::SynthWaveFormItem(Synth *synth, char *text, int value)
1000  : BC_MenuItem(text)
1001 {
1002         this->synth = synth;
1003         this->value = value;
1004 }
1005
1006 SynthWaveFormItem::~SynthWaveFormItem()
1007 {
1008 }
1009
1010 int SynthWaveFormItem::handle_event()
1011 {
1012         synth->config.wavefunction = value;
1013         synth->thread->window->canvas->update();
1014         synth->send_configure_change();
1015         return 1;
1016 }
1017
1018
1019 SynthWetness::SynthWetness(Synth *synth, int x, int y)
1020  : BC_FPot(x,
1021                 y,
1022                 synth->config.wetness,
1023                 INFINITYGAIN,
1024                 0)
1025 {
1026         this->synth = synth;
1027 }
1028
1029 int SynthWetness::handle_event()
1030 {
1031         synth->config.wetness = get_value();
1032         synth->send_configure_change();
1033         return 1;
1034 }
1035
1036
1037
1038 SynthFreqPot::SynthFreqPot(Synth *synth, SynthWindow *window, int x, int y)
1039  : BC_QPot(x, y, synth->config.base_freq)
1040 {
1041         this->synth = synth;
1042 }
1043 SynthFreqPot::~SynthFreqPot()
1044 {
1045 }
1046 int SynthFreqPot::handle_event()
1047 {
1048         if(get_value() > 0 && get_value() < 30000)
1049         {
1050                 synth->config.base_freq = get_value();
1051                 freq_text->update(get_value());
1052                 synth->send_configure_change();
1053         }
1054         return 1;
1055 }
1056
1057
1058
1059 SynthBaseFreq::SynthBaseFreq(Synth *synth, int x, int y)
1060  : BC_TextBox(x, y, 70, 1, (int)synth->config.base_freq)
1061 {
1062         this->synth = synth;
1063 }
1064 SynthBaseFreq::~SynthBaseFreq()
1065 {
1066 }
1067 int SynthBaseFreq::handle_event()
1068 {
1069         int new_value = atol(get_text());
1070
1071         if(new_value > 0 && new_value < 30000)
1072         {
1073                 synth->config.base_freq = new_value;
1074                 freq_pot->update(synth->config.base_freq);
1075                 synth->send_configure_change();
1076         }
1077         return 1;
1078 }
1079
1080
1081
1082
1083
1084 SynthCanvas::SynthCanvas(Synth *synth,
1085         SynthWindow *window,
1086         int x,
1087         int y,
1088         int w,
1089         int h)
1090  : BC_SubWindow(x,
1091         y,
1092         w,
1093         h,
1094         BLACK)
1095 {
1096         this->synth = synth;
1097         this->window = window;
1098 }
1099
1100 SynthCanvas::~SynthCanvas()
1101 {
1102 }
1103
1104 int SynthCanvas::update()
1105 {
1106         int y1, y2, y = 0;
1107
1108         clear_box(0, 0, get_w(), get_h());
1109         set_color(RED);
1110
1111         draw_line(0, get_h() / 2 + y, get_w(), get_h() / 2 + y);
1112
1113         set_color(GREEN);
1114
1115         double normalize_constant = (double)1 / synth->get_total_power();
1116         y1 = (int)(synth->get_point((float)0, normalize_constant) * get_h() / 2);
1117
1118         for(int i = 1; i < get_w(); i++)
1119         {
1120                 y2 = (int)(synth->get_point((float)i / get_w(), normalize_constant) * get_h() / 2);
1121                 draw_line(i - 1, get_h() / 2 - y1, i, get_h() / 2 - y2);
1122                 y1 = y2;
1123         }
1124         flash();
1125         return 0;
1126 }
1127
1128
1129
1130
1131
1132
1133
1134
1135 // ======================= level calculations
1136 SynthLevelZero::SynthLevelZero(Synth *synth)
1137  : BC_MenuItem(_("Zero"))
1138 {
1139         this->synth = synth;
1140 }
1141
1142 SynthLevelZero::~SynthLevelZero()
1143 {
1144 }
1145
1146 int SynthLevelZero::handle_event()
1147 {
1148         for(int i = 0; i < synth->config.oscillator_config.total; i++)
1149         {
1150                 synth->config.oscillator_config.values[i]->level = INFINITYGAIN;
1151         }
1152
1153         synth->thread->window->update_gui();
1154         synth->send_configure_change();
1155 }
1156
1157 SynthLevelMax::SynthLevelMax(Synth *synth)
1158  : BC_MenuItem(_("Maximum"))
1159 {
1160         this->synth = synth;
1161 }
1162
1163 SynthLevelMax::~SynthLevelMax()
1164 {
1165 }
1166
1167 int SynthLevelMax::handle_event()
1168 {
1169         for(int i = 0; i < synth->config.oscillator_config.total; i++)
1170         {
1171                 synth->config.oscillator_config.values[i]->level = 0;
1172         }
1173         synth->thread->window->update_gui();
1174         synth->send_configure_change();
1175 }
1176
1177 SynthLevelNormalize::SynthLevelNormalize(Synth *synth)
1178  : BC_MenuItem(_("Normalize"))
1179 {
1180         this->synth = synth;
1181 }
1182
1183 SynthLevelNormalize::~SynthLevelNormalize()
1184 {
1185 }
1186
1187 int SynthLevelNormalize::handle_event()
1188 {
1189 // get total power
1190         float total = 0;
1191
1192         for(int i = 0; i < synth->config.oscillator_config.total; i++)
1193         {
1194                 total += synth->db.fromdb(synth->config.oscillator_config.values[i]->level);
1195         }
1196
1197         float scale = 1 / total;
1198         float new_value;
1199
1200         for(int i = 0; i < synth->config.oscillator_config.total; i++)
1201         {
1202                 new_value = synth->db.fromdb(synth->config.oscillator_config.values[i]->level);
1203                 new_value *= scale;
1204                 new_value = synth->db.todb(new_value);
1205
1206                 synth->config.oscillator_config.values[i]->level = new_value;
1207         }
1208
1209         synth->thread->window->update_gui();
1210         synth->send_configure_change();
1211 }
1212
1213 SynthLevelSlope::SynthLevelSlope(Synth *synth)
1214  : BC_MenuItem(_("Slope"))
1215 {
1216         this->synth = synth;
1217 }
1218
1219 SynthLevelSlope::~SynthLevelSlope()
1220 {
1221 }
1222
1223 int SynthLevelSlope::handle_event()
1224 {
1225         float slope = (float)INFINITYGAIN / synth->config.oscillator_config.total;
1226
1227         for(int i = 0; i < synth->config.oscillator_config.total; i++)
1228         {
1229                 synth->config.oscillator_config.values[i]->level = i * slope;
1230         }
1231
1232         synth->thread->window->update_gui();
1233         synth->send_configure_change();
1234 }
1235
1236 SynthLevelRandom::SynthLevelRandom(Synth *synth)
1237  : BC_MenuItem(_("Random"))
1238 {
1239         this->synth = synth;
1240 }
1241 SynthLevelRandom::~SynthLevelRandom()
1242 {
1243 }
1244
1245 int SynthLevelRandom::handle_event()
1246 {
1247         srand(time(0));
1248         for(int i = 0; i < synth->config.oscillator_config.total; i++)
1249         {
1250                 synth->config.oscillator_config.values[i]->level = -(rand() % -INFINITYGAIN);
1251         }
1252
1253         synth->thread->window->update_gui();
1254         synth->send_configure_change();
1255 }
1256
1257 SynthLevelInvert::SynthLevelInvert(Synth *synth)
1258  : BC_MenuItem(_("Invert"))
1259 {
1260         this->synth = synth;
1261 }
1262 SynthLevelInvert::~SynthLevelInvert()
1263 {
1264 }
1265
1266 int SynthLevelInvert::handle_event()
1267 {
1268         for(int i = 0; i < synth->config.oscillator_config.total; i++)
1269         {
1270                 synth->config.oscillator_config.values[i]->level =
1271                         INFINITYGAIN - synth->config.oscillator_config.values[i]->level;
1272         }
1273
1274         synth->thread->window->update_gui();
1275         synth->send_configure_change();
1276 }
1277
1278 SynthLevelSine::SynthLevelSine(Synth *synth)
1279  : BC_MenuItem(_("Sine"))
1280 {
1281         this->synth = synth;
1282 }
1283 SynthLevelSine::~SynthLevelSine()
1284 {
1285 }
1286
1287 int SynthLevelSine::handle_event()
1288 {
1289         float new_value;
1290
1291         for(int i = 0; i < synth->config.oscillator_config.total; i++)
1292         {
1293                 new_value = (float)i / synth->config.oscillator_config.total * 2 * M_PI;
1294                 new_value = sin(new_value) * INFINITYGAIN / 2 + INFINITYGAIN / 2;
1295                 synth->config.oscillator_config.values[i]->level = new_value;
1296         }
1297
1298         synth->thread->window->update_gui();
1299         synth->send_configure_change();
1300 }
1301
1302 // ============================ phase calculations
1303
1304 SynthPhaseInvert::SynthPhaseInvert(Synth *synth)
1305  : BC_MenuItem(_("Invert"))
1306 {
1307         this->synth = synth;
1308 }
1309 SynthPhaseInvert::~SynthPhaseInvert()
1310 {
1311 }
1312
1313 int SynthPhaseInvert::handle_event()
1314 {
1315         for(int i = 0; i < synth->config.oscillator_config.total; i++)
1316         {
1317                 synth->config.oscillator_config.values[i]->phase =
1318                         1 - synth->config.oscillator_config.values[i]->phase;
1319         }
1320
1321         synth->thread->window->update_gui();
1322         synth->send_configure_change();
1323 }
1324
1325 SynthPhaseZero::SynthPhaseZero(Synth *synth)
1326  : BC_MenuItem(_("Zero"))
1327 {
1328         this->synth = synth;
1329 }
1330 SynthPhaseZero::~SynthPhaseZero()
1331 {
1332 }
1333
1334 int SynthPhaseZero::handle_event()
1335 {
1336         for(int i = 0; i < synth->config.oscillator_config.total; i++)
1337         {
1338                 synth->config.oscillator_config.values[i]->phase = 0;
1339         }
1340
1341         synth->thread->window->update_gui();
1342         synth->send_configure_change();
1343 }
1344
1345 SynthPhaseSine::SynthPhaseSine(Synth *synth)
1346  : BC_MenuItem(_("Sine"))
1347 {
1348         this->synth = synth;
1349 }
1350 SynthPhaseSine::~SynthPhaseSine()
1351 {
1352 }
1353
1354 int SynthPhaseSine::handle_event()
1355 {
1356         float new_value;
1357         for(int i = 0; i < synth->config.oscillator_config.total; i++)
1358         {
1359                 new_value = (float)i / synth->config.oscillator_config.total * 2 * M_PI;
1360                 new_value = sin(new_value) / 2 + .5;
1361                 synth->config.oscillator_config.values[i]->phase = new_value;
1362         }
1363
1364         synth->thread->window->update_gui();
1365         synth->send_configure_change();
1366 }
1367
1368 SynthPhaseRandom::SynthPhaseRandom(Synth *synth)
1369  : BC_MenuItem(_("Random"))
1370 {
1371         this->synth = synth;
1372 }
1373 SynthPhaseRandom::~SynthPhaseRandom()
1374 {
1375 }
1376
1377 int SynthPhaseRandom::handle_event()
1378 {
1379         srand(time(0));
1380         for(int i = 0; i < synth->config.oscillator_config.total; i++)
1381         {
1382                 synth->config.oscillator_config.values[i]->phase =
1383                         (float)(rand() % 360) / 360;
1384         }
1385
1386         synth->thread->window->update_gui();
1387         synth->send_configure_change();
1388 }
1389
1390
1391 // ============================ freq calculations
1392
1393 SynthFreqRandom::SynthFreqRandom(Synth *synth)
1394  : BC_MenuItem(_("Random"))
1395 {
1396         this->synth = synth;
1397 }
1398 SynthFreqRandom::~SynthFreqRandom()
1399 {
1400 }
1401
1402 int SynthFreqRandom::handle_event()
1403 {
1404         srand(time(0));
1405         for(int i = 0; i < synth->config.oscillator_config.total; i++)
1406         {
1407                 synth->config.oscillator_config.values[i]->freq_factor = rand() % 100;
1408         }
1409
1410         synth->thread->window->update_gui();
1411         synth->send_configure_change();
1412 }
1413
1414 SynthFreqEnum::SynthFreqEnum(Synth *synth)
1415  : BC_MenuItem(_("Enumerate"))
1416 {
1417         this->synth = synth;
1418 }
1419 SynthFreqEnum::~SynthFreqEnum()
1420 {
1421 }
1422
1423 int SynthFreqEnum::handle_event()
1424 {
1425         for(int i = 0; i < synth->config.oscillator_config.total; i++)
1426         {
1427                 synth->config.oscillator_config.values[i]->freq_factor = (float)i + 1;
1428         }
1429
1430         synth->thread->window->update_gui();
1431         synth->send_configure_change();
1432 }
1433
1434 SynthFreqEven::SynthFreqEven(Synth *synth)
1435  : BC_MenuItem(_("Even"))
1436 {
1437         this->synth = synth;
1438 }
1439 SynthFreqEven::~SynthFreqEven()
1440 {
1441 }
1442
1443 int SynthFreqEven::handle_event()
1444 {
1445         if(synth->config.oscillator_config.total)
1446                 synth->config.oscillator_config.values[0]->freq_factor = (float)1;
1447
1448         for(int i = 1; i < synth->config.oscillator_config.total; i++)
1449         {
1450                 synth->config.oscillator_config.values[i]->freq_factor = (float)i * 2;
1451         }
1452
1453         synth->thread->window->update_gui();
1454         synth->send_configure_change();
1455 }
1456
1457 SynthFreqOdd::SynthFreqOdd(Synth *synth)
1458  : BC_MenuItem(_("Odd"))
1459 { this->synth = synth; }
1460 SynthFreqOdd::~SynthFreqOdd()
1461 {
1462 }
1463
1464 int SynthFreqOdd::handle_event()
1465 {
1466         for(int i = 0; i < synth->config.oscillator_config.total; i++)
1467         {
1468                 synth->config.oscillator_config.values[i]->freq_factor = (float)1 + i * 2;
1469         }
1470
1471         synth->thread->window->update_gui();
1472         synth->send_configure_change();
1473 }
1474
1475 SynthFreqFibonacci::SynthFreqFibonacci(Synth *synth)
1476  : BC_MenuItem(_("Fibonnacci"))
1477 {
1478         this->synth = synth;
1479 }
1480 SynthFreqFibonacci::~SynthFreqFibonacci()
1481 {
1482 }
1483
1484 int SynthFreqFibonacci::handle_event()
1485 {
1486         float last_value1 = 0, last_value2 = 1;
1487         for(int i = 0; i < synth->config.oscillator_config.total; i++)
1488         {
1489                 synth->config.oscillator_config.values[i]->freq_factor = last_value1 + last_value2;
1490                 if(synth->config.oscillator_config.values[i]->freq_factor > 100) synth->config.oscillator_config.values[i]->freq_factor = 100;
1491                 last_value1 = last_value2;
1492                 last_value2 = synth->config.oscillator_config.values[i]->freq_factor;
1493         }
1494
1495         synth->thread->window->update_gui();
1496         synth->send_configure_change();
1497 }
1498
1499 SynthFreqPrime::SynthFreqPrime(Synth *synth)
1500  : BC_MenuItem(_("Prime"))
1501 {
1502         this->synth = synth;
1503 }
1504 SynthFreqPrime::~SynthFreqPrime()
1505 {
1506 }
1507
1508 int SynthFreqPrime::handle_event()
1509 {
1510         float number = 1;
1511         for(int i = 0; i < synth->config.oscillator_config.total; i++)
1512         {
1513                 synth->config.oscillator_config.values[i]->freq_factor = number;
1514                 number = get_next_prime(number);
1515         }
1516
1517         synth->thread->window->update_gui();
1518         synth->send_configure_change();
1519 }
1520
1521 float SynthFreqPrime::get_next_prime(float number)
1522 {
1523         int result = 1;
1524
1525         while(result)
1526         {
1527                 result = 0;
1528                 number++;
1529
1530                 for(float i = number - 1; i > 1 && !result; i--)
1531                 {
1532                         if((number / i) - (int)(number / i) == 0) result = 1;
1533                 }
1534         }
1535
1536         return number;
1537 }
1538
1539
1540
1541
1542
1543
1544
1545
1546 SynthOscillatorConfig::SynthOscillatorConfig(int number)
1547 {
1548         reset();
1549         this->number = number;
1550 }
1551
1552 SynthOscillatorConfig::~SynthOscillatorConfig()
1553 {
1554 }
1555
1556 void SynthOscillatorConfig::reset()
1557 {
1558         level = 0;
1559         phase = 0;
1560         freq_factor = 1;
1561 }
1562
1563 void SynthOscillatorConfig::load_defaults(Defaults *defaults)
1564 {
1565         char string[BCTEXTLEN];
1566
1567         sprintf(string, "LEVEL%d", number);
1568         level = defaults->get(string, (float)0);
1569         sprintf(string, "PHASE%d", number);
1570         phase = defaults->get(string, (float)0);
1571         sprintf(string, "FREQFACTOR%d", number);
1572         freq_factor = defaults->get(string, (float)1);
1573 }
1574
1575 void SynthOscillatorConfig::save_defaults(Defaults *defaults)
1576 {
1577         char string[BCTEXTLEN];
1578
1579         sprintf(string, "LEVEL%d", number);
1580         defaults->update(string, (float)level);
1581         sprintf(string, "PHASE%d", number);
1582         defaults->update(string, (float)phase);
1583         sprintf(string, "FREQFACTOR%d", number);
1584         defaults->update(string, (float)freq_factor);
1585 }
1586
1587 void SynthOscillatorConfig::read_data(FileXML *file)
1588 {
1589         level = file->tag.get_property("LEVEL", (float)level);
1590         phase = file->tag.get_property("PHASE", (float)phase);
1591         freq_factor = file->tag.get_property("FREQFACTOR", (float)freq_factor);
1592 }
1593
1594 void SynthOscillatorConfig::save_data(FileXML *file)
1595 {
1596         file->tag.set_title("OSCILLATOR");
1597         file->tag.set_property("LEVEL", (float)level);
1598         file->tag.set_property("PHASE", (float)phase);
1599         file->tag.set_property("FREQFACTOR", (float)freq_factor);
1600         file->append_tag();
1601         file->append_newline();
1602 }
1603
1604 int SynthOscillatorConfig::equivalent(SynthOscillatorConfig &that)
1605 {
1606         if(EQUIV(level, that.level) &&
1607                 EQUIV(phase, that.phase) &&
1608                 EQUIV(freq_factor, that.freq_factor))
1609                 return 1;
1610         else
1611                 return 0;
1612 }
1613
1614 void SynthOscillatorConfig::copy_from(SynthOscillatorConfig& that)
1615 {
1616         level = that.level;
1617         phase = that.phase;
1618         freq_factor = that.freq_factor;
1619 }
1620
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
1632 SynthConfig::SynthConfig()
1633 {
1634         reset();
1635 }
1636
1637 SynthConfig::~SynthConfig()
1638 {
1639         oscillator_config.remove_all_objects();
1640 }
1641
1642 void SynthConfig::reset()
1643 {
1644         wetness = 0;
1645         base_freq = 440;
1646         wavefunction = SINE;
1647         for(int i = 0; i < oscillator_config.total; i++)
1648         {
1649                 oscillator_config.values[i]->reset();
1650         }
1651 }
1652
1653 int SynthConfig::equivalent(SynthConfig &that)
1654 {
1655 //printf("SynthConfig::equivalent %d %d\n", base_freq, that.base_freq);
1656         if(base_freq != that.base_freq ||
1657                 wavefunction != that.wavefunction ||
1658                 oscillator_config.total != that.oscillator_config.total) return 0;
1659
1660         for(int i = 0; i < oscillator_config.total; i++)
1661         {
1662                 if(!oscillator_config.values[i]->equivalent(*that.oscillator_config.values[i]))
1663                         return 0;
1664         }
1665
1666         return 1;
1667 }
1668
1669 void SynthConfig::copy_from(SynthConfig& that)
1670 {
1671         wetness = that.wetness;
1672         base_freq = that.base_freq;
1673         wavefunction = that.wavefunction;
1674
1675         int i;
1676         for(i = 0;
1677                 i < oscillator_config.total && i < that.oscillator_config.total;
1678                 i++)
1679         {
1680                 oscillator_config.values[i]->copy_from(*that.oscillator_config.values[i]);
1681         }
1682
1683         for( ;
1684                 i < that.oscillator_config.total;
1685                 i++)
1686         {
1687                 oscillator_config.append(new SynthOscillatorConfig(i));
1688                 oscillator_config.values[i]->copy_from(*that.oscillator_config.values[i]);
1689         }
1690
1691         for( ;
1692                 i < oscillator_config.total;
1693                 i++)
1694         {
1695                 oscillator_config.remove_object();
1696         }
1697 }
1698
1699 void SynthConfig::interpolate(SynthConfig &prev,
1700         SynthConfig &next,
1701         int64_t prev_frame,
1702         int64_t next_frame,
1703         int64_t current_frame)
1704 {
1705         double next_scale = (double)(current_frame - prev_frame) / (next_frame - prev_frame);
1706         double prev_scale = (double)(next_frame - current_frame) / (next_frame - prev_frame);
1707
1708         copy_from(prev);
1709         wetness = (int)(prev.wetness * prev_scale + next.wetness * next_scale);
1710         base_freq = (int)(prev.base_freq * prev_scale + next.base_freq * next_scale);
1711 }
1712
1713
1714
1715
1716