OLD | NEW |
1 /* | 1 /* |
2 * libjingle | 2 * libjingle |
3 * Copyright 2004 Google Inc. | 3 * Copyright 2004 Google Inc. |
4 * | 4 * |
5 * Redistribution and use in source and binary forms, with or without | 5 * Redistribution and use in source and binary forms, with or without |
6 * modification, are permitted provided that the following conditions are met: | 6 * modification, are permitted provided that the following conditions are met: |
7 * | 7 * |
8 * 1. Redistributions of source code must retain the above copyright notice, | 8 * 1. Redistributions of source code must retain the above copyright notice, |
9 * this list of conditions and the following disclaimer. | 9 * this list of conditions and the following disclaimer. |
10 * 2. Redistributions in binary form must reproduce the above copyright notice, | 10 * 2. Redistributions in binary form must reproduce the above copyright notice, |
(...skipping 92 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
103 it->second == config.rtp.fec.red_rtx_payload_type); | 103 it->second == config.rtp.fec.red_rtx_payload_type); |
104 } | 104 } |
105 } | 105 } |
106 } // namespace | 106 } // namespace |
107 | 107 |
108 namespace cricket { | 108 namespace cricket { |
109 class WebRtcVideoEngine2Test : public ::testing::Test { | 109 class WebRtcVideoEngine2Test : public ::testing::Test { |
110 public: | 110 public: |
111 WebRtcVideoEngine2Test() : WebRtcVideoEngine2Test(nullptr) {} | 111 WebRtcVideoEngine2Test() : WebRtcVideoEngine2Test(nullptr) {} |
112 WebRtcVideoEngine2Test(WebRtcVoiceEngine* voice_engine) | 112 WebRtcVideoEngine2Test(WebRtcVoiceEngine* voice_engine) |
113 : engine_(voice_engine) { | 113 : call_(webrtc::Call::Create(webrtc::Call::Config())), |
| 114 engine_() { |
114 std::vector<VideoCodec> engine_codecs = engine_.codecs(); | 115 std::vector<VideoCodec> engine_codecs = engine_.codecs(); |
115 DCHECK(!engine_codecs.empty()); | 116 DCHECK(!engine_codecs.empty()); |
116 bool codec_set = false; | 117 bool codec_set = false; |
117 for (size_t i = 0; i < engine_codecs.size(); ++i) { | 118 for (size_t i = 0; i < engine_codecs.size(); ++i) { |
118 if (engine_codecs[i].name == "red") { | 119 if (engine_codecs[i].name == "red") { |
119 default_red_codec_ = engine_codecs[i]; | 120 default_red_codec_ = engine_codecs[i]; |
120 } else if (engine_codecs[i].name == "ulpfec") { | 121 } else if (engine_codecs[i].name == "ulpfec") { |
121 default_ulpfec_codec_ = engine_codecs[i]; | 122 default_ulpfec_codec_ = engine_codecs[i]; |
122 } else if (engine_codecs[i].name == "rtx") { | 123 } else if (engine_codecs[i].name == "rtx") { |
123 int associated_payload_type; | 124 int associated_payload_type; |
124 if (engine_codecs[i].GetParam(kCodecParamAssociatedPayloadType, | 125 if (engine_codecs[i].GetParam(kCodecParamAssociatedPayloadType, |
125 &associated_payload_type)) { | 126 &associated_payload_type)) { |
126 default_apt_rtx_types_[associated_payload_type] = engine_codecs[i].id; | 127 default_apt_rtx_types_[associated_payload_type] = engine_codecs[i].id; |
127 } | 128 } |
128 } else if (!codec_set) { | 129 } else if (!codec_set) { |
129 default_codec_ = engine_codecs[i]; | 130 default_codec_ = engine_codecs[i]; |
130 codec_set = true; | 131 codec_set = true; |
131 } | 132 } |
132 } | 133 } |
133 | 134 |
134 DCHECK(codec_set); | 135 DCHECK(codec_set); |
135 } | 136 } |
136 | 137 |
137 protected: | 138 protected: |
138 class FakeCallFactory : public WebRtcCallFactory { | |
139 public: | |
140 FakeCallFactory() : fake_call_(NULL) {} | |
141 FakeCall* GetCall() { return fake_call_; } | |
142 | |
143 private: | |
144 webrtc::Call* CreateCall(const webrtc::Call::Config& config) override { | |
145 DCHECK(fake_call_ == NULL); | |
146 fake_call_ = new FakeCall(config); | |
147 return fake_call_; | |
148 } | |
149 | |
150 FakeCall* fake_call_; | |
151 }; | |
152 | |
153 VideoMediaChannel* SetUpForExternalEncoderFactory( | 139 VideoMediaChannel* SetUpForExternalEncoderFactory( |
154 cricket::WebRtcVideoEncoderFactory* encoder_factory, | 140 cricket::WebRtcVideoEncoderFactory* encoder_factory, |
155 const std::vector<VideoCodec>& codecs); | 141 const std::vector<VideoCodec>& codecs); |
156 | 142 |
157 VideoMediaChannel* SetUpForExternalDecoderFactory( | 143 VideoMediaChannel* SetUpForExternalDecoderFactory( |
158 cricket::WebRtcVideoDecoderFactory* decoder_factory, | 144 cricket::WebRtcVideoDecoderFactory* decoder_factory, |
159 const std::vector<VideoCodec>& codecs); | 145 const std::vector<VideoCodec>& codecs); |
160 | 146 |
161 // Used in WebRtcVideoEngine2VoiceTest, but defined here so it's properly | 147 // Used in WebRtcVideoEngine2VoiceTest, but defined here so it's properly |
162 // initialized when the constructor is called. | 148 // initialized when the constructor is called. |
| 149 rtc::scoped_ptr<webrtc::Call> call_; |
163 WebRtcVoiceEngine voice_engine_; | 150 WebRtcVoiceEngine voice_engine_; |
164 WebRtcVideoEngine2 engine_; | 151 WebRtcVideoEngine2 engine_; |
165 VideoCodec default_codec_; | 152 VideoCodec default_codec_; |
166 VideoCodec default_red_codec_; | 153 VideoCodec default_red_codec_; |
167 VideoCodec default_ulpfec_codec_; | 154 VideoCodec default_ulpfec_codec_; |
168 std::map<int, int> default_apt_rtx_types_; | 155 std::map<int, int> default_apt_rtx_types_; |
169 }; | 156 }; |
170 | 157 |
171 TEST_F(WebRtcVideoEngine2Test, FindCodec) { | 158 TEST_F(WebRtcVideoEngine2Test, FindCodec) { |
172 const std::vector<cricket::VideoCodec>& c = engine_.codecs(); | 159 const std::vector<cricket::VideoCodec>& c = engine_.codecs(); |
(...skipping 170 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
343 | 330 |
344 // Verify removing header extension turns on applying rotation. | 331 // Verify removing header extension turns on applying rotation. |
345 extensions.clear(); | 332 extensions.clear(); |
346 EXPECT_TRUE(channel->SetSendRtpHeaderExtensions(extensions)); | 333 EXPECT_TRUE(channel->SetSendRtpHeaderExtensions(extensions)); |
347 EXPECT_TRUE(capturer.GetApplyRotation()); | 334 EXPECT_TRUE(capturer.GetApplyRotation()); |
348 } | 335 } |
349 | 336 |
350 TEST_F(WebRtcVideoEngine2Test, SetSendFailsBeforeSettingCodecs) { | 337 TEST_F(WebRtcVideoEngine2Test, SetSendFailsBeforeSettingCodecs) { |
351 engine_.Init(); | 338 engine_.Init(); |
352 rtc::scoped_ptr<VideoMediaChannel> channel( | 339 rtc::scoped_ptr<VideoMediaChannel> channel( |
353 engine_.CreateChannel(cricket::VideoOptions(), NULL)); | 340 engine_.CreateChannel(call_.get(), cricket::VideoOptions())); |
354 | 341 |
355 EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(123))); | 342 EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(123))); |
356 | 343 |
357 EXPECT_FALSE(channel->SetSend(true)) | 344 EXPECT_FALSE(channel->SetSend(true)) |
358 << "Channel should not start without codecs."; | 345 << "Channel should not start without codecs."; |
359 EXPECT_TRUE(channel->SetSend(false)) | 346 EXPECT_TRUE(channel->SetSend(false)) |
360 << "Channel should be stoppable even without set codecs."; | 347 << "Channel should be stoppable even without set codecs."; |
361 } | 348 } |
362 | 349 |
363 TEST_F(WebRtcVideoEngine2Test, GetStatsWithoutSendCodecsSetDoesNotCrash) { | 350 TEST_F(WebRtcVideoEngine2Test, GetStatsWithoutSendCodecsSetDoesNotCrash) { |
364 engine_.Init(); | 351 engine_.Init(); |
365 rtc::scoped_ptr<VideoMediaChannel> channel( | 352 rtc::scoped_ptr<VideoMediaChannel> channel( |
366 engine_.CreateChannel(cricket::VideoOptions(), NULL)); | 353 engine_.CreateChannel(call_.get(), cricket::VideoOptions())); |
367 EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(123))); | 354 EXPECT_TRUE(channel->AddSendStream(StreamParams::CreateLegacy(123))); |
368 VideoMediaInfo info; | 355 VideoMediaInfo info; |
369 channel->GetStats(&info); | 356 channel->GetStats(&info); |
370 } | 357 } |
371 | 358 |
372 TEST_F(WebRtcVideoEngine2Test, UseExternalFactoryForVp8WhenSupported) { | 359 TEST_F(WebRtcVideoEngine2Test, UseExternalFactoryForVp8WhenSupported) { |
373 cricket::FakeWebRtcVideoEncoderFactory encoder_factory; | 360 cricket::FakeWebRtcVideoEncoderFactory encoder_factory; |
374 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8, "VP8"); | 361 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8, "VP8"); |
375 std::vector<cricket::VideoCodec> codecs; | 362 std::vector<cricket::VideoCodec> codecs; |
376 codecs.push_back(kVp8Codec); | 363 codecs.push_back(kVp8Codec); |
(...skipping 41 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
418 EXPECT_TRUE( | 405 EXPECT_TRUE( |
419 channel->AddRecvStream(cricket::StreamParams::CreateLegacy(kSsrc))); | 406 channel->AddRecvStream(cricket::StreamParams::CreateLegacy(kSsrc))); |
420 } | 407 } |
421 | 408 |
422 TEST_F(WebRtcVideoEngine2Test, PropagatesInputFrameTimestamp) { | 409 TEST_F(WebRtcVideoEngine2Test, PropagatesInputFrameTimestamp) { |
423 cricket::FakeWebRtcVideoEncoderFactory encoder_factory; | 410 cricket::FakeWebRtcVideoEncoderFactory encoder_factory; |
424 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8, "VP8"); | 411 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8, "VP8"); |
425 std::vector<cricket::VideoCodec> codecs; | 412 std::vector<cricket::VideoCodec> codecs; |
426 codecs.push_back(kVp8Codec); | 413 codecs.push_back(kVp8Codec); |
427 | 414 |
428 FakeCallFactory factory; | 415 FakeCall* fake_call = new FakeCall(webrtc::Call::Config()); |
429 engine_.SetCallFactory(&factory); | 416 call_.reset(fake_call); |
430 rtc::scoped_ptr<VideoMediaChannel> channel( | 417 rtc::scoped_ptr<VideoMediaChannel> channel( |
431 SetUpForExternalEncoderFactory(&encoder_factory, codecs)); | 418 SetUpForExternalEncoderFactory(&encoder_factory, codecs)); |
432 | 419 |
433 EXPECT_TRUE( | 420 EXPECT_TRUE( |
434 channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc))); | 421 channel->AddSendStream(cricket::StreamParams::CreateLegacy(kSsrc))); |
435 | 422 |
436 FakeVideoCapturer capturer; | 423 FakeVideoCapturer capturer; |
437 EXPECT_TRUE(channel->SetCapturer(kSsrc, &capturer)); | 424 EXPECT_TRUE(channel->SetCapturer(kSsrc, &capturer)); |
438 capturer.Start(cricket::VideoFormat(1280, 720, | 425 capturer.Start(cricket::VideoFormat(1280, 720, |
439 cricket::VideoFormat::FpsToInterval(60), | 426 cricket::VideoFormat::FpsToInterval(60), |
440 cricket::FOURCC_I420)); | 427 cricket::FOURCC_I420)); |
441 channel->SetSend(true); | 428 channel->SetSend(true); |
442 | 429 |
443 FakeCall* call = factory.GetCall(); | 430 std::vector<FakeVideoSendStream*> streams = fake_call->GetVideoSendStreams(); |
444 std::vector<FakeVideoSendStream*> streams = call->GetVideoSendStreams(); | |
445 FakeVideoSendStream* stream = streams[0]; | 431 FakeVideoSendStream* stream = streams[0]; |
446 | 432 |
447 int64_t timestamp; | 433 int64_t timestamp; |
448 int64_t last_timestamp; | 434 int64_t last_timestamp; |
449 | 435 |
450 EXPECT_TRUE(capturer.CaptureFrame()); | 436 EXPECT_TRUE(capturer.CaptureFrame()); |
451 last_timestamp = stream->GetLastTimestamp(); | 437 last_timestamp = stream->GetLastTimestamp(); |
452 for (int i = 0; i < 10; i++) { | 438 for (int i = 0; i < 10; i++) { |
453 EXPECT_TRUE(capturer.CaptureFrame()); | 439 EXPECT_TRUE(capturer.CaptureFrame()); |
454 timestamp = stream->GetLastTimestamp(); | 440 timestamp = stream->GetLastTimestamp(); |
(...skipping 28 matching lines...) Expand all Loading... |
483 EXPECT_TRUE(channel->RemoveSendStream(kSsrc)); | 469 EXPECT_TRUE(channel->RemoveSendStream(kSsrc)); |
484 } | 470 } |
485 | 471 |
486 VideoMediaChannel* WebRtcVideoEngine2Test::SetUpForExternalEncoderFactory( | 472 VideoMediaChannel* WebRtcVideoEngine2Test::SetUpForExternalEncoderFactory( |
487 cricket::WebRtcVideoEncoderFactory* encoder_factory, | 473 cricket::WebRtcVideoEncoderFactory* encoder_factory, |
488 const std::vector<VideoCodec>& codecs) { | 474 const std::vector<VideoCodec>& codecs) { |
489 engine_.SetExternalEncoderFactory(encoder_factory); | 475 engine_.SetExternalEncoderFactory(encoder_factory); |
490 engine_.Init(); | 476 engine_.Init(); |
491 | 477 |
492 VideoMediaChannel* channel = | 478 VideoMediaChannel* channel = |
493 engine_.CreateChannel(cricket::VideoOptions(), NULL); | 479 engine_.CreateChannel(call_.get(), cricket::VideoOptions()); |
494 EXPECT_TRUE(channel->SetSendCodecs(codecs)); | 480 EXPECT_TRUE(channel->SetSendCodecs(codecs)); |
495 | 481 |
496 return channel; | 482 return channel; |
497 } | 483 } |
498 | 484 |
499 VideoMediaChannel* WebRtcVideoEngine2Test::SetUpForExternalDecoderFactory( | 485 VideoMediaChannel* WebRtcVideoEngine2Test::SetUpForExternalDecoderFactory( |
500 cricket::WebRtcVideoDecoderFactory* decoder_factory, | 486 cricket::WebRtcVideoDecoderFactory* decoder_factory, |
501 const std::vector<VideoCodec>& codecs) { | 487 const std::vector<VideoCodec>& codecs) { |
502 engine_.SetExternalDecoderFactory(decoder_factory); | 488 engine_.SetExternalDecoderFactory(decoder_factory); |
503 engine_.Init(); | 489 engine_.Init(); |
504 | 490 |
505 VideoMediaChannel* channel = | 491 VideoMediaChannel* channel = |
506 engine_.CreateChannel(cricket::VideoOptions(), NULL); | 492 engine_.CreateChannel(call_.get(), cricket::VideoOptions()); |
507 EXPECT_TRUE(channel->SetRecvCodecs(codecs)); | 493 EXPECT_TRUE(channel->SetRecvCodecs(codecs)); |
508 | 494 |
509 return channel; | 495 return channel; |
510 } | 496 } |
511 | 497 |
512 TEST_F(WebRtcVideoEngine2Test, UsesSimulcastAdapterForVp8Factories) { | 498 TEST_F(WebRtcVideoEngine2Test, UsesSimulcastAdapterForVp8Factories) { |
513 cricket::FakeWebRtcVideoEncoderFactory encoder_factory; | 499 cricket::FakeWebRtcVideoEncoderFactory encoder_factory; |
514 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8, "VP8"); | 500 encoder_factory.AddSupportedVideoCodecType(webrtc::kVideoCodecVP8, "VP8"); |
515 std::vector<cricket::VideoCodec> codecs; | 501 std::vector<cricket::VideoCodec> codecs; |
516 codecs.push_back(kVp8Codec); | 502 codecs.push_back(kVp8Codec); |
(...skipping 331 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
848 codec.width /= 2; | 834 codec.width /= 2; |
849 codec.height /= 2; | 835 codec.height /= 2; |
850 EXPECT_TRUE(SetSend(true)); | 836 EXPECT_TRUE(SetSend(true)); |
851 EXPECT_TRUE(channel_->SetRender(true)); | 837 EXPECT_TRUE(channel_->SetRender(true)); |
852 EXPECT_EQ(0, renderer_.num_rendered_frames()); | 838 EXPECT_EQ(0, renderer_.num_rendered_frames()); |
853 EXPECT_TRUE(SendFrame()); | 839 EXPECT_TRUE(SendFrame()); |
854 EXPECT_FRAME_WAIT(1, codec.width, codec.height, kTimeout); | 840 EXPECT_FRAME_WAIT(1, codec.width, codec.height, kTimeout); |
855 } | 841 } |
856 | 842 |
857 class WebRtcVideoChannel2Test : public WebRtcVideoEngine2Test, | 843 class WebRtcVideoChannel2Test : public WebRtcVideoEngine2Test, |
858 public WebRtcCallFactory { | 844 public webrtc::LoadObserver { |
859 public: | 845 public: |
860 WebRtcVideoChannel2Test() : fake_call_(NULL), last_ssrc_(0) {} | 846 WebRtcVideoChannel2Test() : last_ssrc_(0) {} |
861 void SetUp() override { | 847 void SetUp() override { |
862 engine_.SetCallFactory(this); | 848 webrtc::Call::Config call_config; |
| 849 call_config.overuse_callback = this; |
| 850 fake_call_.reset(new FakeCall(call_config)); |
863 engine_.Init(); | 851 engine_.Init(); |
864 channel_.reset(engine_.CreateChannel(cricket::VideoOptions(), NULL)); | 852 channel_.reset( |
865 ASSERT_TRUE(fake_call_ != NULL) << "Call not created through factory."; | 853 engine_.CreateChannel(fake_call_.get(), cricket::VideoOptions())); |
866 last_ssrc_ = 123; | 854 last_ssrc_ = 123; |
867 ASSERT_TRUE(channel_->SetSendCodecs(engine_.codecs())); | 855 ASSERT_TRUE(channel_->SetSendCodecs(engine_.codecs())); |
868 } | 856 } |
869 | 857 |
870 protected: | 858 protected: |
| 859 void OnLoadUpdate(Load load) override { |
| 860 ASSERT_TRUE(channel_.get()); |
| 861 static_cast<cricket::WebRtcVideoChannel2*>( |
| 862 channel_.get())->OnLoadUpdate(load); |
| 863 } |
| 864 |
871 virtual std::vector<cricket::VideoCodec> GetCodecs() { | 865 virtual std::vector<cricket::VideoCodec> GetCodecs() { |
872 return engine_.codecs(); | 866 return engine_.codecs(); |
873 } | 867 } |
874 | 868 |
875 webrtc::Call* CreateCall(const webrtc::Call::Config& config) override { | |
876 DCHECK(fake_call_ == NULL); | |
877 fake_call_ = new FakeCall(config); | |
878 return fake_call_; | |
879 } | |
880 | |
881 FakeVideoSendStream* AddSendStream() { | 869 FakeVideoSendStream* AddSendStream() { |
882 return AddSendStream(StreamParams::CreateLegacy(++last_ssrc_)); | 870 return AddSendStream(StreamParams::CreateLegacy(++last_ssrc_)); |
883 } | 871 } |
884 | 872 |
885 FakeVideoSendStream* AddSendStream(const StreamParams& sp) { | 873 FakeVideoSendStream* AddSendStream(const StreamParams& sp) { |
886 size_t num_streams = fake_call_->GetVideoSendStreams().size(); | 874 size_t num_streams = fake_call_->GetVideoSendStreams().size(); |
887 EXPECT_TRUE(channel_->AddSendStream(sp)); | 875 EXPECT_TRUE(channel_->AddSendStream(sp)); |
888 std::vector<FakeVideoSendStream*> streams = | 876 std::vector<FakeVideoSendStream*> streams = |
889 fake_call_->GetVideoSendStreams(); | 877 fake_call_->GetVideoSendStreams(); |
890 EXPECT_EQ(num_streams + 1, streams.size()); | 878 EXPECT_EQ(num_streams + 1, streams.size()); |
(...skipping 33 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
924 EXPECT_EQ(expected_min_bitrate_bps, | 912 EXPECT_EQ(expected_min_bitrate_bps, |
925 fake_call_->GetConfig().bitrate_config.min_bitrate_bps); | 913 fake_call_->GetConfig().bitrate_config.min_bitrate_bps); |
926 EXPECT_EQ(expected_start_bitrate_bps, | 914 EXPECT_EQ(expected_start_bitrate_bps, |
927 fake_call_->GetConfig().bitrate_config.start_bitrate_bps); | 915 fake_call_->GetConfig().bitrate_config.start_bitrate_bps); |
928 EXPECT_EQ(expected_max_bitrate_bps, | 916 EXPECT_EQ(expected_max_bitrate_bps, |
929 fake_call_->GetConfig().bitrate_config.max_bitrate_bps); | 917 fake_call_->GetConfig().bitrate_config.max_bitrate_bps); |
930 } | 918 } |
931 | 919 |
932 void TestSetSendRtpHeaderExtensions(const std::string& cricket_ext, | 920 void TestSetSendRtpHeaderExtensions(const std::string& cricket_ext, |
933 const std::string& webrtc_ext) { | 921 const std::string& webrtc_ext) { |
934 FakeCall* call = fake_call_; | |
935 // Enable extension. | 922 // Enable extension. |
936 const int id = 1; | 923 const int id = 1; |
937 std::vector<cricket::RtpHeaderExtension> extensions; | 924 std::vector<cricket::RtpHeaderExtension> extensions; |
938 extensions.push_back(cricket::RtpHeaderExtension(cricket_ext, id)); | 925 extensions.push_back(cricket::RtpHeaderExtension(cricket_ext, id)); |
939 EXPECT_TRUE(channel_->SetSendRtpHeaderExtensions(extensions)); | 926 EXPECT_TRUE(channel_->SetSendRtpHeaderExtensions(extensions)); |
940 | 927 |
941 FakeVideoSendStream* send_stream = | 928 FakeVideoSendStream* send_stream = |
942 AddSendStream(cricket::StreamParams::CreateLegacy(123)); | 929 AddSendStream(cricket::StreamParams::CreateLegacy(123)); |
943 | 930 |
944 // Verify the send extension id. | 931 // Verify the send extension id. |
945 ASSERT_EQ(1u, send_stream->GetConfig().rtp.extensions.size()); | 932 ASSERT_EQ(1u, send_stream->GetConfig().rtp.extensions.size()); |
946 EXPECT_EQ(id, send_stream->GetConfig().rtp.extensions[0].id); | 933 EXPECT_EQ(id, send_stream->GetConfig().rtp.extensions[0].id); |
947 EXPECT_EQ(webrtc_ext, send_stream->GetConfig().rtp.extensions[0].name); | 934 EXPECT_EQ(webrtc_ext, send_stream->GetConfig().rtp.extensions[0].name); |
948 // Verify call with same set of extensions returns true. | 935 // Verify call with same set of extensions returns true. |
949 EXPECT_TRUE(channel_->SetSendRtpHeaderExtensions(extensions)); | 936 EXPECT_TRUE(channel_->SetSendRtpHeaderExtensions(extensions)); |
950 // Verify that SetSendRtpHeaderExtensions doesn't implicitly add them for | 937 // Verify that SetSendRtpHeaderExtensions doesn't implicitly add them for |
951 // receivers. | 938 // receivers. |
952 EXPECT_TRUE(AddRecvStream(cricket::StreamParams::CreateLegacy(123)) | 939 EXPECT_TRUE(AddRecvStream(cricket::StreamParams::CreateLegacy(123)) |
953 ->GetConfig() | 940 ->GetConfig() |
954 .rtp.extensions.empty()); | 941 .rtp.extensions.empty()); |
955 | 942 |
956 // Verify that existing RTP header extensions can be removed. | 943 // Verify that existing RTP header extensions can be removed. |
957 std::vector<cricket::RtpHeaderExtension> empty_extensions; | 944 std::vector<cricket::RtpHeaderExtension> empty_extensions; |
958 EXPECT_TRUE(channel_->SetSendRtpHeaderExtensions(empty_extensions)); | 945 EXPECT_TRUE(channel_->SetSendRtpHeaderExtensions(empty_extensions)); |
959 ASSERT_EQ(1u, call->GetVideoSendStreams().size()); | 946 ASSERT_EQ(1u, fake_call_->GetVideoSendStreams().size()); |
960 send_stream = call->GetVideoSendStreams()[0]; | 947 send_stream = fake_call_->GetVideoSendStreams()[0]; |
961 EXPECT_TRUE(send_stream->GetConfig().rtp.extensions.empty()); | 948 EXPECT_TRUE(send_stream->GetConfig().rtp.extensions.empty()); |
962 | 949 |
963 // Verify that adding receive RTP header extensions adds them for existing | 950 // Verify that adding receive RTP header extensions adds them for existing |
964 // streams. | 951 // streams. |
965 EXPECT_TRUE(channel_->SetSendRtpHeaderExtensions(extensions)); | 952 EXPECT_TRUE(channel_->SetSendRtpHeaderExtensions(extensions)); |
966 send_stream = call->GetVideoSendStreams()[0]; | 953 send_stream = fake_call_->GetVideoSendStreams()[0]; |
967 ASSERT_EQ(1u, send_stream->GetConfig().rtp.extensions.size()); | 954 ASSERT_EQ(1u, send_stream->GetConfig().rtp.extensions.size()); |
968 EXPECT_EQ(id, send_stream->GetConfig().rtp.extensions[0].id); | 955 EXPECT_EQ(id, send_stream->GetConfig().rtp.extensions[0].id); |
969 EXPECT_EQ(webrtc_ext, send_stream->GetConfig().rtp.extensions[0].name); | 956 EXPECT_EQ(webrtc_ext, send_stream->GetConfig().rtp.extensions[0].name); |
970 } | 957 } |
971 | 958 |
972 void TestSetRecvRtpHeaderExtensions(const std::string& cricket_ext, | 959 void TestSetRecvRtpHeaderExtensions(const std::string& cricket_ext, |
973 const std::string& webrtc_ext) { | 960 const std::string& webrtc_ext) { |
974 FakeCall* call = fake_call_; | |
975 // Enable extension. | 961 // Enable extension. |
976 const int id = 1; | 962 const int id = 1; |
977 std::vector<cricket::RtpHeaderExtension> extensions; | 963 std::vector<cricket::RtpHeaderExtension> extensions; |
978 extensions.push_back(cricket::RtpHeaderExtension(cricket_ext, id)); | 964 extensions.push_back(cricket::RtpHeaderExtension(cricket_ext, id)); |
979 EXPECT_TRUE(channel_->SetRecvRtpHeaderExtensions(extensions)); | 965 EXPECT_TRUE(channel_->SetRecvRtpHeaderExtensions(extensions)); |
980 | 966 |
981 FakeVideoReceiveStream* recv_stream = | 967 FakeVideoReceiveStream* recv_stream = |
982 AddRecvStream(cricket::StreamParams::CreateLegacy(123)); | 968 AddRecvStream(cricket::StreamParams::CreateLegacy(123)); |
983 | 969 |
984 // Verify the recv extension id. | 970 // Verify the recv extension id. |
985 ASSERT_EQ(1u, recv_stream->GetConfig().rtp.extensions.size()); | 971 ASSERT_EQ(1u, recv_stream->GetConfig().rtp.extensions.size()); |
986 EXPECT_EQ(id, recv_stream->GetConfig().rtp.extensions[0].id); | 972 EXPECT_EQ(id, recv_stream->GetConfig().rtp.extensions[0].id); |
987 EXPECT_EQ(webrtc_ext, recv_stream->GetConfig().rtp.extensions[0].name); | 973 EXPECT_EQ(webrtc_ext, recv_stream->GetConfig().rtp.extensions[0].name); |
988 // Verify call with same set of extensions returns true. | 974 // Verify call with same set of extensions returns true. |
989 EXPECT_TRUE(channel_->SetRecvRtpHeaderExtensions(extensions)); | 975 EXPECT_TRUE(channel_->SetRecvRtpHeaderExtensions(extensions)); |
990 | 976 |
991 // Verify that SetRecvRtpHeaderExtensions doesn't implicitly add them for | 977 // Verify that SetRecvRtpHeaderExtensions doesn't implicitly add them for |
992 // senders. | 978 // senders. |
993 EXPECT_TRUE(AddSendStream(cricket::StreamParams::CreateLegacy(123)) | 979 EXPECT_TRUE(AddSendStream(cricket::StreamParams::CreateLegacy(123)) |
994 ->GetConfig() | 980 ->GetConfig() |
995 .rtp.extensions.empty()); | 981 .rtp.extensions.empty()); |
996 | 982 |
997 // Verify that existing RTP header extensions can be removed. | 983 // Verify that existing RTP header extensions can be removed. |
998 std::vector<cricket::RtpHeaderExtension> empty_extensions; | 984 std::vector<cricket::RtpHeaderExtension> empty_extensions; |
999 EXPECT_TRUE(channel_->SetRecvRtpHeaderExtensions(empty_extensions)); | 985 EXPECT_TRUE(channel_->SetRecvRtpHeaderExtensions(empty_extensions)); |
1000 ASSERT_EQ(1u, call->GetVideoReceiveStreams().size()); | 986 ASSERT_EQ(1u, fake_call_->GetVideoReceiveStreams().size()); |
1001 recv_stream = call->GetVideoReceiveStreams()[0]; | 987 recv_stream = fake_call_->GetVideoReceiveStreams()[0]; |
1002 EXPECT_TRUE(recv_stream->GetConfig().rtp.extensions.empty()); | 988 EXPECT_TRUE(recv_stream->GetConfig().rtp.extensions.empty()); |
1003 | 989 |
1004 // Verify that adding receive RTP header extensions adds them for existing | 990 // Verify that adding receive RTP header extensions adds them for existing |
1005 // streams. | 991 // streams. |
1006 EXPECT_TRUE(channel_->SetRecvRtpHeaderExtensions(extensions)); | 992 EXPECT_TRUE(channel_->SetRecvRtpHeaderExtensions(extensions)); |
1007 recv_stream = call->GetVideoReceiveStreams()[0]; | 993 recv_stream = fake_call_->GetVideoReceiveStreams()[0]; |
1008 ASSERT_EQ(1u, recv_stream->GetConfig().rtp.extensions.size()); | 994 ASSERT_EQ(1u, recv_stream->GetConfig().rtp.extensions.size()); |
1009 EXPECT_EQ(id, recv_stream->GetConfig().rtp.extensions[0].id); | 995 EXPECT_EQ(id, recv_stream->GetConfig().rtp.extensions[0].id); |
1010 EXPECT_EQ(webrtc_ext, recv_stream->GetConfig().rtp.extensions[0].name); | 996 EXPECT_EQ(webrtc_ext, recv_stream->GetConfig().rtp.extensions[0].name); |
1011 } | 997 } |
1012 | 998 |
1013 void TestCpuAdaptation(bool enable_overuse, bool is_screenshare); | 999 void TestCpuAdaptation(bool enable_overuse, bool is_screenshare); |
1014 void TestReceiverLocalSsrcConfiguration(bool receiver_first); | 1000 void TestReceiverLocalSsrcConfiguration(bool receiver_first); |
1015 void TestReceiveUnsignalledSsrcPacket(uint8_t payload_type, | 1001 void TestReceiveUnsignalledSsrcPacket(uint8_t payload_type, |
1016 bool expect_created_receive_stream); | 1002 bool expect_created_receive_stream); |
1017 | 1003 |
(...skipping 10 matching lines...) Expand all Loading... |
1028 std::vector<uint32_t> ssrcs; | 1014 std::vector<uint32_t> ssrcs; |
1029 ssrcs.push_back(last_ssrc_); | 1015 ssrcs.push_back(last_ssrc_); |
1030 ssrcs.push_back(last_ssrc_ + 1); | 1016 ssrcs.push_back(last_ssrc_ + 1); |
1031 ssrcs.push_back(last_ssrc_ + 2); | 1017 ssrcs.push_back(last_ssrc_ + 2); |
1032 return AddSendStream(CreateSimStreamParams("cname", ssrcs)); | 1018 return AddSendStream(CreateSimStreamParams("cname", ssrcs)); |
1033 } else { | 1019 } else { |
1034 return AddSendStream(StreamParams::CreateLegacy(last_ssrc_)); | 1020 return AddSendStream(StreamParams::CreateLegacy(last_ssrc_)); |
1035 } | 1021 } |
1036 } | 1022 } |
1037 | 1023 |
1038 FakeCall* fake_call_; | 1024 rtc::scoped_ptr<FakeCall> fake_call_; |
1039 rtc::scoped_ptr<VideoMediaChannel> channel_; | 1025 rtc::scoped_ptr<VideoMediaChannel> channel_; |
1040 uint32 last_ssrc_; | 1026 uint32 last_ssrc_; |
1041 }; | 1027 }; |
1042 | 1028 |
1043 TEST_F(WebRtcVideoChannel2Test, SetsSyncGroupFromSyncLabel) { | 1029 TEST_F(WebRtcVideoChannel2Test, SetsSyncGroupFromSyncLabel) { |
1044 const uint32 kVideoSsrc = 123; | 1030 const uint32 kVideoSsrc = 123; |
1045 const std::string kSyncLabel = "AvSyncLabel"; | 1031 const std::string kSyncLabel = "AvSyncLabel"; |
1046 | 1032 |
1047 cricket::StreamParams sp = cricket::StreamParams::CreateLegacy(kVideoSsrc); | 1033 cricket::StreamParams sp = cricket::StreamParams::CreateLegacy(kVideoSsrc); |
1048 sp.sync_label = kSyncLabel; | 1034 sp.sync_label = kSyncLabel; |
(...skipping 1713 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2762 TEST_F(WebRtcVideoChannel2Test, ConfiguresLocalSsrc) { | 2748 TEST_F(WebRtcVideoChannel2Test, ConfiguresLocalSsrc) { |
2763 TestReceiverLocalSsrcConfiguration(false); | 2749 TestReceiverLocalSsrcConfiguration(false); |
2764 } | 2750 } |
2765 | 2751 |
2766 TEST_F(WebRtcVideoChannel2Test, ConfiguresLocalSsrcOnExistingReceivers) { | 2752 TEST_F(WebRtcVideoChannel2Test, ConfiguresLocalSsrcOnExistingReceivers) { |
2767 TestReceiverLocalSsrcConfiguration(true); | 2753 TestReceiverLocalSsrcConfiguration(true); |
2768 } | 2754 } |
2769 | 2755 |
2770 class WebRtcVideoEngine2SimulcastTest : public testing::Test { | 2756 class WebRtcVideoEngine2SimulcastTest : public testing::Test { |
2771 public: | 2757 public: |
2772 WebRtcVideoEngine2SimulcastTest() : engine_(nullptr) {} | 2758 WebRtcVideoEngine2SimulcastTest() {} |
2773 | 2759 |
2774 protected: | 2760 protected: |
2775 WebRtcVideoEngine2 engine_; | 2761 WebRtcVideoEngine2 engine_; |
2776 }; | 2762 }; |
2777 | 2763 |
2778 // Test that if we add a stream with RTX SSRC's, SSRC's get set correctly. | 2764 // Test that if we add a stream with RTX SSRC's, SSRC's get set correctly. |
2779 TEST_F(WebRtcVideoEngine2SimulcastTest, DISABLED_TestStreamWithRtx) { | 2765 TEST_F(WebRtcVideoEngine2SimulcastTest, DISABLED_TestStreamWithRtx) { |
2780 // TODO(pbos): Implement. | 2766 // TODO(pbos): Implement. |
2781 FAIL() << "Not implemented."; | 2767 FAIL() << "Not implemented."; |
2782 } | 2768 } |
(...skipping 130 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2913 // TODO(pbos): Implement. | 2899 // TODO(pbos): Implement. |
2914 FAIL() << "Not implemented."; | 2900 FAIL() << "Not implemented."; |
2915 } | 2901 } |
2916 | 2902 |
2917 TEST_F(WebRtcVideoEngine2SimulcastTest, | 2903 TEST_F(WebRtcVideoEngine2SimulcastTest, |
2918 DISABLED_DontUseSimulcastAdapterOnNonVp8Factory) { | 2904 DISABLED_DontUseSimulcastAdapterOnNonVp8Factory) { |
2919 // TODO(pbos): Implement. | 2905 // TODO(pbos): Implement. |
2920 FAIL() << "Not implemented."; | 2906 FAIL() << "Not implemented."; |
2921 } | 2907 } |
2922 | 2908 |
2923 class WebRtcVideoChannel2SimulcastTest : public WebRtcVideoEngine2SimulcastTest, | 2909 class WebRtcVideoChannel2SimulcastTest : public testing::Test { |
2924 public WebRtcCallFactory { | |
2925 public: | 2910 public: |
2926 WebRtcVideoChannel2SimulcastTest() : fake_call_(NULL) {} | 2911 WebRtcVideoChannel2SimulcastTest() : fake_call_(webrtc::Call::Config()) {} |
2927 | 2912 |
2928 void SetUp() override { | 2913 void SetUp() override { |
2929 engine_.SetCallFactory(this); | |
2930 engine_.Init(); | 2914 engine_.Init(); |
2931 channel_.reset(engine_.CreateChannel(VideoOptions(), NULL)); | 2915 channel_.reset(engine_.CreateChannel(&fake_call_, VideoOptions())); |
2932 ASSERT_TRUE(fake_call_ != NULL) << "Call not created through factory."; | |
2933 last_ssrc_ = 123; | 2916 last_ssrc_ = 123; |
2934 } | 2917 } |
2935 | 2918 |
2936 protected: | 2919 protected: |
2937 webrtc::Call* CreateCall(const webrtc::Call::Config& config) override { | |
2938 DCHECK(fake_call_ == NULL); | |
2939 fake_call_ = new FakeCall(config); | |
2940 return fake_call_; | |
2941 } | |
2942 | |
2943 void VerifySimulcastSettings(const VideoCodec& codec, | 2920 void VerifySimulcastSettings(const VideoCodec& codec, |
2944 VideoOptions::HighestBitrate bitrate_mode, | 2921 VideoOptions::HighestBitrate bitrate_mode, |
2945 size_t num_configured_streams, | 2922 size_t num_configured_streams, |
2946 size_t expected_num_streams, | 2923 size_t expected_num_streams, |
2947 SimulcastBitrateMode simulcast_bitrate_mode) { | 2924 SimulcastBitrateMode simulcast_bitrate_mode) { |
2948 cricket::VideoOptions options; | 2925 cricket::VideoOptions options; |
2949 options.video_highest_bitrate.Set(bitrate_mode); | 2926 options.video_highest_bitrate.Set(bitrate_mode); |
2950 EXPECT_TRUE(channel_->SetOptions(options)); | 2927 EXPECT_TRUE(channel_->SetOptions(options)); |
2951 | 2928 |
2952 std::vector<VideoCodec> codecs; | 2929 std::vector<VideoCodec> codecs; |
(...skipping 73 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3026 | 3003 |
3027 EXPECT_TRUE(channel_->SetCapturer(ssrcs.front(), NULL)); | 3004 EXPECT_TRUE(channel_->SetCapturer(ssrcs.front(), NULL)); |
3028 } | 3005 } |
3029 | 3006 |
3030 FakeVideoSendStream* AddSendStream() { | 3007 FakeVideoSendStream* AddSendStream() { |
3031 return AddSendStream(StreamParams::CreateLegacy(last_ssrc_++)); | 3008 return AddSendStream(StreamParams::CreateLegacy(last_ssrc_++)); |
3032 } | 3009 } |
3033 | 3010 |
3034 FakeVideoSendStream* AddSendStream(const StreamParams& sp) { | 3011 FakeVideoSendStream* AddSendStream(const StreamParams& sp) { |
3035 size_t num_streams = | 3012 size_t num_streams = |
3036 fake_call_->GetVideoSendStreams().size(); | 3013 fake_call_.GetVideoSendStreams().size(); |
3037 EXPECT_TRUE(channel_->AddSendStream(sp)); | 3014 EXPECT_TRUE(channel_->AddSendStream(sp)); |
3038 std::vector<FakeVideoSendStream*> streams = | 3015 std::vector<FakeVideoSendStream*> streams = |
3039 fake_call_->GetVideoSendStreams(); | 3016 fake_call_.GetVideoSendStreams(); |
3040 EXPECT_EQ(num_streams + 1, streams.size()); | 3017 EXPECT_EQ(num_streams + 1, streams.size()); |
3041 return streams[streams.size() - 1]; | 3018 return streams[streams.size() - 1]; |
3042 } | 3019 } |
3043 | 3020 |
3044 std::vector<FakeVideoSendStream*> GetFakeSendStreams() { | 3021 std::vector<FakeVideoSendStream*> GetFakeSendStreams() { |
3045 return fake_call_->GetVideoSendStreams(); | 3022 return fake_call_.GetVideoSendStreams(); |
3046 } | 3023 } |
3047 | 3024 |
3048 FakeVideoReceiveStream* AddRecvStream() { | 3025 FakeVideoReceiveStream* AddRecvStream() { |
3049 return AddRecvStream(StreamParams::CreateLegacy(last_ssrc_++)); | 3026 return AddRecvStream(StreamParams::CreateLegacy(last_ssrc_++)); |
3050 } | 3027 } |
3051 | 3028 |
3052 FakeVideoReceiveStream* AddRecvStream(const StreamParams& sp) { | 3029 FakeVideoReceiveStream* AddRecvStream(const StreamParams& sp) { |
3053 size_t num_streams = | 3030 size_t num_streams = |
3054 fake_call_->GetVideoReceiveStreams().size(); | 3031 fake_call_.GetVideoReceiveStreams().size(); |
3055 EXPECT_TRUE(channel_->AddRecvStream(sp)); | 3032 EXPECT_TRUE(channel_->AddRecvStream(sp)); |
3056 std::vector<FakeVideoReceiveStream*> streams = | 3033 std::vector<FakeVideoReceiveStream*> streams = |
3057 fake_call_->GetVideoReceiveStreams(); | 3034 fake_call_.GetVideoReceiveStreams(); |
3058 EXPECT_EQ(num_streams + 1, streams.size()); | 3035 EXPECT_EQ(num_streams + 1, streams.size()); |
3059 return streams[streams.size() - 1]; | 3036 return streams[streams.size() - 1]; |
3060 } | 3037 } |
3061 | 3038 |
3062 FakeCall* fake_call_; | 3039 FakeCall fake_call_; |
| 3040 WebRtcVideoEngine2 engine_; |
3063 rtc::scoped_ptr<VideoMediaChannel> channel_; | 3041 rtc::scoped_ptr<VideoMediaChannel> channel_; |
3064 uint32 last_ssrc_; | 3042 uint32 last_ssrc_; |
3065 }; | 3043 }; |
3066 | 3044 |
3067 TEST_F(WebRtcVideoChannel2SimulcastTest, SetSendCodecsWith2SimulcastStreams) { | 3045 TEST_F(WebRtcVideoChannel2SimulcastTest, SetSendCodecsWith2SimulcastStreams) { |
3068 VerifySimulcastSettings(kVp8Codec, VideoOptions::NORMAL, 2, 2, SBM_NORMAL); | 3046 VerifySimulcastSettings(kVp8Codec, VideoOptions::NORMAL, 2, 2, SBM_NORMAL); |
3069 } | 3047 } |
3070 | 3048 |
3071 TEST_F(WebRtcVideoChannel2SimulcastTest, SetSendCodecsWith3SimulcastStreams) { | 3049 TEST_F(WebRtcVideoChannel2SimulcastTest, SetSendCodecsWith3SimulcastStreams) { |
3072 VerifySimulcastSettings( | 3050 VerifySimulcastSettings( |
(...skipping 105 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3178 // Ensures that the correct settings are applied to the codec when two temporal | 3156 // Ensures that the correct settings are applied to the codec when two temporal |
3179 // layer screencasting is enabled, and that the correct simulcast settings are | 3157 // layer screencasting is enabled, and that the correct simulcast settings are |
3180 // reapplied when disabling screencasting. | 3158 // reapplied when disabling screencasting. |
3181 TEST_F(WebRtcVideoChannel2SimulcastTest, | 3159 TEST_F(WebRtcVideoChannel2SimulcastTest, |
3182 DISABLED_TwoTemporalLayerScreencastSettings) { | 3160 DISABLED_TwoTemporalLayerScreencastSettings) { |
3183 // TODO(pbos): Implement. | 3161 // TODO(pbos): Implement. |
3184 FAIL() << "Not implemented."; | 3162 FAIL() << "Not implemented."; |
3185 } | 3163 } |
3186 | 3164 |
3187 } // namespace cricket | 3165 } // namespace cricket |
OLD | NEW |