Revert of Opus implementation of the AudioEncoderFactoryTemplate API

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 30 matching lines @@
 // 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.
 constexpr int kOpusBitrateNbBps = 12000;
 constexpr int kOpusBitrateWbBps = 20000;
 constexpr int kOpusBitrateFbBps = 32000;
 
+// Opus API allows a min bitrate of 500bps, but Opus documentation suggests
+// bitrate should be in the range of 6000 to 510000, inclusive.
+constexpr int kOpusMinBitrateBps = 6000;
+constexpr int kOpusMaxBitrateBps = 510000;
+
 constexpr int kSampleRateHz = 48000;
 constexpr int kDefaultMaxPlaybackRate = 48000;
 
 // These two lists must be sorted from low to high
 #if WEBRTC_OPUS_SUPPORT_120MS_PTIME
 constexpr int kANASupportedFrameLengths[] = {20, 60, 120};
 constexpr int kOpusSupportedFrameLengths[] = {10, 20, 40, 60, 120};
 #else
 constexpr int kANASupportedFrameLengths[] = {20, 60};
 constexpr int kOpusSupportedFrameLengths[] = {10, 20, 40, 60};
@@ skipping 60 matching lines @@
 int CalculateDefaultBitrate(int max_playback_rate, size_t num_channels) {
   const int bitrate = [&] {
     if (max_playback_rate <= 8000) {
       return kOpusBitrateNbBps * rtc::dchecked_cast<int>(num_channels);
     } else if (max_playback_rate <= 16000) {
       return kOpusBitrateWbBps * rtc::dchecked_cast<int>(num_channels);
     } else {
       return kOpusBitrateFbBps * rtc::dchecked_cast<int>(num_channels);
     }
   }();
-  RTC_DCHECK_GE(bitrate, AudioEncoderOpusConfig::kMinBitrateBps);
-  RTC_DCHECK_LE(bitrate, AudioEncoderOpusConfig::kMaxBitrateBps);
+  RTC_DCHECK_GE(bitrate, kOpusMinBitrateBps);
+  RTC_DCHECK_LE(bitrate, kOpusMaxBitrateBps);
   return bitrate;
 }
 
 // Get the maxaveragebitrate parameter in string-form, so we can properly figure
 // out how invalid it is and accurately log invalid values.
 int CalculateBitrate(int max_playback_rate_hz,
                      size_t num_channels,
                      rtc::Optional<std::string> bitrate_param) {
   const int default_bitrate =
       CalculateDefaultBitrate(max_playback_rate_hz, num_channels);
 
   if (bitrate_param) {
     const auto bitrate = rtc::StringToNumber<int>(*bitrate_param);
     if (bitrate) {
       const int chosen_bitrate =
-          std::max(AudioEncoderOpusConfig::kMinBitrateBps,
-                   std::min(*bitrate, AudioEncoderOpusConfig::kMaxBitrateBps));
+          std::max(kOpusMinBitrateBps, std::min(*bitrate, kOpusMaxBitrateBps));
       if (bitrate != chosen_bitrate) {
         LOG(LS_WARNING) << "Invalid maxaveragebitrate " << *bitrate
                         << " clamped to " << chosen_bitrate;
       }
       return chosen_bitrate;
     }
     LOG(LS_WARNING) << "Invalid maxaveragebitrate \"" << *bitrate_param
                     << "\" replaced by default bitrate " << default_bitrate;
   }
 
@@ skipping 24 matching lines @@
     // kOpusSupportedFrameLengths.
     for (const int supported_frame_length : kOpusSupportedFrameLengths) {
       if (supported_frame_length >= *ptime) {
         return supported_frame_length;
       }
     }
     // If none was found, return the largest supported frame length.
     return *(std::end(kOpusSupportedFrameLengths) - 1);
   }
 
-  return AudioEncoderOpusConfig::kDefaultFrameSizeMs;
+  return AudioEncoderOpus::Config::kDefaultFrameSizeMs;
 }
 
 void FindSupportedFrameLengths(int min_frame_length_ms,
                                int max_frame_length_ms,
                                std::vector<int>* out) {
   out->clear();
   std::copy_if(std::begin(kANASupportedFrameLengths),
                std::end(kANASupportedFrameLengths), std::back_inserter(*out),
                [&](int frame_length_ms) {
                  return frame_length_ms >= min_frame_length_ms &&
                         frame_length_ms <= max_frame_length_ms;
                });
   RTC_DCHECK(std::is_sorted(out->begin(), out->end()));
 }
 
-int GetBitrateBps(const AudioEncoderOpusConfig& config) {
-  RTC_DCHECK(config.IsOk());
-  return config.bitrate_bps;
-}
-
 }  // namespace
 
-rtc::Optional<AudioCodecInfo> AudioEncoderOpusImpl::QueryAudioEncoder(
+rtc::Optional<AudioCodecInfo> AudioEncoderOpus::QueryAudioEncoder(
     const SdpAudioFormat& format) {
   if (STR_CASE_CMP(format.name.c_str(), GetPayloadName()) == 0 &&
       format.clockrate_hz == 48000 && format.num_channels == 2) {
     const size_t num_channels = GetChannelCount(format);
     const int bitrate =
         CalculateBitrate(GetMaxPlaybackRate(format), num_channels,
                          GetFormatParameter(format, "maxaveragebitrate"));
-    AudioCodecInfo info(48000, num_channels, bitrate,
-                        AudioEncoderOpusConfig::kMinBitrateBps,
-                        AudioEncoderOpusConfig::kMaxBitrateBps);
+    AudioCodecInfo info(48000, num_channels, bitrate, kOpusMinBitrateBps,
+                        kOpusMaxBitrateBps);
     info.allow_comfort_noise = false;
     info.supports_network_adaption = true;
 
     return rtc::Optional<AudioCodecInfo>(info);
   }
   return rtc::Optional<AudioCodecInfo>();
 }
 
-AudioEncoderOpusConfig AudioEncoderOpusImpl::CreateConfig(
+AudioEncoderOpus::Config AudioEncoderOpus::CreateConfig(
     const CodecInst& codec_inst) {
-  AudioEncoderOpusConfig config;
+  AudioEncoderOpus::Config config;
   config.frame_size_ms = rtc::CheckedDivExact(codec_inst.pacsize, 48);
   config.num_channels = codec_inst.channels;
-  config.bitrate_bps = codec_inst.rate;
-  config.application = config.num_channels == 1
-                           ? AudioEncoderOpusConfig::ApplicationMode::kVoip
-                           : AudioEncoderOpusConfig::ApplicationMode::kAudio;
+  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;
 }
 
-rtc::Optional<AudioEncoderOpusConfig> AudioEncoderOpusImpl::SdpToConfig(
+AudioEncoderOpus::Config AudioEncoderOpus::CreateConfig(
+    int payload_type,
     const SdpAudioFormat& format) {
-  if (STR_CASE_CMP(format.name.c_str(), "opus") != 0 ||
-      format.clockrate_hz != 48000 || format.num_channels != 2) {
-    return rtc::Optional<AudioEncoderOpusConfig>();
-  }
+  AudioEncoderOpus::Config config;
 
-  AudioEncoderOpusConfig config;
   config.num_channels = GetChannelCount(format);
   config.frame_size_ms = GetFrameSizeMs(format);
   config.max_playback_rate_hz = GetMaxPlaybackRate(format);
   config.fec_enabled = (GetFormatParameter(format, "useinbandfec") == "1");
   config.dtx_enabled = (GetFormatParameter(format, "usedtx") == "1");
   config.cbr_enabled = (GetFormatParameter(format, "cbr") == "1");
-  config.bitrate_bps =
+  config.bitrate_bps = rtc::Optional<int>(
       CalculateBitrate(config.max_playback_rate_hz, config.num_channels,
-                       GetFormatParameter(format, "maxaveragebitrate"));
-  config.application = config.num_channels == 1
-                           ? AudioEncoderOpusConfig::ApplicationMode::kVoip
-                           : AudioEncoderOpusConfig::ApplicationMode::kAudio;
+                       GetFormatParameter(format, "maxaveragebitrate")));
+  config.payload_type = payload_type;
+  config.application = config.num_channels == 1 ? AudioEncoderOpus::kVoip
+                                                : AudioEncoderOpus::kAudio;
+#if WEBRTC_OPUS_VARIABLE_COMPLEXITY
+  config.low_rate_complexity = 9;
+#endif
 
   constexpr int kMinANAFrameLength = kANASupportedFrameLengths[0];
   constexpr int kMaxANAFrameLength =
       kANASupportedFrameLengths[arraysize(kANASupportedFrameLengths) - 1];
-
   // For now, minptime and maxptime are only used with ANA. If ptime is outside
   // of this range, it will get adjusted once ANA takes hold. Ideally, we'd know
   // if ANA was to be used when setting up the config, and adjust accordingly.
   const int min_frame_length_ms =
       GetFormatParameter<int>(format, "minptime").value_or(kMinANAFrameLength);
   const int max_frame_length_ms =
       GetFormatParameter<int>(format, "maxptime").value_or(kMaxANAFrameLength);
 
   FindSupportedFrameLengths(min_frame_length_ms, max_frame_length_ms,
                             &config.supported_frame_lengths_ms);
-  RTC_DCHECK(config.IsOk());
-  return rtc::Optional<AudioEncoderOpusConfig>(config);
+  return config;
 }
 
-rtc::Optional<int> AudioEncoderOpusImpl::GetNewComplexity(
-    const AudioEncoderOpusConfig& config) {
-  RTC_DCHECK(config.IsOk());
-  const int bitrate_bps = GetBitrateBps(config);
-  if (bitrate_bps >= config.complexity_threshold_bps -
-                         config.complexity_threshold_window_bps &&
-      bitrate_bps <= config.complexity_threshold_bps +
-                         config.complexity_threshold_window_bps) {
-    // Within the hysteresis window; make no change.
-    return rtc::Optional<int>();
-  } else {
-    return rtc::Optional<int>(bitrate_bps <= config.complexity_threshold_bps
-                                  ? config.low_rate_complexity
-                                  : config.complexity);
-  }
-}
-
-class AudioEncoderOpusImpl::PacketLossFractionSmoother {
+class AudioEncoderOpus::PacketLossFractionSmoother {
  public:
   explicit PacketLossFractionSmoother()
       : last_sample_time_ms_(rtc::TimeMillis()),
         smoother_(kAlphaForPacketLossFractionSmoother) {}
 
   // Gets the smoothed packet loss fraction.
   float GetAverage() const {
     float value = smoother_.filtered();
     return (value == rtc::ExpFilter::kValueUndefined) ? 0.0f : value;
   }
 
   // Add new observation to the packet loss fraction smoother.
   void AddSample(float packet_loss_fraction) {
     int64_t now_ms = rtc::TimeMillis();
     smoother_.Apply(static_cast<float>(now_ms - last_sample_time_ms_),
                     packet_loss_fraction);
     last_sample_time_ms_ = now_ms;
   }
 
  private:
   int64_t last_sample_time_ms_;
 
   // An exponential filter is used to smooth the packet loss fraction.
   rtc::ExpFilter smoother_;
 };
 
-AudioEncoderOpusImpl::AudioEncoderOpusImpl(
-    const AudioEncoderOpusConfig& config,
-    int payload_type,
+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 < kOpusMinBitrateBps || *bitrate_bps > kOpusMaxBitrateBps))
+    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.
+}
+
+rtc::Optional<int> AudioEncoderOpus::Config::GetNewComplexity() const {
+  RTC_DCHECK(IsOk());
+  const int bitrate_bps = GetBitrateBps();
+  if (bitrate_bps >=
+          complexity_threshold_bps - complexity_threshold_window_bps &&
+      bitrate_bps <=
+          complexity_threshold_bps + complexity_threshold_window_bps) {
+    // Within the hysteresis window; make no change.
+    return rtc::Optional<int>();
+  }
+  return bitrate_bps <= complexity_threshold_bps
+             ? rtc::Optional<int>(low_rate_complexity)
+             : rtc::Optional<int>(complexity);
+}
+
+AudioEncoderOpus::AudioEncoderOpus(
+    const Config& config,
     AudioNetworkAdaptorCreator&& audio_network_adaptor_creator,
     std::unique_ptr<SmoothingFilter> bitrate_smoother)
-    : payload_type_(payload_type),
-      send_side_bwe_with_overhead_(webrtc::field_trial::IsEnabled(
+    : send_side_bwe_with_overhead_(webrtc::field_trial::IsEnabled(
           "WebRTC-SendSideBwe-WithOverhead")),
       packet_loss_rate_(0.0),
       inst_(nullptr),
       packet_loss_fraction_smoother_(new PacketLossFractionSmoother()),
       audio_network_adaptor_creator_(
           audio_network_adaptor_creator
               ? std::move(audio_network_adaptor_creator)
               : [this](const ProtoString& config_string,
                        RtcEventLog* event_log) {
                   return DefaultAudioNetworkAdaptorCreator(config_string,
                                                            event_log);
               }),
       bitrate_smoother_(bitrate_smoother
           ? std::move(bitrate_smoother) : std::unique_ptr<SmoothingFilter>(
               // We choose 5sec as initial time constant due to empirical data.
               new SmoothingFilterImpl(5000))) {
   RTC_CHECK(RecreateEncoderInstance(config));
 }
 
-AudioEncoderOpusImpl::AudioEncoderOpusImpl(const CodecInst& codec_inst)
-    : AudioEncoderOpusImpl(CreateConfig(codec_inst), codec_inst.pltype) {}
+AudioEncoderOpus::AudioEncoderOpus(const CodecInst& codec_inst)
+    : AudioEncoderOpus(CreateConfig(codec_inst), nullptr) {}
 
-AudioEncoderOpusImpl::AudioEncoderOpusImpl(int payload_type,
-                                           const SdpAudioFormat& format)
-    : AudioEncoderOpusImpl(*SdpToConfig(format), payload_type) {}
+AudioEncoderOpus::AudioEncoderOpus(int payload_type,
+                                   const SdpAudioFormat& format)
+    : AudioEncoderOpus(CreateConfig(payload_type, format), nullptr) {}
 
-AudioEncoderOpusImpl::~AudioEncoderOpusImpl() {
+AudioEncoderOpus::~AudioEncoderOpus() {
   RTC_CHECK_EQ(0, WebRtcOpus_EncoderFree(inst_));
 }
 
-int AudioEncoderOpusImpl::SampleRateHz() const {
+int AudioEncoderOpus::SampleRateHz() const {
   return kSampleRateHz;
 }
 
-size_t AudioEncoderOpusImpl::NumChannels() const {
+size_t AudioEncoderOpus::NumChannels() const {
   return config_.num_channels;
 }
 
-size_t AudioEncoderOpusImpl::Num10MsFramesInNextPacket() const {
+size_t AudioEncoderOpus::Num10MsFramesInNextPacket() const {
   return Num10msFramesPerPacket();
 }
 
-size_t AudioEncoderOpusImpl::Max10MsFramesInAPacket() const {
+size_t AudioEncoderOpus::Max10MsFramesInAPacket() const {
   return Num10msFramesPerPacket();
 }
 
-int AudioEncoderOpusImpl::GetTargetBitrate() const {
-  return GetBitrateBps(config_);
+int AudioEncoderOpus::GetTargetBitrate() const {
+  return config_.GetBitrateBps();
 }
 
-void AudioEncoderOpusImpl::Reset() {
+void AudioEncoderOpus::Reset() {
   RTC_CHECK(RecreateEncoderInstance(config_));
 }
 
-bool AudioEncoderOpusImpl::SetFec(bool enable) {
+bool AudioEncoderOpus::SetFec(bool enable) {
   if (enable) {
     RTC_CHECK_EQ(0, WebRtcOpus_EnableFec(inst_));
   } else {
     RTC_CHECK_EQ(0, WebRtcOpus_DisableFec(inst_));
   }
   config_.fec_enabled = enable;
   return true;
 }
 
-bool AudioEncoderOpusImpl::SetDtx(bool enable) {
+bool AudioEncoderOpus::SetDtx(bool enable) {
   if (enable) {
     RTC_CHECK_EQ(0, WebRtcOpus_EnableDtx(inst_));
   } else {
     RTC_CHECK_EQ(0, WebRtcOpus_DisableDtx(inst_));
   }
   config_.dtx_enabled = enable;
   return true;
 }
 
-bool AudioEncoderOpusImpl::GetDtx() const {
+bool AudioEncoderOpus::GetDtx() const {
   return config_.dtx_enabled;
 }
 
-bool AudioEncoderOpusImpl::SetApplication(Application application) {
+bool AudioEncoderOpus::SetApplication(Application application) {
   auto conf = config_;
   switch (application) {
     case Application::kSpeech:
-      conf.application = AudioEncoderOpusConfig::ApplicationMode::kVoip;
+      conf.application = AudioEncoderOpus::kVoip;
       break;
     case Application::kAudio:
-      conf.application = AudioEncoderOpusConfig::ApplicationMode::kAudio;
+      conf.application = AudioEncoderOpus::kAudio;
       break;
   }
   return RecreateEncoderInstance(conf);
 }
 
-void AudioEncoderOpusImpl::SetMaxPlaybackRate(int frequency_hz) {
+void AudioEncoderOpus::SetMaxPlaybackRate(int frequency_hz) {
   auto conf = config_;
   conf.max_playback_rate_hz = frequency_hz;
   RTC_CHECK(RecreateEncoderInstance(conf));
 }
 
-bool AudioEncoderOpusImpl::EnableAudioNetworkAdaptor(
+bool AudioEncoderOpus::EnableAudioNetworkAdaptor(
     const std::string& config_string,
     RtcEventLog* event_log) {
   audio_network_adaptor_ =
       audio_network_adaptor_creator_(config_string, event_log);
   return audio_network_adaptor_.get() != nullptr;
 }
 
-void AudioEncoderOpusImpl::DisableAudioNetworkAdaptor() {
+void AudioEncoderOpus::DisableAudioNetworkAdaptor() {
   audio_network_adaptor_.reset(nullptr);
 }
 
-void AudioEncoderOpusImpl::OnReceivedUplinkPacketLossFraction(
+void AudioEncoderOpus::OnReceivedUplinkPacketLossFraction(
     float uplink_packet_loss_fraction) {
   if (!audio_network_adaptor_) {
     packet_loss_fraction_smoother_->AddSample(uplink_packet_loss_fraction);
     float average_fraction_loss = packet_loss_fraction_smoother_->GetAverage();
     return SetProjectedPacketLossRate(average_fraction_loss);
   }
   audio_network_adaptor_->SetUplinkPacketLossFraction(
       uplink_packet_loss_fraction);
   ApplyAudioNetworkAdaptor();
 }
 
-void AudioEncoderOpusImpl::OnReceivedUplinkRecoverablePacketLossFraction(
+void AudioEncoderOpus::OnReceivedUplinkRecoverablePacketLossFraction(
     float uplink_recoverable_packet_loss_fraction) {
   if (!audio_network_adaptor_)
     return;
   audio_network_adaptor_->SetUplinkRecoverablePacketLossFraction(
       uplink_recoverable_packet_loss_fraction);
   ApplyAudioNetworkAdaptor();
 }
 
-void AudioEncoderOpusImpl::OnReceivedUplinkBandwidth(
+void AudioEncoderOpus::OnReceivedUplinkBandwidth(
     int target_audio_bitrate_bps,
     rtc::Optional<int64_t> probing_interval_ms) {
   if (audio_network_adaptor_) {
     audio_network_adaptor_->SetTargetAudioBitrate(target_audio_bitrate_bps);
     // We give smoothed bitrate allocation to audio network adaptor as
     // the uplink bandwidth.
     // The probing spikes should not affect the bitrate smoother more than 25%.
     // To simplify the calculations we use a step response as input signal.
     // The step response of an exponential filter is
     // u(t) = 1 - e^(-t / time_constant).
     // In order to limit the affect of a BWE spike within 25% of its value
     // before
     // the next probing, we would choose a time constant that fulfills
     // 1 - e^(-probing_interval_ms / time_constant) < 0.25
     // Then 4 * probing_interval_ms is a good choice.
     if (probing_interval_ms)
       bitrate_smoother_->SetTimeConstantMs(*probing_interval_ms * 4);
     bitrate_smoother_->AddSample(target_audio_bitrate_bps);
 
     ApplyAudioNetworkAdaptor();
   } else if (send_side_bwe_with_overhead_) {
     if (!overhead_bytes_per_packet_) {
       LOG(LS_INFO)
-          << "AudioEncoderOpusImpl: Overhead unknown, target audio bitrate "
+          << "AudioEncoderOpus: Overhead unknown, target audio bitrate "
           << target_audio_bitrate_bps << " bps is ignored.";
       return;
     }
     const int overhead_bps = static_cast<int>(
         *overhead_bytes_per_packet_ * 8 * 100 / Num10MsFramesInNextPacket());
-    SetTargetBitrate(
-        std::min(AudioEncoderOpusConfig::kMaxBitrateBps,
-                 std::max(AudioEncoderOpusConfig::kMinBitrateBps,
-                          target_audio_bitrate_bps - overhead_bps)));
+    SetTargetBitrate(std::min(
+        kOpusMaxBitrateBps,
+        std::max(kOpusMinBitrateBps, target_audio_bitrate_bps - overhead_bps)));
   } else {
     SetTargetBitrate(target_audio_bitrate_bps);
   }
 }
 
-void AudioEncoderOpusImpl::OnReceivedRtt(int rtt_ms) {
+void AudioEncoderOpus::OnReceivedRtt(int rtt_ms) {
   if (!audio_network_adaptor_)
     return;
   audio_network_adaptor_->SetRtt(rtt_ms);
   ApplyAudioNetworkAdaptor();
 }
 
-void AudioEncoderOpusImpl::OnReceivedOverhead(
-    size_t overhead_bytes_per_packet) {
+void AudioEncoderOpus::OnReceivedOverhead(size_t overhead_bytes_per_packet) {
   if (audio_network_adaptor_) {
     audio_network_adaptor_->SetOverhead(overhead_bytes_per_packet);
     ApplyAudioNetworkAdaptor();
   } else {
     overhead_bytes_per_packet_ =
         rtc::Optional<size_t>(overhead_bytes_per_packet);
   }
 }
 
-void AudioEncoderOpusImpl::SetReceiverFrameLengthRange(
-    int min_frame_length_ms,
-    int max_frame_length_ms) {
+void AudioEncoderOpus::SetReceiverFrameLengthRange(int min_frame_length_ms,
+                                                   int max_frame_length_ms) {
   // Ensure that |SetReceiverFrameLengthRange| is called before
   // |EnableAudioNetworkAdaptor|, otherwise we need to recreate
   // |audio_network_adaptor_|, which is not a needed use case.
   RTC_DCHECK(!audio_network_adaptor_);
   FindSupportedFrameLengths(min_frame_length_ms, max_frame_length_ms,
                             &config_.supported_frame_lengths_ms);
 }
 
-AudioEncoder::EncodedInfo AudioEncoderOpusImpl::EncodeImpl(
+AudioEncoder::EncodedInfo AudioEncoderOpus::EncodeImpl(
     uint32_t rtp_timestamp,
     rtc::ArrayView<const int16_t> audio,
     rtc::Buffer* encoded) {
   MaybeUpdateUplinkBandwidth();
 
   if (input_buffer_.empty())
     first_timestamp_in_buffer_ = rtp_timestamp;
 
   input_buffer_.insert(input_buffer_.end(), audio.cbegin(), audio.cend());
   if (input_buffer_.size() <
@@ skipping 18 matching lines @@
             RTC_CHECK_GE(status, 0);  // Fails only if fed invalid data.
 
             return static_cast<size_t>(status);
           });
   input_buffer_.clear();
 
   // Will use new packet size for next encoding.
   config_.frame_size_ms = next_frame_length_ms_;
 
   info.encoded_timestamp = first_timestamp_in_buffer_;
-  info.payload_type = payload_type_;
+  info.payload_type = config_.payload_type;
   info.send_even_if_empty = true;  // Allows Opus to send empty packets.
   info.speech = (info.encoded_bytes > 0);
   info.encoder_type = CodecType::kOpus;
   return info;
 }
 
-size_t AudioEncoderOpusImpl::Num10msFramesPerPacket() const {
+size_t AudioEncoderOpus::Num10msFramesPerPacket() const {
   return static_cast<size_t>(rtc::CheckedDivExact(config_.frame_size_ms, 10));
 }
 
-size_t AudioEncoderOpusImpl::SamplesPer10msFrame() const {
+size_t AudioEncoderOpus::SamplesPer10msFrame() const {
   return rtc::CheckedDivExact(kSampleRateHz, 100) * config_.num_channels;
 }
 
-size_t AudioEncoderOpusImpl::SufficientOutputBufferSize() const {
+size_t AudioEncoderOpus::SufficientOutputBufferSize() const {
   // Calculate the number of bytes we expect the encoder to produce,
   // then multiply by two to give a wide margin for error.
   const size_t bytes_per_millisecond =
-      static_cast<size_t>(GetBitrateBps(config_) / (1000 * 8) + 1);
+      static_cast<size_t>(config_.GetBitrateBps() / (1000 * 8) + 1);
   const size_t approx_encoded_bytes =
       Num10msFramesPerPacket() * 10 * bytes_per_millisecond;
   return 2 * approx_encoded_bytes;
 }
 
 // If the given config is OK, recreate the Opus encoder instance with those
 // settings, save the config, and return true. Otherwise, do nothing and return
 // false.
-bool AudioEncoderOpusImpl::RecreateEncoderInstance(
-    const AudioEncoderOpusConfig& config) {
+bool AudioEncoderOpus::RecreateEncoderInstance(const Config& config) {
   if (!config.IsOk())
     return false;
   config_ = config;
   if (inst_)
     RTC_CHECK_EQ(0, WebRtcOpus_EncoderFree(inst_));
   input_buffer_.clear();
   input_buffer_.reserve(Num10msFramesPerPacket() * SamplesPer10msFrame());
-  RTC_CHECK_EQ(0, WebRtcOpus_EncoderCreate(
-                      &inst_, config.num_channels,
-                      config.application ==
-                              AudioEncoderOpusConfig::ApplicationMode::kVoip
-                          ? 0
-                          : 1));
-  RTC_CHECK_EQ(0, WebRtcOpus_SetBitRate(inst_, GetBitrateBps(config)));
+  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));
   // Use the default complexity if the start bitrate is within the hysteresis
   // window.
-  complexity_ = GetNewComplexity(config).value_or(config.complexity);
+  complexity_ = config.GetNewComplexity().value_or(config.complexity);
   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)));
   if (config.cbr_enabled) {
     RTC_CHECK_EQ(0, WebRtcOpus_EnableCbr(inst_));
   } else {
     RTC_CHECK_EQ(0, WebRtcOpus_DisableCbr(inst_));
   }
   num_channels_to_encode_ = NumChannels();
   next_frame_length_ms_ = config_.frame_size_ms;
   return true;
 }
 
-void AudioEncoderOpusImpl::SetFrameLength(int frame_length_ms) {
+void AudioEncoderOpus::SetFrameLength(int frame_length_ms) {
   next_frame_length_ms_ = frame_length_ms;
 }
 
-void AudioEncoderOpusImpl::SetNumChannelsToEncode(
-    size_t num_channels_to_encode) {
+void AudioEncoderOpus::SetNumChannelsToEncode(size_t num_channels_to_encode) {
   RTC_DCHECK_GT(num_channels_to_encode, 0);
   RTC_DCHECK_LE(num_channels_to_encode, config_.num_channels);
 
   if (num_channels_to_encode_ == num_channels_to_encode)
     return;
 
   RTC_CHECK_EQ(0, WebRtcOpus_SetForceChannels(inst_, num_channels_to_encode));
   num_channels_to_encode_ = num_channels_to_encode;
 }
 
-void AudioEncoderOpusImpl::SetProjectedPacketLossRate(float fraction) {
+void AudioEncoderOpus::SetProjectedPacketLossRate(float fraction) {
   float opt_loss_rate = OptimizePacketLossRate(fraction, packet_loss_rate_);
   if (packet_loss_rate_ != opt_loss_rate) {
     packet_loss_rate_ = opt_loss_rate;
     RTC_CHECK_EQ(
         0, WebRtcOpus_SetPacketLossRate(
                inst_, static_cast<int32_t>(packet_loss_rate_ * 100 + .5)));
   }
 }
 
-void AudioEncoderOpusImpl::SetTargetBitrate(int bits_per_second) {
-  config_.bitrate_bps = rtc::SafeClamp<int>(
-      bits_per_second, AudioEncoderOpusConfig::kMinBitrateBps,
-      AudioEncoderOpusConfig::kMaxBitrateBps);
+void AudioEncoderOpus::SetTargetBitrate(int bits_per_second) {
+  config_.bitrate_bps = rtc::Optional<int>(rtc::SafeClamp<int>(
+      bits_per_second, kOpusMinBitrateBps, kOpusMaxBitrateBps));
   RTC_DCHECK(config_.IsOk());
-  RTC_CHECK_EQ(0, WebRtcOpus_SetBitRate(inst_, GetBitrateBps(config_)));
-  const auto new_complexity = GetNewComplexity(config_);
+  RTC_CHECK_EQ(0, WebRtcOpus_SetBitRate(inst_, config_.GetBitrateBps()));
+  const auto new_complexity = config_.GetNewComplexity();
   if (new_complexity && complexity_ != *new_complexity) {
     complexity_ = *new_complexity;
     RTC_CHECK_EQ(0, WebRtcOpus_SetComplexity(inst_, complexity_));
   }
 }
 
-void AudioEncoderOpusImpl::ApplyAudioNetworkAdaptor() {
+void AudioEncoderOpus::ApplyAudioNetworkAdaptor() {
   auto config = audio_network_adaptor_->GetEncoderRuntimeConfig();
   RTC_DCHECK(!config.frame_length_ms || *config.frame_length_ms == 20 ||
              *config.frame_length_ms == 60);
 
   if (config.bitrate_bps)
     SetTargetBitrate(*config.bitrate_bps);
   if (config.frame_length_ms)
     SetFrameLength(*config.frame_length_ms);
   if (config.enable_fec)
     SetFec(*config.enable_fec);
   if (config.uplink_packet_loss_fraction)
     SetProjectedPacketLossRate(*config.uplink_packet_loss_fraction);
   if (config.enable_dtx)
     SetDtx(*config.enable_dtx);
   if (config.num_channels)
     SetNumChannelsToEncode(*config.num_channels);
 }
 
 std::unique_ptr<AudioNetworkAdaptor>
-AudioEncoderOpusImpl::DefaultAudioNetworkAdaptorCreator(
+AudioEncoderOpus::DefaultAudioNetworkAdaptorCreator(
     const ProtoString& config_string,
     RtcEventLog* event_log) const {
   AudioNetworkAdaptorImpl::Config config;
   config.event_log = event_log;
   return std::unique_ptr<AudioNetworkAdaptor>(new AudioNetworkAdaptorImpl(
-      config, ControllerManagerImpl::Create(
-                  config_string, NumChannels(), supported_frame_lengths_ms(),
-                  AudioEncoderOpusConfig::kMinBitrateBps,
-                  num_channels_to_encode_, next_frame_length_ms_,
-                  GetTargetBitrate(), config_.fec_enabled, GetDtx())));
+      config,
+      ControllerManagerImpl::Create(
+          config_string, NumChannels(), supported_frame_lengths_ms(),
+          kOpusMinBitrateBps, num_channels_to_encode_, next_frame_length_ms_,
+          GetTargetBitrate(), config_.fec_enabled, GetDtx())));
 }
 
-void AudioEncoderOpusImpl::MaybeUpdateUplinkBandwidth() {
+void AudioEncoderOpus::MaybeUpdateUplinkBandwidth() {
   if (audio_network_adaptor_) {
     int64_t now_ms = rtc::TimeMillis();
     if (!bitrate_smoother_last_update_time_ ||
         now_ms - *bitrate_smoother_last_update_time_ >=
             config_.uplink_bandwidth_update_interval_ms) {
       rtc::Optional<float> smoothed_bitrate = bitrate_smoother_->GetAverage();
       if (smoothed_bitrate)
         audio_network_adaptor_->SetUplinkBandwidth(*smoothed_bitrate);
       bitrate_smoother_last_update_time_ = rtc::Optional<int64_t>(now_ms);
     }
   }
 }
 
 }  // namespace webrtc