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 37 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
48 if (received_ts == nullptr) { | 48 if (received_ts == nullptr) { |
49 temp_deltas.reset(new int64_t[length]); | 49 temp_deltas.reset(new int64_t[length]); |
50 GenerateDeltas(received_seq, length, temp_deltas.get()); | 50 GenerateDeltas(received_seq, length, temp_deltas.get()); |
51 received_ts = temp_deltas.get(); | 51 received_ts = temp_deltas.get(); |
52 } | 52 } |
53 | 53 |
54 expected_seq_.clear(); | 54 expected_seq_.clear(); |
55 expected_deltas_.clear(); | 55 expected_deltas_.clear(); |
56 feedback_.reset(new TransportFeedback()); | 56 feedback_.reset(new TransportFeedback()); |
57 | 57 |
58 feedback_->SetBase(received_seq[0], received_ts[0]); | 58 feedback_->WithBase(received_seq[0], received_ts[0]); |
59 int64_t last_time = feedback_->GetBaseTimeUs(); | 59 int64_t last_time = feedback_->GetBaseTimeUs(); |
60 for (int i = 0; i < length; ++i) { | 60 for (int i = 0; i < length; ++i) { |
61 int64_t time = received_ts[i]; | 61 int64_t time = received_ts[i]; |
62 EXPECT_TRUE(feedback_->AddReceivedPacket(received_seq[i], time)); | 62 EXPECT_TRUE(feedback_->WithReceivedPacket(received_seq[i], time)); |
63 | 63 |
64 if (last_time != -1) { | 64 if (last_time != -1) { |
65 int64_t delta = time - last_time; | 65 int64_t delta = time - last_time; |
66 expected_deltas_.push_back(delta); | 66 expected_deltas_.push_back(delta); |
67 } | 67 } |
68 last_time = time; | 68 last_time = time; |
69 } | 69 } |
70 expected_seq_.insert(expected_seq_.begin(), &received_seq[0], | 70 expected_seq_.insert(expected_seq_.begin(), &received_seq[0], |
71 &received_seq[length]); | 71 &received_seq[length]); |
72 } | 72 } |
(...skipping 252 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
325 } | 325 } |
326 | 326 |
327 FeedbackTester test; | 327 FeedbackTester test; |
328 test.WithExpectedSize(kExpectedSizeBytes); | 328 test.WithExpectedSize(kExpectedSizeBytes); |
329 test.WithInput(kReceived, kReceiveTimes, kNumPackets); | 329 test.WithInput(kReceived, kReceiveTimes, kNumPackets); |
330 test.VerifyPacket(); | 330 test.VerifyPacket(); |
331 } | 331 } |
332 | 332 |
333 TEST(RtcpPacketTest, TransportFeedback_Aliasing) { | 333 TEST(RtcpPacketTest, TransportFeedback_Aliasing) { |
334 TransportFeedback feedback; | 334 TransportFeedback feedback; |
335 feedback.SetBase(0, 0); | 335 feedback.WithBase(0, 0); |
336 | 336 |
337 const int kSamples = 100; | 337 const int kSamples = 100; |
338 const int64_t kTooSmallDelta = TransportFeedback::kDeltaScaleFactor / 3; | 338 const int64_t kTooSmallDelta = TransportFeedback::kDeltaScaleFactor / 3; |
339 | 339 |
340 for (int i = 0; i < kSamples; ++i) | 340 for (int i = 0; i < kSamples; ++i) |
341 feedback.AddReceivedPacket(i, i * kTooSmallDelta); | 341 feedback.WithReceivedPacket(i, i * kTooSmallDelta); |
342 | 342 |
343 feedback.Build(); | 343 feedback.Build(); |
344 std::vector<int64_t> deltas = feedback.GetReceiveDeltasUs(); | 344 std::vector<int64_t> deltas = feedback.GetReceiveDeltasUs(); |
345 | 345 |
346 int64_t accumulated_delta = 0; | 346 int64_t accumulated_delta = 0; |
347 int num_samples = 0; | 347 int num_samples = 0; |
348 for (int64_t delta : deltas) { | 348 for (int64_t delta : deltas) { |
349 accumulated_delta += delta; | 349 accumulated_delta += delta; |
350 int64_t expected_time = num_samples * kTooSmallDelta; | 350 int64_t expected_time = num_samples * kTooSmallDelta; |
351 ++num_samples; | 351 ++num_samples; |
352 | 352 |
353 EXPECT_NEAR(expected_time, accumulated_delta, | 353 EXPECT_NEAR(expected_time, accumulated_delta, |
354 TransportFeedback::kDeltaScaleFactor / 2); | 354 TransportFeedback::kDeltaScaleFactor / 2); |
355 } | 355 } |
356 } | 356 } |
357 | 357 |
358 TEST(RtcpPacketTest, TransportFeedback_Limits) { | 358 TEST(RtcpPacketTest, TransportFeedback_Limits) { |
359 // Sequence number wrap above 0x8000. | 359 // Sequence number wrap above 0x8000. |
360 std::unique_ptr<TransportFeedback> packet(new TransportFeedback()); | 360 std::unique_ptr<TransportFeedback> packet(new TransportFeedback()); |
361 packet->SetBase(0, 0); | 361 packet->WithBase(0, 0); |
362 EXPECT_TRUE(packet->AddReceivedPacket(0x0, 0)); | 362 EXPECT_TRUE(packet->WithReceivedPacket(0x0, 0)); |
363 EXPECT_TRUE(packet->AddReceivedPacket(0x8000, 1000)); | 363 EXPECT_TRUE(packet->WithReceivedPacket(0x8000, 1000)); |
364 | 364 |
365 packet.reset(new TransportFeedback()); | 365 packet.reset(new TransportFeedback()); |
366 packet->SetBase(0, 0); | 366 packet->WithBase(0, 0); |
367 EXPECT_TRUE(packet->AddReceivedPacket(0x0, 0)); | 367 EXPECT_TRUE(packet->WithReceivedPacket(0x0, 0)); |
368 EXPECT_FALSE(packet->AddReceivedPacket(0x8000 + 1, 1000)); | 368 EXPECT_FALSE(packet->WithReceivedPacket(0x8000 + 1, 1000)); |
369 | 369 |
370 // Packet status count max 0xFFFF. | 370 // Packet status count max 0xFFFF. |
371 packet.reset(new TransportFeedback()); | 371 packet.reset(new TransportFeedback()); |
372 packet->SetBase(0, 0); | 372 packet->WithBase(0, 0); |
373 EXPECT_TRUE(packet->AddReceivedPacket(0x0, 0)); | 373 EXPECT_TRUE(packet->WithReceivedPacket(0x0, 0)); |
374 EXPECT_TRUE(packet->AddReceivedPacket(0x8000, 1000)); | 374 EXPECT_TRUE(packet->WithReceivedPacket(0x8000, 1000)); |
375 EXPECT_TRUE(packet->AddReceivedPacket(0xFFFF, 2000)); | 375 EXPECT_TRUE(packet->WithReceivedPacket(0xFFFF, 2000)); |
376 EXPECT_FALSE(packet->AddReceivedPacket(0, 3000)); | 376 EXPECT_FALSE(packet->WithReceivedPacket(0, 3000)); |
377 | 377 |
378 // Too large delta. | 378 // Too large delta. |
379 packet.reset(new TransportFeedback()); | 379 packet.reset(new TransportFeedback()); |
380 packet->SetBase(0, 0); | 380 packet->WithBase(0, 0); |
381 int64_t kMaxPositiveTimeDelta = std::numeric_limits<int16_t>::max() * | 381 int64_t kMaxPositiveTimeDelta = std::numeric_limits<int16_t>::max() * |
382 TransportFeedback::kDeltaScaleFactor; | 382 TransportFeedback::kDeltaScaleFactor; |
383 EXPECT_FALSE(packet->AddReceivedPacket( | 383 EXPECT_FALSE(packet->WithReceivedPacket( |
384 1, kMaxPositiveTimeDelta + TransportFeedback::kDeltaScaleFactor)); | 384 1, kMaxPositiveTimeDelta + TransportFeedback::kDeltaScaleFactor)); |
385 EXPECT_TRUE(packet->AddReceivedPacket(1, kMaxPositiveTimeDelta)); | 385 EXPECT_TRUE(packet->WithReceivedPacket(1, kMaxPositiveTimeDelta)); |
386 | 386 |
387 // Too large negative delta. | 387 // Too large negative delta. |
388 packet.reset(new TransportFeedback()); | 388 packet.reset(new TransportFeedback()); |
389 packet->SetBase(0, 0); | 389 packet->WithBase(0, 0); |
390 int64_t kMaxNegativeTimeDelta = std::numeric_limits<int16_t>::min() * | 390 int64_t kMaxNegativeTimeDelta = std::numeric_limits<int16_t>::min() * |
391 TransportFeedback::kDeltaScaleFactor; | 391 TransportFeedback::kDeltaScaleFactor; |
392 EXPECT_FALSE(packet->AddReceivedPacket( | 392 EXPECT_FALSE(packet->WithReceivedPacket( |
393 1, kMaxNegativeTimeDelta - TransportFeedback::kDeltaScaleFactor)); | 393 1, kMaxNegativeTimeDelta - TransportFeedback::kDeltaScaleFactor)); |
394 EXPECT_TRUE(packet->AddReceivedPacket(1, kMaxNegativeTimeDelta)); | 394 EXPECT_TRUE(packet->WithReceivedPacket(1, kMaxNegativeTimeDelta)); |
395 | 395 |
396 // Base time at maximum value. | 396 // Base time at maximum value. |
397 int64_t kMaxBaseTime = | 397 int64_t kMaxBaseTime = |
398 static_cast<int64_t>(TransportFeedback::kDeltaScaleFactor) * (1L << 8) * | 398 static_cast<int64_t>(TransportFeedback::kDeltaScaleFactor) * (1L << 8) * |
399 ((1L << 23) - 1); | 399 ((1L << 23) - 1); |
400 packet.reset(new TransportFeedback()); | 400 packet.reset(new TransportFeedback()); |
401 packet->SetBase(0, kMaxBaseTime); | 401 packet->WithBase(0, kMaxBaseTime); |
402 packet->AddReceivedPacket(0, kMaxBaseTime); | 402 packet->WithReceivedPacket(0, kMaxBaseTime); |
403 // Serialize and de-serialize (verify 24bit parsing). | 403 // Serialize and de-serialize (verify 24bit parsing). |
404 rtc::Buffer raw_packet = packet->Build(); | 404 rtc::Buffer raw_packet = packet->Build(); |
405 packet = TransportFeedback::ParseFrom(raw_packet.data(), raw_packet.size()); | 405 packet = TransportFeedback::ParseFrom(raw_packet.data(), raw_packet.size()); |
406 EXPECT_EQ(kMaxBaseTime, packet->GetBaseTimeUs()); | 406 EXPECT_EQ(kMaxBaseTime, packet->GetBaseTimeUs()); |
407 | 407 |
408 // Base time above maximum value. | 408 // Base time above maximum value. |
409 int64_t kTooLargeBaseTime = | 409 int64_t kTooLargeBaseTime = |
410 kMaxBaseTime + (TransportFeedback::kDeltaScaleFactor * (1L << 8)); | 410 kMaxBaseTime + (TransportFeedback::kDeltaScaleFactor * (1L << 8)); |
411 packet.reset(new TransportFeedback()); | 411 packet.reset(new TransportFeedback()); |
412 packet->SetBase(0, kTooLargeBaseTime); | 412 packet->WithBase(0, kTooLargeBaseTime); |
413 packet->AddReceivedPacket(0, kTooLargeBaseTime); | 413 packet->WithReceivedPacket(0, kTooLargeBaseTime); |
414 raw_packet = packet->Build(); | 414 raw_packet = packet->Build(); |
415 packet = TransportFeedback::ParseFrom(raw_packet.data(), raw_packet.size()); | 415 packet = TransportFeedback::ParseFrom(raw_packet.data(), raw_packet.size()); |
416 EXPECT_NE(kTooLargeBaseTime, packet->GetBaseTimeUs()); | 416 EXPECT_NE(kTooLargeBaseTime, packet->GetBaseTimeUs()); |
417 | 417 |
418 // TODO(sprang): Once we support max length lower than RTCP length limit, | 418 // TODO(sprang): Once we support max length lower than RTCP length limit, |
419 // add back test for max size in bytes. | 419 // add back test for max size in bytes. |
420 } | 420 } |
421 | 421 |
422 TEST(RtcpPacketTest, TransportFeedback_Padding) { | 422 TEST(RtcpPacketTest, TransportFeedback_Padding) { |
423 const size_t kExpectedSizeBytes = | 423 const size_t kExpectedSizeBytes = |
424 kHeaderSize + kStatusChunkSize + kSmallDeltaSize; | 424 kHeaderSize + kStatusChunkSize + kSmallDeltaSize; |
425 const size_t kExpectedSizeWords = (kExpectedSizeBytes + 3) / 4; | 425 const size_t kExpectedSizeWords = (kExpectedSizeBytes + 3) / 4; |
426 | 426 |
427 TransportFeedback feedback; | 427 TransportFeedback feedback; |
428 feedback.SetBase(0, 0); | 428 feedback.WithBase(0, 0); |
429 EXPECT_TRUE(feedback.AddReceivedPacket(0, 0)); | 429 EXPECT_TRUE(feedback.WithReceivedPacket(0, 0)); |
430 | 430 |
431 rtc::Buffer packet = feedback.Build(); | 431 rtc::Buffer packet = feedback.Build(); |
432 EXPECT_EQ(kExpectedSizeWords * 4, packet.size()); | 432 EXPECT_EQ(kExpectedSizeWords * 4, packet.size()); |
433 ASSERT_GT(kExpectedSizeWords * 4, kExpectedSizeBytes); | 433 ASSERT_GT(kExpectedSizeWords * 4, kExpectedSizeBytes); |
434 for (size_t i = kExpectedSizeBytes; i < kExpectedSizeWords * 4; ++i) | 434 for (size_t i = kExpectedSizeBytes; i < kExpectedSizeWords * 4; ++i) |
435 EXPECT_EQ(0u, packet.data()[i]); | 435 EXPECT_EQ(0u, packet.data()[i]); |
436 | 436 |
437 // Modify packet by adding 4 bytes of padding at the end. Not currently used | 437 // Modify packet by adding 4 bytes of padding at the end. Not currently used |
438 // when we're sending, but need to be able to handle it when receiving. | 438 // when we're sending, but need to be able to handle it when receiving. |
439 | 439 |
(...skipping 19 matching lines...) Expand all Loading... |
459 TEST(RtcpPacketTest, TransportFeedback_CorrectlySplitsVectorChunks) { | 459 TEST(RtcpPacketTest, TransportFeedback_CorrectlySplitsVectorChunks) { |
460 const int kOneBitVectorCapacity = 14; | 460 const int kOneBitVectorCapacity = 14; |
461 const int64_t kLargeTimeDelta = | 461 const int64_t kLargeTimeDelta = |
462 TransportFeedback::kDeltaScaleFactor * (1 << 8); | 462 TransportFeedback::kDeltaScaleFactor * (1 << 8); |
463 | 463 |
464 // Test that a number of small deltas followed by a large delta results in a | 464 // Test that a number of small deltas followed by a large delta results in a |
465 // correct split into multiple chunks, as needed. | 465 // correct split into multiple chunks, as needed. |
466 | 466 |
467 for (int deltas = 0; deltas <= kOneBitVectorCapacity + 1; ++deltas) { | 467 for (int deltas = 0; deltas <= kOneBitVectorCapacity + 1; ++deltas) { |
468 TransportFeedback feedback; | 468 TransportFeedback feedback; |
469 feedback.SetBase(0, 0); | 469 feedback.WithBase(0, 0); |
470 for (int i = 0; i < deltas; ++i) | 470 for (int i = 0; i < deltas; ++i) |
471 feedback.AddReceivedPacket(i, i * 1000); | 471 feedback.WithReceivedPacket(i, i * 1000); |
472 feedback.AddReceivedPacket(deltas, deltas * 1000 + kLargeTimeDelta); | 472 feedback.WithReceivedPacket(deltas, deltas * 1000 + kLargeTimeDelta); |
473 | 473 |
474 rtc::Buffer serialized_packet = feedback.Build(); | 474 rtc::Buffer serialized_packet = feedback.Build(); |
475 std::unique_ptr<TransportFeedback> deserialized_packet = | 475 std::unique_ptr<TransportFeedback> deserialized_packet = |
476 TransportFeedback::ParseFrom(serialized_packet.data(), | 476 TransportFeedback::ParseFrom(serialized_packet.data(), |
477 serialized_packet.size()); | 477 serialized_packet.size()); |
478 EXPECT_TRUE(deserialized_packet.get() != nullptr); | 478 EXPECT_TRUE(deserialized_packet.get() != nullptr); |
479 } | 479 } |
480 } | 480 } |
481 | 481 |
482 } // namespace | 482 } // namespace |
483 } // namespace webrtc | 483 } // namespace webrtc |
OLD | NEW |