cinelerra-5.1/plugins/overlay/overlay.C

   1
   2 /*
   3  * CINELERRA
   4  * Copyright (C) 2008 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 "clip.h"
  24 #include "bchash.h"
  25 #include "edl.h"
  26 #include "edlsession.h"
  27 #include "filexml.h"
  28 #include "guicast.h"
  29 #include "keyframe.h"
  30 #include "language.h"
  31 #include "overlayframe.h"
  32 #include "pluginvclient.h"
  33 #include "vpatchgui.h"
  34 #include "vframe.h"
  35
  36 #include <string.h>
  37 #include <stdint.h>
  38
  39
  40 class Overlay;
  41 class OverlayWindow;
  42
  43
  44 class OverlayConfig
  45 {
  46 public:
  47         OverlayConfig();
  48
  49         static const char* mode_to_text(int mode);
  50         int mode;
  51
  52         static const char* direction_to_text(int direction);
  53         int direction;
  54         enum
  55         {
  56                 BOTTOM_FIRST,
  57                 TOP_FIRST
  58         };
  59
  60         static const char* output_to_text(int output_layer);
  61         int output_layer;
  62         enum
  63         {
  64                 TOP,
  65                 BOTTOM
  66         };
  67 };
  68
  69 class OverlayMode : public BC_PopupMenu
  70 {
  71 public:
  72         OverlayMode(Overlay *plugin,
  73                 int x,
  74                 int y);
  75         void create_objects();
  76         int handle_event();
  77         Overlay *plugin;
  78 };
  79
  80 class OverlayDirection : public BC_PopupMenu
  81 {
  82 public:
  83         OverlayDirection(Overlay *plugin,
  84                 int x,
  85                 int y);
  86         void create_objects();
  87         int handle_event();
  88         Overlay *plugin;
  89 };
  90
  91 class OverlayOutput : public BC_PopupMenu
  92 {
  93 public:
  94         OverlayOutput(Overlay *plugin,
  95                 int x,
  96                 int y);
  97         void create_objects();
  98         int handle_event();
  99         Overlay *plugin;
 100 };
 101
 102
 103 class OverlayWindow : public PluginClientWindow
 104 {
 105 public:
 106         OverlayWindow(Overlay *plugin);
 107         ~OverlayWindow();
 108
 109         void create_objects();
 110
 111
 112         Overlay *plugin;
 113         OverlayMode *mode;
 114         OverlayDirection *direction;
 115         OverlayOutput *output;
 116 };
 117
 118 class Overlay : public PluginVClient
 119 {
 120 public:
 121         Overlay(PluginServer *server);
 122         ~Overlay();
 123
 124
 125         PLUGIN_CLASS_MEMBERS(OverlayConfig);
 126
 127         int process_buffer(VFrame **frame,
 128                 int64_t start_position,
 129                 double frame_rate);
 130         int is_realtime();
 131         int is_multichannel();
 132         int is_synthesis();
 133         void save_data(KeyFrame *keyframe);
 134         void read_data(KeyFrame *keyframe);
 135         void update_gui();
 136         int handle_opengl();
 137
 138         OverlayFrame *overlayer;
 139         VFrame *temp;
 140         int current_layer;
 141         int output_layer;
 142         int input_layer;
 143 };
 144
 145 OverlayConfig::OverlayConfig()
 146 {
 147         mode = TRANSFER_NORMAL;
 148         direction = OverlayConfig::BOTTOM_FIRST;
 149         output_layer = OverlayConfig::TOP;
 150 }
 151
 152 const char* OverlayConfig::mode_to_text(int mode)
 153 {
 154         return VModePatch::mode_to_text(mode);
 155 }
 156
 157 const char* OverlayConfig::direction_to_text(int direction)
 158 {
 159         switch(direction)
 160         {
 161                 case OverlayConfig::BOTTOM_FIRST: return _("Bottom first");
 162                 case OverlayConfig::TOP_FIRST:    return _("Top first");
 163         }
 164         return "";
 165 }
 166
 167 const char* OverlayConfig::output_to_text(int output_layer)
 168 {
 169         switch(output_layer)
 170         {
 171                 case OverlayConfig::TOP:    return _("Top");
 172                 case OverlayConfig::BOTTOM: return _("Bottom");
 173         }
 174         return "";
 175 }
 176
 177
 178
 179
 180
 181
 182
 183
 184
 185 OverlayWindow::OverlayWindow(Overlay *plugin)
 186  : PluginClientWindow(plugin, xS(300), yS(100), xS(300), yS(100), 0)
 187 {
 188         this->plugin = plugin;
 189 }
 190
 191 OverlayWindow::~OverlayWindow()
 192 {
 193 }
 194
 195 void OverlayWindow::create_objects()
 196 {
 197         int xs5 = xS(5), xs10 = xS(10);
 198         int ys10 = yS(10), ys30 = yS(30);
 199         int x = xs10, y = ys10;
 200
 201         BC_Title *title;
 202         add_subwindow(title = new BC_Title(x, y, _("Mode:")));
 203         add_subwindow(mode = new OverlayMode(plugin,
 204                 x + title->get_w() + xs5,
 205                 y));
 206         mode->create_objects();
 207
 208         y += ys30;
 209         add_subwindow(title = new BC_Title(x, y, _("Layer order:")));
 210         add_subwindow(direction = new OverlayDirection(plugin,
 211                 x + title->get_w() + xs5,
 212                 y));
 213         direction->create_objects();
 214
 215         y += ys30;
 216         add_subwindow(title = new BC_Title(x, y, _("Output layer:")));
 217         add_subwindow(output = new OverlayOutput(plugin,
 218                 x + title->get_w() + xs5,
 219                 y));
 220         output->create_objects();
 221
 222         show_window();
 223         flush();
 224 }
 225
 226
 227
 228
 229
 230
 231
 232 OverlayMode::OverlayMode(Overlay *plugin, int x, int y)
 233  : BC_PopupMenu(x, y, xS(150),
 234         OverlayConfig::mode_to_text(plugin->config.mode), 1)
 235 {
 236         this->plugin = plugin;
 237 }
 238
 239 void OverlayMode::create_objects()
 240 {
 241         for(int i = 0; i < TRANSFER_TYPES; i++)
 242                 add_item(new BC_MenuItem(OverlayConfig::mode_to_text(i)));
 243 }
 244
 245 int OverlayMode::handle_event()
 246 {
 247         char *text = get_text();
 248
 249         for(int i = 0; i < TRANSFER_TYPES; i++)
 250         {
 251                 if(!strcmp(text, OverlayConfig::mode_to_text(i)))
 252                 {
 253                         plugin->config.mode = i;
 254                         break;
 255                 }
 256         }
 257
 258         plugin->send_configure_change();
 259         return 1;
 260 }
 261
 262
 263 OverlayDirection::OverlayDirection(Overlay *plugin,
 264         int x,
 265         int y)
 266  : BC_PopupMenu(x, y, xS(150),
 267         OverlayConfig::direction_to_text(plugin->config.direction),
 268         1)
 269 {
 270         this->plugin = plugin;
 271 }
 272
 273 void OverlayDirection::create_objects()
 274 {
 275         add_item(new BC_MenuItem(
 276                 OverlayConfig::direction_to_text(
 277                         OverlayConfig::TOP_FIRST)));
 278         add_item(new BC_MenuItem(
 279                 OverlayConfig::direction_to_text(
 280                         OverlayConfig::BOTTOM_FIRST)));
 281 }
 282
 283 int OverlayDirection::handle_event()
 284 {
 285         char *text = get_text();
 286
 287         if(!strcmp(text,
 288                 OverlayConfig::direction_to_text(
 289                         OverlayConfig::TOP_FIRST)))
 290                 plugin->config.direction = OverlayConfig::TOP_FIRST;
 291         else
 292         if(!strcmp(text,
 293                 OverlayConfig::direction_to_text(
 294                         OverlayConfig::BOTTOM_FIRST)))
 295                 plugin->config.direction = OverlayConfig::BOTTOM_FIRST;
 296
 297         plugin->send_configure_change();
 298         return 1;
 299 }
 300
 301
 302 OverlayOutput::OverlayOutput(Overlay *plugin,
 303         int x,
 304         int y)
 305  : BC_PopupMenu(x, y, xS(100),
 306         OverlayConfig::output_to_text(plugin->config.output_layer),
 307         1)
 308 {
 309         this->plugin = plugin;
 310 }
 311
 312 void OverlayOutput::create_objects()
 313 {
 314         add_item(new BC_MenuItem(
 315                 OverlayConfig::output_to_text(
 316                         OverlayConfig::TOP)));
 317         add_item(new BC_MenuItem(
 318                 OverlayConfig::output_to_text(
 319                         OverlayConfig::BOTTOM)));
 320 }
 321
 322 int OverlayOutput::handle_event()
 323 {
 324         char *text = get_text();
 325
 326         if(!strcmp(text,
 327                 OverlayConfig::output_to_text(
 328                         OverlayConfig::TOP)))
 329                 plugin->config.output_layer = OverlayConfig::TOP;
 330         else
 331         if(!strcmp(text,
 332                 OverlayConfig::output_to_text(
 333                         OverlayConfig::BOTTOM)))
 334                 plugin->config.output_layer = OverlayConfig::BOTTOM;
 335
 336         plugin->send_configure_change();
 337         return 1;
 338 }
 339
 340
 341
 342
 343
 344
 345
 346
 347
 348
 349
 350
 351
 352
 353
 354
 355
 356
 357
 358
 359 REGISTER_PLUGIN(Overlay)
 360
 361
 362
 363
 364
 365
 366 Overlay::Overlay(PluginServer *server)
 367  : PluginVClient(server)
 368 {
 369
 370         overlayer = 0;
 371         temp = 0;
 372 }
 373
 374
 375 Overlay::~Overlay()
 376 {
 377
 378         if(overlayer) delete overlayer;
 379         if(temp) delete temp;
 380 }
 381
 382
 383
 384 int Overlay::process_buffer(VFrame **frame,
 385         int64_t start_position,
 386         double frame_rate)
 387 {
 388         load_configuration();
 389
 390         EDLSession* session = get_edl()->session;
 391         int interpolation_type = session ? session->interpolation_type : NEAREST_NEIGHBOR;
 392
 393         int step = config.direction == OverlayConfig::BOTTOM_FIRST ?  -1 : 1;
 394         int layers = get_total_buffers();
 395         input_layer = config.direction == OverlayConfig::BOTTOM_FIRST ? layers-1 : 0;
 396         output_layer = config.output_layer == OverlayConfig::TOP ?  0 : layers-1;
 397         VFrame *output = frame[output_layer];
 398
 399         current_layer = input_layer;
 400         read_frame(output, current_layer,  // Direct copy the first layer
 401                          start_position, frame_rate, get_use_opengl());
 402
 403         if( --layers > 0 ) {    // need 2 layers to do overlay
 404                 if( !temp )
 405                         temp = new VFrame(frame[0]->get_w(), frame[0]->get_h(),
 406                                         frame[0]->get_color_model(), 0);
 407
 408                 while( --layers >= 0 ) {
 409                         current_layer += step;
 410                         read_frame(temp, current_layer,
 411                                  start_position, frame_rate, get_use_opengl());
 412
 413                         if(get_use_opengl()) {
 414                                 run_opengl();
 415                                 continue;
 416                         }
 417
 418                         if(!overlayer)
 419                                 overlayer = new OverlayFrame(get_project_smp() + 1);
 420
 421                         overlayer->overlay(output, temp,
 422                                 0, 0, output->get_w(), output->get_h(),
 423                                 0, 0, output->get_w(), output->get_h(),
 424                                 1, config.mode, interpolation_type);
 425                 }
 426         }
 427
 428         return 0;
 429 }
 430
 431 int Overlay::handle_opengl()
 432 {
 433 #ifdef HAVE_GL
 434         static const char *get_pixels_frag =
 435                 "uniform sampler2D src_tex;\n"
 436                 "uniform sampler2D dst_tex;\n"
 437                 "uniform vec2 dst_tex_dimensions;\n"
 438                 "uniform vec3 chroma_offset;\n"
 439                 "void main()\n"
 440                 "{\n"
 441                 "       vec4 dst_color = texture2D(dst_tex, gl_FragCoord.xy / dst_tex_dimensions);\n"
 442                 "       vec4 src_color = texture2D(src_tex, gl_TexCoord[0].st);\n"
 443                 "       src_color.rgb -= chroma_offset;\n"
 444                 "       dst_color.rgb -= chroma_offset;\n";
 445
 446         static const char *put_pixels_frag =
 447                 "       result.rgb += chroma_offset;\n"
 448                 "       gl_FragColor = result;\n"
 449                 "}\n";
 450
 451 #define QQ(q)#q
 452 #define SS(s)QQ(s)
 453
 454 #define GL_STD_FRAG(FN) static const char *blend_##FN##_frag = \
 455         "       vec4 result;\n" \
 456         "       result.rgb = " SS(COLOR_##FN(1.0, src_color.rgb, src_color.a, dst_color.rgb, dst_color.a)) ";\n" \
 457         "       result.a = " SS(ALPHA_##FN(1.0, src_color.a, dst_color.a))";\n" \
 458
 459 #define GL_VEC_FRAG(FN) static const char *blend_##FN##_frag = \
 460         "       vec4 result;\n" \
 461         "       result.r = " SS(COLOR_##FN(1.0, src_color.r, src_color.a, dst_color.r, dst_color.a)) ";\n" \
 462         "       result.g = " SS(COLOR_##FN(1.0, src_color.g, src_color.a, dst_color.g, dst_color.a)) ";\n" \
 463         "       result.b = " SS(COLOR_##FN(1.0, src_color.b, src_color.a, dst_color.b, dst_color.a)) ";\n" \
 464         "       result.a = " SS(ALPHA_##FN(1.0, src_color.a, dst_color.a)) ";\n" \
 465         "       result = clamp(result, 0.0, 1.0);\n" \
 466
 467 #undef mabs
 468 #define mabs abs
 469 #undef mmin
 470 #define mmin min
 471 #undef mmax
 472 #define mmax max
 473
 474 #undef ZERO
 475 #define ZERO 0.0
 476 #undef ONE
 477 #define ONE 1.0
 478 #undef TWO
 479 #define TWO 2.0
 480
 481 static const char *blend_REPLACE_frag =
 482         "       vec4 result = src_color;\n";
 483
 484 GL_VEC_FRAG(NORMAL);
 485 GL_VEC_FRAG(ADDITION);
 486 GL_VEC_FRAG(SUBTRACT);
 487 GL_STD_FRAG(MULTIPLY);
 488 GL_VEC_FRAG(DIVIDE);
 489 GL_VEC_FRAG(MAX);
 490 GL_VEC_FRAG(MIN);
 491 GL_VEC_FRAG(DARKEN);
 492 GL_VEC_FRAG(LIGHTEN);
 493 GL_STD_FRAG(DST);
 494 GL_STD_FRAG(DST_ATOP);
 495 GL_STD_FRAG(DST_IN);
 496 GL_STD_FRAG(DST_OUT);
 497 GL_STD_FRAG(DST_OVER);
 498 GL_STD_FRAG(SRC);
 499 GL_STD_FRAG(SRC_ATOP);
 500 GL_STD_FRAG(SRC_IN);
 501 GL_STD_FRAG(SRC_OUT);
 502 GL_STD_FRAG(SRC_OVER);
 503 GL_STD_FRAG(AND);
 504 GL_STD_FRAG(OR);
 505 GL_STD_FRAG(XOR);
 506 GL_VEC_FRAG(OVERLAY);
 507 GL_STD_FRAG(SCREEN);
 508 GL_VEC_FRAG(BURN);
 509 GL_VEC_FRAG(DODGE);
 510 GL_VEC_FRAG(HARDLIGHT);
 511 GL_VEC_FRAG(SOFTLIGHT);
 512 GL_VEC_FRAG(DIFFERENCE);
 513
 514 static const char * const overlay_shaders[TRANSFER_TYPES] = {
 515         blend_NORMAL_frag,      // TRANSFER_NORMAL
 516         blend_ADDITION_frag,    // TRANSFER_ADDITION
 517         blend_SUBTRACT_frag,    // TRANSFER_SUBTRACT
 518         blend_MULTIPLY_frag,    // TRANSFER_MULTIPLY
 519         blend_DIVIDE_frag,      // TRANSFER_DIVIDE
 520         blend_REPLACE_frag,     // TRANSFER_REPLACE
 521         blend_MAX_frag,         // TRANSFER_MAX
 522         blend_MIN_frag,         // TRANSFER_MIN
 523         blend_DARKEN_frag,      // TRANSFER_DARKEN
 524         blend_LIGHTEN_frag,     // TRANSFER_LIGHTEN
 525         blend_DST_frag,         // TRANSFER_DST
 526         blend_DST_ATOP_frag,    // TRANSFER_DST_ATOP
 527         blend_DST_IN_frag,      // TRANSFER_DST_IN
 528         blend_DST_OUT_frag,     // TRANSFER_DST_OUT
 529         blend_DST_OVER_frag,    // TRANSFER_DST_OVER
 530         blend_SRC_frag,         // TRANSFER_SRC
 531         blend_SRC_ATOP_frag,    // TRANSFER_SRC_ATOP
 532         blend_SRC_IN_frag,      // TRANSFER_SRC_IN
 533         blend_SRC_OUT_frag,     // TRANSFER_SRC_OUT
 534         blend_SRC_OVER_frag,    // TRANSFER_SRC_OVER
 535         blend_AND_frag,         // TRANSFER_AND
 536         blend_OR_frag,          // TRANSFER_OR
 537         blend_XOR_frag,         // TRANSFER_XOR
 538         blend_OVERLAY_frag,     // TRANSFER_OVERLAY
 539         blend_SCREEN_frag,      // TRANSFER_SCREEN
 540         blend_BURN_frag,        // TRANSFER_BURN
 541         blend_DODGE_frag,       // TRANSFER_DODGE
 542         blend_HARDLIGHT_frag,   // TRANSFER_HARDLIGHT
 543         blend_SOFTLIGHT_frag,   // TRANSFER_SOFTLIGHT
 544         blend_DIFFERENCE_frag,  // TRANSFER_DIFFERENCE
 545 };
 546
 547         glDisable(GL_BLEND);
 548         VFrame *dst = get_output(output_layer);
 549         VFrame *src = temp;
 550
 551         switch( config.mode ) {
 552         case TRANSFER_REPLACE:
 553         case TRANSFER_SRC:
 554 // Direct copy layer
 555                 src->to_texture();
 556                 dst->enable_opengl();
 557                 dst->init_screen();
 558                 src->draw_texture();
 559                 break;
 560         default:
 561                 src->to_texture();
 562                 dst->to_texture();
 563                 dst->enable_opengl();
 564                 dst->init_screen();
 565                 src->bind_texture(0);
 566                 dst->bind_texture(1);
 567
 568                 const char *shader_stack[16];
 569                 memset(shader_stack,0, sizeof(shader_stack));
 570                 int current_shader = 0;
 571
 572                 shader_stack[current_shader++] = get_pixels_frag;
 573                 shader_stack[current_shader++] = overlay_shaders[config.mode];
 574                 shader_stack[current_shader++] = put_pixels_frag;
 575                 shader_stack[current_shader] = 0;
 576                 unsigned int shader = VFrame::make_shader(shader_stack);
 577                 if( shader > 0 ) {
 578                         glUseProgram(shader);
 579                         glUniform1i(glGetUniformLocation(shader, "src_tex"), 0);
 580                         glUniform1i(glGetUniformLocation(shader, "dst_tex"), 1);
 581                         glUniform2f(glGetUniformLocation(shader, "dst_tex_dimensions"),
 582                                         (float)dst->get_texture_w(), (float)dst->get_texture_h());
 583                         float chroma_offset = BC_CModels::is_yuv(dst->get_color_model()) ? 0.5 : 0.0;
 584                         glUniform3f(glGetUniformLocation(shader, "chroma_offset"),
 585                                         0.0, chroma_offset, chroma_offset);
 586                 }
 587                 src->draw_texture();
 588                 glUseProgram(0);
 589
 590                 glActiveTexture(GL_TEXTURE1);
 591                 glDisable(GL_TEXTURE_2D);
 592                 break;
 593         }
 594
 595         glActiveTexture(GL_TEXTURE0);
 596         glDisable(GL_TEXTURE_2D);
 597         glDisable(GL_BLEND);
 598
 599 // get the data before something else uses the screen
 600         dst->screen_to_ram();
 601 #endif
 602         return 0;
 603 }
 604
 605
 606 const char* Overlay::plugin_title() { return N_("Overlay"); }
 607 int Overlay::is_realtime() { return 1; }
 608 int Overlay::is_multichannel() { return 1; }
 609 int Overlay::is_synthesis() { return 1; }
 610
 611
 612
 613 NEW_WINDOW_MACRO(Overlay, OverlayWindow)
 614
 615
 616
 617 int Overlay::load_configuration()
 618 {
 619         KeyFrame *prev_keyframe;
 620         prev_keyframe = get_prev_keyframe(get_source_position());
 621         read_data(prev_keyframe);
 622         return 0;
 623 }
 624
 625
 626 void Overlay::save_data(KeyFrame *keyframe)
 627 {
 628         FileXML output;
 629
 630 // cause data to be stored directly in text
 631         output.set_shared_output(keyframe->xbuf);
 632         output.tag.set_title("OVERLAY");
 633         output.tag.set_property("MODE", config.mode);
 634         output.tag.set_property("DIRECTION", config.direction);
 635         output.tag.set_property("OUTPUT_LAYER", config.output_layer);
 636         output.append_tag();
 637         output.tag.set_title("/OVERLAY");
 638         output.append_tag();
 639         output.terminate_string();
 640 }
 641
 642 void Overlay::read_data(KeyFrame *keyframe)
 643 {
 644         FileXML input;
 645
 646         input.set_shared_input(keyframe->xbuf);
 647
 648         while(!input.read_tag())
 649         {
 650                 if(input.tag.title_is("OVERLAY"))
 651                 {
 652                         config.mode = input.tag.get_property("MODE", config.mode);
 653                         config.direction = input.tag.get_property("DIRECTION", config.direction);
 654                         config.output_layer = input.tag.get_property("OUTPUT_LAYER", config.output_layer);
 655                 }
 656         }
 657 }
 658
 659 void Overlay::update_gui()
 660 {
 661         if(thread)
 662         {
 663                 thread->window->lock_window("Overlay::update_gui");
 664                 ((OverlayWindow*)thread->window)->mode->set_text(OverlayConfig::mode_to_text(config.mode));
 665                 ((OverlayWindow*)thread->window)->direction->set_text(OverlayConfig::direction_to_text(config.direction));
 666                 ((OverlayWindow*)thread->window)->output->set_text(OverlayConfig::output_to_text(config.output_layer));
 667                 thread->window->unlock_window();
 668         }
 669 }
 670
 671
 672
 673
 674