RELAND 3: ImageCapture: Implement takePhoto() for Mac AVFoundation

media/capture/video/mac/video_capture_device_avfoundation_mac.mm

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #import "media/capture/video/mac/video_capture_device_avfoundation_mac.h"
 
 #import <CoreMedia/CoreMedia.h>
 #import <CoreVideo/CoreVideo.h>
 #include <stddef.h>
 #include <stdint.h>
@@ skipping 77 matching lines @@
     UMA_HISTOGRAM_COUNTS("Media.VideoCapture.MacBook.NumberOfDevices",
                          number_of_devices + number_of_suspended_devices);
     if (number_of_devices + number_of_suspended_devices == 0) {
       UMA_HISTOGRAM_ENUMERATION(
           "Media.VideoCapture.MacBook.HardwareVersionWhenNoCamera",
           GetMacBookModel(model), MAX_MACBOOK_VERSION + 1);
     }
   }
 }
 
-}  // anonymous namespace
-
 // This function translates Mac Core Video pixel formats to Chromium pixel
 // formats.
 media::VideoPixelFormat FourCCToChromiumPixelFormat(FourCharCode code) {
   switch (code) {
     case kCVPixelFormatType_422YpCbCr8:
       return media::PIXEL_FORMAT_UYVY;
     case CoreMediaGlue::kCMPixelFormat_422YpCbCr8_yuvs:
       return media::PIXEL_FORMAT_YUY2;
     case CoreMediaGlue::kCMVideoCodecType_JPEG_OpenDML:
       return media::PIXEL_FORMAT_MJPEG;
     default:
       return media::PIXEL_FORMAT_UNKNOWN;
   }
 }
 
+// Extracts |base_address| and |length| out of a SampleBuffer.
+void ExtractBaseAddressAndLength(
+    char** base_address,
+    size_t* length,
+    CoreMediaGlue::CMSampleBufferRef sample_buffer) {
+  CoreMediaGlue::CMBlockBufferRef block_buffer =
+      CoreMediaGlue::CMSampleBufferGetDataBuffer(sample_buffer);
+  DCHECK(block_buffer);
+
+  size_t length_at_offset;
+  const OSStatus status = CoreMediaGlue::CMBlockBufferGetDataPointer(
+      block_buffer, 0, &length_at_offset, length, base_address);
+  DCHECK_EQ(noErr, status);
+  // Expect the (M)JPEG data to be available as a contiguous reference, i.e.
+  // not covered by multiple memory blocks.
+  DCHECK_EQ(length_at_offset, *length);
+}
+
+}  // anonymous namespace
+
 @implementation VideoCaptureDeviceAVFoundation
 
 #pragma mark Class methods
 
 + (void)getDeviceNames:(NSMutableDictionary*)deviceNames {
   // At this stage we already know that AVFoundation is supported and the whole
   // library is loaded and initialised, by the device monitoring.
   NSArray* devices = [AVCaptureDeviceGlue devices];
   int number_of_suspended_devices = 0;
   for (CrAVCaptureDevice* device in devices) {
@@ skipping 80 matching lines @@
 
 - (BOOL)setCaptureDevice:(NSString*)deviceId {
   DCHECK(captureSession_);
   DCHECK(main_thread_checker_.CalledOnValidThread());
 
   if (!deviceId) {
     // First stop the capture session, if it's running.
     [self stopCapture];
     // Now remove the input and output from the capture session.
     [captureSession_ removeOutput:captureVideoDataOutput_];
+    if (stillImageOutput_)
+      [captureSession_ removeOutput:stillImageOutput_];
     if (captureDeviceInput_) {
       [captureSession_ removeInput:captureDeviceInput_];
       // No need to release |captureDeviceInput_|, is owned by the session.
       captureDeviceInput_ = nil;
     }
     return YES;
   }
 
   // Look for input device with requested name.
   captureDevice_ = [AVCaptureDeviceGlue deviceWithUniqueID:deviceId];
@@ skipping 29 matching lines @@
     [self sendErrorString:[NSString stringWithUTF8String:
                                         "Could not create video data output."]];
     return NO;
   }
   [captureVideoDataOutput_ setAlwaysDiscardsLateVideoFrames:true];
   [captureVideoDataOutput_
       setSampleBufferDelegate:self
                         queue:dispatch_get_global_queue(
                                   DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)];
   [captureSession_ addOutput:captureVideoDataOutput_];
+
+  // Create and plug the still image capture output. This should happen in
+  // advance of the actual picture to allow for the 3A to stabilize.
+  stillImageOutput_.reset(
+      [[AVFoundationGlue::AVCaptureStillImageOutputClass() alloc] init]);
+  if (stillImageOutput_ && [captureSession_ canAddOutput:stillImageOutput_])
+    [captureSession_ addOutput:stillImageOutput_];
+
   return YES;
 }
 
 - (BOOL)setCaptureHeight:(int)height
                    width:(int)width
                frameRate:(float)frameRate {
   DCHECK(![captureSession_ isRunning] &&
          main_thread_checker_.CalledOnValidThread());
 
   frameWidth_ = width;
@@ skipping 14 matching lines @@
     }
 
     // Compare according to Chromium preference.
     if (media::VideoCaptureFormat::ComparePixelFormatPreference(
             FourCCToChromiumPixelFormat(fourcc),
             FourCCToChromiumPixelFormat(best_fourcc))) {
       best_fourcc = fourcc;
     }
   }
 
+  if (best_fourcc == CoreMediaGlue::kCMVideoCodecType_JPEG_OpenDML) {
+    [captureSession_ removeOutput:stillImageOutput_];
+    stillImageOutput_.reset();
+  }
+
   // The capture output has to be configured, despite Mac documentation
   // detailing that setting the sessionPreset would be enough. The reason for
   // this mismatch is probably because most of the AVFoundation docs are written
   // for iOS and not for MacOsX. AVVideoScalingModeKey() refers to letterboxing
   // yes/no and preserve aspect ratio yes/no when scaling. Currently we set
   // cropping and preservation.
   NSDictionary* videoSettingsDictionary = @{
     (id) kCVPixelBufferWidthKey : @(width), (id)
     kCVPixelBufferHeightKey : @(height), (id)
     kCVPixelBufferPixelFormatTypeKey : @(best_fourcc),
@@ skipping 44 matching lines @@
   return YES;
 }
 
 - (void)stopCapture {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   if ([captureSession_ isRunning])
     [captureSession_ stopRunning];  // Synchronous.
   [[NSNotificationCenter defaultCenter] removeObserver:self];
 }
 
+- (void)takePhoto {
+  DCHECK(main_thread_checker_.CalledOnValidThread());
+  DCHECK([captureSession_ isRunning]);
+  if (!stillImageOutput_)
+    return;
+
+  DCHECK_EQ(1u, [[stillImageOutput_ connections] count]);
+  CrAVCaptureConnection* const connection =
+      [[stillImageOutput_ connections] firstObject];
+  if (!connection) {
+    base::AutoLock lock(lock_);
+    frameReceiver_->OnPhotoError();
+    return;
+  }
+
+  const auto handler = ^(CoreMediaGlue::CMSampleBufferRef sampleBuffer,
+                         NSError* error) {
+    base::AutoLock lock(lock_);
+    if (!frameReceiver_)
+      return;
+    if (error != nil) {
+      frameReceiver_->OnPhotoError();
+      return;
+    }
+
+    // Recommended compressed pixel format is JPEG, we don't expect surprises.
+    // TODO(mcasas): Consider using [1] for merging EXIF output information:
+    // [1] +(NSData*)jpegStillImageNSDataRepresentation:jpegSampleBuffer;
+    DCHECK_EQ(
+        CoreMediaGlue::kCMVideoCodecType_JPEG,
+        CoreMediaGlue::CMFormatDescriptionGetMediaSubType(
+            CoreMediaGlue::CMSampleBufferGetFormatDescription(sampleBuffer)));
+
+    char* baseAddress = 0;
+    size_t length = 0;
+    ExtractBaseAddressAndLength(&baseAddress, &length, sampleBuffer);
+    frameReceiver_->OnPhotoTaken(reinterpret_cast<uint8_t*>(baseAddress),
+                                 length, "image/jpeg");
+  };
+
+  [stillImageOutput_ captureStillImageAsynchronouslyFromConnection:connection
+                                                 completionHandler:handler];
+}
+
 #pragma mark Private methods
 
 // |captureOutput| is called by the capture device to deliver a new frame.
 // AVFoundation calls from a number of threads, depending on, at least, if
 // Chrome is on foreground or background.
 - (void)captureOutput:(CrAVCaptureOutput*)captureOutput
 didOutputSampleBuffer:(CoreMediaGlue::CMSampleBufferRef)sampleBuffer
        fromConnection:(CrAVCaptureConnection*)connection {
   const CoreMediaGlue::CMFormatDescriptionRef formatDescription =
       CoreMediaGlue::CMSampleBufferGetFormatDescription(sampleBuffer);
   const FourCharCode fourcc =
       CoreMediaGlue::CMFormatDescriptionGetMediaSubType(formatDescription);
   const CoreMediaGlue::CMVideoDimensions dimensions =
       CoreMediaGlue::CMVideoFormatDescriptionGetDimensions(formatDescription);
   const media::VideoCaptureFormat captureFormat(
       gfx::Size(dimensions.width, dimensions.height), frameRate_,
       FourCCToChromiumPixelFormat(fourcc));
 
   char* baseAddress = 0;
   size_t frameSize = 0;
   CVImageBufferRef videoFrame = nil;
   if (fourcc == CoreMediaGlue::kCMVideoCodecType_JPEG_OpenDML) {
-    // If MJPEG, use block buffer instead of pixel buffer.
-    CoreMediaGlue::CMBlockBufferRef blockBuffer =
-        CoreMediaGlue::CMSampleBufferGetDataBuffer(sampleBuffer);
-    if (blockBuffer) {
-      size_t lengthAtOffset;
-      CoreMediaGlue::CMBlockBufferGetDataPointer(
-          blockBuffer, 0, &lengthAtOffset, &frameSize, &baseAddress);
-      // Expect the MJPEG data to be available as a contiguous reference, i.e.
-      // not covered by multiple memory blocks.
-      CHECK_EQ(lengthAtOffset, frameSize);
-    }
+    ExtractBaseAddressAndLength(&baseAddress, &frameSize, sampleBuffer);
   } else {
     videoFrame = CoreMediaGlue::CMSampleBufferGetImageBuffer(sampleBuffer);
     // Lock the frame and calculate frame size.
     if (CVPixelBufferLockBaseAddress(videoFrame, kCVPixelBufferLock_ReadOnly) ==
         kCVReturnSuccess) {
       baseAddress = static_cast<char*>(CVPixelBufferGetBaseAddress(videoFrame));
       frameSize = CVPixelBufferGetHeight(videoFrame) *
                   CVPixelBufferGetBytesPerRow(videoFrame);
     } else {
       videoFrame = nil;
@@ skipping 31 matching lines @@
 }
 
 - (void)sendErrorString:(NSString*)error {
   DLOG(ERROR) << [error UTF8String];
   base::AutoLock lock(lock_);
   if (frameReceiver_)
     frameReceiver_->ReceiveError(FROM_HERE, [error UTF8String]);
 }
 
 @end