plugins/interpolatevideo/interpolatevideo.C

   1 #include "bcdisplayinfo.h"
   2 #include "clip.h"
   3 #include "defaults.h"
   4 #include "filexml.h"
   5 #include "guicast.h"
   6 #include "keyframe.h"
   7 #include "language.h"
   8 #include "picon_png.h"
   9 #include "pluginvclient.h"
  10 #include "theme.h"
  11 #include "transportque.inc"
  12 #include "vframe.h"
  13
  14 #include <string.h>
  15 #include <stdint.h>
  16
  17
  18
  19 class InterpolateVideo;
  20 class InterpolateVideoWindow;
  21
  22
  23 class InterpolateVideoConfig
  24 {
  25 public:
  26         InterpolateVideoConfig();
  27
  28         void copy_from(InterpolateVideoConfig *config);
  29         int equivalent(InterpolateVideoConfig *config);
  30
  31 // Frame rate of input
  32         double input_rate;
  33 // If 1, use the keyframes as beginning and end frames and ignore input rate
  34         int use_keyframes;
  35 };
  36
  37
  38
  39
  40 class InterpolateVideoRate : public BC_TextBox
  41 {
  42 public:
  43         InterpolateVideoRate(InterpolateVideo *plugin,
  44                 InterpolateVideoWindow *gui,
  45                 int x,
  46                 int y);
  47         int handle_event();
  48         InterpolateVideo *plugin;
  49         InterpolateVideoWindow *gui;
  50 };
  51
  52 class InterpolateVideoRateMenu : public BC_ListBox
  53 {
  54 public:
  55         InterpolateVideoRateMenu(InterpolateVideo *plugin,
  56                 InterpolateVideoWindow *gui,
  57                 int x,
  58                 int y);
  59         int handle_event();
  60         InterpolateVideo *plugin;
  61         InterpolateVideoWindow *gui;
  62 };
  63
  64 class InterpolateVideoKeyframes : public BC_CheckBox
  65 {
  66 public:
  67         InterpolateVideoKeyframes(InterpolateVideo *plugin,
  68                 int x,
  69                 int y);
  70         int handle_event();
  71         InterpolateVideo *plugin;
  72 };
  73
  74 class InterpolateVideoWindow : public BC_Window
  75 {
  76 public:
  77         InterpolateVideoWindow(InterpolateVideo *plugin, int x, int y);
  78         ~InterpolateVideoWindow();
  79
  80         void create_objects();
  81         int close_event();
  82
  83         ArrayList<BC_ListBoxItem*> frame_rates;
  84         InterpolateVideo *plugin;
  85
  86         InterpolateVideoRate *rate;
  87         InterpolateVideoRateMenu *rate_menu;
  88         InterpolateVideoKeyframes *keyframes;
  89 };
  90
  91
  92 PLUGIN_THREAD_HEADER(InterpolateVideo, InterpolateVideoThread, InterpolateVideoWindow)
  93
  94
  95
  96 class InterpolateVideo : public PluginVClient
  97 {
  98 public:
  99         InterpolateVideo(PluginServer *server);
 100         ~InterpolateVideo();
 101
 102         PLUGIN_CLASS_MEMBERS(InterpolateVideoConfig, InterpolateVideoThread)
 103
 104         int process_buffer(VFrame *frame,
 105                 int64_t start_position,
 106                 double frame_rate);
 107         int is_realtime();
 108         int load_defaults();
 109         int save_defaults();
 110         void save_data(KeyFrame *keyframe);
 111         void read_data(KeyFrame *keyframe);
 112         void update_gui();
 113
 114         void fill_border(double frame_rate, int64_t start_position);
 115
 116 // beginning and end frames
 117         VFrame *frames[2];
 118 // Last requested positions
 119         int64_t frame_number[2];
 120 // Last output position
 121         int64_t last_position;
 122         double last_rate;
 123
 124 // Current requested positions
 125         int64_t range_start;
 126         int64_t range_end;
 127
 128 };
 129
 130
 131
 132
 133
 134
 135
 136
 137
 138
 139
 140
 141 InterpolateVideoConfig::InterpolateVideoConfig()
 142 {
 143         input_rate = (double)30000 / 1001;
 144         use_keyframes = 0;
 145 }
 146
 147 void InterpolateVideoConfig::copy_from(InterpolateVideoConfig *config)
 148 {
 149         this->input_rate = config->input_rate;
 150         this->use_keyframes = config->use_keyframes;
 151 }
 152
 153 int InterpolateVideoConfig::equivalent(InterpolateVideoConfig *config)
 154 {
 155         return EQUIV(this->input_rate, config->input_rate) &&
 156                 (this->use_keyframes == config->use_keyframes);
 157 }
 158
 159
 160
 161
 162
 163
 164
 165
 166
 167 InterpolateVideoWindow::InterpolateVideoWindow(InterpolateVideo *plugin, int x, int y)
 168  : BC_Window(plugin->gui_string,
 169         x,
 170         y,
 171         210,
 172         160,
 173         200,
 174         160,
 175         0,
 176         0,
 177         1)
 178 {
 179         this->plugin = plugin;
 180 }
 181
 182 InterpolateVideoWindow::~InterpolateVideoWindow()
 183 {
 184 }
 185
 186 void InterpolateVideoWindow::create_objects()
 187 {
 188         int x = 10, y = 10;
 189
 190         BC_Title *title;
 191         add_subwindow(title = new BC_Title(x, y, "Input frames per second:"));
 192         y += 30;
 193         add_subwindow(rate = new InterpolateVideoRate(plugin,
 194                 this,
 195                 x,
 196                 y));
 197         add_subwindow(rate_menu = new InterpolateVideoRateMenu(plugin,
 198                 this,
 199                 x + rate->get_w() + 5,
 200                 y));
 201         y += 30;
 202         add_subwindow(keyframes = new InterpolateVideoKeyframes(plugin,
 203                 x,
 204                 y));
 205
 206         show_window();
 207         flush();
 208 }
 209
 210 WINDOW_CLOSE_EVENT(InterpolateVideoWindow)
 211
 212
 213
 214
 215
 216
 217
 218
 219
 220
 221
 222
 223 InterpolateVideoRate::InterpolateVideoRate(InterpolateVideo *plugin,
 224         InterpolateVideoWindow *gui,
 225         int x,
 226         int y)
 227  : BC_TextBox(x,
 228         y,
 229         90,
 230         1,
 231         (float)plugin->config.input_rate)
 232 {
 233         this->plugin = plugin;
 234         this->gui = gui;
 235 }
 236
 237 int InterpolateVideoRate::handle_event()
 238 {
 239         plugin->config.input_rate = Units::atoframerate(get_text());
 240         plugin->send_configure_change();
 241         return 1;
 242 }
 243
 244
 245
 246
 247 InterpolateVideoRateMenu::InterpolateVideoRateMenu(InterpolateVideo *plugin,
 248         InterpolateVideoWindow *gui,
 249         int x,
 250         int y)
 251  : BC_ListBox(x,
 252         y,
 253         100,
 254         200,
 255         LISTBOX_TEXT,
 256         &plugin->get_theme()->frame_rates,
 257         0,
 258         0,
 259         1,
 260         0,
 261         1)
 262 {
 263         this->plugin = plugin;
 264         this->gui = gui;
 265 }
 266
 267 int InterpolateVideoRateMenu::handle_event()
 268 {
 269         char *text = get_selection(0, 0)->get_text();
 270         plugin->config.input_rate = atof(text);
 271         gui->rate->update(text);
 272         plugin->send_configure_change();
 273         return 1;
 274 }
 275
 276
 277
 278
 279 InterpolateVideoKeyframes::InterpolateVideoKeyframes(InterpolateVideo *plugin,
 280         int x,
 281         int y)
 282  : BC_CheckBox(x,
 283         y,
 284         plugin->config.use_keyframes,
 285         "Use keyframes as input")
 286 {
 287         this->plugin = plugin;
 288 }
 289 int InterpolateVideoKeyframes::handle_event()
 290 {
 291         plugin->config.use_keyframes = get_value();
 292         plugin->send_configure_change();
 293         return 1;
 294 }
 295
 296
 297
 298
 299
 300
 301
 302
 303
 304 PLUGIN_THREAD_OBJECT(InterpolateVideo, InterpolateVideoThread, InterpolateVideoWindow)
 305
 306
 307
 308
 309
 310
 311
 312
 313
 314
 315 REGISTER_PLUGIN(InterpolateVideo)
 316
 317
 318
 319
 320
 321
 322 InterpolateVideo::InterpolateVideo(PluginServer *server)
 323  : PluginVClient(server)
 324 {
 325         PLUGIN_CONSTRUCTOR_MACRO
 326         bzero(frames, sizeof(VFrame*) * 2);
 327         for(int i = 0; i < 2; i++)
 328                 frame_number[i] = -1;
 329         last_position = -1;
 330         last_rate = -1;
 331 }
 332
 333
 334 InterpolateVideo::~InterpolateVideo()
 335 {
 336         PLUGIN_DESTRUCTOR_MACRO
 337         if(frames[0]) delete frames[0];
 338         if(frames[1]) delete frames[1];
 339 }
 340
 341
 342 void InterpolateVideo::fill_border(double frame_rate, int64_t start_position)
 343 {
 344 // A border frame changed or the start position is identical to the last
 345 // start position.
 346         if(range_start != frame_number[0] ||
 347                 last_position != start_position ||
 348                 !EQUIV(last_rate, frame_rate))
 349         {
 350                 read_frame(frames[0],
 351                         0,
 352                         range_start + (get_direction() == PLAY_REVERSE ? 1 : 0),
 353                         config.input_rate);
 354         }
 355
 356         if(range_end != frame_number[1] ||
 357                 last_position != start_position ||
 358                 !EQUIV(last_rate, frame_rate))
 359         {
 360                 read_frame(frames[1],
 361                         0,
 362                         range_end + (get_direction() == PLAY_REVERSE ? 1 : 0),
 363                         config.input_rate);
 364         }
 365
 366         last_position = start_position;
 367         last_rate = frame_rate;
 368         frame_number[0] = range_start;
 369         frame_number[1] = range_end;
 370 }
 371
 372
 373 #define AVERAGE(type, temp_type,components, max) \
 374 { \
 375         temp_type fraction0 = (temp_type)(lowest_fraction * max); \
 376         temp_type fraction1 = (temp_type)(max - fraction0); \
 377  \
 378         for(int i = 0; i < h; i++) \
 379         { \
 380                 type *in_row0 = (type*)frames[0]->get_rows()[i]; \
 381                 type *in_row1 = (type*)frames[1]->get_rows()[i]; \
 382                 type *out_row = (type*)frame->get_rows()[i]; \
 383                 for(int j = 0; j < w * components; j++) \
 384                 { \
 385                         *out_row++ = (*in_row0++ * fraction0 + *in_row1++ * fraction1) / max; \
 386                 } \
 387         } \
 388 }
 389
 390
 391
 392
 393
 394 int InterpolateVideo::process_buffer(VFrame *frame,
 395         int64_t start_position,
 396         double frame_rate)
 397 {
 398         if(get_direction() == PLAY_REVERSE) start_position--;
 399         load_configuration();
 400
 401         if(!frames[0])
 402         {
 403                 for(int i = 0; i < 2; i++)
 404                 {
 405                         frames[i] = new VFrame(0,
 406                                 frame->get_w(),
 407                                 frame->get_h(),
 408                                 frame->get_color_model(),
 409                                 -1);
 410                 }
 411         }
 412
 413
 414         if(range_start == range_end)
 415         {
 416                 read_frame(frame,
 417                         0,
 418                         range_start,
 419                         config.input_rate);
 420                 return 0;
 421         }
 422         else
 423         {
 424
 425 // Fill border frames
 426                 fill_border(frame_rate, start_position);
 427
 428 // Fraction of lowest frame in output
 429                 int64_t requested_range_start = (int64_t)((double)range_start *
 430                         frame_rate /
 431                         config.input_rate);
 432                 int64_t requested_range_end = (int64_t)((double)range_end *
 433                         frame_rate /
 434                         config.input_rate);
 435                 float highest_fraction = (float)(start_position - requested_range_start) /
 436                         (requested_range_end - requested_range_start);
 437
 438 // Fraction of highest frame in output
 439                 float lowest_fraction = 1.0 - highest_fraction;
 440                 CLAMP(highest_fraction, 0, 1);
 441                 CLAMP(lowest_fraction, 0, 1);
 442
 443 // printf("InterpolateVideo::process_buffer %lld %lld %lld %f %f %lld %lld %f %f\n",
 444 // range_start,
 445 // range_end,
 446 // requested_range_start,
 447 // requested_range_end,
 448 // start_position,
 449 // config.input_rate,
 450 // frame_rate,
 451 // lowest_fraction,
 452 // highest_fraction);
 453
 454                 int w = frame->get_w();
 455                 int h = frame->get_h();
 456                 switch(frame->get_color_model())
 457                 {
 458                         case BC_RGB_FLOAT:
 459                                 AVERAGE(float, float, 3, 1);
 460                                 break;
 461                         case BC_RGB888:
 462                         case BC_YUV888:
 463                                 AVERAGE(unsigned char, int, 3, 0xff);
 464                                 break;
 465                         case BC_RGBA_FLOAT:
 466                                 AVERAGE(float, float, 4, 1);
 467                                 break;
 468                         case BC_RGBA8888:
 469                         case BC_YUVA8888:
 470                                 AVERAGE(unsigned char, int, 4, 0xff);
 471                                 break;
 472                         case BC_RGB161616:
 473                         case BC_YUV161616:
 474                                 AVERAGE(uint16_t, int, 3, 0xffff);
 475                                 break;
 476                         case BC_RGBA16161616:
 477                         case BC_YUVA16161616:
 478                                 AVERAGE(uint16_t, int, 4, 0xffff);
 479                                 break;
 480                 }
 481         }
 482         return 0;
 483 }
 484
 485
 486
 487 int InterpolateVideo::is_realtime()
 488 {
 489         return 1;
 490 }
 491
 492 char* InterpolateVideo::plugin_title()
 493 {
 494         return N_("Interpolate");
 495 }
 496
 497 NEW_PICON_MACRO(InterpolateVideo)
 498
 499 SHOW_GUI_MACRO(InterpolateVideo, InterpolateVideoThread)
 500
 501 RAISE_WINDOW_MACRO(InterpolateVideo)
 502
 503 SET_STRING_MACRO(InterpolateVideo)
 504
 505 int InterpolateVideo::load_configuration()
 506 {
 507         KeyFrame *prev_keyframe, *next_keyframe;
 508         InterpolateVideoConfig old_config;
 509         old_config.copy_from(&config);
 510
 511         next_keyframe = get_next_keyframe(get_source_position());
 512         prev_keyframe = get_prev_keyframe(get_source_position());
 513 // Previous keyframe stays in config object.
 514         read_data(prev_keyframe);
 515
 516
 517         int64_t prev_position = edl_to_local(prev_keyframe->position);
 518         int64_t next_position = edl_to_local(next_keyframe->position);
 519         if(prev_position == 0 && next_position == 0)
 520         {
 521                 next_position = prev_position = get_source_start();
 522         }
 523 // printf("InterpolateVideo::load_configuration 1 %lld %lld %lld %lld\n",
 524 // prev_keyframe->position,
 525 // next_keyframe->position,
 526 // prev_position,
 527 // next_position);
 528
 529 // Get range to average in requested rate
 530         range_start = prev_position;
 531         range_end = next_position;
 532
 533
 534 // Use keyframes to determine range
 535         if(config.use_keyframes)
 536         {
 537 // Between keyframe and edge of range or no keyframes
 538                 if(range_start == range_end)
 539                 {
 540 // Between first keyframe and start of effect
 541                         if(get_source_position() >= get_source_start() &&
 542                                 get_source_position() < range_start)
 543                         {
 544                                 range_start = get_source_start();
 545                         }
 546                         else
 547 // Between last keyframe and end of effect
 548                         if(get_source_position() >= range_start &&
 549                                 get_source_position() < get_source_start() + get_total_len())
 550                         {
 551 // Last frame should be inclusive of current effect
 552                                 range_end = get_source_start() + get_total_len() - 1;
 553                         }
 554                         else
 555                         {
 556 // Should never get here
 557                                 ;
 558                         }
 559                 }
 560
 561 // Convert requested rate to input rate
 562                 range_start = (int64_t)((double)range_start / get_framerate() * config.input_rate + 0.5);
 563                 range_end = (int64_t)((double)range_end / get_framerate() * config.input_rate + 0.5);
 564         }
 565         else
 566 // Use frame rate
 567         {
 568 // Convert to input frame rate
 569                 range_start = (int64_t)(get_source_position() /
 570                         get_framerate() *
 571                         config.input_rate);
 572                 range_end = (int64_t)(get_source_position() /
 573                         get_framerate() *
 574                         config.input_rate) + 1;
 575         }
 576
 577 // printf("InterpolateVideo::load_configuration 1 %lld %lld %lld %lld %lld %lld\n",
 578 // prev_keyframe->position,
 579 // next_keyframe->position,
 580 // prev_position,
 581 // next_position,
 582 // range_start,
 583 // range_end);
 584
 585
 586         return !config.equivalent(&old_config);
 587 }
 588
 589 int InterpolateVideo::load_defaults()
 590 {
 591         char directory[BCTEXTLEN];
 592 // set the default directory
 593         sprintf(directory, "%sinterpolatevideo.rc", BCASTDIR);
 594
 595 // load the defaults
 596         defaults = new Defaults(directory);
 597         defaults->load();
 598
 599         config.input_rate = defaults->get("INPUT_RATE", config.input_rate);
 600         config.input_rate = Units::fix_framerate(config.input_rate);
 601         config.use_keyframes = defaults->get("USE_KEYFRAMES", config.use_keyframes);
 602         return 0;
 603 }
 604
 605 int InterpolateVideo::save_defaults()
 606 {
 607         defaults->update("INPUT_RATE", config.input_rate);
 608         defaults->update("USE_KEYFRAMES", config.use_keyframes);
 609         defaults->save();
 610         return 0;
 611 }
 612
 613 void InterpolateVideo::save_data(KeyFrame *keyframe)
 614 {
 615         FileXML output;
 616
 617 // cause data to be stored directly in text
 618         output.set_shared_string(keyframe->data, MESSAGESIZE);
 619         output.tag.set_title("INTERPOLATEVIDEO");
 620         output.tag.set_property("INPUT_RATE", config.input_rate);
 621         output.tag.set_property("USE_KEYFRAMES", config.use_keyframes);
 622         output.append_tag();
 623         output.terminate_string();
 624 }
 625
 626 void InterpolateVideo::read_data(KeyFrame *keyframe)
 627 {
 628         FileXML input;
 629
 630         input.set_shared_string(keyframe->data, strlen(keyframe->data));
 631
 632         int result = 0;
 633
 634         while(!input.read_tag())
 635         {
 636                 if(input.tag.title_is("INTERPOLATEVIDEO"))
 637                 {
 638                         config.input_rate = input.tag.get_property("INPUT_RATE", config.input_rate);
 639                         config.input_rate = Units::fix_framerate(config.input_rate);
 640                         config.use_keyframes = input.tag.get_property("USE_KEYFRAMES", config.use_keyframes);
 641                 }
 642         }
 643 }
 644
 645 void InterpolateVideo::update_gui()
 646 {
 647         if(thread)
 648         {
 649                 if(load_configuration())
 650                 {
 651                         thread->window->lock_window("InterpolateVideo::update_gui");
 652                         thread->window->rate->update((float)config.input_rate);
 653                         thread->window->keyframes->update(config.use_keyframes);
 654                         thread->window->unlock_window();
 655                 }
 656         }
 657 }
 658
 659