bg/clr color tweaks, clear borders rework, fc31 depends
[goodguy/cinelerra.git] / 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