Revision control
++ // Copyright (C) 2023 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 "qv4l2cameradevices_p.h"
++
++ #include <QtMultimedia/private/qcameradevice_p.h>
++ #include <QtMultimedia/private/qmultimediautils_p.h>
++ #include <QtMultimedia/private/qv4l2camera_p.h>
++ #include <QtMultimedia/private/qv4l2filedescriptor_p.h>
++ #include <QtCore/qdebug.h>
++ #include <QtCore/qdir.h>
++ #include <QtCore/qfile.h>
++ #include <QtCore/qloggingcategory.h>
++ #include <QtCore/private/qcore_unix_p.h>
++
++ #include <linux/videodev2.h>
++
++ QT_BEGIN_NAMESPACE
++
++ namespace QtV4L2 {
++
++ Q_STATIC_LOGGING_CATEGORY(qLcV4L2CameraDevices, "qt.multimedia.v4l2.cameradevices");
++
++ static bool areCamerasEqual(QSpan<const QCameraDevice> a, QSpan<const QCameraDevice> b)
++ {
++ auto areCamerasDataEqual = [](const QCameraDevice &a, const QCameraDevice &b) {
++ Q_ASSERT(QCameraDevicePrivate::handle(a));
++ Q_ASSERT(QCameraDevicePrivate::handle(b));
++ return *QCameraDevicePrivate::handle(a) == *QCameraDevicePrivate::handle(b);
++ };
++
++ return std::equal(a.cbegin(), a.cend(), b.cbegin(), b.cend(), areCamerasDataEqual);
++ }
++
++ QV4L2CameraDevices::QV4L2CameraDevices(QPlatformMediaIntegration *integration)
++ : QPlatformVideoDevices(integration)
++ {
++ m_deviceWatcher.addPath(QLatin1String("/dev"));
++ connect(&m_deviceWatcher, &QFileSystemWatcher::directoryChanged, this,
++ &QV4L2CameraDevices::checkCameras);
++ doCheckCameras();
++ }
++
++ QList<QCameraDevice> QV4L2CameraDevices::findVideoInputs() const
++ {
++ return m_cameras;
++ }
++
++ void QV4L2CameraDevices::checkCameras()
++ {
++ if (doCheckCameras())
++ onVideoInputsChanged();
++ }
++
++ bool QV4L2CameraDevices::doCheckCameras()
++ {
++ using namespace QtMultimediaPrivate;
++
++ QList<QCameraDevice> newCameras;
++
++ QDir dir(QLatin1String("/dev"));
++ const auto devices = dir.entryList(QDir::System);
++
++ bool first = true;
++
++ for (auto device : devices) {
++ // qCDebug(qLcV4L2Camera) << "device:" << device;
++ if (!device.startsWith(QLatin1String("video")))
++ continue;
++
++ QByteArray file = QFile::encodeName(dir.filePath(device));
++ const int fd = open(file.constData(), O_RDONLY);
++ if (fd < 0)
++ continue;
++
++ auto fileCloseGuard = qScopeGuard([fd]() {
++ close(fd);
++ });
++
++ v4l2_fmtdesc formatDesc = {};
++
++ struct v4l2_capability cap;
++ if (qt_safe_ioctl(fd, VIDIOC_QUERYCAP, &cap) < 0)
++ continue;
++
++ if (cap.device_caps & V4L2_CAP_META_CAPTURE)
++ continue;
++ if (!(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE))
++ continue;
++ if (!(cap.capabilities & V4L2_CAP_STREAMING))
++ continue;
++
++ auto camera = std::make_unique<QCameraDevicePrivate>();
++
++ camera->id = file;
++ camera->description = QString::fromUtf8((const char *)cap.card);
++ qCDebug(qLcV4L2CameraDevices) << "found camera" << camera->id << camera->description;
++
++ formatDesc.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
++
++ while (!qt_safe_ioctl(fd, VIDIOC_ENUM_FMT, &formatDesc)) {
++ auto pixelFmt = formatForV4L2Format(formatDesc.pixelformat);
++ qCDebug(qLcV4L2CameraDevices) << " " << pixelFmt;
++
++ if (pixelFmt == QVideoFrameFormat::Format_Invalid) {
++ ++formatDesc.index;
++ continue;
++ }
++
++ qCDebug(qLcV4L2CameraDevices) << "frame sizes:";
++ v4l2_frmsizeenum frameSize = {};
++ frameSize.pixel_format = formatDesc.pixelformat;
++
++ while (!qt_safe_ioctl(fd, VIDIOC_ENUM_FRAMESIZES, &frameSize)) {
++ QList<QSize> resolutions;
++ if (frameSize.type == V4L2_FRMSIZE_TYPE_DISCRETE) {
++ resolutions.append(QSize(frameSize.discrete.width, frameSize.discrete.height));
++ } else {
++ resolutions.append(
++ QSize(frameSize.stepwise.max_width, frameSize.stepwise.max_height));
++ resolutions.append(
++ QSize(frameSize.stepwise.min_width, frameSize.stepwise.min_height));
++ }
++
++ for (auto resolution : resolutions) {
++ float min = 1e10;
++ float max = 0;
++ auto updateMaxMinFrameRate = [&max, &min](auto discreteFrameRate) {
++ const float rate = float(discreteFrameRate.denominator)
++ / float(discreteFrameRate.numerator);
++ if (rate > max)
++ max = rate;
++ if (rate < min)
++ min = rate;
++ };
++
++ v4l2_frmivalenum frameInterval = {};
++ frameInterval.pixel_format = formatDesc.pixelformat;
++ frameInterval.width = resolution.width();
++ frameInterval.height = resolution.height();
++
++ while (!qt_safe_ioctl(fd, VIDIOC_ENUM_FRAMEINTERVALS, &frameInterval)) {
++ if (frameInterval.type == V4L2_FRMIVAL_TYPE_DISCRETE) {
++ updateMaxMinFrameRate(frameInterval.discrete);
++ } else {
++ updateMaxMinFrameRate(frameInterval.stepwise.max);
++ updateMaxMinFrameRate(frameInterval.stepwise.min);
++ }
++ ++frameInterval.index;
++ }
++
++ qCDebug(qLcV4L2CameraDevices) << " " << resolution << min << max;
++
++ if (min <= max) {
++ auto fmt = std::make_unique<QCameraFormatPrivate>();
++ fmt->pixelFormat = pixelFmt;
++ fmt->resolution = resolution;
++ fmt->minFrameRate = min;
++ fmt->maxFrameRate = max;
++ camera->videoFormats.append(fmt.release()->create());
++ camera->photoResolutions.append(resolution);
++ }
++ }
++ ++frameSize.index;
++ }
++ ++formatDesc.index;
++ }
++
++ if (camera->videoFormats.empty())
++ continue;
++
++ // first camera is default
++ camera->isDefault = std::exchange(first, false);
++
++ newCameras.append(camera.release()->create());
++ }
++
++ if (areCamerasEqual(m_cameras, newCameras))
++ return false;
++
++ m_cameras = std::move(newCameras);
++ return true;
++ }
++
++ } // namespace QtV4L2
++
++ QT_END_NAMESPACE
++
++ #include "moc_qv4l2cameradevices_p.cpp"