cinelerra-5.1/plugins/chromakeyhsv/chromakey.C

   1
   2 /*
   3  * CINELERRA
   4  * Copyright (C) 2012 Adam Williams <broadcast at earthling dot net>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  *
  20  */
  21
  22 #include "bcdisplayinfo.h"
  23 #include "bcsignals.h"
  24 #include "chromakey.h"
  25 #include "clip.h"
  26 #include "bchash.h"
  27 #include "filexml.h"
  28 #include "guicast.h"
  29 #include "keyframe.h"
  30 #include "language.h"
  31 #include "loadbalance.h"
  32 #include "playback3d.h"
  33 #include "cicolors.h"
  34 #include "pluginvclient.h"
  35 #include "vframe.h"
  36
  37 #include <stdint.h>
  38 #include <string.h>
  39 #include <unistd.h>
  40
  41
  42
  43 ChromaKeyConfig::ChromaKeyConfig ()
  44 {
  45   red = 0.0;
  46   green = 1.0;
  47   blue = 0.0;
  48
  49   min_brightness = 50.0;
  50   max_brightness = 100.0;
  51   tolerance = 15.0;
  52   saturation = 0.0;
  53   min_saturation = 50.0;
  54
  55   in_slope = 2;
  56   out_slope = 2;
  57   alpha_offset = 0;
  58
  59   spill_threshold = 0.0;
  60   spill_amount = 90.0;
  61
  62   show_mask = 0;
  63
  64 }
  65
  66
  67 void
  68 ChromaKeyConfig::copy_from (ChromaKeyConfig & src)
  69 {
  70   red = src.red;
  71   green = src.green;
  72   blue = src.blue;
  73   spill_threshold = src.spill_threshold;
  74   spill_amount = src.spill_amount;
  75   min_brightness = src.min_brightness;
  76   max_brightness = src.max_brightness;
  77   saturation = src.saturation;
  78   min_saturation = src.min_saturation;
  79   tolerance = src.tolerance;
  80   in_slope = src.in_slope;
  81   out_slope = src.out_slope;
  82   alpha_offset = src.alpha_offset;
  83   show_mask = src.show_mask;
  84 }
  85
  86 int
  87 ChromaKeyConfig::equivalent (ChromaKeyConfig & src)
  88 {
  89   return (EQUIV (red, src.red) &&
  90           EQUIV (green, src.green) &&
  91           EQUIV (blue, src.blue) &&
  92           EQUIV (spill_threshold, src.spill_threshold) &&
  93           EQUIV (spill_amount, src.spill_amount) &&
  94           EQUIV (min_brightness, src.min_brightness) &&
  95           EQUIV (max_brightness, src.max_brightness) &&
  96           EQUIV (saturation, src.saturation) &&
  97           EQUIV (min_saturation, src.min_saturation) &&
  98           EQUIV (tolerance, src.tolerance) &&
  99           EQUIV (in_slope, src.in_slope) &&
 100           EQUIV (out_slope, src.out_slope) &&
 101           EQUIV (show_mask, src.show_mask) &&
 102           EQUIV (alpha_offset, src.alpha_offset));
 103 }
 104
 105 void
 106 ChromaKeyConfig::interpolate (ChromaKeyConfig & prev,
 107                               ChromaKeyConfig & next,
 108                               int64_t prev_frame,
 109                               int64_t next_frame, int64_t current_frame)
 110 {
 111   double next_scale =
 112     (double) (current_frame - prev_frame) / (next_frame - prev_frame);
 113   double prev_scale =
 114     (double) (next_frame - current_frame) / (next_frame - prev_frame);
 115
 116   this->red = prev.red * prev_scale + next.red * next_scale;
 117   this->green = prev.green * prev_scale + next.green * next_scale;
 118   this->blue = prev.blue * prev_scale + next.blue * next_scale;
 119   this->spill_threshold =
 120     prev.spill_threshold * prev_scale + next.spill_threshold * next_scale;
 121   this->spill_amount =
 122     prev.spill_amount * prev_scale + next.tolerance * next_scale;
 123   this->min_brightness =
 124     prev.min_brightness * prev_scale + next.min_brightness * next_scale;
 125   this->max_brightness =
 126     prev.max_brightness * prev_scale + next.max_brightness * next_scale;
 127   this->saturation =
 128     prev.saturation * prev_scale + next.saturation * next_scale;
 129   this->min_saturation =
 130     prev.min_saturation * prev_scale + next.min_saturation * next_scale;
 131   this->tolerance = prev.tolerance * prev_scale + next.tolerance * next_scale;
 132   this->in_slope = prev.in_slope * prev_scale + next.in_slope * next_scale;
 133   this->out_slope = prev.out_slope * prev_scale + next.out_slope * next_scale;
 134   this->alpha_offset =
 135     prev.alpha_offset * prev_scale + next.alpha_offset * next_scale;
 136   this->show_mask = next.show_mask;
 137
 138 }
 139
 140 int
 141 ChromaKeyConfig::get_color ()
 142 {
 143   int red = (int) (CLIP (this->red, 0, 1) * 0xff);
 144   int green = (int) (CLIP (this->green, 0, 1) * 0xff);
 145   int blue = (int) (CLIP (this->blue, 0, 1) * 0xff);
 146   return (red << 16) | (green << 8) | blue;
 147 }
 148
 149
 150
 151 ChromaKeyWindow::ChromaKeyWindow (ChromaKeyHSV * plugin)
 152  : PluginClientWindow(plugin,
 153            400,
 154            450,
 155            400,
 156            450,
 157            0)
 158 {
 159   this->plugin = plugin;
 160   color_thread = 0;
 161 }
 162
 163 ChromaKeyWindow::~ChromaKeyWindow ()
 164 {
 165   delete color_thread;
 166 }
 167
 168 void
 169 ChromaKeyWindow::create_objects ()
 170 {
 171   int y = 10, y1, x1 = 0, x2 = 10;
 172   int x = 30;
 173
 174   BC_Title *title;
 175   BC_Bar *bar;
 176   int ymargin = get_text_height(MEDIUMFONT) + 5;
 177   int ymargin2 = get_text_height(MEDIUMFONT) + 10;
 178
 179   add_subwindow (title = new BC_Title (x2, y, _("Color:")));
 180
 181   add_subwindow (color = new ChromaKeyColor (plugin, this, x, y + 25));
 182
 183   add_subwindow (sample =
 184                  new BC_SubWindow (x + color->get_w () + 10, y, 100, 50));
 185   y += sample->get_h () + 10;
 186
 187   add_subwindow (use_colorpicker =
 188                  new ChromaKeyUseColorPicker (plugin, this, x, y));
 189   y += use_colorpicker->get_h() + 10;
 190   add_subwindow (show_mask = new ChromaKeyShowMask (plugin, x2, y));
 191         y += show_mask->get_h() + 5;
 192
 193         add_subwindow(bar = new BC_Bar(x2, y, get_w() - x2 * 2));
 194         y += bar->get_h() + 5;
 195         y1 = y;
 196   add_subwindow (new BC_Title (x2, y, _("Key parameters:")));
 197   y += ymargin;
 198   add_subwindow (title = new BC_Title (x, y, _("Hue Tolerance:")));
 199   if(title->get_w() > x1) x1 = title->get_w();
 200   y += ymargin;
 201   add_subwindow (title = new BC_Title (x, y, _("Min. Brightness:")));
 202   if(title->get_w() > x1) x1 = title->get_w();
 203   y += ymargin;
 204   add_subwindow (title = new BC_Title (x, y, _("Max. Brightness:")));
 205   if(title->get_w() > x1) x1 = title->get_w();
 206   y += ymargin;
 207   add_subwindow (title = new BC_Title (x, y, _("Saturation Offset:")));
 208   if(title->get_w() > x1) x1 = title->get_w();
 209   y += ymargin;
 210   add_subwindow (title = new BC_Title (x, y, _("Min Saturation:")));
 211   if(title->get_w() > x1) x1 = title->get_w();
 212   y += ymargin2;
 213
 214         add_subwindow(bar = new BC_Bar(x2, y, get_w() - x2 * 2));
 215         y += bar->get_h() + 5;
 216   add_subwindow (title = new BC_Title (x2, y, _("Mask tweaking:")));
 217   y += ymargin;
 218   add_subwindow (title = new BC_Title (x, y, _("In Slope:")));
 219   if(title->get_w() > x1) x1 = title->get_w();
 220   y += ymargin;
 221   add_subwindow (title = new BC_Title (x, y, _("Out Slope:")));
 222   if(title->get_w() > x1) x1 = title->get_w();
 223   y += ymargin;
 224   add_subwindow (title = new BC_Title (x, y, _("Alpha Offset:")));
 225   if(title->get_w() > x1) x1 = title->get_w();
 226   y += ymargin2;
 227
 228
 229
 230         add_subwindow(bar = new BC_Bar(x2, y, get_w() - x2 * 2));
 231         y += bar->get_h() + 5;
 232   add_subwindow (title = new BC_Title (x2, y, _("Spill light control:")));
 233   y += ymargin;
 234   add_subwindow (title = new BC_Title (x, y, _("Spill Threshold:")));
 235   if(title->get_w() > x1) x1 = title->get_w();
 236   y += ymargin;
 237   add_subwindow (title = new BC_Title (x, y, _("Spill Compensation:")));
 238   if(title->get_w() > x1) x1 = title->get_w();
 239   y += ymargin;
 240
 241
 242         y = y1;
 243   y += ymargin;
 244         x1 += x;
 245
 246
 247
 248   add_subwindow (tolerance = new ChromaKeyTolerance (plugin, x1, y));
 249   y += ymargin;
 250   add_subwindow (min_brightness = new ChromaKeyMinBrightness (plugin, x1, y));
 251   y += ymargin;
 252   add_subwindow (max_brightness = new ChromaKeyMaxBrightness (plugin, x1, y));
 253   y += ymargin;
 254   add_subwindow (saturation = new ChromaKeySaturation (plugin, x1, y));
 255   y += ymargin;
 256   add_subwindow (min_saturation = new ChromaKeyMinSaturation (plugin, x1, y));
 257   y += ymargin;
 258
 259         y += bar->get_h() + 5;
 260   y += ymargin2;
 261   add_subwindow (in_slope = new ChromaKeyInSlope (plugin, x1, y));
 262   y += ymargin;
 263   add_subwindow (out_slope = new ChromaKeyOutSlope (plugin, x1, y));
 264   y += ymargin;
 265   add_subwindow (alpha_offset = new ChromaKeyAlphaOffset (plugin, x1, y));
 266    y += ymargin;
 267
 268         y += bar->get_h() + 5;
 269   y += ymargin2;
 270   add_subwindow (spill_threshold = new ChromaKeySpillThreshold (plugin, x1, y));
 271   y += ymargin;
 272   add_subwindow (spill_amount = new ChromaKeySpillAmount (plugin, x1, y));
 273
 274   color_thread = new ChromaKeyColorThread (plugin, this);
 275
 276   update_sample ();
 277   show_window ();
 278 }
 279
 280 void
 281 ChromaKeyWindow::update_sample ()
 282 {
 283   sample->set_color (plugin->config.get_color ());
 284   sample->draw_box (0, 0, sample->get_w (), sample->get_h ());
 285   sample->set_color (BLACK);
 286   sample->draw_rectangle (0, 0, sample->get_w (), sample->get_h ());
 287   sample->flash ();
 288 }
 289
 290
 291
 292 ChromaKeyColor::ChromaKeyColor (ChromaKeyHSV * plugin,
 293                                   ChromaKeyWindow * gui, int x, int y):
 294 BC_GenericButton (x, y, _("Color..."))
 295 {
 296   this->plugin = plugin;
 297   this->gui = gui;
 298 }
 299
 300 int
 301 ChromaKeyColor::handle_event ()
 302 {
 303   gui->color_thread->start_window (plugin->config.get_color (), 0xff);
 304   return 1;
 305 }
 306
 307
 308
 309
 310 ChromaKeyMinBrightness::ChromaKeyMinBrightness (ChromaKeyHSV * plugin, int x, int y):BC_FSlider (x,
 311             y,
 312             0,
 313             200, 200, (float) 0, (float) 100, plugin->config.min_brightness)
 314 {
 315   this->plugin = plugin;
 316   set_precision (0.01);
 317 }
 318
 319 int
 320 ChromaKeyMinBrightness::handle_event ()
 321 {
 322   plugin->config.min_brightness = get_value ();
 323   plugin->send_configure_change ();
 324   return 1;
 325 }
 326
 327 ChromaKeyMaxBrightness::ChromaKeyMaxBrightness (ChromaKeyHSV * plugin, int x, int y):BC_FSlider (x,
 328             y,
 329             0,
 330             200, 200, (float) 0, (float) 100, plugin->config.max_brightness)
 331 {
 332   this->plugin = plugin;
 333   set_precision (0.01);
 334 }
 335
 336 int
 337 ChromaKeyMaxBrightness::handle_event ()
 338 {
 339   plugin->config.max_brightness = get_value ();
 340   plugin->send_configure_change ();
 341   return 1;
 342 }
 343
 344
 345 ChromaKeySaturation::ChromaKeySaturation (ChromaKeyHSV * plugin, int x, int y):BC_FSlider (x,
 346             y,
 347             0, 200, 200, (float) 0, (float) 100, plugin->config.saturation)
 348 {
 349   this->plugin = plugin;
 350   set_precision (0.01);
 351 }
 352
 353 int
 354 ChromaKeySaturation::handle_event ()
 355 {
 356   plugin->config.saturation = get_value ();
 357   plugin->send_configure_change ();
 358   return 1;
 359 }
 360
 361 ChromaKeyMinSaturation::ChromaKeyMinSaturation (ChromaKeyHSV * plugin, int x, int y):BC_FSlider (x,
 362             y,
 363             0,
 364             200, 200, (float) 0, (float) 100, plugin->config.min_saturation)
 365 {
 366   this->plugin = plugin;
 367   set_precision (0.01);
 368 }
 369
 370 int
 371 ChromaKeyMinSaturation::handle_event ()
 372 {
 373   plugin->config.min_saturation = get_value ();
 374   plugin->send_configure_change ();
 375   return 1;
 376 }
 377
 378
 379 ChromaKeyTolerance::ChromaKeyTolerance (ChromaKeyHSV * plugin, int x, int y):BC_FSlider (x,
 380             y,
 381             0, 200, 200, (float) 0, (float) 100, plugin->config.tolerance)
 382 {
 383   this->plugin = plugin;
 384   set_precision (0.01);
 385 }
 386
 387 int
 388 ChromaKeyTolerance::handle_event ()
 389 {
 390   plugin->config.tolerance = get_value ();
 391   plugin->send_configure_change ();
 392   return 1;
 393 }
 394
 395
 396
 397 ChromaKeyInSlope::ChromaKeyInSlope (ChromaKeyHSV * plugin, int x, int y):BC_FSlider (x,
 398             y,
 399             0, 200, 200, (float) 0, (float) 20, plugin->config.in_slope)
 400 {
 401   this->plugin = plugin;
 402   set_precision (0.01);
 403 }
 404
 405 int
 406 ChromaKeyInSlope::handle_event ()
 407 {
 408   plugin->config.in_slope = get_value ();
 409   plugin->send_configure_change ();
 410   return 1;
 411 }
 412
 413
 414 ChromaKeyOutSlope::ChromaKeyOutSlope (ChromaKeyHSV * plugin, int x, int y):BC_FSlider (x,
 415             y,
 416             0, 200, 200, (float) 0, (float) 20, plugin->config.out_slope)
 417 {
 418   this->plugin = plugin;
 419   set_precision (0.01);
 420 }
 421
 422 int
 423 ChromaKeyOutSlope::handle_event ()
 424 {
 425   plugin->config.out_slope = get_value ();
 426   plugin->send_configure_change ();
 427   return 1;
 428 }
 429
 430
 431 ChromaKeyAlphaOffset::ChromaKeyAlphaOffset (ChromaKeyHSV * plugin, int x, int y):BC_FSlider (x,
 432             y,
 433             0,
 434             200, 200, (float) -100, (float) 100, plugin->config.alpha_offset)
 435 {
 436   this->plugin = plugin;
 437   set_precision (0.01);
 438 }
 439
 440 int
 441 ChromaKeyAlphaOffset::handle_event ()
 442 {
 443   plugin->config.alpha_offset = get_value ();
 444   plugin->send_configure_change ();
 445   return 1;
 446 }
 447
 448 ChromaKeyShowMask::ChromaKeyShowMask (ChromaKeyHSV * plugin, int x, int y):BC_CheckBox (x, y, plugin->config.show_mask,
 449              _
 450              ("Show Mask"))
 451 {
 452   this->plugin = plugin;
 453
 454 }
 455
 456 int
 457 ChromaKeyShowMask::handle_event ()
 458 {
 459   plugin->config.show_mask = get_value ();
 460   plugin->send_configure_change ();
 461   return 1;
 462 }
 463
 464 ChromaKeyUseColorPicker::ChromaKeyUseColorPicker (ChromaKeyHSV * plugin, ChromaKeyWindow * gui, int x, int y)
 465  : BC_GenericButton (x, y,
 466                   _
 467                   ("Use color picker"))
 468 {
 469   this->plugin = plugin;
 470   this->gui = gui;
 471 }
 472
 473 int
 474 ChromaKeyUseColorPicker::handle_event ()
 475 {
 476   plugin->config.red = plugin->get_red ();
 477   plugin->config.green = plugin->get_green ();
 478   plugin->config.blue = plugin->get_blue ();
 479
 480   gui->update_sample ();
 481
 482
 483   plugin->send_configure_change ();
 484   return 1;
 485 }
 486
 487
 488
 489 ChromaKeySpillThreshold::ChromaKeySpillThreshold (ChromaKeyHSV * plugin, int x, int y):BC_FSlider (x,
 490             y,
 491             0,
 492             200, 200, (float) 0, (float) 100, plugin->config.spill_threshold)
 493 {
 494   this->plugin = plugin;
 495   set_precision (0.01);
 496 }
 497
 498 int
 499 ChromaKeySpillThreshold::handle_event ()
 500 {
 501   plugin->config.spill_threshold = get_value ();
 502   plugin->send_configure_change ();
 503   return 1;
 504 }
 505
 506 ChromaKeySpillAmount::ChromaKeySpillAmount (ChromaKeyHSV * plugin, int x, int y):BC_FSlider (x,
 507             y,
 508             0, 200, 200, (float) 0, (float) 100, plugin->config.spill_amount)
 509 {
 510   this->plugin = plugin;
 511   set_precision (0.01);
 512 }
 513
 514 int
 515 ChromaKeySpillAmount::handle_event ()
 516 {
 517   plugin->config.spill_amount = get_value ();
 518   plugin->send_configure_change ();
 519   return 1;
 520 }
 521
 522
 523
 524
 525
 526
 527 ChromaKeyColorThread::ChromaKeyColorThread (ChromaKeyHSV * plugin, ChromaKeyWindow * gui)
 528  : ColorThread (1, _("Inner color"))
 529 {
 530   this->plugin = plugin;
 531   this->gui = gui;
 532 }
 533
 534 int
 535 ChromaKeyColorThread::handle_new_color (int output, int alpha)
 536 {
 537   plugin->config.red = (float) (output & 0xff0000) / 0xff0000;
 538   plugin->config.green = (float) (output & 0xff00) / 0xff00;
 539   plugin->config.blue = (float) (output & 0xff) / 0xff;
 540
 541   get_gui()->unlock_window();
 542   gui->lock_window("ChromaKeyColorThread::handle_new_color");
 543   gui->update_sample ();
 544   gui->unlock_window();
 545   get_gui()->lock_window("ChromaKeyColorThread::handle_new_color");
 546
 547
 548   plugin->send_configure_change ();
 549   return 1;
 550 }
 551
 552
 553
 554
 555
 556
 557
 558
 559 ChromaKeyServer::ChromaKeyServer (ChromaKeyHSV * plugin):LoadServer (plugin->PluginClient::smp + 1,
 560             plugin->PluginClient::smp +
 561             1)
 562 {
 563   this->plugin = plugin;
 564 }
 565
 566 void
 567 ChromaKeyServer::init_packages ()
 568 {
 569   for (int i = 0; i < get_total_packages (); i++)
 570     {
 571       ChromaKeyPackage *pkg = (ChromaKeyPackage *) get_package (i);
 572       pkg->y1 = plugin->input->get_h () * i / get_total_packages ();
 573       pkg->y2 = plugin->input->get_h () * (i + 1) / get_total_packages ();
 574     }
 575
 576 }
 577 LoadClient *
 578 ChromaKeyServer::new_client ()
 579 {
 580   return new ChromaKeyUnit (plugin, this);
 581 }
 582
 583 LoadPackage *
 584 ChromaKeyServer::new_package ()
 585 {
 586   return new ChromaKeyPackage;
 587 }
 588
 589
 590
 591 ChromaKeyPackage::ChromaKeyPackage ():LoadPackage ()
 592 {
 593 }
 594
 595 ChromaKeyUnit::ChromaKeyUnit (ChromaKeyHSV * plugin, ChromaKeyServer * server):LoadClient
 596   (server)
 597 {
 598   this->plugin = plugin;
 599 }
 600
 601
 602
 603
 604 #define ABS(a) ((a<0)?-(a):a)
 605 // Reuse as much as possible in the opengl version
 606 #define OUTER_VARIABLES \
 607   float red = plugin->config.red; \
 608   float green = plugin->config.green; \
 609   float blue = plugin->config.blue; \
 610  \
 611   float in_slope = plugin->config.in_slope / 100; \
 612   float out_slope = plugin->config.out_slope / 100; \
 613  \
 614   float tolerance = plugin->config.tolerance / 100; \
 615   float tolerance_in = tolerance - in_slope; \
 616   float tolerance_out = tolerance + out_slope; \
 617  \
 618   float sat = plugin->config.saturation / 100; \
 619   float min_s = plugin->config.min_saturation / 100; \
 620   float min_s_in = min_s + in_slope; \
 621   float min_s_out = min_s - out_slope; \
 622  \
 623   float min_v = plugin->config.min_brightness / 100; \
 624   float min_v_in = min_v + in_slope; \
 625   float min_v_out = min_v - out_slope; \
 626  \
 627   float max_v = plugin->config.max_brightness / 100; \
 628   float max_v_in = max_v - in_slope; \
 629   float max_v_out = max_v + out_slope; \
 630  \
 631   float spill_threshold = plugin->config.spill_threshold / 100; \
 632   float spill_amount = 1.0 - plugin->config.spill_amount / 100; \
 633  \
 634   float alpha_offset = plugin->config.alpha_offset / 100; \
 635  \
 636 /* Convert RGB key to HSV key */ \
 637         float hue_key, saturation_key, value_key; \
 638         HSV::rgb_to_hsv(red,  \
 639                 green, \
 640                 blue, \
 641                 hue_key, \
 642                 saturation_key, \
 643                 value_key);
 644
 645
 646 template <typename component_type>
 647 void ChromaKeyUnit::process_chromakey(int components,
 648         component_type max,
 649         bool use_yuv,
 650         ChromaKeyPackage *pkg)
 651 {
 652         OUTER_VARIABLES
 653
 654         int w = plugin->input->get_w();
 655
 656         for (int i = pkg->y1; i < pkg->y2; i++)
 657         {
 658         component_type *row = (component_type *) plugin->input->get_rows ()[i];
 659
 660         for (int j = 0; j < w; j++)
 661                 {
 662                         float a = 1;
 663
 664                         float r = (float) row[0] / max;
 665                         float g = (float) row[1] / max;
 666                         float b = (float) row[2] / max;
 667
 668                         float h, s, v;
 669
 670                         float av = 1, ah = 1, as = 1, avm = 1;
 671                         bool has_match = true;
 672
 673                         if (use_yuv)
 674                 {
 675 /* Convert pixel to RGB float */
 676                         float y = r;
 677                         float u = g;
 678                         float v = b;
 679                         YUV::yuv_to_rgb_f (r, g, b, y, u - 0.5, v - 0.5);
 680                 }
 681
 682                         HSV::rgb_to_hsv (r, g, b, h, s, v);
 683
 684 // First, test if the hue is in range
 685
 686 /* Hue wrap */
 687                         if(h <= hue_key - tolerance_in * 180.0)
 688                                 h += 360;
 689                         else
 690                         if(h >= hue_key + tolerance_in * 180.0)
 691                                 h -= 360;
 692
 693
 694                         if (tolerance == 0)
 695                     ah = 1.0;
 696                         else
 697                         if (ABS (h - hue_key) < tolerance_in * 180)
 698                     ah = 0;
 699                         else
 700                         if ((out_slope != 0) && (ABS (h - hue_key) < tolerance * 180))
 701 /* we scale alpha between 0 and 1/2 */
 702                     ah = ABS (h - hue_key) / tolerance / 360;
 703                         else
 704                         if (ABS (h - hue_key) < tolerance_out * 180)
 705 /* we scale alpha between 1/2 and 1 */
 706                     ah = ABS (h - hue_key) / tolerance_out / 360;
 707                         else
 708                     has_match = false;
 709
 710 // Check if the saturation matches
 711                         if (has_match)
 712                 {
 713                         if (min_s == 0)
 714                                         as = 0;
 715                         else if (s - sat >= min_s_in)
 716                                         as = 0;
 717                         else if ((out_slope != 0) && (s - sat > min_s))
 718                                         as = (s - sat - min_s) / (min_s * 2);
 719                         else if (s - sat > min_s_out)
 720                                         as = (s - sat - min_s_out) / (min_s_out * 2);
 721                         else
 722                                         has_match = false;
 723                 }
 724
 725 // Check if the value is more than the minimun
 726                         if (has_match)
 727                 {
 728                         if (min_v == 0)
 729                                         av = 0;
 730                         else if (v >= min_v_in)
 731                                         av = 0;
 732                         else if ((out_slope != 0) && (v > min_v))
 733                                         av = (v - min_v) / (min_v * 2);
 734                         else if (v > min_v_out)
 735                                         av = (v - min_v_out) / (min_v_out * 2);
 736                         else
 737                                         has_match = false;
 738                 }
 739
 740 // Check if the value is less than the maximum
 741                         if (has_match)
 742                 {
 743                         if (max_v == 0)
 744                                         avm = 1;
 745                         else if (v <= max_v_in)
 746                                         avm = 0;
 747                         else if ((out_slope != 0) && (v < max_v))
 748                                         avm = (v - max_v) / (max_v * 2);
 749                         else if (v < max_v_out)
 750                                         avm = (v - max_v_out) / (max_v_out * 2);
 751                         else
 752                                         has_match = false;
 753                 }
 754
 755           // If the color is part of the key, update the alpha channel
 756           if (has_match)
 757             a = MAX (MAX (ah, av), MAX (as, avm));
 758
 759           // Spill light processing
 760           if ((ABS (h - hue_key) < spill_threshold * 180) ||
 761               ((ABS (h - hue_key) > 360)
 762                && (ABS (h - hue_key) - 360 < spill_threshold * 180)))
 763             {
 764               s = s * spill_amount * ABS (h - hue_key) / (spill_threshold * 180);
 765
 766               HSV::hsv_to_rgb (r, g, b, h, s, v);
 767
 768               if (use_yuv)
 769                 {
 770                   float y;
 771                   float u;
 772                   float v;
 773                   YUV::rgb_to_yuv_f (r, g, b, y, u, v);
 774               CLAMP (y, 0, 1.0);
 775               CLAMP (u, 0, 1.0);
 776               CLAMP (v, 0, 1.0);
 777                   row[0] = (component_type) ((float) y * max);
 778                   row[1] = (component_type) ((float) (u + 0.5) * max);
 779                   row[2] = (component_type) ((float) (v + 0.5) * max);
 780                 }
 781               else
 782                 {
 783               CLAMP (r, 0, 1.0);
 784               CLAMP (g, 0, 1.0);
 785               CLAMP (b, 0, 1.0);
 786                   row[0] = (component_type) ((float) r * max);
 787                   row[1] = (component_type) ((float) g * max);
 788                   row[2] = (component_type) ((float) b * max);
 789                 }
 790             }
 791
 792           a += alpha_offset;
 793           CLAMP (a, 0.0, 1.0);
 794
 795           if (plugin->config.show_mask)
 796             {
 797
 798               if (use_yuv)
 799                 {
 800                   row[0] = (component_type) ((float) a * max);
 801                   row[1] = (component_type) ((float) max / 2);
 802                   row[2] = (component_type) ((float) max / 2);
 803                 }
 804               else
 805                 {
 806                   row[0] = (component_type) ((float) a * max);
 807                   row[1] = (component_type) ((float) a * max);
 808                   row[2] = (component_type) ((float) a * max);
 809                 }
 810             }
 811
 812           /* Multiply alpha and put back in frame */
 813           if (components == 4)
 814             {
 815               row[3] = MIN ((component_type) (a * max), row[3]);
 816             }
 817           else if (use_yuv)
 818             {
 819               row[0] = (component_type) ((float) a * row[0]);
 820               row[1] =
 821                 (component_type) ((float) a * (row[1] - (max / 2 + 1)) +
 822                                   max / 2 + 1);
 823               row[2] =
 824                 (component_type) ((float) a * (row[2] - (max / 2 + 1)) +
 825                                   max / 2 + 1);
 826             }
 827           else
 828             {
 829               row[0] = (component_type) ((float) a * row[0]);
 830               row[1] = (component_type) ((float) a * row[1]);
 831               row[2] = (component_type) ((float) a * row[2]);
 832             }
 833
 834           row += components;
 835         }
 836     }
 837 }
 838
 839
 840
 841
 842 void ChromaKeyUnit::process_package(LoadPackage *package)
 843 {
 844         ChromaKeyPackage *pkg = (ChromaKeyPackage*)package;
 845
 846
 847         switch(plugin->input->get_color_model())
 848         {
 849                 case BC_RGB_FLOAT:
 850                         process_chromakey<float> (3, 1.0, 0, pkg);
 851                         break;
 852                 case BC_RGBA_FLOAT:
 853                         process_chromakey<float> ( 4, 1.0, 0, pkg);
 854                         break;
 855                 case BC_RGB888:
 856                         process_chromakey<unsigned char> ( 3, 0xff, 0, pkg);
 857                         break;
 858                 case BC_RGBA8888:
 859                         process_chromakey<unsigned char> ( 4, 0xff, 0, pkg);
 860                         break;
 861                 case BC_YUV888:
 862                         process_chromakey<unsigned char> ( 3, 0xff, 1, pkg);
 863                         break;
 864                 case BC_YUVA8888:
 865                         process_chromakey<unsigned char> ( 4, 0xff, 1, pkg);
 866                         break;
 867                 case BC_YUV161616:
 868                         process_chromakey<uint16_t> (3, 0xffff, 1, pkg);
 869                         break;
 870                 case BC_YUVA16161616:
 871                         process_chromakey<uint16_t> (4, 0xffff, 1, pkg);
 872                         break;
 873         }
 874
 875 }
 876
 877
 878
 879
 880
 881 REGISTER_PLUGIN(ChromaKeyHSV)
 882
 883
 884
 885 ChromaKeyHSV::ChromaKeyHSV(PluginServer *server)
 886  : PluginVClient(server)
 887 {
 888
 889         engine = 0;
 890 }
 891
 892 ChromaKeyHSV::~ChromaKeyHSV()
 893 {
 894
 895         if(engine) delete engine;
 896 }
 897
 898
 899 int ChromaKeyHSV::process_buffer(VFrame *frame,
 900                 int64_t start_position,
 901                 double frame_rate)
 902 {
 903         load_configuration();
 904         this->input = frame;
 905         this->output = frame;
 906
 907
 908         read_frame(frame,
 909                 0,
 910                 start_position,
 911                 frame_rate,
 912                 get_use_opengl());
 913         if(get_use_opengl()) return run_opengl();
 914
 915
 916         if(!engine) engine = new ChromaKeyServer(this);
 917         engine->process_packages();
 918
 919         return 0;
 920 }
 921
 922 const char* ChromaKeyHSV::plugin_title() { return _("Chroma key (HSV)"); }
 923 int ChromaKeyHSV::is_realtime() { return 1; }
 924
 925
 926 LOAD_CONFIGURATION_MACRO(ChromaKeyHSV, ChromaKeyConfig)
 927
 928
 929 void ChromaKeyHSV::save_data(KeyFrame * keyframe)
 930 {
 931         FileXML output;
 932         output.set_shared_output(keyframe->get_data(), MESSAGESIZE);
 933         output.tag.set_title("CHROMAKEY_HSV");
 934         output.tag.set_property("RED", config.red);
 935         output.tag.set_property("GREEN", config.green);
 936         output.tag.set_property("BLUE", config.blue);
 937         output.tag.set_property("MIN_BRIGHTNESS", config.min_brightness);
 938         output.tag.set_property("MAX_BRIGHTNESS", config.max_brightness);
 939         output.tag.set_property("SATURATION", config.saturation);
 940         output.tag.set_property("MIN_SATURATION", config.min_saturation);
 941         output.tag.set_property("TOLERANCE", config.tolerance);
 942         output.tag.set_property("IN_SLOPE", config.in_slope);
 943         output.tag.set_property("OUT_SLOPE", config.out_slope);
 944         output.tag.set_property("ALPHA_OFFSET", config.alpha_offset);
 945         output.tag.set_property("SPILL_THRESHOLD", config.spill_threshold);
 946         output.tag.set_property("SPILL_AMOUNT", config.spill_amount);
 947         output.tag.set_property("SHOW_MASK", config.show_mask);
 948         output.append_tag();
 949         output.tag.set_title("/CHROMAKEY_HSV");
 950         output.append_tag();
 951         output.append_newline();
 952         output.terminate_string();
 953 }
 954
 955 void ChromaKeyHSV::read_data(KeyFrame * keyframe)
 956 {
 957         FileXML input;
 958
 959         input.set_shared_input(keyframe->get_data(), strlen(keyframe->get_data()));
 960
 961         while( !input.read_tag() ) {
 962                 if( input.tag.title_is("CHROMAKEY_HSV") ) {
 963                         config.red = input.tag.get_property("RED", config.red);
 964                         config.green = input.tag.get_property("GREEN", config.green);
 965                         config.blue = input.tag.get_property("BLUE", config.blue);
 966                         config.min_brightness =
 967                                 input.tag.get_property("MIN_BRIGHTNESS", config.min_brightness);
 968                         config.max_brightness =
 969                                 input.tag.get_property("MAX_BRIGHTNESS", config.max_brightness);
 970                         config.saturation =
 971                                 input.tag.get_property("SATURATION", config.saturation);
 972                         config.min_saturation =
 973                                 input.tag.get_property("MIN_SATURATION", config.min_saturation);
 974                         config.tolerance =
 975                                 input.tag.get_property("TOLERANCE", config.tolerance);
 976                         config.in_slope =
 977                                 input.tag.get_property("IN_SLOPE", config.in_slope);
 978                         config.out_slope =
 979                                 input.tag.get_property("OUT_SLOPE", config.out_slope);
 980                         config.alpha_offset =
 981                                 input.tag.get_property("ALPHA_OFFSET", config.alpha_offset);
 982                         config.spill_threshold =
 983                                 input.tag.get_property("SPILL_THRESHOLD",
 984                                                         config.spill_threshold);
 985                         config.spill_amount =
 986                                 input.tag.get_property("SPILL_AMOUNT", config.spill_amount);
 987                         config.show_mask =
 988                                 input.tag.get_property("SHOW_MASK", config.show_mask);
 989                 }
 990         }
 991 }
 992
 993
 994 NEW_WINDOW_MACRO(ChromaKeyHSV, ChromaKeyWindow)
 995
 996 void ChromaKeyHSV::update_gui()
 997 {
 998         if( thread ) {
 999                 load_configuration();
1000                 ChromaKeyWindow *window = (ChromaKeyWindow*)thread->window;
1001                 window->lock_window();
1002                 window->min_brightness->update(config.min_brightness);
1003                 window->max_brightness->update(config.max_brightness);
1004                 window->saturation->update(config.saturation);
1005                 window->min_saturation->update(config.min_saturation);
1006                 window->tolerance->update(config.tolerance);
1007                 window->in_slope->update(config.in_slope);
1008                 window->out_slope->update(config.out_slope);
1009                 window->alpha_offset->update(config.alpha_offset);
1010                 window->spill_threshold->update(config.spill_threshold);
1011                 window->spill_amount->update(config.spill_amount);
1012                 window->show_mask->update(config.show_mask);
1013                 window->update_sample();
1014                 window->unlock_window();
1015         }
1016 }
1017
1018
1019
1020
1021 int ChromaKeyHSV::handle_opengl()
1022 {
1023 #ifdef HAVE_GL
1024 // For macro
1025         ChromaKeyHSV *plugin = this;
1026         OUTER_VARIABLES
1027
1028         static const char *yuv_shader =
1029                 "const vec3 black = vec3(0.0, 0.5, 0.5);\n"
1030                 "\n"
1031                 "vec4 yuv_to_rgb(vec4 color)\n"
1032                 "{\n"
1033                         YUV_TO_RGB_FRAG("color")
1034                 "       return color;\n"
1035                 "}\n"
1036                 "\n"
1037                 "vec4 rgb_to_yuv(vec4 color)\n"
1038                 "{\n"
1039                         RGB_TO_YUV_FRAG("color")
1040                 "       return color;\n"
1041                 "}\n";
1042
1043         static const char *rgb_shader =
1044                 "const vec3 black = vec3(0.0, 0.0, 0.0);\n"
1045                 "\n"
1046                 "vec4 yuv_to_rgb(vec4 color)\n"
1047                 "{\n"
1048                 "       return color;\n"
1049                 "}\n"
1050                 "vec4 rgb_to_yuv(vec4 color)\n"
1051                 "{\n"
1052                 "       return color;\n"
1053                 "}\n";
1054
1055         static const char *hsv_shader =
1056                 "vec4 rgb_to_hsv(vec4 color)\n"
1057                 "{\n"
1058                         RGB_TO_HSV_FRAG("color")
1059                 "       return color;\n"
1060                 "}\n"
1061                 "\n"
1062                 "vec4 hsv_to_rgb(vec4 color)\n"
1063                 "{\n"
1064                         HSV_TO_RGB_FRAG("color")
1065                 "       return color;\n"
1066                 "}\n"
1067                 "\n";
1068
1069         static const char *show_rgbmask_shader =
1070                 "vec4 show_mask(vec4 color, vec4 color2)\n"
1071                 "{\n"
1072                 "       return vec4(1.0, 1.0, 1.0, min(color.a, color2.a));"
1073                 "}\n";
1074
1075         static const char *show_yuvmask_shader =
1076                 "vec4 show_mask(vec4 color, vec4 color2)\n"
1077                 "{\n"
1078                 "       return vec4(1.0, 0.5, 0.5, min(color.a, color2.a));"
1079                 "}\n";
1080
1081         static const char *nomask_shader =
1082                 "vec4 show_mask(vec4 color, vec4 color2)\n"
1083                 "{\n"
1084                 "       return vec4(color.rgb, min(color.a, color2.a));"
1085                 "}\n";
1086
1087         extern unsigned char _binary_chromakey_sl_start[];
1088         static const char *shader = (char*)_binary_chromakey_sl_start;
1089
1090         get_output()->to_texture();
1091         get_output()->enable_opengl();
1092         get_output()->init_screen();
1093
1094         const char* shader_stack[] = { 0, 0, 0, 0, 0 };
1095
1096         switch(get_output()->get_color_model())
1097         {
1098                 case BC_YUV888:
1099                 case BC_YUVA8888:
1100                         shader_stack[0] = yuv_shader;
1101                         shader_stack[1] = hsv_shader;
1102                         if(config.show_mask)
1103                                 shader_stack[2] = show_yuvmask_shader;
1104                         else
1105                                 shader_stack[2] = nomask_shader;
1106                         shader_stack[3] = shader;
1107                         break;
1108
1109                 default:
1110                         shader_stack[0] = rgb_shader;
1111                         shader_stack[1] = hsv_shader;
1112                         if(config.show_mask)
1113                                 shader_stack[2] = show_rgbmask_shader;
1114                         else
1115                                 shader_stack[2] = nomask_shader;
1116                         shader_stack[3] = shader;
1117                         break;
1118         }
1119
1120
1121         unsigned int frag = VFrame::make_shader(0,
1122                 shader_stack[0],
1123                 shader_stack[1],
1124                 shader_stack[2],
1125                 shader_stack[3],
1126                 0);
1127
1128         if(frag)
1129         {
1130                 glUseProgram(frag);
1131                 glUniform1i(glGetUniformLocation(frag, "tex"), 0);
1132                 glUniform1f(glGetUniformLocation(frag, "red"), red);
1133                 glUniform1f(glGetUniformLocation(frag, "green"), green);
1134                 glUniform1f(glGetUniformLocation(frag, "blue"), blue);
1135                 glUniform1f(glGetUniformLocation(frag, "in_slope"), in_slope);
1136                 glUniform1f(glGetUniformLocation(frag, "out_slope"), out_slope);
1137                 glUniform1f(glGetUniformLocation(frag, "tolerance"), tolerance);
1138                 glUniform1f(glGetUniformLocation(frag, "tolerance_in"), tolerance_in);
1139                 glUniform1f(glGetUniformLocation(frag, "tolerance_out"), tolerance_out);
1140                 glUniform1f(glGetUniformLocation(frag, "sat"), sat);
1141                 glUniform1f(glGetUniformLocation(frag, "min_s"), min_s);
1142                 glUniform1f(glGetUniformLocation(frag, "min_s_in"), min_s_in);
1143                 glUniform1f(glGetUniformLocation(frag, "min_s_out"), min_s_out);
1144                 glUniform1f(glGetUniformLocation(frag, "min_v"), min_v);
1145                 glUniform1f(glGetUniformLocation(frag, "min_v_in"), min_v_in);
1146                 glUniform1f(glGetUniformLocation(frag, "min_v_out"), min_v_out);
1147                 glUniform1f(glGetUniformLocation(frag, "max_v"), max_v);
1148                 glUniform1f(glGetUniformLocation(frag, "max_v_in"), max_v_in);
1149                 glUniform1f(glGetUniformLocation(frag, "max_v_out"), max_v_out);
1150                 glUniform1f(glGetUniformLocation(frag, "spill_threshold"), spill_threshold);
1151                 glUniform1f(glGetUniformLocation(frag, "spill_amount"), spill_amount);
1152                 glUniform1f(glGetUniformLocation(frag, "alpha_offset"), alpha_offset);
1153                 glUniform1f(glGetUniformLocation(frag, "hue_key"), hue_key);
1154                 glUniform1f(glGetUniformLocation(frag, "saturation_key"), saturation_key);
1155                 glUniform1f(glGetUniformLocation(frag, "value_key"), value_key);
1156         }
1157
1158
1159         get_output()->bind_texture(0);
1160         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
1161         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
1162
1163         if(BC_CModels::components(get_output()->get_color_model()) == 3)
1164         {
1165                 glEnable(GL_BLEND);
1166                 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1167                 get_output()->clear_pbuffer();
1168         }
1169         get_output()->draw_texture();
1170
1171         glUseProgram(0);
1172         get_output()->set_opengl_state(VFrame::SCREEN);
1173         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
1174         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
1175         glDisable(GL_BLEND);
1176
1177
1178 #endif
1179         return 0;
1180 }
1181