23aff9b737
This is a standardized metric: https://w3c.github.io/webrtc-stats/#dom-rtcoutboundrtpstreamstats-totalencodedbytestarget We estimate the target frame size in bytes from the current encoder target bitrate and encoder framerate. We would expect that the average bytes produced by the encoder would over time match the average target, which is calculated by polling getStats() twice and dividing the delta totalEncodedBytesTarget with the delta framesEncoded. This is meant to make googTargetEncBitrate obsolete. Bug: webrtc:10446 Change-Id: Ib10ce236476a2f965582d5c536f419952926d4e6 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/137200 Reviewed-by: Stefan Holmer <stefan@webrtc.org> Commit-Queue: Henrik Boström <hbos@webrtc.org> Cr-Commit-Position: refs/heads/master@{#28022}
755 lines
29 KiB
C++
755 lines
29 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 "rtc_base/checks.h"
|
|
|
|
#include "api/stats/rtc_stats.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://webrtc.org/experiments/rtp-hdrext/video-content-type/
|
|
const char* const RTCContentType::kUnspecified = "unspecified";
|
|
const char* const RTCContentType::kScreenshare = "screenshare";
|
|
|
|
// 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",
|
|
&payload_type,
|
|
&mime_type,
|
|
&clock_rate,
|
|
&channels,
|
|
&sdp_fmtp_line,
|
|
&implementation)
|
|
// 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),
|
|
payload_type("payloadType"),
|
|
mime_type("mimeType"),
|
|
clock_rate("clockRate"),
|
|
channels("channels"),
|
|
sdp_fmtp_line("sdpFmtpLine"),
|
|
implementation("implementation") {}
|
|
|
|
RTCCodecStats::RTCCodecStats(const RTCCodecStats& other)
|
|
: RTCStats(other.id(), other.timestamp_us()),
|
|
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),
|
|
implementation(other.implementation) {}
|
|
|
|
RTCCodecStats::~RTCCodecStats() {}
|
|
|
|
// clang-format off
|
|
WEBRTC_RTCSTATS_IMPL(RTCDataChannelStats, RTCStats, "data-channel",
|
|
&label,
|
|
&protocol,
|
|
&datachannelid,
|
|
&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"),
|
|
datachannelid("datachannelid"),
|
|
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),
|
|
datachannelid(other.datachannelid),
|
|
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,
|
|
&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)
|
|
// 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"),
|
|
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") {}
|
|
|
|
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),
|
|
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) {}
|
|
|
|
RTCIceCandidatePairStats::~RTCIceCandidatePairStats() {}
|
|
|
|
// clang-format off
|
|
WEBRTC_RTCSTATS_IMPL(RTCIceCandidateStats, RTCStats, "abstract-ice-candidate",
|
|
&transport_id,
|
|
&is_remote,
|
|
&network_type,
|
|
&ip,
|
|
&port,
|
|
&protocol,
|
|
&relay_protocol,
|
|
&candidate_type,
|
|
&priority,
|
|
&url,
|
|
&deleted)
|
|
// 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"),
|
|
port("port"),
|
|
protocol("protocol"),
|
|
relay_protocol("relayProtocol"),
|
|
candidate_type("candidateType"),
|
|
priority("priority"),
|
|
url("url"),
|
|
deleted("deleted", false) {}
|
|
|
|
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),
|
|
port(other.port),
|
|
protocol(other.protocol),
|
|
relay_protocol(other.relay_protocol),
|
|
candidate_type(other.candidate_type),
|
|
priority(other.priority),
|
|
url(other.url),
|
|
deleted(other.deleted) {}
|
|
|
|
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,
|
|
&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,
|
|
&concealment_events,
|
|
&jitter_buffer_flushes,
|
|
&delayed_packet_outage_samples,
|
|
&relative_packet_arrival_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"),
|
|
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}),
|
|
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),
|
|
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),
|
|
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,
|
|
&associate_stats_id,
|
|
&is_remote,
|
|
&media_type,
|
|
&kind,
|
|
&track_id,
|
|
&transport_id,
|
|
&codec_id,
|
|
&fir_count,
|
|
&pli_count,
|
|
&nack_count,
|
|
&sli_count,
|
|
&qp_sum)
|
|
// 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"),
|
|
associate_stats_id("associateStatsId"),
|
|
is_remote("isRemote", false),
|
|
media_type("mediaType"),
|
|
kind("kind"),
|
|
track_id("trackId"),
|
|
transport_id("transportId"),
|
|
codec_id("codecId"),
|
|
fir_count("firCount"),
|
|
pli_count("pliCount"),
|
|
nack_count("nackCount"),
|
|
sli_count("sliCount"),
|
|
qp_sum("qpSum") {}
|
|
|
|
RTCRTPStreamStats::RTCRTPStreamStats(const RTCRTPStreamStats& other)
|
|
: RTCStats(other.id(), other.timestamp_us()),
|
|
ssrc(other.ssrc),
|
|
associate_stats_id(other.associate_stats_id),
|
|
is_remote(other.is_remote),
|
|
media_type(other.media_type),
|
|
kind(other.kind),
|
|
track_id(other.track_id),
|
|
transport_id(other.transport_id),
|
|
codec_id(other.codec_id),
|
|
fir_count(other.fir_count),
|
|
pli_count(other.pli_count),
|
|
nack_count(other.nack_count),
|
|
sli_count(other.sli_count),
|
|
qp_sum(other.qp_sum) {}
|
|
|
|
RTCRTPStreamStats::~RTCRTPStreamStats() {}
|
|
|
|
// clang-format off
|
|
WEBRTC_RTCSTATS_IMPL(
|
|
RTCInboundRTPStreamStats, RTCRTPStreamStats, "inbound-rtp",
|
|
&packets_received,
|
|
&bytes_received,
|
|
&packets_lost,
|
|
&last_packet_received_timestamp,
|
|
&jitter,
|
|
&fraction_lost,
|
|
&round_trip_time,
|
|
&packets_discarded,
|
|
&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_decoded,
|
|
&content_type)
|
|
// 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)
|
|
: RTCRTPStreamStats(std::move(id), timestamp_us),
|
|
packets_received("packetsReceived"),
|
|
fec_packets_received("fecPacketsReceived"),
|
|
fec_packets_discarded("fecPacketsDiscarded"),
|
|
bytes_received("bytesReceived"),
|
|
packets_lost("packetsLost"),
|
|
last_packet_received_timestamp("lastPacketReceivedTimestamp"),
|
|
jitter("jitter"),
|
|
fraction_lost("fractionLost"),
|
|
round_trip_time("roundTripTime"),
|
|
packets_discarded("packetsDiscarded"),
|
|
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_decoded("framesDecoded"),
|
|
content_type("contentType") {}
|
|
|
|
RTCInboundRTPStreamStats::RTCInboundRTPStreamStats(
|
|
const RTCInboundRTPStreamStats& other)
|
|
: RTCRTPStreamStats(other),
|
|
packets_received(other.packets_received),
|
|
fec_packets_received(other.fec_packets_received),
|
|
fec_packets_discarded(other.fec_packets_discarded),
|
|
bytes_received(other.bytes_received),
|
|
packets_lost(other.packets_lost),
|
|
last_packet_received_timestamp(other.last_packet_received_timestamp),
|
|
jitter(other.jitter),
|
|
fraction_lost(other.fraction_lost),
|
|
round_trip_time(other.round_trip_time),
|
|
packets_discarded(other.packets_discarded),
|
|
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_decoded(other.frames_decoded),
|
|
content_type(other.content_type) {}
|
|
|
|
RTCInboundRTPStreamStats::~RTCInboundRTPStreamStats() {}
|
|
|
|
// clang-format off
|
|
WEBRTC_RTCSTATS_IMPL(
|
|
RTCOutboundRTPStreamStats, RTCRTPStreamStats, "outbound-rtp",
|
|
&packets_sent,
|
|
&retransmitted_packets_sent,
|
|
&bytes_sent,
|
|
&retransmitted_bytes_sent,
|
|
&target_bitrate,
|
|
&frames_encoded,
|
|
&total_encode_time,
|
|
&total_encoded_bytes_target,
|
|
&total_packet_send_delay,
|
|
&content_type)
|
|
// 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),
|
|
packets_sent("packetsSent"),
|
|
retransmitted_packets_sent("retransmittedPacketsSent"),
|
|
bytes_sent("bytesSent"),
|
|
retransmitted_bytes_sent("retransmittedBytesSent"),
|
|
target_bitrate("targetBitrate"),
|
|
frames_encoded("framesEncoded"),
|
|
total_encode_time("totalEncodeTime"),
|
|
total_encoded_bytes_target("totalEncodedBytesTarget"),
|
|
total_packet_send_delay("totalPacketSendDelay"),
|
|
content_type("contentType") {}
|
|
|
|
RTCOutboundRTPStreamStats::RTCOutboundRTPStreamStats(
|
|
const RTCOutboundRTPStreamStats& other)
|
|
: RTCRTPStreamStats(other),
|
|
packets_sent(other.packets_sent),
|
|
retransmitted_packets_sent(other.retransmitted_packets_sent),
|
|
bytes_sent(other.bytes_sent),
|
|
retransmitted_bytes_sent(other.retransmitted_bytes_sent),
|
|
target_bitrate(other.target_bitrate),
|
|
frames_encoded(other.frames_encoded),
|
|
total_encode_time(other.total_encode_time),
|
|
total_encoded_bytes_target(other.total_encoded_bytes_target),
|
|
total_packet_send_delay(other.total_packet_send_delay),
|
|
content_type(other.content_type) {}
|
|
|
|
RTCOutboundRTPStreamStats::~RTCOutboundRTPStreamStats() {}
|
|
|
|
// clang-format off
|
|
WEBRTC_RTCSTATS_IMPL(RTCTransportStats, RTCStats, "transport",
|
|
&bytes_sent,
|
|
&bytes_received,
|
|
&rtcp_transport_stats_id,
|
|
&dtls_state,
|
|
&selected_candidate_pair_id,
|
|
&local_certificate_id,
|
|
&remote_certificate_id)
|
|
// 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"),
|
|
bytes_received("bytesReceived"),
|
|
rtcp_transport_stats_id("rtcpTransportStatsId"),
|
|
dtls_state("dtlsState"),
|
|
selected_candidate_pair_id("selectedCandidatePairId"),
|
|
local_certificate_id("localCertificateId"),
|
|
remote_certificate_id("remoteCertificateId") {}
|
|
|
|
RTCTransportStats::RTCTransportStats(const RTCTransportStats& other)
|
|
: RTCStats(other.id(), other.timestamp_us()),
|
|
bytes_sent(other.bytes_sent),
|
|
bytes_received(other.bytes_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) {}
|
|
|
|
RTCTransportStats::~RTCTransportStats() {}
|
|
|
|
} // namespace webrtc
|