Revert of RELAND: 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 85 matching lines @@
   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 (captureDeviceInput_) {
       [captureSession_ removeInput:captureDeviceInput_];
       // No need to release |captureDeviceInput_|, is owned by the session.
       captureDeviceInput_ = nil;
     }
-    if (stillImageOutput_)
-      [captureSession_ removeOutput:stillImageOutput_];
     return YES;
   }
 
   // Look for input device with requested name.
   captureDevice_ = [AVCaptureDeviceGlue deviceWithUniqueID:deviceId];
   if (!captureDevice_) {
     [self
         sendErrorString:[NSString stringWithUTF8String:
                                       "Could not open video capture device."]];
     return NO;
@@ skipping 24 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 ([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 78 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]);
-
-  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) {
-    ExtractBaseAddressAndLength(&baseAddress, &frameSize, sampleBuffer);
+    // 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);
+    }
   } 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