Dictionary {{RTCRtpStreamStats}} Members

ssrc of type unsigned long

The synchronization source (SSRC) identifier is an unsigned integer value per [[RFC3550]] used to identify the stream of RTP packets that this stats object is describing.

For outbound and inbound local, SSRC describes the stats for the RTP stream that were sent and received, respectively by those endpoints. For the remote inbound and remote outbound, SSRC describes the stats for the RTP stream that were received by and sent to the remote endpoint.

kind of type DOMString

Either "audio" or "video". This MUST match the kind attribute of the related {{MediaStreamTrack}}.

transportId of type DOMString

It is a unique identifier that is associated to the object that was inspected to produce the {{RTCTransportStats}} associated with this RTP stream.

codecId of type DOMString

It is a unique identifier that is associated to the object that was inspected to produce the {{RTCCodecStats}} associated with this RTP stream.

Dictionary {{RTCCodecStats}} Members

payloadType of type unsigned long

Payload type as used in RTP encoding or decoding.

transportId of type DOMString

The unique identifier of the transport on which this codec is being used, which can be used to look up the corresponding {{RTCTransportStats}} object.

mimeType of type DOMString

The codec MIME media type/subtype defined in the IANA media types registry [[!IANA-MEDIA-TYPES]], e.g. video/VP8.

clockRate of type unsigned long

Represents the media sampling rate.

channels of type unsigned long

When present, indicates the number of channels (mono=1, stereo=2).

sdpFmtpLine of type DOMString

The "format specific parameters" field from the a=fmtp line in the SDP corresponding to the codec, if one [= map/exist =]s, as defined by [[!RFC8829]] (section 5.8).

Dictionary {{RTCReceivedRtpStreamStats}} Members

packetsReceived of type unsigned long long

Total number of RTP packets received for this SSRC. This includes retransmissions. At the receiving endpoint, this is calculated as defined in [[!RFC3550]] section 6.4.1. At the sending endpoint the {{packetsReceived}} is estimated by subtracting the Cumulative Number of Packets Lost from the Extended Highest Sequence Number Received, both reported in the RTCP Receiver Report, and then subtracting the initial Extended Sequence Number that was sent to this SSRC in a RTCP Sender Report and then adding one, to mirror what is discussed in Appendix A.3 in [[!RFC3550]], but for the sender side. If no RTCP Receiver Report has been received yet, then return 0.

packetsLost of type long long

Total number of RTP packets lost for this SSRC. Calculated as defined in [[!RFC3550]] section 6.4.1. Note that because of how this is estimated, it can be negative if more packets are received than sent.

jitter of type double

Packet Jitter measured in seconds for this SSRC. Calculated as defined in section 6.4.1. of [[!RFC3550]].

Dictionary {{RTCInboundRtpStreamStats}} Members

trackIdentifier of type DOMString

The value of the {{MediaStreamTrack}}'s id attribute.

mid of type DOMString

If the {{RTCRtpTransceiver}} owning this stream has a {{RTCRtpTransceiver/mid}} value that is not null, this is that value, otherwise this member MUST NOT be [= map/exist | present =].

remoteId of type DOMString

The {{remoteId}} is used for looking up the remote {{RTCRemoteOutboundRtpStreamStats}} object for the same SSRC.

framesDecoded

MUST NOT [= map/exist =] for audio. It represents the total number of frames correctly decoded for this RTP stream, i.e., frames that would be displayed if no frames are dropped.

keyFramesDecoded of type unsigned long

MUST NOT [= map/exist =] for audio. It represents the total number of key frames, such as key frames in VP8 [[RFC6386]] or IDR-frames in H.264 [[RFC6184]], successfully decoded for this RTP media stream. This is a subset of {{framesDecoded}}. framesDecoded - keyFramesDecoded gives you the number of delta frames decoded.

framesRendered

MUST NOT [= map/exist =] for audio. It represents the total number of frames that have been rendered. It is incremented just after a frame has been rendered.

framesDropped of type unsigned long

MUST NOT [= map/exist =] for audio. The total number of frames dropped prior to decode or dropped because the frame missed its display deadline for this receiver's track. The measurement begins when the receiver is created and is a cumulative metric as defined in Appendix A (g) of [[!RFC7004]].

frameWidth of type unsigned long

MUST NOT [= map/exist =] for audio. Represents the width of the last decoded frame. Before the first frame is decoded this member MUST NOT [= map/exist =].

frameHeight of type unsigned long

MUST NOT [= map/exist =] for audio. Represents the height of the last decoded frame. Before the first frame is decoded this member MUST NOT [= map/exist =].

framesPerSecond of type double

MUST NOT [= map/exist =] for audio. The number of decoded frames in the last second.

qpSum of type unsigned long long

MUST NOT [= map/exist =] for audio. The sum of the QP values of frames decoded by this receiver. The count of frames is in {{framesDecoded}}.

The definition of QP value depends on the codec; for VP8, the QP value is the value carried in the frame header as the syntax element y_ac_qi, and defined in [[RFC6386]] section 19.2. Its range is 0..127.

Note that the QP value is only an indication of quantizer values used; many formats have ways to vary the quantizer value within the frame.

totalDecodeTime of type double

MUST NOT [= map/exist =] for audio. Total number of seconds that have been spent decoding the {{framesDecoded}} frames of this stream. The average decode time can be calculated by dividing this value with {{framesDecoded}}. The time it takes to decode one frame is the time passed between feeding the decoder a frame and the decoder returning decoded data for that frame.

totalInterFrameDelay of type double

MUST NOT [= map/exist =] for audio. Sum of the interframe delays in seconds between consecutively rendered frames, recorded just after a frame has been rendered. The interframe delay variance be calculated from {{totalInterFrameDelay}}, {{totalSquaredInterFrameDelay}}, and {{framesRendered}} according to the formula: ({{totalSquaredInterFrameDelay}} - {{totalInterFrameDelay}}^2/ {{framesRendered}})/{{framesRendered}}.

totalSquaredInterFrameDelay of type double

MUST NOT [= map/exist =] for audio. Sum of the squared interframe delays in seconds between consecutively rendered frames, recorded just after a frame has been rendered. See {{totalInterFrameDelay}} for details on how to calculate the interframe delay variance.

pauseCount of type unsigned long

MUST NOT [= map/exist =] for audio. Count the total number of video pauses experienced by this receiver. Video is considered to be paused if time passed since last rendered frame exceeds 5 seconds. {{pauseCount}} is incremented when a frame is rendered after such a pause.

totalPausesDuration of type double

MUST NOT [= map/exist =] for audio. Total duration of pauses (for definition of pause see {{pauseCount}}), in seconds. This value is updated when a frame is rendered.

freezeCount of type unsigned long

MUST NOT [= map/exist =] for audio. Count the total number of video freezes experienced by this receiver. It is a freeze if frame duration, which is time interval between two consecutively rendered frames, is equal or exceeds Max(3 * avg_frame_duration_ms, avg_frame_duration_ms + 150), where avg_frame_duration_ms is linear average of durations of last 30 rendered frames.

totalFreezesDuration of type double

MUST NOT [= map/exist =] for audio. Total duration of rendered frames which are considered as frozen (for definition of freeze see {{freezeCount}}), in seconds. This value is updated when a frame is rendered.

lastPacketReceivedTimestamp of type DOMHighResTimeStamp

Represents the timestamp at which the last packet was received for this SSRC. This differs from {{RTCStats/timestamp}}, which represents the time at which the statistics were generated by the local endpoint.

headerBytesReceived of type unsigned long long

Total number of RTP header and padding bytes received for this SSRC. This includes retransmissions. This does not include the size of transport layer headers such as IP or UDP. headerBytesReceived + bytesReceived equals the number of bytes received as payload over the transport.

packetsDiscarded of type unsigned long long

The cumulative number of RTP packets discarded by the jitter buffer due to late or early-arrival, i.e., these packets are not played out. RTP packets discarded due to packet duplication are not reported in this metric [[XRBLOCK-STATS]]. Calculated as defined in [[!RFC7002]] section 3.2 and Appendix A.a.

fecBytesReceived of type unsigned long long

Total number of RTP FEC bytes received for this SSRC, only including payload bytes. This is a subset of {{RTCInboundRtpStreamStats/bytesReceived}}. If a FEC mechanism that uses a different {{RTCRtpStreamStats/ssrc}} was negotiated, FEC packets are sent over a separate SSRC but is still accounted for here.

fecPacketsReceived of type unsigned long long

Total number of RTP FEC packets received for this SSRC. If a FEC mechanism that uses a different {{RTCRtpStreamStats/ssrc}} was negotiated, FEC packets are sent over a separate SSRC but is still accounted for here. This counter can also be incremented when receiving FEC packets in-band with media packets (e.g., with Opus).

fecPacketsDiscarded of type unsigned long long

Total number of RTP FEC packets received for this SSRC where the error correction payload was discarded by the application. This may happen 1. if all the source packets protected by the FEC packet were received or already recovered by a separate FEC packet, or 2. if the FEC packet arrived late, i.e., outside the recovery window, and the lost RTP packets have already been skipped during playout. This is a subset of {{fecPacketsReceived}}.

bytesReceived of type unsigned long long

Total number of bytes received for this SSRC. This includes retransmissions. Calculated as defined in [[!RFC3550]] section 6.4.1.

firCount of type unsigned long

MUST NOT [= map/exist =] for audio. Count the total number of Full Intra Request (FIR) packets, as defined in [[!RFC5104]] section 4.3.1, sent by this receiver. Does not count the RTCP FIR indicated in [[?RFC2032]] which was deprecated by [[?RFC4587]].

pliCount of type unsigned long

MUST NOT [= map/exist =] for audio. Count the total number of Picture Loss Indication (PLI) packets, as defined in [[!RFC4585]] section 6.3.1, sent by this receiver.

totalProcessingDelay of type double

It is the sum of the time, in seconds, each audio sample or video frame takes from the time the first RTP packet is received (reception timestamp) and to the time the corresponding sample or frame is decoded (decoded timestamp). At this point the audio sample or video frame is ready for playout by the MediaStreamTrack. Typically ready for playout here means after the audio sample or video frame is fully decoded by the decoder.

Given the complexities involved, the time of arrival or the reception timestamp is measured as close to the network layer as possible and the decoded timestamp is measured as soon as the complete sample or frame is decoded.

In the case of audio, several samples are received in the same RTP packet, all samples will share the same reception timestamp and different decoded timestamps. In the case of video, the frame is received over several RTP packets, in this case the earliest timestamp containing the frame is counted as the reception timestamp, and the decoded timestamp corresponds to when the complete frame is decoded.

This metric is not incremented for frames that are not decoded, i.e. {{RTCInboundRtpStreamStats/framesDropped}}. The average processing delay can be calculated by dividing the {{totalProcessingDelay}} with the {{framesDecoded}} for video (or povisional stats spec totalSamplesDecoded for audio).

nackCount of type unsigned long

Count the total number of Negative ACKnowledgement (NACK) packets, as defined in [[!RFC4585]] section 6.2.1, sent by this receiver.

estimatedPlayoutTimestamp of type DOMHighResTimeStamp

This is the estimated playout time of this receiver's track. The playout time is the NTP timestamp of the last playable audio sample or video frame that has a known timestamp (from an RTCP SR packet mapping RTP timestamps to NTP timestamps), extrapolated with the time elapsed since it was ready to be played out. This is the "current time" of the track in NTP clock time of the sender and can be present even if there is no audio currently playing.

This can be useful for estimating how much audio and video is out of sync for two tracks from the same source, audioInboundRtpStats.{{estimatedPlayoutTimestamp}} - videoInboundRtpStats.{{estimatedPlayoutTimestamp}}.

jitterBufferDelay of type double

The purpose of the jitter buffer is to recombine RTP packets into frames (in the case of video) and have smooth playout. The model described here assumes that the samples or frames are still compressed and have not yet been decoded. It is the sum of the time, in seconds, each audio sample or a video frame takes from the time the first packet is received by the jitter buffer (ingest timestamp) to the time it exits the jitter buffer (emit timestamp). In the case of audio, several samples belong to the same RTP packet, hence they will have the same ingest timestamp but different jitter buffer emit timestamps. In the case of video, the frame maybe is received over several RTP packets, hence the ingest timestamp is the earliest packet of the frame that entered the jitter buffer and the emit timestamp is when the whole frame exits the jitter buffer. This metric increases upon samples or frames exiting, having completed their time in the buffer (and incrementing {{jitterBufferEmittedCount}}). The average jitter buffer delay can be calculated by dividing the {{jitterBufferDelay}} with the {{jitterBufferEmittedCount}}.

jitterBufferTargetDelay of type double

This value is increased by the target jitter buffer delay every time a sample is emitted by the jitter buffer. The added target is the target delay, in seconds, at the time that the sample was emitted from the jitter buffer. To get the average target delay, divide by {{jitterBufferEmittedCount}}.

jitterBufferEmittedCount of type unsigned long long

The total number of audio samples or video frames that have come out of the jitter buffer (increasing {{jitterBufferDelay}}).

jitterBufferMinimumDelay of type double

There are various reasons why the jitter buffer delay might be increased to a higher value, such as to achieve AV synchronization or because a jitterBufferTarget was set on a RTCRtpReceiver. When using one of these mechanisms, it can be useful to keep track of the minimal jitter buffer delay that could have been achieved, so WebRTC clients can track the amount of additional delay that is being added.

This metric works the same way as {{jitterBufferTargetDelay}}, except that it is not affected by external mechanisms that increase the jitter buffer target delay, such as jitterBufferTarget (see link above), AV sync, or any other mechanisms. This metric is purely based on the network characteristics such as jitter and packet loss, and can be seen as the minimum obtainable jitter buffer delay if no external factors would affect it. The metric is updated every time {{jitterBufferEmittedCount}} is updated.

totalSamplesReceived of type unsigned long long

MUST NOT [= map/exist =] for video. The total number of samples that have been received on this RTP stream. This includes {{concealedSamples}}.

concealedSamples of type unsigned long long

MUST NOT [= map/exist =] for video. The total number of samples that are concealed samples. A concealed sample is a sample that was replaced with synthesized samples generated locally before being played out. Examples of samples that have to be concealed are samples from lost packets (reported in {{RTCReceivedRtpStreamStats/packetsLost}}) or samples from packets that arrive too late to be played out (reported in {{RTCInboundRtpStreamStats/packetsDiscarded}}).

silentConcealedSamples of type unsigned long long

MUST NOT [= map/exist =] for video. The total number of concealed samples inserted that are "silent". Playing out silent samples results in silence or comfort noise. This is a subset of {{concealedSamples}}.

concealmentEvents of type unsigned long long

MUST NOT [= map/exist =] for video. The number of concealment events. This counter increases every time a concealed sample is synthesized after a non-concealed sample. That is, multiple consecutive concealed samples will increase the {{concealedSamples}} count multiple times but is a single concealment event.

insertedSamplesForDeceleration of type unsigned long long

MUST NOT [= map/exist =] for video. When playout is slowed down, this counter is increased by the difference between the number of samples received and the number of samples played out. If playout is slowed down by inserting samples, this will be the number of inserted samples.

removedSamplesForAcceleration of type unsigned long long

MUST NOT [= map/exist =] for video. When playout is sped up, this counter is increased by the difference between the number of samples received and the number of samples played out. If speedup is achieved by removing samples, this will be the count of samples removed.

audioLevel of type double

MUST NOT [= map/exist =] for video. Represents the audio level of the receiving track. For audio levels of tracks attached locally, see {{RTCAudioSourceStats}} instead.

The value is between 0..1 (linear), where 1.0 represents 0 dBov, 0 represents silence, and 0.5 represents approximately 6 dBSPL change in the sound pressure level from 0 dBov.

The {{audioLevel}} is averaged over some small interval, using the algorithm described under {{totalAudioEnergy}}. The interval used is implementation dependent.

totalAudioEnergy of type double

MUST NOT [= map/exist =] for video. Represents the audio energy of the receiving track. For audio energy of tracks attached locally, see {{RTCAudioSourceStats}} instead.

This value MUST be computed as follows: for each audio sample that is received (and thus counted by {{totalSamplesReceived}}), add the sample's value divided by the highest-intensity encodable value, squared and then multiplied by the duration of the sample in seconds. In other words, duration * Math.pow(energy/maxEnergy, 2).

This can be used to obtain a root mean square (RMS) value that uses the same units as {{audioLevel}}, as defined in [[RFC6464]]. It can be converted to these units using the formula Math.sqrt(totalAudioEnergy/totalSamplesDuration). This calculation can also be performed using the differences between the values of two different {{RTCPeerConnection/getStats()}} calls, in order to compute the average audio level over any desired time interval. In other words, do Math.sqrt((energy2 - energy1)/(duration2 - duration1)).

For example, if a 10ms packet of audio is produced with an RMS of 0.5 (out of 1.0), this should add 0.5 * 0.5 * 0.01 = 0.0025 to {{totalAudioEnergy}}. If another 10ms packet with an RMS of 0.1 is received, this should similarly add 0.0001 to {{totalAudioEnergy}}. Then, Math.sqrt(totalAudioEnergy/totalSamplesDuration) becomes Math.sqrt(0.0026/0.02) = 0.36, which is the same value that would be obtained by doing an RMS calculation over the contiguous 20ms segment of audio.

If multiple audio channels are used, the audio energy of a sample refers to the highest energy of any channel.

totalSamplesDuration of type double

MUST NOT [= map/exist =] for video. Represents the audio duration of the receiving track. For audio durations of tracks attached locally, see {{RTCAudioSourceStats}} instead.

Represents the total duration in seconds of all samples that have been received (and thus counted by {{totalSamplesReceived}}). Can be used with {{totalAudioEnergy}} to compute an average audio level over different intervals.

framesReceived of type unsigned long

MUST NOT [= map/exist =] for audio. Represents the total number of complete frames received on this RTP stream. This metric is incremented when the complete frame is received.

decoderImplementation of type DOMString

MUST NOT [= map/exist =] unless [= exposing hardware is allowed =].

MUST NOT [= map/exist =] for audio. Identifies the decoder implementation used. This is useful for diagnosing interoperability issues.

playoutId of type DOMString

MUST NOT [= map/exist =] for video. If audio playout is happening, this is used to look up the corresponding {{RTCAudioPlayoutStats}}.

powerEfficientDecoder of type boolean

MUST NOT [= map/exist =] unless [= exposing hardware is allowed =].

MUST NOT [= map/exist =] for audio. Whether the decoder currently used is considered power efficient by the user agent. This SHOULD reflect if the configuration results in hardware acceleration, but the user agent MAY take other information into account when deciding if the configuration is considered power efficient.

framesAssembledFromMultiplePackets of type unsigned long

MUST NOT [= map/exist =] for audio. 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. The average frame assembly time can be calculated by dividing the {{totalAssemblyTime}} with {{framesAssembledFromMultiplePackets}}.

totalAssemblyTime of type double

MUST NOT [= map/exist =] for audio. 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. Only incremented for frames consisting of more than one RTP packet.

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}} or frames that fail decoding for other reasons (if any). Only incremented for frames consisting of more than one RTP packet.

retransmittedPacketsReceived of type unsigned long long

The total number of retransmitted packets that were received for this SSRC. This is a subset of {{RTCReceivedRtpStreamStats/packetsReceived}}. If RTX is not negotiated, retransmitted packets can not be identified and this member MUST NOT [= map/exist =].

retransmittedBytesReceived of type unsigned long long

The total number of retransmitted bytes that were received for this SSRC, only including payload bytes. This is a subset of {{RTCInboundRtpStreamStats/bytesReceived}}. If RTX is not negotiated, retransmitted packets can not be identified and this member MUST NOT [= map/exist =].

rtxSsrc of type unsigned long

If RTX is negotiated for retransmissions on a separate RTP stream, this is the SSRC of the RTX stream that is associated with this stream's {{RTCRtpStreamStats/ssrc}}. If RTX is not negotiated, this value MUST NOT be [= map/exist | present =].

fecSsrc of type unsigned long

If a FEC mechanism that uses a separate RTP stream is negotiated, this is the SSRC of the FEC stream that is associated with this stream's {{RTCRtpStreamStats/ssrc}}. If FEC is not negotiated or uses the same RTP stream, this value MUST NOT be [= map/exist | present =].

totalCorruptionProbability of type double

MUST NOT [= map/exist =] for audio. Represents the cumulative sum of all corruption probability measurements that have been made for this SSRC, see {{corruptionMeasurements}} regarding when this attribute SHOULD be [= map/exist | present =].

Each measurement added to {{totalCorruptionProbability}} MUST be in the range [0.0, 1.0], where a value of 0.0 indicates the system has estimated there is no or negligible corruption present in the processed frame. Similarly a value of 1.0 indicates there is almost certainly a corruption visible in the processed frame. A value in between those two indicates there is likely some corruption visible, but it could for instance have a low magnitude or be present only in a small portion of the frame.

The corruption likelihood values are estimates - not guarantees. Even if the estimate is 0.0, there could be corruptions present (i.e. it's a false negative) for instance if only a very small area of the frame is affected. Similarly, even if the estimate is 1.0 there might not be a corruption present (i.e. it's a false positive) for instance if there are macroblocks with a QP far higher than the frame average. Just like there are edge cases for e.g. PSNR measurements, these metrics should primarily be used as a basis for statistical analysis rather than be used as an absolute truth on a per-frame basis.

totalSquaredCorruptionProbability of type double

MUST NOT [= map/exist =] for audio. Represents the cumulative sum of all corruption probability measurements squared that have been made for this SSRC, see {{corruptionMeasurements}} regarding when this attribute SHOULD be [= map/exist | present =].

corruptionMeasurements of type unsigned long long

MUST NOT [= map/exist =] for audio. When the user agent is able to make a corruption probability measurement, this counter is incremented for each such measurement and {{totalCorruptionProbability}} and {{totalSquaredCorruptionProbability}} are aggregated with this measurement and measurement squared respectively. If the corruption-detection header extension is present in the RTP packets, corruption probability measurements MUST be [= map/exist | present =].

The corruption-detection header extension documented at http://www.webrtc.org/experiments/rtp-hdrext/corruption-detection is experimental. The identifier and format may change once an IETF standard has been established.

Dictionary {{RTCRemoteInboundRtpStreamStats}} Members

localId of type DOMString

The {{localId}} is used for looking up the local {{RTCOutboundRtpStreamStats}} object for the same SSRC.

roundTripTime of type double

Estimated round trip time for this SSRC based on the RTCP timestamps in the RTCP Receiver Report (RR) and measured in seconds. Calculated as defined in section 6.4.1. of [[!RFC3550]]. MUST NOT [= map/exist =] until a RTCP Receiver Report is received with a DLSR value other than 0 has been received.

totalRoundTripTime of type double

Represents the cumulative sum of all round trip time measurements in seconds since the beginning of the session. The individual round trip time is calculated based on the RTCP timestamps in the RTCP Receiver Report (RR) [[!RFC3550]], hence requires a DLSR value other than 0. The average round trip time can be computed from {{totalRoundTripTime}} by dividing it by {{roundTripTimeMeasurements}}.

fractionLost of type double

The fraction packet loss reported for this SSRC. Calculated as defined in [[!RFC3550]] section 6.4.1 and Appendix A.3.

roundTripTimeMeasurements of type unsigned long long

Represents the total number of RTCP RR blocks received for this SSRC that contain a valid round trip time. This counter will not increment if the {{roundTripTime}} can not be calculated because no RTCP Receiver Report with a DLSR value other than 0 has been received.

Dictionary {{RTCSentRtpStreamStats}} Members

packetsSent of type unsigned long long

Total number of RTP packets sent for this SSRC. This includes retransmissions. Calculated as defined in [[!RFC3550]] section 6.4.1.

bytesSent of type unsigned long long

Total number of bytes sent for this SSRC. This includes retransmissions. Calculated as defined in [[!RFC3550]] section 6.4.1.

Dictionary {{RTCOutboundRtpStreamStats}} Members

mid of type DOMString

If the {{RTCRtpTransceiver}} owning this stream has a {{RTCRtpTransceiver/mid}} value that is not null, this is that value, otherwise this member MUST NOT be [= map/exist | present =].

mediaSourceId of type DOMString

The identifier of the stats object representing the track currently attached to the sender of this stream, an {{RTCMediaSourceStats}}.

remoteId of type DOMString

The {{remoteId}} is used for looking up the remote {{RTCRemoteInboundRtpStreamStats}} object for the same SSRC.

rid of type DOMString

MUST NOT [= map/exist =] for audio. Only [= map/exist =]s if a {{RTCRtpCodingParameters/rid}} has been set for this RTP stream. If {{RTCRtpCodingParameters/rid}} is set this value will be present regardless if the RID RTP header extension has been negotiated.

headerBytesSent of type unsigned long long

Total number of RTP header and padding bytes sent for this SSRC. This does not include the size of transport layer headers such as IP or UDP. headerBytesSent + bytesSent equals the number of bytes sent as payload over the transport.

retransmittedPacketsSent of type unsigned long long

The total number of packets that were retransmitted for this SSRC. This is a subset of {{RTCSentRtpStreamStats/packetsSent}}. If RTX is not negotiated, retransmitted packets are sent over this {{RTCRtpStreamStats/ssrc}}. If RTX was negotiated, retransmitted packets are sent over a separate SSRC but is still accounted for here.

retransmittedBytesSent of type unsigned long long

The total number of bytes that were retransmitted for this SSRC, only including payload bytes. This is a subset of {{RTCSentRtpStreamStats/bytesSent}}. If RTX is not negotiated, retransmitted bytes are sent over this {{RTCRtpStreamStats/ssrc}}. If RTX was negotiated, retransmitted bytes are sent over a separate SSRC but is still accounted for here.

rtxSsrc of type unsigned long

If RTX is negotiated for retransmissions on a separate RTP stream, this is the SSRC of the RTX stream that is associated with this stream's {{RTCRtpStreamStats/ssrc}}. If RTX is not negotiated, this value MUST NOT be [= map/exist | present =].

targetBitrate of type double

Reflects the current encoder target in bits per second. The target is an instantanous value reflecting the encoder's settings, but the resulting payload bytes sent per second, excluding retransmissions, SHOULD closely correlate to the target. See also {{RTCSentRtpStreamStats/bytesSent}} and {{RTCOutboundRtpStreamStats/retransmittedBytesSent}}. The {{targetBitrate}} is defined in the same way as the Transport Independent Application Specific (TIAS) bitrate [[!RFC3890]].

totalEncodedBytesTarget of type unsigned long long

MUST NOT [= map/exist =] for audio. This value is increased by the target frame size in bytes every time a frame has been encoded. The actual frame size may be bigger or smaller than this number. This value goes up every time {{framesEncoded}} goes up.

frameWidth of type unsigned long

MUST NOT [= map/exist =] for audio. Represents the width of the last encoded frame. The resolution of the encoded frame may be lower than the media source (see {{RTCVideoSourceStats.width}}). Before the first frame is encoded this member MUST NOT [= map/exist =].

frameHeight of type unsigned long

MUST NOT [= map/exist =] for audio. Represents the height of the last encoded frame. The resolution of the encoded frame may be lower than the media source (see {{RTCVideoSourceStats.height}}). Before the first frame is encoded this member MUST NOT [= map/exist =].

framesPerSecond of type double

MUST NOT [= map/exist =] for audio. The number of encoded frames during the last second. This may be lower than the media source frame rate (see {{RTCVideoSourceStats.framesPerSecond}}).

framesSent of type unsigned long

MUST NOT [= map/exist =] for audio. Represents the total number of frames sent on this RTP stream.

hugeFramesSent of type unsigned long

MUST NOT [= map/exist =] for audio. Represents the total number of huge frames sent by this RTP stream. Huge frames, by definition, are frames that have an encoded size at least 2.5 times the average size of the frames. The average size of the frames is defined as the target bitrate per second divided by the target FPS at the time the frame was encoded. These are usually complex to encode frames with a lot of changes in the picture. This can be used to estimate, e.g slide changes in the streamed presentation.

The multiplier of 2.5 is choosen from analyzing encoded frame sizes for a sample presentation using WebRTC standalone implementation. 2.5 is a reasonably large multiplier which still caused all slide change events to be identified as a huge frames. It, however, produced 1.4% of false positive slide change detections which is deemed reasonable.

framesEncoded of type unsigned long

MUST NOT [= map/exist =] for audio. It represents the total number of frames successfully encoded for this RTP media stream.

keyFramesEncoded of type unsigned long

MUST NOT [= map/exist =] for audio. It represents the total number of key frames, such as key frames in VP8 [[RFC6386]] or IDR-frames in H.264 [[RFC6184]], successfully encoded for this RTP media stream. This is a subset of {{framesEncoded}}. framesEncoded - keyFramesEncoded gives you the number of delta frames encoded.

qpSum of type unsigned long long

MUST NOT [= map/exist =] for audio. The sum of the QP values of frames encoded by this sender. The count of frames is in {{framesEncoded}}.

The definition of QP value depends on the codec; for VP8, the QP value is the value carried in the frame header as the syntax element y_ac_qi, and defined in [[RFC6386]] section 19.2. Its range is 0..127.

Note that the QP value is only an indication of quantizer values used; many formats have ways to vary the quantizer value within the frame.

totalEncodeTime of type double

MUST NOT [= map/exist =] for audio. Total number of seconds that has been spent encoding the {{framesEncoded}} frames of this stream. The average encode time can be calculated by dividing this value with {{framesEncoded}}. The time it takes to encode one frame is the time passed between feeding the encoder a frame and the encoder returning encoded data for that frame. This does not include any additional time it may take to packetize the resulting data.

totalPacketSendDelay of type double

The total number of seconds that packets have spent buffered locally before being transmitted onto the network. The time is measured from when a packet is emitted from the RTP packetizer until it is handed over to the OS network socket. This measurement is added to {{totalPacketSendDelay}} when {{RTCSentRtpStreamStats/packetsSent}} is incremented.

qualityLimitationReason of type {{RTCQualityLimitationReason}}

MUST NOT [= map/exist =] for audio. The current reason for limiting the resolution and/or framerate, or {{RTCQualityLimitationReason/"none"}} if not limited.

The implementation reports the most limiting factor. If the implementation is not able to determine the most limiting factor because multiple may exist, the reasons MUST be reported in the following order of priority: "bandwidth", "cpu", "other".

The consumption of CPU and bandwidth resources is interdependent and difficult to estimate, making it hard to determine what the "most limiting factor" is. The priority order promoted here is based on the heuristic that "bandwidth" is generally more varying and thus a more likely and more useful signal than "cpu".

qualityLimitationDurations of type record<DOMString, double>

MUST NOT [= map/exist =] for audio. A record of the total time, in seconds, that this stream has spent in each quality limitation state. The record includes a mapping for all {{RTCQualityLimitationReason}} types, including {{RTCQualityLimitationReason/"none"}}.

The sum of all entries minus {{qualityLimitationDurations}}[{{RTCQualityLimitationReason/"none"}}] gives the total time that the stream has been limited.

qualityLimitationResolutionChanges of type unsigned long

MUST NOT [= map/exist =] for audio. The number of times that the resolution has changed because we are quality limited ({{qualityLimitationReason}} has a value other than {{RTCQualityLimitationReason/"none"}}). The counter is initially zero and increases when the resolution goes up or down. For example, if a 720p track is sent as 480p for some time and then recovers to 720p, {{qualityLimitationResolutionChanges}} will have the value 2.

nackCount of type unsigned long

Count the total number of Negative ACKnowledgement (NACK) packets, as defined in [[!RFC4585]] section 6.2.1, received by this sender.

firCount of type unsigned long

MUST NOT [= map/exist =] for audio. Count the total number of Full Intra Request (FIR) packets, as defined in [[!RFC5104]] section 4.3.1, received by this sender. Does not count the RTCP FIR indicated in [[?RFC2032]] which was deprecated by [[?RFC4587]].

pliCount of type unsigned long

MUST NOT [= map/exist =] for audio. Count the total number of Picture Loss Indication (PLI) packets, as defined in [[!RFC4585]] section 6.3.1, received by this sender

encoderImplementation of type DOMString

MUST NOT [= map/exist =] unless [= exposing hardware is allowed =].

MUST NOT [= map/exist =] for audio. Identifies the encoder implementation used. This is useful for diagnosing interoperability issues.

powerEfficientEncoder of type boolean

MUST NOT [= map/exist =] unless [= exposing hardware is allowed =].

MUST NOT [= map/exist =] for audio. Whether the encoder currently used is considered power efficient by the user agent. This SHOULD reflect if the configuration results in hardware acceleration, but the user agent MAY take other information into account when deciding if the configuration is considered power efficient.

active of type boolean

Indicates whether this RTP stream is configured to be sent or disabled. Note that an active stream can still not be sending, e.g. when being limited by network conditions.

scalabilityMode of type DOMString

MUST NOT [= map/exist =] for audio. Only [= map/exist =]s when a scalability mode is currently configured for this RTP stream.

Dictionary {{RTCRemoteOutboundRtpStreamStats}} Members

localId of type DOMString

The {{localId}} is used for looking up the local {{RTCInboundRtpStreamStats}} object for the same SSRC.

remoteTimestamp of type DOMHighResTimeStamp

{{remoteTimestamp}}, of type {{DOMHighResTimeStamp}} [[!HIGHRES-TIME]], represents the remote timestamp at which these statistics were sent by the remote endpoint. This differs from {{RTCStats/timestamp}}, which represents the time at which the statistics were generated or received by the local endpoint. The {{remoteTimestamp}}, if present, is derived from the NTP timestamp in an RTCP Sender Report (SR) block, which reflects the remote endpoint's clock. That clock may not be synchronized with the local clock.

reportsSent of type unsigned long long

Represents the total number of RTCP Sender Report (SR) blocks sent for this SSRC.

roundTripTime of type double

Estimated round trip time for this SSRC based on the latest RTCP Sender Report (SR) that contains a DLRR report block as defined in [[!RFC3611]]. The Calculation of the round trip time is defined in section 4.5. of [[!RFC3611]]. MUST NOT [= map/exist =] if the latest SR does not contain the DLRR report block, or if the last RR timestamp in the DLRR report block is zero, or if the delay since last RR value in the DLRR report block is zero.

totalRoundTripTime of type double

Represents the cumulative sum of all round trip time measurements in seconds since the beginning of the session. The individual round trip time is calculated based on the DLRR report block in the RTCP Sender Report (SR) [[!RFC3611]]. This counter will not increment if the {{roundTripTime}} can not be calculated. The average round trip time can be computed from {{totalRoundTripTime}} by dividing it by {{roundTripTimeMeasurements}}.

roundTripTimeMeasurements of type unsigned long long

Represents the total number of RTCP Sender Report (SR) blocks received for this SSRC that contain a DLRR report block that can derive a valid round trip time according to [[!RFC3611]]. This counter will not increment if the {{roundTripTime}} can not be calculated.

Dictionary {{RTCMediaSourceStats}} Members

trackIdentifier of type DOMString

The value of the {{MediaStreamTrack}}'s id attribute.

kind of type DOMString

The value of the {{MediaStreamTrack}}'s kind attribute. This is either "audio" or "video". If it is "audio" then this stats object is of type {{RTCAudioSourceStats}}. If it is "video" then this stats object is of type {{RTCVideoSourceStats}}.

Dictionary {{RTCAudioSourceStats}} Members

audioLevel of type double

Represents the audio level of the media source. For audio levels of remotely sourced tracks, see {{RTCInboundRtpStreamStats}} instead.

The value is between 0..1 (linear), where 1.0 represents 0 dBov, 0 represents silence, and 0.5 represents approximately 6 dBSPL change in the sound pressure level from 0 dBov.

The {{audioLevel}} is averaged over some small interval, using the algorithm described under {{totalAudioEnergy}}. The interval used is implementation dependent.

totalAudioEnergy of type double

Represents the audio energy of the media source. For audio energy of remotely sourced tracks, see {{RTCInboundRtpStreamStats}} instead.

This value MUST be computed as follows: for each audio sample produced by the media source during the lifetime of this stats object, add the sample's value divided by the highest-intensity encodable value, squared and then multiplied by the duration of the sample in seconds. In other words, duration * Math.pow(energy/maxEnergy, 2).

This can be used to obtain a root mean square (RMS) value that uses the same units as {{audioLevel}}, as defined in [[RFC6464]]. It can be converted to these units using the formula Math.sqrt(totalAudioEnergy/totalSamplesDuration). This calculation can also be performed using the differences between the values of two different {{RTCPeerConnection/getStats()}} calls, in order to compute the average audio level over any desired time interval. In other words, do Math.sqrt((energy2 - energy1)/(duration2 - duration1)).

For example, if a 10ms packet of audio is produced with an RMS of 0.5 (out of 1.0), this should add 0.5 * 0.5 * 0.01 = 0.0025 to {{totalAudioEnergy}}. If another 10ms packet with an RMS of 0.1 is received, this should similarly add 0.0001 to {{totalAudioEnergy}}. Then, Math.sqrt(totalAudioEnergy/totalSamplesDuration) becomes Math.sqrt(0.0026/0.02) = 0.36, which is the same value that would be obtained by doing an RMS calculation over the contiguous 20ms segment of audio.

If multiple audio channels are used, the audio energy of a sample refers to the highest energy of any channel.

totalSamplesDuration of type double

Represents the audio duration of the media source. For audio durations of remotely sourced tracks, see {{RTCInboundRtpStreamStats}} instead.

Represents the total duration in seconds of all samples that have been produced by this source for the lifetime of this stats object. Can be used with {{totalAudioEnergy}} to compute an average audio level over different intervals.

echoReturnLoss of type double

Only [= map/exist =]s when the {{MediaStreamTrack}} is sourced from a microphone where echo cancellation is applied. Calculated in decibels, as defined in [[!ECHO]] (2012) section 3.14.

If multiple audio channels are used, the channel of the least audio energy is considered for any sample.

echoReturnLossEnhancement of type double

Only [= map/exist =]s when the {{MediaStreamTrack}} is sourced from a microphone where echo cancellation is applied. Calculated in decibels, as defined in [[!ECHO]] (2012) section 3.15.

If multiple audio channels are used, the channel of the least audio energy is considered for any sample.

Dictionary {{RTCVideoSourceStats}} Members

width of type unsigned long

The width, in pixels, of the last frame originating from this source. Before a frame has been produced this member MUST NOT [= map/exist =].

height of type unsigned long

The height, in pixels, of the last frame originating from this source. Before a frame has been produced this member MUST NOT [= map/exist =].

frames of type unsigned long

The total number of frames originating from this source.

framesPerSecond of type double

The number of frames originating from this source, measured during the last second. For the first second of this object's lifetime this member MUST NOT [= map/exist =].

Dictionary {{RTCAudioPlayoutStats}} Members

kind of type DOMString

For audio playout, this has the value "audio". This reflects the kind attribute {{MediaStreamTrack}}(s) being played out.

synthesizedSamplesDuration of type double

If the playout path is unable to produce audio samples on time for device playout, samples are synthesized to be playout out instead. {{synthesizedSamplesDuration}} is measured in seconds and is incremented each time an audio sample is synthesized by this playout path. This metric can be used together with {{totalSamplesDuration}} to calculate the percentage of played out media being synthesized.

Synthesization typically only happens if the pipeline is underperforming. Samples synthesized by the {{RTCInboundRtpStreamStats}} are not counted for here, but in {{RTCInboundRtpStreamStats}}.{{RTCInboundRtpStreamStats/concealedSamples}}.

synthesizedSamplesEvents of type unsigned long

The number of synthesized samples events. This counter increases every time a sample is synthesized after a non-synthesized sample. That is, multiple consecutive synthesized samples will increase {{synthesizedSamplesDuration}} multiple times but is a single synthesization samples event.

totalSamplesDuration of type double

The total duration, in seconds, of all audio samples that have been playout. Includes both synthesized and non-synthesized samples.

totalPlayoutDelay of type double

When audio samples are pulled by the playout device, this counter is incremented with the estimated delay of the playout path for that audio sample. The playout delay includes the delay from being emitted to the actual time of playout on the device. This metric can be used together with {{totalSamplesCount}} to calculate the average playout delay per sample.

totalSamplesCount of type unsigned long long

When audio samples are pulled by the playout device, this counter is incremented with the number of samples emitted for playout.

Dictionary {{RTCPeerConnectionStats}} Members

dataChannelsOpened of type unsigned long

Represents the number of unique {{RTCDataChannel}}s that have entered the {{RTCDataChannelState/"open"}} state during their lifetime.

dataChannelsClosed of type unsigned long

Represents the number of unique {{RTCDataChannel}}s that have left the {{RTCDataChannelState/"open"}} state during their lifetime (due to being closed by either end or the underlying transport being closed). {{RTCDataChannel}}s that transition from {{RTCDataChannelState/"connecting"}} to {{RTCDataChannelState/"closing"}} or {{RTCDataChannelState/"closed"}} without ever being {{RTCDataChannelState/"open"}} are not counted in this number.

The total number of open data channels at any time can be calculated as {{RTCPeerConnectionStats/dataChannelsOpened}} - {{RTCPeerConnectionStats/dataChannelsClosed}}. This number is always positive.

Dictionary {{RTCDataChannelStats}} Members

label of type DOMString

The {{RTCDataChannel/label}} value of the {{RTCDataChannel}} object.

protocol of type DOMString

The {{RTCDataChannel/protocol}} value of the {{RTCDataChannel}} object.

dataChannelIdentifier of type unsigned short

The {{RTCDataChannel/id}} attribute of the {{RTCDataChannel}} object.

state of type {{RTCDataChannelState}}

The {{RTCDataChannel/readyState}} value of the {{RTCDataChannel}} object.

messagesSent of type unsigned long

Represents the total number of API "message" events sent.

bytesSent of type unsigned long long

Represents the total number of payload bytes sent on this {{RTCDataChannel}}, i.e., not including headers or padding.

messagesReceived of type unsigned long

Represents the total number of API "message" events received.

bytesReceived of type unsigned long long

Represents the total number of bytes received on this {{RTCDataChannel}}, i.e., not including headers or padding.

Dictionary {{RTCTransportStats}} Members

packetsSent of type unsigned long long

Represents the total number of packets sent over this transport.

packetsReceived of type unsigned long long

Represents the total number of packets received on this transport.

bytesSent of type unsigned long long

Represents the total number of payload bytes sent on this {{RTCIceTransport}}, i.e., not including headers, padding or ICE connectivity checks.

bytesReceived of type unsigned long long

Represents the total number of payload bytes received on this {{RTCIceTransport}}, i.e., not including headers, padding or ICE connectivity checks.

iceRole of type {{RTCIceRole}}

Set to the current value of the {{RTCIceTransport/role}} attribute of the underlying {{RTCDtlsTransport}}.{{RTCDtlsTransport/iceTransport}}.

iceLocalUsernameFragment of type DOMString

Set to the current value of the local username fragment used in message validation procedures [[RFC5245]] for this {{RTCIceTransport}}. It may be updated on setLocalDescription() and on ICE restart.

dtlsState of type {{RTCDtlsTransportState}}

Set to the current value of the {{RTCDtlsTransport/state}} attribute of the underlying {{RTCDtlsTransport}}.

iceState of type {{RTCIceTransportState}}

Set to the current value of the {{RTCIceTransport/state}} attribute of the underlying {{RTCIceTransport}}.

selectedCandidatePairId of type DOMString

It is a unique identifier that is associated to the object that was inspected to produce the {{RTCIceCandidatePairStats}} associated with this transport.

localCertificateId of type DOMString

For components where DTLS is negotiated, give local certificate.

remoteCertificateId of type DOMString

For components where DTLS is negotiated, give remote certificate.

tlsVersion of type DOMString

For components where DTLS is negotiated, the TLS version agreed. Only [= map/exist =]s after DTLS negotiation is complete.

The value comes from ServerHello.supported_versions if present, otherwise from ServerHello.version. It is represented as four upper case hexadecimal digits, representing the two bytes of the version.

dtlsCipher of type DOMString

Descriptive name of the cipher suite used for the DTLS transport, as defined in the "Description" column of the IANA cipher suite registry [[!IANA-TLS-CIPHERS]].

dtlsRole of type RTCDtlsRole

{{RTCDtlsRole/"client"}} or {{RTCDtlsRole/"server"}} depending on the DTLS role. {{RTCDtlsRole/"unknown"}} before the DTLS negotiation starts.

srtpCipher of type DOMString

Descriptive name of the protection profile used for the SRTP transport, as defined in the "Profile" column of the IANA DTLS-SRTP protection profile registry [[!IANA-DTLS-SRTP]] and described further in [[RFC5764]].

selectedCandidatePairChanges of type unsigned long

The number of times that the selected candidate pair of this transport has changed. Going from not having a selected candidate pair to having a selected candidate pair, or the other way around, also increases this counter. It is initially zero and becomes one when an initial candidate pair is selected.

RTCDtlsRole enum

enum RTCDtlsRole {
      "client",
      "server",
      "unknown",
};

Dictionary {{RTCIceCandidateStats}} Members

transportId of type DOMString

It is a unique identifier that is associated to the object that was inspected to produce the {{RTCTransportStats}} associated with this candidate.

address of type DOMString

It is the address of the candidate, allowing for IPv4 addresses, IPv6 addresses, and fully qualified domain names (FQDNs). See [[!RFC5245]] section 15.1 for details.

The user agent should make sure that only remote candidate addresses that the web application has configured on the corresponding {{RTCPeerConnection}} are exposed; This is especially important for peer reflexive remote candidates. By default, the user agent MUST leave the {{RTCIceCandidateStats/address}} member as null in the {{RTCIceCandidateStats}} dictionary of any remote candidate. Once a {{RTCPeerConnection}} instance learns on an address by the web application using {{RTCPeerConnection/addIceCandidate()}}, the user agent can expose the 'address' member value in any remote {{RTCIceCandidateStats}} dictionary of the corresponding {{RTCPeerConnection}} that matches the newly learnt address.

port of type long

It is the port number of the candidate.

protocol of type DOMString

Valid values for transport is one of "udp" and "tcp". Based on the "transport" defined in [[!RFC5245]] section 15.1.

candidateType of type {{RTCIceCandidateType}}

This enumeration is defined in [[WEBRTC]].

priority of type long

Calculated as defined in [[!RFC5245]] section 15.1.

url of type DOMString

For local candidates of type {{RTCIceCandidateType/"srflx"}} or type {{RTCIceCandidateType/"relay"}} this is the URL of the ICE server from which the candidate was obtained and defined in [[WEBRTC]].

For remote candidates, this property MUST NOT be [= map/exist | present =].

relayProtocol of type {{RTCIceServerTransportProtocol}}

It is the protocol used by the endpoint to communicate with the TURN server. This is only present for local relay candidates and defined in [[WEBRTC]].

For remote candidates, this property MUST NOT be [= map/exist | present =].

foundation of type DOMString

The ICE foundation as defined in [[!RFC5245]] section 15.1.

relatedAddress of type DOMString

The ICE rel-addr defined in [[!RFC5245]] section 15.1. Only set for serverreflexive, peerreflexive and relay candidates.

relatedPort of type long

The ICE rel-addr defined in [[!RFC5245]] section 15.1. Only set for serverreflexive, peerreflexive and relay candidates.

usernameFragment of type DOMString

The ICE username fragment as defined in [[!RFC5245]] section 7.1.2.3.

tcpType of type {{RTCIceTcpCandidateType}}

The ICE candidate TCP type, as defined іn {{RTCIceTcpCandidateType}} and used in {{RTCIceCandidate}}.

Dictionary {{RTCIceCandidatePairStats}} Members

transportId of type DOMString

It is a unique identifier that is associated to the object that was inspected to produce the {{RTCTransportStats}} associated with this candidate pair.

localCandidateId of type DOMString

It is a unique identifier that is associated to the object that was inspected to produce the {{RTCIceCandidateStats}} for the local candidate associated with this candidate pair.

remoteCandidateId of type DOMString

It is a unique identifier that is associated to the object that was inspected to produce the {{RTCIceCandidateStats}} for the remote candidate associated with this candidate pair.

state of type {{RTCStatsIceCandidatePairState}}

Represents the state of the checklist for the local and remote candidates in a pair.

nominated of type boolean

Related to updating the nominated flag described in Section 7.1.3.2.4 of [[!RFC5245]].

packetsSent of type unsigned long long

Represents the total number of packets sent on this candidate pair.

packetsReceived of type unsigned long long

Represents the total number of packets received on this candidate pair.

bytesSent of type unsigned long long

Represents the total number of payload bytes sent on this candidate pair, i.e., not including headers, padding or ICE connectivity checks.

bytesReceived of type unsigned long long

Represents the total number of payload bytes received on this candidate pair, i.e., not including headers, padding or ICE connectivity checks.

lastPacketSentTimestamp of type DOMHighResTimeStamp

Represents the timestamp at which the last packet was sent on this particular candidate pair, excluding STUN packets.

lastPacketReceivedTimestamp of type DOMHighResTimeStamp

Represents the timestamp at which the last packet was received on this particular candidate pair, excluding STUN packets.

totalRoundTripTime of type double

Represents the sum of all round trip time measurements in seconds since the beginning of the session, based on STUN connectivity check [[!STUN-PATH-CHAR]] responses (responsesReceived), including those that reply to requests that are sent in order to verify consent [[!RFC7675]]. The average round trip time can be computed from {{totalRoundTripTime}} by dividing it by {{responsesReceived}}.

currentRoundTripTime of type double

Represents the latest round trip time measured in seconds, computed from both STUN connectivity checks [[!STUN-PATH-CHAR]], including those that are sent for consent verification [[!RFC7675]].

availableOutgoingBitrate of type double

It is calculated by the underlying congestion control by combining the available bitrate for all the outgoing RTP streams using this candidate pair. The bitrate measurement does not count the size of the IP or other transport layers like TCP or UDP. It is similar to the TIAS defined in [[!RFC3890]], i.e., it is measured in bits per second and the bitrate is calculated over a 1 second window. For candidate pairs in use, the estimate is normally no lower than the bitrate for the packets sent at {{lastPacketSentTimestamp}}, but might be higher.

Only [= map/exist =]s when the underlying congestion control calculated either a send-side bandwidth estimation, for example using mechanisms such as TWCC, or received a receive-side estimation via RTCP, for example the one described in REMB. MUST NOT [= map/exist =] for candidate pairs that were never used for sending packets that were taken into account for bandwidth estimation or candidate pairs that have have been used previously but are not currently in use.

availableIncomingBitrate of type double

It is calculated by the underlying congestion control by combining the available bitrate for all the incoming RTP streams using this candidate pair. The bitrate measurement does not count the size of the IP or other transport layers like TCP or UDP. It is similar to the TIAS defined in [[!RFC3890]], i.e., it is measured in bits per second and the bitrate is calculated over a 1 second window. For pairs in use, the estimate is normally no lower than the bitrate for the packets received at {{lastPacketReceivedTimestamp}}, but might be higher.

Only [= map/exist =]s when a receive-side bandwidth estimation, for example REMB was calculated. MUST NOT [= map/exist =] for candidate pairs that were never used for receiving packets that were taken into account for bandwidth estimation or candidate pairs that have have been used previously but are not currently in use.

requestsReceived of type unsigned long long

Represents the total number of connectivity check requests received (including retransmissions). It is impossible for the receiver to tell whether the request was sent in order to check connectivity or check consent, so all connectivity checks requests are counted here.

requestsSent of type unsigned long long

Represents the total number of connectivity check requests sent (not including retransmissions).

responsesReceived of type unsigned long long

Represents the total number of connectivity check responses received.

responsesSent of type unsigned long long

Represents the total number of connectivity check responses sent. Since we cannot distinguish connectivity check requests and consent requests, all responses are counted.

consentRequestsSent of type unsigned long long

Represents the total number of consent requests sent.

packetsDiscardedOnSend of type unsigned long

Total number of packets for this candidate pair that have been discarded due to socket errors, i.e. a socket error occurred when handing the packets to the socket. This might happen due to various reasons, including full buffer or no available memory.

bytesDiscardedOnSend of type unsigned long long

Total number of bytes for this candidate pair that have been discarded due to socket errors, i.e. a socket error occurred when handing the packets containing the bytes to the socket. This might happen due to various reasons, including full buffer or no available memory. Calculated as defined in [[!RFC3550]] section 6.4.1.

Dictionary {{RTCCertificateStats}} Members

fingerprint of type DOMString

The fingerprint of the certificate. Only use the fingerprint value as defined in Section 5 of [[!RFC4572]].

fingerprintAlgorithm of type DOMString

The hash function used to compute the certificate fingerprint. For instance, "sha-256".

base64Certificate of type DOMString

The DER-encoded base-64 representation of the certificate.

issuerCertificateId of type DOMString

The {{issuerCertificateId}} refers to the stats object that contains the next certificate in the certificate chain. If the current certificate is at the end of the chain (i.e. a self-signed certificate), this will not be set.