cinelerra-5.1/cinelerra/recordmonitor.C

   1 /*
   2  * CINELERRA
   3  * Copyright (C) 2011 Adam Williams <broadcast at earthling dot net>
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18  *
  19  */
  20
  21 #include "asset.h"
  22 #include "bcdialog.h"
  23 #include "bcsignals.h"
  24 #include "channelpicker.h"
  25 #include "condition.h"
  26 #include "cursors.h"
  27 #include "devicedvbinput.h"
  28 #ifdef HAVE_DV
  29 #include "libdv.h"
  30 #endif
  31 #include "edl.h"
  32 #include "edlsession.h"
  33 #include "keys.h"
  34 #include "language.h"
  35 #include "mainsession.h"
  36 #include "meterpanel.h"
  37 #include "mwindow.h"
  38 #include "playbackconfig.h"
  39 #include "preferences.h"
  40 #include "record.h"
  41 #include "recordconfig.h"
  42 #include "recordgui.h"
  43 #include "recordscopes.h"
  44 #include "recordtransport.h"
  45 #include "recordmonitor.h"
  46 #include "signalstatus.h"
  47 #include "theme.h"
  48 #include "videodevice.inc"
  49 #include "vframe.h"
  50 #include "videodevice.h"
  51 #include "vdevicedvb.h"
  52
  53
  54 RecordMonitor::RecordMonitor(MWindow *mwindow, Record *record)
  55  : Thread(1, 0, 0)
  56 {
  57         this->mwindow = mwindow;
  58         this->record = record;
  59         device = 0;
  60         thread = 0;
  61         scope_thread = 0;
  62 }
  63
  64
  65 RecordMonitor::~RecordMonitor()
  66 {
  67         delete thread;
  68         window->set_done(0);
  69         Thread::join();
  70         if( device ) {
  71                 device->close_all();
  72                 delete device;
  73         }
  74         delete scope_thread;
  75         delete window;
  76 }
  77
  78 void RecordMonitor::create_objects()
  79 {
  80         int min_w = 150;
  81         mwindow->session->rwindow_fullscreen = 0;
  82
  83         if( !record->default_asset->video_data )
  84                 min_w = MeterPanel::get_meters_width(mwindow->theme,
  85                         record->default_asset->channels, 1);
  86
  87         window = new RecordMonitorGUI(mwindow, record, this, min_w);
  88         window->create_objects();
  89
  90         if( record->default_asset->video_data ) {
  91 // Configure the output for record monitoring
  92                 VideoOutConfig config;
  93                 device = new VideoDevice;
  94
  95 // Override default device for X11 drivers
  96                 if(mwindow->edl->session->playback_config->vconfig->driver ==
  97                         PLAYBACK_X11_XV) config.driver = PLAYBACK_X11_XV;
  98                 config.x11_use_fields = 0;
  99                 device->open_output(&config,
 100                         record->default_asset->frame_rate,
 101                         record->default_asset->width,
 102                         record->default_asset->height,
 103                         window->canvas, 0);
 104
 105                 scope_thread = new RecordScopeThread(mwindow, this);
 106
 107                 if(mwindow->session->record_scope) {
 108                         scope_thread->start();
 109                 }
 110
 111                 thread = new RecordMonitorThread(mwindow, record, this);
 112                 thread->start_playback();
 113         }
 114
 115         Thread::start();
 116 }
 117
 118
 119 void RecordMonitor::run()
 120 {
 121         window->run_window();
 122         close_threads();
 123 }
 124
 125 void RecordMonitor::close_threads()
 126 {
 127         if(window->channel_picker) window->channel_picker->close_threads();
 128 }
 129
 130 int RecordMonitor::update(VFrame *vframe)
 131 {
 132         return thread->write_frame(vframe);
 133 }
 134
 135 void RecordMonitor::update_channel(char *text)
 136 {
 137         if( window->channel_picker )
 138                 window->channel_picker->channel_text->update(text);
 139 }
 140
 141 int RecordMonitor::get_mbuttons_height()
 142 {
 143         return RECBUTTON_HEIGHT;
 144 }
 145
 146 void RecordMonitor::fix_size(int &w, int &h, int width_given, float aspect_ratio)
 147 {
 148         w = width_given;
 149         h = (int)((float)width_given / aspect_ratio);
 150 }
 151
 152 float RecordMonitor::get_scale(int w)
 153 {
 154         if( mwindow->edl->get_aspect_ratio() >
 155                 (float)record->frame_w / record->frame_h ) {
 156                 return (float)w /
 157                         ((float)record->frame_h *
 158                         mwindow->edl->get_aspect_ratio());
 159         }
 160         else {
 161                 return (float)w / record->frame_w;
 162         }
 163 }
 164
 165 int RecordMonitor::get_canvas_height()
 166 {
 167         return window->get_h() - get_mbuttons_height();
 168 }
 169
 170 int RecordMonitor::get_channel_x()
 171 {
 172 //      return 240;
 173         return 5;
 174 }
 175
 176 int RecordMonitor::get_channel_y()
 177 {
 178         return 2;
 179 }
 180
 181 void RecordMonitor::stop_playback()
 182 {
 183         if( !thread || thread->finished() ) return;
 184         window->enable_signal_status(0);
 185         if( thread ) {
 186                 thread->stop_playback();
 187         }
 188 }
 189
 190 void RecordMonitor::start_playback()
 191 {
 192         if( thread ) {
 193                 thread->output_lock->reset();
 194                 thread->start_playback();
 195         }
 196         window->enable_signal_status(1);
 197 }
 198
 199
 200 void RecordMonitor::reconfig()
 201 {
 202         stop_playback();
 203         VideoOutConfig config = *device->out_config;
 204         device->close_all();
 205         device->open_output(&config,
 206                 record->default_asset->frame_rate,
 207                 record->default_asset->width,
 208                 record->default_asset->height,
 209                 window->canvas, 0);
 210         start_playback();
 211         redraw();
 212 }
 213
 214 void RecordMonitor::redraw()
 215 {
 216         if( thread && window && thread->record->video_window_open )
 217                 window->redraw();
 218 }
 219
 220 void RecordMonitor::display_vframe(VFrame *in, int x, int y,
 221                 int alpha, double secs, double scale)
 222 {
 223         if( !thread ) return;
 224         thread->display_vframe(in, x, y, alpha, secs, scale);
 225 }
 226
 227 void RecordMonitor::undisplay_vframe()
 228 {
 229         if( !thread ) return;
 230         thread->undisplay_vframe();
 231 }
 232
 233 RecordMonitorGUI::RecordMonitorGUI(MWindow *mwindow,
 234         Record *record, RecordMonitor *thread, int min_w)
 235  : BC_Window(_(PROGRAM_NAME ": Video in"),
 236                         mwindow->session->rmonitor_x,
 237                         mwindow->session->rmonitor_y,
 238                         mwindow->session->rmonitor_w,
 239                         mwindow->session->rmonitor_h,
 240                         min_w, 50, 1, 1, 1, -1,
 241                         mwindow->get_cwindow_display())
 242 {
 243 //printf("%d %d\n", mwindow->session->rmonitor_w, mwindow->theme->rmonitor_meter_x);
 244         this->mwindow = mwindow;
 245         this->thread = thread;
 246         this->record = record;
 247 #ifdef HAVE_FIREWIRE
 248         avc = 0;
 249         avc1394_transport = 0;
 250         avc1394transport_title = 0;
 251         avc1394transport_timecode = 0;
 252         avc1394transport_thread = 0;
 253 #endif
 254         bitmap = 0;
 255         channel_picker = 0;
 256         reverse_interlace = 0;
 257         meters = 0;
 258         canvas = 0;
 259         cursor_toggle = 0;
 260         big_cursor_toggle = 0;
 261         current_operation = MONITOR_NONE;
 262         signal_status = 0;
 263 }
 264
 265 RecordMonitorGUI::~RecordMonitorGUI()
 266 {
 267         lock_window("RecordMonitorGUI::~RecordMonitorGUI");
 268 #ifdef HAVE_DVB
 269         delete signal_status;
 270 #endif
 271         delete canvas;
 272         delete cursor_toggle;
 273         delete big_cursor_toggle;
 274         delete bitmap;
 275         if( channel_picker ) delete channel_picker;
 276 #ifdef HAVE_FIREWIRE
 277         delete avc1394transport_thread;
 278         delete avc;
 279         delete avc1394_transport;
 280         delete avc1394transport_title;
 281 #endif
 282         delete meters;
 283         unlock_window();
 284 }
 285
 286 void RecordMonitorGUI::create_objects()
 287 {
 288 // y offset for video canvas if we have the transport controls
 289         lock_window("RecordMonitorGUI::create_objects");
 290         int driver = mwindow->edl->session->vconfig_in->driver;
 291         int do_channel = (driver == CAPTURE_DVB ||
 292                         driver == VIDEO4LINUX2 ||
 293                         driver == VIDEO4LINUX2JPEG ||
 294                         driver == VIDEO4LINUX2MPEG ||
 295                         driver == CAPTURE_JPEG_WEBCAM ||
 296                         driver == CAPTURE_YUYV_WEBCAM);
 297         int do_cursor = driver == SCREENCAPTURE;
 298         int do_scopes = do_channel || driver == SCREENCAPTURE;
 299         int do_interlace = driver == VIDEO4LINUX2JPEG;
 300         int background_done = 0;
 301         int do_audio = record->default_asset->audio_data;
 302         int do_video = record->default_asset->video_data;
 303         int do_meters = record->metering_audio;
 304         int channels = !do_meters ? 0 : record->default_asset->channels;
 305
 306         mwindow->theme->get_rmonitor_sizes(do_meters, do_video,
 307                 do_channel || do_scopes, do_interlace, 0, channels);
 308
 309
 310         if(do_video) {
 311 #ifdef HAVE_FIREWIRE
 312                 if( driver == CAPTURE_FIREWIRE || driver == CAPTURE_IEC61883 ) {
 313                         avc = new AVC1394Control;
 314                         if( avc->device > -1 ) {
 315                                 mwindow->theme->get_rmonitor_sizes(do_meters, do_video,
 316                                          do_channel, do_interlace, 1, channels);
 317                                 mwindow->theme->draw_rmonitor_bg(this);
 318                                 background_done = 1;
 319
 320                                 avc1394_transport = new AVC1394Transport(mwindow,
 321                                         avc,
 322                                         this,
 323                                         mwindow->theme->rmonitor_tx_x,
 324                                         mwindow->theme->rmonitor_tx_y);
 325                                 avc1394_transport->create_objects();
 326
 327                                 add_subwindow(avc1394transport_timecode =
 328                                         new BC_Title(avc1394_transport->x_end,
 329                                                 mwindow->theme->rmonitor_tx_y + 10,
 330                                                 "00:00:00:00",
 331                                                 MEDIUM_7SEGMENT,
 332                                                 BLACK));
 333
 334                                 avc1394transport_thread =
 335                                         new AVC1394TransportThread(avc1394transport_timecode,
 336                                                 avc);
 337
 338                                 avc1394transport_thread->start();
 339
 340                         }
 341                 }
 342 #endif
 343
 344                 if( !background_done ) {
 345                         mwindow->theme->draw_rmonitor_bg(this);
 346                         background_done = 1;
 347                 }
 348
 349                 mwindow->theme->rmonitor_canvas_w = MAX(10, mwindow->theme->rmonitor_canvas_w);
 350                 mwindow->theme->rmonitor_canvas_h = MAX(10, mwindow->theme->rmonitor_canvas_h);
 351                 canvas = new RecordMonitorCanvas(mwindow, this, record,
 352                         mwindow->theme->rmonitor_canvas_x,
 353                         mwindow->theme->rmonitor_canvas_y,
 354                         mwindow->theme->rmonitor_canvas_w,
 355                         mwindow->theme->rmonitor_canvas_h);
 356                 canvas->create_objects(0);
 357                 canvas->use_rwindow();
 358
 359 #ifdef HAVE_DVB
 360                 if( driver == CAPTURE_DVB ) {
 361                         int ssw = SignalStatus::calculate_w(this);
 362                         signal_status = new SignalStatus(this, get_w()-ssw-3, 0);
 363                         add_subwindow(signal_status);
 364                         signal_status->create_objects();
 365                 }
 366 #endif
 367
 368                 int x = mwindow->theme->widget_border;
 369                 int y = mwindow->theme->widget_border;
 370                 if( do_channel ) {
 371                         channel_picker = new RecordChannelPicker(mwindow,
 372                                 record, thread, this, record->channeldb,
 373                                 mwindow->theme->rmonitor_channel_x,
 374                                 mwindow->theme->rmonitor_channel_y);
 375                         channel_picker->create_objects();
 376                         x += channel_picker->get_w() + mwindow->theme->widget_border;
 377                 }
 378                 if( driver == VIDEO4LINUX2JPEG ) {
 379                         add_subwindow(reverse_interlace = new ReverseInterlace(record,
 380                                 mwindow->theme->rmonitor_interlace_x,
 381                                 mwindow->theme->rmonitor_interlace_y));
 382                         x += reverse_interlace->get_w() + mwindow->theme->widget_border;
 383                 }
 384
 385                 if( do_scopes ) {
 386                         scope_toggle = new ScopeEnable(mwindow, thread, x, y);
 387                         add_subwindow(scope_toggle);
 388                         x += scope_toggle->get_w() + mwindow->theme->widget_border;
 389                 }
 390
 391                 if( do_cursor ) {
 392                         add_subwindow(cursor_toggle = new DoCursor(record,
 393                                 x,
 394                                 y));
 395                         x += cursor_toggle->get_w() + mwindow->theme->widget_border;
 396                         add_subwindow(big_cursor_toggle = new DoBigCursor(record,
 397                                 x,
 398                                 y));
 399                         x += big_cursor_toggle->get_w() + mwindow->theme->widget_border;
 400                 }
 401
 402                 add_subwindow(monitor_menu = new BC_PopupMenu(0, 0, 0, "", 0));
 403                 monitor_menu->add_item(new RecordMonitorFullsize(mwindow, this));
 404         }
 405
 406
 407         if( !background_done ) {
 408                 mwindow->theme->draw_rmonitor_bg(this);
 409                 background_done = 1;
 410         }
 411
 412         if( do_audio ) {
 413                 meters = new MeterPanel(mwindow,
 414                         this,
 415                         mwindow->theme->rmonitor_meter_x,
 416                         mwindow->theme->rmonitor_meter_y,
 417                         record->default_asset->video_data ? -1 : mwindow->theme->rmonitor_meter_w,
 418                         mwindow->theme->rmonitor_meter_h,
 419                         channels, do_meters, 1, 0);
 420                 meters->create_objects();
 421         }
 422         unlock_window();
 423 }
 424
 425 int RecordMonitorGUI::button_press_event()
 426 {
 427         if(mwindow->session->rwindow_fullscreen && canvas && canvas->get_canvas())
 428                 return canvas->button_press_event_base(canvas->get_canvas());
 429
 430         if( get_buttonpress() == 2 ) {
 431                 return 0;
 432         }
 433         else
 434 // Right button
 435         if( get_buttonpress() == 3 ) {
 436                 monitor_menu->activate_menu();
 437                 return 1;
 438         }
 439         return 0;
 440 }
 441
 442 int RecordMonitorGUI::cursor_leave_event()
 443 {
 444         if(canvas && canvas->get_canvas())
 445                 return canvas->cursor_leave_event_base(canvas->get_canvas());
 446         return 0;
 447 }
 448
 449 int RecordMonitorGUI::cursor_enter_event()
 450 {
 451         if( canvas && canvas->get_canvas() )
 452                 return canvas->cursor_enter_event_base(canvas->get_canvas());
 453         return 0;
 454 }
 455
 456 int RecordMonitorGUI::button_release_event()
 457 {
 458         if( canvas && canvas->get_canvas() )
 459                 return canvas->button_release_event();
 460         return 0;
 461 }
 462
 463 int RecordMonitorGUI::cursor_motion_event()
 464 {
 465         if( canvas && canvas->get_canvas() ) {
 466                 canvas->get_canvas()->unhide_cursor();
 467                 return canvas->cursor_motion_event();
 468         }
 469         return 0;
 470 }
 471
 472 int RecordMonitorGUI::keypress_event()
 473 {
 474         int result = 0;
 475
 476         switch(get_keypress()) {
 477         case LEFT:
 478                 if( !ctrl_down() ) {
 479                         record->record_gui->set_translation(--(record->video_x), record->video_y, record->video_zoom);
 480                 }
 481                 else {
 482                         record->video_zoom -= 0.1;
 483                         record->record_gui->set_translation(record->video_x, record->video_y, record->video_zoom);
 484                 }
 485                 result = 1;
 486                 break;
 487         case RIGHT:
 488                 if( !ctrl_down() ) {
 489                         record->record_gui->set_translation(++(record->video_x), record->video_y, record->video_zoom);
 490                 }
 491                 else {
 492                         record->video_zoom += 0.1;
 493                         record->record_gui->set_translation(record->video_x, record->video_y, record->video_zoom);
 494                 }
 495                 result = 1;
 496                 break;
 497         case UP:
 498                 if( !ctrl_down() ) {
 499                         record->record_gui->set_translation(record->video_x, --(record->video_y), record->video_zoom);
 500                 }
 501                 else {
 502                         record->video_zoom -= 0.1;
 503                         record->record_gui->set_translation(record->video_x, record->video_y, record->video_zoom);
 504                 }
 505                 result = 1;
 506                 break;
 507         case DOWN:
 508                 if( !ctrl_down() ) {
 509                         record->record_gui->set_translation(record->video_x, ++(record->video_y), record->video_zoom);
 510                 }
 511                 else {
 512                         record->video_zoom += 0.1;
 513                         record->record_gui->set_translation(record->video_x, record->video_y, record->video_zoom);
 514                 }
 515                 result = 1;
 516                 break;
 517         case 'w':
 518                 close_event();
 519                 break;
 520
 521         default:
 522                 if(canvas) result = canvas->keypress_event(this);
 523 #ifdef HAVE_FIREWIRE
 524                 if(!result && avc1394_transport)
 525                         result = avc1394_transport->keypress_event(get_keypress());
 526 #endif
 527                 break;
 528         }
 529
 530         return result;
 531 }
 532
 533
 534 int RecordMonitorGUI::translation_event()
 535 {
 536 //printf("MWindowGUI::translation_event 1 %d %d\n", get_x(), get_y());
 537         mwindow->session->rmonitor_x = get_x();
 538         mwindow->session->rmonitor_y = get_y();
 539         return 0;
 540 }
 541
 542 int RecordMonitorGUI::resize_event(int w, int h)
 543 {
 544         int driver = mwindow->edl->session->vconfig_in->driver;
 545         int do_channel = (driver == CAPTURE_DVB ||
 546                         driver == VIDEO4LINUX2 ||
 547                         driver == VIDEO4LINUX2JPEG ||
 548                         driver == VIDEO4LINUX2MPEG ||
 549                         driver == CAPTURE_JPEG_WEBCAM ||
 550                         driver == CAPTURE_YUYV_WEBCAM);
 551         int do_scopes = do_channel || driver == SCREENCAPTURE;
 552         int do_interlace = (driver == VIDEO4LINUX2JPEG);
 553         int do_avc = 0;
 554 #ifdef HAVE_FIREWIRE
 555         do_avc = avc1394_transport ? 1 : 0;
 556 #endif
 557         int do_meters = meters && record->default_asset->audio_data &&
 558                 record->metering_audio;
 559         int do_video = record->default_asset->video_data;
 560
 561         mwindow->session->rmonitor_x = get_x();
 562         mwindow->session->rmonitor_y = get_y();
 563         mwindow->session->rmonitor_w = w;
 564         mwindow->session->rmonitor_h = h;
 565
 566         mwindow->theme->get_rmonitor_sizes(do_meters, do_video,
 567                 do_channel || do_scopes, do_interlace, do_avc,
 568                 record->default_asset->channels);
 569         mwindow->theme->draw_rmonitor_bg(this);
 570
 571
 572 //      record_transport->reposition_window(mwindow->theme->rmonitor_tx_x,
 573 //              mwindow->theme->rmonitor_tx_y);
 574 #ifdef HAVE_FIREWIRE
 575         if(avc1394_transport)
 576         {
 577                 avc1394_transport->reposition_window(mwindow->theme->rmonitor_tx_x,
 578                         mwindow->theme->rmonitor_tx_y);
 579         }
 580 #endif
 581
 582
 583         if( channel_picker ) {
 584                 channel_picker->reposition();
 585         }
 586         if( reverse_interlace ) {
 587                 reverse_interlace->reposition_window(
 588                         reverse_interlace->get_x(),
 589                         reverse_interlace->get_y());
 590         }
 591         if( cursor_toggle ) {
 592                 cursor_toggle->reposition_window(
 593                         cursor_toggle->get_x(),
 594                         cursor_toggle->get_y());
 595                 big_cursor_toggle->reposition_window(
 596                         big_cursor_toggle->get_x(),
 597                         big_cursor_toggle->get_y());
 598         }
 599
 600         if( canvas && do_video ) {
 601                 canvas->reposition_window(0,
 602                         mwindow->theme->rmonitor_canvas_x,
 603                         mwindow->theme->rmonitor_canvas_y,
 604                         mwindow->theme->rmonitor_canvas_w,
 605                         mwindow->theme->rmonitor_canvas_h);
 606         }
 607
 608         if( do_meters ) {
 609                 meters->reposition_window(mwindow->theme->rmonitor_meter_x,
 610                         mwindow->theme->rmonitor_meter_y,
 611                         do_video ? -1 : mwindow->theme->rmonitor_meter_w,
 612                         mwindow->theme->rmonitor_meter_h);
 613                 meters->set_meters(record->default_asset->channels,1);
 614         }
 615         else if( meters ) {
 616                 meters->set_meters(0,0);
 617         }
 618
 619         set_title();
 620         BC_WindowBase::resize_event(w, h);
 621         flash();
 622         return 1;
 623 }
 624
 625 int RecordMonitorGUI::redraw()
 626 {
 627         lock_window("RecordMonitorGUI::redraw");
 628         int w = mwindow->session->rmonitor_w;
 629         int h = mwindow->session->rmonitor_h;
 630         int result = resize_event(w, h);
 631         unlock_window();
 632         return result;
 633 }
 634
 635 int RecordMonitorGUI::set_title()
 636 {
 637 return 0;
 638         char string[1024];
 639         int scale;
 640
 641         scale = (int)(thread->get_scale(thread->record->video_window_w) * 100 + 0.5);
 642
 643         sprintf(string, _(PROGRAM_NAME ": Video in %d%%"), scale);
 644         BC_Window::set_title(string);
 645         return 0;
 646 }
 647
 648 int RecordMonitorGUI::close_event()
 649 {
 650         thread->record->set_video_monitoring(0);
 651         thread->record->set_audio_monitoring(0);
 652         thread->record->video_window_open = 0;
 653         unlock_window();
 654         lock_window("RecordMonitorGUI::close_event");
 655         hide_window();
 656         return 0;
 657 }
 658
 659 int RecordMonitorGUI::create_bitmap()
 660 {
 661         if(bitmap && (bitmap->get_w() != get_w() ||
 662                         bitmap->get_h() != thread->get_canvas_height())) {
 663                 delete bitmap;
 664                 bitmap = 0;
 665         }
 666
 667         if( !bitmap && canvas ) {
 668 //              bitmap = canvas->new_bitmap(get_w(), thread->get_canvas_height());
 669         }
 670         return 0;
 671 }
 672
 673
 674 DoCursor::DoCursor(Record *record, int x, int y)
 675  : BC_CheckBox(x, y, record->do_cursor, _("Record cursor"))
 676 {
 677         this->record = record;
 678 }
 679
 680 DoCursor::~DoCursor()
 681 {
 682 }
 683
 684 int DoCursor::handle_event()
 685 {
 686         record->do_cursor = get_value();
 687         return 0;
 688 }
 689
 690
 691 DoBigCursor::DoBigCursor(Record *record, int x, int y)
 692  : BC_CheckBox(x, y, record->do_big_cursor, _("Big cursor"))
 693 {
 694         this->record = record;
 695 }
 696
 697 DoBigCursor::~DoBigCursor()
 698 {
 699 }
 700
 701 int DoBigCursor::handle_event()
 702 {
 703         record->do_big_cursor = get_value();
 704         return 0;
 705 }
 706
 707
 708 void RecordMonitorGUI::enable_signal_status(int enable)
 709 {
 710 #ifdef HAVE_DVB
 711         if( !signal_status ) return;
 712         signal_status->lock_window("RecordMonitorGUI::enable_signal_status");
 713         if( !enable )
 714                 signal_status->hide_window();
 715         else
 716                 signal_status->show_window();
 717         signal_status->unlock_window();
 718         DeviceDVBInput *dvb_input = record->dvb_device();
 719         if( dvb_input )
 720                 dvb_input->set_signal_status(!enable ? 0 : signal_status);
 721 #endif
 722 }
 723
 724 void RecordMonitorGUI::
 725 display_video_text(int x, int y, const char *text, int font,
 726         int bg_color, int color, int alpha, double secs, double scale)
 727 {
 728         lock_window("RecordMonitorGUI::display_text");
 729         set_font(font);
 730         int ch = get_text_height(font);
 731         int h = get_text_height(font,text) + ch/2;
 732         int w = get_text_width(font, text) + ch;
 733         BC_Pixmap pixmap(this, w, h);
 734         set_opaque();
 735         set_color(bg_color);
 736         draw_box(0, 0, w, h, &pixmap);
 737         set_color(color);
 738         draw_text(ch/2, ch, text, strlen(text), &pixmap);
 739         BC_Bitmap bitmap(this, w, h, BC_RGB888, 0);
 740         VFrame in(&bitmap, w, h, BC_RGB888, -1);
 741         Drawable drawable = pixmap.get_pixmap();
 742         bitmap.read_drawable(drawable, 0, 0, &in);
 743         unlock_window();
 744         record->display_vframe(&in, x, y, alpha, secs, scale);
 745 }
 746
 747 ReverseInterlace::ReverseInterlace(Record *record, int x, int y)
 748  : BC_CheckBox(x, y, record->reverse_interlace, _("Swap fields"))
 749 {
 750         this->record = record;
 751 }
 752
 753 ReverseInterlace::~ReverseInterlace()
 754 {
 755 }
 756
 757 int ReverseInterlace::handle_event()
 758 {
 759         record->reverse_interlace = get_value();
 760         return 0;
 761 }
 762
 763 RecordMonitorCanvas::RecordMonitorCanvas(MWindow *mwindow,
 764         RecordMonitorGUI *window, Record *record,
 765         int x, int y, int w, int h)
 766  : Canvas(mwindow, window, x, y, w, h,
 767         record->default_asset->width,
 768         record->default_asset->height,
 769         0)
 770 {
 771         this->window = window;
 772         this->mwindow = mwindow;
 773         this->record = record;
 774 //printf("RecordMonitorCanvas::RecordMonitorCanvas 1 %d %d %d %d\n",
 775 //x, y, w, h);
 776 //printf("RecordMonitorCanvas::RecordMonitorCanvas 2\n");
 777 }
 778
 779 RecordMonitorCanvas::~RecordMonitorCanvas()
 780 {
 781 }
 782
 783 int RecordMonitorCanvas::get_output_w()
 784 {
 785         return record->default_asset->width;
 786 }
 787
 788 int RecordMonitorCanvas::get_output_h()
 789 {
 790         return record->default_asset->height;
 791 }
 792
 793
 794 int RecordMonitorCanvas::button_press_event()
 795 {
 796
 797         if(Canvas::button_press_event()) return 1;
 798         if( mwindow->edl->session->vconfig_in->driver == SCREENCAPTURE ) {
 799                 window->current_operation = MONITOR_TRANSLATE;
 800                 window->translate_x_origin = record->video_x;
 801                 window->translate_y_origin = record->video_y;
 802                 window->cursor_x_origin = get_cursor_x();
 803                 window->cursor_y_origin = get_cursor_y();
 804         }
 805
 806         return 0;
 807 }
 808
 809 void RecordMonitorCanvas::zoom_resize_window(float percentage)
 810 {
 811         int canvas_w, canvas_h;
 812         calculate_sizes(mwindow->edl->get_aspect_ratio(),
 813                 record->default_asset->width, record->default_asset->height,
 814                 percentage, canvas_w, canvas_h);
 815         int new_w, new_h;
 816         new_w = canvas_w + (window->get_w() - mwindow->theme->rmonitor_canvas_w);
 817         new_h = canvas_h + (window->get_h() - mwindow->theme->rmonitor_canvas_h);
 818         window->resize_window(new_w, new_h);
 819         window->resize_event(new_w, new_h);
 820 }
 821
 822 int RecordMonitorCanvas::get_fullscreen()
 823 {
 824         return mwindow->session->rwindow_fullscreen;
 825 }
 826
 827 void RecordMonitorCanvas::set_fullscreen(int value)
 828 {
 829         mwindow->session->rwindow_fullscreen = value;
 830 }
 831
 832
 833 int RecordMonitorCanvas::button_release_event()
 834 {
 835         window->current_operation = MONITOR_NONE;
 836         return 0;
 837 }
 838
 839 int RecordMonitorCanvas::cursor_motion_event()
 840 {
 841 //SET_TRACE
 842         if( window->current_operation == MONITOR_TRANSLATE ) {
 843 //SET_TRACE
 844                 record->set_translation(
 845                         get_cursor_x() - window->cursor_x_origin + window->translate_x_origin,
 846                         get_cursor_y() - window->cursor_y_origin + window->translate_y_origin);
 847 //SET_TRACE
 848         }
 849
 850         return 0;
 851 }
 852
 853 int RecordMonitorCanvas::cursor_enter_event()
 854 {
 855         if(mwindow->edl->session->vconfig_in->driver == SCREENCAPTURE)
 856                 set_cursor(MOVE_CURSOR);
 857         return 0;
 858 }
 859
 860 void RecordMonitorCanvas::reset_translation()
 861 {
 862         record->set_translation(0, 0);
 863 }
 864
 865 int RecordMonitorCanvas::keypress_event()
 866 {
 867         if( !get_canvas() ) return 0;
 868
 869         switch(get_canvas()->get_keypress()) {
 870         case LEFT:
 871                 record->set_translation(--record->video_x, record->video_y);
 872                 break;
 873         case RIGHT:
 874                 record->set_translation(++record->video_x, record->video_y);
 875                 break;
 876         case UP:
 877                 record->set_translation(record->video_x, --record->video_y);
 878                 break;
 879         case DOWN:
 880                 record->set_translation(record->video_x, ++record->video_y);
 881                 break;
 882         default:
 883                 return 0;
 884         }
 885         return 1;
 886 }
 887
 888
 889 RecordMonitorFullsize::RecordMonitorFullsize(MWindow *mwindow,
 890         RecordMonitorGUI *window)
 891  : BC_MenuItem(_("Zoom 100%"))
 892 {
 893         this->mwindow = mwindow;
 894         this->window = window;
 895 }
 896 int RecordMonitorFullsize::handle_event()
 897 {
 898         return 1;
 899 }
 900
 901
 902
 903
 904
 905
 906
 907
 908 // ================================== slippery playback ============================
 909
 910
 911 RecordMonitorThread::RecordMonitorThread(MWindow *mwindow,
 912         Record *record,
 913         RecordMonitor *record_monitor)
 914  : Thread(1, 0, 0)
 915 {
 916         this->mwindow = mwindow;
 917         this->record_monitor = record_monitor;
 918         this->record = record;
 919         this->ovly = 0;
 920         reset_parameters();
 921         output_lock = new Condition(1, "RecordMonitor::output_lock");
 922         input_lock = new Condition(1, "RecordMonitor::input_lock");
 923 }
 924
 925 void RecordMonitorThread::reset_parameters()
 926 {
 927         input_frame = 0;
 928         output_frame = 0;
 929         shared_data = 0;
 930         jpeg_engine = 0;
 931         dv_engine = 0;
 932         ready = 0;
 933         done = 1;
 934 }
 935
 936
 937 RecordMonitorThread::~RecordMonitorThread()
 938 {
 939         stop_playback();
 940         if( input_frame && !shared_data )
 941                 delete input_frame;
 942         delete ovly;
 943         delete output_lock;
 944         delete input_lock;
 945 }
 946
 947 void RecordMonitorThread::init_output_format()
 948 {
 949 //printf("RecordMonitorThread::init_output_format 1\n");
 950         switch(mwindow->edl->session->vconfig_in->driver) {
 951         case SCREENCAPTURE:
 952                 output_colormodel = record->vdevice->get_best_colormodel(record->default_asset);
 953                 break;
 954
 955         case VIDEO4LINUX2JPEG:
 956                 jpeg_engine = new RecVideoMJPGThread(record, this,
 957                         mwindow->edl->session->vconfig_in->v4l2jpeg_in_fields);
 958                 jpeg_engine->start_rendering();
 959                 output_colormodel = BC_YUV422P;
 960                 break;
 961
 962         case CAPTURE_FIREWIRE:
 963         case CAPTURE_IEC61883:
 964                 dv_engine = new RecVideoDVThread(record, this);
 965                 dv_engine->start_rendering();
 966                 output_colormodel = BC_YUV422P;
 967                 break;
 968
 969         case CAPTURE_JPEG_WEBCAM:
 970                 jpeg_engine = new RecVideoMJPGThread(record, this, 1);
 971                 jpeg_engine->start_rendering();
 972                 output_colormodel = BC_YUV420P;
 973                 break;
 974
 975         case CAPTURE_YUYV_WEBCAM:
 976                 output_colormodel = BC_YUV422;
 977                 break;
 978
 979
 980         case CAPTURE_DVB:
 981         case VIDEO4LINUX2:
 982         case VIDEO4LINUX2MPEG:
 983                 output_colormodel = record->vdevice->get_best_colormodel(record->default_asset);
 984 //printf("RecordMonitorThread::init_output_format 2 %d\n", output_colormodel);
 985                 break;
 986         }
 987 }
 988
 989 int RecordMonitorThread::start_playback()
 990 {
 991         ready = 1;
 992         done = 0;
 993         output_frame = 0;
 994         output_lock->lock("RecordMonitorThread::start_playback");
 995         Thread::start();
 996         return 0;
 997 }
 998
 999 int RecordMonitorThread::stop_playback()
1000 {
1001         if( done ) return 0;
1002         done = 1;
1003         output_lock->unlock();
1004         Thread::join();
1005 //printf("RecordMonitorThread::stop_playback 1\n");
1006
1007         switch(mwindow->edl->session->vconfig_in->driver) {
1008         case VIDEO4LINUX2JPEG:
1009                 if( jpeg_engine ) {
1010                         jpeg_engine->stop_rendering();
1011                         delete jpeg_engine;
1012                         jpeg_engine = 0;
1013                 }
1014                 break;
1015
1016         case CAPTURE_FIREWIRE:
1017         case CAPTURE_IEC61883:
1018                 if( dv_engine ) {
1019                         dv_engine->stop_rendering();
1020                         delete dv_engine;
1021                         dv_engine = 0;
1022                 }
1023                 break;
1024         case CAPTURE_DVB:
1025         case VIDEO4LINUX2MPEG:
1026                 break;
1027         }
1028 //printf("RecordMonitorThread::stop_playback 4\n");
1029
1030         return 0;
1031 }
1032
1033 int RecordMonitorThread::write_frame(VFrame *new_frame)
1034 {
1035         if( ready ) {
1036                 ready = 0;
1037                 shared_data = (new_frame->get_color_model() != BC_COMPRESSED);
1038
1039
1040 // Need to wait until after Record creates the input device before starting monitor
1041 // because the input device deterimes the output format.
1042 // First time
1043                 if( !output_frame ) init_output_format();
1044                 if( !shared_data ) {
1045                         if(!input_frame) input_frame = new VFrame;
1046                         input_frame->allocate_compressed_data(new_frame->get_compressed_size());
1047                         memcpy(input_frame->get_data(),
1048                                 new_frame->get_data(),
1049                                 new_frame->get_compressed_size());
1050                         input_frame->set_compressed_size(new_frame->get_compressed_size());
1051                         input_frame->set_field2_offset(new_frame->get_field2_offset());
1052                 }
1053                 else {
1054                         input_lock->lock("RecordMonitorThread::write_frame");
1055                         input_frame = new_frame;
1056                 }
1057                 output_lock->unlock();
1058         }
1059         return 0;
1060 }
1061
1062 int RecordMonitorThread::render_jpeg()
1063 {
1064 //printf("RecordMonitorThread::render_jpeg 1\n");
1065         jpeg_engine->render_frame(input_frame, input_frame->get_compressed_size());
1066 //printf("RecordMonitorThread::render_jpeg 2\n");
1067         return 0;
1068 }
1069
1070 int RecordMonitorThread::render_dv()
1071 {
1072         dv_engine->render_frame(input_frame, input_frame->get_compressed_size());
1073         return 0;
1074 }
1075
1076 void RecordMonitorThread::render_uncompressed()
1077 {
1078         output_frame->transfer_from(input_frame);
1079 }
1080
1081 void RecordMonitorThread::show_output_frame()
1082 {
1083         if( ovly && ovly->overlay(output_frame) )
1084                 undisplay_vframe();
1085         record_monitor->device->write_buffer(output_frame, record->edl);
1086 }
1087
1088
1089 void RecordMonitorThread::unlock_input()
1090 {
1091         if(shared_data) input_lock->unlock();
1092 }
1093
1094 void RecordMonitorThread::lock_input()
1095 {
1096         if(shared_data) input_lock->lock();
1097 }
1098
1099 int RecordMonitorThread::render_frame()
1100 {
1101         switch(mwindow->edl->session->vconfig_in->driver) {
1102         case VIDEO4LINUX2JPEG:
1103         case CAPTURE_JPEG_WEBCAM:
1104                 render_jpeg();
1105                 break;
1106
1107         case CAPTURE_FIREWIRE:
1108         case CAPTURE_IEC61883:
1109                 render_dv();
1110                 break;
1111
1112         default:
1113                 render_uncompressed();
1114                 break;
1115         }
1116
1117         return 0;
1118 }
1119
1120 void RecordMonitorThread::new_output_frame()
1121 {
1122         record_monitor->device->new_output_buffer(&output_frame,
1123                 output_colormodel,
1124                 record->edl);
1125 }
1126
1127 void RecordMonitorThread::
1128 display_vframe(VFrame *in, int x, int y, int alpha, double secs, double scale)
1129 {
1130         delete ovly;
1131         int ticks = secs * SESSION->vconfig_in->in_framerate;
1132         scale *= SESSION->vconfig_in->h / 1080.;
1133         ovly = new RecVideoOverlay(in, x, y, ticks, scale, alpha/255.);
1134 }
1135
1136 RecVideoOverlay::
1137 RecVideoOverlay(VFrame *vframe, int x, int y, int ticks, float scale, float alpha)
1138 {
1139         this->x = x;
1140         this->y = y;
1141         this->ticks = ticks;
1142         this->scale = scale;
1143         this->alpha = alpha;
1144         this->vframe = new VFrame(*vframe);
1145 }
1146
1147 RecVideoOverlay::
1148 ~RecVideoOverlay()
1149 {
1150         delete vframe;
1151 }
1152
1153 int RecVideoOverlay::
1154 overlay(VFrame *out)
1155 {
1156         VFrame *in = vframe;
1157         int xx = x * scale, yy = y * scale;
1158         int w = in->get_w(), h = in->get_h();
1159         int ww = w * scale, hh = h * scale;
1160         BC_CModels::transfer(out->get_rows(), in->get_rows(),
1161                 out->get_y(), out->get_u(), out->get_v(),
1162                 in->get_y(), in->get_u(), in->get_v(),
1163                 0, 0, w, h, xx, yy, ww, hh,
1164                 in->get_color_model(), out->get_color_model(), 0,
1165                 in->get_bytes_per_line(), out->get_bytes_per_line());
1166         return ticks > 0 && --ticks == 0 ? 1 : 0;
1167 }
1168
1169 void RecordMonitorThread::
1170 undisplay_vframe()
1171 {
1172         delete ovly;  ovly = 0;
1173 }
1174
1175 void RecordMonitorThread::run()
1176 {
1177 //printf("RecordMonitorThread::run 1 %d\n", getpid());
1178         while(!done) {
1179 // Wait for next frame
1180 //SET_TRACE
1181                 output_lock->lock("RecordMonitorThread::run");
1182
1183                 if(done) {
1184                         unlock_input();
1185                         return;
1186                 }
1187 //SET_TRACE
1188                 new_output_frame();
1189 //SET_TRACE
1190                 render_frame();
1191 //SET_TRACE
1192                 record_monitor->scope_thread->process(output_frame);
1193 //SET_TRACE
1194                 show_output_frame();
1195 //SET_TRACE
1196                 unlock_input();
1197 // Get next frame
1198                 ready = 1;
1199         }
1200 }
1201
1202
1203
1204 RecVideoMJPGThread::RecVideoMJPGThread(Record *record,
1205         RecordMonitorThread *thread,
1206         int fields)
1207 {
1208         this->record = record;
1209         this->thread = thread;
1210         mjpeg = 0;
1211         this->fields = fields;
1212 }
1213
1214 RecVideoMJPGThread::~RecVideoMJPGThread()
1215 {
1216 }
1217
1218 int RecVideoMJPGThread::start_rendering()
1219 {
1220         mjpeg = mjpeg_new(record->default_asset->width,
1221                 record->default_asset->height,
1222                 fields);
1223 //printf("RecVideoMJPGThread::start_rendering 1 %p\n", mjpeg);
1224         return 0;
1225 }
1226
1227 int RecVideoMJPGThread::stop_rendering()
1228 {
1229 //printf("RecVideoMJPGThread::stop_rendering 1 %p\n", mjpeg);
1230         if(mjpeg) mjpeg_delete(mjpeg);
1231 //printf("RecVideoMJPGThread::stop_rendering 2\n");
1232         return 0;
1233 }
1234
1235 int RecVideoMJPGThread::render_frame(VFrame *frame, long size)
1236 {
1237 // printf("RecVideoMJPGThread::render_frame %d %02x%02x %02x%02x\n",
1238 // frame->get_field2_offset(),
1239 // frame->get_data()[0],
1240 // frame->get_data()[1],
1241 // frame->get_data()[frame->get_field2_offset()],
1242 // frame->get_data()[frame->get_field2_offset() + 1]);
1243 //frame->set_field2_offset(0);
1244         mjpeg_decompress(mjpeg,
1245                 frame->get_data(),
1246                 frame->get_compressed_size(),
1247                 frame->get_field2_offset(),
1248                 thread->output_frame->get_rows(),
1249                 thread->output_frame->get_y(),
1250                 thread->output_frame->get_u(),
1251                 thread->output_frame->get_v(),
1252                 thread->output_frame->get_color_model(),
1253                 record->mwindow->preferences->processors);
1254         return 0;
1255 }
1256
1257
1258
1259
1260 RecVideoDVThread::RecVideoDVThread(Record *record, RecordMonitorThread *thread)
1261 {
1262         this->record = record;
1263         this->thread = thread;
1264         dv = 0;
1265 }
1266
1267 RecVideoDVThread::~RecVideoDVThread()
1268 {
1269 }
1270
1271
1272 int RecVideoDVThread::start_rendering()
1273 {
1274 #ifdef HAVE_DV
1275         dv = dv_new();
1276 #endif
1277         return 0;
1278 }
1279
1280 int RecVideoDVThread::stop_rendering()
1281 {
1282 #ifdef HAVE_DV
1283         if( dv ) { dv_delete(((dv_t*)dv));  dv = 0; }
1284 #endif
1285         return 0;
1286 }
1287
1288 int RecVideoDVThread::render_frame(VFrame *frame, long size)
1289 {
1290 #ifdef HAVE_DV
1291         unsigned char *yuv_planes[3];
1292         yuv_planes[0] = thread->output_frame->get_y();
1293         yuv_planes[1] = thread->output_frame->get_u();
1294         yuv_planes[2] = thread->output_frame->get_v();
1295         dv_read_video(((dv_t*)dv),
1296                 yuv_planes,
1297                 frame->get_data(),
1298                 frame->get_compressed_size(),
1299                 thread->output_frame->get_color_model());
1300 #endif
1301         return 0;
1302 }
1303