Remove dependency in FakeWebRtcVideoCodecFactories.
Previously, constructing a PeerConnection or WebRtcVideoEngine with
fake encoder/decoder factories would result in the real, built-in factories
also being used. In https://webrtc-review.googlesource.com/c/src/+/71162, this
changed, so to temporarily allow tests to continue working exactly the same as
before, the fake factories started encapsulating the real factories. This CL
removes that behavior and updates the tests accordingly.
Bug: webrtc:9228
Change-Id: Ida14a1e3f5f5a0e2f03100b7895b3b1bdf0a0a42
Reviewed-on: https://webrtc-review.googlesource.com/75260
Reviewed-by: Patrik Höglund <phoglund@webrtc.org>
Reviewed-by: Magnus Jedvert <magjed@webrtc.org>
Reviewed-by: Taylor Brandstetter <deadbeef@webrtc.org>
Commit-Queue: Anders Carlsson <andersc@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#23209}diff --git a/BUILD.gn b/BUILD.gn
index 4f019c1..9291b62 100644
--- a/BUILD.gn
+++ b/BUILD.gn
@@ -425,6 +425,7 @@
"api:rtc_api_unittests",
"api/audio/test:audio_api_unittests",
"api/audio_codecs/test:audio_codecs_api_unittests",
+ "api/video_codecs/test:builtin_video_codec_factory_unittests",
"p2p:libstunprober_unittests",
"p2p:rtc_p2p_unittests",
"rtc_base:rtc_base_approved_unittests",
diff --git a/api/video_codecs/test/BUILD.gn b/api/video_codecs/test/BUILD.gn
new file mode 100644
index 0000000..aa68f93
--- /dev/null
+++ b/api/video_codecs/test/BUILD.gn
@@ -0,0 +1,27 @@
+# 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.
+
+import("../../../webrtc.gni")
+
+if (rtc_include_tests) {
+ rtc_source_set("builtin_video_codec_factory_unittests") {
+ testonly = true
+ sources = [
+ "builtin_video_encoder_factory_unittest.cc",
+ ]
+
+ deps = [
+ "..:builtin_video_encoder_factory",
+ "..:video_codecs_api",
+ "../../../system_wrappers:metrics_default",
+ "../../../test:field_trial",
+ "../../../test:test_support",
+ "//testing/gtest",
+ ]
+ }
+}
diff --git a/api/video_codecs/test/builtin_video_encoder_factory_unittest.cc b/api/video_codecs/test/builtin_video_encoder_factory_unittest.cc
new file mode 100644
index 0000000..73957c9
--- /dev/null
+++ b/api/video_codecs/test/builtin_video_encoder_factory_unittest.cc
@@ -0,0 +1,37 @@
+/*
+ * 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 <memory>
+
+#include "api/video_codecs/sdp_video_format.h"
+#include "test/gmock.h"
+
+namespace webrtc {
+
+TEST(BuiltinVideoEncoderFactoryTest, AnnouncesVp9AccordingToBuildFlags) {
+ std::unique_ptr<VideoEncoderFactory> factory =
+ CreateBuiltinVideoEncoderFactory();
+ bool claims_vp9_support = false;
+ for (const SdpVideoFormat& format : factory->GetSupportedFormats()) {
+ if (format.name == "VP9") {
+ claims_vp9_support = true;
+ break;
+ }
+ }
+#if defined(RTC_DISABLE_VP9)
+ EXPECT_FALSE(claims_vp9_support);
+#else
+ EXPECT_TRUE(claims_vp9_support);
+#endif // defined(RTC_DISABLE_VP9)
+}
+
+} // namespace webrtc
diff --git a/media/BUILD.gn b/media/BUILD.gn
index 2808191..402fcfb 100644
--- a/media/BUILD.gn
+++ b/media/BUILD.gn
@@ -448,6 +448,7 @@
rtc_source_set("rtc_media_tests_utils") {
testonly = true
+ defines = []
include_dirs = []
deps = [
":rtc_audio_video",
@@ -493,6 +494,10 @@
suppressed_configs += [ "//build/config/clang:find_bad_constructs" ]
}
+ if (rtc_use_h264) {
+ defines += [ "WEBRTC_USE_H264" ]
+ }
+
deps += [
":rtc_internal_video_codecs",
":rtc_media",
@@ -654,6 +659,8 @@
"../api/audio_codecs:builtin_audio_decoder_factory",
"../api/audio_codecs:builtin_audio_encoder_factory",
"../api/video:video_frame",
+ "../api/video_codecs:builtin_video_decoder_factory",
+ "../api/video_codecs:builtin_video_encoder_factory",
"../api/video_codecs:video_codecs_api",
"../audio",
"../call:call_interfaces",
diff --git a/media/engine/fakewebrtcvideoengine.cc b/media/engine/fakewebrtcvideoengine.cc
index 6f1f166..96ab1d1 100644
--- a/media/engine/fakewebrtcvideoengine.cc
+++ b/media/engine/fakewebrtcvideoengine.cc
@@ -12,7 +12,6 @@
#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"
@@ -78,19 +77,12 @@
// Decoder factory.
FakeWebRtcVideoDecoderFactory::FakeWebRtcVideoDecoderFactory()
- : num_created_decoders_(0),
- internal_decoder_factory_(new webrtc::InternalDecoderFactory()) {}
-
-FakeWebRtcVideoDecoderFactory::~FakeWebRtcVideoDecoderFactory() {
- delete internal_decoder_factory_;
-}
+ : num_created_decoders_(0) {}
std::vector<webrtc::SdpVideoFormat>
FakeWebRtcVideoDecoderFactory::GetSupportedFormats() const {
- std::vector<webrtc::SdpVideoFormat> formats =
- internal_decoder_factory_->GetSupportedFormats();
+ std::vector<webrtc::SdpVideoFormat> formats;
- // Add external codecs.
for (const webrtc::SdpVideoFormat& format : supported_codec_formats_) {
// Don't add same codec twice.
if (!IsFormatSupported(formats, format))
@@ -109,9 +101,9 @@
rtc::MakeUnique<FakeWebRtcVideoDecoder>(this);
decoders_.push_back(decoder.get());
return decoder;
- } else {
- return internal_decoder_factory_->CreateVideoDecoder(format);
}
+
+ return nullptr;
}
void FakeWebRtcVideoDecoderFactory::DecoderDestroyed(
@@ -206,19 +198,12 @@
: 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();
+ std::vector<webrtc::SdpVideoFormat> formats;
- // Add external codecs.
for (const webrtc::SdpVideoFormat& format : formats_) {
// Don't add same codec twice.
if (!IsFormatSupported(formats, format))
@@ -247,16 +232,6 @@
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;
}
@@ -264,14 +239,10 @@
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);
- }
+ webrtc::VideoEncoderFactory::CodecInfo info;
+ info.has_internal_source = encoders_have_internal_sources_;
+ info.is_hardware_accelerated = true;
+ return info;
}
bool FakeWebRtcVideoEncoderFactory::WaitForCreatedVideoEncoders(
diff --git a/media/engine/fakewebrtcvideoengine.h b/media/engine/fakewebrtcvideoengine.h
index c23e35f..8ebabb1 100644
--- a/media/engine/fakewebrtcvideoengine.h
+++ b/media/engine/fakewebrtcvideoengine.h
@@ -19,8 +19,6 @@
#include "api/video_codecs/video_decoder_factory.h"
#include "api/video_codecs/video_encoder.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/event.h"
#include "rtc_base/ptr_util.h"
@@ -37,13 +35,14 @@
explicit FakeWebRtcVideoDecoder(FakeWebRtcVideoDecoderFactory* factory);
~FakeWebRtcVideoDecoder();
- virtual int32_t InitDecode(const webrtc::VideoCodec*, int32_t);
- virtual int32_t Decode(const webrtc::EncodedImage&,
- bool,
- const webrtc::CodecSpecificInfo*,
- int64_t);
- virtual int32_t RegisterDecodeCompleteCallback(webrtc::DecodedImageCallback*);
- virtual int32_t Release();
+ int32_t InitDecode(const webrtc::VideoCodec*, int32_t) override;
+ int32_t Decode(const webrtc::EncodedImage&,
+ bool,
+ const webrtc::CodecSpecificInfo*,
+ int64_t) override;
+ int32_t RegisterDecodeCompleteCallback(
+ webrtc::DecodedImageCallback*) override;
+ int32_t Release() override;
int GetNumFramesReceived() const;
@@ -53,11 +52,9 @@
};
// Fake class for mocking out webrtc::VideoDecoderFactory.
-// TODO(bugs.webrtc.org/9228): Remove internal_decoder_factory_.
class FakeWebRtcVideoDecoderFactory : public webrtc::VideoDecoderFactory {
public:
FakeWebRtcVideoDecoderFactory();
- ~FakeWebRtcVideoDecoderFactory();
std::vector<webrtc::SdpVideoFormat> GetSupportedFormats() const override;
std::unique_ptr<webrtc::VideoDecoder> CreateVideoDecoder(
@@ -72,7 +69,6 @@
std::vector<webrtc::SdpVideoFormat> supported_codec_formats_;
std::vector<FakeWebRtcVideoDecoder*> decoders_;
int num_created_decoders_;
- webrtc::InternalDecoderFactory* internal_decoder_factory_;
};
// Fake class for mocking out webrtc::VideoEnoder
@@ -107,11 +103,9 @@
};
// Fake class for mocking out webrtc::VideoEncoderFactory.
-// TODO(bugs.webrtc.org/9228): Remove internal_encoder_factory_.
class FakeWebRtcVideoEncoderFactory : public webrtc::VideoEncoderFactory {
public:
FakeWebRtcVideoEncoderFactory();
- ~FakeWebRtcVideoEncoderFactory();
std::vector<webrtc::SdpVideoFormat> GetSupportedFormats() const override;
std::unique_ptr<webrtc::VideoEncoder> CreateVideoEncoder(
@@ -134,7 +128,6 @@
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_;
};
diff --git a/media/engine/webrtcvideoengine_unittest.cc b/media/engine/webrtcvideoengine_unittest.cc
index 31f5656..6d6e61f 100644
--- a/media/engine/webrtcvideoengine_unittest.cc
+++ b/media/engine/webrtcvideoengine_unittest.cc
@@ -17,6 +17,8 @@
#include "api/rtpparameters.h"
#include "api/test/mock_video_decoder_factory.h"
#include "api/test/mock_video_encoder_factory.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 "api/video_codecs/video_decoder_factory.h"
#include "api/video_codecs/video_encoder.h"
@@ -33,7 +35,6 @@
#include "media/engine/constants.h"
#include "media/engine/fakewebrtccall.h"
#include "media/engine/fakewebrtcvideoengine.h"
-#include "media/engine/internalencoderfactory.h"
#include "media/engine/simulcast.h"
#include "media/engine/webrtcvideoengine.h"
#include "media/engine/webrtcvoiceengine.h"
@@ -186,27 +187,12 @@
engine_(std::unique_ptr<cricket::FakeWebRtcVideoEncoderFactory>(
encoder_factory_),
std::unique_ptr<cricket::FakeWebRtcVideoDecoderFactory>(
- decoder_factory_)) {
- std::vector<VideoCodec> engine_codecs = engine_.codecs();
- RTC_DCHECK(!engine_codecs.empty());
- bool codec_set = false;
- for (const cricket::VideoCodec& codec : engine_codecs) {
- if (codec.name == "rtx") {
- int associated_payload_type;
- if (codec.GetParam(kCodecParamAssociatedPayloadType,
- &associated_payload_type)) {
- default_apt_rtx_types_[associated_payload_type] = codec.id;
- }
- } else if (!codec_set && codec.name != "red" && codec.name != "ulpfec") {
- default_codec_ = codec;
- codec_set = true;
- }
- }
-
- RTC_DCHECK(codec_set);
- }
+ decoder_factory_)) {}
protected:
+ void AssignDefaultAptRtxTypes();
+ void AssignDefaultCodec();
+
// Find the index of the codec in the engine with the given name. The codec
// must be present.
size_t GetEngineCodecIndex(const std::string& name) const;
@@ -215,9 +201,9 @@
// present.
cricket::VideoCodec GetEngineCodec(const std::string& name) const;
- VideoMediaChannel* SetUpForExternalEncoderFactory();
+ VideoMediaChannel* SetSendParamsWithAllSupportedCodecs();
- VideoMediaChannel* SetUpForExternalDecoderFactory(
+ VideoMediaChannel* SetRecvParamsWithSupportedCodecs(
const std::vector<VideoCodec>& codecs);
void TestExtendedEncoderOveruse(bool use_external_encoder);
@@ -234,22 +220,10 @@
std::map<int, int> default_apt_rtx_types_;
};
-TEST_F(WebRtcVideoEngineTest, AnnouncesVp9AccordingToBuildFlags) {
- bool claims_vp9_support = false;
- for (const cricket::VideoCodec& codec : engine_.codecs()) {
- if (codec.name == "VP9") {
- claims_vp9_support = true;
- break;
- }
- }
-#if defined(RTC_DISABLE_VP9)
- EXPECT_FALSE(claims_vp9_support);
-#else
- EXPECT_TRUE(claims_vp9_support);
-#endif // defined(RTC_DISABLE_VP9)
-}
-
TEST_F(WebRtcVideoEngineTest, DefaultRtxCodecHasAssociatedPayloadTypeSet) {
+ encoder_factory_->AddSupportedVideoCodecType("VP8");
+ AssignDefaultCodec();
+
std::vector<VideoCodec> engine_codecs = engine_.codecs();
for (size_t i = 0; i < engine_codecs.size(); ++i) {
if (engine_codecs[i].name != kRtxCodecName)
@@ -318,7 +292,8 @@
encoder_factory_->AddSupportedVideoCodecType("VP8");
- std::unique_ptr<VideoMediaChannel> channel(SetUpForExternalEncoderFactory());
+ std::unique_ptr<VideoMediaChannel> channel(
+ SetSendParamsWithAllSupportedCodecs());
EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(kSsrc)));
// Add CVO extension.
@@ -348,7 +323,8 @@
encoder_factory_->AddSupportedVideoCodecType("VP8");
- std::unique_ptr<VideoMediaChannel> channel(SetUpForExternalEncoderFactory());
+ std::unique_ptr<VideoMediaChannel> channel(
+ SetSendParamsWithAllSupportedCodecs());
// Add CVO extension.
const int id = 1;
cricket::VideoSendParameters parameters;
@@ -371,7 +347,8 @@
encoder_factory_->AddSupportedVideoCodecType("VP8");
encoder_factory_->AddSupportedVideoCodecType("VP9");
- std::unique_ptr<VideoMediaChannel> channel(SetUpForExternalEncoderFactory());
+ std::unique_ptr<VideoMediaChannel> channel(
+ SetSendParamsWithAllSupportedCodecs());
EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(kSsrc)));
// Set capturer.
@@ -401,6 +378,8 @@
}
TEST_F(WebRtcVideoEngineTest, SetSendFailsBeforeSettingCodecs) {
+ encoder_factory_->AddSupportedVideoCodecType("VP8");
+
std::unique_ptr<VideoMediaChannel> channel(
engine_.CreateChannel(call_.get(), GetMediaConfig(), VideoOptions()));
@@ -413,6 +392,8 @@
}
TEST_F(WebRtcVideoEngineTest, GetStatsWithoutSendCodecsSetDoesNotCrash) {
+ encoder_factory_->AddSupportedVideoCodecType("VP8");
+
std::unique_ptr<VideoMediaChannel> channel(
engine_.CreateChannel(call_.get(), GetMediaConfig(), VideoOptions()));
EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(123)));
@@ -420,10 +401,11 @@
channel->GetStats(&info);
}
-TEST_F(WebRtcVideoEngineTest, UseExternalFactoryForVp8WhenSupported) {
+TEST_F(WebRtcVideoEngineTest, UseFactoryForVp8WhenSupported) {
encoder_factory_->AddSupportedVideoCodecType("VP8");
- std::unique_ptr<VideoMediaChannel> channel(SetUpForExternalEncoderFactory());
+ std::unique_ptr<VideoMediaChannel> channel(
+ SetSendParamsWithAllSupportedCodecs());
channel->OnReadyToSend(true);
EXPECT_TRUE(
@@ -455,12 +437,11 @@
EXPECT_EQ(0u, encoder_factory_->encoders().size());
}
-// Test that when an external encoder factory supports a codec we don't
-// internally support, we still add an RTX codec for it.
-// TODO(deadbeef): Currently this test is only effective if WebRTC is
-// built with no internal H264 support. This test should be updated
-// if/when we start adding RTX codecs for unrecognized codec names.
-TEST_F(WebRtcVideoEngineTest, RtxCodecAddedForExternalCodec) {
+// Test that when an encoder factory supports H264, we add an RTX
+// codec for it.
+// TODO(deadbeef): This test should be updated if/when we start
+// adding RTX codecs for unrecognized codec names.
+TEST_F(WebRtcVideoEngineTest, RtxCodecAddedForH264Codec) {
using webrtc::H264::ProfileLevelIdToString;
using webrtc::H264::ProfileLevelId;
using webrtc::H264::kLevel1;
@@ -500,7 +481,8 @@
TEST_F(WebRtcVideoEngineTest, CanConstructDecoderForVp9EncoderFactory) {
encoder_factory_->AddSupportedVideoCodecType("VP9");
- std::unique_ptr<VideoMediaChannel> channel(SetUpForExternalEncoderFactory());
+ std::unique_ptr<VideoMediaChannel> channel(
+ SetSendParamsWithAllSupportedCodecs());
EXPECT_TRUE(
channel->AddRecvStream(cricket::StreamParams::CreateLegacy(kSsrc)));
@@ -511,7 +493,8 @@
encoder_factory_->AddSupportedVideoCodecType("VP8");
FakeCall* fake_call = new FakeCall();
call_.reset(fake_call);
- std::unique_ptr<VideoMediaChannel> channel(SetUpForExternalEncoderFactory());
+ std::unique_ptr<VideoMediaChannel> channel(
+ SetSendParamsWithAllSupportedCodecs());
EXPECT_TRUE(
channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
@@ -561,6 +544,35 @@
EXPECT_TRUE(channel->RemoveSendStream(kSsrc));
}
+void WebRtcVideoEngineTest::AssignDefaultAptRtxTypes() {
+ std::vector<VideoCodec> engine_codecs = engine_.codecs();
+ RTC_DCHECK(!engine_codecs.empty());
+ for (const cricket::VideoCodec& codec : engine_codecs) {
+ if (codec.name == "rtx") {
+ int associated_payload_type;
+ if (codec.GetParam(kCodecParamAssociatedPayloadType,
+ &associated_payload_type)) {
+ default_apt_rtx_types_[associated_payload_type] = codec.id;
+ }
+ }
+ }
+}
+
+void WebRtcVideoEngineTest::AssignDefaultCodec() {
+ std::vector<VideoCodec> engine_codecs = engine_.codecs();
+ RTC_DCHECK(!engine_codecs.empty());
+ bool codec_set = false;
+ for (const cricket::VideoCodec& codec : engine_codecs) {
+ if (!codec_set && codec.name != "rtx" && codec.name != "red" &&
+ codec.name != "ulpfec") {
+ default_codec_ = codec;
+ codec_set = true;
+ }
+ }
+
+ RTC_DCHECK(codec_set);
+}
+
size_t WebRtcVideoEngineTest::GetEngineCodecIndex(
const std::string& name) const {
const std::vector<cricket::VideoCodec> codecs = engine_.codecs();
@@ -590,7 +602,8 @@
return engine_.codecs()[GetEngineCodecIndex(name)];
}
-VideoMediaChannel* WebRtcVideoEngineTest::SetUpForExternalEncoderFactory() {
+VideoMediaChannel*
+WebRtcVideoEngineTest::SetSendParamsWithAllSupportedCodecs() {
VideoMediaChannel* channel =
engine_.CreateChannel(call_.get(), GetMediaConfig(), VideoOptions());
cricket::VideoSendParameters parameters;
@@ -609,7 +622,7 @@
return channel;
}
-VideoMediaChannel* WebRtcVideoEngineTest::SetUpForExternalDecoderFactory(
+VideoMediaChannel* WebRtcVideoEngineTest::SetRecvParamsWithSupportedCodecs(
const std::vector<VideoCodec>& codecs) {
VideoMediaChannel* channel =
engine_.CreateChannel(call_.get(), GetMediaConfig(), VideoOptions());
@@ -623,7 +636,8 @@
TEST_F(WebRtcVideoEngineTest, UsesSimulcastAdapterForVp8Factories) {
encoder_factory_->AddSupportedVideoCodecType("VP8");
- std::unique_ptr<VideoMediaChannel> channel(SetUpForExternalEncoderFactory());
+ std::unique_ptr<VideoMediaChannel> channel(
+ SetSendParamsWithAllSupportedCodecs());
std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs3);
@@ -657,7 +671,8 @@
ASSERT_EQ(0u, encoder_factory_->encoders().size());
}
-TEST_F(WebRtcVideoEngineTest, ChannelWithExternalH264CanChangeToInternalVp8) {
+TEST_F(WebRtcVideoEngineTest, ChannelWithH264CanChangeToVp8) {
+ encoder_factory_->AddSupportedVideoCodecType("VP8");
encoder_factory_->AddSupportedVideoCodecType("H264");
// Set capturer.
@@ -690,22 +705,6 @@
}
TEST_F(WebRtcVideoEngineTest,
- DontUseExternalEncoderFactoryForUnsupportedCodecs) {
- encoder_factory_->AddSupportedVideoCodecType("H264");
-
- std::unique_ptr<VideoMediaChannel> channel(
- engine_.CreateChannel(call_.get(), GetMediaConfig(), VideoOptions()));
- cricket::VideoSendParameters parameters;
- parameters.codecs.push_back(GetEngineCodec("VP8"));
- EXPECT_TRUE(channel->SetSendParameters(parameters));
-
- EXPECT_TRUE(
- channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
- // Make sure DestroyVideoEncoder was called on the factory.
- ASSERT_EQ(0u, encoder_factory_->encoders().size());
-}
-
-TEST_F(WebRtcVideoEngineTest,
UsesSimulcastAdapterForVp8WithCombinedVP8AndH264Factory) {
encoder_factory_->AddSupportedVideoCodecType("VP8");
encoder_factory_->AddSupportedVideoCodecType("H264");
@@ -809,6 +808,8 @@
// TODO(brandtr): Remove this test, when the FlexFEC field trial is gone.
TEST_F(WebRtcVideoEngineTest,
Flexfec03SupportedAsInternalCodecBehindFieldTrial) {
+ encoder_factory_->AddSupportedVideoCodecType("VP8");
+
auto is_flexfec = [](const VideoCodec& codec) {
if (codec.name == "flexfec-03")
return true;
@@ -828,21 +829,21 @@
std::find_if(codecs_after.begin(), codecs_after.end(), is_flexfec));
}
-// Test that external codecs are added after internal SW codecs.
-TEST_F(WebRtcVideoEngineTest, ReportSupportedExternalCodecs) {
- const char* kFakeExternalCodecName = "FakeExternalCodec";
- encoder_factory_->AddSupportedVideoCodecType(kFakeExternalCodecName);
+// Test that codecs are added in the order they are reported from the factory.
+TEST_F(WebRtcVideoEngineTest, ReportSupportedCodecs) {
+ encoder_factory_->AddSupportedVideoCodecType("VP8");
+ const char* kFakeCodecName = "FakeCodec";
+ encoder_factory_->AddSupportedVideoCodecType(kFakeCodecName);
- // The external codec should appear after the internal codec in the vector.
+ // The last reported codec should appear after the first codec in the vector.
const size_t vp8_index = GetEngineCodecIndex("VP8");
- const size_t fake_external_codec_index =
- GetEngineCodecIndex(kFakeExternalCodecName);
- EXPECT_LT(vp8_index, fake_external_codec_index);
+ const size_t fake_codec_index = GetEngineCodecIndex(kFakeCodecName);
+ EXPECT_LT(vp8_index, fake_codec_index);
}
-// Test that an external codec that was added after the engine was initialized
+// Test that a codec that was added after the engine was initialized
// does show up in the codec list after it was added.
-TEST_F(WebRtcVideoEngineTest, ReportSupportedExternalCodecsWithAddedCodec) {
+TEST_F(WebRtcVideoEngineTest, ReportSupportedAddedCodec) {
const char* kFakeExternalCodecName1 = "FakeExternalCodec1";
const char* kFakeExternalCodecName2 = "FakeExternalCodec2";
@@ -863,13 +864,14 @@
EXPECT_LT(fake_codec_index1, fake_codec_index2);
}
-TEST_F(WebRtcVideoEngineTest, RegisterExternalDecodersIfSupported) {
+TEST_F(WebRtcVideoEngineTest, RegisterDecodersIfSupported) {
+ encoder_factory_->AddSupportedVideoCodecType("VP8");
decoder_factory_->AddSupportedVideoCodecType(webrtc::SdpVideoFormat("VP8"));
cricket::VideoRecvParameters parameters;
parameters.codecs.push_back(GetEngineCodec("VP8"));
std::unique_ptr<VideoMediaChannel> channel(
- SetUpForExternalDecoderFactory(parameters.codecs));
+ SetRecvParamsWithSupportedCodecs(parameters.codecs));
EXPECT_TRUE(
channel->AddRecvStream(cricket::StreamParams::CreateLegacy(kSsrc)));
@@ -884,8 +886,8 @@
EXPECT_EQ(0u, decoder_factory_->decoders().size());
}
-// Verifies that we can set up decoders that are not internally supported.
-TEST_F(WebRtcVideoEngineTest, RegisterExternalH264DecoderIfSupported) {
+// Verifies that we can set up decoders.
+TEST_F(WebRtcVideoEngineTest, RegisterH264DecoderIfSupported) {
// TODO(pbos): Do not assume that encoder/decoder support is symmetric. We
// can't even query the WebRtcVideoDecoderFactory for supported codecs.
// For now we add a FakeWebRtcVideoEncoderFactory to add H264 to supported
@@ -896,7 +898,7 @@
codecs.push_back(GetEngineCodec("H264"));
std::unique_ptr<VideoMediaChannel> channel(
- SetUpForExternalDecoderFactory(codecs));
+ SetRecvParamsWithSupportedCodecs(codecs));
EXPECT_TRUE(
channel->AddRecvStream(cricket::StreamParams::CreateLegacy(kSsrc)));
@@ -1079,7 +1081,8 @@
TEST_F(WebRtcVideoEngineTest, DISABLED_RecreatesEncoderOnContentTypeChange) {
encoder_factory_->AddSupportedVideoCodecType("VP8");
std::unique_ptr<FakeCall> fake_call(new FakeCall());
- std::unique_ptr<VideoMediaChannel> channel(SetUpForExternalEncoderFactory());
+ std::unique_ptr<VideoMediaChannel> channel(
+ SetSendParamsWithAllSupportedCodecs());
ASSERT_TRUE(
channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
cricket::VideoCodec codec = GetEngineCodec("VP8");
@@ -1139,10 +1142,8 @@
protected:
WebRtcVideoChannelBaseTest()
: call_(webrtc::Call::Create(webrtc::Call::Config(&event_log_))),
- engine_(std::unique_ptr<cricket::FakeWebRtcVideoEncoderFactory>(
- new cricket::FakeWebRtcVideoEncoderFactory()),
- std::unique_ptr<cricket::FakeWebRtcVideoDecoderFactory>(
- new cricket::FakeWebRtcVideoDecoderFactory())) {}
+ engine_(webrtc::CreateBuiltinVideoEncoderFactory(),
+ webrtc::CreateBuiltinVideoDecoderFactory()) {}
virtual void SetUp() {
cricket::MediaConfig media_config;
@@ -1975,6 +1976,12 @@
explicit WebRtcVideoChannelTest(const char* field_trials)
: WebRtcVideoEngineTest(field_trials), last_ssrc_(0) {}
void SetUp() override {
+ encoder_factory_->AddSupportedVideoCodecType("VP8");
+ encoder_factory_->AddSupportedVideoCodecType("VP9");
+#if defined(WEBRTC_USE_H264)
+ encoder_factory_->AddSupportedVideoCodecType("H264");
+#endif
+
fake_call_.reset(new FakeCall());
channel_.reset(engine_.CreateChannel(fake_call_.get(), GetMediaConfig(),
VideoOptions()));
@@ -2570,6 +2577,7 @@
}
TEST_F(WebRtcVideoChannelTest, NackIsEnabledByDefault) {
+ AssignDefaultCodec();
VerifyCodecHasDefaultFeedbackParams(default_codec_);
cricket::VideoSendParameters parameters;
@@ -3439,6 +3447,7 @@
}
TEST_F(WebRtcVideoChannelTest, SetDefaultSendCodecs) {
+ AssignDefaultAptRtxTypes();
ASSERT_TRUE(channel_->SetSendParameters(send_parameters_));
VideoCodec codec;
@@ -5010,6 +5019,7 @@
}
TEST_F(WebRtcVideoChannelTest, RtxPacketDoesntCreateUnsignalledStream) {
+ AssignDefaultAptRtxTypes();
const cricket::VideoCodec vp8 = GetEngineCodec("VP8");
const int rtx_vp8_payload_type = default_apt_rtx_types_[vp8.id];
TestReceiveUnsignaledSsrcPacket(rtx_vp8_payload_type,
@@ -5754,6 +5764,7 @@
last_ssrc_(0) {}
void SetUp() override {
+ encoder_factory_->AddSupportedVideoCodecType("VP8");
channel_.reset(
engine_.CreateChannel(&fake_call_, GetMediaConfig(), VideoOptions()));
channel_->OnReadyToSend(true);
diff --git a/pc/peerconnection_integrationtest.cc b/pc/peerconnection_integrationtest.cc
index e5f3ad4..e697e3a 100644
--- a/pc/peerconnection_integrationtest.cc
+++ b/pc/peerconnection_integrationtest.cc
@@ -420,48 +420,14 @@
// frames.
int min_video_frames_received_per_track() const {
int min_frames = INT_MAX;
- if (video_decoder_factory_enabled_) {
- const std::vector<FakeWebRtcVideoDecoder*>& decoders =
- fake_video_decoder_factory_->decoders();
- if (decoders.empty()) {
- return 0;
- }
- for (FakeWebRtcVideoDecoder* decoder : decoders) {
- min_frames = std::min(min_frames, decoder->GetNumFramesReceived());
- }
- return min_frames;
- } else {
- if (fake_video_renderers_.empty()) {
- return 0;
- }
-
- for (const auto& pair : fake_video_renderers_) {
- min_frames = std::min(min_frames, pair.second->num_rendered_frames());
- }
- return min_frames;
+ if (fake_video_renderers_.empty()) {
+ return 0;
}
- }
- // In contrast to the above, sums the video frames received for all tracks.
- // Can be used to verify that no video frames were received, or that the
- // counts didn't increase.
- int total_video_frames_received() const {
- int total = 0;
- if (video_decoder_factory_enabled_) {
- const std::vector<FakeWebRtcVideoDecoder*>& decoders =
- fake_video_decoder_factory_->decoders();
- for (const FakeWebRtcVideoDecoder* decoder : decoders) {
- total += decoder->GetNumFramesReceived();
- }
- } else {
- for (const auto& pair : fake_video_renderers_) {
- total += pair.second->num_rendered_frames();
- }
- for (const auto& renderer : removed_fake_video_renderers_) {
- total += renderer->num_rendered_frames();
- }
+ for (const auto& pair : fake_video_renderers_) {
+ min_frames = std::min(min_frames, pair.second->num_rendered_frames());
}
- return total;
+ return min_frames;
}
// Returns a MockStatsObserver in a state after stats gathering finished,
@@ -619,10 +585,6 @@
if (!fake_audio_capture_module_) {
return false;
}
- // Note that these factories don't end up getting used unless supported
- // codecs are added to them.
- fake_video_decoder_factory_ = new FakeWebRtcVideoDecoderFactory();
- fake_video_encoder_factory_ = new FakeWebRtcVideoEncoderFactory();
rtc::Thread* const signaling_thread = rtc::Thread::Current();
peer_connection_factory_ = webrtc::CreatePeerConnectionFactory(
network_thread, worker_thread, signaling_thread,
@@ -630,11 +592,9 @@
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 */);
+ webrtc::CreateBuiltinVideoEncoderFactory(),
+ webrtc::CreateBuiltinVideoDecoderFactory(), nullptr /* audio_mixer */,
+ nullptr /* audio_processing */);
if (!peer_connection_factory_) {
return false;
}
@@ -689,12 +649,6 @@
signal_ice_candidates_ = signal;
}
- void EnableVideoDecoderFactory() {
- video_decoder_factory_enabled_ = true;
- fake_video_decoder_factory_->AddSupportedVideoCodecType(
- webrtc::SdpVideoFormat("VP8"));
- }
-
rtc::scoped_refptr<webrtc::VideoTrackInterface> CreateLocalVideoTrackInternal(
webrtc::FakePeriodicVideoSource::Config config) {
// Set max frame rate to 10fps to reduce the risk of test flakiness.
@@ -978,11 +932,6 @@
// Needed to ensure frames aren't received for removed tracks.
std::vector<std::unique_ptr<webrtc::FakeVideoTrackRenderer>>
removed_fake_video_renderers_;
- // Needed to keep track of number of frames received when external decoder
- // used.
- FakeWebRtcVideoDecoderFactory* fake_video_decoder_factory_ = nullptr;
- FakeWebRtcVideoEncoderFactory* fake_video_encoder_factory_ = nullptr;
- bool video_decoder_factory_enabled_ = false;
// For remote peer communication.
SignalingMessageReceiver* signaling_message_receiver_ = nullptr;
@@ -1317,11 +1266,6 @@
callee_->set_signal_ice_candidates(signal);
}
- void EnableVideoDecoderFactory() {
- caller_->EnableVideoDecoderFactory();
- callee_->EnableVideoDecoderFactory();
- }
-
// Messages may get lost on the unreliable DataChannel, so we send multiple
// times to avoid test flakiness.
void SendRtpDataWithRetries(webrtc::DataChannelInterface* dc,
@@ -3675,24 +3619,6 @@
ASSERT_TRUE(ExpectNewFrames(media_expectations));
}
-// This test sets up a Jsep call between two parties with external
-// VideoDecoderFactory.
-// TODO(holmer): Disabled due to sometimes crashing on buildbots.
-// See issue webrtc/2378.
-TEST_P(PeerConnectionIntegrationTest,
- DISABLED_EndToEndCallWithVideoDecoderFactory) {
- ASSERT_TRUE(CreatePeerConnectionWrappers());
- EnableVideoDecoderFactory();
- ConnectFakeSignaling();
- caller()->AddAudioVideoTracks();
- callee()->AddAudioVideoTracks();
- caller()->CreateAndSetAndSignalOffer();
- ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
- MediaExpectations media_expectations;
- media_expectations.ExpectBidirectionalAudioAndVideo();
- ASSERT_TRUE(ExpectNewFrames(media_expectations));
-}
-
// This tests that if we negotiate after calling CreateSender but before we
// have a track, then set a track later, frames from the newly-set track are
// received end-to-end.
