zqz/platform-external-webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Removes clock from TransportFeedbackAdapter.

Browse Source 
Instead timestamps required for processing are provided explicitly.
This makes it easier to ensure correct usage in log processing
and simulation.

Bug: webrtc:10170
Change-Id: I724a6b9b94e83caa22b8e43b63ef4e6b46138e6a
Reviewed-on: https://webrtc-review.googlesource.com/c/118702
Commit-Queue: Sebastian Jansson <srte@webrtc.org>
Reviewed-by: Björn Terelius <terelius@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#26339}
This commit is contained in:
Sebastian Jansson
2019-01-21 13:07:47 +01:00
committed by Commit Bot
parent 805a27e134
commit 05acd2b76f
11 changed files with 85 additions and 75 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
call/rtp_transport_controller_send.cc
View File

@ -65,7 +65,6 @@ RtpTransportControllerSend::RtpTransportControllerSend(
bitrate_configurator_(bitrate_config), bitrate_configurator_(bitrate_config),
process_thread_(ProcessThread::Create("SendControllerThread")), process_thread_(ProcessThread::Create("SendControllerThread")),
observer_(nullptr), observer_(nullptr),
transport_feedback_adapter_(clock_),
controller_factory_override_(controller_factory), controller_factory_override_(controller_factory),
controller_factory_fallback_( controller_factory_fallback_(
absl::make_unique<GoogCcNetworkControllerFactory>(event_log)), absl::make_unique<GoogCcNetworkControllerFactory>(event_log)),
@ -443,8 +442,9 @@ void RtpTransportControllerSend::AddPacket(uint32_t ssrc,
if (send_side_bwe_with_overhead_) { if (send_side_bwe_with_overhead_) {
length += transport_overhead_bytes_per_packet_; length += transport_overhead_bytes_per_packet_;
} }
transport_feedback_adapter_.AddPacket(ssrc, sequence_number, length, transport_feedback_adapter_.AddPacket(
pacing_info); ssrc, sequence_number, length, pacing_info,
Timestamp::ms(clock_->TimeInMilliseconds()));
} }
void RtpTransportControllerSend::OnTransportFeedback( void RtpTransportControllerSend::OnTransportFeedback(
@ -452,7 +452,8 @@ void RtpTransportControllerSend::OnTransportFeedback(
RTC_DCHECK_RUNS_SERIALIZED(&worker_race_); RTC_DCHECK_RUNS_SERIALIZED(&worker_race_);
absl::optional<TransportPacketsFeedback> feedback_msg = absl::optional<TransportPacketsFeedback> feedback_msg =
transport_feedback_adapter_.ProcessTransportFeedback(feedback); transport_feedback_adapter_.ProcessTransportFeedback(
feedback, Timestamp::ms(clock_->TimeInMilliseconds()));
if (feedback_msg) { if (feedback_msg) {
task_queue_.PostTask([this, feedback_msg]() { task_queue_.PostTask([this, feedback_msg]() {
RTC_DCHECK_RUN_ON(&task_queue_); RTC_DCHECK_RUN_ON(&task_queue_);

8
logging/rtc_event_log/rtc_event_log_parser.cc
View File

@ -1782,7 +1782,7 @@ const std::vector<MatchedSendArrivalTimes> GetNetworkTrace(
parsed_log.transport_feedbacks(kIncomingPacket); parsed_log.transport_feedbacks(kIncomingPacket);
SimulatedClock clock(0); SimulatedClock clock(0);
TransportFeedbackAdapter feedback_adapter(&clock); TransportFeedbackAdapter feedback_adapter;
auto rtp_iterator = outgoing_rtp.begin(); auto rtp_iterator = outgoing_rtp.begin();
auto rtcp_iterator = incoming_rtcp.begin(); auto rtcp_iterator = incoming_rtcp.begin();
@ -1814,7 +1814,8 @@ const std::vector<MatchedSendArrivalTimes> GetNetworkTrace(
feedback_adapter.AddPacket( feedback_adapter.AddPacket(
rtp_packet.rtp.header.ssrc, rtp_packet.rtp.header.ssrc,
rtp_packet.rtp.header.extension.transportSequenceNumber, rtp_packet.rtp.header.extension.transportSequenceNumber,
rtp_packet.rtp.total_length, PacedPacketInfo()); rtp_packet.rtp.total_length, PacedPacketInfo(),
Timestamp::ms(clock.TimeInMilliseconds()));
sent_packet.packet_id = sent_packet.packet_id =
rtp_packet.rtp.header.extension.transportSequenceNumber; rtp_packet.rtp.header.extension.transportSequenceNumber;
sent_packet.info.included_in_feedback = true; sent_packet.info.included_in_feedback = true;
@ -1832,7 +1833,8 @@ const std::vector<MatchedSendArrivalTimes> GetNetworkTrace(
if (clock.TimeInMicroseconds() >= NextRtcpTime()) { if (clock.TimeInMicroseconds() >= NextRtcpTime()) {
RTC_DCHECK_EQ(clock.TimeInMicroseconds(), NextRtcpTime()); RTC_DCHECK_EQ(clock.TimeInMicroseconds(), NextRtcpTime());
feedback_adapter.ProcessTransportFeedback( feedback_adapter.ProcessTransportFeedback(
rtcp_iterator->transport_feedback); rtcp_iterator->transport_feedback,
Timestamp::ms(clock.TimeInMilliseconds()));
std::vector<PacketFeedback> feedback = std::vector<PacketFeedback> feedback =
feedback_adapter.GetTransportFeedbackVector(); feedback_adapter.GetTransportFeedbackVector();
SortPacketFeedbackVectorWithLoss(&feedback); SortPacketFeedbackVectorWithLoss(&feedback);

12
modules/congestion_controller/rtp/send_time_history.cc
View File

@ -16,21 +16,19 @@
#include "modules/rtp_rtcp/include/rtp_rtcp_defines.h" #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
#include "rtc_base/checks.h" #include "rtc_base/checks.h"
#include "rtc_base/logging.h" #include "rtc_base/logging.h"
#include "system_wrappers/include/clock.h"
namespace webrtc { namespace webrtc {
SendTimeHistory::SendTimeHistory(const Clock* clock, SendTimeHistory::SendTimeHistory(int64_t packet_age_limit_ms)
int64_t packet_age_limit_ms) : packet_age_limit_ms_(packet_age_limit_ms) {}
: clock_(clock), packet_age_limit_ms_(packet_age_limit_ms) {}
SendTimeHistory::~SendTimeHistory() {} SendTimeHistory::~SendTimeHistory() {}
void SendTimeHistory::AddAndRemoveOld(const PacketFeedback& packet) { void SendTimeHistory::AddAndRemoveOld(const PacketFeedback& packet,
int64_t now_ms = clock_->TimeInMilliseconds(); int64_t at_time_ms) {
// Remove old. // Remove old.
while (!history_.empty() && while (!history_.empty() &&
now_ms - history_.begin()->second.creation_time_ms > at_time_ms - history_.begin()->second.creation_time_ms >
packet_age_limit_ms_) { packet_age_limit_ms_) {
// TODO(sprang): Warn if erasing (too many) old items? // TODO(sprang): Warn if erasing (too many) old items?
RemovePacketBytes(history_.begin()->second); RemovePacketBytes(history_.begin()->second);

6
modules/congestion_controller/rtp/send_time_history.h
View File

@ -19,16 +19,15 @@
#include "rtc_base/constructor_magic.h" #include "rtc_base/constructor_magic.h"
namespace webrtc { namespace webrtc {
class Clock;
struct PacketFeedback; struct PacketFeedback;
class SendTimeHistory { class SendTimeHistory {
public: public:
SendTimeHistory(const Clock* clock, int64_t packet_age_limit_ms); explicit SendTimeHistory(int64_t packet_age_limit_ms);
~SendTimeHistory(); ~SendTimeHistory();
// Cleanup old entries, then add new packet info with provided parameters. // Cleanup old entries, then add new packet info with provided parameters.
void AddAndRemoveOld(const PacketFeedback& packet); void AddAndRemoveOld(const PacketFeedback& packet, int64_t at_time_ms);
void AddUntracked(size_t packet_size, int64_t send_time_ms); void AddUntracked(size_t packet_size, int64_t send_time_ms);
@ -55,7 +54,6 @@ class SendTimeHistory {
void AddPacketBytes(const PacketFeedback& packet); void AddPacketBytes(const PacketFeedback& packet);
void RemovePacketBytes(const PacketFeedback& packet); void RemovePacketBytes(const PacketFeedback& packet);
void UpdateAckedSeqNum(int64_t acked_seq_num); void UpdateAckedSeqNum(int64_t acked_seq_num);
const Clock* const clock_;
const int64_t packet_age_limit_ms_; const int64_t packet_age_limit_ms_;
size_t pending_untracked_size_ = 0; size_t pending_untracked_size_ = 0;
int64_t last_send_time_ms_ = -1; int64_t last_send_time_ms_ = -1;

9
modules/congestion_controller/rtp/send_time_history_unittest.cc
View File

@ -26,8 +26,7 @@ static const int kDefaultHistoryLengthMs = 1000;
class SendTimeHistoryTest : public ::testing::Test { class SendTimeHistoryTest : public ::testing::Test {
protected: protected:
SendTimeHistoryTest() SendTimeHistoryTest() : clock_(0), history_(kDefaultHistoryLengthMs) {}
: clock_(0), history_(&clock_, kDefaultHistoryLengthMs) {}
~SendTimeHistoryTest() {} ~SendTimeHistoryTest() {}
virtual void SetUp() {} virtual void SetUp() {}
@ -40,7 +39,7 @@ class SendTimeHistoryTest : public ::testing::Test {
const PacedPacketInfo& pacing_info) { const PacedPacketInfo& pacing_info) {
PacketFeedback packet(clock_.TimeInMilliseconds(), sequence_number, length, PacketFeedback packet(clock_.TimeInMilliseconds(), sequence_number, length,
0, 0, pacing_info); 0, 0, pacing_info);
history_.AddAndRemoveOld(packet); history_.AddAndRemoveOld(packet, clock_.TimeInMilliseconds());
history_.OnSentPacket(sequence_number, send_time_ms); history_.OnSentPacket(sequence_number, send_time_ms);
} }
@ -54,7 +53,7 @@ TEST_F(SendTimeHistoryTest, SaveAndRestoreNetworkId) {
int64_t now_ms = clock_.TimeInMilliseconds(); int64_t now_ms = clock_.TimeInMilliseconds();
for (int i = 1; i < 5; ++i) { for (int i = 1; i < 5; ++i) {
PacketFeedback packet(now_ms, sequence_number, 1000, i, i - 1, kPacingInfo); PacketFeedback packet(now_ms, sequence_number, 1000, i, i - 1, kPacingInfo);
history_.AddAndRemoveOld(packet); history_.AddAndRemoveOld(packet, clock_.TimeInMilliseconds());
history_.OnSentPacket(sequence_number, now_ms); history_.OnSentPacket(sequence_number, now_ms);
PacketFeedback restored(now_ms, sequence_number); PacketFeedback restored(now_ms, sequence_number);
EXPECT_TRUE(history_.GetFeedback(&restored, sequence_number++)); EXPECT_TRUE(history_.GetFeedback(&restored, sequence_number++));
@ -139,7 +138,7 @@ TEST_F(SendTimeHistoryTest, AddThenRemoveOutOfOrder) {
PacketFeedback packet = sent_packets[i]; PacketFeedback packet = sent_packets[i];
packet.arrival_time_ms = PacketFeedback::kNotReceived; packet.arrival_time_ms = PacketFeedback::kNotReceived;
packet.send_time_ms = PacketFeedback::kNoSendTime; packet.send_time_ms = PacketFeedback::kNoSendTime;
history_.AddAndRemoveOld(packet); history_.AddAndRemoveOld(packet, clock_.TimeInMilliseconds());
} }
for (size_t i = 0; i < num_items; ++i) for (size_t i = 0; i < num_items; ++i)
history_.OnSentPacket(sent_packets[i].sequence_number, history_.OnSentPacket(sent_packets[i].sequence_number,

51
modules/congestion_controller/rtp/transport_feedback_adapter.cc
View File

@ -49,9 +49,8 @@ const int64_t kBaseTimestampScaleFactor =
rtcp::TransportFeedback::kDeltaScaleFactor * (1 << 8); rtcp::TransportFeedback::kDeltaScaleFactor * (1 << 8);
const int64_t kBaseTimestampRangeSizeUs = kBaseTimestampScaleFactor * (1 << 24); const int64_t kBaseTimestampRangeSizeUs = kBaseTimestampScaleFactor * (1 << 24);
TransportFeedbackAdapter::TransportFeedbackAdapter(const Clock* clock) TransportFeedbackAdapter::TransportFeedbackAdapter()
: send_time_history_(clock, kSendTimeHistoryWindowMs), : send_time_history_(kSendTimeHistoryWindowMs),
clock_(clock),
current_offset_ms_(kNoTimestamp), current_offset_ms_(kNoTimestamp),
last_timestamp_us_(kNoTimestamp), last_timestamp_us_(kNoTimestamp),
local_net_id_(0), local_net_id_(0),
@ -82,13 +81,14 @@ void TransportFeedbackAdapter::DeRegisterPacketFeedbackObserver(
void TransportFeedbackAdapter::AddPacket(uint32_t ssrc, void TransportFeedbackAdapter::AddPacket(uint32_t ssrc,
uint16_t sequence_number, uint16_t sequence_number,
size_t length, size_t length,
const PacedPacketInfo& pacing_info) { const PacedPacketInfo& pacing_info,
Timestamp creation_time) {
{ {
rtc::CritScope cs(&lock_); rtc::CritScope cs(&lock_);
const int64_t creation_time_ms = clock_->TimeInMilliseconds();
send_time_history_.AddAndRemoveOld( send_time_history_.AddAndRemoveOld(
PacketFeedback(creation_time_ms, sequence_number, length, local_net_id_, PacketFeedback(creation_time.ms(), sequence_number, length,
remote_net_id_, pacing_info)); local_net_id_, remote_net_id_, pacing_info),
creation_time.ms());
} }
{ {
@ -98,7 +98,6 @@ void TransportFeedbackAdapter::AddPacket(uint32_t ssrc,
} }
} }
} }
absl::optional<SentPacket> TransportFeedbackAdapter::ProcessSentPacket( absl::optional<SentPacket> TransportFeedbackAdapter::ProcessSentPacket(
const rtc::SentPacket& sent_packet) { const rtc::SentPacket& sent_packet) {
rtc::CritScope cs(&lock_); rtc::CritScope cs(&lock_);
@ -127,10 +126,19 @@ absl::optional<SentPacket> TransportFeedbackAdapter::ProcessSentPacket(
absl::optional<TransportPacketsFeedback> absl::optional<TransportPacketsFeedback>
TransportFeedbackAdapter::ProcessTransportFeedback( TransportFeedbackAdapter::ProcessTransportFeedback(
const rtcp::TransportFeedback& feedback) { const rtcp::TransportFeedback& feedback,
int64_t feedback_time_ms = clock_->TimeInMilliseconds(); Timestamp feedback_receive_time) {
DataSize prior_in_flight = GetOutstandingData(); DataSize prior_in_flight = GetOutstandingData();
OnTransportFeedback(feedback);
last_packet_feedback_vector_ =
GetPacketFeedbackVector(feedback, feedback_receive_time);
{
rtc::CritScope cs(&observers_lock_);
for (auto* observer : observers_) {
observer->OnPacketFeedbackVector(last_packet_feedback_vector_);
}
}
std::vector<PacketFeedback> feedback_vector = last_packet_feedback_vector_; std::vector<PacketFeedback> feedback_vector = last_packet_feedback_vector_;
if (feedback_vector.empty()) if (feedback_vector.empty())
return absl::nullopt; return absl::nullopt;
@ -155,7 +163,7 @@ TransportFeedbackAdapter::ProcessTransportFeedback(
if (first_unacked_send_time_ms) if (first_unacked_send_time_ms)
msg.first_unacked_send_time = Timestamp::ms(*first_unacked_send_time_ms); msg.first_unacked_send_time = Timestamp::ms(*first_unacked_send_time_ms);
} }
msg.feedback_time = Timestamp::ms(feedback_time_ms); msg.feedback_time = feedback_receive_time;
msg.prior_in_flight = prior_in_flight; msg.prior_in_flight = prior_in_flight;
msg.data_in_flight = GetOutstandingData(); msg.data_in_flight = GetOutstandingData();
return msg; return msg;
@ -174,14 +182,15 @@ DataSize TransportFeedbackAdapter::GetOutstandingData() const {
} }
std::vector<PacketFeedback> TransportFeedbackAdapter::GetPacketFeedbackVector( std::vector<PacketFeedback> TransportFeedbackAdapter::GetPacketFeedbackVector(
const rtcp::TransportFeedback& feedback) { const rtcp::TransportFeedback& feedback,
Timestamp feedback_time) {
int64_t timestamp_us = feedback.GetBaseTimeUs(); int64_t timestamp_us = feedback.GetBaseTimeUs();
int64_t now_ms = clock_->TimeInMilliseconds();
// Add timestamp deltas to a local time base selected on first packet arrival. // Add timestamp deltas to a local time base selected on first packet arrival.
// This won't be the true time base, but makes it easier to manually inspect // This won't be the true time base, but makes it easier to manually inspect
// time stamps. // time stamps.
if (last_timestamp_us_ == kNoTimestamp) { if (last_timestamp_us_ == kNoTimestamp) {
current_offset_ms_ = now_ms; current_offset_ms_ = feedback_time.ms();
} else { } else {
int64_t delta = timestamp_us - last_timestamp_us_; int64_t delta = timestamp_us - last_timestamp_us_;
@ -246,19 +255,9 @@ std::vector<PacketFeedback> TransportFeedbackAdapter::GetPacketFeedbackVector(
return packet_feedback_vector; return packet_feedback_vector;
} }
void TransportFeedbackAdapter::OnTransportFeedback(
const rtcp::TransportFeedback& feedback) {
last_packet_feedback_vector_ = GetPacketFeedbackVector(feedback);
{
rtc::CritScope cs(&observers_lock_);
for (auto* observer : observers_) {
observer->OnPacketFeedbackVector(last_packet_feedback_vector_);
}
}
}
std::vector<PacketFeedback> std::vector<PacketFeedback>
TransportFeedbackAdapter::GetTransportFeedbackVector() const { TransportFeedbackAdapter::GetTransportFeedbackVector() const {
return last_packet_feedback_vector_; return last_packet_feedback_vector_;
} }
} // namespace webrtc } // namespace webrtc

13
modules/congestion_controller/rtp/transport_feedback_adapter.h
View File

@ -20,7 +20,6 @@
#include "rtc_base/network/sent_packet.h" #include "rtc_base/network/sent_packet.h"
#include "rtc_base/thread_annotations.h" #include "rtc_base/thread_annotations.h"
#include "rtc_base/thread_checker.h" #include "rtc_base/thread_checker.h"
#include "system_wrappers/include/clock.h"
namespace webrtc { namespace webrtc {
@ -32,7 +31,7 @@ class TransportFeedback;
class TransportFeedbackAdapter { class TransportFeedbackAdapter {
public: public:
explicit TransportFeedbackAdapter(const Clock* clock); TransportFeedbackAdapter();
virtual ~TransportFeedbackAdapter(); virtual ~TransportFeedbackAdapter();
void RegisterPacketFeedbackObserver(PacketFeedbackObserver* observer); void RegisterPacketFeedbackObserver(PacketFeedbackObserver* observer);
@ -41,13 +40,15 @@ class TransportFeedbackAdapter {
void AddPacket(uint32_t ssrc, void AddPacket(uint32_t ssrc,
uint16_t sequence_number, uint16_t sequence_number,
size_t length, size_t length,
const PacedPacketInfo& pacing_info); const PacedPacketInfo& pacing_info,
Timestamp creation_time);
absl::optional<SentPacket> ProcessSentPacket( absl::optional<SentPacket> ProcessSentPacket(
const rtc::SentPacket& sent_packet); const rtc::SentPacket& sent_packet);
absl::optional<TransportPacketsFeedback> ProcessTransportFeedback( absl::optional<TransportPacketsFeedback> ProcessTransportFeedback(
const rtcp::TransportFeedback& feedback); const rtcp::TransportFeedback& feedback,
Timestamp feedback_time);
std::vector<PacketFeedback> GetTransportFeedbackVector() const; std::vector<PacketFeedback> GetTransportFeedbackVector() const;
@ -59,11 +60,11 @@ class TransportFeedbackAdapter {
void OnTransportFeedback(const rtcp::TransportFeedback& feedback); void OnTransportFeedback(const rtcp::TransportFeedback& feedback);
std::vector<PacketFeedback> GetPacketFeedbackVector( std::vector<PacketFeedback> GetPacketFeedbackVector(
const rtcp::TransportFeedback& feedback); const rtcp::TransportFeedback& feedback,
Timestamp feedback_time);
rtc::CriticalSection lock_; rtc::CriticalSection lock_;
SendTimeHistory send_time_history_ RTC_GUARDED_BY(&lock_); SendTimeHistory send_time_history_ RTC_GUARDED_BY(&lock_);
const Clock* const clock_;
int64_t current_offset_ms_; int64_t current_offset_ms_;
int64_t last_timestamp_us_; int64_t last_timestamp_us_;
std::vector<PacketFeedback> last_packet_feedback_vector_; std::vector<PacketFeedback> last_packet_feedback_vector_;

34
modules/congestion_controller/rtp/transport_feedback_adapter_unittest.cc
View File

@ -52,9 +52,7 @@ class TransportFeedbackAdapterTest : public ::testing::Test {
virtual ~TransportFeedbackAdapterTest() {} virtual ~TransportFeedbackAdapterTest() {}
virtual void SetUp() { virtual void SetUp() { adapter_.reset(new TransportFeedbackAdapter()); }
adapter_.reset(new TransportFeedbackAdapter(&clock_));
}
virtual void TearDown() { adapter_.reset(); } virtual void TearDown() { adapter_.reset(); }
@ -68,7 +66,8 @@ class TransportFeedbackAdapterTest : public ::testing::Test {
void OnSentPacket(const PacketFeedback& packet_feedback) { void OnSentPacket(const PacketFeedback& packet_feedback) {
adapter_->AddPacket(kSsrc, packet_feedback.sequence_number, adapter_->AddPacket(kSsrc, packet_feedback.sequence_number,
packet_feedback.payload_size, packet_feedback.payload_size,
packet_feedback.pacing_info); packet_feedback.pacing_info,
Timestamp::ms(clock_.TimeInMilliseconds()));
adapter_->ProcessSentPacket(rtc::SentPacket(packet_feedback.sequence_number, adapter_->ProcessSentPacket(rtc::SentPacket(packet_feedback.sequence_number,
packet_feedback.send_time_ms, packet_feedback.send_time_ms,
rtc::PacketInfo())); rtc::PacketInfo()));
@ -101,7 +100,8 @@ TEST_F(TransportFeedbackAdapterTest, ObserverSanity) {
} }
EXPECT_CALL(mock, OnPacketFeedbackVector(_)).Times(1); EXPECT_CALL(mock, OnPacketFeedbackVector(_)).Times(1);
adapter_->ProcessTransportFeedback(feedback); adapter_->ProcessTransportFeedback(
feedback, Timestamp::ms(clock_.TimeInMilliseconds()));
adapter_->DeRegisterPacketFeedbackObserver(&mock); adapter_->DeRegisterPacketFeedbackObserver(&mock);
@ -116,7 +116,8 @@ TEST_F(TransportFeedbackAdapterTest, ObserverSanity) {
EXPECT_TRUE(feedback.AddReceivedPacket(new_packet.sequence_number, EXPECT_TRUE(feedback.AddReceivedPacket(new_packet.sequence_number,
new_packet.arrival_time_ms * 1000)); new_packet.arrival_time_ms * 1000));
EXPECT_CALL(mock, OnPacketFeedbackVector(_)).Times(0); EXPECT_CALL(mock, OnPacketFeedbackVector(_)).Times(0);
adapter_->ProcessTransportFeedback(second_feedback); adapter_->ProcessTransportFeedback(
second_feedback, Timestamp::ms(clock_.TimeInMilliseconds()));
} }
#if RTC_DCHECK_IS_ON && GTEST_HAS_DEATH_TEST && !defined(WEBRTC_ANDROID) #if RTC_DCHECK_IS_ON && GTEST_HAS_DEATH_TEST && !defined(WEBRTC_ANDROID)
@ -157,7 +158,8 @@ TEST_F(TransportFeedbackAdapterTest, AdaptsFeedbackAndPopulatesSendTimes) {
feedback.Build(); feedback.Build();
adapter_->ProcessTransportFeedback(feedback); adapter_->ProcessTransportFeedback(
feedback, Timestamp::ms(clock_.TimeInMilliseconds()));
ComparePacketFeedbackVectors(packets, adapter_->GetTransportFeedbackVector()); ComparePacketFeedbackVectors(packets, adapter_->GetTransportFeedbackVector());
} }
@ -190,7 +192,8 @@ TEST_F(TransportFeedbackAdapterTest, FeedbackVectorReportsUnreceived) {
feedback.Build(); feedback.Build();
adapter_->ProcessTransportFeedback(feedback); adapter_->ProcessTransportFeedback(
feedback, Timestamp::ms(clock_.TimeInMilliseconds()));
ComparePacketFeedbackVectors(sent_packets, ComparePacketFeedbackVectors(sent_packets,
adapter_->GetTransportFeedbackVector()); adapter_->GetTransportFeedbackVector());
} }
@ -234,7 +237,8 @@ TEST_F(TransportFeedbackAdapterTest, HandlesDroppedPackets) {
expected_packets[i].pacing_info = PacedPacketInfo(); expected_packets[i].pacing_info = PacedPacketInfo();
} }
adapter_->ProcessTransportFeedback(feedback); adapter_->ProcessTransportFeedback(
feedback, Timestamp::ms(clock_.TimeInMilliseconds()));
ComparePacketFeedbackVectors(expected_packets, ComparePacketFeedbackVectors(expected_packets,
adapter_->GetTransportFeedbackVector()); adapter_->GetTransportFeedbackVector());
} }
@ -270,7 +274,8 @@ TEST_F(TransportFeedbackAdapterTest, SendTimeWrapsBothWays) {
std::vector<PacketFeedback> expected_packets; std::vector<PacketFeedback> expected_packets;
expected_packets.push_back(packets[i]); expected_packets.push_back(packets[i]);
adapter_->ProcessTransportFeedback(*feedback.get()); adapter_->ProcessTransportFeedback(
*feedback.get(), Timestamp::ms(clock_.TimeInMilliseconds()));
ComparePacketFeedbackVectors(expected_packets, ComparePacketFeedbackVectors(expected_packets,
adapter_->GetTransportFeedbackVector()); adapter_->GetTransportFeedbackVector());
} }
@ -299,7 +304,8 @@ TEST_F(TransportFeedbackAdapterTest, HandlesArrivalReordering) {
// Adapter keeps the packets ordered by sequence number (which is itself // Adapter keeps the packets ordered by sequence number (which is itself
// assigned by the order of transmission). Reordering by some other criteria, // assigned by the order of transmission). Reordering by some other criteria,
// eg. arrival time, is up to the observers. // eg. arrival time, is up to the observers.
adapter_->ProcessTransportFeedback(feedback); adapter_->ProcessTransportFeedback(
feedback, Timestamp::ms(clock_.TimeInMilliseconds()));
ComparePacketFeedbackVectors(packets, adapter_->GetTransportFeedbackVector()); ComparePacketFeedbackVectors(packets, adapter_->GetTransportFeedbackVector());
} }
@ -363,7 +369,8 @@ TEST_F(TransportFeedbackAdapterTest, TimestampDeltas) {
std::vector<PacketFeedback> received_feedback; std::vector<PacketFeedback> received_feedback;
EXPECT_TRUE(feedback.get() != nullptr); EXPECT_TRUE(feedback.get() != nullptr);
adapter_->ProcessTransportFeedback(*feedback.get()); adapter_->ProcessTransportFeedback(
*feedback.get(), Timestamp::ms(clock_.TimeInMilliseconds()));
ComparePacketFeedbackVectors(sent_packets, ComparePacketFeedbackVectors(sent_packets,
adapter_->GetTransportFeedbackVector()); adapter_->GetTransportFeedbackVector());
@ -378,7 +385,8 @@ TEST_F(TransportFeedbackAdapterTest, TimestampDeltas) {
rtcp::TransportFeedback::ParseFrom(raw_packet.data(), raw_packet.size()); rtcp::TransportFeedback::ParseFrom(raw_packet.data(), raw_packet.size());
EXPECT_TRUE(feedback.get() != nullptr); EXPECT_TRUE(feedback.get() != nullptr);
adapter_->ProcessTransportFeedback(*feedback.get()); adapter_->ProcessTransportFeedback(
*feedback.get(), Timestamp::ms(clock_.TimeInMilliseconds()));
{ {
std::vector<PacketFeedback> expected_packets; std::vector<PacketFeedback> expected_packets;
expected_packets.push_back(packet_feedback); expected_packets.push_back(packet_feedback);

5
modules/congestion_controller/transport_feedback_adapter.cc
View File

@ -31,7 +31,7 @@ const int64_t kBaseTimestampRangeSizeUs = kBaseTimestampScaleFactor * (1 << 24);
LegacyTransportFeedbackAdapter::LegacyTransportFeedbackAdapter( LegacyTransportFeedbackAdapter::LegacyTransportFeedbackAdapter(
const Clock* clock) const Clock* clock)
: send_time_history_(clock, kSendTimeHistoryWindowMs), : send_time_history_(kSendTimeHistoryWindowMs),
clock_(clock), clock_(clock),
current_offset_ms_(kNoTimestamp), current_offset_ms_(kNoTimestamp),
last_timestamp_us_(kNoTimestamp), last_timestamp_us_(kNoTimestamp),
@ -70,7 +70,8 @@ void LegacyTransportFeedbackAdapter::AddPacket(
const int64_t creation_time_ms = clock_->TimeInMilliseconds(); const int64_t creation_time_ms = clock_->TimeInMilliseconds();
send_time_history_.AddAndRemoveOld( send_time_history_.AddAndRemoveOld(
PacketFeedback(creation_time_ms, sequence_number, length, local_net_id_, PacketFeedback(creation_time_ms, sequence_number, length, local_net_id_,
remote_net_id_, pacing_info)); remote_net_id_, pacing_info),
creation_time_ms);
} }
{ {

5
modules/remote_bitrate_estimator/test/estimators/send_side.cc
View File

@ -41,7 +41,7 @@ SendSideBweSender::SendSideBweSender(int kbps,
bwe_(new DelayBasedBwe(&field_trial_config_, nullptr)), bwe_(new DelayBasedBwe(&field_trial_config_, nullptr)),
feedback_observer_(bitrate_controller_.get()), feedback_observer_(bitrate_controller_.get()),
clock_(clock), clock_(clock),
send_time_history_(clock_, 10000), send_time_history_(10000),
has_received_ack_(false), has_received_ack_(false),
last_acked_seq_num_(0), last_acked_seq_num_(0),
last_log_time_ms_(0) { last_log_time_ms_(0) {
@ -134,7 +134,8 @@ void SendSideBweSender::OnPacketsSent(const Packets& packets) {
PacketFeedback packet_feedback( PacketFeedback packet_feedback(
clock_->TimeInMilliseconds(), media_packet->header().sequenceNumber, clock_->TimeInMilliseconds(), media_packet->header().sequenceNumber,
media_packet->payload_size(), 0, 0, PacedPacketInfo()); media_packet->payload_size(), 0, 0, PacedPacketInfo());
send_time_history_.AddAndRemoveOld(packet_feedback); send_time_history_.AddAndRemoveOld(packet_feedback,
clock_->TimeInMilliseconds());
send_time_history_.OnSentPacket(media_packet->header().sequenceNumber, send_time_history_.OnSentPacket(media_packet->header().sequenceNumber,
media_packet->sender_timestamp_ms()); media_packet->sender_timestamp_ms());
} }

8
rtc_tools/event_log_visualizer/analyzer.cc
View File

@ -1076,7 +1076,7 @@ void EventLogAnalyzer::CreateSendSideBweSimulationGraph(Plot* plot) {
RtcEventLogNullImpl null_event_log; RtcEventLogNullImpl null_event_log;
PacketRouter packet_router; PacketRouter packet_router;
PacedSender pacer(&clock, &packet_router, &null_event_log); PacedSender pacer(&clock, &packet_router, &null_event_log);
TransportFeedbackAdapter transport_feedback(&clock); TransportFeedbackAdapter transport_feedback;
auto factory = GoogCcNetworkControllerFactory(&null_event_log); auto factory = GoogCcNetworkControllerFactory(&null_event_log);
TimeDelta process_interval = factory.GetProcessInterval(); TimeDelta process_interval = factory.GetProcessInterval();
// TODO(holmer): Log the call config and use that here instead. // TODO(holmer): Log the call config and use that here instead.
@ -1144,7 +1144,8 @@ void EventLogAnalyzer::CreateSendSideBweSimulationGraph(Plot* plot) {
transport_feedback.AddPacket( transport_feedback.AddPacket(
rtp_packet.rtp.header.ssrc, rtp_packet.rtp.header.ssrc,
rtp_packet.rtp.header.extension.transportSequenceNumber, rtp_packet.rtp.header.extension.transportSequenceNumber,
rtp_packet.rtp.total_length, PacedPacketInfo()); rtp_packet.rtp.total_length, PacedPacketInfo(),
Timestamp::us(rtp_packet.rtp.log_time_us()));
rtc::SentPacket sent_packet( rtc::SentPacket sent_packet(
rtp_packet.rtp.header.extension.transportSequenceNumber, rtp_packet.rtp.header.extension.transportSequenceNumber,
rtp_packet.rtp.log_time_us() / 1000); rtp_packet.rtp.log_time_us() / 1000);
@ -1158,7 +1159,8 @@ void EventLogAnalyzer::CreateSendSideBweSimulationGraph(Plot* plot) {
RTC_DCHECK_EQ(clock.TimeInMicroseconds(), NextRtcpTime()); RTC_DCHECK_EQ(clock.TimeInMicroseconds(), NextRtcpTime());
auto feedback_msg = transport_feedback.ProcessTransportFeedback( auto feedback_msg = transport_feedback.ProcessTransportFeedback(
rtcp_iterator->transport_feedback); rtcp_iterator->transport_feedback,
Timestamp::ms(clock.TimeInMilliseconds()));
absl::optional<uint32_t> bitrate_bps; absl::optional<uint32_t> bitrate_bps;
if (feedback_msg) { if (feedback_msg) {
observer.Update(goog_cc->OnTransportPacketsFeedback(*feedback_msg)); observer.Update(goog_cc->OnTransportPacketsFeedback(*feedback_msg));