mirror of
https://github.com/mollyim/webrtc.git
synced 2025-05-13 05:40:42 +01:00
bb547203bf
In order to eliminate the WebRTC Subtree mirror in Chromium, WebRTC is moving the content of the src/webrtc directory up to the src/ directory. NOPRESUBMIT=true NOTREECHECKS=true NOTRY=true TBR=tommi@webrtc.org Bug: chromium:611808 Change-Id: Iac59c5b51b950f174119565bac87955a7994bc38 Reviewed-on: https://webrtc-review.googlesource.com/1560 Commit-Queue: Mirko Bonadei <mbonadei@webrtc.org> Reviewed-by: Henrik Kjellander <kjellander@webrtc.org> Cr-Commit-Position: refs/heads/master@{#19845}
691 lines
22 KiB
C++
691 lines
22 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 "webrtc/api/stats/rtcstats_objects.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";
|
|
|
|
// 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, "ice-candidate",
|
|
&transport_id,
|
|
&is_remote,
|
|
&ip,
|
|
&port,
|
|
&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),
|
|
ip("ip"),
|
|
port("port"),
|
|
protocol("protocol"),
|
|
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),
|
|
ip(other.ip),
|
|
port(other.port),
|
|
protocol(other.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) {
|
|
}
|
|
|
|
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) {
|
|
}
|
|
|
|
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,
|
|
&frame_width,
|
|
&frame_height,
|
|
&frames_per_second,
|
|
&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);
|
|
// 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),
|
|
frame_width("frameWidth"),
|
|
frame_height("frameHeight"),
|
|
frames_per_second("framesPerSecond"),
|
|
frames_sent("framesSent"),
|
|
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") {
|
|
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),
|
|
frame_width(other.frame_width),
|
|
frame_height(other.frame_height),
|
|
frames_per_second(other.frames_per_second),
|
|
frames_sent(other.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) {}
|
|
|
|
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,
|
|
&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"),
|
|
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),
|
|
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,
|
|
&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);
|
|
// 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"),
|
|
bytes_received("bytesReceived"),
|
|
packets_lost("packetsLost"),
|
|
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") {
|
|
}
|
|
|
|
RTCInboundRTPStreamStats::RTCInboundRTPStreamStats(
|
|
const RTCInboundRTPStreamStats& other)
|
|
: RTCRTPStreamStats(other),
|
|
packets_received(other.packets_received),
|
|
bytes_received(other.bytes_received),
|
|
packets_lost(other.packets_lost),
|
|
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) {
|
|
}
|
|
|
|
RTCInboundRTPStreamStats::~RTCInboundRTPStreamStats() {
|
|
}
|
|
|
|
// clang-format off
|
|
WEBRTC_RTCSTATS_IMPL(
|
|
RTCOutboundRTPStreamStats, RTCRTPStreamStats, "outbound-rtp",
|
|
&packets_sent,
|
|
&bytes_sent,
|
|
&target_bitrate,
|
|
&frames_encoded);
|
|
// 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"),
|
|
bytes_sent("bytesSent"),
|
|
target_bitrate("targetBitrate"),
|
|
frames_encoded("framesEncoded") {
|
|
}
|
|
|
|
RTCOutboundRTPStreamStats::RTCOutboundRTPStreamStats(
|
|
const RTCOutboundRTPStreamStats& other)
|
|
: RTCRTPStreamStats(other),
|
|
packets_sent(other.packets_sent),
|
|
bytes_sent(other.bytes_sent),
|
|
target_bitrate(other.target_bitrate),
|
|
frames_encoded(other.frames_encoded) {
|
|
}
|
|
|
|
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
|