Remove SendPacer from 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 61 matching lines @@
                              const uint32_t height);
 
  private:
   VideoProcessing* vp_;
 };
 
 ViEEncoder::ViEEncoder(uint32_t number_of_cores,
                        const std::vector<uint32_t>& ssrcs,
                        ProcessThread* module_process_thread,
                        SendStatisticsProxy* stats_proxy,
-                       rtc::VideoSinkInterface<VideoFrame>* pre_encode_callback,
                        OveruseFrameDetector* overuse_detector,
-                       PacedSender* pacer,
                        PayloadRouter* payload_router,
                        EncodedImageCallback* post_encode_callback)
     : number_of_cores_(number_of_cores),
       ssrcs_(ssrcs),
       vp_(VideoProcessing::Create()),
       qm_callback_(new QMVideoSettingsCallback(vp_.get())),
       video_sender_(Clock::GetRealTimeClock(), this, this, qm_callback_.get()),
       stats_proxy_(stats_proxy),
-      pre_encode_callback_(pre_encode_callback),
       overuse_detector_(overuse_detector),
-      pacer_(pacer),
       send_payload_router_(payload_router),
       post_encode_callback_(post_encode_callback),
       time_of_last_frame_activity_ms_(0),
       encoder_config_(),
       min_transmit_bitrate_bps_(0),
       last_observed_bitrate_bps_(0),
       network_is_transmitting_(true),
       encoder_paused_(false),
       encoder_paused_and_dropped_frame_(false),
       time_last_intra_request_ms_(ssrcs.size(), -1),
@@ skipping 169 matching lines @@
 
   return pad_up_to_bitrate_bps;
 }
 
 bool ViEEncoder::EncoderPaused() const {
   // Pause video if paused by caller or as long as the network is down or the
   // pacer queue has grown too large in buffered mode.
   if (encoder_paused_) {
     return true;
   }
-  if (pacer_->ExpectedQueueTimeMs() > PacedSender::kMaxQueueLengthMs) {
-    // Too much data in pacer queue, drop frame.
+  if (video_suspended_ || last_observed_bitrate_bps_ == 0) {
+    // Too low bitrate to send data.

[stefan-webrtc, 2016/04/29 10:48:39]

I think we can remove the comment.

[perkj_webrtc, 2016/05/02 11:29:10]

Done.

     return true;
   }
   return !network_is_transmitting_;
 }
 
 void ViEEncoder::TraceFrameDropStart() {
   // Start trace event only on the first frame after encoder is paused.
   if (!encoder_paused_and_dropped_frame_) {
     TRACE_EVENT_ASYNC_BEGIN0("webrtc", "EncoderPaused", this);
   }
@@ skipping 33 matching lines @@
   // TODO(wuchengli): support texture frames.
   if (!video_frame.video_frame_buffer()->native_handle()) {
     // Pass frame via preprocessor.
     frame_to_send = vp_->PreprocessFrame(video_frame);
     if (!frame_to_send) {
       // Drop this frame, or there was an error processing it.
       return;
     }
   }
 
-  if (pre_encode_callback_) {
-    pre_encode_callback_->OnFrame(*frame_to_send);
-  }
-
   if (codec_type == webrtc::kVideoCodecVP8) {
     webrtc::CodecSpecificInfo codec_specific_info;
     codec_specific_info.codecType = webrtc::kVideoCodecVP8;
     {
       rtc::CritScope lock(&data_cs_);
       codec_specific_info.codecSpecific.VP8.hasReceivedRPSI =
           has_received_rpsi_;
       codec_specific_info.codecSpecific.VP8.hasReceivedSLI =
           has_received_sli_;
       codec_specific_info.codecSpecific.VP8.pictureIdRPSI =
@@ skipping 125 matching lines @@
     }
     video_sender_.IntraFrameRequest(static_cast<int>(i));
     return;
   }
   RTC_NOTREACHED() << "Should not receive keyframe requests on unknown SSRCs.";
 }
 
 void ViEEncoder::OnBitrateUpdated(uint32_t bitrate_bps,
                                   uint8_t fraction_lost,
                                   int64_t round_trip_time_ms) {
-  LOG(LS_VERBOSE) << "OnBitrateUpdated, bitrate" << bitrate_bps
+  LOG(LS_VERBOSE) << "OnBitrateUpdated, bitrate " << bitrate_bps
                   << " packet loss " << static_cast<int>(fraction_lost)
                   << " rtt " << round_trip_time_ms;
   RTC_DCHECK(send_payload_router_);
   video_sender_.SetChannelParameters(bitrate_bps, fraction_lost,
                                      round_trip_time_ms);
   bool video_is_suspended = video_sender_.VideoSuspended();
   bool video_suspension_changed;
   VideoCodec send_codec;
   {
     rtc::CritScope lock(&data_cs_);
@@ skipping 26 matching lines @@
 }
 
 int32_t QMVideoSettingsCallback::SetVideoQMSettings(
     const uint32_t frame_rate,
     const uint32_t width,
     const uint32_t height) {
   return vp_->SetTargetResolution(width, height, frame_rate);
 }
 
 }  // namespace webrtc