#include "vedit.h"
#include "vframe.h"
#include "videodevice.h"
+#include "virtualvconsole.h"
#include "vmodule.h"
#include "vrender.h"
#include "vplugin.h"
-int VModule::import_frame(VFrame *output,
- VEdit *current_edit,
- int64_t input_position,
- double frame_rate,
- int direction,
- int use_opengl)
+int VModule::import_frame(VFrame *output, VEdit *current_edit,
+ int64_t input_position, double frame_rate, int direction, int use_opengl)
{
int64_t direction_position;
// Translation of edit
- float in_x;
- float in_y;
- float in_w;
- float in_h;
- float out_x;
- float out_y;
- float out_w;
- float out_h;
+ float in_x, in_y, in_w, in_h;
+ float out_x, out_y, out_w, out_h;
int result = 0;
const int debug = 0;
double edl_rate = get_edl()->session->frame_rate;
int64_t input_position_project = Units::to_int64(input_position *
- edl_rate /
- frame_rate +
- 0.001);
-
-
-
-
-
-
+ edl_rate / frame_rate + 0.001);
if(!output) printf("VModule::import_frame %d output=%p\n", __LINE__, output);
//output->dump_params();
-
if(debug) printf("VModule::import_frame %d this=%p input_position=%lld direction=%d\n",
- __LINE__,
- this,
- (long long)input_position,
- direction);
+ __LINE__, this, (long long)input_position, direction);
// Convert to position corrected for direction
direction_position = input_position;
- if(direction == PLAY_REVERSE)
- {
- direction_position--;
- input_position_project--;
+ if(direction == PLAY_REVERSE) {
+ if( direction_position > 0 ) direction_position--;
+ if( input_position_project > 0 ) input_position_project--;
}
if(!output) printf("VModule::import_frame %d output=%p\n", __LINE__, output);
}
if(!output) printf("VModule::import_frame %d output=%p x11_device=%p nested_edl=%p\n",
- __LINE__,
- output,
- x11_device,
- nested_edl);
-
+ __LINE__, output, x11_device, nested_edl);
if(debug) printf("VModule::import_frame %d current_edit=%p\n",
- __LINE__,
- current_edit);
-
+ __LINE__, current_edit);
// Load frame into output
// Create objects for nested EDL
- if(current_edit &&
- current_edit->nested_edl)
- {
+ if(current_edit && current_edit->nested_edl) {
int command;
if(debug) printf("VModule::import_frame %d nested_edl=%p current_edit->nested_edl=%p\n",
- __LINE__,
- nested_edl,
- current_edit->nested_edl);
+ __LINE__, nested_edl, current_edit->nested_edl);
// Convert requested direction to command
if(renderengine->command->command == CURRENT_FRAME)
nested_command->get_edl()->copy_all(nested_edl);
nested_command->change_type = CHANGE_ALL;
nested_command->realtime = renderengine->command->realtime;
- nested_renderengine = new RenderEngine(0,
- get_preferences(),
- 0,
- renderengine ? renderengine->channeldb : 0,
- 1);
+ nested_renderengine = new RenderEngine(0, get_preferences(), 0, 1);
nested_renderengine->set_vcache(get_cache());
nested_renderengine->arm_command(nested_command);
}
{
// integrate position from start of edit.
double speed_position = edit_startsource;
- FloatAuto *previous = 0;
- FloatAuto *next = 0;
FloatAutos *speed_autos = (FloatAutos*)track->automation->autos[AUTOMATION_SPEED];
- for(int64_t i = edit_startproject; i < direction_position; i++)
- {
- double speed = speed_autos->get_value(i,
- PLAY_FORWARD,
- previous,
- next);
- speed_position += speed;
- }
+ speed_position += speed_autos->automation_integral(edit_startproject,
+ direction_position-edit_startproject, PLAY_FORWARD);
//printf("VModule::import_frame %d %lld %lld\n", __LINE__, position, (int64_t)speed_position);
position = (int64_t)speed_position;
}
// current_edit->asset->interlace_fixmethod);
// Determine the interlacing method to use.
- int interlace_fixmethod = ilaceautofixmethod2(get_edl()->session->interlace_mode,
+ int interlace_fixmethod = !current_edit->asset ? ILACE_FIXMETHOD_NONE :
+ ilaceautofixmethod2(get_edl()->session->interlace_mode,
current_edit->asset->interlace_autofixoption,
current_edit->asset->interlace_mode,
current_edit->asset->interlace_fixmethod);
// Compensate for the said interlacing...
switch (interlace_fixmethod) {
- case BC_ILACE_FIXMETHOD_NONE:
+ case ILACE_FIXMETHOD_NONE:
break;
- case BC_ILACE_FIXMETHOD_UPONE:
+ case ILACE_FIXMETHOD_UPONE:
out_y--;
break;
- case BC_ILACE_FIXMETHOD_DOWNONE:
+ case ILACE_FIXMETHOD_DOWNONE:
out_y++;
break;
default:
//printf("VModule::render %d %p %ld %d\n", __LINE__, current_edit, start_position_project, direction);
if(debug_render)
- printf(" VModule::render %d %d %ld %s transition=%p opengl=%d current_edit=%p output=%p\n",
+ printf(" VModule::render %d %d %jd %s transition=%p opengl=%d current_edit=%p output=%p\n",
__LINE__,
use_nudge,
start_position_project,
use_opengl);
}
- int64_t mask_position = !renderengine ? start_position :
- renderengine->vrender->current_position;
Auto *current = 0;
MaskAutos *keyframe_set =
(MaskAutos*)track->automation->autos[AUTOMATION_MASK];
- MaskAuto *keyframe =
+ int64_t mask_position = !renderengine ? start_position :
+ renderengine->vrender->current_position;
+ MaskAuto *keyframe =
(MaskAuto*)keyframe_set->get_prev_auto(mask_position, direction, current);
+
if( keyframe->apply_before_plugins ) {
- if( !masker ) {
- int cpus = renderengine ?
- renderengine->preferences->processors :
- plugin_array->mwindow->preferences->processors;
- masker = new MaskEngine(cpus);
+ VDeviceX11 *x11_device = 0;
+ if(use_opengl && renderengine && renderengine->video) {
+ x11_device = (VDeviceX11*)renderengine->video->get_output_base();
+ if( !x11_device->can_mask(mask_position, keyframe_set) )
+ use_opengl = 0;
+ }
+ if( use_opengl && x11_device ) {
+ x11_device->do_mask(output, mask_position, keyframe_set,
+ keyframe, keyframe);
+ }
+ else {
+ if( !masker ) {
+ int cpus = renderengine ?
+ renderengine->preferences->processors :
+ plugin_array->mwindow->preferences->processors;
+ masker = new MaskEngine(cpus);
+ }
+ masker->do_mask(output, mask_position, keyframe_set, keyframe, keyframe);
}
- masker->do_mask(output, mask_position, keyframe_set, keyframe, keyframe);
}
return result;