16 bit capture and GPU&CPU memory buffer support.

media/capture/video/fake_video_capture_device.cc

 // 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/fake_video_capture_device.h"
 
 #include <stddef.h>
 #include <algorithm>
 #include <utility>
 
@@ skipping 95 matching lines @@
       buffer.get(), gfx::PNGCodec::FORMAT_RGBA, 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";
   callback.Run(std::move(blob));
 }
 
 FakeVideoCaptureDevice::FakeVideoCaptureDevice(BufferOwnership buffer_ownership,
-                                               float fake_capture_rate)
+                                               float fake_capture_rate,
+                                               VideoPixelFormat pixel_format)
     : buffer_ownership_(buffer_ownership),
       fake_capture_rate_(fake_capture_rate),
+      pixel_format_(pixel_format),
       current_zoom_(kMinZoom),
       weak_factory_(this) {}
 
 FakeVideoCaptureDevice::~FakeVideoCaptureDevice() {
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
 void FakeVideoCaptureDevice::AllocateAndStart(
     const VideoCaptureParams& params,
     std::unique_ptr<VideoCaptureDevice::Client> client) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   client_ = std::move(client);
 
   // Incoming |params| can be none of the supported formats, so we get the
   // closest thing rounded up. TODO(mcasas): Use the |params|, if they belong to
   // the supported ones, when http://crbug.com/309554 is verified.
   capture_format_.frame_rate = fake_capture_rate_;
   if (params.requested_format.frame_size.width() > 1280)
     capture_format_.frame_size.SetSize(1920, 1080);
   else if (params.requested_format.frame_size.width() > 640)
     capture_format_.frame_size.SetSize(1280, 720);
   else if (params.requested_format.frame_size.width() > 320)
     capture_format_.frame_size.SetSize(640, 480);
   else
     capture_format_.frame_size.SetSize(320, 240);
 
+  capture_format_.pixel_format = pixel_format_;
   if (buffer_ownership_ == BufferOwnership::CLIENT_BUFFERS) {
     capture_format_.pixel_storage = PIXEL_STORAGE_CPU;
     capture_format_.pixel_format = PIXEL_FORMAT_ARGB;
     DVLOG(1) << "starting with client argb buffers";
   } else if (buffer_ownership_ == BufferOwnership::OWN_BUFFERS) {
     capture_format_.pixel_storage = PIXEL_STORAGE_CPU;
-    capture_format_.pixel_format = PIXEL_FORMAT_I420;
-    DVLOG(1) << "starting with own I420 buffers";
+    DVLOG(1) << "starting with own" << VideoPixelFormatToString(pixel_format_)
+             << "buffers";
   }
 
-  if (capture_format_.pixel_format == PIXEL_FORMAT_I420) {
+  if (buffer_ownership_ != BufferOwnership::CLIENT_BUFFERS) {
     fake_frame_.reset(new uint8_t[VideoFrame::AllocationSize(
-        PIXEL_FORMAT_I420, capture_format_.frame_size)]);
+        pixel_format_, capture_format_.frame_size)]);
   }
 
   beep_time_ = base::TimeDelta();
   elapsed_time_ = base::TimeDelta();
 
   if (buffer_ownership_ == BufferOwnership::CLIENT_BUFFERS)
     BeepAndScheduleNextCapture(
         base::TimeTicks::Now(),
         base::Bind(&FakeVideoCaptureDevice::CaptureUsingClientBuffers,
                    weak_factory_.GetWeakPtr()));
@@ skipping 85 matching lines @@
     base::TimeTicks expected_execution_time) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   std::unique_ptr<VideoCaptureDevice::Client::Buffer> capture_buffer(
       client_->ReserveOutputBuffer(capture_format_.frame_size,
                                    capture_format_.pixel_format,
                                    capture_format_.pixel_storage));
   DLOG_IF(ERROR, !capture_buffer) << "Couldn't allocate Capture Buffer";
   DCHECK(capture_buffer->data()) << "Buffer has NO backing memory";
 
-  if (capture_format_.pixel_storage == PIXEL_STORAGE_GPUMEMORYBUFFER &&
-      capture_format_.pixel_format == media::PIXEL_FORMAT_I420) {
+  if (capture_format_.pixel_storage == PIXEL_STORAGE_GPUMEMORYBUFFER) {
     // Since SkBitmap expects a packed&continuous memory region for I420, we
     // need to use |fake_frame_| to draw onto.
     memset(fake_frame_.get(), 0, capture_format_.ImageAllocationSize());
     DrawPacman(false /* use_argb */, fake_frame_.get(), elapsed_time_,
                fake_capture_rate_, capture_format_.frame_size, current_zoom_);
 
     // Copy data from |fake_frame_| into the reserved planes of GpuMemoryBuffer.
     size_t offset = 0;
-    for (size_t i = 0; i < VideoFrame::NumPlanes(PIXEL_FORMAT_I420); ++i) {
+    for (size_t i = 0; i < VideoFrame::NumPlanes(capture_format_.pixel_format);
+         ++i) {
       const size_t plane_size =
-          VideoFrame::PlaneSize(PIXEL_FORMAT_I420, i,
+          VideoFrame::PlaneSize(capture_format_.pixel_format, i,
                                 capture_format_.frame_size)
               .GetArea();
       memcpy(capture_buffer->data(i), fake_frame_.get() + offset, plane_size);
       offset += plane_size;
     }
   } else {
     DCHECK_EQ(capture_format_.pixel_storage, PIXEL_STORAGE_CPU);
     DCHECK_EQ(capture_format_.pixel_format, PIXEL_FORMAT_ARGB);
     uint8_t* data_ptr = static_cast<uint8_t*>(capture_buffer->data());
     memset(data_ptr, 0, capture_buffer->mapped_size());
@@ skipping 35 matching lines @@
   // Don't accumulate any debt if we are lagging behind - just post the next
   // frame immediately and continue as normal.
   const base::TimeTicks next_execution_time =
       std::max(current_time, expected_execution_time + frame_interval);
   const base::TimeDelta delay = next_execution_time - current_time;
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE, base::Bind(next_capture, next_execution_time), delay);
 }
 
 }  // namespace media