cinelerra-5.1/plugins/translate/translate.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 "clip.h"
  23 #include "filexml.h"
  24 #include "language.h"
  25 #include "translate.h"
  26 #include "translatewin.h"
  27
  28 #include <string.h>
  29
  30
  31
  32
  33 REGISTER_PLUGIN(TranslateMain)
  34
  35 TranslateConfig::TranslateConfig()
  36 {
  37         in_x = 0;
  38         in_y = 0;
  39         in_w = 720;
  40         in_h = 480;
  41         out_x = 0;
  42         out_y = 0;
  43         out_w = 720;
  44         out_h = 480;
  45 }
  46
  47 int TranslateConfig::equivalent(TranslateConfig &that)
  48 {
  49         return EQUIV(in_x, that.in_x) &&
  50                 EQUIV(in_y, that.in_y) &&
  51                 EQUIV(in_w, that.in_w) &&
  52                 EQUIV(in_h, that.in_h) &&
  53                 EQUIV(out_x, that.out_x) &&
  54                 EQUIV(out_y, that.out_y) &&
  55                 EQUIV(out_w, that.out_w) &&
  56                 EQUIV(out_h, that.out_h);
  57 }
  58
  59 void TranslateConfig::copy_from(TranslateConfig &that)
  60 {
  61         in_x = that.in_x;
  62         in_y = that.in_y;
  63         in_w = that.in_w;
  64         in_h = that.in_h;
  65         out_x = that.out_x;
  66         out_y = that.out_y;
  67         out_w = that.out_w;
  68         out_h = that.out_h;
  69 }
  70
  71 void TranslateConfig::interpolate(TranslateConfig &prev,
  72         TranslateConfig &next,
  73         int64_t prev_frame,
  74         int64_t next_frame,
  75         int64_t current_frame)
  76 {
  77         double next_scale = (double)(current_frame - prev_frame) / (next_frame - prev_frame);
  78         double prev_scale = (double)(next_frame - current_frame) / (next_frame - prev_frame);
  79
  80         this->in_x = prev.in_x * prev_scale + next.in_x * next_scale;
  81         this->in_y = prev.in_y * prev_scale + next.in_y * next_scale;
  82         this->in_w = prev.in_w * prev_scale + next.in_w * next_scale;
  83         this->in_h = prev.in_h * prev_scale + next.in_h * next_scale;
  84         this->out_x = prev.out_x * prev_scale + next.out_x * next_scale;
  85         this->out_y = prev.out_y * prev_scale + next.out_y * next_scale;
  86         this->out_w = prev.out_w * prev_scale + next.out_w * next_scale;
  87         this->out_h = prev.out_h * prev_scale + next.out_h * next_scale;
  88 }
  89
  90
  91
  92
  93
  94
  95
  96
  97 TranslateMain::TranslateMain(PluginServer *server)
  98  : PluginVClient(server)
  99 {
 100         temp_frame = 0;
 101         overlayer = 0;
 102
 103 }
 104
 105 TranslateMain::~TranslateMain()
 106 {
 107
 108
 109         if(temp_frame) delete temp_frame;
 110         temp_frame = 0;
 111         if(overlayer) delete overlayer;
 112         overlayer = 0;
 113 }
 114
 115 const char* TranslateMain::plugin_title() { return _("Translate"); }
 116 int TranslateMain::is_realtime() { return 1; }
 117
 118
 119
 120 LOAD_CONFIGURATION_MACRO(TranslateMain, TranslateConfig)
 121
 122 void TranslateMain::save_data(KeyFrame *keyframe)
 123 {
 124         FileXML output;
 125
 126 // cause data to be stored directly in text
 127         output.set_shared_output(keyframe->get_data(), MESSAGESIZE);
 128
 129 // Store data
 130         output.tag.set_title("TRANSLATE");
 131         output.tag.set_property("IN_X", config.in_x);
 132         output.tag.set_property("IN_Y", config.in_y);
 133         output.tag.set_property("IN_W", config.in_w);
 134         output.tag.set_property("IN_H", config.in_h);
 135         output.tag.set_property("OUT_X", config.out_x);
 136         output.tag.set_property("OUT_Y", config.out_y);
 137         output.tag.set_property("OUT_W", config.out_w);
 138         output.tag.set_property("OUT_H", config.out_h);
 139         output.append_tag();
 140         output.tag.set_title("/TRANSLATE");
 141         output.append_tag();
 142         output.append_newline();
 143         output.terminate_string();
 144 // data is now in *text
 145 }
 146
 147 void TranslateMain::read_data(KeyFrame *keyframe)
 148 {
 149         FileXML input;
 150
 151         input.set_shared_input(keyframe->get_data(), strlen(keyframe->get_data()));
 152
 153         int result = 0;
 154
 155         while(!result)
 156         {
 157                 result = input.read_tag();
 158
 159                 if(!result)
 160                 {
 161                         if(input.tag.title_is("TRANSLATE"))
 162                         {
 163                                 config.in_x = input.tag.get_property("IN_X", config.in_x);
 164                                 config.in_y = input.tag.get_property("IN_Y", config.in_y);
 165                                 config.in_w = input.tag.get_property("IN_W", config.in_w);
 166                                 config.in_h = input.tag.get_property("IN_H", config.in_h);
 167                                 config.out_x =  input.tag.get_property("OUT_X", config.out_x);
 168                                 config.out_y =  input.tag.get_property("OUT_Y", config.out_y);
 169                                 config.out_w =  input.tag.get_property("OUT_W", config.out_w);
 170                                 config.out_h =  input.tag.get_property("OUT_H", config.out_h);
 171                         }
 172                 }
 173         }
 174 }
 175
 176
 177 #define EPSILON 0.001
 178
 179 int TranslateMain::process_realtime(VFrame *input_ptr, VFrame *output_ptr)
 180 {
 181         VFrame *input = input_ptr;
 182         VFrame *output = output_ptr;
 183
 184         load_configuration();
 185
 186 //printf("TranslateMain::process_realtime 1 %p\n", input);
 187         if( input->get_rows()[0] == output->get_rows()[0] ) {
 188                 if( temp_frame && (
 189                     temp_frame->get_w() != input_ptr->get_w() ||
 190                     temp_frame->get_h() != input_ptr->get_h() ||
 191                     temp_frame->get_color_model() != input_ptr->get_color_model() ) ) {
 192                         delete temp_frame;
 193                         temp_frame = 0;
 194                 }
 195                 if(!temp_frame)
 196                         temp_frame = new VFrame(0,
 197                                 -1,
 198                                 input_ptr->get_w(),
 199                                 input_ptr->get_h(),
 200                                 input->get_color_model(),
 201                                 -1);
 202                 temp_frame->copy_from(input);
 203                 input = temp_frame;
 204         }
 205 //printf("TranslateMain::process_realtime 2 %p\n", input);
 206
 207
 208         if(!overlayer)
 209         {
 210                 overlayer = new OverlayFrame(smp + 1);
 211         }
 212
 213         output->clear_frame();
 214
 215         if( config.in_w < EPSILON ) return 1;
 216         if( config.in_h < EPSILON ) return 1;
 217         if( config.out_w < EPSILON ) return 1;
 218         if( config.out_h < EPSILON ) return 1;
 219
 220         float ix1 = config.in_x, ox1 = config.out_x;
 221         float ix2 = ix1 + config.in_w;
 222
 223         if( ix1 < 0 ) {
 224                 ox1 -= ix1;
 225                 ix2 = config.in_w;
 226                 ix1 = 0;
 227         }
 228
 229         if(ix2 > output->get_w())
 230                 ix2 = output->get_w();
 231
 232         float iy1 = config.in_y, oy1 = config.out_y;
 233         float iy2 = iy1 + config.in_h;
 234
 235         if( iy1 < 0 ) {
 236                 oy1 -= iy1;
 237                 iy2 = config.in_h;
 238                 iy1 = 0;
 239         }
 240
 241         if( iy2 > output->get_h() )
 242                 iy2 = output->get_h();
 243
 244         float cx = config.out_w / config.in_w;
 245         float cy = config.out_h / config.in_h;
 246
 247         float ox2 = ox1 + (ix2 - ix1) * cx;
 248         float oy2 = oy1 + (iy2 - iy1) * cy;
 249
 250         if( ox1 < 0 ) {
 251                 ix1 += -ox1 / cx;
 252                 ox1 = 0;
 253         }
 254         if( oy1 < 0 ) {
 255                 iy1 += -oy1 / cy;
 256                 oy1 = 0;
 257         }
 258         if( ox2 > output->get_w() ) {
 259                 ix2 -= (ox2 - output->get_w()) / cx;
 260                 ox2 = output->get_w();
 261         }
 262         if( oy2 > output->get_h() ) {
 263                 iy2 -= (oy2 - output->get_h()) / cy;
 264                 oy2 = output->get_h();
 265         }
 266
 267         if( ix1 >= ix2 ) return 1;
 268         if( iy1 >= iy2 ) return 1;
 269         if( ox1 >= ox2 ) return 1;
 270         if( oy1 >= oy2 ) return 1;
 271
 272         overlayer->overlay(output, input,
 273                 ix1, iy1, ix2, iy2,
 274                 ox1, oy1, ox2, oy2,
 275                 1, TRANSFER_REPLACE,
 276                 get_interpolation_type());
 277         return 0;
 278 }
 279
 280 NEW_WINDOW_MACRO(TranslateMain, TranslateWin)
 281
 282 void TranslateMain::update_gui()
 283 {
 284         if( !thread ) return;
 285         if( !load_configuration() ) return;
 286
 287         TranslateWin *window = (TranslateWin*)thread->window;
 288         window->lock_window();
 289         window->in_x->update(config.in_x);
 290         window->in_y->update(config.in_y);
 291         window->in_w->update(config.in_w);
 292         window->in_h->update(config.in_h);
 293         window->out_x->update(config.out_x);
 294         window->out_y->update(config.out_y);
 295         window->out_w->update(config.out_w);
 296         window->out_h->update(config.out_h);
 297         window->unlock_window();
 298 }