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

media/base/moving_average.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/base/moving_average.h"
 
 #include <algorithm>
 
 namespace media {
 
 MovingAverage::MovingAverage(size_t depth)
-    : depth_(depth), count_(0), samples_(depth_) {
-}
+    : depth_(depth), count_(0), samples_(depth_), square_sum_ms_(0) {}
 
 MovingAverage::~MovingAverage() {
 }
 
 void MovingAverage::AddSample(base::TimeDelta sample) {
   // |samples_| is zero-initialized, so |oldest| is also zero before |count_|
   // exceeds |depth_|.
   base::TimeDelta& oldest = samples_[count_++ % depth_];
   total_ += sample - oldest;
+  square_sum_ms_ += sample.InMillisecondsF() * sample.InMillisecondsF() -

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

Why work in float here? Keep these as timedelta*timedelta - timedelta*timedelta

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

I do not think there is a multiplication defined in that way.

And it is not natural to define one, as the result's unit is time square, not
time.

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

They are defined, which is why I suggested it :) It'll include some checked
numeric code to prevent overflows as well. If you don't want to store as
TimeDelta storing as int64_t is fine with me. I.e., square_sum_us_ =
(sample*sample - oldest*oldest).InMicroseconds()

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

There is multiplication defined between numeric (int, float) and TimeDelta,
there is not a multiplication defined between two TimeDeltas.

+                    oldest.InMillisecondsF() * oldest.InMillisecondsF();
   oldest = sample;
 }
 
 base::TimeDelta MovingAverage::Average() const {
   DCHECK_GT(count_, 0u);
 
   // TODO(dalecurtis): Consider limiting |depth| to powers of two so that we can
   // replace the integer divide with a bit shift operation.
 
   return total_ / std::min(static_cast<uint64_t>(depth_), count_);
 }
 
+base::TimeDelta MovingAverage::Deviation() const {
+  DCHECK_GT(count_, 0u);
+
+  const int size = std::min(static_cast<uint64_t>(depth_), count_);
+  const double average_ms = Average().InMillisecondsF();
+  double sqr_deviation_ms = square_sum_ms_ / size - average_ms * average_ms;

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

cast size to double and keep the rest as TimeDelta and you won't lose any
precision here by making everything TimeDelta.

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

Perhaps, we can use int64 to store the square_sum_us, and then no precision lost
at all.

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

sgtm

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

Done.

+  if (sqr_deviation_ms < 0)
+    sqr_deviation_ms = 0;
+
+  return base::TimeDelta::FromMillisecondsD(sqrt(sqr_deviation_ms));
+}
+
 void MovingAverage::Reset() {
   count_ = 0;
   total_ = base::TimeDelta();
+  square_sum_ms_ = 0;
   std::fill(samples_.begin(), samples_.end(), base::TimeDelta());
 }
 
 }  // namespace media