Move the decoder thread into VideoReceiveStream.

webrtc/video/vie_channel.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 18 matching lines @@
 #include "webrtc/modules/video_processing/include/video_processing.h"
 #include "webrtc/modules/video_render/video_render_defines.h"
 #include "webrtc/system_wrappers/include/metrics.h"
 #include "webrtc/video/call_stats.h"
 #include "webrtc/video/payload_router.h"
 #include "webrtc/video/receive_statistics_proxy.h"
 #include "webrtc/video/report_block_stats.h"
 
 namespace webrtc {
 
-const int kMaxDecodeWaitTimeMs = 50;
 static const int kMaxTargetDelayMs = 10000;
 const int kMinSendSidePacketHistorySize = 600;
 const int kMaxPacketAgeToNack = 450;
 const int kMaxNackListSize = 250;
 
 // Helper class receiving statistics callbacks.
 class ChannelStatsObserver : public CallStatsObserver {
  public:
   explicit ChannelStatsObserver(ViEChannel* owner) : owner_(owner) {}
   virtual ~ChannelStatsObserver() {}
@@ skipping 49 matching lines @@
       vie_sync_(vcm_),
       stats_observer_(new ChannelStatsObserver(this)),
       receive_stats_callback_(nullptr),
       incoming_video_stream_(nullptr),
       intra_frame_observer_(intra_frame_observer),
       rtt_stats_(rtt_stats),
       paced_sender_(paced_sender),
       packet_router_(packet_router),
       bandwidth_observer_(bandwidth_observer),
       transport_feedback_observer_(transport_feedback_observer),
-      decode_thread_(ChannelDecodeThreadFunction, this, "DecodingThread"),
       nack_history_size_sender_(kMinSendSidePacketHistorySize),
       max_nack_reordering_threshold_(kMaxPacketAgeToNack),
       pre_render_callback_(NULL),
       report_block_stats_sender_(new ReportBlockStats()),
       time_of_first_rtt_ms_(-1),
       rtt_sum_ms_(0),
       last_rtt_ms_(0),
       num_rtts_(0),
       rtp_rtcp_modules_(
           CreateRtpRtcpModules(!sender,
@@ skipping 62 matching lines @@
     send_payload_router_->SetSendingRtpModules(std::list<RtpRtcp*>());
   } else {
     module_process_thread_->DeRegisterModule(&vie_sync_);
   }
   for (size_t i = 0; i < num_active_rtp_rtcp_modules_; ++i)
     packet_router_->RemoveRtpModule(rtp_rtcp_modules_[i], sender_);
   for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) {
     module_process_thread_->DeRegisterModule(rtp_rtcp);
     delete rtp_rtcp;
   }
-  if (!sender_)
-    StopDecodeThread();
 }
 
 void ViEChannel::UpdateHistograms() {
   int64_t now = Clock::GetRealTimeClock()->TimeInMilliseconds();
 
   {
     rtc::CritScope lock(&crit_);
     int64_t elapsed_sec = (now - time_of_first_rtt_ms_) / 1000;
     if (time_of_first_rtt_ms_ != -1 && num_rtts_ > 0 &&
         elapsed_sec > metrics::kMinRunTimeInSeconds) {
@@ skipping 606 matching lines @@
   if (!rtp_rtcp_modules_[0]->Sending()) {
     return -1;
   }
 
   for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) {
     rtp_rtcp->SetSendingStatus(false);
   }
   return 0;
 }
 
-bool ViEChannel::Sending() {
-  return rtp_rtcp_modules_[0]->Sending();
-}
-
-void ViEChannel::StartReceive() {
-  if (!sender_)
-    StartDecodeThread();
-  vie_receiver_.StartReceive();
-}
-
-void ViEChannel::StopReceive() {
-  vie_receiver_.StopReceive();
-  if (!sender_)
-    StopDecodeThread();
-}
-
 int32_t ViEChannel::SetMTU(uint16_t mtu) {
   RTC_DCHECK(sender_);
   for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_)
     rtp_rtcp->SetMaxTransferUnit(mtu);
   return 0;
 }
 
 RtpRtcp* ViEChannel::rtp_rtcp() {
   return rtp_rtcp_modules_[0];
 }
@@ skipping 84 matching lines @@
   const uint64_t picture_id) {
   return rtp_rtcp_modules_[0]->SendRTCPSliceLossIndication(
       static_cast<uint8_t>(picture_id));
 }
 
 int32_t ViEChannel::ResendPackets(const uint16_t* sequence_numbers,
                                   uint16_t length) {
   return rtp_rtcp_modules_[0]->SendNACK(sequence_numbers, length);
 }
 
-bool ViEChannel::ChannelDecodeThreadFunction(void* obj) {
-  return static_cast<ViEChannel*>(obj)->ChannelDecodeProcess();
-}
-
-bool ViEChannel::ChannelDecodeProcess() {
-  RTC_DCHECK(!sender_);
-  vcm_->Decode(kMaxDecodeWaitTimeMs);
-  return true;
-}
-
 void ViEChannel::OnRttUpdate(int64_t avg_rtt_ms, int64_t max_rtt_ms) {
   if (!sender_)
     vcm_->SetReceiveChannelParameters(max_rtt_ms);
 
   rtc::CritScope lock(&crit_);
   if (time_of_first_rtt_ms_ == -1)
     time_of_first_rtt_ms_ = Clock::GetRealTimeClock()->TimeInMilliseconds();
   rtt_sum_ms_ += avg_rtt_ms;
   last_rtt_ms_ = avg_rtt_ms;
   ++num_rtts_;
@@ skipping 66 matching lines @@
     rtp_rtcp->SetRTCPStatus(RtcpMode::kCompound);
     modules.push_back(rtp_rtcp);
     // Receive statistics and remote bitrate estimator should only be set for
     // the primary (first) module.
     configuration.receive_statistics = null_receive_statistics;
     configuration.remote_bitrate_estimator = nullptr;
   }
   return modules;
 }
 
-void ViEChannel::StartDecodeThread() {
-  RTC_DCHECK(!sender_);
-  if (decode_thread_.IsRunning())
-    return;
-  // Start the decode thread
-  decode_thread_.Start();
-  decode_thread_.SetPriority(rtc::kHighestPriority);
-}
-
-void ViEChannel::StopDecodeThread() {
-  RTC_DCHECK(!sender_);
-  vcm_->TriggerDecoderShutdown();
-
-  decode_thread_.Stop();
-}
-
 int32_t ViEChannel::SetVoiceChannel(int32_t ve_channel_id,
                                     VoEVideoSync* ve_sync_interface) {
   RTC_DCHECK(!sender_);
   return vie_sync_.ConfigureSync(ve_channel_id, ve_sync_interface,
                                  rtp_rtcp_modules_[0],
                                  vie_receiver_.GetRtpReceiver());
 }
 
 int32_t ViEChannel::VoiceChannel() {
   RTC_DCHECK(!sender_);
@@ skipping 35 matching lines @@
   rtc::CritScope lock(&crit_);
   receive_stats_callback_ = receive_statistics_proxy;
 }
 
 void ViEChannel::SetIncomingVideoStream(
     IncomingVideoStream* incoming_video_stream) {
   rtc::CritScope lock(&crit_);
   incoming_video_stream_ = incoming_video_stream;
 }
 }  // namespace webrtc