Median filter

webrtc/modules/remote_bitrate_estimator/test/estimators/nada.cc

 /*
  *  Copyright (c) 2015 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 106 matching lines @@
         latest->send_time_ms + now_ms - latest->arrival_time_ms;
   }
 
   // Sends a tuple containing latest values of <d_hat_n, d_tilde_n, x_n, x'_n,
   // R_r> and additional information.
   return new NadaFeedback(flow_id_, now_ms * 1000, exp_smoothed_delay_ms_,
                           est_queuing_delay_signal_ms_, congestion_signal_ms,
                           derivative, RecentKbps(), corrected_send_time_ms);
 }
 
+// If size is even, the median will be the average of the two middlemost
+// numbers.
 int64_t NadaBweReceiver::MedianFilter(int64_t* last_delays_ms, int size) {
-  // Typically, size = 5.
   std::vector<int64_t> array_copy(last_delays_ms, last_delays_ms + size);
   std::nth_element(array_copy.begin(), array_copy.begin() + size / 2,
                    array_copy.end());

[stefan-webrtc, 2015/07/22 09:21:19]

Move this inside the if statement.

-  return array_copy.at(size / 2);
+  // Typically, size = 5. For odd size values, right and left are equal.
+  if (size % 2 == 1) {

[magalhaesc, 2015/07/22 09:01:11]

This "if" statement isn't necessary here. But it avoids unnecessary nth_element
computations (since currently nearly all calls use size = 5).

+    return array_copy.at(size / 2);
+  }
+  int64_t right = array_copy.at(size / 2);
+  std::nth_element(array_copy.begin(), array_copy.begin() + (size - 1) / 2,
+                   array_copy.end());
+  int64_t left = array_copy.at((size - 1) / 2);
+  return (left + right + 1) / 2;
 }
 
 int64_t NadaBweReceiver::ExponentialSmoothingFilter(int64_t new_value,
                                                     int64_t last_smoothed_value,
                                                     float alpha) {
   if (last_smoothed_value < 0) {
     return new_value;  // Handling initial case.
   }
   return static_cast<int64_t>(alpha * new_value +
                               (1.0f - alpha) * last_smoothed_value + 0.5f);
@@ skipping 127 matching lines @@
                         (kTheta - (bitrate_kbps_ - kMinBitrateKbps) * x_hat)) /
                            (kTauOMs * kTauOMs) +
                        0.5f);
 
   bitrate_kbps_ = bitrate_kbps_ + smoothing_factor * original_increase;
 }
 
 }  // namespace bwe
 }  // namespace testing
 }  // namespace webrtc