Remove RentACodec::GetEncoderStack

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 112 matching lines @@
 AudioCodingModuleImpl::~AudioCodingModuleImpl() = default;
 
 int32_t AudioCodingModuleImpl::Encode(const InputData& input_data) {
   AudioEncoder::EncodedInfo encoded_info;
   uint8_t previous_pltype;
 
   // Check if there is an encoder before.
   if (!HaveValidEncoder("Process"))
     return -1;
 
-  AudioEncoder* audio_encoder = rent_a_codec_.GetEncoderStack();
   // Scale the timestamp to the codec's RTP timestamp rate.
   uint32_t rtp_timestamp =
       first_frame_ ? input_data.input_timestamp
                    : last_rtp_timestamp_ +
                          rtc::CheckedDivExact(
                              input_data.input_timestamp - last_timestamp_,
                              static_cast<uint32_t>(rtc::CheckedDivExact(
-                                 audio_encoder->SampleRateHz(),
-                                 audio_encoder->RtpTimestampRateHz())));
+                                 encoder_stack_->SampleRateHz(),
+                                 encoder_stack_->RtpTimestampRateHz())));
   last_timestamp_ = input_data.input_timestamp;
   last_rtp_timestamp_ = rtp_timestamp;
   first_frame_ = false;
 
-  encode_buffer_.SetSize(audio_encoder->MaxEncodedBytes());
-  encoded_info = audio_encoder->Encode(
+  encode_buffer_.SetSize(encoder_stack_->MaxEncodedBytes());
+  encoded_info = encoder_stack_->Encode(
       rtp_timestamp, rtc::ArrayView<const int16_t>(
                          input_data.audio, input_data.audio_channel *
                                                input_data.length_per_channel),
       encode_buffer_.size(), encode_buffer_.data());
   encode_buffer_.SetSize(encoded_info.encoded_bytes);
-  bitrate_logger_.MaybeLog(audio_encoder->GetTargetBitrate() / 1000);
+  bitrate_logger_.MaybeLog(encoder_stack_->GetTargetBitrate() / 1000);
   if (encode_buffer_.size() == 0 && !encoded_info.send_even_if_empty) {
     // Not enough data.
     return 0;
   }
   previous_pltype = previous_pltype_;  // Read it while we have the critsect.
 
   RTPFragmentationHeader my_fragmentation;
   ConvertEncodedInfoToFragmentationHeader(encoded_info, &my_fragmentation);
   FrameType frame_type;
   if (encode_buffer_.size() == 0 && encoded_info.send_even_if_empty) {
@@ skipping 36 matching lines @@
   auto* sp = codec_manager_.GetStackParams();
   if (!sp->speech_encoder && 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());
     if (!enc)
       return -1;
     sp->speech_encoder = enc;
   }
   if (sp->speech_encoder)
-    rent_a_codec_.RentEncoderStack(sp);
+    encoder_stack_ = 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();
   sp->speech_encoder = external_speech_encoder;
-  rent_a_codec_.RentEncoderStack(sp);
+  encoder_stack_ = 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();
   if (ci) {
     return rtc::Optional<CodecInst>(*ci);
   }
   auto* enc = 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()");
   rtc::CritScope lock(&acm_crit_sect_);
 
-  const auto* enc = rent_a_codec_.GetEncoderStack();
-  if (!enc) {
+  if (!encoder_stack_) {
     WEBRTC_TRACE(webrtc::kTraceStream, webrtc::kTraceAudioCoding, id_,
                  "SendFrequency Failed, no codec is registered");
     return -1;
   }
 
-  return enc->SampleRateHz();
+  return encoder_stack_->SampleRateHz();
 }
 
 void AudioCodingModuleImpl::SetBitRate(int bitrate_bps) {
   rtc::CritScope lock(&acm_crit_sect_);
-  auto* enc = rent_a_codec_.GetEncoderStack();
-  if (enc) {
-    enc->SetTargetBitrate(bitrate_bps);
+  if (encoder_stack_) {
+    encoder_stack_->SetTargetBitrate(bitrate_bps);
   }
 }
 
 // Register a transport callback which will be called to deliver
 // the encoded buffers.
 int AudioCodingModuleImpl::RegisterTransportCallback(
     AudioPacketizationCallback* transport) {
   rtc::CritScope lock(&callback_crit_sect_);
   packetization_callback_ = transport;
   return 0;
@@ skipping 46 matching lines @@
   const AudioFrame* ptr_frame;
   // Perform a resampling, also down-mix if it is required and can be
   // performed before resampling (a down mix prior to resampling will take
   // place if both primary and secondary encoders are mono and input is in
   // stereo).
   if (PreprocessToAddData(audio_frame, &ptr_frame) < 0) {
     return -1;
   }
 
   // Check whether we need an up-mix or down-mix?
-  const size_t current_num_channels =
-      rent_a_codec_.GetEncoderStack()->NumChannels();
+  const size_t current_num_channels = encoder_stack_->NumChannels();
   const bool same_num_channels =
       ptr_frame->num_channels_ == current_num_channels;
 
   if (!same_num_channels) {
     if (ptr_frame->num_channels_ == 1) {
       if (UpMix(*ptr_frame, WEBRTC_10MS_PCM_AUDIO, input_data->buffer) < 0)
         return -1;
     } else {
       if (DownMix(*ptr_frame, WEBRTC_10MS_PCM_AUDIO, input_data->buffer) < 0)
         return -1;
@@ skipping 16 matching lines @@
   return 0;
 }
 
 // Perform a resampling and down-mix if required. We down-mix only if
 // encoder is mono and input is stereo. In case of dual-streaming, both
 // encoders has to be mono for down-mix to take place.
 // |*ptr_out| will point to the pre-processed audio-frame. If no pre-processing
 // is required, |*ptr_out| points to |in_frame|.
 int AudioCodingModuleImpl::PreprocessToAddData(const AudioFrame& in_frame,
                                                const AudioFrame** ptr_out) {
-  const auto* enc = rent_a_codec_.GetEncoderStack();
-  const bool resample = in_frame.sample_rate_hz_ != enc->SampleRateHz();
+  const bool resample =
+      in_frame.sample_rate_hz_ != encoder_stack_->SampleRateHz();
 
   // This variable is true if primary codec and secondary codec (if exists)
   // are both mono and input is stereo.
   // TODO(henrik.lundin): This condition should probably be
-  //   in_frame.num_channels_ > enc->NumChannels()
-  const bool down_mix = in_frame.num_channels_ == 2 && enc->NumChannels() == 1;
+  //   in_frame.num_channels_ > encoder_stack_->NumChannels()
+  const bool down_mix =
+      in_frame.num_channels_ == 2 && encoder_stack_->NumChannels() == 1;
 
   if (!first_10ms_data_) {
     expected_in_ts_ = in_frame.timestamp_;
     expected_codec_ts_ = in_frame.timestamp_;
     first_10ms_data_ = true;
   } else if (in_frame.timestamp_ != expected_in_ts_) {
     // TODO(turajs): Do we need a warning here.
     expected_codec_ts_ +=
         (in_frame.timestamp_ - expected_in_ts_) *
-        static_cast<uint32_t>(static_cast<double>(enc->SampleRateHz()) /
-                              static_cast<double>(in_frame.sample_rate_hz_));
+        static_cast<uint32_t>(
+            static_cast<double>(encoder_stack_->SampleRateHz()) /
+            static_cast<double>(in_frame.sample_rate_hz_));
     expected_in_ts_ = in_frame.timestamp_;
   }
 
 
   if (!down_mix && !resample) {
     // No pre-processing is required.
     expected_in_ts_ += static_cast<uint32_t>(in_frame.samples_per_channel_);
     expected_codec_ts_ += static_cast<uint32_t>(in_frame.samples_per_channel_);
     *ptr_out = &in_frame;
     return 0;
@@ skipping 18 matching lines @@
 
   preprocess_frame_.timestamp_ = expected_codec_ts_;
   preprocess_frame_.samples_per_channel_ = in_frame.samples_per_channel_;
   preprocess_frame_.sample_rate_hz_ = in_frame.sample_rate_hz_;
   // If it is required, we have to do a resampling.
   if (resample) {
     // The result of the resampler is written to output frame.
     dest_ptr_audio = preprocess_frame_.data_;
 
     int samples_per_channel = resampler_.Resample10Msec(
-        src_ptr_audio, in_frame.sample_rate_hz_, enc->SampleRateHz(),
+        src_ptr_audio, in_frame.sample_rate_hz_, encoder_stack_->SampleRateHz(),
         preprocess_frame_.num_channels_, AudioFrame::kMaxDataSizeSamples,
         dest_ptr_audio);
 
     if (samples_per_channel < 0) {
       WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceAudioCoding, id_,
                    "Cannot add 10 ms audio, resampling failed");
       return -1;
     }
     preprocess_frame_.samples_per_channel_ =
         static_cast<size_t>(samples_per_channel);
-    preprocess_frame_.sample_rate_hz_ = enc->SampleRateHz();
+    preprocess_frame_.sample_rate_hz_ = encoder_stack_->SampleRateHz();
   }
 
   expected_codec_ts_ +=
       static_cast<uint32_t>(preprocess_frame_.samples_per_channel_);
   expected_in_ts_ += static_cast<uint32_t>(in_frame.samples_per_channel_);
 
   return 0;
 }
 
 /////////////////////////////////////////
 //   (RED) Redundant Coding
 //
 
 bool AudioCodingModuleImpl::REDStatus() const {
   rtc::CritScope lock(&acm_crit_sect_);
   return 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)) {
     return -1;
   }
   auto* sp = codec_manager_.GetStackParams();
   if (sp->speech_encoder)
-    rent_a_codec_.RentEncoderStack(sp);
+    encoder_stack_ = 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;
 }
 
 int AudioCodingModuleImpl::SetCodecFEC(bool enable_codec_fec) {
   rtc::CritScope lock(&acm_crit_sect_);
   if (!codec_manager_.SetCodecFEC(enable_codec_fec)) {
     return -1;
   }
   auto* sp = codec_manager_.GetStackParams();
   if (sp->speech_encoder)
-    rent_a_codec_.RentEncoderStack(sp);
+    encoder_stack_ = 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")) {
-    rent_a_codec_.GetEncoderStack()->SetProjectedPacketLossRate(loss_rate /
-                                                                100.0);
+    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)) {
     return -1;
   }
   auto* sp = codec_manager_.GetStackParams();
   if (sp->speech_encoder)
-    rent_a_codec_.RentEncoderStack(sp);
+    encoder_stack_ = 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();
   *dtx_enabled = *vad_enabled = sp->use_cng;
   *mode = sp->vad_mode;
@@ skipping 220 matching lines @@
     case kVoip:
       app = AudioEncoder::Application::kSpeech;
       break;
     case kAudio:
       app = AudioEncoder::Application::kAudio;
       break;
     default:
       FATAL();
       return 0;
   }
-  return rent_a_codec_.GetEncoderStack()->SetApplication(app) ? 0 : -1;
+  return encoder_stack_->SetApplication(app) ? 0 : -1;
 }
 
 // Informs Opus encoder of the maximum playback rate the receiver will render.
 int AudioCodingModuleImpl::SetOpusMaxPlaybackRate(int frequency_hz) {
   rtc::CritScope lock(&acm_crit_sect_);
   if (!HaveValidEncoder("SetOpusMaxPlaybackRate")) {
     return -1;
   }
-  rent_a_codec_.GetEncoderStack()->SetMaxPlaybackRate(frequency_hz);
+  encoder_stack_->SetMaxPlaybackRate(frequency_hz);
   return 0;
 }
 
 int AudioCodingModuleImpl::EnableOpusDtx() {
   rtc::CritScope lock(&acm_crit_sect_);
   if (!HaveValidEncoder("EnableOpusDtx")) {
     return -1;
   }
-  return rent_a_codec_.GetEncoderStack()->SetDtx(true) ? 0 : -1;
+  return encoder_stack_->SetDtx(true) ? 0 : -1;
 }
 
 int AudioCodingModuleImpl::DisableOpusDtx() {
   rtc::CritScope lock(&acm_crit_sect_);
   if (!HaveValidEncoder("DisableOpusDtx")) {
     return -1;
   }
-  return rent_a_codec_.GetEncoderStack()->SetDtx(false) ? 0 : -1;
+  return encoder_stack_->SetDtx(false) ? 0 : -1;
 }
 
 int AudioCodingModuleImpl::PlayoutTimestamp(uint32_t* timestamp) {
   return receiver_.GetPlayoutTimestamp(timestamp) ? 0 : -1;
 }
 
 bool AudioCodingModuleImpl::HaveValidEncoder(const char* caller_name) const {
-  if (!rent_a_codec_.GetEncoderStack()) {
+  if (!encoder_stack_) {
     WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceAudioCoding, id_,
                  "%s failed: No send codec is registered.", caller_name);
     return false;
   }
   return true;
 }
 
 int AudioCodingModuleImpl::UnregisterReceiveCodec(uint8_t payload_type) {
   return receiver_.RemoveCodec(payload_type);
 }
@@ skipping 15 matching lines @@
   return receiver_.LeastRequiredDelayMs();
 }
 
 void AudioCodingModuleImpl::GetDecodingCallStatistics(
       AudioDecodingCallStats* call_stats) const {
   receiver_.GetDecodingCallStatistics(call_stats);
 }
 
 }  // namespace acm2
 }  // namespace webrtc