diff --git a/audio/channel_send.cc b/audio/channel_send.cc index 3e734aab45..e08dbfbb2f 100644 --- a/audio/channel_send.cc +++ b/audio/channel_send.cc @@ -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( diff --git a/audio/voip/audio_ingress.cc b/audio/voip/audio_ingress.cc index d2e7c2396a..d2ea58da91 100644 --- a/audio/voip/audio_ingress.cc +++ b/audio/voip/audio_ingress.cc @@ -275,13 +275,10 @@ ChannelStatistics AudioIngress::GetChannelStatistics() { static_cast(rtcp_report.jitter) / clockrate_hz; } if (block_data.has_rtt()) { - remote_stat.round_trip_time = - static_cast(block_data.last_rtt_ms()) / - rtc::kNumMillisecsPerSec; + remote_stat.round_trip_time = block_data.last_rtt().seconds(); } 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 8447c82ac4..cefc0a9857 100644 --- a/media/engine/webrtc_video_engine_unittest.cc +++ b/media/engine/webrtc_video_engine_unittest.cc @@ -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; diff --git a/modules/rtp_rtcp/include/report_block_data.cc b/modules/rtp_rtcp/include/report_block_data.cc index ec4d9d82e0..81f1b0108a 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(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 2c4533ada8..fa556cf8e7 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(); } + + 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 69fd1f6f07..5f53c5823c 100644 --- a/modules/rtp_rtcp/source/rtcp_receiver.cc +++ b/modules/rtp_rtcp/source/rtcp_receiver.cc @@ -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); } diff --git a/modules/rtp_rtcp/source/rtcp_receiver_unittest.cc b/modules/rtp_rtcp/source/rtcp_receiver_unittest.cc index b64363a87c..a1a346718f 100644 --- a/modules/rtp_rtcp/source/rtcp_receiver_unittest.cc +++ b/modules/rtp_rtcp/source/rtcp_receiver_unittest.cc @@ -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) { diff --git a/pc/rtc_stats_collector.cc b/pc/rtc_stats_collector.cc index 574e1cc6ec..4303581299 100644 --- a/pc/rtc_stats_collector.cc +++ b/pc/rtc_stats_collector.cc @@ -851,7 +851,7 @@ ProduceRemoteInboundRtpStreamStatsFromReportBlockData( auto remote_inbound = std::make_unique( 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(report_block.fraction_lost) / (1 << 8); if (report_block_data.num_rtts() > 0) { remote_inbound->round_trip_time = - static_cast(report_block_data.last_rtt_ms()) / - rtc::kNumMillisecsPerSec; + report_block_data.last_rtt().seconds(); } remote_inbound->total_round_trip_time = - static_cast(report_block_data.sum_rtt_ms()) / - rtc::kNumMillisecsPerSec; + report_block_data.sum_rtts().seconds(); 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 304272c6cc..e18af6f019 100644 --- a/pc/rtc_stats_collector_unittest.cc +++ b/pc/rtc_stats_collector_unittest.cc @@ -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 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(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(); expected_remote_inbound_rtp.total_round_trip_time = - kRoundTripTimeSample1Seconds + kRoundTripTimeSample2Seconds; + (kRoundTripTimeSample1 + kRoundTripTimeSample2).seconds(); 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; diff --git a/video/send_statistics_proxy_unittest.cc b/video/send_statistics_proxy_unittest.cc index 923057907a..d3d14d6859 100644 --- a/video/send_statistics_proxy_unittest.cc +++ b/video/send_statistics_proxy_unittest.cc @@ -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