Revert of VideoCapture: add support for GpuMemoryBuffer allocation and lifetime mgmt in VideoCaptureBufferPool

media/video/capture/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/video/capture/fake_video_capture_device.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 83 matching lines @@
   capture_format_.frame_rate = 30.0;
   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);
 
-  if (device_type_ == USING_OWN_BUFFERS ||
-      device_type_ == USING_OWN_BUFFERS_TRIPLANAR) {
-    fake_frame_.reset(new uint8[VideoFrame::AllocationSize(
-        VideoFrame::I420, capture_format_.frame_size)]);
-    BeepAndScheduleNextCapture(
-        base::Bind(&FakeVideoCaptureDevice::CaptureUsingOwnBuffers,
-                   weak_factory_.GetWeakPtr()));
-  } else if (device_type_ == USING_CLIENT_BUFFERS_I420 ||
-             device_type_ == USING_CLIENT_BUFFERS_GPU) {
-    DVLOG(1) << "starting with " << (device_type_ == USING_CLIENT_BUFFERS_I420
-                                         ? "Client buffers"
-                                         : "GpuMemoryBuffers");
-    BeepAndScheduleNextCapture(base::Bind(
-        &FakeVideoCaptureDevice::CaptureUsingClientBuffers,
-        weak_factory_.GetWeakPtr(), (device_type_ == USING_CLIENT_BUFFERS_I420
-                                         ? PIXEL_FORMAT_I420
-                                         : PIXEL_FORMAT_GPUMEMORYBUFFER)));
-  } else {
-    client_->OnError("Unknown Fake Video Capture Device type.");
+  switch (device_type_) {
+    case USING_OWN_BUFFERS:
+      fake_frame_.reset(new uint8[VideoFrame::AllocationSize(
+          VideoFrame::I420, capture_format_.frame_size)]);
+      BeepAndScheduleNextCapture(
+          base::Bind(&FakeVideoCaptureDevice::CaptureUsingOwnBuffers,
+                     weak_factory_.GetWeakPtr()));
+      break;
+    case USING_CLIENT_BUFFERS:
+      BeepAndScheduleNextCapture(
+          base::Bind(&FakeVideoCaptureDevice::CaptureUsingClientBuffers,
+                     weak_factory_.GetWeakPtr()));
+      break;
+    case USING_GPU_MEMORY_BUFFERS:
+      BeepAndScheduleNextCapture(
+          base::Bind(&FakeVideoCaptureDevice::CaptureUsingGpuMemoryBuffers,
+                     weak_factory_.GetWeakPtr()));
+      break;
+    default:
+      client_->OnError("Unknown Fake Video Capture Device type.");
   }
 }
 
 void FakeVideoCaptureDevice::StopAndDeAllocate() {
   DCHECK(thread_checker_.CalledOnValidThread());
   client_.reset();
 }
 
 void FakeVideoCaptureDevice::CaptureUsingOwnBuffers() {
   DCHECK(thread_checker_.CalledOnValidThread());
-  const size_t frame_size = capture_format_.ImageAllocationSize();
+  const size_t frame_size =
+      VideoFrame::AllocationSize(VideoFrame::I420, capture_format_.frame_size);
   memset(fake_frame_.get(), 0, frame_size);
 
   DrawPacman(false  /* use_argb */,
              fake_frame_.get(),
              frame_count_,
              kFakeCapturePeriodMs,
              capture_format_.frame_size);
 
   // Give the captured frame to the client.
-  if (device_type_ == USING_OWN_BUFFERS) {
-    client_->OnIncomingCapturedData(fake_frame_.get(),
-                                    frame_size,
-                                    capture_format_,
-                                    0  /* rotation */,
-                                    base::TimeTicks::Now());
-  } else if (device_type_ == USING_OWN_BUFFERS_TRIPLANAR) {
-    client_->OnIncomingCapturedYuvData(
-        fake_frame_.get(),
-        fake_frame_.get() + capture_format_.frame_size.GetArea(),
-        fake_frame_.get() + capture_format_.frame_size.GetArea() * 5 / 4,
-        capture_format_.frame_size.width(),
-        capture_format_.frame_size.width() / 2,
-        capture_format_.frame_size.width() / 2,
-        capture_format_,
-        0  /* rotation */,
-        base::TimeTicks::Now());
-  }
+  client_->OnIncomingCapturedData(fake_frame_.get(),
+                                  frame_size,
+                                  capture_format_,
+                                  0,
+                                  base::TimeTicks::Now());
   BeepAndScheduleNextCapture(
       base::Bind(&FakeVideoCaptureDevice::CaptureUsingOwnBuffers,
                  weak_factory_.GetWeakPtr()));
 }
 
-void FakeVideoCaptureDevice::CaptureUsingClientBuffers(
-    VideoPixelFormat pixel_format) {
+void FakeVideoCaptureDevice::CaptureUsingClientBuffers() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  scoped_ptr<VideoCaptureDevice::Client::Buffer> capture_buffer(
-      client_->ReserveOutputBuffer(pixel_format, capture_format_.frame_size));
+  const scoped_refptr<VideoCaptureDevice::Client::Buffer> capture_buffer =
+      client_->ReserveOutputBuffer(capture_format_.pixel_format,
+                                   capture_format_.frame_size);
   DLOG_IF(ERROR, !capture_buffer) << "Couldn't allocate Capture Buffer";
+  if (!capture_buffer)
+    return;
 
-  if (capture_buffer.get()) {
-    uint8_t* const data_ptr = static_cast<uint8_t*>(capture_buffer->data());
-    DCHECK(data_ptr) << "Buffer has NO backing memory";
-    memset(data_ptr, 0, capture_buffer->size());
+  uint8_t* const data_ptr = static_cast<uint8_t*>(capture_buffer->data());
+  memset(data_ptr, 0, capture_buffer->size());
+  DCHECK(data_ptr) << "Buffer has NO backing memory";
 
-    DrawPacman(
-        (pixel_format == media::PIXEL_FORMAT_GPUMEMORYBUFFER), /* use_argb */
-        data_ptr,
-        frame_count_,
-        kFakeCapturePeriodMs,
-        capture_format_.frame_size);
+  DrawPacman(false  /* use_argb */,
+             data_ptr,
+             frame_count_,
+             kFakeCapturePeriodMs,
+             capture_format_.frame_size);
 
-    // Give the captured frame to the client.
-    const VideoCaptureFormat format(capture_format_.frame_size,
-                                    capture_format_.frame_rate,
-                                    pixel_format);
-    client_->OnIncomingCapturedBuffer(capture_buffer.Pass(), format,
-                                      base::TimeTicks::Now());
-  }
+  scoped_refptr<VideoFrame> video_frame =
+      VideoFrame::WrapExternalPackedMemory(
+          VideoFrame::I420,
+          capture_format_.frame_size,
+          gfx::Rect(capture_format_.frame_size),
+          capture_format_.frame_size,
+          static_cast<uint8*>(capture_buffer->data()),
+          capture_buffer->size(),
+          base::SharedMemory::NULLHandle(),
+          0,
+          base::TimeDelta(),
+          base::Closure());
 
+  // Give the captured frame to the client.
+  client_->OnIncomingCapturedVideoFrame(capture_buffer,
+                                        video_frame,
+                                        base::TimeTicks::Now());
   BeepAndScheduleNextCapture(
       base::Bind(&FakeVideoCaptureDevice::CaptureUsingClientBuffers,
-                 weak_factory_.GetWeakPtr(), pixel_format));
+                 weak_factory_.GetWeakPtr()));
+}
+
+void FakeVideoCaptureDevice::CaptureUsingGpuMemoryBuffers() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  NOTIMPLEMENTED();
 }
 
 void FakeVideoCaptureDevice::BeepAndScheduleNextCapture(
     const base::Closure& next_capture) {
   // Generate a synchronized beep sound every so many frames.
   if (frame_count_++ % kFakeCaptureBeepCycle == 0)
     FakeAudioInputStream::BeepOnce();
 
   // Reschedule next CaptureTask.
   base::MessageLoop::current()->PostDelayedTask(FROM_HERE, next_capture,
       base::TimeDelta::FromMilliseconds(kFakeCapturePeriodMs));
 }
 
 }  // namespace media