OLD | NEW |
1 /* | 1 /* |
2 * Copyright (c) 2013 The WebRTC project authors. All Rights Reserved. | 2 * Copyright (c) 2013 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 #include <algorithm> | 10 #include <algorithm> |
(...skipping 1813 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1824 uint32_t first_media_ssrc_; | 1824 uint32_t first_media_ssrc_; |
1825 std::map<uint32_t, uint32_t> rtx_to_media_ssrcs_; | 1825 std::map<uint32_t, uint32_t> rtx_to_media_ssrcs_; |
1826 RtpExtensionHeaderObserver* observer_; | 1826 RtpExtensionHeaderObserver* observer_; |
1827 } tester; | 1827 } tester; |
1828 | 1828 |
1829 tester.RunTest(); | 1829 tester.RunTest(); |
1830 } | 1830 } |
1831 | 1831 |
1832 class TransportFeedbackTester : public test::EndToEndTest { | 1832 class TransportFeedbackTester : public test::EndToEndTest { |
1833 public: | 1833 public: |
1834 TransportFeedbackTester(bool feedback_enabled, | 1834 explicit TransportFeedbackTester(bool feedback_enabled, |
1835 size_t num_video_streams, | 1835 size_t num_video_streams, |
1836 size_t num_audio_streams) | 1836 size_t num_audio_streams) |
1837 : EndToEndTest(::webrtc::EndToEndTest::kDefaultTimeoutMs), | 1837 : EndToEndTest(::webrtc::EndToEndTest::kDefaultTimeoutMs), |
1838 feedback_enabled_(feedback_enabled), | 1838 feedback_enabled_(feedback_enabled), |
1839 num_video_streams_(num_video_streams), | 1839 num_video_streams_(num_video_streams), |
1840 num_audio_streams_(num_audio_streams), | 1840 num_audio_streams_(num_audio_streams), |
1841 receiver_call_(nullptr) { | 1841 receiver_call_(nullptr) { |
1842 // Only one stream of each supported for now. | 1842 // Only one stream of each supported for now. |
1843 EXPECT_LE(num_video_streams, 1u); | 1843 EXPECT_LE(num_video_streams, 1u); |
1844 EXPECT_LE(num_audio_streams, 1u); | 1844 EXPECT_LE(num_audio_streams, 1u); |
1845 } | 1845 } |
1846 | 1846 |
(...skipping 74 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1921 TEST_F(EndToEndTest, AudioTransportFeedbackNotConfigured) { | 1921 TEST_F(EndToEndTest, AudioTransportFeedbackNotConfigured) { |
1922 TransportFeedbackTester test(false, 0, 1); | 1922 TransportFeedbackTester test(false, 0, 1); |
1923 RunBaseTest(&test); | 1923 RunBaseTest(&test); |
1924 } | 1924 } |
1925 | 1925 |
1926 TEST_F(EndToEndTest, AudioVideoReceivesTransportFeedback) { | 1926 TEST_F(EndToEndTest, AudioVideoReceivesTransportFeedback) { |
1927 TransportFeedbackTester test(true, 1, 1); | 1927 TransportFeedbackTester test(true, 1, 1); |
1928 RunBaseTest(&test); | 1928 RunBaseTest(&test); |
1929 } | 1929 } |
1930 | 1930 |
1931 TEST_F(EndToEndTest, StopsSendingMediaWithoutFeedback) { | |
1932 test::ScopedFieldTrials override_field_trials( | |
1933 "WebRTC-CwndExperiment/Enabled/"); | |
1934 | |
1935 class TransportFeedbackTester : public test::EndToEndTest { | |
1936 public: | |
1937 TransportFeedbackTester(size_t num_video_streams, size_t num_audio_streams) | |
1938 : EndToEndTest(::webrtc::EndToEndTest::kDefaultTimeoutMs), | |
1939 num_video_streams_(num_video_streams), | |
1940 num_audio_streams_(num_audio_streams), | |
1941 media_sent_(0), | |
1942 padding_sent_(0) { | |
1943 // Only one stream of each supported for now. | |
1944 EXPECT_LE(num_video_streams, 1u); | |
1945 EXPECT_LE(num_audio_streams, 1u); | |
1946 } | |
1947 | |
1948 protected: | |
1949 Action OnSendRtp(const uint8_t* packet, size_t length) override { | |
1950 RTPHeader header; | |
1951 EXPECT_TRUE(parser_->Parse(packet, length, &header)); | |
1952 const bool only_padding = | |
1953 header.headerLength + header.paddingLength == length; | |
1954 rtc::CritScope lock(&crit_); | |
1955 if (only_padding) { | |
1956 ++padding_sent_; | |
1957 } else { | |
1958 ++media_sent_; | |
1959 EXPECT_LT(media_sent_, 40) << "Media sent without feedback."; | |
1960 } | |
1961 | |
1962 return SEND_PACKET; | |
1963 } | |
1964 | |
1965 Action OnReceiveRtcp(const uint8_t* data, size_t length) override { | |
1966 rtc::CritScope lock(&crit_); | |
1967 if (media_sent_ > 20 && HasTransportFeedback(data, length)) { | |
1968 return DROP_PACKET; | |
1969 } | |
1970 return SEND_PACKET; | |
1971 } | |
1972 | |
1973 bool HasTransportFeedback(const uint8_t* data, size_t length) const { | |
1974 test::RtcpPacketParser parser; | |
1975 EXPECT_TRUE(parser.Parse(data, length)); | |
1976 return parser.transport_feedback()->num_packets() > 0; | |
1977 } | |
1978 | |
1979 Call::Config GetSenderCallConfig() override { | |
1980 Call::Config config = EndToEndTest::GetSenderCallConfig(); | |
1981 config.bitrate_config.max_bitrate_bps = 300000; | |
1982 return config; | |
1983 } | |
1984 | |
1985 void PerformTest() override { | |
1986 const int64_t kDisabledFeedbackTimeoutMs = 10000; | |
1987 observation_complete_.Wait(kDisabledFeedbackTimeoutMs); | |
1988 rtc::CritScope lock(&crit_); | |
1989 EXPECT_GT(padding_sent_, 0); | |
1990 } | |
1991 | |
1992 size_t GetNumVideoStreams() const override { return num_video_streams_; } | |
1993 size_t GetNumAudioStreams() const override { return num_audio_streams_; } | |
1994 | |
1995 private: | |
1996 const size_t num_video_streams_; | |
1997 const size_t num_audio_streams_; | |
1998 rtc::CriticalSection crit_; | |
1999 int media_sent_ GUARDED_BY(crit_); | |
2000 int padding_sent_ GUARDED_BY(crit_); | |
2001 } test(1, 0); | |
2002 RunBaseTest(&test); | |
2003 } | |
2004 | |
2005 TEST_F(EndToEndTest, ObserversEncodedFrames) { | 1931 TEST_F(EndToEndTest, ObserversEncodedFrames) { |
2006 class EncodedFrameTestObserver : public EncodedFrameObserver { | 1932 class EncodedFrameTestObserver : public EncodedFrameObserver { |
2007 public: | 1933 public: |
2008 EncodedFrameTestObserver() | 1934 EncodedFrameTestObserver() |
2009 : length_(0), frame_type_(kEmptyFrame), called_(false, false) {} | 1935 : length_(0), frame_type_(kEmptyFrame), called_(false, false) {} |
2010 virtual ~EncodedFrameTestObserver() {} | 1936 virtual ~EncodedFrameTestObserver() {} |
2011 | 1937 |
2012 virtual void EncodedFrameCallback(const EncodedFrame& encoded_frame) { | 1938 virtual void EncodedFrameCallback(const EncodedFrame& encoded_frame) { |
2013 frame_type_ = encoded_frame.frame_type_; | 1939 frame_type_ = encoded_frame.frame_type_; |
2014 length_ = encoded_frame.length_; | 1940 length_ = encoded_frame.length_; |
(...skipping 460 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2475 }; | 2401 }; |
2476 | 2402 |
2477 bool success; | 2403 bool success; |
2478 const int kMaxAttempts = 3; | 2404 const int kMaxAttempts = 3; |
2479 for (int i = 0; i < kMaxAttempts; ++i) { | 2405 for (int i = 0; i < kMaxAttempts; ++i) { |
2480 TriggerMidCallProbingTest test(&success); | 2406 TriggerMidCallProbingTest test(&success); |
2481 RunBaseTest(&test); | 2407 RunBaseTest(&test); |
2482 if (success) | 2408 if (success) |
2483 return; | 2409 return; |
2484 } | 2410 } |
2485 EXPECT_TRUE(success) << "Failed to perform mid call probing (" << kMaxAttempts | 2411 RTC_DCHECK(success) << "Failed to perform mid call probing (" << kMaxAttempts |
2486 << " attempts)."; | 2412 << " attempts)."; |
2487 } | 2413 } |
2488 | 2414 |
2489 TEST_F(EndToEndTest, VerifyNackStats) { | 2415 TEST_F(EndToEndTest, VerifyNackStats) { |
2490 static const int kPacketNumberToDrop = 200; | 2416 static const int kPacketNumberToDrop = 200; |
2491 class NackObserver : public test::EndToEndTest { | 2417 class NackObserver : public test::EndToEndTest { |
2492 public: | 2418 public: |
2493 NackObserver() | 2419 NackObserver() |
2494 : EndToEndTest(kLongTimeoutMs), | 2420 : EndToEndTest(kLongTimeoutMs), |
2495 sent_rtp_packets_(0), | 2421 sent_rtp_packets_(0), |
2496 dropped_rtp_packet_(0), | 2422 dropped_rtp_packet_(0), |
(...skipping 1764 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4261 public: | 4187 public: |
4262 NetworkStateTest() | 4188 NetworkStateTest() |
4263 : EndToEndTest(kDefaultTimeoutMs), | 4189 : EndToEndTest(kDefaultTimeoutMs), |
4264 FakeEncoder(Clock::GetRealTimeClock()), | 4190 FakeEncoder(Clock::GetRealTimeClock()), |
4265 encoded_frames_(false, false), | 4191 encoded_frames_(false, false), |
4266 packet_event_(false, false), | 4192 packet_event_(false, false), |
4267 sender_call_(nullptr), | 4193 sender_call_(nullptr), |
4268 receiver_call_(nullptr), | 4194 receiver_call_(nullptr), |
4269 sender_state_(kNetworkUp), | 4195 sender_state_(kNetworkUp), |
4270 sender_rtp_(0), | 4196 sender_rtp_(0), |
4271 sender_padding_(0), | |
4272 sender_rtcp_(0), | 4197 sender_rtcp_(0), |
4273 receiver_rtcp_(0), | 4198 receiver_rtcp_(0), |
4274 down_frames_(0) {} | 4199 down_frames_(0) {} |
4275 | 4200 |
4276 Action OnSendRtp(const uint8_t* packet, size_t length) override { | 4201 Action OnSendRtp(const uint8_t* packet, size_t length) override { |
4277 rtc::CritScope lock(&test_crit_); | 4202 rtc::CritScope lock(&test_crit_); |
4278 RTPHeader header; | |
4279 EXPECT_TRUE(parser_->Parse(packet, length, &header)); | |
4280 if (length == header.headerLength + header.paddingLength) | |
4281 ++sender_padding_; | |
4282 ++sender_rtp_; | 4203 ++sender_rtp_; |
4283 packet_event_.Set(); | 4204 packet_event_.Set(); |
4284 return SEND_PACKET; | 4205 return SEND_PACKET; |
4285 } | 4206 } |
4286 | 4207 |
4287 Action OnSendRtcp(const uint8_t* packet, size_t length) override { | 4208 Action OnSendRtcp(const uint8_t* packet, size_t length) override { |
4288 rtc::CritScope lock(&test_crit_); | 4209 rtc::CritScope lock(&test_crit_); |
4289 ++sender_rtcp_; | 4210 ++sender_rtcp_; |
4290 packet_event_.Set(); | 4211 packet_event_.Set(); |
4291 return SEND_PACKET; | 4212 return SEND_PACKET; |
(...skipping 104 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4396 initial_sender_rtcp = sender_rtcp_; | 4317 initial_sender_rtcp = sender_rtcp_; |
4397 initial_receiver_rtcp = receiver_rtcp_; | 4318 initial_receiver_rtcp = receiver_rtcp_; |
4398 } | 4319 } |
4399 bool sender_done = false; | 4320 bool sender_done = false; |
4400 bool receiver_done = false; | 4321 bool receiver_done = false; |
4401 while (!sender_done || !receiver_done) { | 4322 while (!sender_done || !receiver_done) { |
4402 packet_event_.Wait(kSilenceTimeoutMs); | 4323 packet_event_.Wait(kSilenceTimeoutMs); |
4403 int64_t time_now_ms = clock_->TimeInMilliseconds(); | 4324 int64_t time_now_ms = clock_->TimeInMilliseconds(); |
4404 rtc::CritScope lock(&test_crit_); | 4325 rtc::CritScope lock(&test_crit_); |
4405 if (sender_down) { | 4326 if (sender_down) { |
4406 ASSERT_LE(sender_rtp_ - initial_sender_rtp - sender_padding_, | 4327 ASSERT_LE(sender_rtp_ - initial_sender_rtp, kNumAcceptedDowntimeRtp) |
4407 kNumAcceptedDowntimeRtp) | |
4408 << "RTP sent during sender-side downtime."; | 4328 << "RTP sent during sender-side downtime."; |
4409 ASSERT_LE(sender_rtcp_ - initial_sender_rtcp, | 4329 ASSERT_LE(sender_rtcp_ - initial_sender_rtcp, |
4410 kNumAcceptedDowntimeRtcp) | 4330 kNumAcceptedDowntimeRtcp) |
4411 << "RTCP sent during sender-side downtime."; | 4331 << "RTCP sent during sender-side downtime."; |
4412 if (time_now_ms - initial_time_ms >= | 4332 if (time_now_ms - initial_time_ms >= |
4413 static_cast<int64_t>(kSilenceTimeoutMs)) { | 4333 static_cast<int64_t>(kSilenceTimeoutMs)) { |
4414 sender_done = true; | 4334 sender_done = true; |
4415 } | 4335 } |
4416 } else { | 4336 } else { |
4417 if (sender_rtp_ > initial_sender_rtp + kNumAcceptedDowntimeRtp) | 4337 if (sender_rtp_ > initial_sender_rtp + kNumAcceptedDowntimeRtp) |
(...skipping 14 matching lines...) Expand all Loading... |
4432 } | 4352 } |
4433 } | 4353 } |
4434 | 4354 |
4435 rtc::CriticalSection test_crit_; | 4355 rtc::CriticalSection test_crit_; |
4436 rtc::Event encoded_frames_; | 4356 rtc::Event encoded_frames_; |
4437 rtc::Event packet_event_; | 4357 rtc::Event packet_event_; |
4438 Call* sender_call_; | 4358 Call* sender_call_; |
4439 Call* receiver_call_; | 4359 Call* receiver_call_; |
4440 NetworkState sender_state_ GUARDED_BY(test_crit_); | 4360 NetworkState sender_state_ GUARDED_BY(test_crit_); |
4441 int sender_rtp_ GUARDED_BY(test_crit_); | 4361 int sender_rtp_ GUARDED_BY(test_crit_); |
4442 int sender_padding_ GUARDED_BY(test_crit_); | |
4443 int sender_rtcp_ GUARDED_BY(test_crit_); | 4362 int sender_rtcp_ GUARDED_BY(test_crit_); |
4444 int receiver_rtcp_ GUARDED_BY(test_crit_); | 4363 int receiver_rtcp_ GUARDED_BY(test_crit_); |
4445 int down_frames_ GUARDED_BY(test_crit_); | 4364 int down_frames_ GUARDED_BY(test_crit_); |
4446 } test; | 4365 } test; |
4447 | 4366 |
4448 RunBaseTest(&test); | 4367 RunBaseTest(&test); |
4449 } | 4368 } |
4450 | 4369 |
4451 TEST_F(EndToEndTest, CallReportsRttForSender) { | 4370 TEST_F(EndToEndTest, CallReportsRttForSender) { |
4452 static const int kSendDelayMs = 30; | 4371 static const int kSendDelayMs = 30; |
(...skipping 385 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4838 std::unique_ptr<VideoEncoder> encoder_; | 4757 std::unique_ptr<VideoEncoder> encoder_; |
4839 std::unique_ptr<VideoDecoder> decoder_; | 4758 std::unique_ptr<VideoDecoder> decoder_; |
4840 rtc::CriticalSection crit_; | 4759 rtc::CriticalSection crit_; |
4841 int recorded_frames_ GUARDED_BY(crit_); | 4760 int recorded_frames_ GUARDED_BY(crit_); |
4842 } test(this); | 4761 } test(this); |
4843 | 4762 |
4844 RunBaseTest(&test); | 4763 RunBaseTest(&test); |
4845 } | 4764 } |
4846 | 4765 |
4847 } // namespace webrtc | 4766 } // namespace webrtc |
OLD | NEW |