Image Capture: wire getCapabilities() in Windows

media/capture/video/win/video_capture_device_win.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/win/video_capture_device_win.h"
 
 #include <ks.h>
 #include <ksmedia.h>
 #include <objbase.h>
+#include <vidcap.h>
 
 #include <algorithm>
 #include <list>
 #include <utility>
 
 #include "base/macros.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/win/scoped_co_mem.h"
 #include "base/win/scoped_variant.h"
 #include "media/base/timestamp_constants.h"
 #include "media/capture/video/blob_utils.h"
 
 using base::win::ScopedCoMem;
 using base::win::ScopedComPtr;
 using base::win::ScopedVariant;
 
 namespace media {
 
 #if DCHECK_IS_ON()
-#define DLOG_IF_FAILED_WITH_HRESULT(message, hr)                        \
-  {                                                                     \
-    DLOG_IF(ERROR, FAILED(hr)) << (message) << ": "                     \
-                               << logging::SystemErrorCodeToString(hr); \
+#define DLOG_IF_FAILED_WITH_HRESULT(message, hr)                      \
+  {                                                                   \
+    DLOG_IF(ERROR, FAILED(hr))                                        \
+        << (message) << ": " << logging::SystemErrorCodeToString(hr); \
   }
 #else
 #define DLOG_IF_FAILED_WITH_HRESULT(message, hr) \
   {}
 #endif
 
 // Check if a Pin matches a category.
 bool PinMatchesCategory(IPin* pin, REFGUID category) {
   DCHECK(pin);
   bool found = false;
@@ skipping 12 matching lines @@
 }
 
 // Check if a Pin's MediaType matches a given |major_type|.
 bool PinMatchesMajorType(IPin* pin, REFGUID major_type) {
   DCHECK(pin);
   AM_MEDIA_TYPE connection_media_type;
   const HRESULT hr = pin->ConnectionMediaType(&connection_media_type);
   return SUCCEEDED(hr) && connection_media_type.majortype == major_type;
 }
 
+// Retrieves the control range and value using the provided getters, and
+// optionally returns the associated supported and current mode.
+template <typename RangeGetter, typename ValueGetter>
+mojom::RangePtr RetrieveControlRangeAndCurrent(
+    RangeGetter range_getter,
+    ValueGetter value_getter,
+    std::vector<mojom::MeteringMode>* supported_modes,

[robliao, 2017/05/03 21:38:26]

You can use the default = nullptr argument to save on the nullptr, nullptrs
below.

[mcasas, 2017/05/03 22:16:49]

Done.

+    mojom::MeteringMode* current_mode) {
+  auto control_range = mojom::Range::New();

[robliao, 2017/05/03 21:38:27]

Will the caller be okay with any failure below?

[mcasas, 2017/05/03 22:16:49]

Yes, returning an empty mojom::RangePtr is fine.

+  long min, max, step, default_value, flags, current;
+  HRESULT hr = range_getter(&min, &max, &step, &default_value, &flags);
+  DLOG_IF_FAILED_WITH_HRESULT("Control range reading failed", hr);
+  if (!FAILED(hr)) {

[robliao, 2017/05/03 21:38:26]

Use SUCCEEDED(hr) here and below.

[mcasas, 2017/05/03 22:16:49]

Done.

+    control_range->min = min;
+    control_range->max = max;
+    control_range->step = step;
+    if (supported_modes != nullptr) {
+      if (flags && CameraControl_Flags_Auto)
+        supported_modes->push_back(mojom::MeteringMode::CONTINUOUS);
+      if (flags && CameraControl_Flags_Manual)
+        supported_modes->push_back(mojom::MeteringMode::MANUAL);
+    }
+  }
+  hr = value_getter(&current, &flags);
+  DLOG_IF_FAILED_WITH_HRESULT("Control value reading failed", hr);
+  if (!FAILED(hr)) {
+    control_range->current = current;
+    if (current_mode != nullptr) {
+      if (flags && CameraControl_Flags_Auto)
+        *current_mode = mojom::MeteringMode::CONTINUOUS;
+      else if (flags && CameraControl_Flags_Manual)
+        *current_mode = mojom::MeteringMode::MANUAL;
+    }
+  }
+
+  return control_range;
+}
+
 // Finds and creates a DirectShow Video Capture filter matching the |device_id|.
 // static
 HRESULT VideoCaptureDeviceWin::GetDeviceFilter(const std::string& device_id,
                                                IBaseFilter** filter) {
   DCHECK(filter);
 
   ScopedComPtr<ICreateDevEnum> dev_enum;
   HRESULT hr =
       dev_enum.CreateInstance(CLSID_SystemDeviceEnum, NULL, CLSCTX_INPROC);
   if (FAILED(hr))
@@ skipping 11 matching lines @@
   for (ScopedComPtr<IMoniker> moniker;
        enum_moniker->Next(1, moniker.Receive(), NULL) == S_OK;
        moniker.Reset()) {
     ScopedComPtr<IPropertyBag> prop_bag;
     hr = moniker->BindToStorage(0, 0, IID_PPV_ARGS(&prop_bag));
     if (FAILED(hr))
       continue;
 
     // Find |device_id| via DevicePath, Description or FriendlyName, whichever
     // is available first and is a VT_BSTR (i.e. String) type.
-    static const wchar_t* kPropertyNames[] = {
-        L"DevicePath", L"Description", L"FriendlyName"};
+    static const wchar_t* kPropertyNames[] = {L"DevicePath", L"Description",
+                                              L"FriendlyName"};
 
     ScopedVariant name;
     for (const auto* property_name : kPropertyNames) {
       prop_bag->Read(property_name, name.Receive(), 0);
       if (name.type() == VT_BSTR)
         break;
     }
 
     if (name.type() == VT_BSTR) {
       const std::string device_path(base::SysWideToUTF8(V_BSTR(name.ptr())));
@@ skipping 40 matching lines @@
       }
     }
     pin.Reset();
   }
 
   DCHECK(!pin.Get());
   return pin;
 }
 
 // static
-VideoPixelFormat
-VideoCaptureDeviceWin::TranslateMediaSubtypeToPixelFormat(
+VideoPixelFormat VideoCaptureDeviceWin::TranslateMediaSubtypeToPixelFormat(
     const GUID& sub_type) {
   static struct {
     const GUID& sub_type;
     VideoPixelFormat format;
   } const kMediaSubtypeToPixelFormatCorrespondence[] = {
       {kMediaSubTypeI420, PIXEL_FORMAT_I420},
       {MEDIASUBTYPE_IYUV, PIXEL_FORMAT_I420},
       {MEDIASUBTYPE_RGB24, PIXEL_FORMAT_RGB24},
       {MEDIASUBTYPE_YUY2, PIXEL_FORMAT_YUY2},
       {MEDIASUBTYPE_MJPG, PIXEL_FORMAT_MJPEG},
@@ skipping 276 matching lines @@
 
 void VideoCaptureDeviceWin::TakePhoto(TakePhotoCallback callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   // DirectShow has other means of capturing still pictures, e.g. connecting a
   // SampleGrabber filter to a PIN_CATEGORY_STILL of |capture_filter_|. This
   // way, however, is not widespread and proves too cumbersome, so we just grab
   // the next captured frame instead.
   take_photo_callbacks_.push(std::move(callback));
 }
 
+void VideoCaptureDeviceWin::GetPhotoCapabilities(
+    GetPhotoCapabilitiesCallback callback) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  base::win::ScopedComPtr<IKsTopologyInfo> info;
+  HRESULT hr = capture_filter_.QueryInterface(info.Receive());
+  if (FAILED(hr)) {
+    SetErrorState(FROM_HERE, "Failed to obtain the topology info.", hr);
+    return;
+  }
+
+  DWORD num_nodes = 0;
+  hr = info->get_NumNodes(&num_nodes);
+  if (FAILED(hr)) {
+    SetErrorState(FROM_HERE, "Failed to obtain the number of nodes.", hr);
+    return;
+  }
+
+  GUID node_type;
+  base::win::ScopedComPtr<ICameraControl> camera_control;
+  base::win::ScopedComPtr<IVideoProcAmp> video_control;
+  for (size_t i = 0; i < num_nodes; i++) {
+    info->get_NodeType(i, &node_type);
+    if (IsEqualGUID(node_type, KSNODETYPE_VIDEO_CAMERA_TERMINAL)) {
+      hr = info->CreateNodeInstance(i, IID_PPV_ARGS(camera_control.Receive()));

[robliao, 2017/05/03 21:38:26]

Is it possible for the node list to have two types
KSNODETYPE_VIDEO_CAMERA_TERMINAL or KSNODETYPE_VIDEO_PROCESSING?

[mcasas, 2017/05/03 22:16:49]

Yes, as a matter of fact it's the usual and expected
situation, mirroring the USB underlying structure 
(https://tinyurl.com/uvc-1-5-specification), namely 
the "Camera Terminal" and "Processing Unit", respectively.

It's so common to have both or none that if either of
them fail to get mapped, it's not worth following and
it's better to bail out as in l.521, 528 and 533.

[robliao, 2017/05/04 21:34:35]

In that case, you might want to clear camera_control and video_control in your
loop then. If you hit this piece of code twice, you'll DCHECK/leak the pointer.

+      if (FAILED(hr)) {
+        SetErrorState(FROM_HERE, "Failed to retrieve the ICameraControl.", hr);
+        return;
+      }
+    }
+    if (IsEqualGUID(node_type, KSNODETYPE_VIDEO_PROCESSING)) {
+      hr = info->CreateNodeInstance(i, IID_PPV_ARGS(video_control.Receive()));
+      if (FAILED(hr)) {
+        SetErrorState(FROM_HERE, "Failed to retrieve the IVideoProcAmp.", hr);
+        return;
+      }
+    }
+  }
+  if (!camera_control || !video_control)
+    return;
+
+  auto photo_capabilities = mojom::PhotoCapabilities::New();
+
+  photo_capabilities->exposure_compensation = RetrieveControlRangeAndCurrent(
+      [camera_control](auto... args) {

[robliao, 2017/05/03 21:38:26]

Optional: It might be better to just do the long*, long*, long* here or at least
mention the number of expected arguments as both the getRange and get expect
different sorts of args.

maybe getRangeArgs and getArgs

[mcasas, 2017/05/03 22:16:49]

Correct, but if the calls in l.76 and l.89 would
have the wrong number of parameters that'd be a
compiler error.  What I can do is to add inside this
lambda e.g. a:

  static_assert(sizeof...(args) == 5, "Bla() needs 5 arguments");

(resp. with 2 arguments).

WDYT?
?

[robliao, 2017/05/04 21:34:35]

Well, it would error out anyways in a failure to satisfy the template. It's fine
as is, but would be better documented if both lambdas didn't use "args".

+        return camera_control->getRange_Exposure(args...);
+      },
+      [camera_control](auto... args) {
+        return camera_control->get_Exposure(args...);
+      },
+      &photo_capabilities->supported_exposure_modes,
+      &photo_capabilities->current_exposure_mode);
+
+  photo_capabilities->color_temperature = RetrieveControlRangeAndCurrent(
+      [video_control](auto... args) {
+        return video_control->getRange_WhiteBalance(args...);
+      },
+      [video_control](auto... args) {
+        return video_control->get_WhiteBalance(args...);
+      },
+      &photo_capabilities->supported_white_balance_modes,
+      &photo_capabilities->current_white_balance_mode);
+
+  // Ignore the returned Focus control range and status.
+  RetrieveControlRangeAndCurrent(
+      [camera_control](auto... args) {
+        return camera_control->getRange_Focus(args...);
+      },
+      [camera_control](auto... args) {
+        return camera_control->get_Focus(args...);
+      },
+      &photo_capabilities->supported_focus_modes,
+      &photo_capabilities->current_focus_mode);
+
+  photo_capabilities->iso = mojom::Range::New();
+
+  photo_capabilities->brightness = RetrieveControlRangeAndCurrent(
+      [video_control](auto... args) {
+        return video_control->getRange_Brightness(args...);
+      },
+      [video_control](auto... args) {
+        return video_control->get_Brightness(args...);
+      },
+      nullptr, nullptr);
+  photo_capabilities->contrast = RetrieveControlRangeAndCurrent(
+      [video_control](auto... args) {
+        return video_control->getRange_Contrast(args...);
+      },
+      [video_control](auto... args) {
+        return video_control->get_Contrast(args...);
+      },
+      nullptr, nullptr);
+  photo_capabilities->saturation = RetrieveControlRangeAndCurrent(
+      [video_control](auto... args) {
+        return video_control->getRange_Saturation(args...);
+      },
+      [video_control](auto... args) {
+        return video_control->get_Saturation(args...);
+      },
+      nullptr, nullptr);
+  photo_capabilities->sharpness = RetrieveControlRangeAndCurrent(
+      [video_control](auto... args) {
+        return video_control->getRange_Sharpness(args...);
+      },
+      [video_control](auto... args) {
+        return video_control->get_Sharpness(args...);
+      },
+      nullptr, nullptr);
+
+  photo_capabilities->zoom = RetrieveControlRangeAndCurrent(
+      [camera_control](auto... args) {
+        return camera_control->getRange_Zoom(args...);
+      },
+      [camera_control](auto... args) {
+        return camera_control->get_Zoom(args...);
+      },
+      nullptr, nullptr);
+
+  photo_capabilities->red_eye_reduction = mojom::RedEyeReduction::NEVER;
+  photo_capabilities->height = mojom::Range::New();
+  photo_capabilities->width = mojom::Range::New();
+  photo_capabilities->torch = false;
+
+  callback.Run(std::move(photo_capabilities));
+}
+
 // Implements SinkFilterObserver::SinkFilterObserver.
 void VideoCaptureDeviceWin::FrameReceived(const uint8_t* buffer,
                                           int length,
                                           const VideoCaptureFormat& format,
                                           base::TimeDelta timestamp) {
   if (first_ref_time_.is_null())
     first_ref_time_ = base::TimeTicks::Now();
 
   // There is a chance that the platform does not provide us with the timestamp,
   // in which case, we use reference time to calculate a timestamp.
@@ skipping 124 matching lines @@
 void VideoCaptureDeviceWin::SetErrorState(
     const tracked_objects::Location& from_here,
     const std::string& reason,
     HRESULT hr) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DLOG_IF_FAILED_WITH_HRESULT(reason, hr);
   state_ = kError;
   client_->OnError(from_here, reason);
 }
 }  // namespace media