[Mojo Video Capture] Split OnIncomingCapturedVideoFrame() to OnNewBuffer() and OnFrameReadyInBuffer(

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"
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/video_frame.h"
 #include "media/capture/video/video_capture_buffer_handle.h"
 #include "media/capture/video/video_capture_buffer_pool.h"
 #include "media/capture/video/video_capture_jpeg_decoder.h"
 #include "media/capture/video/video_frame_receiver.h"
 #include "media/capture/video_capture_types.h"
-#include "mojo/public/cpp/system/platform_handle.h"
 #include "third_party/libyuv/include/libyuv.h"
 
 using media::VideoCaptureFormat;
 using media::VideoFrame;
 using media::VideoFrameMetadata;
 
 namespace {
 
 bool IsFormatSupported(media::VideoPixelFormat pixel_format) {
   return (pixel_format == media::PIXEL_FORMAT_I420 ||
           pixel_format == media::PIXEL_FORMAT_Y16);
 }
 }
 
 namespace media {
 
-class BufferPoolProducerReservationReleaser
+template <typename ReleaseTraits>
+class ScopedBufferPoolReservation
     : public VideoCaptureDevice::Client::Buffer::ScopedAccessPermission {
  public:
-  BufferPoolProducerReservationReleaser(
-      scoped_refptr<VideoCaptureBufferPool> buffer_pool,
-      int buffer_id)
+  ScopedBufferPoolReservation(scoped_refptr<VideoCaptureBufferPool> buffer_pool,
+                              int buffer_id)
       : buffer_pool_(std::move(buffer_pool)), buffer_id_(buffer_id) {}
 
-  ~BufferPoolProducerReservationReleaser() override {
-    buffer_pool_->RelinquishProducerReservation(buffer_id_);
+  ~ScopedBufferPoolReservation() override {
+    ReleaseTraits::Release(buffer_pool_, buffer_id_);
   }
 
  private:
   const scoped_refptr<VideoCaptureBufferPool> buffer_pool_;
   const int buffer_id_;
 };
 
+class ProducerReleaseTraits {
+ public:
+  static void Release(const scoped_refptr<VideoCaptureBufferPool>& buffer_pool,
+                      int buffer_id) {
+    buffer_pool->RelinquishProducerReservation(buffer_id);
+  }
+};
+
+class ConsumerReleaseTraits {
+ public:
+  static void Release(const scoped_refptr<VideoCaptureBufferPool>& buffer_pool,
+                      int buffer_id) {
+    buffer_pool->RelinquishConsumerHold(buffer_id, 1);
+  }
+};
+using ScopedBufferPoolConsumerReservation =
+    ScopedBufferPoolReservation<ConsumerReleaseTraits>;

[mcasas, 2017/02/16 23:45:07]

This using seems unused, and I don't think is worth it.

[chfremer, 2017/02/16 23:57:20]

Sorry, this was a temporary idea I later discarded and meant to remove before
uploading.
Done.

+
 class BufferPoolBufferHandleProvider
     : public VideoCaptureDevice::Client::Buffer::HandleProvider {
  public:
   BufferPoolBufferHandleProvider(
       scoped_refptr<VideoCaptureBufferPool> buffer_pool,
       int buffer_id)
       : buffer_pool_(std::move(buffer_pool)), buffer_id_(buffer_id) {}
 
   // Implementation of HandleProvider:
   mojo::ScopedSharedBufferHandle GetHandleForInterProcessTransit() override {
@@ skipping 33 matching lines @@
 }
 
 // static
 VideoCaptureDevice::Client::Buffer VideoCaptureDeviceClient::MakeBufferStruct(
     scoped_refptr<VideoCaptureBufferPool> buffer_pool,
     int buffer_id,
     int frame_feedback_id) {
   return Buffer(
       buffer_id, frame_feedback_id,
       base::MakeUnique<BufferPoolBufferHandleProvider>(buffer_pool, buffer_id),
-      base::MakeUnique<BufferPoolProducerReservationReleaser>(buffer_pool,
-                                                              buffer_id));
+      base::MakeUnique<ScopedBufferPoolReservation<ProducerReleaseTraits>>(
+          buffer_pool, buffer_id));
 }
 
 void VideoCaptureDeviceClient::OnIncomingCapturedData(
     const uint8_t* data,
     int length,
     const VideoCaptureFormat& format,
     int rotation,
     base::TimeTicks reference_time,
     base::TimeDelta timestamp,
     int frame_feedback_id) {
@@ skipping 49 matching lines @@
                           media::PIXEL_STORAGE_CPU, frame_feedback_id);
 #if DCHECK_IS_ON()
   dropped_frame_counter_ = buffer.is_valid() ? 0 : dropped_frame_counter_ + 1;
   if (dropped_frame_counter_ >= kMaxDroppedFrames)
     OnError(FROM_HERE, "Too many frames dropped");
 #endif
   // Failed to reserve I420 output buffer, so drop the frame.
   if (!buffer.is_valid())
     return;
 
-  auto buffer_access = buffer.handle_provider()->GetHandleForInProcessAccess();
+  auto buffer_access = buffer.handle_provider->GetHandleForInProcessAccess();
   uint8_t *y_plane_data, *u_plane_data, *v_plane_data;
   InitializeI420PlanePointers(dimensions, buffer_access->data(), &y_plane_data,
                               &u_plane_data, &v_plane_data);
 
   const int yplane_stride = dimensions.width();
   const int uv_plane_stride = yplane_stride / 2;
   int crop_x = 0;
   int crop_y = 0;
   libyuv::FourCC origin_colorspace = libyuv::FOURCC_ANY;
 
@@ skipping 141 matching lines @@
 
 void VideoCaptureDeviceClient::OnIncomingCapturedBufferExt(
     Buffer buffer,
     const VideoCaptureFormat& format,
     base::TimeTicks reference_time,
     base::TimeDelta timestamp,
     gfx::Rect visible_rect,
     const VideoFrameMetadata& additional_metadata) {
   DFAKE_SCOPED_RECURSIVE_LOCK(call_from_producer_);
 
-  if (!base::ContainsValue(buffer_ids_known_by_receiver_, buffer.id()))
-    buffer_ids_known_by_receiver_.push_back(buffer.id());
+  if (!base::ContainsValue(buffer_ids_known_by_receiver_, buffer.id)) {
+    receiver_->OnNewBufferHandle(buffer.id, std::move(buffer.handle_provider));
+    buffer_ids_known_by_receiver_.push_back(buffer.id);
+  }
 
-  auto buffer_access = buffer.handle_provider()->GetHandleForInProcessAccess();
-  scoped_refptr<media::VideoFrame> frame =
-      media::VideoFrame::WrapExternalSharedMemory(
-          format.pixel_format,               // format
-          format.frame_size,                 // coded_size
-          visible_rect,                      // visible_rect
-          format.frame_size,                 // natural_size
-          buffer_access->data(),             // data
-          buffer_access->mapped_size(),      // data_size
-          base::SharedMemory::NULLHandle(),  // handle
-          0u,                                // shared_memory_offset
-          timestamp);                        // timestamp
-  frame->metadata()->MergeMetadataFrom(&additional_metadata);
-  frame->metadata()->SetDouble(media::VideoFrameMetadata::FRAME_RATE,
-                               format.frame_rate);
-  frame->metadata()->SetTimeTicks(media::VideoFrameMetadata::REFERENCE_TIME,
-                                  reference_time);
+  VideoFrameMetadata metadata;
+  metadata.MergeMetadataFrom(&additional_metadata);
+  metadata.SetDouble(media::VideoFrameMetadata::FRAME_RATE, format.frame_rate);
+  metadata.SetTimeTicks(media::VideoFrameMetadata::REFERENCE_TIME,
+                        reference_time);
 
-  receiver_->OnIncomingCapturedVideoFrame(std::move(buffer), std::move(frame));
+  mojom::VideoFrameInfoPtr info = mojom::VideoFrameInfo::New();
+  info->timestamp = timestamp;
+  info->pixel_format = format.pixel_format;
+  info->storage_type = format.pixel_storage;
+  info->coded_size = format.frame_size;
+  info->visible_rect = visible_rect;
+  info->metadata = metadata.CopyInternalValues();
+
+  buffer_pool_->HoldForConsumers(buffer.id, 1);
+  receiver_->OnFrameReadyInBuffer(
+      buffer.id, buffer.frame_feedback_id,
+      base::MakeUnique<ScopedBufferPoolReservation<ConsumerReleaseTraits>>(
+          buffer_pool_, buffer.id),
+      std::move(info));
 }
 
 media::VideoCaptureDevice::Client::Buffer
 VideoCaptureDeviceClient::ResurrectLastOutputBuffer(
     const gfx::Size& dimensions,
     media::VideoPixelFormat format,
     media::VideoPixelStorage storage,
     int new_frame_feedback_id) {
   DFAKE_SCOPED_RECURSIVE_LOCK(call_from_producer_);
   const int buffer_id =
@@ skipping 59 matching lines @@
   // paddings and/or alignments, but it cannot be smaller.
   DCHECK_GE(static_cast<size_t>(length), format.ImageAllocationSize());
 #if DCHECK_IS_ON()
   dropped_frame_counter_ = buffer.is_valid() ? 0 : dropped_frame_counter_ + 1;
   if (dropped_frame_counter_ >= kMaxDroppedFrames)
     OnError(FROM_HERE, "Too many frames dropped");
 #endif
   // Failed to reserve output buffer, so drop the frame.
   if (!buffer.is_valid())
     return;
-  auto buffer_access = buffer.handle_provider()->GetHandleForInProcessAccess();
+  auto buffer_access = buffer.handle_provider->GetHandleForInProcessAccess();
   memcpy(buffer_access->data(), data, length);
   const VideoCaptureFormat output_format =
       VideoCaptureFormat(format.frame_size, format.frame_rate,
                          media::PIXEL_FORMAT_Y16, media::PIXEL_STORAGE_CPU);
   OnIncomingCapturedBuffer(std::move(buffer), output_format, reference_time,
                            timestamp);
 }
 
 }  // namespace media