Define EncodedVideoSource and RtcCapturedEncodingVideoCapturer.

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/encoded_video_source_messages.h"
 #include "content/common/media/video_capture_messages.h"
 #include "media/base/limits.h"
 
 namespace content {
 
 struct VideoCaptureImpl::DIBBuffer {
  public:
   DIBBuffer(
       base::SharedMemory* d,
       media::VideoCapture::VideoFrameBuffer* ptr)
@@ skipping 74 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::RequestCapabilities(
+    const media::EncodedVideoSource::RequestCapabilitiesCallback& callback) {
+  DCHECK(callback_.is_null());
+  callback_ = callback;
+
+  // Invoke callback immediately if capabilities is already available.
+  if (!capabilities_.empty())
+    callback_.Run(capabilities_);
+}
+
+void VideoCaptureImpl::StartFetchCapabilities() {
+  capture_message_loop_proxy_->PostTask(FROM_HERE,
+      base::Bind(&VideoCaptureImpl::DoStartFetchCapabilitiesOnCaptureThread,
+                 base::Unretained(this)));
+}
+
+void VideoCaptureImpl::OpenBitstream(
+    media::EncodedVideoSource::Client* client,
+    const media::VideoEncodingParameters& params) {
+  DCHECK(!client_);
+  client_ = client;
+  capture_message_loop_proxy_->PostTask(FROM_HERE,
+      base::Bind(&VideoCaptureImpl::DoOpenBitstreamOnCaptureThread,
+                 base::Unretained(this), params));
+}
+
+void VideoCaptureImpl::CloseBitstream() {
+  capture_message_loop_proxy_->PostTask(FROM_HERE,
+      base::Bind(&VideoCaptureImpl::DoCloseBitstreamOnCaptureThread,
+                 base::Unretained(this)));
+  client_ = NULL;
+}
+
+void VideoCaptureImpl::ReturnBitstreamBuffer(
+    scoped_refptr<const media::EncodedBitstreamBuffer> buffer) {
+  capture_message_loop_proxy_->PostTask(FROM_HERE,
+      base::Bind(&VideoCaptureImpl::DoReturnBitstreamBufferOnCaptureThread,
+                 base::Unretained(this), buffer->buffer_id()));
+}
+
+void VideoCaptureImpl::TrySetBitstreamConfig(
+    const media::RuntimeVideoEncodingParameters& params) {
+  capture_message_loop_proxy_->PostTask(FROM_HERE,
+      base::Bind(&VideoCaptureImpl::DoTrySetBitstreamConfigOnCaptureThread,
+                 base::Unretained(this), params));
+}
+
+void VideoCaptureImpl::OnCapabilitiesAvailable(
+    const media::VideoEncodingCapabilities& capabilities) {
+  capabilities_ = capabilities;
+  if (!callback_.is_null())
+    callback_.Run(capabilities_);
+}
+
+void VideoCaptureImpl::OnBitstreamOpened(
+    const media::VideoEncodingParameters& params,
+    const std::map<int, base::SharedMemoryHandle>& buffers) {
+  capture_message_loop_proxy_->PostTask(FROM_HERE,
+      base::Bind(&VideoCaptureImpl::DoNotifyBitstreamOpenedOnCaptureThread,
+                 base::Unretained(this), params, buffers));
+}
+
+void VideoCaptureImpl::OnBitstreamClosed() {
+  capture_message_loop_proxy_->PostTask(FROM_HERE,
+      base::Bind(&VideoCaptureImpl::DoNotifyBitstreamClosedOnCaptureThread,
+                 base::Unretained(this)));
+}
+
+void VideoCaptureImpl::OnBitstreamConfigChanged(
+      const media::RuntimeVideoEncodingParameters& params) {
+  capture_message_loop_proxy_->PostTask(FROM_HERE,
+      base::Bind(
+          &VideoCaptureImpl::DoNotifyBitstreamConfigChangedOnCaptureThread,
+          base::Unretained(this), params));
+}
+
+void VideoCaptureImpl::OnBitstreamReady(
+    int buffer_id,
+    int size,
+    const media::BufferEncodingMetadata& metadata) {
+  capture_message_loop_proxy_->PostTask(FROM_HERE,
+      base::Bind(&VideoCaptureImpl::DoNotifyBitstreamBufferReadyOnCaptureThread,
+                 base::Unretained(this), buffer_id, size, metadata));
+}
+
 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,
@@ skipping 185 matching lines @@
     it->first->OnBufferReady(this, buffer);
   }
   cached_dibs_[buffer_id]->references = clients_.size();
 }
 
 void VideoCaptureImpl::DoStateChangedOnCaptureThread(VideoCaptureState state) {
   DCHECK(capture_message_loop_proxy_->BelongsToCurrentThread());
 
   switch (state) {
     case VIDEO_CAPTURE_STATE_STARTED:
+      StartFetchCapabilities();
       break;
     case VIDEO_CAPTURE_STATE_STOPPED:
       state_ = VIDEO_CAPTURE_STATE_STOPPED;
       DVLOG(1) << "OnStateChanged: stopped!, device_id = " << device_id_;
       STLDeleteValues(&cached_dibs_);
       if (!clients_.empty() || !clients_pending_on_restart_.empty())
         RestartCapture();
       break;
     case VIDEO_CAPTURE_STATE_PAUSED:
       for (ClientInfo::iterator it = clients_.begin();
@@ skipping 54 matching lines @@
   }
 }
 
 void VideoCaptureImpl::DoSuspendCaptureOnCaptureThread(bool suspend) {
   DVLOG(1) << "DoSuspendCapture: suspend " << (suspend ? "yes" : "no");
   DCHECK(capture_message_loop_proxy_->BelongsToCurrentThread());
 
   suspended_ = suspend;
 }
 
+void VideoCaptureImpl::DoStartFetchCapabilitiesOnCaptureThread() {
+  DCHECK(capture_message_loop_proxy_->BelongsToCurrentThread());
+  Send(new EncodedVideoSourceHostMsg_GetCapabilities(device_id_));
+}
+
+void VideoCaptureImpl::DoOpenBitstreamOnCaptureThread(
+        const media::VideoEncodingParameters& params) {
+  DCHECK(capture_message_loop_proxy_->BelongsToCurrentThread());
+  Send(new EncodedVideoSourceHostMsg_OpenBitstream(device_id_, params));
+}
+
+void VideoCaptureImpl::DoCloseBitstreamOnCaptureThread() {
+  DCHECK(capture_message_loop_proxy_->BelongsToCurrentThread());
+  Send(new EncodedVideoSourceHostMsg_CloseBitstream(device_id_));
+}
+
+void VideoCaptureImpl::DoReturnBitstreamBufferOnCaptureThread(int buffer_id) {
+  DCHECK(capture_message_loop_proxy_->BelongsToCurrentThread());
+  Send(new EncodedVideoSourceHostMsg_BitstreamBufferConsumed(device_id_,
+                                                             buffer_id));
+}
+
+void VideoCaptureImpl::DoTrySetBitstreamConfigOnCaptureThread(
+    const media::RuntimeVideoEncodingParameters& params) {
+  DCHECK(capture_message_loop_proxy_->BelongsToCurrentThread());
+  Send(new EncodedVideoSourceHostMsg_TryConfigureBitstream(device_id_, params));
+}
+
+void VideoCaptureImpl::DoNotifyBitstreamOpenedOnCaptureThread(
+    const media::VideoEncodingParameters& params,
+    const std::map<int, base::SharedMemoryHandle>& buffers) {
+  std::map<int, base::SharedMemoryHandle>::const_iterator it;
+  for (it = buffers.begin(); it != buffers.end(); ++it) {
+    int buffer_id = it->first;
+    buffers_[buffer_id] = new base::SharedMemory(it->second, true);
+  }
+  client_->OnStreaming(params);
+}
+
+void VideoCaptureImpl::DoNotifyBitstreamClosedOnCaptureThread() {
+  std::map<int, base::SharedMemory*>::iterator it;
+  for (it = buffers_.begin(); it != buffers_.end(); ++it) {
+    if (it->second) {
+      it->second->Close();
+      delete it->second;
+    }
+  }
+  buffers_.clear();
+  client_->OnClosed();
+}
+
+void VideoCaptureImpl::DoNotifyBitstreamConfigChangedOnCaptureThread(
+    const media::RuntimeVideoEncodingParameters& params) {
+  client_->OnConfigChanged(params);
+}
+
+void VideoCaptureImpl::DoNotifyBitstreamBufferReadyOnCaptureThread(
+    int buffer_id,
+    int size,
+    const media::BufferEncodingMetadata& metadata) {
+  if (buffers_.find(buffer_id) != buffers_.end()) {
+    base::SharedMemory* shm = buffers_[buffer_id];
+    if (shm->Map(size)) {
+      scoped_refptr<media::EncodedBitstreamBuffer> buffer =
+          new media::EncodedBitstreamBuffer(
+              buffer_id, (uint8*)shm->memory(), size, metadata);
+      client_->OnBufferReady(buffer);
+      shm->Unmap();
+    }
+  }
+}
+
 void VideoCaptureImpl::StopDevice() {
   DCHECK(capture_message_loop_proxy_->BelongsToCurrentThread());
 
   device_info_available_ = false;
   if (state_ == VIDEO_CAPTURE_STATE_STARTED) {
     state_ = VIDEO_CAPTURE_STATE_STOPPING;
     Send(new VideoCaptureHostMsg_Stop(device_id_));
     current_params_.width = current_params_.height = 0;
   }
 }
@@ skipping 68 matching lines @@
   if (it != clients->end()) {
     handler->OnStopped(this);
     handler->OnRemoved(this);
     clients->erase(it);
     found = true;
   }
   return found;
 }
 
 }  // namespace content