Decouple capture timestamp and reference time

media/capture/video/win/video_capture_device_win.cc

 // Copyright (c) 2012 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/capture/video/win/video_capture_device_win.h"
 
 #include <ks.h>
 #include <ksmedia.h>
 
 #include <algorithm>
 #include <list>
 #include <utility>
 
 #include "base/macros.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/win/scoped_co_mem.h"
 #include "base/win/scoped_variant.h"
+#include "media/base/timestamp_constants.h"
 
 using base::win::ScopedCoMem;
 using base::win::ScopedComPtr;
 using base::win::ScopedVariant;
 
 namespace media {
 
 // Check if a Pin matches a category.
 bool PinMatchesCategory(IPin* pin, REFGUID category) {
   DCHECK(pin);
@@ skipping 416 matching lines @@
   graph_builder_->Disconnect(output_capture_pin_.get());
   graph_builder_->Disconnect(input_sink_pin_.get());
 
   client_.reset();
   state_ = kIdle;
 }
 
 // Implements SinkFilterObserver::SinkFilterObserver.
 void VideoCaptureDeviceWin::FrameReceived(const uint8_t* buffer,
                                           int length,
-                                          base::TimeTicks timestamp) {
+                                          base::TimeDelta timestamp) {
+  if (first_ref_time_.is_null())
+    first_ref_time_ = base::TimeTicks::Now();
+  if (timestamp == media::kNoTimestamp())

[miu, 2016/05/18 22:35:40]

Please add a comment that sometimes the platform does not provide a timestamp
from the video capture hardware, and so this code is a workaround to derive a
timestamp from the system clock.

BTW--Do we know why/when the platform would not provide a timestamp? If so, it's
probably worth documenting that in a comment here or in sink_input_pin_win.cc.

[qiangchen, 2016/05/20 17:55:14]

In my testing, I did not see a case that timestamp is not provided by OS API,
but that API do have a return value to indicate whether a timestamp is provided
or not. So we need to handle it in case a timestamp is not provided. 

I think the API's implementation could differ from camera to camera, and thus it
is safe we do have a fall back solution here.

+    timestamp = base::TimeTicks::Now() - first_ref_time_;
   client_->OnIncomingCapturedData(buffer, length, capture_format_, 0,
-                                  timestamp);
+                                  base::TimeTicks::Now(), timestamp);
 }
 
 bool VideoCaptureDeviceWin::CreateCapabilityMap() {
   DCHECK(thread_checker_.CalledOnValidThread());
   ScopedComPtr<IAMStreamConfig> stream_config;
   HRESULT hr = output_capture_pin_.QueryInterface(stream_config.Receive());
   if (FAILED(hr)) {
     DPLOG(ERROR) << "Failed to get IAMStreamConfig interface from "
                     "capture device: " << logging::SystemErrorCodeToString(hr);
     return false;
@@ skipping 108 matching lines @@
 }
 
 void VideoCaptureDeviceWin::SetErrorState(
     const tracked_objects::Location& from_here,
     const std::string& reason) {
   DCHECK(thread_checker_.CalledOnValidThread());
   state_ = kError;
   client_->OnError(from_here, reason);
 }
 }  // namespace media