plugins/parametric/parametric.C

   1 #include "bcdisplayinfo.h"
   2 #include "bcsignals.h"
   3 #include "clip.h"
   4 #include "bchash.h"
   5 #include "filexml.h"
   6 #include "language.h"
   7 #include "parametric.h"
   8 #include "picon_png.h"
   9 #include "units.h"
  10 #include "vframe.h"
  11
  12 #include <math.h>
  13 #include <string.h>
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23 REGISTER_PLUGIN(ParametricEQ)
  24
  25
  26
  27
  28
  29
  30
  31
  32 ParametricBand::ParametricBand()
  33 {
  34         freq = 440;
  35         quality = 1;
  36         magnitude = 0;
  37         mode = NONE;
  38 }
  39
  40
  41 int ParametricBand::equivalent(ParametricBand &that)
  42 {
  43         if(freq == that.freq &&
  44                 EQUIV(quality, that.quality) &&
  45                 EQUIV(magnitude, that.magnitude) &&
  46                 mode == that.mode)
  47         {
  48                 return 1;
  49         }
  50         else
  51                 return 0;
  52 }
  53
  54
  55 void ParametricBand::copy_from(ParametricBand &that)
  56 {
  57         freq = that.freq;
  58         quality = that.quality;
  59         magnitude = that.magnitude;
  60         mode = that.mode;
  61 }
  62
  63 void ParametricBand::interpolate(ParametricBand &prev,
  64                 ParametricBand &next,
  65                 double prev_scale,
  66                 double next_scale)
  67 {
  68         freq = (int)(prev.freq * prev_scale + next.freq * next_scale + 0.5);
  69         quality = prev.quality * prev_scale + next.quality * next_scale;
  70         magnitude = prev.magnitude * prev_scale + next.magnitude * next_scale;
  71         mode = prev.mode;
  72 }
  73
  74
  75
  76
  77
  78 ParametricConfig::ParametricConfig()
  79 {
  80         wetness = INFINITYGAIN;
  81 }
  82
  83
  84 int ParametricConfig::equivalent(ParametricConfig &that)
  85 {
  86         for(int i = 0; i < BANDS; i++)
  87                 if(!band[i].equivalent(that.band[i])) return 0;
  88
  89         if(!EQUIV(wetness, that.wetness)) return 0;
  90         return 1;
  91 }
  92
  93 void ParametricConfig::copy_from(ParametricConfig &that)
  94 {
  95         wetness = that.wetness;
  96         for(int i = 0; i < BANDS; i++)
  97                 band[i].copy_from(that.band[i]);
  98 }
  99
 100 void ParametricConfig::interpolate(ParametricConfig &prev,
 101                 ParametricConfig &next,
 102                 int64_t prev_frame,
 103                 int64_t next_frame,
 104                 int64_t current_frame)
 105 {
 106         double next_scale = (double)(current_frame - prev_frame) / (next_frame - prev_frame);
 107         double prev_scale = (double)(next_frame - current_frame) / (next_frame - prev_frame);
 108         wetness = prev.wetness;
 109         for(int i = 0; i < BANDS; i++)
 110         {
 111                 band[i].interpolate(prev.band[i], next.band[i], prev_scale, next_scale);
 112         }
 113 }
 114
 115
 116
 117
 118
 119
 120
 121
 122
 123
 124
 125
 126
 127
 128
 129
 130
 131
 132
 133 ParametricFreq::ParametricFreq(ParametricEQ *plugin, int x, int y, int band)
 134  : BC_QPot(x, y, plugin->config.band[band].freq)
 135 {
 136         this->plugin = plugin;
 137         this->band = band;
 138 }
 139
 140 int ParametricFreq::handle_event()
 141 {
 142         plugin->config.band[band].freq = get_value();
 143         plugin->send_configure_change();
 144         plugin->thread->window->update_canvas();
 145         return 1;
 146 }
 147
 148
 149
 150
 151
 152
 153
 154
 155 ParametricQuality::ParametricQuality(ParametricEQ *plugin, int x, int y, int band)
 156  : BC_FPot(x, y, plugin->config.band[band].quality, 0, 1)
 157 {
 158         this->plugin = plugin;
 159         this->band = band;
 160         set_precision(0.01);
 161 }
 162
 163 int ParametricQuality::handle_event()
 164 {
 165         plugin->config.band[band].quality = get_value();
 166         plugin->send_configure_change();
 167         plugin->thread->window->update_canvas();
 168         return 1;
 169 }
 170
 171
 172
 173
 174
 175
 176
 177
 178
 179
 180
 181 ParametricMagnitude::ParametricMagnitude(ParametricEQ *plugin, int x, int y, int band)
 182  : BC_FPot(x, y, plugin->config.band[band].magnitude, -MAXMAGNITUDE, MAXMAGNITUDE)
 183 {
 184         this->plugin = plugin;
 185         this->band = band;
 186 }
 187
 188 int ParametricMagnitude::handle_event()
 189 {
 190         plugin->config.band[band].magnitude = get_value();
 191         plugin->send_configure_change();
 192         plugin->thread->window->update_canvas();
 193         return 1;
 194 }
 195
 196
 197
 198
 199
 200
 201
 202
 203
 204 ParametricMode::ParametricMode(ParametricEQ *plugin, int x, int y, int band)
 205  : BC_PopupMenu(x,
 206                 y,
 207                 150,
 208                 mode_to_text(plugin->config.band[band].mode))
 209 {
 210 //printf("ParametricMode::ParametricMode %d %d\n", band, plugin->config.band[band].mode);
 211         this->plugin = plugin;
 212         this->band = band;
 213 }
 214
 215 void ParametricMode::create_objects()
 216 {
 217         add_item(new BC_MenuItem(mode_to_text(ParametricBand::LOWPASS)));
 218         add_item(new BC_MenuItem(mode_to_text(ParametricBand::HIGHPASS)));
 219         add_item(new BC_MenuItem(mode_to_text(ParametricBand::BANDPASS)));
 220         add_item(new BC_MenuItem(mode_to_text(ParametricBand::NONE)));
 221 }
 222
 223
 224 int ParametricMode::handle_event()
 225 {
 226         plugin->config.band[band].mode = text_to_mode(get_text());
 227         plugin->send_configure_change();
 228         plugin->thread->window->update_canvas();
 229         return 1;
 230 }
 231
 232 int ParametricMode::text_to_mode(char *text)
 233 {
 234         if(!strcmp(mode_to_text(ParametricBand::LOWPASS), text)) return ParametricBand::LOWPASS;
 235         if(!strcmp(mode_to_text(ParametricBand::HIGHPASS), text)) return ParametricBand::HIGHPASS;
 236         if(!strcmp(mode_to_text(ParametricBand::BANDPASS), text)) return ParametricBand::BANDPASS;
 237         if(!strcmp(mode_to_text(ParametricBand::NONE), text)) return ParametricBand::NONE;
 238         return ParametricBand::BANDPASS;
 239 }
 240
 241
 242
 243 char* ParametricMode::mode_to_text(int mode)
 244 {
 245         switch(mode)
 246         {
 247                 case ParametricBand::LOWPASS:
 248                         return _("Lowpass");
 249                         break;
 250                 case ParametricBand::HIGHPASS:
 251                         return _("Highpass");
 252                         break;
 253                 case ParametricBand::BANDPASS:
 254                         return _("Bandpass");
 255                         break;
 256                 case ParametricBand::NONE:
 257                         return _("None");
 258                         break;
 259         }
 260         return "";
 261 }
 262
 263
 264
 265
 266
 267
 268
 269
 270
 271
 272
 273 ParametricBandGUI::ParametricBandGUI(ParametricEQ *plugin, ParametricWindow *window, int x, int y, int band)
 274 {
 275         this->plugin = plugin;
 276         this->band = band;
 277         this->window = window;
 278         this->x = x;
 279         this->y = y;
 280 }
 281
 282 ParametricBandGUI::~ParametricBandGUI()
 283 {
 284 }
 285
 286
 287 #define X1 10
 288 #define X2 60
 289 #define X3 110
 290 #define X4 160
 291
 292
 293 void ParametricBandGUI::create_objects()
 294 {
 295         window->add_subwindow(freq = new ParametricFreq(plugin, X1, y, band));
 296         window->add_subwindow(quality = new ParametricQuality(plugin, X2, y, band));
 297         window->add_subwindow(magnitude = new ParametricMagnitude(plugin, X3, y, band));
 298         window->add_subwindow(mode = new ParametricMode(plugin, X4, y, band));
 299         mode->create_objects();
 300 }
 301
 302 void ParametricBandGUI::update_gui()
 303 {
 304         freq->update(plugin->config.band[band].freq);
 305         quality->update(plugin->config.band[band].quality);
 306         magnitude->update(plugin->config.band[band].magnitude);
 307 }
 308
 309
 310
 311
 312
 313
 314 ParametricWetness::ParametricWetness(ParametricEQ *plugin, int x, int y)
 315  : BC_FPot(x, y, plugin->config.wetness, INFINITYGAIN, 0)
 316 {
 317         this->plugin = plugin;
 318 }
 319
 320 int ParametricWetness::handle_event()
 321 {
 322         plugin->config.wetness = get_value();
 323         plugin->send_configure_change();
 324         plugin->thread->window->update_canvas();
 325         return 1;
 326 }
 327
 328
 329
 330
 331
 332
 333 ParametricWindow::ParametricWindow(ParametricEQ *plugin, int x, int y)
 334  : BC_Window(plugin->gui_string,
 335         x,
 336         y,
 337         320,
 338         400,
 339         320,
 340         400,
 341         0,
 342         0,
 343         1)
 344 {
 345         this->plugin = plugin;
 346 }
 347
 348 ParametricWindow::~ParametricWindow()
 349 {
 350         for(int i = 0; i < BANDS; i++)
 351                 delete bands[i];
 352 }
 353
 354 void ParametricWindow::create_objects()
 355 {
 356         int y = 35;
 357 SET_TRACE
 358
 359         add_subwindow(new BC_Title(X1, 10, _("Freq")));
 360         add_subwindow(new BC_Title(X2, 10, _("Qual")));
 361         add_subwindow(new BC_Title(X3, 10, _("Level")));
 362         add_subwindow(new BC_Title(X4, 10, _("Mode")));
 363         for(int i = 0; i < BANDS; i++)
 364         {
 365                 bands[i] = new ParametricBandGUI(plugin, this, 10, y, i);
 366                 bands[i]->create_objects();
 367                 y += 50;
 368         }
 369
 370 SET_TRACE
 371         add_subwindow(new BC_Title(10, y + 10, _("Wetness:")));
 372         add_subwindow(wetness = new ParametricWetness(plugin, 80, y));
 373         y += 50;
 374         int canvas_x = 30;
 375         int canvas_y = y;
 376         int canvas_w = get_w() - canvas_x - 10;
 377         int canvas_h = get_h() - canvas_y - 30;
 378         add_subwindow(canvas = new BC_SubWindow(canvas_x,
 379                 canvas_y,
 380                 canvas_w,
 381                 canvas_h,
 382                 WHITE));
 383
 384 SET_TRACE
 385 // Draw canvas titles
 386         set_font(SMALLFONT);
 387 #define MAJOR_DIVISIONS 4
 388 #define MINOR_DIVISIONS 5
 389         for(int i = 0; i <= MAJOR_DIVISIONS; i++)
 390         {
 391                 int y1 = canvas_y + canvas_h - i * (canvas_h / MAJOR_DIVISIONS) - 2;
 392                 int y2 = y1 + 3;
 393                 int x1 = canvas_x - 25;
 394                 int x2 = canvas_x - 10;
 395                 int x3 = canvas_x - 2;
 396
 397                 char string[BCTEXTLEN];
 398                 if(i == 0)
 399                         sprintf(string, "oo");
 400                 else
 401                         sprintf(string, "%d", i * 5 - 5);
 402
 403                 set_color(BLACK);
 404                 draw_text(x1 + 1, y2 + 1, string);
 405                 draw_line(x2 + 1, y1 + 1, x3 + 1, y1 + 1);
 406                 set_color(RED);
 407                 draw_text(x1, y2, string);
 408                 draw_line(x2, y1, x3, y1);
 409
 410                 if(i < MAJOR_DIVISIONS)
 411                 {
 412                         for(int j = 1; j < MINOR_DIVISIONS; j++)
 413                         {
 414                                 int y3 = y1 - j * (canvas_h / MAJOR_DIVISIONS) / MINOR_DIVISIONS;
 415                                 int x4 = x3 - 5;
 416                                 set_color(BLACK);
 417                                 draw_line(x4 + 1, y3 + 1, x3 + 1, y3 + 1);
 418                                 set_color(RED);
 419                                 draw_line(x4, y3, x3, y3);
 420                         }
 421                 }
 422         }
 423
 424 SET_TRACE
 425 #undef MAJOR_DIVISIONS
 426 #define MAJOR_DIVISIONS 5
 427         for(int i = 0; i <= MAJOR_DIVISIONS; i++)
 428         {
 429                 int freq = Freq::tofreq(i * TOTALFREQS / MAJOR_DIVISIONS);
 430                 int x1 = canvas_x + i * canvas_w / MAJOR_DIVISIONS;
 431                 int y1 = canvas_y + canvas_h + 20;
 432                 char string[BCTEXTLEN];
 433                 sprintf(string, "%d", freq);
 434                 int x2 = x1 - get_text_width(SMALLFONT, string);
 435                 int y2 = y1 - 10;
 436                 int y3 = y2 - 5;
 437                 int y4 = canvas_y + canvas_h;
 438
 439                 set_color(BLACK);
 440                 draw_text(x2 + 1, y1 + 1, string);
 441                 draw_line(x1 + 1, y4 + 1, x1 + 1, y2 + 1);
 442                 set_color(RED);
 443                 draw_text(x2, y1, string);
 444                 draw_line(x1, y4, x1, y2);
 445
 446                 if(i < MAJOR_DIVISIONS)
 447                 {
 448 #undef MINOR_DIVISIONS
 449 #define MINOR_DIVISIONS 5
 450                         for(int j = 0; j < MINOR_DIVISIONS; j++)
 451                         {
 452                                 int x3 = (int)(x1 +
 453                                         (canvas_w / MAJOR_DIVISIONS) -
 454                                         exp(-(double)j * 0.7) *
 455                                         (canvas_w / MAJOR_DIVISIONS));
 456                                 set_color(BLACK);
 457                                 draw_line(x3 + 1, y4 + 1, x3 + 1, y3 + 1);
 458                                 set_color(RED);
 459                                 draw_line(x3, y4, x3, y3);
 460                         }
 461                 }
 462         }
 463
 464 SET_TRACE
 465         update_canvas();
 466         show_window();
 467 SET_TRACE
 468 }
 469
 470 int ParametricWindow::close_event()
 471 {
 472 // Set result to 1 to indicate a client side close
 473         set_done(1);
 474         return 1;
 475 }
 476
 477 void ParametricWindow::update_gui()
 478 {
 479         for(int i = 0; i < BANDS; i++)
 480                 bands[i]->update_gui();
 481         wetness->update(plugin->config.wetness);
 482         update_canvas();
 483 }
 484
 485
 486 void ParametricWindow::update_canvas()
 487 {
 488         double scale = 1;
 489         int y1 = canvas->get_h() / 2;
 490         int niquist = plugin->PluginAClient::project_sample_rate / 2;
 491         int wetness = canvas->get_h() -
 492                 (int)((plugin->config.wetness - INFINITYGAIN) /
 493                         -INFINITYGAIN *
 494                         canvas->get_h() /
 495                         4);
 496
 497         canvas->clear_box(0, 0, canvas->get_w(), canvas->get_h());
 498 //      canvas->set_color(GREEN);
 499 //      canvas->draw_line(0,
 500 //              wetness,
 501 //              canvas->get_w(),
 502 //              wetness);
 503
 504         canvas->set_color(BLACK);
 505
 506         plugin->calculate_envelope();
 507         for(int i = 0; i < canvas->get_w() - 1; i++)
 508         {
 509                 int freq = Freq::tofreq(i * TOTALFREQS / canvas->get_w());
 510                 int index = freq * WINDOW_SIZE / 2 / niquist;
 511                 double magnitude = plugin->envelope[index];
 512                 int y2 = canvas->get_h() * 3 / 4;
 513
 514                 if(magnitude > 1)
 515                 {
 516                         y2 -= (int)(DB::todb(magnitude) *
 517                                 canvas->get_h() *
 518                                 3 /
 519                                 4 /
 520                                 15);
 521                 }
 522                 else
 523                 {
 524                         y2 += (int)((1 - magnitude) * canvas->get_h() / 4);
 525                 }
 526                 if(i > 0) canvas->draw_line(i - 1, y1, i, y2);
 527                 y1 = y2;
 528         }
 529
 530
 531 //      for(int i = 0; i < canvas->get_w(); i++)
 532 //      {
 533 //              int freq = Freq::tofreq((int)((float)i / canvas->get_w() * TOTALFREQS));
 534 //              int index = (int)((float)freq / niquist * WINDOW_SIZE / 2);
 535 //              double magnitude = plugin->envelope[index];
 536 //              int y2 = canvas->get_h() -
 537 //                      (int)((double)canvas->get_h() / normalize * magnitude);
 538 //              if(i > 0) canvas->draw_line(i - 1, y1, i, y2);
 539 //              y1 = y2;
 540 //      }
 541
 542         canvas->flash();
 543 }
 544
 545
 546
 547
 548
 549
 550
 551 PLUGIN_THREAD_OBJECT(ParametricEQ, ParametricThread, ParametricWindow)
 552
 553
 554
 555
 556
 557
 558
 559 ParametricFFT::ParametricFFT(ParametricEQ *plugin)
 560  : CrossfadeFFT()
 561 {
 562         this->plugin = plugin;
 563 }
 564
 565 ParametricFFT::~ParametricFFT()
 566 {
 567 }
 568
 569
 570 int ParametricFFT::signal_process()
 571 {
 572         for(int i = 0; i < window_size / 2; i++)
 573         {
 574                 double result = plugin->envelope[i] * sqrt(freq_real[i] * freq_real[i] + freq_imag[i] * freq_imag[i]);
 575                 double angle = atan2(freq_imag[i], freq_real[i]);
 576                 freq_real[i] = result * cos(angle);
 577                 freq_imag[i] = result * sin(angle);
 578         }
 579
 580         symmetry(window_size, freq_real, freq_imag);
 581         return 0;
 582 }
 583
 584 int ParametricFFT::read_samples(int64_t output_sample,
 585         int samples,
 586         double *buffer)
 587 {
 588         return plugin->read_samples(buffer,
 589                 0,
 590                 plugin->get_samplerate(),
 591                 output_sample,
 592                 samples);
 593 }
 594
 595
 596
 597
 598
 599
 600
 601
 602 ParametricEQ::ParametricEQ(PluginServer *server)
 603  : PluginAClient(server)
 604 {
 605         PLUGIN_CONSTRUCTOR_MACRO
 606         fft = 0;
 607         need_reconfigure = 1;
 608 }
 609
 610 ParametricEQ::~ParametricEQ()
 611 {
 612         PLUGIN_DESTRUCTOR_MACRO
 613
 614         if(fft) delete fft;
 615 }
 616
 617 NEW_PICON_MACRO(ParametricEQ)
 618
 619 SHOW_GUI_MACRO(ParametricEQ, ParametricThread)
 620
 621 RAISE_WINDOW_MACRO(ParametricEQ)
 622
 623 SET_STRING_MACRO(ParametricEQ)
 624
 625 LOAD_CONFIGURATION_MACRO(ParametricEQ, ParametricConfig)
 626
 627
 628 char* ParametricEQ::plugin_title() { return N_("EQ Parametric"); }
 629 int ParametricEQ::is_realtime() { return 1; }
 630
 631 void ParametricEQ::read_data(KeyFrame *keyframe)
 632 {
 633         FileXML input;
 634         input.set_shared_string(keyframe->data, strlen(keyframe->data));
 635
 636         int result = 0;
 637         while(!result)
 638         {
 639                 result = input.read_tag();
 640
 641                 if(!result)
 642                 {
 643                         if(input.tag.title_is("PARAMETRICEQ"))
 644                         {
 645                                 config.wetness = input.tag.get_property("WETNESS", config.wetness);
 646                         }
 647                         else
 648                         if(input.tag.title_is("BAND"))
 649                         {
 650                                 int band = input.tag.get_property("NUMBER", 0);
 651                                 config.band[band].freq = input.tag.get_property("FREQ", config.band[band].freq);
 652                                 config.band[band].quality = input.tag.get_property("QUALITY", config.band[band].quality);
 653                                 config.band[band].magnitude = input.tag.get_property("MAGNITUDE", config.band[band].magnitude);
 654                                 config.band[band].mode = input.tag.get_property("MODE", config.band[band].mode);
 655                         }
 656                 }
 657         }
 658 }
 659
 660 void ParametricEQ::save_data(KeyFrame *keyframe)
 661 {
 662         FileXML output;
 663         output.set_shared_string(keyframe->data, MESSAGESIZE);
 664
 665         output.tag.set_title("PARAMETRICEQ");
 666         output.tag.set_property("WETNESS", config.wetness);
 667         output.append_tag();
 668         output.append_newline();
 669
 670         for(int i = 0; i < BANDS; i++)
 671         {
 672                 output.tag.set_title("BAND");
 673                 output.tag.set_property("NUMBER", i);
 674                 output.tag.set_property("FREQ", config.band[i].freq);
 675                 output.tag.set_property("QUALITY", config.band[i].quality);
 676                 output.tag.set_property("MAGNITUDE", config.band[i].magnitude);
 677                 output.tag.set_property("MODE", config.band[i].mode);
 678                 output.append_tag();
 679                 output.append_newline();
 680         }
 681
 682         output.terminate_string();
 683 }
 684
 685 void ParametricEQ::reconfigure()
 686 {
 687         if(!fft)
 688         {
 689                 fft = new ParametricFFT(this);
 690                 fft->initialize(WINDOW_SIZE);
 691         }
 692
 693 // Reset envelope
 694
 695 //printf("ParametricEQ::reconfigure %f\n", wetness);
 696         calculate_envelope();
 697
 698         for(int i = 0; i < WINDOW_SIZE / 2; i++)
 699         {
 700                 if(envelope[i] < 0) envelope[i] = 0;
 701         }
 702
 703         need_reconfigure = 0;
 704 }
 705
 706 double ParametricEQ::calculate_envelope()
 707 {
 708         double wetness = DB::fromdb(config.wetness);
 709         int niquist = PluginAClient::project_sample_rate / 2;
 710 //printf("ParametricEQ::calculate_envelope %d %d\n", niquist, PluginAClient::project_sample_rate);
 711
 712
 713         for(int i = 0; i < WINDOW_SIZE / 2; i++)
 714         {
 715                 envelope[i] = wetness;
 716         }
 717
 718         for(int pass = 0; pass < 2; pass++)
 719         {
 720                 for(int band = 0; band < BANDS; band++)
 721                 {
 722                         switch(config.band[band].mode)
 723                         {
 724                                 case ParametricBand::LOWPASS:
 725                                         if(pass == 1)
 726                                         {
 727                                                 double magnitude = DB::fromdb(config.band[band].magnitude);
 728                                                 int cutoff = (int)((float)config.band[band].freq / niquist * WINDOW_SIZE / 2);
 729                                                 for(int i = 0; i < WINDOW_SIZE / 2; i++)
 730                                                 {
 731                                                         if(i < cutoff)
 732                                                                 envelope[i] += magnitude;
 733                                                 }
 734                                         }
 735                                         break;
 736
 737                                 case ParametricBand::HIGHPASS:
 738                                         if(pass == 1)
 739                                         {
 740                                                 double magnitude = DB::fromdb(config.band[band].magnitude);
 741                                                 int cutoff = (int)((float)config.band[band].freq / niquist * WINDOW_SIZE / 2);
 742                                                 for(int i = 0; i < WINDOW_SIZE / 2; i++)
 743                                                 {
 744                                                         if(i > cutoff)
 745                                                                 envelope[i] += magnitude;
 746                                                 }
 747                                         }
 748                                         break;
 749
 750                                 case ParametricBand::BANDPASS:
 751                                         if(pass == 0)
 752                                         {
 753                                                 double magnitude = (config.band[band].magnitude > 0) ?
 754                                                         (DB::fromdb(config.band[band].magnitude) - 1) :
 755                                                         (-1 + DB::fromdb(config.band[band].magnitude));
 756                                                 double sigma = (config.band[band].quality < 1) ?
 757                                                         (1.0 - config.band[band].quality) :
 758                                                         0.01;
 759                                                 sigma /= 4;
 760                                                 double a = (double)config.band[band].freq / niquist;
 761                                                 double normalize = gauss(sigma, 0, 0);
 762                                                 if(config.band[band].magnitude <= -MAXMAGNITUDE)
 763                                                         magnitude = -1;
 764
 765                                                 for(int i = 0; i < WINDOW_SIZE / 2; i++)
 766                                                         envelope[i] += magnitude *
 767                                                                 gauss(sigma, a, (double)i / (WINDOW_SIZE / 2)) /
 768                                                                 normalize;
 769                                         }
 770                                         break;
 771                         }
 772                 }
 773         }
 774         return 0;
 775 }
 776
 777 double ParametricEQ::gauss(double sigma, double a, double x)
 778 {
 779         if(EQUIV(sigma, 0)) sigma = 0.01;
 780
 781         return 1.0 /
 782                 sqrt(2 * M_PI * sigma * sigma) *
 783                 exp(-(x - a) * (x - a) /
 784                         (2 * sigma * sigma));
 785 }
 786
 787
 788
 789 int ParametricEQ::process_buffer(int64_t size,
 790         double *buffer,
 791         int64_t start_position,
 792         int sample_rate)
 793 {
 794         need_reconfigure |= load_configuration();
 795         if(need_reconfigure) reconfigure();
 796
 797
 798         fft->process_buffer(start_position, size, buffer, get_direction());
 799         return 0;
 800 }
 801
 802
 803
 804
 805
 806
 807
 808
 809
 810 int ParametricEQ::load_defaults()
 811 {
 812         char directory[BCTEXTLEN], string[BCTEXTLEN];
 813         sprintf(directory, "%sparametriceq.rc", BCASTDIR);
 814         defaults = new BC_Hash(directory);
 815         defaults->load();
 816
 817         config.wetness = defaults->get("WETNESS", config.wetness);
 818         for(int i = 0; i < BANDS; i++)
 819         {
 820                 sprintf(string, "FREQ_%d", i);
 821                 config.band[i].freq = defaults->get(string, config.band[i].freq);
 822                 sprintf(string, "QUALITY_%d", i);
 823                 config.band[i].quality = defaults->get(string, config.band[i].quality);
 824                 sprintf(string, "MAGNITUDE_%d", i);
 825                 config.band[i].magnitude = defaults->get(string, config.band[i].magnitude);
 826                 sprintf(string, "MODE_%d", i);
 827                 config.band[i].mode = defaults->get(string, config.band[i].mode);
 828         }
 829         return 0;
 830 }
 831
 832 int ParametricEQ::save_defaults()
 833 {
 834         char string[BCTEXTLEN];
 835
 836         defaults->update("WETNESS", config.wetness);
 837
 838
 839         for(int i = 0; i < BANDS; i++)
 840         {
 841                 sprintf(string, "FREQ_%d", i);
 842                 defaults->update(string, config.band[i].freq);
 843                 sprintf(string, "QUALITY_%d", i);
 844                 defaults->update(string, config.band[i].quality);
 845                 sprintf(string, "MAGNITUDE_%d", i);
 846                 defaults->update(string, config.band[i].magnitude);
 847                 sprintf(string, "MODE_%d", i);
 848                 defaults->update(string, config.band[i].mode);
 849         }
 850
 851
 852         defaults->save();
 853
 854         return 0;
 855 }
 856
 857
 858 void ParametricEQ::reset()
 859 {
 860         need_reconfigure = 1;
 861         thread = 0;
 862         fft = 0;
 863 }
 864
 865 void ParametricEQ::update_gui()
 866 {
 867         if(thread)
 868         {
 869                 load_configuration();
 870                 thread->window->lock_window("ParametricEQ::update_gui");
 871                 thread->window->update_gui();
 872                 thread->window->unlock_window();
 873         }
 874 }
 875
 876
 877