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 }
  83 - (id)init;
  84 - (void)outputVideoFrame:(CVImageBufferRef)videoFrame withSampleBuffer:(QTSampleBuffer *)sampleBuffer fromConnection:(QTCaptureConnection *)connection;
  85 - (mtime_t)copyCurrentFrameToBuffer:(void *)buffer;
  86 @end
  87
  88 /* Apple sample code */
  89 @implementation VLCDecompressedVideoOutput : QTCaptureDecompressedVideoOutput
  90 - (id)init
  91 {
  92     if( self = [super init] )
  93     {
  94         currentImageBuffer = nil;
  95         currentPts = 0;
  96         previousPts = 0;
  97     }
  98     return self;
  99 }
 100 - (void)dealloc
 101 {
 102     @synchronized (self)
 103     {
 104         CVBufferRelease(currentImageBuffer);
 105         currentImageBuffer = nil;
 106     }
 107     [super dealloc];
 108 }
 109
 110 - (void)outputVideoFrame:(CVImageBufferRef)videoFrame withSampleBuffer:(QTSampleBuffer *)sampleBuffer fromConnection:(QTCaptureConnection *)connection
 111 {
 112     // Store the latest frame
 113     // This must be done in a @synchronized block because this delegate method is not called on the main thread
 114     CVImageBufferRef imageBufferToRelease;
 115
 116     CVBufferRetain(videoFrame);
 117
 118     @synchronized (self)
 119     {
 120         imageBufferToRelease = currentImageBuffer;
 121         currentImageBuffer = videoFrame;
 122         currentPts = (mtime_t)(1000000L / [sampleBuffer presentationTime].timeScale * [sampleBuffer presentationTime].timeValue);
 123
 124         /* Try to use hosttime of the sample if available, because iSight Pts seems broken */
 125         NSNumber *hosttime = (NSNumber *)[sampleBuffer attributeForKey:QTSampleBufferHostTimeAttribute];
 126         if( hosttime ) currentPts = (mtime_t)AudioConvertHostTimeToNanos([hosttime unsignedLongLongValue])/1000;
 127     }
 128     CVBufferRelease(imageBufferToRelease);
 129 }
 130
 131 - (mtime_t)copyCurrentFrameToBuffer:(void *)buffer
 132 {
 133     CVImageBufferRef imageBuffer;
 134     mtime_t pts;
 135         void * pixels;
 136
 137     if(!currentImageBuffer || currentPts == previousPts )
 138         return 0;
 139
 140     @synchronized (self)
 141     {
 142         imageBuffer = CVBufferRetain(currentImageBuffer);
 143         if(imageBuffer){
 144             pts = previousPts = currentPts;
 145             CVPixelBufferLockBaseAddress(imageBuffer, 0);
 146             pixels = CVPixelBufferGetBaseAddress(imageBuffer);
 147             if(pixels)
 148                 memcpy( buffer, pixels, CVPixelBufferGetBytesPerRow(imageBuffer) * CVPixelBufferGetHeight(imageBuffer));
 149             CVPixelBufferUnlockBaseAddress(imageBuffer, 0);
 150         }
 151
 152     }
 153     CVBufferRelease(imageBuffer);
 154
 155         if(pixels)
 156                 return currentPts;
 157         else
 158                 return 0;
 159 }
 160
 161 @end
 162
 163 /*****************************************************************************
 164 * Struct
 165 *****************************************************************************/
 166
 167 struct demux_sys_t {
 168     QTCaptureSession * session;
 169     QTCaptureDevice * device;
 170     VLCDecompressedVideoOutput * output;
 171     int height, width;
 172     es_out_id_t * p_es_video;
 173 };
 174
 175
 176 /*****************************************************************************
 177 * qtchroma_to_fourcc
 178 *****************************************************************************/
 179 static int qtchroma_to_fourcc( int i_qt )
 180 {
 181     static const struct
 182     {
 183         unsigned int i_qt;
 184         int i_fourcc;
 185     } qtchroma_to_fourcc[] =
 186     {
 187         /* Raw data types */
 188         { '2vuy',    VLC_CODEC_UYVY },
 189         { 'yuv2',VLC_CODEC_YUYV },
 190         { 'yuvs', VLC_CODEC_YUYV },
 191         { 0, 0 }
 192     };
 193     int i;
 194     for( i = 0; qtchroma_to_fourcc[i].i_qt; i++ )
 195     {
 196         if( qtchroma_to_fourcc[i].i_qt == i_qt )
 197             return qtchroma_to_fourcc[i].i_fourcc;
 198     }
 199     return 0;
 200 }
 201
 202 /*****************************************************************************
 203 * Open:
 204 *****************************************************************************/
 205 static int Open( vlc_object_t *p_this )
 206 {
 207     demux_t     *p_demux = (demux_t*)p_this;
 208     demux_sys_t *p_sys = NULL;
 209     es_format_t fmt;
 210     int i;
 211     int i_width;
 212     int i_height;
 213     int result = 0;
 214     char *psz_uid = NULL;
 215
 216     /* Only when selected */
 217     if( *p_demux->psz_access == '\0' )
 218         return VLC_EGENERIC;
 219
 220     NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
 221
 222     if( p_demux->psz_location && *p_demux->psz_location )
 223         psz_uid = strdup(p_demux->psz_location);
 224     msg_Dbg( p_demux, "qtcapture uid = %s", psz_uid );
 225     NSString *qtk_currdevice_uid = [[NSString alloc] initWithFormat:@"%s", psz_uid];
 226
 227     /* Set up p_demux */
 228     p_demux->pf_demux = Demux;
 229     p_demux->pf_control = Control;
 230     p_demux->info.i_update = 0;
 231     p_demux->info.i_title = 0;
 232     p_demux->info.i_seekpoint = 0;
 233
 234     p_demux->p_sys = p_sys = calloc( 1, sizeof( demux_sys_t ) );
 235     if( !p_sys )
 236         return VLC_ENOMEM;
 237
 238     NSArray *myVideoDevices = [[[QTCaptureDevice inputDevicesWithMediaType:QTMediaTypeVideo] arrayByAddingObjectsFromArray:[QTCaptureDevice inputDevicesWithMediaType:QTMediaTypeMuxed]] retain];
 239     if([myVideoDevices count] == 0)
 240     {
 241         dialog_FatalWait( p_demux, _("No Input device found"),
 242                          _("Your Mac does not seem to be equipped with a suitable input device. "
 243                            "Please check your connectors and drivers.") );
 244         msg_Err( p_demux, "Can't find any Video device" );
 245
 246         goto error;
 247     }
 248     NSUInteger ivideo;
 249     NSUInteger deviceCount = [myVideoDevices count];
 250     for(ivideo = 0; ivideo < deviceCount; ivideo++){
 251         QTCaptureDevice *qtk_device;
 252         qtk_device = [myVideoDevices objectAtIndex:ivideo];
 253         msg_Dbg( p_demux, "qtcapture %lu/%lu %s %s", ivideo, deviceCount, [[qtk_device localizedDisplayName] UTF8String], [[qtk_device uniqueID] UTF8String]);
 254         if([[[qtk_device uniqueID]stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceCharacterSet]] isEqualToString:qtk_currdevice_uid]){
 255             break;
 256         }
 257     }
 258
 259     memset( &fmt, 0, sizeof( es_format_t ) );
 260
 261     QTCaptureDeviceInput * input = nil;
 262     NSError *o_returnedError;
 263     if( ivideo < [myVideoDevices count] )
 264         p_sys->device = [myVideoDevices objectAtIndex:ivideo];
 265     else
 266     {
 267         /* cannot found designated device, fall back to open default device */
 268         msg_Dbg(p_demux, "Cannot find designated uid device as %s, falling back to default.", [qtk_currdevice_uid UTF8String]);
 269         p_sys->device = [QTCaptureDevice defaultInputDeviceWithMediaType: QTMediaTypeVideo];
 270     }
 271     if( !p_sys->device )
 272     {
 273         dialog_FatalWait( p_demux, _("No Input device found"),
 274                         _("Your Mac does not seem to be equipped with a suitable input device. "
 275                           "Please check your connectors and drivers.") );
 276         msg_Err( p_demux, "Can't find any Video device" );
 277
 278         goto error;
 279     }
 280
 281     if( ![p_sys->device open: &o_returnedError] )
 282     {
 283         msg_Err( p_demux, "Unable to open the capture device (%ld)", [o_returnedError code] );
 284         goto error;
 285     }
 286
 287     if( [p_sys->device isInUseByAnotherApplication] == YES )
 288     {
 289         msg_Err( p_demux, "default capture device is exclusively in use by another application" );
 290         goto error;
 291     }
 292
 293     input = [[QTCaptureDeviceInput alloc] initWithDevice: p_sys->device];
 294     if( !input )
 295     {
 296         msg_Err( p_demux, "can't create a valid capture input facility" );
 297         goto error;
 298     }
 299
 300     p_sys->output = [[VLCDecompressedVideoOutput alloc] init];
 301
 302     /* Get the formats */
 303     NSArray *format_array = [p_sys->device formatDescriptions];
 304     QTFormatDescription* camera_format = NULL;
 305     NSUInteger formatCount = [format_array count];
 306     for( NSUInteger k = 0; k < formatCount; k++ )
 307     {
 308         camera_format = [format_array objectAtIndex: k];
 309
 310         msg_Dbg(p_demux, "localized Format: %s", [[camera_format localizedFormatSummary] UTF8String] );
 311         msg_Dbg(p_demux, "format description: %s", [[[camera_format formatDescriptionAttributes] description] UTF8String] );
 312     }
 313     if( [format_array count] )
 314         camera_format = [format_array objectAtIndex: 0];
 315     else goto error;
 316
 317     int qtchroma = [camera_format formatType];
 318     int chroma = VLC_CODEC_UYVY;
 319
 320     /* Now we can init */
 321     es_format_Init( &fmt, VIDEO_ES, chroma );
 322
 323     NSSize encoded_size = [[camera_format attributeForKey:QTFormatDescriptionVideoEncodedPixelsSizeAttribute] sizeValue];
 324     NSSize display_size = [[camera_format attributeForKey:QTFormatDescriptionVideoCleanApertureDisplaySizeAttribute] sizeValue];
 325     NSSize par_size = [[camera_format attributeForKey:QTFormatDescriptionVideoProductionApertureDisplaySizeAttribute] sizeValue];
 326
 327     par_size.width = display_size.width = encoded_size.width
 328         = var_InheritInteger (p_this, "qtcapture-width");
 329     par_size.height = display_size.height = encoded_size.height
 330         = var_InheritInteger (p_this, "qtcapture-height");
 331
 332     fmt.video.i_width = p_sys->width = encoded_size.width;
 333     fmt.video.i_height = p_sys->height = encoded_size.height;
 334     if( par_size.width != encoded_size.width )
 335     {
 336         fmt.video.i_sar_num = (int64_t)encoded_size.height * par_size.width / encoded_size.width;
 337         fmt.video.i_sar_den = encoded_size.width;
 338     }
 339
 340     msg_Dbg(p_demux, "encoded_size %i %i", (int)encoded_size.width, (int)encoded_size.height );
 341     msg_Dbg(p_demux, "display_size %i %i", (int)display_size.width, (int)display_size.height );
 342     msg_Dbg(p_demux, "PAR size %i %i", (int)par_size.width, (int)par_size.height );
 343
 344     [p_sys->output setPixelBufferAttributes: [NSDictionary dictionaryWithObjectsAndKeys:
 345         [NSNumber numberWithUnsignedInt:kCVPixelFormatType_422YpCbCr8], (id)kCVPixelBufferPixelFormatTypeKey,
 346         [NSNumber numberWithInt: p_sys->height], kCVPixelBufferHeightKey,
 347         [NSNumber numberWithInt: p_sys->width], kCVPixelBufferWidthKey,
 348         [NSNumber numberWithBool:YES], (id)kCVPixelBufferOpenGLCompatibilityKey,
 349         nil]];
 350
 351     p_sys->session = [[QTCaptureSession alloc] init];
 352
 353     bool ret = [p_sys->session addInput:input error: &o_returnedError];
 354     if( !ret )
 355     {
 356         msg_Err( p_demux, "default video capture device could not be added to capture session (%ld)", [o_returnedError code] );
 357         goto error;
 358     }
 359
 360     ret = [p_sys->session addOutput:p_sys->output error: &o_returnedError];
 361     if( !ret )
 362     {
 363         msg_Err( p_demux, "output could not be added to capture session (%ld)", [o_returnedError code] );
 364         goto error;
 365     }
 366
 367     [p_sys->session startRunning];
 368
 369     msg_Dbg( p_demux, "added new video es %4.4s %dx%d",
 370             (char*)&fmt.i_codec, fmt.video.i_width, fmt.video.i_height );
 371
 372     p_sys->p_es_video = es_out_Add( p_demux->out, &fmt );
 373
 374     [input release];
 375     [pool release];
 376
 377     msg_Dbg( p_demux, "QTCapture: We have a video device ready!" );
 378
 379     return VLC_SUCCESS;
 380 error:
 381     [input release];
 382     [pool release];
 383
 384     free( p_sys );
 385
 386     return VLC_EGENERIC;
 387 }
 388
 389 /*****************************************************************************
 390 * Close:
 391 *****************************************************************************/
 392 static void Close( vlc_object_t *p_this )
 393 {
 394     NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
 395
 396     demux_t     *p_demux = (demux_t*)p_this;
 397     demux_sys_t *p_sys = p_demux->p_sys;
 398
 399     /* Hack: if libvlc was killed, main interface thread was,
 400      * and poor QTKit needs it, so don't tell him.
 401      * Else we dead lock. */
 402     if( vlc_object_alive(p_this->p_libvlc))
 403     {
 404         // Perform this on main thread, as the framework itself will sometimes try to synchronously
 405         // work on main thread. And this will create a dead lock.
 406         [p_sys->session performSelectorOnMainThread:@selector(stopRunning) withObject:nil waitUntilDone:NO];
 407         [p_sys->output performSelectorOnMainThread:@selector(release) withObject:nil waitUntilDone:NO];
 408         [p_sys->session performSelectorOnMainThread:@selector(release) withObject:nil waitUntilDone:NO];
 409     }
 410     free( p_sys );
 411
 412     [pool release];
 413 }
 414
 415
 416 /*****************************************************************************
 417 * Demux:
 418 *****************************************************************************/
 419 static int Demux( demux_t *p_demux )
 420 {
 421     demux_sys_t *p_sys = p_demux->p_sys;
 422     block_t *p_block;
 423
 424     p_block = block_New( p_demux, p_sys->width *
 425                             p_sys->height * 2 /* FIXME */ );
 426     if( !p_block )
 427     {
 428         msg_Err( p_demux, "cannot get block" );
 429         return 0;
 430     }
 431
 432     NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
 433
 434     @synchronized (p_sys->output)
 435     {
 436     p_block->i_pts = [p_sys->output copyCurrentFrameToBuffer: p_block->p_buffer];
 437     }
 438
 439     if( !p_block->i_pts )
 440     {
 441         /* Nothing to display yet, just forget */
 442         block_Release( p_block );
 443         [pool release];
 444         msleep( 10000 );
 445         return 1;
 446     }
 447
 448     es_out_Control( p_demux->out, ES_OUT_SET_PCR, p_block->i_pts );
 449     es_out_Send( p_demux->out, p_sys->p_es_video, p_block );
 450
 451     [pool release];
 452     return 1;
 453 }
 454
 455 /*****************************************************************************
 456 * Control:
 457 *****************************************************************************/
 458 static int Control( demux_t *p_demux, int i_query, va_list args )
 459 {
 460     bool *pb;
 461     int64_t    *pi64;
 462
 463     switch( i_query )
 464     {
 465         /* Special for access_demux */
 466         case DEMUX_CAN_PAUSE:
 467         case DEMUX_CAN_SEEK:
 468         case DEMUX_SET_PAUSE_STATE:
 469         case DEMUX_CAN_CONTROL_PACE:
 470            pb = (bool*)va_arg( args, bool * );
 471            *pb = false;
 472            return VLC_SUCCESS;
 473
 474         case DEMUX_GET_PTS_DELAY:
 475            pi64 = (int64_t*)va_arg( args, int64_t * );
 476            *pi64 = (int64_t)DEFAULT_PTS_DELAY;
 477            return VLC_SUCCESS;
 478
 479         default:
 480            return VLC_EGENERIC;
 481     }
 482     return VLC_EGENERIC;
 483 }