Add task queue to Call.

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 11 matching lines @@
 #include "webrtc/modules/video_coding/include/video_coding.h"
 #include "webrtc/modules/video_coding/include/video_coding_defines.h"
 #include "webrtc/system_wrappers/include/metrics.h"
 #include "webrtc/video/overuse_frame_detector.h"
 #include "webrtc/video/send_statistics_proxy.h"
 #include "webrtc/video_frame.h"
 
 namespace webrtc {
 
 ViEEncoder::ViEEncoder(uint32_t number_of_cores,
-                       ProcessThread* module_process_thread,
                        SendStatisticsProxy* stats_proxy,
                        OveruseFrameDetector* overuse_detector,
                        EncodedImageCallback* sink)
     : number_of_cores_(number_of_cores),
       sink_(sink),
       vp_(VideoProcessing::Create()),
       video_sender_(Clock::GetRealTimeClock(), this, this, this),
       stats_proxy_(stats_proxy),
       overuse_detector_(overuse_detector),
-      time_of_last_frame_activity_ms_(0),
       encoder_config_(),
       last_observed_bitrate_bps_(0),
       encoder_paused_(true),
       encoder_paused_and_dropped_frame_(false),
-      module_process_thread_(module_process_thread),
+      module_process_thread_(nullptr),
       has_received_sli_(false),
       picture_id_sli_(0),
       has_received_rpsi_(false),
       picture_id_rpsi_(0),
       video_suspended_(false) {
-  module_process_thread_->RegisterModule(&video_sender_);
   vp_->EnableTemporalDecimation(true);
 }
 
 vcm::VideoSender* ViEEncoder::video_sender() {
   return &video_sender_;
 }
 
-ViEEncoder::~ViEEncoder() {
+ViEEncoder::~ViEEncoder() {}
+
+void ViEEncoder::RegisterProcessThread(ProcessThread* module_process_thread) {
+  RTC_DCHECK(!module_process_thread_);
+  module_process_thread_ = module_process_thread;
+  module_process_thread_->RegisterModule(&video_sender_);
+}
+void ViEEncoder::DeRegisterProcessThread() {
   module_process_thread_->DeRegisterModule(&video_sender_);
 }
 
 void ViEEncoder::Pause() {
   rtc::CritScope lock(&data_cs_);
   encoder_paused_ = true;
 }
 
 void ViEEncoder::Start() {
   rtc::CritScope lock(&data_cs_);
@@ skipping 74 matching lines @@
   if (encoder_paused_and_dropped_frame_) {
     TRACE_EVENT_ASYNC_END0("webrtc", "EncoderPaused", this);
   }
   encoder_paused_and_dropped_frame_ = false;
 }
 
 void ViEEncoder::EncodeVideoFrame(const VideoFrame& video_frame) {
   VideoCodecType codec_type;
   {
     rtc::CritScope lock(&data_cs_);
-    time_of_last_frame_activity_ms_ = rtc::TimeMillis();
     if (EncoderPaused()) {
       TraceFrameDropStart();
       return;
     }
     TraceFrameDropEnd();
     codec_type = encoder_config_.codecType;
   }
 
   TRACE_EVENT_ASYNC_STEP0("webrtc", "Video", video_frame.render_time_ms(),
                           "Encode");
@@ skipping 28 matching lines @@
     video_sender_.AddVideoFrame(*frame_to_send, &codec_specific_info);
     return;
   }
   video_sender_.AddVideoFrame(*frame_to_send, nullptr);
 }
 
 void ViEEncoder::SendKeyFrame() {
   video_sender_.IntraFrameRequest(0);
 }
 
-int64_t ViEEncoder::time_of_last_frame_activity_ms() {
-  rtc::CritScope lock(&data_cs_);
-  return time_of_last_frame_activity_ms_;
-}
-
 void ViEEncoder::OnSetRates(uint32_t bitrate_bps, int framerate) {
   if (stats_proxy_)
     stats_proxy_->OnSetRates(bitrate_bps, framerate);
 }
 
 int32_t ViEEncoder::Encoded(const EncodedImage& encoded_image,
                             const CodecSpecificInfo* codec_specific_info,
                             const RTPFragmentationHeader* fragmentation) {
-  {
-    rtc::CritScope lock(&data_cs_);
-    time_of_last_frame_activity_ms_ = rtc::TimeMillis();
-  }
   if (stats_proxy_) {
     stats_proxy_->OnSendEncodedImage(encoded_image, codec_specific_info);
   }
 
   int success =
       sink_->Encoded(encoded_image, codec_specific_info, fragmentation);
 
   overuse_detector_->FrameSent(encoded_image._timeStamp);
   return success;
 }
@@ skipping 40 matching lines @@
     video_suspended_ = video_is_suspended;
   }
 
   if (stats_proxy_ && video_suspension_changed) {
     LOG(LS_INFO) << "Video suspend state changed " << video_is_suspended;
     stats_proxy_->OnSuspendChange(video_is_suspended);
   }
 }
 
 }  // namespace webrtc