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 #define QTKIT_VERSION_MIN_REQUIRED 70603
  41
  42 #import <QTKit/QTKit.h>
  43 #import <CoreAudio/CoreAudio.h>
  44
  45 #define QTKIT_WIDTH_TEXT N_("Video Capture width")
  46 #define QTKIT_WIDTH_LONGTEXT N_("Video Capture width in pixel")
  47 #define QTKIT_HEIGHT_TEXT N_("Video Capture height")
  48 #define QTKIT_HEIGHT_LONGTEXT N_("Video Capture height in pixel")
  49
  50 /*****************************************************************************
  51 * Local prototypes
  52 *****************************************************************************/
  53 static int Open(vlc_object_t *p_this);
  54 static void Close(vlc_object_t *p_this);
  55 static int Demux(demux_t *p_demux);
  56 static int Control(demux_t *, int, va_list);
  57
  58 /*****************************************************************************
  59 * Module descriptor
  60 *****************************************************************************/
  61 vlc_module_begin ()
  62    set_shortname(N_("Quicktime Capture"))
  63    set_description(N_("Quicktime Capture"))
  64    set_category(CAT_INPUT)
  65    set_subcategory(SUBCAT_INPUT_ACCESS)
  66    add_shortcut("qtcapture")
  67    set_capability("access_demux", 10)
  68    set_callbacks(Open, Close)
  69    add_integer("qtcapture-width", 640, QTKIT_WIDTH_TEXT, QTKIT_WIDTH_LONGTEXT, true)
  70       change_integer_range (80, 1280)
  71    add_integer("qtcapture-height", 480, QTKIT_HEIGHT_TEXT, QTKIT_HEIGHT_LONGTEXT, true)
  72       change_integer_range (60, 480)
  73 vlc_module_end ()
  74
  75
  76 /*****************************************************************************
  77 * QTKit Bridge
  78 *****************************************************************************/
  79 @interface VLCDecompressedVideoOutput : QTCaptureDecompressedVideoOutput
  80 {
  81     CVImageBufferRef currentImageBuffer;
  82     mtime_t currentPts;
  83     mtime_t previousPts;
  84     long timeScale;
  85 }
  86 - (id)init;
  87 - (void)outputVideoFrame:(CVImageBufferRef)videoFrame withSampleBuffer:(QTSampleBuffer *)sampleBuffer fromConnection:(QTCaptureConnection *)connection;
  88 - (mtime_t)copyCurrentFrameToBuffer:(void *)buffer;
  89 @end
  90
  91 /* Apple sample code */
  92 @implementation VLCDecompressedVideoOutput : QTCaptureDecompressedVideoOutput
  93
  94 - (id)init
  95 {
  96     if (self = [super init]) {
  97         currentImageBuffer = nil;
  98         currentPts = 0;
  99         previousPts = 0;
 100         timeScale = 0;
 101     }
 102     return self;
 103 }
 104
 105 - (void)dealloc
 106 {
 107     @synchronized (self) {
 108         CVBufferRelease(currentImageBuffer);
 109         currentImageBuffer = nil;
 110     }
 111     [super dealloc];
 112 }
 113
 114 - (long)timeScale
 115 {
 116     return timeScale;
 117 }
 118
 119 - (void)outputVideoFrame:(CVImageBufferRef)videoFrame withSampleBuffer:(QTSampleBuffer *)sampleBuffer fromConnection:(QTCaptureConnection *)connection
 120 {
 121     // Store the latest frame
 122     // This must be done in a @synchronized block because this delegate method is not called on the main thread
 123     CVImageBufferRef imageBufferToRelease;
 124
 125     CVBufferRetain(videoFrame);
 126
 127     @synchronized (self) {
 128         imageBufferToRelease = currentImageBuffer;
 129         currentImageBuffer = videoFrame;
 130         QTTime timeStamp = [sampleBuffer presentationTime];
 131         timeScale = timeStamp.timeScale;
 132         currentPts = (mtime_t)(1000000L / timeScale * timeStamp.timeValue);
 133
 134         /* Try to use hosttime of the sample if available, because iSight Pts seems broken */
 135         NSNumber *hosttime = (NSNumber *)[sampleBuffer attributeForKey:QTSampleBufferHostTimeAttribute];
 136         if (hosttime) currentPts = (mtime_t)AudioConvertHostTimeToNanos([hosttime unsignedLongLongValue])/1000;
 137     }
 138     CVBufferRelease(imageBufferToRelease);
 139 }
 140
 141 - (mtime_t)copyCurrentFrameToBuffer:(void *)buffer
 142 {
 143     CVImageBufferRef imageBuffer;
 144     mtime_t pts;
 145
 146 void * pixels;
 147
 148     if (!currentImageBuffer || currentPts == previousPts)
 149         return 0;
 150
 151     @synchronized (self) {
 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
 206     for (int i = 0; qtchroma_to_fourcc[i].i_qt; i++) {
 207         if (qtchroma_to_fourcc[i].i_qt == i_qt)
 208             return qtchroma_to_fourcc[i].i_fourcc;
 209     }
 210     return 0;
 211 }
 212
 213 /*****************************************************************************
 214 * Open:
 215 *****************************************************************************/
 216 static int Open(vlc_object_t *p_this)
 217 {
 218     demux_t     *p_demux = (demux_t*)p_this;
 219     demux_sys_t *p_sys = NULL;
 220     int i;
 221     int i_width;
 222     int i_height;
 223     int result = 0;
 224     char *psz_uid = NULL;
 225
 226     /* Only when selected */
 227     if (*p_demux->psz_access == '\0')
 228         return VLC_EGENERIC;
 229
 230     NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
 231
 232     if (p_demux->psz_location && *p_demux->psz_location)
 233         psz_uid = strdup(p_demux->psz_location);
 234     msg_Dbg(p_demux, "qtcapture uid = %s", psz_uid);
 235     NSString *qtk_currdevice_uid = [[NSString alloc] initWithFormat:@"%s", psz_uid];
 236
 237     /* Set up p_demux */
 238     p_demux->pf_demux = Demux;
 239     p_demux->pf_control = Control;
 240     p_demux->info.i_update = 0;
 241     p_demux->info.i_title = 0;
 242     p_demux->info.i_seekpoint = 0;
 243
 244     p_demux->p_sys = p_sys = calloc(1, sizeof(demux_sys_t));
 245     if (!p_sys)
 246         return VLC_ENOMEM;
 247
 248     NSArray *myVideoDevices = [[[QTCaptureDevice inputDevicesWithMediaType:QTMediaTypeVideo] arrayByAddingObjectsFromArray:[QTCaptureDevice inputDevicesWithMediaType:QTMediaTypeMuxed]] retain];
 249     if ([myVideoDevices count] == 0) {
 250         dialog_FatalWait(p_demux, _("No Input device found"),
 251                          _("Your Mac does not seem to be equipped with a suitable input device. "
 252                            "Please check your connectors and drivers."));
 253         msg_Err(p_demux, "Can't find any Video device");
 254
 255         goto error;
 256     }
 257     NSUInteger ivideo;
 258     NSUInteger deviceCount = [myVideoDevices count];
 259     for (ivideo = 0; ivideo < deviceCount; ivideo++) {
 260         QTCaptureDevice *qtk_device;
 261         qtk_device = [myVideoDevices objectAtIndex:ivideo];
 262         msg_Dbg(p_demux, "qtcapture %lu/%lu %s %s", ivideo, deviceCount, [[qtk_device localizedDisplayName] UTF8String], [[qtk_device uniqueID] UTF8String]);
 263         if ([[[qtk_device uniqueID]stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceCharacterSet]] isEqualToString:qtk_currdevice_uid]) {
 264             break;
 265         }
 266     }
 267
 268     memset(&p_sys->fmt, 0, sizeof(es_format_t));
 269
 270     QTCaptureDeviceInput * input = nil;
 271     NSError *o_returnedError;
 272     if (ivideo < [myVideoDevices count])
 273         p_sys->device = [myVideoDevices objectAtIndex:ivideo];
 274     else {
 275         /* cannot found designated device, fall back to open default device */
 276         msg_Dbg(p_demux, "Cannot find designated uid device as %s, falling back to default.", [qtk_currdevice_uid UTF8String]);
 277         p_sys->device = [QTCaptureDevice defaultInputDeviceWithMediaType: QTMediaTypeVideo];
 278     }
 279     if (!p_sys->device) {
 280         dialog_FatalWait(p_demux, _("No Input device found"),
 281                         _("Your Mac does not seem to be equipped with a suitable input device. "
 282                           "Please check your connectors and drivers."));
 283         msg_Err(p_demux, "Can't find any Video device");
 284
 285         goto error;
 286     }
 287
 288     if (![p_sys->device open: &o_returnedError]) {
 289         msg_Err(p_demux, "Unable to open the capture device (%ld)", [o_returnedError code]);
 290         goto error;
 291     }
 292
 293     if ([p_sys->device isInUseByAnotherApplication] == YES) {
 294         msg_Err(p_demux, "default capture device is exclusively in use by another application");
 295         goto error;
 296     }
 297
 298     input = [[QTCaptureDeviceInput alloc] initWithDevice: p_sys->device];
 299     if (!input) {
 300         msg_Err(p_demux, "can't create a valid capture input facility");
 301         goto error;
 302     }
 303
 304     p_sys->output = [[VLCDecompressedVideoOutput alloc] init];
 305
 306     /* Get the formats */
 307     NSArray *format_array = [p_sys->device formatDescriptions];
 308     QTFormatDescription* camera_format = NULL;
 309     NSUInteger formatCount = [format_array count];
 310     for (NSUInteger k = 0; k < formatCount; k++) {
 311         camera_format = [format_array objectAtIndex:k];
 312
 313         msg_Dbg(p_demux, "localized Format: %s", [[camera_format localizedFormatSummary] UTF8String]);
 314         msg_Dbg(p_demux, "format description: %s", [[[camera_format formatDescriptionAttributes] description] UTF8String]);
 315     }
 316     if ([format_array count])
 317         camera_format = [format_array objectAtIndex:0];
 318     else
 319         goto error;
 320
 321     int qtchroma = [camera_format formatType];
 322     int chroma = VLC_CODEC_UYVY;
 323
 324     /* Now we can init */
 325     es_format_Init(&p_sys->fmt, VIDEO_ES, chroma);
 326
 327     NSSize encoded_size = [[camera_format attributeForKey:QTFormatDescriptionVideoEncodedPixelsSizeAttribute] sizeValue];
 328     NSSize display_size = [[camera_format attributeForKey:QTFormatDescriptionVideoCleanApertureDisplaySizeAttribute] sizeValue];
 329     NSSize par_size = [[camera_format attributeForKey:QTFormatDescriptionVideoProductionApertureDisplaySizeAttribute] sizeValue];
 330
 331     par_size.width = display_size.width = encoded_size.width
 332         = var_InheritInteger (p_this, "qtcapture-width");
 333     par_size.height = display_size.height = encoded_size.height
 334         = var_InheritInteger (p_this, "qtcapture-height");
 335
 336     p_sys->fmt.video.i_width = p_sys->width = encoded_size.width;
 337     p_sys->fmt.video.i_height = p_sys->height = encoded_size.height;
 338     p_sys->fmt.video.i_frame_rate = 25.0; // cave: check with setMinimumVideoFrameInterval (see below)
 339     if (par_size.width != encoded_size.width) {
 340         p_sys->fmt.video.i_sar_num = (int64_t)encoded_size.height * par_size.width / encoded_size.width;
 341         p_sys->fmt.video.i_sar_den = encoded_size.width;
 342     }
 343
 344     msg_Dbg(p_demux, "encoded_size %i %i", (int)encoded_size.width, (int)encoded_size.height);
 345     msg_Dbg(p_demux, "display_size %i %i", (int)display_size.width, (int)display_size.height);
 346     msg_Dbg(p_demux, "PAR size %i %i", (int)par_size.width, (int)par_size.height);
 347
 348     [p_sys->output setPixelBufferAttributes: [NSDictionary dictionaryWithObjectsAndKeys:
 349                                               [NSNumber numberWithInt:kCVPixelFormatType_422YpCbCr8], (id)kCVPixelBufferPixelFormatTypeKey,
 350                                               [NSNumber numberWithInt:p_sys->height], kCVPixelBufferHeightKey,
 351                                               [NSNumber numberWithInt:p_sys->width], kCVPixelBufferWidthKey,
 352                                               [NSNumber numberWithBool:YES], (id)kCVPixelBufferOpenGLCompatibilityKey,
 353                                               nil]];
 354     [p_sys->output setAutomaticallyDropsLateVideoFrames:YES];
 355     [p_sys->output setMinimumVideoFrameInterval: (1/25)]; // 25 fps
 356
 357     p_sys->session = [[QTCaptureSession alloc] init];
 358
 359     bool ret = [p_sys->session addInput:input error: &o_returnedError];
 360     if (!ret) {
 361         msg_Err(p_demux, "default video capture device could not be added to capture session (%ld)", [o_returnedError code]);
 362         goto error;
 363     }
 364
 365     ret = [p_sys->session addOutput:p_sys->output error: &o_returnedError];
 366     if (!ret) {
 367         msg_Err(p_demux, "output could not be added to capture session (%ld)", [o_returnedError code]);
 368         goto error;
 369     }
 370
 371     [p_sys->session startRunning];
 372
 373     [input release];
 374     [pool release];
 375
 376     msg_Dbg(p_demux, "QTCapture: We have a video device ready!");
 377
 378     return VLC_SUCCESS;
 379 error:
 380     [input release];
 381     [pool release];
 382
 383     free(p_sys);
 384
 385     return VLC_EGENERIC;
 386 }
 387
 388 /*****************************************************************************
 389 * Close:
 390 *****************************************************************************/
 391 static void Close(vlc_object_t *p_this)
 392 {
 393     NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
 394
 395     demux_t     *p_demux = (demux_t*)p_this;
 396     demux_sys_t *p_sys = p_demux->p_sys;
 397
 398     /* Hack: if libvlc was killed, main interface thread was,
 399      * and poor QTKit needs it, so don't tell him.
 400      * Else we dead lock. */
 401     if (vlc_object_alive(p_this->p_libvlc)) {
 402         // Perform this on main thread, as the framework itself will sometimes try to synchronously
 403         // work on main thread. And this will create a dead lock.
 404         [p_sys->session performSelectorOnMainThread:@selector(stopRunning) withObject:nil waitUntilDone:NO];
 405         [p_sys->output performSelectorOnMainThread:@selector(release) withObject:nil waitUntilDone:NO];
 406         [p_sys->session performSelectorOnMainThread:@selector(release) withObject:nil waitUntilDone:NO];
 407     }
 408     free(p_sys);
 409
 410     [pool release];
 411 }
 412
 413
 414 /*****************************************************************************
 415 * Demux:
 416 *****************************************************************************/
 417 static int Demux(demux_t *p_demux)
 418 {
 419     demux_sys_t *p_sys = p_demux->p_sys;
 420     block_t *p_block;
 421
 422     p_block = block_Alloc(p_sys->width * p_sys->height * 2 /* FIXME */);
 423     if (!p_block) {
 424         msg_Err(p_demux, "cannot get block");
 425         return 0;
 426     }
 427
 428     NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
 429
 430     @synchronized (p_sys->output) {
 431         p_block->i_pts = [p_sys->output copyCurrentFrameToBuffer: p_block->p_buffer];
 432     }
 433
 434     if (!p_block->i_pts) {
 435         /* Nothing to display yet, just forget */
 436         block_Release(p_block);
 437         [pool release];
 438         msleep(10000);
 439         return 1;
 440     } else if (!p_sys->b_es_setup) {
 441         p_sys->fmt.video.i_frame_rate_base = [p_sys->output timeScale];
 442         msg_Dbg(p_demux, "using frame rate base: %i", p_sys->fmt.video.i_frame_rate_base);
 443         p_sys->p_es_video = es_out_Add(p_demux->out, &p_sys->fmt);
 444         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);
 445         p_sys->b_es_setup = YES;
 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_C(1000) * var_InheritInteger(p_demux, "live-caching");
 477            return VLC_SUCCESS;
 478
 479         case DEMUX_GET_TIME:
 480             pi64 = (int64_t*)va_arg(args, int64_t *);
 481             *pi64 = mdate();
 482             return VLC_SUCCESS;
 483
 484         default:
 485            return VLC_EGENERIC;
 486     }
 487     return VLC_EGENERIC;
 488 }