AudioCodingModule: Add methods for injecting external encoder stacks

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 203 matching lines @@
 }
 
 void AudioCodingModuleImpl::RegisterExternalSendCodec(
     AudioEncoder* external_speech_encoder) {
   rtc::CritScope lock(&acm_crit_sect_);
   auto* sp = encoder_factory_->codec_manager.GetStackParams();
   sp->speech_encoder = external_speech_encoder;
   encoder_stack_ = encoder_factory_->rent_a_codec.RentEncoderStack(sp);
 }
 
+void AudioCodingModuleImpl::VisitEncoder(const EncoderVisitor& ev) {

[hlundin-webrtc, 2016/02/10 09:45:46]

Rename function to ModifyEncoder, or something similar.

+  rtc::CritScope lock(&acm_crit_sect_);
+
+  // Wipe the encoder factory, so that everything that relies on it will fail.
+  // We don't want the complexity of supporting swapping back and forth.
+  encoder_factory_.reset();
+
+  encoder_stack_ = ev(encoder_stack_);
+}
+
 // Get current send codec.
 rtc::Optional<CodecInst> AudioCodingModuleImpl::SendCodec() const {
   rtc::CritScope lock(&acm_crit_sect_);
-  auto* ci = encoder_factory_->codec_manager.GetCodecInst();
-  if (ci) {
-    return rtc::Optional<CodecInst>(*ci);
+  if (encoder_factory_) {
+    auto* ci = encoder_factory_->codec_manager.GetCodecInst();
+    if (ci) {
+      return rtc::Optional<CodecInst>(*ci);
+    }
   }
-  auto* enc = encoder_factory_->codec_manager.GetStackParams()->speech_encoder;
-  if (enc) {
-    return rtc::Optional<CodecInst>(CodecManager::ForgeCodecInst(enc));
+  if (encoder_stack_) {
+    return rtc::Optional<CodecInst>(
+        CodecManager::ForgeCodecInst(encoder_stack_));
   }
   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_);
 
@@ skipping 329 matching lines @@
                                  : receiver_.last_output_sample_rate_hz();
 }
 
 // Get current playout frequency.
 int AudioCodingModuleImpl::PlayoutFrequency() const {
   WEBRTC_TRACE(webrtc::kTraceStream, webrtc::kTraceAudioCoding, id_,
                "PlayoutFrequency()");
   return receiver_.last_output_sample_rate_hz();
 }
 
-// Register possible receive codecs, can be called multiple times,
-// for codecs, CNG (NB, WB and SWB), DTMF, RED.
 int AudioCodingModuleImpl::RegisterReceiveCodec(const CodecInst& codec) {
   rtc::CritScope lock(&acm_crit_sect_);
+  auto* ef = encoder_factory_.get();
+  return RegisterReceiveCodecUnlocked(
+      codec, [ef] { return ef->rent_a_codec.RentIsacDecoder(); });
+}
+
+int AudioCodingModuleImpl::RegisterReceiveCodec(const CodecInst& codec,
+                                                const DecoderFactory& df) {
+  rtc::CritScope lock(&acm_crit_sect_);
+  return RegisterReceiveCodecUnlocked(codec, df);
+}
+
+int AudioCodingModuleImpl::RegisterReceiveCodecUnlocked(
+    const CodecInst& codec,
+    const DecoderFactory& df) {
   RTC_DCHECK(receiver_initialized_);
   if (codec.channels > 2) {
     LOG_F(LS_ERROR) << "Unsupported number of channels: " << codec.channels;
     return -1;
   }
 
   auto codec_id =
       RentACodec::CodecIdByParams(codec.plname, codec.plfreq, codec.channels);
   if (!codec_id) {
     LOG_F(LS_ERROR) << "Wrong codec params to be registered as receive codec";
     return -1;
   }
   auto codec_index = RentACodec::CodecIndexFromId(*codec_id);
   RTC_CHECK(codec_index) << "Invalid codec ID: " << static_cast<int>(*codec_id);
 
   // Check if the payload-type is valid.
   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
-          ? encoder_factory_->rent_a_codec.RentIsacDecoder()
-          : nullptr,
-      codec.plname);
+      STR_CASE_CMP(codec.plname, "isac") == 0 ? df() : 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_);
   RTC_DCHECK(receiver_initialized_);
@@ skipping 189 matching lines @@
   return receiver_.LeastRequiredDelayMs();
 }
 
 void AudioCodingModuleImpl::GetDecodingCallStatistics(
       AudioDecodingCallStats* call_stats) const {
   receiver_.GetDecodingCallStatistics(call_stats);
 }
 
 }  // namespace acm2
 }  // namespace webrtc