Image Capture: split {white_balance,exposure,focus}_modes into current_ and supported_

media/capture/video/linux/v4l2_capture_delegate.cc

 // Copyright 2015 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/linux/v4l2_capture_delegate.h"
 
 #include <linux/version.h>
 #include <linux/videodev2.h>
 #include <poll.h>
 #include <sys/fcntl.h>
 #include <sys/ioctl.h>
 #include <sys/mman.h>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/files/file_enumerator.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/strings/stringprintf.h"
 #include "build/build_config.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/capture/video/blob_utils.h"
 #include "media/capture/video/linux/video_capture_device_linux.h"
 
+using media::mojom::MeteringMode;
+
 #if LINUX_VERSION_CODE < KERNEL_VERSION(4, 6, 0)
 // 16 bit depth, Realsense F200.
 #define V4L2_PIX_FMT_Z16 v4l2_fourcc('Z', '1', '6', ' ')
 #endif
 
 // TODO(aleksandar.stojiljkovic): Wrap this with kernel version check once the
 // format is introduced to kernel.
 // See https://crbug.com/661877
 #ifndef V4L2_PIX_FMT_INVZ
 // 16 bit depth, Realsense SR300.
@@ skipping 509 matching lines @@
   DCHECK(v4l2_task_runner_->BelongsToCurrentThread());
   if (!device_fd_.is_valid() || !is_capturing_)
     return;
 
   mojom::PhotoCapabilitiesPtr photo_capabilities =
       mojom::PhotoCapabilities::New();
 
   photo_capabilities->zoom =
       RetrieveUserControlRange(device_fd_.get(), V4L2_CID_ZOOM_ABSOLUTE);
 
-  photo_capabilities->focus_mode = mojom::MeteringMode::NONE;
+  v4l2_queryctrl manual_focus_ctrl = {};
+  manual_focus_ctrl.id = V4L2_CID_FOCUS_ABSOLUTE;
+  if (RunIoctl(device_fd_.get(), VIDIOC_QUERYCTRL, &manual_focus_ctrl))

[Reilly Grant (use Gerrit), 2017/04/08 00:30:52]

This function didn't previously use RunIoctl. I'm nervous about using this here
where we expect the ioctl to return a failure which means that it will always
run kMaxIOCtrlRetries times.

[mcasas, 2017/04/08 00:50:45]

It did use RunIoctl() before, but it's hidden inside
RetrieveUserControlRange() [1], called in e.g. l.630
and vicinity.

Out of experience, QUERYCTRLs for these newly added 
capabilities tend to succeed, and the failures appear 
while resetting the controls.


[1]
https://cs.chromium.org/chromium/src/media/capture/video/linux/v4l2_capture_d...

+    photo_capabilities->supported_focus_modes.push_back(MeteringMode::MANUAL);
+
+  v4l2_queryctrl auto_focus_ctrl = {};
+  auto_focus_ctrl.id = V4L2_CID_FOCUS_AUTO;
+  if (RunIoctl(device_fd_.get(), VIDIOC_QUERYCTRL, &auto_focus_ctrl)) {
+    photo_capabilities->supported_focus_modes.push_back(
+        MeteringMode::CONTINUOUS);
+  }
+
+  photo_capabilities->current_focus_mode = MeteringMode::NONE;
   v4l2_control auto_focus_current = {};
   auto_focus_current.id = V4L2_CID_FOCUS_AUTO;
   if (HANDLE_EINTR(
           ioctl(device_fd_.get(), VIDIOC_G_CTRL, &auto_focus_current)) >= 0) {
-    photo_capabilities->focus_mode = auto_focus_current.value
-                                         ? mojom::MeteringMode::CONTINUOUS
-                                         : mojom::MeteringMode::MANUAL;
+    photo_capabilities->current_focus_mode = auto_focus_current.value
+                                                 ? MeteringMode::CONTINUOUS
+                                                 : MeteringMode::MANUAL;
   }
 
-  photo_capabilities->exposure_mode = mojom::MeteringMode::NONE;
+  v4l2_queryctrl auto_exposure_ctrl = {};
+  auto_exposure_ctrl.id = V4L2_CID_EXPOSURE_AUTO;
+  if (RunIoctl(device_fd_.get(), VIDIOC_QUERYCTRL, &auto_exposure_ctrl)) {
+    photo_capabilities->supported_exposure_modes.push_back(
+        MeteringMode::MANUAL);
+    photo_capabilities->supported_exposure_modes.push_back(
+        MeteringMode::CONTINUOUS);
+  }
+
+  photo_capabilities->current_exposure_mode = MeteringMode::NONE;
   v4l2_control exposure_current = {};
   exposure_current.id = V4L2_CID_EXPOSURE_AUTO;
   if (HANDLE_EINTR(ioctl(device_fd_.get(), VIDIOC_G_CTRL, &exposure_current)) >=
       0) {
-    photo_capabilities->exposure_mode =
+    photo_capabilities->current_exposure_mode =
         exposure_current.value == V4L2_EXPOSURE_MANUAL
-            ? mojom::MeteringMode::MANUAL
-            : mojom::MeteringMode::CONTINUOUS;
+            ? MeteringMode::MANUAL
+            : MeteringMode::CONTINUOUS;
   }
 
-  photo_capabilities->white_balance_mode = mojom::MeteringMode::NONE;
+  photo_capabilities->color_temperature = RetrieveUserControlRange(
+      device_fd_.get(), V4L2_CID_WHITE_BALANCE_TEMPERATURE);
+  if (photo_capabilities->color_temperature) {
+    photo_capabilities->supported_white_balance_modes.push_back(
+        MeteringMode::MANUAL);
+  }
+
+  v4l2_queryctrl white_balance_ctrl = {};
+  white_balance_ctrl.id = V4L2_CID_AUTO_WHITE_BALANCE;
+  if (RunIoctl(device_fd_.get(), VIDIOC_QUERYCTRL, &white_balance_ctrl) &&
+      !(white_balance_ctrl.flags && V4L2_CTRL_FLAG_DISABLED)) {
+    photo_capabilities->supported_white_balance_modes.push_back(
+        MeteringMode::CONTINUOUS);
+  }
+
+  photo_capabilities->current_white_balance_mode = MeteringMode::NONE;
   v4l2_control white_balance_current = {};
   white_balance_current.id = V4L2_CID_AUTO_WHITE_BALANCE;
   if (HANDLE_EINTR(ioctl(device_fd_.get(), VIDIOC_G_CTRL,
                          &white_balance_current)) >= 0) {
-    photo_capabilities->white_balance_mode =
-        white_balance_current.value ? mojom::MeteringMode::CONTINUOUS
-                                    : mojom::MeteringMode::MANUAL;
+    photo_capabilities->current_white_balance_mode =
+        white_balance_current.value ? MeteringMode::CONTINUOUS
+                                    : MeteringMode::MANUAL;
   }
 
-  photo_capabilities->color_temperature = RetrieveUserControlRange(
-      device_fd_.get(), V4L2_CID_WHITE_BALANCE_TEMPERATURE);
-
   photo_capabilities->iso = mojom::Range::New();
   photo_capabilities->height = mojom::Range::New();
   photo_capabilities->width = mojom::Range::New();
   photo_capabilities->exposure_compensation = mojom::Range::New();
   photo_capabilities->red_eye_reduction = mojom::RedEyeReduction::NEVER;
   photo_capabilities->torch = false;
 
   photo_capabilities->brightness =
       RetrieveUserControlRange(device_fd_.get(), V4L2_CID_BRIGHTNESS);
   photo_capabilities->contrast =
@@ skipping 219 matching lines @@
     DLOG(ERROR) << "Error mmap()ing a V4L2 buffer into userspace";
     return false;
   }
   start_ = static_cast<uint8_t*>(start);
   length_ = buffer.length;
   payload_size_ = 0;
   return true;
 }
 
 }  // namespace media