qwaylandbufferref.cpp

Go to the documentation of this file.

// Copyright (C) 2017 Jolla Ltd, author: <giulio.camuffo@jollamobile.com>
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
// Qt-Security score:significant reason:default
 
#include <QDebug>
#include <QAtomicInt>
 
#include "qwaylandbufferref.h"
#include "wayland_wrapper/qwlclientbuffer_p.h"
 
#include <type_traits>
 
QT_BEGIN_NAMESPACE
 
#define CHECK1(l, r, op)
    static_assert(std::is_same_v<
        bool,
        decltype(std::declval<QWaylandBufferRef l >() op
                 std::declval<QWaylandBufferRef r >())
    >)
#define CHECK2(l, r)
    CHECK1(l, r, ==);
    CHECK1(l, r, !=)
#define CHECK(l, r)
    CHECK2(l, r);
    CHECK2(l &, r);
    CHECK2(l &, r &);
    CHECK2(l, r &)
 
CHECK(, );
CHECK(const, );
CHECK(const, const);
CHECK(, const);
 
#undef CHECK
#undef CHECK2
#undef CHECK1
 
class QWaylandBufferRefPrivate
{
public:
    QtWayland::ClientBuffer *buffer = nullptr;
 
    bool nullOrDestroyed() {
        return !buffer || buffer->isDestroyed();
    }
};
 
/*!
 * \class QWaylandBufferRef
 * \inmodule QtWaylandCompositor
 * \since 5.8
 * \brief The QWaylandBufferRef class holds the reference to a surface buffer.
 *
 * This class can be used to reference a surface buffer. As long as a reference
 * to the buffer exists, it is owned by the compositor and the client cannot modify it.
 */
 
/*!
 * Constructs a null buffer ref.
 */
QWaylandBufferRef::QWaylandBufferRef()
                 : d(new QWaylandBufferRefPrivate)
{
    d->buffer = nullptr;
}
 
/*!
 * Constructs a reference to \a buffer.
 */
QWaylandBufferRef::QWaylandBufferRef(QtWayland::ClientBuffer *buffer)
                 : d(new QWaylandBufferRefPrivate)
{
    d->buffer = buffer;
    if (buffer)
        buffer->ref();
}
 
/*!
 * Creates a new reference to the buffer referenced by \a ref.
 */
QWaylandBufferRef::QWaylandBufferRef(const QWaylandBufferRef &ref)
                 : d(new QWaylandBufferRefPrivate)
{
    d->buffer = ref.d->buffer;
    if (d->buffer)
        d->buffer->ref();
}
 
/*!
 * Dereferences the buffer.
 */
QWaylandBufferRef::~QWaylandBufferRef()
{
    if (d->buffer)
        d->buffer->deref();
    delete d;
}
 
/*!
 * Assigns \a ref to this buffer and adds a reference to it. The previously referenced buffer is
 * dereferenced.
 */
QWaylandBufferRef &QWaylandBufferRef::operator=(const QWaylandBufferRef &ref)
{
    if (ref.d->buffer)
        ref.d->buffer->ref();
 
    if (d->buffer)
        d->buffer->deref();
 
    d->buffer = ref.d->buffer;
 
    return *this;
}
 
/*!
    \fn bool QWaylandBufferRef::operator==(const QWaylandBufferRef &lhs, const QWaylandBufferRef &rhs)
 
    Returns \c true if \a lhs references the same buffer as \a rhs.
    Otherwise returns \c{false}.
 */
bool operator==(const QWaylandBufferRef &lhs, const QWaylandBufferRef &rhs) noexcept
{
    return lhs.d->buffer == rhs.d->buffer;
}
 
/*!
    \fn bool QWaylandBufferRef::operator!=(const QWaylandBufferRef &lhs, const QWaylandBufferRef &rhs)
 
    Returns \c false if \a lhs references the same buffer as \a rhs.
    Otherwise returns \c {true}.
 */
 
/*!
 * Returns true if this QWaylandBufferRef does not reference a buffer.
 * Otherwise returns false.
 *
 * \sa hasBuffer(), hasContent()
 */
bool QWaylandBufferRef::isNull() const
{
    return !d->buffer;
}
 
/*!
 * Returns true if this QWaylandBufferRef references a buffer. Otherwise returns false.
 *
 * \sa isNull(), hasContent()
 */
bool QWaylandBufferRef::hasBuffer() const
{
    return d->buffer;
}
/*!
 * Returns true if this QWaylandBufferRef references a buffer that has content. Otherwise returns false.
 *
 * \sa isNull(), hasBuffer()
 */
bool QWaylandBufferRef::hasContent() const
{
    return QtWayland::ClientBuffer::hasContent(d->buffer);
}
/*!
 * Returns true if this QWaylandBufferRef references a buffer that has protected content. Otherwise returns false.
 *
 * \note This is an enabler which presumes support in the client buffer integration. None of the
 *       client buffer integrations included with Qt currently support protected content buffers.
 *
 * \since 6.2
 * \sa hasContent()
 */
bool QWaylandBufferRef::hasProtectedContent() const
{
    return QtWayland::ClientBuffer::hasProtectedContent(d->buffer);
}
 
/*!
 * Returns true if this QWaylandBufferRef references a buffer that
 * has been destroyed. Otherwise returns false.
 */
bool QWaylandBufferRef::isDestroyed() const
{
    return d->buffer && d->buffer->isDestroyed();
}
 
/*!
 * Returns the Wayland resource for the buffer.
 */
struct ::wl_resource *QWaylandBufferRef::wl_buffer() const
{
    return d->buffer ? d->buffer->waylandBufferHandle() : nullptr;
}
 
/*!
 * \internal
 */
QtWayland::ClientBuffer *QWaylandBufferRef::buffer() const
{
    return d->buffer;
}
 
/*!
 * Returns the size of the buffer.
 * If the buffer referenced is null, an invalid QSize() is returned.
 */
QSize QWaylandBufferRef::size() const
{
    if (d->nullOrDestroyed())
        return QSize();
 
    return d->buffer->size();
}
 
/*!
 * Returns the origin of the buffer.
 * If the buffer referenced is null, QWaylandSurface::OriginBottomLeft
 * is returned.
 */
QWaylandSurface::Origin QWaylandBufferRef::origin() const
{
    if (d->buffer)
        return d->buffer->origin();
 
    return QWaylandSurface::OriginBottomLeft;
}
 
QWaylandBufferRef::BufferType QWaylandBufferRef::bufferType() const
{
    if (d->nullOrDestroyed())
        return BufferType_Null;
 
    if (isSharedMemory())
        return BufferType_SharedMemory;
 
    return BufferType_Egl;
}
 
QWaylandBufferRef::BufferFormatEgl QWaylandBufferRef::bufferFormatEgl() const
{
    if (d->nullOrDestroyed())
        return BufferFormatEgl_Null;
 
    return d->buffer->bufferFormatEgl();
}
 
/*!
 * Returns true if the buffer is a shared memory buffer. Otherwise returns false.
 */
bool QWaylandBufferRef::isSharedMemory() const
{
    if (d->nullOrDestroyed())
        return false;
 
    return d->buffer->isSharedMemory();
}
 
/*!
 * Returns an image with the contents of the buffer.
 */
QImage QWaylandBufferRef::image() const
{
    if (d->nullOrDestroyed())
        return QImage();
 
    return d->buffer->image();
}
 
#if QT_CONFIG(opengl)
/*!
 * Returns an OpenGL texture for the buffer. \a plane is the index for multi-plane formats, such as YUV.
 *
 * The returned texture is owned by the buffer. The texture is only valid for as
 * long as the buffer reference exists. The caller of this function must not delete the texture, and must
 * keep a reference to the buffer for as long as the texture is being used.
 *
 * Returns \c nullptr if there is no valid buffer, or if no texture can be created.
 */
QOpenGLTexture *QWaylandBufferRef::toOpenGLTexture(int plane) const
{
    if (d->nullOrDestroyed())
        return nullptr;
 
    return d->buffer->toOpenGlTexture(plane);
}
 
/*!
 * Returns the native handle for this buffer, and marks it as locked so it will not be
 * released until unlockNativeBuffer() is called.
 *
 * Returns 0 if there is no native handle for this buffer, or if the lock was unsuccessful.
 */
quintptr QWaylandBufferRef::lockNativeBuffer()
{
    return d->buffer->lockNativeBuffer();
}
 
/*!
 * Marks the native buffer as no longer in use. \a handle must correspond to the value returned by
 * a previous call to lockNativeBuffer().
 */
void QWaylandBufferRef::unlockNativeBuffer(quintptr handle)
{
    d->buffer->unlockNativeBuffer(handle);
}
 
#endif
 
QT_END_NAMESPACE