Add overhead to audio bwe min, max.

webrtc/media/engine/webrtcvoiceengine.cc

 /*
  *  Copyright (c) 2004 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.
  */
 
@@ skipping 381 matching lines @@
   static int MaxBitrateBps(const webrtc::CodecInst& codec) {
     for (size_t i = 0; i < arraysize(kCodecPrefs); ++i) {
       if (IsCodec(codec, kCodecPrefs[i].name) &&
           kCodecPrefs[i].clockrate == codec.plfreq) {
         return kCodecPrefs[i].max_bitrate_bps;
       }
     }
     return 0;
   }
 
+  static rtc::ArrayView<const int> GetPacketSizesMs(
+      const webrtc::CodecInst& codec) {
+    for (size_t i = 0; i < arraysize(kCodecPrefs); ++i) {
+      if (IsCodec(codec, kCodecPrefs[i].name)) {
+        int packet_sizes_ms_size = [&]() {

[stefan-webrtc, 2017/01/10 13:42:04]

I'd simply write it like this:

size_t num_packet_sizes = kMaxNumPacketSize;
for (int index = 0; index < kMaxNumPacketSize; index++) {
  if (packet_size == 0)
    num_packet_sizes = index;
}
return rtc::ArrayView<const int>(kCodecPrefs[i].packet_sizes_ms,
num_packet_sizes);

[michaelt, 2017/01/10 14:55:21]

Done.

+          for (int index = 0; index < kMaxNumPacketSize; index++) {
+            if (kCodecPrefs[i].packet_sizes_ms[index] == 0) {
+              return index;
+            }
+          }
+          return kMaxNumPacketSize;
+        }();
+        return rtc::ArrayView<const int>(kCodecPrefs[i].packet_sizes_ms,
+                                         packet_sizes_ms_size);
+      }
+    }
+    return rtc::ArrayView<const int>();
+  }
+
   // If the AudioCodec param kCodecParamPTime is set, then we will set it to
   // codec pacsize if it's valid, or we will pick the next smallest value we
   // support.
   // TODO(Brave): Query supported packet sizes from ACM when the API is ready.
   static bool SetPTimeAsPacketSize(webrtc::CodecInst* codec, int ptime_ms) {
     for (const CodecPref& codec_pref : kCodecPrefs) {
       if ((IsCodec(*codec, codec_pref.name) &&
           codec_pref.clockrate == codec->plfreq) ||
           IsCodec(*codec, kG722CodecName)) {
         int packet_size_ms = SelectPacketSize(codec_pref, ptime_ms);
@@ skipping 1001 matching lines @@
     RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
     if (stream_) {
       call_->DestroyAudioSendStream(stream_);
       stream_ = nullptr;
     }
     RTC_DCHECK(!stream_);
     if (webrtc::field_trial::FindFullName("WebRTC-Audio-SendSideBwe") ==
         "Enabled") {
       // TODO(mflodman): Keep testing this and set proper values.
       // Note: This is an early experiment currently only supported by Opus.
-      config_.min_bitrate_bps = kOpusMinBitrateBps;
-      config_.max_bitrate_bps = kOpusBitrateFbBps;
+      if (webrtc::field_trial::FindFullName(
+              "WebRTC-SendSideBwe-WithOverhead") == "Enabled") {
+        auto packet_sizes_ms = WebRtcVoiceCodecs::GetPacketSizesMs(
+            config_.send_codec_spec.codec_inst);
+        if (packet_sizes_ms.size() > 0) {
+          const int* max_packet_size_ms =
+              std::max_element(packet_sizes_ms.begin(), packet_sizes_ms.end());
+          const int* min_packet_size_ms =
+              std::min_element(packet_sizes_ms.begin(), packet_sizes_ms.end());
+
+          // OverheadPerPacket = Ipv4(20B) + UDP(8B) + SRTP(10B) + RTP(12)
+          constexpr int kOverheadPerPacket = 20 + 8 + 10 + 12;
+
+          int min_overhead_bps =
+              kOverheadPerPacket * 8 * 1000 / *max_packet_size_ms;
+
+          // Opus will not use a shorter frame length than kOpusDefaultPTime.
+          int max_overhead_bps =
+              kOverheadPerPacket * 8 * 1000 /
+              std::max(*min_packet_size_ms, kOpusDefaultPTime);
+
+          config_.min_bitrate_bps = kOpusMinBitrateBps + min_overhead_bps;
+          config_.max_bitrate_bps = kOpusBitrateFbBps + max_overhead_bps;
+        }
+      } else {
+        config_.min_bitrate_bps = kOpusMinBitrateBps;
+        config_.max_bitrate_bps = kOpusBitrateFbBps;
+      }
     }
     stream_ = call_->CreateAudioSendStream(config_);
     RTC_CHECK(stream_);
     UpdateSendState();
   }
 
   rtc::ThreadChecker worker_thread_checker_;
   rtc::RaceChecker audio_capture_race_checker_;
   webrtc::AudioTransport* const voe_audio_transport_ = nullptr;
   webrtc::Call* call_ = nullptr;
@@ skipping 1203 matching lines @@
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
   const auto it = send_streams_.find(ssrc);
   if (it != send_streams_.end()) {
     return it->second->channel();
   }
   return -1;
 }
 }  // namespace cricket
 
 #endif  // HAVE_WEBRTC_VOICE