Enable BWE logging to command line when rtc_enable_bwe_test_logging is set to true

webrtc/modules/remote_bitrate_estimator/overuse_estimator.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/modules/remote_bitrate_estimator/overuse_estimator.h"
 
 #include <assert.h>
 #include <math.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include <algorithm>
 
 #include "webrtc/base/logging.h"
 #include "webrtc/modules/remote_bitrate_estimator/include/bwe_defines.h"
 

[stefan-webrtc, 2016/09/13 08:19:44]

Remove this empty line.

+#include "webrtc/modules/remote_bitrate_estimator/test/bwe_test_logging.h"
+
 namespace webrtc {
 
 enum { kMinFramePeriodHistoryLength = 60 };
 enum { kDeltaCounterMax = 1000 };
 
 OveruseEstimator::OveruseEstimator(const OverUseDetectorOptions& options)
     : options_(options),
       num_of_deltas_(0),
       slope_(options_.initial_slope),
       offset_(options_.initial_offset),
       prev_offset_(options_.initial_offset),
       E_(),
       process_noise_(),
       avg_noise_(options_.initial_avg_noise),
       var_noise_(options_.initial_var_noise),
       ts_delta_hist_() {
   memcpy(E_, options_.initial_e, sizeof(E_));
   memcpy(process_noise_, options_.initial_process_noise,
          sizeof(process_noise_));
 }
 
 OveruseEstimator::~OveruseEstimator() {
   ts_delta_hist_.clear();
 }
 
 void OveruseEstimator::Update(int64_t t_delta,
                               double ts_delta,
                               int size_delta,
-                              BandwidthUsage current_hypothesis) {
+                              BandwidthUsage current_hypothesis,
+                              int64_t now_ms) {
   const double min_frame_period = UpdateMinFramePeriod(ts_delta);
   const double t_ts_delta = t_delta - ts_delta;
+  BWE_TEST_LOGGING_PLOT(1, "dm[ms]", now_ms, t_ts_delta);
   double fs_delta = size_delta;
 
   ++num_of_deltas_;
   if (num_of_deltas_ > kDeltaCounterMax) {
     num_of_deltas_ = kDeltaCounterMax;
   }
 
   // Update the Kalman filter.
   E_[0][0] += process_noise_[0];
   E_[1][1] += process_noise_[1];
 
   if ((current_hypothesis == kBwOverusing && offset_ < prev_offset_) ||
       (current_hypothesis == kBwUnderusing && offset_ > prev_offset_)) {
     E_[1][1] += 10 * process_noise_[1];
   }
 
   const double h[2] = {fs_delta, 1.0};
   const double Eh[2] = {E_[0][0]*h[0] + E_[0][1]*h[1],
                         E_[1][0]*h[0] + E_[1][1]*h[1]};
 
+  BWE_TEST_LOGGING_PLOT(1, "d[ms]", now_ms, slope_ * h[0] - offset_);
+
   const double residual = t_ts_delta - slope_*h[0] - offset_;
 
   const bool in_stable_state = (current_hypothesis == kBwNormal);
   const double max_residual = 3.0 * sqrt(var_noise_);
   // We try to filter out very late frames. For instance periodic key
   // frames doesn't fit the Gaussian model well.
   if (fabs(residual) < max_residual) {
     UpdateNoiseEstimate(residual, min_frame_period, in_stable_state);
   } else {
     UpdateNoiseEstimate(residual < 0 ? -max_residual : max_residual,
@@ skipping 21 matching lines @@
       E_[0][0] * E_[1][1] - E_[0][1] * E_[1][0] >= 0 && E_[0][0] >= 0;
   assert(positive_semi_definite);
   if (!positive_semi_definite) {
     LOG(LS_ERROR) << "The over-use estimator's covariance matrix is no longer "
                      "semi-definite.";
   }
 
   slope_ = slope_ + K[0] * residual;
   prev_offset_ = offset_;
   offset_ = offset_ + K[1] * residual;
+
+  BWE_TEST_LOGGING_PLOT(1, "kc", now_ms, K[0]);
+  BWE_TEST_LOGGING_PLOT(1, "km", now_ms, K[1]);
+  BWE_TEST_LOGGING_PLOT(1, "slope[1/bps]", now_ms, slope_);
+  BWE_TEST_LOGGING_PLOT(1, "var_noise", now_ms, var_noise_);
 }
 
 double OveruseEstimator::UpdateMinFramePeriod(double ts_delta) {
   double min_frame_period = ts_delta;
   if (ts_delta_hist_.size() >= kMinFramePeriodHistoryLength) {
     ts_delta_hist_.pop_front();
   }
   std::list<double>::iterator it = ts_delta_hist_.begin();
   for (; it != ts_delta_hist_.end(); it++) {
     min_frame_period = std::min(*it, min_frame_period);
@@ skipping 20 matching lines @@
   const double beta = pow(1 - alpha, ts_delta * 30.0 / 1000.0);
   avg_noise_ = beta * avg_noise_
               + (1 - beta) * residual;
   var_noise_ = beta * var_noise_
               + (1 - beta) * (avg_noise_ - residual) * (avg_noise_ - residual);
   if (var_noise_ < 1) {
     var_noise_ = 1;
   }
 }
 }  // namespace webrtc