Remove PayloadRouter dependency 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 20 matching lines @@
 #include "webrtc/video/overuse_frame_detector.h"
 #include "webrtc/video/payload_router.h"
 #include "webrtc/video/send_statistics_proxy.h"
 #include "webrtc/video_frame.h"
 
 namespace webrtc {
 
 static const float kStopPaddingThresholdMs = 2000;
 static const int kMinKeyFrameRequestIntervalMs = 300;
 
-std::vector<uint32_t> AllocateStreamBitrates(
-    uint32_t total_bitrate,
-    const SimulcastStream* stream_configs,
-    size_t number_of_streams) {
-  if (number_of_streams == 0) {
-    std::vector<uint32_t> stream_bitrates(1, 0);
-    stream_bitrates[0] = total_bitrate;
-    return stream_bitrates;
-  }
-  std::vector<uint32_t> stream_bitrates(number_of_streams, 0);
-  uint32_t bitrate_remainder = total_bitrate;
-  for (size_t i = 0; i < stream_bitrates.size() && bitrate_remainder > 0; ++i) {
-    if (stream_configs[i].maxBitrate * 1000 > bitrate_remainder) {
-      stream_bitrates[i] = bitrate_remainder;
-    } else {
-      stream_bitrates[i] = stream_configs[i].maxBitrate * 1000;
-    }
-    bitrate_remainder -= stream_bitrates[i];
-  }
-  return stream_bitrates;
-}
-
 class QMVideoSettingsCallback : public VCMQMSettingsCallback {
  public:
   explicit QMVideoSettingsCallback(VideoProcessing* vpm);
 
   ~QMVideoSettingsCallback();
 
   // Update VPM with QM (quality modes: frame size & frame rate) settings.
   int32_t SetVideoQMSettings(const uint32_t frame_rate,
                              const uint32_t width,
                              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)
+                       PacedSender* pacer)
     : 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_(true),
       encoder_paused_and_dropped_frame_(false),
       time_last_intra_request_ms_(ssrcs.size(), -1),
       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) {
   module_process_thread_->RegisterModule(&video_sender_);
 }
@@ skipping 28 matching lines @@
     rtc::CritScope lock(&data_cs_);
     network_is_transmitting_ = is_transmitting;
   }
 }
 
 void ViEEncoder::Pause() {
   rtc::CritScope lock(&data_cs_);
   encoder_paused_ = true;
 }
 
-void ViEEncoder::Restart() {
+void ViEEncoder::Start() {
   rtc::CritScope lock(&data_cs_);
   encoder_paused_ = false;
 }
 
 int32_t ViEEncoder::RegisterExternalEncoder(webrtc::VideoEncoder* encoder,
                                             uint8_t pl_type,
                                             bool internal_source) {
   video_sender_.RegisterExternalEncoder(encoder, pl_type, internal_source);
   return 0;
 }
 
 int32_t ViEEncoder::DeRegisterExternalEncoder(uint8_t pl_type) {
   video_sender_.RegisterExternalEncoder(nullptr, pl_type, false);
   return 0;
 }
 void ViEEncoder::SetEncoder(const webrtc::VideoCodec& video_codec,
-                            int min_transmit_bitrate_bps) {
-  RTC_DCHECK(send_payload_router_);
+                            int min_transmit_bitrate_bps,
+                            size_t max_data_payload_length,
+                            EncodedImageCallback* sink) {
   // Setting target width and height for VPM.
   RTC_CHECK_EQ(VPM_OK,
                vp_->SetTargetResolution(video_codec.width, video_codec.height,
                                         video_codec.maxFramerate));
 
   // Cache codec before calling AddBitrateObserver (which calls OnBitrateUpdated
   // that makes use of the number of simulcast streams configured).
   {
     rtc::CritScope lock(&data_cs_);
     encoder_config_ = video_codec;
-    encoder_paused_ = true;
     min_transmit_bitrate_bps_ = min_transmit_bitrate_bps;
   }
+  {
+    rtc::CritScope lock(&sink_cs_);
+    sink_ = sink;
+  }
 
-  size_t max_data_payload_length = send_payload_router_->MaxPayloadLength();
   bool success = video_sender_.RegisterSendCodec(
                      &video_codec, number_of_cores_,
                      static_cast<uint32_t>(max_data_payload_length)) == VCM_OK;
   if (!success) {
     LOG(LS_ERROR) << "Failed to configure encoder.";
     RTC_DCHECK(success);
   }
 
-  send_payload_router_->SetSendingRtpModules(
-      video_codec.numberOfSimulcastStreams);
-
-  // Restart the media flow
-  Restart();
   if (stats_proxy_) {
     // Clear stats for disabled layers.
     for (size_t i = video_codec.numberOfSimulcastStreams; i < ssrcs_.size();
          ++i) {
       stats_proxy_->OnInactiveSsrc(ssrcs_[i]);
     }
     VideoEncoderConfig::ContentType content_type =
         VideoEncoderConfig::ContentType::kRealtimeVideo;
     switch (video_codec.mode) {
       case kRealtimeVideo:
@@ skipping 91 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::EncodeVideoFrame(const VideoFrame& video_frame) {
-  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()) {
       TraceFrameDropStart();
       return;
     }
     TraceFrameDropEnd();
     codec_type = encoder_config_.codecType;
@@ skipping 62 matching lines @@
 }
 
 void ViEEncoder::OnEncoderImplementationName(const char* implementation_name) {
   if (stats_proxy_)
     stats_proxy_->OnEncoderImplementationName(implementation_name);
 }
 
 int32_t ViEEncoder::Encoded(const EncodedImage& encoded_image,
                             const CodecSpecificInfo* codec_specific_info,
                             const RTPFragmentationHeader* fragmentation) {
-  RTC_DCHECK(send_payload_router_);
-
   {
     rtc::CritScope lock(&data_cs_);
     time_of_last_frame_activity_ms_ = TickTime::MillisecondTimestamp();
   }
-
-  if (post_encode_callback_) {
-    post_encode_callback_->Encoded(encoded_image, codec_specific_info,
-                                   fragmentation);
-  }
-
   if (stats_proxy_) {
     stats_proxy_->OnSendEncodedImage(encoded_image, codec_specific_info);
   }
-  int success = send_payload_router_->Encoded(
-      encoded_image, codec_specific_info, fragmentation);
+
+  int success = 0;
+  {
+    rtc::CritScope lock(&sink_cs_);
+    success = sink_->Encoded(encoded_image, codec_specific_info, fragmentation);
+  }
+
   overuse_detector_->FrameSent(encoded_image._timeStamp);
-
   if (kEnableFrameRecording) {
     int layer = codec_specific_info->codecType == kVideoCodecVP8
                     ? codec_specific_info->codecSpecific.VP8.simulcastIdx
                     : 0;
     IvfFileWriter* file_writer;
     {
       rtc::CritScope lock(&data_cs_);
       if (file_writers_[layer] == nullptr) {
         std::ostringstream oss;
         oss << "send_bitstream_ssrc";
@@ skipping 56 matching lines @@
   }
   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
                   << " 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_);
     last_observed_bitrate_bps_ = bitrate_bps;
     video_suspension_changed = video_suspended_ != video_is_suspended;
     video_suspended_ = video_is_suspended;
-    send_codec = encoder_config_;
   }
 
-  SimulcastStream* stream_configs = send_codec.simulcastStream;
-  // Allocate the bandwidth between the streams.
-  std::vector<uint32_t> stream_bitrates = AllocateStreamBitrates(
-      bitrate_bps, stream_configs, send_codec.numberOfSimulcastStreams);
-  send_payload_router_->SetTargetSendBitrates(stream_bitrates);
-
   if (!video_suspension_changed)
     return;
   // Video suspend-state changed, inform codec observer.
   LOG(LS_INFO) << "Video suspend state changed " << video_is_suspended
                << " for ssrc " << ssrcs_[0];
   if (stats_proxy_)
     stats_proxy_->OnSuspendChange(video_is_suspended);
 }
 
 QMVideoSettingsCallback::QMVideoSettingsCallback(VideoProcessing* vpm)
     : vp_(vpm) {
 }
 
 QMVideoSettingsCallback::~QMVideoSettingsCallback() {
 }
 
 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