refactor video capture in renderer process

content/renderer/media/video_capture_impl.cc

 // Copyright (c) 2011 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/common/child_process.h"
 #include "content/common/media/video_capture_messages.h"
 
-VideoCaptureImpl::DIBBuffer::DIBBuffer(
-    base::SharedMemory* d, media::VideoCapture::VideoFrameBuffer* ptr)
-    : dib(d),
-      mapped_memory(ptr) {}
+struct VideoCaptureImpl::DIBBuffer {
+ public:
+  DIBBuffer(
+      base::SharedMemory* d,
+      media::VideoCapture::VideoFrameBuffer* ptr)
+      : dib(d),
+        mapped_memory(ptr),
+        references(0) {
+  }
+  ~DIBBuffer() {}
 
-VideoCaptureImpl::DIBBuffer::~DIBBuffer() {
-  delete dib;
-}
+  scoped_ptr<base::SharedMemory> dib;
+  scoped_refptr<media::VideoCapture::VideoFrameBuffer> mapped_memory;
+
+  // Number of clients which hold this DIB.
+  int references;
+};
 
 bool VideoCaptureImpl::CaptureStarted() {
   return state_ == kStarted;
 }
 
 int VideoCaptureImpl::CaptureWidth() {
   return current_params_.width;
 }
 
 int VideoCaptureImpl::CaptureHeight() {
@@ skipping 10 matching lines @@
     VideoCaptureMessageFilter* filter)
     : VideoCapture(),
       message_filter_(filter),
       ml_proxy_(ml_proxy),
       device_id_(0),
       video_type_(media::VideoFrame::I420),
       device_info_available_(false),
       state_(kStopped) {
   DCHECK(filter);
   memset(&current_params_, 0, sizeof(current_params_));
-  memset(&new_params_, 0, sizeof(new_params_));
-  current_params_.session_id = new_params_.session_id = id;
+  current_params_.session_id = id;
 }
 
 VideoCaptureImpl::~VideoCaptureImpl() {
   STLDeleteContainerPairSecondPointers(cached_dibs_.begin(),
                                        cached_dibs_.end());
 }
 
 void VideoCaptureImpl::Init() {
   base::MessageLoopProxy* io_message_loop_proxy =
       ChildProcess::current()->io_message_loop_proxy();
@@ skipping 78 matching lines @@
   ml_proxy_->PostTask(FROM_HERE,
       base::Bind(&VideoCaptureImpl::DoDelegateAdded,
                  base::Unretained(this), device_id));
 }
 
 void VideoCaptureImpl::DoStartCapture(
     media::VideoCapture::EventHandler* handler,
     const VideoCaptureCapability& capability) {
   DCHECK(ml_proxy_->BelongsToCurrentThread());
 
-  if (pending_clients_.find(handler) != pending_clients_.end() ||
+  if (state_ == kError) {
+    handler->OnError(this, 1);
+    handler->OnRemoved(this);
+    return;
+  }
+
+  ClientInfo::iterator it1 = clients_pending_on_filter_.find(handler);
+  ClientInfo::iterator it2 = clients_pending_on_restart_.find(handler);
+  if (it1 != clients_pending_on_filter_.end() ||
+      it2 != clients_pending_on_restart_.end() ||
       clients_.find(handler) != clients_.end() ) {
     // This client has started.
     return;
   }
 
   if (!device_id_) {
-    pending_clients_[handler] = capability;
+    clients_pending_on_filter_[handler] = capability;
     return;
   }
 
-  if (capability.resolution_fixed && master_clients_.size()) {
-    bool matches_current_params =
-        CapabilityMatchesParameters(capability, current_params_);
-    bool matches_new_params =
-        CapabilityMatchesParameters(capability, new_params_);
-    if ((state_ == kStarted && !matches_current_params) ||
-        (state_ == kStopping && !matches_new_params)) {
-      // Can't have 2 master clients with different resolutions.
-      handler->OnError(this, 1);
-      handler->OnRemoved(this);
+  handler->OnStarted(this);
+  if (state_ == kStarted) {
+    if (capability.width > current_params_.width ||
+        capability.height > current_params_.height) {
+      StopDevice();
+      DVLOG(1) << "StartCapture: Got client with higher resolution ("
+               << capability.width << ", " << capability.height << ") "
+               << "after started, try to restart.";
+      clients_pending_on_restart_[handler] = capability;
       return;
     }
-  }
 
-  handler->OnStarted(this);
-  clients_[handler] = capability;
-  if (capability.resolution_fixed) {
-    master_clients_.push_back(handler);
-    if (master_clients_.size() > 1) {
-      if (device_info_available_)
-        handler->OnDeviceInfoReceived(this, device_info_);
-      return;
-    }
-  }
-
-  if (state_ == kStarted) {
-    // Take the resolution of master client.
-    if (capability.resolution_fixed &&
-        !CapabilityMatchesParameters(capability, current_params_)) {
-      new_params_.width = capability.width;
-      new_params_.height = capability.height;
-      new_params_.frame_per_second = capability.max_fps;
-      DLOG(INFO) << "StartCapture: Got master client with new resolution ("
-                 << new_params_.width << ", " << new_params_.height << ") "
-                 << "during started, try to restart.";
-      StopDevice();
-    } else if (device_info_available_) {
+    if (device_info_available_) {
       handler->OnDeviceInfoReceived(this, device_info_);
     }
+
+    clients_[handler] = capability;
     return;
   }
 
   if (state_ == kStopping) {
-    if (capability.resolution_fixed || !pending_start()) {
-      new_params_.width = capability.width;
-      new_params_.height = capability.height;
-      new_params_.frame_per_second = capability.max_fps;
-      DLOG(INFO) << "StartCapture: Got new resolution ("
-                 << new_params_.width << ", " << new_params_.height << ") "
-                 << ", already in stopping.";
-    }
+    clients_pending_on_restart_[handler] = capability;
+    DVLOG(1) << "StartCapture: Got new resolution ("
+             << capability.width << ", " << capability.height << ") "
+             << ", during stopping.";
     return;
   }
 
+  clients_[handler] = capability;
   DCHECK_EQ(clients_.size(), 1ul);
   video_type_ = capability.raw_type;
-  new_params_.width = 0;
-  new_params_.height = 0;
-  new_params_.frame_per_second = 0;
   current_params_.width = capability.width;
   current_params_.height = capability.height;
   current_params_.frame_per_second = capability.max_fps;
-  DLOG(INFO) << "StartCapture: resolution ("
-             << current_params_.width << ", " << current_params_.height << ")";
+  DVLOG(1) << "StartCapture: starting with first resolution ("
+           << current_params_.width << ", " << current_params_.height << ")";
 
   StartCaptureInternal();
 }
 
 void VideoCaptureImpl::DoStopCapture(
     media::VideoCapture::EventHandler* handler) {
   DCHECK(ml_proxy_->BelongsToCurrentThread());
 
-  ClientInfo::iterator it = pending_clients_.find(handler);
-  if (it != pending_clients_.end()) {
+  ClientInfo::iterator it = clients_pending_on_filter_.find(handler);
+  if (it != clients_pending_on_filter_.end()) {
     handler->OnStopped(this);
     handler->OnRemoved(this);
-    pending_clients_.erase(it);
+    clients_pending_on_filter_.erase(it);
+    return;
+  }
+  it = clients_pending_on_restart_.find(handler);
+  if (it != clients_pending_on_restart_.end()) {
+    handler->OnStopped(this);
+    handler->OnRemoved(this);
+    clients_pending_on_filter_.erase(it);
     return;
   }
 
   if (clients_.find(handler) == clients_.end())
     return;
 
   handler->OnStopped(this);
   handler->OnRemoved(this);
   clients_.erase(handler);
-  master_clients_.remove(handler);
 
-  // Still have at least one master client.
-  if (master_clients_.size() > 0)
-    return;
-
-  // TODO(wjia): Is it really needed to handle resolution change for non-master
-  // clients, except no client case?
-  if (clients_.size() > 0) {
-    DLOG(INFO) << "StopCapture: No master client.";
-    int max_width = 0;
-    int max_height = 0;
-    int frame_rate = 0;
-    for (ClientInfo::iterator it = clients_.begin();
-         it != clients_.end(); it++) {
-      if (it->second.width > max_width && it->second.height > max_height) {
-        max_width = it->second.width;
-        max_height = it->second.height;
-        frame_rate = it->second.max_fps;
-      }
-    }
-
-    if (state_ == kStarted) {
-      // Only handle resolution reduction.
-      if (max_width < current_params_.width &&
-          max_height < current_params_.height) {
-        new_params_.width = max_width;
-        new_params_.height = max_height;
-        new_params_.frame_per_second = frame_rate;
-        DLOG(INFO) << "StopCapture: New smaller resolution ("
-                   << new_params_.width << ", " << new_params_.height << ") "
-                   << "), stopping ...";
-        StopDevice();
-      }
-      return;
-    }
-
-    if (state_ == kStopping) {
-      new_params_.width = max_width;
-      new_params_.height = max_height;
-      new_params_.frame_per_second = frame_rate;
-      DLOG(INFO) << "StopCapture: New resolution ("
-                 << new_params_.width << ", " << new_params_.height << ") "
-                 << "), during stopping.";
-      return;
-    }
-  } else {
-    new_params_.width = current_params_.width = 0;
-    new_params_.height = current_params_.height = 0;
-    new_params_.frame_per_second = current_params_.frame_per_second = 0;
-    DLOG(INFO) << "StopCapture: No more client, stopping ...";
+  if (clients_.empty()) {
+    DVLOG(1) << "StopCapture: No more client, stopping ...";
     StopDevice();
   }
 }
 
 void VideoCaptureImpl::DoFeedBuffer(scoped_refptr<VideoFrameBuffer> buffer) {
   DCHECK(ml_proxy_->BelongsToCurrentThread());
-  DCHECK(client_side_dibs_.find(buffer) != client_side_dibs_.end());
 
   CachedDIB::iterator it;
   for (it = cached_dibs_.begin(); it != cached_dibs_.end(); it++) {
     if (buffer == it->second->mapped_memory)
       break;
   }
 
   DCHECK(it != cached_dibs_.end());
-  if (client_side_dibs_[buffer] <= 1) {
-    client_side_dibs_.erase(buffer);
+  DCHECK_GT(it->second->references, 0);
+  it->second->references--;
+  if (it->second->references == 0) {
     Send(new VideoCaptureHostMsg_BufferReady(device_id_, it->first));
-  } else {
-    client_side_dibs_[buffer]--;
   }
 }
 
 void VideoCaptureImpl::DoBufferCreated(
     base::SharedMemoryHandle handle,
     int length, int buffer_id) {
   DCHECK(ml_proxy_->BelongsToCurrentThread());
+  DCHECK(device_info_available_);
 
   media::VideoCapture::VideoFrameBuffer* buffer;
   DCHECK(cached_dibs_.find(buffer_id) == cached_dibs_.end());
 
   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 = current_params_.width;
-  buffer->height = current_params_.height;
+  buffer->width = device_info_.width;
+  buffer->height = device_info_.height;
+  buffer->stride = device_info_.width;
 
   DIBBuffer* dib_buffer = new DIBBuffer(dib, buffer);
   cached_dibs_[buffer_id] = dib_buffer;
 }
 
 void VideoCaptureImpl::DoBufferReceived(int buffer_id, base::Time timestamp) {
   DCHECK(ml_proxy_->BelongsToCurrentThread());
 
   if (state_ != kStarted) {
     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;
 
   for (ClientInfo::iterator it = clients_.begin(); it != clients_.end(); it++) {
     it->first->OnBufferReady(this, buffer);
   }
-  client_side_dibs_[buffer] = clients_.size();
+  cached_dibs_[buffer_id]->references = clients_.size();
 }
 
 void VideoCaptureImpl::DoStateChanged(const media::VideoCapture::State& state) {
   DCHECK(ml_proxy_->BelongsToCurrentThread());
 
   switch (state) {
     case media::VideoCapture::kStarted:
       break;
     case media::VideoCapture::kStopped:
       state_ = kStopped;
-      DLOG(INFO) << "OnStateChanged: stopped!, device_id = " << device_id_;
+      DVLOG(1) << "OnStateChanged: stopped!, device_id = " << device_id_;
       STLDeleteValues(&cached_dibs_);
-      if (pending_start())
+      if (!clients_.empty() || !clients_pending_on_restart_.empty())
         RestartCapture();
       break;
     case media::VideoCapture::kPaused:
       for (ClientInfo::iterator it = clients_.begin();
            it != clients_.end(); it++) {
         it->first->OnPaused(this);
       }
       break;
     case media::VideoCapture::kError:
+      DVLOG(1) << "OnStateChanged: error!, device_id = " << device_id_;
       for (ClientInfo::iterator it = clients_.begin();
            it != clients_.end(); it++) {
         // TODO(wjia): browser process would send error code.
         it->first->OnError(this, 1);
         it->first->OnRemoved(this);
       }
       clients_.clear();
-      master_clients_.clear();
-      state_ = kStopped;
-      current_params_.width = current_params_.height = 0;
+      state_ = kError;
       break;
     default:
       break;
   }
 }
 
 void VideoCaptureImpl::DoDeviceInfoReceived(
     const media::VideoCaptureParams& device_info) {
   DCHECK(ml_proxy_->BelongsToCurrentThread());
-  if (state_ != kStarted)
-    return;
+  DCHECK(!ClientHasDIB());
+
+  STLDeleteValues(&cached_dibs_);
 
   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::DoDelegateAdded(int32 device_id) {
-  DLOG(INFO) << "DoDelegateAdded: device_id " << device_id;
+  DVLOG(1) << "DoDelegateAdded: device_id " << device_id;
   DCHECK(ml_proxy_->BelongsToCurrentThread());
 
   device_id_ = device_id;
-  for (ClientInfo::iterator it = pending_clients_.begin();
-       it != pending_clients_.end(); ) {
+  for (ClientInfo::iterator it = clients_pending_on_filter_.begin();
+       it != clients_pending_on_filter_.end(); ) {
     media::VideoCapture::EventHandler* handler = it->first;
     const VideoCaptureCapability capability = it->second;
-    pending_clients_.erase(it++);
+    clients_pending_on_filter_.erase(it++);
     StartCapture(handler, capability);
   }
 }
 
 void VideoCaptureImpl::StopDevice() {
   DCHECK(ml_proxy_->BelongsToCurrentThread());
 
   device_info_available_ = false;
   if (state_ == kStarted) {
     state_ = kStopping;
     Send(new VideoCaptureHostMsg_Stop(device_id_));
     current_params_.width = current_params_.height = 0;
   }
 }
 
 void VideoCaptureImpl::RestartCapture() {
   DCHECK(ml_proxy_->BelongsToCurrentThread());
   DCHECK_EQ(state_, kStopped);
 
-  current_params_.width = new_params_.width;
-  current_params_.height = new_params_.height;
-  current_params_.frame_per_second = new_params_.frame_per_second;
-
-  new_params_.width = 0;
-  new_params_.height = 0;
-  new_params_.frame_per_second = 0;
-
-  DLOG(INFO) << "RestartCapture, " << current_params_.width << ", "
-             << current_params_.height;
+  int width = 0;
+  int height = 0;
+  for (ClientInfo::iterator it = clients_.begin();
+       it != clients_.end(); it++) {
+    if (it->second.width > width)
+      width = it->second.width;
+    if (it->second.height > height)
+      height = it->second.height;
+  }
+  for (ClientInfo::iterator it = clients_pending_on_restart_.begin();
+       it != clients_pending_on_restart_.end(); ) {
+    if (it->second.width > width)
+      width = it->second.width;
+    if (it->second.height > height)
+      height = it->second.height;
+    clients_[it->first] = it->second;
+    clients_pending_on_restart_.erase(it++);
+  }
+  current_params_.width = width;
+  current_params_.height = height;
+  DVLOG(1) << "RestartCapture, " << current_params_.width << ", "
+           << current_params_.height;
   StartCaptureInternal();
 }
 
 void VideoCaptureImpl::StartCaptureInternal() {
   DCHECK(ml_proxy_->BelongsToCurrentThread());
   DCHECK(device_id_);
 
   Send(new VideoCaptureHostMsg_Start(device_id_, current_params_));
   state_ = kStarted;
 }
 
 void VideoCaptureImpl::AddDelegateOnIOThread() {
   message_filter_->AddDelegate(this);
 }
 
 void VideoCaptureImpl::RemoveDelegateOnIOThread(base::Closure task) {
   base::ScopedClosureRunner task_runner(task);
   message_filter_->RemoveDelegate(this);
 }
 
 void VideoCaptureImpl::Send(IPC::Message* message) {
   base::MessageLoopProxy* io_message_loop_proxy =
       ChildProcess::current()->io_message_loop_proxy();
 
   io_message_loop_proxy->PostTask(FROM_HERE,
       base::IgnoreReturn<bool>(base::Bind(&VideoCaptureMessageFilter::Send,
                                           message_filter_.get(), message)));
 }
 
-bool VideoCaptureImpl::CapabilityMatchesParameters(
-    const VideoCaptureCapability& capability,
-    const media::VideoCaptureParams& params) {
-  return (capability.width == params.width &&
-          capability.height == params.height &&
-          capability.max_fps == params.frame_per_second);
+bool VideoCaptureImpl::ClientHasDIB() {
+  CachedDIB::iterator it;
+  for (it = cached_dibs_.begin(); it != cached_dibs_.end(); it++) {
+    if (it->second->references > 0)
+      return true;
+  }
+  return false;
 }