Wire up send-side bandwidth estimation.

webrtc/video/rampup_tests.cc

Index: webrtc/video/rampup_tests.cc
diff --git a/webrtc/video/rampup_tests.cc b/webrtc/video/rampup_tests.cc
index fb533cb89039b84b04cd3be387b94616e1d2a8d5..03c5306377687699f3fec187f1b826e7cf210ab5 100644
--- a/webrtc/video/rampup_tests.cc
+++ b/webrtc/video/rampup_tests.cc
@@ -11,14 +11,18 @@
 #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"
 
@@ -70,14 +74,22 @@ StreamObserver::StreamObserver(const SsrcMap& rtx_media_ssrcs,
   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_);
@@ -163,6 +175,10 @@ 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) {
@@ -371,6 +387,48 @@ 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) {
+    DCHECK(bitrate_observer != nullptr);
+    poller_thread_ = ThreadWrapper::CreateThread(&SendBitrateAdapterThread,
+                                                 this, "SendBitratePoller");
+    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,
@@ -391,6 +449,8 @@ void RampUpTest::RunRampUpTest(size_t num_streams,
   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(
@@ -398,6 +458,11 @@ void RampUpTest::RunRampUpTest(size_t num_streams,
             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 {

[stefan-webrtc, 2015/09/17 10:33:19]

I'm starting to think that instead of adding a lot of extra special code for the
send-side BWE, maybe we can just use a true receive Call in this test, and have
both versions of the test monitor the send-side estimate? I don't think it would
be that much work actually. What do you think?

[sprang_webrtc, 2015/09/17 15:08:28]

I initially tried that but there were some obstacles. Can't quite remember what
they were now.. Injecting a mock RemoteBitrateEstimator to fetch remb values is
one. Could we do this in a follow-up cl instead?

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

We can do it in a follow-up.

I don't see why we need to know the remb values though? Can't we make the test
rely on send-side bwe values as reported from GetStats?

[sprang_webrtc, 2015/09/21 10:44:10]

I was just under the presumption that we wanted to test the remb values, rather
than changing the semantics and instead relying on the combined bandwidth
estimate? If that isn't the case then sure, let's do a follow up where we have a
real receive call and use the get stats. All will then have to use polling, just
like send-side...

[stefan-webrtc, 2015/09/21 11:12:07]

Right, that's my thinking. I never intended to check the remb values, it was
probably a bad choice writing the tests like this. I think the problem was
partly that the stats APIs weren't ready at that time.

[sprang_webrtc, 2015/09/21 13:42:53]

Acknowledged.

     stream_observer.SetRemoteBitrateEstimator(
         new RemoteBitrateEstimatorSingleStream(
@@ -449,9 +514,14 @@ void RampUpTest::RunRampUpTest(size_t num_streams,
   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());
+  send_bitrate_adapter_.reset();

[stefan-webrtc, 2015/09/17 10:33:19]

This is needed to stop the thread? Maybe comment.

[sprang_webrtc, 2015/09/17 15:08:28]

Done.

 
   Stop();
   DestroyStreams();
@@ -563,4 +633,25 @@ 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