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