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

Revert "Improve outbound-rtp statistics for simulcast"

Browse Source 
This reverts commit da6cda839dac7d9d18eba8d365188fa94831e0b1.

Reason for revert: Breaks googRtt in legacy getStats API

Original change's description:
> Improve outbound-rtp statistics for simulcast
> 
> Bug: webrtc:9547
> Change-Id: Iec4eb976aa11ee743805425bedb77dcea7c2c9be
> Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/168120
> Reviewed-by: Sebastian Jansson <srte@webrtc.org>
> Reviewed-by: Erik Språng <sprang@webrtc.org>
> Reviewed-by: Henrik Boström <hbos@webrtc.org>
> Reviewed-by: Harald Alvestrand <hta@webrtc.org>
> Commit-Queue: Eldar Rello <elrello@microsoft.com>
> Cr-Commit-Position: refs/heads/master@{#31097}

TBR=hbos@webrtc.org,sprang@webrtc.org,stefan@webrtc.org,srte@webrtc.org,hta@webrtc.org,elrello@microsoft.com

# Not skipping CQ checks because original CL landed > 1 day ago.

Bug: webrtc:9547
Change-Id: I06673328c2a5293a7eef03b3aaf2ded9d13df1b3
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/174443
Reviewed-by: Henrik Boström <hbos@webrtc.org>
Commit-Queue: Henrik Boström <hbos@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#31165}
This commit is contained in:
Henrik Boström 2020-05-05 12:20:01 +02:00 committed by Commit Bot
parent 49f574b3b3
commit 9a925c9ce3
23 changed files with 150 additions and 789 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
api/peer_connection_interface.h
View File

@ -666,8 +666,6 @@ class RTC_EXPORT PeerConnectionInterface : public rtc::RefCountInterface {
// Whether network condition based codec switching is allowed.
absl::optional<bool> allow_codec_switching;
bool enable_simulcast_stats = true;
//
// Don't forget to update operator== if adding something.
//

6
api/stats/rtcstats_objects.h
View File

@ -469,7 +469,6 @@ class RTC_EXPORT RTCOutboundRTPStreamStats final : public RTCRTPStreamStats {
RTCStatsMember<std::string> media_source_id;
RTCStatsMember<std::string> remote_id;
RTCStatsMember<std::string> rid;
RTCStatsMember<uint32_t> packets_sent;
RTCStatsMember<uint64_t> retransmitted_packets_sent;
RTCStatsMember<uint64_t> bytes_sent;
@ -481,11 +480,6 @@ class RTC_EXPORT RTCOutboundRTPStreamStats final : public RTCRTPStreamStats {
RTCStatsMember<uint32_t> key_frames_encoded;
RTCStatsMember<double> total_encode_time;
RTCStatsMember<uint64_t> total_encoded_bytes_target;
RTCStatsMember<uint32_t> frame_width;
RTCStatsMember<uint32_t> frame_height;
RTCStatsMember<double> frames_per_second;
RTCStatsMember<uint32_t> frames_sent;
RTCStatsMember<uint32_t> huge_frames_sent;
// TODO(https://crbug.com/webrtc/10635): This is only implemented for video;
// implement it for audio as well.
RTCStatsMember<double> total_packet_send_delay;

11
call/rtp_config.cc
View File

@ -189,15 +189,4 @@ uint32_t RtpConfig::GetMediaSsrcAssociatedWithFlexfecSsrc(
return media_ssrc;
}
absl::optional<std::string> RtpConfig::GetRidForSsrc(uint32_t ssrc) const {
auto it = std::find(ssrcs.begin(), ssrcs.end(), ssrc);
if (it != ssrcs.end()) {
size_t ssrc_index = std::distance(ssrcs.begin(), it);
if (ssrc_index < rids.size()) {
return rids[ssrc_index];
}
}
return absl::nullopt;
}
} // namespace webrtc

1
call/rtp_config.h
View File

@ -166,7 +166,6 @@ struct RtpConfig {
uint32_t media_ssrc) const;
uint32_t GetMediaSsrcAssociatedWithRtxSsrc(uint32_t rtx_ssrc) const;
uint32_t GetMediaSsrcAssociatedWithFlexfecSsrc(uint32_t flexfec_ssrc) const;
absl::optional<std::string> GetRidForSsrc(uint32_t ssrc) const;
};
} // namespace webrtc
#endif // CALL_RTP_CONFIG_H_

8
call/video_send_stream.h
View File

@ -83,12 +83,6 @@ class VideoSendStream {
// A snapshot of the most recent Report Block with additional data of
// interest to statistics. Used to implement RTCRemoteInboundRtpStreamStats.
absl::optional<ReportBlockData> report_block_data;
double encode_frame_rate = 0.0;
int frames_encoded = 0;
absl::optional<uint64_t> qp_sum;
uint64_t total_encode_time_ms = 0;
uint64_t total_encoded_bytes_target = 0;
uint32_t huge_frames_sent = 0;
};
struct Stats {
@ -110,6 +104,7 @@ class VideoSendStream {
uint32_t frames_dropped_by_rate_limiter = 0;
uint32_t frames_dropped_by_congestion_window = 0;
uint32_t frames_dropped_by_encoder = 0;
absl::optional<uint64_t> qp_sum;
// Bitrate the encoder is currently configured to use due to bandwidth
// limitations.
int target_media_bitrate_bps = 0;
@ -135,7 +130,6 @@ class VideoSendStream {
std::map<uint32_t, StreamStats> substreams;
webrtc::VideoContentType content_type =
webrtc::VideoContentType::UNSPECIFIED;
uint32_t frames_sent = 0;
uint32_t huge_frames_sent = 0;
};

13
media/base/media_channel.h
View File

@ -569,7 +569,6 @@ struct VideoSenderInfo : public MediaSenderInfo {
int send_frame_height = 0;
int framerate_input = 0;
int framerate_sent = 0;
int aggregated_framerate_sent = 0;
int nominal_bitrate = 0;
int adapt_reason = 0;
int adapt_changes = 0;
@ -593,11 +592,8 @@ struct VideoSenderInfo : public MediaSenderInfo {
bool has_entered_low_resolution = false;
absl::optional<uint64_t> qp_sum;
webrtc::VideoContentType content_type = webrtc::VideoContentType::UNSPECIFIED;
uint32_t frames_sent = 0;
// https://w3c.github.io/webrtc-stats/#dom-rtcvideosenderstats-hugeframessent
uint32_t huge_frames_sent = 0;
uint32_t aggregated_huge_frames_sent = 0;
absl::optional<std::string> rid;
};
struct VideoReceiverInfo : public MediaReceiverInfo {
@ -717,20 +713,11 @@ struct VideoMediaInfo {
~VideoMediaInfo();
void Clear() {
senders.clear();
aggregated_senders.clear();
receivers.clear();
send_codecs.clear();
receive_codecs.clear();
}
// Each sender info represents one "outbound-rtp" stream.In non - simulcast,
// this means one info per RtpSender but if simulcast is used this means
// one info per simulcast layer.
std::vector<VideoSenderInfo> senders;
// Used for legacy getStats() API's "ssrc" stats and modern getStats() API's
// "track" stats. If simulcast is used, instead of having one sender info per
// simulcast layer, the metrics of all layers of an RtpSender are aggregated
// into a single sender info per RtpSender.
std::vector<VideoSenderInfo> aggregated_senders;
std::vector<VideoReceiverInfo> receivers;
RtpCodecParametersMap send_codecs;
RtpCodecParametersMap receive_codecs;

219
media/engine/webrtc_video_engine.cc
View File

@ -1583,12 +1583,8 @@ void WebRtcVideoChannel::FillSenderStats(VideoMediaInfo* video_media_info,
for (std::map<uint32_t, WebRtcVideoSendStream*>::iterator it =
send_streams_.begin();
it != send_streams_.end(); ++it) {
auto infos = it->second->GetPerLayerVideoSenderInfos(log_stats);
video_media_info->aggregated_senders.push_back(
it->second->GetAggregatedVideoSenderInfo(infos));
for (auto&& info : infos) {
video_media_info->senders.push_back(info);
}
video_media_info->senders.push_back(
it->second->GetVideoSenderInfo(log_stats));
}
}
@ -2478,161 +2474,108 @@ void WebRtcVideoChannel::WebRtcVideoSendStream::AddOrUpdateSink(
});
}
}
std::vector<VideoSenderInfo>
WebRtcVideoChannel::WebRtcVideoSendStream::GetPerLayerVideoSenderInfos(
VideoSenderInfo WebRtcVideoChannel::WebRtcVideoSendStream::GetVideoSenderInfo(
bool log_stats) {
VideoSenderInfo info;
RTC_DCHECK_RUN_ON(&thread_checker_);
VideoSenderInfo common_info;
for (uint32_t ssrc : parameters_.config.rtp.ssrcs)
info.add_ssrc(ssrc);
if (parameters_.codec_settings) {
common_info.codec_name = parameters_.codec_settings->codec.name;
common_info.codec_payload_type = parameters_.codec_settings->codec.id;
info.codec_name = parameters_.codec_settings->codec.name;
info.codec_payload_type = parameters_.codec_settings->codec.id;
}
std::vector<VideoSenderInfo> infos;
webrtc::VideoSendStream::Stats stats;
if (stream_ == nullptr) {
for (uint32_t ssrc : parameters_.config.rtp.ssrcs) {
common_info.add_ssrc(ssrc);
}
infos.push_back(common_info);
return infos;
} else {
stats = stream_->GetStats();
if (log_stats)
RTC_LOG(LS_INFO) << stats.ToString(rtc::TimeMillis());
// Metrics that are in common for all substreams.
common_info.adapt_changes = stats.number_of_cpu_adapt_changes;
common_info.adapt_reason =
stats.cpu_limited_resolution ? ADAPTREASON_CPU : ADAPTREASON_NONE;
common_info.has_entered_low_resolution = stats.has_entered_low_resolution;
if (stream_ == NULL)
return info;
// Get bandwidth limitation info from stream_->GetStats().
// Input resolution (output from video_adapter) can be further scaled down
// or higher video layer(s) can be dropped due to bitrate constraints.
// Note, adapt_changes only include changes from the video_adapter.
if (stats.bw_limited_resolution)
common_info.adapt_reason |= ADAPTREASON_BANDWIDTH;
webrtc::VideoSendStream::Stats stats = stream_->GetStats();
common_info.quality_limitation_reason = stats.quality_limitation_reason;
common_info.quality_limitation_durations_ms =
stats.quality_limitation_durations_ms;
common_info.quality_limitation_resolution_changes =
stats.quality_limitation_resolution_changes;
common_info.encoder_implementation_name = stats.encoder_implementation_name;
common_info.ssrc_groups = ssrc_groups_;
common_info.framerate_input = stats.input_frame_rate;
common_info.avg_encode_ms = stats.avg_encode_time_ms;
common_info.encode_usage_percent = stats.encode_usage_percent;
common_info.nominal_bitrate = stats.media_bitrate_bps;
common_info.content_type = stats.content_type;
common_info.aggregated_framerate_sent = stats.encode_frame_rate;
common_info.aggregated_huge_frames_sent = stats.huge_frames_sent;
if (log_stats)
RTC_LOG(LS_INFO) << stats.ToString(rtc::TimeMillis());
// If we don't have any substreams, get the remaining metrics from |stats|.
// Otherwise, these values are obtained from |sub_stream| below.
if (stats.substreams.empty()) {
for (uint32_t ssrc : parameters_.config.rtp.ssrcs) {
common_info.add_ssrc(ssrc);
}
common_info.framerate_sent = stats.encode_frame_rate;
common_info.frames_encoded = stats.frames_encoded;
common_info.total_encode_time_ms = stats.total_encode_time_ms;
common_info.total_encoded_bytes_target = stats.total_encoded_bytes_target;
common_info.frames_sent = stats.frames_encoded;
common_info.huge_frames_sent = stats.huge_frames_sent;
infos.push_back(common_info);
return infos;
}
info.adapt_changes = stats.number_of_cpu_adapt_changes;
info.adapt_reason =
stats.cpu_limited_resolution ? ADAPTREASON_CPU : ADAPTREASON_NONE;
info.has_entered_low_resolution = stats.has_entered_low_resolution;
// Get bandwidth limitation info from stream_->GetStats().
// Input resolution (output from video_adapter) can be further scaled down or
// higher video layer(s) can be dropped due to bitrate constraints.
// Note, adapt_changes only include changes from the video_adapter.
if (stats.bw_limited_resolution)
info.adapt_reason |= ADAPTREASON_BANDWIDTH;
info.quality_limitation_reason = stats.quality_limitation_reason;
info.quality_limitation_durations_ms = stats.quality_limitation_durations_ms;
info.quality_limitation_resolution_changes =
stats.quality_limitation_resolution_changes;
info.encoder_implementation_name = stats.encoder_implementation_name;
info.ssrc_groups = ssrc_groups_;
info.framerate_input = stats.input_frame_rate;
info.framerate_sent = stats.encode_frame_rate;
info.avg_encode_ms = stats.avg_encode_time_ms;
info.encode_usage_percent = stats.encode_usage_percent;
info.frames_encoded = stats.frames_encoded;
// TODO(bugs.webrtc.org/9547): Populate individual outbound-rtp stats objects
// for each simulcast stream, instead of accumulating all keyframes encoded
// over all simulcast streams in the same outbound-rtp stats object.
info.key_frames_encoded = 0;
for (const auto& kv : stats.substreams) {
info.key_frames_encoded += kv.second.frame_counts.key_frames;
}
auto outbound_rtp_substreams =
MergeInfoAboutOutboundRtpSubstreams(stats.substreams);
info.total_encode_time_ms = stats.total_encode_time_ms;
info.total_encoded_bytes_target = stats.total_encoded_bytes_target;
info.qp_sum = stats.qp_sum;
info.nominal_bitrate = stats.media_bitrate_bps;
info.content_type = stats.content_type;
info.huge_frames_sent = stats.huge_frames_sent;
info.send_frame_width = 0;
info.send_frame_height = 0;
info.total_packet_send_delay_ms = 0;
std::map<uint32_t, webrtc::VideoSendStream::StreamStats>
outbound_rtp_substreams =
MergeInfoAboutOutboundRtpSubstreams(stats.substreams);
for (const auto& pair : outbound_rtp_substreams) {
auto info = common_info;
info.add_ssrc(pair.first);
info.rid = parameters_.config.rtp.GetRidForSsrc(pair.first);
auto stream_stats = pair.second;
// TODO(pbos): Wire up additional stats, such as padding bytes.
const webrtc::VideoSendStream::StreamStats& stream_stats = pair.second;
RTC_DCHECK_EQ(stream_stats.type,
webrtc::VideoSendStream::StreamStats::StreamType::kMedia);
info.payload_bytes_sent = stream_stats.rtp_stats.transmitted.payload_bytes;
info.header_and_padding_bytes_sent =
info.payload_bytes_sent += stream_stats.rtp_stats.transmitted.payload_bytes;
info.header_and_padding_bytes_sent +=
stream_stats.rtp_stats.transmitted.header_bytes +
stream_stats.rtp_stats.transmitted.padding_bytes;
info.packets_sent = stream_stats.rtp_stats.transmitted.packets;
info.packets_sent += stream_stats.rtp_stats.transmitted.packets;
info.total_packet_send_delay_ms += stream_stats.total_packet_send_delay_ms;
info.send_frame_width = stream_stats.width;
info.send_frame_height = stream_stats.height;
info.key_frames_encoded = stream_stats.frame_counts.key_frames;
info.framerate_sent = stream_stats.encode_frame_rate;
info.frames_encoded = stream_stats.frames_encoded;
info.frames_sent = stream_stats.frames_encoded;
info.retransmitted_bytes_sent =
info.retransmitted_bytes_sent +=
stream_stats.rtp_stats.retransmitted.payload_bytes;
info.retransmitted_packets_sent =
info.retransmitted_packets_sent +=
stream_stats.rtp_stats.retransmitted.packets;
info.packets_lost = stream_stats.rtcp_stats.packets_lost;
info.firs_rcvd = stream_stats.rtcp_packet_type_counts.fir_packets;
info.nacks_rcvd = stream_stats.rtcp_packet_type_counts.nack_packets;
info.plis_rcvd = stream_stats.rtcp_packet_type_counts.pli_packets;
info.packets_lost += stream_stats.rtcp_stats.packets_lost;
if (stream_stats.width > info.send_frame_width)
info.send_frame_width = stream_stats.width;
if (stream_stats.height > info.send_frame_height)
info.send_frame_height = stream_stats.height;
info.firs_rcvd += stream_stats.rtcp_packet_type_counts.fir_packets;
info.nacks_rcvd += stream_stats.rtcp_packet_type_counts.nack_packets;
info.plis_rcvd += stream_stats.rtcp_packet_type_counts.pli_packets;
if (stream_stats.report_block_data.has_value()) {
info.report_block_datas.push_back(stream_stats.report_block_data.value());
}
}
if (!stats.substreams.empty()) {
// TODO(pbos): Report fraction lost per SSRC.
webrtc::VideoSendStream::StreamStats first_stream_stats =
stats.substreams.begin()->second;
info.fraction_lost =
static_cast<float>(stream_stats.rtcp_stats.fraction_lost) / (1 << 8);
info.qp_sum = stream_stats.qp_sum;
info.total_encode_time_ms = stream_stats.total_encode_time_ms;
info.total_encoded_bytes_target = stream_stats.total_encoded_bytes_target;
info.huge_frames_sent = stream_stats.huge_frames_sent;
infos.push_back(info);
static_cast<float>(first_stream_stats.rtcp_stats.fraction_lost) /
(1 << 8);
}
return infos;
}
VideoSenderInfo
WebRtcVideoChannel::WebRtcVideoSendStream::GetAggregatedVideoSenderInfo(
const std::vector<VideoSenderInfo>& infos) const {
RTC_DCHECK_RUN_ON(&thread_checker_);
RTC_DCHECK(!infos.empty());
if (infos.size() == 1) {
return infos[0];
}
VideoSenderInfo info = infos[0];
info.local_stats.clear();
for (uint32_t ssrc : parameters_.config.rtp.ssrcs) {
info.add_ssrc(ssrc);
}
info.framerate_sent = info.aggregated_framerate_sent;
info.huge_frames_sent = info.aggregated_huge_frames_sent;
for (size_t i = 1; i < infos.size(); i++) {
info.key_frames_encoded += infos[i].key_frames_encoded;
info.payload_bytes_sent += infos[i].payload_bytes_sent;
info.header_and_padding_bytes_sent +=
infos[i].header_and_padding_bytes_sent;
info.packets_sent += infos[i].packets_sent;
info.total_packet_send_delay_ms += infos[i].total_packet_send_delay_ms;
info.retransmitted_bytes_sent += infos[i].retransmitted_bytes_sent;
info.retransmitted_packets_sent += infos[i].retransmitted_packets_sent;
info.packets_lost += infos[i].packets_lost;
if (infos[i].send_frame_width > info.send_frame_width)
info.send_frame_width = infos[i].send_frame_width;
if (infos[i].send_frame_height > info.send_frame_height)
info.send_frame_height = infos[i].send_frame_height;
info.firs_rcvd += infos[i].firs_rcvd;
info.nacks_rcvd += infos[i].nacks_rcvd;
info.plis_rcvd += infos[i].plis_rcvd;
if (infos[i].report_block_datas.size())
info.report_block_datas.push_back(infos[i].report_block_datas[0]);
if (infos[i].qp_sum) {
if (!info.qp_sum) {
info.qp_sum = 0;
}
info.qp_sum = *info.qp_sum + *infos[i].qp_sum;
}
info.frames_encoded += infos[i].frames_encoded;
info.frames_sent += infos[i].frames_sent;
info.total_encode_time_ms += infos[i].total_encode_time_ms;
info.total_encoded_bytes_target += infos[i].total_encoded_bytes_target;
}
return info;
}

7
media/engine/webrtc_video_engine.h
View File

@ -357,12 +357,7 @@ class WebRtcVideoChannel : public VideoMediaChannel,
void SetSend(bool send);
const std::vector<uint32_t>& GetSsrcs() const;
// Returns per ssrc VideoSenderInfos. Useful for simulcast scenario.
std::vector<VideoSenderInfo> GetPerLayerVideoSenderInfos(bool log_stats);
// Aggregates per ssrc VideoSenderInfos to single VideoSenderInfo for
// legacy reasons. Used in old GetStats API and track stats.
VideoSenderInfo GetAggregatedVideoSenderInfo(
const std::vector<VideoSenderInfo>& infos) const;
VideoSenderInfo GetVideoSenderInfo(bool log_stats);
void FillBitrateInfo(BandwidthEstimationInfo* bwe_info);
void SetEncoderToPacketizerFrameTransformer(

433
media/engine/webrtc_video_engine_unittest.cc
View File

@ -2425,18 +2425,6 @@ class WebRtcVideoChannelTest : public WebRtcVideoEngineTest {
ASSERT_TRUE(channel_->SetSendParameters(send_parameters_));
}
cricket::VideoCodec GetEngineCodec(const std::string& name) {
for (const cricket::VideoCodec& engine_codec : engine_.send_codecs()) {
if (absl::EqualsIgnoreCase(name, engine_codec.name))
return engine_codec;
}
// This point should never be reached.
ADD_FAILURE() << "Unrecognized codec name: " << name;
return cricket::VideoCodec();
}
cricket::VideoCodec DefaultCodec() { return GetEngineCodec("VP8"); }
protected:
FakeVideoSendStream* AddSendStream() {
return AddSendStream(StreamParams::CreateLegacy(++last_ssrc_));
@ -5230,369 +5218,21 @@ TEST_F(WebRtcVideoChannelTest, GetStatsReportsKeyFramesEncoded) {
cricket::VideoMediaInfo info;
ASSERT_TRUE(channel_->GetStats(&info));
EXPECT_EQ(info.senders.size(), 2u);
EXPECT_EQ(10u, info.senders[0].key_frames_encoded);
EXPECT_EQ(87u, info.senders[1].key_frames_encoded);
EXPECT_EQ(97u, info.aggregated_senders[0].key_frames_encoded);
// TODO(bugs.webrtc.org/9547): Populate individual outbound-rtp stats objects
// for each simulcast stream, instead of accumulating all keyframes encoded
// over all simulcast streams in the same outbound-rtp stats object.
EXPECT_EQ(97u, info.senders[0].key_frames_encoded);
}
TEST_F(WebRtcVideoChannelTest, GetStatsReportsPerLayerQpSum) {
TEST_F(WebRtcVideoChannelTest, GetStatsReportsQpSum) {
FakeVideoSendStream* stream = AddSendStream();
webrtc::VideoSendStream::Stats stats;
stats.substreams[123].qp_sum = 15;
stats.substreams[456].qp_sum = 11;
stats.qp_sum = 13;
stream->SetStats(stats);
cricket::VideoMediaInfo info;
ASSERT_TRUE(channel_->GetStats(&info));
EXPECT_EQ(info.senders.size(), 2u);
EXPECT_EQ(stats.substreams[123].qp_sum, info.senders[0].qp_sum);
EXPECT_EQ(stats.substreams[456].qp_sum, info.senders[1].qp_sum);
EXPECT_EQ(*info.aggregated_senders[0].qp_sum, 26u);
}
webrtc::VideoSendStream::Stats GetInitialisedStats() {
webrtc::VideoSendStream::Stats stats;
stats.encoder_implementation_name = "vp";
stats.input_frame_rate = 1;
stats.encode_frame_rate = 2;
stats.avg_encode_time_ms = 3;
stats.encode_usage_percent = 4;
stats.frames_encoded = 5;
stats.total_encode_time_ms = 6;
stats.frames_dropped_by_capturer = 7;
stats.frames_dropped_by_encoder_queue = 8;
stats.frames_dropped_by_rate_limiter = 9;
stats.frames_dropped_by_congestion_window = 10;
stats.frames_dropped_by_encoder = 11;
stats.target_media_bitrate_bps = 13;
stats.media_bitrate_bps = 14;
stats.suspended = true;
stats.bw_limited_resolution = true;
stats.cpu_limited_resolution = true;
// Not wired.
stats.bw_limited_framerate = true;
// Not wired.
stats.cpu_limited_framerate = true;
stats.quality_limitation_reason = webrtc::QualityLimitationReason::kCpu;
stats.quality_limitation_durations_ms[webrtc::QualityLimitationReason::kCpu] =
15;
stats.quality_limitation_resolution_changes = 16;
stats.number_of_cpu_adapt_changes = 17;
stats.number_of_quality_adapt_changes = 18;
stats.has_entered_low_resolution = true;
stats.content_type = webrtc::VideoContentType::SCREENSHARE;
stats.frames_sent = 19;
stats.huge_frames_sent = 20;
return stats;
}
TEST_F(WebRtcVideoChannelTest, GetAggregatedStatsReportWithoutSubStreams) {
FakeVideoSendStream* stream = AddSendStream();
auto stats = GetInitialisedStats();
stream->SetStats(stats);
cricket::VideoMediaInfo video_media_info;
ASSERT_TRUE(channel_->GetStats(&video_media_info));
EXPECT_EQ(video_media_info.aggregated_senders.size(), 1u);
auto& sender = video_media_info.aggregated_senders[0];
// MediaSenderInfo
EXPECT_EQ(sender.payload_bytes_sent, 0);
EXPECT_EQ(sender.header_and_padding_bytes_sent, 0);
EXPECT_EQ(sender.retransmitted_bytes_sent, 0u);
EXPECT_EQ(sender.packets_sent, 0);
EXPECT_EQ(sender.retransmitted_packets_sent, 0u);
EXPECT_EQ(sender.packets_lost, 0);
EXPECT_EQ(sender.fraction_lost, 0.0f);
EXPECT_EQ(sender.rtt_ms, 0);
EXPECT_EQ(sender.codec_name, DefaultCodec().name);
EXPECT_EQ(sender.codec_payload_type, DefaultCodec().id);
EXPECT_EQ(sender.local_stats.size(), 1u);
EXPECT_EQ(sender.local_stats[0].ssrc, last_ssrc_);
EXPECT_EQ(sender.local_stats[0].timestamp, 0.0f);
EXPECT_EQ(sender.remote_stats.size(), 0u);
EXPECT_EQ(sender.report_block_datas.size(), 0u);
// VideoSenderInfo
EXPECT_EQ(sender.ssrc_groups.size(), 0u);
EXPECT_EQ(sender.encoder_implementation_name,
stats.encoder_implementation_name);
// Comes from substream only.
EXPECT_EQ(sender.firs_rcvd, 0);
EXPECT_EQ(sender.plis_rcvd, 0);
EXPECT_EQ(sender.nacks_rcvd, 0);
EXPECT_EQ(sender.send_frame_width, 0);
EXPECT_EQ(sender.send_frame_height, 0);
EXPECT_EQ(sender.framerate_input, stats.input_frame_rate);
EXPECT_EQ(sender.framerate_sent, stats.encode_frame_rate);
EXPECT_EQ(sender.nominal_bitrate, stats.media_bitrate_bps);
EXPECT_NE(sender.adapt_reason & WebRtcVideoChannel::ADAPTREASON_CPU, 0);
EXPECT_NE(sender.adapt_reason & WebRtcVideoChannel::ADAPTREASON_BANDWIDTH, 0);
EXPECT_EQ(sender.adapt_changes, stats.number_of_cpu_adapt_changes);
EXPECT_EQ(sender.quality_limitation_reason, stats.quality_limitation_reason);
EXPECT_EQ(sender.quality_limitation_durations_ms,
stats.quality_limitation_durations_ms);
EXPECT_EQ(sender.quality_limitation_resolution_changes,
stats.quality_limitation_resolution_changes);
EXPECT_EQ(sender.avg_encode_ms, stats.avg_encode_time_ms);
EXPECT_EQ(sender.encode_usage_percent, stats.encode_usage_percent);
EXPECT_EQ(sender.frames_encoded, stats.frames_encoded);
// Comes from substream only.
EXPECT_EQ(sender.key_frames_encoded, 0u);
EXPECT_EQ(sender.total_encode_time_ms, stats.total_encode_time_ms);
EXPECT_EQ(sender.total_encoded_bytes_target,
stats.total_encoded_bytes_target);
// Comes from substream only.
EXPECT_EQ(sender.total_packet_send_delay_ms, 0u);
EXPECT_EQ(sender.qp_sum, absl::nullopt);
EXPECT_EQ(sender.has_entered_low_resolution,
stats.has_entered_low_resolution);
EXPECT_EQ(sender.content_type, webrtc::VideoContentType::SCREENSHARE);
EXPECT_EQ(sender.frames_sent, stats.frames_encoded);
EXPECT_EQ(sender.huge_frames_sent, stats.huge_frames_sent);
EXPECT_EQ(sender.rid, absl::nullopt);
}
TEST_F(WebRtcVideoChannelTest, GetAggregatedStatsReportForSubStreams) {
FakeVideoSendStream* stream = AddSendStream();
auto stats = GetInitialisedStats();
const uint32_t ssrc_1 = 123u;
const uint32_t ssrc_2 = 456u;
auto& substream = stats.substreams[ssrc_1];
substream.frame_counts.key_frames = 1;
substream.frame_counts.delta_frames = 2;
substream.width = 3;
substream.height = 4;
substream.total_bitrate_bps = 5;
substream.retransmit_bitrate_bps = 6;
substream.avg_delay_ms = 7;
substream.max_delay_ms = 8;
substream.total_packet_send_delay_ms = 9;
substream.rtp_stats.transmitted.header_bytes = 10;
substream.rtp_stats.transmitted.padding_bytes = 11;
substream.rtp_stats.retransmitted.payload_bytes = 12;
substream.rtp_stats.retransmitted.packets = 13;
substream.rtcp_packet_type_counts.fir_packets = 14;
substream.rtcp_packet_type_counts.nack_packets = 15;
substream.rtcp_packet_type_counts.pli_packets = 16;
substream.rtcp_stats.packets_lost = 17;
substream.rtcp_stats.fraction_lost = 18;
webrtc::ReportBlockData report_block_data;
report_block_data.AddRoundTripTimeSample(19);
substream.report_block_data = report_block_data;
substream.encode_frame_rate = 20.0;
substream.frames_encoded = 21;
substream.qp_sum = 22;
substream.total_encode_time_ms = 23;
substream.total_encoded_bytes_target = 24;
substream.huge_frames_sent = 25;
stats.substreams[ssrc_2] = substream;
stream->SetStats(stats);
cricket::VideoMediaInfo video_media_info;
ASSERT_TRUE(channel_->GetStats(&video_media_info));
EXPECT_EQ(video_media_info.aggregated_senders.size(), 1u);
auto& sender = video_media_info.aggregated_senders[0];
// MediaSenderInfo
EXPECT_EQ(
sender.payload_bytes_sent,
static_cast<int64_t>(2u * substream.rtp_stats.transmitted.payload_bytes));
EXPECT_EQ(sender.header_and_padding_bytes_sent,
static_cast<int64_t>(
2u * (substream.rtp_stats.transmitted.header_bytes +
substream.rtp_stats.transmitted.padding_bytes)));
EXPECT_EQ(sender.retransmitted_bytes_sent,
2u * substream.rtp_stats.retransmitted.payload_bytes);
EXPECT_EQ(sender.packets_sent,
static_cast<int>(2 * substream.rtp_stats.transmitted.packets));
EXPECT_EQ(sender.retransmitted_packets_sent,
2u * substream.rtp_stats.retransmitted.packets);
EXPECT_EQ(sender.packets_lost, 2 * substream.rtcp_stats.packets_lost);
EXPECT_EQ(sender.fraction_lost,
static_cast<float>(substream.rtcp_stats.fraction_lost) / (1 << 8));
EXPECT_EQ(sender.rtt_ms, 0);
EXPECT_EQ(sender.codec_name, DefaultCodec().name);
EXPECT_EQ(sender.codec_payload_type, DefaultCodec().id);
EXPECT_EQ(sender.local_stats.size(), 1u);
EXPECT_EQ(sender.local_stats[0].ssrc, last_ssrc_);
EXPECT_EQ(sender.local_stats[0].timestamp, 0.0f);
EXPECT_EQ(sender.remote_stats.size(), 0u);
EXPECT_EQ(sender.report_block_datas.size(), 2u * 1);
// VideoSenderInfo
EXPECT_EQ(sender.ssrc_groups.size(), 0u);
EXPECT_EQ(sender.encoder_implementation_name,
stats.encoder_implementation_name);
EXPECT_EQ(
sender.firs_rcvd,
static_cast<int>(2 * substream.rtcp_packet_type_counts.fir_packets));
EXPECT_EQ(
sender.plis_rcvd,
static_cast<int>(2 * substream.rtcp_packet_type_counts.pli_packets));
EXPECT_EQ(
sender.nacks_rcvd,
static_cast<int>(2 * substream.rtcp_packet_type_counts.nack_packets));
EXPECT_EQ(sender.send_frame_width, substream.width);
EXPECT_EQ(sender.send_frame_height, substream.height);
EXPECT_EQ(sender.framerate_input, stats.input_frame_rate);
EXPECT_EQ(sender.framerate_sent, stats.encode_frame_rate);
EXPECT_EQ(sender.nominal_bitrate, stats.media_bitrate_bps);
EXPECT_NE(sender.adapt_reason & WebRtcVideoChannel::ADAPTREASON_CPU, 0);
EXPECT_NE(sender.adapt_reason & WebRtcVideoChannel::ADAPTREASON_BANDWIDTH, 0);
EXPECT_EQ(sender.adapt_changes, stats.number_of_cpu_adapt_changes);
EXPECT_EQ(sender.quality_limitation_reason, stats.quality_limitation_reason);
EXPECT_EQ(sender.quality_limitation_durations_ms,
stats.quality_limitation_durations_ms);
EXPECT_EQ(sender.quality_limitation_resolution_changes,
stats.quality_limitation_resolution_changes);
EXPECT_EQ(sender.avg_encode_ms, stats.avg_encode_time_ms);
EXPECT_EQ(sender.encode_usage_percent, stats.encode_usage_percent);
EXPECT_EQ(sender.frames_encoded, 2u * substream.frames_encoded);
EXPECT_EQ(sender.key_frames_encoded, 2u * substream.frame_counts.key_frames);
EXPECT_EQ(sender.total_encode_time_ms, 2u * substream.total_encode_time_ms);
EXPECT_EQ(sender.total_encoded_bytes_target,
2u * substream.total_encoded_bytes_target);
EXPECT_EQ(sender.total_packet_send_delay_ms,
2u * substream.total_packet_send_delay_ms);
EXPECT_EQ(sender.has_entered_low_resolution,
stats.has_entered_low_resolution);
EXPECT_EQ(sender.qp_sum, 2u * *substream.qp_sum);
EXPECT_EQ(sender.content_type, webrtc::VideoContentType::SCREENSHARE);
EXPECT_EQ(sender.frames_sent, 2u * substream.frames_encoded);
EXPECT_EQ(sender.huge_frames_sent, stats.huge_frames_sent);
EXPECT_EQ(sender.rid, absl::nullopt);
}
TEST_F(WebRtcVideoChannelTest, GetPerLayerStatsReportForSubStreams) {
FakeVideoSendStream* stream = AddSendStream();
auto stats = GetInitialisedStats();
const uint32_t ssrc_1 = 123u;
const uint32_t ssrc_2 = 456u;
auto& substream = stats.substreams[ssrc_1];
substream.frame_counts.key_frames = 1;
substream.frame_counts.delta_frames = 2;
substream.width = 3;
substream.height = 4;
substream.total_bitrate_bps = 5;
substream.retransmit_bitrate_bps = 6;
substream.avg_delay_ms = 7;
substream.max_delay_ms = 8;
substream.total_packet_send_delay_ms = 9;
substream.rtp_stats.transmitted.header_bytes = 10;
substream.rtp_stats.transmitted.padding_bytes = 11;
substream.rtp_stats.retransmitted.payload_bytes = 12;
substream.rtp_stats.retransmitted.packets = 13;
substream.rtcp_packet_type_counts.fir_packets = 14;
substream.rtcp_packet_type_counts.nack_packets = 15;
substream.rtcp_packet_type_counts.pli_packets = 16;
substream.rtcp_stats.packets_lost = 17;
substream.rtcp_stats.fraction_lost = 18;
webrtc::ReportBlockData report_block_data;
report_block_data.AddRoundTripTimeSample(19);
substream.report_block_data = report_block_data;
substream.encode_frame_rate = 20.0;
substream.frames_encoded = 21;
substream.qp_sum = 22;
substream.total_encode_time_ms = 23;
substream.total_encoded_bytes_target = 24;
substream.huge_frames_sent = 25;
stats.substreams[ssrc_2] = substream;
stream->SetStats(stats);
cricket::VideoMediaInfo video_media_info;
ASSERT_TRUE(channel_->GetStats(&video_media_info));
EXPECT_EQ(video_media_info.senders.size(), 2u);
auto& sender = video_media_info.senders[0];
// MediaSenderInfo
EXPECT_EQ(
sender.payload_bytes_sent,
static_cast<int64_t>(substream.rtp_stats.transmitted.payload_bytes));
EXPECT_EQ(
sender.header_and_padding_bytes_sent,
static_cast<int64_t>(substream.rtp_stats.transmitted.header_bytes +
substream.rtp_stats.transmitted.padding_bytes));
EXPECT_EQ(sender.retransmitted_bytes_sent,
substream.rtp_stats.retransmitted.payload_bytes);
EXPECT_EQ(sender.packets_sent,
static_cast<int>(substream.rtp_stats.transmitted.packets));
EXPECT_EQ(sender.retransmitted_packets_sent,
substream.rtp_stats.retransmitted.packets);
EXPECT_EQ(sender.packets_lost, substream.rtcp_stats.packets_lost);
EXPECT_EQ(sender.fraction_lost,
static_cast<float>(substream.rtcp_stats.fraction_lost) / (1 << 8));
EXPECT_EQ(sender.rtt_ms, 0);
EXPECT_EQ(sender.codec_name, DefaultCodec().name);
EXPECT_EQ(sender.codec_payload_type, DefaultCodec().id);
EXPECT_EQ(sender.local_stats.size(), 1u);
EXPECT_EQ(sender.local_stats[0].ssrc, ssrc_1);
EXPECT_EQ(sender.local_stats[0].timestamp, 0.0f);
EXPECT_EQ(sender.remote_stats.size(), 0u);
EXPECT_EQ(sender.report_block_datas.size(), 1u);
// VideoSenderInfo
EXPECT_EQ(sender.ssrc_groups.size(), 0u);
EXPECT_EQ(sender.encoder_implementation_name,
stats.encoder_implementation_name);
EXPECT_EQ(sender.firs_rcvd,
static_cast<int>(substream.rtcp_packet_type_counts.fir_packets));
EXPECT_EQ(sender.plis_rcvd,
static_cast<int>(substream.rtcp_packet_type_counts.pli_packets));
EXPECT_EQ(sender.nacks_rcvd,
static_cast<int>(substream.rtcp_packet_type_counts.nack_packets));
EXPECT_EQ(sender.send_frame_width, substream.width);
EXPECT_EQ(sender.send_frame_height, substream.height);
EXPECT_EQ(sender.framerate_input, stats.input_frame_rate);
EXPECT_EQ(sender.framerate_sent, substream.encode_frame_rate);
EXPECT_EQ(sender.nominal_bitrate, stats.media_bitrate_bps);
EXPECT_NE(sender.adapt_reason & WebRtcVideoChannel::ADAPTREASON_CPU, 0);
EXPECT_NE(sender.adapt_reason & WebRtcVideoChannel::ADAPTREASON_BANDWIDTH, 0);
EXPECT_EQ(sender.adapt_changes, stats.number_of_cpu_adapt_changes);
EXPECT_EQ(sender.quality_limitation_reason, stats.quality_limitation_reason);
EXPECT_EQ(sender.quality_limitation_durations_ms,
stats.quality_limitation_durations_ms);
EXPECT_EQ(sender.quality_limitation_resolution_changes,
stats.quality_limitation_resolution_changes);
EXPECT_EQ(sender.avg_encode_ms, stats.avg_encode_time_ms);
EXPECT_EQ(sender.encode_usage_percent, stats.encode_usage_percent);
EXPECT_EQ(sender.frames_encoded,
static_cast<uint32_t>(substream.frames_encoded));
EXPECT_EQ(sender.key_frames_encoded,
static_cast<uint32_t>(substream.frame_counts.key_frames));
EXPECT_EQ(sender.total_encode_time_ms, substream.total_encode_time_ms);
EXPECT_EQ(sender.total_encoded_bytes_target,
substream.total_encoded_bytes_target);
EXPECT_EQ(sender.total_packet_send_delay_ms,
substream.total_packet_send_delay_ms);
EXPECT_EQ(sender.has_entered_low_resolution,
stats.has_entered_low_resolution);
EXPECT_EQ(sender.qp_sum, *substream.qp_sum);
EXPECT_EQ(sender.content_type, webrtc::VideoContentType::SCREENSHARE);
EXPECT_EQ(sender.frames_sent,
static_cast<uint32_t>(substream.frames_encoded));
EXPECT_EQ(sender.huge_frames_sent, substream.huge_frames_sent);
EXPECT_EQ(sender.rid, absl::nullopt);
EXPECT_EQ(stats.qp_sum, info.senders[0].qp_sum);
}
TEST_F(WebRtcVideoChannelTest, GetStatsReportsUpperResolution) {
@ -5608,16 +5248,9 @@ TEST_F(WebRtcVideoChannelTest, GetStatsReportsUpperResolution) {
cricket::VideoMediaInfo info;
ASSERT_TRUE(channel_->GetStats(&info));
ASSERT_EQ(1u, info.aggregated_senders.size());
ASSERT_EQ(3u, info.senders.size());
EXPECT_EQ(123, info.senders[1].send_frame_width);
EXPECT_EQ(40, info.senders[1].send_frame_height);
EXPECT_EQ(80, info.senders[2].send_frame_width);
EXPECT_EQ(31, info.senders[2].send_frame_height);
EXPECT_EQ(20, info.senders[0].send_frame_width);
ASSERT_EQ(1u, info.senders.size());
EXPECT_EQ(123, info.senders[0].send_frame_width);
EXPECT_EQ(90, info.senders[0].send_frame_height);
EXPECT_EQ(123, info.aggregated_senders[0].send_frame_width);
EXPECT_EQ(90, info.aggregated_senders[0].send_frame_height);
}
TEST_F(WebRtcVideoChannelTest, GetStatsReportsCpuAdaptationStats) {
@ -5815,18 +5448,19 @@ TEST_F(WebRtcVideoChannelTest,
cricket::VideoMediaInfo info;
ASSERT_TRUE(channel_->GetStats(&info));
EXPECT_EQ(info.senders.size(), 2u);
EXPECT_EQ(15u, info.senders[0].header_and_padding_bytes_sent);
EXPECT_EQ(30u, info.senders[0].payload_bytes_sent);
EXPECT_EQ(4, info.senders[0].packets_sent);
EXPECT_EQ(10u, info.senders[0].retransmitted_bytes_sent);
EXPECT_EQ(1u, info.senders[0].retransmitted_packets_sent);
EXPECT_EQ(45u, info.senders[1].header_and_padding_bytes_sent);
EXPECT_EQ(77u, info.senders[1].payload_bytes_sent);
EXPECT_EQ(16, info.senders[1].packets_sent);
EXPECT_EQ(20u, info.senders[1].retransmitted_bytes_sent);
EXPECT_EQ(4u, info.senders[1].retransmitted_packets_sent);
// TODO(https://crbug.com/webrtc/9547): Populate individual VideoSenderInfo
// objects for each simulcast stream, instead of accumulating all layers into
// a single VideoSenderInfo. When this is fixed, this test should expect that
// there are two VideoSenderInfo, where the first info accounts for the first
// RTX and the second info accounts for the second RTX. In order for the test
// to be set up correctly, it may need to be updated such that the
// relationship between RTP and RTX streams are known. See also
// https://crbug.com/webrtc/11439.
EXPECT_EQ(60u, info.senders[0].header_and_padding_bytes_sent);
EXPECT_EQ(107u, info.senders[0].payload_bytes_sent);
EXPECT_EQ(20, info.senders[0].packets_sent);
EXPECT_EQ(30u, info.senders[0].retransmitted_bytes_sent);
EXPECT_EQ(5u, info.senders[0].retransmitted_packets_sent);
}
TEST_F(WebRtcVideoChannelTest,
@ -5858,17 +5492,9 @@ TEST_F(WebRtcVideoChannelTest, GetStatsTranslatesSendRtcpPacketTypesCorrectly) {
cricket::VideoMediaInfo info;
ASSERT_TRUE(channel_->GetStats(&info));
EXPECT_EQ(2, info.senders[0].firs_rcvd);
EXPECT_EQ(3, info.senders[0].nacks_rcvd);
EXPECT_EQ(4, info.senders[0].plis_rcvd);
EXPECT_EQ(5, info.senders[1].firs_rcvd);
EXPECT_EQ(7, info.senders[1].nacks_rcvd);
EXPECT_EQ(9, info.senders[1].plis_rcvd);
EXPECT_EQ(7, info.aggregated_senders[0].firs_rcvd);
EXPECT_EQ(10, info.aggregated_senders[0].nacks_rcvd);
EXPECT_EQ(13, info.aggregated_senders[0].plis_rcvd);
EXPECT_EQ(7, info.senders[0].firs_rcvd);
EXPECT_EQ(10, info.senders[0].nacks_rcvd);
EXPECT_EQ(13, info.senders[0].plis_rcvd);
}
TEST_F(WebRtcVideoChannelTest,
@ -6013,16 +5639,13 @@ TEST_F(WebRtcVideoChannelTest, TranslatesSenderBitrateStatsCorrectly) {
cricket::VideoMediaInfo info;
ASSERT_TRUE(channel_->GetStats(&info));
ASSERT_EQ(2u, info.aggregated_senders.size());
ASSERT_EQ(4u, info.senders.size());
ASSERT_EQ(2u, info.senders.size());
BandwidthEstimationInfo bwe_info;
channel_->FillBitrateInfo(&bwe_info);
// Assuming stream and stream2 corresponds to senders[0] and [1] respectively
// is OK as std::maps are sorted and AddSendStream() gives increasing SSRCs.
EXPECT_EQ(stats.media_bitrate_bps,
info.aggregated_senders[0].nominal_bitrate);
EXPECT_EQ(stats2.media_bitrate_bps,
info.aggregated_senders[1].nominal_bitrate);
EXPECT_EQ(stats.media_bitrate_bps, info.senders[0].nominal_bitrate);
EXPECT_EQ(stats2.media_bitrate_bps, info.senders[1].nominal_bitrate);
EXPECT_EQ(stats.target_media_bitrate_bps + stats2.target_media_bitrate_bps,
bwe_info.target_enc_bitrate);
EXPECT_EQ(stats.media_bitrate_bps + stats2.media_bitrate_bps,

3
pc/peer_connection.cc
View File

@ -973,8 +973,7 @@ bool PeerConnectionInterface::RTCConfiguration::operator==(
offer_extmap_allow_mixed == o.offer_extmap_allow_mixed &&
turn_logging_id == o.turn_logging_id &&
enable_implicit_rollback == o.enable_implicit_rollback &&
allow_codec_switching == o.allow_codec_switching &&
enable_simulcast_stats == o.enable_simulcast_stats;
allow_codec_switching == o.allow_codec_switching;
}
bool PeerConnectionInterface::RTCConfiguration::operator!=(

2
pc/peer_connection_integrationtest.cc
View File

@ -3059,7 +3059,7 @@ TEST_P(PeerConnectionIntegrationTest, NewGetStatsManyAudioAndManyVideoStreams) {
ASSERT_TRUE(caller_report);
auto outbound_stream_stats =
caller_report->GetStatsOfType<webrtc::RTCOutboundRTPStreamStats>();
ASSERT_EQ(outbound_stream_stats.size(), 4u);
ASSERT_EQ(4u, outbound_stream_stats.size());
std::vector<std::string> outbound_track_ids;
for (const auto& stat : outbound_stream_stats) {
ASSERT_TRUE(stat->bytes_sent.is_defined());

28
pc/rtc_stats_collector.cc
View File

@ -397,7 +397,6 @@ void SetOutboundRTPStreamStatsFromVoiceSenderInfo(
void SetOutboundRTPStreamStatsFromVideoSenderInfo(
const std::string& mid,
const cricket::VideoSenderInfo& video_sender_info,
bool enable_simulcast_stats,
RTCOutboundRTPStreamStats* outbound_video) {
SetOutboundRTPStreamStatsFromMediaSenderInfo(video_sender_info,
outbound_video);
@ -422,21 +421,6 @@ void SetOutboundRTPStreamStatsFromVideoSenderInfo(
rtc::kNumMillisecsPerSec;
outbound_video->total_encoded_bytes_target =
video_sender_info.total_encoded_bytes_target;
if (enable_simulcast_stats) {
if (video_sender_info.send_frame_width > 0) {
outbound_video->frame_width =
static_cast<uint32_t>(video_sender_info.send_frame_width);
}
if (video_sender_info.send_frame_height > 0) {
outbound_video->frame_height =
static_cast<uint32_t>(video_sender_info.send_frame_height);
}
if (video_sender_info.framerate_sent > 0) {
outbound_video->frames_per_second = video_sender_info.framerate_sent;
}
outbound_video->frames_sent = video_sender_info.frames_sent;
outbound_video->huge_frames_sent = video_sender_info.huge_frames_sent;
}
outbound_video->total_packet_send_delay =
static_cast<double>(video_sender_info.total_packet_send_delay_ms) /
rtc::kNumMillisecsPerSec;
@ -453,9 +437,6 @@ void SetOutboundRTPStreamStatsFromVideoSenderInfo(
outbound_video->encoder_implementation =
video_sender_info.encoder_implementation_name;
}
if (video_sender_info.rid) {
outbound_video->rid = *video_sender_info.rid;
}
}
std::unique_ptr<RTCRemoteInboundRtpStreamStats>
@ -987,7 +968,6 @@ RTCStatsCollector::RTCStatsCollector(PeerConnectionInternal* pc,
RTC_DCHECK_GE(cache_lifetime_us_, 0);
pc_->SignalDataChannelCreated().connect(
this, &RTCStatsCollector::OnDataChannelCreated);
enable_simulcast_stats_ = pc_->GetConfiguration().enable_simulcast_stats;
}
RTCStatsCollector::~RTCStatsCollector() {
@ -1663,16 +1643,14 @@ void RTCStatsCollector::ProduceVideoRTPStreamStats_n(
// Outbound
std::map<std::string, RTCOutboundRTPStreamStats*> video_outbound_rtps;
for (const cricket::VideoSenderInfo& video_sender_info :
enable_simulcast_stats_
? track_media_info_map.video_media_info()->senders
: track_media_info_map.video_media_info()->aggregated_senders) {
track_media_info_map.video_media_info()->senders) {
if (!video_sender_info.connected())
continue;
auto outbound_video = std::make_unique<RTCOutboundRTPStreamStats>(
RTCOutboundRTPStreamStatsIDFromSSRC(false, video_sender_info.ssrc()),
timestamp_us);
SetOutboundRTPStreamStatsFromVideoSenderInfo(
mid, video_sender_info, enable_simulcast_stats_, outbound_video.get());
SetOutboundRTPStreamStatsFromVideoSenderInfo(mid, video_sender_info,
outbound_video.get());
rtc::scoped_refptr<VideoTrackInterface> video_track =
track_media_info_map.GetVideoTrack(video_sender_info);
if (video_track) {

1
pc/rtc_stats_collector.h
View File

@ -288,7 +288,6 @@ class RTCStatsCollector : public virtual rtc::RefCountInterface,
std::set<uintptr_t> opened_data_channels;
};
InternalRecord internal_record_;
bool enable_simulcast_stats_ = false;
};
const char* CandidateTypeToRTCIceCandidateTypeForTesting(

24
pc/rtc_stats_collector_unittest.cc
View File

@ -519,7 +519,6 @@ class RTCStatsCollectorWrapper {
MediaStreamTrackInterface::kVideoKind);
video_media_info.senders.push_back(video_sender_info);
video_media_info.aggregated_senders.push_back(video_sender_info);
rtc::scoped_refptr<MockRtpSenderInternal> rtp_sender = CreateMockSender(
cricket::MEDIA_TYPE_VIDEO,
rtc::scoped_refptr<MediaStreamTrackInterface>(local_video_track),
@ -642,7 +641,6 @@ class RTCStatsCollectorTest : public ::testing::Test {
cricket::SsrcSenderInfo());
video_media_info.senders[0].local_stats[0].ssrc = 3;
video_media_info.senders[0].codec_payload_type = send_codec.payload_type;
video_media_info.aggregated_senders.push_back(video_media_info.senders[0]);
// inbound-rtp
graph.inbound_rtp_id = "RTCInboundRTPVideoStream_4";
video_media_info.receivers.push_back(cricket::VideoReceiverInfo());
@ -2016,12 +2014,7 @@ TEST_F(RTCStatsCollectorTest, CollectRTCOutboundRTPStreamStats_Video) {
video_media_info.senders[0].qp_sum = absl::nullopt;
video_media_info.senders[0].content_type = VideoContentType::UNSPECIFIED;
video_media_info.senders[0].encoder_implementation_name = "";
video_media_info.senders[0].send_frame_width = 200;
video_media_info.senders[0].send_frame_height = 100;
video_media_info.senders[0].framerate_sent = 10;
video_media_info.senders[0].frames_sent = 5;
video_media_info.senders[0].huge_frames_sent = 2;
video_media_info.aggregated_senders.push_back(video_media_info.senders[0]);
RtpCodecParameters codec_parameters;
codec_parameters.payload_type = 42;
codec_parameters.kind = cricket::MEDIA_TYPE_AUDIO;
@ -2069,13 +2062,6 @@ TEST_F(RTCStatsCollectorTest, CollectRTCOutboundRTPStreamStats_Video) {
expected_video.total_packet_send_delay = 10.0;
expected_video.quality_limitation_reason = "bandwidth";
expected_video.quality_limitation_resolution_changes = 56u;
if (pc_->GetConfiguration().enable_simulcast_stats) {
expected_video.frame_width = 200u;
expected_video.frame_height = 100u;
expected_video.frames_per_second = 10.0;
expected_video.frames_sent = 5;
expected_video.huge_frames_sent = 2;
}
// |expected_video.content_type| should be undefined.
// |expected_video.qp_sum| should be undefined.
// |expected_video.encoder_implementation| should be undefined.
@ -2091,7 +2077,6 @@ TEST_F(RTCStatsCollectorTest, CollectRTCOutboundRTPStreamStats_Video) {
video_media_info.senders[0].content_type = VideoContentType::SCREENSHARE;
expected_video.content_type = "screenshare";
video_media_info.senders[0].encoder_implementation_name = "libfooencoder";
video_media_info.aggregated_senders[0] = video_media_info.senders[0];
expected_video.encoder_implementation = "libfooencoder";
video_media_channel->SetStats(video_media_info);
@ -2405,15 +2390,10 @@ TEST_F(RTCStatsCollectorTest, RTCVideoSourceStatsCollectedForSenderWithTrack) {
const int kVideoSourceHeight = 34;
cricket::VideoMediaInfo video_media_info;
video_media_info.aggregated_senders.push_back(cricket::VideoSenderInfo());
video_media_info.senders.push_back(cricket::VideoSenderInfo());
video_media_info.senders[0].local_stats.push_back(cricket::SsrcSenderInfo());
video_media_info.senders[0].local_stats[0].ssrc = kSsrc;
video_media_info.senders[0].framerate_input = 29;
video_media_info.aggregated_senders[0].local_stats.push_back(
cricket::SsrcSenderInfo());
video_media_info.aggregated_senders[0].local_stats[0].ssrc = kSsrc;
video_media_info.aggregated_senders[0].framerate_input = 29;
auto* video_media_channel = pc_->AddVideoChannel("VideoMid", "TransportName");
video_media_channel->SetStats(video_media_info);
@ -2592,8 +2572,6 @@ class RTCStatsCollectorTestWithParamKind
}
video_media_info.senders[0].report_block_datas.push_back(
report_block_data);
video_media_info.aggregated_senders.push_back(
video_media_info.senders[0]);
auto* video_media_channel = pc_->AddVideoChannel("mid", transport_name);
video_media_channel->SetStats(video_media_info);
return;

58
pc/rtc_stats_integrationtest.cc
View File

@ -352,8 +352,7 @@ class RTCStatsReportVerifier {
explicit RTCStatsReportVerifier(const RTCStatsReport* report)
: report_(report) {}
void VerifyReport(std::vector<const char*> allowed_missing_stats,
bool enable_simulcast_stats) {
void VerifyReport(std::vector<const char*> allowed_missing_stats) {
std::set<const char*> missing_stats = StatsTypes();
bool verify_successful = true;
std::vector<const RTCTransportStats*> transport_stats =
@ -396,7 +395,7 @@ class RTCStatsReportVerifier {
stats.cast_to<RTCInboundRTPStreamStats>());
} else if (stats.type() == RTCOutboundRTPStreamStats::kType) {
verify_successful &= VerifyRTCOutboundRTPStreamStats(
stats.cast_to<RTCOutboundRTPStreamStats>(), enable_simulcast_stats);
stats.cast_to<RTCOutboundRTPStreamStats>());
} else if (stats.type() == RTCRemoteInboundRtpStreamStats::kType) {
verify_successful &= VerifyRTCRemoteInboundRtpStreamStats(
stats.cast_to<RTCRemoteInboundRtpStreamStats>());
@ -866,19 +865,14 @@ class RTCStatsReportVerifier {
}
bool VerifyRTCOutboundRTPStreamStats(
const RTCOutboundRTPStreamStats& outbound_stream,
bool enable_simulcast_stats) {
const RTCOutboundRTPStreamStats& outbound_stream) {
RTCStatsVerifier verifier(report_, &outbound_stream);
VerifyRTCRTPStreamStats(outbound_stream, &verifier);
if (outbound_stream.media_type.is_defined() &&
*outbound_stream.media_type == "video") {
verifier.TestMemberIsIDReference(outbound_stream.media_source_id,
RTCVideoSourceStats::kType);
if (*outbound_stream.frames_encoded > 0) {
verifier.TestMemberIsNonNegative<uint64_t>(outbound_stream.qp_sum);
} else {
verifier.TestMemberIsUndefined(outbound_stream.qp_sum);
}
verifier.TestMemberIsNonNegative<uint64_t>(outbound_stream.qp_sum);
} else {
verifier.TestMemberIsIDReference(outbound_stream.media_source_id,
RTCAudioSourceStats::kType);
@ -912,24 +906,6 @@ class RTCStatsReportVerifier {
// this to be present.
verifier.MarkMemberTested(outbound_stream.content_type, true);
verifier.TestMemberIsDefined(outbound_stream.encoder_implementation);
if (enable_simulcast_stats) {
verifier.TestMemberIsNonNegative<double>(
outbound_stream.frames_per_second);
verifier.TestMemberIsNonNegative<uint32_t>(
outbound_stream.frame_height);
verifier.TestMemberIsNonNegative<uint32_t>(outbound_stream.frame_width);
verifier.TestMemberIsNonNegative<uint32_t>(outbound_stream.frames_sent);
verifier.TestMemberIsNonNegative<uint32_t>(
outbound_stream.huge_frames_sent);
verifier.MarkMemberTested(outbound_stream.rid, true);
} else {
verifier.TestMemberIsUndefined(outbound_stream.frames_per_second);
verifier.TestMemberIsUndefined(outbound_stream.frame_height);
verifier.TestMemberIsUndefined(outbound_stream.frame_width);
verifier.TestMemberIsUndefined(outbound_stream.frames_sent);
verifier.TestMemberIsUndefined(outbound_stream.huge_frames_sent);
verifier.TestMemberIsUndefined(outbound_stream.rid);
}
} else {
verifier.TestMemberIsUndefined(outbound_stream.frames_encoded);
verifier.TestMemberIsUndefined(outbound_stream.key_frames_encoded);
@ -944,12 +920,6 @@ class RTCStatsReportVerifier {
verifier.TestMemberIsUndefined(outbound_stream.content_type);
// TODO(hbos): Implement for audio as well.
verifier.TestMemberIsUndefined(outbound_stream.encoder_implementation);
verifier.TestMemberIsUndefined(outbound_stream.rid);
verifier.TestMemberIsUndefined(outbound_stream.frames_per_second);
verifier.TestMemberIsUndefined(outbound_stream.frame_height);
verifier.TestMemberIsUndefined(outbound_stream.frame_width);
verifier.TestMemberIsUndefined(outbound_stream.frames_sent);
verifier.TestMemberIsUndefined(outbound_stream.huge_frames_sent);
}
return verifier.ExpectAllMembersSuccessfullyTested();
}
@ -1044,11 +1014,9 @@ TEST_F(RTCStatsIntegrationTest, GetStatsFromCaller) {
StartCall();
rtc::scoped_refptr<const RTCStatsReport> report = GetStatsFromCaller();
RTCStatsReportVerifier(report.get())
.VerifyReport({},
caller_->pc()->GetConfiguration().enable_simulcast_stats);
RTCStatsReportVerifier(report.get()).VerifyReport({});
#if RTC_TRACE_EVENTS_ENABLED
#if RTC_TRACE_EVENTS_ENABLED
EXPECT_EQ(report->ToJson(), RTCStatsReportTraceListener::last_trace());
#endif
}
@ -1057,11 +1025,9 @@ TEST_F(RTCStatsIntegrationTest, GetStatsFromCallee) {
StartCall();
rtc::scoped_refptr<const RTCStatsReport> report = GetStatsFromCallee();
RTCStatsReportVerifier(report.get())
.VerifyReport({},
caller_->pc()->GetConfiguration().enable_simulcast_stats);
RTCStatsReportVerifier(report.get()).VerifyReport({});
#if RTC_TRACE_EVENTS_ENABLED
#if RTC_TRACE_EVENTS_ENABLED
EXPECT_EQ(report->ToJson(), RTCStatsReportTraceListener::last_trace());
#endif
}
@ -1083,9 +1049,7 @@ TEST_F(RTCStatsIntegrationTest, GetStatsWithSenderSelector) {
RTCMediaStreamStats::kType,
RTCDataChannelStats::kType,
};
RTCStatsReportVerifier(report.get())
.VerifyReport(allowed_missing_stats,
caller_->pc()->GetConfiguration().enable_simulcast_stats);
RTCStatsReportVerifier(report.get()).VerifyReport(allowed_missing_stats);
EXPECT_TRUE(report->size());
}
@ -1104,9 +1068,7 @@ TEST_F(RTCStatsIntegrationTest, GetStatsWithReceiverSelector) {
RTCMediaStreamStats::kType,
RTCDataChannelStats::kType,
};
RTCStatsReportVerifier(report.get())
.VerifyReport(allowed_missing_stats,
caller_->pc()->GetConfiguration().enable_simulcast_stats);
RTCStatsReportVerifier(report.get()).VerifyReport(allowed_missing_stats);
EXPECT_TRUE(report->size());
}

2
pc/stats_collector.cc
View File

@ -1028,7 +1028,7 @@ class VideoMediaChannelStatsGatherer final : public MediaChannelStatsGatherer {
void ExtractStats(StatsCollector* collector) const override {
ExtractSenderReceiverStats(collector, video_media_info.receivers,
video_media_info.aggregated_senders);
video_media_info.senders);
}
bool HasRemoteAudio() const override { return false; }

12
pc/stats_collector_unittest.cc
View File

@ -912,7 +912,7 @@ TEST_P(StatsCollectorTrackTest, BytesCounterHandles64Bits) {
video_sender_info.payload_bytes_sent = kBytesSent;
video_sender_info.header_and_padding_bytes_sent = 0;
VideoMediaInfo video_info;
video_info.aggregated_senders.push_back(video_sender_info);
video_info.senders.push_back(video_sender_info);
auto* video_media_channel = pc->AddVideoChannel("video", "transport");
video_media_channel->SetStats(video_info);
@ -995,7 +995,7 @@ TEST_P(StatsCollectorTrackTest, VideoBandwidthEstimationInfoIsReported) {
video_sender_info.header_and_padding_bytes_sent = 12;
VideoMediaInfo video_info;
video_info.aggregated_senders.push_back(video_sender_info);
video_info.senders.push_back(video_sender_info);
auto* video_media_channel = pc->AddVideoChannel("video", "transport");
video_media_channel->SetStats(video_info);
@ -1093,7 +1093,7 @@ TEST_P(StatsCollectorTrackTest, TrackAndSsrcObjectExistAfterUpdateSsrcStats) {
video_sender_info.payload_bytes_sent = kBytesSent - 12;
video_sender_info.header_and_padding_bytes_sent = 12;
VideoMediaInfo video_info;
video_info.aggregated_senders.push_back(video_sender_info);
video_info.senders.push_back(video_sender_info);
auto* video_media_channel = pc->AddVideoChannel("video", "transport");
video_media_channel->SetStats(video_info);
@ -1148,7 +1148,7 @@ TEST_P(StatsCollectorTrackTest, TransportObjectLinkedFromSsrcObject) {
video_sender_info.payload_bytes_sent = kBytesSent - 12;
video_sender_info.header_and_padding_bytes_sent = 12;
VideoMediaInfo video_info;
video_info.aggregated_senders.push_back(video_sender_info);
video_info.senders.push_back(video_sender_info);
auto* video_media_channel = pc->AddVideoChannel("video", "transport");
video_media_channel->SetStats(video_info);
@ -1211,7 +1211,7 @@ TEST_P(StatsCollectorTrackTest, RemoteSsrcInfoIsPresent) {
video_sender_info.add_ssrc(kSsrcOfTrack);
video_sender_info.remote_stats.push_back(remote_ssrc_stats);
VideoMediaInfo video_info;
video_info.aggregated_senders.push_back(video_sender_info);
video_info.senders.push_back(video_sender_info);
auto* video_media_channel = pc->AddVideoChannel("video", "transport");
video_media_channel->SetStats(video_info);
@ -1853,7 +1853,7 @@ TEST_P(StatsCollectorTrackTest, VerifyVideoSendSsrcStats) {
video_sender_info.frames_encoded = 10;
video_sender_info.qp_sum = 11;
VideoMediaInfo video_info;
video_info.aggregated_senders.push_back(video_sender_info);
video_info.senders.push_back(video_sender_info);
auto* video_media_channel = pc->AddVideoChannel("video", "transport");
video_media_channel->SetStats(video_info);

32
pc/track_media_info_map.cc
View File

@ -10,7 +10,6 @@
#include "pc/track_media_info_map.h"
#include <set>
#include <string>
#include <utility>
@ -171,36 +170,19 @@ TrackMediaInfoMap::TrackMediaInfoMap(
}
if (video_media_info_) {
for (auto& sender_info : video_media_info_->senders) {
std::set<uint32_t> ssrcs;
ssrcs.insert(sender_info.ssrc());
for (auto& ssrc_group : sender_info.ssrc_groups) {
for (auto ssrc : ssrc_group.ssrcs) {
ssrcs.insert(ssrc);
}
VideoTrackInterface* associated_track =
FindValueOrNull(local_video_track_by_ssrc, sender_info.ssrc());
if (associated_track) {
// One sender is associated with at most one track.
// One track may be associated with multiple senders.
video_track_by_sender_info_[&sender_info] = associated_track;
video_infos_by_local_track_[associated_track].push_back(&sender_info);
}
for (auto ssrc : ssrcs) {
VideoTrackInterface* associated_track =
FindValueOrNull(local_video_track_by_ssrc, ssrc);
if (associated_track) {
// One sender is associated with at most one track.
// One track may be associated with multiple senders.
video_track_by_sender_info_[&sender_info] = associated_track;
video_infos_by_local_track_[associated_track].push_back(&sender_info);
break;
}
}
}
for (auto& sender_info : video_media_info_->aggregated_senders) {
if (sender_info.ssrc() == 0)
continue; // Unconnected SSRC. bugs.webrtc.org/8673
RTC_DCHECK(video_info_by_sender_ssrc_.count(sender_info.ssrc()) == 0)
<< "Duplicate video sender SSRC: " << sender_info.ssrc();
video_info_by_sender_ssrc_[sender_info.ssrc()] = &sender_info;
VideoTrackInterface* associated_track =
FindValueOrNull(local_video_track_by_ssrc, sender_info.ssrc());
if (associated_track) {
video_track_by_sender_info_[&sender_info] = associated_track;
}
}
for (auto& receiver_info : video_media_info_->receivers) {
VideoTrackInterface* associated_track =

1
pc/track_media_info_map_unittest.cc
View File

@ -131,7 +131,6 @@ class TrackMediaInfoMapTest : public ::testing::Test {
video_sender_info.local_stats[i++].ssrc = ssrc;
}
video_media_info_->senders.push_back(video_sender_info);
video_media_info_->aggregated_senders.push_back(video_sender_info);
}
}

18
stats/rtcstats_objects.cc
View File

@ -698,7 +698,6 @@ WEBRTC_RTCSTATS_IMPL(
RTCOutboundRTPStreamStats, RTCRTPStreamStats, "outbound-rtp",
&media_source_id,
&remote_id,
&rid,
&packets_sent,
&retransmitted_packets_sent,
&bytes_sent,
@ -709,11 +708,6 @@ WEBRTC_RTCSTATS_IMPL(
&key_frames_encoded,
&total_encode_time,
&total_encoded_bytes_target,
&frame_width,
&frame_height,
&frames_per_second,
&frames_sent,
&huge_frames_sent,
&total_packet_send_delay,
&quality_limitation_reason,
&quality_limitation_resolution_changes,
@ -730,7 +724,6 @@ RTCOutboundRTPStreamStats::RTCOutboundRTPStreamStats(std::string&& id,
: RTCRTPStreamStats(std::move(id), timestamp_us),
media_source_id("mediaSourceId"),
remote_id("remoteId"),
rid("rid"),
packets_sent("packetsSent"),
retransmitted_packets_sent("retransmittedPacketsSent"),
bytes_sent("bytesSent"),
@ -741,11 +734,6 @@ RTCOutboundRTPStreamStats::RTCOutboundRTPStreamStats(std::string&& id,
key_frames_encoded("keyFramesEncoded"),
total_encode_time("totalEncodeTime"),
total_encoded_bytes_target("totalEncodedBytesTarget"),
frame_width("frameWidth"),
frame_height("frameHeight"),
frames_per_second("framesPerSecond"),
frames_sent("framesSent"),
huge_frames_sent("hugeFramesSent"),
total_packet_send_delay("totalPacketSendDelay"),
quality_limitation_reason("qualityLimitationReason"),
quality_limitation_resolution_changes(
@ -758,7 +746,6 @@ RTCOutboundRTPStreamStats::RTCOutboundRTPStreamStats(
: RTCRTPStreamStats(other),
media_source_id(other.media_source_id),
remote_id(other.remote_id),
rid(other.rid),
packets_sent(other.packets_sent),
retransmitted_packets_sent(other.retransmitted_packets_sent),
bytes_sent(other.bytes_sent),
@ -769,11 +756,6 @@ RTCOutboundRTPStreamStats::RTCOutboundRTPStreamStats(
key_frames_encoded(other.key_frames_encoded),
total_encode_time(other.total_encode_time),
total_encoded_bytes_target(other.total_encoded_bytes_target),
frame_width(other.frame_width),
frame_height(other.frame_height),
frames_per_second(other.frames_per_second),
frames_sent(other.frames_sent),
huge_frames_sent(other.huge_frames_sent),
total_packet_send_delay(other.total_packet_send_delay),
quality_limitation_reason(other.quality_limitation_reason),
quality_limitation_resolution_changes(

18
video/send_statistics_proxy.cc
View File

@ -958,15 +958,7 @@ void SendStatisticsProxy::OnSendEncodedImage(
VideoSendStream::StreamStats* stats = GetStatsEntry(ssrc);
if (!stats)
return;
if (encoded_frame_rate_trackers_.count(simulcast_idx) == 0) {
encoded_frame_rate_trackers_[simulcast_idx] =
std::make_unique<rtc::RateTracker>(kBucketSizeMs, kBucketCount);
}
stats->encode_frame_rate =
encoded_frame_rate_trackers_[simulcast_idx]->ComputeRate();
stats->frames_encoded++;
stats->total_encode_time_ms += encoded_image.timing_.encode_finish_ms -
encoded_image.timing_.encode_start_ms;
// Report resolution of top spatial layer in case of VP9 SVC.
bool is_svc_low_spatial_layer =
(codec_info && codec_info->codecType == kVideoCodecVP9)
@ -983,9 +975,9 @@ void SendStatisticsProxy::OnSendEncodedImage(
VideoFrameType::kVideoFrameKey);
if (encoded_image.qp_ != -1) {
if (!stats->qp_sum)
stats->qp_sum = 0;
*stats->qp_sum += encoded_image.qp_;
if (!stats_.qp_sum)
stats_.qp_sum = 0;
*stats_.qp_sum += encoded_image.qp_;
if (codec_info) {
if (codec_info->codecType == kVideoCodecVP8) {
@ -1005,7 +997,6 @@ void SendStatisticsProxy::OnSendEncodedImage(
// as a single difficult input frame.
// https://w3c.github.io/webrtc-stats/#dom-rtcvideosenderstats-hugeframessent
if (encoded_image.timing_.flags & VideoSendTiming::kTriggeredBySize) {
++stats->huge_frames_sent;
if (!last_outlier_timestamp_ ||
*last_outlier_timestamp_ < encoded_image.capture_time_ms_) {
last_outlier_timestamp_.emplace(encoded_image.capture_time_ms_);
@ -1016,7 +1007,6 @@ void SendStatisticsProxy::OnSendEncodedImage(
media_byte_rate_tracker_.AddSamples(encoded_image.size());
if (uma_container_->InsertEncodedFrame(encoded_image, simulcast_idx)) {
encoded_frame_rate_trackers_[simulcast_idx]->AddSamples(1);
encoded_frame_rate_tracker_.AddSamples(1);
}

2
video/send_statistics_proxy.h
View File

@ -285,8 +285,6 @@ class SendStatisticsProxy : public VideoStreamEncoderObserver,
RTC_GUARDED_BY(crit_);
rtc::RateTracker media_byte_rate_tracker_ RTC_GUARDED_BY(crit_);
rtc::RateTracker encoded_frame_rate_tracker_ RTC_GUARDED_BY(crit_);
std::map<uint32_t, std::unique_ptr<rtc::RateTracker>>
encoded_frame_rate_trackers_ RTC_GUARDED_BY(crit_);
absl::optional<int64_t> last_outlier_timestamp_ RTC_GUARDED_BY(crit_);

38
video/send_statistics_proxy_unittest.cc
View File

@ -372,27 +372,22 @@ TEST_F(SendStatisticsProxyTest, OnSendEncodedImageIncreasesFramesEncoded) {
TEST_F(SendStatisticsProxyTest, OnSendEncodedImageIncreasesQpSum) {
EncodedImage encoded_image;
CodecSpecificInfo codec_info;
auto ssrc = config_.rtp.ssrcs[0];
EXPECT_EQ(absl::nullopt,
statistics_proxy_->GetStats().substreams[ssrc].qp_sum);
EXPECT_EQ(absl::nullopt, statistics_proxy_->GetStats().qp_sum);
encoded_image.qp_ = 3;
statistics_proxy_->OnSendEncodedImage(encoded_image, &codec_info);
EXPECT_EQ(3u, statistics_proxy_->GetStats().substreams[ssrc].qp_sum);
EXPECT_EQ(3u, statistics_proxy_->GetStats().qp_sum);
encoded_image.qp_ = 127;
statistics_proxy_->OnSendEncodedImage(encoded_image, &codec_info);
EXPECT_EQ(130u, statistics_proxy_->GetStats().substreams[ssrc].qp_sum);
EXPECT_EQ(130u, statistics_proxy_->GetStats().qp_sum);
}
TEST_F(SendStatisticsProxyTest, OnSendEncodedImageWithoutQpQpSumWontExist) {
EncodedImage encoded_image;
CodecSpecificInfo codec_info;
auto ssrc = config_.rtp.ssrcs[0];
encoded_image.qp_ = -1;
EXPECT_EQ(absl::nullopt,
statistics_proxy_->GetStats().substreams[ssrc].qp_sum);
EXPECT_EQ(absl::nullopt, statistics_proxy_->GetStats().qp_sum);
statistics_proxy_->OnSendEncodedImage(encoded_image, &codec_info);
EXPECT_EQ(absl::nullopt,
statistics_proxy_->GetStats().substreams[ssrc].qp_sum);
EXPECT_EQ(absl::nullopt, statistics_proxy_->GetStats().qp_sum);
}
TEST_F(SendStatisticsProxyTest, TotalEncodedBytesTargetFirstFrame) {
@ -447,29 +442,6 @@ TEST_F(SendStatisticsProxyTest,
EXPECT_EQ(kTargetBytesPerSecond / 10, delta_encoded_bytes_target);
}
TEST_F(SendStatisticsProxyTest, EncodeFrameRateInSubStream) {
const int kInterframeDelayMs = 100;
auto ssrc = config_.rtp.ssrcs[0];
rtc::ScopedFakeClock fake_global_clock;
fake_global_clock.SetTime(
Timestamp::Millis(fake_clock_.TimeInMilliseconds()));
EncodedImage encoded_image;
// First frame
statistics_proxy_->OnSendEncodedImage(encoded_image, nullptr);
// Second frame
fake_clock_.AdvanceTimeMilliseconds(kInterframeDelayMs);
fake_global_clock.SetTime(
Timestamp::Millis(fake_clock_.TimeInMilliseconds()));
encoded_image.SetTimestamp(encoded_image.Timestamp() +
90 * kInterframeDelayMs);
statistics_proxy_->OnSendEncodedImage(encoded_image, nullptr);
auto stats = statistics_proxy_->GetStats();
EXPECT_EQ(stats.substreams[ssrc].encode_frame_rate, 10);
}
TEST_F(SendStatisticsProxyTest, GetCpuAdaptationStats) {
VideoAdaptationCounters cpu_counts;
VideoAdaptationCounters quality_counts;