File indexing completed on 2024-05-12 05:32:22

 /*
     SPDX-FileCopyrightText: 2018 Fredrik Höglund <fredrik@kde.org>
     SPDX-FileCopyrightText: 2019 Roman Gilg <subdiff@gmail.com>
     SPDX-FileCopyrightText: 2021 Vlad Zahorodnii <vlad.zahorodnii@kde.org>
     SPDX-FileCopyrightText: 2021 Xaver Hugl <xaver.hugl@gmail.com>
 
     Based on the libweston implementation,
     SPDX-FileCopyrightText: 2014, 2015 Collabora, Ltd.
 
     SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
 */
 
 #include "linuxdmabufv1clientbuffer.h"
 #include "core/renderbackend.h"
 #include "linuxdmabufv1clientbuffer_p.h"
 #include "surface_p.h"
 #include "utils/common.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <unistd.h>
 
 namespace KWin
 {
 static const int s_version = 4;
 
 LinuxDmaBufV1ClientBufferIntegrationPrivate::LinuxDmaBufV1ClientBufferIntegrationPrivate(LinuxDmaBufV1ClientBufferIntegration *q, Display *display)
     : QtWaylandServer::zwp_linux_dmabuf_v1(*display, s_version)
     , q(q)
     , defaultFeedback(new LinuxDmaBufV1Feedback(this))
 {
 }
 
 void LinuxDmaBufV1ClientBufferIntegrationPrivate::zwp_linux_dmabuf_v1_bind_resource(Resource *resource)
 {
     if (resource->version() < ZWP_LINUX_DMABUF_V1_GET_DEFAULT_FEEDBACK_SINCE_VERSION) {
         for (auto it = supportedModifiers.constBegin(); it != supportedModifiers.constEnd(); ++it) {
             const uint32_t &format = it.key();
             const auto &modifiers = it.value();
             for (const uint64_t &modifier : std::as_const(modifiers)) {
                 if (resource->version() >= ZWP_LINUX_DMABUF_V1_MODIFIER_SINCE_VERSION) {
                     const uint32_t modifier_lo = modifier & 0xffffffff;
                     const uint32_t modifier_hi = modifier >> 32;
                     send_modifier(resource->handle, format, modifier_hi, modifier_lo);
                 } else if (modifier == DRM_FORMAT_MOD_LINEAR || modifier == DRM_FORMAT_MOD_INVALID) {
                     send_format(resource->handle, format);
                 }
             }
         }
     }
 }
 
 void LinuxDmaBufV1ClientBufferIntegrationPrivate::zwp_linux_dmabuf_v1_get_default_feedback(Resource *resource, uint32_t id)
 {
     LinuxDmaBufV1FeedbackPrivate::get(defaultFeedback.get())->add(resource->client(), id, resource->version());
 }
 
 void LinuxDmaBufV1ClientBufferIntegrationPrivate::zwp_linux_dmabuf_v1_get_surface_feedback(Resource *resource, uint32_t id, wl_resource *surfaceResource)
 {
     auto surface = SurfaceInterface::get(surfaceResource);
     if (!surface) {
         qCWarning(KWIN_CORE) << "requested surface feedback for nonexistant surface!";
         return;
     }
     auto surfacePrivate = SurfaceInterfacePrivate::get(surface);
     if (!surfacePrivate->dmabufFeedbackV1) {
         surfacePrivate->dmabufFeedbackV1.reset(new LinuxDmaBufV1Feedback(this));
     }
     LinuxDmaBufV1FeedbackPrivate::get(surfacePrivate->dmabufFeedbackV1.get())->add(resource->client(), id, resource->version());
 }
 
 void LinuxDmaBufV1ClientBufferIntegrationPrivate::zwp_linux_dmabuf_v1_destroy(Resource *resource)
 {
     wl_resource_destroy(resource->handle);
 }
 
 void LinuxDmaBufV1ClientBufferIntegrationPrivate::zwp_linux_dmabuf_v1_create_params(Resource *resource, uint32_t params_id)
 {
     wl_resource *paramsResource = wl_resource_create(resource->client(), &zwp_linux_buffer_params_v1_interface, resource->version(), params_id);
     if (!paramsResource) {
         wl_resource_post_no_memory(resource->handle);
         return;
     }
     new LinuxDmaBufParamsV1(q, paramsResource);
 }
 
 LinuxDmaBufParamsV1::LinuxDmaBufParamsV1(LinuxDmaBufV1ClientBufferIntegration *integration, ::wl_resource *resource)
     : QtWaylandServer::zwp_linux_buffer_params_v1(resource)
     , m_integration(integration)
 {
 }
 
 void LinuxDmaBufParamsV1::zwp_linux_buffer_params_v1_destroy_resource(Resource *resource)
 {
     delete this;
 }
 
 void LinuxDmaBufParamsV1::zwp_linux_buffer_params_v1_destroy(Resource *resource)
 {
     wl_resource_destroy(resource->handle);
 }
 
 void LinuxDmaBufParamsV1::zwp_linux_buffer_params_v1_add(Resource *resource,
                                                          int32_t fd,
                                                          uint32_t plane_idx,
                                                          uint32_t offset,
                                                          uint32_t stride,
                                                          uint32_t modifier_hi,
                                                          uint32_t modifier_lo)
 {
     if (Q_UNLIKELY(m_isUsed)) {
         wl_resource_post_error(resource->handle, error_already_used, "the params object has already been used to create a wl_buffer");
         close(fd);
         return;
     }
 
     if (Q_UNLIKELY(plane_idx >= 4)) {
         wl_resource_post_error(resource->handle, error_plane_idx, "plane index %d is out of bounds", plane_idx);
         close(fd);
         return;
     }
 
     if (Q_UNLIKELY(m_attrs.fd[plane_idx].isValid())) {
         wl_resource_post_error(resource->handle, error_plane_set, "the plane index %d was already set", plane_idx);
         close(fd);
         return;
     }
     m_attrs.fd[plane_idx] = FileDescriptor{fd};
     m_attrs.offset[plane_idx] = offset;
     m_attrs.pitch[plane_idx] = stride;
     m_attrs.modifier = (quint64(modifier_hi) << 32) | modifier_lo;
     m_attrs.planeCount++;
 }
 
 void LinuxDmaBufParamsV1::zwp_linux_buffer_params_v1_create(Resource *resource, int32_t width, int32_t height, uint32_t format, uint32_t flags)
 {
     if (Q_UNLIKELY(m_isUsed)) {
         wl_resource_post_error(resource->handle, error_already_used, "the params object has already been used to create a wl_buffer");
         return;
     }
 
     if (Q_UNLIKELY(!test(resource, width, height))) {
         return;
     }
 
     RenderBackend *renderBackend = m_integration->renderBackend();
     if (Q_UNLIKELY(!renderBackend)) {
         send_failed(resource->handle);
         return;
     }
 
     if (flags) {
         send_failed(resource->handle);
         return;
     }
 
     m_isUsed = true;
 
     m_attrs.width = width;
     m_attrs.height = height;
     m_attrs.format = format;
 
     auto clientBuffer = new LinuxDmaBufV1ClientBuffer(std::move(m_attrs));
     if (!renderBackend->testImportBuffer(clientBuffer)) {
         send_failed(resource->handle);
         delete clientBuffer;
         return;
     }
 
     wl_resource *bufferResource = wl_resource_create(resource->client(), &wl_buffer_interface, 1, 0);
     if (!bufferResource) {
         wl_resource_post_no_memory(resource->handle);
         delete clientBuffer;
         return;
     }
 
     clientBuffer->initialize(bufferResource);
     send_created(resource->handle, bufferResource);
 }
 
 void LinuxDmaBufParamsV1::zwp_linux_buffer_params_v1_create_immed(Resource *resource,
                                                                   uint32_t buffer_id,
                                                                   int32_t width,
                                                                   int32_t height,
                                                                   uint32_t format,
                                                                   uint32_t flags)
 {
     if (Q_UNLIKELY(m_isUsed)) {
         wl_resource_post_error(resource->handle, error_already_used, "the params object has already been used to create a wl_buffer");
         return;
     }
 
     if (Q_UNLIKELY(!test(resource, width, height))) {
         return;
     }
 
     RenderBackend *renderBackend = m_integration->renderBackend();
     if (Q_UNLIKELY(!renderBackend)) {
         wl_resource_post_error(resource->handle, error_invalid_wl_buffer, "importing the supplied dmabufs failed");
         return;
     }
 
     if (flags) {
         wl_resource_post_error(resource->handle, error_invalid_wl_buffer, "dma-buf flags are not supported");
         return;
     }
 
     m_isUsed = true;
 
     m_attrs.width = width;
     m_attrs.height = height;
     m_attrs.format = format;
 
     auto clientBuffer = new LinuxDmaBufV1ClientBuffer(std::move(m_attrs));
     if (!renderBackend->testImportBuffer(clientBuffer)) {
         wl_resource_post_error(resource->handle, error_invalid_wl_buffer, "importing the supplied dmabufs failed");
         delete clientBuffer;
         return;
     }
 
     wl_resource *bufferResource = wl_resource_create(resource->client(), &wl_buffer_interface, 1, buffer_id);
     if (!bufferResource) {
         wl_resource_post_no_memory(resource->handle);
         delete clientBuffer;
         return;
     }
 
     clientBuffer->initialize(bufferResource);
 }
 
 bool LinuxDmaBufParamsV1::test(Resource *resource, uint32_t width, uint32_t height)
 {
     if (Q_UNLIKELY(!m_attrs.planeCount)) {
         wl_resource_post_error(resource->handle, error_incomplete, "no planes have been specified");
         return false;
     }
 
     // Check for holes in the dmabuf set (e.g. [0, 1, 3]).
     for (int i = 0; i < m_attrs.planeCount; ++i) {
         if (!m_attrs.fd[i].isValid()) {
             wl_resource_post_error(resource->handle, error_incomplete, "no dmabuf has been added for plane %d", i);
             return false;
         }
     }
 
     if (Q_UNLIKELY(width == 0 || height == 0)) {
         wl_resource_post_error(resource->handle, error_invalid_dimensions, "invalid width %d or height %d", width, height);
         return false;
     }
 
     for (int i = 0; i < m_attrs.planeCount; ++i) {
         // Check for overflows.
         if (Q_UNLIKELY(uint64_t(m_attrs.offset[i]) + m_attrs.pitch[i] > UINT32_MAX)) {
             wl_resource_post_error(resource->handle, error_out_of_bounds, "size overflow for plane %d", i);
             return false;
         }
 
         if (Q_UNLIKELY(i == 0 && uint64_t(m_attrs.offset[i]) + uint64_t(m_attrs.pitch[i]) * height > UINT32_MAX)) {
             wl_resource_post_error(resource->handle, error_out_of_bounds, "size overflow for plane %d", i);
             return false;
         }
 
         // Don't report an error as it might be caused by the kernel not supporting
         // seeking on dmabuf.
         const off_t size = lseek(m_attrs.fd[i].get(), 0, SEEK_END);
         if (size == -1) {
             continue;
         }
 
         if (Q_UNLIKELY(m_attrs.offset[i] >= size)) {
             wl_resource_post_error(resource->handle, error_out_of_bounds, "invalid offset %i for plane %d", m_attrs.offset[i], i);
             return false;
         }
 
         if (Q_UNLIKELY(m_attrs.offset[i] + m_attrs.pitch[i] > size)) {
             wl_resource_post_error(resource->handle, error_out_of_bounds, "invalid stride %i for plane %d", m_attrs.pitch[i], i);
             return false;
         }
 
         // Only valid for first plane as other planes might be sub-sampled according to
         // fourcc format.
         if (Q_UNLIKELY(i == 0 && m_attrs.offset[i] + m_attrs.pitch[i] * height > size)) {
             wl_resource_post_error(resource->handle, error_out_of_bounds, "invalid buffer stride of height for plane %d", i);
             return false;
         }
     }
 
     return true;
 }
 
 LinuxDmaBufV1ClientBufferIntegration::LinuxDmaBufV1ClientBufferIntegration(Display *display)
     : QObject(display)
     , d(new LinuxDmaBufV1ClientBufferIntegrationPrivate(this, display))
 {
 }
 
 LinuxDmaBufV1ClientBufferIntegration::~LinuxDmaBufV1ClientBufferIntegration()
 {
 }
 
 bool operator==(const LinuxDmaBufV1Feedback::Tranche &t1, const LinuxDmaBufV1Feedback::Tranche &t2)
 {
     return t1.device == t2.device && t1.flags == t2.flags && t1.formatTable == t2.formatTable;
 }
 
 RenderBackend *LinuxDmaBufV1ClientBufferIntegration::renderBackend() const
 {
     return d->renderBackend;
 }
 
 void LinuxDmaBufV1ClientBufferIntegration::setRenderBackend(RenderBackend *renderBackend)
 {
     d->renderBackend = renderBackend;
 }
 
 void LinuxDmaBufV1ClientBufferIntegration::setSupportedFormatsWithModifiers(const QList<LinuxDmaBufV1Feedback::Tranche> &tranches)
 {
     if (LinuxDmaBufV1FeedbackPrivate::get(d->defaultFeedback.get())->m_tranches != tranches) {
         QHash<uint32_t, QList<uint64_t>> set;
         for (const auto &tranche : tranches) {
             set.insert(tranche.formatTable);
         }
         d->supportedModifiers = set;
         d->mainDevice = tranches.first().device;
         d->table = std::make_unique<LinuxDmaBufV1FormatTable>(set);
         d->defaultFeedback->setTranches(tranches);
     }
 }
 
 void LinuxDmaBufV1ClientBuffer::buffer_destroy_resource(wl_resource *resource)
 {
     if (LinuxDmaBufV1ClientBuffer *buffer = LinuxDmaBufV1ClientBuffer::get(resource)) {
         buffer->m_resource = nullptr;
         buffer->drop();
     }
 }
 
 void LinuxDmaBufV1ClientBuffer::buffer_destroy(wl_client *client, wl_resource *resource)
 {
     wl_resource_destroy(resource);
 }
 
 const struct wl_buffer_interface LinuxDmaBufV1ClientBuffer::implementation = {
     .destroy = buffer_destroy,
 };
 
 LinuxDmaBufV1ClientBuffer::LinuxDmaBufV1ClientBuffer(DmaBufAttributes &&attrs)
 {
     m_attrs = std::move(attrs);
     m_hasAlphaChannel = alphaChannelFromDrmFormat(m_attrs.format);
 }
 
 void LinuxDmaBufV1ClientBuffer::initialize(wl_resource *resource)
 {
     m_resource = resource;
     wl_resource_set_implementation(resource, &implementation, this, buffer_destroy_resource);
 
     connect(this, &GraphicsBuffer::released, [this]() {
         wl_buffer_send_release(m_resource);
     });
 }
 
 const DmaBufAttributes *LinuxDmaBufV1ClientBuffer::dmabufAttributes() const
 {
     return &m_attrs;
 }
 
 QSize LinuxDmaBufV1ClientBuffer::size() const
 {
     return QSize(m_attrs.width, m_attrs.height);
 }
 
 bool LinuxDmaBufV1ClientBuffer::hasAlphaChannel() const
 {
     return m_hasAlphaChannel;
 }
 
 LinuxDmaBufV1ClientBuffer *LinuxDmaBufV1ClientBuffer::get(wl_resource *resource)
 {
     if (wl_resource_instance_of(resource, &wl_buffer_interface, &implementation)) {
         return static_cast<LinuxDmaBufV1ClientBuffer *>(wl_resource_get_user_data(resource));
     }
     return nullptr;
 }
 
 LinuxDmaBufV1Feedback::LinuxDmaBufV1Feedback(LinuxDmaBufV1ClientBufferIntegrationPrivate *integration)
     : d(new LinuxDmaBufV1FeedbackPrivate(integration))
 {
 }
 
 LinuxDmaBufV1Feedback::~LinuxDmaBufV1Feedback() = default;
 
 void LinuxDmaBufV1Feedback::setTranches(const QList<Tranche> &tranches)
 {
     if (d->m_tranches != tranches) {
         d->m_tranches = tranches;
         const auto &map = d->resourceMap();
         for (const auto &resource : map) {
             d->send(resource);
         }
     }
 }
 
 LinuxDmaBufV1FeedbackPrivate *LinuxDmaBufV1FeedbackPrivate::get(LinuxDmaBufV1Feedback *q)
 {
     return q->d.get();
 }
 
 LinuxDmaBufV1FeedbackPrivate::LinuxDmaBufV1FeedbackPrivate(LinuxDmaBufV1ClientBufferIntegrationPrivate *bufferintegration)
     : m_bufferintegration(bufferintegration)
 {
 }
 
 void LinuxDmaBufV1FeedbackPrivate::send(Resource *resource)
 {
     send_format_table(resource->handle, m_bufferintegration->table->file.fd(), m_bufferintegration->table->file.size());
     QByteArray bytes;
     bytes.append(reinterpret_cast<const char *>(&m_bufferintegration->mainDevice), sizeof(dev_t));
     send_main_device(resource->handle, bytes);
     const auto &sendTranche = [this, resource](const LinuxDmaBufV1Feedback::Tranche &tranche) {
         QByteArray targetDevice;
         targetDevice.append(reinterpret_cast<const char *>(&tranche.device), sizeof(dev_t));
         QByteArray indices;
         for (auto it = tranche.formatTable.begin(); it != tranche.formatTable.end(); it++) {
             const uint32_t format = it.key();
             for (const auto &mod : std::as_const(it.value())) {
                 uint16_t index = m_bufferintegration->table->indices[std::pair<uint32_t, uint64_t>(format, mod)];
                 indices.append(reinterpret_cast<const char *>(&index), 2);
             }
         }
         send_tranche_target_device(resource->handle, targetDevice);
         send_tranche_formats(resource->handle, indices);
         send_tranche_flags(resource->handle, static_cast<uint32_t>(tranche.flags));
         send_tranche_done(resource->handle);
     };
     for (const auto &tranche : std::as_const(m_tranches)) {
         sendTranche(tranche);
     }
     // send default hints as the last fallback tranche
     const auto defaultFeedbackPrivate = get(m_bufferintegration->defaultFeedback.get());
     if (this != defaultFeedbackPrivate) {
         for (const auto &tranche : std::as_const(defaultFeedbackPrivate->m_tranches)) {
             sendTranche(tranche);
         }
     }
     send_done(resource->handle);
 }
 
 void LinuxDmaBufV1FeedbackPrivate::zwp_linux_dmabuf_feedback_v1_bind_resource(Resource *resource)
 {
     send(resource);
 }
 
 void LinuxDmaBufV1FeedbackPrivate::zwp_linux_dmabuf_feedback_v1_destroy(Resource *resource)
 {
     wl_resource_destroy(resource->handle);
 }
 
 struct linux_dmabuf_feedback_v1_table_entry
 {
     uint32_t format;
     uint32_t pad; // unused
     uint64_t modifier;
 };
 
 LinuxDmaBufV1FormatTable::LinuxDmaBufV1FormatTable(const QHash<uint32_t, QList<uint64_t>> &supportedModifiers)
 {
     QList<linux_dmabuf_feedback_v1_table_entry> data;
     for (auto it = supportedModifiers.begin(); it != supportedModifiers.end(); it++) {
         const uint32_t format = it.key();
         for (const uint64_t &mod : *it) {
             indices.insert({format, mod}, data.size());
             data.append({format, 0, mod});
         }
     }
 
     const auto size = data.size() * sizeof(linux_dmabuf_feedback_v1_table_entry);
     file = RamFile("kwin-dmabuf-feedback-table", data.constData(), size, RamFile::Flag::SealWrite);
     if (!file.isValid()) {
         qCCritical(KWIN_CORE) << "Failed to create RamFile for LinuxDmaBufV1FormatTable";
         return;
     }
 }
 
 } // namespace KWin
 
 #include "moc_linuxdmabufv1clientbuffer_p.cpp"
 
 #include "moc_linuxdmabufv1clientbuffer.cpp"