OLD | NEW |
---|---|
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 Loading... | |
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 Loading... | |
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 Loading... | |
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 Loading... | |
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 Loading... | |
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 Loading... | |
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 Loading... | |
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 Loading... | |
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 Loading... | |
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 Loading... | |
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 Loading... | |
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 Loading... | |
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 Loading... | |
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 Loading... | |
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 Loading... | |
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 Loading... | |
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 Loading... | |
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 Loading... | |
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 Loading... | |
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 Loading... | |
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 Loading... | |
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 Loading... | |
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 Loading... | |
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 Loading... | |
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 Loading... | |
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 Loading... | |
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 Loading... | |
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 Loading... | |
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 Loading... | |
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 |
OLD | NEW |