Add ramp-up tests for transport sequence number with and w/o audio.

webrtc/call/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 "webrtc/call/rampup_tests.h"
 
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/platform_thread.h"
 #include "webrtc/test/testsupport/perf_test.h"
 
 namespace webrtc {
 namespace {
 
+static const uint32_t kStartBitrateBps = 60000;
 static const int64_t kPollIntervalMs = 20;
 
 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
 
@@ skipping 17 matching lines @@
       test_start_ms_(-1),
       ramp_up_finished_ms_(-1),
       extension_type_(extension_type),
       video_ssrcs_(GenerateSsrcs(num_video_streams_, 100)),
       video_rtx_ssrcs_(GenerateSsrcs(num_video_streams_, 200)),
       audio_ssrcs_(GenerateSsrcs(num_audio_streams_, 300)),
       poller_thread_(&BitrateStatsPollingThread,
                      this,
                      "BitrateStatsPollingThread"),
       sender_call_(nullptr) {
+  EXPECT_LE(num_audio_streams_, 1u);
   if (rtx_) {
     for (size_t i = 0; i < video_ssrcs_.size(); ++i)
       rtx_ssrc_map_[video_rtx_ssrcs_[i]] = video_ssrcs_[i];
   }
 }
 
 RampUpTester::~RampUpTester() {
   event_.Set();
 }
 
@@ skipping 16 matching lines @@
   send_transport_ = new test::PacketTransport(sender_call, this,
                                               test::PacketTransport::kSender,
                                               forward_transport_config_);
   return send_transport_;
 }
 
 size_t RampUpTester::GetNumVideoStreams() const {
   return num_video_streams_;
 }
 
+size_t RampUpTester::GetNumAudioStreams() const {
+  return num_audio_streams_;
+}
+
 void RampUpTester::ModifyVideoConfigs(
     VideoSendStream::Config* send_config,
     std::vector<VideoReceiveStream::Config>* receive_configs,
     VideoEncoderConfig* encoder_config) {
   send_config->suspend_below_min_bitrate = true;
 
   if (num_video_streams_ == 1) {
     encoder_config->streams[0].target_bitrate_bps =
         encoder_config->streams[0].max_bitrate_bps = 2000000;
     // For single stream rampup until 1mbps
@@ skipping 60 matching lines @@
     if (rtx_) {
       recv_config.rtp.rtx[send_config->encoder_settings.payload_type].ssrc =
           video_rtx_ssrcs_[i];
       recv_config.rtp.rtx[send_config->encoder_settings.payload_type]
           .payload_type = send_config->rtp.rtx.payload_type;
     }
     ++i;
   }
 }
 
+void RampUpTester::ModifyAudioConfigs(
+    AudioSendStream::Config* send_config,
+    std::vector<AudioReceiveStream::Config>* receive_configs) {
+  if (num_audio_streams_ == 0)
+    return;
+
+  EXPECT_NE(RtpExtension::kTOffset, extension_type_)
+      << "Audio BWE not supported with toffset.";
+
+  send_config->rtp.ssrc = audio_ssrcs_[0];
+  send_config->rtp.extensions.clear();
+
+  bool transport_cc;
+  if (extension_type_ == RtpExtension::kAbsSendTime) {
+    transport_cc = false;
+    send_config->rtp.extensions.push_back(
+        RtpExtension(extension_type_.c_str(), kAbsSendTimeExtensionId));
+  } else if (extension_type_ == RtpExtension::kTransportSequenceNumber) {
+    transport_cc = true;
+    send_config->rtp.extensions.push_back(RtpExtension(
+        extension_type_.c_str(), kTransportSequenceNumberExtensionId));
+  }
+
+  size_t i = 0;

[mflodman, 2016/01/13 15:12:45]

Not used for real.

[stefan-webrtc, 2016/01/13 16:23:25]

Done.

+  for (AudioReceiveStream::Config& recv_config : *receive_configs) {
+    recv_config.combined_audio_video_bwe = true;
+    recv_config.rtp.transport_cc = transport_cc;
+    recv_config.rtp.extensions = send_config->rtp.extensions;
+    recv_config.rtp.remote_ssrc = send_config->rtp.ssrc;
+    ++i;
+  }
+}
+
 void RampUpTester::OnCallsCreated(Call* sender_call, Call* receiver_call) {
   sender_call_ = sender_call;
 }
 
 bool RampUpTester::BitrateStatsPollingThread(void* obj) {
   return static_cast<RampUpTester*>(obj)->PollStats();
 }
 
 bool RampUpTester::PollStats() {
   if (sender_call_) {
@@ skipping 40 matching lines @@
                  stream.rtp_stats.fec.TotalBytes();
   *padding_sent += stream.rtp_stats.transmitted.padding_bytes +
                    stream.rtp_stats.retransmitted.padding_bytes +
                    stream.rtp_stats.fec.padding_bytes;
   *media_sent += stream.rtp_stats.MediaPayloadBytes();
 }
 
 void RampUpTester::TriggerTestDone() {
   RTC_DCHECK_GE(test_start_ms_, 0);
 
+  // TODO(holmer): Add audio send stats here too when those APIs are available.
   VideoSendStream::Stats send_stats = send_stream_->GetStats();
 
   size_t total_packets_sent = 0;
   size_t total_sent = 0;
   size_t padding_sent = 0;
   size_t media_sent = 0;
   for (uint32_t ssrc : video_ssrcs_) {
     AccumulateStats(send_stats.substreams[ssrc], &total_packets_sent,
                     &total_sent, &padding_sent, &media_sent);
   }
@@ skipping 13 matching lines @@
   ReportResult("ramp-up-padding-sent", padding_sent, "bytes");
   ReportResult("ramp-up-rtx-total-packets-sent", rtx_total_packets_sent,
                "packets");
   ReportResult("ramp-up-rtx-total-sent", rtx_total_sent, "bytes");
   ReportResult("ramp-up-rtx-media-sent", rtx_media_sent, "bytes");
   ReportResult("ramp-up-rtx-padding-sent", rtx_padding_sent, "bytes");
   if (ramp_up_finished_ms_ >= 0) {
     ReportResult("ramp-up-time", ramp_up_finished_ms_ - test_start_ms_,
                  "milliseconds");
   }
+  ReportResult("ramp-up-average-network-latency",
+               send_transport_->GetAverageDelayMs(), "milliseconds");
 }
 
 void RampUpTester::PerformTest() {
   test_start_ms_ = clock_->TimeInMilliseconds();
   poller_thread_.Start();
   EXPECT_TRUE(Wait()) << "Timed out while waiting for ramp-up to complete.";
   TriggerTestDone();
   poller_thread_.Stop();
 }
 
-RampUpDownUpTester::RampUpDownUpTester(size_t num_streams,
+RampUpDownUpTester::RampUpDownUpTester(size_t num_video_streams,
+                                       size_t num_audio_streams,
                                        unsigned int start_bitrate_bps,
                                        const std::string& extension_type,
                                        bool rtx,
                                        bool red)
-    : RampUpTester(num_streams, 0, start_bitrate_bps, extension_type, rtx, red),
+    : RampUpTester(num_video_streams,
+                   num_audio_streams,
+                   start_bitrate_bps,
+                   extension_type,
+                   rtx,
+                   red),
       test_state_(kFirstRampup),
       state_start_ms_(clock_->TimeInMilliseconds()),
       interval_start_ms_(clock_->TimeInMilliseconds()),
       sent_bytes_(0) {
   forward_transport_config_.link_capacity_kbps = kHighBandwidthLimitBps / 1000;
 }
 
 RampUpDownUpTester::~RampUpDownUpTester() {}
 
 bool RampUpDownUpTester::PollStats() {
@@ skipping 75 matching lines @@
         interval_start_ms_ = now;
         sent_bytes_ = 0;
       }
       break;
     }
     case kSecondRampup: {
       if (bitrate_bps > kExpectedHighBitrateBps && !suspended) {
         webrtc::test::PrintResult("ramp_up_down_up", GetModifierString(),
                                   "second_rampup", now - state_start_ms_, "ms",
                                   false);
+        ReportResult("ramp-up-down-up-average-network-latency",
+                     send_transport_->GetAverageDelayMs(), "milliseconds");
         observation_complete_.Set();
       }
       break;
     }
   }
 }
 
 class RampUpTest : public test::CallTest {
  public:
   RampUpTest() {}
@@ skipping 27 matching lines @@
 TEST_F(RampUpTest, SingleStreamWithHighStartBitrate) {
   RampUpTester test(1, 0, 0.9 * kSingleStreamTargetBps, RtpExtension::kTOffset,
                     false, false);
   RunBaseTest(&test);
 }
 
 // Disabled on Mac due to flakiness, see
 // https://bugs.chromium.org/p/webrtc/issues/detail?id=5407
 #ifndef WEBRTC_MAC
 TEST_F(RampUpTest, UpDownUpOneStream) {
-  RampUpDownUpTester test(1, 60000, RtpExtension::kAbsSendTime, false, false);
+  RampUpDownUpTester test(1, 0, kStartBitrateBps, RtpExtension::kAbsSendTime,
+                          false, false);
   RunBaseTest(&test);
 }
 
 TEST_F(RampUpTest, UpDownUpThreeStreams) {
-  RampUpDownUpTester test(3, 60000, RtpExtension::kAbsSendTime, false, false);
+  RampUpDownUpTester test(3, 0, kStartBitrateBps, RtpExtension::kAbsSendTime,
+                          false, false);
   RunBaseTest(&test);
 }
 
 TEST_F(RampUpTest, UpDownUpOneStreamRtx) {
-  RampUpDownUpTester test(1, 60000, RtpExtension::kAbsSendTime, true, false);
+  RampUpDownUpTester test(1, 0, kStartBitrateBps, RtpExtension::kAbsSendTime,
+                          true, false);
   RunBaseTest(&test);
 }
 
 TEST_F(RampUpTest, UpDownUpThreeStreamsRtx) {
-  RampUpDownUpTester test(3, 60000, RtpExtension::kAbsSendTime, true, false);
+  RampUpDownUpTester test(3, 0, kStartBitrateBps, RtpExtension::kAbsSendTime,
+                          true, false);
   RunBaseTest(&test);
 }
 
 TEST_F(RampUpTest, UpDownUpOneStreamByRedRtx) {
-  RampUpDownUpTester test(1, 60000, RtpExtension::kAbsSendTime, true, true);
+  RampUpDownUpTester test(1, 0, kStartBitrateBps, RtpExtension::kAbsSendTime,
+                          true, true);
   RunBaseTest(&test);
 }
 
 TEST_F(RampUpTest, UpDownUpThreeStreamsByRedRtx) {
-  RampUpDownUpTester test(3, 60000, RtpExtension::kAbsSendTime, true, true);
+  RampUpDownUpTester test(3, 0, kStartBitrateBps, RtpExtension::kAbsSendTime,
+                          true, true);
   RunBaseTest(&test);
 }
+
+TEST_F(RampUpTest, SendSideVideoUpDownUpRtx) {
+  RampUpDownUpTester test(3, 0, kStartBitrateBps,
+                          RtpExtension::kTransportSequenceNumber, true, false);
+  RunBaseTest(&test);
+}
+
+// TODO(holmer): Enable when audio bitrates are included in the bitrate
+//               allocation.
+TEST_F(RampUpTest, DISABLED_SendSideAudioVideoUpDownUpRtx) {
+  RampUpDownUpTester test(3, 1, kStartBitrateBps,
+                          RtpExtension::kTransportSequenceNumber, true, false);
+  RunBaseTest(&test);
+}
+
 #endif
 
 TEST_F(RampUpTest, AbsSendTimeSingleStream) {
   RampUpTester test(1, 0, 0, RtpExtension::kAbsSendTime, false, false);
   RunBaseTest(&test);
 }
 
 TEST_F(RampUpTest, AbsSendTimeSimulcast) {
   RampUpTester test(3, 0, 0, RtpExtension::kAbsSendTime, false, false);
   RunBaseTest(&test);
@@ skipping 26 matching lines @@
                     false);
   RunBaseTest(&test);
 }
 
 TEST_F(RampUpTest, TransportSequenceNumberSimulcastWithRtx) {
   RampUpTester test(3, 0, 0, RtpExtension::kTransportSequenceNumber, true,
                     false);
   RunBaseTest(&test);
 }
 
+TEST_F(RampUpTest, AudioVideoTransportSequenceNumberSimulcastWithRtx) {
+  RampUpTester test(3, 1, 0, RtpExtension::kTransportSequenceNumber, true,
+                    false);
+  RunBaseTest(&test);
+}
+
 TEST_F(RampUpTest, TransportSequenceNumberSimulcastByRedWithRtx) {
   RampUpTester test(3, 0, 0, RtpExtension::kTransportSequenceNumber, true,
                     true);
   RunBaseTest(&test);
 }
 
 TEST_F(RampUpTest, TransportSequenceNumberSingleStreamWithHighStartBitrate) {
   RampUpTester test(1, 0, 0.9 * kSingleStreamTargetBps,
                     RtpExtension::kTransportSequenceNumber, false, false);
   RunBaseTest(&test);
 }
 }  // namespace webrtc