content/renderer/media/video_capture_impl.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4 //
   5 // Notes about usage of this object by VideoCaptureImplManager.
   6 //
   7 // VideoCaptureImplManager access this object by using a Unretained()
   8 // binding and tasks on the IO thread. It is then important that
   9 // VideoCaptureImpl never post task to itself. All operations must be
  10 // synchronous.
  11
  12 #include "content/renderer/media/video_capture_impl.h"
  13
  14 #include "base/bind.h"
  15 #include "base/stl_util.h"
  16 #include "content/child/child_process.h"
  17 #include "content/common/media/video_capture_messages.h"
  18 #include "media/base/bind_to_current_loop.h"
  19 #include "media/base/limits.h"
  20 #include "media/base/video_frame.h"
  21
  22 namespace content {
  23
  24 class VideoCaptureImpl::ClientBuffer
  25     : public base::RefCountedThreadSafe<ClientBuffer> {
  26  public:
  27   ClientBuffer(scoped_ptr<base::SharedMemory> buffer,
  28                size_t buffer_size)
  29       : buffer(buffer.Pass()),
  30         buffer_size(buffer_size) {}
  31   const scoped_ptr<base::SharedMemory> buffer;
  32   const size_t buffer_size;
  33
  34  private:
  35   friend class base::RefCountedThreadSafe<ClientBuffer>;
  36
  37   virtual ~ClientBuffer() {}
  38
  39   DISALLOW_COPY_AND_ASSIGN(ClientBuffer);
  40 };
  41
  42 VideoCaptureImpl::ClientInfo::ClientInfo() {}
  43 VideoCaptureImpl::ClientInfo::~ClientInfo() {}
  44
  45 VideoCaptureImpl::VideoCaptureImpl(
  46     const media::VideoCaptureSessionId session_id,
  47     VideoCaptureMessageFilter* filter)
  48     : message_filter_(filter),
  49       device_id_(0),
  50       session_id_(session_id),
  51       suspended_(false),
  52       state_(VIDEO_CAPTURE_STATE_STOPPED),
  53       weak_factory_(this) {
  54   DCHECK(filter);
  55   thread_checker_.DetachFromThread();
  56 }
  57
  58 VideoCaptureImpl::~VideoCaptureImpl() {
  59   DCHECK(thread_checker_.CalledOnValidThread());
  60 }
  61
  62 void VideoCaptureImpl::Init() {
  63   DCHECK(thread_checker_.CalledOnValidThread());
  64   message_filter_->AddDelegate(this);
  65 }
  66
  67 void VideoCaptureImpl::DeInit() {
  68   DCHECK(thread_checker_.CalledOnValidThread());
  69   if (state_ == VIDEO_CAPTURE_STATE_STARTED)
  70     Send(new VideoCaptureHostMsg_Stop(device_id_));
  71   message_filter_->RemoveDelegate(this);
  72 }
  73
  74 void VideoCaptureImpl::SuspendCapture(bool suspend) {
  75   DCHECK(thread_checker_.CalledOnValidThread());
  76   Send(suspend ?
  77        static_cast<IPC::Message*>(new VideoCaptureHostMsg_Pause(device_id_)) :
  78        static_cast<IPC::Message*>(
  79            new VideoCaptureHostMsg_Resume(device_id_, session_id_, params_)));
  80 }
  81
  82 void VideoCaptureImpl::StartCapture(
  83     int client_id,
  84     const media::VideoCaptureParams& params,
  85     const VideoCaptureStateUpdateCB& state_update_cb,
  86     const VideoCaptureDeliverFrameCB& deliver_frame_cb) {
  87   DCHECK(thread_checker_.CalledOnValidThread());
  88   ClientInfo client_info;
  89   client_info.params = params;
  90   client_info.state_update_cb = state_update_cb;
  91   client_info.deliver_frame_cb = deliver_frame_cb;
  92
  93   if (state_ == VIDEO_CAPTURE_STATE_ERROR) {
  94     state_update_cb.Run(VIDEO_CAPTURE_STATE_ERROR);
  95   } else if (clients_pending_on_filter_.count(client_id) ||
  96              clients_pending_on_restart_.count(client_id) ||
  97              clients_.count(client_id)) {
  98     LOG(FATAL) << "This client has already started.";
  99   } else if (!device_id_) {
 100     clients_pending_on_filter_[client_id] = client_info;
 101   } else {
 102     // Note: |state_| might not be started at this point. But we tell
 103     // client that we have started.
 104     state_update_cb.Run(VIDEO_CAPTURE_STATE_STARTED);
 105     if (state_ == VIDEO_CAPTURE_STATE_STARTED) {
 106       clients_[client_id] = client_info;
 107       // TODO(sheu): Allowing resolution change will require that all
 108       // outstanding clients of a capture session support resolution change.
 109       DCHECK_EQ(params_.resolution_change_policy,
 110                 params.resolution_change_policy);
 111     } else if (state_ == VIDEO_CAPTURE_STATE_STOPPING) {
 112       clients_pending_on_restart_[client_id] = client_info;
 113       DVLOG(1) << "StartCapture: Got new resolution "
 114                << params.requested_format.frame_size.ToString()
 115                << " during stopping.";
 116     } else {
 117       clients_[client_id] = client_info;
 118       if (state_ == VIDEO_CAPTURE_STATE_STARTED)
 119         return;
 120       params_ = params;
 121       if (params_.requested_format.frame_rate >
 122           media::limits::kMaxFramesPerSecond) {
 123         params_.requested_format.frame_rate =
 124             media::limits::kMaxFramesPerSecond;
 125       }
 126       DVLOG(1) << "StartCapture: starting with first resolution "
 127                << params_.requested_format.frame_size.ToString();
 128       first_frame_timestamp_ = base::TimeTicks();
 129       StartCaptureInternal();
 130     }
 131   }
 132 }
 133
 134 void VideoCaptureImpl::StopCapture(int client_id) {
 135   DCHECK(thread_checker_.CalledOnValidThread());
 136
 137   // A client ID can be in only one client list.
 138   // If this ID is in any client list, we can just remove it from
 139   // that client list and don't have to run the other following RemoveClient().
 140   if (!RemoveClient(client_id, &clients_pending_on_filter_)) {
 141     if (!RemoveClient(client_id, &clients_pending_on_restart_)) {
 142       RemoveClient(client_id, &clients_);
 143     }
 144   }
 145
 146   if (clients_.empty()) {
 147     DVLOG(1) << "StopCapture: No more client, stopping ...";
 148     StopDevice();
 149     client_buffers_.clear();
 150     weak_factory_.InvalidateWeakPtrs();
 151   }
 152 }
 153
 154 void VideoCaptureImpl::GetDeviceSupportedFormats(
 155     const VideoCaptureDeviceFormatsCB& callback) {
 156   DCHECK(thread_checker_.CalledOnValidThread());
 157   device_formats_cb_queue_.push_back(callback);
 158   if (device_formats_cb_queue_.size() == 1)
 159     Send(new VideoCaptureHostMsg_GetDeviceSupportedFormats(device_id_,
 160                                                            session_id_));
 161 }
 162
 163 void VideoCaptureImpl::GetDeviceFormatsInUse(
 164     const VideoCaptureDeviceFormatsCB& callback) {
 165   DCHECK(thread_checker_.CalledOnValidThread());
 166   device_formats_in_use_cb_queue_.push_back(callback);
 167   if (device_formats_in_use_cb_queue_.size() == 1)
 168     Send(
 169         new VideoCaptureHostMsg_GetDeviceFormatsInUse(device_id_, session_id_));
 170 }
 171
 172 void VideoCaptureImpl::OnBufferCreated(
 173     base::SharedMemoryHandle handle,
 174     int length, int buffer_id) {
 175   DCHECK(thread_checker_.CalledOnValidThread());
 176
 177   // In case client calls StopCapture before the arrival of created buffer,
 178   // just close this buffer and return.
 179   if (state_ != VIDEO_CAPTURE_STATE_STARTED) {
 180     base::SharedMemory::CloseHandle(handle);
 181     return;
 182   }
 183
 184   scoped_ptr<base::SharedMemory> shm(new base::SharedMemory(handle, false));
 185   if (!shm->Map(length)) {
 186     DLOG(ERROR) << "OnBufferCreated: Map failed.";
 187     return;
 188   }
 189
 190   bool inserted =
 191       client_buffers_.insert(std::make_pair(
 192                                  buffer_id,
 193                                  new ClientBuffer(shm.Pass(),
 194                                                   length))).second;
 195   DCHECK(inserted);
 196 }
 197
 198 void VideoCaptureImpl::OnBufferDestroyed(int buffer_id) {
 199   DCHECK(thread_checker_.CalledOnValidThread());
 200
 201   ClientBufferMap::iterator iter = client_buffers_.find(buffer_id);
 202   if (iter == client_buffers_.end())
 203     return;
 204
 205   DCHECK(!iter->second.get() || iter->second->HasOneRef())
 206       << "Instructed to delete buffer we are still using.";
 207   client_buffers_.erase(iter);
 208 }
 209
 210 void VideoCaptureImpl::OnBufferReceived(int buffer_id,
 211                                         const media::VideoCaptureFormat& format,
 212                                         const gfx::Rect& visible_rect,
 213                                         base::TimeTicks timestamp) {
 214   DCHECK(thread_checker_.CalledOnValidThread());
 215
 216   // The capture pipeline supports only I420 for now.
 217   DCHECK_EQ(format.pixel_format, media::PIXEL_FORMAT_I420);
 218
 219   if (state_ != VIDEO_CAPTURE_STATE_STARTED || suspended_) {
 220     Send(new VideoCaptureHostMsg_BufferReady(device_id_, buffer_id, 0));
 221     return;
 222   }
 223
 224   last_frame_format_ = format;
 225   if (first_frame_timestamp_.is_null())
 226     first_frame_timestamp_ = timestamp;
 227
 228   // Used by chrome/browser/extension/api/cast_streaming/performance_test.cc
 229   TRACE_EVENT_INSTANT2(
 230       "cast_perf_test", "OnBufferReceived",
 231       TRACE_EVENT_SCOPE_THREAD,
 232       "timestamp", timestamp.ToInternalValue(),
 233       "time_delta", (timestamp - first_frame_timestamp_).ToInternalValue());
 234
 235   ClientBufferMap::iterator iter = client_buffers_.find(buffer_id);
 236   DCHECK(iter != client_buffers_.end());
 237   scoped_refptr<ClientBuffer> buffer = iter->second;
 238   scoped_refptr<media::VideoFrame> frame =
 239       media::VideoFrame::WrapExternalPackedMemory(
 240           media::VideoFrame::I420,
 241           last_frame_format_.frame_size,
 242           visible_rect,
 243           gfx::Size(visible_rect.width(), visible_rect.height()),
 244           reinterpret_cast<uint8*>(buffer->buffer->memory()),
 245           buffer->buffer_size,
 246           buffer->buffer->handle(),
 247           timestamp - first_frame_timestamp_,
 248           media::BindToCurrentLoop(
 249               base::Bind(&VideoCaptureImpl::OnClientBufferFinished,
 250                          weak_factory_.GetWeakPtr(),
 251                          buffer_id,
 252                          buffer,
 253                          0)));
 254
 255   for (ClientInfoMap::iterator it = clients_.begin(); it != clients_.end();
 256        ++it) {
 257     it->second.deliver_frame_cb.Run(frame, format, timestamp);
 258   }
 259 }
 260
 261 static void NullReadPixelsCB(const SkBitmap& bitmap) { NOTIMPLEMENTED(); }
 262
 263 void VideoCaptureImpl::OnMailboxBufferReceived(
 264     int buffer_id,
 265     const gpu::MailboxHolder& mailbox_holder,
 266     const media::VideoCaptureFormat& format,
 267     base::TimeTicks timestamp) {
 268   DCHECK(thread_checker_.CalledOnValidThread());
 269
 270   if (state_ != VIDEO_CAPTURE_STATE_STARTED || suspended_) {
 271     Send(new VideoCaptureHostMsg_BufferReady(device_id_, buffer_id, 0));
 272     return;
 273   }
 274
 275   last_frame_format_ = format;
 276   if (first_frame_timestamp_.is_null())
 277     first_frame_timestamp_ = timestamp;
 278
 279   scoped_refptr<media::VideoFrame> frame = media::VideoFrame::WrapNativeTexture(
 280       make_scoped_ptr(new gpu::MailboxHolder(mailbox_holder)),
 281       media::BindToCurrentLoop(
 282           base::Bind(&VideoCaptureImpl::OnClientBufferFinished,
 283                      weak_factory_.GetWeakPtr(),
 284                      buffer_id,
 285                      scoped_refptr<ClientBuffer>())),
 286       last_frame_format_.frame_size,
 287       gfx::Rect(last_frame_format_.frame_size),
 288       last_frame_format_.frame_size,
 289       timestamp - first_frame_timestamp_,
 290       base::Bind(&NullReadPixelsCB));
 291
 292   for (ClientInfoMap::iterator it = clients_.begin(); it != clients_.end();
 293        ++it) {
 294     it->second.deliver_frame_cb.Run(frame, format, timestamp);
 295   }
 296 }
 297
 298 void VideoCaptureImpl::OnClientBufferFinished(
 299     int buffer_id,
 300     const scoped_refptr<ClientBuffer>& /* ignored_buffer */,
 301     uint32 release_sync_point) {
 302   DCHECK(thread_checker_.CalledOnValidThread());
 303   Send(new VideoCaptureHostMsg_BufferReady(
 304       device_id_, buffer_id, release_sync_point));
 305 }
 306
 307 void VideoCaptureImpl::OnStateChanged(VideoCaptureState state) {
 308   DCHECK(thread_checker_.CalledOnValidThread());
 309
 310   switch (state) {
 311     case VIDEO_CAPTURE_STATE_STARTED:
 312       // Camera has started in the browser process. Since we have already
 313       // told all clients that we have started there's nothing to do.
 314       break;
 315     case VIDEO_CAPTURE_STATE_STOPPED:
 316       state_ = VIDEO_CAPTURE_STATE_STOPPED;
 317       DVLOG(1) << "OnStateChanged: stopped!, device_id = " << device_id_;
 318       client_buffers_.clear();
 319       weak_factory_.InvalidateWeakPtrs();
 320       if (!clients_.empty() || !clients_pending_on_restart_.empty())
 321         RestartCapture();
 322       break;
 323     case VIDEO_CAPTURE_STATE_PAUSED:
 324       for (ClientInfoMap::iterator it = clients_.begin();
 325            it != clients_.end(); ++it) {
 326         it->second.state_update_cb.Run(VIDEO_CAPTURE_STATE_PAUSED);
 327       }
 328       break;
 329     case VIDEO_CAPTURE_STATE_ERROR:
 330       DVLOG(1) << "OnStateChanged: error!, device_id = " << device_id_;
 331       for (ClientInfoMap::iterator it = clients_.begin();
 332            it != clients_.end(); ++it) {
 333         it->second.state_update_cb.Run(VIDEO_CAPTURE_STATE_ERROR);
 334       }
 335       clients_.clear();
 336       state_ = VIDEO_CAPTURE_STATE_ERROR;
 337       break;
 338     case VIDEO_CAPTURE_STATE_ENDED:
 339       DVLOG(1) << "OnStateChanged: ended!, device_id = " << device_id_;
 340       for (ClientInfoMap::iterator it = clients_.begin();
 341           it != clients_.end(); ++it) {
 342         // We'll only notify the client that the stream has stopped.
 343         it->second.state_update_cb.Run(VIDEO_CAPTURE_STATE_STOPPED);
 344       }
 345       clients_.clear();
 346       state_ = VIDEO_CAPTURE_STATE_ENDED;
 347       break;
 348     default:
 349       break;
 350   }
 351 }
 352
 353 void VideoCaptureImpl::OnDeviceSupportedFormatsEnumerated(
 354     const media::VideoCaptureFormats& supported_formats) {
 355   DCHECK(thread_checker_.CalledOnValidThread());
 356   for (size_t i = 0; i < device_formats_cb_queue_.size(); ++i)
 357     device_formats_cb_queue_[i].Run(supported_formats);
 358   device_formats_cb_queue_.clear();
 359 }
 360
 361 void VideoCaptureImpl::OnDeviceFormatsInUseReceived(
 362     const media::VideoCaptureFormats& formats_in_use) {
 363   DCHECK(thread_checker_.CalledOnValidThread());
 364   for (size_t i = 0; i < device_formats_in_use_cb_queue_.size(); ++i)
 365     device_formats_in_use_cb_queue_[i].Run(formats_in_use);
 366   device_formats_in_use_cb_queue_.clear();
 367 }
 368
 369 void VideoCaptureImpl::OnDelegateAdded(int32 device_id) {
 370   DCHECK(thread_checker_.CalledOnValidThread());
 371   DVLOG(1) << "OnDelegateAdded: device_id " << device_id;
 372
 373   device_id_ = device_id;
 374   for (ClientInfoMap::iterator it = clients_pending_on_filter_.begin();
 375        it != clients_pending_on_filter_.end(); ) {
 376     int client_id = it->first;
 377     VideoCaptureStateUpdateCB state_update_cb =
 378         it->second.state_update_cb;
 379     VideoCaptureDeliverFrameCB deliver_frame_cb =
 380         it->second.deliver_frame_cb;
 381     const media::VideoCaptureParams params = it->second.params;
 382     clients_pending_on_filter_.erase(it++);
 383     StartCapture(client_id, params, state_update_cb,
 384                  deliver_frame_cb);
 385   }
 386 }
 387
 388 void VideoCaptureImpl::StopDevice() {
 389   DCHECK(thread_checker_.CalledOnValidThread());
 390
 391   if (state_ == VIDEO_CAPTURE_STATE_STARTED) {
 392     state_ = VIDEO_CAPTURE_STATE_STOPPING;
 393     Send(new VideoCaptureHostMsg_Stop(device_id_));
 394     params_.requested_format.frame_size.SetSize(0, 0);
 395   }
 396 }
 397
 398 void VideoCaptureImpl::RestartCapture() {
 399   DCHECK(thread_checker_.CalledOnValidThread());
 400   DCHECK_EQ(state_, VIDEO_CAPTURE_STATE_STOPPED);
 401
 402   int width = 0;
 403   int height = 0;
 404   clients_.insert(clients_pending_on_restart_.begin(),
 405                   clients_pending_on_restart_.end());
 406   clients_pending_on_restart_.clear();
 407   for (ClientInfoMap::iterator it = clients_.begin();
 408        it != clients_.end(); ++it) {
 409     width = std::max(width,
 410                      it->second.params.requested_format.frame_size.width());
 411     height = std::max(height,
 412                       it->second.params.requested_format.frame_size.height());
 413   }
 414   params_.requested_format.frame_size.SetSize(width, height);
 415   DVLOG(1) << "RestartCapture, "
 416            << params_.requested_format.frame_size.ToString();
 417   StartCaptureInternal();
 418 }
 419
 420 void VideoCaptureImpl::StartCaptureInternal() {
 421   DCHECK(thread_checker_.CalledOnValidThread());
 422   DCHECK(device_id_);
 423
 424   Send(new VideoCaptureHostMsg_Start(device_id_, session_id_, params_));
 425   state_ = VIDEO_CAPTURE_STATE_STARTED;
 426 }
 427
 428 void VideoCaptureImpl::Send(IPC::Message* message) {
 429   DCHECK(thread_checker_.CalledOnValidThread());
 430   message_filter_->Send(message);
 431 }
 432
 433 bool VideoCaptureImpl::RemoveClient(int client_id, ClientInfoMap* clients) {
 434   DCHECK(thread_checker_.CalledOnValidThread());
 435   bool found = false;
 436
 437   ClientInfoMap::iterator it = clients->find(client_id);
 438   if (it != clients->end()) {
 439     it->second.state_update_cb.Run(VIDEO_CAPTURE_STATE_STOPPED);
 440     clients->erase(it);
 441     found = true;
 442   }
 443   return found;
 444 }
 445
 446 }  // namespace content