transaction.cpp

Go to the documentation of this file.

/*
    SPDX-FileCopyrightText: 2023 Vlad Zahorodnii <vlad.zahorodnii@kde.org>
 
    SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
*/
 
#include "wayland/transaction.h"
#include "utils/filedescriptor.h"
#include "wayland/subcompositor.h"
#include "wayland/surface_p.h"
#include "wayland/transaction_p.h"
 
namespace KWin
{
 
TransactionDmaBufLocker *TransactionDmaBufLocker::get(GraphicsBuffer *buffer)
{
    static QHash<GraphicsBuffer *, TransactionDmaBufLocker *> lockers;
    if (auto it = lockers.find(buffer); it != lockers.end()) {
        return *it;
    }
 
    const DmaBufAttributes *attributes = buffer->dmabufAttributes();
    if (!attributes) {
        return nullptr;
    }
 
    auto locker = new TransactionDmaBufLocker(attributes);
    lockers[buffer] = locker;
    QObject::connect(buffer, &QObject::destroyed, [buffer]() {
        delete lockers.take(buffer);
    });
 
    return locker;
}
 
TransactionDmaBufLocker::TransactionDmaBufLocker(const DmaBufAttributes *attributes)
{
    for (int i = 0; i < attributes->planeCount; ++i) {
        auto notifier = new QSocketNotifier(attributes->fd[i].get(), QSocketNotifier::Read);
        notifier->setEnabled(false);
        connect(notifier, &QSocketNotifier::activated, this, [this, notifier]() {
            notifier->setEnabled(false);
            m_pending.removeOne(notifier);
            if (m_pending.isEmpty()) {
                const auto transactions = m_transactions; // unlock() may destroy this
                m_transactions.clear();
                for (Transaction *transition : transactions) {
                    transition->unlock();
                }
            }
        });
        m_notifiers.emplace_back(notifier);
    }
}
 
void TransactionDmaBufLocker::add(Transaction *transition)
{
    if (arm()) {
        transition->lock();
        m_transactions.append(transition);
    }
}
 
bool TransactionDmaBufLocker::arm()
{
    if (!m_pending.isEmpty()) {
        return true;
    }
    for (const auto &notifier : m_notifiers) {
        if (!FileDescriptor::isReadable(notifier->socket())) {
            notifier->setEnabled(true);
            m_pending.append(notifier.get());
        }
    }
    return !m_pending.isEmpty();
}
 
Transaction::Transaction()
{
}
 
void Transaction::lock()
{
    m_locks++;
}
 
void Transaction::unlock()
{
    Q_ASSERT(m_locks > 0);
    m_locks--;
    if (m_locks == 0) {
        tryApply();
    }
}
 
bool Transaction::isReady() const
{
    if (m_locks) {
        return false;
    }
 
    return std::none_of(m_entries.cbegin(), m_entries.cend(), [](const TransactionEntry &entry) {
        return entry.previousTransaction;
    });
}
 
Transaction *Transaction::next(SurfaceInterface *surface) const
{
    for (const TransactionEntry &entry : m_entries) {
        if (entry.surface == surface) {
            return entry.nextTransaction;
        }
    }
    return nullptr;
}
 
void Transaction::add(SurfaceInterface *surface)
{
    SurfaceState *pending = SurfaceInterfacePrivate::get(surface)->pending.get();
 
    for (TransactionEntry &entry : m_entries) {
        if (entry.surface == surface) {
            if (pending->bufferIsSet) {
                entry.buffer = GraphicsBufferRef(pending->buffer);
            }
            pending->mergeInto(entry.state.get());
            return;
        }
    }
 
    auto state = std::make_unique<SurfaceState>();
    pending->mergeInto(state.get());
 
    m_entries.emplace_back(TransactionEntry{
        .surface = surface,
        .buffer = GraphicsBufferRef(state->buffer),
        .state = std::move(state),
    });
}
 
void Transaction::amend(SurfaceInterface *surface, std::function<void(SurfaceState *)> mutator)
{
    for (TransactionEntry &entry : m_entries) {
        if (entry.surface == surface) {
            mutator(entry.state.get());
        }
    }
}
 
void Transaction::merge(Transaction *other)
{
    for (size_t i = 0; i < other->m_entries.size(); ++i) {
        m_entries.emplace_back(std::move(other->m_entries[i]));
    }
    other->m_entries.clear();
}
 
static bool isAncestor(SurfaceInterface *surface, SurfaceInterface *ancestor)
{
    SurfaceInterface *candidate = surface;
    while (candidate) {
        SubSurfaceInterface *subsurface = candidate->subSurface();
        if (!subsurface) {
            return false;
        }
 
        if (subsurface->parentSurface() == ancestor) {
            return true;
        }
 
        candidate = subsurface->parentSurface();
    }
 
    return false;
}
 
static SurfaceInterface *mainSurface(SurfaceInterface *surface)
{
    SubSurfaceInterface *subsurface = surface->subSurface();
    if (subsurface) {
        return subsurface->mainSurface();
    }
    return surface;
}
 
void Transaction::apply()
{
    // Sort surfaces so descendants come first, then their ancestors.
    std::sort(m_entries.begin(), m_entries.end(), [](const TransactionEntry &a, const TransactionEntry &b) {
        if (!a.surface) {
            return false;
        }
        if (!b.surface) {
            return true;
        }
 
        if (isAncestor(a.surface, b.surface)) {
            return true;
        }
        if (isAncestor(b.surface, a.surface)) {
            return false;
        }
        return mainSurface(a.surface) < mainSurface(b.surface);
    });
 
    for (TransactionEntry &entry : m_entries) {
        if (entry.surface) {
            SurfaceInterfacePrivate::get(entry.surface)->applyState(entry.state.get());
        }
    }
 
    for (TransactionEntry &entry : m_entries) {
        if (entry.surface) {
            if (entry.surface->lastTransaction() == this) {
                entry.surface->setFirstTransaction(nullptr);
                entry.surface->setLastTransaction(nullptr);
            } else {
                entry.surface->setFirstTransaction(entry.nextTransaction);
            }
        }
 
        if (entry.nextTransaction) {
            for (TransactionEntry &otherEntry : entry.nextTransaction->m_entries) {
                if (otherEntry.previousTransaction == this) {
                    otherEntry.previousTransaction = nullptr;
                    break;
                }
            }
            entry.nextTransaction->tryApply();
        }
    }
 
    delete this;
}
 
bool Transaction::tryApply()
{
    if (!isReady()) {
        return false;
    }
    apply();
    return true;
}
 
void Transaction::commit()
{
    for (TransactionEntry &entry : m_entries) {
        if (entry.state->bufferIsSet && entry.state->buffer) {
            // Avoid applying the transaction until all graphics buffers have become idle.
            if (auto locker = TransactionDmaBufLocker::get(entry.state->buffer)) {
                locker->add(this);
            }
        }
 
        if (entry.surface->firstTransaction()) {
            Transaction *lastTransaction = entry.surface->lastTransaction();
            for (TransactionEntry &lastEntry : lastTransaction->m_entries) {
                if (lastEntry.surface == entry.surface) {
                    lastEntry.nextTransaction = this;
                }
            }
        } else {
            entry.surface->setFirstTransaction(this);
        }
 
        entry.previousTransaction = entry.surface->lastTransaction();
        entry.surface->setLastTransaction(this);
    }
 
    if (!tryApply()) {
        for (const TransactionEntry &entry : m_entries) {
            Q_EMIT entry.surface->stateStashed(entry.state->serial);
        }
    }
}
 
} // namespace KWin
 
#include "moc_transaction.cpp"