hvirtual/plugins/denoisefft/denoisefft.C

   1 #include "bcdisplayinfo.h"
   2 #include "clip.h"
   3 #include "defaults.h"
   4 #include "filesystem.h"
   5 #include "filexml.h"
   6 #include "guicast.h"
   7 #include "mutex.h"
   8 #include "fourier.h"
   9 #include "picon_png.h"
  10 #include "pluginaclient.h"
  11 #include "units.h"
  12 #include "vframe.h"
  13
  14 #include <errno.h>
  15 #include <math.h>
  16 #include <string.h>
  17
  18 #include <libintl.h>
  19 #define _(String) gettext(String)
  20 #define gettext_noop(String) String
  21 #define N_(String) gettext_noop (String)
  22
  23
  24
  25
  26
  27
  28
  29 class DenoiseFFTEffect;
  30 class DenoiseFFTWindow;
  31 #define REFERENCE_FILE BCASTDIR "denoise.ref"
  32
  33
  34
  35
  36 class DenoiseFFTConfig
  37 {
  38 public:
  39         DenoiseFFTConfig();
  40         void copy_from(DenoiseFFTConfig &that);
  41         int equivalent(DenoiseFFTConfig &that);
  42         void interpolate(DenoiseFFTConfig &prev,
  43                 DenoiseFFTConfig &next,
  44                 int64_t prev_frame,
  45                 int64_t next_frame,
  46                 int64_t current_frame);
  47
  48         int window_size;
  49         int collecting;
  50         double level;
  51 };
  52
  53 class DenoiseFFTCollecting : public BC_CheckBox
  54 {
  55 public:
  56         DenoiseFFTCollecting(DenoiseFFTEffect *plugin, int x, int y);
  57         int handle_event();
  58         DenoiseFFTEffect *plugin;
  59 };
  60
  61 class DenoiseFFTLevel : public BC_FPot
  62 {
  63 public:
  64         DenoiseFFTLevel(DenoiseFFTEffect *plugin, int x, int y);
  65         int handle_event();
  66         DenoiseFFTEffect *plugin;
  67 };
  68
  69 // class DenoiseFFTSize : public BC_TextBox
  70 // {
  71 // public:
  72 //      DenoiseFFTSize(DenoiseFFTEffect *plugin, int x, int y);
  73 //      int handle_event();
  74 //      DenoiseFFTEffect *plugin;
  75 // };
  76
  77 class DenoiseFFTWindow : public BC_Window
  78 {
  79 public:
  80         DenoiseFFTWindow(DenoiseFFTEffect *plugin, int x, int y);
  81         void create_objects();
  82         int close_event();
  83         DenoiseFFTLevel *level;
  84         DenoiseFFTCollecting *collect;
  85 //      DenoiseFFTSize *size;
  86         DenoiseFFTEffect *plugin;
  87 };
  88
  89
  90
  91
  92
  93
  94
  95
  96
  97
  98
  99
 100
 101 PLUGIN_THREAD_HEADER(DenoiseFFTEffect, DenoiseFFTThread, DenoiseFFTWindow)
 102
 103
 104 class DenoiseFFTRemove : public CrossfadeFFT
 105 {
 106 public:
 107         DenoiseFFTRemove(DenoiseFFTEffect *plugin);
 108         int signal_process();
 109         DenoiseFFTEffect *plugin;
 110 };
 111
 112 class DenoiseFFTCollect : public CrossfadeFFT
 113 {
 114 public:
 115         DenoiseFFTCollect(DenoiseFFTEffect *plugin);
 116         int signal_process();
 117         DenoiseFFTEffect *plugin;
 118 };
 119
 120 class DenoiseFFTEffect : public PluginAClient
 121 {
 122 public:
 123         DenoiseFFTEffect(PluginServer *server);
 124         ~DenoiseFFTEffect();
 125
 126         int is_realtime();
 127         void read_data(KeyFrame *keyframe);
 128         void save_data(KeyFrame *keyframe);
 129         int process_realtime(int64_t size, double *input_ptr, double *output_ptr);
 130
 131
 132
 133
 134         int load_defaults();
 135         int save_defaults();
 136         void reset();
 137         void update_gui();
 138
 139         void process_window();
 140
 141
 142         PLUGIN_CLASS_MEMBERS(DenoiseFFTConfig, DenoiseFFTThread)
 143
 144         int is_collecting;
 145         int prev_window_size;
 146         double *reference;
 147         DenoiseFFTRemove *remove_engine;
 148         DenoiseFFTCollect *collect_engine;
 149 };
 150
 151
 152
 153
 154
 155
 156
 157
 158
 159
 160 REGISTER_PLUGIN(DenoiseFFTEffect)
 161
 162
 163
 164
 165
 166
 167
 168
 169
 170 DenoiseFFTConfig::DenoiseFFTConfig()
 171 {
 172         window_size = 16384;
 173         collecting = 0;
 174         level = 0.0;
 175 }
 176
 177 void DenoiseFFTConfig::copy_from(DenoiseFFTConfig &that)
 178 {
 179         window_size = that.window_size;
 180         collecting = that.collecting;
 181         level = that.level;
 182 }
 183
 184 int DenoiseFFTConfig::equivalent(DenoiseFFTConfig &that)
 185 {
 186         return EQUIV(level, that.level) &&
 187                 window_size == that.window_size &&
 188                 collecting == that.collecting;
 189 }
 190
 191 void DenoiseFFTConfig::interpolate(DenoiseFFTConfig &prev,
 192         DenoiseFFTConfig &next,
 193         int64_t prev_frame,
 194         int64_t next_frame,
 195         int64_t current_frame)
 196 {
 197         double next_scale = (double)(current_frame - prev_frame) / (next_frame - prev_frame);
 198         double prev_scale = (double)(next_frame - current_frame) / (next_frame - prev_frame);
 199         this->level = prev.level * prev_scale + next.level * next_scale;
 200         this->window_size = prev.window_size;
 201         this->collecting = prev.collecting;
 202 }
 203
 204
 205
 206
 207
 208
 209
 210
 211
 212
 213
 214
 215
 216
 217
 218 DenoiseFFTLevel::DenoiseFFTLevel(DenoiseFFTEffect *plugin, int x, int y)
 219  : BC_FPot(x, y, (float)plugin->config.level, INFINITYGAIN, 6.0)
 220 {
 221         this->plugin = plugin;
 222         set_precision(0.1);
 223 }
 224
 225 int DenoiseFFTLevel::handle_event()
 226 {
 227         plugin->config.level = get_value();
 228         plugin->send_configure_change();
 229         return 1;
 230 }
 231
 232 DenoiseFFTCollecting::DenoiseFFTCollecting(DenoiseFFTEffect *plugin, int x, int y)
 233  : BC_CheckBox(x, y, plugin->config.collecting, _("Collect noise"))
 234 {
 235         this->plugin = plugin;
 236 }
 237
 238 int DenoiseFFTCollecting::handle_event()
 239 {
 240         plugin->config.collecting = get_value();
 241         plugin->send_configure_change();
 242         return 1;
 243 }
 244
 245 // DenoiseFFTSize::DenoiseFFTSize(DenoiseFFTEffect *plugin, int x, int y)
 246 //  : BC_TextBox(x, y, 100, 1, plugin->config.window_size)
 247 // {
 248 //      this->plugin = plugin;
 249 // }
 250 // int DenoiseFFTSize::handle_event()
 251 // {
 252 //      plugin->config.window_size = atol(get_text());
 253 //      plugin->send_configure_change();
 254 //      return 1;
 255 // }
 256
 257
 258
 259 DenoiseFFTWindow::DenoiseFFTWindow(DenoiseFFTEffect *plugin, int x, int y)
 260  : BC_Window(plugin->gui_string,
 261         x,
 262         y,
 263         220,
 264         120,
 265         220,
 266         120,
 267         0,
 268         0,
 269         1)
 270 {
 271         this->plugin = plugin;
 272 }
 273
 274 void DenoiseFFTWindow::create_objects()
 275 {
 276         int x = 10, y = 10;
 277
 278         add_subwindow(new BC_Title(x, y, _("Denoise power:")));
 279         add_subwindow(level = new DenoiseFFTLevel(plugin, x + 130, y));
 280         y += 35;
 281         add_subwindow(collect = new DenoiseFFTCollecting(plugin, x, y));
 282 //      y += 35;
 283 //      add_subwindow(new BC_Title(x, y, _("Window size:")));
 284 //      add_subwindow(size = new DenoiseFFTSize(plugin, x + 100, y));
 285         show_window();
 286         flush();
 287 }
 288
 289 int DenoiseFFTWindow::close_event()
 290 {
 291 // Set result to 1 to indicate a client side close
 292         set_done(1);
 293         return 1;
 294 }
 295
 296
 297
 298
 299
 300
 301
 302
 303
 304
 305
 306 PLUGIN_THREAD_OBJECT(DenoiseFFTEffect, DenoiseFFTThread, DenoiseFFTWindow)
 307
 308
 309
 310
 311
 312
 313
 314
 315
 316
 317
 318
 319
 320
 321
 322 DenoiseFFTEffect::DenoiseFFTEffect(PluginServer *server)
 323  : PluginAClient(server)
 324 {
 325         reset();
 326         PLUGIN_CONSTRUCTOR_MACRO
 327 }
 328
 329 DenoiseFFTEffect::~DenoiseFFTEffect()
 330 {
 331         PLUGIN_DESTRUCTOR_MACRO
 332         if(reference) delete [] reference;
 333         if(remove_engine) delete remove_engine;
 334         if(collect_engine) delete collect_engine;
 335 }
 336
 337 NEW_PICON_MACRO(DenoiseFFTEffect)
 338
 339 LOAD_CONFIGURATION_MACRO(DenoiseFFTEffect, DenoiseFFTConfig)
 340
 341 SHOW_GUI_MACRO(DenoiseFFTEffect, DenoiseFFTThread)
 342
 343 RAISE_WINDOW_MACRO(DenoiseFFTEffect)
 344
 345 SET_STRING_MACRO(DenoiseFFTEffect)
 346
 347
 348 void DenoiseFFTEffect::reset()
 349 {
 350         reference = 0;
 351         remove_engine = 0;
 352         collect_engine = 0;
 353         is_collecting = 0;
 354         prev_window_size = 0;
 355 }
 356
 357 char* DenoiseFFTEffect::plugin_title()
 358 {
 359         return _("DenoiseFFT");
 360 }
 361
 362
 363 int DenoiseFFTEffect::is_realtime()
 364 {
 365         return 1;
 366 }
 367
 368
 369
 370 void DenoiseFFTEffect::read_data(KeyFrame *keyframe)
 371 {
 372         FileXML input;
 373         input.set_shared_string(keyframe->data, strlen(keyframe->data));
 374
 375         int result = 0;
 376         while(!result)
 377         {
 378                 result = input.read_tag();
 379
 380                 if(!result)
 381                 {
 382                         if(input.tag.title_is("DENOISEFFT"))
 383                         {
 384                                 config.window_size = input.tag.get_property("WINDOW_SIZE", config.window_size);
 385                                 config.level = input.tag.get_property("LEVEL", config.level);
 386                                 config.collecting = input.tag.get_property("COLLECTING", config.collecting);
 387                         }
 388                 }
 389         }
 390 }
 391
 392 void DenoiseFFTEffect::save_data(KeyFrame *keyframe)
 393 {
 394         FileXML output;
 395         output.set_shared_string(keyframe->data, MESSAGESIZE);
 396
 397         output.tag.set_title("DENOISEFFT");
 398         output.tag.set_property("WINDOW_SIZE", config.window_size);
 399         output.tag.set_property("LEVEL", config.level);
 400         output.tag.set_property("COLLECTING", config.collecting);
 401         output.append_tag();
 402         output.append_newline();
 403
 404         output.terminate_string();
 405 }
 406
 407 int DenoiseFFTEffect::load_defaults()
 408 {
 409         defaults = new Defaults(BCASTDIR "denoisefft.rc");
 410         defaults->load();
 411
 412         config.level = defaults->get("LEVEL", config.level);
 413         config.window_size = defaults->get("WINDOW_SIZE", config.window_size);
 414         config.collecting = defaults->get("COLLECTING", config.collecting);
 415         return 0;
 416 }
 417
 418 int DenoiseFFTEffect::save_defaults()
 419 {
 420         char string[BCTEXTLEN];
 421
 422         defaults->update("LEVEL", config.level);
 423         defaults->update("WINDOW_SIZE", config.window_size);
 424         defaults->update("COLLECTING", config.collecting);
 425         defaults->save();
 426
 427         return 0;
 428 }
 429
 430 void DenoiseFFTEffect::update_gui()
 431 {
 432         if(thread)
 433         {
 434                 load_configuration();
 435                 thread->window->lock_window();
 436                 thread->window->level->update(config.level);
 437                 thread->window->collect->update(config.collecting);
 438 //              thread->window->size->update((int64_t)config.window_size);
 439                 thread->window->unlock_window();
 440         }
 441 }
 442
 443 int DenoiseFFTEffect::process_realtime(int64_t size, double *input_ptr, double *output_ptr)
 444 {
 445         load_configuration();
 446
 447         if(prev_window_size != config.window_size)
 448         {
 449                 if(reference) delete [] reference;
 450                 if(collect_engine) delete collect_engine;
 451                 if(remove_engine) delete remove_engine;
 452                 reference = 0;
 453                 collect_engine = 0;
 454                 remove_engine = 0;
 455                 prev_window_size = config.window_size;
 456         }
 457
 458         if(config.collecting)
 459         {
 460 // Create reference
 461                 if(!reference)
 462                 {
 463                         reference = new double[config.window_size / 2];
 464                 }
 465
 466                 if(!is_collecting)
 467                         bzero(reference, sizeof(double) * config.window_size / 2);
 468
 469                 if(!collect_engine) collect_engine = new DenoiseFFTCollect(this);
 470                 collect_engine->process_fifo(size, input_ptr, output_ptr);
 471
 472                 memcpy(output_ptr, input_ptr, sizeof(double) * size);
 473                 is_collecting = 1;
 474         }
 475         else
 476         {
 477                 is_collecting = 0;
 478 // Hasn't collected yet.  Load from disk file
 479                 if(!reference)
 480                 {
 481                         reference = new double[config.window_size / 2];
 482                         FileSystem fs;
 483                         char string[BCTEXTLEN];
 484                         strcpy(string, REFERENCE_FILE);
 485                         fs.complete_path(string);
 486                         FILE *fd = fopen(string, "r");
 487
 488                         if(fd)
 489                         {
 490                                 fread(reference, config.window_size / 2 * sizeof(double), 1, fd);
 491                                 fclose(fd);
 492                         }
 493                         else
 494                         {
 495                                 bzero(reference, sizeof(double) * config.window_size / 2);
 496                         }
 497
 498                 }
 499
 500                 if(!remove_engine) remove_engine = new DenoiseFFTRemove(this);
 501                 remove_engine->process_fifo(size, input_ptr, output_ptr);
 502         }
 503
 504         return 0;
 505 }
 506
 507
 508
 509
 510
 511
 512
 513
 514
 515 DenoiseFFTRemove::DenoiseFFTRemove(DenoiseFFTEffect *plugin)
 516 {
 517         this->plugin = plugin;
 518 }
 519
 520 int DenoiseFFTRemove::signal_process()
 521 {
 522         double level = DB::fromdb(plugin->config.level);
 523         for(int i = 0; i < window_size / 2; i++)
 524         {
 525                 double result = sqrt(freq_real[i] * freq_real[i] + freq_imag[i] * freq_imag[i]);
 526                 double angle = atan2(freq_imag[i], freq_real[i]);
 527                 result -= plugin->reference[i] * level;
 528                 if(result < 0) result = 0;
 529                 freq_real[i] = result * cos(angle);
 530                 freq_imag[i] = result * sin(angle);
 531         }
 532         symmetry(window_size, freq_real, freq_imag);
 533         return 0;
 534 }
 535
 536
 537
 538
 539
 540 DenoiseFFTCollect::DenoiseFFTCollect(DenoiseFFTEffect *plugin)
 541 {
 542         this->plugin = plugin;
 543 }
 544
 545 int DenoiseFFTCollect::signal_process()
 546 {
 547         for(int i = 0; i < window_size / 2; i++)
 548         {
 549 // Moving average of peak so you don't need to stop, play, restart, play to
 550 // collect new data.
 551                 double result = sqrt(freq_real[i] * freq_real[i] + freq_imag[i] * freq_imag[i]);
 552                 double reference = plugin->reference[i];
 553                 if(result < reference)
 554                         plugin->reference[i] = (result + reference * 4) / 5;
 555                 else
 556                         plugin->reference[i] = result;
 557         }
 558
 559         FileSystem fs;
 560         char string[BCTEXTLEN];
 561         strcpy(string, REFERENCE_FILE);
 562         fs.complete_path(string);
 563         FILE *fd = fopen(string, "w");
 564         if(fd)
 565         {
 566                 fwrite(plugin->reference, window_size / 2 * sizeof(double), 1, fd);
 567                 fclose(fd);
 568         }
 569         else
 570                 printf("DenoiseFFTCollect::signal_process: can't open %s for writing. %s.\n",
 571                         REFERENCE_FILE, strerror(errno));
 572         return 0;
 573 }
 574