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