Android Tango depth camera capture support.

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 86 matching lines @@
 }  // anonymous namespace
 
 // static
 bool VideoCaptureDeviceAndroid::RegisterVideoCaptureDevice(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 VideoCaptureDeviceAndroid::VideoCaptureDeviceAndroid(
     const VideoCaptureDeviceDescriptor& device_descriptor)
     : main_task_runner_(base::ThreadTaskRunnerHandle::Get()),
-      state_(kIdle),
-      got_first_frame_(false),
       device_descriptor_(device_descriptor),
       weak_ptr_factory_(this) {}
 
 VideoCaptureDeviceAndroid::~VideoCaptureDeviceAndroid() {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   StopAndDeAllocate();
 }
 
 bool VideoCaptureDeviceAndroid::Init() {
   int id;
@@ skipping 136 matching lines @@
   }
   DoSetPhotoOptions(std::move(settings), std::move(callback));
 }
 
 void VideoCaptureDeviceAndroid::OnFrameAvailable(
     JNIEnv* env,
     const JavaParamRef<jobject>& obj,
     const JavaParamRef<jbyteArray>& data,
     jint length,
     jint rotation) {
-  {
-    base::AutoLock lock(lock_);
-    if (state_ != kConfigured || !client_)
-      return;
-  }
-
+  if (!IsClientConfiguredForIncomingData())
+    return;
   jbyte* buffer = env->GetByteArrayElements(data, NULL);
   if (!buffer) {
     LOG(ERROR) << "VideoCaptureDeviceAndroid::OnFrameAvailable: "
                   "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_;
-      got_first_frame_ = true;
-
-      for (const auto& request : photo_requests_queue_)
-        main_task_runner_->PostTask(FROM_HERE, request);
-      photo_requests_queue_.clear();
-    }
-  }
+  ProcessFirstFrameAvailable(current_time);
 
   // 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,
-                                    capture_time);
+    SendIncomingDataToClient(reinterpret_cast<uint8_t*>(buffer), length,
+                             rotation, current_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,
                                                      jlong timestamp) {
-  {
-    base::AutoLock lock(lock_);
-    if (state_ != kConfigured || !client_)
-      return;
-  }
+  if (!IsClientConfiguredForIncomingData())
+    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_;
-      got_first_frame_ = true;
-
-      for (const auto& request : photo_requests_queue_)
-        main_task_runner_->PostTask(FROM_HERE, request);
-      photo_requests_queue_.clear();
-    }
-  }
+  ProcessFirstFrameAvailable(current_time);
 
   uint8_t* const y_src =
       reinterpret_cast<uint8_t*>(env->GetDirectBufferAddress(y_buffer));
   CHECK(y_src);
   uint8_t* const u_src =
       reinterpret_cast<uint8_t*>(env->GetDirectBufferAddress(u_buffer));
   CHECK(u_src);
   uint8_t* const v_src =
       reinterpret_cast<uint8_t*>(env->GetDirectBufferAddress(v_buffer));
   CHECK(v_src);
 
   const int y_plane_length = width * height;
   const int uv_plane_length = y_plane_length / 4;
   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) {
-    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,
-                                    capture_time);
+  if (AdvanceToNextFrameTime(current_time)) {
+    SendIncomingDataToClient(buffer.get(), buffer_length, rotation,
+                             current_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 30 matching lines @@
 void VideoCaptureDeviceAndroid::OnStarted(JNIEnv* env,
                                           const JavaParamRef<jobject>& obj) {
   if (client_)
     client_->OnStarted();
 }
 
 void VideoCaptureDeviceAndroid::ConfigureForTesting() {
   Java_VideoCapture_setTestMode(AttachCurrentThread(), j_capture_);
 }
 
+void VideoCaptureDeviceAndroid::ProcessFirstFrameAvailable(
+    base::TimeTicks current_time) {
+  base::AutoLock lock(lock_);
+  if (got_first_frame_)
+    return;
+  // Set aside one frame allowance for fluctuation.
+  expected_next_frame_time_ = current_time - frame_interval_;
+  got_first_frame_ = true;
+
+  for (const auto& request : photo_requests_queue_)
+    main_task_runner_->PostTask(FROM_HERE, request);
+  photo_requests_queue_.clear();
+}
+
+bool VideoCaptureDeviceAndroid::IsClientConfiguredForIncomingData() {
+  base::AutoLock lock(lock_);
+  return (state_ == kConfigured && client_);
+}
+
+bool VideoCaptureDeviceAndroid::AdvanceToNextFrameTime(
+    base::TimeTicks current_time) {
+  if (expected_next_frame_time_ > current_time)
+    return false;
+  expected_next_frame_time_ += frame_interval_;
+  return true;
+}
+
+void VideoCaptureDeviceAndroid::SendIncomingDataToClient(
+    const uint8_t* data,
+    int length,
+    int rotation,
+    base::TimeTicks reference_time,
+    base::TimeDelta timestamp) {
+  base::AutoLock lock(lock_);
+  if (!client_)
+    return;
+  client_->OnIncomingCapturedData(data, length, capture_format_, rotation,
+                                  reference_time, timestamp);
+}
+
 VideoPixelFormat VideoCaptureDeviceAndroid::GetColorspace() {
   JNIEnv* env = AttachCurrentThread();
   const int current_capture_colorspace =
       Java_VideoCapture_getColorspace(env, j_capture_);
   switch (current_capture_colorspace) {
     case ANDROID_IMAGE_FORMAT_YV12:
       return media::PIXEL_FORMAT_YV12;
     case ANDROID_IMAGE_FORMAT_YUV_420_888:
       return media::PIXEL_FORMAT_I420;
     case ANDROID_IMAGE_FORMAT_NV21:
@@ skipping 201 matching lines @@
       settings->has_exposure_compensation, exposure_compensation,
       static_cast<int>(white_balance_mode), iso,
       settings->has_red_eye_reduction, settings->red_eye_reduction,
       static_cast<int>(fill_light_mode), settings->has_torch, settings->torch,
       color_temperature);
 
   callback.Run(true);
 }
 
 }  // namespace media