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.";

[mcasas, 2016/09/16 21:17:07]

Same reasoning as before, remove these two lines.
Note that in this case is worse than others, since a
Release build would remove DLOG(ERROR), but will
have to deal with an empty else branch (which might
be optimized off, but that's something else).

Or, if you really really want to see an error in this case,
consider instead:
DLOG_IF(ERROR, !blob) << "converting captured frame to Blob";
if (blob)
  cb.Run(std::move(blob));

Note the message has change to give information as to
the process that has failed, as opposed to now, where 
the message is essentially stating a fact that could be
deduced by the surrounding code; again, imagine a 
developer of the future trying to decypher some code
that they have never seen.

+    }
+
     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) {

[mcasas, 2016/09/16 21:17:06]

We're only using buffer.bytesused, so pass that uint32_t
instead (try to send as parameters the barest minimum).

+  uint32 src_format;
+
+  if (capture_format_.pixel_format == 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;
+  } else if (capture_format_.pixel_format ==
+             VideoPixelFormat::PIXEL_FORMAT_UYVY) {
+    src_format = libyuv::FOURCC_UYVY;
+  } else if (capture_format_.pixel_format ==
+             VideoPixelFormat::PIXEL_FORMAT_YUY2) {
+    src_format = libyuv::FOURCC_YUY2;
+  } else if (capture_format_.pixel_format ==
+             VideoPixelFormat::PIXEL_FORMAT_I420) {
+    src_format = libyuv::FOURCC_I420;
+  } else if (capture_format_.pixel_format ==
+             VideoPixelFormat::PIXEL_FORMAT_RGB24) {
+    src_format = libyuv::FOURCC_24BG;
+  } else {
+    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