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