plugins/chromakey/chromakey.C

   1 #include "bcdisplayinfo.h"
   2 #include "chromakey.h"
   3 #include "clip.h"
   4 #include "defaults.h"
   5 #include "filexml.h"
   6 #include "guicast.h"
   7 #include "keyframe.h"
   8 #include "language.h"
   9 #include "loadbalance.h"
  10 #include "picon_png.h"
  11 #include "plugincolors.h"
  12 #include "pluginvclient.h"
  13 #include "vframe.h"
  14
  15 #include <stdint.h>
  16 #include <string.h>
  17
  18
  19
  20
  21
  22 ChromaKeyConfig::ChromaKeyConfig()
  23 {
  24         red = 0.0;
  25         green = 0.0;
  26         blue = 0.0;
  27         threshold = 60.0;
  28         use_value = 0;
  29         slope = 100;
  30 }
  31
  32
  33 void ChromaKeyConfig::copy_from(ChromaKeyConfig &src)
  34 {
  35         red = src.red;
  36         green = src.green;
  37         blue = src.blue;
  38         threshold = src.threshold;
  39         use_value = src.use_value;
  40         slope = src.slope;
  41 }
  42
  43 int ChromaKeyConfig::equivalent(ChromaKeyConfig &src)
  44 {
  45         return (EQUIV(red, src.red) &&
  46                 EQUIV(green, src.green) &&
  47                 EQUIV(blue, src.blue) &&
  48                 EQUIV(threshold, src.threshold) &&
  49                 EQUIV(slope, src.slope) &&
  50                 use_value == src.use_value);
  51 }
  52
  53 void ChromaKeyConfig::interpolate(ChromaKeyConfig &prev,
  54         ChromaKeyConfig &next,
  55         int64_t prev_frame,
  56         int64_t next_frame,
  57         int64_t current_frame)
  58 {
  59         double next_scale = (double)(current_frame - prev_frame) / (next_frame - prev_frame);
  60         double prev_scale = (double)(next_frame - current_frame) / (next_frame - prev_frame);
  61
  62         this->red = prev.red * prev_scale + next.red * next_scale;
  63         this->green = prev.green * prev_scale + next.green * next_scale;
  64         this->blue = prev.blue * prev_scale + next.blue * next_scale;
  65         this->threshold = prev.threshold * prev_scale + next.threshold * next_scale;
  66         this->slope = prev.slope * prev_scale + next.slope * next_scale;
  67         this->use_value = prev.use_value;
  68 }
  69
  70 int ChromaKeyConfig::get_color()
  71 {
  72         int red = (int)(CLIP(this->red, 0, 1) * 0xff);
  73         int green = (int)(CLIP(this->green, 0, 1) * 0xff);
  74         int blue = (int)(CLIP(this->blue, 0, 1) * 0xff);
  75         return (red << 16) | (green << 8) | blue;
  76 }
  77
  78
  79
  80
  81
  82
  83
  84 ChromaKeyWindow::ChromaKeyWindow(ChromaKey *plugin, int x, int y)
  85  : BC_Window(plugin->gui_string,
  86         x,
  87         y,
  88         320,
  89         220,
  90         320,
  91         220,
  92         0,
  93         0,
  94         1)
  95 {
  96         this->plugin = plugin;
  97         color_thread = 0;
  98 }
  99
 100 ChromaKeyWindow::~ChromaKeyWindow()
 101 {
 102         delete color_thread;
 103 }
 104
 105 void ChromaKeyWindow::create_objects()
 106 {
 107         int x = 10, y = 10, x1 = 100;
 108
 109         BC_Title *title;
 110         add_subwindow(title = new BC_Title(x, y, _("Color:")));
 111         x += title->get_w() + 10;
 112         add_subwindow(color = new ChromaKeyColor(plugin, this, x, y));
 113         x += color->get_w() + 10;
 114         add_subwindow(sample = new BC_SubWindow(x, y, 100, 50));
 115         y += sample->get_h() + 10;
 116         x = 10;
 117
 118         add_subwindow(new BC_Title(x, y, _("Slope:")));
 119         add_subwindow(slope = new ChromaKeySlope(plugin, x1, y));
 120
 121         y += 30;
 122         add_subwindow(new BC_Title(x, y, _("Threshold:")));
 123         add_subwindow(threshold = new ChromaKeyThreshold(plugin, x1, y));
 124
 125
 126         y += 30;
 127         add_subwindow(use_value = new ChromaKeyUseValue(plugin, x1, y));
 128
 129         y += 30;
 130         add_subwindow(use_colorpicker = new ChromaKeyUseColorPicker(plugin, this, x1, y));
 131
 132         color_thread = new ChromaKeyColorThread(plugin, this);
 133
 134         update_sample();
 135         show_window();
 136         flush();
 137 }
 138
 139 void ChromaKeyWindow::update_sample()
 140 {
 141         sample->set_color(plugin->config.get_color());
 142         sample->draw_box(0,
 143                 0,
 144                 sample->get_w(),
 145                 sample->get_h());
 146         sample->set_color(BLACK);
 147         sample->draw_rectangle(0,
 148                 0,
 149                 sample->get_w(),
 150                 sample->get_h());
 151         sample->flash();
 152 }
 153
 154
 155
 156 WINDOW_CLOSE_EVENT(ChromaKeyWindow)
 157
 158
 159
 160
 161
 162
 163 ChromaKeyColor::ChromaKeyColor(ChromaKey *plugin,
 164         ChromaKeyWindow *gui,
 165         int x,
 166         int y)
 167  : BC_GenericButton(x,
 168         y,
 169         _("Color..."))
 170 {
 171         this->plugin = plugin;
 172         this->gui = gui;
 173 }
 174 int ChromaKeyColor::handle_event()
 175 {
 176         gui->color_thread->start_window(
 177                 plugin->config.get_color(),
 178                 0xff);
 179         return 1;
 180 }
 181
 182
 183
 184
 185 ChromaKeyThreshold::ChromaKeyThreshold(ChromaKey *plugin, int x, int y)
 186  : BC_FSlider(x,
 187                         y,
 188                         0,
 189                         200,
 190                         200,
 191                         (float)0,
 192                         (float)100,
 193                         plugin->config.threshold)
 194 {
 195         this->plugin = plugin;
 196         set_precision(0.01);
 197 }
 198 int ChromaKeyThreshold::handle_event()
 199 {
 200         plugin->config.threshold = get_value();
 201         plugin->send_configure_change();
 202         return 1;
 203 }
 204
 205
 206 ChromaKeySlope::ChromaKeySlope(ChromaKey *plugin, int x, int y)
 207  : BC_FSlider(x,
 208                         y,
 209                         0,
 210                         200,
 211                         200,
 212                         (float)0,
 213                         (float)100,
 214                         plugin->config.slope)
 215 {
 216         this->plugin = plugin;
 217         set_precision(0.01);
 218 }
 219
 220 int ChromaKeySlope::handle_event()
 221 {
 222         plugin->config.slope = get_value();
 223         plugin->send_configure_change();
 224         return 1;
 225 }
 226
 227
 228 ChromaKeyUseValue::ChromaKeyUseValue(ChromaKey *plugin, int x, int y)
 229  : BC_CheckBox(x, y, plugin->config.use_value, _("Use value"))
 230 {
 231         this->plugin = plugin;
 232 }
 233 int ChromaKeyUseValue::handle_event()
 234 {
 235         plugin->config.use_value = get_value();
 236         plugin->send_configure_change();
 237         return 1;
 238 }
 239
 240
 241 ChromaKeyUseColorPicker::ChromaKeyUseColorPicker(ChromaKey *plugin,
 242         ChromaKeyWindow *gui,
 243         int x,
 244         int y)
 245  : BC_GenericButton(x, y, _("Use color picker"))
 246 {
 247         this->plugin = plugin;
 248         this->gui = gui;
 249 }
 250
 251 int ChromaKeyUseColorPicker::handle_event()
 252 {
 253         plugin->config.red = plugin->get_red();
 254         plugin->config.green = plugin->get_green();
 255         plugin->config.blue = plugin->get_blue();
 256         gui->update_sample();
 257         plugin->send_configure_change();
 258         return 1;
 259 }
 260
 261
 262
 263
 264 ChromaKeyColorThread::ChromaKeyColorThread(ChromaKey *plugin, ChromaKeyWindow *gui)
 265  : ColorThread(1, _("Inner color"))
 266 {
 267         this->plugin = plugin;
 268         this->gui = gui;
 269 }
 270
 271 int ChromaKeyColorThread::handle_new_color(int output, int alpha)
 272 {
 273         plugin->config.red = (float)(output & 0xff0000) / 0xff0000;
 274         plugin->config.green = (float)(output & 0xff00) / 0xff00;
 275         plugin->config.blue = (float)(output & 0xff) / 0xff;
 276         gui->update_sample();
 277         plugin->send_configure_change();
 278         return 1;
 279 }
 280
 281
 282
 283
 284
 285
 286
 287
 288 PLUGIN_THREAD_OBJECT(ChromaKey, ChromaKeyThread, ChromaKeyWindow)
 289
 290
 291 ChromaKeyServer::ChromaKeyServer(ChromaKey *plugin)
 292  : LoadServer(plugin->PluginClient::smp + 1, plugin->PluginClient::smp + 1)
 293 {
 294         this->plugin = plugin;
 295 }
 296 void ChromaKeyServer::init_packages()
 297 {
 298         for(int i = 0; i < get_total_packages(); i++)
 299         {
 300                 ChromaKeyPackage *pkg = (ChromaKeyPackage*)get_package(i);
 301                 pkg->y1 = plugin->input->get_h() * i / get_total_packages();
 302                 pkg->y2 = plugin->input->get_h() * (i + 1) / get_total_packages();
 303         }
 304
 305 }
 306 LoadClient* ChromaKeyServer::new_client()
 307 {
 308         return new ChromaKeyUnit(plugin, this);
 309 }
 310 LoadPackage* ChromaKeyServer::new_package()
 311 {
 312         return new ChromaKeyPackage;
 313 }
 314
 315
 316
 317 ChromaKeyPackage::ChromaKeyPackage()
 318  : LoadPackage()
 319 {
 320 }
 321
 322 ChromaKeyUnit::ChromaKeyUnit(ChromaKey *plugin, ChromaKeyServer *server)
 323  : LoadClient(server)
 324 {
 325         this->plugin = plugin;
 326 }
 327
 328
 329 void ChromaKeyUnit::process_package(LoadPackage *package)
 330 {
 331         ChromaKeyPackage *pkg = (ChromaKeyPackage*)package;
 332
 333         int w = plugin->input->get_w();
 334
 335         float h, s, v;
 336         HSV::rgb_to_hsv(plugin->config.red,
 337                 plugin->config.green,
 338                 plugin->config.blue,
 339                 h,
 340                 s,
 341                 v);
 342         float min_hue = h - plugin->config.threshold * 360 / 100;
 343         float max_hue = h + plugin->config.threshold * 360 / 100;
 344
 345
 346 #define RGB_TO_VALUE(r, g, b) \
 347 ((r) * R_TO_Y + (g) * G_TO_Y + (b) * B_TO_Y)
 348
 349 #define SQR(x) ((x) * (x))
 350
 351         float value = RGB_TO_VALUE(plugin->config.red,
 352                 plugin->config.green,
 353                 plugin->config.blue);
 354         float min_v = value - plugin->config.threshold / 100;
 355         float max_v = value + plugin->config.threshold / 100;
 356         float threshold = plugin->config.threshold / 100;
 357         float red = plugin->config.red;
 358         float green = plugin->config.green;
 359         float blue = plugin->config.blue;
 360
 361         float run = plugin->config.slope / 100;
 362         float threshold_run = threshold + run;
 363
 364
 365 #define CHROMAKEY(type, components, max, use_yuv) \
 366 { \
 367         for(int i = pkg->y1; i < pkg->y2; i++) \
 368         { \
 369                 type *row = (type*)plugin->input->get_rows()[i]; \
 370  \
 371                 for(int j = 0; j < w; j++) \
 372                 { \
 373                         float a = 1; \
 374  \
 375 /* Test for value in range */ \
 376                         if(plugin->config.use_value) \
 377                         { \
 378                                 float current_value; \
 379                                 if(use_yuv) \
 380                                 { \
 381                                         float r = (float)row[0] / max; \
 382                                         current_value = r; \
 383                                 } \
 384                                 else \
 385                                 { \
 386                                         float r = (float)row[0] / max; \
 387                                         float g = (float)row[1] / max; \
 388                                         float b = (float)row[2] / max; \
 389                                         current_value = RGB_TO_VALUE(r, g, b); \
 390                                 } \
 391  \
 392 /* Full transparency if in range */ \
 393                                 if(current_value >= min_v && current_value < max_v) \
 394                                 { \
 395                                         a = 0; \
 396                                 } \
 397                                 else \
 398 /* Phased out if below or above range */ \
 399                                 if(current_value < min_v) \
 400                                 { \
 401                                         if(min_v - current_value < run) \
 402                                                 a = (min_v - current_value) / run; \
 403                                 } \
 404                                 else \
 405                                 if(current_value - max_v < run) \
 406                                         a = (current_value - max_v) / run; \
 407                         } \
 408                         else \
 409 /* Use color cube */ \
 410                         { \
 411                                 float r = (float)row[0] / max; \
 412                                 float g = (float)row[1] / max; \
 413                                 float b = (float)row[2] / max; \
 414                                 if(use_yuv) \
 415                                 { \
 416 /* Convert pixel to RGB float */ \
 417                                         float y = r; \
 418                                         float u = g; \
 419                                         float v = b; \
 420                                         YUV::yuv_to_rgb_f(r, g, b, y, u - 0.5, v - 0.5); \
 421                                 } \
 422  \
 423                                 float difference = sqrt(SQR(r - red) +  \
 424                                         SQR(g - green) + \
 425                                         SQR(b - blue)); \
 426  \
 427                                 if(difference < threshold) \
 428                                 { \
 429                                         a = 0; \
 430                                 } \
 431                                 else \
 432                                 if(difference < threshold_run) \
 433                                 { \
 434                                         a = (difference - threshold) / run; \
 435                                 } \
 436  \
 437                         } \
 438  \
 439 /* Multiply alpha and put back in frame */ \
 440                         if(components == 4) \
 441                         { \
 442                                 row[3] = MIN((type)(a * max), row[3]); \
 443                         } \
 444                         else \
 445                         if(use_yuv) \
 446                         { \
 447                                 row[0] = (type)(a * row[0]); \
 448                                 row[1] = (type)(a * (row[1] - (max / 2 + 1)) + max / 2 + 1); \
 449                                 row[2] = (type)(a * (row[2] - (max / 2 + 1)) + max / 2 + 1); \
 450                         } \
 451                         else \
 452                         { \
 453                                 row[0] = (type)(a * row[0]); \
 454                                 row[1] = (type)(a * row[1]); \
 455                                 row[2] = (type)(a * row[2]); \
 456                         } \
 457  \
 458                         row += components; \
 459                 } \
 460         } \
 461 }
 462
 463
 464
 465
 466         switch(plugin->input->get_color_model())
 467         {
 468                 case BC_RGB_FLOAT:
 469                         CHROMAKEY(float, 3, 1.0, 0);
 470                         break;
 471                 case BC_RGBA_FLOAT:
 472                         CHROMAKEY(float, 4, 1.0, 0);
 473                         break;
 474                 case BC_RGB888:
 475                         CHROMAKEY(unsigned char, 3, 0xff, 0);
 476                         break;
 477                 case BC_RGBA8888:
 478                         CHROMAKEY(unsigned char, 4, 0xff, 0);
 479                         break;
 480                 case BC_YUV888:
 481                         CHROMAKEY(unsigned char, 3, 0xff, 1);
 482                         break;
 483                 case BC_YUVA8888:
 484                         CHROMAKEY(unsigned char, 4, 0xff, 1);
 485                         break;
 486                 case BC_YUV161616:
 487                         CHROMAKEY(uint16_t, 3, 0xffff, 1);
 488                         break;
 489                 case BC_YUVA16161616:
 490                         CHROMAKEY(uint16_t, 4, 0xffff, 1);
 491                         break;
 492         }
 493
 494 }
 495
 496
 497
 498
 499
 500 REGISTER_PLUGIN(ChromaKey)
 501
 502
 503
 504 ChromaKey::ChromaKey(PluginServer *server)
 505  : PluginVClient(server)
 506 {
 507         PLUGIN_CONSTRUCTOR_MACRO
 508         engine = 0;
 509 }
 510
 511 ChromaKey::~ChromaKey()
 512 {
 513         PLUGIN_DESTRUCTOR_MACRO
 514         if(engine) delete engine;
 515 }
 516
 517
 518 int ChromaKey::process_realtime(VFrame *input, VFrame *output)
 519 {
 520         load_configuration();
 521         this->input = input;
 522         this->output = output;
 523
 524         if(EQUIV(config.threshold, 0))
 525         {
 526                 if(input->get_rows()[0] != output->get_rows()[0])
 527                         output->copy_from(input);
 528         }
 529         else
 530         {
 531                 if(!engine) engine = new ChromaKeyServer(this);
 532                 engine->process_packages();
 533         }
 534
 535         return 0;
 536 }
 537
 538 char* ChromaKey::plugin_title() { return N_("Chroma key"); }
 539 int ChromaKey::is_realtime() { return 1; }
 540
 541 NEW_PICON_MACRO(ChromaKey)
 542
 543 LOAD_CONFIGURATION_MACRO(ChromaKey, ChromaKeyConfig)
 544
 545 int ChromaKey::load_defaults()
 546 {
 547         char directory[BCTEXTLEN];
 548 // set the default directory
 549         sprintf(directory, "%schromakey.rc", BCASTDIR);
 550
 551 // load the defaults
 552         defaults = new Defaults(directory);
 553         defaults->load();
 554
 555         config.red = defaults->get("RED", config.red);
 556         config.green = defaults->get("GREEN", config.green);
 557         config.blue = defaults->get("BLUE", config.blue);
 558         config.threshold = defaults->get("THRESHOLD", config.threshold);
 559         config.slope = defaults->get("SLOPE", config.slope);
 560         config.use_value = defaults->get("USE_VALUE", config.use_value);
 561         return 0;
 562 }
 563
 564 int ChromaKey::save_defaults()
 565 {
 566         defaults->update("RED", config.red);
 567         defaults->update("GREEN", config.green);
 568         defaults->update("BLUE", config.blue);
 569     defaults->update("THRESHOLD", config.threshold);
 570     defaults->update("SLOPE", config.slope);
 571     defaults->update("USE_VALUE", config.use_value);
 572         defaults->save();
 573         return 0;
 574 }
 575
 576 void ChromaKey::save_data(KeyFrame *keyframe)
 577 {
 578         FileXML output;
 579         output.set_shared_string(keyframe->data, MESSAGESIZE);
 580         output.tag.set_title("CHROMAKEY");
 581         output.tag.set_property("RED", config.red);
 582         output.tag.set_property("GREEN", config.green);
 583         output.tag.set_property("BLUE", config.blue);
 584         output.tag.set_property("THRESHOLD", config.threshold);
 585         output.tag.set_property("SLOPE", config.slope);
 586         output.tag.set_property("USE_VALUE", config.use_value);
 587         output.append_tag();
 588         output.terminate_string();
 589 }
 590
 591 void ChromaKey::read_data(KeyFrame *keyframe)
 592 {
 593         FileXML input;
 594
 595         input.set_shared_string(keyframe->data, strlen(keyframe->data));
 596
 597         while(!input.read_tag())
 598         {
 599                 if(input.tag.title_is("CHROMAKEY"))
 600                 {
 601                         config.red = input.tag.get_property("RED", config.red);
 602                         config.green = input.tag.get_property("GREEN", config.green);
 603                         config.blue = input.tag.get_property("BLUE", config.blue);
 604                         config.threshold = input.tag.get_property("THRESHOLD", config.threshold);
 605                         config.slope = input.tag.get_property("SLOPE", config.slope);
 606                         config.use_value = input.tag.get_property("USE_VALUE", config.use_value);
 607                 }
 608         }
 609 }
 610
 611
 612 SHOW_GUI_MACRO(ChromaKey, ChromaKeyThread)
 613
 614 SET_STRING_MACRO(ChromaKey)
 615
 616 RAISE_WINDOW_MACRO(ChromaKey)
 617
 618 void ChromaKey::update_gui()
 619 {
 620         if(thread)
 621         {
 622                 load_configuration();
 623                 thread->window->lock_window();
 624                 thread->window->threshold->update(config.threshold);
 625                 thread->window->slope->update(config.slope);
 626                 thread->window->use_value->update(config.use_value);
 627                 thread->window->update_sample();
 628
 629                 thread->window->unlock_window();
 630         }
 631 }
 632
 633
 634
 635
 636
 637
 638
 639