BitrateProber: Support higher probing bitrates

webrtc/video/video_send_stream_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 <algorithm>  // max
@@ skipping 1026 matching lines @@
     Clock* const clock_;
     std::unique_ptr<internal::TransportAdapter> transport_adapter_;
     rtc::CriticalSection crit_;
     int64_t last_packet_time_ms_ GUARDED_BY(crit_);
     test::FrameGeneratorCapturer* capturer_ GUARDED_BY(crit_);
   } test;
 
   RunBaseTest(&test);
 }
 
+TEST_F(VideoSendStreamTest, PaddingIsPrimarilyRetransmissions) {
+  const int kCapacityKbps = 10000;  // 10 Mbps
+  class PaddingIsPrimarilyRetransmissions : public test::EndToEndTest {
+   public:
+    PaddingIsPrimarilyRetransmissions()
+        : EndToEndTest(kDefaultTimeoutMs),
+          clock_(Clock::GetRealTimeClock()),
+          padding_length_(0),
+          total_length_(0),
+          call_(nullptr) {}
+
+   private:
+    void OnCallsCreated(Call* sender_call, Call* receiver_call) override {
+      call_ = sender_call;
+    }
+
+    Action OnSendRtp(const uint8_t* packet, size_t length) override {
+      rtc::CritScope lock(&crit_);
+
+      RTPHeader header;
+      parser_->Parse(packet, length, &header);
+      padding_length_ += header.paddingLength;

[stefan-webrtc, 2016/09/30 08:37:21]

You only have to protect padding_length_ and total_length_ with the crit.

[Irfan, 2016/10/03 18:45:26]

Right, but given the contention is a one time thing at end of test, having the
CritScope at top keeps it a bit cleaner. 

[stefan-webrtc, 2016/10/04 14:56:40]

Acknowledged.

+      total_length_ += length;
+      return SEND_PACKET;
+    }
+
+    test::PacketTransport* CreateSendTransport(Call* sender_call) override {
+      const int kNetworkDelayMs = 50;
+      FakeNetworkPipe::Config config;
+      config.loss_percent = 10;
+      config.link_capacity_kbps = kCapacityKbps;
+      config.queue_delay_ms = kNetworkDelayMs;
+      return new test::PacketTransport(sender_call, this,
+                                       test::PacketTransport::kSender, config);
+    }
+
+    void ModifyVideoConfigs(
+        VideoSendStream::Config* send_config,
+        std::vector<VideoReceiveStream::Config>* receive_configs,
+        VideoEncoderConfig* encoder_config) override {
+      send_config->rtp.extensions.clear();
+      send_config->rtp.extensions.push_back(
+          RtpExtension(RtpExtension::kTransportSequenceNumberUri,
+                       test::kTransportSequenceNumberExtensionId));
+      // Turn on RTX

[stefan-webrtc, 2016/09/30 08:37:21]

End with .

[Irfan, 2016/10/03 18:45:26]

Done.

+      send_config->rtp.rtx.payload_type = kFakeVideoSendPayloadType;
+      send_config->rtp.rtx.ssrcs.push_back(kVideoSendSsrcs[0]);
+
+      (*receive_configs)[0].rtp.extensions.clear();
+      (*receive_configs)[0].rtp.extensions.push_back(
+          RtpExtension(RtpExtension::kTransportSequenceNumberUri,
+                       test::kTransportSequenceNumberExtensionId));
+      (*receive_configs)[0].rtp.transport_cc = true;
+    }
+
+    void PerformTest() override {
+      // TODO(isheriff): Some platforms do not ramp up as expected to full
+      // capacity due to packet scheduling delays. Fix that before getting
+      // rid of this.
+      SleepMs(5000);
+      {
+        rtc::CritScope lock(&crit_);
+        // Expect padding to be a small percentage of total bytes sent.
+        EXPECT_LT(padding_length_, .1 * total_length_);

[stefan-webrtc, 2016/09/30 08:37:21]

Just a question: I would have expected 0% padding. Do you know why that is not
the case?

[Irfan, 2016/10/03 18:45:26]

Adding logs, I see that there are a small number of instances where there is
nothing in packet_history to force rtx

[stefan-webrtc, 2016/10/04 14:56:40]

Out of curiosity, are those sent before any media packets are sent, or are they
sent because the packets in the history are too old? Or maybe it's just that the
requested padding size is too small for it to make sense to send a full sized
media packet.

[Irfan, 2016/10/04 15:23:33]

Clarification here: Turns out, its actually because there is a small amount of
pad is requested (< 50 bytes) and rtp_packet_history just returns nothing when
that happens. 

+      }
+    }
+
+    rtc::CriticalSection crit_;
+    Clock* const clock_;
+    size_t padding_length_;
+    size_t total_length_;

[stefan-webrtc, 2016/09/30 08:37:21]

Add GUARDED_BY

[Irfan, 2016/10/03 18:45:26]

Done.

+    Call* call_;
+  } test;
+
+  RunBaseTest(&test);
+}
+
 // This test first observes "high" bitrate use at which point it sends a REMB to
 // indicate that it should be lowered significantly. The test then observes that
 // the bitrate observed is sinking well below the min-transmit-bitrate threshold
 // to verify that the min-transmit bitrate respects incoming REMB.
 //
 // Note that the test starts at "high" bitrate and does not ramp up to "higher"
 // bitrate since no receiver block or remb is sent in the initial phase.
 TEST_F(VideoSendStreamTest, MinTransmitBitrateRespectsRemb) {
   static const int kMinTransmitBitrateBps = 400000;
   static const int kHighBitrateBps = 150000;
@@ skipping 1540 matching lines @@
         observation_complete_.Set();
       }
     }
   } test;
 
   RunBaseTest(&test);
 }
 #endif  // !defined(RTC_DISABLE_VP9)
 
 }  // namespace webrtc