4 * Copyright (C) 2008-2017 Adam Williams <broadcast at earthling dot net>
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.
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.
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
24 #include "bccapture.h"
25 #include "bccmodels.h"
26 #include "bcsignals.h"
29 #include "edlsession.h"
32 #include "maskautos.h"
34 #include "mwindowgui.h"
35 #include "playback3d.h"
36 #include "playbackconfig.h"
37 #include "preferences.h"
38 #include "recordconfig.h"
39 #include "strategies.inc"
40 #include "vdevicex11.h"
42 #include "videodevice.h"
43 #include "videowindow.h"
44 #include "videowindowgui.h"
49 VDeviceX11::VDeviceX11(VideoDevice *device, Canvas *output)
53 this->output = output;
56 VDeviceX11::~VDeviceX11()
61 int VDeviceX11::reset_parameters()
78 color_model_selected = 0;
81 for( int i = 0; i < SCREENCAP_BORDERS; i++ ) {
82 screencap_border[i] = 0;
87 int VDeviceX11::open_input()
89 //printf("VDeviceX11::open_input 1\n");
90 capture_bitmap = new BC_Capture(device->in_config->w,
92 device->in_config->screencapture_display);
93 //printf("VDeviceX11::open_input 2\n");
96 device->mwindow->gui->lock_window("VDeviceX11::close_all");
98 screencap_border[0] = new BC_Popup(device->mwindow->gui,
99 device->input_x - SCREENCAP_PIXELS, device->input_y - SCREENCAP_PIXELS,
100 device->in_config->w + SCREENCAP_PIXELS * 2, SCREENCAP_PIXELS,
102 screencap_border[1] = new BC_Popup(device->mwindow->gui,
103 device->input_x - SCREENCAP_PIXELS, device->input_y,
104 SCREENCAP_PIXELS, device->in_config->h,
106 screencap_border[2] = new BC_Popup(device->mwindow->gui,
107 device->input_x - SCREENCAP_PIXELS, device->input_y + device->in_config->h,
108 device->in_config->w + SCREENCAP_PIXELS * 2, SCREENCAP_PIXELS,
110 screencap_border[3] = new BC_Popup(device->mwindow->gui,
111 device->input_x + device->in_config->w, device->input_y,
112 SCREENCAP_PIXELS, device->in_config->h,
115 for( int i=0; i<SCREENCAP_BORDERS; ++i ) {
116 BC_Popup *box = screencap_border[i];
117 box->set_bg_color(SCREENCAP_COLOR);
118 box->clear_box(0, 0, box->get_w(), box->get_h());
123 device->mwindow->gui->unlock_window();
128 int VDeviceX11::open_output()
131 output->lock_canvas("VDeviceX11::open_output");
132 output->get_canvas()->lock_window("VDeviceX11::open_output");
133 if( !device->single_frame )
134 output->start_video();
136 output->start_single();
137 output->get_canvas()->unlock_window();
139 // Enable opengl in the first routine that needs it, to reduce the complexity.
140 output->unlock_canvas();
146 int VDeviceX11::output_visible()
148 if( !output ) return 0;
150 output->lock_canvas("VDeviceX11::output_visible");
151 if( output->get_canvas()->get_hidden() ) {
152 output->unlock_canvas();
156 output->unlock_canvas();
162 int VDeviceX11::close_all()
165 output->lock_canvas("VDeviceX11::close_all 1");
166 output->get_canvas()->lock_window("VDeviceX11::close_all 1");
169 if( output && output_frame ) {
170 output->update_refresh(device, output_frame);
171 if( device->single_frame )
172 output->draw_refresh();
175 delete bitmap; bitmap = 0;
176 delete output_frame; output_frame = 0;
177 delete capture_bitmap; capture_bitmap = 0;
180 // Update the status bug
181 if( !device->single_frame ) {
182 output->stop_video();
185 output->stop_single();
188 output->get_canvas()->unlock_window();
189 output->unlock_canvas();
192 if( device->mwindow ) {
193 device->mwindow->gui->lock_window("VDeviceX11::close_all");
194 for( int i=0; i<SCREENCAP_BORDERS; ++i ) {
195 delete screencap_border[i];
196 screencap_border[i] = 0;
198 device->mwindow->gui->unlock_window();
206 int VDeviceX11::read_buffer(VFrame *frame)
208 //printf("VDeviceX11::read_buffer %d colormodel=%d\n", __LINE__, frame->get_color_model());
209 device->mwindow->gui->lock_window("VDeviceX11::close_all");
211 screencap_border[0]->reposition_window(device->input_x - SCREENCAP_PIXELS,
212 device->input_y - SCREENCAP_PIXELS);
213 screencap_border[1]->reposition_window(device->input_x - SCREENCAP_PIXELS,
215 screencap_border[2]->reposition_window(device->input_x - SCREENCAP_PIXELS,
216 device->input_y + device->in_config->h);
217 screencap_border[3]->reposition_window(device->input_x + device->in_config->w,
219 device->mwindow->gui->flush();
220 device->mwindow->gui->unlock_window();
223 capture_bitmap->capture_frame(frame,
224 device->input_x, device->input_y, device->do_cursor);
229 int VDeviceX11::get_best_colormodel(Asset *asset)
231 return File::get_best_colormodel(asset, SCREENCAPTURE);
236 int VDeviceX11::get_display_colormodel(int file_colormodel)
240 if( device->out_config->driver == PLAYBACK_X11_GL ) {
241 if( file_colormodel == BC_RGB888 ||
242 file_colormodel == BC_RGBA8888 ||
243 file_colormodel == BC_YUV888 ||
244 file_colormodel == BC_YUVA8888 ||
245 file_colormodel == BC_RGB_FLOAT ||
246 file_colormodel == BC_RGBA_FLOAT ) {
247 return file_colormodel;
253 if( !device->single_frame ) {
254 switch( file_colormodel ) {
258 result = file_colormodel;
263 // 2 more colormodels are supported by OpenGL
264 if( device->out_config->driver == PLAYBACK_X11_GL ) {
265 if( file_colormodel == BC_RGB_FLOAT ||
266 file_colormodel == BC_RGBA_FLOAT )
267 result = file_colormodel;
271 switch( file_colormodel ) {
278 result = file_colormodel;
282 output->lock_canvas("VDeviceX11::get_display_colormodel");
283 result = output->get_canvas()->get_color_model();
284 output->unlock_canvas();
293 void VDeviceX11::new_output_buffer(VFrame **result, int file_colormodel, EDL *edl)
295 // printf("VDeviceX11::new_output_buffer %d hardware_scaling=%d\n",
296 // __LINE__, bitmap ? bitmap->hardware_scaling() : 0);
297 output->lock_canvas("VDeviceX11::new_output_buffer");
298 output->get_canvas()->lock_window("VDeviceX11::new_output_buffer 1");
300 // Get the best colormodel the display can handle.
301 int display_colormodel = get_display_colormodel(file_colormodel);
303 //printf("VDeviceX11::new_output_buffer %d file_colormodel=%d display_colormodel=%d\n",
304 // __LINE__, file_colormodel, display_colormodel);
305 // Only create OpenGL Pbuffer and texture.
306 if( device->out_config->driver == PLAYBACK_X11_GL ) {
307 // Create bitmap for initial load into texture.
308 // Not necessary to do through Playback3D.....yet
309 if( !output_frame ) {
310 output_frame = new VFrame(device->out_w, device->out_h, file_colormodel);
313 window_id = output->get_canvas()->get_id();
314 output_frame->set_opengl_state(VFrame::RAM);
317 output->get_transfers(edl,
318 output_x1, output_y1, output_x2, output_y2,
319 canvas_x1, canvas_y1, canvas_x2, canvas_y2,
320 // Canvas may be a different size than the temporary bitmap for pure software
322 canvas_w = canvas_x2 - canvas_x1;
323 canvas_h = canvas_y2 - canvas_y1;
324 // can the direct frame be used?
325 int direct_supported =
326 device->out_config->use_direct_x11 &&
327 !output->xscroll && !output->yscroll &&
328 output_x1 == 0 && output_x2 == device->out_w &&
329 output_y1 == 0 && output_y2 == device->out_h;
331 // file wants direct frame but we need a temp
332 if( !direct_supported && file_colormodel == BC_BGR8888 )
333 file_colormodel = BC_RGB888;
335 // Conform existing bitmap to new colormodel and output size
337 // printf("VDeviceX11::new_output_buffer %d bitmap=%dx%d canvas=%dx%d canvas=%dx%d\n",
338 // __LINE__, bitmap->get_w(), bitmap->get_h(), canvas_w, canvas_h,);
340 bitmap->get_w() != canvas_w ||
341 bitmap->get_h() != canvas_h );
343 // Restart if output size changed or output colormodel changed.
344 // May have to recreate if transferring between windowed and fullscreen.
345 if( !color_model_selected ||
346 file_colormodel != output_frame->get_color_model() ||
347 (!bitmap->hardware_scaling() && size_change) ) {
348 //printf("VDeviceX11::new_output_buffer %d file_colormodel=%d prev "
349 // "file_colormodel=%d bitmap=%p output_frame=%p\n", __LINE__,
350 // file_colormodel, output_frame->get_color_model(), bitmap, output_frame);
351 delete bitmap; bitmap = 0;
352 delete output_frame; output_frame = 0;
353 // Clear borders if size changed
355 //printf("VDeviceX11::new_output_buffer %d w=%d h=%d "
356 // "canvas_x1=%d canvas_y1=%d canvas_x2=%d canvas_y2=%d\n",
357 // __LINE__, // (int)output->w, (int)output->h,
358 // (int)canvas_x1, (int)canvas_y1, (int)canvas_x2, (int)canvas_y2);
359 output->get_canvas()->set_color(BLACK);
361 if( canvas_y1 > 0 ) {
362 output->get_canvas()->draw_box(0, 0, output->w, canvas_y1);
363 output->get_canvas()->flash(0, 0, output->w, canvas_y1);
366 if( canvas_y2 < output->h ) {
367 output->get_canvas()->draw_box(0, canvas_y2, output->w, output->h - canvas_y2);
368 output->get_canvas()->flash(0, canvas_y2, output->w, output->h - canvas_y2);
371 if( canvas_x1 > 0 ) {
372 output->get_canvas()->draw_box(0, canvas_y1, canvas_x1, canvas_y2 - canvas_y1);
373 output->get_canvas()->flash(0, canvas_y1, canvas_x1, canvas_y2 - canvas_y1);
376 if( canvas_x2 < output->w ) {
377 output->get_canvas()->draw_box(canvas_x2, canvas_y1,
378 output->w - canvas_x2, canvas_y2 - canvas_y1);
379 output->get_canvas()->flash(canvas_x2, canvas_y1,
380 output->w - canvas_x2, canvas_y2 - canvas_y1);
389 bitmap_type = BITMAP_TEMP;
390 //printf("VDeviceX11::new_output_buffer %d file_colormodel=%d display_colormodel=%d\n",
391 // __LINE__, file_colormodel, display_colormodel);
393 // Try hardware accelerated
394 switch( display_colormodel ) {
395 // blit from the codec directly to the window, using the standard X11 color model.
396 // Must scale in the codec. No cropping
398 if( direct_supported ) {
399 bitmap_type = BITMAP_PRIMARY;
405 if( device->out_config->driver == PLAYBACK_X11_XV &&
406 output->get_canvas()->accel_available(display_colormodel, 0) &&
407 !output->use_scrollbars )
408 bitmap_type = BITMAP_PRIMARY;
412 if( device->out_config->driver == PLAYBACK_X11_XV &&
413 output->get_canvas()->accel_available(display_colormodel, 0) &&
414 !output->use_scrollbars )
415 bitmap_type = BITMAP_PRIMARY;
416 else if( device->out_config->driver == PLAYBACK_X11_XV &&
417 output->get_canvas()->accel_available(BC_YUV422, 0) ) {
418 bitmap = new BC_Bitmap(output->get_canvas(),
419 device->out_w, device->out_h, BC_YUV422, 1);
424 if( device->out_config->driver == PLAYBACK_X11_XV &&
425 output->get_canvas()->accel_available(display_colormodel, 0) &&
426 !output->use_scrollbars ) {
427 bitmap_type = BITMAP_PRIMARY;
429 else if( device->out_config->driver == PLAYBACK_X11_XV &&
430 output->get_canvas()->accel_available(BC_YUV422P, 0) ) {
431 bitmap = new BC_Bitmap(output->get_canvas(),
432 device->out_w, device->out_h, BC_YUV422P, 1);
436 if( bitmap_type == BITMAP_PRIMARY ) {
437 int bitmap_w = use_direct ? canvas_w : device->out_w;
438 int bitmap_h = use_direct ? canvas_h : device->out_h;
439 bitmap = new BC_Bitmap(output->get_canvas(),
440 bitmap_w, bitmap_h, display_colormodel, -1);
441 output_frame = new VFrame(bitmap,
442 bitmap_w, bitmap_h, display_colormodel, -1);
444 // Make an intermediate frame
446 display_colormodel = output->get_canvas()->get_color_model();
447 // printf("VDeviceX11::new_output_buffer %d creating temp display_colormodel=%d "
448 // "file_colormodel=%d %dx%d %dx%d %dx%d\n", __LINE__,
449 // display_colormodel, file_colormodel, device->out_w, device->out_h,
450 // output->get_canvas()->get_w(), output->get_canvas()->get_h(), canvas_w, canvas_h);
451 bitmap = new BC_Bitmap(output->get_canvas(),
452 canvas_w, canvas_h, display_colormodel, 1);
453 bitmap_type = BITMAP_TEMP;
456 if( bitmap_type == BITMAP_TEMP ) {
457 // Intermediate frame
458 //printf("VDeviceX11::new_output_buffer %d creating output_frame\n", __LINE__);
459 output_frame = new VFrame(device->out_w, device->out_h, file_colormodel);
461 color_model_selected = 1;
463 else if( bitmap_type == BITMAP_PRIMARY ) {
464 output_frame->set_memory(bitmap);
468 *result = output_frame;
469 //printf("VDeviceX11::new_output_buffer 10 %d\n", output->get_canvas()->get_window_lock());
471 output->get_canvas()->unlock_window();
472 output->unlock_canvas();
476 int VDeviceX11::start_playback()
478 // Record window is initialized when its monitor starts.
479 if( !device->single_frame )
480 output->start_video();
484 int VDeviceX11::stop_playback()
486 if( !device->single_frame )
487 output->stop_video();
488 // Record window goes back to monitoring
489 // get the last frame played and store it in the video_out
493 int VDeviceX11::write_buffer(VFrame *output_channels, EDL *edl)
495 output->lock_canvas("VDeviceX11::write_buffer");
496 output->get_canvas()->lock_window("VDeviceX11::write_buffer 1");
497 // if( device->out_config->driver == PLAYBACK_X11_GL &&
498 // output_frame->get_color_model() != BC_RGB888 ) {
499 // this is handled by overlay call in virtualvnode, using flatten alpha
500 // invoked when is_nested = -1 is passed to vdevicex11->overlay(...)
503 // printf("VDeviceX11::write_buffer %d %d bitmap_type=%d\n",
505 // output->get_canvas()->get_video_on(),
508 // int use_bitmap_extents = 0;
509 // canvas_w = -1; canvas_h = -1;
510 // // Canvas may be a different size than the temporary bitmap for pure software
511 // if( bitmap_type == BITMAP_TEMP && !bitmap->hardware_scaling() ) {
512 // canvas_w = bitmap->get_w();
513 // canvas_h = bitmap->get_h();
516 // output->get_transfers(edl,
517 // output_x1, output_y1, output_x2, output_y2,
518 // canvas_x1, canvas_y1, canvas_x2, canvas_y2,
519 // canvas_w, canvas_h);
521 // Convert colormodel
522 if( bitmap_type == BITMAP_TEMP ) {
523 // printf("VDeviceX11::write_buffer 1 %d %d, %d %d %d %d -> %d %d %d %d\n",
524 // output->w, output->h, in_x, in_y, in_w, in_h, out_x, out_y, out_w, out_h);
527 // printf("VDeviceX11::write_buffer %d output_channels=%p\n", __LINE__, output_channels);
528 // printf("VDeviceX11::write_buffer %d input color_model=%d output color_model=%d\n",
529 // __LINE__, output_channels->get_color_model(), bitmap->get_color_model());
530 if( bitmap->hardware_scaling() ) {
531 BC_CModels::transfer(bitmap->get_row_pointers(), output_channels->get_rows(), 0, 0, 0,
532 output_channels->get_y(), output_channels->get_u(), output_channels->get_v(),
533 0, 0, output_channels->get_w(), output_channels->get_h(),
534 0, 0, bitmap->get_w(), bitmap->get_h(),
535 output_channels->get_color_model(), bitmap->get_color_model(),
536 0, output_channels->get_w(), bitmap->get_w());
539 BC_CModels::transfer(bitmap->get_row_pointers(), output_channels->get_rows(), 0, 0, 0,
540 output_channels->get_y(), output_channels->get_u(), output_channels->get_v(),
541 (int)output_x1, (int)output_y1, (int)(output_x2 - output_x1), (int)(output_y2 - output_y1),
542 0, 0, (int)(canvas_x2 - canvas_x1), (int)(canvas_y2 - canvas_y1),
543 output_channels->get_color_model(), bitmap->get_color_model(),
544 0, output_channels->get_w(), bitmap->get_w());
548 //printf("VDeviceX11::write_buffer 4 %p\n", bitmap);
549 //for( i = 0; i < 1000; i += 4 ) bitmap->get_data()[i] = 128;
550 //printf("VDeviceX11::write_buffer 2 %d %d %d\n", bitmap_type,
551 // bitmap->get_color_model(),
552 // output->get_color_model());fflush(stdout);
554 // printf("VDeviceX11::write_buffer %d %dx%d %f %f %f %f -> %f %f %f %f\n",
555 // __LINE__, // output->w, output->h,
556 // output_x1, output_y1, output_x2, output_y2,
557 // canvas_x1, canvas_y1, canvas_x2, canvas_y2);
559 // Cause X server to display it
560 if( device->out_config->driver == PLAYBACK_X11_GL ) {
561 // Output is drawn in close_all if no video.
562 if( output->get_canvas()->get_video_on() ) {
563 canvas_w = -1; canvas_h = -1;
564 // Canvas may be a different size than the temporary bitmap for pure software
565 if( bitmap_type == BITMAP_TEMP &&
566 !bitmap->hardware_scaling() ) {
567 canvas_w = bitmap->get_w();
568 canvas_h = bitmap->get_h();
571 output->get_transfers(edl,
572 output_x1, output_y1, output_x2, output_y2,
573 canvas_x1, canvas_y1, canvas_x2, canvas_y2,
576 //printf("VDeviceX11::write_buffer %d\n", __LINE__);
577 // Draw output frame directly. Not used for compositing.
578 output->get_canvas()->unlock_window();
579 output->unlock_canvas();
580 output->mwindow->playback_3d->write_buffer(output, output_frame,
581 output_x1, output_y1, output_x2, output_y2,
582 canvas_x1, canvas_y1, canvas_x2, canvas_y2,
585 output->lock_canvas("VDeviceX11::write_buffer 2");
586 output->get_canvas()->lock_window("VDeviceX11::write_buffer 2");
590 if( bitmap->hardware_scaling() ) {
591 output->get_canvas()->draw_bitmap(bitmap, !device->single_frame,
592 (int)canvas_x1, (int)canvas_y1,
593 (int)(canvas_x2 - canvas_x1), (int)(canvas_y2 - canvas_y1),
594 (int)output_x1, (int)output_y1,
595 (int)(output_x2 - output_x1), (int)(output_y2 - output_y1),
599 //printf("VDeviceX11::write_buffer %d x=%d y=%d w=%d h=%d\n",
600 // __LINE__, (int)canvas_x1, (int)canvas_y1,
601 // output->get_canvas()->get_w(), output->get_canvas()->get_h());
603 output->get_canvas()->draw_bitmap(bitmap, !device->single_frame,
604 (int)canvas_x1, (int)canvas_y1,
605 (int)(canvas_x2 - canvas_x1), (int)(canvas_y2 - canvas_y1),
607 (int)(canvas_x2 - canvas_x1), (int)(canvas_y2 - canvas_y1),
609 //printf("VDeviceX11::write_buffer %d bitmap=%p\n", __LINE__, bitmap);
612 output->get_canvas()->unlock_window();
613 output->unlock_canvas();
618 void VDeviceX11::clear_output()
622 output->mwindow->playback_3d->clear_output(output,
623 output->get_canvas()->get_video_on() ? 0 : output_frame);
628 void VDeviceX11::clear_input(VFrame *frame)
630 this->output->mwindow->playback_3d->clear_input(this->output, frame);
633 void VDeviceX11::convert_cmodel(VFrame *output, int dst_cmodel)
635 this->output->mwindow->playback_3d->convert_cmodel(this->output,
640 void VDeviceX11::do_camera(VFrame *output, VFrame *input,
641 float in_x1, float in_y1, float in_x2, float in_y2,
642 float out_x1, float out_y1, float out_x2, float out_y2)
644 this->output->mwindow->playback_3d->do_camera(this->output,
646 in_x1, in_y1, in_x2, in_y2,
647 out_x1, out_y1, out_x2, out_y2);
651 void VDeviceX11::do_fade(VFrame *output_temp, float fade)
653 this->output->mwindow->playback_3d->do_fade(this->output, output_temp, fade);
656 bool VDeviceX11::can_mask(int64_t start_position_project, MaskAutos *keyframe_set)
659 MaskAuto *keyframe = (MaskAuto*)keyframe_set->
660 get_prev_auto(start_position_project, PLAY_FORWARD, current);
661 return keyframe->disable_opengl_masking ? 0 : 1;
664 void VDeviceX11::do_mask(VFrame *output_temp, int64_t start_position_project,
665 MaskAutos *keyframe_set, MaskAuto *keyframe, MaskAuto *default_auto)
667 this->output->mwindow->playback_3d->do_mask(output, output_temp,
668 start_position_project, keyframe_set, keyframe, default_auto);
671 void VDeviceX11::overlay(VFrame *output_frame, VFrame *input,
672 // This is the transfer from track to output frame
673 float in_x1, float in_y1, float in_x2, float in_y2,
674 float out_x1, float out_y1, float out_x2, float out_y2,
675 float alpha, // 0 - 1
676 int mode, EDL *edl, int is_nested)
678 int interpolation_type = edl->session->interpolation_type;
680 // printf("VDeviceX11::overlay 1:\n"
681 // "in_x1=%f in_y1=%f in_x2=%f in_y2=%f\n"
682 // "out_x1=%f out_y1=%f out_x2=%f out_y2=%f\n",
683 // in_x1, in_y1, in_x2, in_y2, out_x1, out_y1, out_x2, out_y2);
684 // Convert node coords to canvas coords in here
686 // If single frame playback or nested EDL, use full sized PBuffer as output.
687 if( device->single_frame || is_nested > 0 ) {
688 output->mwindow->playback_3d->overlay(output, input,
689 in_x1, in_y1, in_x2, in_y2,
690 out_x1, out_y1, out_x2, out_y2, alpha, // 0 - 1
691 mode, interpolation_type, output_frame, is_nested);
692 // printf("VDeviceX11::overlay 1 %p %d %d %d\n",
693 // output_frame, output_frame->get_w(), output_frame->get_h(),
694 // output_frame->get_opengl_state());
697 output->lock_canvas("VDeviceX11::overlay");
698 output->get_canvas()->lock_window("VDeviceX11::overlay");
700 // This is the transfer from output frame to canvas
701 output->get_transfers(edl,
702 output_x1, output_y1, output_x2, output_y2,
703 canvas_x1, canvas_y1, canvas_x2, canvas_y2,
706 output->get_canvas()->unlock_window();
707 output->unlock_canvas();
710 // Get transfer from track to canvas
711 float track_xscale = (out_x2 - out_x1) / (in_x2 - in_x1);
712 float track_yscale = (out_y2 - out_y1) / (in_y2 - in_y1);
713 float canvas_xscale = (float)(canvas_x2 - canvas_x1) / (output_x2 - output_x1);
714 float canvas_yscale = (float)(canvas_y2 - canvas_y1) / (output_y2 - output_y1);
717 // Get coordinates of canvas relative to track frame
718 float track_x1 = (float)(output_x1 - out_x1) / track_xscale + in_x1;
719 float track_y1 = (float)(output_y1 - out_y1) / track_yscale + in_y1;
720 float track_x2 = (float)(output_x2 - out_x2) / track_xscale + in_x2;
721 float track_y2 = (float)(output_y2 - out_y2) / track_yscale + in_y2;
723 // Clamp canvas coords to track boundary
725 float difference = -track_x1;
726 track_x1 += difference;
727 canvas_x1 += difference * track_xscale * canvas_xscale;
730 float difference = -track_y1;
731 track_y1 += difference;
732 canvas_y1 += difference * track_yscale * canvas_yscale;
735 if( track_x2 > input->get_w() ) {
736 float difference = track_x2 - input->get_w();
737 track_x2 -= difference;
738 canvas_x2 -= difference * track_xscale * canvas_xscale;
740 if( track_y2 > input->get_h() ) {
741 float difference = track_y2 - input->get_h();
742 track_y2 -= difference;
743 canvas_y2 -= difference * track_yscale * canvas_yscale;
746 // Overlay directly from track buffer to canvas, skipping output buffer
747 if( track_x2 > track_x1 && track_y2 > track_y1 &&
748 canvas_x2 > canvas_x1 && canvas_y2 > canvas_y1 ) {
749 output->mwindow->playback_3d->overlay(output, input,
750 track_x1, track_y1, track_x2, track_y2,
751 canvas_x1, canvas_y1, canvas_x2, canvas_y2, alpha, // 0 - 1
752 mode, interpolation_type, 0, is_nested);
757 void VDeviceX11::run_plugin(PluginClient *client)
759 output->mwindow->playback_3d->run_plugin(output, client);
762 void VDeviceX11::copy_frame(VFrame *dst, VFrame *src)
764 output->mwindow->playback_3d->copy_from(output, dst, src, 1);