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 1524 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1535 | 1535 |
1536 private: | 1536 private: |
1537 uint32_t first_media_ssrc_; | 1537 uint32_t first_media_ssrc_; |
1538 std::map<uint32_t, uint32_t> rtx_to_media_ssrcs_; | 1538 std::map<uint32_t, uint32_t> rtx_to_media_ssrcs_; |
1539 RtpExtensionHeaderObserver* observer_; | 1539 RtpExtensionHeaderObserver* observer_; |
1540 } tester; | 1540 } tester; |
1541 | 1541 |
1542 tester.RunTest(); | 1542 tester.RunTest(); |
1543 } | 1543 } |
1544 | 1544 |
1545 void TransportFeedbackTest(bool feedback_enabled) { | 1545 class TransportFeedbackTester : public test::EndToEndTest { |
1546 static const int kExtensionId = 5; | 1546 public: |
1547 class TransportFeedbackObserver : public test::DirectTransport { | 1547 explicit TransportFeedbackTester(bool feedback_enabled, |
1548 public: | 1548 size_t num_video_streams, |
1549 TransportFeedbackObserver(Call* receiver_call, rtc::Event* done_event) | 1549 size_t num_audio_streams) |
1550 : DirectTransport(receiver_call), done_(done_event) {} | 1550 : EndToEndTest(::webrtc::EndToEndTest::kDefaultTimeoutMs), |
1551 virtual ~TransportFeedbackObserver() {} | 1551 feedback_enabled_(feedback_enabled), |
| 1552 num_video_streams_(num_video_streams), |
| 1553 num_audio_streams_(num_audio_streams) { |
| 1554 // Only one stream of each supported for now. |
| 1555 EXPECT_LE(num_video_streams, 1u); |
| 1556 EXPECT_LE(num_audio_streams, 1u); |
| 1557 } |
1552 | 1558 |
1553 bool SendRtcp(const uint8_t* data, size_t length) override { | 1559 protected: |
1554 RTCPUtility::RTCPParserV2 parser(data, length, true); | 1560 Action OnSendRtcp(const uint8_t* data, size_t length) override { |
1555 EXPECT_TRUE(parser.IsValid()); | 1561 EXPECT_FALSE(HasTransportFeedback(data, length)); |
| 1562 return SEND_PACKET; |
| 1563 } |
1556 | 1564 |
1557 RTCPUtility::RTCPPacketTypes packet_type = parser.Begin(); | 1565 Action OnReceiveRtcp(const uint8_t* data, size_t length) override { |
1558 while (packet_type != RTCPUtility::RTCPPacketTypes::kInvalid) { | 1566 if (HasTransportFeedback(data, length)) |
1559 if (packet_type == RTCPUtility::RTCPPacketTypes::kTransportFeedback) { | 1567 observation_complete_.Set(); |
1560 done_->Set(); | 1568 return SEND_PACKET; |
1561 break; | 1569 } |
1562 } | |
1563 packet_type = parser.Iterate(); | |
1564 } | |
1565 | 1570 |
1566 return test::DirectTransport::SendRtcp(data, length); | 1571 bool HasTransportFeedback(const uint8_t* data, size_t length) const { |
| 1572 RTCPUtility::RTCPParserV2 parser(data, length, true); |
| 1573 EXPECT_TRUE(parser.IsValid()); |
| 1574 |
| 1575 RTCPUtility::RTCPPacketTypes packet_type = parser.Begin(); |
| 1576 while (packet_type != RTCPUtility::RTCPPacketTypes::kInvalid) { |
| 1577 if (packet_type == RTCPUtility::RTCPPacketTypes::kTransportFeedback) |
| 1578 return true; |
| 1579 packet_type = parser.Iterate(); |
1567 } | 1580 } |
1568 | 1581 |
1569 rtc::Event* done_; | 1582 return false; |
1570 }; | 1583 } |
1571 | 1584 |
1572 class TransportFeedbackTester : public MultiStreamTest { | 1585 void PerformTest() override { |
1573 public: | 1586 const int64_t kDisabledFeedbackTimeoutMs = 5000; |
1574 explicit TransportFeedbackTester(bool feedback_enabled) | 1587 EXPECT_EQ(feedback_enabled_, |
1575 : feedback_enabled_(feedback_enabled), done_(false, false) {} | 1588 observation_complete_.Wait(feedback_enabled_ |
1576 virtual ~TransportFeedbackTester() {} | 1589 ? test::CallTest::kDefaultTimeoutMs |
| 1590 : kDisabledFeedbackTimeoutMs)); |
| 1591 } |
1577 | 1592 |
1578 protected: | 1593 void OnCallsCreated(Call* sender_call, Call* receiver_call) override { |
1579 void Wait() override { | 1594 receiver_call_ = receiver_call; |
1580 const int64_t kDisabledFeedbackTimeoutMs = 5000; | 1595 } |
1581 EXPECT_EQ(feedback_enabled_, done_.Wait(feedback_enabled_ | |
1582 ? test::CallTest::kDefaultTimeoutMs | |
1583 : kDisabledFeedbackTimeoutMs)); | |
1584 } | |
1585 | 1596 |
1586 void UpdateSendConfig( | 1597 size_t GetNumVideoStreams() const override { return num_video_streams_; } |
1587 size_t stream_index, | 1598 size_t GetNumAudioStreams() const override { return num_audio_streams_; } |
1588 VideoSendStream::Config* send_config, | |
1589 VideoEncoderConfig* encoder_config, | |
1590 test::FrameGeneratorCapturer** frame_generator) override { | |
1591 send_config->rtp.extensions.push_back( | |
1592 RtpExtension(RtpExtension::kTransportSequenceNumber, kExtensionId)); | |
1593 } | |
1594 | 1599 |
1595 void UpdateReceiveConfig( | 1600 void ModifyVideoConfigs( |
1596 size_t stream_index, | 1601 VideoSendStream::Config* send_config, |
1597 VideoReceiveStream::Config* receive_config) override { | 1602 std::vector<VideoReceiveStream::Config>* receive_configs, |
1598 receive_config->rtp.extensions.push_back( | 1603 VideoEncoderConfig* encoder_config) override { |
1599 RtpExtension(RtpExtension::kTransportSequenceNumber, kExtensionId)); | 1604 send_config->rtp.extensions.clear(); |
1600 receive_config->rtp.transport_cc = feedback_enabled_; | 1605 send_config->rtp.extensions.push_back( |
1601 } | 1606 RtpExtension(RtpExtension::kTransportSequenceNumber, kExtensionId)); |
| 1607 (*receive_configs)[0].rtp.extensions = send_config->rtp.extensions; |
| 1608 (*receive_configs)[0].rtp.transport_cc = feedback_enabled_; |
| 1609 } |
1602 | 1610 |
1603 test::DirectTransport* CreateReceiveTransport( | 1611 void ModifyAudioConfigs( |
1604 Call* receiver_call) override { | 1612 AudioSendStream::Config* send_config, |
1605 return new TransportFeedbackObserver(receiver_call, &done_); | 1613 std::vector<AudioReceiveStream::Config>* receive_configs) override { |
1606 } | 1614 send_config->rtp.extensions.clear(); |
| 1615 send_config->rtp.extensions.push_back( |
| 1616 RtpExtension(RtpExtension::kTransportSequenceNumber, kExtensionId)); |
| 1617 (*receive_configs)[0].rtp.extensions.clear(); |
| 1618 (*receive_configs)[0].rtp.extensions = send_config->rtp.extensions; |
| 1619 (*receive_configs)[0].rtp.transport_cc = feedback_enabled_; |
| 1620 (*receive_configs)[0].combined_audio_video_bwe = true; |
| 1621 } |
1607 | 1622 |
1608 private: | 1623 private: |
1609 const bool feedback_enabled_; | 1624 static const int kExtensionId = 5; |
1610 rtc::Event done_; | 1625 const bool feedback_enabled_; |
1611 } tester(feedback_enabled); | 1626 const size_t num_video_streams_; |
1612 tester.RunTest(); | 1627 const size_t num_audio_streams_; |
| 1628 Call* receiver_call_; |
| 1629 }; |
| 1630 |
| 1631 TEST_F(EndToEndTest, VideoReceivesTransportFeedback) { |
| 1632 TransportFeedbackTester test(true, 1, 0); |
| 1633 RunBaseTest(&test); |
1613 } | 1634 } |
1614 | 1635 |
1615 TEST_F(EndToEndTest, ReceivesTransportFeedback) { | 1636 TEST_F(EndToEndTest, VideoTransportFeedbackNotConfigured) { |
1616 TransportFeedbackTest(true); | 1637 TransportFeedbackTester test(false, 1, 0); |
| 1638 RunBaseTest(&test); |
1617 } | 1639 } |
1618 | 1640 |
1619 TEST_F(EndToEndTest, TransportFeedbackNotConfigured) { | 1641 TEST_F(EndToEndTest, AudioReceivesTransportFeedback) { |
1620 TransportFeedbackTest(false); | 1642 TransportFeedbackTester test(true, 0, 1); |
| 1643 RunBaseTest(&test); |
| 1644 } |
| 1645 |
| 1646 TEST_F(EndToEndTest, AudioTransportFeedbackNotConfigured) { |
| 1647 TransportFeedbackTester test(false, 0, 1); |
| 1648 RunBaseTest(&test); |
| 1649 } |
| 1650 |
| 1651 TEST_F(EndToEndTest, AudioVideoReceivesTransportFeedback) { |
| 1652 TransportFeedbackTester test(true, 1, 1); |
| 1653 RunBaseTest(&test); |
1621 } | 1654 } |
1622 | 1655 |
1623 TEST_F(EndToEndTest, ObserversEncodedFrames) { | 1656 TEST_F(EndToEndTest, ObserversEncodedFrames) { |
1624 class EncodedFrameTestObserver : public EncodedFrameObserver { | 1657 class EncodedFrameTestObserver : public EncodedFrameObserver { |
1625 public: | 1658 public: |
1626 EncodedFrameTestObserver() | 1659 EncodedFrameTestObserver() |
1627 : length_(0), frame_type_(kEmptyFrame), called_(false, false) {} | 1660 : length_(0), frame_type_(kEmptyFrame), called_(false, false) {} |
1628 virtual ~EncodedFrameTestObserver() {} | 1661 virtual ~EncodedFrameTestObserver() {} |
1629 | 1662 |
1630 virtual void EncodedFrameCallback(const EncodedFrame& encoded_frame) { | 1663 virtual void EncodedFrameCallback(const EncodedFrame& encoded_frame) { |
(...skipping 1692 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3323 private: | 3356 private: |
3324 bool video_observed_; | 3357 bool video_observed_; |
3325 bool audio_observed_; | 3358 bool audio_observed_; |
3326 SequenceNumberUnwrapper unwrapper_; | 3359 SequenceNumberUnwrapper unwrapper_; |
3327 std::set<int64_t> received_packet_ids_; | 3360 std::set<int64_t> received_packet_ids_; |
3328 } test; | 3361 } test; |
3329 | 3362 |
3330 RunBaseTest(&test); | 3363 RunBaseTest(&test); |
3331 } | 3364 } |
3332 } // namespace webrtc | 3365 } // namespace webrtc |
OLD | NEW |