Remove ViECapture usage in VideoSendStream.

Instead a ViECapturer object is allocated and directly operated on. This
additionally exposes ViESharedData to Call to access the module
ProcessThread, moving towards Call ownership of shared resources.

BUG=1695
R=stefan@webrtc.org

Review URL: https://webrtc-codereview.appspot.com/45339004

Cr-Commit-Position: refs/heads/master@{#9119}

talk/media/webrtc/fakewebrtcvideoengine.h

@@ -718,6 +718,7 @@ class FakeWebRtcVideoEngine
   }
   webrtc::ViEChannel* GetChannel(int channel_id) override { return nullptr; }
   webrtc::ViEEncoder* GetEncoder(int channel_id) override { return nullptr; }
+  webrtc::ViESharedData* shared_data() override { return nullptr; }
 
   WEBRTC_FUNC(CreateReceiveChannel, (int& channel, int original_channel)) {
     return CreateChannel(channel, original_channel);

webrtc/video/call.cc

@@ -32,6 +32,7 @@
 #include "webrtc/video/audio_receive_stream.h"
 #include "webrtc/video/video_receive_stream.h"
 #include "webrtc/video/video_send_stream.h"
+#include "webrtc/video_engine/vie_shared_data.h"
 #include "webrtc/video_engine/include/vie_base.h"
 #include "webrtc/video_engine/include/vie_codec.h"
 #include "webrtc/video_engine/include/vie_rtp_rtcp.h"
@@ -152,8 +153,8 @@ class Call : public webrtc::Call, public PacketReceiver {
   VideoSendStream::RtpStateMap suspended_video_send_ssrcs_;
 
   VideoEngine* video_engine_;
+  ViESharedData* vie_shared_data_;
   ViERTP_RTCP* rtp_rtcp_;
-  ViECodec* codec_;
   ViERender* render_;
   ViEBase* base_;
   ViENetwork* network_;
@@ -209,9 +210,6 @@ Call::Call(webrtc::VideoEngine* video_engine, const Call::Config& config)
   rtp_rtcp_ = ViERTP_RTCP::GetInterface(video_engine_);
   DCHECK(rtp_rtcp_ != nullptr);
 
-  codec_ = ViECodec::GetInterface(video_engine_);
-  DCHECK(codec_ != nullptr);
-
   network_ = ViENetwork::GetInterface(video_engine_);
 
   // As a workaround for non-existing calls in the old API, create a base
@@ -222,6 +220,7 @@ Call::Call(webrtc::VideoEngine* video_engine, const Call::Config& config)
   base_->CreateChannel(base_channel_id_);
   DCHECK(base_channel_id_ != -1);
   channel_group_ = base_->GetChannelGroup(base_channel_id_);
+  vie_shared_data_ = base_->shared_data();
 
   network_->SetBitrateConfig(base_channel_id_,
                              config_.bitrate_config.min_bitrate_bps,
@@ -241,7 +240,6 @@ Call::~Call() {
 
   base_->Release();
   network_->Release();
-  codec_->Release();
   render_->Release();
   rtp_rtcp_->Release();
   CHECK(webrtc::VideoEngine::Delete(video_engine_));
@@ -288,10 +286,10 @@ webrtc::VideoSendStream* Call::CreateVideoSendStream(
 
   // TODO(mflodman): Base the start bitrate on a current bandwidth estimate, if
   // the call has already started.
-  VideoSendStream* send_stream =
+  VideoSendStream* send_stream = new VideoSendStream(
-      new VideoSendStream(config_.send_transport, overuse_observer_proxy_.get(),
+      config_.send_transport, overuse_observer_proxy_.get(), video_engine_,
-                          video_engine_, channel_group_, config, encoder_config,
+      channel_group_, vie_shared_data_->module_process_thread(), config,
-                          suspended_video_send_ssrcs_, base_channel_id_);
+      encoder_config, suspended_video_send_ssrcs_, base_channel_id_);
 
   // This needs to be taken before send_crit_ as both locks need to be held
   // while changing network state.

webrtc/video/video_send_stream.cc

@@ -25,6 +25,7 @@
 #include "webrtc/video_engine/include/vie_external_codec.h"
 #include "webrtc/video_engine/include/vie_image_process.h"
 #include "webrtc/video_engine/include/vie_network.h"
+#include "webrtc/video_engine/vie_capturer.h"
 #include "webrtc/video_engine/vie_channel.h"
 #include "webrtc/video_engine/vie_channel_group.h"
 #include "webrtc/video_engine/vie_encoder.h"
@@ -109,6 +110,7 @@ VideoSendStream::VideoSendStream(
     CpuOveruseObserver* overuse_observer,
     webrtc::VideoEngine* video_engine,
     ChannelGroup* channel_group,
+    ProcessThread* module_process_thread,
     const VideoSendStream::Config& config,
     const VideoEncoderConfig& encoder_config,
     const std::map<uint32_t, RtpState>& suspended_ssrcs,
@@ -118,6 +120,7 @@ VideoSendStream::VideoSendStream(
       config_(config),
       suspended_ssrcs_(suspended_ssrcs),
       channel_group_(channel_group),
+      module_process_thread_(module_process_thread),
       channel_(-1),
       use_config_bitrate_(true),
       stats_proxy_(Clock::GetRealTimeClock(), config) {
@@ -187,9 +190,8 @@ VideoSendStream::VideoSendStream(
 
   vie_channel_->SetRTCPCName(rtcp_cname);
 
-  capture_ = ViECapture::GetInterface(video_engine);
+  vie_capturer_ = ViECapturer::CreateViECapturer(module_process_thread_);
-  capture_->AllocateExternalCaptureDevice(capture_id_, external_capture_);
+  CHECK_EQ(0, vie_capturer_->RegisterFrameCallback(channel_, vie_encoder_));
-  capture_->ConnectCaptureDevice(capture_id_, channel_);
 
   vie_channel_->RegisterSendTransport(&transport_adapter_);
   // 28 to match packet overhead in ModuleRtpRtcpImpl.
@@ -207,11 +209,11 @@ VideoSendStream::VideoSendStream(
   codec_ = ViECodec::GetInterface(video_engine);
   CHECK(ReconfigureVideoEncoder(encoder_config));
 
-  if (overuse_observer)
+  if (overuse_observer) {
-    video_engine_base_->RegisterCpuOveruseObserver(channel_, overuse_observer);
+    vie_capturer_->RegisterCpuOveruseObserver(overuse_observer);
+  }
   // Registered regardless of monitoring, used for stats.
-  video_engine_base_->RegisterCpuOveruseMetricsObserver(channel_,
+  vie_capturer_->RegisterCpuOveruseMetricsObserver(&stats_proxy_);
-                                                        &stats_proxy_);
 
   video_engine_base_->RegisterSendSideDelayObserver(channel_, &stats_proxy_);
   video_engine_base_->RegisterSendStatisticsProxy(channel_, &stats_proxy_);
@@ -233,7 +235,6 @@ VideoSendStream::VideoSendStream(
 }
 
 VideoSendStream::~VideoSendStream() {
-  capture_->DeregisterObserver(capture_id_);
   codec_->DeregisterEncoderObserver(channel_);
 
   vie_channel_->RegisterSendFrameCountObserver(nullptr);
@@ -247,8 +248,9 @@ VideoSendStream::~VideoSendStream() {
 
   vie_channel_->DeregisterSendTransport();
 
-  capture_->DisconnectCaptureDevice(channel_);
+  vie_capturer_->RegisterCpuOveruseObserver(nullptr);
-  capture_->ReleaseCaptureDevice(capture_id_);
+  vie_capturer_->DeregisterFrameCallback(vie_encoder_);
+  delete vie_capturer_;
 
   vie_encoder_->DeRegisterExternalEncoder(
       config_.encoder_settings.payload_type);
@@ -256,7 +258,6 @@ VideoSendStream::~VideoSendStream() {
   video_engine_base_->DeleteChannel(channel_);
 
   video_engine_base_->Release();
-  capture_->Release();
   codec_->Release();
 }
 
@@ -266,7 +267,7 @@ void VideoSendStream::IncomingCapturedFrame(const I420VideoFrame& frame) {
     config_.local_renderer->RenderFrame(frame, 0);
 
   stats_proxy_.OnIncomingFrame();
-  external_capture_->IncomingFrame(frame);
+  vie_capturer_->IncomingFrame(frame);
 }
 
 VideoSendStreamInput* VideoSendStream::Input() { return this; }

webrtc/video/video_send_stream.h

@@ -27,14 +27,14 @@
 namespace webrtc {
 
 class CpuOveruseObserver;
-class VideoEngine;
+class ProcessThread;
 class ViEBase;
-class ViECapture;
+class ViECapturer;
-class ViECodec;
 class ViEChannel;
+class ViECodec;
 class ViEEncoder;
-class ViEExternalCapture;
 class ViEExternalCodec;
+class VideoEngine;
 
 namespace internal {
 
@@ -45,6 +45,7 @@ class VideoSendStream : public webrtc::VideoSendStream,
                   CpuOveruseObserver* overuse_observer,
                   webrtc::VideoEngine* video_engine,
                   ChannelGroup* channel_group,
+                  ProcessThread* module_process_thread,
                   const VideoSendStream::Config& config,
                   const VideoEncoderConfig& encoder_config,
                   const std::map<uint32_t, RtpState>& suspended_ssrcs,
@@ -83,16 +84,15 @@ class VideoSendStream : public webrtc::VideoSendStream,
   std::map<uint32_t, RtpState> suspended_ssrcs_;
 
   ChannelGroup* const channel_group_;
+  ProcessThread* const module_process_thread_;
 
   ViEBase* video_engine_base_;
-  ViECapture* capture_;
   ViEChannel* vie_channel_;
   ViECodec* codec_;
   ViEEncoder* vie_encoder_;
-  ViEExternalCapture* external_capture_;
+  ViECapturer* vie_capturer_;
 
   int channel_;
-  int capture_id_;
 
   // Used as a workaround to indicate that we should be using the configured
   // start bitrate initially, instead of the one reported by VideoEngine (which

webrtc/video_engine/include/vie_base.h

@@ -34,7 +34,7 @@ class SendStatisticsProxy;
 class ChannelGroup;
 class ViEChannel;
 class ViEEncoder;
-class ViERenderManager;
+class ViESharedData;
 
 // CpuOveruseObserver is called when a system overuse is detected and
 // VideoEngine cannot keep up the encoding frequency.
@@ -269,6 +269,8 @@ class WEBRTC_DLLEXPORT ViEBase {
       int channel,
       ReceiveStatisticsProxy* receive_statistics_proxy) = 0;
 
+  virtual ViESharedData* shared_data() = 0;
+
  protected:
   ViEBase() {}
   virtual ~ViEBase() {}

webrtc/video_engine/vie_base_impl.h

@@ -67,12 +67,12 @@ class ViEBaseImpl
   virtual int GetVersion(char version[1024]);
   virtual int LastError();
 
+  ViESharedData* shared_data() { return &shared_data_; }
+
  protected:
   explicit ViEBaseImpl(const Config& config);
   virtual ~ViEBaseImpl();
 
-  ViESharedData* shared_data() { return &shared_data_; }
-
  private:
   int CreateChannel(int& video_channel, int original_channel,  // NOLINT
                     bool sender, bool disable_default_encoder);

webrtc/video_engine/vie_capturer.cc

@@ -10,6 +10,7 @@
 
 #include "webrtc/video_engine/vie_capturer.h"
 
+#include "webrtc/base/checks.h"
 #include "webrtc/common_video/libyuv/include/webrtc_libyuv.h"
 #include "webrtc/modules/interface/module_common_types.h"
 #include "webrtc/modules/utility/interface/process_thread.h"
@@ -58,8 +59,7 @@ class RegistrableCpuOveruseMetricsObserver : public CpuOveruseMetricsObserver {
 
 ViECapturer::ViECapturer(int capture_id,
                          int engine_id,
-                         const Config& config,
+                         ProcessThread* module_process_thread)
-                         ProcessThread& module_process_thread)
     : ViEFrameProviderBase(capture_id, engine_id),
       capture_cs_(CriticalSectionWrapper::CreateCriticalSection()),
       effects_and_stats_cs_(CriticalSectionWrapper::CreateCriticalSection()),
@@ -92,11 +92,11 @@ ViECapturer::ViECapturer(int capture_id,
                                    cpu_overuse_metrics_observer_.get())) {
   capture_thread_->Start();
   capture_thread_->SetPriority(kHighPriority);
-  module_process_thread_.RegisterModule(overuse_detector_.get());
+  module_process_thread_->RegisterModule(overuse_detector_.get());
 }
 
 ViECapturer::~ViECapturer() {
-  module_process_thread_.DeRegisterModule(overuse_detector_.get());
+  module_process_thread_->DeRegisterModule(overuse_detector_.get());
 
   // Stop the thread.
   rtc::AtomicOps::Increment(&stop_);
@@ -104,7 +104,7 @@ ViECapturer::~ViECapturer() {
 
   // Stop the camera input.
   if (capture_module_) {
-    module_process_thread_.DeRegisterModule(capture_module_);
+    module_process_thread_->DeRegisterModule(capture_module_);
     capture_module_->DeRegisterCaptureDataCallback();
     capture_module_->Release();
     capture_module_ = NULL;
@@ -124,14 +124,22 @@ ViECapturer::~ViECapturer() {
   delete brightness_frame_stats_;
 }
 
+ViECapturer* ViECapturer::CreateViECapturer(
+    ProcessThread* module_process_thread) {
+  ViECapturer* capturer = new ViECapturer(0, 0, module_process_thread);
+  // Init with nullptr, 0 will set capture as an external capturer.
+  CHECK_EQ(0, capturer->Init(nullptr, 0));
+  return capturer;
+}
+
 ViECapturer* ViECapturer::CreateViECapture(
     int capture_id,
     int engine_id,
     const Config& config,
     VideoCaptureModule* capture_module,
     ProcessThread& module_process_thread) {
-  ViECapturer* capture = new ViECapturer(capture_id, engine_id, config,
+  ViECapturer* capture = new ViECapturer(capture_id, engine_id,
-                                         module_process_thread);
+                                         &module_process_thread);
   if (!capture || capture->Init(capture_module) != 0) {
     delete capture;
     capture = NULL;
@@ -144,7 +152,7 @@ int32_t ViECapturer::Init(VideoCaptureModule* capture_module) {
   capture_module_ = capture_module;
   capture_module_->RegisterCaptureDataCallback(*this);
   capture_module_->AddRef();
-  module_process_thread_.RegisterModule(capture_module_);
+  module_process_thread_->RegisterModule(capture_module_);
   return 0;
 }
 
@@ -155,8 +163,8 @@ ViECapturer* ViECapturer::CreateViECapture(
     const char* device_unique_idUTF8,
     const uint32_t device_unique_idUTF8Length,
     ProcessThread& module_process_thread) {
-  ViECapturer* capture = new ViECapturer(capture_id, engine_id, config,
+  ViECapturer* capture = new ViECapturer(capture_id, engine_id,
-                                         module_process_thread);
+                                         &module_process_thread);
   if (!capture ||
       capture->Init(device_unique_idUTF8, device_unique_idUTF8Length) != 0) {
     delete capture;
@@ -180,7 +188,7 @@ int32_t ViECapturer::Init(const char* device_unique_idUTF8,
   }
   capture_module_->AddRef();
   capture_module_->RegisterCaptureDataCallback(*this);
-  module_process_thread_.RegisterModule(capture_module_);
+  module_process_thread_->RegisterModule(capture_module_);
 
   return 0;
 }

webrtc/video_engine/vie_capturer.h

@@ -49,6 +49,12 @@ class ViECapturer
       protected VideoCaptureDataCallback,
       protected VideoCaptureFeedBack {
  public:
+  ViECapturer(int capture_id,
+              int engine_id,
+              ProcessThread* module_process_thread);
+
+  static ViECapturer* CreateViECapturer(ProcessThread* module_process_thread);
+
   static ViECapturer* CreateViECapture(int capture_id,
                                        int engine_id,
                                        const Config& config,
@@ -102,11 +108,6 @@ class ViECapturer
   void GetCpuOveruseMetrics(CpuOveruseMetrics* metrics) const;
 
  protected:
-  ViECapturer(int capture_id,
-              int engine_id,
-              const Config& config,
-              ProcessThread& module_process_thread);
-
   int32_t Init(VideoCaptureModule* capture_module);
   int32_t Init(const char* device_unique_idUTF8,
                uint32_t device_unique_idUTF8Length);
@@ -145,7 +146,7 @@ class ViECapturer
   rtc::scoped_ptr<CriticalSectionWrapper> effects_and_stats_cs_;
   VideoCaptureModule* capture_module_;
   bool use_external_capture_;
-  ProcessThread& module_process_thread_;
+  ProcessThread* const module_process_thread_;
   const int capture_id_;
 
   // Frame used in IncomingFrameI420.

webrtc/video_engine/vie_shared_data.h

@@ -41,6 +41,9 @@ class ViESharedData {
   ViEChannelManager* channel_manager() { return channel_manager_.get(); }
   ViEInputManager* input_manager() { return input_manager_.get(); }
   ViERenderManager* render_manager() { return render_manager_.get(); }
+  ProcessThread* module_process_thread() {
+    return module_process_thread_.get();
+  }
 
   std::map<int, CpuOveruseObserver*>* overuse_observers() {
     return &overuse_observers_; }