// Copyright 2014 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_factory_win.h"

#include <mfapi.h>
#include <mferror.h>
#include <objbase.h>
#include <stddef.h>
#include <windows.devices.enumeration.h>
#include <windows.foundation.collections.h>
#include <wrl.h>
#include <wrl/client.h>

#include <utility>

#include "base/bind.h"
#include "base/command_line.h"
#include "base/containers/contains.h"
#include "base/cxx17_backports.h"
#include "base/feature_list.h"
#include "base/metrics/histogram_macros.h"
#include "base/no_destructor.h"
#include "base/single_thread_task_runner.h"
#include "base/strings/string_util.h"
#include "base/strings/sys_string_conversions.h"
#include "base/threading/scoped_thread_priority.h"
#include "base/win/core_winrt_util.h"
#include "base/win/scoped_co_mem.h"
#include "base/win/scoped_variant.h"
#include "base/win/windows_version.h"
#include "media/base/media_switches.h"
#include "media/base/win/mf_initializer.h"
#include "media/capture/capture_switches.h"
#include "media/capture/video/win/metrics.h"
#include "media/capture/video/win/video_capture_device_mf_win.h"
#include "media/capture/video/win/video_capture_device_win.h"

using DevicesInfo = std::vector<media::VideoCaptureDeviceInfo>;
using base::win::GetActivationFactory;
using base::win::ScopedCoMem;
using base::win::ScopedHString;
using base::win::ScopedVariant;
using Microsoft::WRL::ComPtr;

namespace media {

namespace {

// In Windows device identifiers, the USB VID and PID are preceded by the string
// "vid_" or "pid_".  The identifiers are each 4 bytes long.
const char kVidPrefix[] = "vid_";  // Also contains '\0'.
const char kPidPrefix[] = "pid_";  // Also contains '\0'.
const size_t kVidPidSize = 4;

// AQS device selector string to filter enumerated DeviceInformation objects to
// KSCATEGORY_SENSOR_CAMERA (Class GUID 24e552d7-6523-47F7-a647-d3465bf1f5ca)
// OR KSCATEGORY_VIDEO_CAMERA (Class GUID e5323777-f976-4f5b-9b55-b94699c46e44).
const wchar_t* kVideoAndSensorCamerasAqsString =
    L"(System.Devices.InterfaceClassGuid:="
    L"\"{e5323777-f976-4f5b-9b55-b94699c46e44}\" AND "
    L"(System.Devices.WinPhone8CameraFlags:=[] OR "
    L"System.Devices.WinPhone8CameraFlags:<4096)) OR "
    L"System.Devices.InterfaceClassGuid:="
    L"\"{24e552d7-6523-47f7-a647-d3465bf1f5ca}\" AND "
    L"System.Devices.InterfaceEnabled:=System.StructuredQueryType.Boolean#True";

// Class GUID for KSCATEGORY_VIDEO_CAMERA. Only devices from that category will
// contain this GUID in their |device_id|.
const char kVideoCameraGuid[] = "e5323777-f976-4f5b-9b55-b94699c46e44";

// Avoid enumerating and/or using certain devices due to they provoking crashes
// or any other reason (http://crbug.com/378494). This enum is defined for the
// purposes of UMA collection. Existing entries cannot be removed.
enum BlockedCameraNames {
  BLOCKED_CAMERA_GOOGLE_CAMERA_ADAPTER = 0,
  BLOCKED_CAMERA_IP_CAMERA = 1,
  BLOCKED_CAMERA_CYBERLINK_WEBCAM_SPLITTER = 2,
  BLOCKED_CAMERA_EPOCCAM = 3,
  // This one must be last, and equal to the previous enumerated value.
  BLOCKED_CAMERA_MAX = BLOCKED_CAMERA_EPOCCAM,
};

#define UWP_ENUM_ERROR_HANDLER(hr, err_log)                         \
  DLOG(WARNING) << err_log << logging::SystemErrorCodeToString(hr); \
  origin_task_runner_->PostTask(FROM_HERE,                          \
                                base::BindOnce(device_info_callback, nullptr))

// Blocked devices are identified by a characteristic prefix of the name.
// This prefix is used case-insensitively. This list must be kept in sync with
// |BlockedCameraNames|.
const char* const kBlockedCameraNames[] = {
    // Name of a fake DirectShow filter on computers with GTalk installed.
    "Google Camera Adapter",
    // The following software WebCams cause crashes.
    "IP Camera [JPEG/MJPEG]",
    "CyberLink Webcam Splitter",
    "EpocCam",
};
static_assert(base::size(kBlockedCameraNames) == BLOCKED_CAMERA_MAX + 1,
              "kBlockedCameraNames should be same size as "
              "BlockedCameraNames enum");

// Use this list only for USB webcams.
const char* const kModelIdsBlockedForMediaFoundation[] = {
    // Devices using Empia 2860 or 2820 chips, see https://crbug.com/849636.
    "eb1a:2860", "eb1a:2820", "1ce6:2820",
    // Elgato HD60 Pro
    "12ab:0380",
    // Sensoray 2253
    "1943:2253",
    // Dell E5440
    "0c45:64d0", "0c45:64d2",
    // Dell E7440
    "1bcf:2985",
    // Lenovo Thinkpad Model 20CG0006FMZ front and rear cameras, see
    // also https://crbug.com/924528.
    "04ca:7047", "04ca:7048",
    // HP Elitebook 840 G1
    "04f2:b3ed", "04f2:b3ca", "05c8:035d", "05c8:0369",
    // HP HD Camera. See https://crbug.com/1011888.
    "04ca:7095",
    // RBG/IR camera for Windows Hello Face Auth. See https://crbug.com/984864.
    "13d3:5257",
    // Acer Aspire f5-573g. See https://crbug.com/1034644.
    "0bda:57f2",
    // Elgato Camlink 4k
    "0fd9:0066"};

// Use this list only for non-USB webcams.
const char* const kDisplayNamesBlockedForMediaFoundation[] = {
    // VMware Virtual Webcams cause hangs when there is no physical Webcam.
    // See https://crbug.com/1044974.
    "VMware Virtual Webcam"};

const std::vector<
    std::pair<VideoCaptureApi, std::vector<std::pair<GUID, GUID>>>>&
GetMFAttributes() {
  if (base::FeatureList::IsEnabled(
          media::kIncludeIRCamerasInDeviceEnumeration)) {
    static const base::NoDestructor<std::vector<
        std::pair<VideoCaptureApi, std::vector<std::pair<GUID, GUID>>>>>
        mf_attributes({{{VideoCaptureApi::WIN_MEDIA_FOUNDATION,
                         {
                             {MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE,
                              MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_GUID},
                         }},
                        {VideoCaptureApi::WIN_MEDIA_FOUNDATION_SENSOR,
                         {{MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE,
                           MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_GUID},
                          {MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_CATEGORY,
                           KSCATEGORY_SENSOR_CAMERA}}}}});
    return *mf_attributes;
  }

  static const base::NoDestructor<std::vector<
      std::pair<VideoCaptureApi, std::vector<std::pair<GUID, GUID>>>>>
      mf_attributes({{VideoCaptureApi::WIN_MEDIA_FOUNDATION,
                      {
                          {MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE,
                           MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_GUID},
                      }}});
  return *mf_attributes;
}

bool IsDeviceBlockedForQueryingDetailedFrameRates(
    const std::string& display_name) {
  return display_name.find("WebcamMax") != std::string::npos;
}

bool IsDeviceBlockedForMediaFoundationByModelId(const std::string& model_id) {
  return base::Contains(kModelIdsBlockedForMediaFoundation, model_id);
}

bool IsDeviceBlockedForMediaFoundationByDisplayName(
    const std::string& display_name) {
  return base::Contains(kDisplayNamesBlockedForMediaFoundation, display_name);
}

bool LoadMediaFoundationDlls() {
  static const wchar_t* const kMfDLLs[] = {
      L"%WINDIR%\\system32\\mf.dll", L"%WINDIR%\\system32\\mfplat.dll",
      L"%WINDIR%\\system32\\mfreadwrite.dll",
      L"%WINDIR%\\system32\\MFCaptureEngine.dll"};

  // Mitigate the issues caused by loading DLLs on a background thread
  // (http://crbug/973868).
  SCOPED_MAY_LOAD_LIBRARY_AT_BACKGROUND_PRIORITY_REPEATEDLY();

  for (const wchar_t* kMfDLL : kMfDLLs) {
    wchar_t path[MAX_PATH] = {0};
    ExpandEnvironmentStringsW(kMfDLL, path, base::size(path));
    if (!LoadLibraryExW(path, nullptr, LOAD_WITH_ALTERED_SEARCH_PATH))
      return false;
  }
  return true;
}

bool PrepareVideoCaptureAttributesMediaFoundation(
    const std::vector<std::pair<GUID, GUID>>& attributes_data,
    int count,
    IMFAttributes** attributes) {
  DCHECK(attributes);
  DCHECK(!*attributes);

  // Once https://bugs.chromium.org/p/chromium/issues/detail?id=791615 is fixed,
  // we must make sure that this method succeeds in capture_unittests context
  // when MediaFoundation is enabled.
  if (!VideoCaptureDeviceFactoryWin::PlatformSupportsMediaFoundation())
    return false;

  if (FAILED(MFCreateAttributes(attributes, count)))
    return false;

  for (const auto& value : attributes_data) {
    if (!SUCCEEDED((*attributes)->SetGUID(value.first, value.second)))
      return false;
  }
  return true;
}

bool IsDeviceBlocked(const std::string& name) {
  DCHECK_EQ(BLOCKED_CAMERA_MAX + 1,
            static_cast<int>(base::size(kBlockedCameraNames)));
  for (size_t i = 0; i < base::size(kBlockedCameraNames); ++i) {
    if (base::StartsWith(name, kBlockedCameraNames[i],
                         base::CompareCase::INSENSITIVE_ASCII)) {
      DVLOG(1) << "Enumerated blocked device: " << name;
      UMA_HISTOGRAM_ENUMERATION("Media.VideoCapture.BlacklistedDevice", i,
                                BLOCKED_CAMERA_MAX + 1);
      return true;
    }
  }
  return false;
}

std::string GetDeviceModelId(const std::string& device_id) {
  const size_t vid_prefix_size = sizeof(kVidPrefix) - 1;
  const size_t pid_prefix_size = sizeof(kPidPrefix) - 1;
  const size_t vid_location = device_id.find(kVidPrefix);
  if (vid_location == std::string::npos ||
      vid_location + vid_prefix_size + kVidPidSize > device_id.size()) {
    return std::string();
  }
  const size_t pid_location = device_id.find(kPidPrefix);
  if (pid_location == std::string::npos ||
      pid_location + pid_prefix_size + kVidPidSize > device_id.size()) {
    return std::string();
  }
  const std::string id_vendor =
      device_id.substr(vid_location + vid_prefix_size, kVidPidSize);
  const std::string id_product =
      device_id.substr(pid_location + pid_prefix_size, kVidPidSize);
  return id_vendor + ":" + id_product;
}

bool DevicesInfoContainsDeviceId(const DevicesInfo& devices_info,
                                 const std::string& device_id) {
  return std::find_if(devices_info.begin(), devices_info.end(),
                      [device_id](const VideoCaptureDeviceInfo& device_info) {
                        return device_id == device_info.descriptor.device_id;
                      }) != devices_info.end();
}

// Returns a non DirectShow descriptor DevicesInfo with the provided name and
// model.
DevicesInfo::const_iterator FindNonDirectShowDeviceInfoByNameAndModel(
    const DevicesInfo& devices_info,
    const std::string& name_and_model) {
  return std::find_if(
      devices_info.begin(), devices_info.end(),
      [name_and_model](const VideoCaptureDeviceInfo& device_info) {
        return device_info.descriptor.capture_api !=
                   VideoCaptureApi::WIN_DIRECT_SHOW &&
               name_and_model == device_info.descriptor.GetNameAndModel();
      });
}

bool IsEnclosureLocationSupported() {
  // DeviceInformation class is only available in Win10 onwards (v10.0.10240.0).
  if (base::win::GetVersion() < base::win::Version::WIN10) {
    DVLOG(1) << "DeviceInformation not supported before Windows 10";
    return false;
  }

  if (!(base::win::ResolveCoreWinRTDelayload() &&
        ScopedHString::ResolveCoreWinRTStringDelayload())) {
    DLOG(ERROR) << "Failed loading functions from combase.dll";
    return false;
  }

  return true;
}

void FindAndSetDefaultVideoCamera(
    std::vector<VideoCaptureDeviceInfo>* devices_info) {
  // When available, the default video camera should be external with
  // MEDIA_VIDEO_FACING_NONE. Otherwise, it should be internal with
  // MEDIA_VIDEO_FACING_USER. It occupies the first index in |devices_info|.
  for (auto it = devices_info->begin(); it != devices_info->end(); ++it) {
    // Default video camera belongs to KSCATEGORY_VIDEO_CAMERA.
    if (it->descriptor.device_id.find(kVideoCameraGuid) != std::string::npos) {
      if (it->descriptor.facing == VideoFacingMode::MEDIA_VIDEO_FACING_NONE) {
        std::iter_swap(devices_info->begin(), it);
        break;  // Stop iterating once an external video camera is found.
      } else if (it->descriptor.facing ==
                 VideoFacingMode::MEDIA_VIDEO_FACING_USER) {
        std::iter_swap(devices_info->begin(), it);
      }
    }
  }
}

}  // namespace

// Returns true if the current platform supports the Media Foundation API
// and that the DLLs are available.  On Vista this API is an optional download
// but the API is advertised as a part of Windows 7 and onwards.  However,
// we've seen that the required DLLs are not available in some Win7
// distributions such as Windows 7 N and Windows 7 KN.
// static
bool VideoCaptureDeviceFactoryWin::PlatformSupportsMediaFoundation() {
  static const bool has_media_foundation =
      LoadMediaFoundationDlls() && InitializeMediaFoundation();
  return has_media_foundation;
}

VideoCaptureDeviceFactoryWin::VideoCaptureDeviceFactoryWin()
    : use_media_foundation_(
          base::FeatureList::IsEnabled(media::kMediaFoundationVideoCapture)),
      use_d3d11_with_media_foundation_(
          base::FeatureList::IsEnabled(
              media::kMediaFoundationD3D11VideoCapture) &&
          switches::IsVideoCaptureUseGpuMemoryBufferEnabled()),
      com_thread_("Windows Video Capture COM Thread") {
  if (use_media_foundation_ && !PlatformSupportsMediaFoundation()) {
    use_media_foundation_ = false;
    LogVideoCaptureWinBackendUsed(
        VideoCaptureWinBackendUsed::kUsingDirectShowAsFallback);
  } else if (use_media_foundation_) {
    LogVideoCaptureWinBackendUsed(
        VideoCaptureWinBackendUsed::kUsingMediaFoundationAsDefault);
  } else {
    LogVideoCaptureWinBackendUsed(
        VideoCaptureWinBackendUsed::kUsingDirectShowAsDefault);
  }
}

VideoCaptureDeviceFactoryWin::~VideoCaptureDeviceFactoryWin() {
  if (com_thread_.IsRunning()) {
    com_thread_.Stop();
  }
}

std::unique_ptr<VideoCaptureDevice> VideoCaptureDeviceFactoryWin::CreateDevice(
    const VideoCaptureDeviceDescriptor& device_descriptor) {
  DCHECK(thread_checker_.CalledOnValidThread());
  switch (device_descriptor.capture_api) {
    case VideoCaptureApi::WIN_MEDIA_FOUNDATION:
      FALLTHROUGH;
    case VideoCaptureApi::WIN_MEDIA_FOUNDATION_SENSOR: {
      DCHECK(PlatformSupportsMediaFoundation());
      ComPtr<IMFMediaSource> source;
      if (!CreateDeviceSourceMediaFoundation(device_descriptor.device_id,
                                             device_descriptor.capture_api,
                                             &source)) {
        break;
      }
      auto device = std::make_unique<VideoCaptureDeviceMFWin>(
          device_descriptor, std::move(source), dxgi_device_manager_);
      DVLOG(1) << " MediaFoundation Device: "
               << device_descriptor.display_name();
      if (device->Init())
        return device;
      break;
    }
    case VideoCaptureApi::WIN_DIRECT_SHOW: {
      ComPtr<IBaseFilter> capture_filter;
      if (!CreateDeviceFilterDirectShow(device_descriptor.device_id,
                                        &capture_filter)) {
        break;
      }
      auto device = std::make_unique<VideoCaptureDeviceWin>(
          device_descriptor, std::move(capture_filter));
      DVLOG(1) << " DirectShow Device: " << device_descriptor.display_name();
      if (device->Init())
        return device;
      break;
    }
    default:
      NOTREACHED();
      break;
  }
  return nullptr;
}

bool VideoCaptureDeviceFactoryWin::CreateDeviceEnumMonikerDirectShow(
    IEnumMoniker** enum_moniker) {
  DCHECK(enum_moniker);
  DCHECK(!*enum_moniker);

  // Mitigate the issues caused by loading DLLs on a background thread
  // (http://crbug/973868).
  SCOPED_MAY_LOAD_LIBRARY_AT_BACKGROUND_PRIORITY();

  ComPtr<ICreateDevEnum> dev_enum;
  HRESULT hr = ::CoCreateInstance(CLSID_SystemDeviceEnum, nullptr,
                                  CLSCTX_INPROC, IID_PPV_ARGS(&dev_enum));
  if (FAILED(hr)) {
    DLOG(ERROR) << "Failed to create system device enumerator: "
                << logging::SystemErrorCodeToString(hr);
    return false;
  }

  hr = dev_enum->CreateClassEnumerator(CLSID_VideoInputDeviceCategory,
                                       enum_moniker, 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) {
    DLOG(ERROR) << "Failed to create video input device enum moniker: "
                << logging::SystemErrorCodeToString(hr);
    return false;
  }

  return true;
}

bool VideoCaptureDeviceFactoryWin::CreateDeviceFilterDirectShow(
    const std::string& device_id,
    IBaseFilter** capture_filter) {
  DCHECK(capture_filter);
  DCHECK(!*capture_filter);

  ComPtr<IEnumMoniker> enum_moniker;
  if (!CreateDeviceEnumMonikerDirectShow(&enum_moniker))
    return false;

  HRESULT hr = S_OK;
  for (ComPtr<IMoniker> moniker;
       enum_moniker->Next(1, &moniker, nullptr) == 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)
        continue;  // Continue to the next property.
      const std::string device_path(base::SysWideToUTF8(V_BSTR(name.ptr())));
      if (device_path.compare(device_id) != 0)
        break;  // Continue to the next moniker.
      // We have found the requested device.
      return CreateDeviceFilterDirectShow(std::move(moniker), capture_filter);
    }
  }

  if (SUCCEEDED(hr))
    hr = HRESULT_FROM_WIN32(ERROR_NOT_FOUND);
  DLOG(ERROR) << "Failed to find camera filter: "
              << logging::SystemErrorCodeToString(hr);
  return false;
}

bool VideoCaptureDeviceFactoryWin::CreateDeviceFilterDirectShow(
    ComPtr<IMoniker> moniker,
    IBaseFilter** capture_filter) {
  DCHECK(capture_filter);
  DCHECK(!*capture_filter);

  // Mitigate the issues caused by loading DLLs on a background thread
  // (http://crbug/973868).
  SCOPED_MAY_LOAD_LIBRARY_AT_BACKGROUND_PRIORITY_REPEATEDLY();

  HRESULT hr = moniker->BindToObject(0, 0, IID_PPV_ARGS(capture_filter));
  if (FAILED(hr)) {
    DLOG(ERROR) << "Failed to bind camera filter: "
                << logging::SystemErrorCodeToString(hr);
    return false;
  }
  return true;
}

bool VideoCaptureDeviceFactoryWin::CreateDeviceSourceMediaFoundation(
    const std::string& device_id,
    VideoCaptureApi capture_api,
    IMFMediaSource** source) {
  DCHECK(source);
  DCHECK(!*source);

  ComPtr<IMFAttributes> attributes;
  DCHECK_EQ(GetMFAttributes()[0].first, VideoCaptureApi::WIN_MEDIA_FOUNDATION);
  const auto& attributes_data =
      capture_api == VideoCaptureApi::WIN_MEDIA_FOUNDATION
          ? GetMFAttributes()[0].second
          : GetMFAttributes()[1].second;
  // We allocate attributes_data.size() + 1 (+1 is for sym_link below) elements
  // in attributes store.
  if (!PrepareVideoCaptureAttributesMediaFoundation(
          attributes_data, attributes_data.size() + 1, &attributes)) {
    return false;
  }

  attributes->SetString(MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_SYMBOLIC_LINK,
                        base::SysUTF8ToWide(device_id).c_str());

  return CreateDeviceSourceMediaFoundation(std::move(attributes), source);
}

bool VideoCaptureDeviceFactoryWin::CreateDeviceSourceMediaFoundation(
    ComPtr<IMFAttributes> attributes,
    IMFMediaSource** source_out) {
  ComPtr<IMFMediaSource> source;
  HRESULT hr = MFCreateDeviceSource(attributes.Get(), &source);
  DLOG_IF(ERROR, FAILED(hr)) << "MFCreateDeviceSource failed: "
                             << logging::SystemErrorCodeToString(hr);
  if (SUCCEEDED(hr) && use_d3d11_with_media_foundation_ &&
      dxgi_device_manager_) {
    dxgi_device_manager_->RegisterWithMediaSource(source);
  }
  *source_out = source.Detach();
  return SUCCEEDED(hr);
}

bool VideoCaptureDeviceFactoryWin::EnumerateDeviceSourcesMediaFoundation(
    Microsoft::WRL::ComPtr<IMFAttributes> attributes,
    IMFActivate*** devices,
    UINT32* count) {
  HRESULT hr = MFEnumDeviceSources(attributes.Get(), devices, count);
  DLOG_IF(ERROR, FAILED(hr))
      << "MFEnumDeviceSources failed: " << logging::SystemErrorCodeToString(hr);
  return SUCCEEDED(hr);
}

void VideoCaptureDeviceFactoryWin::GetDevicesInfo(
    GetDevicesInfoCallback callback) {
  DCHECK(thread_checker_.CalledOnValidThread());

  std::vector<VideoCaptureDeviceInfo> devices_info;

  if (use_media_foundation_) {
    DCHECK(PlatformSupportsMediaFoundation());
    devices_info = GetDevicesInfoMediaFoundation();
    AugmentDevicesListWithDirectShowOnlyDevices(&devices_info);
  } else {
    devices_info = GetDevicesInfoDirectShow();
  }

  if (IsEnclosureLocationSupported()) {
    origin_task_runner_ = base::ThreadTaskRunnerHandle::Get();
    com_thread_.init_com_with_mta(true);
    com_thread_.Start();
    com_thread_.task_runner()->PostTask(
        FROM_HERE,
        base::BindOnce(&VideoCaptureDeviceFactoryWin::EnumerateDevicesUWP,
                       base::Unretained(this), std::move(devices_info),
                       std::move(callback)));
  } else {
    DeviceInfoReady(std::move(devices_info), std::move(callback));
  }
}

void VideoCaptureDeviceFactoryWin::EnumerateDevicesUWP(
    std::vector<VideoCaptureDeviceInfo> devices_info,
    GetDevicesInfoCallback result_callback) {
  DCHECK_GE(base::win::OSInfo::GetInstance()->version_number().build, 10240u);

  VideoCaptureDeviceFactoryWin* factory = this;
  scoped_refptr<base::SingleThreadTaskRunner> com_thread_runner =
      com_thread_.task_runner();

  // The |device_info_callback| created by base::BindRepeating() is copyable,
  // which is necessary for the below lambda function of |callback| for the
  // asynchronous operation. The reason is to permanently capture anything in a
  // lambda, it must be copyable, merely movable is insufficient.
  auto device_info_callback = base::BindRepeating(
      &VideoCaptureDeviceFactoryWin::FoundAllDevicesUWP,
      base::Unretained(factory), base::Passed(&devices_info),
      base::Passed(&result_callback));
  auto callback =
      Microsoft::WRL::Callback<
          ABI::Windows::Foundation::IAsyncOperationCompletedHandler<
              DeviceInformationCollection*>>(
          [com_thread_runner, device_info_callback](
              IAsyncOperation<DeviceInformationCollection*>* operation,
              AsyncStatus status) -> HRESULT {
            com_thread_runner->PostTask(
                FROM_HERE, base::BindOnce(device_info_callback,
                                          base::Unretained(operation)));
            return S_OK;
          });

  ComPtr<ABI::Windows::Devices::Enumeration::IDeviceInformationStatics>
      dev_info_statics;
  HRESULT hr = GetActivationFactory<
      ABI::Windows::Devices::Enumeration::IDeviceInformationStatics,
      RuntimeClass_Windows_Devices_Enumeration_DeviceInformation>(
      &dev_info_statics);
  if (FAILED(hr)) {
    UWP_ENUM_ERROR_HANDLER(hr, "DeviceInformation factory failed: ");
    return;
  }

  IAsyncOperation<DeviceInformationCollection*>* async_op;
  ScopedHString aqs_filter =
      ScopedHString::Create(kVideoAndSensorCamerasAqsString);
  hr = dev_info_statics->FindAllAsyncAqsFilter(aqs_filter.get(), &async_op);
  if (FAILED(hr)) {
    UWP_ENUM_ERROR_HANDLER(hr, "Find all devices asynchronously failed: ");
    return;
  }

  hr = async_op->put_Completed(callback.Get());
  if (FAILED(hr)) {
    UWP_ENUM_ERROR_HANDLER(hr, "Register async operation callback failed: ");
    return;
  }

  // Keep a reference to incomplete |asyn_op| for releasing later.
  async_ops_.insert(async_op);
}

void VideoCaptureDeviceFactoryWin::FoundAllDevicesUWP(
    std::vector<VideoCaptureDeviceInfo> devices_info,
    GetDevicesInfoCallback result_callback,
    IAsyncOperation<DeviceInformationCollection*>* operation) {
  if (!operation) {
    origin_task_runner_->PostTask(
        FROM_HERE,
        base::BindOnce(&VideoCaptureDeviceFactoryWin::DeviceInfoReady,
                       weak_ptr_factory_.GetWeakPtr(), std::move(devices_info),
                       std::move(result_callback)));
    return;
  }

  ComPtr<ABI::Windows::Foundation::Collections::IVectorView<
      ABI::Windows::Devices::Enumeration::DeviceInformation*>>
      devices;
  operation->GetResults(&devices);

  unsigned int count = 0;
  if (devices) {
    devices->get_Size(&count);
  }

  for (unsigned int j = 0; j < count; ++j) {
    ComPtr<ABI::Windows::Devices::Enumeration::IDeviceInformation> device_info;
    HRESULT hr = devices->GetAt(j, &device_info);
    if (SUCCEEDED(hr)) {
      HSTRING id;
      device_info->get_Id(&id);

      std::string device_id = ScopedHString(id).GetAsUTF8();
      transform(device_id.begin(), device_id.end(), device_id.begin(),
                ::tolower);

      ComPtr<ABI::Windows::Devices::Enumeration::IEnclosureLocation>
          enclosure_location;
      hr = device_info->get_EnclosureLocation(&enclosure_location);
      if (FAILED(hr)) {
        break;
      }

      VideoFacingMode facing = VideoFacingMode::MEDIA_VIDEO_FACING_NONE;
      if (enclosure_location) {
        ABI::Windows::Devices::Enumeration::Panel panel;
        enclosure_location->get_Panel(&panel);
        switch (panel) {
          case ABI::Windows::Devices::Enumeration::Panel_Unknown:
            facing = VideoFacingMode::MEDIA_VIDEO_FACING_NONE;
            break;
          case ABI::Windows::Devices::Enumeration::Panel_Front:
            facing = VideoFacingMode::MEDIA_VIDEO_FACING_USER;
            break;
          case ABI::Windows::Devices::Enumeration::Panel_Back:
            facing = VideoFacingMode::MEDIA_VIDEO_FACING_ENVIRONMENT;
            break;
          default:
            facing = VideoFacingMode::MEDIA_VIDEO_FACING_NONE;
        }
      }

      for (auto& device : devices_info) {
        if (!device.descriptor.device_id.compare(device_id)) {
          device.descriptor.facing = facing;
          break;
        }
      }
    }
  }

  FindAndSetDefaultVideoCamera(&devices_info);

  origin_task_runner_->PostTask(
      FROM_HERE, base::BindOnce(&VideoCaptureDeviceFactoryWin::DeviceInfoReady,
                                base::Unretained(this), std::move(devices_info),
                                std::move(result_callback)));

  auto it = async_ops_.find(operation);
  DCHECK(it != async_ops_.end());
  (*it)->Release();
  async_ops_.erase(it);
}

void VideoCaptureDeviceFactoryWin::DeviceInfoReady(
    std::vector<VideoCaptureDeviceInfo> devices_info,
    GetDevicesInfoCallback result_callback) {
  if (com_thread_.IsRunning()) {
    com_thread_.Stop();
  }

  std::move(result_callback).Run(std::move(devices_info));
}

DevicesInfo VideoCaptureDeviceFactoryWin::GetDevicesInfoMediaFoundation() {
  DVLOG(1) << " GetDevicesInfoMediaFoundation";

  DevicesInfo devices_info;

  if (use_d3d11_with_media_foundation_ && !dxgi_device_manager_) {
    dxgi_device_manager_ = DXGIDeviceManager::Create();
  }

  // Recent non-RGB (depth, IR) cameras could be marked as sensor cameras in
  // driver inf file and MFEnumDeviceSources enumerates them only if attribute
  // KSCATEGORY_SENSOR_CAMERA is supplied. We enumerate twice. As it is possible
  // that SENSOR_CAMERA is also in VIDEO_CAMERA category, we prevent duplicate
  // entries. https://crbug.com/807293
  for (const auto& api_attributes : GetMFAttributes()) {
    ComPtr<IMFAttributes> attributes;
    if (!PrepareVideoCaptureAttributesMediaFoundation(
            api_attributes.second, api_attributes.second.size(), &attributes)) {
      return {};
    }
    ScopedCoMem<IMFActivate*> devices;
    UINT32 count;
    if (!EnumerateDeviceSourcesMediaFoundation(std::move(attributes), &devices,
                                               &count)) {
      return {};
    }
    const bool list_was_empty = devices_info.empty();
    for (UINT32 i = 0; i < count; ++i) {
      ScopedCoMem<wchar_t> name;
      UINT32 name_size;
      HRESULT hr = devices[i]->GetAllocatedString(
          MF_DEVSOURCE_ATTRIBUTE_FRIENDLY_NAME, &name, &name_size);
      if (SUCCEEDED(hr)) {
        ScopedCoMem<wchar_t> id;
        UINT32 id_size;
        hr = devices[i]->GetAllocatedString(
            MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_SYMBOLIC_LINK, &id,
            &id_size);
        if (SUCCEEDED(hr)) {
          const std::string device_id =
              base::SysWideToUTF8(std::wstring(id, id_size));
          const std::string model_id = GetDeviceModelId(device_id);
          const std::string display_name =
              base::SysWideToUTF8(std::wstring(name, name_size));
          if (IsDeviceBlockedForMediaFoundationByModelId(model_id) ||
              IsDeviceBlockedForMediaFoundationByDisplayName(display_name)) {
            continue;
          }
          if (list_was_empty ||
              !DevicesInfoContainsDeviceId(devices_info, device_id)) {
            ComPtr<IMFMediaSource> source;
            VideoCaptureControlSupport control_support;
            VideoCaptureFormats supported_formats;
            if (CreateDeviceSourceMediaFoundation(
                    device_id, api_attributes.first, &source)) {
              control_support =
                  VideoCaptureDeviceMFWin::GetControlSupport(source);
              supported_formats =
                  GetSupportedFormatsMediaFoundation(source, display_name);
            }
            devices_info.emplace_back(VideoCaptureDeviceDescriptor(
                display_name, device_id, model_id, api_attributes.first,
                control_support));
            devices_info.back().supported_formats =
                std::move(supported_formats);
          }
        }
      }
      DLOG_IF(ERROR, FAILED(hr)) << "GetAllocatedString failed: "
                                 << logging::SystemErrorCodeToString(hr);
      devices[i]->Release();
    }
  }

  return devices_info;
}

// Adds descriptors that are only reported by the DirectShow API.
// Replaces MediaFoundation descriptors with corresponding DirectShow
// ones if the MediaFoundation one has no supported formats,
// but the DirectShow one does.
void VideoCaptureDeviceFactoryWin::AugmentDevicesListWithDirectShowOnlyDevices(
    DevicesInfo* devices_info) {
  // DirectShow virtual cameras are not supported by MediaFoundation.
  // To overcome this, based on device name and model, we append
  // missing DirectShow device descriptor to full devices list.
  DevicesInfo direct_show_devices_info = GetDevicesInfoDirectShow();
  for (const auto& direct_show_device_info : direct_show_devices_info) {
    // DirectShow can produce two descriptors with same name and model.
    // If those descriptors are missing from MediaFoundation, we want them both
    // appended to the full descriptors list.
    // Therefore, we prevent duplication by always comparing a DirectShow
    // descriptor with a MediaFoundation one.

    DevicesInfo::const_iterator matching_non_direct_show_device =
        FindNonDirectShowDeviceInfoByNameAndModel(
            *devices_info,
            direct_show_device_info.descriptor.GetNameAndModel());

    // Devices like the Pinnacle Dazzle, appear both in DirectShow and
    // MediaFoundation. In MediaFoundation, they will have no supported video
    // format while in DirectShow they will have at least one video format.
    // Therefore, we must prioritize the MediaFoundation descriptor if it has at
    // least one supported format
    if (matching_non_direct_show_device != devices_info->end()) {
      if (matching_non_direct_show_device->supported_formats.size() > 0)
        continue;
      if (direct_show_device_info.supported_formats.size() == 0)
        continue;
      devices_info->erase(matching_non_direct_show_device);
    }
    devices_info->emplace_back(direct_show_device_info);
  }
}

DevicesInfo VideoCaptureDeviceFactoryWin::GetDevicesInfoDirectShow() {
  DVLOG(1) << __func__;

  ComPtr<IEnumMoniker> enum_moniker;
  if (!CreateDeviceEnumMonikerDirectShow(&enum_moniker))
    return {};

  DevicesInfo devices_info;

  // Enumerate all video capture devices.
  for (ComPtr<IMoniker> moniker;
       enum_moniker->Next(1, &moniker, nullptr) == S_OK; moniker.Reset()) {
    ComPtr<IPropertyBag> prop_bag;
    HRESULT hr = moniker->BindToStorage(0, 0, IID_PPV_ARGS(&prop_bag));
    if (FAILED(hr))
      continue;

    // Find the description or friendly name.
    ScopedVariant name;
    hr = prop_bag->Read(L"Description", name.Receive(), 0);
    if (FAILED(hr))
      hr = prop_bag->Read(L"FriendlyName", name.Receive(), 0);

    if (FAILED(hr) || name.type() != VT_BSTR)
      continue;

    const std::string device_name(base::SysWideToUTF8(V_BSTR(name.ptr())));
    if (IsDeviceBlocked(device_name))
      continue;

    name.Reset();
    hr = prop_bag->Read(L"DevicePath", name.Receive(), 0);
    std::string id;
    if (FAILED(hr) || name.type() != VT_BSTR) {
      id = device_name;
    } else {
      DCHECK_EQ(name.type(), VT_BSTR);
      id = base::SysWideToUTF8(V_BSTR(name.ptr()));
    }

    const std::string model_id = GetDeviceModelId(id);

    VideoCaptureControlSupport control_support;
    VideoCaptureFormats supported_formats;
    ComPtr<IBaseFilter> capture_filter;
    if (CreateDeviceFilterDirectShow(std::move(moniker), &capture_filter)) {
      control_support =
          VideoCaptureDeviceWin::GetControlSupport(capture_filter);
      supported_formats =
          GetSupportedFormatsDirectShow(capture_filter, device_name);
    }

    devices_info.emplace_back(VideoCaptureDeviceDescriptor(
        device_name, id, model_id, VideoCaptureApi::WIN_DIRECT_SHOW,
        control_support));
    devices_info.back().supported_formats = std::move(supported_formats);
  }

  return devices_info;
}

VideoCaptureFormats VideoCaptureDeviceFactoryWin::GetSupportedFormatsDirectShow(
    ComPtr<IBaseFilter> capture_filter,
    const std::string& display_name) {
  VideoCaptureFormats formats;
  bool query_detailed_frame_rates =
      !IsDeviceBlockedForQueryingDetailedFrameRates(display_name);
  CapabilityList capability_list;
  VideoCaptureDeviceWin::GetDeviceCapabilityList(
      capture_filter, query_detailed_frame_rates, &capability_list);
  for (const auto& entry : capability_list) {
    formats.emplace_back(entry.supported_format);
    DVLOG(1) << display_name << " "
             << VideoCaptureFormat::ToString(entry.supported_format);
  }
  return formats;
}

VideoCaptureFormats
VideoCaptureDeviceFactoryWin::GetSupportedFormatsMediaFoundation(
    ComPtr<IMFMediaSource> source,
    const std::string& display_name) {
  ComPtr<IMFAttributes> source_reader_attributes;
  if (dxgi_device_manager_) {
    dxgi_device_manager_->RegisterWithMediaSource(source);

    HRESULT hr = MFCreateAttributes(&source_reader_attributes, 1);
    if (SUCCEEDED(hr)) {
      dxgi_device_manager_->RegisterInSourceReaderAttributes(
          source_reader_attributes.Get());
    } else {
      DLOG(ERROR) << "MFCreateAttributes failed: "
                  << logging::SystemErrorCodeToString(hr);
    }
  }

  ComPtr<IMFSourceReader> reader;
  HRESULT hr = MFCreateSourceReaderFromMediaSource(
      source.Get(), source_reader_attributes.Get(), &reader);
  if (FAILED(hr)) {
    DLOG(ERROR) << "MFCreateSourceReaderFromMediaSource failed: "
                << logging::SystemErrorCodeToString(hr);
    return {};
  }

  VideoCaptureFormats formats;

  DWORD stream_index = 0;
  ComPtr<IMFMediaType> type;
  const bool dxgi_device_manager_available = dxgi_device_manager_ != nullptr;
  while (SUCCEEDED(hr = reader->GetNativeMediaType(
                       static_cast<DWORD>(MF_SOURCE_READER_FIRST_VIDEO_STREAM),
                       stream_index, &type))) {
    UINT32 width, height;
    hr = MFGetAttributeSize(type.Get(), MF_MT_FRAME_SIZE, &width, &height);
    if (FAILED(hr)) {
      DLOG(ERROR) << "MFGetAttributeSize failed: "
                  << logging::SystemErrorCodeToString(hr);
      return {};
    }
    VideoCaptureFormat capture_format;
    capture_format.frame_size.SetSize(width, height);

    UINT32 numerator, denominator;
    hr = MFGetAttributeRatio(type.Get(), MF_MT_FRAME_RATE, &numerator,
                             &denominator);
    if (FAILED(hr)) {
      DLOG(ERROR) << "MFGetAttributeSize failed: "
                  << logging::SystemErrorCodeToString(hr);
      return {};
    }
    capture_format.frame_rate =
        denominator ? static_cast<float>(numerator) / denominator : 0.0f;

    GUID type_guid;
    hr = type->GetGUID(MF_MT_SUBTYPE, &type_guid);
    if (FAILED(hr)) {
      DLOG(ERROR) << "GetGUID failed: " << logging::SystemErrorCodeToString(hr);
      return {};
    }
    VideoCaptureDeviceMFWin::GetPixelFormatFromMFSourceMediaSubtype(
        type_guid, /*use_hardware_format=*/dxgi_device_manager_available,
        &capture_format.pixel_format);
    type.Reset();
    ++stream_index;
    if (capture_format.pixel_format == PIXEL_FORMAT_UNKNOWN)
      continue;
    formats.push_back(capture_format);

    DVLOG(1) << display_name << " "
             << VideoCaptureFormat::ToString(capture_format);
  }

  return formats;
}

}  // namespace media