Add speech encoder to the encoder stack specification struct

webrtc/modules/audio_coding/acm2/codec_manager.cc

 /*
  *  Copyright (c) 2015 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 147 matching lines @@
   // Recreate the encoder if anything except the send bitrate has changed.
   if (!CurrentEncoder() || send_codec_inst_.pltype != send_codec.pltype ||
       STR_CASE_CMP(send_codec_inst_.plname, send_codec.plname) != 0 ||
       send_codec_inst_.plfreq != send_codec.plfreq ||
       send_codec_inst_.pacsize != send_codec.pacsize ||
       send_codec_inst_.channels != send_codec.channels) {
     RTC_DCHECK(CodecSupported(send_codec));
     AudioEncoder* enc = rent_a_codec_.RentEncoder(send_codec);
     if (!enc)
       return -1;
-    rent_a_codec_.RentEncoderStack(enc, &codec_stack_params_);
+    codec_stack_params_.speech_encoder = enc;
+    rent_a_codec_.RentEncoderStack(&codec_stack_params_);
     RTC_DCHECK(CurrentEncoder());
   }
 
   send_codec_inst_ = send_codec;
   CurrentEncoder()->SetTargetBitrate(send_codec_inst_.rate);
   return 0;
 }
 
 void CodecManager::RegisterEncoder(AudioEncoder* external_speech_encoder) {
   // Make up a CodecInst.
   send_codec_inst_.channels = external_speech_encoder->NumChannels();
   send_codec_inst_.plfreq = external_speech_encoder->SampleRateHz();
   send_codec_inst_.pacsize = rtc::CheckedDivExact(
       static_cast<int>(external_speech_encoder->Max10MsFramesInAPacket() *
                        send_codec_inst_.plfreq),
       100);
   send_codec_inst_.pltype = -1;  // Not valid.
   send_codec_inst_.rate = -1;    // Not valid.
   static const char kName[] = "external";
   memcpy(send_codec_inst_.plname, kName, sizeof(kName));
 
-  rent_a_codec_.RentEncoderStack(external_speech_encoder, &codec_stack_params_);
+  codec_stack_params_.speech_encoder = external_speech_encoder;
+  rent_a_codec_.RentEncoderStack(&codec_stack_params_);
 }
 
 rtc::Optional<CodecInst> CodecManager::GetCodecInst() const {
   int dummy_id = 0;
   WEBRTC_TRACE(webrtc::kTraceStream, webrtc::kTraceAudioCoding, dummy_id,
                "SendCodec()");
 
   if (!CurrentEncoder()) {
     WEBRTC_TRACE(webrtc::kTraceStream, webrtc::kTraceAudioCoding, dummy_id,
                  "SendCodec Failed, no codec is registered");
@@ skipping 11 matching lines @@
   if (enable &&
       codec_stack_params_.red_payload_types.count(send_codec_inst_.plfreq) <
           1) {
     WEBRTC_TRACE(webrtc::kTraceWarning, webrtc::kTraceAudioCoding, 0,
                  "Cannot enable RED at %i Hz.", send_codec_inst_.plfreq);
     return false;
   }
   if (codec_stack_params_.use_red != enable) {
     codec_stack_params_.use_red = enable;
     if (CurrentEncoder())
-      rent_a_codec_.RentEncoderStack(rent_a_codec_.GetEncoder(),
-                                     &codec_stack_params_);
+      rent_a_codec_.RentEncoderStack(&codec_stack_params_);
   }
   return true;
 }
 
 int CodecManager::SetVAD(bool enable, ACMVADMode mode) {
   // Sanity check of the mode.
   RTC_DCHECK(mode == VADNormal || mode == VADLowBitrate || mode == VADAggr ||
              mode == VADVeryAggr);
 
   // Check that the send codec is mono. We don't support VAD/DTX for stereo
   // sending.
-  auto* enc = rent_a_codec_.GetEncoder();
-  const bool stereo_send = enc ? (enc->NumChannels() != 1) : false;
+  const bool stereo_send =
+      codec_stack_params_.speech_encoder
+          ? (codec_stack_params_.speech_encoder->NumChannels() != 1)
+          : false;
   if (enable && stereo_send) {
     WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceAudioCoding, 0,
                  "VAD/DTX not supported for stereo sending");
     codec_stack_params_.use_cng = false;
     return -1;
   }
 
   // If a send codec is registered, set VAD/DTX for the codec.
   if (IsOpus(send_codec_inst_)) {
     // VAD/DTX not supported.
     codec_stack_params_.use_cng = false;
     return 0;
   }
 
   if (codec_stack_params_.use_cng != enable ||
       codec_stack_params_.vad_mode != mode) {
     codec_stack_params_.use_cng = enable;
     codec_stack_params_.vad_mode = mode;
-    if (enc)
-      rent_a_codec_.RentEncoderStack(enc, &codec_stack_params_);
+    if (codec_stack_params_.speech_encoder)
+      rent_a_codec_.RentEncoderStack(&codec_stack_params_);
   }
   return 0;
 }
 
 void CodecManager::VAD(bool* dtx_enabled,
                        bool* vad_enabled,
                        ACMVADMode* mode) const {
   *dtx_enabled = *vad_enabled = codec_stack_params_.use_cng;
   *mode = codec_stack_params_.vad_mode;
 }
@@ skipping 10 matching lines @@
       CurrentEncoder()->SetFec(enable_codec_fec) && enable_codec_fec;
   return codec_stack_params_.use_codec_fec == enable_codec_fec ? 0 : -1;
 }
 
 AudioDecoder* CodecManager::GetAudioDecoder(const CodecInst& codec) {
   return IsIsac(codec) ? rent_a_codec_.RentIsacDecoder() : nullptr;
 }
 
 }  // namespace acm2
 }  // namespace webrtc