AudioCodingModuleImpl: Put CodecManager and Rent-A-Codec in a separate struct

webrtc/modules/audio_coding/acm2/audio_coding_module_impl.cc

 /*
  *  Copyright (c) 2012 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 89 matching lines @@
   }
 }
 
 AudioCodingModuleImpl::AudioCodingModuleImpl(
     const AudioCodingModule::Config& config)
     : id_(config.id),
       expected_codec_ts_(0xD87F3F9F),
       expected_in_ts_(0xD87F3F9F),
       receiver_(config),
       bitrate_logger_("WebRTC.Audio.TargetBitrateInKbps"),
+      encoder_factory_(new EncoderFactory),
       encoder_stack_(nullptr),
       previous_pltype_(255),
       receiver_initialized_(false),
       first_10ms_data_(false),
       first_frame_(true),
       packetization_callback_(NULL),
       vad_callback_(NULL) {
   if (InitializeReceiverSafe() < 0) {
     WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceAudioCoding, id_,
                  "Cannot initialize receiver");
@@ skipping 68 matching lines @@
   return static_cast<int32_t>(encode_buffer_.size());
 }
 
 /////////////////////////////////////////
 //   Sender
 //
 
 // Can be called multiple times for Codec, CNG, RED.
 int AudioCodingModuleImpl::RegisterSendCodec(const CodecInst& send_codec) {
   rtc::CritScope lock(&acm_crit_sect_);
-  if (!codec_manager_.RegisterEncoder(send_codec)) {
+  if (!encoder_factory_->codec_manager.RegisterEncoder(send_codec)) {
     return -1;
   }
-  auto* sp = codec_manager_.GetStackParams();
-  if (!sp->speech_encoder && codec_manager_.GetCodecInst()) {
+  auto* sp = encoder_factory_->codec_manager.GetStackParams();
+  if (!sp->speech_encoder && encoder_factory_->codec_manager.GetCodecInst()) {
     // We have no speech encoder, but we have a specification for making one.
-    AudioEncoder* enc =
-        rent_a_codec_.RentEncoder(*codec_manager_.GetCodecInst());
+    AudioEncoder* enc = encoder_factory_->rent_a_codec.RentEncoder(
+        *encoder_factory_->codec_manager.GetCodecInst());
     if (!enc)
       return -1;
     sp->speech_encoder = enc;
   }
   if (sp->speech_encoder)
-    encoder_stack_ = rent_a_codec_.RentEncoderStack(sp);
+    encoder_stack_ = encoder_factory_->rent_a_codec.RentEncoderStack(sp);
   return 0;
 }
 
 void AudioCodingModuleImpl::RegisterExternalSendCodec(
     AudioEncoder* external_speech_encoder) {
   rtc::CritScope lock(&acm_crit_sect_);
-  auto* sp = codec_manager_.GetStackParams();
+  auto* sp = encoder_factory_->codec_manager.GetStackParams();
   sp->speech_encoder = external_speech_encoder;
-  encoder_stack_ = rent_a_codec_.RentEncoderStack(sp);
+  encoder_stack_ = encoder_factory_->rent_a_codec.RentEncoderStack(sp);
 }
 
 // Get current send codec.
 rtc::Optional<CodecInst> AudioCodingModuleImpl::SendCodec() const {
   rtc::CritScope lock(&acm_crit_sect_);
-  auto* ci = codec_manager_.GetCodecInst();
+  auto* ci = encoder_factory_->codec_manager.GetCodecInst();
   if (ci) {
     return rtc::Optional<CodecInst>(*ci);
   }
-  auto* enc = codec_manager_.GetStackParams()->speech_encoder;
+  auto* enc = encoder_factory_->codec_manager.GetStackParams()->speech_encoder;
   if (enc) {
     return rtc::Optional<CodecInst>(CodecManager::ForgeCodecInst(enc));
   }
   return rtc::Optional<CodecInst>();
 }
 
 // Get current send frequency.
 int AudioCodingModuleImpl::SendFrequency() const {
   WEBRTC_TRACE(webrtc::kTraceStream, webrtc::kTraceAudioCoding, id_,
                "SendFrequency()");
@@ skipping 194 matching lines @@
 
   return 0;
 }
 
 /////////////////////////////////////////
 //   (RED) Redundant Coding
 //
 
 bool AudioCodingModuleImpl::REDStatus() const {
   rtc::CritScope lock(&acm_crit_sect_);
-  return codec_manager_.GetStackParams()->use_red;
+  return encoder_factory_->codec_manager.GetStackParams()->use_red;
 }
 
 // Configure RED status i.e on/off.
 int AudioCodingModuleImpl::SetREDStatus(bool enable_red) {
 #ifdef WEBRTC_CODEC_RED
   rtc::CritScope lock(&acm_crit_sect_);
-  if (!codec_manager_.SetCopyRed(enable_red)) {
+  if (!encoder_factory_->codec_manager.SetCopyRed(enable_red)) {
     return -1;
   }
-  auto* sp = codec_manager_.GetStackParams();
+  auto* sp = encoder_factory_->codec_manager.GetStackParams();
   if (sp->speech_encoder)
-    encoder_stack_ = rent_a_codec_.RentEncoderStack(sp);
+    encoder_stack_ = encoder_factory_->rent_a_codec.RentEncoderStack(sp);
   return 0;
 #else
   WEBRTC_TRACE(webrtc::kTraceWarning, webrtc::kTraceAudioCoding, id_,
                "  WEBRTC_CODEC_RED is undefined");
   return -1;
 #endif
 }
 
 /////////////////////////////////////////
 //   (FEC) Forward Error Correction (codec internal)
 //
 
 bool AudioCodingModuleImpl::CodecFEC() const {
   rtc::CritScope lock(&acm_crit_sect_);
-  return codec_manager_.GetStackParams()->use_codec_fec;
+  return encoder_factory_->codec_manager.GetStackParams()->use_codec_fec;
 }
 
 int AudioCodingModuleImpl::SetCodecFEC(bool enable_codec_fec) {
   rtc::CritScope lock(&acm_crit_sect_);
-  if (!codec_manager_.SetCodecFEC(enable_codec_fec)) {
+  if (!encoder_factory_->codec_manager.SetCodecFEC(enable_codec_fec)) {
     return -1;
   }
-  auto* sp = codec_manager_.GetStackParams();
+  auto* sp = encoder_factory_->codec_manager.GetStackParams();
   if (sp->speech_encoder)
-    encoder_stack_ = rent_a_codec_.RentEncoderStack(sp);
+    encoder_stack_ = encoder_factory_->rent_a_codec.RentEncoderStack(sp);
   if (enable_codec_fec) {
     return sp->use_codec_fec ? 0 : -1;
   } else {
     RTC_DCHECK(!sp->use_codec_fec);
     return 0;
   }
 }
 
 int AudioCodingModuleImpl::SetPacketLossRate(int loss_rate) {
   rtc::CritScope lock(&acm_crit_sect_);
   if (HaveValidEncoder("SetPacketLossRate")) {
     encoder_stack_->SetProjectedPacketLossRate(loss_rate / 100.0);
   }
   return 0;
 }
 
 /////////////////////////////////////////
 //   (VAD) Voice Activity Detection
 //
 int AudioCodingModuleImpl::SetVAD(bool enable_dtx,
                                   bool enable_vad,
                                   ACMVADMode mode) {
   // Note: |enable_vad| is not used; VAD is enabled based on the DTX setting.
   RTC_DCHECK_EQ(enable_dtx, enable_vad);
   rtc::CritScope lock(&acm_crit_sect_);
-  if (!codec_manager_.SetVAD(enable_dtx, mode)) {
+  if (!encoder_factory_->codec_manager.SetVAD(enable_dtx, mode)) {
     return -1;
   }
-  auto* sp = codec_manager_.GetStackParams();
+  auto* sp = encoder_factory_->codec_manager.GetStackParams();
   if (sp->speech_encoder)
-    encoder_stack_ = rent_a_codec_.RentEncoderStack(sp);
+    encoder_stack_ = encoder_factory_->rent_a_codec.RentEncoderStack(sp);
   return 0;
 }
 
 // Get VAD/DTX settings.
 int AudioCodingModuleImpl::VAD(bool* dtx_enabled, bool* vad_enabled,
                                ACMVADMode* mode) const {
   rtc::CritScope lock(&acm_crit_sect_);
-  const auto* sp = codec_manager_.GetStackParams();
+  const auto* sp = encoder_factory_->codec_manager.GetStackParams();
   *dtx_enabled = *vad_enabled = sp->use_cng;
   *mode = sp->vad_mode;
   return 0;
 }
 
 /////////////////////////////////////////
 //   Receiver
 //
 
 int AudioCodingModuleImpl::InitializeReceiver() {
@@ skipping 70 matching lines @@
   if (!RentACodec::IsPayloadTypeValid(codec.pltype)) {
     LOG_F(LS_ERROR) << "Invalid payload type " << codec.pltype << " for "
                     << codec.plname;
     return -1;
   }
 
   // Get |decoder| associated with |codec|. |decoder| is NULL if |codec| does
   // not own its decoder.
   return receiver_.AddCodec(
       *codec_index, codec.pltype, codec.channels, codec.plfreq,
-      STR_CASE_CMP(codec.plname, "isac") == 0 ? rent_a_codec_.RentIsacDecoder()
-                                              : nullptr,
+      STR_CASE_CMP(codec.plname, "isac") == 0
+          ? encoder_factory_->rent_a_codec.RentIsacDecoder()
+          : nullptr,
       codec.plname);
 }
 
 int AudioCodingModuleImpl::RegisterExternalReceiveCodec(
     int rtp_payload_type,
     AudioDecoder* external_decoder,
     int sample_rate_hz,
     int num_channels,
     const std::string& name) {
   rtc::CritScope lock(&acm_crit_sect_);
@@ skipping 190 matching lines @@
   return receiver_.LeastRequiredDelayMs();
 }
 
 void AudioCodingModuleImpl::GetDecodingCallStatistics(
       AudioDecodingCallStats* call_stats) const {
   receiver_.GetDecodingCallStatistics(call_stats);
 }
 
 }  // namespace acm2
 }  // namespace webrtc