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

 /*
     KWin - the KDE window manager
     This file is part of the KDE project.
 
     SPDX-FileCopyrightText: 2017 Martin Flöser <mgraesslin@kde.org>
     SPDX-FileCopyrightText: 2022 Xaver Hugl <xaver.hugl@gmail.com>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 #include "opengl/eglswapchain.h"
 #include "core/graphicsbuffer.h"
 #include "core/graphicsbufferallocator.h"
 #include "opengl/eglcontext.h"
 #include "opengl/glutils.h"
 #include "utils/common.h"
 
 #include <drm_fourcc.h>
 #include <errno.h>
 
 namespace KWin
 {
 
 EglSwapchainSlot::EglSwapchainSlot(GraphicsBuffer *buffer, std::unique_ptr<GLFramebuffer> &&framebuffer, const std::shared_ptr<GLTexture> &texture)
     : m_buffer(buffer)
     , m_framebuffer(std::move(framebuffer))
     , m_texture(texture)
 {
 }
 
 EglSwapchainSlot::~EglSwapchainSlot()
 {
     m_framebuffer.reset();
     m_texture.reset();
     m_buffer->drop();
 }
 
 GraphicsBuffer *EglSwapchainSlot::buffer() const
 {
     return m_buffer;
 }
 
 std::shared_ptr<GLTexture> EglSwapchainSlot::texture() const
 {
     return m_texture;
 }
 
 GLFramebuffer *EglSwapchainSlot::framebuffer() const
 {
     return m_framebuffer.get();
 }
 
 int EglSwapchainSlot::age() const
 {
     return m_age;
 }
 
 std::shared_ptr<EglSwapchainSlot> EglSwapchainSlot::create(EglContext *context, GraphicsBuffer *buffer)
 {
     auto texture = context->importDmaBufAsTexture(*buffer->dmabufAttributes());
     if (!texture) {
         buffer->drop();
         return nullptr;
     }
     auto framebuffer = std::make_unique<GLFramebuffer>(texture.get());
     if (!framebuffer->valid()) {
         buffer->drop();
         return nullptr;
     }
     return std::make_shared<EglSwapchainSlot>(buffer, std::move(framebuffer), texture);
 }
 
 EglSwapchain::EglSwapchain(GraphicsBufferAllocator *allocator, EglContext *context, const QSize &size, uint32_t format, uint64_t modifier, const std::shared_ptr<EglSwapchainSlot> &seed)
     : m_allocator(allocator)
     , m_context(context)
     , m_size(size)
     , m_format(format)
     , m_modifier(modifier)
     , m_slots({seed})
 {
 }
 
 EglSwapchain::~EglSwapchain()
 {
 }
 
 QSize EglSwapchain::size() const
 {
     return m_size;
 }
 
 uint32_t EglSwapchain::format() const
 {
     return m_format;
 }
 
 uint64_t EglSwapchain::modifier() const
 {
     return m_modifier;
 }
 
 std::shared_ptr<EglSwapchainSlot> EglSwapchain::acquire()
 {
     for (const auto &slot : std::as_const(m_slots)) {
         if (!slot->buffer()->isReferenced()) {
             return slot;
         }
     }
 
     GraphicsBuffer *buffer = m_allocator->allocate(GraphicsBufferOptions{
         .size = m_size,
         .format = m_format,
         .modifiers = {m_modifier},
     });
     if (!buffer) {
         qCWarning(KWIN_OPENGL) << "Failed to allocate an egl gbm swapchain graphics buffer";
         return nullptr;
     }
 
     auto slot = EglSwapchainSlot::create(m_context, buffer);
     if (!slot) {
         return nullptr;
     }
     m_slots.append(slot);
     return slot;
 }
 
 void EglSwapchain::release(std::shared_ptr<EglSwapchainSlot> slot)
 {
     for (qsizetype i = 0; i < m_slots.count(); ++i) {
         if (m_slots[i] == slot) {
             m_slots[i]->m_age = 1;
         } else if (m_slots[i]->m_age > 0) {
             m_slots[i]->m_age++;
         }
     }
 }
 
 std::shared_ptr<EglSwapchain> EglSwapchain::create(GraphicsBufferAllocator *allocator, EglContext *context, const QSize &size, uint32_t format, const QList<uint64_t> &modifiers)
 {
     if (!context->makeCurrent()) {
         return nullptr;
     }
 
     // The seed graphics buffer is used to fixate modifiers.
     GraphicsBuffer *seed = allocator->allocate(GraphicsBufferOptions{
         .size = size,
         .format = format,
         .modifiers = modifiers,
     });
     if (!seed) {
         return nullptr;
     }
     const auto first = EglSwapchainSlot::create(context, seed);
     if (!first) {
         return nullptr;
     }
     return std::make_shared<EglSwapchain>(std::move(allocator),
                                           context,
                                           size,
                                           format,
                                           seed->dmabufAttributes()->modifier,
                                           first);
 }
 
 } // namespace KWin