Fixing config for Audio BWE.

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 65 matching lines @@
 // draft-spittka-payload-rtp-opus-03
 
 // Recommended bitrates:
 // 8-12 kb/s for NB speech,
 // 16-20 kb/s for WB speech,
 // 28-40 kb/s for FB speech,
 // 48-64 kb/s for FB mono music, and
 // 64-128 kb/s for FB stereo music.
 // The current implementation applies the following values to mono signals,
 // and multiplies them by 2 for stereo.
-const int kOpusBitrateNb = 12000;
-const int kOpusBitrateWb = 20000;
-const int kOpusBitrateFb = 32000;
+const int kOpusBitrateNbBps = 12000;
+const int kOpusBitrateWbBps = 20000;
+const int kOpusBitrateFbBps = 32000;
 
 // Opus bitrate should be in the range between 6000 and 510000.
-const int kOpusMinBitrate = 6000;
-const int kOpusMaxBitrate = 510000;
+const int kOpusMinBitrateBps = 6000;
+const int kOpusMaxBitrateBps = 510000;
 
 // iSAC bitrate should be <= 56000.
-const int kIsacMaxBitrate = 56000;
+const int kIsacMaxBitrateBps = 56000;
 
 // Default audio dscp value.
 // See http://tools.ietf.org/html/rfc2474 for details.
 // See also http://tools.ietf.org/html/draft-jennings-rtcweb-qos-00
 const rtc::DiffServCodePoint kAudioDscpValue = rtc::DSCP_EF;
 
 // Constants from voice_engine_defines.h.
 const int kMinTelephoneEventCode = 0;           // RFC4733 (Section 2.3.1)
 const int kMaxTelephoneEventCode = 255;
 const int kMinTelephoneEventDuration = 100;
@@ skipping 109 matching lines @@
 // clamp it. Returns the Opus bit rate for operation.
 int GetOpusBitrate(const AudioCodec& codec, int max_playback_rate) {
   int bitrate = 0;
   bool use_param = true;
   if (!codec.GetParam(kCodecParamMaxAverageBitrate, &bitrate)) {
     bitrate = codec.bitrate;
     use_param = false;
   }
   if (bitrate <= 0) {
     if (max_playback_rate <= 8000) {
-      bitrate = kOpusBitrateNb;
+      bitrate = kOpusBitrateNbBps;
     } else if (max_playback_rate <= 16000) {
-      bitrate = kOpusBitrateWb;
+      bitrate = kOpusBitrateWbBps;
     } else {
-      bitrate = kOpusBitrateFb;
+      bitrate = kOpusBitrateFbBps;
     }
 
     if (IsCodecFeatureEnabled(codec, kCodecParamStereo)) {
       bitrate *= 2;
     }
-  } else if (bitrate < kOpusMinBitrate || bitrate > kOpusMaxBitrate) {
-    bitrate = (bitrate < kOpusMinBitrate) ? kOpusMinBitrate : kOpusMaxBitrate;
+  } else if (bitrate < kOpusMinBitrateBps || bitrate > kOpusMaxBitrateBps) {
+    bitrate = (bitrate < kOpusMinBitrateBps) ? kOpusMinBitrateBps
+                                             : kOpusMaxBitrateBps;
     std::string rate_source =
         use_param ? "Codec parameter \"maxaveragebitrate\"" :
             "Supplied Opus bitrate";
     LOG(LS_WARNING) << rate_source
                     << " is invalid and is replaced by: "
                     << bitrate;
   }
   return bitrate;
 }
 
@@ skipping 224 matching lines @@
     if (IsCodec(*voe_codec, kG722CodecName)) {
       // If the ASSERT triggers, the codec definition in WebRTC VoiceEngine
       // has changed, and this special case is no longer needed.
       RTC_DCHECK(voe_codec->plfreq != new_plfreq);
       voe_codec->plfreq = new_plfreq;
     }
   }
 };
 
 const WebRtcVoiceCodecs::CodecPref WebRtcVoiceCodecs::kCodecPrefs[11] = {
-    {kOpusCodecName, 48000, 2, 111, true, {10, 20, 40, 60}, kOpusMaxBitrate},
-    {kIsacCodecName, 16000, 1, 103, true, {30, 60}, kIsacMaxBitrate},
-    {kIsacCodecName, 32000, 1, 104, true, {30}, kIsacMaxBitrate},
+    {kOpusCodecName, 48000, 2, 111, true, {10, 20, 40, 60}, kOpusMaxBitrateBps},
+    {kIsacCodecName, 16000, 1, 103, true, {30, 60}, kIsacMaxBitrateBps},
+    {kIsacCodecName, 32000, 1, 104, true, {30}, kIsacMaxBitrateBps},
     // G722 should be advertised as 8000 Hz because of the RFC "bug".
     {kG722CodecName, 8000, 1, 9, false, {10, 20, 30, 40, 50, 60}},
     {kIlbcCodecName, 8000, 1, 102, false, {20, 30, 40, 60}},
     {kPcmuCodecName, 8000, 1, 0, false, {10, 20, 30, 40, 50, 60}},
     {kPcmaCodecName, 8000, 1, 8, false, {10, 20, 30, 40, 50, 60}},
     {kCnCodecName, 32000, 1, 106, false, {}},
     {kCnCodecName, 16000, 1, 105, false, {}},
     {kCnCodecName, 8000, 1, 13, false, {}},
-    {kDtmfCodecName, 8000, 1, 126, false, {}}
-};
+    {kDtmfCodecName, 8000, 1, 126, false, {}}};
 
 rtc::Optional<int> ComputeSendBitrate(int max_send_bitrate_bps,
                                       int rtp_max_bitrate_bps,
                                       const webrtc::CodecInst& codec_inst) {
   const int bps = MinPositive(max_send_bitrate_bps, rtp_max_bitrate_bps);
   const int codec_rate = codec_inst.rate;
 
   if (bps <= 0) {
     return rtc::Optional<int>(codec_rate);
   }
@@ skipping 881 matching lines @@
     RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
     if (stream_) {
       call_->DestroyAudioSendStream(stream_);
       stream_ = nullptr;
     }
     RTC_DCHECK(!stream_);
     if (webrtc::field_trial::FindFullName("WebRTC-AdaptAudioBitrate") ==
         "Enabled") {
       // TODO(mflodman): Keep testing this and set proper values.
       // Note: This is an early experiment currently only supported by Opus.
-      config_.min_bitrate_kbps = kOpusMinBitrate;
-      config_.max_bitrate_kbps = kOpusBitrateFb;
+      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 1165 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