Sent bitrate stats are incorrect if FlexFEC is configured.

webrtc/video/send_statistics_proxy_unittest.cc

 /*
  *  Copyright (c) 2013 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #include "webrtc/video/send_statistics_proxy.h"
 
 #include <map>
 #include <memory>
 #include <string>
 #include <vector>
 
 #include "webrtc/system_wrappers/include/metrics.h"
 #include "webrtc/system_wrappers/include/metrics_default.h"
 #include "webrtc/test/gtest.h"
 
 namespace webrtc {
 namespace {
 const uint32_t kFirstSsrc = 17;
 const uint32_t kSecondSsrc = 42;
 const uint32_t kFirstRtxSsrc = 18;
 const uint32_t kSecondRtxSsrc = 43;
+const uint32_t kFlexFecSsrc = 55;
 
 const int kQpIdx0 = 21;
 const int kQpIdx1 = 39;
 }  // namespace
 
 class SendStatisticsProxyTest : public ::testing::Test {
  public:
   SendStatisticsProxyTest()
       : fake_clock_(1234), config_(GetTestConfig()), avg_delay_ms_(0),
         max_delay_ms_(0) {}
@@ skipping 15 matching lines @@
   VideoSendStream::Config GetTestConfig() {
     VideoSendStream::Config config(nullptr);
     config.rtp.ssrcs.push_back(kFirstSsrc);
     config.rtp.ssrcs.push_back(kSecondSsrc);
     config.rtp.rtx.ssrcs.push_back(kFirstRtxSsrc);
     config.rtp.rtx.ssrcs.push_back(kSecondRtxSsrc);
     config.rtp.ulpfec.red_payload_type = 17;
     return config;
   }
 
+  VideoSendStream::Config GetTestConfigWithFlexFec() {
+    VideoSendStream::Config config(nullptr);
+    config.rtp.ssrcs.push_back(kFirstSsrc);
+    config.rtp.ssrcs.push_back(kSecondSsrc);
+    config.rtp.rtx.ssrcs.push_back(kFirstRtxSsrc);
+    config.rtp.rtx.ssrcs.push_back(kSecondRtxSsrc);
+    config.rtp.flexfec.flexfec_payload_type = 50;
+    config.rtp.flexfec.flexfec_ssrc = kFlexFecSsrc;
+    return config;
+  }
+
+  VideoSendStream::StreamStats GetStreamStats(uint32_t ssrc) {
+    VideoSendStream::Stats stats = statistics_proxy_->GetStats();
+    std::map<uint32_t, VideoSendStream::StreamStats>::iterator it =
+        stats.substreams.find(ssrc);
+    EXPECT_NE(it, stats.substreams.end());
+    return it->second;
+  }
+
   void ExpectEqual(VideoSendStream::Stats one, VideoSendStream::Stats other) {
     EXPECT_EQ(one.input_frame_rate, other.input_frame_rate);
     EXPECT_EQ(one.encode_frame_rate, other.encode_frame_rate);
     EXPECT_EQ(one.media_bitrate_bps, other.media_bitrate_bps);
     EXPECT_EQ(one.preferred_media_bitrate_bps,
               other.preferred_media_bitrate_bps);
     EXPECT_EQ(one.suspended, other.suspended);
 
     EXPECT_EQ(one.substreams.size(), other.substreams.size());
     for (std::map<uint32_t, VideoSendStream::StreamStats>::const_iterator it =
@@ skipping 744 matching lines @@
                    2 * kRate));
   EXPECT_EQ(1, metrics::NumEvents(
                    "WebRTC.Video.Screenshare.PliPacketsReceivedPerMinute",
                    3 * kRate));
   EXPECT_EQ(1,
             metrics::NumEvents(
                 "WebRTC.Video.Screenshare.UniqueNackRequestsReceivedInPercent",
                 4 * 100 / 5));
 }
 
+TEST_F(SendStatisticsProxyTest, GetStatsReportsIsFlexFec) {
+  statistics_proxy_.reset(
+      new SendStatisticsProxy(&fake_clock_, GetTestConfigWithFlexFec(),
+                              VideoEncoderConfig::ContentType::kRealtimeVideo));
+
+  StreamDataCountersCallback* proxy =
+      static_cast<StreamDataCountersCallback*>(statistics_proxy_.get());
+  StreamDataCounters counters;
+  proxy->DataCountersUpdated(counters, kFirstSsrc);
+  proxy->DataCountersUpdated(counters, kFlexFecSsrc);
+
+  EXPECT_FALSE(GetStreamStats(kFirstSsrc).is_flexfec);
+  EXPECT_TRUE(GetStreamStats(kFlexFecSsrc).is_flexfec);
+}
+
+TEST_F(SendStatisticsProxyTest, SendBitratesAreReportedWithFlexFecEnabled) {
+  statistics_proxy_.reset(
+      new SendStatisticsProxy(&fake_clock_, GetTestConfigWithFlexFec(),
+                              VideoEncoderConfig::ContentType::kRealtimeVideo));
+
+  StreamDataCountersCallback* proxy =
+      static_cast<StreamDataCountersCallback*>(statistics_proxy_.get());
+
+  StreamDataCounters counters;
+  StreamDataCounters rtx_counters;
+  proxy->DataCountersUpdated(counters, kFirstSsrc);
+  proxy->DataCountersUpdated(counters, kSecondSsrc);
+  proxy->DataCountersUpdated(rtx_counters, kFirstRtxSsrc);
+  proxy->DataCountersUpdated(rtx_counters, kSecondRtxSsrc);
+  proxy->DataCountersUpdated(counters, kFlexFecSsrc);
+
+  counters.transmitted.header_bytes = 5000;
+  counters.transmitted.packets = 20;
+  counters.transmitted.padding_bytes = 10000;
+  counters.transmitted.payload_bytes = 20000;
+  counters.retransmitted.header_bytes = 400;
+  counters.retransmitted.packets = 2;
+  counters.retransmitted.padding_bytes = 1000;
+  counters.retransmitted.payload_bytes = 2000;
+  counters.fec = counters.retransmitted;
+  rtx_counters.transmitted = counters.transmitted;
+
+  fake_clock_.AdvanceTimeMilliseconds(1000 * metrics::kMinRunTimeInSeconds);
+  proxy->DataCountersUpdated(counters, kFirstSsrc);
+  proxy->DataCountersUpdated(counters, kSecondSsrc);
+  proxy->DataCountersUpdated(rtx_counters, kFirstRtxSsrc);
+  proxy->DataCountersUpdated(rtx_counters, kSecondRtxSsrc);
+  proxy->DataCountersUpdated(counters, kFlexFecSsrc);
+
+  // Reset stats proxy causes histograms to be reported.
+  statistics_proxy_.reset();
+  EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.BitrateSentInKbps"));
+  EXPECT_EQ(1,
+            metrics::NumEvents(
+                "WebRTC.Video.BitrateSentInKbps",
+                static_cast<int>((counters.transmitted.TotalBytes() * 4 * 8) /
+                                 metrics::kMinRunTimeInSeconds / 1000)));
+
+  EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.MediaBitrateSentInKbps"));
+  EXPECT_EQ(1, metrics::NumEvents(
+                   "WebRTC.Video.MediaBitrateSentInKbps",
+                   static_cast<int>((counters.MediaPayloadBytes() * 2 * 8) /
+                                    metrics::kMinRunTimeInSeconds / 1000)));
+
+  EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.PaddingBitrateSentInKbps"));
+  EXPECT_EQ(1,
+            metrics::NumEvents(
+                "WebRTC.Video.PaddingBitrateSentInKbps",
+                static_cast<int>((counters.transmitted.padding_bytes * 4 * 8) /
+                                 metrics::kMinRunTimeInSeconds / 1000)));
+
+  EXPECT_EQ(1,
+            metrics::NumSamples("WebRTC.Video.RetransmittedBitrateSentInKbps"));
+  EXPECT_EQ(1,
+            metrics::NumEvents(
+                "WebRTC.Video.RetransmittedBitrateSentInKbps",
+                static_cast<int>((counters.retransmitted.TotalBytes() * 2 * 8) /
+                                 metrics::kMinRunTimeInSeconds / 1000)));
+
+  EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.RtxBitrateSentInKbps"));
+  EXPECT_EQ(
+      1, metrics::NumEvents(
+             "WebRTC.Video.RtxBitrateSentInKbps",
+             static_cast<int>((rtx_counters.transmitted.TotalBytes() * 2 * 8) /
+                              metrics::kMinRunTimeInSeconds / 1000)));
+
+  EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.FecBitrateSentInKbps"));
+  EXPECT_EQ(1, metrics::NumEvents(
+                   "WebRTC.Video.FecBitrateSentInKbps",
+                   static_cast<int>((counters.fec.TotalBytes() * 2 * 8) /
+                                    metrics::kMinRunTimeInSeconds / 1000)));
+}
+
 TEST_F(SendStatisticsProxyTest, ResetsRtpCountersOnContentChange) {
   StreamDataCountersCallback* proxy =
       static_cast<StreamDataCountersCallback*>(statistics_proxy_.get());
   StreamDataCounters counters;
   StreamDataCounters rtx_counters;
   counters.first_packet_time_ms = fake_clock_.TimeInMilliseconds();
   proxy->DataCountersUpdated(counters, kFirstSsrc);
   proxy->DataCountersUpdated(counters, kSecondSsrc);
   proxy->DataCountersUpdated(rtx_counters, kFirstRtxSsrc);
   proxy->DataCountersUpdated(rtx_counters, kSecondRtxSsrc);
 
-  counters.transmitted.header_bytes = 400;
+  counters.transmitted.header_bytes = 5000;
   counters.transmitted.packets = 20;
-  counters.transmitted.padding_bytes = 1000;
-  counters.transmitted.payload_bytes = 2000;
+  counters.transmitted.padding_bytes = 10000;
+  counters.transmitted.payload_bytes = 20000;
 
-  counters.retransmitted.header_bytes = 40;
+  counters.retransmitted.header_bytes = 400;
   counters.retransmitted.packets = 2;
-  counters.retransmitted.padding_bytes = 100;
-  counters.retransmitted.payload_bytes = 200;
+  counters.retransmitted.padding_bytes = 1000;
+  counters.retransmitted.payload_bytes = 2000;
 
   counters.fec = counters.retransmitted;
 
   rtx_counters.transmitted = counters.transmitted;
 
   fake_clock_.AdvanceTimeMilliseconds(1000 * metrics::kMinRunTimeInSeconds);
   proxy->DataCountersUpdated(counters, kFirstSsrc);
   proxy->DataCountersUpdated(counters, kSecondSsrc);
   proxy->DataCountersUpdated(rtx_counters, kFirstRtxSsrc);
   proxy->DataCountersUpdated(rtx_counters, kSecondRtxSsrc);
@@ skipping 34 matching lines @@
   EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.RtxBitrateSentInKbps"));
   EXPECT_EQ(
       1, metrics::NumEvents(
              "WebRTC.Video.RtxBitrateSentInKbps",
              static_cast<int>((rtx_counters.transmitted.TotalBytes() * 2 * 8) /
                               metrics::kMinRunTimeInSeconds / 1000)));
 
   EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.FecBitrateSentInKbps"));
   EXPECT_EQ(1, metrics::NumEvents(
                    "WebRTC.Video.FecBitrateSentInKbps",
-                   static_cast<int>((rtx_counters.fec.TotalBytes() * 2 * 8) /
+                   static_cast<int>((counters.fec.TotalBytes() * 2 * 8) /
                                     metrics::kMinRunTimeInSeconds / 1000)));
 
   // New start time but same counter values.
   proxy->DataCountersUpdated(counters, kFirstSsrc);
   proxy->DataCountersUpdated(counters, kSecondSsrc);
   proxy->DataCountersUpdated(rtx_counters, kFirstRtxSsrc);
   proxy->DataCountersUpdated(rtx_counters, kSecondRtxSsrc);
 
   // Double counter values, this should result in the same counts as before but
   // with new histogram names.
@@ skipping 46 matching lines @@
   EXPECT_EQ(
       1, metrics::NumEvents(
              "WebRTC.Video.Screenshare.RtxBitrateSentInKbps",
              static_cast<int>((rtx_counters.transmitted.TotalBytes() * 2 * 8) /
                               metrics::kMinRunTimeInSeconds / 1000)));
 
   EXPECT_EQ(
       1, metrics::NumSamples("WebRTC.Video.Screenshare.FecBitrateSentInKbps"));
   EXPECT_EQ(1, metrics::NumEvents(
                    "WebRTC.Video.Screenshare.FecBitrateSentInKbps",
-                   static_cast<int>((rtx_counters.fec.TotalBytes() * 2 * 8) /
+                   static_cast<int>((counters.fec.TotalBytes() * 2 * 8) /
                                     metrics::kMinRunTimeInSeconds / 1000)));
 }
 
 }  // namespace webrtc