eceb75c8a85a9714b90d5cbe5ec1e457d97a4bfd
[goodguy/history.git] / 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