diff --git a/modules/modules.gyp b/modules/modules.gyp
index 25a9b29..5fc87fe 100644
--- a/modules/modules.gyp
+++ b/modules/modules.gyp
@@ -369,6 +369,7 @@
             'video_coding/jitter_estimator_tests.cc',
             'video_coding/media_optimization_unittest.cc',
             'video_coding/nack_module_unittest.cc',
+            'video_coding/percentile_filter_unittest.cc',
             'video_coding/receiver_unittest.cc',
             'video_coding/session_info_unittest.cc',
             'video_coding/sequence_number_util_unittest.cc',
diff --git a/modules/video_coding/BUILD.gn b/modules/video_coding/BUILD.gn
index d95d2bc..37a0d2c 100644
--- a/modules/video_coding/BUILD.gn
+++ b/modules/video_coding/BUILD.gn
@@ -50,6 +50,8 @@
     "nack_module.h",
     "packet.cc",
     "packet.h",
+    "percentile_filter.cc",
+    "percentile_filter.h",
     "qm_select.cc",
     "qm_select.h",
     "qm_select_data.h",
diff --git a/modules/video_coding/codec_timer.cc b/modules/video_coding/codec_timer.cc
index 60add8f..0fdf1a6 100644
--- a/modules/video_coding/codec_timer.cc
+++ b/modules/video_coding/codec_timer.cc
@@ -10,87 +10,47 @@
 
 #include "webrtc/modules/video_coding/codec_timer.h"
 
-#include <assert.h>
-
 namespace webrtc {
 
+namespace {
+
 // The first kIgnoredSampleCount samples will be ignored.
-static const int32_t kIgnoredSampleCount = 5;
+const int kIgnoredSampleCount = 5;
+// Return the |kPercentile| value in RequiredDecodeTimeMs().
+const float kPercentile = 0.95f;
+// The window size in ms.
+const int64_t kTimeLimitMs = 10000;
+
+}  // anonymous namespace
 
 VCMCodecTimer::VCMCodecTimer()
-    : _filteredMax(0), _ignoredSampleCount(0), _shortMax(0), _history() {
-  Reset();
-}
+    : ignored_sample_count_(0), filter_(kPercentile) {}
 
-void VCMCodecTimer::Reset() {
-  _filteredMax = 0;
-  _ignoredSampleCount = 0;
-  _shortMax = 0;
-  for (int i = 0; i < MAX_HISTORY_SIZE; i++) {
-    _history[i].shortMax = 0;
-    _history[i].timeMs = -1;
-  }
-}
-
-// Update the max-value filter
-void VCMCodecTimer::MaxFilter(int32_t decodeTime, int64_t nowMs) {
-  if (_ignoredSampleCount >= kIgnoredSampleCount) {
-    UpdateMaxHistory(decodeTime, nowMs);
-    ProcessHistory(nowMs);
-  } else {
-    _ignoredSampleCount++;
-  }
-}
-
-void VCMCodecTimer::UpdateMaxHistory(int32_t decodeTime, int64_t now) {
-  if (_history[0].timeMs >= 0 && now - _history[0].timeMs < SHORT_FILTER_MS) {
-    if (decodeTime > _shortMax) {
-      _shortMax = decodeTime;
-    }
-  } else {
-    // Only add a new value to the history once a second
-    if (_history[0].timeMs == -1) {
-      // First, no shift
-      _shortMax = decodeTime;
-    } else {
-      // Shift
-      for (int i = (MAX_HISTORY_SIZE - 2); i >= 0; i--) {
-        _history[i + 1].shortMax = _history[i].shortMax;
-        _history[i + 1].timeMs = _history[i].timeMs;
-      }
-    }
-    if (_shortMax == 0) {
-      _shortMax = decodeTime;
-    }
-
-    _history[0].shortMax = _shortMax;
-    _history[0].timeMs = now;
-    _shortMax = 0;
-  }
-}
-
-void VCMCodecTimer::ProcessHistory(int64_t nowMs) {
-  _filteredMax = _shortMax;
-  if (_history[0].timeMs == -1) {
+void VCMCodecTimer::AddTiming(int64_t decode_time_ms, int64_t now_ms) {
+  // Ignore the first |kIgnoredSampleCount| samples.
+  if (ignored_sample_count_ < kIgnoredSampleCount) {
+    ++ignored_sample_count_;
     return;
   }
-  for (int i = 0; i < MAX_HISTORY_SIZE; i++) {
-    if (_history[i].timeMs == -1) {
-      break;
-    }
-    if (nowMs - _history[i].timeMs > MAX_HISTORY_SIZE * SHORT_FILTER_MS) {
-      // This sample (and all samples after this) is too old
-      break;
-    }
-    if (_history[i].shortMax > _filteredMax) {
-      // This sample is the largest one this far into the history
-      _filteredMax = _history[i].shortMax;
-    }
+
+  // Insert new decode time value.
+  filter_.Insert(decode_time_ms);
+  history_.emplace(decode_time_ms, now_ms);
+
+  // Pop old decode time values.
+  while (!history_.empty() &&
+         now_ms - history_.front().sample_time_ms > kTimeLimitMs) {
+    filter_.Erase(history_.front().decode_time_ms);
+    history_.pop();
   }
 }
 
-// Get the maximum observed time within a time window
-int32_t VCMCodecTimer::RequiredDecodeTimeMs(FrameType /*frameType*/) const {
-  return _filteredMax;
+// Get the 95th percentile observed decode time within a time window.
+int64_t VCMCodecTimer::RequiredDecodeTimeMs() const {
+  return filter_.GetPercentileValue();
 }
+
+VCMCodecTimer::Sample::Sample(int64_t decode_time_ms, int64_t sample_time_ms)
+    : decode_time_ms(decode_time_ms), sample_time_ms(sample_time_ms) {}
+
 }  // namespace webrtc
diff --git a/modules/video_coding/codec_timer.h b/modules/video_coding/codec_timer.h
index 8ebd82a..90ef6bb 100644
--- a/modules/video_coding/codec_timer.h
+++ b/modules/video_coding/codec_timer.h
@@ -11,45 +11,39 @@
 #ifndef WEBRTC_MODULES_VIDEO_CODING_CODEC_TIMER_H_
 #define WEBRTC_MODULES_VIDEO_CODING_CODEC_TIMER_H_
 
+#include <queue>
+
 #include "webrtc/modules/include/module_common_types.h"
+#include "webrtc/modules/video_coding/percentile_filter.h"
 #include "webrtc/typedefs.h"
 
 namespace webrtc {
 
-// MAX_HISTORY_SIZE * SHORT_FILTER_MS defines the window size in milliseconds
-#define MAX_HISTORY_SIZE 10
-#define SHORT_FILTER_MS 1000
-
-class VCMShortMaxSample {
- public:
-  VCMShortMaxSample() : shortMax(0), timeMs(-1) {}
-
-  int32_t shortMax;
-  int64_t timeMs;
-};
-
 class VCMCodecTimer {
  public:
   VCMCodecTimer();
 
-  // Updates the max filtered decode time.
-  void MaxFilter(int32_t newDecodeTimeMs, int64_t nowMs);
+  // Add a new decode time to the filter.
+  void AddTiming(int64_t new_decode_time_ms, int64_t now_ms);
 
-  // Empty the list of timers.
-  void Reset();
-
-  // Get the required decode time in ms.
-  int32_t RequiredDecodeTimeMs(FrameType frameType) const;
+  // Get the required decode time in ms. It is the 95th percentile observed
+  // decode time within a time window.
+  int64_t RequiredDecodeTimeMs() const;
 
  private:
-  void UpdateMaxHistory(int32_t decodeTime, int64_t now);
-  void ProcessHistory(int64_t nowMs);
+  struct Sample {
+    Sample(int64_t decode_time_ms, int64_t sample_time_ms);
+    int64_t decode_time_ms;
+    int64_t sample_time_ms;
+  };
 
-  int32_t _filteredMax;
   // The number of samples ignored so far.
-  int32_t _ignoredSampleCount;
-  int32_t _shortMax;
-  VCMShortMaxSample _history[MAX_HISTORY_SIZE];
+  int ignored_sample_count_;
+  // Queue with history of latest decode time values.
+  std::queue<Sample> history_;
+  // |filter_| contains the same values as |history_|, but in a data structure
+  // that allows efficient retrieval of the percentile value.
+  PercentileFilter filter_;
 };
 
 }  // namespace webrtc
diff --git a/modules/video_coding/percentile_filter.cc b/modules/video_coding/percentile_filter.cc
new file mode 100644
index 0000000..6495567
--- /dev/null
+++ b/modules/video_coding/percentile_filter.cc
@@ -0,0 +1,70 @@
+/*
+ *  Copyright (c) 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.
+ */
+
+#include "webrtc/modules/video_coding/percentile_filter.h"
+
+#include <iterator>
+
+#include "webrtc/base/checks.h"
+
+namespace webrtc {
+
+PercentileFilter::PercentileFilter(float percentile)
+    : percentile_(percentile),
+      percentile_it_(set_.begin()),
+      percentile_index_(0) {
+  RTC_CHECK_GE(percentile, 0.0f);
+  RTC_CHECK_LE(percentile, 1.0f);
+}
+
+void PercentileFilter::Insert(const int64_t& value) {
+  // Insert element at the upper bound.
+  set_.insert(value);
+  if (set_.size() == 1u) {
+    // First element inserted - initialize percentile iterator and index.
+    percentile_it_ = set_.begin();
+    percentile_index_ = 0;
+  } else if (value < *percentile_it_) {
+    // If new element is before us, increment |percentile_index_|.
+    ++percentile_index_;
+  }
+  UpdatePercentileIterator();
+}
+
+void PercentileFilter::Erase(const int64_t& value) {
+  std::multiset<int64_t>::const_iterator it = set_.lower_bound(value);
+  // Ignore erase operation if the element is not present in the current set.
+  if (it == set_.end() || *it != value)
+    return;
+  if (it == percentile_it_) {
+    // If same iterator, update to the following element. Index is not affected.
+    percentile_it_ = set_.erase(it);
+  } else {
+    set_.erase(it);
+    // If erased element was before us, decrement |percentile_index_|.
+    if (value <= *percentile_it_)
+      --percentile_index_;
+  }
+  UpdatePercentileIterator();
+}
+
+void PercentileFilter::UpdatePercentileIterator() {
+  if (set_.empty())
+    return;
+  const int64_t index = static_cast<int64_t>(percentile_ * (set_.size() - 1));
+  std::advance(percentile_it_, index - percentile_index_);
+  percentile_index_ = index;
+}
+
+int64_t PercentileFilter::GetPercentileValue() const {
+  return set_.empty() ? 0 : *percentile_it_;
+}
+
+}  // namespace webrtc
diff --git a/modules/video_coding/percentile_filter.h b/modules/video_coding/percentile_filter.h
new file mode 100644
index 0000000..125a244
--- /dev/null
+++ b/modules/video_coding/percentile_filter.h
@@ -0,0 +1,50 @@
+/*
+ *  Copyright (c) 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.
+ */
+
+#ifndef WEBRTC_MODULES_VIDEO_CODING_PERCENTILE_FILTER_H_
+#define WEBRTC_MODULES_VIDEO_CODING_PERCENTILE_FILTER_H_
+
+#include <stdint.h>
+
+#include <set>
+
+namespace webrtc {
+
+// Class to efficiently get the percentile value from a group of observations.
+// The percentile is the value below which a given percentage of the
+// observations fall.
+class PercentileFilter {
+ public:
+  // Construct filter. |percentile| should be between 0 and 1.
+  explicit PercentileFilter(float percentile);
+
+  // Insert one observation. The complexity of this operation is logarithmic in
+  // the size of the container.
+  void Insert(const int64_t& value);
+  // Remove one observation. The complexity of this operation is logarithmic in
+  // the size of the container.
+  void Erase(const int64_t& value);
+  // Get the percentile value. The complexity of this operation is constant.
+  int64_t GetPercentileValue() const;
+
+ private:
+  // Update iterator and index to point at target percentile value.
+  void UpdatePercentileIterator();
+
+  const float percentile_;
+  std::multiset<int64_t> set_;
+  // Maintain iterator and index of current target percentile value.
+  std::multiset<int64_t>::iterator percentile_it_;
+  int64_t percentile_index_;
+};
+
+}  // namespace webrtc
+
+#endif  // WEBRTC_MODULES_VIDEO_CODING_PERCENTILE_FILTER_H_
diff --git a/modules/video_coding/percentile_filter_unittest.cc b/modules/video_coding/percentile_filter_unittest.cc
new file mode 100644
index 0000000..8029bdb
--- /dev/null
+++ b/modules/video_coding/percentile_filter_unittest.cc
@@ -0,0 +1,104 @@
+/*
+ *  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.
+ */
+
+#include <algorithm>
+
+#include "testing/gtest/include/gtest/gtest.h"
+#include "webrtc/base/constructormagic.h"
+#include "webrtc/modules/video_coding/percentile_filter.h"
+
+namespace webrtc {
+
+class PercentileFilterTest : public ::testing::TestWithParam<float> {
+ public:
+  PercentileFilterTest() : filter_(GetParam()) {
+    // Make sure the tests are deterministic by seeding with a constant.
+    srand(42);
+  }
+
+ protected:
+  PercentileFilter filter_;
+
+ private:
+  RTC_DISALLOW_COPY_AND_ASSIGN(PercentileFilterTest);
+};
+
+INSTANTIATE_TEST_CASE_P(PercentileFilterTests,
+                        PercentileFilterTest,
+                        ::testing::Values(0.0f, 0.1f, 0.5f, 0.9f, 1.0f));
+
+TEST(PercentileFilterTest, MinFilter) {
+  PercentileFilter filter(0.0f);
+  filter.Insert(4);
+  EXPECT_EQ(4, filter.GetPercentileValue());
+  filter.Insert(3);
+  EXPECT_EQ(3, filter.GetPercentileValue());
+}
+
+TEST(PercentileFilterTest, MaxFilter) {
+  PercentileFilter filter(1.0f);
+  filter.Insert(3);
+  EXPECT_EQ(3, filter.GetPercentileValue());
+  filter.Insert(4);
+  EXPECT_EQ(4, filter.GetPercentileValue());
+}
+
+TEST_P(PercentileFilterTest, EmptyFilter) {
+  EXPECT_EQ(0, filter_.GetPercentileValue());
+  filter_.Insert(3);
+  filter_.Erase(3);
+  EXPECT_EQ(0, filter_.GetPercentileValue());
+}
+
+TEST_P(PercentileFilterTest, EraseNonExistingElement) {
+  filter_.Erase(3);
+  EXPECT_EQ(0, filter_.GetPercentileValue());
+  filter_.Insert(4);
+  filter_.Erase(3);
+  EXPECT_EQ(4, filter_.GetPercentileValue());
+}
+
+TEST_P(PercentileFilterTest, DuplicateElements) {
+  filter_.Insert(3);
+  filter_.Insert(3);
+  filter_.Erase(3);
+  EXPECT_EQ(3, filter_.GetPercentileValue());
+}
+
+TEST_P(PercentileFilterTest, InsertAndEraseTenValuesInRandomOrder) {
+  int64_t zero_to_nine[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+  // The percentile value of the ten values above.
+  const int64_t expected_value = static_cast<int64_t>(GetParam() * 9);
+
+  // Insert two sets of |zero_to_nine| in random order.
+  for (int i = 0; i < 2; ++i) {
+    std::random_shuffle(zero_to_nine, zero_to_nine + 10);
+    for (int64_t value : zero_to_nine)
+      filter_.Insert(value);
+    // After inserting a full set of |zero_to_nine|, the percentile should
+    // stay constant.
+    EXPECT_EQ(expected_value, filter_.GetPercentileValue());
+  }
+
+  // Insert and erase sets of |zero_to_nine| in random order a few times.
+  for (int i = 0; i < 3; ++i) {
+    std::random_shuffle(zero_to_nine, zero_to_nine + 10);
+    for (int64_t value : zero_to_nine)
+      filter_.Erase(value);
+    EXPECT_EQ(expected_value, filter_.GetPercentileValue());
+
+    std::random_shuffle(zero_to_nine, zero_to_nine + 10);
+    for (int64_t value : zero_to_nine)
+      filter_.Insert(value);
+    EXPECT_EQ(expected_value, filter_.GetPercentileValue());
+  }
+}
+
+}  // namespace webrtc
diff --git a/modules/video_coding/timing.cc b/modules/video_coding/timing.cc
index 680860a..91f5f84 100644
--- a/modules/video_coding/timing.cc
+++ b/modules/video_coding/timing.cc
@@ -25,7 +25,7 @@
       clock_(clock),
       master_(false),
       ts_extrapolator_(),
-      codec_timer_(),
+      codec_timer_(new VCMCodecTimer()),
       render_delay_ms_(kDefaultRenderDelayMs),
       min_playout_delay_ms_(0),
       jitter_delay_ms_(0),
@@ -78,7 +78,7 @@
 void VCMTiming::Reset() {
   CriticalSectionScoped cs(crit_sect_);
   ts_extrapolator_->Reset(clock_->TimeInMilliseconds());
-  codec_timer_.Reset();
+  codec_timer_.reset(new VCMCodecTimer());
   render_delay_ms_ = kDefaultRenderDelayMs;
   min_playout_delay_ms_ = 0;
   jitter_delay_ms_ = 0;
@@ -88,7 +88,7 @@
 
 void VCMTiming::ResetDecodeTime() {
   CriticalSectionScoped lock(crit_sect_);
-  codec_timer_.Reset();
+  codec_timer_.reset(new VCMCodecTimer());
 }
 
 void VCMTiming::set_render_delay(uint32_t render_delay_ms) {
@@ -156,8 +156,9 @@
                                    int64_t actual_decode_time_ms) {
   CriticalSectionScoped cs(crit_sect_);
   uint32_t target_delay_ms = TargetDelayInternal();
-  int64_t delayed_ms = actual_decode_time_ms -
-                       (render_time_ms - MaxDecodeTimeMs() - render_delay_ms_);
+  int64_t delayed_ms =
+      actual_decode_time_ms -
+      (render_time_ms - RequiredDecodeTimeMs() - render_delay_ms_);
   if (delayed_ms < 0) {
     return;
   }
@@ -173,7 +174,7 @@
                                    int64_t now_ms,
                                    int64_t render_time_ms) {
   CriticalSectionScoped cs(crit_sect_);
-  codec_timer_.MaxFilter(decode_time_ms, now_ms);
+  codec_timer_->AddTiming(decode_time_ms, now_ms);
   assert(decode_time_ms >= 0);
   last_decode_ms_ = decode_time_ms;
 
@@ -216,9 +217,8 @@
 }
 
 // Must be called from inside a critical section.
-int32_t VCMTiming::MaxDecodeTimeMs(
-    FrameType frame_type /*= kVideoFrameDelta*/) const {
-  const int32_t decode_time_ms = codec_timer_.RequiredDecodeTimeMs(frame_type);
+int64_t VCMTiming::RequiredDecodeTimeMs() const {
+  const int64_t decode_time_ms = codec_timer_->RequiredDecodeTimeMs();
   assert(decode_time_ms >= 0);
   return decode_time_ms;
 }
@@ -228,7 +228,7 @@
   CriticalSectionScoped cs(crit_sect_);
 
   const int64_t max_wait_time_ms =
-      render_time_ms - now_ms - MaxDecodeTimeMs() - render_delay_ms_;
+      render_time_ms - now_ms - RequiredDecodeTimeMs() - render_delay_ms_;
 
   if (max_wait_time_ms < 0) {
     return 0;
@@ -239,18 +239,18 @@
 bool VCMTiming::EnoughTimeToDecode(
     uint32_t available_processing_time_ms) const {
   CriticalSectionScoped cs(crit_sect_);
-  int32_t max_decode_time_ms = MaxDecodeTimeMs();
-  if (max_decode_time_ms < 0) {
+  int64_t required_decode_time_ms = RequiredDecodeTimeMs();
+  if (required_decode_time_ms < 0) {
     // Haven't decoded any frames yet, try decoding one to get an estimate
     // of the decode time.
     return true;
-  } else if (max_decode_time_ms == 0) {
+  } else if (required_decode_time_ms == 0) {
     // Decode time is less than 1, set to 1 for now since
     // we don't have any better precision. Count ticks later?
-    max_decode_time_ms = 1;
+    required_decode_time_ms = 1;
   }
-  return static_cast<int32_t>(available_processing_time_ms) -
-             max_decode_time_ms >
+  return static_cast<int64_t>(available_processing_time_ms) -
+             required_decode_time_ms >
          0;
 }
 
@@ -261,7 +261,9 @@
 
 uint32_t VCMTiming::TargetDelayInternal() const {
   return std::max(min_playout_delay_ms_,
-                  jitter_delay_ms_ + MaxDecodeTimeMs() + render_delay_ms_);
+                  jitter_delay_ms_ +
+                      static_cast<uint32_t>(RequiredDecodeTimeMs()) +
+                      render_delay_ms_);
 }
 
 void VCMTiming::GetTimings(int* decode_ms,
@@ -273,7 +275,7 @@
                            int* render_delay_ms) const {
   CriticalSectionScoped cs(crit_sect_);
   *decode_ms = last_decode_ms_;
-  *max_decode_ms = MaxDecodeTimeMs();
+  *max_decode_ms = static_cast<int>(RequiredDecodeTimeMs());
   *current_delay_ms = current_delay_ms_;
   *target_delay_ms = TargetDelayInternal();
   *jitter_buffer_ms = jitter_delay_ms_;
diff --git a/modules/video_coding/timing.h b/modules/video_coding/timing.h
index a4d0cf4..a45eee3 100644
--- a/modules/video_coding/timing.h
+++ b/modules/video_coding/timing.h
@@ -11,6 +11,8 @@
 #ifndef WEBRTC_MODULES_VIDEO_CODING_TIMING_H_
 #define WEBRTC_MODULES_VIDEO_CODING_TIMING_H_
 
+#include <memory>
+
 #include "webrtc/base/thread_annotations.h"
 #include "webrtc/modules/video_coding/codec_timer.h"
 #include "webrtc/system_wrappers/include/critical_section_wrapper.h"
@@ -94,7 +96,7 @@
   enum { kDelayMaxChangeMsPerS = 100 };
 
  protected:
-  int32_t MaxDecodeTimeMs(FrameType frame_type = kVideoFrameDelta) const
+  int64_t RequiredDecodeTimeMs() const
       EXCLUSIVE_LOCKS_REQUIRED(crit_sect_);
   int64_t RenderTimeMsInternal(uint32_t frame_timestamp, int64_t now_ms) const
       EXCLUSIVE_LOCKS_REQUIRED(crit_sect_);
@@ -107,7 +109,7 @@
   Clock* const clock_;
   bool master_ GUARDED_BY(crit_sect_);
   TimestampExtrapolator* ts_extrapolator_ GUARDED_BY(crit_sect_);
-  VCMCodecTimer codec_timer_ GUARDED_BY(crit_sect_);
+  std::unique_ptr<VCMCodecTimer> codec_timer_ GUARDED_BY(crit_sect_);
   uint32_t render_delay_ms_ GUARDED_BY(crit_sect_);
   uint32_t min_playout_delay_ms_ GUARDED_BY(crit_sect_);
   uint32_t jitter_delay_ms_ GUARDED_BY(crit_sect_);
diff --git a/modules/video_coding/timing_unittest.cc b/modules/video_coding/timing_unittest.cc
index 2e8df83..51ef354 100644
--- a/modules/video_coding/timing_unittest.cc
+++ b/modules/video_coding/timing_unittest.cc
@@ -29,7 +29,7 @@
   VCMTiming timing(&clock);
   uint32_t waitTime = 0;
   uint32_t jitterDelayMs = 0;
-  uint32_t maxDecodeTimeMs = 0;
+  uint32_t requiredDecodeTimeMs = 0;
   uint32_t timeStamp = 0;
 
   timing.Reset();
@@ -94,7 +94,7 @@
     clock.AdvanceTimeMilliseconds(1000 / 25 - 10);
     timing.IncomingTimestamp(timeStamp, clock.TimeInMilliseconds());
   }
-  maxDecodeTimeMs = 10;
+  requiredDecodeTimeMs = 10;
   timing.SetJitterDelay(jitterDelayMs);
   clock.AdvanceTimeMilliseconds(1000);
   timeStamp += 90000;
@@ -116,7 +116,7 @@
       clock.TimeInMilliseconds());
   // We should at least have minTotalDelayMs - decodeTime (10) - renderTime
   // (10) to wait.
-  EXPECT_EQ(waitTime, minTotalDelayMs - maxDecodeTimeMs - kRenderDelayMs);
+  EXPECT_EQ(waitTime, minTotalDelayMs - requiredDecodeTimeMs - kRenderDelayMs);
   // The total video delay should be equal to the min total delay.
   EXPECT_EQ(minTotalDelayMs, timing.TargetVideoDelay());
 
diff --git a/modules/video_coding/video_coding.gypi b/modules/video_coding/video_coding.gypi
index 02c9c6b..82c2726 100644
--- a/modules/video_coding/video_coding.gypi
+++ b/modules/video_coding/video_coding.gypi
@@ -47,6 +47,7 @@
         'nack_fec_tables.h',
         'nack_module.h',
         'packet.h',
+        'percentile_filter.h',
         'qm_select_data.h',
         'qm_select.h',
         'receiver.h',
@@ -74,6 +75,7 @@
         'media_optimization.cc',
         'nack_module.cc',
         'packet.cc',
+        'percentile_filter.cc',
         'qm_select.cc',
         'receiver.cc',
         'rtt_filter.cc',