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}diff --git a/api/video_codecs/BUILD.gn b/api/video_codecs/BUILD.gn
index e2ac074..38951fd 100644
--- a/api/video_codecs/BUILD.gn
+++ b/api/video_codecs/BUILD.gn
@@ -35,3 +35,40 @@
"../../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",
+ ]
+}
diff --git a/api/video_codecs/builtin_video_decoder_factory.cc b/api/video_codecs/builtin_video_decoder_factory.cc
new file mode 100644
index 0000000..7395b96
--- /dev/null
+++ b/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
diff --git a/api/video_codecs/builtin_video_decoder_factory.h b/api/video_codecs/builtin_video_decoder_factory.h
new file mode 100644
index 0000000..1f8e75c
--- /dev/null
+++ b/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_
diff --git a/api/video_codecs/builtin_video_encoder_factory.cc b/api/video_codecs/builtin_video_encoder_factory.cc
new file mode 100644
index 0000000..b866810
--- /dev/null
+++ b/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
diff --git a/api/video_codecs/builtin_video_encoder_factory.h b/api/video_codecs/builtin_video_encoder_factory.h
new file mode 100644
index 0000000..6a6618f
--- /dev/null
+++ b/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_
diff --git a/examples/BUILD.gn b/examples/BUILD.gn
index c9c2752..ed6e060 100644
--- a/examples/BUILD.gn
+++ b/examples/BUILD.gn
@@ -670,7 +670,11 @@
"../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",
diff --git a/examples/peerconnection/client/conductor.cc b/examples/peerconnection/client/conductor.cc
index 7e36746..2483e48 100644
--- a/examples/peerconnection/client/conductor.cc
+++ b/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 @@
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",
diff --git a/media/BUILD.gn b/media/BUILD.gn
index fe6b4c0..589c7bc 100644
--- a/media/BUILD.gn
+++ b/media/BUILD.gn
@@ -486,6 +486,7 @@
"engine/fakewebrtcdeviceinfo.h",
"engine/fakewebrtcvcmfactory.h",
"engine/fakewebrtcvideocapturemodule.h",
+ "engine/fakewebrtcvideoengine.cc",
"engine/fakewebrtcvideoengine.h",
]
diff --git a/media/engine/fakewebrtcvideoengine.cc b/media/engine/fakewebrtcvideoengine.cc
new file mode 100644
index 0000000..59157eb
--- /dev/null
+++ b/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
diff --git a/media/engine/fakewebrtcvideoengine.h b/media/engine/fakewebrtcvideoengine.h
index 3705a83..3a1fbdd 100644
--- a/media/engine/fakewebrtcvideoengine.h
+++ b/media/engine/fakewebrtcvideoengine.h
@@ -11,248 +11,132 @@
#ifndef MEDIA_ENGINE_FAKEWEBRTCVIDEOENGINE_H_
#define MEDIA_ENGINE_FAKEWEBRTCVIDEOENGINE_H_
-#include <map>
-#include <set>
-#include <vector>
+#include <memory>
#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 "media/engine/webrtcvideodecoderfactory.h"
-#include "media/engine/webrtcvideoencoderfactory.h"
-#include "modules/video_coding/include/video_error_codes.h"
-#include "rtc_base/basictypes.h"
+#include "api/video_codecs/video_encoder_factory.h"
+#include "media/engine/internaldecoderfactory.h"
+#include "media/engine/internalencoderfactory.h"
#include "rtc_base/criticalsection.h"
-#include "rtc_base/gunit.h"
-#include "rtc_base/stringutils.h"
+#include "rtc_base/event.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) {
- num_frames_received_++;
- return WEBRTC_VIDEO_CODEC_OK;
- }
+ int64_t);
+ virtual int32_t RegisterDecodeCompleteCallback(webrtc::DecodedImageCallback*);
+ virtual int32_t Release();
- virtual int32_t RegisterDecodeCompleteCallback(
- webrtc::DecodedImageCallback*) {
- return WEBRTC_VIDEO_CODEC_OK;
- }
-
- virtual int32_t Release() { return WEBRTC_VIDEO_CODEC_OK; }
-
- int GetNumFramesReceived() const {
- return num_frames_received_;
- }
+ int GetNumFramesReceived() const;
private:
int num_frames_received_;
+ FakeWebRtcVideoDecoderFactory* factory_;
};
-// Fake class for mocking out WebRtcVideoDecoderFactory.
-class FakeWebRtcVideoDecoderFactory : public WebRtcVideoDecoderFactory {
+// Fake class for mocking out webrtc::VideoDecoderFactory.
+// TODO(bugs.webrtc.org/9228): Remove internal_decoder_factory_.
+class FakeWebRtcVideoDecoderFactory : public webrtc::VideoDecoderFactory {
public:
- FakeWebRtcVideoDecoderFactory()
- : num_created_decoders_(0) {
- }
+ FakeWebRtcVideoDecoderFactory();
+ ~FakeWebRtcVideoDecoderFactory();
- virtual webrtc::VideoDecoder* CreateVideoDecoder(
- webrtc::VideoCodecType type) {
- if (supported_codec_types_.count(type) == 0) {
- return NULL;
- }
- FakeWebRtcVideoDecoder* decoder = new FakeWebRtcVideoDecoder();
- decoders_.push_back(decoder);
- num_created_decoders_++;
- return decoder;
- }
+ std::vector<webrtc::SdpVideoFormat> GetSupportedFormats() const override;
+ std::unique_ptr<webrtc::VideoDecoder> CreateVideoDecoder(
+ const webrtc::SdpVideoFormat& format) override;
- virtual webrtc::VideoDecoder* CreateVideoDecoderWithParams(
- webrtc::VideoCodecType type,
- VideoDecoderParams params) {
- params_.push_back(params);
- 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_; }
+ void DecoderDestroyed(FakeWebRtcVideoDecoder* decoder);
+ void AddSupportedVideoCodecType(const webrtc::SdpVideoFormat& format);
+ int GetNumCreatedDecoders();
+ const std::vector<FakeWebRtcVideoDecoder*>& decoders();
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()
- : init_encode_event_(false, false), num_frames_encoded_(0) {}
+ explicit FakeWebRtcVideoEncoder(FakeWebRtcVideoEncoderFactory* factory);
+ ~FakeWebRtcVideoEncoder();
int32_t InitEncode(const webrtc::VideoCodec* codecSettings,
int32_t numberOfCores,
- 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_;
- }
-
+ size_t maxPayloadSize) override;
int32_t Encode(const webrtc::VideoFrame& inputImage,
const webrtc::CodecSpecificInfo* codecSpecificInfo,
- const std::vector<webrtc::FrameType>* frame_types) override {
- rtc::CritScope lock(&crit_);
- ++num_frames_encoded_;
- init_encode_event_.Set();
- return WEBRTC_VIDEO_CODEC_OK;
- }
-
+ const std::vector<webrtc::FrameType>* frame_types) override;
int32_t RegisterEncodeCompleteCallback(
- webrtc::EncodedImageCallback* callback) override {
- return WEBRTC_VIDEO_CODEC_OK;
- }
-
- int32_t Release() override { return WEBRTC_VIDEO_CODEC_OK; }
-
- int32_t SetChannelParameters(uint32_t packetLoss, int64_t rtt) override {
- return WEBRTC_VIDEO_CODEC_OK;
- }
-
+ webrtc::EncodedImageCallback* callback) override;
+ int32_t Release() override;
+ int32_t SetChannelParameters(uint32_t packetLoss, int64_t rtt) override;
int32_t SetRateAllocation(const webrtc::VideoBitrateAllocation& allocation,
- uint32_t framerate) override {
- return WEBRTC_VIDEO_CODEC_OK;
- }
+ uint32_t framerate) override;
- int GetNumEncodedFrames() {
- rtc::CritScope lock(&crit_);
- return num_frames_encoded_;
- }
+ bool WaitForInitEncode();
+ webrtc::VideoCodec GetCodecSettings();
+ 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.
-class FakeWebRtcVideoEncoderFactory : public WebRtcVideoEncoderFactory {
+// Fake class for mocking out webrtc::VideoEncoderFactory.
+// TODO(bugs.webrtc.org/9228): Remove internal_encoder_factory_.
+class FakeWebRtcVideoEncoderFactory : public webrtc::VideoEncoderFactory {
public:
- FakeWebRtcVideoEncoderFactory()
- : created_video_encoder_event_(false, false),
- num_created_encoders_(0),
- encoders_have_internal_sources_(false) {}
+ FakeWebRtcVideoEncoderFactory();
+ ~FakeWebRtcVideoEncoderFactory();
- webrtc::VideoEncoder* CreateVideoEncoder(
- const cricket::VideoCodec& codec) override {
- rtc::CritScope lock(&crit_);
- if (!FindMatchingCodec(codecs_, codec))
- return nullptr;
- FakeWebRtcVideoEncoder* encoder = new FakeWebRtcVideoEncoder();
- encoders_.push_back(encoder);
- num_created_encoders_++;
- created_video_encoder_event_.Set();
- return encoder;
- }
+ std::vector<webrtc::SdpVideoFormat> GetSupportedFormats() const override;
+ std::unique_ptr<webrtc::VideoEncoder> CreateVideoEncoder(
+ const webrtc::SdpVideoFormat& format) override;
+ CodecInfo QueryVideoEncoder(
+ const webrtc::SdpVideoFormat& format) const override;
- bool 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 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_;
- }
+ bool WaitForCreatedVideoEncoders(int num_encoders);
+ void EncoderDestroyed(FakeWebRtcVideoEncoder* encoder);
+ void set_encoders_have_internal_sources(bool internal_source);
+ void AddSupportedVideoCodec(const webrtc::SdpVideoFormat& format);
+ void AddSupportedVideoCodecType(const std::string& name);
+ int GetNumCreatedEncoders();
+ const std::vector<FakeWebRtcVideoEncoder*> 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
diff --git a/media/engine/vp8_encoder_simulcast_proxy.h b/media/engine/vp8_encoder_simulcast_proxy.h
index 7e9fd4e..7763ad0 100644
--- a/media/engine/vp8_encoder_simulcast_proxy.h
+++ b/media/engine/vp8_encoder_simulcast_proxy.h
@@ -25,7 +25,7 @@
class VP8EncoderSimulcastProxy : public VP8Encoder {
public:
explicit VP8EncoderSimulcastProxy(VideoEncoderFactory* factory);
- virtual ~VP8EncoderSimulcastProxy();
+ ~VP8EncoderSimulcastProxy() override;
// Implements VideoEncoder.
int Release() override;
diff --git a/media/engine/webrtcvideoengine_unittest.cc b/media/engine/webrtcvideoengine_unittest.cc
index 6be9bc7..54f6470 100644
--- a/media/engine/webrtcvideoengine_unittest.cc
+++ b/media/engine/webrtcvideoengine_unittest.cc
@@ -183,9 +183,9 @@
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 @@
// 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 @@
using webrtc::H264::ProfileLevelIdToString;
using webrtc::H264::ProfileLevelId;
using webrtc::H264::kLevel1;
- cricket::VideoCodec h264_constrained_baseline("H264");
- h264_constrained_baseline.params[kH264FmtpProfileLevelId] =
+ webrtc::SdpVideoFormat h264_constrained_baseline("H264");
+ h264_constrained_baseline.parameters[kH264FmtpProfileLevelId] =
*ProfileLevelIdToString(
ProfileLevelId(webrtc::H264::kProfileConstrainedBaseline, kLevel1));
- cricket::VideoCodec h264_constrained_high("H264");
- h264_constrained_high.params[kH264FmtpProfileLevelId] =
+ webrtc::SdpVideoFormat h264_constrained_high("H264");
+ h264_constrained_high.parameters[kH264FmtpProfileLevelId] =
*ProfileLevelIdToString(
ProfileLevelId(webrtc::H264::kProfileConstrainedHigh, kLevel1));
- cricket::VideoCodec h264_high("H264");
- h264_high.params[kH264FmtpProfileLevelId] = *ProfileLevelIdToString(
+ webrtc::SdpVideoFormat h264_high("H264");
+ h264_high.parameters[kH264FmtpProfileLevelId] = *ProfileLevelIdToString(
ProfileLevelId(webrtc::H264::kProfileHigh, kLevel1));
encoder_factory_->AddSupportedVideoCodec(h264_constrained_baseline);
@@ -489,11 +485,15 @@
// 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 @@
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())
- parameters.codecs.push_back(GetEngineCodec(codec.name));
+ for (const webrtc::SdpVideoFormat& format :
+ 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 @@
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 @@
ASSERT_EQ_WAIT(1u, encoder_factory_->encoders().size(), kTimeout);
- cricket::VideoSendParameters parameters;
- parameters.codecs.push_back(GetEngineCodec("VP8"));
- EXPECT_TRUE(channel->SetSendParameters(parameters));
+ cricket::VideoSendParameters new_parameters;
+ new_parameters.codecs.push_back(GetEngineCodec("VP8"));
+ EXPECT_TRUE(channel->SetSendParameters(new_parameters));
// Sending one frame will switch encoder.
EXPECT_TRUE(capturer.CaptureFrame());
@@ -766,7 +776,11 @@
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, 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 @@
// 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 @@
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 @@
::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 @@
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 @@
protected:
WebRtcVideoChannelBaseTest()
: call_(webrtc::Call::Create(webrtc::Call::Config(&event_log_))),
- engine_(std::unique_ptr<cricket::WebRtcVideoEncoderFactory>(),
- std::unique_ptr<cricket::WebRtcVideoDecoderFactory>()) {}
+ engine_(std::unique_ptr<cricket::FakeWebRtcVideoEncoderFactory>(
+ new cricket::FakeWebRtcVideoEncoderFactory()),
+ std::unique_ptr<cricket::FakeWebRtcVideoDecoderFactory>(
+ new cricket::FakeWebRtcVideoDecoderFactory())) {}
virtual void SetUp() {
cricket::MediaConfig media_config;
@@ -5721,9 +5718,9 @@
: 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) {}
diff --git a/pc/BUILD.gn b/pc/BUILD.gn
index 23c5ef4..5cb084f 100644
--- a/pc/BUILD.gn
+++ b/pc/BUILD.gn
@@ -377,6 +377,8 @@
"../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 @@
"../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 @@
"../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",
diff --git a/pc/peerconnection_bundle_unittest.cc b/pc/peerconnection_bundle_unittest.cc
index dfd47cd..b31861d 100644
--- a/pc/peerconnection_bundle_unittest.cc
+++ b/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 @@
#endif
pc_factory_ = CreatePeerConnectionFactory(
rtc::Thread::Current(), rtc::Thread::Current(), rtc::Thread::Current(),
- FakeAudioCaptureModule::Create(), CreateBuiltinAudioEncoderFactory(),
- CreateBuiltinAudioDecoderFactory(), nullptr, nullptr);
+ rtc::scoped_refptr<AudioDeviceModule>(FakeAudioCaptureModule::Create()),
+ CreateBuiltinAudioEncoderFactory(), CreateBuiltinAudioDecoderFactory(),
+ CreateBuiltinVideoEncoderFactory(), CreateBuiltinVideoDecoderFactory(),
+ nullptr /* audio_mixer */, nullptr /* audio_processing */);
}
WrapperPtr CreatePeerConnection() {
diff --git a/pc/peerconnection_crypto_unittest.cc b/pc/peerconnection_crypto_unittest.cc
index b2f2469..5077358 100644
--- a/pc/peerconnection_crypto_unittest.cc
+++ b/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 @@
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() {
diff --git a/pc/peerconnection_ice_unittest.cc b/pc/peerconnection_ice_unittest.cc
index 1f8213e..3c1782c 100644
--- a/pc/peerconnection_ice_unittest.cc
+++ b/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 @@
#endif
pc_factory_ = CreatePeerConnectionFactory(
rtc::Thread::Current(), rtc::Thread::Current(), rtc::Thread::Current(),
- FakeAudioCaptureModule::Create(), CreateBuiltinAudioEncoderFactory(),
- CreateBuiltinAudioDecoderFactory(), nullptr, nullptr);
+ rtc::scoped_refptr<AudioDeviceModule>(FakeAudioCaptureModule::Create()),
+ CreateBuiltinAudioEncoderFactory(), CreateBuiltinAudioDecoderFactory(),
+ CreateBuiltinVideoEncoderFactory(), CreateBuiltinVideoDecoderFactory(),
+ nullptr /* audio_mixer */, nullptr /* audio_processing */);
}
WrapperPtr CreatePeerConnection() {
@@ -948,7 +952,9 @@
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(
diff --git a/pc/peerconnection_integrationtest.cc b/pc/peerconnection_integrationtest.cc
index 40218e7..c3a41e4 100644
--- a/pc/peerconnection_integrationtest.cc
+++ b/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 @@
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(),
- webrtc::CreateBuiltinAudioDecoderFactory(), fake_video_encoder_factory_,
- fake_video_decoder_factory_);
+ rtc::scoped_refptr<webrtc::AudioDeviceModule>(
+ fake_audio_capture_module_),
+ 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 @@
void EnableVideoDecoderFactory() {
video_decoder_factory_enabled_ = true;
fake_video_decoder_factory_->AddSupportedVideoCodecType(
- webrtc::kVideoCodecVP8);
+ webrtc::SdpVideoFormat("VP8"));
}
rtc::scoped_refptr<webrtc::VideoTrackInterface> CreateLocalVideoTrackInternal(
diff --git a/pc/peerconnection_rtp_unittest.cc b/pc/peerconnection_rtp_unittest.cc
index 942bd46..36fa5c7 100644
--- a/pc/peerconnection_rtp_unittest.cc
+++ b/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 @@
FakeAudioCaptureModule::Create(),
CreateBuiltinAudioEncoderFactory(),
CreateBuiltinAudioDecoderFactory(),
- nullptr,
- nullptr)) {}
+ CreateBuiltinVideoEncoderFactory(),
+ CreateBuiltinVideoDecoderFactory(),
+ nullptr /* audio_mixer */,
+ nullptr /* audio_processing */)) {}
std::unique_ptr<PeerConnectionWrapper> CreatePeerConnection() {
return CreatePeerConnection(RTCConfiguration());
diff --git a/pc/peerconnection_signaling_unittest.cc b/pc/peerconnection_signaling_unittest.cc
index 3059fd2..73a659b 100644
--- a/pc/peerconnection_signaling_unittest.cc
+++ b/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 @@
#endif
pc_factory_ = CreatePeerConnectionFactory(
rtc::Thread::Current(), rtc::Thread::Current(), rtc::Thread::Current(),
- FakeAudioCaptureModule::Create(), CreateBuiltinAudioEncoderFactory(),
- CreateBuiltinAudioDecoderFactory(), nullptr, nullptr);
+ rtc::scoped_refptr<AudioDeviceModule>(FakeAudioCaptureModule::Create()),
+ CreateBuiltinAudioEncoderFactory(), CreateBuiltinAudioDecoderFactory(),
+ CreateBuiltinVideoEncoderFactory(), CreateBuiltinVideoDecoderFactory(),
+ nullptr /* audio_mixer */, nullptr /* audio_processing */);
}
WrapperPtr CreatePeerConnection() {
diff --git a/pc/peerconnectionfactory_unittest.cc b/pc/peerconnectionfactory_unittest.cc
index c8133a3..66036b1 100644
--- a/pc/peerconnectionfactory_unittest.cc
+++ b/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 @@
// 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(),
- FakeAudioCaptureModule::Create(),
+ rtc::Thread::Current(), rtc::Thread::Current(), rtc::Thread::Current(),
+ 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 @@
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;
diff --git a/pc/peerconnectioninterface_unittest.cc b/pc/peerconnectioninterface_unittest.cc
index 0d5f177..799baa6 100644
--- a/pc/peerconnectioninterface_unittest.cc
+++ b/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 @@
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(),
- webrtc::CreateBuiltinAudioDecoderFactory(), nullptr, nullptr);
+ rtc::scoped_refptr<webrtc::AudioDeviceModule>(
+ 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 @@
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_));
diff --git a/pc/test/peerconnectiontestwrapper.cc b/pc/test/peerconnectiontestwrapper.cc
index 1b87208..a3ee5ab3 100644
--- a/pc/test/peerconnectiontestwrapper.cc
+++ b/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 @@
peer_connection_factory_ = webrtc::CreatePeerConnectionFactory(
network_thread_, worker_thread_, rtc::Thread::Current(),
- fake_audio_capture_module_, audio_encoder_factory, audio_decoder_factory,
- nullptr, nullptr);
+ rtc::scoped_refptr<webrtc::AudioDeviceModule>(fake_audio_capture_module_),
+ audio_encoder_factory, audio_decoder_factory,
+ webrtc::CreateBuiltinVideoEncoderFactory(),
+ webrtc::CreateBuiltinVideoDecoderFactory(), nullptr /* audio_mixer */,
+ nullptr /* audio_processing */);
if (!peer_connection_factory_) {
return false;
}