Revert of Image Capture: wire setPhotoOptions() for Win

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"
@@ skipping 238 matching lines @@
 void VideoCaptureDeviceWin::ScopedMediaType::DeleteMediaType(
     AM_MEDIA_TYPE* mt) {
   if (mt != NULL) {
     FreeMediaType(mt);
     CoTaskMemFree(mt);
   }
 }
 
 VideoCaptureDeviceWin::VideoCaptureDeviceWin(
     const VideoCaptureDeviceDescriptor& device_descriptor)
-    : device_descriptor_(device_descriptor),
-      state_(kIdle),
-      white_balance_mode_manual_(false),
-      exposure_mode_manual_(false) {
+    : device_descriptor_(device_descriptor), state_(kIdle) {
   // TODO(mcasas): Check that CoInitializeEx() has been called with the
   // appropriate Apartment model, i.e., Single Threaded.
 }
 
 VideoCaptureDeviceWin::~VideoCaptureDeviceWin() {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (media_control_.Get())
     media_control_->Stop();
 
   if (graph_builder_.Get()) {
@@ skipping 144 matching lines @@
   // Set the sink filter to request this format.
   sink_filter_->SetRequestedMediaFormat(
       found_capability.supported_format.pixel_format, frame_rate,
       found_capability.info_header);
   // Order the capture device to use this format.
   hr = stream_config->SetFormat(media_type.get());
   if (FAILED(hr)) {
     SetErrorState(FROM_HERE, "Failed to set capture device output format", hr);
     return;
   }
-  capture_format_ = found_capability.supported_format;
 
   SetAntiFlickerInCaptureFilter(params);
 
   if (media_type->subtype == kMediaSubTypeHDYC) {
     // HDYC pixel format, used by the DeckLink capture card, needs an AVI
     // decompressor filter after source, let |graph_builder_| add it.
     hr = graph_builder_->Connect(output_capture_pin_.Get(),
                                  input_sink_pin_.Get());
   } else {
     hr = graph_builder_->ConnectDirect(output_capture_pin_.Get(),
@@ skipping 13 matching lines @@
 
   // Start capturing.
   hr = media_control_->Run();
   if (FAILED(hr)) {
     SetErrorState(FROM_HERE, "Failed to start the Capture device.", hr);
     return;
   }
 
   client_->OnStarted();
   state_ = kCapturing;
-
-  base::win::ScopedComPtr<IKsTopologyInfo> info;
-  hr = capture_filter_.CopyTo(info.GetAddressOf());
-  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;
-  }
-
-  // Every UVC camera is expected to have a single ICameraControl and a single
-  // IVideoProcAmp nodes, and both are needed; ignore any unlikely later ones.
-  GUID node_type;
-  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_));
-      if (SUCCEEDED(hr))
-        break;
-      SetErrorState(FROM_HERE, "Failed to retrieve the ICameraControl.", hr);
-      return;
-    }
-  }
-  for (size_t i = 0; i < num_nodes; i++) {
-    info->get_NodeType(i, &node_type);
-    if (IsEqualGUID(node_type, KSNODETYPE_VIDEO_PROCESSING)) {
-      hr = info->CreateNodeInstance(i, IID_PPV_ARGS(&video_control_));
-      if (SUCCEEDED(hr))
-        break;
-      SetErrorState(FROM_HERE, "Failed to retrieve the IVideoProcAmp.", hr);
-      return;
-    }
-  }
 }
 
 void VideoCaptureDeviceWin::StopAndDeAllocate() {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (state_ != kCapturing)
     return;
 
   HRESULT hr = media_control_->Stop();
   if (FAILED(hr)) {
     SetErrorState(FROM_HERE, "Failed to stop the capture graph.", hr);
@@ skipping 13 matching lines @@
   // 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());
 
-  if (!camera_control_ || !video_control_)
+  base::win::ScopedComPtr<IKsTopologyInfo> info;
+  HRESULT hr = capture_filter_.CopyTo(info.GetAddressOf());
+  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;
+  }
+
+  // Every UVC camera is expected to have a single ICameraControl and a single
+  // IVideoProcAmp nodes, and both are needed; ignore any unlikely later ones.
+  GUID node_type;
+  base::win::ScopedComPtr<ICameraControl> camera_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));
+      if (SUCCEEDED(hr))
+        break;
+      SetErrorState(FROM_HERE, "Failed to retrieve the ICameraControl.", hr);
+      return;
+    }
+  }
+  if (!camera_control)
+    return;
+  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_PROCESSING)) {
+      hr = info->CreateNodeInstance(i, IID_PPV_ARGS(&video_control));
+      if (SUCCEEDED(hr))
+        break;
+      SetErrorState(FROM_HERE, "Failed to retrieve the IVideoProcAmp.", hr);
+      return;
+    }
+  }
+  if (!video_control)
     return;
 
   auto photo_capabilities = mojom::PhotoCapabilities::New();
 
   photo_capabilities->exposure_compensation = RetrieveControlRangeAndCurrent(
-      [this](auto... args) {
-        return this->camera_control_->getRange_Exposure(args...);
+      [camera_control](auto... args) {
+        return camera_control->getRange_Exposure(args...);
       },
-      [this](auto... args) {
-        return this->camera_control_->get_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(
-      [this](auto... args) {
-        return this->video_control_->getRange_WhiteBalance(args...);
+      [video_control](auto... args) {
+        return video_control->getRange_WhiteBalance(args...);
       },
-      [this](auto... args) {
-        return this->video_control_->get_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(
-      [this](auto... args) {
-        return this->camera_control_->getRange_Focus(args...);
+      [camera_control](auto... args) {
+        return camera_control->getRange_Focus(args...);
       },
-      [this](auto... args) {
-        return this->camera_control_->get_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(
-      [this](auto... args) {
-        return this->video_control_->getRange_Brightness(args...);
+      [video_control](auto... args) {
+        return video_control->getRange_Brightness(args...);
       },
-      [this](auto... args) {
-        return this->video_control_->get_Brightness(args...);
+      [video_control](auto... args) {
+        return video_control->get_Brightness(args...);
       });
   photo_capabilities->contrast = RetrieveControlRangeAndCurrent(
-      [this](auto... args) {
-        return this->video_control_->getRange_Contrast(args...);
+      [video_control](auto... args) {
+        return video_control->getRange_Contrast(args...);
       },
-      [this](auto... args) {
-        return this->video_control_->get_Contrast(args...);
+      [video_control](auto... args) {
+        return video_control->get_Contrast(args...);
       });
   photo_capabilities->saturation = RetrieveControlRangeAndCurrent(
-      [this](auto... args) {
-        return this->video_control_->getRange_Saturation(args...);
+      [video_control](auto... args) {
+        return video_control->getRange_Saturation(args...);
       },
-      [this](auto... args) {
-        return this->video_control_->get_Saturation(args...);
+      [video_control](auto... args) {
+        return video_control->get_Saturation(args...);
       });
   photo_capabilities->sharpness = RetrieveControlRangeAndCurrent(
-      [this](auto... args) {
-        return this->video_control_->getRange_Sharpness(args...);
+      [video_control](auto... args) {
+        return video_control->getRange_Sharpness(args...);
       },
-      [this](auto... args) {
-        return this->video_control_->get_Sharpness(args...);
+      [video_control](auto... args) {
+        return video_control->get_Sharpness(args...);
       });
 
   photo_capabilities->zoom = RetrieveControlRangeAndCurrent(
-      [this](auto... args) {
-        return this->camera_control_->getRange_Zoom(args...);
+      [camera_control](auto... args) {
+        return camera_control->getRange_Zoom(args...);
       },
-      [this](auto... args) {
-        return this->camera_control_->get_Zoom(args...);
+      [camera_control](auto... args) {
+        return camera_control->get_Zoom(args...);
       });
 
   photo_capabilities->red_eye_reduction = mojom::RedEyeReduction::NEVER;
-  photo_capabilities->height = mojom::Range::New(
-      capture_format_.frame_size.height(), capture_format_.frame_size.height(),
-      capture_format_.frame_size.height(), 0 /* step */);
-  photo_capabilities->width = mojom::Range::New(
-      capture_format_.frame_size.width(), capture_format_.frame_size.width(),
-      capture_format_.frame_size.width(), 0 /* step */);
+  photo_capabilities->height = mojom::Range::New();
+  photo_capabilities->width = mojom::Range::New();
   photo_capabilities->torch = false;
 
   callback.Run(std::move(photo_capabilities));
 }
 
-void VideoCaptureDeviceWin::SetPhotoOptions(
-    mojom::PhotoSettingsPtr settings,
-    VideoCaptureDevice::SetPhotoOptionsCallback callback) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-
-  if (!camera_control_ || !video_control_)
-    return;
-
-  if (settings->has_zoom) {
-    HRESULT hr =
-        camera_control_->put_Zoom(settings->zoom, CameraControl_Flags_Manual);
-    DLOG_IF_FAILED_WITH_HRESULT("Zoom config failed", hr);
-  }
-
-  if (settings->has_white_balance_mode) {
-    if (settings->white_balance_mode == mojom::MeteringMode::CONTINUOUS) {
-      HRESULT hr =
-          video_control_->put_WhiteBalance(0L, VideoProcAmp_Flags_Auto);
-      DLOG_IF_FAILED_WITH_HRESULT("Auto white balance config failed", hr);
-
-      white_balance_mode_manual_ = false;
-    } else {
-      white_balance_mode_manual_ = true;
-    }
-  }
-  if (white_balance_mode_manual_ && settings->has_color_temperature) {
-    HRESULT hr = video_control_->put_WhiteBalance(settings->color_temperature,
-                                                  CameraControl_Flags_Manual);
-    DLOG_IF_FAILED_WITH_HRESULT("Color temperature config failed", hr);
-  }
-
-  if (settings->has_exposure_mode) {
-    if (settings->exposure_mode == mojom::MeteringMode::CONTINUOUS) {
-      HRESULT hr = camera_control_->put_Exposure(0L, VideoProcAmp_Flags_Auto);
-      DLOG_IF_FAILED_WITH_HRESULT("Auto exposure config failed", hr);
-
-      exposure_mode_manual_ = false;
-    } else {
-      exposure_mode_manual_ = true;
-    }
-  }
-  if (exposure_mode_manual_ && settings->has_exposure_compensation) {
-    HRESULT hr = camera_control_->put_Exposure(settings->exposure_compensation,
-                                               CameraControl_Flags_Manual);
-    DLOG_IF_FAILED_WITH_HRESULT("Exposure Compensation config failed", hr);
-  }
-
-  if (settings->has_brightness) {
-    HRESULT hr = video_control_->put_Brightness(settings->brightness,
-                                                CameraControl_Flags_Manual);
-    DLOG_IF_FAILED_WITH_HRESULT("Brightness config failed", hr);
-  }
-  if (settings->has_contrast) {
-    HRESULT hr = video_control_->put_Contrast(settings->contrast,
-                                              CameraControl_Flags_Manual);
-    DLOG_IF_FAILED_WITH_HRESULT("Contrast config failed", hr);
-  }
-  if (settings->has_saturation) {
-    HRESULT hr = video_control_->put_Saturation(settings->saturation,
-                                                CameraControl_Flags_Manual);
-    DLOG_IF_FAILED_WITH_HRESULT("Saturation config failed", hr);
-  }
-  if (settings->has_sharpness) {
-    HRESULT hr = video_control_->put_Sharpness(settings->sharpness,
-                                               CameraControl_Flags_Manual);
-    DLOG_IF_FAILED_WITH_HRESULT("Sharpness config failed", hr);
-  }
-
-  callback.Run(true);
-}
 // 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