Android Tango depth camera capture support.

media/capture/video/video_capture_device_unittest.cc

 // 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/video_capture_device.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
@@ skipping 273 matching lines @@
     last_format_ = format;
     if (run_loop_)
       run_loop_->QuitClosure().Run();
   }
 
   void WaitForCapturedFrame() {
     run_loop_.reset(new base::RunLoop());
     run_loop_->Run();
   }
 
-  bool FindUsableDevices() {
+  std::unique_ptr<VideoCaptureDeviceDescriptor> FindUsableDeviceDescriptor() {
     video_capture_device_factory_->GetDeviceDescriptors(
         device_descriptors_.get());
 
 #if defined(OS_ANDROID)
-    // Android deprecated/legacy devices capture on a single thread, which is
-    // occupied by the tests, so nothing gets actually delivered.
+    // Android deprecated/legacy devices and Tango cameras capture on a single
+    // thread, which is occupied by the tests, so nothing gets actually
+    // delivered.
     // TODO(mcasas): use those devices' test mode to deliver frames in a
     // background thread, https://crbug.com/626857
     for (const auto& descriptor : *device_descriptors_) {
-      if (VideoCaptureDeviceFactoryAndroid::IsLegacyOrDeprecatedDevice(
-              descriptor.device_id)) {
-        return false;
+      if (!VideoCaptureDeviceFactoryAndroid::IsLegacyOrDeprecatedDevice(
+              descriptor.device_id) &&
+          descriptor.capture_api != VideoCaptureApi::ANDROID_TANGO) {
+        LOG(INFO) << "Using camera " << descriptor.display_name << " ("
+                  << descriptor.model_id << ")";
+        return std::unique_ptr<VideoCaptureDeviceDescriptor>(
+            new VideoCaptureDeviceDescriptor(descriptor));
       }
     }
+    LOG(WARNING) << "No usable camera found";
+    return nullptr;
 #endif
 
-    if (device_descriptors_->empty())
+    if (device_descriptors_->empty()) {
       LOG(WARNING) << "No camera found";
-    else {
-      LOG(INFO) << "Using camera " << device_descriptors_->front().display_name
-                << " (" << device_descriptors_->front().model_id << ")";
+      return nullptr;
     }
-
-    return !device_descriptors_->empty();
+    LOG(INFO) << "Using camera " << device_descriptors_->front().display_name
+              << " (" << device_descriptors_->front().model_id << ")";
+    return std::unique_ptr<VideoCaptureDeviceDescriptor>(
+        new VideoCaptureDeviceDescriptor(device_descriptors_->front()));
   }
 
   const VideoCaptureFormat& last_format() const { return last_format_; }
 
   std::unique_ptr<VideoCaptureDeviceDescriptor>
   GetFirstDeviceDescriptorSupportingPixelFormat(
       const VideoPixelFormat& pixel_format) {
-    if (!FindUsableDevices())
+    if (!FindUsableDeviceDescriptor())
       return nullptr;
 
     for (const auto& descriptor : *device_descriptors_) {
       VideoCaptureFormats supported_formats;
       video_capture_device_factory_->GetSupportedFormats(descriptor,
                                                          &supported_formats);
       for (const auto& formats_iterator : supported_formats) {
         if (formats_iterator.pixel_format == pixel_format) {
           return std::unique_ptr<VideoCaptureDeviceDescriptor>(
               new VideoCaptureDeviceDescriptor(descriptor));
@@ skipping 66 matching lines @@
   capture_params.requested_format.frame_size.SetSize(640, 480);
   capture_params.requested_format.frame_rate = 30;
   capture_params.requested_format.pixel_format = PIXEL_FORMAT_I420;
   device->AllocateAndStart(capture_params, std::move(video_capture_client_));
   device->StopAndDeAllocate();
 #endif
 }
 
 // Allocates the first enumerated device, and expects a frame.
 TEST_P(VideoCaptureDeviceTest, CaptureWithSize) {
-  if (!FindUsableDevices())
+  auto descriptor = FindUsableDeviceDescriptor();
+  if (!descriptor)
     return;
 
   const gfx::Size& size = GetParam();
-  if (!IsCaptureSizeSupported(device_descriptors_->front(), size))
+  if (!IsCaptureSizeSupported(*descriptor, size))
     return;
   const int width = size.width();
   const int height = size.height();
 
   std::unique_ptr<VideoCaptureDevice> device(
       video_capture_device_factory_->CreateDevice(
           device_descriptors_->front()));
   ASSERT_TRUE(device);
 
   EXPECT_CALL(*video_capture_client_, OnError(_, _)).Times(0);
@@ skipping 16 matching lines @@
 
 const gfx::Size kCaptureSizes[] = {gfx::Size(640, 480), gfx::Size(1280, 720)};
 
 INSTANTIATE_TEST_CASE_P(VideoCaptureDeviceTests,
                         VideoCaptureDeviceTest,
                         testing::ValuesIn(kCaptureSizes));
 
 // Allocates a device with an uncommon resolution and verifies frames are
 // captured in a close, much more typical one.
 TEST_F(VideoCaptureDeviceTest, MAYBE_AllocateBadSize) {
-  if (!FindUsableDevices())
+  auto descriptor = FindUsableDeviceDescriptor();
+  if (!descriptor)
     return;
 
   std::unique_ptr<VideoCaptureDevice> device(
-      video_capture_device_factory_->CreateDevice(
-          device_descriptors_->front()));
+      video_capture_device_factory_->CreateDevice(*descriptor));
   ASSERT_TRUE(device);
 
   EXPECT_CALL(*video_capture_client_, OnError(_, _)).Times(0);
   EXPECT_CALL(*video_capture_client_, OnStarted());
 
   const gfx::Size input_size(640, 480);
   VideoCaptureParams capture_params;
   capture_params.requested_format.frame_size.SetSize(637, 472);
   capture_params.requested_format.frame_rate = 35;
   capture_params.requested_format.pixel_format = PIXEL_FORMAT_I420;
   device->AllocateAndStart(capture_params, std::move(video_capture_client_));
   WaitForCapturedFrame();
   device->StopAndDeAllocate();
   EXPECT_EQ(last_format().frame_size.width(), input_size.width());
   EXPECT_EQ(last_format().frame_size.height(), input_size.height());
   if (last_format().pixel_format != PIXEL_FORMAT_MJPEG)
     EXPECT_EQ(input_size.GetArea(), last_format().frame_size.GetArea());
 }
 
 // Cause hangs on Windows, Linux. Fails Android. https://crbug.com/417824
 TEST_F(VideoCaptureDeviceTest, DISABLED_ReAllocateCamera) {
-  if (!FindUsableDevices())
+  auto descriptor = FindUsableDeviceDescriptor();
+  if (!descriptor)
     return;
 
   // First, do a number of very fast device start/stops.
   for (int i = 0; i <= 5; i++) {
     ResetWithNewClient();
     std::unique_ptr<VideoCaptureDevice> device(
-        video_capture_device_factory_->CreateDevice(
-            device_descriptors_->front()));
+        video_capture_device_factory_->CreateDevice(*descriptor));
     gfx::Size resolution;
     if (i % 2)
       resolution = gfx::Size(640, 480);
     else
       resolution = gfx::Size(1280, 1024);
 
     VideoCaptureParams capture_params;
     capture_params.requested_format.frame_size = resolution;
     capture_params.requested_format.frame_rate = 30;
     capture_params.requested_format.pixel_format = PIXEL_FORMAT_I420;
@@ skipping 64 matching lines @@
   std::unique_ptr<VideoCaptureDeviceDescriptor> device_descriptor =
       GetFirstDeviceDescriptorSupportingPixelFormat(PIXEL_FORMAT_MAX);
   // Verify no camera returned for PIXEL_FORMAT_MAX. Nothing else to test here
   // since we cannot forecast the hardware capabilities.
   ASSERT_FALSE(device_descriptor);
 }
 
 // Starts the camera and verifies that a photo can be taken. The correctness of
 // the photo is enforced by MockImageCaptureClient.
 TEST_F(VideoCaptureDeviceTest, MAYBE_TakePhoto) {
-  if (!FindUsableDevices())
+  auto descriptor = FindUsableDeviceDescriptor();
+  if (!descriptor)
     return;
 
 #if defined(OS_CHROMEOS)
   // TODO(jcliang): Remove this after we implement TakePhoto.
   if (VideoCaptureDeviceFactoryChromeOS::ShouldEnable()) {
     return;
   }
 #endif
 
 #if defined(OS_ANDROID)
   // TODO(mcasas): fails on Lollipop devices, reconnect https://crbug.com/646840
   if (base::android::BuildInfo::GetInstance()->sdk_int() <
       base::android::SDK_VERSION_MARSHMALLOW) {
     return;
   }
 #endif
 
   std::unique_ptr<VideoCaptureDevice> device(
-      video_capture_device_factory_->CreateDevice(
-          device_descriptors_->front()));
+      video_capture_device_factory_->CreateDevice(*descriptor));
   ASSERT_TRUE(device);
 
   EXPECT_CALL(*video_capture_client_, OnError(_, _)).Times(0);
   EXPECT_CALL(*video_capture_client_, OnStarted());
 
   VideoCaptureParams capture_params;
   capture_params.requested_format.frame_size.SetSize(320, 240);
   capture_params.requested_format.frame_rate = 30;
   capture_params.requested_format.pixel_format = PIXEL_FORMAT_I420;
   device->AllocateAndStart(capture_params, std::move(video_capture_client_));
@@ skipping 11 matching lines @@
       .WillOnce(RunClosure(quit_closure));
 
   device->TakePhoto(std::move(scoped_callback));
   run_loop.Run();
 
   device->StopAndDeAllocate();
 }
 
 // Starts the camera and verifies that the photo capabilities can be retrieved.
 TEST_F(VideoCaptureDeviceTest, MAYBE_GetPhotoState) {
-  if (!FindUsableDevices())
+  auto descriptor = FindUsableDeviceDescriptor();
+  if (!descriptor)
     return;
 
 #if defined(OS_CHROMEOS)
   // TODO(jcliang): Remove this after we implement GetPhotoCapabilities.
   if (VideoCaptureDeviceFactoryChromeOS::ShouldEnable()) {
     return;
   }
 #endif
 
 #if defined(OS_ANDROID)
   // TODO(mcasas): fails on Lollipop devices, reconnect https://crbug.com/646840
   if (base::android::BuildInfo::GetInstance()->sdk_int() <
       base::android::SDK_VERSION_MARSHMALLOW) {
     return;
   }
 #endif
 
   std::unique_ptr<VideoCaptureDevice> device(
-      video_capture_device_factory_->CreateDevice(
-          device_descriptors_->front()));
+      video_capture_device_factory_->CreateDevice(*descriptor));
   ASSERT_TRUE(device);
 
   EXPECT_CALL(*video_capture_client_, OnError(_, _)).Times(0);
   EXPECT_CALL(*video_capture_client_, OnStarted());
 
   VideoCaptureParams capture_params;
   capture_params.requested_format.frame_size.SetSize(320, 240);
   capture_params.requested_format.frame_rate = 30;
   capture_params.requested_format.pixel_format = PIXEL_FORMAT_I420;
   device->AllocateAndStart(capture_params, std::move(video_capture_client_));
@@ skipping 13 matching lines @@
 
   device->GetPhotoState(std::move(scoped_get_callback));
   run_loop.Run();
 
   ASSERT_TRUE(image_capture_client_->capabilities());
 
   device->StopAndDeAllocate();
 }
 
 };  // namespace media