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

Cleanup ReportBlockData class: use Timestamp and TimeDelta

Browse Source 
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}
This commit is contained in:
Danil Chapovalov 2023-04-12 13:11:21 +02:00 committed by WebRTC LUCI CQ
parent 26d1b26277
commit ec2670e631
10 changed files with 151 additions and 148 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
audio/channel_send.cc
View File

@ -895,7 +895,7 @@ int64_t ChannelSend::GetRTT() const {
// 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(

7
audio/voip/audio_ingress.cc
View File

@ -275,13 +275,10 @@ ChannelStatistics AudioIngress::GetChannelStatistics() {
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.

20
media/engine/webrtc_video_engine_unittest.cc
View File

@ -5867,12 +5867,12 @@ TEST_F(WebRtcVideoChannelTest, GetAggregatedStatsReportForSubStreams) {
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 @@ TEST_F(WebRtcVideoChannelTest, GetPerLayerStatsReportForSubStreams) {
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;

46
modules/rtp_rtcp/include/report_block_data.cc
View File

@ -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_;
}

52
modules/rtp_rtcp/include/report_block_data.h
View File

@ -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 {

25
modules/rtp_rtcp/source/rtcp_receiver.cc
View File

@ -606,33 +606,23 @@ void RTCPReceiver::HandleReportBlock(const ReportBlock& report_block,
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 @@ void RTCPReceiver::HandleReportBlock(const ReportBlock& report_block,
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);
}

20
modules/rtp_rtcp/source/rtcp_receiver_unittest.cc
View File

@ -1584,8 +1584,8 @@ TEST(RtcpReceiverTest,
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 @@ TEST(RtcpReceiverTest, VerifyRttObtainedFromReportBlockDataObserver) {
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 @@ TEST(RtcpReceiverTest, VerifyRttObtainedFromReportBlockDataObserver) {
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) {

8
pc/rtc_stats_collector.cc
View File

@ -851,7 +851,7 @@ ProduceRemoteInboundRtpStreamStatsFromReportBlockData(
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 @@ ProduceRemoteInboundRtpStreamStatsFromReportBlockData(
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();

79
pc/rtc_stats_collector_unittest.cc
View File

@ -3599,31 +3599,29 @@ class RTCStatsCollectorTestWithParamKind
// 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 @@ TEST_P(RTCStatsCollectorTestWithParamKind,
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 @@ TEST_P(RTCStatsCollectorTestWithParamKind,
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,
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,
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 @@ TEST_P(RTCStatsCollectorTestWithParamKind,
// 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,
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;

40
video/send_statistics_proxy_unittest.cc
View File

@ -194,14 +194,14 @@ TEST_F(SendStatisticsProxyTest, ReportBlockDataObserver) {
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 @@ TEST_F(SendStatisticsProxyTest, ReportBlockDataObserver) {
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 @@ TEST_F(SendStatisticsProxyTest, NoSubstreams) {
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 @@ TEST_F(SendStatisticsProxyTest, EncodedResolutionTimesOut) {
// 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