cinelerra-5.0/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
 141         output.terminate_string();
 142 // data is now in *text
 143 }
 144
 145 void TranslateMain::read_data(KeyFrame *keyframe)
 146 {
 147         FileXML input;
 148
 149         input.set_shared_input(keyframe->get_data(), strlen(keyframe->get_data()));
 150
 151         int result = 0;
 152
 153         while(!result)
 154         {
 155                 result = input.read_tag();
 156
 157                 if(!result)
 158                 {
 159                         if(input.tag.title_is("TRANSLATE"))
 160                         {
 161                                 config.in_x = input.tag.get_property("IN_X", config.in_x);
 162                                 config.in_y = input.tag.get_property("IN_Y", config.in_y);
 163                                 config.in_w = input.tag.get_property("IN_W", config.in_w);
 164                                 config.in_h = input.tag.get_property("IN_H", config.in_h);
 165                                 config.out_x =  input.tag.get_property("OUT_X", config.out_x);
 166                                 config.out_y =  input.tag.get_property("OUT_Y", config.out_y);
 167                                 config.out_w =  input.tag.get_property("OUT_W", config.out_w);
 168                                 config.out_h =  input.tag.get_property("OUT_H", config.out_h);
 169                         }
 170                 }
 171         }
 172 }
 173
 174
 175
 176
 177
 178
 179
 180
 181 int TranslateMain::process_realtime(VFrame *input_ptr, VFrame *output_ptr)
 182 {
 183         VFrame *input, *output;
 184
 185
 186         input = input_ptr;
 187         output = output_ptr;
 188
 189         load_configuration();
 190
 191 //printf("TranslateMain::process_realtime 1 %p\n", input);
 192         if(input->get_rows()[0] == output->get_rows()[0])
 193         {
 194                 if(!temp_frame)
 195                         temp_frame = new VFrame(0,
 196                                 -1,
 197                                 input_ptr->get_w(),
 198                                 input_ptr->get_h(),
 199                                 input->get_color_model(),
 200                                 -1);
 201                 temp_frame->copy_from(input);
 202                 input = temp_frame;
 203         }
 204 //printf("TranslateMain::process_realtime 2 %p\n", input);
 205
 206
 207         if(!overlayer)
 208         {
 209                 overlayer = new OverlayFrame(smp + 1);
 210         }
 211
 212         output->clear_frame();
 213
 214
 215 // printf("TranslateMain::process_realtime 3 output=%p input=%p config.w=%f config.h=%f"
 216 //   "%f %f %f %f -> %f %f %f %f\n", output, input, config.w, config.h,
 217 //   in_x1, in_y1, in_x2, in_y2, out_x1, out_y1, out_x2, out_y2);
 218                 overlayer->overlay(output, input,
 219                         config.in_x, config.in_y,
 220                         config.in_x + config.in_w, config.in_y + config.in_h,
 221                         config.out_x, config.out_y,
 222                         config.out_x + config.out_w, config.out_y + config.out_h,
 223                         1, TRANSFER_REPLACE, get_interpolation_type());
 224         return 0;
 225 }
 226
 227
 228
 229 NEW_WINDOW_MACRO(TranslateMain, TranslateWin)
 230
 231 void TranslateMain::update_gui()
 232 {
 233         if(thread)
 234         {
 235                 if(load_configuration())
 236                 {
 237                         thread->window->lock_window();
 238                         ((TranslateWin*)thread->window)->in_x->update(config.in_x);
 239                         ((TranslateWin*)thread->window)->in_y->update(config.in_y);
 240                         ((TranslateWin*)thread->window)->in_w->update(config.in_w);
 241                         ((TranslateWin*)thread->window)->in_h->update(config.in_h);
 242                         ((TranslateWin*)thread->window)->out_x->update(config.out_x);
 243                         ((TranslateWin*)thread->window)->out_y->update(config.out_y);
 244                         ((TranslateWin*)thread->window)->out_w->update(config.out_w);
 245                         ((TranslateWin*)thread->window)->out_h->update(config.out_h);
 246                         thread->window->unlock_window();
 247                 }
 248         }
 249 }