cinelerra-5.1/cinelerra/vmodule.C

   1
   2 /*
   3  * CINELERRA
   4  * Copyright (C) 2009-2013 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 "asset.h"
  23 #include "bchash.h"
  24 #include "bcpbuffer.h"
  25 #include "bcsignals.h"
  26 #include "cache.h"
  27 #include "clip.h"
  28 #include "commonrender.h"
  29 #include "edits.h"
  30 #include "edl.h"
  31 #include "edlsession.h"
  32 #include "file.h"
  33 #include "filexml.h"
  34 #include "floatautos.h"
  35 #include "maskauto.h"
  36 #include "maskautos.h"
  37 #include "mwindow.h"
  38 #include "overlayframe.h"
  39 #include "patch.h"
  40 #include "pluginarray.h"
  41 #include "preferences.h"
  42 #include "renderengine.h"
  43 #include "sharedlocation.h"
  44 #include "tracks.h"
  45 #include "transition.h"
  46 #include "transportque.h"
  47 #include "units.h"
  48 #include "vattachmentpoint.h"
  49 #include "vdevicex11.h"
  50 #include "vedit.h"
  51 #include "vframe.h"
  52 #include "videodevice.h"
  53 #include "virtualvconsole.h"
  54 #include "vmodule.h"
  55 #include "vrender.h"
  56 #include "vplugin.h"
  57 #include "vtrack.h"
  58 #include <string.h>
  59 #include "maskengine.h"
  60 #include "automation.h"
  61
  62 VModule::VModule(RenderEngine *renderengine,
  63         CommonRender *commonrender,
  64         PluginArray *plugin_array,
  65         Track *track)
  66  : Module(renderengine, commonrender, plugin_array, track)
  67 {
  68         data_type = TRACK_VIDEO;
  69         overlay_temp = 0;
  70         input_temp = 0;
  71         transition_temp = 0;
  72         masker = 0;
  73 }
  74
  75 VModule::~VModule()
  76 {
  77         if( overlay_temp ) delete overlay_temp;
  78         if( input_temp ) delete input_temp;
  79         if( transition_temp ) delete transition_temp;
  80         delete masker;
  81 }
  82
  83
  84 AttachmentPoint* VModule::new_attachment(Plugin *plugin)
  85 {
  86         return new VAttachmentPoint(renderengine, plugin);
  87 }
  88
  89 int VModule::get_buffer_size()
  90 {
  91         return 1;
  92 }
  93
  94 CICache* VModule::get_cache()
  95 {
  96         if( renderengine )
  97                 return renderengine->get_vcache();
  98         else
  99                 return cache;
 100 }
 101
 102
 103 int VModule::import_frame(VFrame *output, VEdit *current_edit,
 104         int64_t input_position, double frame_rate, int direction, int use_opengl)
 105 {
 106         int64_t direction_position;
 107 // Translation of edit
 108         float in_x, in_y, in_w, in_h;
 109         float out_x, out_y, out_w, out_h;
 110         int result = 0;
 111         const int debug = 0;
 112         double edl_rate = get_edl()->session->frame_rate;
 113
 114         int64_t input_position_project = Units::to_int64(input_position *
 115                 edl_rate / frame_rate + 0.001);
 116
 117         if( !output ) printf("VModule::import_frame %d output=%p\n", __LINE__, output);
 118         //output->dump_params();
 119
 120         if( debug ) printf("VModule::import_frame %d this=%p input_position=%lld direction=%d\n",
 121                 __LINE__, this, (long long)input_position, direction);
 122
 123 // Convert to position corrected for direction
 124         direction_position = input_position;
 125         if( direction == PLAY_REVERSE ) {
 126                 if( direction_position > 0 ) direction_position--;
 127                 if( input_position_project > 0 ) input_position_project--;
 128         }
 129         if( !output ) printf("VModule::import_frame %d output=%p\n", __LINE__, output);
 130
 131         VDeviceX11 *x11_device = 0;
 132         if( use_opengl ) {
 133                 if( renderengine && renderengine->video ) {
 134                         x11_device = (VDeviceX11*)renderengine->video->get_output_base();
 135                         output->set_opengl_state(VFrame::RAM);
 136                         if( !x11_device ) use_opengl = 0;
 137                 }
 138         }
 139
 140         if( !output ) printf("VModule::import_frame %d output=%p x11_device=%p nested_edl=%p\n",
 141                 __LINE__, output, x11_device, nested_edl);
 142
 143         if( debug ) printf("VModule::import_frame %d current_edit=%p\n",
 144                 __LINE__, current_edit);
 145
 146 // Load frame into output
 147
 148 // Create objects for nested EDL
 149         if( current_edit && current_edit->nested_edl ) {
 150                 int command;
 151                 if( debug ) printf("VModule::import_frame %d nested_edl=%p current_edit->nested_edl=%p\n",
 152                         __LINE__, nested_edl, current_edit->nested_edl);
 153
 154 // Convert requested direction to command
 155                 if( renderengine->command->command == CURRENT_FRAME ||
 156                     renderengine->command->command == LAST_FRAME ) {
 157                         command = renderengine->command->command;
 158                 }
 159                 else
 160                 if( direction == PLAY_REVERSE ) {
 161                         if( renderengine->command->single_frame() )
 162                                 command = SINGLE_FRAME_REWIND;
 163                         else
 164                                 command = NORMAL_REWIND;
 165                 }
 166                 else {
 167                         if( renderengine->command->single_frame() )
 168                                 command = SINGLE_FRAME_FWD;
 169                         else
 170                                 command = NORMAL_FWD;
 171                 }
 172
 173                 if( !nested_edl || nested_edl->id != current_edit->nested_edl->id ) {
 174                         nested_edl = current_edit->nested_edl;
 175                         if( nested_renderengine ) {
 176                                 delete nested_renderengine;
 177                                 nested_renderengine = 0;
 178                         }
 179                         if( !nested_command )
 180                                 nested_command = new TransportCommand;
 181                         nested_command->command = command;
 182                         nested_command->get_edl()->copy_all(nested_edl);
 183                         nested_command->change_type = CHANGE_ALL;
 184                         nested_command->realtime = renderengine->command->realtime;
 185                         nested_renderengine = new RenderEngine(0, get_preferences(), 0, 1);
 186                         nested_renderengine->set_vcache(get_cache());
 187                         nested_renderengine->arm_command(nested_command);
 188                 }
 189                 else {
 190
 191 // Update nested command
 192                         nested_renderengine->command->command = command;
 193                         nested_command->realtime = renderengine->command->realtime;
 194                 }
 195
 196 // Update nested video driver for opengl
 197                 nested_renderengine->video = renderengine->video;
 198         }
 199         else {
 200                 nested_edl = 0;
 201         }
 202         if( debug ) printf("VModule::import_frame %d\n", __LINE__);
 203
 204         if( output ) {
 205                 if( use_opengl )
 206                         x11_device->clear_input(output);
 207                 else
 208                         output->clear_frame();
 209         }
 210         else
 211                 printf("VModule::import_frame %d output=%p\n", __LINE__, output);
 212
 213         if( current_edit &&
 214                 (current_edit->asset ||
 215                 (current_edit->nested_edl && nested_renderengine->vrender)) ) {
 216                 File *file = 0;
 217
 218 //printf("VModule::import_frame %d cache=%p\n", __LINE__, get_cache());
 219                 if( current_edit->asset ) {
 220                         get_cache()->age();
 221                         file = get_cache()->check_out(current_edit->asset,
 222                                 get_edl());
 223 //                      get_cache()->dump();
 224                 }
 225
 226 // File found
 227                 if( file || nested_edl ) {
 228 // Make all positions based on requested frame rate.
 229                         int64_t edit_startproject = Units::to_int64(current_edit->startproject *
 230                                 frame_rate /
 231                                 edl_rate);
 232                         int64_t edit_startsource = Units::to_int64(current_edit->startsource *
 233                                 frame_rate /
 234                                 edl_rate);
 235 // Source position going forward
 236                         uint64_t position = direction_position -
 237                                 edit_startproject +
 238                                 edit_startsource;
 239                         int64_t nested_position = 0;
 240
 241
 242
 243
 244
 245 // apply speed curve to source position so the timeline agrees with the playback
 246                         if( track->has_speed() ) {
 247 // integrate position from start of edit.
 248                                 double speed_position = edit_startsource;
 249                                 FloatAutos *speed_autos = (FloatAutos*)track->automation->autos[AUTOMATION_SPEED];
 250                                 speed_position += speed_autos->automation_integral(edit_startproject,
 251                                                 direction_position-edit_startproject, PLAY_FORWARD);
 252 //printf("VModule::import_frame %d %lld %lld\n", __LINE__, position, (int64_t)speed_position);
 253                                 position = (int64_t)speed_position;
 254                         }
 255
 256
 257
 258
 259
 260                         int asset_w;
 261                         int asset_h;
 262                         if( debug ) printf("VModule::import_frame %d\n", __LINE__);
 263
 264
 265 // maybe apply speed curve here, so timeline reflects actual playback
 266
 267
 268
 269 // if we hit the end of stream, freeze at last frame
 270                         uint64_t max_position = 0;
 271                         if( file ) {
 272                                 max_position = Units::to_int64((double)file->get_video_length() *
 273                                         frame_rate /
 274                                         current_edit->asset->frame_rate - 1);
 275                         }
 276                         else {
 277                                 max_position = Units::to_int64(nested_edl->tracks->total_length() *
 278                                         frame_rate - 1);
 279                         }
 280
 281
 282                         if( position > max_position ) position = max_position;
 283                         else
 284                         if( position < 0 ) position = 0;
 285
 286                         int use_cache = renderengine &&
 287                                 renderengine->command->single_frame();
 288 //                      int use_asynchronous = !use_cache &&
 289 //                              renderengine &&
 290 // Try to make rendering go faster.
 291 // But converts some formats to YUV420, which may degrade input format.
 292 ////                            renderengine->command->realtime &&
 293 //                              renderengine->get_edl()->session->video_asynchronous;
 294
 295                         if( file ) {
 296                                 if( debug ) printf("VModule::import_frame %d\n", __LINE__);
 297 //                              if( use_asynchronous )
 298 //                                      file->start_video_decode_thread();
 299 //                              else
 300                                         file->stop_video_thread();
 301
 302                                 int64_t normalized_position = Units::to_int64(position *
 303                                         current_edit->asset->frame_rate /
 304                                         frame_rate);
 305 // printf("VModule::import_frame %d %lld %lld\n",
 306 // __LINE__,
 307 // position,
 308 // normalized_position);
 309                                 file->set_layer(current_edit->channel);
 310                                 file->set_video_position(normalized_position,
 311                                         0);
 312                                 asset_w = current_edit->asset->width;
 313                                 asset_h = current_edit->asset->height;
 314 //printf("VModule::import_frame %d normalized_position=%lld\n", __LINE__, normalized_position);
 315                         }
 316                         else {
 317                                 if( debug ) printf("VModule::import_frame %d\n", __LINE__);
 318                                 asset_w = nested_edl->session->output_w;
 319                                 asset_h = nested_edl->session->output_h;
 320 // Get source position in nested frame rate in direction of playback.
 321                                 nested_position = Units::to_int64(position *
 322                                         nested_edl->session->frame_rate /
 323                                         frame_rate);
 324                                 if( direction == PLAY_REVERSE )
 325                                         nested_position++;
 326                         }
 327
 328
 329 // Auto scale if required
 330                         if( output->get_params()->get("AUTOSCALE", 0) ) {
 331                                 float autoscale_w = output->get_params()->get("AUTOSCALE_W", 1024);
 332                                 float autoscale_h = output->get_params()->get("AUTOSCALE_H", 1024);
 333                                 float x_scale = autoscale_w / asset_w;
 334                                 float y_scale = autoscale_h / asset_h;
 335
 336 // Overriding camera
 337                                 in_x = 0;
 338                                 in_y = 0;
 339                                 in_w = asset_w;
 340                                 in_h = asset_h;
 341
 342                                 if( x_scale < y_scale ) {
 343                                         out_w = in_w * x_scale;
 344                                         out_h = in_h * x_scale;
 345                                 }
 346                                 else {
 347                                         out_w = in_w * y_scale;
 348                                         out_h = in_h * y_scale;
 349                                 }
 350
 351                                 out_x = track->track_w / 2 - out_w / 2;
 352                                 out_y = track->track_h / 2 - out_h / 2;
 353                         }
 354                         else {
 355 // Apply camera
 356                                 ((VTrack*)track)->calculate_input_transfer(asset_w,
 357                                         asset_h, input_position_project, direction,
 358                                         in_x, in_y, in_w, in_h,
 359                                         out_x, out_y, out_w, out_h);
 360                         }
 361
 362 // printf("VModule::import_frame %d %f %d %f %d\n",
 363 // __LINE__, in_w, asset_w, in_h, asset_h);
 364
 365 // file -> temp -> output
 366                         if( !EQUIV(in_x, 0) ||
 367                                 !EQUIV(in_y, 0) ||
 368                                 !EQUIV(in_w, track->track_w) ||
 369                                 !EQUIV(in_h, track->track_h) ||
 370                                 !EQUIV(out_x, 0) ||
 371                                 !EQUIV(out_y, 0) ||
 372                                 !EQUIV(out_w, track->track_w) ||
 373                                 !EQUIV(out_h, track->track_h) ||
 374                                 !EQUIV(in_w, asset_w) ||
 375                                 !EQUIV(in_h, asset_h)) {
 376 //printf("VModule::import_frame %d file -> temp -> output\n", __LINE__);
 377 // Get temporary input buffer
 378                                 VFrame **input = 0;
 379 // Realtime playback
 380                                 if( commonrender ) {
 381                                         VRender *vrender = (VRender*)commonrender;
 382 //printf("VModule::import_frame %d vrender->input_temp=%p\n", __LINE__, vrender->input_temp);
 383                                         input = &vrender->input_temp;
 384                                 }
 385                                 else {
 386 // Menu effect
 387                                         input = &input_temp;
 388                                 }
 389
 390
 391                                 if( (*input) &&
 392                                    ((*input)->get_w() != asset_w ||
 393                                    (*input)->get_h() != asset_h) ) {
 394                                         delete (*input);
 395                                         (*input) = 0;
 396                                 }
 397
 398                                 if( !(*input) ) {
 399                                         (*input) =
 400                                                 new VFrame(asset_w, asset_h,
 401                                                         get_edl()->session->color_model);
 402                                 }
 403                                 (*input)->copy_stacks(output);
 404
 405 // file -> temp
 406 // Cache for single frame only
 407                                 if( file ) {
 408                                         if( debug ) printf("VModule::import_frame %d this=%p file=%s\n",
 409                                                 __LINE__,
 410                                                 this,
 411                                                 current_edit->asset->path);
 412                                         if( use_cache ) file->set_cache_frames(1);
 413                                         result = file->read_frame((*input));
 414                                         if( use_cache ) file->set_cache_frames(0);
 415                                         (*input)->set_opengl_state(VFrame::RAM);
 416                                 }
 417                                 else
 418                                 if( nested_edl ) {
 419 // If the colormodels differ, change input to nested colormodel
 420                                         int nested_cmodel = nested_renderengine->get_edl()->session->color_model;
 421                                         int current_cmodel = output->get_color_model();
 422                                         int output_w = output->get_w();
 423                                         int output_h = output->get_h();
 424                                         VFrame *input2 = (*input);
 425
 426                                         if( nested_cmodel != current_cmodel ) {
 427 // If opengl, input -> input -> output
 428                                                 if( use_opengl ) { }
 429                                                 else {
 430 // If software, input2 -> input -> output
 431 // Use output as a temporary.
 432                                                         input2 = output;
 433                                                 }
 434
 435                                                 if( debug ) printf("VModule::import_frame %d this=%p nested_cmodel=%d\n",
 436                                                         __LINE__,
 437                                                         this,
 438                                                         nested_cmodel);
 439                                                 input2->dump();
 440                                                 input2->reallocate(0, -1, 0, 0, 0,
 441                                                         (*input)->get_w(), (*input)->get_h(),
 442                                                         nested_cmodel, -1);
 443                                                 input2->dump();
 444                                         }
 445
 446
 447                                         if( debug ) printf("VModule::import_frame %d this=%p nested_edl=%s input2=%p\n",
 448                                                 __LINE__, this, nested_edl->path, input2);
 449
 450                                         result = nested_renderengine->vrender->process_buffer(
 451                                                 input2, nested_position, use_opengl);
 452
 453                                         if( debug ) printf("VModule::import_frame %d this=%p nested_edl=%s\n",
 454                                                 __LINE__,
 455                                                 this,
 456                                                 nested_edl->path);
 457
 458                                         if( nested_cmodel != current_cmodel ) {
 459                                                 if( debug ) printf("VModule::import_frame %d\n", __LINE__);
 460                                                 if( use_opengl ) {
 461 // Change colormodel in hardware.
 462                                                         if( debug ) printf("VModule::import_frame %d\n", __LINE__);
 463                                                         x11_device->convert_cmodel(input2,
 464                                                                 current_cmodel);
 465
 466 // The converted color model is now in hardware, so return the input2 buffer
 467 // to the expected color model.
 468                                                         input2->reallocate(0, -1, 0, 0, 0,
 469                                                                 (*input)->get_w(), (*input)->get_h(),
 470                                                                 current_cmodel, -1);
 471                                                 }
 472                                                 else {
 473 // Transfer from input2 to input
 474 if( debug ) printf("VModule::import_frame %d nested_cmodel=%d current_cmodel=%d input2=%p input=%p output=%p\n",
 475   __LINE__, nested_cmodel, current_cmodel, input2, (*input), output);
 476                                                         BC_CModels::transfer((*input)->get_rows(), input2->get_rows(),
 477                                                                 0, 0, 0, 0, 0, 0,
 478                                                                 0, 0, input2->get_w(), input2->get_h(),
 479                                                                 0, 0, (*input)->get_w(), (*input)->get_h(),
 480                                                                 nested_cmodel, current_cmodel, 0,
 481                                                                 input2->get_w(), (*input)->get_w());
 482 //printf("VModule::import_frame %d\n", __LINE__);
 483
 484 // input2 was the output buffer, so it must be restored
 485                                                 input2->reallocate(0, -1, 0, 0, 0,
 486                                                         output_w, output_h, current_cmodel, -1);
 487 //printf("VModule::import_frame %d\n", __LINE__);
 488                                                 }
 489                                         }
 490
 491                                 }
 492
 493 // Find an overlayer object to perform the camera transformation
 494                                 OverlayFrame *overlayer = 0;
 495
 496 // OpenGL playback uses hardware
 497                                 if( use_opengl ) {
 498 //printf("VModule::import_frame %d\n", __LINE__);
 499                                 }
 500                                 else if( commonrender ) {
 501 // Realtime playback
 502                                         VRender *vrender = (VRender*)commonrender;
 503                                         overlayer = vrender->overlayer;
 504                                 }
 505                                 else {
 506 // Menu effect
 507                                         if( !plugin_array )
 508                                                 printf("VModule::import_frame neither plugin_array nor commonrender is defined.\n");
 509                                         if( !overlay_temp ) {
 510                                                 overlay_temp = new OverlayFrame(plugin_array->mwindow->preferences->processors);
 511                                         }
 512
 513                                         overlayer = overlay_temp;
 514                                 }
 515 // printf("VModule::import_frame 1 %.2f %.2f %.2f %.2f %.2f %.2f %.2f %.2f\n",
 516 //   in_x, in_y, in_w, in_h, out_x, out_y, out_w, out_h);
 517
 518 // temp -> output
 519 // for( int j = 0; j < output->get_w() * 3 * 5; j++ )
 520 //      output->get_rows()[0][j] = 255;
 521
 522                                 if( use_opengl ) {
 523                                         x11_device->do_camera(output, (*input),
 524                                                 in_x, in_y, in_x + in_w, in_y + in_h,
 525                                                 out_x, out_y, out_x + out_w, out_y + out_h);
 526 if( debug ) printf("VModule::import_frame %d %d %d\n",
 527  __LINE__, output->get_opengl_state(), (*input)->get_opengl_state());
 528                                 }
 529                                 else {
 530                                         output->clear_frame();
 531 // get_cache()->check_in(current_edit->asset);
 532 // return;
 533
 534 // TRANSFER_REPLACE is the fastest transfer mode but it has the disadvantage
 535 // of producing green borders in floating point translation of YUV
 536                                         int mode = TRANSFER_REPLACE;
 537                                         if( get_edl()->session->interpolation_type != NEAREST_NEIGHBOR &&
 538                                                 BC_CModels::is_yuv(output->get_color_model()) )
 539                                                 mode = TRANSFER_NORMAL;
 540
 541                                         if( debug ) printf("VModule::import_frame %d temp -> output\n", __LINE__);
 542                                         overlayer->overlay(output, (*input),
 543                                                 in_x, in_y, in_x + in_w, in_y + in_h,
 544                                                 out_x, out_y, out_x + out_w, out_y + out_h,
 545                                                 1, mode, get_edl()->session->interpolation_type);
 546                                 }
 547                                 result = 1;
 548
 549                                 output->copy_stacks((*input));
 550
 551
 552 //printf("VModule::import_frame %d\n", __LINE__);
 553 //(*input)->dump_params();
 554 //output->dump_params();
 555                         }
 556                         else {
 557 // file -> output
 558                                 if( debug ) printf("VModule::import_frame %d file -> output nested_edl=%p file=%p\n",
 559                                         __LINE__, nested_edl, file);
 560                                 if( nested_edl ) {
 561                                         VFrame **input = &output;
 562 // If colormodels differ, reallocate output in nested colormodel.
 563                                         int nested_cmodel = nested_renderengine->get_edl()->session->color_model;
 564                                         int current_cmodel = output->get_color_model();
 565
 566 if( debug ) printf("VModule::import_frame %d nested_cmodel=%d current_cmodel=%d\n",
 567 __LINE__,
 568 nested_cmodel,
 569 current_cmodel);
 570
 571                                         if( nested_cmodel != current_cmodel ) {
 572                                                 if( use_opengl ) { }
 573                                                 else {
 574                                                         if( commonrender ) {
 575                                                                 input = &((VRender*)commonrender)->input_temp;
 576                                                         }
 577                                                         else {
 578                                                                 input = &input_temp;
 579                                                         }
 580
 581                                                         if( !(*input) ) (*input) = new VFrame;
 582                                                 }
 583
 584                                                 (*input)->reallocate(0, -1, 0, 0, 0,
 585                                                         output->get_w(), output->get_h(),
 586                                                         nested_cmodel, -1);
 587 if( debug ) printf("VModule::import_frame %d\n", __LINE__);
 588 //(*input)->dump();
 589 //(*input)->clear_frame();
 590                                         }
 591
 592 if( debug ) printf("VModule::import_frame %d %p %p\n",
 593  __LINE__, (*input)->get_rows(), (*input));
 594                                         result = nested_renderengine->vrender->process_buffer(
 595                                                 (*input), nested_position, use_opengl);
 596 if( debug ) printf("VModule::import_frame %d\n",
 597 __LINE__);
 598
 599 // If colormodels differ, change colormodels in opengl if possible.
 600 // Swap output for temp if not possible.
 601                                         if( nested_cmodel != current_cmodel ) {
 602                                                 if( use_opengl ) {
 603                                                         x11_device->convert_cmodel(output,
 604                                                                 current_cmodel);
 605
 606 // The color model was changed in place, so return output buffer
 607                                                         output->reallocate(0, -1, 0, 0, 0,
 608                                                                 output->get_w(), output->get_h(),
 609                                                                 current_cmodel, -1);
 610                                                 }
 611                                                 else {
 612 // Transfer from temporary to output
 613 if( debug ) printf("VModule::import_frame %d %d %d %d %d %d %d\n",
 614   __LINE__, (*input)->get_w(), (*input)->get_h(),
 615   output->get_w(), output->get_h(), nested_cmodel, current_cmodel);
 616                                                         BC_CModels::transfer(output->get_rows(), (*input)->get_rows(),
 617                                                                 0, 0, 0, 0, 0, 0,
 618                                                                 0, 0, (*input)->get_w(), (*input)->get_h(),
 619                                                                 0, 0, output->get_w(), output->get_h(),
 620                                                                 nested_cmodel, current_cmodel, 0,
 621                                                                 (*input)->get_w(), output->get_w());
 622                                                 }
 623
 624                                         }
 625                                 }
 626                                 else if( file ) {
 627 // Cache single frames
 628 //memset(output->get_rows()[0], 0xff, 1024);
 629                                         if( use_cache ) file->set_cache_frames(1);
 630                                         result = file->read_frame(output);
 631                                         if( use_cache ) file->set_cache_frames(0);
 632                                         output->set_opengl_state(VFrame::RAM);
 633                                 }
 634                         }
 635
 636                         if( file ) {
 637                                 get_cache()->check_in(current_edit->asset);
 638                                 file = 0;
 639                         }
 640                 }
 641                 else {
 642 // Source not found
 643                         result = 1;
 644                 }
 645
 646 //              printf("VModule::import_frame %d cache=%p\n",
 647 //                      __LINE__,
 648 //                      get_cache());
 649
 650         }
 651         else {
 652 // Source is silence
 653                 if( debug ) printf("VModule::import_frame %d\n", __LINE__);
 654                 if( use_opengl ) {
 655                         x11_device->clear_input(output);
 656                 }
 657                 else {
 658                         output->clear_frame();
 659                 }
 660         }
 661
 662         if( debug ) printf("VModule::import_frame %d done\n", __LINE__);
 663
 664         return result;
 665 }
 666
 667
 668 int VModule::render(VFrame *output,
 669         int64_t start_position, int direction, double frame_rate,
 670         int use_nudge, int debug_render, int use_opengl)
 671 {
 672         int result = 0;
 673         double edl_rate = get_edl()->session->frame_rate;
 674
 675 //printf("VModule::render %d %ld\n", __LINE__, start_position);
 676
 677         if( use_nudge ) start_position += Units::to_int64(track->nudge *
 678                 frame_rate / edl_rate);
 679
 680         int64_t start_position_project = Units::to_int64(start_position *
 681                 edl_rate / frame_rate + 0.5);
 682
 683         update_transition(start_position_project, direction);
 684
 685         VEdit* current_edit = (VEdit*)track->edits->editof(start_position_project,
 686                 direction, 0);
 687         VEdit* previous_edit = 0;
 688 //printf("VModule::render %d %p %ld %d\n", __LINE__, current_edit, start_position_project, direction);
 689
 690         Plugin *transition = get_edl()->tracks->plugin_exists(transition_id);
 691         if( debug_render )
 692                 printf("    VModule::render %d %d %jd %s transition=%p opengl=%d current_edit=%p output=%p\n",
 693                         __LINE__, use_nudge, start_position_project, track->title,
 694                         transition, use_opengl, current_edit, output);
 695
 696         if( !current_edit ) {
 697                 output->clear_frame();
 698                 // We do not apply mask here, since alpha is 0, and neither substracting nor multypling changes it
 699                 // Another mask mode - "addition" should be added to be able to create mask from empty frames
 700                 // in this case we would call masking here too...
 701                 return 0;
 702         }
 703
 704
 705
 706
 707 // Process transition
 708         if( transition && transition->on ) {
 709
 710 // Get temporary buffer
 711                 VFrame **transition_input = 0;
 712                 if( commonrender ) {
 713                         VRender *vrender = (VRender*)commonrender;
 714                         transition_input = &vrender->transition_temp;
 715                 }
 716                 else {
 717                         transition_input = &transition_temp;
 718                 }
 719
 720                 if( (*transition_input) &&
 721                         ((*transition_input)->get_w() != track->track_w ||
 722                         (*transition_input)->get_h() != track->track_h) ) {
 723                         delete (*transition_input);
 724                         (*transition_input) = 0;
 725                 }
 726
 727 // Load incoming frame
 728                 if( !(*transition_input) ) {
 729                         (*transition_input) =
 730                                 new VFrame(track->track_w, track->track_h,
 731                                         get_edl()->session->color_model);
 732                 }
 733
 734                 (*transition_input)->copy_stacks(output);
 735
 736 //printf("VModule::render %d\n", __LINE__);
 737                 result = import_frame((*transition_input),
 738                         current_edit, start_position, frame_rate,
 739                         direction, use_opengl);
 740
 741
 742 // Load transition buffer
 743                 previous_edit = (VEdit*)current_edit->previous;
 744
 745                 result |= import_frame(output,
 746                         previous_edit, start_position, frame_rate,
 747                         direction, use_opengl);
 748 //printf("VModule::render %d %p %p %p %p\n", __LINE__,
 749 // (*transition_input), (*transition_input)->get_pbuffer(),
 750 // output, output->get_pbuffer());
 751
 752 // Execute plugin with transition_input and output here
 753                 if( renderengine )
 754                         transition_server->set_use_opengl(use_opengl, renderengine->video);
 755                 transition_server->process_transition((*transition_input), output,
 756                         (direction == PLAY_FORWARD) ?
 757                                 (start_position_project - current_edit->startproject) :
 758                                 (start_position_project - current_edit->startproject - 1),
 759                         transition->length);
 760         }
 761         else {
 762 // Load output buffer
 763                 result = import_frame(output,
 764                         current_edit, start_position, frame_rate,
 765                         direction, use_opengl);
 766         }
 767
 768         Auto *current = 0;
 769         MaskAutos *keyframe_set =
 770                 (MaskAutos*)track->automation->autos[AUTOMATION_MASK];
 771         int64_t mask_position = !renderengine ? start_position :
 772                 renderengine->vrender->current_position;
 773         MaskAuto *keyframe =
 774                 (MaskAuto*)keyframe_set->get_prev_auto(mask_position, direction, current);
 775
 776         if( keyframe->apply_before_plugins && keyframe->has_active_mask() ) {
 777                 VDeviceX11 *x11_device = 0;
 778                 if( use_opengl && renderengine && renderengine->video ) {
 779                         x11_device = (VDeviceX11*)renderengine->video->get_output_base();
 780                         if( !x11_device->can_mask(mask_position, keyframe_set) ) {
 781                                 if( output->get_opengl_state() != VFrame::RAM ) {
 782                                         int w = output->get_w(), h = output->get_h();
 783                                         x11_device->do_camera(output, output,
 784                                                 0,0,w,h, 0,0,w,h); // copy to ram
 785                                 }
 786                                 use_opengl = 0;
 787                         }
 788                 }
 789                 if( use_opengl && x11_device ) {
 790                         x11_device->do_mask(output, mask_position, keyframe_set,
 791                                         keyframe, keyframe);
 792                 }
 793                 else {
 794                         if( !masker ) {
 795                                 int cpus = renderengine ?
 796                                         renderengine->preferences->processors :
 797                                         plugin_array->mwindow->preferences->processors;
 798                                 masker = new MaskEngine(cpus);
 799                         }
 800                         masker->do_mask(output, mask_position, keyframe_set, keyframe, keyframe);
 801                 }
 802         }
 803
 804         return result;
 805 }
 806
 807
 808 void VModule::create_objects()
 809 {
 810         Module::create_objects();
 811 }
 812