Remove MimdRateControl and factories for RemoteBitrateEstimor.

webrtc/video/rampup_tests.cc

 /*
  *  Copyright (c) 2013 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.
  */
 
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/common.h"
+#include "webrtc/modules/remote_bitrate_estimator/remote_bitrate_estimator_abs_send_time.h"
+#include "webrtc/modules/remote_bitrate_estimator/remote_bitrate_estimator_single_stream.h"
 #include "webrtc/modules/rtp_rtcp/interface/receive_statistics.h"
 #include "webrtc/modules/rtp_rtcp/interface/rtp_header_parser.h"
 #include "webrtc/modules/rtp_rtcp/interface/rtp_payload_registry.h"
 #include "webrtc/modules/rtp_rtcp/interface/rtp_rtcp.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_utility.h"
 #include "webrtc/system_wrappers/interface/critical_section_wrapper.h"
 #include "webrtc/test/testsupport/perf_test.h"
 #include "webrtc/video/rampup_tests.h"
 
 namespace webrtc {
 namespace {
 
 static const int kMaxPacketSize = 1500;
+const uint32_t kRemoteBitrateEstimatorMinBitrateBps = 30000;
 
 std::vector<uint32_t> GenerateSsrcs(size_t num_streams,
                                     uint32_t ssrc_offset) {
   std::vector<uint32_t> ssrcs;
   for (size_t i = 0; i != num_streams; ++i)
     ssrcs.push_back(static_cast<uint32_t>(ssrc_offset + i));
   return ssrcs;
 }
 }  // namespace
 
 StreamObserver::StreamObserver(const SsrcMap& rtx_media_ssrcs,
                                newapi::Transport* feedback_transport,
-                               Clock* clock,
-                               RemoteBitrateEstimatorFactory* rbe_factory,
-                               RateControlType control_type)
+                               Clock* clock)
     : clock_(clock),
       test_done_(EventWrapper::Create()),
       rtp_parser_(RtpHeaderParser::Create()),
       feedback_transport_(feedback_transport),
       receive_stats_(ReceiveStatistics::Create(clock)),
       payload_registry_(
           new RTPPayloadRegistry(RTPPayloadStrategy::CreateStrategy(false))),
+      remote_bitrate_estimator_(nullptr),
       expected_bitrate_bps_(0),
       start_bitrate_bps_(0),
       rtx_media_ssrcs_(rtx_media_ssrcs),
       total_sent_(0),
       padding_sent_(0),
       rtx_media_sent_(0),
       total_packets_sent_(0),
       padding_packets_sent_(0),
       rtx_media_packets_sent_(0),
       test_start_ms_(clock_->TimeInMilliseconds()),
       ramp_up_finished_ms_(0) {
   // Ideally we would only have to instantiate an RtcpSender, an
   // RtpHeaderParser and a RemoteBitrateEstimator here, but due to the current
   // state of the RTP module we need a full module and receive statistics to
   // be able to produce an RTCP with REMB.
   RtpRtcp::Configuration config;
   config.receive_statistics = receive_stats_.get();
   feedback_transport_.Enable();
   config.outgoing_transport = &feedback_transport_;
   rtp_rtcp_.reset(RtpRtcp::CreateRtpRtcp(config));
   rtp_rtcp_->SetREMBStatus(true);
   rtp_rtcp_->SetRTCPStatus(kRtcpNonCompound);
   rtp_parser_->RegisterRtpHeaderExtension(kRtpExtensionAbsoluteSendTime,
                                           kAbsSendTimeExtensionId);
   rtp_parser_->RegisterRtpHeaderExtension(kRtpExtensionTransmissionTimeOffset,
                                           kTransmissionTimeOffsetExtensionId);
-  const uint32_t kRemoteBitrateEstimatorMinBitrateBps = 30000;
-  remote_bitrate_estimator_.reset(
-      rbe_factory->Create(this, clock, control_type,
-                          kRemoteBitrateEstimatorMinBitrateBps));
   payload_registry_->SetRtxPayloadType(RampUpTest::kSendRtxPayloadType,
                                        RampUpTest::kFakeSendPayloadType);
 }
 
 void StreamObserver::set_expected_bitrate_bps(
     unsigned int expected_bitrate_bps) {
   rtc::CritScope lock(&crit_);
   expected_bitrate_bps_ = expected_bitrate_bps;
 }
 
@@ skipping 25 matching lines @@
   rtp_rtcp_->SetREMBData(bitrate, ssrcs);
   rtp_rtcp_->Process();
 }
 
 bool StreamObserver::SendRtp(const uint8_t* packet, size_t length) {
   rtc::CritScope lock(&crit_);
   RTPHeader header;
   EXPECT_TRUE(rtp_parser_->Parse(packet, length, &header));
   receive_stats_->IncomingPacket(header, length, false);
   payload_registry_->SetIncomingPayloadType(header);
+  DCHECK(remote_bitrate_estimator_ != nullptr);
   remote_bitrate_estimator_->IncomingPacket(clock_->TimeInMilliseconds(),
                                             length - 12, header, true);
   if (remote_bitrate_estimator_->TimeUntilNextProcess() <= 0) {
     remote_bitrate_estimator_->Process();
   }
   total_sent_ += length;
   padding_sent_ += header.paddingLength;
   ++total_packets_sent_;
   if (header.paddingLength > 0)
     ++padding_packets_sent_;
@@ skipping 17 matching lines @@
 }
 
 bool StreamObserver::SendRtcp(const uint8_t* packet, size_t length) {
   return true;
 }
 
 EventTypeWrapper StreamObserver::Wait() {
   return test_done_->Wait(test::CallTest::kLongTimeoutMs);
 }
 
+void StreamObserver::SetRemoteBitrateEstimator(RemoteBitrateEstimator* rbe) {
+  remote_bitrate_estimator_.reset(rbe);
+}
+
 void StreamObserver::ReportResult(const std::string& measurement,
                   size_t value,
                   const std::string& units) {
   webrtc::test::PrintResult(
       measurement, "",
       ::testing::UnitTest::GetInstance()->current_test_info()->name(),
       value, units, false);
 }
 
 void StreamObserver::TriggerTestDone() EXCLUSIVE_LOCKS_REQUIRED(crit_) {
@@ skipping 35 matching lines @@
       suspended_in_stats_(false) {
   RtpRtcp::Configuration config;
   config.receive_statistics = receive_stats_.get();
   feedback_transport_.Enable();
   config.outgoing_transport = &feedback_transport_;
   rtp_rtcp_.reset(RtpRtcp::CreateRtpRtcp(config));
   rtp_rtcp_->SetREMBStatus(true);
   rtp_rtcp_->SetRTCPStatus(kRtcpNonCompound);
   rtp_parser_->RegisterRtpHeaderExtension(kRtpExtensionAbsoluteSendTime,
                                           kAbsSendTimeExtensionId);
-  AbsoluteSendTimeRemoteBitrateEstimatorFactory rbe_factory;
   const uint32_t kRemoteBitrateEstimatorMinBitrateBps = 10000;
-  remote_bitrate_estimator_.reset(
-      rbe_factory.Create(this, clock, kAimdControl,
-                         kRemoteBitrateEstimatorMinBitrateBps));
+  remote_bitrate_estimator_.reset(new RemoteBitrateEstimatorAbsSendTime(
+      this, clock, kRemoteBitrateEstimatorMinBitrateBps));
   forward_transport_config_.link_capacity_kbps =
       kHighBandwidthLimitBps / 1000;
   forward_transport_config_.queue_length_packets = 100;  // Something large.
   test::DirectTransport::SetConfig(forward_transport_config_);
   test::DirectTransport::SetReceiver(this);
 }
 
 void LowRateStreamObserver::SetSendStream(VideoSendStream* send_stream) {
   rtc::CritScope lock(&crit_);
   send_stream_ = send_stream;
@@ skipping 143 matching lines @@
   std::vector<uint32_t> rtx_ssrcs(GenerateSsrcs(num_streams, 200));
   StreamObserver::SsrcMap rtx_ssrc_map;
   if (rtx) {
     for (size_t i = 0; i < ssrcs.size(); ++i)
       rtx_ssrc_map[rtx_ssrcs[i]] = ssrcs[i];
   }
 
   CreateSendConfig(num_streams);
   send_config_.rtp.extensions.clear();
 
-  rtc::scoped_ptr<RemoteBitrateEstimatorFactory> rbe_factory;
-  RateControlType control_type;
+  test::DirectTransport receiver_transport;
+  StreamObserver stream_observer(rtx_ssrc_map, &receiver_transport,
+                                 Clock::GetRealTimeClock());
+
   if (extension_type == RtpExtension::kAbsSendTime) {
-    control_type = kAimdControl;
-    rbe_factory.reset(new AbsoluteSendTimeRemoteBitrateEstimatorFactory);
+    stream_observer.SetRemoteBitrateEstimator(
+        new RemoteBitrateEstimatorAbsSendTime(
+            &stream_observer, Clock::GetRealTimeClock(),
+            kRemoteBitrateEstimatorMinBitrateBps));
     send_config_.rtp.extensions.push_back(RtpExtension(
         extension_type.c_str(), kAbsSendTimeExtensionId));
   } else {
-    control_type = kMimdControl;
-    rbe_factory.reset(new RemoteBitrateEstimatorFactory);
+    stream_observer.SetRemoteBitrateEstimator(
+        new RemoteBitrateEstimatorSingleStream(
+            &stream_observer, Clock::GetRealTimeClock(),
+            kRemoteBitrateEstimatorMinBitrateBps));
     send_config_.rtp.extensions.push_back(RtpExtension(
         extension_type.c_str(), kTransmissionTimeOffsetExtensionId));
   }
 
-  test::DirectTransport receiver_transport;
-  StreamObserver stream_observer(rtx_ssrc_map,
-                                 &receiver_transport,
-                                 Clock::GetRealTimeClock(),
-                                 rbe_factory.get(),
-                                 control_type);
-
   Call::Config call_config(&stream_observer);
   if (start_bitrate_bps != 0) {
     call_config.bitrate_config.start_bitrate_bps = start_bitrate_bps;
     stream_observer.set_start_bitrate_bps(start_bitrate_bps);
   }
 
   CreateSenderCall(call_config);
 
   receiver_transport.SetReceiver(sender_call_->Receiver());
 
@@ skipping 136 matching lines @@
 
 TEST_F(RampUpTest, AbsSendTimeSimulcastByRedWithRtx) {
   RunRampUpTest(3, 0, RtpExtension::kAbsSendTime, true, true);
 }
 
 TEST_F(RampUpTest, AbsSendTimeSingleStreamWithHighStartBitrate) {
   RunRampUpTest(1, 0.9 * kSingleStreamTargetBps, RtpExtension::kAbsSendTime,
                 false, false);
 }
 }  // namespace webrtc