Fixes a bug where a video stream can get stuck in the suspended state.

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 "webrtc/base/checks.h"
+#include "webrtc/base/logging.h"
 #include "webrtc/base/platform_thread.h"
 #include "webrtc/test/encoder_settings.h"
 #include "webrtc/test/gtest.h"
 #include "webrtc/test/testsupport/perf_test.h"
 
 namespace webrtc {
 namespace {
 
 static const int64_t kPollIntervalMs = 20;
-static const int kExpectedHighVideoBitrateBps = 60000;
+static const int kExpectedHighVideoBitrateBps = 80000;
 static const int kExpectedHighAudioBitrateBps = 30000;
 static const int kLowBandwidthLimitBps = 20000;
 static const int kExpectedLowBitrateBps = 20000;
 
 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
 
 RampUpTester::RampUpTester(size_t num_video_streams,
                            size_t num_audio_streams,
+                           size_t num_flexfec_streams,
                            unsigned int start_bitrate_bps,
                            int64_t min_run_time_ms,
                            const std::string& extension_type,
                            bool rtx,
                            bool red,
                            bool report_perf_stats)
     : EndToEndTest(test::CallTest::kLongTimeoutMs),
       event_(false, false),
       clock_(Clock::GetRealTimeClock()),
       num_video_streams_(num_video_streams),
       num_audio_streams_(num_audio_streams),
+      num_flexfec_streams_(num_flexfec_streams),
       rtx_(rtx),
       red_(red),
       sender_call_(nullptr),
       send_stream_(nullptr),
       start_bitrate_bps_(start_bitrate_bps),
       min_run_time_ms_(min_run_time_ms),
       report_perf_stats_(report_perf_stats),
       expected_bitrate_bps_(0),
       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") {
+  if (red_)
+    EXPECT_EQ(0u, num_flexfec_streams_);
   EXPECT_LE(num_audio_streams_, 1u);
 }
 
 RampUpTester::~RampUpTester() {
   event_.Set();
 }
 
 Call::Config RampUpTester::GetSenderCallConfig() {
   Call::Config call_config(&event_log_);
   if (start_bitrate_bps_ != 0) {
@@ skipping 17 matching lines @@
 }
 
 size_t RampUpTester::GetNumVideoStreams() const {
   return num_video_streams_;
 }
 
 size_t RampUpTester::GetNumAudioStreams() const {
   return num_audio_streams_;
 }
 
+size_t RampUpTester::GetNumFlexfecStreams() const {
+  return num_flexfec_streams_;
+}
+
 class RampUpTester::VideoStreamFactory
     : public VideoEncoderConfig::VideoStreamFactoryInterface {
  public:
   VideoStreamFactory() {}
 
  private:
   std::vector<VideoStream> CreateEncoderStreams(
       int width,
       int height,
       const VideoEncoderConfig& encoder_config) override {
@@ skipping 89 matching lines @@
     }
 
     if (rtx_) {
       recv_config.rtp.rtx_ssrc = video_rtx_ssrcs_[i];
       recv_config.rtp
           .rtx_payload_types[send_config->encoder_settings.payload_type] =
           send_config->rtp.rtx.payload_type;
     }
     ++i;
   }
+
+  RTC_DCHECK_LE(num_flexfec_streams_, 1);
+  if (num_flexfec_streams_ == 1) {
+    send_config->rtp.flexfec.payload_type = test::CallTest::kFlexfecPayloadType;
+    send_config->rtp.flexfec.ssrc = test::CallTest::kFlexfecSendSsrc;
+    send_config->rtp.flexfec.protected_media_ssrcs = {video_ssrcs_[0]};
+  }
 }
 
 void RampUpTester::ModifyAudioConfigs(
     AudioSendStream::Config* send_config,
     std::vector<AudioReceiveStream::Config>* receive_configs) {
   if (num_audio_streams_ == 0)
     return;
 
   EXPECT_NE(RtpExtension::kTimestampOffsetUri, extension_type_)
       << "Audio BWE not supported with toffset.";
+  EXPECT_NE(RtpExtension::kAbsSendTimeUri, extension_type_)
+      << "Audio BWE not supported with abs-send-time.";
 
   send_config->rtp.ssrc = audio_ssrcs_[0];
   send_config->rtp.extensions.clear();
 
   send_config->min_bitrate_bps = 6000;
   send_config->max_bitrate_bps = 60000;
 
   bool transport_cc = false;
-  if (extension_type_ == RtpExtension::kAbsSendTimeUri) {
-    transport_cc = false;
-    send_config->rtp.extensions.push_back(
-        RtpExtension(extension_type_.c_str(), kAbsSendTimeExtensionId));
-  } else if (extension_type_ == RtpExtension::kTransportSequenceNumberUri) {
+  if (extension_type_ == RtpExtension::kTransportSequenceNumberUri) {
     transport_cc = true;
     send_config->rtp.extensions.push_back(RtpExtension(
         extension_type_.c_str(), kTransportSequenceNumberExtensionId));
   }
 
   for (AudioReceiveStream::Config& recv_config : *receive_configs) {
     recv_config.rtp.transport_cc = transport_cc;
     recv_config.rtp.extensions = send_config->rtp.extensions;
     recv_config.rtp.remote_ssrc = send_config->rtp.ssrc;
   }
 }
 
+void RampUpTester::ModifyFlexfecConfigs(
+    std::vector<FlexfecReceiveStream::Config>* receive_configs) {
+  if (num_flexfec_streams_ == 0)
+    return;
+  RTC_DCHECK_EQ(1, num_flexfec_streams_);
+  (*receive_configs)[0].payload_type = test::CallTest::kFlexfecPayloadType;
+  (*receive_configs)[0].remote_ssrc = test::CallTest::kFlexfecSendSsrc;
+  (*receive_configs)[0].protected_media_ssrcs = {video_ssrcs_[0]};
+  (*receive_configs)[0].local_ssrc = video_ssrcs_[0];
+  if (extension_type_ == RtpExtension::kAbsSendTimeUri) {
+    (*receive_configs)[0].transport_cc = false;
+    (*receive_configs)[0].rtp_header_extensions.push_back(
+        RtpExtension(extension_type_.c_str(), kAbsSendTimeExtensionId));
+  } else if (extension_type_ == RtpExtension::kTransportSequenceNumberUri) {
+    (*receive_configs)[0].transport_cc = true;
+    (*receive_configs)[0].rtp_header_extensions.push_back(RtpExtension(
+        extension_type_.c_str(), kTransportSequenceNumberExtensionId));
+  }
+}
+
 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 87 matching lines @@
 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_video_streams,
                                        size_t num_audio_streams,
+                                       size_t num_flexfec_streams,
                                        unsigned int start_bitrate_bps,
                                        const std::string& extension_type,
                                        bool rtx,
                                        bool red)
     : RampUpTester(num_video_streams,
                    num_audio_streams,
+                   num_flexfec_streams,
                    start_bitrate_bps,
                    0,
                    extension_type,
                    rtx,
                    red,
                    true),
       test_state_(kFirstRampup),
       state_start_ms_(clock_->TimeInMilliseconds()),
       interval_start_ms_(clock_->TimeInMilliseconds()),
       sent_bytes_(0) {
@@ skipping 61 matching lines @@
 int RampUpDownUpTester::GetHighLinkCapacity() const {
   return 4 * GetExpectedHighBitrate() / (3 * 1000);
 }
 
 void RampUpDownUpTester::EvolveTestState(int bitrate_bps, bool suspended) {
   int64_t now = clock_->TimeInMilliseconds();
   switch (test_state_) {
     case kFirstRampup: {
       EXPECT_FALSE(suspended);
       if (bitrate_bps >= GetExpectedHighBitrate()) {
+        webrtc::test::PrintResult("ramp_up_down_up", GetModifierString(),
+                                  "first_rampup", now - state_start_ms_, "ms",
+                                  false);
+        if (num_flexfec_streams_ > 0) {
+          // Increase loss rate and delay and wait for FEC to be produced.
+          forward_transport_config_.loss_percent = 25;
+          forward_transport_config_.queue_delay_ms = 100;
+        }
+        test_state_ = kWaitForFec;
+        send_transport_->SetConfig(forward_transport_config_);
+      }
+      break;
+    }
+    case kWaitForFec: {
+      size_t flex_fec_bytes = 0;
+      if (num_flexfec_streams_ > 0) {
+        webrtc::VideoSendStream::Stats stats = send_stream_->GetStats();
+        for (const auto& kv : stats.substreams)
+          flex_fec_bytes += kv.second.rtp_stats.fec.TotalBytes();
+      }
+      if (num_flexfec_streams_ == 0 || flex_fec_bytes > 0) {

[terelius, 2017/02/20 17:42:37]

How about functions SetLossRates(r1,r2,r3) and SetExpectedFecRates(r) that
allows configuring packet loss and FEC from each test? The tests would be
slightly more verbose (at least if many of them use FEC), but I think it would
increase flexibility and clarity. WDYT?

[stefan-webrtc, 2017/02/21 09:09:45]

I improved it quite a bit, but not exactly how you suggested.

         // The first ramp-up has reached the target bitrate. Change the
         // channel limit, and move to the next test state.
         forward_transport_config_.link_capacity_kbps =
             kLowBandwidthLimitBps / 1000;
+        forward_transport_config_.loss_percent = 0;
         send_transport_->SetConfig(forward_transport_config_);
-        test_state_ = kLowRate;
-        webrtc::test::PrintResult("ramp_up_down_up", GetModifierString(),
-                                  "first_rampup", now - state_start_ms_, "ms",
-                                  false);
         state_start_ms_ = now;
         interval_start_ms_ = now;
         sent_bytes_ = 0;
+        test_state_ = kLowRate;
       }
       break;
     }
     case kLowRate: {
       // Audio streams are never suspended.
       bool check_suspend_state = num_video_streams_ > 0;
       if (bitrate_bps < kExpectedLowBitrateBps &&
           suspended == check_suspend_state) {
         // The ramp-down was successful. Change the channel limit back to a
         // high value, and move to the next test state.
@@ skipping 29 matching lines @@
 
   virtual ~RampUpTest() {
     EXPECT_EQ(nullptr, video_send_stream_);
     EXPECT_TRUE(video_receive_streams_.empty());
   }
 };
 
 static const uint32_t kStartBitrateBps = 60000;
 
 TEST_F(RampUpTest, UpDownUpAbsSendTimeSimulcastRedRtx) {
-  RampUpDownUpTester test(3, 0, kStartBitrateBps, RtpExtension::kAbsSendTimeUri,
-                          true, true);
+  RampUpDownUpTester test(3, 0, 0, kStartBitrateBps,
+                          RtpExtension::kAbsSendTimeUri, true, true);
   RunBaseTest(&test);
 }
 
 TEST_F(RampUpTest, UpDownUpTransportSequenceNumberRtx) {
-  RampUpDownUpTester test(3, 0, kStartBitrateBps,
+  RampUpDownUpTester test(1, 0, 0, kStartBitrateBps,

[terelius, 2017/02/20 17:42:37]

Why change the number of streams here? Is it because FlexFEC only protects one
stream and you want to compare results with the test below?

[stefan-webrtc, 2017/02/21 09:09:45]

Mistake. Changing back. :)

+                          RtpExtension::kTransportSequenceNumberUri, true,
+                          false);
+  RunBaseTest(&test);
+}
+
+TEST_F(RampUpTest, UpDownUpTransportSequenceNumberPacketLoss) {
+  RampUpDownUpTester test(1, 0, 1, kStartBitrateBps,
                           RtpExtension::kTransportSequenceNumberUri, true,
                           false);
   RunBaseTest(&test);
 }
 
 TEST_F(RampUpTest, UpDownUpAudioVideoTransportSequenceNumberRtx) {
-  RampUpDownUpTester test(3, 1, kStartBitrateBps,
+  RampUpDownUpTester test(3, 1, 0, kStartBitrateBps,
                           RtpExtension::kTransportSequenceNumberUri, true,
                           false);
   RunBaseTest(&test);
 }
 
 TEST_F(RampUpTest, UpDownUpAudioTransportSequenceNumberRtx) {
-  RampUpDownUpTester test(0, 1, kStartBitrateBps,
+  RampUpDownUpTester test(0, 1, 0, kStartBitrateBps,
                           RtpExtension::kTransportSequenceNumberUri, true,
                           false);
   RunBaseTest(&test);
 }
 
 TEST_F(RampUpTest, TOffsetSimulcastRedRtx) {
-  RampUpTester test(3, 0, 0, 0, RtpExtension::kTimestampOffsetUri, true, true,
-                    true);
+  RampUpTester test(3, 0, 0, 0, 0, RtpExtension::kTimestampOffsetUri, true,
+                    true, true);
   RunBaseTest(&test);
 }
 
 TEST_F(RampUpTest, AbsSendTime) {
-  RampUpTester test(1, 0, 0, 0, RtpExtension::kAbsSendTimeUri, false, false,
+  RampUpTester test(1, 0, 0, 0, 0, RtpExtension::kAbsSendTimeUri, false, false,
                     true);
   RunBaseTest(&test);
 }
 
 TEST_F(RampUpTest, AbsSendTimeSimulcastRedRtx) {
-  RampUpTester test(3, 0, 0, 0, RtpExtension::kAbsSendTimeUri, true, true,
+  RampUpTester test(3, 0, 0, 0, 0, RtpExtension::kAbsSendTimeUri, true, true,
                     true);
   RunBaseTest(&test);
 }
 
 TEST_F(RampUpTest, TransportSequenceNumber) {
-  RampUpTester test(1, 0, 0, 0, RtpExtension::kTransportSequenceNumberUri,
+  RampUpTester test(1, 0, 0, 0, 0, RtpExtension::kTransportSequenceNumberUri,
                     false, false, true);
   RunBaseTest(&test);
 }
 
 TEST_F(RampUpTest, TransportSequenceNumberSimulcast) {
-  RampUpTester test(3, 0, 0, 0, RtpExtension::kTransportSequenceNumberUri,
+  RampUpTester test(3, 0, 0, 0, 0, RtpExtension::kTransportSequenceNumberUri,
                     false, false, true);
   RunBaseTest(&test);
 }
 
 TEST_F(RampUpTest, TransportSequenceNumberSimulcastRedRtx) {
-  RampUpTester test(3, 0, 0, 0, RtpExtension::kTransportSequenceNumberUri,
+  RampUpTester test(3, 0, 0, 0, 0, RtpExtension::kTransportSequenceNumberUri,
                     true, true, true);
   RunBaseTest(&test);
 }
 
 TEST_F(RampUpTest, AudioTransportSequenceNumber) {
-  RampUpTester test(0, 1, 300000, 10000,
+  RampUpTester test(0, 1, 0, 300000, 10000,
                     RtpExtension::kTransportSequenceNumberUri, false, false,
                     false);
   RunBaseTest(&test);
 }
 }  // namespace webrtc