Android video capture: only use reference time for outbound timestamp.

media/capture/video/android/video_capture_device_android.cc

 // Copyright (c) 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/capture/video/android/video_capture_device_android.h"
 
 #include <stdint.h>
 #include <utility>
 
 #include "base/android/jni_android.h"
@@ skipping 234 matching lines @@
                   "failed to GetByteArrayElements";
     return;
   }
 
   const base::TimeTicks current_time = base::TimeTicks::Now();
   {
     base::AutoLock lock(lock_);
     if (!got_first_frame_) {
       // Set aside one frame allowance for fluctuation.
       expected_next_frame_time_ = current_time - frame_interval_;
-      first_ref_time_ = current_time;
       got_first_frame_ = true;
 
       for (const auto& request : photo_requests_queue_)
         main_task_runner_->PostTask(FROM_HERE, request);
       photo_requests_queue_.clear();
     }
   }
 
   // Deliver the frame when it doesn't arrive too early.
   if (expected_next_frame_time_ <= current_time) {
+    // Using |expected_next_frame_time_| to estimate a proper capture timestamp
+    // since android.hardware.Camera API doesn't expose a better timestamp.
+    const base::TimeDelta capture_time =
+        expected_next_frame_time_ - base::TimeTicks();
+
     expected_next_frame_time_ += frame_interval_;
 
     // TODO(qiangchen): Investigate how to get raw timestamp for Android,
     // rather than using reference time to calculate timestamp.
     base::AutoLock lock(lock_);
     if (!client_)
       return;
     client_->OnIncomingCapturedData(reinterpret_cast<uint8_t*>(buffer), length,
                                     capture_format_, rotation, current_time,
-                                    current_time - first_ref_time_);
+                                    capture_time);
   }
 
   env->ReleaseByteArrayElements(data, buffer, JNI_ABORT);
 }
 
 void VideoCaptureDeviceAndroid::OnI420FrameAvailable(JNIEnv* env,
                                                      jobject obj,
                                                      jobject y_buffer,
                                                      jint y_stride,
                                                      jobject u_buffer,
                                                      jobject v_buffer,
                                                      jint uv_row_stride,
                                                      jint uv_pixel_stride,
                                                      jint width,
                                                      jint height,
-                                                     jint rotation) {
+                                                     jint rotation,
+                                                     jlong timestamp) {
   {
     base::AutoLock lock(lock_);
     if (state_ != kConfigured || !client_)
       return;
   }
+  const int64_t absolute_micro =
+      timestamp / base::Time::kNanosecondsPerMicrosecond;
+  const base::TimeDelta capture_time =
+      base::TimeDelta::FromMicroseconds(absolute_micro);
 
   const base::TimeTicks current_time = base::TimeTicks::Now();
   {
     base::AutoLock lock(lock_);
     if (!got_first_frame_) {
       // Set aside one frame allowance for fluctuation.
       expected_next_frame_time_ = current_time - frame_interval_;
-      first_ref_time_ = current_time;
       got_first_frame_ = true;
 
       for (const auto& request : photo_requests_queue_)
         main_task_runner_->PostTask(FROM_HERE, request);
       photo_requests_queue_.clear();
     }
   }
 
   uint8_t* const y_src =
       reinterpret_cast<uint8_t*>(env->GetDirectBufferAddress(y_buffer));
@@ skipping 20 matching lines @@
   if (expected_next_frame_time_ <= current_time) {
     expected_next_frame_time_ += frame_interval_;
 
     // TODO(qiangchen): Investigate how to get raw timestamp for Android,
     // rather than using reference time to calculate timestamp.
     base::AutoLock lock(lock_);
     if (!client_)
       return;
     client_->OnIncomingCapturedData(buffer.get(), buffer_length,
                                     capture_format_, rotation, current_time,
-                                    current_time - first_ref_time_);
+                                    capture_time);
   }
 }
 
 void VideoCaptureDeviceAndroid::OnError(JNIEnv* env,
                                         const JavaParamRef<jobject>& obj,
                                         const JavaParamRef<jstring>& message) {
   SetErrorState(FROM_HERE,
                 base::android::ConvertJavaStringToUTF8(env, message));
 }
 
@@ skipping 169 matching lines @@
 
   Java_VideoCapture_setPhotoOptions(
       env, j_capture_, zoom, static_cast<int>(focus_mode),
       static_cast<int>(exposure_mode), width, height, points_of_interest,
       settings->has_exposure_compensation, exposure_compensation);
 
   callback.Run(true);
 }
 
 }  // namespace media