Let clients interact with VideoCaptureDeviceClient instead of VideoCaptureDevice

media/capture/video/video_capture_device_client.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/video_capture_device_client.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 35 matching lines @@
   size_t mapped_size() const override { return buffer_handle_->mapped_size(); }
   void* data(int plane) override { return buffer_handle_->data(plane); }
   ClientBuffer AsClientBuffer(int plane) override {
     return buffer_handle_->AsClientBuffer(plane);
   }
 #if defined(OS_POSIX) && !defined(OS_MACOSX)
   base::FileDescriptor AsPlatformFile() override {
     return buffer_handle_->AsPlatformFile();
   }
 #endif
+  bool IsBackedByVideoFrame() const override {
+    return buffer_handle_->IsBackedByVideoFrame();
+  }
+  scoped_refptr<VideoFrame> GetVideoFrame() override {
+    return buffer_handle_->GetVideoFrame();
+  }
 
  private:
   ~AutoReleaseBuffer() override { pool_->RelinquishProducerReservation(id_); }
 
   const int id_;
   const scoped_refptr<VideoCaptureBufferPool> pool_;
   const std::unique_ptr<VideoCaptureBufferHandle> buffer_handle_;
 };
 
 VideoCaptureDeviceClient::VideoCaptureDeviceClient(
@@ skipping 212 matching lines @@
 
 void VideoCaptureDeviceClient::OnIncomingCapturedBuffer(
     std::unique_ptr<Buffer> buffer,
     const VideoCaptureFormat& frame_format,
     base::TimeTicks reference_time,
     base::TimeDelta timestamp) {
   // Currently, only I420 pixel format is supported.
   DCHECK_EQ(media::PIXEL_FORMAT_I420, frame_format.pixel_format);
 
   scoped_refptr<VideoFrame> frame;
-  switch (frame_format.pixel_storage) {
-    case media::PIXEL_STORAGE_GPUMEMORYBUFFER: {
-      // Create a VideoFrame to set the correct storage_type and pixel_format.
-      gfx::GpuMemoryBufferHandle handle;
-      frame = VideoFrame::WrapExternalYuvGpuMemoryBuffers(
-          media::PIXEL_FORMAT_I420, frame_format.frame_size,
-          gfx::Rect(frame_format.frame_size), frame_format.frame_size, 0, 0, 0,
-          reinterpret_cast<uint8_t*>(buffer->data(media::VideoFrame::kYPlane)),
-          reinterpret_cast<uint8_t*>(buffer->data(media::VideoFrame::kUPlane)),
-          reinterpret_cast<uint8_t*>(buffer->data(media::VideoFrame::kVPlane)),
-          handle, handle, handle, timestamp);
-      break;
+  if (buffer->IsBackedByVideoFrame()) {
+    frame = buffer->GetVideoFrame();
+    frame->set_timestamp(timestamp);
+  } else {
+    switch (frame_format.pixel_storage) {
+      case media::PIXEL_STORAGE_GPUMEMORYBUFFER: {
+        // Create a VideoFrame to set the correct storage_type and pixel_format.
+        gfx::GpuMemoryBufferHandle handle;
+        frame = VideoFrame::WrapExternalYuvGpuMemoryBuffers(
+            media::PIXEL_FORMAT_I420, frame_format.frame_size,
+            gfx::Rect(frame_format.frame_size), frame_format.frame_size, 0, 0,
+            0, reinterpret_cast<uint8_t*>(
+                   buffer->data(media::VideoFrame::kYPlane)),
+            reinterpret_cast<uint8_t*>(
+                buffer->data(media::VideoFrame::kUPlane)),
+            reinterpret_cast<uint8_t*>(
+                buffer->data(media::VideoFrame::kVPlane)),
+            handle, handle, handle, timestamp);
+        break;
+      }
+      case media::PIXEL_STORAGE_CPU:
+        frame = VideoFrame::WrapExternalSharedMemory(
+            media::PIXEL_FORMAT_I420, frame_format.frame_size,
+            gfx::Rect(frame_format.frame_size), frame_format.frame_size,
+            reinterpret_cast<uint8_t*>(buffer->data()),
+            VideoFrame::AllocationSize(media::PIXEL_FORMAT_I420,
+                                       frame_format.frame_size),
+            base::SharedMemory::NULLHandle(), 0u, timestamp);
+        break;
     }
-    case media::PIXEL_STORAGE_CPU:
-      frame = VideoFrame::WrapExternalSharedMemory(
-          media::PIXEL_FORMAT_I420, frame_format.frame_size,
-          gfx::Rect(frame_format.frame_size), frame_format.frame_size,
-          reinterpret_cast<uint8_t*>(buffer->data()),
-          VideoFrame::AllocationSize(media::PIXEL_FORMAT_I420,
-                                     frame_format.frame_size),
-          base::SharedMemory::NULLHandle(), 0u, timestamp);
-      break;
   }
   if (!frame)
     return;
   frame->metadata()->SetDouble(media::VideoFrameMetadata::FRAME_RATE,
                                frame_format.frame_rate);
   frame->metadata()->SetTimeTicks(media::VideoFrameMetadata::REFERENCE_TIME,
                                   reference_time);
   OnIncomingCapturedVideoFrame(std::move(buffer), frame);
 }
 
 void VideoCaptureDeviceClient::OnIncomingCapturedVideoFrame(

[emircan, 2016/10/10 18:46:13]

As we discussed, lets add a TODO to remove this class. If we can send a metadata
to OnIncomingCapturedBuffer(), this wouldn't be necessary.

[chfremer, 2016/10/11 19:09:07]

Done. Added the TODO to the interface.

     std::unique_ptr<Buffer> buffer,
     const scoped_refptr<VideoFrame>& frame) {
   receiver_->OnIncomingCapturedVideoFrame(std::move(buffer), frame);
 }
 
 std::unique_ptr<media::VideoCaptureDevice::Client::Buffer>
 VideoCaptureDeviceClient::ResurrectLastOutputBuffer(
     const gfx::Size& dimensions,
     media::VideoPixelFormat format,
     media::VideoPixelStorage storage) {
@@ skipping 65 matching lines @@
           reinterpret_cast<uint8_t*>(buffer->data(VideoFrame::kUPlane));
       *v_plane_data =
           reinterpret_cast<uint8_t*>(buffer->data(VideoFrame::kVPlane));
       return buffer;
   }
   NOTREACHED();
   return std::unique_ptr<Buffer>();
 }
 
 }  // namespace media