OLD | NEW |
1 /* | 1 /* |
2 * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. | 2 * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. |
3 * | 3 * |
4 * Use of this source code is governed by a BSD-style license | 4 * Use of this source code is governed by a BSD-style license |
5 * that can be found in the LICENSE file in the root of the source | 5 * that can be found in the LICENSE file in the root of the source |
6 * tree. An additional intellectual property rights grant can be found | 6 * tree. An additional intellectual property rights grant can be found |
7 * in the file PATENTS. All contributing project authors may | 7 * in the file PATENTS. All contributing project authors may |
8 * be found in the AUTHORS file in the root of the source tree. | 8 * be found in the AUTHORS file in the root of the source tree. |
9 */ | 9 */ |
10 | 10 |
11 | 11 |
12 /* | 12 /* |
13 * This file includes unit tests for the RTCPReceiver. | 13 * This file includes unit tests for the RTCPReceiver. |
14 */ | 14 */ |
15 #include "testing/gmock/include/gmock/gmock.h" | 15 #include "testing/gmock/include/gmock/gmock.h" |
16 #include "testing/gtest/include/gtest/gtest.h" | 16 #include "testing/gtest/include/gtest/gtest.h" |
17 | 17 |
18 #include "webrtc/common_types.h" | 18 #include "webrtc/common_types.h" |
19 #include "webrtc/modules/remote_bitrate_estimator/include/mock/mock_remote_bitra
te_observer.h" | 19 #include "webrtc/modules/remote_bitrate_estimator/include/mock/mock_remote_bitra
te_estimator.h" |
20 #include "webrtc/modules/remote_bitrate_estimator/remote_bitrate_estimator_singl
e_stream.h" | 20 #include "webrtc/modules/rtp_rtcp/mocks/mock_rtcp_observers.h" |
21 #include "webrtc/modules/rtp_rtcp/source/byte_io.h" | 21 #include "webrtc/modules/rtp_rtcp/source/byte_io.h" |
22 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet.h" | 22 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet.h" |
23 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/app.h" | 23 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/app.h" |
24 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/bye.h" | 24 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/bye.h" |
25 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_jitter_report.h" | 25 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_jitter_report.h" |
26 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_reports.h" | 26 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_reports.h" |
27 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/fir.h" | 27 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/fir.h" |
| 28 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/nack.h" |
28 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/pli.h" | 29 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/pli.h" |
29 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/receiver_report.h" | 30 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/receiver_report.h" |
30 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/remb.h" | 31 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/remb.h" |
| 32 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/rpsi.h" |
31 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/sdes.h" | 33 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/sdes.h" |
32 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/sender_report.h" | 34 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/sender_report.h" |
33 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/sli.h" | 35 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/sli.h" |
34 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/tmmbr.h" | 36 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/tmmbr.h" |
35 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h" | 37 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h" |
36 #include "webrtc/modules/rtp_rtcp/source/rtcp_receiver.h" | 38 #include "webrtc/modules/rtp_rtcp/source/rtcp_receiver.h" |
37 #include "webrtc/modules/rtp_rtcp/source/rtcp_sender.h" | |
38 #include "webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.h" | 39 #include "webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.h" |
39 #include "webrtc/modules/rtp_rtcp/source/time_util.h" | 40 #include "webrtc/modules/rtp_rtcp/source/time_util.h" |
40 #include "webrtc/system_wrappers/include/ntp_time.h" | 41 #include "webrtc/system_wrappers/include/ntp_time.h" |
| 42 #include "webrtc/test/mock_transport.h" |
| 43 |
| 44 using testing::_; |
| 45 using testing::AllOf; |
| 46 using testing::Field; |
| 47 using testing::IsEmpty; |
| 48 using testing::NiceMock; |
| 49 using testing::Property; |
| 50 using testing::SizeIs; |
| 51 using testing::StrEq; |
| 52 using testing::StrictMock; |
| 53 using testing::UnorderedElementsAre; |
41 | 54 |
42 namespace webrtc { | 55 namespace webrtc { |
43 | 56 |
44 namespace { // Anonymous namespace; hide utility functions and classes. | |
45 | |
46 // This test transport verifies that no functions get called. | |
47 class TestTransport : public Transport, | |
48 public NullRtpData { | |
49 public: | |
50 explicit TestTransport() : rtcp_receiver_(nullptr) {} | |
51 void SetRTCPReceiver(RTCPReceiver* rtcp_receiver) { | |
52 rtcp_receiver_ = rtcp_receiver; | |
53 } | |
54 bool SendRtp(const uint8_t* /*data*/, | |
55 size_t /*len*/, | |
56 const PacketOptions& options) override { | |
57 ADD_FAILURE(); // FAIL() gives a compile error. | |
58 return false; | |
59 } | |
60 | |
61 bool SendRtcp(const uint8_t* packet, size_t packet_len) override { | |
62 ADD_FAILURE(); | |
63 return true; | |
64 } | |
65 | |
66 int OnReceivedPayloadData(const uint8_t* payloadData, | |
67 const size_t payloadSize, | |
68 const WebRtcRTPHeader* rtpHeader) override { | |
69 ADD_FAILURE(); | |
70 return 0; | |
71 } | |
72 RTCPReceiver* rtcp_receiver_; | |
73 }; | |
74 | |
75 class RtcpReceiverTest : public ::testing::Test { | 57 class RtcpReceiverTest : public ::testing::Test { |
76 protected: | 58 protected: |
77 RtcpReceiverTest() | 59 RtcpReceiverTest() : system_clock_(1335900000) { |
78 : over_use_detector_options_(), | |
79 system_clock_(1335900000), | |
80 remote_bitrate_observer_(), | |
81 remote_bitrate_estimator_( | |
82 new RemoteBitrateEstimatorSingleStream(&remote_bitrate_observer_, | |
83 &system_clock_)) { | |
84 test_transport_ = new TestTransport(); | |
85 | |
86 RtpRtcp::Configuration configuration; | 60 RtpRtcp::Configuration configuration; |
87 configuration.audio = false; | 61 configuration.audio = false; |
88 configuration.clock = &system_clock_; | 62 configuration.clock = &system_clock_; |
89 configuration.outgoing_transport = test_transport_; | 63 configuration.outgoing_transport = &transport_; |
90 configuration.remote_bitrate_estimator = remote_bitrate_estimator_.get(); | 64 configuration.remote_bitrate_estimator = &remote_bitrate_estimator_; |
91 rtp_rtcp_impl_ = new ModuleRtpRtcpImpl(configuration); | 65 rtp_rtcp_impl_.reset(new ModuleRtpRtcpImpl(configuration)); |
92 rtcp_receiver_ = new RTCPReceiver(&system_clock_, false, nullptr, nullptr, | 66 rtcp_receiver_.reset( |
93 nullptr, nullptr, rtp_rtcp_impl_); | 67 new RTCPReceiver(&system_clock_, false, &packet_type_counter_observer_, |
94 test_transport_->SetRTCPReceiver(rtcp_receiver_); | 68 &bandwidth_observer_, &intra_frame_observer_, |
95 } | 69 &transport_feedback_observer_, rtp_rtcp_impl_.get())); |
96 ~RtcpReceiverTest() { | |
97 delete rtcp_receiver_; | |
98 delete rtp_rtcp_impl_; | |
99 delete test_transport_; | |
100 } | 70 } |
101 | 71 |
102 // Injects an RTCP packet into the receiver. | 72 void InjectPacket(const rtcp::RtcpPacket& packet) { |
103 // Returns 0 for OK, non-0 for failure. | 73 rtc::Buffer raw = packet.Build(); |
104 int InjectRtcpPacket(const uint8_t* packet, | 74 EXPECT_TRUE(rtcp_receiver_->IncomingPacket(raw.data(), raw.size())); |
105 uint16_t packet_len) { | |
106 RTCPUtility::RTCPParserV2 rtcpParser(packet, | |
107 packet_len, | |
108 true); // Allow non-compound RTCP | |
109 | |
110 RTCPHelp::RTCPPacketInformation rtcpPacketInformation; | |
111 EXPECT_EQ(0, rtcp_receiver_->IncomingRTCPPacket(rtcpPacketInformation, | |
112 &rtcpParser)); | |
113 rtcp_receiver_->TriggerCallbacksFromRTCPPacket(rtcpPacketInformation); | |
114 // The NACK list is on purpose not copied below as it isn't needed by the | |
115 // test. | |
116 rtcp_packet_info_.rtcpPacketTypeFlags = | |
117 rtcpPacketInformation.rtcpPacketTypeFlags; | |
118 rtcp_packet_info_.remoteSSRC = rtcpPacketInformation.remoteSSRC; | |
119 rtcp_packet_info_.applicationSubType = | |
120 rtcpPacketInformation.applicationSubType; | |
121 rtcp_packet_info_.applicationName = rtcpPacketInformation.applicationName; | |
122 rtcp_packet_info_.applicationLength = | |
123 rtcpPacketInformation.applicationLength; | |
124 rtcp_packet_info_.report_blocks = rtcpPacketInformation.report_blocks; | |
125 rtcp_packet_info_.rtt = rtcpPacketInformation.rtt; | |
126 rtcp_packet_info_.interArrivalJitter = | |
127 rtcpPacketInformation.interArrivalJitter; | |
128 rtcp_packet_info_.sliPictureId = rtcpPacketInformation.sliPictureId; | |
129 rtcp_packet_info_.rpsiPictureId = rtcpPacketInformation.rpsiPictureId; | |
130 rtcp_packet_info_.receiverEstimatedMaxBitrate = | |
131 rtcpPacketInformation.receiverEstimatedMaxBitrate; | |
132 rtcp_packet_info_.ntp_secs = rtcpPacketInformation.ntp_secs; | |
133 rtcp_packet_info_.ntp_frac = rtcpPacketInformation.ntp_frac; | |
134 rtcp_packet_info_.rtp_timestamp = rtcpPacketInformation.rtp_timestamp; | |
135 rtcp_packet_info_.xr_dlrr_item = rtcpPacketInformation.xr_dlrr_item; | |
136 if (rtcpPacketInformation.VoIPMetric) | |
137 rtcp_packet_info_.AddVoIPMetric(rtcpPacketInformation.VoIPMetric); | |
138 rtcp_packet_info_.transport_feedback_.reset( | |
139 rtcpPacketInformation.transport_feedback_.release()); | |
140 return 0; | |
141 } | 75 } |
142 | 76 |
143 OverUseDetectorOptions over_use_detector_options_; | 77 void SetSsrc(uint32_t ssrc) { |
| 78 std::set<uint32_t> ssrcs; |
| 79 ssrcs.insert(ssrc); |
| 80 EXPECT_CALL(intra_frame_observer_, OnLocalSsrcChanged(0, ssrc)); |
| 81 rtcp_receiver_->SetSsrcs(ssrc, ssrcs); |
| 82 } |
| 83 |
| 84 template <typename Container> |
| 85 void SetSsrcs(const Container& c) { |
| 86 std::set<uint32_t> ssrcs(std::begin(c), std::end(c)); |
| 87 ASSERT_FALSE(ssrcs.empty()); |
| 88 uint32_t main_ssrc = *std::begin(c); |
| 89 EXPECT_CALL(intra_frame_observer_, OnLocalSsrcChanged(0, main_ssrc)); |
| 90 rtcp_receiver_->SetSsrcs(main_ssrc, ssrcs); |
| 91 } |
| 92 |
144 SimulatedClock system_clock_; | 93 SimulatedClock system_clock_; |
145 ModuleRtpRtcpImpl* rtp_rtcp_impl_; | 94 |
146 RTCPReceiver* rtcp_receiver_; | 95 StrictMock<MockTransport> transport_; |
147 TestTransport* test_transport_; | 96 StrictMock<MockRemoteBitrateEstimator> remote_bitrate_estimator_; |
148 RTCPHelp::RTCPPacketInformation rtcp_packet_info_; | 97 rtc::scoped_ptr<ModuleRtpRtcpImpl> rtp_rtcp_impl_; |
149 MockRemoteBitrateObserver remote_bitrate_observer_; | 98 |
150 rtc::scoped_ptr<RemoteBitrateEstimator> remote_bitrate_estimator_; | 99 // Callbacks to packet_type_counter_observer are frequent but most of the time |
| 100 // are not interesting. |
| 101 NiceMock<MockRtcpPacketTypeCounterObserver> packet_type_counter_observer_; |
| 102 StrictMock<MockRtcpBandwidthObserver> bandwidth_observer_; |
| 103 StrictMock<MockRtcpIntraFrameObserver> intra_frame_observer_; |
| 104 StrictMock<MockTransportFeedbackObserver> transport_feedback_observer_; |
| 105 rtc::scoped_ptr<RTCPReceiver> rtcp_receiver_; |
151 }; | 106 }; |
152 | 107 |
153 | |
154 TEST_F(RtcpReceiverTest, BrokenPacketIsIgnored) { | 108 TEST_F(RtcpReceiverTest, BrokenPacketIsIgnored) { |
155 const uint8_t bad_packet[] = {0, 0, 0, 0}; | 109 const uint8_t bad_packet[] = {0, 0, 0, 0}; |
156 EXPECT_EQ(0, InjectRtcpPacket(bad_packet, sizeof(bad_packet))); | 110 int64_t now = system_clock_.TimeInMilliseconds(); |
157 EXPECT_EQ(0U, rtcp_packet_info_.rtcpPacketTypeFlags); | 111 EXPECT_CALL(packet_type_counter_observer_, |
| 112 RtcpPacketTypesCounterUpdated(_, _)) |
| 113 .Times(0); |
| 114 EXPECT_FALSE(rtcp_receiver_->IncomingPacket(bad_packet, sizeof(bad_packet))); |
| 115 EXPECT_NE(now, rtcp_receiver_->LastReceived()); |
158 } | 116 } |
159 | 117 |
160 TEST_F(RtcpReceiverTest, InjectSrPacket) { | 118 TEST_F(RtcpReceiverTest, InjectSrPacket) { |
161 const uint32_t kSenderSsrc = 0x10203; | 119 const uint32_t kSenderSsrc = 0x10203; |
| 120 int64_t now = system_clock_.TimeInMilliseconds(); |
162 rtcp::SenderReport sr; | 121 rtcp::SenderReport sr; |
163 sr.From(kSenderSsrc); | 122 sr.From(kSenderSsrc); |
164 rtc::Buffer packet = sr.Build(); | 123 EXPECT_CALL(bandwidth_observer_, |
165 EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size())); | 124 OnReceivedRtcpReceiverReport(IsEmpty(), _, now)); |
| 125 InjectPacket(sr); |
| 126 // The packet should be processed. |
| 127 EXPECT_EQ(now, rtcp_receiver_->LastReceived()); |
166 // The parser will note the remote SSRC on a SR from other than his | 128 // The parser will note the remote SSRC on a SR from other than his |
167 // expected peer, but will not flag that he's gotten a packet. | 129 // expected peer, but will not flag that he's gotten a packet. |
168 EXPECT_EQ(kSenderSsrc, rtcp_packet_info_.remoteSSRC); | 130 RTCPSenderInfo info; |
169 EXPECT_EQ(0U, kRtcpSr & rtcp_packet_info_.rtcpPacketTypeFlags); | 131 EXPECT_EQ(-1, rtcp_receiver_->SenderInfoReceived(&info)); |
170 } | 132 } |
171 | 133 |
172 TEST_F(RtcpReceiverTest, InjectSrPacketFromExpectedPeer) { | 134 TEST_F(RtcpReceiverTest, InjectSrPacketFromExpectedPeer) { |
173 const uint32_t kSenderSsrc = 0x10203; | 135 const uint32_t kSenderSsrc = 0x10203; |
| 136 int64_t now = system_clock_.TimeInMilliseconds(); |
| 137 |
| 138 RTCPSenderInfo info; |
174 rtcp_receiver_->SetRemoteSSRC(kSenderSsrc); | 139 rtcp_receiver_->SetRemoteSSRC(kSenderSsrc); |
175 rtcp::SenderReport sr; | 140 rtcp::SenderReport sr; |
176 sr.From(kSenderSsrc); | 141 sr.From(kSenderSsrc); |
177 rtc::Buffer packet = sr.Build(); | 142 |
178 EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size())); | 143 EXPECT_EQ(-1, rtcp_receiver_->SenderInfoReceived(&info)); |
179 EXPECT_EQ(kSenderSsrc, rtcp_packet_info_.remoteSSRC); | 144 EXPECT_CALL(bandwidth_observer_, |
180 EXPECT_EQ(kRtcpSr, rtcp_packet_info_.rtcpPacketTypeFlags); | 145 OnReceivedRtcpReceiverReport(IsEmpty(), _, now)); |
| 146 InjectPacket(sr); |
| 147 EXPECT_EQ(now, rtcp_receiver_->LastReceived()); |
| 148 EXPECT_EQ(0, rtcp_receiver_->SenderInfoReceived(&info)); |
181 } | 149 } |
182 | 150 |
183 TEST_F(RtcpReceiverTest, InjectSrPacketCalculatesRTT) { | 151 TEST_F(RtcpReceiverTest, InjectSrPacketCalculatesRTT) { |
184 Random r(0x0123456789abcdef); | 152 Random r(0x0123456789abcdef); |
185 const uint32_t kSenderSsrc = r.Rand(0x00000001u, 0xfffffffeu); | 153 const uint32_t kSenderSsrc = r.Rand(0x00000001u, 0xfffffffeu); |
186 const uint32_t kRemoteSsrc = r.Rand(0x00000001u, 0xfffffffeu); | 154 const uint32_t kRemoteSsrc = r.Rand(0x00000001u, 0xfffffffeu); |
187 const int64_t kRttMs = r.Rand(1, 18 * 3600 * 1000); | 155 const int64_t kRttMs = r.Rand(1, 18 * 3600 * 1000); |
188 const uint32_t kDelayNtp = r.Rand<uint32_t>(); | 156 const uint32_t kDelayNtp = r.Rand<uint32_t>(); |
189 const uint32_t kDelayMs = CompactNtpIntervalToMs(kDelayNtp); | 157 const uint32_t kDelayMs = CompactNtpIntervalToMs(kDelayNtp); |
190 | 158 |
191 rtcp_receiver_->SetRemoteSSRC(kSenderSsrc); | 159 rtcp_receiver_->SetRemoteSSRC(kSenderSsrc); |
192 std::set<uint32_t> ssrcs; | 160 SetSsrc(kRemoteSsrc); |
193 ssrcs.insert(kRemoteSsrc); | |
194 rtcp_receiver_->SetSsrcs(kRemoteSsrc, ssrcs); | |
195 | 161 |
196 int64_t rtt_ms = 0; | 162 int64_t rtt_ms = 0; |
197 EXPECT_EQ( | 163 EXPECT_EQ( |
198 -1, rtcp_receiver_->RTT(kSenderSsrc, &rtt_ms, nullptr, nullptr, nullptr)); | 164 -1, rtcp_receiver_->RTT(kSenderSsrc, &rtt_ms, nullptr, nullptr, nullptr)); |
199 | 165 |
200 uint32_t sent_ntp = CompactNtp(NtpTime(system_clock_)); | 166 uint32_t sent_ntp = CompactNtp(NtpTime(system_clock_)); |
201 system_clock_.AdvanceTimeMilliseconds(kRttMs + kDelayMs); | 167 system_clock_.AdvanceTimeMilliseconds(kRttMs + kDelayMs); |
202 | 168 |
203 rtcp::SenderReport sr; | 169 rtcp::SenderReport sr; |
204 sr.From(kSenderSsrc); | 170 sr.From(kSenderSsrc); |
205 rtcp::ReportBlock block; | 171 rtcp::ReportBlock block; |
206 block.To(kRemoteSsrc); | 172 block.To(kRemoteSsrc); |
207 block.WithLastSr(sent_ntp); | 173 block.WithLastSr(sent_ntp); |
208 block.WithDelayLastSr(kDelayNtp); | 174 block.WithDelayLastSr(kDelayNtp); |
209 sr.WithReportBlock(block); | 175 sr.WithReportBlock(block); |
210 | 176 |
211 rtc::Buffer packet = sr.Build(); | 177 EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _)); |
212 EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size())); | 178 InjectPacket(sr); |
213 | 179 |
214 EXPECT_EQ( | 180 EXPECT_EQ( |
215 0, rtcp_receiver_->RTT(kSenderSsrc, &rtt_ms, nullptr, nullptr, nullptr)); | 181 0, rtcp_receiver_->RTT(kSenderSsrc, &rtt_ms, nullptr, nullptr, nullptr)); |
216 EXPECT_NEAR(kRttMs, rtt_ms, 1); | 182 EXPECT_NEAR(kRttMs, rtt_ms, 1); |
217 } | 183 } |
218 | 184 |
219 TEST_F(RtcpReceiverTest, InjectRrPacket) { | 185 TEST_F(RtcpReceiverTest, InjectRrPacket) { |
220 const uint32_t kSenderSsrc = 0x10203; | 186 const uint32_t kSenderSsrc = 0x10203; |
| 187 int64_t now = system_clock_.TimeInMilliseconds(); |
| 188 |
221 rtcp::ReceiverReport rr; | 189 rtcp::ReceiverReport rr; |
222 rr.From(kSenderSsrc); | 190 rr.From(kSenderSsrc); |
223 rtc::Buffer packet = rr.Build(); | 191 EXPECT_CALL(bandwidth_observer_, |
224 EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size())); | 192 OnReceivedRtcpReceiverReport(IsEmpty(), _, now)); |
225 EXPECT_EQ(kSenderSsrc, rtcp_packet_info_.remoteSSRC); | 193 InjectPacket(rr); |
226 EXPECT_EQ(kRtcpRr, rtcp_packet_info_.rtcpPacketTypeFlags); | 194 EXPECT_EQ(now, rtcp_receiver_->LastReceived()); |
227 ASSERT_EQ(0u, rtcp_packet_info_.report_blocks.size()); | 195 RTCPSenderInfo info; |
| 196 EXPECT_EQ(-1, rtcp_receiver_->SenderInfoReceived(&info)); |
| 197 EXPECT_EQ(now, rtcp_receiver_->LastReceivedReceiverReport()); |
| 198 std::vector<RTCPReportBlock> report_blocks; |
| 199 rtcp_receiver_->StatisticsReceived(&report_blocks); |
| 200 EXPECT_TRUE(report_blocks.empty()); |
228 } | 201 } |
229 | 202 |
230 TEST_F(RtcpReceiverTest, InjectRrPacketWithReportBlockNotToUsIgnored) { | 203 TEST_F(RtcpReceiverTest, InjectRrPacketWithReportBlockNotToUsIgnored) { |
231 const uint32_t kSenderSsrc = 0x10203; | 204 const uint32_t kSenderSsrc = 0x10203; |
232 const uint32_t kSourceSsrc = 0x123456; | 205 const uint32_t kSourceSsrc = 0x123456; |
233 std::set<uint32_t> ssrcs; | 206 int64_t now = system_clock_.TimeInMilliseconds(); |
234 ssrcs.insert(kSourceSsrc); | 207 SetSsrc(kSourceSsrc); |
235 rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs); | |
236 | |
237 rtcp::ReportBlock rb; | 208 rtcp::ReportBlock rb; |
238 rb.To(kSourceSsrc + 1); | 209 rb.To(kSourceSsrc + 1); |
239 rtcp::ReceiverReport rr; | 210 rtcp::ReceiverReport rr; |
240 rr.From(kSenderSsrc); | 211 rr.From(kSenderSsrc); |
241 rr.WithReportBlock(rb); | 212 rr.WithReportBlock(rb); |
242 rtc::Buffer packet = rr.Build(); | 213 EXPECT_CALL(bandwidth_observer_, |
243 EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size())); | 214 OnReceivedRtcpReceiverReport(IsEmpty(), _, now)); |
244 EXPECT_EQ(kSenderSsrc, rtcp_packet_info_.remoteSSRC); | 215 InjectPacket(rr); |
245 EXPECT_EQ(kRtcpRr, rtcp_packet_info_.rtcpPacketTypeFlags); | 216 EXPECT_EQ(now, rtcp_receiver_->LastReceivedReceiverReport()); |
246 ASSERT_EQ(0u, rtcp_packet_info_.report_blocks.size()); | |
247 | 217 |
248 std::vector<RTCPReportBlock> received_blocks; | 218 std::vector<RTCPReportBlock> received_blocks; |
249 rtcp_receiver_->StatisticsReceived(&received_blocks); | 219 rtcp_receiver_->StatisticsReceived(&received_blocks); |
250 EXPECT_TRUE(received_blocks.empty()); | 220 EXPECT_TRUE(received_blocks.empty()); |
251 } | 221 } |
252 | 222 |
253 TEST_F(RtcpReceiverTest, InjectRrPacketWithOneReportBlock) { | 223 TEST_F(RtcpReceiverTest, InjectRrPacketWithOneReportBlock) { |
254 const uint32_t kSenderSsrc = 0x10203; | 224 const uint32_t kSenderSsrc = 0x10203; |
255 const uint32_t kSourceSsrc = 0x123456; | 225 const uint32_t kSourceSsrc = 0x123456; |
256 std::set<uint32_t> ssrcs; | 226 int64_t now = system_clock_.TimeInMilliseconds(); |
257 ssrcs.insert(kSourceSsrc); | 227 SetSsrc(kSourceSsrc); |
258 rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs); | |
259 | 228 |
260 rtcp::ReportBlock rb; | 229 rtcp::ReportBlock rb; |
261 rb.To(kSourceSsrc); | 230 rb.To(kSourceSsrc); |
262 rtcp::ReceiverReport rr; | 231 rtcp::ReceiverReport rr; |
263 rr.From(kSenderSsrc); | 232 rr.From(kSenderSsrc); |
264 rr.WithReportBlock(rb); | 233 rr.WithReportBlock(rb); |
265 rtc::Buffer packet = rr.Build(); | 234 EXPECT_CALL(bandwidth_observer_, |
266 EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size())); | 235 OnReceivedRtcpReceiverReport(SizeIs(1), _, now)); |
267 EXPECT_EQ(kSenderSsrc, rtcp_packet_info_.remoteSSRC); | 236 InjectPacket(rr); |
268 EXPECT_EQ(kRtcpRr, rtcp_packet_info_.rtcpPacketTypeFlags); | 237 EXPECT_EQ(now, rtcp_receiver_->LastReceivedReceiverReport()); |
269 ASSERT_EQ(1u, rtcp_packet_info_.report_blocks.size()); | |
270 | 238 |
271 std::vector<RTCPReportBlock> received_blocks; | 239 std::vector<RTCPReportBlock> received_blocks; |
272 rtcp_receiver_->StatisticsReceived(&received_blocks); | 240 rtcp_receiver_->StatisticsReceived(&received_blocks); |
273 EXPECT_EQ(1u, received_blocks.size()); | 241 EXPECT_EQ(1u, received_blocks.size()); |
274 } | 242 } |
275 | 243 |
276 TEST_F(RtcpReceiverTest, InjectRrPacketWithTwoReportBlocks) { | 244 TEST_F(RtcpReceiverTest, InjectRrPacketWithTwoReportBlocks) { |
277 const uint32_t kSenderSsrc = 0x10203; | 245 const uint32_t kSenderSsrc = 0x10203; |
278 const uint32_t kSourceSsrcs[] = {0x40506, 0x50607}; | 246 const uint32_t kSourceSsrcs[] = {0x40506, 0x50607}; |
279 const uint16_t kSequenceNumbers[] = {10, 12423}; | 247 const uint16_t kSequenceNumbers[] = {10, 12423}; |
280 const uint32_t kCumLost[] = {13, 555}; | 248 const uint32_t kCumLost[] = {13, 555}; |
281 const uint8_t kFracLost[] = {20, 11}; | 249 const uint8_t kFracLost[] = {20, 11}; |
282 const int kNumSsrcs = sizeof(kSourceSsrcs) / sizeof(kSourceSsrcs[0]); | 250 int64_t now = system_clock_.TimeInMilliseconds(); |
283 | 251 |
284 std::set<uint32_t> ssrcs(kSourceSsrcs, kSourceSsrcs + kNumSsrcs); | 252 SetSsrcs(kSourceSsrcs); |
285 rtcp_receiver_->SetSsrcs(kSourceSsrcs[0], ssrcs); | |
286 | 253 |
287 rtcp::ReportBlock rb1; | 254 rtcp::ReportBlock rb1; |
288 rb1.To(kSourceSsrcs[0]); | 255 rb1.To(kSourceSsrcs[0]); |
289 rb1.WithExtHighestSeqNum(kSequenceNumbers[0]); | 256 rb1.WithExtHighestSeqNum(kSequenceNumbers[0]); |
290 rb1.WithFractionLost(10); | 257 rb1.WithFractionLost(10); |
291 rb1.WithCumulativeLost(5); | 258 rb1.WithCumulativeLost(5); |
292 | 259 |
293 rtcp::ReportBlock rb2; | 260 rtcp::ReportBlock rb2; |
294 rb2.To(kSourceSsrcs[1]); | 261 rb2.To(kSourceSsrcs[1]); |
295 rb2.WithExtHighestSeqNum(kSequenceNumbers[1]); | 262 rb2.WithExtHighestSeqNum(kSequenceNumbers[1]); |
296 | 263 |
297 rtcp::ReceiverReport rr1; | 264 rtcp::ReceiverReport rr1; |
298 rr1.From(kSenderSsrc); | 265 rr1.From(kSenderSsrc); |
299 rr1.WithReportBlock(rb1); | 266 rr1.WithReportBlock(rb1); |
300 rr1.WithReportBlock(rb2); | 267 rr1.WithReportBlock(rb2); |
301 | 268 |
302 rtc::Buffer p1 = rr1.Build(); | 269 EXPECT_CALL(bandwidth_observer_, |
303 EXPECT_EQ(0, InjectRtcpPacket(p1.data(), p1.size())); | 270 OnReceivedRtcpReceiverReport(SizeIs(2), _, now)); |
304 ASSERT_EQ(2u, rtcp_packet_info_.report_blocks.size()); | 271 |
305 EXPECT_EQ(10, rtcp_packet_info_.report_blocks.front().fractionLost); | 272 InjectPacket(rr1); |
306 EXPECT_EQ(0, rtcp_packet_info_.report_blocks.back().fractionLost); | 273 EXPECT_EQ(now, rtcp_receiver_->LastReceivedReceiverReport()); |
| 274 |
| 275 std::vector<RTCPReportBlock> received_blocks; |
| 276 rtcp_receiver_->StatisticsReceived(&received_blocks); |
| 277 |
| 278 ASSERT_EQ(2u, received_blocks.size()); |
| 279 { |
| 280 int fraction_losts[2] = {received_blocks[0].fractionLost, |
| 281 received_blocks[1].fractionLost}; |
| 282 EXPECT_THAT(fraction_losts, UnorderedElementsAre(0, 10)); |
| 283 } |
307 | 284 |
308 rtcp::ReportBlock rb3; | 285 rtcp::ReportBlock rb3; |
309 rb3.To(kSourceSsrcs[0]); | 286 rb3.To(kSourceSsrcs[0]); |
310 rb3.WithExtHighestSeqNum(kSequenceNumbers[0]); | 287 rb3.WithExtHighestSeqNum(kSequenceNumbers[0]); |
311 rb3.WithFractionLost(kFracLost[0]); | 288 rb3.WithFractionLost(kFracLost[0]); |
312 rb3.WithCumulativeLost(kCumLost[0]); | 289 rb3.WithCumulativeLost(kCumLost[0]); |
313 | 290 |
314 rtcp::ReportBlock rb4; | 291 rtcp::ReportBlock rb4; |
315 rb4.To(kSourceSsrcs[1]); | 292 rb4.To(kSourceSsrcs[1]); |
316 rb4.WithExtHighestSeqNum(kSequenceNumbers[1]); | 293 rb4.WithExtHighestSeqNum(kSequenceNumbers[1]); |
317 rb4.WithFractionLost(kFracLost[1]); | 294 rb4.WithFractionLost(kFracLost[1]); |
318 rb4.WithCumulativeLost(kCumLost[1]); | 295 rb4.WithCumulativeLost(kCumLost[1]); |
319 | 296 |
320 rtcp::ReceiverReport rr2; | 297 rtcp::ReceiverReport rr2; |
321 rr2.From(kSenderSsrc); | 298 rr2.From(kSenderSsrc); |
322 rr2.WithReportBlock(rb3); | 299 rr2.WithReportBlock(rb3); |
323 rr2.WithReportBlock(rb4); | 300 rr2.WithReportBlock(rb4); |
324 | 301 |
325 rtc::Buffer p2 = rr2.Build(); | 302 system_clock_.AdvanceTimeMilliseconds(500); |
326 EXPECT_EQ(0, InjectRtcpPacket(p2.data(), p2.size())); | 303 now = system_clock_.TimeInMilliseconds(); |
327 ASSERT_EQ(2u, rtcp_packet_info_.report_blocks.size()); | 304 EXPECT_CALL(bandwidth_observer_, |
328 EXPECT_EQ(kFracLost[0], rtcp_packet_info_.report_blocks.front().fractionLost); | 305 OnReceivedRtcpReceiverReport(SizeIs(2), _, now)); |
329 EXPECT_EQ(kFracLost[1], rtcp_packet_info_.report_blocks.back().fractionLost); | 306 InjectPacket(rr2); |
330 | 307 |
331 std::vector<RTCPReportBlock> received_blocks; | 308 received_blocks.clear(); |
332 rtcp_receiver_->StatisticsReceived(&received_blocks); | 309 rtcp_receiver_->StatisticsReceived(&received_blocks); |
333 EXPECT_EQ(2u, received_blocks.size()); | 310 EXPECT_EQ(2u, received_blocks.size()); |
334 for (size_t i = 0; i < received_blocks.size(); ++i) { | 311 EXPECT_THAT(received_blocks, |
335 EXPECT_EQ(kSenderSsrc, received_blocks[i].remoteSSRC); | 312 UnorderedElementsAre( |
336 EXPECT_EQ(kSourceSsrcs[i], received_blocks[i].sourceSSRC); | 313 AllOf(Field(&RTCPReportBlock::sourceSSRC, kSourceSsrcs[0]), |
337 EXPECT_EQ(kFracLost[i], received_blocks[i].fractionLost); | 314 Field(&RTCPReportBlock::fractionLost, kFracLost[0]), |
338 EXPECT_EQ(kCumLost[i], received_blocks[i].cumulativeLost); | 315 Field(&RTCPReportBlock::cumulativeLost, kCumLost[0]), |
339 EXPECT_EQ(kSequenceNumbers[i], received_blocks[i].extendedHighSeqNum); | 316 Field(&RTCPReportBlock::extendedHighSeqNum, |
340 } | 317 kSequenceNumbers[0])), |
| 318 AllOf(Field(&RTCPReportBlock::sourceSSRC, kSourceSsrcs[1]), |
| 319 Field(&RTCPReportBlock::fractionLost, kFracLost[1]), |
| 320 Field(&RTCPReportBlock::cumulativeLost, kCumLost[1]), |
| 321 Field(&RTCPReportBlock::extendedHighSeqNum, |
| 322 kSequenceNumbers[1])))); |
341 } | 323 } |
342 | 324 |
343 TEST_F(RtcpReceiverTest, InjectRrPacketsFromTwoRemoteSsrcs) { | 325 TEST_F(RtcpReceiverTest, InjectRrPacketsFromTwoRemoteSsrcs) { |
344 const uint32_t kSenderSsrc1 = 0x10203; | 326 const uint32_t kSenderSsrc[] = {0x10203, 0x20304}; |
345 const uint32_t kSenderSsrc2 = 0x20304; | |
346 const uint32_t kSourceSsrcs[] = {0x40506, 0x50607}; | 327 const uint32_t kSourceSsrcs[] = {0x40506, 0x50607}; |
347 const uint16_t kSequenceNumbers[] = {10, 12423}; | 328 const uint16_t kSequenceNumbers[] = {10, 12423}; |
348 const uint32_t kCumLost[] = {13, 555}; | 329 const uint32_t kCumLost[] = {13, 555}; |
349 const uint8_t kFracLost[] = {20, 11}; | 330 const uint8_t kFracLost[] = {20, 11}; |
350 const int kNumSsrcs = sizeof(kSourceSsrcs) / sizeof(kSourceSsrcs[0]); | |
351 | 331 |
352 std::set<uint32_t> ssrcs(kSourceSsrcs, kSourceSsrcs + kNumSsrcs); | 332 SetSsrcs(kSourceSsrcs); |
353 rtcp_receiver_->SetSsrcs(kSourceSsrcs[0], ssrcs); | |
354 | 333 |
355 rtcp::ReportBlock rb1; | 334 rtcp::ReportBlock rb1; |
356 rb1.To(kSourceSsrcs[0]); | 335 rb1.To(kSourceSsrcs[0]); |
357 rb1.WithExtHighestSeqNum(kSequenceNumbers[0]); | 336 rb1.WithExtHighestSeqNum(kSequenceNumbers[0]); |
358 rb1.WithFractionLost(kFracLost[0]); | 337 rb1.WithFractionLost(kFracLost[0]); |
359 rb1.WithCumulativeLost(kCumLost[0]); | 338 rb1.WithCumulativeLost(kCumLost[0]); |
360 rtcp::ReceiverReport rr1; | 339 rtcp::ReceiverReport rr1; |
361 rr1.From(kSenderSsrc1); | 340 rr1.From(kSenderSsrc[0]); |
362 rr1.WithReportBlock(rb1); | 341 rr1.WithReportBlock(rb1); |
363 | 342 |
364 rtc::Buffer p1 = rr1.Build(); | 343 int64_t now = system_clock_.TimeInMilliseconds(); |
365 EXPECT_EQ(0, InjectRtcpPacket(p1.data(), p1.size())); | 344 EXPECT_CALL(bandwidth_observer_, |
366 ASSERT_EQ(1u, rtcp_packet_info_.report_blocks.size()); | 345 OnReceivedRtcpReceiverReport(SizeIs(1), _, now)); |
367 EXPECT_EQ(kFracLost[0], rtcp_packet_info_.report_blocks.front().fractionLost); | 346 InjectPacket(rr1); |
| 347 EXPECT_EQ(now, rtcp_receiver_->LastReceivedReceiverReport()); |
368 | 348 |
369 std::vector<RTCPReportBlock> received_blocks; | 349 std::vector<RTCPReportBlock> received_blocks; |
370 rtcp_receiver_->StatisticsReceived(&received_blocks); | 350 rtcp_receiver_->StatisticsReceived(&received_blocks); |
371 EXPECT_EQ(1u, received_blocks.size()); | 351 EXPECT_EQ(1u, received_blocks.size()); |
372 EXPECT_EQ(kSenderSsrc1, received_blocks[0].remoteSSRC); | 352 EXPECT_EQ(kSenderSsrc[0], received_blocks[0].remoteSSRC); |
373 EXPECT_EQ(kSourceSsrcs[0], received_blocks[0].sourceSSRC); | 353 EXPECT_EQ(kSourceSsrcs[0], received_blocks[0].sourceSSRC); |
374 EXPECT_EQ(kFracLost[0], received_blocks[0].fractionLost); | 354 EXPECT_EQ(kFracLost[0], received_blocks[0].fractionLost); |
375 EXPECT_EQ(kCumLost[0], received_blocks[0].cumulativeLost); | 355 EXPECT_EQ(kCumLost[0], received_blocks[0].cumulativeLost); |
376 EXPECT_EQ(kSequenceNumbers[0], received_blocks[0].extendedHighSeqNum); | 356 EXPECT_EQ(kSequenceNumbers[0], received_blocks[0].extendedHighSeqNum); |
377 | 357 |
378 rtcp::ReportBlock rb2; | 358 rtcp::ReportBlock rb2; |
379 rb2.To(kSourceSsrcs[0]); | 359 rb2.To(kSourceSsrcs[0]); |
380 rb2.WithExtHighestSeqNum(kSequenceNumbers[1]); | 360 rb2.WithExtHighestSeqNum(kSequenceNumbers[1]); |
381 rb2.WithFractionLost(kFracLost[1]); | 361 rb2.WithFractionLost(kFracLost[1]); |
382 rb2.WithCumulativeLost(kCumLost[1]); | 362 rb2.WithCumulativeLost(kCumLost[1]); |
383 rtcp::ReceiverReport rr2; | 363 rtcp::ReceiverReport rr2; |
384 rr2.From(kSenderSsrc2); | 364 rr2.From(kSenderSsrc[1]); |
385 rr2.WithReportBlock(rb2); | 365 rr2.WithReportBlock(rb2); |
386 rtc::Buffer p2 = rr2.Build(); | 366 |
387 EXPECT_EQ(0, InjectRtcpPacket(p2.data(), p2.size())); | 367 EXPECT_CALL(bandwidth_observer_, |
388 ASSERT_EQ(1u, rtcp_packet_info_.report_blocks.size()); | 368 OnReceivedRtcpReceiverReport(SizeIs(1), _, now)); |
389 EXPECT_EQ(kFracLost[1], rtcp_packet_info_.report_blocks.front().fractionLost); | 369 InjectPacket(rr2); |
390 | 370 |
391 received_blocks.clear(); | 371 received_blocks.clear(); |
392 rtcp_receiver_->StatisticsReceived(&received_blocks); | 372 rtcp_receiver_->StatisticsReceived(&received_blocks); |
393 ASSERT_EQ(2u, received_blocks.size()); | 373 ASSERT_EQ(2u, received_blocks.size()); |
394 EXPECT_EQ(kSenderSsrc1, received_blocks[0].remoteSSRC); | 374 // Order is not guaranteed. |
395 EXPECT_EQ(kSenderSsrc2, received_blocks[1].remoteSSRC); | 375 EXPECT_THAT(received_blocks, |
396 for (size_t i = 0; i < received_blocks.size(); ++i) { | 376 UnorderedElementsAre( |
397 EXPECT_EQ(kSourceSsrcs[0], received_blocks[i].sourceSSRC); | 377 AllOf(Field(&RTCPReportBlock::sourceSSRC, kSourceSsrcs[0]), |
398 EXPECT_EQ(kFracLost[i], received_blocks[i].fractionLost); | 378 Field(&RTCPReportBlock::remoteSSRC, kSenderSsrc[0]), |
399 EXPECT_EQ(kCumLost[i], received_blocks[i].cumulativeLost); | 379 Field(&RTCPReportBlock::fractionLost, kFracLost[0]), |
400 EXPECT_EQ(kSequenceNumbers[i], received_blocks[i].extendedHighSeqNum); | 380 Field(&RTCPReportBlock::cumulativeLost, kCumLost[0]), |
401 } | 381 Field(&RTCPReportBlock::extendedHighSeqNum, |
| 382 kSequenceNumbers[0])), |
| 383 AllOf(Field(&RTCPReportBlock::sourceSSRC, kSourceSsrcs[0]), |
| 384 Field(&RTCPReportBlock::remoteSSRC, kSenderSsrc[1]), |
| 385 Field(&RTCPReportBlock::fractionLost, kFracLost[1]), |
| 386 Field(&RTCPReportBlock::cumulativeLost, kCumLost[1]), |
| 387 Field(&RTCPReportBlock::extendedHighSeqNum, |
| 388 kSequenceNumbers[1])))); |
402 } | 389 } |
403 | 390 |
404 TEST_F(RtcpReceiverTest, GetRtt) { | 391 TEST_F(RtcpReceiverTest, GetRtt) { |
405 const uint32_t kSenderSsrc = 0x10203; | 392 const uint32_t kSenderSsrc = 0x10203; |
406 const uint32_t kSourceSsrc = 0x123456; | 393 const uint32_t kSourceSsrc = 0x123456; |
407 std::set<uint32_t> ssrcs; | 394 SetSsrc(kSourceSsrc); |
408 ssrcs.insert(kSourceSsrc); | |
409 rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs); | |
410 | 395 |
411 // No report block received. | 396 // No report block received. |
412 EXPECT_EQ( | 397 EXPECT_EQ( |
413 -1, rtcp_receiver_->RTT(kSenderSsrc, nullptr, nullptr, nullptr, nullptr)); | 398 -1, rtcp_receiver_->RTT(kSenderSsrc, nullptr, nullptr, nullptr, nullptr)); |
414 | 399 |
415 rtcp::ReportBlock rb; | 400 rtcp::ReportBlock rb; |
416 rb.To(kSourceSsrc); | 401 rb.To(kSourceSsrc); |
| 402 rb.WithLastSr(0x12344321); |
417 rtcp::ReceiverReport rr; | 403 rtcp::ReceiverReport rr; |
418 rr.From(kSenderSsrc); | 404 rr.From(kSenderSsrc); |
419 rr.WithReportBlock(rb); | 405 rr.WithReportBlock(rb); |
420 rtc::Buffer packet = rr.Build(); | 406 int64_t now = system_clock_.TimeInMilliseconds(); |
421 EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size())); | 407 EXPECT_CALL(bandwidth_observer_, |
422 EXPECT_EQ(kSenderSsrc, rtcp_packet_info_.remoteSSRC); | 408 OnReceivedRtcpReceiverReport(SizeIs(1), _, now)); |
423 EXPECT_EQ(kRtcpRr, rtcp_packet_info_.rtcpPacketTypeFlags); | 409 InjectPacket(rr); |
424 EXPECT_EQ(1u, rtcp_packet_info_.report_blocks.size()); | 410 EXPECT_EQ(now, rtcp_receiver_->LastReceivedReceiverReport()); |
425 EXPECT_EQ( | 411 EXPECT_EQ( |
426 0, rtcp_receiver_->RTT(kSenderSsrc, nullptr, nullptr, nullptr, nullptr)); | 412 0, rtcp_receiver_->RTT(kSenderSsrc, nullptr, nullptr, nullptr, nullptr)); |
427 | 413 |
428 // Report block not received. | 414 // Report block not received. |
429 EXPECT_EQ(-1, rtcp_receiver_->RTT(kSenderSsrc + 1, nullptr, nullptr, nullptr, | 415 EXPECT_EQ(-1, rtcp_receiver_->RTT(kSenderSsrc + 1, nullptr, nullptr, nullptr, |
430 nullptr)); | 416 nullptr)); |
431 } | 417 } |
432 | 418 |
| 419 // Currently ij packets are ignored. |
433 TEST_F(RtcpReceiverTest, InjectIjWithNoItem) { | 420 TEST_F(RtcpReceiverTest, InjectIjWithNoItem) { |
| 421 int64_t now = system_clock_.TimeInMilliseconds(); |
434 rtcp::ExtendedJitterReport ij; | 422 rtcp::ExtendedJitterReport ij; |
435 rtc::Buffer packet = ij.Build(); | 423 |
436 EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size())); | 424 InjectPacket(ij); |
437 EXPECT_EQ(0U, rtcp_packet_info_.rtcpPacketTypeFlags); | 425 EXPECT_EQ(now, rtcp_receiver_->LastReceived()); |
438 } | 426 } |
439 | 427 |
| 428 // Currently ij packets are ignored. |
440 TEST_F(RtcpReceiverTest, InjectIjWithOneItem) { | 429 TEST_F(RtcpReceiverTest, InjectIjWithOneItem) { |
| 430 int64_t now = system_clock_.TimeInMilliseconds(); |
441 rtcp::ExtendedJitterReport ij; | 431 rtcp::ExtendedJitterReport ij; |
442 ij.WithJitter(0x11213141); | 432 ij.WithJitter(0x11213141); |
443 | 433 |
444 rtc::Buffer packet = ij.Build(); | 434 InjectPacket(ij); |
445 EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size())); | 435 EXPECT_EQ(now, rtcp_receiver_->LastReceived()); |
446 EXPECT_EQ(kRtcpTransmissionTimeOffset, rtcp_packet_info_.rtcpPacketTypeFlags); | 436 // EXPECT_EQ(0x11213141U, rtcp_receiver->LastInterArrivalJitter()); |
447 EXPECT_EQ(0x11213141U, rtcp_packet_info_.interArrivalJitter); | |
448 } | 437 } |
449 | 438 |
| 439 // Currently app packets are ignored. |
450 TEST_F(RtcpReceiverTest, InjectAppWithNoData) { | 440 TEST_F(RtcpReceiverTest, InjectAppWithNoData) { |
| 441 int64_t now = system_clock_.TimeInMilliseconds(); |
451 rtcp::App app; | 442 rtcp::App app; |
452 app.WithSubType(30); | 443 app.WithSubType(30); |
453 uint32_t name = 'n' << 24; | 444 uint32_t name = 'n' << 24; |
454 name += 'a' << 16; | 445 name += 'a' << 16; |
455 name += 'm' << 8; | 446 name += 'm' << 8; |
456 name += 'e'; | 447 name += 'e'; |
457 app.WithName(name); | 448 app.WithName(name); |
458 | 449 |
459 rtc::Buffer packet = app.Build(); | 450 InjectPacket(app); |
460 EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size())); | 451 EXPECT_EQ(now, rtcp_receiver_->LastReceived()); |
461 EXPECT_EQ(kRtcpApp, rtcp_packet_info_.rtcpPacketTypeFlags); | 452 // EXPECT_EQ(kRtcpApp, rtcp_packet_info_.rtcpPacketTypeFlags); |
462 EXPECT_EQ(30, rtcp_packet_info_.applicationSubType); | 453 // EXPECT_EQ(30, rtcp_packet_info_.applicationSubType); |
463 EXPECT_EQ(name, rtcp_packet_info_.applicationName); | 454 // EXPECT_EQ(name, rtcp_packet_info_.applicationName); |
464 EXPECT_EQ(0, rtcp_packet_info_.applicationLength); | 455 // EXPECT_EQ(0, rtcp_packet_info_.applicationLength); |
465 } | 456 } |
466 | 457 |
| 458 // Currently app packets are ignored. |
467 TEST_F(RtcpReceiverTest, InjectAppWithData) { | 459 TEST_F(RtcpReceiverTest, InjectAppWithData) { |
| 460 int64_t now = system_clock_.TimeInMilliseconds(); |
468 rtcp::App app; | 461 rtcp::App app; |
469 app.WithSubType(30); | 462 app.WithSubType(30); |
470 uint32_t name = 'n' << 24; | 463 uint32_t name = 'n' << 24; |
471 name += 'a' << 16; | 464 name += 'a' << 16; |
472 name += 'm' << 8; | 465 name += 'm' << 8; |
473 name += 'e'; | 466 name += 'e'; |
474 app.WithName(name); | 467 app.WithName(name); |
475 const char kData[] = {'t', 'e', 's', 't', 'd', 'a', 't', 'a'}; | 468 const uint8_t kData[] = {'t', 'e', 's', 't', 'd', 'a', 't', 'a'}; |
476 const size_t kDataLength = sizeof(kData) / sizeof(kData[0]); | 469 const size_t kDataLength = sizeof(kData) / sizeof(kData[0]); |
477 app.WithData((const uint8_t*)kData, kDataLength); | 470 app.WithData(kData, kDataLength); |
478 | 471 |
479 rtc::Buffer packet = app.Build(); | 472 InjectPacket(app); |
480 EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size())); | 473 EXPECT_EQ(now, rtcp_receiver_->LastReceived()); |
481 EXPECT_EQ(kRtcpApp, rtcp_packet_info_.rtcpPacketTypeFlags); | 474 // EXPECT_EQ(kRtcpApp, rtcp_packet_info_.rtcpPacketTypeFlags); |
482 EXPECT_EQ(30, rtcp_packet_info_.applicationSubType); | 475 // EXPECT_EQ(30, rtcp_packet_info_.applicationSubType); |
483 EXPECT_EQ(name, rtcp_packet_info_.applicationName); | 476 // EXPECT_EQ(name, rtcp_packet_info_.applicationName); |
484 EXPECT_EQ(kDataLength, rtcp_packet_info_.applicationLength); | 477 // EXPECT_EQ(kDataLength, rtcp_packet_info_.applicationLength); |
485 } | 478 } |
486 | 479 |
487 TEST_F(RtcpReceiverTest, InjectSdesWithOneChunk) { | 480 TEST_F(RtcpReceiverTest, InjectSdesWithOneChunk) { |
488 const uint32_t kSenderSsrc = 0x123456; | 481 const uint32_t kSenderSsrc = 0x123456; |
489 rtcp::Sdes sdes; | 482 rtcp::Sdes sdes; |
490 sdes.WithCName(kSenderSsrc, "alice@host"); | 483 sdes.WithCName(kSenderSsrc, "alice@host"); |
| 484 MockRtcpCallbackImpl callback; |
| 485 rtcp_receiver_->RegisterRtcpStatisticsCallback(&callback); |
| 486 EXPECT_CALL(callback, CNameChanged(StrEq("alice@host"), kSenderSsrc)); |
491 | 487 |
492 rtc::Buffer packet = sdes.Build(); | 488 InjectPacket(sdes); |
493 EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size())); | 489 |
494 char cName[RTCP_CNAME_SIZE]; | 490 char cName[RTCP_CNAME_SIZE]; |
495 EXPECT_EQ(0, rtcp_receiver_->CNAME(kSenderSsrc, cName)); | 491 EXPECT_EQ(0, rtcp_receiver_->CNAME(kSenderSsrc, cName)); |
496 EXPECT_EQ(0, strncmp(cName, "alice@host", RTCP_CNAME_SIZE)); | 492 EXPECT_EQ(0, strncmp(cName, "alice@host", RTCP_CNAME_SIZE)); |
497 } | 493 } |
498 | 494 |
499 TEST_F(RtcpReceiverTest, InjectByePacket_RemovesCname) { | 495 TEST_F(RtcpReceiverTest, InjectByePacket_RemovesCname) { |
500 const uint32_t kSenderSsrc = 0x123456; | 496 const uint32_t kSenderSsrc = 0x123456; |
501 rtcp::Sdes sdes; | 497 rtcp::Sdes sdes; |
502 sdes.WithCName(kSenderSsrc, "alice@host"); | 498 sdes.WithCName(kSenderSsrc, "alice@host"); |
503 | 499 |
504 rtc::Buffer packet = sdes.Build(); | 500 InjectPacket(sdes); |
505 EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size())); | |
506 char cName[RTCP_CNAME_SIZE]; | 501 char cName[RTCP_CNAME_SIZE]; |
507 EXPECT_EQ(0, rtcp_receiver_->CNAME(kSenderSsrc, cName)); | 502 EXPECT_EQ(0, rtcp_receiver_->CNAME(kSenderSsrc, cName)); |
508 | 503 |
509 // Verify that BYE removes the CNAME. | 504 // Verify that BYE removes the CNAME. |
510 rtcp::Bye bye; | 505 rtcp::Bye bye; |
511 bye.From(kSenderSsrc); | 506 bye.From(kSenderSsrc); |
512 rtc::Buffer p2 = bye.Build(); | 507 InjectPacket(bye); |
513 EXPECT_EQ(0, InjectRtcpPacket(p2.data(), p2.size())); | |
514 EXPECT_EQ(-1, rtcp_receiver_->CNAME(kSenderSsrc, cName)); | 508 EXPECT_EQ(-1, rtcp_receiver_->CNAME(kSenderSsrc, cName)); |
515 } | 509 } |
516 | 510 |
517 TEST_F(RtcpReceiverTest, InjectByePacket_RemovesReportBlocks) { | 511 TEST_F(RtcpReceiverTest, InjectByePacket_RemovesReportBlocks) { |
518 const uint32_t kSenderSsrc = 0x10203; | 512 const uint32_t kSenderSsrc = 0x10203; |
519 const uint32_t kSourceSsrcs[] = {0x40506, 0x50607}; | 513 const uint32_t kSourceSsrcs[] = {0x40506, 0x50607}; |
520 const int kNumSsrcs = sizeof(kSourceSsrcs) / sizeof(kSourceSsrcs[0]); | |
521 | 514 |
522 std::set<uint32_t> ssrcs(kSourceSsrcs, kSourceSsrcs + kNumSsrcs); | 515 SetSsrcs(kSourceSsrcs); |
523 rtcp_receiver_->SetSsrcs(kSourceSsrcs[0], ssrcs); | |
524 | 516 |
525 rtcp::ReportBlock rb1; | 517 rtcp::ReportBlock rb1; |
526 rb1.To(kSourceSsrcs[0]); | 518 rb1.To(kSourceSsrcs[0]); |
527 rtcp::ReportBlock rb2; | 519 rtcp::ReportBlock rb2; |
528 rb2.To(kSourceSsrcs[1]); | 520 rb2.To(kSourceSsrcs[1]); |
529 rtcp::ReceiverReport rr; | 521 rtcp::ReceiverReport rr; |
530 rr.From(kSenderSsrc); | 522 rr.From(kSenderSsrc); |
531 rr.WithReportBlock(rb1); | 523 rr.WithReportBlock(rb1); |
532 rr.WithReportBlock(rb2); | 524 rr.WithReportBlock(rb2); |
533 | 525 |
534 rtc::Buffer p1 = rr.Build(); | 526 EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _)); |
535 EXPECT_EQ(0, InjectRtcpPacket(p1.data(), p1.size())); | 527 InjectPacket(rr); |
536 ASSERT_EQ(2u, rtcp_packet_info_.report_blocks.size()); | |
537 std::vector<RTCPReportBlock> received_blocks; | 528 std::vector<RTCPReportBlock> received_blocks; |
538 rtcp_receiver_->StatisticsReceived(&received_blocks); | 529 rtcp_receiver_->StatisticsReceived(&received_blocks); |
539 EXPECT_EQ(2u, received_blocks.size()); | 530 EXPECT_EQ(2u, received_blocks.size()); |
540 | 531 |
541 // Verify that BYE removes the report blocks. | 532 // Verify that BYE removes the report blocks. |
542 rtcp::Bye bye; | 533 rtcp::Bye bye; |
543 bye.From(kSenderSsrc); | 534 bye.From(kSenderSsrc); |
544 rtc::Buffer p2 = bye.Build(); | 535 InjectPacket(bye); |
545 EXPECT_EQ(0, InjectRtcpPacket(p2.data(), p2.size())); | |
546 received_blocks.clear(); | 536 received_blocks.clear(); |
547 rtcp_receiver_->StatisticsReceived(&received_blocks); | 537 rtcp_receiver_->StatisticsReceived(&received_blocks); |
548 EXPECT_TRUE(received_blocks.empty()); | 538 EXPECT_TRUE(received_blocks.empty()); |
549 | 539 |
550 // Inject packet. | 540 // Inject packet. |
551 EXPECT_EQ(0, InjectRtcpPacket(p1.data(), p1.size())); | 541 EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _)); |
552 ASSERT_EQ(2u, rtcp_packet_info_.report_blocks.size()); | 542 InjectPacket(rr); |
553 received_blocks.clear(); | 543 received_blocks.clear(); |
554 rtcp_receiver_->StatisticsReceived(&received_blocks); | 544 rtcp_receiver_->StatisticsReceived(&received_blocks); |
555 EXPECT_EQ(2u, received_blocks.size()); | 545 EXPECT_EQ(2u, received_blocks.size()); |
556 } | 546 } |
557 | 547 |
558 TEST_F(RtcpReceiverTest, InjectPliPacket) { | 548 TEST_F(RtcpReceiverTest, InjectPliPacket) { |
559 const uint32_t kSourceSsrc = 0x123456; | 549 const uint32_t kSourceSsrc = 0x123456; |
560 std::set<uint32_t> ssrcs; | 550 SetSsrc(kSourceSsrc); |
561 ssrcs.insert(kSourceSsrc); | |
562 rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs); | |
563 | 551 |
564 rtcp::Pli pli; | 552 rtcp::Pli pli; |
565 pli.To(kSourceSsrc); | 553 pli.To(kSourceSsrc); |
566 rtc::Buffer packet = pli.Build(); | 554 EXPECT_CALL(packet_type_counter_observer_, |
567 EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size())); | 555 RtcpPacketTypesCounterUpdated( |
568 EXPECT_EQ(kRtcpPli, rtcp_packet_info_.rtcpPacketTypeFlags); | 556 kSourceSsrc, Field(&RtcpPacketTypeCounter::pli_packets, 1))); |
| 557 EXPECT_CALL(intra_frame_observer_, OnReceivedIntraFrameRequest(kSourceSsrc)); |
| 558 InjectPacket(pli); |
569 } | 559 } |
570 | 560 |
571 TEST_F(RtcpReceiverTest, PliPacketNotToUsIgnored) { | 561 TEST_F(RtcpReceiverTest, PliPacketNotToUsIgnored) { |
572 const uint32_t kSourceSsrc = 0x123456; | 562 const uint32_t kSourceSsrc = 0x123456; |
573 std::set<uint32_t> ssrcs; | 563 SetSsrc(kSourceSsrc); |
574 ssrcs.insert(kSourceSsrc); | |
575 rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs); | |
576 | 564 |
577 rtcp::Pli pli; | 565 rtcp::Pli pli; |
578 pli.To(kSourceSsrc + 1); | 566 pli.To(kSourceSsrc + 1); |
579 rtc::Buffer packet = pli.Build(); | 567 EXPECT_CALL(packet_type_counter_observer_, |
580 EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size())); | 568 RtcpPacketTypesCounterUpdated( |
581 EXPECT_EQ(0U, rtcp_packet_info_.rtcpPacketTypeFlags); | 569 kSourceSsrc, Field(&RtcpPacketTypeCounter::pli_packets, 0))); |
| 570 EXPECT_CALL(intra_frame_observer_, OnReceivedIntraFrameRequest(_)).Times(0); |
| 571 InjectPacket(pli); |
582 } | 572 } |
583 | 573 |
584 TEST_F(RtcpReceiverTest, InjectFirPacket) { | 574 TEST_F(RtcpReceiverTest, InjectFirPacket) { |
585 const uint32_t kSourceSsrc = 0x123456; | 575 const uint32_t kSourceSsrc = 0x123456; |
586 std::set<uint32_t> ssrcs; | 576 SetSsrc(kSourceSsrc); |
587 ssrcs.insert(kSourceSsrc); | |
588 rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs); | |
589 | 577 |
590 rtcp::Fir fir; | 578 rtcp::Fir fir; |
591 fir.WithRequestTo(kSourceSsrc, 13); | 579 fir.WithRequestTo(kSourceSsrc, 13); |
592 rtc::Buffer packet = fir.Build(); | 580 EXPECT_CALL(packet_type_counter_observer_, |
593 EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size())); | 581 RtcpPacketTypesCounterUpdated( |
594 EXPECT_EQ(kRtcpFir, rtcp_packet_info_.rtcpPacketTypeFlags); | 582 kSourceSsrc, Field(&RtcpPacketTypeCounter::fir_packets, 1))); |
| 583 EXPECT_CALL(intra_frame_observer_, OnReceivedIntraFrameRequest(kSourceSsrc)); |
| 584 InjectPacket(fir); |
595 } | 585 } |
596 | 586 |
597 TEST_F(RtcpReceiverTest, FirPacketNotToUsIgnored) { | 587 TEST_F(RtcpReceiverTest, FirPacketNotToUsIgnored) { |
598 const uint32_t kSourceSsrc = 0x123456; | 588 const uint32_t kSourceSsrc = 0x123456; |
599 std::set<uint32_t> ssrcs; | 589 SetSsrc(kSourceSsrc); |
600 ssrcs.insert(kSourceSsrc); | |
601 rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs); | |
602 | 590 |
603 rtcp::Fir fir; | 591 rtcp::Fir fir; |
604 fir.WithRequestTo(kSourceSsrc + 1, 13); | 592 fir.WithRequestTo(kSourceSsrc + 1, 13); |
605 rtc::Buffer packet = fir.Build(); | 593 EXPECT_CALL(intra_frame_observer_, OnReceivedIntraFrameRequest(kSourceSsrc)) |
606 EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size())); | 594 .Times(0); |
607 EXPECT_EQ(0U, rtcp_packet_info_.rtcpPacketTypeFlags); | 595 InjectPacket(fir); |
608 } | 596 } |
609 | 597 |
610 TEST_F(RtcpReceiverTest, InjectSliPacket) { | 598 TEST_F(RtcpReceiverTest, InjectSliPacket) { |
611 rtcp::Sli sli; | 599 rtcp::Sli sli; |
612 sli.WithPictureId(40); | 600 sli.WithPictureId(40); |
613 rtc::Buffer packet = sli.Build(); | 601 EXPECT_CALL(intra_frame_observer_, OnReceivedSLI(_, 40)); |
614 EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size())); | 602 InjectPacket(sli); |
615 EXPECT_EQ(kRtcpSli, rtcp_packet_info_.rtcpPacketTypeFlags); | 603 } |
616 EXPECT_EQ(40, rtcp_packet_info_.sliPictureId); | 604 |
| 605 TEST_F(RtcpReceiverTest, InjectRPsiPacket) { |
| 606 const uint64_t kPictureId = 0x123456789; |
| 607 rtcp::Rpsi rpsi; |
| 608 rpsi.WithPictureId(kPictureId); |
| 609 EXPECT_CALL(intra_frame_observer_, OnReceivedRPSI(_, kPictureId)); |
| 610 InjectPacket(rpsi); |
617 } | 611 } |
618 | 612 |
619 TEST_F(RtcpReceiverTest, ExtendedReportsPacketWithZeroReportBlocksIgnored) { | 613 TEST_F(RtcpReceiverTest, ExtendedReportsPacketWithZeroReportBlocksIgnored) { |
620 rtcp::ExtendedReports xr; | 614 rtcp::ExtendedReports xr; |
621 xr.From(0x2345); | 615 xr.From(0x2345); |
622 rtc::Buffer packet = xr.Build(); | 616 InjectPacket(xr); |
623 EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size())); | |
624 EXPECT_EQ(0U, rtcp_packet_info_.rtcpPacketTypeFlags); | |
625 } | 617 } |
626 | 618 |
| 619 // Currently VOiP reports are ignored. |
627 TEST_F(RtcpReceiverTest, InjectExtendedReportsVoipPacket) { | 620 TEST_F(RtcpReceiverTest, InjectExtendedReportsVoipPacket) { |
628 const uint32_t kSourceSsrc = 0x123456; | 621 const uint32_t kSourceSsrc = 0x123456; |
629 std::set<uint32_t> ssrcs; | 622 SetSsrc(kSourceSsrc); |
630 ssrcs.insert(kSourceSsrc); | |
631 rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs); | |
632 | 623 |
633 const uint8_t kLossRate = 123; | 624 const uint8_t kLossRate = 123; |
634 rtcp::VoipMetric voip_metric; | 625 rtcp::VoipMetric voip_metric; |
635 voip_metric.To(kSourceSsrc); | 626 voip_metric.To(kSourceSsrc); |
636 RTCPVoIPMetric metric; | 627 RTCPVoIPMetric metric; |
637 metric.lossRate = kLossRate; | 628 metric.lossRate = kLossRate; |
638 voip_metric.WithVoipMetric(metric); | 629 voip_metric.WithVoipMetric(metric); |
639 rtcp::ExtendedReports xr; | 630 rtcp::ExtendedReports xr; |
640 xr.From(0x2345); | 631 xr.From(0x2345); |
641 xr.WithVoipMetric(voip_metric); | 632 xr.WithVoipMetric(voip_metric); |
642 rtc::Buffer packet = xr.Build(); | 633 |
643 EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size())); | 634 InjectPacket(xr); |
644 ASSERT_TRUE(rtcp_packet_info_.VoIPMetric != nullptr); | |
645 EXPECT_EQ(kLossRate, rtcp_packet_info_.VoIPMetric->lossRate); | |
646 EXPECT_EQ(kRtcpXrVoipMetric, rtcp_packet_info_.rtcpPacketTypeFlags); | |
647 } | 635 } |
648 | 636 |
| 637 // Currently VOiP reports are ignored. |
649 TEST_F(RtcpReceiverTest, ExtendedReportsVoipPacketNotToUsIgnored) { | 638 TEST_F(RtcpReceiverTest, ExtendedReportsVoipPacketNotToUsIgnored) { |
650 const uint32_t kSourceSsrc = 0x123456; | 639 const uint32_t kSourceSsrc = 0x123456; |
651 std::set<uint32_t> ssrcs; | 640 SetSsrc(kSourceSsrc); |
652 ssrcs.insert(kSourceSsrc); | |
653 rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs); | |
654 | 641 |
655 rtcp::VoipMetric voip_metric; | 642 rtcp::VoipMetric voip_metric; |
656 voip_metric.To(kSourceSsrc + 1); | 643 voip_metric.To(kSourceSsrc + 1); |
657 rtcp::ExtendedReports xr; | 644 rtcp::ExtendedReports xr; |
658 xr.From(0x2345); | 645 xr.From(0x2345); |
659 xr.WithVoipMetric(voip_metric); | 646 xr.WithVoipMetric(voip_metric); |
660 rtc::Buffer packet = xr.Build(); | 647 |
661 EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size())); | 648 InjectPacket(xr); |
662 EXPECT_EQ(0U, rtcp_packet_info_.rtcpPacketTypeFlags); | |
663 } | 649 } |
664 | 650 |
665 TEST_F(RtcpReceiverTest, InjectExtendedReportsReceiverReferenceTimePacket) { | 651 TEST_F(RtcpReceiverTest, InjectExtendedReportsReceiverReferenceTimePacket) { |
| 652 const NtpTime kNtp(0x10203, 0x40506); |
| 653 const uint32_t kSenderSsrc = 0x2345; |
666 rtcp::Rrtr rrtr; | 654 rtcp::Rrtr rrtr; |
667 rrtr.WithNtp(NtpTime(0x10203, 0x40506)); | 655 rrtr.WithNtp(kNtp); |
668 rtcp::ExtendedReports xr; | 656 rtcp::ExtendedReports xr; |
669 xr.From(0x2345); | 657 xr.From(kSenderSsrc); |
670 xr.WithRrtr(rrtr); | 658 xr.WithRrtr(rrtr); |
671 | 659 |
672 rtc::Buffer packet = xr.Build(); | 660 RtcpReceiveTimeInfo rrtime; |
673 EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size())); | 661 EXPECT_FALSE(rtcp_receiver_->LastReceivedXrReferenceTimeInfo(&rrtime)); |
674 EXPECT_EQ(kRtcpXrReceiverReferenceTime, | 662 InjectPacket(xr); |
675 rtcp_packet_info_.rtcpPacketTypeFlags); | 663 |
| 664 EXPECT_TRUE(rtcp_receiver_->LastReceivedXrReferenceTimeInfo(&rrtime)); |
| 665 EXPECT_EQ(rrtime.sourceSSRC, kSenderSsrc); |
| 666 EXPECT_EQ(rrtime.lastRR, CompactNtp(kNtp)); |
| 667 EXPECT_EQ(0u, CompactNtpIntervalToMs(rrtime.delaySinceLastRR)); |
| 668 |
| 669 system_clock_.AdvanceTimeMilliseconds(1500); |
| 670 |
| 671 EXPECT_TRUE(rtcp_receiver_->LastReceivedXrReferenceTimeInfo(&rrtime)); |
| 672 EXPECT_NEAR(1500, CompactNtpIntervalToMs(rrtime.delaySinceLastRR), 1); |
676 } | 673 } |
677 | 674 |
678 TEST_F(RtcpReceiverTest, ExtendedReportsDlrrPacketNotToUsIgnored) { | 675 TEST_F(RtcpReceiverTest, ExtendedReportsDlrrPacketNotToUsIgnored) { |
679 const uint32_t kSourceSsrc = 0x123456; | 676 const uint32_t kSourceSsrc = 0x123456; |
680 std::set<uint32_t> ssrcs; | 677 SetSsrc(kSourceSsrc); |
681 ssrcs.insert(kSourceSsrc); | |
682 rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs); | |
683 | 678 |
684 rtcp::Dlrr dlrr; | 679 rtcp::Dlrr dlrr; |
685 dlrr.WithDlrrItem(kSourceSsrc + 1, 0x12345, 0x67890); | 680 dlrr.WithDlrrItem(kSourceSsrc + 1, 0x12345, 0x67890); |
686 rtcp::ExtendedReports xr; | 681 rtcp::ExtendedReports xr; |
687 xr.From(0x2345); | 682 xr.From(0x2345); |
688 xr.WithDlrr(dlrr); | 683 xr.WithDlrr(dlrr); |
689 rtc::Buffer packet = xr.Build(); | 684 InjectPacket(xr); |
690 EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size())); | 685 int64_t rtt_ms = 0; |
691 EXPECT_EQ(0U, rtcp_packet_info_.rtcpPacketTypeFlags); | 686 EXPECT_FALSE(rtcp_receiver_->GetAndResetXrRrRtt(&rtt_ms)); |
692 EXPECT_FALSE(rtcp_packet_info_.xr_dlrr_item); | |
693 } | 687 } |
694 | 688 |
695 TEST_F(RtcpReceiverTest, InjectExtendedReportsDlrrPacketWithSubBlock) { | 689 TEST_F(RtcpReceiverTest, InjectExtendedReportsDlrrPacketWithSubBlock) { |
696 const uint32_t kSourceSsrc = 0x123456; | 690 const uint32_t kSourceSsrc = 0x123456; |
697 std::set<uint32_t> ssrcs; | 691 const uint32_t kLastRR = 0x12345; |
698 ssrcs.insert(kSourceSsrc); | 692 const uint32_t kDelay = 0x23456; |
699 rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs); | 693 SetSsrc(kSourceSsrc); |
| 694 int64_t rtt_ms = 0; |
700 | 695 |
701 rtcp::Dlrr dlrr; | 696 rtcp::Dlrr dlrr; |
702 dlrr.WithDlrrItem(kSourceSsrc, 0x12345, 0x67890); | 697 dlrr.WithDlrrItem(kSourceSsrc, kLastRR, kDelay); |
703 rtcp::ExtendedReports xr; | 698 rtcp::ExtendedReports xr; |
704 xr.From(0x2345); | 699 xr.From(0x2345); |
705 xr.WithDlrr(dlrr); | 700 xr.WithDlrr(dlrr); |
706 rtc::Buffer packet = xr.Build(); | 701 |
707 EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size())); | 702 EXPECT_FALSE(rtcp_receiver_->GetAndResetXrRrRtt(&rtt_ms)); |
708 // The parser should note the DLRR report block item. | 703 InjectPacket(xr); |
709 EXPECT_TRUE(rtcp_packet_info_.xr_dlrr_item); | 704 |
| 705 uint32_t compact_ntp_now = CompactNtp(NtpTime(system_clock_)); |
| 706 EXPECT_TRUE(rtcp_receiver_->GetAndResetXrRrRtt(&rtt_ms)); |
| 707 uint32_t rtt_ntp = compact_ntp_now - kDelay - kLastRR; |
| 708 EXPECT_NEAR(CompactNtpIntervalToMs(rtt_ntp), rtt_ms, 1); |
710 } | 709 } |
711 | 710 |
712 TEST_F(RtcpReceiverTest, InjectExtendedReportsDlrrPacketWithMultipleSubBlocks) { | 711 TEST_F(RtcpReceiverTest, InjectExtendedReportsDlrrPacketWithMultipleSubBlocks) { |
713 const uint32_t kSourceSsrc = 0x123456; | 712 const uint32_t kSourceSsrc = 0x123456; |
714 std::set<uint32_t> ssrcs; | 713 const uint32_t kLastRR = 0x12345; |
715 ssrcs.insert(kSourceSsrc); | 714 const uint32_t kDelay = 0x56789; |
716 rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs); | 715 SetSsrc(kSourceSsrc); |
717 | 716 |
718 rtcp::Dlrr dlrr; | 717 rtcp::Dlrr dlrr; |
| 718 dlrr.WithDlrrItem(kSourceSsrc, kLastRR, kDelay); |
719 dlrr.WithDlrrItem(kSourceSsrc + 1, 0x12345, 0x67890); | 719 dlrr.WithDlrrItem(kSourceSsrc + 1, 0x12345, 0x67890); |
720 dlrr.WithDlrrItem(kSourceSsrc + 2, 0x12345, 0x67890); | 720 dlrr.WithDlrrItem(kSourceSsrc + 2, 0x12345, 0x67890); |
721 dlrr.WithDlrrItem(kSourceSsrc, 0x12345, 0x67890); | 721 |
722 rtcp::ExtendedReports xr; | 722 rtcp::ExtendedReports xr; |
723 xr.From(0x2345); | 723 xr.From(0x2345); |
724 xr.WithDlrr(dlrr); | 724 xr.WithDlrr(dlrr); |
725 rtc::Buffer packet = xr.Build(); | 725 |
726 EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size())); | 726 InjectPacket(xr); |
727 // The parser should note the DLRR report block item. | 727 uint32_t compact_ntp_now = CompactNtp(NtpTime(system_clock_)); |
728 EXPECT_TRUE(rtcp_packet_info_.xr_dlrr_item); | 728 int64_t rtt_ms = 0; |
| 729 EXPECT_TRUE(rtcp_receiver_->GetAndResetXrRrRtt(&rtt_ms)); |
| 730 uint32_t rtt_ntp = compact_ntp_now - kDelay - kLastRR; |
| 731 EXPECT_NEAR(CompactNtpIntervalToMs(rtt_ntp), rtt_ms, 1); |
729 } | 732 } |
730 | 733 |
731 TEST_F(RtcpReceiverTest, InjectExtendedReportsPacketWithMultipleReportBlocks) { | 734 TEST_F(RtcpReceiverTest, InjectExtendedReportsPacketWithMultipleReportBlocks) { |
732 const uint32_t kSourceSsrc = 0x123456; | 735 const uint32_t kSourceSsrc = 0x123456; |
733 std::set<uint32_t> ssrcs; | 736 SetSsrc(kSourceSsrc); |
734 ssrcs.insert(kSourceSsrc); | |
735 rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs); | |
736 | 737 |
737 rtcp::Rrtr rrtr; | 738 rtcp::Rrtr rrtr; |
738 rtcp::Dlrr dlrr; | 739 rtcp::Dlrr dlrr; |
739 dlrr.WithDlrrItem(kSourceSsrc, 0, 0x67890); | 740 dlrr.WithDlrrItem(kSourceSsrc, 0x12345, 0x67890); |
740 rtcp::VoipMetric metric; | 741 rtcp::VoipMetric metric; |
741 metric.To(kSourceSsrc); | 742 metric.To(kSourceSsrc); |
742 rtcp::ExtendedReports xr; | 743 rtcp::ExtendedReports xr; |
743 xr.From(0x2345); | 744 xr.From(0x2345); |
744 xr.WithRrtr(rrtr); | 745 xr.WithRrtr(rrtr); |
745 xr.WithDlrr(dlrr); | 746 xr.WithDlrr(dlrr); |
746 xr.WithVoipMetric(metric); | 747 xr.WithVoipMetric(metric); |
747 rtc::Buffer packet = xr.Build(); | 748 |
748 EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size())); | 749 InjectPacket(xr); |
749 // The parser should not flag the packet since the RTT is not estimated. | 750 |
750 EXPECT_EQ(static_cast<unsigned int>(kRtcpXrReceiverReferenceTime + | 751 RtcpReceiveTimeInfo rrtime; |
751 kRtcpXrVoipMetric), | 752 EXPECT_TRUE(rtcp_receiver_->LastReceivedXrReferenceTimeInfo(&rrtime)); |
752 rtcp_packet_info_.rtcpPacketTypeFlags); | 753 int64_t rtt_ms = 0; |
753 // The parser should note the DLRR report block item. | 754 EXPECT_TRUE(rtcp_receiver_->GetAndResetXrRrRtt(&rtt_ms)); |
754 EXPECT_TRUE(rtcp_packet_info_.xr_dlrr_item); | |
755 } | 755 } |
756 | 756 |
757 TEST_F(RtcpReceiverTest, InjectExtendedReportsPacketWithUnknownReportBlock) { | 757 TEST_F(RtcpReceiverTest, InjectExtendedReportsPacketWithUnknownReportBlock) { |
758 const uint32_t kSourceSsrc = 0x123456; | 758 const uint32_t kSourceSsrc = 0x123456; |
759 std::set<uint32_t> ssrcs; | 759 SetSsrc(kSourceSsrc); |
760 ssrcs.insert(kSourceSsrc); | |
761 rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs); | |
762 std::vector<uint32_t> remote_ssrcs; | |
763 remote_ssrcs.push_back(kSourceSsrc); | |
764 | 760 |
765 rtcp::Rrtr rrtr; | 761 rtcp::Rrtr rrtr; |
766 rtcp::Dlrr dlrr; | 762 rtcp::Dlrr dlrr; |
767 dlrr.WithDlrrItem(kSourceSsrc, 0x12345, 0x67890); | 763 dlrr.WithDlrrItem(kSourceSsrc, 0x12345, 0x67890); |
768 rtcp::VoipMetric metric; | 764 rtcp::VoipMetric metric; |
769 metric.To(kSourceSsrc); | 765 metric.To(kSourceSsrc); |
770 rtcp::ExtendedReports xr; | 766 rtcp::ExtendedReports xr; |
771 xr.From(0x2345); | 767 xr.From(0x2345); |
| 768 xr.WithDlrr(dlrr); |
772 xr.WithRrtr(rrtr); | 769 xr.WithRrtr(rrtr); |
773 xr.WithDlrr(dlrr); | 770 |
774 xr.WithVoipMetric(metric); | |
775 rtc::Buffer packet = xr.Build(); | 771 rtc::Buffer packet = xr.Build(); |
776 // Modify the DLRR block to have an unsupported block type, from 5 to 6. | 772 // Modify the DLRR block to have an unsupported block type, from 5 to 6. |
777 uint8_t* buffer = packet.data(); | 773 ASSERT_EQ(5, packet.data()[20]); |
778 EXPECT_EQ(5, buffer[20]); | 774 packet.data()[20] = 6; |
779 buffer[20] = 6; | 775 EXPECT_TRUE(rtcp_receiver_->IncomingPacket(packet.data(), packet.size())); |
780 | 776 |
781 EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size())); | 777 // Validate Rrtr was received and processed. |
782 EXPECT_EQ(static_cast<unsigned int>(kRtcpXrReceiverReferenceTime + | 778 RtcpReceiveTimeInfo rrtime; |
783 kRtcpXrVoipMetric), | 779 EXPECT_TRUE(rtcp_receiver_->LastReceivedXrReferenceTimeInfo(&rrtime)); |
784 rtcp_packet_info_.rtcpPacketTypeFlags); | 780 // Validate Dlrr report wasn't processed. |
785 EXPECT_FALSE(rtcp_packet_info_.xr_dlrr_item); | 781 int64_t rtt_ms = 0; |
| 782 EXPECT_FALSE(rtcp_receiver_->GetAndResetXrRrRtt(&rtt_ms)); |
786 } | 783 } |
787 | 784 |
788 TEST_F(RtcpReceiverTest, TestXrRrRttInitiallyFalse) { | 785 TEST_F(RtcpReceiverTest, TestExtendedReportsRrRttInitiallyFalse) { |
789 int64_t rtt_ms; | 786 int64_t rtt_ms; |
790 EXPECT_FALSE(rtcp_receiver_->GetAndResetXrRrRtt(&rtt_ms)); | 787 EXPECT_FALSE(rtcp_receiver_->GetAndResetXrRrRtt(&rtt_ms)); |
791 } | 788 } |
792 | 789 |
793 TEST_F(RtcpReceiverTest, RttCalculatedAfterXrDlrr) { | 790 TEST_F(RtcpReceiverTest, RttCalculatedAfterExtendedReportsDlrr) { |
794 Random rand(0x0123456789abcdef); | 791 Random rand(0x0123456789abcdef); |
795 const uint32_t kSourceSsrc = rand.Rand(0x00000001u, 0xfffffffeu); | 792 const uint32_t kSourceSsrc = rand.Rand(0x00000001u, 0xfffffffeu); |
796 const uint32_t kRttMs = rand.Rand(1, 18 * 3600 * 1000); | 793 const uint32_t kRttMs = rand.Rand(1, 18 * 3600 * 1000); |
797 const uint32_t kDelayNtp = rand.Rand<uint32_t>(); | 794 const uint32_t kDelayNtp = rand.Rand<uint32_t>(); |
798 const uint32_t kDelayMs = CompactNtpIntervalToMs(kDelayNtp); | 795 const uint32_t kDelayMs = CompactNtpIntervalToMs(kDelayNtp); |
799 std::set<uint32_t> ssrcs; | 796 |
800 ssrcs.insert(kSourceSsrc); | 797 SetSsrc(kSourceSsrc); |
801 rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs); | |
802 NtpTime now(system_clock_); | 798 NtpTime now(system_clock_); |
803 uint32_t sent_ntp = CompactNtp(now); | 799 uint32_t sent_ntp = CompactNtp(now); |
804 system_clock_.AdvanceTimeMilliseconds(kRttMs + kDelayMs); | 800 system_clock_.AdvanceTimeMilliseconds(kRttMs + kDelayMs); |
805 | 801 |
806 rtcp::Dlrr dlrr; | 802 rtcp::Dlrr dlrr; |
807 dlrr.WithDlrrItem(kSourceSsrc, sent_ntp, kDelayNtp); | 803 dlrr.WithDlrrItem(kSourceSsrc, sent_ntp, kDelayNtp); |
808 rtcp::ExtendedReports xr; | 804 rtcp::ExtendedReports xr; |
809 xr.From(0x2345); | 805 xr.From(0x2345); |
810 xr.WithDlrr(dlrr); | 806 xr.WithDlrr(dlrr); |
811 rtc::Buffer packet = xr.Build(); | 807 InjectPacket(xr); |
812 EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size())); | |
813 | 808 |
814 int64_t rtt_ms = 0; | 809 int64_t rtt_ms = 0; |
815 EXPECT_TRUE(rtcp_receiver_->GetAndResetXrRrRtt(&rtt_ms)); | 810 EXPECT_TRUE(rtcp_receiver_->GetAndResetXrRrRtt(&rtt_ms)); |
816 EXPECT_NEAR(kRttMs, rtt_ms, 1); | 811 EXPECT_NEAR(kRttMs, rtt_ms, 1); |
817 } | 812 } |
818 | 813 |
819 TEST_F(RtcpReceiverTest, LastReceivedXrReferenceTimeInfoInitiallyFalse) { | 814 TEST_F(RtcpReceiverTest, LastReceivedXrReferenceTimeInfoInitiallyFalse) { |
820 RtcpReceiveTimeInfo info; | 815 RtcpReceiveTimeInfo info; |
821 EXPECT_FALSE(rtcp_receiver_->LastReceivedXrReferenceTimeInfo(&info)); | 816 EXPECT_FALSE(rtcp_receiver_->LastReceivedXrReferenceTimeInfo(&info)); |
822 } | 817 } |
823 | 818 |
824 TEST_F(RtcpReceiverTest, GetLastReceivedExtendedReportsReferenceTimeInfo) { | 819 TEST_F(RtcpReceiverTest, GetLastReceivedExtendedReportsReferenceTimeInfo) { |
825 const uint32_t kSenderSsrc = 0x123456; | 820 const uint32_t kSenderSsrc = 0x123456; |
826 const NtpTime kNtp(0x10203, 0x40506); | 821 const NtpTime kNtp(0x10203, 0x40506); |
827 const uint32_t kNtpMid = CompactNtp(kNtp); | 822 const uint32_t kNtpMid = CompactNtp(kNtp); |
828 | 823 |
829 rtcp::Rrtr rrtr; | 824 rtcp::Rrtr rrtr; |
830 rrtr.WithNtp(kNtp); | 825 rrtr.WithNtp(kNtp); |
831 rtcp::ExtendedReports xr; | 826 rtcp::ExtendedReports xr; |
832 xr.From(kSenderSsrc); | 827 xr.From(kSenderSsrc); |
833 xr.WithRrtr(rrtr); | 828 xr.WithRrtr(rrtr); |
834 rtc::Buffer packet = xr.Build(); | 829 |
835 EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size())); | 830 InjectPacket(xr); |
836 EXPECT_EQ(kRtcpXrReceiverReferenceTime, | |
837 rtcp_packet_info_.rtcpPacketTypeFlags); | |
838 | 831 |
839 RtcpReceiveTimeInfo info; | 832 RtcpReceiveTimeInfo info; |
840 EXPECT_TRUE(rtcp_receiver_->LastReceivedXrReferenceTimeInfo(&info)); | 833 EXPECT_TRUE(rtcp_receiver_->LastReceivedXrReferenceTimeInfo(&info)); |
841 EXPECT_EQ(kSenderSsrc, info.sourceSSRC); | 834 EXPECT_EQ(kSenderSsrc, info.sourceSSRC); |
842 EXPECT_EQ(kNtpMid, info.lastRR); | 835 EXPECT_EQ(kNtpMid, info.lastRR); |
843 EXPECT_EQ(0U, info.delaySinceLastRR); | 836 EXPECT_EQ(0U, info.delaySinceLastRR); |
844 | 837 |
845 system_clock_.AdvanceTimeMilliseconds(1000); | 838 system_clock_.AdvanceTimeMilliseconds(1000); |
846 EXPECT_TRUE(rtcp_receiver_->LastReceivedXrReferenceTimeInfo(&info)); | 839 EXPECT_TRUE(rtcp_receiver_->LastReceivedXrReferenceTimeInfo(&info)); |
847 EXPECT_EQ(65536U, info.delaySinceLastRR); | 840 EXPECT_EQ(65536U, info.delaySinceLastRR); |
848 } | 841 } |
849 | 842 |
850 TEST_F(RtcpReceiverTest, ReceiveReportTimeout) { | 843 TEST_F(RtcpReceiverTest, ReceiveReportTimeout) { |
851 const uint32_t kSenderSsrc = 0x10203; | 844 const uint32_t kSenderSsrc = 0x10203; |
852 const uint32_t kSourceSsrc = 0x40506; | 845 const uint32_t kSourceSsrc = 0x40506; |
853 const int64_t kRtcpIntervalMs = 1000; | 846 const int64_t kRtcpIntervalMs = 1000; |
854 | 847 |
855 std::set<uint32_t> ssrcs; | 848 SetSsrc(kSourceSsrc); |
856 ssrcs.insert(kSourceSsrc); | |
857 rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs); | |
858 | 849 |
859 const uint16_t kSequenceNumber = 1234; | 850 const uint16_t kSequenceNumber = 1234; |
860 system_clock_.AdvanceTimeMilliseconds(3 * kRtcpIntervalMs); | 851 system_clock_.AdvanceTimeMilliseconds(3 * kRtcpIntervalMs); |
861 | 852 |
862 // No RR received, shouldn't trigger a timeout. | 853 // No RR received, shouldn't trigger a timeout. |
863 EXPECT_FALSE(rtcp_receiver_->RtcpRrTimeout(kRtcpIntervalMs)); | 854 EXPECT_FALSE(rtcp_receiver_->RtcpRrTimeout(kRtcpIntervalMs)); |
864 EXPECT_FALSE(rtcp_receiver_->RtcpRrSequenceNumberTimeout(kRtcpIntervalMs)); | 855 EXPECT_FALSE(rtcp_receiver_->RtcpRrSequenceNumberTimeout(kRtcpIntervalMs)); |
865 | 856 |
866 // Add a RR and advance the clock just enough to not trigger a timeout. | 857 // Add a RR and advance the clock just enough to not trigger a timeout. |
867 rtcp::ReportBlock rb1; | 858 rtcp::ReportBlock rb1; |
868 rb1.To(kSourceSsrc); | 859 rb1.To(kSourceSsrc); |
869 rb1.WithExtHighestSeqNum(kSequenceNumber); | 860 rb1.WithExtHighestSeqNum(kSequenceNumber); |
870 rtcp::ReceiverReport rr1; | 861 rtcp::ReceiverReport rr1; |
871 rr1.From(kSenderSsrc); | 862 rr1.From(kSenderSsrc); |
872 rr1.WithReportBlock(rb1); | 863 rr1.WithReportBlock(rb1); |
873 rtc::Buffer p1 = rr1.Build(); | 864 |
874 EXPECT_EQ(0, InjectRtcpPacket(p1.data(), p1.size())); | 865 EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _)); |
| 866 InjectPacket(rr1); |
875 system_clock_.AdvanceTimeMilliseconds(3 * kRtcpIntervalMs - 1); | 867 system_clock_.AdvanceTimeMilliseconds(3 * kRtcpIntervalMs - 1); |
876 EXPECT_FALSE(rtcp_receiver_->RtcpRrTimeout(kRtcpIntervalMs)); | 868 EXPECT_FALSE(rtcp_receiver_->RtcpRrTimeout(kRtcpIntervalMs)); |
877 EXPECT_FALSE(rtcp_receiver_->RtcpRrSequenceNumberTimeout(kRtcpIntervalMs)); | 869 EXPECT_FALSE(rtcp_receiver_->RtcpRrSequenceNumberTimeout(kRtcpIntervalMs)); |
878 | 870 |
879 // Add a RR with the same extended max as the previous RR to trigger a | 871 // Add a RR with the same extended max as the previous RR to trigger a |
880 // sequence number timeout, but not a RR timeout. | 872 // sequence number timeout, but not a RR timeout. |
881 EXPECT_EQ(0, InjectRtcpPacket(p1.data(), p1.size())); | 873 EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _)); |
| 874 InjectPacket(rr1); |
882 system_clock_.AdvanceTimeMilliseconds(2); | 875 system_clock_.AdvanceTimeMilliseconds(2); |
883 EXPECT_FALSE(rtcp_receiver_->RtcpRrTimeout(kRtcpIntervalMs)); | 876 EXPECT_FALSE(rtcp_receiver_->RtcpRrTimeout(kRtcpIntervalMs)); |
884 EXPECT_TRUE(rtcp_receiver_->RtcpRrSequenceNumberTimeout(kRtcpIntervalMs)); | 877 EXPECT_TRUE(rtcp_receiver_->RtcpRrSequenceNumberTimeout(kRtcpIntervalMs)); |
885 | 878 |
886 // Advance clock enough to trigger an RR timeout too. | 879 // Advance clock enough to trigger an RR timeout too. |
887 system_clock_.AdvanceTimeMilliseconds(3 * kRtcpIntervalMs); | 880 system_clock_.AdvanceTimeMilliseconds(3 * kRtcpIntervalMs); |
888 EXPECT_TRUE(rtcp_receiver_->RtcpRrTimeout(kRtcpIntervalMs)); | 881 EXPECT_TRUE(rtcp_receiver_->RtcpRrTimeout(kRtcpIntervalMs)); |
889 | 882 |
890 // We should only get one timeout even though we still haven't received a new | 883 // We should only get one timeout even though we still haven't received a new |
891 // RR. | 884 // RR. |
892 EXPECT_FALSE(rtcp_receiver_->RtcpRrTimeout(kRtcpIntervalMs)); | 885 EXPECT_FALSE(rtcp_receiver_->RtcpRrTimeout(kRtcpIntervalMs)); |
893 EXPECT_FALSE(rtcp_receiver_->RtcpRrSequenceNumberTimeout(kRtcpIntervalMs)); | 886 EXPECT_FALSE(rtcp_receiver_->RtcpRrSequenceNumberTimeout(kRtcpIntervalMs)); |
894 | 887 |
895 // Add a new RR with increase sequence number to reset timers. | 888 // Add a new RR with increase sequence number to reset timers. |
896 rtcp::ReportBlock rb2; | 889 rtcp::ReportBlock rb2; |
897 rb2.To(kSourceSsrc); | 890 rb2.To(kSourceSsrc); |
898 rb2.WithExtHighestSeqNum(kSequenceNumber + 1); | 891 rb2.WithExtHighestSeqNum(kSequenceNumber + 1); |
899 rtcp::ReceiverReport rr2; | 892 rtcp::ReceiverReport rr2; |
900 rr2.From(kSenderSsrc); | 893 rr2.From(kSenderSsrc); |
901 rr2.WithReportBlock(rb2); | 894 rr2.WithReportBlock(rb2); |
902 rtc::Buffer p2 = rr2.Build(); | 895 EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _)); |
903 EXPECT_EQ(0, InjectRtcpPacket(p2.data(), p2.size())); | 896 InjectPacket(rr2); |
904 EXPECT_FALSE(rtcp_receiver_->RtcpRrTimeout(kRtcpIntervalMs)); | 897 EXPECT_FALSE(rtcp_receiver_->RtcpRrTimeout(kRtcpIntervalMs)); |
905 EXPECT_FALSE(rtcp_receiver_->RtcpRrSequenceNumberTimeout(kRtcpIntervalMs)); | 898 EXPECT_FALSE(rtcp_receiver_->RtcpRrSequenceNumberTimeout(kRtcpIntervalMs)); |
906 | 899 |
907 // Verify we can get a timeout again once we've received new RR. | 900 // Verify we can get a timeout again once we've received new RR. |
908 system_clock_.AdvanceTimeMilliseconds(2 * kRtcpIntervalMs); | 901 system_clock_.AdvanceTimeMilliseconds(2 * kRtcpIntervalMs); |
909 EXPECT_EQ(0, InjectRtcpPacket(p2.data(), p2.size())); | 902 EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _)); |
| 903 InjectPacket(rr2); |
910 system_clock_.AdvanceTimeMilliseconds(kRtcpIntervalMs + 1); | 904 system_clock_.AdvanceTimeMilliseconds(kRtcpIntervalMs + 1); |
911 EXPECT_FALSE(rtcp_receiver_->RtcpRrTimeout(kRtcpIntervalMs)); | 905 EXPECT_FALSE(rtcp_receiver_->RtcpRrTimeout(kRtcpIntervalMs)); |
912 EXPECT_TRUE(rtcp_receiver_->RtcpRrSequenceNumberTimeout(kRtcpIntervalMs)); | 906 EXPECT_TRUE(rtcp_receiver_->RtcpRrSequenceNumberTimeout(kRtcpIntervalMs)); |
913 system_clock_.AdvanceTimeMilliseconds(2 * kRtcpIntervalMs); | 907 system_clock_.AdvanceTimeMilliseconds(2 * kRtcpIntervalMs); |
914 EXPECT_TRUE(rtcp_receiver_->RtcpRrTimeout(kRtcpIntervalMs)); | 908 EXPECT_TRUE(rtcp_receiver_->RtcpRrTimeout(kRtcpIntervalMs)); |
915 } | 909 } |
916 | 910 |
917 TEST_F(RtcpReceiverTest, TmmbrReceivedWithNoIncomingPacket) { | 911 TEST_F(RtcpReceiverTest, TmmbrReceivedWithNoIncomingPacket) { |
918 // This call is expected to fail because no data has arrived. | 912 // This call is expected to fail because no data has arrived. |
919 EXPECT_EQ(-1, rtcp_receiver_->TMMBRReceived(0, 0, nullptr)); | 913 EXPECT_EQ(-1, rtcp_receiver_->TMMBRReceived(0, 0, nullptr)); |
920 } | 914 } |
921 | 915 |
922 TEST_F(RtcpReceiverTest, TmmbrPacketAccepted) { | 916 TEST_F(RtcpReceiverTest, TmmbrPacketAccepted) { |
923 const uint32_t kMediaFlowSsrc = 0x2040608; | 917 const uint32_t kMediaFlowSsrc = 0x2040608; |
924 const uint32_t kSenderSsrc = 0x10203; | 918 const uint32_t kSenderSsrc = 0x10203; |
925 std::set<uint32_t> ssrcs; | 919 SetSsrc(kMediaFlowSsrc); |
926 ssrcs.insert(kMediaFlowSsrc); // Matches "media source" above. | |
927 rtcp_receiver_->SetSsrcs(kMediaFlowSsrc, ssrcs); | |
928 | 920 |
929 rtcp::Tmmbr tmmbr; | 921 rtcp::Tmmbr tmmbr; |
930 tmmbr.From(kSenderSsrc); | 922 tmmbr.From(kSenderSsrc); |
931 tmmbr.WithTmmbr(rtcp::TmmbItem(kMediaFlowSsrc, 30000, 0)); | 923 tmmbr.WithTmmbr(rtcp::TmmbItem(kMediaFlowSsrc, 30000, 0)); |
932 | 924 |
933 rtcp::SenderReport sr; | 925 rtcp::SenderReport sr; |
934 sr.From(kSenderSsrc); | 926 sr.From(kSenderSsrc); |
935 sr.Append(&tmmbr); | 927 sr.Append(&tmmbr); |
936 rtc::Buffer packet = sr.Build(); | 928 EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _)); |
937 EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size())); | 929 EXPECT_CALL(bandwidth_observer_, OnReceivedEstimatedBitrate(30000)); |
| 930 InjectPacket(sr); |
938 | 931 |
939 EXPECT_EQ(1, rtcp_receiver_->TMMBRReceived(0, 0, nullptr)); | 932 EXPECT_EQ(1, rtcp_receiver_->TMMBRReceived(0, 0, nullptr)); |
940 TMMBRSet candidate_set; | 933 TMMBRSet candidate_set; |
941 candidate_set.VerifyAndAllocateSet(1); | 934 candidate_set.VerifyAndAllocateSet(1); |
942 EXPECT_EQ(1, rtcp_receiver_->TMMBRReceived(1, 0, &candidate_set)); | 935 EXPECT_EQ(1, rtcp_receiver_->TMMBRReceived(1, 0, &candidate_set)); |
943 EXPECT_LT(0U, candidate_set.Tmmbr(0)); | 936 EXPECT_LT(0U, candidate_set.Tmmbr(0)); |
944 EXPECT_EQ(kSenderSsrc, candidate_set.Ssrc(0)); | 937 EXPECT_EQ(kSenderSsrc, candidate_set.Ssrc(0)); |
945 } | 938 } |
946 | 939 |
947 TEST_F(RtcpReceiverTest, TmmbrPacketNotForUsIgnored) { | 940 TEST_F(RtcpReceiverTest, TmmbrPacketNotForUsIgnored) { |
948 const uint32_t kMediaFlowSsrc = 0x2040608; | 941 const uint32_t kMediaFlowSsrc = 0x2040608; |
949 const uint32_t kSenderSsrc = 0x10203; | 942 const uint32_t kSenderSsrc = 0x10203; |
950 | 943 |
951 rtcp::Tmmbr tmmbr; | 944 rtcp::Tmmbr tmmbr; |
952 tmmbr.From(kSenderSsrc); | 945 tmmbr.From(kSenderSsrc); |
953 // This SSRC is not what we are sending. | 946 // This SSRC is not what we are sending. |
954 tmmbr.WithTmmbr(rtcp::TmmbItem(kMediaFlowSsrc + 1, 30000, 0)); | 947 tmmbr.WithTmmbr(rtcp::TmmbItem(kMediaFlowSsrc + 1, 30000, 0)); |
955 | 948 |
956 rtcp::SenderReport sr; | 949 rtcp::SenderReport sr; |
957 sr.From(kSenderSsrc); | 950 sr.From(kSenderSsrc); |
958 sr.Append(&tmmbr); | 951 sr.Append(&tmmbr); |
959 rtc::Buffer packet = sr.Build(); | |
960 | 952 |
961 std::set<uint32_t> ssrcs; | 953 SetSsrc(kMediaFlowSsrc); |
962 ssrcs.insert(kMediaFlowSsrc); | 954 EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _)); |
963 rtcp_receiver_->SetSsrcs(kMediaFlowSsrc, ssrcs); | 955 EXPECT_CALL(bandwidth_observer_, OnReceivedEstimatedBitrate(_)).Times(0); |
964 EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size())); | 956 InjectPacket(sr); |
965 EXPECT_EQ(0, rtcp_receiver_->TMMBRReceived(0, 0, nullptr)); | 957 EXPECT_EQ(0, rtcp_receiver_->TMMBRReceived(0, 0, nullptr)); |
966 } | 958 } |
967 | 959 |
968 TEST_F(RtcpReceiverTest, TmmbrPacketZeroRateIgnored) { | 960 TEST_F(RtcpReceiverTest, TmmbrPacketZeroRateIgnored) { |
969 const uint32_t kMediaFlowSsrc = 0x2040608; | 961 const uint32_t kMediaFlowSsrc = 0x2040608; |
970 const uint32_t kSenderSsrc = 0x10203; | 962 const uint32_t kSenderSsrc = 0x10203; |
971 std::set<uint32_t> ssrcs; | 963 SetSsrc(kMediaFlowSsrc); |
972 ssrcs.insert(kMediaFlowSsrc); // Matches "media source" above. | |
973 rtcp_receiver_->SetSsrcs(kMediaFlowSsrc, ssrcs); | |
974 | 964 |
975 rtcp::Tmmbr tmmbr; | 965 rtcp::Tmmbr tmmbr; |
976 tmmbr.From(kSenderSsrc); | 966 tmmbr.From(kSenderSsrc); |
977 tmmbr.WithTmmbr(rtcp::TmmbItem(kMediaFlowSsrc, 0, 0)); | 967 tmmbr.WithTmmbr(rtcp::TmmbItem(kMediaFlowSsrc, 0, 0)); |
978 | 968 |
979 rtcp::SenderReport sr; | 969 rtcp::SenderReport sr; |
980 sr.From(kSenderSsrc); | 970 sr.From(kSenderSsrc); |
981 sr.Append(&tmmbr); | 971 sr.Append(&tmmbr); |
982 rtc::Buffer packet = sr.Build(); | 972 EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _)); |
983 | 973 EXPECT_CALL(bandwidth_observer_, OnReceivedEstimatedBitrate(_)).Times(0); |
984 EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size())); | 974 InjectPacket(sr); |
985 EXPECT_EQ(0, rtcp_receiver_->TMMBRReceived(0, 0, nullptr)); | 975 EXPECT_EQ(0, rtcp_receiver_->TMMBRReceived(0, 0, nullptr)); |
986 } | 976 } |
987 | 977 |
988 TEST_F(RtcpReceiverTest, TmmbrThreeConstraintsTimeOut) { | 978 TEST_F(RtcpReceiverTest, TmmbrThreeConstraintsTimeOut) { |
989 const uint32_t kMediaFlowSsrc = 0x2040608; | 979 const uint32_t kMediaFlowSsrc = 0x2040608; |
990 const uint32_t kSenderSsrc = 0x10203; | 980 const uint32_t kSenderSsrc = 0x10203; |
991 std::set<uint32_t> ssrcs; | 981 SetSsrc(kMediaFlowSsrc); |
992 ssrcs.insert(kMediaFlowSsrc); // Matches "media source" above. | |
993 rtcp_receiver_->SetSsrcs(kMediaFlowSsrc, ssrcs); | |
994 | 982 |
995 // Inject 3 packets "from" kSenderSsrc, kSenderSsrc+1, kSenderSsrc+2. | 983 // Inject 3 packets "from" kSenderSsrc, kSenderSsrc+1, kSenderSsrc+2. |
996 // The times of arrival are starttime + 0, starttime + 5 and starttime + 10. | 984 // The times of arrival are starttime + 0, starttime + 5 and starttime + 10. |
997 for (uint32_t ssrc = kSenderSsrc; ssrc < kSenderSsrc + 3; ++ssrc) { | 985 for (uint32_t ssrc = kSenderSsrc; ssrc < kSenderSsrc + 3; ++ssrc) { |
998 rtcp::Tmmbr tmmbr; | 986 rtcp::Tmmbr tmmbr; |
999 tmmbr.From(ssrc); | 987 tmmbr.From(ssrc); |
1000 tmmbr.WithTmmbr(rtcp::TmmbItem(kMediaFlowSsrc, 30000, 0)); | 988 tmmbr.WithTmmbr(rtcp::TmmbItem(kMediaFlowSsrc, 30000, 0)); |
1001 | 989 |
1002 rtcp::SenderReport sr; | 990 rtcp::SenderReport sr; |
1003 sr.From(ssrc); | 991 sr.From(ssrc); |
1004 sr.Append(&tmmbr); | 992 sr.Append(&tmmbr); |
1005 rtc::Buffer packet = sr.Build(); | 993 EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _)); |
1006 EXPECT_EQ(0, InjectRtcpPacket(packet.data(), packet.size())); | 994 EXPECT_CALL(bandwidth_observer_, OnReceivedEstimatedBitrate(_)); |
| 995 InjectPacket(sr); |
1007 // 5 seconds between each packet. | 996 // 5 seconds between each packet. |
1008 system_clock_.AdvanceTimeMilliseconds(5000); | 997 system_clock_.AdvanceTimeMilliseconds(5000); |
1009 } | 998 } |
1010 // It is now starttime + 15. | 999 // It is now starttime + 15. |
1011 EXPECT_EQ(3, rtcp_receiver_->TMMBRReceived(0, 0, nullptr)); | 1000 EXPECT_EQ(3, rtcp_receiver_->TMMBRReceived(0, 0, nullptr)); |
1012 TMMBRSet candidate_set; | 1001 TMMBRSet candidate_set; |
1013 candidate_set.VerifyAndAllocateSet(3); | 1002 candidate_set.VerifyAndAllocateSet(3); |
1014 EXPECT_EQ(3, rtcp_receiver_->TMMBRReceived(3, 0, &candidate_set)); | 1003 EXPECT_EQ(3, rtcp_receiver_->TMMBRReceived(3, 0, &candidate_set)); |
1015 EXPECT_LT(0U, candidate_set.Tmmbr(0)); | 1004 EXPECT_LT(0U, candidate_set.Tmmbr(0)); |
1016 // We expect the timeout to be 25 seconds. Advance the clock by 12 | 1005 // We expect the timeout to be 25 seconds. Advance the clock by 12 |
1017 // seconds, timing out the first packet. | 1006 // seconds, timing out the first packet. |
1018 system_clock_.AdvanceTimeMilliseconds(12000); | 1007 system_clock_.AdvanceTimeMilliseconds(12000); |
1019 // Odd behaviour: Just counting them does not trigger the timeout. | 1008 // Odd behaviour: Just counting them does not trigger the timeout. |
1020 EXPECT_EQ(3, rtcp_receiver_->TMMBRReceived(0, 0, nullptr)); | 1009 EXPECT_EQ(3, rtcp_receiver_->TMMBRReceived(0, 0, nullptr)); |
1021 EXPECT_EQ(2, rtcp_receiver_->TMMBRReceived(3, 0, &candidate_set)); | 1010 EXPECT_EQ(2, rtcp_receiver_->TMMBRReceived(3, 0, &candidate_set)); |
1022 EXPECT_EQ(kSenderSsrc + 1, candidate_set.Ssrc(0)); | 1011 EXPECT_EQ(kSenderSsrc + 1, candidate_set.Ssrc(0)); |
1023 } | 1012 } |
1024 | 1013 |
1025 TEST_F(RtcpReceiverTest, Callbacks) { | 1014 TEST_F(RtcpReceiverTest, Callbacks) { |
1026 class RtcpCallbackImpl : public RtcpStatisticsCallback { | 1015 MockRtcpCallbackImpl callback; |
1027 public: | |
1028 RtcpCallbackImpl() : RtcpStatisticsCallback(), ssrc_(0) {} | |
1029 virtual ~RtcpCallbackImpl() {} | |
1030 | |
1031 void StatisticsUpdated(const RtcpStatistics& statistics, | |
1032 uint32_t ssrc) override { | |
1033 stats_ = statistics; | |
1034 ssrc_ = ssrc; | |
1035 } | |
1036 | |
1037 void CNameChanged(const char* cname, uint32_t ssrc) override {} | |
1038 | |
1039 bool Matches(uint32_t ssrc, uint32_t extended_max, uint8_t fraction_loss, | |
1040 uint32_t cumulative_loss, uint32_t jitter) { | |
1041 return ssrc_ == ssrc && | |
1042 stats_.fraction_lost == fraction_loss && | |
1043 stats_.cumulative_lost == cumulative_loss && | |
1044 stats_.extended_max_sequence_number == extended_max && | |
1045 stats_.jitter == jitter; | |
1046 } | |
1047 | |
1048 RtcpStatistics stats_; | |
1049 uint32_t ssrc_; | |
1050 } callback; | |
1051 | 1016 |
1052 rtcp_receiver_->RegisterRtcpStatisticsCallback(&callback); | 1017 rtcp_receiver_->RegisterRtcpStatisticsCallback(&callback); |
1053 | 1018 |
1054 const uint32_t kSenderSsrc = 0x10203; | 1019 const uint32_t kSenderSsrc = 0x10203; |
1055 const uint32_t kSourceSsrc = 0x123456; | 1020 const uint32_t kSourceSsrc = 0x123456; |
1056 const uint8_t kFractionLoss = 3; | 1021 const uint8_t kFractionLoss = 3; |
1057 const uint32_t kCumulativeLoss = 7; | 1022 const uint32_t kCumulativeLoss = 7; |
1058 const uint32_t kJitter = 9; | 1023 const uint32_t kJitter = 9; |
1059 const uint16_t kSequenceNumber = 1234; | 1024 const uint16_t kSequenceNumber = 1234; |
1060 | 1025 |
1061 std::set<uint32_t> ssrcs; | 1026 SetSsrc(kSourceSsrc); |
1062 ssrcs.insert(kSourceSsrc); | |
1063 rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs); | |
1064 | 1027 |
1065 // First packet, all numbers should just propagate. | 1028 // First packet, all numbers should just propagate. |
1066 rtcp::ReportBlock rb1; | 1029 rtcp::ReportBlock rb1; |
1067 rb1.To(kSourceSsrc); | 1030 rb1.To(kSourceSsrc); |
1068 rb1.WithExtHighestSeqNum(kSequenceNumber); | 1031 rb1.WithExtHighestSeqNum(kSequenceNumber); |
1069 rb1.WithFractionLost(kFractionLoss); | 1032 rb1.WithFractionLost(kFractionLoss); |
1070 rb1.WithCumulativeLost(kCumulativeLoss); | 1033 rb1.WithCumulativeLost(kCumulativeLoss); |
1071 rb1.WithJitter(kJitter); | 1034 rb1.WithJitter(kJitter); |
1072 | 1035 |
1073 rtcp::ReceiverReport rr1; | 1036 rtcp::ReceiverReport rr1; |
1074 rr1.From(kSenderSsrc); | 1037 rr1.From(kSenderSsrc); |
1075 rr1.WithReportBlock(rb1); | 1038 rr1.WithReportBlock(rb1); |
1076 rtc::Buffer p1 = rr1.Build(); | 1039 EXPECT_CALL( |
1077 EXPECT_EQ(0, InjectRtcpPacket(p1.data(), p1.size())); | 1040 callback, |
1078 EXPECT_TRUE(callback.Matches(kSourceSsrc, kSequenceNumber, kFractionLoss, | 1041 StatisticsUpdated( |
1079 kCumulativeLoss, kJitter)); | 1042 AllOf(Field(&RtcpStatistics::fraction_lost, kFractionLoss), |
| 1043 Field(&RtcpStatistics::cumulative_lost, kCumulativeLoss), |
| 1044 Field(&RtcpStatistics::extended_max_sequence_number, |
| 1045 kSequenceNumber), |
| 1046 Field(&RtcpStatistics::jitter, kJitter)), |
| 1047 kSourceSsrc)); |
| 1048 EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _)); |
| 1049 InjectPacket(rr1); |
1080 | 1050 |
1081 rtcp_receiver_->RegisterRtcpStatisticsCallback(nullptr); | 1051 rtcp_receiver_->RegisterRtcpStatisticsCallback(nullptr); |
1082 | 1052 |
1083 // Add arbitrary numbers, callback should not be called (retain old values). | 1053 // Add arbitrary numbers, callback should not be called. |
1084 rtcp::ReportBlock rb2; | 1054 rtcp::ReportBlock rb2; |
1085 rb2.To(kSourceSsrc); | 1055 rb2.To(kSourceSsrc); |
1086 rb2.WithExtHighestSeqNum(kSequenceNumber + 1); | 1056 rb2.WithExtHighestSeqNum(kSequenceNumber + 1); |
1087 rb2.WithFractionLost(42); | 1057 rb2.WithFractionLost(42); |
1088 rb2.WithCumulativeLost(137); | 1058 rb2.WithCumulativeLost(137); |
1089 rb2.WithJitter(4711); | 1059 rb2.WithJitter(4711); |
1090 | 1060 |
1091 rtcp::ReceiverReport rr2; | 1061 rtcp::ReceiverReport rr2; |
1092 rr2.From(kSenderSsrc); | 1062 rr2.From(kSenderSsrc); |
1093 rr2.WithReportBlock(rb2); | 1063 rr2.WithReportBlock(rb2); |
1094 rtc::Buffer p2 = rr2.Build(); | 1064 EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _)); |
1095 EXPECT_EQ(0, InjectRtcpPacket(p2.data(), p2.size())); | 1065 EXPECT_CALL(callback, StatisticsUpdated(_, _)).Times(0); |
1096 EXPECT_TRUE(callback.Matches(kSourceSsrc, kSequenceNumber, kFractionLoss, | 1066 InjectPacket(rr2); |
1097 kCumulativeLoss, kJitter)); | |
1098 } | 1067 } |
1099 | 1068 |
1100 TEST_F(RtcpReceiverTest, ReceivesTransportFeedback) { | 1069 TEST_F(RtcpReceiverTest, ReceivesTransportFeedback) { |
| 1070 using rtcp::TransportFeedback; |
1101 const uint32_t kSenderSsrc = 0x10203; | 1071 const uint32_t kSenderSsrc = 0x10203; |
1102 const uint32_t kSourceSsrc = 0x123456; | 1072 const uint32_t kSourceSsrc = 0x123456; |
1103 | 1073 |
1104 std::set<uint32_t> ssrcs; | 1074 SetSsrc(kSourceSsrc); |
1105 ssrcs.insert(kSourceSsrc); | |
1106 rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs); | |
1107 | 1075 |
1108 rtcp::TransportFeedback packet; | 1076 TransportFeedback packet; |
1109 packet.WithMediaSourceSsrc(kSourceSsrc); | 1077 packet.WithMediaSourceSsrc(kSourceSsrc); |
1110 packet.WithPacketSenderSsrc(kSenderSsrc); | 1078 packet.WithPacketSenderSsrc(kSenderSsrc); |
1111 packet.WithBase(1, 1000); | 1079 packet.WithBase(1, 1000); |
1112 packet.WithReceivedPacket(1, 1000); | 1080 packet.WithReceivedPacket(1, 1000); |
1113 | 1081 |
1114 rtc::Buffer built_packet = packet.Build(); | 1082 EXPECT_CALL( |
1115 | 1083 transport_feedback_observer_, |
1116 EXPECT_EQ(0, InjectRtcpPacket(built_packet.data(), built_packet.size())); | 1084 OnTransportFeedback(AllOf( |
1117 | 1085 Property(&TransportFeedback::GetMediaSourceSsrc, kSourceSsrc), |
1118 EXPECT_NE(0u, rtcp_packet_info_.rtcpPacketTypeFlags & kRtcpTransportFeedback); | 1086 Property(&TransportFeedback::GetPacketSenderSsrc, kSenderSsrc)))); |
1119 EXPECT_TRUE(rtcp_packet_info_.transport_feedback_.get() != nullptr); | 1087 InjectPacket(packet); |
1120 } | 1088 } |
1121 | 1089 |
1122 TEST_F(RtcpReceiverTest, HandlesInvalidTransportFeedback) { | 1090 TEST_F(RtcpReceiverTest, HandlesInvalidTransportFeedback) { |
1123 const uint32_t kSenderSsrc = 0x10203; | 1091 const uint32_t kSenderSsrc = 0x10203; |
1124 const uint32_t kSourceSsrc = 0x123456; | 1092 const uint32_t kSourceSsrc = 0x123456; |
1125 | 1093 |
1126 std::set<uint32_t> ssrcs; | 1094 SetSsrc(kSourceSsrc); |
1127 ssrcs.insert(kSourceSsrc); | |
1128 rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs); | |
1129 | 1095 |
1130 // Send a compound packet with a TransportFeedback followed by something else. | 1096 // Send a compound packet with a TransportFeedback followed by something else. |
1131 rtcp::TransportFeedback packet; | 1097 rtcp::TransportFeedback packet; |
1132 packet.WithMediaSourceSsrc(kSourceSsrc); | 1098 packet.WithMediaSourceSsrc(kSourceSsrc); |
1133 packet.WithPacketSenderSsrc(kSenderSsrc); | 1099 packet.WithPacketSenderSsrc(kSenderSsrc); |
1134 packet.WithBase(1, 1000); | 1100 packet.WithBase(1, 1000); |
1135 packet.WithReceivedPacket(1, 1000); | 1101 packet.WithReceivedPacket(1, 1000); |
1136 | 1102 |
1137 static uint32_t kBitrateBps = 50000; | 1103 static uint32_t kBitrateBps = 50000; |
1138 rtcp::Remb remb; | 1104 rtcp::Remb remb; |
1139 remb.From(kSourceSsrc); | 1105 remb.From(kSourceSsrc); |
1140 remb.WithBitrateBps(kBitrateBps); | 1106 remb.WithBitrateBps(kBitrateBps); |
1141 packet.Append(&remb); | 1107 packet.Append(&remb); |
1142 | 1108 |
1143 rtc::Buffer built_packet = packet.Build(); | 1109 rtc::Buffer built_packet = packet.Build(); |
1144 | 1110 |
1145 // Modify the TransportFeedback packet so that it is invalid. | 1111 // Modify the TransportFeedback packet so that it is invalid. |
1146 const size_t kStatusCountOffset = 14; | 1112 const size_t kStatusCountOffset = 14; |
1147 ByteWriter<uint16_t>::WriteBigEndian( | 1113 ByteWriter<uint16_t>::WriteBigEndian( |
1148 &built_packet.data()[kStatusCountOffset], 42); | 1114 &built_packet.data()[kStatusCountOffset], 42); |
1149 | 1115 |
1150 EXPECT_EQ(0, InjectRtcpPacket(built_packet.data(), built_packet.size())); | 1116 // Explicetly repeat that no tansport feedback callback is expected. |
1151 | 1117 EXPECT_CALL(transport_feedback_observer_, OnTransportFeedback(_)).Times(0); |
1152 // Transport feedback should be ignored, but next packet should work. | 1118 // But remb should be processed and cause a callback |
1153 EXPECT_EQ(0u, rtcp_packet_info_.rtcpPacketTypeFlags & kRtcpTransportFeedback); | 1119 EXPECT_CALL(bandwidth_observer_, OnReceivedEstimatedBitrate(kBitrateBps)); |
1154 EXPECT_NE(0u, rtcp_packet_info_.rtcpPacketTypeFlags & kRtcpRemb); | 1120 EXPECT_TRUE(rtcp_receiver_->IncomingPacket(built_packet.data(), |
1155 EXPECT_EQ(kBitrateBps, rtcp_packet_info_.receiverEstimatedMaxBitrate); | 1121 built_packet.size())); |
1156 } | 1122 } |
1157 | 1123 |
1158 } // Anonymous namespace | 1124 TEST_F(RtcpReceiverTest, Nack) { |
| 1125 const uint32_t kSenderSsrc = 0x10203; |
| 1126 const uint32_t kSourceSsrc = 0x123456; |
| 1127 const uint16_t kNackList1[] = {1, 2, 3, 5}; |
| 1128 const size_t kNackListLength1 = std::end(kNackList1) - std::begin(kNackList1); |
| 1129 const uint16_t kNackList2[] = {5, 7, 30, 40}; |
| 1130 const size_t kNackListLength2 = std::end(kNackList2) - std::begin(kNackList2); |
| 1131 SetSsrc(kSourceSsrc); |
1159 | 1132 |
| 1133 rtcp::Nack nack; |
| 1134 nack.From(kSenderSsrc); |
| 1135 nack.To(kSourceSsrc); |
| 1136 nack.WithList(kNackList1, kNackListLength1); |
| 1137 |
| 1138 EXPECT_CALL( |
| 1139 packet_type_counter_observer_, |
| 1140 RtcpPacketTypesCounterUpdated( |
| 1141 kSourceSsrc, |
| 1142 AllOf(Field(&RtcpPacketTypeCounter::nack_requests, 4), |
| 1143 Field(&RtcpPacketTypeCounter::unique_nack_requests, 4)))); |
| 1144 InjectPacket(nack); |
| 1145 |
| 1146 rtcp::Nack nack2; |
| 1147 nack2.From(kSenderSsrc); |
| 1148 nack2.To(kSourceSsrc); |
| 1149 nack2.WithList(kNackList2, kNackListLength2); |
| 1150 EXPECT_CALL( |
| 1151 packet_type_counter_observer_, |
| 1152 RtcpPacketTypesCounterUpdated( |
| 1153 kSourceSsrc, |
| 1154 AllOf(Field(&RtcpPacketTypeCounter::nack_requests, 8), |
| 1155 Field(&RtcpPacketTypeCounter::unique_nack_requests, 7)))); |
| 1156 InjectPacket(nack2); |
| 1157 } |
| 1158 |
| 1159 TEST_F(RtcpReceiverTest, NackNotForUsIgnored) { |
| 1160 const uint32_t kSenderSsrc = 0x10203; |
| 1161 const uint32_t kSourceSsrc = 0x123456; |
| 1162 const uint16_t kNackList1[] = {1, 2, 3, 5}; |
| 1163 const size_t kNackListLength1 = std::end(kNackList1) - std::begin(kNackList1); |
| 1164 SetSsrc(kSourceSsrc); |
| 1165 |
| 1166 rtcp::Nack nack; |
| 1167 nack.From(kSenderSsrc); |
| 1168 nack.To(kSourceSsrc + 1); |
| 1169 nack.WithList(kNackList1, kNackListLength1); |
| 1170 |
| 1171 EXPECT_CALL(packet_type_counter_observer_, |
| 1172 RtcpPacketTypesCounterUpdated( |
| 1173 _, Field(&RtcpPacketTypeCounter::nack_requests, 0))); |
| 1174 InjectPacket(nack); |
| 1175 } |
| 1176 // TODO(danilchap): Add test for SendReportRequest experemental packet. |
1160 } // namespace webrtc | 1177 } // namespace webrtc |
OLD | NEW |