Mac Video Capture: Sending the timestamps provided by the driver to the capture pipeline

media/capture/video/mac/video_capture_device_mac.mm

 // 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/mac/video_capture_device_mac.h"
 
 #include <IOKit/IOCFPlugIn.h>
 #include <IOKit/usb/IOUSBLib.h>
 #include <IOKit/usb/USBSpec.h>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/mac/scoped_ioobject.h"
 #include "base/mac/scoped_ioplugininterface.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #import "media/base/mac/avfoundation_glue.h"
+#include "media/base/timestamp_constants.h"
 #import "media/capture/video/mac/platform_video_capturing_mac.h"
 #import "media/capture/video/mac/video_capture_device_avfoundation_mac.h"
 #import "media/capture/video/mac/video_capture_device_qtkit_mac.h"
 #include "ui/gfx/geometry/size.h"
 
 @implementation DeviceNameAndTransportType
 
 - (id)initWithName:(NSString*)deviceName transportType:(int32_t)transportType {
   if (self = [super init]) {
     deviceName_.reset([deviceName copy]);
@@ skipping 306 matching lines @@
 
   return id_vendor + ":" + id_product;
 }
 
 VideoCaptureDeviceMac::VideoCaptureDeviceMac(const Name& device_name)
     : device_name_(device_name),
       tried_to_square_pixels_(false),
       task_runner_(base::ThreadTaskRunnerHandle::Get()),
       state_(kNotInitialized),
       capture_device_(nil),
+      first_timestamp_(media::kNoTimestamp()),
       weak_factory_(this) {
   // Avoid reconfiguring AVFoundation or blacklisted devices.
   final_resolution_selected_ = AVFoundationGlue::IsAVFoundationSupported() ||
                                device_name.is_blacklisted();
 }
 
 VideoCaptureDeviceMac::~VideoCaptureDeviceMac() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   [capture_device_ release];
 }
@@ skipping 100 matching lines @@
     return false;
 
   state_ = kIdle;
   return true;
 }
 
 void VideoCaptureDeviceMac::ReceiveFrame(const uint8* video_frame,
                                          int video_frame_length,
                                          const VideoCaptureFormat& frame_format,
                                          int aspect_numerator,
-                                         int aspect_denominator) {
+                                         int aspect_denominator,
+                                         base::TimeDelta timestamp) {
   // This method is safe to call from a device capture thread, i.e. any thread
   // controlled by QTKit/AVFoundation.
   if (!final_resolution_selected_) {
     DCHECK(!AVFoundationGlue::IsAVFoundationSupported());
     if (capture_format_.frame_size.width() > kVGA.width ||
         capture_format_.frame_size.height() > kVGA.height) {
       // We are requesting HD.  Make sure that the picture is good, otherwise
       // drop down to VGA.
       bool change_to_vga = false;
       if (frame_format.frame_size.width() <
@@ skipping 50 matching lines @@
   // camera, and that is fine: http://crbug.com/353620. In AVFoundation, this
   // should not happen, it should resize internally.
   if (!AVFoundationGlue::IsAVFoundationSupported()) {
     capture_format_.frame_size = frame_format.frame_size;
   } else if (capture_format_.frame_size != frame_format.frame_size) {
     ReceiveError("Captured resolution " + frame_format.frame_size.ToString() +
                  ", and expected " + capture_format_.frame_size.ToString());
     return;
   }
 
+  base::TimeTicks aligned_timestamp;
+  if (timestamp == media::kNoTimestamp()) {
+    aligned_timestamp = base::TimeTicks::Now();
+  } else {
+    if (first_timestamp_ == media::kNoTimestamp()) {
+      first_timestamp_ = timestamp;
+      first_aligned_timestamp_ = base::TimeTicks::Now();
+    }
+    aligned_timestamp = first_aligned_timestamp_ + timestamp - first_timestamp_;
+  }
   client_->OnIncomingCapturedData(video_frame, video_frame_length, frame_format,
-                                  0, base::TimeTicks::Now());
+                                  0, aligned_timestamp);
 }
 
 void VideoCaptureDeviceMac::ReceiveError(const std::string& reason) {
   task_runner_->PostTask(FROM_HERE,
                          base::Bind(&VideoCaptureDeviceMac::SetErrorState,
                                     weak_factory_.GetWeakPtr(), reason));
 }
 
 void VideoCaptureDeviceMac::SetErrorState(const std::string& reason) {
   DCHECK(task_runner_->BelongsToCurrentThread());
@@ skipping 11 matching lines @@
   if (![capture_device_ setCaptureHeight:capture_format_.frame_size.height()
                                    width:capture_format_.frame_size.width()
                                frameRate:capture_format_.frame_rate]) {
     ReceiveError("Could not configure capture device.");
     return false;
   }
   return true;
 }
 
 }  // namespace media