ImageCapture: Queue up requests while device not ready

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"
 #include "base/android/jni_array.h"
 #include "base/android/jni_string.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/strings/string_number_conversions.h"
+#include "base/threading/thread_task_runner_handle.h"
 #include "jni/VideoCapture_jni.h"
 #include "media/capture/video/android/photo_capabilities.h"
 #include "media/capture/video/android/video_capture_device_factory_android.h"
 #include "third_party/libyuv/include/libyuv.h"
 
 using base::android::AttachCurrentThread;
 using base::android::CheckException;
 using base::android::GetClass;
 using base::android::MethodID;
 using base::android::JavaRef;
 using base::android::ScopedJavaLocalRef;
 
 namespace media {
 
 // static
 bool VideoCaptureDeviceAndroid::RegisterVideoCaptureDevice(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 VideoCaptureDeviceAndroid::VideoCaptureDeviceAndroid(
     const VideoCaptureDeviceDescriptor& device_descriptor)
-    : state_(kIdle),
+    : main_task_runner_(base::ThreadTaskRunnerHandle::Get()),
+      state_(kIdle),
       got_first_frame_(false),
-      device_descriptor_(device_descriptor) {}
+      device_descriptor_(device_descriptor),
+      weak_ptr_factory_(this) {}
 
 VideoCaptureDeviceAndroid::~VideoCaptureDeviceAndroid() {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
   StopAndDeAllocate();
 }
 
 bool VideoCaptureDeviceAndroid::Init() {
   int id;
   if (!base::StringToInt(device_descriptor_.device_id, &id))
     return false;
 
   j_capture_.Reset(VideoCaptureDeviceFactoryAndroid::createVideoCaptureAndroid(
       id, reinterpret_cast<intptr_t>(this)));
   return true;
 }
 
 void VideoCaptureDeviceAndroid::AllocateAndStart(
     const VideoCaptureParams& params,
     std::unique_ptr<Client> client) {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
   {
     base::AutoLock lock(lock_);
     if (state_ != kIdle)
       return;
     client_ = std::move(client);
     got_first_frame_ = false;
   }
 
   JNIEnv* env = AttachCurrentThread();
 
@@ skipping 28 matching lines @@
            << capture_format_.frame_rate << "fps";
 
   ret = Java_VideoCapture_startCapture(env, j_capture_.obj());
   if (!ret) {
     SetErrorState(FROM_HERE, "failed to start capture");
     return;
   }
 
   {
     base::AutoLock lock(lock_);
-    state_ = kCapturing;
+    state_ = kConfigured;
   }
 }
 
 void VideoCaptureDeviceAndroid::StopAndDeAllocate() {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
   {
     base::AutoLock lock(lock_);
-    if (state_ != kCapturing && state_ != kError)
+    if (state_ != kConfigured && state_ != kError)
       return;
   }
 
   JNIEnv* env = AttachCurrentThread();
 
   const jboolean ret = Java_VideoCapture_stopCapture(env, j_capture_.obj());
   if (!ret) {
     SetErrorState(FROM_HERE, "failed to stop capture");
     return;
   }
 
   {
     base::AutoLock lock(lock_);
     state_ = kIdle;
     client_.reset();
   }
 
   Java_VideoCapture_deallocate(env, j_capture_.obj());
 }
 
 void VideoCaptureDeviceAndroid::TakePhoto(TakePhotoCallback callback) {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
   {
     base::AutoLock lock(lock_);
-    if (state_ != kCapturing)
+    if (state_ != kConfigured)
       return;
+    if (!got_first_frame_) {  // We have to wait until we get the first frame.
+      photo_requests_queue_.push_back(
+          base::Bind(&VideoCaptureDeviceAndroid::DoTakePhoto,
+                     weak_ptr_factory_.GetWeakPtr(), base::Passed(&callback)));
+      return;
+    }
   }
-
-  JNIEnv* env = AttachCurrentThread();
-
-  // Make copy on the heap so we can pass the pointer through JNI.
-  std::unique_ptr<TakePhotoCallback> heap_callback(
-      new TakePhotoCallback(std::move(callback)));
-  const intptr_t callback_id = reinterpret_cast<intptr_t>(heap_callback.get());
-  if (!Java_VideoCapture_takePhoto(env, j_capture_.obj(), callback_id,
-                                   next_photo_resolution_.width(),
-                                   next_photo_resolution_.height()))
-    return;
-
-  {
-    base::AutoLock lock(photo_callbacks_lock_);
-    photo_callbacks_.push_back(std::move(heap_callback));
-  }
+  DoTakePhoto(std::move(callback));
 }
 
 void VideoCaptureDeviceAndroid::GetPhotoCapabilities(
     GetPhotoCapabilitiesCallback callback) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  JNIEnv* env = AttachCurrentThread();
-
-  PhotoCapabilities caps(
-      Java_VideoCapture_getPhotoCapabilities(env, j_capture_.obj()));
-
-  // TODO(mcasas): Manual member copying sucks, consider adding typemapping from
-  // PhotoCapabilities to mojom::PhotoCapabilitiesPtr, https://crbug.com/622002.
-  mojom::PhotoCapabilitiesPtr photo_capabilities =
-      mojom::PhotoCapabilities::New();
-  photo_capabilities->iso = mojom::Range::New();
-  photo_capabilities->iso->current = caps.getCurrentIso();
-  photo_capabilities->iso->max = caps.getMaxIso();
-  photo_capabilities->iso->min = caps.getMinIso();
-  photo_capabilities->height = mojom::Range::New();
-  photo_capabilities->height->current = caps.getCurrentHeight();
-  photo_capabilities->height->max = caps.getMaxHeight();
-  photo_capabilities->height->min = caps.getMinHeight();
-  photo_capabilities->width = mojom::Range::New();
-  photo_capabilities->width->current = caps.getCurrentWidth();
-  photo_capabilities->width->max = caps.getMaxWidth();
-  photo_capabilities->width->min = caps.getMinWidth();
-  photo_capabilities->zoom = mojom::Range::New();
-  photo_capabilities->zoom->current = caps.getCurrentZoom();
-  photo_capabilities->zoom->max = caps.getMaxZoom();
-  photo_capabilities->zoom->min = caps.getMinZoom();
-  photo_capabilities->focus_mode = caps.getAutoFocusInUse()
-                                       ? mojom::FocusMode::AUTO
-                                       : mojom::FocusMode::MANUAL;
-  callback.Run(std::move(photo_capabilities));
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
+  {
+    base::AutoLock lock(lock_);
+    if (state_ != kConfigured)
+      return;
+    if (!got_first_frame_) {  // We have to wait until we get the first frame.
+      photo_requests_queue_.push_back(
+          base::Bind(&VideoCaptureDeviceAndroid::DoGetPhotoCapabilities,
+                     weak_ptr_factory_.GetWeakPtr(), base::Passed(&callback)));
+      return;
+    }
+  }
+  DoGetPhotoCapabilities(std::move(callback));
 }
 
 void VideoCaptureDeviceAndroid::SetPhotoOptions(
     mojom::PhotoSettingsPtr settings,
     SetPhotoOptionsCallback callback) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  JNIEnv* env = AttachCurrentThread();
-  // |width| and/or |height| are kept for the next TakePhoto()s.
-  if (settings->has_width || settings->has_height)
-    next_photo_resolution_.SetSize(0, 0);
-  if (settings->has_width) {
-    next_photo_resolution_.set_width(
-        base::saturated_cast<int>(settings->width));
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
+  {
+    base::AutoLock lock(lock_);
+    if (state_ != kConfigured)
+      return;
+    if (!got_first_frame_) {  // We have to wait until we get the first frame.
+      photo_requests_queue_.push_back(
+          base::Bind(&VideoCaptureDeviceAndroid::DoSetPhotoOptions,
+                     weak_ptr_factory_.GetWeakPtr(), base::Passed(&settings),
+                     base::Passed(&callback)));
+      return;
+    }
   }
-  if (settings->has_height) {
-    next_photo_resolution_.set_height(
-        base::saturated_cast<int>(settings->height));
-  }
-
-  if (settings->has_zoom)
-    Java_VideoCapture_setZoom(env, j_capture_.obj(), settings->zoom);
-  callback.Run(true);
+  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_ != kCapturing || !client_)
+    if (state_ != kConfigured || !client_)
       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();
-  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;
+  {
+    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);

[emircan, 2016/08/03 21:55:54]

photo_requests_queue_.clear();

[mcasas, 2016/08/03 22:19:36]

Done.

+    }
   }
 
   // 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_)
@@ skipping 12 matching lines @@
                                                      jint y_stride,
                                                      jobject u_buffer,
                                                      jobject v_buffer,
                                                      jint uv_row_stride,
                                                      jint uv_pixel_stride,
                                                      jint width,
                                                      jint height,
                                                      jint rotation) {
   {
     base::AutoLock lock(lock_);
-    if (state_ != kCapturing || !client_)
+    if (state_ != kConfigured || !client_)
       return;
   }
 
   const base::TimeTicks current_time = base::TimeTicks::Now();
-  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;
+  {
+    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));
   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));
@@ skipping 84 matching lines @@
     const std::string& reason) {
   {
     base::AutoLock lock(lock_);
     state_ = kError;
     if (!client_)
       return;
     client_->OnError(from_here, reason);
   }
 }
 
+void VideoCaptureDeviceAndroid::DoTakePhoto(TakePhotoCallback callback) {
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
+#if DCHECK_IS_ON()
+  {
+    base::AutoLock lock(lock_);
+    DCHECK_EQ(kConfigured, state_);
+    DCHECK(got_first_frame_);
+  }
+#endif
+  JNIEnv* env = AttachCurrentThread();
+
+  // Make copy on the heap so we can pass the pointer through JNI.
+  std::unique_ptr<TakePhotoCallback> heap_callback(
+      new TakePhotoCallback(std::move(callback)));
+  const intptr_t callback_id = reinterpret_cast<intptr_t>(heap_callback.get());
+  if (!Java_VideoCapture_takePhoto(env, j_capture_.obj(), callback_id,
+                                   next_photo_resolution_.width(),
+                                   next_photo_resolution_.height()))
+    return;
+
+  {
+    base::AutoLock lock(photo_callbacks_lock_);
+    photo_callbacks_.push_back(std::move(heap_callback));
+  }
+}
+
+void VideoCaptureDeviceAndroid::DoGetPhotoCapabilities(
+    GetPhotoCapabilitiesCallback callback) {
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
+#if DCHECK_IS_ON()
+  {
+    base::AutoLock lock(lock_);
+    DCHECK_EQ(kConfigured, state_);
+    DCHECK(got_first_frame_);
+  }
+#endif
+  JNIEnv* env = AttachCurrentThread();
+
+  PhotoCapabilities caps(
+      Java_VideoCapture_getPhotoCapabilities(env, j_capture_.obj()));
+
+  // TODO(mcasas): Manual member copying sucks, consider adding typemapping from
+  // PhotoCapabilities to mojom::PhotoCapabilitiesPtr, https://crbug.com/622002.
+  mojom::PhotoCapabilitiesPtr photo_capabilities =
+      mojom::PhotoCapabilities::New();
+  photo_capabilities->iso = mojom::Range::New();
+  photo_capabilities->iso->current = caps.getCurrentIso();
+  photo_capabilities->iso->max = caps.getMaxIso();
+  photo_capabilities->iso->min = caps.getMinIso();
+  photo_capabilities->height = mojom::Range::New();
+  photo_capabilities->height->current = caps.getCurrentHeight();
+  photo_capabilities->height->max = caps.getMaxHeight();
+  photo_capabilities->height->min = caps.getMinHeight();
+  photo_capabilities->width = mojom::Range::New();
+  photo_capabilities->width->current = caps.getCurrentWidth();
+  photo_capabilities->width->max = caps.getMaxWidth();
+  photo_capabilities->width->min = caps.getMinWidth();
+  photo_capabilities->zoom = mojom::Range::New();
+  photo_capabilities->zoom->current = caps.getCurrentZoom();
+  photo_capabilities->zoom->max = caps.getMaxZoom();
+  photo_capabilities->zoom->min = caps.getMinZoom();
+  photo_capabilities->focus_mode = caps.getAutoFocusInUse()
+                                       ? mojom::FocusMode::AUTO
+                                       : mojom::FocusMode::MANUAL;
+  callback.Run(std::move(photo_capabilities));
+}
+
+void VideoCaptureDeviceAndroid::DoSetPhotoOptions(
+    mojom::PhotoSettingsPtr settings,
+    SetPhotoOptionsCallback callback) {
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
+#if DCHECK_IS_ON()
+  {
+    base::AutoLock lock(lock_);
+    DCHECK_EQ(kConfigured, state_);
+    DCHECK(got_first_frame_);
+  }
+#endif
+  JNIEnv* env = AttachCurrentThread();
+
+  // |width| and/or |height| are kept for the next TakePhoto()s.
+  if (settings->has_width || settings->has_height)
+    next_photo_resolution_.SetSize(0, 0);
+  if (settings->has_width) {
+    next_photo_resolution_.set_width(
+        base::saturated_cast<int>(settings->width));
+  }
+  if (settings->has_height) {
+    next_photo_resolution_.set_height(
+        base::saturated_cast<int>(settings->height));
+  }
+
+  if (settings->has_zoom)
+    Java_VideoCapture_setZoom(env, j_capture_.obj(), settings->zoom);
+
+  callback.Run(true);
+}
+
 }  // namespace media