Built in video codec factories.

To prepare for making the software codecs optional and injectable, these
codec factories provide a way to pass in identical factories as were the
default old behaviour.

Bug: webrtc:7925
Change-Id: I0c70fa3c56c999e9d1af6e172eff2fbba849e921
Reviewed-on: https://webrtc-review.googlesource.com/71162
Commit-Queue: Anders Carlsson <andersc@webrtc.org>
Reviewed-by: Magnus Jedvert <magjed@webrtc.org>
Reviewed-by: Taylor Brandstetter <deadbeef@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#23096}

api/video_codecs/BUILD.gn

@@ -35,3 +35,40 @@ rtc_source_set("video_codecs_api") {
     "../../rtc_base:rtc_base_approved",
   ]
 }
+
+rtc_static_library("builtin_video_decoder_factory") {
+  visibility = [ "*" ]
+  allow_poison = [
+    "audio_codecs",  # TODO(bugs.webrtc.org/8396): Remove.
+    "software_video_codecs",
+  ]
+  sources = [
+    "builtin_video_decoder_factory.cc",
+    "builtin_video_decoder_factory.h",
+  ]
+
+  deps = [
+    ":video_codecs_api",
+    "../../media:rtc_internal_video_codecs",
+    "../../rtc_base:ptr_util",
+  ]
+}
+
+rtc_static_library("builtin_video_encoder_factory") {
+  visibility = [ "*" ]
+  allow_poison = [
+    "audio_codecs",  # TODO(bugs.webrtc.org/8396): Remove.
+    "software_video_codecs",
+  ]
+  sources = [
+    "builtin_video_encoder_factory.cc",
+    "builtin_video_encoder_factory.h",
+  ]
+
+  deps = [
+    ":video_codecs_api",
+    "../../media:rtc_internal_video_codecs",
+    "../../media:rtc_media_base",
+    "../../rtc_base:ptr_util",
+  ]
+}

api/video_codecs/builtin_video_decoder_factory.cc

@@ -0,0 +1,22 @@
+/*
+ *  Copyright (c) 2018 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 "api/video_codecs/builtin_video_decoder_factory.h"
+
+#include "media/engine/internaldecoderfactory.h"
+#include "rtc_base/ptr_util.h"
+
+namespace webrtc {
+
+std::unique_ptr<VideoDecoderFactory> CreateBuiltinVideoDecoderFactory() {
+  return rtc::MakeUnique<InternalDecoderFactory>();
+}
+
+}  // namespace webrtc

api/video_codecs/builtin_video_decoder_factory.h

@@ -0,0 +1,25 @@
+/*
+ *  Copyright (c) 2018 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 API_VIDEO_CODECS_BUILTIN_VIDEO_DECODER_FACTORY_H_
+#define API_VIDEO_CODECS_BUILTIN_VIDEO_DECODER_FACTORY_H_
+
+#include <memory>
+
+#include "api/video_codecs/video_decoder_factory.h"
+
+namespace webrtc {
+
+// Creates a new factory that can create the built-in types of video decoders.
+std::unique_ptr<VideoDecoderFactory> CreateBuiltinVideoDecoderFactory();
+
+}  // namespace webrtc
+
+#endif  // API_VIDEO_CODECS_BUILTIN_VIDEO_DECODER_FACTORY_H_

api/video_codecs/builtin_video_encoder_factory.cc

@@ -0,0 +1,85 @@
+/*
+ *  Copyright (c) 2018 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 "api/video_codecs/builtin_video_encoder_factory.h"
+
+#include <vector>
+
+#include "api/video_codecs/sdp_video_format.h"
+#include "media/base/codec.h"
+#include "media/base/mediaconstants.h"
+#include "media/engine/internalencoderfactory.h"
+#include "media/engine/vp8_encoder_simulcast_proxy.h"
+#include "rtc_base/ptr_util.h"
+
+namespace webrtc {
+
+namespace {
+
+bool IsFormatSupported(const std::vector<SdpVideoFormat>& supported_formats,
+                       const SdpVideoFormat& format) {
+  for (const SdpVideoFormat& supported_format : supported_formats) {
+    if (cricket::IsSameCodec(format.name, format.parameters,
+                             supported_format.name,
+                             supported_format.parameters)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// This class wraps the internal factory and adds simulcast.
+class BuiltinVideoEncoderFactory : public VideoEncoderFactory {
+ public:
+  BuiltinVideoEncoderFactory()
+      : internal_encoder_factory_(new InternalEncoderFactory()) {}
+
+  VideoEncoderFactory::CodecInfo QueryVideoEncoder(
+      const SdpVideoFormat& format) const override {
+    // Format must be one of the internal formats.
+    RTC_DCHECK(IsFormatSupported(
+        internal_encoder_factory_->GetSupportedFormats(), format));
+    VideoEncoderFactory::CodecInfo info;
+    info.has_internal_source = false;
+    info.is_hardware_accelerated = false;
+    return info;
+  }
+
+  std::unique_ptr<VideoEncoder> CreateVideoEncoder(
+      const SdpVideoFormat& format) override {
+    // Try creating internal encoder.
+    std::unique_ptr<VideoEncoder> internal_encoder;
+    if (IsFormatSupported(internal_encoder_factory_->GetSupportedFormats(),
+                          format)) {
+      internal_encoder =
+          cricket::CodecNamesEq(format.name.c_str(), cricket::kVp8CodecName)
+              ? rtc::MakeUnique<VP8EncoderSimulcastProxy>(
+                    internal_encoder_factory_.get())
+              : internal_encoder_factory_->CreateVideoEncoder(format);
+    }
+
+    return internal_encoder;
+  }
+
+  std::vector<SdpVideoFormat> GetSupportedFormats() const override {
+    return internal_encoder_factory_->GetSupportedFormats();
+  }
+
+ private:
+  const std::unique_ptr<VideoEncoderFactory> internal_encoder_factory_;
+};
+
+}  // namespace
+
+std::unique_ptr<VideoEncoderFactory> CreateBuiltinVideoEncoderFactory() {
+  return rtc::MakeUnique<BuiltinVideoEncoderFactory>();
+}
+
+}  // namespace webrtc

api/video_codecs/builtin_video_encoder_factory.h

@@ -0,0 +1,26 @@
+/*
+ *  Copyright (c) 2018 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 API_VIDEO_CODECS_BUILTIN_VIDEO_ENCODER_FACTORY_H_
+#define API_VIDEO_CODECS_BUILTIN_VIDEO_ENCODER_FACTORY_H_
+
+#include <memory>
+
+#include "api/video_codecs/video_encoder_factory.h"
+
+namespace webrtc {
+
+// Creates a new factory that can create the built-in types of video encoders.
+// The factory has simulcast support for VP8.
+std::unique_ptr<VideoEncoderFactory> CreateBuiltinVideoEncoderFactory();
+
+}  // namespace webrtc
+
+#endif  // API_VIDEO_CODECS_BUILTIN_VIDEO_ENCODER_FACTORY_H_

examples/BUILD.gn

@@ -670,7 +670,11 @@ if (is_linux || is_win) {
       "../api:video_frame_api",
       "../api/audio_codecs:builtin_audio_decoder_factory",
       "../api/audio_codecs:builtin_audio_encoder_factory",
+      "../api/video_codecs:builtin_video_decoder_factory",
+      "../api/video_codecs:builtin_video_encoder_factory",
       "../media:rtc_audio_video",
+      "../modules/audio_device:audio_device",
+      "../modules/audio_processing:audio_processing",
       "../modules/video_capture:video_capture_module",
       "../pc:libjingle_peerconnection",
       "../rtc_base:rtc_base",

examples/peerconnection/client/conductor.cc

@@ -17,8 +17,12 @@
 #include "api/audio_codecs/builtin_audio_decoder_factory.h"
 #include "api/audio_codecs/builtin_audio_encoder_factory.h"
 #include "api/test/fakeconstraints.h"
+#include "api/video_codecs/builtin_video_decoder_factory.h"
+#include "api/video_codecs/builtin_video_encoder_factory.h"
 #include "examples/peerconnection/client/defaults.h"
 #include "media/engine/webrtcvideocapturerfactory.h"
+#include "modules/audio_device/include/audio_device.h"
+#include "modules/audio_processing/include/audio_processing.h"
 #include "modules/video_capture/video_capture_factory.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/json.h"
@@ -73,8 +77,13 @@ bool Conductor::InitializePeerConnection() {
   RTC_DCHECK(!peer_connection_);
 
   peer_connection_factory_ = webrtc::CreatePeerConnectionFactory(
+      nullptr /* network_thread */, nullptr /* worker_thread */,
+      nullptr /* signaling_thread */, nullptr /* default_adm */,
       webrtc::CreateBuiltinAudioEncoderFactory(),
-      webrtc::CreateBuiltinAudioDecoderFactory());
+      webrtc::CreateBuiltinAudioDecoderFactory(),
+      webrtc::CreateBuiltinVideoEncoderFactory(),
+      webrtc::CreateBuiltinVideoDecoderFactory(), nullptr /* audio_mixer */,
+      nullptr /* audio_processing */);
 
   if (!peer_connection_factory_) {
     main_wnd_->MessageBox("Error",

media/BUILD.gn

@@ -486,6 +486,7 @@ if (rtc_include_tests) {
       "engine/fakewebrtcdeviceinfo.h",
       "engine/fakewebrtcvcmfactory.h",
       "engine/fakewebrtcvideocapturemodule.h",
+      "engine/fakewebrtcvideoengine.cc",
       "engine/fakewebrtcvideoengine.h",
     ]
 

media/engine/fakewebrtcvideoengine.cc

@@ -0,0 +1,326 @@
+/*
+ *  Copyright (c) 2018 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 "media/engine/fakewebrtcvideoengine.h"
+
+#include "media/base/codec.h"
+#include "media/engine/simulcast_encoder_adapter.h"
+#include "media/engine/vp8_encoder_simulcast_proxy.h"
+#include "media/engine/webrtcvideodecoderfactory.h"
+#include "media/engine/webrtcvideoencoderfactory.h"
+#include "modules/video_coding/include/video_error_codes.h"
+#include "rtc_base/basictypes.h"
+#include "rtc_base/gunit.h"
+#include "rtc_base/stringutils.h"
+
+namespace cricket {
+
+namespace {
+
+static const int kEventTimeoutMs = 10000;
+
+bool IsFormatSupported(
+    const std::vector<webrtc::SdpVideoFormat>& supported_formats,
+    const webrtc::SdpVideoFormat& format) {
+  for (const webrtc::SdpVideoFormat& supported_format : supported_formats) {
+    if (IsSameCodec(format.name, format.parameters, supported_format.name,
+                    supported_format.parameters)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+}  // namespace
+
+// Decoder.
+FakeWebRtcVideoDecoder::FakeWebRtcVideoDecoder(
+    FakeWebRtcVideoDecoderFactory* factory)
+    : num_frames_received_(0), factory_(factory) {}
+
+FakeWebRtcVideoDecoder::~FakeWebRtcVideoDecoder() {
+  if (factory_) {
+    factory_->DecoderDestroyed(this);
+  }
+}
+
+int32_t FakeWebRtcVideoDecoder::InitDecode(const webrtc::VideoCodec*, int32_t) {
+  return WEBRTC_VIDEO_CODEC_OK;
+}
+
+int32_t FakeWebRtcVideoDecoder::Decode(const webrtc::EncodedImage&,
+                                       bool,
+                                       const webrtc::RTPFragmentationHeader*,
+                                       const webrtc::CodecSpecificInfo*,
+                                       int64_t) {
+  num_frames_received_++;
+  return WEBRTC_VIDEO_CODEC_OK;
+}
+
+int32_t FakeWebRtcVideoDecoder::RegisterDecodeCompleteCallback(
+    webrtc::DecodedImageCallback*) {
+  return WEBRTC_VIDEO_CODEC_OK;
+}
+
+int32_t FakeWebRtcVideoDecoder::Release() {
+  return WEBRTC_VIDEO_CODEC_OK;
+}
+
+int FakeWebRtcVideoDecoder::GetNumFramesReceived() const {
+  return num_frames_received_;
+}
+
+// Decoder factory.
+FakeWebRtcVideoDecoderFactory::FakeWebRtcVideoDecoderFactory()
+    : num_created_decoders_(0),
+      internal_decoder_factory_(new webrtc::InternalDecoderFactory()) {}
+
+FakeWebRtcVideoDecoderFactory::~FakeWebRtcVideoDecoderFactory() {
+  delete internal_decoder_factory_;
+}
+
+std::vector<webrtc::SdpVideoFormat>
+FakeWebRtcVideoDecoderFactory::GetSupportedFormats() const {
+  std::vector<webrtc::SdpVideoFormat> formats =
+      internal_decoder_factory_->GetSupportedFormats();
+
+  // Add external codecs.
+  for (const webrtc::SdpVideoFormat& format : supported_codec_formats_) {
+    // Don't add same codec twice.
+    if (!IsFormatSupported(formats, format))
+      formats.push_back(format);
+  }
+
+  return formats;
+}
+
+std::unique_ptr<webrtc::VideoDecoder>
+FakeWebRtcVideoDecoderFactory::CreateVideoDecoder(
+    const webrtc::SdpVideoFormat& format) {
+  if (IsFormatSupported(supported_codec_formats_, format)) {
+    num_created_decoders_++;
+    std::unique_ptr<FakeWebRtcVideoDecoder> decoder =
+        rtc::MakeUnique<FakeWebRtcVideoDecoder>(this);
+    decoders_.push_back(decoder.get());
+    return decoder;
+  } else {
+    return internal_decoder_factory_->CreateVideoDecoder(format);
+  }
+}
+
+void FakeWebRtcVideoDecoderFactory::DecoderDestroyed(
+    FakeWebRtcVideoDecoder* decoder) {
+  decoders_.erase(std::remove(decoders_.begin(), decoders_.end(), decoder),
+                  decoders_.end());
+}
+
+void FakeWebRtcVideoDecoderFactory::AddSupportedVideoCodecType(
+    const webrtc::SdpVideoFormat& format) {
+  supported_codec_formats_.push_back(format);
+}
+
+int FakeWebRtcVideoDecoderFactory::GetNumCreatedDecoders() {
+  return num_created_decoders_;
+}
+
+const std::vector<FakeWebRtcVideoDecoder*>&
+FakeWebRtcVideoDecoderFactory::decoders() {
+  return decoders_;
+}
+
+// Encoder.
+FakeWebRtcVideoEncoder::FakeWebRtcVideoEncoder(
+    FakeWebRtcVideoEncoderFactory* factory)
+    : init_encode_event_(false, false),
+      num_frames_encoded_(0),
+      factory_(factory) {}
+
+FakeWebRtcVideoEncoder::~FakeWebRtcVideoEncoder() {
+  if (factory_) {
+    factory_->EncoderDestroyed(this);
+  }
+}
+
+int32_t FakeWebRtcVideoEncoder::InitEncode(
+    const webrtc::VideoCodec* codecSettings,
+    int32_t numberOfCores,
+    size_t maxPayloadSize) {
+  rtc::CritScope lock(&crit_);
+  codec_settings_ = *codecSettings;
+  init_encode_event_.Set();
+  return WEBRTC_VIDEO_CODEC_OK;
+}
+
+int32_t FakeWebRtcVideoEncoder::Encode(
+    const webrtc::VideoFrame& inputImage,
+    const webrtc::CodecSpecificInfo* codecSpecificInfo,
+    const std::vector<webrtc::FrameType>* frame_types) {
+  rtc::CritScope lock(&crit_);
+  ++num_frames_encoded_;
+  init_encode_event_.Set();
+  return WEBRTC_VIDEO_CODEC_OK;
+}
+
+int32_t FakeWebRtcVideoEncoder::RegisterEncodeCompleteCallback(
+    webrtc::EncodedImageCallback* callback) {
+  return WEBRTC_VIDEO_CODEC_OK;
+}
+
+int32_t FakeWebRtcVideoEncoder::Release() {
+  return WEBRTC_VIDEO_CODEC_OK;
+}
+
+int32_t FakeWebRtcVideoEncoder::SetChannelParameters(uint32_t packetLoss,
+                                                     int64_t rtt) {
+  return WEBRTC_VIDEO_CODEC_OK;
+}
+
+int32_t FakeWebRtcVideoEncoder::SetRateAllocation(
+    const webrtc::VideoBitrateAllocation& allocation,
+    uint32_t framerate) {
+  return WEBRTC_VIDEO_CODEC_OK;
+}
+
+bool FakeWebRtcVideoEncoder::WaitForInitEncode() {
+  return init_encode_event_.Wait(kEventTimeoutMs);
+}
+
+webrtc::VideoCodec FakeWebRtcVideoEncoder::GetCodecSettings() {
+  rtc::CritScope lock(&crit_);
+  return codec_settings_;
+}
+
+int FakeWebRtcVideoEncoder::GetNumEncodedFrames() {
+  rtc::CritScope lock(&crit_);
+  return num_frames_encoded_;
+}
+
+// Video encoder factory.
+FakeWebRtcVideoEncoderFactory::FakeWebRtcVideoEncoderFactory()
+    : created_video_encoder_event_(false, false),
+      num_created_encoders_(0),
+      encoders_have_internal_sources_(false),
+      internal_encoder_factory_(new webrtc::InternalEncoderFactory()),
+      vp8_factory_mode_(false) {}
+
+FakeWebRtcVideoEncoderFactory::~FakeWebRtcVideoEncoderFactory() {
+  delete internal_encoder_factory_;
+}
+
+std::vector<webrtc::SdpVideoFormat>
+FakeWebRtcVideoEncoderFactory::GetSupportedFormats() const {
+  std::vector<webrtc::SdpVideoFormat> formats =
+      internal_encoder_factory_->GetSupportedFormats();
+
+  // Add external codecs.
+  for (const webrtc::SdpVideoFormat& format : formats_) {
+    // Don't add same codec twice.
+    if (!IsFormatSupported(formats, format))
+      formats.push_back(format);
+  }
+
+  return formats;
+}
+
+std::unique_ptr<webrtc::VideoEncoder>
+FakeWebRtcVideoEncoderFactory::CreateVideoEncoder(
+    const webrtc::SdpVideoFormat& format) {
+  rtc::CritScope lock(&crit_);
+  std::unique_ptr<webrtc::VideoEncoder> encoder;
+  if (IsFormatSupported(formats_, format)) {
+    if (CodecNamesEq(format.name.c_str(), kVp8CodecName) &&
+        !vp8_factory_mode_) {
+      // The simulcast adapter will ask this factory for multiple VP8
+      // encoders. Enter vp8_factory_mode so that we now create these encoders
+      // instead of more adapters.
+      vp8_factory_mode_ = true;
+      encoder = rtc::MakeUnique<webrtc::SimulcastEncoderAdapter>(this);
+    } else {
+      num_created_encoders_++;
+      created_video_encoder_event_.Set();
+      encoder = rtc::MakeUnique<FakeWebRtcVideoEncoder>(this);
+      encoders_.push_back(static_cast<FakeWebRtcVideoEncoder*>(encoder.get()));
+    }
+  } else {
+    RTC_LOG(LS_INFO) << "FakeWebRtcVideoEncoderFactory: no match for "
+                     << format.name;
+    for (auto elem : format.parameters) {
+      RTC_LOG(LS_INFO) << elem.first << " " << elem.second;
+    }
+    encoder = CodecNamesEq(format.name.c_str(), kVp8CodecName)
+                  ? rtc::MakeUnique<webrtc::VP8EncoderSimulcastProxy>(
+                        internal_encoder_factory_)
+                  : internal_encoder_factory_->CreateVideoEncoder(format);
+  }
+  return encoder;
+}
+
+webrtc::VideoEncoderFactory::CodecInfo
+FakeWebRtcVideoEncoderFactory::QueryVideoEncoder(
+    const webrtc::SdpVideoFormat& format) const {
+  if (IsFormatSupported(formats_, format)) {
+    webrtc::VideoEncoderFactory::CodecInfo info;
+    info.has_internal_source = encoders_have_internal_sources_;
+    info.is_hardware_accelerated = true;
+    return info;
+  } else {
+    return internal_encoder_factory_->QueryVideoEncoder(format);
+  }
+}
+
+bool FakeWebRtcVideoEncoderFactory::WaitForCreatedVideoEncoders(
+    int num_encoders) {
+  int64_t start_offset_ms = rtc::TimeMillis();
+  int64_t wait_time = kEventTimeoutMs;
+  do {
+    if (GetNumCreatedEncoders() >= num_encoders)
+      return true;
+    wait_time = kEventTimeoutMs - (rtc::TimeMillis() - start_offset_ms);
+  } while (wait_time > 0 && created_video_encoder_event_.Wait(wait_time));
+  return false;
+}
+
+void FakeWebRtcVideoEncoderFactory::EncoderDestroyed(
+    FakeWebRtcVideoEncoder* encoder) {
+  rtc::CritScope lock(&crit_);
+  encoders_.erase(std::remove(encoders_.begin(), encoders_.end(), encoder),
+                  encoders_.end());
+}
+
+void FakeWebRtcVideoEncoderFactory::set_encoders_have_internal_sources(
+    bool internal_source) {
+  encoders_have_internal_sources_ = internal_source;
+}
+
+void FakeWebRtcVideoEncoderFactory::AddSupportedVideoCodec(
+    const webrtc::SdpVideoFormat& format) {
+  formats_.push_back(format);
+}
+
+void FakeWebRtcVideoEncoderFactory::AddSupportedVideoCodecType(
+    const std::string& name) {
+  // This is to match the default H264 params of cricket::VideoCodec.
+  cricket::VideoCodec video_codec(name);
+  formats_.push_back(
+      webrtc::SdpVideoFormat(video_codec.name, video_codec.params));
+}
+
+int FakeWebRtcVideoEncoderFactory::GetNumCreatedEncoders() {
+  rtc::CritScope lock(&crit_);
+  return num_created_encoders_;
+}
+
+const std::vector<FakeWebRtcVideoEncoder*>
+FakeWebRtcVideoEncoderFactory::encoders() {
+  rtc::CritScope lock(&crit_);
+  return encoders_;
+}
+
+}  // namespace cricket

media/engine/fakewebrtcvideoengine.h

@@ -11,248 +11,132 @@
 #ifndef MEDIA_ENGINE_FAKEWEBRTCVIDEOENGINE_H_
 #define MEDIA_ENGINE_FAKEWEBRTCVIDEOENGINE_H_
 
-#include <map>
+#include <memory>
-#include <set>
-#include <vector>
 #include <string>
+#include <vector>
 
 #include "api/video_codecs/video_decoder.h"
+#include "api/video_codecs/video_decoder_factory.h"
 #include "api/video_codecs/video_encoder.h"
-#include "media/base/codec.h"
+#include "api/video_codecs/video_encoder_factory.h"
-#include "media/engine/webrtcvideodecoderfactory.h"
+#include "media/engine/internaldecoderfactory.h"
-#include "media/engine/webrtcvideoencoderfactory.h"
+#include "media/engine/internalencoderfactory.h"
-#include "modules/video_coding/include/video_error_codes.h"
-#include "rtc_base/basictypes.h"
 #include "rtc_base/criticalsection.h"
-#include "rtc_base/gunit.h"
+#include "rtc_base/event.h"
-#include "rtc_base/stringutils.h"
+#include "rtc_base/ptr_util.h"
 #include "rtc_base/thread_annotations.h"
 
 namespace cricket {
-static const int kEventTimeoutMs = 10000;
+
+class FakeWebRtcVideoDecoderFactory;
+class FakeWebRtcVideoEncoderFactory;
 
 // Fake class for mocking out webrtc::VideoDecoder
 class FakeWebRtcVideoDecoder : public webrtc::VideoDecoder {
  public:
-  FakeWebRtcVideoDecoder() : num_frames_received_(0) {}
+  explicit FakeWebRtcVideoDecoder(FakeWebRtcVideoDecoderFactory* factory);
-
+  ~FakeWebRtcVideoDecoder();
-  virtual int32_t InitDecode(const webrtc::VideoCodec*, int32_t) {
-    return WEBRTC_VIDEO_CODEC_OK;
-  }
 
+  virtual int32_t InitDecode(const webrtc::VideoCodec*, int32_t);
   virtual int32_t Decode(const webrtc::EncodedImage&,
                          bool,
                          const webrtc::RTPFragmentationHeader*,
                          const webrtc::CodecSpecificInfo*,
-                         int64_t) {
+                         int64_t);
-    num_frames_received_++;
+  virtual int32_t RegisterDecodeCompleteCallback(webrtc::DecodedImageCallback*);
-    return WEBRTC_VIDEO_CODEC_OK;
+  virtual int32_t Release();
-  }
 
-  virtual int32_t RegisterDecodeCompleteCallback(
+  int GetNumFramesReceived() const;
-      webrtc::DecodedImageCallback*) {
-    return WEBRTC_VIDEO_CODEC_OK;
-  }
-
-  virtual int32_t Release() { return WEBRTC_VIDEO_CODEC_OK; }
-
-  int GetNumFramesReceived() const {
-    return num_frames_received_;
-  }
 
  private:
   int num_frames_received_;
+  FakeWebRtcVideoDecoderFactory* factory_;
 };
 
-// Fake class for mocking out WebRtcVideoDecoderFactory.
+// Fake class for mocking out webrtc::VideoDecoderFactory.
-class FakeWebRtcVideoDecoderFactory : public WebRtcVideoDecoderFactory {
+// TODO(bugs.webrtc.org/9228): Remove internal_decoder_factory_.
+class FakeWebRtcVideoDecoderFactory : public webrtc::VideoDecoderFactory {
  public:
-  FakeWebRtcVideoDecoderFactory()
+  FakeWebRtcVideoDecoderFactory();
-      : num_created_decoders_(0) {
+  ~FakeWebRtcVideoDecoderFactory();
-  }
 
-  virtual webrtc::VideoDecoder* CreateVideoDecoder(
+  std::vector<webrtc::SdpVideoFormat> GetSupportedFormats() const override;
-      webrtc::VideoCodecType type) {
+  std::unique_ptr<webrtc::VideoDecoder> CreateVideoDecoder(
-    if (supported_codec_types_.count(type) == 0) {
+      const webrtc::SdpVideoFormat& format) override;
-      return NULL;
-    }
-    FakeWebRtcVideoDecoder* decoder = new FakeWebRtcVideoDecoder();
-    decoders_.push_back(decoder);
-    num_created_decoders_++;
-    return decoder;
-  }
 
-  virtual webrtc::VideoDecoder* CreateVideoDecoderWithParams(
+  void DecoderDestroyed(FakeWebRtcVideoDecoder* decoder);
-      webrtc::VideoCodecType type,
+  void AddSupportedVideoCodecType(const webrtc::SdpVideoFormat& format);
-      VideoDecoderParams params) {
+  int GetNumCreatedDecoders();
-    params_.push_back(params);
+  const std::vector<FakeWebRtcVideoDecoder*>& decoders();
-    return CreateVideoDecoder(type);
-  }
-
-  virtual void DestroyVideoDecoder(webrtc::VideoDecoder* decoder) {
-    decoders_.erase(
-        std::remove(decoders_.begin(), decoders_.end(), decoder),
-        decoders_.end());
-    delete decoder;
-  }
-
-  void AddSupportedVideoCodecType(webrtc::VideoCodecType type) {
-    supported_codec_types_.insert(type);
-  }
-
-  int GetNumCreatedDecoders() {
-    return num_created_decoders_;
-  }
-
-  const std::vector<FakeWebRtcVideoDecoder*>& decoders() {
-    return decoders_;
-  }
-
-  const std::vector<VideoDecoderParams>& params() { return params_; }
 
  private:
-  std::set<webrtc::VideoCodecType> supported_codec_types_;
+  std::vector<webrtc::SdpVideoFormat> supported_codec_formats_;
   std::vector<FakeWebRtcVideoDecoder*> decoders_;
   int num_created_decoders_;
-  std::vector<VideoDecoderParams> params_;
+  webrtc::InternalDecoderFactory* internal_decoder_factory_;
 };
 
 // Fake class for mocking out webrtc::VideoEnoder
 class FakeWebRtcVideoEncoder : public webrtc::VideoEncoder {
  public:
-  FakeWebRtcVideoEncoder()
+  explicit FakeWebRtcVideoEncoder(FakeWebRtcVideoEncoderFactory* factory);
-      : init_encode_event_(false, false), num_frames_encoded_(0) {}
+  ~FakeWebRtcVideoEncoder();
 
   int32_t InitEncode(const webrtc::VideoCodec* codecSettings,
                      int32_t numberOfCores,
-                     size_t maxPayloadSize) override {
+                     size_t maxPayloadSize) override;
-    rtc::CritScope lock(&crit_);
-    codec_settings_ = *codecSettings;
-    init_encode_event_.Set();
-    return WEBRTC_VIDEO_CODEC_OK;
-  }
-
-  bool WaitForInitEncode() { return init_encode_event_.Wait(kEventTimeoutMs); }
-
-  webrtc::VideoCodec GetCodecSettings() {
-    rtc::CritScope lock(&crit_);
-    return codec_settings_;
-  }
-
   int32_t Encode(const webrtc::VideoFrame& inputImage,
                  const webrtc::CodecSpecificInfo* codecSpecificInfo,
-                 const std::vector<webrtc::FrameType>* frame_types) override {
+                 const std::vector<webrtc::FrameType>* frame_types) override;
-    rtc::CritScope lock(&crit_);
-    ++num_frames_encoded_;
-    init_encode_event_.Set();
-    return WEBRTC_VIDEO_CODEC_OK;
-  }
-
   int32_t RegisterEncodeCompleteCallback(
-      webrtc::EncodedImageCallback* callback) override {
+      webrtc::EncodedImageCallback* callback) override;
-    return WEBRTC_VIDEO_CODEC_OK;
+  int32_t Release() override;
-  }
+  int32_t SetChannelParameters(uint32_t packetLoss, int64_t rtt) override;
-
-  int32_t Release() override { return WEBRTC_VIDEO_CODEC_OK; }
-
-  int32_t SetChannelParameters(uint32_t packetLoss, int64_t rtt) override {
-    return WEBRTC_VIDEO_CODEC_OK;
-  }
-
   int32_t SetRateAllocation(const webrtc::VideoBitrateAllocation& allocation,
-                            uint32_t framerate) override {
+                            uint32_t framerate) override;
-    return WEBRTC_VIDEO_CODEC_OK;
-  }
 
-  int GetNumEncodedFrames() {
+  bool WaitForInitEncode();
-    rtc::CritScope lock(&crit_);
+  webrtc::VideoCodec GetCodecSettings();
-    return num_frames_encoded_;
+  int GetNumEncodedFrames();
-  }
 
  private:
   rtc::CriticalSection crit_;
   rtc::Event init_encode_event_;
   int num_frames_encoded_ RTC_GUARDED_BY(crit_);
   webrtc::VideoCodec codec_settings_ RTC_GUARDED_BY(crit_);
+  FakeWebRtcVideoEncoderFactory* factory_;
 };
 
-// Fake class for mocking out WebRtcVideoEncoderFactory.
+// Fake class for mocking out webrtc::VideoEncoderFactory.
-class FakeWebRtcVideoEncoderFactory : public WebRtcVideoEncoderFactory {
+// TODO(bugs.webrtc.org/9228): Remove internal_encoder_factory_.
+class FakeWebRtcVideoEncoderFactory : public webrtc::VideoEncoderFactory {
  public:
-  FakeWebRtcVideoEncoderFactory()
+  FakeWebRtcVideoEncoderFactory();
-      : created_video_encoder_event_(false, false),
+  ~FakeWebRtcVideoEncoderFactory();
-        num_created_encoders_(0),
-        encoders_have_internal_sources_(false) {}
 
-  webrtc::VideoEncoder* CreateVideoEncoder(
+  std::vector<webrtc::SdpVideoFormat> GetSupportedFormats() const override;
-      const cricket::VideoCodec& codec) override {
+  std::unique_ptr<webrtc::VideoEncoder> CreateVideoEncoder(
-    rtc::CritScope lock(&crit_);
+      const webrtc::SdpVideoFormat& format) override;
-    if (!FindMatchingCodec(codecs_, codec))
+  CodecInfo QueryVideoEncoder(
-      return nullptr;
+      const webrtc::SdpVideoFormat& format) const override;
-    FakeWebRtcVideoEncoder* encoder = new FakeWebRtcVideoEncoder();
-    encoders_.push_back(encoder);
-    num_created_encoders_++;
-    created_video_encoder_event_.Set();
-    return encoder;
-  }
 
-  bool WaitForCreatedVideoEncoders(int num_encoders) {
+  bool WaitForCreatedVideoEncoders(int num_encoders);
-    int64_t start_offset_ms = rtc::TimeMillis();
+  void EncoderDestroyed(FakeWebRtcVideoEncoder* encoder);
-    int64_t wait_time = kEventTimeoutMs;
+  void set_encoders_have_internal_sources(bool internal_source);
-    do {
+  void AddSupportedVideoCodec(const webrtc::SdpVideoFormat& format);
-      if (GetNumCreatedEncoders() >= num_encoders)
+  void AddSupportedVideoCodecType(const std::string& name);
-        return true;
+  int GetNumCreatedEncoders();
-      wait_time = kEventTimeoutMs - (rtc::TimeMillis() - start_offset_ms);
+  const std::vector<FakeWebRtcVideoEncoder*> encoders();
-    } while (wait_time > 0 && created_video_encoder_event_.Wait(wait_time));
-    return false;
-  }
-
-  void DestroyVideoEncoder(webrtc::VideoEncoder* encoder) override {
-    rtc::CritScope lock(&crit_);
-    encoders_.erase(
-        std::remove(encoders_.begin(), encoders_.end(), encoder),
-        encoders_.end());
-    delete encoder;
-  }
-
-  const std::vector<cricket::VideoCodec>& supported_codecs() const override {
-    return codecs_;
-  }
-
-  bool EncoderTypeHasInternalSource(
-      webrtc::VideoCodecType type) const override {
-    return encoders_have_internal_sources_;
-  }
-
-  void set_encoders_have_internal_sources(bool internal_source) {
-    encoders_have_internal_sources_ = internal_source;
-  }
-
-  void AddSupportedVideoCodec(const cricket::VideoCodec& codec) {
-    codecs_.push_back(codec);
-  }
-
-  void AddSupportedVideoCodecType(const std::string& name) {
-    codecs_.push_back(cricket::VideoCodec(name));
-  }
-
-  int GetNumCreatedEncoders() {
-    rtc::CritScope lock(&crit_);
-    return num_created_encoders_;
-  }
-
-  const std::vector<FakeWebRtcVideoEncoder*> encoders() {
-    rtc::CritScope lock(&crit_);
-    return encoders_;
-  }
 
  private:
   rtc::CriticalSection crit_;
   rtc::Event created_video_encoder_event_;
-  std::vector<cricket::VideoCodec> codecs_;
+  std::vector<webrtc::SdpVideoFormat> formats_;
   std::vector<FakeWebRtcVideoEncoder*> encoders_ RTC_GUARDED_BY(crit_);
   int num_created_encoders_ RTC_GUARDED_BY(crit_);
   bool encoders_have_internal_sources_;
+  webrtc::InternalEncoderFactory* internal_encoder_factory_;
+  bool vp8_factory_mode_;
 };
 
 }  // namespace cricket

media/engine/vp8_encoder_simulcast_proxy.h

@@ -25,7 +25,7 @@ namespace webrtc {
 class VP8EncoderSimulcastProxy : public VP8Encoder {
  public:
   explicit VP8EncoderSimulcastProxy(VideoEncoderFactory* factory);
-  virtual ~VP8EncoderSimulcastProxy();
+  ~VP8EncoderSimulcastProxy() override;
 
   // Implements VideoEncoder.
   int Release() override;

media/engine/webrtcvideoengine_unittest.cc

@@ -183,9 +183,9 @@ class WebRtcVideoEngineTest : public ::testing::Test {
         call_(webrtc::Call::Create(webrtc::Call::Config(&event_log_))),
         encoder_factory_(new cricket::FakeWebRtcVideoEncoderFactory),
         decoder_factory_(new cricket::FakeWebRtcVideoDecoderFactory),
-        engine_(std::unique_ptr<cricket::WebRtcVideoEncoderFactory>(
+        engine_(std::unique_ptr<cricket::FakeWebRtcVideoEncoderFactory>(
                     encoder_factory_),
-                std::unique_ptr<cricket::WebRtcVideoDecoderFactory>(
+                std::unique_ptr<cricket::FakeWebRtcVideoDecoderFactory>(
                     decoder_factory_)) {
     std::vector<VideoCodec> engine_codecs = engine_.codecs();
     RTC_DCHECK(!engine_codecs.empty());
@@ -227,10 +227,6 @@ class WebRtcVideoEngineTest : public ::testing::Test {
   // Used in WebRtcVideoEngineVoiceTest, but defined here so it's properly
   // initialized when the constructor is called.
   std::unique_ptr<webrtc::Call> call_;
-  // TODO(magjed): Update all tests to use new video codec factories once the
-  // old factories are deprecated,
-  // https://bugs.chromium.org/p/webrtc/issues/detail?id=7925.
-  // These factories are owned by the video engine.
   cricket::FakeWebRtcVideoEncoderFactory* encoder_factory_;
   cricket::FakeWebRtcVideoDecoderFactory* decoder_factory_;
   WebRtcVideoEngine engine_;
@@ -468,16 +464,16 @@ TEST_F(WebRtcVideoEngineTest, RtxCodecAddedForExternalCodec) {
   using webrtc::H264::ProfileLevelIdToString;
   using webrtc::H264::ProfileLevelId;
   using webrtc::H264::kLevel1;
-  cricket::VideoCodec h264_constrained_baseline("H264");
+  webrtc::SdpVideoFormat h264_constrained_baseline("H264");
-  h264_constrained_baseline.params[kH264FmtpProfileLevelId] =
+  h264_constrained_baseline.parameters[kH264FmtpProfileLevelId] =
       *ProfileLevelIdToString(
           ProfileLevelId(webrtc::H264::kProfileConstrainedBaseline, kLevel1));
-  cricket::VideoCodec h264_constrained_high("H264");
+  webrtc::SdpVideoFormat h264_constrained_high("H264");
-  h264_constrained_high.params[kH264FmtpProfileLevelId] =
+  h264_constrained_high.parameters[kH264FmtpProfileLevelId] =
       *ProfileLevelIdToString(
           ProfileLevelId(webrtc::H264::kProfileConstrainedHigh, kLevel1));
-  cricket::VideoCodec h264_high("H264");
+  webrtc::SdpVideoFormat h264_high("H264");
-  h264_high.params[kH264FmtpProfileLevelId] = *ProfileLevelIdToString(
+  h264_high.parameters[kH264FmtpProfileLevelId] = *ProfileLevelIdToString(
       ProfileLevelId(webrtc::H264::kProfileHigh, kLevel1));
 
   encoder_factory_->AddSupportedVideoCodec(h264_constrained_baseline);
@@ -489,11 +485,15 @@ TEST_F(WebRtcVideoEngineTest, RtxCodecAddedForExternalCodec) {
   // Now search for RTX codecs for them. Expect that they all have associated
   // RTX codecs.
   EXPECT_TRUE(HasRtxCodec(
-      codecs, FindMatchingCodec(codecs, h264_constrained_baseline)->id));
+      codecs,
+      FindMatchingCodec(codecs, cricket::VideoCodec(h264_constrained_baseline))
+          ->id));
   EXPECT_TRUE(HasRtxCodec(
-      codecs, FindMatchingCodec(codecs, h264_constrained_high)->id));
+      codecs,
+      FindMatchingCodec(codecs, cricket::VideoCodec(h264_constrained_high))
+          ->id));
   EXPECT_TRUE(HasRtxCodec(
-      codecs, FindMatchingCodec(codecs, h264_high)->id));
+      codecs, FindMatchingCodec(codecs, cricket::VideoCodec(h264_high))->id));
 }
 
 #if !defined(RTC_DISABLE_VP9)
@@ -595,8 +595,14 @@ VideoMediaChannel* WebRtcVideoEngineTest::SetUpForExternalEncoderFactory() {
       engine_.CreateChannel(call_.get(), GetMediaConfig(), VideoOptions());
   cricket::VideoSendParameters parameters;
   // We need to look up the codec in the engine to get the correct payload type.
-  for (const VideoCodec& codec : encoder_factory_->supported_codecs())
+  for (const webrtc::SdpVideoFormat& format :
-    parameters.codecs.push_back(GetEngineCodec(codec.name));
+       encoder_factory_->GetSupportedFormats()) {
+    cricket::VideoCodec engine_codec = GetEngineCodec(format.name);
+    if (std::find(parameters.codecs.begin(), parameters.codecs.end(),
+                  engine_codec) == parameters.codecs.end()) {
+      parameters.codecs.push_back(engine_codec);
+    }
+  }
 
   EXPECT_TRUE(channel->SetSendParameters(parameters));
 
@@ -659,7 +665,11 @@ TEST_F(WebRtcVideoEngineTest, ChannelWithExternalH264CanChangeToInternalVp8) {
   EXPECT_EQ(cricket::CS_RUNNING,
             capturer.Start(capturer.GetSupportedFormats()->front()));
 
-  std::unique_ptr<VideoMediaChannel> channel(SetUpForExternalEncoderFactory());
+  std::unique_ptr<VideoMediaChannel> channel(
+      engine_.CreateChannel(call_.get(), GetMediaConfig(), VideoOptions()));
+  cricket::VideoSendParameters parameters;
+  parameters.codecs.push_back(GetEngineCodec("H264"));
+  EXPECT_TRUE(channel->SetSendParameters(parameters));
 
   EXPECT_TRUE(
       channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
@@ -669,9 +679,9 @@ TEST_F(WebRtcVideoEngineTest, ChannelWithExternalH264CanChangeToInternalVp8) {
 
   ASSERT_EQ_WAIT(1u, encoder_factory_->encoders().size(), kTimeout);
 
-  cricket::VideoSendParameters parameters;
+  cricket::VideoSendParameters new_parameters;
-  parameters.codecs.push_back(GetEngineCodec("VP8"));
+  new_parameters.codecs.push_back(GetEngineCodec("VP8"));
-  EXPECT_TRUE(channel->SetSendParameters(parameters));
+  EXPECT_TRUE(channel->SetSendParameters(new_parameters));
 
   // Sending one frame will switch encoder.
   EXPECT_TRUE(capturer.CaptureFrame());
@@ -766,7 +776,11 @@ TEST_F(WebRtcVideoEngineTest,
 TEST_F(WebRtcVideoEngineTest, SimulcastDisabledForH264) {
   encoder_factory_->AddSupportedVideoCodecType("H264");
 
-  std::unique_ptr<VideoMediaChannel> channel(SetUpForExternalEncoderFactory());
+  std::unique_ptr<VideoMediaChannel> channel(
+      engine_.CreateChannel(call_.get(), GetMediaConfig(), VideoOptions()));
+  cricket::VideoSendParameters parameters;
+  parameters.codecs.push_back(GetEngineCodec("H264"));
+  EXPECT_TRUE(channel->SetSendParameters(parameters));
 
   const std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs3);
   EXPECT_TRUE(
@@ -850,7 +864,7 @@ TEST_F(WebRtcVideoEngineTest, ReportSupportedExternalCodecsWithAddedCodec) {
 }
 
 TEST_F(WebRtcVideoEngineTest, RegisterExternalDecodersIfSupported) {
-  decoder_factory_->AddSupportedVideoCodecType(webrtc::kVideoCodecVP8);
+  decoder_factory_->AddSupportedVideoCodecType(webrtc::SdpVideoFormat("VP8"));
   cricket::VideoRecvParameters parameters;
   parameters.codecs.push_back(GetEngineCodec("VP8"));
 
@@ -877,7 +891,7 @@ TEST_F(WebRtcVideoEngineTest, RegisterExternalH264DecoderIfSupported) {
   // For now we add a FakeWebRtcVideoEncoderFactory to add H264 to supported
   // codecs.
   encoder_factory_->AddSupportedVideoCodecType("H264");
-  decoder_factory_->AddSupportedVideoCodecType(webrtc::kVideoCodecH264);
+  decoder_factory_->AddSupportedVideoCodecType(webrtc::SdpVideoFormat("H264"));
   std::vector<cricket::VideoCodec> codecs;
   codecs.push_back(GetEngineCodec("H264"));
 
@@ -968,7 +982,7 @@ TEST(WebRtcVideoEngineNewVideoCodecFactoryTest, Vp8) {
   const webrtc::SdpVideoFormat format("VP8");
   EXPECT_CALL(*encoder_factory, QueryVideoEncoder(format))
       .WillRepeatedly(testing::Return(codec_info));
-  FakeWebRtcVideoEncoder* const encoder = new FakeWebRtcVideoEncoder();
+  FakeWebRtcVideoEncoder* const encoder = new FakeWebRtcVideoEncoder(nullptr);
   rtc::Event encoder_created(false, false);
   EXPECT_CALL(*encoder_factory, CreateVideoEncoderProxy(format))
       .WillOnce(
@@ -977,7 +991,7 @@ TEST(WebRtcVideoEngineNewVideoCodecFactoryTest, Vp8) {
                            ::testing::Return(encoder)));
 
   // Mock decoder creation. |engine| take ownership of the decoder.
-  FakeWebRtcVideoDecoder* const decoder = new FakeWebRtcVideoDecoder();
+  FakeWebRtcVideoDecoder* const decoder = new FakeWebRtcVideoDecoder(nullptr);
   EXPECT_CALL(*decoder_factory, CreateVideoDecoderProxy(format))
       .WillOnce(testing::Return(decoder));
 
@@ -1062,25 +1076,6 @@ TEST(WebRtcVideoEngineNewVideoCodecFactoryTest, NullDecoder) {
   EXPECT_TRUE(recv_channel->RemoveRecvStream(recv_ssrc));
 }
 
-// Verifies that id given in stream params is passed to the decoder factory.
-TEST_F(WebRtcVideoEngineTest, StreamParamsIdPassedToDecoderFactory) {
-  decoder_factory_->AddSupportedVideoCodecType(webrtc::kVideoCodecVP8);
-  cricket::VideoRecvParameters parameters;
-  parameters.codecs.push_back(GetEngineCodec("VP8"));
-
-  std::unique_ptr<VideoMediaChannel> channel(
-      SetUpForExternalDecoderFactory(parameters.codecs));
-
-  StreamParams sp = cricket::StreamParams::CreateLegacy(kSsrc);
-  sp.id = "FakeStreamParamsId";
-  EXPECT_TRUE(channel->AddRecvStream(sp));
-  EXPECT_EQ(1u, decoder_factory_->decoders().size());
-
-  std::vector<cricket::VideoDecoderParams> params = decoder_factory_->params();
-  ASSERT_EQ(1u, params.size());
-  EXPECT_EQ(sp.id, params[0].receive_stream_id);
-}
-
 TEST_F(WebRtcVideoEngineTest, DISABLED_RecreatesEncoderOnContentTypeChange) {
   encoder_factory_->AddSupportedVideoCodecType("VP8");
   std::unique_ptr<FakeCall> fake_call(new FakeCall());
@@ -1144,8 +1139,10 @@ class WebRtcVideoChannelBaseTest : public testing::Test {
  protected:
   WebRtcVideoChannelBaseTest()
       : call_(webrtc::Call::Create(webrtc::Call::Config(&event_log_))),
-        engine_(std::unique_ptr<cricket::WebRtcVideoEncoderFactory>(),
+        engine_(std::unique_ptr<cricket::FakeWebRtcVideoEncoderFactory>(
-                std::unique_ptr<cricket::WebRtcVideoDecoderFactory>()) {}
+                    new cricket::FakeWebRtcVideoEncoderFactory()),
+                std::unique_ptr<cricket::FakeWebRtcVideoDecoderFactory>(
+                    new cricket::FakeWebRtcVideoDecoderFactory())) {}
 
   virtual void SetUp() {
     cricket::MediaConfig media_config;
@@ -5721,9 +5718,9 @@ class WebRtcVideoChannelSimulcastTest : public testing::Test {
       : fake_call_(),
         encoder_factory_(new cricket::FakeWebRtcVideoEncoderFactory),
         decoder_factory_(new cricket::FakeWebRtcVideoDecoderFactory),
-        engine_(std::unique_ptr<cricket::WebRtcVideoEncoderFactory>(
+        engine_(std::unique_ptr<cricket::FakeWebRtcVideoEncoderFactory>(
                     encoder_factory_),
-                std::unique_ptr<cricket::WebRtcVideoDecoderFactory>(
+                std::unique_ptr<cricket::FakeWebRtcVideoDecoderFactory>(
                     decoder_factory_)),
         last_ssrc_(0) {}
 

pc/BUILD.gn

@@ -377,6 +377,8 @@ if (rtc_include_tests) {
       "../api:libjingle_peerconnection_api",
       "../api:libjingle_peerconnection_test_api",
       "../api:rtc_stats_api",
+      "../api/video_codecs:builtin_video_decoder_factory",
+      "../api/video_codecs:builtin_video_encoder_factory",
       "../call:call_interfaces",
       "../logging:rtc_event_log_api",
       "../media:rtc_data",
@@ -384,6 +386,7 @@ if (rtc_include_tests) {
       "../media:rtc_media_base",
       "../media:rtc_media_tests_utils",
       "../modules/audio_device:audio_device",
+      "../modules/audio_processing:audio_processing",
       "../p2p:p2p_test_utils",
       "../rtc_base:checks",
       "../rtc_base:rtc_base",
@@ -506,6 +509,9 @@ if (rtc_include_tests) {
       "../api/audio_codecs:builtin_audio_encoder_factory",
       "../api/audio_codecs/L16:audio_decoder_L16",
       "../api/audio_codecs/L16:audio_encoder_L16",
+      "../api/video_codecs:builtin_video_decoder_factory",
+      "../api/video_codecs:builtin_video_encoder_factory",
+      "../api/video_codecs:video_codecs_api",
       "../call:call_interfaces",
       "../logging:rtc_event_log_api",
       "../logging:rtc_event_log_impl_base",

pc/peerconnection_bundle_unittest.cc

@@ -11,6 +11,8 @@
 #include "api/audio_codecs/builtin_audio_decoder_factory.h"
 #include "api/audio_codecs/builtin_audio_encoder_factory.h"
 #include "api/peerconnectionproxy.h"
+#include "api/video_codecs/builtin_video_decoder_factory.h"
+#include "api/video_codecs/builtin_video_encoder_factory.h"
 #include "p2p/base/fakeportallocator.h"
 #include "p2p/base/teststunserver.h"
 #include "p2p/client/basicportallocator.h"
@@ -168,8 +170,10 @@ class PeerConnectionBundleBaseTest : public ::testing::Test {
 #endif
     pc_factory_ = CreatePeerConnectionFactory(
         rtc::Thread::Current(), rtc::Thread::Current(), rtc::Thread::Current(),
-        FakeAudioCaptureModule::Create(), CreateBuiltinAudioEncoderFactory(),
+        rtc::scoped_refptr<AudioDeviceModule>(FakeAudioCaptureModule::Create()),
-        CreateBuiltinAudioDecoderFactory(), nullptr, nullptr);
+        CreateBuiltinAudioEncoderFactory(), CreateBuiltinAudioDecoderFactory(),
+        CreateBuiltinVideoEncoderFactory(), CreateBuiltinVideoDecoderFactory(),
+        nullptr /* audio_mixer */, nullptr /* audio_processing */);
   }
 
   WrapperPtr CreatePeerConnection() {

pc/peerconnection_crypto_unittest.cc

@@ -10,6 +10,8 @@
 
 #include "api/audio_codecs/builtin_audio_decoder_factory.h"
 #include "api/audio_codecs/builtin_audio_encoder_factory.h"
+#include "api/video_codecs/builtin_video_decoder_factory.h"
+#include "api/video_codecs/builtin_video_encoder_factory.h"
 #include "p2p/base/fakeportallocator.h"
 #include "pc/mediasession.h"
 #include "pc/peerconnectionwrapper.h"
@@ -46,7 +48,9 @@ class PeerConnectionCryptoBaseTest : public ::testing::Test {
     pc_factory_ = CreatePeerConnectionFactory(
         rtc::Thread::Current(), rtc::Thread::Current(), rtc::Thread::Current(),
         FakeAudioCaptureModule::Create(), CreateBuiltinAudioEncoderFactory(),
-        CreateBuiltinAudioDecoderFactory(), nullptr, nullptr);
+        CreateBuiltinAudioDecoderFactory(), CreateBuiltinVideoEncoderFactory(),
+        CreateBuiltinVideoDecoderFactory(), nullptr /* audio_mixer */,
+        nullptr /* audio_processing */);
   }
 
   WrapperPtr CreatePeerConnection() {

pc/peerconnection_ice_unittest.cc

@@ -21,6 +21,8 @@
 #include "api/audio_codecs/builtin_audio_decoder_factory.h"
 #include "api/audio_codecs/builtin_audio_encoder_factory.h"
 #include "api/peerconnectionproxy.h"
+#include "api/video_codecs/builtin_video_decoder_factory.h"
+#include "api/video_codecs/builtin_video_encoder_factory.h"
 #include "pc/test/fakeaudiocapturemodule.h"
 #include "rtc_base/fakenetwork.h"
 #include "rtc_base/gunit.h"
@@ -89,8 +91,10 @@ class PeerConnectionIceBaseTest : public ::testing::Test {
 #endif
     pc_factory_ = CreatePeerConnectionFactory(
         rtc::Thread::Current(), rtc::Thread::Current(), rtc::Thread::Current(),
-        FakeAudioCaptureModule::Create(), CreateBuiltinAudioEncoderFactory(),
+        rtc::scoped_refptr<AudioDeviceModule>(FakeAudioCaptureModule::Create()),
-        CreateBuiltinAudioDecoderFactory(), nullptr, nullptr);
+        CreateBuiltinAudioEncoderFactory(), CreateBuiltinAudioDecoderFactory(),
+        CreateBuiltinVideoEncoderFactory(), CreateBuiltinVideoDecoderFactory(),
+        nullptr /* audio_mixer */, nullptr /* audio_processing */);
   }
 
   WrapperPtr CreatePeerConnection() {
@@ -948,7 +952,9 @@ class PeerConnectionIceConfigTest : public testing::Test {
     pc_factory_ = CreatePeerConnectionFactory(
         rtc::Thread::Current(), rtc::Thread::Current(), rtc::Thread::Current(),
         FakeAudioCaptureModule::Create(), CreateBuiltinAudioEncoderFactory(),
-        CreateBuiltinAudioDecoderFactory(), nullptr, nullptr);
+        CreateBuiltinAudioDecoderFactory(), CreateBuiltinVideoEncoderFactory(),
+        CreateBuiltinVideoDecoderFactory(), nullptr /* audio_mixer */,
+        nullptr /* audio_processing */);
   }
   void CreatePeerConnection(const RTCConfiguration& config) {
     std::unique_ptr<cricket::FakePortAllocator> port_allocator(

pc/peerconnection_integrationtest.cc

@@ -30,6 +30,9 @@
 #include "api/peerconnectionproxy.h"
 #include "api/rtpreceiverinterface.h"
 #include "api/test/fakeconstraints.h"
+#include "api/video_codecs/builtin_video_decoder_factory.h"
+#include "api/video_codecs/builtin_video_encoder_factory.h"
+#include "api/video_codecs/sdp_video_format.h"
 #include "media/engine/fakewebrtcvideoengine.h"
 #include "p2p/base/p2pconstants.h"
 #include "p2p/base/portinterface.h"
@@ -604,9 +607,15 @@ class PeerConnectionWrapper : public webrtc::PeerConnectionObserver,
     rtc::Thread* const signaling_thread = rtc::Thread::Current();
     peer_connection_factory_ = webrtc::CreatePeerConnectionFactory(
         network_thread, worker_thread, signaling_thread,
-        fake_audio_capture_module_, webrtc::CreateBuiltinAudioEncoderFactory(),
+        rtc::scoped_refptr<webrtc::AudioDeviceModule>(
-        webrtc::CreateBuiltinAudioDecoderFactory(), fake_video_encoder_factory_,
+            fake_audio_capture_module_),
-        fake_video_decoder_factory_);
+        webrtc::CreateBuiltinAudioEncoderFactory(),
+        webrtc::CreateBuiltinAudioDecoderFactory(),
+        std::unique_ptr<FakeWebRtcVideoEncoderFactory>(
+            fake_video_encoder_factory_),
+        std::unique_ptr<FakeWebRtcVideoDecoderFactory>(
+            fake_video_decoder_factory_),
+        nullptr /* audio_mixer */, nullptr /* audio_processing */);
     if (!peer_connection_factory_) {
       return false;
     }
@@ -658,7 +667,7 @@ class PeerConnectionWrapper : public webrtc::PeerConnectionObserver,
   void EnableVideoDecoderFactory() {
     video_decoder_factory_enabled_ = true;
     fake_video_decoder_factory_->AddSupportedVideoCodecType(
-        webrtc::kVideoCodecVP8);
+        webrtc::SdpVideoFormat("VP8"));
   }
 
   rtc::scoped_refptr<webrtc::VideoTrackInterface> CreateLocalVideoTrackInternal(

pc/peerconnection_rtp_unittest.cc

@@ -17,6 +17,8 @@
 #include "api/mediastreaminterface.h"
 #include "api/peerconnectioninterface.h"
 #include "api/umametrics.h"
+#include "api/video_codecs/builtin_video_decoder_factory.h"
+#include "api/video_codecs/builtin_video_encoder_factory.h"
 #include "pc/mediasession.h"
 #include "pc/mediastream.h"
 #include "pc/mediastreamtrack.h"
@@ -70,8 +72,10 @@ class PeerConnectionRtpTest : public testing::Test {
                                         FakeAudioCaptureModule::Create(),
                                         CreateBuiltinAudioEncoderFactory(),
                                         CreateBuiltinAudioDecoderFactory(),
-                                        nullptr,
+                                        CreateBuiltinVideoEncoderFactory(),
-                                        nullptr)) {}
+                                        CreateBuiltinVideoDecoderFactory(),
+                                        nullptr /* audio_mixer */,
+                                        nullptr /* audio_processing */)) {}
 
   std::unique_ptr<PeerConnectionWrapper> CreatePeerConnection() {
     return CreatePeerConnection(RTCConfiguration());

pc/peerconnection_signaling_unittest.cc

@@ -16,6 +16,8 @@
 #include "api/audio_codecs/builtin_audio_decoder_factory.h"
 #include "api/audio_codecs/builtin_audio_encoder_factory.h"
 #include "api/peerconnectionproxy.h"
+#include "api/video_codecs/builtin_video_decoder_factory.h"
+#include "api/video_codecs/builtin_video_encoder_factory.h"
 #include "pc/peerconnection.h"
 #include "pc/peerconnectionwrapper.h"
 #include "pc/sdputils.h"
@@ -68,8 +70,10 @@ class PeerConnectionSignalingBaseTest : public ::testing::Test {
 #endif
     pc_factory_ = CreatePeerConnectionFactory(
         rtc::Thread::Current(), rtc::Thread::Current(), rtc::Thread::Current(),
-        FakeAudioCaptureModule::Create(), CreateBuiltinAudioEncoderFactory(),
+        rtc::scoped_refptr<AudioDeviceModule>(FakeAudioCaptureModule::Create()),
-        CreateBuiltinAudioDecoderFactory(), nullptr, nullptr);
+        CreateBuiltinAudioEncoderFactory(), CreateBuiltinAudioDecoderFactory(),
+        CreateBuiltinVideoEncoderFactory(), CreateBuiltinVideoDecoderFactory(),
+        nullptr /* audio_mixer */, nullptr /* audio_processing */);
   }
 
   WrapperPtr CreatePeerConnection() {

pc/peerconnectionfactory_unittest.cc

@@ -16,6 +16,8 @@
 #include "api/audio_codecs/builtin_audio_decoder_factory.h"
 #include "api/audio_codecs/builtin_audio_encoder_factory.h"
 #include "api/mediastreaminterface.h"
+#include "api/video_codecs/builtin_video_decoder_factory.h"
+#include "api/video_codecs/builtin_video_encoder_factory.h"
 #include "media/base/fakevideocapturer.h"
 #include "p2p/base/fakeportallocator.h"
 #include "pc/peerconnectionfactory.h"
@@ -93,10 +95,14 @@ class PeerConnectionFactoryTest : public testing::Test {
     // level, and using a real one could make tests flaky e.g. when run in
     // parallel.
     factory_ = webrtc::CreatePeerConnectionFactory(
-        rtc::Thread::Current(), rtc::Thread::Current(),
+        rtc::Thread::Current(), rtc::Thread::Current(), rtc::Thread::Current(),
-        FakeAudioCaptureModule::Create(),
+        rtc::scoped_refptr<webrtc::AudioDeviceModule>(
+            FakeAudioCaptureModule::Create()),
         webrtc::CreateBuiltinAudioEncoderFactory(),
-        webrtc::CreateBuiltinAudioDecoderFactory(), nullptr, nullptr);
+        webrtc::CreateBuiltinAudioDecoderFactory(),
+        webrtc::CreateBuiltinVideoEncoderFactory(),
+        webrtc::CreateBuiltinVideoDecoderFactory(), nullptr /* audio_mixer */,
+        nullptr /* audio_processing */);
 
     ASSERT_TRUE(factory_.get() != NULL);
     port_allocator_.reset(
@@ -147,8 +153,13 @@ TEST(PeerConnectionFactoryTestInternal, DISABLED_CreatePCUsingInternalModules) {
 
   rtc::scoped_refptr<PeerConnectionFactoryInterface> factory(
       webrtc::CreatePeerConnectionFactory(
+          nullptr /* network_thread */, nullptr /* worker_thread */,
+          nullptr /* signaling_thread */, nullptr /* default_adm */,
           webrtc::CreateBuiltinAudioEncoderFactory(),
-          webrtc::CreateBuiltinAudioDecoderFactory()));
+          webrtc::CreateBuiltinAudioDecoderFactory(),
+          webrtc::CreateBuiltinVideoEncoderFactory(),
+          webrtc::CreateBuiltinVideoDecoderFactory(), nullptr /* audio_mixer */,
+          nullptr /* audio_processing */));
 
   NullPeerConnectionObserver observer;
   webrtc::PeerConnectionInterface::RTCConfiguration config;

pc/peerconnectioninterface_unittest.cc

@@ -22,6 +22,8 @@
 #include "api/rtpreceiverinterface.h"
 #include "api/rtpsenderinterface.h"
 #include "api/test/fakeconstraints.h"
+#include "api/video_codecs/builtin_video_decoder_factory.h"
+#include "api/video_codecs/builtin_video_encoder_factory.h"
 #include "logging/rtc_event_log/output/rtc_event_log_output_file.h"
 #include "media/base/fakevideocapturer.h"
 #include "media/engine/webrtcmediaengine.h"
@@ -688,8 +690,13 @@ class PeerConnectionInterfaceBaseTest : public testing::Test {
     fake_audio_capture_module_ = FakeAudioCaptureModule::Create();
     pc_factory_ = webrtc::CreatePeerConnectionFactory(
         rtc::Thread::Current(), rtc::Thread::Current(), rtc::Thread::Current(),
-        fake_audio_capture_module_, webrtc::CreateBuiltinAudioEncoderFactory(),
+        rtc::scoped_refptr<webrtc::AudioDeviceModule>(
-        webrtc::CreateBuiltinAudioDecoderFactory(), nullptr, nullptr);
+            fake_audio_capture_module_),
+        webrtc::CreateBuiltinAudioEncoderFactory(),
+        webrtc::CreateBuiltinAudioDecoderFactory(),
+        webrtc::CreateBuiltinVideoEncoderFactory(),
+        webrtc::CreateBuiltinVideoDecoderFactory(), nullptr /* audio_mixer */,
+        nullptr /* audio_processing */);
     ASSERT_TRUE(pc_factory_);
     pc_factory_for_test_ =
         PeerConnectionFactoryForTest::CreatePeerConnectionFactoryForTest();
@@ -1398,7 +1405,10 @@ TEST_P(PeerConnectionInterfaceTest,
           rtc::Thread::Current(), rtc::Thread::Current(),
           rtc::Thread::Current(), fake_audio_capture_module_,
           webrtc::CreateBuiltinAudioEncoderFactory(),
-          webrtc::CreateBuiltinAudioDecoderFactory(), nullptr, nullptr));
+          webrtc::CreateBuiltinAudioDecoderFactory(),
+          webrtc::CreateBuiltinVideoEncoderFactory(),
+          webrtc::CreateBuiltinVideoDecoderFactory(), nullptr /* audio_mixer */,
+          nullptr /* audio_processing */));
   rtc::scoped_refptr<PeerConnectionInterface> pc(
       pc_factory->CreatePeerConnection(
           config, nullptr, std::move(port_allocator), nullptr, &observer_));

pc/test/peerconnectiontestwrapper.cc

@@ -12,6 +12,9 @@
 #include <utility>
 #include <vector>
 
+#include "api/video_codecs/builtin_video_decoder_factory.h"
+#include "api/video_codecs/builtin_video_encoder_factory.h"
+#include "modules/audio_processing/include/audio_processing.h"
 #include "p2p/base/fakeportallocator.h"
 #include "pc/sdputils.h"
 #include "pc/test/fakeperiodicvideocapturer.h"
@@ -80,8 +83,11 @@ bool PeerConnectionTestWrapper::CreatePc(
 
   peer_connection_factory_ = webrtc::CreatePeerConnectionFactory(
       network_thread_, worker_thread_, rtc::Thread::Current(),
-      fake_audio_capture_module_, audio_encoder_factory, audio_decoder_factory,
+      rtc::scoped_refptr<webrtc::AudioDeviceModule>(fake_audio_capture_module_),
-      nullptr, nullptr);
+      audio_encoder_factory, audio_decoder_factory,
+      webrtc::CreateBuiltinVideoEncoderFactory(),
+      webrtc::CreateBuiltinVideoDecoderFactory(), nullptr /* audio_mixer */,
+      nullptr /* audio_processing */);
   if (!peer_connection_factory_) {
     return false;
   }