Replace media::VideoCapture::VideoFrameBuffer with media::VideoFrame.

content/renderer/media/video_capture_impl.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 "content/renderer/media/video_capture_impl.h"
 
 #include "base/bind.h"
 #include "base/stl_util.h"
 #include "content/child/child_process.h"
 #include "content/common/media/video_capture_messages.h"
+#include "media/base/bind_to_loop.h"
 #include "media/base/limits.h"
 
 namespace content {
 
-struct VideoCaptureImpl::DIBBuffer {
+class VideoCaptureImpl::ClientBuffer : public base::RefCounted<ClientBuffer> {
  public:
-  DIBBuffer(
-      base::SharedMemory* d,
-      media::VideoCapture::VideoFrameBuffer* ptr)
-      : dib(d),
-        mapped_memory(ptr),
-        references(0) {
-  }
-  ~DIBBuffer() {}
+  ClientBuffer(scoped_ptr<base::SharedMemory> buffer,
+               size_t buffer_size,
+               int frame_width,
+               int frame_height,
+               int frame_stride)
+      : buffer(buffer.Pass()),
+        buffer_size(buffer_size),
+        frame_width(frame_width),
+        frame_height(frame_height),
+        frame_stride(frame_stride) {}
+  const scoped_ptr<base::SharedMemory> buffer;
+  const size_t buffer_size;
+  const int frame_width;   // In pixels.
+  const int frame_height;  // In pixels.
+  const int frame_stride;  // In pixels.
 
-  scoped_ptr<base::SharedMemory> dib;
-  scoped_refptr<media::VideoCapture::VideoFrameBuffer> mapped_memory;
+ private:
+  friend class base::RefCounted<ClientBuffer>;
 
-  // Number of clients which hold this DIB.
-  int references;
+  virtual ~ClientBuffer() {}
+
+  DISALLOW_COPY_AND_ASSIGN(ClientBuffer);
 };
 
 bool VideoCaptureImpl::CaptureStarted() {
   return state_ == VIDEO_CAPTURE_STATE_STARTED;
 }
 
 int VideoCaptureImpl::CaptureWidth() {
   return capture_format_.width;
 }
 
 int VideoCaptureImpl::CaptureHeight() {
   return capture_format_.height;
 }
 
 int VideoCaptureImpl::CaptureFrameRate() {
   return capture_format_.frame_rate;
 }
 
 VideoCaptureImpl::VideoCaptureImpl(
     const media::VideoCaptureSessionId id,
     base::MessageLoopProxy* capture_message_loop_proxy,
     VideoCaptureMessageFilter* filter)
     : VideoCapture(),
       message_filter_(filter),
       capture_message_loop_proxy_(capture_message_loop_proxy),
       io_message_loop_proxy_(ChildProcess::current()->io_message_loop_proxy()),
       device_id_(0),
+      client_buffer_weak_this_factory_(this),
       video_type_(media::PIXEL_FORMAT_I420),
       device_info_available_(false),
       suspended_(false),
       state_(VIDEO_CAPTURE_STATE_STOPPED) {
   DCHECK(filter);
   capture_format_.session_id = id;
 }
 
-VideoCaptureImpl::~VideoCaptureImpl() {
-  STLDeleteValues(&cached_dibs_);
-}
+VideoCaptureImpl::~VideoCaptureImpl() {}
 
 void VideoCaptureImpl::Init() {
   if (!io_message_loop_proxy_->BelongsToCurrentThread()) {
     io_message_loop_proxy_->PostTask(FROM_HERE,
         base::Bind(&VideoCaptureImpl::AddDelegateOnIOThread,
                    base::Unretained(this)));
   } else {
     AddDelegateOnIOThread();
   }
 }
@@ skipping 13 matching lines @@
       base::Bind(&VideoCaptureImpl::DoStartCaptureOnCaptureThread,
                  base::Unretained(this), handler, capability));
 }
 
 void VideoCaptureImpl::StopCapture(media::VideoCapture::EventHandler* handler) {
   capture_message_loop_proxy_->PostTask(FROM_HERE,
       base::Bind(&VideoCaptureImpl::DoStopCaptureOnCaptureThread,
                  base::Unretained(this), handler));
 }
 
-void VideoCaptureImpl::FeedBuffer(scoped_refptr<VideoFrameBuffer> buffer) {
-  capture_message_loop_proxy_->PostTask(FROM_HERE,
-      base::Bind(&VideoCaptureImpl::DoFeedBufferOnCaptureThread,
-                 base::Unretained(this), buffer));
-}
-
 void VideoCaptureImpl::OnBufferCreated(
     base::SharedMemoryHandle handle,
     int length, int buffer_id) {
   capture_message_loop_proxy_->PostTask(FROM_HERE,
       base::Bind(&VideoCaptureImpl::DoBufferCreatedOnCaptureThread,
                  base::Unretained(this), handle, length, buffer_id));
 }
 
 void VideoCaptureImpl::OnBufferReceived(int buffer_id, base::Time timestamp) {
   capture_message_loop_proxy_->PostTask(FROM_HERE,
@@ skipping 110 matching lines @@
   // A handler can be in only one client list.
   // If this handler is in any client list, we can just remove it from
   // that client list and don't have to run the other following RemoveClient().
   RemoveClient(handler, &clients_pending_on_filter_) ||
   RemoveClient(handler, &clients_pending_on_restart_) ||
   RemoveClient(handler, &clients_);
 
   if (clients_.empty()) {
     DVLOG(1) << "StopCapture: No more client, stopping ...";
     StopDevice();
+    client_buffers_.clear();
+    client_buffer_weak_this_factory_.InvalidateWeakPtrs();
   }
 }
 
-void VideoCaptureImpl::DoFeedBufferOnCaptureThread(
-    scoped_refptr<VideoFrameBuffer> buffer) {
-  DCHECK(capture_message_loop_proxy_->BelongsToCurrentThread());
-
-  CachedDIB::iterator it;
-  for (it = cached_dibs_.begin(); it != cached_dibs_.end(); ++it) {
-    if (buffer.get() == it->second->mapped_memory.get())
-      break;
-  }
-
-  if (it != cached_dibs_.end() && it->second) {
-    DCHECK_GT(it->second->references, 0);
-    --it->second->references;
-    if (it->second->references == 0) {
-      Send(new VideoCaptureHostMsg_BufferReady(device_id_, it->first));
-    }
-  }
-}
-
 void VideoCaptureImpl::DoBufferCreatedOnCaptureThread(
     base::SharedMemoryHandle handle,
     int length, int buffer_id) {
   DCHECK(capture_message_loop_proxy_->BelongsToCurrentThread());
 
   // In case client calls StopCapture before the arrival of created buffer,
   // just close this buffer and return.
   if (state_ != VIDEO_CAPTURE_STATE_STARTED) {
     base::SharedMemory::CloseHandle(handle);
     return;
   }
 
   DCHECK(device_info_available_);
 
-  media::VideoCapture::VideoFrameBuffer* buffer;
-  DCHECK(cached_dibs_.find(buffer_id) == cached_dibs_.end());
+  DCHECK(client_buffers_.find(buffer_id) == client_buffers_.end());

[Ami GONE FROM CHROMIUM, 2013/09/13 00:26:35]

fwiw, 
mymap.find(key) == mymap.end()
is equivalent to but longer than
mymap.count(key) == 0
or even
!mymap.count(key)
just sayin'.

For my money, if what you're doing is "make sure my insert is neither a no-op
nor a silent overwrite" then the best idiom is
bool inserted = mymap.insert(make_pair(key, value));
DCHECK(inserted);
because it involves only a single walk of the map, and says what it does instead
of breaking it up into multiple statements whose interrelation may be less than
clear.

But obvs. this is all personal taste.

[sheu, 2013/09/16 19:09:11]

Sure, this way works.

 
-  base::SharedMemory* dib = new base::SharedMemory(handle, false);
-  dib->Map(length);
-  buffer = new VideoFrameBuffer();
-  buffer->memory_pointer = static_cast<uint8*>(dib->memory());
-  buffer->buffer_size = length;
-  buffer->width = device_info_.width;
-  buffer->height = device_info_.height;
-  buffer->stride = device_info_.width;
+  scoped_ptr<base::SharedMemory> shm(new base::SharedMemory(handle, false));
+  if (!shm->Map(length)) {
+    DLOG(ERROR) << "DoBufferCreatedOnCaptureThread: Map() failed.";
+    return;
+  }
 
-  DIBBuffer* dib_buffer = new DIBBuffer(dib, buffer);
-  cached_dibs_[buffer_id] = dib_buffer;
+  client_buffers_[buffer_id] =
+      make_scoped_refptr(new ClientBuffer(shm.Pass(),
+                                          length,
+                                          device_info_.width,
+                                          device_info_.height,
+                                          device_info_.width));
 }
 
 void VideoCaptureImpl::DoBufferReceivedOnCaptureThread(
     int buffer_id, base::Time timestamp) {
   DCHECK(capture_message_loop_proxy_->BelongsToCurrentThread());
 
   if (state_ != VIDEO_CAPTURE_STATE_STARTED || suspended_) {
     Send(new VideoCaptureHostMsg_BufferReady(device_id_, buffer_id));
     return;
   }
 
-  media::VideoCapture::VideoFrameBuffer* buffer;
-  DCHECK(cached_dibs_.find(buffer_id) != cached_dibs_.end());
-  buffer = cached_dibs_[buffer_id]->mapped_memory.get();
-  buffer->timestamp = timestamp;
+  ClientBufferMap::iterator iter = client_buffers_.find(buffer_id);
+  DCHECK(iter != client_buffers_.end());
+  scoped_refptr<ClientBuffer> buffer = iter->second;
+  scoped_refptr<media::VideoFrame> frame =
+      media::VideoFrame::WrapExternalSharedMemory(
+          media::VideoFrame::I420,
+          gfx::Size(buffer->frame_stride, buffer->frame_height),
+          gfx::Rect(0, 0, buffer->frame_width, buffer->frame_height),
+          gfx::Size(buffer->frame_width, buffer->frame_height),
+          reinterpret_cast<uint8*>(buffer->buffer->memory()),
+          buffer->buffer_size,
+          buffer->buffer->handle(),
+          // TODO(sheu): convert VideoCaptureMessageFilter::Delegate to use
+          // base::TimeTicks instead of base::Time.  http://crbug.com/249215
+          timestamp - base::Time::UnixEpoch(),
+          media::BindToLoop(

[Ami GONE FROM CHROMIUM, 2013/09/13 00:26:35]

Only a lack of faith by base/bind's OWNERS that this would be a generally useful
facility when I first introduced it.

+              capture_message_loop_proxy_,
+              base::Bind(
+                  &VideoCaptureImpl::DoClientBufferFinishedOnCaptureThread,
+                  client_buffer_weak_this_factory_.GetWeakPtr(),
+                  buffer_id,
+                  buffer)));
 
-  for (ClientInfo::iterator it = clients_.begin(); it != clients_.end(); ++it) {
-    it->first->OnBufferReady(this, buffer);
-  }
-  cached_dibs_[buffer_id]->references = clients_.size();
+  for (ClientInfo::iterator it = clients_.begin(); it != clients_.end(); ++it)
+    it->first->OnFrameReady(this, frame);
+}
+
+void VideoCaptureImpl::DoClientBufferFinishedOnCaptureThread(
+    int buffer_id,
+    const scoped_refptr<ClientBuffer>& buffer) {
+  DCHECK(capture_message_loop_proxy_->BelongsToCurrentThread());
+  Send(new VideoCaptureHostMsg_BufferReady(device_id_, buffer_id));
 }
 
 void VideoCaptureImpl::DoStateChangedOnCaptureThread(VideoCaptureState state) {
   DCHECK(capture_message_loop_proxy_->BelongsToCurrentThread());
 
   switch (state) {
     case VIDEO_CAPTURE_STATE_STARTED:
       break;
     case VIDEO_CAPTURE_STATE_STOPPED:
       state_ = VIDEO_CAPTURE_STATE_STOPPED;
       DVLOG(1) << "OnStateChanged: stopped!, device_id = " << device_id_;
-      STLDeleteValues(&cached_dibs_);
+      client_buffers_.clear();
+      client_buffer_weak_this_factory_.InvalidateWeakPtrs();
       if (!clients_.empty() || !clients_pending_on_restart_.empty())
         RestartCapture();
       break;
     case VIDEO_CAPTURE_STATE_PAUSED:
       for (ClientInfo::iterator it = clients_.begin();
            it != clients_.end(); ++it) {
         it->first->OnPaused(this);
       }
       break;
     case VIDEO_CAPTURE_STATE_ERROR:
@@ skipping 17 matching lines @@
       state_ = VIDEO_CAPTURE_STATE_ENDED;
       break;
     default:
       break;
   }
 }
 
 void VideoCaptureImpl::DoDeviceInfoReceivedOnCaptureThread(
     const media::VideoCaptureParams& device_info) {
   DCHECK(capture_message_loop_proxy_->BelongsToCurrentThread());
-  DCHECK(!ClientHasDIB());
-
-  STLDeleteValues(&cached_dibs_);
+  DCHECK(client_buffers_.empty());
 
   device_info_ = device_info;
   device_info_available_ = true;
   for (ClientInfo::iterator it = clients_.begin(); it != clients_.end(); ++it) {
     it->first->OnDeviceInfoReceived(this, device_info);
   }
 }
 
 void VideoCaptureImpl::DoDeviceInfoChangedOnCaptureThread(
     const media::VideoCaptureParams& device_info) {
@@ skipping 85 matching lines @@
   message_filter_->RemoveDelegate(this);
   capture_message_loop_proxy_->PostTask(FROM_HERE, task);
 }
 
 void VideoCaptureImpl::Send(IPC::Message* message) {
   io_message_loop_proxy_->PostTask(FROM_HERE,
       base::Bind(base::IgnoreResult(&VideoCaptureMessageFilter::Send),
                  message_filter_.get(), message));
 }
 
-bool VideoCaptureImpl::ClientHasDIB() const {
-  DCHECK(capture_message_loop_proxy_->BelongsToCurrentThread());
-  for (CachedDIB::const_iterator it = cached_dibs_.begin();
-       it != cached_dibs_.end(); ++it) {
-    if (it->second->references > 0)
-      return true;
-  }
-  return false;
-}
-
 bool VideoCaptureImpl::RemoveClient(
     media::VideoCapture::EventHandler* handler,
     ClientInfo* clients) {
   DCHECK(capture_message_loop_proxy_->BelongsToCurrentThread());
   bool found = false;
 
   ClientInfo::iterator it = clients->find(handler);
   if (it != clients->end()) {
     handler->OnStopped(this);
     handler->OnRemoved(this);
     clients->erase(it);
     found = true;
   }
   return found;
 }
 
 }  // namespace content