blob: e1e9ac72d223364a9310dc3db20abfe3ed06e3a1 [file] [log] [blame]
// 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 <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 Microsoft::WRL::ComPtr;
using base::win::ScopedCoMem;
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); \
}
#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;
ComPtr<IKsPropertySet> ks_property;
HRESULT hr = pin->QueryInterface(IID_PPV_ARGS(&ks_property));
if (SUCCEEDED(hr)) {
GUID pin_category;
DWORD return_value;
hr = ks_property->Get(AMPROPSETID_Pin, AMPROPERTY_PIN_CATEGORY, NULL, 0,
&pin_category, sizeof(pin_category), &return_value);
if (SUCCEEDED(hr) && (return_value == sizeof(pin_category))) {
found = (pin_category == category);
}
}
return found;
}
// 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 = nullptr,
mojom::MeteringMode* current_mode = nullptr) {
auto control_range = mojom::Range::New();
long min, max, step, default_value, flags;
HRESULT hr = range_getter(&min, &max, &step, &default_value, &flags);
DLOG_IF_FAILED_WITH_HRESULT("Control range reading failed", hr);
if (SUCCEEDED(hr)) {
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);
}
}
long current;
hr = value_getter(&current, &flags);
DLOG_IF_FAILED_WITH_HRESULT("Control value reading failed", hr);
if (SUCCEEDED(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;
}
// static
void VideoCaptureDeviceWin::GetDeviceCapabilityList(
const std::string& device_id,
bool query_detailed_frame_rates,
CapabilityList* out_capability_list) {
ComPtr<IBaseFilter> capture_filter;
HRESULT hr = VideoCaptureDeviceWin::GetDeviceFilter(
device_id, capture_filter.GetAddressOf());
if (!capture_filter.Get()) {
DLOG(ERROR) << "Failed to create capture filter: "
<< logging::SystemErrorCodeToString(hr);
return;
}
ComPtr<IPin> output_capture_pin(VideoCaptureDeviceWin::GetPin(
capture_filter.Get(), PINDIR_OUTPUT, PIN_CATEGORY_CAPTURE, GUID_NULL));
if (!output_capture_pin.Get()) {
DLOG(ERROR) << "Failed to get capture output pin";
return;
}
GetPinCapabilityList(capture_filter, output_capture_pin,
query_detailed_frame_rates, out_capability_list);
}
// static
void VideoCaptureDeviceWin::GetPinCapabilityList(
ComPtr<IBaseFilter> capture_filter,
ComPtr<IPin> output_capture_pin,
bool query_detailed_frame_rates,
CapabilityList* out_capability_list) {
ComPtr<IAMStreamConfig> stream_config;
HRESULT hr = output_capture_pin.CopyTo(stream_config.GetAddressOf());
if (FAILED(hr)) {
DLOG(ERROR) << "Failed to get IAMStreamConfig interface from "
"capture device: "
<< logging::SystemErrorCodeToString(hr);
return;
}
// Get interface used for getting the frame rate.
ComPtr<IAMVideoControl> video_control;
hr = capture_filter.CopyTo(video_control.GetAddressOf());
int count = 0, size = 0;
hr = stream_config->GetNumberOfCapabilities(&count, &size);
if (FAILED(hr)) {
DLOG(ERROR) << "GetNumberOfCapabilities failed: "
<< logging::SystemErrorCodeToString(hr);
return;
}
std::unique_ptr<BYTE[]> caps(new BYTE[size]);
for (int i = 0; i < count; ++i) {
VideoCaptureDeviceWin::ScopedMediaType media_type;
hr = stream_config->GetStreamCaps(i, media_type.Receive(), caps.get());
// GetStreamCaps() may return S_FALSE, so don't use FAILED() or SUCCEED()
// macros here since they'll trigger incorrectly.
if (hr != S_OK || !media_type.get()) {
DLOG(ERROR) << "GetStreamCaps failed: "
<< logging::SystemErrorCodeToString(hr);
return;
}
if (media_type->majortype == MEDIATYPE_Video &&
media_type->formattype == FORMAT_VideoInfo) {
VideoCaptureFormat format;
format.pixel_format =
VideoCaptureDeviceWin::TranslateMediaSubtypeToPixelFormat(
media_type->subtype);
if (format.pixel_format == PIXEL_FORMAT_UNKNOWN)
continue;
VIDEOINFOHEADER* h =
reinterpret_cast<VIDEOINFOHEADER*>(media_type->pbFormat);
format.frame_size.SetSize(h->bmiHeader.biWidth, h->bmiHeader.biHeight);
std::vector<float> frame_rates;
if (query_detailed_frame_rates && video_control.Get()) {
// Try to get a better |time_per_frame| from IAMVideoControl. If not,
// use the value from VIDEOINFOHEADER.
ScopedCoMem<LONGLONG> time_per_frame_list;
LONG list_size = 0;
const SIZE size = {format.frame_size.width(),
format.frame_size.height()};
hr = video_control->GetFrameRateList(output_capture_pin.Get(), i, size,
&list_size, &time_per_frame_list);
// Sometimes |list_size| will be > 0, but time_per_frame_list will be
// NULL. Some drivers may return an HRESULT of S_FALSE which
// SUCCEEDED() translates into success, so explicitly check S_OK. See
// http://crbug.com/306237.
if (hr == S_OK && list_size > 0 && time_per_frame_list) {
for (int k = 0; k < list_size; k++) {
LONGLONG time_per_frame = *(time_per_frame_list.get() + k);
if (time_per_frame <= 0)
continue;
frame_rates.push_back(kSecondsToReferenceTime /
static_cast<float>(time_per_frame));
}
}
}
if (frame_rates.empty() && h->AvgTimePerFrame > 0) {
frame_rates.push_back(kSecondsToReferenceTime /
static_cast<float>(h->AvgTimePerFrame));
}
if (frame_rates.empty())
frame_rates.push_back(0.0f);
for (const auto& frame_rate : frame_rates) {
format.frame_rate = frame_rate;
out_capability_list->emplace_back(i, format, h->bmiHeader);
}
}
}
}
// 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);
ComPtr<ICreateDevEnum> dev_enum;
HRESULT hr = ::CoCreateInstance(CLSID_SystemDeviceEnum, NULL, CLSCTX_INPROC,
IID_PPV_ARGS(&dev_enum));
if (FAILED(hr))
return hr;
ComPtr<IEnumMoniker> enum_moniker;
hr = dev_enum->CreateClassEnumerator(CLSID_VideoInputDeviceCategory,
enum_moniker.GetAddressOf(), 0);
// CreateClassEnumerator returns S_FALSE on some Windows OS
// when no camera exist. Therefore the FAILED macro can't be used.
if (hr != S_OK)
return hr;
ComPtr<IBaseFilter> capture_filter;
for (ComPtr<IMoniker> moniker;
enum_moniker->Next(1, moniker.GetAddressOf(), NULL) == S_OK;
moniker.Reset()) {
ComPtr<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"};
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())));
if (device_path.compare(device_id) == 0) {
// We have found the requested device
hr = moniker->BindToObject(0, 0, IID_PPV_ARGS(&capture_filter));
DLOG_IF(ERROR, FAILED(hr)) << "Failed to bind camera filter: "
<< logging::SystemErrorCodeToString(hr);
break;
}
}
}
*filter = capture_filter.Detach();
if (!*filter && SUCCEEDED(hr))
hr = HRESULT_FROM_WIN32(ERROR_NOT_FOUND);
return hr;
}
// Finds an IPin on an IBaseFilter given the direction, Category and/or Major
// Type. If either |category| or |major_type| are GUID_NULL, they are ignored.
// static
ComPtr<IPin> VideoCaptureDeviceWin::GetPin(IBaseFilter* filter,
PIN_DIRECTION pin_dir,
REFGUID category,
REFGUID major_type) {
ComPtr<IPin> pin;
ComPtr<IEnumPins> pin_enum;
HRESULT hr = filter->EnumPins(pin_enum.GetAddressOf());
if (pin_enum.Get() == NULL)
return pin;
// Get first unconnected pin.
hr = pin_enum->Reset(); // set to first pin
while ((hr = pin_enum->Next(1, pin.GetAddressOf(), NULL)) == S_OK) {
PIN_DIRECTION this_pin_dir = static_cast<PIN_DIRECTION>(-1);
hr = pin->QueryDirection(&this_pin_dir);
if (pin_dir == this_pin_dir) {
if ((category == GUID_NULL || PinMatchesCategory(pin.Get(), category)) &&
(major_type == GUID_NULL ||
PinMatchesMajorType(pin.Get(), major_type))) {
return pin;
}
}
pin.Reset();
}
DCHECK(!pin.Get());
return pin;
}
// static
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},
{MEDIASUBTYPE_UYVY, PIXEL_FORMAT_UYVY},
{MEDIASUBTYPE_ARGB32, PIXEL_FORMAT_ARGB},
{kMediaSubTypeHDYC, PIXEL_FORMAT_UYVY},
{kMediaSubTypeY16, PIXEL_FORMAT_Y16},
{kMediaSubTypeZ16, PIXEL_FORMAT_Y16},
{kMediaSubTypeINVZ, PIXEL_FORMAT_Y16},
};
for (const auto& pixel_format : kMediaSubtypeToPixelFormatCorrespondence) {
if (sub_type == pixel_format.sub_type)
return pixel_format.format;
}
#ifndef NDEBUG
WCHAR guid_str[128];
StringFromGUID2(sub_type, guid_str, arraysize(guid_str));
DVLOG(2) << "Device (also) supports an unknown media type " << guid_str;
#endif
return PIXEL_FORMAT_UNKNOWN;
}
void VideoCaptureDeviceWin::ScopedMediaType::Free() {
if (!media_type_)
return;
DeleteMediaType(media_type_);
media_type_ = NULL;
}
AM_MEDIA_TYPE** VideoCaptureDeviceWin::ScopedMediaType::Receive() {
DCHECK(!media_type_);
return &media_type_;
}
// Release the format block for a media type.
// http://msdn.microsoft.com/en-us/library/dd375432(VS.85).aspx
void VideoCaptureDeviceWin::ScopedMediaType::FreeMediaType(AM_MEDIA_TYPE* mt) {
if (mt->cbFormat != 0) {
CoTaskMemFree(mt->pbFormat);
mt->cbFormat = 0;
mt->pbFormat = NULL;
}
if (mt->pUnk != NULL) {
NOTREACHED();
// pUnk should not be used.
mt->pUnk->Release();
mt->pUnk = NULL;
}
}
// Delete a media type structure that was allocated on the heap.
// http://msdn.microsoft.com/en-us/library/dd375432(VS.85).aspx
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) {
// 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()) {
if (sink_filter_.get()) {
graph_builder_->RemoveFilter(sink_filter_.get());
sink_filter_ = NULL;
}
if (capture_filter_.Get())
graph_builder_->RemoveFilter(capture_filter_.Get());
}
if (capture_graph_builder_.Get())
capture_graph_builder_.Reset();
}
bool VideoCaptureDeviceWin::Init() {
DCHECK(thread_checker_.CalledOnValidThread());
HRESULT hr = GetDeviceFilter(device_descriptor_.device_id,
capture_filter_.GetAddressOf());
DLOG_IF_FAILED_WITH_HRESULT("Failed to create capture filter", hr);
if (!capture_filter_.Get())
return false;
output_capture_pin_ = GetPin(capture_filter_.Get(), PINDIR_OUTPUT,
PIN_CATEGORY_CAPTURE, GUID_NULL);
if (!output_capture_pin_.Get()) {
DLOG(ERROR) << "Failed to get capture output pin";
return false;
}
// Create the sink filter used for receiving Captured frames.
sink_filter_ = new SinkFilter(this);
if (sink_filter_.get() == NULL) {
DLOG(ERROR) << "Failed to create sink filter";
return false;
}
input_sink_pin_ = sink_filter_->GetPin(0);
hr = ::CoCreateInstance(CLSID_FilterGraph, NULL, CLSCTX_INPROC_SERVER,
IID_PPV_ARGS(&graph_builder_));
DLOG_IF_FAILED_WITH_HRESULT("Failed to create capture filter", hr);
if (FAILED(hr))
return false;
hr = ::CoCreateInstance(CLSID_CaptureGraphBuilder2, NULL, CLSCTX_INPROC,
IID_PPV_ARGS(&capture_graph_builder_));
DLOG_IF_FAILED_WITH_HRESULT("Failed to create the Capture Graph Builder", hr);
if (FAILED(hr))
return false;
hr = capture_graph_builder_->SetFiltergraph(graph_builder_.Get());
DLOG_IF_FAILED_WITH_HRESULT("Failed to give graph to capture graph builder",
hr);
if (FAILED(hr))
return false;
hr = graph_builder_.CopyTo(media_control_.GetAddressOf());
DLOG_IF_FAILED_WITH_HRESULT("Failed to create media control builder", hr);
if (FAILED(hr))
return false;
hr = graph_builder_->AddFilter(capture_filter_.Get(), NULL);
DLOG_IF_FAILED_WITH_HRESULT("Failed to add the capture device to the graph",
hr);
if (FAILED(hr))
return false;
hr = graph_builder_->AddFilter(sink_filter_.get(), NULL);
DLOG_IF_FAILED_WITH_HRESULT("Failed to add the sink filter to the graph", hr);
if (FAILED(hr))
return false;
// The following code builds the upstream portions of the graph, for example
// if a capture device uses a Windows Driver Model (WDM) driver, the graph may
// require certain filters upstream from the WDM Video Capture filter, such as
// a TV Tuner filter or an Analog Video Crossbar filter. We try using the more
// prevalent MEDIATYPE_Interleaved first.
ComPtr<IAMStreamConfig> stream_config;
hr = capture_graph_builder_->FindInterface(
&PIN_CATEGORY_CAPTURE, &MEDIATYPE_Interleaved, capture_filter_.Get(),
IID_IAMStreamConfig, (void**)stream_config.GetAddressOf());
if (FAILED(hr)) {
hr = capture_graph_builder_->FindInterface(
&PIN_CATEGORY_CAPTURE, &MEDIATYPE_Video, capture_filter_.Get(),
IID_IAMStreamConfig, (void**)stream_config.GetAddressOf());
DLOG_IF_FAILED_WITH_HRESULT("Failed to find CapFilter:IAMStreamConfig", hr);
}
return CreateCapabilityMap();
}
void VideoCaptureDeviceWin::AllocateAndStart(
const VideoCaptureParams& params,
std::unique_ptr<VideoCaptureDevice::Client> client) {
DCHECK(thread_checker_.CalledOnValidThread());
if (state_ != kIdle)
return;
client_ = std::move(client);
// Get the camera capability that best match the requested format.
const CapabilityWin found_capability =
GetBestMatchedCapability(params.requested_format, capabilities_);
// Reduce the frame rate if the requested frame rate is lower
// than the capability.
const float frame_rate =
std::min(params.requested_format.frame_rate,
found_capability.supported_format.frame_rate);
ComPtr<IAMStreamConfig> stream_config;
HRESULT hr = output_capture_pin_.CopyTo(stream_config.GetAddressOf());
if (FAILED(hr)) {
SetErrorState(FROM_HERE, "Can't get the Capture format settings", hr);
return;
}
int count = 0, size = 0;
hr = stream_config->GetNumberOfCapabilities(&count, &size);
if (FAILED(hr)) {
SetErrorState(FROM_HERE, "Failed to GetNumberOfCapabilities", hr);
return;
}
std::unique_ptr<BYTE[]> caps(new BYTE[size]);
ScopedMediaType media_type;
// Get the windows capability from the capture device.
// GetStreamCaps can return S_FALSE which we consider an error. Therefore the
// FAILED macro can't be used.
hr = stream_config->GetStreamCaps(found_capability.stream_index,
media_type.Receive(), caps.get());
if (hr != S_OK) {
SetErrorState(FROM_HERE, "Failed to get capture device capabilities", hr);
return;
}
if (media_type->formattype == FORMAT_VideoInfo) {
VIDEOINFOHEADER* h =
reinterpret_cast<VIDEOINFOHEADER*>(media_type->pbFormat);
if (frame_rate > 0)
h->AvgTimePerFrame = kSecondsToReferenceTime / frame_rate;
}
// 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(),
input_sink_pin_.Get(), NULL);
}
if (FAILED(hr)) {
SetErrorState(FROM_HERE, "Failed to connect the Capture graph.", hr);
return;
}
hr = media_control_->Pause();
if (FAILED(hr)) {
SetErrorState(FROM_HERE, "Failed to pause the Capture device", hr);
return;
}
// Start capturing.
hr = media_control_->Run();
if (FAILED(hr)) {
SetErrorState(FROM_HERE, "Failed to start the Capture device.", hr);
return;
}
client_->OnStarted();
state_ = kCapturing;
}
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);
return;
}
graph_builder_->Disconnect(output_capture_pin_.Get());
graph_builder_->Disconnect(input_sink_pin_.Get());
client_.reset();
state_ = kIdle;
}
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::GetPhotoState(GetPhotoStateCallback callback) {
DCHECK(thread_checker_.CalledOnValidThread());
if (!camera_control_ || !video_control_) {
if (!InitializeVideoAndCameraControls())
return;
}
auto photo_capabilities = mojom::PhotoState::New();
photo_capabilities->exposure_compensation = RetrieveControlRangeAndCurrent(
[this](auto... args) {
return this->camera_control_->getRange_Exposure(args...);
},
[this](auto... args) {
return this->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...);
},
[this](auto... args) {
return this->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...);
},
[this](auto... args) {
return this->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...);
},
[this](auto... args) {
return this->video_control_->get_Brightness(args...);
});
photo_capabilities->contrast = RetrieveControlRangeAndCurrent(
[this](auto... args) {
return this->video_control_->getRange_Contrast(args...);
},
[this](auto... args) {
return this->video_control_->get_Contrast(args...);
});
photo_capabilities->saturation = RetrieveControlRangeAndCurrent(
[this](auto... args) {
return this->video_control_->getRange_Saturation(args...);
},
[this](auto... args) {
return this->video_control_->get_Saturation(args...);
});
photo_capabilities->sharpness = RetrieveControlRangeAndCurrent(
[this](auto... args) {
return this->video_control_->getRange_Sharpness(args...);
},
[this](auto... args) {
return this->video_control_->get_Sharpness(args...);
});
photo_capabilities->zoom = RetrieveControlRangeAndCurrent(
[this](auto... args) {
return this->camera_control_->getRange_Zoom(args...);
},
[this](auto... args) {
return this->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->torch = false;
std::move(callback).Run(std::move(photo_capabilities));
}
void VideoCaptureDeviceWin::SetPhotoOptions(
mojom::PhotoSettingsPtr settings,
VideoCaptureDevice::SetPhotoOptionsCallback callback) {
DCHECK(thread_checker_.CalledOnValidThread());
if (!camera_control_ || !video_control_) {
if (!InitializeVideoAndCameraControls())
return;
}
HRESULT hr;
if (settings->has_zoom) {
hr = camera_control_->put_Zoom(settings->zoom, CameraControl_Flags_Manual);
DLOG_IF_FAILED_WITH_HRESULT("Zoom config failed", hr);
if (FAILED(hr))
return;
}
if (settings->has_white_balance_mode) {
if (settings->white_balance_mode == mojom::MeteringMode::CONTINUOUS) {
hr = video_control_->put_WhiteBalance(0L, VideoProcAmp_Flags_Auto);
DLOG_IF_FAILED_WITH_HRESULT("Auto white balance config failed", hr);
if (FAILED(hr))
return;
white_balance_mode_manual_ = false;
} else {
white_balance_mode_manual_ = true;
}
}
if (white_balance_mode_manual_ && settings->has_color_temperature) {
hr = video_control_->put_WhiteBalance(settings->color_temperature,
CameraControl_Flags_Manual);
DLOG_IF_FAILED_WITH_HRESULT("Color temperature config failed", hr);
if (FAILED(hr))
return;
}
if (settings->has_exposure_mode) {
if (settings->exposure_mode == mojom::MeteringMode::CONTINUOUS) {
hr = camera_control_->put_Exposure(0L, VideoProcAmp_Flags_Auto);
DLOG_IF_FAILED_WITH_HRESULT("Auto exposure config failed", hr);
if (FAILED(hr))
return;
exposure_mode_manual_ = false;
} else {
exposure_mode_manual_ = true;
}
}
if (exposure_mode_manual_ && settings->has_exposure_compensation) {
hr = camera_control_->put_Exposure(settings->exposure_compensation,
CameraControl_Flags_Manual);
DLOG_IF_FAILED_WITH_HRESULT("Exposure Compensation config failed", hr);
if (FAILED(hr))
return;
}
if (settings->has_brightness) {
hr = video_control_->put_Brightness(settings->brightness,
CameraControl_Flags_Manual);
DLOG_IF_FAILED_WITH_HRESULT("Brightness config failed", hr);
if (FAILED(hr))
return;
}
if (settings->has_contrast) {
hr = video_control_->put_Contrast(settings->contrast,
CameraControl_Flags_Manual);
DLOG_IF_FAILED_WITH_HRESULT("Contrast config failed", hr);
if (FAILED(hr))
return;
}
if (settings->has_saturation) {
hr = video_control_->put_Saturation(settings->saturation,
CameraControl_Flags_Manual);
DLOG_IF_FAILED_WITH_HRESULT("Saturation config failed", hr);
if (FAILED(hr))
return;
}
if (settings->has_sharpness) {
hr = video_control_->put_Sharpness(settings->sharpness,
CameraControl_Flags_Manual);
DLOG_IF_FAILED_WITH_HRESULT("Sharpness config failed", hr);
if (FAILED(hr))
return;
}
std::move(callback).Run(true);
}
bool VideoCaptureDeviceWin::InitializeVideoAndCameraControls() {
ComPtr<IKsTopologyInfo> info;
HRESULT hr = capture_filter_.CopyTo(info.GetAddressOf());
if (FAILED(hr)) {
SetErrorState(FROM_HERE, "Failed to obtain the topology info.", hr);
return false;
}
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 false;
}
// 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 false;
}
}
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 false;
}
}
return camera_control_ && video_control_;
}
// 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.
if (timestamp == media::kNoTimestamp)
timestamp = base::TimeTicks::Now() - first_ref_time_;
client_->OnIncomingCapturedData(buffer, length, format, 0,
base::TimeTicks::Now(), timestamp);
while (!take_photo_callbacks_.empty()) {
TakePhotoCallback cb = std::move(take_photo_callbacks_.front());
take_photo_callbacks_.pop();
mojom::BlobPtr blob = Blobify(buffer, length, format);
if (blob)
std::move(cb).Run(std::move(blob));
}
}
bool VideoCaptureDeviceWin::CreateCapabilityMap() {
DCHECK(thread_checker_.CalledOnValidThread());
GetPinCapabilityList(capture_filter_, output_capture_pin_,
true /* query_detailed_frame_rates */, &capabilities_);
return !capabilities_.empty();
}
// Set the power line frequency removal in |capture_filter_| if available.
void VideoCaptureDeviceWin::SetAntiFlickerInCaptureFilter(
const VideoCaptureParams& params) {
const PowerLineFrequency power_line_frequency = GetPowerLineFrequency(params);
if (power_line_frequency != media::PowerLineFrequency::FREQUENCY_50HZ &&
power_line_frequency != media::PowerLineFrequency::FREQUENCY_60HZ) {
return;
}
ComPtr<IKsPropertySet> ks_propset;
DWORD type_support = 0;
HRESULT hr;
if (SUCCEEDED(hr = capture_filter_.CopyTo(ks_propset.GetAddressOf())) &&
SUCCEEDED(hr = ks_propset->QuerySupported(
PROPSETID_VIDCAP_VIDEOPROCAMP,
KSPROPERTY_VIDEOPROCAMP_POWERLINE_FREQUENCY,
&type_support)) &&
(type_support & KSPROPERTY_SUPPORT_SET)) {
KSPROPERTY_VIDEOPROCAMP_S data = {};
data.Property.Set = PROPSETID_VIDCAP_VIDEOPROCAMP;
data.Property.Id = KSPROPERTY_VIDEOPROCAMP_POWERLINE_FREQUENCY;
data.Property.Flags = KSPROPERTY_TYPE_SET;
data.Value =
(power_line_frequency == media::PowerLineFrequency::FREQUENCY_50HZ) ? 1
: 2;
data.Flags = KSPROPERTY_VIDEOPROCAMP_FLAGS_MANUAL;
hr = ks_propset->Set(PROPSETID_VIDCAP_VIDEOPROCAMP,
KSPROPERTY_VIDEOPROCAMP_POWERLINE_FREQUENCY, &data,
sizeof(data), &data, sizeof(data));
DLOG_IF_FAILED_WITH_HRESULT("Anti-flicker setting failed", hr);
}
}
void VideoCaptureDeviceWin::SetErrorState(const base::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