diff --git a/modules/audio_coding/main/acm2/acm_generic_codec.cc b/modules/audio_coding/main/acm2/acm_generic_codec.cc
index c472a4a..6d7b095 100644
--- a/modules/audio_coding/main/acm2/acm_generic_codec.cc
+++ b/modules/audio_coding/main/acm2/acm_generic_codec.cc
@@ -209,7 +209,7 @@
   return decoder_->Channels();
 }
 
-int16_t ACMGenericCodec::EncoderParams(WebRtcACMCodecParams* enc_params) {
+int16_t ACMGenericCodec::EncoderParams(WebRtcACMCodecParams* enc_params) const {
   *enc_params = acm_codec_params_;
   return 0;
 }
@@ -540,6 +540,10 @@
   return encoder_;
 }
 
+const AudioEncoder* ACMGenericCodec::GetAudioEncoder() const {
+  return encoder_;
+}
+
 }  // namespace acm2
 
 }  // namespace webrtc
diff --git a/modules/audio_coding/main/acm2/acm_generic_codec.h b/modules/audio_coding/main/acm2/acm_generic_codec.h
index 6a5a04a..d491dfd 100644
--- a/modules/audio_coding/main/acm2/acm_generic_codec.h
+++ b/modules/audio_coding/main/acm2/acm_generic_codec.h
@@ -120,7 +120,7 @@
   //   -1 if the encoder is not initialized,
   //    0 otherwise.
   //
-  int16_t EncoderParams(WebRtcACMCodecParams* enc_params);
+  int16_t EncoderParams(WebRtcACMCodecParams* enc_params) const;
 
   ///////////////////////////////////////////////////////////////////////////
   // int16_t InitEncoder(...)
@@ -410,6 +410,8 @@
 
   AudioEncoder* GetAudioEncoder();
 
+  const AudioEncoder* GetAudioEncoder() const;
+
  private:
   bool has_internal_fec_;
 
diff --git a/modules/audio_coding/main/acm2/acm_receiver_unittest_oldapi.cc b/modules/audio_coding/main/acm2/acm_receiver_unittest_oldapi.cc
index d2b7746..269d19c 100644
--- a/modules/audio_coding/main/acm2/acm_receiver_unittest_oldapi.cc
+++ b/modules/audio_coding/main/acm2/acm_receiver_unittest_oldapi.cc
@@ -62,7 +62,6 @@
     }
 
     acm_->InitializeReceiver();
-    acm_->InitializeSender();
     acm_->RegisterTransportCallback(this);
 
     rtp_header_.header.sequenceNumber = 0;
diff --git a/modules/audio_coding/main/acm2/audio_coding_module.gypi b/modules/audio_coding/main/acm2/audio_coding_module.gypi
index edbcaa9..6b938b6 100644
--- a/modules/audio_coding/main/acm2/audio_coding_module.gypi
+++ b/modules/audio_coding/main/acm2/audio_coding_module.gypi
@@ -70,6 +70,8 @@
         'audio_coding_module_impl.h',
         'call_statistics.cc',
         'call_statistics.h',
+        'codec_manager.cc',
+        'codec_manager.h',
         'initial_delay_manager.cc',
         'initial_delay_manager.h',
         'nack.cc',
diff --git a/modules/audio_coding/main/acm2/audio_coding_module_impl.cc b/modules/audio_coding/main/acm2/audio_coding_module_impl.cc
index c4ab6a9..d78af65 100644
--- a/modules/audio_coding/main/acm2/audio_coding_module_impl.cc
+++ b/modules/audio_coding/main/acm2/audio_coding_module_impl.cc
@@ -18,7 +18,6 @@
 #include "webrtc/base/safe_conversions.h"
 #include "webrtc/engine_configurations.h"
 #include "webrtc/modules/audio_coding/main/interface/audio_coding_module_typedefs.h"
-#include "webrtc/modules/audio_coding/main/acm2/acm_codec_database.h"
 #include "webrtc/modules/audio_coding/main/acm2/acm_common_defs.h"
 #include "webrtc/modules/audio_coding/main/acm2/acm_generic_codec.h"
 #include "webrtc/modules/audio_coding/main/acm2/acm_resampler.h"
@@ -126,20 +125,8 @@
       id_(config.id),
       expected_codec_ts_(0xD87F3F9F),
       expected_in_ts_(0xD87F3F9F),
-      send_codec_inst_(),
-      cng_nb_pltype_(255),
-      cng_wb_pltype_(255),
-      cng_swb_pltype_(255),
-      cng_fb_pltype_(255),
-      red_nb_pltype_(255),
-      vad_enabled_(false),
-      dtx_enabled_(false),
-      vad_mode_(VADNormal),
-      current_encoder_(nullptr),
-      stereo_send_(false),
       receiver_(config),
-      red_enabled_(false),
-      codec_fec_enabled_(false),
+      codec_manager_(this),
       previous_pltype_(255),
       aux_rtp_header_(NULL),
       receiver_initialized_(false),
@@ -148,35 +135,6 @@
       callback_crit_sect_(CriticalSectionWrapper::CreateCriticalSection()),
       packetization_callback_(NULL),
       vad_callback_(NULL) {
-  // Nullify send codec memory, set payload type and set codec name to
-  // invalid values.
-  const char no_name[] = "noCodecRegistered";
-  strncpy(send_codec_inst_.plname, no_name, RTP_PAYLOAD_NAME_SIZE - 1);
-  send_codec_inst_.pltype = -1;
-
-  for (int i = 0; i < ACMCodecDB::kMaxNumCodecs; i++) {
-    codecs_[i] = NULL;
-    mirror_codec_idx_[i] = -1;
-  }
-
-  // Register the default payload type for RED and for CNG at sampling rates of
-  // 8, 16, 32 and 48 kHz.
-  for (int i = (ACMCodecDB::kNumCodecs - 1); i >= 0; i--) {
-    if (IsCodecRED(i) && ACMCodecDB::database_[i].plfreq == 8000) {
-      red_nb_pltype_ = static_cast<uint8_t>(ACMCodecDB::database_[i].pltype);
-    } else if (IsCodecCN(i)) {
-      if (ACMCodecDB::database_[i].plfreq == 8000) {
-        cng_nb_pltype_ = static_cast<uint8_t>(ACMCodecDB::database_[i].pltype);
-      } else if (ACMCodecDB::database_[i].plfreq == 16000) {
-        cng_wb_pltype_ = static_cast<uint8_t>(ACMCodecDB::database_[i].pltype);
-      } else if (ACMCodecDB::database_[i].plfreq == 32000) {
-        cng_swb_pltype_ = static_cast<uint8_t>(ACMCodecDB::database_[i].pltype);
-      } else if (ACMCodecDB::database_[i].plfreq == 48000) {
-        cng_fb_pltype_ = static_cast<uint8_t>(ACMCodecDB::database_[i].pltype);
-      }
-    }
-  }
-
   if (InitializeReceiverSafe() < 0) {
     WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceAudioCoding, id_,
                  "Cannot initialize receiver");
@@ -185,23 +143,6 @@
 }
 
 AudioCodingModuleImpl::~AudioCodingModuleImpl() {
-  {
-    CriticalSectionScoped lock(acm_crit_sect_);
-
-    for (int i = 0; i < ACMCodecDB::kMaxNumCodecs; i++) {
-      if (codecs_[i] != NULL) {
-        // Mirror index holds the address of the codec memory.
-        assert(mirror_codec_idx_[i] > -1);
-        if (codecs_[mirror_codec_idx_[i]] != NULL) {
-          delete codecs_[mirror_codec_idx_[i]];
-          codecs_[mirror_codec_idx_[i]] = NULL;
-        }
-
-        codecs_[i] = NULL;
-      }
-    }
-  }
-
   if (aux_rtp_header_ != NULL) {
     delete aux_rtp_header_;
     aux_rtp_header_ = NULL;
@@ -229,7 +170,8 @@
       return -1;
     }
 
-    AudioEncoder* audio_encoder = current_encoder_->GetAudioEncoder();
+    AudioEncoder* audio_encoder =
+        codec_manager_.current_encoder()->GetAudioEncoder();
     // Scale the timestamp to the codec's RTP timestamp rate.
     uint32_t rtp_timestamp =
         first_frame_ ? input_data.input_timestamp
@@ -271,7 +213,7 @@
           frame_type, encoded_info.payload_type, encoded_info.encoded_timestamp,
           stream, encoded_info.encoded_bytes,
           my_fragmentation.fragmentationVectorSize > 0 ? &my_fragmentation
-              : nullptr);
+                                                       : nullptr);
     }
 
     if (vad_callback_) {
@@ -290,17 +232,6 @@
 //   Sender
 //
 
-// Initialize send codec.
-int AudioCodingModuleImpl::InitializeSender() {
-  CriticalSectionScoped lock(acm_crit_sect_);
-
-  // Start with invalid values.
-  current_encoder_ = nullptr;
-  send_codec_inst_.plname[0] = '\0';
-
-  return 0;
-}
-
 // TODO(henrik.lundin): Remove this method; only used in tests.
 int AudioCodingModuleImpl::ResetEncoder() {
   CriticalSectionScoped lock(acm_crit_sect_);
@@ -310,365 +241,16 @@
   return 0;
 }
 
-ACMGenericCodec* AudioCodingModuleImpl::CreateCodec(const CodecInst& codec) {
-  ACMGenericCodec* my_codec = NULL;
-  CriticalSectionScoped lock(acm_crit_sect_);
-  my_codec = ACMCodecDB::CreateCodecInstance(
-      codec, cng_nb_pltype_, cng_wb_pltype_, cng_swb_pltype_, cng_fb_pltype_,
-      red_enabled_, red_nb_pltype_);
-  if (my_codec == NULL) {
-    // Error, could not create the codec.
-    WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceAudioCoding, id_,
-                 "ACMCodecDB::CreateCodecInstance() failed in CreateCodec()");
-    return my_codec;
-  }
-
-  return my_codec;
-}
-
-// Check if the given codec is a valid to be registered as send codec.
-static int IsValidSendCodec(const CodecInst& send_codec,
-                            bool is_primary_encoder,
-                            int acm_id,
-                            int* mirror_id) {
-  if ((send_codec.channels != 1) && (send_codec.channels != 2)) {
-    WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceAudioCoding, acm_id,
-                 "Wrong number of channels (%d, only mono and stereo are "
-                 "supported) for %s encoder", send_codec.channels,
-                 is_primary_encoder ? "primary" : "secondary");
-    return -1;
-  }
-
-  int codec_id = ACMCodecDB::CodecNumber(send_codec, mirror_id);
-  if (codec_id < 0) {
-    WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceAudioCoding, acm_id,
-                 "Invalid codec setting for the send codec.");
-    return -1;
-  }
-
-  // TODO(tlegrand): Remove this check. Already taken care of in
-  // ACMCodecDB::CodecNumber().
-  // Check if the payload-type is valid
-  if (!ACMCodecDB::ValidPayloadType(send_codec.pltype)) {
-    WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceAudioCoding, acm_id,
-                 "Invalid payload-type %d for %s.", send_codec.pltype,
-                 send_codec.plname);
-    return -1;
-  }
-
-  // Telephone-event cannot be a send codec.
-  if (!STR_CASE_CMP(send_codec.plname, "telephone-event")) {
-    WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceAudioCoding, acm_id,
-                 "telephone-event cannot be a send codec");
-    *mirror_id = -1;
-    return -1;
-  }
-
-  if (ACMCodecDB::codec_settings_[codec_id].channel_support
-      < send_codec.channels) {
-    WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceAudioCoding, acm_id,
-                 "%d number of channels not supportedn for %s.",
-                 send_codec.channels, send_codec.plname);
-    *mirror_id = -1;
-    return -1;
-  }
-
-  if (!is_primary_encoder) {
-    // If registering the secondary encoder, then RED and CN are not valid
-    // choices as encoder.
-    if (IsCodecRED(&send_codec)) {
-      WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceAudioCoding, acm_id,
-                   "RED cannot be secondary codec");
-      *mirror_id = -1;
-      return -1;
-    }
-
-    if (IsCodecCN(&send_codec)) {
-      WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceAudioCoding, acm_id,
-                   "DTX cannot be secondary codec");
-      *mirror_id = -1;
-      return -1;
-    }
-  }
-  return codec_id;
-}
-
 // Can be called multiple times for Codec, CNG, RED.
 int AudioCodingModuleImpl::RegisterSendCodec(const CodecInst& send_codec) {
-  int mirror_id;
-  int codec_id = IsValidSendCodec(send_codec, true, id_, &mirror_id);
-
   CriticalSectionScoped lock(acm_crit_sect_);
-
-  // Check for reported errors from function IsValidSendCodec().
-  if (codec_id < 0) {
-    return -1;
-  }
-
-  // RED can be registered with other payload type. If not registered a default
-  // payload type is used.
-  if (IsCodecRED(&send_codec)) {
-    // TODO(tlegrand): Remove this check. Already taken care of in
-    // ACMCodecDB::CodecNumber().
-    // Check if the payload-type is valid
-    if (!ACMCodecDB::ValidPayloadType(send_codec.pltype)) {
-      WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceAudioCoding, id_,
-                   "Invalid payload-type %d for %s.", send_codec.pltype,
-                   send_codec.plname);
-      return -1;
-    }
-    // Set RED payload type.
-    if (send_codec.plfreq == 8000) {
-      red_nb_pltype_ = static_cast<uint8_t>(send_codec.pltype);
-    } else {
-      WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceAudioCoding, id_,
-                   "RegisterSendCodec() failed, invalid frequency for RED "
-                   "registration");
-      return -1;
-    }
-    SetRedPayloadType(send_codec.plfreq, send_codec.pltype);
-    return 0;
-  }
-
-  // CNG can be registered with other payload type. If not registered the
-  // default payload types from codec database will be used.
-  if (IsCodecCN(&send_codec)) {
-    // CNG is registered.
-    switch (send_codec.plfreq) {
-      case 8000: {
-        cng_nb_pltype_ = static_cast<uint8_t>(send_codec.pltype);
-        break;
-      }
-      case 16000: {
-        cng_wb_pltype_ = static_cast<uint8_t>(send_codec.pltype);
-        break;
-      }
-      case 32000: {
-        cng_swb_pltype_ = static_cast<uint8_t>(send_codec.pltype);
-        break;
-      }
-      case 48000: {
-        cng_fb_pltype_ = static_cast<uint8_t>(send_codec.pltype);
-        break;
-      }
-      default: {
-        WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceAudioCoding, id_,
-                     "RegisterSendCodec() failed, invalid frequency for CNG "
-                     "registration");
-        return -1;
-      }
-    }
-    SetCngPayloadType(send_codec.plfreq, send_codec.pltype);
-    return 0;
-  }
-
-  // Set Stereo, and make sure VAD and DTX is turned off.
-  if (send_codec.channels == 2) {
-    stereo_send_ = true;
-    if (vad_enabled_ || dtx_enabled_) {
-      WEBRTC_TRACE(webrtc::kTraceWarning, webrtc::kTraceAudioCoding, id_,
-                   "VAD/DTX is turned off, not supported when sending stereo.");
-    }
-    vad_enabled_ = false;
-    dtx_enabled_ = false;
-  } else {
-    stereo_send_ = false;
-  }
-
-  // Check if the codec is already registered as send codec.
-  bool is_send_codec;
-  if (current_encoder_) {
-    int send_codec_mirror_id;
-    int send_codec_id = ACMCodecDB::CodecNumber(send_codec_inst_,
-                                                &send_codec_mirror_id);
-    assert(send_codec_id >= 0);
-    is_send_codec = (send_codec_id == codec_id) ||
-        (mirror_id == send_codec_mirror_id);
-  } else {
-    is_send_codec = false;
-  }
-
-  // If new codec, or new settings, register.
-  if (!is_send_codec) {
-    if (codecs_[mirror_id] == NULL) {
-      codecs_[mirror_id] = CreateCodec(send_codec);
-      if (codecs_[mirror_id] == NULL) {
-        WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceAudioCoding, id_,
-                     "Cannot Create the codec");
-        return -1;
-      }
-      mirror_codec_idx_[mirror_id] = mirror_id;
-    }
-
-    if (mirror_id != codec_id) {
-      codecs_[codec_id] = codecs_[mirror_id];
-      mirror_codec_idx_[codec_id] = mirror_id;
-    }
-
-    ACMGenericCodec* codec_ptr = codecs_[codec_id];
-    WebRtcACMCodecParams codec_params;
-
-    memcpy(&(codec_params.codec_inst), &send_codec, sizeof(CodecInst));
-    codec_params.enable_vad = vad_enabled_;
-    codec_params.enable_dtx = dtx_enabled_;
-    codec_params.vad_mode = vad_mode_;
-    // Force initialization.
-    if (codec_ptr->InitEncoder(&codec_params, true) < 0) {
-      // Could not initialize the encoder.
-
-      // Check if already have a registered codec.
-      // Depending on that different messages are logged.
-      if (!current_encoder_) {
-        WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceAudioCoding, id_,
-                     "Cannot Initialize the encoder No Encoder is registered");
-      } else {
-        WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceAudioCoding, id_,
-                     "Cannot Initialize the encoder, continue encoding with "
-                     "the previously registered codec");
-      }
-      return -1;
-    }
-
-    // Update states.
-    dtx_enabled_ = codec_params.enable_dtx;
-    vad_enabled_ = codec_params.enable_vad;
-    vad_mode_ = codec_params.vad_mode;
-
-    // Everything is fine so we can replace the previous codec with this one.
-    if (current_encoder_) {
-      // If we change codec we start fresh with RED.
-      // This is not strictly required by the standard.
-
-      if(codec_ptr->SetCopyRed(red_enabled_) < 0) {
-        // We tried to preserve the old red status, if failed, it means the
-        // red status has to be flipped.
-        red_enabled_ = !red_enabled_;
-      }
-
-      codec_ptr->SetVAD(&dtx_enabled_, &vad_enabled_, &vad_mode_);
-
-      if (!codec_ptr->HasInternalFEC()) {
-        codec_fec_enabled_ = false;
-      } else {
-        if (codec_ptr->SetFEC(codec_fec_enabled_) < 0) {
-          WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceAudioCoding, id_,
-                       "Cannot set codec FEC");
-          return -1;
-        }
-      }
-    }
-
-    current_encoder_ = codecs_[codec_id];
-    DCHECK(current_encoder_);
-    memcpy(&send_codec_inst_, &send_codec, sizeof(CodecInst));
-    return 0;
-  } else {
-    // If codec is the same as already registered check if any parameters
-    // has changed compared to the current values.
-    // If any parameter is valid then apply it and record.
-    bool force_init = false;
-
-    if (mirror_id != codec_id) {
-      codecs_[codec_id] = codecs_[mirror_id];
-      mirror_codec_idx_[codec_id] = mirror_id;
-    }
-
-    // Check the payload type.
-    if (send_codec.pltype != send_codec_inst_.pltype) {
-      // At this point check if the given payload type is valid.
-      // Record it later when the sampling frequency is changed
-      // successfully.
-      if (!ACMCodecDB::ValidPayloadType(send_codec.pltype)) {
-        WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceAudioCoding, id_,
-                     "Out of range payload type");
-        return -1;
-      }
-    }
-
-    // If there is a codec that ONE instance of codec supports multiple
-    // sampling frequencies, then we need to take care of it here.
-    // one such a codec is iSAC. Both WB and SWB are encoded and decoded
-    // with one iSAC instance. Therefore, we need to update the encoder
-    // frequency if required.
-    if (send_codec_inst_.plfreq != send_codec.plfreq) {
-      force_init = true;
-    }
-
-    // If packet size or number of channels has changed, we need to
-    // re-initialize the encoder.
-    if (send_codec_inst_.pacsize != send_codec.pacsize) {
-      force_init = true;
-    }
-    if (send_codec_inst_.channels != send_codec.channels) {
-      force_init = true;
-    }
-
-    if (force_init) {
-      WebRtcACMCodecParams codec_params;
-
-      memcpy(&(codec_params.codec_inst), &send_codec, sizeof(CodecInst));
-      codec_params.enable_vad = vad_enabled_;
-      codec_params.enable_dtx = dtx_enabled_;
-      codec_params.vad_mode = vad_mode_;
-
-      // Force initialization.
-      if (current_encoder_->InitEncoder(&codec_params, true) < 0) {
-        WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceAudioCoding, id_,
-                     "Could not change the codec packet-size.");
-        return -1;
-      }
-
-      send_codec_inst_.plfreq = send_codec.plfreq;
-      send_codec_inst_.pacsize = send_codec.pacsize;
-      send_codec_inst_.channels = send_codec.channels;
-    }
-
-    // If the change of sampling frequency has been successful then
-    // we store the payload-type.
-    send_codec_inst_.pltype = send_codec.pltype;
-
-    // Check if a change in Rate is required.
-    if (send_codec.rate != send_codec_inst_.rate) {
-      if (codecs_[codec_id]->SetBitRate(send_codec.rate) < 0) {
-        WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceAudioCoding, id_,
-                     "Could not change the codec rate.");
-        return -1;
-      }
-      send_codec_inst_.rate = send_codec.rate;
-    }
-
-    if (!codecs_[codec_id]->HasInternalFEC()) {
-      codec_fec_enabled_ = false;
-    } else {
-      if (codecs_[codec_id]->SetFEC(codec_fec_enabled_) < 0) {
-        WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceAudioCoding, id_,
-                     "Cannot set codec FEC");
-        return -1;
-      }
-    }
-
-    return 0;
-  }
+  return codec_manager_.RegisterSendCodec(send_codec);
 }
 
 // Get current send codec.
-int AudioCodingModuleImpl::SendCodec(
-    CodecInst* current_codec) const {
-  WEBRTC_TRACE(webrtc::kTraceStream, webrtc::kTraceAudioCoding, id_,
-               "SendCodec()");
+int AudioCodingModuleImpl::SendCodec(CodecInst* current_codec) const {
   CriticalSectionScoped lock(acm_crit_sect_);
-
-  if (!current_encoder_) {
-    WEBRTC_TRACE(webrtc::kTraceStream, webrtc::kTraceAudioCoding, id_,
-                 "SendCodec Failed, no codec is registered");
-    return -1;
-  }
-  WebRtcACMCodecParams encoder_param;
-  current_encoder_->EncoderParams(&encoder_param);
-  encoder_param.codec_inst.pltype = send_codec_inst_.pltype;
-  memcpy(current_codec, &(encoder_param.codec_inst), sizeof(CodecInst));
-
-  return 0;
+  return codec_manager_.SendCodec(current_codec);
 }
 
 // Get current send frequency.
@@ -677,13 +259,13 @@
                "SendFrequency()");
   CriticalSectionScoped lock(acm_crit_sect_);
 
-  if (!current_encoder_) {
+  if (!codec_manager_.current_encoder()) {
     WEBRTC_TRACE(webrtc::kTraceStream, webrtc::kTraceAudioCoding, id_,
                  "SendFrequency Failed, no codec is registered");
     return -1;
   }
 
-  return send_codec_inst_.plfreq;
+  return codec_manager_.current_encoder()->GetAudioEncoder()->SampleRateHz();
 }
 
 // Get encode bitrate.
@@ -693,14 +275,14 @@
 int AudioCodingModuleImpl::SendBitrate() const {
   CriticalSectionScoped lock(acm_crit_sect_);
 
-  if (!current_encoder_) {
+  if (!codec_manager_.current_encoder()) {
     WEBRTC_TRACE(webrtc::kTraceStream, webrtc::kTraceAudioCoding, id_,
                  "SendBitrate Failed, no codec is registered");
     return -1;
   }
 
   WebRtcACMCodecParams encoder_param;
-  current_encoder_->EncoderParams(&encoder_param);
+  codec_manager_.current_encoder()->EncoderParams(&encoder_param);
 
   return encoder_param.codec_inst.rate;
 }
@@ -779,7 +361,9 @@
   }
 
   // Check whether we need an up-mix or down-mix?
-  bool remix = ptr_frame->num_channels_ != send_codec_inst_.channels;
+  bool remix =
+      ptr_frame->num_channels_ !=
+      codec_manager_.current_encoder()->GetAudioEncoder()->NumChannels();
 
   if (remix) {
     if (ptr_frame->num_channels_ == 1) {
@@ -796,13 +380,15 @@
   const int16_t* ptr_audio = ptr_frame->data_;
 
   // For pushing data to primary, point the |ptr_audio| to correct buffer.
-  if (send_codec_inst_.channels != ptr_frame->num_channels_)
+  if (codec_manager_.current_encoder()->GetAudioEncoder()->NumChannels() !=
+      ptr_frame->num_channels_)
     ptr_audio = input_data->buffer;
 
   input_data->input_timestamp = ptr_frame->timestamp_;
   input_data->audio = ptr_audio;
   input_data->length_per_channel = ptr_frame->samples_per_channel_;
-  input_data->audio_channel = send_codec_inst_.channels;
+  input_data->audio_channel =
+      codec_manager_.current_encoder()->GetAudioEncoder()->NumChannels();
 
   return 0;
 }
@@ -814,12 +400,15 @@
 // is required, |*ptr_out| points to |in_frame|.
 int AudioCodingModuleImpl::PreprocessToAddData(const AudioFrame& in_frame,
                                                const AudioFrame** ptr_out) {
-  bool resample = (in_frame.sample_rate_hz_ != send_codec_inst_.plfreq);
+  bool resample =
+      (in_frame.sample_rate_hz_ !=
+       codec_manager_.current_encoder()->GetAudioEncoder()->SampleRateHz());
 
   // This variable is true if primary codec and secondary codec (if exists)
   // are both mono and input is stereo.
   bool down_mix =
-      (in_frame.num_channels_ == 2) && (send_codec_inst_.channels == 1);
+      (in_frame.num_channels_ == 2) &&
+      (codec_manager_.current_encoder()->GetAudioEncoder()->NumChannels() == 1);
 
   if (!first_10ms_data_) {
     expected_in_ts_ = in_frame.timestamp_;
@@ -827,9 +416,13 @@
     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>(send_codec_inst_.plfreq) /
-                    static_cast<double>(in_frame.sample_rate_hz_)));
+    expected_codec_ts_ +=
+        (in_frame.timestamp_ - expected_in_ts_) *
+        static_cast<uint32_t>(
+            (static_cast<double>(codec_manager_.current_encoder()
+                                     ->GetAudioEncoder()
+                                     ->SampleRateHz()) /
+             static_cast<double>(in_frame.sample_rate_hz_)));
     expected_in_ts_ = in_frame.timestamp_;
   }
 
@@ -867,20 +460,19 @@
     // The result of the resampler is written to output frame.
     dest_ptr_audio = preprocess_frame_.data_;
 
-    preprocess_frame_.samples_per_channel_ =
-        resampler_.Resample10Msec(src_ptr_audio,
-                                  in_frame.sample_rate_hz_,
-                                  send_codec_inst_.plfreq,
-                                  preprocess_frame_.num_channels_,
-                                  AudioFrame::kMaxDataSizeSamples,
-                                  dest_ptr_audio);
+    preprocess_frame_.samples_per_channel_ = resampler_.Resample10Msec(
+        src_ptr_audio, in_frame.sample_rate_hz_,
+        codec_manager_.current_encoder()->GetAudioEncoder()->SampleRateHz(),
+        preprocess_frame_.num_channels_, AudioFrame::kMaxDataSizeSamples,
+        dest_ptr_audio);
 
     if (preprocess_frame_.samples_per_channel_ < 0) {
       WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceAudioCoding, id_,
                    "Cannot add 10 ms audio, resampling failed");
       return -1;
     }
-    preprocess_frame_.sample_rate_hz_ = send_codec_inst_.plfreq;
+    preprocess_frame_.sample_rate_hz_ =
+        codec_manager_.current_encoder()->GetAudioEncoder()->SampleRateHz();
   }
 
   expected_codec_ts_ += preprocess_frame_.samples_per_channel_;
@@ -895,8 +487,7 @@
 
 bool AudioCodingModuleImpl::REDStatus() const {
   CriticalSectionScoped lock(acm_crit_sect_);
-
-  return red_enabled_;
+  return codec_manager_.red_enabled();
 }
 
 // Configure RED status i.e on/off.
@@ -904,23 +495,7 @@
 #ifdef WEBRTC_CODEC_RED
     bool enable_red) {
   CriticalSectionScoped lock(acm_crit_sect_);
-
-  if (enable_red == true && codec_fec_enabled_ == true) {
-    WEBRTC_TRACE(webrtc::kTraceWarning, webrtc::kTraceAudioCoding, id_,
-                 "Codec internal FEC and RED cannot be co-enabled.");
-    return -1;
-  }
-
-  // If a send codec is registered, set RED for the codec. We now only support
-  // copy red.
-  if (HaveValidEncoder("SetCopyRed") &&
-      current_encoder_->SetCopyRed(enable_red) < 0) {
-      WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceAudioCoding, id_,
-                   "SetREDStatus failed");
-      return -1;
-  }
-  red_enabled_ = enable_red;
-  return 0;
+  return codec_manager_.SetCopyRed(enable_red) ? 0 : -1;
 #else
     bool /* enable_red */) {
   WEBRTC_TRACE(webrtc::kTraceWarning, webrtc::kTraceAudioCoding, id_,
@@ -935,33 +510,18 @@
 
 bool AudioCodingModuleImpl::CodecFEC() const {
   CriticalSectionScoped lock(acm_crit_sect_);
-  return codec_fec_enabled_;
+  return codec_manager_.codec_fec_enabled();
 }
 
 int AudioCodingModuleImpl::SetCodecFEC(bool enable_codec_fec) {
   CriticalSectionScoped lock(acm_crit_sect_);
-
-  if (enable_codec_fec == true && red_enabled_ == true) {
-    WEBRTC_TRACE(webrtc::kTraceWarning, webrtc::kTraceAudioCoding, id_,
-                 "Codec internal FEC and RED cannot be co-enabled.");
-    return -1;
-  }
-
-  // Set codec FEC.
-  if (HaveValidEncoder("SetCodecFEC") &&
-      current_encoder_->SetFEC(enable_codec_fec) < 0) {
-      WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceAudioCoding, id_,
-                   "Set codec internal FEC failed.");
-    return -1;
-  }
-  codec_fec_enabled_ = enable_codec_fec;
-  return 0;
+  return codec_manager_.SetCodecFEC(enable_codec_fec);
 }
 
 int AudioCodingModuleImpl::SetPacketLossRate(int loss_rate) {
   CriticalSectionScoped lock(acm_crit_sect_);
   if (HaveValidEncoder("SetPacketLossRate") &&
-      current_encoder_->SetPacketLossRate(loss_rate) < 0) {
+      codec_manager_.current_encoder()->SetPacketLossRate(loss_rate) < 0) {
       WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceAudioCoding, id_,
                    "Set packet loss rate failed.");
     return -1;
@@ -976,60 +536,14 @@
                                   bool enable_vad,
                                   ACMVADMode mode) {
   CriticalSectionScoped lock(acm_crit_sect_);
-  return SetVADSafe(enable_dtx, enable_vad, mode);
-}
-
-int AudioCodingModuleImpl::SetVADSafe(bool enable_dtx,
-                                      bool enable_vad,
-                                      ACMVADMode mode) {
-  // Sanity check of the mode.
-  if ((mode != VADNormal) && (mode != VADLowBitrate)
-      && (mode != VADAggr) && (mode != VADVeryAggr)) {
-    WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceAudioCoding, id_,
-                 "Invalid VAD Mode %d, no change is made to VAD/DTX status",
-                 mode);
-    return -1;
-  }
-
-  // Check that the send codec is mono. We don't support VAD/DTX for stereo
-  // sending.
-  if ((enable_dtx || enable_vad) && stereo_send_) {
-    WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceAudioCoding, id_,
-                 "VAD/DTX not supported for stereo sending");
-    dtx_enabled_ = false;
-    vad_enabled_ = false;
-    vad_mode_ = mode;
-    return -1;
-  }
-
-  // Store VAD/DTX settings. Values can be changed in the call to "SetVAD"
-  // below.
-  dtx_enabled_ = enable_dtx;
-  vad_enabled_ = enable_vad;
-  vad_mode_ = mode;
-
-  // If a send codec is registered, set VAD/DTX for the codec.
-  if (HaveValidEncoder("SetVAD") &&
-      current_encoder_->SetVAD(&dtx_enabled_, &vad_enabled_, &vad_mode_) < 0) {
-      // SetVAD failed.
-      WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceAudioCoding, id_,
-                   "SetVAD failed");
-      vad_enabled_ = false;
-      dtx_enabled_ = false;
-      return -1;
-  }
-  return 0;
+  return codec_manager_.SetVAD(enable_dtx, enable_vad, mode);
 }
 
 // Get VAD/DTX settings.
 int AudioCodingModuleImpl::VAD(bool* dtx_enabled, bool* vad_enabled,
                                ACMVADMode* mode) const {
   CriticalSectionScoped lock(acm_crit_sect_);
-
-  *dtx_enabled = dtx_enabled_;
-  *vad_enabled = vad_enabled_;
-  *mode = vad_mode_;
-
+  codec_manager_.VAD(dtx_enabled, vad_enabled, mode);
   return 0;
 }
 
@@ -1108,56 +622,24 @@
 // for codecs, CNG (NB, WB and SWB), DTMF, RED.
 int AudioCodingModuleImpl::RegisterReceiveCodec(const CodecInst& codec) {
   CriticalSectionScoped lock(acm_crit_sect_);
-
-  if (codec.channels > 2 || codec.channels < 0) {
-    WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceAudioCoding, id_,
-                 "Unsupported number of channels, %d.", codec.channels);
-    return -1;
-  }
-
-  // TODO(turajs) do we need this for NetEq 4?
-  if (!receiver_initialized_) {
-    if (InitializeReceiverSafe() < 0) {
-      WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceAudioCoding, id_,
-                   "Cannot initialize receiver, failed registering codec.");
-      return -1;
-    }
-  }
-
-  int mirror_id;
-  int codec_id = ACMCodecDB::ReceiverCodecNumber(codec, &mirror_id);
-
-  if (codec_id < 0 || codec_id >= ACMCodecDB::kNumCodecs) {
-    WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceAudioCoding, id_,
-                 "Wrong codec params to be registered as receive codec");
-    return -1;
-  }
-
-  // Check if the payload-type is valid.
-  if (!ACMCodecDB::ValidPayloadType(codec.pltype)) {
-    WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceAudioCoding, id_,
-                 "Invalid payload-type %d for %s.", codec.pltype,
-                 codec.plname);
-    return -1;
-  }
-
-  AudioDecoder* decoder = NULL;
-  // Get |decoder| associated with |codec|. |decoder| can be NULL if |codec|
-  // does not own its decoder.
-  if (GetAudioDecoder(codec, codec_id, mirror_id, &decoder) < 0) {
-    WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceAudioCoding, id_,
-                 "Wrong codec params to be registered as receive codec");
-    return -1;
-  }
-  uint8_t payload_type = static_cast<uint8_t>(codec.pltype);
-  return receiver_.AddCodec(codec_id, payload_type, codec.channels, decoder);
+  DCHECK(receiver_initialized_);
+  return codec_manager_.RegisterReceiveCodec(codec);
 }
 
 // Get current received codec.
 int AudioCodingModuleImpl::ReceiveCodec(CodecInst* current_codec) const {
+  CriticalSectionScoped lock(acm_crit_sect_);
   return receiver_.LastAudioCodec(current_codec);
 }
 
+int AudioCodingModuleImpl::RegisterDecoder(int acm_codec_id,
+                                           uint8_t payload_type,
+                                           int channels,
+                                           AudioDecoder* audio_decoder) {
+  return receiver_.AddCodec(acm_codec_id, payload_type, channels,
+                            audio_decoder);
+}
+
 // Incoming packet from network parsed and ready for decode.
 int AudioCodingModuleImpl::IncomingPacket(const uint8_t* incoming_payload,
                                           const size_t payload_length,
@@ -1312,7 +794,7 @@
     return -1;
   }
 
-  return current_encoder_->SetISACMaxRate(max_bit_per_sec);
+  return codec_manager_.current_encoder()->SetISACMaxRate(max_bit_per_sec);
 }
 
 // TODO(henrik.lundin): Remove? Only used in tests. Deprecated in VoiceEngine.
@@ -1323,7 +805,8 @@
     return -1;
   }
 
-  return current_encoder_->SetISACMaxPayloadSize(max_size_bytes);
+  return codec_manager_.current_encoder()->SetISACMaxPayloadSize(
+      max_size_bytes);
 }
 
 // TODO(henrik.lundin): Remove? Only used in tests.
@@ -1349,8 +832,8 @@
   if (!HaveValidEncoder("SetOpusApplication")) {
     return -1;
   }
-  return current_encoder_->SetOpusApplication(application,
-                                              disable_dtx_if_needed);
+  return codec_manager_.current_encoder()->SetOpusApplication(
+      application, disable_dtx_if_needed);
 }
 
 // Informs Opus encoder of the maximum playback rate the receiver will render.
@@ -1359,7 +842,7 @@
   if (!HaveValidEncoder("SetOpusMaxPlaybackRate")) {
     return -1;
   }
-  return current_encoder_->SetOpusMaxPlaybackRate(frequency_hz);
+  return codec_manager_.current_encoder()->SetOpusMaxPlaybackRate(frequency_hz);
 }
 
 int AudioCodingModuleImpl::EnableOpusDtx(bool force_voip) {
@@ -1367,7 +850,7 @@
   if (!HaveValidEncoder("EnableOpusDtx")) {
     return -1;
   }
-  return current_encoder_->EnableOpusDtx(force_voip);
+  return codec_manager_.current_encoder()->EnableOpusDtx(force_voip);
 }
 
 int AudioCodingModuleImpl::DisableOpusDtx() {
@@ -1375,7 +858,7 @@
   if (!HaveValidEncoder("DisableOpusDtx")) {
     return -1;
   }
-  return current_encoder_->DisableOpusDtx();
+  return codec_manager_.current_encoder()->DisableOpusDtx();
 }
 
 int AudioCodingModuleImpl::PlayoutTimestamp(uint32_t* timestamp) {
@@ -1383,7 +866,7 @@
 }
 
 bool AudioCodingModuleImpl::HaveValidEncoder(const char* caller_name) const {
-  if (!current_encoder_) {
+  if (!codec_manager_.current_encoder()) {
     WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceAudioCoding, id_,
                  "%s failed: No send codec is registered.", caller_name);
     return false;
@@ -1415,60 +898,6 @@
 //  return status;
 }
 
-int AudioCodingModuleImpl::GetAudioDecoder(const CodecInst& codec, int codec_id,
-                                           int mirror_id,
-                                           AudioDecoder** decoder) {
-  if (ACMCodecDB::OwnsDecoder(codec_id)) {
-    // This codec has to own its own decoder. Therefore, it should create the
-    // corresponding AudioDecoder class and insert it into NetEq. If the codec
-    // does not exist create it.
-    //
-    // TODO(turajs): this part of the code is common with RegisterSendCodec(),
-    //               make a method for it.
-    if (codecs_[mirror_id] == NULL) {
-      codecs_[mirror_id] = CreateCodec(codec);
-      if (codecs_[mirror_id] == NULL) {
-        WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceAudioCoding, id_,
-                     "Cannot Create the codec");
-        return -1;
-      }
-      mirror_codec_idx_[mirror_id] = mirror_id;
-    }
-
-    if (mirror_id != codec_id) {
-      codecs_[codec_id] = codecs_[mirror_id];
-      mirror_codec_idx_[codec_id] = mirror_id;
-    }
-    *decoder = codecs_[codec_id]->Decoder();
-    if (!*decoder) {
-      assert(false);
-      return -1;
-    }
-  } else {
-    *decoder = NULL;
-  }
-
-  return 0;
-}
-
-void AudioCodingModuleImpl::SetCngPayloadType(int sample_rate_hz,
-                                              int payload_type) {
-  for (auto* codec : codecs_) {
-    if (codec) {
-      codec->SetCngPt(sample_rate_hz, payload_type);
-    }
-  }
-}
-
-void AudioCodingModuleImpl::SetRedPayloadType(int sample_rate_hz,
-                                              int payload_type) {
-  for (auto* codec : codecs_) {
-    if (codec) {
-      codec->SetRedPt(sample_rate_hz, payload_type);
-    }
-  }
-}
-
 int AudioCodingModuleImpl::SetInitialPlayoutDelay(int delay_ms) {
   {
     CriticalSectionScoped lock(acm_crit_sect_);
diff --git a/modules/audio_coding/main/acm2/audio_coding_module_impl.h b/modules/audio_coding/main/acm2/audio_coding_module_impl.h
index 04a2059..1e9cbb9 100644
--- a/modules/audio_coding/main/acm2/audio_coding_module_impl.h
+++ b/modules/audio_coding/main/acm2/audio_coding_module_impl.h
@@ -20,6 +20,7 @@
 #include "webrtc/modules/audio_coding/main/acm2/acm_codec_database.h"
 #include "webrtc/modules/audio_coding/main/acm2/acm_receiver.h"
 #include "webrtc/modules/audio_coding/main/acm2/acm_resampler.h"
+#include "webrtc/modules/audio_coding/main/acm2/codec_manager.h"
 
 namespace webrtc {
 
@@ -42,9 +43,6 @@
   //   Sender
   //
 
-  // Initialize send codec.
-  int InitializeSender() override;
-
   // Reset send codec.
   int ResetEncoder() override;
 
@@ -135,6 +133,11 @@
   // Get current received codec.
   int ReceiveCodec(CodecInst* current_codec) const override;
 
+  int RegisterDecoder(int acm_codec_id,
+                      uint8_t payload_type,
+                      int channels,
+                      AudioDecoder* audio_decoder);
+
   // Incoming packet from network parsed and ready for decode.
   int IncomingPacket(const uint8_t* incoming_payload,
                      const size_t payload_length,
@@ -249,18 +252,11 @@
   int Add10MsDataInternal(const AudioFrame& audio_frame, InputData* input_data);
   int Encode(const InputData& input_data);
 
-  ACMGenericCodec* CreateCodec(const CodecInst& codec);
-
   int InitializeReceiverSafe() EXCLUSIVE_LOCKS_REQUIRED(acm_crit_sect_);
 
   bool HaveValidEncoder(const char* caller_name) const
       EXCLUSIVE_LOCKS_REQUIRED(acm_crit_sect_);
 
-  // Set VAD/DTX status. This function does not acquire a lock, and it is
-  // created to be called only from inside a critical section.
-  int SetVADSafe(bool enable_dtx, bool enable_vad, ACMVADMode mode)
-      EXCLUSIVE_LOCKS_REQUIRED(acm_crit_sect_);
-
   // Preprocessing of input audio, including resampling and down-mixing if
   // required, before pushing audio into encoder's buffer.
   //
@@ -280,54 +276,13 @@
   // to |index|.
   int UpdateUponReceivingCodec(int index);
 
-  // Get a pointer to AudioDecoder of the given codec. For some codecs, e.g.
-  // iSAC, encoding and decoding have to be performed on a shared
-  // codec-instance. By calling this method, we get the codec-instance that ACM
-  // owns, then pass that to NetEq. This way, we perform both encoding and
-  // decoding on the same codec-instance. Furthermore, ACM would have control
-  // over decoder functionality if required. If |codec| does not share an
-  // instance between encoder and decoder, the |*decoder| is set NULL.
-  // The field ACMCodecDB::CodecSettings.owns_decoder indicates that if a
-  // codec owns the decoder-instance. For such codecs |*decoder| should be a
-  // valid pointer, otherwise it will be NULL.
-  int GetAudioDecoder(const CodecInst& codec, int codec_id,
-                      int mirror_id, AudioDecoder** decoder)
-      EXCLUSIVE_LOCKS_REQUIRED(acm_crit_sect_);
-
-  void SetCngPayloadType(int sample_rate_hz, int payload_type)
-      EXCLUSIVE_LOCKS_REQUIRED(acm_crit_sect_);
-
-  void SetRedPayloadType(int sample_rate_hz, int payload_type)
-      EXCLUSIVE_LOCKS_REQUIRED(acm_crit_sect_);
-
   CriticalSectionWrapper* acm_crit_sect_;
   int id_;  // TODO(henrik.lundin) Make const.
   uint32_t expected_codec_ts_ GUARDED_BY(acm_crit_sect_);
   uint32_t expected_in_ts_ GUARDED_BY(acm_crit_sect_);
-  CodecInst send_codec_inst_ GUARDED_BY(acm_crit_sect_);
-
-  uint8_t cng_nb_pltype_ GUARDED_BY(acm_crit_sect_);
-  uint8_t cng_wb_pltype_ GUARDED_BY(acm_crit_sect_);
-  uint8_t cng_swb_pltype_ GUARDED_BY(acm_crit_sect_);
-  uint8_t cng_fb_pltype_ GUARDED_BY(acm_crit_sect_);
-
-  uint8_t red_nb_pltype_ GUARDED_BY(acm_crit_sect_);
-  bool vad_enabled_ GUARDED_BY(acm_crit_sect_);
-  bool dtx_enabled_ GUARDED_BY(acm_crit_sect_);
-  ACMVADMode vad_mode_ GUARDED_BY(acm_crit_sect_);
-  ACMGenericCodec* codecs_[ACMCodecDB::kMaxNumCodecs]
-      GUARDED_BY(acm_crit_sect_);
-  ACMGenericCodec* current_encoder_ GUARDED_BY(acm_crit_sect_);
-  int mirror_codec_idx_[ACMCodecDB::kMaxNumCodecs] GUARDED_BY(acm_crit_sect_);
-  bool stereo_send_ GUARDED_BY(acm_crit_sect_);
   ACMResampler resampler_ GUARDED_BY(acm_crit_sect_);
   AcmReceiver receiver_;  // AcmReceiver has it's own internal lock.
-
-  // RED.
-  bool red_enabled_ GUARDED_BY(acm_crit_sect_);
-
-  // Codec internal FEC
-  bool codec_fec_enabled_ GUARDED_BY(acm_crit_sect_);
+  CodecManager codec_manager_ GUARDED_BY(acm_crit_sect_);
 
   // This is to keep track of CN instances where we can send DTMFs.
   uint8_t previous_pltype_ GUARDED_BY(acm_crit_sect_);
diff --git a/modules/audio_coding/main/acm2/codec_manager.cc b/modules/audio_coding/main/acm2/codec_manager.cc
new file mode 100644
index 0000000..c3e340e
--- /dev/null
+++ b/modules/audio_coding/main/acm2/codec_manager.cc
@@ -0,0 +1,612 @@
+/*
+ *  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.
+ */
+
+#include "webrtc/modules/audio_coding/main/acm2/codec_manager.h"
+
+#include "webrtc/base/checks.h"
+#include "webrtc/modules/audio_coding/main/acm2/audio_coding_module_impl.h"
+
+namespace webrtc {
+namespace acm2 {
+
+namespace {
+bool IsCodecRED(const CodecInst* codec) {
+  return (STR_CASE_CMP(codec->plname, "RED") == 0);
+}
+
+bool IsCodecRED(int index) {
+  return (IsCodecRED(&ACMCodecDB::database_[index]));
+}
+
+bool IsCodecCN(const CodecInst* codec) {
+  return (STR_CASE_CMP(codec->plname, "CN") == 0);
+}
+
+bool IsCodecCN(int index) {
+  return (IsCodecCN(&ACMCodecDB::database_[index]));
+}
+
+// Check if the given codec is a valid to be registered as send codec.
+int IsValidSendCodec(const CodecInst& send_codec,
+                     bool is_primary_encoder,
+                     int* mirror_id) {
+  int dummy_id = 0;
+  if ((send_codec.channels != 1) && (send_codec.channels != 2)) {
+    WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceAudioCoding, dummy_id,
+                 "Wrong number of channels (%d, only mono and stereo are "
+                 "supported) for %s encoder",
+                 send_codec.channels,
+                 is_primary_encoder ? "primary" : "secondary");
+    return -1;
+  }
+
+  int codec_id = ACMCodecDB::CodecNumber(send_codec, mirror_id);
+  if (codec_id < 0) {
+    WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceAudioCoding, dummy_id,
+                 "Invalid codec setting for the send codec.");
+    return -1;
+  }
+
+  // TODO(tlegrand): Remove this check. Already taken care of in
+  // ACMCodecDB::CodecNumber().
+  // Check if the payload-type is valid
+  if (!ACMCodecDB::ValidPayloadType(send_codec.pltype)) {
+    WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceAudioCoding, dummy_id,
+                 "Invalid payload-type %d for %s.", send_codec.pltype,
+                 send_codec.plname);
+    return -1;
+  }
+
+  // Telephone-event cannot be a send codec.
+  if (!STR_CASE_CMP(send_codec.plname, "telephone-event")) {
+    WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceAudioCoding, dummy_id,
+                 "telephone-event cannot be a send codec");
+    *mirror_id = -1;
+    return -1;
+  }
+
+  if (ACMCodecDB::codec_settings_[codec_id].channel_support <
+      send_codec.channels) {
+    WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceAudioCoding, dummy_id,
+                 "%d number of channels not supportedn for %s.",
+                 send_codec.channels, send_codec.plname);
+    *mirror_id = -1;
+    return -1;
+  }
+
+  if (!is_primary_encoder) {
+    // If registering the secondary encoder, then RED and CN are not valid
+    // choices as encoder.
+    if (IsCodecRED(&send_codec)) {
+      WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceAudioCoding, dummy_id,
+                   "RED cannot be secondary codec");
+      *mirror_id = -1;
+      return -1;
+    }
+
+    if (IsCodecCN(&send_codec)) {
+      WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceAudioCoding, dummy_id,
+                   "DTX cannot be secondary codec");
+      *mirror_id = -1;
+      return -1;
+    }
+  }
+  return codec_id;
+}
+
+const CodecInst kEmptyCodecInst = {-1, "noCodecRegistered", 0, 0, 0, 0};
+}  // namespace
+
+CodecManager::CodecManager(AudioCodingModuleImpl* acm)
+    : acm_(acm),
+      cng_nb_pltype_(255),
+      cng_wb_pltype_(255),
+      cng_swb_pltype_(255),
+      cng_fb_pltype_(255),
+      red_nb_pltype_(255),
+      stereo_send_(false),
+      vad_enabled_(false),
+      dtx_enabled_(false),
+      vad_mode_(VADNormal),
+      current_encoder_(nullptr),
+      send_codec_inst_(kEmptyCodecInst),
+      red_enabled_(false),
+      codec_fec_enabled_(false) {
+  for (int i = 0; i < ACMCodecDB::kMaxNumCodecs; i++) {
+    codecs_[i] = nullptr;
+    mirror_codec_idx_[i] = -1;
+  }
+
+  // Register the default payload type for RED and for CNG at sampling rates of
+  // 8, 16, 32 and 48 kHz.
+  for (int i = (ACMCodecDB::kNumCodecs - 1); i >= 0; i--) {
+    if (IsCodecRED(i) && ACMCodecDB::database_[i].plfreq == 8000) {
+      red_nb_pltype_ = static_cast<uint8_t>(ACMCodecDB::database_[i].pltype);
+    } else if (IsCodecCN(i)) {
+      if (ACMCodecDB::database_[i].plfreq == 8000) {
+        cng_nb_pltype_ = static_cast<uint8_t>(ACMCodecDB::database_[i].pltype);
+      } else if (ACMCodecDB::database_[i].plfreq == 16000) {
+        cng_wb_pltype_ = static_cast<uint8_t>(ACMCodecDB::database_[i].pltype);
+      } else if (ACMCodecDB::database_[i].plfreq == 32000) {
+        cng_swb_pltype_ = static_cast<uint8_t>(ACMCodecDB::database_[i].pltype);
+      } else if (ACMCodecDB::database_[i].plfreq == 48000) {
+        cng_fb_pltype_ = static_cast<uint8_t>(ACMCodecDB::database_[i].pltype);
+      }
+    }
+  }
+  thread_checker_.DetachFromThread();
+}
+
+CodecManager::~CodecManager() {
+  for (int i = 0; i < ACMCodecDB::kMaxNumCodecs; i++) {
+    if (codecs_[i] != NULL) {
+      // Mirror index holds the address of the codec memory.
+      assert(mirror_codec_idx_[i] > -1);
+      if (codecs_[mirror_codec_idx_[i]] != NULL) {
+        delete codecs_[mirror_codec_idx_[i]];
+        codecs_[mirror_codec_idx_[i]] = NULL;
+      }
+
+      codecs_[i] = NULL;
+    }
+  }
+}
+
+int CodecManager::RegisterSendCodec(const CodecInst& send_codec) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  int mirror_id;
+  int codec_id = IsValidSendCodec(send_codec, true, &mirror_id);
+
+  // Check for reported errors from function IsValidSendCodec().
+  if (codec_id < 0) {
+    return -1;
+  }
+
+  int dummy_id = 0;
+  // RED can be registered with other payload type. If not registered a default
+  // payload type is used.
+  if (IsCodecRED(&send_codec)) {
+    // TODO(tlegrand): Remove this check. Already taken care of in
+    // ACMCodecDB::CodecNumber().
+    // Check if the payload-type is valid
+    if (!ACMCodecDB::ValidPayloadType(send_codec.pltype)) {
+      WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceAudioCoding, dummy_id,
+                   "Invalid payload-type %d for %s.", send_codec.pltype,
+                   send_codec.plname);
+      return -1;
+    }
+    // Set RED payload type.
+    if (send_codec.plfreq == 8000) {
+      red_nb_pltype_ = static_cast<uint8_t>(send_codec.pltype);
+    } else {
+      WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceAudioCoding, dummy_id,
+                   "RegisterSendCodec() failed, invalid frequency for RED "
+                   "registration");
+      return -1;
+    }
+    SetRedPayloadType(send_codec.plfreq, send_codec.pltype);
+    return 0;
+  }
+
+  // CNG can be registered with other payload type. If not registered the
+  // default payload types from codec database will be used.
+  if (IsCodecCN(&send_codec)) {
+    // CNG is registered.
+    switch (send_codec.plfreq) {
+      case 8000: {
+        cng_nb_pltype_ = static_cast<uint8_t>(send_codec.pltype);
+        break;
+      }
+      case 16000: {
+        cng_wb_pltype_ = static_cast<uint8_t>(send_codec.pltype);
+        break;
+      }
+      case 32000: {
+        cng_swb_pltype_ = static_cast<uint8_t>(send_codec.pltype);
+        break;
+      }
+      case 48000: {
+        cng_fb_pltype_ = static_cast<uint8_t>(send_codec.pltype);
+        break;
+      }
+      default: {
+        WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceAudioCoding, dummy_id,
+                     "RegisterSendCodec() failed, invalid frequency for CNG "
+                     "registration");
+        return -1;
+      }
+    }
+    SetCngPayloadType(send_codec.plfreq, send_codec.pltype);
+    return 0;
+  }
+
+  // Set Stereo, and make sure VAD and DTX is turned off.
+  if (send_codec.channels == 2) {
+    stereo_send_ = true;
+    if (vad_enabled_ || dtx_enabled_) {
+      WEBRTC_TRACE(webrtc::kTraceWarning, webrtc::kTraceAudioCoding, dummy_id,
+                   "VAD/DTX is turned off, not supported when sending stereo.");
+    }
+    vad_enabled_ = false;
+    dtx_enabled_ = false;
+  } else {
+    stereo_send_ = false;
+  }
+
+  // Check if the codec is already registered as send codec.
+  bool is_send_codec;
+  if (current_encoder_) {
+    int send_codec_mirror_id;
+    int send_codec_id =
+        ACMCodecDB::CodecNumber(send_codec_inst_, &send_codec_mirror_id);
+    assert(send_codec_id >= 0);
+    is_send_codec =
+        (send_codec_id == codec_id) || (mirror_id == send_codec_mirror_id);
+  } else {
+    is_send_codec = false;
+  }
+
+  // If new codec, or new settings, register.
+  if (!is_send_codec) {
+    if (!codecs_[mirror_id]) {
+      codecs_[mirror_id] = ACMCodecDB::CreateCodecInstance(
+          send_codec, cng_nb_pltype_, cng_wb_pltype_, cng_swb_pltype_,
+          cng_fb_pltype_, red_enabled_, red_nb_pltype_);
+      if (!codecs_[mirror_id]) {
+        WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceAudioCoding, dummy_id,
+                     "Cannot Create the codec");
+        return -1;
+      }
+      mirror_codec_idx_[mirror_id] = mirror_id;
+    }
+
+    if (mirror_id != codec_id) {
+      codecs_[codec_id] = codecs_[mirror_id];
+      mirror_codec_idx_[codec_id] = mirror_id;
+    }
+
+    ACMGenericCodec* codec_ptr = codecs_[codec_id];
+    WebRtcACMCodecParams codec_params;
+
+    memcpy(&(codec_params.codec_inst), &send_codec, sizeof(CodecInst));
+    codec_params.enable_vad = vad_enabled_;
+    codec_params.enable_dtx = dtx_enabled_;
+    codec_params.vad_mode = vad_mode_;
+    // Force initialization.
+    if (codec_ptr->InitEncoder(&codec_params, true) < 0) {
+      // Could not initialize the encoder.
+
+      // Check if already have a registered codec.
+      // Depending on that different messages are logged.
+      if (!current_encoder_) {
+        WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceAudioCoding, dummy_id,
+                     "Cannot Initialize the encoder No Encoder is registered");
+      } else {
+        WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceAudioCoding, dummy_id,
+                     "Cannot Initialize the encoder, continue encoding with "
+                     "the previously registered codec");
+      }
+      return -1;
+    }
+
+    // Update states.
+    dtx_enabled_ = codec_params.enable_dtx;
+    vad_enabled_ = codec_params.enable_vad;
+    vad_mode_ = codec_params.vad_mode;
+
+    // Everything is fine so we can replace the previous codec with this one.
+    if (current_encoder_) {
+      // If we change codec we start fresh with RED.
+      // This is not strictly required by the standard.
+
+      if (codec_ptr->SetCopyRed(red_enabled_) < 0) {
+        // We tried to preserve the old red status, if failed, it means the
+        // red status has to be flipped.
+        red_enabled_ = !red_enabled_;
+      }
+
+      codec_ptr->SetVAD(&dtx_enabled_, &vad_enabled_, &vad_mode_);
+
+      if (!codec_ptr->HasInternalFEC()) {
+        codec_fec_enabled_ = false;
+      } else {
+        if (codec_ptr->SetFEC(codec_fec_enabled_) < 0) {
+          WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceAudioCoding, dummy_id,
+                       "Cannot set codec FEC");
+          return -1;
+        }
+      }
+    }
+
+    current_encoder_ = codecs_[codec_id];
+    DCHECK(current_encoder_);
+    memcpy(&send_codec_inst_, &send_codec, sizeof(CodecInst));
+    return 0;
+  } else {
+    // If codec is the same as already registered check if any parameters
+    // has changed compared to the current values.
+    // If any parameter is valid then apply it and record.
+    bool force_init = false;
+
+    if (mirror_id != codec_id) {
+      codecs_[codec_id] = codecs_[mirror_id];
+      mirror_codec_idx_[codec_id] = mirror_id;
+    }
+
+    // Check the payload type.
+    if (send_codec.pltype != send_codec_inst_.pltype) {
+      // At this point check if the given payload type is valid.
+      // Record it later when the sampling frequency is changed
+      // successfully.
+      if (!ACMCodecDB::ValidPayloadType(send_codec.pltype)) {
+        WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceAudioCoding, dummy_id,
+                     "Out of range payload type");
+        return -1;
+      }
+    }
+
+    // If there is a codec that ONE instance of codec supports multiple
+    // sampling frequencies, then we need to take care of it here.
+    // one such a codec is iSAC. Both WB and SWB are encoded and decoded
+    // with one iSAC instance. Therefore, we need to update the encoder
+    // frequency if required.
+    if (send_codec_inst_.plfreq != send_codec.plfreq) {
+      force_init = true;
+    }
+
+    // If packet size or number of channels has changed, we need to
+    // re-initialize the encoder.
+    if (send_codec_inst_.pacsize != send_codec.pacsize) {
+      force_init = true;
+    }
+    if (send_codec_inst_.channels != send_codec.channels) {
+      force_init = true;
+    }
+
+    if (force_init) {
+      WebRtcACMCodecParams codec_params;
+
+      memcpy(&(codec_params.codec_inst), &send_codec, sizeof(CodecInst));
+      codec_params.enable_vad = vad_enabled_;
+      codec_params.enable_dtx = dtx_enabled_;
+      codec_params.vad_mode = vad_mode_;
+
+      // Force initialization.
+      if (current_encoder_->InitEncoder(&codec_params, true) < 0) {
+        WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceAudioCoding, dummy_id,
+                     "Could not change the codec packet-size.");
+        return -1;
+      }
+
+      send_codec_inst_.plfreq = send_codec.plfreq;
+      send_codec_inst_.pacsize = send_codec.pacsize;
+      send_codec_inst_.channels = send_codec.channels;
+    }
+
+    // If the change of sampling frequency has been successful then
+    // we store the payload-type.
+    send_codec_inst_.pltype = send_codec.pltype;
+
+    // Check if a change in Rate is required.
+    if (send_codec.rate != send_codec_inst_.rate) {
+      if (codecs_[codec_id]->SetBitRate(send_codec.rate) < 0) {
+        WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceAudioCoding, dummy_id,
+                     "Could not change the codec rate.");
+        return -1;
+      }
+      send_codec_inst_.rate = send_codec.rate;
+    }
+
+    if (!codecs_[codec_id]->HasInternalFEC()) {
+      codec_fec_enabled_ = false;
+    } else {
+      if (codecs_[codec_id]->SetFEC(codec_fec_enabled_) < 0) {
+        WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceAudioCoding, dummy_id,
+                     "Cannot set codec FEC");
+        return -1;
+      }
+    }
+
+    return 0;
+  }
+}
+
+int CodecManager::SendCodec(CodecInst* current_codec) const {
+  int dummy_id = 0;
+  WEBRTC_TRACE(webrtc::kTraceStream, webrtc::kTraceAudioCoding, dummy_id,
+               "SendCodec()");
+
+  if (!current_encoder_) {
+    WEBRTC_TRACE(webrtc::kTraceStream, webrtc::kTraceAudioCoding, dummy_id,
+                 "SendCodec Failed, no codec is registered");
+    return -1;
+  }
+  WebRtcACMCodecParams encoder_param;
+  current_encoder_->EncoderParams(&encoder_param);
+  encoder_param.codec_inst.pltype = send_codec_inst_.pltype;
+  memcpy(current_codec, &(encoder_param.codec_inst), sizeof(CodecInst));
+
+  return 0;
+}
+
+// Register possible receive codecs, can be called multiple times,
+// for codecs, CNG (NB, WB and SWB), DTMF, RED.
+int CodecManager::RegisterReceiveCodec(const CodecInst& codec) {
+  if (codec.channels > 2 || codec.channels < 0) {
+    WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceAudioCoding, 0,
+                 "Unsupported number of channels, %d.", codec.channels);
+    return -1;
+  }
+
+  int mirror_id;
+  int codec_id = ACMCodecDB::ReceiverCodecNumber(codec, &mirror_id);
+
+  if (codec_id < 0 || codec_id >= ACMCodecDB::kNumCodecs) {
+    WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceAudioCoding, 0,
+                 "Wrong codec params to be registered as receive codec");
+    return -1;
+  }
+
+  // Check if the payload-type is valid.
+  if (!ACMCodecDB::ValidPayloadType(codec.pltype)) {
+    WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceAudioCoding, 0,
+                 "Invalid payload-type %d for %s.", codec.pltype, codec.plname);
+    return -1;
+  }
+
+  AudioDecoder* decoder = NULL;
+  // Get |decoder| associated with |codec|. |decoder| can be NULL if |codec|
+  // does not own its decoder.
+  if (GetAudioDecoder(codec, codec_id, mirror_id, &decoder) < 0) {
+    WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceAudioCoding, 0,
+                 "Wrong codec params to be registered as receive codec");
+    return -1;
+  }
+  uint8_t payload_type = static_cast<uint8_t>(codec.pltype);
+  return acm_->RegisterDecoder(codec_id, payload_type, codec.channels, decoder);
+}
+
+bool CodecManager::SetCopyRed(bool enable) {
+  if (enable && codec_fec_enabled_) {
+    WEBRTC_TRACE(webrtc::kTraceWarning, webrtc::kTraceAudioCoding, 0,
+                 "Codec internal FEC and RED cannot be co-enabled.");
+    return false;
+  }
+  if (current_encoder_ && current_encoder_->SetCopyRed(enable) < 0) {
+    WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceAudioCoding, 0,
+                 "SetCopyRed failed");
+    return false;
+  }
+  red_enabled_ = enable;
+  return true;
+}
+
+int CodecManager::SetVAD(bool enable_dtx, bool enable_vad, ACMVADMode mode) {
+  // Sanity check of the mode.
+  if ((mode != VADNormal) && (mode != VADLowBitrate) && (mode != VADAggr) &&
+      (mode != VADVeryAggr)) {
+    WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceAudioCoding, 0,
+                 "Invalid VAD Mode %d, no change is made to VAD/DTX status",
+                 mode);
+    return -1;
+  }
+
+  // Check that the send codec is mono. We don't support VAD/DTX for stereo
+  // sending.
+  if ((enable_dtx || enable_vad) && stereo_send_) {
+    WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceAudioCoding, 0,
+                 "VAD/DTX not supported for stereo sending");
+    dtx_enabled_ = false;
+    vad_enabled_ = false;
+    vad_mode_ = mode;
+    return -1;
+  }
+
+  // Store VAD/DTX settings. Values can be changed in the call to "SetVAD"
+  // below.
+  dtx_enabled_ = enable_dtx;
+  vad_enabled_ = enable_vad;
+  vad_mode_ = mode;
+
+  // If a send codec is registered, set VAD/DTX for the codec.
+  if (current_encoder_ &&
+      current_encoder_->SetVAD(&dtx_enabled_, &vad_enabled_, &vad_mode_) < 0) {
+    // SetVAD failed.
+    WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceAudioCoding, 0,
+                 "SetVAD failed");
+    vad_enabled_ = false;
+    dtx_enabled_ = false;
+    return -1;
+  }
+  return 0;
+}
+
+void CodecManager::VAD(bool* dtx_enabled,
+                       bool* vad_enabled,
+                       ACMVADMode* mode) const {
+  *dtx_enabled = dtx_enabled_;
+  *vad_enabled = vad_enabled_;
+  *mode = vad_mode_;
+}
+
+int CodecManager::SetCodecFEC(bool enable_codec_fec) {
+  if (enable_codec_fec == true && red_enabled_ == true) {
+    WEBRTC_TRACE(webrtc::kTraceWarning, webrtc::kTraceAudioCoding, 0,
+                 "Codec internal FEC and RED cannot be co-enabled.");
+    return -1;
+  }
+
+  // Set codec FEC.
+  if (current_encoder_ && current_encoder_->SetFEC(enable_codec_fec) < 0) {
+    WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceAudioCoding, 0,
+                 "Set codec internal FEC failed.");
+    return -1;
+  }
+  codec_fec_enabled_ = enable_codec_fec;
+  return 0;
+}
+
+void CodecManager::SetCngPayloadType(int sample_rate_hz, int payload_type) {
+  for (auto* codec : codecs_) {
+    if (codec) {
+      codec->SetCngPt(sample_rate_hz, payload_type);
+    }
+  }
+}
+
+void CodecManager::SetRedPayloadType(int sample_rate_hz, int payload_type) {
+  for (auto* codec : codecs_) {
+    if (codec) {
+      codec->SetRedPt(sample_rate_hz, payload_type);
+    }
+  }
+}
+
+int CodecManager::GetAudioDecoder(const CodecInst& codec,
+                                  int codec_id,
+                                  int mirror_id,
+                                  AudioDecoder** decoder) {
+  if (ACMCodecDB::OwnsDecoder(codec_id)) {
+    // This codec has to own its own decoder. Therefore, it should create the
+    // corresponding AudioDecoder class and insert it into NetEq. If the codec
+    // does not exist create it.
+    //
+    // TODO(turajs): this part of the code is common with RegisterSendCodec(),
+    //               make a method for it.
+    if (codecs_[mirror_id] == NULL) {
+      codecs_[mirror_id] = ACMCodecDB::CreateCodecInstance(
+          codec, cng_nb_pltype_, cng_wb_pltype_, cng_swb_pltype_,
+          cng_fb_pltype_, red_enabled_, red_nb_pltype_);
+      if (codecs_[mirror_id] == NULL) {
+        WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceAudioCoding, 0,
+                     "Cannot Create the codec");
+        return -1;
+      }
+      mirror_codec_idx_[mirror_id] = mirror_id;
+    }
+
+    if (mirror_id != codec_id) {
+      codecs_[codec_id] = codecs_[mirror_id];
+      mirror_codec_idx_[codec_id] = mirror_id;
+    }
+    *decoder = codecs_[codec_id]->Decoder();
+    if (!*decoder) {
+      assert(false);
+      return -1;
+    }
+  } else {
+    *decoder = NULL;
+  }
+
+  return 0;
+}
+
+}  // namespace acm2
+}  // namespace webrtc
diff --git a/modules/audio_coding/main/acm2/codec_manager.h b/modules/audio_coding/main/acm2/codec_manager.h
new file mode 100644
index 0000000..8d5350d
--- /dev/null
+++ b/modules/audio_coding/main/acm2/codec_manager.h
@@ -0,0 +1,101 @@
+/*
+ *  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.
+ */
+
+#ifndef WEBRTC_MODULES_AUDIO_CODING_MAIN_ACM2_CODEC_MANAGER_H_
+#define WEBRTC_MODULES_AUDIO_CODING_MAIN_ACM2_CODEC_MANAGER_H_
+
+#include "webrtc/base/constructormagic.h"
+#include "webrtc/base/thread_checker.h"
+#include "webrtc/modules/audio_coding/main/acm2/acm_codec_database.h"
+#include "webrtc/modules/audio_coding/main/interface/audio_coding_module_typedefs.h"
+#include "webrtc/common_types.h"
+
+namespace webrtc {
+
+class AudioDecoder;
+
+namespace acm2 {
+
+class ACMGenericCodec;
+class AudioCodingModuleImpl;
+
+class CodecManager final {
+ public:
+  explicit CodecManager(AudioCodingModuleImpl* acm);
+  ~CodecManager();
+
+  int RegisterSendCodec(const CodecInst& send_codec);
+
+  int SendCodec(CodecInst* current_codec) const;
+
+  int RegisterReceiveCodec(const CodecInst& receive_codec);
+
+  bool SetCopyRed(bool enable);
+
+  int SetVAD(bool enable_dtx, bool enable_vad, ACMVADMode mode);
+
+  void VAD(bool* dtx_enabled, bool* vad_enabled, ACMVADMode* mode) const;
+
+  int SetCodecFEC(bool enable_codec_fec);
+
+  bool stereo_send() const { return stereo_send_; }
+
+  bool red_enabled() const { return red_enabled_; }
+
+  bool codec_fec_enabled() const { return codec_fec_enabled_; }
+
+  ACMGenericCodec* current_encoder() { return current_encoder_; }
+
+  const ACMGenericCodec* current_encoder() const { return current_encoder_; }
+
+ private:
+  void SetCngPayloadType(int sample_rate_hz, int payload_type);
+
+  void SetRedPayloadType(int sample_rate_hz, int payload_type);
+
+  // Get a pointer to AudioDecoder of the given codec. For some codecs, e.g.
+  // iSAC, encoding and decoding have to be performed on a shared
+  // codec-instance. By calling this method, we get the codec-instance that ACM
+  // owns, then pass that to NetEq. This way, we perform both encoding and
+  // decoding on the same codec-instance. Furthermore, ACM would have control
+  // over decoder functionality if required. If |codec| does not share an
+  // instance between encoder and decoder, the |*decoder| is set NULL.
+  // The field ACMCodecDB::CodecSettings.owns_decoder indicates that if a
+  // codec owns the decoder-instance. For such codecs |*decoder| should be a
+  // valid pointer, otherwise it will be NULL.
+  int GetAudioDecoder(const CodecInst& codec,
+                      int codec_id,
+                      int mirror_id,
+                      AudioDecoder** decoder);
+
+  AudioCodingModuleImpl* acm_;
+  rtc::ThreadChecker thread_checker_;
+  uint8_t cng_nb_pltype_;
+  uint8_t cng_wb_pltype_;
+  uint8_t cng_swb_pltype_;
+  uint8_t cng_fb_pltype_;
+  uint8_t red_nb_pltype_;
+  bool stereo_send_;
+  bool vad_enabled_;
+  bool dtx_enabled_;
+  ACMVADMode vad_mode_;
+  ACMGenericCodec* current_encoder_;
+  CodecInst send_codec_inst_;
+  bool red_enabled_;
+  bool codec_fec_enabled_;
+  ACMGenericCodec* codecs_[ACMCodecDB::kMaxNumCodecs];
+  int mirror_codec_idx_[ACMCodecDB::kMaxNumCodecs];
+
+  DISALLOW_COPY_AND_ASSIGN(CodecManager);
+};
+
+}  // namespace acm2
+}  // namespace webrtc
+#endif  // WEBRTC_MODULES_AUDIO_CODING_MAIN_ACM2_CODEC_MANAGER_H_
diff --git a/modules/audio_coding/main/interface/audio_coding_module.h b/modules/audio_coding/main/interface/audio_coding_module.h
index 014b9f3..796444e 100644
--- a/modules/audio_coding/main/interface/audio_coding_module.h
+++ b/modules/audio_coding/main/interface/audio_coding_module.h
@@ -191,20 +191,6 @@
   //
 
   ///////////////////////////////////////////////////////////////////////////
-  // int32_t InitializeSender()
-  // Any encoder-related state of ACM will be initialized to the
-  // same state when ACM is created. This will not interrupt or
-  // effect decoding functionality of ACM. ACM will lose all the
-  // encoding-related settings by calling this function.
-  // For instance, a send codec has to be registered again.
-  //
-  // Return value:
-  //   -1 if failed to initialize,
-  //    0 if succeeded.
-  //
-  virtual int32_t InitializeSender() = 0;
-
-  ///////////////////////////////////////////////////////////////////////////
   // int32_t ResetEncoder()
   // This API resets the states of encoder. All the encoder settings, such as
   // send-codec or VAD/DTX, will be preserved.
diff --git a/modules/audio_coding/main/test/APITest.cc b/modules/audio_coding/main/test/APITest.cc
index ccb5c59..1cdf6c7 100644
--- a/modules/audio_coding/main/test/APITest.cc
+++ b/modules/audio_coding/main/test/APITest.cc
@@ -1144,9 +1144,6 @@
         WriteLockScoped wl(_apiTestRWLock);
         *thereIsEncoder = false;
       }
-      CHECK_ERROR_MT(myACM->InitializeSender());
-      Wait(1000);
-
       // After Initialization CN is lost, re-register them
       if (AudioCodingModule::Codec("CN", &myCodec, 8000, 1) >= 0) {
         CHECK_ERROR_MT(myACM->RegisterSendCodec(myCodec));
diff --git a/modules/audio_coding/main/test/EncodeDecodeTest.cc b/modules/audio_coding/main/test/EncodeDecodeTest.cc
index b785cc3..8394bc0 100644
--- a/modules/audio_coding/main/test/EncodeDecodeTest.cc
+++ b/modules/audio_coding/main/test/EncodeDecodeTest.cc
@@ -53,7 +53,6 @@
 
 void Sender::Setup(AudioCodingModule *acm, RTPStream *rtpStream,
                    std::string in_file_name, int sample_rate, int channels) {
-  acm->InitializeSender();
   struct CodecInst sendCodec;
   int noOfCodecs = acm->NumberOfCodecs();
   int codecNo;
diff --git a/modules/audio_coding/main/test/TwoWayCommunication.cc b/modules/audio_coding/main/test/TwoWayCommunication.cc
index f4db1db..1014fc9 100644
--- a/modules/audio_coding/main/test/TwoWayCommunication.cc
+++ b/modules/audio_coding/main/test/TwoWayCommunication.cc
@@ -281,7 +281,6 @@
   // In the middle of a session with data flowing between two sides, called A
   // and B, APIs will be called, like ResetEncoder(), and the code should
   // continue to run, and be able to recover.
-  bool expect_error_add = false;
   while (!_inFileA.EndOfFile() && !_inFileB.EndOfFile()) {
     msecPassed += 10;
     EXPECT_GT(_inFileA.Read10MsData(audioFrame), 0);
@@ -290,12 +289,7 @@
 
     EXPECT_GT(_inFileB.Read10MsData(audioFrame), 0);
 
-    // Expect call to pass except for the time when no send codec is registered.
-    if (!expect_error_add) {
-      EXPECT_GE(_acmB->Add10MsData(audioFrame), 0);
-    } else {
-      EXPECT_EQ(-1, _acmB->Add10MsData(audioFrame));
-    }
+    EXPECT_GE(_acmB->Add10MsData(audioFrame), 0);
     EXPECT_GE(_acmRefB->Add10MsData(audioFrame), 0);
     EXPECT_EQ(0, _acmA->PlayoutData10Ms(outFreqHzA, &audioFrame));
     _outFileA.Write10MsData(audioFrame);
@@ -315,14 +309,11 @@
     // side B.
     if (((secPassed % 5) == 4) && (msecPassed == 0)) {
       EXPECT_EQ(0, _acmA->ResetEncoder());
-      EXPECT_EQ(0, _acmB->InitializeSender());
-      expect_error_add = true;
     }
     // Re-register send codec on side B.
     if (((secPassed % 5) == 4) && (msecPassed >= 990)) {
       EXPECT_EQ(0, _acmB->RegisterSendCodec(codecInst_B));
       EXPECT_EQ(0, _acmB->SendCodec(&dummy));
-      expect_error_add = false;
     }
     // Reset decoder on side B, and initialize receiver on side A.
     if (((secPassed % 7) == 6) && (msecPassed == 0)) {