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

Side by Side Diff: webrtc/media/engine/webrtcvideoengine2_unittest.cc

Issue 2493133002: Stop using hardcoded payload types for video codecs (Closed)
Patch Set: 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 unified diff | Download patch
OLDNEW
1 /* 1 /*
2 * Copyright (c) 2004 The WebRTC project authors. All Rights Reserved. 2 * Copyright (c) 2004 The WebRTC project authors. All Rights Reserved.
3 * 3 *
4 * Use of this source code is governed by a BSD-style license 4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source 5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found 6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may 7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree. 8 * be found in the AUTHORS file in the root of the source tree.
9 */ 9 */
10 10
(...skipping 14 matching lines...) Expand all
25 #include "webrtc/media/engine/webrtcvideoengine2.h" 25 #include "webrtc/media/engine/webrtcvideoengine2.h"
26 #include "webrtc/media/engine/webrtcvoiceengine.h" 26 #include "webrtc/media/engine/webrtcvoiceengine.h"
27 #include "webrtc/test/field_trial.h" 27 #include "webrtc/test/field_trial.h"
28 #include "webrtc/video_encoder.h" 28 #include "webrtc/video_encoder.h"
29 29
30 using webrtc::RtpExtension; 30 using webrtc::RtpExtension;
31 31
32 namespace { 32 namespace {
33 static const int kDefaultQpMax = 56; 33 static const int kDefaultQpMax = 56;
34 34
35 static const cricket::VideoCodec kVp8Codec(100, "VP8");
36 static const cricket::VideoCodec kVp9Codec(101, "VP9");
37 static const cricket::VideoCodec kH264Codec(102, "H264");
38
39 static const cricket::VideoCodec kRedCodec(116, "red");
40 static const cricket::VideoCodec kUlpfecCodec(117, "ulpfec");
41
42 static const uint8_t kRedRtxPayloadType = 125; 35 static const uint8_t kRedRtxPayloadType = 125;
43 36
44 static const uint32_t kSsrcs1[] = {1}; 37 static const uint32_t kSsrcs1[] = {1};
45 static const uint32_t kSsrcs3[] = {1, 2, 3}; 38 static const uint32_t kSsrcs3[] = {1, 2, 3};
46 static const uint32_t kRtxSsrcs1[] = {4}; 39 static const uint32_t kRtxSsrcs1[] = {4};
47 static const uint32_t kIncomingUnsignalledSsrc = 0xC0FFEE; 40 static const uint32_t kIncomingUnsignalledSsrc = 0xC0FFEE;
48 static const char kUnsupportedExtensionName[] = 41 static const char kUnsupportedExtensionName[] =
49 "urn:ietf:params:rtp-hdrext:unsupported"; 42 "urn:ietf:params:rtp-hdrext:unsupported";
50 43
51 void VerifyCodecHasDefaultFeedbackParams(const cricket::VideoCodec& codec) { 44 void VerifyCodecHasDefaultFeedbackParams(const cricket::VideoCodec& codec) {
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after
89 class WebRtcVideoEngine2Test : public ::testing::Test { 82 class WebRtcVideoEngine2Test : public ::testing::Test {
90 public: 83 public:
91 WebRtcVideoEngine2Test() : WebRtcVideoEngine2Test("") {} 84 WebRtcVideoEngine2Test() : WebRtcVideoEngine2Test("") {}
92 explicit WebRtcVideoEngine2Test(const char* field_trials) 85 explicit WebRtcVideoEngine2Test(const char* field_trials)
93 : override_field_trials_(field_trials), 86 : override_field_trials_(field_trials),
94 call_(webrtc::Call::Create(webrtc::Call::Config(&event_log_))), 87 call_(webrtc::Call::Create(webrtc::Call::Config(&event_log_))),
95 engine_() { 88 engine_() {
96 std::vector<VideoCodec> engine_codecs = engine_.codecs(); 89 std::vector<VideoCodec> engine_codecs = engine_.codecs();
97 RTC_DCHECK(!engine_codecs.empty()); 90 RTC_DCHECK(!engine_codecs.empty());
98 bool codec_set = false; 91 bool codec_set = false;
99 for (size_t i = 0; i < engine_codecs.size(); ++i) { 92 for (const cricket::VideoCodec& codec : engine_codecs) {
100 if (engine_codecs[i].name == "red") { 93 if (codec.name == "rtx") {
101 default_red_codec_ = engine_codecs[i];
102 } else if (engine_codecs[i].name == "ulpfec") {
103 default_ulpfec_codec_ = engine_codecs[i];
104 } else if (engine_codecs[i].name == "rtx") {
105 int associated_payload_type; 94 int associated_payload_type;
106 if (engine_codecs[i].GetParam(kCodecParamAssociatedPayloadType, 95 if (codec.GetParam(kCodecParamAssociatedPayloadType,
107 &associated_payload_type)) { 96 &associated_payload_type)) {
108 default_apt_rtx_types_[associated_payload_type] = engine_codecs[i].id; 97 default_apt_rtx_types_[associated_payload_type] = codec.id;
109 } 98 }
110 } else if (!codec_set) { 99 } else if (!codec_set && codec.name != "red" && codec.name != "ulpfec") {
111 default_codec_ = engine_codecs[i]; 100 default_codec_ = codec;
112 codec_set = true; 101 codec_set = true;
113 } 102 }
114 } 103 }
115 104
116 RTC_DCHECK(codec_set); 105 RTC_DCHECK(codec_set);
117 } 106 }
118 107
119 protected: 108 protected:
109 // Find the codec in the engine with the given name. The codec must be
110 // present.
111 cricket::VideoCodec GetEngineCodec(const std::string& name);
112
120 VideoMediaChannel* SetUpForExternalEncoderFactory( 113 VideoMediaChannel* SetUpForExternalEncoderFactory(
121 cricket::WebRtcVideoEncoderFactory* encoder_factory, 114 cricket::WebRtcVideoEncoderFactory* encoder_factory);
122 const std::vector<VideoCodec>& codecs);
123 115
124 VideoMediaChannel* SetUpForExternalDecoderFactory( 116 VideoMediaChannel* SetUpForExternalDecoderFactory(
125 cricket::WebRtcVideoDecoderFactory* decoder_factory, 117 cricket::WebRtcVideoDecoderFactory* decoder_factory,
126 const std::vector<VideoCodec>& codecs); 118 const std::vector<VideoCodec>& codecs);
127 119
128 void TestExtendedEncoderOveruse(bool use_external_encoder); 120 void TestExtendedEncoderOveruse(bool use_external_encoder);
129 121
130 webrtc::test::ScopedFieldTrials override_field_trials_; 122 webrtc::test::ScopedFieldTrials override_field_trials_;
131 webrtc::RtcEventLogNullImpl event_log_; 123 webrtc::RtcEventLogNullImpl event_log_;
132 // Used in WebRtcVideoEngine2VoiceTest, but defined here so it's properly 124 // Used in WebRtcVideoEngine2VoiceTest, but defined here so it's properly
133 // initialized when the constructor is called. 125 // initialized when the constructor is called.
134 std::unique_ptr<webrtc::Call> call_; 126 std::unique_ptr<webrtc::Call> call_;
135 WebRtcVideoEngine2 engine_; 127 WebRtcVideoEngine2 engine_;
136 VideoCodec default_codec_; 128 VideoCodec default_codec_;
137 VideoCodec default_red_codec_;
138 VideoCodec default_ulpfec_codec_;
139 std::map<int, int> default_apt_rtx_types_; 129 std::map<int, int> default_apt_rtx_types_;
140 }; 130 };
141 131
142 TEST_F(WebRtcVideoEngine2Test, AnnouncesVp9AccordingToBuildFlags) { 132 TEST_F(WebRtcVideoEngine2Test, AnnouncesVp9AccordingToBuildFlags) {
143 bool claims_vp9_support = false; 133 bool claims_vp9_support = false;
144 for (const cricket::VideoCodec& codec : engine_.codecs()) { 134 for (const cricket::VideoCodec& codec : engine_.codecs()) {
145 if (codec.name == "VP9") { 135 if (codec.name == "VP9") {
146 claims_vp9_support = true; 136 claims_vp9_support = true;
147 break; 137 break;
148 } 138 }
(...skipping 67 matching lines...) Expand 10 before | Expand all | Expand 10 after
216 FAIL() << "Video Rotation extension not in header-extension list."; 206 FAIL() << "Video Rotation extension not in header-extension list.";
217 } 207 }
218 208
219 TEST_F(WebRtcVideoEngine2Test, CVOSetHeaderExtensionBeforeCapturer) { 209 TEST_F(WebRtcVideoEngine2Test, CVOSetHeaderExtensionBeforeCapturer) {
220 // Allocate the capturer first to prevent early destruction before channel's 210 // Allocate the capturer first to prevent early destruction before channel's
221 // dtor is called. 211 // dtor is called.
222 cricket::FakeVideoCapturer capturer; 212 cricket::FakeVideoCapturer capturer;
223 213
224 cricket::FakeWebRtcVideoEncoderFactory encoder_factory; 214 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
225 encoder_factory.AddSupportedVideoCodecType("VP8"); 215 encoder_factory.AddSupportedVideoCodecType("VP8");
226 cricket::VideoSendParameters parameters;
227 parameters.codecs.push_back(kVp8Codec);
228 216
229 std::unique_ptr<VideoMediaChannel> channel( 217 std::unique_ptr<VideoMediaChannel> channel(
230 SetUpForExternalEncoderFactory(&encoder_factory, parameters.codecs)); 218 SetUpForExternalEncoderFactory(&encoder_factory));
231 EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(kSsrc))); 219 EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(kSsrc)));
232 220
233 // Add CVO extension. 221 // Add CVO extension.
234 const int id = 1; 222 const int id = 1;
223 cricket::VideoSendParameters parameters;
224 parameters.codecs.push_back(GetEngineCodec("VP8"));
235 parameters.extensions.push_back( 225 parameters.extensions.push_back(
236 RtpExtension(RtpExtension::kVideoRotationUri, id)); 226 RtpExtension(RtpExtension::kVideoRotationUri, id));
237 EXPECT_TRUE(channel->SetSendParameters(parameters)); 227 EXPECT_TRUE(channel->SetSendParameters(parameters));
238 228
239 // Set capturer. 229 // Set capturer.
240 EXPECT_TRUE(channel->SetVideoSend(kSsrc, true, nullptr, &capturer)); 230 EXPECT_TRUE(channel->SetVideoSend(kSsrc, true, nullptr, &capturer));
241 231
242 // Verify capturer has turned off applying rotation. 232 // Verify capturer has turned off applying rotation.
243 EXPECT_FALSE(capturer.apply_rotation()); 233 EXPECT_FALSE(capturer.apply_rotation());
244 234
245 // Verify removing header extension turns on applying rotation. 235 // Verify removing header extension turns on applying rotation.
246 parameters.extensions.clear(); 236 parameters.extensions.clear();
247 EXPECT_TRUE(channel->SetSendParameters(parameters)); 237 EXPECT_TRUE(channel->SetSendParameters(parameters));
248 EXPECT_TRUE(capturer.apply_rotation()); 238 EXPECT_TRUE(capturer.apply_rotation());
249 } 239 }
250 240
251 TEST_F(WebRtcVideoEngine2Test, CVOSetHeaderExtensionBeforeAddSendStream) { 241 TEST_F(WebRtcVideoEngine2Test, CVOSetHeaderExtensionBeforeAddSendStream) {
252 // Allocate the capturer first to prevent early destruction before channel's 242 // Allocate the capturer first to prevent early destruction before channel's
253 // dtor is called. 243 // dtor is called.
254 cricket::FakeVideoCapturer capturer; 244 cricket::FakeVideoCapturer capturer;
255 245
256 cricket::FakeWebRtcVideoEncoderFactory encoder_factory; 246 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
257 encoder_factory.AddSupportedVideoCodecType("VP8"); 247 encoder_factory.AddSupportedVideoCodecType("VP8");
258 cricket::VideoSendParameters parameters;
259 parameters.codecs.push_back(kVp8Codec);
260 248
261 std::unique_ptr<VideoMediaChannel> channel( 249 std::unique_ptr<VideoMediaChannel> channel(
262 SetUpForExternalEncoderFactory(&encoder_factory, parameters.codecs)); 250 SetUpForExternalEncoderFactory(&encoder_factory));
263 // Add CVO extension. 251 // Add CVO extension.
264 const int id = 1; 252 const int id = 1;
253 cricket::VideoSendParameters parameters;
254 parameters.codecs.push_back(GetEngineCodec("VP8"));
265 parameters.extensions.push_back( 255 parameters.extensions.push_back(
266 RtpExtension(RtpExtension::kVideoRotationUri, id)); 256 RtpExtension(RtpExtension::kVideoRotationUri, id));
267 EXPECT_TRUE(channel->SetSendParameters(parameters)); 257 EXPECT_TRUE(channel->SetSendParameters(parameters));
268 EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(kSsrc))); 258 EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(kSsrc)));
269 259
270 // Set capturer. 260 // Set capturer.
271 EXPECT_TRUE(channel->SetVideoSend(kSsrc, true, nullptr, &capturer)); 261 EXPECT_TRUE(channel->SetVideoSend(kSsrc, true, nullptr, &capturer));
272 262
273 // Verify capturer has turned off applying rotation. 263 // Verify capturer has turned off applying rotation.
274 EXPECT_FALSE(capturer.apply_rotation()); 264 EXPECT_FALSE(capturer.apply_rotation());
275 } 265 }
276 266
277 TEST_F(WebRtcVideoEngine2Test, CVOSetHeaderExtensionAfterCapturer) { 267 TEST_F(WebRtcVideoEngine2Test, CVOSetHeaderExtensionAfterCapturer) {
278 cricket::FakeVideoCapturer capturer; 268 cricket::FakeVideoCapturer capturer;
279 269
280 cricket::FakeWebRtcVideoEncoderFactory encoder_factory; 270 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
281 encoder_factory.AddSupportedVideoCodecType("VP8"); 271 encoder_factory.AddSupportedVideoCodecType("VP8");
282 encoder_factory.AddSupportedVideoCodecType("VP9"); 272 encoder_factory.AddSupportedVideoCodecType("VP9");
283 cricket::VideoSendParameters parameters;
284 parameters.codecs.push_back(kVp8Codec);
285 parameters.codecs.push_back(kVp9Codec);
286 273
287 std::unique_ptr<VideoMediaChannel> channel( 274 std::unique_ptr<VideoMediaChannel> channel(
288 SetUpForExternalEncoderFactory(&encoder_factory, parameters.codecs)); 275 SetUpForExternalEncoderFactory(&encoder_factory));
289 EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(kSsrc))); 276 EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(kSsrc)));
290 277
291 // Set capturer. 278 // Set capturer.
292 EXPECT_TRUE(channel->SetVideoSend(kSsrc, true, nullptr, &capturer)); 279 EXPECT_TRUE(channel->SetVideoSend(kSsrc, true, nullptr, &capturer));
293 280
294 // Verify capturer has turned on applying rotation. 281 // Verify capturer has turned on applying rotation.
295 EXPECT_TRUE(capturer.apply_rotation()); 282 EXPECT_TRUE(capturer.apply_rotation());
296 283
297 // Add CVO extension. 284 // Add CVO extension.
298 const int id = 1; 285 const int id = 1;
286 cricket::VideoSendParameters parameters;
287 parameters.codecs.push_back(GetEngineCodec("VP8"));
288 parameters.codecs.push_back(GetEngineCodec("VP9"));
299 parameters.extensions.push_back( 289 parameters.extensions.push_back(
300 RtpExtension(RtpExtension::kVideoRotationUri, id)); 290 RtpExtension(RtpExtension::kVideoRotationUri, id));
301 // Also remove the first codec to trigger a codec change as well. 291 // Also remove the first codec to trigger a codec change as well.
302 parameters.codecs.erase(parameters.codecs.begin()); 292 parameters.codecs.erase(parameters.codecs.begin());
303 EXPECT_TRUE(channel->SetSendParameters(parameters)); 293 EXPECT_TRUE(channel->SetSendParameters(parameters));
304 294
305 // Verify capturer has turned off applying rotation. 295 // Verify capturer has turned off applying rotation.
306 EXPECT_FALSE(capturer.apply_rotation()); 296 EXPECT_FALSE(capturer.apply_rotation());
307 297
308 // Verify removing header extension turns on applying rotation. 298 // Verify removing header extension turns on applying rotation.
(...skipping 20 matching lines...) Expand all
329 std::unique_ptr<VideoMediaChannel> channel( 319 std::unique_ptr<VideoMediaChannel> channel(
330 engine_.CreateChannel(call_.get(), MediaConfig(), VideoOptions())); 320 engine_.CreateChannel(call_.get(), MediaConfig(), VideoOptions()));
331 EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(123))); 321 EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(123)));
332 VideoMediaInfo info; 322 VideoMediaInfo info;
333 channel->GetStats(&info); 323 channel->GetStats(&info);
334 } 324 }
335 325
336 TEST_F(WebRtcVideoEngine2Test, UseExternalFactoryForVp8WhenSupported) { 326 TEST_F(WebRtcVideoEngine2Test, UseExternalFactoryForVp8WhenSupported) {
337 cricket::FakeWebRtcVideoEncoderFactory encoder_factory; 327 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
338 encoder_factory.AddSupportedVideoCodecType("VP8"); 328 encoder_factory.AddSupportedVideoCodecType("VP8");
339 cricket::VideoSendParameters parameters;
340 parameters.codecs.push_back(kVp8Codec);
341 329
342 std::unique_ptr<VideoMediaChannel> channel( 330 std::unique_ptr<VideoMediaChannel> channel(
343 SetUpForExternalEncoderFactory(&encoder_factory, parameters.codecs)); 331 SetUpForExternalEncoderFactory(&encoder_factory));
344 332
345 EXPECT_TRUE( 333 EXPECT_TRUE(
346 channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc))); 334 channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
347 EXPECT_EQ(0, encoder_factory.GetNumCreatedEncoders()); 335 EXPECT_EQ(0, encoder_factory.GetNumCreatedEncoders());
348 EXPECT_TRUE(channel->SetSend(true)); 336 EXPECT_TRUE(channel->SetSend(true));
349 cricket::FakeVideoCapturer capturer; 337 cricket::FakeVideoCapturer capturer;
350 EXPECT_TRUE(channel->SetVideoSend(kSsrc, true, nullptr, &capturer)); 338 EXPECT_TRUE(channel->SetVideoSend(kSsrc, true, nullptr, &capturer));
351 EXPECT_EQ(cricket::CS_RUNNING, 339 EXPECT_EQ(cricket::CS_RUNNING,
352 capturer.Start(capturer.GetSupportedFormats()->front())); 340 capturer.Start(capturer.GetSupportedFormats()->front()));
353 EXPECT_TRUE(capturer.CaptureFrame()); 341 EXPECT_TRUE(capturer.CaptureFrame());
354 // Sending one frame will have allocate the encoder. 342 // Sending one frame will have allocate the encoder.
355 ASSERT_TRUE(encoder_factory.WaitForCreatedVideoEncoders(1)); 343 ASSERT_TRUE(encoder_factory.WaitForCreatedVideoEncoders(1));
356 EXPECT_TRUE_WAIT(encoder_factory.encoders()[0]->GetNumEncodedFrames() > 0, 344 EXPECT_TRUE_WAIT(encoder_factory.encoders()[0]->GetNumEncodedFrames() > 0,
357 kTimeout); 345 kTimeout);
358 346
359 int num_created_encoders = encoder_factory.GetNumCreatedEncoders(); 347 int num_created_encoders = encoder_factory.GetNumCreatedEncoders();
360 EXPECT_EQ(num_created_encoders, 1); 348 EXPECT_EQ(num_created_encoders, 1);
361 349
362 // Setting codecs of the same type should not reallocate any encoders 350 // Setting codecs of the same type should not reallocate any encoders
363 // (expecting a no-op). 351 // (expecting a no-op).
352 cricket::VideoSendParameters parameters;
353 parameters.codecs.push_back(GetEngineCodec("VP8"));
364 EXPECT_TRUE(channel->SetSendParameters(parameters)); 354 EXPECT_TRUE(channel->SetSendParameters(parameters));
365 EXPECT_EQ(num_created_encoders, encoder_factory.GetNumCreatedEncoders()); 355 EXPECT_EQ(num_created_encoders, encoder_factory.GetNumCreatedEncoders());
366 356
367 // Remove stream previously added to free the external encoder instance. 357 // Remove stream previously added to free the external encoder instance.
368 EXPECT_TRUE(channel->RemoveSendStream(kSsrc)); 358 EXPECT_TRUE(channel->RemoveSendStream(kSsrc));
369 EXPECT_EQ(0u, encoder_factory.encoders().size()); 359 EXPECT_EQ(0u, encoder_factory.encoders().size());
370 } 360 }
371 361
372 // Test that when an external encoder factory supports a codec we don't 362 // Test that when an external encoder factory supports a codec we don't
373 // internally support, we still add an RTX codec for it. 363 // internally support, we still add an RTX codec for it.
(...skipping 20 matching lines...) Expand all
394 c.GetParam(kCodecParamAssociatedPayloadType, 384 c.GetParam(kCodecParamAssociatedPayloadType,
395 &associated_payload_type) && 385 &associated_payload_type) &&
396 associated_payload_type == test_codec_it->id; 386 associated_payload_type == test_codec_it->id;
397 })); 387 }));
398 } 388 }
399 389
400 void WebRtcVideoEngine2Test::TestExtendedEncoderOveruse( 390 void WebRtcVideoEngine2Test::TestExtendedEncoderOveruse(
401 bool use_external_encoder) { 391 bool use_external_encoder) {
402 cricket::FakeWebRtcVideoEncoderFactory encoder_factory; 392 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
403 encoder_factory.AddSupportedVideoCodecType("VP8"); 393 encoder_factory.AddSupportedVideoCodecType("VP8");
404 cricket::VideoSendParameters parameters;
405 parameters.codecs.push_back(kVp8Codec);
406 std::unique_ptr<VideoMediaChannel> channel; 394 std::unique_ptr<VideoMediaChannel> channel;
407 FakeCall* fake_call = new FakeCall(webrtc::Call::Config(&event_log_)); 395 FakeCall* fake_call = new FakeCall(webrtc::Call::Config(&event_log_));
408 call_.reset(fake_call); 396 call_.reset(fake_call);
409 if (use_external_encoder) { 397 if (use_external_encoder) {
410 channel.reset( 398 channel.reset(SetUpForExternalEncoderFactory(&encoder_factory));
411 SetUpForExternalEncoderFactory(&encoder_factory, parameters.codecs));
412 } else { 399 } else {
413 engine_.Init(); 400 engine_.Init();
414 channel.reset( 401 channel.reset(
415 engine_.CreateChannel(call_.get(), MediaConfig(), VideoOptions())); 402 engine_.CreateChannel(call_.get(), MediaConfig(), VideoOptions()));
416 } 403 }
417 ASSERT_TRUE( 404 ASSERT_TRUE(
418 channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc))); 405 channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
406 cricket::VideoSendParameters parameters;
407 parameters.codecs.push_back(GetEngineCodec("VP8"));
419 EXPECT_TRUE(channel->SetSendParameters(parameters)); 408 EXPECT_TRUE(channel->SetSendParameters(parameters));
420 EXPECT_TRUE(channel->SetSend(true)); 409 EXPECT_TRUE(channel->SetSend(true));
421 FakeVideoSendStream* stream = fake_call->GetVideoSendStreams()[0]; 410 FakeVideoSendStream* stream = fake_call->GetVideoSendStreams()[0];
422 411
423 EXPECT_EQ(use_external_encoder, 412 EXPECT_EQ(use_external_encoder,
424 stream->GetConfig().encoder_settings.full_overuse_time); 413 stream->GetConfig().encoder_settings.full_overuse_time);
425 // Remove stream previously added to free the external encoder instance. 414 // Remove stream previously added to free the external encoder instance.
426 EXPECT_TRUE(channel->RemoveSendStream(kSsrc)); 415 EXPECT_TRUE(channel->RemoveSendStream(kSsrc));
427 } 416 }
428 417
429 TEST_F(WebRtcVideoEngine2Test, EnablesFullEncoderTimeForExternalEncoders) { 418 TEST_F(WebRtcVideoEngine2Test, EnablesFullEncoderTimeForExternalEncoders) {
430 TestExtendedEncoderOveruse(true); 419 TestExtendedEncoderOveruse(true);
431 } 420 }
432 421
433 TEST_F(WebRtcVideoEngine2Test, DisablesFullEncoderTimeForNonExternalEncoders) { 422 TEST_F(WebRtcVideoEngine2Test, DisablesFullEncoderTimeForNonExternalEncoders) {
434 TestExtendedEncoderOveruse(false); 423 TestExtendedEncoderOveruse(false);
435 } 424 }
436 425
437 #if !defined(RTC_DISABLE_VP9) 426 #if !defined(RTC_DISABLE_VP9)
438 TEST_F(WebRtcVideoEngine2Test, CanConstructDecoderForVp9EncoderFactory) { 427 TEST_F(WebRtcVideoEngine2Test, CanConstructDecoderForVp9EncoderFactory) {
439 cricket::FakeWebRtcVideoEncoderFactory encoder_factory; 428 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
440 encoder_factory.AddSupportedVideoCodecType("VP9"); 429 encoder_factory.AddSupportedVideoCodecType("VP9");
441 std::vector<cricket::VideoCodec> codecs;
442 codecs.push_back(kVp9Codec);
443 430
444 std::unique_ptr<VideoMediaChannel> channel( 431 std::unique_ptr<VideoMediaChannel> channel(
445 SetUpForExternalEncoderFactory(&encoder_factory, codecs)); 432 SetUpForExternalEncoderFactory(&encoder_factory));
446 433
447 EXPECT_TRUE( 434 EXPECT_TRUE(
448 channel->AddRecvStream(cricket::StreamParams::CreateLegacy(kSsrc))); 435 channel->AddRecvStream(cricket::StreamParams::CreateLegacy(kSsrc)));
449 } 436 }
450 #endif // !defined(RTC_DISABLE_VP9) 437 #endif // !defined(RTC_DISABLE_VP9)
451 438
452 TEST_F(WebRtcVideoEngine2Test, PropagatesInputFrameTimestamp) { 439 TEST_F(WebRtcVideoEngine2Test, PropagatesInputFrameTimestamp) {
453 cricket::FakeWebRtcVideoEncoderFactory encoder_factory; 440 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
454 encoder_factory.AddSupportedVideoCodecType("VP8"); 441 encoder_factory.AddSupportedVideoCodecType("VP8");
455 std::vector<cricket::VideoCodec> codecs;
456 codecs.push_back(kVp8Codec);
457 FakeCall* fake_call = new FakeCall(webrtc::Call::Config(&event_log_)); 442 FakeCall* fake_call = new FakeCall(webrtc::Call::Config(&event_log_));
458 call_.reset(fake_call); 443 call_.reset(fake_call);
459 std::unique_ptr<VideoMediaChannel> channel( 444 std::unique_ptr<VideoMediaChannel> channel(
460 SetUpForExternalEncoderFactory(&encoder_factory, codecs)); 445 SetUpForExternalEncoderFactory(&encoder_factory));
461 446
462 EXPECT_TRUE( 447 EXPECT_TRUE(
463 channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc))); 448 channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
464 449
465 FakeVideoCapturer capturer; 450 FakeVideoCapturer capturer;
466 EXPECT_TRUE(channel->SetVideoSend(kSsrc, true, nullptr, &capturer)); 451 EXPECT_TRUE(channel->SetVideoSend(kSsrc, true, nullptr, &capturer));
467 capturer.Start(cricket::VideoFormat(1280, 720, 452 capturer.Start(cricket::VideoFormat(1280, 720,
468 cricket::VideoFormat::FpsToInterval(60), 453 cricket::VideoFormat::FpsToInterval(60),
469 cricket::FOURCC_I420)); 454 cricket::FOURCC_I420));
470 channel->SetSend(true); 455 channel->SetSend(true);
(...skipping 29 matching lines...) Expand all
500 // Allow error to be no more than 1. 485 // Allow error to be no more than 1.
501 EXPECT_NEAR(cricket::VideoFormat::FpsToInterval(30) / 1E6, interval, 1); 486 EXPECT_NEAR(cricket::VideoFormat::FpsToInterval(30) / 1E6, interval, 1);
502 487
503 last_timestamp = timestamp; 488 last_timestamp = timestamp;
504 } 489 }
505 490
506 // Remove stream previously added to free the external encoder instance. 491 // Remove stream previously added to free the external encoder instance.
507 EXPECT_TRUE(channel->RemoveSendStream(kSsrc)); 492 EXPECT_TRUE(channel->RemoveSendStream(kSsrc));
508 } 493 }
509 494
495 cricket::VideoCodec WebRtcVideoEngine2Test::GetEngineCodec(
496 const std::string& name) {
497 for (const cricket::VideoCodec& engine_codec : engine_.codecs()) {
498 if (CodecNamesEq(name, engine_codec.name))
499 return engine_codec;
500 }
501 // This point should never be reached.
502 EXPECT_TRUE(false);
hta-webrtc 2016/11/15 11:34:59 FAIL()?
magjed_webrtc 2016/11/15 17:18:26 Done.
503 return cricket::VideoCodec();
504 }
505
510 VideoMediaChannel* WebRtcVideoEngine2Test::SetUpForExternalEncoderFactory( 506 VideoMediaChannel* WebRtcVideoEngine2Test::SetUpForExternalEncoderFactory(
511 cricket::WebRtcVideoEncoderFactory* encoder_factory, 507 cricket::WebRtcVideoEncoderFactory* encoder_factory) {
512 const std::vector<VideoCodec>& codecs) {
513 engine_.SetExternalEncoderFactory(encoder_factory); 508 engine_.SetExternalEncoderFactory(encoder_factory);
514 engine_.Init(); 509 engine_.Init();
515 510
516 VideoMediaChannel* channel = 511 VideoMediaChannel* channel =
517 engine_.CreateChannel(call_.get(), MediaConfig(), VideoOptions()); 512 engine_.CreateChannel(call_.get(), MediaConfig(), VideoOptions());
518 cricket::VideoSendParameters parameters; 513 cricket::VideoSendParameters parameters;
519 parameters.codecs = codecs; 514 // Need to look up the codec in the engine to get the correct payload type.
hta-webrtc 2016/11/15 11:35:00 Grammar: "We need to look up ", or just "We look u
magjed_webrtc 2016/11/15 17:18:26 Done.
515 for (const VideoCodec& codec : encoder_factory->supported_codecs())
516 parameters.codecs.push_back(GetEngineCodec(codec.name));
517
520 EXPECT_TRUE(channel->SetSendParameters(parameters)); 518 EXPECT_TRUE(channel->SetSendParameters(parameters));
521 519
522 return channel; 520 return channel;
523 } 521 }
524 522
525 VideoMediaChannel* WebRtcVideoEngine2Test::SetUpForExternalDecoderFactory( 523 VideoMediaChannel* WebRtcVideoEngine2Test::SetUpForExternalDecoderFactory(
526 cricket::WebRtcVideoDecoderFactory* decoder_factory, 524 cricket::WebRtcVideoDecoderFactory* decoder_factory,
527 const std::vector<VideoCodec>& codecs) { 525 const std::vector<VideoCodec>& codecs) {
528 engine_.SetExternalDecoderFactory(decoder_factory); 526 engine_.SetExternalDecoderFactory(decoder_factory);
529 engine_.Init(); 527 engine_.Init();
530 528
531 VideoMediaChannel* channel = 529 VideoMediaChannel* channel =
532 engine_.CreateChannel(call_.get(), MediaConfig(), VideoOptions()); 530 engine_.CreateChannel(call_.get(), MediaConfig(), VideoOptions());
533 cricket::VideoRecvParameters parameters; 531 cricket::VideoRecvParameters parameters;
534 parameters.codecs = codecs; 532 parameters.codecs = codecs;
535 EXPECT_TRUE(channel->SetRecvParameters(parameters)); 533 EXPECT_TRUE(channel->SetRecvParameters(parameters));
536 534
537 return channel; 535 return channel;
538 } 536 }
539 537
540 TEST_F(WebRtcVideoEngine2Test, UsesSimulcastAdapterForVp8Factories) { 538 TEST_F(WebRtcVideoEngine2Test, UsesSimulcastAdapterForVp8Factories) {
541 cricket::FakeWebRtcVideoEncoderFactory encoder_factory; 539 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
542 encoder_factory.AddSupportedVideoCodecType("VP8"); 540 encoder_factory.AddSupportedVideoCodecType("VP8");
543 std::vector<cricket::VideoCodec> codecs;
544 codecs.push_back(kVp8Codec);
545 541
546 std::unique_ptr<VideoMediaChannel> channel( 542 std::unique_ptr<VideoMediaChannel> channel(
547 SetUpForExternalEncoderFactory(&encoder_factory, codecs)); 543 SetUpForExternalEncoderFactory(&encoder_factory));
548 544
549 std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs3); 545 std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs3);
550 546
551 EXPECT_TRUE( 547 EXPECT_TRUE(
552 channel->AddSendStream(CreateSimStreamParams("cname", ssrcs))); 548 channel->AddSendStream(CreateSimStreamParams("cname", ssrcs)));
553 EXPECT_TRUE(channel->SetSend(true)); 549 EXPECT_TRUE(channel->SetSend(true));
554 550
555 cricket::FakeVideoCapturer capturer; 551 cricket::FakeVideoCapturer capturer;
556 EXPECT_TRUE(channel->SetVideoSend(ssrcs.front(), true, nullptr, &capturer)); 552 EXPECT_TRUE(channel->SetVideoSend(ssrcs.front(), true, nullptr, &capturer));
557 EXPECT_EQ(cricket::CS_RUNNING, 553 EXPECT_EQ(cricket::CS_RUNNING,
(...skipping 16 matching lines...) Expand all
574 570
575 EXPECT_TRUE(channel->SetVideoSend(ssrcs.front(), true, nullptr, nullptr)); 571 EXPECT_TRUE(channel->SetVideoSend(ssrcs.front(), true, nullptr, nullptr));
576 572
577 channel.reset(); 573 channel.reset();
578 ASSERT_EQ(0u, encoder_factory.encoders().size()); 574 ASSERT_EQ(0u, encoder_factory.encoders().size());
579 } 575 }
580 576
581 TEST_F(WebRtcVideoEngine2Test, ChannelWithExternalH264CanChangeToInternalVp8) { 577 TEST_F(WebRtcVideoEngine2Test, ChannelWithExternalH264CanChangeToInternalVp8) {
582 cricket::FakeWebRtcVideoEncoderFactory encoder_factory; 578 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
583 encoder_factory.AddSupportedVideoCodecType("H264"); 579 encoder_factory.AddSupportedVideoCodecType("H264");
584 std::vector<cricket::VideoCodec> codecs;
585 codecs.push_back(kH264Codec);
586 580
587 std::unique_ptr<VideoMediaChannel> channel( 581 std::unique_ptr<VideoMediaChannel> channel(
588 SetUpForExternalEncoderFactory(&encoder_factory, codecs)); 582 SetUpForExternalEncoderFactory(&encoder_factory));
589 583
590 EXPECT_TRUE( 584 EXPECT_TRUE(
591 channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc))); 585 channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
592 ASSERT_EQ(1u, encoder_factory.encoders().size()); 586 ASSERT_EQ(1u, encoder_factory.encoders().size());
593 587
594 cricket::VideoSendParameters parameters; 588 cricket::VideoSendParameters parameters;
595 parameters.codecs.push_back(kVp8Codec); 589 parameters.codecs.push_back(GetEngineCodec("VP8"));
596 EXPECT_TRUE(channel->SetSendParameters(parameters)); 590 EXPECT_TRUE(channel->SetSendParameters(parameters));
597 ASSERT_EQ(0u, encoder_factory.encoders().size()); 591 ASSERT_EQ(0u, encoder_factory.encoders().size());
598 } 592 }
599 593
600 TEST_F(WebRtcVideoEngine2Test, 594 TEST_F(WebRtcVideoEngine2Test,
601 DontUseExternalEncoderFactoryForUnsupportedCodecs) { 595 DontUseExternalEncoderFactoryForUnsupportedCodecs) {
602 cricket::FakeWebRtcVideoEncoderFactory encoder_factory; 596 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
603 encoder_factory.AddSupportedVideoCodecType("H264"); 597 encoder_factory.AddSupportedVideoCodecType("H264");
604 std::vector<cricket::VideoCodec> codecs; 598
605 codecs.push_back(kVp8Codec); 599 engine_.SetExternalEncoderFactory(&encoder_factory);
600 engine_.Init();
606 601
607 std::unique_ptr<VideoMediaChannel> channel( 602 std::unique_ptr<VideoMediaChannel> channel(
608 SetUpForExternalEncoderFactory(&encoder_factory, codecs)); 603 engine_.CreateChannel(call_.get(), MediaConfig(), VideoOptions()));
604 cricket::VideoSendParameters parameters;
605 parameters.codecs.push_back(GetEngineCodec("VP8"));
606 EXPECT_TRUE(channel->SetSendParameters(parameters));
609 607
610 EXPECT_TRUE( 608 EXPECT_TRUE(
611 channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc))); 609 channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
612 // Make sure DestroyVideoEncoder was called on the factory. 610 // Make sure DestroyVideoEncoder was called on the factory.
613 ASSERT_EQ(0u, encoder_factory.encoders().size()); 611 ASSERT_EQ(0u, encoder_factory.encoders().size());
614 } 612 }
615 613
616 TEST_F(WebRtcVideoEngine2Test, 614 TEST_F(WebRtcVideoEngine2Test,
617 UsesSimulcastAdapterForVp8WithCombinedVP8AndH264Factory) { 615 UsesSimulcastAdapterForVp8WithCombinedVP8AndH264Factory) {
618 cricket::FakeWebRtcVideoEncoderFactory encoder_factory; 616 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
619 encoder_factory.AddSupportedVideoCodecType("VP8"); 617 encoder_factory.AddSupportedVideoCodecType("VP8");
620 encoder_factory.AddSupportedVideoCodecType("H264"); 618 encoder_factory.AddSupportedVideoCodecType("H264");
621 619
622 std::vector<cricket::VideoCodec> codecs; 620 engine_.SetExternalEncoderFactory(&encoder_factory);
623 codecs.push_back(kVp8Codec); 621 engine_.Init();
624 622
625 std::unique_ptr<VideoMediaChannel> channel( 623 std::unique_ptr<VideoMediaChannel> channel(
626 SetUpForExternalEncoderFactory(&encoder_factory, codecs)); 624 engine_.CreateChannel(call_.get(), MediaConfig(), VideoOptions()));
625 cricket::VideoSendParameters parameters;
626 parameters.codecs.push_back(GetEngineCodec("VP8"));
627 EXPECT_TRUE(channel->SetSendParameters(parameters));
627 628
628 std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs3); 629 std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs3);
629 630
630 EXPECT_TRUE( 631 EXPECT_TRUE(
631 channel->AddSendStream(CreateSimStreamParams("cname", ssrcs))); 632 channel->AddSendStream(CreateSimStreamParams("cname", ssrcs)));
632 EXPECT_TRUE(channel->SetSend(true)); 633 EXPECT_TRUE(channel->SetSend(true));
633 634
634 // Send a fake frame, or else the media engine will configure the simulcast 635 // Send a fake frame, or else the media engine will configure the simulcast
635 // encoder adapter at a low-enough size that it'll only create a single 636 // encoder adapter at a low-enough size that it'll only create a single
636 // encoder layer. 637 // encoder layer.
(...skipping 12 matching lines...) Expand all
649 // Make sure DestroyVideoEncoder was called on the factory. 650 // Make sure DestroyVideoEncoder was called on the factory.
650 EXPECT_EQ(0u, encoder_factory.encoders().size()); 651 EXPECT_EQ(0u, encoder_factory.encoders().size());
651 } 652 }
652 653
653 TEST_F(WebRtcVideoEngine2Test, 654 TEST_F(WebRtcVideoEngine2Test,
654 DestroysNonSimulcastEncoderFromCombinedVP8AndH264Factory) { 655 DestroysNonSimulcastEncoderFromCombinedVP8AndH264Factory) {
655 cricket::FakeWebRtcVideoEncoderFactory encoder_factory; 656 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
656 encoder_factory.AddSupportedVideoCodecType("VP8"); 657 encoder_factory.AddSupportedVideoCodecType("VP8");
657 encoder_factory.AddSupportedVideoCodecType("H264"); 658 encoder_factory.AddSupportedVideoCodecType("H264");
658 659
659 std::vector<cricket::VideoCodec> codecs; 660 engine_.SetExternalEncoderFactory(&encoder_factory);
660 codecs.push_back(kH264Codec); 661 engine_.Init();
661 662
662 std::unique_ptr<VideoMediaChannel> channel( 663 std::unique_ptr<VideoMediaChannel> channel(
663 SetUpForExternalEncoderFactory(&encoder_factory, codecs)); 664 engine_.CreateChannel(call_.get(), MediaConfig(), VideoOptions()));
665 cricket::VideoSendParameters parameters;
666 parameters.codecs.push_back(GetEngineCodec("H264"));
667 EXPECT_TRUE(channel->SetSendParameters(parameters));
664 668
665 EXPECT_TRUE( 669 EXPECT_TRUE(
666 channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc))); 670 channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc)));
667 ASSERT_EQ(1u, encoder_factory.encoders().size()); 671 ASSERT_EQ(1u, encoder_factory.encoders().size());
668 672
669 // Send a frame of 720p. This should trigger a "real" encoder initialization. 673 // Send a frame of 720p. This should trigger a "real" encoder initialization.
670 cricket::VideoFormat format( 674 cricket::VideoFormat format(
671 1280, 720, cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420); 675 1280, 720, cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420);
672 cricket::FakeVideoCapturer capturer; 676 cricket::FakeVideoCapturer capturer;
673 EXPECT_TRUE(channel->SetVideoSend(kSsrc, true, nullptr, &capturer)); 677 EXPECT_TRUE(channel->SetVideoSend(kSsrc, true, nullptr, &capturer));
674 EXPECT_EQ(cricket::CS_RUNNING, capturer.Start(format)); 678 EXPECT_EQ(cricket::CS_RUNNING, capturer.Start(format));
675 EXPECT_TRUE(capturer.CaptureFrame()); 679 EXPECT_TRUE(capturer.CaptureFrame());
676 ASSERT_TRUE(encoder_factory.encoders()[0]->WaitForInitEncode()); 680 ASSERT_TRUE(encoder_factory.encoders()[0]->WaitForInitEncode());
677 EXPECT_EQ(webrtc::kVideoCodecH264, 681 EXPECT_EQ(webrtc::kVideoCodecH264,
678 encoder_factory.encoders()[0]->GetCodecSettings().codecType); 682 encoder_factory.encoders()[0]->GetCodecSettings().codecType);
679 683
680 channel.reset(); 684 channel.reset();
681 // Make sure DestroyVideoEncoder was called on the factory. 685 // Make sure DestroyVideoEncoder was called on the factory.
682 ASSERT_EQ(0u, encoder_factory.encoders().size()); 686 ASSERT_EQ(0u, encoder_factory.encoders().size());
683 } 687 }
684 688
685 TEST_F(WebRtcVideoEngine2Test, SimulcastDisabledForH264) { 689 TEST_F(WebRtcVideoEngine2Test, SimulcastDisabledForH264) {
686 cricket::FakeWebRtcVideoEncoderFactory encoder_factory; 690 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
687 encoder_factory.AddSupportedVideoCodecType("H264"); 691 encoder_factory.AddSupportedVideoCodecType("H264");
688 std::vector<cricket::VideoCodec> codecs;
689 codecs.push_back(kH264Codec);
690 692
691 std::unique_ptr<VideoMediaChannel> channel( 693 std::unique_ptr<VideoMediaChannel> channel(
692 SetUpForExternalEncoderFactory(&encoder_factory, codecs)); 694 SetUpForExternalEncoderFactory(&encoder_factory));
693 695
694 const std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs3); 696 const std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs3);
695 EXPECT_TRUE( 697 EXPECT_TRUE(
696 channel->AddSendStream(cricket::CreateSimStreamParams("cname", ssrcs))); 698 channel->AddSendStream(cricket::CreateSimStreamParams("cname", ssrcs)));
697 699
698 // Send a frame of 720p. This should trigger a "real" encoder initialization. 700 // Send a frame of 720p. This should trigger a "real" encoder initialization.
699 cricket::VideoFormat format( 701 cricket::VideoFormat format(
700 1280, 720, cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420); 702 1280, 720, cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420);
701 cricket::FakeVideoCapturer capturer; 703 cricket::FakeVideoCapturer capturer;
702 EXPECT_TRUE(channel->SetVideoSend(ssrcs[0], true, nullptr, &capturer)); 704 EXPECT_TRUE(channel->SetVideoSend(ssrcs[0], true, nullptr, &capturer));
(...skipping 22 matching lines...) Expand all
725 727
726 // The external codec will appear at last. 728 // The external codec will appear at last.
727 EXPECT_EQ("VP8", internal_codec.name); 729 EXPECT_EQ("VP8", internal_codec.name);
728 EXPECT_EQ("FakeExternalCodec", external_codec.name); 730 EXPECT_EQ("FakeExternalCodec", external_codec.name);
729 } 731 }
730 732
731 TEST_F(WebRtcVideoEngine2Test, RegisterExternalDecodersIfSupported) { 733 TEST_F(WebRtcVideoEngine2Test, RegisterExternalDecodersIfSupported) {
732 cricket::FakeWebRtcVideoDecoderFactory decoder_factory; 734 cricket::FakeWebRtcVideoDecoderFactory decoder_factory;
733 decoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8); 735 decoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8);
734 cricket::VideoRecvParameters parameters; 736 cricket::VideoRecvParameters parameters;
735 parameters.codecs.push_back(kVp8Codec); 737 parameters.codecs.push_back(GetEngineCodec("VP8"));
736 738
737 std::unique_ptr<VideoMediaChannel> channel( 739 std::unique_ptr<VideoMediaChannel> channel(
738 SetUpForExternalDecoderFactory(&decoder_factory, parameters.codecs)); 740 SetUpForExternalDecoderFactory(&decoder_factory, parameters.codecs));
739 741
740 EXPECT_TRUE( 742 EXPECT_TRUE(
741 channel->AddRecvStream(cricket::StreamParams::CreateLegacy(kSsrc))); 743 channel->AddRecvStream(cricket::StreamParams::CreateLegacy(kSsrc)));
742 ASSERT_EQ(1u, decoder_factory.decoders().size()); 744 ASSERT_EQ(1u, decoder_factory.decoders().size());
743 745
744 // Setting codecs of the same type should not reallocate the decoder. 746 // Setting codecs of the same type should not reallocate the decoder.
745 EXPECT_TRUE(channel->SetRecvParameters(parameters)); 747 EXPECT_TRUE(channel->SetRecvParameters(parameters));
746 EXPECT_EQ(1, decoder_factory.GetNumCreatedDecoders()); 748 EXPECT_EQ(1, decoder_factory.GetNumCreatedDecoders());
747 749
748 // Remove stream previously added to free the external decoder instance. 750 // Remove stream previously added to free the external decoder instance.
749 EXPECT_TRUE(channel->RemoveRecvStream(kSsrc)); 751 EXPECT_TRUE(channel->RemoveRecvStream(kSsrc));
750 EXPECT_EQ(0u, decoder_factory.decoders().size()); 752 EXPECT_EQ(0u, decoder_factory.decoders().size());
751 } 753 }
752 754
753 // Verifies that we can set up decoders that are not internally supported. 755 // Verifies that we can set up decoders that are not internally supported.
754 TEST_F(WebRtcVideoEngine2Test, RegisterExternalH264DecoderIfSupported) { 756 TEST_F(WebRtcVideoEngine2Test, RegisterExternalH264DecoderIfSupported) {
755 // TODO(pbos): Do not assume that encoder/decoder support is symmetric. We 757 // TODO(pbos): Do not assume that encoder/decoder support is symmetric. We
756 // can't even query the WebRtcVideoDecoderFactory for supported codecs. 758 // can't even query the WebRtcVideoDecoderFactory for supported codecs.
757 // For now we add a FakeWebRtcVideoEncoderFactory to add H264 to supported 759 // For now we add a FakeWebRtcVideoEncoderFactory to add H264 to supported
758 // codecs. 760 // codecs.
759 cricket::FakeWebRtcVideoEncoderFactory encoder_factory; 761 cricket::FakeWebRtcVideoEncoderFactory encoder_factory;
760 encoder_factory.AddSupportedVideoCodecType("H264"); 762 encoder_factory.AddSupportedVideoCodecType("H264");
761 engine_.SetExternalEncoderFactory(&encoder_factory); 763 engine_.SetExternalEncoderFactory(&encoder_factory);
762 cricket::FakeWebRtcVideoDecoderFactory decoder_factory; 764 cricket::FakeWebRtcVideoDecoderFactory decoder_factory;
763 decoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecH264); 765 decoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecH264);
764 std::vector<cricket::VideoCodec> codecs; 766 std::vector<cricket::VideoCodec> codecs;
765 codecs.push_back(kH264Codec); 767 codecs.push_back(GetEngineCodec("H264"));
766 768
767 std::unique_ptr<VideoMediaChannel> channel( 769 std::unique_ptr<VideoMediaChannel> channel(
768 SetUpForExternalDecoderFactory(&decoder_factory, codecs)); 770 SetUpForExternalDecoderFactory(&decoder_factory, codecs));
769 771
770 EXPECT_TRUE( 772 EXPECT_TRUE(
771 channel->AddRecvStream(cricket::StreamParams::CreateLegacy(kSsrc))); 773 channel->AddRecvStream(cricket::StreamParams::CreateLegacy(kSsrc)));
772 ASSERT_EQ(1u, decoder_factory.decoders().size()); 774 ASSERT_EQ(1u, decoder_factory.decoders().size());
773 } 775 }
774 776
775 class WebRtcVideoChannel2BaseTest 777 class WebRtcVideoChannel2BaseTest
776 : public VideoMediaChannelTest<WebRtcVideoEngine2, WebRtcVideoChannel2> { 778 : public VideoMediaChannelTest<WebRtcVideoEngine2, WebRtcVideoChannel2> {
777 protected: 779 protected:
778 typedef VideoMediaChannelTest<WebRtcVideoEngine2, WebRtcVideoChannel2> Base; 780 typedef VideoMediaChannelTest<WebRtcVideoEngine2, WebRtcVideoChannel2> Base;
779 781
780 cricket::VideoCodec DefaultCodec() override { return kVp8Codec; } 782 cricket::VideoCodec GetEngineCodec(const std::string& name) {
783 for (const cricket::VideoCodec& engine_codec : engine_.codecs()) {
784 if (CodecNamesEq(name, engine_codec.name))
785 return engine_codec;
786 }
787 // This point should never be reached.
788 EXPECT_TRUE(false);
hta-webrtc 2016/11/15 11:34:59 FAIL()
magjed_webrtc 2016/11/15 17:18:26 Done.
789 return cricket::VideoCodec();
790 }
791
792 cricket::VideoCodec DefaultCodec() override { return GetEngineCodec("VP8"); }
781 }; 793 };
782 794
783 // Verifies that id given in stream params is passed to the decoder factory. 795 // Verifies that id given in stream params is passed to the decoder factory.
784 TEST_F(WebRtcVideoEngine2Test, StreamParamsIdPassedToDecoderFactory) { 796 TEST_F(WebRtcVideoEngine2Test, StreamParamsIdPassedToDecoderFactory) {
785 cricket::FakeWebRtcVideoDecoderFactory decoder_factory; 797 cricket::FakeWebRtcVideoDecoderFactory decoder_factory;
786 decoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8); 798 decoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8);
787 cricket::VideoRecvParameters parameters; 799 cricket::VideoRecvParameters parameters;
788 parameters.codecs.push_back(kVp8Codec); 800 parameters.codecs.push_back(GetEngineCodec("VP8"));
789 801
790 std::unique_ptr<VideoMediaChannel> channel( 802 std::unique_ptr<VideoMediaChannel> channel(
791 SetUpForExternalDecoderFactory(&decoder_factory, parameters.codecs)); 803 SetUpForExternalDecoderFactory(&decoder_factory, parameters.codecs));
792 804
793 StreamParams sp = cricket::StreamParams::CreateLegacy(kSsrc); 805 StreamParams sp = cricket::StreamParams::CreateLegacy(kSsrc);
794 sp.id = "FakeStreamParamsId"; 806 sp.id = "FakeStreamParamsId";
795 EXPECT_TRUE(channel->AddRecvStream(sp)); 807 EXPECT_TRUE(channel->AddRecvStream(sp));
796 EXPECT_EQ(1u, decoder_factory.decoders().size()); 808 EXPECT_EQ(1u, decoder_factory.decoders().size());
797 809
798 std::vector<cricket::VideoDecoderParams> params = decoder_factory.params(); 810 std::vector<cricket::VideoDecoderParams> params = decoder_factory.params();
(...skipping 30 matching lines...) Expand all
829 841
830 WEBRTC_BASE_TEST(RemoveCapturerWithoutAdd); 842 WEBRTC_BASE_TEST(RemoveCapturerWithoutAdd);
831 843
832 WEBRTC_BASE_TEST(AddRemoveCapturerMultipleSources); 844 WEBRTC_BASE_TEST(AddRemoveCapturerMultipleSources);
833 845
834 WEBRTC_BASE_TEST(RejectEmptyStreamParams); 846 WEBRTC_BASE_TEST(RejectEmptyStreamParams);
835 847
836 WEBRTC_BASE_TEST(MultipleSendStreams); 848 WEBRTC_BASE_TEST(MultipleSendStreams);
837 849
838 TEST_F(WebRtcVideoChannel2BaseTest, SendAndReceiveVp8Vga) { 850 TEST_F(WebRtcVideoChannel2BaseTest, SendAndReceiveVp8Vga) {
839 SendAndReceive(cricket::VideoCodec(100, "VP8")); 851 SendAndReceive(GetEngineCodec("VP8"));
840 } 852 }
841 853
842 TEST_F(WebRtcVideoChannel2BaseTest, SendAndReceiveVp8Qvga) { 854 TEST_F(WebRtcVideoChannel2BaseTest, SendAndReceiveVp8Qvga) {
843 SendAndReceive(cricket::VideoCodec(100, "VP8")); 855 SendAndReceive(GetEngineCodec("VP8"));
844 } 856 }
845 857
846 TEST_F(WebRtcVideoChannel2BaseTest, SendAndReceiveVp8SvcQqvga) { 858 TEST_F(WebRtcVideoChannel2BaseTest, SendAndReceiveVp8SvcQqvga) {
847 SendAndReceive(cricket::VideoCodec(100, "VP8")); 859 SendAndReceive(GetEngineCodec("VP8"));
848 } 860 }
849 861
850 TEST_F(WebRtcVideoChannel2BaseTest, TwoStreamsSendAndReceive) { 862 TEST_F(WebRtcVideoChannel2BaseTest, TwoStreamsSendAndReceive) {
851 // Set a high bitrate to not be downscaled by VP8 due to low initial start 863 // Set a high bitrate to not be downscaled by VP8 due to low initial start
852 // bitrates. This currently happens at <250k, and two streams sharing 300k 864 // bitrates. This currently happens at <250k, and two streams sharing 300k
853 // initially will use QVGA instead of VGA. 865 // initially will use QVGA instead of VGA.
854 // TODO(pbos): Set up the quality scaler so that both senders reliably start 866 // TODO(pbos): Set up the quality scaler so that both senders reliably start
855 // at QVGA, then verify that instead. 867 // at QVGA, then verify that instead.
856 cricket::VideoCodec codec = kVp8Codec; 868 cricket::VideoCodec codec = GetEngineCodec("VP8");
857 codec.params[kCodecParamStartBitrate] = "1000000"; 869 codec.params[kCodecParamStartBitrate] = "1000000";
858 Base::TwoStreamsSendAndReceive(codec); 870 Base::TwoStreamsSendAndReceive(codec);
859 } 871 }
860 872
861 class WebRtcVideoChannel2Test : public WebRtcVideoEngine2Test { 873 class WebRtcVideoChannel2Test : public WebRtcVideoEngine2Test {
862 public: 874 public:
863 WebRtcVideoChannel2Test() : WebRtcVideoChannel2Test("") {} 875 WebRtcVideoChannel2Test() : WebRtcVideoChannel2Test("") {}
864 explicit WebRtcVideoChannel2Test(const char* field_trials) 876 explicit WebRtcVideoChannel2Test(const char* field_trials)
865 : WebRtcVideoEngine2Test(field_trials), last_ssrc_(0) {} 877 : WebRtcVideoEngine2Test(field_trials), last_ssrc_(0) {}
866 void SetUp() override { 878 void SetUp() override {
(...skipping 39 matching lines...) Expand 10 before | Expand all | Expand 10 after
906 } 918 }
907 919
908 void SetSendCodecsShouldWorkForBitrates(const char* min_bitrate_kbps, 920 void SetSendCodecsShouldWorkForBitrates(const char* min_bitrate_kbps,
909 int expected_min_bitrate_bps, 921 int expected_min_bitrate_bps,
910 const char* start_bitrate_kbps, 922 const char* start_bitrate_kbps,
911 int expected_start_bitrate_bps, 923 int expected_start_bitrate_bps,
912 const char* max_bitrate_kbps, 924 const char* max_bitrate_kbps,
913 int expected_max_bitrate_bps) { 925 int expected_max_bitrate_bps) {
914 auto& codecs = send_parameters_.codecs; 926 auto& codecs = send_parameters_.codecs;
915 codecs.clear(); 927 codecs.clear();
916 codecs.push_back(kVp8Codec); 928 codecs.push_back(GetEngineCodec("VP8"));
917 codecs[0].params[kCodecParamMinBitrate] = min_bitrate_kbps; 929 codecs[0].params[kCodecParamMinBitrate] = min_bitrate_kbps;
918 codecs[0].params[kCodecParamStartBitrate] = start_bitrate_kbps; 930 codecs[0].params[kCodecParamStartBitrate] = start_bitrate_kbps;
919 codecs[0].params[kCodecParamMaxBitrate] = max_bitrate_kbps; 931 codecs[0].params[kCodecParamMaxBitrate] = max_bitrate_kbps;
920 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); 932 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_));
921 933
922 EXPECT_EQ(expected_min_bitrate_bps, 934 EXPECT_EQ(expected_min_bitrate_bps,
923 fake_call_->GetConfig().bitrate_config.min_bitrate_bps); 935 fake_call_->GetConfig().bitrate_config.min_bitrate_bps);
924 EXPECT_EQ(expected_start_bitrate_bps, 936 EXPECT_EQ(expected_start_bitrate_bps,
925 fake_call_->GetConfig().bitrate_config.start_bitrate_bps); 937 fake_call_->GetConfig().bitrate_config.start_bitrate_bps);
926 EXPECT_EQ(expected_max_bitrate_bps, 938 EXPECT_EQ(expected_max_bitrate_bps,
(...skipping 91 matching lines...) Expand 10 before | Expand all | Expand 10 after
1018 // Verify that only one of them has been set, and that it is the one with 1030 // Verify that only one of them has been set, and that it is the one with
1019 // highest priority (transport sequence number). 1031 // highest priority (transport sequence number).
1020 ASSERT_EQ(1u, send_stream->GetConfig().rtp.extensions.size()); 1032 ASSERT_EQ(1u, send_stream->GetConfig().rtp.extensions.size());
1021 EXPECT_EQ(expected_id, send_stream->GetConfig().rtp.extensions[0].id); 1033 EXPECT_EQ(expected_id, send_stream->GetConfig().rtp.extensions[0].id);
1022 EXPECT_EQ(expected_extension, 1034 EXPECT_EQ(expected_extension,
1023 send_stream->GetConfig().rtp.extensions[0].uri); 1035 send_stream->GetConfig().rtp.extensions[0].uri);
1024 } 1036 }
1025 1037
1026 void TestCpuAdaptation(bool enable_overuse, bool is_screenshare); 1038 void TestCpuAdaptation(bool enable_overuse, bool is_screenshare);
1027 void TestReceiverLocalSsrcConfiguration(bool receiver_first); 1039 void TestReceiverLocalSsrcConfiguration(bool receiver_first);
1028 void TestReceiveUnsignalledSsrcPacket(uint8_t payload_type, 1040 void TestReceiveUnsignaledSsrcPacket(uint8_t payload_type,
1029 bool expect_created_receive_stream); 1041 bool expect_created_receive_stream);
1030 1042
1031 FakeVideoSendStream* SetDenoisingOption( 1043 FakeVideoSendStream* SetDenoisingOption(
1032 uint32_t ssrc, 1044 uint32_t ssrc,
1033 cricket::FakeVideoCapturer* capturer, 1045 cricket::FakeVideoCapturer* capturer,
1034 bool enabled) { 1046 bool enabled) {
1035 cricket::VideoOptions options; 1047 cricket::VideoOptions options;
1036 options.video_noise_reduction = rtc::Optional<bool>(enabled); 1048 options.video_noise_reduction = rtc::Optional<bool>(enabled);
1037 EXPECT_TRUE(channel_->SetVideoSend(ssrc, true, &options, capturer)); 1049 EXPECT_TRUE(channel_->SetVideoSend(ssrc, true, &options, capturer));
1038 // Options only take effect on the next frame. 1050 // Options only take effect on the next frame.
1039 EXPECT_TRUE(capturer->CaptureFrame()); 1051 EXPECT_TRUE(capturer->CaptureFrame());
(...skipping 353 matching lines...) Expand 10 before | Expand all | Expand 10 after
1393 FakeVideoReceiveStream* stream = AddRecvStream(); 1405 FakeVideoReceiveStream* stream = AddRecvStream();
1394 EXPECT_TRUE(stream->GetConfig().rtp.transport_cc); 1406 EXPECT_TRUE(stream->GetConfig().rtp.transport_cc);
1395 } 1407 }
1396 1408
1397 TEST_F(WebRtcVideoChannel2Test, RembCanBeEnabledAndDisabled) { 1409 TEST_F(WebRtcVideoChannel2Test, RembCanBeEnabledAndDisabled) {
1398 FakeVideoReceiveStream* stream = AddRecvStream(); 1410 FakeVideoReceiveStream* stream = AddRecvStream();
1399 EXPECT_TRUE(stream->GetConfig().rtp.remb); 1411 EXPECT_TRUE(stream->GetConfig().rtp.remb);
1400 1412
1401 // Verify that REMB is turned off when send(!) codecs without REMB are set. 1413 // Verify that REMB is turned off when send(!) codecs without REMB are set.
1402 cricket::VideoSendParameters parameters; 1414 cricket::VideoSendParameters parameters;
1403 parameters.codecs.push_back(kVp8Codec); 1415 cricket::VideoCodec vp8_codec_without_feedback_params = GetEngineCodec("VP8");
1416 vp8_codec_without_feedback_params.feedback_params = cricket::FeedbackParams();
1417 parameters.codecs.push_back(vp8_codec_without_feedback_params);
1404 EXPECT_TRUE(parameters.codecs[0].feedback_params.params().empty()); 1418 EXPECT_TRUE(parameters.codecs[0].feedback_params.params().empty());
1405 EXPECT_TRUE(channel_->SetSendParameters(parameters)); 1419 EXPECT_TRUE(channel_->SetSendParameters(parameters));
1406 stream = fake_call_->GetVideoReceiveStreams()[0]; 1420 stream = fake_call_->GetVideoReceiveStreams()[0];
1407 EXPECT_FALSE(stream->GetConfig().rtp.remb); 1421 EXPECT_FALSE(stream->GetConfig().rtp.remb);
1408 1422
1409 // Verify that REMB is turned on when setting default codecs since the 1423 // Verify that REMB is turned on when setting default codecs since the
1410 // default codecs have REMB enabled. 1424 // default codecs have REMB enabled.
1411 parameters.codecs = engine_.codecs(); 1425 parameters.codecs = engine_.codecs();
1412 EXPECT_TRUE(channel_->SetSendParameters(parameters)); 1426 EXPECT_TRUE(channel_->SetSendParameters(parameters));
1413 stream = fake_call_->GetVideoReceiveStreams()[0]; 1427 stream = fake_call_->GetVideoReceiveStreams()[0];
1414 EXPECT_TRUE(stream->GetConfig().rtp.remb); 1428 EXPECT_TRUE(stream->GetConfig().rtp.remb);
1415 } 1429 }
1416 1430
1417 TEST_F(WebRtcVideoChannel2Test, TransportCcCanBeEnabledAndDisabled) { 1431 TEST_F(WebRtcVideoChannel2Test, TransportCcCanBeEnabledAndDisabled) {
1418 FakeVideoReceiveStream* stream = AddRecvStream(); 1432 FakeVideoReceiveStream* stream = AddRecvStream();
1419 EXPECT_TRUE(stream->GetConfig().rtp.transport_cc); 1433 EXPECT_TRUE(stream->GetConfig().rtp.transport_cc);
1420 1434
1421 // Verify that transport cc feedback is turned off when send(!) codecs without 1435 // Verify that transport cc feedback is turned off when send(!) codecs without
1422 // transport cc feedback are set. 1436 // transport cc feedback are set.
1423 cricket::VideoSendParameters parameters; 1437 cricket::VideoSendParameters parameters;
1424 parameters.codecs.push_back(kVp8Codec); 1438 cricket::VideoCodec vp8_codec_without_feedback_params = GetEngineCodec("VP8");
1439 vp8_codec_without_feedback_params.feedback_params = cricket::FeedbackParams();
1440 parameters.codecs.push_back(vp8_codec_without_feedback_params);
1425 EXPECT_TRUE(parameters.codecs[0].feedback_params.params().empty()); 1441 EXPECT_TRUE(parameters.codecs[0].feedback_params.params().empty());
1426 EXPECT_TRUE(channel_->SetSendParameters(parameters)); 1442 EXPECT_TRUE(channel_->SetSendParameters(parameters));
1427 stream = fake_call_->GetVideoReceiveStreams()[0]; 1443 stream = fake_call_->GetVideoReceiveStreams()[0];
1428 EXPECT_FALSE(stream->GetConfig().rtp.transport_cc); 1444 EXPECT_FALSE(stream->GetConfig().rtp.transport_cc);
1429 1445
1430 // Verify that transport cc feedback is turned on when setting default codecs 1446 // Verify that transport cc feedback is turned on when setting default codecs
1431 // since the default codecs have transport cc feedback enabled. 1447 // since the default codecs have transport cc feedback enabled.
1432 parameters.codecs = engine_.codecs(); 1448 parameters.codecs = engine_.codecs();
1433 EXPECT_TRUE(channel_->SetSendParameters(parameters)); 1449 EXPECT_TRUE(channel_->SetSendParameters(parameters));
1434 stream = fake_call_->GetVideoReceiveStreams()[0]; 1450 stream = fake_call_->GetVideoReceiveStreams()[0];
(...skipping 25 matching lines...) Expand all
1460 1476
1461 TEST_F(WebRtcVideoChannel2Test, NackCanBeEnabledAndDisabled) { 1477 TEST_F(WebRtcVideoChannel2Test, NackCanBeEnabledAndDisabled) {
1462 FakeVideoSendStream* send_stream = AddSendStream(); 1478 FakeVideoSendStream* send_stream = AddSendStream();
1463 FakeVideoReceiveStream* recv_stream = AddRecvStream(); 1479 FakeVideoReceiveStream* recv_stream = AddRecvStream();
1464 1480
1465 EXPECT_GT(recv_stream->GetConfig().rtp.nack.rtp_history_ms, 0); 1481 EXPECT_GT(recv_stream->GetConfig().rtp.nack.rtp_history_ms, 0);
1466 EXPECT_GT(send_stream->GetConfig().rtp.nack.rtp_history_ms, 0); 1482 EXPECT_GT(send_stream->GetConfig().rtp.nack.rtp_history_ms, 0);
1467 1483
1468 // Verify that NACK is turned off when send(!) codecs without NACK are set. 1484 // Verify that NACK is turned off when send(!) codecs without NACK are set.
1469 cricket::VideoSendParameters parameters; 1485 cricket::VideoSendParameters parameters;
1470 parameters.codecs.push_back(kVp8Codec); 1486 cricket::VideoCodec vp8_codec_without_feedback_params = GetEngineCodec("VP8");
1487 vp8_codec_without_feedback_params.feedback_params = cricket::FeedbackParams();
1488 parameters.codecs.push_back(vp8_codec_without_feedback_params);
hta-webrtc 2016/11/15 11:34:59 That's three times for this 3-line code block. Tim
magjed_webrtc 2016/11/15 17:18:26 Yeah, probably. Done.
1471 EXPECT_TRUE(parameters.codecs[0].feedback_params.params().empty()); 1489 EXPECT_TRUE(parameters.codecs[0].feedback_params.params().empty());
1472 EXPECT_TRUE(channel_->SetSendParameters(parameters)); 1490 EXPECT_TRUE(channel_->SetSendParameters(parameters));
1473 recv_stream = fake_call_->GetVideoReceiveStreams()[0]; 1491 recv_stream = fake_call_->GetVideoReceiveStreams()[0];
1474 EXPECT_EQ(0, recv_stream->GetConfig().rtp.nack.rtp_history_ms); 1492 EXPECT_EQ(0, recv_stream->GetConfig().rtp.nack.rtp_history_ms);
1475 send_stream = fake_call_->GetVideoSendStreams()[0]; 1493 send_stream = fake_call_->GetVideoSendStreams()[0];
1476 EXPECT_EQ(0, send_stream->GetConfig().rtp.nack.rtp_history_ms); 1494 EXPECT_EQ(0, send_stream->GetConfig().rtp.nack.rtp_history_ms);
1477 1495
1478 // Verify that NACK is turned on when setting default codecs since the 1496 // Verify that NACK is turned on when setting default codecs since the
1479 // default codecs have NACK enabled. 1497 // default codecs have NACK enabled.
1480 parameters.codecs = engine_.codecs(); 1498 parameters.codecs = engine_.codecs();
1481 EXPECT_TRUE(channel_->SetSendParameters(parameters)); 1499 EXPECT_TRUE(channel_->SetSendParameters(parameters));
1482 recv_stream = fake_call_->GetVideoReceiveStreams()[0]; 1500 recv_stream = fake_call_->GetVideoReceiveStreams()[0];
1483 EXPECT_GT(recv_stream->GetConfig().rtp.nack.rtp_history_ms, 0); 1501 EXPECT_GT(recv_stream->GetConfig().rtp.nack.rtp_history_ms, 0);
1484 send_stream = fake_call_->GetVideoSendStreams()[0]; 1502 send_stream = fake_call_->GetVideoSendStreams()[0];
1485 EXPECT_GT(send_stream->GetConfig().rtp.nack.rtp_history_ms, 0); 1503 EXPECT_GT(send_stream->GetConfig().rtp.nack.rtp_history_ms, 0);
1486 } 1504 }
1487 1505
1488 // This test verifies that new frame sizes reconfigures encoders even though not 1506 // This test verifies that new frame sizes reconfigures encoders even though not
1489 // (yet) sending. The purpose of this is to permit encoding as quickly as 1507 // (yet) sending. The purpose of this is to permit encoding as quickly as
1490 // possible once we start sending. Likely the frames being input are from the 1508 // possible once we start sending. Likely the frames being input are from the
1491 // same source that will be sent later, which just means that we're ready 1509 // same source that will be sent later, which just means that we're ready
1492 // earlier. 1510 // earlier.
1493 TEST_F(WebRtcVideoChannel2Test, ReconfiguresEncodersWhenNotSending) { 1511 TEST_F(WebRtcVideoChannel2Test, ReconfiguresEncodersWhenNotSending) {
1494 cricket::VideoSendParameters parameters; 1512 cricket::VideoSendParameters parameters;
1495 parameters.codecs.push_back(kVp8Codec); 1513 parameters.codecs.push_back(GetEngineCodec("VP8"));
1496 ASSERT_TRUE(channel_->SetSendParameters(parameters)); 1514 ASSERT_TRUE(channel_->SetSendParameters(parameters));
1497 channel_->SetSend(false); 1515 channel_->SetSend(false);
1498 1516
1499 FakeVideoSendStream* stream = AddSendStream(); 1517 FakeVideoSendStream* stream = AddSendStream();
1500 1518
1501 // No frames entered. 1519 // No frames entered.
1502 std::vector<webrtc::VideoStream> streams = stream->GetVideoStreams(); 1520 std::vector<webrtc::VideoStream> streams = stream->GetVideoStreams();
1503 EXPECT_EQ(0u, streams[0].width); 1521 EXPECT_EQ(0u, streams[0].width);
1504 EXPECT_EQ(0u, streams[0].height); 1522 EXPECT_EQ(0u, streams[0].height);
1505 1523
1506 cricket::FakeVideoCapturer capturer; 1524 cricket::FakeVideoCapturer capturer;
1507 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, nullptr, &capturer)); 1525 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, nullptr, &capturer));
1508 VideoFormat capture_format = capturer.GetSupportedFormats()->front(); 1526 VideoFormat capture_format = capturer.GetSupportedFormats()->front();
1509 EXPECT_EQ(cricket::CS_RUNNING, capturer.Start(capture_format)); 1527 EXPECT_EQ(cricket::CS_RUNNING, capturer.Start(capture_format));
1510 EXPECT_TRUE(capturer.CaptureFrame()); 1528 EXPECT_TRUE(capturer.CaptureFrame());
1511 1529
1512 // Frame entered, should be reconfigured to new dimensions. 1530 // Frame entered, should be reconfigured to new dimensions.
1513 streams = stream->GetVideoStreams(); 1531 streams = stream->GetVideoStreams();
1514 EXPECT_EQ(capture_format.width, streams[0].width); 1532 EXPECT_EQ(capture_format.width, streams[0].width);
1515 EXPECT_EQ(capture_format.height, streams[0].height); 1533 EXPECT_EQ(capture_format.height, streams[0].height);
1516 1534
1517 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, nullptr, nullptr)); 1535 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, nullptr, nullptr));
1518 } 1536 }
1519 1537
1520 TEST_F(WebRtcVideoChannel2Test, UsesCorrectSettingsForScreencast) { 1538 TEST_F(WebRtcVideoChannel2Test, UsesCorrectSettingsForScreencast) {
1521 static const int kScreenshareMinBitrateKbps = 800; 1539 static const int kScreenshareMinBitrateKbps = 800;
1522 cricket::VideoCodec codec = kVp8Codec; 1540 cricket::VideoCodec codec = GetEngineCodec("VP8");
1523 cricket::VideoSendParameters parameters; 1541 cricket::VideoSendParameters parameters;
1524 parameters.codecs.push_back(codec); 1542 parameters.codecs.push_back(codec);
1525 EXPECT_TRUE(channel_->SetSendParameters(parameters)); 1543 EXPECT_TRUE(channel_->SetSendParameters(parameters));
1526 AddSendStream(); 1544 AddSendStream();
1527 1545
1528 cricket::FakeVideoCapturer capturer; 1546 cricket::FakeVideoCapturer capturer;
1529 VideoOptions min_bitrate_options; 1547 VideoOptions min_bitrate_options;
1530 min_bitrate_options.screencast_min_bitrate_kbps = 1548 min_bitrate_options.screencast_min_bitrate_kbps =
1531 rtc::Optional<int>(kScreenshareMinBitrateKbps); 1549 rtc::Optional<int>(kScreenshareMinBitrateKbps);
1532 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, &min_bitrate_options, 1550 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, &min_bitrate_options,
(...skipping 168 matching lines...) Expand 10 before | Expand all | Expand 10 after
1701 1719
1702 TEST_F(WebRtcVideoChannel2Test, Vp8DenoisingEnabledByDefault) { 1720 TEST_F(WebRtcVideoChannel2Test, Vp8DenoisingEnabledByDefault) {
1703 FakeVideoSendStream* stream = AddSendStream(); 1721 FakeVideoSendStream* stream = AddSendStream();
1704 webrtc::VideoCodecVP8 vp8_settings; 1722 webrtc::VideoCodecVP8 vp8_settings;
1705 ASSERT_TRUE(stream->GetVp8Settings(&vp8_settings)) << "No VP8 config set."; 1723 ASSERT_TRUE(stream->GetVp8Settings(&vp8_settings)) << "No VP8 config set.";
1706 EXPECT_TRUE(vp8_settings.denoisingOn); 1724 EXPECT_TRUE(vp8_settings.denoisingOn);
1707 } 1725 }
1708 1726
1709 TEST_F(WebRtcVideoChannel2Test, VerifyVp8SpecificSettings) { 1727 TEST_F(WebRtcVideoChannel2Test, VerifyVp8SpecificSettings) {
1710 cricket::VideoSendParameters parameters; 1728 cricket::VideoSendParameters parameters;
1711 parameters.codecs.push_back(kVp8Codec); 1729 parameters.codecs.push_back(GetEngineCodec("VP8"));
1712 ASSERT_TRUE(channel_->SetSendParameters(parameters)); 1730 ASSERT_TRUE(channel_->SetSendParameters(parameters));
1713 1731
1714 // Single-stream settings should apply with RTX as well (verifies that we 1732 // Single-stream settings should apply with RTX as well (verifies that we
1715 // check number of regular SSRCs and not StreamParams::ssrcs which contains 1733 // check number of regular SSRCs and not StreamParams::ssrcs which contains
1716 // both RTX and regular SSRCs). 1734 // both RTX and regular SSRCs).
1717 FakeVideoSendStream* stream = SetUpSimulcast(false, true); 1735 FakeVideoSendStream* stream = SetUpSimulcast(false, true);
1718 1736
1719 cricket::FakeVideoCapturer capturer; 1737 cricket::FakeVideoCapturer capturer;
1720 EXPECT_EQ(cricket::CS_RUNNING, 1738 EXPECT_EQ(cricket::CS_RUNNING,
1721 capturer.Start(capturer.GetSupportedFormats()->front())); 1739 capturer.Start(capturer.GetSupportedFormats()->front()));
(...skipping 60 matching lines...) Expand 10 before | Expand all | Expand 10 after
1782 // Test that setting the same options doesn't result in the encoder being 1800 // Test that setting the same options doesn't result in the encoder being
1783 // reconfigured. 1801 // reconfigured.
1784 TEST_F(WebRtcVideoChannel2Test, SetIdenticalOptionsDoesntReconfigureEncoder) { 1802 TEST_F(WebRtcVideoChannel2Test, SetIdenticalOptionsDoesntReconfigureEncoder) {
1785 VideoOptions options; 1803 VideoOptions options;
1786 cricket::FakeVideoCapturer capturer; 1804 cricket::FakeVideoCapturer capturer;
1787 1805
1788 AddSendStream(); 1806 AddSendStream();
1789 EXPECT_EQ(cricket::CS_RUNNING, 1807 EXPECT_EQ(cricket::CS_RUNNING,
1790 capturer.Start(capturer.GetSupportedFormats()->front())); 1808 capturer.Start(capturer.GetSupportedFormats()->front()));
1791 cricket::VideoSendParameters parameters; 1809 cricket::VideoSendParameters parameters;
1792 parameters.codecs.push_back(kVp8Codec); 1810 parameters.codecs.push_back(GetEngineCodec("VP8"));
1793 ASSERT_TRUE(channel_->SetSendParameters(parameters)); 1811 ASSERT_TRUE(channel_->SetSendParameters(parameters));
1794 FakeVideoSendStream* send_stream = fake_call_->GetVideoSendStreams().front(); 1812 FakeVideoSendStream* send_stream = fake_call_->GetVideoSendStreams().front();
1795 1813
1796 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, &options, &capturer)); 1814 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, &options, &capturer));
1797 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, &options, &capturer)); 1815 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, &options, &capturer));
1798 EXPECT_TRUE(capturer.CaptureFrame()); 1816 EXPECT_TRUE(capturer.CaptureFrame());
1799 // Expect 1 reconfigurations at this point from the initial configuration. 1817 // Expect 1 reconfigurations at this point from the initial configuration.
1800 EXPECT_EQ(1, send_stream->num_encoder_reconfigurations()); 1818 EXPECT_EQ(1, send_stream->num_encoder_reconfigurations());
1801 1819
1802 // Set the options one more time and expect no additional reconfigurations. 1820 // Set the options one more time and expect no additional reconfigurations.
(...skipping 28 matching lines...) Expand all
1831 // Remove references to encoder_factory_ since this will be destroyed 1849 // Remove references to encoder_factory_ since this will be destroyed
1832 // before channel_ and engine_. 1850 // before channel_ and engine_.
1833 ASSERT_TRUE(channel_->SetSendParameters(send_parameters_)); 1851 ASSERT_TRUE(channel_->SetSendParameters(send_parameters_));
1834 } 1852 }
1835 1853
1836 cricket::FakeWebRtcVideoEncoderFactory encoder_factory_; 1854 cricket::FakeWebRtcVideoEncoderFactory encoder_factory_;
1837 }; 1855 };
1838 1856
1839 TEST_F(Vp9SettingsTest, VerifyVp9SpecificSettings) { 1857 TEST_F(Vp9SettingsTest, VerifyVp9SpecificSettings) {
1840 cricket::VideoSendParameters parameters; 1858 cricket::VideoSendParameters parameters;
1841 parameters.codecs.push_back(kVp9Codec); 1859 parameters.codecs.push_back(GetEngineCodec("VP9"));
1842 ASSERT_TRUE(channel_->SetSendParameters(parameters)); 1860 ASSERT_TRUE(channel_->SetSendParameters(parameters));
1843 1861
1844 FakeVideoSendStream* stream = SetUpSimulcast(false, false); 1862 FakeVideoSendStream* stream = SetUpSimulcast(false, false);
1845 1863
1846 cricket::FakeVideoCapturer capturer; 1864 cricket::FakeVideoCapturer capturer;
1847 EXPECT_EQ(cricket::CS_RUNNING, 1865 EXPECT_EQ(cricket::CS_RUNNING,
1848 capturer.Start(capturer.GetSupportedFormats()->front())); 1866 capturer.Start(capturer.GetSupportedFormats()->front()));
1849 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, nullptr, &capturer)); 1867 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, nullptr, &capturer));
1850 channel_->SetSend(true); 1868 channel_->SetSend(true);
1851 1869
(...skipping 39 matching lines...) Expand 10 before | Expand all | Expand 10 after
1891 } 1909 }
1892 1910
1893 class Vp9SettingsTestWithFieldTrial : public Vp9SettingsTest { 1911 class Vp9SettingsTestWithFieldTrial : public Vp9SettingsTest {
1894 public: 1912 public:
1895 Vp9SettingsTestWithFieldTrial(const char* field_trials) 1913 Vp9SettingsTestWithFieldTrial(const char* field_trials)
1896 : Vp9SettingsTest(field_trials) {} 1914 : Vp9SettingsTest(field_trials) {}
1897 1915
1898 protected: 1916 protected:
1899 void VerifySettings(int num_spatial_layers, int num_temporal_layers) { 1917 void VerifySettings(int num_spatial_layers, int num_temporal_layers) {
1900 cricket::VideoSendParameters parameters; 1918 cricket::VideoSendParameters parameters;
1901 parameters.codecs.push_back(kVp9Codec); 1919 parameters.codecs.push_back(GetEngineCodec("VP9"));
1902 ASSERT_TRUE(channel_->SetSendParameters(parameters)); 1920 ASSERT_TRUE(channel_->SetSendParameters(parameters));
1903 1921
1904 FakeVideoSendStream* stream = SetUpSimulcast(false, false); 1922 FakeVideoSendStream* stream = SetUpSimulcast(false, false);
1905 1923
1906 cricket::FakeVideoCapturer capturer; 1924 cricket::FakeVideoCapturer capturer;
1907 EXPECT_EQ(cricket::CS_RUNNING, 1925 EXPECT_EQ(cricket::CS_RUNNING,
1908 capturer.Start(capturer.GetSupportedFormats()->front())); 1926 capturer.Start(capturer.GetSupportedFormats()->front()));
1909 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, nullptr, &capturer)); 1927 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, nullptr, &capturer));
1910 channel_->SetSend(true); 1928 channel_->SetSend(true);
1911 1929
(...skipping 50 matching lines...) Expand 10 before | Expand all | Expand 10 after
1962 1980
1963 TEST_F(WebRtcVideoChannel2Test, DoesNotAdaptOnOveruseWhenDisabled) { 1981 TEST_F(WebRtcVideoChannel2Test, DoesNotAdaptOnOveruseWhenDisabled) {
1964 TestCpuAdaptation(false, false); 1982 TestCpuAdaptation(false, false);
1965 } 1983 }
1966 1984
1967 TEST_F(WebRtcVideoChannel2Test, DoesNotAdaptOnOveruseWhenScreensharing) { 1985 TEST_F(WebRtcVideoChannel2Test, DoesNotAdaptOnOveruseWhenScreensharing) {
1968 TestCpuAdaptation(true, true); 1986 TestCpuAdaptation(true, true);
1969 } 1987 }
1970 1988
1971 TEST_F(WebRtcVideoChannel2Test, AdaptsOnOveruseAndChangeResolution) { 1989 TEST_F(WebRtcVideoChannel2Test, AdaptsOnOveruseAndChangeResolution) {
1972 cricket::VideoCodec codec = kVp8Codec; 1990 cricket::VideoCodec codec = GetEngineCodec("VP8");
1973 cricket::VideoSendParameters parameters; 1991 cricket::VideoSendParameters parameters;
1974 parameters.codecs.push_back(codec); 1992 parameters.codecs.push_back(codec);
1975 1993
1976 MediaConfig media_config = MediaConfig(); 1994 MediaConfig media_config = MediaConfig();
1977 channel_.reset( 1995 channel_.reset(
1978 engine_.CreateChannel(fake_call_.get(), media_config, VideoOptions())); 1996 engine_.CreateChannel(fake_call_.get(), media_config, VideoOptions()));
1979 ASSERT_TRUE(channel_->SetSendParameters(parameters)); 1997 ASSERT_TRUE(channel_->SetSendParameters(parameters));
1980 1998
1981 AddSendStream(); 1999 AddSendStream();
1982 2000
(...skipping 53 matching lines...) Expand 10 before | Expand all | Expand 10 after
2036 send_stream->InjectVideoSinkWants(wants); 2054 send_stream->InjectVideoSinkWants(wants);
2037 EXPECT_TRUE(capturer.CaptureCustomFrame(1284, 724, cricket::FOURCC_I420)); 2055 EXPECT_TRUE(capturer.CaptureCustomFrame(1284, 724, cricket::FOURCC_I420));
2038 EXPECT_EQ(6, send_stream->GetNumberOfSwappedFrames()); 2056 EXPECT_EQ(6, send_stream->GetNumberOfSwappedFrames());
2039 EXPECT_EQ(1284, send_stream->GetLastWidth()); 2057 EXPECT_EQ(1284, send_stream->GetLastWidth());
2040 EXPECT_EQ(724, send_stream->GetLastHeight()); 2058 EXPECT_EQ(724, send_stream->GetLastHeight());
2041 2059
2042 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, nullptr, nullptr)); 2060 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, nullptr, nullptr));
2043 } 2061 }
2044 2062
2045 TEST_F(WebRtcVideoChannel2Test, PreviousAdaptationDoesNotApplyToScreenshare) { 2063 TEST_F(WebRtcVideoChannel2Test, PreviousAdaptationDoesNotApplyToScreenshare) {
2046 cricket::VideoCodec codec = kVp8Codec; 2064 cricket::VideoCodec codec = GetEngineCodec("VP8");
2047 cricket::VideoSendParameters parameters; 2065 cricket::VideoSendParameters parameters;
2048 parameters.codecs.push_back(codec); 2066 parameters.codecs.push_back(codec);
2049 2067
2050 MediaConfig media_config = MediaConfig(); 2068 MediaConfig media_config = MediaConfig();
2051 channel_.reset( 2069 channel_.reset(
2052 engine_.CreateChannel(fake_call_.get(), media_config, VideoOptions())); 2070 engine_.CreateChannel(fake_call_.get(), media_config, VideoOptions()));
2053 ASSERT_TRUE(channel_->SetSendParameters(parameters)); 2071 ASSERT_TRUE(channel_->SetSendParameters(parameters));
2054 2072
2055 AddSendStream(); 2073 AddSendStream();
2056 2074
(...skipping 43 matching lines...) Expand 10 before | Expand all | Expand 10 after
2100 EXPECT_TRUE(capturer.CaptureCustomFrame(1280, 720, cricket::FOURCC_I420)); 2118 EXPECT_TRUE(capturer.CaptureCustomFrame(1280, 720, cricket::FOURCC_I420));
2101 EXPECT_EQ(4, send_stream->GetNumberOfSwappedFrames()); 2119 EXPECT_EQ(4, send_stream->GetNumberOfSwappedFrames());
2102 EXPECT_EQ(1280 * 3 / 4, send_stream->GetLastWidth()); 2120 EXPECT_EQ(1280 * 3 / 4, send_stream->GetLastWidth());
2103 EXPECT_EQ(720 * 3 / 4, send_stream->GetLastHeight()); 2121 EXPECT_EQ(720 * 3 / 4, send_stream->GetLastHeight());
2104 2122
2105 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, nullptr, nullptr)); 2123 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, nullptr, nullptr));
2106 } 2124 }
2107 2125
2108 void WebRtcVideoChannel2Test::TestCpuAdaptation(bool enable_overuse, 2126 void WebRtcVideoChannel2Test::TestCpuAdaptation(bool enable_overuse,
2109 bool is_screenshare) { 2127 bool is_screenshare) {
2110 cricket::VideoCodec codec = kVp8Codec; 2128 cricket::VideoCodec codec = GetEngineCodec("VP8");
2111 cricket::VideoSendParameters parameters; 2129 cricket::VideoSendParameters parameters;
2112 parameters.codecs.push_back(codec); 2130 parameters.codecs.push_back(codec);
2113 2131
2114 MediaConfig media_config = MediaConfig(); 2132 MediaConfig media_config = MediaConfig();
2115 if (!enable_overuse) { 2133 if (!enable_overuse) {
2116 media_config.video.enable_cpu_overuse_detection = false; 2134 media_config.video.enable_cpu_overuse_detection = false;
2117 } 2135 }
2118 channel_.reset( 2136 channel_.reset(
2119 engine_.CreateChannel(fake_call_.get(), media_config, VideoOptions())); 2137 engine_.CreateChannel(fake_call_.get(), media_config, VideoOptions()));
2120 2138
(...skipping 103 matching lines...) Expand 10 before | Expand all | Expand 10 after
2224 2242
2225 // Using a RTX setup to verify that the default RTX payload type is good. 2243 // Using a RTX setup to verify that the default RTX payload type is good.
2226 const std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs1); 2244 const std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs1);
2227 const std::vector<uint32_t> rtx_ssrcs = MAKE_VECTOR(kRtxSsrcs1); 2245 const std::vector<uint32_t> rtx_ssrcs = MAKE_VECTOR(kRtxSsrcs1);
2228 FakeVideoSendStream* stream = AddSendStream( 2246 FakeVideoSendStream* stream = AddSendStream(
2229 cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs)); 2247 cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs));
2230 webrtc::VideoSendStream::Config config = stream->GetConfig().Copy(); 2248 webrtc::VideoSendStream::Config config = stream->GetConfig().Copy();
2231 2249
2232 // Make sure NACK and FEC are enabled on the correct payload types. 2250 // Make sure NACK and FEC are enabled on the correct payload types.
2233 EXPECT_EQ(1000, config.rtp.nack.rtp_history_ms); 2251 EXPECT_EQ(1000, config.rtp.nack.rtp_history_ms);
2234 EXPECT_EQ(default_ulpfec_codec_.id, config.rtp.ulpfec.ulpfec_payload_type); 2252 EXPECT_EQ(GetEngineCodec("ulpfec").id, config.rtp.ulpfec.ulpfec_payload_type);
2235 EXPECT_EQ(default_red_codec_.id, config.rtp.ulpfec.red_payload_type); 2253 EXPECT_EQ(GetEngineCodec("red").id, config.rtp.ulpfec.red_payload_type);
2236 2254
2237 EXPECT_EQ(1u, config.rtp.rtx.ssrcs.size()); 2255 EXPECT_EQ(1u, config.rtp.rtx.ssrcs.size());
2238 EXPECT_EQ(kRtxSsrcs1[0], config.rtp.rtx.ssrcs[0]); 2256 EXPECT_EQ(kRtxSsrcs1[0], config.rtp.rtx.ssrcs[0]);
2239 VerifySendStreamHasRtxTypes(config, default_apt_rtx_types_); 2257 VerifySendStreamHasRtxTypes(config, default_apt_rtx_types_);
2240 // TODO(juberti): Check RTCP, PLI, TMMBR. 2258 // TODO(juberti): Check RTCP, PLI, TMMBR.
2241 } 2259 }
2242 2260
2243 TEST_F(WebRtcVideoChannel2Test, SetSendCodecsWithoutFec) { 2261 TEST_F(WebRtcVideoChannel2Test, SetSendCodecsWithoutFec) {
2244 cricket::VideoSendParameters parameters; 2262 cricket::VideoSendParameters parameters;
2245 parameters.codecs.push_back(kVp8Codec); 2263 parameters.codecs.push_back(GetEngineCodec("VP8"));
2246 ASSERT_TRUE(channel_->SetSendParameters(parameters)); 2264 ASSERT_TRUE(channel_->SetSendParameters(parameters));
2247 2265
2248 FakeVideoSendStream* stream = AddSendStream(); 2266 FakeVideoSendStream* stream = AddSendStream();
2249 webrtc::VideoSendStream::Config config = stream->GetConfig().Copy(); 2267 webrtc::VideoSendStream::Config config = stream->GetConfig().Copy();
2250 2268
2251 EXPECT_EQ(-1, config.rtp.ulpfec.ulpfec_payload_type); 2269 EXPECT_EQ(-1, config.rtp.ulpfec.ulpfec_payload_type);
2252 EXPECT_EQ(-1, config.rtp.ulpfec.red_payload_type); 2270 EXPECT_EQ(-1, config.rtp.ulpfec.red_payload_type);
2253 } 2271 }
2254 2272
2255 TEST_F(WebRtcVideoChannel2Test, 2273 TEST_F(WebRtcVideoChannel2Test,
2256 SetSendCodecRejectsRtxWithoutAssociatedPayloadType) { 2274 SetSendCodecRejectsRtxWithoutAssociatedPayloadType) {
2275 const int kUnusedPayloadType = 127;
2276 EXPECT_FALSE(FindCodecById(engine_.codecs(), kUnusedPayloadType));
2277
2257 cricket::VideoSendParameters parameters; 2278 cricket::VideoSendParameters parameters;
2258 cricket::VideoCodec rtx_codec(96, "rtx"); 2279 cricket::VideoCodec rtx_codec(kUnusedPayloadType, "rtx");
2259 parameters.codecs.push_back(rtx_codec); 2280 parameters.codecs.push_back(rtx_codec);
2260 EXPECT_FALSE(channel_->SetSendParameters(parameters)) 2281 EXPECT_FALSE(channel_->SetSendParameters(parameters))
2261 << "RTX codec without associated payload type should be rejected."; 2282 << "RTX codec without associated payload type should be rejected.";
2262 } 2283 }
2263 2284
2264 TEST_F(WebRtcVideoChannel2Test, 2285 TEST_F(WebRtcVideoChannel2Test,
2265 SetSendCodecRejectsRtxWithoutMatchingVideoCodec) { 2286 SetSendCodecRejectsRtxWithoutMatchingVideoCodec) {
2266 cricket::VideoSendParameters parameters; 2287 const int kUnusedPayloadType1 = 126;
2267 cricket::VideoCodec rtx_codec = 2288 const int kUnusedPayloadType2 = 127;
2268 cricket::VideoCodec::CreateRtxCodec(96, kVp8Codec.id); 2289 EXPECT_FALSE(FindCodecById(engine_.codecs(), kUnusedPayloadType1));
2269 parameters.codecs.push_back(kVp8Codec); 2290 EXPECT_FALSE(FindCodecById(engine_.codecs(), kUnusedPayloadType2));
2270 parameters.codecs.push_back(rtx_codec); 2291 {
2271 ASSERT_TRUE(channel_->SetSendParameters(parameters)); 2292 cricket::VideoCodec rtx_codec = cricket::VideoCodec::CreateRtxCodec(
2272 2293 kUnusedPayloadType1, GetEngineCodec("VP8").id);
2273 cricket::VideoCodec rtx_codec2 = 2294 cricket::VideoSendParameters parameters;
2274 cricket::VideoCodec::CreateRtxCodec(96, kVp8Codec.id + 1); 2295 parameters.codecs.push_back(GetEngineCodec("VP8"));
2275 parameters.codecs.pop_back(); 2296 parameters.codecs.push_back(rtx_codec);
2276 parameters.codecs.push_back(rtx_codec2); 2297 ASSERT_TRUE(channel_->SetSendParameters(parameters));
2277 EXPECT_FALSE(channel_->SetSendParameters(parameters)) 2298 }
2278 << "RTX without matching video codec should be rejected."; 2299 {
2300 cricket::VideoCodec rtx_codec = cricket::VideoCodec::CreateRtxCodec(
2301 kUnusedPayloadType1, kUnusedPayloadType2);
2302 cricket::VideoSendParameters parameters;
2303 parameters.codecs.push_back(GetEngineCodec("VP8"));
2304 parameters.codecs.push_back(rtx_codec);
2305 EXPECT_FALSE(channel_->SetSendParameters(parameters))
2306 << "RTX without matching video codec should be rejected.";
2307 }
2279 } 2308 }
2280 2309
2281 TEST_F(WebRtcVideoChannel2Test, SetSendCodecsWithoutFecDisablesFec) { 2310 TEST_F(WebRtcVideoChannel2Test, SetSendCodecsWithoutFecDisablesFec) {
2282 cricket::VideoSendParameters parameters; 2311 cricket::VideoSendParameters parameters;
2283 parameters.codecs.push_back(kVp8Codec); 2312 parameters.codecs.push_back(GetEngineCodec("VP8"));
2284 parameters.codecs.push_back(kUlpfecCodec); 2313 parameters.codecs.push_back(GetEngineCodec("ulpfec"));
2285 ASSERT_TRUE(channel_->SetSendParameters(parameters)); 2314 ASSERT_TRUE(channel_->SetSendParameters(parameters));
2286 2315
2287 FakeVideoSendStream* stream = AddSendStream(); 2316 FakeVideoSendStream* stream = AddSendStream();
2288 webrtc::VideoSendStream::Config config = stream->GetConfig().Copy(); 2317 webrtc::VideoSendStream::Config config = stream->GetConfig().Copy();
2289 2318
2290 EXPECT_EQ(kUlpfecCodec.id, config.rtp.ulpfec.ulpfec_payload_type); 2319 EXPECT_EQ(GetEngineCodec("ulpfec").id, config.rtp.ulpfec.ulpfec_payload_type);
2291 2320
2292 parameters.codecs.pop_back(); 2321 parameters.codecs.pop_back();
2293 ASSERT_TRUE(channel_->SetSendParameters(parameters)); 2322 ASSERT_TRUE(channel_->SetSendParameters(parameters));
2294 stream = fake_call_->GetVideoSendStreams()[0]; 2323 stream = fake_call_->GetVideoSendStreams()[0];
2295 ASSERT_TRUE(stream != NULL); 2324 ASSERT_TRUE(stream != NULL);
2296 config = stream->GetConfig().Copy(); 2325 config = stream->GetConfig().Copy();
2297 EXPECT_EQ(-1, config.rtp.ulpfec.ulpfec_payload_type) 2326 EXPECT_EQ(-1, config.rtp.ulpfec.ulpfec_payload_type)
2298 << "SetSendCodec without FEC should disable current FEC."; 2327 << "SetSendCodec without FEC should disable current FEC.";
2299 } 2328 }
2300 2329
(...skipping 124 matching lines...) Expand 10 before | Expand all | Expand 10 after
2425 send_parameters_.max_bandwidth_bps = 77777; 2454 send_parameters_.max_bandwidth_bps = 77777;
2426 ASSERT_TRUE(channel_->SetSendParameters(send_parameters_)); 2455 ASSERT_TRUE(channel_->SetSendParameters(send_parameters_));
2427 EXPECT_EQ(send_parameters_.max_bandwidth_bps, 2456 EXPECT_EQ(send_parameters_.max_bandwidth_bps,
2428 fake_call_->GetConfig().bitrate_config.max_bitrate_bps); 2457 fake_call_->GetConfig().bitrate_config.max_bitrate_bps);
2429 EXPECT_EQ(send_parameters_.max_bandwidth_bps, 2458 EXPECT_EQ(send_parameters_.max_bandwidth_bps,
2430 stream->GetVideoStreams()[0].max_bitrate_bps); 2459 stream->GetVideoStreams()[0].max_bitrate_bps);
2431 } 2460 }
2432 2461
2433 TEST_F(WebRtcVideoChannel2Test, SetMaxSendBitrateCanIncreaseSenderBitrate) { 2462 TEST_F(WebRtcVideoChannel2Test, SetMaxSendBitrateCanIncreaseSenderBitrate) {
2434 cricket::VideoSendParameters parameters; 2463 cricket::VideoSendParameters parameters;
2435 parameters.codecs.push_back(kVp8Codec); 2464 parameters.codecs.push_back(GetEngineCodec("VP8"));
2436 ASSERT_TRUE(channel_->SetSendParameters(parameters)); 2465 ASSERT_TRUE(channel_->SetSendParameters(parameters));
2437 channel_->SetSend(true); 2466 channel_->SetSend(true);
2438 2467
2439 FakeVideoSendStream* stream = AddSendStream(); 2468 FakeVideoSendStream* stream = AddSendStream();
2440 2469
2441 cricket::FakeVideoCapturer capturer; 2470 cricket::FakeVideoCapturer capturer;
2442 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, nullptr, &capturer)); 2471 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, nullptr, &capturer));
2443 EXPECT_EQ(cricket::CS_RUNNING, 2472 EXPECT_EQ(cricket::CS_RUNNING,
2444 capturer.Start(capturer.GetSupportedFormats()->front())); 2473 capturer.Start(capturer.GetSupportedFormats()->front()));
2445 2474
2446 std::vector<webrtc::VideoStream> streams = stream->GetVideoStreams(); 2475 std::vector<webrtc::VideoStream> streams = stream->GetVideoStreams();
2447 int initial_max_bitrate_bps = streams[0].max_bitrate_bps; 2476 int initial_max_bitrate_bps = streams[0].max_bitrate_bps;
2448 EXPECT_GT(initial_max_bitrate_bps, 0); 2477 EXPECT_GT(initial_max_bitrate_bps, 0);
2449 2478
2450 parameters.max_bandwidth_bps = initial_max_bitrate_bps * 2; 2479 parameters.max_bandwidth_bps = initial_max_bitrate_bps * 2;
2451 EXPECT_TRUE(channel_->SetSendParameters(parameters)); 2480 EXPECT_TRUE(channel_->SetSendParameters(parameters));
2452 // Insert a frame to update the encoder config. 2481 // Insert a frame to update the encoder config.
2453 EXPECT_TRUE(capturer.CaptureFrame()); 2482 EXPECT_TRUE(capturer.CaptureFrame());
2454 streams = stream->GetVideoStreams(); 2483 streams = stream->GetVideoStreams();
2455 EXPECT_EQ(initial_max_bitrate_bps * 2, streams[0].max_bitrate_bps); 2484 EXPECT_EQ(initial_max_bitrate_bps * 2, streams[0].max_bitrate_bps);
2456 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, nullptr, nullptr)); 2485 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, nullptr, nullptr));
2457 } 2486 }
2458 2487
2459 TEST_F(WebRtcVideoChannel2Test, 2488 TEST_F(WebRtcVideoChannel2Test,
2460 SetMaxSendBitrateCanIncreaseSimulcastSenderBitrate) { 2489 SetMaxSendBitrateCanIncreaseSimulcastSenderBitrate) {
2461 cricket::VideoSendParameters parameters; 2490 cricket::VideoSendParameters parameters;
2462 parameters.codecs.push_back(kVp8Codec); 2491 parameters.codecs.push_back(GetEngineCodec("VP8"));
2463 ASSERT_TRUE(channel_->SetSendParameters(parameters)); 2492 ASSERT_TRUE(channel_->SetSendParameters(parameters));
2464 channel_->SetSend(true); 2493 channel_->SetSend(true);
2465 2494
2466 FakeVideoSendStream* stream = AddSendStream( 2495 FakeVideoSendStream* stream = AddSendStream(
2467 cricket::CreateSimStreamParams("cname", MAKE_VECTOR(kSsrcs3))); 2496 cricket::CreateSimStreamParams("cname", MAKE_VECTOR(kSsrcs3)));
2468 2497
2469 // Send a frame to make sure this scales up to >1 stream (simulcast). 2498 // Send a frame to make sure this scales up to >1 stream (simulcast).
2470 cricket::FakeVideoCapturer capturer; 2499 cricket::FakeVideoCapturer capturer;
2471 EXPECT_TRUE(channel_->SetVideoSend(kSsrcs3[0], true, nullptr, &capturer)); 2500 EXPECT_TRUE(channel_->SetVideoSend(kSsrcs3[0], true, nullptr, &capturer));
2472 EXPECT_EQ(cricket::CS_RUNNING, 2501 EXPECT_EQ(cricket::CS_RUNNING,
(...skipping 13 matching lines...) Expand all
2486 streams = stream->GetVideoStreams(); 2515 streams = stream->GetVideoStreams();
2487 int increased_max_bitrate_bps = GetTotalMaxBitrateBps(streams); 2516 int increased_max_bitrate_bps = GetTotalMaxBitrateBps(streams);
2488 EXPECT_EQ(initial_max_bitrate_bps * 2, increased_max_bitrate_bps); 2517 EXPECT_EQ(initial_max_bitrate_bps * 2, increased_max_bitrate_bps);
2489 2518
2490 EXPECT_TRUE(channel_->SetVideoSend(kSsrcs3[0], true, nullptr, nullptr)); 2519 EXPECT_TRUE(channel_->SetVideoSend(kSsrcs3[0], true, nullptr, nullptr));
2491 } 2520 }
2492 2521
2493 TEST_F(WebRtcVideoChannel2Test, SetSendCodecsWithMaxQuantization) { 2522 TEST_F(WebRtcVideoChannel2Test, SetSendCodecsWithMaxQuantization) {
2494 static const char* kMaxQuantization = "21"; 2523 static const char* kMaxQuantization = "21";
2495 cricket::VideoSendParameters parameters; 2524 cricket::VideoSendParameters parameters;
2496 parameters.codecs.push_back(kVp8Codec); 2525 parameters.codecs.push_back(GetEngineCodec("VP8"));
2497 parameters.codecs[0].params[kCodecParamMaxQuantization] = kMaxQuantization; 2526 parameters.codecs[0].params[kCodecParamMaxQuantization] = kMaxQuantization;
2498 EXPECT_TRUE(channel_->SetSendParameters(parameters)); 2527 EXPECT_TRUE(channel_->SetSendParameters(parameters));
2499 EXPECT_EQ(static_cast<unsigned int>(atoi(kMaxQuantization)), 2528 EXPECT_EQ(static_cast<unsigned int>(atoi(kMaxQuantization)),
2500 AddSendStream()->GetVideoStreams().back().max_qp); 2529 AddSendStream()->GetVideoStreams().back().max_qp);
2501 2530
2502 VideoCodec codec; 2531 VideoCodec codec;
2503 EXPECT_TRUE(channel_->GetSendCodec(&codec)); 2532 EXPECT_TRUE(channel_->GetSendCodec(&codec));
2504 EXPECT_EQ(kMaxQuantization, codec.params[kCodecParamMaxQuantization]); 2533 EXPECT_EQ(kMaxQuantization, codec.params[kCodecParamMaxQuantization]);
2505 } 2534 }
2506 2535
2507 TEST_F(WebRtcVideoChannel2Test, SetSendCodecsRejectBadPayloadTypes) { 2536 TEST_F(WebRtcVideoChannel2Test, SetSendCodecsRejectBadPayloadTypes) {
2508 // TODO(pbos): Should we only allow the dynamic range? 2537 // TODO(pbos): Should we only allow the dynamic range?
2509 static const int kIncorrectPayloads[] = {-2, -1, 128, 129}; 2538 static const int kIncorrectPayloads[] = {-2, -1, 128, 129};
2510 cricket::VideoSendParameters parameters; 2539 cricket::VideoSendParameters parameters;
2511 parameters.codecs.push_back(kVp8Codec); 2540 parameters.codecs.push_back(GetEngineCodec("VP8"));
2512 for (size_t i = 0; i < arraysize(kIncorrectPayloads); ++i) { 2541 for (size_t i = 0; i < arraysize(kIncorrectPayloads); ++i) {
2513 parameters.codecs[0].id = kIncorrectPayloads[i]; 2542 parameters.codecs[0].id = kIncorrectPayloads[i];
2514 EXPECT_FALSE(channel_->SetSendParameters(parameters)) 2543 EXPECT_FALSE(channel_->SetSendParameters(parameters))
2515 << "Bad payload type '" << kIncorrectPayloads[i] << "' accepted."; 2544 << "Bad payload type '" << kIncorrectPayloads[i] << "' accepted.";
2516 } 2545 }
2517 } 2546 }
2518 2547
2519 TEST_F(WebRtcVideoChannel2Test, SetSendCodecsAcceptAllValidPayloadTypes) { 2548 TEST_F(WebRtcVideoChannel2Test, SetSendCodecsAcceptAllValidPayloadTypes) {
2520 cricket::VideoSendParameters parameters; 2549 cricket::VideoSendParameters parameters;
2521 parameters.codecs.push_back(kVp8Codec); 2550 parameters.codecs.push_back(GetEngineCodec("VP8"));
2522 // Only the dynamic payload types are valid for video codecs.
2523 for (int payload_type = 96; payload_type <= 127; ++payload_type) { 2551 for (int payload_type = 96; payload_type <= 127; ++payload_type) {
2524 parameters.codecs[0].id = payload_type; 2552 parameters.codecs[0].id = payload_type;
2525 EXPECT_TRUE(channel_->SetSendParameters(parameters)) 2553 EXPECT_TRUE(channel_->SetSendParameters(parameters))
2526 << "Payload type '" << payload_type << "' rejected."; 2554 << "Payload type '" << payload_type << "' rejected.";
2527 } 2555 }
2528 } 2556 }
2529 2557
2530 // Test that setting the a different set of codecs but with an identical front 2558 // Test that setting the a different set of codecs but with an identical front
2531 // codec doesn't result in the stream being recreated. 2559 // codec doesn't result in the stream being recreated.
2532 // This may happen when a subsequent negotiation includes fewer codecs, as a 2560 // This may happen when a subsequent negotiation includes fewer codecs, as a
2533 // result of one of the codecs being rejected. 2561 // result of one of the codecs being rejected.
2534 TEST_F(WebRtcVideoChannel2Test, 2562 TEST_F(WebRtcVideoChannel2Test,
2535 SetSendCodecsIdenticalFirstCodecDoesntRecreateStream) { 2563 SetSendCodecsIdenticalFirstCodecDoesntRecreateStream) {
2536 cricket::VideoSendParameters parameters1; 2564 cricket::VideoSendParameters parameters1;
2537 parameters1.codecs.push_back(kVp8Codec); 2565 parameters1.codecs.push_back(GetEngineCodec("VP8"));
2538 parameters1.codecs.push_back(kVp9Codec); 2566 parameters1.codecs.push_back(GetEngineCodec("VP9"));
2539 EXPECT_TRUE(channel_->SetSendParameters(parameters1)); 2567 EXPECT_TRUE(channel_->SetSendParameters(parameters1));
2540 2568
2541 AddSendStream(); 2569 AddSendStream();
2542 EXPECT_EQ(1, fake_call_->GetNumCreatedSendStreams()); 2570 EXPECT_EQ(1, fake_call_->GetNumCreatedSendStreams());
2543 2571
2544 cricket::VideoSendParameters parameters2; 2572 cricket::VideoSendParameters parameters2;
2545 parameters2.codecs.push_back(kVp8Codec); 2573 parameters2.codecs.push_back(GetEngineCodec("VP8"));
2546 EXPECT_TRUE(channel_->SetSendParameters(parameters2)); 2574 EXPECT_TRUE(channel_->SetSendParameters(parameters2));
2547 EXPECT_EQ(1, fake_call_->GetNumCreatedSendStreams()); 2575 EXPECT_EQ(1, fake_call_->GetNumCreatedSendStreams());
2548 } 2576 }
2549 2577
2550 TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsWithOnlyVp8) { 2578 TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsWithOnlyVp8) {
2551 cricket::VideoRecvParameters parameters; 2579 cricket::VideoRecvParameters parameters;
2552 parameters.codecs.push_back(kVp8Codec); 2580 parameters.codecs.push_back(GetEngineCodec("VP8"));
2553 EXPECT_TRUE(channel_->SetRecvParameters(parameters)); 2581 EXPECT_TRUE(channel_->SetRecvParameters(parameters));
2554 } 2582 }
2555 2583
2556 // Test that we set our inbound RTX codecs properly. 2584 // Test that we set our inbound RTX codecs properly.
2557 TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsWithRtx) { 2585 TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsWithRtx) {
2586 const int kUnusedPayloadType1 = 126;
2587 const int kUnusedPayloadType2 = 127;
2588 EXPECT_FALSE(FindCodecById(engine_.codecs(), kUnusedPayloadType1));
2589 EXPECT_FALSE(FindCodecById(engine_.codecs(), kUnusedPayloadType2));
2590
2558 cricket::VideoRecvParameters parameters; 2591 cricket::VideoRecvParameters parameters;
2559 parameters.codecs.push_back(kVp8Codec); 2592 parameters.codecs.push_back(GetEngineCodec("VP8"));
2560 cricket::VideoCodec rtx_codec(96, "rtx"); 2593 cricket::VideoCodec rtx_codec(kUnusedPayloadType1, "rtx");
2561 parameters.codecs.push_back(rtx_codec); 2594 parameters.codecs.push_back(rtx_codec);
2562 EXPECT_FALSE(channel_->SetRecvParameters(parameters)) 2595 EXPECT_FALSE(channel_->SetRecvParameters(parameters))
2563 << "RTX codec without associated payload should be rejected."; 2596 << "RTX codec without associated payload should be rejected.";
2564 2597
2565 parameters.codecs[1].SetParam("apt", kVp8Codec.id + 1); 2598 parameters.codecs[1].SetParam("apt", kUnusedPayloadType2);
2566 EXPECT_FALSE(channel_->SetRecvParameters(parameters)) 2599 EXPECT_FALSE(channel_->SetRecvParameters(parameters))
2567 << "RTX codec with invalid associated payload type should be rejected."; 2600 << "RTX codec with invalid associated payload type should be rejected.";
2568 2601
2569 parameters.codecs[1].SetParam("apt", kVp8Codec.id); 2602 parameters.codecs[1].SetParam("apt", GetEngineCodec("VP8").id);
2570 EXPECT_TRUE(channel_->SetRecvParameters(parameters)); 2603 EXPECT_TRUE(channel_->SetRecvParameters(parameters));
2571 2604
2572 cricket::VideoCodec rtx_codec2(97, "rtx"); 2605 cricket::VideoCodec rtx_codec2(kUnusedPayloadType2, "rtx");
2573 rtx_codec2.SetParam("apt", rtx_codec.id); 2606 rtx_codec2.SetParam("apt", rtx_codec.id);
2574 parameters.codecs.push_back(rtx_codec2); 2607 parameters.codecs.push_back(rtx_codec2);
2575 2608
2576 EXPECT_FALSE(channel_->SetRecvParameters(parameters)) << 2609 EXPECT_FALSE(channel_->SetRecvParameters(parameters)) <<
2577 "RTX codec with another RTX as associated payload type should be " 2610 "RTX codec with another RTX as associated payload type should be "
2578 "rejected."; 2611 "rejected.";
2579 } 2612 }
2580 2613
2581 TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsDifferentPayloadType) { 2614 TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsDifferentPayloadType) {
2582 cricket::VideoRecvParameters parameters; 2615 cricket::VideoRecvParameters parameters;
2583 parameters.codecs.push_back(kVp8Codec); 2616 parameters.codecs.push_back(GetEngineCodec("VP8"));
2584 parameters.codecs[0].id = 99; 2617 parameters.codecs[0].id = 99;
2585 EXPECT_TRUE(channel_->SetRecvParameters(parameters)); 2618 EXPECT_TRUE(channel_->SetRecvParameters(parameters));
2586 } 2619 }
2587 2620
2588 TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsAcceptDefaultCodecs) { 2621 TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsAcceptDefaultCodecs) {
2589 cricket::VideoRecvParameters parameters; 2622 cricket::VideoRecvParameters parameters;
2590 parameters.codecs = engine_.codecs(); 2623 parameters.codecs = engine_.codecs();
2591 EXPECT_TRUE(channel_->SetRecvParameters(parameters)); 2624 EXPECT_TRUE(channel_->SetRecvParameters(parameters));
2592 2625
2593 FakeVideoReceiveStream* stream = AddRecvStream(); 2626 FakeVideoReceiveStream* stream = AddRecvStream();
2594 const webrtc::VideoReceiveStream::Config& config = stream->GetConfig(); 2627 const webrtc::VideoReceiveStream::Config& config = stream->GetConfig();
2595 EXPECT_EQ(engine_.codecs()[0].name, config.decoders[0].payload_name); 2628 EXPECT_EQ(engine_.codecs()[0].name, config.decoders[0].payload_name);
2596 EXPECT_EQ(engine_.codecs()[0].id, config.decoders[0].payload_type); 2629 EXPECT_EQ(engine_.codecs()[0].id, config.decoders[0].payload_type);
2597 } 2630 }
2598 2631
2599 TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsRejectUnsupportedCodec) { 2632 TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsRejectUnsupportedCodec) {
2600 cricket::VideoRecvParameters parameters; 2633 cricket::VideoRecvParameters parameters;
2601 parameters.codecs.push_back(kVp8Codec); 2634 parameters.codecs.push_back(GetEngineCodec("VP8"));
2602 parameters.codecs.push_back(VideoCodec(101, "WTF3")); 2635 parameters.codecs.push_back(VideoCodec(101, "WTF3"));
2603 EXPECT_FALSE(channel_->SetRecvParameters(parameters)); 2636 EXPECT_FALSE(channel_->SetRecvParameters(parameters));
2604 } 2637 }
2605 2638
2606 // TODO(pbos): Enable VP9 through external codec support 2639 // TODO(pbos): Enable VP9 through external codec support
2607 TEST_F(WebRtcVideoChannel2Test, 2640 TEST_F(WebRtcVideoChannel2Test,
2608 DISABLED_SetRecvCodecsAcceptsMultipleVideoCodecs) { 2641 DISABLED_SetRecvCodecsAcceptsMultipleVideoCodecs) {
2609 cricket::VideoRecvParameters parameters; 2642 cricket::VideoRecvParameters parameters;
2610 parameters.codecs.push_back(kVp8Codec); 2643 parameters.codecs.push_back(GetEngineCodec("VP8"));
2611 parameters.codecs.push_back(kVp9Codec); 2644 parameters.codecs.push_back(GetEngineCodec("VP9"));
2612 EXPECT_TRUE(channel_->SetRecvParameters(parameters)); 2645 EXPECT_TRUE(channel_->SetRecvParameters(parameters));
2613 } 2646 }
2614 2647
2615 TEST_F(WebRtcVideoChannel2Test, 2648 TEST_F(WebRtcVideoChannel2Test,
2616 DISABLED_SetRecvCodecsSetsFecForAllVideoCodecs) { 2649 DISABLED_SetRecvCodecsSetsFecForAllVideoCodecs) {
2617 cricket::VideoRecvParameters parameters; 2650 cricket::VideoRecvParameters parameters;
2618 parameters.codecs.push_back(kVp8Codec); 2651 parameters.codecs.push_back(GetEngineCodec("VP8"));
2619 parameters.codecs.push_back(kVp9Codec); 2652 parameters.codecs.push_back(GetEngineCodec("VP9"));
2620 EXPECT_TRUE(channel_->SetRecvParameters(parameters)); 2653 EXPECT_TRUE(channel_->SetRecvParameters(parameters));
2621 FAIL(); // TODO(pbos): Verify that the FEC parameters are set for all codecs. 2654 FAIL(); // TODO(pbos): Verify that the FEC parameters are set for all codecs.
2622 } 2655 }
2623 2656
2624 TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsWithoutFecDisablesFec) { 2657 TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsWithoutFecDisablesFec) {
2625 cricket::VideoSendParameters send_parameters; 2658 cricket::VideoSendParameters send_parameters;
2626 send_parameters.codecs.push_back(kVp8Codec); 2659 send_parameters.codecs.push_back(GetEngineCodec("VP8"));
2627 send_parameters.codecs.push_back(kRedCodec); 2660 send_parameters.codecs.push_back(GetEngineCodec("red"));
2628 send_parameters.codecs.push_back(kUlpfecCodec); 2661 send_parameters.codecs.push_back(GetEngineCodec("ulpfec"));
2629 ASSERT_TRUE(channel_->SetSendParameters(send_parameters)); 2662 ASSERT_TRUE(channel_->SetSendParameters(send_parameters));
2630 2663
2631 FakeVideoReceiveStream* stream = AddRecvStream(); 2664 FakeVideoReceiveStream* stream = AddRecvStream();
2632 2665
2633 EXPECT_EQ(kUlpfecCodec.id, 2666 EXPECT_EQ(GetEngineCodec("ulpfec").id,
2634 stream->GetConfig().rtp.ulpfec.ulpfec_payload_type); 2667 stream->GetConfig().rtp.ulpfec.ulpfec_payload_type);
2635 2668
2636 cricket::VideoRecvParameters recv_parameters; 2669 cricket::VideoRecvParameters recv_parameters;
2637 recv_parameters.codecs.push_back(kVp8Codec); 2670 recv_parameters.codecs.push_back(GetEngineCodec("VP8"));
2638 ASSERT_TRUE(channel_->SetRecvParameters(recv_parameters)); 2671 ASSERT_TRUE(channel_->SetRecvParameters(recv_parameters));
2639 stream = fake_call_->GetVideoReceiveStreams()[0]; 2672 stream = fake_call_->GetVideoReceiveStreams()[0];
2640 ASSERT_TRUE(stream != NULL); 2673 ASSERT_TRUE(stream != NULL);
2641 EXPECT_EQ(-1, stream->GetConfig().rtp.ulpfec.ulpfec_payload_type) 2674 EXPECT_EQ(-1, stream->GetConfig().rtp.ulpfec.ulpfec_payload_type)
2642 << "SetSendCodec without FEC should disable current FEC."; 2675 << "SetSendCodec without FEC should disable current FEC.";
2643 } 2676 }
2644 2677
2645 TEST_F(WebRtcVideoChannel2Test, SetSendParamsWithFecEnablesFec) { 2678 TEST_F(WebRtcVideoChannel2Test, SetSendParamsWithFecEnablesFec) {
2646 FakeVideoReceiveStream* stream = AddRecvStream(); 2679 FakeVideoReceiveStream* stream = AddRecvStream();
2647 EXPECT_EQ(kUlpfecCodec.id, 2680 EXPECT_EQ(GetEngineCodec("ulpfec").id,
2648 stream->GetConfig().rtp.ulpfec.ulpfec_payload_type); 2681 stream->GetConfig().rtp.ulpfec.ulpfec_payload_type);
2649 2682
2650 cricket::VideoRecvParameters recv_parameters; 2683 cricket::VideoRecvParameters recv_parameters;
2651 recv_parameters.codecs.push_back(kVp8Codec); 2684 recv_parameters.codecs.push_back(GetEngineCodec("VP8"));
2652 recv_parameters.codecs.push_back(kRedCodec); 2685 recv_parameters.codecs.push_back(GetEngineCodec("red"));
2653 recv_parameters.codecs.push_back(kUlpfecCodec); 2686 recv_parameters.codecs.push_back(GetEngineCodec("ulpfec"));
2654 ASSERT_TRUE(channel_->SetRecvParameters(recv_parameters)); 2687 ASSERT_TRUE(channel_->SetRecvParameters(recv_parameters));
2655 stream = fake_call_->GetVideoReceiveStreams()[0]; 2688 stream = fake_call_->GetVideoReceiveStreams()[0];
2656 ASSERT_TRUE(stream != NULL); 2689 ASSERT_TRUE(stream != NULL);
2657 EXPECT_EQ(kUlpfecCodec.id, stream->GetConfig().rtp.ulpfec.ulpfec_payload_type) 2690 EXPECT_EQ(GetEngineCodec("ulpfec").id,
2691 stream->GetConfig().rtp.ulpfec.ulpfec_payload_type)
2658 << "FEC should be enabled on the receive stream."; 2692 << "FEC should be enabled on the receive stream.";
2659 2693
2660 cricket::VideoSendParameters send_parameters; 2694 cricket::VideoSendParameters send_parameters;
2661 send_parameters.codecs.push_back(kVp8Codec); 2695 send_parameters.codecs.push_back(GetEngineCodec("VP8"));
2662 send_parameters.codecs.push_back(kRedCodec); 2696 send_parameters.codecs.push_back(GetEngineCodec("red"));
2663 send_parameters.codecs.push_back(kUlpfecCodec); 2697 send_parameters.codecs.push_back(GetEngineCodec("ulpfec"));
2664 ASSERT_TRUE(channel_->SetSendParameters(send_parameters)); 2698 ASSERT_TRUE(channel_->SetSendParameters(send_parameters));
2665 stream = fake_call_->GetVideoReceiveStreams()[0]; 2699 stream = fake_call_->GetVideoReceiveStreams()[0];
2666 EXPECT_EQ(kUlpfecCodec.id, stream->GetConfig().rtp.ulpfec.ulpfec_payload_type) 2700 EXPECT_EQ(GetEngineCodec("ulpfec").id,
2701 stream->GetConfig().rtp.ulpfec.ulpfec_payload_type)
2667 << "FEC should be enabled on the receive stream."; 2702 << "FEC should be enabled on the receive stream.";
2668 } 2703 }
2669 2704
2670 TEST_F(WebRtcVideoChannel2Test, SetSendCodecsRejectDuplicateFecPayloads) { 2705 TEST_F(WebRtcVideoChannel2Test, SetSendCodecsRejectDuplicateFecPayloads) {
2671 cricket::VideoRecvParameters parameters; 2706 cricket::VideoRecvParameters parameters;
2672 parameters.codecs.push_back(kVp8Codec); 2707 parameters.codecs.push_back(GetEngineCodec("VP8"));
2673 parameters.codecs.push_back(kRedCodec); 2708 parameters.codecs.push_back(GetEngineCodec("red"));
2674 parameters.codecs[1].id = parameters.codecs[0].id; 2709 parameters.codecs[1].id = parameters.codecs[0].id;
2675 EXPECT_FALSE(channel_->SetRecvParameters(parameters)); 2710 EXPECT_FALSE(channel_->SetRecvParameters(parameters));
2676 } 2711 }
2677 2712
2678 TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsRejectDuplicateCodecPayloads) { 2713 TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsRejectDuplicateCodecPayloads) {
2679 cricket::VideoRecvParameters parameters; 2714 cricket::VideoRecvParameters parameters;
2680 parameters.codecs.push_back(kVp8Codec); 2715 parameters.codecs.push_back(GetEngineCodec("VP8"));
2681 parameters.codecs.push_back(kVp9Codec); 2716 parameters.codecs.push_back(GetEngineCodec("VP9"));
2682 parameters.codecs[1].id = parameters.codecs[0].id; 2717 parameters.codecs[1].id = parameters.codecs[0].id;
2683 EXPECT_FALSE(channel_->SetRecvParameters(parameters)); 2718 EXPECT_FALSE(channel_->SetRecvParameters(parameters));
2684 } 2719 }
2685 2720
2686 TEST_F(WebRtcVideoChannel2Test, 2721 TEST_F(WebRtcVideoChannel2Test,
2687 SetRecvCodecsAcceptSameCodecOnMultiplePayloadTypes) { 2722 SetRecvCodecsAcceptSameCodecOnMultiplePayloadTypes) {
2688 cricket::VideoRecvParameters parameters; 2723 cricket::VideoRecvParameters parameters;
2689 parameters.codecs.push_back(kVp8Codec); 2724 parameters.codecs.push_back(GetEngineCodec("VP8"));
2690 parameters.codecs.push_back(kVp8Codec); 2725 parameters.codecs.push_back(GetEngineCodec("VP8"));
2691 parameters.codecs[1].id += 1; 2726 parameters.codecs[1].id += 1;
2692 EXPECT_TRUE(channel_->SetRecvParameters(parameters)); 2727 EXPECT_TRUE(channel_->SetRecvParameters(parameters));
2693 } 2728 }
2694 2729
2695 // Test that setting the same codecs but with a different order 2730 // Test that setting the same codecs but with a different order
2696 // doesn't result in the stream being recreated. 2731 // doesn't result in the stream being recreated.
2697 TEST_F(WebRtcVideoChannel2Test, 2732 TEST_F(WebRtcVideoChannel2Test,
2698 SetRecvCodecsDifferentOrderDoesntRecreateStream) { 2733 SetRecvCodecsDifferentOrderDoesntRecreateStream) {
2699 cricket::VideoRecvParameters parameters1; 2734 cricket::VideoRecvParameters parameters1;
2700 parameters1.codecs.push_back(kVp8Codec); 2735 parameters1.codecs.push_back(GetEngineCodec("VP8"));
2701 parameters1.codecs.push_back(kRedCodec); 2736 parameters1.codecs.push_back(GetEngineCodec("red"));
2702 EXPECT_TRUE(channel_->SetRecvParameters(parameters1)); 2737 EXPECT_TRUE(channel_->SetRecvParameters(parameters1));
2703 2738
2704 AddRecvStream(cricket::StreamParams::CreateLegacy(123)); 2739 AddRecvStream(cricket::StreamParams::CreateLegacy(123));
2705 EXPECT_EQ(1, fake_call_->GetNumCreatedReceiveStreams()); 2740 EXPECT_EQ(1, fake_call_->GetNumCreatedReceiveStreams());
2706 2741
2707 cricket::VideoRecvParameters parameters2; 2742 cricket::VideoRecvParameters parameters2;
2708 parameters2.codecs.push_back(kRedCodec); 2743 parameters2.codecs.push_back(GetEngineCodec("red"));
2709 parameters2.codecs.push_back(kVp8Codec); 2744 parameters2.codecs.push_back(GetEngineCodec("VP8"));
2710 EXPECT_TRUE(channel_->SetRecvParameters(parameters2)); 2745 EXPECT_TRUE(channel_->SetRecvParameters(parameters2));
2711 EXPECT_EQ(1, fake_call_->GetNumCreatedReceiveStreams()); 2746 EXPECT_EQ(1, fake_call_->GetNumCreatedReceiveStreams());
2712 } 2747 }
2713 2748
2714 TEST_F(WebRtcVideoChannel2Test, SendStreamNotSendingByDefault) { 2749 TEST_F(WebRtcVideoChannel2Test, SendStreamNotSendingByDefault) {
2715 EXPECT_FALSE(AddSendStream()->IsSending()); 2750 EXPECT_FALSE(AddSendStream()->IsSending());
2716 } 2751 }
2717 2752
2718 TEST_F(WebRtcVideoChannel2Test, ReceiveStreamReceivingByDefault) { 2753 TEST_F(WebRtcVideoChannel2Test, ReceiveStreamReceivingByDefault) {
2719 EXPECT_TRUE(AddRecvStream()->IsReceiving()); 2754 EXPECT_TRUE(AddRecvStream()->IsReceiving());
(...skipping 99 matching lines...) Expand 10 before | Expand all | Expand 10 after
2819 2854
2820 channel_->OnReadyToSend(true); 2855 channel_->OnReadyToSend(true);
2821 EXPECT_EQ(webrtc::kNetworkUp, 2856 EXPECT_EQ(webrtc::kNetworkUp,
2822 fake_call_->GetNetworkState(webrtc::MediaType::VIDEO)); 2857 fake_call_->GetNetworkState(webrtc::MediaType::VIDEO));
2823 EXPECT_EQ(webrtc::kNetworkUp, 2858 EXPECT_EQ(webrtc::kNetworkUp,
2824 fake_call_->GetNetworkState(webrtc::MediaType::AUDIO)); 2859 fake_call_->GetNetworkState(webrtc::MediaType::AUDIO));
2825 } 2860 }
2826 2861
2827 TEST_F(WebRtcVideoChannel2Test, GetStatsReportsSentCodecName) { 2862 TEST_F(WebRtcVideoChannel2Test, GetStatsReportsSentCodecName) {
2828 cricket::VideoSendParameters parameters; 2863 cricket::VideoSendParameters parameters;
2829 parameters.codecs.push_back(kVp8Codec); 2864 parameters.codecs.push_back(GetEngineCodec("VP8"));
2830 EXPECT_TRUE(channel_->SetSendParameters(parameters)); 2865 EXPECT_TRUE(channel_->SetSendParameters(parameters));
2831 2866
2832 AddSendStream(); 2867 AddSendStream();
2833 2868
2834 cricket::VideoMediaInfo info; 2869 cricket::VideoMediaInfo info;
2835 ASSERT_TRUE(channel_->GetStats(&info)); 2870 ASSERT_TRUE(channel_->GetStats(&info));
2836 EXPECT_EQ(kVp8Codec.name, info.senders[0].codec_name); 2871 EXPECT_EQ("VP8", info.senders[0].codec_name);
2837 } 2872 }
2838 2873
2839 TEST_F(WebRtcVideoChannel2Test, GetStatsReportsEncoderImplementationName) { 2874 TEST_F(WebRtcVideoChannel2Test, GetStatsReportsEncoderImplementationName) {
2840 FakeVideoSendStream* stream = AddSendStream(); 2875 FakeVideoSendStream* stream = AddSendStream();
2841 webrtc::VideoSendStream::Stats stats; 2876 webrtc::VideoSendStream::Stats stats;
2842 stats.encoder_implementation_name = "encoder_implementation_name"; 2877 stats.encoder_implementation_name = "encoder_implementation_name";
2843 stream->SetStats(stats); 2878 stream->SetStats(stats);
2844 2879
2845 cricket::VideoMediaInfo info; 2880 cricket::VideoMediaInfo info;
2846 ASSERT_TRUE(channel_->GetStats(&info)); 2881 ASSERT_TRUE(channel_->GetStats(&info));
(...skipping 392 matching lines...) Expand 10 before | Expand all | Expand 10 after
3239 FakeVideoReceiveStream* stream = AddRecvStream(); 3274 FakeVideoReceiveStream* stream = AddRecvStream();
3240 webrtc::VideoReceiveStream::Stats stats; 3275 webrtc::VideoReceiveStream::Stats stats;
3241 cricket::VideoMediaInfo info; 3276 cricket::VideoMediaInfo info;
3242 3277
3243 // Report no codec name before receiving. 3278 // Report no codec name before receiving.
3244 stream->SetStats(stats); 3279 stream->SetStats(stats);
3245 ASSERT_TRUE(channel_->GetStats(&info)); 3280 ASSERT_TRUE(channel_->GetStats(&info));
3246 EXPECT_STREQ("", info.receivers[0].codec_name.c_str()); 3281 EXPECT_STREQ("", info.receivers[0].codec_name.c_str());
3247 3282
3248 // Report VP8 if we're receiving it. 3283 // Report VP8 if we're receiving it.
3249 stats.current_payload_type = kDefaultVp8PlType; 3284 stats.current_payload_type = GetEngineCodec("VP8").id;
3250 stream->SetStats(stats); 3285 stream->SetStats(stats);
3251 ASSERT_TRUE(channel_->GetStats(&info)); 3286 ASSERT_TRUE(channel_->GetStats(&info));
3252 EXPECT_STREQ(kVp8CodecName, info.receivers[0].codec_name.c_str()); 3287 EXPECT_STREQ(kVp8CodecName, info.receivers[0].codec_name.c_str());
3253 3288
3254 // Report no codec name for unknown playload types. 3289 // Report no codec name for unknown playload types.
3255 stats.current_payload_type = 3; 3290 stats.current_payload_type = 3;
3256 stream->SetStats(stats); 3291 stream->SetStats(stats);
3257 ASSERT_TRUE(channel_->GetStats(&info)); 3292 ASSERT_TRUE(channel_->GetStats(&info));
3258 EXPECT_STREQ("", info.receivers[0].codec_name.c_str()); 3293 EXPECT_STREQ("", info.receivers[0].codec_name.c_str());
3259 } 3294 }
3260 3295
3261 void WebRtcVideoChannel2Test::TestReceiveUnsignalledSsrcPacket( 3296 void WebRtcVideoChannel2Test::TestReceiveUnsignaledSsrcPacket(
3262 uint8_t payload_type, 3297 uint8_t payload_type,
3263 bool expect_created_receive_stream) { 3298 bool expect_created_receive_stream) {
3299 // kRedRtxPayloadType must currently be unused.
3300 EXPECT_FALSE(FindCodecById(engine_.codecs(), kRedRtxPayloadType));
3301
3264 // Add a RED RTX codec. 3302 // Add a RED RTX codec.
3265 VideoCodec red_rtx_codec = 3303 VideoCodec red_rtx_codec =
3266 VideoCodec::CreateRtxCodec(kRedRtxPayloadType, kDefaultRedPlType); 3304 VideoCodec::CreateRtxCodec(kRedRtxPayloadType, GetEngineCodec("red").id);
3267 recv_parameters_.codecs.push_back(red_rtx_codec); 3305 recv_parameters_.codecs.push_back(red_rtx_codec);
3268 EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_)); 3306 EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_));
3269 3307
3270 ASSERT_EQ(0u, fake_call_->GetVideoReceiveStreams().size()); 3308 ASSERT_EQ(0u, fake_call_->GetVideoReceiveStreams().size());
3271 const size_t kDataLength = 12; 3309 const size_t kDataLength = 12;
3272 uint8_t data[kDataLength]; 3310 uint8_t data[kDataLength];
3273 memset(data, 0, sizeof(data)); 3311 memset(data, 0, sizeof(data));
3274 3312
3275 rtc::Set8(data, 1, payload_type); 3313 rtc::Set8(data, 1, payload_type);
3276 rtc::SetBE32(&data[8], kIncomingUnsignalledSsrc); 3314 rtc::SetBE32(&data[8], kIncomingUnsignalledSsrc);
3277 rtc::CopyOnWriteBuffer packet(data, kDataLength); 3315 rtc::CopyOnWriteBuffer packet(data, kDataLength);
3278 rtc::PacketTime packet_time; 3316 rtc::PacketTime packet_time;
3279 channel_->OnPacketReceived(&packet, packet_time); 3317 channel_->OnPacketReceived(&packet, packet_time);
3280 3318
3281 if (expect_created_receive_stream) { 3319 if (expect_created_receive_stream) {
3282 EXPECT_EQ(1u, fake_call_->GetVideoReceiveStreams().size()) 3320 EXPECT_EQ(1u, fake_call_->GetVideoReceiveStreams().size())
3283 << "Should have created a receive stream for payload type: " 3321 << "Should have created a receive stream for payload type: "
3284 << payload_type; 3322 << payload_type;
3285 } else { 3323 } else {
3286 EXPECT_EQ(0u, fake_call_->GetVideoReceiveStreams().size()) 3324 EXPECT_EQ(0u, fake_call_->GetVideoReceiveStreams().size())
3287 << "Shouldn't have created a receive stream for payload type: " 3325 << "Shouldn't have created a receive stream for payload type: "
3288 << payload_type; 3326 << payload_type;
3289 } 3327 }
3290 } 3328 }
3291 3329
3292 TEST_F(WebRtcVideoChannel2Test, Vp8PacketCreatesUnsignalledStream) { 3330 TEST_F(WebRtcVideoChannel2Test, Vp8PacketCreatesUnsignalledStream) {
3293 TestReceiveUnsignalledSsrcPacket(kDefaultVp8PlType, true); 3331 TestReceiveUnsignaledSsrcPacket(GetEngineCodec("VP8").id,
3332 true /* expect_created_receive_stream */);
3294 } 3333 }
3295 3334
3296 TEST_F(WebRtcVideoChannel2Test, Vp9PacketCreatesUnsignalledStream) { 3335 TEST_F(WebRtcVideoChannel2Test, Vp9PacketCreatesUnsignalledStream) {
3297 TestReceiveUnsignalledSsrcPacket(kDefaultVp9PlType, true); 3336 TestReceiveUnsignaledSsrcPacket(GetEngineCodec("VP9").id,
3337 true /* expect_created_receive_stream */);
3298 } 3338 }
3299 3339
3300 TEST_F(WebRtcVideoChannel2Test, RtxPacketDoesntCreateUnsignalledStream) { 3340 TEST_F(WebRtcVideoChannel2Test, RtxPacketDoesntCreateUnsignalledStream) {
3301 TestReceiveUnsignalledSsrcPacket(kDefaultRtxVp8PlType, false); 3341 const cricket::VideoCodec vp8 = GetEngineCodec("VP8");
3342 const int rtx_vp8_payload_type = default_apt_rtx_types_[vp8.id];
3343 TestReceiveUnsignaledSsrcPacket(rtx_vp8_payload_type,
3344 false /* expect_created_receive_stream */);
3302 } 3345 }
3303 3346
3304 TEST_F(WebRtcVideoChannel2Test, UlpfecPacketDoesntCreateUnsignalledStream) { 3347 TEST_F(WebRtcVideoChannel2Test, UlpfecPacketDoesntCreateUnsignalledStream) {
3305 TestReceiveUnsignalledSsrcPacket(kDefaultUlpfecType, false); 3348 TestReceiveUnsignaledSsrcPacket(GetEngineCodec("ulpfec").id,
3349 false /* expect_created_receive_stream */);
3306 } 3350 }
3307 3351
3308 TEST_F(WebRtcVideoChannel2Test, RedRtxPacketDoesntCreateUnsignalledStream) { 3352 TEST_F(WebRtcVideoChannel2Test, RedRtxPacketDoesntCreateUnsignalledStream) {
3309 TestReceiveUnsignalledSsrcPacket(kRedRtxPayloadType, false); 3353 TestReceiveUnsignaledSsrcPacket(kRedRtxPayloadType,
3354 false /* expect_created_receive_stream */);
3310 } 3355 }
3311 3356
3312 TEST_F(WebRtcVideoChannel2Test, CanSentMaxBitrateForExistingStream) { 3357 TEST_F(WebRtcVideoChannel2Test, CanSentMaxBitrateForExistingStream) {
3313 AddSendStream(); 3358 AddSendStream();
3314 3359
3315 cricket::FakeVideoCapturer capturer; 3360 cricket::FakeVideoCapturer capturer;
3316 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, nullptr, &capturer)); 3361 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, nullptr, &capturer));
3317 cricket::VideoFormat capture_format_hd = 3362 cricket::VideoFormat capture_format_hd =
3318 capturer.GetSupportedFormats()->front(); 3363 capturer.GetSupportedFormats()->front();
3319 EXPECT_EQ(1280, capture_format_hd.width); 3364 EXPECT_EQ(1280, capture_format_hd.width);
(...skipping 74 matching lines...) Expand 10 before | Expand all | Expand 10 after
3394 EXPECT_TRUE(channel_->SetRtpSendParameters(last_ssrc_, parameters)); 3439 EXPECT_TRUE(channel_->SetRtpSendParameters(last_ssrc_, parameters));
3395 EXPECT_TRUE(stream->IsSending()); 3440 EXPECT_TRUE(stream->IsSending());
3396 } 3441 }
3397 3442
3398 // Test that if a stream is reconfigured (due to a codec change or other 3443 // Test that if a stream is reconfigured (due to a codec change or other
3399 // change) while its encoding is still inactive, it doesn't start sending. 3444 // change) while its encoding is still inactive, it doesn't start sending.
3400 TEST_F(WebRtcVideoChannel2Test, 3445 TEST_F(WebRtcVideoChannel2Test,
3401 InactiveStreamDoesntStartSendingWhenReconfigured) { 3446 InactiveStreamDoesntStartSendingWhenReconfigured) {
3402 // Set an initial codec list, which will be modified later. 3447 // Set an initial codec list, which will be modified later.
3403 cricket::VideoSendParameters parameters1; 3448 cricket::VideoSendParameters parameters1;
3404 parameters1.codecs.push_back(kVp8Codec); 3449 parameters1.codecs.push_back(GetEngineCodec("VP8"));
3405 parameters1.codecs.push_back(kVp9Codec); 3450 parameters1.codecs.push_back(GetEngineCodec("VP9"));
3406 EXPECT_TRUE(channel_->SetSendParameters(parameters1)); 3451 EXPECT_TRUE(channel_->SetSendParameters(parameters1));
3407 3452
3408 FakeVideoSendStream* stream = AddSendStream(); 3453 FakeVideoSendStream* stream = AddSendStream();
3409 EXPECT_TRUE(channel_->SetSend(true)); 3454 EXPECT_TRUE(channel_->SetSend(true));
3410 EXPECT_TRUE(stream->IsSending()); 3455 EXPECT_TRUE(stream->IsSending());
3411 3456
3412 // Get current parameters and change "active" to false. 3457 // Get current parameters and change "active" to false.
3413 webrtc::RtpParameters parameters = channel_->GetRtpSendParameters(last_ssrc_); 3458 webrtc::RtpParameters parameters = channel_->GetRtpSendParameters(last_ssrc_);
3414 ASSERT_EQ(1u, parameters.encodings.size()); 3459 ASSERT_EQ(1u, parameters.encodings.size());
3415 ASSERT_TRUE(parameters.encodings[0].active); 3460 ASSERT_TRUE(parameters.encodings[0].active);
3416 parameters.encodings[0].active = false; 3461 parameters.encodings[0].active = false;
3417 EXPECT_EQ(1u, GetFakeSendStreams().size()); 3462 EXPECT_EQ(1u, GetFakeSendStreams().size());
3418 EXPECT_EQ(1, fake_call_->GetNumCreatedSendStreams()); 3463 EXPECT_EQ(1, fake_call_->GetNumCreatedSendStreams());
3419 EXPECT_TRUE(channel_->SetRtpSendParameters(last_ssrc_, parameters)); 3464 EXPECT_TRUE(channel_->SetRtpSendParameters(last_ssrc_, parameters));
3420 EXPECT_FALSE(stream->IsSending()); 3465 EXPECT_FALSE(stream->IsSending());
3421 3466
3422 // Reorder the codec list, causing the stream to be reconfigured. 3467 // Reorder the codec list, causing the stream to be reconfigured.
3423 cricket::VideoSendParameters parameters2; 3468 cricket::VideoSendParameters parameters2;
3424 parameters2.codecs.push_back(kVp9Codec); 3469 parameters2.codecs.push_back(GetEngineCodec("VP9"));
3425 parameters2.codecs.push_back(kVp8Codec); 3470 parameters2.codecs.push_back(GetEngineCodec("VP8"));
3426 EXPECT_TRUE(channel_->SetSendParameters(parameters2)); 3471 EXPECT_TRUE(channel_->SetSendParameters(parameters2));
3427 auto new_streams = GetFakeSendStreams(); 3472 auto new_streams = GetFakeSendStreams();
3428 // Assert that a new underlying stream was created due to the codec change. 3473 // Assert that a new underlying stream was created due to the codec change.
3429 // Otherwise, this test isn't testing what it set out to test. 3474 // Otherwise, this test isn't testing what it set out to test.
3430 EXPECT_EQ(1u, GetFakeSendStreams().size()); 3475 EXPECT_EQ(1u, GetFakeSendStreams().size());
3431 EXPECT_EQ(2, fake_call_->GetNumCreatedSendStreams()); 3476 EXPECT_EQ(2, fake_call_->GetNumCreatedSendStreams());
3432 3477
3433 // Verify that we still are not sending anything, due to the inactive 3478 // Verify that we still are not sending anything, due to the inactive
3434 // encoding. 3479 // encoding.
3435 EXPECT_FALSE(new_streams[0]->IsSending()); 3480 EXPECT_FALSE(new_streams[0]->IsSending());
3436 } 3481 }
3437 3482
3438 // Test that GetRtpSendParameters returns the currently configured codecs. 3483 // Test that GetRtpSendParameters returns the currently configured codecs.
3439 TEST_F(WebRtcVideoChannel2Test, GetRtpSendParametersCodecs) { 3484 TEST_F(WebRtcVideoChannel2Test, GetRtpSendParametersCodecs) {
3440 AddSendStream(); 3485 AddSendStream();
3441 cricket::VideoSendParameters parameters; 3486 cricket::VideoSendParameters parameters;
3442 parameters.codecs.push_back(kVp8Codec); 3487 parameters.codecs.push_back(GetEngineCodec("VP8"));
3443 parameters.codecs.push_back(kVp9Codec); 3488 parameters.codecs.push_back(GetEngineCodec("VP9"));
3444 EXPECT_TRUE(channel_->SetSendParameters(parameters)); 3489 EXPECT_TRUE(channel_->SetSendParameters(parameters));
3445 3490
3446 webrtc::RtpParameters rtp_parameters = 3491 webrtc::RtpParameters rtp_parameters =
3447 channel_->GetRtpSendParameters(last_ssrc_); 3492 channel_->GetRtpSendParameters(last_ssrc_);
3448 ASSERT_EQ(2u, rtp_parameters.codecs.size()); 3493 ASSERT_EQ(2u, rtp_parameters.codecs.size());
3449 EXPECT_EQ(kVp8Codec.ToCodecParameters(), rtp_parameters.codecs[0]); 3494 EXPECT_EQ(GetEngineCodec("VP8").ToCodecParameters(),
3450 EXPECT_EQ(kVp9Codec.ToCodecParameters(), rtp_parameters.codecs[1]); 3495 rtp_parameters.codecs[0]);
3496 EXPECT_EQ(GetEngineCodec("VP9").ToCodecParameters(),
3497 rtp_parameters.codecs[1]);
3451 } 3498 }
3452 3499
3453 // Test that if we set/get parameters multiple times, we get the same results. 3500 // Test that if we set/get parameters multiple times, we get the same results.
3454 TEST_F(WebRtcVideoChannel2Test, SetAndGetRtpSendParameters) { 3501 TEST_F(WebRtcVideoChannel2Test, SetAndGetRtpSendParameters) {
3455 AddSendStream(); 3502 AddSendStream();
3456 cricket::VideoSendParameters parameters; 3503 cricket::VideoSendParameters parameters;
3457 parameters.codecs.push_back(kVp8Codec); 3504 parameters.codecs.push_back(GetEngineCodec("VP8"));
3458 parameters.codecs.push_back(kVp9Codec); 3505 parameters.codecs.push_back(GetEngineCodec("VP9"));
3459 EXPECT_TRUE(channel_->SetSendParameters(parameters)); 3506 EXPECT_TRUE(channel_->SetSendParameters(parameters));
3460 3507
3461 webrtc::RtpParameters initial_params = 3508 webrtc::RtpParameters initial_params =
3462 channel_->GetRtpSendParameters(last_ssrc_); 3509 channel_->GetRtpSendParameters(last_ssrc_);
3463 3510
3464 // We should be able to set the params we just got. 3511 // We should be able to set the params we just got.
3465 EXPECT_TRUE(channel_->SetRtpSendParameters(last_ssrc_, initial_params)); 3512 EXPECT_TRUE(channel_->SetRtpSendParameters(last_ssrc_, initial_params));
3466 3513
3467 // ... And this shouldn't change the params returned by GetRtpSendParameters. 3514 // ... And this shouldn't change the params returned by GetRtpSendParameters.
3468 EXPECT_EQ(initial_params, channel_->GetRtpSendParameters(last_ssrc_)); 3515 EXPECT_EQ(initial_params, channel_->GetRtpSendParameters(last_ssrc_));
3469 } 3516 }
3470 3517
3471 // Test that GetRtpReceiveParameters returns the currently configured codecs. 3518 // Test that GetRtpReceiveParameters returns the currently configured codecs.
3472 TEST_F(WebRtcVideoChannel2Test, GetRtpReceiveParametersCodecs) { 3519 TEST_F(WebRtcVideoChannel2Test, GetRtpReceiveParametersCodecs) {
3473 AddRecvStream(); 3520 AddRecvStream();
3474 cricket::VideoRecvParameters parameters; 3521 cricket::VideoRecvParameters parameters;
3475 parameters.codecs.push_back(kVp8Codec); 3522 parameters.codecs.push_back(GetEngineCodec("VP8"));
3476 parameters.codecs.push_back(kVp9Codec); 3523 parameters.codecs.push_back(GetEngineCodec("VP9"));
3477 EXPECT_TRUE(channel_->SetRecvParameters(parameters)); 3524 EXPECT_TRUE(channel_->SetRecvParameters(parameters));
3478 3525
3479 webrtc::RtpParameters rtp_parameters = 3526 webrtc::RtpParameters rtp_parameters =
3480 channel_->GetRtpReceiveParameters(last_ssrc_); 3527 channel_->GetRtpReceiveParameters(last_ssrc_);
3481 ASSERT_EQ(2u, rtp_parameters.codecs.size()); 3528 ASSERT_EQ(2u, rtp_parameters.codecs.size());
3482 EXPECT_EQ(kVp8Codec.ToCodecParameters(), rtp_parameters.codecs[0]); 3529 EXPECT_EQ(GetEngineCodec("VP8").ToCodecParameters(),
3483 EXPECT_EQ(kVp9Codec.ToCodecParameters(), rtp_parameters.codecs[1]); 3530 rtp_parameters.codecs[0]);
3531 EXPECT_EQ(GetEngineCodec("VP9").ToCodecParameters(),
3532 rtp_parameters.codecs[1]);
3484 } 3533 }
3485 3534
3486 #if defined(WEBRTC_USE_H264) 3535 #if defined(WEBRTC_USE_H264)
3487 TEST_F(WebRtcVideoChannel2Test, GetRtpReceiveFmtpSprop) { 3536 TEST_F(WebRtcVideoChannel2Test, GetRtpReceiveFmtpSprop) {
3488 #else 3537 #else
3489 TEST_F(WebRtcVideoChannel2Test, DISABLED_GetRtpReceiveFmtpSprop) { 3538 TEST_F(WebRtcVideoChannel2Test, DISABLED_GetRtpReceiveFmtpSprop) {
3490 #endif 3539 #endif
3491 cricket::VideoRecvParameters parameters; 3540 cricket::VideoRecvParameters parameters;
3492 cricket::VideoCodec kH264sprop1(101, "H264"); 3541 cricket::VideoCodec kH264sprop1(101, "H264");
3493 kH264sprop1.SetParam("sprop-parameter-sets", "uvw"); 3542 kH264sprop1.SetParam("sprop-parameter-sets", "uvw");
(...skipping 36 matching lines...) Expand 10 before | Expand all | Expand 10 after
3530 channel_->GetRtpReceiveParameters(last_ssrc_); 3579 channel_->GetRtpReceiveParameters(last_ssrc_);
3531 ASSERT_EQ(1u, rtp_parameters.encodings.size()); 3580 ASSERT_EQ(1u, rtp_parameters.encodings.size());
3532 EXPECT_EQ(rtc::Optional<uint32_t>(last_ssrc_), 3581 EXPECT_EQ(rtc::Optional<uint32_t>(last_ssrc_),
3533 rtp_parameters.encodings[0].ssrc); 3582 rtp_parameters.encodings[0].ssrc);
3534 } 3583 }
3535 3584
3536 // Test that if we set/get parameters multiple times, we get the same results. 3585 // Test that if we set/get parameters multiple times, we get the same results.
3537 TEST_F(WebRtcVideoChannel2Test, SetAndGetRtpReceiveParameters) { 3586 TEST_F(WebRtcVideoChannel2Test, SetAndGetRtpReceiveParameters) {
3538 AddRecvStream(); 3587 AddRecvStream();
3539 cricket::VideoRecvParameters parameters; 3588 cricket::VideoRecvParameters parameters;
3540 parameters.codecs.push_back(kVp8Codec); 3589 parameters.codecs.push_back(GetEngineCodec("VP8"));
3541 parameters.codecs.push_back(kVp9Codec); 3590 parameters.codecs.push_back(GetEngineCodec("VP9"));
3542 EXPECT_TRUE(channel_->SetRecvParameters(parameters)); 3591 EXPECT_TRUE(channel_->SetRecvParameters(parameters));
3543 3592
3544 webrtc::RtpParameters initial_params = 3593 webrtc::RtpParameters initial_params =
3545 channel_->GetRtpReceiveParameters(last_ssrc_); 3594 channel_->GetRtpReceiveParameters(last_ssrc_);
3546 3595
3547 // We should be able to set the params we just got. 3596 // We should be able to set the params we just got.
3548 EXPECT_TRUE(channel_->SetRtpReceiveParameters(last_ssrc_, initial_params)); 3597 EXPECT_TRUE(channel_->SetRtpReceiveParameters(last_ssrc_, initial_params));
3549 3598
3550 // ... And this shouldn't change the params returned by 3599 // ... And this shouldn't change the params returned by
3551 // GetRtpReceiveParameters. 3600 // GetRtpReceiveParameters.
(...skipping 173 matching lines...) Expand 10 before | Expand all | Expand 10 after
3725 } 3774 }
3726 3775
3727 webrtc::RtcEventLogNullImpl event_log_; 3776 webrtc::RtcEventLogNullImpl event_log_;
3728 FakeCall fake_call_; 3777 FakeCall fake_call_;
3729 WebRtcVideoEngine2 engine_; 3778 WebRtcVideoEngine2 engine_;
3730 std::unique_ptr<VideoMediaChannel> channel_; 3779 std::unique_ptr<VideoMediaChannel> channel_;
3731 uint32_t last_ssrc_; 3780 uint32_t last_ssrc_;
3732 }; 3781 };
3733 3782
3734 TEST_F(WebRtcVideoChannel2SimulcastTest, SetSendCodecsWith2SimulcastStreams) { 3783 TEST_F(WebRtcVideoChannel2SimulcastTest, SetSendCodecsWith2SimulcastStreams) {
3735 VerifySimulcastSettings(kVp8Codec, 640, 360, 2, 2); 3784 VerifySimulcastSettings(cricket::VideoCodec("VP8"), 640, 360, 2, 2);
3736 } 3785 }
3737 3786
3738 TEST_F(WebRtcVideoChannel2SimulcastTest, SetSendCodecsWith3SimulcastStreams) { 3787 TEST_F(WebRtcVideoChannel2SimulcastTest, SetSendCodecsWith3SimulcastStreams) {
3739 VerifySimulcastSettings(kVp8Codec, 1280, 720, 3, 3); 3788 VerifySimulcastSettings(cricket::VideoCodec("VP8"), 1280, 720, 3, 3);
3740 } 3789 }
3741 3790
3742 // Test that we normalize send codec format size in simulcast. 3791 // Test that we normalize send codec format size in simulcast.
3743 TEST_F(WebRtcVideoChannel2SimulcastTest, SetSendCodecsWithOddSizeInSimulcast) { 3792 TEST_F(WebRtcVideoChannel2SimulcastTest, SetSendCodecsWithOddSizeInSimulcast) {
3744 cricket::VideoCodec codec(kVp8Codec); 3793 VerifySimulcastSettings(cricket::VideoCodec("VP8"), 541, 271, 2, 2);
3745 VerifySimulcastSettings(codec, 541, 271, 2, 2);
3746 } 3794 }
3747 } // namespace cricket 3795 } // namespace cricket
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698