git.sesse.net Git - vlc/blob - modules/access/qtcapture.m

   1 /*****************************************************************************
   2  * qtcapture.m: qtkit (Mac OS X) based capture module
   3  *****************************************************************************
   4  * Copyright © 2008-2011 VLC authors and VideoLAN
   5  *
   6  * Authors: Pierre d'Herbemont <pdherbemont@videolan.org>
   7  *
   8  ****************************************************************************
   9  * This program is free software; you can redistribute it and/or modify it
  10  * under the terms of the GNU Lesser General Public License as published by
  11  * the Free Software Foundation; either version 2.1 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public License
  20  * along with this program; if not, write to the Free Software Foundation,
  21  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  22  *****************************************************************************/
  23
  24 /*****************************************************************************
  25  * Preamble
  26  *****************************************************************************/
  27
  28 #ifdef HAVE_CONFIG_H
  29 # include "config.h"
  30 #endif
  31
  32 #include <vlc_common.h>
  33 #include <vlc_plugin.h>
  34 #include <vlc_input.h>
  35 #include <vlc_demux.h>
  36 #include <vlc_interface.h>
  37 #include <vlc_dialog.h>
  38 #include <vlc_access.h>
  39
  40 #import <QTKit/QTKit.h>
  41 #import <CoreAudio/CoreAudio.h>
  42
  43 #define QTKIT_WIDTH_TEXT N_("Video Capture width")
  44 #define QTKIT_WIDTH_LONGTEXT N_("Video Capture width in pixel")
  45 #define QTKIT_HEIGHT_TEXT N_("Video Capture height")
  46 #define QTKIT_HEIGHT_LONGTEXT N_("Video Capture height in pixel")
  47
  48 /*****************************************************************************
  49 * Local prototypes
  50 *****************************************************************************/
  51 static int Open( vlc_object_t *p_this );
  52 static void Close( vlc_object_t *p_this );
  53 static int Demux( demux_t *p_demux );
  54 static int Control( demux_t *, int, va_list );
  55
  56 /*****************************************************************************
  57 * Module descriptor
  58 *****************************************************************************/
  59 vlc_module_begin ()
  60    set_shortname( N_("Quicktime Capture") )
  61    set_description( N_("Quicktime Capture") )
  62    set_category( CAT_INPUT )
  63    set_subcategory( SUBCAT_INPUT_ACCESS )
  64    add_shortcut( "qtcapture" )
  65    set_capability( "access_demux", 10 )
  66    set_callbacks( Open, Close )
  67    add_integer("qtcapture-width", 640, QTKIT_WIDTH_TEXT, QTKIT_WIDTH_LONGTEXT, true)
  68       change_integer_range (80, 1280)
  69    add_integer("qtcapture-height", 480, QTKIT_HEIGHT_TEXT, QTKIT_HEIGHT_LONGTEXT, true)
  70       change_integer_range (60, 480)
  71 vlc_module_end ()
  72
  73
  74 /*****************************************************************************
  75 * QTKit Bridge
  76 *****************************************************************************/
  77 @interface VLCDecompressedVideoOutput : QTCaptureDecompressedVideoOutput
  78 {
  79     CVImageBufferRef currentImageBuffer;
  80     mtime_t currentPts;
  81     mtime_t previousPts;
  82     long timeScale;
  83 }
  84 - (id)init;
  85 - (void)outputVideoFrame:(CVImageBufferRef)videoFrame withSampleBuffer:(QTSampleBuffer *)sampleBuffer fromConnection:(QTCaptureConnection *)connection;
  86 - (mtime_t)copyCurrentFrameToBuffer:(void *)buffer;
  87 @end
  88
  89 /* Apple sample code */
  90 @implementation VLCDecompressedVideoOutput : QTCaptureDecompressedVideoOutput
  91 - (id)init
  92 {
  93     if( self = [super init] )
  94     {
  95         currentImageBuffer = nil;
  96         currentPts = 0;
  97         previousPts = 0;
  98         timeScale = 0;
  99     }
 100     return self;
 101 }
 102 - (void)dealloc
 103 {
 104     @synchronized (self)
 105     {
 106         CVBufferRelease(currentImageBuffer);
 107         currentImageBuffer = nil;
 108     }
 109     [super dealloc];
 110 }
 111
 112 - (long)timeScale
 113 {
 114     return timeScale;
 115 }
 116
 117 - (void)outputVideoFrame:(CVImageBufferRef)videoFrame withSampleBuffer:(QTSampleBuffer *)sampleBuffer fromConnection:(QTCaptureConnection *)connection
 118 {
 119     // Store the latest frame
 120     // This must be done in a @synchronized block because this delegate method is not called on the main thread
 121     CVImageBufferRef imageBufferToRelease;
 122
 123     CVBufferRetain(videoFrame);
 124
 125     @synchronized (self)
 126     {
 127         imageBufferToRelease = currentImageBuffer;
 128         currentImageBuffer = videoFrame;
 129         QTTime timeStamp = [sampleBuffer presentationTime];
 130         timeScale = timeStamp.timeScale;
 131         currentPts = (mtime_t)(1000000L / timeScale * timeStamp.timeValue);
 132
 133         /* Try to use hosttime of the sample if available, because iSight Pts seems broken */
 134         NSNumber *hosttime = (NSNumber *)[sampleBuffer attributeForKey:QTSampleBufferHostTimeAttribute];
 135         if( hosttime ) currentPts = (mtime_t)AudioConvertHostTimeToNanos([hosttime unsignedLongLongValue])/1000;
 136     }
 137     CVBufferRelease(imageBufferToRelease);
 138 }
 139
 140 - (mtime_t)copyCurrentFrameToBuffer:(void *)buffer
 141 {
 142     CVImageBufferRef imageBuffer;
 143     mtime_t pts;
 144
 145 void * pixels;
 146
 147     if(!currentImageBuffer || currentPts == previousPts )
 148         return 0;
 149
 150     @synchronized (self)
 151     {
 152         imageBuffer = CVBufferRetain(currentImageBuffer);
 153         if(imageBuffer){
 154             pts = previousPts = currentPts;
 155             CVPixelBufferLockBaseAddress(imageBuffer, 0);
 156             pixels = CVPixelBufferGetBaseAddress(imageBuffer);
 157             if(pixels)
 158                 memcpy( buffer, pixels, CVPixelBufferGetBytesPerRow(imageBuffer) * CVPixelBufferGetHeight(imageBuffer));
 159             CVPixelBufferUnlockBaseAddress(imageBuffer, 0);
 160         }
 161
 162     }
 163     CVBufferRelease(imageBuffer);
 164
 165     if(pixels)
 166         return currentPts;
 167     else
 168         return 0;
 169 }
 170
 171 @end
 172
 173 /*****************************************************************************
 174 * Struct
 175 *****************************************************************************/
 176
 177 struct demux_sys_t {
 178     QTCaptureSession * session;
 179     QTCaptureDevice * device;
 180     VLCDecompressedVideoOutput * output;
 181     int height, width;
 182     es_out_id_t * p_es_video;
 183     BOOL b_es_setup;
 184     es_format_t fmt;
 185 };
 186
 187
 188 /*****************************************************************************
 189 * qtchroma_to_fourcc
 190 *****************************************************************************/
 191 static int qtchroma_to_fourcc( int i_qt )
 192 {
 193     static const struct
 194     {
 195         unsigned int i_qt;
 196         int i_fourcc;
 197     } qtchroma_to_fourcc[] =
 198     {
 199         /* Raw data types */
 200         { '2vuy',    VLC_CODEC_UYVY },
 201         { 'yuv2',VLC_CODEC_YUYV },
 202         { 'yuvs', VLC_CODEC_YUYV },
 203         { 0, 0 }
 204     };
 205     int i;
 206     for( i = 0; qtchroma_to_fourcc[i].i_qt; i++ )
 207     {
 208         if( qtchroma_to_fourcc[i].i_qt == i_qt )
 209             return qtchroma_to_fourcc[i].i_fourcc;
 210     }
 211     return 0;
 212 }
 213
 214 /*****************************************************************************
 215 * Open:
 216 *****************************************************************************/
 217 static int Open( vlc_object_t *p_this )
 218 {
 219     demux_t     *p_demux = (demux_t*)p_this;
 220     demux_sys_t *p_sys = NULL;
 221     int i;
 222     int i_width;
 223     int i_height;
 224     int result = 0;
 225     char *psz_uid = NULL;
 226
 227     /* Only when selected */
 228     if( *p_demux->psz_access == '\0' )
 229         return VLC_EGENERIC;
 230
 231     NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
 232
 233     if( p_demux->psz_location && *p_demux->psz_location )
 234         psz_uid = strdup(p_demux->psz_location);
 235     msg_Dbg( p_demux, "qtcapture uid = %s", psz_uid );
 236     NSString *qtk_currdevice_uid = [[NSString alloc] initWithFormat:@"%s", psz_uid];
 237
 238     /* Set up p_demux */
 239     p_demux->pf_demux = Demux;
 240     p_demux->pf_control = Control;
 241     p_demux->info.i_update = 0;
 242     p_demux->info.i_title = 0;
 243     p_demux->info.i_seekpoint = 0;
 244
 245     p_demux->p_sys = p_sys = calloc( 1, sizeof( demux_sys_t ) );
 246     if( !p_sys )
 247         return VLC_ENOMEM;
 248
 249     NSArray *myVideoDevices = [[[QTCaptureDevice inputDevicesWithMediaType:QTMediaTypeVideo] arrayByAddingObjectsFromArray:[QTCaptureDevice inputDevicesWithMediaType:QTMediaTypeMuxed]] retain];
 250     if([myVideoDevices count] == 0)
 251     {
 252         dialog_FatalWait( p_demux, _("No Input device found"),
 253                          _("Your Mac does not seem to be equipped with a suitable input device. "
 254                            "Please check your connectors and drivers.") );
 255         msg_Err( p_demux, "Can't find any Video device" );
 256
 257         goto error;
 258     }
 259     NSUInteger ivideo;
 260     NSUInteger deviceCount = [myVideoDevices count];
 261     for(ivideo = 0; ivideo < deviceCount; ivideo++){
 262         QTCaptureDevice *qtk_device;
 263         qtk_device = [myVideoDevices objectAtIndex:ivideo];
 264         msg_Dbg( p_demux, "qtcapture %lu/%lu %s %s", ivideo, deviceCount, [[qtk_device localizedDisplayName] UTF8String], [[qtk_device uniqueID] UTF8String]);
 265         if([[[qtk_device uniqueID]stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceCharacterSet]] isEqualToString:qtk_currdevice_uid]){
 266             break;
 267         }
 268     }
 269
 270     memset( &p_sys->fmt, 0, sizeof( es_format_t ) );
 271
 272     QTCaptureDeviceInput * input = nil;
 273     NSError *o_returnedError;
 274     if( ivideo < [myVideoDevices count] )
 275         p_sys->device = [myVideoDevices objectAtIndex:ivideo];
 276     else
 277     {
 278         /* cannot found designated device, fall back to open default device */
 279         msg_Dbg(p_demux, "Cannot find designated uid device as %s, falling back to default.", [qtk_currdevice_uid UTF8String]);
 280         p_sys->device = [QTCaptureDevice defaultInputDeviceWithMediaType: QTMediaTypeVideo];
 281     }
 282     if( !p_sys->device )
 283     {
 284         dialog_FatalWait( p_demux, _("No Input device found"),
 285                         _("Your Mac does not seem to be equipped with a suitable input device. "
 286                           "Please check your connectors and drivers.") );
 287         msg_Err( p_demux, "Can't find any Video device" );
 288
 289         goto error;
 290     }
 291
 292     if( ![p_sys->device open: &o_returnedError] )
 293     {
 294         msg_Err( p_demux, "Unable to open the capture device (%ld)", [o_returnedError code] );
 295         goto error;
 296     }
 297
 298     if( [p_sys->device isInUseByAnotherApplication] == YES )
 299     {
 300         msg_Err( p_demux, "default capture device is exclusively in use by another application" );
 301         goto error;
 302     }
 303
 304     input = [[QTCaptureDeviceInput alloc] initWithDevice: p_sys->device];
 305     if( !input )
 306     {
 307         msg_Err( p_demux, "can't create a valid capture input facility" );
 308         goto error;
 309     }
 310
 311     p_sys->output = [[VLCDecompressedVideoOutput alloc] init];
 312
 313     /* Get the formats */
 314     NSArray *format_array = [p_sys->device formatDescriptions];
 315     QTFormatDescription* camera_format = NULL;
 316     NSUInteger formatCount = [format_array count];
 317     for( NSUInteger k = 0; k < formatCount; k++ )
 318     {
 319         camera_format = [format_array objectAtIndex: k];
 320
 321         msg_Dbg(p_demux, "localized Format: %s", [[camera_format localizedFormatSummary] UTF8String] );
 322         msg_Dbg(p_demux, "format description: %s", [[[camera_format formatDescriptionAttributes] description] UTF8String] );
 323     }
 324     if( [format_array count] )
 325         camera_format = [format_array objectAtIndex: 0];
 326     else goto error;
 327
 328     int qtchroma = [camera_format formatType];
 329     int chroma = VLC_CODEC_UYVY;
 330
 331     /* Now we can init */
 332     es_format_Init( &p_sys->fmt, VIDEO_ES, chroma );
 333
 334     NSSize encoded_size = [[camera_format attributeForKey:QTFormatDescriptionVideoEncodedPixelsSizeAttribute] sizeValue];
 335     NSSize display_size = [[camera_format attributeForKey:QTFormatDescriptionVideoCleanApertureDisplaySizeAttribute] sizeValue];
 336     NSSize par_size = [[camera_format attributeForKey:QTFormatDescriptionVideoProductionApertureDisplaySizeAttribute] sizeValue];
 337
 338     par_size.width = display_size.width = encoded_size.width
 339         = var_InheritInteger (p_this, "qtcapture-width");
 340     par_size.height = display_size.height = encoded_size.height
 341         = var_InheritInteger (p_this, "qtcapture-height");
 342
 343     p_sys->fmt.video.i_width = p_sys->width = encoded_size.width;
 344     p_sys->fmt.video.i_height = p_sys->height = encoded_size.height;
 345     p_sys->fmt.video.i_frame_rate = 25.0; // cave: check with setMinimumVideoFrameInterval (see below)
 346     if( par_size.width != encoded_size.width )
 347     {
 348         p_sys->fmt.video.i_sar_num = (int64_t)encoded_size.height * par_size.width / encoded_size.width;
 349         p_sys->fmt.video.i_sar_den = encoded_size.width;
 350     }
 351
 352     msg_Dbg(p_demux, "encoded_size %i %i", (int)encoded_size.width, (int)encoded_size.height );
 353     msg_Dbg(p_demux, "display_size %i %i", (int)display_size.width, (int)display_size.height );
 354     msg_Dbg(p_demux, "PAR size %i %i", (int)par_size.width, (int)par_size.height );
 355
 356     [p_sys->output setPixelBufferAttributes: [NSDictionary dictionaryWithObjectsAndKeys:
 357         [NSNumber numberWithUnsignedInt:kCVPixelFormatType_422YpCbCr8], (id)kCVPixelBufferPixelFormatTypeKey,
 358         [NSNumber numberWithInt: p_sys->height], kCVPixelBufferHeightKey,
 359         [NSNumber numberWithInt: p_sys->width], kCVPixelBufferWidthKey,
 360         [NSNumber numberWithBool:YES], (id)kCVPixelBufferOpenGLCompatibilityKey,
 361         nil]];
 362     [p_sys->output setAutomaticallyDropsLateVideoFrames:YES];
 363     [p_sys->output setMinimumVideoFrameInterval: (1/25)]; // 25 fps
 364
 365     p_sys->session = [[QTCaptureSession alloc] init];
 366
 367     bool ret = [p_sys->session addInput:input error: &o_returnedError];
 368     if( !ret )
 369     {
 370         msg_Err( p_demux, "default video capture device could not be added to capture session (%ld)", [o_returnedError code] );
 371         goto error;
 372     }
 373
 374     ret = [p_sys->session addOutput:p_sys->output error: &o_returnedError];
 375     if( !ret )
 376     {
 377         msg_Err( p_demux, "output could not be added to capture session (%ld)", [o_returnedError code] );
 378         goto error;
 379     }
 380
 381     [p_sys->session startRunning];
 382
 383     [input release];
 384     [pool release];
 385
 386     msg_Dbg( p_demux, "QTCapture: We have a video device ready!" );
 387
 388     return VLC_SUCCESS;
 389 error:
 390     [input release];
 391     [pool release];
 392
 393     free( p_sys );
 394
 395     return VLC_EGENERIC;
 396 }
 397
 398 /*****************************************************************************
 399 * Close:
 400 *****************************************************************************/
 401 static void Close( vlc_object_t *p_this )
 402 {
 403     NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
 404
 405     demux_t     *p_demux = (demux_t*)p_this;
 406     demux_sys_t *p_sys = p_demux->p_sys;
 407
 408     /* Hack: if libvlc was killed, main interface thread was,
 409      * and poor QTKit needs it, so don't tell him.
 410      * Else we dead lock. */
 411     if( vlc_object_alive(p_this->p_libvlc))
 412     {
 413         // Perform this on main thread, as the framework itself will sometimes try to synchronously
 414         // work on main thread. And this will create a dead lock.
 415         [p_sys->session performSelectorOnMainThread:@selector(stopRunning) withObject:nil waitUntilDone:NO];
 416         [p_sys->output performSelectorOnMainThread:@selector(release) withObject:nil waitUntilDone:NO];
 417         [p_sys->session performSelectorOnMainThread:@selector(release) withObject:nil waitUntilDone:NO];
 418     }
 419     free( p_sys );
 420
 421     [pool release];
 422 }
 423
 424
 425 /*****************************************************************************
 426 * Demux:
 427 *****************************************************************************/
 428 static int Demux( demux_t *p_demux )
 429 {
 430     demux_sys_t *p_sys = p_demux->p_sys;
 431     block_t *p_block;
 432
 433     p_block = block_New( p_demux, p_sys->width * p_sys->height * 2 /* FIXME */ );
 434     if( !p_block )
 435     {
 436         msg_Err( p_demux, "cannot get block" );
 437         return 0;
 438     }
 439
 440     NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
 441
 442     @synchronized (p_sys->output)
 443     {
 444     p_block->i_pts = [p_sys->output copyCurrentFrameToBuffer: p_block->p_buffer];
 445     }
 446
 447     if( !p_block->i_pts )
 448     {
 449         /* Nothing to display yet, just forget */
 450         block_Release( p_block );
 451         [pool release];
 452         msleep( 10000 );
 453         return 1;
 454     }
 455     else if( !p_sys->b_es_setup )
 456     {
 457         p_sys->fmt.video.i_frame_rate_base = [p_sys->output timeScale];
 458         msg_Dbg( p_demux, "using frame rate base: %i", p_sys->fmt.video.i_frame_rate_base );
 459         p_sys->p_es_video = es_out_Add( p_demux->out, &p_sys->fmt );
 460         msg_Dbg( p_demux, "added new video es %4.4s %dx%d", (char*)&p_sys->fmt.i_codec, p_sys->fmt.video.i_width, p_sys->fmt.video.i_height );
 461         p_sys->b_es_setup = YES;
 462     }
 463
 464     es_out_Control( p_demux->out, ES_OUT_SET_PCR, p_block->i_pts );
 465     es_out_Send( p_demux->out, p_sys->p_es_video, p_block );
 466
 467     [pool release];
 468     return 1;
 469 }
 470
 471 /*****************************************************************************
 472 * Control:
 473 *****************************************************************************/
 474 static int Control( demux_t *p_demux, int i_query, va_list args )
 475 {
 476     bool *pb;
 477     int64_t    *pi64;
 478
 479     switch( i_query )
 480     {
 481         /* Special for access_demux */
 482         case DEMUX_CAN_PAUSE:
 483         case DEMUX_CAN_SEEK:
 484         case DEMUX_SET_PAUSE_STATE:
 485         case DEMUX_CAN_CONTROL_PACE:
 486            pb = (bool*)va_arg( args, bool * );
 487            *pb = false;
 488            return VLC_SUCCESS;
 489
 490         case DEMUX_GET_PTS_DELAY:
 491            pi64 = (int64_t*)va_arg( args, int64_t * );
 492            *pi64 = INT64_C(1000) * var_InheritInteger( p_demux, "live-caching" );
 493            return VLC_SUCCESS;
 494
 495         case DEMUX_GET_TIME:
 496             pi64 = (int64_t*)va_arg( args, int64_t * );
 497             *pi64 = mdate();
 498             return VLC_SUCCESS;
 499
 500         default:
 501            return VLC_EGENERIC;
 502     }
 503     return VLC_EGENERIC;
 504 }