FileVideoCaptureDevice: Regulate framerate without drifting

media/video/capture/file_video_capture_device.cc

 // Copyright 2013 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/video/capture/file_video_capture_device.h"
 
 
 #include "base/bind.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
@@ skipping 192 matching lines @@
                  base::Unretained(this)));
 }
 
 void FileVideoCaptureDevice::OnStopAndDeAllocate() {
   DCHECK_EQ(capture_thread_.message_loop(), base::MessageLoop::current());
   file_.Close();
   client_.reset();
   current_byte_index_ = 0;
   first_frame_byte_index_ = 0;
   frame_size_ = 0;
+  next_frame_time_ = base::TimeTicks();
   video_frame_.reset();
 }
 
 void FileVideoCaptureDevice::OnCaptureTask() {
   DCHECK_EQ(capture_thread_.message_loop(), base::MessageLoop::current());
   if (!client_)
     return;
-  const base::TimeTicks timestamp_before_reading = base::TimeTicks::Now();
   int result = file_.Read(current_byte_index_,
                           reinterpret_cast<char*>(video_frame_.get()),
                           frame_size_);
 
   // If we passed EOF to base::File, it will return 0 read characters. In that
   // case, reset the pointer and read again.
   if (result != frame_size_) {
     CHECK_EQ(result, 0);
     current_byte_index_ = first_frame_byte_index_;
     CHECK_EQ(file_.Read(current_byte_index_,
                         reinterpret_cast<char*>(video_frame_.get()),
                         frame_size_),
              frame_size_);
   } else {
     current_byte_index_ += frame_size_ + kY4MSimpleFrameDelimiterSize;
   }
 
   // Give the captured frame to the client.
+  const base::TimeTicks current_time = base::TimeTicks::Now();
   client_->OnIncomingCapturedData(video_frame_.get(),
                                   frame_size_,
                                   capture_format_,
                                   0,
-                                  base::TimeTicks::Now());
+                                  current_time);
   // Reschedule next CaptureTask.
   const base::TimeDelta frame_interval =
       base::TimeDelta::FromMicroseconds(1E6 / capture_format_.frame_rate);
-  base::TimeDelta next_on_capture_timedelta = frame_interval -
-      (base::TimeTicks::Now() - timestamp_before_reading);
-  if (next_on_capture_timedelta.InMilliseconds() < 0) {
-    DLOG(WARNING) << "Frame reading took longer than the frame interval.";
-    next_on_capture_timedelta = frame_interval;
+  if (next_frame_time_.is_null()) {
+    next_frame_time_ = current_time + frame_interval;
+  } else {
+    next_frame_time_ += frame_interval;
   }
   base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&FileVideoCaptureDevice::OnCaptureTask,
                  base::Unretained(this)),
-      next_on_capture_timedelta);
+      next_frame_time_ - current_time);
 }
 
 }  // namespace media