Remove V4L2CaptureDelegate{Single,Multi}Plane, VCD::Client::OnIncomingCapturedYuvData()

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 55 matching lines @@
   const int frame_count = elapsed_time.InMilliseconds() * frame_rate / 1000;
 
   const std::string time_string =
       base::StringPrintf("%d:%02d:%02d:%03d %d", hours, minutes, seconds,
                          milliseconds, frame_count);
   canvas.scale(3, 3);
   canvas.drawText(time_string.data(), time_string.length(), 30, 20, paint);
 }
 
 FakeVideoCaptureDevice::FakeVideoCaptureDevice(BufferOwnership buffer_ownership,
-                                               BufferPlanarity planarity,
                                                float fake_capture_rate)
     : buffer_ownership_(buffer_ownership),
-      planarity_(planarity),
       fake_capture_rate_(fake_capture_rate),
       weak_factory_(this) {}
 
 FakeVideoCaptureDevice::~FakeVideoCaptureDevice() {
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
 void FakeVideoCaptureDevice::AllocateAndStart(
     const VideoCaptureParams& params,
     scoped_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);
 
   if (buffer_ownership_ == BufferOwnership::CLIENT_BUFFERS) {
-    if (planarity_ == BufferPlanarity::PACKED) {
-      capture_format_.pixel_storage = PIXEL_STORAGE_CPU;
-      capture_format_.pixel_format = PIXEL_FORMAT_ARGB;
-      DVLOG(1) << "starting with client argb buffers";
-    } else if (planarity_ == BufferPlanarity::TRIPLANAR) {
-      capture_format_.pixel_storage = PIXEL_STORAGE_GPUMEMORYBUFFER;
-      capture_format_.pixel_format = PIXEL_FORMAT_I420;
-      DVLOG(1) << "starting with gmb I420 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";
   }
 
   if (capture_format_.pixel_format == PIXEL_FORMAT_I420) {
     fake_frame_.reset(new uint8_t[VideoFrame::AllocationSize(
         PIXEL_FORMAT_I420, capture_format_.frame_size)]);
   }
@@ skipping 21 matching lines @@
 void FakeVideoCaptureDevice::CaptureUsingOwnBuffers(
     base::TimeTicks expected_execution_time) {
   DCHECK(thread_checker_.CalledOnValidThread());
   const size_t frame_size = capture_format_.ImageAllocationSize();
   memset(fake_frame_.get(), 0, frame_size);
 
   DrawPacman(false /* use_argb */, fake_frame_.get(), elapsed_time_,
              fake_capture_rate_, capture_format_.frame_size);
 
   // Give the captured frame to the client.
-  if (planarity_ == BufferPlanarity::PACKED) {
-    client_->OnIncomingCapturedData(fake_frame_.get(), frame_size,
-                                    capture_format_, 0 /* rotation */,
-                                    base::TimeTicks::Now());
-  } else if (planarity_ == BufferPlanarity::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 /* rotation */,
+                                  base::TimeTicks::Now());
   BeepAndScheduleNextCapture(
       expected_execution_time,
       base::Bind(&FakeVideoCaptureDevice::CaptureUsingOwnBuffers,
                  weak_factory_.GetWeakPtr()));
 }
 
 void FakeVideoCaptureDevice::CaptureUsingClientBuffers(
     base::TimeTicks expected_execution_time) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
@@ skipping 62 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::MessageLoop::current()->PostDelayedTask(
       FROM_HERE, base::Bind(next_capture, next_execution_time), delay);
 }
 
 }  // namespace media