Cap the send bitrate for opus and iSAC before passing down to VoE.

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 @@
 // 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;
 
 // Opus bitrate should be in the range between 6000 and 510000.
 const int kOpusMinBitrate = 6000;
 const int kOpusMaxBitrate = 510000;
 
+// iSAC bitrate should be <= 56000.
+const int kIsacMaxBitrate = 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;
 const int kMaxTelephoneEventDuration = 60000;   // Actual limit is 2^16
@@ skipping 202 matching lines @@
     return result;
   }
 
   static bool ToCodecInst(const AudioCodec& in,
                           webrtc::CodecInst* out) {
     for (webrtc::CodecInst voe_codec : webrtc::acm2::RentACodec::Database()) {
       // Change the sample rate of G722 to 8000 to match SDP.
       MaybeFixupG722(&voe_codec, 8000);
       AudioCodec codec(voe_codec.pltype, voe_codec.plname, voe_codec.plfreq,
                        voe_codec.rate, voe_codec.channels);
-      bool multi_rate = IsCodecMultiRate(voe_codec);
+      // This function returns a nonempty value if the codec is multi-rate.
+      bool multi_rate =
+          bool(WebRtcVoiceCodecs::MaxBitrateBpsForMultiRateCodec(voe_codec));
       // Allow arbitrary rates for ISAC to be specified.
       if (multi_rate) {
         // Set codec.bitrate to 0 so the check for codec.Matches() passes.
         codec.bitrate = 0;
       }
       if (codec.Matches(in)) {
         if (out) {
           // Fixup the payload type.
           voe_codec.pltype = in.id;
 
@@ skipping 12 matching lines @@
             voe_codec.rate = (in.bitrate > 0) ? in.bitrate : -1;
           }
           *out = voe_codec;
         }
         return true;
       }
     }
     return false;
   }
 
-  static bool IsCodecMultiRate(const webrtc::CodecInst& codec) {
+  static rtc::Optional<int> MaxBitrateBpsForMultiRateCodec(
+      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].is_multi_rate;
+        return kCodecPrefs[i].max_bitrate_bps;
       }
     }
-    return false;
+    return rtc::Optional<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) ||
@@ skipping 50 matching lines @@
     return nullptr;
   }
 
  private:
   static const int kMaxNumPacketSize = 6;
   struct CodecPref {
     const char* name;
     int clockrate;
     size_t channels;
     int payload_type;
-    bool is_multi_rate;
     int packet_sizes_ms[kMaxNumPacketSize];
+    // Nonempty if it's a multirate codec.

[The Sun (google.com), 2016/04/26 22:18:08]

Ah, what I had in mind was just to make the return type of the combined function
an Optional. I agree that keeping an Optional in CodecPref makes things rather
messy.

You know what, just revert and we'll go with your initial two-function version.

+    rtc::Optional<int> max_bitrate_bps;
   };
   // Note: keep the supported packet sizes in ascending order.
   static const CodecPref kCodecPrefs[12];
 
   static int SelectPacketSize(const CodecPref& codec_pref, int ptime_ms) {
     int selected_packet_size_ms = codec_pref.packet_sizes_ms[0];
     for (int packet_size_ms : codec_pref.packet_sizes_ms) {
       if (packet_size_ms && packet_size_ms <= ptime_ms) {
         selected_packet_size_ms = packet_size_ms;
       }
@@ skipping 46 matching lines @@
       if (codec.id == red_pt) {
         return &codec;
       }
     }
     LOG(LS_WARNING) << "RED params " << red_params << " are invalid.";
     return nullptr;
   }
 };
 
 const WebRtcVoiceCodecs::CodecPref WebRtcVoiceCodecs::kCodecPrefs[12] = {
-  { kOpusCodecName,   48000, 2, 111, true,  { 10, 20, 40, 60 } },
-  { kIsacCodecName,   16000, 1, 103, true,  { 30, 60 } },
-  { kIsacCodecName,   32000, 1, 104, true,  { 30 } },
-  // 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, { } },
-  { kRedCodecName,    8000,  1, 127, false, { } },
-  { kDtmfCodecName,   8000,  1, 126, false, { } },
+    {kOpusCodecName,
+     48000,
+     2,
+     111,
+     {10, 20, 40, 60},
+     rtc::Optional<int>(kOpusMaxBitrate)},
+    {kIsacCodecName,
+     16000,
+     1,
+     103,
+     {30, 60},
+     rtc::Optional<int>(kIsacMaxBitrate)},
+    {kIsacCodecName, 32000, 1, 104, {30}, rtc::Optional<int>(kIsacMaxBitrate)},
+    // G722 should be advertised as 8000 Hz because of the RFC "bug".
+    {kG722CodecName, 8000, 1, 9, {10, 20, 30, 40, 50, 60}},
+    {kIlbcCodecName, 8000, 1, 102, {20, 30, 40, 60}},
+    {kPcmuCodecName, 8000, 1, 0, {10, 20, 30, 40, 50, 60}},
+    {kPcmaCodecName, 8000, 1, 8, {10, 20, 30, 40, 50, 60}},
+    {kCnCodecName, 32000, 1, 106, {}},
+    {kCnCodecName, 16000, 1, 105, {}},
+    {kCnCodecName, 8000, 1, 13, {}},
+    {kRedCodecName, 8000, 1, 127, {}},
+    {kDtmfCodecName, 8000, 1, 126, {}},
 };
 } // namespace {
 
 bool WebRtcVoiceEngine::ToCodecInst(const AudioCodec& in,
                                     webrtc::CodecInst* out) {
   return WebRtcVoiceCodecs::ToCodecInst(in, out);
 }
 
 WebRtcVoiceEngine::WebRtcVoiceEngine(webrtc::AudioDeviceModule* adm)
     : WebRtcVoiceEngine(adm, new VoEWrapper()) {
@@ skipping 850 matching lines @@
   std::vector<webrtc::RtpExtension> filtered_extensions =
       FilterRtpExtensions(params.extensions,
                           webrtc::RtpExtension::IsSupportedForAudio, true);
   if (send_rtp_extensions_ != filtered_extensions) {
     send_rtp_extensions_.swap(filtered_extensions);
     for (auto& it : send_streams_) {
       it.second->RecreateAudioSendStream(send_rtp_extensions_);
     }
   }
 
-  if (!SetSendBitrate(params.max_bandwidth_bps)) {
+  if (!SetMaxSendBitrate(params.max_bandwidth_bps)) {
     return false;
   }
   return SetOptions(params.options);
 }
 
 bool WebRtcVoiceMediaChannel::SetRecvParameters(
     const AudioRecvParameters& params) {
   TRACE_EVENT0("webrtc", "WebRtcVoiceMediaChannel::SetRecvParameters");
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
   LOG(LS_INFO) << "WebRtcVoiceMediaChannel::SetRecvParameters: "
@@ skipping 359 matching lines @@
                    << " Hz on channel "
                    << channel;
       if (engine()->voe()->codec()->SetOpusMaxPlaybackRate(
           channel, send_codec_spec_.opus_max_playback_rate) == -1) {
         LOG_RTCERR2(SetOpusMaxPlaybackRate, channel,
                     send_codec_spec_.opus_max_playback_rate);
         return false;
       }
     }
   }
-  // TODO(solenberg): SetSendBitrate() yields another call to SetSendCodec().
+  // TODO(solenberg): SetMaxSendBitrate() yields another call to SetSendCodec().
   // Check if it is possible to fuse with the previous call in this function.
   SetChannelParameters(channel, rtp_parameters);
 
   // Set the CN payloadtype and the VAD status.
   if (send_codec_spec_.cng_payload_type != -1) {
     // The CN payload type for 8000 Hz clockrate is fixed at 13.
     if (send_codec_spec_.cng_plfreq != 8000) {
       webrtc::PayloadFrequencies cn_freq;
       switch (send_codec_spec_.cng_plfreq) {
         case 16000:
@@ skipping 615 matching lines @@
     }
   }
 
   webrtc::AudioProcessing* ap = engine()->voe()->base()->audio_processing();
   if (ap) {
     ap->set_output_will_be_muted(all_muted);
   }
   return true;
 }
 
-bool WebRtcVoiceMediaChannel::SetSendBitrate(int bps) {
-  LOG(LS_INFO) << "WebRtcVoiceMediaChannel::SetSendBitrate.";
-  send_bitrate_bps_ = bps;
+bool WebRtcVoiceMediaChannel::SetMaxSendBitrate(int bps) {
+  LOG(LS_INFO) << "WebRtcVoiceMediaChannel::SetMaxSendBitrate.";
+  max_send_bitrate_bps_ = bps;
 
   for (const auto& kv : send_streams_) {
     if (!SetChannelParameters(kv.second->channel(),
                               kv.second->rtp_parameters())) {
       return false;
     }
   }
   return true;
 }
 
 bool WebRtcVoiceMediaChannel::SetChannelParameters(
     int channel,
     const webrtc::RtpParameters& parameters) {
   RTC_CHECK_EQ(1UL, parameters.encodings.size());
   // TODO(deadbeef): Handle setting parameters with a list of codecs in a
   // different order (which should change the send codec).
-  return SetSendBitrate(
-      channel,
-      MinPositive(send_bitrate_bps_, parameters.encodings[0].max_bitrate_bps));
+  return SetMaxSendBitrate(
+      channel, MinPositive(max_send_bitrate_bps_,
+                           parameters.encodings[0].max_bitrate_bps));
 }
 
-bool WebRtcVoiceMediaChannel::SetSendBitrate(int channel, int bps) {
+bool WebRtcVoiceMediaChannel::SetMaxSendBitrate(int channel, int bps) {
   // Bitrate is auto by default.
   // TODO(bemasc): Fix this so that if SetMaxSendBandwidth(50) is followed by
   // SetMaxSendBandwith(0), the second call removes the previous limit.
-  if (bps <= 0)
+  if (bps <= 0) {
     return true;
+  }
 
   if (!HasSendCodec()) {
     LOG(LS_INFO) << "The send codec has not been set up yet. "
                  << "The send bitrate setting will be applied later.";
     return true;
   }
 
   webrtc::CodecInst codec = send_codec_spec_.codec_inst;
-  bool is_multi_rate = WebRtcVoiceCodecs::IsCodecMultiRate(codec);
+  // This function returns a nonempty value if the codec is multi-rate.
+  rtc::Optional<int> max_bitrate_bps =
+      WebRtcVoiceCodecs::MaxBitrateBpsForMultiRateCodec(codec);
 
-  if (is_multi_rate) {
+  if (max_bitrate_bps) {
     // If codec is multi-rate then just set the bitrate.
-    codec.rate = bps;
+    codec.rate = std::min(bps, *max_bitrate_bps);
+    LOG(LS_INFO) << "Setting codec " << codec.plname << " to bitrate " << bps
+                 << " bps.";
     if (!SetSendCodec(channel, codec)) {
-      LOG(LS_INFO) << "Failed to set codec " << codec.plname << " to bitrate "
-                   << bps << " bps.";
+      LOG(LS_ERROR) << "Failed to set codec " << codec.plname << " to bitrate "
+                    << bps << " bps.";
       return false;
     }
     return true;
   } else {
     // If codec is not multi-rate and |bps| is less than the fixed bitrate
     // then fail. If codec is not multi-rate and |bps| exceeds or equal the
     // fixed bitrate then ignore.
     if (bps < codec.rate) {
-      LOG(LS_INFO) << "Failed to set codec " << codec.plname
-                   << " to bitrate " << bps << " bps"
-                   << ", requires at least " << codec.rate << " bps.";
+      LOG(LS_ERROR) << "Failed to set codec " << codec.plname << " to bitrate "
+                    << bps << " bps"
+                    << ", requires at least " << codec.rate << " bps.";
       return false;
     }
     return true;
   }
 }
 
 void WebRtcVoiceMediaChannel::OnReadyToSend(bool ready) {
   RTC_DCHECK(worker_thread_checker_.CalledOnValidThread());
   LOG(LS_VERBOSE) << "OnReadyToSend: " << (ready ? "Ready." : "Not ready.");
   call_->SignalChannelNetworkState(
@@ skipping 122 matching lines @@
     }
   } else {
     LOG(LS_INFO) << "Stopping playout for channel #" << channel;
     engine()->voe()->base()->StopPlayout(channel);
   }
   return true;
 }
 }  // namespace cricket
 
 #endif  // HAVE_WEBRTC_VOICE