diff --git a/webrtc/modules/pacing/paced_sender.cc b/webrtc/modules/pacing/paced_sender.cc index 58c7d2d368..167be23ab6 100644 --- a/webrtc/modules/pacing/paced_sender.cc +++ b/webrtc/modules/pacing/paced_sender.cc @@ -389,9 +389,6 @@ void PacedSender::Process() { int64_t delta_time_ms = std::min(kMaxIntervalTimeMs, elapsed_time_ms); UpdateBytesPerInterval(delta_time_ms); } - - int probe_cluster_id = prober_->IsProbing() ? prober_->CurrentClusterId() - : PacketInfo::kNotAProbe; while (!packets_->Empty()) { if (media_budget_->bytes_remaining() == 0 && !prober_->IsProbing()) return; @@ -400,6 +397,8 @@ void PacedSender::Process() { // 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(); + int probe_cluster_id = + prober_->IsProbing() ? prober_->CurrentClusterId() : -1; if (SendPacket(packet, probe_cluster_id)) { // Send succeeded, remove it from the queue. @@ -425,7 +424,7 @@ void PacedSender::Process() { } if (padding_needed > 0) - SendPadding(padding_needed, probe_cluster_id); + SendPadding(static_cast(padding_needed)); } bool PacedSender::SendPacket(const paced_sender::Packet& packet, @@ -455,10 +454,9 @@ bool PacedSender::SendPacket(const paced_sender::Packet& packet, return success; } -void PacedSender::SendPadding(size_t padding_needed, int probe_cluster_id) { +void PacedSender::SendPadding(size_t padding_needed) { critsect_->Leave(); - size_t bytes_sent = - packet_sender_->TimeToSendPadding(padding_needed, probe_cluster_id); + size_t bytes_sent = packet_sender_->TimeToSendPadding(padding_needed); critsect_->Enter(); if (bytes_sent > 0) { diff --git a/webrtc/modules/pacing/paced_sender.h b/webrtc/modules/pacing/paced_sender.h index 8879f12d03..d42b9b3848 100644 --- a/webrtc/modules/pacing/paced_sender.h +++ b/webrtc/modules/pacing/paced_sender.h @@ -46,7 +46,7 @@ class PacedSender : public Module, public RtpPacketSender { int probe_cluster_id) = 0; // Called when it's a good time to send a padding data. // Returns the number of bytes sent. - virtual size_t TimeToSendPadding(size_t bytes, int probe_cluster_id) = 0; + virtual size_t TimeToSendPadding(size_t bytes) = 0; protected: virtual ~PacketSender() {} @@ -133,8 +133,7 @@ class PacedSender : public Module, public RtpPacketSender { bool SendPacket(const paced_sender::Packet& packet, int probe_cluster_id) EXCLUSIVE_LOCKS_REQUIRED(critsect_); - void SendPadding(size_t padding_needed, int probe_cluster_id) - EXCLUSIVE_LOCKS_REQUIRED(critsect_); + void SendPadding(size_t padding_needed) EXCLUSIVE_LOCKS_REQUIRED(critsect_); Clock* const clock_; PacketSender* const packet_sender_; diff --git a/webrtc/modules/pacing/paced_sender_unittest.cc b/webrtc/modules/pacing/paced_sender_unittest.cc index f698555ce3..6a0a006c32 100644 --- a/webrtc/modules/pacing/paced_sender_unittest.cc +++ b/webrtc/modules/pacing/paced_sender_unittest.cc @@ -32,7 +32,8 @@ class MockPacedSenderCallback : public PacedSender::PacketSender { int64_t capture_time_ms, bool retransmission, int probe_cluster_id)); - MOCK_METHOD2(TimeToSendPadding, size_t(size_t bytes, int probe_cluster_id)); + MOCK_METHOD1(TimeToSendPadding, + size_t(size_t bytes)); }; class PacedSenderPadding : public PacedSender::PacketSender { @@ -47,7 +48,7 @@ class PacedSenderPadding : public PacedSender::PacketSender { return true; } - size_t TimeToSendPadding(size_t bytes, int probe_cluster_id) override { + size_t TimeToSendPadding(size_t bytes) override { const size_t kPaddingPacketSize = 224; size_t num_packets = (bytes + kPaddingPacketSize - 1) / kPaddingPacketSize; padding_sent_ += kPaddingPacketSize * num_packets; @@ -77,7 +78,7 @@ class PacedSenderProbing : public PacedSender::PacketSender { return true; } - size_t TimeToSendPadding(size_t bytes, int probe_cluster_id) override { + size_t TimeToSendPadding(size_t bytes) override { ExpectAndCountPacket(); return bytes; } @@ -158,7 +159,7 @@ TEST_F(PacedSenderTest, QueuePacket) { EXPECT_EQ(packets_to_send + 1, send_bucket_->QueueSizePackets()); send_bucket_->Process(); EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess()); - EXPECT_CALL(callback_, TimeToSendPadding(_, _)).Times(0); + EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0); clock_.AdvanceTimeMilliseconds(4); EXPECT_EQ(1, send_bucket_->TimeUntilNextProcess()); clock_.AdvanceTimeMilliseconds(1); @@ -210,7 +211,7 @@ TEST_F(PacedSenderTest, PaceQueuedPackets) { send_bucket_->Process(); EXPECT_EQ(packets_to_send_per_interval * 10, send_bucket_->QueueSizePackets()); - EXPECT_CALL(callback_, TimeToSendPadding(_, _)).Times(0); + EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0); for (int k = 0; k < 10; ++k) { EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess()); clock_.AdvanceTimeMilliseconds(5); @@ -263,7 +264,7 @@ TEST_F(PacedSenderTest, PaceQueuedPacketsWithDuplicates) { sequence_number++, clock_.TimeInMilliseconds(), 250, false); } - EXPECT_CALL(callback_, TimeToSendPadding(_, _)).Times(0); + EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0); send_bucket_->Process(); for (int k = 0; k < 10; ++k) { EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess()); @@ -334,23 +335,22 @@ TEST_F(PacedSenderTest, Padding) { clock_.TimeInMilliseconds(), 250, false); } // No padding is expected since we have sent too much already. - EXPECT_CALL(callback_, TimeToSendPadding(_, _)).Times(0); + EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0); EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess()); send_bucket_->Process(); EXPECT_EQ(0u, send_bucket_->QueueSizePackets()); // 5 milliseconds later should not send padding since we filled the buffers // initially. - EXPECT_CALL(callback_, TimeToSendPadding(250, _)).Times(0); + EXPECT_CALL(callback_, TimeToSendPadding(250)).Times(0); EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess()); clock_.AdvanceTimeMilliseconds(5); EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess()); 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_CALL(callback_, TimeToSendPadding(250)).Times(1). + WillOnce(Return(250)); EXPECT_EQ(5, send_bucket_->TimeUntilNextProcess()); clock_.AdvanceTimeMilliseconds(5); EXPECT_EQ(0, send_bucket_->TimeUntilNextProcess()); @@ -374,9 +374,8 @@ TEST_F(PacedSenderTest, VerifyPaddingUpToBitrate) { capture_time_ms, 250, false); - EXPECT_CALL(callback_, TimeToSendPadding(250, _)) - .Times(1) - .WillOnce(Return(250)); + EXPECT_CALL(callback_, TimeToSendPadding(250)).Times(1). + WillOnce(Return(250)); send_bucket_->Process(); clock_.AdvanceTimeMilliseconds(kTimeStep); } @@ -444,7 +443,7 @@ TEST_F(PacedSenderTest, Priority) { 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_, TimeToSendPadding(_)).Times(0); EXPECT_CALL(callback_, TimeToSendPacket(ssrc, _, capture_time_ms, false, _)) .Times(packets_to_send_per_interval + 1) .WillRepeatedly(Return(true)); @@ -546,7 +545,7 @@ TEST_F(PacedSenderTest, Pause) { send_bucket_->QueueInMs()); // Expect no packet to come out while paused. - EXPECT_CALL(callback_, TimeToSendPadding(_, _)).Times(0); + EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0); EXPECT_CALL(callback_, TimeToSendPacket(_, _, _, _, _)).Times(0); for (int i = 0; i < 10; ++i) { @@ -821,7 +820,7 @@ TEST_F(PacedSenderTest, PaddingOveruse) { clock_.TimeInMilliseconds(), kPacketSize, false); EXPECT_LT(5u, send_bucket_->ExpectedQueueTimeMs()); // Don't send padding if queue is non-empty, even if padding budget > 0. - EXPECT_CALL(callback_, TimeToSendPadding(_, _)).Times(0); + EXPECT_CALL(callback_, TimeToSendPadding(_)).Times(0); send_bucket_->Process(); } @@ -870,7 +869,7 @@ TEST_F(PacedSenderTest, AverageQueueTime) { EXPECT_EQ(0, send_bucket_->AverageQueueTimeMs()); } -TEST_F(PacedSenderTest, DISABLED_ProbeClusterId) { +TEST_F(PacedSenderTest, ProbeClusterId) { uint32_t ssrc = 12346; uint16_t sequence_number = 1234; const size_t kPacketSize = 1200; @@ -897,7 +896,8 @@ TEST_F(PacedSenderTest, DISABLED_ProbeClusterId) { send_bucket_->Process(); // No more probing packets. - EXPECT_CALL(callback_, TimeToSendPadding(_, _)).Times(1); + EXPECT_CALL(callback_, TimeToSendPadding(_)) + .Times(1); send_bucket_->Process(); } diff --git a/webrtc/modules/pacing/packet_router.cc b/webrtc/modules/pacing/packet_router.cc index be45615ca5..1884958aca 100644 --- a/webrtc/modules/pacing/packet_router.cc +++ b/webrtc/modules/pacing/packet_router.cc @@ -50,22 +50,20 @@ bool PacketRouter::TimeToSendPacket(uint32_t ssrc, for (auto* rtp_module : rtp_modules_) { if (rtp_module->SendingMedia() && ssrc == rtp_module->SSRC()) { return rtp_module->TimeToSendPacket(ssrc, sequence_number, - capture_timestamp, retransmission, - probe_cluster_id); + capture_timestamp, retransmission); } } return true; } -size_t PacketRouter::TimeToSendPadding(size_t bytes_to_send, - int probe_cluster_id) { +size_t PacketRouter::TimeToSendPadding(size_t bytes_to_send) { RTC_DCHECK(pacer_thread_checker_.CalledOnValidThread()); size_t total_bytes_sent = 0; rtc::CritScope cs(&modules_crit_); for (RtpRtcp* module : rtp_modules_) { if (module->SendingMedia()) { - size_t bytes_sent = module->TimeToSendPadding( - bytes_to_send - total_bytes_sent, probe_cluster_id); + size_t bytes_sent = + module->TimeToSendPadding(bytes_to_send - total_bytes_sent); total_bytes_sent += bytes_sent; if (total_bytes_sent >= bytes_to_send) break; diff --git a/webrtc/modules/pacing/packet_router.h b/webrtc/modules/pacing/packet_router.h index 95d630ace4..81d85404ee 100644 --- a/webrtc/modules/pacing/packet_router.h +++ b/webrtc/modules/pacing/packet_router.h @@ -46,7 +46,7 @@ class PacketRouter : public PacedSender::PacketSender, bool retransmission, int probe_cluster_id) override; - size_t TimeToSendPadding(size_t bytes, int probe_cluster_id) override; + size_t TimeToSendPadding(size_t bytes) override; void SetTransportWideSequenceNumber(uint16_t sequence_number); uint16_t AllocateSequenceNumber() override; diff --git a/webrtc/modules/pacing/packet_router_unittest.cc b/webrtc/modules/pacing/packet_router_unittest.cc index 5c1654e6d0..006b9f2bf4 100644 --- a/webrtc/modules/pacing/packet_router_unittest.cc +++ b/webrtc/modules/pacing/packet_router_unittest.cc @@ -48,12 +48,12 @@ TEST_F(PacketRouterTest, TimeToSendPacket) { EXPECT_CALL(rtp_1, SendingMedia()).Times(1).WillOnce(Return(true)); EXPECT_CALL(rtp_1, SSRC()).Times(1).WillOnce(Return(kSsrc1)); EXPECT_CALL(rtp_1, TimeToSendPacket(kSsrc1, sequence_number, timestamp, - retransmission, 1)) + retransmission)) .Times(1) .WillOnce(Return(true)); - EXPECT_CALL(rtp_2, TimeToSendPacket(_, _, _, _, _)).Times(0); + EXPECT_CALL(rtp_2, TimeToSendPacket(_, _, _, _)).Times(0); EXPECT_TRUE(packet_router_->TimeToSendPacket(kSsrc1, sequence_number, - timestamp, retransmission, 1)); + timestamp, retransmission, -1)); // Send on the second module by letting rtp_2 be sending, but not rtp_1. ++sequence_number; @@ -63,31 +63,31 @@ TEST_F(PacketRouterTest, TimeToSendPacket) { EXPECT_CALL(rtp_1, SendingMedia()).Times(1).WillOnce(Return(false)); EXPECT_CALL(rtp_2, SendingMedia()).Times(1).WillOnce(Return(true)); EXPECT_CALL(rtp_2, SSRC()).Times(1).WillOnce(Return(kSsrc2)); - EXPECT_CALL(rtp_1, TimeToSendPacket(_, _, _, _, _)).Times(0); + EXPECT_CALL(rtp_1, TimeToSendPacket(_, _, _, _)).Times(0); EXPECT_CALL(rtp_2, TimeToSendPacket(kSsrc2, sequence_number, timestamp, - retransmission, 2)) + retransmission)) .Times(1) .WillOnce(Return(true)); EXPECT_TRUE(packet_router_->TimeToSendPacket(kSsrc2, sequence_number, - timestamp, retransmission, 2)); + timestamp, retransmission, -1)); // No module is sending, hence no packet should be sent. EXPECT_CALL(rtp_1, SendingMedia()).Times(1).WillOnce(Return(false)); - EXPECT_CALL(rtp_1, TimeToSendPacket(_, _, _, _, _)).Times(0); + EXPECT_CALL(rtp_1, TimeToSendPacket(_, _, _, _)).Times(0); EXPECT_CALL(rtp_2, SendingMedia()).Times(1).WillOnce(Return(false)); - EXPECT_CALL(rtp_2, TimeToSendPacket(_, _, _, _, _)).Times(0); + EXPECT_CALL(rtp_2, TimeToSendPacket(_, _, _, _)).Times(0); EXPECT_TRUE(packet_router_->TimeToSendPacket(kSsrc1, sequence_number, - timestamp, retransmission, 1)); + timestamp, retransmission, -1)); // Add a packet with incorrect ssrc and test it's dropped in the router. EXPECT_CALL(rtp_1, SendingMedia()).Times(1).WillOnce(Return(true)); EXPECT_CALL(rtp_1, SSRC()).Times(1).WillOnce(Return(kSsrc1)); EXPECT_CALL(rtp_2, SendingMedia()).Times(1).WillOnce(Return(true)); EXPECT_CALL(rtp_2, SSRC()).Times(1).WillOnce(Return(kSsrc2)); - EXPECT_CALL(rtp_1, TimeToSendPacket(_, _, _, _, _)).Times(0); - EXPECT_CALL(rtp_2, TimeToSendPacket(_, _, _, _, _)).Times(0); + EXPECT_CALL(rtp_1, TimeToSendPacket(_, _, _, _)).Times(0); + EXPECT_CALL(rtp_2, TimeToSendPacket(_, _, _, _)).Times(0); EXPECT_TRUE(packet_router_->TimeToSendPacket(kSsrc1 + kSsrc2, sequence_number, - timestamp, retransmission, 1)); + timestamp, retransmission, -1)); packet_router_->RemoveRtpModule(&rtp_1); @@ -95,10 +95,9 @@ TEST_F(PacketRouterTest, TimeToSendPacket) { // it is dropped as expected by not expecting any calls to rtp_1. EXPECT_CALL(rtp_2, SendingMedia()).Times(1).WillOnce(Return(true)); EXPECT_CALL(rtp_2, SSRC()).Times(1).WillOnce(Return(kSsrc2)); - EXPECT_CALL(rtp_2, TimeToSendPacket(_, _, _, _, _)).Times(0); + EXPECT_CALL(rtp_2, TimeToSendPacket(_, _, _, _)).Times(0); EXPECT_TRUE(packet_router_->TimeToSendPacket(kSsrc1, sequence_number, - timestamp, retransmission, - PacketInfo::kNotAProbe)); + timestamp, retransmission, -1)); packet_router_->RemoveRtpModule(&rtp_2); } @@ -119,45 +118,42 @@ TEST_F(PacketRouterTest, TimeToSendPadding) { const size_t requested_padding_bytes = 1000; const size_t sent_padding_bytes = 890; EXPECT_CALL(rtp_1, SendingMedia()).Times(1).WillOnce(Return(true)); - EXPECT_CALL(rtp_1, TimeToSendPadding(requested_padding_bytes, 111)) + EXPECT_CALL(rtp_1, TimeToSendPadding(requested_padding_bytes)) .Times(1) .WillOnce(Return(sent_padding_bytes)); EXPECT_CALL(rtp_2, SendingMedia()).Times(1).WillOnce(Return(true)); - EXPECT_CALL(rtp_2, TimeToSendPadding( - requested_padding_bytes - sent_padding_bytes, 111)) + EXPECT_CALL(rtp_2, + TimeToSendPadding(requested_padding_bytes - sent_padding_bytes)) .Times(1) .WillOnce(Return(requested_padding_bytes - sent_padding_bytes)); EXPECT_EQ(requested_padding_bytes, - packet_router_->TimeToSendPadding(requested_padding_bytes, 111)); + packet_router_->TimeToSendPadding(requested_padding_bytes)); // Let only the second module be sending and verify the padding request is // routed there. EXPECT_CALL(rtp_1, SendingMedia()).Times(1).WillOnce(Return(false)); - EXPECT_CALL(rtp_1, TimeToSendPadding(requested_padding_bytes, _)).Times(0); + EXPECT_CALL(rtp_1, TimeToSendPadding(requested_padding_bytes)).Times(0); EXPECT_CALL(rtp_2, SendingMedia()).Times(1).WillOnce(Return(true)); - EXPECT_CALL(rtp_2, TimeToSendPadding(_, _)) + EXPECT_CALL(rtp_2, TimeToSendPadding(_)) .Times(1) .WillOnce(Return(sent_padding_bytes)); EXPECT_EQ(sent_padding_bytes, - packet_router_->TimeToSendPadding(requested_padding_bytes, - PacketInfo::kNotAProbe)); + packet_router_->TimeToSendPadding(requested_padding_bytes)); // No sending module at all. EXPECT_CALL(rtp_1, SendingMedia()).Times(1).WillOnce(Return(false)); - EXPECT_CALL(rtp_1, TimeToSendPadding(requested_padding_bytes, _)).Times(0); + EXPECT_CALL(rtp_1, TimeToSendPadding(requested_padding_bytes)).Times(0); EXPECT_CALL(rtp_2, SendingMedia()).Times(1).WillOnce(Return(false)); - EXPECT_CALL(rtp_2, TimeToSendPadding(_, _)).Times(0); - EXPECT_EQ(0u, packet_router_->TimeToSendPadding(requested_padding_bytes, - PacketInfo::kNotAProbe)); + EXPECT_CALL(rtp_2, TimeToSendPadding(_)).Times(0); + EXPECT_EQ(0u, packet_router_->TimeToSendPadding(requested_padding_bytes)); packet_router_->RemoveRtpModule(&rtp_1); // rtp_1 has been removed, try sending padding and make sure rtp_1 isn't asked // to send by not expecting any calls. Instead verify rtp_2 is called. EXPECT_CALL(rtp_2, SendingMedia()).Times(1).WillOnce(Return(true)); - EXPECT_CALL(rtp_2, TimeToSendPadding(requested_padding_bytes, _)).Times(1); - EXPECT_EQ(0u, packet_router_->TimeToSendPadding(requested_padding_bytes, - PacketInfo::kNotAProbe)); + EXPECT_CALL(rtp_2, TimeToSendPadding(requested_padding_bytes)).Times(1); + EXPECT_EQ(0u, packet_router_->TimeToSendPadding(requested_padding_bytes)); packet_router_->RemoveRtpModule(&rtp_2); } @@ -170,12 +166,11 @@ TEST_F(PacketRouterTest, SenderOnlyFunctionsRespectSendingMedia) { EXPECT_CALL(rtp, SendingMedia()).WillRepeatedly(Return(false)); // Verify that TimeToSendPacket does not end up in a receiver. - EXPECT_CALL(rtp, TimeToSendPacket(_, _, _, _, _)).Times(0); - EXPECT_TRUE(packet_router_->TimeToSendPacket(kSsrc, 1, 1, false, - PacketInfo::kNotAProbe)); + EXPECT_CALL(rtp, TimeToSendPacket(_, _, _, _)).Times(0); + EXPECT_TRUE(packet_router_->TimeToSendPacket(kSsrc, 1, 1, false, -1)); // Verify that TimeToSendPadding does not end up in a receiver. - EXPECT_CALL(rtp, TimeToSendPadding(_, _)).Times(0); - EXPECT_EQ(0u, packet_router_->TimeToSendPadding(200, PacketInfo::kNotAProbe)); + EXPECT_CALL(rtp, TimeToSendPadding(_)).Times(0); + EXPECT_EQ(0u, packet_router_->TimeToSendPadding(200)); packet_router_->RemoveRtpModule(&rtp); } diff --git a/webrtc/modules/remote_bitrate_estimator/include/send_time_history.h b/webrtc/modules/remote_bitrate_estimator/include/send_time_history.h index a50faf6712..a643c1f103 100644 --- a/webrtc/modules/remote_bitrate_estimator/include/send_time_history.h +++ b/webrtc/modules/remote_bitrate_estimator/include/send_time_history.h @@ -24,10 +24,7 @@ class SendTimeHistory { SendTimeHistory(Clock* clock, int64_t packet_age_limit); virtual ~SendTimeHistory(); - void AddAndRemoveOld(uint16_t sequence_number, - size_t length, - bool was_paced, - int probe_cluster_id); + void AddAndRemoveOld(uint16_t sequence_number, size_t length, bool was_paced); bool OnSentPacket(uint16_t sequence_number, int64_t timestamp); // Look up PacketInfo for a sent packet, based on the sequence number, and // populate all fields except for receive_time. The packet parameter must diff --git a/webrtc/modules/remote_bitrate_estimator/send_time_history.cc b/webrtc/modules/remote_bitrate_estimator/send_time_history.cc index 674028e9c8..a58d12a160 100644 --- a/webrtc/modules/remote_bitrate_estimator/send_time_history.cc +++ b/webrtc/modules/remote_bitrate_estimator/send_time_history.cc @@ -28,17 +28,15 @@ void SendTimeHistory::Clear() { void SendTimeHistory::AddAndRemoveOld(uint16_t sequence_number, size_t length, - bool was_paced, - int probe_cluster_id) { + bool was_paced) { EraseOld(); if (history_.empty()) oldest_sequence_number_ = sequence_number; history_.insert(std::pair( - sequence_number, - PacketInfo(clock_->TimeInMilliseconds(), 0, -1, sequence_number, length, - was_paced, probe_cluster_id))); + sequence_number, PacketInfo(clock_->TimeInMilliseconds(), 0, -1, + sequence_number, length, was_paced))); } bool SendTimeHistory::OnSentPacket(uint16_t sequence_number, diff --git a/webrtc/modules/remote_bitrate_estimator/send_time_history_unittest.cc b/webrtc/modules/remote_bitrate_estimator/send_time_history_unittest.cc index 227391a3f4..b525813cdc 100644 --- a/webrtc/modules/remote_bitrate_estimator/send_time_history_unittest.cc +++ b/webrtc/modules/remote_bitrate_estimator/send_time_history_unittest.cc @@ -34,10 +34,8 @@ class SendTimeHistoryTest : public ::testing::Test { void AddPacketWithSendTime(uint16_t sequence_number, size_t length, bool was_paced, - int64_t send_time_ms, - int probe_cluster_id) { - history_.AddAndRemoveOld(sequence_number, length, was_paced, - probe_cluster_id); + int64_t send_time_ms) { + history_.AddAndRemoveOld(sequence_number, length, was_paced); history_.OnSentPacket(sequence_number, send_time_ms); } @@ -48,58 +46,42 @@ class SendTimeHistoryTest : public ::testing::Test { // Help class extended so we can do EXPECT_EQ and collections. class PacketInfo : public webrtc::PacketInfo { public: - PacketInfo() - : webrtc::PacketInfo(-1, - 0, - 0, - 0, - 0, - false, - webrtc::PacketInfo::kNotAProbe) {} + PacketInfo() : webrtc::PacketInfo(-1, 0, 0, 0, 0, false) {} PacketInfo(int64_t arrival_time_ms, uint16_t sequence_number) - : PacketInfo(arrival_time_ms, - 0, - sequence_number, - 0, - false, - PacketInfo::kNotAProbe) {} + : PacketInfo(arrival_time_ms, 0, sequence_number, 0, false) {} PacketInfo(int64_t arrival_time_ms, int64_t send_time_ms, uint16_t sequence_number, size_t payload_size, - bool was_paced, - int probe_cluster_id) + bool was_paced) : webrtc::PacketInfo(-1, arrival_time_ms, send_time_ms, sequence_number, payload_size, - was_paced, - probe_cluster_id) {} + was_paced) {} bool operator==(const PacketInfo& other) const { return arrival_time_ms == other.arrival_time_ms && send_time_ms == other.send_time_ms && sequence_number == other.sequence_number && - payload_size == other.payload_size && was_paced == other.was_paced && - probe_cluster_id == other.probe_cluster_id; + payload_size == other.payload_size && was_paced == other.was_paced; } }; TEST_F(SendTimeHistoryTest, AddRemoveOne) { const uint16_t kSeqNo = 10; - const int kProbeClusterId = 0; - const PacketInfo kSentPacket(0, 1, kSeqNo, 1, true, kProbeClusterId); - AddPacketWithSendTime(kSeqNo, 1, true, 1, kProbeClusterId); + const PacketInfo kSentPacket(0, 1, kSeqNo, 1, true); + AddPacketWithSendTime(kSeqNo, 1, true, 1); - PacketInfo received_packet(0, 0, kSeqNo, 0, false, kProbeClusterId); + PacketInfo received_packet(0, 0, kSeqNo, 0, false); EXPECT_TRUE(history_.GetInfo(&received_packet, false)); EXPECT_EQ(kSentPacket, received_packet); - PacketInfo received_packet2(0, 0, kSeqNo, 0, false, kProbeClusterId); + PacketInfo received_packet2(0, 0, kSeqNo, 0, false); EXPECT_TRUE(history_.GetInfo(&received_packet2, true)); EXPECT_EQ(kSentPacket, received_packet2); - PacketInfo received_packet3(0, 0, kSeqNo, 0, false, kProbeClusterId); + PacketInfo received_packet3(0, 0, kSeqNo, 0, false); EXPECT_FALSE(history_.GetInfo(&received_packet3, true)); } @@ -110,8 +92,7 @@ TEST_F(SendTimeHistoryTest, PopulatesExpectedFields) { const size_t kPayloadSize = 42; const bool kPaced = true; - AddPacketWithSendTime(kSeqNo, kPayloadSize, kPaced, kSendTime, - PacketInfo::kNotAProbe); + AddPacketWithSendTime(kSeqNo, kPayloadSize, kPaced, kSendTime); PacketInfo info(kReceiveTime, kSeqNo); EXPECT_TRUE(history_.GetInfo(&info, true)); @@ -129,19 +110,18 @@ TEST_F(SendTimeHistoryTest, AddThenRemoveOutOfOrder) { const size_t kPacketSize = 400; const size_t kTransmissionTime = 1234; const bool kPaced = true; - const int kProbeClusterId = 1; for (size_t i = 0; i < num_items; ++i) { sent_packets.push_back(PacketInfo(0, static_cast(i), static_cast(i), kPacketSize, - kPaced, kProbeClusterId)); - received_packets.push_back(PacketInfo( - static_cast(i) + kTransmissionTime, 0, - static_cast(i), kPacketSize, false, PacketInfo::kNotAProbe)); + kPaced)); + received_packets.push_back( + PacketInfo(static_cast(i) + kTransmissionTime, 0, + static_cast(i), kPacketSize, false)); } for (size_t i = 0; i < num_items; ++i) { - history_.AddAndRemoveOld( - sent_packets[i].sequence_number, sent_packets[i].payload_size, - sent_packets[i].was_paced, sent_packets[i].probe_cluster_id); + history_.AddAndRemoveOld(sent_packets[i].sequence_number, + sent_packets[i].payload_size, + sent_packets[i].was_paced); } for (size_t i = 0; i < num_items; ++i) history_.OnSentPacket(sent_packets[i].sequence_number, @@ -163,21 +143,19 @@ TEST_F(SendTimeHistoryTest, HistorySize) { const int kItems = kDefaultHistoryLengthMs / 100; for (int i = 0; i < kItems; ++i) { clock_.AdvanceTimeMilliseconds(100); - AddPacketWithSendTime(i, 0, false, i * 100, PacketInfo::kNotAProbe); + AddPacketWithSendTime(i, 0, false, i * 100); } for (int i = 0; i < kItems; ++i) { - PacketInfo info(0, 0, static_cast(i), 0, false, - PacketInfo::kNotAProbe); + PacketInfo info(0, 0, static_cast(i), 0, false); EXPECT_TRUE(history_.GetInfo(&info, false)); EXPECT_EQ(i * 100, info.send_time_ms); } clock_.AdvanceTimeMilliseconds(101); - AddPacketWithSendTime(kItems, 0, false, kItems * 101, PacketInfo::kNotAProbe); - PacketInfo info(0, 0, 0, 0, false, PacketInfo::kNotAProbe); + AddPacketWithSendTime(kItems, 0, false, kItems * 101); + PacketInfo info(0, 0, 0, 0, false); EXPECT_FALSE(history_.GetInfo(&info, false)); for (int i = 1; i < (kItems + 1); ++i) { - PacketInfo info2(0, 0, static_cast(i), 0, false, - PacketInfo::kNotAProbe); + PacketInfo info2(0, 0, static_cast(i), 0, false); EXPECT_TRUE(history_.GetInfo(&info2, false)); int64_t expected_time_ms = (i == kItems) ? i * 101 : i * 100; EXPECT_EQ(expected_time_ms, info2.send_time_ms); @@ -186,17 +164,16 @@ TEST_F(SendTimeHistoryTest, HistorySize) { TEST_F(SendTimeHistoryTest, HistorySizeWithWraparound) { const uint16_t kMaxSeqNo = std::numeric_limits::max(); - AddPacketWithSendTime(kMaxSeqNo - 2, 0, false, 0, PacketInfo::kNotAProbe); + AddPacketWithSendTime(kMaxSeqNo - 2, 0, false, 0); clock_.AdvanceTimeMilliseconds(100); - AddPacketWithSendTime(kMaxSeqNo - 1, 1, false, 100, PacketInfo::kNotAProbe); + AddPacketWithSendTime(kMaxSeqNo - 1, 1, false, 100); clock_.AdvanceTimeMilliseconds(100); - AddPacketWithSendTime(kMaxSeqNo, 0, false, 200, PacketInfo::kNotAProbe); + AddPacketWithSendTime(kMaxSeqNo, 0, false, 200); clock_.AdvanceTimeMilliseconds(kDefaultHistoryLengthMs - 200 + 1); - AddPacketWithSendTime(0, 0, false, kDefaultHistoryLengthMs, - PacketInfo::kNotAProbe); + AddPacketWithSendTime(0, 0, false, kDefaultHistoryLengthMs); PacketInfo info(0, static_cast(kMaxSeqNo - 2)); EXPECT_FALSE(history_.GetInfo(&info, false)); @@ -212,7 +189,7 @@ TEST_F(SendTimeHistoryTest, HistorySizeWithWraparound) { EXPECT_TRUE(history_.GetInfo(&info5, true)); clock_.AdvanceTimeMilliseconds(100); - AddPacketWithSendTime(1, 0, false, 1100, PacketInfo::kNotAProbe); + AddPacketWithSendTime(1, 0, false, 1100); PacketInfo info6(0, static_cast(kMaxSeqNo - 2)); EXPECT_FALSE(history_.GetInfo(&info6, false)); @@ -229,26 +206,26 @@ TEST_F(SendTimeHistoryTest, HistorySizeWithWraparound) { TEST_F(SendTimeHistoryTest, InterlievedGetAndRemove) { const uint16_t kSeqNo = 1; const int64_t kTimestamp = 2; - PacketInfo packets[3] = {{0, kTimestamp, kSeqNo, 0, false, 0}, - {0, kTimestamp + 1, kSeqNo + 1, 0, false, 1}, - {0, kTimestamp + 2, kSeqNo + 2, 0, false, 2}}; + PacketInfo packets[3] = {{0, kTimestamp, kSeqNo, 0, false}, + {0, kTimestamp + 1, kSeqNo + 1, 0, false}, + {0, kTimestamp + 2, kSeqNo + 2, 0, false}}; AddPacketWithSendTime(packets[0].sequence_number, packets[0].payload_size, - packets[0].was_paced, packets[0].send_time_ms, 0); + packets[0].was_paced, packets[0].send_time_ms); AddPacketWithSendTime(packets[1].sequence_number, packets[1].payload_size, - packets[1].was_paced, packets[1].send_time_ms, 1); - PacketInfo info(0, 0, packets[0].sequence_number, 0, false, 0); + packets[1].was_paced, packets[1].send_time_ms); + PacketInfo info(0, 0, packets[0].sequence_number, 0, false); EXPECT_TRUE(history_.GetInfo(&info, true)); EXPECT_EQ(packets[0], info); AddPacketWithSendTime(packets[2].sequence_number, packets[2].payload_size, - packets[2].was_paced, packets[2].send_time_ms, 2); + packets[2].was_paced, packets[2].send_time_ms); - PacketInfo info2(0, 0, packets[1].sequence_number, 0, false, 1); + PacketInfo info2(0, 0, packets[1].sequence_number, 0, false); EXPECT_TRUE(history_.GetInfo(&info2, true)); EXPECT_EQ(packets[1], info2); - PacketInfo info3(0, 0, packets[2].sequence_number, 0, false, 2); + PacketInfo info3(0, 0, packets[2].sequence_number, 0, false); EXPECT_TRUE(history_.GetInfo(&info3, true)); EXPECT_EQ(packets[2], info3); } diff --git a/webrtc/modules/remote_bitrate_estimator/test/estimators/send_side.cc b/webrtc/modules/remote_bitrate_estimator/test/estimators/send_side.cc index 111521ea2e..3cf7c752a0 100644 --- a/webrtc/modules/remote_bitrate_estimator/test/estimators/send_side.cc +++ b/webrtc/modules/remote_bitrate_estimator/test/estimators/send_side.cc @@ -92,11 +92,9 @@ void FullBweSender::OnPacketsSent(const Packets& packets) { for (Packet* packet : packets) { if (packet->GetPacketType() == Packet::kMedia) { MediaPacket* media_packet = static_cast(packet); - // TODO(philipel): Add probe_cluster_id to Packet class in order - // to create tests for probing using cluster ids. - send_time_history_.AddAndRemoveOld( - media_packet->header().sequenceNumber, media_packet->payload_size(), - packet->paced(), PacketInfo::kNotAProbe); + send_time_history_.AddAndRemoveOld(media_packet->header().sequenceNumber, + media_packet->payload_size(), + packet->paced()); send_time_history_.OnSentPacket(media_packet->header().sequenceNumber, media_packet->sender_timestamp_ms()); } diff --git a/webrtc/modules/remote_bitrate_estimator/test/packet_sender.cc b/webrtc/modules/remote_bitrate_estimator/test/packet_sender.cc index 2f3c2d20d3..8767b93347 100644 --- a/webrtc/modules/remote_bitrate_estimator/test/packet_sender.cc +++ b/webrtc/modules/remote_bitrate_estimator/test/packet_sender.cc @@ -299,7 +299,7 @@ bool PacedVideoSender::TimeToSendPacket(uint32_t ssrc, return false; } -size_t PacedVideoSender::TimeToSendPadding(size_t bytes, int probe_cluster_id) { +size_t PacedVideoSender::TimeToSendPadding(size_t bytes) { return 0; } diff --git a/webrtc/modules/remote_bitrate_estimator/test/packet_sender.h b/webrtc/modules/remote_bitrate_estimator/test/packet_sender.h index 0fccb6f1d4..4990574bde 100644 --- a/webrtc/modules/remote_bitrate_estimator/test/packet_sender.h +++ b/webrtc/modules/remote_bitrate_estimator/test/packet_sender.h @@ -115,7 +115,7 @@ class PacedVideoSender : public VideoSender, public PacedSender::PacketSender { int64_t capture_time_ms, bool retransmission, int probe_cluster_id) override; - size_t TimeToSendPadding(size_t bytes, int probe_cluster_id) override; + size_t TimeToSendPadding(size_t bytes) override; // Implements BitrateObserver. void OnNetworkChanged(uint32_t target_bitrate_bps, diff --git a/webrtc/modules/remote_bitrate_estimator/transport_feedback_adapter.cc b/webrtc/modules/remote_bitrate_estimator/transport_feedback_adapter.cc index 18e3c0cbd1..ed8b6e6d3a 100644 --- a/webrtc/modules/remote_bitrate_estimator/transport_feedback_adapter.cc +++ b/webrtc/modules/remote_bitrate_estimator/transport_feedback_adapter.cc @@ -59,11 +59,9 @@ void TransportFeedbackAdapter::SetBitrateEstimator( void TransportFeedbackAdapter::AddPacket(uint16_t sequence_number, size_t length, - bool was_paced, - int probe_cluster_id) { + bool was_paced) { rtc::CritScope cs(&lock_); - send_time_history_.AddAndRemoveOld(sequence_number, length, was_paced, - probe_cluster_id); + send_time_history_.AddAndRemoveOld(sequence_number, length, was_paced); } void TransportFeedbackAdapter::OnSentPacket(uint16_t sequence_number, diff --git a/webrtc/modules/remote_bitrate_estimator/transport_feedback_adapter.h b/webrtc/modules/remote_bitrate_estimator/transport_feedback_adapter.h index 384a64f7c6..c97ef57cf0 100644 --- a/webrtc/modules/remote_bitrate_estimator/transport_feedback_adapter.h +++ b/webrtc/modules/remote_bitrate_estimator/transport_feedback_adapter.h @@ -40,8 +40,7 @@ class TransportFeedbackAdapter : public TransportFeedbackObserver, // Implements TransportFeedbackObserver. void AddPacket(uint16_t sequence_number, size_t length, - bool was_paced, - int probe_cluster_id) override; + bool was_paced) override; void OnSentPacket(uint16_t sequence_number, int64_t send_time_ms); void OnTransportFeedback(const rtcp::TransportFeedback& feedback) override; diff --git a/webrtc/modules/remote_bitrate_estimator/transport_feedback_adapter_unittest.cc b/webrtc/modules/remote_bitrate_estimator/transport_feedback_adapter_unittest.cc index 1e99e5146a..4f7d83c9eb 100644 --- a/webrtc/modules/remote_bitrate_estimator/transport_feedback_adapter_unittest.cc +++ b/webrtc/modules/remote_bitrate_estimator/transport_feedback_adapter_unittest.cc @@ -93,15 +93,14 @@ class TransportFeedbackAdapterTest : public ::testing::Test { EXPECT_EQ(truth[i].sequence_number, input[i].sequence_number); EXPECT_EQ(truth[i].payload_size, input[i].payload_size); EXPECT_EQ(truth[i].was_paced, input[i].was_paced); - EXPECT_EQ(truth[i].probe_cluster_id, input[i].probe_cluster_id); } } // Utility method, to reset arrival_time_ms before adding send time. void OnSentPacket(PacketInfo info) { info.arrival_time_ms = 0; - adapter_->AddPacket(info.sequence_number, info.payload_size, info.was_paced, - info.probe_cluster_id); + adapter_->AddPacket(info.sequence_number, info.payload_size, + info.was_paced); adapter_->OnSentPacket(info.sequence_number, info.send_time_ms); } @@ -115,11 +114,11 @@ class TransportFeedbackAdapterTest : public ::testing::Test { TEST_F(TransportFeedbackAdapterTest, AdaptsFeedbackAndPopulatesSendTimes) { std::vector packets; - packets.push_back(PacketInfo(100, 200, 0, 1500, true, 0)); - packets.push_back(PacketInfo(110, 210, 1, 1500, true, 0)); - packets.push_back(PacketInfo(120, 220, 2, 1500, true, 0)); - packets.push_back(PacketInfo(130, 230, 3, 1500, true, 1)); - packets.push_back(PacketInfo(140, 240, 4, 1500, true, 1)); + packets.push_back(PacketInfo(100, 200, 0, 1500, true)); + packets.push_back(PacketInfo(110, 210, 1, 1500, true)); + packets.push_back(PacketInfo(120, 220, 2, 1500, true)); + packets.push_back(PacketInfo(130, 230, 3, 1500, true)); + packets.push_back(PacketInfo(140, 240, 4, 1500, true)); for (const PacketInfo& packet : packets) OnSentPacket(packet); @@ -146,11 +145,11 @@ TEST_F(TransportFeedbackAdapterTest, AdaptsFeedbackAndPopulatesSendTimes) { TEST_F(TransportFeedbackAdapterTest, HandlesDroppedPackets) { std::vector packets; - packets.push_back(PacketInfo(100, 200, 0, 1500, true, 1)); - packets.push_back(PacketInfo(110, 210, 1, 1500, true, 2)); - packets.push_back(PacketInfo(120, 220, 2, 1500, true, 3)); - packets.push_back(PacketInfo(130, 230, 3, 1500, true, 4)); - packets.push_back(PacketInfo(140, 240, 4, 1500, true, 5)); + packets.push_back(PacketInfo(100, 200, 0, 1500, true)); + packets.push_back(PacketInfo(110, 210, 1, 1500, true)); + packets.push_back(PacketInfo(120, 220, 2, 1500, true)); + packets.push_back(PacketInfo(130, 230, 3, 1500, true)); + packets.push_back(PacketInfo(140, 240, 4, 1500, true)); const uint16_t kSendSideDropBefore = 1; const uint16_t kReceiveSideDropAfter = 3; @@ -191,12 +190,9 @@ TEST_F(TransportFeedbackAdapterTest, SendTimeWrapsBothWays) { static_cast(1 << 8) * static_cast((1 << 23) - 1) / 1000; std::vector packets; - packets.push_back(PacketInfo(kHighArrivalTimeMs - 64, 200, 0, 1500, true, - PacketInfo::kNotAProbe)); - packets.push_back(PacketInfo(kHighArrivalTimeMs + 64, 210, 1, 1500, true, - PacketInfo::kNotAProbe)); - packets.push_back(PacketInfo(kHighArrivalTimeMs, 220, 2, 1500, true, - PacketInfo::kNotAProbe)); + packets.push_back(PacketInfo(kHighArrivalTimeMs - 64, 200, 0, 1500, true)); + packets.push_back(PacketInfo(kHighArrivalTimeMs + 64, 210, 1, 1500, true)); + packets.push_back(PacketInfo(kHighArrivalTimeMs, 220, 2, 1500, true)); for (const PacketInfo& packet : packets) OnSentPacket(packet); @@ -229,9 +225,9 @@ TEST_F(TransportFeedbackAdapterTest, SendTimeWrapsBothWays) { TEST_F(TransportFeedbackAdapterTest, HandlesReordering) { std::vector packets; - packets.push_back(PacketInfo(120, 200, 0, 1500, true, 0)); - packets.push_back(PacketInfo(110, 210, 1, 1500, true, 0)); - packets.push_back(PacketInfo(100, 220, 2, 1500, true, 0)); + packets.push_back(PacketInfo(120, 200, 0, 1500, true)); + packets.push_back(PacketInfo(110, 210, 1, 1500, true)); + packets.push_back(PacketInfo(100, 220, 2, 1500, true)); std::vector expected_packets; expected_packets.push_back(packets[2]); expected_packets.push_back(packets[1]); @@ -271,7 +267,7 @@ TEST_F(TransportFeedbackAdapterTest, TimestampDeltas) { rtcp::TransportFeedback::kDeltaScaleFactor * std::numeric_limits::min(); - PacketInfo info(100, 200, 0, 1500, true, PacketInfo::kNotAProbe); + PacketInfo info(100, 200, 0, 1500, true); sent_packets.push_back(info); info.send_time_ms += kSmallDeltaUs / 1000; diff --git a/webrtc/modules/rtp_rtcp/include/rtp_rtcp.h b/webrtc/modules/rtp_rtcp/include/rtp_rtcp.h index 0dd3a89bd7..66589888bd 100644 --- a/webrtc/modules/rtp_rtcp/include/rtp_rtcp.h +++ b/webrtc/modules/rtp_rtcp/include/rtp_rtcp.h @@ -315,10 +315,9 @@ class RtpRtcp : public Module { virtual bool TimeToSendPacket(uint32_t ssrc, uint16_t sequence_number, int64_t capture_time_ms, - bool retransmission, - int probe_cluster_id) = 0; + bool retransmission) = 0; - virtual size_t TimeToSendPadding(size_t bytes, int probe_cluster_id) = 0; + virtual size_t TimeToSendPadding(size_t bytes) = 0; // Called on generation of new statistics after an RTP send. virtual void RegisterSendChannelRtpStatisticsCallback( diff --git a/webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h b/webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h index 79e767765d..282483b095 100644 --- a/webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h +++ b/webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h @@ -245,44 +245,32 @@ class RtcpBandwidthObserver { struct PacketInfo { PacketInfo(int64_t arrival_time_ms, uint16_t sequence_number) - : PacketInfo(-1, - arrival_time_ms, - -1, - sequence_number, - 0, - false, - kNotAProbe) {} + : PacketInfo(-1, arrival_time_ms, -1, sequence_number, 0, false) {} PacketInfo(int64_t arrival_time_ms, int64_t send_time_ms, uint16_t sequence_number, size_t payload_size, - bool was_paced, - int probe_cluster_id) + bool was_paced) : PacketInfo(-1, arrival_time_ms, send_time_ms, sequence_number, payload_size, - was_paced, - probe_cluster_id) {} + was_paced) {} PacketInfo(int64_t creation_time_ms, int64_t arrival_time_ms, int64_t send_time_ms, uint16_t sequence_number, size_t payload_size, - bool was_paced, - int probe_cluster_id) + bool was_paced) : creation_time_ms(creation_time_ms), arrival_time_ms(arrival_time_ms), send_time_ms(send_time_ms), sequence_number(sequence_number), payload_size(payload_size), - was_paced(was_paced), - probe_cluster_id(probe_cluster_id) {} - - static constexpr int kNotAProbe = -1; + was_paced(was_paced) {} // Time corresponding to when this object was created. int64_t creation_time_ms; @@ -299,8 +287,6 @@ struct PacketInfo { size_t payload_size; // True if the packet was paced out by the pacer. bool was_paced; - // Which probing cluster this packets belongs to. - int probe_cluster_id; }; class TransportFeedbackObserver { @@ -312,8 +298,7 @@ class TransportFeedbackObserver { // must be set to 0. virtual void AddPacket(uint16_t sequence_number, size_t length, - bool was_paced, - int probe_cluster_id) = 0; + bool was_paced) = 0; virtual void OnTransportFeedback(const rtcp::TransportFeedback& feedback) = 0; }; diff --git a/webrtc/modules/rtp_rtcp/mocks/mock_rtp_rtcp.h b/webrtc/modules/rtp_rtcp/mocks/mock_rtp_rtcp.h index 8efa56c275..bf5e936921 100644 --- a/webrtc/modules/rtp_rtcp/mocks/mock_rtp_rtcp.h +++ b/webrtc/modules/rtp_rtcp/mocks/mock_rtp_rtcp.h @@ -131,13 +131,11 @@ class MockRtpRtcp : public RtpRtcp { const size_t payloadSize, const RTPFragmentationHeader* fragmentation, const RTPVideoHeader* rtpVideoHdr)); - MOCK_METHOD5(TimeToSendPacket, - bool(uint32_t ssrc, - uint16_t sequence_number, - int64_t capture_time_ms, - bool retransmission, - int probe_cluster_id)); - MOCK_METHOD2(TimeToSendPadding, size_t(size_t bytes, int probe_cluster_id)); + 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)); MOCK_METHOD2(RegisterRtcpObservers, void(RtcpIntraFrameObserver* intraFrameCallback, RtcpBandwidthObserver* bandwidthCallback)); diff --git a/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.cc b/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.cc index bd36a52975..2a9220d9f0 100644 --- a/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.cc +++ b/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.cc @@ -428,19 +428,17 @@ int32_t ModuleRtpRtcpImpl::SendOutgoingData( bool ModuleRtpRtcpImpl::TimeToSendPacket(uint32_t ssrc, uint16_t sequence_number, int64_t capture_time_ms, - bool retransmission, - int probe_cluster_id) { + bool retransmission) { if (SendingMedia() && ssrc == rtp_sender_.SSRC()) { - return rtp_sender_.TimeToSendPacket(sequence_number, capture_time_ms, - retransmission, probe_cluster_id); + return rtp_sender_.TimeToSendPacket( + sequence_number, capture_time_ms, retransmission); } // No RTP sender is interested in sending this packet. return true; } -size_t ModuleRtpRtcpImpl::TimeToSendPadding(size_t bytes, - int probe_cluster_id) { - return rtp_sender_.TimeToSendPadding(bytes, probe_cluster_id); +size_t ModuleRtpRtcpImpl::TimeToSendPadding(size_t bytes) { + return rtp_sender_.TimeToSendPadding(bytes); } uint16_t ModuleRtpRtcpImpl::MaxPayloadLength() const { diff --git a/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.h b/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.h index cb47cc7700..7bbb06e528 100644 --- a/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.h +++ b/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.h @@ -123,12 +123,11 @@ class ModuleRtpRtcpImpl : public RtpRtcp { bool TimeToSendPacket(uint32_t ssrc, uint16_t sequence_number, int64_t capture_time_ms, - bool retransmission, - int probe_cluster_id) override; + bool retransmission) override; // Returns the number of padding bytes actually sent, which can be more or // less than |bytes|. - size_t TimeToSendPadding(size_t bytes, int probe_cluster_id) override; + size_t TimeToSendPadding(size_t bytes) override; // RTCP part. diff --git a/webrtc/modules/rtp_rtcp/source/rtp_sender.cc b/webrtc/modules/rtp_rtcp/source/rtp_sender.cc index 3ad2293c86..cda776bf22 100644 --- a/webrtc/modules/rtp_rtcp/source/rtp_sender.cc +++ b/webrtc/modules/rtp_rtcp/source/rtp_sender.cc @@ -543,8 +543,7 @@ int32_t RTPSender::SendOutgoingData(FrameType frame_type, return ret_val; } -size_t RTPSender::TrySendRedundantPayloads(size_t bytes_to_send, - int probe_cluster_id) { +size_t RTPSender::TrySendRedundantPayloads(size_t bytes_to_send) { { rtc::CritScope lock(&send_critsect_); if (!sending_media_) @@ -562,8 +561,7 @@ size_t RTPSender::TrySendRedundantPayloads(size_t bytes_to_send, &capture_time_ms)) { break; } - if (!PrepareAndSendPacket(buffer, length, capture_time_ms, true, false, - probe_cluster_id)) + if (!PrepareAndSendPacket(buffer, length, capture_time_ms, true, false)) break; RtpUtility::RtpHeaderParser rtp_parser(buffer, length); RTPHeader rtp_header; @@ -591,8 +589,7 @@ void RTPSender::BuildPaddingPacket(uint8_t* packet, size_t RTPSender::SendPadData(size_t bytes, bool timestamp_provided, uint32_t timestamp, - int64_t capture_time_ms, - int probe_cluster_id) { + int64_t capture_time_ms) { // Always send full padding packets. This is accounted for by the // RtpPacketSender, // which will make sure we don't send too much padding even if a single packet @@ -680,7 +677,7 @@ size_t RTPSender::SendPadData(size_t bytes, length, rtp_header)) { if (transport_feedback_observer_) transport_feedback_observer_->AddPacket(options.packet_id, length, - true, probe_cluster_id); + true); } } @@ -736,8 +733,7 @@ int32_t RTPSender::ReSendPacket(uint16_t packet_id, int64_t min_resend_time) { rtx = rtx_; } if (!PrepareAndSendPacket(data_buffer, length, capture_time_ms, - (rtx & kRtxRetransmitted) > 0, true, - PacketInfo::kNotAProbe)) { + (rtx & kRtxRetransmitted) > 0, true)) { return -1; } return static_cast(length); @@ -873,8 +869,7 @@ void RTPSender::UpdateNACKBitRate(uint32_t bytes, int64_t now) { // Called from pacer when we can send the packet. bool RTPSender::TimeToSendPacket(uint16_t sequence_number, int64_t capture_time_ms, - bool retransmission, - int probe_cluster_id) { + bool retransmission) { size_t length = IP_PACKET_SIZE; uint8_t data_buffer[IP_PACKET_SIZE]; int64_t stored_time_ms; @@ -894,17 +889,18 @@ bool RTPSender::TimeToSendPacket(uint16_t sequence_number, rtc::CritScope lock(&send_critsect_); rtx = rtx_; } - return PrepareAndSendPacket(data_buffer, length, capture_time_ms, + return PrepareAndSendPacket(data_buffer, + length, + capture_time_ms, retransmission && (rtx & kRtxRetransmitted) > 0, - retransmission, probe_cluster_id); + retransmission); } bool RTPSender::PrepareAndSendPacket(uint8_t* buffer, size_t length, int64_t capture_time_ms, bool send_over_rtx, - bool is_retransmit, - int probe_cluster_id) { + bool is_retransmit) { uint8_t* buffer_to_send_ptr = buffer; RtpUtility::RtpHeaderParser rtp_parser(buffer, length); @@ -936,8 +932,8 @@ bool RTPSender::PrepareAndSendPacket(uint8_t* buffer, if (UpdateTransportSequenceNumber(options.packet_id, buffer_to_send_ptr, length, rtp_header)) { if (transport_feedback_observer_) - transport_feedback_observer_->AddPacket(options.packet_id, length, true, - probe_cluster_id); + transport_feedback_observer_->AddPacket(options.packet_id, length, + true); } } @@ -1004,13 +1000,12 @@ bool RTPSender::IsFecPacket(const uint8_t* buffer, buffer[header.headerLength] == pt_fec; } -size_t RTPSender::TimeToSendPadding(size_t bytes, int probe_cluster_id) { +size_t RTPSender::TimeToSendPadding(size_t bytes) { if (audio_configured_ || bytes == 0) return 0; - size_t bytes_sent = TrySendRedundantPayloads(bytes, probe_cluster_id); + size_t bytes_sent = TrySendRedundantPayloads(bytes); if (bytes_sent < bytes) - bytes_sent += - SendPadData(bytes - bytes_sent, false, 0, 0, probe_cluster_id); + bytes_sent += SendPadData(bytes - bytes_sent, false, 0, 0); return bytes_sent; } @@ -1067,8 +1062,8 @@ int32_t RTPSender::SendToNetwork(uint8_t* buffer, if (UpdateTransportSequenceNumber(options.packet_id, buffer, length, rtp_header)) { if (transport_feedback_observer_) - transport_feedback_observer_->AddPacket(options.packet_id, length, true, - PacketInfo::kNotAProbe); + transport_feedback_observer_->AddPacket(options.packet_id, length, + true); } } UpdateDelayStatistics(capture_time_ms, now_ms); diff --git a/webrtc/modules/rtp_rtcp/source/rtp_sender.h b/webrtc/modules/rtp_rtcp/source/rtp_sender.h index 4f540fd865..f501d27a72 100644 --- a/webrtc/modules/rtp_rtcp/source/rtp_sender.h +++ b/webrtc/modules/rtp_rtcp/source/rtp_sender.h @@ -211,11 +211,9 @@ class RTPSender : public RTPSenderInterface { const RTPHeader& rtp_header, VideoRotation rotation) const override; - bool TimeToSendPacket(uint16_t sequence_number, - int64_t capture_time_ms, - bool retransmission, - int probe_cluster_id); - size_t TimeToSendPadding(size_t bytes, int probe_cluster_id); + bool TimeToSendPacket(uint16_t sequence_number, int64_t capture_time_ms, + bool retransmission); + size_t TimeToSendPadding(size_t bytes); // NACK. int SelectiveRetransmissions() const; @@ -302,8 +300,7 @@ class RTPSender : public RTPSenderInterface { size_t SendPadData(size_t bytes, bool timestamp_provided, uint32_t timestamp, - int64_t capture_time_ms, - int probe_cluster_id); + int64_t capture_time_ms); // Called on update of RTP statistics. void RegisterRtpStatisticsCallback(StreamDataCountersCallback* callback); @@ -340,12 +337,11 @@ class RTPSender : public RTPSenderInterface { size_t length, int64_t capture_time_ms, bool send_over_rtx, - bool is_retransmit, - int probe_cluster_id); + bool is_retransmit); // Return the number of bytes sent. Note that both of these functions may // return a larger value that their argument. - size_t TrySendRedundantPayloads(size_t bytes, int probe_cluster_id); + size_t TrySendRedundantPayloads(size_t bytes); void BuildPaddingPacket(uint8_t* packet, size_t header_length, diff --git a/webrtc/modules/rtp_rtcp/source/rtp_sender_unittest.cc b/webrtc/modules/rtp_rtcp/source/rtp_sender_unittest.cc index aa882d2baa..d04ff4d200 100644 --- a/webrtc/modules/rtp_rtcp/source/rtp_sender_unittest.cc +++ b/webrtc/modules/rtp_rtcp/source/rtp_sender_unittest.cc @@ -766,8 +766,7 @@ TEST_F(RtpSenderTest, TrafficSmoothingWithExtensions) { const int kStoredTimeInMs = 100; fake_clock_.AdvanceTimeMilliseconds(kStoredTimeInMs); - rtp_sender_->TimeToSendPacket(kSeqNum, capture_time_ms, false, - PacketInfo::kNotAProbe); + rtp_sender_->TimeToSendPacket(kSeqNum, capture_time_ms, false); // Process send bucket. Packet should now be sent. EXPECT_EQ(1, transport_.packets_sent_); @@ -826,8 +825,7 @@ TEST_F(RtpSenderTest, TrafficSmoothingRetransmits) { EXPECT_EQ(rtp_length_int, rtp_sender_->ReSendPacket(kSeqNum)); EXPECT_EQ(0, transport_.packets_sent_); - rtp_sender_->TimeToSendPacket(kSeqNum, capture_time_ms, false, - PacketInfo::kNotAProbe); + rtp_sender_->TimeToSendPacket(kSeqNum, capture_time_ms, false); // Process send bucket. Packet should now be sent. EXPECT_EQ(1, transport_.packets_sent_); @@ -903,8 +901,7 @@ TEST_F(RtpSenderTest, SendPadding) { const int kStoredTimeInMs = 100; fake_clock_.AdvanceTimeMilliseconds(kStoredTimeInMs); - rtp_sender_->TimeToSendPacket(seq_num++, capture_time_ms, false, - PacketInfo::kNotAProbe); + rtp_sender_->TimeToSendPacket(seq_num++, capture_time_ms, false); // Packet should now be sent. This test doesn't verify the regular video // packet, since it is tested in another test. EXPECT_EQ(++total_packets_sent, transport_.packets_sent_); @@ -916,8 +913,7 @@ TEST_F(RtpSenderTest, SendPadding) { const size_t kPaddingBytes = 100; const size_t kMaxPaddingLength = 224; // Value taken from rtp_sender.cc. // Padding will be forced to full packets. - EXPECT_EQ(kMaxPaddingLength, rtp_sender_->TimeToSendPadding( - kPaddingBytes, PacketInfo::kNotAProbe)); + EXPECT_EQ(kMaxPaddingLength, rtp_sender_->TimeToSendPadding(kPaddingBytes)); // Process send bucket. Padding should now be sent. EXPECT_EQ(++total_packets_sent, transport_.packets_sent_); @@ -958,8 +954,7 @@ TEST_F(RtpSenderTest, SendPadding) { capture_time_ms, kAllowRetransmission, RtpPacketSender::kNormalPriority)); - rtp_sender_->TimeToSendPacket(seq_num, capture_time_ms, false, - PacketInfo::kNotAProbe); + rtp_sender_->TimeToSendPacket(seq_num, capture_time_ms, false); // Process send bucket. EXPECT_EQ(++total_packets_sent, transport_.packets_sent_); EXPECT_EQ(rtp_length, transport_.last_sent_packet_len_); @@ -992,7 +987,7 @@ TEST_F(RtpSenderTest, OnSendPacketUpdated) { SendGenericPayload(); // Packet passed to pacer. const bool kIsRetransmit = false; rtp_sender_->TimeToSendPacket(kSeqNum, fake_clock_.TimeInMilliseconds(), - kIsRetransmit, PacketInfo::kNotAProbe); + kIsRetransmit); EXPECT_EQ(1, transport_.packets_sent_); } @@ -1009,7 +1004,7 @@ TEST_F(RtpSenderTest, OnSendPacketNotUpdatedForRetransmits) { SendGenericPayload(); // Packet passed to pacer. const bool kIsRetransmit = true; rtp_sender_->TimeToSendPacket(kSeqNum, fake_clock_.TimeInMilliseconds(), - kIsRetransmit, PacketInfo::kNotAProbe); + kIsRetransmit); EXPECT_EQ(1, transport_.packets_sent_); } @@ -1027,7 +1022,7 @@ TEST_F(RtpSenderTest, OnSendPacketNotUpdatedWithoutSeqNumAllocator) { SendGenericPayload(); // Packet passed to pacer. const bool kIsRetransmit = false; rtp_sender_->TimeToSendPacket(kSeqNum, fake_clock_.TimeInMilliseconds(), - kIsRetransmit, PacketInfo::kNotAProbe); + kIsRetransmit); EXPECT_EQ(1, transport_.packets_sent_); } @@ -1077,8 +1072,7 @@ TEST_F(RtpSenderTest, SendRedundantPayloads) { int64_t capture_time_ms = fake_clock_.TimeInMilliseconds(); EXPECT_CALL(transport, SendRtp(_, _, _)).WillOnce(testing::Return(true)); SendPacket(capture_time_ms, kPayloadSizes[i]); - rtp_sender_->TimeToSendPacket(seq_num++, capture_time_ms, false, - PacketInfo::kNotAProbe); + rtp_sender_->TimeToSendPacket(seq_num++, capture_time_ms, false); fake_clock_.AdvanceTimeMilliseconds(33); } @@ -1089,14 +1083,12 @@ TEST_F(RtpSenderTest, SendRedundantPayloads) { // The amount of padding to send it too small to send a payload packet. EXPECT_CALL(transport, SendRtp(_, kMaxPaddingSize + rtp_header_len, _)) .WillOnce(testing::Return(true)); - EXPECT_EQ(kMaxPaddingSize, - rtp_sender_->TimeToSendPadding(49, PacketInfo::kNotAProbe)); + EXPECT_EQ(kMaxPaddingSize, rtp_sender_->TimeToSendPadding(49)); EXPECT_CALL(transport, SendRtp(_, kPayloadSizes[0] + rtp_header_len + kRtxHeaderSize, _)) .WillOnce(testing::Return(true)); - EXPECT_EQ(kPayloadSizes[0], - rtp_sender_->TimeToSendPadding(500, PacketInfo::kNotAProbe)); + EXPECT_EQ(kPayloadSizes[0], rtp_sender_->TimeToSendPadding(500)); EXPECT_CALL(transport, SendRtp(_, kPayloadSizes[kNumPayloadSizes - 1] + rtp_header_len + kRtxHeaderSize, @@ -1105,7 +1097,7 @@ TEST_F(RtpSenderTest, SendRedundantPayloads) { EXPECT_CALL(transport, SendRtp(_, kMaxPaddingSize + rtp_header_len, _)) .WillOnce(testing::Return(true)); EXPECT_EQ(kPayloadSizes[kNumPayloadSizes - 1] + kMaxPaddingSize, - rtp_sender_->TimeToSendPadding(999, PacketInfo::kNotAProbe)); + rtp_sender_->TimeToSendPadding(999)); } TEST_F(RtpSenderTestWithoutPacer, SendGenericVideo) { @@ -1368,7 +1360,7 @@ TEST_F(RtpSenderTestWithoutPacer, StreamDataCountersCallbacks) { callback.Matches(ssrc, expected); // Send padding. - rtp_sender_->TimeToSendPadding(kMaxPaddingSize, PacketInfo::kNotAProbe); + rtp_sender_->TimeToSendPadding(kMaxPaddingSize); expected.transmitted.payload_bytes = 12; expected.transmitted.header_bytes = 36; expected.transmitted.padding_bytes = kMaxPaddingSize; @@ -1525,8 +1517,8 @@ TEST_F(RtpSenderTestWithoutPacer, BytesReportedCorrectly) { payload, sizeof(payload), 0)); // Will send 2 full-size padding packets. - rtp_sender_->TimeToSendPadding(1, PacketInfo::kNotAProbe); - rtp_sender_->TimeToSendPadding(1, PacketInfo::kNotAProbe); + rtp_sender_->TimeToSendPadding(1); + rtp_sender_->TimeToSendPadding(1); StreamDataCounters rtp_stats; StreamDataCounters rtx_stats; diff --git a/webrtc/voice_engine/channel.cc b/webrtc/voice_engine/channel.cc index b514dd71d0..6b9de2976e 100644 --- a/webrtc/voice_engine/channel.cc +++ b/webrtc/voice_engine/channel.cc @@ -75,13 +75,11 @@ class TransportFeedbackProxy : public TransportFeedbackObserver { // Implements TransportFeedbackObserver. void AddPacket(uint16_t sequence_number, size_t length, - bool was_paced, - int probe_cluster_id) override { + bool was_paced) override { RTC_DCHECK(pacer_thread_.CalledOnValidThread()); rtc::CritScope lock(&crit_); if (feedback_observer_) - feedback_observer_->AddPacket(sequence_number, length, was_paced, - probe_cluster_id); + feedback_observer_->AddPacket(sequence_number, length, was_paced); } void OnTransportFeedback(const rtcp::TransportFeedback& feedback) override { RTC_DCHECK(network_thread_.CalledOnValidThread());