4e231eedbd
Track stats are roughly equal in size as the RTP stream stats which are the largest objects making up the majority of the RTCStatsReport size and scales with meeting size. Deleting track/stream reduces the size in approximately half which should reduce performance overhead and unblock code simplifications. Blocked on: - https://chromium-review.googlesource.com/c/chromium/src/+/4517530 # Relevant bots already passed NOTRY=True Bug: webrtc:14175, webrtc:14419 Change-Id: Ib7bdb84c10459b42b829228d11876498e5227312 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/289043 Reviewed-by: Harald Alvestrand <hta@webrtc.org> Commit-Queue: Henrik Boström <hbos@webrtc.org> Cr-Commit-Position: refs/heads/main@{#40129}
760 lines
26 KiB
C++
760 lines
26 KiB
C++
/*
|
|
* Copyright 2016 The WebRTC Project Authors. All rights reserved.
|
|
*
|
|
* Use of this source code is governed by a BSD-style license
|
|
* that can be found in the LICENSE file in the root of the source
|
|
* tree. An additional intellectual property rights grant can be found
|
|
* in the file PATENTS. All contributing project authors may
|
|
* be found in the AUTHORS file in the root of the source tree.
|
|
*/
|
|
|
|
#include "api/stats/rtcstats_objects.h"
|
|
|
|
#include <utility>
|
|
|
|
#include "api/stats/rtc_stats.h"
|
|
#include "rtc_base/checks.h"
|
|
|
|
namespace webrtc {
|
|
|
|
const char* const RTCDataChannelState::kConnecting = "connecting";
|
|
const char* const RTCDataChannelState::kOpen = "open";
|
|
const char* const RTCDataChannelState::kClosing = "closing";
|
|
const char* const RTCDataChannelState::kClosed = "closed";
|
|
|
|
const char* const RTCStatsIceCandidatePairState::kFrozen = "frozen";
|
|
const char* const RTCStatsIceCandidatePairState::kWaiting = "waiting";
|
|
const char* const RTCStatsIceCandidatePairState::kInProgress = "in-progress";
|
|
const char* const RTCStatsIceCandidatePairState::kFailed = "failed";
|
|
const char* const RTCStatsIceCandidatePairState::kSucceeded = "succeeded";
|
|
|
|
// Strings defined in https://tools.ietf.org/html/rfc5245.
|
|
const char* const RTCIceCandidateType::kHost = "host";
|
|
const char* const RTCIceCandidateType::kSrflx = "srflx";
|
|
const char* const RTCIceCandidateType::kPrflx = "prflx";
|
|
const char* const RTCIceCandidateType::kRelay = "relay";
|
|
|
|
const char* const RTCDtlsTransportState::kNew = "new";
|
|
const char* const RTCDtlsTransportState::kConnecting = "connecting";
|
|
const char* const RTCDtlsTransportState::kConnected = "connected";
|
|
const char* const RTCDtlsTransportState::kClosed = "closed";
|
|
const char* const RTCDtlsTransportState::kFailed = "failed";
|
|
|
|
const char* const RTCMediaStreamTrackKind::kAudio = "audio";
|
|
const char* const RTCMediaStreamTrackKind::kVideo = "video";
|
|
|
|
// https://w3c.github.io/webrtc-stats/#dom-rtcnetworktype
|
|
const char* const RTCNetworkType::kBluetooth = "bluetooth";
|
|
const char* const RTCNetworkType::kCellular = "cellular";
|
|
const char* const RTCNetworkType::kEthernet = "ethernet";
|
|
const char* const RTCNetworkType::kWifi = "wifi";
|
|
const char* const RTCNetworkType::kWimax = "wimax";
|
|
const char* const RTCNetworkType::kVpn = "vpn";
|
|
const char* const RTCNetworkType::kUnknown = "unknown";
|
|
|
|
// https://w3c.github.io/webrtc-stats/#dom-rtcqualitylimitationreason
|
|
const char* const RTCQualityLimitationReason::kNone = "none";
|
|
const char* const RTCQualityLimitationReason::kCpu = "cpu";
|
|
const char* const RTCQualityLimitationReason::kBandwidth = "bandwidth";
|
|
const char* const RTCQualityLimitationReason::kOther = "other";
|
|
|
|
// https://webrtc.org/experiments/rtp-hdrext/video-content-type/
|
|
const char* const RTCContentType::kUnspecified = "unspecified";
|
|
const char* const RTCContentType::kScreenshare = "screenshare";
|
|
|
|
// https://w3c.github.io/webrtc-stats/#dom-rtcdtlsrole
|
|
const char* const RTCDtlsRole::kUnknown = "unknown";
|
|
const char* const RTCDtlsRole::kClient = "client";
|
|
const char* const RTCDtlsRole::kServer = "server";
|
|
|
|
// https://www.w3.org/TR/webrtc/#rtcicerole
|
|
const char* const RTCIceRole::kUnknown = "unknown";
|
|
const char* const RTCIceRole::kControlled = "controlled";
|
|
const char* const RTCIceRole::kControlling = "controlling";
|
|
|
|
// https://www.w3.org/TR/webrtc/#dom-rtcicetransportstate
|
|
const char* const RTCIceTransportState::kNew = "new";
|
|
const char* const RTCIceTransportState::kChecking = "checking";
|
|
const char* const RTCIceTransportState::kConnected = "connected";
|
|
const char* const RTCIceTransportState::kCompleted = "completed";
|
|
const char* const RTCIceTransportState::kDisconnected = "disconnected";
|
|
const char* const RTCIceTransportState::kFailed = "failed";
|
|
const char* const RTCIceTransportState::kClosed = "closed";
|
|
|
|
// clang-format off
|
|
WEBRTC_RTCSTATS_IMPL(RTCCertificateStats, RTCStats, "certificate",
|
|
&fingerprint,
|
|
&fingerprint_algorithm,
|
|
&base64_certificate,
|
|
&issuer_certificate_id)
|
|
// clang-format on
|
|
|
|
RTCCertificateStats::RTCCertificateStats(std::string id, Timestamp timestamp)
|
|
: RTCStats(std::move(id), timestamp),
|
|
fingerprint("fingerprint"),
|
|
fingerprint_algorithm("fingerprintAlgorithm"),
|
|
base64_certificate("base64Certificate"),
|
|
issuer_certificate_id("issuerCertificateId") {}
|
|
|
|
RTCCertificateStats::RTCCertificateStats(const RTCCertificateStats& other) =
|
|
default;
|
|
RTCCertificateStats::~RTCCertificateStats() {}
|
|
|
|
// clang-format off
|
|
WEBRTC_RTCSTATS_IMPL(RTCCodecStats, RTCStats, "codec",
|
|
&transport_id,
|
|
&payload_type,
|
|
&mime_type,
|
|
&clock_rate,
|
|
&channels,
|
|
&sdp_fmtp_line)
|
|
// clang-format on
|
|
|
|
RTCCodecStats::RTCCodecStats(std::string id, Timestamp timestamp)
|
|
: RTCStats(std::move(id), timestamp),
|
|
transport_id("transportId"),
|
|
payload_type("payloadType"),
|
|
mime_type("mimeType"),
|
|
clock_rate("clockRate"),
|
|
channels("channels"),
|
|
sdp_fmtp_line("sdpFmtpLine") {}
|
|
|
|
RTCCodecStats::RTCCodecStats(const RTCCodecStats& other) = default;
|
|
|
|
RTCCodecStats::~RTCCodecStats() {}
|
|
|
|
// clang-format off
|
|
WEBRTC_RTCSTATS_IMPL(RTCDataChannelStats, RTCStats, "data-channel",
|
|
&label,
|
|
&protocol,
|
|
&data_channel_identifier,
|
|
&state,
|
|
&messages_sent,
|
|
&bytes_sent,
|
|
&messages_received,
|
|
&bytes_received)
|
|
// clang-format on
|
|
|
|
RTCDataChannelStats::RTCDataChannelStats(std::string id, Timestamp timestamp)
|
|
: RTCStats(std::move(id), timestamp),
|
|
label("label"),
|
|
protocol("protocol"),
|
|
data_channel_identifier("dataChannelIdentifier"),
|
|
state("state"),
|
|
messages_sent("messagesSent"),
|
|
bytes_sent("bytesSent"),
|
|
messages_received("messagesReceived"),
|
|
bytes_received("bytesReceived") {}
|
|
|
|
RTCDataChannelStats::RTCDataChannelStats(const RTCDataChannelStats& other) =
|
|
default;
|
|
|
|
RTCDataChannelStats::~RTCDataChannelStats() {}
|
|
|
|
// clang-format off
|
|
WEBRTC_RTCSTATS_IMPL(RTCIceCandidatePairStats, RTCStats, "candidate-pair",
|
|
&transport_id,
|
|
&local_candidate_id,
|
|
&remote_candidate_id,
|
|
&state,
|
|
&priority,
|
|
&nominated,
|
|
&writable,
|
|
&packets_sent,
|
|
&packets_received,
|
|
&bytes_sent,
|
|
&bytes_received,
|
|
&total_round_trip_time,
|
|
¤t_round_trip_time,
|
|
&available_outgoing_bitrate,
|
|
&available_incoming_bitrate,
|
|
&requests_received,
|
|
&requests_sent,
|
|
&responses_received,
|
|
&responses_sent,
|
|
&consent_requests_sent,
|
|
&packets_discarded_on_send,
|
|
&bytes_discarded_on_send,
|
|
&last_packet_received_timestamp,
|
|
&last_packet_sent_timestamp)
|
|
// clang-format on
|
|
|
|
RTCIceCandidatePairStats::RTCIceCandidatePairStats(std::string id,
|
|
Timestamp timestamp)
|
|
: RTCStats(std::move(id), timestamp),
|
|
transport_id("transportId"),
|
|
local_candidate_id("localCandidateId"),
|
|
remote_candidate_id("remoteCandidateId"),
|
|
state("state"),
|
|
priority("priority"),
|
|
nominated("nominated"),
|
|
writable("writable"),
|
|
packets_sent("packetsSent"),
|
|
packets_received("packetsReceived"),
|
|
bytes_sent("bytesSent"),
|
|
bytes_received("bytesReceived"),
|
|
total_round_trip_time("totalRoundTripTime"),
|
|
current_round_trip_time("currentRoundTripTime"),
|
|
available_outgoing_bitrate("availableOutgoingBitrate"),
|
|
available_incoming_bitrate("availableIncomingBitrate"),
|
|
requests_received("requestsReceived"),
|
|
requests_sent("requestsSent"),
|
|
responses_received("responsesReceived"),
|
|
responses_sent("responsesSent"),
|
|
consent_requests_sent("consentRequestsSent"),
|
|
packets_discarded_on_send("packetsDiscardedOnSend"),
|
|
bytes_discarded_on_send("bytesDiscardedOnSend"),
|
|
last_packet_received_timestamp("lastPacketReceivedTimestamp"),
|
|
last_packet_sent_timestamp("lastPacketSentTimestamp") {}
|
|
|
|
RTCIceCandidatePairStats::RTCIceCandidatePairStats(
|
|
const RTCIceCandidatePairStats& other) = default;
|
|
|
|
RTCIceCandidatePairStats::~RTCIceCandidatePairStats() {}
|
|
|
|
// clang-format off
|
|
WEBRTC_RTCSTATS_IMPL(RTCIceCandidateStats, RTCStats, "abstract-ice-candidate",
|
|
&transport_id,
|
|
&is_remote,
|
|
&network_type,
|
|
&ip,
|
|
&address,
|
|
&port,
|
|
&protocol,
|
|
&relay_protocol,
|
|
&candidate_type,
|
|
&priority,
|
|
&url,
|
|
&foundation,
|
|
&related_address,
|
|
&related_port,
|
|
&username_fragment,
|
|
&tcp_type,
|
|
&vpn,
|
|
&network_adapter_type)
|
|
// clang-format on
|
|
|
|
RTCIceCandidateStats::RTCIceCandidateStats(std::string id,
|
|
Timestamp timestamp,
|
|
bool is_remote)
|
|
: RTCStats(std::move(id), timestamp),
|
|
transport_id("transportId"),
|
|
is_remote("isRemote", is_remote),
|
|
network_type("networkType"),
|
|
ip("ip"),
|
|
address("address"),
|
|
port("port"),
|
|
protocol("protocol"),
|
|
relay_protocol("relayProtocol"),
|
|
candidate_type("candidateType"),
|
|
priority("priority"),
|
|
url("url"),
|
|
foundation("foundation"),
|
|
related_address("relatedAddress"),
|
|
related_port("relatedPort"),
|
|
username_fragment("usernameFragment"),
|
|
tcp_type("tcpType"),
|
|
vpn("vpn"),
|
|
network_adapter_type("networkAdapterType") {}
|
|
|
|
RTCIceCandidateStats::RTCIceCandidateStats(const RTCIceCandidateStats& other) =
|
|
default;
|
|
|
|
RTCIceCandidateStats::~RTCIceCandidateStats() {}
|
|
|
|
const char RTCLocalIceCandidateStats::kType[] = "local-candidate";
|
|
|
|
RTCLocalIceCandidateStats::RTCLocalIceCandidateStats(std::string id,
|
|
Timestamp timestamp)
|
|
: RTCIceCandidateStats(std::move(id), timestamp, false) {}
|
|
|
|
std::unique_ptr<RTCStats> RTCLocalIceCandidateStats::copy() const {
|
|
return std::make_unique<RTCLocalIceCandidateStats>(*this);
|
|
}
|
|
|
|
const char* RTCLocalIceCandidateStats::type() const {
|
|
return kType;
|
|
}
|
|
|
|
const char RTCRemoteIceCandidateStats::kType[] = "remote-candidate";
|
|
|
|
RTCRemoteIceCandidateStats::RTCRemoteIceCandidateStats(std::string id,
|
|
Timestamp timestamp)
|
|
: RTCIceCandidateStats(std::move(id), timestamp, true) {}
|
|
|
|
std::unique_ptr<RTCStats> RTCRemoteIceCandidateStats::copy() const {
|
|
return std::make_unique<RTCRemoteIceCandidateStats>(*this);
|
|
}
|
|
|
|
const char* RTCRemoteIceCandidateStats::type() const {
|
|
return kType;
|
|
}
|
|
|
|
// clang-format off
|
|
WEBRTC_RTCSTATS_IMPL(RTCPeerConnectionStats, RTCStats, "peer-connection",
|
|
&data_channels_opened,
|
|
&data_channels_closed)
|
|
// clang-format on
|
|
|
|
RTCPeerConnectionStats::RTCPeerConnectionStats(std::string id,
|
|
Timestamp timestamp)
|
|
: RTCStats(std::move(id), timestamp),
|
|
data_channels_opened("dataChannelsOpened"),
|
|
data_channels_closed("dataChannelsClosed") {}
|
|
|
|
RTCPeerConnectionStats::RTCPeerConnectionStats(
|
|
const RTCPeerConnectionStats& other) = default;
|
|
|
|
RTCPeerConnectionStats::~RTCPeerConnectionStats() {}
|
|
|
|
// clang-format off
|
|
WEBRTC_RTCSTATS_IMPL(RTCRtpStreamStats, RTCStats, "rtp",
|
|
&ssrc,
|
|
&kind,
|
|
&transport_id,
|
|
&codec_id)
|
|
// clang-format on
|
|
|
|
RTCRtpStreamStats::RTCRtpStreamStats(std::string id, Timestamp timestamp)
|
|
: RTCStats(std::move(id), timestamp),
|
|
ssrc("ssrc"),
|
|
kind("kind"),
|
|
transport_id("transportId"),
|
|
codec_id("codecId") {}
|
|
|
|
RTCRtpStreamStats::RTCRtpStreamStats(const RTCRtpStreamStats& other) = default;
|
|
|
|
RTCRtpStreamStats::~RTCRtpStreamStats() {}
|
|
|
|
// clang-format off
|
|
WEBRTC_RTCSTATS_IMPL(
|
|
RTCReceivedRtpStreamStats, RTCRtpStreamStats, "received-rtp",
|
|
&jitter,
|
|
&packets_lost)
|
|
// clang-format on
|
|
|
|
RTCReceivedRtpStreamStats::RTCReceivedRtpStreamStats(std::string id,
|
|
Timestamp timestamp)
|
|
: RTCRtpStreamStats(std::move(id), timestamp),
|
|
jitter("jitter"),
|
|
packets_lost("packetsLost") {}
|
|
|
|
RTCReceivedRtpStreamStats::RTCReceivedRtpStreamStats(
|
|
const RTCReceivedRtpStreamStats& other) = default;
|
|
|
|
RTCReceivedRtpStreamStats::~RTCReceivedRtpStreamStats() {}
|
|
|
|
// clang-format off
|
|
WEBRTC_RTCSTATS_IMPL(
|
|
RTCSentRtpStreamStats, RTCRtpStreamStats, "sent-rtp",
|
|
&packets_sent,
|
|
&bytes_sent)
|
|
// clang-format on
|
|
|
|
RTCSentRtpStreamStats::RTCSentRtpStreamStats(std::string id,
|
|
Timestamp timestamp)
|
|
: RTCRtpStreamStats(std::move(id), timestamp),
|
|
packets_sent("packetsSent"),
|
|
bytes_sent("bytesSent") {}
|
|
|
|
RTCSentRtpStreamStats::RTCSentRtpStreamStats(
|
|
const RTCSentRtpStreamStats& other) = default;
|
|
|
|
RTCSentRtpStreamStats::~RTCSentRtpStreamStats() {}
|
|
|
|
// clang-format off
|
|
WEBRTC_RTCSTATS_IMPL(
|
|
RTCInboundRtpStreamStats, RTCReceivedRtpStreamStats, "inbound-rtp",
|
|
&track_identifier,
|
|
&mid,
|
|
&remote_id,
|
|
&packets_received,
|
|
&packets_discarded,
|
|
&fec_packets_received,
|
|
&fec_packets_discarded,
|
|
&bytes_received,
|
|
&header_bytes_received,
|
|
&retransmitted_packets_received,
|
|
&retransmitted_bytes_received,
|
|
&last_packet_received_timestamp,
|
|
&jitter_buffer_delay,
|
|
&jitter_buffer_target_delay,
|
|
&jitter_buffer_minimum_delay,
|
|
&jitter_buffer_emitted_count,
|
|
&total_samples_received,
|
|
&concealed_samples,
|
|
&silent_concealed_samples,
|
|
&concealment_events,
|
|
&inserted_samples_for_deceleration,
|
|
&removed_samples_for_acceleration,
|
|
&audio_level,
|
|
&total_audio_energy,
|
|
&total_samples_duration,
|
|
&playout_id,
|
|
&frames_received,
|
|
&frame_width,
|
|
&frame_height,
|
|
&frames_per_second,
|
|
&frames_decoded,
|
|
&key_frames_decoded,
|
|
&frames_dropped,
|
|
&total_decode_time,
|
|
&total_processing_delay,
|
|
&total_assembly_time,
|
|
&frames_assembled_from_multiple_packets,
|
|
&total_inter_frame_delay,
|
|
&total_squared_inter_frame_delay,
|
|
&pause_count,
|
|
&total_pauses_duration,
|
|
&freeze_count,
|
|
&total_freezes_duration,
|
|
&content_type,
|
|
&estimated_playout_timestamp,
|
|
&decoder_implementation,
|
|
&fir_count,
|
|
&pli_count,
|
|
&nack_count,
|
|
&qp_sum,
|
|
&goog_timing_frame_info,
|
|
&power_efficient_decoder,
|
|
&jitter_buffer_flushes,
|
|
&delayed_packet_outage_samples,
|
|
&relative_packet_arrival_delay,
|
|
&interruption_count,
|
|
&total_interruption_duration,
|
|
&min_playout_delay)
|
|
// clang-format on
|
|
|
|
RTCInboundRtpStreamStats::RTCInboundRtpStreamStats(std::string id,
|
|
Timestamp timestamp)
|
|
: RTCReceivedRtpStreamStats(std::move(id), timestamp),
|
|
playout_id("playoutId"),
|
|
track_identifier("trackIdentifier"),
|
|
mid("mid"),
|
|
remote_id("remoteId"),
|
|
packets_received("packetsReceived"),
|
|
packets_discarded("packetsDiscarded"),
|
|
fec_packets_received("fecPacketsReceived"),
|
|
fec_packets_discarded("fecPacketsDiscarded"),
|
|
bytes_received("bytesReceived"),
|
|
header_bytes_received("headerBytesReceived"),
|
|
retransmitted_packets_received("retransmittedPacketsReceived"),
|
|
retransmitted_bytes_received("retransmittedBytesReceived"),
|
|
last_packet_received_timestamp("lastPacketReceivedTimestamp"),
|
|
jitter_buffer_delay("jitterBufferDelay"),
|
|
jitter_buffer_target_delay("jitterBufferTargetDelay"),
|
|
jitter_buffer_minimum_delay("jitterBufferMinimumDelay"),
|
|
jitter_buffer_emitted_count("jitterBufferEmittedCount"),
|
|
total_samples_received("totalSamplesReceived"),
|
|
concealed_samples("concealedSamples"),
|
|
silent_concealed_samples("silentConcealedSamples"),
|
|
concealment_events("concealmentEvents"),
|
|
inserted_samples_for_deceleration("insertedSamplesForDeceleration"),
|
|
removed_samples_for_acceleration("removedSamplesForAcceleration"),
|
|
audio_level("audioLevel"),
|
|
total_audio_energy("totalAudioEnergy"),
|
|
total_samples_duration("totalSamplesDuration"),
|
|
frames_received("framesReceived"),
|
|
frame_width("frameWidth"),
|
|
frame_height("frameHeight"),
|
|
frames_per_second("framesPerSecond"),
|
|
frames_decoded("framesDecoded"),
|
|
key_frames_decoded("keyFramesDecoded"),
|
|
frames_dropped("framesDropped"),
|
|
total_decode_time("totalDecodeTime"),
|
|
total_processing_delay("totalProcessingDelay"),
|
|
total_assembly_time("totalAssemblyTime"),
|
|
frames_assembled_from_multiple_packets(
|
|
"framesAssembledFromMultiplePackets"),
|
|
total_inter_frame_delay("totalInterFrameDelay"),
|
|
total_squared_inter_frame_delay("totalSquaredInterFrameDelay"),
|
|
pause_count("pauseCount"),
|
|
total_pauses_duration("totalPausesDuration"),
|
|
freeze_count("freezeCount"),
|
|
total_freezes_duration("totalFreezesDuration"),
|
|
content_type("contentType"),
|
|
estimated_playout_timestamp("estimatedPlayoutTimestamp"),
|
|
decoder_implementation("decoderImplementation"),
|
|
fir_count("firCount"),
|
|
pli_count("pliCount"),
|
|
nack_count("nackCount"),
|
|
qp_sum("qpSum"),
|
|
goog_timing_frame_info("googTimingFrameInfo"),
|
|
power_efficient_decoder("powerEfficientDecoder"),
|
|
jitter_buffer_flushes(
|
|
"jitterBufferFlushes",
|
|
{NonStandardGroupId::kRtcAudioJitterBufferMaxPackets}),
|
|
delayed_packet_outage_samples(
|
|
"delayedPacketOutageSamples",
|
|
{NonStandardGroupId::kRtcAudioJitterBufferMaxPackets,
|
|
NonStandardGroupId::kRtcStatsRelativePacketArrivalDelay}),
|
|
relative_packet_arrival_delay(
|
|
"relativePacketArrivalDelay",
|
|
{NonStandardGroupId::kRtcStatsRelativePacketArrivalDelay}),
|
|
interruption_count("interruptionCount"),
|
|
total_interruption_duration("totalInterruptionDuration"),
|
|
min_playout_delay("minPlayoutDelay") {}
|
|
|
|
RTCInboundRtpStreamStats::RTCInboundRtpStreamStats(
|
|
const RTCInboundRtpStreamStats& other) = default;
|
|
RTCInboundRtpStreamStats::~RTCInboundRtpStreamStats() {}
|
|
|
|
// clang-format off
|
|
WEBRTC_RTCSTATS_IMPL(
|
|
RTCOutboundRtpStreamStats, RTCSentRtpStreamStats, "outbound-rtp",
|
|
&media_source_id,
|
|
&remote_id,
|
|
&mid,
|
|
&rid,
|
|
&retransmitted_packets_sent,
|
|
&header_bytes_sent,
|
|
&retransmitted_bytes_sent,
|
|
&target_bitrate,
|
|
&frames_encoded,
|
|
&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_durations,
|
|
&quality_limitation_resolution_changes,
|
|
&content_type,
|
|
&encoder_implementation,
|
|
&fir_count,
|
|
&pli_count,
|
|
&nack_count,
|
|
&qp_sum,
|
|
&active,
|
|
&power_efficient_encoder,
|
|
&scalability_mode)
|
|
// clang-format on
|
|
|
|
RTCOutboundRtpStreamStats::RTCOutboundRtpStreamStats(std::string id,
|
|
Timestamp timestamp)
|
|
: RTCSentRtpStreamStats(std::move(id), timestamp),
|
|
media_source_id("mediaSourceId"),
|
|
remote_id("remoteId"),
|
|
mid("mid"),
|
|
rid("rid"),
|
|
retransmitted_packets_sent("retransmittedPacketsSent"),
|
|
header_bytes_sent("headerBytesSent"),
|
|
retransmitted_bytes_sent("retransmittedBytesSent"),
|
|
target_bitrate("targetBitrate"),
|
|
frames_encoded("framesEncoded"),
|
|
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_durations("qualityLimitationDurations"),
|
|
quality_limitation_resolution_changes(
|
|
"qualityLimitationResolutionChanges"),
|
|
content_type("contentType"),
|
|
encoder_implementation("encoderImplementation"),
|
|
fir_count("firCount"),
|
|
pli_count("pliCount"),
|
|
nack_count("nackCount"),
|
|
qp_sum("qpSum"),
|
|
active("active"),
|
|
power_efficient_encoder("powerEfficientEncoder"),
|
|
scalability_mode("scalabilityMode") {}
|
|
|
|
RTCOutboundRtpStreamStats::RTCOutboundRtpStreamStats(
|
|
const RTCOutboundRtpStreamStats& other) = default;
|
|
|
|
RTCOutboundRtpStreamStats::~RTCOutboundRtpStreamStats() {}
|
|
|
|
// clang-format off
|
|
WEBRTC_RTCSTATS_IMPL(
|
|
RTCRemoteInboundRtpStreamStats, RTCReceivedRtpStreamStats,
|
|
"remote-inbound-rtp",
|
|
&local_id,
|
|
&round_trip_time,
|
|
&fraction_lost,
|
|
&total_round_trip_time,
|
|
&round_trip_time_measurements)
|
|
// clang-format on
|
|
|
|
RTCRemoteInboundRtpStreamStats::RTCRemoteInboundRtpStreamStats(
|
|
std::string id,
|
|
Timestamp timestamp)
|
|
: RTCReceivedRtpStreamStats(std::move(id), timestamp),
|
|
local_id("localId"),
|
|
round_trip_time("roundTripTime"),
|
|
fraction_lost("fractionLost"),
|
|
total_round_trip_time("totalRoundTripTime"),
|
|
round_trip_time_measurements("roundTripTimeMeasurements") {}
|
|
|
|
RTCRemoteInboundRtpStreamStats::RTCRemoteInboundRtpStreamStats(
|
|
const RTCRemoteInboundRtpStreamStats& other) = default;
|
|
|
|
RTCRemoteInboundRtpStreamStats::~RTCRemoteInboundRtpStreamStats() {}
|
|
|
|
// clang-format off
|
|
WEBRTC_RTCSTATS_IMPL(
|
|
RTCRemoteOutboundRtpStreamStats, RTCSentRtpStreamStats,
|
|
"remote-outbound-rtp",
|
|
&local_id,
|
|
&remote_timestamp,
|
|
&reports_sent,
|
|
&round_trip_time,
|
|
&round_trip_time_measurements,
|
|
&total_round_trip_time)
|
|
// clang-format on
|
|
|
|
RTCRemoteOutboundRtpStreamStats::RTCRemoteOutboundRtpStreamStats(
|
|
std::string id,
|
|
Timestamp timestamp)
|
|
: RTCSentRtpStreamStats(std::move(id), timestamp),
|
|
local_id("localId"),
|
|
remote_timestamp("remoteTimestamp"),
|
|
reports_sent("reportsSent"),
|
|
round_trip_time("roundTripTime"),
|
|
round_trip_time_measurements("roundTripTimeMeasurements"),
|
|
total_round_trip_time("totalRoundTripTime") {}
|
|
|
|
RTCRemoteOutboundRtpStreamStats::RTCRemoteOutboundRtpStreamStats(
|
|
const RTCRemoteOutboundRtpStreamStats& other) = default;
|
|
|
|
RTCRemoteOutboundRtpStreamStats::~RTCRemoteOutboundRtpStreamStats() {}
|
|
|
|
// clang-format off
|
|
WEBRTC_RTCSTATS_IMPL(RTCMediaSourceStats, RTCStats, "parent-media-source",
|
|
&track_identifier,
|
|
&kind)
|
|
// clang-format on
|
|
|
|
RTCMediaSourceStats::RTCMediaSourceStats(std::string id, Timestamp timestamp)
|
|
: RTCStats(std::move(id), timestamp),
|
|
track_identifier("trackIdentifier"),
|
|
kind("kind") {}
|
|
|
|
RTCMediaSourceStats::RTCMediaSourceStats(const RTCMediaSourceStats& other) =
|
|
default;
|
|
|
|
RTCMediaSourceStats::~RTCMediaSourceStats() {}
|
|
|
|
// clang-format off
|
|
WEBRTC_RTCSTATS_IMPL(RTCAudioSourceStats, RTCMediaSourceStats, "media-source",
|
|
&audio_level,
|
|
&total_audio_energy,
|
|
&total_samples_duration,
|
|
&echo_return_loss,
|
|
&echo_return_loss_enhancement)
|
|
// clang-format on
|
|
|
|
RTCAudioSourceStats::RTCAudioSourceStats(std::string id, Timestamp timestamp)
|
|
: RTCMediaSourceStats(std::move(id), timestamp),
|
|
audio_level("audioLevel"),
|
|
total_audio_energy("totalAudioEnergy"),
|
|
total_samples_duration("totalSamplesDuration"),
|
|
echo_return_loss("echoReturnLoss"),
|
|
echo_return_loss_enhancement("echoReturnLossEnhancement") {}
|
|
|
|
RTCAudioSourceStats::RTCAudioSourceStats(const RTCAudioSourceStats& other) =
|
|
default;
|
|
|
|
RTCAudioSourceStats::~RTCAudioSourceStats() {}
|
|
|
|
// clang-format off
|
|
WEBRTC_RTCSTATS_IMPL(RTCVideoSourceStats, RTCMediaSourceStats, "media-source",
|
|
&width,
|
|
&height,
|
|
&frames,
|
|
&frames_per_second)
|
|
// clang-format on
|
|
|
|
RTCVideoSourceStats::RTCVideoSourceStats(std::string id, Timestamp timestamp)
|
|
: RTCMediaSourceStats(std::move(id), timestamp),
|
|
width("width"),
|
|
height("height"),
|
|
frames("frames"),
|
|
frames_per_second("framesPerSecond") {}
|
|
|
|
RTCVideoSourceStats::RTCVideoSourceStats(const RTCVideoSourceStats& other) =
|
|
default;
|
|
|
|
RTCVideoSourceStats::~RTCVideoSourceStats() {}
|
|
|
|
// clang-format off
|
|
WEBRTC_RTCSTATS_IMPL(RTCTransportStats, RTCStats, "transport",
|
|
&bytes_sent,
|
|
&packets_sent,
|
|
&bytes_received,
|
|
&packets_received,
|
|
&rtcp_transport_stats_id,
|
|
&dtls_state,
|
|
&selected_candidate_pair_id,
|
|
&local_certificate_id,
|
|
&remote_certificate_id,
|
|
&tls_version,
|
|
&dtls_cipher,
|
|
&dtls_role,
|
|
&srtp_cipher,
|
|
&selected_candidate_pair_changes,
|
|
&ice_role,
|
|
&ice_local_username_fragment,
|
|
&ice_state)
|
|
// clang-format on
|
|
|
|
RTCTransportStats::RTCTransportStats(std::string id, Timestamp timestamp)
|
|
: RTCStats(std::move(id), timestamp),
|
|
bytes_sent("bytesSent"),
|
|
packets_sent("packetsSent"),
|
|
bytes_received("bytesReceived"),
|
|
packets_received("packetsReceived"),
|
|
rtcp_transport_stats_id("rtcpTransportStatsId"),
|
|
dtls_state("dtlsState"),
|
|
selected_candidate_pair_id("selectedCandidatePairId"),
|
|
local_certificate_id("localCertificateId"),
|
|
remote_certificate_id("remoteCertificateId"),
|
|
tls_version("tlsVersion"),
|
|
dtls_cipher("dtlsCipher"),
|
|
dtls_role("dtlsRole"),
|
|
srtp_cipher("srtpCipher"),
|
|
selected_candidate_pair_changes("selectedCandidatePairChanges"),
|
|
ice_role("iceRole"),
|
|
ice_local_username_fragment("iceLocalUsernameFragment"),
|
|
ice_state("iceState") {}
|
|
|
|
RTCTransportStats::RTCTransportStats(const RTCTransportStats& other) = default;
|
|
|
|
RTCTransportStats::~RTCTransportStats() {}
|
|
|
|
RTCAudioPlayoutStats::RTCAudioPlayoutStats(const std::string& id,
|
|
Timestamp timestamp)
|
|
: RTCStats(std::move(id), timestamp),
|
|
kind("kind", "audio"),
|
|
synthesized_samples_duration("synthesizedSamplesDuration"),
|
|
synthesized_samples_events("synthesizedSamplesEvents"),
|
|
total_samples_duration("totalSamplesDuration"),
|
|
total_playout_delay("totalPlayoutDelay"),
|
|
total_samples_count("totalSamplesCount") {}
|
|
|
|
RTCAudioPlayoutStats::RTCAudioPlayoutStats(const RTCAudioPlayoutStats& other) =
|
|
default;
|
|
|
|
RTCAudioPlayoutStats::~RTCAudioPlayoutStats() {}
|
|
|
|
// clang-format off
|
|
WEBRTC_RTCSTATS_IMPL(RTCAudioPlayoutStats, RTCStats, "media-playout",
|
|
&kind,
|
|
&synthesized_samples_duration,
|
|
&synthesized_samples_events,
|
|
&total_samples_duration,
|
|
&total_playout_delay,
|
|
&total_samples_count)
|
|
// clang-format on
|
|
|
|
} // namespace webrtc
|