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