2057d71775
NonStandardGroupId is no longer wired up to Chrome, but if we did want to only expose certain metrics if a field trial was enabled then the right place to do that would be in blink, where WebIDL lives. This was only used prior to the WebRtcStatsReportIdl launch and experiments haven't been active in several years so its dead code. Blocked on: - https://chromium-review.googlesource.com/c/chromium/src/+/4514754 Bug: webrtc:15162 Change-Id: Ia41a4d21d7e5f029ddb121183fbd69ae7f98fac4 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/304720 Commit-Queue: Henrik Boström <hbos@webrtc.org> Reviewed-by: Harald Alvestrand <hta@webrtc.org> Cr-Commit-Position: refs/heads/main@{#40132}
755 lines
25 KiB
C++
755 lines
25 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"),
|
|
delayed_packet_outage_samples("delayedPacketOutageSamples"),
|
|
relative_packet_arrival_delay("relativePacketArrivalDelay"),
|
|
interruption_count("interruptionCount"),
|
|
total_interruption_duration("totalInterruptionDuration"),
|
|
min_playout_delay("minPlayoutDelay"),
|
|
track_id("trackId") {}
|
|
|
|
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"),
|
|
track_id("trackId") {}
|
|
|
|
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
|