cinelerra-5.1/plugins/yuvshift/yuvshift.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 "yuvshift.h"
  23
  24
  25
  26 REGISTER_PLUGIN(YUVShiftEffect)
  27
  28
  29
  30
  31
  32
  33 YUVShiftConfig::YUVShiftConfig()
  34 {
  35         reset(RESET_ALL);
  36 }
  37
  38 void YUVShiftConfig::reset(int clear)
  39 {
  40         switch(clear) {
  41                 case RESET_Y_DX : y_dx = 0;
  42                         break;
  43                 case RESET_Y_DY : y_dy = 0;
  44                         break;
  45                 case RESET_U_DX : u_dx = 0;
  46                         break;
  47                 case RESET_U_DY : u_dy = 0;
  48                         break;
  49                 case RESET_V_DX : v_dx = 0;
  50                         break;
  51                 case RESET_V_DY : v_dy = 0;
  52                         break;
  53                 case RESET_ALL :
  54                 default:
  55                         y_dx = y_dy = 0;
  56                         u_dx = u_dy = 0;
  57                         v_dx = v_dy = 0;
  58                         break;
  59         }
  60 }
  61
  62 void YUVShiftConfig::copy_from(YUVShiftConfig &src)
  63 {
  64         y_dx = src.y_dx;  y_dy = src.y_dy;
  65         u_dx = src.u_dx;  u_dy = src.u_dy;
  66         v_dx = src.v_dx;  v_dy = src.v_dy;
  67 }
  68
  69 int YUVShiftConfig::equivalent(YUVShiftConfig &src)
  70 {
  71         return EQUIV(y_dx, src.y_dx) && EQUIV(u_dx, src.u_dx) && EQUIV(v_dx, src.v_dx) &&
  72                 EQUIV(y_dy, src.y_dy) && EQUIV(u_dy, src.u_dy) && EQUIV(v_dy, src.v_dy);
  73 }
  74
  75 void YUVShiftConfig::interpolate(YUVShiftConfig &prev,
  76         YUVShiftConfig &next,
  77         long prev_frame,
  78         long next_frame,
  79         long current_frame)
  80 {
  81         double next_scale = (double)(current_frame - prev_frame) / (next_frame - prev_frame);
  82         double prev_scale = (double)(next_frame - current_frame) / (next_frame - prev_frame);
  83
  84         y_dx = prev.y_dx * prev_scale + next.y_dx * next_scale;
  85         y_dy = prev.y_dy * prev_scale + next.y_dy * next_scale;
  86         u_dx = prev.u_dx * prev_scale + next.u_dx * next_scale;
  87         u_dy = prev.u_dy * prev_scale + next.u_dy * next_scale;
  88         v_dx = prev.v_dx * prev_scale + next.v_dx * next_scale;
  89         v_dy = prev.v_dy * prev_scale + next.v_dy * next_scale;
  90 }
  91
  92
  93
  94
  95
  96
  97 #define MAXVALUE 100
  98
  99 YUVShiftLevel::YUVShiftLevel(YUVShiftEffect *plugin, int *output, int x, int y)
 100  : BC_ISlider(x, y, 0, 200, 200, -MAXVALUE, MAXVALUE, *output)
 101 {
 102         this->plugin = plugin;
 103         this->output = output;
 104 }
 105
 106 int YUVShiftLevel::handle_event()
 107 {
 108         *output = get_value();
 109         plugin->send_configure_change();
 110         return 1;
 111 }
 112
 113
 114 YUVShiftReset::YUVShiftReset(YUVShiftEffect *plugin, YUVShiftWindow *window, int x, int y)
 115  : BC_GenericButton(x, y, _("Reset"))
 116 {
 117         this->plugin = plugin;
 118         this->window = window;
 119 }
 120 YUVShiftReset::~YUVShiftReset()
 121 {
 122 }
 123 int YUVShiftReset::handle_event()
 124 {
 125         plugin->config.reset(RESET_ALL);
 126         window->update_gui(RESET_ALL);
 127         plugin->send_configure_change();
 128         return 1;
 129 }
 130
 131
 132 YUVShiftSliderClr::YUVShiftSliderClr(YUVShiftEffect *plugin, YUVShiftWindow *window, int x, int y, int w, int clear)
 133  : BC_GenericButton(x, y, w, _("⌂"))
 134 {
 135         this->plugin = plugin;
 136         this->window = window;
 137         this->clear = clear;
 138 }
 139 YUVShiftSliderClr::~YUVShiftSliderClr()
 140 {
 141 }
 142 int YUVShiftSliderClr::handle_event()
 143 {
 144         // clear==1 ==> y_dx slider --- clear==2 ==> y_dy slider
 145         // clear==3 ==> u_dx slider --- clear==4 ==> u_dy slider
 146         // clear==5 ==> v_dx slider --- clear==6 ==> v_dy slider
 147         plugin->config.reset(clear);
 148         window->update_gui(clear);
 149         plugin->send_configure_change();
 150         return 1;
 151 }
 152
 153
 154 YUVShiftWindow::YUVShiftWindow(YUVShiftEffect *plugin)
 155  : PluginClientWindow(plugin, 320, 230, 320, 230, 0)
 156 {
 157         this->plugin = plugin;
 158 }
 159
 160 void YUVShiftWindow::create_objects()
 161 {
 162         int x = 10, y = 10, x1 = 50;
 163         int x2 = 0; int clrBtn_w = 50;
 164
 165         add_subwindow(new BC_Title(x, y, _("Y_dx:")));
 166         add_subwindow(y_dx = new YUVShiftLevel(plugin, &plugin->config.y_dx, x1, y));
 167         x2 = x1 + y_dx->get_w() + 10;
 168         add_subwindow(y_dxClr = new YUVShiftSliderClr(plugin, this, x2, y, clrBtn_w, RESET_Y_DX));
 169
 170         y += 30;
 171         add_subwindow(new BC_Title(x, y, _("Y_dy:")));
 172         add_subwindow(y_dy = new YUVShiftLevel(plugin, &plugin->config.y_dy, x1, y));
 173         add_subwindow(y_dyClr = new YUVShiftSliderClr(plugin, this, x2, y, clrBtn_w, RESET_Y_DY));
 174
 175         y += 30;
 176         add_subwindow(new BC_Title(x, y, _("U_dx:")));
 177         add_subwindow(u_dx = new YUVShiftLevel(plugin, &plugin->config.u_dx, x1, y));
 178         add_subwindow(u_dxClr = new YUVShiftSliderClr(plugin, this, x2, y, clrBtn_w, RESET_U_DX));
 179
 180         y += 30;
 181         add_subwindow(new BC_Title(x, y, _("U_dy:")));
 182         add_subwindow(u_dy = new YUVShiftLevel(plugin, &plugin->config.u_dy, x1, y));
 183         add_subwindow(u_dyClr = new YUVShiftSliderClr(plugin, this, x2, y, clrBtn_w, RESET_U_DY));
 184
 185         y += 30;
 186         add_subwindow(new BC_Title(x, y, _("V_dx:")));
 187         add_subwindow(v_dx = new YUVShiftLevel(plugin, &plugin->config.v_dx, x1, y));
 188         add_subwindow(v_dxClr = new YUVShiftSliderClr(plugin, this, x2, y, clrBtn_w, RESET_V_DX));
 189
 190         y += 30;
 191         add_subwindow(new BC_Title(x, y, _("V_dy:")));
 192         add_subwindow(v_dy = new YUVShiftLevel(plugin, &plugin->config.v_dy, x1, y));
 193         add_subwindow(v_dyClr = new YUVShiftSliderClr(plugin, this, x2, y, clrBtn_w, RESET_V_DY));
 194
 195         y += 40;
 196         add_subwindow(reset = new YUVShiftReset(plugin, this, x, y));
 197
 198         show_window();
 199         flush();
 200 }
 201
 202
 203 // for Reset button
 204 void YUVShiftWindow::update_gui(int clear)
 205 {
 206         switch(clear) {
 207                 case RESET_Y_DX : y_dx->update(plugin->config.y_dx);
 208                         break;
 209                 case RESET_Y_DY : y_dy->update(plugin->config.y_dy);
 210                         break;
 211                 case RESET_U_DX : u_dx->update(plugin->config.u_dx);
 212                         break;
 213                 case RESET_U_DY : u_dy->update(plugin->config.u_dy);
 214                         break;
 215                 case RESET_V_DX : v_dx->update(plugin->config.v_dx);
 216                         break;
 217                 case RESET_V_DY : v_dy->update(plugin->config.v_dy);
 218                         break;
 219                 case RESET_ALL :
 220                 default:
 221                         y_dx->update(plugin->config.y_dx);
 222                         y_dy->update(plugin->config.y_dy);
 223                         u_dx->update(plugin->config.u_dx);
 224                         u_dy->update(plugin->config.u_dy);
 225                         v_dx->update(plugin->config.v_dx);
 226                         v_dy->update(plugin->config.v_dy);
 227                         break;
 228         }
 229 }
 230
 231
 232
 233
 234
 235
 236 YUVShiftEffect::YUVShiftEffect(PluginServer *server)
 237  : PluginVClient(server)
 238 {
 239         temp_frame = 0;
 240 }
 241 YUVShiftEffect::~YUVShiftEffect()
 242 {
 243         delete temp_frame;
 244 }
 245
 246 const char* YUVShiftEffect::plugin_title() { return N_("YUVShift"); }
 247 int YUVShiftEffect::is_realtime() { return 1; }
 248
 249
 250 NEW_WINDOW_MACRO(YUVShiftEffect, YUVShiftWindow)
 251 LOAD_CONFIGURATION_MACRO(YUVShiftEffect, YUVShiftConfig)
 252
 253 void YUVShiftEffect::update_gui()
 254 {
 255         if(thread)
 256         {
 257                 YUVShiftWindow *yuv_wdw = (YUVShiftWindow*)thread->window;
 258                 yuv_wdw->lock_window("YUVShiftEffect::update_gui");
 259                 load_configuration();
 260                 yuv_wdw->y_dx->update(config.y_dx);
 261                 yuv_wdw->y_dy->update(config.y_dy);
 262                 yuv_wdw->u_dx->update(config.u_dx);
 263                 yuv_wdw->u_dy->update(config.u_dy);
 264                 yuv_wdw->v_dx->update(config.v_dx);
 265                 yuv_wdw->v_dy->update(config.v_dy);
 266                 yuv_wdw->unlock_window();
 267         }
 268 }
 269
 270 void YUVShiftEffect::save_data(KeyFrame *keyframe)
 271 {
 272         FileXML output;
 273         output.set_shared_output(keyframe->xbuf);
 274         output.tag.set_title("YUVSHIFT");
 275         output.tag.set_property("Y_DX", config.y_dx);
 276         output.tag.set_property("Y_DY", config.y_dy);
 277         output.tag.set_property("U_DX", config.u_dx);
 278         output.tag.set_property("U_DY", config.u_dy);
 279         output.tag.set_property("V_DX", config.v_dx);
 280         output.tag.set_property("V_DY", config.v_dy);
 281         output.append_tag();
 282         output.tag.set_title("/YUVSHIFT");
 283         output.append_tag();
 284         output.append_newline();
 285         output.terminate_string();
 286 }
 287
 288 void YUVShiftEffect::read_data(KeyFrame *keyframe)
 289 {
 290         FileXML input;
 291         input.set_shared_input(keyframe->xbuf);
 292         while(!input.read_tag())
 293         {
 294                 if(input.tag.title_is("YUVSHIFT"))
 295                 {
 296                         config.y_dx = input.tag.get_property("Y_DX", config.y_dx);
 297                         config.y_dy = input.tag.get_property("Y_DY", config.y_dy);
 298                         config.u_dx = input.tag.get_property("U_DX", config.u_dx);
 299                         config.u_dy = input.tag.get_property("U_DY", config.u_dy);
 300                         config.v_dx = input.tag.get_property("V_DX", config.v_dx);
 301                         config.v_dy = input.tag.get_property("V_DY", config.v_dy);
 302                 }
 303         }
 304 }
 305
 306
 307 #define YUV_MACRO(type, temp_type, components) \
 308 { \
 309         for(int i = 0; i < h; i++) { \
 310                 int yi = i + config.y_dy, ui = i + config.u_dy, vi = i + config.v_dy; \
 311                 type *in_y = yi >= 0 && yi < h ? (type *)frame->get_rows()[yi] : 0; \
 312                 type *in_u = ui >= 0 && ui < h ? (type *)frame->get_rows()[ui] : 0; \
 313                 type *in_v = vi >= 0 && vi < h ? (type *)frame->get_rows()[vi] : 0; \
 314                 type *out_row = (type *)output->get_rows()[i]; \
 315                 for(int j = 0; j < w; j++) { \
 316                         int yj = j + config.y_dx, uj = j + config.u_dx, vj = j + config.v_dx; \
 317                         type *yp = in_y && yj >= 0 && yj < w ? in_y + yj*components: 0; \
 318                         type *up = in_u && uj >= 0 && uj < w ? in_u + uj*components: 0; \
 319                         type *vp = in_v && vj >= 0 && vj < w ? in_v + vj*components: 0; \
 320                         out_row[0] = yp ? yp[0] : 0; \
 321                         out_row[1] = up ? up[1] : (1<<(8*sizeof(type)-1)); \
 322                         out_row[2] = vp ? vp[2] : (1<<(8*sizeof(type)-1)); \
 323                         out_row += components; \
 324                 } \
 325         } \
 326 }
 327
 328 #define RGB_MACRO(type, temp_type, components) \
 329 { \
 330         for(int i = 0; i < h; i++) { \
 331                 int yi = i + config.y_dy, ui = i + config.u_dy, vi = i + config.v_dy; \
 332                 uint8_t *in_y = yi >= 0 && yi < h ? (uint8_t *)frame->get_rows()[yi] : 0; \
 333                 uint8_t *in_u = ui >= 0 && ui < h ? (uint8_t *)frame->get_rows()[ui] : 0; \
 334                 uint8_t *in_v = vi >= 0 && vi < h ? (uint8_t *)frame->get_rows()[vi] : 0; \
 335                 type *out_row = (type *)output->get_rows()[i]; \
 336                 for(int j = 0; j < w; j++) { \
 337                         int yj = j + config.y_dx, uj = j + config.u_dx, vj = j + config.v_dx; \
 338                         uint8_t *yp = in_y && yj >= 0 && yj < w ? in_y + yj*3: 0; \
 339                         uint8_t *up = in_u && uj >= 0 && uj < w ? in_u + uj*3: 0; \
 340                         uint8_t *vp = in_v && vj >= 0 && vj < w ? in_v + vj*3: 0; \
 341                         temp_type r, g, b; \
 342                         temp_type y = yp ? yp[0] : 0x00; \
 343                         temp_type u = up ? up[1] : 0x80; \
 344                         temp_type v = vp ? vp[2] : 0x80; \
 345                         if( sizeof(type) == 4 ) \
 346                                 YUV::yuv.yuv_to_rgb_f(r, g, b, y/255., (u-128.)/255., (v-128.)/255.); \
 347                         else if( sizeof(type) == 2 ) \
 348                                 YUV::yuv.yuv_to_rgb_16(r, g, b, y, u, v); \
 349                         else \
 350                                 YUV::yuv.yuv_to_rgb_8(r, g, b, y, u, v); \
 351                         out_row[0] = r; \
 352                         out_row[1] = g; \
 353                         out_row[2] = b; \
 354                         out_row += components; \
 355                 } \
 356         } \
 357 }
 358
 359 int YUVShiftEffect::process_realtime(VFrame *input, VFrame *output)
 360 {
 361         load_configuration();
 362
 363         if( EQUIV(config.y_dx, 0) && EQUIV(config.u_dx, 0) && EQUIV(config.v_dx, 0) &&
 364                 EQUIV(config.y_dy, 0) && EQUIV(config.u_dy, 0) && EQUIV(config.v_dy, 0) ) {
 365                 if(input->get_rows()[0] != output->get_rows()[0])
 366                         output->copy_from(input);
 367                 return 0;
 368         }
 369
 370         int w = input->get_w(), h = input->get_h();
 371         int color_model = input->get_color_model();
 372         int is_yuv = BC_CModels::is_yuv(color_model);
 373         if( !is_yuv ) color_model = BC_YUV888;
 374         VFrame *frame = input;
 375         if( input->get_rows()[0] == output->get_rows()[0] || !is_yuv ) {
 376                 if( temp_frame && ( temp_frame->get_color_model() != color_model ||
 377                         temp_frame->get_w() != w || temp_frame->get_h() != h ) ) {
 378                         delete temp_frame;  temp_frame = 0;
 379                 }
 380                 if( !temp_frame )
 381                         temp_frame = new VFrame(w, h, color_model, 0);
 382                 frame = temp_frame;
 383                 if( color_model != input->get_color_model() )
 384                         BC_CModels::transfer(frame->get_rows(), input->get_rows(),
 385                                 frame->get_y(), frame->get_u(), frame->get_v(),
 386                                 input->get_y(), input->get_u(), input->get_v(),
 387                                 0, 0, input->get_w(), input->get_h(),
 388                                 0, 0, frame->get_w(), frame->get_h(),
 389                                 input->get_color_model(), frame->get_color_model(), 0,
 390                                 input->get_bytes_per_line(), w);
 391                 else
 392                         frame->copy_from(input);
 393         }
 394
 395         switch( input->get_color_model() ) {
 396         case BC_YUV888:       YUV_MACRO(unsigned char, int, 3);  break;
 397         case BC_YUV161616:    YUV_MACRO(uint16_t, int, 3);       break;
 398         case BC_YUVA8888:     YUV_MACRO(unsigned char, int, 4);  break;
 399         case BC_YUVA16161616: YUV_MACRO(uint16_t, int, 4);       break;
 400         case BC_RGB_FLOAT:    RGB_MACRO(float, float, 3);        break;
 401         case BC_RGB888:       RGB_MACRO(unsigned char, int, 3);  break;
 402         case BC_RGB161616:    RGB_MACRO(uint16_t, int, 3);       break;
 403         case BC_RGBA_FLOAT:   RGB_MACRO(float, float, 4);        break;
 404         case BC_RGBA8888:     RGB_MACRO(unsigned char, int, 4);  break;
 405         case BC_RGBA16161616: RGB_MACRO(uint16_t, int, 4);       break;
 406         }
 407
 408         return 0;
 409 }
 410
 411