Wire up send-side bandwidth estimation.

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/base/event.h"
+#include "webrtc/modules/pacing/include/packet_router.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/remote_bitrate_estimator/remote_estimator_proxy.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/system_wrappers/interface/thread_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,
@@ skipping 31 matching lines @@
   // 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);
+  packet_router_.reset(new PacketRouter());
+  packet_router_->AddRtpModule(rtp_rtcp_.get());
   rtp_parser_->RegisterRtpHeaderExtension(kRtpExtensionAbsoluteSendTime,
                                           kAbsSendTimeExtensionId);
   rtp_parser_->RegisterRtpHeaderExtension(kRtpExtensionTransmissionTimeOffset,
                                           kTransmissionTimeOffsetExtensionId);
+  rtp_parser_->RegisterRtpHeaderExtension(kRtpExtensionTransportSequenceNumber,
+                                          kTransportSequenceNumberExtensionId);
   payload_registry_->SetRtxPayloadType(RampUpTest::kSendRtxPayloadType,
                                        RampUpTest::kFakeSendPayloadType);
 }
 
+StreamObserver::~StreamObserver() {
+  packet_router_->RemoveRtpModule(rtp_rtcp_.get());
+}
+
 void StreamObserver::set_expected_bitrate_bps(
     unsigned int expected_bitrate_bps) {
   rtc::CritScope lock(&crit_);
   expected_bitrate_bps_ = expected_bitrate_bps;
 }
 
 void StreamObserver::set_start_bitrate_bps(unsigned int start_bitrate_bps) {
   rtc::CritScope lock(&crit_);
   start_bitrate_bps_ = start_bitrate_bps;
 }
@@ skipping 10 matching lines @@
     // first estimate really is as high as the start bitrate.
     EXPECT_GT(bitrate, 0.9 * start_bitrate_bps_);
     start_bitrate_bps_ = 0;
   }
   if (bitrate >= expected_bitrate_bps_) {
     ramp_up_finished_ms_ = clock_->TimeInMilliseconds();
     // Just trigger if there was any rtx padding packet.
     if (rtx_media_ssrcs_.empty() || rtx_media_sent_ > 0) {
       TriggerTestDone();
     }
   }

[stefan-webrtc, 2015/09/18 10:57:23]

Basically we can move all of this into a thread which monitors GetStats(), or we
call GetStats() from SendRtp below.

   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);
@@ skipping 34 matching lines @@
 }
 
 EventTypeWrapper StreamObserver::Wait() {
   return test_done_->Wait(test::CallTest::kLongTimeoutMs);
 }
 
 void StreamObserver::SetRemoteBitrateEstimator(RemoteBitrateEstimator* rbe) {
   remote_bitrate_estimator_.reset(rbe);
 }
 
+PacketRouter* StreamObserver::GetPacketRouter() {
+  return packet_router_.get();
+}
+
 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 188 matching lines @@
       }
       break;
     }
   }
 }
 
 EventTypeWrapper LowRateStreamObserver::Wait() {
   return test_done_->Wait(test::CallTest::kLongTimeoutMs);
 }
 
+class SendBitrateAdapter {
+ public:
+  static const int64_t kPollIntervalMs = 250;
+
+  SendBitrateAdapter(const Call& call,
+                     const std::vector<uint32_t>& ssrcs,
+                     RemoteBitrateObserver* bitrate_observer)
+      : event_(false, false),
+        call_(call),
+        ssrcs_(ssrcs),
+        bitrate_observer_(bitrate_observer) {
+    RTC_DCHECK(bitrate_observer != nullptr);
+    poller_thread_ = ThreadWrapper::CreateThread(&SendBitrateAdapterThread,
+                                                 this, "SendBitratePoller");
+    RTC_DCHECK(poller_thread_->Start());
+  }
+
+  virtual ~SendBitrateAdapter() {
+    event_.Set();
+    poller_thread_->Stop();
+  }
+
+ private:
+  static bool SendBitrateAdapterThread(void* obj) {
+    return static_cast<SendBitrateAdapter*>(obj)->PollStats();
+  }
+
+  bool PollStats() {
+    Call::Stats stats = call_.GetStats();
+
+    bitrate_observer_->OnReceiveBitrateChanged(ssrcs_,
+                                               stats.send_bandwidth_bps);
+    return !event_.Wait(kPollIntervalMs);
+  }
+
+  rtc::Event event_;
+  rtc::scoped_ptr<ThreadWrapper> poller_thread_;
+  const Call& call_;
+  const std::vector<uint32_t> ssrcs_;
+  RemoteBitrateObserver* const bitrate_observer_;
+};
+
 void RampUpTest::RunRampUpTest(size_t num_streams,
                                unsigned int start_bitrate_bps,
                                const std::string& extension_type,
                                bool rtx,
                                bool red) {
   std::vector<uint32_t> ssrcs(GenerateSsrcs(num_streams, 100));
   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];
   }
 
   test::DirectTransport receiver_transport;
   StreamObserver stream_observer(rtx_ssrc_map, &receiver_transport,
                                  Clock::GetRealTimeClock());
 
   CreateSendConfig(num_streams, &stream_observer);
   send_config_.rtp.extensions.clear();
 
+  rtc::scoped_ptr<SendBitrateAdapter> send_bitrate_adapter_;
+
   if (extension_type == RtpExtension::kAbsSendTime) {
     stream_observer.SetRemoteBitrateEstimator(
         new RemoteBitrateEstimatorAbsSendTime(
             &stream_observer, Clock::GetRealTimeClock(),
             kRemoteBitrateEstimatorMinBitrateBps));
     send_config_.rtp.extensions.push_back(RtpExtension(
         extension_type.c_str(), kAbsSendTimeExtensionId));
+  } else if (extension_type == RtpExtension::kTransportSequenceNumber) {
+    stream_observer.SetRemoteBitrateEstimator(new RemoteEstimatorProxy(
+        Clock::GetRealTimeClock(), stream_observer.GetPacketRouter()));
+    send_config_.rtp.extensions.push_back(RtpExtension(
+        extension_type.c_str(), kTransportSequenceNumberExtensionId));
   } else {
     stream_observer.SetRemoteBitrateEstimator(
         new RemoteBitrateEstimatorSingleStream(
             &stream_observer, Clock::GetRealTimeClock(),
             kRemoteBitrateEstimatorMinBitrateBps));
     send_config_.rtp.extensions.push_back(RtpExtension(
         extension_type.c_str(), kTransmissionTimeOffsetExtensionId));
   }
 
   Call::Config call_config;
@@ skipping 31 matching lines @@
     int expected_bitrate_bps = encoder_config_.streams.back().min_bitrate_bps;
     for (size_t i = 0; i < encoder_config_.streams.size() - 1; ++i) {
       expected_bitrate_bps += encoder_config_.streams[i].target_bitrate_bps;
     }
     stream_observer.set_expected_bitrate_bps(expected_bitrate_bps);
   }
 
   CreateStreams();
   CreateFrameGeneratorCapturer();
 
+  if (extension_type == RtpExtension::kTransportSequenceNumber) {
+    send_bitrate_adapter_.reset(
+        new SendBitrateAdapter(*sender_call_.get(), ssrcs, &stream_observer));
+  }
   Start();
 
   EXPECT_EQ(kEventSignaled, stream_observer.Wait());
 
+  // Destroy the SendBitrateAdapter (if any) to stop the poller thread in it,
+  // otherwise we might get a data race with the destruction of the call.
+  send_bitrate_adapter_.reset();
+
   Stop();
   DestroyStreams();
 }
 
 void RampUpTest::RunRampUpDownUpTest(size_t number_of_streams,
                                      bool rtx,
                                      bool red) {
   test::DirectTransport receiver_transport;
   LowRateStreamObserver stream_observer(
       &receiver_transport, Clock::GetRealTimeClock(), number_of_streams, rtx);
@@ skipping 90 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);
 }
+
+TEST_F(RampUpTest, TransportSequenceNumberSingleStream) {
+  RunRampUpTest(1, 0, RtpExtension::kTransportSequenceNumber, false, false);
+}
+
+TEST_F(RampUpTest, TransportSequenceNumberSimulcast) {
+  RunRampUpTest(3, 0, RtpExtension::kTransportSequenceNumber, false, false);
+}
+
+TEST_F(RampUpTest, TransportSequenceNumberSimulcastWithRtx) {
+  RunRampUpTest(3, 0, RtpExtension::kTransportSequenceNumber, true, false);
+}
+
+TEST_F(RampUpTest, TransportSequenceNumberSimulcastByRedWithRtx) {
+  RunRampUpTest(3, 0, RtpExtension::kTransportSequenceNumber, true, true);
+}
+
+TEST_F(RampUpTest, TransportSequenceNumberSingleStreamWithHighStartBitrate) {
+  RunRampUpTest(1, 0.9 * kSingleStreamTargetBps,
+                RtpExtension::kTransportSequenceNumber, false, false);
+}
 }  // namespace webrtc