Let Opus increase complexity for low bitrates

webrtc/modules/audio_coding/codecs/opus/audio_encoder_opus.cc

 /*
  *  Copyright (c) 2014 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 26 matching lines @@
 
 AudioEncoderOpus::Config CreateConfig(const CodecInst& codec_inst) {
   AudioEncoderOpus::Config config;
   config.frame_size_ms = rtc::CheckedDivExact(codec_inst.pacsize, 48);
   config.num_channels = codec_inst.channels;
   config.bitrate_bps = rtc::Optional<int>(codec_inst.rate);
   config.payload_type = codec_inst.pltype;
   config.application = config.num_channels == 1 ? AudioEncoderOpus::kVoip
                                                 : AudioEncoderOpus::kAudio;
   config.supported_frame_lengths_ms.push_back(config.frame_size_ms);
+#if WEBRTC_OPUS_VARIABLE_COMPLEXITY
+  config.low_rate_complexity = 9;
+#endif
   return config;
 }
 
 // Optimize the loss rate to configure Opus. Basically, optimized loss rate is
 // the input loss rate rounded down to various levels, because a robustly good
 // audio quality is achieved by lowering the packet loss down.
 // Additionally, to prevent toggling, margins are used, i.e., when jumping to
 // a loss rate from below, a higher threshold is used than jumping to the same
 // level from above.
 double OptimizePacketLossRate(double new_loss_rate, double old_loss_rate) {
@@ skipping 54 matching lines @@
   }
 
  private:
   const Clock* const clock_;
   int64_t last_sample_time_ms_;
 
   // An exponential filter is used to smooth the packet loss fraction.
   rtc::ExpFilter smoother_;
 };
 
-AudioEncoderOpus::Config::Config() = default;
+AudioEncoderOpus::Config::Config() {
+#if WEBRTC_OPUS_VARIABLE_COMPLEXITY
+  low_rate_complexity = 9;
+#endif
+}
 AudioEncoderOpus::Config::Config(const Config&) = default;
 AudioEncoderOpus::Config::~Config() = default;
 auto AudioEncoderOpus::Config::operator=(const Config&) -> Config& = default;
 
 bool AudioEncoderOpus::Config::IsOk() const {
   if (frame_size_ms <= 0 || frame_size_ms % 10 != 0)
     return false;
   if (num_channels != 1 && num_channels != 2)
     return false;
   if (bitrate_bps &&
       (*bitrate_bps < kMinBitrateBps || *bitrate_bps > kMaxBitrateBps))
     return false;
   if (complexity < 0 || complexity > 10)
     return false;
+  if (low_rate_complexity < 0 || low_rate_complexity > 10)
+    return false;
   return true;
 }
 
 int AudioEncoderOpus::Config::GetBitrateBps() const {
   RTC_DCHECK(IsOk());
   if (bitrate_bps)
     return *bitrate_bps;  // Explicitly set value.
   else
     return num_channels == 1 ? 32000 : 64000;  // Default value.
 }
 
+int AudioEncoderOpus::Config::GetComplexity() const {
+  RTC_DCHECK(IsOk());
+  return GetBitrateBps() <= complexity_threshold_bps ? low_rate_complexity
+                                                     : complexity;
+}
+
 AudioEncoderOpus::AudioEncoderOpus(
     const Config& config,
     AudioNetworkAdaptorCreator&& audio_network_adaptor_creator)
     : packet_loss_rate_(0.0),
       inst_(nullptr),
       packet_loss_fraction_smoother_(new PacketLossFractionSmoother(
           config.clock ? config.clock : Clock::GetRealTimeClock())),
       audio_network_adaptor_creator_(
           audio_network_adaptor_creator
               ? std::move(audio_network_adaptor_creator)
@@ skipping 86 matching lines @@
         0, WebRtcOpus_SetPacketLossRate(
                inst_, static_cast<int32_t>(packet_loss_rate_ * 100 + .5)));
   }
 }
 
 void AudioEncoderOpus::SetTargetBitrate(int bits_per_second) {
   config_.bitrate_bps = rtc::Optional<int>(
       std::max(std::min(bits_per_second, kMaxBitrateBps), kMinBitrateBps));
   RTC_DCHECK(config_.IsOk());
   RTC_CHECK_EQ(0, WebRtcOpus_SetBitRate(inst_, config_.GetBitrateBps()));
+  if (complexity_ != config_.GetComplexity()) {
+    complexity_ = config_.GetComplexity();
+    RTC_CHECK_EQ(0, WebRtcOpus_SetComplexity(inst_, complexity_));
+  }
 }
 
 bool AudioEncoderOpus::EnableAudioNetworkAdaptor(
     const std::string& config_string,
     const Clock* clock) {
   audio_network_adaptor_ = audio_network_adaptor_creator_(config_string, clock);
   return audio_network_adaptor_.get() != nullptr;
 }
 
 void AudioEncoderOpus::DisableAudioNetworkAdaptor() {
@@ skipping 129 matching lines @@
   RTC_CHECK_EQ(0, WebRtcOpus_EncoderCreate(&inst_, config.num_channels,
                                            config.application));
   RTC_CHECK_EQ(0, WebRtcOpus_SetBitRate(inst_, config.GetBitrateBps()));
   if (config.fec_enabled) {
     RTC_CHECK_EQ(0, WebRtcOpus_EnableFec(inst_));
   } else {
     RTC_CHECK_EQ(0, WebRtcOpus_DisableFec(inst_));
   }
   RTC_CHECK_EQ(
       0, WebRtcOpus_SetMaxPlaybackRate(inst_, config.max_playback_rate_hz));
-  RTC_CHECK_EQ(0, WebRtcOpus_SetComplexity(inst_, config.complexity));
+  complexity_ = config.GetComplexity();
+  RTC_CHECK_EQ(0, WebRtcOpus_SetComplexity(inst_, complexity_));
   if (config.dtx_enabled) {
     RTC_CHECK_EQ(0, WebRtcOpus_EnableDtx(inst_));
   } else {
     RTC_CHECK_EQ(0, WebRtcOpus_DisableDtx(inst_));
   }
   RTC_CHECK_EQ(0,
                WebRtcOpus_SetPacketLossRate(
                    inst_, static_cast<int32_t>(packet_loss_rate_ * 100 + .5)));
   config_ = config;
 
@@ skipping 45 matching lines @@
   AudioNetworkAdaptorImpl::Config config;
   config.clock = clock;
   return std::unique_ptr<AudioNetworkAdaptor>(new AudioNetworkAdaptorImpl(
       config, ControllerManagerImpl::Create(
                   config_string, NumChannels(), supported_frame_lengths_ms(),
                   num_channels_to_encode_, next_frame_length_ms_,
                   GetTargetBitrate(), config_.fec_enabled, GetDtx(), clock)));
 }
 
 }  // namespace webrtc