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 11 matching lines...) Expand all Loading... |
22 #include "webrtc/system_wrappers/include/clock.h" | 22 #include "webrtc/system_wrappers/include/clock.h" |
23 #include "webrtc/test/gmock.h" | 23 #include "webrtc/test/gmock.h" |
24 #include "webrtc/test/gtest.h" | 24 #include "webrtc/test/gtest.h" |
25 | 25 |
26 using ::testing::_; | 26 using ::testing::_; |
27 using ::testing::Invoke; | 27 using ::testing::Invoke; |
28 | 28 |
29 namespace webrtc { | 29 namespace webrtc { |
30 | 30 |
31 namespace { | 31 namespace { |
| 32 |
32 const PacedPacketInfo kPacingInfo0(0, 5, 2000); | 33 const PacedPacketInfo kPacingInfo0(0, 5, 2000); |
33 const PacedPacketInfo kPacingInfo1(1, 8, 4000); | 34 const PacedPacketInfo kPacingInfo1(1, 8, 4000); |
34 const PacedPacketInfo kPacingInfo2(2, 14, 7000); | 35 const PacedPacketInfo kPacingInfo2(2, 14, 7000); |
35 const PacedPacketInfo kPacingInfo3(3, 20, 10000); | 36 const PacedPacketInfo kPacingInfo3(3, 20, 10000); |
36 const PacedPacketInfo kPacingInfo4(4, 22, 10000); | 37 const PacedPacketInfo kPacingInfo4(4, 22, 10000); |
37 } | 38 constexpr size_t kRtpHeadersSize = 12; |
| 39 constexpr size_t kTransportHeadersSize = 20; |
| 40 |
| 41 } // namespace |
38 | 42 |
39 namespace test { | 43 namespace test { |
40 | 44 |
41 class MockPacketFeedbackObserver : public webrtc::PacketFeedbackObserver { | 45 class MockPacketFeedbackObserver : public webrtc::PacketFeedbackObserver { |
42 public: | 46 public: |
43 MOCK_METHOD2(OnPacketAdded, void(uint32_t ssrc, uint16_t seq_num)); | 47 MOCK_METHOD2(OnPacketAdded, void(uint32_t ssrc, uint16_t seq_num)); |
44 MOCK_METHOD1(OnPacketFeedbackVector, | 48 MOCK_METHOD1(OnPacketFeedbackVector, |
45 void(const std::vector<PacketFeedback>& packet_feedback_vector)); | 49 void(const std::vector<PacketFeedback>& packet_feedback_vector)); |
46 }; | 50 }; |
47 | 51 |
(...skipping 10 matching lines...) Expand all Loading... |
58 virtual void TearDown() { adapter_.reset(); } | 62 virtual void TearDown() { adapter_.reset(); } |
59 | 63 |
60 protected: | 64 protected: |
61 void OnReceivedEstimatedBitrate(uint32_t bitrate) {} | 65 void OnReceivedEstimatedBitrate(uint32_t bitrate) {} |
62 | 66 |
63 void OnReceivedRtcpReceiverReport(const ReportBlockList& report_blocks, | 67 void OnReceivedRtcpReceiverReport(const ReportBlockList& report_blocks, |
64 int64_t rtt, | 68 int64_t rtt, |
65 int64_t now_ms) {} | 69 int64_t now_ms) {} |
66 | 70 |
67 void OnSentPacket(const PacketFeedback& packet_feedback) { | 71 void OnSentPacket(const PacketFeedback& packet_feedback) { |
68 adapter_->AddPacket(kSsrc, packet_feedback.sequence_number, | 72 adapter_->AddPacket( |
69 packet_feedback.payload_size, | 73 kSsrc, packet_feedback.sequence_number, packet_feedback.payload_size, |
70 packet_feedback.pacing_info); | 74 packet_feedback.rtp_headers_size, packet_feedback.pacing_info); |
71 adapter_->OnSentPacket(packet_feedback.sequence_number, | 75 adapter_->OnSentPacket(packet_feedback.sequence_number, |
72 packet_feedback.send_time_ms); | 76 packet_feedback.send_time_ms); |
73 } | 77 } |
74 | 78 |
75 static constexpr uint32_t kSsrc = 8492; | 79 static constexpr uint32_t kSsrc = 8492; |
76 | 80 |
77 SimulatedClock clock_; | 81 SimulatedClock clock_; |
78 std::unique_ptr<TransportFeedbackAdapter> adapter_; | 82 std::unique_ptr<TransportFeedbackAdapter> adapter_; |
79 }; | 83 }; |
80 | 84 |
81 TEST_F(TransportFeedbackAdapterTest, ObserverSanity) { | 85 TEST_F(TransportFeedbackAdapterTest, ObserverSanity) { |
82 MockPacketFeedbackObserver mock; | 86 MockPacketFeedbackObserver mock; |
83 adapter_->RegisterPacketFeedbackObserver(&mock); | 87 adapter_->RegisterPacketFeedbackObserver(&mock); |
84 | 88 |
85 const std::vector<PacketFeedback> packets = { | 89 const std::vector<PacketFeedback> packets = { |
86 PacketFeedback(100, 200, 0, 1000, kPacingInfo0), | 90 PacketFeedback(100, 200, 0, 1000, kRtpHeadersSize, kTransportHeadersSize, |
87 PacketFeedback(110, 210, 1, 2000, kPacingInfo0), | 91 kPacingInfo0), |
88 PacketFeedback(120, 220, 2, 3000, kPacingInfo0) | 92 PacketFeedback(110, 210, 1, 2000, kRtpHeadersSize, kTransportHeadersSize, |
89 }; | 93 kPacingInfo0), |
| 94 PacketFeedback(120, 220, 2, 3000, kRtpHeadersSize, kTransportHeadersSize, |
| 95 kPacingInfo0)}; |
90 | 96 |
91 rtcp::TransportFeedback feedback; | 97 rtcp::TransportFeedback feedback; |
92 feedback.SetBase(packets[0].sequence_number, | 98 feedback.SetBase(packets[0].sequence_number, |
93 packets[0].arrival_time_ms * 1000); | 99 packets[0].arrival_time_ms * 1000); |
94 | 100 |
95 for (const PacketFeedback& packet : packets) { | 101 for (const PacketFeedback& packet : packets) { |
96 EXPECT_CALL(mock, OnPacketAdded(kSsrc, packet.sequence_number)).Times(1); | 102 EXPECT_CALL(mock, OnPacketAdded(kSsrc, packet.sequence_number)).Times(1); |
97 OnSentPacket(packet); | 103 OnSentPacket(packet); |
98 EXPECT_TRUE(feedback.AddReceivedPacket(packet.sequence_number, | 104 EXPECT_TRUE(feedback.AddReceivedPacket(packet.sequence_number, |
99 packet.arrival_time_ms * 1000)); | 105 packet.arrival_time_ms * 1000)); |
100 } | 106 } |
101 | 107 |
102 EXPECT_CALL(mock, OnPacketFeedbackVector(_)).Times(1); | 108 EXPECT_CALL(mock, OnPacketFeedbackVector(_)).Times(1); |
103 adapter_->OnTransportFeedback(feedback); | 109 adapter_->OnTransportFeedback(feedback); |
104 | 110 |
105 adapter_->DeRegisterPacketFeedbackObserver(&mock); | 111 adapter_->DeRegisterPacketFeedbackObserver(&mock); |
106 | 112 |
107 // After deregistration, the observer no longers gets indications. | 113 // After deregistration, the observer no longers gets indications. |
108 EXPECT_CALL(mock, OnPacketAdded(_, _)).Times(0); | 114 EXPECT_CALL(mock, OnPacketAdded(_, _)).Times(0); |
109 const PacketFeedback new_packet(130, 230, 3, 4000, kPacingInfo0); | 115 const PacketFeedback new_packet(130, 230, 3, 4000, kRtpHeadersSize, |
| 116 kTransportHeadersSize, kPacingInfo0); |
110 OnSentPacket(new_packet); | 117 OnSentPacket(new_packet); |
111 | 118 |
112 rtcp::TransportFeedback second_feedback; | 119 rtcp::TransportFeedback second_feedback; |
113 second_feedback.SetBase(new_packet.sequence_number, | 120 second_feedback.SetBase(new_packet.sequence_number, |
114 new_packet.arrival_time_ms * 1000); | 121 new_packet.arrival_time_ms * 1000); |
115 EXPECT_TRUE(feedback.AddReceivedPacket(new_packet.sequence_number, | 122 EXPECT_TRUE(feedback.AddReceivedPacket(new_packet.sequence_number, |
116 new_packet.arrival_time_ms * 1000)); | 123 new_packet.arrival_time_ms * 1000)); |
117 EXPECT_CALL(mock, OnPacketFeedbackVector(_)).Times(0); | 124 EXPECT_CALL(mock, OnPacketFeedbackVector(_)).Times(0); |
118 adapter_->OnTransportFeedback(second_feedback); | 125 adapter_->OnTransportFeedback(second_feedback); |
119 } | 126 } |
120 | 127 |
121 #if RTC_DCHECK_IS_ON && GTEST_HAS_DEATH_TEST && !defined(WEBRTC_ANDROID) | 128 #if RTC_DCHECK_IS_ON && GTEST_HAS_DEATH_TEST && !defined(WEBRTC_ANDROID) |
122 TEST_F(TransportFeedbackAdapterTest, ObserverDoubleRegistrationDeathTest) { | 129 TEST_F(TransportFeedbackAdapterTest, ObserverDoubleRegistrationDeathTest) { |
123 MockPacketFeedbackObserver mock; | 130 MockPacketFeedbackObserver mock; |
124 adapter_->RegisterPacketFeedbackObserver(&mock); | 131 adapter_->RegisterPacketFeedbackObserver(&mock); |
125 EXPECT_DEATH(adapter_->RegisterPacketFeedbackObserver(&mock), ""); | 132 EXPECT_DEATH(adapter_->RegisterPacketFeedbackObserver(&mock), ""); |
126 adapter_->DeRegisterPacketFeedbackObserver(&mock); | 133 adapter_->DeRegisterPacketFeedbackObserver(&mock); |
127 } | 134 } |
128 | 135 |
129 TEST_F(TransportFeedbackAdapterTest, ObserverMissingDeRegistrationDeathTest) { | 136 TEST_F(TransportFeedbackAdapterTest, ObserverMissingDeRegistrationDeathTest) { |
130 MockPacketFeedbackObserver mock; | 137 MockPacketFeedbackObserver mock; |
131 adapter_->RegisterPacketFeedbackObserver(&mock); | 138 adapter_->RegisterPacketFeedbackObserver(&mock); |
132 EXPECT_DEATH(adapter_.reset(), ""); | 139 EXPECT_DEATH(adapter_.reset(), ""); |
133 adapter_->DeRegisterPacketFeedbackObserver(&mock); | 140 adapter_->DeRegisterPacketFeedbackObserver(&mock); |
134 } | 141 } |
135 #endif | 142 #endif |
136 | 143 |
137 TEST_F(TransportFeedbackAdapterTest, AdaptsFeedbackAndPopulatesSendTimes) { | 144 TEST_F(TransportFeedbackAdapterTest, AdaptsFeedbackAndPopulatesSendTimes) { |
138 std::vector<PacketFeedback> packets; | 145 std::vector<PacketFeedback> packets; |
139 packets.push_back(PacketFeedback(100, 200, 0, 1500, kPacingInfo0)); | 146 packets.push_back(PacketFeedback(100, 200, 0, 1500, kRtpHeadersSize, |
140 packets.push_back(PacketFeedback(110, 210, 1, 1500, kPacingInfo0)); | 147 kTransportHeadersSize, kPacingInfo0)); |
141 packets.push_back(PacketFeedback(120, 220, 2, 1500, kPacingInfo0)); | 148 packets.push_back(PacketFeedback(110, 210, 1, 1500, kRtpHeadersSize, |
142 packets.push_back(PacketFeedback(130, 230, 3, 1500, kPacingInfo1)); | 149 kTransportHeadersSize, kPacingInfo0)); |
143 packets.push_back(PacketFeedback(140, 240, 4, 1500, kPacingInfo1)); | 150 packets.push_back(PacketFeedback(120, 220, 2, 1500, kRtpHeadersSize, |
| 151 kTransportHeadersSize, kPacingInfo0)); |
| 152 packets.push_back(PacketFeedback(130, 230, 3, 1500, kRtpHeadersSize, |
| 153 kTransportHeadersSize, kPacingInfo1)); |
| 154 packets.push_back(PacketFeedback(140, 240, 4, 1500, kRtpHeadersSize, |
| 155 kTransportHeadersSize, kPacingInfo1)); |
144 | 156 |
145 for (const PacketFeedback& packet : packets) | 157 for (const PacketFeedback& packet : packets) |
146 OnSentPacket(packet); | 158 OnSentPacket(packet); |
147 | 159 |
148 rtcp::TransportFeedback feedback; | 160 rtcp::TransportFeedback feedback; |
149 feedback.SetBase(packets[0].sequence_number, | 161 feedback.SetBase(packets[0].sequence_number, |
150 packets[0].arrival_time_ms * 1000); | 162 packets[0].arrival_time_ms * 1000); |
151 | 163 |
152 for (const PacketFeedback& packet : packets) { | 164 for (const PacketFeedback& packet : packets) { |
153 EXPECT_TRUE(feedback.AddReceivedPacket(packet.sequence_number, | 165 EXPECT_TRUE(feedback.AddReceivedPacket(packet.sequence_number, |
154 packet.arrival_time_ms * 1000)); | 166 packet.arrival_time_ms * 1000)); |
155 } | 167 } |
156 | 168 |
157 feedback.Build(); | 169 feedback.Build(); |
158 | 170 |
159 adapter_->OnTransportFeedback(feedback); | 171 adapter_->OnTransportFeedback(feedback); |
160 ComparePacketFeedbackVectors(packets, adapter_->GetTransportFeedbackVector()); | 172 ComparePacketFeedbackVectors(packets, adapter_->GetTransportFeedbackVector()); |
161 } | 173 } |
162 | 174 |
163 TEST_F(TransportFeedbackAdapterTest, FeedbackVectorReportsUnreceived) { | 175 TEST_F(TransportFeedbackAdapterTest, FeedbackVectorReportsUnreceived) { |
164 std::vector<PacketFeedback> sent_packets = { | 176 std::vector<PacketFeedback> sent_packets = { |
165 PacketFeedback(100, 220, 0, 1500, kPacingInfo0), | 177 PacketFeedback(100, 220, 0, 1500, kRtpHeadersSize, kTransportHeadersSize, |
166 PacketFeedback(110, 210, 1, 1500, kPacingInfo0), | 178 kPacingInfo0), |
167 PacketFeedback(120, 220, 2, 1500, kPacingInfo0), | 179 PacketFeedback(110, 210, 1, 1500, kRtpHeadersSize, kTransportHeadersSize, |
168 PacketFeedback(130, 230, 3, 1500, kPacingInfo0), | 180 kPacingInfo0), |
169 PacketFeedback(140, 240, 4, 1500, kPacingInfo0), | 181 PacketFeedback(120, 220, 2, 1500, kRtpHeadersSize, kTransportHeadersSize, |
170 PacketFeedback(150, 250, 5, 1500, kPacingInfo0), | 182 kPacingInfo0), |
171 PacketFeedback(160, 260, 6, 1500, kPacingInfo0) | 183 PacketFeedback(130, 230, 3, 1500, kRtpHeadersSize, kTransportHeadersSize, |
172 }; | 184 kPacingInfo0), |
| 185 PacketFeedback(140, 240, 4, 1500, kRtpHeadersSize, kTransportHeadersSize, |
| 186 kPacingInfo0), |
| 187 PacketFeedback(150, 250, 5, 1500, kRtpHeadersSize, kTransportHeadersSize, |
| 188 kPacingInfo0), |
| 189 PacketFeedback(160, 260, 6, 1500, kRtpHeadersSize, kTransportHeadersSize, |
| 190 kPacingInfo0)}; |
173 | 191 |
174 for (const PacketFeedback& packet : sent_packets) | 192 for (const PacketFeedback& packet : sent_packets) |
175 OnSentPacket(packet); | 193 OnSentPacket(packet); |
176 | 194 |
177 // Note: Important to include the last packet, as only unreceived packets in | 195 // Note: Important to include the last packet, as only unreceived packets in |
178 // between received packets can be inferred. | 196 // between received packets can be inferred. |
179 std::vector<PacketFeedback> received_packets = { | 197 std::vector<PacketFeedback> received_packets = { |
180 sent_packets[0], sent_packets[2], sent_packets[6] | 198 sent_packets[0], sent_packets[2], sent_packets[6] |
181 }; | 199 }; |
182 | 200 |
183 rtcp::TransportFeedback feedback; | 201 rtcp::TransportFeedback feedback; |
184 feedback.SetBase(received_packets[0].sequence_number, | 202 feedback.SetBase(received_packets[0].sequence_number, |
185 received_packets[0].arrival_time_ms * 1000); | 203 received_packets[0].arrival_time_ms * 1000); |
186 | 204 |
187 for (const PacketFeedback& packet : received_packets) { | 205 for (const PacketFeedback& packet : received_packets) { |
188 EXPECT_TRUE(feedback.AddReceivedPacket(packet.sequence_number, | 206 EXPECT_TRUE(feedback.AddReceivedPacket(packet.sequence_number, |
189 packet.arrival_time_ms * 1000)); | 207 packet.arrival_time_ms * 1000)); |
190 } | 208 } |
191 | 209 |
192 feedback.Build(); | 210 feedback.Build(); |
193 | 211 |
194 adapter_->OnTransportFeedback(feedback); | 212 adapter_->OnTransportFeedback(feedback); |
195 ComparePacketFeedbackVectors(sent_packets, | 213 ComparePacketFeedbackVectors(sent_packets, |
196 adapter_->GetTransportFeedbackVector()); | 214 adapter_->GetTransportFeedbackVector()); |
197 } | 215 } |
198 | 216 |
199 TEST_F(TransportFeedbackAdapterTest, HandlesDroppedPackets) { | 217 TEST_F(TransportFeedbackAdapterTest, HandlesDroppedPackets) { |
200 std::vector<PacketFeedback> packets; | 218 std::vector<PacketFeedback> packets; |
201 packets.push_back(PacketFeedback(100, 200, 0, 1500, kPacingInfo0)); | 219 packets.push_back(PacketFeedback(100, 200, 0, 1500, kRtpHeadersSize, |
202 packets.push_back(PacketFeedback(110, 210, 1, 1500, kPacingInfo1)); | 220 kTransportHeadersSize, kPacingInfo0)); |
203 packets.push_back(PacketFeedback(120, 220, 2, 1500, kPacingInfo2)); | 221 packets.push_back(PacketFeedback(110, 210, 1, 1500, kRtpHeadersSize, |
204 packets.push_back(PacketFeedback(130, 230, 3, 1500, kPacingInfo3)); | 222 kTransportHeadersSize, kPacingInfo1)); |
205 packets.push_back(PacketFeedback(140, 240, 4, 1500, kPacingInfo4)); | 223 packets.push_back(PacketFeedback(120, 220, 2, 1500, kRtpHeadersSize, |
| 224 kTransportHeadersSize, kPacingInfo2)); |
| 225 packets.push_back(PacketFeedback(130, 230, 3, 1500, kRtpHeadersSize, |
| 226 kTransportHeadersSize, kPacingInfo3)); |
| 227 packets.push_back(PacketFeedback(140, 240, 4, 1500, kRtpHeadersSize, |
| 228 kTransportHeadersSize, kPacingInfo4)); |
206 | 229 |
207 const uint16_t kSendSideDropBefore = 1; | 230 const uint16_t kSendSideDropBefore = 1; |
208 const uint16_t kReceiveSideDropAfter = 3; | 231 const uint16_t kReceiveSideDropAfter = 3; |
209 | 232 |
210 for (const PacketFeedback& packet : packets) { | 233 for (const PacketFeedback& packet : packets) { |
211 if (packet.sequence_number >= kSendSideDropBefore) | 234 if (packet.sequence_number >= kSendSideDropBefore) |
212 OnSentPacket(packet); | 235 OnSentPacket(packet); |
213 } | 236 } |
214 | 237 |
215 rtcp::TransportFeedback feedback; | 238 rtcp::TransportFeedback feedback; |
(...skipping 22 matching lines...) Expand all Loading... |
238 adapter_->OnTransportFeedback(feedback); | 261 adapter_->OnTransportFeedback(feedback); |
239 ComparePacketFeedbackVectors(expected_packets, | 262 ComparePacketFeedbackVectors(expected_packets, |
240 adapter_->GetTransportFeedbackVector()); | 263 adapter_->GetTransportFeedbackVector()); |
241 } | 264 } |
242 | 265 |
243 TEST_F(TransportFeedbackAdapterTest, SendTimeWrapsBothWays) { | 266 TEST_F(TransportFeedbackAdapterTest, SendTimeWrapsBothWays) { |
244 int64_t kHighArrivalTimeMs = rtcp::TransportFeedback::kDeltaScaleFactor * | 267 int64_t kHighArrivalTimeMs = rtcp::TransportFeedback::kDeltaScaleFactor * |
245 static_cast<int64_t>(1 << 8) * | 268 static_cast<int64_t>(1 << 8) * |
246 static_cast<int64_t>((1 << 23) - 1) / 1000; | 269 static_cast<int64_t>((1 << 23) - 1) / 1000; |
247 std::vector<PacketFeedback> packets; | 270 std::vector<PacketFeedback> packets; |
248 packets.push_back( | 271 packets.push_back(PacketFeedback(kHighArrivalTimeMs - 64, 200, 0, 1500, |
249 PacketFeedback(kHighArrivalTimeMs - 64, 200, 0, 1500, PacedPacketInfo())); | 272 kRtpHeadersSize, kTransportHeadersSize, |
250 packets.push_back( | 273 PacedPacketInfo())); |
251 PacketFeedback(kHighArrivalTimeMs + 64, 210, 1, 1500, PacedPacketInfo())); | 274 packets.push_back(PacketFeedback(kHighArrivalTimeMs + 64, 210, 1, 1500, |
252 packets.push_back( | 275 kRtpHeadersSize, kTransportHeadersSize, |
253 PacketFeedback(kHighArrivalTimeMs, 220, 2, 1500, PacedPacketInfo())); | 276 PacedPacketInfo())); |
| 277 packets.push_back(PacketFeedback(kHighArrivalTimeMs, 220, 2, 1500, |
| 278 kRtpHeadersSize, kTransportHeadersSize, |
| 279 PacedPacketInfo())); |
254 | 280 |
255 for (const PacketFeedback& packet : packets) | 281 for (const PacketFeedback& packet : packets) |
256 OnSentPacket(packet); | 282 OnSentPacket(packet); |
257 | 283 |
258 for (size_t i = 0; i < packets.size(); ++i) { | 284 for (size_t i = 0; i < packets.size(); ++i) { |
259 std::unique_ptr<rtcp::TransportFeedback> feedback( | 285 std::unique_ptr<rtcp::TransportFeedback> feedback( |
260 new rtcp::TransportFeedback()); | 286 new rtcp::TransportFeedback()); |
261 feedback->SetBase(packets[i].sequence_number, | 287 feedback->SetBase(packets[i].sequence_number, |
262 packets[i].arrival_time_ms * 1000); | 288 packets[i].arrival_time_ms * 1000); |
263 | 289 |
264 EXPECT_TRUE(feedback->AddReceivedPacket(packets[i].sequence_number, | 290 EXPECT_TRUE(feedback->AddReceivedPacket(packets[i].sequence_number, |
265 packets[i].arrival_time_ms * 1000)); | 291 packets[i].arrival_time_ms * 1000)); |
266 | 292 |
267 rtc::Buffer raw_packet = feedback->Build(); | 293 rtc::Buffer raw_packet = feedback->Build(); |
268 feedback = rtcp::TransportFeedback::ParseFrom(raw_packet.data(), | 294 feedback = rtcp::TransportFeedback::ParseFrom(raw_packet.data(), |
269 raw_packet.size()); | 295 raw_packet.size()); |
270 | 296 |
271 std::vector<PacketFeedback> expected_packets; | 297 std::vector<PacketFeedback> expected_packets; |
272 expected_packets.push_back(packets[i]); | 298 expected_packets.push_back(packets[i]); |
273 | 299 |
274 adapter_->OnTransportFeedback(*feedback.get()); | 300 adapter_->OnTransportFeedback(*feedback.get()); |
275 ComparePacketFeedbackVectors(expected_packets, | 301 ComparePacketFeedbackVectors(expected_packets, |
276 adapter_->GetTransportFeedbackVector()); | 302 adapter_->GetTransportFeedbackVector()); |
277 } | 303 } |
278 } | 304 } |
279 | 305 |
280 TEST_F(TransportFeedbackAdapterTest, HandlesArrivalReordering) { | 306 TEST_F(TransportFeedbackAdapterTest, HandlesArrivalReordering) { |
281 std::vector<PacketFeedback> packets; | 307 std::vector<PacketFeedback> packets; |
282 packets.push_back(PacketFeedback(120, 200, 0, 1500, kPacingInfo0)); | 308 packets.push_back(PacketFeedback(120, 200, 0, 1500, kRtpHeadersSize, |
283 packets.push_back(PacketFeedback(110, 210, 1, 1500, kPacingInfo0)); | 309 kTransportHeadersSize, kPacingInfo0)); |
284 packets.push_back(PacketFeedback(100, 220, 2, 1500, kPacingInfo0)); | 310 packets.push_back(PacketFeedback(110, 210, 1, 1500, kRtpHeadersSize, |
| 311 kTransportHeadersSize, kPacingInfo0)); |
| 312 packets.push_back(PacketFeedback(100, 220, 2, 1500, kRtpHeadersSize, |
| 313 kTransportHeadersSize, kPacingInfo0)); |
285 | 314 |
286 for (const PacketFeedback& packet : packets) | 315 for (const PacketFeedback& packet : packets) |
287 OnSentPacket(packet); | 316 OnSentPacket(packet); |
288 | 317 |
289 rtcp::TransportFeedback feedback; | 318 rtcp::TransportFeedback feedback; |
290 feedback.SetBase(packets[0].sequence_number, | 319 feedback.SetBase(packets[0].sequence_number, |
291 packets[0].arrival_time_ms * 1000); | 320 packets[0].arrival_time_ms * 1000); |
292 | 321 |
293 for (const PacketFeedback& packet : packets) { | 322 for (const PacketFeedback& packet : packets) { |
294 EXPECT_TRUE(feedback.AddReceivedPacket(packet.sequence_number, | 323 EXPECT_TRUE(feedback.AddReceivedPacket(packet.sequence_number, |
(...skipping 13 matching lines...) Expand all Loading... |
308 std::vector<PacketFeedback> sent_packets; | 337 std::vector<PacketFeedback> sent_packets; |
309 const int64_t kSmallDeltaUs = | 338 const int64_t kSmallDeltaUs = |
310 rtcp::TransportFeedback::kDeltaScaleFactor * ((1 << 8) - 1); | 339 rtcp::TransportFeedback::kDeltaScaleFactor * ((1 << 8) - 1); |
311 const int64_t kLargePositiveDeltaUs = | 340 const int64_t kLargePositiveDeltaUs = |
312 rtcp::TransportFeedback::kDeltaScaleFactor * | 341 rtcp::TransportFeedback::kDeltaScaleFactor * |
313 std::numeric_limits<int16_t>::max(); | 342 std::numeric_limits<int16_t>::max(); |
314 const int64_t kLargeNegativeDeltaUs = | 343 const int64_t kLargeNegativeDeltaUs = |
315 rtcp::TransportFeedback::kDeltaScaleFactor * | 344 rtcp::TransportFeedback::kDeltaScaleFactor * |
316 std::numeric_limits<int16_t>::min(); | 345 std::numeric_limits<int16_t>::min(); |
317 | 346 |
318 PacketFeedback packet_feedback(100, 200, 0, 1500, true, 0, 0, | 347 PacketFeedback packet_feedback(100, 200, 0, 1500, kRtpHeadersSize, |
| 348 kTransportHeadersSize, true, 0, 0, |
319 PacedPacketInfo()); | 349 PacedPacketInfo()); |
320 sent_packets.push_back(packet_feedback); | 350 sent_packets.push_back(packet_feedback); |
321 | 351 |
322 packet_feedback.send_time_ms += kSmallDeltaUs / 1000; | 352 packet_feedback.send_time_ms += kSmallDeltaUs / 1000; |
323 packet_feedback.arrival_time_ms += kSmallDeltaUs / 1000; | 353 packet_feedback.arrival_time_ms += kSmallDeltaUs / 1000; |
324 ++packet_feedback.sequence_number; | 354 ++packet_feedback.sequence_number; |
325 sent_packets.push_back(packet_feedback); | 355 sent_packets.push_back(packet_feedback); |
326 | 356 |
327 packet_feedback.send_time_ms += kLargePositiveDeltaUs / 1000; | 357 packet_feedback.send_time_ms += kLargePositiveDeltaUs / 1000; |
328 packet_feedback.arrival_time_ms += kLargePositiveDeltaUs / 1000; | 358 packet_feedback.arrival_time_ms += kLargePositiveDeltaUs / 1000; |
(...skipping 53 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
382 adapter_->OnTransportFeedback(*feedback.get()); | 412 adapter_->OnTransportFeedback(*feedback.get()); |
383 { | 413 { |
384 std::vector<PacketFeedback> expected_packets; | 414 std::vector<PacketFeedback> expected_packets; |
385 expected_packets.push_back(packet_feedback); | 415 expected_packets.push_back(packet_feedback); |
386 ComparePacketFeedbackVectors(expected_packets, | 416 ComparePacketFeedbackVectors(expected_packets, |
387 adapter_->GetTransportFeedbackVector()); | 417 adapter_->GetTransportFeedbackVector()); |
388 } | 418 } |
389 } | 419 } |
390 } // namespace test | 420 } // namespace test |
391 } // namespace webrtc | 421 } // namespace webrtc |
OLD | NEW |