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 |
(...skipping 49 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
60 }; | 60 }; |
61 | 61 |
62 TEST_F(RemoteEstimatorProxyTest, SendsSinglePacketFeedback) { | 62 TEST_F(RemoteEstimatorProxyTest, SendsSinglePacketFeedback) { |
63 IncomingPacket(kBaseSeq, kBaseTimeMs); | 63 IncomingPacket(kBaseSeq, kBaseTimeMs); |
64 | 64 |
65 EXPECT_CALL(router_, SendFeedback(_)) | 65 EXPECT_CALL(router_, SendFeedback(_)) |
66 .Times(1) | 66 .Times(1) |
67 .WillOnce(Invoke([this](rtcp::TransportFeedback* packet) { | 67 .WillOnce(Invoke([this](rtcp::TransportFeedback* packet) { |
68 packet->Build(); | 68 packet->Build(); |
69 EXPECT_EQ(kBaseSeq, packet->GetBaseSequence()); | 69 EXPECT_EQ(kBaseSeq, packet->GetBaseSequence()); |
70 EXPECT_EQ(kMediaSsrc, packet->GetMediaSourceSsrc()); | 70 EXPECT_EQ(kMediaSsrc, packet->media_ssrc()); |
71 | 71 |
72 std::vector<rtcp::TransportFeedback::StatusSymbol> status_vec = | 72 std::vector<rtcp::TransportFeedback::StatusSymbol> status_vec = |
73 packet->GetStatusVector(); | 73 packet->GetStatusVector(); |
74 EXPECT_EQ(1u, status_vec.size()); | 74 EXPECT_EQ(1u, status_vec.size()); |
75 EXPECT_EQ(rtcp::TransportFeedback::StatusSymbol::kReceivedSmallDelta, | 75 EXPECT_EQ(rtcp::TransportFeedback::StatusSymbol::kReceivedSmallDelta, |
76 status_vec[0]); | 76 status_vec[0]); |
77 std::vector<int64_t> delta_vec = packet->GetReceiveDeltasUs(); | 77 std::vector<int64_t> delta_vec = packet->GetReceiveDeltasUs(); |
78 EXPECT_EQ(1u, delta_vec.size()); | 78 EXPECT_EQ(1u, delta_vec.size()); |
79 EXPECT_EQ(kBaseTimeMs, (packet->GetBaseTimeUs() + delta_vec[0]) / 1000); | 79 EXPECT_EQ(kBaseTimeMs, (packet->GetBaseTimeUs() + delta_vec[0]) / 1000); |
80 return true; | 80 return true; |
81 })); | 81 })); |
82 | 82 |
83 Process(); | 83 Process(); |
84 } | 84 } |
85 | 85 |
86 TEST_F(RemoteEstimatorProxyTest, DuplicatedPackets) { | 86 TEST_F(RemoteEstimatorProxyTest, DuplicatedPackets) { |
87 IncomingPacket(kBaseSeq, kBaseTimeMs); | 87 IncomingPacket(kBaseSeq, kBaseTimeMs); |
88 IncomingPacket(kBaseSeq, kBaseTimeMs + 1000); | 88 IncomingPacket(kBaseSeq, kBaseTimeMs + 1000); |
89 | 89 |
90 EXPECT_CALL(router_, SendFeedback(_)) | 90 EXPECT_CALL(router_, SendFeedback(_)) |
91 .Times(1) | 91 .Times(1) |
92 .WillOnce(Invoke([this](rtcp::TransportFeedback* packet) { | 92 .WillOnce(Invoke([this](rtcp::TransportFeedback* packet) { |
93 packet->Build(); | 93 packet->Build(); |
94 EXPECT_EQ(kBaseSeq, packet->GetBaseSequence()); | 94 EXPECT_EQ(kBaseSeq, packet->GetBaseSequence()); |
95 EXPECT_EQ(kMediaSsrc, packet->GetMediaSourceSsrc()); | 95 EXPECT_EQ(kMediaSsrc, packet->media_ssrc()); |
96 | 96 |
97 std::vector<rtcp::TransportFeedback::StatusSymbol> status_vec = | 97 std::vector<rtcp::TransportFeedback::StatusSymbol> status_vec = |
98 packet->GetStatusVector(); | 98 packet->GetStatusVector(); |
99 EXPECT_EQ(1u, status_vec.size()); | 99 EXPECT_EQ(1u, status_vec.size()); |
100 EXPECT_EQ(rtcp::TransportFeedback::StatusSymbol::kReceivedSmallDelta, | 100 EXPECT_EQ(rtcp::TransportFeedback::StatusSymbol::kReceivedSmallDelta, |
101 status_vec[0]); | 101 status_vec[0]); |
102 std::vector<int64_t> delta_vec = packet->GetReceiveDeltasUs(); | 102 std::vector<int64_t> delta_vec = packet->GetReceiveDeltasUs(); |
103 EXPECT_EQ(1u, delta_vec.size()); | 103 EXPECT_EQ(1u, delta_vec.size()); |
104 EXPECT_EQ(kBaseTimeMs, (packet->GetBaseTimeUs() + delta_vec[0]) / 1000); | 104 EXPECT_EQ(kBaseTimeMs, (packet->GetBaseTimeUs() + delta_vec[0]) / 1000); |
105 return true; | 105 return true; |
(...skipping 10 matching lines...) Expand all Loading... |
116 Process(); | 116 Process(); |
117 | 117 |
118 // Second feedback starts with a missing packet (DROP kBaseSeq + 2). | 118 // Second feedback starts with a missing packet (DROP kBaseSeq + 2). |
119 IncomingPacket(kBaseSeq + 3, kBaseTimeMs + 3000); | 119 IncomingPacket(kBaseSeq + 3, kBaseTimeMs + 3000); |
120 | 120 |
121 EXPECT_CALL(router_, SendFeedback(_)) | 121 EXPECT_CALL(router_, SendFeedback(_)) |
122 .Times(1) | 122 .Times(1) |
123 .WillOnce(Invoke([this](rtcp::TransportFeedback* packet) { | 123 .WillOnce(Invoke([this](rtcp::TransportFeedback* packet) { |
124 packet->Build(); | 124 packet->Build(); |
125 EXPECT_EQ(kBaseSeq + 2, packet->GetBaseSequence()); | 125 EXPECT_EQ(kBaseSeq + 2, packet->GetBaseSequence()); |
126 EXPECT_EQ(kMediaSsrc, packet->GetMediaSourceSsrc()); | 126 EXPECT_EQ(kMediaSsrc, packet->media_ssrc()); |
127 | 127 |
128 std::vector<rtcp::TransportFeedback::StatusSymbol> status_vec = | 128 std::vector<rtcp::TransportFeedback::StatusSymbol> status_vec = |
129 packet->GetStatusVector(); | 129 packet->GetStatusVector(); |
130 EXPECT_EQ(2u, status_vec.size()); | 130 EXPECT_EQ(2u, status_vec.size()); |
131 EXPECT_EQ(rtcp::TransportFeedback::StatusSymbol::kNotReceived, | 131 EXPECT_EQ(rtcp::TransportFeedback::StatusSymbol::kNotReceived, |
132 status_vec[0]); | 132 status_vec[0]); |
133 EXPECT_EQ(rtcp::TransportFeedback::StatusSymbol::kReceivedSmallDelta, | 133 EXPECT_EQ(rtcp::TransportFeedback::StatusSymbol::kReceivedSmallDelta, |
134 status_vec[1]); | 134 status_vec[1]); |
135 std::vector<int64_t> delta_vec = packet->GetReceiveDeltasUs(); | 135 std::vector<int64_t> delta_vec = packet->GetReceiveDeltasUs(); |
136 EXPECT_EQ(1u, delta_vec.size()); | 136 EXPECT_EQ(1u, delta_vec.size()); |
137 EXPECT_EQ(kBaseTimeMs + 3000, | 137 EXPECT_EQ(kBaseTimeMs + 3000, |
138 (packet->GetBaseTimeUs() + delta_vec[0]) / 1000); | 138 (packet->GetBaseTimeUs() + delta_vec[0]) / 1000); |
139 return true; | 139 return true; |
140 })); | 140 })); |
141 | 141 |
142 Process(); | 142 Process(); |
143 } | 143 } |
144 | 144 |
145 TEST_F(RemoteEstimatorProxyTest, SendsFeedbackWithVaryingDeltas) { | 145 TEST_F(RemoteEstimatorProxyTest, SendsFeedbackWithVaryingDeltas) { |
146 IncomingPacket(kBaseSeq, kBaseTimeMs); | 146 IncomingPacket(kBaseSeq, kBaseTimeMs); |
147 IncomingPacket(kBaseSeq + 1, kBaseTimeMs + kMaxSmallDeltaMs); | 147 IncomingPacket(kBaseSeq + 1, kBaseTimeMs + kMaxSmallDeltaMs); |
148 IncomingPacket(kBaseSeq + 2, kBaseTimeMs + (2 * kMaxSmallDeltaMs) + 1); | 148 IncomingPacket(kBaseSeq + 2, kBaseTimeMs + (2 * kMaxSmallDeltaMs) + 1); |
149 | 149 |
150 EXPECT_CALL(router_, SendFeedback(_)) | 150 EXPECT_CALL(router_, SendFeedback(_)) |
151 .Times(1) | 151 .Times(1) |
152 .WillOnce(Invoke([this](rtcp::TransportFeedback* packet) { | 152 .WillOnce(Invoke([this](rtcp::TransportFeedback* packet) { |
153 packet->Build(); | 153 packet->Build(); |
154 EXPECT_EQ(kBaseSeq, packet->GetBaseSequence()); | 154 EXPECT_EQ(kBaseSeq, packet->GetBaseSequence()); |
155 EXPECT_EQ(kMediaSsrc, packet->GetMediaSourceSsrc()); | 155 EXPECT_EQ(kMediaSsrc, packet->media_ssrc()); |
156 | 156 |
157 std::vector<rtcp::TransportFeedback::StatusSymbol> status_vec = | 157 std::vector<rtcp::TransportFeedback::StatusSymbol> status_vec = |
158 packet->GetStatusVector(); | 158 packet->GetStatusVector(); |
159 EXPECT_EQ(3u, status_vec.size()); | 159 EXPECT_EQ(3u, status_vec.size()); |
160 EXPECT_EQ(rtcp::TransportFeedback::StatusSymbol::kReceivedSmallDelta, | 160 EXPECT_EQ(rtcp::TransportFeedback::StatusSymbol::kReceivedSmallDelta, |
161 status_vec[0]); | 161 status_vec[0]); |
162 EXPECT_EQ(rtcp::TransportFeedback::StatusSymbol::kReceivedSmallDelta, | 162 EXPECT_EQ(rtcp::TransportFeedback::StatusSymbol::kReceivedSmallDelta, |
163 status_vec[1]); | 163 status_vec[1]); |
164 EXPECT_EQ(rtcp::TransportFeedback::StatusSymbol::kReceivedLargeDelta, | 164 EXPECT_EQ(rtcp::TransportFeedback::StatusSymbol::kReceivedLargeDelta, |
165 status_vec[2]); | 165 status_vec[2]); |
(...skipping 15 matching lines...) Expand all Loading... |
181 | 181 |
182 IncomingPacket(kBaseSeq, kBaseTimeMs); | 182 IncomingPacket(kBaseSeq, kBaseTimeMs); |
183 IncomingPacket(kBaseSeq + 1, kBaseTimeMs + kTooLargeDelta); | 183 IncomingPacket(kBaseSeq + 1, kBaseTimeMs + kTooLargeDelta); |
184 | 184 |
185 InSequence s; | 185 InSequence s; |
186 EXPECT_CALL(router_, SendFeedback(_)) | 186 EXPECT_CALL(router_, SendFeedback(_)) |
187 .Times(1) | 187 .Times(1) |
188 .WillOnce(Invoke([kTooLargeDelta, this](rtcp::TransportFeedback* packet) { | 188 .WillOnce(Invoke([kTooLargeDelta, this](rtcp::TransportFeedback* packet) { |
189 packet->Build(); | 189 packet->Build(); |
190 EXPECT_EQ(kBaseSeq, packet->GetBaseSequence()); | 190 EXPECT_EQ(kBaseSeq, packet->GetBaseSequence()); |
191 EXPECT_EQ(kMediaSsrc, packet->GetMediaSourceSsrc()); | 191 EXPECT_EQ(kMediaSsrc, packet->media_ssrc()); |
192 | 192 |
193 std::vector<rtcp::TransportFeedback::StatusSymbol> status_vec = | 193 std::vector<rtcp::TransportFeedback::StatusSymbol> status_vec = |
194 packet->GetStatusVector(); | 194 packet->GetStatusVector(); |
195 EXPECT_EQ(1u, status_vec.size()); | 195 EXPECT_EQ(1u, status_vec.size()); |
196 EXPECT_EQ(rtcp::TransportFeedback::StatusSymbol::kReceivedSmallDelta, | 196 EXPECT_EQ(rtcp::TransportFeedback::StatusSymbol::kReceivedSmallDelta, |
197 status_vec[0]); | 197 status_vec[0]); |
198 std::vector<int64_t> delta_vec = packet->GetReceiveDeltasUs(); | 198 std::vector<int64_t> delta_vec = packet->GetReceiveDeltasUs(); |
199 EXPECT_EQ(1u, delta_vec.size()); | 199 EXPECT_EQ(1u, delta_vec.size()); |
200 EXPECT_EQ(kBaseTimeMs, (packet->GetBaseTimeUs() + delta_vec[0]) / 1000); | 200 EXPECT_EQ(kBaseTimeMs, (packet->GetBaseTimeUs() + delta_vec[0]) / 1000); |
201 return true; | 201 return true; |
202 })) | 202 })) |
203 .RetiresOnSaturation(); | 203 .RetiresOnSaturation(); |
204 | 204 |
205 EXPECT_CALL(router_, SendFeedback(_)) | 205 EXPECT_CALL(router_, SendFeedback(_)) |
206 .Times(1) | 206 .Times(1) |
207 .WillOnce(Invoke([kTooLargeDelta, this](rtcp::TransportFeedback* packet) { | 207 .WillOnce(Invoke([kTooLargeDelta, this](rtcp::TransportFeedback* packet) { |
208 packet->Build(); | 208 packet->Build(); |
209 EXPECT_EQ(kBaseSeq + 1, packet->GetBaseSequence()); | 209 EXPECT_EQ(kBaseSeq + 1, packet->GetBaseSequence()); |
210 EXPECT_EQ(kMediaSsrc, packet->GetMediaSourceSsrc()); | 210 EXPECT_EQ(kMediaSsrc, packet->media_ssrc()); |
211 | 211 |
212 std::vector<rtcp::TransportFeedback::StatusSymbol> status_vec = | 212 std::vector<rtcp::TransportFeedback::StatusSymbol> status_vec = |
213 packet->GetStatusVector(); | 213 packet->GetStatusVector(); |
214 EXPECT_EQ(1u, status_vec.size()); | 214 EXPECT_EQ(1u, status_vec.size()); |
215 EXPECT_EQ(rtcp::TransportFeedback::StatusSymbol::kReceivedSmallDelta, | 215 EXPECT_EQ(rtcp::TransportFeedback::StatusSymbol::kReceivedSmallDelta, |
216 status_vec[0]); | 216 status_vec[0]); |
217 std::vector<int64_t> delta_vec = packet->GetReceiveDeltasUs(); | 217 std::vector<int64_t> delta_vec = packet->GetReceiveDeltasUs(); |
218 EXPECT_EQ(1u, delta_vec.size()); | 218 EXPECT_EQ(1u, delta_vec.size()); |
219 EXPECT_EQ(kBaseTimeMs + kTooLargeDelta, | 219 EXPECT_EQ(kBaseTimeMs + kTooLargeDelta, |
220 (packet->GetBaseTimeUs() + delta_vec[0]) / 1000); | 220 (packet->GetBaseTimeUs() + delta_vec[0]) / 1000); |
221 return true; | 221 return true; |
222 })) | 222 })) |
223 .RetiresOnSaturation(); | 223 .RetiresOnSaturation(); |
224 | 224 |
225 Process(); | 225 Process(); |
226 } | 226 } |
227 | 227 |
228 TEST_F(RemoteEstimatorProxyTest, GracefullyHandlesReorderingAndWrap) { | 228 TEST_F(RemoteEstimatorProxyTest, GracefullyHandlesReorderingAndWrap) { |
229 const int64_t kDeltaMs = 1000; | 229 const int64_t kDeltaMs = 1000; |
230 const uint16_t kLargeSeq = 62762; | 230 const uint16_t kLargeSeq = 62762; |
231 IncomingPacket(kBaseSeq, kBaseTimeMs); | 231 IncomingPacket(kBaseSeq, kBaseTimeMs); |
232 IncomingPacket(kLargeSeq, kBaseTimeMs + kDeltaMs); | 232 IncomingPacket(kLargeSeq, kBaseTimeMs + kDeltaMs); |
233 | 233 |
234 EXPECT_CALL(router_, SendFeedback(_)) | 234 EXPECT_CALL(router_, SendFeedback(_)) |
235 .Times(1) | 235 .Times(1) |
236 .WillOnce(Invoke([this](rtcp::TransportFeedback* packet) { | 236 .WillOnce(Invoke([this](rtcp::TransportFeedback* packet) { |
237 packet->Build(); | 237 packet->Build(); |
238 EXPECT_EQ(kBaseSeq, packet->GetBaseSequence()); | 238 EXPECT_EQ(kBaseSeq, packet->GetBaseSequence()); |
239 EXPECT_EQ(kMediaSsrc, packet->GetMediaSourceSsrc()); | 239 EXPECT_EQ(kMediaSsrc, packet->media_ssrc()); |
240 | 240 |
241 std::vector<int64_t> delta_vec = packet->GetReceiveDeltasUs(); | 241 std::vector<int64_t> delta_vec = packet->GetReceiveDeltasUs(); |
242 EXPECT_EQ(1u, delta_vec.size()); | 242 EXPECT_EQ(1u, delta_vec.size()); |
243 EXPECT_EQ(kBaseTimeMs, (packet->GetBaseTimeUs() + delta_vec[0]) / 1000); | 243 EXPECT_EQ(kBaseTimeMs, (packet->GetBaseTimeUs() + delta_vec[0]) / 1000); |
244 return true; | 244 return true; |
245 })); | 245 })); |
246 | 246 |
247 Process(); | 247 Process(); |
248 } | 248 } |
249 | 249 |
250 TEST_F(RemoteEstimatorProxyTest, ResendsTimestampsOnReordering) { | 250 TEST_F(RemoteEstimatorProxyTest, ResendsTimestampsOnReordering) { |
251 IncomingPacket(kBaseSeq, kBaseTimeMs); | 251 IncomingPacket(kBaseSeq, kBaseTimeMs); |
252 IncomingPacket(kBaseSeq + 2, kBaseTimeMs + 2); | 252 IncomingPacket(kBaseSeq + 2, kBaseTimeMs + 2); |
253 | 253 |
254 EXPECT_CALL(router_, SendFeedback(_)) | 254 EXPECT_CALL(router_, SendFeedback(_)) |
255 .Times(1) | 255 .Times(1) |
256 .WillOnce(Invoke([this](rtcp::TransportFeedback* packet) { | 256 .WillOnce(Invoke([this](rtcp::TransportFeedback* packet) { |
257 packet->Build(); | 257 packet->Build(); |
258 EXPECT_EQ(kBaseSeq, packet->GetBaseSequence()); | 258 EXPECT_EQ(kBaseSeq, packet->GetBaseSequence()); |
259 EXPECT_EQ(kMediaSsrc, packet->GetMediaSourceSsrc()); | 259 EXPECT_EQ(kMediaSsrc, packet->media_ssrc()); |
260 | 260 |
261 std::vector<int64_t> delta_vec = packet->GetReceiveDeltasUs(); | 261 std::vector<int64_t> delta_vec = packet->GetReceiveDeltasUs(); |
262 EXPECT_EQ(2u, delta_vec.size()); | 262 EXPECT_EQ(2u, delta_vec.size()); |
263 EXPECT_EQ(kBaseTimeMs, (packet->GetBaseTimeUs() + delta_vec[0]) / 1000); | 263 EXPECT_EQ(kBaseTimeMs, (packet->GetBaseTimeUs() + delta_vec[0]) / 1000); |
264 EXPECT_EQ(2, delta_vec[1] / 1000); | 264 EXPECT_EQ(2, delta_vec[1] / 1000); |
265 return true; | 265 return true; |
266 })); | 266 })); |
267 | 267 |
268 Process(); | 268 Process(); |
269 | 269 |
270 IncomingPacket(kBaseSeq + 1, kBaseTimeMs + 1); | 270 IncomingPacket(kBaseSeq + 1, kBaseTimeMs + 1); |
271 | 271 |
272 EXPECT_CALL(router_, SendFeedback(_)) | 272 EXPECT_CALL(router_, SendFeedback(_)) |
273 .Times(1) | 273 .Times(1) |
274 .WillOnce(Invoke([this](rtcp::TransportFeedback* packet) { | 274 .WillOnce(Invoke([this](rtcp::TransportFeedback* packet) { |
275 packet->Build(); | 275 packet->Build(); |
276 EXPECT_EQ(kBaseSeq + 1, packet->GetBaseSequence()); | 276 EXPECT_EQ(kBaseSeq + 1, packet->GetBaseSequence()); |
277 EXPECT_EQ(kMediaSsrc, packet->GetMediaSourceSsrc()); | 277 EXPECT_EQ(kMediaSsrc, packet->media_ssrc()); |
278 | 278 |
279 std::vector<int64_t> delta_vec = packet->GetReceiveDeltasUs(); | 279 std::vector<int64_t> delta_vec = packet->GetReceiveDeltasUs(); |
280 EXPECT_EQ(2u, delta_vec.size()); | 280 EXPECT_EQ(2u, delta_vec.size()); |
281 EXPECT_EQ(kBaseTimeMs + 1, | 281 EXPECT_EQ(kBaseTimeMs + 1, |
282 (packet->GetBaseTimeUs() + delta_vec[0]) / 1000); | 282 (packet->GetBaseTimeUs() + delta_vec[0]) / 1000); |
283 EXPECT_EQ(1, delta_vec[1] / 1000); | 283 EXPECT_EQ(1, delta_vec[1] / 1000); |
284 return true; | 284 return true; |
285 })); | 285 })); |
286 | 286 |
287 Process(); | 287 Process(); |
(...skipping 57 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
345 (packet->GetBaseTimeUs() + delta_vec[0]) / 1000); | 345 (packet->GetBaseTimeUs() + delta_vec[0]) / 1000); |
346 EXPECT_EQ(kTimeoutTimeMs - kBaseTimeMs, delta_vec[1] / 1000); | 346 EXPECT_EQ(kTimeoutTimeMs - kBaseTimeMs, delta_vec[1] / 1000); |
347 EXPECT_EQ(1, delta_vec[2] / 1000); | 347 EXPECT_EQ(1, delta_vec[2] / 1000); |
348 return true; | 348 return true; |
349 })); | 349 })); |
350 | 350 |
351 Process(); | 351 Process(); |
352 } | 352 } |
353 | 353 |
354 } // namespace webrtc | 354 } // namespace webrtc |
OLD | NEW |