File indexing completed on 2024-11-10 04:56:33

 /*
     KWin - the KDE window manager
     This file is part of the KDE project.
 
     SPDX-FileCopyrightText: 2015 Martin Gräßlin <mgraesslin@kde.org>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 #include "virtual_qpainter_backend.h"
 #include "core/graphicsbufferview.h"
 #include "core/shmgraphicsbufferallocator.h"
 #include "platformsupport/scenes/qpainter/qpainterswapchain.h"
 #include "utils/softwarevsyncmonitor.h"
 #include "virtual_backend.h"
 #include "virtual_output.h"
 
 #include <drm_fourcc.h>
 
 namespace KWin
 {
 
 VirtualQPainterLayer::VirtualQPainterLayer(Output *output, VirtualQPainterBackend *backend)
     : m_output(output)
     , m_backend(backend)
 {
 }
 
 VirtualQPainterLayer::~VirtualQPainterLayer()
 {
 }
 
 std::optional<OutputLayerBeginFrameInfo> VirtualQPainterLayer::beginFrame()
 {
     const QSize nativeSize(m_output->modeSize());
     if (!m_swapchain || m_swapchain->size() != nativeSize) {
         m_swapchain = std::make_unique<QPainterSwapchain>(m_backend->graphicsBufferAllocator(), nativeSize, DRM_FORMAT_XRGB8888);
     }
 
     m_current = m_swapchain->acquire();
     if (!m_current) {
         return std::nullopt;
     }
 
     m_renderStart = std::chrono::steady_clock::now();
     return OutputLayerBeginFrameInfo{
         .renderTarget = RenderTarget(m_current->view()->image()),
         .repaint = m_output->rect(),
     };
 }
 
 bool VirtualQPainterLayer::endFrame(const QRegion &renderedRegion, const QRegion &damagedRegion)
 {
     m_renderTime = std::chrono::steady_clock::now() - m_renderStart;
     return true;
 }
 
 QImage *VirtualQPainterLayer::image()
 {
     return m_current->view()->image();
 }
 
 std::chrono::nanoseconds VirtualQPainterLayer::queryRenderTime() const
 {
     return m_renderTime;
 }
 
 VirtualQPainterBackend::VirtualQPainterBackend(VirtualBackend *backend)
     : m_allocator(std::make_unique<ShmGraphicsBufferAllocator>())
 {
     connect(backend, &VirtualBackend::outputAdded, this, &VirtualQPainterBackend::addOutput);
     connect(backend, &VirtualBackend::outputRemoved, this, &VirtualQPainterBackend::removeOutput);
 
     const auto outputs = backend->outputs();
     for (Output *output : outputs) {
         addOutput(output);
     }
 }
 
 VirtualQPainterBackend::~VirtualQPainterBackend() = default;
 
 void VirtualQPainterBackend::addOutput(Output *output)
 {
     m_outputs[output] = std::make_unique<VirtualQPainterLayer>(output, this);
 }
 
 void VirtualQPainterBackend::removeOutput(Output *output)
 {
     m_outputs.erase(output);
 }
 
 GraphicsBufferAllocator *VirtualQPainterBackend::graphicsBufferAllocator() const
 {
     return m_allocator.get();
 }
 
 void VirtualQPainterBackend::present(Output *output, const std::shared_ptr<OutputFrame> &frame)
 {
     static_cast<VirtualOutput *>(output)->present(frame);
 }
 
 VirtualQPainterLayer *VirtualQPainterBackend::primaryLayer(Output *output)
 {
     return m_outputs[output].get();
 }
 }
 
 #include "moc_virtual_qpainter_backend.cpp"