diff --git a/api/video_codecs/BUILD.gn b/api/video_codecs/BUILD.gn
index be7194e..c8bde01 100644
--- a/api/video_codecs/BUILD.gn
+++ b/api/video_codecs/BUILD.gn
@@ -14,6 +14,7 @@
 
 rtc_source_set("video_codecs_api") {
   sources = [
+    "sdp_video_format.h",
     "video_decoder.h",
     "video_encoder.cc",
     "video_encoder.h",
diff --git a/api/video_codecs/sdp_video_format.h b/api/video_codecs/sdp_video_format.h
new file mode 100644
index 0000000..bee4bf0
--- /dev/null
+++ b/api/video_codecs/sdp_video_format.h
@@ -0,0 +1,42 @@
+/*
+ *  Copyright (c) 2017 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_API_VIDEO_CODECS_SDP_VIDEO_FORMAT_H_
+#define WEBRTC_API_VIDEO_CODECS_SDP_VIDEO_FORMAT_H_
+
+#include <map>
+#include <string>
+
+namespace webrtc {
+
+// SDP specification for a single video codec.
+// NOTE: This class is still under development and may change without notice.
+struct SdpVideoFormat {
+  using Parameters = std::map<std::string, std::string>;
+
+  explicit SdpVideoFormat(const std::string& name) : name(name) {}
+  SdpVideoFormat(const std::string& name, const Parameters& parameters)
+      : name(name), parameters(parameters) {}
+
+  friend bool operator==(const SdpVideoFormat& a, const SdpVideoFormat& b) {
+    return a.name == b.name && a.parameters == b.parameters;
+  }
+
+  friend bool operator!=(const SdpVideoFormat& a, const SdpVideoFormat& b) {
+    return !(a == b);
+  }
+
+  std::string name;
+  Parameters parameters;
+};
+
+}  // namespace webrtc
+
+#endif  // WEBRTC_API_VIDEO_CODECS_SDP_VIDEO_FORMAT_H_
diff --git a/media/BUILD.gn b/media/BUILD.gn
index 25aa1e0..9deddee 100644
--- a/media/BUILD.gn
+++ b/media/BUILD.gn
@@ -147,6 +147,8 @@
     "engine/nullwebrtcvideoengine.h",
     "engine/payload_type_mapper.cc",
     "engine/payload_type_mapper.h",
+    "engine/scopedvideodecoder.cc",
+    "engine/scopedvideodecoder.h",
     "engine/scopedvideoencoder.cc",
     "engine/scopedvideoencoder.h",
     "engine/simulcast.cc",
diff --git a/media/engine/scopedvideodecoder.cc b/media/engine/scopedvideodecoder.cc
new file mode 100644
index 0000000..b328286
--- /dev/null
+++ b/media/engine/scopedvideodecoder.cc
@@ -0,0 +1,100 @@
+/*
+ *  Copyright (c) 2017 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/media/engine/scopedvideodecoder.h"
+
+#include <vector>
+
+#include "webrtc/api/video_codecs/video_decoder.h"
+
+namespace cricket {
+
+namespace {
+
+class ScopedVideoDecoder : public webrtc::VideoDecoder {
+ public:
+  ScopedVideoDecoder(WebRtcVideoDecoderFactory* factory,
+                     webrtc::VideoDecoder* decoder);
+
+  int32_t InitDecode(const webrtc::VideoCodec* codec_settings,
+                     int32_t number_of_cores) override;
+  int32_t RegisterDecodeCompleteCallback(
+      webrtc::DecodedImageCallback* callback) override;
+  int32_t Release() override;
+  int32_t Decode(const webrtc::EncodedImage& input_image,
+                 bool missing_frames,
+                 const webrtc::RTPFragmentationHeader* fragmentation,
+                 const webrtc::CodecSpecificInfo* codec_specific_info,
+                 int64_t render_time_ms) override;
+  bool PrefersLateDecoding() const override;
+  const char* ImplementationName() const override;
+
+  ~ScopedVideoDecoder() override;
+
+ private:
+  WebRtcVideoDecoderFactory* factory_;
+  webrtc::VideoDecoder* decoder_;
+};
+
+ScopedVideoDecoder::ScopedVideoDecoder(WebRtcVideoDecoderFactory* factory,
+                                       webrtc::VideoDecoder* decoder)
+    : factory_(factory), decoder_(decoder) {}
+
+int32_t ScopedVideoDecoder::InitDecode(const webrtc::VideoCodec* codec_settings,
+                                       int32_t number_of_cores) {
+  return decoder_->InitDecode(codec_settings, number_of_cores);
+}
+
+int32_t ScopedVideoDecoder::RegisterDecodeCompleteCallback(
+    webrtc::DecodedImageCallback* callback) {
+  return decoder_->RegisterDecodeCompleteCallback(callback);
+}
+
+int32_t ScopedVideoDecoder::Release() {
+  return decoder_->Release();
+}
+
+int32_t ScopedVideoDecoder::Decode(
+    const webrtc::EncodedImage& input_image,
+    bool missing_frames,
+    const webrtc::RTPFragmentationHeader* fragmentation,
+    const webrtc::CodecSpecificInfo* codec_specific_info,
+    int64_t render_time_ms) {
+  return decoder_->Decode(input_image, missing_frames, fragmentation,
+                          codec_specific_info, render_time_ms);
+}
+
+bool ScopedVideoDecoder::PrefersLateDecoding() const {
+  return decoder_->PrefersLateDecoding();
+}
+
+const char* ScopedVideoDecoder::ImplementationName() const {
+  return decoder_->ImplementationName();
+}
+
+ScopedVideoDecoder::~ScopedVideoDecoder() {
+  factory_->DestroyVideoDecoder(decoder_);
+}
+
+}  // namespace
+
+std::unique_ptr<webrtc::VideoDecoder> CreateScopedVideoDecoder(
+    WebRtcVideoDecoderFactory* factory,
+    const VideoCodec& codec,
+    VideoDecoderParams params) {
+  webrtc::VideoDecoder* decoder =
+      factory->CreateVideoDecoderWithParams(codec, params);
+  if (!decoder)
+    return nullptr;
+  return std::unique_ptr<webrtc::VideoDecoder>(
+      new ScopedVideoDecoder(factory, decoder));
+}
+
+}  // namespace cricket
diff --git a/media/engine/scopedvideodecoder.h b/media/engine/scopedvideodecoder.h
new file mode 100644
index 0000000..c76c9fc
--- /dev/null
+++ b/media/engine/scopedvideodecoder.h
@@ -0,0 +1,34 @@
+/*
+ *  Copyright (c) 2017 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_MEDIA_ENGINE_SCOPEDVIDEODECODER_H_
+#define WEBRTC_MEDIA_ENGINE_SCOPEDVIDEODECODER_H_
+
+#include <memory>
+
+#include "webrtc/media/engine/webrtcvideodecoderfactory.h"
+
+namespace cricket {
+
+// Helper function that creates a webrtc::VideoDecoder held by an
+// std::unique_ptr instead of having to be deleted through
+// WebRtcVideoDecoderFactory::DestroyVideoDecoder. The factory passed in must
+// outlive the returned encoder.
+// TODO(andersc): This helper function will be deleted once
+// cricket::WebRtcVideoDecoderFactory is deprecated, see
+// https://bugs.chromium.org/p/webrtc/issues/detail?id=7925 for more info.
+std::unique_ptr<webrtc::VideoDecoder> CreateScopedVideoDecoder(
+    cricket::WebRtcVideoDecoderFactory* factory,
+    const VideoCodec& codec,
+    VideoDecoderParams params);
+
+}  // namespace cricket
+
+#endif  // WEBRTC_MEDIA_ENGINE_SCOPEDVIDEODECODER_H_
diff --git a/media/engine/videodecodersoftwarefallbackwrapper.cc b/media/engine/videodecodersoftwarefallbackwrapper.cc
index 6a234d5..0e7632b 100644
--- a/media/engine/videodecodersoftwarefallbackwrapper.cc
+++ b/media/engine/videodecodersoftwarefallbackwrapper.cc
@@ -22,9 +22,9 @@
 
 VideoDecoderSoftwareFallbackWrapper::VideoDecoderSoftwareFallbackWrapper(
     VideoCodecType codec_type,
-    VideoDecoder* decoder)
+    std::unique_ptr<VideoDecoder> decoder)
     : codec_type_(codec_type),
-      decoder_(decoder),
+      decoder_(std::move(decoder)),
       decoder_initialized_(false),
       callback_(nullptr) {}
 
diff --git a/media/engine/videodecodersoftwarefallbackwrapper.h b/media/engine/videodecodersoftwarefallbackwrapper.h
index 3984e1f..d6c3e0e 100644
--- a/media/engine/videodecodersoftwarefallbackwrapper.h
+++ b/media/engine/videodecodersoftwarefallbackwrapper.h
@@ -21,10 +21,10 @@
 // Class used to wrap external VideoDecoders to provide a fallback option on
 // software decoding when a hardware decoder fails to decode a stream due to
 // hardware restrictions, such as max resolution.
-class VideoDecoderSoftwareFallbackWrapper : public webrtc::VideoDecoder {
+class VideoDecoderSoftwareFallbackWrapper : public VideoDecoder {
  public:
   VideoDecoderSoftwareFallbackWrapper(VideoCodecType codec_type,
-                                      VideoDecoder* decoder);
+                                      std::unique_ptr<VideoDecoder> decoder);
 
   int32_t InitDecode(const VideoCodec* codec_settings,
                      int32_t number_of_cores) override;
@@ -47,7 +47,7 @@
   bool InitFallbackDecoder();
 
   const VideoCodecType codec_type_;
-  VideoDecoder* const decoder_;
+  std::unique_ptr<VideoDecoder> decoder_;
   bool decoder_initialized_;
 
   VideoCodec codec_settings_;
diff --git a/media/engine/videodecodersoftwarefallbackwrapper_unittest.cc b/media/engine/videodecodersoftwarefallbackwrapper_unittest.cc
index b4fc7ca..84a6a59 100644
--- a/media/engine/videodecodersoftwarefallbackwrapper_unittest.cc
+++ b/media/engine/videodecodersoftwarefallbackwrapper_unittest.cc
@@ -19,7 +19,9 @@
 class VideoDecoderSoftwareFallbackWrapperTest : public ::testing::Test {
  protected:
   VideoDecoderSoftwareFallbackWrapperTest()
-      : fallback_wrapper_(kVideoCodecVP8, &fake_decoder_) {}
+      : fake_decoder_(new CountingFakeDecoder()),
+        fallback_wrapper_(kVideoCodecVP8,
+                          std::unique_ptr<VideoDecoder>(fake_decoder_)) {}
 
   class CountingFakeDecoder : public VideoDecoder {
    public:
@@ -61,39 +63,41 @@
     int release_count_ = 0;
     int reset_count_ = 0;
   };
-  CountingFakeDecoder fake_decoder_;
+  // |fake_decoder_| is owned and released by |fallback_wrapper_|.
+  CountingFakeDecoder* fake_decoder_;
   VideoDecoderSoftwareFallbackWrapper fallback_wrapper_;
 };
 
 TEST_F(VideoDecoderSoftwareFallbackWrapperTest, InitializesDecoder) {
   VideoCodec codec = {};
   fallback_wrapper_.InitDecode(&codec, 2);
-  EXPECT_EQ(1, fake_decoder_.init_decode_count_);
+  EXPECT_EQ(1, fake_decoder_->init_decode_count_);
 
   EncodedImage encoded_image;
   encoded_image._frameType = kVideoFrameKey;
   fallback_wrapper_.Decode(encoded_image, false, nullptr, nullptr, -1);
-  EXPECT_EQ(1, fake_decoder_.init_decode_count_)
+  EXPECT_EQ(1, fake_decoder_->init_decode_count_)
       << "Initialized decoder should not be reinitialized.";
-  EXPECT_EQ(1, fake_decoder_.decode_count_);
+  EXPECT_EQ(1, fake_decoder_->decode_count_);
 }
 
 TEST_F(VideoDecoderSoftwareFallbackWrapperTest,
        UsesFallbackDecoderAfterOnInitDecodeFailure) {
   VideoCodec codec = {};
-  fake_decoder_.init_decode_return_code_ = WEBRTC_VIDEO_CODEC_FALLBACK_SOFTWARE;
+  fake_decoder_->init_decode_return_code_ =
+      WEBRTC_VIDEO_CODEC_FALLBACK_SOFTWARE;
   fallback_wrapper_.InitDecode(&codec, 2);
-  EXPECT_EQ(1, fake_decoder_.init_decode_count_);
+  EXPECT_EQ(1, fake_decoder_->init_decode_count_);
 
   EncodedImage encoded_image;
   encoded_image._frameType = kVideoFrameKey;
   fallback_wrapper_.Decode(encoded_image, false, nullptr, nullptr, -1);
-  EXPECT_EQ(2, fake_decoder_.init_decode_count_)
+  EXPECT_EQ(2, fake_decoder_->init_decode_count_)
       << "Should have attempted reinitializing the fallback decoder on "
          "keyframe.";
   // Unfortunately faking a VP8 frame is hard. Rely on no Decode -> using SW
   // decoder.
-  EXPECT_EQ(0, fake_decoder_.decode_count_)
+  EXPECT_EQ(0, fake_decoder_->decode_count_)
       << "Decoder used even though no InitDecode had succeeded.";
 }
 
@@ -103,41 +107,41 @@
   fallback_wrapper_.InitDecode(&codec, 2);
   // Unfortunately faking a VP8 frame is hard. Rely on no Decode -> using SW
   // decoder.
-  fake_decoder_.decode_return_code_ = WEBRTC_VIDEO_CODEC_FALLBACK_SOFTWARE;
+  fake_decoder_->decode_return_code_ = WEBRTC_VIDEO_CODEC_FALLBACK_SOFTWARE;
   EncodedImage encoded_image;
   fallback_wrapper_.Decode(encoded_image, false, nullptr, nullptr, -1);
-  EXPECT_EQ(1, fake_decoder_.decode_count_);
+  EXPECT_EQ(1, fake_decoder_->decode_count_);
 
   // Fail -> fake_decoder shouldn't be used anymore.
   fallback_wrapper_.Decode(encoded_image, false, nullptr, nullptr, -1);
-  EXPECT_EQ(1, fake_decoder_.decode_count_)
+  EXPECT_EQ(1, fake_decoder_->decode_count_)
       << "Decoder used even though fallback should be active.";
 
   // Should be able to recover on a keyframe.
   encoded_image._frameType = kVideoFrameKey;
-  fake_decoder_.decode_return_code_ = WEBRTC_VIDEO_CODEC_OK;
+  fake_decoder_->decode_return_code_ = WEBRTC_VIDEO_CODEC_OK;
   fallback_wrapper_.Decode(encoded_image, false, nullptr, nullptr, -1);
-  EXPECT_EQ(2, fake_decoder_.decode_count_)
+  EXPECT_EQ(2, fake_decoder_->decode_count_)
       << "Wrapper did not try to decode a keyframe using registered decoder.";
 
   encoded_image._frameType = kVideoFrameDelta;
   fallback_wrapper_.Decode(encoded_image, false, nullptr, nullptr, -1);
-  EXPECT_EQ(3, fake_decoder_.decode_count_)
+  EXPECT_EQ(3, fake_decoder_->decode_count_)
       << "Decoder not used on future delta frames.";
 }
 
 TEST_F(VideoDecoderSoftwareFallbackWrapperTest, DoesNotFallbackOnEveryError) {
   VideoCodec codec = {};
   fallback_wrapper_.InitDecode(&codec, 2);
-  fake_decoder_.decode_return_code_ = WEBRTC_VIDEO_CODEC_ERROR;
+  fake_decoder_->decode_return_code_ = WEBRTC_VIDEO_CODEC_ERROR;
   EncodedImage encoded_image;
   EXPECT_EQ(
-      fake_decoder_.decode_return_code_,
+      fake_decoder_->decode_return_code_,
       fallback_wrapper_.Decode(encoded_image, false, nullptr, nullptr, -1));
-  EXPECT_EQ(1, fake_decoder_.decode_count_);
+  EXPECT_EQ(1, fake_decoder_->decode_count_);
 
   fallback_wrapper_.Decode(encoded_image, false, nullptr, nullptr, -1);
-  EXPECT_EQ(2, fake_decoder_.decode_count_)
+  EXPECT_EQ(2, fake_decoder_->decode_count_)
       << "Decoder should be active even though previous decode failed.";
 }
 
@@ -145,15 +149,15 @@
   VideoCodec codec = {};
   fallback_wrapper_.InitDecode(&codec, 2);
   fallback_wrapper_.Release();
-  EXPECT_EQ(1, fake_decoder_.release_count_);
+  EXPECT_EQ(1, fake_decoder_->release_count_);
 
-  fake_decoder_.decode_return_code_ = WEBRTC_VIDEO_CODEC_FALLBACK_SOFTWARE;
+  fake_decoder_->decode_return_code_ = WEBRTC_VIDEO_CODEC_FALLBACK_SOFTWARE;
   EncodedImage encoded_image;
   fallback_wrapper_.Decode(encoded_image, false, nullptr, nullptr, -1);
-  EXPECT_EQ(1, fake_decoder_.release_count_)
+  EXPECT_EQ(1, fake_decoder_->release_count_)
       << "Decoder should not be released during fallback.";
   fallback_wrapper_.Release();
-  EXPECT_EQ(2, fake_decoder_.release_count_);
+  EXPECT_EQ(2, fake_decoder_->release_count_);
 }
 
 // TODO(pbos): Fake a VP8 frame well enough to actually receive a callback from
@@ -177,13 +181,13 @@
   VideoCodec codec = {};
   fallback_wrapper_.InitDecode(&codec, 2);
   fallback_wrapper_.RegisterDecodeCompleteCallback(&callback);
-  EXPECT_EQ(&callback, fake_decoder_.decode_complete_callback_);
+  EXPECT_EQ(&callback, fake_decoder_->decode_complete_callback_);
 
-  fake_decoder_.decode_return_code_ = WEBRTC_VIDEO_CODEC_FALLBACK_SOFTWARE;
+  fake_decoder_->decode_return_code_ = WEBRTC_VIDEO_CODEC_FALLBACK_SOFTWARE;
   EncodedImage encoded_image;
   fallback_wrapper_.Decode(encoded_image, false, nullptr, nullptr, -1);
   fallback_wrapper_.RegisterDecodeCompleteCallback(&callback2);
-  EXPECT_EQ(&callback2, fake_decoder_.decode_complete_callback_);
+  EXPECT_EQ(&callback2, fake_decoder_->decode_complete_callback_);
 }
 
 TEST_F(VideoDecoderSoftwareFallbackWrapperTest,
@@ -191,7 +195,7 @@
   VideoCodec codec = {};
   fallback_wrapper_.InitDecode(&codec, 2);
 
-  fake_decoder_.decode_return_code_ = WEBRTC_VIDEO_CODEC_FALLBACK_SOFTWARE;
+  fake_decoder_->decode_return_code_ = WEBRTC_VIDEO_CODEC_FALLBACK_SOFTWARE;
   EncodedImage encoded_image;
   fallback_wrapper_.Decode(encoded_image, false, nullptr, nullptr, -1);
   // Hard coded expected value since libvpx is the software implementation name
diff --git a/media/engine/webrtcvideoengine.cc b/media/engine/webrtcvideoengine.cc
index a613dc6..284eb9a 100644
--- a/media/engine/webrtcvideoengine.cc
+++ b/media/engine/webrtcvideoengine.cc
@@ -24,6 +24,7 @@
 #include "webrtc/media/engine/constants.h"
 #include "webrtc/media/engine/internaldecoderfactory.h"
 #include "webrtc/media/engine/internalencoderfactory.h"
+#include "webrtc/media/engine/scopedvideodecoder.h"
 #include "webrtc/media/engine/scopedvideoencoder.h"
 #include "webrtc/media/engine/simulcast.h"
 #include "webrtc/media/engine/simulcast_encoder_adapter.h"
@@ -71,6 +72,17 @@
   virtual std::unique_ptr<EncoderFactoryAdapter> clone() const = 0;
 };
 
+class DecoderFactoryAdapter {
+ public:
+  virtual ~DecoderFactoryAdapter() {}
+
+  virtual std::unique_ptr<webrtc::VideoDecoder> CreateVideoDecoder(
+      const VideoCodec& codec,
+      const VideoDecoderParams& decoder_params) const = 0;
+
+  virtual std::unique_ptr<DecoderFactoryAdapter> clone() const = 0;
+};
+
 namespace {
 
 // Wraps cricket::WebRtcVideoEncoderFactory* into common EncoderFactoryAdapter
@@ -104,6 +116,31 @@
   WebRtcVideoEncoderFactory* const external_encoder_factory_;
 };
 
+class CricketDecoderFactoryAdapter : public DecoderFactoryAdapter {
+ public:
+  explicit CricketDecoderFactoryAdapter(
+      WebRtcVideoDecoderFactory* external_decoder_factory)
+      : internal_decoder_factory_(new InternalDecoderFactory()),
+        external_decoder_factory_(external_decoder_factory) {}
+
+ private:
+  explicit CricketDecoderFactoryAdapter(
+      const CricketDecoderFactoryAdapter& other)
+      : CricketDecoderFactoryAdapter(other.external_decoder_factory_) {}
+
+  std::unique_ptr<webrtc::VideoDecoder> CreateVideoDecoder(
+      const VideoCodec& codec,
+      const VideoDecoderParams& decoder_params) const override;
+
+  std::unique_ptr<DecoderFactoryAdapter> clone() const override {
+    return std::unique_ptr<DecoderFactoryAdapter>(
+        new CricketDecoderFactoryAdapter(*this));
+  }
+
+  const std::unique_ptr<WebRtcVideoDecoderFactory> internal_decoder_factory_;
+  WebRtcVideoDecoderFactory* const external_decoder_factory_;
+};
+
 // If this field trial is enabled, we will enable sending FlexFEC and disable
 // sending ULPFEC whenever the former has been negotiated in the SDPs.
 bool IsFlexfecFieldTrialEnabled() {
@@ -367,7 +404,8 @@
 
 WebRtcVideoEngine::WebRtcVideoEngine()
     : initialized_(false),
-      external_decoder_factory_(NULL),
+      decoder_factory_(new CricketDecoderFactoryAdapter(
+          nullptr /* external_decoder_factory */)),
       encoder_factory_(new CricketEncoderFactoryAdapter(
           nullptr /* external_encoder_factory */)) {
   LOG(LS_INFO) << "WebRtcVideoEngine::WebRtcVideoEngine()";
@@ -389,7 +427,7 @@
   RTC_DCHECK(initialized_);
   LOG(LS_INFO) << "CreateChannel. Options: " << options.ToString();
   return new WebRtcVideoChannel(call, config, options, *encoder_factory_,
-                                external_decoder_factory_);
+                                *decoder_factory_);
 }
 
 std::vector<VideoCodec> WebRtcVideoEngine::codecs() const {
@@ -425,7 +463,7 @@
 void WebRtcVideoEngine::SetExternalDecoderFactory(
     WebRtcVideoDecoderFactory* decoder_factory) {
   RTC_DCHECK(!initialized_);
-  external_decoder_factory_ = decoder_factory;
+  decoder_factory_.reset(new CricketDecoderFactoryAdapter(decoder_factory));
 }
 
 void WebRtcVideoEngine::SetExternalEncoderFactory(
@@ -503,13 +541,13 @@
     const MediaConfig& config,
     const VideoOptions& options,
     const EncoderFactoryAdapter& encoder_factory,
-    WebRtcVideoDecoderFactory* external_decoder_factory)
+    const DecoderFactoryAdapter& decoder_factory)
     : VideoMediaChannel(config),
       call_(call),
       unsignalled_ssrc_handler_(&default_unsignalled_ssrc_handler_),
       video_config_(config.video),
       encoder_factory_(encoder_factory.clone()),
-      external_decoder_factory_(external_decoder_factory),
+      decoder_factory_(decoder_factory.clone()),
       default_send_options_(options),
       last_stats_log_ms_(-1) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
@@ -1125,7 +1163,7 @@
   config.sync_group = sp.sync_label;
 
   receive_streams_[ssrc] = new WebRtcVideoReceiveStream(
-      call_, sp, std::move(config), external_decoder_factory_, default_stream,
+      call_, sp, std::move(config), *decoder_factory_, default_stream,
       recv_codecs_, flexfec_config);
 
   return true;
@@ -2065,7 +2103,7 @@
     webrtc::Call* call,
     const StreamParams& sp,
     webrtc::VideoReceiveStream::Config config,
-    WebRtcVideoDecoderFactory* external_decoder_factory,
+    const DecoderFactoryAdapter& decoder_factory,
     bool default_stream,
     const std::vector<VideoCodecSettings>& recv_codecs,
     const webrtc::FlexfecReceiveStream::Config& flexfec_config)
@@ -2076,12 +2114,12 @@
       config_(std::move(config)),
       flexfec_config_(flexfec_config),
       flexfec_stream_(nullptr),
-      external_decoder_factory_(external_decoder_factory),
+      decoder_factory_(decoder_factory.clone()),
       sink_(NULL),
       first_frame_timestamp_(-1),
       estimated_remote_start_ntp_time_ms_(0) {
   config_.renderer = this;
-  std::vector<AllocatedDecoder> old_decoders;
+  DecoderMap old_decoders;
   ConfigureCodecs(recv_codecs, &old_decoders);
   ConfigureFlexfecCodec(flexfec_config.payload_type);
   MaybeRecreateWebRtcFlexfecStream();
@@ -2089,28 +2127,13 @@
   RTC_DCHECK(old_decoders.empty());
 }
 
-WebRtcVideoChannel::WebRtcVideoReceiveStream::AllocatedDecoder::
-    AllocatedDecoder(webrtc::VideoDecoder* decoder,
-                     webrtc::VideoCodecType type,
-                     bool external)
-    : decoder(decoder),
-      external_decoder(nullptr),
-      type(type),
-      external(external) {
-  if (external) {
-    external_decoder = decoder;
-    this->decoder =
-        new webrtc::VideoDecoderSoftwareFallbackWrapper(type, external_decoder);
-  }
-}
-
 WebRtcVideoChannel::WebRtcVideoReceiveStream::~WebRtcVideoReceiveStream() {
   if (flexfec_stream_) {
     MaybeDissociateFlexfecFromVideo();
     call_->DestroyFlexfecReceiveStream(flexfec_stream_);
   }
   call_->DestroyVideoReceiveStream(stream_);
-  ClearDecoders(&allocated_decoders_);
+  allocated_decoders_.clear();
 }
 
 const std::vector<uint32_t>&
@@ -2131,56 +2154,66 @@
   }
 }
 
-WebRtcVideoChannel::WebRtcVideoReceiveStream::AllocatedDecoder
-WebRtcVideoChannel::WebRtcVideoReceiveStream::CreateOrReuseVideoDecoder(
-    std::vector<AllocatedDecoder>* old_decoders,
-    const VideoCodec& codec) {
-  webrtc::VideoCodecType type = webrtc::PayloadStringToCodecType(codec.name);
-
-  const auto& found = std::find_if(
-      old_decoders->begin(), old_decoders->end(),
-      [type](const AllocatedDecoder decoder) { return decoder.type == type; });
-  if (found != old_decoders->end()) {
-    AllocatedDecoder decoder = *found;
-    old_decoders->erase(found);
-    return decoder;
-  }
-
-  if (external_decoder_factory_ != NULL) {
-    webrtc::VideoDecoder* decoder =
-        external_decoder_factory_->CreateVideoDecoderWithParams(
-            codec, {stream_params_.id});
-    if (decoder != NULL) {
-      return AllocatedDecoder(decoder, type, true /* is_external */);
+std::unique_ptr<webrtc::VideoDecoder>
+CricketDecoderFactoryAdapter::CreateVideoDecoder(
+    const VideoCodec& codec,
+    const VideoDecoderParams& decoder_params) const {
+  if (external_decoder_factory_ != nullptr) {
+    std::unique_ptr<webrtc::VideoDecoder> external_decoder =
+        CreateScopedVideoDecoder(external_decoder_factory_, codec,
+                                 decoder_params);
+    if (external_decoder) {
+      webrtc::VideoCodecType type =
+          webrtc::PayloadStringToCodecType(codec.name);
+      std::unique_ptr<webrtc::VideoDecoder> internal_decoder(
+          new webrtc::VideoDecoderSoftwareFallbackWrapper(
+              type, std::move(external_decoder)));
+      return internal_decoder;
     }
   }
 
-  InternalDecoderFactory internal_decoder_factory;
-  return AllocatedDecoder(internal_decoder_factory.CreateVideoDecoderWithParams(
-                              codec, {stream_params_.id}),
-                          type, false /* is_external */);
+  std::unique_ptr<webrtc::VideoDecoder> internal_decoder(
+      internal_decoder_factory_->CreateVideoDecoderWithParams(codec,
+                                                              decoder_params));
+  return internal_decoder;
 }
 
 void WebRtcVideoChannel::WebRtcVideoReceiveStream::ConfigureCodecs(
     const std::vector<VideoCodecSettings>& recv_codecs,
-    std::vector<AllocatedDecoder>* old_decoders) {
-  *old_decoders = allocated_decoders_;
-  allocated_decoders_.clear();
+    DecoderMap* old_decoders) {
+  *old_decoders = std::move(allocated_decoders_);
   config_.decoders.clear();
   config_.rtp.rtx_associated_payload_types.clear();
   for (const auto& recv_codec : recv_codecs) {
-    AllocatedDecoder allocated_decoder =
-        CreateOrReuseVideoDecoder(old_decoders, recv_codec.codec);
-    allocated_decoders_.push_back(allocated_decoder);
+    webrtc::SdpVideoFormat video_format(recv_codec.codec.name,
+                                        recv_codec.codec.params);
+    std::unique_ptr<webrtc::VideoDecoder> new_decoder;
+
+    auto it = old_decoders->find(video_format);
+    if (it != old_decoders->end()) {
+      new_decoder = std::move(it->second);
+      old_decoders->erase(it);
+    }
+
+    if (!new_decoder) {
+      new_decoder = decoder_factory_->CreateVideoDecoder(recv_codec.codec,
+                                                         {stream_params_.id});
+    }
 
     webrtc::VideoReceiveStream::Decoder decoder;
-    decoder.decoder = allocated_decoder.decoder;
+    decoder.decoder = new_decoder.get();
     decoder.payload_type = recv_codec.codec.id;
     decoder.payload_name = recv_codec.codec.name;
     decoder.codec_params = recv_codec.codec.params;
     config_.decoders.push_back(decoder);
     config_.rtp.rtx_associated_payload_types[recv_codec.rtx_payload_type] =
         recv_codec.codec.id;
+
+    const bool did_insert =
+        allocated_decoders_
+            .insert(std::make_pair(video_format, std::move(new_decoder)))
+            .second;
+    RTC_CHECK(did_insert);
   }
 
   config_.rtp.ulpfec = recv_codecs.front().ulpfec;
@@ -2257,7 +2290,7 @@
     const ChangedRecvParameters& params) {
   bool video_needs_recreation = false;
   bool flexfec_needs_recreation = false;
-  std::vector<AllocatedDecoder> old_decoders;
+  DecoderMap old_decoders;
   if (params.codec_settings) {
     ConfigureCodecs(*params.codec_settings, &old_decoders);
     video_needs_recreation = true;
@@ -2281,7 +2314,6 @@
     LOG(LS_INFO)
         << "RecreateWebRtcVideoStream (recv) because of SetRecvParameters";
     RecreateWebRtcVideoStream();
-    ClearDecoders(&old_decoders);
   }
 }
 
@@ -2326,16 +2358,6 @@
   }
 }
 
-void WebRtcVideoChannel::WebRtcVideoReceiveStream::ClearDecoders(
-    std::vector<AllocatedDecoder>* allocated_decoders) {
-  for (auto& dec : *allocated_decoders) {
-    if (dec.external)
-      external_decoder_factory_->DestroyVideoDecoder(dec.external_decoder);
-    delete dec.decoder;
-  }
-  allocated_decoders->clear();
-}
-
 void WebRtcVideoChannel::WebRtcVideoReceiveStream::OnFrame(
     const webrtc::VideoFrame& frame) {
   rtc::CritScope crit(&sink_lock_);
diff --git a/media/engine/webrtcvideoengine.h b/media/engine/webrtcvideoengine.h
index 81a85c8..e61f422 100644
--- a/media/engine/webrtcvideoengine.h
+++ b/media/engine/webrtcvideoengine.h
@@ -20,6 +20,7 @@
 #include "webrtc/api/call/transport.h"
 #include "webrtc/api/optional.h"
 #include "webrtc/api/video/video_frame.h"
+#include "webrtc/api/video_codecs/sdp_video_format.h"
 #include "webrtc/call/call.h"
 #include "webrtc/call/flexfec_receive_stream.h"
 #include "webrtc/call/video_receive_stream.h"
@@ -47,6 +48,7 @@
 
 namespace cricket {
 
+class DecoderFactoryAdapter;
 class EncoderFactoryAdapter;
 class VideoCapturer;
 class VideoProcessor;
@@ -121,7 +123,7 @@
  private:
   bool initialized_;
 
-  WebRtcVideoDecoderFactory* external_decoder_factory_;
+  std::unique_ptr<DecoderFactoryAdapter> decoder_factory_;
   std::unique_ptr<EncoderFactoryAdapter> encoder_factory_;
 };
 
@@ -131,7 +133,7 @@
                      const MediaConfig& config,
                      const VideoOptions& options,
                      const EncoderFactoryAdapter& encoder_factory,
-                     WebRtcVideoDecoderFactory* external_decoder_factory);
+                     const DecoderFactoryAdapter& decoder_factory);
   ~WebRtcVideoChannel() override;
 
   // VideoMediaChannel implementation
@@ -369,7 +371,7 @@
         webrtc::Call* call,
         const StreamParams& sp,
         webrtc::VideoReceiveStream::Config config,
-        WebRtcVideoDecoderFactory* external_decoder_factory,
+        const DecoderFactoryAdapter& decoder_factory,
         bool default_stream,
         const std::vector<VideoCodecSettings>& recv_codecs,
         const webrtc::FlexfecReceiveStream::Config& flexfec_config);
@@ -394,16 +396,17 @@
     VideoReceiverInfo GetVideoReceiverInfo(bool log_stats);
 
    private:
-    struct AllocatedDecoder {
-      AllocatedDecoder(webrtc::VideoDecoder* decoder,
-                       webrtc::VideoCodecType type,
-                       bool external);
-      webrtc::VideoDecoder* decoder;
-      // Decoder wrapped into a fallback decoder to permit software fallback.
-      webrtc::VideoDecoder* external_decoder;
-      webrtc::VideoCodecType type;
-      bool external;
+    struct SdpVideoFormatCompare {
+      bool operator()(const webrtc::SdpVideoFormat& lhs,
+                      const webrtc::SdpVideoFormat& rhs) const {
+        return std::tie(lhs.name, lhs.parameters) <
+               std::tie(rhs.name, rhs.parameters);
+      }
     };
+    typedef std::map<webrtc::SdpVideoFormat,
+                     std::unique_ptr<webrtc::VideoDecoder>,
+                     SdpVideoFormatCompare>
+        DecoderMap;
 
     void RecreateWebRtcVideoStream();
     void MaybeRecreateWebRtcFlexfecStream();
@@ -412,12 +415,8 @@
     void MaybeDissociateFlexfecFromVideo();
 
     void ConfigureCodecs(const std::vector<VideoCodecSettings>& recv_codecs,
-                         std::vector<AllocatedDecoder>* old_codecs);
+                         DecoderMap* old_codecs);
     void ConfigureFlexfecCodec(int flexfec_payload_type);
-    AllocatedDecoder CreateOrReuseVideoDecoder(
-        std::vector<AllocatedDecoder>* old_decoder,
-        const VideoCodec& codec);
-    void ClearDecoders(std::vector<AllocatedDecoder>* allocated_decoders);
 
     std::string GetCodecNameFromPayloadType(int payload_type);
 
@@ -433,8 +432,8 @@
     webrtc::FlexfecReceiveStream::Config flexfec_config_;
     webrtc::FlexfecReceiveStream* flexfec_stream_;
 
-    WebRtcVideoDecoderFactory* const external_decoder_factory_;
-    std::vector<AllocatedDecoder> allocated_decoders_;
+    std::unique_ptr<DecoderFactoryAdapter> decoder_factory_;
+    DecoderMap allocated_decoders_;
 
     rtc::CriticalSection sink_lock_;
     rtc::VideoSinkInterface<webrtc::VideoFrame>* sink_
@@ -498,7 +497,7 @@
   rtc::Optional<std::vector<webrtc::RtpExtension>> send_rtp_extensions_;
 
   std::unique_ptr<EncoderFactoryAdapter> encoder_factory_;
-  WebRtcVideoDecoderFactory* const external_decoder_factory_;
+  std::unique_ptr<DecoderFactoryAdapter> decoder_factory_;
   std::vector<VideoCodecSettings> recv_codecs_;
   std::vector<webrtc::RtpExtension> recv_rtp_extensions_;
   // See reason for keeping track of the FlexFEC payload type separately in