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 107 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
118 packets.push_back(PacketInfo(100, 200, 0, 1500, 0)); | 118 packets.push_back(PacketInfo(100, 200, 0, 1500, 0)); |
119 packets.push_back(PacketInfo(110, 210, 1, 1500, 0)); | 119 packets.push_back(PacketInfo(110, 210, 1, 1500, 0)); |
120 packets.push_back(PacketInfo(120, 220, 2, 1500, 0)); | 120 packets.push_back(PacketInfo(120, 220, 2, 1500, 0)); |
121 packets.push_back(PacketInfo(130, 230, 3, 1500, 1)); | 121 packets.push_back(PacketInfo(130, 230, 3, 1500, 1)); |
122 packets.push_back(PacketInfo(140, 240, 4, 1500, 1)); | 122 packets.push_back(PacketInfo(140, 240, 4, 1500, 1)); |
123 | 123 |
124 for (const PacketInfo& packet : packets) | 124 for (const PacketInfo& packet : packets) |
125 OnSentPacket(packet); | 125 OnSentPacket(packet); |
126 | 126 |
127 rtcp::TransportFeedback feedback; | 127 rtcp::TransportFeedback feedback; |
128 feedback.SetBase(packets[0].sequence_number, | 128 feedback.WithBase(packets[0].sequence_number, |
129 packets[0].arrival_time_ms * 1000); | 129 packets[0].arrival_time_ms * 1000); |
130 | 130 |
131 for (const PacketInfo& packet : packets) { | 131 for (const PacketInfo& packet : packets) { |
132 EXPECT_TRUE(feedback.AddReceivedPacket(packet.sequence_number, | 132 EXPECT_TRUE(feedback.WithReceivedPacket(packet.sequence_number, |
133 packet.arrival_time_ms * 1000)); | 133 packet.arrival_time_ms * 1000)); |
134 } | 134 } |
135 | 135 |
136 feedback.Build(); | 136 feedback.Build(); |
137 | 137 |
138 EXPECT_CALL(*bitrate_estimator_, IncomingPacketFeedbackVector(_)) | 138 EXPECT_CALL(*bitrate_estimator_, IncomingPacketFeedbackVector(_)) |
139 .Times(1) | 139 .Times(1) |
140 .WillOnce(Invoke( | 140 .WillOnce(Invoke( |
141 [packets, this](const std::vector<PacketInfo>& feedback_vector) { | 141 [packets, this](const std::vector<PacketInfo>& feedback_vector) { |
142 ComparePacketVectors(packets, feedback_vector); | 142 ComparePacketVectors(packets, feedback_vector); |
143 })); | 143 })); |
(...skipping 10 matching lines...) Expand all Loading... |
154 | 154 |
155 const uint16_t kSendSideDropBefore = 1; | 155 const uint16_t kSendSideDropBefore = 1; |
156 const uint16_t kReceiveSideDropAfter = 3; | 156 const uint16_t kReceiveSideDropAfter = 3; |
157 | 157 |
158 for (const PacketInfo& packet : packets) { | 158 for (const PacketInfo& packet : packets) { |
159 if (packet.sequence_number >= kSendSideDropBefore) | 159 if (packet.sequence_number >= kSendSideDropBefore) |
160 OnSentPacket(packet); | 160 OnSentPacket(packet); |
161 } | 161 } |
162 | 162 |
163 rtcp::TransportFeedback feedback; | 163 rtcp::TransportFeedback feedback; |
164 feedback.SetBase(packets[0].sequence_number, | 164 feedback.WithBase(packets[0].sequence_number, |
165 packets[0].arrival_time_ms * 1000); | 165 packets[0].arrival_time_ms * 1000); |
166 | 166 |
167 for (const PacketInfo& packet : packets) { | 167 for (const PacketInfo& packet : packets) { |
168 if (packet.sequence_number <= kReceiveSideDropAfter) { | 168 if (packet.sequence_number <= kReceiveSideDropAfter) { |
169 EXPECT_TRUE(feedback.AddReceivedPacket(packet.sequence_number, | 169 EXPECT_TRUE(feedback.WithReceivedPacket(packet.sequence_number, |
170 packet.arrival_time_ms * 1000)); | 170 packet.arrival_time_ms * 1000)); |
171 } | 171 } |
172 } | 172 } |
173 | 173 |
174 feedback.Build(); | 174 feedback.Build(); |
175 | 175 |
176 std::vector<PacketInfo> expected_packets( | 176 std::vector<PacketInfo> expected_packets( |
177 packets.begin() + kSendSideDropBefore, | 177 packets.begin() + kSendSideDropBefore, |
178 packets.begin() + kReceiveSideDropAfter + 1); | 178 packets.begin() + kReceiveSideDropAfter + 1); |
179 | 179 |
180 EXPECT_CALL(*bitrate_estimator_, IncomingPacketFeedbackVector(_)) | 180 EXPECT_CALL(*bitrate_estimator_, IncomingPacketFeedbackVector(_)) |
(...skipping 16 matching lines...) Expand all Loading... |
197 PacketInfo::kNotAProbe)); | 197 PacketInfo::kNotAProbe)); |
198 packets.push_back( | 198 packets.push_back( |
199 PacketInfo(kHighArrivalTimeMs, 220, 2, 1500, PacketInfo::kNotAProbe)); | 199 PacketInfo(kHighArrivalTimeMs, 220, 2, 1500, PacketInfo::kNotAProbe)); |
200 | 200 |
201 for (const PacketInfo& packet : packets) | 201 for (const PacketInfo& packet : packets) |
202 OnSentPacket(packet); | 202 OnSentPacket(packet); |
203 | 203 |
204 for (size_t i = 0; i < packets.size(); ++i) { | 204 for (size_t i = 0; i < packets.size(); ++i) { |
205 std::unique_ptr<rtcp::TransportFeedback> feedback( | 205 std::unique_ptr<rtcp::TransportFeedback> feedback( |
206 new rtcp::TransportFeedback()); | 206 new rtcp::TransportFeedback()); |
207 feedback->SetBase(packets[i].sequence_number, | 207 feedback->WithBase(packets[i].sequence_number, |
208 packets[i].arrival_time_ms * 1000); | 208 packets[i].arrival_time_ms * 1000); |
209 | 209 |
210 EXPECT_TRUE(feedback->AddReceivedPacket(packets[i].sequence_number, | 210 EXPECT_TRUE(feedback->WithReceivedPacket( |
211 packets[i].arrival_time_ms * 1000)); | 211 packets[i].sequence_number, packets[i].arrival_time_ms * 1000)); |
212 | 212 |
213 rtc::Buffer raw_packet = feedback->Build(); | 213 rtc::Buffer raw_packet = feedback->Build(); |
214 feedback = rtcp::TransportFeedback::ParseFrom(raw_packet.data(), | 214 feedback = rtcp::TransportFeedback::ParseFrom(raw_packet.data(), |
215 raw_packet.size()); | 215 raw_packet.size()); |
216 | 216 |
217 std::vector<PacketInfo> expected_packets; | 217 std::vector<PacketInfo> expected_packets; |
218 expected_packets.push_back(packets[i]); | 218 expected_packets.push_back(packets[i]); |
219 | 219 |
220 EXPECT_CALL(*bitrate_estimator_, IncomingPacketFeedbackVector(_)) | 220 EXPECT_CALL(*bitrate_estimator_, IncomingPacketFeedbackVector(_)) |
221 .Times(1) | 221 .Times(1) |
(...skipping 12 matching lines...) Expand all Loading... |
234 packets.push_back(PacketInfo(100, 220, 2, 1500, 0)); | 234 packets.push_back(PacketInfo(100, 220, 2, 1500, 0)); |
235 std::vector<PacketInfo> expected_packets; | 235 std::vector<PacketInfo> expected_packets; |
236 expected_packets.push_back(packets[2]); | 236 expected_packets.push_back(packets[2]); |
237 expected_packets.push_back(packets[1]); | 237 expected_packets.push_back(packets[1]); |
238 expected_packets.push_back(packets[0]); | 238 expected_packets.push_back(packets[0]); |
239 | 239 |
240 for (const PacketInfo& packet : packets) | 240 for (const PacketInfo& packet : packets) |
241 OnSentPacket(packet); | 241 OnSentPacket(packet); |
242 | 242 |
243 rtcp::TransportFeedback feedback; | 243 rtcp::TransportFeedback feedback; |
244 feedback.SetBase(packets[0].sequence_number, | 244 feedback.WithBase(packets[0].sequence_number, |
245 packets[0].arrival_time_ms * 1000); | 245 packets[0].arrival_time_ms * 1000); |
246 | 246 |
247 for (const PacketInfo& packet : packets) { | 247 for (const PacketInfo& packet : packets) { |
248 EXPECT_TRUE(feedback.AddReceivedPacket(packet.sequence_number, | 248 EXPECT_TRUE(feedback.WithReceivedPacket(packet.sequence_number, |
249 packet.arrival_time_ms * 1000)); | 249 packet.arrival_time_ms * 1000)); |
250 } | 250 } |
251 | 251 |
252 feedback.Build(); | 252 feedback.Build(); |
253 | 253 |
254 EXPECT_CALL(*bitrate_estimator_, IncomingPacketFeedbackVector(_)) | 254 EXPECT_CALL(*bitrate_estimator_, IncomingPacketFeedbackVector(_)) |
255 .Times(1) | 255 .Times(1) |
256 .WillOnce(Invoke([expected_packets, | 256 .WillOnce(Invoke([expected_packets, |
257 this](const std::vector<PacketInfo>& feedback_vector) { | 257 this](const std::vector<PacketInfo>& feedback_vector) { |
258 ComparePacketVectors(expected_packets, feedback_vector); | 258 ComparePacketVectors(expected_packets, feedback_vector); |
259 })); | 259 })); |
(...skipping 43 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
303 expected_packets.push_back(sent_packets[2]); | 303 expected_packets.push_back(sent_packets[2]); |
304 | 304 |
305 // Packets will be added to send history. | 305 // Packets will be added to send history. |
306 for (const PacketInfo& packet : sent_packets) | 306 for (const PacketInfo& packet : sent_packets) |
307 OnSentPacket(packet); | 307 OnSentPacket(packet); |
308 OnSentPacket(info); | 308 OnSentPacket(info); |
309 | 309 |
310 // Create expected feedback and send into adapter. | 310 // Create expected feedback and send into adapter. |
311 std::unique_ptr<rtcp::TransportFeedback> feedback( | 311 std::unique_ptr<rtcp::TransportFeedback> feedback( |
312 new rtcp::TransportFeedback()); | 312 new rtcp::TransportFeedback()); |
313 feedback->SetBase(sent_packets[0].sequence_number, | 313 feedback->WithBase(sent_packets[0].sequence_number, |
314 sent_packets[0].arrival_time_ms * 1000); | 314 sent_packets[0].arrival_time_ms * 1000); |
315 | 315 |
316 for (const PacketInfo& packet : sent_packets) { | 316 for (const PacketInfo& packet : sent_packets) { |
317 EXPECT_TRUE(feedback->AddReceivedPacket(packet.sequence_number, | 317 EXPECT_TRUE(feedback->WithReceivedPacket(packet.sequence_number, |
318 packet.arrival_time_ms * 1000)); | 318 packet.arrival_time_ms * 1000)); |
319 } | 319 } |
320 EXPECT_FALSE(feedback->AddReceivedPacket(info.sequence_number, | 320 EXPECT_FALSE(feedback->WithReceivedPacket(info.sequence_number, |
321 info.arrival_time_ms * 1000)); | 321 info.arrival_time_ms * 1000)); |
322 | 322 |
323 rtc::Buffer raw_packet = feedback->Build(); | 323 rtc::Buffer raw_packet = feedback->Build(); |
324 feedback = | 324 feedback = |
325 rtcp::TransportFeedback::ParseFrom(raw_packet.data(), raw_packet.size()); | 325 rtcp::TransportFeedback::ParseFrom(raw_packet.data(), raw_packet.size()); |
326 | 326 |
327 std::vector<PacketInfo> received_feedback; | 327 std::vector<PacketInfo> received_feedback; |
328 | 328 |
329 EXPECT_TRUE(feedback.get() != nullptr); | 329 EXPECT_TRUE(feedback.get() != nullptr); |
330 EXPECT_CALL(*bitrate_estimator_, IncomingPacketFeedbackVector(_)) | 330 EXPECT_CALL(*bitrate_estimator_, IncomingPacketFeedbackVector(_)) |
331 .Times(1) | 331 .Times(1) |
332 .WillOnce(Invoke([expected_packets, &received_feedback]( | 332 .WillOnce(Invoke([expected_packets, &received_feedback]( |
333 const std::vector<PacketInfo>& feedback_vector) { | 333 const std::vector<PacketInfo>& feedback_vector) { |
334 EXPECT_EQ(expected_packets.size(), feedback_vector.size()); | 334 EXPECT_EQ(expected_packets.size(), feedback_vector.size()); |
335 received_feedback = feedback_vector; | 335 received_feedback = feedback_vector; |
336 })); | 336 })); |
337 adapter_->OnTransportFeedback(*feedback.get()); | 337 adapter_->OnTransportFeedback(*feedback.get()); |
338 | 338 |
339 // Create a new feedback message and add the trailing item. | 339 // Create a new feedback message and add the trailing item. |
340 feedback.reset(new rtcp::TransportFeedback()); | 340 feedback.reset(new rtcp::TransportFeedback()); |
341 feedback->SetBase(info.sequence_number, info.arrival_time_ms * 1000); | 341 feedback->WithBase(info.sequence_number, info.arrival_time_ms * 1000); |
342 EXPECT_TRUE(feedback->AddReceivedPacket(info.sequence_number, | 342 EXPECT_TRUE(feedback->WithReceivedPacket(info.sequence_number, |
343 info.arrival_time_ms * 1000)); | 343 info.arrival_time_ms * 1000)); |
344 raw_packet = feedback->Build(); | 344 raw_packet = feedback->Build(); |
345 feedback = | 345 feedback = |
346 rtcp::TransportFeedback::ParseFrom(raw_packet.data(), raw_packet.size()); | 346 rtcp::TransportFeedback::ParseFrom(raw_packet.data(), raw_packet.size()); |
347 | 347 |
348 EXPECT_TRUE(feedback.get() != nullptr); | 348 EXPECT_TRUE(feedback.get() != nullptr); |
349 EXPECT_CALL(*bitrate_estimator_, IncomingPacketFeedbackVector(_)) | 349 EXPECT_CALL(*bitrate_estimator_, IncomingPacketFeedbackVector(_)) |
350 .Times(1) | 350 .Times(1) |
351 .WillOnce(Invoke( | 351 .WillOnce(Invoke( |
352 [&received_feedback](const std::vector<PacketInfo>& feedback_vector) { | 352 [&received_feedback](const std::vector<PacketInfo>& feedback_vector) { |
353 EXPECT_EQ(1u, feedback_vector.size()); | 353 EXPECT_EQ(1u, feedback_vector.size()); |
354 received_feedback.push_back(feedback_vector[0]); | 354 received_feedback.push_back(feedback_vector[0]); |
355 })); | 355 })); |
356 adapter_->OnTransportFeedback(*feedback.get()); | 356 adapter_->OnTransportFeedback(*feedback.get()); |
357 | 357 |
358 expected_packets.push_back(info); | 358 expected_packets.push_back(info); |
359 | 359 |
360 ComparePacketVectors(expected_packets, received_feedback); | 360 ComparePacketVectors(expected_packets, received_feedback); |
361 } | 361 } |
362 | 362 |
363 } // namespace test | 363 } // namespace test |
364 } // namespace webrtc | 364 } // namespace webrtc |
OLD | NEW |