586b19bdb6
To make this possible padding only packets will have the same timestamp as the previously sent media packet, as long as RTX is not enabled. This has the side effect that if we send only padding for a long time without sending media, a receive-side jitter buffer could potentially overflow. In practice this shouldn't be an issue, partly because RTX is recommended and used by default, but also because padding typically is terminated before being received by a client. It is also not an issue for bandwidth estimation as long as abs-send-time is used instead of toffset. BUG=chromium:425925 R=mflodman@webrtc.org, sprang@webrtc.org, tommi@webrtc.org Review URL: https://codereview.webrtc.org/1327933003 . Cr-Commit-Position: refs/heads/master@{#9984}
856 lines
31 KiB
C++
856 lines
31 KiB
C++
/*
|
|
* Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
|
|
*
|
|
* Use of this source code is governed by a BSD-style license
|
|
* that can be found in the LICENSE file in the root of the source
|
|
* tree. An additional intellectual property rights grant can be found
|
|
* in the file PATENTS. All contributing project authors may
|
|
* be found in the AUTHORS file in the root of the source tree.
|
|
*/
|
|
|
|
#include <list>
|
|
|
|
#include "testing/gmock/include/gmock/gmock.h"
|
|
#include "testing/gtest/include/gtest/gtest.h"
|
|
#include "webrtc/modules/pacing/include/paced_sender.h"
|
|
#include "webrtc/system_wrappers/interface/clock.h"
|
|
|
|
using testing::_;
|
|
using testing::Return;
|
|
|
|
namespace webrtc {
|
|
namespace test {
|
|
|
|
static const int kTargetBitrate = 800;
|
|
static const float kPaceMultiplier = 1.5f;
|
|
|
|
class MockPacedSenderCallback : public PacedSender::Callback {
|
|
public:
|
|
MOCK_METHOD4(TimeToSendPacket,
|
|
bool(uint32_t ssrc,
|
|
uint16_t sequence_number,
|
|
int64_t capture_time_ms,
|
|
bool retransmission));
|
|
MOCK_METHOD1(TimeToSendPadding,
|
|
size_t(size_t bytes));
|
|
};
|
|
|
|
class PacedSenderPadding : public PacedSender::Callback {
|
|
public:
|
|
PacedSenderPadding() : padding_sent_(0) {}
|
|
|
|
bool TimeToSendPacket(uint32_t ssrc,
|
|
uint16_t sequence_number,
|
|
int64_t capture_time_ms,
|
|
bool retransmission) {
|
|
return true;
|
|
}
|
|
|
|
size_t TimeToSendPadding(size_t bytes) {
|
|
const size_t kPaddingPacketSize = 224;
|
|
size_t num_packets = (bytes + kPaddingPacketSize - 1) / kPaddingPacketSize;
|
|
padding_sent_ += kPaddingPacketSize * num_packets;
|
|
return kPaddingPacketSize * num_packets;
|
|
}
|
|
|
|
size_t padding_sent() { return padding_sent_; }
|
|
|
|
private:
|
|
size_t padding_sent_;
|
|
};
|
|
|
|
class PacedSenderProbing : public PacedSender::Callback {
|
|
public:
|
|
PacedSenderProbing(const std::list<int>& expected_deltas, Clock* clock)
|
|
: prev_packet_time_ms_(-1),
|
|
expected_deltas_(expected_deltas),
|
|
packets_sent_(0),
|
|
clock_(clock) {}
|
|
|
|
bool TimeToSendPacket(uint32_t ssrc,
|
|
uint16_t sequence_number,
|
|
int64_t capture_time_ms,
|
|
bool retransmission) {
|
|
ExpectAndCountPacket();
|
|
return true;
|
|
}
|
|
|
|
size_t TimeToSendPadding(size_t bytes) {
|
|
ExpectAndCountPacket();
|
|
return bytes;
|
|
}
|
|
|
|
void ExpectAndCountPacket() {
|
|
++packets_sent_;
|
|
EXPECT_FALSE(expected_deltas_.empty());
|
|
if (expected_deltas_.empty())
|
|
return;
|
|
int64_t now_ms = clock_->TimeInMilliseconds();
|
|
if (prev_packet_time_ms_ >= 0) {
|
|
EXPECT_EQ(expected_deltas_.front(), now_ms - prev_packet_time_ms_);
|
|
expected_deltas_.pop_front();
|
|
}
|
|
prev_packet_time_ms_ = now_ms;
|
|
}
|
|
|
|
int packets_sent() const { return packets_sent_; }
|
|
|
|
private:
|
|
int64_t prev_packet_time_ms_;
|
|
std::list<int> expected_deltas_;
|
|
int packets_sent_;
|
|
Clock* clock_;
|
|
};
|
|
|
|
class PacedSenderTest : public ::testing::Test {
|
|
protected:
|
|
PacedSenderTest() : clock_(123456) {
|
|
srand(0);
|
|
// Need to initialize PacedSender after we initialize clock.
|
|
send_bucket_.reset(new PacedSender(&clock_,
|
|
&callback_,
|
|
kTargetBitrate,
|
|
kPaceMultiplier * kTargetBitrate,
|
|
0));
|
|
// Default to bitrate probing disabled for testing purposes. Probing tests
|
|
// have to enable probing, either by creating a new PacedSender instance or
|
|
// by calling SetProbingEnabled(true).
|
|
send_bucket_->SetProbingEnabled(false);
|
|
}
|
|
|
|
void SendAndExpectPacket(PacedSender::Priority priority,
|
|
uint32_t ssrc,
|
|
uint16_t sequence_number,
|
|
int64_t capture_time_ms,
|
|
size_t size,
|
|
bool retransmission) {
|
|
EXPECT_FALSE(send_bucket_->SendPacket(priority, ssrc,
|
|
sequence_number, capture_time_ms, size, retransmission));
|
|
EXPECT_CALL(callback_,
|
|
TimeToSendPacket(ssrc, sequence_number, capture_time_ms, false))
|
|
.Times(1)
|
|
.WillRepeatedly(Return(true));
|
|
}
|
|
|
|
SimulatedClock clock_;
|
|
MockPacedSenderCallback callback_;
|
|
rtc::scoped_ptr<PacedSender> send_bucket_;
|
|
};
|
|
|
|
TEST_F(PacedSenderTest, QueuePacket) {
|
|
uint32_t ssrc = 12345;
|
|
uint16_t sequence_number = 1234;
|
|
// Due to the multiplicative factor we can send 3 packets not 2 packets.
|
|
SendAndExpectPacket(PacedSender::kNormalPriority,
|
|
ssrc,
|
|
sequence_number++,
|
|
clock_.TimeInMilliseconds(),
|
|
250,
|
|
false);
|
|
SendAndExpectPacket(PacedSender::kNormalPriority,
|
|
ssrc,
|
|
sequence_number++,
|
|
clock_.TimeInMilliseconds(),
|
|
250,
|
|
false);
|
|
SendAndExpectPacket(PacedSender::kNormalPriority,
|
|
ssrc,
|
|
sequence_number++,
|
|
clock_.TimeInMilliseconds(),
|
|
250,
|
|
false);
|
|
int64_t queued_packet_timestamp = clock_.TimeInMilliseconds();
|
|
EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority, ssrc,
|
|
sequence_number, queued_packet_timestamp, 250, false));
|
|
send_bucket_->Process();
|
|
EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
|
|
EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0);
|
|
clock_.AdvanceTimeMilliseconds(4);
|
|
EXPECT_EQ(1, send_bucket_->TimeUntilNextProcess());
|
|
clock_.AdvanceTimeMilliseconds(1);
|
|
EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
|
|
EXPECT_CALL(
|
|
callback_,
|
|
TimeToSendPacket(ssrc, sequence_number++, queued_packet_timestamp, false))
|
|
.Times(1)
|
|
.WillRepeatedly(Return(true));
|
|
send_bucket_->Process();
|
|
sequence_number++;
|
|
SendAndExpectPacket(PacedSender::kNormalPriority,
|
|
ssrc,
|
|
sequence_number++,
|
|
clock_.TimeInMilliseconds(),
|
|
250,
|
|
false);
|
|
SendAndExpectPacket(PacedSender::kNormalPriority,
|
|
ssrc,
|
|
sequence_number++,
|
|
clock_.TimeInMilliseconds(),
|
|
250,
|
|
false);
|
|
EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority, ssrc,
|
|
sequence_number++, clock_.TimeInMilliseconds(), 250, false));
|
|
send_bucket_->Process();
|
|
}
|
|
|
|
TEST_F(PacedSenderTest, PaceQueuedPackets) {
|
|
uint32_t ssrc = 12345;
|
|
uint16_t sequence_number = 1234;
|
|
|
|
// Due to the multiplicative factor we can send 3 packets not 2 packets.
|
|
for (int i = 0; i < 3; ++i) {
|
|
SendAndExpectPacket(PacedSender::kNormalPriority,
|
|
ssrc,
|
|
sequence_number++,
|
|
clock_.TimeInMilliseconds(),
|
|
250,
|
|
false);
|
|
}
|
|
for (int j = 0; j < 30; ++j) {
|
|
EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority, ssrc,
|
|
sequence_number++, clock_.TimeInMilliseconds(), 250, false));
|
|
}
|
|
send_bucket_->Process();
|
|
EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0);
|
|
for (int k = 0; k < 10; ++k) {
|
|
EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
|
|
clock_.AdvanceTimeMilliseconds(5);
|
|
EXPECT_CALL(callback_, TimeToSendPacket(ssrc, _, _, false))
|
|
.Times(3)
|
|
.WillRepeatedly(Return(true));
|
|
EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
|
|
EXPECT_EQ(0, send_bucket_->Process());
|
|
}
|
|
EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
|
|
clock_.AdvanceTimeMilliseconds(5);
|
|
EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
|
|
EXPECT_EQ(0, send_bucket_->Process());
|
|
SendAndExpectPacket(PacedSender::kNormalPriority,
|
|
ssrc,
|
|
sequence_number++,
|
|
clock_.TimeInMilliseconds(),
|
|
250,
|
|
false);
|
|
SendAndExpectPacket(PacedSender::kNormalPriority,
|
|
ssrc,
|
|
sequence_number++,
|
|
clock_.TimeInMilliseconds(),
|
|
250,
|
|
false);
|
|
SendAndExpectPacket(PacedSender::kNormalPriority,
|
|
ssrc,
|
|
sequence_number++,
|
|
clock_.TimeInMilliseconds(),
|
|
250,
|
|
false);
|
|
EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority, ssrc,
|
|
sequence_number, clock_.TimeInMilliseconds(), 250, false));
|
|
send_bucket_->Process();
|
|
}
|
|
|
|
TEST_F(PacedSenderTest, PaceQueuedPacketsWithDuplicates) {
|
|
uint32_t ssrc = 12345;
|
|
uint16_t sequence_number = 1234;
|
|
uint16_t queued_sequence_number;
|
|
|
|
// Due to the multiplicative factor we can send 3 packets not 2 packets.
|
|
for (int i = 0; i < 3; ++i) {
|
|
SendAndExpectPacket(PacedSender::kNormalPriority,
|
|
ssrc,
|
|
sequence_number++,
|
|
clock_.TimeInMilliseconds(),
|
|
250,
|
|
false);
|
|
}
|
|
queued_sequence_number = sequence_number;
|
|
|
|
for (int j = 0; j < 30; ++j) {
|
|
// Send in duplicate packets.
|
|
EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority, ssrc,
|
|
sequence_number, clock_.TimeInMilliseconds(), 250, false));
|
|
EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority, ssrc,
|
|
sequence_number++, clock_.TimeInMilliseconds(), 250, false));
|
|
}
|
|
EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0);
|
|
send_bucket_->Process();
|
|
for (int k = 0; k < 10; ++k) {
|
|
EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
|
|
clock_.AdvanceTimeMilliseconds(5);
|
|
|
|
for (int i = 0; i < 3; ++i) {
|
|
EXPECT_CALL(callback_,
|
|
TimeToSendPacket(ssrc, queued_sequence_number++, _, false))
|
|
.Times(1)
|
|
.WillRepeatedly(Return(true));
|
|
}
|
|
EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
|
|
EXPECT_EQ(0, send_bucket_->Process());
|
|
}
|
|
EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
|
|
clock_.AdvanceTimeMilliseconds(5);
|
|
EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
|
|
EXPECT_EQ(0, send_bucket_->Process());
|
|
SendAndExpectPacket(PacedSender::kNormalPriority,
|
|
ssrc,
|
|
sequence_number++,
|
|
clock_.TimeInMilliseconds(),
|
|
250,
|
|
false);
|
|
SendAndExpectPacket(PacedSender::kNormalPriority,
|
|
ssrc,
|
|
sequence_number++,
|
|
clock_.TimeInMilliseconds(),
|
|
250,
|
|
false);
|
|
SendAndExpectPacket(PacedSender::kNormalPriority,
|
|
ssrc,
|
|
sequence_number++,
|
|
clock_.TimeInMilliseconds(),
|
|
250,
|
|
false);
|
|
EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority, ssrc,
|
|
sequence_number++, clock_.TimeInMilliseconds(), 250, false));
|
|
send_bucket_->Process();
|
|
}
|
|
|
|
TEST_F(PacedSenderTest, CanQueuePacketsWithSameSequenceNumberOnDifferentSsrcs) {
|
|
uint32_t ssrc = 12345;
|
|
uint16_t sequence_number = 1234;
|
|
|
|
SendAndExpectPacket(PacedSender::kNormalPriority,
|
|
ssrc,
|
|
sequence_number,
|
|
clock_.TimeInMilliseconds(),
|
|
250,
|
|
false);
|
|
|
|
// Expect packet on second ssrc to be queued and sent as well.
|
|
SendAndExpectPacket(PacedSender::kNormalPriority,
|
|
ssrc + 1,
|
|
sequence_number,
|
|
clock_.TimeInMilliseconds(),
|
|
250,
|
|
false);
|
|
|
|
clock_.AdvanceTimeMilliseconds(1000);
|
|
send_bucket_->Process();
|
|
}
|
|
|
|
TEST_F(PacedSenderTest, Padding) {
|
|
uint32_t ssrc = 12345;
|
|
uint16_t sequence_number = 1234;
|
|
|
|
send_bucket_->UpdateBitrate(
|
|
kTargetBitrate, kPaceMultiplier * kTargetBitrate, kTargetBitrate);
|
|
// Due to the multiplicative factor we can send 3 packets not 2 packets.
|
|
SendAndExpectPacket(PacedSender::kNormalPriority,
|
|
ssrc,
|
|
sequence_number++,
|
|
clock_.TimeInMilliseconds(),
|
|
250,
|
|
false);
|
|
SendAndExpectPacket(PacedSender::kNormalPriority,
|
|
ssrc,
|
|
sequence_number++,
|
|
clock_.TimeInMilliseconds(),
|
|
250,
|
|
false);
|
|
SendAndExpectPacket(PacedSender::kNormalPriority,
|
|
ssrc,
|
|
sequence_number++,
|
|
clock_.TimeInMilliseconds(),
|
|
250,
|
|
false);
|
|
// No padding is expected since we have sent too much already.
|
|
EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0);
|
|
EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
|
|
clock_.AdvanceTimeMilliseconds(5);
|
|
EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
|
|
EXPECT_EQ(0, send_bucket_->Process());
|
|
|
|
// 5 milliseconds later we have enough budget to send some padding.
|
|
EXPECT_CALL(callback_, TimeToSendPadding(250)).Times(1).
|
|
WillOnce(Return(250));
|
|
EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
|
|
clock_.AdvanceTimeMilliseconds(5);
|
|
EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
|
|
EXPECT_EQ(0, send_bucket_->Process());
|
|
}
|
|
|
|
TEST_F(PacedSenderTest, NoPaddingWhenDisabled) {
|
|
send_bucket_->SetStatus(false);
|
|
send_bucket_->UpdateBitrate(
|
|
kTargetBitrate, kPaceMultiplier * kTargetBitrate, kTargetBitrate);
|
|
// No padding is expected since the pacer is disabled.
|
|
EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0);
|
|
EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
|
|
clock_.AdvanceTimeMilliseconds(5);
|
|
EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
|
|
EXPECT_EQ(0, send_bucket_->Process());
|
|
EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0);
|
|
EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
|
|
clock_.AdvanceTimeMilliseconds(5);
|
|
EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
|
|
EXPECT_EQ(0, send_bucket_->Process());
|
|
}
|
|
|
|
TEST_F(PacedSenderTest, VerifyPaddingUpToBitrate) {
|
|
uint32_t ssrc = 12345;
|
|
uint16_t sequence_number = 1234;
|
|
int64_t capture_time_ms = 56789;
|
|
const int kTimeStep = 5;
|
|
const int64_t kBitrateWindow = 100;
|
|
send_bucket_->UpdateBitrate(
|
|
kTargetBitrate, kPaceMultiplier * kTargetBitrate, kTargetBitrate);
|
|
int64_t start_time = clock_.TimeInMilliseconds();
|
|
while (clock_.TimeInMilliseconds() - start_time < kBitrateWindow) {
|
|
SendAndExpectPacket(PacedSender::kNormalPriority,
|
|
ssrc,
|
|
sequence_number++,
|
|
capture_time_ms,
|
|
250,
|
|
false);
|
|
clock_.AdvanceTimeMilliseconds(kTimeStep);
|
|
EXPECT_CALL(callback_, TimeToSendPadding(250)).Times(1).
|
|
WillOnce(Return(250));
|
|
send_bucket_->Process();
|
|
}
|
|
}
|
|
|
|
TEST_F(PacedSenderTest, VerifyAverageBitrateVaryingMediaPayload) {
|
|
uint32_t ssrc = 12345;
|
|
uint16_t sequence_number = 1234;
|
|
int64_t capture_time_ms = 56789;
|
|
const int kTimeStep = 5;
|
|
const int64_t kBitrateWindow = 10000;
|
|
PacedSenderPadding callback;
|
|
send_bucket_.reset(new PacedSender(
|
|
&clock_, &callback, kTargetBitrate, kPaceMultiplier * kTargetBitrate, 0));
|
|
send_bucket_->SetProbingEnabled(false);
|
|
send_bucket_->UpdateBitrate(
|
|
kTargetBitrate, kPaceMultiplier * kTargetBitrate, kTargetBitrate);
|
|
int64_t start_time = clock_.TimeInMilliseconds();
|
|
size_t media_bytes = 0;
|
|
while (clock_.TimeInMilliseconds() - start_time < kBitrateWindow) {
|
|
size_t media_payload = rand() % 100 + 200; // [200, 300] bytes.
|
|
EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority, ssrc,
|
|
sequence_number++, capture_time_ms,
|
|
media_payload, false));
|
|
media_bytes += media_payload;
|
|
clock_.AdvanceTimeMilliseconds(kTimeStep);
|
|
send_bucket_->Process();
|
|
}
|
|
EXPECT_NEAR(kTargetBitrate,
|
|
static_cast<int>(8 * (media_bytes + callback.padding_sent()) /
|
|
kBitrateWindow), 1);
|
|
}
|
|
|
|
TEST_F(PacedSenderTest, Priority) {
|
|
uint32_t ssrc_low_priority = 12345;
|
|
uint32_t ssrc = 12346;
|
|
uint16_t sequence_number = 1234;
|
|
int64_t capture_time_ms = 56789;
|
|
int64_t capture_time_ms_low_priority = 1234567;
|
|
|
|
// Due to the multiplicative factor we can send 3 packets not 2 packets.
|
|
SendAndExpectPacket(PacedSender::kLowPriority,
|
|
ssrc,
|
|
sequence_number++,
|
|
capture_time_ms,
|
|
250,
|
|
false);
|
|
SendAndExpectPacket(PacedSender::kNormalPriority,
|
|
ssrc,
|
|
sequence_number++,
|
|
capture_time_ms,
|
|
250,
|
|
false);
|
|
SendAndExpectPacket(PacedSender::kNormalPriority,
|
|
ssrc,
|
|
sequence_number++,
|
|
capture_time_ms,
|
|
250,
|
|
false);
|
|
send_bucket_->Process();
|
|
|
|
// Expect normal and low priority to be queued and high to pass through.
|
|
EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kLowPriority,
|
|
ssrc_low_priority, sequence_number++, capture_time_ms_low_priority, 250,
|
|
false));
|
|
EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority,
|
|
ssrc, sequence_number++, capture_time_ms, 250, false));
|
|
EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority,
|
|
ssrc, sequence_number++, capture_time_ms, 250, false));
|
|
EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kHighPriority,
|
|
ssrc, sequence_number++, capture_time_ms, 250, false));
|
|
|
|
// Expect all high and normal priority to be sent out first.
|
|
EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0);
|
|
EXPECT_CALL(callback_, TimeToSendPacket(ssrc, _, capture_time_ms, false))
|
|
.Times(3)
|
|
.WillRepeatedly(Return(true));
|
|
|
|
EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
|
|
clock_.AdvanceTimeMilliseconds(5);
|
|
EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
|
|
EXPECT_EQ(0, send_bucket_->Process());
|
|
|
|
EXPECT_CALL(callback_,
|
|
TimeToSendPacket(
|
|
ssrc_low_priority, _, capture_time_ms_low_priority, false))
|
|
.Times(1)
|
|
.WillRepeatedly(Return(true));
|
|
|
|
EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
|
|
clock_.AdvanceTimeMilliseconds(5);
|
|
EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
|
|
EXPECT_EQ(0, send_bucket_->Process());
|
|
}
|
|
|
|
TEST_F(PacedSenderTest, Pause) {
|
|
uint32_t ssrc_low_priority = 12345;
|
|
uint32_t ssrc = 12346;
|
|
uint16_t sequence_number = 1234;
|
|
int64_t capture_time_ms = clock_.TimeInMilliseconds();
|
|
|
|
EXPECT_EQ(0, send_bucket_->QueueInMs());
|
|
|
|
// Due to the multiplicative factor we can send 3 packets not 2 packets.
|
|
SendAndExpectPacket(PacedSender::kLowPriority,
|
|
ssrc,
|
|
sequence_number++,
|
|
capture_time_ms,
|
|
250,
|
|
false);
|
|
SendAndExpectPacket(PacedSender::kNormalPriority,
|
|
ssrc,
|
|
sequence_number++,
|
|
capture_time_ms,
|
|
250,
|
|
false);
|
|
SendAndExpectPacket(PacedSender::kNormalPriority,
|
|
ssrc,
|
|
sequence_number++,
|
|
capture_time_ms,
|
|
250,
|
|
false);
|
|
send_bucket_->Process();
|
|
|
|
send_bucket_->Pause();
|
|
|
|
EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority,
|
|
ssrc, sequence_number++, capture_time_ms, 250, false));
|
|
EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority,
|
|
ssrc, sequence_number++, capture_time_ms, 250, false));
|
|
EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kHighPriority,
|
|
ssrc, sequence_number++, capture_time_ms, 250, false));
|
|
|
|
clock_.AdvanceTimeMilliseconds(10000);
|
|
int64_t second_capture_time_ms = clock_.TimeInMilliseconds();
|
|
|
|
// Expect everything to be queued.
|
|
EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kLowPriority,
|
|
ssrc_low_priority, sequence_number++, second_capture_time_ms, 250,
|
|
false));
|
|
|
|
EXPECT_EQ(clock_.TimeInMilliseconds() - capture_time_ms,
|
|
send_bucket_->QueueInMs());
|
|
|
|
// Expect no packet to come out while paused.
|
|
EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0);
|
|
EXPECT_CALL(callback_, TimeToSendPacket(_, _, _, _)).Times(0);
|
|
|
|
for (int i = 0; i < 10; ++i) {
|
|
clock_.AdvanceTimeMilliseconds(5);
|
|
EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
|
|
EXPECT_EQ(0, send_bucket_->Process());
|
|
}
|
|
// Expect high prio packets to come out first followed by all packets in the
|
|
// way they were added.
|
|
EXPECT_CALL(callback_, TimeToSendPacket(_, _, capture_time_ms, false))
|
|
.Times(3)
|
|
.WillRepeatedly(Return(true));
|
|
send_bucket_->Resume();
|
|
|
|
EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
|
|
clock_.AdvanceTimeMilliseconds(5);
|
|
EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
|
|
EXPECT_EQ(0, send_bucket_->Process());
|
|
|
|
EXPECT_CALL(callback_, TimeToSendPacket(_, _, second_capture_time_ms, false))
|
|
.Times(1)
|
|
.WillRepeatedly(Return(true));
|
|
EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess());
|
|
clock_.AdvanceTimeMilliseconds(5);
|
|
EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess());
|
|
EXPECT_EQ(0, send_bucket_->Process());
|
|
EXPECT_EQ(0, send_bucket_->QueueInMs());
|
|
}
|
|
|
|
TEST_F(PacedSenderTest, ResendPacket) {
|
|
uint32_t ssrc = 12346;
|
|
uint16_t sequence_number = 1234;
|
|
int64_t capture_time_ms = clock_.TimeInMilliseconds();
|
|
EXPECT_EQ(0, send_bucket_->QueueInMs());
|
|
|
|
EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority,
|
|
ssrc,
|
|
sequence_number,
|
|
capture_time_ms,
|
|
250,
|
|
false));
|
|
clock_.AdvanceTimeMilliseconds(1);
|
|
EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority,
|
|
ssrc,
|
|
sequence_number + 1,
|
|
capture_time_ms + 1,
|
|
250,
|
|
false));
|
|
clock_.AdvanceTimeMilliseconds(9999);
|
|
EXPECT_EQ(clock_.TimeInMilliseconds() - capture_time_ms,
|
|
send_bucket_->QueueInMs());
|
|
// Fails to send first packet so only one call.
|
|
EXPECT_CALL(callback_,
|
|
TimeToSendPacket(ssrc, sequence_number, capture_time_ms, false))
|
|
.Times(1)
|
|
.WillOnce(Return(false));
|
|
clock_.AdvanceTimeMilliseconds(10000);
|
|
send_bucket_->Process();
|
|
|
|
// Queue remains unchanged.
|
|
EXPECT_EQ(clock_.TimeInMilliseconds() - capture_time_ms,
|
|
send_bucket_->QueueInMs());
|
|
|
|
// Fails to send second packet.
|
|
EXPECT_CALL(callback_,
|
|
TimeToSendPacket(ssrc, sequence_number, capture_time_ms, false))
|
|
.Times(1)
|
|
.WillOnce(Return(true));
|
|
EXPECT_CALL(
|
|
callback_,
|
|
TimeToSendPacket(ssrc, sequence_number + 1, capture_time_ms + 1, false))
|
|
.Times(1)
|
|
.WillOnce(Return(false));
|
|
clock_.AdvanceTimeMilliseconds(10000);
|
|
send_bucket_->Process();
|
|
|
|
// Queue is reduced by 1 packet.
|
|
EXPECT_EQ(clock_.TimeInMilliseconds() - capture_time_ms - 1,
|
|
send_bucket_->QueueInMs());
|
|
|
|
// Send second packet and queue becomes empty.
|
|
EXPECT_CALL(
|
|
callback_,
|
|
TimeToSendPacket(ssrc, sequence_number + 1, capture_time_ms + 1, false))
|
|
.Times(1)
|
|
.WillOnce(Return(true));
|
|
clock_.AdvanceTimeMilliseconds(10000);
|
|
send_bucket_->Process();
|
|
EXPECT_EQ(0, send_bucket_->QueueInMs());
|
|
}
|
|
|
|
TEST_F(PacedSenderTest, ExpectedQueueTimeMs) {
|
|
uint32_t ssrc = 12346;
|
|
uint16_t sequence_number = 1234;
|
|
const size_t kNumPackets = 60;
|
|
const size_t kPacketSize = 1200;
|
|
const int32_t kMaxBitrate = kPaceMultiplier * 30;
|
|
EXPECT_EQ(0, send_bucket_->ExpectedQueueTimeMs());
|
|
|
|
send_bucket_->UpdateBitrate(30, kMaxBitrate, 0);
|
|
for (size_t i = 0; i < kNumPackets; ++i) {
|
|
SendAndExpectPacket(PacedSender::kNormalPriority, ssrc, sequence_number++,
|
|
clock_.TimeInMilliseconds(), kPacketSize, false);
|
|
}
|
|
|
|
// Queue in ms = 1000 * (bytes in queue) / (kbit per second * 1000 / 8)
|
|
int64_t queue_in_ms =
|
|
static_cast<int64_t>(kNumPackets * kPacketSize * 8 / kMaxBitrate);
|
|
EXPECT_EQ(queue_in_ms, send_bucket_->ExpectedQueueTimeMs());
|
|
|
|
int64_t time_start = clock_.TimeInMilliseconds();
|
|
while (send_bucket_->QueueSizePackets() > 0) {
|
|
int time_until_process = send_bucket_->TimeUntilNextProcess();
|
|
if (time_until_process <= 0) {
|
|
send_bucket_->Process();
|
|
} else {
|
|
clock_.AdvanceTimeMilliseconds(time_until_process);
|
|
}
|
|
}
|
|
int64_t duration = clock_.TimeInMilliseconds() - time_start;
|
|
|
|
EXPECT_EQ(0, send_bucket_->ExpectedQueueTimeMs());
|
|
|
|
// Allow for aliasing, duration should be in [expected(n - 1), expected(n)].
|
|
EXPECT_LE(duration, queue_in_ms);
|
|
EXPECT_GE(duration,
|
|
queue_in_ms - static_cast<int64_t>(kPacketSize * 8 / kMaxBitrate));
|
|
}
|
|
|
|
TEST_F(PacedSenderTest, QueueTimeGrowsOverTime) {
|
|
uint32_t ssrc = 12346;
|
|
uint16_t sequence_number = 1234;
|
|
EXPECT_EQ(0, send_bucket_->QueueInMs());
|
|
|
|
send_bucket_->UpdateBitrate(30, kPaceMultiplier * 30, 0);
|
|
SendAndExpectPacket(PacedSender::kNormalPriority,
|
|
ssrc,
|
|
sequence_number,
|
|
clock_.TimeInMilliseconds(),
|
|
1200,
|
|
false);
|
|
|
|
clock_.AdvanceTimeMilliseconds(500);
|
|
EXPECT_EQ(500, send_bucket_->QueueInMs());
|
|
send_bucket_->Process();
|
|
EXPECT_EQ(0, send_bucket_->QueueInMs());
|
|
}
|
|
|
|
TEST_F(PacedSenderTest, ProbingWithInitialFrame) {
|
|
const int kNumPackets = 11;
|
|
const int kNumDeltas = kNumPackets - 1;
|
|
const size_t kPacketSize = 1200;
|
|
const int kInitialBitrateKbps = 300;
|
|
uint32_t ssrc = 12346;
|
|
uint16_t sequence_number = 1234;
|
|
const int expected_deltas[kNumDeltas] = {
|
|
10, 10, 10, 10, 10, 5, 5, 5, 5, 5};
|
|
std::list<int> expected_deltas_list(expected_deltas,
|
|
expected_deltas + kNumPackets - 1);
|
|
PacedSenderProbing callback(expected_deltas_list, &clock_);
|
|
send_bucket_.reset(
|
|
new PacedSender(&clock_,
|
|
&callback,
|
|
kInitialBitrateKbps,
|
|
kPaceMultiplier * kInitialBitrateKbps,
|
|
0));
|
|
|
|
for (int i = 0; i < kNumPackets; ++i) {
|
|
EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority,
|
|
ssrc,
|
|
sequence_number++,
|
|
clock_.TimeInMilliseconds(),
|
|
kPacketSize,
|
|
false));
|
|
}
|
|
while (callback.packets_sent() < kNumPackets) {
|
|
int time_until_process = send_bucket_->TimeUntilNextProcess();
|
|
if (time_until_process <= 0) {
|
|
send_bucket_->Process();
|
|
} else {
|
|
clock_.AdvanceTimeMilliseconds(time_until_process);
|
|
}
|
|
}
|
|
}
|
|
|
|
TEST_F(PacedSenderTest, ProbingWithTooSmallInitialFrame) {
|
|
const int kNumPackets = 11;
|
|
const int kNumDeltas = kNumPackets - 1;
|
|
const size_t kPacketSize = 1200;
|
|
const int kInitialBitrateKbps = 300;
|
|
uint32_t ssrc = 12346;
|
|
uint16_t sequence_number = 1234;
|
|
const int expected_deltas[kNumDeltas] = {10, 10, 10, 10, 10, 5, 5, 5, 5, 5};
|
|
std::list<int> expected_deltas_list(expected_deltas,
|
|
expected_deltas + kNumPackets - 1);
|
|
PacedSenderProbing callback(expected_deltas_list, &clock_);
|
|
send_bucket_.reset(new PacedSender(&clock_, &callback, kInitialBitrateKbps,
|
|
kPaceMultiplier * kInitialBitrateKbps, 0));
|
|
|
|
for (int i = 0; i < kNumPackets - 5; ++i) {
|
|
EXPECT_FALSE(send_bucket_->SendPacket(
|
|
PacedSender::kNormalPriority, ssrc, sequence_number++,
|
|
clock_.TimeInMilliseconds(), kPacketSize, false));
|
|
}
|
|
while (callback.packets_sent() < kNumPackets) {
|
|
int time_until_process = send_bucket_->TimeUntilNextProcess();
|
|
if (time_until_process <= 0) {
|
|
send_bucket_->Process();
|
|
} else {
|
|
clock_.AdvanceTimeMilliseconds(time_until_process);
|
|
}
|
|
}
|
|
|
|
// Process one more time and make sure we don't send any more probes.
|
|
int time_until_process = send_bucket_->TimeUntilNextProcess();
|
|
clock_.AdvanceTimeMilliseconds(time_until_process);
|
|
send_bucket_->Process();
|
|
EXPECT_EQ(kNumPackets, callback.packets_sent());
|
|
}
|
|
|
|
TEST_F(PacedSenderTest, PriorityInversion) {
|
|
uint32_t ssrc = 12346;
|
|
uint16_t sequence_number = 1234;
|
|
const size_t kPacketSize = 1200;
|
|
|
|
EXPECT_FALSE(send_bucket_->SendPacket(
|
|
PacedSender::kHighPriority, ssrc, sequence_number + 3,
|
|
clock_.TimeInMilliseconds() + 33, kPacketSize, true));
|
|
|
|
EXPECT_FALSE(send_bucket_->SendPacket(
|
|
PacedSender::kHighPriority, ssrc, sequence_number + 2,
|
|
clock_.TimeInMilliseconds() + 33, kPacketSize, true));
|
|
|
|
EXPECT_FALSE(send_bucket_->SendPacket(
|
|
PacedSender::kHighPriority, ssrc, sequence_number,
|
|
clock_.TimeInMilliseconds(), kPacketSize, true));
|
|
|
|
EXPECT_FALSE(send_bucket_->SendPacket(
|
|
PacedSender::kHighPriority, ssrc, sequence_number + 1,
|
|
clock_.TimeInMilliseconds(), kPacketSize, true));
|
|
|
|
// Packets from earlier frames should be sent first.
|
|
{
|
|
::testing::InSequence sequence;
|
|
EXPECT_CALL(callback_, TimeToSendPacket(ssrc, sequence_number,
|
|
clock_.TimeInMilliseconds(), true))
|
|
.WillOnce(Return(true));
|
|
EXPECT_CALL(callback_, TimeToSendPacket(ssrc, sequence_number + 1,
|
|
clock_.TimeInMilliseconds(), true))
|
|
.WillOnce(Return(true));
|
|
EXPECT_CALL(callback_, TimeToSendPacket(ssrc, sequence_number + 3,
|
|
clock_.TimeInMilliseconds() + 33,
|
|
true)).WillOnce(Return(true));
|
|
EXPECT_CALL(callback_, TimeToSendPacket(ssrc, sequence_number + 2,
|
|
clock_.TimeInMilliseconds() + 33,
|
|
true)).WillOnce(Return(true));
|
|
|
|
while (send_bucket_->QueueSizePackets() > 0) {
|
|
int time_until_process = send_bucket_->TimeUntilNextProcess();
|
|
if (time_until_process <= 0) {
|
|
send_bucket_->Process();
|
|
} else {
|
|
clock_.AdvanceTimeMilliseconds(time_until_process);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
TEST_F(PacedSenderTest, PaddingOveruse) {
|
|
uint32_t ssrc = 12346;
|
|
uint16_t sequence_number = 1234;
|
|
const size_t kPacketSize = 1200;
|
|
|
|
// Min bitrate 0 => no padding, padding budget will stay at 0.
|
|
send_bucket_->UpdateBitrate(60, 90, 0);
|
|
SendAndExpectPacket(PacedSender::kNormalPriority, ssrc, sequence_number++,
|
|
clock_.TimeInMilliseconds(), kPacketSize, false);
|
|
send_bucket_->Process();
|
|
|
|
// Add 30kbit padding. When increasing budget, media budget will increase from
|
|
// negative (overuse) while padding budget will increase form 0.
|
|
clock_.AdvanceTimeMilliseconds(5);
|
|
send_bucket_->UpdateBitrate(60, 90, 30);
|
|
|
|
EXPECT_FALSE(send_bucket_->SendPacket(
|
|
PacedSender::kHighPriority, ssrc, sequence_number++,
|
|
clock_.TimeInMilliseconds(), kPacketSize, false));
|
|
|
|
// Don't send padding if queue is non-empty, even if padding budget > 0.
|
|
EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0);
|
|
send_bucket_->Process();
|
|
}
|
|
|
|
} // namespace test
|
|
} // namespace webrtc
|