Cleanup ReportBlockData class: use Timestamp and TimeDelta
Bug: webrtc:13757
Change-Id: Ic3ddb05413f58cedd12bf0f32c852befb9bd40f4
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/300940
Reviewed-by: Erik Språng <sprang@webrtc.org>
Reviewed-by: Henrik Boström <hbos@webrtc.org>
Commit-Queue: Danil Chapovalov <danilchap@webrtc.org>
Reviewed-by: Alessio Bazzica <alessiob@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#39841}
diff --git a/audio/channel_send.cc b/audio/channel_send.cc
index 3e734aa..e08dbfb 100644
--- a/audio/channel_send.cc
+++ b/audio/channel_send.cc
@@ -895,7 +895,7 @@
// We don't know in advance the remote ssrc used by the other end's receiver
// reports, so use the first report block for the RTT.
- return report_blocks.front().last_rtt_ms();
+ return report_blocks.front().last_rtt().ms();
}
void ChannelSend::SetFrameEncryptor(
diff --git a/audio/voip/audio_ingress.cc b/audio/voip/audio_ingress.cc
index d2e7c23..d2ea58d 100644
--- a/audio/voip/audio_ingress.cc
+++ b/audio/voip/audio_ingress.cc
@@ -275,13 +275,10 @@
static_cast<double>(rtcp_report.jitter) / clockrate_hz;
}
if (block_data.has_rtt()) {
- remote_stat.round_trip_time =
- static_cast<double>(block_data.last_rtt_ms()) /
- rtc::kNumMillisecsPerSec;
+ remote_stat.round_trip_time = block_data.last_rtt().seconds<double>();
}
remote_stat.last_report_received_timestamp_ms =
- block_data.report_block_timestamp_utc_us() /
- rtc::kNumMicrosecsPerMillisec;
+ block_data.report_block_timestamp_utc().ms();
channel_stats.remote_rtcp = remote_stat;
// Receive only channel won't send any RTP packets.
diff --git a/media/engine/webrtc_video_engine_unittest.cc b/media/engine/webrtc_video_engine_unittest.cc
index 8447c82..cefc0a9 100644
--- a/media/engine/webrtc_video_engine_unittest.cc
+++ b/media/engine/webrtc_video_engine_unittest.cc
@@ -5867,12 +5867,12 @@
substream.rtcp_packet_type_counts.fir_packets = 14;
substream.rtcp_packet_type_counts.nack_packets = 15;
substream.rtcp_packet_type_counts.pli_packets = 16;
- webrtc::RTCPReportBlock report_block;
- report_block.packets_lost = 17;
- report_block.fraction_lost = 18;
+ webrtc::rtcp::ReportBlock report_block;
+ report_block.SetCumulativeLost(17);
+ report_block.SetFractionLost(18);
webrtc::ReportBlockData report_block_data;
- report_block_data.SetReportBlock(report_block, 0);
- report_block_data.AddRoundTripTimeSample(19);
+ report_block_data.SetReportBlock(0, report_block, webrtc::Timestamp::Zero());
+ report_block_data.AddRoundTripTimeSample(webrtc::TimeDelta::Millis(19));
substream.report_block_data = report_block_data;
substream.encode_frame_rate = 20.0;
substream.frames_encoded = 21;
@@ -5993,12 +5993,12 @@
substream.rtcp_packet_type_counts.fir_packets = 14;
substream.rtcp_packet_type_counts.nack_packets = 15;
substream.rtcp_packet_type_counts.pli_packets = 16;
- webrtc::RTCPReportBlock report_block;
- report_block.packets_lost = 17;
- report_block.fraction_lost = 18;
+ webrtc::rtcp::ReportBlock report_block;
+ report_block.SetCumulativeLost(17);
+ report_block.SetFractionLost(18);
webrtc::ReportBlockData report_block_data;
- report_block_data.SetReportBlock(report_block, 0);
- report_block_data.AddRoundTripTimeSample(19);
+ report_block_data.SetReportBlock(0, report_block, webrtc::Timestamp::Zero());
+ report_block_data.AddRoundTripTimeSample(webrtc::TimeDelta::Millis(19));
substream.report_block_data = report_block_data;
substream.encode_frame_rate = 20.0;
substream.frames_encoded = 21;
diff --git a/modules/rtp_rtcp/include/report_block_data.cc b/modules/rtp_rtcp/include/report_block_data.cc
index ec4d9d8..81f1b01 100644
--- a/modules/rtp_rtcp/include/report_block_data.cc
+++ b/modules/rtp_rtcp/include/report_block_data.cc
@@ -12,32 +12,34 @@
namespace webrtc {
-ReportBlockData::ReportBlockData()
- : report_block_(),
- report_block_timestamp_utc_us_(0),
- last_rtt_ms_(0),
- min_rtt_ms_(0),
- max_rtt_ms_(0),
- sum_rtt_ms_(0),
- num_rtts_(0) {}
-
-double ReportBlockData::AvgRttMs() const {
- return num_rtts_ ? static_cast<double>(sum_rtt_ms_) / num_rtts_ : 0.0;
+TimeDelta ReportBlockData::AvgRtt() const {
+ return num_rtts_ > 0 ? sum_rtt_ / num_rtts_ : TimeDelta::Zero();
}
-void ReportBlockData::SetReportBlock(RTCPReportBlock report_block,
- int64_t report_block_timestamp_utc_us) {
- report_block_ = report_block;
- report_block_timestamp_utc_us_ = report_block_timestamp_utc_us;
+void ReportBlockData::SetReportBlock(uint32_t sender_ssrc,
+ const rtcp::ReportBlock& report_block,
+ Timestamp report_block_timestamp_utc) {
+ report_block_.sender_ssrc = sender_ssrc;
+ report_block_.source_ssrc = report_block.source_ssrc();
+ report_block_.fraction_lost = report_block.fraction_lost();
+ report_block_.packets_lost = report_block.cumulative_lost_signed();
+ report_block_.extended_highest_sequence_number =
+ report_block.extended_high_seq_num();
+ report_block_.jitter = report_block.jitter();
+ report_block_.delay_since_last_sender_report =
+ report_block.delay_since_last_sr();
+ report_block_.last_sender_report_timestamp = report_block.last_sr();
+
+ report_block_timestamp_utc_ = report_block_timestamp_utc;
}
-void ReportBlockData::AddRoundTripTimeSample(int64_t rtt_ms) {
- if (rtt_ms > max_rtt_ms_)
- max_rtt_ms_ = rtt_ms;
- if (num_rtts_ == 0 || rtt_ms < min_rtt_ms_)
- min_rtt_ms_ = rtt_ms;
- last_rtt_ms_ = rtt_ms;
- sum_rtt_ms_ += rtt_ms;
+void ReportBlockData::AddRoundTripTimeSample(TimeDelta rtt) {
+ if (rtt > max_rtt_)
+ max_rtt_ = rtt;
+ if (num_rtts_ == 0 || rtt < min_rtt_)
+ min_rtt_ = rtt;
+ last_rtt_ = rtt;
+ sum_rtt_ += rtt;
++num_rtts_;
}
diff --git a/modules/rtp_rtcp/include/report_block_data.h b/modules/rtp_rtcp/include/report_block_data.h
index 2c4533a..fa556cf 100644
--- a/modules/rtp_rtcp/include/report_block_data.h
+++ b/modules/rtp_rtcp/include/report_block_data.h
@@ -11,40 +11,56 @@
#ifndef MODULES_RTP_RTCP_INCLUDE_REPORT_BLOCK_DATA_H_
#define MODULES_RTP_RTCP_INCLUDE_REPORT_BLOCK_DATA_H_
+#include "api/units/time_delta.h"
+#include "api/units/timestamp.h"
#include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
+#include "modules/rtp_rtcp/source/rtcp_packet/report_block.h"
namespace webrtc {
class ReportBlockData {
public:
- ReportBlockData();
+ ReportBlockData() = default;
+
+ ReportBlockData(const ReportBlockData&) = default;
+ ReportBlockData& operator=(const ReportBlockData&) = default;
const RTCPReportBlock& report_block() const { return report_block_; }
- int64_t report_block_timestamp_utc_us() const {
- return report_block_timestamp_utc_us_;
+
+ [[deprecated]] int64_t report_block_timestamp_utc_us() const {
+ return report_block_timestamp_utc_.us();
}
- int64_t last_rtt_ms() const { return last_rtt_ms_; }
- int64_t min_rtt_ms() const { return min_rtt_ms_; }
- int64_t max_rtt_ms() const { return max_rtt_ms_; }
- int64_t sum_rtt_ms() const { return sum_rtt_ms_; }
+ [[deprecated]] int64_t last_rtt_ms() const { return last_rtt_.ms(); }
+ [[deprecated]] int64_t min_rtt_ms() const { return min_rtt_.ms(); }
+ [[deprecated]] int64_t max_rtt_ms() const { return max_rtt_.ms(); }
+ [[deprecated]] int64_t sum_rtt_ms() const { return sum_rtt_.ms(); }
+ [[deprecated]] double AvgRttMs() const { return AvgRtt().ms<double>(); }
+
+ Timestamp report_block_timestamp_utc() const {
+ return report_block_timestamp_utc_;
+ }
+ TimeDelta last_rtt() const { return last_rtt_; }
+ TimeDelta min_rtt() const { return min_rtt_; }
+ TimeDelta max_rtt() const { return max_rtt_; }
+ TimeDelta sum_rtts() const { return sum_rtt_; }
size_t num_rtts() const { return num_rtts_; }
bool has_rtt() const { return num_rtts_ != 0; }
- double AvgRttMs() const;
+ TimeDelta AvgRtt() const;
- void SetReportBlock(RTCPReportBlock report_block,
- int64_t report_block_timestamp_utc_us);
- void AddRoundTripTimeSample(int64_t rtt_ms);
+ void SetReportBlock(uint32_t sender_ssrc,
+ const rtcp::ReportBlock& report_block,
+ Timestamp report_block_timestamp_utc_us);
+ void AddRoundTripTimeSample(TimeDelta rtt);
private:
RTCPReportBlock report_block_;
- int64_t report_block_timestamp_utc_us_;
-
- int64_t last_rtt_ms_;
- int64_t min_rtt_ms_;
- int64_t max_rtt_ms_;
- int64_t sum_rtt_ms_;
- size_t num_rtts_;
+ Timestamp report_block_timestamp_utc_ = Timestamp::Zero();
+ TimeDelta last_rtt_ = TimeDelta::Zero();
+ TimeDelta min_rtt_ = TimeDelta::Zero();
+ TimeDelta max_rtt_ = TimeDelta::Zero();
+ TimeDelta sum_rtt_ = TimeDelta::Zero();
+ size_t num_rtts_ = 0;
};
class ReportBlockDataObserver {
diff --git a/modules/rtp_rtcp/source/rtcp_receiver.cc b/modules/rtp_rtcp/source/rtcp_receiver.cc
index 69fd1f6..5f53c58 100644
--- a/modules/rtp_rtcp/source/rtcp_receiver.cc
+++ b/modules/rtp_rtcp/source/rtcp_receiver.cc
@@ -606,33 +606,23 @@
if (!registered_ssrcs_.contains(report_block.source_ssrc()))
return;
- last_received_rb_ = clock_->CurrentTime();
+ Timestamp now = clock_->CurrentTime();
+ last_received_rb_ = now;
ReportBlockData* report_block_data =
&received_report_blocks_[report_block.source_ssrc()];
- RTCPReportBlock rtcp_report_block;
- rtcp_report_block.sender_ssrc = remote_ssrc;
- rtcp_report_block.source_ssrc = report_block.source_ssrc();
- rtcp_report_block.fraction_lost = report_block.fraction_lost();
- rtcp_report_block.packets_lost = report_block.cumulative_lost_signed();
if (report_block.extended_high_seq_num() >
report_block_data->report_block().extended_highest_sequence_number) {
// We have successfully delivered new RTP packets to the remote side after
// the last RR was sent from the remote side.
last_increased_sequence_number_ = last_received_rb_;
}
- rtcp_report_block.extended_highest_sequence_number =
- report_block.extended_high_seq_num();
- rtcp_report_block.jitter = report_block.jitter();
- rtcp_report_block.delay_since_last_sender_report =
- report_block.delay_since_last_sr();
- rtcp_report_block.last_sender_report_timestamp = report_block.last_sr();
+ NtpTime now_ntp = clock_->ConvertTimestampToNtpTime(now);
// Number of seconds since 1900 January 1 00:00 GMT (see
// https://tools.ietf.org/html/rfc868).
report_block_data->SetReportBlock(
- rtcp_report_block,
- (clock_->CurrentNtpInMilliseconds() - rtc::kNtpJan1970Millisecs) *
- rtc::kNumMicrosecsPerMillisec);
+ remote_ssrc, report_block,
+ Timestamp::Millis(now_ntp.ToMs() - rtc::kNtpJan1970Millisecs));
uint32_t send_time_ntp = report_block.last_sr();
// RFC3550, section 6.4.1, LSR field discription states:
@@ -642,14 +632,13 @@
if (send_time_ntp != 0) {
uint32_t delay_ntp = report_block.delay_since_last_sr();
// Local NTP time.
- uint32_t receive_time_ntp =
- CompactNtp(clock_->ConvertTimestampToNtpTime(last_received_rb_));
+ uint32_t receive_time_ntp = CompactNtp(now_ntp);
// RTT in 1/(2^16) seconds.
uint32_t rtt_ntp = receive_time_ntp - delay_ntp - send_time_ntp;
// Convert to 1/1000 seconds (milliseconds).
TimeDelta rtt = CompactNtpRttToTimeDelta(rtt_ntp);
- report_block_data->AddRoundTripTimeSample(rtt.ms());
+ report_block_data->AddRoundTripTimeSample(rtt);
if (report_block.source_ssrc() == local_media_ssrc()) {
rtts_[remote_ssrc].AddRtt(rtt);
}
diff --git a/modules/rtp_rtcp/source/rtcp_receiver_unittest.cc b/modules/rtp_rtcp/source/rtcp_receiver_unittest.cc
index b64363a..a1a3467 100644
--- a/modules/rtp_rtcp/source/rtcp_receiver_unittest.cc
+++ b/modules/rtp_rtcp/source/rtcp_receiver_unittest.cc
@@ -1584,8 +1584,8 @@
EXPECT_EQ(rtcp_block.extended_high_seq_num(),
report_block.extended_highest_sequence_number);
EXPECT_EQ(rtcp_block.jitter(), report_block.jitter);
- EXPECT_EQ(kNtpNowMs * rtc::kNumMicrosecsPerMillisec,
- report_block_data.report_block_timestamp_utc_us());
+ EXPECT_EQ(report_block_data.report_block_timestamp_utc(),
+ Timestamp::Millis(kNtpNowMs));
// No RTT is calculated in this test.
EXPECT_EQ(0u, report_block_data.num_rtts());
});
@@ -1602,8 +1602,12 @@
RTCPReceiver receiver(config, &mocks.rtp_rtcp_impl);
receiver.SetRemoteSSRC(kSenderSsrc);
- const TimeDelta kRtt = TimeDelta::Millis(120);
- const uint32_t kDelayNtp = 123000;
+ // To avoid issues with rounding due to different way to represent time units,
+ // use RTT that can be precisly represented both with
+ // TimeDelta units (i.e. integer number of microseconds), and
+ // ntp units (i.e. integer number of 2^(-32) seconds)
+ const TimeDelta kRtt = TimeDelta::Millis(125);
+ const uint32_t kDelayNtp = 123'000;
const TimeDelta kDelay = CompactNtpRttToTimeDelta(kDelayNtp);
uint32_t sent_ntp = CompactNtp(mocks.clock.CurrentNtpTime());
@@ -1628,10 +1632,10 @@
EXPECT_EQ(kReceiverMainSsrc,
report_block_data.report_block().source_ssrc);
EXPECT_EQ(1u, report_block_data.num_rtts());
- EXPECT_EQ(kRtt.ms(), report_block_data.min_rtt_ms());
- EXPECT_EQ(kRtt.ms(), report_block_data.max_rtt_ms());
- EXPECT_EQ(kRtt.ms(), report_block_data.sum_rtt_ms());
- EXPECT_EQ(kRtt.ms(), report_block_data.last_rtt_ms());
+ EXPECT_EQ(kRtt, report_block_data.min_rtt());
+ EXPECT_EQ(kRtt, report_block_data.max_rtt());
+ EXPECT_EQ(kRtt, report_block_data.sum_rtts());
+ EXPECT_EQ(kRtt, report_block_data.last_rtt());
});
EXPECT_CALL(observer, OnReportBlockDataUpdated)
.WillOnce([](ReportBlockData report_block_data) {
diff --git a/pc/rtc_stats_collector.cc b/pc/rtc_stats_collector.cc
index 574e1cc..4303581 100644
--- a/pc/rtc_stats_collector.cc
+++ b/pc/rtc_stats_collector.cc
@@ -851,7 +851,7 @@
auto remote_inbound = std::make_unique<RTCRemoteInboundRtpStreamStats>(
RTCRemoteInboundRtpStreamStatsIdFromSourceSsrc(media_type,
report_block.source_ssrc),
- Timestamp::Micros(report_block_data.report_block_timestamp_utc_us()));
+ report_block_data.report_block_timestamp_utc());
remote_inbound->ssrc = report_block.source_ssrc;
remote_inbound->kind =
media_type == cricket::MEDIA_TYPE_AUDIO ? "audio" : "video";
@@ -860,12 +860,10 @@
static_cast<double>(report_block.fraction_lost) / (1 << 8);
if (report_block_data.num_rtts() > 0) {
remote_inbound->round_trip_time =
- static_cast<double>(report_block_data.last_rtt_ms()) /
- rtc::kNumMillisecsPerSec;
+ report_block_data.last_rtt().seconds<double>();
}
remote_inbound->total_round_trip_time =
- static_cast<double>(report_block_data.sum_rtt_ms()) /
- rtc::kNumMillisecsPerSec;
+ report_block_data.sum_rtts().seconds<double>();
remote_inbound->round_trip_time_measurements =
report_block_data.num_rtts();
diff --git a/pc/rtc_stats_collector_unittest.cc b/pc/rtc_stats_collector_unittest.cc
index 304272c..e18af6f 100644
--- a/pc/rtc_stats_collector_unittest.cc
+++ b/pc/rtc_stats_collector_unittest.cc
@@ -3599,31 +3599,29 @@
// RTCCodecStats (codecId, jitter) and without setting up an RTCP transport.
TEST_P(RTCStatsCollectorTestWithParamKind,
RTCRemoteInboundRtpStreamStatsCollectedFromReportBlock) {
- const int64_t kReportBlockTimestampUtcUs = 123456789;
+ const Timestamp kReportBlockTimestampUtc = Timestamp::Micros(123456789);
const uint8_t kFractionLost = 12;
- const int64_t kRoundTripTimeSample1Ms = 1234;
- const double kRoundTripTimeSample1Seconds = 1.234;
- const int64_t kRoundTripTimeSample2Ms = 13000;
- const double kRoundTripTimeSample2Seconds = 13;
+ const TimeDelta kRoundTripTimeSample1 = TimeDelta::Millis(1'234);
+ const TimeDelta kRoundTripTimeSample2 = TimeDelta::Seconds(13);
// The report block's timestamp cannot be from the future, set the fake clock
// to match.
- fake_clock_.SetTime(Timestamp::Micros(kReportBlockTimestampUtcUs));
+ fake_clock_.SetTime(kReportBlockTimestampUtc);
auto ssrcs = {12, 13};
std::vector<ReportBlockData> report_block_datas;
for (auto ssrc : ssrcs) {
- RTCPReportBlock report_block;
+ rtcp::ReportBlock report_block;
// The remote-inbound-rtp SSRC and the outbound-rtp SSRC is the same as the
// `source_ssrc`, "SSRC of the RTP packet sender".
- report_block.source_ssrc = ssrc;
- report_block.packets_lost = 7;
- report_block.fraction_lost = kFractionLost;
+ report_block.SetMediaSsrc(ssrc);
+ report_block.SetCumulativeLost(7);
+ report_block.SetFractionLost(kFractionLost);
ReportBlockData report_block_data;
- report_block_data.SetReportBlock(report_block, kReportBlockTimestampUtcUs);
- report_block_data.AddRoundTripTimeSample(kRoundTripTimeSample1Ms);
+ report_block_data.SetReportBlock(0, report_block, kReportBlockTimestampUtc);
+ report_block_data.AddRoundTripTimeSample(kRoundTripTimeSample1);
// Only the last sample should be exposed as the
// `RTCRemoteInboundRtpStreamStats::round_trip_time`.
- report_block_data.AddRoundTripTimeSample(kRoundTripTimeSample2Ms);
+ report_block_data.AddRoundTripTimeSample(kRoundTripTimeSample2);
report_block_datas.push_back(report_block_data);
}
AddSenderInfoAndMediaChannel("TransportName", report_block_datas,
@@ -3633,8 +3631,7 @@
for (auto ssrc : ssrcs) {
std::string stream_id = "" + std::to_string(ssrc);
RTCRemoteInboundRtpStreamStats expected_remote_inbound_rtp(
- "RI" + MediaTypeCharStr() + stream_id,
- Timestamp::Micros(kReportBlockTimestampUtcUs));
+ "RI" + MediaTypeCharStr() + stream_id, kReportBlockTimestampUtc);
expected_remote_inbound_rtp.ssrc = ssrc;
expected_remote_inbound_rtp.fraction_lost =
static_cast<double>(kFractionLost) / (1 << 8);
@@ -3645,9 +3642,10 @@
expected_remote_inbound_rtp.packets_lost = 7;
expected_remote_inbound_rtp.local_id =
"OTTransportName1" + MediaTypeCharStr() + stream_id;
- expected_remote_inbound_rtp.round_trip_time = kRoundTripTimeSample2Seconds;
+ expected_remote_inbound_rtp.round_trip_time =
+ kRoundTripTimeSample2.seconds<double>();
expected_remote_inbound_rtp.total_round_trip_time =
- kRoundTripTimeSample1Seconds + kRoundTripTimeSample2Seconds;
+ (kRoundTripTimeSample1 + kRoundTripTimeSample2).seconds<double>();
expected_remote_inbound_rtp.round_trip_time_measurements = 2;
// This test does not set up RTCCodecStats, so `codec_id` and `jitter` are
// expected to be missing. These are tested separately.
@@ -3668,14 +3666,14 @@
TEST_P(RTCStatsCollectorTestWithParamKind,
RTCRemoteInboundRtpStreamStatsRttMissingBeforeMeasurement) {
- constexpr int64_t kReportBlockTimestampUtcUs = 123456789;
+ constexpr Timestamp kReportBlockTimestampUtc = Timestamp::Micros(123456789);
- RTCPReportBlock report_block;
+ rtcp::ReportBlock report_block;
// The remote-inbound-rtp SSRC and the outbound-rtp SSRC is the same as the
// `source_ssrc`, "SSRC of the RTP packet sender".
- report_block.source_ssrc = 12;
+ report_block.SetMediaSsrc(12);
ReportBlockData report_block_data; // AddRoundTripTimeSample() not called.
- report_block_data.SetReportBlock(report_block, kReportBlockTimestampUtcUs);
+ report_block_data.SetReportBlock(0, report_block, kReportBlockTimestampUtc);
AddSenderInfoAndMediaChannel("TransportName", {report_block_data},
absl::nullopt);
@@ -3694,15 +3692,15 @@
TEST_P(RTCStatsCollectorTestWithParamKind,
RTCRemoteInboundRtpStreamStatsWithTimestampFromReportBlock) {
- const int64_t kReportBlockTimestampUtcUs = 123456789;
- fake_clock_.SetTime(Timestamp::Micros(kReportBlockTimestampUtcUs));
+ const Timestamp kReportBlockTimestampUtc = Timestamp::Micros(123456789);
+ fake_clock_.SetTime(kReportBlockTimestampUtc);
- RTCPReportBlock report_block;
+ rtcp::ReportBlock report_block;
// The remote-inbound-rtp SSRC and the outbound-rtp SSRC is the same as the
// `source_ssrc`, "SSRC of the RTP packet sender".
- report_block.source_ssrc = 12;
+ report_block.SetMediaSsrc(12);
ReportBlockData report_block_data;
- report_block_data.SetReportBlock(report_block, kReportBlockTimestampUtcUs);
+ report_block_data.SetReportBlock(0, report_block, kReportBlockTimestampUtc);
AddSenderInfoAndMediaChannel("TransportName", {report_block_data},
absl::nullopt);
@@ -3719,24 +3717,23 @@
// Even though the report time is different, the remote-inbound-rtp timestamp
// is of the time that the report block was received.
- EXPECT_EQ(Timestamp::Micros(kReportBlockTimestampUtcUs + 1234),
- report->timestamp());
- EXPECT_EQ(Timestamp::Micros(kReportBlockTimestampUtcUs),
- remote_inbound_rtp.timestamp());
+ EXPECT_EQ(report->timestamp(),
+ kReportBlockTimestampUtc + TimeDelta::Micros(1234));
+ EXPECT_EQ(remote_inbound_rtp.timestamp(), kReportBlockTimestampUtc);
}
TEST_P(RTCStatsCollectorTestWithParamKind,
RTCRemoteInboundRtpStreamStatsWithCodecBasedMembers) {
- const int64_t kReportBlockTimestampUtcUs = 123456789;
- fake_clock_.SetTime(Timestamp::Micros(kReportBlockTimestampUtcUs));
+ const Timestamp kReportBlockTimestampUtc = Timestamp::Micros(123456789);
+ fake_clock_.SetTime(kReportBlockTimestampUtc);
- RTCPReportBlock report_block;
+ rtcp::ReportBlock report_block;
// The remote-inbound-rtp SSRC and the outbound-rtp SSRC is the same as the
// `source_ssrc`, "SSRC of the RTP packet sender".
- report_block.source_ssrc = 12;
- report_block.jitter = 5000;
+ report_block.SetMediaSsrc(12);
+ report_block.SetJitter(5000);
ReportBlockData report_block_data;
- report_block_data.SetReportBlock(report_block, kReportBlockTimestampUtcUs);
+ report_block_data.SetReportBlock(0, report_block, kReportBlockTimestampUtc);
RtpCodecParameters codec;
codec.payload_type = 3;
@@ -3763,15 +3760,15 @@
TEST_P(RTCStatsCollectorTestWithParamKind,
RTCRemoteInboundRtpStreamStatsWithRtcpTransport) {
- const int64_t kReportBlockTimestampUtcUs = 123456789;
- fake_clock_.SetTime(Timestamp::Micros(kReportBlockTimestampUtcUs));
+ const Timestamp kReportBlockTimestampUtc = Timestamp::Micros(123456789);
+ fake_clock_.SetTime(kReportBlockTimestampUtc);
- RTCPReportBlock report_block;
+ rtcp::ReportBlock report_block;
// The remote-inbound-rtp SSRC and the outbound-rtp SSRC is the same as the
// `source_ssrc`, "SSRC of the RTP packet sender".
- report_block.source_ssrc = 12;
+ report_block.SetMediaSsrc(12);
ReportBlockData report_block_data;
- report_block_data.SetReportBlock(report_block, kReportBlockTimestampUtcUs);
+ report_block_data.SetReportBlock(0, report_block, kReportBlockTimestampUtc);
cricket::TransportChannelStats rtp_transport_channel_stats;
rtp_transport_channel_stats.component = cricket::ICE_CANDIDATE_COMPONENT_RTP;
diff --git a/video/send_statistics_proxy_unittest.cc b/video/send_statistics_proxy_unittest.cc
index 9230579..d3d14d6 100644
--- a/video/send_statistics_proxy_unittest.cc
+++ b/video/send_statistics_proxy_unittest.cc
@@ -194,14 +194,14 @@
for (uint32_t ssrc : config_.rtp.ssrcs) {
// Add statistics with some arbitrary, but unique, numbers.
uint32_t offset = ssrc * 4;
- RTCPReportBlock report_block;
- report_block.source_ssrc = ssrc;
- report_block.packets_lost = offset;
- report_block.extended_highest_sequence_number = offset + 1;
- report_block.fraction_lost = offset + 2;
- report_block.jitter = offset + 3;
+ rtcp::ReportBlock report_block;
+ report_block.SetMediaSsrc(ssrc);
+ report_block.SetCumulativeLost(offset);
+ report_block.SetExtHighestSeqNum(offset + 1);
+ report_block.SetFractionLost(offset + 2);
+ report_block.SetJitter(offset + 3);
ReportBlockData data;
- data.SetReportBlock(report_block, 0);
+ data.SetReportBlock(/*sender_ssrc=*/0, report_block, Timestamp::Zero());
expected_.substreams[ssrc].report_block_data = data;
callback->OnReportBlockDataUpdated(data);
@@ -209,14 +209,14 @@
for (uint32_t ssrc : config_.rtp.rtx.ssrcs) {
// Add statistics with some arbitrary, but unique, numbers.
uint32_t offset = ssrc * 4;
- RTCPReportBlock report_block;
- report_block.source_ssrc = ssrc;
- report_block.packets_lost = offset;
- report_block.extended_highest_sequence_number = offset + 1;
- report_block.fraction_lost = offset + 2;
- report_block.jitter = offset + 3;
+ rtcp::ReportBlock report_block;
+ report_block.SetMediaSsrc(ssrc);
+ report_block.SetCumulativeLost(offset);
+ report_block.SetExtHighestSeqNum(offset + 1);
+ report_block.SetFractionLost(offset + 2);
+ report_block.SetJitter(offset + 3);
ReportBlockData data;
- data.SetReportBlock(report_block, 0);
+ data.SetReportBlock(/*sender_ssrc=*/0, report_block, Timestamp::Zero());
expected_.substreams[ssrc].report_block_data = data;
callback->OnReportBlockDataUpdated(data);
@@ -2311,10 +2311,10 @@
1;
// From ReportBlockDataObserver.
ReportBlockDataObserver* rtcp_callback = statistics_proxy_.get();
- RTCPReportBlock report_block;
- report_block.source_ssrc = excluded_ssrc;
+ rtcp::ReportBlock report_block;
+ report_block.SetMediaSsrc(excluded_ssrc);
ReportBlockData data;
- data.SetReportBlock(report_block, 0);
+ data.SetReportBlock(0, report_block, Timestamp::Zero());
rtcp_callback->OnReportBlockDataUpdated(data);
// From BitrateStatisticsObserver.
@@ -2363,10 +2363,10 @@
// Update the first SSRC with bogus RTCP stats to make sure that encoded
// resolution still times out (no global timeout for all stats).
ReportBlockDataObserver* rtcp_callback = statistics_proxy_.get();
- RTCPReportBlock report_block;
- report_block.source_ssrc = config_.rtp.ssrcs[0];
+ rtcp::ReportBlock report_block;
+ report_block.SetMediaSsrc(config_.rtp.ssrcs[0]);
ReportBlockData data;
- data.SetReportBlock(report_block, 0);
+ data.SetReportBlock(0, report_block, Timestamp::Zero());
rtcp_callback->OnReportBlockDataUpdated(data);
// Report stats for second SSRC to make sure it's not outdated along with the
