ImageCapture: Implement TakePhoto() for Linux/CrOs

media/capture/video/linux/v4l2_capture_delegate.cc

 // Copyright 2015 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/linux/v4l2_capture_delegate.h"
 
 #include <poll.h>
 #include <sys/fcntl.h>
 #include <sys/ioctl.h>
 #include <sys/mman.h>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/files/file_enumerator.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/strings/stringprintf.h"
 #include "build/build_config.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/capture/video/linux/video_capture_device_linux.h"
+#include "third_party/libyuv/include/libyuv.h"
+#include "third_party/skia/include/core/SkImage.h"
+#include "ui/gfx/codec/png_codec.h"
 
 namespace media {
 
 // Desired number of video buffers to allocate. The actual number of allocated
 // buffers by v4l2 driver can be higher or lower than this number.
 // kNumVideoBuffers should not be too small, or Chrome may not return enough
 // buffers back to driver in time.
 const uint32_t kNumVideoBuffers = 4;
 // Timeout in milliseconds v4l2_thread_ blocks waiting for a frame from the hw.
 // This value has been fine tuned. Before changing or modifying it see
@@ skipping 284 matching lines @@
   if (HANDLE_EINTR(ioctl(device_fd_.get(), VIDIOC_REQBUFS, &r_buffer)) < 0)
     SetErrorState(FROM_HERE, "Failed to VIDIOC_REQBUFS with count = 0");
 
   // At this point we can close the device.
   // This is also needed for correctly changing settings later via VIDIOC_S_FMT.
   device_fd_.reset();
   is_capturing_ = false;
   client_.reset();
 }
 
+void V4L2CaptureDelegate::TakePhoto(
+    VideoCaptureDevice::TakePhotoCallback callback) {
+  DCHECK(v4l2_task_runner_->BelongsToCurrentThread());
+  take_photo_callbacks_.push(std::move(callback));
+}
+
 void V4L2CaptureDelegate::SetRotation(int rotation) {
   DCHECK(v4l2_task_runner_->BelongsToCurrentThread());
   DCHECK(rotation >= 0 && rotation < 360 && rotation % 90 == 0);
   rotation_ = rotation;
 }
 
 V4L2CaptureDelegate::~V4L2CaptureDelegate() {}
 
 bool V4L2CaptureDelegate::MapAndQueueBuffer(int index) {
   v4l2_buffer buffer;
@@ skipping 60 matching lines @@
     const scoped_refptr<BufferTracker>& buffer_tracker =
         buffer_tracker_pool_[buffer.index];
 
     base::TimeDelta timestamp =
         base::TimeDelta::FromSeconds(buffer.timestamp.tv_sec) +
         base::TimeDelta::FromMicroseconds(buffer.timestamp.tv_usec);
     client_->OnIncomingCapturedData(
         buffer_tracker->start(), buffer_tracker->payload_size(),
         capture_format_, rotation_, base::TimeTicks::Now(), timestamp);
 
+    while (!take_photo_callbacks_.empty()) {
+      VideoCaptureDevice::TakePhotoCallback cb =
+          std::move(take_photo_callbacks_.front());
+      take_photo_callbacks_.pop();
+
+      mojom::BlobPtr blob = GetPhotoBlob(buffer_tracker, buffer);
+      if (blob)
+        cb.Run(std::move(blob));
+      else
+        DLOG(ERROR) << "blob pointer is null.";
+    }
+
     if (HANDLE_EINTR(ioctl(device_fd_.get(), VIDIOC_QBUF, &buffer)) < 0) {
       SetErrorState(FROM_HERE, "Failed to enqueue capture buffer");
       return;
     }
   }
 
   v4l2_task_runner_->PostTask(
       FROM_HERE, base::Bind(&V4L2CaptureDelegate::DoCapture, this));
 }
 
+mojom::BlobPtr V4L2CaptureDelegate::GetPhotoBlob(
+    const scoped_refptr<BufferTracker>& buffer_tracker,
+    const v4l2_buffer& buffer) {
+  uint32 src_format;
+  switch (capture_format_.pixel_format) {
+    case VideoPixelFormat::PIXEL_FORMAT_MJPEG: {
+      mojom::BlobPtr blob = mojom::Blob::New();
+      blob->data.resize(buffer.bytesused);
+      memcpy(blob->data.data(), buffer_tracker->start(), buffer.bytesused);
+      blob->mime_type = "image/jpeg";
+      return blob;
+    }
+    case VideoPixelFormat::PIXEL_FORMAT_UYVY:
+      src_format = libyuv::FOURCC_UYVY;
+      break;
+    case VideoPixelFormat::PIXEL_FORMAT_YUY2:
+      src_format = libyuv::FOURCC_YUY2;
+      break;
+    default:

[mcasas, 2016/09/16 18:59:15]

I missed this one. It's a good practice to
not use default: but enumerate all cases
individually, so that, if someone adds a 
new VideoPixelFormat in the future, the 
compiler will fail (unhandled enum entry), 
forcing that developer to think about what 
to do in this routine. (I thought this was 
enforced via a presubmit script, but could 
be in another folder).

Since, in this case you only contemplate
three cases, namely YUY2, UYVY and MJPEG
(although you should also support the other
two in l.50 and l.53), and there's a large
number of other formats you really don't 
expect here, switch-case might be too 
verbose, so I'd say consider if/else instead.

+      DLOG(ERROR) << "FORMAT not supported."
+                  << VideoPixelFormatToString(capture_format_.pixel_format);
+      return nullptr;
+  }
+
+  std::unique_ptr<uint8_t[]> dst_argb(new uint8_t[VideoFrame::AllocationSize(
+      PIXEL_FORMAT_ARGB, capture_format_.frame_size)]);
+  if (ConvertToARGB(buffer_tracker->start(), buffer.bytesused, dst_argb.get(),
+                    capture_format_.frame_size.width() * 4, 0 /* crop_x_pos */,
+                    0 /* crop_y_pos */, capture_format_.frame_size.width(),
+                    capture_format_.frame_size.height(),
+                    capture_format_.frame_size.width(),
+                    capture_format_.frame_size.height(),
+                    libyuv::RotationMode::kRotate0, src_format) != 0) {
+    return nullptr;
+  }
+
+  mojom::BlobPtr blob = mojom::Blob::New();
+  const gfx::PNGCodec::ColorFormat codec_color_format =
+      (kN32_SkColorType == kRGBA_8888_SkColorType) ? gfx::PNGCodec::FORMAT_RGBA
+                                                   : gfx::PNGCodec::FORMAT_BGRA;
+  const bool result = gfx::PNGCodec::Encode(
+      dst_argb.get(), codec_color_format, capture_format_.frame_size,
+      capture_format_.frame_size.width() * 4, true /* discard_transparency */,
+      std::vector<gfx::PNGCodec::Comment>(), &blob->data);
+  DCHECK(result);
+
+  blob->mime_type = "image/png";
+  return blob;
+}
+
 void V4L2CaptureDelegate::SetErrorState(
     const tracked_objects::Location& from_here,
     const std::string& reason) {
   DCHECK(v4l2_task_runner_->BelongsToCurrentThread());
   is_capturing_ = false;
   client_->OnError(from_here, reason);
 }
 
 V4L2CaptureDelegate::BufferTracker::BufferTracker() {}
 
@@ skipping 14 matching lines @@
     DLOG(ERROR) << "Error mmap()ing a V4L2 buffer into userspace";
     return false;
   }
   start_ = static_cast<uint8_t*>(start);
   length_ = buffer.length;
   payload_size_ = 0;
   return true;
 }
 
 }  // namespace media