Struct RtcOutboundRtpStreamVideo 

pub struct RtcOutboundRtpStreamVideo {

    pub rid: Option<String>,
    pub encoding_index: Option<u32>,
    pub total_encoded_bytes_target: Option<u64>,
    pub frame_width: Option<u32>,
    pub frame_height: Option<u32>,
    pub frames_per_second: Option<Double>,
    pub frames_sent: Option<u32>,
    pub huge_frames_sent: Option<u32>,
    pub frames_encoded: Option<u32>,
    pub key_frames_encoded: Option<u32>,
    pub qp_sum: Option<u64>,
    pub psnr_sum: Option<BTreeMap<String, Double>>,
    pub psnr_measurements: Option<u64>,
    pub total_encode_time: Option<Double>,
    pub fir_count: Option<u32>,
    pub pli_count: Option<u32>,
    pub encoder_implementation: Option<String>,
    pub power_efficient_encoder: Option<bool>,
    pub quality_limitation_reason: Option<RtcQualityLimitationReason>,
    pub quality_limitation_durations: Option<BTreeMap<RtcQualityLimitationReason, Double>>,
    pub quality_limitation_resolution_changes: Option<u32>,
    pub scalability_mode: Option<String>,
}

Video-specific RtcOutboundRtpStreamStats part.

Full doc on W3C.

Fields

rid: Option<String>

Only exists if a rid has been set for the RTP stream.

If rid is set, this value will be present regardless if the RID RTP header extension has been negotiated.

encoding_index: Option<u32>

Index of the encoding that represents the [RTP stream] in the RTP sender’s list of encodings.

total_encoded_bytes_target: Option<u64>

Value, 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 the RtcOutboundRtpStreamVideo::frames_encoded goes up.

frame_width: Option<u32>

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 attribute is missing.

frame_height: Option<u32>

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 attribute is missing.

frames_per_second: Option<Double>

Number of encoded frames during the last second.

This may be lower than the media source frame rate (see RTCVideoSourceStats.framesPerSecond).

frames_sent: Option<u32>

Total number of frames sent on the RTP stream.

huge_frames_sent: Option<u32>

Total number of huge frames sent by the 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 slide changes in the streamed presentation.

The multiplier of 2.5 is chosen 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.

frames_encoded: Option<u32>

Total number of frames successfully encoded for the media RTP stream.

key_frames_encoded: Option<u32>

Total number of key frames, such as key frames in VP8 RFC6386 or IDR-frames in H.264 RFC6184, successfully encoded for the media RTP stream.

This is a subset of RtcOutboundRtpStreamVideo::frames_encoded. RtcOutboundRtpStreamVideo::frames_encoded - RtcOutboundRtpStreamVideo::key_frames_encoded gives the number of delta frames encoded.

qp_sum: Option<u64>

Sum of the QP values of frames encoded by the sender.

The count of frames is in RtcOutboundRtpStreamVideo::frames_encoded.

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.

psnr_sum: Option<BTreeMap<String, Double>>

Cumulative sum of the PSNR values of frames encoded by the sender.

The record includes values for the y, u and v components.

The count of measurements is in Self::psnr_measurements.

psnr_measurements: Option<u64>

Number of times PSNR was measured.

The components of Self::psnr_sum are aggregated with this measurement.

total_encode_time: Option<Double>

Total number of seconds that has been spent encoding the RtcOutboundRtpStreamVideo::frames_encoded frames of the RTP stream.

The average encode time can be calculated by dividing this value with RtcOutboundRtpStreamVideo::frames_encoded. 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 doesn’t include any additional time it may take to packetize the resulting data.

fir_count: Option<u32>

Total number of Full Intra Request (FIR) packets, as defined in RFC5104 section 4.3.1, received by the sender.

Doesn’t count the RTCP FIR indicated in RFC2032 which was deprecated by RFC4587.

pli_count: Option<u32>

Total number of Picture Loss Indication (PLI) packets, as defined in RFC4585 section 6.3.1, received by the sender.

encoder_implementation: Option<String>

Identification of the used encoder implementation.

This is useful for diagnosing interoperability issues.

power_efficient_encoder: Option<bool>

Indicator 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.

quality_limitation_reason: Option<RtcQualityLimitationReason>

Current reason for limiting the resolution and/or framerate.

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.

quality_limitation_durations: Option<BTreeMap<RtcQualityLimitationReason, Double>>

Record of the total time, in seconds, that the RTP stream has spent in each quality limitation state.

The record includes a mapping for all RtcQualityLimitationReason types, including KnownRtcQualityLimitationReason::None.

The sum of all entries minus KnownRtcQualityLimitationReason::None gives the total time that the stream has been limited.

quality_limitation_resolution_changes: Option<u32>

Number of times that the resolution has changed because of the quality limit (quality_limitation_reason has a value other than KnownRtcQualityLimitationReason::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, this will have the value 2.

scalability_mode: Option<String>

Currently configured scalability mode the RTP stream, if any.

Trait Implementations

impl Clone for RtcOutboundRtpStreamVideo

fn clone(&self) -> RtcOutboundRtpStreamVideo

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for RtcOutboundRtpStreamVideo

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for RtcOutboundRtpStreamVideo

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for RtcOutboundRtpStreamVideo

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for RtcOutboundRtpStreamVideo

fn eq(&self, other: &RtcOutboundRtpStreamVideo) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for RtcOutboundRtpStreamVideo

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for RtcOutboundRtpStreamVideo