1 files changed, 83 insertions, 128 deletions

diff --git a/chromium/third_party/webrtc/modules/audio_coding/main/acm2/codec_owner.cc b/chromium/third_party/webrtc/modules/audio_coding/main/acm2/codec_owner.cc
index 4d214be2428..449a467a172 100644
--- a/chromium/third_party/webrtc/modules/audio_coding/main/acm2/codec_owner.cc
+++ b/chromium/third_party/webrtc/modules/audio_coding/main/acm2/codec_owner.cc
@@ -11,133 +11,104 @@
 #include "webrtc/modules/audio_coding/main/acm2/codec_owner.h"
 
 #include "webrtc/base/checks.h"
+#include "webrtc/base/logging.h"
 #include "webrtc/engine_configurations.h"
 #include "webrtc/modules/audio_coding/codecs/cng/include/audio_encoder_cng.h"
 #include "webrtc/modules/audio_coding/codecs/g711/include/audio_encoder_pcm.h"
+#ifdef WEBRTC_CODEC_G722
 #include "webrtc/modules/audio_coding/codecs/g722/include/audio_encoder_g722.h"
+#endif
+#ifdef WEBRTC_CODEC_ILBC
 #include "webrtc/modules/audio_coding/codecs/ilbc/interface/audio_encoder_ilbc.h"
+#endif
+#ifdef WEBRTC_CODEC_ISACFX
+#include "webrtc/modules/audio_coding/codecs/isac/fix/interface/audio_decoder_isacfix.h"
 #include "webrtc/modules/audio_coding/codecs/isac/fix/interface/audio_encoder_isacfix.h"
+#endif
+#ifdef WEBRTC_CODEC_ISAC
+#include "webrtc/modules/audio_coding/codecs/isac/main/interface/audio_decoder_isac.h"
 #include "webrtc/modules/audio_coding/codecs/isac/main/interface/audio_encoder_isac.h"
+#endif
+#ifdef WEBRTC_CODEC_OPUS
 #include "webrtc/modules/audio_coding/codecs/opus/interface/audio_encoder_opus.h"
+#endif
 #include "webrtc/modules/audio_coding/codecs/pcm16b/include/audio_encoder_pcm16b.h"
+#ifdef WEBRTC_CODEC_RED
 #include "webrtc/modules/audio_coding/codecs/red/audio_encoder_copy_red.h"
+#endif
 
 namespace webrtc {
 namespace acm2 {
 
-namespace {
-bool IsIsac(const CodecInst& codec) {
-  return
-#if (defined(WEBRTC_CODEC_ISAC) || defined(WEBRTC_CODEC_ISACFX))
-      !STR_CASE_CMP(codec.plname, "isac") ||
-#endif
-      false;
-}
-
-bool IsOpus(const CodecInst& codec) {
-  return
-#ifdef WEBRTC_CODEC_OPUS
-      !STR_CASE_CMP(codec.plname, "opus") ||
-#endif
-      false;
-}
-
-bool IsPcmU(const CodecInst& codec) {
-  return !STR_CASE_CMP(codec.plname, "pcmu");
-}
-
-bool IsPcmA(const CodecInst& codec) {
-  return !STR_CASE_CMP(codec.plname, "pcma");
-}
-
-bool IsPcm16B(const CodecInst& codec) {
-  return
-#ifdef WEBRTC_CODEC_PCM16
-      !STR_CASE_CMP(codec.plname, "l16") ||
-#endif
-      false;
-}
-
-bool IsIlbc(const CodecInst& codec) {
-  return
-#ifdef WEBRTC_CODEC_ILBC
-      !STR_CASE_CMP(codec.plname, "ilbc") ||
-#endif
-      false;
-}
-
-bool IsG722(const CodecInst& codec) {
-  return
-#ifdef WEBRTC_CODEC_G722
-      !STR_CASE_CMP(codec.plname, "g722") ||
-#endif
-      false;
-}
-}  // namespace
-
-CodecOwner::CodecOwner()
-    : isac_is_encoder_(false), external_speech_encoder_(nullptr) {
+CodecOwner::CodecOwner() : external_speech_encoder_(nullptr) {
 }
 
 CodecOwner::~CodecOwner() = default;
 
 namespace {
-AudioEncoderDecoderMutableIsac* CreateIsacCodec(const CodecInst& speech_inst) {
+
+rtc::scoped_ptr<AudioDecoder> CreateIsacDecoder(
+    LockedIsacBandwidthInfo* bwinfo) {
 #if defined(WEBRTC_CODEC_ISACFX)
-  return new AudioEncoderDecoderMutableIsacFix(speech_inst);
+  return rtc_make_scoped_ptr(new AudioDecoderIsacFix(bwinfo));
 #elif defined(WEBRTC_CODEC_ISAC)
-  return new AudioEncoderDecoderMutableIsacFloat(speech_inst);
+  return rtc_make_scoped_ptr(new AudioDecoderIsac(bwinfo));
 #else
   FATAL() << "iSAC is not supported.";
-  return nullptr;
+  return rtc::scoped_ptr<AudioDecoder>();
 #endif
 }
 
-void CreateSpeechEncoder(
+// Returns a new speech encoder, or null on error.
+// TODO(kwiberg): Don't handle errors here (bug 5033)
+rtc::scoped_ptr<AudioEncoder> CreateSpeechEncoder(
     const CodecInst& speech_inst,
-    rtc::scoped_ptr<AudioEncoderMutable>* speech_encoder,
-    rtc::scoped_ptr<AudioEncoderDecoderMutableIsac>* isac_codec,
-    bool* isac_is_encoder) {
-  if (IsIsac(speech_inst)) {
-    if (*isac_codec) {
-      (*isac_codec)->UpdateSettings(speech_inst);
-    } else {
-      isac_codec->reset(CreateIsacCodec(speech_inst));
-    }
-    *isac_is_encoder = true;
-    speech_encoder->reset();
-    return;
-  }
-  if (IsOpus(speech_inst)) {
-    speech_encoder->reset(new AudioEncoderMutableOpus(speech_inst));
-  } else if (IsPcmU(speech_inst)) {
-    speech_encoder->reset(new AudioEncoderMutablePcmU(speech_inst));
-  } else if (IsPcmA(speech_inst)) {
-    speech_encoder->reset(new AudioEncoderMutablePcmA(speech_inst));
-  } else if (IsPcm16B(speech_inst)) {
-    speech_encoder->reset(new AudioEncoderMutablePcm16B(speech_inst));
-  } else if (IsIlbc(speech_inst)) {
-    speech_encoder->reset(new AudioEncoderMutableIlbc(speech_inst));
-  } else if (IsG722(speech_inst)) {
-    speech_encoder->reset(new AudioEncoderMutableG722(speech_inst));
-  } else {
-    FATAL();
-  }
-  *isac_is_encoder = false;
+    LockedIsacBandwidthInfo* bwinfo) {
+#if defined(WEBRTC_CODEC_ISACFX)
+  if (STR_CASE_CMP(speech_inst.plname, "isac") == 0)
+    return rtc_make_scoped_ptr(new AudioEncoderIsacFix(speech_inst, bwinfo));
+#endif
+#if defined(WEBRTC_CODEC_ISAC)
+  if (STR_CASE_CMP(speech_inst.plname, "isac") == 0)
+    return rtc_make_scoped_ptr(new AudioEncoderIsac(speech_inst, bwinfo));
+#endif
+#ifdef WEBRTC_CODEC_OPUS
+  if (STR_CASE_CMP(speech_inst.plname, "opus") == 0)
+    return rtc_make_scoped_ptr(new AudioEncoderOpus(speech_inst));
+#endif
+  if (STR_CASE_CMP(speech_inst.plname, "pcmu") == 0)
+    return rtc_make_scoped_ptr(new AudioEncoderPcmU(speech_inst));
+  if (STR_CASE_CMP(speech_inst.plname, "pcma") == 0)
+    return rtc_make_scoped_ptr(new AudioEncoderPcmA(speech_inst));
+  if (STR_CASE_CMP(speech_inst.plname, "l16") == 0)
+    return rtc_make_scoped_ptr(new AudioEncoderPcm16B(speech_inst));
+#ifdef WEBRTC_CODEC_ILBC
+  if (STR_CASE_CMP(speech_inst.plname, "ilbc") == 0)
+    return rtc_make_scoped_ptr(new AudioEncoderIlbc(speech_inst));
+#endif
+#ifdef WEBRTC_CODEC_G722
+  if (STR_CASE_CMP(speech_inst.plname, "g722") == 0)
+    return rtc_make_scoped_ptr(new AudioEncoderG722(speech_inst));
+#endif
+  LOG_F(LS_ERROR) << "Could not create encoder of type " << speech_inst.plname;
+  return rtc::scoped_ptr<AudioEncoder>();
 }
 
 AudioEncoder* CreateRedEncoder(int red_payload_type,
                                AudioEncoder* encoder,
                                rtc::scoped_ptr<AudioEncoder>* red_encoder) {
-  if (red_payload_type == -1) {
-    red_encoder->reset();
-    return encoder;
+#ifdef WEBRTC_CODEC_RED
+  if (red_payload_type != -1) {
+    AudioEncoderCopyRed::Config config;
+    config.payload_type = red_payload_type;
+    config.speech_encoder = encoder;
+    red_encoder->reset(new AudioEncoderCopyRed(config));
+    return red_encoder->get();
   }
-  AudioEncoderCopyRed::Config config;
-  config.payload_type = red_payload_type;
-  config.speech_encoder = encoder;
-  red_encoder->reset(new AudioEncoderCopyRed(config));
-  return red_encoder->get();
+#endif
+
+  red_encoder->reset();
+  return encoder;
 }
 
 void CreateCngEncoder(int cng_payload_type,
@@ -172,30 +143,31 @@ void CreateCngEncoder(int cng_payload_type,
 }
 }  // namespace
 
-void CodecOwner::SetEncoders(const CodecInst& speech_inst,
+bool CodecOwner::SetEncoders(const CodecInst& speech_inst,
                              int cng_payload_type,
                              ACMVADMode vad_mode,
                              int red_payload_type) {
-  CreateSpeechEncoder(speech_inst, &speech_encoder_, &isac_codec_,
-                      &isac_is_encoder_);
+  speech_encoder_ = CreateSpeechEncoder(speech_inst, &isac_bandwidth_info_);
+  if (!speech_encoder_)
+    return false;
   external_speech_encoder_ = nullptr;
   ChangeCngAndRed(cng_payload_type, vad_mode, red_payload_type);
+  return true;
 }
 
-void CodecOwner::SetEncoders(AudioEncoderMutable* external_speech_encoder,
+void CodecOwner::SetEncoders(AudioEncoder* external_speech_encoder,
                              int cng_payload_type,
                              ACMVADMode vad_mode,
                              int red_payload_type) {
   external_speech_encoder_ = external_speech_encoder;
   speech_encoder_.reset();
-  isac_is_encoder_ = false;
   ChangeCngAndRed(cng_payload_type, vad_mode, red_payload_type);
 }
 
 void CodecOwner::ChangeCngAndRed(int cng_payload_type,
                                  ACMVADMode vad_mode,
                                  int red_payload_type) {
-  AudioEncoderMutable* speech_encoder = SpeechEncoder();
+  AudioEncoder* speech_encoder = SpeechEncoder();
   if (cng_payload_type != -1 || red_payload_type != -1) {
     // The RED and CNG encoders need to be in sync with the speech encoder, so
     // reset the latter to ensure its buffer is empty.
@@ -204,24 +176,13 @@ void CodecOwner::ChangeCngAndRed(int cng_payload_type,
   AudioEncoder* encoder =
       CreateRedEncoder(red_payload_type, speech_encoder, &red_encoder_);
   CreateCngEncoder(cng_payload_type, vad_mode, encoder, &cng_encoder_);
-  int num_true =
-      !!speech_encoder_ + !!external_speech_encoder_ + isac_is_encoder_;
-  DCHECK_EQ(num_true, 1);
-  DCHECK(!isac_is_encoder_ || isac_codec_);
+  RTC_DCHECK_EQ(!!speech_encoder_ + !!external_speech_encoder_, 1);
 }
 
 AudioDecoder* CodecOwner::GetIsacDecoder() {
-  if (!isac_codec_) {
-    DCHECK(!isac_is_encoder_);
-    // None of the parameter values in |speech_inst| matter when the codec is
-    // used only as a decoder.
-    CodecInst speech_inst;
-    speech_inst.plfreq = 16000;
-    speech_inst.rate = -1;
-    speech_inst.pacsize = 480;
-    isac_codec_.reset(CreateIsacCodec(speech_inst));
-  }
-  return isac_codec_.get();
+  if (!isac_decoder_)
+    isac_decoder_ = CreateIsacDecoder(&isac_bandwidth_info_);
+  return isac_decoder_.get();
 }
 
 AudioEncoder* CodecOwner::Encoder() {
@@ -237,21 +198,15 @@ const AudioEncoder* CodecOwner::Encoder() const {
   return SpeechEncoder();
 }
 
-AudioEncoderMutable* CodecOwner::SpeechEncoder() {
-  const auto& const_this = *this;
-  return const_cast<AudioEncoderMutable*>(const_this.SpeechEncoder());
+AudioEncoder* CodecOwner::SpeechEncoder() {
+  const auto* const_this = this;
+  return const_cast<AudioEncoder*>(const_this->SpeechEncoder());
 }
 
-const AudioEncoderMutable* CodecOwner::SpeechEncoder() const {
-  int num_true =
-      !!speech_encoder_ + !!external_speech_encoder_ + isac_is_encoder_;
-  DCHECK_GE(num_true, 0);
-  DCHECK_LE(num_true, 1);
-  if (external_speech_encoder_)
-    return external_speech_encoder_;
-  if (speech_encoder_)
-    return speech_encoder_.get();
-  return isac_is_encoder_ ? isac_codec_.get() : nullptr;
+const AudioEncoder* CodecOwner::SpeechEncoder() const {
+  RTC_DCHECK(!speech_encoder_ || !external_speech_encoder_);
+  return external_speech_encoder_ ? external_speech_encoder_
+                                  : speech_encoder_.get();
 }
 
 }  // namespace acm2