hta@webrtc.org | 47059b5 | 2012-05-02 07:46:22 +0000 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. |
| 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 | |
kwiberg | 529662a | 2017-09-04 05:43:17 -0700 | [diff] [blame] | 13 | #include "webrtc/api/array_view.h" |
pbos@webrtc.org | a048d7c | 2013-05-29 14:27:38 +0000 | [diff] [blame] | 14 | #include "webrtc/common_types.h" |
sprang | a790d83 | 2016-12-02 07:29:44 -0800 | [diff] [blame] | 15 | #include "webrtc/common_video/include/video_bitrate_allocator.h" |
sprang | 49f9cdb | 2015-10-01 03:06:57 -0700 | [diff] [blame] | 16 | #include "webrtc/modules/rtp_rtcp/source/byte_io.h" |
asapersson@webrtc.org | e75d78d | 2014-07-29 08:21:50 +0000 | [diff] [blame] | 17 | #include "webrtc/modules/rtp_rtcp/source/rtcp_packet.h" |
danilchap | 0219c9b | 2015-11-18 05:56:53 -0800 | [diff] [blame] | 18 | #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/app.h" |
danilchap | 50c5136 | 2015-11-22 09:03:11 -0800 | [diff] [blame] | 19 | #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/bye.h" |
danilchap | 7a4116a | 2016-03-14 08:19:28 -0700 | [diff] [blame] | 20 | #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/compound_packet.h" |
danilchap | f8506cb | 2015-11-13 07:33:20 -0800 | [diff] [blame] | 21 | #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_jitter_report.h" |
Danil Chapovalov | 256e5b2 | 2016-01-15 14:16:24 +0100 | [diff] [blame] | 22 | #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_reports.h" |
Danil Chapovalov | 5679da1 | 2016-01-15 13:19:53 +0100 | [diff] [blame] | 23 | #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/fir.h" |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 24 | #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/nack.h" |
danilchap | f8385ad | 2015-11-27 05:36:09 -0800 | [diff] [blame] | 25 | #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/pli.h" |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 26 | #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/rapid_resync_request.h" |
Danil Chapovalov | 97f7e13 | 2015-12-04 16:13:30 +0100 | [diff] [blame] | 27 | #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/receiver_report.h" |
Danil Chapovalov | a5eba6c | 2016-01-15 12:40:15 +0100 | [diff] [blame] | 28 | #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/remb.h" |
Danil Chapovalov | 1567d0b | 2016-01-15 17:34:27 +0100 | [diff] [blame] | 29 | #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/sdes.h" |
danilchap | 34ed2b9 | 2016-01-18 02:43:32 -0800 | [diff] [blame] | 30 | #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/sender_report.h" |
danilchap | 7e8145f | 2016-01-11 11:49:19 -0800 | [diff] [blame] | 31 | #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/tmmbr.h" |
sprang | 49f9cdb | 2015-10-01 03:06:57 -0700 | [diff] [blame] | 32 | #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h" |
danilchap | b8b6fbb | 2015-12-10 05:05:27 -0800 | [diff] [blame] | 33 | #include "webrtc/modules/rtp_rtcp/source/rtcp_receiver.h" |
Danil Chapovalov | a094fd1 | 2016-02-22 18:59:36 +0100 | [diff] [blame] | 34 | #include "webrtc/modules/rtp_rtcp/source/time_util.h" |
Edward Lemur | c20978e | 2017-07-06 19:44:34 +0200 | [diff] [blame] | 35 | #include "webrtc/rtc_base/arraysize.h" |
| 36 | #include "webrtc/rtc_base/random.h" |
Danil Chapovalov | a094fd1 | 2016-02-22 18:59:36 +0100 | [diff] [blame] | 37 | #include "webrtc/system_wrappers/include/ntp_time.h" |
kwiberg | ac9f876 | 2016-09-30 22:29:43 -0700 | [diff] [blame] | 38 | #include "webrtc/test/gmock.h" |
| 39 | #include "webrtc/test/gtest.h" |
hta@webrtc.org | 47059b5 | 2012-05-02 07:46:22 +0000 | [diff] [blame] | 40 | |
| 41 | namespace webrtc { |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 42 | namespace { |
hta@webrtc.org | 47059b5 | 2012-05-02 07:46:22 +0000 | [diff] [blame] | 43 | |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 44 | using ::testing::_; |
| 45 | using ::testing::AllOf; |
| 46 | using ::testing::ElementsAreArray; |
| 47 | using ::testing::Field; |
| 48 | using ::testing::IsEmpty; |
| 49 | using ::testing::NiceMock; |
| 50 | using ::testing::Property; |
| 51 | using ::testing::SizeIs; |
| 52 | using ::testing::StrEq; |
| 53 | using ::testing::StrictMock; |
| 54 | using ::testing::UnorderedElementsAre; |
danilchap | 80ac24d | 2016-10-31 08:40:47 -0700 | [diff] [blame] | 55 | using rtcp::ReceiveTimeInfo; |
hta@webrtc.org | 47059b5 | 2012-05-02 07:46:22 +0000 | [diff] [blame] | 56 | |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 57 | class MockRtcpPacketTypeCounterObserver : public RtcpPacketTypeCounterObserver { |
hta@webrtc.org | 47059b5 | 2012-05-02 07:46:22 +0000 | [diff] [blame] | 58 | public: |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 59 | MOCK_METHOD2(RtcpPacketTypesCounterUpdated, |
| 60 | void(uint32_t, const RtcpPacketTypeCounter&)); |
hta@webrtc.org | 47059b5 | 2012-05-02 07:46:22 +0000 | [diff] [blame] | 61 | }; |
| 62 | |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 63 | class MockRtcpIntraFrameObserver : public RtcpIntraFrameObserver { |
| 64 | public: |
| 65 | MOCK_METHOD1(OnReceivedIntraFrameRequest, void(uint32_t)); |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 66 | }; |
| 67 | |
| 68 | class MockRtcpCallbackImpl : public RtcpStatisticsCallback { |
| 69 | public: |
| 70 | MOCK_METHOD2(StatisticsUpdated, void(const RtcpStatistics&, uint32_t)); |
| 71 | MOCK_METHOD2(CNameChanged, void(const char*, uint32_t)); |
| 72 | }; |
| 73 | |
| 74 | class MockTransportFeedbackObserver : public TransportFeedbackObserver { |
| 75 | public: |
elad.alon | d12a8e1 | 2017-03-23 11:04:48 -0700 | [diff] [blame] | 76 | MOCK_METHOD3(AddPacket, void(uint32_t, uint16_t, size_t)); |
| 77 | MOCK_METHOD4(AddPacket, |
| 78 | void(uint32_t, uint16_t, size_t, const PacedPacketInfo&)); |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 79 | MOCK_METHOD1(OnTransportFeedback, void(const rtcp::TransportFeedback&)); |
elad.alon | f949000 | 2017-03-06 05:32:21 -0800 | [diff] [blame] | 80 | MOCK_CONST_METHOD0(GetTransportFeedbackVector, std::vector<PacketFeedback>()); |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 81 | }; |
| 82 | |
| 83 | class MockRtcpBandwidthObserver : public RtcpBandwidthObserver { |
| 84 | public: |
| 85 | MOCK_METHOD1(OnReceivedEstimatedBitrate, void(uint32_t)); |
| 86 | MOCK_METHOD3(OnReceivedRtcpReceiverReport, |
| 87 | void(const ReportBlockList&, int64_t, int64_t)); |
| 88 | }; |
| 89 | |
| 90 | class MockModuleRtpRtcp : public RTCPReceiver::ModuleRtpRtcp { |
| 91 | public: |
| 92 | MOCK_METHOD1(SetTmmbn, void(std::vector<rtcp::TmmbItem>)); |
| 93 | MOCK_METHOD0(OnRequestSendReport, void()); |
| 94 | MOCK_METHOD1(OnReceivedNack, void(const std::vector<uint16_t>&)); |
| 95 | MOCK_METHOD1(OnReceivedRtcpReportBlocks, void(const ReportBlockList&)); |
| 96 | }; |
| 97 | |
sprang | a790d83 | 2016-12-02 07:29:44 -0800 | [diff] [blame] | 98 | class MockVideoBitrateAllocationObserver |
| 99 | : public VideoBitrateAllocationObserver { |
| 100 | public: |
| 101 | MOCK_METHOD1(OnBitrateAllocationUpdated, |
| 102 | void(const BitrateAllocation& allocation)); |
| 103 | }; |
| 104 | |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 105 | // SSRC of remote peer, that sends rtcp packet to the rtcp receiver under test. |
| 106 | constexpr uint32_t kSenderSsrc = 0x10203; |
| 107 | // SSRCs of local peer, that rtcp packet addressed to. |
| 108 | constexpr uint32_t kReceiverMainSsrc = 0x123456; |
| 109 | // RtcpReceiver can accept several ssrc, e.g. regular and rtx streams. |
| 110 | constexpr uint32_t kReceiverExtraSsrc = 0x1234567; |
| 111 | // SSRCs to ignore (i.e. not configured in RtcpReceiver). |
| 112 | constexpr uint32_t kNotToUsSsrc = 0x654321; |
| 113 | constexpr uint32_t kUnknownSenderSsrc = 0x54321; |
| 114 | |
| 115 | } // namespace |
| 116 | |
hta@webrtc.org | 47059b5 | 2012-05-02 07:46:22 +0000 | [diff] [blame] | 117 | class RtcpReceiverTest : public ::testing::Test { |
| 118 | protected: |
stefan@webrtc.org | 9354cc9 | 2012-06-07 08:10:14 +0000 | [diff] [blame] | 119 | RtcpReceiverTest() |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 120 | : system_clock_(1335900000), |
| 121 | rtcp_receiver_(&system_clock_, |
| 122 | false, |
| 123 | &packet_type_counter_observer_, |
| 124 | &bandwidth_observer_, |
| 125 | &intra_frame_observer_, |
| 126 | &transport_feedback_observer_, |
sprang | a790d83 | 2016-12-02 07:29:44 -0800 | [diff] [blame] | 127 | &bitrate_allocation_observer_, |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 128 | &rtp_rtcp_impl_) {} |
| 129 | void SetUp() { |
| 130 | std::set<uint32_t> ssrcs = {kReceiverMainSsrc, kReceiverExtraSsrc}; |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 131 | rtcp_receiver_.SetSsrcs(kReceiverMainSsrc, ssrcs); |
stefan@webrtc.org | 9354cc9 | 2012-06-07 08:10:14 +0000 | [diff] [blame] | 132 | |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 133 | rtcp_receiver_.SetRemoteSSRC(kSenderSsrc); |
hta@webrtc.org | 47059b5 | 2012-05-02 07:46:22 +0000 | [diff] [blame] | 134 | } |
Erik Språng | 737336d | 2016-07-29 12:59:36 +0200 | [diff] [blame] | 135 | |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 136 | void InjectRtcpPacket(rtc::ArrayView<const uint8_t> raw) { |
| 137 | rtcp_receiver_.IncomingPacket(raw.data(), raw.size()); |
hta@webrtc.org | 47059b5 | 2012-05-02 07:46:22 +0000 | [diff] [blame] | 138 | } |
| 139 | |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 140 | void InjectRtcpPacket(const rtcp::RtcpPacket& packet) { |
| 141 | rtc::Buffer raw = packet.Build(); |
| 142 | rtcp_receiver_.IncomingPacket(raw.data(), raw.size()); |
| 143 | } |
| 144 | |
stefan@webrtc.org | a678a3b | 2013-01-21 07:42:11 +0000 | [diff] [blame] | 145 | SimulatedClock system_clock_; |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 146 | // Callbacks to packet_type_counter_observer are frequent but most of the time |
| 147 | // are not interesting. |
| 148 | NiceMock<MockRtcpPacketTypeCounterObserver> packet_type_counter_observer_; |
| 149 | StrictMock<MockRtcpBandwidthObserver> bandwidth_observer_; |
| 150 | StrictMock<MockRtcpIntraFrameObserver> intra_frame_observer_; |
| 151 | StrictMock<MockTransportFeedbackObserver> transport_feedback_observer_; |
sprang | a790d83 | 2016-12-02 07:29:44 -0800 | [diff] [blame] | 152 | StrictMock<MockVideoBitrateAllocationObserver> bitrate_allocation_observer_; |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 153 | StrictMock<MockModuleRtpRtcp> rtp_rtcp_impl_; |
hta@webrtc.org | 47059b5 | 2012-05-02 07:46:22 +0000 | [diff] [blame] | 154 | |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 155 | RTCPReceiver rtcp_receiver_; |
| 156 | }; |
hta@webrtc.org | 47059b5 | 2012-05-02 07:46:22 +0000 | [diff] [blame] | 157 | |
| 158 | TEST_F(RtcpReceiverTest, BrokenPacketIsIgnored) { |
pbos@webrtc.org | 2f44673 | 2013-04-08 11:08:41 +0000 | [diff] [blame] | 159 | const uint8_t bad_packet[] = {0, 0, 0, 0}; |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 160 | EXPECT_CALL(packet_type_counter_observer_, |
| 161 | RtcpPacketTypesCounterUpdated(_, _)) |
| 162 | .Times(0); |
| 163 | InjectRtcpPacket(bad_packet); |
hta@webrtc.org | 47059b5 | 2012-05-02 07:46:22 +0000 | [diff] [blame] | 164 | } |
| 165 | |
danilchap | 50da1d3 | 2016-03-10 13:13:52 -0800 | [diff] [blame] | 166 | TEST_F(RtcpReceiverTest, InvalidFeedbackPacketIsIgnored) { |
| 167 | // Too short feedback packet. |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 168 | const uint8_t bad_packet[] = {0x81, rtcp::Rtpfb::kPacketType, 0, 0}; |
| 169 | |
| 170 | // TODO(danilchap): Add expectation RtcpPacketTypesCounterUpdated |
| 171 | // is not called once parser would be adjusted to avoid that callback on |
| 172 | // semi-valid packets. |
| 173 | InjectRtcpPacket(bad_packet); |
danilchap | 50da1d3 | 2016-03-10 13:13:52 -0800 | [diff] [blame] | 174 | } |
| 175 | |
hta@webrtc.org | 47059b5 | 2012-05-02 07:46:22 +0000 | [diff] [blame] | 176 | TEST_F(RtcpReceiverTest, InjectSrPacket) { |
danilchap | a04d9c3 | 2017-07-25 04:03:39 -0700 | [diff] [blame] | 177 | EXPECT_FALSE(rtcp_receiver_.NTP(nullptr, nullptr, nullptr, nullptr, nullptr)); |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 178 | |
| 179 | int64_t now = system_clock_.TimeInMilliseconds(); |
asapersson@webrtc.org | e75d78d | 2014-07-29 08:21:50 +0000 | [diff] [blame] | 180 | rtcp::SenderReport sr; |
danilchap | 822a16f | 2016-09-27 09:27:47 -0700 | [diff] [blame] | 181 | sr.SetSenderSsrc(kSenderSsrc); |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 182 | |
| 183 | EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(IsEmpty())); |
| 184 | EXPECT_CALL(bandwidth_observer_, |
| 185 | OnReceivedRtcpReceiverReport(IsEmpty(), _, now)); |
| 186 | InjectRtcpPacket(sr); |
| 187 | |
danilchap | a04d9c3 | 2017-07-25 04:03:39 -0700 | [diff] [blame] | 188 | EXPECT_TRUE(rtcp_receiver_.NTP(nullptr, nullptr, nullptr, nullptr, nullptr)); |
hta@webrtc.org | 47059b5 | 2012-05-02 07:46:22 +0000 | [diff] [blame] | 189 | } |
| 190 | |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 191 | TEST_F(RtcpReceiverTest, InjectSrPacketFromUnknownSender) { |
| 192 | int64_t now = system_clock_.TimeInMilliseconds(); |
asapersson@webrtc.org | f8723d6 | 2014-08-28 07:35:06 +0000 | [diff] [blame] | 193 | rtcp::SenderReport sr; |
danilchap | 822a16f | 2016-09-27 09:27:47 -0700 | [diff] [blame] | 194 | sr.SetSenderSsrc(kUnknownSenderSsrc); |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 195 | |
| 196 | // The parser will handle report blocks in Sender Report from other than his |
| 197 | // expected peer. |
| 198 | EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_)); |
| 199 | EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, now)); |
| 200 | InjectRtcpPacket(sr); |
| 201 | |
| 202 | // But will not flag that he's gotten sender information. |
danilchap | a04d9c3 | 2017-07-25 04:03:39 -0700 | [diff] [blame] | 203 | EXPECT_FALSE(rtcp_receiver_.NTP(nullptr, nullptr, nullptr, nullptr, nullptr)); |
asapersson@webrtc.org | f8723d6 | 2014-08-28 07:35:06 +0000 | [diff] [blame] | 204 | } |
| 205 | |
Danil Chapovalov | a094fd1 | 2016-02-22 18:59:36 +0100 | [diff] [blame] | 206 | TEST_F(RtcpReceiverTest, InjectSrPacketCalculatesRTT) { |
| 207 | Random r(0x0123456789abcdef); |
Danil Chapovalov | c1e55c7 | 2016-03-09 15:14:35 +0100 | [diff] [blame] | 208 | const int64_t kRttMs = r.Rand(1, 9 * 3600 * 1000); |
| 209 | const uint32_t kDelayNtp = r.Rand(0, 0x7fffffff); |
| 210 | const int64_t kDelayMs = CompactNtpRttToMs(kDelayNtp); |
Danil Chapovalov | a094fd1 | 2016-02-22 18:59:36 +0100 | [diff] [blame] | 211 | |
Danil Chapovalov | a094fd1 | 2016-02-22 18:59:36 +0100 | [diff] [blame] | 212 | int64_t rtt_ms = 0; |
| 213 | EXPECT_EQ( |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 214 | -1, rtcp_receiver_.RTT(kSenderSsrc, &rtt_ms, nullptr, nullptr, nullptr)); |
Danil Chapovalov | a094fd1 | 2016-02-22 18:59:36 +0100 | [diff] [blame] | 215 | |
danilchap | 3795376 | 2017-02-09 11:15:25 -0800 | [diff] [blame] | 216 | uint32_t sent_ntp = CompactNtp(system_clock_.CurrentNtpTime()); |
Danil Chapovalov | a094fd1 | 2016-02-22 18:59:36 +0100 | [diff] [blame] | 217 | system_clock_.AdvanceTimeMilliseconds(kRttMs + kDelayMs); |
| 218 | |
| 219 | rtcp::SenderReport sr; |
danilchap | 822a16f | 2016-09-27 09:27:47 -0700 | [diff] [blame] | 220 | sr.SetSenderSsrc(kSenderSsrc); |
Danil Chapovalov | a094fd1 | 2016-02-22 18:59:36 +0100 | [diff] [blame] | 221 | rtcp::ReportBlock block; |
danilchap | 822a16f | 2016-09-27 09:27:47 -0700 | [diff] [blame] | 222 | block.SetMediaSsrc(kReceiverMainSsrc); |
| 223 | block.SetLastSr(sent_ntp); |
| 224 | block.SetDelayLastSr(kDelayNtp); |
| 225 | sr.AddReportBlock(block); |
Danil Chapovalov | a094fd1 | 2016-02-22 18:59:36 +0100 | [diff] [blame] | 226 | |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 227 | EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_)); |
| 228 | EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _)); |
| 229 | InjectRtcpPacket(sr); |
Danil Chapovalov | a094fd1 | 2016-02-22 18:59:36 +0100 | [diff] [blame] | 230 | |
| 231 | EXPECT_EQ( |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 232 | 0, rtcp_receiver_.RTT(kSenderSsrc, &rtt_ms, nullptr, nullptr, nullptr)); |
Danil Chapovalov | a094fd1 | 2016-02-22 18:59:36 +0100 | [diff] [blame] | 233 | EXPECT_NEAR(kRttMs, rtt_ms, 1); |
| 234 | } |
| 235 | |
Danil Chapovalov | c1e55c7 | 2016-03-09 15:14:35 +0100 | [diff] [blame] | 236 | TEST_F(RtcpReceiverTest, InjectSrPacketCalculatesNegativeRTTAsOne) { |
| 237 | Random r(0x0123456789abcdef); |
Danil Chapovalov | c1e55c7 | 2016-03-09 15:14:35 +0100 | [diff] [blame] | 238 | const int64_t kRttMs = r.Rand(-3600 * 1000, -1); |
| 239 | const uint32_t kDelayNtp = r.Rand(0, 0x7fffffff); |
| 240 | const int64_t kDelayMs = CompactNtpRttToMs(kDelayNtp); |
| 241 | |
Danil Chapovalov | c1e55c7 | 2016-03-09 15:14:35 +0100 | [diff] [blame] | 242 | int64_t rtt_ms = 0; |
| 243 | EXPECT_EQ( |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 244 | -1, rtcp_receiver_.RTT(kSenderSsrc, &rtt_ms, nullptr, nullptr, nullptr)); |
Danil Chapovalov | c1e55c7 | 2016-03-09 15:14:35 +0100 | [diff] [blame] | 245 | |
danilchap | 3795376 | 2017-02-09 11:15:25 -0800 | [diff] [blame] | 246 | uint32_t sent_ntp = CompactNtp(system_clock_.CurrentNtpTime()); |
Danil Chapovalov | c1e55c7 | 2016-03-09 15:14:35 +0100 | [diff] [blame] | 247 | system_clock_.AdvanceTimeMilliseconds(kRttMs + kDelayMs); |
| 248 | |
| 249 | rtcp::SenderReport sr; |
danilchap | 822a16f | 2016-09-27 09:27:47 -0700 | [diff] [blame] | 250 | sr.SetSenderSsrc(kSenderSsrc); |
Danil Chapovalov | c1e55c7 | 2016-03-09 15:14:35 +0100 | [diff] [blame] | 251 | rtcp::ReportBlock block; |
danilchap | 822a16f | 2016-09-27 09:27:47 -0700 | [diff] [blame] | 252 | block.SetMediaSsrc(kReceiverMainSsrc); |
| 253 | block.SetLastSr(sent_ntp); |
| 254 | block.SetDelayLastSr(kDelayNtp); |
| 255 | sr.AddReportBlock(block); |
Danil Chapovalov | c1e55c7 | 2016-03-09 15:14:35 +0100 | [diff] [blame] | 256 | |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 257 | EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(SizeIs(1))); |
| 258 | EXPECT_CALL(bandwidth_observer_, |
| 259 | OnReceivedRtcpReceiverReport(SizeIs(1), _, _)); |
| 260 | InjectRtcpPacket(sr); |
Danil Chapovalov | c1e55c7 | 2016-03-09 15:14:35 +0100 | [diff] [blame] | 261 | |
| 262 | EXPECT_EQ( |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 263 | 0, rtcp_receiver_.RTT(kSenderSsrc, &rtt_ms, nullptr, nullptr, nullptr)); |
Danil Chapovalov | c1e55c7 | 2016-03-09 15:14:35 +0100 | [diff] [blame] | 264 | EXPECT_EQ(1, rtt_ms); |
| 265 | } |
| 266 | |
asapersson@webrtc.org | f8723d6 | 2014-08-28 07:35:06 +0000 | [diff] [blame] | 267 | TEST_F(RtcpReceiverTest, InjectRrPacket) { |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 268 | int64_t now = system_clock_.TimeInMilliseconds(); |
asapersson@webrtc.org | f8723d6 | 2014-08-28 07:35:06 +0000 | [diff] [blame] | 269 | rtcp::ReceiverReport rr; |
danilchap | 822a16f | 2016-09-27 09:27:47 -0700 | [diff] [blame] | 270 | rr.SetSenderSsrc(kSenderSsrc); |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 271 | |
| 272 | EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(IsEmpty())); |
| 273 | EXPECT_CALL(bandwidth_observer_, |
| 274 | OnReceivedRtcpReceiverReport(IsEmpty(), _, now)); |
| 275 | InjectRtcpPacket(rr); |
| 276 | |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 277 | EXPECT_EQ(now, rtcp_receiver_.LastReceivedReceiverReport()); |
| 278 | std::vector<RTCPReportBlock> report_blocks; |
| 279 | rtcp_receiver_.StatisticsReceived(&report_blocks); |
| 280 | EXPECT_TRUE(report_blocks.empty()); |
asapersson@webrtc.org | f8723d6 | 2014-08-28 07:35:06 +0000 | [diff] [blame] | 281 | } |
| 282 | |
| 283 | TEST_F(RtcpReceiverTest, InjectRrPacketWithReportBlockNotToUsIgnored) { |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 284 | int64_t now = system_clock_.TimeInMilliseconds(); |
asapersson@webrtc.org | f8723d6 | 2014-08-28 07:35:06 +0000 | [diff] [blame] | 285 | rtcp::ReportBlock rb; |
danilchap | 822a16f | 2016-09-27 09:27:47 -0700 | [diff] [blame] | 286 | rb.SetMediaSsrc(kNotToUsSsrc); |
asapersson@webrtc.org | f8723d6 | 2014-08-28 07:35:06 +0000 | [diff] [blame] | 287 | rtcp::ReceiverReport rr; |
danilchap | 822a16f | 2016-09-27 09:27:47 -0700 | [diff] [blame] | 288 | rr.SetSenderSsrc(kSenderSsrc); |
| 289 | rr.AddReportBlock(rb); |
asapersson@webrtc.org | cb79141 | 2014-12-18 14:30:32 +0000 | [diff] [blame] | 290 | |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 291 | EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(IsEmpty())); |
| 292 | EXPECT_CALL(bandwidth_observer_, |
| 293 | OnReceivedRtcpReceiverReport(IsEmpty(), _, now)); |
| 294 | InjectRtcpPacket(rr); |
| 295 | |
| 296 | EXPECT_EQ(now, rtcp_receiver_.LastReceivedReceiverReport()); |
asapersson@webrtc.org | cb79141 | 2014-12-18 14:30:32 +0000 | [diff] [blame] | 297 | std::vector<RTCPReportBlock> received_blocks; |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 298 | rtcp_receiver_.StatisticsReceived(&received_blocks); |
asapersson@webrtc.org | cb79141 | 2014-12-18 14:30:32 +0000 | [diff] [blame] | 299 | EXPECT_TRUE(received_blocks.empty()); |
asapersson@webrtc.org | f8723d6 | 2014-08-28 07:35:06 +0000 | [diff] [blame] | 300 | } |
| 301 | |
| 302 | TEST_F(RtcpReceiverTest, InjectRrPacketWithOneReportBlock) { |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 303 | int64_t now = system_clock_.TimeInMilliseconds(); |
asapersson@webrtc.org | f8723d6 | 2014-08-28 07:35:06 +0000 | [diff] [blame] | 304 | |
| 305 | rtcp::ReportBlock rb; |
danilchap | 822a16f | 2016-09-27 09:27:47 -0700 | [diff] [blame] | 306 | rb.SetMediaSsrc(kReceiverMainSsrc); |
asapersson@webrtc.org | f8723d6 | 2014-08-28 07:35:06 +0000 | [diff] [blame] | 307 | rtcp::ReceiverReport rr; |
danilchap | 822a16f | 2016-09-27 09:27:47 -0700 | [diff] [blame] | 308 | rr.SetSenderSsrc(kSenderSsrc); |
| 309 | rr.AddReportBlock(rb); |
asapersson@webrtc.org | cb79141 | 2014-12-18 14:30:32 +0000 | [diff] [blame] | 310 | |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 311 | EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(SizeIs(1))); |
| 312 | EXPECT_CALL(bandwidth_observer_, |
| 313 | OnReceivedRtcpReceiverReport(SizeIs(1), _, now)); |
| 314 | InjectRtcpPacket(rr); |
| 315 | |
| 316 | EXPECT_EQ(now, rtcp_receiver_.LastReceivedReceiverReport()); |
asapersson@webrtc.org | cb79141 | 2014-12-18 14:30:32 +0000 | [diff] [blame] | 317 | std::vector<RTCPReportBlock> received_blocks; |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 318 | rtcp_receiver_.StatisticsReceived(&received_blocks); |
asapersson@webrtc.org | cb79141 | 2014-12-18 14:30:32 +0000 | [diff] [blame] | 319 | EXPECT_EQ(1u, received_blocks.size()); |
asapersson@webrtc.org | f8723d6 | 2014-08-28 07:35:06 +0000 | [diff] [blame] | 320 | } |
| 321 | |
| 322 | TEST_F(RtcpReceiverTest, InjectRrPacketWithTwoReportBlocks) { |
asapersson@webrtc.org | f8723d6 | 2014-08-28 07:35:06 +0000 | [diff] [blame] | 323 | const uint16_t kSequenceNumbers[] = {10, 12423}; |
asapersson@webrtc.org | cb79141 | 2014-12-18 14:30:32 +0000 | [diff] [blame] | 324 | const uint32_t kCumLost[] = {13, 555}; |
| 325 | const uint8_t kFracLost[] = {20, 11}; |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 326 | int64_t now = system_clock_.TimeInMilliseconds(); |
asapersson@webrtc.org | f8723d6 | 2014-08-28 07:35:06 +0000 | [diff] [blame] | 327 | |
| 328 | rtcp::ReportBlock rb1; |
danilchap | 822a16f | 2016-09-27 09:27:47 -0700 | [diff] [blame] | 329 | rb1.SetMediaSsrc(kReceiverMainSsrc); |
| 330 | rb1.SetExtHighestSeqNum(kSequenceNumbers[0]); |
| 331 | rb1.SetFractionLost(10); |
asapersson@webrtc.org | f8723d6 | 2014-08-28 07:35:06 +0000 | [diff] [blame] | 332 | |
| 333 | rtcp::ReportBlock rb2; |
danilchap | 822a16f | 2016-09-27 09:27:47 -0700 | [diff] [blame] | 334 | rb2.SetMediaSsrc(kReceiverExtraSsrc); |
| 335 | rb2.SetExtHighestSeqNum(kSequenceNumbers[1]); |
| 336 | rb2.SetFractionLost(0); |
asapersson@webrtc.org | f8723d6 | 2014-08-28 07:35:06 +0000 | [diff] [blame] | 337 | |
| 338 | rtcp::ReceiverReport rr1; |
danilchap | 822a16f | 2016-09-27 09:27:47 -0700 | [diff] [blame] | 339 | rr1.SetSenderSsrc(kSenderSsrc); |
| 340 | rr1.AddReportBlock(rb1); |
| 341 | rr1.AddReportBlock(rb2); |
asapersson@webrtc.org | f8723d6 | 2014-08-28 07:35:06 +0000 | [diff] [blame] | 342 | |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 343 | EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(SizeIs(2))); |
| 344 | EXPECT_CALL(bandwidth_observer_, |
| 345 | OnReceivedRtcpReceiverReport(SizeIs(2), _, now)); |
| 346 | InjectRtcpPacket(rr1); |
asapersson@webrtc.org | f8723d6 | 2014-08-28 07:35:06 +0000 | [diff] [blame] | 347 | |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 348 | EXPECT_EQ(now, rtcp_receiver_.LastReceivedReceiverReport()); |
| 349 | std::vector<RTCPReportBlock> received_blocks; |
| 350 | rtcp_receiver_.StatisticsReceived(&received_blocks); |
| 351 | EXPECT_THAT(received_blocks, |
srte | 3e69e5c | 2017-08-09 06:13:45 -0700 | [diff] [blame] | 352 | UnorderedElementsAre(Field(&RTCPReportBlock::fraction_lost, 0), |
| 353 | Field(&RTCPReportBlock::fraction_lost, 10))); |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 354 | |
| 355 | // Insert next receiver report with same ssrc but new values. |
asapersson@webrtc.org | f8723d6 | 2014-08-28 07:35:06 +0000 | [diff] [blame] | 356 | rtcp::ReportBlock rb3; |
danilchap | 822a16f | 2016-09-27 09:27:47 -0700 | [diff] [blame] | 357 | rb3.SetMediaSsrc(kReceiverMainSsrc); |
| 358 | rb3.SetExtHighestSeqNum(kSequenceNumbers[0]); |
| 359 | rb3.SetFractionLost(kFracLost[0]); |
| 360 | rb3.SetCumulativeLost(kCumLost[0]); |
asapersson@webrtc.org | f8723d6 | 2014-08-28 07:35:06 +0000 | [diff] [blame] | 361 | |
| 362 | rtcp::ReportBlock rb4; |
danilchap | 822a16f | 2016-09-27 09:27:47 -0700 | [diff] [blame] | 363 | rb4.SetMediaSsrc(kReceiverExtraSsrc); |
| 364 | rb4.SetExtHighestSeqNum(kSequenceNumbers[1]); |
| 365 | rb4.SetFractionLost(kFracLost[1]); |
| 366 | rb4.SetCumulativeLost(kCumLost[1]); |
asapersson@webrtc.org | f8723d6 | 2014-08-28 07:35:06 +0000 | [diff] [blame] | 367 | |
| 368 | rtcp::ReceiverReport rr2; |
danilchap | 822a16f | 2016-09-27 09:27:47 -0700 | [diff] [blame] | 369 | rr2.SetSenderSsrc(kSenderSsrc); |
| 370 | rr2.AddReportBlock(rb3); |
| 371 | rr2.AddReportBlock(rb4); |
asapersson@webrtc.org | f8723d6 | 2014-08-28 07:35:06 +0000 | [diff] [blame] | 372 | |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 373 | // Advance time to make 1st sent time and 2nd sent time different. |
| 374 | system_clock_.AdvanceTimeMilliseconds(500); |
| 375 | now = system_clock_.TimeInMilliseconds(); |
asapersson@webrtc.org | cb79141 | 2014-12-18 14:30:32 +0000 | [diff] [blame] | 376 | |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 377 | EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(SizeIs(2))); |
| 378 | EXPECT_CALL(bandwidth_observer_, |
| 379 | OnReceivedRtcpReceiverReport(SizeIs(2), _, now)); |
| 380 | InjectRtcpPacket(rr2); |
| 381 | |
| 382 | received_blocks.clear(); |
| 383 | rtcp_receiver_.StatisticsReceived(&received_blocks); |
asapersson@webrtc.org | cb79141 | 2014-12-18 14:30:32 +0000 | [diff] [blame] | 384 | EXPECT_EQ(2u, received_blocks.size()); |
srte | 3e69e5c | 2017-08-09 06:13:45 -0700 | [diff] [blame] | 385 | EXPECT_THAT( |
| 386 | received_blocks, |
| 387 | UnorderedElementsAre( |
| 388 | AllOf(Field(&RTCPReportBlock::source_ssrc, kReceiverMainSsrc), |
| 389 | Field(&RTCPReportBlock::fraction_lost, kFracLost[0]), |
| 390 | Field(&RTCPReportBlock::packets_lost, kCumLost[0]), |
| 391 | Field(&RTCPReportBlock::extended_highest_sequence_number, |
| 392 | kSequenceNumbers[0])), |
| 393 | AllOf(Field(&RTCPReportBlock::source_ssrc, kReceiverExtraSsrc), |
| 394 | Field(&RTCPReportBlock::fraction_lost, kFracLost[1]), |
| 395 | Field(&RTCPReportBlock::packets_lost, kCumLost[1]), |
| 396 | Field(&RTCPReportBlock::extended_highest_sequence_number, |
| 397 | kSequenceNumbers[1])))); |
asapersson@webrtc.org | cb79141 | 2014-12-18 14:30:32 +0000 | [diff] [blame] | 398 | } |
| 399 | |
| 400 | TEST_F(RtcpReceiverTest, InjectRrPacketsFromTwoRemoteSsrcs) { |
asapersson@webrtc.org | cb79141 | 2014-12-18 14:30:32 +0000 | [diff] [blame] | 401 | const uint32_t kSenderSsrc2 = 0x20304; |
asapersson@webrtc.org | cb79141 | 2014-12-18 14:30:32 +0000 | [diff] [blame] | 402 | const uint16_t kSequenceNumbers[] = {10, 12423}; |
| 403 | const uint32_t kCumLost[] = {13, 555}; |
| 404 | const uint8_t kFracLost[] = {20, 11}; |
asapersson@webrtc.org | cb79141 | 2014-12-18 14:30:32 +0000 | [diff] [blame] | 405 | |
| 406 | rtcp::ReportBlock rb1; |
danilchap | 822a16f | 2016-09-27 09:27:47 -0700 | [diff] [blame] | 407 | rb1.SetMediaSsrc(kReceiverMainSsrc); |
| 408 | rb1.SetExtHighestSeqNum(kSequenceNumbers[0]); |
| 409 | rb1.SetFractionLost(kFracLost[0]); |
| 410 | rb1.SetCumulativeLost(kCumLost[0]); |
asapersson@webrtc.org | cb79141 | 2014-12-18 14:30:32 +0000 | [diff] [blame] | 411 | rtcp::ReceiverReport rr1; |
danilchap | 822a16f | 2016-09-27 09:27:47 -0700 | [diff] [blame] | 412 | rr1.SetSenderSsrc(kSenderSsrc); |
| 413 | rr1.AddReportBlock(rb1); |
asapersson@webrtc.org | cb79141 | 2014-12-18 14:30:32 +0000 | [diff] [blame] | 414 | |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 415 | int64_t now = system_clock_.TimeInMilliseconds(); |
| 416 | |
| 417 | EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(SizeIs(1))); |
| 418 | EXPECT_CALL(bandwidth_observer_, |
| 419 | OnReceivedRtcpReceiverReport(SizeIs(1), _, now)); |
| 420 | InjectRtcpPacket(rr1); |
| 421 | |
| 422 | EXPECT_EQ(now, rtcp_receiver_.LastReceivedReceiverReport()); |
asapersson@webrtc.org | cb79141 | 2014-12-18 14:30:32 +0000 | [diff] [blame] | 423 | |
| 424 | std::vector<RTCPReportBlock> received_blocks; |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 425 | rtcp_receiver_.StatisticsReceived(&received_blocks); |
asapersson@webrtc.org | cb79141 | 2014-12-18 14:30:32 +0000 | [diff] [blame] | 426 | EXPECT_EQ(1u, received_blocks.size()); |
srte | 3e69e5c | 2017-08-09 06:13:45 -0700 | [diff] [blame] | 427 | EXPECT_EQ(kSenderSsrc, received_blocks[0].sender_ssrc); |
| 428 | EXPECT_EQ(kReceiverMainSsrc, received_blocks[0].source_ssrc); |
| 429 | EXPECT_EQ(kFracLost[0], received_blocks[0].fraction_lost); |
| 430 | EXPECT_EQ(kCumLost[0], received_blocks[0].packets_lost); |
| 431 | EXPECT_EQ(kSequenceNumbers[0], |
| 432 | received_blocks[0].extended_highest_sequence_number); |
asapersson@webrtc.org | cb79141 | 2014-12-18 14:30:32 +0000 | [diff] [blame] | 433 | |
| 434 | rtcp::ReportBlock rb2; |
danilchap | 822a16f | 2016-09-27 09:27:47 -0700 | [diff] [blame] | 435 | rb2.SetMediaSsrc(kReceiverMainSsrc); |
| 436 | rb2.SetExtHighestSeqNum(kSequenceNumbers[1]); |
| 437 | rb2.SetFractionLost(kFracLost[1]); |
| 438 | rb2.SetCumulativeLost(kCumLost[1]); |
asapersson@webrtc.org | cb79141 | 2014-12-18 14:30:32 +0000 | [diff] [blame] | 439 | rtcp::ReceiverReport rr2; |
danilchap | 822a16f | 2016-09-27 09:27:47 -0700 | [diff] [blame] | 440 | rr2.SetSenderSsrc(kSenderSsrc2); |
| 441 | rr2.AddReportBlock(rb2); |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 442 | |
| 443 | EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(SizeIs(1))); |
| 444 | EXPECT_CALL(bandwidth_observer_, |
| 445 | OnReceivedRtcpReceiverReport(SizeIs(1), _, now)); |
| 446 | InjectRtcpPacket(rr2); |
asapersson@webrtc.org | cb79141 | 2014-12-18 14:30:32 +0000 | [diff] [blame] | 447 | |
| 448 | received_blocks.clear(); |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 449 | rtcp_receiver_.StatisticsReceived(&received_blocks); |
asapersson@webrtc.org | cb79141 | 2014-12-18 14:30:32 +0000 | [diff] [blame] | 450 | ASSERT_EQ(2u, received_blocks.size()); |
srte | 3e69e5c | 2017-08-09 06:13:45 -0700 | [diff] [blame] | 451 | EXPECT_THAT( |
| 452 | received_blocks, |
| 453 | UnorderedElementsAre( |
| 454 | AllOf(Field(&RTCPReportBlock::source_ssrc, kReceiverMainSsrc), |
| 455 | Field(&RTCPReportBlock::sender_ssrc, kSenderSsrc), |
| 456 | Field(&RTCPReportBlock::fraction_lost, kFracLost[0]), |
| 457 | Field(&RTCPReportBlock::packets_lost, kCumLost[0]), |
| 458 | Field(&RTCPReportBlock::extended_highest_sequence_number, |
| 459 | kSequenceNumbers[0])), |
| 460 | AllOf(Field(&RTCPReportBlock::source_ssrc, kReceiverMainSsrc), |
| 461 | Field(&RTCPReportBlock::sender_ssrc, kSenderSsrc2), |
| 462 | Field(&RTCPReportBlock::fraction_lost, kFracLost[1]), |
| 463 | Field(&RTCPReportBlock::packets_lost, kCumLost[1]), |
| 464 | Field(&RTCPReportBlock::extended_highest_sequence_number, |
| 465 | kSequenceNumbers[1])))); |
asapersson@webrtc.org | cb79141 | 2014-12-18 14:30:32 +0000 | [diff] [blame] | 466 | } |
| 467 | |
| 468 | TEST_F(RtcpReceiverTest, GetRtt) { |
danilchap | 28b03eb | 2016-10-05 06:59:44 -0700 | [diff] [blame] | 469 | const uint32_t kSentCompactNtp = 0x1234; |
| 470 | const uint32_t kDelayCompactNtp = 0x222; |
asapersson@webrtc.org | cb79141 | 2014-12-18 14:30:32 +0000 | [diff] [blame] | 471 | // No report block received. |
Erik Språng | 6b8d355 | 2015-09-24 15:06:57 +0200 | [diff] [blame] | 472 | EXPECT_EQ( |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 473 | -1, rtcp_receiver_.RTT(kSenderSsrc, nullptr, nullptr, nullptr, nullptr)); |
asapersson@webrtc.org | cb79141 | 2014-12-18 14:30:32 +0000 | [diff] [blame] | 474 | |
| 475 | rtcp::ReportBlock rb; |
danilchap | 822a16f | 2016-09-27 09:27:47 -0700 | [diff] [blame] | 476 | rb.SetMediaSsrc(kReceiverMainSsrc); |
danilchap | 28b03eb | 2016-10-05 06:59:44 -0700 | [diff] [blame] | 477 | rb.SetLastSr(kSentCompactNtp); |
| 478 | rb.SetDelayLastSr(kDelayCompactNtp); |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 479 | |
asapersson@webrtc.org | cb79141 | 2014-12-18 14:30:32 +0000 | [diff] [blame] | 480 | rtcp::ReceiverReport rr; |
danilchap | 822a16f | 2016-09-27 09:27:47 -0700 | [diff] [blame] | 481 | rr.SetSenderSsrc(kSenderSsrc); |
| 482 | rr.AddReportBlock(rb); |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 483 | int64_t now = system_clock_.TimeInMilliseconds(); |
asapersson@webrtc.org | cb79141 | 2014-12-18 14:30:32 +0000 | [diff] [blame] | 484 | |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 485 | EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_)); |
| 486 | EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _)); |
| 487 | InjectRtcpPacket(rr); |
| 488 | |
| 489 | EXPECT_EQ(now, rtcp_receiver_.LastReceivedReceiverReport()); |
| 490 | EXPECT_EQ( |
| 491 | 0, rtcp_receiver_.RTT(kSenderSsrc, nullptr, nullptr, nullptr, nullptr)); |
asapersson@webrtc.org | f8723d6 | 2014-08-28 07:35:06 +0000 | [diff] [blame] | 492 | } |
| 493 | |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 494 | // Ij packets are ignored. |
asapersson@webrtc.org | f8723d6 | 2014-08-28 07:35:06 +0000 | [diff] [blame] | 495 | TEST_F(RtcpReceiverTest, InjectIjWithNoItem) { |
danilchap | f8506cb | 2015-11-13 07:33:20 -0800 | [diff] [blame] | 496 | rtcp::ExtendedJitterReport ij; |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 497 | InjectRtcpPacket(ij); |
asapersson@webrtc.org | f8723d6 | 2014-08-28 07:35:06 +0000 | [diff] [blame] | 498 | } |
| 499 | |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 500 | // App packets are ignored. |
| 501 | TEST_F(RtcpReceiverTest, InjectApp) { |
asapersson@webrtc.org | f8723d6 | 2014-08-28 07:35:06 +0000 | [diff] [blame] | 502 | rtcp::App app; |
danilchap | 822a16f | 2016-09-27 09:27:47 -0700 | [diff] [blame] | 503 | app.SetSubType(30); |
| 504 | app.SetName(0x17a177e); |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 505 | const uint8_t kData[] = {'t', 'e', 's', 't', 'd', 'a', 't', 'a'}; |
danilchap | 822a16f | 2016-09-27 09:27:47 -0700 | [diff] [blame] | 506 | app.SetData(kData, sizeof(kData)); |
asapersson@webrtc.org | f8723d6 | 2014-08-28 07:35:06 +0000 | [diff] [blame] | 507 | |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 508 | InjectRtcpPacket(app); |
asapersson@webrtc.org | f8723d6 | 2014-08-28 07:35:06 +0000 | [diff] [blame] | 509 | } |
| 510 | |
| 511 | TEST_F(RtcpReceiverTest, InjectSdesWithOneChunk) { |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 512 | const char kCname[] = "alice@host"; |
| 513 | MockRtcpCallbackImpl callback; |
| 514 | rtcp_receiver_.RegisterRtcpStatisticsCallback(&callback); |
asapersson@webrtc.org | f8723d6 | 2014-08-28 07:35:06 +0000 | [diff] [blame] | 515 | rtcp::Sdes sdes; |
danilchap | 822a16f | 2016-09-27 09:27:47 -0700 | [diff] [blame] | 516 | sdes.AddCName(kSenderSsrc, kCname); |
asapersson@webrtc.org | f8723d6 | 2014-08-28 07:35:06 +0000 | [diff] [blame] | 517 | |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 518 | EXPECT_CALL(callback, CNameChanged(StrEq(kCname), kSenderSsrc)); |
| 519 | InjectRtcpPacket(sdes); |
| 520 | |
asapersson@webrtc.org | f8723d6 | 2014-08-28 07:35:06 +0000 | [diff] [blame] | 521 | char cName[RTCP_CNAME_SIZE]; |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 522 | EXPECT_EQ(0, rtcp_receiver_.CNAME(kSenderSsrc, cName)); |
| 523 | EXPECT_EQ(0, strncmp(cName, kCname, RTCP_CNAME_SIZE)); |
asapersson@webrtc.org | f8723d6 | 2014-08-28 07:35:06 +0000 | [diff] [blame] | 524 | } |
| 525 | |
asapersson@webrtc.org | cb79141 | 2014-12-18 14:30:32 +0000 | [diff] [blame] | 526 | TEST_F(RtcpReceiverTest, InjectByePacket_RemovesCname) { |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 527 | const char kCname[] = "alice@host"; |
asapersson@webrtc.org | f8723d6 | 2014-08-28 07:35:06 +0000 | [diff] [blame] | 528 | rtcp::Sdes sdes; |
danilchap | 822a16f | 2016-09-27 09:27:47 -0700 | [diff] [blame] | 529 | sdes.AddCName(kSenderSsrc, kCname); |
asapersson@webrtc.org | f8723d6 | 2014-08-28 07:35:06 +0000 | [diff] [blame] | 530 | |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 531 | InjectRtcpPacket(sdes); |
| 532 | |
asapersson@webrtc.org | f8723d6 | 2014-08-28 07:35:06 +0000 | [diff] [blame] | 533 | char cName[RTCP_CNAME_SIZE]; |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 534 | EXPECT_EQ(0, rtcp_receiver_.CNAME(kSenderSsrc, cName)); |
asapersson@webrtc.org | f8723d6 | 2014-08-28 07:35:06 +0000 | [diff] [blame] | 535 | |
| 536 | // Verify that BYE removes the CNAME. |
| 537 | rtcp::Bye bye; |
danilchap | 822a16f | 2016-09-27 09:27:47 -0700 | [diff] [blame] | 538 | bye.SetSenderSsrc(kSenderSsrc); |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 539 | |
| 540 | InjectRtcpPacket(bye); |
| 541 | |
| 542 | EXPECT_EQ(-1, rtcp_receiver_.CNAME(kSenderSsrc, cName)); |
asapersson@webrtc.org | f8723d6 | 2014-08-28 07:35:06 +0000 | [diff] [blame] | 543 | } |
| 544 | |
asapersson@webrtc.org | cb79141 | 2014-12-18 14:30:32 +0000 | [diff] [blame] | 545 | TEST_F(RtcpReceiverTest, InjectByePacket_RemovesReportBlocks) { |
asapersson@webrtc.org | cb79141 | 2014-12-18 14:30:32 +0000 | [diff] [blame] | 546 | rtcp::ReportBlock rb1; |
danilchap | 822a16f | 2016-09-27 09:27:47 -0700 | [diff] [blame] | 547 | rb1.SetMediaSsrc(kReceiverMainSsrc); |
asapersson@webrtc.org | cb79141 | 2014-12-18 14:30:32 +0000 | [diff] [blame] | 548 | rtcp::ReportBlock rb2; |
danilchap | 822a16f | 2016-09-27 09:27:47 -0700 | [diff] [blame] | 549 | rb2.SetMediaSsrc(kReceiverExtraSsrc); |
asapersson@webrtc.org | cb79141 | 2014-12-18 14:30:32 +0000 | [diff] [blame] | 550 | rtcp::ReceiverReport rr; |
danilchap | 822a16f | 2016-09-27 09:27:47 -0700 | [diff] [blame] | 551 | rr.SetSenderSsrc(kSenderSsrc); |
| 552 | rr.AddReportBlock(rb1); |
| 553 | rr.AddReportBlock(rb2); |
asapersson@webrtc.org | cb79141 | 2014-12-18 14:30:32 +0000 | [diff] [blame] | 554 | |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 555 | EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_)); |
| 556 | EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _)); |
| 557 | InjectRtcpPacket(rr); |
| 558 | |
asapersson@webrtc.org | cb79141 | 2014-12-18 14:30:32 +0000 | [diff] [blame] | 559 | std::vector<RTCPReportBlock> received_blocks; |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 560 | rtcp_receiver_.StatisticsReceived(&received_blocks); |
asapersson@webrtc.org | cb79141 | 2014-12-18 14:30:32 +0000 | [diff] [blame] | 561 | EXPECT_EQ(2u, received_blocks.size()); |
| 562 | |
| 563 | // Verify that BYE removes the report blocks. |
| 564 | rtcp::Bye bye; |
danilchap | 822a16f | 2016-09-27 09:27:47 -0700 | [diff] [blame] | 565 | bye.SetSenderSsrc(kSenderSsrc); |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 566 | |
| 567 | InjectRtcpPacket(bye); |
| 568 | |
asapersson@webrtc.org | cb79141 | 2014-12-18 14:30:32 +0000 | [diff] [blame] | 569 | received_blocks.clear(); |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 570 | rtcp_receiver_.StatisticsReceived(&received_blocks); |
asapersson@webrtc.org | cb79141 | 2014-12-18 14:30:32 +0000 | [diff] [blame] | 571 | EXPECT_TRUE(received_blocks.empty()); |
| 572 | |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 573 | // Inject packet again. |
| 574 | EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_)); |
| 575 | EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _)); |
| 576 | InjectRtcpPacket(rr); |
| 577 | |
asapersson@webrtc.org | cb79141 | 2014-12-18 14:30:32 +0000 | [diff] [blame] | 578 | received_blocks.clear(); |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 579 | rtcp_receiver_.StatisticsReceived(&received_blocks); |
asapersson@webrtc.org | cb79141 | 2014-12-18 14:30:32 +0000 | [diff] [blame] | 580 | EXPECT_EQ(2u, received_blocks.size()); |
| 581 | } |
| 582 | |
asapersson@webrtc.org | f8723d6 | 2014-08-28 07:35:06 +0000 | [diff] [blame] | 583 | TEST_F(RtcpReceiverTest, InjectPliPacket) { |
asapersson@webrtc.org | f8723d6 | 2014-08-28 07:35:06 +0000 | [diff] [blame] | 584 | rtcp::Pli pli; |
danilchap | 822a16f | 2016-09-27 09:27:47 -0700 | [diff] [blame] | 585 | pli.SetMediaSsrc(kReceiverMainSsrc); |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 586 | |
| 587 | EXPECT_CALL( |
| 588 | packet_type_counter_observer_, |
| 589 | RtcpPacketTypesCounterUpdated( |
| 590 | kReceiverMainSsrc, Field(&RtcpPacketTypeCounter::pli_packets, 1))); |
| 591 | EXPECT_CALL(intra_frame_observer_, |
| 592 | OnReceivedIntraFrameRequest(kReceiverMainSsrc)); |
| 593 | InjectRtcpPacket(pli); |
asapersson@webrtc.org | f8723d6 | 2014-08-28 07:35:06 +0000 | [diff] [blame] | 594 | } |
| 595 | |
| 596 | TEST_F(RtcpReceiverTest, PliPacketNotToUsIgnored) { |
asapersson@webrtc.org | f8723d6 | 2014-08-28 07:35:06 +0000 | [diff] [blame] | 597 | rtcp::Pli pli; |
danilchap | 822a16f | 2016-09-27 09:27:47 -0700 | [diff] [blame] | 598 | pli.SetMediaSsrc(kNotToUsSsrc); |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 599 | |
| 600 | EXPECT_CALL( |
| 601 | packet_type_counter_observer_, |
| 602 | RtcpPacketTypesCounterUpdated( |
| 603 | kReceiverMainSsrc, Field(&RtcpPacketTypeCounter::pli_packets, 0))); |
| 604 | EXPECT_CALL(intra_frame_observer_, OnReceivedIntraFrameRequest(_)).Times(0); |
| 605 | InjectRtcpPacket(pli); |
asapersson@webrtc.org | f8723d6 | 2014-08-28 07:35:06 +0000 | [diff] [blame] | 606 | } |
| 607 | |
| 608 | TEST_F(RtcpReceiverTest, InjectFirPacket) { |
asapersson@webrtc.org | f8723d6 | 2014-08-28 07:35:06 +0000 | [diff] [blame] | 609 | rtcp::Fir fir; |
danilchap | 822a16f | 2016-09-27 09:27:47 -0700 | [diff] [blame] | 610 | fir.AddRequestTo(kReceiverMainSsrc, 13); |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 611 | |
| 612 | EXPECT_CALL( |
| 613 | packet_type_counter_observer_, |
| 614 | RtcpPacketTypesCounterUpdated( |
| 615 | kReceiverMainSsrc, Field(&RtcpPacketTypeCounter::fir_packets, 1))); |
| 616 | EXPECT_CALL(intra_frame_observer_, |
| 617 | OnReceivedIntraFrameRequest(kReceiverMainSsrc)); |
| 618 | InjectRtcpPacket(fir); |
asapersson@webrtc.org | f8723d6 | 2014-08-28 07:35:06 +0000 | [diff] [blame] | 619 | } |
| 620 | |
| 621 | TEST_F(RtcpReceiverTest, FirPacketNotToUsIgnored) { |
asapersson@webrtc.org | f8723d6 | 2014-08-28 07:35:06 +0000 | [diff] [blame] | 622 | rtcp::Fir fir; |
danilchap | 822a16f | 2016-09-27 09:27:47 -0700 | [diff] [blame] | 623 | fir.AddRequestTo(kNotToUsSsrc, 13); |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 624 | |
| 625 | EXPECT_CALL(intra_frame_observer_, OnReceivedIntraFrameRequest(_)).Times(0); |
| 626 | InjectRtcpPacket(fir); |
asapersson@webrtc.org | f8723d6 | 2014-08-28 07:35:06 +0000 | [diff] [blame] | 627 | } |
| 628 | |
Danil Chapovalov | 256e5b2 | 2016-01-15 14:16:24 +0100 | [diff] [blame] | 629 | TEST_F(RtcpReceiverTest, ExtendedReportsPacketWithZeroReportBlocksIgnored) { |
| 630 | rtcp::ExtendedReports xr; |
danilchap | 822a16f | 2016-09-27 09:27:47 -0700 | [diff] [blame] | 631 | xr.SetSenderSsrc(kSenderSsrc); |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 632 | |
| 633 | InjectRtcpPacket(xr); |
asapersson@webrtc.org | 8469f7b | 2013-10-02 13:15:34 +0000 | [diff] [blame] | 634 | } |
| 635 | |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 636 | // VOiP reports are ignored. |
Danil Chapovalov | 256e5b2 | 2016-01-15 14:16:24 +0100 | [diff] [blame] | 637 | TEST_F(RtcpReceiverTest, InjectExtendedReportsVoipPacket) { |
asapersson@webrtc.org | 8469f7b | 2013-10-02 13:15:34 +0000 | [diff] [blame] | 638 | const uint8_t kLossRate = 123; |
asapersson@webrtc.org | e75d78d | 2014-07-29 08:21:50 +0000 | [diff] [blame] | 639 | rtcp::VoipMetric voip_metric; |
danilchap | 822a16f | 2016-09-27 09:27:47 -0700 | [diff] [blame] | 640 | voip_metric.SetMediaSsrc(kReceiverMainSsrc); |
danilchap | 91941ae | 2015-12-15 07:06:36 -0800 | [diff] [blame] | 641 | RTCPVoIPMetric metric; |
| 642 | metric.lossRate = kLossRate; |
danilchap | 822a16f | 2016-09-27 09:27:47 -0700 | [diff] [blame] | 643 | voip_metric.SetVoipMetric(metric); |
Danil Chapovalov | 256e5b2 | 2016-01-15 14:16:24 +0100 | [diff] [blame] | 644 | rtcp::ExtendedReports xr; |
danilchap | 822a16f | 2016-09-27 09:27:47 -0700 | [diff] [blame] | 645 | xr.SetSenderSsrc(kSenderSsrc); |
danilchap | 80ac24d | 2016-10-31 08:40:47 -0700 | [diff] [blame] | 646 | xr.SetVoipMetric(voip_metric); |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 647 | |
| 648 | InjectRtcpPacket(xr); |
asapersson@webrtc.org | 8469f7b | 2013-10-02 13:15:34 +0000 | [diff] [blame] | 649 | } |
| 650 | |
Danil Chapovalov | 256e5b2 | 2016-01-15 14:16:24 +0100 | [diff] [blame] | 651 | TEST_F(RtcpReceiverTest, ExtendedReportsVoipPacketNotToUsIgnored) { |
asapersson@webrtc.org | e75d78d | 2014-07-29 08:21:50 +0000 | [diff] [blame] | 652 | rtcp::VoipMetric voip_metric; |
danilchap | 822a16f | 2016-09-27 09:27:47 -0700 | [diff] [blame] | 653 | voip_metric.SetMediaSsrc(kNotToUsSsrc); |
Danil Chapovalov | 256e5b2 | 2016-01-15 14:16:24 +0100 | [diff] [blame] | 654 | rtcp::ExtendedReports xr; |
danilchap | 822a16f | 2016-09-27 09:27:47 -0700 | [diff] [blame] | 655 | xr.SetSenderSsrc(kSenderSsrc); |
danilchap | 80ac24d | 2016-10-31 08:40:47 -0700 | [diff] [blame] | 656 | xr.SetVoipMetric(voip_metric); |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 657 | |
| 658 | InjectRtcpPacket(xr); |
asapersson@webrtc.org | e75d78d | 2014-07-29 08:21:50 +0000 | [diff] [blame] | 659 | } |
| 660 | |
Danil Chapovalov | 256e5b2 | 2016-01-15 14:16:24 +0100 | [diff] [blame] | 661 | TEST_F(RtcpReceiverTest, InjectExtendedReportsReceiverReferenceTimePacket) { |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 662 | const NtpTime kNtp(0x10203, 0x40506); |
asapersson@webrtc.org | e75d78d | 2014-07-29 08:21:50 +0000 | [diff] [blame] | 663 | rtcp::Rrtr rrtr; |
danilchap | 822a16f | 2016-09-27 09:27:47 -0700 | [diff] [blame] | 664 | rrtr.SetNtp(kNtp); |
Danil Chapovalov | 256e5b2 | 2016-01-15 14:16:24 +0100 | [diff] [blame] | 665 | rtcp::ExtendedReports xr; |
danilchap | 822a16f | 2016-09-27 09:27:47 -0700 | [diff] [blame] | 666 | xr.SetSenderSsrc(kSenderSsrc); |
danilchap | 80ac24d | 2016-10-31 08:40:47 -0700 | [diff] [blame] | 667 | xr.SetRrtr(rrtr); |
asapersson@webrtc.org | e75d78d | 2014-07-29 08:21:50 +0000 | [diff] [blame] | 668 | |
danilchap | 80ac24d | 2016-10-31 08:40:47 -0700 | [diff] [blame] | 669 | ReceiveTimeInfo rrtime; |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 670 | EXPECT_FALSE(rtcp_receiver_.LastReceivedXrReferenceTimeInfo(&rrtime)); |
| 671 | |
| 672 | InjectRtcpPacket(xr); |
| 673 | |
| 674 | EXPECT_TRUE(rtcp_receiver_.LastReceivedXrReferenceTimeInfo(&rrtime)); |
danilchap | 798896a | 2016-09-28 02:54:25 -0700 | [diff] [blame] | 675 | EXPECT_EQ(rrtime.ssrc, kSenderSsrc); |
| 676 | EXPECT_EQ(rrtime.last_rr, CompactNtp(kNtp)); |
| 677 | EXPECT_EQ(0U, rrtime.delay_since_last_rr); |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 678 | |
| 679 | system_clock_.AdvanceTimeMilliseconds(1500); |
| 680 | EXPECT_TRUE(rtcp_receiver_.LastReceivedXrReferenceTimeInfo(&rrtime)); |
danilchap | 798896a | 2016-09-28 02:54:25 -0700 | [diff] [blame] | 681 | EXPECT_NEAR(1500, CompactNtpRttToMs(rrtime.delay_since_last_rr), 1); |
asapersson@webrtc.org | 8469f7b | 2013-10-02 13:15:34 +0000 | [diff] [blame] | 682 | } |
| 683 | |
Danil Chapovalov | 256e5b2 | 2016-01-15 14:16:24 +0100 | [diff] [blame] | 684 | TEST_F(RtcpReceiverTest, ExtendedReportsDlrrPacketNotToUsIgnored) { |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 685 | // Allow calculate rtt using dlrr/rrtr, simulating media receiver side. |
| 686 | rtcp_receiver_.SetRtcpXrRrtrStatus(true); |
asapersson@webrtc.org | 8469f7b | 2013-10-02 13:15:34 +0000 | [diff] [blame] | 687 | |
Danil Chapovalov | 256e5b2 | 2016-01-15 14:16:24 +0100 | [diff] [blame] | 688 | rtcp::ExtendedReports xr; |
danilchap | 822a16f | 2016-09-27 09:27:47 -0700 | [diff] [blame] | 689 | xr.SetSenderSsrc(kSenderSsrc); |
danilchap | 80ac24d | 2016-10-31 08:40:47 -0700 | [diff] [blame] | 690 | xr.AddDlrrItem(ReceiveTimeInfo(kNotToUsSsrc, 0x12345, 0x67890)); |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 691 | |
| 692 | InjectRtcpPacket(xr); |
| 693 | |
| 694 | int64_t rtt_ms = 0; |
| 695 | EXPECT_FALSE(rtcp_receiver_.GetAndResetXrRrRtt(&rtt_ms)); |
asapersson@webrtc.org | 8469f7b | 2013-10-02 13:15:34 +0000 | [diff] [blame] | 696 | } |
| 697 | |
Danil Chapovalov | 256e5b2 | 2016-01-15 14:16:24 +0100 | [diff] [blame] | 698 | TEST_F(RtcpReceiverTest, InjectExtendedReportsDlrrPacketWithSubBlock) { |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 699 | const uint32_t kLastRR = 0x12345; |
| 700 | const uint32_t kDelay = 0x23456; |
| 701 | rtcp_receiver_.SetRtcpXrRrtrStatus(true); |
| 702 | int64_t rtt_ms = 0; |
| 703 | EXPECT_FALSE(rtcp_receiver_.GetAndResetXrRrRtt(&rtt_ms)); |
asapersson@webrtc.org | 8469f7b | 2013-10-02 13:15:34 +0000 | [diff] [blame] | 704 | |
Danil Chapovalov | 256e5b2 | 2016-01-15 14:16:24 +0100 | [diff] [blame] | 705 | rtcp::ExtendedReports xr; |
danilchap | 822a16f | 2016-09-27 09:27:47 -0700 | [diff] [blame] | 706 | xr.SetSenderSsrc(kSenderSsrc); |
danilchap | 80ac24d | 2016-10-31 08:40:47 -0700 | [diff] [blame] | 707 | xr.AddDlrrItem(ReceiveTimeInfo(kReceiverMainSsrc, kLastRR, kDelay)); |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 708 | |
| 709 | InjectRtcpPacket(xr); |
| 710 | |
danilchap | 3795376 | 2017-02-09 11:15:25 -0800 | [diff] [blame] | 711 | uint32_t compact_ntp_now = CompactNtp(system_clock_.CurrentNtpTime()); |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 712 | EXPECT_TRUE(rtcp_receiver_.GetAndResetXrRrRtt(&rtt_ms)); |
| 713 | uint32_t rtt_ntp = compact_ntp_now - kDelay - kLastRR; |
| 714 | EXPECT_NEAR(CompactNtpRttToMs(rtt_ntp), rtt_ms, 1); |
asapersson@webrtc.org | 8469f7b | 2013-10-02 13:15:34 +0000 | [diff] [blame] | 715 | } |
| 716 | |
Danil Chapovalov | 256e5b2 | 2016-01-15 14:16:24 +0100 | [diff] [blame] | 717 | TEST_F(RtcpReceiverTest, InjectExtendedReportsDlrrPacketWithMultipleSubBlocks) { |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 718 | const uint32_t kLastRR = 0x12345; |
| 719 | const uint32_t kDelay = 0x56789; |
| 720 | rtcp_receiver_.SetRtcpXrRrtrStatus(true); |
asapersson@webrtc.org | 8469f7b | 2013-10-02 13:15:34 +0000 | [diff] [blame] | 721 | |
Danil Chapovalov | 256e5b2 | 2016-01-15 14:16:24 +0100 | [diff] [blame] | 722 | rtcp::ExtendedReports xr; |
danilchap | 822a16f | 2016-09-27 09:27:47 -0700 | [diff] [blame] | 723 | xr.SetSenderSsrc(kSenderSsrc); |
danilchap | 80ac24d | 2016-10-31 08:40:47 -0700 | [diff] [blame] | 724 | xr.AddDlrrItem(ReceiveTimeInfo(kReceiverMainSsrc, kLastRR, kDelay)); |
| 725 | xr.AddDlrrItem(ReceiveTimeInfo(kReceiverMainSsrc + 1, 0x12345, 0x67890)); |
| 726 | xr.AddDlrrItem(ReceiveTimeInfo(kReceiverMainSsrc + 2, 0x12345, 0x67890)); |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 727 | |
| 728 | InjectRtcpPacket(xr); |
| 729 | |
danilchap | 3795376 | 2017-02-09 11:15:25 -0800 | [diff] [blame] | 730 | uint32_t compact_ntp_now = CompactNtp(system_clock_.CurrentNtpTime()); |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 731 | int64_t rtt_ms = 0; |
| 732 | EXPECT_TRUE(rtcp_receiver_.GetAndResetXrRrRtt(&rtt_ms)); |
| 733 | uint32_t rtt_ntp = compact_ntp_now - kDelay - kLastRR; |
| 734 | EXPECT_NEAR(CompactNtpRttToMs(rtt_ntp), rtt_ms, 1); |
asapersson@webrtc.org | 8469f7b | 2013-10-02 13:15:34 +0000 | [diff] [blame] | 735 | } |
| 736 | |
Danil Chapovalov | 256e5b2 | 2016-01-15 14:16:24 +0100 | [diff] [blame] | 737 | TEST_F(RtcpReceiverTest, InjectExtendedReportsPacketWithMultipleReportBlocks) { |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 738 | rtcp_receiver_.SetRtcpXrRrtrStatus(true); |
asapersson@webrtc.org | 8469f7b | 2013-10-02 13:15:34 +0000 | [diff] [blame] | 739 | |
asapersson@webrtc.org | e75d78d | 2014-07-29 08:21:50 +0000 | [diff] [blame] | 740 | rtcp::Rrtr rrtr; |
asapersson@webrtc.org | e75d78d | 2014-07-29 08:21:50 +0000 | [diff] [blame] | 741 | rtcp::VoipMetric metric; |
danilchap | 822a16f | 2016-09-27 09:27:47 -0700 | [diff] [blame] | 742 | metric.SetMediaSsrc(kReceiverMainSsrc); |
Danil Chapovalov | 256e5b2 | 2016-01-15 14:16:24 +0100 | [diff] [blame] | 743 | rtcp::ExtendedReports xr; |
danilchap | 822a16f | 2016-09-27 09:27:47 -0700 | [diff] [blame] | 744 | xr.SetSenderSsrc(kSenderSsrc); |
danilchap | 80ac24d | 2016-10-31 08:40:47 -0700 | [diff] [blame] | 745 | xr.SetRrtr(rrtr); |
| 746 | xr.AddDlrrItem(ReceiveTimeInfo(kReceiverMainSsrc, 0x12345, 0x67890)); |
| 747 | xr.SetVoipMetric(metric); |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 748 | |
| 749 | InjectRtcpPacket(xr); |
| 750 | |
danilchap | 80ac24d | 2016-10-31 08:40:47 -0700 | [diff] [blame] | 751 | ReceiveTimeInfo rrtime; |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 752 | EXPECT_TRUE(rtcp_receiver_.LastReceivedXrReferenceTimeInfo(&rrtime)); |
| 753 | int64_t rtt_ms = 0; |
| 754 | EXPECT_TRUE(rtcp_receiver_.GetAndResetXrRrRtt(&rtt_ms)); |
asapersson@webrtc.org | 8469f7b | 2013-10-02 13:15:34 +0000 | [diff] [blame] | 755 | } |
| 756 | |
Danil Chapovalov | 256e5b2 | 2016-01-15 14:16:24 +0100 | [diff] [blame] | 757 | TEST_F(RtcpReceiverTest, InjectExtendedReportsPacketWithUnknownReportBlock) { |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 758 | rtcp_receiver_.SetRtcpXrRrtrStatus(true); |
asapersson@webrtc.org | 3859951 | 2013-11-12 08:08:26 +0000 | [diff] [blame] | 759 | |
asapersson@webrtc.org | e75d78d | 2014-07-29 08:21:50 +0000 | [diff] [blame] | 760 | rtcp::Rrtr rrtr; |
asapersson@webrtc.org | e75d78d | 2014-07-29 08:21:50 +0000 | [diff] [blame] | 761 | rtcp::VoipMetric metric; |
danilchap | 822a16f | 2016-09-27 09:27:47 -0700 | [diff] [blame] | 762 | metric.SetMediaSsrc(kReceiverMainSsrc); |
Danil Chapovalov | 256e5b2 | 2016-01-15 14:16:24 +0100 | [diff] [blame] | 763 | rtcp::ExtendedReports xr; |
danilchap | 822a16f | 2016-09-27 09:27:47 -0700 | [diff] [blame] | 764 | xr.SetSenderSsrc(kSenderSsrc); |
danilchap | 80ac24d | 2016-10-31 08:40:47 -0700 | [diff] [blame] | 765 | xr.SetRrtr(rrtr); |
| 766 | xr.AddDlrrItem(ReceiveTimeInfo(kReceiverMainSsrc, 0x12345, 0x67890)); |
| 767 | xr.SetVoipMetric(metric); |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 768 | |
danilchap | 69e59e6 | 2016-02-17 03:11:42 -0800 | [diff] [blame] | 769 | rtc::Buffer packet = xr.Build(); |
asapersson@webrtc.org | e75d78d | 2014-07-29 08:21:50 +0000 | [diff] [blame] | 770 | // Modify the DLRR block to have an unsupported block type, from 5 to 6. |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 771 | ASSERT_EQ(5, packet.data()[20]); |
| 772 | packet.data()[20] = 6; |
| 773 | InjectRtcpPacket(packet); |
asapersson@webrtc.org | 3859951 | 2013-11-12 08:08:26 +0000 | [diff] [blame] | 774 | |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 775 | // Validate Rrtr was received and processed. |
danilchap | 80ac24d | 2016-10-31 08:40:47 -0700 | [diff] [blame] | 776 | ReceiveTimeInfo rrtime; |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 777 | EXPECT_TRUE(rtcp_receiver_.LastReceivedXrReferenceTimeInfo(&rrtime)); |
| 778 | // Validate Dlrr report wasn't processed. |
| 779 | int64_t rtt_ms = 0; |
| 780 | EXPECT_FALSE(rtcp_receiver_.GetAndResetXrRrRtt(&rtt_ms)); |
asapersson@webrtc.org | 3859951 | 2013-11-12 08:08:26 +0000 | [diff] [blame] | 781 | } |
| 782 | |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 783 | TEST_F(RtcpReceiverTest, TestExtendedReportsRrRttInitiallyFalse) { |
| 784 | rtcp_receiver_.SetRtcpXrRrtrStatus(true); |
| 785 | |
pkasting@chromium.org | 16825b1 | 2015-01-12 21:51:21 +0000 | [diff] [blame] | 786 | int64_t rtt_ms; |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 787 | EXPECT_FALSE(rtcp_receiver_.GetAndResetXrRrRtt(&rtt_ms)); |
asapersson@webrtc.org | 7d6bd22 | 2013-10-31 12:14:34 +0000 | [diff] [blame] | 788 | } |
| 789 | |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 790 | TEST_F(RtcpReceiverTest, RttCalculatedAfterExtendedReportsDlrr) { |
Danil Chapovalov | a094fd1 | 2016-02-22 18:59:36 +0100 | [diff] [blame] | 791 | Random rand(0x0123456789abcdef); |
Danil Chapovalov | c1e55c7 | 2016-03-09 15:14:35 +0100 | [diff] [blame] | 792 | const int64_t kRttMs = rand.Rand(1, 9 * 3600 * 1000); |
| 793 | const uint32_t kDelayNtp = rand.Rand(0, 0x7fffffff); |
| 794 | const int64_t kDelayMs = CompactNtpRttToMs(kDelayNtp); |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 795 | rtcp_receiver_.SetRtcpXrRrtrStatus(true); |
danilchap | 3795376 | 2017-02-09 11:15:25 -0800 | [diff] [blame] | 796 | NtpTime now = system_clock_.CurrentNtpTime(); |
Danil Chapovalov | a094fd1 | 2016-02-22 18:59:36 +0100 | [diff] [blame] | 797 | uint32_t sent_ntp = CompactNtp(now); |
| 798 | system_clock_.AdvanceTimeMilliseconds(kRttMs + kDelayMs); |
| 799 | |
Danil Chapovalov | a094fd1 | 2016-02-22 18:59:36 +0100 | [diff] [blame] | 800 | rtcp::ExtendedReports xr; |
danilchap | 822a16f | 2016-09-27 09:27:47 -0700 | [diff] [blame] | 801 | xr.SetSenderSsrc(kSenderSsrc); |
danilchap | 80ac24d | 2016-10-31 08:40:47 -0700 | [diff] [blame] | 802 | xr.AddDlrrItem(ReceiveTimeInfo(kReceiverMainSsrc, sent_ntp, kDelayNtp)); |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 803 | |
| 804 | InjectRtcpPacket(xr); |
Danil Chapovalov | a094fd1 | 2016-02-22 18:59:36 +0100 | [diff] [blame] | 805 | |
| 806 | int64_t rtt_ms = 0; |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 807 | EXPECT_TRUE(rtcp_receiver_.GetAndResetXrRrRtt(&rtt_ms)); |
Danil Chapovalov | a094fd1 | 2016-02-22 18:59:36 +0100 | [diff] [blame] | 808 | EXPECT_NEAR(kRttMs, rtt_ms, 1); |
| 809 | } |
| 810 | |
Danil Chapovalov | c1e55c7 | 2016-03-09 15:14:35 +0100 | [diff] [blame] | 811 | TEST_F(RtcpReceiverTest, XrDlrrCalculatesNegativeRttAsOne) { |
| 812 | Random rand(0x0123456789abcdef); |
Danil Chapovalov | c1e55c7 | 2016-03-09 15:14:35 +0100 | [diff] [blame] | 813 | const int64_t kRttMs = rand.Rand(-3600 * 1000, -1); |
| 814 | const uint32_t kDelayNtp = rand.Rand(0, 0x7fffffff); |
| 815 | const int64_t kDelayMs = CompactNtpRttToMs(kDelayNtp); |
danilchap | 3795376 | 2017-02-09 11:15:25 -0800 | [diff] [blame] | 816 | NtpTime now = system_clock_.CurrentNtpTime(); |
Danil Chapovalov | c1e55c7 | 2016-03-09 15:14:35 +0100 | [diff] [blame] | 817 | uint32_t sent_ntp = CompactNtp(now); |
| 818 | system_clock_.AdvanceTimeMilliseconds(kRttMs + kDelayMs); |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 819 | rtcp_receiver_.SetRtcpXrRrtrStatus(true); |
Danil Chapovalov | c1e55c7 | 2016-03-09 15:14:35 +0100 | [diff] [blame] | 820 | |
Danil Chapovalov | c1e55c7 | 2016-03-09 15:14:35 +0100 | [diff] [blame] | 821 | rtcp::ExtendedReports xr; |
danilchap | 822a16f | 2016-09-27 09:27:47 -0700 | [diff] [blame] | 822 | xr.SetSenderSsrc(kSenderSsrc); |
danilchap | 80ac24d | 2016-10-31 08:40:47 -0700 | [diff] [blame] | 823 | xr.AddDlrrItem(ReceiveTimeInfo(kReceiverMainSsrc, sent_ntp, kDelayNtp)); |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 824 | |
| 825 | InjectRtcpPacket(xr); |
Danil Chapovalov | c1e55c7 | 2016-03-09 15:14:35 +0100 | [diff] [blame] | 826 | |
| 827 | int64_t rtt_ms = 0; |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 828 | EXPECT_TRUE(rtcp_receiver_.GetAndResetXrRrRtt(&rtt_ms)); |
Danil Chapovalov | c1e55c7 | 2016-03-09 15:14:35 +0100 | [diff] [blame] | 829 | EXPECT_EQ(1, rtt_ms); |
| 830 | } |
| 831 | |
asapersson@webrtc.org | 8469f7b | 2013-10-02 13:15:34 +0000 | [diff] [blame] | 832 | TEST_F(RtcpReceiverTest, LastReceivedXrReferenceTimeInfoInitiallyFalse) { |
danilchap | 80ac24d | 2016-10-31 08:40:47 -0700 | [diff] [blame] | 833 | ReceiveTimeInfo info; |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 834 | EXPECT_FALSE(rtcp_receiver_.LastReceivedXrReferenceTimeInfo(&info)); |
asapersson@webrtc.org | 8469f7b | 2013-10-02 13:15:34 +0000 | [diff] [blame] | 835 | } |
| 836 | |
Danil Chapovalov | 256e5b2 | 2016-01-15 14:16:24 +0100 | [diff] [blame] | 837 | TEST_F(RtcpReceiverTest, GetLastReceivedExtendedReportsReferenceTimeInfo) { |
Danil Chapovalov | fc47ed6 | 2015-12-07 14:46:35 +0100 | [diff] [blame] | 838 | const NtpTime kNtp(0x10203, 0x40506); |
Danil Chapovalov | a094fd1 | 2016-02-22 18:59:36 +0100 | [diff] [blame] | 839 | const uint32_t kNtpMid = CompactNtp(kNtp); |
asapersson@webrtc.org | 8469f7b | 2013-10-02 13:15:34 +0000 | [diff] [blame] | 840 | |
asapersson@webrtc.org | e75d78d | 2014-07-29 08:21:50 +0000 | [diff] [blame] | 841 | rtcp::Rrtr rrtr; |
danilchap | 822a16f | 2016-09-27 09:27:47 -0700 | [diff] [blame] | 842 | rrtr.SetNtp(kNtp); |
Danil Chapovalov | 256e5b2 | 2016-01-15 14:16:24 +0100 | [diff] [blame] | 843 | rtcp::ExtendedReports xr; |
danilchap | 822a16f | 2016-09-27 09:27:47 -0700 | [diff] [blame] | 844 | xr.SetSenderSsrc(kSenderSsrc); |
danilchap | 80ac24d | 2016-10-31 08:40:47 -0700 | [diff] [blame] | 845 | xr.SetRrtr(rrtr); |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 846 | |
| 847 | InjectRtcpPacket(xr); |
asapersson@webrtc.org | 8469f7b | 2013-10-02 13:15:34 +0000 | [diff] [blame] | 848 | |
danilchap | 80ac24d | 2016-10-31 08:40:47 -0700 | [diff] [blame] | 849 | ReceiveTimeInfo info; |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 850 | EXPECT_TRUE(rtcp_receiver_.LastReceivedXrReferenceTimeInfo(&info)); |
danilchap | 798896a | 2016-09-28 02:54:25 -0700 | [diff] [blame] | 851 | EXPECT_EQ(kSenderSsrc, info.ssrc); |
| 852 | EXPECT_EQ(kNtpMid, info.last_rr); |
| 853 | EXPECT_EQ(0U, info.delay_since_last_rr); |
asapersson@webrtc.org | 8469f7b | 2013-10-02 13:15:34 +0000 | [diff] [blame] | 854 | |
| 855 | system_clock_.AdvanceTimeMilliseconds(1000); |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 856 | EXPECT_TRUE(rtcp_receiver_.LastReceivedXrReferenceTimeInfo(&info)); |
danilchap | 798896a | 2016-09-28 02:54:25 -0700 | [diff] [blame] | 857 | EXPECT_EQ(65536U, info.delay_since_last_rr); |
asapersson@webrtc.org | 8469f7b | 2013-10-02 13:15:34 +0000 | [diff] [blame] | 858 | } |
| 859 | |
mflodman@webrtc.org | 2f225ca | 2013-01-09 13:54:43 +0000 | [diff] [blame] | 860 | TEST_F(RtcpReceiverTest, ReceiveReportTimeout) { |
mflodman@webrtc.org | 2f225ca | 2013-01-09 13:54:43 +0000 | [diff] [blame] | 861 | const int64_t kRtcpIntervalMs = 1000; |
asapersson@webrtc.org | e75d78d | 2014-07-29 08:21:50 +0000 | [diff] [blame] | 862 | const uint16_t kSequenceNumber = 1234; |
stefan@webrtc.org | a678a3b | 2013-01-21 07:42:11 +0000 | [diff] [blame] | 863 | system_clock_.AdvanceTimeMilliseconds(3 * kRtcpIntervalMs); |
mflodman@webrtc.org | 2f225ca | 2013-01-09 13:54:43 +0000 | [diff] [blame] | 864 | |
| 865 | // No RR received, shouldn't trigger a timeout. |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 866 | EXPECT_FALSE(rtcp_receiver_.RtcpRrTimeout(kRtcpIntervalMs)); |
| 867 | EXPECT_FALSE(rtcp_receiver_.RtcpRrSequenceNumberTimeout(kRtcpIntervalMs)); |
mflodman@webrtc.org | 2f225ca | 2013-01-09 13:54:43 +0000 | [diff] [blame] | 868 | |
| 869 | // Add a RR and advance the clock just enough to not trigger a timeout. |
asapersson@webrtc.org | e75d78d | 2014-07-29 08:21:50 +0000 | [diff] [blame] | 870 | rtcp::ReportBlock rb1; |
danilchap | 822a16f | 2016-09-27 09:27:47 -0700 | [diff] [blame] | 871 | rb1.SetMediaSsrc(kReceiverMainSsrc); |
| 872 | rb1.SetExtHighestSeqNum(kSequenceNumber); |
asapersson@webrtc.org | e75d78d | 2014-07-29 08:21:50 +0000 | [diff] [blame] | 873 | rtcp::ReceiverReport rr1; |
danilchap | 822a16f | 2016-09-27 09:27:47 -0700 | [diff] [blame] | 874 | rr1.SetSenderSsrc(kSenderSsrc); |
| 875 | rr1.AddReportBlock(rb1); |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 876 | |
| 877 | EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_)); |
| 878 | EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _)); |
| 879 | InjectRtcpPacket(rr1); |
| 880 | |
stefan@webrtc.org | a678a3b | 2013-01-21 07:42:11 +0000 | [diff] [blame] | 881 | system_clock_.AdvanceTimeMilliseconds(3 * kRtcpIntervalMs - 1); |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 882 | EXPECT_FALSE(rtcp_receiver_.RtcpRrTimeout(kRtcpIntervalMs)); |
| 883 | EXPECT_FALSE(rtcp_receiver_.RtcpRrSequenceNumberTimeout(kRtcpIntervalMs)); |
mflodman@webrtc.org | 2f225ca | 2013-01-09 13:54:43 +0000 | [diff] [blame] | 884 | |
| 885 | // Add a RR with the same extended max as the previous RR to trigger a |
| 886 | // sequence number timeout, but not a RR timeout. |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 887 | EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_)); |
| 888 | EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _)); |
| 889 | InjectRtcpPacket(rr1); |
| 890 | |
stefan@webrtc.org | a678a3b | 2013-01-21 07:42:11 +0000 | [diff] [blame] | 891 | system_clock_.AdvanceTimeMilliseconds(2); |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 892 | EXPECT_FALSE(rtcp_receiver_.RtcpRrTimeout(kRtcpIntervalMs)); |
| 893 | EXPECT_TRUE(rtcp_receiver_.RtcpRrSequenceNumberTimeout(kRtcpIntervalMs)); |
mflodman@webrtc.org | 2f225ca | 2013-01-09 13:54:43 +0000 | [diff] [blame] | 894 | |
| 895 | // Advance clock enough to trigger an RR timeout too. |
stefan@webrtc.org | a678a3b | 2013-01-21 07:42:11 +0000 | [diff] [blame] | 896 | system_clock_.AdvanceTimeMilliseconds(3 * kRtcpIntervalMs); |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 897 | EXPECT_TRUE(rtcp_receiver_.RtcpRrTimeout(kRtcpIntervalMs)); |
mflodman@webrtc.org | 2f225ca | 2013-01-09 13:54:43 +0000 | [diff] [blame] | 898 | |
| 899 | // We should only get one timeout even though we still haven't received a new |
| 900 | // RR. |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 901 | EXPECT_FALSE(rtcp_receiver_.RtcpRrTimeout(kRtcpIntervalMs)); |
| 902 | EXPECT_FALSE(rtcp_receiver_.RtcpRrSequenceNumberTimeout(kRtcpIntervalMs)); |
mflodman@webrtc.org | 2f225ca | 2013-01-09 13:54:43 +0000 | [diff] [blame] | 903 | |
| 904 | // Add a new RR with increase sequence number to reset timers. |
asapersson@webrtc.org | e75d78d | 2014-07-29 08:21:50 +0000 | [diff] [blame] | 905 | rtcp::ReportBlock rb2; |
danilchap | 822a16f | 2016-09-27 09:27:47 -0700 | [diff] [blame] | 906 | rb2.SetMediaSsrc(kReceiverMainSsrc); |
| 907 | rb2.SetExtHighestSeqNum(kSequenceNumber + 1); |
asapersson@webrtc.org | e75d78d | 2014-07-29 08:21:50 +0000 | [diff] [blame] | 908 | rtcp::ReceiverReport rr2; |
danilchap | 822a16f | 2016-09-27 09:27:47 -0700 | [diff] [blame] | 909 | rr2.SetSenderSsrc(kSenderSsrc); |
| 910 | rr2.AddReportBlock(rb2); |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 911 | |
| 912 | EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_)); |
| 913 | EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _)); |
| 914 | InjectRtcpPacket(rr2); |
| 915 | |
| 916 | EXPECT_FALSE(rtcp_receiver_.RtcpRrTimeout(kRtcpIntervalMs)); |
| 917 | EXPECT_FALSE(rtcp_receiver_.RtcpRrSequenceNumberTimeout(kRtcpIntervalMs)); |
mflodman@webrtc.org | 2f225ca | 2013-01-09 13:54:43 +0000 | [diff] [blame] | 918 | |
| 919 | // Verify we can get a timeout again once we've received new RR. |
stefan@webrtc.org | a678a3b | 2013-01-21 07:42:11 +0000 | [diff] [blame] | 920 | system_clock_.AdvanceTimeMilliseconds(2 * kRtcpIntervalMs); |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 921 | EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_)); |
| 922 | EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _)); |
| 923 | InjectRtcpPacket(rr2); |
| 924 | |
stefan@webrtc.org | a678a3b | 2013-01-21 07:42:11 +0000 | [diff] [blame] | 925 | system_clock_.AdvanceTimeMilliseconds(kRtcpIntervalMs + 1); |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 926 | EXPECT_FALSE(rtcp_receiver_.RtcpRrTimeout(kRtcpIntervalMs)); |
| 927 | EXPECT_TRUE(rtcp_receiver_.RtcpRrSequenceNumberTimeout(kRtcpIntervalMs)); |
| 928 | |
stefan@webrtc.org | a678a3b | 2013-01-21 07:42:11 +0000 | [diff] [blame] | 929 | system_clock_.AdvanceTimeMilliseconds(2 * kRtcpIntervalMs); |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 930 | EXPECT_TRUE(rtcp_receiver_.RtcpRrTimeout(kRtcpIntervalMs)); |
mflodman@webrtc.org | 2f225ca | 2013-01-09 13:54:43 +0000 | [diff] [blame] | 931 | } |
| 932 | |
hta@webrtc.org | 47059b5 | 2012-05-02 07:46:22 +0000 | [diff] [blame] | 933 | TEST_F(RtcpReceiverTest, TmmbrReceivedWithNoIncomingPacket) { |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 934 | EXPECT_EQ(0u, rtcp_receiver_.TmmbrReceived().size()); |
hta@webrtc.org | 47059b5 | 2012-05-02 07:46:22 +0000 | [diff] [blame] | 935 | } |
| 936 | |
| 937 | TEST_F(RtcpReceiverTest, TmmbrPacketAccepted) { |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 938 | const uint32_t kBitrateBps = 30000; |
asapersson@webrtc.org | e75d78d | 2014-07-29 08:21:50 +0000 | [diff] [blame] | 939 | rtcp::Tmmbr tmmbr; |
danilchap | 822a16f | 2016-09-27 09:27:47 -0700 | [diff] [blame] | 940 | tmmbr.SetSenderSsrc(kSenderSsrc); |
| 941 | tmmbr.AddTmmbr(rtcp::TmmbItem(kReceiverMainSsrc, kBitrateBps, 0)); |
asapersson@webrtc.org | e75d78d | 2014-07-29 08:21:50 +0000 | [diff] [blame] | 942 | rtcp::SenderReport sr; |
danilchap | 822a16f | 2016-09-27 09:27:47 -0700 | [diff] [blame] | 943 | sr.SetSenderSsrc(kSenderSsrc); |
danilchap | 7a4116a | 2016-03-14 08:19:28 -0700 | [diff] [blame] | 944 | rtcp::CompoundPacket compound; |
| 945 | compound.Append(&sr); |
| 946 | compound.Append(&tmmbr); |
asapersson@webrtc.org | e75d78d | 2014-07-29 08:21:50 +0000 | [diff] [blame] | 947 | |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 948 | EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_)); |
| 949 | EXPECT_CALL(rtp_rtcp_impl_, SetTmmbn(SizeIs(1))); |
| 950 | EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _)); |
| 951 | EXPECT_CALL(bandwidth_observer_, OnReceivedEstimatedBitrate(kBitrateBps)); |
| 952 | InjectRtcpPacket(compound); |
| 953 | |
| 954 | std::vector<rtcp::TmmbItem> tmmbr_received = rtcp_receiver_.TmmbrReceived(); |
| 955 | ASSERT_EQ(1u, tmmbr_received.size()); |
| 956 | EXPECT_EQ(kBitrateBps, tmmbr_received[0].bitrate_bps()); |
| 957 | EXPECT_EQ(kSenderSsrc, tmmbr_received[0].ssrc()); |
hta@webrtc.org | 47059b5 | 2012-05-02 07:46:22 +0000 | [diff] [blame] | 958 | } |
| 959 | |
| 960 | TEST_F(RtcpReceiverTest, TmmbrPacketNotForUsIgnored) { |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 961 | const uint32_t kBitrateBps = 30000; |
asapersson@webrtc.org | e75d78d | 2014-07-29 08:21:50 +0000 | [diff] [blame] | 962 | rtcp::Tmmbr tmmbr; |
danilchap | 822a16f | 2016-09-27 09:27:47 -0700 | [diff] [blame] | 963 | tmmbr.SetSenderSsrc(kSenderSsrc); |
| 964 | tmmbr.AddTmmbr(rtcp::TmmbItem(kNotToUsSsrc, kBitrateBps, 0)); |
asapersson@webrtc.org | e75d78d | 2014-07-29 08:21:50 +0000 | [diff] [blame] | 965 | |
| 966 | rtcp::SenderReport sr; |
danilchap | 822a16f | 2016-09-27 09:27:47 -0700 | [diff] [blame] | 967 | sr.SetSenderSsrc(kSenderSsrc); |
danilchap | 7a4116a | 2016-03-14 08:19:28 -0700 | [diff] [blame] | 968 | rtcp::CompoundPacket compound; |
| 969 | compound.Append(&sr); |
| 970 | compound.Append(&tmmbr); |
hta@webrtc.org | 404843e | 2012-05-02 09:56:45 +0000 | [diff] [blame] | 971 | |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 972 | EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_)); |
| 973 | EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _)); |
| 974 | EXPECT_CALL(bandwidth_observer_, OnReceivedEstimatedBitrate(_)).Times(0); |
| 975 | InjectRtcpPacket(compound); |
| 976 | |
| 977 | EXPECT_EQ(0u, rtcp_receiver_.TmmbrReceived().size()); |
hta@webrtc.org | 47059b5 | 2012-05-02 07:46:22 +0000 | [diff] [blame] | 978 | } |
| 979 | |
| 980 | TEST_F(RtcpReceiverTest, TmmbrPacketZeroRateIgnored) { |
asapersson@webrtc.org | e75d78d | 2014-07-29 08:21:50 +0000 | [diff] [blame] | 981 | rtcp::Tmmbr tmmbr; |
danilchap | 822a16f | 2016-09-27 09:27:47 -0700 | [diff] [blame] | 982 | tmmbr.SetSenderSsrc(kSenderSsrc); |
| 983 | tmmbr.AddTmmbr(rtcp::TmmbItem(kReceiverMainSsrc, 0, 0)); |
asapersson@webrtc.org | e75d78d | 2014-07-29 08:21:50 +0000 | [diff] [blame] | 984 | rtcp::SenderReport sr; |
danilchap | 822a16f | 2016-09-27 09:27:47 -0700 | [diff] [blame] | 985 | sr.SetSenderSsrc(kSenderSsrc); |
danilchap | 7a4116a | 2016-03-14 08:19:28 -0700 | [diff] [blame] | 986 | rtcp::CompoundPacket compound; |
| 987 | compound.Append(&sr); |
| 988 | compound.Append(&tmmbr); |
asapersson@webrtc.org | e75d78d | 2014-07-29 08:21:50 +0000 | [diff] [blame] | 989 | |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 990 | EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_)); |
| 991 | EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _)); |
| 992 | EXPECT_CALL(bandwidth_observer_, OnReceivedEstimatedBitrate(_)).Times(0); |
| 993 | InjectRtcpPacket(compound); |
| 994 | |
| 995 | EXPECT_EQ(0u, rtcp_receiver_.TmmbrReceived().size()); |
hta@webrtc.org | 47059b5 | 2012-05-02 07:46:22 +0000 | [diff] [blame] | 996 | } |
| 997 | |
hta@webrtc.org | 404843e | 2012-05-02 09:56:45 +0000 | [diff] [blame] | 998 | TEST_F(RtcpReceiverTest, TmmbrThreeConstraintsTimeOut) { |
asapersson@webrtc.org | e75d78d | 2014-07-29 08:21:50 +0000 | [diff] [blame] | 999 | // Inject 3 packets "from" kSenderSsrc, kSenderSsrc+1, kSenderSsrc+2. |
hta@webrtc.org | 404843e | 2012-05-02 09:56:45 +0000 | [diff] [blame] | 1000 | // The times of arrival are starttime + 0, starttime + 5 and starttime + 10. |
asapersson@webrtc.org | e75d78d | 2014-07-29 08:21:50 +0000 | [diff] [blame] | 1001 | for (uint32_t ssrc = kSenderSsrc; ssrc < kSenderSsrc + 3; ++ssrc) { |
| 1002 | rtcp::Tmmbr tmmbr; |
danilchap | 822a16f | 2016-09-27 09:27:47 -0700 | [diff] [blame] | 1003 | tmmbr.SetSenderSsrc(ssrc); |
| 1004 | tmmbr.AddTmmbr(rtcp::TmmbItem(kReceiverMainSsrc, 30000, 0)); |
asapersson@webrtc.org | e75d78d | 2014-07-29 08:21:50 +0000 | [diff] [blame] | 1005 | rtcp::SenderReport sr; |
danilchap | 822a16f | 2016-09-27 09:27:47 -0700 | [diff] [blame] | 1006 | sr.SetSenderSsrc(ssrc); |
danilchap | 7a4116a | 2016-03-14 08:19:28 -0700 | [diff] [blame] | 1007 | rtcp::CompoundPacket compound; |
| 1008 | compound.Append(&sr); |
| 1009 | compound.Append(&tmmbr); |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 1010 | |
| 1011 | EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_)); |
| 1012 | EXPECT_CALL(rtp_rtcp_impl_, SetTmmbn(_)); |
| 1013 | EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _)); |
| 1014 | EXPECT_CALL(bandwidth_observer_, OnReceivedEstimatedBitrate(_)); |
| 1015 | InjectRtcpPacket(compound); |
| 1016 | |
stefan@webrtc.org | a678a3b | 2013-01-21 07:42:11 +0000 | [diff] [blame] | 1017 | // 5 seconds between each packet. |
| 1018 | system_clock_.AdvanceTimeMilliseconds(5000); |
hta@webrtc.org | 404843e | 2012-05-02 09:56:45 +0000 | [diff] [blame] | 1019 | } |
asapersson@webrtc.org | e75d78d | 2014-07-29 08:21:50 +0000 | [diff] [blame] | 1020 | // It is now starttime + 15. |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 1021 | std::vector<rtcp::TmmbItem> candidate_set = rtcp_receiver_.TmmbrReceived(); |
| 1022 | ASSERT_EQ(3u, candidate_set.size()); |
| 1023 | EXPECT_EQ(30000U, candidate_set[0].bitrate_bps()); |
| 1024 | |
hta@webrtc.org | 404843e | 2012-05-02 09:56:45 +0000 | [diff] [blame] | 1025 | // We expect the timeout to be 25 seconds. Advance the clock by 12 |
| 1026 | // seconds, timing out the first packet. |
stefan@webrtc.org | a678a3b | 2013-01-21 07:42:11 +0000 | [diff] [blame] | 1027 | system_clock_.AdvanceTimeMilliseconds(12000); |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 1028 | candidate_set = rtcp_receiver_.TmmbrReceived(); |
| 1029 | ASSERT_EQ(2u, candidate_set.size()); |
danilchap | 287e548 | 2016-08-16 15:15:39 -0700 | [diff] [blame] | 1030 | EXPECT_EQ(kSenderSsrc + 1, candidate_set[0].ssrc()); |
hta@webrtc.org | 404843e | 2012-05-02 09:56:45 +0000 | [diff] [blame] | 1031 | } |
| 1032 | |
sprang@webrtc.org | a6ad6e5 | 2013-12-05 09:48:44 +0000 | [diff] [blame] | 1033 | TEST_F(RtcpReceiverTest, Callbacks) { |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 1034 | MockRtcpCallbackImpl callback; |
| 1035 | rtcp_receiver_.RegisterRtcpStatisticsCallback(&callback); |
sprang@webrtc.org | a6ad6e5 | 2013-12-05 09:48:44 +0000 | [diff] [blame] | 1036 | |
asapersson@webrtc.org | e75d78d | 2014-07-29 08:21:50 +0000 | [diff] [blame] | 1037 | const uint8_t kFractionLoss = 3; |
| 1038 | const uint32_t kCumulativeLoss = 7; |
| 1039 | const uint32_t kJitter = 9; |
| 1040 | const uint16_t kSequenceNumber = 1234; |
sprang@webrtc.org | a6ad6e5 | 2013-12-05 09:48:44 +0000 | [diff] [blame] | 1041 | |
asapersson@webrtc.org | e75d78d | 2014-07-29 08:21:50 +0000 | [diff] [blame] | 1042 | // First packet, all numbers should just propagate. |
| 1043 | rtcp::ReportBlock rb1; |
danilchap | 822a16f | 2016-09-27 09:27:47 -0700 | [diff] [blame] | 1044 | rb1.SetMediaSsrc(kReceiverMainSsrc); |
| 1045 | rb1.SetExtHighestSeqNum(kSequenceNumber); |
| 1046 | rb1.SetFractionLost(kFractionLoss); |
| 1047 | rb1.SetCumulativeLost(kCumulativeLoss); |
| 1048 | rb1.SetJitter(kJitter); |
asapersson@webrtc.org | e75d78d | 2014-07-29 08:21:50 +0000 | [diff] [blame] | 1049 | |
| 1050 | rtcp::ReceiverReport rr1; |
danilchap | 822a16f | 2016-09-27 09:27:47 -0700 | [diff] [blame] | 1051 | rr1.SetSenderSsrc(kSenderSsrc); |
| 1052 | rr1.AddReportBlock(rb1); |
srte | 186d9c3 | 2017-08-04 05:03:53 -0700 | [diff] [blame] | 1053 | EXPECT_CALL(callback, |
| 1054 | StatisticsUpdated( |
| 1055 | AllOf(Field(&RtcpStatistics::fraction_lost, kFractionLoss), |
| 1056 | Field(&RtcpStatistics::packets_lost, kCumulativeLoss), |
| 1057 | Field(&RtcpStatistics::extended_highest_sequence_number, |
| 1058 | kSequenceNumber), |
| 1059 | Field(&RtcpStatistics::jitter, kJitter)), |
| 1060 | kReceiverMainSsrc)); |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 1061 | EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_)); |
| 1062 | EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _)); |
| 1063 | InjectRtcpPacket(rr1); |
sprang@webrtc.org | a6ad6e5 | 2013-12-05 09:48:44 +0000 | [diff] [blame] | 1064 | |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 1065 | rtcp_receiver_.RegisterRtcpStatisticsCallback(nullptr); |
sprang@webrtc.org | a6ad6e5 | 2013-12-05 09:48:44 +0000 | [diff] [blame] | 1066 | |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 1067 | // Add arbitrary numbers, callback should not be called. |
asapersson@webrtc.org | e75d78d | 2014-07-29 08:21:50 +0000 | [diff] [blame] | 1068 | rtcp::ReportBlock rb2; |
danilchap | 822a16f | 2016-09-27 09:27:47 -0700 | [diff] [blame] | 1069 | rb2.SetMediaSsrc(kReceiverMainSsrc); |
| 1070 | rb2.SetExtHighestSeqNum(kSequenceNumber + 1); |
| 1071 | rb2.SetFractionLost(42); |
| 1072 | rb2.SetCumulativeLost(137); |
| 1073 | rb2.SetJitter(4711); |
asapersson@webrtc.org | e75d78d | 2014-07-29 08:21:50 +0000 | [diff] [blame] | 1074 | |
| 1075 | rtcp::ReceiverReport rr2; |
danilchap | 822a16f | 2016-09-27 09:27:47 -0700 | [diff] [blame] | 1076 | rr2.SetSenderSsrc(kSenderSsrc); |
| 1077 | rr2.AddReportBlock(rb2); |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 1078 | |
| 1079 | EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_)); |
| 1080 | EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _)); |
| 1081 | EXPECT_CALL(callback, StatisticsUpdated(_, _)).Times(0); |
| 1082 | InjectRtcpPacket(rr2); |
sprang@webrtc.org | a6ad6e5 | 2013-12-05 09:48:44 +0000 | [diff] [blame] | 1083 | } |
hta@webrtc.org | 404843e | 2012-05-02 09:56:45 +0000 | [diff] [blame] | 1084 | |
sprang | 49f9cdb | 2015-10-01 03:06:57 -0700 | [diff] [blame] | 1085 | TEST_F(RtcpReceiverTest, ReceivesTransportFeedback) { |
sprang | 49f9cdb | 2015-10-01 03:06:57 -0700 | [diff] [blame] | 1086 | rtcp::TransportFeedback packet; |
danilchap | 822a16f | 2016-09-27 09:27:47 -0700 | [diff] [blame] | 1087 | packet.SetMediaSsrc(kReceiverMainSsrc); |
| 1088 | packet.SetSenderSsrc(kSenderSsrc); |
| 1089 | packet.SetBase(1, 1000); |
| 1090 | packet.AddReceivedPacket(1, 1000); |
sprang | 49f9cdb | 2015-10-01 03:06:57 -0700 | [diff] [blame] | 1091 | |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 1092 | EXPECT_CALL( |
| 1093 | transport_feedback_observer_, |
| 1094 | OnTransportFeedback(AllOf( |
| 1095 | Property(&rtcp::TransportFeedback::media_ssrc, kReceiverMainSsrc), |
| 1096 | Property(&rtcp::TransportFeedback::sender_ssrc, kSenderSsrc)))); |
| 1097 | InjectRtcpPacket(packet); |
sprang | 49f9cdb | 2015-10-01 03:06:57 -0700 | [diff] [blame] | 1098 | } |
| 1099 | |
Danil Chapovalov | ee6e427 | 2016-04-19 12:15:10 +0200 | [diff] [blame] | 1100 | TEST_F(RtcpReceiverTest, ReceivesRemb) { |
Danil Chapovalov | ee6e427 | 2016-04-19 12:15:10 +0200 | [diff] [blame] | 1101 | const uint32_t kBitrateBps = 500000; |
| 1102 | rtcp::Remb remb; |
danilchap | 822a16f | 2016-09-27 09:27:47 -0700 | [diff] [blame] | 1103 | remb.SetSenderSsrc(kSenderSsrc); |
| 1104 | remb.SetBitrateBps(kBitrateBps); |
Danil Chapovalov | ee6e427 | 2016-04-19 12:15:10 +0200 | [diff] [blame] | 1105 | |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 1106 | EXPECT_CALL(bandwidth_observer_, OnReceivedEstimatedBitrate(kBitrateBps)); |
| 1107 | InjectRtcpPacket(remb); |
Danil Chapovalov | ee6e427 | 2016-04-19 12:15:10 +0200 | [diff] [blame] | 1108 | } |
| 1109 | |
sprang | 49f9cdb | 2015-10-01 03:06:57 -0700 | [diff] [blame] | 1110 | TEST_F(RtcpReceiverTest, HandlesInvalidTransportFeedback) { |
sprang | 49f9cdb | 2015-10-01 03:06:57 -0700 | [diff] [blame] | 1111 | // Send a compound packet with a TransportFeedback followed by something else. |
| 1112 | rtcp::TransportFeedback packet; |
danilchap | 822a16f | 2016-09-27 09:27:47 -0700 | [diff] [blame] | 1113 | packet.SetMediaSsrc(kReceiverMainSsrc); |
| 1114 | packet.SetSenderSsrc(kSenderSsrc); |
| 1115 | packet.SetBase(1, 1000); |
| 1116 | packet.AddReceivedPacket(1, 1000); |
sprang | 49f9cdb | 2015-10-01 03:06:57 -0700 | [diff] [blame] | 1117 | |
| 1118 | static uint32_t kBitrateBps = 50000; |
| 1119 | rtcp::Remb remb; |
danilchap | 822a16f | 2016-09-27 09:27:47 -0700 | [diff] [blame] | 1120 | remb.SetSenderSsrc(kSenderSsrc); |
| 1121 | remb.SetBitrateBps(kBitrateBps); |
danilchap | 7a4116a | 2016-03-14 08:19:28 -0700 | [diff] [blame] | 1122 | rtcp::CompoundPacket compound; |
| 1123 | compound.Append(&packet); |
| 1124 | compound.Append(&remb); |
| 1125 | rtc::Buffer built_packet = compound.Build(); |
sprang | 49f9cdb | 2015-10-01 03:06:57 -0700 | [diff] [blame] | 1126 | |
| 1127 | // Modify the TransportFeedback packet so that it is invalid. |
| 1128 | const size_t kStatusCountOffset = 14; |
| 1129 | ByteWriter<uint16_t>::WriteBigEndian( |
danilchap | 69e59e6 | 2016-02-17 03:11:42 -0800 | [diff] [blame] | 1130 | &built_packet.data()[kStatusCountOffset], 42); |
sprang | 49f9cdb | 2015-10-01 03:06:57 -0700 | [diff] [blame] | 1131 | |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 1132 | // Stress no transport feedback is expected. |
| 1133 | EXPECT_CALL(transport_feedback_observer_, OnTransportFeedback(_)).Times(0); |
| 1134 | // But remb should be processed and cause a callback |
| 1135 | EXPECT_CALL(bandwidth_observer_, OnReceivedEstimatedBitrate(kBitrateBps)); |
| 1136 | InjectRtcpPacket(built_packet); |
sprang | 49f9cdb | 2015-10-01 03:06:57 -0700 | [diff] [blame] | 1137 | } |
| 1138 | |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 1139 | TEST_F(RtcpReceiverTest, Nack) { |
| 1140 | const uint16_t kNackList1[] = {1, 2, 3, 5}; |
danilchap | 142f019 | 2016-10-20 08:22:42 -0700 | [diff] [blame] | 1141 | const uint16_t kNackList23[] = {5, 7, 30, 40, 41, 58, 59, 61, 63}; |
| 1142 | const size_t kNackListLength2 = 4; |
| 1143 | const size_t kNackListLength3 = arraysize(kNackList23) - kNackListLength2; |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 1144 | std::set<uint16_t> nack_set; |
| 1145 | nack_set.insert(std::begin(kNackList1), std::end(kNackList1)); |
danilchap | 142f019 | 2016-10-20 08:22:42 -0700 | [diff] [blame] | 1146 | nack_set.insert(std::begin(kNackList23), std::end(kNackList23)); |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 1147 | |
danilchap | 142f019 | 2016-10-20 08:22:42 -0700 | [diff] [blame] | 1148 | rtcp::Nack nack1; |
| 1149 | nack1.SetSenderSsrc(kSenderSsrc); |
| 1150 | nack1.SetMediaSsrc(kReceiverMainSsrc); |
| 1151 | nack1.SetPacketIds(kNackList1, arraysize(kNackList1)); |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 1152 | |
| 1153 | EXPECT_CALL(rtp_rtcp_impl_, OnReceivedNack(ElementsAreArray(kNackList1))); |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 1154 | EXPECT_CALL(packet_type_counter_observer_, |
| 1155 | RtcpPacketTypesCounterUpdated( |
| 1156 | kReceiverMainSsrc, |
| 1157 | AllOf(Field(&RtcpPacketTypeCounter::nack_requests, |
danilchap | 142f019 | 2016-10-20 08:22:42 -0700 | [diff] [blame] | 1158 | arraysize(kNackList1)), |
| 1159 | Field(&RtcpPacketTypeCounter::unique_nack_requests, |
| 1160 | arraysize(kNackList1))))); |
| 1161 | InjectRtcpPacket(nack1); |
| 1162 | |
| 1163 | rtcp::Nack nack2; |
| 1164 | nack2.SetSenderSsrc(kSenderSsrc); |
| 1165 | nack2.SetMediaSsrc(kReceiverMainSsrc); |
| 1166 | nack2.SetPacketIds(kNackList23, kNackListLength2); |
| 1167 | |
| 1168 | rtcp::Nack nack3; |
| 1169 | nack3.SetSenderSsrc(kSenderSsrc); |
| 1170 | nack3.SetMediaSsrc(kReceiverMainSsrc); |
| 1171 | nack3.SetPacketIds(kNackList23 + kNackListLength2, kNackListLength3); |
| 1172 | |
| 1173 | rtcp::CompoundPacket two_nacks; |
| 1174 | two_nacks.Append(&nack2); |
| 1175 | two_nacks.Append(&nack3); |
| 1176 | |
| 1177 | EXPECT_CALL(rtp_rtcp_impl_, OnReceivedNack(ElementsAreArray(kNackList23))); |
| 1178 | EXPECT_CALL(packet_type_counter_observer_, |
| 1179 | RtcpPacketTypesCounterUpdated( |
| 1180 | kReceiverMainSsrc, |
| 1181 | AllOf(Field(&RtcpPacketTypeCounter::nack_requests, |
| 1182 | arraysize(kNackList1) + arraysize(kNackList23)), |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 1183 | Field(&RtcpPacketTypeCounter::unique_nack_requests, |
| 1184 | nack_set.size())))); |
danilchap | 142f019 | 2016-10-20 08:22:42 -0700 | [diff] [blame] | 1185 | InjectRtcpPacket(two_nacks); |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 1186 | } |
| 1187 | |
| 1188 | TEST_F(RtcpReceiverTest, NackNotForUsIgnored) { |
| 1189 | const uint16_t kNackList1[] = {1, 2, 3, 5}; |
| 1190 | const size_t kNackListLength1 = std::end(kNackList1) - std::begin(kNackList1); |
| 1191 | |
| 1192 | rtcp::Nack nack; |
danilchap | 822a16f | 2016-09-27 09:27:47 -0700 | [diff] [blame] | 1193 | nack.SetSenderSsrc(kSenderSsrc); |
| 1194 | nack.SetMediaSsrc(kNotToUsSsrc); |
| 1195 | nack.SetPacketIds(kNackList1, kNackListLength1); |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 1196 | |
| 1197 | EXPECT_CALL(packet_type_counter_observer_, |
| 1198 | RtcpPacketTypesCounterUpdated( |
| 1199 | _, Field(&RtcpPacketTypeCounter::nack_requests, 0))); |
| 1200 | InjectRtcpPacket(nack); |
| 1201 | } |
| 1202 | |
| 1203 | TEST_F(RtcpReceiverTest, ForceSenderReport) { |
| 1204 | rtcp::RapidResyncRequest rr; |
danilchap | 822a16f | 2016-09-27 09:27:47 -0700 | [diff] [blame] | 1205 | rr.SetSenderSsrc(kSenderSsrc); |
| 1206 | rr.SetMediaSsrc(kReceiverMainSsrc); |
danilchap | 1e714ae | 2016-09-05 09:57:22 -0700 | [diff] [blame] | 1207 | |
| 1208 | EXPECT_CALL(rtp_rtcp_impl_, OnRequestSendReport()); |
| 1209 | InjectRtcpPacket(rr); |
| 1210 | } |
hta@webrtc.org | 47059b5 | 2012-05-02 07:46:22 +0000 | [diff] [blame] | 1211 | |
sprang | a790d83 | 2016-12-02 07:29:44 -0800 | [diff] [blame] | 1212 | TEST_F(RtcpReceiverTest, ReceivesTargetBitrate) { |
| 1213 | BitrateAllocation expected_allocation; |
| 1214 | expected_allocation.SetBitrate(0, 0, 10000); |
| 1215 | expected_allocation.SetBitrate(0, 1, 20000); |
| 1216 | expected_allocation.SetBitrate(1, 0, 40000); |
| 1217 | expected_allocation.SetBitrate(1, 1, 80000); |
| 1218 | |
| 1219 | rtcp::TargetBitrate bitrate; |
| 1220 | bitrate.AddTargetBitrate(0, 0, expected_allocation.GetBitrate(0, 0) / 1000); |
| 1221 | bitrate.AddTargetBitrate(0, 1, expected_allocation.GetBitrate(0, 1) / 1000); |
| 1222 | bitrate.AddTargetBitrate(1, 0, expected_allocation.GetBitrate(1, 0) / 1000); |
| 1223 | bitrate.AddTargetBitrate(1, 1, expected_allocation.GetBitrate(1, 1) / 1000); |
| 1224 | |
| 1225 | rtcp::ExtendedReports xr; |
| 1226 | xr.SetTargetBitrate(bitrate); |
| 1227 | |
sprang | b32aaf9 | 2017-08-28 05:49:12 -0700 | [diff] [blame] | 1228 | // Wrong sender ssrc, target bitrate should be discarded. |
| 1229 | xr.SetSenderSsrc(kSenderSsrc + 1); |
| 1230 | EXPECT_CALL(bitrate_allocation_observer_, |
| 1231 | OnBitrateAllocationUpdated(expected_allocation)) |
| 1232 | .Times(0); |
| 1233 | InjectRtcpPacket(xr); |
| 1234 | |
| 1235 | // Set correct ssrc, callback should be called once. |
| 1236 | xr.SetSenderSsrc(kSenderSsrc); |
sprang | a790d83 | 2016-12-02 07:29:44 -0800 | [diff] [blame] | 1237 | EXPECT_CALL(bitrate_allocation_observer_, |
| 1238 | OnBitrateAllocationUpdated(expected_allocation)); |
| 1239 | InjectRtcpPacket(xr); |
| 1240 | } |
| 1241 | |
sprang | 6d314c7 | 2016-12-06 06:08:53 -0800 | [diff] [blame] | 1242 | TEST_F(RtcpReceiverTest, HandlesIncorrectTargetBitrate) { |
| 1243 | BitrateAllocation expected_allocation; |
| 1244 | expected_allocation.SetBitrate(0, 0, 10000); |
| 1245 | |
| 1246 | rtcp::TargetBitrate bitrate; |
| 1247 | bitrate.AddTargetBitrate(0, 0, expected_allocation.GetBitrate(0, 0) / 1000); |
| 1248 | bitrate.AddTargetBitrate(0, kMaxTemporalStreams, 20000); |
| 1249 | bitrate.AddTargetBitrate(kMaxSpatialLayers, 0, 40000); |
| 1250 | |
| 1251 | rtcp::ExtendedReports xr; |
| 1252 | xr.SetTargetBitrate(bitrate); |
sprang | b32aaf9 | 2017-08-28 05:49:12 -0700 | [diff] [blame] | 1253 | xr.SetSenderSsrc(kSenderSsrc); |
sprang | 6d314c7 | 2016-12-06 06:08:53 -0800 | [diff] [blame] | 1254 | |
| 1255 | EXPECT_CALL(bitrate_allocation_observer_, |
| 1256 | OnBitrateAllocationUpdated(expected_allocation)); |
| 1257 | InjectRtcpPacket(xr); |
| 1258 | } |
| 1259 | |
hta@webrtc.org | 47059b5 | 2012-05-02 07:46:22 +0000 | [diff] [blame] | 1260 | } // namespace webrtc |