Disable pacer disabling.
Since the pacer is always enabled, removing enable/disable which makes
all packet queueing succeed. Also renaming one of the ::SendPackets
::InsertPacket to avoid confusion.
BUG=webrtc:1695, webrtc:2629
R=stefan@webrtc.org
Review URL: https://codereview.webrtc.org/1392513002 .
Cr-Commit-Position: refs/heads/master@{#10211}
diff --git a/webrtc/modules/pacing/include/paced_sender.h b/webrtc/modules/pacing/include/paced_sender.h
index afb196f..f142f55 100644
--- a/webrtc/modules/pacing/include/paced_sender.h
+++ b/webrtc/modules/pacing/include/paced_sender.h
@@ -71,11 +71,6 @@
virtual ~PacedSender();
- // Enable/disable pacing.
- void SetStatus(bool enable);
-
- bool Enabled() const;
-
// Temporarily pause all sending.
void Pause();
@@ -98,12 +93,12 @@
// Returns true if we send the packet now, else it will add the packet
// information to the queue and call TimeToSendPacket when it's time to send.
- bool SendPacket(RtpPacketSender::Priority priority,
- uint32_t ssrc,
- uint16_t sequence_number,
- int64_t capture_time_ms,
- size_t bytes,
- bool retransmission) override;
+ void InsertPacket(RtpPacketSender::Priority priority,
+ uint32_t ssrc,
+ uint16_t sequence_number,
+ int64_t capture_time_ms,
+ size_t bytes,
+ bool retransmission) override;
// Returns the time since the oldest queued packet was enqueued.
virtual int64_t QueueInMs() const;
@@ -134,7 +129,6 @@
Callback* const callback_;
rtc::scoped_ptr<CriticalSectionWrapper> critsect_;
- bool enabled_ GUARDED_BY(critsect_);
bool paused_ GUARDED_BY(critsect_);
bool probing_enabled_;
// This is the media budget, keeping track of how many bits of media
diff --git a/webrtc/modules/pacing/paced_sender.cc b/webrtc/modules/pacing/paced_sender.cc
index 55c361b..6a7d19a 100644
--- a/webrtc/modules/pacing/paced_sender.cc
+++ b/webrtc/modules/pacing/paced_sender.cc
@@ -219,7 +219,6 @@
: clock_(clock),
callback_(callback),
critsect_(CriticalSectionWrapper::CreateCriticalSection()),
- enabled_(true),
paused_(false),
probing_enabled_(true),
media_budget_(new paced_sender::IntervalBudget(max_bitrate_kbps)),
@@ -249,16 +248,6 @@
probing_enabled_ = enabled;
}
-void PacedSender::SetStatus(bool enable) {
- CriticalSectionScoped cs(critsect_.get());
- enabled_ = enable;
-}
-
-bool PacedSender::Enabled() const {
- CriticalSectionScoped cs(critsect_.get());
- return enabled_;
-}
-
void PacedSender::UpdateBitrate(int bitrate_kbps,
int max_bitrate_kbps,
int min_bitrate_kbps) {
@@ -268,17 +257,14 @@
bitrate_bps_ = 1000 * bitrate_kbps;
}
-bool PacedSender::SendPacket(RtpPacketSender::Priority priority,
- uint32_t ssrc,
- uint16_t sequence_number,
- int64_t capture_time_ms,
- size_t bytes,
- bool retransmission) {
+void PacedSender::InsertPacket(RtpPacketSender::Priority priority,
+ uint32_t ssrc,
+ uint16_t sequence_number,
+ int64_t capture_time_ms,
+ size_t bytes,
+ bool retransmission) {
CriticalSectionScoped cs(critsect_.get());
- if (!enabled_) {
- return true; // We can send now.
- }
if (probing_enabled_ && !prober_->IsProbing()) {
prober_->SetEnabled(true);
}
@@ -291,7 +277,6 @@
packets_->Push(paced_sender::Packet(
priority, ssrc, sequence_number, capture_time_ms,
clock_->TimeInMilliseconds(), bytes, retransmission, packet_counter_++));
- return false;
}
int64_t PacedSender::ExpectedQueueTimeMs() const {
@@ -334,48 +319,45 @@
CriticalSectionScoped cs(critsect_.get());
int64_t elapsed_time_ms = (now_us - time_last_update_us_ + 500) / 1000;
time_last_update_us_ = now_us;
- if (!enabled_) {
+ if (paused_)
return 0;
+ if (elapsed_time_ms > 0) {
+ int64_t delta_time_ms = std::min(kMaxIntervalTimeMs, elapsed_time_ms);
+ UpdateBytesPerInterval(delta_time_ms);
}
- if (!paused_) {
- if (elapsed_time_ms > 0) {
- int64_t delta_time_ms = std::min(kMaxIntervalTimeMs, elapsed_time_ms);
- UpdateBytesPerInterval(delta_time_ms);
- }
- while (!packets_->Empty()) {
- if (media_budget_->bytes_remaining() == 0 && !prober_->IsProbing()) {
- return 0;
- }
-
- // Since we need to release the lock in order to send, we first pop the
- // element from the priority queue but keep it in storage, so that we can
- // reinsert it if send fails.
- const paced_sender::Packet& packet = packets_->BeginPop();
- if (SendPacket(packet)) {
- // Send succeeded, remove it from the queue.
- packets_->FinalizePop(packet);
- if (prober_->IsProbing()) {
- return 0;
- }
- } else {
- // Send failed, put it back into the queue.
- packets_->CancelPop(packet);
- return 0;
- }
- }
-
- if (!packets_->Empty())
+ while (!packets_->Empty()) {
+ if (media_budget_->bytes_remaining() == 0 && !prober_->IsProbing()) {
return 0;
+ }
- size_t padding_needed;
- if (prober_->IsProbing())
- padding_needed = prober_->RecommendedPacketSize();
- else
- padding_needed = padding_budget_->bytes_remaining();
-
- if (padding_needed > 0)
- SendPadding(static_cast<size_t>(padding_needed));
+ // Since we need to release the lock in order to send, we first pop the
+ // element from the priority queue but keep it in storage, so that we can
+ // reinsert it if send fails.
+ const paced_sender::Packet& packet = packets_->BeginPop();
+ if (SendPacket(packet)) {
+ // Send succeeded, remove it from the queue.
+ packets_->FinalizePop(packet);
+ if (prober_->IsProbing()) {
+ return 0;
+ }
+ } else {
+ // Send failed, put it back into the queue.
+ packets_->CancelPop(packet);
+ return 0;
+ }
}
+
+ if (!packets_->Empty())
+ return 0;
+
+ size_t padding_needed;
+ if (prober_->IsProbing())
+ padding_needed = prober_->RecommendedPacketSize();
+ else
+ padding_needed = padding_budget_->bytes_remaining();
+
+ if (padding_needed > 0)
+ SendPadding(static_cast<size_t>(padding_needed));
return 0;
}
diff --git a/webrtc/modules/pacing/paced_sender_unittest.cc b/webrtc/modules/pacing/paced_sender_unittest.cc
index a00b5fa..1e701ff 100644
--- a/webrtc/modules/pacing/paced_sender_unittest.cc
+++ b/webrtc/modules/pacing/paced_sender_unittest.cc
@@ -124,8 +124,8 @@
int64_t capture_time_ms,
size_t size,
bool retransmission) {
- EXPECT_FALSE(send_bucket_->SendPacket(priority, ssrc,
- sequence_number, capture_time_ms, size, retransmission));
+ send_bucket_->InsertPacket(priority, ssrc, sequence_number, capture_time_ms,
+ size, retransmission);
EXPECT_CALL(callback_,
TimeToSendPacket(ssrc, sequence_number, capture_time_ms, false))
.Times(1)
@@ -160,8 +160,9 @@
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_->InsertPacket(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);
@@ -188,8 +189,9 @@
clock_.TimeInMilliseconds(),
250,
false);
- EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority, ssrc,
- sequence_number++, clock_.TimeInMilliseconds(), 250, false));
+ send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc,
+ sequence_number++, clock_.TimeInMilliseconds(),
+ 250, false);
send_bucket_->Process();
}
@@ -207,8 +209,9 @@
false);
}
for (int j = 0; j < 30; ++j) {
- EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority, ssrc,
- sequence_number++, clock_.TimeInMilliseconds(), 250, false));
+ send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc,
+ sequence_number++, clock_.TimeInMilliseconds(),
+ 250, false);
}
send_bucket_->Process();
EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0);
@@ -243,8 +246,9 @@
clock_.TimeInMilliseconds(),
250,
false);
- EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority, ssrc,
- sequence_number, clock_.TimeInMilliseconds(), 250, false));
+ send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc,
+ sequence_number, clock_.TimeInMilliseconds(), 250,
+ false);
send_bucket_->Process();
}
@@ -266,10 +270,12 @@
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));
+ send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc,
+ sequence_number, clock_.TimeInMilliseconds(),
+ 250, false);
+ send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc,
+ sequence_number++, clock_.TimeInMilliseconds(),
+ 250, false);
}
EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0);
send_bucket_->Process();
@@ -308,8 +314,9 @@
clock_.TimeInMilliseconds(),
250,
false);
- EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority, ssrc,
- sequence_number++, clock_.TimeInMilliseconds(), 250, false));
+ send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc,
+ sequence_number++, clock_.TimeInMilliseconds(),
+ 250, false);
send_bucket_->Process();
}
@@ -377,23 +384,6 @@
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;
@@ -433,9 +423,9 @@
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));
+ send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc,
+ sequence_number++, capture_time_ms,
+ media_payload, false);
media_bytes += media_payload;
clock_.AdvanceTimeMilliseconds(kTimeStep);
send_bucket_->Process();
@@ -474,15 +464,15 @@
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));
+ send_bucket_->InsertPacket(PacedSender::kLowPriority, ssrc_low_priority,
+ sequence_number++, capture_time_ms_low_priority,
+ 250, false);
+ send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc,
+ sequence_number++, capture_time_ms, 250, false);
+ send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc,
+ sequence_number++, capture_time_ms, 250, false);
+ send_bucket_->InsertPacket(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);
@@ -538,20 +528,20 @@
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));
+ send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc,
+ sequence_number++, capture_time_ms, 250, false);
+ send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc,
+ sequence_number++, capture_time_ms, 250, false);
+ send_bucket_->InsertPacket(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));
+ send_bucket_->InsertPacket(PacedSender::kLowPriority, ssrc_low_priority,
+ sequence_number++, second_capture_time_ms, 250,
+ false);
EXPECT_EQ(clock_.TimeInMilliseconds() - capture_time_ms,
send_bucket_->QueueInMs());
@@ -593,19 +583,12 @@
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));
+ send_bucket_->InsertPacket(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));
+ send_bucket_->InsertPacket(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());
@@ -726,12 +709,9 @@
0));
for (int i = 0; i < kNumPackets; ++i) {
- EXPECT_FALSE(send_bucket_->SendPacket(PacedSender::kNormalPriority,
- ssrc,
- sequence_number++,
- clock_.TimeInMilliseconds(),
- kPacketSize,
- false));
+ send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc,
+ sequence_number++, clock_.TimeInMilliseconds(),
+ kPacketSize, false);
}
while (callback.packets_sent() < kNumPackets) {
int time_until_process = send_bucket_->TimeUntilNextProcess();
@@ -758,9 +738,9 @@
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));
+ send_bucket_->InsertPacket(PacedSender::kNormalPriority, ssrc,
+ sequence_number++, clock_.TimeInMilliseconds(),
+ kPacketSize, false);
}
while (callback.packets_sent() < kNumPackets) {
int time_until_process = send_bucket_->TimeUntilNextProcess();
@@ -783,21 +763,20 @@
uint16_t sequence_number = 1234;
const size_t kPacketSize = 1200;
- EXPECT_FALSE(send_bucket_->SendPacket(
+ send_bucket_->InsertPacket(
PacedSender::kHighPriority, ssrc, sequence_number + 3,
- clock_.TimeInMilliseconds() + 33, kPacketSize, true));
+ clock_.TimeInMilliseconds() + 33, kPacketSize, true);
- EXPECT_FALSE(send_bucket_->SendPacket(
+ send_bucket_->InsertPacket(
PacedSender::kHighPriority, ssrc, sequence_number + 2,
- clock_.TimeInMilliseconds() + 33, kPacketSize, true));
+ clock_.TimeInMilliseconds() + 33, kPacketSize, true);
- EXPECT_FALSE(send_bucket_->SendPacket(
- PacedSender::kHighPriority, ssrc, sequence_number,
- clock_.TimeInMilliseconds(), kPacketSize, true));
+ send_bucket_->InsertPacket(PacedSender::kHighPriority, ssrc, sequence_number,
+ clock_.TimeInMilliseconds(), kPacketSize, true);
- EXPECT_FALSE(send_bucket_->SendPacket(
- PacedSender::kHighPriority, ssrc, sequence_number + 1,
- clock_.TimeInMilliseconds(), kPacketSize, true));
+ send_bucket_->InsertPacket(PacedSender::kHighPriority, ssrc,
+ sequence_number + 1, clock_.TimeInMilliseconds(),
+ kPacketSize, true);
// Packets from earlier frames should be sent first.
{
@@ -842,9 +821,9 @@
clock_.AdvanceTimeMilliseconds(5);
send_bucket_->UpdateBitrate(60, 90, 30);
- EXPECT_FALSE(send_bucket_->SendPacket(
- PacedSender::kHighPriority, ssrc, sequence_number++,
- clock_.TimeInMilliseconds(), kPacketSize, false));
+ send_bucket_->InsertPacket(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);
diff --git a/webrtc/modules/remote_bitrate_estimator/test/packet_sender.cc b/webrtc/modules/remote_bitrate_estimator/test/packet_sender.cc
index 21c2f36..f1faa49 100644
--- a/webrtc/modules/remote_bitrate_estimator/test/packet_sender.cc
+++ b/webrtc/modules/remote_bitrate_estimator/test/packet_sender.cc
@@ -209,7 +209,7 @@
if (!generated_packets.empty()) {
for (Packet* packet : generated_packets) {
MediaPacket* media_packet = static_cast<MediaPacket*>(packet);
- pacer_.SendPacket(
+ pacer_.InsertPacket(
PacedSender::kNormalPriority, media_packet->header().ssrc,
media_packet->header().sequenceNumber, media_packet->send_time_ms(),
media_packet->payload_size(), false);
diff --git a/webrtc/modules/rtp_rtcp/interface/rtp_rtcp_defines.h b/webrtc/modules/rtp_rtcp/interface/rtp_rtcp_defines.h
index fdca434..a262a07 100644
--- a/webrtc/modules/rtp_rtcp/interface/rtp_rtcp_defines.h
+++ b/webrtc/modules/rtp_rtcp/interface/rtp_rtcp_defines.h
@@ -65,7 +65,6 @@
};
enum StorageType {
- kDontStore,
kDontRetransmit,
kAllowRetransmission
};
@@ -108,12 +107,7 @@
kRtcpTransportFeedback = 0x100000,
};
-enum KeyFrameRequestMethod
-{
- kKeyFrameReqFirRtp = 1,
- kKeyFrameReqPliRtcp = 2,
- kKeyFrameReqFirRtcp = 3
-};
+enum KeyFrameRequestMethod { kKeyFrameReqPliRtcp, kKeyFrameReqFirRtcp };
enum RtpRtcpPacketType
{
@@ -404,12 +398,12 @@
// Returns true if we send the packet now, else it will add the packet
// information to the queue and call TimeToSendPacket when it's time to send.
- virtual bool SendPacket(Priority priority,
- uint32_t ssrc,
- uint16_t sequence_number,
- int64_t capture_time_ms,
- size_t bytes,
- bool retransmission) = 0;
+ virtual void InsertPacket(Priority priority,
+ uint32_t ssrc,
+ uint16_t sequence_number,
+ int64_t capture_time_ms,
+ size_t bytes,
+ bool retransmission) = 0;
};
class TransportSequenceNumberAllocator {
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_packet_history.cc b/webrtc/modules/rtp_rtcp/source/rtp_packet_history.cc
index cc0cc83..e1d6d48 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_packet_history.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtp_packet_history.cc
@@ -75,10 +75,6 @@
size_t packet_length,
int64_t capture_time_ms,
StorageType type) {
- if (type == kDontStore) {
- return 0;
- }
-
CriticalSectionScoped cs(critsect_.get());
if (!store_) {
return 0;
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_packet_history.h b/webrtc/modules/rtp_rtcp/source/rtp_packet_history.h
index 4a99e16..d128494 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_packet_history.h
+++ b/webrtc/modules/rtp_rtcp/source/rtp_packet_history.h
@@ -93,7 +93,7 @@
uint16_t sequence_number = 0;
int64_t time_ms = 0;
int64_t send_time = 0;
- StorageType storage_type = kDontStore;
+ StorageType storage_type = kDontRetransmit;
uint8_t data[IP_PACKET_SIZE];
size_t length = 0;
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_packet_history_unittest.cc b/webrtc/modules/rtp_rtcp/source/rtp_packet_history_unittest.cc
index f3b5556..a30753a 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_packet_history_unittest.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtp_packet_history_unittest.cc
@@ -79,20 +79,6 @@
&time));
}
-TEST_F(RtpPacketHistoryTest, DontStore) {
- hist_->SetStorePacketsStatus(true, 10);
- size_t len = 0;
- int64_t capture_time_ms = fake_clock_.TimeInMilliseconds();
- CreateRtpPacket(kSeqNum, kSsrc, kPayload, kTimestamp, packet_, &len);
- EXPECT_EQ(0, hist_->PutRTPPacket(packet_, len, capture_time_ms, kDontStore));
-
- // Packet should not be stored.
- len = kMaxPacketLength;
- int64_t time;
- EXPECT_FALSE(hist_->GetPacketAndSetSendTime(kSeqNum, 0, false, packet_, &len,
- &time));
-}
-
TEST_F(RtpPacketHistoryTest, PutRtpPacket_TooLargePacketLength) {
hist_->SetStorePacketsStatus(true, 10);
int64_t capture_time_ms = fake_clock_.TimeInMilliseconds();
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.cc b/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.cc
index 6840d81..29954e2 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.cc
@@ -93,7 +93,7 @@
nack_last_time_sent_full_(0),
nack_last_time_sent_full_prev_(0),
nack_last_seq_number_sent_(0),
- key_frame_req_method_(kKeyFrameReqFirRtp),
+ key_frame_req_method_(kKeyFrameReqPliRtcp),
remote_bitrate_(configuration.remote_bitrate_estimator),
rtt_stats_(configuration.rtt_stats),
critical_section_rtt_(CriticalSectionWrapper::CreateCriticalSection()),
@@ -811,8 +811,6 @@
int32_t ModuleRtpRtcpImpl::RequestKeyFrame() {
switch (key_frame_req_method_) {
- case kKeyFrameReqFirRtp:
- return rtp_sender_.SendRTPIntraRequest();
case kKeyFrameReqPliRtcp:
return SendRTCP(kRtcpPli);
case kKeyFrameReqFirRtcp:
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_sender.cc b/webrtc/modules/rtp_rtcp/source/rtp_sender.cc
index 252ffb2..0c67c69 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_sender.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtp_sender.cc
@@ -712,13 +712,11 @@
// Convert from TickTime to Clock since capture_time_ms is based on
// TickTime.
int64_t corrected_capture_tims_ms = capture_time_ms + clock_delta_ms_;
- if (!paced_sender_->SendPacket(
- RtpPacketSender::kHighPriority, header.ssrc, header.sequenceNumber,
- corrected_capture_tims_ms, length - header.headerLength, true)) {
- // We can't send the packet right now.
- // We will be called when it is time.
- return length;
- }
+ paced_sender_->InsertPacket(
+ RtpPacketSender::kHighPriority, header.ssrc, header.sequenceNumber,
+ corrected_capture_tims_ms, length - header.headerLength, true);
+
+ return length;
}
int rtx = kRtxOff;
{
@@ -1037,24 +1035,21 @@
return -1;
}
- if (paced_sender_ && storage != kDontStore) {
+ if (paced_sender_) {
// Correct offset between implementations of millisecond time stamps in
// TickTime and Clock.
int64_t corrected_time_ms = capture_time_ms + clock_delta_ms_;
- if (!paced_sender_->SendPacket(priority, rtp_header.ssrc,
- rtp_header.sequenceNumber, corrected_time_ms,
- payload_length, false)) {
- if (last_capture_time_ms_sent_ == 0 ||
- corrected_time_ms > last_capture_time_ms_sent_) {
- last_capture_time_ms_sent_ = corrected_time_ms;
- TRACE_EVENT_ASYNC_BEGIN1(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"),
- "PacedSend", corrected_time_ms,
- "capture_time_ms", corrected_time_ms);
- }
- // We can't send the packet right now.
- // We will be called when it is time.
- return 0;
+ paced_sender_->InsertPacket(priority, rtp_header.ssrc,
+ rtp_header.sequenceNumber, corrected_time_ms,
+ payload_length, false);
+ if (last_capture_time_ms_sent_ == 0 ||
+ corrected_time_ms > last_capture_time_ms_sent_) {
+ last_capture_time_ms_sent_ = corrected_time_ms;
+ TRACE_EVENT_ASYNC_BEGIN1(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"),
+ "PacedSend", corrected_time_ms,
+ "capture_time_ms", corrected_time_ms);
}
+ return 0;
}
if (capture_time_ms > 0) {
UpdateDelayStatistics(capture_time_ms, now_ms);
@@ -1063,12 +1058,11 @@
size_t length = payload_length + rtp_header_length;
bool sent = SendPacketToNetwork(buffer, length, PacketOptions());
- if (storage != kDontStore) {
- // Mark the packet as sent in the history even if send failed. Dropping a
- // packet here should be treated as any other packet drop so we should be
- // ready for a retransmission.
- packet_history_.SetSent(rtp_header.sequenceNumber);
- }
+ // Mark the packet as sent in the history even if send failed. Dropping a
+ // packet here should be treated as any other packet drop so we should be
+ // ready for a retransmission.
+ packet_history_.SetSent(rtp_header.sequenceNumber);
+
if (!sent)
return -1;
@@ -1784,13 +1778,6 @@
return video_->MaxConfiguredBitrateVideo();
}
-int32_t RTPSender::SendRTPIntraRequest() {
- if (audio_configured_) {
- return -1;
- }
- return video_->SendRTPIntraRequest();
-}
-
void RTPSender::SetGenericFECStatus(bool enable,
uint8_t payload_type_red,
uint8_t payload_type_fec) {
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_sender.h b/webrtc/modules/rtp_rtcp/source/rtp_sender.h
index 57516f8..a134370 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_sender.h
+++ b/webrtc/modules/rtp_rtcp/source/rtp_sender.h
@@ -283,8 +283,6 @@
uint32_t MaxConfiguredBitrateVideo() const;
- int32_t SendRTPIntraRequest();
-
// FEC.
void SetGenericFECStatus(bool enable,
uint8_t payload_type_red,
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_sender_unittest.cc b/webrtc/modules/rtp_rtcp/source/rtp_sender_unittest.cc
index 305ea13..6d30263 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_sender_unittest.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtp_sender_unittest.cc
@@ -107,8 +107,8 @@
MockRtpPacketSender() {}
virtual ~MockRtpPacketSender() {}
- MOCK_METHOD6(SendPacket,
- bool(Priority priority,
+ MOCK_METHOD6(InsertPacket,
+ void(Priority priority,
uint32_t ssrc,
uint16_t sequence_number,
int64_t capture_time_ms,
@@ -125,14 +125,17 @@
payload_(kPayload),
transport_(),
kMarkerBit(true) {
- EXPECT_CALL(mock_paced_sender_,
- SendPacket(_, _, _, _, _, _)).WillRepeatedly(testing::Return(true));
+ EXPECT_CALL(mock_paced_sender_, InsertPacket(_, _, _, _, _, _))
+ .WillRepeatedly(testing::Return());
}
- void SetUp() override {
+ void SetUp() override { SetUpRtpSender(true); }
+
+ void SetUpRtpSender(bool pacer) {
rtp_sender_.reset(new RTPSender(false, &fake_clock_, &transport_, nullptr,
- &mock_paced_sender_, nullptr, nullptr,
- nullptr, nullptr, nullptr));
+ pacer ? &mock_paced_sender_ : nullptr,
+ nullptr, nullptr, nullptr, nullptr,
+ nullptr));
rtp_sender_->SetSequenceNumber(kSeqNum);
}
@@ -174,10 +177,18 @@
}
};
+// TODO(pbos): Move tests over from WithoutPacer to RtpSenderTest as this is our
+// default code path.
+class RtpSenderTestWithoutPacer : public RtpSenderTest {
+ public:
+ void SetUp() override { SetUpRtpSender(false); }
+};
+
class RtpSenderVideoTest : public RtpSenderTest {
protected:
virtual void SetUp() override {
- RtpSenderTest::SetUp();
+ // TODO(pbos): Set up to use pacer.
+ SetUpRtpSender(false);
rtp_sender_video_.reset(
new RTPSenderVideo(&fake_clock_, rtp_sender_.get()));
}
@@ -213,7 +224,8 @@
}
};
-TEST_F(RtpSenderTest, RegisterRtpTransmissionTimeOffsetHeaderExtension) {
+TEST_F(RtpSenderTestWithoutPacer,
+ RegisterRtpTransmissionTimeOffsetHeaderExtension) {
EXPECT_EQ(0u, rtp_sender_->RtpHeaderExtensionTotalLength());
EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
kRtpExtensionTransmissionTimeOffset, kTransmissionTimeOffsetExtensionId));
@@ -224,7 +236,7 @@
EXPECT_EQ(0u, rtp_sender_->RtpHeaderExtensionTotalLength());
}
-TEST_F(RtpSenderTest, RegisterRtpAbsoluteSendTimeHeaderExtension) {
+TEST_F(RtpSenderTestWithoutPacer, RegisterRtpAbsoluteSendTimeHeaderExtension) {
EXPECT_EQ(0u, rtp_sender_->RtpHeaderExtensionTotalLength());
EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
kRtpExtensionAbsoluteSendTime, kAbsoluteSendTimeExtensionId));
@@ -236,7 +248,7 @@
EXPECT_EQ(0u, rtp_sender_->RtpHeaderExtensionTotalLength());
}
-TEST_F(RtpSenderTest, RegisterRtpAudioLevelHeaderExtension) {
+TEST_F(RtpSenderTestWithoutPacer, RegisterRtpAudioLevelHeaderExtension) {
EXPECT_EQ(0u, rtp_sender_->RtpHeaderExtensionTotalLength());
EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
kRtpExtensionAudioLevel, kAudioLevelExtensionId));
@@ -248,7 +260,7 @@
EXPECT_EQ(0u, rtp_sender_->RtpHeaderExtensionTotalLength());
}
-TEST_F(RtpSenderTest, RegisterRtpHeaderExtensions) {
+TEST_F(RtpSenderTestWithoutPacer, RegisterRtpHeaderExtensions) {
EXPECT_EQ(0u, rtp_sender_->RtpHeaderExtensionTotalLength());
EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
kRtpExtensionTransmissionTimeOffset, kTransmissionTimeOffsetExtensionId));
@@ -298,7 +310,7 @@
EXPECT_EQ(0u, rtp_sender_->RtpHeaderExtensionTotalLength());
}
-TEST_F(RtpSenderTest, RegisterRtpVideoRotationHeaderExtension) {
+TEST_F(RtpSenderTestWithoutPacer, RegisterRtpVideoRotationHeaderExtension) {
EXPECT_EQ(0u, rtp_sender_->RtpHeaderExtensionTotalLength());
EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
kRtpExtensionVideoRotation, kVideoRotationExtensionId));
@@ -313,7 +325,7 @@
EXPECT_EQ(0u, rtp_sender_->RtpHeaderExtensionTotalLength());
}
-TEST_F(RtpSenderTest, BuildRTPPacket) {
+TEST_F(RtpSenderTestWithoutPacer, BuildRTPPacket) {
size_t length = static_cast<size_t>(rtp_sender_->BuildRTPheader(
packet_, kPayload, kMarkerBit, kTimestamp, 0));
ASSERT_EQ(kRtpHeaderSize, length);
@@ -338,7 +350,8 @@
EXPECT_EQ(0u, rtp_header.extension.videoRotation);
}
-TEST_F(RtpSenderTest, BuildRTPPacketWithTransmissionOffsetExtension) {
+TEST_F(RtpSenderTestWithoutPacer,
+ BuildRTPPacketWithTransmissionOffsetExtension) {
EXPECT_EQ(0, rtp_sender_->SetTransmissionTimeOffset(kTimeOffset));
EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
kRtpExtensionTransmissionTimeOffset, kTransmissionTimeOffsetExtensionId));
@@ -375,7 +388,8 @@
EXPECT_EQ(0, rtp_header2.extension.transmissionTimeOffset);
}
-TEST_F(RtpSenderTest, BuildRTPPacketWithNegativeTransmissionOffsetExtension) {
+TEST_F(RtpSenderTestWithoutPacer,
+ BuildRTPPacketWithNegativeTransmissionOffsetExtension) {
const int kNegTimeOffset = -500;
EXPECT_EQ(0, rtp_sender_->SetTransmissionTimeOffset(kNegTimeOffset));
EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
@@ -403,7 +417,7 @@
EXPECT_EQ(kNegTimeOffset, rtp_header.extension.transmissionTimeOffset);
}
-TEST_F(RtpSenderTest, BuildRTPPacketWithAbsoluteSendTimeExtension) {
+TEST_F(RtpSenderTestWithoutPacer, BuildRTPPacketWithAbsoluteSendTimeExtension) {
EXPECT_EQ(0, rtp_sender_->SetAbsoluteSendTime(kAbsoluteSendTime));
EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
kRtpExtensionAbsoluteSendTime, kAbsoluteSendTimeExtensionId));
@@ -440,7 +454,7 @@
}
// Test CVO header extension is only set when marker bit is true.
-TEST_F(RtpSenderTest, BuildRTPPacketWithVideoRotation_MarkerBit) {
+TEST_F(RtpSenderTestWithoutPacer, BuildRTPPacketWithVideoRotation_MarkerBit) {
rtp_sender_->SetVideoRotation(kRotation);
EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
kRtpExtensionVideoRotation, kVideoRotationExtensionId));
@@ -468,7 +482,8 @@
}
// Test CVO header extension is not set when marker bit is false.
-TEST_F(RtpSenderTest, DISABLED_BuildRTPPacketWithVideoRotation_NoMarkerBit) {
+TEST_F(RtpSenderTestWithoutPacer,
+ DISABLED_BuildRTPPacketWithVideoRotation_NoMarkerBit) {
rtp_sender_->SetVideoRotation(kRotation);
EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
kRtpExtensionVideoRotation, kVideoRotationExtensionId));
@@ -492,7 +507,7 @@
EXPECT_FALSE(rtp_header.extension.hasVideoRotation);
}
-TEST_F(RtpSenderTest, BuildRTPPacketWithAudioLevelExtension) {
+TEST_F(RtpSenderTestWithoutPacer, BuildRTPPacketWithAudioLevelExtension) {
EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
kRtpExtensionAudioLevel, kAudioLevelExtensionId));
@@ -533,7 +548,7 @@
EXPECT_EQ(0u, rtp_header2.extension.audioLevel);
}
-TEST_F(RtpSenderTest, BuildRTPPacketWithHeaderExtensions) {
+TEST_F(RtpSenderTestWithoutPacer, BuildRTPPacketWithHeaderExtensions) {
EXPECT_EQ(0, rtp_sender_->SetTransmissionTimeOffset(kTimeOffset));
EXPECT_EQ(0, rtp_sender_->SetAbsoluteSendTime(kAbsoluteSendTime));
EXPECT_EQ(0,
@@ -605,9 +620,9 @@
}
TEST_F(RtpSenderTest, TrafficSmoothingWithExtensions) {
- EXPECT_CALL(mock_paced_sender_,
- SendPacket(RtpPacketSender::kNormalPriority, _, kSeqNum, _, _, _))
- .WillOnce(testing::Return(false));
+ EXPECT_CALL(mock_paced_sender_, InsertPacket(RtpPacketSender::kNormalPriority,
+ _, kSeqNum, _, _, _))
+ .WillRepeatedly(testing::Return());
rtp_sender_->SetStorePacketsStatus(true, 10);
EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
@@ -655,9 +670,9 @@
}
TEST_F(RtpSenderTest, TrafficSmoothingRetransmits) {
- EXPECT_CALL(mock_paced_sender_,
- SendPacket(RtpPacketSender::kNormalPriority, _, kSeqNum, _, _, _))
- .WillOnce(testing::Return(false));
+ EXPECT_CALL(mock_paced_sender_, InsertPacket(RtpPacketSender::kNormalPriority,
+ _, kSeqNum, _, _, _))
+ .WillRepeatedly(testing::Return());
rtp_sender_->SetStorePacketsStatus(true, 10);
EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
@@ -679,8 +694,8 @@
EXPECT_EQ(0, transport_.packets_sent_);
EXPECT_CALL(mock_paced_sender_,
- SendPacket(RtpPacketSender::kHighPriority, _, kSeqNum, _, _, _))
- .WillOnce(testing::Return(false));
+ InsertPacket(RtpPacketSender::kHighPriority, _, kSeqNum, _, _, _))
+ .WillRepeatedly(testing::Return());
const int kStoredTimeInMs = 100;
fake_clock_.AdvanceTimeMilliseconds(kStoredTimeInMs);
@@ -717,8 +732,8 @@
TEST_F(RtpSenderTest, SendPadding) {
// Make all (non-padding) packets go to send queue.
EXPECT_CALL(mock_paced_sender_,
- SendPacket(RtpPacketSender::kNormalPriority, _, _, _, _, _))
- .WillRepeatedly(testing::Return(false));
+ InsertPacket(RtpPacketSender::kNormalPriority, _, _, _, _, _))
+ .WillRepeatedly(testing::Return());
uint16_t seq_num = kSeqNum;
uint32_t timestamp = kTimestamp;
@@ -837,8 +852,8 @@
rtp_sender_->SetRtxPayloadType(kRtxPayload, kPayload);
// Make all packets go through the pacer.
EXPECT_CALL(mock_paced_sender_,
- SendPacket(RtpPacketSender::kNormalPriority, _, _, _, _, _))
- .WillRepeatedly(testing::Return(false));
+ InsertPacket(RtpPacketSender::kNormalPriority, _, _, _, _, _))
+ .WillRepeatedly(testing::Return());
uint16_t seq_num = kSeqNum;
rtp_sender_->SetStorePacketsStatus(true, 10);
@@ -891,7 +906,7 @@
rtp_sender_->TimeToSendPadding(999));
}
-TEST_F(RtpSenderTest, SendGenericVideo) {
+TEST_F(RtpSenderTestWithoutPacer, SendGenericVideo) {
char payload_name[RTP_PAYLOAD_NAME_SIZE] = "GENERIC";
const uint8_t payload_type = 127;
ASSERT_EQ(0, rtp_sender_->RegisterPayload(payload_name, payload_type, 90000,
@@ -1017,8 +1032,8 @@
BitrateStatistics retransmit_stats_;
} callback;
rtp_sender_.reset(new RTPSender(false, &fake_clock_, &transport_, nullptr,
- &mock_paced_sender_, nullptr, nullptr,
- &callback, nullptr, nullptr));
+ nullptr, nullptr, nullptr, &callback, nullptr,
+ nullptr));
// Simulate kNumPackets sent with kPacketInterval ms intervals.
const uint32_t kNumPackets = 15;
@@ -1076,13 +1091,13 @@
void SetUp() override {
payload_ = kAudioPayload;
rtp_sender_.reset(new RTPSender(true, &fake_clock_, &transport_, nullptr,
- &mock_paced_sender_, nullptr, nullptr,
- nullptr, nullptr, nullptr));
+ nullptr, nullptr, nullptr, nullptr, nullptr,
+ nullptr));
rtp_sender_->SetSequenceNumber(kSeqNum);
}
};
-TEST_F(RtpSenderTest, StreamDataCountersCallbacks) {
+TEST_F(RtpSenderTestWithoutPacer, StreamDataCountersCallbacks) {
class TestCallback : public StreamDataCountersCallback {
public:
TestCallback()
@@ -1298,7 +1313,7 @@
EXPECT_FALSE(rtp_header.markerBit);
}
-TEST_F(RtpSenderTest, BytesReportedCorrectly) {
+TEST_F(RtpSenderTestWithoutPacer, BytesReportedCorrectly) {
const char* kPayloadName = "GENERIC";
const uint8_t kPayloadType = 127;
rtp_sender_->SetSSRC(1234);
@@ -1351,7 +1366,7 @@
rtx_stats.transmitted.TotalBytes());
}
-TEST_F(RtpSenderTest, RespectsNackBitrateLimit) {
+TEST_F(RtpSenderTestWithoutPacer, RespectsNackBitrateLimit) {
const int32_t kPacketSize = 1400;
const int32_t kNumPackets = 30;
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_sender_video.cc b/webrtc/modules/rtp_rtcp/source/rtp_sender_video.cc
index a2008bf..0c7f41a 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_sender_video.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtp_sender_video.cc
@@ -176,26 +176,6 @@
}
}
-int32_t RTPSenderVideo::SendRTPIntraRequest() {
- // RFC 2032
- // 5.2.1. Full intra-frame Request (FIR) packet
-
- size_t length = 8;
- uint8_t data[8];
- data[0] = 0x80;
- data[1] = 192;
- data[2] = 0;
- data[3] = 1; // length
-
- ByteWriter<uint32_t>::WriteBigEndian(data + 4, _rtpSender.SSRC());
-
- TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"),
- "Video::IntraRequest", "seqnum",
- _rtpSender.SequenceNumber());
- return _rtpSender.SendToNetwork(data, 0, length, -1, kDontStore,
- RtpPacketSender::kNormalPriority);
-}
-
void RTPSenderVideo::SetGenericFECStatus(const bool enable,
const uint8_t payloadTypeRED,
const uint8_t payloadTypeFEC) {
@@ -259,8 +239,8 @@
RtpPacketizer::Create(videoType, _rtpSender.MaxDataPayloadLength(),
&(rtpHdr->codecHeader), frameType));
- StorageType storage = kDontStore;
- bool fec_enabled = false;
+ StorageType storage;
+ bool fec_enabled;
{
CriticalSectionScoped cs(crit_.get());
FecProtectionParams* fec_params =
diff --git a/webrtc/video/video_receive_stream.cc b/webrtc/video/video_receive_stream.cc
index d50bb22..018da73 100644
--- a/webrtc/video/video_receive_stream.cc
+++ b/webrtc/video/video_receive_stream.cc
@@ -147,7 +147,6 @@
// TODO(pbos): This is not fine grained enough...
vie_channel_->SetProtectionMode(config_.rtp.nack.rtp_history_ms > 0, false,
-1, -1);
- vie_channel_->SetKeyFrameRequestMethod(kKeyFrameReqPliRtcp);
RTC_DCHECK(config_.rtp.rtcp_mode != RtcpMode::kOff)
<< "A stream should not be configured with RTCP disabled. This value is "
"reserved for internal usage.";
diff --git a/webrtc/video/video_send_stream.cc b/webrtc/video/video_send_stream.cc
index 953aa35..d55adf0 100644
--- a/webrtc/video/video_send_stream.cc
+++ b/webrtc/video/video_send_stream.cc
@@ -183,14 +183,8 @@
if (config_.post_encode_callback)
vie_encoder_->RegisterPostEncodeImageCallback(&encoded_frame_proxy_);
- if (config_.suspend_below_min_bitrate) {
+ if (config_.suspend_below_min_bitrate)
vie_encoder_->SuspendBelowMinBitrate();
- // Must enable pacing when enabling SuspendBelowMinBitrate. Otherwise, no
- // padding will be sent when the video is suspended so the video will be
- // unable to recover.
- // TODO(pbos): Pacing should probably be enabled outside of VideoSendStream.
- vie_channel_->SetTransmissionSmoothingStatus(true);
- }
vie_channel_->RegisterSendChannelRtcpStatisticsCallback(&stats_proxy_);
vie_channel_->RegisterSendChannelRtpStatisticsCallback(&stats_proxy_);
diff --git a/webrtc/video_engine/vie_channel.cc b/webrtc/video_engine/vie_channel.cc
index 264964d..84a86f8 100644
--- a/webrtc/video_engine/vie_channel.cc
+++ b/webrtc/video_engine/vie_channel.cc
@@ -144,7 +144,7 @@
// RTP/RTCP initialization.
module_process_thread_->RegisterModule(rtp_rtcp_modules_[0]);
- rtp_rtcp_modules_[0]->SetKeyFrameRequestMethod(kKeyFrameReqFirRtp);
+ rtp_rtcp_modules_[0]->SetKeyFrameRequestMethod(kKeyFrameReqPliRtcp);
if (paced_sender_) {
for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_)
rtp_rtcp->SetStorePacketsStatus(true, nack_history_size_sender_);
@@ -609,11 +609,6 @@
return target_delay_ms * 40 * 30 / 1000;
}
-int32_t ViEChannel::SetKeyFrameRequestMethod(
- const KeyFrameRequestMethod method) {
- return rtp_rtcp_modules_[0]->SetKeyFrameRequestMethod(method);
-}
-
void ViEChannel::EnableRemb(bool enable) {
rtp_rtcp_modules_[0]->SetREMBStatus(enable);
}
@@ -702,11 +697,6 @@
rtp_rtcp_modules_[0]->SetRtcpXrRrtrStatus(enable);
}
-void ViEChannel::SetTransmissionSmoothingStatus(bool enable) {
- RTC_DCHECK(paced_sender_ && "No paced sender registered.");
- paced_sender_->SetStatus(enable);
-}
-
void ViEChannel::EnableTMMBR(bool enable) {
rtp_rtcp_modules_[0]->SetTMMBRStatus(enable);
}
diff --git a/webrtc/video_engine/vie_channel.h b/webrtc/video_engine/vie_channel.h
index cc61080..ed6521c 100644
--- a/webrtc/video_engine/vie_channel.h
+++ b/webrtc/video_engine/vie_channel.h
@@ -109,7 +109,6 @@
bool IsSendingFecEnabled();
int SetSenderBufferingMode(int target_delay_ms);
int SetReceiverBufferingMode(int target_delay_ms);
- int32_t SetKeyFrameRequestMethod(const KeyFrameRequestMethod method);
void EnableRemb(bool enable);
int SetSendTimestampOffsetStatus(bool enable, int id);
int SetReceiveTimestampOffsetStatus(bool enable, int id);
@@ -120,7 +119,6 @@
int SetSendTransportSequenceNumber(bool enable, int id);
int SetReceiveTransportSequenceNumber(bool enable, int id);
void SetRtcpXrRrtrStatus(bool enable);
- void SetTransmissionSmoothingStatus(bool enable);
void EnableTMMBR(bool enable);
// Sets SSRC for outgoing stream.
