RTC[In/Out]boundRTPStreamStats: qpSum,framesDecoded,framesEncoded added.

webrtc/stats/rtcstats_objects.cc

 /*
  *  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.
  */
 
@@ skipping 424 matching lines @@
     &ssrc,
     &associate_stats_id,
     &is_remote,
     &media_type,
     &media_track_id,
     &transport_id,
     &codec_id,
     &fir_count,
     &pli_count,
     &nack_count,
-    &sli_count);
+    &sli_count,
+    &qp_sum);
 
 RTCRTPStreamStats::RTCRTPStreamStats(
     const std::string& id, int64_t timestamp_us)
     : RTCRTPStreamStats(std::string(id), timestamp_us) {
 }
 
 RTCRTPStreamStats::RTCRTPStreamStats(
     std::string&& id, int64_t timestamp_us)
     : RTCStats(std::move(id), timestamp_us),
       ssrc("ssrc"),
       associate_stats_id("associateStatsId"),
       is_remote("isRemote", false),
       media_type("mediaType"),
       media_track_id("mediaTrackId"),
       transport_id("transportId"),
       codec_id("codecId"),
       fir_count("firCount"),
       pli_count("pliCount"),
       nack_count("nackCount"),
-      sli_count("sliCount") {
+      sli_count("sliCount"),
+      qp_sum("qpSum") {
 }
 
 RTCRTPStreamStats::RTCRTPStreamStats(
     const RTCRTPStreamStats& other)
     : RTCStats(other.id(), other.timestamp_us()),
       ssrc(other.ssrc),
       associate_stats_id(other.associate_stats_id),
       is_remote(other.is_remote),
       media_type(other.media_type),
       media_track_id(other.media_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) {
+      sli_count(other.sli_count),
+      qp_sum(other.qp_sum) {
 }
 
 RTCRTPStreamStats::~RTCRTPStreamStats() {
 }
 
 WEBRTC_RTCSTATS_IMPL(
     RTCInboundRTPStreamStats, RTCRTPStreamStats, "inbound-rtp",
     &packets_received,
     &bytes_received,
     &packets_lost,
     &jitter,
     &fraction_lost,
     &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);
+    &gap_discard_rate,
+    &frames_decoded);
 
 RTCInboundRTPStreamStats::RTCInboundRTPStreamStats(
     const std::string& id, int64_t timestamp_us)
     : RTCInboundRTPStreamStats(std::string(id), timestamp_us) {
 }
 
 RTCInboundRTPStreamStats::RTCInboundRTPStreamStats(
     std::string&& id, int64_t timestamp_us)
     : RTCRTPStreamStats(std::move(id), timestamp_us),
       packets_received("packetsReceived"),
       bytes_received("bytesReceived"),
       packets_lost("packetsLost"),
       jitter("jitter"),
       fraction_lost("fractionLost"),
       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") {
+      gap_discard_rate("gapDiscardRate"),
+      frames_decoded("framesDecoded") {
 }
 
 RTCInboundRTPStreamStats::RTCInboundRTPStreamStats(
     const RTCInboundRTPStreamStats& other)
     : RTCRTPStreamStats(other),
       packets_received(other.packets_received),
       bytes_received(other.bytes_received),
       packets_lost(other.packets_lost),
       jitter(other.jitter),
       fraction_lost(other.fraction_lost),
       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) {
+      gap_discard_rate(other.gap_discard_rate),
+      frames_decoded(other.frames_decoded) {
 }
 
 RTCInboundRTPStreamStats::~RTCInboundRTPStreamStats() {
 }
 
 WEBRTC_RTCSTATS_IMPL(
     RTCOutboundRTPStreamStats, RTCRTPStreamStats, "outbound-rtp",
     &packets_sent,
     &bytes_sent,
     &target_bitrate,
-    &round_trip_time);
+    &round_trip_time,
+    &frames_encoded);
 
 RTCOutboundRTPStreamStats::RTCOutboundRTPStreamStats(
     const std::string& id, int64_t timestamp_us)
     : RTCOutboundRTPStreamStats(std::string(id), timestamp_us) {
 }
 
 RTCOutboundRTPStreamStats::RTCOutboundRTPStreamStats(
     std::string&& id, int64_t timestamp_us)
     : RTCRTPStreamStats(std::move(id), timestamp_us),
       packets_sent("packetsSent"),
       bytes_sent("bytesSent"),
       target_bitrate("targetBitrate"),
-      round_trip_time("roundTripTime") {
+      round_trip_time("roundTripTime"),
+      frames_encoded("framesEncoded") {
 }
 
 RTCOutboundRTPStreamStats::RTCOutboundRTPStreamStats(
     const RTCOutboundRTPStreamStats& other)
     : RTCRTPStreamStats(other),
       packets_sent(other.packets_sent),
       bytes_sent(other.bytes_sent),
       target_bitrate(other.target_bitrate),
-      round_trip_time(other.round_trip_time) {
+      round_trip_time(other.round_trip_time),
+      frames_encoded(other.frames_encoded) {
 }
 
 RTCOutboundRTPStreamStats::~RTCOutboundRTPStreamStats() {
 }
 
 WEBRTC_RTCSTATS_IMPL(RTCTransportStats, RTCStats, "transport",
     &bytes_sent,
     &bytes_received,
     &rtcp_transport_stats_id,
     &active_connection,
@@ skipping 27 matching lines @@
       active_connection(other.active_connection),
       selected_candidate_pair_id(other.selected_candidate_pair_id),
       local_certificate_id(other.local_certificate_id),
       remote_certificate_id(other.remote_certificate_id) {
 }
 
 RTCTransportStats::~RTCTransportStats() {
 }
 
 }  // namespace webrtc