admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Set send times in send time history via OnSentPacket.

Browse Source 
BUG=webrtc:4173

Review URL: https://codereview.webrtc.org/1419503004

Cr-Commit-Position: refs/heads/master@{#10384}
This commit is contained in:
stefan 2015-10-23 02:05:40 -07:00 committed by Commit bot
parent 9a4cd87640
commit bbe876f0d3
11 changed files with 170 additions and 122 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
webrtc/call/congestion_controller.cc
View File

@ -297,8 +297,8 @@ void CongestionController::OnNetworkChanged(uint32_t target_bitrate_bps,
void CongestionController::OnSentPacket(const rtc::SentPacket& sent_packet) {
if (transport_feedback_adapter_) {
transport_feedback_adapter_->UpdateSendTime(sent_packet.packet_id,
sent_packet.send_time_ms);
transport_feedback_adapter_->OnSentPacket(sent_packet.packet_id,
sent_packet.send_time_ms);
}
}
} // namespace webrtc

9
webrtc/modules/remote_bitrate_estimator/include/send_time_history.h
View File

@ -21,11 +21,11 @@ namespace webrtc {
class SendTimeHistory {
public:
explicit SendTimeHistory(int64_t packet_age_limit);
SendTimeHistory(Clock* clock, int64_t packet_age_limit);
virtual ~SendTimeHistory();
void AddAndRemoveOld(const PacketInfo& packet);
bool UpdateSendTime(uint16_t sequence_number, int64_t timestamp);
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
// thus be non-null and have the sequence_number field set.
@ -33,9 +33,10 @@ class SendTimeHistory {
void Clear();
private:
void EraseOld(int64_t limit);
void EraseOld();
void UpdateOldestSequenceNumber();
Clock* const clock_;
const int64_t packet_age_limit_;
uint16_t oldest_sequence_number_; // Oldest may not be lowest.
std::map<uint16_t, PacketInfo> history_;

6
webrtc/modules/remote_bitrate_estimator/remote_estimator_proxy.cc
View File

@ -45,7 +45,11 @@ void RemoteEstimatorProxy::IncomingPacket(int64_t arrival_time_ms,
size_t payload_size,
const RTPHeader& header,
bool was_paced) {
RTC_DCHECK(header.extension.hasTransportSequenceNumber);
if (!header.extension.hasTransportSequenceNumber) {
LOG(LS_WARNING) << "RemoteEstimatorProxy: Incoming packet "
"is missing the transport sequence number extension!";
return;
}
rtc::CritScope cs(&lock_);
media_ssrc_ = header.ssrc;
OnPacketArrival(header.extension.transportSequenceNumber, arrival_time_ms);

30
webrtc/modules/remote_bitrate_estimator/send_time_history.cc
View File

@ -14,9 +14,10 @@
namespace webrtc {
SendTimeHistory::SendTimeHistory(int64_t packet_age_limit)
: packet_age_limit_(packet_age_limit), oldest_sequence_number_(0) {
}
SendTimeHistory::SendTimeHistory(Clock* clock, int64_t packet_age_limit)
: clock_(clock),
packet_age_limit_(packet_age_limit),
oldest_sequence_number_(0) {}
SendTimeHistory::~SendTimeHistory() {
}
@ -25,18 +26,21 @@ void SendTimeHistory::Clear() {
history_.clear();
}
void SendTimeHistory::AddAndRemoveOld(const PacketInfo& packet) {
EraseOld(packet.send_time_ms - packet_age_limit_);
void SendTimeHistory::AddAndRemoveOld(uint16_t sequence_number,
size_t length,
bool was_paced) {
EraseOld();
if (history_.empty())
oldest_sequence_number_ = packet.sequence_number;
oldest_sequence_number_ = sequence_number;
history_.insert(
std::pair<uint16_t, PacketInfo>(packet.sequence_number, packet));
history_.insert(std::pair<uint16_t, PacketInfo>(
sequence_number, PacketInfo(clock_->TimeInMilliseconds(), 0, -1,
sequence_number, length, was_paced)));
}
bool SendTimeHistory::UpdateSendTime(uint16_t sequence_number,
int64_t send_time_ms) {
bool SendTimeHistory::OnSentPacket(uint16_t sequence_number,
int64_t send_time_ms) {
auto it = history_.find(sequence_number);
if (it == history_.end())
return false;
@ -44,13 +48,15 @@ bool SendTimeHistory::UpdateSendTime(uint16_t sequence_number,
return true;
}
void SendTimeHistory::EraseOld(int64_t limit) {
void SendTimeHistory::EraseOld() {
while (!history_.empty()) {
auto it = history_.find(oldest_sequence_number_);
assert(it != history_.end());
if (it->second.send_time_ms > limit)
if (clock_->TimeInMilliseconds() - it->second.creation_time_ms <=
packet_age_limit_) {
return; // Oldest packet within age limit, return.
}
// TODO(sprang): Warn if erasing (too many) old items?
history_.erase(it);

170
webrtc/modules/remote_bitrate_estimator/send_time_history_unittest.cc
View File

@ -23,27 +23,39 @@ static const int kDefaultHistoryLengthMs = 1000;
class SendTimeHistoryTest : public ::testing::Test {
protected:
SendTimeHistoryTest() : history_(kDefaultHistoryLengthMs), clock_(0) {}
SendTimeHistoryTest()
: clock_(0), history_(&clock_, kDefaultHistoryLengthMs) {}
~SendTimeHistoryTest() {}
virtual void SetUp() {}
virtual void TearDown() {}
SendTimeHistory history_;
void AddPacketWithSendTime(uint16_t sequence_number,
size_t length,
bool was_paced,
int64_t send_time_ms) {
history_.AddAndRemoveOld(sequence_number, length, was_paced);
history_.OnSentPacket(sequence_number, send_time_ms);
}
webrtc::SimulatedClock clock_;
SendTimeHistory history_;
};
// Help class extended so we can do EXPECT_EQ and collections.
class PacketInfo : public webrtc::PacketInfo {
public:
PacketInfo() : webrtc::PacketInfo(0, 0, 0, 0, false) {}
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(int64_t arrival_time_ms,
int64_t send_time_ms,
uint16_t sequence_number,
size_t payload_size,
bool was_paced)
: webrtc::PacketInfo(arrival_time_ms,
: webrtc::PacketInfo(-1,
arrival_time_ms,
send_time_ms,
sequence_number,
payload_size,
@ -58,40 +70,19 @@ class PacketInfo : public webrtc::PacketInfo {
TEST_F(SendTimeHistoryTest, AddRemoveOne) {
const uint16_t kSeqNo = 10;
const PacketInfo kSentPacket = {0, 1, kSeqNo, 1, true};
history_.AddAndRemoveOld(kSentPacket);
const PacketInfo kSentPacket(0, 1, kSeqNo, 1, true);
AddPacketWithSendTime(kSeqNo, 1, true, 1);
PacketInfo received_packet = {0, 0, kSeqNo, 0, false};
PacketInfo received_packet(0, 0, kSeqNo, 0, false);
EXPECT_TRUE(history_.GetInfo(&received_packet, false));
EXPECT_EQ(kSentPacket, received_packet);
received_packet = {0, 0, kSeqNo, 0, false};
EXPECT_TRUE(history_.GetInfo(&received_packet, true));
EXPECT_EQ(kSentPacket, received_packet);
PacketInfo received_packet2(0, 0, kSeqNo, 0, false);
EXPECT_TRUE(history_.GetInfo(&received_packet2, true));
EXPECT_EQ(kSentPacket, received_packet2);
received_packet = {0, 0, kSeqNo, 0, false};
EXPECT_FALSE(history_.GetInfo(&received_packet, true));
}
TEST_F(SendTimeHistoryTest, UpdateSendTime) {
const uint16_t kSeqNo = 10;
const int64_t kSendTime = 1000;
const int64_t kSendTimeUpdated = 2000;
const PacketInfo kSentPacket = {0, kSendTime, kSeqNo, 1, true};
const PacketInfo kUpdatedPacket = {0, kSendTimeUpdated, kSeqNo, 1, true};
history_.AddAndRemoveOld(kSentPacket);
PacketInfo info = {0, 0, kSeqNo, 0, false};
EXPECT_TRUE(history_.GetInfo(&info, false));
EXPECT_EQ(kSentPacket, info);
EXPECT_TRUE(history_.UpdateSendTime(kSeqNo, kSendTimeUpdated));
info = {0, 0, kSeqNo, 0, false};
EXPECT_TRUE(history_.GetInfo(&info, true));
EXPECT_EQ(kUpdatedPacket, info);
EXPECT_FALSE(history_.UpdateSendTime(kSeqNo, kSendTimeUpdated));
PacketInfo received_packet3(0, 0, kSeqNo, 0, false);
EXPECT_FALSE(history_.GetInfo(&received_packet3, true));
}
TEST_F(SendTimeHistoryTest, PopulatesExpectedFields) {
@ -100,11 +91,10 @@ TEST_F(SendTimeHistoryTest, PopulatesExpectedFields) {
const int64_t kReceiveTime = 2000;
const size_t kPayloadSize = 42;
const bool kPaced = true;
const PacketInfo kSentPacket = {0, kSendTime, kSeqNo, kPayloadSize, kPaced};
history_.AddAndRemoveOld(kSentPacket);
AddPacketWithSendTime(kSeqNo, kPayloadSize, kPaced, kSendTime);
PacketInfo info = {kReceiveTime, 0, kSeqNo, 0, false};
PacketInfo info(kReceiveTime, kSeqNo);
EXPECT_TRUE(history_.GetInfo(&info, true));
EXPECT_EQ(kReceiveTime, info.arrival_time_ms);
EXPECT_EQ(kSendTime, info.send_time_ms);
@ -128,8 +118,14 @@ TEST_F(SendTimeHistoryTest, AddThenRemoveOutOfOrder) {
PacketInfo(static_cast<int64_t>(i) + kTransmissionTime, 0,
static_cast<uint16_t>(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);
}
for (size_t i = 0; i < num_items; ++i)
history_.AddAndRemoveOld(sent_packets[i]);
history_.OnSentPacket(sent_packets[i].sequence_number,
sent_packets[i].send_time_ms);
std::random_shuffle(received_packets.begin(), received_packets.end());
for (size_t i = 0; i < num_items; ++i) {
PacketInfo packet = received_packets[i];
@ -145,54 +141,66 @@ TEST_F(SendTimeHistoryTest, AddThenRemoveOutOfOrder) {
TEST_F(SendTimeHistoryTest, HistorySize) {
const int kItems = kDefaultHistoryLengthMs / 100;
for (int i = 0; i < kItems; ++i)
history_.AddAndRemoveOld(PacketInfo(0, i * 100, i, 0, false));
for (int i = 0; i < kItems; ++i) {
PacketInfo info = {0, 0, static_cast<uint16_t>(i), 0, false};
clock_.AdvanceTimeMilliseconds(100);
AddPacketWithSendTime(i, 0, false, i * 100);
}
for (int i = 0; i < kItems; ++i) {
PacketInfo info(0, 0, static_cast<uint16_t>(i), 0, false);
EXPECT_TRUE(history_.GetInfo(&info, false));
EXPECT_EQ(i * 100, info.send_time_ms);
}
history_.AddAndRemoveOld(PacketInfo(0, kItems * 100, kItems, 0, false));
PacketInfo info = {0, 0, 0, 0, false};
clock_.AdvanceTimeMilliseconds(101);
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) {
info = {0, 0, static_cast<uint16_t>(i), 0, false};
EXPECT_TRUE(history_.GetInfo(&info, false));
EXPECT_EQ(i * 100, info.send_time_ms);
PacketInfo info2(0, 0, static_cast<uint16_t>(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);
}
}
TEST_F(SendTimeHistoryTest, HistorySizeWithWraparound) {
const uint16_t kMaxSeqNo = std::numeric_limits<uint16_t>::max();
history_.AddAndRemoveOld(PacketInfo(0, 0, kMaxSeqNo - 2, 0, false));
history_.AddAndRemoveOld(PacketInfo(0, 100, kMaxSeqNo - 1, 0, false));
history_.AddAndRemoveOld(PacketInfo(0, 200, kMaxSeqNo, 0, false));
history_.AddAndRemoveOld(PacketInfo(0, kDefaultHistoryLengthMs, 0, 0, false));
PacketInfo info = {0, 0, static_cast<uint16_t>(kMaxSeqNo - 2), 0, false};
AddPacketWithSendTime(kMaxSeqNo - 2, 0, false, 0);
clock_.AdvanceTimeMilliseconds(100);
AddPacketWithSendTime(kMaxSeqNo - 1, 1, false, 100);
clock_.AdvanceTimeMilliseconds(100);
AddPacketWithSendTime(kMaxSeqNo, 0, false, 200);
clock_.AdvanceTimeMilliseconds(kDefaultHistoryLengthMs - 200 + 1);
AddPacketWithSendTime(0, 0, false, kDefaultHistoryLengthMs);
PacketInfo info(0, static_cast<uint16_t>(kMaxSeqNo - 2));
EXPECT_FALSE(history_.GetInfo(&info, false));
info = {0, 0, static_cast<uint16_t>(kMaxSeqNo - 1), 0, false};
EXPECT_TRUE(history_.GetInfo(&info, false));
info = {0, 0, static_cast<uint16_t>(kMaxSeqNo), 0, false};
EXPECT_TRUE(history_.GetInfo(&info, false));
info = {0, 0, 0, 0, false};
EXPECT_TRUE(history_.GetInfo(&info, false));
PacketInfo info2(0, static_cast<uint16_t>(kMaxSeqNo - 1));
EXPECT_TRUE(history_.GetInfo(&info2, false));
PacketInfo info3(0, static_cast<uint16_t>(kMaxSeqNo));
EXPECT_TRUE(history_.GetInfo(&info3, false));
PacketInfo info4(0, 0);
EXPECT_TRUE(history_.GetInfo(&info4, false));
// Create a gap (kMaxSeqNo - 1) -> 0.
info = {0, 0, kMaxSeqNo, 0, false};
EXPECT_TRUE(history_.GetInfo(&info, true));
PacketInfo info5(0, kMaxSeqNo);
EXPECT_TRUE(history_.GetInfo(&info5, true));
history_.AddAndRemoveOld(PacketInfo(0, 1100, 1, 0, false));
clock_.AdvanceTimeMilliseconds(100);
AddPacketWithSendTime(1, 0, false, 1100);
info = {0, 0, static_cast<uint16_t>(kMaxSeqNo - 2), 0, false};
EXPECT_FALSE(history_.GetInfo(&info, false));
info = {0, 0, static_cast<uint16_t>(kMaxSeqNo - 1), 0, false};
EXPECT_FALSE(history_.GetInfo(&info, false));
info = {0, 0, kMaxSeqNo, 0, false};
EXPECT_FALSE(history_.GetInfo(&info, false));
info = {0, 0, 0, 0, false};
EXPECT_TRUE(history_.GetInfo(&info, false));
info = {0, 0, 1, 0, false};
EXPECT_TRUE(history_.GetInfo(&info, false));
PacketInfo info6(0, static_cast<uint16_t>(kMaxSeqNo - 2));
EXPECT_FALSE(history_.GetInfo(&info6, false));
PacketInfo info7(0, static_cast<uint16_t>(kMaxSeqNo - 1));
EXPECT_FALSE(history_.GetInfo(&info7, false));
PacketInfo info8(0, kMaxSeqNo);
EXPECT_FALSE(history_.GetInfo(&info8, false));
PacketInfo info9(0, 0);
EXPECT_TRUE(history_.GetInfo(&info9, false));
PacketInfo info10(0, 1);
EXPECT_TRUE(history_.GetInfo(&info10, false));
}
TEST_F(SendTimeHistoryTest, InterlievedGetAndRemove) {
@ -202,22 +210,24 @@ TEST_F(SendTimeHistoryTest, InterlievedGetAndRemove) {
{0, kTimestamp + 1, kSeqNo + 1, 0, false},
{0, kTimestamp + 2, kSeqNo + 2, 0, false}};
history_.AddAndRemoveOld(packets[0]);
history_.AddAndRemoveOld(packets[1]);
PacketInfo info = {0, 0, packets[0].sequence_number, 0, false};
AddPacketWithSendTime(packets[0].sequence_number, packets[0].payload_size,
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);
PacketInfo info(0, 0, packets[0].sequence_number, 0, false);
EXPECT_TRUE(history_.GetInfo(&info, true));
EXPECT_EQ(packets[0], info);
history_.AddAndRemoveOld(packets[2]);
AddPacketWithSendTime(packets[2].sequence_number, packets[2].payload_size,
packets[2].was_paced, packets[2].send_time_ms);
info = {0, 0, packets[1].sequence_number, 0, false};
EXPECT_TRUE(history_.GetInfo(&info, true));
EXPECT_EQ(packets[1], info);
PacketInfo info2(0, 0, packets[1].sequence_number, 0, false);
EXPECT_TRUE(history_.GetInfo(&info2, true));
EXPECT_EQ(packets[1], info2);
info = {0, 0, packets[2].sequence_number, 0, false};
EXPECT_TRUE(history_.GetInfo(&info, true));
EXPECT_EQ(packets[2], info);
PacketInfo info3(0, 0, packets[2].sequence_number, 0, false);
EXPECT_TRUE(history_.GetInfo(&info3, true));
EXPECT_EQ(packets[2], info3);
}
} // namespace test

13
webrtc/modules/remote_bitrate_estimator/test/estimators/send_side.cc
View File

@ -26,7 +26,7 @@ FullBweSender::FullBweSender(int kbps, BitrateObserver* observer, Clock* clock)
rbe_(new RemoteBitrateEstimatorAbsSendTime(this, clock)),
feedback_observer_(bitrate_controller_->CreateRtcpBandwidthObserver()),
clock_(clock),
send_time_history_(10000),
send_time_history_(clock_, 10000),
has_received_ack_(false),
last_acked_seq_num_(0) {
assert(kbps >= kMinBitrateKbps);
@ -92,10 +92,11 @@ void FullBweSender::OnPacketsSent(const Packets& packets) {
for (Packet* packet : packets) {
if (packet->GetPacketType() == Packet::kMedia) {
MediaPacket* media_packet = static_cast<MediaPacket*>(packet);
PacketInfo info(0, media_packet->sender_timestamp_ms(),
media_packet->header().sequenceNumber,
media_packet->payload_size(), packet->paced());
send_time_history_.AddAndRemoveOld(info);
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());
}
}
}
@ -125,7 +126,7 @@ SendSideBweReceiver::~SendSideBweReceiver() {
void SendSideBweReceiver::ReceivePacket(int64_t arrival_time_ms,
const MediaPacket& media_packet) {
packet_feedback_vector_.push_back(PacketInfo(
arrival_time_ms, media_packet.sender_timestamp_ms(),
-1, arrival_time_ms, media_packet.sender_timestamp_ms(),
media_packet.header().sequenceNumber, media_packet.payload_size(), true));
// Log received packet information.

18
webrtc/modules/remote_bitrate_estimator/transport_feedback_adapter.cc
View File

@ -29,7 +29,7 @@ TransportFeedbackAdapter::TransportFeedbackAdapter(
RtcpBandwidthObserver* bandwidth_observer,
Clock* clock,
ProcessThread* process_thread)
: send_time_history_(kSendTimeHistoryWindowMs),
: send_time_history_(clock, kSendTimeHistoryWindowMs),
rtcp_bandwidth_observer_(bandwidth_observer),
process_thread_(process_thread),
clock_(clock),
@ -49,15 +49,17 @@ void TransportFeedbackAdapter::SetBitrateEstimator(
}
}
void TransportFeedbackAdapter::OnSentPacket(const PacketInfo& info) {
void TransportFeedbackAdapter::AddPacket(uint16_t sequence_number,
size_t length,
bool was_paced) {
rtc::CritScope cs(&lock_);
send_time_history_.AddAndRemoveOld(info);
send_time_history_.AddAndRemoveOld(sequence_number, length, was_paced);
}
void TransportFeedbackAdapter::UpdateSendTime(uint16_t sequence_number,
int64_t send_time_ms) {
void TransportFeedbackAdapter::OnSentPacket(uint16_t sequence_number,
int64_t send_time_ms) {
rtc::CritScope cs(&lock_);
send_time_history_.UpdateSendTime(sequence_number, send_time_ms);
send_time_history_.OnSentPacket(sequence_number, send_time_ms);
}
void TransportFeedbackAdapter::OnTransportFeedback(
@ -97,8 +99,8 @@ void TransportFeedbackAdapter::OnTransportFeedback(
RTC_DCHECK(delta_it != delta_vec.end());
offset_us += *(delta_it++);
int64_t timestamp_ms = current_offset_ms_ + (offset_us / 1000);
PacketInfo info = {timestamp_ms, 0, sequence_number, 0, false};
if (send_time_history_.GetInfo(&info, true)) {
PacketInfo info(timestamp_ms, sequence_number);
if (send_time_history_.GetInfo(&info, true) && info.send_time_ms >= 0) {
packet_feedback_vector.push_back(info);
} else {
++failed_lookups;

6
webrtc/modules/remote_bitrate_estimator/transport_feedback_adapter.h
View File

@ -33,9 +33,11 @@ class TransportFeedbackAdapter : public TransportFeedbackObserver,
ProcessThread* process_thread);
virtual ~TransportFeedbackAdapter();
void OnSentPacket(const PacketInfo& info) override;
void AddPacket(uint16_t sequence_number,
size_t length,
bool was_paced) override;
void UpdateSendTime(uint16_t sequence_number, int64_t send_time_ms);
void OnSentPacket(uint16_t sequence_number, int64_t send_time_ms);
void OnTransportFeedback(const rtcp::TransportFeedback& feedback) override;

4
webrtc/modules/remote_bitrate_estimator/transport_feedback_adapter_unittest.cc
View File

@ -105,7 +105,9 @@ class TransportFeedbackAdapterTest : public ::testing::Test {
// Utility method, to reset arrival_time_ms before adding send time.
void OnSentPacket(PacketInfo info) {
info.arrival_time_ms = 0;
adapter_->OnSentPacket(info);
adapter_->AddPacket(info.sequence_number, info.payload_size,
info.was_paced);
adapter_->OnSentPacket(info.sequence_number, info.send_time_ms);
}
SimulatedClock clock_;

26
webrtc/modules/rtp_rtcp/interface/rtp_rtcp_defines.h
View File

@ -281,16 +281,36 @@ class RtcpBandwidthObserver {
};
struct PacketInfo {
PacketInfo(int64_t arrival_time_ms, uint16_t sequence_number)
: 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)
: arrival_time_ms(arrival_time_ms),
: PacketInfo(-1,
arrival_time_ms,
send_time_ms,
sequence_number,
payload_size,
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)
: 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) {}
// Time corresponding to when this object was created.
int64_t creation_time_ms;
// Time corresponding to when the packet was received. Timestamped with the
// receiver's clock.
int64_t arrival_time_ms;
@ -313,7 +333,9 @@ class TransportFeedbackObserver {
// Note: Transport-wide sequence number as sequence number. Arrival time
// must be set to 0.
virtual void OnSentPacket(const PacketInfo& info) = 0;
virtual void AddPacket(uint16_t sequence_number,
size_t length,
bool was_paced) = 0;
virtual void OnTransportFeedback(const rtcp::TransportFeedback& feedback) = 0;
};

6
webrtc/modules/rtp_rtcp/source/rtp_sender.cc
View File

@ -684,8 +684,7 @@ size_t RTPSender::SendPadData(size_t bytes,
break;
if (using_transport_seq && transport_feedback_observer_) {
transport_feedback_observer_->OnSentPacket(
PacketInfo(0, now_ms, options.packet_id, length, true));
transport_feedback_observer_->AddPacket(options.packet_id, length, true);
}
bytes_sent += padding_bytes_in_packet;
@ -947,8 +946,7 @@ bool RTPSender::PrepareAndSendPacket(uint8_t* buffer,
media_has_been_sent_ = true;
}
if (using_transport_seq && transport_feedback_observer_) {
transport_feedback_observer_->OnSentPacket(
PacketInfo(0, now_ms, options.packet_id, length, true));
transport_feedback_observer_->AddPacket(options.packet_id, length, true);
}
UpdateRtpStats(buffer_to_send_ptr, length, rtp_header, send_over_rtx,
is_retransmit);