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 15 matching lines...) Expand all Loading... |
26 #include "webrtc/media/engine/webrtcvideoengine2.h" | 26 #include "webrtc/media/engine/webrtcvideoengine2.h" |
27 #include "webrtc/media/engine/webrtcvoiceengine.h" | 27 #include "webrtc/media/engine/webrtcvoiceengine.h" |
28 #include "webrtc/test/field_trial.h" | 28 #include "webrtc/test/field_trial.h" |
29 #include "webrtc/video_encoder.h" | 29 #include "webrtc/video_encoder.h" |
30 | 30 |
31 using webrtc::RtpExtension; | 31 using webrtc::RtpExtension; |
32 | 32 |
33 namespace { | 33 namespace { |
34 static const int kDefaultQpMax = 56; | 34 static const int kDefaultQpMax = 56; |
35 | 35 |
36 static const cricket::VideoCodec kVp8Codec(100, "VP8"); | |
37 static const cricket::VideoCodec kVp9Codec(101, "VP9"); | |
38 static const cricket::VideoCodec kH264Codec(102, "H264"); | |
39 | |
40 static const cricket::VideoCodec kRedCodec(116, "red"); | |
41 static const cricket::VideoCodec kUlpfecCodec(117, "ulpfec"); | |
42 | |
43 static const uint8_t kRedRtxPayloadType = 125; | 36 static const uint8_t kRedRtxPayloadType = 125; |
44 | 37 |
45 static const uint32_t kSsrcs1[] = {1}; | 38 static const uint32_t kSsrcs1[] = {1}; |
46 static const uint32_t kSsrcs3[] = {1, 2, 3}; | 39 static const uint32_t kSsrcs3[] = {1, 2, 3}; |
47 static const uint32_t kRtxSsrcs1[] = {4}; | 40 static const uint32_t kRtxSsrcs1[] = {4}; |
48 static const uint32_t kIncomingUnsignalledSsrc = 0xC0FFEE; | 41 static const uint32_t kIncomingUnsignalledSsrc = 0xC0FFEE; |
49 static const char kUnsupportedExtensionName[] = | 42 static const char kUnsupportedExtensionName[] = |
50 "urn:ietf:params:rtp-hdrext:unsupported"; | 43 "urn:ietf:params:rtp-hdrext:unsupported"; |
51 | 44 |
| 45 cricket::VideoCodec RemoveFeedbackParams(cricket::VideoCodec&& codec) { |
| 46 codec.feedback_params = cricket::FeedbackParams(); |
| 47 return codec; |
| 48 } |
| 49 |
52 void VerifyCodecHasDefaultFeedbackParams(const cricket::VideoCodec& codec) { | 50 void VerifyCodecHasDefaultFeedbackParams(const cricket::VideoCodec& codec) { |
53 EXPECT_TRUE(codec.HasFeedbackParam(cricket::FeedbackParam( | 51 EXPECT_TRUE(codec.HasFeedbackParam(cricket::FeedbackParam( |
54 cricket::kRtcpFbParamNack, cricket::kParamValueEmpty))); | 52 cricket::kRtcpFbParamNack, cricket::kParamValueEmpty))); |
55 EXPECT_TRUE(codec.HasFeedbackParam(cricket::FeedbackParam( | 53 EXPECT_TRUE(codec.HasFeedbackParam(cricket::FeedbackParam( |
56 cricket::kRtcpFbParamNack, cricket::kRtcpFbNackParamPli))); | 54 cricket::kRtcpFbParamNack, cricket::kRtcpFbNackParamPli))); |
57 EXPECT_TRUE(codec.HasFeedbackParam(cricket::FeedbackParam( | 55 EXPECT_TRUE(codec.HasFeedbackParam(cricket::FeedbackParam( |
58 cricket::kRtcpFbParamRemb, cricket::kParamValueEmpty))); | 56 cricket::kRtcpFbParamRemb, cricket::kParamValueEmpty))); |
59 EXPECT_TRUE(codec.HasFeedbackParam(cricket::FeedbackParam( | 57 EXPECT_TRUE(codec.HasFeedbackParam(cricket::FeedbackParam( |
60 cricket::kRtcpFbParamTransportCc, cricket::kParamValueEmpty))); | 58 cricket::kRtcpFbParamTransportCc, cricket::kParamValueEmpty))); |
61 EXPECT_TRUE(codec.HasFeedbackParam(cricket::FeedbackParam( | 59 EXPECT_TRUE(codec.HasFeedbackParam(cricket::FeedbackParam( |
(...skipping 44 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
106 class WebRtcVideoEngine2Test : public ::testing::Test { | 104 class WebRtcVideoEngine2Test : public ::testing::Test { |
107 public: | 105 public: |
108 WebRtcVideoEngine2Test() : WebRtcVideoEngine2Test("") {} | 106 WebRtcVideoEngine2Test() : WebRtcVideoEngine2Test("") {} |
109 explicit WebRtcVideoEngine2Test(const char* field_trials) | 107 explicit WebRtcVideoEngine2Test(const char* field_trials) |
110 : override_field_trials_(field_trials), | 108 : override_field_trials_(field_trials), |
111 call_(webrtc::Call::Create(webrtc::Call::Config(&event_log_))), | 109 call_(webrtc::Call::Create(webrtc::Call::Config(&event_log_))), |
112 engine_() { | 110 engine_() { |
113 std::vector<VideoCodec> engine_codecs = engine_.codecs(); | 111 std::vector<VideoCodec> engine_codecs = engine_.codecs(); |
114 RTC_DCHECK(!engine_codecs.empty()); | 112 RTC_DCHECK(!engine_codecs.empty()); |
115 bool codec_set = false; | 113 bool codec_set = false; |
116 for (size_t i = 0; i < engine_codecs.size(); ++i) { | 114 for (const cricket::VideoCodec& codec : engine_codecs) { |
117 if (engine_codecs[i].name == "red") { | 115 if (codec.name == "rtx") { |
118 default_red_codec_ = engine_codecs[i]; | |
119 } else if (engine_codecs[i].name == "ulpfec") { | |
120 default_ulpfec_codec_ = engine_codecs[i]; | |
121 } else if (engine_codecs[i].name == "rtx") { | |
122 int associated_payload_type; | 116 int associated_payload_type; |
123 if (engine_codecs[i].GetParam(kCodecParamAssociatedPayloadType, | 117 if (codec.GetParam(kCodecParamAssociatedPayloadType, |
124 &associated_payload_type)) { | 118 &associated_payload_type)) { |
125 default_apt_rtx_types_[associated_payload_type] = engine_codecs[i].id; | 119 default_apt_rtx_types_[associated_payload_type] = codec.id; |
126 } | 120 } |
127 } else if (!codec_set) { | 121 } else if (!codec_set && codec.name != "red" && codec.name != "ulpfec") { |
128 default_codec_ = engine_codecs[i]; | 122 default_codec_ = codec; |
129 codec_set = true; | 123 codec_set = true; |
130 } | 124 } |
131 } | 125 } |
132 | 126 |
133 RTC_DCHECK(codec_set); | 127 RTC_DCHECK(codec_set); |
134 } | 128 } |
135 | 129 |
136 protected: | 130 protected: |
| 131 // Find the codec in the engine with the given name. The codec must be |
| 132 // present. |
| 133 cricket::VideoCodec GetEngineCodec(const std::string& name); |
| 134 |
137 VideoMediaChannel* SetUpForExternalEncoderFactory( | 135 VideoMediaChannel* SetUpForExternalEncoderFactory( |
138 cricket::WebRtcVideoEncoderFactory* encoder_factory, | 136 cricket::WebRtcVideoEncoderFactory* encoder_factory); |
139 const std::vector<VideoCodec>& codecs); | |
140 | 137 |
141 VideoMediaChannel* SetUpForExternalDecoderFactory( | 138 VideoMediaChannel* SetUpForExternalDecoderFactory( |
142 cricket::WebRtcVideoDecoderFactory* decoder_factory, | 139 cricket::WebRtcVideoDecoderFactory* decoder_factory, |
143 const std::vector<VideoCodec>& codecs); | 140 const std::vector<VideoCodec>& codecs); |
144 | 141 |
145 void TestExtendedEncoderOveruse(bool use_external_encoder); | 142 void TestExtendedEncoderOveruse(bool use_external_encoder); |
146 | 143 |
147 webrtc::test::ScopedFieldTrials override_field_trials_; | 144 webrtc::test::ScopedFieldTrials override_field_trials_; |
148 webrtc::RtcEventLogNullImpl event_log_; | 145 webrtc::RtcEventLogNullImpl event_log_; |
149 // Used in WebRtcVideoEngine2VoiceTest, but defined here so it's properly | 146 // Used in WebRtcVideoEngine2VoiceTest, but defined here so it's properly |
150 // initialized when the constructor is called. | 147 // initialized when the constructor is called. |
151 std::unique_ptr<webrtc::Call> call_; | 148 std::unique_ptr<webrtc::Call> call_; |
152 WebRtcVideoEngine2 engine_; | 149 WebRtcVideoEngine2 engine_; |
153 VideoCodec default_codec_; | 150 VideoCodec default_codec_; |
154 VideoCodec default_red_codec_; | |
155 VideoCodec default_ulpfec_codec_; | |
156 std::map<int, int> default_apt_rtx_types_; | 151 std::map<int, int> default_apt_rtx_types_; |
157 }; | 152 }; |
158 | 153 |
159 TEST_F(WebRtcVideoEngine2Test, AnnouncesVp9AccordingToBuildFlags) { | 154 TEST_F(WebRtcVideoEngine2Test, AnnouncesVp9AccordingToBuildFlags) { |
160 bool claims_vp9_support = false; | 155 bool claims_vp9_support = false; |
161 for (const cricket::VideoCodec& codec : engine_.codecs()) { | 156 for (const cricket::VideoCodec& codec : engine_.codecs()) { |
162 if (codec.name == "VP9") { | 157 if (codec.name == "VP9") { |
163 claims_vp9_support = true; | 158 claims_vp9_support = true; |
164 break; | 159 break; |
165 } | 160 } |
(...skipping 67 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
233 FAIL() << "Video Rotation extension not in header-extension list."; | 228 FAIL() << "Video Rotation extension not in header-extension list."; |
234 } | 229 } |
235 | 230 |
236 TEST_F(WebRtcVideoEngine2Test, CVOSetHeaderExtensionBeforeCapturer) { | 231 TEST_F(WebRtcVideoEngine2Test, CVOSetHeaderExtensionBeforeCapturer) { |
237 // Allocate the capturer first to prevent early destruction before channel's | 232 // Allocate the capturer first to prevent early destruction before channel's |
238 // dtor is called. | 233 // dtor is called. |
239 cricket::FakeVideoCapturer capturer; | 234 cricket::FakeVideoCapturer capturer; |
240 | 235 |
241 cricket::FakeWebRtcVideoEncoderFactory encoder_factory; | 236 cricket::FakeWebRtcVideoEncoderFactory encoder_factory; |
242 encoder_factory.AddSupportedVideoCodecType("VP8"); | 237 encoder_factory.AddSupportedVideoCodecType("VP8"); |
243 cricket::VideoSendParameters parameters; | |
244 parameters.codecs.push_back(kVp8Codec); | |
245 | 238 |
246 std::unique_ptr<VideoMediaChannel> channel( | 239 std::unique_ptr<VideoMediaChannel> channel( |
247 SetUpForExternalEncoderFactory(&encoder_factory, parameters.codecs)); | 240 SetUpForExternalEncoderFactory(&encoder_factory)); |
248 EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(kSsrc))); | 241 EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(kSsrc))); |
249 | 242 |
250 // Add CVO extension. | 243 // Add CVO extension. |
251 const int id = 1; | 244 const int id = 1; |
| 245 cricket::VideoSendParameters parameters; |
| 246 parameters.codecs.push_back(GetEngineCodec("VP8")); |
252 parameters.extensions.push_back( | 247 parameters.extensions.push_back( |
253 RtpExtension(RtpExtension::kVideoRotationUri, id)); | 248 RtpExtension(RtpExtension::kVideoRotationUri, id)); |
254 EXPECT_TRUE(channel->SetSendParameters(parameters)); | 249 EXPECT_TRUE(channel->SetSendParameters(parameters)); |
255 | 250 |
256 // Set capturer. | 251 // Set capturer. |
257 EXPECT_TRUE(channel->SetVideoSend(kSsrc, true, nullptr, &capturer)); | 252 EXPECT_TRUE(channel->SetVideoSend(kSsrc, true, nullptr, &capturer)); |
258 | 253 |
259 // Verify capturer has turned off applying rotation. | 254 // Verify capturer has turned off applying rotation. |
260 EXPECT_FALSE(capturer.apply_rotation()); | 255 EXPECT_FALSE(capturer.apply_rotation()); |
261 | 256 |
262 // Verify removing header extension turns on applying rotation. | 257 // Verify removing header extension turns on applying rotation. |
263 parameters.extensions.clear(); | 258 parameters.extensions.clear(); |
264 EXPECT_TRUE(channel->SetSendParameters(parameters)); | 259 EXPECT_TRUE(channel->SetSendParameters(parameters)); |
265 EXPECT_TRUE(capturer.apply_rotation()); | 260 EXPECT_TRUE(capturer.apply_rotation()); |
266 } | 261 } |
267 | 262 |
268 TEST_F(WebRtcVideoEngine2Test, CVOSetHeaderExtensionBeforeAddSendStream) { | 263 TEST_F(WebRtcVideoEngine2Test, CVOSetHeaderExtensionBeforeAddSendStream) { |
269 // Allocate the capturer first to prevent early destruction before channel's | 264 // Allocate the capturer first to prevent early destruction before channel's |
270 // dtor is called. | 265 // dtor is called. |
271 cricket::FakeVideoCapturer capturer; | 266 cricket::FakeVideoCapturer capturer; |
272 | 267 |
273 cricket::FakeWebRtcVideoEncoderFactory encoder_factory; | 268 cricket::FakeWebRtcVideoEncoderFactory encoder_factory; |
274 encoder_factory.AddSupportedVideoCodecType("VP8"); | 269 encoder_factory.AddSupportedVideoCodecType("VP8"); |
275 cricket::VideoSendParameters parameters; | |
276 parameters.codecs.push_back(kVp8Codec); | |
277 | 270 |
278 std::unique_ptr<VideoMediaChannel> channel( | 271 std::unique_ptr<VideoMediaChannel> channel( |
279 SetUpForExternalEncoderFactory(&encoder_factory, parameters.codecs)); | 272 SetUpForExternalEncoderFactory(&encoder_factory)); |
280 // Add CVO extension. | 273 // Add CVO extension. |
281 const int id = 1; | 274 const int id = 1; |
| 275 cricket::VideoSendParameters parameters; |
| 276 parameters.codecs.push_back(GetEngineCodec("VP8")); |
282 parameters.extensions.push_back( | 277 parameters.extensions.push_back( |
283 RtpExtension(RtpExtension::kVideoRotationUri, id)); | 278 RtpExtension(RtpExtension::kVideoRotationUri, id)); |
284 EXPECT_TRUE(channel->SetSendParameters(parameters)); | 279 EXPECT_TRUE(channel->SetSendParameters(parameters)); |
285 EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(kSsrc))); | 280 EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(kSsrc))); |
286 | 281 |
287 // Set capturer. | 282 // Set capturer. |
288 EXPECT_TRUE(channel->SetVideoSend(kSsrc, true, nullptr, &capturer)); | 283 EXPECT_TRUE(channel->SetVideoSend(kSsrc, true, nullptr, &capturer)); |
289 | 284 |
290 // Verify capturer has turned off applying rotation. | 285 // Verify capturer has turned off applying rotation. |
291 EXPECT_FALSE(capturer.apply_rotation()); | 286 EXPECT_FALSE(capturer.apply_rotation()); |
292 } | 287 } |
293 | 288 |
294 TEST_F(WebRtcVideoEngine2Test, CVOSetHeaderExtensionAfterCapturer) { | 289 TEST_F(WebRtcVideoEngine2Test, CVOSetHeaderExtensionAfterCapturer) { |
295 cricket::FakeVideoCapturer capturer; | 290 cricket::FakeVideoCapturer capturer; |
296 | 291 |
297 cricket::FakeWebRtcVideoEncoderFactory encoder_factory; | 292 cricket::FakeWebRtcVideoEncoderFactory encoder_factory; |
298 encoder_factory.AddSupportedVideoCodecType("VP8"); | 293 encoder_factory.AddSupportedVideoCodecType("VP8"); |
299 encoder_factory.AddSupportedVideoCodecType("VP9"); | 294 encoder_factory.AddSupportedVideoCodecType("VP9"); |
300 cricket::VideoSendParameters parameters; | |
301 parameters.codecs.push_back(kVp8Codec); | |
302 parameters.codecs.push_back(kVp9Codec); | |
303 | 295 |
304 std::unique_ptr<VideoMediaChannel> channel( | 296 std::unique_ptr<VideoMediaChannel> channel( |
305 SetUpForExternalEncoderFactory(&encoder_factory, parameters.codecs)); | 297 SetUpForExternalEncoderFactory(&encoder_factory)); |
306 EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(kSsrc))); | 298 EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(kSsrc))); |
307 | 299 |
308 // Set capturer. | 300 // Set capturer. |
309 EXPECT_TRUE(channel->SetVideoSend(kSsrc, true, nullptr, &capturer)); | 301 EXPECT_TRUE(channel->SetVideoSend(kSsrc, true, nullptr, &capturer)); |
310 | 302 |
311 // Verify capturer has turned on applying rotation. | 303 // Verify capturer has turned on applying rotation. |
312 EXPECT_TRUE(capturer.apply_rotation()); | 304 EXPECT_TRUE(capturer.apply_rotation()); |
313 | 305 |
314 // Add CVO extension. | 306 // Add CVO extension. |
315 const int id = 1; | 307 const int id = 1; |
| 308 cricket::VideoSendParameters parameters; |
| 309 parameters.codecs.push_back(GetEngineCodec("VP8")); |
| 310 parameters.codecs.push_back(GetEngineCodec("VP9")); |
316 parameters.extensions.push_back( | 311 parameters.extensions.push_back( |
317 RtpExtension(RtpExtension::kVideoRotationUri, id)); | 312 RtpExtension(RtpExtension::kVideoRotationUri, id)); |
318 // Also remove the first codec to trigger a codec change as well. | 313 // Also remove the first codec to trigger a codec change as well. |
319 parameters.codecs.erase(parameters.codecs.begin()); | 314 parameters.codecs.erase(parameters.codecs.begin()); |
320 EXPECT_TRUE(channel->SetSendParameters(parameters)); | 315 EXPECT_TRUE(channel->SetSendParameters(parameters)); |
321 | 316 |
322 // Verify capturer has turned off applying rotation. | 317 // Verify capturer has turned off applying rotation. |
323 EXPECT_FALSE(capturer.apply_rotation()); | 318 EXPECT_FALSE(capturer.apply_rotation()); |
324 | 319 |
325 // Verify removing header extension turns on applying rotation. | 320 // Verify removing header extension turns on applying rotation. |
(...skipping 20 matching lines...) Expand all Loading... |
346 std::unique_ptr<VideoMediaChannel> channel( | 341 std::unique_ptr<VideoMediaChannel> channel( |
347 engine_.CreateChannel(call_.get(), MediaConfig(), VideoOptions())); | 342 engine_.CreateChannel(call_.get(), MediaConfig(), VideoOptions())); |
348 EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(123))); | 343 EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(123))); |
349 VideoMediaInfo info; | 344 VideoMediaInfo info; |
350 channel->GetStats(&info); | 345 channel->GetStats(&info); |
351 } | 346 } |
352 | 347 |
353 TEST_F(WebRtcVideoEngine2Test, UseExternalFactoryForVp8WhenSupported) { | 348 TEST_F(WebRtcVideoEngine2Test, UseExternalFactoryForVp8WhenSupported) { |
354 cricket::FakeWebRtcVideoEncoderFactory encoder_factory; | 349 cricket::FakeWebRtcVideoEncoderFactory encoder_factory; |
355 encoder_factory.AddSupportedVideoCodecType("VP8"); | 350 encoder_factory.AddSupportedVideoCodecType("VP8"); |
356 cricket::VideoSendParameters parameters; | |
357 parameters.codecs.push_back(kVp8Codec); | |
358 | 351 |
359 std::unique_ptr<VideoMediaChannel> channel( | 352 std::unique_ptr<VideoMediaChannel> channel( |
360 SetUpForExternalEncoderFactory(&encoder_factory, parameters.codecs)); | 353 SetUpForExternalEncoderFactory(&encoder_factory)); |
361 | 354 |
362 EXPECT_TRUE( | 355 EXPECT_TRUE( |
363 channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc))); | 356 channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc))); |
364 EXPECT_EQ(0, encoder_factory.GetNumCreatedEncoders()); | 357 EXPECT_EQ(0, encoder_factory.GetNumCreatedEncoders()); |
365 EXPECT_TRUE(channel->SetSend(true)); | 358 EXPECT_TRUE(channel->SetSend(true)); |
366 cricket::FakeVideoCapturer capturer; | 359 cricket::FakeVideoCapturer capturer; |
367 EXPECT_TRUE(channel->SetVideoSend(kSsrc, true, nullptr, &capturer)); | 360 EXPECT_TRUE(channel->SetVideoSend(kSsrc, true, nullptr, &capturer)); |
368 EXPECT_EQ(cricket::CS_RUNNING, | 361 EXPECT_EQ(cricket::CS_RUNNING, |
369 capturer.Start(capturer.GetSupportedFormats()->front())); | 362 capturer.Start(capturer.GetSupportedFormats()->front())); |
370 EXPECT_TRUE(capturer.CaptureFrame()); | 363 EXPECT_TRUE(capturer.CaptureFrame()); |
371 // Sending one frame will have allocate the encoder. | 364 // Sending one frame will have allocate the encoder. |
372 ASSERT_TRUE(encoder_factory.WaitForCreatedVideoEncoders(1)); | 365 ASSERT_TRUE(encoder_factory.WaitForCreatedVideoEncoders(1)); |
373 EXPECT_TRUE_WAIT(encoder_factory.encoders()[0]->GetNumEncodedFrames() > 0, | 366 EXPECT_TRUE_WAIT(encoder_factory.encoders()[0]->GetNumEncodedFrames() > 0, |
374 kTimeout); | 367 kTimeout); |
375 | 368 |
376 int num_created_encoders = encoder_factory.GetNumCreatedEncoders(); | 369 int num_created_encoders = encoder_factory.GetNumCreatedEncoders(); |
377 EXPECT_EQ(num_created_encoders, 1); | 370 EXPECT_EQ(num_created_encoders, 1); |
378 | 371 |
379 // Setting codecs of the same type should not reallocate any encoders | 372 // Setting codecs of the same type should not reallocate any encoders |
380 // (expecting a no-op). | 373 // (expecting a no-op). |
| 374 cricket::VideoSendParameters parameters; |
| 375 parameters.codecs.push_back(GetEngineCodec("VP8")); |
381 EXPECT_TRUE(channel->SetSendParameters(parameters)); | 376 EXPECT_TRUE(channel->SetSendParameters(parameters)); |
382 EXPECT_EQ(num_created_encoders, encoder_factory.GetNumCreatedEncoders()); | 377 EXPECT_EQ(num_created_encoders, encoder_factory.GetNumCreatedEncoders()); |
383 | 378 |
384 // Remove stream previously added to free the external encoder instance. | 379 // Remove stream previously added to free the external encoder instance. |
385 EXPECT_TRUE(channel->RemoveSendStream(kSsrc)); | 380 EXPECT_TRUE(channel->RemoveSendStream(kSsrc)); |
386 EXPECT_EQ(0u, encoder_factory.encoders().size()); | 381 EXPECT_EQ(0u, encoder_factory.encoders().size()); |
387 } | 382 } |
388 | 383 |
389 // Test that when an external encoder factory supports a codec we don't | 384 // Test that when an external encoder factory supports a codec we don't |
390 // internally support, we still add an RTX codec for it. | 385 // internally support, we still add an RTX codec for it. |
(...skipping 18 matching lines...) Expand all Loading... |
409 | 404 |
410 cricket::FakeWebRtcVideoEncoderFactory encoder_factory; | 405 cricket::FakeWebRtcVideoEncoderFactory encoder_factory; |
411 encoder_factory.AddSupportedVideoCodec(h264_constrained_baseline); | 406 encoder_factory.AddSupportedVideoCodec(h264_constrained_baseline); |
412 encoder_factory.AddSupportedVideoCodec(h264_constrained_high); | 407 encoder_factory.AddSupportedVideoCodec(h264_constrained_high); |
413 encoder_factory.AddSupportedVideoCodec(h264_high); | 408 encoder_factory.AddSupportedVideoCodec(h264_high); |
414 engine_.SetExternalEncoderFactory(&encoder_factory); | 409 engine_.SetExternalEncoderFactory(&encoder_factory); |
415 engine_.Init(); | 410 engine_.Init(); |
416 | 411 |
417 // First figure out what payload types the test codecs got assigned. | 412 // First figure out what payload types the test codecs got assigned. |
418 const std::vector<cricket::VideoCodec> codecs = engine_.codecs(); | 413 const std::vector<cricket::VideoCodec> codecs = engine_.codecs(); |
419 // Now search for RTX codecs for them. Expect that Constrained Baseline and | 414 // Now search for RTX codecs for them. Expect that they all have associated |
420 // Constrained High got an associated RTX codec, but not High. | 415 // RTX codecs. |
421 EXPECT_TRUE(HasRtxCodec( | 416 EXPECT_TRUE(HasRtxCodec( |
422 codecs, FindMatchingCodec(codecs, h264_constrained_baseline)->id)); | 417 codecs, FindMatchingCodec(codecs, h264_constrained_baseline)->id)); |
423 EXPECT_TRUE(HasRtxCodec( | 418 EXPECT_TRUE(HasRtxCodec( |
424 codecs, FindMatchingCodec(codecs, h264_constrained_high)->id)); | 419 codecs, FindMatchingCodec(codecs, h264_constrained_high)->id)); |
425 EXPECT_FALSE(HasRtxCodec( | 420 EXPECT_TRUE(HasRtxCodec( |
426 codecs, FindMatchingCodec(codecs, h264_high)->id)); | 421 codecs, FindMatchingCodec(codecs, h264_high)->id)); |
427 } | 422 } |
428 | 423 |
429 void WebRtcVideoEngine2Test::TestExtendedEncoderOveruse( | 424 void WebRtcVideoEngine2Test::TestExtendedEncoderOveruse( |
430 bool use_external_encoder) { | 425 bool use_external_encoder) { |
431 cricket::FakeWebRtcVideoEncoderFactory encoder_factory; | 426 cricket::FakeWebRtcVideoEncoderFactory encoder_factory; |
432 encoder_factory.AddSupportedVideoCodecType("VP8"); | 427 encoder_factory.AddSupportedVideoCodecType("VP8"); |
433 cricket::VideoSendParameters parameters; | |
434 parameters.codecs.push_back(kVp8Codec); | |
435 std::unique_ptr<VideoMediaChannel> channel; | 428 std::unique_ptr<VideoMediaChannel> channel; |
436 FakeCall* fake_call = new FakeCall(webrtc::Call::Config(&event_log_)); | 429 FakeCall* fake_call = new FakeCall(webrtc::Call::Config(&event_log_)); |
437 call_.reset(fake_call); | 430 call_.reset(fake_call); |
438 if (use_external_encoder) { | 431 if (use_external_encoder) { |
439 channel.reset( | 432 channel.reset(SetUpForExternalEncoderFactory(&encoder_factory)); |
440 SetUpForExternalEncoderFactory(&encoder_factory, parameters.codecs)); | |
441 } else { | 433 } else { |
442 engine_.Init(); | 434 engine_.Init(); |
443 channel.reset( | 435 channel.reset( |
444 engine_.CreateChannel(call_.get(), MediaConfig(), VideoOptions())); | 436 engine_.CreateChannel(call_.get(), MediaConfig(), VideoOptions())); |
445 } | 437 } |
446 ASSERT_TRUE( | 438 ASSERT_TRUE( |
447 channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc))); | 439 channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc))); |
| 440 cricket::VideoSendParameters parameters; |
| 441 parameters.codecs.push_back(GetEngineCodec("VP8")); |
448 EXPECT_TRUE(channel->SetSendParameters(parameters)); | 442 EXPECT_TRUE(channel->SetSendParameters(parameters)); |
449 EXPECT_TRUE(channel->SetSend(true)); | 443 EXPECT_TRUE(channel->SetSend(true)); |
450 FakeVideoSendStream* stream = fake_call->GetVideoSendStreams()[0]; | 444 FakeVideoSendStream* stream = fake_call->GetVideoSendStreams()[0]; |
451 | 445 |
452 EXPECT_EQ(use_external_encoder, | 446 EXPECT_EQ(use_external_encoder, |
453 stream->GetConfig().encoder_settings.full_overuse_time); | 447 stream->GetConfig().encoder_settings.full_overuse_time); |
454 // Remove stream previously added to free the external encoder instance. | 448 // Remove stream previously added to free the external encoder instance. |
455 EXPECT_TRUE(channel->RemoveSendStream(kSsrc)); | 449 EXPECT_TRUE(channel->RemoveSendStream(kSsrc)); |
456 } | 450 } |
457 | 451 |
458 TEST_F(WebRtcVideoEngine2Test, EnablesFullEncoderTimeForExternalEncoders) { | 452 TEST_F(WebRtcVideoEngine2Test, EnablesFullEncoderTimeForExternalEncoders) { |
459 TestExtendedEncoderOveruse(true); | 453 TestExtendedEncoderOveruse(true); |
460 } | 454 } |
461 | 455 |
462 TEST_F(WebRtcVideoEngine2Test, DisablesFullEncoderTimeForNonExternalEncoders) { | 456 TEST_F(WebRtcVideoEngine2Test, DisablesFullEncoderTimeForNonExternalEncoders) { |
463 TestExtendedEncoderOveruse(false); | 457 TestExtendedEncoderOveruse(false); |
464 } | 458 } |
465 | 459 |
466 #if !defined(RTC_DISABLE_VP9) | 460 #if !defined(RTC_DISABLE_VP9) |
467 TEST_F(WebRtcVideoEngine2Test, CanConstructDecoderForVp9EncoderFactory) { | 461 TEST_F(WebRtcVideoEngine2Test, CanConstructDecoderForVp9EncoderFactory) { |
468 cricket::FakeWebRtcVideoEncoderFactory encoder_factory; | 462 cricket::FakeWebRtcVideoEncoderFactory encoder_factory; |
469 encoder_factory.AddSupportedVideoCodecType("VP9"); | 463 encoder_factory.AddSupportedVideoCodecType("VP9"); |
470 std::vector<cricket::VideoCodec> codecs; | |
471 codecs.push_back(kVp9Codec); | |
472 | 464 |
473 std::unique_ptr<VideoMediaChannel> channel( | 465 std::unique_ptr<VideoMediaChannel> channel( |
474 SetUpForExternalEncoderFactory(&encoder_factory, codecs)); | 466 SetUpForExternalEncoderFactory(&encoder_factory)); |
475 | 467 |
476 EXPECT_TRUE( | 468 EXPECT_TRUE( |
477 channel->AddRecvStream(cricket::StreamParams::CreateLegacy(kSsrc))); | 469 channel->AddRecvStream(cricket::StreamParams::CreateLegacy(kSsrc))); |
478 } | 470 } |
479 #endif // !defined(RTC_DISABLE_VP9) | 471 #endif // !defined(RTC_DISABLE_VP9) |
480 | 472 |
481 TEST_F(WebRtcVideoEngine2Test, PropagatesInputFrameTimestamp) { | 473 TEST_F(WebRtcVideoEngine2Test, PropagatesInputFrameTimestamp) { |
482 cricket::FakeWebRtcVideoEncoderFactory encoder_factory; | 474 cricket::FakeWebRtcVideoEncoderFactory encoder_factory; |
483 encoder_factory.AddSupportedVideoCodecType("VP8"); | 475 encoder_factory.AddSupportedVideoCodecType("VP8"); |
484 std::vector<cricket::VideoCodec> codecs; | |
485 codecs.push_back(kVp8Codec); | |
486 FakeCall* fake_call = new FakeCall(webrtc::Call::Config(&event_log_)); | 476 FakeCall* fake_call = new FakeCall(webrtc::Call::Config(&event_log_)); |
487 call_.reset(fake_call); | 477 call_.reset(fake_call); |
488 std::unique_ptr<VideoMediaChannel> channel( | 478 std::unique_ptr<VideoMediaChannel> channel( |
489 SetUpForExternalEncoderFactory(&encoder_factory, codecs)); | 479 SetUpForExternalEncoderFactory(&encoder_factory)); |
490 | 480 |
491 EXPECT_TRUE( | 481 EXPECT_TRUE( |
492 channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc))); | 482 channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc))); |
493 | 483 |
494 FakeVideoCapturer capturer; | 484 FakeVideoCapturer capturer; |
495 EXPECT_TRUE(channel->SetVideoSend(kSsrc, true, nullptr, &capturer)); | 485 EXPECT_TRUE(channel->SetVideoSend(kSsrc, true, nullptr, &capturer)); |
496 capturer.Start(cricket::VideoFormat(1280, 720, | 486 capturer.Start(cricket::VideoFormat(1280, 720, |
497 cricket::VideoFormat::FpsToInterval(60), | 487 cricket::VideoFormat::FpsToInterval(60), |
498 cricket::FOURCC_I420)); | 488 cricket::FOURCC_I420)); |
499 channel->SetSend(true); | 489 channel->SetSend(true); |
(...skipping 29 matching lines...) Expand all Loading... |
529 // Allow error to be no more than 1. | 519 // Allow error to be no more than 1. |
530 EXPECT_NEAR(cricket::VideoFormat::FpsToInterval(30) / 1E6, interval, 1); | 520 EXPECT_NEAR(cricket::VideoFormat::FpsToInterval(30) / 1E6, interval, 1); |
531 | 521 |
532 last_timestamp = timestamp; | 522 last_timestamp = timestamp; |
533 } | 523 } |
534 | 524 |
535 // Remove stream previously added to free the external encoder instance. | 525 // Remove stream previously added to free the external encoder instance. |
536 EXPECT_TRUE(channel->RemoveSendStream(kSsrc)); | 526 EXPECT_TRUE(channel->RemoveSendStream(kSsrc)); |
537 } | 527 } |
538 | 528 |
| 529 cricket::VideoCodec WebRtcVideoEngine2Test::GetEngineCodec( |
| 530 const std::string& name) { |
| 531 for (const cricket::VideoCodec& engine_codec : engine_.codecs()) { |
| 532 if (CodecNamesEq(name, engine_codec.name)) |
| 533 return engine_codec; |
| 534 } |
| 535 // This point should never be reached. |
| 536 ADD_FAILURE() << "Unrecognized codec name: " << name; |
| 537 return cricket::VideoCodec(); |
| 538 } |
| 539 |
539 VideoMediaChannel* WebRtcVideoEngine2Test::SetUpForExternalEncoderFactory( | 540 VideoMediaChannel* WebRtcVideoEngine2Test::SetUpForExternalEncoderFactory( |
540 cricket::WebRtcVideoEncoderFactory* encoder_factory, | 541 cricket::WebRtcVideoEncoderFactory* encoder_factory) { |
541 const std::vector<VideoCodec>& codecs) { | |
542 engine_.SetExternalEncoderFactory(encoder_factory); | 542 engine_.SetExternalEncoderFactory(encoder_factory); |
543 engine_.Init(); | 543 engine_.Init(); |
544 | 544 |
545 VideoMediaChannel* channel = | 545 VideoMediaChannel* channel = |
546 engine_.CreateChannel(call_.get(), MediaConfig(), VideoOptions()); | 546 engine_.CreateChannel(call_.get(), MediaConfig(), VideoOptions()); |
547 cricket::VideoSendParameters parameters; | 547 cricket::VideoSendParameters parameters; |
548 parameters.codecs = codecs; | 548 // We need to look up the codec in the engine to get the correct payload type. |
| 549 for (const VideoCodec& codec : encoder_factory->supported_codecs()) |
| 550 parameters.codecs.push_back(GetEngineCodec(codec.name)); |
| 551 |
549 EXPECT_TRUE(channel->SetSendParameters(parameters)); | 552 EXPECT_TRUE(channel->SetSendParameters(parameters)); |
550 | 553 |
551 return channel; | 554 return channel; |
552 } | 555 } |
553 | 556 |
554 VideoMediaChannel* WebRtcVideoEngine2Test::SetUpForExternalDecoderFactory( | 557 VideoMediaChannel* WebRtcVideoEngine2Test::SetUpForExternalDecoderFactory( |
555 cricket::WebRtcVideoDecoderFactory* decoder_factory, | 558 cricket::WebRtcVideoDecoderFactory* decoder_factory, |
556 const std::vector<VideoCodec>& codecs) { | 559 const std::vector<VideoCodec>& codecs) { |
557 engine_.SetExternalDecoderFactory(decoder_factory); | 560 engine_.SetExternalDecoderFactory(decoder_factory); |
558 engine_.Init(); | 561 engine_.Init(); |
559 | 562 |
560 VideoMediaChannel* channel = | 563 VideoMediaChannel* channel = |
561 engine_.CreateChannel(call_.get(), MediaConfig(), VideoOptions()); | 564 engine_.CreateChannel(call_.get(), MediaConfig(), VideoOptions()); |
562 cricket::VideoRecvParameters parameters; | 565 cricket::VideoRecvParameters parameters; |
563 parameters.codecs = codecs; | 566 parameters.codecs = codecs; |
564 EXPECT_TRUE(channel->SetRecvParameters(parameters)); | 567 EXPECT_TRUE(channel->SetRecvParameters(parameters)); |
565 | 568 |
566 return channel; | 569 return channel; |
567 } | 570 } |
568 | 571 |
569 TEST_F(WebRtcVideoEngine2Test, UsesSimulcastAdapterForVp8Factories) { | 572 TEST_F(WebRtcVideoEngine2Test, UsesSimulcastAdapterForVp8Factories) { |
570 cricket::FakeWebRtcVideoEncoderFactory encoder_factory; | 573 cricket::FakeWebRtcVideoEncoderFactory encoder_factory; |
571 encoder_factory.AddSupportedVideoCodecType("VP8"); | 574 encoder_factory.AddSupportedVideoCodecType("VP8"); |
572 std::vector<cricket::VideoCodec> codecs; | |
573 codecs.push_back(kVp8Codec); | |
574 | 575 |
575 std::unique_ptr<VideoMediaChannel> channel( | 576 std::unique_ptr<VideoMediaChannel> channel( |
576 SetUpForExternalEncoderFactory(&encoder_factory, codecs)); | 577 SetUpForExternalEncoderFactory(&encoder_factory)); |
577 | 578 |
578 std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs3); | 579 std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs3); |
579 | 580 |
580 EXPECT_TRUE( | 581 EXPECT_TRUE( |
581 channel->AddSendStream(CreateSimStreamParams("cname", ssrcs))); | 582 channel->AddSendStream(CreateSimStreamParams("cname", ssrcs))); |
582 EXPECT_TRUE(channel->SetSend(true)); | 583 EXPECT_TRUE(channel->SetSend(true)); |
583 | 584 |
584 cricket::FakeVideoCapturer capturer; | 585 cricket::FakeVideoCapturer capturer; |
585 EXPECT_TRUE(channel->SetVideoSend(ssrcs.front(), true, nullptr, &capturer)); | 586 EXPECT_TRUE(channel->SetVideoSend(ssrcs.front(), true, nullptr, &capturer)); |
586 EXPECT_EQ(cricket::CS_RUNNING, | 587 EXPECT_EQ(cricket::CS_RUNNING, |
(...skipping 16 matching lines...) Expand all Loading... |
603 | 604 |
604 EXPECT_TRUE(channel->SetVideoSend(ssrcs.front(), true, nullptr, nullptr)); | 605 EXPECT_TRUE(channel->SetVideoSend(ssrcs.front(), true, nullptr, nullptr)); |
605 | 606 |
606 channel.reset(); | 607 channel.reset(); |
607 ASSERT_EQ(0u, encoder_factory.encoders().size()); | 608 ASSERT_EQ(0u, encoder_factory.encoders().size()); |
608 } | 609 } |
609 | 610 |
610 TEST_F(WebRtcVideoEngine2Test, ChannelWithExternalH264CanChangeToInternalVp8) { | 611 TEST_F(WebRtcVideoEngine2Test, ChannelWithExternalH264CanChangeToInternalVp8) { |
611 cricket::FakeWebRtcVideoEncoderFactory encoder_factory; | 612 cricket::FakeWebRtcVideoEncoderFactory encoder_factory; |
612 encoder_factory.AddSupportedVideoCodecType("H264"); | 613 encoder_factory.AddSupportedVideoCodecType("H264"); |
613 std::vector<cricket::VideoCodec> codecs; | |
614 codecs.push_back(kH264Codec); | |
615 | 614 |
616 std::unique_ptr<VideoMediaChannel> channel( | 615 std::unique_ptr<VideoMediaChannel> channel( |
617 SetUpForExternalEncoderFactory(&encoder_factory, codecs)); | 616 SetUpForExternalEncoderFactory(&encoder_factory)); |
618 | 617 |
619 EXPECT_TRUE( | 618 EXPECT_TRUE( |
620 channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc))); | 619 channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc))); |
621 ASSERT_EQ(1u, encoder_factory.encoders().size()); | 620 ASSERT_EQ(1u, encoder_factory.encoders().size()); |
622 | 621 |
623 cricket::VideoSendParameters parameters; | 622 cricket::VideoSendParameters parameters; |
624 parameters.codecs.push_back(kVp8Codec); | 623 parameters.codecs.push_back(GetEngineCodec("VP8")); |
625 EXPECT_TRUE(channel->SetSendParameters(parameters)); | 624 EXPECT_TRUE(channel->SetSendParameters(parameters)); |
626 ASSERT_EQ(0u, encoder_factory.encoders().size()); | 625 ASSERT_EQ(0u, encoder_factory.encoders().size()); |
627 } | 626 } |
628 | 627 |
629 TEST_F(WebRtcVideoEngine2Test, | 628 TEST_F(WebRtcVideoEngine2Test, |
630 DontUseExternalEncoderFactoryForUnsupportedCodecs) { | 629 DontUseExternalEncoderFactoryForUnsupportedCodecs) { |
631 cricket::FakeWebRtcVideoEncoderFactory encoder_factory; | 630 cricket::FakeWebRtcVideoEncoderFactory encoder_factory; |
632 encoder_factory.AddSupportedVideoCodecType("H264"); | 631 encoder_factory.AddSupportedVideoCodecType("H264"); |
633 std::vector<cricket::VideoCodec> codecs; | 632 |
634 codecs.push_back(kVp8Codec); | 633 engine_.SetExternalEncoderFactory(&encoder_factory); |
| 634 engine_.Init(); |
635 | 635 |
636 std::unique_ptr<VideoMediaChannel> channel( | 636 std::unique_ptr<VideoMediaChannel> channel( |
637 SetUpForExternalEncoderFactory(&encoder_factory, codecs)); | 637 engine_.CreateChannel(call_.get(), MediaConfig(), VideoOptions())); |
| 638 cricket::VideoSendParameters parameters; |
| 639 parameters.codecs.push_back(GetEngineCodec("VP8")); |
| 640 EXPECT_TRUE(channel->SetSendParameters(parameters)); |
638 | 641 |
639 EXPECT_TRUE( | 642 EXPECT_TRUE( |
640 channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc))); | 643 channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc))); |
641 // Make sure DestroyVideoEncoder was called on the factory. | 644 // Make sure DestroyVideoEncoder was called on the factory. |
642 ASSERT_EQ(0u, encoder_factory.encoders().size()); | 645 ASSERT_EQ(0u, encoder_factory.encoders().size()); |
643 } | 646 } |
644 | 647 |
645 TEST_F(WebRtcVideoEngine2Test, | 648 TEST_F(WebRtcVideoEngine2Test, |
646 UsesSimulcastAdapterForVp8WithCombinedVP8AndH264Factory) { | 649 UsesSimulcastAdapterForVp8WithCombinedVP8AndH264Factory) { |
647 cricket::FakeWebRtcVideoEncoderFactory encoder_factory; | 650 cricket::FakeWebRtcVideoEncoderFactory encoder_factory; |
648 encoder_factory.AddSupportedVideoCodecType("VP8"); | 651 encoder_factory.AddSupportedVideoCodecType("VP8"); |
649 encoder_factory.AddSupportedVideoCodecType("H264"); | 652 encoder_factory.AddSupportedVideoCodecType("H264"); |
650 | 653 |
651 std::vector<cricket::VideoCodec> codecs; | 654 engine_.SetExternalEncoderFactory(&encoder_factory); |
652 codecs.push_back(kVp8Codec); | 655 engine_.Init(); |
653 | 656 |
654 std::unique_ptr<VideoMediaChannel> channel( | 657 std::unique_ptr<VideoMediaChannel> channel( |
655 SetUpForExternalEncoderFactory(&encoder_factory, codecs)); | 658 engine_.CreateChannel(call_.get(), MediaConfig(), VideoOptions())); |
| 659 cricket::VideoSendParameters parameters; |
| 660 parameters.codecs.push_back(GetEngineCodec("VP8")); |
| 661 EXPECT_TRUE(channel->SetSendParameters(parameters)); |
656 | 662 |
657 std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs3); | 663 std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs3); |
658 | 664 |
659 EXPECT_TRUE( | 665 EXPECT_TRUE( |
660 channel->AddSendStream(CreateSimStreamParams("cname", ssrcs))); | 666 channel->AddSendStream(CreateSimStreamParams("cname", ssrcs))); |
661 EXPECT_TRUE(channel->SetSend(true)); | 667 EXPECT_TRUE(channel->SetSend(true)); |
662 | 668 |
663 // Send a fake frame, or else the media engine will configure the simulcast | 669 // Send a fake frame, or else the media engine will configure the simulcast |
664 // encoder adapter at a low-enough size that it'll only create a single | 670 // encoder adapter at a low-enough size that it'll only create a single |
665 // encoder layer. | 671 // encoder layer. |
(...skipping 12 matching lines...) Expand all Loading... |
678 // Make sure DestroyVideoEncoder was called on the factory. | 684 // Make sure DestroyVideoEncoder was called on the factory. |
679 EXPECT_EQ(0u, encoder_factory.encoders().size()); | 685 EXPECT_EQ(0u, encoder_factory.encoders().size()); |
680 } | 686 } |
681 | 687 |
682 TEST_F(WebRtcVideoEngine2Test, | 688 TEST_F(WebRtcVideoEngine2Test, |
683 DestroysNonSimulcastEncoderFromCombinedVP8AndH264Factory) { | 689 DestroysNonSimulcastEncoderFromCombinedVP8AndH264Factory) { |
684 cricket::FakeWebRtcVideoEncoderFactory encoder_factory; | 690 cricket::FakeWebRtcVideoEncoderFactory encoder_factory; |
685 encoder_factory.AddSupportedVideoCodecType("VP8"); | 691 encoder_factory.AddSupportedVideoCodecType("VP8"); |
686 encoder_factory.AddSupportedVideoCodecType("H264"); | 692 encoder_factory.AddSupportedVideoCodecType("H264"); |
687 | 693 |
688 std::vector<cricket::VideoCodec> codecs; | 694 engine_.SetExternalEncoderFactory(&encoder_factory); |
689 codecs.push_back(kH264Codec); | 695 engine_.Init(); |
690 | 696 |
691 std::unique_ptr<VideoMediaChannel> channel( | 697 std::unique_ptr<VideoMediaChannel> channel( |
692 SetUpForExternalEncoderFactory(&encoder_factory, codecs)); | 698 engine_.CreateChannel(call_.get(), MediaConfig(), VideoOptions())); |
| 699 cricket::VideoSendParameters parameters; |
| 700 parameters.codecs.push_back(GetEngineCodec("H264")); |
| 701 EXPECT_TRUE(channel->SetSendParameters(parameters)); |
693 | 702 |
694 EXPECT_TRUE( | 703 EXPECT_TRUE( |
695 channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc))); | 704 channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc))); |
696 ASSERT_EQ(1u, encoder_factory.encoders().size()); | 705 ASSERT_EQ(1u, encoder_factory.encoders().size()); |
697 | 706 |
698 // Send a frame of 720p. This should trigger a "real" encoder initialization. | 707 // Send a frame of 720p. This should trigger a "real" encoder initialization. |
699 cricket::VideoFormat format( | 708 cricket::VideoFormat format( |
700 1280, 720, cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420); | 709 1280, 720, cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420); |
701 cricket::FakeVideoCapturer capturer; | 710 cricket::FakeVideoCapturer capturer; |
702 EXPECT_TRUE(channel->SetVideoSend(kSsrc, true, nullptr, &capturer)); | 711 EXPECT_TRUE(channel->SetVideoSend(kSsrc, true, nullptr, &capturer)); |
703 EXPECT_EQ(cricket::CS_RUNNING, capturer.Start(format)); | 712 EXPECT_EQ(cricket::CS_RUNNING, capturer.Start(format)); |
704 EXPECT_TRUE(capturer.CaptureFrame()); | 713 EXPECT_TRUE(capturer.CaptureFrame()); |
705 ASSERT_TRUE(encoder_factory.encoders()[0]->WaitForInitEncode()); | 714 ASSERT_TRUE(encoder_factory.encoders()[0]->WaitForInitEncode()); |
706 EXPECT_EQ(webrtc::kVideoCodecH264, | 715 EXPECT_EQ(webrtc::kVideoCodecH264, |
707 encoder_factory.encoders()[0]->GetCodecSettings().codecType); | 716 encoder_factory.encoders()[0]->GetCodecSettings().codecType); |
708 | 717 |
709 channel.reset(); | 718 channel.reset(); |
710 // Make sure DestroyVideoEncoder was called on the factory. | 719 // Make sure DestroyVideoEncoder was called on the factory. |
711 ASSERT_EQ(0u, encoder_factory.encoders().size()); | 720 ASSERT_EQ(0u, encoder_factory.encoders().size()); |
712 } | 721 } |
713 | 722 |
714 TEST_F(WebRtcVideoEngine2Test, SimulcastDisabledForH264) { | 723 TEST_F(WebRtcVideoEngine2Test, SimulcastDisabledForH264) { |
715 cricket::FakeWebRtcVideoEncoderFactory encoder_factory; | 724 cricket::FakeWebRtcVideoEncoderFactory encoder_factory; |
716 encoder_factory.AddSupportedVideoCodecType("H264"); | 725 encoder_factory.AddSupportedVideoCodecType("H264"); |
717 std::vector<cricket::VideoCodec> codecs; | |
718 codecs.push_back(kH264Codec); | |
719 | 726 |
720 std::unique_ptr<VideoMediaChannel> channel( | 727 std::unique_ptr<VideoMediaChannel> channel( |
721 SetUpForExternalEncoderFactory(&encoder_factory, codecs)); | 728 SetUpForExternalEncoderFactory(&encoder_factory)); |
722 | 729 |
723 const std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs3); | 730 const std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs3); |
724 EXPECT_TRUE( | 731 EXPECT_TRUE( |
725 channel->AddSendStream(cricket::CreateSimStreamParams("cname", ssrcs))); | 732 channel->AddSendStream(cricket::CreateSimStreamParams("cname", ssrcs))); |
726 | 733 |
727 // Send a frame of 720p. This should trigger a "real" encoder initialization. | 734 // Send a frame of 720p. This should trigger a "real" encoder initialization. |
728 cricket::VideoFormat format( | 735 cricket::VideoFormat format( |
729 1280, 720, cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420); | 736 1280, 720, cricket::VideoFormat::FpsToInterval(30), cricket::FOURCC_I420); |
730 cricket::FakeVideoCapturer capturer; | 737 cricket::FakeVideoCapturer capturer; |
731 EXPECT_TRUE(channel->SetVideoSend(ssrcs[0], true, nullptr, &capturer)); | 738 EXPECT_TRUE(channel->SetVideoSend(ssrcs[0], true, nullptr, &capturer)); |
(...skipping 22 matching lines...) Expand all Loading... |
754 | 761 |
755 // The external codec will appear at last. | 762 // The external codec will appear at last. |
756 EXPECT_EQ("VP8", internal_codec.name); | 763 EXPECT_EQ("VP8", internal_codec.name); |
757 EXPECT_EQ("FakeExternalCodec", external_codec.name); | 764 EXPECT_EQ("FakeExternalCodec", external_codec.name); |
758 } | 765 } |
759 | 766 |
760 TEST_F(WebRtcVideoEngine2Test, RegisterExternalDecodersIfSupported) { | 767 TEST_F(WebRtcVideoEngine2Test, RegisterExternalDecodersIfSupported) { |
761 cricket::FakeWebRtcVideoDecoderFactory decoder_factory; | 768 cricket::FakeWebRtcVideoDecoderFactory decoder_factory; |
762 decoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8); | 769 decoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8); |
763 cricket::VideoRecvParameters parameters; | 770 cricket::VideoRecvParameters parameters; |
764 parameters.codecs.push_back(kVp8Codec); | 771 parameters.codecs.push_back(GetEngineCodec("VP8")); |
765 | 772 |
766 std::unique_ptr<VideoMediaChannel> channel( | 773 std::unique_ptr<VideoMediaChannel> channel( |
767 SetUpForExternalDecoderFactory(&decoder_factory, parameters.codecs)); | 774 SetUpForExternalDecoderFactory(&decoder_factory, parameters.codecs)); |
768 | 775 |
769 EXPECT_TRUE( | 776 EXPECT_TRUE( |
770 channel->AddRecvStream(cricket::StreamParams::CreateLegacy(kSsrc))); | 777 channel->AddRecvStream(cricket::StreamParams::CreateLegacy(kSsrc))); |
771 ASSERT_EQ(1u, decoder_factory.decoders().size()); | 778 ASSERT_EQ(1u, decoder_factory.decoders().size()); |
772 | 779 |
773 // Setting codecs of the same type should not reallocate the decoder. | 780 // Setting codecs of the same type should not reallocate the decoder. |
774 EXPECT_TRUE(channel->SetRecvParameters(parameters)); | 781 EXPECT_TRUE(channel->SetRecvParameters(parameters)); |
775 EXPECT_EQ(1, decoder_factory.GetNumCreatedDecoders()); | 782 EXPECT_EQ(1, decoder_factory.GetNumCreatedDecoders()); |
776 | 783 |
777 // Remove stream previously added to free the external decoder instance. | 784 // Remove stream previously added to free the external decoder instance. |
778 EXPECT_TRUE(channel->RemoveRecvStream(kSsrc)); | 785 EXPECT_TRUE(channel->RemoveRecvStream(kSsrc)); |
779 EXPECT_EQ(0u, decoder_factory.decoders().size()); | 786 EXPECT_EQ(0u, decoder_factory.decoders().size()); |
780 } | 787 } |
781 | 788 |
782 // Verifies that we can set up decoders that are not internally supported. | 789 // Verifies that we can set up decoders that are not internally supported. |
783 TEST_F(WebRtcVideoEngine2Test, RegisterExternalH264DecoderIfSupported) { | 790 TEST_F(WebRtcVideoEngine2Test, RegisterExternalH264DecoderIfSupported) { |
784 // TODO(pbos): Do not assume that encoder/decoder support is symmetric. We | 791 // TODO(pbos): Do not assume that encoder/decoder support is symmetric. We |
785 // can't even query the WebRtcVideoDecoderFactory for supported codecs. | 792 // can't even query the WebRtcVideoDecoderFactory for supported codecs. |
786 // For now we add a FakeWebRtcVideoEncoderFactory to add H264 to supported | 793 // For now we add a FakeWebRtcVideoEncoderFactory to add H264 to supported |
787 // codecs. | 794 // codecs. |
788 cricket::FakeWebRtcVideoEncoderFactory encoder_factory; | 795 cricket::FakeWebRtcVideoEncoderFactory encoder_factory; |
789 encoder_factory.AddSupportedVideoCodecType("H264"); | 796 encoder_factory.AddSupportedVideoCodecType("H264"); |
790 engine_.SetExternalEncoderFactory(&encoder_factory); | 797 engine_.SetExternalEncoderFactory(&encoder_factory); |
791 cricket::FakeWebRtcVideoDecoderFactory decoder_factory; | 798 cricket::FakeWebRtcVideoDecoderFactory decoder_factory; |
792 decoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecH264); | 799 decoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecH264); |
793 std::vector<cricket::VideoCodec> codecs; | 800 std::vector<cricket::VideoCodec> codecs; |
794 codecs.push_back(kH264Codec); | 801 codecs.push_back(GetEngineCodec("H264")); |
795 | 802 |
796 std::unique_ptr<VideoMediaChannel> channel( | 803 std::unique_ptr<VideoMediaChannel> channel( |
797 SetUpForExternalDecoderFactory(&decoder_factory, codecs)); | 804 SetUpForExternalDecoderFactory(&decoder_factory, codecs)); |
798 | 805 |
799 EXPECT_TRUE( | 806 EXPECT_TRUE( |
800 channel->AddRecvStream(cricket::StreamParams::CreateLegacy(kSsrc))); | 807 channel->AddRecvStream(cricket::StreamParams::CreateLegacy(kSsrc))); |
801 ASSERT_EQ(1u, decoder_factory.decoders().size()); | 808 ASSERT_EQ(1u, decoder_factory.decoders().size()); |
802 } | 809 } |
803 | 810 |
804 class WebRtcVideoChannel2BaseTest | 811 class WebRtcVideoChannel2BaseTest |
805 : public VideoMediaChannelTest<WebRtcVideoEngine2, WebRtcVideoChannel2> { | 812 : public VideoMediaChannelTest<WebRtcVideoEngine2, WebRtcVideoChannel2> { |
806 protected: | 813 protected: |
807 typedef VideoMediaChannelTest<WebRtcVideoEngine2, WebRtcVideoChannel2> Base; | 814 typedef VideoMediaChannelTest<WebRtcVideoEngine2, WebRtcVideoChannel2> Base; |
808 | 815 |
809 cricket::VideoCodec DefaultCodec() override { return kVp8Codec; } | 816 cricket::VideoCodec GetEngineCodec(const std::string& name) { |
| 817 for (const cricket::VideoCodec& engine_codec : engine_.codecs()) { |
| 818 if (CodecNamesEq(name, engine_codec.name)) |
| 819 return engine_codec; |
| 820 } |
| 821 // This point should never be reached. |
| 822 ADD_FAILURE() << "Unrecognized codec name: " << name; |
| 823 return cricket::VideoCodec(); |
| 824 } |
| 825 |
| 826 cricket::VideoCodec DefaultCodec() override { return GetEngineCodec("VP8"); } |
810 }; | 827 }; |
811 | 828 |
812 // Verifies that id given in stream params is passed to the decoder factory. | 829 // Verifies that id given in stream params is passed to the decoder factory. |
813 TEST_F(WebRtcVideoEngine2Test, StreamParamsIdPassedToDecoderFactory) { | 830 TEST_F(WebRtcVideoEngine2Test, StreamParamsIdPassedToDecoderFactory) { |
814 cricket::FakeWebRtcVideoDecoderFactory decoder_factory; | 831 cricket::FakeWebRtcVideoDecoderFactory decoder_factory; |
815 decoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8); | 832 decoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8); |
816 cricket::VideoRecvParameters parameters; | 833 cricket::VideoRecvParameters parameters; |
817 parameters.codecs.push_back(kVp8Codec); | 834 parameters.codecs.push_back(GetEngineCodec("VP8")); |
818 | 835 |
819 std::unique_ptr<VideoMediaChannel> channel( | 836 std::unique_ptr<VideoMediaChannel> channel( |
820 SetUpForExternalDecoderFactory(&decoder_factory, parameters.codecs)); | 837 SetUpForExternalDecoderFactory(&decoder_factory, parameters.codecs)); |
821 | 838 |
822 StreamParams sp = cricket::StreamParams::CreateLegacy(kSsrc); | 839 StreamParams sp = cricket::StreamParams::CreateLegacy(kSsrc); |
823 sp.id = "FakeStreamParamsId"; | 840 sp.id = "FakeStreamParamsId"; |
824 EXPECT_TRUE(channel->AddRecvStream(sp)); | 841 EXPECT_TRUE(channel->AddRecvStream(sp)); |
825 EXPECT_EQ(1u, decoder_factory.decoders().size()); | 842 EXPECT_EQ(1u, decoder_factory.decoders().size()); |
826 | 843 |
827 std::vector<cricket::VideoDecoderParams> params = decoder_factory.params(); | 844 std::vector<cricket::VideoDecoderParams> params = decoder_factory.params(); |
(...skipping 30 matching lines...) Expand all Loading... |
858 | 875 |
859 WEBRTC_BASE_TEST(RemoveCapturerWithoutAdd); | 876 WEBRTC_BASE_TEST(RemoveCapturerWithoutAdd); |
860 | 877 |
861 WEBRTC_BASE_TEST(AddRemoveCapturerMultipleSources); | 878 WEBRTC_BASE_TEST(AddRemoveCapturerMultipleSources); |
862 | 879 |
863 WEBRTC_BASE_TEST(RejectEmptyStreamParams); | 880 WEBRTC_BASE_TEST(RejectEmptyStreamParams); |
864 | 881 |
865 WEBRTC_BASE_TEST(MultipleSendStreams); | 882 WEBRTC_BASE_TEST(MultipleSendStreams); |
866 | 883 |
867 TEST_F(WebRtcVideoChannel2BaseTest, SendAndReceiveVp8Vga) { | 884 TEST_F(WebRtcVideoChannel2BaseTest, SendAndReceiveVp8Vga) { |
868 SendAndReceive(cricket::VideoCodec(100, "VP8")); | 885 SendAndReceive(GetEngineCodec("VP8")); |
869 } | 886 } |
870 | 887 |
871 TEST_F(WebRtcVideoChannel2BaseTest, SendAndReceiveVp8Qvga) { | 888 TEST_F(WebRtcVideoChannel2BaseTest, SendAndReceiveVp8Qvga) { |
872 SendAndReceive(cricket::VideoCodec(100, "VP8")); | 889 SendAndReceive(GetEngineCodec("VP8")); |
873 } | 890 } |
874 | 891 |
875 TEST_F(WebRtcVideoChannel2BaseTest, SendAndReceiveVp8SvcQqvga) { | 892 TEST_F(WebRtcVideoChannel2BaseTest, SendAndReceiveVp8SvcQqvga) { |
876 SendAndReceive(cricket::VideoCodec(100, "VP8")); | 893 SendAndReceive(GetEngineCodec("VP8")); |
877 } | 894 } |
878 | 895 |
879 TEST_F(WebRtcVideoChannel2BaseTest, TwoStreamsSendAndReceive) { | 896 TEST_F(WebRtcVideoChannel2BaseTest, TwoStreamsSendAndReceive) { |
880 // Set a high bitrate to not be downscaled by VP8 due to low initial start | 897 // Set a high bitrate to not be downscaled by VP8 due to low initial start |
881 // bitrates. This currently happens at <250k, and two streams sharing 300k | 898 // bitrates. This currently happens at <250k, and two streams sharing 300k |
882 // initially will use QVGA instead of VGA. | 899 // initially will use QVGA instead of VGA. |
883 // TODO(pbos): Set up the quality scaler so that both senders reliably start | 900 // TODO(pbos): Set up the quality scaler so that both senders reliably start |
884 // at QVGA, then verify that instead. | 901 // at QVGA, then verify that instead. |
885 cricket::VideoCodec codec = kVp8Codec; | 902 cricket::VideoCodec codec = GetEngineCodec("VP8"); |
886 codec.params[kCodecParamStartBitrate] = "1000000"; | 903 codec.params[kCodecParamStartBitrate] = "1000000"; |
887 Base::TwoStreamsSendAndReceive(codec); | 904 Base::TwoStreamsSendAndReceive(codec); |
888 } | 905 } |
889 | 906 |
890 class WebRtcVideoChannel2Test : public WebRtcVideoEngine2Test { | 907 class WebRtcVideoChannel2Test : public WebRtcVideoEngine2Test { |
891 public: | 908 public: |
892 WebRtcVideoChannel2Test() : WebRtcVideoChannel2Test("") {} | 909 WebRtcVideoChannel2Test() : WebRtcVideoChannel2Test("") {} |
893 explicit WebRtcVideoChannel2Test(const char* field_trials) | 910 explicit WebRtcVideoChannel2Test(const char* field_trials) |
894 : WebRtcVideoEngine2Test(field_trials), last_ssrc_(0) {} | 911 : WebRtcVideoEngine2Test(field_trials), last_ssrc_(0) {} |
895 void SetUp() override { | 912 void SetUp() override { |
(...skipping 39 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
935 } | 952 } |
936 | 953 |
937 void SetSendCodecsShouldWorkForBitrates(const char* min_bitrate_kbps, | 954 void SetSendCodecsShouldWorkForBitrates(const char* min_bitrate_kbps, |
938 int expected_min_bitrate_bps, | 955 int expected_min_bitrate_bps, |
939 const char* start_bitrate_kbps, | 956 const char* start_bitrate_kbps, |
940 int expected_start_bitrate_bps, | 957 int expected_start_bitrate_bps, |
941 const char* max_bitrate_kbps, | 958 const char* max_bitrate_kbps, |
942 int expected_max_bitrate_bps) { | 959 int expected_max_bitrate_bps) { |
943 auto& codecs = send_parameters_.codecs; | 960 auto& codecs = send_parameters_.codecs; |
944 codecs.clear(); | 961 codecs.clear(); |
945 codecs.push_back(kVp8Codec); | 962 codecs.push_back(GetEngineCodec("VP8")); |
946 codecs[0].params[kCodecParamMinBitrate] = min_bitrate_kbps; | 963 codecs[0].params[kCodecParamMinBitrate] = min_bitrate_kbps; |
947 codecs[0].params[kCodecParamStartBitrate] = start_bitrate_kbps; | 964 codecs[0].params[kCodecParamStartBitrate] = start_bitrate_kbps; |
948 codecs[0].params[kCodecParamMaxBitrate] = max_bitrate_kbps; | 965 codecs[0].params[kCodecParamMaxBitrate] = max_bitrate_kbps; |
949 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); | 966 EXPECT_TRUE(channel_->SetSendParameters(send_parameters_)); |
950 | 967 |
951 EXPECT_EQ(expected_min_bitrate_bps, | 968 EXPECT_EQ(expected_min_bitrate_bps, |
952 fake_call_->GetConfig().bitrate_config.min_bitrate_bps); | 969 fake_call_->GetConfig().bitrate_config.min_bitrate_bps); |
953 EXPECT_EQ(expected_start_bitrate_bps, | 970 EXPECT_EQ(expected_start_bitrate_bps, |
954 fake_call_->GetConfig().bitrate_config.start_bitrate_bps); | 971 fake_call_->GetConfig().bitrate_config.start_bitrate_bps); |
955 EXPECT_EQ(expected_max_bitrate_bps, | 972 EXPECT_EQ(expected_max_bitrate_bps, |
(...skipping 91 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1047 // Verify that only one of them has been set, and that it is the one with | 1064 // Verify that only one of them has been set, and that it is the one with |
1048 // highest priority (transport sequence number). | 1065 // highest priority (transport sequence number). |
1049 ASSERT_EQ(1u, send_stream->GetConfig().rtp.extensions.size()); | 1066 ASSERT_EQ(1u, send_stream->GetConfig().rtp.extensions.size()); |
1050 EXPECT_EQ(expected_id, send_stream->GetConfig().rtp.extensions[0].id); | 1067 EXPECT_EQ(expected_id, send_stream->GetConfig().rtp.extensions[0].id); |
1051 EXPECT_EQ(expected_extension, | 1068 EXPECT_EQ(expected_extension, |
1052 send_stream->GetConfig().rtp.extensions[0].uri); | 1069 send_stream->GetConfig().rtp.extensions[0].uri); |
1053 } | 1070 } |
1054 | 1071 |
1055 void TestCpuAdaptation(bool enable_overuse, bool is_screenshare); | 1072 void TestCpuAdaptation(bool enable_overuse, bool is_screenshare); |
1056 void TestReceiverLocalSsrcConfiguration(bool receiver_first); | 1073 void TestReceiverLocalSsrcConfiguration(bool receiver_first); |
1057 void TestReceiveUnsignalledSsrcPacket(uint8_t payload_type, | 1074 void TestReceiveUnsignaledSsrcPacket(uint8_t payload_type, |
1058 bool expect_created_receive_stream); | 1075 bool expect_created_receive_stream); |
1059 | 1076 |
1060 FakeVideoSendStream* SetDenoisingOption( | 1077 FakeVideoSendStream* SetDenoisingOption( |
1061 uint32_t ssrc, | 1078 uint32_t ssrc, |
1062 cricket::FakeVideoCapturer* capturer, | 1079 cricket::FakeVideoCapturer* capturer, |
1063 bool enabled) { | 1080 bool enabled) { |
1064 cricket::VideoOptions options; | 1081 cricket::VideoOptions options; |
1065 options.video_noise_reduction = rtc::Optional<bool>(enabled); | 1082 options.video_noise_reduction = rtc::Optional<bool>(enabled); |
1066 EXPECT_TRUE(channel_->SetVideoSend(ssrc, true, &options, capturer)); | 1083 EXPECT_TRUE(channel_->SetVideoSend(ssrc, true, &options, capturer)); |
1067 // Options only take effect on the next frame. | 1084 // Options only take effect on the next frame. |
1068 EXPECT_TRUE(capturer->CaptureFrame()); | 1085 EXPECT_TRUE(capturer->CaptureFrame()); |
(...skipping 353 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1422 FakeVideoReceiveStream* stream = AddRecvStream(); | 1439 FakeVideoReceiveStream* stream = AddRecvStream(); |
1423 EXPECT_TRUE(stream->GetConfig().rtp.transport_cc); | 1440 EXPECT_TRUE(stream->GetConfig().rtp.transport_cc); |
1424 } | 1441 } |
1425 | 1442 |
1426 TEST_F(WebRtcVideoChannel2Test, RembCanBeEnabledAndDisabled) { | 1443 TEST_F(WebRtcVideoChannel2Test, RembCanBeEnabledAndDisabled) { |
1427 FakeVideoReceiveStream* stream = AddRecvStream(); | 1444 FakeVideoReceiveStream* stream = AddRecvStream(); |
1428 EXPECT_TRUE(stream->GetConfig().rtp.remb); | 1445 EXPECT_TRUE(stream->GetConfig().rtp.remb); |
1429 | 1446 |
1430 // Verify that REMB is turned off when send(!) codecs without REMB are set. | 1447 // Verify that REMB is turned off when send(!) codecs without REMB are set. |
1431 cricket::VideoSendParameters parameters; | 1448 cricket::VideoSendParameters parameters; |
1432 parameters.codecs.push_back(kVp8Codec); | 1449 parameters.codecs.push_back(RemoveFeedbackParams(GetEngineCodec("VP8"))); |
1433 EXPECT_TRUE(parameters.codecs[0].feedback_params.params().empty()); | 1450 EXPECT_TRUE(parameters.codecs[0].feedback_params.params().empty()); |
1434 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1451 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
1435 stream = fake_call_->GetVideoReceiveStreams()[0]; | 1452 stream = fake_call_->GetVideoReceiveStreams()[0]; |
1436 EXPECT_FALSE(stream->GetConfig().rtp.remb); | 1453 EXPECT_FALSE(stream->GetConfig().rtp.remb); |
1437 | 1454 |
1438 // Verify that REMB is turned on when setting default codecs since the | 1455 // Verify that REMB is turned on when setting default codecs since the |
1439 // default codecs have REMB enabled. | 1456 // default codecs have REMB enabled. |
1440 parameters.codecs = engine_.codecs(); | 1457 parameters.codecs = engine_.codecs(); |
1441 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1458 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
1442 stream = fake_call_->GetVideoReceiveStreams()[0]; | 1459 stream = fake_call_->GetVideoReceiveStreams()[0]; |
1443 EXPECT_TRUE(stream->GetConfig().rtp.remb); | 1460 EXPECT_TRUE(stream->GetConfig().rtp.remb); |
1444 } | 1461 } |
1445 | 1462 |
1446 TEST_F(WebRtcVideoChannel2Test, TransportCcCanBeEnabledAndDisabled) { | 1463 TEST_F(WebRtcVideoChannel2Test, TransportCcCanBeEnabledAndDisabled) { |
1447 FakeVideoReceiveStream* stream = AddRecvStream(); | 1464 FakeVideoReceiveStream* stream = AddRecvStream(); |
1448 EXPECT_TRUE(stream->GetConfig().rtp.transport_cc); | 1465 EXPECT_TRUE(stream->GetConfig().rtp.transport_cc); |
1449 | 1466 |
1450 // Verify that transport cc feedback is turned off when send(!) codecs without | 1467 // Verify that transport cc feedback is turned off when send(!) codecs without |
1451 // transport cc feedback are set. | 1468 // transport cc feedback are set. |
1452 cricket::VideoSendParameters parameters; | 1469 cricket::VideoSendParameters parameters; |
1453 parameters.codecs.push_back(kVp8Codec); | 1470 parameters.codecs.push_back(RemoveFeedbackParams(GetEngineCodec("VP8"))); |
1454 EXPECT_TRUE(parameters.codecs[0].feedback_params.params().empty()); | 1471 EXPECT_TRUE(parameters.codecs[0].feedback_params.params().empty()); |
1455 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1472 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
1456 stream = fake_call_->GetVideoReceiveStreams()[0]; | 1473 stream = fake_call_->GetVideoReceiveStreams()[0]; |
1457 EXPECT_FALSE(stream->GetConfig().rtp.transport_cc); | 1474 EXPECT_FALSE(stream->GetConfig().rtp.transport_cc); |
1458 | 1475 |
1459 // Verify that transport cc feedback is turned on when setting default codecs | 1476 // Verify that transport cc feedback is turned on when setting default codecs |
1460 // since the default codecs have transport cc feedback enabled. | 1477 // since the default codecs have transport cc feedback enabled. |
1461 parameters.codecs = engine_.codecs(); | 1478 parameters.codecs = engine_.codecs(); |
1462 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1479 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
1463 stream = fake_call_->GetVideoReceiveStreams()[0]; | 1480 stream = fake_call_->GetVideoReceiveStreams()[0]; |
(...skipping 25 matching lines...) Expand all Loading... |
1489 | 1506 |
1490 TEST_F(WebRtcVideoChannel2Test, NackCanBeEnabledAndDisabled) { | 1507 TEST_F(WebRtcVideoChannel2Test, NackCanBeEnabledAndDisabled) { |
1491 FakeVideoSendStream* send_stream = AddSendStream(); | 1508 FakeVideoSendStream* send_stream = AddSendStream(); |
1492 FakeVideoReceiveStream* recv_stream = AddRecvStream(); | 1509 FakeVideoReceiveStream* recv_stream = AddRecvStream(); |
1493 | 1510 |
1494 EXPECT_GT(recv_stream->GetConfig().rtp.nack.rtp_history_ms, 0); | 1511 EXPECT_GT(recv_stream->GetConfig().rtp.nack.rtp_history_ms, 0); |
1495 EXPECT_GT(send_stream->GetConfig().rtp.nack.rtp_history_ms, 0); | 1512 EXPECT_GT(send_stream->GetConfig().rtp.nack.rtp_history_ms, 0); |
1496 | 1513 |
1497 // Verify that NACK is turned off when send(!) codecs without NACK are set. | 1514 // Verify that NACK is turned off when send(!) codecs without NACK are set. |
1498 cricket::VideoSendParameters parameters; | 1515 cricket::VideoSendParameters parameters; |
1499 parameters.codecs.push_back(kVp8Codec); | 1516 parameters.codecs.push_back(RemoveFeedbackParams(GetEngineCodec("VP8"))); |
1500 EXPECT_TRUE(parameters.codecs[0].feedback_params.params().empty()); | 1517 EXPECT_TRUE(parameters.codecs[0].feedback_params.params().empty()); |
1501 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1518 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
1502 recv_stream = fake_call_->GetVideoReceiveStreams()[0]; | 1519 recv_stream = fake_call_->GetVideoReceiveStreams()[0]; |
1503 EXPECT_EQ(0, recv_stream->GetConfig().rtp.nack.rtp_history_ms); | 1520 EXPECT_EQ(0, recv_stream->GetConfig().rtp.nack.rtp_history_ms); |
1504 send_stream = fake_call_->GetVideoSendStreams()[0]; | 1521 send_stream = fake_call_->GetVideoSendStreams()[0]; |
1505 EXPECT_EQ(0, send_stream->GetConfig().rtp.nack.rtp_history_ms); | 1522 EXPECT_EQ(0, send_stream->GetConfig().rtp.nack.rtp_history_ms); |
1506 | 1523 |
1507 // Verify that NACK is turned on when setting default codecs since the | 1524 // Verify that NACK is turned on when setting default codecs since the |
1508 // default codecs have NACK enabled. | 1525 // default codecs have NACK enabled. |
1509 parameters.codecs = engine_.codecs(); | 1526 parameters.codecs = engine_.codecs(); |
1510 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1527 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
1511 recv_stream = fake_call_->GetVideoReceiveStreams()[0]; | 1528 recv_stream = fake_call_->GetVideoReceiveStreams()[0]; |
1512 EXPECT_GT(recv_stream->GetConfig().rtp.nack.rtp_history_ms, 0); | 1529 EXPECT_GT(recv_stream->GetConfig().rtp.nack.rtp_history_ms, 0); |
1513 send_stream = fake_call_->GetVideoSendStreams()[0]; | 1530 send_stream = fake_call_->GetVideoSendStreams()[0]; |
1514 EXPECT_GT(send_stream->GetConfig().rtp.nack.rtp_history_ms, 0); | 1531 EXPECT_GT(send_stream->GetConfig().rtp.nack.rtp_history_ms, 0); |
1515 } | 1532 } |
1516 | 1533 |
1517 // This test verifies that new frame sizes reconfigures encoders even though not | 1534 // This test verifies that new frame sizes reconfigures encoders even though not |
1518 // (yet) sending. The purpose of this is to permit encoding as quickly as | 1535 // (yet) sending. The purpose of this is to permit encoding as quickly as |
1519 // possible once we start sending. Likely the frames being input are from the | 1536 // possible once we start sending. Likely the frames being input are from the |
1520 // same source that will be sent later, which just means that we're ready | 1537 // same source that will be sent later, which just means that we're ready |
1521 // earlier. | 1538 // earlier. |
1522 TEST_F(WebRtcVideoChannel2Test, ReconfiguresEncodersWhenNotSending) { | 1539 TEST_F(WebRtcVideoChannel2Test, ReconfiguresEncodersWhenNotSending) { |
1523 cricket::VideoSendParameters parameters; | 1540 cricket::VideoSendParameters parameters; |
1524 parameters.codecs.push_back(kVp8Codec); | 1541 parameters.codecs.push_back(GetEngineCodec("VP8")); |
1525 ASSERT_TRUE(channel_->SetSendParameters(parameters)); | 1542 ASSERT_TRUE(channel_->SetSendParameters(parameters)); |
1526 channel_->SetSend(false); | 1543 channel_->SetSend(false); |
1527 | 1544 |
1528 FakeVideoSendStream* stream = AddSendStream(); | 1545 FakeVideoSendStream* stream = AddSendStream(); |
1529 | 1546 |
1530 // No frames entered. | 1547 // No frames entered. |
1531 std::vector<webrtc::VideoStream> streams = stream->GetVideoStreams(); | 1548 std::vector<webrtc::VideoStream> streams = stream->GetVideoStreams(); |
1532 EXPECT_EQ(0u, streams[0].width); | 1549 EXPECT_EQ(0u, streams[0].width); |
1533 EXPECT_EQ(0u, streams[0].height); | 1550 EXPECT_EQ(0u, streams[0].height); |
1534 | 1551 |
1535 cricket::FakeVideoCapturer capturer; | 1552 cricket::FakeVideoCapturer capturer; |
1536 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, nullptr, &capturer)); | 1553 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, nullptr, &capturer)); |
1537 VideoFormat capture_format = capturer.GetSupportedFormats()->front(); | 1554 VideoFormat capture_format = capturer.GetSupportedFormats()->front(); |
1538 EXPECT_EQ(cricket::CS_RUNNING, capturer.Start(capture_format)); | 1555 EXPECT_EQ(cricket::CS_RUNNING, capturer.Start(capture_format)); |
1539 EXPECT_TRUE(capturer.CaptureFrame()); | 1556 EXPECT_TRUE(capturer.CaptureFrame()); |
1540 | 1557 |
1541 // Frame entered, should be reconfigured to new dimensions. | 1558 // Frame entered, should be reconfigured to new dimensions. |
1542 streams = stream->GetVideoStreams(); | 1559 streams = stream->GetVideoStreams(); |
1543 EXPECT_EQ(capture_format.width, streams[0].width); | 1560 EXPECT_EQ(capture_format.width, streams[0].width); |
1544 EXPECT_EQ(capture_format.height, streams[0].height); | 1561 EXPECT_EQ(capture_format.height, streams[0].height); |
1545 | 1562 |
1546 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, nullptr, nullptr)); | 1563 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, nullptr, nullptr)); |
1547 } | 1564 } |
1548 | 1565 |
1549 TEST_F(WebRtcVideoChannel2Test, UsesCorrectSettingsForScreencast) { | 1566 TEST_F(WebRtcVideoChannel2Test, UsesCorrectSettingsForScreencast) { |
1550 static const int kScreenshareMinBitrateKbps = 800; | 1567 static const int kScreenshareMinBitrateKbps = 800; |
1551 cricket::VideoCodec codec = kVp8Codec; | 1568 cricket::VideoCodec codec = GetEngineCodec("VP8"); |
1552 cricket::VideoSendParameters parameters; | 1569 cricket::VideoSendParameters parameters; |
1553 parameters.codecs.push_back(codec); | 1570 parameters.codecs.push_back(codec); |
1554 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 1571 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
1555 AddSendStream(); | 1572 AddSendStream(); |
1556 | 1573 |
1557 cricket::FakeVideoCapturer capturer; | 1574 cricket::FakeVideoCapturer capturer; |
1558 VideoOptions min_bitrate_options; | 1575 VideoOptions min_bitrate_options; |
1559 min_bitrate_options.screencast_min_bitrate_kbps = | 1576 min_bitrate_options.screencast_min_bitrate_kbps = |
1560 rtc::Optional<int>(kScreenshareMinBitrateKbps); | 1577 rtc::Optional<int>(kScreenshareMinBitrateKbps); |
1561 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, &min_bitrate_options, | 1578 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, &min_bitrate_options, |
(...skipping 168 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1730 | 1747 |
1731 TEST_F(WebRtcVideoChannel2Test, Vp8DenoisingEnabledByDefault) { | 1748 TEST_F(WebRtcVideoChannel2Test, Vp8DenoisingEnabledByDefault) { |
1732 FakeVideoSendStream* stream = AddSendStream(); | 1749 FakeVideoSendStream* stream = AddSendStream(); |
1733 webrtc::VideoCodecVP8 vp8_settings; | 1750 webrtc::VideoCodecVP8 vp8_settings; |
1734 ASSERT_TRUE(stream->GetVp8Settings(&vp8_settings)) << "No VP8 config set."; | 1751 ASSERT_TRUE(stream->GetVp8Settings(&vp8_settings)) << "No VP8 config set."; |
1735 EXPECT_TRUE(vp8_settings.denoisingOn); | 1752 EXPECT_TRUE(vp8_settings.denoisingOn); |
1736 } | 1753 } |
1737 | 1754 |
1738 TEST_F(WebRtcVideoChannel2Test, VerifyVp8SpecificSettings) { | 1755 TEST_F(WebRtcVideoChannel2Test, VerifyVp8SpecificSettings) { |
1739 cricket::VideoSendParameters parameters; | 1756 cricket::VideoSendParameters parameters; |
1740 parameters.codecs.push_back(kVp8Codec); | 1757 parameters.codecs.push_back(GetEngineCodec("VP8")); |
1741 ASSERT_TRUE(channel_->SetSendParameters(parameters)); | 1758 ASSERT_TRUE(channel_->SetSendParameters(parameters)); |
1742 | 1759 |
1743 // Single-stream settings should apply with RTX as well (verifies that we | 1760 // Single-stream settings should apply with RTX as well (verifies that we |
1744 // check number of regular SSRCs and not StreamParams::ssrcs which contains | 1761 // check number of regular SSRCs and not StreamParams::ssrcs which contains |
1745 // both RTX and regular SSRCs). | 1762 // both RTX and regular SSRCs). |
1746 FakeVideoSendStream* stream = SetUpSimulcast(false, true); | 1763 FakeVideoSendStream* stream = SetUpSimulcast(false, true); |
1747 | 1764 |
1748 cricket::FakeVideoCapturer capturer; | 1765 cricket::FakeVideoCapturer capturer; |
1749 EXPECT_EQ(cricket::CS_RUNNING, | 1766 EXPECT_EQ(cricket::CS_RUNNING, |
1750 capturer.Start(capturer.GetSupportedFormats()->front())); | 1767 capturer.Start(capturer.GetSupportedFormats()->front())); |
(...skipping 60 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1811 // Test that setting the same options doesn't result in the encoder being | 1828 // Test that setting the same options doesn't result in the encoder being |
1812 // reconfigured. | 1829 // reconfigured. |
1813 TEST_F(WebRtcVideoChannel2Test, SetIdenticalOptionsDoesntReconfigureEncoder) { | 1830 TEST_F(WebRtcVideoChannel2Test, SetIdenticalOptionsDoesntReconfigureEncoder) { |
1814 VideoOptions options; | 1831 VideoOptions options; |
1815 cricket::FakeVideoCapturer capturer; | 1832 cricket::FakeVideoCapturer capturer; |
1816 | 1833 |
1817 AddSendStream(); | 1834 AddSendStream(); |
1818 EXPECT_EQ(cricket::CS_RUNNING, | 1835 EXPECT_EQ(cricket::CS_RUNNING, |
1819 capturer.Start(capturer.GetSupportedFormats()->front())); | 1836 capturer.Start(capturer.GetSupportedFormats()->front())); |
1820 cricket::VideoSendParameters parameters; | 1837 cricket::VideoSendParameters parameters; |
1821 parameters.codecs.push_back(kVp8Codec); | 1838 parameters.codecs.push_back(GetEngineCodec("VP8")); |
1822 ASSERT_TRUE(channel_->SetSendParameters(parameters)); | 1839 ASSERT_TRUE(channel_->SetSendParameters(parameters)); |
1823 FakeVideoSendStream* send_stream = fake_call_->GetVideoSendStreams().front(); | 1840 FakeVideoSendStream* send_stream = fake_call_->GetVideoSendStreams().front(); |
1824 | 1841 |
1825 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, &options, &capturer)); | 1842 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, &options, &capturer)); |
1826 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, &options, &capturer)); | 1843 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, &options, &capturer)); |
1827 EXPECT_TRUE(capturer.CaptureFrame()); | 1844 EXPECT_TRUE(capturer.CaptureFrame()); |
1828 // Expect 1 reconfigurations at this point from the initial configuration. | 1845 // Expect 1 reconfigurations at this point from the initial configuration. |
1829 EXPECT_EQ(1, send_stream->num_encoder_reconfigurations()); | 1846 EXPECT_EQ(1, send_stream->num_encoder_reconfigurations()); |
1830 | 1847 |
1831 // Set the options one more time and expect no additional reconfigurations. | 1848 // Set the options one more time and expect no additional reconfigurations. |
(...skipping 28 matching lines...) Expand all Loading... |
1860 // Remove references to encoder_factory_ since this will be destroyed | 1877 // Remove references to encoder_factory_ since this will be destroyed |
1861 // before channel_ and engine_. | 1878 // before channel_ and engine_. |
1862 ASSERT_TRUE(channel_->SetSendParameters(send_parameters_)); | 1879 ASSERT_TRUE(channel_->SetSendParameters(send_parameters_)); |
1863 } | 1880 } |
1864 | 1881 |
1865 cricket::FakeWebRtcVideoEncoderFactory encoder_factory_; | 1882 cricket::FakeWebRtcVideoEncoderFactory encoder_factory_; |
1866 }; | 1883 }; |
1867 | 1884 |
1868 TEST_F(Vp9SettingsTest, VerifyVp9SpecificSettings) { | 1885 TEST_F(Vp9SettingsTest, VerifyVp9SpecificSettings) { |
1869 cricket::VideoSendParameters parameters; | 1886 cricket::VideoSendParameters parameters; |
1870 parameters.codecs.push_back(kVp9Codec); | 1887 parameters.codecs.push_back(GetEngineCodec("VP9")); |
1871 ASSERT_TRUE(channel_->SetSendParameters(parameters)); | 1888 ASSERT_TRUE(channel_->SetSendParameters(parameters)); |
1872 | 1889 |
1873 FakeVideoSendStream* stream = SetUpSimulcast(false, false); | 1890 FakeVideoSendStream* stream = SetUpSimulcast(false, false); |
1874 | 1891 |
1875 cricket::FakeVideoCapturer capturer; | 1892 cricket::FakeVideoCapturer capturer; |
1876 EXPECT_EQ(cricket::CS_RUNNING, | 1893 EXPECT_EQ(cricket::CS_RUNNING, |
1877 capturer.Start(capturer.GetSupportedFormats()->front())); | 1894 capturer.Start(capturer.GetSupportedFormats()->front())); |
1878 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, nullptr, &capturer)); | 1895 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, nullptr, &capturer)); |
1879 channel_->SetSend(true); | 1896 channel_->SetSend(true); |
1880 | 1897 |
(...skipping 39 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1920 } | 1937 } |
1921 | 1938 |
1922 class Vp9SettingsTestWithFieldTrial : public Vp9SettingsTest { | 1939 class Vp9SettingsTestWithFieldTrial : public Vp9SettingsTest { |
1923 public: | 1940 public: |
1924 Vp9SettingsTestWithFieldTrial(const char* field_trials) | 1941 Vp9SettingsTestWithFieldTrial(const char* field_trials) |
1925 : Vp9SettingsTest(field_trials) {} | 1942 : Vp9SettingsTest(field_trials) {} |
1926 | 1943 |
1927 protected: | 1944 protected: |
1928 void VerifySettings(int num_spatial_layers, int num_temporal_layers) { | 1945 void VerifySettings(int num_spatial_layers, int num_temporal_layers) { |
1929 cricket::VideoSendParameters parameters; | 1946 cricket::VideoSendParameters parameters; |
1930 parameters.codecs.push_back(kVp9Codec); | 1947 parameters.codecs.push_back(GetEngineCodec("VP9")); |
1931 ASSERT_TRUE(channel_->SetSendParameters(parameters)); | 1948 ASSERT_TRUE(channel_->SetSendParameters(parameters)); |
1932 | 1949 |
1933 FakeVideoSendStream* stream = SetUpSimulcast(false, false); | 1950 FakeVideoSendStream* stream = SetUpSimulcast(false, false); |
1934 | 1951 |
1935 cricket::FakeVideoCapturer capturer; | 1952 cricket::FakeVideoCapturer capturer; |
1936 EXPECT_EQ(cricket::CS_RUNNING, | 1953 EXPECT_EQ(cricket::CS_RUNNING, |
1937 capturer.Start(capturer.GetSupportedFormats()->front())); | 1954 capturer.Start(capturer.GetSupportedFormats()->front())); |
1938 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, nullptr, &capturer)); | 1955 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, nullptr, &capturer)); |
1939 channel_->SetSend(true); | 1956 channel_->SetSend(true); |
1940 | 1957 |
(...skipping 50 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1991 | 2008 |
1992 TEST_F(WebRtcVideoChannel2Test, DoesNotAdaptOnOveruseWhenDisabled) { | 2009 TEST_F(WebRtcVideoChannel2Test, DoesNotAdaptOnOveruseWhenDisabled) { |
1993 TestCpuAdaptation(false, false); | 2010 TestCpuAdaptation(false, false); |
1994 } | 2011 } |
1995 | 2012 |
1996 TEST_F(WebRtcVideoChannel2Test, DoesNotAdaptOnOveruseWhenScreensharing) { | 2013 TEST_F(WebRtcVideoChannel2Test, DoesNotAdaptOnOveruseWhenScreensharing) { |
1997 TestCpuAdaptation(true, true); | 2014 TestCpuAdaptation(true, true); |
1998 } | 2015 } |
1999 | 2016 |
2000 TEST_F(WebRtcVideoChannel2Test, AdaptsOnOveruseAndChangeResolution) { | 2017 TEST_F(WebRtcVideoChannel2Test, AdaptsOnOveruseAndChangeResolution) { |
2001 cricket::VideoCodec codec = kVp8Codec; | 2018 cricket::VideoCodec codec = GetEngineCodec("VP8"); |
2002 cricket::VideoSendParameters parameters; | 2019 cricket::VideoSendParameters parameters; |
2003 parameters.codecs.push_back(codec); | 2020 parameters.codecs.push_back(codec); |
2004 | 2021 |
2005 MediaConfig media_config = MediaConfig(); | 2022 MediaConfig media_config = MediaConfig(); |
2006 channel_.reset( | 2023 channel_.reset( |
2007 engine_.CreateChannel(fake_call_.get(), media_config, VideoOptions())); | 2024 engine_.CreateChannel(fake_call_.get(), media_config, VideoOptions())); |
2008 ASSERT_TRUE(channel_->SetSendParameters(parameters)); | 2025 ASSERT_TRUE(channel_->SetSendParameters(parameters)); |
2009 | 2026 |
2010 AddSendStream(); | 2027 AddSendStream(); |
2011 | 2028 |
(...skipping 53 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2065 send_stream->InjectVideoSinkWants(wants); | 2082 send_stream->InjectVideoSinkWants(wants); |
2066 EXPECT_TRUE(capturer.CaptureCustomFrame(1284, 724, cricket::FOURCC_I420)); | 2083 EXPECT_TRUE(capturer.CaptureCustomFrame(1284, 724, cricket::FOURCC_I420)); |
2067 EXPECT_EQ(6, send_stream->GetNumberOfSwappedFrames()); | 2084 EXPECT_EQ(6, send_stream->GetNumberOfSwappedFrames()); |
2068 EXPECT_EQ(1284, send_stream->GetLastWidth()); | 2085 EXPECT_EQ(1284, send_stream->GetLastWidth()); |
2069 EXPECT_EQ(724, send_stream->GetLastHeight()); | 2086 EXPECT_EQ(724, send_stream->GetLastHeight()); |
2070 | 2087 |
2071 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, nullptr, nullptr)); | 2088 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, nullptr, nullptr)); |
2072 } | 2089 } |
2073 | 2090 |
2074 TEST_F(WebRtcVideoChannel2Test, PreviousAdaptationDoesNotApplyToScreenshare) { | 2091 TEST_F(WebRtcVideoChannel2Test, PreviousAdaptationDoesNotApplyToScreenshare) { |
2075 cricket::VideoCodec codec = kVp8Codec; | 2092 cricket::VideoCodec codec = GetEngineCodec("VP8"); |
2076 cricket::VideoSendParameters parameters; | 2093 cricket::VideoSendParameters parameters; |
2077 parameters.codecs.push_back(codec); | 2094 parameters.codecs.push_back(codec); |
2078 | 2095 |
2079 MediaConfig media_config = MediaConfig(); | 2096 MediaConfig media_config = MediaConfig(); |
2080 channel_.reset( | 2097 channel_.reset( |
2081 engine_.CreateChannel(fake_call_.get(), media_config, VideoOptions())); | 2098 engine_.CreateChannel(fake_call_.get(), media_config, VideoOptions())); |
2082 ASSERT_TRUE(channel_->SetSendParameters(parameters)); | 2099 ASSERT_TRUE(channel_->SetSendParameters(parameters)); |
2083 | 2100 |
2084 AddSendStream(); | 2101 AddSendStream(); |
2085 | 2102 |
(...skipping 43 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2129 EXPECT_TRUE(capturer.CaptureCustomFrame(1280, 720, cricket::FOURCC_I420)); | 2146 EXPECT_TRUE(capturer.CaptureCustomFrame(1280, 720, cricket::FOURCC_I420)); |
2130 EXPECT_EQ(4, send_stream->GetNumberOfSwappedFrames()); | 2147 EXPECT_EQ(4, send_stream->GetNumberOfSwappedFrames()); |
2131 EXPECT_EQ(1280 * 3 / 4, send_stream->GetLastWidth()); | 2148 EXPECT_EQ(1280 * 3 / 4, send_stream->GetLastWidth()); |
2132 EXPECT_EQ(720 * 3 / 4, send_stream->GetLastHeight()); | 2149 EXPECT_EQ(720 * 3 / 4, send_stream->GetLastHeight()); |
2133 | 2150 |
2134 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, nullptr, nullptr)); | 2151 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, nullptr, nullptr)); |
2135 } | 2152 } |
2136 | 2153 |
2137 void WebRtcVideoChannel2Test::TestCpuAdaptation(bool enable_overuse, | 2154 void WebRtcVideoChannel2Test::TestCpuAdaptation(bool enable_overuse, |
2138 bool is_screenshare) { | 2155 bool is_screenshare) { |
2139 cricket::VideoCodec codec = kVp8Codec; | 2156 cricket::VideoCodec codec = GetEngineCodec("VP8"); |
2140 cricket::VideoSendParameters parameters; | 2157 cricket::VideoSendParameters parameters; |
2141 parameters.codecs.push_back(codec); | 2158 parameters.codecs.push_back(codec); |
2142 | 2159 |
2143 MediaConfig media_config = MediaConfig(); | 2160 MediaConfig media_config = MediaConfig(); |
2144 if (!enable_overuse) { | 2161 if (!enable_overuse) { |
2145 media_config.video.enable_cpu_overuse_detection = false; | 2162 media_config.video.enable_cpu_overuse_detection = false; |
2146 } | 2163 } |
2147 channel_.reset( | 2164 channel_.reset( |
2148 engine_.CreateChannel(fake_call_.get(), media_config, VideoOptions())); | 2165 engine_.CreateChannel(fake_call_.get(), media_config, VideoOptions())); |
2149 | 2166 |
(...skipping 103 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2253 | 2270 |
2254 // Using a RTX setup to verify that the default RTX payload type is good. | 2271 // Using a RTX setup to verify that the default RTX payload type is good. |
2255 const std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs1); | 2272 const std::vector<uint32_t> ssrcs = MAKE_VECTOR(kSsrcs1); |
2256 const std::vector<uint32_t> rtx_ssrcs = MAKE_VECTOR(kRtxSsrcs1); | 2273 const std::vector<uint32_t> rtx_ssrcs = MAKE_VECTOR(kRtxSsrcs1); |
2257 FakeVideoSendStream* stream = AddSendStream( | 2274 FakeVideoSendStream* stream = AddSendStream( |
2258 cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs)); | 2275 cricket::CreateSimWithRtxStreamParams("cname", ssrcs, rtx_ssrcs)); |
2259 webrtc::VideoSendStream::Config config = stream->GetConfig().Copy(); | 2276 webrtc::VideoSendStream::Config config = stream->GetConfig().Copy(); |
2260 | 2277 |
2261 // Make sure NACK and FEC are enabled on the correct payload types. | 2278 // Make sure NACK and FEC are enabled on the correct payload types. |
2262 EXPECT_EQ(1000, config.rtp.nack.rtp_history_ms); | 2279 EXPECT_EQ(1000, config.rtp.nack.rtp_history_ms); |
2263 EXPECT_EQ(default_ulpfec_codec_.id, config.rtp.ulpfec.ulpfec_payload_type); | 2280 EXPECT_EQ(GetEngineCodec("ulpfec").id, config.rtp.ulpfec.ulpfec_payload_type); |
2264 EXPECT_EQ(default_red_codec_.id, config.rtp.ulpfec.red_payload_type); | 2281 EXPECT_EQ(GetEngineCodec("red").id, config.rtp.ulpfec.red_payload_type); |
2265 | 2282 |
2266 EXPECT_EQ(1u, config.rtp.rtx.ssrcs.size()); | 2283 EXPECT_EQ(1u, config.rtp.rtx.ssrcs.size()); |
2267 EXPECT_EQ(kRtxSsrcs1[0], config.rtp.rtx.ssrcs[0]); | 2284 EXPECT_EQ(kRtxSsrcs1[0], config.rtp.rtx.ssrcs[0]); |
2268 VerifySendStreamHasRtxTypes(config, default_apt_rtx_types_); | 2285 VerifySendStreamHasRtxTypes(config, default_apt_rtx_types_); |
2269 // TODO(juberti): Check RTCP, PLI, TMMBR. | 2286 // TODO(juberti): Check RTCP, PLI, TMMBR. |
2270 } | 2287 } |
2271 | 2288 |
2272 TEST_F(WebRtcVideoChannel2Test, SetSendCodecsWithoutFec) { | 2289 TEST_F(WebRtcVideoChannel2Test, SetSendCodecsWithoutFec) { |
2273 cricket::VideoSendParameters parameters; | 2290 cricket::VideoSendParameters parameters; |
2274 parameters.codecs.push_back(kVp8Codec); | 2291 parameters.codecs.push_back(GetEngineCodec("VP8")); |
2275 ASSERT_TRUE(channel_->SetSendParameters(parameters)); | 2292 ASSERT_TRUE(channel_->SetSendParameters(parameters)); |
2276 | 2293 |
2277 FakeVideoSendStream* stream = AddSendStream(); | 2294 FakeVideoSendStream* stream = AddSendStream(); |
2278 webrtc::VideoSendStream::Config config = stream->GetConfig().Copy(); | 2295 webrtc::VideoSendStream::Config config = stream->GetConfig().Copy(); |
2279 | 2296 |
2280 EXPECT_EQ(-1, config.rtp.ulpfec.ulpfec_payload_type); | 2297 EXPECT_EQ(-1, config.rtp.ulpfec.ulpfec_payload_type); |
2281 EXPECT_EQ(-1, config.rtp.ulpfec.red_payload_type); | 2298 EXPECT_EQ(-1, config.rtp.ulpfec.red_payload_type); |
2282 } | 2299 } |
2283 | 2300 |
2284 TEST_F(WebRtcVideoChannel2Test, | 2301 TEST_F(WebRtcVideoChannel2Test, |
2285 SetSendCodecRejectsRtxWithoutAssociatedPayloadType) { | 2302 SetSendCodecRejectsRtxWithoutAssociatedPayloadType) { |
| 2303 const int kUnusedPayloadType = 127; |
| 2304 EXPECT_FALSE(FindCodecById(engine_.codecs(), kUnusedPayloadType)); |
| 2305 |
2286 cricket::VideoSendParameters parameters; | 2306 cricket::VideoSendParameters parameters; |
2287 cricket::VideoCodec rtx_codec(96, "rtx"); | 2307 cricket::VideoCodec rtx_codec(kUnusedPayloadType, "rtx"); |
2288 parameters.codecs.push_back(rtx_codec); | 2308 parameters.codecs.push_back(rtx_codec); |
2289 EXPECT_FALSE(channel_->SetSendParameters(parameters)) | 2309 EXPECT_FALSE(channel_->SetSendParameters(parameters)) |
2290 << "RTX codec without associated payload type should be rejected."; | 2310 << "RTX codec without associated payload type should be rejected."; |
2291 } | 2311 } |
2292 | 2312 |
2293 TEST_F(WebRtcVideoChannel2Test, | 2313 TEST_F(WebRtcVideoChannel2Test, |
2294 SetSendCodecRejectsRtxWithoutMatchingVideoCodec) { | 2314 SetSendCodecRejectsRtxWithoutMatchingVideoCodec) { |
2295 cricket::VideoSendParameters parameters; | 2315 const int kUnusedPayloadType1 = 126; |
2296 cricket::VideoCodec rtx_codec = | 2316 const int kUnusedPayloadType2 = 127; |
2297 cricket::VideoCodec::CreateRtxCodec(96, kVp8Codec.id); | 2317 EXPECT_FALSE(FindCodecById(engine_.codecs(), kUnusedPayloadType1)); |
2298 parameters.codecs.push_back(kVp8Codec); | 2318 EXPECT_FALSE(FindCodecById(engine_.codecs(), kUnusedPayloadType2)); |
2299 parameters.codecs.push_back(rtx_codec); | 2319 { |
2300 ASSERT_TRUE(channel_->SetSendParameters(parameters)); | 2320 cricket::VideoCodec rtx_codec = cricket::VideoCodec::CreateRtxCodec( |
2301 | 2321 kUnusedPayloadType1, GetEngineCodec("VP8").id); |
2302 cricket::VideoCodec rtx_codec2 = | 2322 cricket::VideoSendParameters parameters; |
2303 cricket::VideoCodec::CreateRtxCodec(96, kVp8Codec.id + 1); | 2323 parameters.codecs.push_back(GetEngineCodec("VP8")); |
2304 parameters.codecs.pop_back(); | 2324 parameters.codecs.push_back(rtx_codec); |
2305 parameters.codecs.push_back(rtx_codec2); | 2325 ASSERT_TRUE(channel_->SetSendParameters(parameters)); |
2306 EXPECT_FALSE(channel_->SetSendParameters(parameters)) | 2326 } |
2307 << "RTX without matching video codec should be rejected."; | 2327 { |
| 2328 cricket::VideoCodec rtx_codec = cricket::VideoCodec::CreateRtxCodec( |
| 2329 kUnusedPayloadType1, kUnusedPayloadType2); |
| 2330 cricket::VideoSendParameters parameters; |
| 2331 parameters.codecs.push_back(GetEngineCodec("VP8")); |
| 2332 parameters.codecs.push_back(rtx_codec); |
| 2333 EXPECT_FALSE(channel_->SetSendParameters(parameters)) |
| 2334 << "RTX without matching video codec should be rejected."; |
| 2335 } |
2308 } | 2336 } |
2309 | 2337 |
2310 TEST_F(WebRtcVideoChannel2Test, SetSendCodecsWithoutFecDisablesFec) { | 2338 TEST_F(WebRtcVideoChannel2Test, SetSendCodecsWithoutFecDisablesFec) { |
2311 cricket::VideoSendParameters parameters; | 2339 cricket::VideoSendParameters parameters; |
2312 parameters.codecs.push_back(kVp8Codec); | 2340 parameters.codecs.push_back(GetEngineCodec("VP8")); |
2313 parameters.codecs.push_back(kUlpfecCodec); | 2341 parameters.codecs.push_back(GetEngineCodec("ulpfec")); |
2314 ASSERT_TRUE(channel_->SetSendParameters(parameters)); | 2342 ASSERT_TRUE(channel_->SetSendParameters(parameters)); |
2315 | 2343 |
2316 FakeVideoSendStream* stream = AddSendStream(); | 2344 FakeVideoSendStream* stream = AddSendStream(); |
2317 webrtc::VideoSendStream::Config config = stream->GetConfig().Copy(); | 2345 webrtc::VideoSendStream::Config config = stream->GetConfig().Copy(); |
2318 | 2346 |
2319 EXPECT_EQ(kUlpfecCodec.id, config.rtp.ulpfec.ulpfec_payload_type); | 2347 EXPECT_EQ(GetEngineCodec("ulpfec").id, config.rtp.ulpfec.ulpfec_payload_type); |
2320 | 2348 |
2321 parameters.codecs.pop_back(); | 2349 parameters.codecs.pop_back(); |
2322 ASSERT_TRUE(channel_->SetSendParameters(parameters)); | 2350 ASSERT_TRUE(channel_->SetSendParameters(parameters)); |
2323 stream = fake_call_->GetVideoSendStreams()[0]; | 2351 stream = fake_call_->GetVideoSendStreams()[0]; |
2324 ASSERT_TRUE(stream != NULL); | 2352 ASSERT_TRUE(stream != NULL); |
2325 config = stream->GetConfig().Copy(); | 2353 config = stream->GetConfig().Copy(); |
2326 EXPECT_EQ(-1, config.rtp.ulpfec.ulpfec_payload_type) | 2354 EXPECT_EQ(-1, config.rtp.ulpfec.ulpfec_payload_type) |
2327 << "SetSendCodec without FEC should disable current FEC."; | 2355 << "SetSendCodec without FEC should disable current FEC."; |
2328 } | 2356 } |
2329 | 2357 |
(...skipping 124 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2454 send_parameters_.max_bandwidth_bps = 77777; | 2482 send_parameters_.max_bandwidth_bps = 77777; |
2455 ASSERT_TRUE(channel_->SetSendParameters(send_parameters_)); | 2483 ASSERT_TRUE(channel_->SetSendParameters(send_parameters_)); |
2456 EXPECT_EQ(send_parameters_.max_bandwidth_bps, | 2484 EXPECT_EQ(send_parameters_.max_bandwidth_bps, |
2457 fake_call_->GetConfig().bitrate_config.max_bitrate_bps); | 2485 fake_call_->GetConfig().bitrate_config.max_bitrate_bps); |
2458 EXPECT_EQ(send_parameters_.max_bandwidth_bps, | 2486 EXPECT_EQ(send_parameters_.max_bandwidth_bps, |
2459 stream->GetVideoStreams()[0].max_bitrate_bps); | 2487 stream->GetVideoStreams()[0].max_bitrate_bps); |
2460 } | 2488 } |
2461 | 2489 |
2462 TEST_F(WebRtcVideoChannel2Test, SetMaxSendBitrateCanIncreaseSenderBitrate) { | 2490 TEST_F(WebRtcVideoChannel2Test, SetMaxSendBitrateCanIncreaseSenderBitrate) { |
2463 cricket::VideoSendParameters parameters; | 2491 cricket::VideoSendParameters parameters; |
2464 parameters.codecs.push_back(kVp8Codec); | 2492 parameters.codecs.push_back(GetEngineCodec("VP8")); |
2465 ASSERT_TRUE(channel_->SetSendParameters(parameters)); | 2493 ASSERT_TRUE(channel_->SetSendParameters(parameters)); |
2466 channel_->SetSend(true); | 2494 channel_->SetSend(true); |
2467 | 2495 |
2468 FakeVideoSendStream* stream = AddSendStream(); | 2496 FakeVideoSendStream* stream = AddSendStream(); |
2469 | 2497 |
2470 cricket::FakeVideoCapturer capturer; | 2498 cricket::FakeVideoCapturer capturer; |
2471 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, nullptr, &capturer)); | 2499 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, nullptr, &capturer)); |
2472 EXPECT_EQ(cricket::CS_RUNNING, | 2500 EXPECT_EQ(cricket::CS_RUNNING, |
2473 capturer.Start(capturer.GetSupportedFormats()->front())); | 2501 capturer.Start(capturer.GetSupportedFormats()->front())); |
2474 | 2502 |
2475 std::vector<webrtc::VideoStream> streams = stream->GetVideoStreams(); | 2503 std::vector<webrtc::VideoStream> streams = stream->GetVideoStreams(); |
2476 int initial_max_bitrate_bps = streams[0].max_bitrate_bps; | 2504 int initial_max_bitrate_bps = streams[0].max_bitrate_bps; |
2477 EXPECT_GT(initial_max_bitrate_bps, 0); | 2505 EXPECT_GT(initial_max_bitrate_bps, 0); |
2478 | 2506 |
2479 parameters.max_bandwidth_bps = initial_max_bitrate_bps * 2; | 2507 parameters.max_bandwidth_bps = initial_max_bitrate_bps * 2; |
2480 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 2508 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
2481 // Insert a frame to update the encoder config. | 2509 // Insert a frame to update the encoder config. |
2482 EXPECT_TRUE(capturer.CaptureFrame()); | 2510 EXPECT_TRUE(capturer.CaptureFrame()); |
2483 streams = stream->GetVideoStreams(); | 2511 streams = stream->GetVideoStreams(); |
2484 EXPECT_EQ(initial_max_bitrate_bps * 2, streams[0].max_bitrate_bps); | 2512 EXPECT_EQ(initial_max_bitrate_bps * 2, streams[0].max_bitrate_bps); |
2485 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, nullptr, nullptr)); | 2513 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, nullptr, nullptr)); |
2486 } | 2514 } |
2487 | 2515 |
2488 TEST_F(WebRtcVideoChannel2Test, | 2516 TEST_F(WebRtcVideoChannel2Test, |
2489 SetMaxSendBitrateCanIncreaseSimulcastSenderBitrate) { | 2517 SetMaxSendBitrateCanIncreaseSimulcastSenderBitrate) { |
2490 cricket::VideoSendParameters parameters; | 2518 cricket::VideoSendParameters parameters; |
2491 parameters.codecs.push_back(kVp8Codec); | 2519 parameters.codecs.push_back(GetEngineCodec("VP8")); |
2492 ASSERT_TRUE(channel_->SetSendParameters(parameters)); | 2520 ASSERT_TRUE(channel_->SetSendParameters(parameters)); |
2493 channel_->SetSend(true); | 2521 channel_->SetSend(true); |
2494 | 2522 |
2495 FakeVideoSendStream* stream = AddSendStream( | 2523 FakeVideoSendStream* stream = AddSendStream( |
2496 cricket::CreateSimStreamParams("cname", MAKE_VECTOR(kSsrcs3))); | 2524 cricket::CreateSimStreamParams("cname", MAKE_VECTOR(kSsrcs3))); |
2497 | 2525 |
2498 // Send a frame to make sure this scales up to >1 stream (simulcast). | 2526 // Send a frame to make sure this scales up to >1 stream (simulcast). |
2499 cricket::FakeVideoCapturer capturer; | 2527 cricket::FakeVideoCapturer capturer; |
2500 EXPECT_TRUE(channel_->SetVideoSend(kSsrcs3[0], true, nullptr, &capturer)); | 2528 EXPECT_TRUE(channel_->SetVideoSend(kSsrcs3[0], true, nullptr, &capturer)); |
2501 EXPECT_EQ(cricket::CS_RUNNING, | 2529 EXPECT_EQ(cricket::CS_RUNNING, |
(...skipping 13 matching lines...) Expand all Loading... |
2515 streams = stream->GetVideoStreams(); | 2543 streams = stream->GetVideoStreams(); |
2516 int increased_max_bitrate_bps = GetTotalMaxBitrateBps(streams); | 2544 int increased_max_bitrate_bps = GetTotalMaxBitrateBps(streams); |
2517 EXPECT_EQ(initial_max_bitrate_bps * 2, increased_max_bitrate_bps); | 2545 EXPECT_EQ(initial_max_bitrate_bps * 2, increased_max_bitrate_bps); |
2518 | 2546 |
2519 EXPECT_TRUE(channel_->SetVideoSend(kSsrcs3[0], true, nullptr, nullptr)); | 2547 EXPECT_TRUE(channel_->SetVideoSend(kSsrcs3[0], true, nullptr, nullptr)); |
2520 } | 2548 } |
2521 | 2549 |
2522 TEST_F(WebRtcVideoChannel2Test, SetSendCodecsWithMaxQuantization) { | 2550 TEST_F(WebRtcVideoChannel2Test, SetSendCodecsWithMaxQuantization) { |
2523 static const char* kMaxQuantization = "21"; | 2551 static const char* kMaxQuantization = "21"; |
2524 cricket::VideoSendParameters parameters; | 2552 cricket::VideoSendParameters parameters; |
2525 parameters.codecs.push_back(kVp8Codec); | 2553 parameters.codecs.push_back(GetEngineCodec("VP8")); |
2526 parameters.codecs[0].params[kCodecParamMaxQuantization] = kMaxQuantization; | 2554 parameters.codecs[0].params[kCodecParamMaxQuantization] = kMaxQuantization; |
2527 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 2555 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
2528 EXPECT_EQ(static_cast<unsigned int>(atoi(kMaxQuantization)), | 2556 EXPECT_EQ(static_cast<unsigned int>(atoi(kMaxQuantization)), |
2529 AddSendStream()->GetVideoStreams().back().max_qp); | 2557 AddSendStream()->GetVideoStreams().back().max_qp); |
2530 | 2558 |
2531 VideoCodec codec; | 2559 VideoCodec codec; |
2532 EXPECT_TRUE(channel_->GetSendCodec(&codec)); | 2560 EXPECT_TRUE(channel_->GetSendCodec(&codec)); |
2533 EXPECT_EQ(kMaxQuantization, codec.params[kCodecParamMaxQuantization]); | 2561 EXPECT_EQ(kMaxQuantization, codec.params[kCodecParamMaxQuantization]); |
2534 } | 2562 } |
2535 | 2563 |
2536 TEST_F(WebRtcVideoChannel2Test, SetSendCodecsRejectBadPayloadTypes) { | 2564 TEST_F(WebRtcVideoChannel2Test, SetSendCodecsRejectBadPayloadTypes) { |
2537 // TODO(pbos): Should we only allow the dynamic range? | 2565 // TODO(pbos): Should we only allow the dynamic range? |
2538 static const int kIncorrectPayloads[] = {-2, -1, 128, 129}; | 2566 static const int kIncorrectPayloads[] = {-2, -1, 128, 129}; |
2539 cricket::VideoSendParameters parameters; | 2567 cricket::VideoSendParameters parameters; |
2540 parameters.codecs.push_back(kVp8Codec); | 2568 parameters.codecs.push_back(GetEngineCodec("VP8")); |
2541 for (size_t i = 0; i < arraysize(kIncorrectPayloads); ++i) { | 2569 for (size_t i = 0; i < arraysize(kIncorrectPayloads); ++i) { |
2542 parameters.codecs[0].id = kIncorrectPayloads[i]; | 2570 parameters.codecs[0].id = kIncorrectPayloads[i]; |
2543 EXPECT_FALSE(channel_->SetSendParameters(parameters)) | 2571 EXPECT_FALSE(channel_->SetSendParameters(parameters)) |
2544 << "Bad payload type '" << kIncorrectPayloads[i] << "' accepted."; | 2572 << "Bad payload type '" << kIncorrectPayloads[i] << "' accepted."; |
2545 } | 2573 } |
2546 } | 2574 } |
2547 | 2575 |
2548 TEST_F(WebRtcVideoChannel2Test, SetSendCodecsAcceptAllValidPayloadTypes) { | 2576 TEST_F(WebRtcVideoChannel2Test, SetSendCodecsAcceptAllValidPayloadTypes) { |
2549 cricket::VideoSendParameters parameters; | 2577 cricket::VideoSendParameters parameters; |
2550 parameters.codecs.push_back(kVp8Codec); | 2578 parameters.codecs.push_back(GetEngineCodec("VP8")); |
2551 // Only the dynamic payload types are valid for video codecs. | |
2552 for (int payload_type = 96; payload_type <= 127; ++payload_type) { | 2579 for (int payload_type = 96; payload_type <= 127; ++payload_type) { |
2553 parameters.codecs[0].id = payload_type; | 2580 parameters.codecs[0].id = payload_type; |
2554 EXPECT_TRUE(channel_->SetSendParameters(parameters)) | 2581 EXPECT_TRUE(channel_->SetSendParameters(parameters)) |
2555 << "Payload type '" << payload_type << "' rejected."; | 2582 << "Payload type '" << payload_type << "' rejected."; |
2556 } | 2583 } |
2557 } | 2584 } |
2558 | 2585 |
2559 // Test that setting the a different set of codecs but with an identical front | 2586 // Test that setting the a different set of codecs but with an identical front |
2560 // codec doesn't result in the stream being recreated. | 2587 // codec doesn't result in the stream being recreated. |
2561 // This may happen when a subsequent negotiation includes fewer codecs, as a | 2588 // This may happen when a subsequent negotiation includes fewer codecs, as a |
2562 // result of one of the codecs being rejected. | 2589 // result of one of the codecs being rejected. |
2563 TEST_F(WebRtcVideoChannel2Test, | 2590 TEST_F(WebRtcVideoChannel2Test, |
2564 SetSendCodecsIdenticalFirstCodecDoesntRecreateStream) { | 2591 SetSendCodecsIdenticalFirstCodecDoesntRecreateStream) { |
2565 cricket::VideoSendParameters parameters1; | 2592 cricket::VideoSendParameters parameters1; |
2566 parameters1.codecs.push_back(kVp8Codec); | 2593 parameters1.codecs.push_back(GetEngineCodec("VP8")); |
2567 parameters1.codecs.push_back(kVp9Codec); | 2594 parameters1.codecs.push_back(GetEngineCodec("VP9")); |
2568 EXPECT_TRUE(channel_->SetSendParameters(parameters1)); | 2595 EXPECT_TRUE(channel_->SetSendParameters(parameters1)); |
2569 | 2596 |
2570 AddSendStream(); | 2597 AddSendStream(); |
2571 EXPECT_EQ(1, fake_call_->GetNumCreatedSendStreams()); | 2598 EXPECT_EQ(1, fake_call_->GetNumCreatedSendStreams()); |
2572 | 2599 |
2573 cricket::VideoSendParameters parameters2; | 2600 cricket::VideoSendParameters parameters2; |
2574 parameters2.codecs.push_back(kVp8Codec); | 2601 parameters2.codecs.push_back(GetEngineCodec("VP8")); |
2575 EXPECT_TRUE(channel_->SetSendParameters(parameters2)); | 2602 EXPECT_TRUE(channel_->SetSendParameters(parameters2)); |
2576 EXPECT_EQ(1, fake_call_->GetNumCreatedSendStreams()); | 2603 EXPECT_EQ(1, fake_call_->GetNumCreatedSendStreams()); |
2577 } | 2604 } |
2578 | 2605 |
2579 TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsWithOnlyVp8) { | 2606 TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsWithOnlyVp8) { |
2580 cricket::VideoRecvParameters parameters; | 2607 cricket::VideoRecvParameters parameters; |
2581 parameters.codecs.push_back(kVp8Codec); | 2608 parameters.codecs.push_back(GetEngineCodec("VP8")); |
2582 EXPECT_TRUE(channel_->SetRecvParameters(parameters)); | 2609 EXPECT_TRUE(channel_->SetRecvParameters(parameters)); |
2583 } | 2610 } |
2584 | 2611 |
2585 // Test that we set our inbound RTX codecs properly. | 2612 // Test that we set our inbound RTX codecs properly. |
2586 TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsWithRtx) { | 2613 TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsWithRtx) { |
| 2614 const int kUnusedPayloadType1 = 126; |
| 2615 const int kUnusedPayloadType2 = 127; |
| 2616 EXPECT_FALSE(FindCodecById(engine_.codecs(), kUnusedPayloadType1)); |
| 2617 EXPECT_FALSE(FindCodecById(engine_.codecs(), kUnusedPayloadType2)); |
| 2618 |
2587 cricket::VideoRecvParameters parameters; | 2619 cricket::VideoRecvParameters parameters; |
2588 parameters.codecs.push_back(kVp8Codec); | 2620 parameters.codecs.push_back(GetEngineCodec("VP8")); |
2589 cricket::VideoCodec rtx_codec(96, "rtx"); | 2621 cricket::VideoCodec rtx_codec(kUnusedPayloadType1, "rtx"); |
2590 parameters.codecs.push_back(rtx_codec); | 2622 parameters.codecs.push_back(rtx_codec); |
2591 EXPECT_FALSE(channel_->SetRecvParameters(parameters)) | 2623 EXPECT_FALSE(channel_->SetRecvParameters(parameters)) |
2592 << "RTX codec without associated payload should be rejected."; | 2624 << "RTX codec without associated payload should be rejected."; |
2593 | 2625 |
2594 parameters.codecs[1].SetParam("apt", kVp8Codec.id + 1); | 2626 parameters.codecs[1].SetParam("apt", kUnusedPayloadType2); |
2595 EXPECT_FALSE(channel_->SetRecvParameters(parameters)) | 2627 EXPECT_FALSE(channel_->SetRecvParameters(parameters)) |
2596 << "RTX codec with invalid associated payload type should be rejected."; | 2628 << "RTX codec with invalid associated payload type should be rejected."; |
2597 | 2629 |
2598 parameters.codecs[1].SetParam("apt", kVp8Codec.id); | 2630 parameters.codecs[1].SetParam("apt", GetEngineCodec("VP8").id); |
2599 EXPECT_TRUE(channel_->SetRecvParameters(parameters)); | 2631 EXPECT_TRUE(channel_->SetRecvParameters(parameters)); |
2600 | 2632 |
2601 cricket::VideoCodec rtx_codec2(97, "rtx"); | 2633 cricket::VideoCodec rtx_codec2(kUnusedPayloadType2, "rtx"); |
2602 rtx_codec2.SetParam("apt", rtx_codec.id); | 2634 rtx_codec2.SetParam("apt", rtx_codec.id); |
2603 parameters.codecs.push_back(rtx_codec2); | 2635 parameters.codecs.push_back(rtx_codec2); |
2604 | 2636 |
2605 EXPECT_FALSE(channel_->SetRecvParameters(parameters)) << | 2637 EXPECT_FALSE(channel_->SetRecvParameters(parameters)) << |
2606 "RTX codec with another RTX as associated payload type should be " | 2638 "RTX codec with another RTX as associated payload type should be " |
2607 "rejected."; | 2639 "rejected."; |
2608 } | 2640 } |
2609 | 2641 |
2610 TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsDifferentPayloadType) { | 2642 TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsDifferentPayloadType) { |
2611 cricket::VideoRecvParameters parameters; | 2643 cricket::VideoRecvParameters parameters; |
2612 parameters.codecs.push_back(kVp8Codec); | 2644 parameters.codecs.push_back(GetEngineCodec("VP8")); |
2613 parameters.codecs[0].id = 99; | 2645 parameters.codecs[0].id = 99; |
2614 EXPECT_TRUE(channel_->SetRecvParameters(parameters)); | 2646 EXPECT_TRUE(channel_->SetRecvParameters(parameters)); |
2615 } | 2647 } |
2616 | 2648 |
2617 TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsAcceptDefaultCodecs) { | 2649 TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsAcceptDefaultCodecs) { |
2618 cricket::VideoRecvParameters parameters; | 2650 cricket::VideoRecvParameters parameters; |
2619 parameters.codecs = engine_.codecs(); | 2651 parameters.codecs = engine_.codecs(); |
2620 EXPECT_TRUE(channel_->SetRecvParameters(parameters)); | 2652 EXPECT_TRUE(channel_->SetRecvParameters(parameters)); |
2621 | 2653 |
2622 FakeVideoReceiveStream* stream = AddRecvStream(); | 2654 FakeVideoReceiveStream* stream = AddRecvStream(); |
2623 const webrtc::VideoReceiveStream::Config& config = stream->GetConfig(); | 2655 const webrtc::VideoReceiveStream::Config& config = stream->GetConfig(); |
2624 EXPECT_EQ(engine_.codecs()[0].name, config.decoders[0].payload_name); | 2656 EXPECT_EQ(engine_.codecs()[0].name, config.decoders[0].payload_name); |
2625 EXPECT_EQ(engine_.codecs()[0].id, config.decoders[0].payload_type); | 2657 EXPECT_EQ(engine_.codecs()[0].id, config.decoders[0].payload_type); |
2626 } | 2658 } |
2627 | 2659 |
2628 TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsRejectUnsupportedCodec) { | 2660 TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsRejectUnsupportedCodec) { |
2629 cricket::VideoRecvParameters parameters; | 2661 cricket::VideoRecvParameters parameters; |
2630 parameters.codecs.push_back(kVp8Codec); | 2662 parameters.codecs.push_back(GetEngineCodec("VP8")); |
2631 parameters.codecs.push_back(VideoCodec(101, "WTF3")); | 2663 parameters.codecs.push_back(VideoCodec(101, "WTF3")); |
2632 EXPECT_FALSE(channel_->SetRecvParameters(parameters)); | 2664 EXPECT_FALSE(channel_->SetRecvParameters(parameters)); |
2633 } | 2665 } |
2634 | 2666 |
2635 // TODO(pbos): Enable VP9 through external codec support | 2667 // TODO(pbos): Enable VP9 through external codec support |
2636 TEST_F(WebRtcVideoChannel2Test, | 2668 TEST_F(WebRtcVideoChannel2Test, |
2637 DISABLED_SetRecvCodecsAcceptsMultipleVideoCodecs) { | 2669 DISABLED_SetRecvCodecsAcceptsMultipleVideoCodecs) { |
2638 cricket::VideoRecvParameters parameters; | 2670 cricket::VideoRecvParameters parameters; |
2639 parameters.codecs.push_back(kVp8Codec); | 2671 parameters.codecs.push_back(GetEngineCodec("VP8")); |
2640 parameters.codecs.push_back(kVp9Codec); | 2672 parameters.codecs.push_back(GetEngineCodec("VP9")); |
2641 EXPECT_TRUE(channel_->SetRecvParameters(parameters)); | 2673 EXPECT_TRUE(channel_->SetRecvParameters(parameters)); |
2642 } | 2674 } |
2643 | 2675 |
2644 TEST_F(WebRtcVideoChannel2Test, | 2676 TEST_F(WebRtcVideoChannel2Test, |
2645 DISABLED_SetRecvCodecsSetsFecForAllVideoCodecs) { | 2677 DISABLED_SetRecvCodecsSetsFecForAllVideoCodecs) { |
2646 cricket::VideoRecvParameters parameters; | 2678 cricket::VideoRecvParameters parameters; |
2647 parameters.codecs.push_back(kVp8Codec); | 2679 parameters.codecs.push_back(GetEngineCodec("VP8")); |
2648 parameters.codecs.push_back(kVp9Codec); | 2680 parameters.codecs.push_back(GetEngineCodec("VP9")); |
2649 EXPECT_TRUE(channel_->SetRecvParameters(parameters)); | 2681 EXPECT_TRUE(channel_->SetRecvParameters(parameters)); |
2650 FAIL(); // TODO(pbos): Verify that the FEC parameters are set for all codecs. | 2682 FAIL(); // TODO(pbos): Verify that the FEC parameters are set for all codecs. |
2651 } | 2683 } |
2652 | 2684 |
2653 TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsWithoutFecDisablesFec) { | 2685 TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsWithoutFecDisablesFec) { |
2654 cricket::VideoSendParameters send_parameters; | 2686 cricket::VideoSendParameters send_parameters; |
2655 send_parameters.codecs.push_back(kVp8Codec); | 2687 send_parameters.codecs.push_back(GetEngineCodec("VP8")); |
2656 send_parameters.codecs.push_back(kRedCodec); | 2688 send_parameters.codecs.push_back(GetEngineCodec("red")); |
2657 send_parameters.codecs.push_back(kUlpfecCodec); | 2689 send_parameters.codecs.push_back(GetEngineCodec("ulpfec")); |
2658 ASSERT_TRUE(channel_->SetSendParameters(send_parameters)); | 2690 ASSERT_TRUE(channel_->SetSendParameters(send_parameters)); |
2659 | 2691 |
2660 FakeVideoReceiveStream* stream = AddRecvStream(); | 2692 FakeVideoReceiveStream* stream = AddRecvStream(); |
2661 | 2693 |
2662 EXPECT_EQ(kUlpfecCodec.id, | 2694 EXPECT_EQ(GetEngineCodec("ulpfec").id, |
2663 stream->GetConfig().rtp.ulpfec.ulpfec_payload_type); | 2695 stream->GetConfig().rtp.ulpfec.ulpfec_payload_type); |
2664 | 2696 |
2665 cricket::VideoRecvParameters recv_parameters; | 2697 cricket::VideoRecvParameters recv_parameters; |
2666 recv_parameters.codecs.push_back(kVp8Codec); | 2698 recv_parameters.codecs.push_back(GetEngineCodec("VP8")); |
2667 ASSERT_TRUE(channel_->SetRecvParameters(recv_parameters)); | 2699 ASSERT_TRUE(channel_->SetRecvParameters(recv_parameters)); |
2668 stream = fake_call_->GetVideoReceiveStreams()[0]; | 2700 stream = fake_call_->GetVideoReceiveStreams()[0]; |
2669 ASSERT_TRUE(stream != NULL); | 2701 ASSERT_TRUE(stream != NULL); |
2670 EXPECT_EQ(-1, stream->GetConfig().rtp.ulpfec.ulpfec_payload_type) | 2702 EXPECT_EQ(-1, stream->GetConfig().rtp.ulpfec.ulpfec_payload_type) |
2671 << "SetSendCodec without FEC should disable current FEC."; | 2703 << "SetSendCodec without FEC should disable current FEC."; |
2672 } | 2704 } |
2673 | 2705 |
2674 TEST_F(WebRtcVideoChannel2Test, SetSendParamsWithFecEnablesFec) { | 2706 TEST_F(WebRtcVideoChannel2Test, SetSendParamsWithFecEnablesFec) { |
2675 FakeVideoReceiveStream* stream = AddRecvStream(); | 2707 FakeVideoReceiveStream* stream = AddRecvStream(); |
2676 EXPECT_EQ(kUlpfecCodec.id, | 2708 EXPECT_EQ(GetEngineCodec("ulpfec").id, |
2677 stream->GetConfig().rtp.ulpfec.ulpfec_payload_type); | 2709 stream->GetConfig().rtp.ulpfec.ulpfec_payload_type); |
2678 | 2710 |
2679 cricket::VideoRecvParameters recv_parameters; | 2711 cricket::VideoRecvParameters recv_parameters; |
2680 recv_parameters.codecs.push_back(kVp8Codec); | 2712 recv_parameters.codecs.push_back(GetEngineCodec("VP8")); |
2681 recv_parameters.codecs.push_back(kRedCodec); | 2713 recv_parameters.codecs.push_back(GetEngineCodec("red")); |
2682 recv_parameters.codecs.push_back(kUlpfecCodec); | 2714 recv_parameters.codecs.push_back(GetEngineCodec("ulpfec")); |
2683 ASSERT_TRUE(channel_->SetRecvParameters(recv_parameters)); | 2715 ASSERT_TRUE(channel_->SetRecvParameters(recv_parameters)); |
2684 stream = fake_call_->GetVideoReceiveStreams()[0]; | 2716 stream = fake_call_->GetVideoReceiveStreams()[0]; |
2685 ASSERT_TRUE(stream != NULL); | 2717 ASSERT_TRUE(stream != NULL); |
2686 EXPECT_EQ(kUlpfecCodec.id, stream->GetConfig().rtp.ulpfec.ulpfec_payload_type) | 2718 EXPECT_EQ(GetEngineCodec("ulpfec").id, |
| 2719 stream->GetConfig().rtp.ulpfec.ulpfec_payload_type) |
2687 << "FEC should be enabled on the receive stream."; | 2720 << "FEC should be enabled on the receive stream."; |
2688 | 2721 |
2689 cricket::VideoSendParameters send_parameters; | 2722 cricket::VideoSendParameters send_parameters; |
2690 send_parameters.codecs.push_back(kVp8Codec); | 2723 send_parameters.codecs.push_back(GetEngineCodec("VP8")); |
2691 send_parameters.codecs.push_back(kRedCodec); | 2724 send_parameters.codecs.push_back(GetEngineCodec("red")); |
2692 send_parameters.codecs.push_back(kUlpfecCodec); | 2725 send_parameters.codecs.push_back(GetEngineCodec("ulpfec")); |
2693 ASSERT_TRUE(channel_->SetSendParameters(send_parameters)); | 2726 ASSERT_TRUE(channel_->SetSendParameters(send_parameters)); |
2694 stream = fake_call_->GetVideoReceiveStreams()[0]; | 2727 stream = fake_call_->GetVideoReceiveStreams()[0]; |
2695 EXPECT_EQ(kUlpfecCodec.id, stream->GetConfig().rtp.ulpfec.ulpfec_payload_type) | 2728 EXPECT_EQ(GetEngineCodec("ulpfec").id, |
| 2729 stream->GetConfig().rtp.ulpfec.ulpfec_payload_type) |
2696 << "FEC should be enabled on the receive stream."; | 2730 << "FEC should be enabled on the receive stream."; |
2697 } | 2731 } |
2698 | 2732 |
2699 TEST_F(WebRtcVideoChannel2Test, SetSendCodecsRejectDuplicateFecPayloads) { | 2733 TEST_F(WebRtcVideoChannel2Test, SetSendCodecsRejectDuplicateFecPayloads) { |
2700 cricket::VideoRecvParameters parameters; | 2734 cricket::VideoRecvParameters parameters; |
2701 parameters.codecs.push_back(kVp8Codec); | 2735 parameters.codecs.push_back(GetEngineCodec("VP8")); |
2702 parameters.codecs.push_back(kRedCodec); | 2736 parameters.codecs.push_back(GetEngineCodec("red")); |
2703 parameters.codecs[1].id = parameters.codecs[0].id; | 2737 parameters.codecs[1].id = parameters.codecs[0].id; |
2704 EXPECT_FALSE(channel_->SetRecvParameters(parameters)); | 2738 EXPECT_FALSE(channel_->SetRecvParameters(parameters)); |
2705 } | 2739 } |
2706 | 2740 |
2707 TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsRejectDuplicateCodecPayloads) { | 2741 TEST_F(WebRtcVideoChannel2Test, SetRecvCodecsRejectDuplicateCodecPayloads) { |
2708 cricket::VideoRecvParameters parameters; | 2742 cricket::VideoRecvParameters parameters; |
2709 parameters.codecs.push_back(kVp8Codec); | 2743 parameters.codecs.push_back(GetEngineCodec("VP8")); |
2710 parameters.codecs.push_back(kVp9Codec); | 2744 parameters.codecs.push_back(GetEngineCodec("VP9")); |
2711 parameters.codecs[1].id = parameters.codecs[0].id; | 2745 parameters.codecs[1].id = parameters.codecs[0].id; |
2712 EXPECT_FALSE(channel_->SetRecvParameters(parameters)); | 2746 EXPECT_FALSE(channel_->SetRecvParameters(parameters)); |
2713 } | 2747 } |
2714 | 2748 |
2715 TEST_F(WebRtcVideoChannel2Test, | 2749 TEST_F(WebRtcVideoChannel2Test, |
2716 SetRecvCodecsAcceptSameCodecOnMultiplePayloadTypes) { | 2750 SetRecvCodecsAcceptSameCodecOnMultiplePayloadTypes) { |
2717 cricket::VideoRecvParameters parameters; | 2751 cricket::VideoRecvParameters parameters; |
2718 parameters.codecs.push_back(kVp8Codec); | 2752 parameters.codecs.push_back(GetEngineCodec("VP8")); |
2719 parameters.codecs.push_back(kVp8Codec); | 2753 parameters.codecs.push_back(GetEngineCodec("VP8")); |
2720 parameters.codecs[1].id += 1; | 2754 parameters.codecs[1].id += 1; |
2721 EXPECT_TRUE(channel_->SetRecvParameters(parameters)); | 2755 EXPECT_TRUE(channel_->SetRecvParameters(parameters)); |
2722 } | 2756 } |
2723 | 2757 |
2724 // Test that setting the same codecs but with a different order | 2758 // Test that setting the same codecs but with a different order |
2725 // doesn't result in the stream being recreated. | 2759 // doesn't result in the stream being recreated. |
2726 TEST_F(WebRtcVideoChannel2Test, | 2760 TEST_F(WebRtcVideoChannel2Test, |
2727 SetRecvCodecsDifferentOrderDoesntRecreateStream) { | 2761 SetRecvCodecsDifferentOrderDoesntRecreateStream) { |
2728 cricket::VideoRecvParameters parameters1; | 2762 cricket::VideoRecvParameters parameters1; |
2729 parameters1.codecs.push_back(kVp8Codec); | 2763 parameters1.codecs.push_back(GetEngineCodec("VP8")); |
2730 parameters1.codecs.push_back(kRedCodec); | 2764 parameters1.codecs.push_back(GetEngineCodec("red")); |
2731 EXPECT_TRUE(channel_->SetRecvParameters(parameters1)); | 2765 EXPECT_TRUE(channel_->SetRecvParameters(parameters1)); |
2732 | 2766 |
2733 AddRecvStream(cricket::StreamParams::CreateLegacy(123)); | 2767 AddRecvStream(cricket::StreamParams::CreateLegacy(123)); |
2734 EXPECT_EQ(1, fake_call_->GetNumCreatedReceiveStreams()); | 2768 EXPECT_EQ(1, fake_call_->GetNumCreatedReceiveStreams()); |
2735 | 2769 |
2736 cricket::VideoRecvParameters parameters2; | 2770 cricket::VideoRecvParameters parameters2; |
2737 parameters2.codecs.push_back(kRedCodec); | 2771 parameters2.codecs.push_back(GetEngineCodec("red")); |
2738 parameters2.codecs.push_back(kVp8Codec); | 2772 parameters2.codecs.push_back(GetEngineCodec("VP8")); |
2739 EXPECT_TRUE(channel_->SetRecvParameters(parameters2)); | 2773 EXPECT_TRUE(channel_->SetRecvParameters(parameters2)); |
2740 EXPECT_EQ(1, fake_call_->GetNumCreatedReceiveStreams()); | 2774 EXPECT_EQ(1, fake_call_->GetNumCreatedReceiveStreams()); |
2741 } | 2775 } |
2742 | 2776 |
2743 TEST_F(WebRtcVideoChannel2Test, SendStreamNotSendingByDefault) { | 2777 TEST_F(WebRtcVideoChannel2Test, SendStreamNotSendingByDefault) { |
2744 EXPECT_FALSE(AddSendStream()->IsSending()); | 2778 EXPECT_FALSE(AddSendStream()->IsSending()); |
2745 } | 2779 } |
2746 | 2780 |
2747 TEST_F(WebRtcVideoChannel2Test, ReceiveStreamReceivingByDefault) { | 2781 TEST_F(WebRtcVideoChannel2Test, ReceiveStreamReceivingByDefault) { |
2748 EXPECT_TRUE(AddRecvStream()->IsReceiving()); | 2782 EXPECT_TRUE(AddRecvStream()->IsReceiving()); |
(...skipping 99 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2848 | 2882 |
2849 channel_->OnReadyToSend(true); | 2883 channel_->OnReadyToSend(true); |
2850 EXPECT_EQ(webrtc::kNetworkUp, | 2884 EXPECT_EQ(webrtc::kNetworkUp, |
2851 fake_call_->GetNetworkState(webrtc::MediaType::VIDEO)); | 2885 fake_call_->GetNetworkState(webrtc::MediaType::VIDEO)); |
2852 EXPECT_EQ(webrtc::kNetworkUp, | 2886 EXPECT_EQ(webrtc::kNetworkUp, |
2853 fake_call_->GetNetworkState(webrtc::MediaType::AUDIO)); | 2887 fake_call_->GetNetworkState(webrtc::MediaType::AUDIO)); |
2854 } | 2888 } |
2855 | 2889 |
2856 TEST_F(WebRtcVideoChannel2Test, GetStatsReportsSentCodecName) { | 2890 TEST_F(WebRtcVideoChannel2Test, GetStatsReportsSentCodecName) { |
2857 cricket::VideoSendParameters parameters; | 2891 cricket::VideoSendParameters parameters; |
2858 parameters.codecs.push_back(kVp8Codec); | 2892 parameters.codecs.push_back(GetEngineCodec("VP8")); |
2859 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 2893 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
2860 | 2894 |
2861 AddSendStream(); | 2895 AddSendStream(); |
2862 | 2896 |
2863 cricket::VideoMediaInfo info; | 2897 cricket::VideoMediaInfo info; |
2864 ASSERT_TRUE(channel_->GetStats(&info)); | 2898 ASSERT_TRUE(channel_->GetStats(&info)); |
2865 EXPECT_EQ(kVp8Codec.name, info.senders[0].codec_name); | 2899 EXPECT_EQ("VP8", info.senders[0].codec_name); |
2866 } | 2900 } |
2867 | 2901 |
2868 TEST_F(WebRtcVideoChannel2Test, GetStatsReportsEncoderImplementationName) { | 2902 TEST_F(WebRtcVideoChannel2Test, GetStatsReportsEncoderImplementationName) { |
2869 FakeVideoSendStream* stream = AddSendStream(); | 2903 FakeVideoSendStream* stream = AddSendStream(); |
2870 webrtc::VideoSendStream::Stats stats; | 2904 webrtc::VideoSendStream::Stats stats; |
2871 stats.encoder_implementation_name = "encoder_implementation_name"; | 2905 stats.encoder_implementation_name = "encoder_implementation_name"; |
2872 stream->SetStats(stats); | 2906 stream->SetStats(stats); |
2873 | 2907 |
2874 cricket::VideoMediaInfo info; | 2908 cricket::VideoMediaInfo info; |
2875 ASSERT_TRUE(channel_->GetStats(&info)); | 2909 ASSERT_TRUE(channel_->GetStats(&info)); |
(...skipping 392 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3268 FakeVideoReceiveStream* stream = AddRecvStream(); | 3302 FakeVideoReceiveStream* stream = AddRecvStream(); |
3269 webrtc::VideoReceiveStream::Stats stats; | 3303 webrtc::VideoReceiveStream::Stats stats; |
3270 cricket::VideoMediaInfo info; | 3304 cricket::VideoMediaInfo info; |
3271 | 3305 |
3272 // Report no codec name before receiving. | 3306 // Report no codec name before receiving. |
3273 stream->SetStats(stats); | 3307 stream->SetStats(stats); |
3274 ASSERT_TRUE(channel_->GetStats(&info)); | 3308 ASSERT_TRUE(channel_->GetStats(&info)); |
3275 EXPECT_STREQ("", info.receivers[0].codec_name.c_str()); | 3309 EXPECT_STREQ("", info.receivers[0].codec_name.c_str()); |
3276 | 3310 |
3277 // Report VP8 if we're receiving it. | 3311 // Report VP8 if we're receiving it. |
3278 stats.current_payload_type = kDefaultVp8PlType; | 3312 stats.current_payload_type = GetEngineCodec("VP8").id; |
3279 stream->SetStats(stats); | 3313 stream->SetStats(stats); |
3280 ASSERT_TRUE(channel_->GetStats(&info)); | 3314 ASSERT_TRUE(channel_->GetStats(&info)); |
3281 EXPECT_STREQ(kVp8CodecName, info.receivers[0].codec_name.c_str()); | 3315 EXPECT_STREQ(kVp8CodecName, info.receivers[0].codec_name.c_str()); |
3282 | 3316 |
3283 // Report no codec name for unknown playload types. | 3317 // Report no codec name for unknown playload types. |
3284 stats.current_payload_type = 3; | 3318 stats.current_payload_type = 3; |
3285 stream->SetStats(stats); | 3319 stream->SetStats(stats); |
3286 ASSERT_TRUE(channel_->GetStats(&info)); | 3320 ASSERT_TRUE(channel_->GetStats(&info)); |
3287 EXPECT_STREQ("", info.receivers[0].codec_name.c_str()); | 3321 EXPECT_STREQ("", info.receivers[0].codec_name.c_str()); |
3288 } | 3322 } |
3289 | 3323 |
3290 void WebRtcVideoChannel2Test::TestReceiveUnsignalledSsrcPacket( | 3324 void WebRtcVideoChannel2Test::TestReceiveUnsignaledSsrcPacket( |
3291 uint8_t payload_type, | 3325 uint8_t payload_type, |
3292 bool expect_created_receive_stream) { | 3326 bool expect_created_receive_stream) { |
| 3327 // kRedRtxPayloadType must currently be unused. |
| 3328 EXPECT_FALSE(FindCodecById(engine_.codecs(), kRedRtxPayloadType)); |
| 3329 |
3293 // Add a RED RTX codec. | 3330 // Add a RED RTX codec. |
3294 VideoCodec red_rtx_codec = | 3331 VideoCodec red_rtx_codec = |
3295 VideoCodec::CreateRtxCodec(kRedRtxPayloadType, kDefaultRedPlType); | 3332 VideoCodec::CreateRtxCodec(kRedRtxPayloadType, GetEngineCodec("red").id); |
3296 recv_parameters_.codecs.push_back(red_rtx_codec); | 3333 recv_parameters_.codecs.push_back(red_rtx_codec); |
3297 EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_)); | 3334 EXPECT_TRUE(channel_->SetRecvParameters(recv_parameters_)); |
3298 | 3335 |
3299 ASSERT_EQ(0u, fake_call_->GetVideoReceiveStreams().size()); | 3336 ASSERT_EQ(0u, fake_call_->GetVideoReceiveStreams().size()); |
3300 const size_t kDataLength = 12; | 3337 const size_t kDataLength = 12; |
3301 uint8_t data[kDataLength]; | 3338 uint8_t data[kDataLength]; |
3302 memset(data, 0, sizeof(data)); | 3339 memset(data, 0, sizeof(data)); |
3303 | 3340 |
3304 rtc::Set8(data, 1, payload_type); | 3341 rtc::Set8(data, 1, payload_type); |
3305 rtc::SetBE32(&data[8], kIncomingUnsignalledSsrc); | 3342 rtc::SetBE32(&data[8], kIncomingUnsignalledSsrc); |
3306 rtc::CopyOnWriteBuffer packet(data, kDataLength); | 3343 rtc::CopyOnWriteBuffer packet(data, kDataLength); |
3307 rtc::PacketTime packet_time; | 3344 rtc::PacketTime packet_time; |
3308 channel_->OnPacketReceived(&packet, packet_time); | 3345 channel_->OnPacketReceived(&packet, packet_time); |
3309 | 3346 |
3310 if (expect_created_receive_stream) { | 3347 if (expect_created_receive_stream) { |
3311 EXPECT_EQ(1u, fake_call_->GetVideoReceiveStreams().size()) | 3348 EXPECT_EQ(1u, fake_call_->GetVideoReceiveStreams().size()) |
3312 << "Should have created a receive stream for payload type: " | 3349 << "Should have created a receive stream for payload type: " |
3313 << payload_type; | 3350 << payload_type; |
3314 } else { | 3351 } else { |
3315 EXPECT_EQ(0u, fake_call_->GetVideoReceiveStreams().size()) | 3352 EXPECT_EQ(0u, fake_call_->GetVideoReceiveStreams().size()) |
3316 << "Shouldn't have created a receive stream for payload type: " | 3353 << "Shouldn't have created a receive stream for payload type: " |
3317 << payload_type; | 3354 << payload_type; |
3318 } | 3355 } |
3319 } | 3356 } |
3320 | 3357 |
3321 TEST_F(WebRtcVideoChannel2Test, Vp8PacketCreatesUnsignalledStream) { | 3358 TEST_F(WebRtcVideoChannel2Test, Vp8PacketCreatesUnsignalledStream) { |
3322 TestReceiveUnsignalledSsrcPacket(kDefaultVp8PlType, true); | 3359 TestReceiveUnsignaledSsrcPacket(GetEngineCodec("VP8").id, |
| 3360 true /* expect_created_receive_stream */); |
3323 } | 3361 } |
3324 | 3362 |
3325 TEST_F(WebRtcVideoChannel2Test, Vp9PacketCreatesUnsignalledStream) { | 3363 TEST_F(WebRtcVideoChannel2Test, Vp9PacketCreatesUnsignalledStream) { |
3326 TestReceiveUnsignalledSsrcPacket(kDefaultVp9PlType, true); | 3364 TestReceiveUnsignaledSsrcPacket(GetEngineCodec("VP9").id, |
| 3365 true /* expect_created_receive_stream */); |
3327 } | 3366 } |
3328 | 3367 |
3329 TEST_F(WebRtcVideoChannel2Test, RtxPacketDoesntCreateUnsignalledStream) { | 3368 TEST_F(WebRtcVideoChannel2Test, RtxPacketDoesntCreateUnsignalledStream) { |
3330 TestReceiveUnsignalledSsrcPacket(kDefaultRtxVp8PlType, false); | 3369 const cricket::VideoCodec vp8 = GetEngineCodec("VP8"); |
| 3370 const int rtx_vp8_payload_type = default_apt_rtx_types_[vp8.id]; |
| 3371 TestReceiveUnsignaledSsrcPacket(rtx_vp8_payload_type, |
| 3372 false /* expect_created_receive_stream */); |
3331 } | 3373 } |
3332 | 3374 |
3333 TEST_F(WebRtcVideoChannel2Test, UlpfecPacketDoesntCreateUnsignalledStream) { | 3375 TEST_F(WebRtcVideoChannel2Test, UlpfecPacketDoesntCreateUnsignalledStream) { |
3334 TestReceiveUnsignalledSsrcPacket(kDefaultUlpfecType, false); | 3376 TestReceiveUnsignaledSsrcPacket(GetEngineCodec("ulpfec").id, |
| 3377 false /* expect_created_receive_stream */); |
3335 } | 3378 } |
3336 | 3379 |
3337 TEST_F(WebRtcVideoChannel2Test, RedRtxPacketDoesntCreateUnsignalledStream) { | 3380 TEST_F(WebRtcVideoChannel2Test, RedRtxPacketDoesntCreateUnsignalledStream) { |
3338 TestReceiveUnsignalledSsrcPacket(kRedRtxPayloadType, false); | 3381 TestReceiveUnsignaledSsrcPacket(kRedRtxPayloadType, |
| 3382 false /* expect_created_receive_stream */); |
3339 } | 3383 } |
3340 | 3384 |
3341 TEST_F(WebRtcVideoChannel2Test, CanSentMaxBitrateForExistingStream) { | 3385 TEST_F(WebRtcVideoChannel2Test, CanSentMaxBitrateForExistingStream) { |
3342 AddSendStream(); | 3386 AddSendStream(); |
3343 | 3387 |
3344 cricket::FakeVideoCapturer capturer; | 3388 cricket::FakeVideoCapturer capturer; |
3345 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, nullptr, &capturer)); | 3389 EXPECT_TRUE(channel_->SetVideoSend(last_ssrc_, true, nullptr, &capturer)); |
3346 cricket::VideoFormat capture_format_hd = | 3390 cricket::VideoFormat capture_format_hd = |
3347 capturer.GetSupportedFormats()->front(); | 3391 capturer.GetSupportedFormats()->front(); |
3348 EXPECT_EQ(1280, capture_format_hd.width); | 3392 EXPECT_EQ(1280, capture_format_hd.width); |
(...skipping 74 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3423 EXPECT_TRUE(channel_->SetRtpSendParameters(last_ssrc_, parameters)); | 3467 EXPECT_TRUE(channel_->SetRtpSendParameters(last_ssrc_, parameters)); |
3424 EXPECT_TRUE(stream->IsSending()); | 3468 EXPECT_TRUE(stream->IsSending()); |
3425 } | 3469 } |
3426 | 3470 |
3427 // Test that if a stream is reconfigured (due to a codec change or other | 3471 // Test that if a stream is reconfigured (due to a codec change or other |
3428 // change) while its encoding is still inactive, it doesn't start sending. | 3472 // change) while its encoding is still inactive, it doesn't start sending. |
3429 TEST_F(WebRtcVideoChannel2Test, | 3473 TEST_F(WebRtcVideoChannel2Test, |
3430 InactiveStreamDoesntStartSendingWhenReconfigured) { | 3474 InactiveStreamDoesntStartSendingWhenReconfigured) { |
3431 // Set an initial codec list, which will be modified later. | 3475 // Set an initial codec list, which will be modified later. |
3432 cricket::VideoSendParameters parameters1; | 3476 cricket::VideoSendParameters parameters1; |
3433 parameters1.codecs.push_back(kVp8Codec); | 3477 parameters1.codecs.push_back(GetEngineCodec("VP8")); |
3434 parameters1.codecs.push_back(kVp9Codec); | 3478 parameters1.codecs.push_back(GetEngineCodec("VP9")); |
3435 EXPECT_TRUE(channel_->SetSendParameters(parameters1)); | 3479 EXPECT_TRUE(channel_->SetSendParameters(parameters1)); |
3436 | 3480 |
3437 FakeVideoSendStream* stream = AddSendStream(); | 3481 FakeVideoSendStream* stream = AddSendStream(); |
3438 EXPECT_TRUE(channel_->SetSend(true)); | 3482 EXPECT_TRUE(channel_->SetSend(true)); |
3439 EXPECT_TRUE(stream->IsSending()); | 3483 EXPECT_TRUE(stream->IsSending()); |
3440 | 3484 |
3441 // Get current parameters and change "active" to false. | 3485 // Get current parameters and change "active" to false. |
3442 webrtc::RtpParameters parameters = channel_->GetRtpSendParameters(last_ssrc_); | 3486 webrtc::RtpParameters parameters = channel_->GetRtpSendParameters(last_ssrc_); |
3443 ASSERT_EQ(1u, parameters.encodings.size()); | 3487 ASSERT_EQ(1u, parameters.encodings.size()); |
3444 ASSERT_TRUE(parameters.encodings[0].active); | 3488 ASSERT_TRUE(parameters.encodings[0].active); |
3445 parameters.encodings[0].active = false; | 3489 parameters.encodings[0].active = false; |
3446 EXPECT_EQ(1u, GetFakeSendStreams().size()); | 3490 EXPECT_EQ(1u, GetFakeSendStreams().size()); |
3447 EXPECT_EQ(1, fake_call_->GetNumCreatedSendStreams()); | 3491 EXPECT_EQ(1, fake_call_->GetNumCreatedSendStreams()); |
3448 EXPECT_TRUE(channel_->SetRtpSendParameters(last_ssrc_, parameters)); | 3492 EXPECT_TRUE(channel_->SetRtpSendParameters(last_ssrc_, parameters)); |
3449 EXPECT_FALSE(stream->IsSending()); | 3493 EXPECT_FALSE(stream->IsSending()); |
3450 | 3494 |
3451 // Reorder the codec list, causing the stream to be reconfigured. | 3495 // Reorder the codec list, causing the stream to be reconfigured. |
3452 cricket::VideoSendParameters parameters2; | 3496 cricket::VideoSendParameters parameters2; |
3453 parameters2.codecs.push_back(kVp9Codec); | 3497 parameters2.codecs.push_back(GetEngineCodec("VP9")); |
3454 parameters2.codecs.push_back(kVp8Codec); | 3498 parameters2.codecs.push_back(GetEngineCodec("VP8")); |
3455 EXPECT_TRUE(channel_->SetSendParameters(parameters2)); | 3499 EXPECT_TRUE(channel_->SetSendParameters(parameters2)); |
3456 auto new_streams = GetFakeSendStreams(); | 3500 auto new_streams = GetFakeSendStreams(); |
3457 // Assert that a new underlying stream was created due to the codec change. | 3501 // Assert that a new underlying stream was created due to the codec change. |
3458 // Otherwise, this test isn't testing what it set out to test. | 3502 // Otherwise, this test isn't testing what it set out to test. |
3459 EXPECT_EQ(1u, GetFakeSendStreams().size()); | 3503 EXPECT_EQ(1u, GetFakeSendStreams().size()); |
3460 EXPECT_EQ(2, fake_call_->GetNumCreatedSendStreams()); | 3504 EXPECT_EQ(2, fake_call_->GetNumCreatedSendStreams()); |
3461 | 3505 |
3462 // Verify that we still are not sending anything, due to the inactive | 3506 // Verify that we still are not sending anything, due to the inactive |
3463 // encoding. | 3507 // encoding. |
3464 EXPECT_FALSE(new_streams[0]->IsSending()); | 3508 EXPECT_FALSE(new_streams[0]->IsSending()); |
3465 } | 3509 } |
3466 | 3510 |
3467 // Test that GetRtpSendParameters returns the currently configured codecs. | 3511 // Test that GetRtpSendParameters returns the currently configured codecs. |
3468 TEST_F(WebRtcVideoChannel2Test, GetRtpSendParametersCodecs) { | 3512 TEST_F(WebRtcVideoChannel2Test, GetRtpSendParametersCodecs) { |
3469 AddSendStream(); | 3513 AddSendStream(); |
3470 cricket::VideoSendParameters parameters; | 3514 cricket::VideoSendParameters parameters; |
3471 parameters.codecs.push_back(kVp8Codec); | 3515 parameters.codecs.push_back(GetEngineCodec("VP8")); |
3472 parameters.codecs.push_back(kVp9Codec); | 3516 parameters.codecs.push_back(GetEngineCodec("VP9")); |
3473 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 3517 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
3474 | 3518 |
3475 webrtc::RtpParameters rtp_parameters = | 3519 webrtc::RtpParameters rtp_parameters = |
3476 channel_->GetRtpSendParameters(last_ssrc_); | 3520 channel_->GetRtpSendParameters(last_ssrc_); |
3477 ASSERT_EQ(2u, rtp_parameters.codecs.size()); | 3521 ASSERT_EQ(2u, rtp_parameters.codecs.size()); |
3478 EXPECT_EQ(kVp8Codec.ToCodecParameters(), rtp_parameters.codecs[0]); | 3522 EXPECT_EQ(GetEngineCodec("VP8").ToCodecParameters(), |
3479 EXPECT_EQ(kVp9Codec.ToCodecParameters(), rtp_parameters.codecs[1]); | 3523 rtp_parameters.codecs[0]); |
| 3524 EXPECT_EQ(GetEngineCodec("VP9").ToCodecParameters(), |
| 3525 rtp_parameters.codecs[1]); |
3480 } | 3526 } |
3481 | 3527 |
3482 // Test that if we set/get parameters multiple times, we get the same results. | 3528 // Test that if we set/get parameters multiple times, we get the same results. |
3483 TEST_F(WebRtcVideoChannel2Test, SetAndGetRtpSendParameters) { | 3529 TEST_F(WebRtcVideoChannel2Test, SetAndGetRtpSendParameters) { |
3484 AddSendStream(); | 3530 AddSendStream(); |
3485 cricket::VideoSendParameters parameters; | 3531 cricket::VideoSendParameters parameters; |
3486 parameters.codecs.push_back(kVp8Codec); | 3532 parameters.codecs.push_back(GetEngineCodec("VP8")); |
3487 parameters.codecs.push_back(kVp9Codec); | 3533 parameters.codecs.push_back(GetEngineCodec("VP9")); |
3488 EXPECT_TRUE(channel_->SetSendParameters(parameters)); | 3534 EXPECT_TRUE(channel_->SetSendParameters(parameters)); |
3489 | 3535 |
3490 webrtc::RtpParameters initial_params = | 3536 webrtc::RtpParameters initial_params = |
3491 channel_->GetRtpSendParameters(last_ssrc_); | 3537 channel_->GetRtpSendParameters(last_ssrc_); |
3492 | 3538 |
3493 // We should be able to set the params we just got. | 3539 // We should be able to set the params we just got. |
3494 EXPECT_TRUE(channel_->SetRtpSendParameters(last_ssrc_, initial_params)); | 3540 EXPECT_TRUE(channel_->SetRtpSendParameters(last_ssrc_, initial_params)); |
3495 | 3541 |
3496 // ... And this shouldn't change the params returned by GetRtpSendParameters. | 3542 // ... And this shouldn't change the params returned by GetRtpSendParameters. |
3497 EXPECT_EQ(initial_params, channel_->GetRtpSendParameters(last_ssrc_)); | 3543 EXPECT_EQ(initial_params, channel_->GetRtpSendParameters(last_ssrc_)); |
3498 } | 3544 } |
3499 | 3545 |
3500 // Test that GetRtpReceiveParameters returns the currently configured codecs. | 3546 // Test that GetRtpReceiveParameters returns the currently configured codecs. |
3501 TEST_F(WebRtcVideoChannel2Test, GetRtpReceiveParametersCodecs) { | 3547 TEST_F(WebRtcVideoChannel2Test, GetRtpReceiveParametersCodecs) { |
3502 AddRecvStream(); | 3548 AddRecvStream(); |
3503 cricket::VideoRecvParameters parameters; | 3549 cricket::VideoRecvParameters parameters; |
3504 parameters.codecs.push_back(kVp8Codec); | 3550 parameters.codecs.push_back(GetEngineCodec("VP8")); |
3505 parameters.codecs.push_back(kVp9Codec); | 3551 parameters.codecs.push_back(GetEngineCodec("VP9")); |
3506 EXPECT_TRUE(channel_->SetRecvParameters(parameters)); | 3552 EXPECT_TRUE(channel_->SetRecvParameters(parameters)); |
3507 | 3553 |
3508 webrtc::RtpParameters rtp_parameters = | 3554 webrtc::RtpParameters rtp_parameters = |
3509 channel_->GetRtpReceiveParameters(last_ssrc_); | 3555 channel_->GetRtpReceiveParameters(last_ssrc_); |
3510 ASSERT_EQ(2u, rtp_parameters.codecs.size()); | 3556 ASSERT_EQ(2u, rtp_parameters.codecs.size()); |
3511 EXPECT_EQ(kVp8Codec.ToCodecParameters(), rtp_parameters.codecs[0]); | 3557 EXPECT_EQ(GetEngineCodec("VP8").ToCodecParameters(), |
3512 EXPECT_EQ(kVp9Codec.ToCodecParameters(), rtp_parameters.codecs[1]); | 3558 rtp_parameters.codecs[0]); |
| 3559 EXPECT_EQ(GetEngineCodec("VP9").ToCodecParameters(), |
| 3560 rtp_parameters.codecs[1]); |
3513 } | 3561 } |
3514 | 3562 |
3515 #if defined(WEBRTC_USE_H264) | 3563 #if defined(WEBRTC_USE_H264) |
3516 TEST_F(WebRtcVideoChannel2Test, GetRtpReceiveFmtpSprop) { | 3564 TEST_F(WebRtcVideoChannel2Test, GetRtpReceiveFmtpSprop) { |
3517 #else | 3565 #else |
3518 TEST_F(WebRtcVideoChannel2Test, DISABLED_GetRtpReceiveFmtpSprop) { | 3566 TEST_F(WebRtcVideoChannel2Test, DISABLED_GetRtpReceiveFmtpSprop) { |
3519 #endif | 3567 #endif |
3520 cricket::VideoRecvParameters parameters; | 3568 cricket::VideoRecvParameters parameters; |
3521 cricket::VideoCodec kH264sprop1(101, "H264"); | 3569 cricket::VideoCodec kH264sprop1(101, "H264"); |
3522 kH264sprop1.SetParam("sprop-parameter-sets", "uvw"); | 3570 kH264sprop1.SetParam("sprop-parameter-sets", "uvw"); |
(...skipping 36 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3559 channel_->GetRtpReceiveParameters(last_ssrc_); | 3607 channel_->GetRtpReceiveParameters(last_ssrc_); |
3560 ASSERT_EQ(1u, rtp_parameters.encodings.size()); | 3608 ASSERT_EQ(1u, rtp_parameters.encodings.size()); |
3561 EXPECT_EQ(rtc::Optional<uint32_t>(last_ssrc_), | 3609 EXPECT_EQ(rtc::Optional<uint32_t>(last_ssrc_), |
3562 rtp_parameters.encodings[0].ssrc); | 3610 rtp_parameters.encodings[0].ssrc); |
3563 } | 3611 } |
3564 | 3612 |
3565 // Test that if we set/get parameters multiple times, we get the same results. | 3613 // Test that if we set/get parameters multiple times, we get the same results. |
3566 TEST_F(WebRtcVideoChannel2Test, SetAndGetRtpReceiveParameters) { | 3614 TEST_F(WebRtcVideoChannel2Test, SetAndGetRtpReceiveParameters) { |
3567 AddRecvStream(); | 3615 AddRecvStream(); |
3568 cricket::VideoRecvParameters parameters; | 3616 cricket::VideoRecvParameters parameters; |
3569 parameters.codecs.push_back(kVp8Codec); | 3617 parameters.codecs.push_back(GetEngineCodec("VP8")); |
3570 parameters.codecs.push_back(kVp9Codec); | 3618 parameters.codecs.push_back(GetEngineCodec("VP9")); |
3571 EXPECT_TRUE(channel_->SetRecvParameters(parameters)); | 3619 EXPECT_TRUE(channel_->SetRecvParameters(parameters)); |
3572 | 3620 |
3573 webrtc::RtpParameters initial_params = | 3621 webrtc::RtpParameters initial_params = |
3574 channel_->GetRtpReceiveParameters(last_ssrc_); | 3622 channel_->GetRtpReceiveParameters(last_ssrc_); |
3575 | 3623 |
3576 // We should be able to set the params we just got. | 3624 // We should be able to set the params we just got. |
3577 EXPECT_TRUE(channel_->SetRtpReceiveParameters(last_ssrc_, initial_params)); | 3625 EXPECT_TRUE(channel_->SetRtpReceiveParameters(last_ssrc_, initial_params)); |
3578 | 3626 |
3579 // ... And this shouldn't change the params returned by | 3627 // ... And this shouldn't change the params returned by |
3580 // GetRtpReceiveParameters. | 3628 // GetRtpReceiveParameters. |
(...skipping 173 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3754 } | 3802 } |
3755 | 3803 |
3756 webrtc::RtcEventLogNullImpl event_log_; | 3804 webrtc::RtcEventLogNullImpl event_log_; |
3757 FakeCall fake_call_; | 3805 FakeCall fake_call_; |
3758 WebRtcVideoEngine2 engine_; | 3806 WebRtcVideoEngine2 engine_; |
3759 std::unique_ptr<VideoMediaChannel> channel_; | 3807 std::unique_ptr<VideoMediaChannel> channel_; |
3760 uint32_t last_ssrc_; | 3808 uint32_t last_ssrc_; |
3761 }; | 3809 }; |
3762 | 3810 |
3763 TEST_F(WebRtcVideoChannel2SimulcastTest, SetSendCodecsWith2SimulcastStreams) { | 3811 TEST_F(WebRtcVideoChannel2SimulcastTest, SetSendCodecsWith2SimulcastStreams) { |
3764 VerifySimulcastSettings(kVp8Codec, 640, 360, 2, 2); | 3812 VerifySimulcastSettings(cricket::VideoCodec("VP8"), 640, 360, 2, 2); |
3765 } | 3813 } |
3766 | 3814 |
3767 TEST_F(WebRtcVideoChannel2SimulcastTest, SetSendCodecsWith3SimulcastStreams) { | 3815 TEST_F(WebRtcVideoChannel2SimulcastTest, SetSendCodecsWith3SimulcastStreams) { |
3768 VerifySimulcastSettings(kVp8Codec, 1280, 720, 3, 3); | 3816 VerifySimulcastSettings(cricket::VideoCodec("VP8"), 1280, 720, 3, 3); |
3769 } | 3817 } |
3770 | 3818 |
3771 // Test that we normalize send codec format size in simulcast. | 3819 // Test that we normalize send codec format size in simulcast. |
3772 TEST_F(WebRtcVideoChannel2SimulcastTest, SetSendCodecsWithOddSizeInSimulcast) { | 3820 TEST_F(WebRtcVideoChannel2SimulcastTest, SetSendCodecsWithOddSizeInSimulcast) { |
3773 cricket::VideoCodec codec(kVp8Codec); | 3821 VerifySimulcastSettings(cricket::VideoCodec("VP8"), 541, 271, 2, 2); |
3774 VerifySimulcastSettings(codec, 541, 271, 2, 2); | |
3775 } | 3822 } |
3776 } // namespace cricket | 3823 } // namespace cricket |
OLD | NEW |