cinelerra-5.1/plugins/foreground/foreground.C

   1
   2 /*
   3  * CINELERRA
   4  * Copyright (C) 2008-2019 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 #include <math.h>
  22 #include <stdint.h>
  23 #include <string.h>
  24
  25 #include "foreground.h"
  26 #include "filexml.h"
  27 #include "keyframe.h"
  28 #include "language.h"
  29 #include "vframe.h"
  30
  31
  32 REGISTER_PLUGIN(ForegroundMain)
  33
  34
  35 ForegroundConfig::ForegroundConfig()
  36 {
  37         r = 0xff;
  38         g = 0xff;
  39         b = 0xff;
  40         a = 0xff;
  41 }
  42
  43 int ForegroundConfig::equivalent(ForegroundConfig &that)
  44 {
  45         return (r == that.r && g == that.g && b == that.b &&
  46                 a == that.a);
  47 }
  48
  49 void ForegroundConfig::copy_from(ForegroundConfig &that)
  50 {
  51         r = that.r;
  52         g = that.g;
  53         b = that.b;
  54         a = that.a;
  55 }
  56
  57 void ForegroundConfig::interpolate(ForegroundConfig &prev, ForegroundConfig &next,
  58                 long prev_frame, long next_frame, long current_frame)
  59 {
  60         double next_scale = (double)(current_frame - prev_frame) / (next_frame - prev_frame);
  61         double prev_scale = (double)(next_frame - current_frame) / (next_frame - prev_frame);
  62
  63
  64         r = (int)(prev.r * prev_scale + next.r * next_scale);
  65         g = (int)(prev.g * prev_scale + next.g * next_scale);
  66         b = (int)(prev.b * prev_scale + next.b * next_scale);
  67         a = (int)(prev.a * prev_scale + next.a * next_scale);
  68 }
  69
  70 int ForegroundConfig::get_color()
  71 {
  72         int result = (r << 16) | (g << 8) | (b);
  73         return result;
  74 }
  75
  76
  77 ForegroundColors::ForegroundColors(ForegroundWindow *window, ForegroundMain *plugin)
  78  : ColorGUI(window)
  79 {
  80         this->window = window;
  81         this->plugin = plugin;
  82 }
  83 ForegroundColors::~ForegroundColors()
  84 {
  85 }
  86
  87 int ForegroundColors::handle_new_color(int output, int alpha)
  88 {
  89         plugin->config.r = (output>>16) & 0xff;
  90         plugin->config.g = (output>>8) & 0xff;
  91         plugin->config.b = (output) & 0xff;
  92         plugin->config.a = alpha;
  93         plugin->send_configure_change();
  94         return 1;
  95 }
  96 void ForegroundColors::update_gui(int output, int alpha)
  97 {
  98 }
  99
 100 ForegroundWindow::ForegroundWindow(ForegroundMain *plugin)
 101  : PluginClientWindow(plugin,
 102         ColorWindow::calculate_w(), ColorWindow::calculate_h() + BC_OKButton::calculate_h(),
 103         ColorWindow::calculate_w(), ColorWindow::calculate_h() + BC_OKButton::calculate_h(),
 104         0)
 105 {
 106         this->plugin = plugin;
 107         colors = new ForegroundColors(this, plugin);
 108 }
 109
 110 ForegroundWindow::~ForegroundWindow()
 111 {
 112         delete colors;
 113 }
 114
 115 void ForegroundWindow::create_objects()
 116 {
 117         colors = new ForegroundColors(this, plugin);
 118         int color = plugin->config.get_color();
 119         int alpha = plugin->config.a;
 120         colors->start_selection(color, alpha, 1);
 121         colors->create_objects();
 122         show_window();
 123 }
 124
 125 void ForegroundWindow::update()
 126 {
 127         int color = plugin->config.get_color();
 128         int alpha = plugin->config.a;
 129         colors->update_gui(color, alpha);
 130 }
 131
 132
 133 ForegroundMain::ForegroundMain(PluginServer *server)
 134  : PluginVClient(server)
 135 {
 136 }
 137
 138 ForegroundMain::~ForegroundMain()
 139 {
 140 }
 141
 142 const char* ForegroundMain::plugin_title() { return N_("Foreground"); }
 143 int ForegroundMain::is_realtime() { return 1; }
 144
 145 NEW_WINDOW_MACRO(ForegroundMain, ForegroundWindow)
 146
 147 LOAD_CONFIGURATION_MACRO(ForegroundMain, ForegroundConfig)
 148
 149 int ForegroundMain::is_synthesis()
 150 {
 151         return 1;
 152 }
 153
 154
 155 int ForegroundMain::process_buffer(VFrame *frame,
 156         int64_t start_position,
 157         double frame_rate)
 158 {
 159         load_configuration();
 160
 161         int need_alpha = config.a != 0xff;
 162         if( need_alpha ) {
 163                 read_frame(frame, 0, start_position,
 164                         frame_rate, get_use_opengl());
 165         }
 166
 167         int w = frame->get_w();
 168         int h = frame->get_h();
 169
 170
 171 #define MAIN_LOOP(type, temp, components, is_yuv) \
 172 { \
 173         temp c1, c2, c3, a; \
 174         temp transparency, max; \
 175         if( is_yuv ) { \
 176                 yuv.rgb_to_yuv_8(config.r, config.g, config.b, \
 177                         c1, c2, c3); \
 178                 a = config.a; \
 179                 transparency = 0xff - a; \
 180                 max = 0xff; \
 181 /* multiply alpha */ \
 182                 if( components == 3 ) { \
 183                         c1 = a * c1 / 0xff; \
 184                         c2 = (a * c2 + 0x80 * transparency) / 0xff; \
 185                         c3 = (a * c3 + 0x80 * transparency) / 0xff; \
 186                 } \
 187         } \
 188         else { \
 189                 c1 = config.r; c2 = config.g; c3 = config.b; a = config.a; \
 190                 transparency = 0xff - a; \
 191                 max = 0xff; \
 192                 if( sizeof(type) == 4 ) { \
 193                         c1 /= 0xff; c2 /= 0xff; c3 /= 0xff; a /= 0xff; \
 194                         transparency /= 0xff; \
 195                         max = 1.0; \
 196                 } \
 197 /* multiply alpha */ \
 198                 if(components == 3) { \
 199                         c1 = a * c1 / max; \
 200                         c2 = a * c2 / max; \
 201                         c3 = a * c3 / max; \
 202                 } \
 203         } \
 204  \
 205         for( int i=0; i<h; ++i ) { \
 206                 type *row = (type*)frame->get_rows()[i]; \
 207                 for( int j=0; j<w; ++j ) { \
 208                         if( components == 3 ) { \
 209                                 *row++ = c1; \
 210                                 *row++ = c2; \
 211                                 *row++ = c3; \
 212                         } \
 213                         else { \
 214                                 row[0] = (transparency * row[0] + a * c1) / max; \
 215                                 row[1] = (transparency * row[1] + a * c2) / max; \
 216                                 row[2] = (transparency * row[2] + a * c3) / max; \
 217                                 row[3] = MAX(row[3], a); \
 218                                 row += components; \
 219                         } \
 220                 } \
 221         } \
 222 }
 223         switch( frame->get_color_model() ) {
 224         case BC_RGB888:     MAIN_LOOP(uint8_t, int, 3, 0) break;
 225         case BC_RGB_FLOAT:  MAIN_LOOP(float, float, 3, 0) break;
 226         case BC_YUV888:     MAIN_LOOP(uint8_t, int, 3, 1) break;
 227         case BC_RGBA8888:   MAIN_LOOP(uint8_t, int, 4, 0) break;
 228         case BC_RGBA_FLOAT: MAIN_LOOP(float, float, 4, 0) break;
 229         case BC_YUVA8888:   MAIN_LOOP(uint8_t, int, 4, 1) break;
 230         }
 231
 232         return 0;
 233 }
 234
 235
 236 void ForegroundMain::update_gui()
 237 {
 238         if( !thread ) return;
 239         ForegroundWindow *window = (ForegroundWindow*)thread->window;
 240         if( !window ) return;
 241         if( !load_configuration() ) return;
 242         window->lock_window("ForegroundMain::update_gui");
 243         window->update();
 244         window->unlock_window();
 245 }
 246
 247
 248 void ForegroundMain::save_data(KeyFrame *keyframe)
 249 {
 250         FileXML output;
 251         output.set_shared_output(keyframe->xbuf);
 252         output.tag.set_title("FOREGROUND");
 253         output.tag.set_property("R", config.r);
 254         output.tag.set_property("G", config.g);
 255         output.tag.set_property("B", config.b);
 256         output.tag.set_property("A", config.a);
 257         output.append_tag();
 258         output.terminate_string();
 259 }
 260
 261 void ForegroundMain::read_data(KeyFrame *keyframe)
 262 {
 263         FileXML input;
 264         input.set_shared_input(keyframe->xbuf);
 265
 266         int result = 0;
 267         while( !(result = input.read_tag()) ) {
 268                 if( input.tag.title_is("FOREGROUND") ) {
 269                         config.r = input.tag.get_property("R", config.r);
 270                         config.g = input.tag.get_property("G", config.g);
 271                         config.b = input.tag.get_property("B", config.b);
 272                         config.a = input.tag.get_property("A", config.a);
 273                 }
 274         }
 275 }
 276