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