cinelerra-5.0/plugins/interpolate/interpolate.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 "bcdisplayinfo.h"
  23 #include "clip.h"
  24 #include "colormodels.h"
  25 #include "filexml.h"
  26 #include "aggregated.h"
  27 #include "language.h"
  28 #include "interpolate.h"
  29
  30 #include <stdio.h>
  31 #include <string.h>
  32
  33
  34 REGISTER_PLUGIN(InterpolatePixelsMain)
  35
  36
  37
  38
  39
  40
  41 InterpolatePixelsOffset::InterpolatePixelsOffset(InterpolatePixelsWindow *window,
  42         int x,
  43         int y,
  44         int *output)
  45  : BC_ISlider(x,
  46         y,
  47         0,
  48         50,
  49         50,
  50         0,
  51         1,
  52         *output,
  53         0)
  54 {
  55         this->window = window;
  56         this->output = output;
  57 }
  58
  59 InterpolatePixelsOffset::~InterpolatePixelsOffset()
  60 {
  61 }
  62
  63 int InterpolatePixelsOffset::handle_event()
  64 {
  65         *output = get_value();
  66         window->client->send_configure_change();
  67         return 1;
  68 }
  69
  70
  71
  72
  73
  74
  75 InterpolatePixelsWindow::InterpolatePixelsWindow(InterpolatePixelsMain *client)
  76  : PluginClientWindow(client,
  77         200,
  78         100,
  79         200,
  80         100,
  81         0)
  82 {
  83         this->client = client;
  84 }
  85
  86 InterpolatePixelsWindow::~InterpolatePixelsWindow()
  87 {
  88 }
  89
  90 void InterpolatePixelsWindow::create_objects()
  91 {
  92         int x = 10, y = 10;
  93
  94         BC_Title *title;
  95         add_tool(title = new BC_Title(x, y, _("X Offset:")));
  96         add_tool(x_offset = new InterpolatePixelsOffset(this,
  97                 x + title->get_w() + 5,
  98                 y,
  99                 &client->config.x));
 100         y += MAX(x_offset->get_h(), title->get_h()) + 5;
 101         add_tool(title = new BC_Title(x, y, _("Y Offset:")));
 102         add_tool(y_offset = new InterpolatePixelsOffset(this,
 103                 x + title->get_w() + 5,
 104                 y,
 105                 &client->config.y));
 106         y += MAX(y_offset->get_h(), title->get_h()) + 5;
 107
 108         show_window();
 109 }
 110
 111
 112
 113
 114
 115
 116
 117
 118
 119
 120
 121
 122
 123
 124
 125 InterpolatePixelsConfig::InterpolatePixelsConfig()
 126 {
 127         x = 0;
 128         y = 0;
 129 }
 130
 131 int InterpolatePixelsConfig::equivalent(InterpolatePixelsConfig &that)
 132 {
 133         return x == that.x && y == that.y;
 134 }
 135
 136 void InterpolatePixelsConfig::copy_from(InterpolatePixelsConfig &that)
 137 {
 138         x = that.x;
 139         y = that.y;
 140 }
 141
 142 void InterpolatePixelsConfig::interpolate(InterpolatePixelsConfig &prev,
 143     InterpolatePixelsConfig &next,
 144     int64_t prev_position,
 145     int64_t next_position,
 146     int64_t current_position)
 147 {
 148     this->x = prev.x;
 149     this->y = prev.y;
 150 }
 151
 152
 153
 154
 155
 156
 157 InterpolatePixelsMain::InterpolatePixelsMain(PluginServer *server)
 158  : PluginVClient(server)
 159 {
 160         out_temp = out_frame = 0;
 161         engine = 0;
 162 }
 163
 164 InterpolatePixelsMain::~InterpolatePixelsMain()
 165 {
 166         delete out_temp;
 167         delete engine;
 168 }
 169
 170 const char* InterpolatePixelsMain::plugin_title() { return _("Interpolate Pixels"); }
 171 int InterpolatePixelsMain::is_realtime() { return 1; }
 172
 173
 174 NEW_WINDOW_MACRO(InterpolatePixelsMain, InterpolatePixelsWindow)
 175
 176
 177 void InterpolatePixelsMain::update_gui()
 178 {
 179         if(thread)
 180         {
 181                 int changed = load_configuration();
 182                 if(changed)
 183                 {
 184                         thread->window->lock_window("InterpolatePixelsMain::update_gui");
 185                         ((InterpolatePixelsWindow*)thread->window)->x_offset->update(config.x);
 186                         ((InterpolatePixelsWindow*)thread->window)->y_offset->update(config.y);
 187                         thread->window->unlock_window();
 188                 }
 189         }
 190 }
 191
 192
 193 LOAD_CONFIGURATION_MACRO(InterpolatePixelsMain, InterpolatePixelsConfig)
 194
 195
 196 void InterpolatePixelsMain::save_data(KeyFrame *keyframe)
 197 {
 198         FileXML output;
 199
 200 // cause data to be stored directly in text
 201         output.set_shared_output(keyframe->get_data(), MESSAGESIZE);
 202         output.tag.set_title("INTERPOLATEPIXELS");
 203         output.tag.set_property("X", config.x);
 204         output.tag.set_property("Y", config.y);
 205         output.append_tag();
 206         output.terminate_string();
 207 }
 208
 209 void InterpolatePixelsMain::read_data(KeyFrame *keyframe)
 210 {
 211         FileXML input;
 212
 213         input.set_shared_input(keyframe->get_data(), strlen(keyframe->get_data()));
 214
 215         int result = 0;
 216
 217         while(!result)
 218         {
 219                 result = input.read_tag();
 220
 221                 if(!result)
 222                 {
 223                         if(input.tag.title_is("INTERPOLATEPIXELS"))
 224                         {
 225                                 config.x = input.tag.get_property("X", config.x);
 226                                 config.y = input.tag.get_property("Y", config.y);
 227                         }
 228                 }
 229         }
 230 }
 231
 232 int InterpolatePixelsMain::process_buffer(VFrame *frame,
 233         int64_t start_position,
 234         double frame_rate)
 235 {
 236         load_configuration();
 237
 238 // Set aggregation parameters
 239         frame->get_params()->update("INTERPOLATEPIXELS_X", config.x);
 240         frame->get_params()->update("INTERPOLATEPIXELS_Y", config.y);
 241
 242         read_frame(frame,
 243                 0,
 244                 start_position,
 245                 frame_rate,
 246                 get_use_opengl());
 247 //frame->dump_params();
 248
 249         if(get_use_opengl())
 250         {
 251 // Aggregate with gamma
 252                 if(next_effect_is(_("Gamma")) ||
 253                         next_effect_is(_("Histogram")) ||
 254                         next_effect_is(_("Color Balance")))
 255                         return 0;
 256
 257
 258                 return run_opengl();
 259         }
 260
 261         int color_model = frame->get_color_model();
 262         int active_model = BC_CModels::has_alpha(color_model) ?
 263                 BC_RGBA_FLOAT : BC_RGB_FLOAT;
 264         new_temp(frame->get_w(), frame->get_h(), active_model);
 265         get_temp()->transfer_from(frame);
 266
 267         out_frame = get_output();
 268         color_model = out_frame->get_color_model();
 269         active_model = BC_CModels::has_alpha(color_model) ?
 270                 BC_RGBA_FLOAT : BC_RGB_FLOAT;
 271         if( active_model != color_model ) {
 272                 int w = out_frame->get_w(), h = out_frame->get_h();
 273                 if( out_temp && ( out_temp->get_color_model() != active_model ||
 274                              out_temp->get_w() != w || out_temp->get_w() != h ) ) {
 275                         delete out_temp;  out_temp = 0;
 276                 }
 277                 if( !out_temp )
 278                         out_temp = new VFrame(0, -1, w, h, active_model, -1);
 279                 out_frame = out_temp;
 280         }
 281
 282         if(!engine)
 283                 engine = new InterpolatePixelsEngine(this);
 284         engine->process_packages();
 285
 286         if( out_frame != get_output() ) {
 287                 if( BC_CModels::has_alpha(out_frame->get_color_model()) ) {
 288                         unsigned char **out_rows = out_frame->get_rows();
 289                         int w = out_frame->get_w(), h = out_frame->get_h();
 290                         if( BC_CModels::has_alpha(get_temp()->get_color_model()) ) {
 291                                 unsigned char **in_rows = get_temp()->get_rows();
 292                                 for( int y=0; y<h; ++y ) {
 293                                         float *inp = (float *)in_rows[y];
 294                                         float *outp = (float *)out_rows[y];
 295                                         for( int x=0; x<w; ++x,inp+=4,outp+=4 ) outp[3] = inp[3];
 296                                 }
 297                         }
 298                         else {
 299                                 for( int y=0; y<h; ++y ) {
 300                                         float *outp = (float *)out_rows[y];
 301                                         for( int x=0; x<w; ++x,outp+=4 ) outp[3] = 1;
 302                                 }
 303                         }
 304                 }
 305                 get_output()->transfer_from(out_frame);
 306         }
 307
 308         return 0;
 309 }
 310
 311 // The pattern is
 312 //   G B
 313 //   R G
 314 // And is offset to recreate the 4 possibilities.
 315 // The color values are interpolated in the most basic way.
 316 // No adaptive algorithm is used.
 317
 318 int InterpolatePixelsMain::handle_opengl()
 319 {
 320 //printf("InterpolatePixelsMain::handle_opengl\n");
 321 #ifdef HAVE_GL
 322
 323
 324         get_output()->to_texture();
 325         get_output()->enable_opengl();
 326
 327         const char *shader_stack[] = { 0, 0, 0 };
 328         int current_shader = 0;
 329         INTERPOLATE_COMPILE(shader_stack, current_shader)
 330         unsigned int frag = VFrame::make_shader(0,
 331                                         shader_stack[0],
 332                                         0);
 333         if(frag > 0)
 334         {
 335                 glUseProgram(frag);
 336                 glUniform1i(glGetUniformLocation(frag, "tex"), 0);
 337                 INTERPOLATE_UNIFORMS(frag)
 338         }
 339
 340
 341         get_output()->init_screen();
 342         get_output()->bind_texture(0);
 343         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
 344         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
 345
 346
 347         get_output()->draw_texture();
 348         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 349         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
 350         glUseProgram(0);
 351         get_output()->set_opengl_state(VFrame::SCREEN);
 352
 353 #endif
 354         return 0;
 355 }
 356
 357
 358
 359
 360
 361
 362
 363
 364
 365
 366
 367
 368
 369 InterpolatePixelsPackage::InterpolatePixelsPackage()
 370  : LoadPackage()
 371 {
 372
 373 }
 374
 375
 376
 377
 378
 379
 380 InterpolatePixelsUnit::InterpolatePixelsUnit(InterpolatePixelsEngine *server, InterpolatePixelsMain *plugin)
 381  : LoadClient(server)
 382 {
 383         this->plugin = plugin;
 384         this->server = server;
 385 }
 386
 387 void InterpolatePixelsUnit::process_package(LoadPackage *package)
 388 {
 389         InterpolatePixelsPackage *pkg = (InterpolatePixelsPackage*)package;
 390         int h = plugin->get_temp()->get_h();
 391         int w = plugin->get_temp()->get_w();
 392         int pattern_offset_x = plugin->config.x;
 393         int pattern_offset_y = plugin->config.y;
 394         int y1 = pkg->y1;
 395         int y2 = pkg->y2;
 396         int components = cmodel_components(plugin->out_frame->get_color_model());
 397         float color_matrix[9];
 398         memcpy(color_matrix, server->color_matrix, sizeof(color_matrix));
 399
 400         y1 = MAX(y1, 1);
 401         y2 = MIN(y2, h - 1);
 402
 403 // Only supports float because it's useless in any other colormodel.
 404         for(int i = y1; i < y2; i++)
 405         {
 406                 int pattern_coord_y = (i - pattern_offset_y) % 2;
 407                 float *prev_row = (float*)plugin->get_temp()->get_rows()[i - 1];
 408                 float *current_row = (float*)plugin->get_temp()->get_rows()[i];
 409                 float *next_row = (float*)plugin->get_temp()->get_rows()[i + 1];
 410                 float *out_row = (float*)plugin->out_frame->get_rows()[i];
 411
 412                 prev_row += components;
 413                 current_row += components;
 414                 next_row += components;
 415                 out_row += components;
 416                 float r;
 417                 float g;
 418                 float b;
 419 #undef RED
 420 #define RED 0
 421 #undef GREEN
 422 #define GREEN 1
 423 #undef BLUE
 424 #define BLUE 2
 425                 if(pattern_coord_y == 0)
 426                 {
 427                         for(int j = 1; j < w - 1; j++)
 428                         {
 429                                 int pattern_coord_x = (j - pattern_offset_x) % 2;
 430 // Top left pixel
 431                                 if(pattern_coord_x == 0)
 432                                 {
 433                                         r = (prev_row[RED] + next_row[RED]) / 2;
 434                                         g = current_row[GREEN];
 435                                         b = (current_row[-components + BLUE] + current_row[components + BLUE]) / 2;
 436                                 }
 437                                 else
 438 // Top right pixel
 439                                 {
 440                                         r = (prev_row[-components + RED] +
 441                                                 prev_row[components + RED] +
 442                                                 next_row[-components + RED] +
 443                                                 next_row[components + RED]) / 4;
 444                                         g = (current_row[-components + GREEN] +
 445                                                 prev_row[GREEN] +
 446                                                 current_row[components + GREEN] +
 447                                                 next_row[GREEN]) / 4;
 448                                         b = current_row[BLUE];
 449                                 }
 450
 451                                 out_row[0] = r * color_matrix[0] + g * color_matrix[1] + b * color_matrix[2];
 452                                 out_row[1] = r * color_matrix[3] + g * color_matrix[4] + b * color_matrix[5];
 453                                 out_row[2] = r * color_matrix[6] + g * color_matrix[7] + b * color_matrix[8];
 454                                 prev_row += components;
 455                                 current_row += components;
 456                                 next_row += components;
 457                                 out_row += components;
 458                         }
 459                 }
 460                 else
 461                 {
 462                         for(int j = 1; j < w - 1; j++)
 463                         {
 464                                 int pattern_coord_x = (j - pattern_offset_x) % 2;
 465 // Bottom left pixel
 466                                 if(pattern_coord_x == 0)
 467                                 {
 468                                         r = current_row[RED];
 469                                         g = (current_row[-components + GREEN] +
 470                                                 prev_row[GREEN] +
 471                                                 current_row[components + GREEN] +
 472                                                 next_row[GREEN]) / 4;
 473                                         b = (prev_row[-components + BLUE] +
 474                                                 prev_row[components + BLUE] +
 475                                                 next_row[-components + BLUE] +
 476                                                 next_row[components + BLUE]) / 4;
 477                                 }
 478                                 else
 479 // Bottom right pixel
 480                                 {
 481                                         r = (current_row[-components + RED] + current_row[components + RED]) / 2;
 482                                         g = current_row[GREEN];
 483                                         b = (prev_row[BLUE] + next_row[BLUE]) / 2;
 484                                 }
 485
 486                                 out_row[0] = r * color_matrix[0] + g * color_matrix[1] + b * color_matrix[2];
 487                                 out_row[1] = r * color_matrix[3] + g * color_matrix[4] + b * color_matrix[5];
 488                                 out_row[2] = r * color_matrix[6] + g * color_matrix[7] + b * color_matrix[8];
 489                                 prev_row += components;
 490                                 current_row += components;
 491                                 next_row += components;
 492                                 out_row += components;
 493                         }
 494                 }
 495         }
 496 }
 497
 498
 499
 500
 501 InterpolatePixelsEngine::InterpolatePixelsEngine(InterpolatePixelsMain *plugin)
 502  : LoadServer(plugin->get_project_smp() + 1, plugin->get_project_smp() + 1)
 503 {
 504         this->plugin = plugin;
 505 }
 506
 507 void InterpolatePixelsEngine::init_packages()
 508 {
 509         for( int i=0; i<9; ++i ) color_matrix[i] = 0;
 510         for( int i=0; i<3; ++i ) color_matrix[i*3 + i] = 1;
 511         char string[BCTEXTLEN];
 512         string[0] = 0;
 513         plugin->get_output()->get_params()->get("DCRAW_MATRIX", string);
 514         sscanf(string,
 515                 "%f %f %f %f %f %f %f %f %f",
 516                 &color_matrix[0],
 517                 &color_matrix[1],
 518                 &color_matrix[2],
 519                 &color_matrix[3],
 520                 &color_matrix[4],
 521                 &color_matrix[5],
 522                 &color_matrix[6],
 523                 &color_matrix[7],
 524                 &color_matrix[8]);
 525         for(int i = 0; i < get_total_packages(); i++)
 526         {
 527                 InterpolatePixelsPackage *package = (InterpolatePixelsPackage*)get_package(i);
 528                 package->y1 = plugin->get_temp()->get_h() * i / get_total_packages();
 529                 package->y2 = plugin->get_temp()->get_h() * (i + 1) / get_total_packages();
 530         }
 531 }
 532
 533
 534 LoadClient* InterpolatePixelsEngine::new_client()
 535 {
 536         return new InterpolatePixelsUnit(this, plugin);
 537 }
 538
 539
 540 LoadPackage* InterpolatePixelsEngine::new_package()
 541 {
 542         return new InterpolatePixelsPackage;
 543 }
 544
 545