Revision control
Copy as Markdown
// Copyright (C) 2022 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
#include "qwindowsvideodevices_p.h"
#include <QtCore/quuid.h>
#include <QtCore/private/qcomptr_p.h>
#include <QtCore/private/qfunctions_win_p.h>
#include <QtMultimedia/private/qcameradevice_p.h>
#include <QtMultimedia/private/qcomtaskresource_p.h>
#include <QtMultimedia/private/qwindowsmultimediautils_p.h>
#include <dbt.h>
#include <mfapi.h>
#include <mfidl.h>
#include <mfreadwrite.h>
#include <mferror.h>
#include <ks.h>
// MinGW-13.1 workaround
#ifndef KSCATEGORY_SENSOR_CAMERA
static constexpr GUID KSCATEGORY_SENSOR_CAMERA = {
0x24e552d7, 0x6523, 0x47f7, { 0xa6, 0x47, 0xd3, 0x46, 0x5b, 0xf1, 0xf5, 0xca }
};
#endif
QT_BEGIN_NAMESPACE
namespace {
LRESULT QT_WIN_CALLBACK deviceNotificationWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
if (message == WM_DEVICECHANGE) {
auto b = (PDEV_BROADCAST_HDR)lParam;
if (b && b->dbch_devicetype == DBT_DEVTYP_DEVICEINTERFACE) {
auto wmd = reinterpret_cast<QWindowsVideoDevices *>(GetWindowLongPtr(hWnd, GWLP_USERDATA));
if (wmd) {
if (wParam == DBT_DEVICEARRIVAL || wParam == DBT_DEVICEREMOVECOMPLETE) {
wmd->onVideoInputsChanged();
}
}
}
}
return 1;
}
LPCWSTR getWindowsClassName()
{
// each Qt instance should have its own window class name to prevent name clashes when multiple
// qt instances are used in the same process.
// appending a uuid is good enough to ensure that.
static const std::wstring singleton =
QString(QStringLiteral("QWindowsMediaDevicesMessageWindow_")
+ QUuid::createUuid().toString())
.toStdWString();
Q_ASSERT(singleton.size() < 256 && "The maximum length for lpszClassName is 256");
return singleton.c_str();
}
HWND createMessageOnlyWindow()
{
WNDCLASSEX wx = {};
wx.cbSize = sizeof(WNDCLASSEX);
wx.lpfnWndProc = deviceNotificationWndProc;
wx.hInstance = GetModuleHandle(nullptr);
wx.lpszClassName = getWindowsClassName();
if (!RegisterClassEx(&wx))
return nullptr;
auto hwnd = CreateWindowEx(0, getWindowsClassName(), TEXT("Message"), 0, 0, 0, 0, 0,
HWND_MESSAGE, nullptr, nullptr, nullptr);
if (!hwnd) {
UnregisterClass(getWindowsClassName(), GetModuleHandle(nullptr));
return nullptr;
}
return hwnd;
}
} // namespace
QWindowsVideoDevices::QWindowsVideoDevices(QPlatformMediaIntegration *integration)
: QPlatformVideoDevices(integration)
{
qt_win_ensureComInitializedOnThisThread();
m_videoDeviceMsgWindow = createMessageOnlyWindow();
if (m_videoDeviceMsgWindow) {
SetWindowLongPtr(m_videoDeviceMsgWindow, GWLP_USERDATA, (LONG_PTR)this);
DEV_BROADCAST_DEVICEINTERFACE di = {};
di.dbcc_size = sizeof(di);
di.dbcc_devicetype = DBT_DEVTYP_DEVICEINTERFACE;
di.dbcc_classguid = KSCATEGORY_VIDEO_CAMERA;
m_videoDeviceNotification =
RegisterDeviceNotification(m_videoDeviceMsgWindow, &di, DEVICE_NOTIFY_WINDOW_HANDLE);
if (!m_videoDeviceNotification) {
DestroyWindow(m_videoDeviceMsgWindow);
m_videoDeviceMsgWindow = nullptr;
UnregisterClass(getWindowsClassName(), GetModuleHandle(nullptr));
}
}
if (!m_videoDeviceNotification) {
qWarning() << "Video device change notification disabled";
}
}
QWindowsVideoDevices::~QWindowsVideoDevices()
{
if (m_videoDeviceNotification) {
UnregisterDeviceNotification(m_videoDeviceNotification);
}
if (m_videoDeviceMsgWindow) {
DestroyWindow(m_videoDeviceMsgWindow);
UnregisterClass(getWindowsClassName(), GetModuleHandle(nullptr));
}
}
static QString getString(IMFActivate *device, const IID &id)
{
QComTaskResource<WCHAR> str;
UINT32 length = 0;
HRESULT hr = device->GetAllocatedString(id, str.address(), &length);
if (SUCCEEDED(hr)) {
return QString::fromWCharArray(str.get());
} else {
return {};
}
}
static std::optional<QCameraDevice> createCameraDevice(const QWindowsMediaFoundation &wmf,
IMFActivate *device)
{
auto info = std::make_unique<QCameraDevicePrivate>();
info->description = getString(device, MF_DEVSOURCE_ATTRIBUTE_FRIENDLY_NAME);
info->id = getString(device, MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_SYMBOLIC_LINK).toUtf8();
ComPtr<IMFMediaSource> source;
HRESULT hr = device->ActivateObject(IID_PPV_ARGS(source.GetAddressOf()));
if (FAILED(hr))
return {};
ComPtr<IMFSourceReader> reader;
hr = wmf.mfCreateSourceReaderFromMediaSource(source.Get(), NULL, reader.GetAddressOf());
if (FAILED(hr))
return {};
QList<QSize> photoResolutions;
QList<QCameraFormat> videoFormats;
for (DWORD i = 0;; ++i) {
// Loop through the supported formats for the video device
ComPtr<IMFMediaType> mediaFormat;
hr = reader->GetNativeMediaType((DWORD)MF_SOURCE_READER_FIRST_VIDEO_STREAM, i,
mediaFormat.GetAddressOf());
if (FAILED(hr))
break;
auto maybeCamera = QWMF::cameraFormatFromMediaType(mediaFormat.Get());
if (maybeCamera) {
videoFormats << *maybeCamera;
photoResolutions << maybeCamera->resolution();
}
}
info->videoFormats = videoFormats;
info->photoResolutions = photoResolutions;
return info.release()->create();
}
static QList<QCameraDevice> readCameraDevices(const QWindowsMediaFoundation &wmf,
IMFAttributes *attr)
{
QList<QCameraDevice> cameras;
UINT32 count = 0;
IMFActivate **devicesRaw = nullptr;
HRESULT hr = wmf.mfEnumDeviceSources(attr, &devicesRaw, &count);
if (SUCCEEDED(hr)) {
QComTaskResource<IMFActivate *[], QComDeleter> devices(devicesRaw, count);
for (UINT32 i = 0; i < count; i++) {
IMFActivate *device = devices[i];
if (device) {
auto maybeCamera = createCameraDevice(wmf, device);
if (maybeCamera)
cameras << *maybeCamera;
}
}
}
return cameras;
}
QList<QCameraDevice> QWindowsVideoDevices::findVideoInputs() const
{
if (!m_wmf)
return {};
QList<QCameraDevice> cameras;
ComPtr<IMFAttributes> attr;
HRESULT hr = m_wmf->mfCreateAttributes(attr.GetAddressOf(), 2);
if (FAILED(hr))
return {};
hr = attr->SetGUID(MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE,
MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_GUID);
if (SUCCEEDED(hr)) {
cameras << readCameraDevices(*m_wmf, attr.Get());
hr = attr->SetGUID(MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_CATEGORY,
KSCATEGORY_SENSOR_CAMERA);
if (SUCCEEDED(hr))
cameras << readCameraDevices(*m_wmf, attr.Get());
}
return cameras;
}
QT_END_NAMESPACE