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 196 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) {
     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_);
+                                    base::TimeDelta());

[miu, 2016/08/31 21:09:16]

Please plumb-in timestamp here too.

[braveyao, 2016/08/31 23:01:28]

No capture timestamp available here. Maybe better to keep the previous way.

   }
 
   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 uint64_t absolute_micro =

[miu, 2016/08/31 21:09:16]

nit: Should be int64_t since both operands are signed integers.

[braveyao, 2016/08/31 23:01:28]

Done.

+      timestamp / base::Time::kNanosecondsPerMicrosecond;
+  const base::TimeDelta start_time =

[miu, 2016/08/31 21:09:16]

naming nit: How about |capture_time|? According to the Android API docs, the
timestamps are all relative and monotonically increasing, and determined by the
source capturer. So, basically they are exactly the media timestmaps
OnIncomingCapturedData() expects.

[braveyao, 2016/08/31 23:01:28]

Done.

+      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 10 matching lines @@
   const int buffer_length = y_plane_length + uv_plane_length * 2;
   std::unique_ptr<uint8_t> buffer(new uint8_t[buffer_length]);
 
   libyuv::Android420ToI420(y_src, y_stride, u_src, uv_row_stride, v_src,
                            uv_row_stride, uv_pixel_stride, buffer.get(), width,
                            buffer.get() + y_plane_length, width / 2,
                            buffer.get() + y_plane_length + uv_plane_length,
                            width / 2, width, height);
 
   // Deliver the frame when it doesn't arrive too early.
   if (expected_next_frame_time_ <= current_time) {

[miu, 2016/08/31 21:09:16]

What happened to the code from the "part I" patch that used the
VideoCaptureOracle to do proper throttling?

[braveyao, 2016/08/31 23:01:28]

Can't get you. 
My 'part I' patch is for content capture. It didn't touch this camera capture
path. Also there is no such a CaptureOracle to do throttling yet.

[miu, 2016/09/02 21:49:15]

Acknowledged. My misunderstanding. ;-)

     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_);
+                                    start_time);
   }
 }
 
 void VideoCaptureDeviceAndroid::OnError(JNIEnv* env,
                                         const JavaParamRef<jobject>& obj,
                                         const JavaParamRef<jstring>& message) {
   SetErrorState(FROM_HERE,
                 base::android::ConvertJavaStringToUTF8(env, message));
 }
 
@@ skipping 168 matching lines @@
     }
   }
 
   Java_VideoCapture_setPhotoOptions(
       env, j_capture_, zoom, static_cast<int>(focus_mode), width, height);
 
   callback.Run(true);
 }
 
 }  // namespace media