Decouple capture timestamp and reference time

media/capture/video/mac/video_capture_device_decklink_mac.mm

 // Copyright 2014 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/mac/video_capture_device_decklink_mac.h"
 
 #include <utility>
 
 #include "base/logging.h"
 #include "base/macros.h"
@@ skipping 74 matching lines @@
   // Weak reference to the captured frames client, used also for error messages
   // and logging. Initialized on construction and used until cleared by calling
   // ResetVideoCaptureDeviceReference().
   media::VideoCaptureDeviceDeckLinkMac* frame_receiver_;
 
   // This is used to control the video capturing device input interface.
   ScopedDeckLinkPtr<IDeckLinkInput> decklink_input_;
   // |decklink_| represents a physical device attached to the host.
   ScopedDeckLinkPtr<IDeckLink> decklink_;
 
+  base::TimeTicks first_ref_time_;
+
   // Checks for Device (a.k.a. Audio) thread.
   base::ThreadChecker thread_checker_;
 
   friend class scoped_refptr<DeckLinkCaptureDelegate>;
   friend class base::RefCountedThreadSafe<DeckLinkCaptureDelegate>;
 
   ~DeckLinkCaptureDelegate() override;
 
   DISALLOW_COPY_AND_ASSIGN(DeckLinkCaptureDelegate);
 };
@@ skipping 144 matching lines @@
       break;
     default:
       SendErrorString(FROM_HERE, "Unsupported pixel format");
       break;
   }
 
   const media::VideoCaptureFormat capture_format(
       gfx::Size(video_frame->GetWidth(), video_frame->GetHeight()),
       0.0f,  // Frame rate is not needed for captured data callback.
       pixel_format);
+  base::TimeTicks now = base::TimeTicks::Now();
+  if (first_ref_time_.is_null())
+    first_ref_time_ = now;
   base::AutoLock lock(lock_);
   if (frame_receiver_) {
+    const BMDTimeScale micros_time_scale = base::Time::kMicrosecondsPerSecond;
+    BMDTimeValue frame_time;
+    BMDTimeValue frame_duration;
+    base::TimeDelta timestamp;
+    if (SUCCEEDED(video_frame->GetStreamTime(&frame_time, &frame_duration,
+                                             micros_time_scale))) {
+      timestamp = base::TimeDelta::FromMicroseconds(frame_time);
+    } else {
+      timestamp = now - first_ref_time_;
+    }
     frame_receiver_->OnIncomingCapturedData(
         video_data, video_frame->GetRowBytes() * video_frame->GetHeight(),
         capture_format,
         0,  // Rotation.
-        base::TimeTicks::Now());
+        now, timestamp);
   }
   return S_OK;
 }
 
 HRESULT DeckLinkCaptureDelegate::QueryInterface(REFIID iid, void** ppv) {
   DCHECK(thread_checker_.CalledOnValidThread());
   CFUUIDBytes iunknown = CFUUIDGetUUIDBytes(IUnknownUUID);
   if (memcmp(&iid, &iunknown, sizeof(REFIID)) == 0 ||
       memcmp(&iid, &IID_IDeckLinkInputCallback, sizeof(REFIID)) == 0) {
     *ppv = static_cast<IDeckLinkInputCallback*>(this);
@@ skipping 168 matching lines @@
 
 VideoCaptureDeviceDeckLinkMac::~VideoCaptureDeviceDeckLinkMac() {
   decklink_capture_delegate_->ResetVideoCaptureDeviceReference();
 }
 
 void VideoCaptureDeviceDeckLinkMac::OnIncomingCapturedData(
     const uint8_t* data,
     size_t length,
     const VideoCaptureFormat& frame_format,
     int rotation,  // Clockwise.
-    base::TimeTicks timestamp) {
+    base::TimeTicks reference_time,
+    base::TimeDelta timestamp) {
   base::AutoLock lock(lock_);
   if (client_) {
     client_->OnIncomingCapturedData(data, length, frame_format, rotation,
-                                    timestamp);
+                                    reference_time, timestamp);
   }
 }
 
 void VideoCaptureDeviceDeckLinkMac::SendErrorString(
     const tracked_objects::Location& from_here,
     const std::string& reason) {
   DCHECK(thread_checker_.CalledOnValidThread());
   base::AutoLock lock(lock_);
   if (client_)
     client_->OnError(from_here, reason);
@@ skipping 14 matching lines @@
   if (decklink_capture_delegate_.get())
     decklink_capture_delegate_->AllocateAndStart(params);
 }
 
 void VideoCaptureDeviceDeckLinkMac::StopAndDeAllocate() {
   if (decklink_capture_delegate_.get())
     decklink_capture_delegate_->StopAndDeAllocate();
 }
 
 }  // namespace media