OLD | NEW |
1 /* | 1 /* |
2 * Copyright (c) 2015 The WebRTC project authors. All Rights Reserved. | 2 * Copyright (c) 2015 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 #include "webrtc/modules/pacing/packet_router.h" | 11 #include "webrtc/modules/pacing/packet_router.h" |
12 #include "webrtc/modules/remote_bitrate_estimator/remote_estimator_proxy.h" | 12 #include "webrtc/modules/remote_bitrate_estimator/remote_estimator_proxy.h" |
13 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h" | 13 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h" |
14 #include "webrtc/system_wrappers/include/clock.h" | 14 #include "webrtc/system_wrappers/include/clock.h" |
15 #include "webrtc/test/gmock.h" | 15 #include "webrtc/test/gmock.h" |
16 #include "webrtc/test/gtest.h" | 16 #include "webrtc/test/gtest.h" |
17 | 17 |
18 using ::testing::_; | 18 using ::testing::_; |
19 using ::testing::InSequence; | 19 using ::testing::ElementsAre; |
20 using ::testing::Invoke; | 20 using ::testing::Invoke; |
21 using ::testing::Return; | 21 using ::testing::Return; |
22 | 22 |
23 namespace webrtc { | 23 namespace webrtc { |
| 24 namespace { |
| 25 |
| 26 constexpr size_t kDefaultPacketSize = 100; |
| 27 constexpr uint32_t kMediaSsrc = 456; |
| 28 constexpr uint16_t kBaseSeq = 10; |
| 29 constexpr int64_t kBaseTimeMs = 123; |
| 30 constexpr int64_t kMaxSmallDeltaMs = |
| 31 (rtcp::TransportFeedback::kDeltaScaleFactor * 0xFF) / 1000; |
| 32 |
| 33 std::vector<uint16_t> SequenceNumbers( |
| 34 const rtcp::TransportFeedback& feedback_packet) { |
| 35 std::vector<uint16_t> sequence_numbers; |
| 36 for (const auto& rtp_packet_received : feedback_packet.GetReceivedPackets()) { |
| 37 sequence_numbers.push_back(rtp_packet_received.sequence_number()); |
| 38 } |
| 39 return sequence_numbers; |
| 40 } |
| 41 |
| 42 std::vector<int64_t> TimestampsMs( |
| 43 const rtcp::TransportFeedback& feedback_packet) { |
| 44 std::vector<int64_t> timestamps; |
| 45 int64_t timestamp_us = feedback_packet.GetBaseTimeUs(); |
| 46 for (const auto& rtp_packet_received : feedback_packet.GetReceivedPackets()) { |
| 47 timestamp_us += rtp_packet_received.delta_us(); |
| 48 timestamps.push_back(timestamp_us / 1000); |
| 49 } |
| 50 return timestamps; |
| 51 } |
24 | 52 |
25 class MockPacketRouter : public PacketRouter { | 53 class MockPacketRouter : public PacketRouter { |
26 public: | 54 public: |
27 MOCK_METHOD1(SendFeedback, bool(rtcp::TransportFeedback* packet)); | 55 MOCK_METHOD1(SendFeedback, bool(rtcp::TransportFeedback* feedback_packet)); |
28 }; | 56 }; |
29 | 57 |
30 class RemoteEstimatorProxyTest : public ::testing::Test { | 58 class RemoteEstimatorProxyTest : public ::testing::Test { |
31 public: | 59 public: |
32 RemoteEstimatorProxyTest() : clock_(0), proxy_(&clock_, &router_) {} | 60 RemoteEstimatorProxyTest() : clock_(0), proxy_(&clock_, &router_) {} |
33 | 61 |
34 protected: | 62 protected: |
35 void IncomingPacket(uint16_t seq, int64_t time_ms) { | 63 void IncomingPacket(uint16_t seq, int64_t time_ms) { |
36 RTPHeader header; | 64 RTPHeader header; |
37 header.extension.hasTransportSequenceNumber = true; | 65 header.extension.hasTransportSequenceNumber = true; |
38 header.extension.transportSequenceNumber = seq; | 66 header.extension.transportSequenceNumber = seq; |
39 header.ssrc = kMediaSsrc; | 67 header.ssrc = kMediaSsrc; |
40 proxy_.IncomingPacket(time_ms, kDefaultPacketSize, header); | 68 proxy_.IncomingPacket(time_ms, kDefaultPacketSize, header); |
41 } | 69 } |
42 | 70 |
43 void Process() { | 71 void Process() { |
44 clock_.AdvanceTimeMilliseconds( | 72 clock_.AdvanceTimeMilliseconds( |
45 RemoteEstimatorProxy::kDefaultSendIntervalMs); | 73 RemoteEstimatorProxy::kDefaultSendIntervalMs); |
46 proxy_.Process(); | 74 proxy_.Process(); |
47 } | 75 } |
48 | 76 |
49 SimulatedClock clock_; | 77 SimulatedClock clock_; |
50 testing::StrictMock<MockPacketRouter> router_; | 78 testing::StrictMock<MockPacketRouter> router_; |
51 RemoteEstimatorProxy proxy_; | 79 RemoteEstimatorProxy proxy_; |
52 | |
53 const size_t kDefaultPacketSize = 100; | |
54 const uint32_t kMediaSsrc = 456; | |
55 const uint16_t kBaseSeq = 10; | |
56 const int64_t kBaseTimeMs = 123; | |
57 const int64_t kMaxSmallDeltaMs = | |
58 (rtcp::TransportFeedback::kDeltaScaleFactor * 0xFF) / 1000; | |
59 }; | 80 }; |
60 | 81 |
61 TEST_F(RemoteEstimatorProxyTest, SendsSinglePacketFeedback) { | 82 TEST_F(RemoteEstimatorProxyTest, SendsSinglePacketFeedback) { |
62 IncomingPacket(kBaseSeq, kBaseTimeMs); | 83 IncomingPacket(kBaseSeq, kBaseTimeMs); |
63 | 84 |
64 EXPECT_CALL(router_, SendFeedback(_)) | 85 EXPECT_CALL(router_, SendFeedback(_)) |
65 .Times(1) | 86 .WillOnce(Invoke([](rtcp::TransportFeedback* feedback_packet) { |
66 .WillOnce(Invoke([this](rtcp::TransportFeedback* packet) { | 87 EXPECT_EQ(kBaseSeq, feedback_packet->GetBaseSequence()); |
67 packet->Build(); | 88 EXPECT_EQ(kMediaSsrc, feedback_packet->media_ssrc()); |
68 EXPECT_EQ(kBaseSeq, packet->GetBaseSequence()); | |
69 EXPECT_EQ(kMediaSsrc, packet->media_ssrc()); | |
70 | 89 |
71 std::vector<rtcp::TransportFeedback::StatusSymbol> status_vec = | 90 EXPECT_THAT(SequenceNumbers(*feedback_packet), ElementsAre(kBaseSeq)); |
72 packet->GetStatusVector(); | 91 EXPECT_THAT(TimestampsMs(*feedback_packet), ElementsAre(kBaseTimeMs)); |
73 EXPECT_EQ(1u, status_vec.size()); | |
74 EXPECT_EQ(rtcp::TransportFeedback::StatusSymbol::kReceivedSmallDelta, | |
75 status_vec[0]); | |
76 std::vector<int64_t> delta_vec = packet->GetReceiveDeltasUs(); | |
77 EXPECT_EQ(1u, delta_vec.size()); | |
78 EXPECT_EQ(kBaseTimeMs, (packet->GetBaseTimeUs() + delta_vec[0]) / 1000); | |
79 return true; | 92 return true; |
80 })); | 93 })); |
81 | 94 |
82 Process(); | 95 Process(); |
83 } | 96 } |
84 | 97 |
85 TEST_F(RemoteEstimatorProxyTest, DuplicatedPackets) { | 98 TEST_F(RemoteEstimatorProxyTest, DuplicatedPackets) { |
86 IncomingPacket(kBaseSeq, kBaseTimeMs); | 99 IncomingPacket(kBaseSeq, kBaseTimeMs); |
87 IncomingPacket(kBaseSeq, kBaseTimeMs + 1000); | 100 IncomingPacket(kBaseSeq, kBaseTimeMs + 1000); |
88 | 101 |
89 EXPECT_CALL(router_, SendFeedback(_)) | 102 EXPECT_CALL(router_, SendFeedback(_)) |
90 .Times(1) | 103 .WillOnce(Invoke([](rtcp::TransportFeedback* feedback_packet) { |
91 .WillOnce(Invoke([this](rtcp::TransportFeedback* packet) { | 104 EXPECT_EQ(kBaseSeq, feedback_packet->GetBaseSequence()); |
92 packet->Build(); | 105 EXPECT_EQ(kMediaSsrc, feedback_packet->media_ssrc()); |
93 EXPECT_EQ(kBaseSeq, packet->GetBaseSequence()); | |
94 EXPECT_EQ(kMediaSsrc, packet->media_ssrc()); | |
95 | 106 |
96 std::vector<rtcp::TransportFeedback::StatusSymbol> status_vec = | 107 EXPECT_THAT(SequenceNumbers(*feedback_packet), ElementsAre(kBaseSeq)); |
97 packet->GetStatusVector(); | 108 EXPECT_THAT(TimestampsMs(*feedback_packet), ElementsAre(kBaseTimeMs)); |
98 EXPECT_EQ(1u, status_vec.size()); | |
99 EXPECT_EQ(rtcp::TransportFeedback::StatusSymbol::kReceivedSmallDelta, | |
100 status_vec[0]); | |
101 std::vector<int64_t> delta_vec = packet->GetReceiveDeltasUs(); | |
102 EXPECT_EQ(1u, delta_vec.size()); | |
103 EXPECT_EQ(kBaseTimeMs, (packet->GetBaseTimeUs() + delta_vec[0]) / 1000); | |
104 return true; | 109 return true; |
105 })); | 110 })); |
106 | 111 |
107 Process(); | 112 Process(); |
108 } | 113 } |
109 | 114 |
110 TEST_F(RemoteEstimatorProxyTest, FeedbackWithMissingStart) { | 115 TEST_F(RemoteEstimatorProxyTest, FeedbackWithMissingStart) { |
111 // First feedback. | 116 // First feedback. |
112 IncomingPacket(kBaseSeq, kBaseTimeMs); | 117 IncomingPacket(kBaseSeq, kBaseTimeMs); |
113 IncomingPacket(kBaseSeq + 1, kBaseTimeMs + 1000); | 118 IncomingPacket(kBaseSeq + 1, kBaseTimeMs + 1000); |
114 EXPECT_CALL(router_, SendFeedback(_)).Times(1).WillOnce(Return(true)); | 119 EXPECT_CALL(router_, SendFeedback(_)).WillOnce(Return(true)); |
115 Process(); | 120 Process(); |
116 | 121 |
117 // Second feedback starts with a missing packet (DROP kBaseSeq + 2). | 122 // Second feedback starts with a missing packet (DROP kBaseSeq + 2). |
118 IncomingPacket(kBaseSeq + 3, kBaseTimeMs + 3000); | 123 IncomingPacket(kBaseSeq + 3, kBaseTimeMs + 3000); |
119 | 124 |
120 EXPECT_CALL(router_, SendFeedback(_)) | 125 EXPECT_CALL(router_, SendFeedback(_)) |
121 .Times(1) | 126 .WillOnce(Invoke([](rtcp::TransportFeedback* feedback_packet) { |
122 .WillOnce(Invoke([this](rtcp::TransportFeedback* packet) { | 127 EXPECT_EQ(kBaseSeq + 2, feedback_packet->GetBaseSequence()); |
123 packet->Build(); | 128 EXPECT_EQ(kMediaSsrc, feedback_packet->media_ssrc()); |
124 EXPECT_EQ(kBaseSeq + 2, packet->GetBaseSequence()); | |
125 EXPECT_EQ(kMediaSsrc, packet->media_ssrc()); | |
126 | 129 |
127 std::vector<rtcp::TransportFeedback::StatusSymbol> status_vec = | 130 EXPECT_THAT(SequenceNumbers(*feedback_packet), |
128 packet->GetStatusVector(); | 131 ElementsAre(kBaseSeq + 3)); |
129 EXPECT_EQ(2u, status_vec.size()); | 132 EXPECT_THAT(TimestampsMs(*feedback_packet), |
130 EXPECT_EQ(rtcp::TransportFeedback::StatusSymbol::kNotReceived, | 133 ElementsAre(kBaseTimeMs + 3000)); |
131 status_vec[0]); | |
132 EXPECT_EQ(rtcp::TransportFeedback::StatusSymbol::kReceivedSmallDelta, | |
133 status_vec[1]); | |
134 std::vector<int64_t> delta_vec = packet->GetReceiveDeltasUs(); | |
135 EXPECT_EQ(1u, delta_vec.size()); | |
136 EXPECT_EQ(kBaseTimeMs + 3000, | |
137 (packet->GetBaseTimeUs() + delta_vec[0]) / 1000); | |
138 return true; | 134 return true; |
139 })); | 135 })); |
140 | 136 |
141 Process(); | 137 Process(); |
142 } | 138 } |
143 | 139 |
144 TEST_F(RemoteEstimatorProxyTest, SendsFeedbackWithVaryingDeltas) { | 140 TEST_F(RemoteEstimatorProxyTest, SendsFeedbackWithVaryingDeltas) { |
145 IncomingPacket(kBaseSeq, kBaseTimeMs); | 141 IncomingPacket(kBaseSeq, kBaseTimeMs); |
146 IncomingPacket(kBaseSeq + 1, kBaseTimeMs + kMaxSmallDeltaMs); | 142 IncomingPacket(kBaseSeq + 1, kBaseTimeMs + kMaxSmallDeltaMs); |
147 IncomingPacket(kBaseSeq + 2, kBaseTimeMs + (2 * kMaxSmallDeltaMs) + 1); | 143 IncomingPacket(kBaseSeq + 2, kBaseTimeMs + (2 * kMaxSmallDeltaMs) + 1); |
148 | 144 |
149 EXPECT_CALL(router_, SendFeedback(_)) | 145 EXPECT_CALL(router_, SendFeedback(_)) |
150 .Times(1) | 146 .WillOnce(Invoke([](rtcp::TransportFeedback* feedback_packet) { |
151 .WillOnce(Invoke([this](rtcp::TransportFeedback* packet) { | 147 EXPECT_EQ(kBaseSeq, feedback_packet->GetBaseSequence()); |
152 packet->Build(); | 148 EXPECT_EQ(kMediaSsrc, feedback_packet->media_ssrc()); |
153 EXPECT_EQ(kBaseSeq, packet->GetBaseSequence()); | |
154 EXPECT_EQ(kMediaSsrc, packet->media_ssrc()); | |
155 | 149 |
156 std::vector<rtcp::TransportFeedback::StatusSymbol> status_vec = | 150 EXPECT_THAT(SequenceNumbers(*feedback_packet), |
157 packet->GetStatusVector(); | 151 ElementsAre(kBaseSeq, kBaseSeq + 1, kBaseSeq + 2)); |
158 EXPECT_EQ(3u, status_vec.size()); | 152 EXPECT_THAT(TimestampsMs(*feedback_packet), |
159 EXPECT_EQ(rtcp::TransportFeedback::StatusSymbol::kReceivedSmallDelta, | 153 ElementsAre(kBaseTimeMs, kBaseTimeMs + kMaxSmallDeltaMs, |
160 status_vec[0]); | 154 kBaseTimeMs + (2 * kMaxSmallDeltaMs) + 1)); |
161 EXPECT_EQ(rtcp::TransportFeedback::StatusSymbol::kReceivedSmallDelta, | |
162 status_vec[1]); | |
163 EXPECT_EQ(rtcp::TransportFeedback::StatusSymbol::kReceivedLargeDelta, | |
164 status_vec[2]); | |
165 | |
166 std::vector<int64_t> delta_vec = packet->GetReceiveDeltasUs(); | |
167 EXPECT_EQ(3u, delta_vec.size()); | |
168 EXPECT_EQ(kBaseTimeMs, (packet->GetBaseTimeUs() + delta_vec[0]) / 1000); | |
169 EXPECT_EQ(kMaxSmallDeltaMs, delta_vec[1] / 1000); | |
170 EXPECT_EQ(kMaxSmallDeltaMs + 1, delta_vec[2] / 1000); | |
171 return true; | 155 return true; |
172 })); | 156 })); |
173 | 157 |
174 Process(); | 158 Process(); |
175 } | 159 } |
176 | 160 |
177 TEST_F(RemoteEstimatorProxyTest, SendsFragmentedFeedback) { | 161 TEST_F(RemoteEstimatorProxyTest, SendsFragmentedFeedback) { |
178 const int64_t kTooLargeDelta = | 162 static constexpr int64_t kTooLargeDelta = |
179 rtcp::TransportFeedback::kDeltaScaleFactor * (1 << 16); | 163 rtcp::TransportFeedback::kDeltaScaleFactor * (1 << 16); |
180 | 164 |
181 IncomingPacket(kBaseSeq, kBaseTimeMs); | 165 IncomingPacket(kBaseSeq, kBaseTimeMs); |
182 IncomingPacket(kBaseSeq + 1, kBaseTimeMs + kTooLargeDelta); | 166 IncomingPacket(kBaseSeq + 1, kBaseTimeMs + kTooLargeDelta); |
183 | 167 |
184 InSequence s; | |
185 EXPECT_CALL(router_, SendFeedback(_)) | 168 EXPECT_CALL(router_, SendFeedback(_)) |
186 .Times(1) | 169 .WillOnce(Invoke([](rtcp::TransportFeedback* feedback_packet) { |
187 .WillOnce(Invoke([kTooLargeDelta, this](rtcp::TransportFeedback* packet) { | 170 EXPECT_EQ(kBaseSeq, feedback_packet->GetBaseSequence()); |
188 packet->Build(); | 171 EXPECT_EQ(kMediaSsrc, feedback_packet->media_ssrc()); |
189 EXPECT_EQ(kBaseSeq, packet->GetBaseSequence()); | |
190 EXPECT_EQ(kMediaSsrc, packet->media_ssrc()); | |
191 | 172 |
192 std::vector<rtcp::TransportFeedback::StatusSymbol> status_vec = | 173 EXPECT_THAT(SequenceNumbers(*feedback_packet), ElementsAre(kBaseSeq)); |
193 packet->GetStatusVector(); | 174 EXPECT_THAT(TimestampsMs(*feedback_packet), ElementsAre(kBaseTimeMs)); |
194 EXPECT_EQ(1u, status_vec.size()); | |
195 EXPECT_EQ(rtcp::TransportFeedback::StatusSymbol::kReceivedSmallDelta, | |
196 status_vec[0]); | |
197 std::vector<int64_t> delta_vec = packet->GetReceiveDeltasUs(); | |
198 EXPECT_EQ(1u, delta_vec.size()); | |
199 EXPECT_EQ(kBaseTimeMs, (packet->GetBaseTimeUs() + delta_vec[0]) / 1000); | |
200 return true; | 175 return true; |
201 })) | 176 })) |
202 .RetiresOnSaturation(); | 177 .WillOnce(Invoke([](rtcp::TransportFeedback* feedback_packet) { |
| 178 EXPECT_EQ(kBaseSeq + 1, feedback_packet->GetBaseSequence()); |
| 179 EXPECT_EQ(kMediaSsrc, feedback_packet->media_ssrc()); |
203 | 180 |
204 EXPECT_CALL(router_, SendFeedback(_)) | 181 EXPECT_THAT(SequenceNumbers(*feedback_packet), |
205 .Times(1) | 182 ElementsAre(kBaseSeq + 1)); |
206 .WillOnce(Invoke([kTooLargeDelta, this](rtcp::TransportFeedback* packet) { | 183 EXPECT_THAT(TimestampsMs(*feedback_packet), |
207 packet->Build(); | 184 ElementsAre(kBaseTimeMs + kTooLargeDelta)); |
208 EXPECT_EQ(kBaseSeq + 1, packet->GetBaseSequence()); | |
209 EXPECT_EQ(kMediaSsrc, packet->media_ssrc()); | |
210 | |
211 std::vector<rtcp::TransportFeedback::StatusSymbol> status_vec = | |
212 packet->GetStatusVector(); | |
213 EXPECT_EQ(1u, status_vec.size()); | |
214 EXPECT_EQ(rtcp::TransportFeedback::StatusSymbol::kReceivedSmallDelta, | |
215 status_vec[0]); | |
216 std::vector<int64_t> delta_vec = packet->GetReceiveDeltasUs(); | |
217 EXPECT_EQ(1u, delta_vec.size()); | |
218 EXPECT_EQ(kBaseTimeMs + kTooLargeDelta, | |
219 (packet->GetBaseTimeUs() + delta_vec[0]) / 1000); | |
220 return true; | 185 return true; |
221 })) | 186 })); |
222 .RetiresOnSaturation(); | |
223 | 187 |
224 Process(); | 188 Process(); |
225 } | 189 } |
226 | 190 |
227 TEST_F(RemoteEstimatorProxyTest, GracefullyHandlesReorderingAndWrap) { | 191 TEST_F(RemoteEstimatorProxyTest, GracefullyHandlesReorderingAndWrap) { |
228 const int64_t kDeltaMs = 1000; | 192 const int64_t kDeltaMs = 1000; |
229 const uint16_t kLargeSeq = 62762; | 193 const uint16_t kLargeSeq = 62762; |
230 IncomingPacket(kBaseSeq, kBaseTimeMs); | 194 IncomingPacket(kBaseSeq, kBaseTimeMs); |
231 IncomingPacket(kLargeSeq, kBaseTimeMs + kDeltaMs); | 195 IncomingPacket(kLargeSeq, kBaseTimeMs + kDeltaMs); |
232 | 196 |
233 EXPECT_CALL(router_, SendFeedback(_)) | 197 EXPECT_CALL(router_, SendFeedback(_)) |
234 .Times(1) | 198 .WillOnce(Invoke([](rtcp::TransportFeedback* feedback_packet) { |
235 .WillOnce(Invoke([this](rtcp::TransportFeedback* packet) { | 199 EXPECT_EQ(kBaseSeq, feedback_packet->GetBaseSequence()); |
236 packet->Build(); | 200 EXPECT_EQ(kMediaSsrc, feedback_packet->media_ssrc()); |
237 EXPECT_EQ(kBaseSeq, packet->GetBaseSequence()); | |
238 EXPECT_EQ(kMediaSsrc, packet->media_ssrc()); | |
239 | 201 |
240 std::vector<int64_t> delta_vec = packet->GetReceiveDeltasUs(); | 202 EXPECT_THAT(TimestampsMs(*feedback_packet), ElementsAre(kBaseTimeMs)); |
241 EXPECT_EQ(1u, delta_vec.size()); | |
242 EXPECT_EQ(kBaseTimeMs, (packet->GetBaseTimeUs() + delta_vec[0]) / 1000); | |
243 return true; | 203 return true; |
244 })); | 204 })); |
245 | 205 |
246 Process(); | 206 Process(); |
247 } | 207 } |
248 | 208 |
249 TEST_F(RemoteEstimatorProxyTest, ResendsTimestampsOnReordering) { | 209 TEST_F(RemoteEstimatorProxyTest, ResendsTimestampsOnReordering) { |
250 IncomingPacket(kBaseSeq, kBaseTimeMs); | 210 IncomingPacket(kBaseSeq, kBaseTimeMs); |
251 IncomingPacket(kBaseSeq + 2, kBaseTimeMs + 2); | 211 IncomingPacket(kBaseSeq + 2, kBaseTimeMs + 2); |
252 | 212 |
253 EXPECT_CALL(router_, SendFeedback(_)) | 213 EXPECT_CALL(router_, SendFeedback(_)) |
254 .Times(1) | 214 .WillOnce(Invoke([](rtcp::TransportFeedback* feedback_packet) { |
255 .WillOnce(Invoke([this](rtcp::TransportFeedback* packet) { | 215 EXPECT_EQ(kBaseSeq, feedback_packet->GetBaseSequence()); |
256 packet->Build(); | 216 EXPECT_EQ(kMediaSsrc, feedback_packet->media_ssrc()); |
257 EXPECT_EQ(kBaseSeq, packet->GetBaseSequence()); | |
258 EXPECT_EQ(kMediaSsrc, packet->media_ssrc()); | |
259 | 217 |
260 std::vector<int64_t> delta_vec = packet->GetReceiveDeltasUs(); | 218 EXPECT_THAT(SequenceNumbers(*feedback_packet), |
261 EXPECT_EQ(2u, delta_vec.size()); | 219 ElementsAre(kBaseSeq, kBaseSeq + 2)); |
262 EXPECT_EQ(kBaseTimeMs, (packet->GetBaseTimeUs() + delta_vec[0]) / 1000); | 220 EXPECT_THAT(TimestampsMs(*feedback_packet), |
263 EXPECT_EQ(2, delta_vec[1] / 1000); | 221 ElementsAre(kBaseTimeMs, kBaseTimeMs + 2)); |
264 return true; | 222 return true; |
265 })); | 223 })); |
266 | 224 |
267 Process(); | 225 Process(); |
268 | 226 |
269 IncomingPacket(kBaseSeq + 1, kBaseTimeMs + 1); | 227 IncomingPacket(kBaseSeq + 1, kBaseTimeMs + 1); |
270 | 228 |
271 EXPECT_CALL(router_, SendFeedback(_)) | 229 EXPECT_CALL(router_, SendFeedback(_)) |
272 .Times(1) | 230 .WillOnce(Invoke([](rtcp::TransportFeedback* feedback_packet) { |
273 .WillOnce(Invoke([this](rtcp::TransportFeedback* packet) { | 231 EXPECT_EQ(kBaseSeq + 1, feedback_packet->GetBaseSequence()); |
274 packet->Build(); | 232 EXPECT_EQ(kMediaSsrc, feedback_packet->media_ssrc()); |
275 EXPECT_EQ(kBaseSeq + 1, packet->GetBaseSequence()); | |
276 EXPECT_EQ(kMediaSsrc, packet->media_ssrc()); | |
277 | 233 |
278 std::vector<int64_t> delta_vec = packet->GetReceiveDeltasUs(); | 234 EXPECT_THAT(SequenceNumbers(*feedback_packet), |
279 EXPECT_EQ(2u, delta_vec.size()); | 235 ElementsAre(kBaseSeq + 1, kBaseSeq + 2)); |
280 EXPECT_EQ(kBaseTimeMs + 1, | 236 EXPECT_THAT(TimestampsMs(*feedback_packet), |
281 (packet->GetBaseTimeUs() + delta_vec[0]) / 1000); | 237 ElementsAre(kBaseTimeMs + 1, kBaseTimeMs + 2)); |
282 EXPECT_EQ(1, delta_vec[1] / 1000); | |
283 return true; | 238 return true; |
284 })); | 239 })); |
285 | 240 |
286 Process(); | 241 Process(); |
287 } | 242 } |
288 | 243 |
289 TEST_F(RemoteEstimatorProxyTest, RemovesTimestampsOutOfScope) { | 244 TEST_F(RemoteEstimatorProxyTest, RemovesTimestampsOutOfScope) { |
290 const int64_t kTimeoutTimeMs = | 245 const int64_t kTimeoutTimeMs = |
291 kBaseTimeMs + RemoteEstimatorProxy::kBackWindowMs; | 246 kBaseTimeMs + RemoteEstimatorProxy::kBackWindowMs; |
292 | 247 |
293 IncomingPacket(kBaseSeq + 2, kBaseTimeMs); | 248 IncomingPacket(kBaseSeq + 2, kBaseTimeMs); |
294 | 249 |
295 EXPECT_CALL(router_, SendFeedback(_)) | 250 EXPECT_CALL(router_, SendFeedback(_)) |
296 .Times(1) | 251 .WillOnce(Invoke([](rtcp::TransportFeedback* feedback_packet) { |
297 .WillOnce(Invoke([kTimeoutTimeMs, this](rtcp::TransportFeedback* packet) { | 252 EXPECT_EQ(kBaseSeq + 2, feedback_packet->GetBaseSequence()); |
298 packet->Build(); | |
299 EXPECT_EQ(kBaseSeq + 2, packet->GetBaseSequence()); | |
300 | 253 |
301 std::vector<int64_t> delta_vec = packet->GetReceiveDeltasUs(); | 254 EXPECT_THAT(TimestampsMs(*feedback_packet), ElementsAre(kBaseTimeMs)); |
302 EXPECT_EQ(1u, delta_vec.size()); | |
303 EXPECT_EQ(kBaseTimeMs, (packet->GetBaseTimeUs() + delta_vec[0]) / 1000); | |
304 return true; | 255 return true; |
305 })); | 256 })); |
306 | 257 |
307 Process(); | 258 Process(); |
308 | 259 |
309 IncomingPacket(kBaseSeq + 3, kTimeoutTimeMs); // kBaseSeq + 2 times out here. | 260 IncomingPacket(kBaseSeq + 3, kTimeoutTimeMs); // kBaseSeq + 2 times out here. |
310 | 261 |
311 EXPECT_CALL(router_, SendFeedback(_)) | 262 EXPECT_CALL(router_, SendFeedback(_)) |
312 .Times(1) | 263 .WillOnce( |
313 .WillOnce(Invoke([kTimeoutTimeMs, this](rtcp::TransportFeedback* packet) { | 264 Invoke([kTimeoutTimeMs](rtcp::TransportFeedback* feedback_packet) { |
314 packet->Build(); | 265 EXPECT_EQ(kBaseSeq + 3, feedback_packet->GetBaseSequence()); |
315 EXPECT_EQ(kBaseSeq + 3, packet->GetBaseSequence()); | |
316 | 266 |
317 std::vector<int64_t> delta_vec = packet->GetReceiveDeltasUs(); | 267 EXPECT_THAT(TimestampsMs(*feedback_packet), |
318 EXPECT_EQ(1u, delta_vec.size()); | 268 ElementsAre(kTimeoutTimeMs)); |
319 EXPECT_EQ(kTimeoutTimeMs, | 269 return true; |
320 (packet->GetBaseTimeUs() + delta_vec[0]) / 1000); | 270 })); |
321 return true; | |
322 })); | |
323 | 271 |
324 Process(); | 272 Process(); |
325 | 273 |
326 // New group, with sequence starting below the first so that they may be | 274 // New group, with sequence starting below the first so that they may be |
327 // retransmitted. | 275 // retransmitted. |
328 IncomingPacket(kBaseSeq, kBaseTimeMs - 1); | 276 IncomingPacket(kBaseSeq, kBaseTimeMs - 1); |
329 IncomingPacket(kBaseSeq + 1, kTimeoutTimeMs - 1); | 277 IncomingPacket(kBaseSeq + 1, kTimeoutTimeMs - 1); |
330 | 278 |
331 EXPECT_CALL(router_, SendFeedback(_)) | 279 EXPECT_CALL(router_, SendFeedback(_)) |
332 .Times(1) | 280 .WillOnce( |
333 .WillOnce(Invoke([kTimeoutTimeMs, this](rtcp::TransportFeedback* packet) { | 281 Invoke([kTimeoutTimeMs](rtcp::TransportFeedback* feedback_packet) { |
334 packet->Build(); | 282 EXPECT_EQ(kBaseSeq, feedback_packet->GetBaseSequence()); |
335 EXPECT_EQ(kBaseSeq, packet->GetBaseSequence()); | |
336 | 283 |
337 // Four status entries (kBaseSeq + 3 missing). | 284 EXPECT_THAT(SequenceNumbers(*feedback_packet), |
338 EXPECT_EQ(4u, packet->GetStatusVector().size()); | 285 ElementsAre(kBaseSeq, kBaseSeq + 1, kBaseSeq + 3)); |
339 | 286 EXPECT_THAT(TimestampsMs(*feedback_packet), |
340 // Only three actual timestamps. | 287 ElementsAre(kBaseTimeMs - 1, kTimeoutTimeMs - 1, |
341 std::vector<int64_t> delta_vec = packet->GetReceiveDeltasUs(); | 288 kTimeoutTimeMs)); |
342 EXPECT_EQ(3u, delta_vec.size()); | 289 return true; |
343 EXPECT_EQ(kBaseTimeMs - 1, | 290 })); |
344 (packet->GetBaseTimeUs() + delta_vec[0]) / 1000); | |
345 EXPECT_EQ(kTimeoutTimeMs - kBaseTimeMs, delta_vec[1] / 1000); | |
346 EXPECT_EQ(1, delta_vec[2] / 1000); | |
347 return true; | |
348 })); | |
349 | 291 |
350 Process(); | 292 Process(); |
351 } | 293 } |
352 | 294 |
353 TEST_F(RemoteEstimatorProxyTest, TimeUntilNextProcessIsZeroBeforeFirstProcess) { | 295 TEST_F(RemoteEstimatorProxyTest, TimeUntilNextProcessIsZeroBeforeFirstProcess) { |
354 EXPECT_EQ(0, proxy_.TimeUntilNextProcess()); | 296 EXPECT_EQ(0, proxy_.TimeUntilNextProcess()); |
355 } | 297 } |
356 | 298 |
357 TEST_F(RemoteEstimatorProxyTest, TimeUntilNextProcessIsDefaultOnUnkownBitrate) { | 299 TEST_F(RemoteEstimatorProxyTest, TimeUntilNextProcessIsDefaultOnUnkownBitrate) { |
358 Process(); | 300 Process(); |
(...skipping 25 matching lines...) Expand all Loading... |
384 proxy_.TimeUntilNextProcess()); | 326 proxy_.TimeUntilNextProcess()); |
385 } | 327 } |
386 | 328 |
387 TEST_F(RemoteEstimatorProxyTest, TwccReportsUse5PercentOfAvailableBandwidth) { | 329 TEST_F(RemoteEstimatorProxyTest, TwccReportsUse5PercentOfAvailableBandwidth) { |
388 Process(); | 330 Process(); |
389 proxy_.OnBitrateChanged(80000); | 331 proxy_.OnBitrateChanged(80000); |
390 // 80kbps * 0.05 = TwccReportSize(68B * 8b/B) * 1000ms / SendInterval(136ms) | 332 // 80kbps * 0.05 = TwccReportSize(68B * 8b/B) * 1000ms / SendInterval(136ms) |
391 EXPECT_EQ(136, proxy_.TimeUntilNextProcess()); | 333 EXPECT_EQ(136, proxy_.TimeUntilNextProcess()); |
392 } | 334 } |
393 | 335 |
| 336 } // namespace |
394 } // namespace webrtc | 337 } // namespace webrtc |
OLD | NEW |