Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(46)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: webrtc/media/engine/webrtcvideoengine2_unittest.cc

Issue 2511933002: Reland of Stop using hardcoded payload types for video codecs (Closed)
Patch Set: Remove singleton pattern for InternalEncoderFactory Created 4 years, 1 month ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « webrtc/media/engine/webrtcvideoengine2.cc ('k') | webrtc/video/BUILD.gn » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: webrtc/media/engine/webrtcvideoengine2_unittest.cc
diff --git a/webrtc/media/engine/webrtcvideoengine2_unittest.cc b/webrtc/media/engine/webrtcvideoengine2_unittest.cc
index 19b7d644cd8942ea702158e08efef53adccf5e3f..70de26711a93871df73b41c364b4263a80a14e90 100644
--- a/webrtc/media/engine/webrtcvideoengine2_unittest.cc
+++ b/webrtc/media/engine/webrtcvideoengine2_unittest.cc
@@ -33,13 +33,6 @@ using webrtc::RtpExtension;
namespace {
static const int kDefaultQpMax = 56;
-static const cricket::VideoCodec kVp8Codec(100, "VP8");
-static const cricket::VideoCodec kVp9Codec(101, "VP9");
-static const cricket::VideoCodec kH264Codec(102, "H264");
-
-static const cricket::VideoCodec kRedCodec(116, "red");
-static const cricket::VideoCodec kUlpfecCodec(117, "ulpfec");
-
static const uint8_t kRedRtxPayloadType = 125;
static const uint32_t kSsrcs1[] = {1};
@@ -49,6 +42,11 @@ static const uint32_t kIncomingUnsignalledSsrc = 0xC0FFEE;
static const char kUnsupportedExtensionName[] =
"urn:ietf:params:rtp-hdrext:unsupported";
+cricket::VideoCodec RemoveFeedbackParams(cricket::VideoCodec&& codec) {
+ codec.feedback_params = cricket::FeedbackParams();
+ return codec;
+}
+
void VerifyCodecHasDefaultFeedbackParams(const cricket::VideoCodec& codec) {
EXPECT_TRUE(codec.HasFeedbackParam(cricket::FeedbackParam(
cricket::kRtcpFbParamNack, cricket::kParamValueEmpty)));
@@ -113,19 +111,15 @@ class WebRtcVideoEngine2Test : public ::testing::Test {
std::vector<VideoCodec> engine_codecs = engine_.codecs();
RTC_DCHECK(!engine_codecs.empty());
bool codec_set = false;
- for (size_t i = 0; i < engine_codecs.size(); ++i) {
- if (engine_codecs[i].name == "red") {
- default_red_codec_ = engine_codecs[i];
- } else if (engine_codecs[i].name == "ulpfec") {
- default_ulpfec_codec_ = engine_codecs[i];
- } else if (engine_codecs[i].name == "rtx") {
+ for (const cricket::VideoCodec& codec : engine_codecs) {
+ if (codec.name == "rtx") {
int associated_payload_type;
- if (engine_codecs[i].GetParam(kCodecParamAssociatedPayloadType,
- &associated_payload_type)) {
- default_apt_rtx_types_[associated_payload_type] = engine_codecs[i].id;
+ if (codec.GetParam(kCodecParamAssociatedPayloadType,
+ &associated_payload_type)) {
+ default_apt_rtx_types_[associated_payload_type] = codec.id;
}
- } else if (!codec_set) {
- default_codec_ = engine_codecs[i];
+ } else if (!codec_set && codec.name != "red" && codec.name != "ulpfec") {
+ default_codec_ = codec;
codec_set = true;
}
}
@@ -134,9 +128,12 @@ class WebRtcVideoEngine2Test : public ::testing::Test {
}
protected:
+ // Find the codec in the engine with the given name. The codec must be
+ // present.
+ cricket::VideoCodec GetEngineCodec(const std::string& name);
+
VideoMediaChannel* SetUpForExternalEncoderFactory(
- cricket::WebRtcVideoEncoderFactory* encoder_factory,
- const std::vector<VideoCodec>& codecs);
+ cricket::WebRtcVideoEncoderFactory* encoder_factory);
VideoMediaChannel* SetUpForExternalDecoderFactory(
cricket::WebRtcVideoDecoderFactory* decoder_factory,
@@ -151,8 +148,6 @@ class WebRtcVideoEngine2Test : public ::testing::Test {
std::unique_ptr<webrtc::Call> call_;
WebRtcVideoEngine2 engine_;
VideoCodec default_codec_;
- VideoCodec default_red_codec_;
- VideoCodec default_ulpfec_codec_;
std::map<int, int> default_apt_rtx_types_;
};
@@ -240,15 +235,15 @@ TEST_F(WebRtcVideoEngine2Test, CVOSetHeaderExtensionBeforeCapturer) {
cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
encoder_factory.AddSupportedVideoCodecType("VP8");
- cricket::VideoSendParameters parameters;
- parameters.codecs.push_back(kVp8Codec);
std::unique_ptr<VideoMediaChannel> channel(
- SetUpForExternalEncoderFactory(&encoder_factory, parameters.codecs));
+ SetUpForExternalEncoderFactory(&encoder_factory));
EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(kSsrc)));
// Add CVO extension.
const int id = 1;
+ cricket::VideoSendParameters parameters;
+ parameters.codecs.push_back(GetEngineCodec("VP8"));
parameters.extensions.push_back(
RtpExtension(RtpExtension::kVideoRotationUri, id));
EXPECT_TRUE(channel->SetSendParameters(parameters));
@@ -272,13 +267,13 @@ TEST_F(WebRtcVideoEngine2Test, CVOSetHeaderExtensionBeforeAddSendStream) {
cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
encoder_factory.AddSupportedVideoCodecType("VP8");
- cricket::VideoSendParameters parameters;
- parameters.codecs.push_back(kVp8Codec);
std::unique_ptr<VideoMediaChannel> channel(
- SetUpForExternalEncoderFactory(&encoder_factory, parameters.codecs));
+ SetUpForExternalEncoderFactory(&encoder_factory));
// Add CVO extension.
const int id = 1;
+ cricket::VideoSendParameters parameters;
+ parameters.codecs.push_back(GetEngineCodec("VP8"));
parameters.extensions.push_back(
RtpExtension(RtpExtension::kVideoRotationUri, id));
EXPECT_TRUE(channel->SetSendParameters(parameters));
@@ -297,12 +292,9 @@ TEST_F(WebRtcVideoEngine2Test, CVOSetHeaderExtensionAfterCapturer) {
cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
encoder_factory.AddSupportedVideoCodecType("VP8");
encoder_factory.AddSupportedVideoCodecType("VP9");
- cricket::VideoSendParameters parameters;
- parameters.codecs.push_back(kVp8Codec);
- parameters.codecs.push_back(kVp9Codec);
std::unique_ptr<VideoMediaChannel> channel(
- SetUpForExternalEncoderFactory(&encoder_factory, parameters.codecs));
+ SetUpForExternalEncoderFactory(&encoder_factory));
EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(kSsrc)));
// Set capturer.
@@ -313,6 +305,9 @@ TEST_F(WebRtcVideoEngine2Test, CVOSetHeaderExtensionAfterCapturer) {
// Add CVO extension.
const int id = 1;
+ cricket::VideoSendParameters parameters;
+ parameters.codecs.push_back(GetEngineCodec("VP8"));
+ parameters.codecs.push_back(GetEngineCodec("VP9"));
parameters.extensions.push_back(
RtpExtension(RtpExtension::kVideoRotationUri, id));
// Also remove the first codec to trigger a codec change as well.
@@ -353,11 +348,9 @@ TEST_F(WebRtcVideoEngine2Test, GetStatsWithoutSendCodecsSetDoesNotCrash) {
TEST_F(WebRtcVideoEngine2Test, UseExternalFactoryForVp8WhenSupported) {
cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
encoder_factory.AddSupportedVideoCodecType("VP8");
- cricket::VideoSendParameters parameters;
- parameters.codecs.push_back(kVp8Codec);
std::unique_ptr<VideoMediaChannel> channel(
- SetUpForExternalEncoderFactory(&encoder_factory, parameters.codecs));
+ SetUpForExternalEncoderFactory(&encoder_factory));
EXPECT_TRUE(
channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
@@ -378,6 +371,8 @@ TEST_F(WebRtcVideoEngine2Test, UseExternalFactoryForVp8WhenSupported) {
// Setting codecs of the same type should not reallocate any encoders
// (expecting a no-op).
+ cricket::VideoSendParameters parameters;
+ parameters.codecs.push_back(GetEngineCodec("VP8"));
EXPECT_TRUE(channel->SetSendParameters(parameters));
EXPECT_EQ(num_created_encoders, encoder_factory.GetNumCreatedEncoders());
@@ -416,13 +411,13 @@ TEST_F(WebRtcVideoEngine2Test, RtxCodecAddedForExternalCodec) {
// First figure out what payload types the test codecs got assigned.
const std::vector<cricket::VideoCodec> codecs = engine_.codecs();
- // Now search for RTX codecs for them. Expect that Constrained Baseline and
- // Constrained High got an associated RTX codec, but not High.
+ // 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));
EXPECT_TRUE(HasRtxCodec(
codecs, FindMatchingCodec(codecs, h264_constrained_high)->id));
- EXPECT_FALSE(HasRtxCodec(
+ EXPECT_TRUE(HasRtxCodec(
codecs, FindMatchingCodec(codecs, h264_high)->id));
}
@@ -430,14 +425,11 @@ void WebRtcVideoEngine2Test::TestExtendedEncoderOveruse(
bool use_external_encoder) {
cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
encoder_factory.AddSupportedVideoCodecType("VP8");
- cricket::VideoSendParameters parameters;
- parameters.codecs.push_back(kVp8Codec);
std::unique_ptr<VideoMediaChannel> channel;
FakeCall* fake_call = new FakeCall(webrtc::Call::Config(&event_log_));
call_.reset(fake_call);
if (use_external_encoder) {
- channel.reset(
- SetUpForExternalEncoderFactory(&encoder_factory, parameters.codecs));
+ channel.reset(SetUpForExternalEncoderFactory(&encoder_factory));
} else {
engine_.Init();
channel.reset(
@@ -445,6 +437,8 @@ void WebRtcVideoEngine2Test::TestExtendedEncoderOveruse(
}
ASSERT_TRUE(
channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
+ cricket::VideoSendParameters parameters;
+ parameters.codecs.push_back(GetEngineCodec("VP8"));
EXPECT_TRUE(channel->SetSendParameters(parameters));
EXPECT_TRUE(channel->SetSend(true));
FakeVideoSendStream* stream = fake_call->GetVideoSendStreams()[0];
@@ -467,11 +461,9 @@ TEST_F(WebRtcVideoEngine2Test, DisablesFullEncoderTimeForNonExternalEncoders) {
TEST_F(WebRtcVideoEngine2Test, CanConstructDecoderForVp9EncoderFactory) {
cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
encoder_factory.AddSupportedVideoCodecType("VP9");
- std::vector<cricket::VideoCodec> codecs;
- codecs.push_back(kVp9Codec);
std::unique_ptr<VideoMediaChannel> channel(
- SetUpForExternalEncoderFactory(&encoder_factory, codecs));
+ SetUpForExternalEncoderFactory(&encoder_factory));
EXPECT_TRUE(
channel->AddRecvStream(cricket::StreamParams::CreateLegacy(kSsrc)));
@@ -481,12 +473,10 @@ TEST_F(WebRtcVideoEngine2Test, CanConstructDecoderForVp9EncoderFactory) {
TEST_F(WebRtcVideoEngine2Test, PropagatesInputFrameTimestamp) {
cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
encoder_factory.AddSupportedVideoCodecType("VP8");
- std::vector<cricket::VideoCodec> codecs;
- codecs.push_back(kVp8Codec);
FakeCall* fake_call = new FakeCall(webrtc::Call::Config(&event_log_));
call_.reset(fake_call);
std::unique_ptr<VideoMediaChannel> channel(
- SetUpForExternalEncoderFactory(&encoder_factory, codecs));
+ SetUpForExternalEncoderFactory(&encoder_factory));
EXPECT_TRUE(
channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
@@ -536,16 +526,29 @@ TEST_F(WebRtcVideoEngine2Test, PropagatesInputFrameTimestamp) {
EXPECT_TRUE(channel->RemoveSendStream(kSsrc));
}
+cricket::VideoCodec WebRtcVideoEngine2Test::GetEngineCodec(
+ const std::string& name) {
+ for (const cricket::VideoCodec& engine_codec : engine_.codecs()) {
+ if (CodecNamesEq(name, engine_codec.name))
+ return engine_codec;
+ }
+ // This point should never be reached.
+ ADD_FAILURE() << "Unrecognized codec name: " << name;
+ return cricket::VideoCodec();
+}
+
VideoMediaChannel* WebRtcVideoEngine2Test::SetUpForExternalEncoderFactory(
- cricket::WebRtcVideoEncoderFactory* encoder_factory,
- const std::vector<VideoCodec>& codecs) {
+ cricket::WebRtcVideoEncoderFactory* encoder_factory) {
engine_.SetExternalEncoderFactory(encoder_factory);
engine_.Init();
VideoMediaChannel* channel =
engine_.CreateChannel(call_.get(), MediaConfig(), VideoOptions());
cricket::VideoSendParameters parameters;
- parameters.codecs = codecs;
+ // 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));
+
EXPECT_TRUE(channel->SetSendParameters(parameters));
return channel;
@@ -569,11 +572,9 @@ VideoMediaChannel* WebRtcVideoEngine2Test::SetUpForExternalDecoderFactory(
TEST_F(WebRtcVideoEngine2Test, UsesSimulcastAdapterForVp8Factories) {
cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
encoder_factory.AddSupportedVideoCodecType("VP8");
- std::vector<cricket::VideoCodec> codecs;
- codecs.push_back(kVp8Codec);
std::unique_ptr<VideoMediaChannel> channel(
- SetUpForExternalEncoderFactory(&encoder_factory, codecs));
+ SetUpForExternalEncoderFactory(&encoder_factory));
std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs3);
@@ -610,18 +611,16 @@ TEST_F(WebRtcVideoEngine2Test, UsesSimulcastAdapterForVp8Factories) {
TEST_F(WebRtcVideoEngine2Test, ChannelWithExternalH264CanChangeToInternalVp8) {
cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
encoder_factory.AddSupportedVideoCodecType("H264");
- std::vector<cricket::VideoCodec> codecs;
- codecs.push_back(kH264Codec);
std::unique_ptr<VideoMediaChannel> channel(
- SetUpForExternalEncoderFactory(&encoder_factory, codecs));
+ SetUpForExternalEncoderFactory(&encoder_factory));
EXPECT_TRUE(
channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
ASSERT_EQ(1u, encoder_factory.encoders().size());
cricket::VideoSendParameters parameters;
- parameters.codecs.push_back(kVp8Codec);
+ parameters.codecs.push_back(GetEngineCodec("VP8"));
EXPECT_TRUE(channel->SetSendParameters(parameters));
ASSERT_EQ(0u, encoder_factory.encoders().size());
}
@@ -630,11 +629,15 @@ TEST_F(WebRtcVideoEngine2Test,
DontUseExternalEncoderFactoryForUnsupportedCodecs) {
cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
encoder_factory.AddSupportedVideoCodecType("H264");
- std::vector<cricket::VideoCodec> codecs;
- codecs.push_back(kVp8Codec);
+
+ engine_.SetExternalEncoderFactory(&encoder_factory);
+ engine_.Init();
std::unique_ptr<VideoMediaChannel> channel(
- SetUpForExternalEncoderFactory(&encoder_factory, codecs));
+ engine_.CreateChannel(call_.get(), MediaConfig(), VideoOptions()));
+ cricket::VideoSendParameters parameters;
+ parameters.codecs.push_back(GetEngineCodec("VP8"));
+ EXPECT_TRUE(channel->SetSendParameters(parameters));
EXPECT_TRUE(
channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
@@ -648,11 +651,14 @@ TEST_F(WebRtcVideoEngine2Test,
encoder_factory.AddSupportedVideoCodecType("VP8");
encoder_factory.AddSupportedVideoCodecType("H264");
- std::vector<cricket::VideoCodec> codecs;
- codecs.push_back(kVp8Codec);
+ engine_.SetExternalEncoderFactory(&encoder_factory);
+ engine_.Init();
std::unique_ptr<VideoMediaChannel> channel(
- SetUpForExternalEncoderFactory(&encoder_factory, codecs));
+ engine_.CreateChannel(call_.get(), MediaConfig(), VideoOptions()));
+ cricket::VideoSendParameters parameters;
+ parameters.codecs.push_back(GetEngineCodec("VP8"));
+ EXPECT_TRUE(channel->SetSendParameters(parameters));
std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs3);
@@ -685,11 +691,14 @@ TEST_F(WebRtcVideoEngine2Test,
encoder_factory.AddSupportedVideoCodecType("VP8");
encoder_factory.AddSupportedVideoCodecType("H264");
- std::vector<cricket::VideoCodec> codecs;
- codecs.push_back(kH264Codec);
+ engine_.SetExternalEncoderFactory(&encoder_factory);
+ engine_.Init();
std::unique_ptr<VideoMediaChannel> channel(
- SetUpForExternalEncoderFactory(&encoder_factory, codecs));
+ engine_.CreateChannel(call_.get(), MediaConfig(), VideoOptions()));
+ cricket::VideoSendParameters parameters;
+ parameters.codecs.push_back(GetEngineCodec("H264"));
+ EXPECT_TRUE(channel->SetSendParameters(parameters));
EXPECT_TRUE(
channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
@@ -714,11 +723,9 @@ TEST_F(WebRtcVideoEngine2Test,
TEST_F(WebRtcVideoEngine2Test, SimulcastDisabledForH264) {
cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
encoder_factory.AddSupportedVideoCodecType("H264");
- std::vector<cricket::VideoCodec> codecs;
- codecs.push_back(kH264Codec);
std::unique_ptr<VideoMediaChannel> channel(
- SetUpForExternalEncoderFactory(&encoder_factory, codecs));
+ SetUpForExternalEncoderFactory(&encoder_factory));
const std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs3);
EXPECT_TRUE(
@@ -761,7 +768,7 @@ TEST_F(WebRtcVideoEngine2Test, RegisterExternalDecodersIfSupported) {
cricket::FakeWebRtcVideoDecoderFactory decoder_factory;
decoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8);
cricket::VideoRecvParameters parameters;
- parameters.codecs.push_back(kVp8Codec);
+ parameters.codecs.push_back(GetEngineCodec("VP8"));
std::unique_ptr<VideoMediaChannel> channel(
SetUpForExternalDecoderFactory(&decoder_factory, parameters.codecs));
@@ -791,7 +798,7 @@ TEST_F(WebRtcVideoEngine2Test, RegisterExternalH264DecoderIfSupported) {
cricket::FakeWebRtcVideoDecoderFactory decoder_factory;
decoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecH264);
std::vector<cricket::VideoCodec> codecs;
- codecs.push_back(kH264Codec);
+ codecs.push_back(GetEngineCodec("H264"));
std::unique_ptr<VideoMediaChannel> channel(
SetUpForExternalDecoderFactory(&decoder_factory, codecs));
@@ -806,7 +813,17 @@ class WebRtcVideoChannel2BaseTest
protected:
typedef VideoMediaChannelTest<WebRtcVideoEngine2, WebRtcVideoChannel2> Base;
- cricket::VideoCodec DefaultCodec() override { return kVp8Codec; }
+ cricket::VideoCodec GetEngineCodec(const std::string& name) {
+ for (const cricket::VideoCodec& engine_codec : engine_.codecs()) {
+ if (CodecNamesEq(name, engine_codec.name))
+ return engine_codec;
+ }
+ // This point should never be reached.
+ ADD_FAILURE() << "Unrecognized codec name: " << name;
+ return cricket::VideoCodec();
+ }
+
+ cricket::VideoCodec DefaultCodec() override { return GetEngineCodec("VP8"); }
};
// Verifies that id given in stream params is passed to the decoder factory.
@@ -814,7 +831,7 @@ TEST_F(WebRtcVideoEngine2Test, StreamParamsIdPassedToDecoderFactory) {
cricket::FakeWebRtcVideoDecoderFactory decoder_factory;
decoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8);
cricket::VideoRecvParameters parameters;
- parameters.codecs.push_back(kVp8Codec);
+ parameters.codecs.push_back(GetEngineCodec("VP8"));
std::unique_ptr<VideoMediaChannel> channel(
SetUpForExternalDecoderFactory(&decoder_factory, parameters.codecs));
@@ -865,15 +882,15 @@ WEBRTC_BASE_TEST(RejectEmptyStreamParams);
WEBRTC_BASE_TEST(MultipleSendStreams);
TEST_F(WebRtcVideoChannel2BaseTest, SendAndReceiveVp8Vga) {
- SendAndReceive(cricket::VideoCodec(100, "VP8"));
+ SendAndReceive(GetEngineCodec("VP8"));
}
TEST_F(WebRtcVideoChannel2BaseTest, SendAndReceiveVp8Qvga) {
- SendAndReceive(cricket::VideoCodec(100, "VP8"));
+ SendAndReceive(GetEngineCodec("VP8"));
}
TEST_F(WebRtcVideoChannel2BaseTest, SendAndReceiveVp8SvcQqvga) {
- SendAndReceive(cricket::VideoCodec(100, "VP8"));
+ SendAndReceive(GetEngineCodec("VP8"));
}
TEST_F(WebRtcVideoChannel2BaseTest, TwoStreamsSendAndReceive) {
@@ -882,7 +899,7 @@ TEST_F(WebRtcVideoChannel2BaseTest, TwoStreamsSendAndReceive) {
// initially will use QVGA instead of VGA.
// TODO(pbos): Set up the quality scaler so that both senders reliably start
// at QVGA, then verify that instead.
- cricket::VideoCodec codec = kVp8Codec;
+ cricket::VideoCodec codec = GetEngineCodec("VP8");
codec.params[kCodecParamStartBitrate] = "1000000";
Base::TwoStreamsSendAndReceive(codec);
}
@@ -942,7 +959,7 @@ class WebRtcVideoChannel2Test : public WebRtcVideoEngine2Test {
int expected_max_bitrate_bps) {
auto& codecs = send_parameters_.codecs;
codecs.clear();
- codecs.push_back(kVp8Codec);
+ codecs.push_back(GetEngineCodec("VP8"));
codecs[0].params[kCodecParamMinBitrate] = min_bitrate_kbps;
codecs[0].params[kCodecParamStartBitrate] = start_bitrate_kbps;
codecs[0].params[kCodecParamMaxBitrate] = max_bitrate_kbps;
@@ -1054,8 +1071,8 @@ class WebRtcVideoChannel2Test : public WebRtcVideoEngine2Test {
void TestCpuAdaptation(bool enable_overuse, bool is_screenshare);
void TestReceiverLocalSsrcConfiguration(bool receiver_first);
- void TestReceiveUnsignalledSsrcPacket(uint8_t payload_type,
- bool expect_created_receive_stream);
+ void TestReceiveUnsignaledSsrcPacket(uint8_t payload_type,
+ bool expect_created_receive_stream);
FakeVideoSendStream* SetDenoisingOption(
uint32_t ssrc,
@@ -1429,7 +1446,7 @@ TEST_F(WebRtcVideoChannel2Test, RembCanBeEnabledAndDisabled) {
// Verify that REMB is turned off when send(!) codecs without REMB are set.
cricket::VideoSendParameters parameters;
- parameters.codecs.push_back(kVp8Codec);
+ parameters.codecs.push_back(RemoveFeedbackParams(GetEngineCodec("VP8")));
EXPECT_TRUE(parameters.codecs[0].feedback_params.params().empty());
EXPECT_TRUE(channel_->SetSendParameters(parameters));
stream = fake_call_->GetVideoReceiveStreams()[0];
@@ -1450,7 +1467,7 @@ TEST_F(WebRtcVideoChannel2Test, TransportCcCanBeEnabledAndDisabled) {
// Verify that transport cc feedback is turned off when send(!) codecs without
// transport cc feedback are set.
cricket::VideoSendParameters parameters;
- parameters.codecs.push_back(kVp8Codec);
+ parameters.codecs.push_back(RemoveFeedbackParams(GetEngineCodec("VP8")));
EXPECT_TRUE(parameters.codecs[0].feedback_params.params().empty());
EXPECT_TRUE(channel_->SetSendParameters(parameters));
stream = fake_call_->GetVideoReceiveStreams()[0];
@@ -1496,7 +1513,7 @@ TEST_F(WebRtcVideoChannel2Test, NackCanBeEnabledAndDisabled) {
// Verify that NACK is turned off when send(!) codecs without NACK are set.
cricket::VideoSendParameters parameters;
- parameters.codecs.push_back(kVp8Codec);
+ parameters.codecs.push_back(RemoveFeedbackParams(GetEngineCodec("VP8")));
EXPECT_TRUE(parameters.codecs[0].feedback_params.params().empty());
EXPECT_TRUE(channel_->SetSendParameters(parameters));
recv_stream = fake_call_->GetVideoReceiveStreams()[0];
@@ -1521,7 +1538,7 @@ TEST_F(WebRtcVideoChannel2Test, NackCanBeEnabledAndDisabled) {
// earlier.
TEST_F(WebRtcVideoChannel2Test, ReconfiguresEncodersWhenNotSending) {
cricket::VideoSendParameters parameters;
- parameters.codecs.push_back(kVp8Codec);
+ parameters.codecs.push_back(GetEngineCodec("VP8"));
ASSERT_TRUE(channel_->SetSendParameters(parameters));
channel_->SetSend(false);
@@ -1548,7 +1565,7 @@ TEST_F(WebRtcVideoChannel2Test, ReconfiguresEncodersWhenNotSending) {
TEST_F(WebRtcVideoChannel2Test, UsesCorrectSettingsForScreencast) {
static const int kScreenshareMinBitrateKbps = 800;
- cricket::VideoCodec codec = kVp8Codec;
+ cricket::VideoCodec codec = GetEngineCodec("VP8");
cricket::VideoSendParameters parameters;
parameters.codecs.push_back(codec);
EXPECT_TRUE(channel_->SetSendParameters(parameters));
@@ -1737,7 +1754,7 @@ TEST_F(WebRtcVideoChannel2Test, Vp8DenoisingEnabledByDefault) {
TEST_F(WebRtcVideoChannel2Test, VerifyVp8SpecificSettings) {
cricket::VideoSendParameters parameters;
- parameters.codecs.push_back(kVp8Codec);
+ parameters.codecs.push_back(GetEngineCodec("VP8"));
ASSERT_TRUE(channel_->SetSendParameters(parameters));
// Single-stream settings should apply with RTX as well (verifies that we
@@ -1818,7 +1835,7 @@ TEST_F(WebRtcVideoChannel2Test, SetIdenticalOptionsDoesntReconfigureEncoder) {
EXPECT_EQ(cricket::CS_RUNNING,
capturer.Start(capturer.GetSupportedFormats()->front()));
cricket::VideoSendParameters parameters;
- parameters.codecs.push_back(kVp8Codec);
+ parameters.codecs.push_back(GetEngineCodec("VP8"));
ASSERT_TRUE(channel_->SetSendParameters(parameters));
FakeVideoSendStream* send_stream = fake_call_->GetVideoSendStreams().front();
@@ -1867,7 +1884,7 @@ class Vp9SettingsTest : public WebRtcVideoChannel2Test {
TEST_F(Vp9SettingsTest, VerifyVp9SpecificSettings) {
cricket::VideoSendParameters parameters;
- parameters.codecs.push_back(kVp9Codec);
+ parameters.codecs.push_back(GetEngineCodec("VP9"));
ASSERT_TRUE(channel_->SetSendParameters(parameters));
FakeVideoSendStream* stream = SetUpSimulcast(false, false);
@@ -1927,7 +1944,7 @@ class Vp9SettingsTestWithFieldTrial : public Vp9SettingsTest {
protected:
void VerifySettings(int num_spatial_layers, int num_temporal_layers) {
cricket::VideoSendParameters parameters;
- parameters.codecs.push_back(kVp9Codec);
+ parameters.codecs.push_back(GetEngineCodec("VP9"));
ASSERT_TRUE(channel_->SetSendParameters(parameters));
FakeVideoSendStream* stream = SetUpSimulcast(false, false);
@@ -1998,7 +2015,7 @@ TEST_F(WebRtcVideoChannel2Test, DoesNotAdaptOnOveruseWhenScreensharing) {
}
TEST_F(WebRtcVideoChannel2Test, AdaptsOnOveruseAndChangeResolution) {
- cricket::VideoCodec codec = kVp8Codec;
+ cricket::VideoCodec codec = GetEngineCodec("VP8");
cricket::VideoSendParameters parameters;
parameters.codecs.push_back(codec);
@@ -2072,7 +2089,7 @@ TEST_F(WebRtcVideoChannel2Test, AdaptsOnOveruseAndChangeResolution) {
}
TEST_F(WebRtcVideoChannel2Test, PreviousAdaptationDoesNotApplyToScreenshare) {
- cricket::VideoCodec codec = kVp8Codec;
+ cricket::VideoCodec codec = GetEngineCodec("VP8");
cricket::VideoSendParameters parameters;
parameters.codecs.push_back(codec);
@@ -2136,7 +2153,7 @@ TEST_F(WebRtcVideoChannel2Test, PreviousAdaptationDoesNotApplyToScreenshare) {
void WebRtcVideoChannel2Test::TestCpuAdaptation(bool enable_overuse,
bool is_screenshare) {
- cricket::VideoCodec codec = kVp8Codec;
+ cricket::VideoCodec codec = GetEngineCodec("VP8");
cricket::VideoSendParameters parameters;
parameters.codecs.push_back(codec);
@@ -2260,8 +2277,8 @@ TEST_F(WebRtcVideoChannel2Test, SetDefaultSendCodecs) {
// Make sure NACK and FEC are enabled on the correct payload types.
EXPECT_EQ(1000, config.rtp.nack.rtp_history_ms);
- EXPECT_EQ(default_ulpfec_codec_.id, config.rtp.ulpfec.ulpfec_payload_type);
- EXPECT_EQ(default_red_codec_.id, config.rtp.ulpfec.red_payload_type);
+ EXPECT_EQ(GetEngineCodec("ulpfec").id, config.rtp.ulpfec.ulpfec_payload_type);
+ EXPECT_EQ(GetEngineCodec("red").id, config.rtp.ulpfec.red_payload_type);
EXPECT_EQ(1u, config.rtp.rtx.ssrcs.size());
EXPECT_EQ(kRtxSsrcs1[0], config.rtp.rtx.ssrcs[0]);
@@ -2271,7 +2288,7 @@ TEST_F(WebRtcVideoChannel2Test, SetDefaultSendCodecs) {
TEST_F(WebRtcVideoChannel2Test, SetSendCodecsWithoutFec) {
cricket::VideoSendParameters parameters;
- parameters.codecs.push_back(kVp8Codec);
+ parameters.codecs.push_back(GetEngineCodec("VP8"));
ASSERT_TRUE(channel_->SetSendParameters(parameters));
FakeVideoSendStream* stream = AddSendStream();
@@ -2283,8 +2300,11 @@ TEST_F(WebRtcVideoChannel2Test, SetSendCodecsWithoutFec) {
TEST_F(WebRtcVideoChannel2Test,
SetSendCodecRejectsRtxWithoutAssociatedPayloadType) {
+ const int kUnusedPayloadType = 127;
+ EXPECT_FALSE(FindCodecById(engine_.codecs(), kUnusedPayloadType));
+
cricket::VideoSendParameters parameters;
- cricket::VideoCodec rtx_codec(96, "rtx");
+ cricket::VideoCodec rtx_codec(kUnusedPayloadType, "rtx");
parameters.codecs.push_back(rtx_codec);
EXPECT_FALSE(channel_->SetSendParameters(parameters))
<< "RTX codec without associated payload type should be rejected.";
@@ -2292,31 +2312,39 @@ TEST_F(WebRtcVideoChannel2Test,
TEST_F(WebRtcVideoChannel2Test,
SetSendCodecRejectsRtxWithoutMatchingVideoCodec) {
- cricket::VideoSendParameters parameters;
- cricket::VideoCodec rtx_codec =
- cricket::VideoCodec::CreateRtxCodec(96, kVp8Codec.id);
- parameters.codecs.push_back(kVp8Codec);
- parameters.codecs.push_back(rtx_codec);
- ASSERT_TRUE(channel_->SetSendParameters(parameters));
-
- cricket::VideoCodec rtx_codec2 =
- cricket::VideoCodec::CreateRtxCodec(96, kVp8Codec.id + 1);
- parameters.codecs.pop_back();
- parameters.codecs.push_back(rtx_codec2);
- EXPECT_FALSE(channel_->SetSendParameters(parameters))
- << "RTX without matching video codec should be rejected.";
+ const int kUnusedPayloadType1 = 126;
+ const int kUnusedPayloadType2 = 127;
+ EXPECT_FALSE(FindCodecById(engine_.codecs(), kUnusedPayloadType1));
+ EXPECT_FALSE(FindCodecById(engine_.codecs(), kUnusedPayloadType2));
+ {
+ cricket::VideoCodec rtx_codec = cricket::VideoCodec::CreateRtxCodec(
+ kUnusedPayloadType1, GetEngineCodec("VP8").id);
+ cricket::VideoSendParameters parameters;
+ parameters.codecs.push_back(GetEngineCodec("VP8"));
+ parameters.codecs.push_back(rtx_codec);
+ ASSERT_TRUE(channel_->SetSendParameters(parameters));
+ }
+ {
+ cricket::VideoCodec rtx_codec = cricket::VideoCodec::CreateRtxCodec(
+ kUnusedPayloadType1, kUnusedPayloadType2);
+ cricket::VideoSendParameters parameters;
+ parameters.codecs.push_back(GetEngineCodec("VP8"));
+ parameters.codecs.push_back(rtx_codec);
+ EXPECT_FALSE(channel_->SetSendParameters(parameters))
+ << "RTX without matching video codec should be rejected.";
+ }
}
TEST_F(WebRtcVideoChannel2Test, SetSendCodecsWithoutFecDisablesFec) {
cricket::VideoSendParameters parameters;
- parameters.codecs.push_back(kVp8Codec);
- parameters.codecs.push_back(kUlpfecCodec);
+ parameters.codecs.push_back(GetEngineCodec("VP8"));
+ parameters.codecs.push_back(GetEngineCodec("ulpfec"));
ASSERT_TRUE(channel_->SetSendParameters(parameters));
FakeVideoSendStream* stream = AddSendStream();
webrtc::VideoSendStream::Config config = stream->GetConfig().Copy();
- EXPECT_EQ(kUlpfecCodec.id, config.rtp.ulpfec.ulpfec_payload_type);
+ EXPECT_EQ(GetEngineCodec("ulpfec").id, config.rtp.ulpfec.ulpfec_payload_type);
parameters.codecs.pop_back();
ASSERT_TRUE(channel_->SetSendParameters(parameters));
@@ -2461,7 +2489,7 @@ TEST_F(WebRtcVideoChannel2Test, SetMaxSendBandwidthAndAddSendStream) {
TEST_F(WebRtcVideoChannel2Test, SetMaxSendBitrateCanIncreaseSenderBitrate) {
cricket::VideoSendParameters parameters;
- parameters.codecs.push_back(kVp8Codec);
+ parameters.codecs.push_back(GetEngineCodec("VP8"));
ASSERT_TRUE(channel_->SetSendParameters(parameters));
channel_->SetSend(true);
@@ -2488,7 +2516,7 @@ TEST_F(WebRtcVideoChannel2Test, SetMaxSendBitrateCanIncreaseSenderBitrate) {
TEST_F(WebRtcVideoChannel2Test,
SetMaxSendBitrateCanIncreaseSimulcastSenderBitrate) {
cricket::VideoSendParameters parameters;
- parameters.codecs.push_back(kVp8Codec);
+ parameters.codecs.push_back(GetEngineCodec("VP8"));
ASSERT_TRUE(channel_->SetSendParameters(parameters));
channel_->SetSend(true);
@@ -2522,7 +2550,7 @@ TEST_F(WebRtcVideoChannel2Test,
TEST_F(WebRtcVideoChannel2Test, SetSendCodecsWithMaxQuantization) {
static const char* kMaxQuantization = "21";
cricket::VideoSendParameters parameters;
- parameters.codecs.push_back(kVp8Codec);
+ parameters.codecs.push_back(GetEngineCodec("VP8"));
parameters.codecs[0].params[kCodecParamMaxQuantization] = kMaxQuantization;
EXPECT_TRUE(channel_->SetSendParameters(parameters));
EXPECT_EQ(static_cast<unsigned int>(atoi(kMaxQuantization)),
@@ -2537,7 +2565,7 @@ TEST_F(WebRtcVideoChannel2Test, SetSendCodecsRejectBadPayloadTypes) {
// TODO(pbos): Should we only allow the dynamic range?
static const int kIncorrectPayloads[] = {-2, -1, 128, 129};
cricket::VideoSendParameters parameters;
- parameters.codecs.push_back(kVp8Codec);
+ parameters.codecs.push_back(GetEngineCodec("VP8"));
for (size_t i = 0; i < arraysize(kIncorrectPayloads); ++i) {
parameters.codecs[0].id = kIncorrectPayloads[i];
EXPECT_FALSE(channel_->SetSendParameters(parameters))
@@ -2547,8 +2575,7 @@ TEST_F(WebRtcVideoChannel2Test, SetSendCodecsRejectBadPayloadTypes) {
TEST_F(WebRtcVideoChannel2Test, SetSendCodecsAcceptAllValidPayloadTypes) {
cricket::VideoSendParameters parameters;
- parameters.codecs.push_back(kVp8Codec);
- // Only the dynamic payload types are valid for video codecs.
+ parameters.codecs.push_back(GetEngineCodec("VP8"));
for (int payload_type = 96; payload_type <= 127; ++payload_type) {
parameters.codecs[0].id = payload_type;
EXPECT_TRUE(channel_->SetSendParameters(parameters))
@@ -2563,42 +2590,47 @@ TEST_F(WebRtcVideoChannel2Test, SetSendCodecsAcceptAllValidPayloadTypes) {
TEST_F(WebRtcVideoChannel2Test,
SetSendCodecsIdenticalFirstCodecDoesntRecreateStream) {
cricket::VideoSendParameters parameters1;
- parameters1.codecs.push_back(kVp8Codec);
- parameters1.codecs.push_back(kVp9Codec);
+ parameters1.codecs.push_back(GetEngineCodec("VP8"));
+ parameters1.codecs.push_back(GetEngineCodec("VP9"));
EXPECT_TRUE(channel_->SetSendParameters(parameters1));
AddSendStream();
EXPECT_EQ(1, fake_call_->GetNumCreatedSendStreams());
cricket::VideoSendParameters parameters2;
- parameters2.codecs.push_back(kVp8Codec);
+ parameters2.codecs.push_back(GetEngineCodec("VP8"));
EXPECT_TRUE(channel_->SetSendParameters(parameters2));
EXPECT_EQ(1, fake_call_->GetNumCreatedSendStreams());
}
TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsWithOnlyVp8) {
cricket::VideoRecvParameters parameters;
- parameters.codecs.push_back(kVp8Codec);
+ parameters.codecs.push_back(GetEngineCodec("VP8"));
EXPECT_TRUE(channel_->SetRecvParameters(parameters));
}
// Test that we set our inbound RTX codecs properly.
TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsWithRtx) {
+ const int kUnusedPayloadType1 = 126;
+ const int kUnusedPayloadType2 = 127;
+ EXPECT_FALSE(FindCodecById(engine_.codecs(), kUnusedPayloadType1));
+ EXPECT_FALSE(FindCodecById(engine_.codecs(), kUnusedPayloadType2));
+
cricket::VideoRecvParameters parameters;
- parameters.codecs.push_back(kVp8Codec);
- cricket::VideoCodec rtx_codec(96, "rtx");
+ parameters.codecs.push_back(GetEngineCodec("VP8"));
+ cricket::VideoCodec rtx_codec(kUnusedPayloadType1, "rtx");
parameters.codecs.push_back(rtx_codec);
EXPECT_FALSE(channel_->SetRecvParameters(parameters))
<< "RTX codec without associated payload should be rejected.";
- parameters.codecs[1].SetParam("apt", kVp8Codec.id + 1);
+ parameters.codecs[1].SetParam("apt", kUnusedPayloadType2);
EXPECT_FALSE(channel_->SetRecvParameters(parameters))
<< "RTX codec with invalid associated payload type should be rejected.";
- parameters.codecs[1].SetParam("apt", kVp8Codec.id);
+ parameters.codecs[1].SetParam("apt", GetEngineCodec("VP8").id);
EXPECT_TRUE(channel_->SetRecvParameters(parameters));
- cricket::VideoCodec rtx_codec2(97, "rtx");
+ cricket::VideoCodec rtx_codec2(kUnusedPayloadType2, "rtx");
rtx_codec2.SetParam("apt", rtx_codec.id);
parameters.codecs.push_back(rtx_codec2);
@@ -2609,7 +2641,7 @@ TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsWithRtx) {
TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsDifferentPayloadType) {
cricket::VideoRecvParameters parameters;
- parameters.codecs.push_back(kVp8Codec);
+ parameters.codecs.push_back(GetEngineCodec("VP8"));
parameters.codecs[0].id = 99;
EXPECT_TRUE(channel_->SetRecvParameters(parameters));
}
@@ -2627,7 +2659,7 @@ TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsAcceptDefaultCodecs) {
TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsRejectUnsupportedCodec) {
cricket::VideoRecvParameters parameters;
- parameters.codecs.push_back(kVp8Codec);
+ parameters.codecs.push_back(GetEngineCodec("VP8"));
parameters.codecs.push_back(VideoCodec(101, "WTF3"));
EXPECT_FALSE(channel_->SetRecvParameters(parameters));
}
@@ -2636,34 +2668,34 @@ TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsRejectUnsupportedCodec) {
TEST_F(WebRtcVideoChannel2Test,
DISABLED_SetRecvCodecsAcceptsMultipleVideoCodecs) {
cricket::VideoRecvParameters parameters;
- parameters.codecs.push_back(kVp8Codec);
- parameters.codecs.push_back(kVp9Codec);
+ parameters.codecs.push_back(GetEngineCodec("VP8"));
+ parameters.codecs.push_back(GetEngineCodec("VP9"));
EXPECT_TRUE(channel_->SetRecvParameters(parameters));
}
TEST_F(WebRtcVideoChannel2Test,
DISABLED_SetRecvCodecsSetsFecForAllVideoCodecs) {
cricket::VideoRecvParameters parameters;
- parameters.codecs.push_back(kVp8Codec);
- parameters.codecs.push_back(kVp9Codec);
+ parameters.codecs.push_back(GetEngineCodec("VP8"));
+ parameters.codecs.push_back(GetEngineCodec("VP9"));
EXPECT_TRUE(channel_->SetRecvParameters(parameters));
FAIL(); // TODO(pbos): Verify that the FEC parameters are set for all codecs.
}
TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsWithoutFecDisablesFec) {
cricket::VideoSendParameters send_parameters;
- send_parameters.codecs.push_back(kVp8Codec);
- send_parameters.codecs.push_back(kRedCodec);
- send_parameters.codecs.push_back(kUlpfecCodec);
+ send_parameters.codecs.push_back(GetEngineCodec("VP8"));
+ send_parameters.codecs.push_back(GetEngineCodec("red"));
+ send_parameters.codecs.push_back(GetEngineCodec("ulpfec"));
ASSERT_TRUE(channel_->SetSendParameters(send_parameters));
FakeVideoReceiveStream* stream = AddRecvStream();
- EXPECT_EQ(kUlpfecCodec.id,
+ EXPECT_EQ(GetEngineCodec("ulpfec").id,
stream->GetConfig().rtp.ulpfec.ulpfec_payload_type);
cricket::VideoRecvParameters recv_parameters;
- recv_parameters.codecs.push_back(kVp8Codec);
+ recv_parameters.codecs.push_back(GetEngineCodec("VP8"));
ASSERT_TRUE(channel_->SetRecvParameters(recv_parameters));
stream = fake_call_->GetVideoReceiveStreams()[0];
ASSERT_TRUE(stream != NULL);
@@ -2673,41 +2705,43 @@ TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsWithoutFecDisablesFec) {
TEST_F(WebRtcVideoChannel2Test, SetSendParamsWithFecEnablesFec) {
FakeVideoReceiveStream* stream = AddRecvStream();
- EXPECT_EQ(kUlpfecCodec.id,
+ EXPECT_EQ(GetEngineCodec("ulpfec").id,
stream->GetConfig().rtp.ulpfec.ulpfec_payload_type);
cricket::VideoRecvParameters recv_parameters;
- recv_parameters.codecs.push_back(kVp8Codec);
- recv_parameters.codecs.push_back(kRedCodec);
- recv_parameters.codecs.push_back(kUlpfecCodec);
+ recv_parameters.codecs.push_back(GetEngineCodec("VP8"));
+ recv_parameters.codecs.push_back(GetEngineCodec("red"));
+ recv_parameters.codecs.push_back(GetEngineCodec("ulpfec"));
ASSERT_TRUE(channel_->SetRecvParameters(recv_parameters));
stream = fake_call_->GetVideoReceiveStreams()[0];
ASSERT_TRUE(stream != NULL);
- EXPECT_EQ(kUlpfecCodec.id, stream->GetConfig().rtp.ulpfec.ulpfec_payload_type)
+ EXPECT_EQ(GetEngineCodec("ulpfec").id,
+ stream->GetConfig().rtp.ulpfec.ulpfec_payload_type)
<< "FEC should be enabled on the receive stream.";
cricket::VideoSendParameters send_parameters;
- send_parameters.codecs.push_back(kVp8Codec);
- send_parameters.codecs.push_back(kRedCodec);
- send_parameters.codecs.push_back(kUlpfecCodec);
+ send_parameters.codecs.push_back(GetEngineCodec("VP8"));
+ send_parameters.codecs.push_back(GetEngineCodec("red"));
+ send_parameters.codecs.push_back(GetEngineCodec("ulpfec"));
ASSERT_TRUE(channel_->SetSendParameters(send_parameters));
stream = fake_call_->GetVideoReceiveStreams()[0];
- EXPECT_EQ(kUlpfecCodec.id, stream->GetConfig().rtp.ulpfec.ulpfec_payload_type)
+ EXPECT_EQ(GetEngineCodec("ulpfec").id,
+ stream->GetConfig().rtp.ulpfec.ulpfec_payload_type)
<< "FEC should be enabled on the receive stream.";
}
TEST_F(WebRtcVideoChannel2Test, SetSendCodecsRejectDuplicateFecPayloads) {
cricket::VideoRecvParameters parameters;
- parameters.codecs.push_back(kVp8Codec);
- parameters.codecs.push_back(kRedCodec);
+ parameters.codecs.push_back(GetEngineCodec("VP8"));
+ parameters.codecs.push_back(GetEngineCodec("red"));
parameters.codecs[1].id = parameters.codecs[0].id;
EXPECT_FALSE(channel_->SetRecvParameters(parameters));
}
TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsRejectDuplicateCodecPayloads) {
cricket::VideoRecvParameters parameters;
- parameters.codecs.push_back(kVp8Codec);
- parameters.codecs.push_back(kVp9Codec);
+ parameters.codecs.push_back(GetEngineCodec("VP8"));
+ parameters.codecs.push_back(GetEngineCodec("VP9"));
parameters.codecs[1].id = parameters.codecs[0].id;
EXPECT_FALSE(channel_->SetRecvParameters(parameters));
}
@@ -2715,8 +2749,8 @@ TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsRejectDuplicateCodecPayloads) {
TEST_F(WebRtcVideoChannel2Test,
SetRecvCodecsAcceptSameCodecOnMultiplePayloadTypes) {
cricket::VideoRecvParameters parameters;
- parameters.codecs.push_back(kVp8Codec);
- parameters.codecs.push_back(kVp8Codec);
+ parameters.codecs.push_back(GetEngineCodec("VP8"));
+ parameters.codecs.push_back(GetEngineCodec("VP8"));
parameters.codecs[1].id += 1;
EXPECT_TRUE(channel_->SetRecvParameters(parameters));
}
@@ -2726,16 +2760,16 @@ TEST_F(WebRtcVideoChannel2Test,
TEST_F(WebRtcVideoChannel2Test,
SetRecvCodecsDifferentOrderDoesntRecreateStream) {
cricket::VideoRecvParameters parameters1;
- parameters1.codecs.push_back(kVp8Codec);
- parameters1.codecs.push_back(kRedCodec);
+ parameters1.codecs.push_back(GetEngineCodec("VP8"));
+ parameters1.codecs.push_back(GetEngineCodec("red"));
EXPECT_TRUE(channel_->SetRecvParameters(parameters1));
AddRecvStream(cricket::StreamParams::CreateLegacy(123));
EXPECT_EQ(1, fake_call_->GetNumCreatedReceiveStreams());
cricket::VideoRecvParameters parameters2;
- parameters2.codecs.push_back(kRedCodec);
- parameters2.codecs.push_back(kVp8Codec);
+ parameters2.codecs.push_back(GetEngineCodec("red"));
+ parameters2.codecs.push_back(GetEngineCodec("VP8"));
EXPECT_TRUE(channel_->SetRecvParameters(parameters2));
EXPECT_EQ(1, fake_call_->GetNumCreatedReceiveStreams());
}
@@ -2855,14 +2889,14 @@ TEST_F(WebRtcVideoChannel2Test, OnReadyToSendSignalsNetworkState) {
TEST_F(WebRtcVideoChannel2Test, GetStatsReportsSentCodecName) {
cricket::VideoSendParameters parameters;
- parameters.codecs.push_back(kVp8Codec);
+ parameters.codecs.push_back(GetEngineCodec("VP8"));
EXPECT_TRUE(channel_->SetSendParameters(parameters));
AddSendStream();
cricket::VideoMediaInfo info;
ASSERT_TRUE(channel_->GetStats(&info));
- EXPECT_EQ(kVp8Codec.name, info.senders[0].codec_name);
+ EXPECT_EQ("VP8", info.senders[0].codec_name);
}
TEST_F(WebRtcVideoChannel2Test, GetStatsReportsEncoderImplementationName) {
@@ -3275,7 +3309,7 @@ TEST_F(WebRtcVideoChannel2Test, MapsReceivedPayloadTypeToCodecName) {
EXPECT_STREQ("", info.receivers[0].codec_name.c_str());
// Report VP8 if we're receiving it.
- stats.current_payload_type = kDefaultVp8PlType;
+ stats.current_payload_type = GetEngineCodec("VP8").id;
stream->SetStats(stats);
ASSERT_TRUE(channel_->GetStats(&info));
EXPECT_STREQ(kVp8CodecName, info.receivers[0].codec_name.c_str());
@@ -3287,12 +3321,15 @@ TEST_F(WebRtcVideoChannel2Test, MapsReceivedPayloadTypeToCodecName) {
EXPECT_STREQ("", info.receivers[0].codec_name.c_str());
}
-void WebRtcVideoChannel2Test::TestReceiveUnsignalledSsrcPacket(
+void WebRtcVideoChannel2Test::TestReceiveUnsignaledSsrcPacket(
uint8_t payload_type,
bool expect_created_receive_stream) {
+ // kRedRtxPayloadType must currently be unused.
+ EXPECT_FALSE(FindCodecById(engine_.codecs(), kRedRtxPayloadType));
+
// Add a RED RTX codec.
VideoCodec red_rtx_codec =
- VideoCodec::CreateRtxCodec(kRedRtxPayloadType, kDefaultRedPlType);
+ VideoCodec::CreateRtxCodec(kRedRtxPayloadType, GetEngineCodec("red").id);
recv_parameters_.codecs.push_back(red_rtx_codec);
EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_));
@@ -3319,23 +3356,30 @@ void WebRtcVideoChannel2Test::TestReceiveUnsignalledSsrcPacket(
}
TEST_F(WebRtcVideoChannel2Test, Vp8PacketCreatesUnsignalledStream) {
- TestReceiveUnsignalledSsrcPacket(kDefaultVp8PlType, true);
+ TestReceiveUnsignaledSsrcPacket(GetEngineCodec("VP8").id,
+ true /* expect_created_receive_stream */);
}
TEST_F(WebRtcVideoChannel2Test, Vp9PacketCreatesUnsignalledStream) {
- TestReceiveUnsignalledSsrcPacket(kDefaultVp9PlType, true);
+ TestReceiveUnsignaledSsrcPacket(GetEngineCodec("VP9").id,
+ true /* expect_created_receive_stream */);
}
TEST_F(WebRtcVideoChannel2Test, RtxPacketDoesntCreateUnsignalledStream) {
- TestReceiveUnsignalledSsrcPacket(kDefaultRtxVp8PlType, false);
+ const cricket::VideoCodec vp8 = GetEngineCodec("VP8");
+ const int rtx_vp8_payload_type = default_apt_rtx_types_[vp8.id];
+ TestReceiveUnsignaledSsrcPacket(rtx_vp8_payload_type,
+ false /* expect_created_receive_stream */);
}
TEST_F(WebRtcVideoChannel2Test, UlpfecPacketDoesntCreateUnsignalledStream) {
- TestReceiveUnsignalledSsrcPacket(kDefaultUlpfecType, false);
+ TestReceiveUnsignaledSsrcPacket(GetEngineCodec("ulpfec").id,
+ false /* expect_created_receive_stream */);
}
TEST_F(WebRtcVideoChannel2Test, RedRtxPacketDoesntCreateUnsignalledStream) {
- TestReceiveUnsignalledSsrcPacket(kRedRtxPayloadType, false);
+ TestReceiveUnsignaledSsrcPacket(kRedRtxPayloadType,
+ false /* expect_created_receive_stream */);
}
TEST_F(WebRtcVideoChannel2Test, CanSentMaxBitrateForExistingStream) {
@@ -3430,8 +3474,8 @@ TEST_F(WebRtcVideoChannel2Test,
InactiveStreamDoesntStartSendingWhenReconfigured) {
// Set an initial codec list, which will be modified later.
cricket::VideoSendParameters parameters1;
- parameters1.codecs.push_back(kVp8Codec);
- parameters1.codecs.push_back(kVp9Codec);
+ parameters1.codecs.push_back(GetEngineCodec("VP8"));
+ parameters1.codecs.push_back(GetEngineCodec("VP9"));
EXPECT_TRUE(channel_->SetSendParameters(parameters1));
FakeVideoSendStream* stream = AddSendStream();
@@ -3450,8 +3494,8 @@ TEST_F(WebRtcVideoChannel2Test,
// Reorder the codec list, causing the stream to be reconfigured.
cricket::VideoSendParameters parameters2;
- parameters2.codecs.push_back(kVp9Codec);
- parameters2.codecs.push_back(kVp8Codec);
+ parameters2.codecs.push_back(GetEngineCodec("VP9"));
+ parameters2.codecs.push_back(GetEngineCodec("VP8"));
EXPECT_TRUE(channel_->SetSendParameters(parameters2));
auto new_streams = GetFakeSendStreams();
// Assert that a new underlying stream was created due to the codec change.
@@ -3468,23 +3512,25 @@ TEST_F(WebRtcVideoChannel2Test,
TEST_F(WebRtcVideoChannel2Test, GetRtpSendParametersCodecs) {
AddSendStream();
cricket::VideoSendParameters parameters;
- parameters.codecs.push_back(kVp8Codec);
- parameters.codecs.push_back(kVp9Codec);
+ parameters.codecs.push_back(GetEngineCodec("VP8"));
+ parameters.codecs.push_back(GetEngineCodec("VP9"));
EXPECT_TRUE(channel_->SetSendParameters(parameters));
webrtc::RtpParameters rtp_parameters =
channel_->GetRtpSendParameters(last_ssrc_);
ASSERT_EQ(2u, rtp_parameters.codecs.size());
- EXPECT_EQ(kVp8Codec.ToCodecParameters(), rtp_parameters.codecs[0]);
- EXPECT_EQ(kVp9Codec.ToCodecParameters(), rtp_parameters.codecs[1]);
+ EXPECT_EQ(GetEngineCodec("VP8").ToCodecParameters(),
+ rtp_parameters.codecs[0]);
+ EXPECT_EQ(GetEngineCodec("VP9").ToCodecParameters(),
+ rtp_parameters.codecs[1]);
}
// Test that if we set/get parameters multiple times, we get the same results.
TEST_F(WebRtcVideoChannel2Test, SetAndGetRtpSendParameters) {
AddSendStream();
cricket::VideoSendParameters parameters;
- parameters.codecs.push_back(kVp8Codec);
- parameters.codecs.push_back(kVp9Codec);
+ parameters.codecs.push_back(GetEngineCodec("VP8"));
+ parameters.codecs.push_back(GetEngineCodec("VP9"));
EXPECT_TRUE(channel_->SetSendParameters(parameters));
webrtc::RtpParameters initial_params =
@@ -3501,15 +3547,17 @@ TEST_F(WebRtcVideoChannel2Test, SetAndGetRtpSendParameters) {
TEST_F(WebRtcVideoChannel2Test, GetRtpReceiveParametersCodecs) {
AddRecvStream();
cricket::VideoRecvParameters parameters;
- parameters.codecs.push_back(kVp8Codec);
- parameters.codecs.push_back(kVp9Codec);
+ parameters.codecs.push_back(GetEngineCodec("VP8"));
+ parameters.codecs.push_back(GetEngineCodec("VP9"));
EXPECT_TRUE(channel_->SetRecvParameters(parameters));
webrtc::RtpParameters rtp_parameters =
channel_->GetRtpReceiveParameters(last_ssrc_);
ASSERT_EQ(2u, rtp_parameters.codecs.size());
- EXPECT_EQ(kVp8Codec.ToCodecParameters(), rtp_parameters.codecs[0]);
- EXPECT_EQ(kVp9Codec.ToCodecParameters(), rtp_parameters.codecs[1]);
+ EXPECT_EQ(GetEngineCodec("VP8").ToCodecParameters(),
+ rtp_parameters.codecs[0]);
+ EXPECT_EQ(GetEngineCodec("VP9").ToCodecParameters(),
+ rtp_parameters.codecs[1]);
}
#if defined(WEBRTC_USE_H264)
@@ -3566,8 +3614,8 @@ TEST_F(WebRtcVideoChannel2Test, RtpEncodingParametersSsrcIsSet) {
TEST_F(WebRtcVideoChannel2Test, SetAndGetRtpReceiveParameters) {
AddRecvStream();
cricket::VideoRecvParameters parameters;
- parameters.codecs.push_back(kVp8Codec);
- parameters.codecs.push_back(kVp9Codec);
+ parameters.codecs.push_back(GetEngineCodec("VP8"));
+ parameters.codecs.push_back(GetEngineCodec("VP9"));
EXPECT_TRUE(channel_->SetRecvParameters(parameters));
webrtc::RtpParameters initial_params =
@@ -3761,16 +3809,15 @@ class WebRtcVideoChannel2SimulcastTest : public testing::Test {
};
TEST_F(WebRtcVideoChannel2SimulcastTest, SetSendCodecsWith2SimulcastStreams) {
- VerifySimulcastSettings(kVp8Codec, 640, 360, 2, 2);
+ VerifySimulcastSettings(cricket::VideoCodec("VP8"), 640, 360, 2, 2);
}
TEST_F(WebRtcVideoChannel2SimulcastTest, SetSendCodecsWith3SimulcastStreams) {
- VerifySimulcastSettings(kVp8Codec, 1280, 720, 3, 3);
+ VerifySimulcastSettings(cricket::VideoCodec("VP8"), 1280, 720, 3, 3);
}
// Test that we normalize send codec format size in simulcast.
TEST_F(WebRtcVideoChannel2SimulcastTest, SetSendCodecsWithOddSizeInSimulcast) {
- cricket::VideoCodec codec(kVp8Codec);
- VerifySimulcastSettings(codec, 541, 271, 2, 2);
+ VerifySimulcastSettings(cricket::VideoCodec("VP8"), 541, 271, 2, 2);
}
} // namespace cricket
« no previous file with comments | « webrtc/media/engine/webrtcvideoengine2.cc ('k') | webrtc/video/BUILD.gn » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698