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 149 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
160 private: | 160 private: |
161 // Arbitrary values, won't change these test results. | 161 // Arbitrary values, won't change these test results. |
162 static const int kFlowId = 2; | 162 static const int kFlowId = 2; |
163 static const int64_t kNowMs = 1000; | 163 static const int64_t kNowMs = 1000; |
164 }; | 164 }; |
165 | 165 |
166 // Verify if AcceleratedRampUp is called and that bitrate increases. | 166 // Verify if AcceleratedRampUp is called and that bitrate increases. |
167 TEST_F(NadaSenderSideTest, AcceleratedRampUp) { | 167 TEST_F(NadaSenderSideTest, AcceleratedRampUp) { |
168 const int64_t kRefSignalMs = 3; | 168 const int64_t kRefSignalMs = 3; |
169 const int64_t kOneWayDelayMs = 50; | 169 const int64_t kOneWayDelayMs = 50; |
170 int original_bitrate = 2 * NadaBweSender::kMinRefRateKbps; | 170 int original_bitrate = 2 * kMinBitrateKbps; |
171 size_t receiving_rate = static_cast<size_t>(original_bitrate); | 171 size_t receiving_rate = static_cast<size_t>(original_bitrate); |
172 int64_t send_time_ms = nada_sender_.NowMs() - kOneWayDelayMs; | 172 int64_t send_time_ms = nada_sender_.NowMs() - kOneWayDelayMs; |
173 | 173 |
174 NadaFeedback not_congested_fb = NadaFbGenerator::NotCongestedFb( | 174 NadaFeedback not_congested_fb = NadaFbGenerator::NotCongestedFb( |
175 receiving_rate, kRefSignalMs, send_time_ms); | 175 receiving_rate, kRefSignalMs, send_time_ms); |
176 | 176 |
177 nada_sender_.set_original_operating_mode(true); | 177 nada_sender_.set_original_operating_mode(true); |
178 nada_sender_.set_bitrate_kbps(original_bitrate); | 178 nada_sender_.set_bitrate_kbps(original_bitrate); |
179 | 179 |
180 // Trigger AcceleratedRampUp mode. | 180 // Trigger AcceleratedRampUp mode. |
(...skipping 11 matching lines...) Expand all Loading... | |
192 nada_sender_.GiveFeedback(not_congested_fb); | 192 nada_sender_.GiveFeedback(not_congested_fb); |
193 bitrate_1_kbps = nada_sender_.bitrate_kbps(); | 193 bitrate_1_kbps = nada_sender_.bitrate_kbps(); |
194 EXPECT_GT(bitrate_1_kbps, original_bitrate); | 194 EXPECT_GT(bitrate_1_kbps, original_bitrate); |
195 nada_sender_.AcceleratedRampUp(not_congested_fb); | 195 nada_sender_.AcceleratedRampUp(not_congested_fb); |
196 EXPECT_EQ(nada_sender_.bitrate_kbps(), bitrate_1_kbps); | 196 EXPECT_EQ(nada_sender_.bitrate_kbps(), bitrate_1_kbps); |
197 } | 197 } |
198 | 198 |
199 // Verify if AcceleratedRampDown is called and if bitrate decreases. | 199 // Verify if AcceleratedRampDown is called and if bitrate decreases. |
200 TEST_F(NadaSenderSideTest, AcceleratedRampDown) { | 200 TEST_F(NadaSenderSideTest, AcceleratedRampDown) { |
201 const int64_t kOneWayDelayMs = 50; | 201 const int64_t kOneWayDelayMs = 50; |
202 int original_bitrate = 3 * NadaBweSender::kMinRefRateKbps; | 202 int original_bitrate = 3 * kMinBitrateKbps; |
203 size_t receiving_rate = static_cast<size_t>(original_bitrate); | 203 size_t receiving_rate = static_cast<size_t>(original_bitrate); |
204 int64_t send_time_ms = nada_sender_.NowMs() - kOneWayDelayMs; | 204 int64_t send_time_ms = nada_sender_.NowMs() - kOneWayDelayMs; |
205 | 205 |
206 NadaFeedback congested_fb = | 206 NadaFeedback congested_fb = |
207 NadaFbGenerator::CongestedFb(receiving_rate, send_time_ms); | 207 NadaFbGenerator::CongestedFb(receiving_rate, send_time_ms); |
208 | 208 |
209 nada_sender_.set_original_operating_mode(false); | 209 nada_sender_.set_original_operating_mode(false); |
210 nada_sender_.set_bitrate_kbps(original_bitrate); | 210 nada_sender_.set_bitrate_kbps(original_bitrate); |
211 nada_sender_.GiveFeedback(congested_fb); // Trigger AcceleratedRampDown mode. | 211 nada_sender_.GiveFeedback(congested_fb); // Trigger AcceleratedRampDown mode. |
212 int bitrate_1_kbps = nada_sender_.bitrate_kbps(); | 212 int bitrate_1_kbps = nada_sender_.bitrate_kbps(); |
213 EXPECT_LE(bitrate_1_kbps, original_bitrate * 0.9f + 0.5f); | 213 EXPECT_LE(bitrate_1_kbps, original_bitrate * 0.9f + 0.5f); |
214 EXPECT_LT(bitrate_1_kbps, original_bitrate); | 214 EXPECT_LT(bitrate_1_kbps, original_bitrate); |
215 | 215 |
216 // Updates the bitrate according to the receiving rate and other constant | 216 // Updates the bitrate according to the receiving rate and other constant |
217 // parameters. | 217 // parameters. |
218 nada_sender_.AcceleratedRampDown(congested_fb); | 218 nada_sender_.AcceleratedRampDown(congested_fb); |
219 int bitrate_2_kbps = | 219 int bitrate_2_kbps = |
220 std::max(nada_sender_.bitrate_kbps(), NadaBweSender::kMinRefRateKbps); | 220 std::max(nada_sender_.bitrate_kbps(), kMinBitrateKbps); |
221 EXPECT_EQ(bitrate_2_kbps, bitrate_1_kbps); | 221 EXPECT_EQ(bitrate_2_kbps, bitrate_1_kbps); |
222 } | 222 } |
223 | 223 |
224 TEST_F(NadaSenderSideTest, GradualRateUpdate) { | 224 TEST_F(NadaSenderSideTest, GradualRateUpdate) { |
225 const int64_t kDeltaSMs = 20; | 225 const int64_t kDeltaSMs = 20; |
226 const int64_t kRefSignalMs = 20; | 226 const int64_t kRefSignalMs = 20; |
227 const int64_t kOneWayDelayMs = 50; | 227 const int64_t kOneWayDelayMs = 50; |
228 int original_bitrate = 2 * NadaBweSender::kMinRefRateKbps; | 228 int original_bitrate = 2 * kMinBitrateKbps; |
229 size_t receiving_rate = static_cast<size_t>(original_bitrate); | 229 size_t receiving_rate = static_cast<size_t>(original_bitrate); |
230 int64_t send_time_ms = nada_sender_.NowMs() - kOneWayDelayMs; | 230 int64_t send_time_ms = nada_sender_.NowMs() - kOneWayDelayMs; |
231 | 231 |
232 NadaFeedback congested_fb = | 232 NadaFeedback congested_fb = |
233 NadaFbGenerator::CongestedFb(receiving_rate, send_time_ms); | 233 NadaFbGenerator::CongestedFb(receiving_rate, send_time_ms); |
234 NadaFeedback not_congested_fb = NadaFbGenerator::NotCongestedFb( | 234 NadaFeedback not_congested_fb = NadaFbGenerator::NotCongestedFb( |
235 original_bitrate, kRefSignalMs, send_time_ms); | 235 original_bitrate, kRefSignalMs, send_time_ms); |
236 | 236 |
237 nada_sender_.set_bitrate_kbps(original_bitrate); | 237 nada_sender_.set_bitrate_kbps(original_bitrate); |
238 double smoothing_factor = 0.0; | 238 double smoothing_factor = 0.0; |
239 nada_sender_.GradualRateUpdate(congested_fb, kDeltaSMs, smoothing_factor); | 239 nada_sender_.GradualRateUpdate(congested_fb, kDeltaSMs, smoothing_factor); |
240 EXPECT_EQ(nada_sender_.bitrate_kbps(), original_bitrate); | 240 EXPECT_EQ(nada_sender_.bitrate_kbps(), original_bitrate); |
241 | 241 |
242 smoothing_factor = 1.0; | 242 smoothing_factor = 1.0; |
243 nada_sender_.GradualRateUpdate(congested_fb, kDeltaSMs, smoothing_factor); | 243 nada_sender_.GradualRateUpdate(congested_fb, kDeltaSMs, smoothing_factor); |
244 EXPECT_LT(nada_sender_.bitrate_kbps(), original_bitrate); | 244 EXPECT_LT(nada_sender_.bitrate_kbps(), original_bitrate); |
245 | 245 |
246 nada_sender_.set_bitrate_kbps(original_bitrate); | 246 nada_sender_.set_bitrate_kbps(original_bitrate); |
247 nada_sender_.GradualRateUpdate(not_congested_fb, kDeltaSMs, smoothing_factor); | 247 nada_sender_.GradualRateUpdate(not_congested_fb, kDeltaSMs, smoothing_factor); |
248 EXPECT_GT(nada_sender_.bitrate_kbps(), original_bitrate); | 248 EXPECT_GT(nada_sender_.bitrate_kbps(), original_bitrate); |
249 } | 249 } |
250 | 250 |
251 // Sending bitrate should decrease and reach its Min bound. | 251 // Sending bitrate should decrease and reach its Min bound. |
252 TEST_F(NadaSenderSideTest, VeryLowBandwith) { | 252 TEST_F(NadaSenderSideTest, VeryLowBandwith) { |
253 const int64_t kOneWayDelayMs = 50; | 253 const int64_t kOneWayDelayMs = 50; |
254 const int kMin = NadaBweSender::kMinRefRateKbps; | 254 |
255 size_t receiving_rate = static_cast<size_t>(kMin); | 255 size_t receiving_rate = static_cast<size_t>(kMinBitrateKbps); |
256 int64_t send_time_ms = nada_sender_.NowMs() - kOneWayDelayMs; | 256 int64_t send_time_ms = nada_sender_.NowMs() - kOneWayDelayMs; |
257 | 257 |
258 NadaFeedback extremely_congested_fb = | 258 NadaFeedback extremely_congested_fb = |
259 NadaFbGenerator::ExtremelyCongestedFb(receiving_rate, send_time_ms); | 259 NadaFbGenerator::ExtremelyCongestedFb(receiving_rate, send_time_ms); |
260 NadaFeedback congested_fb = | 260 NadaFeedback congested_fb = |
261 NadaFbGenerator::CongestedFb(receiving_rate, send_time_ms); | 261 NadaFbGenerator::CongestedFb(receiving_rate, send_time_ms); |
262 | 262 |
263 nada_sender_.set_bitrate_kbps(5 * kMin); | 263 nada_sender_.set_bitrate_kbps(5 * kMinBitrateKbps); |
264 nada_sender_.set_original_operating_mode(true); | 264 nada_sender_.set_original_operating_mode(true); |
265 for (int i = 0; i < 100; ++i) { | 265 for (int i = 0; i < 100; ++i) { |
266 // Trigger GradualRateUpdate mode. | 266 // Trigger GradualRateUpdate mode. |
267 nada_sender_.GiveFeedback(extremely_congested_fb); | 267 nada_sender_.GiveFeedback(extremely_congested_fb); |
268 } | 268 } |
269 // The original implementation doesn't allow the bitrate to stay at kMin, | 269 // The original implementation doesn't allow the bitrate to stay at kMin, |
270 // even if the congestion signal is very high. | 270 // even if the congestion signal is very high. |
271 EXPECT_GE(nada_sender_.bitrate_kbps(), kMin); | 271 EXPECT_GE(nada_sender_.bitrate_kbps(), kMinBitrateKbps); |
272 | 272 |
273 nada_sender_.set_original_operating_mode(false); | 273 nada_sender_.set_original_operating_mode(false); |
274 nada_sender_.set_bitrate_kbps(5 * kMin); | 274 nada_sender_.set_bitrate_kbps(5 * kMinBitrateKbps); |
275 | 275 |
276 for (int i = 0; i < 100; ++i) { | 276 for (int i = 0; i < 100; ++i) { |
277 int previous_bitrate = nada_sender_.bitrate_kbps(); | 277 int previous_bitrate = nada_sender_.bitrate_kbps(); |
278 // Trigger AcceleratedRampDown mode. | 278 // Trigger AcceleratedRampDown mode. |
279 nada_sender_.GiveFeedback(congested_fb); | 279 nada_sender_.GiveFeedback(congested_fb); |
280 EXPECT_LE(nada_sender_.bitrate_kbps(), previous_bitrate); | 280 EXPECT_LE(nada_sender_.bitrate_kbps(), previous_bitrate); |
281 } | 281 } |
282 EXPECT_EQ(nada_sender_.bitrate_kbps(), kMin); | 282 EXPECT_EQ(nada_sender_.bitrate_kbps(), kMinBitrateKbps); |
283 } | 283 } |
284 | 284 |
285 // Sending bitrate should increase and reach its Max bound. | 285 // Sending bitrate should increase and reach its Max bound. |
286 TEST_F(NadaSenderSideTest, VeryHighBandwith) { | 286 TEST_F(NadaSenderSideTest, VeryHighBandwith) { |
287 const int64_t kOneWayDelayMs = 50; | 287 const int64_t kOneWayDelayMs = 50; |
288 const int kMax = NadaBweSender::kMaxRefRateKbps; | 288 const size_t kRecentReceivingRate = static_cast<size_t>(kMaxBitrateKbps); |
289 const size_t kRecentReceivingRate = static_cast<size_t>(kMax); | |
290 const int64_t kRefSignalMs = 5; | 289 const int64_t kRefSignalMs = 5; |
291 int64_t send_time_ms = nada_sender_.NowMs() - kOneWayDelayMs; | 290 int64_t send_time_ms = nada_sender_.NowMs() - kOneWayDelayMs; |
292 | 291 |
293 NadaFeedback not_congested_fb = NadaFbGenerator::NotCongestedFb( | 292 NadaFeedback not_congested_fb = NadaFbGenerator::NotCongestedFb( |
294 kRecentReceivingRate, kRefSignalMs, send_time_ms); | 293 kRecentReceivingRate, kRefSignalMs, send_time_ms); |
295 | 294 |
296 nada_sender_.set_original_operating_mode(true); | 295 nada_sender_.set_original_operating_mode(true); |
297 for (int i = 0; i < 100; ++i) { | 296 for (int i = 0; i < 100; ++i) { |
298 int previous_bitrate = nada_sender_.bitrate_kbps(); | 297 int previous_bitrate = nada_sender_.bitrate_kbps(); |
299 nada_sender_.GiveFeedback(not_congested_fb); | 298 nada_sender_.GiveFeedback(not_congested_fb); |
300 EXPECT_GE(nada_sender_.bitrate_kbps(), previous_bitrate); | 299 EXPECT_GE(nada_sender_.bitrate_kbps(), previous_bitrate); |
301 } | 300 } |
302 EXPECT_EQ(nada_sender_.bitrate_kbps(), kMax); | 301 EXPECT_EQ(nada_sender_.bitrate_kbps(), kMaxBitrateKbps); |
303 | 302 |
304 nada_sender_.set_original_operating_mode(false); | 303 nada_sender_.set_original_operating_mode(false); |
305 nada_sender_.set_bitrate_kbps(NadaBweSender::kMinRefRateKbps); | 304 nada_sender_.set_bitrate_kbps(kMinBitrateKbps); |
306 | 305 |
307 for (int i = 0; i < 100; ++i) { | 306 for (int i = 0; i < 100; ++i) { |
308 int previous_bitrate = nada_sender_.bitrate_kbps(); | 307 int previous_bitrate = nada_sender_.bitrate_kbps(); |
309 nada_sender_.GiveFeedback(not_congested_fb); | 308 nada_sender_.GiveFeedback(not_congested_fb); |
310 EXPECT_GE(nada_sender_.bitrate_kbps(), previous_bitrate); | 309 EXPECT_GE(nada_sender_.bitrate_kbps(), previous_bitrate); |
311 } | 310 } |
312 EXPECT_EQ(nada_sender_.bitrate_kbps(), kMax); | 311 EXPECT_EQ(nada_sender_.bitrate_kbps(), kMaxBitrateKbps); |
313 } | 312 } |
314 | 313 |
315 TEST_F(NadaReceiverSideTest, ReceivingRateNoPackets) { | 314 TEST_F(NadaReceiverSideTest, ReceivingRateNoPackets) { |
316 EXPECT_EQ(nada_receiver_.RecentReceivingRate(), static_cast<size_t>(0)); | 315 EXPECT_EQ(nada_receiver_.RecentKbps(), static_cast<size_t>(0)); |
317 } | 316 } |
318 | 317 |
319 TEST_F(NadaReceiverSideTest, ReceivingRateSinglePacket) { | 318 TEST_F(NadaReceiverSideTest, ReceivingRateSinglePacket) { |
320 const size_t kPayloadSizeBytes = 500 * 1000; | 319 const size_t kPayloadSizeBytes = 500 * 1000; |
321 const int64_t kSendTimeUs = 300 * 1000; | 320 const int64_t kSendTimeUs = 300 * 1000; |
322 const int64_t kArrivalTimeMs = kSendTimeUs / 1000 + 100; | 321 const int64_t kArrivalTimeMs = kSendTimeUs / 1000 + 100; |
323 const uint16_t kSequenceNumber = 1; | 322 const uint16_t kSequenceNumber = 1; |
324 const int64_t kTimeWindowMs = NadaBweReceiver::kReceivingRateTimeWindowMs; | 323 const int64_t kTimeWindowMs = NadaBweReceiver::kReceivingRateTimeWindowMs; |
325 | 324 |
326 const MediaPacket media_packet(kFlowId, kSendTimeUs, kPayloadSizeBytes, | 325 const MediaPacket media_packet(kFlowId, kSendTimeUs, kPayloadSizeBytes, |
327 kSequenceNumber); | 326 kSequenceNumber); |
328 nada_receiver_.ReceivePacket(kArrivalTimeMs, media_packet); | 327 nada_receiver_.ReceivePacket(kArrivalTimeMs, media_packet); |
329 | 328 |
330 const size_t kReceivingRateKbps = 8 * kPayloadSizeBytes / kTimeWindowMs; | 329 const size_t kReceivingRateKbps = 8 * kPayloadSizeBytes / kTimeWindowMs; |
331 | 330 |
332 EXPECT_EQ(nada_receiver_.RecentReceivingRate(), kReceivingRateKbps); | 331 EXPECT_NEAR(nada_receiver_.RecentKbps(), kReceivingRateKbps, |
333 } | 332 static_cast<float>(kReceivingRateKbps) / 100); |
334 | |
335 TEST_F(NadaReceiverSideTest, ReceivingRateLargePackets) { | |
336 const size_t kPayloadSizeBytes = 3000 * 1000; | |
337 const int64_t kTimeGapMs = 3000; // Between each packet. | |
338 const int64_t kOneWayDelayMs = 1000; | |
339 | |
340 for (int i = 1; i < 5; ++i) { | |
341 int64_t send_time_us = i * kTimeGapMs * 1000; | |
342 int64_t arrival_time_ms = send_time_us / 1000 + kOneWayDelayMs; | |
343 uint16_t sequence_number = i; | |
344 const MediaPacket media_packet(kFlowId, send_time_us, kPayloadSizeBytes, | |
345 sequence_number); | |
346 nada_receiver_.ReceivePacket(arrival_time_ms, media_packet); | |
347 } | |
348 | |
349 const size_t kReceivingRateKbps = 8 * kPayloadSizeBytes / kTimeGapMs; | |
350 EXPECT_EQ(nada_receiver_.RecentReceivingRate(), kReceivingRateKbps); | |
351 } | 333 } |
352 | 334 |
353 TEST_F(NadaReceiverSideTest, ReceivingRateSmallPackets) { | 335 TEST_F(NadaReceiverSideTest, ReceivingRateSmallPackets) { |
354 const size_t kPayloadSizeBytes = 100 * 1000; | 336 const size_t kPayloadSizeBytes = 100 * 1000; |
355 const int64_t kTimeGapMs = 50; // Between each packet. | 337 const int64_t kTimeGapMs = 50; // Between each packet. |
356 const int64_t kOneWayDelayMs = 50; | 338 const int64_t kOneWayDelayMs = 50; |
357 | 339 |
358 for (int i = 1; i < 50; ++i) { | 340 for (int i = 1; i < 50; ++i) { |
359 int64_t send_time_us = i * kTimeGapMs * 1000; | 341 int64_t send_time_us = i * kTimeGapMs * 1000; |
360 int64_t arrival_time_ms = send_time_us / 1000 + kOneWayDelayMs; | 342 int64_t arrival_time_ms = send_time_us / 1000 + kOneWayDelayMs; |
361 uint16_t sequence_number = i; | 343 uint16_t sequence_number = i; |
362 const MediaPacket media_packet(kFlowId, send_time_us, kPayloadSizeBytes, | 344 const MediaPacket media_packet(kFlowId, send_time_us, kPayloadSizeBytes, |
363 sequence_number); | 345 sequence_number); |
364 nada_receiver_.ReceivePacket(arrival_time_ms, media_packet); | 346 nada_receiver_.ReceivePacket(arrival_time_ms, media_packet); |
365 } | 347 } |
366 | 348 |
367 const size_t kReceivingRateKbps = 8 * kPayloadSizeBytes / kTimeGapMs; | 349 const size_t kReceivingRateKbps = 8 * kPayloadSizeBytes / kTimeGapMs; |
368 EXPECT_EQ(nada_receiver_.RecentReceivingRate(), kReceivingRateKbps); | 350 EXPECT_NEAR(nada_receiver_.RecentKbps(), kReceivingRateKbps, |
369 } | 351 static_cast<float>(kReceivingRateKbps) / 100); |
stefan-webrtc
2015/07/09 09:55:00
divide with 100.0f here and above.
magalhaesc
2015/07/09 11:43:22
Done.
| |
370 | |
371 TEST_F(NadaReceiverSideTest, ReceivingRateIntermittentPackets) { | |
372 const size_t kPayloadSizeBytes = 100 * 1000; | |
373 const int64_t kTimeGapMs = 50; // Between each packet. | |
374 const int64_t kFirstSendTimeMs = 0; | |
375 const int64_t kOneWayDelayMs = 50; | |
376 | |
377 // Gap between first and other packets | |
378 const MediaPacket media_packet(kFlowId, kFirstSendTimeMs, kPayloadSizeBytes, | |
379 1); | |
380 nada_receiver_.ReceivePacket(kFirstSendTimeMs + kOneWayDelayMs, media_packet); | |
381 | |
382 const int64_t kDelayAfterFirstPacketMs = 1000; | |
383 const int kNumPackets = 5; // Small enough so that all packets are covered. | |
384 EXPECT_LT((kNumPackets - 2) * kTimeGapMs, | |
385 NadaBweReceiver::kReceivingRateTimeWindowMs); | |
386 const int64_t kTimeWindowMs = | |
387 kDelayAfterFirstPacketMs + (kNumPackets - 2) * kTimeGapMs; | |
388 | |
389 for (int i = 2; i <= kNumPackets; ++i) { | |
390 int64_t send_time_us = | |
391 ((i - 2) * kTimeGapMs + kFirstSendTimeMs + kDelayAfterFirstPacketMs) * | |
392 1000; | |
393 int64_t arrival_time_ms = send_time_us / 1000 + kOneWayDelayMs; | |
394 uint16_t sequence_number = i; | |
395 const MediaPacket media_packet(kFlowId, send_time_us, kPayloadSizeBytes, | |
396 sequence_number); | |
397 nada_receiver_.ReceivePacket(arrival_time_ms, media_packet); | |
398 } | |
399 | |
400 const size_t kTotalReceivedKb = 8 * kNumPackets * kPayloadSizeBytes; | |
401 const int64_t kCorrectedTimeWindowMs = | |
402 (kTimeWindowMs * kNumPackets) / (kNumPackets - 1); | |
403 EXPECT_EQ(nada_receiver_.RecentReceivingRate(), | |
404 kTotalReceivedKb / kCorrectedTimeWindowMs); | |
405 } | |
406 | |
407 TEST_F(NadaReceiverSideTest, ReceivingRateDuplicatedPackets) { | |
408 const size_t kPayloadSizeBytes = 500 * 1000; | |
409 const int64_t kSendTimeUs = 300 * 1000; | |
410 const int64_t kArrivalTimeMs = kSendTimeUs / 1000 + 100; | |
411 const uint16_t kSequenceNumber = 1; | |
412 const int64_t kTimeWindowMs = NadaBweReceiver::kReceivingRateTimeWindowMs; | |
413 | |
414 // Insert the same packet twice. | |
415 for (int i = 0; i < 2; ++i) { | |
416 const MediaPacket media_packet(kFlowId, kSendTimeUs + 50 * i, | |
417 kPayloadSizeBytes, kSequenceNumber); | |
418 nada_receiver_.ReceivePacket(kArrivalTimeMs + 50 * i, media_packet); | |
419 } | |
420 // Should be counted only once. | |
421 const size_t kReceivingRateKbps = 8 * kPayloadSizeBytes / kTimeWindowMs; | |
422 | |
423 EXPECT_EQ(nada_receiver_.RecentReceivingRate(), kReceivingRateKbps); | |
424 } | 352 } |
425 | 353 |
426 TEST_F(NadaReceiverSideTest, PacketLossNoPackets) { | 354 TEST_F(NadaReceiverSideTest, PacketLossNoPackets) { |
427 EXPECT_EQ(nada_receiver_.RecentPacketLossRatio(), 0.0f); | 355 EXPECT_EQ(nada_receiver_.RecentPacketLossRatio(), 0.0f); |
428 } | 356 } |
429 | 357 |
430 TEST_F(NadaReceiverSideTest, PacketLossSinglePacket) { | 358 TEST_F(NadaReceiverSideTest, PacketLossSinglePacket) { |
431 const MediaPacket media_packet(kFlowId, 0, 0, 0); | 359 const MediaPacket media_packet(kFlowId, 0, 0, 0); |
432 nada_receiver_.ReceivePacket(0, media_packet); | 360 nada_receiver_.ReceivePacket(0, media_packet); |
433 EXPECT_EQ(nada_receiver_.RecentPacketLossRatio(), 0.0f); | 361 EXPECT_EQ(nada_receiver_.RecentPacketLossRatio(), 0.0f); |
(...skipping 168 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
602 for (int i = 1; i < kNumElements; ++i) { | 530 for (int i = 1; i < kNumElements; ++i) { |
603 EXPECT_EQ( | 531 EXPECT_EQ( |
604 exp_smoothed[i], | 532 exp_smoothed[i], |
605 static_cast<int64_t>(exp_smoothed[i - 1] * (1.0f - kAlpha) + 0.5f)); | 533 static_cast<int64_t>(exp_smoothed[i - 1] * (1.0f - kAlpha) + 0.5f)); |
606 } | 534 } |
607 } | 535 } |
608 | 536 |
609 } // namespace bwe | 537 } // namespace bwe |
610 } // namespace testing | 538 } // namespace testing |
611 } // namespace webrtc | 539 } // namespace webrtc |
OLD | NEW |