ImageCapture: Implement takePhoto() for Mac AVFoundation

media/capture/video/mac/video_capture_device_mac.mm

 // Copyright (c) 2012 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.
 
 #include "media/capture/video/mac/video_capture_device_mac.h"
 
 #include <IOKit/IOCFPlugIn.h>
 #include <IOKit/usb/IOUSBLib.h>
 #include <IOKit/usb/USBSpec.h>
 #include <stddef.h>
@@ skipping 371 matching lines @@
 void VideoCaptureDeviceMac::StopAndDeAllocate() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(state_ == kCapturing || state_ == kError) << state_;
 
   [capture_device_ setCaptureDevice:nil];
   [capture_device_ setFrameReceiver:nil];
   client_.reset();
   state_ = kIdle;
 }
 
+void VideoCaptureDeviceMac::TakePhoto(TakePhotoCallback callback) {
+  DCHECK(task_runner_->BelongsToCurrentThread());
+  DCHECK(state_ == kCapturing) << state_;
+
+  if (photo_callback_)  // Only one picture can be in flight at a time.
+    return;
+
+  photo_callback_.reset(new TakePhotoCallback(std::move(callback)));
+  [capture_device_ takePhoto];
+}
+
 bool VideoCaptureDeviceMac::Init(
     VideoCaptureDevice::Name::CaptureApiType capture_api_type) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK_EQ(state_, kNotInitialized);
 
   if (capture_api_type != Name::AVFOUNDATION)
     return false;
 
   capture_device_.reset(
       [[VideoCaptureDeviceAVFoundation alloc] initWithFrameReceiver:this]);
 
   if (!capture_device_)
     return false;
 
   state_ = kIdle;
   return true;
 }
 
 void VideoCaptureDeviceMac::ReceiveFrame(const uint8_t* video_frame,
                                          int video_frame_length,
                                          const VideoCaptureFormat& frame_format,
                                          int aspect_numerator,
                                          int aspect_denominator,
                                          base::TimeDelta timestamp) {
-  // This method is safe to call from a device capture thread, i.e. any thread
-  // controlled by AVFoundation.
   if (capture_format_.frame_size != frame_format.frame_size) {
     ReceiveError(FROM_HERE,
                  "Captured resolution " + frame_format.frame_size.ToString() +
                      ", and expected " + capture_format_.frame_size.ToString());
     return;
   }
 
   client_->OnIncomingCapturedData(video_frame, video_frame_length, frame_format,
                                   0, base::TimeTicks::Now(), timestamp);
 }
 
+void VideoCaptureDeviceMac::OnPhotoTaken(const uint8_t* image_data,
+                                         int image_length,
+                                         const std::string& mime_type) {
+  DCHECK(photo_callback_);
+  if (!image_data || !image_length) {
+    OnPhotoError();
+    return;
+  }
+  const std::vector<uint8_t> photo(image_data, image_data + image_length);
+  photo_callback_->Run(mojo::String::From(mime_type),
+                       mojo::Array<uint8_t>::From(photo));

[Robert Sesek, 2016/07/08 19:31:04]

Does this copy the data? Does it take an rvalue reference for move?

[mcasas, 2016/07/08 21:39:28]

From() copies the data in this case [1], which is
what we want since |image_data| belongs to a
CoreMediaGlue::CMSampleBufferRef that has to be
processed synchronously.

[1]
https://cs.chromium.org/chromium/src/mojo/public/cpp/bindings/array.h?sq=pack...

[Robert Sesek, 2016/07/11 15:20:43]

But this isn't being copied from the CoreMedia buffer, it's copying from |photo|
which has already copied the data. It looks like mojo::Array has a vector rvalue
reference ctor that would be a better choice.

[mcasas, 2016/07/11 23:29:59]

Gotcha, done.

+  photo_callback_.reset();
+}
+
+void VideoCaptureDeviceMac::OnPhotoError() {
+  DLOG(ERROR) << __FUNCTION__ << " error taking picture";
+  photo_callback_.reset();
+}
+
 void VideoCaptureDeviceMac::ReceiveError(
     const tracked_objects::Location& from_here,
     const std::string& reason) {
   task_runner_->PostTask(
       FROM_HERE, base::Bind(&VideoCaptureDeviceMac::SetErrorState,
                             weak_factory_.GetWeakPtr(), from_here, reason));
 }
 
 void VideoCaptureDeviceMac::SetErrorState(
     const tracked_objects::Location& from_here,
@@ skipping 13 matching lines @@
   if (![capture_device_ setCaptureHeight:capture_format_.frame_size.height()
                                    width:capture_format_.frame_size.width()
                                frameRate:capture_format_.frame_rate]) {
     ReceiveError(FROM_HERE, "Could not configure capture device.");
     return false;
   }
   return true;
 }
 
 }  // namespace media