qpipewire_cameradevicemonitor.cpp

Go to the documentation of this file.

// Copyright (C) 2026 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 "qpipewire_cameradevicemonitor_p.h"
 
#include <QtMultimedia/private/qcameradevice_p.h>
#include <QtMultimedia/private/qpipewire_async_support_p.h>
#include <QtMultimedia/private/qpipewire_cameracontextmanager_p.h>
#include <QtMultimedia/private/qpipewire_cameranode_p.h>
#include <QtMultimedia/private/qmultimedia_ranges_p.h>
#include <QtCore/qcoreapplication.h>
#include <QtCore/qloggingcategory.h>
#include <QtCore/qthread.h>
 
#include <spa/param/param.h>
 
QT_BEGIN_NAMESPACE
 
namespace QtPipeWire {
 
Q_STATIC_LOGGING_CATEGORY(lcPipewireCameraMonitor, "qt.multimedia.pipewire.camera.devicemonitor")
 
std::vector<QCameraDeviceMonitor::CameraNode> QCameraDeviceMonitor::cameraNodes() const
{
    using namespace QtMultimediaPrivate;
 
    std::vector<CameraNode> result = [&] {
        std::lock_guard guard{ m_mutex };
        return m_nodes | views::values | ranges::to<std::vector>();
    }();
 
    ranges::sort(result, [](const CameraNode &lhs, const CameraNode &rhs) {
        return cameraDeviceId(lhs.properties) < cameraDeviceId(rhs.properties);
    });
 
    return result;
}
 
QCameraDeviceMonitor::QCameraDeviceMonitor()
{
    if (!QThread::isMainThread())
        // ensure that device monitor runs on application thread
        moveToThread(qApp->thread());
}
 
std::optional<ObjectId> QCameraDeviceMonitor::findCameraNode(QByteArrayView deviceId) const
{
    std::lock_guard guard{ m_mutex };
 
    for (const auto &[id, node] : m_nodes) {
        if (cameraDeviceId(node.properties) == deviceId)
            return id;
    }
 
    return std::nullopt;
}
 
std::optional<QByteArray> QCameraDeviceMonitor::findTargetObject(QByteArrayView deviceId) const
{
    std::lock_guard guard{ m_mutex };
 
    for (const auto &[id, node] : m_nodes) {
        if (cameraDeviceId(node.properties) != deviceId)
            continue;
 
        // The serial is unambiguous and survives a node name being reused.
        if (std::optional<ObjectSerial> serial = getObjectSerial(node.properties))
            return QByteArray::number(qulonglong(serial->value));
 
        if (std::optional<std::string_view> nodeName = getNodeName(node.properties))
            return QByteArray(nodeName->data(), qsizetype(nodeName->size()));
 
        return std::nullopt;
    }
 
    return std::nullopt;
}
 
const PwPropertyDict *
QCameraDeviceMonitor::findDeviceProperties(const PwPropertyDict &nodeProperties) const
{
    const std::optional<ObjectId> deviceId = getDeviceId(nodeProperties);
    if (!deviceId)
        return nullptr;
 
    const auto device = m_devices.find(*deviceId);
    if (device == m_devices.end())
        return nullptr;
 
    return &device->second.properties;
}
 
namespace {
 
std::vector<SpaObjectVideoFormat> enumerateNodeFormats(QCameraContextManager &context,
                                                       ObjectId node)
{
    using namespace std::chrono_literals;
    QPipeWireInstance &pwInstance = context.pwInstance();
 
    auto formats = std::make_shared<std::vector<SpaObjectVideoFormat>>();
 
    auto onParam = [formats](int /*seq*/, uint32_t /*id*/, uint32_t /*index*/, uint32_t /*next*/,
                             const spa_pod *param) {
        if (std::optional<SpaObjectVideoFormat> format = SpaObjectVideoFormat::parse(param))
            formats->push_back(std::move(*format));
    };
 
    std::optional<NodeEventListener> listener;
 
    pwInstance.runWithEventLoopLock([&] {
        listener.emplace(context.bindNode(node),
                         NodeEventListener::NodeHandler{
                                 {},
                                 std::move(onParam),
                         });
        listener->enumParams(SPA_PARAM_EnumFormat);
    });
 
    CoreEventSyncHelper sync;
    // wait for the enumeration to complete, so that we can return the formats to the caller.
    auto syncOrErr = sync.sync(context.coreConnection().get(), 3s);
    if (syncOrErr != true)
        qCWarning(lcPipewireCameraMonitor) << "timed out enumerating the formats of node" << node;
 
    // The listener has to go before the formats are handed out, so that no
    // further param event can append to them.
    listener.reset();
 
    return std::move(*formats);
}
 
} // namespace
 
QList<QCameraDevice> QCameraDeviceMonitor::cameraDevices()
{
    QCameraContextManager &context = *QCameraContextManager::instance();
    Q_ASSERT(!context.isInPwThreadLoop());
 
    // Make sure everything the server had to say about the graph has arrived
    // before deciding which cameras there are.
    context.syncRegistry();
 
    QList<QCameraDevice> result;
 
    for (const CameraNode &node : cameraNodes()) {
        const QByteArray id = cameraDeviceId(node.properties);
        if (id.isEmpty())
            continue;
 
        const std::vector<SpaObjectVideoFormat> formats = enumerateNodeFormats(context, node.id);
 
        auto info = std::make_unique<QCameraDevicePrivate>();
        info->id = id;
        info->description = cameraDescription(node.properties, node.deviceProperties);
        info->position = cameraPosition(node.properties);
        info->videoFormats = toCameraFormats(formats);
 
        if (info->videoFormats.isEmpty()) {
            qCDebug(lcPipewireCameraMonitor) << "skipping camera without usable formats" << id;
            continue;
        }
 
        for (const QCameraFormat &format : info->videoFormats) {
            if (!info->photoResolutions.contains(format.resolution()))
                info->photoResolutions.push_back(format.resolution());
        }
 
        // PipeWire has no notion of a default video source, unlike
        // default.audio.source, so the first camera in a stable order it is.
        info->isDefault = result.isEmpty();
 
        result.push_back(QCameraDevicePrivate::create(std::move(info)));
    }
 
    return result;
}
 
void QCameraDeviceMonitor::objectAdded(ObjectId id, PipewireRegistryType type,
                                       const spa_dict &properties)
{
    using namespace QtMultimediaPrivate;
    bool changed = false;
 
    switch (type) {
    case PipewireRegistryType::Device: {
        PwPropertyDict dict = toPropertyDict(properties);
 
        std::lock_guard guard{ m_mutex };
        m_devices[id] = DeviceRecord{ std::move(dict) };
 
        // A device may show up after the nodes that belong to it, so the
        // descriptions of those nodes can change now.
        for (auto &[nodeId, node] : m_nodes) {
            if (getDeviceId(node.properties) == id) {
                node.deviceProperties = m_devices[id].properties;
                changed = true;
            }
        }
        break;
    }
 
    case PipewireRegistryType::Node: {
        PwPropertyDict dict = toPropertyDict(properties);
        if (!isCameraNode(dict))
            return;
 
        qCDebug(lcPipewireCameraMonitor) << "camera node added" << id << cameraDeviceId(dict);
 
        CameraNode node{
            id,
            std::move(dict),
            PwPropertyDict{},
        };
 
        std::lock_guard guard{ m_mutex };
        if (const PwPropertyDict *deviceProperties = findDeviceProperties(node.properties))
            node.deviceProperties = *deviceProperties;
 
        m_nodes.insert_or_assign(id, std::move(node));
        changed = true;
        break;
    }
 
    default:
        return;
    }
 
    if (changed)
        emit camerasChanged();
}
 
void QCameraDeviceMonitor::objectRemoved(ObjectId id)
{
    bool changed = false;
 
    {
        std::lock_guard guard{ m_mutex };
 
        if (m_nodes.erase(id) != 0) {
            qCDebug(lcPipewireCameraMonitor) << "camera node removed" << id;
            changed = true;
        }
 
        if (m_devices.erase(id) != 0) {
            // Drop the borrowed description of any node that outlives its
            // device, rather than keeping stale properties around.
            for (auto &[nodeId, node] : m_nodes) {
                if (getDeviceId(node.properties) == id) {
                    node.deviceProperties.clear();
                    changed = true;
                }
            }
        }
    }
 
    if (changed)
        emit camerasChanged();
}
 
} // namespace QtPipeWire
 
QT_END_NAMESPACE