asapersson@webrtc.org | 5249cc8 | 2011-12-16 14:31:37 +0000 | [diff] [blame] | 1 | /* |
henrike@webrtc.org | d6d014f | 2012-02-16 02:18:09 +0000 | [diff] [blame] | 2 | * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. |
asapersson@webrtc.org | 5249cc8 | 2011-12-16 14:31:37 +0000 | [diff] [blame] | 3 | * |
| 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 |
| 6 | * tree. An additional intellectual property rights grant can be found |
| 7 | * in the file PATENTS. All contributing project authors may |
| 8 | * be found in the AUTHORS file in the root of the source tree. |
| 9 | */ |
| 10 | |
kwiberg | 84be511 | 2016-04-27 01:19:58 -0700 | [diff] [blame] | 11 | #include <memory> |
| 12 | |
Mirko Bonadei | 7120742 | 2017-09-15 13:58:09 +0200 | [diff] [blame] | 13 | #include "common_types.h" // NOLINT(build/include) |
Ilya Nikolaevskiy | 88c2c50 | 2018-10-26 16:00:08 +0200 | [diff] [blame] | 14 | #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 15 | #include "modules/rtp_rtcp/source/rtcp_packet/bye.h" |
| 16 | #include "modules/rtp_rtcp/source/rtcp_packet/common_header.h" |
| 17 | #include "modules/rtp_rtcp/source/rtcp_sender.h" |
Niels Möller | 1f3206c | 2018-09-14 08:26:32 +0200 | [diff] [blame] | 18 | #include "modules/rtp_rtcp/source/rtp_packet_received.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 19 | #include "modules/rtp_rtcp/source/rtp_rtcp_impl.h" |
Ilya Nikolaevskiy | 88c2c50 | 2018-10-26 16:00:08 +0200 | [diff] [blame] | 20 | #include "modules/rtp_rtcp/source/time_util.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 21 | #include "rtc_base/rate_limiter.h" |
| 22 | #include "test/gmock.h" |
| 23 | #include "test/gtest.h" |
| 24 | #include "test/mock_transport.h" |
| 25 | #include "test/rtcp_packet_parser.h" |
asapersson | 22ff75a | 2015-08-21 00:02:47 -0700 | [diff] [blame] | 26 | |
aleungbroadsoft | 0e2e50c | 2016-02-18 08:33:26 -0800 | [diff] [blame] | 27 | using ::testing::_; |
asapersson | 22ff75a | 2015-08-21 00:02:47 -0700 | [diff] [blame] | 28 | using ::testing::ElementsAre; |
aleungbroadsoft | 0e2e50c | 2016-02-18 08:33:26 -0800 | [diff] [blame] | 29 | using ::testing::Invoke; |
Mirta Dvornicic | b1f063d | 2018-04-16 11:16:21 +0200 | [diff] [blame] | 30 | using ::testing::SizeIs; |
asapersson@webrtc.org | 5249cc8 | 2011-12-16 14:31:37 +0000 | [diff] [blame] | 31 | |
| 32 | namespace webrtc { |
| 33 | |
asapersson | 22ff75a | 2015-08-21 00:02:47 -0700 | [diff] [blame] | 34 | class RtcpPacketTypeCounterObserverImpl : public RtcpPacketTypeCounterObserver { |
| 35 | public: |
| 36 | RtcpPacketTypeCounterObserverImpl() : ssrc_(0) {} |
Danil Chapovalov | dd7e284 | 2018-03-09 15:37:03 +0000 | [diff] [blame] | 37 | ~RtcpPacketTypeCounterObserverImpl() override = default; |
asapersson | 22ff75a | 2015-08-21 00:02:47 -0700 | [diff] [blame] | 38 | void RtcpPacketTypesCounterUpdated( |
| 39 | uint32_t ssrc, |
| 40 | const RtcpPacketTypeCounter& packet_counter) override { |
| 41 | ssrc_ = ssrc; |
| 42 | counter_ = packet_counter; |
| 43 | } |
| 44 | uint32_t ssrc_; |
| 45 | RtcpPacketTypeCounter counter_; |
| 46 | }; |
asapersson@webrtc.org | 5249cc8 | 2011-12-16 14:31:37 +0000 | [diff] [blame] | 47 | |
Niels Möller | 8fb5746 | 2018-11-13 10:08:33 +0100 | [diff] [blame] | 48 | class TestTransport : public Transport { |
asapersson@webrtc.org | 5249cc8 | 2011-12-16 14:31:37 +0000 | [diff] [blame] | 49 | public: |
asapersson | 22ff75a | 2015-08-21 00:02:47 -0700 | [diff] [blame] | 50 | TestTransport() {} |
| 51 | |
stefan | 1d8a506 | 2015-10-02 03:39:33 -0700 | [diff] [blame] | 52 | bool SendRtp(const uint8_t* /*data*/, |
| 53 | size_t /*len*/, |
| 54 | const PacketOptions& options) override { |
pbos | 2d56668 | 2015-09-28 09:59:31 -0700 | [diff] [blame] | 55 | return false; |
asapersson@webrtc.org | 5249cc8 | 2011-12-16 14:31:37 +0000 | [diff] [blame] | 56 | } |
pbos | 2d56668 | 2015-09-28 09:59:31 -0700 | [diff] [blame] | 57 | bool SendRtcp(const uint8_t* data, size_t len) override { |
Danil Chapovalov | ba6f7be | 2016-09-02 18:29:10 +0200 | [diff] [blame] | 58 | parser_.Parse(data, len); |
pbos | 2d56668 | 2015-09-28 09:59:31 -0700 | [diff] [blame] | 59 | return true; |
asapersson@webrtc.org | 5249cc8 | 2011-12-16 14:31:37 +0000 | [diff] [blame] | 60 | } |
asapersson | 22ff75a | 2015-08-21 00:02:47 -0700 | [diff] [blame] | 61 | test::RtcpPacketParser parser_; |
asapersson@webrtc.org | 5249cc8 | 2011-12-16 14:31:37 +0000 | [diff] [blame] | 62 | }; |
| 63 | |
Erik Språng | a38233a | 2015-07-24 09:58:18 +0200 | [diff] [blame] | 64 | namespace { |
asapersson | 22ff75a | 2015-08-21 00:02:47 -0700 | [diff] [blame] | 65 | static const uint32_t kSenderSsrc = 0x11111111; |
| 66 | static const uint32_t kRemoteSsrc = 0x22222222; |
Danil Chapovalov | 70ffead | 2016-07-20 15:26:59 +0200 | [diff] [blame] | 67 | static const uint32_t kStartRtpTimestamp = 0x34567; |
| 68 | static const uint32_t kRtpTimestamp = 0x45678; |
Yves Gerey | 665174f | 2018-06-19 15:03:05 +0200 | [diff] [blame] | 69 | } // namespace |
Erik Språng | a38233a | 2015-07-24 09:58:18 +0200 | [diff] [blame] | 70 | |
asapersson@webrtc.org | 5249cc8 | 2011-12-16 14:31:37 +0000 | [diff] [blame] | 71 | class RtcpSenderTest : public ::testing::Test { |
| 72 | protected: |
stefan@webrtc.org | 9354cc9 | 2012-06-07 08:10:14 +0000 | [diff] [blame] | 73 | RtcpSenderTest() |
asapersson | 22ff75a | 2015-08-21 00:02:47 -0700 | [diff] [blame] | 74 | : clock_(1335900000), |
Erik Språng | 737336d | 2016-07-29 12:59:36 +0200 | [diff] [blame] | 75 | receive_statistics_(ReceiveStatistics::Create(&clock_)), |
| 76 | retransmission_rate_limiter_(&clock_, 1000) { |
pwestin@webrtc.org | 2853dde | 2012-05-11 11:08:54 +0000 | [diff] [blame] | 77 | RtpRtcp::Configuration configuration; |
pwestin@webrtc.org | 2853dde | 2012-05-11 11:08:54 +0000 | [diff] [blame] | 78 | configuration.audio = false; |
asapersson@webrtc.org | 8469f7b | 2013-10-02 13:15:34 +0000 | [diff] [blame] | 79 | configuration.clock = &clock_; |
asapersson | 22ff75a | 2015-08-21 00:02:47 -0700 | [diff] [blame] | 80 | configuration.outgoing_transport = &test_transport_; |
Erik Språng | 737336d | 2016-07-29 12:59:36 +0200 | [diff] [blame] | 81 | configuration.retransmission_rate_limiter = &retransmission_rate_limiter_; |
Jiawei Ou | 8b5d9d8 | 2018-11-15 16:44:37 -0800 | [diff] [blame] | 82 | configuration.rtcp_report_interval_ms = 1000; |
pwestin@webrtc.org | 2853dde | 2012-05-11 11:08:54 +0000 | [diff] [blame] | 83 | |
asapersson | 22ff75a | 2015-08-21 00:02:47 -0700 | [diff] [blame] | 84 | rtp_rtcp_impl_.reset(new ModuleRtpRtcpImpl(configuration)); |
sprang | 86fd9ed | 2015-09-29 04:45:43 -0700 | [diff] [blame] | 85 | rtcp_sender_.reset(new RTCPSender(false, &clock_, receive_statistics_.get(), |
Jiawei Ou | 3587b83 | 2018-01-31 22:08:26 -0800 | [diff] [blame] | 86 | nullptr, nullptr, &test_transport_, |
Jiawei Ou | 8b5d9d8 | 2018-11-15 16:44:37 -0800 | [diff] [blame] | 87 | configuration.rtcp_report_interval_ms)); |
asapersson | 22ff75a | 2015-08-21 00:02:47 -0700 | [diff] [blame] | 88 | rtcp_sender_->SetSSRC(kSenderSsrc); |
| 89 | rtcp_sender_->SetRemoteSSRC(kRemoteSsrc); |
danilchap | 71fead2 | 2016-08-18 02:01:49 -0700 | [diff] [blame] | 90 | rtcp_sender_->SetTimestampOffset(kStartRtpTimestamp); |
Ilya Nikolaevskiy | 5e58bcb | 2018-10-24 13:34:32 +0200 | [diff] [blame] | 91 | rtcp_sender_->SetLastRtpTime(kRtpTimestamp, clock_.TimeInMilliseconds(), |
| 92 | /*paylpad_type=*/0); |
asapersson@webrtc.org | 5249cc8 | 2011-12-16 14:31:37 +0000 | [diff] [blame] | 93 | } |
Erik Språng | a38233a | 2015-07-24 09:58:18 +0200 | [diff] [blame] | 94 | |
asapersson | 22ff75a | 2015-08-21 00:02:47 -0700 | [diff] [blame] | 95 | void InsertIncomingPacket(uint32_t remote_ssrc, uint16_t seq_num) { |
Niels Möller | 1f3206c | 2018-09-14 08:26:32 +0200 | [diff] [blame] | 96 | RtpPacketReceived packet; |
| 97 | packet.SetSsrc(remote_ssrc); |
| 98 | packet.SetSequenceNumber(seq_num); |
| 99 | packet.SetTimestamp(12345); |
| 100 | packet.SetPayloadSize(100 - 12); |
| 101 | receive_statistics_->OnRtpPacket(packet); |
asapersson@webrtc.org | 5249cc8 | 2011-12-16 14:31:37 +0000 | [diff] [blame] | 102 | } |
| 103 | |
asapersson | 22ff75a | 2015-08-21 00:02:47 -0700 | [diff] [blame] | 104 | test::RtcpPacketParser* parser() { return &test_transport_.parser_; } |
| 105 | |
| 106 | RTCPSender::FeedbackState feedback_state() { |
| 107 | return rtp_rtcp_impl_->GetFeedbackState(); |
hta@webrtc.org | 9d54cd1 | 2012-04-30 08:24:55 +0000 | [diff] [blame] | 108 | } |
| 109 | |
asapersson@webrtc.org | 8469f7b | 2013-10-02 13:15:34 +0000 | [diff] [blame] | 110 | SimulatedClock clock_; |
asapersson | 22ff75a | 2015-08-21 00:02:47 -0700 | [diff] [blame] | 111 | TestTransport test_transport_; |
kwiberg | 84be511 | 2016-04-27 01:19:58 -0700 | [diff] [blame] | 112 | std::unique_ptr<ReceiveStatistics> receive_statistics_; |
| 113 | std::unique_ptr<ModuleRtpRtcpImpl> rtp_rtcp_impl_; |
| 114 | std::unique_ptr<RTCPSender> rtcp_sender_; |
Erik Språng | 737336d | 2016-07-29 12:59:36 +0200 | [diff] [blame] | 115 | RateLimiter retransmission_rate_limiter_; |
asapersson@webrtc.org | 5249cc8 | 2011-12-16 14:31:37 +0000 | [diff] [blame] | 116 | }; |
| 117 | |
asapersson | 22ff75a | 2015-08-21 00:02:47 -0700 | [diff] [blame] | 118 | TEST_F(RtcpSenderTest, SetRtcpStatus) { |
pbos | da903ea | 2015-10-02 02:36:56 -0700 | [diff] [blame] | 119 | EXPECT_EQ(RtcpMode::kOff, rtcp_sender_->Status()); |
| 120 | rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize); |
| 121 | EXPECT_EQ(RtcpMode::kReducedSize, rtcp_sender_->Status()); |
asapersson | 22ff75a | 2015-08-21 00:02:47 -0700 | [diff] [blame] | 122 | } |
| 123 | |
| 124 | TEST_F(RtcpSenderTest, SetSendingStatus) { |
| 125 | EXPECT_FALSE(rtcp_sender_->Sending()); |
| 126 | EXPECT_EQ(0, rtcp_sender_->SetSendingStatus(feedback_state(), true)); |
| 127 | EXPECT_TRUE(rtcp_sender_->Sending()); |
| 128 | } |
| 129 | |
| 130 | TEST_F(RtcpSenderTest, NoPacketSentIfOff) { |
pbos | da903ea | 2015-10-02 02:36:56 -0700 | [diff] [blame] | 131 | rtcp_sender_->SetRTCPStatus(RtcpMode::kOff); |
asapersson | 22ff75a | 2015-08-21 00:02:47 -0700 | [diff] [blame] | 132 | EXPECT_EQ(-1, rtcp_sender_->SendRTCP(feedback_state(), kRtcpSr)); |
asapersson@webrtc.org | 5249cc8 | 2011-12-16 14:31:37 +0000 | [diff] [blame] | 133 | } |
| 134 | |
asapersson | 22ff75a | 2015-08-21 00:02:47 -0700 | [diff] [blame] | 135 | TEST_F(RtcpSenderTest, SendSr) { |
| 136 | const uint32_t kPacketCount = 0x12345; |
| 137 | const uint32_t kOctetCount = 0x23456; |
pbos | da903ea | 2015-10-02 02:36:56 -0700 | [diff] [blame] | 138 | rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize); |
pbos@webrtc.org | 2f4b14e | 2014-07-15 15:25:39 +0000 | [diff] [blame] | 139 | RTCPSender::FeedbackState feedback_state = rtp_rtcp_impl_->GetFeedbackState(); |
Danil Chapovalov | 70ffead | 2016-07-20 15:26:59 +0200 | [diff] [blame] | 140 | rtcp_sender_->SetSendingStatus(feedback_state, true); |
asapersson | 22ff75a | 2015-08-21 00:02:47 -0700 | [diff] [blame] | 141 | feedback_state.packets_sent = kPacketCount; |
| 142 | feedback_state.media_bytes_sent = kOctetCount; |
Ilya Nikolaevskiy | 88c2c50 | 2018-10-26 16:00:08 +0200 | [diff] [blame] | 143 | NtpTime ntp = TimeMicrosToNtp(clock_.TimeInMicroseconds()); |
asapersson | 22ff75a | 2015-08-21 00:02:47 -0700 | [diff] [blame] | 144 | EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state, kRtcpSr)); |
| 145 | EXPECT_EQ(1, parser()->sender_report()->num_packets()); |
Danil Chapovalov | ba6f7be | 2016-09-02 18:29:10 +0200 | [diff] [blame] | 146 | EXPECT_EQ(kSenderSsrc, parser()->sender_report()->sender_ssrc()); |
danilchap | 21dc189 | 2017-03-07 02:51:09 -0800 | [diff] [blame] | 147 | EXPECT_EQ(ntp, parser()->sender_report()->ntp()); |
Danil Chapovalov | ba6f7be | 2016-09-02 18:29:10 +0200 | [diff] [blame] | 148 | EXPECT_EQ(kPacketCount, parser()->sender_report()->sender_packet_count()); |
| 149 | EXPECT_EQ(kOctetCount, parser()->sender_report()->sender_octet_count()); |
Danil Chapovalov | 70ffead | 2016-07-20 15:26:59 +0200 | [diff] [blame] | 150 | EXPECT_EQ(kStartRtpTimestamp + kRtpTimestamp, |
Danil Chapovalov | ba6f7be | 2016-09-02 18:29:10 +0200 | [diff] [blame] | 151 | parser()->sender_report()->rtp_timestamp()); |
| 152 | EXPECT_EQ(0U, parser()->sender_report()->report_blocks().size()); |
asapersson@webrtc.org | 5249cc8 | 2011-12-16 14:31:37 +0000 | [diff] [blame] | 153 | } |
| 154 | |
Ilya Nikolaevskiy | 88c2c50 | 2018-10-26 16:00:08 +0200 | [diff] [blame] | 155 | TEST_F(RtcpSenderTest, SendConsecutiveSrWithExactSlope) { |
| 156 | const uint32_t kPacketCount = 0x12345; |
| 157 | const uint32_t kOctetCount = 0x23456; |
| 158 | const int kTimeBetweenSRsUs = 10043; // Not exact value in milliseconds. |
| 159 | const int kExtraPackets = 30; |
| 160 | // Make sure clock is not exactly at some milliseconds point. |
| 161 | clock_.AdvanceTimeMicroseconds(kTimeBetweenSRsUs); |
| 162 | rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize); |
| 163 | RTCPSender::FeedbackState feedback_state = rtp_rtcp_impl_->GetFeedbackState(); |
| 164 | rtcp_sender_->SetSendingStatus(feedback_state, true); |
| 165 | feedback_state.packets_sent = kPacketCount; |
| 166 | feedback_state.media_bytes_sent = kOctetCount; |
| 167 | |
| 168 | EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state, kRtcpSr)); |
| 169 | EXPECT_EQ(1, parser()->sender_report()->num_packets()); |
| 170 | NtpTime ntp1 = parser()->sender_report()->ntp(); |
| 171 | uint32_t rtp1 = parser()->sender_report()->rtp_timestamp(); |
| 172 | |
| 173 | // Send more SRs to ensure slope is always exact for different offsets |
| 174 | for (int packets = 1; packets <= kExtraPackets; ++packets) { |
| 175 | clock_.AdvanceTimeMicroseconds(kTimeBetweenSRsUs); |
| 176 | EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state, kRtcpSr)); |
| 177 | EXPECT_EQ(packets + 1, parser()->sender_report()->num_packets()); |
| 178 | |
| 179 | NtpTime ntp2 = parser()->sender_report()->ntp(); |
| 180 | uint32_t rtp2 = parser()->sender_report()->rtp_timestamp(); |
| 181 | |
| 182 | uint32_t ntp_diff_in_rtp_units = |
| 183 | (ntp2.ToMs() - ntp1.ToMs()) * (kVideoPayloadTypeFrequency / 1000); |
| 184 | EXPECT_EQ(rtp2 - rtp1, ntp_diff_in_rtp_units); |
| 185 | } |
| 186 | } |
| 187 | |
Danil Chapovalov | 70ffead | 2016-07-20 15:26:59 +0200 | [diff] [blame] | 188 | TEST_F(RtcpSenderTest, DoNotSendSrBeforeRtp) { |
| 189 | rtcp_sender_.reset(new RTCPSender(false, &clock_, receive_statistics_.get(), |
Jiawei Ou | 8b5d9d8 | 2018-11-15 16:44:37 -0800 | [diff] [blame] | 190 | nullptr, nullptr, &test_transport_, 1000)); |
Danil Chapovalov | 70ffead | 2016-07-20 15:26:59 +0200 | [diff] [blame] | 191 | rtcp_sender_->SetSSRC(kSenderSsrc); |
| 192 | rtcp_sender_->SetRemoteSSRC(kRemoteSsrc); |
| 193 | rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize); |
| 194 | rtcp_sender_->SetSendingStatus(feedback_state(), true); |
| 195 | |
| 196 | // Sender Report shouldn't be send as an SR nor as a Report. |
| 197 | rtcp_sender_->SendRTCP(feedback_state(), kRtcpSr); |
| 198 | EXPECT_EQ(0, parser()->sender_report()->num_packets()); |
| 199 | rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport); |
| 200 | EXPECT_EQ(0, parser()->sender_report()->num_packets()); |
| 201 | // Other packets (e.g. Pli) are allowed, even if useless. |
| 202 | EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpPli)); |
| 203 | EXPECT_EQ(1, parser()->pli()->num_packets()); |
| 204 | } |
| 205 | |
| 206 | TEST_F(RtcpSenderTest, DoNotSendCompundBeforeRtp) { |
| 207 | rtcp_sender_.reset(new RTCPSender(false, &clock_, receive_statistics_.get(), |
Jiawei Ou | 8b5d9d8 | 2018-11-15 16:44:37 -0800 | [diff] [blame] | 208 | nullptr, nullptr, &test_transport_, 1000)); |
Danil Chapovalov | 70ffead | 2016-07-20 15:26:59 +0200 | [diff] [blame] | 209 | rtcp_sender_->SetSSRC(kSenderSsrc); |
| 210 | rtcp_sender_->SetRemoteSSRC(kRemoteSsrc); |
| 211 | rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound); |
| 212 | rtcp_sender_->SetSendingStatus(feedback_state(), true); |
| 213 | |
| 214 | // In compound mode no packets are allowed (e.g. Pli) because compound mode |
| 215 | // should start with Sender Report. |
| 216 | EXPECT_EQ(-1, rtcp_sender_->SendRTCP(feedback_state(), kRtcpPli)); |
| 217 | EXPECT_EQ(0, parser()->pli()->num_packets()); |
| 218 | } |
| 219 | |
asapersson | 22ff75a | 2015-08-21 00:02:47 -0700 | [diff] [blame] | 220 | TEST_F(RtcpSenderTest, SendRr) { |
pbos | da903ea | 2015-10-02 02:36:56 -0700 | [diff] [blame] | 221 | rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize); |
asapersson | 22ff75a | 2015-08-21 00:02:47 -0700 | [diff] [blame] | 222 | EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpRr)); |
| 223 | EXPECT_EQ(1, parser()->receiver_report()->num_packets()); |
Danil Chapovalov | ba6f7be | 2016-09-02 18:29:10 +0200 | [diff] [blame] | 224 | EXPECT_EQ(kSenderSsrc, parser()->receiver_report()->sender_ssrc()); |
| 225 | EXPECT_EQ(0U, parser()->receiver_report()->report_blocks().size()); |
asapersson@webrtc.org | 5249cc8 | 2011-12-16 14:31:37 +0000 | [diff] [blame] | 226 | } |
| 227 | |
asapersson | 22ff75a | 2015-08-21 00:02:47 -0700 | [diff] [blame] | 228 | TEST_F(RtcpSenderTest, SendRrWithOneReportBlock) { |
| 229 | const uint16_t kSeqNum = 11111; |
| 230 | InsertIncomingPacket(kRemoteSsrc, kSeqNum); |
pbos | da903ea | 2015-10-02 02:36:56 -0700 | [diff] [blame] | 231 | rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound); |
asapersson | 22ff75a | 2015-08-21 00:02:47 -0700 | [diff] [blame] | 232 | EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpRr)); |
| 233 | EXPECT_EQ(1, parser()->receiver_report()->num_packets()); |
Danil Chapovalov | ba6f7be | 2016-09-02 18:29:10 +0200 | [diff] [blame] | 234 | EXPECT_EQ(kSenderSsrc, parser()->receiver_report()->sender_ssrc()); |
| 235 | ASSERT_EQ(1U, parser()->receiver_report()->report_blocks().size()); |
| 236 | const rtcp::ReportBlock& rb = parser()->receiver_report()->report_blocks()[0]; |
| 237 | EXPECT_EQ(kRemoteSsrc, rb.source_ssrc()); |
| 238 | EXPECT_EQ(0U, rb.fraction_lost()); |
Harald Alvestrand | 70206d6 | 2017-12-08 08:59:07 +0100 | [diff] [blame] | 239 | EXPECT_EQ(0, rb.cumulative_lost_signed()); |
Danil Chapovalov | ba6f7be | 2016-09-02 18:29:10 +0200 | [diff] [blame] | 240 | EXPECT_EQ(kSeqNum, rb.extended_high_seq_num()); |
asapersson | 22ff75a | 2015-08-21 00:02:47 -0700 | [diff] [blame] | 241 | } |
| 242 | |
| 243 | TEST_F(RtcpSenderTest, SendRrWithTwoReportBlocks) { |
| 244 | const uint16_t kSeqNum = 11111; |
| 245 | InsertIncomingPacket(kRemoteSsrc, kSeqNum); |
| 246 | InsertIncomingPacket(kRemoteSsrc + 1, kSeqNum + 1); |
pbos | da903ea | 2015-10-02 02:36:56 -0700 | [diff] [blame] | 247 | rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound); |
asapersson | 22ff75a | 2015-08-21 00:02:47 -0700 | [diff] [blame] | 248 | EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpRr)); |
| 249 | EXPECT_EQ(1, parser()->receiver_report()->num_packets()); |
Danil Chapovalov | ba6f7be | 2016-09-02 18:29:10 +0200 | [diff] [blame] | 250 | EXPECT_EQ(kSenderSsrc, parser()->receiver_report()->sender_ssrc()); |
| 251 | EXPECT_EQ(2U, parser()->receiver_report()->report_blocks().size()); |
| 252 | EXPECT_EQ(kRemoteSsrc, |
| 253 | parser()->receiver_report()->report_blocks()[0].source_ssrc()); |
| 254 | EXPECT_EQ(kRemoteSsrc + 1, |
| 255 | parser()->receiver_report()->report_blocks()[1].source_ssrc()); |
asapersson | 22ff75a | 2015-08-21 00:02:47 -0700 | [diff] [blame] | 256 | } |
| 257 | |
| 258 | TEST_F(RtcpSenderTest, SendSdes) { |
pbos | da903ea | 2015-10-02 02:36:56 -0700 | [diff] [blame] | 259 | rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize); |
asapersson | 22ff75a | 2015-08-21 00:02:47 -0700 | [diff] [blame] | 260 | EXPECT_EQ(0, rtcp_sender_->SetCNAME("alice@host")); |
| 261 | EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpSdes)); |
| 262 | EXPECT_EQ(1, parser()->sdes()->num_packets()); |
Danil Chapovalov | ba6f7be | 2016-09-02 18:29:10 +0200 | [diff] [blame] | 263 | EXPECT_EQ(1U, parser()->sdes()->chunks().size()); |
| 264 | EXPECT_EQ(kSenderSsrc, parser()->sdes()->chunks()[0].ssrc); |
| 265 | EXPECT_EQ("alice@host", parser()->sdes()->chunks()[0].cname); |
asapersson | 22ff75a | 2015-08-21 00:02:47 -0700 | [diff] [blame] | 266 | } |
| 267 | |
danilchap | 74e8df8f | 2017-03-16 08:04:08 -0700 | [diff] [blame] | 268 | TEST_F(RtcpSenderTest, SendSdesWithMaxChunks) { |
| 269 | rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize); |
| 270 | EXPECT_EQ(0, rtcp_sender_->SetCNAME("alice@host")); |
| 271 | const char cname[] = "smith@host"; |
| 272 | for (size_t i = 0; i < 30; ++i) { |
| 273 | const uint32_t csrc = 0x1234 + i; |
| 274 | EXPECT_EQ(0, rtcp_sender_->AddMixedCNAME(csrc, cname)); |
| 275 | } |
| 276 | EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpSdes)); |
| 277 | EXPECT_EQ(1, parser()->sdes()->num_packets()); |
| 278 | EXPECT_EQ(31U, parser()->sdes()->chunks().size()); |
| 279 | } |
| 280 | |
asapersson | 22ff75a | 2015-08-21 00:02:47 -0700 | [diff] [blame] | 281 | TEST_F(RtcpSenderTest, SdesIncludedInCompoundPacket) { |
pbos | da903ea | 2015-10-02 02:36:56 -0700 | [diff] [blame] | 282 | rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound); |
asapersson | 22ff75a | 2015-08-21 00:02:47 -0700 | [diff] [blame] | 283 | EXPECT_EQ(0, rtcp_sender_->SetCNAME("alice@host")); |
| 284 | EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport)); |
| 285 | EXPECT_EQ(1, parser()->receiver_report()->num_packets()); |
| 286 | EXPECT_EQ(1, parser()->sdes()->num_packets()); |
Danil Chapovalov | ba6f7be | 2016-09-02 18:29:10 +0200 | [diff] [blame] | 287 | EXPECT_EQ(1U, parser()->sdes()->chunks().size()); |
asapersson | 22ff75a | 2015-08-21 00:02:47 -0700 | [diff] [blame] | 288 | } |
| 289 | |
| 290 | TEST_F(RtcpSenderTest, SendBye) { |
pbos | da903ea | 2015-10-02 02:36:56 -0700 | [diff] [blame] | 291 | rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize); |
asapersson | 22ff75a | 2015-08-21 00:02:47 -0700 | [diff] [blame] | 292 | EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpBye)); |
| 293 | EXPECT_EQ(1, parser()->bye()->num_packets()); |
Danil Chapovalov | ba6f7be | 2016-09-02 18:29:10 +0200 | [diff] [blame] | 294 | EXPECT_EQ(kSenderSsrc, parser()->bye()->sender_ssrc()); |
asapersson | 22ff75a | 2015-08-21 00:02:47 -0700 | [diff] [blame] | 295 | } |
| 296 | |
| 297 | TEST_F(RtcpSenderTest, StopSendingTriggersBye) { |
pbos | da903ea | 2015-10-02 02:36:56 -0700 | [diff] [blame] | 298 | rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize); |
asapersson | 22ff75a | 2015-08-21 00:02:47 -0700 | [diff] [blame] | 299 | EXPECT_EQ(0, rtcp_sender_->SetSendingStatus(feedback_state(), true)); |
| 300 | EXPECT_EQ(0, rtcp_sender_->SetSendingStatus(feedback_state(), false)); |
| 301 | EXPECT_EQ(1, parser()->bye()->num_packets()); |
Danil Chapovalov | ba6f7be | 2016-09-02 18:29:10 +0200 | [diff] [blame] | 302 | EXPECT_EQ(kSenderSsrc, parser()->bye()->sender_ssrc()); |
asapersson | 22ff75a | 2015-08-21 00:02:47 -0700 | [diff] [blame] | 303 | } |
| 304 | |
| 305 | TEST_F(RtcpSenderTest, SendApp) { |
| 306 | const uint8_t kSubType = 30; |
| 307 | uint32_t name = 'n' << 24; |
| 308 | name += 'a' << 16; |
| 309 | name += 'm' << 8; |
| 310 | name += 'e'; |
| 311 | const uint8_t kData[] = {'t', 'e', 's', 't', 'd', 'a', 't', 'a'}; |
asapersson | 22ff75a | 2015-08-21 00:02:47 -0700 | [diff] [blame] | 312 | EXPECT_EQ(0, rtcp_sender_->SetApplicationSpecificData(kSubType, name, kData, |
Danil Chapovalov | ba6f7be | 2016-09-02 18:29:10 +0200 | [diff] [blame] | 313 | sizeof(kData))); |
pbos | da903ea | 2015-10-02 02:36:56 -0700 | [diff] [blame] | 314 | rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize); |
asapersson | 22ff75a | 2015-08-21 00:02:47 -0700 | [diff] [blame] | 315 | EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpApp)); |
| 316 | EXPECT_EQ(1, parser()->app()->num_packets()); |
Danil Chapovalov | ba6f7be | 2016-09-02 18:29:10 +0200 | [diff] [blame] | 317 | EXPECT_EQ(kSubType, parser()->app()->sub_type()); |
| 318 | EXPECT_EQ(name, parser()->app()->name()); |
| 319 | EXPECT_EQ(sizeof(kData), parser()->app()->data_size()); |
| 320 | EXPECT_EQ(0, memcmp(kData, parser()->app()->data(), sizeof(kData))); |
asapersson | 22ff75a | 2015-08-21 00:02:47 -0700 | [diff] [blame] | 321 | } |
| 322 | |
Erik Språng | 521875a | 2015-09-01 10:11:16 +0200 | [diff] [blame] | 323 | TEST_F(RtcpSenderTest, SendEmptyApp) { |
| 324 | const uint8_t kSubType = 30; |
| 325 | const uint32_t kName = 0x6E616D65; |
| 326 | |
| 327 | EXPECT_EQ( |
| 328 | 0, rtcp_sender_->SetApplicationSpecificData(kSubType, kName, nullptr, 0)); |
| 329 | |
pbos | da903ea | 2015-10-02 02:36:56 -0700 | [diff] [blame] | 330 | rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize); |
Erik Språng | 521875a | 2015-09-01 10:11:16 +0200 | [diff] [blame] | 331 | EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpApp)); |
| 332 | EXPECT_EQ(1, parser()->app()->num_packets()); |
Danil Chapovalov | ba6f7be | 2016-09-02 18:29:10 +0200 | [diff] [blame] | 333 | EXPECT_EQ(kSubType, parser()->app()->sub_type()); |
| 334 | EXPECT_EQ(kName, parser()->app()->name()); |
| 335 | EXPECT_EQ(0U, parser()->app()->data_size()); |
Erik Språng | 521875a | 2015-09-01 10:11:16 +0200 | [diff] [blame] | 336 | } |
| 337 | |
asapersson | 22ff75a | 2015-08-21 00:02:47 -0700 | [diff] [blame] | 338 | TEST_F(RtcpSenderTest, SetInvalidApplicationSpecificData) { |
| 339 | const uint8_t kData[] = {'t', 'e', 's', 't', 'd', 'a', 't'}; |
| 340 | const uint16_t kInvalidDataLength = sizeof(kData) / sizeof(kData[0]); |
Yves Gerey | 665174f | 2018-06-19 15:03:05 +0200 | [diff] [blame] | 341 | EXPECT_EQ(-1, |
| 342 | rtcp_sender_->SetApplicationSpecificData( |
| 343 | 0, 0, kData, kInvalidDataLength)); // Should by multiple of 4. |
asapersson | 22ff75a | 2015-08-21 00:02:47 -0700 | [diff] [blame] | 344 | } |
| 345 | |
danilchap | 498ee8e | 2017-02-08 05:24:31 -0800 | [diff] [blame] | 346 | TEST_F(RtcpSenderTest, SendFir) { |
pbos | da903ea | 2015-10-02 02:36:56 -0700 | [diff] [blame] | 347 | rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize); |
asapersson | 22ff75a | 2015-08-21 00:02:47 -0700 | [diff] [blame] | 348 | EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpFir)); |
| 349 | EXPECT_EQ(1, parser()->fir()->num_packets()); |
Danil Chapovalov | ba6f7be | 2016-09-02 18:29:10 +0200 | [diff] [blame] | 350 | EXPECT_EQ(kSenderSsrc, parser()->fir()->sender_ssrc()); |
| 351 | EXPECT_EQ(1U, parser()->fir()->requests().size()); |
| 352 | EXPECT_EQ(kRemoteSsrc, parser()->fir()->requests()[0].ssrc); |
| 353 | uint8_t seq = parser()->fir()->requests()[0].seq_nr; |
asapersson | 22ff75a | 2015-08-21 00:02:47 -0700 | [diff] [blame] | 354 | EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpFir)); |
| 355 | EXPECT_EQ(2, parser()->fir()->num_packets()); |
Danil Chapovalov | ba6f7be | 2016-09-02 18:29:10 +0200 | [diff] [blame] | 356 | EXPECT_EQ(seq + 1, parser()->fir()->requests()[0].seq_nr); |
asapersson | 22ff75a | 2015-08-21 00:02:47 -0700 | [diff] [blame] | 357 | } |
| 358 | |
asapersson | 22ff75a | 2015-08-21 00:02:47 -0700 | [diff] [blame] | 359 | TEST_F(RtcpSenderTest, SendPli) { |
pbos | da903ea | 2015-10-02 02:36:56 -0700 | [diff] [blame] | 360 | rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize); |
asapersson | 22ff75a | 2015-08-21 00:02:47 -0700 | [diff] [blame] | 361 | EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpPli)); |
| 362 | EXPECT_EQ(1, parser()->pli()->num_packets()); |
Danil Chapovalov | ba6f7be | 2016-09-02 18:29:10 +0200 | [diff] [blame] | 363 | EXPECT_EQ(kSenderSsrc, parser()->pli()->sender_ssrc()); |
| 364 | EXPECT_EQ(kRemoteSsrc, parser()->pli()->media_ssrc()); |
asapersson | 22ff75a | 2015-08-21 00:02:47 -0700 | [diff] [blame] | 365 | } |
| 366 | |
asapersson | 22ff75a | 2015-08-21 00:02:47 -0700 | [diff] [blame] | 367 | TEST_F(RtcpSenderTest, SendNack) { |
pbos | da903ea | 2015-10-02 02:36:56 -0700 | [diff] [blame] | 368 | rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize); |
asapersson | 22ff75a | 2015-08-21 00:02:47 -0700 | [diff] [blame] | 369 | const uint16_t kList[] = {0, 1, 16}; |
| 370 | const int32_t kListLength = sizeof(kList) / sizeof(kList[0]); |
| 371 | EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpNack, kListLength, |
| 372 | kList)); |
| 373 | EXPECT_EQ(1, parser()->nack()->num_packets()); |
Danil Chapovalov | ba6f7be | 2016-09-02 18:29:10 +0200 | [diff] [blame] | 374 | EXPECT_EQ(kSenderSsrc, parser()->nack()->sender_ssrc()); |
| 375 | EXPECT_EQ(kRemoteSsrc, parser()->nack()->media_ssrc()); |
| 376 | EXPECT_THAT(parser()->nack()->packet_ids(), ElementsAre(0, 1, 16)); |
asapersson | 22ff75a | 2015-08-21 00:02:47 -0700 | [diff] [blame] | 377 | } |
| 378 | |
Elad Alon | 7d6a4c0 | 2019-02-25 13:00:51 +0100 | [diff] [blame] | 379 | TEST_F(RtcpSenderTest, SendLossNotification) { |
| 380 | rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize); |
| 381 | constexpr uint16_t kLastDecoded = 0x1234; |
| 382 | constexpr uint16_t kLastReceived = 0x4321; |
| 383 | constexpr bool kDecodabilityFlag = true; |
| 384 | const int32_t result = rtcp_sender_->SendLossNotification( |
| 385 | feedback_state(), kLastDecoded, kLastReceived, kDecodabilityFlag); |
| 386 | EXPECT_EQ(result, 0); |
| 387 | EXPECT_EQ(1, parser()->loss_notification()->num_packets()); |
| 388 | EXPECT_EQ(kSenderSsrc, parser()->loss_notification()->sender_ssrc()); |
| 389 | EXPECT_EQ(kRemoteSsrc, parser()->loss_notification()->media_ssrc()); |
| 390 | } |
| 391 | |
Danil Chapovalov | f74d641 | 2017-10-18 13:32:57 +0200 | [diff] [blame] | 392 | TEST_F(RtcpSenderTest, RembNotIncludedBeforeSet) { |
| 393 | rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize); |
| 394 | |
| 395 | rtcp_sender_->SendRTCP(feedback_state(), kRtcpRr); |
| 396 | |
| 397 | ASSERT_EQ(1, parser()->receiver_report()->num_packets()); |
| 398 | EXPECT_EQ(0, parser()->remb()->num_packets()); |
| 399 | } |
| 400 | |
| 401 | TEST_F(RtcpSenderTest, RembNotIncludedAfterUnset) { |
danilchap | ba6aa90 | 2017-04-18 06:57:02 -0700 | [diff] [blame] | 402 | const uint64_t kBitrate = 261011; |
| 403 | const std::vector<uint32_t> kSsrcs = {kRemoteSsrc, kRemoteSsrc + 1}; |
| 404 | rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize); |
Danil Chapovalov | f74d641 | 2017-10-18 13:32:57 +0200 | [diff] [blame] | 405 | rtcp_sender_->SetRemb(kBitrate, kSsrcs); |
danilchap | ba6aa90 | 2017-04-18 06:57:02 -0700 | [diff] [blame] | 406 | rtcp_sender_->SendRTCP(feedback_state(), kRtcpRr); |
| 407 | ASSERT_EQ(1, parser()->receiver_report()->num_packets()); |
Danil Chapovalov | f74d641 | 2017-10-18 13:32:57 +0200 | [diff] [blame] | 408 | EXPECT_EQ(1, parser()->remb()->num_packets()); |
danilchap | ba6aa90 | 2017-04-18 06:57:02 -0700 | [diff] [blame] | 409 | |
Danil Chapovalov | f74d641 | 2017-10-18 13:32:57 +0200 | [diff] [blame] | 410 | // Turn off REMB. rtcp_sender no longer should send it. |
| 411 | rtcp_sender_->UnsetRemb(); |
danilchap | ba6aa90 | 2017-04-18 06:57:02 -0700 | [diff] [blame] | 412 | rtcp_sender_->SendRTCP(feedback_state(), kRtcpRr); |
| 413 | ASSERT_EQ(2, parser()->receiver_report()->num_packets()); |
| 414 | EXPECT_EQ(1, parser()->remb()->num_packets()); |
Danil Chapovalov | 857a8fb | 2016-09-06 11:41:46 +0200 | [diff] [blame] | 415 | } |
| 416 | |
asapersson | 22ff75a | 2015-08-21 00:02:47 -0700 | [diff] [blame] | 417 | TEST_F(RtcpSenderTest, SendRemb) { |
Danil Chapovalov | ba6f7be | 2016-09-02 18:29:10 +0200 | [diff] [blame] | 418 | const uint64_t kBitrate = 261011; |
Danil Chapovalov | f74d641 | 2017-10-18 13:32:57 +0200 | [diff] [blame] | 419 | const std::vector<uint32_t> kSsrcs = {kRemoteSsrc, kRemoteSsrc + 1}; |
pbos | da903ea | 2015-10-02 02:36:56 -0700 | [diff] [blame] | 420 | rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize); |
Danil Chapovalov | f74d641 | 2017-10-18 13:32:57 +0200 | [diff] [blame] | 421 | rtcp_sender_->SetRemb(kBitrate, kSsrcs); |
| 422 | |
| 423 | rtcp_sender_->SendRTCP(feedback_state(), kRtcpRemb); |
| 424 | |
Danil Chapovalov | ba6f7be | 2016-09-02 18:29:10 +0200 | [diff] [blame] | 425 | EXPECT_EQ(1, parser()->remb()->num_packets()); |
| 426 | EXPECT_EQ(kSenderSsrc, parser()->remb()->sender_ssrc()); |
| 427 | EXPECT_EQ(kBitrate, parser()->remb()->bitrate_bps()); |
| 428 | EXPECT_THAT(parser()->remb()->ssrcs(), |
asapersson | 22ff75a | 2015-08-21 00:02:47 -0700 | [diff] [blame] | 429 | ElementsAre(kRemoteSsrc, kRemoteSsrc + 1)); |
| 430 | } |
| 431 | |
Danil Chapovalov | f74d641 | 2017-10-18 13:32:57 +0200 | [diff] [blame] | 432 | TEST_F(RtcpSenderTest, RembIncludedInEachCompoundPacketAfterSet) { |
asapersson | 22ff75a | 2015-08-21 00:02:47 -0700 | [diff] [blame] | 433 | const int kBitrate = 261011; |
Danil Chapovalov | f74d641 | 2017-10-18 13:32:57 +0200 | [diff] [blame] | 434 | const std::vector<uint32_t> kSsrcs = {kRemoteSsrc, kRemoteSsrc + 1}; |
pbos | da903ea | 2015-10-02 02:36:56 -0700 | [diff] [blame] | 435 | rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound); |
Danil Chapovalov | f74d641 | 2017-10-18 13:32:57 +0200 | [diff] [blame] | 436 | rtcp_sender_->SetRemb(kBitrate, kSsrcs); |
| 437 | |
| 438 | rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport); |
Danil Chapovalov | ba6f7be | 2016-09-02 18:29:10 +0200 | [diff] [blame] | 439 | EXPECT_EQ(1, parser()->remb()->num_packets()); |
asapersson | 22ff75a | 2015-08-21 00:02:47 -0700 | [diff] [blame] | 440 | // REMB should be included in each compound packet. |
Danil Chapovalov | f74d641 | 2017-10-18 13:32:57 +0200 | [diff] [blame] | 441 | rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport); |
Danil Chapovalov | ba6f7be | 2016-09-02 18:29:10 +0200 | [diff] [blame] | 442 | EXPECT_EQ(2, parser()->remb()->num_packets()); |
asapersson | 22ff75a | 2015-08-21 00:02:47 -0700 | [diff] [blame] | 443 | } |
| 444 | |
asapersson | 22ff75a | 2015-08-21 00:02:47 -0700 | [diff] [blame] | 445 | TEST_F(RtcpSenderTest, SendXrWithDlrr) { |
pbos | da903ea | 2015-10-02 02:36:56 -0700 | [diff] [blame] | 446 | rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound); |
pbos@webrtc.org | 2f4b14e | 2014-07-15 15:25:39 +0000 | [diff] [blame] | 447 | RTCPSender::FeedbackState feedback_state = rtp_rtcp_impl_->GetFeedbackState(); |
danilchap | 798896a | 2016-09-28 02:54:25 -0700 | [diff] [blame] | 448 | rtcp::ReceiveTimeInfo last_xr_rr; |
| 449 | last_xr_rr.ssrc = 0x11111111; |
| 450 | last_xr_rr.last_rr = 0x22222222; |
| 451 | last_xr_rr.delay_since_last_rr = 0x33333333; |
Mirta Dvornicic | b1f063d | 2018-04-16 11:16:21 +0200 | [diff] [blame] | 452 | feedback_state.last_xr_rtis.push_back(last_xr_rr); |
asapersson@webrtc.org | 8469f7b | 2013-10-02 13:15:34 +0000 | [diff] [blame] | 453 | EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state, kRtcpReport)); |
Danil Chapovalov | ba6f7be | 2016-09-02 18:29:10 +0200 | [diff] [blame] | 454 | EXPECT_EQ(1, parser()->xr()->num_packets()); |
| 455 | EXPECT_EQ(kSenderSsrc, parser()->xr()->sender_ssrc()); |
Mirta Dvornicic | b1f063d | 2018-04-16 11:16:21 +0200 | [diff] [blame] | 456 | ASSERT_THAT(parser()->xr()->dlrr().sub_blocks(), SizeIs(1)); |
danilchap | 80ac24d | 2016-10-31 08:40:47 -0700 | [diff] [blame] | 457 | EXPECT_EQ(last_xr_rr.ssrc, parser()->xr()->dlrr().sub_blocks()[0].ssrc); |
| 458 | EXPECT_EQ(last_xr_rr.last_rr, parser()->xr()->dlrr().sub_blocks()[0].last_rr); |
danilchap | 798896a | 2016-09-28 02:54:25 -0700 | [diff] [blame] | 459 | EXPECT_EQ(last_xr_rr.delay_since_last_rr, |
danilchap | 80ac24d | 2016-10-31 08:40:47 -0700 | [diff] [blame] | 460 | parser()->xr()->dlrr().sub_blocks()[0].delay_since_last_rr); |
asapersson@webrtc.org | 8469f7b | 2013-10-02 13:15:34 +0000 | [diff] [blame] | 461 | } |
| 462 | |
Mirta Dvornicic | b1f063d | 2018-04-16 11:16:21 +0200 | [diff] [blame] | 463 | TEST_F(RtcpSenderTest, SendXrWithMultipleDlrrSubBlocks) { |
| 464 | const size_t kNumReceivers = 2; |
| 465 | rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound); |
| 466 | RTCPSender::FeedbackState feedback_state = rtp_rtcp_impl_->GetFeedbackState(); |
| 467 | for (size_t i = 0; i < kNumReceivers; ++i) { |
| 468 | rtcp::ReceiveTimeInfo last_xr_rr; |
| 469 | last_xr_rr.ssrc = i; |
| 470 | last_xr_rr.last_rr = (i + 1) * 100; |
| 471 | last_xr_rr.delay_since_last_rr = (i + 2) * 200; |
| 472 | feedback_state.last_xr_rtis.push_back(last_xr_rr); |
| 473 | } |
| 474 | |
| 475 | EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state, kRtcpReport)); |
| 476 | EXPECT_EQ(1, parser()->xr()->num_packets()); |
| 477 | EXPECT_EQ(kSenderSsrc, parser()->xr()->sender_ssrc()); |
| 478 | ASSERT_THAT(parser()->xr()->dlrr().sub_blocks(), SizeIs(kNumReceivers)); |
| 479 | for (size_t i = 0; i < kNumReceivers; ++i) { |
| 480 | EXPECT_EQ(feedback_state.last_xr_rtis[i].ssrc, |
| 481 | parser()->xr()->dlrr().sub_blocks()[i].ssrc); |
| 482 | EXPECT_EQ(feedback_state.last_xr_rtis[i].last_rr, |
| 483 | parser()->xr()->dlrr().sub_blocks()[i].last_rr); |
| 484 | EXPECT_EQ(feedback_state.last_xr_rtis[i].delay_since_last_rr, |
| 485 | parser()->xr()->dlrr().sub_blocks()[i].delay_since_last_rr); |
| 486 | } |
| 487 | } |
| 488 | |
asapersson | 22ff75a | 2015-08-21 00:02:47 -0700 | [diff] [blame] | 489 | TEST_F(RtcpSenderTest, SendXrWithRrtr) { |
pbos | da903ea | 2015-10-02 02:36:56 -0700 | [diff] [blame] | 490 | rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound); |
asapersson | 22ff75a | 2015-08-21 00:02:47 -0700 | [diff] [blame] | 491 | EXPECT_EQ(0, rtcp_sender_->SetSendingStatus(feedback_state(), false)); |
asapersson@webrtc.org | 8469f7b | 2013-10-02 13:15:34 +0000 | [diff] [blame] | 492 | rtcp_sender_->SendRtcpXrReceiverReferenceTime(true); |
Ilya Nikolaevskiy | 88c2c50 | 2018-10-26 16:00:08 +0200 | [diff] [blame] | 493 | NtpTime ntp = TimeMicrosToNtp(clock_.TimeInMicroseconds()); |
asapersson | 22ff75a | 2015-08-21 00:02:47 -0700 | [diff] [blame] | 494 | EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport)); |
Danil Chapovalov | ba6f7be | 2016-09-02 18:29:10 +0200 | [diff] [blame] | 495 | EXPECT_EQ(1, parser()->xr()->num_packets()); |
| 496 | EXPECT_EQ(kSenderSsrc, parser()->xr()->sender_ssrc()); |
danilchap | 80ac24d | 2016-10-31 08:40:47 -0700 | [diff] [blame] | 497 | EXPECT_FALSE(parser()->xr()->dlrr()); |
danilchap | 80ac24d | 2016-10-31 08:40:47 -0700 | [diff] [blame] | 498 | ASSERT_TRUE(parser()->xr()->rrtr()); |
danilchap | 21dc189 | 2017-03-07 02:51:09 -0800 | [diff] [blame] | 499 | EXPECT_EQ(ntp, parser()->xr()->rrtr()->ntp()); |
asapersson@webrtc.org | 8469f7b | 2013-10-02 13:15:34 +0000 | [diff] [blame] | 500 | } |
| 501 | |
asapersson | 22ff75a | 2015-08-21 00:02:47 -0700 | [diff] [blame] | 502 | TEST_F(RtcpSenderTest, TestNoXrRrtrSentIfSending) { |
pbos | da903ea | 2015-10-02 02:36:56 -0700 | [diff] [blame] | 503 | rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound); |
asapersson | 22ff75a | 2015-08-21 00:02:47 -0700 | [diff] [blame] | 504 | EXPECT_EQ(0, rtcp_sender_->SetSendingStatus(feedback_state(), true)); |
| 505 | rtcp_sender_->SendRtcpXrReceiverReferenceTime(true); |
| 506 | EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport)); |
Danil Chapovalov | ba6f7be | 2016-09-02 18:29:10 +0200 | [diff] [blame] | 507 | EXPECT_EQ(0, parser()->xr()->num_packets()); |
asapersson | 22ff75a | 2015-08-21 00:02:47 -0700 | [diff] [blame] | 508 | } |
| 509 | |
| 510 | TEST_F(RtcpSenderTest, TestNoXrRrtrSentIfNotEnabled) { |
pbos | da903ea | 2015-10-02 02:36:56 -0700 | [diff] [blame] | 511 | rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound); |
asapersson | 22ff75a | 2015-08-21 00:02:47 -0700 | [diff] [blame] | 512 | EXPECT_EQ(0, rtcp_sender_->SetSendingStatus(feedback_state(), false)); |
asapersson@webrtc.org | 8469f7b | 2013-10-02 13:15:34 +0000 | [diff] [blame] | 513 | rtcp_sender_->SendRtcpXrReceiverReferenceTime(false); |
asapersson | 22ff75a | 2015-08-21 00:02:47 -0700 | [diff] [blame] | 514 | EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport)); |
Danil Chapovalov | ba6f7be | 2016-09-02 18:29:10 +0200 | [diff] [blame] | 515 | EXPECT_EQ(0, parser()->xr()->num_packets()); |
asapersson@webrtc.org | 8469f7b | 2013-10-02 13:15:34 +0000 | [diff] [blame] | 516 | } |
| 517 | |
asapersson | 22ff75a | 2015-08-21 00:02:47 -0700 | [diff] [blame] | 518 | TEST_F(RtcpSenderTest, TestRegisterRtcpPacketTypeObserver) { |
| 519 | RtcpPacketTypeCounterObserverImpl observer; |
sprang | 86fd9ed | 2015-09-29 04:45:43 -0700 | [diff] [blame] | 520 | rtcp_sender_.reset(new RTCPSender(false, &clock_, receive_statistics_.get(), |
Jiawei Ou | 3587b83 | 2018-01-31 22:08:26 -0800 | [diff] [blame] | 521 | &observer, nullptr, &test_transport_, |
Jiawei Ou | 8b5d9d8 | 2018-11-15 16:44:37 -0800 | [diff] [blame] | 522 | 1000)); |
asapersson | 22ff75a | 2015-08-21 00:02:47 -0700 | [diff] [blame] | 523 | rtcp_sender_->SetRemoteSSRC(kRemoteSsrc); |
pbos | da903ea | 2015-10-02 02:36:56 -0700 | [diff] [blame] | 524 | rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize); |
asapersson | 22ff75a | 2015-08-21 00:02:47 -0700 | [diff] [blame] | 525 | EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpPli)); |
| 526 | EXPECT_EQ(1, parser()->pli()->num_packets()); |
| 527 | EXPECT_EQ(kRemoteSsrc, observer.ssrc_); |
| 528 | EXPECT_EQ(1U, observer.counter_.pli_packets); |
| 529 | EXPECT_EQ(clock_.TimeInMilliseconds(), |
| 530 | observer.counter_.first_packet_time_ms); |
| 531 | } |
| 532 | |
| 533 | TEST_F(RtcpSenderTest, SendTmmbr) { |
| 534 | const unsigned int kBitrateBps = 312000; |
pbos | da903ea | 2015-10-02 02:36:56 -0700 | [diff] [blame] | 535 | rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize); |
asapersson | 22ff75a | 2015-08-21 00:02:47 -0700 | [diff] [blame] | 536 | rtcp_sender_->SetTargetBitrate(kBitrateBps); |
| 537 | EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpTmmbr)); |
| 538 | EXPECT_EQ(1, parser()->tmmbr()->num_packets()); |
Danil Chapovalov | ba6f7be | 2016-09-02 18:29:10 +0200 | [diff] [blame] | 539 | EXPECT_EQ(kSenderSsrc, parser()->tmmbr()->sender_ssrc()); |
| 540 | EXPECT_EQ(1U, parser()->tmmbr()->requests().size()); |
| 541 | EXPECT_EQ(kBitrateBps, parser()->tmmbr()->requests()[0].bitrate_bps()); |
asapersson | 22ff75a | 2015-08-21 00:02:47 -0700 | [diff] [blame] | 542 | // TODO(asapersson): tmmbr_item()->Overhead() looks broken, always zero. |
| 543 | } |
| 544 | |
| 545 | TEST_F(RtcpSenderTest, TmmbrIncludedInCompoundPacketIfEnabled) { |
| 546 | const unsigned int kBitrateBps = 312000; |
pbos | da903ea | 2015-10-02 02:36:56 -0700 | [diff] [blame] | 547 | rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound); |
asapersson | 22ff75a | 2015-08-21 00:02:47 -0700 | [diff] [blame] | 548 | EXPECT_FALSE(rtcp_sender_->TMMBR()); |
| 549 | rtcp_sender_->SetTMMBRStatus(true); |
| 550 | EXPECT_TRUE(rtcp_sender_->TMMBR()); |
| 551 | rtcp_sender_->SetTargetBitrate(kBitrateBps); |
| 552 | EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport)); |
| 553 | EXPECT_EQ(1, parser()->tmmbr()->num_packets()); |
Danil Chapovalov | ba6f7be | 2016-09-02 18:29:10 +0200 | [diff] [blame] | 554 | EXPECT_EQ(1U, parser()->tmmbr()->requests().size()); |
asapersson | 22ff75a | 2015-08-21 00:02:47 -0700 | [diff] [blame] | 555 | // TMMBR should be included in each compound packet. |
| 556 | EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport)); |
| 557 | EXPECT_EQ(2, parser()->tmmbr()->num_packets()); |
asapersson | 22ff75a | 2015-08-21 00:02:47 -0700 | [diff] [blame] | 558 | |
| 559 | rtcp_sender_->SetTMMBRStatus(false); |
| 560 | EXPECT_FALSE(rtcp_sender_->TMMBR()); |
| 561 | } |
| 562 | |
| 563 | TEST_F(RtcpSenderTest, SendTmmbn) { |
pbos | da903ea | 2015-10-02 02:36:56 -0700 | [diff] [blame] | 564 | rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound); |
Danil Chapovalov | 70ffead | 2016-07-20 15:26:59 +0200 | [diff] [blame] | 565 | rtcp_sender_->SetSendingStatus(feedback_state(), true); |
danilchap | 6eaa3a4 | 2016-05-09 10:59:50 -0700 | [diff] [blame] | 566 | std::vector<rtcp::TmmbItem> bounding_set; |
Danil Chapovalov | ba6f7be | 2016-09-02 18:29:10 +0200 | [diff] [blame] | 567 | const uint32_t kBitrateBps = 32768000; |
asapersson | 22ff75a | 2015-08-21 00:02:47 -0700 | [diff] [blame] | 568 | const uint32_t kPacketOh = 40; |
| 569 | const uint32_t kSourceSsrc = 12345; |
Danil Chapovalov | ba6f7be | 2016-09-02 18:29:10 +0200 | [diff] [blame] | 570 | const rtcp::TmmbItem tmmbn(kSourceSsrc, kBitrateBps, kPacketOh); |
danilchap | 6eaa3a4 | 2016-05-09 10:59:50 -0700 | [diff] [blame] | 571 | bounding_set.push_back(tmmbn); |
danilchap | 853ecb2 | 2016-08-22 08:26:15 -0700 | [diff] [blame] | 572 | rtcp_sender_->SetTmmbn(bounding_set); |
danilchap | 6eaa3a4 | 2016-05-09 10:59:50 -0700 | [diff] [blame] | 573 | |
asapersson | 22ff75a | 2015-08-21 00:02:47 -0700 | [diff] [blame] | 574 | EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpSr)); |
| 575 | EXPECT_EQ(1, parser()->sender_report()->num_packets()); |
| 576 | EXPECT_EQ(1, parser()->tmmbn()->num_packets()); |
Danil Chapovalov | ba6f7be | 2016-09-02 18:29:10 +0200 | [diff] [blame] | 577 | EXPECT_EQ(kSenderSsrc, parser()->tmmbn()->sender_ssrc()); |
| 578 | EXPECT_EQ(1U, parser()->tmmbn()->items().size()); |
| 579 | EXPECT_EQ(kBitrateBps, parser()->tmmbn()->items()[0].bitrate_bps()); |
| 580 | EXPECT_EQ(kPacketOh, parser()->tmmbn()->items()[0].packet_overhead()); |
| 581 | EXPECT_EQ(kSourceSsrc, parser()->tmmbn()->items()[0].ssrc()); |
asapersson | 22ff75a | 2015-08-21 00:02:47 -0700 | [diff] [blame] | 582 | } |
| 583 | |
hta@webrtc.org | 9d54cd1 | 2012-04-30 08:24:55 +0000 | [diff] [blame] | 584 | // This test is written to verify actual behaviour. It does not seem |
| 585 | // to make much sense to send an empty TMMBN, since there is no place |
| 586 | // to put an actual limit here. It's just information that no limit |
| 587 | // is set, which is kind of the starting assumption. |
| 588 | // See http://code.google.com/p/webrtc/issues/detail?id=468 for one |
| 589 | // situation where this caused confusion. |
| 590 | TEST_F(RtcpSenderTest, SendsTmmbnIfSetAndEmpty) { |
pbos | da903ea | 2015-10-02 02:36:56 -0700 | [diff] [blame] | 591 | rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound); |
Danil Chapovalov | 70ffead | 2016-07-20 15:26:59 +0200 | [diff] [blame] | 592 | rtcp_sender_->SetSendingStatus(feedback_state(), true); |
danilchap | 6eaa3a4 | 2016-05-09 10:59:50 -0700 | [diff] [blame] | 593 | std::vector<rtcp::TmmbItem> bounding_set; |
danilchap | 853ecb2 | 2016-08-22 08:26:15 -0700 | [diff] [blame] | 594 | rtcp_sender_->SetTmmbn(bounding_set); |
asapersson | 22ff75a | 2015-08-21 00:02:47 -0700 | [diff] [blame] | 595 | EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpSr)); |
| 596 | EXPECT_EQ(1, parser()->sender_report()->num_packets()); |
| 597 | EXPECT_EQ(1, parser()->tmmbn()->num_packets()); |
Danil Chapovalov | ba6f7be | 2016-09-02 18:29:10 +0200 | [diff] [blame] | 598 | EXPECT_EQ(kSenderSsrc, parser()->tmmbn()->sender_ssrc()); |
| 599 | EXPECT_EQ(0U, parser()->tmmbn()->items().size()); |
hta@webrtc.org | 65a4e4e | 2012-04-30 11:23:41 +0000 | [diff] [blame] | 600 | } |
| 601 | |
asapersson | 22ff75a | 2015-08-21 00:02:47 -0700 | [diff] [blame] | 602 | TEST_F(RtcpSenderTest, SendCompoundPliRemb) { |
| 603 | const int kBitrate = 261011; |
| 604 | std::vector<uint32_t> ssrcs; |
| 605 | ssrcs.push_back(kRemoteSsrc); |
pbos | da903ea | 2015-10-02 02:36:56 -0700 | [diff] [blame] | 606 | rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound); |
Danil Chapovalov | f74d641 | 2017-10-18 13:32:57 +0200 | [diff] [blame] | 607 | rtcp_sender_->SetRemb(kBitrate, ssrcs); |
asapersson | 22ff75a | 2015-08-21 00:02:47 -0700 | [diff] [blame] | 608 | std::set<RTCPPacketType> packet_types; |
| 609 | packet_types.insert(kRtcpRemb); |
| 610 | packet_types.insert(kRtcpPli); |
| 611 | EXPECT_EQ(0, rtcp_sender_->SendCompoundRTCP(feedback_state(), packet_types)); |
Danil Chapovalov | ba6f7be | 2016-09-02 18:29:10 +0200 | [diff] [blame] | 612 | EXPECT_EQ(1, parser()->remb()->num_packets()); |
asapersson | 22ff75a | 2015-08-21 00:02:47 -0700 | [diff] [blame] | 613 | EXPECT_EQ(1, parser()->pli()->num_packets()); |
asapersson@webrtc.org | 5249cc8 | 2011-12-16 14:31:37 +0000 | [diff] [blame] | 614 | } |
Erik Språng | a38233a | 2015-07-24 09:58:18 +0200 | [diff] [blame] | 615 | |
aleungbroadsoft | 0e2e50c | 2016-02-18 08:33:26 -0800 | [diff] [blame] | 616 | // This test is written to verify that BYE is always the last packet |
| 617 | // type in a RTCP compoud packet. The rtcp_sender_ is recreated with |
| 618 | // mock_transport, which is used to check for whether BYE at the end |
| 619 | // of a RTCP compound packet. |
| 620 | TEST_F(RtcpSenderTest, ByeMustBeLast) { |
| 621 | MockTransport mock_transport; |
| 622 | EXPECT_CALL(mock_transport, SendRtcp(_, _)) |
Yves Gerey | 665174f | 2018-06-19 15:03:05 +0200 | [diff] [blame] | 623 | .WillOnce(Invoke([](const uint8_t* data, size_t len) { |
| 624 | const uint8_t* next_packet = data; |
| 625 | const uint8_t* const packet_end = data + len; |
| 626 | rtcp::CommonHeader packet; |
| 627 | while (next_packet < packet_end) { |
| 628 | EXPECT_TRUE(packet.Parse(next_packet, packet_end - next_packet)); |
| 629 | next_packet = packet.NextPacket(); |
| 630 | if (packet.type() == |
| 631 | rtcp::Bye::kPacketType) // Main test expectation. |
| 632 | EXPECT_EQ(0, packet_end - next_packet) |
| 633 | << "Bye packet should be last in a compound RTCP packet."; |
| 634 | if (next_packet == packet_end) // Validate test was set correctly. |
| 635 | EXPECT_EQ(packet.type(), rtcp::Bye::kPacketType) |
| 636 | << "Last packet in this test expected to be Bye."; |
| 637 | } |
aleungbroadsoft | 0e2e50c | 2016-02-18 08:33:26 -0800 | [diff] [blame] | 638 | |
Yves Gerey | 665174f | 2018-06-19 15:03:05 +0200 | [diff] [blame] | 639 | return true; |
| 640 | })); |
aleungbroadsoft | 0e2e50c | 2016-02-18 08:33:26 -0800 | [diff] [blame] | 641 | |
| 642 | // Re-configure rtcp_sender_ with mock_transport_ |
| 643 | rtcp_sender_.reset(new RTCPSender(false, &clock_, receive_statistics_.get(), |
Jiawei Ou | 8b5d9d8 | 2018-11-15 16:44:37 -0800 | [diff] [blame] | 644 | nullptr, nullptr, &mock_transport, 1000)); |
aleungbroadsoft | 0e2e50c | 2016-02-18 08:33:26 -0800 | [diff] [blame] | 645 | rtcp_sender_->SetSSRC(kSenderSsrc); |
| 646 | rtcp_sender_->SetRemoteSSRC(kRemoteSsrc); |
danilchap | 71fead2 | 2016-08-18 02:01:49 -0700 | [diff] [blame] | 647 | rtcp_sender_->SetTimestampOffset(kStartRtpTimestamp); |
Ilya Nikolaevskiy | 5e58bcb | 2018-10-24 13:34:32 +0200 | [diff] [blame] | 648 | rtcp_sender_->SetLastRtpTime(kRtpTimestamp, clock_.TimeInMilliseconds(), |
| 649 | /*paylpad_type=*/0); |
aleungbroadsoft | 0e2e50c | 2016-02-18 08:33:26 -0800 | [diff] [blame] | 650 | |
Niels Möller | 44b384d | 2018-10-05 11:15:57 +0200 | [diff] [blame] | 651 | // Set up REMB info to be included with BYE. |
aleungbroadsoft | 0e2e50c | 2016-02-18 08:33:26 -0800 | [diff] [blame] | 652 | rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound); |
Niels Möller | 44b384d | 2018-10-05 11:15:57 +0200 | [diff] [blame] | 653 | rtcp_sender_->SetRemb(1234, {}); |
aleungbroadsoft | 0e2e50c | 2016-02-18 08:33:26 -0800 | [diff] [blame] | 654 | EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpBye)); |
| 655 | } |
| 656 | |
sprang | 5e38c96 | 2016-12-01 05:18:09 -0800 | [diff] [blame] | 657 | TEST_F(RtcpSenderTest, SendXrWithTargetBitrate) { |
| 658 | rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound); |
| 659 | const size_t kNumSpatialLayers = 2; |
| 660 | const size_t kNumTemporalLayers = 2; |
Erik Språng | 566124a | 2018-04-23 12:32:22 +0200 | [diff] [blame] | 661 | VideoBitrateAllocation allocation; |
sprang | 5e38c96 | 2016-12-01 05:18:09 -0800 | [diff] [blame] | 662 | for (size_t sl = 0; sl < kNumSpatialLayers; ++sl) { |
| 663 | uint32_t start_bitrate_bps = (sl + 1) * 100000; |
| 664 | for (size_t tl = 0; tl < kNumTemporalLayers; ++tl) |
| 665 | allocation.SetBitrate(sl, tl, start_bitrate_bps + (tl * 20000)); |
| 666 | } |
| 667 | rtcp_sender_->SetVideoBitrateAllocation(allocation); |
| 668 | |
| 669 | EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport)); |
| 670 | EXPECT_EQ(1, parser()->xr()->num_packets()); |
| 671 | EXPECT_EQ(kSenderSsrc, parser()->xr()->sender_ssrc()); |
Danil Chapovalov | d264df5 | 2018-06-14 12:59:38 +0200 | [diff] [blame] | 672 | const absl::optional<rtcp::TargetBitrate>& target_bitrate = |
sprang | 5e38c96 | 2016-12-01 05:18:09 -0800 | [diff] [blame] | 673 | parser()->xr()->target_bitrate(); |
| 674 | ASSERT_TRUE(target_bitrate); |
| 675 | const std::vector<rtcp::TargetBitrate::BitrateItem>& bitrates = |
| 676 | target_bitrate->GetTargetBitrates(); |
| 677 | EXPECT_EQ(kNumSpatialLayers * kNumTemporalLayers, bitrates.size()); |
| 678 | |
| 679 | for (size_t sl = 0; sl < kNumSpatialLayers; ++sl) { |
| 680 | uint32_t start_bitrate_bps = (sl + 1) * 100000; |
| 681 | for (size_t tl = 0; tl < kNumTemporalLayers; ++tl) { |
| 682 | size_t index = (sl * kNumSpatialLayers) + tl; |
| 683 | const rtcp::TargetBitrate::BitrateItem& item = bitrates[index]; |
| 684 | EXPECT_EQ(sl, item.spatial_layer); |
| 685 | EXPECT_EQ(tl, item.temporal_layer); |
| 686 | EXPECT_EQ(start_bitrate_bps + (tl * 20000), |
| 687 | item.target_bitrate_kbps * 1000); |
| 688 | } |
| 689 | } |
| 690 | } |
| 691 | |
Erik Språng | 8782a58 | 2018-10-04 15:36:06 +0200 | [diff] [blame] | 692 | TEST_F(RtcpSenderTest, SendImmediateXrWithTargetBitrate) { |
| 693 | // Initialize. Send a first report right away. |
| 694 | rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound); |
| 695 | EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport)); |
| 696 | clock_.AdvanceTimeMilliseconds(5); |
| 697 | |
| 698 | // Video bitrate allocation generated, save until next time we send a report. |
| 699 | VideoBitrateAllocation allocation; |
| 700 | allocation.SetBitrate(0, 0, 100000); |
| 701 | rtcp_sender_->SetVideoBitrateAllocation(allocation); |
| 702 | // First seen instance will be sent immediately. |
| 703 | EXPECT_TRUE(rtcp_sender_->TimeToSendRTCPReport(false)); |
| 704 | EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport)); |
| 705 | clock_.AdvanceTimeMilliseconds(5); |
| 706 | |
| 707 | // Update bitrate of existing layer, does not quality for immediate sending. |
| 708 | allocation.SetBitrate(0, 0, 150000); |
| 709 | rtcp_sender_->SetVideoBitrateAllocation(allocation); |
| 710 | EXPECT_FALSE(rtcp_sender_->TimeToSendRTCPReport(false)); |
| 711 | |
| 712 | // A new spatial layer enabled, signal this as soon as possible. |
| 713 | allocation.SetBitrate(1, 0, 200000); |
| 714 | rtcp_sender_->SetVideoBitrateAllocation(allocation); |
| 715 | EXPECT_TRUE(rtcp_sender_->TimeToSendRTCPReport(false)); |
| 716 | EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport)); |
| 717 | clock_.AdvanceTimeMilliseconds(5); |
| 718 | |
| 719 | // Explicitly disable top layer. The same set of layers now has a bitrate |
| 720 | // defined, but the explicit 0 indicates shutdown. Signal immediately. |
| 721 | allocation.SetBitrate(1, 0, 0); |
| 722 | EXPECT_FALSE(rtcp_sender_->TimeToSendRTCPReport(false)); |
| 723 | rtcp_sender_->SetVideoBitrateAllocation(allocation); |
| 724 | EXPECT_TRUE(rtcp_sender_->TimeToSendRTCPReport(false)); |
| 725 | } |
| 726 | |
Erik Språng | 1cd7391 | 2018-10-05 12:57:59 +0200 | [diff] [blame] | 727 | TEST_F(RtcpSenderTest, SendTargetBitrateExplicitZeroOnStreamRemoval) { |
| 728 | // Set up and send a bitrate allocation with two layers. |
| 729 | |
| 730 | rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound); |
| 731 | VideoBitrateAllocation allocation; |
| 732 | allocation.SetBitrate(0, 0, 100000); |
| 733 | allocation.SetBitrate(1, 0, 200000); |
| 734 | rtcp_sender_->SetVideoBitrateAllocation(allocation); |
| 735 | EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport)); |
| 736 | absl::optional<rtcp::TargetBitrate> target_bitrate = |
| 737 | parser()->xr()->target_bitrate(); |
| 738 | ASSERT_TRUE(target_bitrate); |
| 739 | std::vector<rtcp::TargetBitrate::BitrateItem> bitrates = |
| 740 | target_bitrate->GetTargetBitrates(); |
| 741 | ASSERT_EQ(2u, bitrates.size()); |
| 742 | EXPECT_EQ(bitrates[0].target_bitrate_kbps, |
| 743 | allocation.GetBitrate(0, 0) / 1000); |
| 744 | EXPECT_EQ(bitrates[1].target_bitrate_kbps, |
| 745 | allocation.GetBitrate(1, 0) / 1000); |
| 746 | |
| 747 | // Create a new allocation, where the second stream is no longer available. |
| 748 | VideoBitrateAllocation new_allocation; |
| 749 | new_allocation.SetBitrate(0, 0, 150000); |
| 750 | rtcp_sender_->SetVideoBitrateAllocation(new_allocation); |
| 751 | EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport)); |
| 752 | target_bitrate = parser()->xr()->target_bitrate(); |
| 753 | ASSERT_TRUE(target_bitrate); |
| 754 | bitrates = target_bitrate->GetTargetBitrates(); |
| 755 | |
| 756 | // Two bitrates should still be set, with an explicit entry indicating the |
| 757 | // removed stream is gone. |
| 758 | ASSERT_EQ(2u, bitrates.size()); |
| 759 | EXPECT_EQ(bitrates[0].target_bitrate_kbps, |
| 760 | new_allocation.GetBitrate(0, 0) / 1000); |
| 761 | EXPECT_EQ(bitrates[1].target_bitrate_kbps, 0u); |
| 762 | } |
| 763 | |
asapersson@webrtc.org | 5249cc8 | 2011-12-16 14:31:37 +0000 | [diff] [blame] | 764 | } // namespace webrtc |