Added configurable offsets to the per-packet overhead in ANA.

modules/audio_coding/audio_network_adaptor/frame_length_controller_unittest.cc

 /*
  *  Copyright (c) 2016 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 <memory>
 #include <utility>
 
 #include "modules/audio_coding/audio_network_adaptor/frame_length_controller.h"
 #include "test/gtest.h"
 
 namespace webrtc {
 
 namespace {
 
 constexpr float kFlIncreasingPacketLossFraction = 0.04f;
 constexpr float kFlDecreasingPacketLossFraction = 0.05f;
+constexpr int kFlIncreaseOverheadOffset = 0;
+constexpr int kFlDecreaseOverheadOffset = 0;
 constexpr int kMinEncoderBitrateBps = 6000;
 constexpr int kPreventOveruseMarginBps = 5000;
 constexpr size_t kOverheadBytesPerPacket = 20;
 constexpr int kFl20msTo60msBandwidthBps = 40000;
 constexpr int kFl60msTo20msBandwidthBps = 50000;
 constexpr int kFl60msTo120msBandwidthBps = 30000;
 constexpr int kFl120msTo60msBandwidthBps = 40000;
 constexpr int kMediumBandwidthBps =
     (kFl60msTo20msBandwidthBps + kFl20msTo60msBandwidthBps) / 2;
 constexpr float kMediumPacketLossFraction =
     (kFlDecreasingPacketLossFraction + kFlIncreasingPacketLossFraction) / 2;
 
 int VeryLowBitrate(int frame_length_ms) {
   return kMinEncoderBitrateBps + kPreventOveruseMarginBps +
          (kOverheadBytesPerPacket * 8 * 1000 / frame_length_ms);
 }
 
 std::unique_ptr<FrameLengthController> CreateController(
     const std::map<FrameLengthController::Config::FrameLengthChange, int>&
         frame_length_change_criteria,
     const std::vector<int>& encoder_frame_lengths_ms,
     int initial_frame_length_ms) {
   std::unique_ptr<FrameLengthController> controller(
       new FrameLengthController(FrameLengthController::Config(
           encoder_frame_lengths_ms, initial_frame_length_ms,
           kMinEncoderBitrateBps, kFlIncreasingPacketLossFraction,
-          kFlDecreasingPacketLossFraction, frame_length_change_criteria)));
+          kFlDecreasingPacketLossFraction, kFlIncreaseOverheadOffset,
+          kFlDecreaseOverheadOffset, frame_length_change_criteria)));
 
   return controller;
 }
 
 std::map<FrameLengthController::Config::FrameLengthChange, int>
 CreateChangeCriteriaFor20msAnd60ms() {
   return std::map<FrameLengthController::Config::FrameLengthChange, int>{
       {FrameLengthController::Config::FrameLengthChange(20, 60),
        kFl20msTo60msBandwidthBps},
       {FrameLengthController::Config::FrameLengthChange(60, 20),
@@ skipping 314 matching lines @@
   CheckDecision(controller.get(), 60);
 
   UpdateNetworkMetrics(controller.get(),
                        rtc::Optional<int>(kMediumBandwidthBps),
                        rtc::Optional<float>(kFlDecreasingPacketLossFraction),
                        rtc::Optional<size_t>(kOverheadBytesPerPacket));
   CheckDecision(controller.get(), 20);
 }
 
 }  // namespace webrtc