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

Implement RTCInboundRTPStreamStats.JitterBufferTargetDelay

Browse Source 
This CL also removes the existing non-standard implementation of the metric.

Bug: webrtc:14147, webrtc:11789
Change-Id: I70fd1c451dfd59380fe5ce959086f37b31697c16
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/265360
Reviewed-by: Artem Titov <titovartem@webrtc.org>
Commit-Queue: Ivo Creusen <ivoc@webrtc.org>
Reviewed-by: Sam Zackrisson <saza@webrtc.org>
Reviewed-by: Henrik Boström <hbos@webrtc.org>
Reviewed-by: Ivo Creusen <ivoc@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#37441}
This commit is contained in:
Ivo Creusen 2022-07-04 14:16:39 +02:00 committed by WebRTC LUCI CQ
parent 63299a3124
commit 11fdb08282
8 changed files with 23 additions and 30 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
api/stats/rtcstats_objects.h
View File

@ -345,15 +345,6 @@ class RTC_EXPORT RTCMediaStreamTrackStats final : public RTCStats {
RTCNonStandardStatsMember<uint64_t> jitter_buffer_flushes;
RTCNonStandardStatsMember<uint64_t> delayed_packet_outage_samples;
RTCNonStandardStatsMember<double> relative_packet_arrival_delay;
// Non-standard metric showing target delay of jitter buffer.
// This value is increased by the target jitter buffer delay every time a
// sample is emitted by the jitter buffer. The added target is the target
// delay, in seconds, at the time that the sample was emitted from the jitter
// buffer. (https://github.com/w3c/webrtc-provisional-stats/pull/20)
// Currently it is implemented only for audio.
// TODO(https://crbug.com/webrtc/14176): This should be moved to
// RTCInboundRtpStreamStats and it should be implemented for video as well.
RTCNonStandardStatsMember<double> jitter_buffer_target_delay;
// TODO(henrik.lundin): Add description of the interruption metrics at
// https://github.com/w3c/webrtc-provisional-stats/issues/17
RTCNonStandardStatsMember<uint32_t> interruption_count;
@ -461,6 +452,7 @@ class RTC_EXPORT RTCInboundRTPStreamStats final
RTCStatsMember<uint64_t> header_bytes_received;
RTCStatsMember<double> last_packet_received_timestamp;
RTCStatsMember<double> jitter_buffer_delay;
RTCStatsMember<double> jitter_buffer_target_delay;
RTCStatsMember<uint64_t> jitter_buffer_emitted_count;
RTCStatsMember<uint64_t> total_samples_received;
RTCStatsMember<uint64_t> concealed_samples;

6
media/base/media_channel.h
View File

@ -450,6 +450,11 @@ struct MediaReceiverInfo {
// Jitter (network-related) latency (cumulative).
// https://w3c.github.io/webrtc-stats/#dom-rtcinboundrtpstreamstats-jitterbufferdelay
double jitter_buffer_delay_seconds = 0.0;
// Target delay for the jitter buffer (cumulative).
// TODO(https://crbug.com/webrtc/14244): This metric is only implemented for
// audio, it should be implemented for video as well.
// https://w3c.github.io/webrtc-stats/#dom-rtcinboundrtpstreamstats-jitterbuffertargetdelay
absl::optional<double> jitter_buffer_target_delay_seconds;
// Number of observations for cumulative jitter latency.
// https://w3c.github.io/webrtc-stats/#dom-rtcinboundrtpstreamstats-jitterbufferemittedcount
uint64_t jitter_buffer_emitted_count = 0;
@ -495,7 +500,6 @@ struct VoiceReceiverInfo : public MediaReceiverInfo {
uint64_t concealed_samples = 0;
uint64_t silent_concealed_samples = 0;
uint64_t concealment_events = 0;
double jitter_buffer_target_delay_seconds = 0.0;
uint64_t inserted_samples_for_deceleration = 0;
uint64_t removed_samples_for_acceleration = 0;
uint64_t fec_packets_received = 0;

3
modules/audio_coding/include/audio_coding_module_typedefs.h
View File

@ -87,6 +87,7 @@ struct NetworkStatistics {
uint64_t silentConcealedSamples;
uint64_t concealmentEvents;
uint64_t jitterBufferDelayMs;
uint64_t jitterBufferTargetDelayMs;
uint64_t jitterBufferEmittedCount;
uint64_t insertedSamplesForDeceleration;
uint64_t removedSamplesForAcceleration;
@ -95,8 +96,6 @@ struct NetworkStatistics {
// Stats below correspond to similarly-named fields in the WebRTC stats spec.
// https://w3c.github.io/webrtc-stats/#dom-rtcreceivedrtpstreamstats
uint64_t packetsDiscarded;
// Non standard stats propagated to spec complaint GetStats API.
uint64_t jitterBufferTargetDelayMs;
// Stats below DO NOT correspond directly to anything in the WebRTC stats
// fraction (of original stream) of synthesized audio inserted through
// expansion (in Q14)

6
pc/rtc_stats_collector.cc
View File

@ -405,6 +405,10 @@ void SetInboundRTPStreamStatsFromMediaReceiverInfo(
static_cast<int32_t>(media_receiver_info.packets_lost);
inbound_stats->jitter_buffer_delay =
media_receiver_info.jitter_buffer_delay_seconds;
if (media_receiver_info.jitter_buffer_target_delay_seconds) {
inbound_stats->jitter_buffer_target_delay =
*media_receiver_info.jitter_buffer_target_delay_seconds;
}
inbound_stats->jitter_buffer_emitted_count =
media_receiver_info.jitter_buffer_emitted_count;
if (media_receiver_info.nacks_sent) {
@ -952,8 +956,6 @@ ProduceMediaStreamTrackStatsFromVoiceReceiverInfo(
voice_receiver_info.delayed_packet_outage_samples;
audio_track_stats->relative_packet_arrival_delay =
voice_receiver_info.relative_packet_arrival_delay_seconds;
audio_track_stats->jitter_buffer_target_delay =
voice_receiver_info.jitter_buffer_target_delay_seconds;
audio_track_stats->interruption_count =
voice_receiver_info.interruption_count >= 0
? voice_receiver_info.interruption_count

6
pc/rtc_stats_collector_unittest.cc
View File

@ -1837,7 +1837,6 @@ TEST_F(RTCStatsCollectorTest,
voice_receiver_info.silent_concealed_samples = 765;
voice_receiver_info.jitter_buffer_delay_seconds = 3.456;
voice_receiver_info.jitter_buffer_emitted_count = 13;
voice_receiver_info.jitter_buffer_target_delay_seconds = 7.894;
voice_receiver_info.jitter_buffer_flushes = 7;
voice_receiver_info.delayed_packet_outage_samples = 15;
voice_receiver_info.relative_packet_arrival_delay_seconds = 16;
@ -1882,7 +1881,6 @@ TEST_F(RTCStatsCollectorTest,
expected_remote_audio_track.silent_concealed_samples = 765;
expected_remote_audio_track.jitter_buffer_delay = 3.456;
expected_remote_audio_track.jitter_buffer_emitted_count = 13;
expected_remote_audio_track.jitter_buffer_target_delay = 7.894;
expected_remote_audio_track.jitter_buffer_flushes = 7;
expected_remote_audio_track.delayed_packet_outage_samples = 15;
expected_remote_audio_track.relative_packet_arrival_delay = 16;
@ -2061,6 +2059,7 @@ TEST_F(RTCStatsCollectorTest, CollectRTCInboundRTPStreamStats_Audio) {
voice_media_info.receivers[0].codec_payload_type = 42;
voice_media_info.receivers[0].jitter_ms = 4500;
voice_media_info.receivers[0].jitter_buffer_delay_seconds = 1.0;
voice_media_info.receivers[0].jitter_buffer_target_delay_seconds = 1.1;
voice_media_info.receivers[0].jitter_buffer_emitted_count = 2;
voice_media_info.receivers[0].total_samples_received = 3;
voice_media_info.receivers[0].concealed_samples = 4;
@ -2114,6 +2113,7 @@ TEST_F(RTCStatsCollectorTest, CollectRTCInboundRTPStreamStats_Audio) {
// `expected_audio.last_packet_received_timestamp` should be undefined.
expected_audio.jitter = 4.5;
expected_audio.jitter_buffer_delay = 1.0;
expected_audio.jitter_buffer_target_delay = 1.1;
expected_audio.jitter_buffer_emitted_count = 2;
expected_audio.total_samples_received = 3;
expected_audio.concealed_samples = 4;
@ -2179,6 +2179,7 @@ TEST_F(RTCStatsCollectorTest, CollectRTCInboundRTPStreamStats_Video) {
video_media_info.receivers[0].total_squared_inter_frame_delay = 0.00456;
video_media_info.receivers[0].jitter_ms = 1199;
video_media_info.receivers[0].jitter_buffer_delay_seconds = 3.456;
video_media_info.receivers[0].jitter_buffer_target_delay_seconds = 1.1;
video_media_info.receivers[0].jitter_buffer_emitted_count = 13;
video_media_info.receivers[0].last_packet_received_timestamp_ms =
@ -2239,6 +2240,7 @@ TEST_F(RTCStatsCollectorTest, CollectRTCInboundRTPStreamStats_Video) {
expected_video.total_squared_inter_frame_delay = 0.00456;
expected_video.jitter = 1.199;
expected_video.jitter_buffer_delay = 3.456;
expected_video.jitter_buffer_target_delay = 1.1;
expected_video.jitter_buffer_emitted_count = 13;
// `expected_video.last_packet_received_timestamp` should be undefined.
// `expected_video.content_type` should be undefined.

9
pc/rtc_stats_integrationtest.cc
View File

@ -655,8 +655,6 @@ class RTCStatsReportVerifier {
verifier.TestMemberIsUndefined(media_stream_track.interruption_count);
verifier.TestMemberIsUndefined(
media_stream_track.total_interruption_duration);
verifier.TestMemberIsUndefined(
media_stream_track.jitter_buffer_target_delay);
} else {
RTC_DCHECK_EQ(*media_stream_track.kind, RTCMediaStreamTrackKind::kAudio);
// The type of the referenced media source depends on kind.
@ -667,8 +665,6 @@ class RTCStatsReportVerifier {
media_stream_track.jitter_buffer_delay);
verifier.TestMemberIsNonNegative<uint64_t>(
media_stream_track.jitter_buffer_emitted_count);
verifier.TestMemberIsNonNegative<double>(
media_stream_track.jitter_buffer_target_delay);
verifier.TestMemberIsPositive<double>(media_stream_track.audio_level);
verifier.TestMemberIsPositive<double>(
media_stream_track.total_audio_energy);
@ -703,8 +699,6 @@ class RTCStatsReportVerifier {
verifier.TestMemberIsUndefined(media_stream_track.jitter_buffer_delay);
verifier.TestMemberIsUndefined(
media_stream_track.jitter_buffer_emitted_count);
verifier.TestMemberIsUndefined(
media_stream_track.jitter_buffer_target_delay);
verifier.TestMemberIsUndefined(media_stream_track.audio_level);
verifier.TestMemberIsUndefined(media_stream_track.total_audio_energy);
verifier.TestMemberIsUndefined(
@ -850,6 +844,7 @@ class RTCStatsReportVerifier {
inbound_stream.inserted_samples_for_deceleration);
verifier.TestMemberIsUndefined(
inbound_stream.removed_samples_for_acceleration);
verifier.TestMemberIsUndefined(inbound_stream.jitter_buffer_target_delay);
verifier.TestMemberIsUndefined(inbound_stream.audio_level);
verifier.TestMemberIsUndefined(inbound_stream.total_audio_energy);
verifier.TestMemberIsUndefined(inbound_stream.total_samples_duration);
@ -873,6 +868,8 @@ class RTCStatsReportVerifier {
inbound_stream.inserted_samples_for_deceleration);
verifier.TestMemberIsNonNegative<uint64_t>(
inbound_stream.removed_samples_for_acceleration);
verifier.TestMemberIsNonNegative<double>(
inbound_stream.jitter_buffer_target_delay);
verifier.TestMemberIsPositive<double>(inbound_stream.audio_level);
verifier.TestMemberIsPositive<double>(inbound_stream.total_audio_energy);
verifier.TestMemberIsPositive<double>(

6
stats/rtcstats_objects.cc
View File

@ -413,7 +413,6 @@ WEBRTC_RTCSTATS_IMPL(RTCMediaStreamTrackStats, RTCStats, "track",
&jitter_buffer_flushes,
&delayed_packet_outage_samples,
&relative_packet_arrival_delay,
&jitter_buffer_target_delay,
&interruption_count,
&total_interruption_duration,
&freeze_count,
@ -469,7 +468,6 @@ RTCMediaStreamTrackStats::RTCMediaStreamTrackStats(std::string&& id,
relative_packet_arrival_delay(
"relativePacketArrivalDelay",
{NonStandardGroupId::kRtcStatsRelativePacketArrivalDelay}),
jitter_buffer_target_delay("jitterBufferTargetDelay"),
interruption_count("interruptionCount"),
total_interruption_duration("totalInterruptionDuration"),
freeze_count("freezeCount"),
@ -515,7 +513,6 @@ RTCMediaStreamTrackStats::RTCMediaStreamTrackStats(
jitter_buffer_flushes(other.jitter_buffer_flushes),
delayed_packet_outage_samples(other.delayed_packet_outage_samples),
relative_packet_arrival_delay(other.relative_packet_arrival_delay),
jitter_buffer_target_delay(other.jitter_buffer_target_delay),
interruption_count(other.interruption_count),
total_interruption_duration(other.total_interruption_duration),
freeze_count(other.freeze_count),
@ -650,6 +647,7 @@ WEBRTC_RTCSTATS_IMPL(
&header_bytes_received,
&last_packet_received_timestamp,
&jitter_buffer_delay,
&jitter_buffer_target_delay,
&jitter_buffer_emitted_count,
&total_samples_received,
&concealed_samples,
@ -700,6 +698,7 @@ RTCInboundRTPStreamStats::RTCInboundRTPStreamStats(std::string&& id,
header_bytes_received("headerBytesReceived"),
last_packet_received_timestamp("lastPacketReceivedTimestamp"),
jitter_buffer_delay("jitterBufferDelay"),
jitter_buffer_target_delay("jitterBufferTargetDelay"),
jitter_buffer_emitted_count("jitterBufferEmittedCount"),
total_samples_received("totalSamplesReceived"),
concealed_samples("concealedSamples"),
@ -746,6 +745,7 @@ RTCInboundRTPStreamStats::RTCInboundRTPStreamStats(
header_bytes_received(other.header_bytes_received),
last_packet_received_timestamp(other.last_packet_received_timestamp),
jitter_buffer_delay(other.jitter_buffer_delay),
jitter_buffer_target_delay(other.jitter_buffer_target_delay),
jitter_buffer_emitted_count(other.jitter_buffer_emitted_count),
total_samples_received(other.total_samples_received),
concealed_samples(other.concealed_samples),

7
test/pc/e2e/analyzer/audio/default_audio_quality_analyzer.cc
View File

@ -26,14 +26,11 @@ void DefaultAudioQualityAnalyzer::Start(std::string test_case_name,
void DefaultAudioQualityAnalyzer::OnStatsReports(
absl::string_view pc_label,
const rtc::scoped_refptr<const RTCStatsReport>& report) {
// TODO(https://crbug.com/webrtc/11789): use "inbound-rtp" instead of "track"
// stats when required audio metrics moved there
auto stats = report->GetStatsOfType<RTCMediaStreamTrackStats>();
auto stats = report->GetStatsOfType<RTCInboundRTPStreamStats>();
for (auto& stat : stats) {
if (!stat->kind.is_defined() ||
!(*stat->kind == RTCMediaStreamTrackKind::kAudio) ||
!*stat->remote_source) {
!(*stat->kind == RTCMediaStreamTrackKind::kAudio)) {
continue;
}