Remove overhead from video bitrate.

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 18 matching lines @@
 #include "webrtc/system_wrappers/include/sleep.h"
 #include "webrtc/test/call_test.h"
 #include "webrtc/test/configurable_frame_size_encoder.h"
 #include "webrtc/test/fake_texture_frame.h"
 #include "webrtc/test/frame_generator.h"
 #include "webrtc/test/frame_utils.h"
 #include "webrtc/test/gtest.h"
 #include "webrtc/test/null_transport.h"
 #include "webrtc/test/rtcp_packet_parser.h"
 #include "webrtc/test/testsupport/perf_test.h"
+#include "webrtc/test/field_trial.h"
 
 #include "webrtc/video/send_statistics_proxy.h"
 #include "webrtc/video/transport_adapter.h"
 #include "webrtc/video_frame.h"
 #include "webrtc/video_send_stream.h"
 
 namespace webrtc {
 
 enum VideoFormat { kGeneric, kVP8, };
 
@@ skipping 1446 matching lines @@
         : EndToEndTest(test::CallTest::kDefaultTimeoutMs),
           call_(nullptr),
           packets_sent_(0),
           transport_overhead_(0) {}
 
     void OnCallsCreated(Call* sender_call, Call* receiver_call) override {
       call_ = sender_call;
     }
 
     Action OnSendRtp(const uint8_t* packet, size_t length) override {
-      EXPECT_LE(length,
-                IP_PACKET_SIZE - static_cast<size_t>(transport_overhead_));
+      EXPECT_LE(length, kMaxRtpPacketSize);
       if (++packets_sent_ < 100)
         return SEND_PACKET;
       observation_complete_.Set();
       return SEND_PACKET;
     }
 
+    void ModifyVideoConfigs(
+        VideoSendStream::Config* send_config,
+        std::vector<VideoReceiveStream::Config>* receive_configs,
+        VideoEncoderConfig* encoder_config) override {
+      send_config->rtp.max_packet_size = kMaxRtpPacketSize;
+    }
+
     void PerformTest() override {
+      transport_overhead_ = 100;
+      call_->OnTransportOverheadChanged(webrtc::MediaType::VIDEO,
+                                        transport_overhead_);
+      EXPECT_TRUE(Wait());
+      packets_sent_ = 0;
       transport_overhead_ = 500;
       call_->OnTransportOverheadChanged(webrtc::MediaType::VIDEO,
                                         transport_overhead_);
       EXPECT_TRUE(Wait());
-      packets_sent_ = 0;
-      transport_overhead_ = 1000;
-      call_->OnTransportOverheadChanged(webrtc::MediaType::VIDEO,
-                                        transport_overhead_);
-      EXPECT_TRUE(Wait());
     }
 
    private:
     Call* call_;
     int packets_sent_;
     int transport_overhead_;
+    const size_t kMaxRtpPacketSize = 1000;
   } test;
 
   RunBaseTest(&test);
 }
 
 class MaxPaddingSetTest : public test::SendTest {
  public:
   static const uint32_t kMinTransmitBitrateBps = 400000;
   static const uint32_t kActualEncodeBitrateBps = 40000;
   static const uint32_t kMinPacketsToSend = 50;
@@ skipping 1627 matching lines @@
 TEST_F(VideoSendStreamTest,
        RequestSourceRotateIfVideoOrientationExtensionNotSupported) {
   TestRequestSourceRotateVideo(false);
 }
 
 TEST_F(VideoSendStreamTest,
        DoNotRequestsRotationIfVideoOrientationExtensionSupported) {
   TestRequestSourceRotateVideo(true);
 }
 
+// This test verifies that overhead is removed from the bandwidth estimate by
+// testing that the maximum possible target payload rate is smaller than the
+// maximum bandwidth estimate by the overhead rate.
+TEST_F(VideoSendStreamTest, RemoveOverheadFromBandwidth) {
+  test::ScopedFieldTrials override_field_trials(
+      "WebRTC-SendSideBwe-WithOverhead/Enabled/");
+  class RemoveOverheadFromBandwidthTest : public test::EndToEndTest,
+                                          public test::FakeEncoder {
+   public:
+    RemoveOverheadFromBandwidthTest()
+        : EndToEndTest(test::CallTest::kDefaultTimeoutMs),
+          FakeEncoder(Clock::GetRealTimeClock()),
+          call_(nullptr),
+          max_bitrate_kbps_(0) {}
+
+    int32_t SetRateAllocation(const BitrateAllocation& bitrate,
+                              uint32_t frameRate) override {
+      rtc::CritScope lock(&crit_);
+      if (max_bitrate_kbps_ < bitrate.get_sum_kbps())
+        max_bitrate_kbps_ = bitrate.get_sum_kbps();
+      return FakeEncoder::SetRateAllocation(bitrate, frameRate);
+    }
+
+    void OnCallsCreated(Call* sender_call, Call* receiver_call) override {
+      call_ = sender_call;
+    }
+
+    void ModifyVideoConfigs(
+        VideoSendStream::Config* send_config,
+        std::vector<VideoReceiveStream::Config>* receive_configs,
+        VideoEncoderConfig* encoder_config) override {
+      send_config->rtp.max_packet_size = 1200;
+      send_config->encoder_settings.encoder = this;
+      EXPECT_FALSE(send_config->rtp.extensions.empty());
+    }
+
+    void PerformTest() override {
+      call_->OnTransportOverheadChanged(webrtc::MediaType::VIDEO, 20);
+      Call::Config::BitrateConfig bitrate_config;
+      constexpr int kStartBitrateBps = 50000;
+      constexpr int kMaxBitrateBps = 60000;
+      bitrate_config.start_bitrate_bps = kStartBitrateBps;
+      bitrate_config.max_bitrate_bps = kMaxBitrateBps;
+      call_->SetBitrateConfig(bitrate_config);
+
+      // At a bitrate of 60kbps with a packet size of 1200B video and an
+      // overhead of 40B per packet video produces 2kbps overhead.
+      // So with a BWE should reach 58kbps but not 60kbps.
+      Wait();
+      {
+        rtc::CritScope lock(&crit_);
+        EXPECT_EQ(58u, max_bitrate_kbps_);
+      }
+    }
+
+   private:
+    Call* call_;
+    rtc::CriticalSection crit_;
+    uint32_t max_bitrate_kbps_ GUARDED_BY(&crit_);
+  } test;
+
+  RunBaseTest(&test);
+}
+
 }  // namespace webrtc