cinelerra-5.0/cinelerra/videodevice.C

   1
   2 /*
   3  * CINELERRA
   4  * Copyright (C) 2008-2013 Adam Williams <broadcast at earthling dot net>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  *
  20  */
  21
  22 #include "asset.h"
  23 #include "assets.h"
  24 #include "bccapture.h"
  25 #include "bcsignals.h"
  26 #include "channel.h"
  27 #include "channeldb.h"
  28 #include "chantables.h"
  29 #include "edl.h"
  30 #include "edlsession.h"
  31 #include "file.inc"
  32 #include "../hvirtual_config.h"
  33 #include "mainmenu.h"
  34 #include "mutex.h"
  35 #include "mwindow.h"
  36 #include "mwindowgui.h"
  37 #include "picture.h"
  38 #include "playbackconfig.h"
  39 #include "playbackengine.h"
  40 #include "preferences.h"
  41 #include "recordconfig.h"
  42 #include "recordgui.h"
  43 #include "recordmonitor.h"
  44 #include "record.h"
  45 #include "vdevice1394.h"
  46 #include "vdevicebuz.h"
  47 #include "vdevicedvb.h"
  48 #include "vdevicev4l.h"
  49 #include "vdevicev4l2.h"
  50 #include "vdevicev4l2jpeg.h"
  51 #include "vdevicev4l2mpeg.h"
  52 #include "vdevicex11.h"
  53 #include "videoconfig.h"
  54 #include "videodevice.h"
  55 #include "videowindow.h"
  56 #include "videowindowgui.h"
  57 #include "vframe.h"
  58
  59 #include <unistd.h>
  60 #include <fcntl.h>
  61
  62 KeepaliveThread::KeepaliveThread(VideoDevice *device)
  63  : Thread(1, 0, 0)
  64 {
  65         still_alive = 1;
  66         failed = 0;
  67         interrupted = 0;
  68         set_synchronous(1);
  69         this->device = device;
  70         capturing = 0;
  71         startup_lock = new Mutex("KeepaliveThread::startup_lock");
  72 }
  73
  74 KeepaliveThread::~KeepaliveThread()
  75 {
  76         delete startup_lock;
  77 }
  78
  79 int KeepaliveThread::start_keepalive()
  80 {
  81         startup_lock->lock("KeepaliveThread::start_keepalive 1");
  82         start();
  83         startup_lock->lock("KeepaliveThread::start_keepalive 2");
  84         startup_lock->unlock();
  85         return 0;
  86 }
  87
  88 void KeepaliveThread::run()
  89 {
  90         startup_lock->unlock();
  91         while(!interrupted)
  92         {
  93                 still_alive = 0;
  94 // Give the capture a moment
  95 // Should fix the delay in case users want slower frame rates.
  96                 timer.delay((long)(KEEPALIVE_DELAY * 1000));
  97
  98 // See if a capture happened
  99                 if(still_alive == 0 && capturing)
 100                 {
 101 //                      printf("KeepaliveThread::run: device crashed\n");
 102                         failed++;
 103                 }
 104                 else
 105                         failed = 0;
 106         }
 107 }
 108
 109 int KeepaliveThread::reset_keepalive()
 110 {
 111         still_alive = 1;
 112         return 0;
 113 }
 114
 115 int KeepaliveThread::get_failed()
 116 {
 117         if(failed) return 1; else return 0;
 118 }
 119
 120 int KeepaliveThread::stop()
 121 {
 122         interrupted = 1;
 123
 124 // Force an immediate exit even if capture_frame worked.
 125         Thread::cancel();
 126         Thread::join();
 127         return 0;
 128 }
 129
 130
 131
 132
 133
 134
 135
 136 VideoDevice::VideoDevice(MWindow *mwindow)
 137 {
 138         this->mwindow = mwindow;
 139         in_config = new VideoInConfig;
 140         out_config = new VideoOutConfig;
 141         channel = new Channel;
 142         picture = new PictureConfig();
 143         sharing_lock = new Mutex("VideoDevice::sharing_lock");
 144         channel_lock = new Mutex("VideoDevice::channel_lock");
 145         picture_lock = new Mutex("VideoDevice::picture_lock");
 146         initialize();
 147 }
 148
 149
 150 VideoDevice::~VideoDevice()
 151 {
 152         input_sources.remove_all_objects();
 153         delete in_config;
 154         delete out_config;
 155         delete channel;
 156         delete picture;
 157         delete sharing_lock;
 158         delete channel_lock;
 159         delete picture_lock;
 160 }
 161
 162 int VideoDevice::initialize()
 163 {
 164         sharing = 0;
 165         done_sharing = 0;
 166         sharing_lock->reset();
 167         orate = irate = 0;
 168         out_w = out_h = 0;
 169         r = w = 0;
 170         is_playing_back = is_recording = 0;
 171         input_x = 0;
 172         input_y = 0;
 173         input_z = 1;
 174         frame_resized = 0;
 175         frame_rate = 0;
 176         timestamp = -1.;
 177         capturing = 0;
 178         keepalive = 0;
 179         swap_bytes = 0;
 180         in_config_updated = 0;
 181         input_base = 0;
 182         output_base = 0;
 183         output_format = 0;
 184         interrupt = 0;
 185         adevice = 0;
 186         quality = 80;
 187         cpus = 1;
 188         single_frame = 0;
 189         channel_changed = 0;
 190         picture_changed = 0;
 191         return 0;
 192 }
 193
 194 int VideoDevice::open_input(VideoInConfig *config,
 195         int input_x,
 196         int input_y,
 197         float input_z,
 198         double frame_rate)
 199 {
 200         int result = 0;
 201
 202         *this->in_config = *config;
 203
 204         r = 1;
 205         this->input_z = -1;   // Force initialization.
 206         this->frame_rate = frame_rate;
 207         if( input_base ) return 1; // device already open
 208
 209         switch(in_config->driver) {
 210                 case VIDEO4LINUX:
 211                         keepalive = new KeepaliveThread(this);
 212                         keepalive->start_keepalive();
 213                         break;
 214
 215
 216 #ifdef HAVE_VIDEO4LINUX2
 217
 218                 case VIDEO4LINUX2:
 219                 case VIDEO4LINUX2JPEG:
 220                 case VIDEO4LINUX2MPEG:
 221                 case CAPTURE_JPEG_WEBCAM:
 222                 case CAPTURE_YUYV_WEBCAM:
 223                         break;
 224
 225 #endif
 226
 227                 case SCREENCAPTURE:
 228                         this->input_x = input_x;
 229                         this->input_y = input_y;
 230                         break;
 231                 case CAPTURE_LML:
 232                 case CAPTURE_BUZ:
 233 //printf("VideoDevice 1\n");
 234                         keepalive = new KeepaliveThread(this);
 235                         keepalive->start_keepalive();
 236                         break;
 237 #ifdef HAVE_FIREWIRE
 238                 case CAPTURE_FIREWIRE:
 239                 case CAPTURE_IEC61883:
 240                         break;
 241 #endif
 242
 243 #ifdef HAVE_DVB
 244                 case CAPTURE_DVB:
 245                         break;
 246 #endif
 247
 248                 default:
 249                         return 1;
 250         }
 251
 252         new_device_base();
 253         if( !input_base ) return 1;
 254         result = input_base->open_input();
 255         if(!result) capturing = 1;
 256         in_config_updated = 0;
 257         return 0;
 258 }
 259
 260 VDeviceBase* VideoDevice::new_device_base()
 261 {
 262         switch(in_config->driver) {
 263 #ifdef HAVE_VIDEO4LINUX
 264         case VIDEO4LINUX:
 265                 return input_base = new VDeviceV4L(this);
 266 #endif
 267
 268 #ifdef HAVE_VIDEO4LINUX2
 269         case VIDEO4LINUX2:
 270         case CAPTURE_JPEG_WEBCAM:
 271         case CAPTURE_YUYV_WEBCAM:
 272                 return input_base = new VDeviceV4L2(this);
 273         case VIDEO4LINUX2JPEG:
 274                 return input_base = new VDeviceV4L2JPEG(this);
 275         case VIDEO4LINUX2MPEG:
 276                 return input_base = new VDeviceV4L2MPEG(this);
 277 #endif
 278
 279         case SCREENCAPTURE:
 280                 return input_base = new VDeviceX11(this, 0);
 281
 282 #ifdef HAVE_VIDEO4LINUX
 283         case CAPTURE_BUZ:
 284                 return input_base = new VDeviceBUZ(this);
 285         case CAPTURE_LML:
 286                 return input_base = new VDeviceLML(this);
 287 #endif
 288
 289 #ifdef HAVE_FIREWIRE
 290         case CAPTURE_FIREWIRE:
 291         case CAPTURE_IEC61883:
 292                 return input_base = new VDevice1394(this);
 293 #endif
 294
 295 #ifdef HAVE_DVB
 296         case CAPTURE_DVB:
 297                 return input_base = new VDeviceDVB(this);
 298 #endif
 299         }
 300         return 0;
 301 }
 302
 303 static char* get_channeldb_path(VideoInConfig *vconfig_in)
 304 {
 305         char *path = 0;
 306         switch(vconfig_in->driver)
 307         {
 308                 case VIDEO4LINUX:
 309                         path = (char*)"channels_v4l";
 310                         break;
 311                 case VIDEO4LINUX2:
 312                 case CAPTURE_JPEG_WEBCAM:
 313                 case CAPTURE_YUYV_WEBCAM:
 314                         path = (char*)"channels_v4l2";
 315                         break;
 316                 case VIDEO4LINUX2JPEG:
 317                         path = (char*)"channels_v4l2jpeg";
 318                         break;
 319                 case VIDEO4LINUX2MPEG:
 320                         path = (char*)"channels_v4l2mpeg";
 321                         break;
 322                 case CAPTURE_BUZ:
 323                         path = (char*)"channels_buz";
 324                         break;
 325                 case CAPTURE_DVB:
 326                         path = (char*)"channels_dvb";
 327                         break;
 328         }
 329         return path;
 330 }
 331
 332 void VideoDevice::load_channeldb(ChannelDB *channeldb, VideoInConfig *vconfig_in)
 333 {
 334         channeldb->load(get_channeldb_path(vconfig_in));
 335 }
 336
 337 void VideoDevice::save_channeldb(ChannelDB *channeldb, VideoInConfig *vconfig_in)
 338 {
 339         channeldb->save(get_channeldb_path(vconfig_in));
 340 }
 341
 342
 343 VDeviceBase* VideoDevice::get_input_base()
 344 {
 345         return input_base;
 346 }
 347
 348 VDeviceBase* VideoDevice::get_output_base()
 349 {
 350         return output_base;
 351 }
 352
 353 DeviceMPEGInput *VideoDevice::mpeg_device()
 354 {
 355         return !input_base ? 0 : input_base->mpeg_device();
 356 }
 357
 358 int VideoDevice::is_compressed(int driver, int use_file, int use_fixed)
 359 {
 360 // FileMOV needs to have write_frames called so the start codes get scanned.
 361         return ((driver == CAPTURE_BUZ && use_fixed) ||
 362                 (driver == VIDEO4LINUX2JPEG && use_fixed) ||
 363                 (driver == VIDEO4LINUX2MPEG && use_fixed) ||
 364                 (driver == CAPTURE_JPEG_WEBCAM && use_fixed) ||
 365                 driver == CAPTURE_LML ||
 366                 driver == CAPTURE_FIREWIRE ||
 367                 driver == CAPTURE_IEC61883);
 368 }
 369
 370 int VideoDevice::is_compressed(int use_file, int use_fixed)
 371 {
 372         return is_compressed(in_config->driver, use_file, use_fixed);
 373 }
 374
 375
 376 void VideoDevice::fix_asset(Asset *asset, int driver)
 377 {
 378 // Fix asset using legacy routine
 379         switch(driver)
 380         {
 381                 case CAPTURE_JPEG_WEBCAM:
 382                         if(asset->format != FILE_AVI &&
 383                                 asset->format != FILE_MOV)
 384                                 asset->format = FILE_MOV;
 385                         strcpy(asset->vcodec, QUICKTIME_JPEG);
 386                         break;
 387
 388                 case CAPTURE_BUZ:
 389                 case CAPTURE_LML:
 390                 case VIDEO4LINUX2JPEG:
 391                         if(asset->format != FILE_AVI &&
 392                                 asset->format != FILE_MOV)
 393                                 asset->format = FILE_MOV;
 394                         if( strncmp(asset->vcodec,QUICKTIME_MJPG,4) != 0 )
 395                                 strncpy(asset->vcodec,QUICKTIME_MJPA,4);
 396                         return;
 397
 398                 case CAPTURE_FIREWIRE:
 399                 case CAPTURE_IEC61883:
 400                         if(asset->format != FILE_AVI &&
 401                                 asset->format != FILE_MOV)
 402                                 asset->format = FILE_MOV;
 403                         strcpy(asset->vcodec, QUICKTIME_DVSD);
 404                         return;
 405         }
 406
 407 // Fix asset using inherited routine
 408         new_device_base();
 409
 410         if(input_base) input_base->fix_asset(asset);
 411         delete input_base;
 412         input_base = 0;
 413 }
 414
 415
 416 const char* VideoDevice::drivertostr(int driver)
 417 {
 418         switch(driver) {
 419         case PLAYBACK_X11:     return PLAYBACK_X11_TITLE;
 420         case PLAYBACK_X11_XV:  return PLAYBACK_X11_XV_TITLE;
 421         case PLAYBACK_X11_GL:  return PLAYBACK_X11_GL_TITLE;
 422         case PLAYBACK_BUZ:     return PLAYBACK_BUZ_TITLE;
 423         case VIDEO4LINUX:      return VIDEO4LINUX_TITLE;
 424         case VIDEO4LINUX2:     return VIDEO4LINUX2_TITLE;
 425         case VIDEO4LINUX2JPEG: return VIDEO4LINUX2JPEG_TITLE;
 426         case VIDEO4LINUX2MPEG: return VIDEO4LINUX2MPEG_TITLE;
 427         case CAPTURE_JPEG_WEBCAM: return CAPTURE_JPEG_WEBCAM_TITLE;
 428         case CAPTURE_YUYV_WEBCAM: return CAPTURE_YUYV_WEBCAM_TITLE;
 429         case SCREENCAPTURE:    return SCREENCAPTURE_TITLE;
 430         case CAPTURE_BUZ:      return CAPTURE_BUZ_TITLE;
 431         case CAPTURE_LML:      return CAPTURE_LML_TITLE;
 432         case CAPTURE_DVB:      return CAPTURE_DVB_TITLE;
 433         case CAPTURE_FIREWIRE: return CAPTURE_FIREWIRE_TITLE;
 434         case CAPTURE_IEC61883: return CAPTURE_IEC61883_TITLE;
 435         }
 436         return "";
 437 }
 438
 439 int VideoDevice::get_best_colormodel(Asset *asset)
 440 {
 441         return input_base ? input_base->get_best_colormodel(asset) : BC_RGB888;
 442 }
 443
 444 int VideoDevice::drop_frames(int frames)
 445 {
 446         return input_base ? input_base->drop_frames(frames) : 1;
 447 }
 448
 449 double VideoDevice::device_timestamp()
 450 {
 451         return input_base ? input_base->device_timestamp() : -1.;
 452 }
 453
 454 double VideoDevice::get_timestamp()
 455 {
 456         return timestamp;
 457 }
 458
 459 int VideoDevice::close_all()
 460 {
 461         if(w) {
 462                 if( output_base ) {
 463                         output_base->close_all();
 464                         delete output_base;
 465                         output_base = 0;
 466                 }
 467         }
 468
 469         if(r && capturing) {
 470                 capturing = 0;
 471                 if(input_base) {
 472                         input_base->close_all();
 473                         delete input_base;
 474                         input_base = 0;
 475                 }
 476                 if(keepalive) {
 477                         keepalive->stop();
 478                         delete keepalive;
 479                 }
 480         }
 481
 482         input_sources.remove_all_objects();
 483         initialize();
 484         return 0;
 485 }
 486
 487
 488 int VideoDevice::set_adevice(AudioDevice *adev)
 489 {
 490         adevice = adev;
 491         return 0;
 492 }
 493
 494
 495 ArrayList<Channel*>* VideoDevice::get_inputs()
 496 {
 497         return &input_sources;
 498 }
 499
 500 Channel* VideoDevice::new_input_source(char *device_name)
 501 {
 502         for( int i=0; i<input_sources.total; ++i ) {
 503                 if(!strcmp(input_sources.values[i]->device_name, device_name))
 504                         return input_sources.values[i];
 505         }
 506         Channel *item = new Channel;
 507         strcpy(item->device_name, device_name);
 508         input_sources.append(item);
 509         return item;
 510 }
 511
 512 int VideoDevice::get_failed()
 513 {
 514         return keepalive ? keepalive->get_failed() : 0;
 515 }
 516
 517 int VideoDevice::interrupt_crash()
 518 {
 519         return input_base ? input_base->interrupt_crash() : 0;
 520 }
 521
 522 int VideoDevice::set_translation(int in_x, int in_y)
 523 {
 524         input_x = in_x;
 525         input_y = in_y;
 526         return 0;
 527 }
 528
 529 int VideoDevice::set_field_order(int odd_field_first)
 530 {
 531         this->odd_field_first = odd_field_first;
 532         return 0;
 533 }
 534
 535 int VideoDevice::set_channel(Channel *channel)
 536 {
 537         int result = 0;
 538         if( channel ) {
 539                 channel_lock->lock("VideoDevice::set_channel");
 540                 this->channel->copy_settings(channel);
 541                 channel_changed = 1;
 542                 channel_lock->unlock();
 543                 result = input_base ? input_base->set_channel(channel) :
 544                          output_base ? output_base->set_channel(channel) :
 545                          1;
 546         }
 547         return result;
 548 }
 549
 550 int VideoDevice::set_captioning(int mode)
 551 {
 552         if( input_base )
 553                 input_base->set_captioning(mode);
 554         return 0;
 555 }
 556
 557 void VideoDevice::set_quality(int quality)
 558 {
 559         this->quality = quality;
 560 }
 561
 562 void VideoDevice::set_cpus(int cpus)
 563 {
 564         this->cpus = cpus;
 565 }
 566
 567 int VideoDevice::set_picture(PictureConfig *picture)
 568 {
 569         if( picture ) {
 570                 picture_lock->lock("VideoDevice::set_picture");
 571                 this->picture->copy_settings(picture);
 572                 picture_changed = 1;
 573                 picture_lock->unlock();
 574
 575                 if(input_base) return input_base->set_picture(picture);
 576         }
 577         return 0;
 578 }
 579
 580 int VideoDevice::update_translation()
 581 {
 582         float frame_in_capture_x1f, frame_in_capture_x2f, frame_in_capture_y1f, frame_in_capture_y2f;
 583         float capture_in_frame_x1f, capture_in_frame_x2f, capture_in_frame_y1f, capture_in_frame_y2f;
 584         //int z_changed = 0;
 585
 586         if(frame_resized) {
 587                 input_x = new_input_x;
 588                 input_y = new_input_y;
 589                 if( in_config->driver == VIDEO4LINUX ||
 590                         in_config->driver == VIDEO4LINUX2 ) {
 591                         if(input_z != new_input_z) {
 592                                 input_z = new_input_z;
 593                                 //z_changed = 1;
 594
 595                                 capture_w = (int)((float)in_config->w * input_z + 0.5);
 596                                 capture_h = (int)((float)in_config->h * input_z + 0.5);
 597
 598 // Need to align to multiple of 4
 599                                 capture_w &= ~3;
 600                                 capture_h &= ~3;
 601                         }
 602
 603                         frame_in_capture_x1f = (float)input_x * input_z + capture_w / 2 - in_config->w / 2;
 604                         frame_in_capture_x2f = (float)input_x * input_z  + capture_w / 2 + in_config->w / 2;
 605                         frame_in_capture_y1f = (float)input_y * input_z  + capture_h / 2 - in_config->h / 2;
 606                         frame_in_capture_y2f = (float)input_y * input_z  + capture_h / 2 + in_config->h / 2;
 607
 608                         capture_in_frame_x1f = 0;
 609                         capture_in_frame_y1f = 0;
 610                         capture_in_frame_x2f = in_config->w;
 611                         capture_in_frame_y2f = in_config->h;
 612
 613                         if(frame_in_capture_x1f < 0) { capture_in_frame_x1f -= frame_in_capture_x1f; frame_in_capture_x1f = 0; }
 614                         if(frame_in_capture_y1f < 0) { capture_in_frame_y1f -= frame_in_capture_y1f; frame_in_capture_y1f = 0; }
 615                         if(frame_in_capture_x2f > capture_w) { capture_in_frame_x2f -= frame_in_capture_x2f - capture_w; frame_in_capture_x2f = capture_w; }
 616                         if(frame_in_capture_y2f > capture_h) { capture_in_frame_y2f -= frame_in_capture_y2f - capture_h; frame_in_capture_y2f = capture_h; }
 617
 618                         frame_in_capture_x1 = (int)frame_in_capture_x1f;
 619                         frame_in_capture_y1 = (int)frame_in_capture_y1f;
 620                         frame_in_capture_x2 = (int)frame_in_capture_x2f;
 621                         frame_in_capture_y2 = (int)frame_in_capture_y2f;
 622
 623                         capture_in_frame_x1 = (int)capture_in_frame_x1f;
 624                         capture_in_frame_y1 = (int)capture_in_frame_y1f;
 625                         capture_in_frame_x2 = (int)capture_in_frame_x2f;
 626                         capture_in_frame_y2 = (int)capture_in_frame_y2f;
 627
 628                         frame_resized = 0;
 629                 }
 630         }
 631         return 0;
 632 }
 633
 634 int VideoDevice::set_latency_counter(int value)
 635 {
 636         latency_counter = value;
 637         return 0;
 638 }
 639
 640 int VideoDevice::has_signal()
 641 {
 642         return input_base ? input_base->has_signal() : 0;
 643 }
 644
 645 int VideoDevice::create_channeldb(ArrayList<Channel*> *channeldb)
 646 {
 647         return input_base ? input_base->create_channeldb(channeldb) : 1;
 648 }
 649
 650
 651 int VideoDevice::read_buffer(VFrame *frame)
 652 {
 653         int result = 0;
 654         if(!capturing) return 0;
 655
 656 //printf("VideoDevice::read_buffer %p %p\n", frame, input_base);
 657         if(input_base) {
 658 // Reset the keepalive thread
 659                 if(keepalive) keepalive->capturing = 1;
 660                 result = input_base->read_buffer(frame);
 661                 timestamp = frame->get_timestamp();
 662                 if( timestamp < 0 ) {
 663                         struct timeval tv;  gettimeofday(&tv, 0);
 664                         timestamp = tv.tv_sec + tv.tv_usec / 1000000.0;
 665                 }
 666                 if(keepalive) {
 667                         keepalive->capturing = 0;
 668                         keepalive->reset_keepalive();
 669                 }
 670                 return result;
 671         }
 672
 673         return 0;
 674 }
 675
 676
 677 // ================================= OUTPUT ==========================================
 678
 679
 680 int VideoDevice::open_output(VideoOutConfig *config, float rate,
 681         int out_w, int out_h, Canvas *output, int single_frame)
 682 {
 683         w = 1;
 684 //printf("VideoDevice::open_output 1 %d\n", out_config->driver);
 685         *this->out_config = *config;
 686 //printf("VideoDevice::open_output 1 %d\n", out_config->driver);
 687         this->out_w = out_w;
 688         this->out_h = out_h;
 689         this->orate = rate;
 690         this->single_frame = single_frame;
 691
 692 //printf("VideoDevice::open_output 1 %d\n", out_config->driver);
 693         switch(out_config->driver) {
 694 #ifdef HAVE_VIDEO4LINUX
 695         case PLAYBACK_BUZ:
 696                 output_base = new VDeviceBUZ(this);
 697                 break;
 698         case PLAYBACK_LML:
 699                 output_base = new VDeviceLML(this);
 700                 break;
 701 #endif
 702         case PLAYBACK_X11:
 703         case PLAYBACK_X11_XV:
 704         case PLAYBACK_X11_GL:
 705                 output_base = new VDeviceX11(this, output);
 706                 break;
 707
 708         case PLAYBACK_DV1394:
 709         case PLAYBACK_FIREWIRE:
 710         case PLAYBACK_IEC61883:
 711                 output_base = new VDevice1394(this);
 712                 break;
 713         }
 714 //printf("VideoDevice::open_output 2 %d\n", out_config->driver);
 715
 716         if(output_base->open_output()) {
 717                 delete output_base;
 718                 output_base = 0;
 719         }
 720 //printf("VideoDevice::open_output 3 %d\n", out_config->driver);
 721         return output_base ? 0 : 1;
 722 }
 723
 724
 725
 726 int VideoDevice::start_playback()
 727 {
 728 // arm buffer before doing this
 729         is_playing_back = 1;
 730         interrupt = 0;
 731         return output_base ? output_base->start_playback() : 1;
 732 }
 733
 734 int VideoDevice::stop_playback()
 735 {
 736         if( output_base ) output_base->stop_playback();
 737         is_playing_back = 0;
 738         interrupt = 0;
 739         return 0;
 740 }
 741
 742 void VideoDevice::goose_input()
 743 {
 744         if(input_base) input_base->goose_input();
 745 }
 746
 747 void VideoDevice::new_output_buffer(VFrame **output, int colormodel)
 748 {
 749         if(!output_base) return;
 750         output_base->new_output_buffer(output, colormodel);
 751 }
 752
 753
 754 int VideoDevice::interrupt_playback()
 755 {
 756         interrupt = 1;
 757         return 0;
 758 }
 759
 760 int VideoDevice::write_buffer(VFrame *output, EDL *edl)
 761 {
 762         return output_base ? output_base->write_buffer(output, edl) : 1;
 763 }
 764
 765 int VideoDevice::output_visible()
 766 {
 767         return output_base ? output_base->output_visible() : 0;
 768 }
 769
 770 BC_Bitmap* VideoDevice::get_bitmap()
 771 {
 772         return output_base ? output_base->get_bitmap() : 0;
 773 }
 774
 775
 776 int VideoDevice::set_cloexec_flag(int desc, int value)
 777 {
 778         int oldflags = fcntl(desc, F_GETFD, 0);
 779         if( oldflags < 0 ) return oldflags;
 780         if( value != 0 )
 781                 oldflags |= FD_CLOEXEC;
 782         else
 783                 oldflags &= ~FD_CLOEXEC;
 784         return fcntl(desc, F_SETFD, oldflags);
 785 }
 786
 787
 788 void VideoDevice::auto_update(double rate, int width, int height)
 789 {
 790         if( !in_config || !in_config->follow_video ) return;
 791         capture_w = width;
 792         capture_h = height;
 793         frame_rate = rate;
 794         in_config_updated = 1;
 795 }
 796
 797 int VideoDevice::config_updated()
 798 {
 799         if( !in_config || !in_config->follow_video ) return 0;
 800         return in_config_updated;
 801 }
 802
 803 void VideoDevice::config_update()
 804 {
 805         in_config_updated = 0;
 806         VideoInConfig *vconfig_in = mwindow->edl->session->vconfig_in;
 807         vconfig_in->w = capture_w;
 808         vconfig_in->h = capture_h;
 809         vconfig_in->in_framerate = frame_rate;
 810 }
 811
 812
 813 int VideoDevice::start_toc(const char *path, const char *toc_path)
 814 {
 815         return input_base ? input_base->start_toc(path, toc_path) : -1;
 816 }
 817
 818 int VideoDevice::start_record(int fd, int bsz)
 819 {
 820         return input_base ? input_base->start_record(fd, bsz) : -1;
 821 }
 822
 823 int VideoDevice::stop_record()
 824 {
 825         return input_base ? input_base->stop_record() : -1;
 826 }
 827
 828
 829 int VideoDevice::total_video_streams()
 830 {
 831         return input_base ? input_base->total_video_streams() : 0;
 832 }
 833
 834
 835 // skimming
 836 int VideoDevice::get_video_pid(int track)
 837 {
 838         return !input_base ? -1 : input_base->get_video_pid(track);
 839
 840 }
 841
 842 int VideoDevice::get_video_info(int track, int &pid,
 843                 double &framerate, int &width, int &height, char *title)
 844 {
 845         return !input_base ? 1 : input_base->
 846                 get_video_info(track, pid, framerate, width, height, title);
 847 }
 848
 849 int VideoDevice::get_thumbnail(int stream, int64_t &position,
 850                 unsigned char *&thumbnail, int &ww, int &hh)
 851 {
 852         return !input_base ? 1 :
 853                 input_base->get_thumbnail(stream, position, thumbnail, ww, hh);
 854 }
 855
 856 int VideoDevice::set_skimming(int track, int skim, skim_fn fn, void *vp)
 857 {
 858         return !input_base ? 1 :
 859                 input_base->set_skimming(track, skim, fn, vp);
 860 }
 861