| /* |
| * 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"; |
| |
| // 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) |
| // 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") {} |
| |
| 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) {} |
| |
| 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, |
| &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, |
| &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}), |
| 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), |
| 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, |
| &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"), |
| 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), |
| 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, |
| &fec_packets_received, |
| &fec_packets_discarded, |
| &bytes_received, |
| &header_bytes_received, |
| &packets_lost, |
| &last_packet_received_timestamp, |
| &jitter, |
| &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, |
| &key_frames_decoded, |
| &total_decode_time, |
| &total_inter_frame_delay, |
| &total_squared_inter_frame_delay, |
| &content_type, |
| &estimated_playout_timestamp, |
| &decoder_implementation) |
| // 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"), |
| header_bytes_received("headerBytesReceived"), |
| packets_lost("packetsLost"), |
| last_packet_received_timestamp("lastPacketReceivedTimestamp"), |
| jitter("jitter"), |
| 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"), |
| key_frames_decoded("keyFramesDecoded"), |
| total_decode_time("totalDecodeTime"), |
| total_inter_frame_delay("totalInterFrameDelay"), |
| total_squared_inter_frame_delay("totalSquaredInterFrameDelay"), |
| content_type("contentType"), |
| estimated_playout_timestamp("estimatedPlayoutTimestamp"), |
| decoder_implementation("decoderImplementation") {} |
| |
| 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), |
| header_bytes_received(other.header_bytes_received), |
| packets_lost(other.packets_lost), |
| last_packet_received_timestamp(other.last_packet_received_timestamp), |
| jitter(other.jitter), |
| 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), |
| key_frames_decoded(other.key_frames_decoded), |
| total_decode_time(other.total_decode_time), |
| 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) {} |
| |
| RTCInboundRTPStreamStats::~RTCInboundRTPStreamStats() {} |
| |
| // clang-format off |
| WEBRTC_RTCSTATS_IMPL( |
| RTCOutboundRTPStreamStats, RTCRTPStreamStats, "outbound-rtp", |
| &media_source_id, |
| &remote_id, |
| &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, |
| &total_packet_send_delay, |
| &quality_limitation_reason, |
| &quality_limitation_resolution_changes, |
| &content_type, |
| &encoder_implementation) |
| // 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"), |
| 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"), |
| total_packet_send_delay("totalPacketSendDelay"), |
| quality_limitation_reason("qualityLimitationReason"), |
| quality_limitation_resolution_changes( |
| "qualityLimitationResolutionChanges"), |
| content_type("contentType"), |
| encoder_implementation("encoderImplementation") {} |
| |
| RTCOutboundRTPStreamStats::RTCOutboundRTPStreamStats( |
| const RTCOutboundRTPStreamStats& other) |
| : RTCRTPStreamStats(other), |
| media_source_id(other.media_source_id), |
| remote_id(other.remote_id), |
| 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), |
| total_packet_send_delay(other.total_packet_send_delay), |
| quality_limitation_reason(other.quality_limitation_reason), |
| quality_limitation_resolution_changes( |
| other.quality_limitation_resolution_changes), |
| content_type(other.content_type), |
| encoder_implementation(other.encoder_implementation) {} |
| |
| RTCOutboundRTPStreamStats::~RTCOutboundRTPStreamStats() {} |
| |
| // clang-format off |
| WEBRTC_RTCSTATS_IMPL( |
| RTCRemoteInboundRtpStreamStats, RTCStats, "remote-inbound-rtp", |
| &ssrc, |
| &kind, |
| &transport_id, |
| &codec_id, |
| &packets_lost, |
| &jitter, |
| &local_id, |
| &round_trip_time) |
| // 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) |
| : RTCStats(std::move(id), timestamp_us), |
| ssrc("ssrc"), |
| kind("kind"), |
| transport_id("transportId"), |
| codec_id("codecId"), |
| packets_lost("packetsLost"), |
| jitter("jitter"), |
| local_id("localId"), |
| round_trip_time("roundTripTime") {} |
| |
| RTCRemoteInboundRtpStreamStats::RTCRemoteInboundRtpStreamStats( |
| const RTCRemoteInboundRtpStreamStats& other) |
| : RTCStats(other), |
| ssrc(other.ssrc), |
| kind(other.kind), |
| transport_id(other.transport_id), |
| codec_id(other.codec_id), |
| packets_lost(other.packets_lost), |
| jitter(other.jitter), |
| local_id(other.local_id), |
| round_trip_time(other.round_trip_time) {} |
| |
| RTCRemoteInboundRtpStreamStats::~RTCRemoteInboundRtpStreamStats() {} |
| |
| // 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) |
| // 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") {} |
| |
| 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) {} |
| |
| 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, |
| &bytes_received, |
| &rtcp_transport_stats_id, |
| &dtls_state, |
| &selected_candidate_pair_id, |
| &local_certificate_id, |
| &remote_certificate_id, |
| &tls_version, |
| &dtls_cipher, |
| &srtp_cipher, |
| &selected_candidate_pair_changes) |
| // 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"), |
| tls_version("tlsVersion"), |
| dtls_cipher("dtlsCipher"), |
| srtp_cipher("srtpCipher"), |
| selected_candidate_pair_changes("selectedCandidatePairChanges") {} |
| |
| 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), |
| tls_version(other.tls_version), |
| dtls_cipher(other.dtls_cipher), |
| srtp_cipher(other.srtp_cipher), |
| selected_candidate_pair_changes(other.selected_candidate_pair_changes) {} |
| |
| RTCTransportStats::~RTCTransportStats() {} |
| |
| } // namespace webrtc |
