Untangle ViEChannel and ViEEncoder.

webrtc/video/vie_encoder.cc

 /*
  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 90 matching lines @@
   }
  private:
   ViEEncoder* owner_;
 };
 
 ViEEncoder::ViEEncoder(uint32_t number_of_cores,
                        ProcessThread* module_process_thread,
                        SendStatisticsProxy* stats_proxy,
                        I420FrameCallback* pre_encode_callback,
                        PacedSender* pacer,
+                       PayloadRouter* payload_router,
                        BitrateAllocator* bitrate_allocator)
     : number_of_cores_(number_of_cores),
       vp_(VideoProcessing::Create()),
       qm_callback_(new QMVideoSettingsCallback(vp_.get())),
       vcm_(VideoCodingModule::Create(Clock::GetRealTimeClock(),
                                      this,
                                      qm_callback_.get())),
-      send_payload_router_(NULL),
       stats_proxy_(stats_proxy),
       pre_encode_callback_(pre_encode_callback),
       pacer_(pacer),
+      send_payload_router_(payload_router),
       bitrate_allocator_(bitrate_allocator),
       time_of_last_frame_activity_ms_(0),
       encoder_config_(),
       min_transmit_bitrate_kbps_(0),
       last_observed_bitrate_bps_(0),
       target_delay_ms_(0),
       network_is_transmitting_(true),
       encoder_paused_(false),
       encoder_paused_and_dropped_frame_(false),
       module_process_thread_(module_process_thread),
       has_received_sli_(false),
       picture_id_sli_(0),
       has_received_rpsi_(false),
       picture_id_rpsi_(0),
       video_suspended_(false) {
   bitrate_observer_.reset(new ViEBitrateObserver(this));
+  module_process_thread_->RegisterModule(vcm_.get());
 }
 
 bool ViEEncoder::Init() {
   vp_->EnableTemporalDecimation(true);
 
   // Enable/disable content analysis: off by default for now.
   vp_->EnableContentAnalysis(false);
 
   if (vcm_->RegisterTransportCallback(this) != 0) {
     return false;
   }
   if (vcm_->RegisterSendStatisticsCallback(this) != 0) {
     return false;
   }
   return true;
 }
 
-void ViEEncoder::StartThreadsAndSetSharedMembers(
-    rtc::scoped_refptr<PayloadRouter> send_payload_router,
-    VCMProtectionCallback* vcm_protection_callback) {
-  RTC_DCHECK(send_payload_router_ == NULL);
-
-  send_payload_router_ = send_payload_router;
-  vcm_->RegisterProtectionCallback(vcm_protection_callback);
-  module_process_thread_->RegisterModule(vcm_.get());
-}
-
-void ViEEncoder::StopThreadsAndRemoveSharedMembers() {
-  if (bitrate_allocator_)
-    bitrate_allocator_->RemoveBitrateObserver(bitrate_observer_.get());
-  module_process_thread_->DeRegisterModule(vcm_.get());
+VideoCodingModule* ViEEncoder::vcm() const {
+  return vcm_.get();
 }
 
 ViEEncoder::~ViEEncoder() {
+  module_process_thread_->DeRegisterModule(vcm_.get());
+  if (bitrate_allocator_)
+    bitrate_allocator_->RemoveBitrateObserver(bitrate_observer_.get());
 }
 
 void ViEEncoder::SetNetworkTransmissionState(bool is_transmitting) {
   {
     rtc::CritScope lock(&data_cs_);
     network_is_transmitting_ = is_transmitting;
   }
 }
 
 void ViEEncoder::Pause() {
@@ skipping 146 matching lines @@
 
 void ViEEncoder::TraceFrameDropEnd() {
   // End trace event on first frame after encoder resumes, if frame was dropped.
   if (encoder_paused_and_dropped_frame_) {
     TRACE_EVENT_ASYNC_END0("webrtc", "EncoderPaused", this);
   }
   encoder_paused_and_dropped_frame_ = false;
 }
 
 void ViEEncoder::DeliverFrame(VideoFrame video_frame) {
-  RTC_DCHECK(send_payload_router_ != NULL);
   if (!send_payload_router_->active()) {
     // We've paused or we have no channels attached, don't waste resources on
     // encoding.
     return;
   }
   VideoCodecType codec_type;
   {
     rtc::CritScope lock(&data_cs_);
     time_of_last_frame_activity_ms_ = TickTime::MillisecondTimestamp();
     if (EncoderPaused()) {
@@ skipping 273 matching lines @@
     const uint32_t width,
     const uint32_t height) {
   return vp_->SetTargetResolution(width, height, frame_rate);
 }
 
 void QMVideoSettingsCallback::SetTargetFramerate(int frame_rate) {
   vp_->SetTargetFramerate(frame_rate);
 }
 
 }  // namespace webrtc