[Mojo Video Capture] Split OnIncomingCapturedVideoFrame() to OnNewBuffer() + 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 ||
@@ skipping 15 matching lines @@
 
   ~BufferPoolProducerReservation() override {
     buffer_pool_->RelinquishProducerReservation(buffer_id_);
   }
 
  private:
   const scoped_refptr<VideoCaptureBufferPool> buffer_pool_;
   const int buffer_id_;
 };
 
+class BufferPoolConsumerReservation : public Ownership {
+ public:
+  BufferPoolConsumerReservation(
+      scoped_refptr<VideoCaptureBufferPool> buffer_pool,
+      int buffer_id)
+      : buffer_pool_(std::move(buffer_pool)), buffer_id_(buffer_id) {
+    // The code invoking this contstructor is supposed to have already set a
+    // consumer hold on the buffer from pool.
+  }
+
+  ~BufferPoolConsumerReservation() override {
+    buffer_pool_->RelinquishConsumerHold(buffer_id_, 1);
+  }
+
+ private:
+  const scoped_refptr<VideoCaptureBufferPool> buffer_pool_;
+  const int buffer_id_;
+};
+
 class BufferPoolBufferHandleProvider : public BufferHandleProvider {
  public:
   BufferPoolBufferHandleProvider(
       scoped_refptr<VideoCaptureBufferPool> buffer_pool,
       int buffer_id)
       : buffer_pool_(std::move(buffer_pool)), buffer_id_(buffer_id) {}
 
   // Implementation of BufferHandleProvider:
   mojo::ScopedSharedBufferHandle GetHandleForInterProcessTransit() override {
     return buffer_pool_->GetHandleForInterProcessTransit(buffer_id_);
@@ skipping 15 matching lines @@
     : receiver_(std::move(receiver)),
       jpeg_decoder_factory_callback_(jpeg_decoder_factory),
       external_jpeg_decoder_initialized_(false),
       buffer_pool_(std::move(buffer_pool)),
       last_captured_pixel_format_(media::PIXEL_FORMAT_UNKNOWN) {}
 
 VideoCaptureDeviceClient::~VideoCaptureDeviceClient() {
   // This should be on the platform auxiliary thread since
   // |external_jpeg_decoder_| need to be destructed on the same thread as
   // OnIncomingCapturedData.
+
+  for (int buffer_id : buffer_ids_known_by_receiver_) {
+    receiver_->OnBufferRetired(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 166 matching lines @@
   OnIncomingCapturedBuffer(std::move(buffer), output_format, reference_time,
                            timestamp);
 }
 
 media::VideoCaptureDevice::Client::Buffer
 VideoCaptureDeviceClient::ReserveOutputBuffer(
     const gfx::Size& frame_size,
     media::VideoPixelFormat pixel_format,
     media::VideoPixelStorage pixel_storage,
     int frame_feedback_id) {
+  DFAKE_SCOPED_RECURSIVE_LOCK(call_from_producer_);
   DCHECK_GT(frame_size.width(), 0);
   DCHECK_GT(frame_size.height(), 0);
   DCHECK(IsFormatSupported(pixel_format));
 
   int buffer_id_to_drop = VideoCaptureBufferPool::kInvalidId;
   const int buffer_id =
       buffer_pool_->ReserveForProducer(frame_size, pixel_format, pixel_storage,
                                        frame_feedback_id, &buffer_id_to_drop);
-  if (buffer_id_to_drop != VideoCaptureBufferPool::kInvalidId)
-    receiver_->OnBufferDestroyed(buffer_id_to_drop);
+  if (buffer_id_to_drop != VideoCaptureBufferPool::kInvalidId) {
+    // Buffer pool has decided to releasea buffer. Notify receiver in case
+    // the buffer has already been shared with it.
+    if (buffer_ids_known_by_receiver_.find(buffer_id_to_drop) !=
+        buffer_ids_known_by_receiver_.end()) {
+      buffer_ids_known_by_receiver_.erase(buffer_id_to_drop);
+      receiver_->OnBufferRetired(buffer_id_to_drop);
+    }
+  }
   if (buffer_id == VideoCaptureBufferPool::kInvalidId)
     return Buffer();
   return MakeBufferStruct(buffer_pool_, buffer_id, frame_feedback_id);
 }
 
 void VideoCaptureDeviceClient::OnIncomingCapturedBuffer(
     Buffer buffer,
     const VideoCaptureFormat& format,
     base::TimeTicks reference_time,
     base::TimeDelta timestamp) {
+  DFAKE_SCOPED_RECURSIVE_LOCK(call_from_producer_);
   OnIncomingCapturedBufferExt(std::move(buffer), format, reference_time,
                               timestamp, gfx::Rect(format.frame_size),
                               VideoFrameMetadata());
 }
 
 void VideoCaptureDeviceClient::OnIncomingCapturedBufferExt(
     Buffer buffer,
     const VideoCaptureFormat& format,
     base::TimeTicks reference_time,
     base::TimeDelta timestamp,
     gfx::Rect visible_rect,
     const VideoFrameMetadata& additional_metadata) {
-  auto buffer_mojo_handle =
-      buffer_pool_->GetHandleForInterProcessTransit(buffer.id());
-  base::SharedMemoryHandle memory_handle;
-  size_t memory_size = 0;
-  bool read_only_flag = false;
-  const MojoResult unwrap_result_code = mojo::UnwrapSharedMemoryHandle(
-      std::move(buffer_mojo_handle), &memory_handle, &memory_size,
-      &read_only_flag);
-  DCHECK_EQ(MOJO_RESULT_OK, unwrap_result_code);
+  DFAKE_SCOPED_RECURSIVE_LOCK(call_from_producer_);
 
-  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
-          memory_handle,                 // handle
-          0,                             // 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);
+  if (buffer_ids_known_by_receiver_.find(buffer.id()) ==
+      buffer_ids_known_by_receiver_.end()) {
+    receiver_->OnNewBufferHandle(buffer.id(),
+                                 std::move(buffer.handle_provider));
+    buffer_ids_known_by_receiver_.insert(buffer.id());
+  }
 
-  receiver_->OnIncomingCapturedVideoFrame(std::move(buffer), std::move(frame));
+  VideoFrameMetadata metadata;
+  metadata.MergeMetadataFrom(&additional_metadata);
+  metadata.SetDouble(media::VideoFrameMetadata::FRAME_RATE, format.frame_rate);
+  metadata.SetTimeTicks(media::VideoFrameMetadata::REFERENCE_TIME,
+                        reference_time);
+
+  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<BufferPoolConsumerReservation>(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 =
       buffer_pool_->ResurrectLastForProducer(dimensions, format, storage);
   if (buffer_id == VideoCaptureBufferPool::kInvalidId)
     return Buffer();
   return MakeBufferStruct(buffer_pool_, buffer_id, new_frame_feedback_id);
 }
 
 void VideoCaptureDeviceClient::OnError(
     const tracked_objects::Location& from_here,
     const std::string& reason) {
@@ skipping 71 matching lines @@
   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