qx11surfacecapture.cpp

Go to the documentation of this file.

// 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 "qx11surfacecapture_p.h"
#include "qffmpegsurfacecapturegrabber_p.h"
 
#include <qvideoframe.h>
#include <qscreen.h>
#include <qwindow.h>
#include <qdebug.h>
#include <qguiapplication.h>
#include <qloggingcategory.h>
#include <qminmax.h>
 
#include "private/qcapturablewindow_p.h"
#include "private/qmemoryvideobuffer_p.h"
#include "private/qvideoframeconversionhelper_p.h"
#include "private/qvideoframe_p.h"
 
#include <X11/Xlib.h>
#include <sys/shm.h>
#include <X11/extensions/XShm.h>
#include <X11/Xutil.h>
#include <X11/extensions/Xrandr.h>
 
#include <optional>
#include <utility>
 
QT_BEGIN_NAMESPACE
 
Q_STATIC_LOGGING_CATEGORY(qLcX11SurfaceCapture, "qt.multimedia.ffmpeg.qx11surfacecapture");
 
namespace {
 
void destroyXImage(XImage* image) {
    XDestroyImage(image); // macro
}
 
template <typename T, typename D>
std::unique_ptr<T, D> makeXUptr(T* ptr, D deleter) {
   return std::unique_ptr<T, D>(ptr, deleter);
}
 
int screenNumberByName(Display *display, const QString &name)
{
    int size = 0;
    auto monitors = makeXUptr(
            XRRGetMonitors(display, XDefaultRootWindow(display), true, &size),
                &XRRFreeMonitors);
    const auto end = monitors.get() + size;
    auto found = std::find_if(monitors.get(), end, [&](const XRRMonitorInfo &info) {
        auto atomName = makeXUptr(XGetAtomName(display, info.name), &XFree);
        return atomName && name == QString::fromUtf8(atomName.get());
    });
 
    return found == end ? -1 : std::distance(monitors.get(), found);
}
 
QVideoFrameFormat::PixelFormat xImagePixelFormat(const XImage &image)
{
    if (image.bits_per_pixel != 32) return QVideoFrameFormat::Format_Invalid;
 
    if (image.red_mask == 0xff0000 &&
        image.green_mask == 0xff00 &&
        image.blue_mask == 0xff)
        return QVideoFrameFormat::Format_BGRX8888;
 
    if (image.red_mask == 0xff00 &&
        image.green_mask == 0xff0000 &&
        image.blue_mask == 0xff000000)
        return QVideoFrameFormat::Format_XBGR8888;
 
    if (image.blue_mask == 0xff0000 &&
        image.green_mask == 0xff00 &&
        image.red_mask == 0xff)
        return QVideoFrameFormat::Format_RGBX8888;
 
    if (image.red_mask == 0xff00 &&
        image.green_mask == 0xff0000 &&
        image.blue_mask == 0xff000000)
        return QVideoFrameFormat::Format_XRGB8888;
 
    return QVideoFrameFormat::Format_Invalid;
}
 
} // namespace
 
class QX11SurfaceCapture::Grabber : public QFFmpegSurfaceCaptureGrabber
{
public:
    static std::unique_ptr<Grabber> create(QX11SurfaceCapture &capture, QScreen *screen)
    {
        std::unique_ptr<Grabber> result(new Grabber(capture));
        return result->init(screen) ? std::move(result) : nullptr;
    }
 
    static std::unique_ptr<Grabber> create(QX11SurfaceCapture &capture, WId wid)
    {
        std::unique_ptr<Grabber> result(new Grabber(capture));
        return result->init(wid) ? std::move(result) : nullptr;
    }
 
    ~Grabber() override
    {
        stop();
 
        detachShm();
    }
 
    const QVideoFrameFormat &format() const { return m_format; }
 
private:
    Grabber(QX11SurfaceCapture &capture) : QFFmpegSurfaceCaptureGrabber()
    {
        addFrameCallback(&capture, &QX11SurfaceCapture::newVideoFrame);
        connect(this, &Grabber::errorUpdated, &capture, &QX11SurfaceCapture::updateError);
 
        m_userFrameRate = capture.frameRate();
    }
 
    bool createDisplay()
    {
        if (!m_display)
            m_display.reset(XOpenDisplay(nullptr));
 
        if (!m_display)
            updateError(QPlatformSurfaceCapture::InternalError,
                        QStringLiteral("Cannot open X11 display"));
 
        return m_display != nullptr;
    }
 
    bool init(WId wid)
    {
        const auto defaultRate = QGuiApplication::primaryScreen()
                ? qMin(QGuiApplication::primaryScreen()->refreshRate(),
                       DefaultScreenCaptureFrameRate)
                : DefaultScreenCaptureFrameRate;
        setFrameRate(m_userFrameRate.value_or(defaultRate));
 
        return createDisplay() && initWithXID(static_cast<XID>(wid));
    }
 
    bool init(QScreen *screen)
    {
        if (!screen) {
            updateError(QPlatformSurfaceCapture::NotFound, QStringLiteral("Screen Not Found"));
            return false;
        }
 
        if (!createDisplay())
            return false;
 
        auto screenNumber = screenNumberByName(m_display.get(), screen->name());
 
        if (screenNumber < 0)
            return false;
 
        setFrameRate(m_userFrameRate.value_or(
                qMin(screen->refreshRate(), DefaultScreenCaptureFrameRate)));
 
        return initWithXID(RootWindow(m_display.get(), screenNumber));
    }
 
    bool initWithXID(XID xid)
    {
        m_xid = xid;
 
        if (update()) {
            start();
            return true;
        }
 
        return false;
    }
 
    void detachShm()
    {
        if (std::exchange(m_attached, false)) {
            XShmDetach(m_display.get(), &m_shmInfo);
            shmdt(m_shmInfo.shmaddr);
            shmctl(m_shmInfo.shmid, IPC_RMID, nullptr);
        }
    }
 
    void attachShm()
    {
        Q_ASSERT(!m_attached);
 
        m_shmInfo.shmid =
                shmget(IPC_PRIVATE, m_xImage->bytes_per_line * m_xImage->height, IPC_CREAT | 0777);
 
        if (m_shmInfo.shmid == -1)
            return;
 
        m_shmInfo.readOnly = false;
        m_shmInfo.shmaddr = m_xImage->data = (char *)shmat(m_shmInfo.shmid, nullptr, 0);
 
        m_attached = XShmAttach(m_display.get(), &m_shmInfo);
    }
 
    bool update()
    {
        Window win = m_xid;
        XWindowAttributes wndattr;
        int xPos = 0;
        int yPos = 0;
        int width = 0;
        int height = 0;
        int depth = 0;
        Visual *visual = nullptr;
        while (true) {
            if (!XGetWindowAttributes(m_display.get(), win, &wndattr)) {
                updateError(QPlatformSurfaceCapture::CaptureFailed,
                            QStringLiteral("Cannot get window attributes"));
                return false;
            }
            if (win == m_xid) {
                if (wndattr.map_state != IsViewable) {
                    updateError(QPlatformSurfaceCapture::CaptureFailed,
                                QStringLiteral("Window is not viewable"));
                    return false;
                }
                width = wndattr.width;
                height = wndattr.height;
                depth = wndattr.depth;
                visual = wndattr.visual;
            }
            if (win == wndattr.root)
                break;
            xPos += wndattr.x;
            yPos += wndattr.y;
 
            Window root, *children;
            unsigned int nchildren;
            if (!XQueryTree(m_display.get(), win, &root, &win, &children, &nchildren)) {
                updateError(QPlatformSurfaceCapture::CaptureFailed,
                            QStringLiteral("Cannot get parent window"));
                return false;
            }
            if (children) XFree(children);
        }
 
        m_xOffset = qMax(0, -xPos);
        m_yOffset = qMax(0, -yPos);
        width = qMin(width, wndattr.width - xPos) - m_xOffset;
        height = qMin(height, wndattr.height - yPos) - m_yOffset;
        if (width <= 0 || height <= 0) {
            updateError(QPlatformSurfaceCapture::CaptureFailed,
                        QStringLiteral("Window is completely out of the screen borders"));
            return false;
        }
 
        // check window params for the root window as well since
        // it potentially can be changed (e.g. on VM with resizing)
        if (!m_xImage || width != m_xImage->width || height != m_xImage->height
            || depth != m_xImage->depth || visual->visualid != m_visualID) {
 
            qCDebug(qLcX11SurfaceCapture) << "recreate ximage: " << width << height
                                          << depth << visual->visualid;
 
            detachShm();
            m_xImage.reset();
 
            m_visualID = wndattr.visual->visualid;
            m_xImage.reset(XShmCreateImage(m_display.get(), visual, depth, ZPixmap,
                                           nullptr, &m_shmInfo, width, height));
 
            if (!m_xImage) {
                updateError(QPlatformSurfaceCapture::CaptureFailed,
                            QStringLiteral("Cannot create image"));
                return false;
            }
 
            const auto pixelFormat = xImagePixelFormat(*m_xImage);
 
            // TODO: probably, add a converter instead
            if (pixelFormat == QVideoFrameFormat::Format_Invalid) {
                updateError(QPlatformSurfaceCapture::CaptureFailed,
                            QStringLiteral("Not handled pixel format, bpp=")
                                    + QString::number(m_xImage->bits_per_pixel));
                return false;
            }
 
            attachShm();
 
            if (!m_attached) {
                updateError(QPlatformSurfaceCapture::CaptureFailed,
                            QStringLiteral("Cannot attach shared memory"));
                return false;
            }
 
            QVideoFrameFormat format(QSize(m_xImage->width, m_xImage->height), pixelFormat);
            format.setStreamFrameRate(frameRate());
            m_format = format;
        }
 
        return m_attached;
    }
 
protected:
    QVideoFrame grabFrame() override
    {
        if (!grabXImage())
            return {};
 
        QByteArray data(m_xImage->bytes_per_line * m_xImage->height, Qt::Uninitialized);
 
        const auto pixelSrc = reinterpret_cast<const uint32_t *>(m_xImage->data);
        const auto pixelDst = reinterpret_cast<uint32_t *>(data.data());
        const auto pixelCount = data.size() / 4;
        const auto xImageAlphaVaries = false; // In known cases it doesn't vary - it's 0xff or 0xff
 
        qCopyPixelsWithAlphaMask(pixelDst, pixelSrc, pixelCount, m_format.pixelFormat(),
                                       xImageAlphaVaries);
 
        auto buffer = std::make_unique<QMemoryVideoBuffer>(data, m_xImage->bytes_per_line);
        return QVideoFramePrivate::createFrame(std::move(buffer), m_format);
    }
 
private:
    bool grabXImage()
    {
        for (int i = 0; i < 10; i++) {
            if (!update())
                return false;
            if (XShmGetImage(m_display.get(), m_xid, m_xImage.get(),
                             m_xOffset, m_yOffset, AllPlanes))
                return true;
        }
 
        updateError(QPlatformSurfaceCapture::CaptureFailed,
                    QStringLiteral(
                        "Cannot get ximage; the window geometry may be undergoing change"));
        return false;
    }
 
    std::optional<QPlatformSurfaceCapture::Error> m_prevGrabberError;
    XID m_xid = None;
    int m_xOffset = 0;
    int m_yOffset = 0;
    std::unique_ptr<Display, decltype(&XCloseDisplay)> m_display{ nullptr, &XCloseDisplay };
    std::unique_ptr<XImage, decltype(&destroyXImage)> m_xImage{ nullptr, &destroyXImage };
    XShmSegmentInfo m_shmInfo{};
    bool m_attached = false;
    VisualID m_visualID = None;
    QVideoFrameFormat m_format;
    std::optional<qreal> m_userFrameRate;
};
 
QX11SurfaceCapture::QX11SurfaceCapture(Source initialSource)
    : QPlatformSurfaceCapture(std::move(initialSource))
{
    // For debug
    //  XSetErrorHandler([](Display *, XErrorEvent * e) {
    //      qDebug() << "error handler" << e->error_code;
    //      return 0;
    //  });
}
 
QX11SurfaceCapture::~QX11SurfaceCapture() = default;
 
QVideoFrameFormat QX11SurfaceCapture::frameFormat() const
{
    return m_grabber ? m_grabber->format() : QVideoFrameFormat{};
}
 
bool QX11SurfaceCapture::setActiveInternal(bool active)
{
    qCDebug(qLcX11SurfaceCapture) << "set active" << active;
 
    if (m_grabber)
        m_grabber.reset();
    else
        std::visit([this](const auto &source) {
            activate(source);
        }, source());
 
    return static_cast<bool>(m_grabber) == active;
}
 
void QX11SurfaceCapture::activate(ScreenSource screen)
{
    if (checkScreenWithError(screen))
        m_grabber = Grabber::create(*this, screen);
}
 
void QX11SurfaceCapture::activate(const WindowSource &window)
{
    auto handle = QCapturableWindowPrivate::handle(window);
    m_grabber = Grabber::create(*this, handle ? handle->id : 0);
}
 
bool QX11SurfaceCapture::isSupported()
{
    return qgetenv("XDG_SESSION_TYPE").compare(QLatin1String("x11"), Qt::CaseInsensitive) == 0;
}
 
QT_END_NAMESPACE