0359ba2225
implements a total frame assembly time statistic that measures the cumulative time between the arrival of the first packet of a frame (the lowest reception time) and the time all packets of the frame have been received (i.e. the highest reception time) This is similar to totalProcessingDelay https://w3c.github.io/webrtc-stats/#dom-rtcinboundrtpstreamstats-totalprocessingdelay in particular with respect to only being incremented for frames that are being decoded but does not include the amount of time spent decoding the frame. This statistic is useful for evaluating mechanisms like NACK and FEC and gives some insight into the behavior of the pacer sending the packets. Note that for frames with just a single packet the assembly time will be zero. In order to calculate an average assembly time an additional frames_assembled_from_multiple_packets counter for frames with more than a single packet is added. Currently this is a nonstandard stat so will only show up in webrtc-internals and not in getStats. Formally it can be defined as totalAssemblyTime of type double Only exists for video. The sum of the time, in seconds, each video frame takes from the time the first RTP packet is received (reception timestamp) and to the time the last RTP packet of a frame is received. Given the complexities involved, the time of arrival or the reception timestamp is measured as close to the network layer as possible. This metric is not incremented for frames that are not decoded, i.e., framesDropped, partialFramesLost or frames that fail decoding for other reasons (if any). Only incremented for frames consisting of more than one RTP packet. The average frame assembly time can be calculated by dividing the totalAssemblyTime with framesAssembledFromMultiplePacket. framesAssembledFromMultiplePacket of type unsigned long Only exists for video. It represents the total number of frames correctly decoded for this RTP stream that consist of more than one RTP packet. For such frames the totalAssemblyTime is incremented. BUG=webrtc:13986 Change-Id: Ie0ae431d72a57a0001c3240daba8eda35955f04e Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/260920 Reviewed-by: Harald Alvestrand <hta@webrtc.org> Reviewed-by: Henrik Boström <hbos@webrtc.org> Commit-Queue: Harald Alvestrand <hta@webrtc.org> Cr-Commit-Position: refs/heads/main@{#36922}
1170 lines
44 KiB
C++
1170 lines
44 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(const std::string& id,
|
|
int64_t timestamp_us)
|
|
: RTCCertificateStats(std::string(id), timestamp_us) {}
|
|
|
|
RTCCertificateStats::RTCCertificateStats(std::string&& id, int64_t timestamp_us)
|
|
: RTCStats(std::move(id), timestamp_us),
|
|
fingerprint("fingerprint"),
|
|
fingerprint_algorithm("fingerprintAlgorithm"),
|
|
base64_certificate("base64Certificate"),
|
|
issuer_certificate_id("issuerCertificateId") {}
|
|
|
|
RTCCertificateStats::RTCCertificateStats(const RTCCertificateStats& other)
|
|
: RTCStats(other.id(), other.timestamp_us()),
|
|
fingerprint(other.fingerprint),
|
|
fingerprint_algorithm(other.fingerprint_algorithm),
|
|
base64_certificate(other.base64_certificate),
|
|
issuer_certificate_id(other.issuer_certificate_id) {}
|
|
|
|
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(const std::string& id, int64_t timestamp_us)
|
|
: RTCCodecStats(std::string(id), timestamp_us) {}
|
|
|
|
RTCCodecStats::RTCCodecStats(std::string&& id, int64_t timestamp_us)
|
|
: RTCStats(std::move(id), timestamp_us),
|
|
transport_id("transportId"),
|
|
payload_type("payloadType"),
|
|
mime_type("mimeType"),
|
|
clock_rate("clockRate"),
|
|
channels("channels"),
|
|
sdp_fmtp_line("sdpFmtpLine") {}
|
|
|
|
RTCCodecStats::RTCCodecStats(const RTCCodecStats& other)
|
|
: RTCStats(other.id(), other.timestamp_us()),
|
|
transport_id(other.transport_id),
|
|
payload_type(other.payload_type),
|
|
mime_type(other.mime_type),
|
|
clock_rate(other.clock_rate),
|
|
channels(other.channels),
|
|
sdp_fmtp_line(other.sdp_fmtp_line) {}
|
|
|
|
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(const std::string& id,
|
|
int64_t timestamp_us)
|
|
: RTCDataChannelStats(std::string(id), timestamp_us) {}
|
|
|
|
RTCDataChannelStats::RTCDataChannelStats(std::string&& id, int64_t timestamp_us)
|
|
: RTCStats(std::move(id), timestamp_us),
|
|
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)
|
|
: RTCStats(other.id(), other.timestamp_us()),
|
|
label(other.label),
|
|
protocol(other.protocol),
|
|
data_channel_identifier(other.data_channel_identifier),
|
|
state(other.state),
|
|
messages_sent(other.messages_sent),
|
|
bytes_sent(other.bytes_sent),
|
|
messages_received(other.messages_received),
|
|
bytes_received(other.bytes_received) {}
|
|
|
|
RTCDataChannelStats::~RTCDataChannelStats() {}
|
|
|
|
// clang-format off
|
|
WEBRTC_RTCSTATS_IMPL(RTCIceCandidatePairStats, RTCStats, "candidate-pair",
|
|
&transport_id,
|
|
&local_candidate_id,
|
|
&remote_candidate_id,
|
|
&state,
|
|
&priority,
|
|
&nominated,
|
|
&writable,
|
|
&readable,
|
|
&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,
|
|
&retransmissions_received,
|
|
&retransmissions_sent,
|
|
&consent_requests_received,
|
|
&consent_requests_sent,
|
|
&consent_responses_received,
|
|
&consent_responses_sent,
|
|
&packets_discarded_on_send,
|
|
&bytes_discarded_on_send)
|
|
// clang-format on
|
|
|
|
RTCIceCandidatePairStats::RTCIceCandidatePairStats(const std::string& id,
|
|
int64_t timestamp_us)
|
|
: RTCIceCandidatePairStats(std::string(id), timestamp_us) {}
|
|
|
|
RTCIceCandidatePairStats::RTCIceCandidatePairStats(std::string&& id,
|
|
int64_t timestamp_us)
|
|
: RTCStats(std::move(id), timestamp_us),
|
|
transport_id("transportId"),
|
|
local_candidate_id("localCandidateId"),
|
|
remote_candidate_id("remoteCandidateId"),
|
|
state("state"),
|
|
priority("priority"),
|
|
nominated("nominated"),
|
|
writable("writable"),
|
|
readable("readable"),
|
|
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"),
|
|
retransmissions_received("retransmissionsReceived"),
|
|
retransmissions_sent("retransmissionsSent"),
|
|
consent_requests_received("consentRequestsReceived"),
|
|
consent_requests_sent("consentRequestsSent"),
|
|
consent_responses_received("consentResponsesReceived"),
|
|
consent_responses_sent("consentResponsesSent"),
|
|
packets_discarded_on_send("packetsDiscardedOnSend"),
|
|
bytes_discarded_on_send("bytesDiscardedOnSend") {}
|
|
|
|
RTCIceCandidatePairStats::RTCIceCandidatePairStats(
|
|
const RTCIceCandidatePairStats& other)
|
|
: RTCStats(other.id(), other.timestamp_us()),
|
|
transport_id(other.transport_id),
|
|
local_candidate_id(other.local_candidate_id),
|
|
remote_candidate_id(other.remote_candidate_id),
|
|
state(other.state),
|
|
priority(other.priority),
|
|
nominated(other.nominated),
|
|
writable(other.writable),
|
|
readable(other.readable),
|
|
packets_sent(other.packets_sent),
|
|
packets_received(other.packets_received),
|
|
bytes_sent(other.bytes_sent),
|
|
bytes_received(other.bytes_received),
|
|
total_round_trip_time(other.total_round_trip_time),
|
|
current_round_trip_time(other.current_round_trip_time),
|
|
available_outgoing_bitrate(other.available_outgoing_bitrate),
|
|
available_incoming_bitrate(other.available_incoming_bitrate),
|
|
requests_received(other.requests_received),
|
|
requests_sent(other.requests_sent),
|
|
responses_received(other.responses_received),
|
|
responses_sent(other.responses_sent),
|
|
retransmissions_received(other.retransmissions_received),
|
|
retransmissions_sent(other.retransmissions_sent),
|
|
consent_requests_received(other.consent_requests_received),
|
|
consent_requests_sent(other.consent_requests_sent),
|
|
consent_responses_received(other.consent_responses_received),
|
|
consent_responses_sent(other.consent_responses_sent),
|
|
packets_discarded_on_send(other.packets_discarded_on_send),
|
|
bytes_discarded_on_send(other.bytes_discarded_on_send) {}
|
|
|
|
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,
|
|
&vpn,
|
|
&network_adapter_type)
|
|
// clang-format on
|
|
|
|
RTCIceCandidateStats::RTCIceCandidateStats(const std::string& id,
|
|
int64_t timestamp_us,
|
|
bool is_remote)
|
|
: RTCIceCandidateStats(std::string(id), timestamp_us, is_remote) {}
|
|
|
|
RTCIceCandidateStats::RTCIceCandidateStats(std::string&& id,
|
|
int64_t timestamp_us,
|
|
bool is_remote)
|
|
: RTCStats(std::move(id), timestamp_us),
|
|
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"),
|
|
vpn("vpn"),
|
|
network_adapter_type("networkAdapterType") {}
|
|
|
|
RTCIceCandidateStats::RTCIceCandidateStats(const RTCIceCandidateStats& other)
|
|
: RTCStats(other.id(), other.timestamp_us()),
|
|
transport_id(other.transport_id),
|
|
is_remote(other.is_remote),
|
|
network_type(other.network_type),
|
|
ip(other.ip),
|
|
address(other.address),
|
|
port(other.port),
|
|
protocol(other.protocol),
|
|
relay_protocol(other.relay_protocol),
|
|
candidate_type(other.candidate_type),
|
|
priority(other.priority),
|
|
url(other.url),
|
|
vpn(other.vpn),
|
|
network_adapter_type(other.network_adapter_type) {}
|
|
|
|
RTCIceCandidateStats::~RTCIceCandidateStats() {}
|
|
|
|
const char RTCLocalIceCandidateStats::kType[] = "local-candidate";
|
|
|
|
RTCLocalIceCandidateStats::RTCLocalIceCandidateStats(const std::string& id,
|
|
int64_t timestamp_us)
|
|
: RTCIceCandidateStats(id, timestamp_us, false) {}
|
|
|
|
RTCLocalIceCandidateStats::RTCLocalIceCandidateStats(std::string&& id,
|
|
int64_t timestamp_us)
|
|
: RTCIceCandidateStats(std::move(id), timestamp_us, false) {}
|
|
|
|
std::unique_ptr<RTCStats> RTCLocalIceCandidateStats::copy() const {
|
|
return std::unique_ptr<RTCStats>(new RTCLocalIceCandidateStats(*this));
|
|
}
|
|
|
|
const char* RTCLocalIceCandidateStats::type() const {
|
|
return kType;
|
|
}
|
|
|
|
const char RTCRemoteIceCandidateStats::kType[] = "remote-candidate";
|
|
|
|
RTCRemoteIceCandidateStats::RTCRemoteIceCandidateStats(const std::string& id,
|
|
int64_t timestamp_us)
|
|
: RTCIceCandidateStats(id, timestamp_us, true) {}
|
|
|
|
RTCRemoteIceCandidateStats::RTCRemoteIceCandidateStats(std::string&& id,
|
|
int64_t timestamp_us)
|
|
: RTCIceCandidateStats(std::move(id), timestamp_us, true) {}
|
|
|
|
std::unique_ptr<RTCStats> RTCRemoteIceCandidateStats::copy() const {
|
|
return std::unique_ptr<RTCStats>(new RTCRemoteIceCandidateStats(*this));
|
|
}
|
|
|
|
const char* RTCRemoteIceCandidateStats::type() const {
|
|
return kType;
|
|
}
|
|
|
|
// clang-format off
|
|
WEBRTC_RTCSTATS_IMPL(RTCMediaStreamStats, RTCStats, "stream",
|
|
&stream_identifier,
|
|
&track_ids)
|
|
// clang-format on
|
|
|
|
RTCMediaStreamStats::RTCMediaStreamStats(const std::string& id,
|
|
int64_t timestamp_us)
|
|
: RTCMediaStreamStats(std::string(id), timestamp_us) {}
|
|
|
|
RTCMediaStreamStats::RTCMediaStreamStats(std::string&& id, int64_t timestamp_us)
|
|
: RTCStats(std::move(id), timestamp_us),
|
|
stream_identifier("streamIdentifier"),
|
|
track_ids("trackIds") {}
|
|
|
|
RTCMediaStreamStats::RTCMediaStreamStats(const RTCMediaStreamStats& other)
|
|
: RTCStats(other.id(), other.timestamp_us()),
|
|
stream_identifier(other.stream_identifier),
|
|
track_ids(other.track_ids) {}
|
|
|
|
RTCMediaStreamStats::~RTCMediaStreamStats() {}
|
|
|
|
// clang-format off
|
|
WEBRTC_RTCSTATS_IMPL(RTCMediaStreamTrackStats, RTCStats, "track",
|
|
&track_identifier,
|
|
&media_source_id,
|
|
&remote_source,
|
|
&ended,
|
|
&detached,
|
|
&kind,
|
|
&jitter_buffer_delay,
|
|
&jitter_buffer_emitted_count,
|
|
&frame_width,
|
|
&frame_height,
|
|
&frames_per_second,
|
|
&frames_sent,
|
|
&huge_frames_sent,
|
|
&frames_received,
|
|
&frames_decoded,
|
|
&frames_dropped,
|
|
&frames_corrupted,
|
|
&partial_frames_lost,
|
|
&full_frames_lost,
|
|
&audio_level,
|
|
&total_audio_energy,
|
|
&echo_return_loss,
|
|
&echo_return_loss_enhancement,
|
|
&total_samples_received,
|
|
&total_samples_duration,
|
|
&concealed_samples,
|
|
&silent_concealed_samples,
|
|
&concealment_events,
|
|
&inserted_samples_for_deceleration,
|
|
&removed_samples_for_acceleration,
|
|
&jitter_buffer_flushes,
|
|
&delayed_packet_outage_samples,
|
|
&relative_packet_arrival_delay,
|
|
&jitter_buffer_target_delay,
|
|
&interruption_count,
|
|
&total_interruption_duration,
|
|
&freeze_count,
|
|
&pause_count,
|
|
&total_freezes_duration,
|
|
&total_pauses_duration,
|
|
&total_frames_duration,
|
|
&sum_squared_frame_durations)
|
|
// clang-format on
|
|
|
|
RTCMediaStreamTrackStats::RTCMediaStreamTrackStats(const std::string& id,
|
|
int64_t timestamp_us,
|
|
const char* kind)
|
|
: RTCMediaStreamTrackStats(std::string(id), timestamp_us, kind) {}
|
|
|
|
RTCMediaStreamTrackStats::RTCMediaStreamTrackStats(std::string&& id,
|
|
int64_t timestamp_us,
|
|
const char* kind)
|
|
: RTCStats(std::move(id), timestamp_us),
|
|
track_identifier("trackIdentifier"),
|
|
media_source_id("mediaSourceId"),
|
|
remote_source("remoteSource"),
|
|
ended("ended"),
|
|
detached("detached"),
|
|
kind("kind", kind),
|
|
jitter_buffer_delay("jitterBufferDelay"),
|
|
jitter_buffer_emitted_count("jitterBufferEmittedCount"),
|
|
frame_width("frameWidth"),
|
|
frame_height("frameHeight"),
|
|
frames_per_second("framesPerSecond"),
|
|
frames_sent("framesSent"),
|
|
huge_frames_sent("hugeFramesSent"),
|
|
frames_received("framesReceived"),
|
|
frames_decoded("framesDecoded"),
|
|
frames_dropped("framesDropped"),
|
|
frames_corrupted("framesCorrupted"),
|
|
partial_frames_lost("partialFramesLost"),
|
|
full_frames_lost("fullFramesLost"),
|
|
audio_level("audioLevel"),
|
|
total_audio_energy("totalAudioEnergy"),
|
|
echo_return_loss("echoReturnLoss"),
|
|
echo_return_loss_enhancement("echoReturnLossEnhancement"),
|
|
total_samples_received("totalSamplesReceived"),
|
|
total_samples_duration("totalSamplesDuration"),
|
|
concealed_samples("concealedSamples"),
|
|
silent_concealed_samples("silentConcealedSamples"),
|
|
concealment_events("concealmentEvents"),
|
|
inserted_samples_for_deceleration("insertedSamplesForDeceleration"),
|
|
removed_samples_for_acceleration("removedSamplesForAcceleration"),
|
|
jitter_buffer_flushes(
|
|
"jitterBufferFlushes",
|
|
{NonStandardGroupId::kRtcAudioJitterBufferMaxPackets}),
|
|
delayed_packet_outage_samples(
|
|
"delayedPacketOutageSamples",
|
|
{NonStandardGroupId::kRtcAudioJitterBufferMaxPackets,
|
|
NonStandardGroupId::kRtcStatsRelativePacketArrivalDelay}),
|
|
relative_packet_arrival_delay(
|
|
"relativePacketArrivalDelay",
|
|
{NonStandardGroupId::kRtcStatsRelativePacketArrivalDelay}),
|
|
jitter_buffer_target_delay("jitterBufferTargetDelay"),
|
|
interruption_count("interruptionCount"),
|
|
total_interruption_duration("totalInterruptionDuration"),
|
|
freeze_count("freezeCount"),
|
|
pause_count("pauseCount"),
|
|
total_freezes_duration("totalFreezesDuration"),
|
|
total_pauses_duration("totalPausesDuration"),
|
|
total_frames_duration("totalFramesDuration"),
|
|
sum_squared_frame_durations("sumOfSquaredFramesDuration") {
|
|
RTC_DCHECK(kind == RTCMediaStreamTrackKind::kAudio ||
|
|
kind == RTCMediaStreamTrackKind::kVideo);
|
|
}
|
|
|
|
RTCMediaStreamTrackStats::RTCMediaStreamTrackStats(
|
|
const RTCMediaStreamTrackStats& other)
|
|
: RTCStats(other.id(), other.timestamp_us()),
|
|
track_identifier(other.track_identifier),
|
|
media_source_id(other.media_source_id),
|
|
remote_source(other.remote_source),
|
|
ended(other.ended),
|
|
detached(other.detached),
|
|
kind(other.kind),
|
|
jitter_buffer_delay(other.jitter_buffer_delay),
|
|
jitter_buffer_emitted_count(other.jitter_buffer_emitted_count),
|
|
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),
|
|
frames_received(other.frames_received),
|
|
frames_decoded(other.frames_decoded),
|
|
frames_dropped(other.frames_dropped),
|
|
frames_corrupted(other.frames_corrupted),
|
|
partial_frames_lost(other.partial_frames_lost),
|
|
full_frames_lost(other.full_frames_lost),
|
|
audio_level(other.audio_level),
|
|
total_audio_energy(other.total_audio_energy),
|
|
echo_return_loss(other.echo_return_loss),
|
|
echo_return_loss_enhancement(other.echo_return_loss_enhancement),
|
|
total_samples_received(other.total_samples_received),
|
|
total_samples_duration(other.total_samples_duration),
|
|
concealed_samples(other.concealed_samples),
|
|
silent_concealed_samples(other.silent_concealed_samples),
|
|
concealment_events(other.concealment_events),
|
|
inserted_samples_for_deceleration(
|
|
other.inserted_samples_for_deceleration),
|
|
removed_samples_for_acceleration(other.removed_samples_for_acceleration),
|
|
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),
|
|
pause_count(other.pause_count),
|
|
total_freezes_duration(other.total_freezes_duration),
|
|
total_pauses_duration(other.total_pauses_duration),
|
|
total_frames_duration(other.total_frames_duration),
|
|
sum_squared_frame_durations(other.sum_squared_frame_durations) {}
|
|
|
|
RTCMediaStreamTrackStats::~RTCMediaStreamTrackStats() {}
|
|
|
|
// clang-format off
|
|
WEBRTC_RTCSTATS_IMPL(RTCPeerConnectionStats, RTCStats, "peer-connection",
|
|
&data_channels_opened,
|
|
&data_channels_closed)
|
|
// clang-format on
|
|
|
|
RTCPeerConnectionStats::RTCPeerConnectionStats(const std::string& id,
|
|
int64_t timestamp_us)
|
|
: RTCPeerConnectionStats(std::string(id), timestamp_us) {}
|
|
|
|
RTCPeerConnectionStats::RTCPeerConnectionStats(std::string&& id,
|
|
int64_t timestamp_us)
|
|
: RTCStats(std::move(id), timestamp_us),
|
|
data_channels_opened("dataChannelsOpened"),
|
|
data_channels_closed("dataChannelsClosed") {}
|
|
|
|
RTCPeerConnectionStats::RTCPeerConnectionStats(
|
|
const RTCPeerConnectionStats& other)
|
|
: RTCStats(other.id(), other.timestamp_us()),
|
|
data_channels_opened(other.data_channels_opened),
|
|
data_channels_closed(other.data_channels_closed) {}
|
|
|
|
RTCPeerConnectionStats::~RTCPeerConnectionStats() {}
|
|
|
|
// clang-format off
|
|
WEBRTC_RTCSTATS_IMPL(RTCRTPStreamStats, RTCStats, "rtp",
|
|
&ssrc,
|
|
&kind,
|
|
&track_id,
|
|
&transport_id,
|
|
&codec_id,
|
|
&media_type)
|
|
// clang-format on
|
|
|
|
RTCRTPStreamStats::RTCRTPStreamStats(const std::string& id,
|
|
int64_t timestamp_us)
|
|
: RTCRTPStreamStats(std::string(id), timestamp_us) {}
|
|
|
|
RTCRTPStreamStats::RTCRTPStreamStats(std::string&& id, int64_t timestamp_us)
|
|
: RTCStats(std::move(id), timestamp_us),
|
|
ssrc("ssrc"),
|
|
kind("kind"),
|
|
track_id("trackId"),
|
|
transport_id("transportId"),
|
|
codec_id("codecId"),
|
|
media_type("mediaType") {}
|
|
|
|
RTCRTPStreamStats::RTCRTPStreamStats(const RTCRTPStreamStats& other)
|
|
: RTCStats(other.id(), other.timestamp_us()),
|
|
ssrc(other.ssrc),
|
|
kind(other.kind),
|
|
track_id(other.track_id),
|
|
transport_id(other.transport_id),
|
|
codec_id(other.codec_id),
|
|
media_type(other.media_type) {}
|
|
|
|
RTCRTPStreamStats::~RTCRTPStreamStats() {}
|
|
|
|
// clang-format off
|
|
WEBRTC_RTCSTATS_IMPL(
|
|
RTCReceivedRtpStreamStats, RTCRTPStreamStats, "received-rtp",
|
|
&jitter,
|
|
&packets_lost,
|
|
&packets_discarded)
|
|
// clang-format on
|
|
|
|
RTCReceivedRtpStreamStats::RTCReceivedRtpStreamStats(const std::string&& id,
|
|
int64_t timestamp_us)
|
|
: RTCReceivedRtpStreamStats(std::string(id), timestamp_us) {}
|
|
|
|
RTCReceivedRtpStreamStats::RTCReceivedRtpStreamStats(std::string&& id,
|
|
int64_t timestamp_us)
|
|
: RTCRTPStreamStats(std::move(id), timestamp_us),
|
|
jitter("jitter"),
|
|
packets_lost("packetsLost"),
|
|
packets_discarded("packetsDiscarded") {}
|
|
|
|
RTCReceivedRtpStreamStats::RTCReceivedRtpStreamStats(
|
|
const RTCReceivedRtpStreamStats& other)
|
|
: RTCRTPStreamStats(other),
|
|
jitter(other.jitter),
|
|
packets_lost(other.packets_lost),
|
|
packets_discarded(other.packets_discarded) {}
|
|
|
|
RTCReceivedRtpStreamStats::~RTCReceivedRtpStreamStats() {}
|
|
|
|
// clang-format off
|
|
WEBRTC_RTCSTATS_IMPL(
|
|
RTCSentRtpStreamStats, RTCRTPStreamStats, "sent-rtp",
|
|
&packets_sent,
|
|
&bytes_sent)
|
|
// clang-format on
|
|
|
|
RTCSentRtpStreamStats::RTCSentRtpStreamStats(const std::string&& id,
|
|
int64_t timestamp_us)
|
|
: RTCSentRtpStreamStats(std::string(id), timestamp_us) {}
|
|
|
|
RTCSentRtpStreamStats::RTCSentRtpStreamStats(std::string&& id,
|
|
int64_t timestamp_us)
|
|
: RTCRTPStreamStats(std::move(id), timestamp_us),
|
|
packets_sent("packetsSent"),
|
|
bytes_sent("bytesSent") {}
|
|
|
|
RTCSentRtpStreamStats::RTCSentRtpStreamStats(const RTCSentRtpStreamStats& other)
|
|
: RTCRTPStreamStats(other),
|
|
packets_sent(other.packets_sent),
|
|
bytes_sent(other.bytes_sent) {}
|
|
|
|
RTCSentRtpStreamStats::~RTCSentRtpStreamStats() {}
|
|
|
|
// clang-format off
|
|
WEBRTC_RTCSTATS_IMPL(
|
|
RTCInboundRTPStreamStats, RTCReceivedRtpStreamStats, "inbound-rtp",
|
|
&remote_id,
|
|
&packets_received,
|
|
&fec_packets_received,
|
|
&fec_packets_discarded,
|
|
&bytes_received,
|
|
&header_bytes_received,
|
|
&last_packet_received_timestamp,
|
|
&jitter_buffer_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,
|
|
&round_trip_time,
|
|
&packets_repaired,
|
|
&burst_packets_lost,
|
|
&burst_packets_discarded,
|
|
&burst_loss_count,
|
|
&burst_discard_count,
|
|
&burst_loss_rate,
|
|
&burst_discard_rate,
|
|
&gap_loss_rate,
|
|
&gap_discard_rate,
|
|
&frames_received,
|
|
&frame_width,
|
|
&frame_height,
|
|
&frame_bit_depth,
|
|
&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,
|
|
&content_type,
|
|
&estimated_playout_timestamp,
|
|
&decoder_implementation,
|
|
&fir_count,
|
|
&pli_count,
|
|
&nack_count,
|
|
&qp_sum)
|
|
// clang-format on
|
|
|
|
RTCInboundRTPStreamStats::RTCInboundRTPStreamStats(const std::string& id,
|
|
int64_t timestamp_us)
|
|
: RTCInboundRTPStreamStats(std::string(id), timestamp_us) {}
|
|
|
|
RTCInboundRTPStreamStats::RTCInboundRTPStreamStats(std::string&& id,
|
|
int64_t timestamp_us)
|
|
: RTCReceivedRtpStreamStats(std::move(id), timestamp_us),
|
|
remote_id("remoteId"),
|
|
packets_received("packetsReceived"),
|
|
fec_packets_received("fecPacketsReceived"),
|
|
fec_packets_discarded("fecPacketsDiscarded"),
|
|
bytes_received("bytesReceived"),
|
|
header_bytes_received("headerBytesReceived"),
|
|
last_packet_received_timestamp("lastPacketReceivedTimestamp"),
|
|
jitter_buffer_delay("jitterBufferDelay"),
|
|
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"),
|
|
round_trip_time("roundTripTime"),
|
|
packets_repaired("packetsRepaired"),
|
|
burst_packets_lost("burstPacketsLost"),
|
|
burst_packets_discarded("burstPacketsDiscarded"),
|
|
burst_loss_count("burstLossCount"),
|
|
burst_discard_count("burstDiscardCount"),
|
|
burst_loss_rate("burstLossRate"),
|
|
burst_discard_rate("burstDiscardRate"),
|
|
gap_loss_rate("gapLossRate"),
|
|
gap_discard_rate("gapDiscardRate"),
|
|
frames_received("framesReceived"),
|
|
frame_width("frameWidth"),
|
|
frame_height("frameHeight"),
|
|
frame_bit_depth("frameBitDepth"),
|
|
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"),
|
|
content_type("contentType"),
|
|
estimated_playout_timestamp("estimatedPlayoutTimestamp"),
|
|
decoder_implementation("decoderImplementation"),
|
|
fir_count("firCount"),
|
|
pli_count("pliCount"),
|
|
nack_count("nackCount"),
|
|
qp_sum("qpSum") {}
|
|
|
|
RTCInboundRTPStreamStats::RTCInboundRTPStreamStats(
|
|
const RTCInboundRTPStreamStats& other)
|
|
: RTCReceivedRtpStreamStats(other),
|
|
remote_id(other.remote_id),
|
|
packets_received(other.packets_received),
|
|
fec_packets_received(other.fec_packets_received),
|
|
fec_packets_discarded(other.fec_packets_discarded),
|
|
bytes_received(other.bytes_received),
|
|
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_emitted_count(other.jitter_buffer_emitted_count),
|
|
total_samples_received(other.total_samples_received),
|
|
concealed_samples(other.concealed_samples),
|
|
silent_concealed_samples(other.silent_concealed_samples),
|
|
concealment_events(other.concealment_events),
|
|
inserted_samples_for_deceleration(
|
|
other.inserted_samples_for_deceleration),
|
|
removed_samples_for_acceleration(other.removed_samples_for_acceleration),
|
|
audio_level(other.audio_level),
|
|
total_audio_energy(other.total_audio_energy),
|
|
total_samples_duration(other.total_samples_duration),
|
|
round_trip_time(other.round_trip_time),
|
|
packets_repaired(other.packets_repaired),
|
|
burst_packets_lost(other.burst_packets_lost),
|
|
burst_packets_discarded(other.burst_packets_discarded),
|
|
burst_loss_count(other.burst_loss_count),
|
|
burst_discard_count(other.burst_discard_count),
|
|
burst_loss_rate(other.burst_loss_rate),
|
|
burst_discard_rate(other.burst_discard_rate),
|
|
gap_loss_rate(other.gap_loss_rate),
|
|
gap_discard_rate(other.gap_discard_rate),
|
|
frames_received(other.frames_received),
|
|
frame_width(other.frame_width),
|
|
frame_height(other.frame_height),
|
|
frame_bit_depth(other.frame_bit_depth),
|
|
frames_per_second(other.frames_per_second),
|
|
frames_decoded(other.frames_decoded),
|
|
key_frames_decoded(other.key_frames_decoded),
|
|
frames_dropped(other.frames_dropped),
|
|
total_decode_time(other.total_decode_time),
|
|
total_processing_delay(other.total_processing_delay),
|
|
total_assembly_time(other.total_assembly_time),
|
|
frames_assembled_from_multiple_packets(
|
|
other.frames_assembled_from_multiple_packets),
|
|
total_inter_frame_delay(other.total_inter_frame_delay),
|
|
total_squared_inter_frame_delay(other.total_squared_inter_frame_delay),
|
|
content_type(other.content_type),
|
|
estimated_playout_timestamp(other.estimated_playout_timestamp),
|
|
decoder_implementation(other.decoder_implementation),
|
|
fir_count(other.fir_count),
|
|
pli_count(other.pli_count),
|
|
nack_count(other.nack_count),
|
|
qp_sum(other.qp_sum) {}
|
|
|
|
RTCInboundRTPStreamStats::~RTCInboundRTPStreamStats() {}
|
|
|
|
// clang-format off
|
|
WEBRTC_RTCSTATS_IMPL(
|
|
RTCOutboundRTPStreamStats, RTCRTPStreamStats, "outbound-rtp",
|
|
&media_source_id,
|
|
&remote_id,
|
|
&rid,
|
|
&packets_sent,
|
|
&retransmitted_packets_sent,
|
|
&bytes_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)
|
|
// clang-format on
|
|
|
|
RTCOutboundRTPStreamStats::RTCOutboundRTPStreamStats(const std::string& id,
|
|
int64_t timestamp_us)
|
|
: RTCOutboundRTPStreamStats(std::string(id), timestamp_us) {}
|
|
|
|
RTCOutboundRTPStreamStats::RTCOutboundRTPStreamStats(std::string&& id,
|
|
int64_t timestamp_us)
|
|
: 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"),
|
|
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") {}
|
|
|
|
RTCOutboundRTPStreamStats::RTCOutboundRTPStreamStats(
|
|
const RTCOutboundRTPStreamStats& other)
|
|
: 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),
|
|
header_bytes_sent(other.header_bytes_sent),
|
|
retransmitted_bytes_sent(other.retransmitted_bytes_sent),
|
|
target_bitrate(other.target_bitrate),
|
|
frames_encoded(other.frames_encoded),
|
|
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_durations(other.quality_limitation_durations),
|
|
quality_limitation_resolution_changes(
|
|
other.quality_limitation_resolution_changes),
|
|
content_type(other.content_type),
|
|
encoder_implementation(other.encoder_implementation),
|
|
fir_count(other.fir_count),
|
|
pli_count(other.pli_count),
|
|
nack_count(other.nack_count),
|
|
qp_sum(other.qp_sum) {}
|
|
|
|
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(
|
|
const std::string& id,
|
|
int64_t timestamp_us)
|
|
: RTCRemoteInboundRtpStreamStats(std::string(id), timestamp_us) {}
|
|
|
|
RTCRemoteInboundRtpStreamStats::RTCRemoteInboundRtpStreamStats(
|
|
std::string&& id,
|
|
int64_t timestamp_us)
|
|
: RTCReceivedRtpStreamStats(std::move(id), timestamp_us),
|
|
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)
|
|
: RTCReceivedRtpStreamStats(other),
|
|
local_id(other.local_id),
|
|
round_trip_time(other.round_trip_time),
|
|
fraction_lost(other.fraction_lost),
|
|
total_round_trip_time(other.total_round_trip_time),
|
|
round_trip_time_measurements(other.round_trip_time_measurements) {}
|
|
|
|
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(
|
|
const std::string& id,
|
|
int64_t timestamp_us)
|
|
: RTCRemoteOutboundRtpStreamStats(std::string(id), timestamp_us) {}
|
|
|
|
RTCRemoteOutboundRtpStreamStats::RTCRemoteOutboundRtpStreamStats(
|
|
std::string&& id,
|
|
int64_t timestamp_us)
|
|
: RTCSentRtpStreamStats(std::move(id), timestamp_us),
|
|
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)
|
|
: RTCSentRtpStreamStats(other),
|
|
local_id(other.local_id),
|
|
remote_timestamp(other.remote_timestamp),
|
|
reports_sent(other.reports_sent),
|
|
round_trip_time(other.round_trip_time),
|
|
round_trip_time_measurements(other.round_trip_time_measurements),
|
|
total_round_trip_time(other.total_round_trip_time) {}
|
|
|
|
RTCRemoteOutboundRtpStreamStats::~RTCRemoteOutboundRtpStreamStats() {}
|
|
|
|
// clang-format off
|
|
WEBRTC_RTCSTATS_IMPL(RTCMediaSourceStats, RTCStats, "parent-media-source",
|
|
&track_identifier,
|
|
&kind)
|
|
// clang-format on
|
|
|
|
RTCMediaSourceStats::RTCMediaSourceStats(const std::string& id,
|
|
int64_t timestamp_us)
|
|
: RTCMediaSourceStats(std::string(id), timestamp_us) {}
|
|
|
|
RTCMediaSourceStats::RTCMediaSourceStats(std::string&& id, int64_t timestamp_us)
|
|
: RTCStats(std::move(id), timestamp_us),
|
|
track_identifier("trackIdentifier"),
|
|
kind("kind") {}
|
|
|
|
RTCMediaSourceStats::RTCMediaSourceStats(const RTCMediaSourceStats& other)
|
|
: RTCStats(other.id(), other.timestamp_us()),
|
|
track_identifier(other.track_identifier),
|
|
kind(other.kind) {}
|
|
|
|
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(const std::string& id,
|
|
int64_t timestamp_us)
|
|
: RTCAudioSourceStats(std::string(id), timestamp_us) {}
|
|
|
|
RTCAudioSourceStats::RTCAudioSourceStats(std::string&& id, int64_t timestamp_us)
|
|
: RTCMediaSourceStats(std::move(id), timestamp_us),
|
|
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)
|
|
: RTCMediaSourceStats(other),
|
|
audio_level(other.audio_level),
|
|
total_audio_energy(other.total_audio_energy),
|
|
total_samples_duration(other.total_samples_duration),
|
|
echo_return_loss(other.echo_return_loss),
|
|
echo_return_loss_enhancement(other.echo_return_loss_enhancement) {}
|
|
|
|
RTCAudioSourceStats::~RTCAudioSourceStats() {}
|
|
|
|
// clang-format off
|
|
WEBRTC_RTCSTATS_IMPL(RTCVideoSourceStats, RTCMediaSourceStats, "media-source",
|
|
&width,
|
|
&height,
|
|
&frames,
|
|
&frames_per_second)
|
|
// clang-format on
|
|
|
|
RTCVideoSourceStats::RTCVideoSourceStats(const std::string& id,
|
|
int64_t timestamp_us)
|
|
: RTCVideoSourceStats(std::string(id), timestamp_us) {}
|
|
|
|
RTCVideoSourceStats::RTCVideoSourceStats(std::string&& id, int64_t timestamp_us)
|
|
: RTCMediaSourceStats(std::move(id), timestamp_us),
|
|
width("width"),
|
|
height("height"),
|
|
frames("frames"),
|
|
frames_per_second("framesPerSecond") {}
|
|
|
|
RTCVideoSourceStats::RTCVideoSourceStats(const RTCVideoSourceStats& other)
|
|
: RTCMediaSourceStats(other),
|
|
width(other.width),
|
|
height(other.height),
|
|
frames(other.frames),
|
|
frames_per_second(other.frames_per_second) {}
|
|
|
|
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(const std::string& id,
|
|
int64_t timestamp_us)
|
|
: RTCTransportStats(std::string(id), timestamp_us) {}
|
|
|
|
RTCTransportStats::RTCTransportStats(std::string&& id, int64_t timestamp_us)
|
|
: RTCStats(std::move(id), timestamp_us),
|
|
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)
|
|
: RTCStats(other.id(), other.timestamp_us()),
|
|
bytes_sent(other.bytes_sent),
|
|
packets_sent(other.packets_sent),
|
|
bytes_received(other.bytes_received),
|
|
packets_received(other.packets_received),
|
|
rtcp_transport_stats_id(other.rtcp_transport_stats_id),
|
|
dtls_state(other.dtls_state),
|
|
selected_candidate_pair_id(other.selected_candidate_pair_id),
|
|
local_certificate_id(other.local_certificate_id),
|
|
remote_certificate_id(other.remote_certificate_id),
|
|
tls_version(other.tls_version),
|
|
dtls_cipher(other.dtls_cipher),
|
|
dtls_role(other.dtls_role),
|
|
srtp_cipher(other.srtp_cipher),
|
|
selected_candidate_pair_changes(other.selected_candidate_pair_changes),
|
|
ice_role(other.ice_role),
|
|
ice_local_username_fragment(other.ice_local_username_fragment),
|
|
ice_state(other.ice_state) {}
|
|
|
|
RTCTransportStats::~RTCTransportStats() {}
|
|
|
|
} // namespace webrtc
|