Fix Bug: Video with Variable Frame Rate plays at incorrect speed.

media/filters/video_cadence_estimator.cc

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "media/filters/video_cadence_estimator.h"
 
 #include <algorithm>
 #include <cmath>
 #include <iterator>
 #include <limits>
 #include <string>
 
 #include "base/metrics/histogram_macros.h"
 
 namespace media {
 
 // To prevent oscillation in and out of cadence or between cadence values, we
 // require some time to elapse before a cadence switch is accepted.
 const int kMinimumCadenceDurationMs = 100;
 
+// The numbers are used to decide whether the current video is variable FPS or
+// constant FPS. If ratio of the sample deviation and the sample average is
+// above |kVariableFPSFactor|, then it is recognized as a variable FPS, and if
+// the ratio is below |kConstantFPSFactor|, then it is recognized as a constant
+// FPS, and if the ratio is in between the two factors, then we do not change
+// previous recognition.
+const double kVariableFPSFactor = 0.1;

[DaleCurtis, 2015/11/20 23:50:46]

Your variable frame rate clip was 0.7? If so it seems like this should be around
that value as well.

[qiangchen, 2015/11/25 18:06:33]

Simply excluding that extreme case may not be optimal. Then one can make another
variable FPS video with variation a little below the threshold and then the
issue still exists obviously.

I'll try to use a more theoretical way to determine the threshold.

That is near the threshold, Cadence method would result in almost same render
length error with that of drift method.

[DaleCurtis, 2015/11/25 21:29:24]

Sure, but I think we want to err on the side of caution here, lets just exclude
things that are *absolutely* variable frame rate material until we have more
data points.

[qiangchen, 2015/12/01 19:37:53]

Done.

+const double kConstantFPSFactor = 0.07;
+
 // Records the number of cadence changes to UMA.
 static void HistogramCadenceChangeCount(int cadence_changes) {
   const int kCadenceChangeMax = 10;
   UMA_HISTOGRAM_CUSTOM_COUNTS("Media.VideoRenderer.CadenceChanges",
                               cadence_changes, 0, kCadenceChangeMax,
                               kCadenceChangeMax);
 }
 
 // Construct a Cadence vector, a vector of integers satisfying the following
 // conditions:
@@ skipping 28 matching lines @@
     actual_accumulate += output[i] * n;
   }
 
   return output;
 }
 
 VideoCadenceEstimator::VideoCadenceEstimator(
     base::TimeDelta minimum_time_until_max_drift)
     : cadence_hysteresis_threshold_(
           base::TimeDelta::FromMilliseconds(kMinimumCadenceDurationMs)),
-      minimum_time_until_max_drift_(minimum_time_until_max_drift) {
+      minimum_time_until_max_drift_(minimum_time_until_max_drift),
+      is_variable_frame_rate_(false) {
   Reset();
 }
 
 VideoCadenceEstimator::~VideoCadenceEstimator() {
 }
 
 void VideoCadenceEstimator::Reset() {
   cadence_.clear();
   pending_cadence_.clear();
   cadence_changes_ = render_intervals_cadence_held_ = 0;
   first_update_call_ = true;
 }
 
 bool VideoCadenceEstimator::UpdateCadenceEstimate(
     base::TimeDelta render_interval,
     base::TimeDelta frame_duration,
+    base::TimeDelta frame_duration_deviation,
     base::TimeDelta max_acceptable_drift) {
   DCHECK_GT(render_interval, base::TimeDelta());
   DCHECK_GT(frame_duration, base::TimeDelta());
 
+  if (frame_duration_deviation.InMillisecondsF() >
+      kVariableFPSFactor * frame_duration.InMillisecondsF()) {
+    is_variable_frame_rate_ = true;
+  } else if (frame_duration_deviation.InMillisecondsF() <
+             kConstantFPSFactor * frame_duration.InMillisecondsF()) {
+    is_variable_frame_rate_ = false;
+  }
+
+  // Variable FPS detected, turn off Cadence by force.
+  if (is_variable_frame_rate_) {
+    render_intervals_cadence_held_ = 0;
+    if (cadence_ != Cadence()) {

[DaleCurtis, 2015/11/20 23:50:46]

if !cadence_.empty() cadence_.clear()

[qiangchen, 2015/11/25 18:06:33]

Done.

+      cadence_ = Cadence();
+      return true;
+    }
+    return false;
+  }
+
   base::TimeDelta time_until_max_drift;
 
   // See if we can find a cadence which fits the data.
   Cadence new_cadence =
       CalculateCadence(render_interval, frame_duration, max_acceptable_drift,
                        &time_until_max_drift);
 
   // If this is the first time UpdateCadenceEstimate() has been called,
   // initialize the histogram with a zero count for cadence changes; this
   // allows us to track the number of playbacks which have cadence at all.
@@ skipping 125 matching lines @@
 
   std::ostringstream os;
   os << "[";
   std::copy(cadence.begin(), cadence.end() - 1,
             std::ostream_iterator<int>(os, ":"));
   os << cadence.back() << "]";
   return os.str();
 }
 
 }  // namespace media